OTB-release-5.8/000077500000000000000000000000001301006202600134165ustar00rootroot00000000000000OTB-release-5.8/.gitignore000066400000000000000000000001051301006202600154020ustar00rootroot00000000000000syntax: glob *~ .*.swp *.orig *.pyc .\#* \#*\# tags *vim* *.template OTB-release-5.8/.hgignore000066400000000000000000000001051301006202600152150ustar00rootroot00000000000000syntax: glob *~ .*.swp *.orig *.pyc .\#* \#*\# tags *vim* *.template OTB-release-5.8/.hgsigs000066400000000000000000000006441301006202600147070ustar00rootroot0000000000000068eebc1b170a636794feda66523e6c0135ebfef2 0 iEYEABECAAYFAkmvX3cACgkQwRJnCg+r8KFSCgCfVYSnx2ev+hIlpbM/arxzLVf3KvsAn3nqaJXaj62RcNUIjv+qcNWlJ5WG e0fdaae06d33190d9b17356c5d51f878fd8fa0b6 0 iEYEABECAAYFAkoNOJEACgkQwRJnCg+r8KHMrACeJMcezNBgXjfx57UNdd/WfXw8kf8An1VEqFVTeG/wUd6QiiVy2icgfLGl c07af3906a803b43018e1a7e15db5c11f54d14b4 0 iEYEABECAAYFAkw68W0ACgkQwRJnCg+r8KGhjgCfR4LL9xW8xYGFXWEpbxSSRsCFVhIAn2nPMTqZvUW0cQvU6pkJD1+eENNj OTB-release-5.8/.travis.yml000066400000000000000000000003161301006202600155270ustar00rootroot00000000000000language: cpp sudo: false dist: trusty compiler: - clang addons: apt: packages: - libboost-all-dev cache: ccache branches: only: - nightly script: Utilities/Maintenance/TravisBuild.sh OTB-release-5.8/CMake/000077500000000000000000000000001301006202600143765ustar00rootroot00000000000000OTB-release-5.8/CMake/CPackFunctions.cmake000077500000000000000000000373671301006202600202750ustar00rootroot00000000000000 #RK: two packages. #function(create_cpack_config application) function(create_cpack_config) #should we handle this when calling function ? #for now mapla has no specific version or it is same as monteverdi SET(CPACK_PACKAGE_VERSION "${Monteverdi_VERSION_MAJOR}.${Monteverdi_VERSION_MINOR}.${Monteverdi_VERSION_PATCH}${Monteverdi_VERSION_SUFFIX}") SET(CPACK_PACKAGE_VERSION_MAJOR "${Monteverdi_VERSION_MAJOR}") SET(CPACK_PACKAGE_VERSION_MINOR "${Monteverdi_VERSION_MINOR}") SET(CPACK_PACKAGE_VERSION_PATCH "${Monteverdi_VERSION_PATCH}") #monteverdi short version string - eg: 3.0.0-beta SET(PACKAGE_SHORT_VERSION_STRING ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}${Monteverdi_VERSION_SUFFIX}) if(WIN32) set(arch_prefix win32) set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES") if(CMAKE_SIZEOF_VOID_P EQUAL 8) set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES64") set(arch_prefix win64) endif() SET(CPACK_GENERATOR "NSIS") SET(CPACK_NSIS_MODIFY_PATH OFF) SET(CPACK_NSIS_CONTACT "contact@orfeo-toolbox.org") #RK: two packages. #STRING(TOLOWER ${application} application_) #SET(EXEFILE_NAME "${application_}.exe") #SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\${EXEFILE_NAME}") #SET(BATFILE_NAME "${application_}.bat") #SET(CPACK_NSIS_MENU_LINKS "bin/${BATFILE_NAME}" "${application}" ) # SET(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS # "Delete \\\"$SMPROGRAMS\\\\${application}-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}\\\\${application}.lnk\\\" ") # SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS # "CreateShortCut \\\"$SMPROGRAMS\\\\${application}-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}\\\\${application}.lnk\\\" \\\"$INSTDIR\\\\bin\\\\${BATFILE_NAME}\\\" \\\" \\\" \\\"$INSTDIR\\\\bin\\\\${EXEFILE_NAME}\\\" # ") SET(application "Monteverdi") SET(startmenufolder "${application}-${PACKAGE_SHORT_VERSION_STRING}") #set(CPACK_NSIS_DEFINES " !define MUI_STARTMENUPAGE_DEFAULTFOLDER \\\"${startmenufolder} (${arch_prefix})\\\"") #SET(CPACK_PACKAGE_EXECUTABLES "monteverdi.bat" "Monteverdi") #SET(CPACK_CREATE_DESKTOP_LINKS "monteverdi.bat" ) SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\monteverdi.exe") SET(CPACK_PACKAGE_ICON "${Monteverdi_SOURCE_DIR}\\\\Data\\\\Icons\\\\monteverdi.ico") SET(CPACK_NSIS_CREATE_ICONS "CreateShortCut '$SMPROGRAMS\\\\${startmenufolder}\\\\Monteverdi.lnk' '$INSTDIR\\\\bin\\\\monteverdi.bat' ") SET(CPACK_NSIS_CREATE_ICONS_EXTRA "CreateShortCut '$SMPROGRAMS\\\\${startmenufolder}\\\\Mapla.lnk' '$INSTDIR\\\\bin\\\\mapla.bat' ") SET(CPACK_NSIS_MUI_FINISHPAGE_RUN "monteverdi.bat") SET(CPACK_NSIS_DELETE_ICONS "Delete \\\"$SMPROGRAMS\\\\${startmenufolder}\\\\Monteverdi.lnk\\\" ") SET(CPACK_NSIS_DELETE_ICONS_EXTRA "Delete \\\"$SMPROGRAMS\\\\${startmenufolder}\\\\Mapla.lnk\\\" ") else(APPLE) set(arch_prefix Darwin) if(CMAKE_SIZEOF_VOID_P EQUAL 8) set(arch_prefix Darwin64) endif() SET(CPACK_GENERATOR "Bundle") SET(CPACK_BUNDLE_ICON "${Monteverdi_SOURCE_DIR}/Packaging/MacOS/Monteverdi.icns" ) SET(CPACK_BUNDLE_NAME "${application}-${PACKAGE_SHORT_VERSION_STRING}" ) SET(CPACK_BUNDLE_PLIST "${CMAKE_BINARY_DIR}/Packaging/MacOS/${application}-Info.plist" ) SET(CPACK_BUNDLE_STARTUP_COMMAND "${Monteverdi_SOURCE_DIR}/Packaging/MacOS/${application}-StartupCommand" ) endif() #common cpack configurations. ################################## ################################## #CAUTION: Be careful when changing values below.# ################################## ################################## SET(CPACK_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") SET(CPACK_MODULE_PATH "${Monteverdi_SOURCE_DIR}/CMake") SET(CPACK_NSIS_INSTALLER_ICON_CODE "") SET(CPACK_NSIS_INSTALLER_MUI_ICON_CODE "") SET(CPACK_PACKAGE_CONTACT "contact@orfeo-toolbox.org") SET(CPACK_PACKAGE_DEFAULT_LOCATION "/") SET(CPACK_PACKAGE_DESCRIPTION_FILE "${Monteverdi_SOURCE_DIR}/Description.txt") SET(CPACK_RESOURCE_FILE_LICENSE "${Monteverdi_SOURCE_DIR}/Copyright/Copyright.txt") SET(CPACK_OUTPUT_CONFIG_FILE "${CMAKE_BINARY_DIR}/CPackConfig-${application}.cmake") SET(CPACK_NSIS_MUI_ICON "${Monteverdi_SOURCE_DIR}/Data/Icons/monteverdi.ico") SET(CPACK_NSIS_MUI_UNIICON "${Monteverdi_SOURCE_DIR}/Data/Icons/monteverdi.ico") SET(CPACK_COMPONENTS_ALL) LIST(APPEND CPACK_COMPONENTS_ALL "Resources") LIST(APPEND CPACK_COMPONENTS_ALL "Runtime") #RK: two packages #LIST(APPEND CPACK_COMPONENTS_ALL "${application}") LIST(APPEND CPACK_COMPONENTS_ALL "Monteverdi") LIST(APPEND CPACK_COMPONENTS_ALL "Mapla") SET(CPACK_COMPONENT_MAPLA_DEPENDS Runtime) SET(CPACK_COMPONENT_MONTEVERDI_DEPENDS Runtime) SET(CPACK_COMPONENT_RUNTIME_DEPENDS Resources) SET(CPACK_COMPONENT_RUNTIME_REQUIRED ON) SET(CPACK_COMPONENT_RESOURCES_REQUIRED ON) SET(CPACK_COMPONENT_MAPLA_REQUIRED ON) SET(CPACK_COMPONENT_MONTEVERDI_REQUIRED ON) SET(CPACK_COMPONENT_RESOURCES_HIDDEN ON) if(APPLE) SET(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR};${application};ALL;/") else(WIN32) SET(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR};ALL;ALL;/") endif() SET(CPACK_PACKAGE_VENDOR "OTB Team") SET(CPACK_PACKAGE_NAME "${application}") SET(CPACK_NSIS_DISPLAY_NAME "${application}-${PACKAGE_SHORT_VERSION_STRING}") SET(CPACK_NSIS_PACKAGE_NAME "${application}-${PACKAGE_SHORT_VERSION_STRING}") SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${application}-${PACKAGE_SHORT_VERSION_STRING}") SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${application}-${PACKAGE_SHORT_VERSION_STRING}") SET(CPACK_PACKAGE_FILE_NAME "${application}-${CPACK_PACKAGE_VERSION}-${arch_prefix}") INCLUDE(InstallRequiredSystemLibraries) INCLUDE(CPack) endfunction(create_cpack_config) function(configure_app_package app with_otb_apps) string(TOLOWER ${app} EXECUTABLE_NAME) set(APP_QTCONF_DIR bin) set(APP_QTSQLITE_FILENAME qsqlite4.dll) set(APP_QTPLUGINS_DIR lib/qt4/plugins) set(APP_OTBLIBS_DIR lib/otb) set(APP_I18N_DIR lib/qt4/translations) set(APP_DATA_DIR share) set(APP_NAME "\${CMAKE_INSTALL_PREFIX}/bin/${EXECUTABLE_NAME}.exe") install(CODE "file(WRITE \"\${CMAKE_INSTALL_PREFIX}/${APP_QTCONF_DIR}/qt.conf\" \"[Paths] Translations=../lib/qt4/translations Plugins=../lib/qt4/plugins \")" COMPONENT Runtime) install(FILES ${Monteverdi_SOURCE_DIR}/Packaging/Windows/${EXECUTABLE_NAME}.bat DESTINATION bin COMPONENT ${app}) if(WIN32) if(NOT CMAKE_CROSSCOMPILING AND Monteverdi_USE_CPACK) file(TO_CMAKE_PATH "$ENV{OSGEO4W_ROOT}" OSGEO4W_ROOT) if(NOT OSGEO4W_ROOT) message(FATAL_ERROR "Cannot generate installer without OSGeo4W environment : OSGEO4W_ROOT") endif(NOT OSGEO4W_ROOT) # The following DLL handling is very specific # both to OSGeo4W flavour (32 bit or 64 bit), OSGeo4W package state # and the compiler used to make the Monteverdi installer (VC2010) # Don't expect too much of it without VC2010. # For some reason, fixup_bundle won't package the msvc runtime dll # I guess it's because cpack already handles installing the runtime, # but here we build with a particular version of Visual, but # some OSGeo4W dependencies are built upon other runtimes set(MVD2_ADDITIONAL_DLLS ${OSGEO4W_ROOT}/bin/msvcp60.dll ${OSGEO4W_ROOT}/bin/msvcp70.dll ${OSGEO4W_ROOT}/bin/msvcp71.dll ${OSGEO4W_ROOT}/bin/msvcr71.dll ${OSGEO4W_ROOT}/bin/msvcrt.dll) # Since an upgrade in OSGeo4W-32bit of libpq (around 2013/10) # libpq depends on two additional libs that cmake # surprisingly miss during package generation # I really don't understand why. # Let's add them manually set(MVD2_ADDITIONAL_DLLS ${MVD2_ADDITIONAL_DLLS} ${OSGEO4W_ROOT}/bin/libgcc_s_dw2-1.dll ${OSGEO4W_ROOT}/bin/libiconv-2.dll) foreach(dll ${MVD2_ADDITIONAL_DLLS}) if (EXISTS ${dll}) install( FILES ${dll} DESTINATION bin COMPONENT Runtime ) endif() endforeach() #RK: two packages # set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${app}") # create_cpack_config(${app}) endif() #(NOT CMAKE_CROSSCOMPILING AND Monteverdi_USE_CPACK) # if(CMAKE_CROSSCOMPILING) # if(NOT DEFINED MXE_TARGET_DIR) # message(FATAL_ERROR "MXE_TARGET_DIR is missing") # endif() # if(MXE_TARGET_DIR MATCHES "i686") # set(mxearch x86) # set(archive_name ${app}-${Monteverdi_VERSION_STRING}-win32) # elseif(MXE_TARGET_DIR MATCHES "x86_64") # set(mxearch x64) # set(archive_name ${app}-${Monteverdi_VERSION_STRING}-win64) # endif() # execute_process(COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_INSTALL_PREFIX}/${archive_name}") # get_filename_component(mxeroot ${MXE_TARGET_DIR} PATH) # get_filename_component(mxeroot ${mxeroot} PATH) # file(WRITE "${CMAKE_BINARY_DIR}/_mingw/${app}/CMakeLists.txt" # "cmake_minimum_required(VERSION 2.6) # include(CMakeParseArguments) # set(Monteverdi_SOURCE_DIR \"${Monteverdi_SOURCE_DIR}\") # set(OTB_MODULES_DIR \"${OTB_MODULES_DIR}\") # set(QT_PLUGINS_DIR \"${QT_PLUGINS_DIR}\") # set(QT_TRANSLATIONS_DIR \"${QT_TRANSLATIONS_DIR}\") # set(Monteverdi_BINARY_DIR \"${CMAKE_BINARY_DIR}\") # set(CMAKE_INSTALL_PREFIX \"${CMAKE_INSTALL_PREFIX}\") # set(Monteverdi_INSTALL_DATA_DIR \"${Monteverdi_INSTALL_DATA_DIR}\") # include(${CMAKE_SOURCE_DIR}/CMake/MinGWPackage.cmake) # include(${CMAKE_SOURCE_DIR}/CMake/CPackFunctions.cmake) # package_mingw( # ARCH \"${mxearch}\" # MXEROOT \"${mxeroot}\" # PREFIX_DIR \"${archive_name}\" # PEFILES \"${APP_NAME}\" # NEEDS_OTB_APPS ${with_otb_apps} # SEARCHDIRS \"\")") # set(GDAL_DATA ${MXE_TARGET_DIR}/share/gdal) # add_custom_target(configure-${app}-mingw-package # COMMAND ${CMAKE_COMMAND} # "${CMAKE_BINARY_DIR}/_mingw/${app}" # WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/_mingw/${app}") # add_custom_target(make-${app}-mingw-package # COMMAND ${CMAKE_COMMAND} # "--build" "${CMAKE_BINARY_DIR}/_mingw/${app}" "--target" "install" # WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/_mingw/${app}" # DEPENDS configure-${app}-mingw-package) # find_program(ZIP_EXECUTABLE zip) # if(ZIP_EXECUTABLE) # add_custom_target(create-${app}-mingw-archive # COMMAND ${ZIP_EXECUTABLE} "-r" "${CMAKE_BINARY_DIR}/${archive_name}.zip" "${archive_name}" # WORKING_DIRECTORY "${CMAKE_INSTALL_PREFIX}" # DEPENDS make-${app}-mingw-package) # else() # message(FATAL_ERROR "Cannot find zip executable. Please add it to your path") # endif() # endif() # (CMAKE_CROSSCOMPILING) endif(WIN32) if(APPLE) set(APP_NAME "\${CMAKE_INSTALL_PREFIX}/${app}.app") set(APP_PREFIX_DIR ${app}.app/Contents) #osx prefix set(APP_QTCONF_DIR ${APP_PREFIX_DIR}/Resources) set(APP_QTSQLITE_FILENAME libqsqlite.dylib) set(APP_QTPLUGINS_DIR ${APP_PREFIX_DIR}/plugins) set(APP_OTBLIBS_DIR ${APP_PREFIX_DIR}/MacOS/otb) set(APP_I18N_DIR ${APP_PREFIX_DIR}/Resources/otb/translations) #translations set(APP_DATA_DIR ${APP_PREFIX_DIR}/Resources) install(FILES ${CMAKE_SOURCE_DIR}/Packaging/MacOS/Monteverdi.icns DESTINATION ${APP_PREFIX_DIR}/Resources COMPONENT Resources) install(FILES ${CMAKE_BINARY_DIR}/Code/Application/${app}/${EXECUTABLE_NAME}_start DESTINATION ${APP_PREFIX_DIR}/MacOS PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_EXECUTE COMPONENT Runtime) install(CODE "file(WRITE \"\${CMAKE_INSTALL_PREFIX}/${APP_QTCONF_DIR}/qt.conf\" \"[Paths] Translations=Resources/otb/translations Plugins=plugins \")" COMPONENT Runtime) file(GLOB APP_QM_TRANSLATIONS /*.qm) # qm files file(GLOB APP_TS_FILES ${CMAKE_SOURCE_DIR}/i18n/*.ts) # qm files foreach(APP_TS_FILE ${APP_TS_FILES}) get_filename_component(APP_TS_FILENAME ${APP_TS_FILE} NAME_WE) install(FILES ${CMAKE_BINARY_DIR}/i18n/${APP_TS_FILENAME}.qm DESTINATION ${APP_PREFIX_DIR}/${Monteverdi_INSTALL_DATA_DIR}/i18n/ COMPONENT Resources) endforeach() set(CPACK_BINARY_DRAGNDROP ON) endif(APPLE) # ################################################################################ # ################################################################################ # ################### END OF PLATFORM SPECIFIC CMAKE VARIABLES ################### # ################################################################################ # ################################################################################ # ####################### install sqldrivers plugin ####################### # install(FILES ${QT_PLUGINS_DIR}/sqldrivers/${APP_QTSQLITE_FILENAME} # DESTINATION ${APP_QTPLUGINS_DIR}/sqldrivers # COMPONENT Runtime) # ####################### install translations ####################### # get_qt_translation_files(QT_TRANSLATIONS_FILES) # install(FILES ${QT_TRANSLATIONS_FILES} # DESTINATION ${APP_I18N_DIR} # COMPONENT Resources) # ####################### install GDAL data ####################### # if(NOT DEFINED GDAL_DATA) # file(TO_CMAKE_PATH "$ENV{GDAL_DATA}" GDAL_DATA) # if(NOT GDAL_DATA) # if(Monteverdi_USE_CPACK) # message(FATAL_ERROR "Cannot generate installer without GDAL_DATA : GDAL_DATA") # else() # message(WARNING "Cannot generate installer without GDAL_DATA : GDAL_DATA") # endif() # endif() # endif() #(DEFINED GDAL_DATA) # # Need to include csv files provided with GDAL that contains some needed EPSG definitions # install(DIRECTORY ${GDAL_DATA} # DESTINATION ${APP_DATA_DIR} # COMPONENT Resources) # ####################### Check otb applications ####################### # if(with_otb_apps) # # message(FATAL_ERROR "No OTB-applications detected") # file(GLOB OTB_APPS_LIST ${OTB_MODULES_DIR}/../../../otb/applications/otbapp_*${CMAKE_SHARED_LIBRARY_SUFFIX}) # /lib/otb # if(NOT OTB_APPS_LIST) # message(FATAL_ERROR "No OTB-applications detected") # endif() # ## otb apps dir /lib/otb/applications # install(DIRECTORY "${OTB_MODULES_DIR}/../../../otb/applications" # DESTINATION ${APP_OTBLIBS_DIR} # COMPONENT Runtime) # endif(with_otb_apps) # ## directories to look for dependencies # set(SEARCH_DIRS) # list(APPEND SEARCH_DIRS "${QT_PLUGINS_DIR}/sqldrivers") # list(APPEND SEARCH_DIRS "${ITK_MODULES_DIR}/../../../") # list(APPEND SEARCH_DIRS "${OTB_MODULES_DIR}/../../../") # list(APPEND SEARCH_DIRS "${CMAKE_INSTALL_PREFIX}/lib/otb/") # ####################### install fixup_bundle code ####################### # ## fixup_bundle code # if(NOT CMAKE_CROSSCOMPILING) # if(with_otb_apps) # install(CODE # "file(GLOB APP_LIBS \"${CMAKE_INSTALL_PREFIX}/${APP_OTBLIBS_DIR}/applications/otbapp_*${CMAKE_SHARED_LIBRARY_SUFFIX}\") # list(APPEND APP_LIBS \"${CMAKE_INSTALL_PREFIX}/${APP_QTPLUGINS_DIR}/sqldrivers/${APP_QTSQLITE_FILENAME}\") # include(BundleUtilities) # set(BU_CHMOD_BUNDLE_ITEMS ON) # fixup_bundle(\"${APP_NAME}\" \"\${APP_LIBS}\" \"${SEARCH_DIRS}\")" # COMPONENT ${app}) # else() #(with_otb_apps) # install(CODE # "file(GLOB APP_LIBS \"${CMAKE_INSTALL_PREFIX}/${APP_QTPLUGINS_DIR}/sqldrivers/${APP_QTSQLITE_FILENAME}\") # include(BundleUtilities) # set(BU_CHMOD_BUNDLE_ITEMS ON) # fixup_bundle(\"${APP_NAME}\" \"\${APP_LIBS}\" \"${SEARCH_DIRS}\")" # COMPONENT ${app}) # endif() #(with_otb_apps) # endif() #(NOT CMAKE_CROSSCOMPILING) endfunction(configure_app_package) OTB-release-5.8/CMake/CTestCustom.cmake.in000066400000000000000000000056261301006202600202330ustar00rootroot00000000000000# # Note that the OTB/CMakeLists.txt file configures this file # # CMake/CTestCustom.cmake.in # # to this file # # ${OTB_BINARY_DIR}/CTestCustom.cmake # #---------------------------------------------------------------------- # # For further details regarding this file, # see http://www.cmake.org/Wiki/CMake_Testing_With_CTest#Customizing_CTest # # and # http://www.kitware.com/blog/home/post/27 # #---------------------------------------------------------------------- set(CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE 1000000) set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS 300) set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS 50) set(CTEST_CUSTOM_COVERAGE_EXCLUDE ${CTEST_CUSTOM_COVERAGE_EXCLUDE} # Exclude try_compile sources from coverage results: "/CMakeFiles/CMakeTmp/" # Exclude files from the Examples directories #".*/Examples/.*" # Exclude files from the Testing directories ".*/test/.*" ".*/Testing/.*" # Exclude files from the ThirdParty Utilities directories ".*/Modules/ThirdParty/.*" ".*/Utilities/.*" # Exclude SWIG wrappers files ".*/Modules/Wrappers/SWIG/src/otbApplicationPYTHON_wrap.*" ".*/Modules/Wrappers/SWIG/src/otbApplicationJAVA_wrap.*" # Exclude Qt moc file ".*moc_.*" ) set(CTEST_CUSTOM_WARNING_EXCEPTION ${CTEST_CUSTOM_WARNING_EXCEPTION} "backward_warning" "warning LNK4221" "ranlib:.*file:.*has no symbols" "ranlib: file: .+ has no symbols" "ranlib:.*warning for library:.*the table of contents is empty.*no object file members in the library define global symbols.*" "libtool:.*file:.*has no symbols" "warning -.: directory name .* does not exist" "ld.*warning.*duplicate dylib.*" "WARNING non-zero return value in ctest" ".*Microsoft.*include.*.h.*[Ww]arning.*" ".*gdal_priv.h.*[Ww]arning.*" ".*cpl_string.h.*[Ww]arning.*" ".*ogr_feature.h.*[Ww]arning.*" # Ignore clang's summary warning, assuming prior text has matched some # other warning expression: "[0-9,]+ warnings? generated." ".*include.opencv2.*warning.*" ".*include.opencv2.*note.*" ".*include.kml.*warning.*" ".*include.ogr_feature.*warning.*" ".*include.ogr_feature.*note.*" ".*itksys.SharedForward.h.*warning.*" ".*vcl_deprecated_header.h.*" ".*otbCurlHelper.cxx:.*warning.*maxConnect.*" ".*include.ITK-4.*warning.*" ".*include.curl.curl.h.*warning.*" ".*include.ossim.*warning.*" ".*include.ossim.*note.*" ".*include.ogr_core.h.*warning.*" ".*include.ogr_srs_api.h.*warning.*" ".*include.ogrsf_frmts.h.*warning.*" ".*include.ogr_geometry.h.*warning.*" ".*include.ogr_spatialref.h.*warning.*" ".*include.cpl_error.h.*warning.*" ".*vnl.vnl_numeric_traits.h.*warning.*" ".*vcl_config_compiler.h.*warning.*" ".*boost.move.unique_ptr.hpp:.*" ".*include.mpValue.h.*[Ww]arning.*\\[-Wc\\+\\+11-extensions\\]" ".*itksys.SharedForward.h.*warning.*itksys_shared_forward_to_real.*" ".*include.mpi_portable_platform.h.*warning.*invalid.suffix.on.literal.*" ) OTB-release-5.8/CMake/CppcheckTargets.cmake000066400000000000000000000253721301006202600204630ustar00rootroot00000000000000# - Run cppcheck on c++ source files as a custom target and a test # # include(CppcheckTargets) # add_cppcheck( [UNUSED_FUNCTIONS] [STYLE] [POSSIBLE_ERROR] [FAIL_ON_WARNINGS]) - # Create a target to check a target's sources with cppcheck and the indicated options # add_cppcheck_sources( [UNUSED_FUNCTIONS] [STYLE] [POSSIBLE_ERROR] [FAIL_ON_WARNINGS]) - # Create a target to check standalone sources with cppcheck and the indicated options # # Requires these CMake modules: # Findcppcheck # # Requires CMake 2.6 or newer (uses the 'function' command) # # # Original Author: # 2009-2010 Ryan Pavlik # http://academic.cleardefinition.com # Iowa State University HCI Graduate Program/VRAC # # Addition: # 2011 Arnaud Gelas # Harvard Medical School # # Copyright Iowa State University 2009-2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) if(__add_cppcheck) return() endif() set(__add_cppcheck YES) if(NOT CPPCHECK_FOUND) find_package(cppcheck QUIET) endif() if(CPPCHECK_FOUND) if(NOT TARGET all_cppcheck) add_custom_target(all_cppcheck) set_target_properties(all_cppcheck PROPERTIES EXCLUDE_FROM_ALL TRUE) endif() endif() # ------------------------------------------------------------------------------ macro( get_cppcheck_arg ) list(FIND _input FORCE _force) if("${_force}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_FORCE_ARG}) list(REMOVE_AT _input ${_force}) endif() list(FIND _input VERBOSE _verbose) if("${_verbose}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_VERBOSE_ARG}) list(REMOVE_AT _input ${_verbose}) endif() list(FIND _input QUIET _quiet) if("${_quiet}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_QUIET_ARG}) list(REMOVE_AT _input ${_quiet}) endif() list(FIND _input ALL _all) if("${_all}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_ALL_ARG}) list(REMOVE_AT _input ${_all}) endif() list(FIND _input UNUSED_FUNCTIONS _unused_func) if("${_unused_func}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_UNUSEDFUNC_ARG}) list(REMOVE_AT _input ${_unused_func}) endif() list(FIND _input STYLE _style) if("${_style}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_STYLE_ARG}) list(REMOVE_AT _input ${_style}) endif() list(FIND _input INFORMATION _information) if("${_information}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_INFORMATION_ARG}) list(REMOVE_AT _input ${_information}) endif() list(FIND _input MISSING_INCLUDE _missing_include) if("${_missing_include}" GREATER "-1") list(APPEND _cppcheck_args ${CPPCHECK_MISSING_INCLUDE_ARG}) list(REMOVE_AT _input ${_missing_include}) endif() list(FIND _input FAIL_ON_WARNINGS _fail_on_warn) if("${_fail_on_warn}" GREATER "-1") list(APPEND _cppcheck_args CPPCHECK_FAIL_REGULAR_EXPRESSION ${CPPCHECK_WARN_REGULAR_EXPRESSION}) list(REMOVE_AT _input ${_fail_on_warn}) endif() endmacro() # ------------------------------------------------------------------------------ # add_cppcheck_dir function(add_cppcheck_dir _name _dir _include_dirs) if(CPPCHECK_FOUND) set(_cppcheck_args ) set(_input ${ARGN}) get_cppcheck_arg( ${_input} ) # -------------------------------------------------------------- foreach( _includeDirs ${_include_dirs} ) set( _cppcheck_include ${_cppcheck_include} -I${_includeDirs} ) endforeach() set( _cppcheck_compile_args ${_cppcheck_include} ) if("${CMAKE_VERSION}" VERSION_LESS "2.8.0") # Older than CMake 2.8.0 itk_add_test(${_name}_cppcheck_test "${CPPCHECK_EXECUTABLE}" ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_dir} ) else() # CMake 2.8.0 and newer itk_add_test( NAME ${_name}_cppcheck_test COMMAND "${CPPCHECK_EXECUTABLE}" ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_dir} ) endif() set_tests_properties(${_name}_cppcheck_test PROPERTIES FAIL_REGULAR_EXPRESSION "${CPPCHECK_FAIL_REGULAR_EXPRESSION}") add_custom_command(TARGET all_cppcheck PRE_BUILD COMMAND ${CPPCHECK_EXECUTABLE} ${CPPCHECK_QUIET_ARG} ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_dir} WORKING_DIRECTORY "${_dir}" COMMENT "${_name}_cppcheck: Running cppcheck on ${_dir}..." VERBATIM) endif() endfunction() # ------------------------------------------------------------------------------ # add_cppcheck_sources function(add_cppcheck_sources _targetname) if(CPPCHECK_FOUND) # Normally --force should not be required, but since all compiler definitions # can't be detected, it is better to enforce testing all possibilities set(_cppcheck_args ) set(_input ${ARGN}) get_cppcheck_arg( "${_input}" ) set(_files) foreach(_source ${_input}) get_source_file_property(_cppcheck_loc "${_source}" LOCATION) if(_cppcheck_loc) # This file has a source file property, carry on. get_source_file_property(_cppcheck_lang "${_source}" LANGUAGE) if("${_cppcheck_lang}" MATCHES "CXX") list(APPEND _files "${_cppcheck_loc}") endif() else() # This file doesn't have source file properties - figure it out. get_filename_component(_cppcheck_loc "${_source}" ABSOLUTE) if(EXISTS "${_cppcheck_loc}") list(APPEND _files "${_cppcheck_loc}") else() message(FATAL_ERROR "Adding CPPCHECK for file target ${_targetname}: " "File ${_source} does not exist or needs a corrected path location " "since we think its absolute path is ${_cppcheck_loc}") endif() endif() endforeach() # let's take of include dirs here get_property( mytargINCLUDES DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" PROPERTY INCLUDE_DIRECTORIES) set( _cppcheck_include ) foreach( _includeDirs ${mytargINCLUDES} ) set( _cppcheck_include ${_cppcheck_include} -I${_includeDirs} ) endforeach() # -------------------------------------------------------------- # let's take of compile definitions here # NOTE: it does not work, you need to get all definitions by # another way get_property(mytargDEFINITIONS DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" PROPERTY COMPILE_DEFINITIONS) set( _cppcheck_def ) foreach( _compiledef ${mytargDEFINITIONS} ) set( _cppcheck_def ${_cppcheck_def} -D${_compiledef} ) endforeach() # -------------------------------------------------------------- set( _cppcheck_compile_args ${_cppcheck_include} ${_cppcheck_def} ) if("${CMAKE_VERSION}" VERSION_LESS "2.8.0") # Older than CMake 2.8.0 itk_add_test(${_targetname}_cppcheck_test "${CPPCHECK_EXECUTABLE}" ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_files}) else() # CMake 2.8.0 and newer itk_add_test( NAME ${_targetname}_cppcheck_test COMMAND "${CPPCHECK_EXECUTABLE}" ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_files}) endif() set_tests_properties(${_targetname}_cppcheck_test PROPERTIES FAIL_REGULAR_EXPRESSION "${CPPCHECK_FAIL_REGULAR_EXPRESSION}") add_custom_command(TARGET all_cppcheck PRE_BUILD COMMAND ${CPPCHECK_EXECUTABLE} ${CPPCHECK_QUIET_ARG} ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_files} WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" COMMENT "${_targetname}_cppcheck: Running cppcheck on target ${_targetname}..." VERBATIM) endif() endfunction() # ------------------------------------------------------------------------------ # add_cppcheck function(add_cppcheck _name) if(NOT TARGET ${_name}) message(FATAL_ERROR "add_cppcheck given a target name that does not exist: '${_name}' !") endif() if(CPPCHECK_FOUND) set(_cppcheck_args ) set(_input ${ARGN}) get_cppcheck_arg( ${_input} ) get_target_property(_cppcheck_sources "${_name}" SOURCES) set(_files) foreach(_source ${_cppcheck_sources}) get_source_file_property(_cppcheck_lang "${_source}" LANGUAGE) get_source_file_property(_cppcheck_loc "${_source}" LOCATION) if("${_cppcheck_lang}" MATCHES "CXX") list(APPEND _files "${_cppcheck_loc}") endif() endforeach() # let's take of include dirs here get_property( mytargINCLUDES DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" PROPERTY INCLUDE_DIRECTORIES) set( _cppcheck_include ) foreach( _includeDirs ${mytargINCLUDES} ) set( _cppcheck_include "${_cppcheck_include} -I ${_includeDirs}" ) endforeach() # -------------------------------------------------------------- # let's take of compile definitions here get_property(mytargDEFINITIONS DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" PROPERTY COMPILE_DEFINITIONS ) set( _cppcheck_def ) foreach( _compiledef ${mytargDEFINITIONS} ) set( _cppcheck_def ${_cppcheck_def} -D${_compiledef} ) endforeach() # -------------------------------------------------------------- set( _cppcheck_compile_args --check-config ${_cppcheck_include} ${_cppcheck_def} ) if("${CMAKE_VERSION}" VERSION_LESS "2.8.0") # Older than CMake 2.8.0 itk_add_test(${_name}_cppcheck_test "${CPPCHECK_EXECUTABLE}" ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_files}) else() # CMake 2.8.0 and newer itk_add_test( NAME ${_name}_cppcheck_test COMMAND "${CPPCHECK_EXECUTABLE}" ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_cppcheck_compile_args} ${_files}) endif() set_tests_properties(${_name}_cppcheck_test PROPERTIES FAIL_REGULAR_EXPRESSION "${CPPCHECK_FAIL_REGULAR_EXPRESSION}") add_custom_command(TARGET all_cppcheck PRE_BUILD COMMAND ${CPPCHECK_EXECUTABLE} ${CPPCHECK_QUIET_ARG} ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_files} WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" COMMENT "${_name}_cppcheck: Running cppcheck on target ${_name}..." VERBATIM) endif() endfunction() OTB-release-5.8/CMake/DeployQtConf.cmake000066400000000000000000000011661301006202600177530ustar00rootroot00000000000000# Deploy a qt.conf file in the specified # target build directory, as a pre-build step macro( deploy_qt_conf TARGET_NAME ) add_custom_command( TARGET ${TARGET_NAME} PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS -D QT_TRANSLATIONS_DIR:PATH=${QT_TRANSLATIONS_DIR} -D QT_PLUGINS_DIR:PATH=${QT_PLUGINS_DIR} -D Monteverdi_SOURCE_DIR:PATH=${Monteverdi_SOURCE_DIR} -D TARGET_DIR:PATH=$ -P ${Monteverdi_SOURCE_DIR}/CMake/DeployQtConfScript.cmake COMMENT "Deploying qt.conf in ${TARGET_NAME} build dir" VERBATIM ) endmacro() OTB-release-5.8/CMake/DeployQtConfScript.cmake000066400000000000000000000001631301006202600211340ustar00rootroot00000000000000configure_file(${Monteverdi_SOURCE_DIR}/CMake/qt.conf.in ${TARGET_DIR}/qt.conf @ONLY)OTB-release-5.8/CMake/Description.txt000066400000000000000000000014721301006202600174260ustar00rootroot00000000000000Remote sensing processing library developed by CNES ORFEO Toolbox (OTB) is distributed as an open source library of image processing algorithms. OTB is based on the medical image processing library ITK and offers particular functionalities for remote sensing image processing in general and for high spatial resolution images in particular. OTB is distributed under a free software licence CeCILL (similar to GPL) to encourage contribution from users and to promote reproducible research. The library is intensively tested on several platforms as Linux, Unix and Windows. Most functionnalies are also adapted to process huge images using streaming and multithreading as often as possible. . This package provide the new version of the Monteverdi GUI application developed in Qt around the OTB library. OTB-release-5.8/CMake/FindAgg.cmake000066400000000000000000000012601301006202600166760ustar00rootroot00000000000000# Find the AntiGrain Geometry graphical toolkit header files # # AGG_FOUND - True if AGG found. # AGG_INCLUDE_DIRS - where to find agg_pixfmt_rgba.h, etc. # if( AGG_INCLUDE_DIR ) # Already in cache, be silent set( AGG_FIND_QUIETLY TRUE ) endif() find_path( AGG_INCLUDE_DIR agg_pixfmt_rgba.h PATH_SUFFIXES agg2 ) # handle the QUIETLY and REQUIRED arguments and set AGG_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( Agg DEFAULT_MSG AGG_INCLUDE_DIR ) mark_as_advanced( AGG_INCLUDE_DIR ) if(AGG_FOUND) set(AGG_INCLUDE_DIRS ${AGG_INCLUDE_DIR}) else() set(AGG_INCLUDE_DIRS) endif() OTB-release-5.8/CMake/FindGBenchmark.cmake000066400000000000000000000016741301006202600202120ustar00rootroot00000000000000# Find the Google Benchmark library # Defines: # GBENCHMARK_INCLUDE_DIR - gbenchmark include directory # GBENCHMARK_LIBRARY - gbenchmark library file # GBENCHMARK_FOUND - TRUE if gbenchmark is found if (GBENCHMARK_INCLUDE_DIR) #check cache set(GBENCHMARK_FIND_QUIETLY TRUE) endif () if (NOT GBENCHMARK_INCLUDE_DIR) find_path(GBENCHMARK_INCLUDE_DIR NAMES benchmark.h PATH_SUFFIXES benchmark) set(GBENCHMARK_INCLUDE_DIR ${GBENCHMARK_INCLUDE_DIR}/benchmark CACHE PATH "Google.benchmark include directory") endif () mark_as_advanced(GBENCHMARK_INCLUDE_DIR) find_library(GBENCHMARK_LIBRARY NAMES benchmark) mark_as_advanced(GBENCHMARK_LIBRARY) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(GBENCHMARK REQUIRED_VARS GBENCHMARK_LIBRARY GBENCHMARK_INCLUDE_DIR ) #VERSION_VAR GBENCHMARK_VERSION_STRING set(GBENCHMARK_LIBRARIES ${GBENCHMARK_LIBRARY}) set(GBENCHMARK_INCLUDE_DIRS ${GBENCHMARK_INCLUDE_DIR}) OTB-release-5.8/CMake/FindGLEW.cmake000066400000000000000000000025531301006202600167440ustar00rootroot00000000000000# Courtesy of: https://raw.github.com/progschj/OpenGL-Examples/ # # Try to find GLEW library and include path. # Once done this will define # # GLEW_FOUND # GLEW_INCLUDE_PATH # GLEW_LIBRARY # IF (WIN32) FIND_PATH( GLEW_INCLUDE_DIR GL/glew.h $ENV{PROGRAMFILES}/GLEW/include ${GLEW_ROOT_DIR}/include DOC "The directory where GL/glew.h resides") FIND_LIBRARY( GLEW_LIBRARY NAMES glew GLEW glew32 glew32s PATHS $ENV{PROGRAMFILES}/GLEW/lib ${GLEW_ROOT_DIR}/lib ${PROJECT_SOURCE_DIR}/src/nvgl/glew/bin ${PROJECT_SOURCE_DIR}/src/nvgl/glew/lib DOC "The GLEW library") ELSE (WIN32) FIND_PATH( GLEW_INCLUDE_DIR GL/glew.h /usr/include /usr/local/include /sw/include /opt/local/include ${GLEW_ROOT_DIR}/include DOC "The directory where GL/glew.h resides") # Prefer the static library. FIND_LIBRARY( GLEW_LIBRARY NAMES libGLEW.so GLEW PATHS /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib /sw/lib /opt/local/lib ${GLEW_ROOT_DIR}/lib DOC "The GLEW library") ENDIF (WIN32) SET(GLEW_FOUND "NO") IF (GLEW_INCLUDE_DIR AND GLEW_LIBRARY) SET(GLEW_LIBRARIES ${GLEW_LIBRARY}) SET(GLEW_FOUND "YES") ENDIF () INCLUDE(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake) FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLEW REQUIRED_VARS GLEW_LIBRARY GLEW_INCLUDE_DIR VERSION_VAR GLEW_VERSION_STRING) OTB-release-5.8/CMake/FindGLFW.cmake000066400000000000000000000047151301006202600167470ustar00rootroot00000000000000# Locate the glfw library # This module defines the following variables: # GLFW_LIBRARY, the name of the library; # GLFW_INCLUDE_DIR, where to find glfw include files. # GLFW_FOUND, true if both the GLFW_LIBRARY and GLFW_INCLUDE_DIR have been found. # # To help locate the library and include file, you could define an environment variable called # GLFW_ROOT which points to the root of the glfw library installation. This is pretty useful # on a Windows platform. # # # Usage example to compile an "executable" target to the glfw library: # # FIND_PACKAGE (glfw REQUIRED) # INCLUDE_DIRECTORIES (${GLFW_INCLUDE_DIR}) # ADD_EXECUTABLE (executable ${EXECUTABLE_SRCS}) # TARGET_LINK_LIBRARIES (executable ${GLFW_LIBRARY}) # # TODO: # Allow the user to select to link to a shared library or to a static library. #Search for the include file... FIND_PATH(GLFW_INCLUDE_DIR GLFW/glfw3.h DOC "Path to GLFW include directory." HINTS $ENV{GLFW_ROOT} PATH_SUFFIX include # For finding the include file under the root of the glfw expanded archive, typically on Windows. ) FIND_LIBRARY(GLFW_LIBRARY DOC "Absolute path to GLFW library." NAMES glfw glfw3dll glfw3 HINTS $ENV{GLFW_ROOT} PATH_SUFFIXES lib # For finding the library file under the root of the glfw expanded archive, typically on Windows. ) IF(GLFW_INCLUDE_DIR AND EXISTS "${GLFW_INCLUDE_DIR}/GLFW/glfw3.h") FILE(STRINGS "${GLFW_INCLUDE_DIR}/GLFW/glfw3.h" glfw_version_str REGEX "^#[\t ]*define[\t ]+GLFW_VERSION_(MAJOR|MINOR|REVISION)[\t ]+[0-9]+$") UNSET(GLFW_VERSION_STRING) FOREACH(VPART MAJOR MINOR REVISION) FOREACH(VLINE ${glfw_version_str}) IF(VLINE MATCHES "^#[\t ]*define[\t ]+GLFW_VERSION_${VPART}") STRING(REGEX REPLACE "^#[\t ]*define[\t ]+GLFW_VERSION_${VPART}[\t ]+([0-9]+)$" "\\1" GLFW_VERSION_PART "${VLINE}") IF(GLFW_VERSION_STRING) SET(GLFW_VERSION_STRING "${GLFW_VERSION_STRING}.${GLFW_VERSION_PART}") ELSE() SET(GLFW_VERSION_STRING "${GLFW_VERSION_PART}") ENDIF() UNSET(GLFW_VERSION_PART) ENDIF() ENDFOREACH() ENDFOREACH() ENDIF() INCLUDE(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake) FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLFW REQUIRED_VARS GLFW_LIBRARY GLFW_INCLUDE_DIR VERSION_VAR GLFW_VERSION_STRING)OTB-release-5.8/CMake/FindGeoTIFF.cmake000066400000000000000000000041011301006202600173600ustar00rootroot00000000000000# - Find GEOTIFF library # Find the native GEOTIFF includes and library # # GEOTIFF_FOUND - True if GEOTIFF found. # GEOTIFF_INCLUDE_DIRS - where to find geotiff.h # GEOTIFF_LIBRARIES - List of libraries to link when using GEOTIFF. # GEOTIFF_VERSION - version string # GEOTIFF_VERSION_MAJOR - version major number # GEOTIFF_VERSION_MINOR - version minor number # GEOTIFF_VERSION_PATCH - version patch number # GEOTIFF_VERSION_NUMBER - version number ((major*100)+minor)*100+patch # find_path( GEOTIFF_INCLUDE_DIR geotiff.h PATH_SUFFIXES geotiff libgeotiff ) if(EXISTS "${GEOTIFF_INCLUDE_DIR}/geotiff.h") file(READ "${GEOTIFF_INCLUDE_DIR}/geotiff.h" _geotiff_h_CONTENTS) string(REGEX REPLACE ".*# *define +LIBGEOTIFF_VERSION +([0-9])([0-9])([0-9])([0-9]).*" "\\1" GEOTIFF_VERSION_MAJOR "${_geotiff_h_CONTENTS}") string(REGEX REPLACE ".*# *define +LIBGEOTIFF_VERSION +([0-9])([0-9])([0-9])([0-9]).*" "\\2" GEOTIFF_VERSION_MINOR "${_geotiff_h_CONTENTS}") string(REGEX REPLACE ".*# *define +LIBGEOTIFF_VERSION +([0-9])([0-9])([0-9])([0-9]).*" "\\3" GEOTIFF_VERSION_PATCH "${_geotiff_h_CONTENTS}") set(GEOTIFF_VERSION "${GEOTIFF_VERSION_MAJOR}.${GEOTIFF_VERSION_MINOR}.${GEOTIFF_VERSION_PATCH}") math(EXPR GEOTIFF_VERSION_NUMBER "((${GEOTIFF_VERSION_MAJOR})*100+${GEOTIFF_VERSION_MINOR})*100+${GEOTIFF_VERSION_PATCH}") else() if(NOT GEOTIFF_FIND_QUIETLY) message(WARNING "geotiff.h not found !") endif() endif() set( GEOTIFF_NAMES ${GEOTIFF_NAMES} geotiff_i geotiff libgeotiff_i libgeotiff ) find_library( GEOTIFF_LIBRARY NAMES ${GEOTIFF_NAMES} ) mark_as_advanced( GEOTIFF_INCLUDE_DIR GEOTIFF_LIBRARY ) # handle the QUIETLY and REQUIRED arguments and set GEOTIFF_FOUND to TRUE if # all listed variables are TRUE include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS( GeoTIFF DEFAULT_MSG GEOTIFF_LIBRARY GEOTIFF_INCLUDE_DIR) if(GEOTIFF_FOUND) set( GEOTIFF_INCLUDE_DIRS ${GEOTIFF_INCLUDE_DIR} ) set( GEOTIFF_LIBRARIES ${GEOTIFF_LIBRARY} ) endif() OTB-release-5.8/CMake/FindICUUC.cmake000066400000000000000000000016031301006202600170510ustar00rootroot00000000000000# - Find ICUUC # Find the native ICUUC includes and library # # ICUUC_FOUND - True if ICUUC found. # ICUUC_INCLUDE_DIRS - where to find unicode/unistr.h, etc. # ICUUC_LIBRARIES - List of libraries when using ICUUC. # if( ICUUC_INCLUDE_DIR ) # Already in cache, be silent set( ICUUC_FIND_QUIETLY TRUE ) endif() find_path( ICUUC_INCLUDE_DIR unicode/unistr.h ) find_library( ICUUC_LIBRARY NAMES icuuc ) # handle the QUIETLY and REQUIRED arguments and set ICUUC_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( ICUUC DEFAULT_MSG ICUUC_LIBRARY ICUUC_INCLUDE_DIR ) mark_as_advanced( ICUUC_INCLUDE_DIR ICUUC_LIBRARY ) if(ICUUC_FOUND) set(ICUUC_INCLUDE_DIRS ${ICUUC_INCLUDE_DIR}) set(ICUUC_LIBRARIES ${ICUUC_LIBRARY}) else() set(ICUUC_INCLUDE_DIRS) set(ICUUC_LIBRARIES) endif() OTB-release-5.8/CMake/FindKWStyle.cmake000066400000000000000000000033531301006202600175470ustar00rootroot00000000000000# - Finds the KWStyle utility # This module looks for KWStyle. If KWStyle is found, # the following variables are defined: # KWSTYLE_FOUND - Set if KWStyle is found # KWSTYLE_EXECUTABLE - Path to the KWStyle executable # KWSTYLE_VERSION_STRING - A human-readable string containing the version of KWStyle #============================================================================= # Copyright 2008-2013 Kitware, Inc. # Copyright 2013 Brian Helba # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= find_program( KWSTYLE_EXECUTABLE NAMES KWStyle DOC "Path to the KWStyle executable" ) mark_as_advanced(KWSTYLE_EXECUTABLE) if(KWSTYLE_EXECUTABLE) execute_process( COMMAND ${KWSTYLE_EXECUTABLE} -version OUTPUT_VARIABLE KWSTYLE_VERSION_STRING ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) if(KWSTYLE_VERSION_STRING) # string(REPLACE ..) fails if the input is an empty string string(REPLACE "Version: " "" KWSTYLE_VERSION_STRING ${KWSTYLE_VERSION_STRING} ) else(KWSTYLE_VERSION_STRING) # CMake's find_package_handle_standard_args has a bug where the # version empty string ("") is always acceptable set(KWSTYLE_VERSION_STRING "?") endif(KWSTYLE_VERSION_STRING) endif(KWSTYLE_EXECUTABLE) include(FindPackageHandleStandardArgs) find_package_handle_standard_args( KWStyle REQUIRED_VARS KWSTYLE_EXECUTABLE VERSION_VAR KWSTYLE_VERSION_STRING ) OTB-release-5.8/CMake/FindLTDL.cmake000066400000000000000000000015261301006202600167440ustar00rootroot00000000000000# - Find LTDL # Find the native LTDL includes and library # # LTDL_FOUND - True if LTDL found. # LTDL_INCLUDE_DIRS - where to find ltdl.h, etc. # LTDL_LIBRARIES - List of libraries when using LTDL. # if( LTDL_INCLUDE_DIR ) # Already in cache, be silent set( LTDL_FIND_QUIETLY TRUE ) endif() find_path( LTDL_INCLUDE_DIR ltdl.h ) find_library( LTDL_LIBRARY NAMES ltdl ) # handle the QUIETLY and REQUIRED arguments and set LTDL_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( LTDL DEFAULT_MSG LTDL_LIBRARY LTDL_INCLUDE_DIR ) mark_as_advanced( LTDL_INCLUDE_DIR LTDL_LIBRARY ) if(LTDL_FOUND) set(LTDL_INCLUDE_DIRS ${LTDL_INCLUDE_DIR}) set(LTDL_LIBRARIES ${LTDL_LIBRARY}) else() set(LTDL_INCLUDE_DIRS) set(LTDL_LIBRARIES) endif() OTB-release-5.8/CMake/FindLibKML.cmake000066400000000000000000000045061301006202600172600ustar00rootroot00000000000000# - Find LibKML # Find the native LibKML includes and library # # LIBKML_FOUND - True if LibKML found. # LIBKML_INCLUDE_DIR - where to find kml/dom.h, etc. # LIBKML_LIBRARIES - List of libraries when using LibKML. # if( LIBKML_INCLUDE_DIR ) # Already in cache, be silent set( LibKML_FIND_QUIETLY TRUE ) endif() find_path( LIBKML_INCLUDE_DIR kml/dom.h ) find_library( LIBKML_BASE_LIBRARY NAMES kmlbase ) # TODO : add HINTS derived from path of LIBKML_BASE_LIBRARY find_library( LIBKML_CONVENIENCE_LIBRARY NAMES kmlconvenience ) find_library( LIBKML_DOM_LIBRARY NAMES kmldom ) find_library( LIBKML_ENGINE_LIBRARY NAMES kmlengine ) find_library( LIBKML_REGIONATOR_LIBRARY NAMES kmlregionator ) find_library( LIBKML_XSD_LIBRARY NAMES kmlxsd ) find_library( LIBKML_MINIZIP_LIBRARY NAMES minizip ) mark_as_advanced( LIBKML_INCLUDE_DIR LIBKML_BASE_LIBRARY LIBKML_CONVENIENCE_LIBRARY LIBKML_DOM_LIBRARY LIBKML_ENGINE_LIBRARY LIBKML_REGIONATOR_LIBRARY LIBKML_XSD_LIBRARY LIBKML_MINIZIP_LIBRARY ) # handle the QUIETLY and REQUIRED arguments and set LIBKML_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( LibKML DEFAULT_MSG LIBKML_BASE_LIBRARY LIBKML_CONVENIENCE_LIBRARY LIBKML_DOM_LIBRARY LIBKML_ENGINE_LIBRARY LIBKML_REGIONATOR_LIBRARY LIBKML_XSD_LIBRARY LIBKML_MINIZIP_LIBRARY LIBKML_INCLUDE_DIR ) if(LIBKML_FOUND) set(LIBKML_INCLUDE_DIRS ${LIBKML_INCLUDE_DIR}) set(LIBKML_LIBRARIES ${LIBKML_BASE_LIBRARY} ${LIBKML_CONVENIENCE_LIBRARY} ${LIBKML_DOM_LIBRARY} ${LIBKML_ENGINE_LIBRARY} ${LIBKML_REGIONATOR_LIBRARY} ${LIBKML_XSD_LIBRARY} ${LIBKML_MINIZIP_LIBRARY}) endif() OTB-release-5.8/CMake/FindLibSVM.cmake000066400000000000000000000116061301006202600173010ustar00rootroot00000000000000# - Find LibSVM # LibSVM is a Library for Support Vector Machines # available at http://www.csie.ntu.edu.tw/~cjlin/libsvm/ # # This file based on http://www.cmake.org/Wiki/CMakeUserFindLibSVM # # The module defines the following variables: # LIBSVM_FOUND - the system has LibSVM # LIBSVM_INCLUDE_DIR - where to find svm.h # LIBSVM_INCLUDE_DIRS - libsvm includes # LIBSVM_LIBRARY - where to find the LibSVM library # LIBSVM_LIBRARIES - additional libraries # LIBSVM_MAJOR_VERSION - major version # LIBSVM_MINOR_VERSION - minor version # LIBSVM_PATCH_VERSION - patch version # LIBSVM_VERSION_STRING - version (ex. 2.9.0) # LIBSVM_ROOT_DIR - root dir (ex. /usr/local) #============================================================================= # Copyright 2000-2009 Kitware, Inc., Insight Software Consortium # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # * Neither the names of Kitware, Inc., the Insight Software Consortium, nor # the names of their contributors may be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. #============================================================================= # set LIBSVM_INCLUDE_DIR find_path ( LIBSVM_INCLUDE_DIR NAMES svm.h PATH_SUFFIXES libsvm libsvm-2.0/libsvm DOC "LibSVM include directory" ) # set LIBSVM_INCLUDE_DIRS if ( LIBSVM_INCLUDE_DIR ) set ( LIBSVM_INCLUDE_DIRS ${LIBSVM_INCLUDE_DIR} ) endif () # version set ( _VERSION_FILE ${LIBSVM_INCLUDE_DIR}/svm.h ) if ( EXISTS ${_VERSION_FILE} ) # LIBSVM_VERSION_STRING macro defined in svm.h since version 2.8.9 file ( STRINGS ${_VERSION_FILE} _VERSION_STRING REGEX ".*define[ ]+LIBSVM_VERSION[ ]+[0-9]+.*" ) if ( _VERSION_STRING ) string ( REGEX REPLACE ".*LIBSVM_VERSION[ ]+([0-9]+)" "\\1" _VERSION_NUMBER "${_VERSION_STRING}" ) math ( EXPR LIBSVM_MAJOR_VERSION "${_VERSION_NUMBER} / 100" ) math ( EXPR LIBSVM_MINOR_VERSION "(${_VERSION_NUMBER} % 100 ) / 10" ) math ( EXPR LIBSVM_PATCH_VERSION "${_VERSION_NUMBER} % 10" ) set ( LIBSVM_VERSION_STRING "${LIBSVM_MAJOR_VERSION}.${LIBSVM_MINOR_VERSION}.${LIBSVM_PATCH_VERSION}" ) endif () endif () # check version set ( _LIBSVM_VERSION_MATCH TRUE ) if ( LibSVM_FIND_VERSION AND LIBSVM_VERSION_STRING ) if ( LibSVM_FIND_VERSION_EXACT ) if ( NOT ${LibSVM_FIND_VERSION} VERSION_EQUAL ${LIBSVM_VERSION_STRING} ) set ( _LIBSVM_VERSION_MATCH FALSE ) endif () else () if ( ${LibSVM_FIND_VERSION} VERSION_GREATER ${LIBSVM_VERSION_STRING} ) set ( _LIBSVM_VERSION_MATCH FALSE ) endif () endif () endif () # set LIBSVM_LIBRARY find_library ( LIBSVM_LIBRARY NAMES svm libsvm DOC "LibSVM library location" ) # set LIBSVM_LIBRARIES set ( LIBSVM_LIBRARIES ${LIBSVM_LIBRARY} ) # link with math library on unix if ( UNIX ) find_library(M_LIB m) mark_as_advanced(M_LIB) list (APPEND LIBSVM_LIBRARIES ${M_LIB} ) endif () # try to guess root dir from include dir if ( LIBSVM_INCLUDE_DIR ) string ( REGEX REPLACE "(.*)/include.*" "\\1" LIBSVM_ROOT_DIR ${LIBSVM_INCLUDE_DIR} ) # try to guess root dir from library dir elseif ( LIBSVM_LIBRARY ) string ( REGEX REPLACE "(.*)/lib[/|32|64].*" "\\1" LIBSVM_ROOT_DIR ${LIBSVM_LIBRARY} ) endif () # handle REQUIRED and QUIET options include ( FindPackageHandleStandardArgs ) find_package_handle_standard_args ( LibSVM DEFAULT_MSG LIBSVM_LIBRARY _LIBSVM_VERSION_MATCH LIBSVM_INCLUDE_DIR LIBSVM_INCLUDE_DIRS LIBSVM_LIBRARIES LIBSVM_ROOT_DIR ) mark_as_advanced ( LIBSVM_LIBRARY LIBSVM_LIBRARIES LIBSVM_INCLUDE_DIR LIBSVM_INCLUDE_DIRS LIBSVM_ROOT_DIR LIBSVM_VERSION_STRING LIBSVM_MAJOR_VERSION LIBSVM_MINOR_VERSION LIBSVM_PATCH_VERSION ) OTB-release-5.8/CMake/FindMapnik.cmake000066400000000000000000000014671301006202600174300ustar00rootroot00000000000000# - Find Mapnik # Find the native Mapnik includes and library # # MAPNIK_FOUND - True if MAPNIK found. # MAPNIK_INCLUDE_DIRS - where to find mapnik/map.hpp, etc. # MAPNIK_LIBRARIES - List of libraries when using MAPNIK # find_path( MAPNIK_INCLUDE_DIR mapnik/map.hpp ) find_library( MAPNIK_LIBRARY NAMES mapnik2 mapnik ) # handle the QUIETLY and REQUIRED arguments and set MAPNIK_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( Mapnik DEFAULT_MSG MAPNIK_LIBRARY MAPNIK_INCLUDE_DIR ) mark_as_advanced( MAPNIK_INCLUDE_DIR MAPNIK_LIBRARY ) if(MAPNIK_FOUND) set(MAPNIK_INCLUDE_DIRS ${MAPNIK_INCLUDE_DIR}) set(MAPNIK_LIBRARIES ${MAPNIK_LIBRARY}) else() set(MAPNIK_INCLUDE_DIRS) set(MAPNIK_LIBRARIES) endif() OTB-release-5.8/CMake/FindMercurial.cmake000066400000000000000000000045051301006202600201300ustar00rootroot00000000000000# - Extract information from a mercurial working copy # Example usage: # find_package(Mercurial) # if(Mercurial_FOUND) # Mercurial_WC_IDENTIFY(${PROJECT_SOURCE_DIR} Project) # message("Current revision is ${Project_WC_REVISION}") # message("Mercurial version is ${Mercurial_VERSION_HG}") # endif() set(Mercurial_FOUND FALSE) set(Mercurial_HG_FOUND FALSE) find_program(Mercurial_HG_EXECUTABLE hg DOC "mercurial command line client") mark_as_advanced(Mercurial_HG_EXECUTABLE) if(Mercurial_HG_EXECUTABLE) set(Mercurial_HG_FOUND TRUE) set(Mercurial_FOUND TRUE) macro(Mercurial_WC_IDENTIFY dir prefix) # the subversion commands should be executed with the C locale, otherwise # the message (which are parsed) may be translated, Alex set(_Mercurial_SAVED_LC_ALL "$ENV{LC_ALL}") set(ENV{LC_ALL} C) execute_process(COMMAND ${Mercurial_HG_EXECUTABLE} version WORKING_DIRECTORY ${dir} OUTPUT_VARIABLE Mercurial_VERSION_HG OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) execute_process(COMMAND ${Mercurial_HG_EXECUTABLE} identify ${dir} OUTPUT_VARIABLE ${prefix}_WC_IDENTIFY # ERROR_VARIABLE Mercurial_hg_identify_error # RESULT_VARIABLE Mercurial_hg_identify_result OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) execute_process(COMMAND ${Mercurial_HG_EXECUTABLE} status -m ${dir} OUTPUT_VARIABLE ${prefix}_WC_STATUS # ERROR_VARIABLE Mercurial_hg_status_error # RESULT_VARIABLE Mercurial_hg_status_result OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) if(NOT ${Mercurial_hg_identify_result} EQUAL 0) message(SEND_ERROR "Command \"${Mercurial_HG_EXECUTABLE} identify ${dir}\" failed with output:\n${Mercurial_hg_identify_error}") else() string(REGEX REPLACE "^(.*\n)?Mercurial Distributed SCM [(]version ([.0-9]+).*" "\\2" Mercurial_VERSION_HG "${Mercurial_VERSION_HG}") string(REGEX REPLACE "^(.*\n)?([0-9a-f]+).*" "\\2" ${prefix}_WC_REVISION "${${prefix}_WC_IDENTIFY}") endif() # restore the previous LC_ALL set(ENV{LC_ALL} ${_Mercurial_SAVED_LC_ALL}) endmacro() endif() if(NOT Mercurial_FOUND) if(NOT Mercurial_FIND_QUIETLY) message(STATUS "Mercurial was not found.") else() if(Mercurial_FIND_REQUIRED) message(FATAL_ERROR "Mercurial was not found.") endif() endif() endif() OTB-release-5.8/CMake/FindMuParser.cmake000066400000000000000000000044461301006202600177470ustar00rootroot00000000000000# - Find MuParser # Find the native MuParser includes and library # # MUPARSER_FOUND - True if MuParser found. # MUPARSER_INCLUDE_DIRS - where to find muParser.h, etc. # MUPARSER_LIBRARIES - List of libraries when using MuParser. # MUPARSER_VERSION - version string # MUPARSER_VERSION_MAJOR - version major number # MUPARSER_VERSION_MINOR - version minor number # MUPARSER_VERSION_PATCH - version patch number # MUPARSER_VERSION_NUMBER - version number ((major*100)+minor)*100+patch # if( MUPARSER_INCLUDE_DIR ) # Already in cache, be silent set( MuParser_FIND_QUIETLY TRUE ) endif() find_path( MUPARSER_INCLUDE_DIR muParser.h PATH_SUFFIXES muParser ) if(EXISTS "${MUPARSER_INCLUDE_DIR}/muParserDef.h") file(READ "${MUPARSER_INCLUDE_DIR}/muParserDef.h" _muParserDef_h_CONTENTS) string(REGEX REPLACE ".*# *define MUP_VERSION *_T\\(\"([0-9.]+)\"\\).*" "\\1" MUPARSER_VERSION "${_muParserDef_h_CONTENTS}") if(MUPARSER_VERSION MATCHES "^[0-9]+\$") set(MUPARSER_VERSION "${MUPARSER_VERSION}.0.0") endif() if(MUPARSER_VERSION MATCHES "^[0-9]+\\.[0-9]+\$") set(MUPARSER_VERSION "${MUPARSER_VERSION}.0") endif() string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" MUPARSER_VERSION_MAJOR "${MUPARSER_VERSION}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" MUPARSER_VERSION_MINOR "${MUPARSER_VERSION}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3" MUPARSER_VERSION_PATCH "${MUPARSER_VERSION}") math(EXPR MUPARSER_VERSION_NUMBER "((${MUPARSER_VERSION_MAJOR})*100+${MUPARSER_VERSION_MINOR})*100+${MUPARSER_VERSION_PATCH}") else() if(NOT MuParser_FIND_QUIETLY) message(WARNING "muParserDef.h not found !") endif() endif() find_library( MUPARSER_LIBRARY NAMES muparser PATH_SUFFIXES muparser ) # handle the QUIETLY and REQUIRED arguments and set MUPARSER_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( MuParser DEFAULT_MSG MUPARSER_LIBRARY MUPARSER_INCLUDE_DIR ) mark_as_advanced( MUPARSER_INCLUDE_DIR MUPARSER_LIBRARY ) if(MUPARSER_FOUND) set(MUPARSER_INCLUDE_DIRS ${MUPARSER_INCLUDE_DIR}) set(MUPARSER_LIBRARIES ${MUPARSER_LIBRARY}) else() set(MUPARSER_INCLUDE_DIRS) set(MUPARSER_LIBRARIES) endif() OTB-release-5.8/CMake/FindMuParserX.cmake000066400000000000000000000041131301006202600200660ustar00rootroot00000000000000# Find MuParserX # # MUPARSERX_FOUND - True if MuParserX found. # MUPARSERX_INCLUDE_DIRS - where to find mpParser.h, etc. # MUPARSERX_LIBRARIES - List of libraries when using MuParserX. # MUPARSERX_VERSION - version string # MUPARSERX_VERSION_MAJOR - version major number # MUPARSERX_VERSION_MINOR - version minor number # MUPARSERX_VERSION_PATCH - version patch number # MUPARSERX_VERSION_NUMBER - version number ((major*100)+minor)*100+patch # if( MUPARSERX_INCLUDE_DIR ) # Already in cache, be silent set( MuParserX_FIND_QUIETLY TRUE ) endif() find_path( MUPARSERX_INCLUDE_DIR mpParser.h PATH_SUFFIXES mpParser ) if(EXISTS "${MUPARSERX_INCLUDE_DIR}/mpDefines.h") file(READ "${MUPARSERX_INCLUDE_DIR}/mpDefines.h" _mpDefines_h_CONTENTS) string(REGEX REPLACE ".*# *define MUP_PARSER_VERSION *_T\\(\"([0-9.]+)( .*)?\"\\).*" "\\1" MUPARSERX_VERSION "${_mpDefines_h_CONTENTS}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" MUPARSERX_VERSION_MAJOR "${MUPARSERX_VERSION}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" MUPARSERX_VERSION_MINOR "${MUPARSERX_VERSION}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3" MUPARSERX_VERSION_PATCH "${MUPARSERX_VERSION}") math(EXPR MUPARSERX_VERSION_NUMBER "((${MUPARSERX_VERSION_MAJOR})*100+${MUPARSERX_VERSION_MINOR})*100+${MUPARSERX_VERSION_PATCH}") else() if(NOT MuParserX_FIND_QUIETLY) message(WARNING "mpDefines.h not found !") endif() endif() find_library( MUPARSERX_LIBRARY NAMES muparserx PATH_SUFFIXES muparserx ) # handle the QUIETLY and REQUIRED arguments and set MUPARSERX_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( MuParserX DEFAULT_MSG MUPARSERX_LIBRARY MUPARSERX_INCLUDE_DIR ) mark_as_advanced( MUPARSERX_INCLUDE_DIR MUPARSERX_LIBRARY ) if(MUPARSERX_FOUND) set(MUPARSERX_INCLUDE_DIRS ${MUPARSERX_INCLUDE_DIR}) set(MUPARSERX_LIBRARIES ${MUPARSERX_LIBRARY}) else() set(MUPARSERX_INCLUDE_DIRS) set(MUPARSERX_LIBRARIES) endif() OTB-release-5.8/CMake/FindNumpy.cmake000066400000000000000000000014331301006202600173120ustar00rootroot00000000000000# - Find Numpy # Find the native numpy includes # # NUMPY_FOUND - True if Numpy headers are found. # NUMPY_INCLUDE_DIR - where to find numpy/arrayobject.h, etc. EXEC_PROGRAM ("${PYTHON_EXECUTABLE}" ARGS "${CMAKE_SOURCE_DIR}/CMake/otbTestNumpy.py" OUTPUT_VARIABLE NUMPY_INCLUDE_DIR RETURN_VALUE NUMPY_NOT_FOUND) if( NUMPY_INCLUDE_DIR MATCHES "Traceback" ) # Did not successfully include numpy set( NUMPY_INCLUDE_DIR ) else() set( NUMPY_INCLUDE_DIR ${NUMPY_INCLUDE_DIR} CACHE STRING "Numpy include path." ) endif() include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( Numpy DEFAULT_MSG NUMPY_INCLUDE_DIR ) mark_as_advanced( NUMPY_INCLUDE_DIR ) if(NUMPY_FOUND) set(NUMPY_INCLUDE_DIRS ${NUMPY_INCLUDE_DIR}) else() set(NUMPY_INCLUDE_DIRS) endif() OTB-release-5.8/CMake/FindOpenCV.cmake000077500000000000000000000070531301006202600173430ustar00rootroot00000000000000set(OPENCV_SEARCH_PATH) if(OpenCV_DIR) get_filename_component(OPENCV_SEARCH_PATH "${OpenCV_DIR}" PATH) if(OPENCV_SEARCH_PATH) get_filename_component(OPENCV_SEARCH_PATH "${OPENCV_SEARCH_PATH}" PATH) endif() if(OPENCV_SEARCH_PATH) find_path( opencv_INCLUDE_DIR opencv/cv.h PATHS "${OPENCV_SEARCH_PATH}" PATH_SUFFIXES "include" DOC "The directory where opencv/cv.h is installed") endif() endif() if(NOT opencv_INCLUDE_DIR) find_path( opencv_INCLUDE_DIR opencv/cv.h PATHS "${OpenCV_DIR}" PATH_SUFFIXES "include" DOC "The directory where opencv/cv.h is installed") endif() if(NOT EXISTS ${opencv_INCLUDE_DIR}/opencv2/opencv.hpp) message(FATAL_ERROR "${opencv_INCLUDE_DIR}/opencv2/opencv.hpp does not exists. " "Make sure you have opencv 2.3 or higher. We had searched in ${OPENCV_SEARCH_PATHS}") endif() set(opencv_core_NAMES opencv_core) set(opencv_ml_NAMES opencv_ml) if ( opencv_INCLUDE_DIR ) set(OPENCV_INCLUDE_DIRS "${opencv_INCLUDE_DIR}") if(NOT OpenCV_VERSION) file(READ "${opencv_INCLUDE_DIR}/opencv2/core/version.hpp" _header_content) string(REGEX MATCH ".*# *define +CV_VERSION_EPOCH +([0-9]+).*" matched ${_header_content}) if( matched) string(REGEX REPLACE ".*# *define +CV_VERSION_EPOCH +([0-9]+).*" "\\1" OpenCV_VERSION_MAJOR ${_header_content}) string(REGEX REPLACE ".*# *define +CV_VERSION_MAJOR +([0-9]+).*" "\\1" OpenCV_VERSION_MINOR ${_header_content}) string(REGEX REPLACE ".*# *define +CV_VERSION_MINOR +([0-9]+).*" "\\1" OpenCV_VERSION_PATCH ${_header_content}) string(REGEX REPLACE ".*# *define +CV_VERSION_REVISION +([0-9]+).*" "\\1" OpenCV_VERSION_TWEAK ${_header_content}) else() #for opencv 2.3.x string(REGEX REPLACE ".*# *define +CV_MAJOR_VERSION +([0-9]+).*" "\\1" OpenCV_VERSION_MAJOR ${_header_content}) string(REGEX REPLACE ".*# *define +CV_MINOR_VERSION +([0-9]+).*" "\\1" OpenCV_VERSION_MINOR ${_header_content}) string(REGEX REPLACE ".*# *define +CV_SUBMINOR_VERSION +([0-9]+).*" "\\1" OpenCV_VERSION_PATCH ${_header_content}) set(OpenCV_VERSION_TWEAK) endif() set(OpenCV_VERSION "${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR}.${OpenCV_VERSION_PATCH}") endif() if(WIN32) list(APPEND opencv_core_NAMES "opencv_core${OpenCV_VERSION_MAJOR}${OpenCV_VERSION_MINOR}${OpenCV_VERSION_PATCH}") list(APPEND opencv_ml_NAMES "opencv_ml${OpenCV_VERSION_MAJOR}${OpenCV_VERSION_MINOR}${OpenCV_VERSION_PATCH}") endif() endif() if(NOT OPENCV_SEARCH_PATH) get_filename_component(OPENCV_SEARCH_PATH "${opencv_INCLUDE_DIR}" PATH) endif() # Prefer the static library. find_library( OPENCV_core_LIBRARY NAMES ${opencv_core_NAMES} PATHS ${OPENCV_SEARCH_PATH} PATH_SUFFIXES "lib" "lib64" "lib/x86_64-linux-gnu" NO_DEFAULT_PATH DOC "Path to opencv_core library") find_library( OPENCV_ml_LIBRARY NAMES ${opencv_ml_NAMES} PATHS ${OPENCV_SEARCH_PATH} PATH_SUFFIXES "lib" "lib64" "lib/x86_64-linux-gnu" NO_DEFAULT_PATH DOC "Path to opencv_ml library") set(OpenCV_FOUND FALSE) if ( OPENCV_core_LIBRARY AND OPENCV_ml_LIBRARY ) set(OPENCV_LIBRARIES "${OPENCV_core_LIBRARY};${OPENCV_ml_LIBRARY}") endif () if( OPENCV_INCLUDE_DIRS AND OPENCV_LIBRARIES ) set(OpenCV_FOUND TRUE) set(OPENCV_VERSION ${OpenCV_VERSION}) #for compatility endif() include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake) FIND_PACKAGE_HANDLE_STANDARD_ARGS(OpenCV REQUIRED_VARS OPENCV_core_LIBRARY OPENCV_INCLUDE_DIRS VERSION_VAR OpenCV_VERSION) OTB-release-5.8/CMake/FindOpenThreads.cmake000066400000000000000000000132751301006202600204250ustar00rootroot00000000000000# OpenThreads is a C++ based threading library. Its largest userbase # seems to OpenSceneGraph so you might notice I accept OSGDIR as an # environment path. # I consider this part of the Findosg* suite used to find OpenSceneGraph # components. # Each component is separate and you must opt in to each module. # # Locate OpenThreads # This module defines # OPENTHREADS_LIBRARIES # OPENTHREADS_FOUND, if false, do not try to link to OpenThreads # OPENTHREADS_INCLUDE_DIRS, where to find the headers # OPENTHREADS_VERSION - version string # OPENTHREADS_VERSION_MAJOR - version major number # OPENTHREADS_VERSION_MINOR - version minor number # OPENTHREADS_VERSION_PATCH - version patch number # OPENTHREADS_VERSION_NUMBER - version number ((major*100)+minor)*100+patch # # $OPENTHREADS_DIR is an environment variable that would # correspond to the ./configure --prefix=$OPENTHREADS_DIR # used in building osg. # # Created by Eric Wing. # Modified by Guillaume Pasero. #============================================================================= # Copyright 2007-2009 Kitware, Inc. # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. # See OTBCopyright.txt for details. # # # This software is distributed WITHOUT ANY WARRANTY; without even # the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR # PURPOSE. See the above copyright notices for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) # Header files are presumed to be included like # #include # To make it easier for one-step automated configuration/builds, # we leverage environmental paths. This is preferable # to the -DVAR=value switches because it insulates the # users from changes we may make in this script. # It also offers a little more flexibility than setting # the CMAKE_*_PATH since we can target specific components. # However, the default CMake behavior will search system paths # before anything else. This is problematic in the cases # where you have an older (stable) version installed, but # are trying to build a newer version. # CMake doesn't offer a nice way to globally control this behavior # so we have to do a nasty "double FIND_" in this module. # The first FIND disables the CMAKE_ search paths and only checks # the environmental paths. # If nothing is found, then the second find will search the # standard install paths. # Explicit -DVAR=value arguments should still be able to override everything. find_path(OPENTHREADS_INCLUDE_DIR OpenThreads/Thread HINTS # enough environment variables? $ENV{OPENTHREADS_INCLUDE_DIR} $ENV{OPENTHREADS_DIR} $ENV{OSG_INCLUDE_DIR} $ENV{OSG_DIR} $ENV{OSGDIR} $ENV{OpenThreads_ROOT} $ENV{OSG_ROOT} PATHS /sw # Fink /opt/local # DarwinPorts /opt/csw # Blastwave /opt /usr/freeware PATH_SUFFIXES include ) mark_as_advanced(OPENTHREADS_INCLUDE_DIR) if(EXISTS "${OPENTHREADS_INCLUDE_DIR}/OpenThreads/Version") file(READ "${OPENTHREADS_INCLUDE_DIR}/OpenThreads/Version" _openthreads_version_CONTENTS) string(REGEX REPLACE ".*# *define +OPENTHREADS_MAJOR_VERSION +([0-9]+).*" "\\1" OPENTHREADS_VERSION_MAJOR "${_openthreads_version_CONTENTS}") string(REGEX REPLACE ".*# *define +OPENTHREADS_MINOR_VERSION +([0-9]+).*" "\\1" OPENTHREADS_VERSION_MINOR "${_openthreads_version_CONTENTS}") string(REGEX REPLACE ".*# *define +OPENTHREADS_PATCH_VERSION +([0-9]+).*" "\\1" OPENTHREADS_VERSION_PATCH "${_openthreads_version_CONTENTS}") set(OPENTHREADS_VERSION "${OPENTHREADS_VERSION_MAJOR}.${OPENTHREADS_VERSION_MINOR}.${OPENTHREADS_VERSION_PATCH}") math(EXPR OPENTHREADS_VERSION_NUMBER "((${OPENTHREADS_VERSION_MAJOR})*100+${OPENTHREADS_VERSION_MINOR})*100+${OPENTHREADS_VERSION_PATCH}") else() if(NOT OPENTHREADS_FIND_QUIETLY) message(WARNING "OpenThreads/Version not found !") endif() endif() find_library(OPENTHREADS_LIBRARY NAMES OpenThreads OpenThreadsWin32 HINTS $ENV{OPENTHREADS_LIBRARY_DIR} $ENV{OPENTHREADS_DIR} $ENV{OSG_LIBRARY_DIR} $ENV{OSG_DIR} $ENV{OSGDIR} $ENV{OpenThreads_ROOT} $ENV{OSG_ROOT} PATHS /sw /opt/local /opt/csw /opt /usr/freeware PATH_SUFFIXES lib64 lib ) mark_as_advanced(OPENTHREADS_LIBRARY) find_library(OPENTHREADS_LIBRARY_DEBUG NAMES OpenThreadsd OpenThreadsWin32d HINTS $ENV{OPENTHREADS_DEBUG_LIBRARY_DIR} $ENV{OPENTHREADS_LIBRARY_DIR} $ENV{OPENTHREADS_DIR} $ENV{OSG_LIBRARY_DIR} $ENV{OSG_DIR} $ENV{OSGDIR} $ENV{OpenThreads_ROOT} $ENV{OSG_ROOT} PATHS /sw /opt/local /opt/csw /opt /usr/freeware PATH_SUFFIXES lib64 lib ) mark_as_advanced(OPENTHREADS_LIBRARY_DEBUG) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(OpenThreads DEFAULT_MSG OPENTHREADS_LIBRARY OPENTHREADS_INCLUDE_DIR) if(OPENTHREADS_LIBRARY_DEBUG) set(OPENTHREADS_LIBRARIES optimized ${OPENTHREADS_LIBRARY} debug ${OPENTHREADS_LIBRARY_DEBUG}) else() set(OPENTHREADS_LIBRARIES ${OPENTHREADS_LIBRARY}) endif() set(OPENTHREADS_INCLUDE_DIRS ${OPENTHREADS_INCLUDE_DIR}) OTB-release-5.8/CMake/FindOssim.cmake000066400000000000000000000054771301006202600173100ustar00rootroot00000000000000# - Find Ossim # Find the native Ossim includes and library # # OSSIM_FOUND - True if Ossim found. # OSSIM_INCLUDE_DIRS - where to find ossim/init/ossimInit.h, etc. # OSSIM_LIBRARIES - List of libraries when using Ossim. # if( OSSIM_INCLUDE_DIR ) # Already in cache, be silent set( Ossim_FIND_QUIETLY TRUE ) endif() find_path( OSSIM_INCLUDE_DIR NAMES ossim/init/ossimInit.h ) # Version checking if(EXISTS "${OSSIM_INCLUDE_DIR}/ossim/ossimVersion.h") file(READ "${OSSIM_INCLUDE_DIR}/ossim/ossimVersion.h" _ossim_version_h_CONTENTS) string(REGEX REPLACE ".*# *define OSSIM_VERSION *\"([0-9.]+)\".*" "\\1" OSSIM_VERSION "${_ossim_version_h_CONTENTS}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" OSSIM_MAJOR_VERSION_NUMBER "${OSSIM_VERSION}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" OSSIM_MINOR_VERSION_NUMBER "${OSSIM_VERSION}") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3" OSSIM_PATCH_VERSION_NUMBER "${OSSIM_VERSION}") math(EXPR OSSIM_VERSION_NUMBER "((${OSSIM_MAJOR_VERSION_NUMBER})*100+${OSSIM_MINOR_VERSION_NUMBER})*100+${OSSIM_PATCH_VERSION_NUMBER}") if("${OSSIM_VERSION}" VERSION_LESS "1.8.20") message(WARNING "The OSSIM include directory detected by OTB is: '${OSSIM_INCLUDE_DIR}'." "This version (${OSSIM_VERSION}) is not fully compatible with OTB." "Please consider updating your Ossim to version 1.8.20-3 or above") else() if("${OSSIM_VERSION}" VERSION_EQUAL "1.8.20") # special case to detect versions 1.8.20-1 and 1.8.20-2 if(EXISTS "${OSSIM_INCLUDE_DIR}/ossim/projection/ossimRpcProjection.h") file(STRINGS "${OSSIM_INCLUDE_DIR}/ossim/projection/ossimRpcProjection.h" _ossim_rpc_proj_h_CONTENTS REGEX "^// \\$Id: ossimRpcProjection\\.h [0-9.]+ ") string(REGEX REPLACE ".*ossimRpcProjection\\.h ([0-9.]+) .*" "\\1" _ossim_svn_revision_hint "${_ossim_rpc_proj_h_CONTENTS}") if("${_ossim_svn_revision_hint}" LESS "23666") message(WARNING "The OSSIM include directory detected by OTB is: '${OSSIM_INCLUDE_DIR}'." "This version (${OSSIM_VERSION}, rev < r23666) is not fully compatible with OTB." "Please consider updating your Ossim to version 1.8.20-3 or above") endif() endif() endif() endif() else() if(NOT Ossim_FIND_QUIETLY) message(WARNING "ossimVersion.h not found !") endif() endif() find_library(OSSIM_LIBRARY NAMES ossim) # handle the QUIETLY and REQUIRED arguments and set OSSIM_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( Ossim DEFAULT_MSG OSSIM_LIBRARY OSSIM_INCLUDE_DIR ) mark_as_advanced( OSSIM_INCLUDE_DIR OSSIM_LIBRARY ) set(OSSIM_LIBRARIES "${OSSIM_LIBRARY};${OPENTHREADS_LIBRARY}") set(OSSIM_INCLUDE_DIRS ${OSSIM_INCLUDE_DIR}) OTB-release-5.8/CMake/FindQwt.cmake000066400000000000000000000106441301006202600167610ustar00rootroot00000000000000# Qt Widgets for Technical Applications # available at http://www.http://qwt.sourceforge.net/ # # The module defines the following variables: # QWT_FOUND - the system has Qwt # QWT_INCLUDE_DIR - where to find qwt_plot.h # QWT_INCLUDE_DIRS - qwt includes # QWT_LIBRARY - where to find the Qwt library # QWT_LIBRARIES - additional libraries # QWT_MAJOR_VERSION - major version # QWT_MINOR_VERSION - minor version # QWT_PATCH_VERSION - patch version # QWT_VERSION_STRING - version (ex. 5.2.1) # QWT_ROOT_DIR - root dir (ex. /usr/local) #============================================================================= # Copyright 2010-2013, Julien Schueller # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, this # list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # The views and conclusions contained in the software and documentation are those # of the authors and should not be interpreted as representing official policies, # either expressed or implied, of the FreeBSD Project. #============================================================================= find_path ( QWT_INCLUDE_DIR NAMES qwt_plot.h HINTS ${QT_INCLUDE_DIR} PATH_SUFFIXES qwt qwt-qt3 qwt-qt4 qwt-qt5 ) set ( QWT_INCLUDE_DIRS ${QWT_INCLUDE_DIR} ) # version set ( _VERSION_FILE ${QWT_INCLUDE_DIR}/qwt_global.h ) if ( EXISTS ${_VERSION_FILE} ) file ( STRINGS ${_VERSION_FILE} _VERSION_LINE REGEX "define[ ]+QWT_VERSION_STR" ) if ( _VERSION_LINE ) string ( REGEX REPLACE ".*define[ ]+QWT_VERSION_STR[ ]+\"(.*)\".*" "\\1" QWT_VERSION_STRING "${_VERSION_LINE}" ) string ( REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" QWT_MAJOR_VERSION "${QWT_VERSION_STRING}" ) string ( REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" QWT_MINOR_VERSION "${QWT_VERSION_STRING}" ) string ( REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3" QWT_PATCH_VERSION "${QWT_VERSION_STRING}" ) endif () endif () # check version set ( _QWT_VERSION_MATCH TRUE ) if ( Qwt_FIND_VERSION AND QWT_VERSION_STRING ) if ( Qwt_FIND_VERSION_EXACT ) if ( NOT Qwt_FIND_VERSION VERSION_EQUAL QWT_VERSION_STRING ) set ( _QWT_VERSION_MATCH FALSE ) endif () else () if ( QWT_VERSION_STRING VERSION_LESS Qwt_FIND_VERSION ) set ( _QWT_VERSION_MATCH FALSE ) endif () endif () endif () find_library ( QWT_LIBRARY NAMES qwt qwt-qt3 qwt-qt4 qwt-qt5 qwt${QWT_MAJOR_VERSION} HINTS ${QT_LIBRARY_DIR} ) set ( QWT_LIBRARIES ${QWT_LIBRARY} ) # try to guess root dir from include dir if ( QWT_INCLUDE_DIR ) string ( REGEX REPLACE "(.*)/include.*" "\\1" QWT_ROOT_DIR ${QWT_INCLUDE_DIR} ) # try to guess root dir from library dir elseif ( QWT_LIBRARY ) string ( REGEX REPLACE "(.*)/lib[/|32|64].*" "\\1" QWT_ROOT_DIR ${QWT_LIBRARY} ) endif () # handle the QUIETLY and REQUIRED arguments include ( FindPackageHandleStandardArgs ) if ( CMAKE_VERSION LESS 2.8.3 ) find_package_handle_standard_args( Qwt DEFAULT_MSG QWT_LIBRARY QWT_INCLUDE_DIR _QWT_VERSION_MATCH ) else () find_package_handle_standard_args( Qwt REQUIRED_VARS QWT_LIBRARY QWT_INCLUDE_DIR _QWT_VERSION_MATCH VERSION_VAR QWT_VERSION_STRING ) endif () mark_as_advanced ( QWT_LIBRARY QWT_LIBRARIES QWT_INCLUDE_DIR QWT_INCLUDE_DIRS QWT_MAJOR_VERSION QWT_MINOR_VERSION QWT_PATCH_VERSION QWT_VERSION_STRING QWT_ROOT_DIR ) OTB-release-5.8/CMake/FindShark.cmake000077500000000000000000000044561301006202600172650ustar00rootroot00000000000000# - Find Shark # Find the Shark includes and library # # SHARK_FOUND - True if Shark found. # SHARK_INCLUDE_DIR - where to find Core/shark.h # SHARK_LIBRARIES - List of libraries required for shark. # set(SHARK_SEARCH_PATH) set(SHARK_CONFIG_FILE) if(Shark_DIR) get_filename_component(SHARK_SEARCH_PATH "${Shark_DIR}" PATH) get_filename_component(SHARK_SEARCH_PATH "${SHARK_SEARCH_PATH}" PATH) get_filename_component(SHARK_SEARCH_PATH "${SHARK_SEARCH_PATH}" PATH) if(EXISTS "${Shark_DIR}/SharkConfig.cmake") set(SHARK_CONFIG_FILE ${Shark_DIR}/SharkConfig.cmake) endif() endif() #if(Shark_DIR) find_path( SHARK_INCLUDE_DIR shark/Core/Shark.h PATHS "${SHARK_SEARCH_PATH}" PATH_SUFFIXES include include/shark shark) find_library( SHARK_LIBRARY NAMES shark PATHS "${SHARK_SEARCH_PATH}" PATH_SUFFIXES lib ) mark_as_advanced( SHARK_INCLUDE_DIR SHARK_LIBRARY ) find_package( Boost 1.48.0 REQUIRED QUIET COMPONENTS system date_time filesystem program_options serialization thread unit_test_framework ) if(NOT Boost_FOUND) message(FATAL_ERROR "Please make sure Boost 1.48.0 is installed on your system") endif() if(NOT SHARK_CONFIG_FILE) find_file(SHARK_CONFIG_FILE SharkConfig.cmake PATH_SUFFIXES lib/cmake/Shark share/Shark) endif() if(SHARK_CONFIG_FILE) file(STRINGS "${SHARK_CONFIG_FILE}" SHARK_CONFIG_FILE_CONTENTS) string(REGEX REPLACE ".*set.*\\(SHARK_VERSION_MAJOR..([0-9]+)\"\\).*" "\\1" SHARK_VERSION_MAJOR "${SHARK_CONFIG_FILE_CONTENTS}") string(REGEX REPLACE ".*set.*\\(SHARK_VERSION_MINOR..([0-9]+)\"\\).*" "\\1" SHARK_VERSION_MINOR "${SHARK_CONFIG_FILE_CONTENTS}") string(REGEX REPLACE ".*set.*\\(SHARK_VERSION_PATCH..([0-9]+)\"\\).*" "\\1" SHARK_VERSION_PATCH "${SHARK_CONFIG_FILE_CONTENTS}") set(SHARK_VERSION_STRING "${SHARK_VERSION_MAJOR}.${SHARK_VERSION_MINOR}.${SHARK_VERSION_PATCH}") endif() INCLUDE(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake) FIND_PACKAGE_HANDLE_STANDARD_ARGS(Shark REQUIRED_VARS SHARK_LIBRARY SHARK_INCLUDE_DIR VERSION_VAR SHARK_VERSION_STRING) if(SHARK_FOUND) set(SHARK_INCLUDE_DIRS ${SHARK_INCLUDE_DIR} ${Boost_INCLUDE_DIR} ) set(SHARK_LIBRARIES ${SHARK_LIBRARY} ${Boost_LIBRARIES} ) endif() OTB-release-5.8/CMake/FindTinyXML.cmake000066400000000000000000000040751301006202600175130ustar00rootroot00000000000000# - Find TinyXML # Find the native TinyXML includes and library # # TINYXML_FOUND - True if TinyXML found. # TINYXML_INCLUDE_DIRS - where to find tinyxml.h, etc. # TINYXML_LIBRARIES - List of libraries when using TinyXML. # TINYXML_VERSION - version string # TINYXML_VERSION_MAJOR - version major number # TINYXML_VERSION_MINOR - version minor number # TINYXML_VERSION_PATCH - version patch number # TINYXML_VERSION_NUMBER - version number ((major*100)+minor)*100+patch # if( TINYXML_INCLUDE_DIR ) # Already in cache, be silent set( TinyXML_FIND_QUIETLY TRUE ) endif() find_path( TINYXML_INCLUDE_DIR tinyxml.h PATH_SUFFIXES tinyxml ) if(EXISTS "${TINYXML_INCLUDE_DIR}/tinyxml.h") file(READ "${TINYXML_INCLUDE_DIR}/tinyxml.h" _tinyxml_h_CONTENTS) string(REGEX REPLACE ".*const +int +TIXML_MAJOR_VERSION += +([0-9]+);.*" "\\1" TINYXML_VERSION_MAJOR "${_tinyxml_h_CONTENTS}") string(REGEX REPLACE ".*const +int +TIXML_MINOR_VERSION += +([0-9]+);.*" "\\1" TINYXML_VERSION_MINOR "${_tinyxml_h_CONTENTS}") string(REGEX REPLACE ".*const +int +TIXML_PATCH_VERSION += +([0-9]+);.*" "\\1" TINYXML_VERSION_PATCH "${_tinyxml_h_CONTENTS}") set(TINYXML_VERSION "${TINYXML_VERSION_MAJOR}.${TINYXML_VERSION_MINOR}.${TINYXML_VERSION_PATCH}") math(EXPR TINYXML_VERSION_NUMBER "((${TINYXML_VERSION_MAJOR})*100+${TINYXML_VERSION_MINOR})*100+${TINYXML_VERSION_PATCH}") else() if(NOT TINYXML_FIND_QUIETLY) message(WARNING "tinyxml.h not found !") endif() endif() find_library( TINYXML_LIBRARY NAMES tinyxml PATH_SUFFIXES tinyxml ) # handle the QUIETLY and REQUIRED arguments and set TINYXML_FOUND to TRUE if # all listed variables are TRUE include( FindPackageHandleStandardArgs ) FIND_PACKAGE_HANDLE_STANDARD_ARGS( TinyXML DEFAULT_MSG TINYXML_LIBRARY TINYXML_INCLUDE_DIR ) mark_as_advanced( TINYXML_INCLUDE_DIR TINYXML_LIBRARY ) if(TINYXML_FOUND) set(TINYXML_INCLUDE_DIRS ${TINYXML_INCLUDE_DIR}) set(TINYXML_LIBRARIES ${TINYXML_LIBRARY}) else() set(TINYXML_INCLUDE_DIRS) set(TINYXML_LIBRARIES) endif() OTB-release-5.8/CMake/Findcppcheck.cmake000066400000000000000000000126101301006202600177610ustar00rootroot00000000000000# - try to find cppcheck tool # # Cache Variables: # CPPCHECK_EXECUTABLE # # Non-cache variables you might use in your CMakeLists.txt: # CPPCHECK_FOUND # CPPCHECK_UNUSEDFUNC_ARG # CPPCHECK_STYLE_ARG # CPPCHECK_QUIET_ARG # CPPCHECK_INCLUDEPATH_ARG # CPPCHECK_FAIL_REGULAR_EXPRESSION # CPPCHECK_WARN_REGULAR_EXPRESSION # CPPCHECK_MARK_AS_ADVANCED - whether to mark our vars as advanced even # if we don't find this program. # # Requires these CMake modules: # FindPackageHandleStandardArgs (known included with CMake >=2.6.2) # # Original Author: # 2009-2010 Ryan Pavlik # http://academic.cleardefinition.com # Iowa State University HCI Graduate Program/VRAC # # Copyright Iowa State University 2009-2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) file(TO_CMAKE_PATH "${CPPCHECK_ROOT_DIR}" CPPCHECK_ROOT_DIR) set(CPPCHECK_ROOT_DIR "${CPPCHECK_ROOT_DIR}" CACHE PATH "Path to search for cppcheck") mark_as_advanced(CPPCHECK_ROOT_DIR) # cppcheck app bundles on Mac OS X are GUI, we want command line only set(_oldappbundlesetting ${CMAKE_FIND_APPBUNDLE}) set(CMAKE_FIND_APPBUNDLE NEVER) # If we have a custom path, look there first. if(CPPCHECK_ROOT_DIR) find_program(CPPCHECK_EXECUTABLE NAMES cppcheck cli PATHS "${CPPCHECK_ROOT_DIR}" PATH_SUFFIXES cli NO_DEFAULT_PATH) endif() find_program(CPPCHECK_EXECUTABLE NAMES cppcheck) # Restore original setting for appbundle finding set(CMAKE_FIND_APPBUNDLE ${_oldappbundlesetting}) if(CPPCHECK_EXECUTABLE) # Find out where our test file is get_filename_component(_cppcheckmoddir ${CMAKE_CURRENT_LIST_FILE} PATH) set(_cppcheckdummyfile "${_cppcheckmoddir}/Findcppcheck.cpp") # common to all version of cppcheck set(CPPCHECK_QUIET_ARG --quiet) set(CPPCHECK_FORCE_ARG --force) set(CPPCHECK_VERBOSE_ARG --verbose) set(CPPCHECK_INCLUDEPATH_ARG -I) set(CPPCHECK_DEFINITION_ARG -D) set( CPPCHECK_ALL_ARG --enable=all) # Check for the two types of command line arguments by just trying them execute_process(COMMAND ${CPPCHECK_EXECUTABLE} --enable=style ${CPPCHECK_QUIET_ARG} ${_cppcheckdummyfile} RESULT_VARIABLE _cppcheck_enable_style_result OUTPUT_QUIET ERROR_QUIET ) if( "${_cppcheck_enable_style_result}" EQUAL 0 ) set( CPPCHECK_STYLE_ARG --enable=style) # How to display errors and warnings: if(MSVC) set(CPPCHECK_TEMPLATE_ARG --template vs) set(CPPCHECK_FAIL_REGULAR_EXPRESSION "[(]error[)]") set(CPPCHECK_WARN_REGULAR_EXPRESSION "[(]style[)]") else() ## This is about the IDE, not the compiler for formatting support. Many IDE's ## support the gcc style error messages. set(CPPCHECK_TEMPLATE_ARG --template gcc) set(CPPCHECK_FAIL_REGULAR_EXPRESSION " error: ") set(CPPCHECK_WARN_REGULAR_EXPRESSION " style: ") endif() else() message( "This file supports only version of cppcheck is newer than 1.43!" ) endif() execute_process(COMMAND ${CPPCHECK_EXECUTABLE} --enable=unusedFunctions ${CPPCHECK_QUIET_ARG} ${_cppcheckdummyfile} RESULT_VARIABLE _cppcheck_enable_unused_functions_results OUTPUT_QUIET ERROR_QUIET ) if("${_cppcheck_enable_unused_functions_results}" EQUAL 0) set(CPPCHECK_UNUSEDFUNC_ARG --enable=unusedFunctions) else() execute_process(COMMAND ${CPPCHECK_EXECUTABLE} --enable=unusedFunction ${CPPCHECK_QUIET_ARG} ${_cppcheckdummyfile} RESULT_VARIABLE _cppcheck_enable_unused_function_results OUTPUT_QUIET ERROR_QUIET ) if( "${_cppcheck_enable_unused_function_results}" EQUAL 0 ) set(CPPCHECK_UNUSEDFUNC_ARG --enable=unusedFunction) else() set(CPPCHECK_UNUSEDFUNC_ARG ) endif() endif() execute_process(COMMAND ${CPPCHECK_EXECUTABLE} --enable=information ${CPPCHECK_QUIET_ARG} ${_cppcheckdummyfile} RESULT_VARIABLE _cppcheck_enable_information_results OUTPUT_QUIET ERROR_QUIET ) if("${_cppcheck_enable_information_results}" EQUAL 0) # supported since set(CPPCHECK_INFORMATION_ARG --enable=information) else() set(CPPCHECK_INFORMATION_ARG ) endif() execute_process(COMMAND ${CPPCHECK_EXECUTABLE} --enable=missingInclude ${CPPCHECK_QUIET_ARG} ${_cppcheckdummyfile} RESULT_VARIABLE _cppcheck_missingInclude_results OUTPUT_QUIET ERROR_QUIET ) if("${_cppcheck_missingInclude_results}" EQUAL 0) # supported since set(CPPCHECK_MISSING_INCLUDE_ARG --enable=missingInclude) else() set(CPPCHECK_MISSING_INCLUDE_ARG ) endif() endif() set(CPPCHECK_ALL "${CPPCHECK_EXECUTABLE} ${CPPCHECK_POSSIBLEERROR_ARG} ${CPPCHECK_UNUSEDFUNC_ARG} ${CPPCHECK_STYLE_ARG} ${CPPCHECK_QUIET_ARG} ${CPPCHECK_INCLUDEPATH_ARG} some/include/path") include(FindPackageHandleStandardArgs) find_package_handle_standard_args(cppcheck DEFAULT_MSG CPPCHECK_ALL CPPCHECK_EXECUTABLE CPPCHECK_UNUSEDFUNC_ARG CPPCHECK_STYLE_ARG CPPCHECK_INFORMATION_ARG CPPCHECK_MISSING_INCLUDE_ARG CPPCHECK_ALL_ARG CPPCHECK_INCLUDEPATH_ARG CPPCHECK_DEFINITION_ARG CPPCHECK_QUIET_ARG CPPCHECK_FORCE_ARG CPPCHECK_VERBOSE_ARG ) if(CPPCHECK_FOUND OR CPPCHECK_MARK_AS_ADVANCED) mark_as_advanced(CPPCHECK_ROOT_DIR) endif() mark_as_advanced(CPPCHECK_EXECUTABLE) OTB-release-5.8/CMake/Findcppcheck.cpp000066400000000000000000000004011301006202600174560ustar00rootroot00000000000000/** * \file Findcppcheck.cpp * \brief Dummy C++ source file used by CMake module Findcppcheck.cmake * * \author * Ryan Pavlik, 2009-2010 * * http://academic.cleardefinition.com/ * */ int main(int argc, char* argv[]) { return 0; } OTB-release-5.8/CMake/InsightValgrind-RHEL6.supp000066400000000000000000000056751301006202600212360ustar00rootroot00000000000000# # This Valgrind suppression file has been developed for: # Red Hat Enterprise Linux Server release 6.3 (Santiago) # gcc (GCC) 4.4.6 20120305 (Red Hat 4.4.6-4) # # And should be maintained for The RHEL 6 linux distribution only. # { NRDD String SSE42 1 Memcheck:Addr8 fun:__strspn_sse42 fun:itk_airStrtok ... fun:itk_nrrdRead } { NRDD String SSE42 2 Memcheck:Value8 fun:__strspn_sse42 fun:itk_airStrtok ... fun:itk_nrrdRead } { NRDD String SSE42 3 Memcheck:Cond fun:__strspn_sse42 fun:itk_airStrtok ... fun:itk_nrrdRead } { NRDD String 1 Memcheck:Value8 fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 2 Memcheck:Value8 fun:strcspn fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 3 Memcheck:Cond fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 4 Memcheck:Cond fun:itk_airStrlen fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 5 Memcheck:Value8 fun:strlen fun:itk_airStrlen fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRRD Direction 1 Memcheck:Cond ... fun:_nrrdReadNrrdParse_space_directions fun:_nrrdFormatNRRD_read fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD Direction 2 Memcheck:Value8 ... fun:_nrrdReadNrrdParse_space_directions fun:_nrrdFormatNRRD_read fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD Dimension 1 Memcheck:Cond ... fun:_nrrdReadNrrdParse_dimension fun:_nrrdFormatNRRD_read fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD Dimension 2 Memcheck:Value8 ... fun:_nrrdReadNrrdParse_dimension fun:_nrrdFormatNRRD_read fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD ReadNrrdParseField Memcheck:Cond fun:__strspn_sse42 fun:itk__nrrdReadNrrdParseField ... fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD ReadNrrdParse 1 Memcheck:Cond ... fun:itk_airEnumVal fun:_nrrdReadNrrdParse_type ... fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD ReadNrrdParse 2 Memcheck:Value8 ... fun:itk_airStrdup fun:itk_airEnumVal fun:_nrrdReadNrrdParse_type ... fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD EncodingAscii 1 Memcheck:Cond fun:__strspn_sse42 fun:_nrrdEncodingAscii_read ... fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD EncodingAscii 2 Memcheck:Cond ... fun:itk_airSingleSscanf fun:_nrrdEncodingAscii_read ... fun:itk_nrrdRead fun:itk_nrrdLoad } { NRRD EncodingAscii 3 Memcheck:Value8 ... fun:itk_airSingleSscanf fun:_nrrdEncodingAscii_read ... fun:itk_nrrdRead fun:itk_nrrdLoad } { dlopen Memcheck:Leak fun:calloc fun:_dlerror_run fun:dlopen@@GLIBC_2.?.? } OTB-release-5.8/CMake/InsightValgrind.supp000066400000000000000000001074131301006202600204110ustar00rootroot00000000000000{ Nrrd fflush 2.3 Memcheck:Param write(buf) fun:__write_nocancel fun:_IO_file_write@@GLIBC_2.2.5 fun:_IO_do_write@@GLIBC_2.2.5 fun:_IO_file_sync@@GLIBC_2.2.5 fun:fflush fun:itk__nrrdEncodingRaw_write fun:itk__nrrdFormatNRRD_write fun:itk_nrrdWrite fun:itk_nrrdSave } { Some 64 bit suppressions Memcheck:Param write(buf) fun:__write_nocancel obj:/usr/lib64/libstdc++.so.6.?.? } { Some more 64 bit suppressions Memcheck:Param write(buf) fun:__write_nocancel fun:_IO_file_write@@GLIBC_2.2.5 fun:_IO_do_write@@GLIBC_2.2.5 fun:_IO_file_sync@@GLIBC_2.2.5 fun:fflush fun:itk__nrrdEncodingRaw_write } { zlib suppression Memcheck:Cond fun:longest_match fun:deflate_slow fun:itk_zlib_deflate } { zlib suppression Memcheck:Cond fun:inflateReset2 fun:inflateInit2_ obj:/lib/x86_64-linux-gnu/libz.so.1.2.3.4 } { Some dl_relocate_object suppressions Memcheck:Cond fun:_dl_relocate_object } { Some Error from the itk::MultiThreader::DispatchSingleMethodThread Memcheck:Leak fun:calloc fun:_dl_allocate_tls fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader26DispatchSingleMethodThreadEPNS0_16ThreadInfoStructE } { Another Error from the itk::MultiThreader::DispatchSingleMethodThread Memcheck:Leak fun:calloc fun:_dl_allocate_tls fun:pthread_create@@GLIBC_2.2.5 } { Some Error from the itk::MultiThreader::SingleMethodExecute Memcheck:Leak fun:calloc obj:/lib/ld-2.3.?.so fun:_dl_allocate_tls fun:allocate_stack fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader26DispatchSingleMethodThreadEPNS0_16ThreadInfoStructE } { Error2 Memcheck:Free fun:calloc obj:*/ld-2.3.?.so fun:_dl_allocate_tls fun:allocate_stack fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader19SingleMethodExecuteEv fun:_ZN3itk11ImageSourceINS_5ImageIfLj3EEEE12GenerateDataEv } { Memcheck:Leak fun:calloc fun:_dl_allocate_tls fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader11SpawnThreadEPFPvS1_ES1_ } { lib/ld conditional jump errors Memcheck:Cond obj:*/ld-2.3.?.so obj:*/ld-2.3.?.so obj:*/ld-2.3.?.so } { CrazyTclError1 Memcheck:Leak fun:calloc obj:/usr/lib/libtcl8.4.so.0 fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_MutexLock fun:TclInitObjSubsystem fun:TclInitSubsystems fun:Tcl_FindExecutable fun:Tcl_Main } { CrazyTclError2 Memcheck:Leak fun:calloc obj:/lib/ld-2.3.?.so fun:_dl_allocate_tls fun:allocate_stack fun:pthread_create@@GLIBC_2.1 fun:TclpThreadCreate fun:Tcl_InitNotifier fun:TclInitNotifier fun:TclInitSubsystems fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { CrazyTclError3 Memcheck:Leak fun:realloc fun:TclpRealloc fun:Tcl_Realloc fun:Tcl_SetObjLength obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSEvalFile fun:Tcl_Main } { CrazyTclError4 Memcheck:Leak fun:malloc obj:/usr/lib/libtcl8.4.so.0 fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetsObj fun:Tcl_Gets obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_SetSystemEncoding fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main } { CrazyTclError5 Memcheck:Leak fun:malloc obj:/usr/lib/libtcl8.4.so.0 fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_MutexLock fun:TclInitObjSubsystem fun:TclInitSubsystems fun:Tcl_FindExecutable fun:Tcl_Main } { CrazyTclError6 Memcheck:Leak fun:malloc fun:TclThreadAllocObj fun:Tcl_NewObj fun:TclpInitLibraryPath obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main } { CrazyTclError7 Memcheck:Leak fun:realloc fun:Tcl_AttemptSetObjLength } { CrazyTclError8 Memcheck:Leak fun:malloc fun:Tcl_Alloc fun:TclCreateExecEnv fun:Tcl_CreateInterp } { CrazyTclError9 Memcheck:Leak fun:realloc fun:Tcl_Realloc fun:Tcl_SetObjLength } { CrazyTclError10 Memcheck:Leak fun:malloc fun:Tcl_Alloc fun:TclAllocateFreeObjects } { CrazyTclError11 Memcheck:Leak fun:malloc fun:realloc fun:Tcl_Realloc fun:Tcl_Export } { CrazyTclError12 Memcheck:Leak fun:malloc ... fun:getpwuid_r fun:getpwuid ... fun:Tcl_CreateInterp } { CrazyTclError13 Memcheck:Leak fun:calloc ... fun:getpwuid_r fun:getpwuid ... fun:Tcl_CreateInterp } { CrazyTclError14 Memcheck:Leak fun:realloc fun:Tcl_Realloc fun:Tcl_Export } { CrazyTclError15 Memcheck:Leak fun:malloc ... fun:Tcl_ListObjIndex fun:Tcl_SetEnsembleMappingDict } { CrazyTclEroor16 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_GetThreadData fun:Tcl_InitNotifier fun:TclInitNotifier fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { CrazyTclError17 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCreateExecEnv fun:Tcl_CreateInterp fun:Tcl_Main fun:main } { CrazyTclError18 Memcheck:Leak fun:malloc fun:TclpAlloc fun:TclpRealloc fun:Tcl_Realloc fun:Tcl_DStringSetLength fun:Tcl_ExternalToUtfDString fun:TclpFindVariable fun:TclGetEnv obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:TclVarTraceExists obj:/usr/lib/libtcl8.4.so.0 } { CrazyTclError19 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSEvalFile fun:TclEvalObjvInternal fun:Tcl_EvalObjv fun:Tcl_EvalObjEx fun:Tcl_UplevelObjCmd fun:TclEvalObjvInternal } { CrazyTclError20 Memcheck:Leak fun:malloc fun:TclpAlloc fun:TclpRealloc fun:Tcl_Realloc fun:Tcl_SetObjLength obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSEvalFile fun:TclEvalObjvInternal fun:Tcl_EvalObjv fun:Tcl_EvalObjEx fun:Tcl_UplevelObjCmd } { CrazyTclError21 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:TclCompileExpr fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileIfCmd } { CrazyTclError22 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_ListObjAppendElement fun:TclGlob fun:Tcl_GlobObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 } { CrazyTclError23 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript fun:TclCompileTokens fun:TclCompileExprWords fun:TclCompileScript fun:TclCompileTokens fun:TclCompileSetCmd fun:TclCompileScript fun:TclCompileIfCmd fun:TclCompileScript } { CrazyTclError24 Memcheck:Leak fun:malloc fun:TclThreadAllocObj fun:Tcl_NewObj fun:TclNewFSPathObj fun:TclpMatchInDirectory fun:Tcl_FSMatchInDirectory fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob } { CrayTclError25 Memcheck:Leak fun:malloc fun:TclpAlloc fun:TclpRealloc fun:Tcl_AttemptSetObjLength obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_AppendObjToObj obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetStringFromObj obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetStringFromObj obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj } { CrazyTclError26 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_ListObjAppendElement fun:TclpMatchInDirectory fun:Tcl_FSMatchInDirectory fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob } { CrazyTclError27 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_WriteObj fun:Tcl_PutsObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc fun:TclEvalObjvInternal } { CrazyTclError28 Memcheck:Leak fun:malloc fun:TclThreadAllocObj fun:Tcl_NewStringObj fun:TclNewFSPathObj fun:TclpMatchInDirectory fun:Tcl_FSMatchInDirectory fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob fun:TclDoGlob } { CrazyTclError29 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclInitByteCodeObj fun:TclSetByteCodeFromAny obj:/usr/lib/libtcl8.4.so.0 fun:TclObjInterpProc fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc fun:TclEvalObjvInternal } { CrazyTclError30 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetsObj fun:Tcl_Gets obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_SetSystemEncoding fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 } { CrazyTclError31 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileWhileCmd fun:TclCompileScript fun:TclCompileIfCmd fun:TclCompileScript } { CrazyTclError32 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclExpandCodeArray fun:TclCompileIncrCmd fun:TclCompileScript fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileWhileCmd fun:TclCompileScript fun:TclCompileIfCmd fun:TclCompileScript } { CrazyTclError33 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_CreateHashEntry fun:TclLookupArrayElement obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc } { CrazyTclError34 Memcheck:Leak fun:malloc fun:TclThreadAllocObj fun:Tcl_NewStringObj fun:TclpNativeSplitPath fun:Tcl_FSSplitPath obj:/usr/lib/libtcl8.4.so.0 fun:TclFSEnsureEpochOk fun:Tcl_FSGetFileSystemForPath fun:Tcl_FSAccess obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FileObjCmd } { CrazyTclError35 Memcheck:Leak fun:malloc fun:TclThreadAllocObj fun:Tcl_NewStringObj fun:TclpNativeSplitPath fun:Tcl_FSSplitPath obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSGetNormalizedPath fun:TclFSEnsureEpochOk fun:Tcl_FSGetFileSystemForPath fun:Tcl_FSAccess obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FileObjCmd } { CrazyTclError36 Memcheck:Leak fun:malloc fun:TclThreadAllocObj fun:Tcl_NewLongObj obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_ExprObj obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc } { CrazyTclError37 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_SetSystemEncoding fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { CrazyTclError38 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript fun:TclCompileTokens fun:TclCompileExprWords fun:TclCompileExprCmd fun:TclCompileScript fun:TclCompileTokens fun:TclCompileSetCmd fun:TclCompileScript fun:TclCompileCmdWord } { CrazyTclError39 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:TclCompileExpr fun:TclCompileExprWords fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileCmdWord fun:TclCompileIfCmd } { CrazyTclError40 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_SetSystemEncoding fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { CrazyTclError41 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_SetSystemEncoding fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { CrazyTclError42 Memcheck:Leak fun:malloc fun:TclpAlloc fun:TclpRealloc fun:Tcl_AttemptRealloc fun:Tcl_AttemptSetObjLength obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_AppendObjToObj obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetStringFromObj obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetStringFromObj obj:/usr/lib/libtcl8.4.so.0 } { CrayTclError43 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript fun:TclCompileTokens fun:TclCompileExprWords fun:TclCompileExprCmd fun:TclCompileScript fun:TclCompileTokens fun:TclCompileSetCmd fun:TclCompileScript fun:TclCompileCmdWord } { CrazyTclError44 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:TclCompileExpr fun:TclCompileExprWords fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileCmdWord fun:TclCompileIfCmd } { CrazyTclError45 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_SetSystemEncoding fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { CrazyTclError46 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript fun:TclCompileTokens fun:TclCompileExprWords fun:TclCompileExprCmd fun:TclCompileScript fun:TclCompileTokens fun:TclCompileSetCmd fun:TclCompileScript fun:TclCompileCmdWord } { CrazyTclError47 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:TclCompileExpr fun:TclCompileExprWords fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileCmdWord fun:TclCompileIfCmd } { CrazyTclError48 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:TclCompileScript obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:TclCompileExpr fun:TclCompileExprWords fun:TclCompileIfCmd fun:TclCompileScript fun:TclCompileCmdWord fun:TclCompileIfCmd } { CrazyTclError49 Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_SetSystemEncoding fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:_ZSt18uncaught_exceptionv fun:_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc fun:_Z63itkGreyLevelCooccurrenceMatrixTextureCoefficientsCalculatorTestiPPc fun:main } { Memcheck:Leak fun:calloc obj:/lib/ld-2.3.?.so fun:_dl_allocate_tls fun:allocate_stack fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader19SingleMethodExecuteEv fun:_ZN3itk11ImageSourceINS_5ImageIdLj6EEEE12GenerateDataEv fun:_ZN3itk13ProcessObject16UpdateOutputDataEPNS_10DataObjectE } { Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:_ZSt18uncaught_exceptionv fun:_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc fun:_ZN3itk12OutputWindow11DisplayTextEPKc } { Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:__cxa_throw } { ostream stuff Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:_ZSt18uncaught_exceptionv fun:_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc } { ostream stuff Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:_ZSt18uncaught_exceptionv fun:_ZNSolsEm fun:_ZNSolsEj } { basic_ostream From cumulative gaussian optimizer Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:_ZSt18uncaught_exceptionv fun:_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc } { ostream stuff Memcheck:Value4 obj:/usr/lib/libstdc++.so.6.0.3 fun:_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE13_M_insert_intImEES3_S3_RSt8ios_basecT_ fun:_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE6do_putES3_RSt8ios_basecm fun:_ZNSolsEm } { ostream stuff Memcheck:Value8 fun:vfprintf fun:vsnprintf fun:snprintf obj:/usr/lib/libstdc++.so.6.0.3 fun:_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE15_M_insert_floatIdEES3_S3_RSt8ios_baseccT_ } { itkThreadLoggerTest 1 Memcheck:Leak fun:calloc obj:/lib/ld-2.3.?.so fun:_dl_allocate_tls fun:allocate_stack fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader11SpawnThreadEPFPvS1_ES1_ fun:_ZN3itk12ThreadLoggerC1Ev fun:_ZN3itk12ThreadLogger3NewEv fun:_Z19itkThreadLoggerTestiPPc fun:main } { itkThreadLoggerTest 1 Memcheck:Leak fun:calloc fun:_dl_allocate_tls fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader11SpawnThreadEPFPvS1_ES1_ fun:_ZN3itk12ThreadLoggerC1Ev fun:_ZN3itk12ThreadLogger3NewEv } { itkCommonPrintTest Memcheck:Cond obj:/usr/lib/libstdc++.so.6.0.3 fun:_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE13_M_insert_intImEES3_S3_RSt8ios_basecT_ fun:_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE6do_putES3_RSt8ios_basecPKv fun:_ZNSolsEPKv fun:_ZNK3itk21KLMSegmentationBorder9PrintSelfERSoNS_6IndentE fun:_ZNK3itk11LightObject5PrintERSoNS_6IndentE fun:_ZNK3itk12SmartPointerINS_21KLMSegmentationBorderEE5PrintERSo fun:_ZN3itklsINS_21KLMSegmentationBorderEEERSoS2_NS_12SmartPointerIT_EE fun:_Z18itkCommonPrintTestiPPc fun:main } { itkCommonPrintTest Memcheck:Value4 obj:/usr/lib/libstdc++.so.6.0.3 fun:_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE13_M_insert_intImEES3_S3_RSt8ios_basecT_ fun:_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE6do_putES3_RSt8ios_basecPKv fun:_ZNSolsEPKv fun:_ZNK3itk21KLMSegmentationBorder9PrintSelfERSoNS_6IndentE fun:_ZNK3itk11LightObject5PrintERSoNS_6IndentE fun:_ZNK3itk12SmartPointerINS_21KLMSegmentationBorderEE5PrintERSo fun:_ZN3itklsINS_21KLMSegmentationBorderEEERSoS2_NS_12SmartPointerIT_EE fun:_Z18itkCommonPrintTestiPPc fun:main } { Below block is after changes to Multithreader, Aug 05 Memcheck:Leak fun:calloc obj:/lib/ld-2.3.?.so fun:_dl_allocate_tls fun:allocate_stack fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader26DispatchSingleMethodThreadEPNS0_16ThreadInfoStructE } { Memcheck:Leak fun:calloc obj:/lib/ld-2.3.?.so fun:_dl_allocate_tls fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader26DispatchSingleMethodThreadEPNS0_16ThreadInfoStructE fun:_ZN3itk13MultiThreader19SingleMethodExecuteEv fun:_ZN3itk11ImageSourceINS_5ImageIfLj2EEEE12GenerateDataEv fun:_ZN3itk13ProcessObject16UpdateOutputDataEPNS_10DataObjectE fun:_ZN3itk10DataObject16UpdateOutputDataEv } { Memcheck:Leak fun:calloc obj:/lib/ld-2.3.?.so fun:_dl_allocate_tls fun:pthread_create@@GLIBC_2.1 fun:_ZN3itk13MultiThreader26DispatchSingleMethodThreadEPNS0_16ThreadInfoStructE fun:_ZN3itk13MultiThreader19SingleMethodExecuteEv } { Exception allocation Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:__cxa_allocate_exception } { Exception allocation Memcheck:Leak fun:malloc fun:__cxa_get_globals fun:__cxa_allocate_exception } { index(strchr.S) Memcheck:Cond fun:index } { /lib/libz Memcheck:Cond obj:*/libz.so.1.2.3 } { dlopen leak1 Memcheck:Leak fun:calloc fun:_dlerror_run fun:dlopen* } { dlopen leak2 Memcheck:Leak fun:calloc obj:/lib/libdl-2.?.?.so fun:dlopen* } { dlopen leak3 Memcheck:Leak fun:calloc obj:/lib64/libdl-2.?.so fun:dlopen } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_GetThreadData fun:Tcl_InitNotifier fun:TclInitNotifier fun:TclInitSubsystems fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_CreateChannel fun:Tcl_MakeFileChannel fun:TclpGetDefaultStdChannel fun:Tcl_GetStdChannel fun:Tcl_GetChannel fun:Tcl_PutsObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetStringFromObj obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetsObj fun:Tcl_GetsObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetsObj fun:Tcl_GetsObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetsObj fun:Tcl_GetsObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_MutexLock fun:TclInitObjSubsystem fun:TclInitSubsystems fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_CreateHashEntry fun:Tcl_RegisterObjType fun:TclInitObjSubsystem fun:TclInitSubsystems fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetsObj fun:Tcl_Gets obj:/usr/lib/libtcl8.4.so.0 fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:TclpSetInitialEncodings obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FindExecutable fun:Tcl_Main fun:main } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSEvalFile fun:Tcl_SourceObjCmd fun:TclEvalObjvInternal fun:Tcl_EvalObjv fun:Tcl_EvalObjEx fun:Tcl_UplevelObjCmd } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSEvalFile fun:Tcl_SourceObjCmd fun:TclEvalObjvInternal fun:Tcl_EvalObjv fun:Tcl_EvalObjEx fun:Tcl_UplevelObjCmd } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:TclpRealloc fun:Tcl_Realloc fun:Tcl_SetObjLength obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSEvalFile fun:Tcl_SourceObjCmd fun:TclEvalObjvInternal fun:Tcl_EvalObjv fun:Tcl_EvalObjEx } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_NewStringObj fun:Tcl_EvalTokensStandard fun:Tcl_EvalEx fun:Tcl_FSEvalFile fun:Tcl_SourceObjCmd fun:TclEvalObjvInternal fun:Tcl_EvalObjv fun:Tcl_EvalObjEx fun:Tcl_UplevelObjCmd } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:TclpRealloc fun:Tcl_Realloc fun:Tcl_SetObjLength obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_FSEvalFile fun:Tcl_Main fun:main } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc fun:Tcl_CreateChannel fun:Tcl_MakeFileChannel fun:TclpGetDefaultStdChannel fun:Tcl_GetStdChannel obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetChannel fun:Tcl_PutsObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:Tcl_Alloc obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_GetsObj fun:Tcl_GetsObjCmd fun:TclEvalObjvInternal obj:/usr/lib/libtcl8.4.so.0 fun:TclCompEvalObj fun:TclObjInterpProc } { Memcheck:Leak fun:malloc fun:TclpAlloc fun:TclpRealloc fun:Tcl_AttemptRealloc fun:Tcl_AttemptSetObjLength obj:/usr/lib/libtcl8.4.so.0 fun:Tcl_EvalTokensStandard fun:Tcl_EvalEx fun:Tcl_FSEvalFile fun:Tcl_SourceObjCmd fun:TclEvalObjvInternal fun:Tcl_EvalObjv } { Memcheck:Cond obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:* obj:* obj:* obj:* obj:* obj:* obj:* } { Memcheck:Cond obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:* obj:* obj:* obj:* } { Memcheck:Addr8 obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/libc-2.10.1.so obj:/lib/ld-2.10.1.so fun:__libc_dlopen_mode fun:pthread_cancel_init fun:_Unwind_ForcedUnwind } { Memcheck:Cond obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:* obj:* obj:* } { Memcheck:Cond obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so obj:/lib/ld-2.10.1.so } { ExitFreeLibC brian.jouy.inra.fr Memcheck:Free fun:free obj:/lib64/libc-2.9.so obj:/lib64/libc-2.9.so fun:_vgnU_freeres fun:exit fun:(below main) } { ExitFreeLibC brian.jouy.inra.fr Memcheck:Free fun:free obj:/lib64/libc-2.9.so obj:/lib64/libc-2.9.so fun:_vgnU_freeres fun:exit fun:fhdl obj:/lib64/libpthread-2.9.so fun:_Z30itkFloatingPointExceptionsTestiPPc fun:main } { itkFloatingPointExceptionsTest leak brian.jouy.inra.fr Memcheck:Leak fun:_Znwm fun:_ZNSs4_Rep9_S_createEmmRKSaIcE obj:/usr/lib64/libstdc++.so.6.0.10 fun:_ZNSsC1EPKcRKSaIcE fun:_Z30itkFloatingPointExceptionsTestiPPc fun:main } { CrazyTclError brian.jouy.inra.fr Memcheck:Leak fun:realloc fun:Tcl_Realloc obj:/usr/lib64/libtcl8.6.so.0 fun:Tcl_GetUnicodeFromObj obj:/usr/lib64/libtcl8.6.so.0 fun:TclNRRunCallbacks obj:/usr/lib64/libtcl8.6.so.0 fun:Tcl_FSEvalFileEx fun:Tcl_Main fun:main } { Memcheck:Leak fun:malloc fun:strdup fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:malloc fun:PyList_New obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:Py_BuildValue fun:PyImport_Import fun:PyImport_ImportModule fun:_PyExc_Init fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:malloc fun:_dl_new_object fun:_dl_map_object_from_fd fun:_dl_map_object fun:dl_open_worker fun:_dl_catch_error fun:_dl_open obj:/lib64/libdl-2.9.so fun:_dl_catch_error obj:/lib64/libdl-2.9.so fun:dlopen fun:_PyImport_GetDynLoadFunc fun:_PyImport_LoadDynamicModule obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyImport_ImportModuleLevel obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call fun:PyEval_CallObjectWithKeywords fun:PyEval_EvalFrameEx fun:PyEval_EvalCodeEx fun:PyEval_EvalCode obj:/usr/lib64/libpython2.6.so.1.0 } { Memcheck:Leak fun:malloc fun:expand_dynamic_string_token fun:_dl_map_object fun:dl_open_worker fun:_dl_catch_error fun:_dl_open obj:/lib64/libdl-2.9.so fun:_dl_catch_error obj:/lib64/libdl-2.9.so fun:dlopen fun:_PyImport_GetDynLoadFunc fun:_PyImport_LoadDynamicModule obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyImport_ImportModuleLevel obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call fun:PyEval_CallObjectWithKeywords fun:PyEval_EvalFrameEx fun:PyEval_EvalCodeEx fun:PyEval_EvalCode obj:/usr/lib64/libpython2.6.so.1.0 fun:PyRun_FileExFlags } { Memcheck:Leak fun:calloc fun:_dl_check_map_versions fun:dl_open_worker fun:_dl_catch_error fun:_dl_open obj:/lib64/libdl-2.9.so fun:_dl_catch_error obj:/lib64/libdl-2.9.so fun:dlopen fun:_PyImport_GetDynLoadFunc fun:_PyImport_LoadDynamicModule obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyImport_ImportModuleLevel obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call fun:PyEval_CallObjectWithKeywords fun:PyEval_EvalFrameEx fun:PyEval_EvalCodeEx fun:PyEval_EvalCode obj:/usr/lib64/libpython2.6.so.1.0 fun:PyRun_FileExFlags fun:PyRun_SimpleFileExFlags } { Memcheck:Leak fun:malloc fun:PyThread_allocate_lock fun:PyInterpreterState_New fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:malloc fun:_dl_map_object_deps fun:dl_open_worker fun:_dl_catch_error fun:_dl_open obj:/lib64/libdl-2.9.so fun:_dl_catch_error obj:/lib64/libdl-2.9.so fun:dlopen fun:_PyImport_GetDynLoadFunc fun:_PyImport_LoadDynamicModule obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyImport_ImportModuleLevel obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call fun:PyEval_CallObjectWithKeywords fun:PyEval_EvalFrameEx fun:PyEval_EvalCodeEx fun:PyEval_EvalCode obj:/usr/lib64/libpython2.6.so.1.0 fun:PyRun_FileExFlags fun:PyRun_SimpleFileExFlags } { Memcheck:Leak fun:malloc obj:/usr/lib64/libpython2.6.so.1.0 fun:Py_GetProgramFullPath fun:_PySys_Init fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:realloc obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyType_Ready fun:_PyExc_Init fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:malloc fun:realloc obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyType_Ready fun:_Py_ReadyTypes fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:calloc fun:_dl_new_object fun:_dl_map_object_from_fd fun:_dl_map_object fun:dl_open_worker fun:_dl_catch_error fun:_dl_open obj:/lib64/libdl-2.9.so fun:_dl_catch_error obj:/lib64/libdl-2.9.so fun:dlopen fun:_PyImport_GetDynLoadFunc fun:_PyImport_LoadDynamicModule obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyImport_ImportModuleLevel obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call fun:PyEval_CallObjectWithKeywords fun:PyEval_EvalFrameEx fun:PyEval_EvalCodeEx fun:PyEval_EvalCode obj:/usr/lib64/libpython2.6.so.1.0 } { Memcheck:Leak fun:malloc obj:/usr/lib64/libpython2.6.so.1.0 fun:_PyInt_Init fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:malloc fun:PyStructSequence_InitType fun:_PyFloat_Init fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:malloc fun:PyObject_Malloc fun:_PyObject_GC_Malloc fun:_PyObject_GC_NewVar fun:PyFrame_New fun:PyEval_EvalCodeEx obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call fun:PyObject_CallFunctionObjArgs fun:PyEval_EvalFrameEx fun:PyEval_EvalCodeEx fun:PyEval_EvalCode fun:PyImport_ExecCodeModuleEx obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 obj:/usr/lib64/libpython2.6.so.1.0 fun:PyImport_ImportModuleLevel obj:/usr/lib64/libpython2.6.so.1.0 fun:PyObject_Call fun:PyEval_CallObjectWithKeywords } { Memcheck:Leak fun:malloc obj:/usr/lib64/libpython2.6.so.1.0 fun:PyType_Ready fun:PyType_Ready fun:_Py_ReadyTypes fun:Py_InitializeEx fun:Py_Main fun:(below main) } { Memcheck:Leak fun:malloc fun:PyObject_Malloc fun:_PyObject_GC_Malloc fun:_PyObject_GC_NewVar fun:PyTuple_New fun:PyType_Ready fun:PyType_Ready fun:_Py_ReadyTypes fun:Py_InitializeEx fun:Py_Main fun:(below main) } { NRDD String SSE42 1 Memcheck:Addr8 fun:__strspn_sse42 fun:itk_airStrtok ... fun:itk_nrrdRead } { NRDD String SSE42 2 Memcheck:Value8 fun:__strspn_sse42 fun:itk_airStrtok ... fun:itk_nrrdRead } { NRDD String SSE42 3 Memcheck:Cond fun:__strspn_sse42 fun:itk_airStrtok ... fun:itk_nrrdRead } { NRDD String 1 Memcheck:Value8 fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 2 Memcheck:Value8 fun:strcspn fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 3 Memcheck:Cond fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 4 Memcheck:Cond fun:itk_airStrlen fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRDD String 5 Memcheck:Value8 fun:strlen fun:itk_airStrlen fun:itk_airStrtok fun:itk_airStrntok fun:itk__nrrdSpaceVectorParse ... fun:itk_nrrdRead } { NRRD Direction 1 Memcheck:Cond ... fun:_nrrdReadNrrdParse_space_directions fun:_nrrdFormatNRRD_read fun:itk__nrrdRead fun:itk_nrrdRead } { NRRD Direction 2 Memcheck:Value8 ... fun:_nrrdReadNrrdParse_space_directions fun:_nrrdFormatNRRD_read fun:itk__nrrdRead fun:itk_nrrdRead }OTB-release-5.8/CMake/MinGWPackage.cmake000066400000000000000000000133401301006202600176360ustar00rootroot00000000000000macro(package_mingw) cmake_parse_arguments(PACKAGE "" "PREFIX_DIR;ARCH;MXEROOT;WITH_OTBGUI" "SEARCHDIRS;PEFILES" ${ARGN} ) list(APPEND PACKAGE_PEFILES ${CMAKE_INSTALL_PREFIX}/bin/otbApplicationLauncherCommandLine.exe) list(APPEND PACKAGE_PEFILES ${CMAKE_INSTALL_PREFIX}/bin/otbTestDriver.exe) if(PACKAGE_WITH_OTBGUI) list(APPEND PACKAGE_PEFILES ${CMAKE_INSTALL_PREFIX}/bin/otbApplicationLauncherQt.exe) endif() if("${PACKAGE_ARCH}" STREQUAL "x86") set(MXE_BIN_DIR "${PACKAGE_MXEROOT}/usr/i686-w64-mingw32.shared/bin") set(MXE_OBJDUMP "${PACKAGE_MXEROOT}/usr/bin/i686-w64-mingw32.shared-objdump") elseif("${PACKAGE_ARCH}" STREQUAL "x64") set(MXE_BIN_DIR "${PACKAGE_MXEROOT}/usr/x86_64-w64-mingw32.shared/bin") set(MXE_OBJDUMP "${PACKAGE_MXEROOT}/usr/bin/x86_64-w64-mingw32.shared-objdump") endif() file(GLOB MXE_GCC_LIB_DIR "${MXE_BIN_DIR}/gcc*") list(APPEND PACKAGE_SEARCHDIRS ${MXE_GCC_LIB_DIR}) list(APPEND PACKAGE_SEARCHDIRS ${MXE_BIN_DIR}) list(APPEND PACKAGE_SEARCHDIRS "${MXE_BIN_DIR}/../qt/bin") #Qt list(APPEND PACKAGE_SEARCHDIRS "${MXE_BIN_DIR}/../qt/lib") #Qwt list(APPEND PACKAGE_SEARCHDIRS "${CMAKE_INSTALL_PREFIX}/bin") #mvd list(APPEND PACKAGE_SEARCHDIRS "${CMAKE_INSTALL_PREFIX}/lib/otb/applications") #otb apps install_common(${PACKAGE_WITH_OTBGUI}) file(GLOB otbapps_list ${CMAKE_INSTALL_PREFIX}/lib/otb/applications/otbapp_*dll) # /lib/otb list(APPEND PACKAGE_PEFILES ${otbapps_list}) set(alldlls) set(notfound_dlls) foreach(infile ${PACKAGE_PEFILES}) get_filename_component(bn ${infile} NAME) process_deps(${bn}) endforeach() list(LENGTH notfound_dlls nos) if(${nos} GREATER 0) STRING(REPLACE ".dll" ".dll," notfound ${notfound_dlls}) message(FATAL_ERROR "Following dlls were not found: ${notfound} Please consider adding their paths to SEARCHDIRS when calling package_mingw macro.") endif() endmacro(package_mingw) set(SYSTEM_DLLS msvc.*dll user32.dll gdi32.dll shell32.dll kernel32.dll advapi32.dll crypt32.dll ws2_32.dll wldap32.dll ole32.dll opengl32.dll glu32.dll comdlg32.dll imm32.dll oleaut32.dll comctl32.dll winmm.dll shfolder.dll secur32.dll wsock32.dll winspool.drv) macro(is_system_dll matched value) set(${matched}) string(TOLOWER ${value} value_) foreach (pattern ${SYSTEM_DLLS}) string(TOLOWER ${pattern} pattern_) if(${value_} MATCHES ${pattern_}) set(${matched} TRUE) endif() endforeach() endmacro() macro(list_contains var value) set(${var}) foreach(value2 ${ARGN}) if(${value} STREQUAL ${value2}) set(${var} TRUE) endif() endforeach(value2) endmacro() function(process_deps infile) get_filename_component(bn ${infile} NAME) list_contains(contains "${bn}" "${alldlls}") if(NOT contains) set(DLL_FOUND FALSE) foreach(SEARCHDIR ${PACKAGE_SEARCHDIRS}) if(NOT DLL_FOUND) if(EXISTS ${SEARCHDIR}/${infile}) set(DLL_FOUND TRUE) else() string(TOLOWER ${infile} infile_lower) if(EXISTS ${SEARCHDIR}/${infile_lower}) set(DLL_FOUND TRUE) set(infile ${infile_lower}) endif() endif() if(DLL_FOUND) message(STATUS "Processing ${SEARCHDIR}/${infile}") if(NOT "${infile}" MATCHES "otbapp") install(FILES "${SEARCHDIR}/${infile}" DESTINATION ${PACKAGE_PREFIX_DIR}/bin) else() ##message(STATUS "skipping..${infile}") endif() if(NOT EXISTS ${MXE_OBJDUMP}) message(FATAL_ERROR "objdump executable not found. please check MXE_OBJDUMP is set to correct cross compiled executable") endif() execute_process(COMMAND ${MXE_OBJDUMP} "-p" "${SEARCHDIR}/${infile}" OUTPUT_VARIABLE dlldeps) string(REGEX MATCHALL "DLL.Name..[A-Za-z(0-9\\.0-9)+_\\-]*" OUT "${dlldeps}") string(REGEX REPLACE "DLL.Name.." "" OUT "${OUT}") foreach(o ${OUT}) process_deps(${o}) endforeach() endif() endif(NOT DLL_FOUND) endforeach() if(NOT DLL_FOUND) is_system_dll(iss "${infile}") if(NOT iss) set(notfound_dlls "${notfound_dlls};${infile}") endif() else(NOT DLL_FOUND) set( alldlls "${alldlls};${bn}" PARENT_SCOPE ) endif(NOT DLL_FOUND) set(notfound_dlls "${notfound_dlls}" PARENT_SCOPE ) endif() endfunction() function(install_common with_otbgui) set(APP_PREFIX_DIR "${PACKAGE_PREFIX_DIR}") set(APP_BIN_DIR "${APP_PREFIX_DIR}/bin") set(APP_OTBLIBS_DIR "${APP_PREFIX_DIR}/lib/otb") set(APP_DATA_DIR "${APP_PREFIX_DIR}/share") ####################### install GDAL data ####################### set(GDAL_DATA ${MXE_BIN_DIR}/../share/gdal) if(NOT EXISTS "${GDAL_DATA}/epsg.wkt") message(FATAL_ERROR "Cannot generate package without GDAL_DATA : ${GDAL_DATA}") endif() install( DIRECTORY ${GDAL_DATA} DESTINATION ${APP_DATA_DIR}) ####################### Check otb applications ####################### file(GLOB OTB_APPS_LIST ${CMAKE_INSTALL_PREFIX}/lib/otb/applications/otbapp_*dll) # /lib/otb if(NOT OTB_APPS_LIST) message(FATAL_ERROR "No OTB-applications detected") endif() ## otb apps dir /lib/otb/applications install( DIRECTORY "${CMAKE_INSTALL_PREFIX}/lib/otb/applications" DESTINATION ${APP_OTBLIBS_DIR}) file(GLOB CLI_SCRIPTS ${CMAKE_INSTALL_PREFIX}/bin/otbcli*) foreach(CLI_SCRIPT ${CLI_SCRIPTS}) install( FILES "${CLI_SCRIPT}" DESTINATION ${APP_BIN_DIR}) endforeach() if(with_otbgui) file(GLOB GUI_SCRIPTS ${CMAKE_INSTALL_PREFIX}/bin/otbgui*) foreach(GUI_SCRIPT ${GUI_SCRIPTS}) install( FILES "${GUI_SCRIPT}" DESTINATION ${APP_BIN_DIR}) endforeach() endif() endfunction() OTB-release-5.8/CMake/MonteverdiApplicationMacros.cmake000066400000000000000000000016121301006202600230450ustar00rootroot00000000000000macro(create_monteverdi_application) cmake_parse_arguments(APPLICATION "" "NAME;OUTPUT_NAME;COMPONENT_NAME" "SOURCES;LINK_LIBRARIES" ${ARGN} ) if(WIN32) add_executable(${APPLICATION_NAME} WIN32 ${APPLICATION_SOURCES}) else() #Unix add_executable(${APPLICATION_NAME} ${APPLICATION_SOURCES}) endif() if (APPLICATION_OUTPUT_NAME) set_target_properties(${APPLICATION_NAME} PROPERTIES OUTPUT_NAME ${APPLICATION_OUTPUT_NAME}) endif() target_link_libraries(${APPLICATION_NAME} ${APPLICATION_LINK_LIBRARIES}) install(TARGETS ${APPLICATION_NAME} RUNTIME DESTINATION ${Monteverdi_INSTALL_BIN_DIR} COMPONENT ${APPLICATION_COMPONENT_NAME} LIBRARY DESTINATION ${Monteverdi_INSTALL_LIB_DIR} COMPONENT ${APPLICATION_COMPONENT_NAME} ARCHIVE DESTINATION ${Monteverdi_INSTALL_LIB_DIR} COMPONENT ${APPLICATION_COMPONENT_NAME} ) endmacro(create_monteverdi_application)OTB-release-5.8/CMake/OTBApplicationMacros.cmake000066400000000000000000000154041301006202600213610ustar00rootroot00000000000000macro(otb_create_application) cmake_parse_arguments(APPLICATION "" "NAME;BUILD_PATH;INSTALL_PATH" "SOURCES;INCLUDE_DIRS;LINK_LIBRARIES" ${ARGN} ) set( APPLICATION_TARGET_NAME otbapp_${APPLICATION_NAME} ) # Build the library as a MODULE (shared lib even if OTB is built statically) include_directories(${APPLICATION_INCLUDE_DIRS}) add_library(${APPLICATION_TARGET_NAME} MODULE ${APPLICATION_SOURCES}) target_link_libraries(${APPLICATION_TARGET_NAME} OTBApplicationEngine ${APPLICATION_LINK_LIBRARIES}) if(otb-module) otb_module_target_label(${APPLICATION_TARGET_NAME}) endif() # Setup build output location # Do not output in the standard lib folder where all shared libs goes. # This is to avoid the application factory to look into each and every shared lib # for itkLoad symbol if(otb-module) set_property(TARGET ${APPLICATION_TARGET_NAME} PROPERTY LIBRARY_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/otb/applications) endif() # Remove the usual 'lib' prefix to make it clear it is a plugin # and not a shared library to link against set_property(TARGET ${APPLICATION_TARGET_NAME} PROPERTY PREFIX "") # on Apple platform, a "MODULE" library gets a ".so" extension # but the ITK factory mechanism looks for ".dylib" if (APPLE) set_property(TARGET ${APPLICATION_TARGET_NAME} PROPERTY SUFFIX ".dylib") endif() # When called from the OTB build system, use OTB_INSTALL_APP_DIR if (NOT APPLICATION_INSTALL_PATH AND OTB_INSTALL_APP_DIR) set(APPLICATION_INSTALL_PATH ${OTB_INSTALL_APP_DIR}) endif() if (APPLICATION_INSTALL_PATH) if(otb-module) install(TARGETS ${APPLICATION_TARGET_NAME} EXPORT ${${otb-module}-targets} LIBRARY DESTINATION ${APPLICATION_INSTALL_PATH} COMPONENT RuntimeLibraries) else() install(TARGETS ${APPLICATION_TARGET_NAME} LIBRARY DESTINATION ${APPLICATION_INSTALL_PATH} COMPONENT RuntimeLibraries) endif() else() install(TARGETS ${APPLICATION_TARGET_NAME} LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib COMPONENT RuntimeLibraries) endif() # Generate a quickstart script in the build dir #if (NOT WIN32) # What is the path to the applications # a MODULE target is always treated as LIBRARY get_target_property(APPLICATION_BINARY_PATH ${APPLICATION_TARGET_NAME} LIBRARY_OUTPUT_DIRECTORY) if (NOT APPLICATION_BINARY_PATH) set(APPLICATION_BINARY_PATH ${CMAKE_CURRENT_BINARY_DIR}) endif() if (WIN32) set(SCRIPT_CLI_SOURCE ${OTB_SOURCE_DIR}/CMake/otbcli_app.bat.in) set(SCRIPT_CLI_INTERMEDIATE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/otbcli_${APPLICATION_NAME}.bat) set(SCRIPT_CLI_INSTALLABLE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/otbcli_${APPLICATION_NAME}.bat) else() set(SCRIPT_CLI_SOURCE ${OTB_SOURCE_DIR}/CMake/otbcli_app.sh.in) set(SCRIPT_CLI_INTERMEDIATE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/otbcli_${APPLICATION_NAME}) set(SCRIPT_CLI_INSTALLABLE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/otbcli_${APPLICATION_NAME}) endif() if (EXISTS ${SCRIPT_CLI_SOURCE}) # Generate a script in the build dir, next to the cli launcher configure_file( ${SCRIPT_CLI_SOURCE} ${SCRIPT_CLI_INTERMEDIATE} @ONLY ) # Copy it next to the application shared lib, and give executable rights file(COPY ${SCRIPT_CLI_INTERMEDIATE} DESTINATION ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) # Install a version of this script if we are inside the OTB build install(PROGRAMS ${SCRIPT_CLI_INSTALLABLE} DESTINATION ${OTB_INSTALL_RUNTIME_DIR} COMPONENT Runtime) endif() if (WIN32) set(SCRIPT_GUI_SOURCE ${OTB_SOURCE_DIR}/CMake/otbgui_app.bat.in) set(SCRIPT_GUI_INTERMEDIATE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/otbgui_${APPLICATION_NAME}.bat) set(SCRIPT_GUI_INSTALLABLE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/otbgui_${APPLICATION_NAME}.bat) else() set(SCRIPT_GUI_SOURCE ${OTB_SOURCE_DIR}/CMake/otbgui_app.sh.in) set(SCRIPT_GUI_INTERMEDIATE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/otbgui_${APPLICATION_NAME}) set(SCRIPT_GUI_INSTALLABLE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/otbgui_${APPLICATION_NAME}) endif() if (EXISTS ${SCRIPT_GUI_SOURCE}) # Generate a script in the build dir, next to the cli launcher configure_file( ${SCRIPT_GUI_SOURCE} ${SCRIPT_GUI_INTERMEDIATE} @ONLY ) # Copy it next to the application shared lib, and give executable rights file(COPY ${SCRIPT_GUI_INTERMEDIATE} DESTINATION ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) # Install a version of this script if we are inside the OTB build install(PROGRAMS ${SCRIPT_GUI_INSTALLABLE} DESTINATION ${OTB_INSTALL_RUNTIME_DIR} COMPONENT Runtime) endif() #endif() list(APPEND OTB_APPLICATIONS_NAME_LIST ${APPLICATION_NAME}) list(REMOVE_DUPLICATES OTB_APPLICATIONS_NAME_LIST) set(OTB_APPLICATIONS_NAME_LIST ${OTB_APPLICATIONS_NAME_LIST} CACHE STRING "List of all applications" FORCE) mark_as_advanced(OTB_APPLICATIONS_NAME_LIST) endmacro() macro(otb_test_application) cmake_parse_arguments(TESTAPPLICATION "" "NAME;APP" "OPTIONS;TESTENVOPTIONS;VALID" ${ARGN} ) if(otb-module) otb_add_test(NAME ${TESTAPPLICATION_NAME} COMMAND otbTestDriver ${TESTAPPLICATION_VALID} Execute $ ${TESTAPPLICATION_APP} $ ${TESTAPPLICATION_OPTIONS} -testenv ${TESTAPPLICATION_TESTENVOPTIONS}) # Be sure that the ${otb-module}-all target triggers the build of commandline launcher and testdriver add_dependencies(${otb-module}-all otbApplicationLauncherCommandLine) add_dependencies(${otb-module}-all otbTestDriver) else() add_test(NAME ${TESTAPPLICATION_NAME} COMMAND otbTestDriver ${TESTAPPLICATION_VALID} Execute $ ${TESTAPPLICATION_APP} $ ${TESTAPPLICATION_OPTIONS} -testenv ${TESTAPPLICATION_TESTENVOPTIONS}) endif() endmacro() OTB-release-5.8/CMake/OTBCheckCpp11Keywords.cmake000066400000000000000000000022631301006202600213220ustar00rootroot00000000000000include(CheckCXXSourceCompiles) unset(OTB_HAS_CXX11 CACHE) CHECK_CXX_SOURCE_COMPILES(" #ifdef _MSC_VER #if _MSC_VER <= 1700 #error Compiler is not C++11 compliant #endif #else #if __cplusplus <= 199711L #error Compiler is not C++11 compliant #endif #endif int main(int argc, char *argv[]) { return 0; } " OTB_HAS_CXX11 ) unset(OTB_CXX_HAS_UNIQUE_PTR CACHE) CHECK_CXX_SOURCE_COMPILES(" #include struct Foo { Foo() { } ~Foo() { } }; int main(int argc, char *argv[]) { std::unique_ptr p(new Foo); return 0; } " OTB_CXX_HAS_UNIQUE_PTR ) unset(OTB_CXX_HAS_OVERRIDE_SPECIFIER CACHE) CHECK_CXX_SOURCE_COMPILES(" struct A { A() { } ~A() { } virtual void foo( ) { } }; struct B : A { B() { } ~B() { } void foo( ) override { } }; int main(int argc, char *argv[]) { A* p = new B; p->foo(); return 0; } " OTB_CXX_HAS_OVERRIDE_SPECIFIER ) unset(OTB_CXX_HAS_NULLPTR CACHE) CHECK_CXX_SOURCE_COMPILES(" #include int main(int argc, char *argv[]) { int *p = nullptr; return 0; } " OTB_CXX_HAS_NULLPTR ) # try_compile( # OTB_HAS_CXX11 # ${CMAKE_CURRENT_BINARY_DIR}/CMake # ${CMAKE_SOURCE_DIR}/CMake/otbTestUniquePtr.cpp # ) OTB-release-5.8/CMake/OTBCheckTargetSystemArch.cmake000077500000000000000000000021571301006202600221440ustar00rootroot00000000000000macro(OTB_CHECK_TARGET_SYSTEM_ARCH _RESULT1 _RESULT2) set(${_RESULT1} "x64") set(${_RESULT2} TRUE) if(MSVC) execute_process( COMMAND ${CMAKE_C_COMPILER} ERROR_VARIABLE ev OUTPUT_VARIABLE ov OUTPUT_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) if("${ev}" MATCHES "x86") set(${_RESULT1} "x86") set(${_RESULT2} FALSE) endif() endif() #MSVC if(UNIX) execute_process( COMMAND uname -m ERROR_VARIABLE ev OUTPUT_VARIABLE ov OUTPUT_STRIP_TRAILING_WHITESPACE ) set(${_RESULT1} "${ov}") set(${_RESULT2} FALSE) if("${ov}" STREQUAL "x86_64") set(${_RESULT2} TRUE) endif() endif() if(WIN32 AND NOT MSVC) if(MXE_TARGET_DIR) if(MXE_TARGET_DIR MATCHES "i686") set(${_RESULT1} "i686") set(${_RESULT2} FALSE) elseif(MXE_TARGET_DIR MATCHES "x86_64") set(${_RESULT1} "x86_64") set(${_RESULT2} TRUE) endif() else() message(STATUS "MXE_TARGET_DIR not set!") endif() endif() endmacro() #call macro OTB_CHECK_TARGET_SYSTEM_ARCH(OTB_TARGET_SYSTEM_ARCH OTB_TARGET_SYSTEM_ARCH_IS_X64) OTB-release-5.8/CMake/OTBConfig.cmake.in000066400000000000000000000037451301006202600175700ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # OTBConfig.cmake - OTB CMake configuration file for external projects. # # This file is configured by OTB and used by the UseOTB.cmake module # to load OTB's settings for an external project. @OTB_CONFIG_CODE@ # The C and C++ flags added by OTB to the cmake-configured flags. set(OTB_REQUIRED_C_FLAGS "@OTB_REQUIRED_C_FLAGS@") set(OTB_REQUIRED_CXX_FLAGS "@OTB_REQUIRED_CXX_FLAGS@") set(OTB_REQUIRED_LINK_FLAGS "@OTB_REQUIRED_LINK_FLAGS@") # The OTB version number set(OTB_VERSION_MAJOR "@OTB_VERSION_MAJOR@") set(OTB_VERSION_MINOR "@OTB_VERSION_MINOR@") set(OTB_VERSION_PATCH "@OTB_VERSION_PATCH@") # OTB's CMake directory with modules OTB uses. set(OTB_CMAKE_DIR "@OTB_CONFIG_CMAKE_DIR@") # The location of the UseOTB.cmake file. set(OTB_USE_FILE "@OTB_USE_FILE@") # Whether OTB was built with shared libraries. set(OTB_BUILD_SHARED "@BUILD_SHARED_LIBS@") # List of available OTB modules. set(OTB_MODULES_ENABLED "@OTB_CONFIG_MODULES_ENABLED@") # Import OTB targets. set(OTB_CONFIG_TARGETS_FILE "@OTB_CONFIG_TARGETS_FILE@") if(NOT OTB_TARGETS_IMPORTED@OTB_CONFIG_TARGETS_CONDITION@) set(OTB_TARGETS_IMPORTED 1) include("${OTB_CONFIG_TARGETS_FILE}") endif() # Load module interface macros. include("@OTB_CONFIG_MODULE_API_FILE@") # Load application macros. include(CMakeParseArguments) include("@OTB_CONFIG_APPLI_MACROS_FILE@") # Compute set of requested modules. if(OTB_FIND_COMPONENTS) # Specific modules requested by find_package(OTB). set(OTB_MODULES_REQUESTED "${OTB_FIND_COMPONENTS}") endif() if(NOT OTB_MODULES_REQUESTED) # No specific modules requested. Use all of them. set(OTB_MODULES_REQUESTED "${OTB_MODULES_ENABLED}") endif() # Load requested modules and their dependencies into variables: # OTB_LIBRARIES = Libraries to link # OTB_INCLUDE_DIRS = Header file search path # OTB_LIBRARY_DIRS = Library search path (for outside dependencies) otb_module_config(OTB ${OTB_MODULES_REQUESTED}) OTB-release-5.8/CMake/OTBConfigVersion.cmake.in000066400000000000000000000005531301006202600211300ustar00rootroot00000000000000set(PACKAGE_VERSION "@OTB_VERSION_MAJOR@.@OTB_VERSION_MINOR@.@OTB_VERSION_PATCH@") if(NOT "${PACKAGE_FIND_VERSION}" VERSION_GREATER "${PACKAGE_VERSION}") set(PACKAGE_VERSION_COMPATIBLE 1) # compatible with older if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}") set(PACKAGE_VERSION_EXACT 1) # exact match for this version endif() endif() OTB-release-5.8/CMake/OTBGroups.cmake000066400000000000000000000123261301006202600172300ustar00rootroot00000000000000# Set a list of group names set(group_list Adapters Applications Core Detection Feature Filtering Fusion Hyperspectral IO Learning OBIA Radiometry Registration Remote Segmentation ThirdParty Visualization Wrappers ) set(Adapters_documentation "This group contains adapters class to third party software") set(Applications_documentation "This group contains the applications shipped with Orfeo TooLBox") set(Core_documentation "This group contains the core module used in Orfeo ToolBox") set(Detection_documentation "This group contains algorithms related to detection of low or high level objects") set(Feature_documentation "This group contains algorithms related to the computation of features") set(Filtering_documentation "This group contains algorithms for classical image to image processing") set(Fusion_documentation "This group contains algorithms for data fusion, including pan-sharpening") set(Hyperspectral_documentation "This group contains algorithms dedicated to hyperspectral remote sensing") set(IO_documentation "This group contains everything related to input/output") set(Learning_documentation "This group contains algorithms and frameworks related to supervised or unsupervised learning") set(OBIA_documentation "This group contains algorithms related to Object Based Image Analysis") set(Radiometry_documentation "This group contains algorithms related to the processing of image radiometry") set(Registration_documentation "This group contains algorithms related to registration of images") set(Segmentation_documentation "This group contains algorithms related to image segmentaiton") set(ThirdParty_documentation "This group contains all Orfeo ToolBox third parties") set(Visualization_documentation "This group contains Ice (visualization framework) and IceViewer (visualization tool)") set(Wrappers_documentation "This group contains the application framework and the wrappers to use it") set(Remote_documentation "This group of modules is for OTB based code that have additional third-party dependencies not bundled with the toolkit, new algorithms or implementations seeking greater exposure and adoption, algorithms that hope to eventually be integrated into the toolkit, niche algorithms with limited application, and Modules in progress that do not yet have the test coverage and cross-platform standards required by the main toolkit. The modules are OFF by default in ITK's CMake configuration. Note that these modules do get the same level of support and backwards compatibility as other modules in the toolkit.") #------------------------------------------------ # Find the modules in each group and the module name line in otb-module.cmake foreach( group ${group_list} ) set( _${group}_module_list ) file( GLOB_RECURSE _${group}_module_files ${OTB_SOURCE_DIR}/Modules/${group}/otb-module.cmake ) foreach( _module_file ${_${group}_module_files} ) file( STRINGS ${_module_file} _module_line REGEX "otb_module[ \n]*\\([ \n]*[A-Za-z0-9]*" ) string( REGEX MATCH "(\\([ \n]*)([A-Za-z0-9]*)" _module_name ${_module_line} ) set( _module_name ${CMAKE_MATCH_2} ) set( _${_module_name}_module_line ${_module_line} ) list( APPEND _${group}_module_list ${_module_name} ) endforeach() endforeach() #------------------------------------------------ # Set up Doxygen Group descriptions set( group_list_dox ) foreach(group ${group_list} ) set( group_list_dox "${group_list_dox} // ----------------------------------------------- // Group ${group} /** \\defgroup Group-${group} Group ${group} ${${group}_documentation} */\n" ) foreach(mod ${_${group}_module_list} ) set( group_list_dox "${group_list_dox} /** \\defgroup ${mod} Module ${mod} \\ingroup Group-${group} */\n" ) endforeach() endforeach() set( _content ${group_list_dox} ) configure_file( "${OTB_SOURCE_DIR}/Utilities/Doxygen/Module.dox.in" "${OTB_BINARY_DIR}/Utilities/Doxygen/Modules/OTB-AllGroups.dox" ) #------------------------------------------------ # Turn on the OTB_BUILD option for each group # Set a module name list for each group and exclude # Modules that should be OFF foreach( group ${group_list} ) set( _${group}_on_module_list ) list( LENGTH _${group}_module_list _num_modules ) set( _current_module 0 ) while( ${_current_module} LESS ${_num_modules} ) list( GET _${group}_module_list ${_current_module} _module_name ) if( NOT OTB_MODULE_${_module_name}_EXCLUDE_FROM_DEFAULT ) list( APPEND _${group}_on_module_list ${_module_name} ) endif() math( EXPR _current_module "${_current_module} + 1" ) endwhile() endforeach() if("$ENV{DASHBOARD_TEST_FROM_CTEST}" STREQUAL "") # developer build option(OTBGroup_Core "Request building core modules" ON) endif() foreach( group ${group_list}) option(OTBGroup_${group} "Request building ${group} modules" OFF) if (OTBGroup_${group}) foreach (otb-module ${_${group}_on_module_list} ) list(APPEND OTB_MODULE_${otb-module}_REQUEST_BY OTBGroup_${group}) endforeach() endif() # Hide group options if building all modules anyway. if(OTB_BUILD_DEFAULT_MODULES) set_property(CACHE OTBGroup_${group} PROPERTY TYPE INTERNAL) else() set_property(CACHE OTBGroup_${group} PROPERTY TYPE BOOL) endif() endforeach() OTB-release-5.8/CMake/OTBManageLargeInputPaths.cmake000066400000000000000000000044531301006202600221360ustar00rootroot00000000000000# -------------------------------------------------------------------------------- # Manage PHR data input if(OTB_DATA_USE_LARGEINPUT) set(GenericTestPHR_DATA_INPUTS ${GenericTestPHR_DATA_INPUTS} ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES-PRE/TLSE_JP2_ORTHO_DIMAPv2_PMS-N_lossy_12bits/IMG_PHR1Z_PMS_N_001/IMG_PHR1A_PMS-N_201006181052297_ORT_IPU_20111011_0619-001_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES-PRE/TLSE_TIFF_ORTHO_DIMAPv2_MS_lossless_8bits/IMG_PHR1A_MS_002/IMG_PHR1A_MS_201006181052297_ORT_IPU_20111109_7807-004_R1C1.TIF ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES-PRE/TLSE_TIFF_PRIMARY_DIMAPv2_MS_lossly_12bits/IMG_PHR1A_MS_002/IMG_PHR1A_MS_201006181052297_SEN_IPU_20111025_3077-004_R1C1.TIF ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R2C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES/LASVEGAS_JP2_DIMAPv1_PRIMARY_PMS_lossless_12bits/IMGPHR_PHR1A_SENSOR_20120217_IPU_20120217_5374-001_V1/IMG_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES/PARIS_JP2_DIMAPv1_ORTHO_PMS_lossless_12bits/IMGPHR_PHR1A_ORTHO_20120502_IPU_20120430_6347-003_V1/IMG_R1C1.JP2 ) set(GenericTestPHR_DATA_TYPES ${GenericTestPHR_DATA_TYPES} SIMUL_PHR_JP2_ORTHO_DIMAPv2_PMS-N_lossy_12bits SIMUL_PHR_TIFF_ORTHO_DIMAPv2_MS_lossless_8bits SIMUL_PHR_TIFF_PRIMARY_DIMAPv2_MS_lossy_12bits PHR_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits PHR_JP2_DIMAPv1_PRIMARY_PMS_lossless_12bits PHR_JP2_DIMAPv1_ORTHO_PMS_lossless_12bits ) set(GenericTestSPOT6_DATA_INPUTS ${GenericTestSPOT6_DATA_INPUTS} ${OTB_DATA_LARGEINPUT_ROOT}/SPOT6/SPOT6_Ortho_Bundle_12_bits/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201306031242000_ORT_816005101_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/SPOT6/SPOT6_Ortho_Pan-sharpened_12_bits/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_PMS_001_A/IMG_SPOT6_PMS_201305251604372_ORT_816009101_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/SPOT6/SPOT6_Primary_Bundle_12_bits/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201211100138085_SEN_816007101_R1C1.JP2 ) set(GenericTestSPOT6_DATA_TYPES ${GenericTestSPOT6_DATA_TYPES} SPOT6_Ortho_Bundle_12_bits SPOT6_Ortho_Pan-sharpened_12_bits SPOT6_Primary_Bundle_12_bits ) endif() OTB-release-5.8/CMake/OTBModuleAPI.cmake000066400000000000000000000053351301006202600175320ustar00rootroot00000000000000 #----------------------------------------------------------------------------- # Private helper macros. macro(_otb_module_use_recurse mod) if(NOT ${dep}_USED) set(${mod}_USED 1) otb_module_load("${mod}") foreach(dep IN LISTS ${mod}_DEPENDS) _otb_module_use_recurse(${dep}) endforeach() if(${mod}_INCLUDE_DIRS) include_directories(${${mod}_INCLUDE_DIRS}) endif() if(${mod}_LIBRARY_DIRS) link_directories(${${mod}_LIBRARY_DIRS}) endif() endif() endmacro() macro(_otb_module_config_recurse ns mod) if(NOT _${ns}_${mod}_USED) set(_${ns}_${mod}_USED 1) list(APPEND _${ns}_USED_MODULES ${mod}) otb_module_load("${mod}") list(APPEND ${ns}_LIBRARIES ${${mod}_LIBRARIES}) list(APPEND ${ns}_INCLUDE_DIRS ${${mod}_INCLUDE_DIRS}) list(APPEND ${ns}_LIBRARY_DIRS ${${mod}_LIBRARY_DIRS}) foreach(dep IN LISTS ${mod}_DEPENDS) _otb_module_config_recurse("${ns}" "${dep}") endforeach() endif() endmacro() #----------------------------------------------------------------------------- # Public interface macros. # otb_module_load() # # Loads variables describing the given module: # _LOADED = True if the module has been loaded # _DEPENDS = List of dependencies on other modules # _LIBRARIES = Libraries to link # _INCLUDE_DIRS = Header search path # _LIBRARY_DIRS = Library search path (for outside dependencies) macro(otb_module_load mod) if(NOT ${mod}_LOADED) include("${OTB_MODULES_DIR}/${mod}.cmake" OPTIONAL) if(NOT ${mod}_LOADED) message(FATAL_ERROR "No such module: \"${mod}\"") endif() endif() endmacro() # otb_module_config( [modules...]) # # Configures variables describing the given modules and their dependencies: # _LIBRARIES = Libraries to link # _INCLUDE_DIRS = Header search path # _LIBRARY_DIRS = Library search path (for outside dependencies) # Do not name a module as the namespace. macro(otb_module_config ns) set(${ns}_LIBRARIES "") set(${ns}_INCLUDE_DIRS "") set(${ns}_LIBRARY_DIRS "") set(_${ns}_USED_MODULES "") foreach(mod ${ARGN}) _otb_module_config_recurse("${ns}" "${mod}") endforeach() foreach(mod ${_${ns}_USED_MODULES}) unset(_${ns}_${mod}_USED) endforeach() unset(_${ns}_USED_MODULES) foreach(v ${ns}_LIBRARIES ${ns}_INCLUDE_DIRS ${ns}_LIBRARY_DIRS) if(${v}) list(REMOVE_DUPLICATES ${v}) endif() endforeach() endmacro() # otb_module_use([modules...]) # # Adds include directories and link directories for the given modules and # their dependencies. macro(otb_module_use) foreach(mod ${ARGN}) _otb_module_use_recurse("${mod}") endforeach() endmacro() OTB-release-5.8/CMake/OTBModuleCPPCheckTest.cmake000066400000000000000000000017041301006202600213350ustar00rootroot00000000000000macro( otb_module_cppcheck_test _name ) if( EXISTS "${${_name}_SOURCE_DIR}/src" ) file( GLOB _cxx_files *.cxx ) list( LENGTH _cxx_files _num_cxx_files ) # let's make sure there are actually cxx files in the src dir if( ${_num_cxx_files} GREATER 0 ) add_cppcheck_dir( ${_name}_SRC_DIR # _name "${${_name}_SOURCE_DIR}/src" #_dir ${${_name}_SOURCE_DIR}/include #_include_dirs VERBOSE FORCE ALL ) endif() endif() if( EXISTS "${${_name}_SOURCE_DIR}/test" ) file( GLOB _cxx_files *.cxx ) list( LENGTH _cxx_files _num_cxx_files ) # let's make sure there are actually cxx files in the src dir if( ${_num_cxx_files} GREATER 0 ) add_cppcheck_dir( ${_name}_TEST_DIR # _name "${${_name}_SOURCE_DIR}/test" #_dir ${${_name}_SOURCE_DIR}/include #_include_dirs VERBOSE FORCE ALL ) endif() endif() endmacro() OTB-release-5.8/CMake/OTBModuleDoxygen.cmake000066400000000000000000000036221301006202600205330ustar00rootroot00000000000000# this macro generates 2 files for a given module ${_name} # ${_name}.dox file which contains the actual doxygen documentation # ${_name}.dot file which defines the local dependency as graph # which will be then processed by dot # python is needed to verify the presence of the module name in the doxygen header # Don't require it to not force the developers to install python to be able to build # OTB. The tests will simply not be run if python is not available. find_package(PythonInterp) macro( otb_module_doxygen _name ) # _content defines the content of the ${_name}.dox file set( _content "/**\n" ) set( _content "${_content} \\defgroup ${_name} Module ${_name} \n" ) set( _content "${_content} ${OTB_MODULE_${_name}_DESCRIPTION} \n" ) set( _content "${_content} \\par Dependencies:\n" ) # _dotcontent defines the content of the ${_name}.dot set( _dotcontent "graph \"${_name}\" { \n") foreach( d ${OTB_MODULE_${_name}_DEPENDS} ) set( _content "${_content} \\li \\ref ${d} \n" ) set( _dotcontent "${_dotcontent} \"${_name}\" -- \"${d}\"; \n" ) endforeach() set( _dotcontent "${_dotcontent} }") # add the image that will be generated by dot based on the defined graph # here set( _content "${_content} \\dot \n" ) set( _content "${_content} ${_dotcontent} \n" ) set( _content "${_content} \\enddot \n" ) set( _content "${_content} */\n" ) if(ITK_SOURCE_DIR) configure_file( "${OTB_SOURCE_DIR}/Utilities/Doxygen/Module.dox.in" "${OTB_BINARY_DIR}/Utilities/Doxygen/Modules/${_name}.dox" @ONLY ) endif() if(NOT ${_name}_THIRD_PARTY AND EXISTS ${${_name}_SOURCE_DIR}/include) if(PYTHON_EXECUTABLE) otb_add_test(NAME ${_name}InDoxygenGroup COMMAND ${PYTHON_EXECUTABLE} "${OTB_SOURCE_DIR}/Utilities/Doxygen/mcdoc.py" check ${_name} ${${_name}_SOURCE_DIR}/include) otb_memcheck_ignore(${_name}InDoxygenGroup) endif() endif() endmacro() OTB-release-5.8/CMake/OTBModuleEnablement.cmake000066400000000000000000000350671301006202600212000ustar00rootroot00000000000000# This script sorts out the module dependencies, provides user options for customizing # the list of modules to be built, and enables modules accordingly. # Load the module DAG. set(OTB_MODULES_ALL) file(GLOB meta RELATIVE "${OTB_SOURCE_DIR}" "${OTB_SOURCE_DIR}/*/*/*/otb-module.cmake" # grouped modules ) foreach(f ${meta}) include(${OTB_SOURCE_DIR}/${f}) list(APPEND OTB_MODULES_ALL ${otb-module}) get_filename_component(${otb-module}_BASE ${f} PATH) set(${otb-module}_SOURCE_DIR ${OTB_SOURCE_DIR}/${${otb-module}_BASE}) set(${otb-module}_BINARY_DIR ${OTB_BINARY_DIR}/${${otb-module}_BASE}) if(BUILD_TESTING AND EXISTS ${${otb-module}_SOURCE_DIR}/test) list(APPEND OTB_MODULES_ALL ${otb-module-test}) set(${otb-module-test}_SOURCE_DIR ${${otb-module}_SOURCE_DIR}/test) set(${otb-module-test}_BINARY_DIR ${${otb-module}_BINARY_DIR}/test) set(${otb-module-test}_IS_TEST 1) set(${otb-module}_TESTED_BY ${otb-module-test}) set(${otb-module-test}_TESTS_FOR ${otb-module}) endif() # Reject bad dependencies. string(REGEX MATCHALL ";(OTBDeprecated|OTBReview|OTBIntegratedTest);" _bad_deps ";${OTB_MODULE_${otb-module}_DEPENDS};${OTB_MODULE_${otb-module-test}_DEPENDS};") foreach(dep ${_bad_deps}) if(NOT "${otb-module}" MATCHES "^(${dep}|OTBIntegratedTest)$") message(FATAL_ERROR "Module \"${otb-module}\" loaded from\n" " ${${otb-module}_BASE}/otb-module.cmake\n" "may not depend on module \"${dep}\".") endif() endforeach() endforeach() # Clear variables set later in each module. unset(otb-module) unset(otb-module-test) # Validate the module DAG. macro(otb_module_check otb-module _needed_by stack) if(NOT OTB_MODULE_${otb-module}_DECLARED) message(FATAL_ERROR "No such module \"${otb-module}\" needed by \"${_needed_by}\"") endif() if(check_started_${otb-module} AND NOT check_finished_${otb-module}) # We reached a module while traversing its own dependencies recursively. set(msg "") foreach(entry ${stack}) set(msg " ${entry} =>${msg}") if("${entry}" STREQUAL "${otb-module}") break() endif() endforeach() message(FATAL_ERROR "Module dependency cycle detected:\n ${msg} ${otb-module}") elseif(NOT check_started_${otb-module}) # Traverse dependencies of this module. Mark the start and finish. set(check_started_${otb-module} 1) foreach(dep IN LISTS OTB_MODULE_${otb-module}_DEPENDS) otb_module_check(${dep} ${otb-module} "${otb-module};${stack}") endforeach() foreach(dep IN LISTS OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS) otb_module_check(${dep} ${otb-module} "${otb-module};${stack}") endforeach() set(check_finished_${otb-module} 1) endif() endmacro() foreach(otb-module ${OTB_MODULES_ALL}) otb_module_check("${otb-module}" "" "") endforeach() #---------------------------------------------------------------------- # Construct direct dependees (first-level) of each module foreach(otb-module1 ${OTB_MODULES_ALL}) foreach(otb-module2 ${OTB_MODULES_ALL}) list(FIND OTB_MODULE_${otb-module2}_DEPENDS ${otb-module1} _find_output) if( NOT ${_find_output} EQUAL -1 ) list(APPEND OTB_MODULE_${otb-module1}_DEPENDEES ${otb-module2}) endif() endforeach() endforeach() #---------------------------------------------------------------------- # Provide an option to build the default set of OTB modules. Only a small # set of modules are excluded and they have the "EXCLUDE_FROM_DEFAULT" tags in # their module definition file (otb-module.cmake). # # However, if you choose to customize which modules will be built, OTB also # allows you to manually enable modules by using either individual Module_* # options or OTBGroup_* options. option(OTB_BUILD_DEFAULT_MODULES "Build the default OTB modules." ON) #---------------------------------------------------------------------- # Provide an option to build the tests of dependencies of a module when # BUILD_TESTING is ON. option(OTB_BUILD_ALL_MODULES_FOR_TESTS "Build the tests of module dependencies." OFF) mark_as_advanced(OTB_BUILD_ALL_MODULES_FOR_TESTS) # To maintain backward compatibility if(DEFINED OTB_BUILD_ALL_MODULES) message(WARNING "OTB_BUILD_ALL_MODULES is deprecated, please remove this entry from the CMake " "cache (edit the CMakeCache.txt file located in the top level of the OTB build " "tree directly or via the CMake GUI), and use OTB_BUILD_DEFAULT_MODULES instead.") set(OTB_BUILD_DEFAULT_MODULES ${OTB_BUILD_ALL_MODULES} CACHE BOOL "Build the default OTB modules." FORCE) endif() # Provide module selections by groups include(${OTB_SOURCE_DIR}/CMake/OTBGroups.cmake) # Provide an option for each module. foreach(otb-module ${OTB_MODULES_ALL}) if(NOT ${otb-module}_IS_TEST) option(Module_${otb-module} "Request building ${otb-module}" OFF) mark_as_advanced(Module_${otb-module}) if(OTB_MODULE_${otb-module}_EXCLUDE_FROM_DEFAULT) set(OTB_MODULE_${otb-module}_IN_DEFAULT 0) else() set(OTB_MODULE_${otb-module}_IN_DEFAULT ${OTB_BUILD_DEFAULT_MODULES}) endif() endif() endforeach() # Follow dependencies. macro(otb_module_enable otb-module _needed_by) if(NOT Module_${otb-module}) if(NOT ${otb-module}_TESTED_BY OR NOT "x${_needed_by}" STREQUAL "x${${otb-module}_TESTED_BY}") list(APPEND OTB_MODULE_${otb-module}_NEEDED_BY ${_needed_by}) endif() endif() if(NOT ${otb-module}_ENABLED) set(${otb-module}_ENABLED 1) foreach(dep IN LISTS OTB_MODULE_${otb-module}_DEPENDS) otb_module_enable(${dep} ${otb-module}) endforeach() if(${otb-module}_TESTED_BY AND (OTB_BUILD_DEFAULT_MODULES OR OTB_BUILD_ALL_MODULES_FOR_TESTS OR Module_${otb-module})) otb_module_enable(${${otb-module}_TESTED_BY} "") endif() endif() endmacro() foreach(otb-module ${OTB_MODULES_ALL}) if(Module_${otb-module} OR OTB_MODULE_${otb-module}_IN_DEFAULT) otb_module_enable("${otb-module}" "") elseif(OTB_MODULE_${otb-module}_REQUEST_BY) otb_module_enable("${otb-module}" "${OTB_MODULE_${otb-module}_REQUEST_BY}") endif() endforeach() # Filter out the ENABLED modules using the OTB_USE_XXX options macro(otb_module_disable otb-module _disabled_by) if(NOT ${otb-module}_IS_TEST AND ${otb-module}_ENABLED) message(STATUS "Disabled ${otb-module} because ${_disabled_by} is OFF") endif() set(${otb-module}_ENABLED 0) foreach(otb-module-dependee ${OTB_MODULE_${otb-module}_DEPENDEES}) otb_module_disable(${otb-module-dependee} ${_disabled_by}) endforeach() endmacro() foreach(otb-module ${OTB_MODULES_ALL}) if(OTB_MODULE_${otb-module}_ACTIVATION_OPTION AND NOT ${OTB_MODULE_${otb-module}_ACTIVATION_OPTION}) otb_module_disable("${otb-module}" "${OTB_MODULE_${otb-module}_ACTIVATION_OPTION}") endif() endforeach() # Build final list of enabled modules. set(OTB_MODULES_ENABLED "") set(OTB_MODULES_DISABLED "") foreach(otb-module ${OTB_MODULES_ALL}) if(${otb-module}_ENABLED) list(APPEND OTB_MODULES_ENABLED ${otb-module}) # We will sort modules according to their dependency graph, # to enable them in order. To solve the modules dependency graph, # we join both DEPENDS and OPTIONAL_DEPENDS (if enabled) set(OTB_MODULE_${otb-module}_DEPENDS_FOR_SORT "") list(APPEND OTB_MODULE_${otb-module}_DEPENDS_FOR_SORT ${OTB_MODULE_${otb-module}_DEPENDS}) foreach(opt-dep ${OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS}) if(${opt-dep}_ENABLED) list(APPEND OTB_MODULE_${otb-module}_DEPENDS_FOR_SORT ${opt-dep}) endif() endforeach() else() list(APPEND OTB_MODULES_DISABLED ${otb-module}) endif() endforeach() list(SORT OTB_MODULES_ENABLED) # Deterministic order. list(SORT OTB_MODULES_DISABLED) # Deterministic order. # Order list to satisfy dependencies. include(CMake/TopologicalSort.cmake) topological_sort(OTB_MODULES_ENABLED OTB_MODULE_ _DEPENDS_FOR_SORT) # TODO : shall we set up CPack ? # # # # Set up CPack support # # # set(OTB_MODULES_DISABLED_CPACK ) # foreach(m ${OTB_MODULES_DISABLED}) # list(APPEND OTB_MODULES_DISABLED_CPACK "/${m}/") # endforeach() # set(CPACK_SOURCE_IGNORE_FILES # "${OTB_MODULES_DISABLED_CPACK};/\\\\.git") # # set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Insight Toolkit version ${OTB_VERSION_MAJOR}") # set(CPACK_PACKAGE_VENDOR "ISC") # set(CPACK_PACKAGE_VERSION_MAJOR "${OTB_VERSION_MAJOR}") # set(CPACK_PACKAGE_VERSION_MINOR "${OTB_VERSION_MINOR}") # set(CPACK_PACKAGE_VERSION_PATCH "${OTB_VERSION_PATCH}") # set(CPACK_PACKAGE_INSTALL_DIRECTORY "OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}") # set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.txt") # set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") # # include(CPack) # Report what will be built. set(_enabled_modules "${OTB_MODULES_ENABLED}") list(SORT _enabled_modules) foreach(otb-module ${_enabled_modules}) if(NOT ${otb-module}_IS_TEST) if(Module_${otb-module}) set(_reason ", requested by Module_${otb-module}") elseif(OTB_MODULE_${otb-module}_IN_DEFAULT) set(_reason ", requested by OTB_BUILD_DEFAULT_MODULES") else() set(_reason ", needed by [${OTB_MODULE_${otb-module}_NEEDED_BY}]") endif() message(STATUS "Enabled ${otb-module}${_reason}.") endif() endforeach() # Hide options for modules that will build anyway. foreach(otb-module ${OTB_MODULES_ALL}) if(NOT ${otb-module}_IS_TEST) if(OTB_MODULE_${otb-module}_IN_DEFAULT OR OTB_MODULE_${otb-module}_NEEDED_BY) set_property(CACHE Module_${otb-module} PROPERTY TYPE INTERNAL) else() set_property(CACHE Module_${otb-module} PROPERTY TYPE BOOL) endif() endif() endforeach() #----------------------------------------------------------------------------- # Construct an in-build-order list of "CDash subproject" modules from the # list of enabled modules: set(OTB_CDASH_SUBPROJECT_MODULES) if(OTB_GENERATE_PROJECT_XML OR OTB_GENERATE_SUBPROJECTS_CMAKE) # Since a "CDash subproject" for OTB logically contains both a non-test # module and its corresponding test module, the subproject order must take # both modules into account. The subprojects in this list are named after # the non-test modules in the enabled modules list. But the ordering of # these subprojects use the dependencies of the modules *and* their test # modules foreach(module ${OTB_MODULES_ENABLED}) if(${module}_TESTED_BY) # module that HAS a test module: skip for now... will be added as a # subproject later, in the slot when its corresponding "-test" module # is encountered elseif(${module}_TESTS_FOR) # this is a test module... *now* list the module which it tests as # the subproject name: list(APPEND OTB_CDASH_SUBPROJECT_MODULES ${${module}_TESTS_FOR}) else() # a module that is not a test module, and has no tested by... # is just a module-only subproject with no test module: list(APPEND OTB_CDASH_SUBPROJECT_MODULES ${module}) endif() endforeach() endif() #----------------------------------------------------------------------------- # Write a Project.xml file to send the description of the submodules and # their dependencies up to CDash: if(OTB_GENERATE_PROJECT_XML) set(filename "${OTB_BINARY_DIR}/${main_project_name}.Project.xml") set(xml "\n") set(xml "${xml}\n") foreach(module ${OTB_CDASH_SUBPROJECT_MODULES}) if(${module}_IS_TEST) message(FATAL_ERROR "unexpected: subproject names should not be test modules module='${module}' tests_for='${${module}_TESTS_FOR}'") endif() set(xml "${xml} \n") set(deps "") set(dep_list ${OTB_MODULE_${module}_DEPENDS}) if(${module}_TESTED_BY) list(APPEND dep_list ${OTB_MODULE_${${module}_TESTED_BY}_DEPENDS}) if(dep_list) list(SORT dep_list) endif() endif() foreach(dep ${dep_list}) if(NOT ${dep}_IS_TEST AND NOT "${module}" STREQUAL "${dep}") set(xml "${xml} \n") endif() endforeach() set(xml "${xml} \n") endforeach() set(xml "${xml}\n") # Always write out "${filename}.in": file(WRITE ${filename}.in "${xml}") # Use configure_file so "${filename}" only changes when its content changes: configure_file(${filename}.in ${filename} COPYONLY) endif() #----------------------------------------------------------------------------- # Write the list of enabled modules out for ctest scripts to use as an # in-order subproject list: if(OTB_GENERATE_SUBPROJECTS_CMAKE) set(filename "${OTB_BINARY_DIR}/${main_project_name}.SubProjects.cmake") set(s "# Generated by CMake, do not edit!\n") set(s "${s}set(otb_subprojects\n") foreach(otb-module ${OTB_CDASH_SUBPROJECT_MODULES}) if(${otb-module}_IS_TEST) message(FATAL_ERROR "unexpected: subproject names should not be test modules otb-module='${otb-module}' tests_for='${${otb-module}_TESTS_FOR}'") endif() set(s "${s} \"${otb-module}\"\n") endforeach() set(s "${s})\n") # Always write out "${filename}.in": file(WRITE ${filename}.in "${s}") # Use configure_file so "${filename}" only changes when its content changes: configure_file(${filename}.in ${filename} COPYONLY) endif() #----------------------------------------------------------------------------- if(NOT OTB_MODULES_ENABLED) message(WARNING "No modules enabled!") file(REMOVE "${OTB_BINARY_DIR}/OTBTargets.cmake") return() endif() file(WRITE "${OTB_BINARY_DIR}/OTBTargets.cmake" "# Generated by CMake, do not edit!") macro(init_module_vars) verify_otb_module_is_set() set(${otb-module}-targets OTBTargets) set(${otb-module}-targets-install "${OTB_INSTALL_PACKAGE_DIR}/OTBTargets.cmake") set(${otb-module}-targets-build "${OTB_BINARY_DIR}/OTBTargets.cmake") endmacro() # Build all modules. foreach(otb-module ${OTB_MODULES_ENABLED}) if(NOT ${otb-module}_IS_TEST) init_module_vars() endif() include("${${otb-module}_SOURCE_DIR}/otb-module-init.cmake" OPTIONAL) add_subdirectory("${${otb-module}_SOURCE_DIR}" "${${otb-module}_BINARY_DIR}") endforeach() #---------------------------------------------------------------------------- get_property(CTEST_CUSTOM_MEMCHECK_IGNORE GLOBAL PROPERTY CTEST_CUSTOM_MEMCHECK_IGNORE) get_property(CTEST_CUSTOM_TESTS_IGNORE GLOBAL PROPERTY CTEST_CUSTOM_TESTS_IGNORE) configure_file(CMake/CTestCustom.cmake.in CTestCustom.cmake @ONLY) #----------------------------------------------------------------------------- # Create list of available modules and libraries. set(OTB_CONFIG_MODULES_ENABLED "") foreach(otb-module ${OTB_MODULES_ENABLED}) if(NOT ${otb-module}_IS_TEST) list(APPEND OTB_CONFIG_MODULES_ENABLED ${otb-module}) endif() endforeach() OTB-release-5.8/CMake/OTBModuleExternal.cmake000066400000000000000000000067171301006202600207100ustar00rootroot00000000000000#Adapted from ITKModuleExternal.cmake # This file ensures the appropriate variables are set up for a project extending # OTB before including OTBModuleMacros. This is the preferred way to build an # OTB module outside of the OTB source tree. if(NOT OTB_FOUND) message(FATAL_ERROR "OTB must be found before module macros can be used.") endif() if(NOT OTB_VERSION VERSION_GREATER "5.2") message(FATAL_ERROR "Requires OTB 5.4 or later to work.") endif() if(NOT EXISTS ${OTB_CMAKE_DIR}/OTBModuleMacros.cmake) message(FATAL_ERROR "Modules can only be built against an OTB build tree; they cannot be built against an OTB install tree.") endif() # Setup build locations. if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OTB_DIR}/bin) endif() if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OTB_DIR}/lib) endif() if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OTB_DIR}/lib) endif() # OTB installation structure if(NOT OTB_INSTALL_RUNTIME_DIR) set(OTB_INSTALL_RUNTIME_DIR bin) endif() if(NOT OTB_INSTALL_LIBRARY_DIR) set(OTB_INSTALL_LIBRARY_DIR lib) endif() if(NOT OTB_INSTALL_ARCHIVE_DIR) set(OTB_INSTALL_ARCHIVE_DIR lib) endif() if(NOT OTB_INSTALL_INCLUDE_DIR) set(OTB_INSTALL_INCLUDE_DIR include/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}) endif() if(NOT OTB_INSTALL_DATA_DIR) set(OTB_INSTALL_DATA_DIR share/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}) endif() if(NOT OTB_INSTALL_DOC_DIR) set(OTB_INSTALL_DOC_DIR share/doc/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}) endif() if(NOT OTB_INSTALL_PACKAGE_DIR) set(OTB_INSTALL_PACKAGE_DIR "lib/cmake/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}") endif() # Use OTB's flags. set(CMAKE_C_FLAGS "${OTB_REQUIRED_C_FLAGS} ${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} ${CMAKE_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}") set(CMAKE_SHARED_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}") option(BUILD_SHARED_LIBS "Build OTB with shared libraries." ${OTB_BUILD_SHARED}) # Add the OTB_MODULES_DIR to the CMAKE_MODULE_PATH and then use the binary # directory for the project to write out new ones to. if(OTB_MODULES_DIR) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${OTB_MODULES_DIR}) endif() set(OTB_MODULES_DIR "${OTB_DIR}/${OTB_INSTALL_PACKAGE_DIR}/Modules") #include(OTBExternalData) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt) include(CTest) include(OTBModuleTest) endif() include(OTBModuleMacros) include(otb-module.cmake) set(${otb-module}-targets ${otb-module}Targets) set(${otb-module}-targets-install "\${OTB_INSTALL_PREFIX}/${OTB_INSTALL_PACKAGE_DIR}/${otb-module}Targets.cmake") set(${otb-module}_TARGETS_FILE_INSTALL "${${otb-module}-targets-install}") set(${otb-module}-targets-build "${OTB_DIR}/${OTB_INSTALL_PACKAGE_DIR}/Modules/${otb-module}Targets.cmake") set(${otb-module}_TARGETS_FILE_BUILD "${${otb-module}-targets-build}") otb_module_impl() if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src/CMakeLists.txt AND NOT ${otb-module}_NO_SRC AND "${${otb-module}-targets}") install(EXPORT ${${otb-module}-targets} DESTINATION "${OTB_INSTALL_PACKAGE_DIR}/Modules" COMPONENT Development) endif() set(OTB_TEST_OUTPUT_DIR "${CMAKE_BINARY_DIR}/Testing/Temporary") if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt") add_subdirectory(test) endif() OTB-release-5.8/CMake/OTBModuleHeaderTest.cmake000066400000000000000000000133011301006202600211410ustar00rootroot00000000000000# This checks HeaderTest's in each module. A HeaderTest can be found in the # module 'test' directory in a file otbHeaderTest.cxx. This # contains a null main(), but includes all the classes in the module. The # primary purpose of this test is to make sure there are not missing module # dependencies. # This does not force the developer to install python to be able to build OTB. # The tests will simply not be run if python is unavailable. find_package(PythonInterp) # The maximum number of headers in a test. This helps limit memory issues, # and the cppcheck tests. However, if this is not unity, there is a slight # chance that problems may be hidden. For a complete header check, set to "1". set( MAXIMUM_NUMBER_OF_HEADERS 35 CACHE STRING "The number of headers in a HeaderTest code." ) mark_as_advanced( MAXIMUM_NUMBER_OF_HEADERS ) add_custom_target( OTBHeaderTests ${CMAKE_COMMAND} --build ${OTB_BINARY_DIR} COMMENT "Regenerating and building the header tests." ) SET(BANNED_HEADERS) if(NOT OTB_USE_OPENCV) SET(BANNED_HEADERS "${BANNED_HEADERS} otbDecisionTreeMachineLearningModelFactory.h otbDecisionTreeMachineLearningModel.h otbKNearestNeighborsMachineLearningModelFactory.h otbKNearestNeighborsMachineLearningModel.h otbRandomForestsMachineLearningModelFactory.h otbRandomForestsMachineLearningModel.h otbSVMMachineLearningModelFactory.h otbSVMMachineLearningModel.h otbGradientBoostedTreeMachineLearningModelFactory.h otbGradientBoostedTreeMachineLearningModel.h otbBoostMachineLearningModelFactory.h otbBoostMachineLearningModel.h otbNeuralNetworkMachineLearningModelFactory.h otbNeuralNetworkMachineLearningModel.h otbNormalBayesMachineLearningModelFactory.h otbNormalBayesMachineLearningModel.h otbRequiresOpenCVCheck.h otbOpenCVUtils.h otbCvRTreesWrapper.h") endif() if(NOT OTB_USE_SHARK) SET(BANNED_HEADERS "${BANNED_HEADERS} otbSharkRandomForestsMachineLearningModel.h otbSharkRandomForestsMachineLearningModel.txx otbSharkUtils.h otbRequiresSharkCheck.h otbSharkRandomForestsMachineLearningModelFactory.h") endif() if(NOT OTB_USE_LIBSVM) SET(BANNED_HEADERS "${BANNED_HEADERS} otbLibSVMMachineLearningModel.h otbLibSVMMachineLearningModelFactory.h") endif() if(NOT OTB_USE_SIFTFAST) SET(BANNED_HEADERS "${BANNED_HEADERS} otbSiftFastImageFilter.h") endif() # ************ ADD YOUR BANNED HEADERS HERE ************ #if(CONDITION) # SET(BANNED_HEADERS "${BANNED_HEADERS} BANNED-HEADER1.h BANNED-HEADER2.h") #endif() macro( otb_module_headertest _name ) if( NOT ${_name}_THIRD_PARTY AND EXISTS ${${_name}_SOURCE_DIR}/include AND PYTHON_EXECUTABLE AND NOT (PYTHON_VERSION_STRING VERSION_LESS 2.6) AND NOT (${_name} STREQUAL OTBTestKernel) AND NOT (CMAKE_GENERATOR MATCHES "^Visual Studio 10.*")) # Count how many tests we are going to get, and put the source files in # the list _outputs. # WARNING: This code is highly coupled with the BuildHeaderTest.py file # below. Before making any logic changes here, make sure that script is not # effected. set( _include ${${_name}_SOURCE_DIR}/include ) file( GLOB _h_files ${_include}/*.h ) file( GLOB _hxx_files ${_include}/*.hxx ) set( _header_files ${_h_files} ${_hxx_files} ) list( LENGTH _h_files _num_headers ) set( _outputs ${${_name}_BINARY_DIR}/test/${_name}HeaderTest1.cxx ) set( _test_num 1 ) set( _available_headers "${MAXIMUM_NUMBER_OF_HEADERS}" ) while( ${_num_headers} GREATER ${_available_headers} ) math( EXPR _test_num "${_test_num} + 1" ) math( EXPR _available_headers "${_available_headers} + ${MAXIMUM_NUMBER_OF_HEADERS}" ) list( APPEND _outputs ${${_name}_BINARY_DIR}/test/${_name}HeaderTest${_test_num}.cxx ) endwhile() add_custom_target( ${_name}HeaderTestClean ${CMAKE_COMMAND} -E remove ${_outputs} ) add_dependencies( OTBHeaderTests ${_name}HeaderTestClean ) # We check to see if the headers are changed. If so, remove the header test # source files so they are regenerated. if( ${CMAKE_VERSION} VERSION_GREATER 2.8.6 ) # for string( MD5 set( _headers_list_md5 "${${_name}_BINARY_DIR}/test/CMakeFiles/HeadersList.md5" ) list( SORT _header_files ) string( MD5 _new_md5 "${_header_files}" ) set( _regenerate_sources FALSE ) if( NOT EXISTS "${_headers_list_md5}" ) set( _regenerate_sources TRUE ) else() file( READ "${_headers_list_md5}" _old_md5 ) if( NOT ("${_old_md5}" STREQUAL "${_new_md5}")) set( _regenerate_sources TRUE ) endif() endif() file( WRITE "${_headers_list_md5}" "${_new_md5}" ) if( ${_regenerate_sources} ) file( REMOVE ${_outputs} ) endif() endif() set( _test_num 1 ) foreach( _header_test_src ${_outputs} ) get_filename_component( _test_name ${_header_test_src} NAME_WE ) add_custom_command( OUTPUT ${_header_test_src} COMMAND ${PYTHON_EXECUTABLE} ${OTB_CMAKE_DIR}/../Utilities/Maintenance/BuildHeaderTest.py ${_name} ${${_name}_SOURCE_DIR} ${${_name}_BINARY_DIR} ${MAXIMUM_NUMBER_OF_HEADERS} ${_test_num} ${BANNED_HEADERS} ) add_executable( ${_test_name} ${_header_test_src} ) target_link_libraries( ${_test_name} OTBCommon ) if (${_name}_LIBRARIES) # OTBBoostAdapters depends only on OTBBoost, # and OTBBoost_LIBRARIES can be empty, so check for it add_dependencies(${_test_name} ${${_name}_LIBRARIES}) # this target_link should be needed only on WIN32 target_link_libraries(${_test_name} ${${_name}_LIBRARIES}) endif() add_dependencies(${_name}-all ${_test_name}) math( EXPR _test_num "${_test_num} + 1" ) endforeach() endif() endmacro() OTB-release-5.8/CMake/OTBModuleInfo.cmake.in000066400000000000000000000004201301006202600204070ustar00rootroot00000000000000set(@otb-module@_LOADED 1) set(@otb-module@_DEPENDS "@otb-module-DEPENDS@") set(@otb-module@_LIBRARIES "@otb-module-LIBRARIES@") set(@otb-module@_INCLUDE_DIRS "@otb-module-INCLUDE_DIRS@") set(@otb-module@_LIBRARY_DIRS "@otb-module-LIBRARY_DIRS@") @otb-module-EXPORT_CODE@ OTB-release-5.8/CMake/OTBModuleMacros.cmake000066400000000000000000000313551301006202600203460ustar00rootroot00000000000000get_filename_component(_OTBModuleMacros_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) set(_OTBModuleMacros_DEFAULT_LABEL "OTBModular") include(${_OTBModuleMacros_DIR}/OTBModuleAPI.cmake) include(${_OTBModuleMacros_DIR}/OTBModuleDoxygen.cmake) include(${_OTBModuleMacros_DIR}/OTBModuleHeaderTest.cmake) include(${_OTBModuleMacros_DIR}/OTBApplicationMacros.cmake) # With Apple's GGC <=4.2 and LLVM-GCC <=4.2 visibility of template # don't work. Set the option to off and hide it. if(APPLE AND CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.3") set( USE_COMPILER_HIDDEN_VISIBILITY OFF CACHE INTERNAL "" ) elseif(APPLE) #RK: compiler visibility nor woking on osx with appleclang xcode. #gcc is a symlink to clang set( USE_COMPILER_HIDDEN_VISIBILITY OFF CACHE INTERNAL "" ) endif() include(GenerateExportHeader) if(OTB_CPPCHECK_TEST) include(${_OTBModuleMacros_DIR}/OTBModuleCPPCheckTest.cmake) endif() macro(otb_module _name) otb_module_check_name(${_name}) set(otb-module ${_name}) set(otb-module-test ${_name}-Test) set(_doing "") set(OTB_MODULE_${otb-module}_DECLARED 1) set(OTB_MODULE_${otb-module-test}_DECLARED 1) set(OTB_MODULE_${otb-module}_DEPENDS "") set(OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS "") set(OTB_MODULE_${otb-module-test}_DEPENDS "${otb-module}") set(OTB_MODULE_${otb-module}_DESCRIPTION "description") set(OTB_MODULE_${otb-module}_EXCLUDE_FROM_DEFAULT 0) set(OTB_MODULE_${otb-module}_ENABLE_SHARED 0) foreach(arg ${ARGN}) if("${arg}" MATCHES "^(DEPENDS|OPTIONAL_DEPENDS|TEST_DEPENDS|DESCRIPTION|DEFAULT)$") set(_doing "${arg}") elseif("${arg}" MATCHES "^EXCLUDE_FROM_DEFAULT$") set(_doing "") set(OTB_MODULE_${otb-module}_EXCLUDE_FROM_DEFAULT 1) elseif("${arg}" MATCHES "^EXCLUDE_FROM_ALL$") # To maintain backward compatibility set(_doing "") message(AUTHOR_WARNING "EXCLUDE_FROM_ALL is deprecated, please use EXCLUDE_FROM_DEFAULT.") set(OTB_MODULE_${otb-module}_EXCLUDE_FROM_DEFAULT 1) elseif("${arg}" MATCHES "^ENABLE_SHARED$") set(_doing "") set(OTB_MODULE_${otb-module}_ENABLE_SHARED 1) elseif("${arg}" MATCHES "^[A-Z][A-Z][A-Z]$") set(_doing "") message(AUTHOR_WARNING "Unknown argument [${arg}]") elseif("${_doing}" MATCHES "^DEPENDS$") list(APPEND OTB_MODULE_${otb-module}_DEPENDS "${arg}") elseif("${_doing}" MATCHES "^OPTIONAL_DEPENDS$") list(APPEND OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS "${arg}") elseif("${_doing}" MATCHES "^TEST_DEPENDS$") list(APPEND OTB_MODULE_${otb-module-test}_DEPENDS "${arg}") elseif("${_doing}" MATCHES "^DESCRIPTION$") set(_doing "") set(OTB_MODULE_${otb-module}_DESCRIPTION "${arg}") elseif("${_doing}" MATCHES "^DEFAULT") message(FATAL_ERROR "Invalid argument [DEFAULT]") else() set(_doing "") message(AUTHOR_WARNING "Unknown argument [${arg}]") endif() endforeach() list(SORT OTB_MODULE_${otb-module}_DEPENDS) # Deterministic order. list(SORT OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS) # Deterministic order. list(SORT OTB_MODULE_${otb-module-test}_DEPENDS) # Deterministic order. endmacro() set(OTB_MODULE_ACTIVATION_OPTION_LIST "") macro(otb_module_activation_option _option_desc _default) string(REGEX REPLACE "OTB(.*)" "OTB_USE_\\1" _option_name ${otb-module}) string(TOUPPER ${_option_name} _option_name) option(${_option_name} ${_option_desc} ${_default}) set(OTB_MODULE_${otb-module}_ACTIVATION_OPTION ${_option_name}) list(APPEND OTB_MODULE_ACTIVATION_OPTION_LIST ${_option_name}) endmacro() macro(otb_module_check_name _name) if( NOT "${_name}" MATCHES "^[a-zA-Z][a-zA-Z0-9]*$") message(FATAL_ERROR "Invalid module name: ${_name}") endif() endmacro() macro(otb_module_impl) include(otb-module.cmake) # Load module meta-data set(${otb-module}_INSTALL_RUNTIME_DIR ${OTB_INSTALL_RUNTIME_DIR}) set(${otb-module}_INSTALL_LIBRARY_DIR ${OTB_INSTALL_LIBRARY_DIR}) set(${otb-module}_INSTALL_ARCHIVE_DIR ${OTB_INSTALL_ARCHIVE_DIR}) set(${otb-module}_INSTALL_INCLUDE_DIR ${OTB_INSTALL_INCLUDE_DIR}) # Collect all sources and headers for IDE projects. set(_srcs "") if("${CMAKE_GENERATOR}" MATCHES "Xcode|Visual Studio|KDevelop" OR CMAKE_EXTRA_GENERATOR) # Add sources to the module target for easy editing in the IDE. set(_include ${${otb-module}_SOURCE_DIR}/include) if(EXISTS ${_include}) set(_src ${${otb-module}_SOURCE_DIR}/src) file(GLOB_RECURSE _srcs ${_src}/*.cxx) file(GLOB_RECURSE _hdrs ${_include}/*.h ${_include}/*.hxx) list(APPEND _srcs ${_hdrs}) endif() endif() # Create a ${otb-module}-all target to build the whole module. add_custom_target(${otb-module}-all ALL SOURCES ${_srcs}) otb_module_use(${OTB_MODULE_${otb-module}_DEPENDS}) foreach(dep IN LISTS OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS) if (${dep}_ENABLED) otb_module_use(${dep}) endif() endforeach() if(NOT DEFINED ${otb-module}_LIBRARIES) set(${otb-module}_LIBRARIES "") foreach(dep IN LISTS OTB_MODULE_${otb-module}_DEPENDS) list(APPEND ${otb-module}_LIBRARIES "${${dep}_LIBRARIES}") endforeach() foreach(dep IN LISTS OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS) if (${dep}_ENABLED) list(APPEND ${otb-module}_LIBRARIES "${${dep}_LIBRARIES}") endif() endforeach() if(${otb-module}_LIBRARIES) list(REMOVE_DUPLICATES ${otb-module}_LIBRARIES) endif() endif() if(EXISTS ${${otb-module}_SOURCE_DIR}/include) list(APPEND ${otb-module}_INCLUDE_DIRS ${${otb-module}_SOURCE_DIR}/include) install(DIRECTORY include/ DESTINATION ${${otb-module}_INSTALL_INCLUDE_DIR} COMPONENT Development) endif() if(NOT OTB_SOURCE_DIR) # When building a module outside the OTB source tree, find the export # header. list(APPEND ${otb-module}_INCLUDE_DIRS ${${otb-module}_BINARY_DIR}/include) else() # if OTB_SOURCE_DIR is set all auto-generated export headers for a class # goes into OTBCommon_BINARY_DIR/src. # Hence it is required to include ${OTBCommon_BINARY_DIR} to list of # ${otb-module}_INCLUDE_DIRS. Not doing this will force developer to # to include them explicitly for each module which can result in # more problems. ( stephane albert) list(APPEND ${otb-module}_INCLUDE_DIRS ${OTBCommon_BINARY_DIR}) endif() if(${otb-module}_INCLUDE_DIRS) include_directories(${${otb-module}_INCLUDE_DIRS}) endif() if(${otb-module}_SYSTEM_INCLUDE_DIRS) include_directories(${${otb-module}_SYSTEM_INCLUDE_DIRS}) endif() if(${otb-module}_SYSTEM_LIBRARY_DIRS) link_directories(${${otb-module}_SYSTEM_LIBRARY_DIRS}) endif() if(${otb-module}_THIRD_PARTY) otb_module_warnings_disable(C CXX) else() if(OTB_CPPCHECK_TEST) otb_module_cppcheck_test( ${otb-module} ) endif() if(EXISTS "${${otb-module}_SOURCE_DIR}/include" AND BUILD_TESTING) otb_module_headertest(${otb-module}) endif() endif() if(EXISTS ${${otb-module}_SOURCE_DIR}/src/CMakeLists.txt) set_property(GLOBAL APPEND PROPERTY OTBTargets_MODULES ${otb-module}) add_subdirectory(src) endif() if(EXISTS ${${otb-module}_SOURCE_DIR}/app/CMakeLists.txt AND NOT ${otb-module}_NO_SRC) add_subdirectory(app) endif() if( OTB_MODULE_${otb-module}_ENABLE_SHARED ) if(OTB_SOURCE_DIR) set(_export_header_file "${OTBCommon_BINARY_DIR}/${otb-module}Export.h") else() set(_export_header_file "${${otb-module}_BINARY_DIR}/include/${otb-module}Export.h") endif() # Generate the export macro header for symbol visibility/Windows DLL declspec generate_export_header(${otb-module} EXPORT_FILE_NAME ${_export_header_file} EXPORT_MACRO_NAME ${otb-module}_EXPORT NO_EXPORT_MACRO_NAME ${otb-module}_HIDDEN STATIC_DEFINE OTB_STATIC ) install(FILES ${_export_header_file} DESTINATION ${${otb-module}_INSTALL_INCLUDE_DIR} COMPONENT Development ) if (BUILD_SHARED_LIBS) # export flags are only added when building shared libs, they cause # mismatched visibility warnings when building statically. add_compiler_export_flags(my_abi_flags) set_property(TARGET ${otb-module} APPEND PROPERTY COMPILE_FLAGS "${my_abi_flags}") endif() endif() set(otb-module-EXPORT_CODE-build "${${otb-module}_EXPORT_CODE_BUILD}") set(otb-module-EXPORT_CODE-install "${${otb-module}_EXPORT_CODE_INSTALL}") set(otb-module-DEPENDS "${OTB_MODULE_${otb-module}_DEPENDS}") foreach(dep IN LISTS OTB_MODULE_${otb-module}_OPTIONAL_DEPENDS) if (${dep}_ENABLED) list(APPEND otb-module-DEPENDS ${dep}) endif() endforeach() set(otb-module-LIBRARIES "${${otb-module}_LIBRARIES}") set(otb-module-INCLUDE_DIRS-build "${${otb-module}_INCLUDE_DIRS}") set(otb-module-INCLUDE_DIRS-install "\${OTB_INSTALL_PREFIX}/${${otb-module}_INSTALL_INCLUDE_DIR}") if(${otb-module}_SYSTEM_INCLUDE_DIRS) list(APPEND otb-module-INCLUDE_DIRS-build "${${otb-module}_SYSTEM_INCLUDE_DIRS}") list(APPEND otb-module-INCLUDE_DIRS-install "${${otb-module}_SYSTEM_INCLUDE_DIRS}") endif() set(otb-module-LIBRARY_DIRS "${${otb-module}_SYSTEM_LIBRARY_DIRS}") set(otb-module-INCLUDE_DIRS "${otb-module-INCLUDE_DIRS-build}") set(otb-module-EXPORT_CODE "${otb-module-EXPORT_CODE-build}") configure_file(${_OTBModuleMacros_DIR}/OTBModuleInfo.cmake.in ${OTB_MODULES_DIR}/${otb-module}.cmake @ONLY) set(otb-module-INCLUDE_DIRS "${otb-module-INCLUDE_DIRS-install}") set(otb-module-EXPORT_CODE "${otb-module-EXPORT_CODE-install}") configure_file(${_OTBModuleMacros_DIR}/OTBModuleInfo.cmake.in CMakeFiles/${otb-module}.cmake @ONLY) install(FILES ${${otb-module}_BINARY_DIR}/CMakeFiles/${otb-module}.cmake DESTINATION ${OTB_INSTALL_PACKAGE_DIR}/Modules COMPONENT Development ) otb_module_doxygen(${otb-module}) # module name endmacro() macro(otb_module_test) include(../otb-module.cmake) # Load module meta-data set(${otb-module-test}_LIBRARIES "") otb_module_use(${OTB_MODULE_${otb-module-test}_DEPENDS}) foreach(dep IN LISTS OTB_MODULE_${otb-module-test}_DEPENDS) list(APPEND ${otb-module-test}_LIBRARIES "${${dep}_LIBRARIES}") endforeach() endmacro() macro(otb_module_warnings_disable) foreach(lang ${ARGN}) if(MSVC) string(REGEX REPLACE "(^| )[/-]W[0-4]( |$)" " " CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS} -w") elseif(BORLAND) set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS} -w-") else() set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS} -w") endif() endforeach() endmacro() macro(otb_module_target_label _target_name) if(otb-module) set(_label ${otb-module}) if(TARGET ${otb-module}-all) add_dependencies(${otb-module}-all ${_target_name}) endif() else() set(_label ${_OTBModuleMacros_DEFAULT_LABEL}) endif() set_property(TARGET ${_target_name} PROPERTY LABELS ${_label}) endmacro() macro(otb_module_target_name _name) get_property(_target_type TARGET ${_name} PROPERTY TYPE) if (NOT ${_target_type} STREQUAL "EXECUTABLE") set_property(TARGET ${_name} PROPERTY VERSION 1) set_property(TARGET ${_name} PROPERTY SOVERSION 1) if("${_name}" MATCHES "^[Oo][Tt][Bb]") set(_otb "") else() set(_otb "otb") endif() set_property(TARGET ${_name} PROPERTY OUTPUT_NAME ${_otb}${_name}-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}) endif() endmacro() macro(otb_module_target_export _name) export(TARGETS ${_name} APPEND FILE ${${otb-module}-targets-build}) endmacro() macro(otb_module_target_install _name) #Use specific runtime components for executables and libraries separately when installing a module, #considering that the target of a module could be either an executable or a library. get_property(_ttype TARGET ${_name} PROPERTY TYPE) if("${_ttype}" STREQUAL EXECUTABLE) set(runtime_component Runtime) else() set(runtime_component RuntimeLibraries) endif() install(TARGETS ${_name} EXPORT ${${otb-module}-targets} RUNTIME DESTINATION ${${otb-module}_INSTALL_RUNTIME_DIR} COMPONENT ${runtime_component} LIBRARY DESTINATION ${${otb-module}_INSTALL_LIBRARY_DIR} COMPONENT RuntimeLibraries ARCHIVE DESTINATION ${${otb-module}_INSTALL_ARCHIVE_DIR} COMPONENT Development ) endmacro() macro(otb_module_target _name) set(_install 1) foreach(arg ${ARGN}) if("${arg}" MATCHES "^(NO_INSTALL)$") set(_install 0) else() message(FATAL_ERROR "Unknown argument [${arg}]") endif() endforeach() otb_module_target_name(${_name}) otb_module_target_label(${_name}) otb_module_target_export(${_name}) if(_install) otb_module_target_install(${_name}) endif() endmacro() macro(otb_module_requires_cxx11) if(${otb-module}_ENABLED AND NOT ${OTB_HAS_CXX11}) message(FATAL_ERROR "Module ${otb-module} requires C++11 support. Consider adding --std=c++11 to your compiler flags or disabling it.") endif() endmacro() OTB-release-5.8/CMake/OTBModuleRemote.cmake000066400000000000000000000125351301006202600203540ustar00rootroot00000000000000# Function to fetch remote modules. # Helper to perform the initial git clone and checkout. function(_git_clone git_executable git_repository git_tag module_dir) execute_process( COMMAND "${git_executable}" clone "${git_repository}" "${module_dir}" RESULT_VARIABLE error_code OUTPUT_QUIET ERROR_QUIET ) if(error_code) message(FATAL_ERROR "Failed to clone repository: '${git_repository}'") endif() execute_process( COMMAND "${git_executable}" checkout ${git_tag} WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code OUTPUT_QUIET ERROR_QUIET ) if(error_code) message(FATAL_ERROR "Failed to checkout tag: '${git_tag}'") endif() execute_process( COMMAND "${git_executable}" submodule init WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code ) if(error_code) message(FATAL_ERROR "Failed to init submodules in: '${module_dir}'") endif() execute_process( COMMAND "${git_executable}" submodule update --recursive WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code ) if(error_code) message(FATAL_ERROR "Failed to update submodules in: '${module_dir}'") endif() endfunction() # Helper to perform a git update. Checks the current Git revision against the # desired revision and only performs a fetch and checkout if needed. function(_git_update git_executable git_repository git_tag module_dir) execute_process( COMMAND "${git_executable}" rev-parse --verify ${git_tag} WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code OUTPUT_VARIABLE tag_hash ) if(error_code) message(FATAL_ERROR "Failed to get the hash for tag '${module_dir}'") endif() execute_process( COMMAND "${git_executable}" rev-parse --verify HEAD WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code OUTPUT_VARIABLE head_hash ) if(error_code) message(FATAL_ERROR "Failed to get the hash for ${git_repository} HEAD") endif() # Is the hash checkout out that we want? if(NOT ("${tag_hash}" STREQUAL "${head_hash}")) execute_process( COMMAND "${git_executable}" fetch "${git_repository}" WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code ) if(error_code) message(FATAL_ERROR "Failed to fetch repository '${git_repository}'") endif() execute_process( COMMAND "${git_executable}" checkout ${git_tag} WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code ) if(error_code) message(FATAL_ERROR "Failed to checkout tag: '${git_tag}'") endif() execute_process( COMMAND "${git_executable}" submodule update --recursive WORKING_DIRECTORY "${module_dir}" RESULT_VARIABLE error_code ) if(error_code) message(FATAL_ERROR "Failed to update submodules in: '${module_dir}'") endif() endif() endfunction() # Helper function to fetch a module stored in a Git repository. # Git fetches are only performed when required. function(_fetch_with_git git_executable git_repository git_tag module_dir) if("${git_tag}" STREQUAL "" OR "${git_repository}" STREQUAL "") message(FATAL_ERROR "Tag or repository for git checkout should not be empty.") endif() # If we don't have a clone yet. if(NOT EXISTS "${module_dir}") _git_clone("${git_executable}" "${git_repository}" "${git_tag}" "${module_dir}") message(STATUS " The remote module: ${git_repository} is cloned into the directory ${module_dir}") else() # We already have a clone, but we need to check that it has the right revision. _git_update("${git_executable}" "${git_repository}" "${git_tag}" "${module_dir}") endif() endfunction() # Download and turn on a remote module. # # The module CMake option is created: Module_${module_name}, which defaults to OFF. # Once set to ON, the module is downloaded into the Remote module group. # # A module name and description are required. The description will show up in # the CMake user interface. # # The following options are currently supported: # [GIT_REPOSITORY url] # URL of git repo # [GIT_TAG tag] # Git branch name, commit id or tag function(otb_fetch_module _name _description) option(Module_${_name} "${_description}" OFF) mark_as_advanced(Module_${_name}) # Fetch_$_remote_module} is deprecated. To maintain backward compatibility: if(Fetch_${_name}) message(WARNING "Fetch_${_name} is deprecated, please use Module_${_name} to download and enable the remote module.") set(Module_${_name} ON CACHE FORCE "${_description}") endif() if(Module_${_name}) otb_download_attempt_check(Module_${_name}) include(CMakeParseArguments) cmake_parse_arguments(_fetch_options "" "GIT_REPOSITORY;GIT_TAG" "" ${ARGN}) find_package(Git) if(NOT GIT_EXECUTABLE) message(FATAL_ERROR "error: could not find git for clone of ${_name}") endif() execute_process( COMMAND "${GIT_EXECUTABLE}" --version OUTPUT_VARIABLE ov OUTPUT_STRIP_TRAILING_WHITESPACE ) string(REGEX REPLACE "^git version (.+)$" "\\1" _version "${ov}") if("${_version}" VERSION_LESS 1.6.6) message(FATAL_ERROR "Git version 1.6.6 or later is required.") endif() _fetch_with_git("${GIT_EXECUTABLE}" "${_fetch_options_GIT_REPOSITORY}" "${_fetch_options_GIT_TAG}" "${OTB_SOURCE_DIR}/Modules/Remote/${_name}" ) endif() endfunction() OTB-release-5.8/CMake/OTBModuleTest.cmake000066400000000000000000000166161301006202600200440ustar00rootroot00000000000000# This file contains CMake functions and macros used when testing ITK modules. #----------------------------------------------------------------------------- # Create source code, compile and link a test driver # Two variables must be defined before including this file. # KIT should define a unique name for the test driver. # KitTests should contain a list of test file names. # Arguments - Input # KIT - the name of the test directory # KIT_LIBS - a list of libraries needed to link the test driver # KitTests - a list of tests to be included in the test driver # ADDITIONAL_SRC (optional) - additional source files, which don't contain tests macro(CreateTestDriver KIT KIT_LIBS KitTests) set(ADDITIONAL_SRC ${ARGN}) if(EMSCRIPTEN) set(emscripten_before " EM_ASM( var cmake_source_dir = '${CMAKE_SOURCE_DIR}'.split('/'); // This is intentionally global so it can be unmounted at the end. source_mount_dir = null; if(cmake_source_dir[1] === 'home') { source_mount_dir = cmake_source_dir.slice(0, 3).join('/'); } else { source_mount_dir = cmake_source_dir.slice(0, 2).join('/'); } FS.mkdir(source_mount_dir); FS.mount(NODEFS, { root: source_mount_dir }, source_mount_dir); var cmake_binary_dir = '${CMAKE_BINARY_DIR}'.split('/'); // This is intentionally global so it can be unmounted at the end. binary_mount_dir = null; if(cmake_binary_dir[1] === 'home') { binary_mount_dir = cmake_binary_dir.slice(0, 3).join('/'); } else { binary_mount_dir = cmake_binary_dir.slice(0, 2).join('/'); } if(source_mount_dir != binary_mount_dir) { FS.mkdir(binary_mount_dir); FS.mount(NODEFS, { root: binary_mount_dir }, binary_mount_dir); } ); ") set(emscripten_after " EM_ASM( FS.unmount(source_mount_dir); if(source_mount_dir != binary_mount_dir) { FS.unmount(binary_mount_dir); } ); ") endif() set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "${emscripten_before}#include \"otbTestDriverBeforeTest.inc\"") set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "#include \"otbTestDriverAfterTest.inc\"${emscripten_after}") create_test_sourcelist(Tests ${KIT}TestDriver.cxx ${KitTests} EXTRA_INCLUDE otbTestDriverIncludeRequiredIOFactories.h FUNCTION ProcessArgumentsAndRegisterRequiredFactories ) add_executable(${KIT}TestDriver ${KIT}TestDriver.cxx ${Tests} ${ADDITIONAL_SRC}) target_link_libraries(${KIT}TestDriver LINK_PUBLIC ${KIT_LIBS} ${OTBTestKernel_LIBRARIES}) otb_module_target_label(${KIT}TestDriver) endmacro() macro(CreateTestDriver_SupportBuildInIOFactories KIT KIT_LIBS KitTests) set(ADDITIONAL_SRC ${ARGN} ) if(EMSCRIPTEN) set(emscripten_before " EM_ASM( var cmake_source_dir = '${CMAKE_SOURCE_DIR}'.split('/'); // This is intentionally global so it can be unmounted at the end. source_mount_dir = null; if(cmake_source_dir[1] === 'home') { source_mount_dir = cmake_source_dir.slice(0, 3).join('/'); } else { source_mount_dir = cmake_source_dir.slice(0, 2).join('/'); } FS.mkdir(source_mount_dir); FS.mount(NODEFS, { root: source_mount_dir }, source_mount_dir); // This is intentionally global so it can be unmounted at the end. binary_mount_dir = null; var cmake_binary_dir = '${CMAKE_BINARY_DIR}'.split('/'); if(cmake_binary_dir[1] === 'home') { binary_mount_dir = cmake_binary_dir.slice(0, 3).join('/'); } else { binary_mount_dir = cmake_binary_dir.slice(0, 2).join('/'); } if(source_mount_dir != binary_mount_dir) { FS.mkdir(binary_mount_dir); FS.mount(NODEFS, { root: binary_mount_dir }, binary_mount_dir); } ); ") set(emscripten_after " EM_ASM( FS.unmount(source_mount_dir); if(source_mount_dir != binary_mount_dir) { FS.unmount(binary_mount_dir); } ); ") endif() set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "${emscripten_before}#include \"otbTestDriverBeforeTest.inc\"") set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "#include \"otbTestDriverAfterTest.inc\"${emscripten_after}") create_test_sourcelist(Tests ${KIT}TestDriver.cxx ${KitTests} EXTRA_INCLUDE otbTestDriverIncludeBuiltInIOFactories.h FUNCTION ProcessArgumentsAndRegisterBuiltInFactories ) add_executable(${KIT}TestDriver ${KIT}TestDriver.cxx ${Tests} ${ADDITIONAL_SRC}) target_link_libraries(${KIT}TestDriver LINK_PUBLIC ${KIT_LIBS} ${OTBTestKernel_LIBRARIES}) otb_module_target_label(${KIT}TestDriver) endmacro() #----------------------------------------------------------------------------- # OTB wrapper for add_test that automatically sets the test's LABELS property # to the value of its containing module. # # function(otb_add_test) # # Add tests with data in the OTBData group. # ExternalData_add_test(OTBData ${ARGN}) # if("NAME" STREQUAL "${ARGV0}") # set(_iat_testname ${ARGV1}) # else() # set(_iat_testname ${ARGV0}) # endif() # if(otb-module) # set(_label ${otb-module}) # if(TARGET ${otb-module}-all AND "${ARGN}" MATCHES "DATA{") # add_dependencies(${otb-module}-all OTBData) # endif() # else() # set(_label ${main_project_name}) # endif() # set_property(TEST ${_iat_testname} PROPERTY LABELS ${_label}) # endfunction() #----------------------------------------------------------------------------- # OTB wrapper for add_test that automatically sets the test's LABELS property # to the value of its containing module. # function(otb_add_test) set(largeinput_regex "LARGEINPUT{([^;{}\r\n]*)}") set(_depends_on_largeinput OFF) foreach(arg IN LISTS ARGN) if("x${arg}" MATCHES "${largeinput_regex}") string(REGEX REPLACE "${largeinput_regex}" "\\1" largeinput_relative_path "${arg}") set(_fullpath "${OTB_DATA_LARGEINPUT_ROOT}/${largeinput_relative_path}") list(APPEND _out_arg ${_fullpath}) set(_depends_on_largeinput ON) else() list(APPEND _out_arg ${arg}) endif() endforeach() if (_depends_on_largeinput AND NOT OTB_DATA_USE_LARGEINPUT) return() endif() add_test(${_out_arg}) if("NAME" STREQUAL "${ARGV0}") set(_iat_testname ${ARGV1}) else() set(_iat_testname ${ARGV0}) endif() if(otb-module) set(_label ${otb-module}) else() set(_label ${main_project_name}) endif() set_property(TEST ${_iat_testname} PROPERTY LABELS ${_label}) endfunction() #----------------------------------------------------------------------------- # OTB function to ignore a test # function(otb_tests_ignore) set_property(GLOBAL APPEND PROPERTY CTEST_CUSTOM_TESTS_IGNORE ${ARGN}) endfunction() #----------------------------------------------------------------------------- # OTB function to ignore a test during MemCheck # function(otb_memcheck_ignore) set_property(GLOBAL APPEND PROPERTY CTEST_CUSTOM_MEMCHECK_IGNORE ${ARGN}) endfunction() #----------------------------------------------------------------------------- # Function otb_add_test_mpi to run mpi tests function(otb_add_test_mpi) set( _OPTIONS_ARGS ) set( _ONE_VALUE_ARGS NAME NBPROCS COMMAND) set( _MULTI_VALUE_ARGS ) cmake_parse_arguments( TEST_MPI "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN} ) # Test nb procs if( NOT TEST_MPI_NBPROCS ) set(TEST_MPI_NBPROCS 2) endif() # Test command line foreach(arg IN LISTS TEST_MPI_UNPARSED_ARGUMENTS) list(APPEND ARGS ${arg}) endforeach() set (test_parameters -np ${TEST_MPI_NBPROCS} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TEST_MPI_COMMAND} ${ARGS}) otb_add_test(NAME ${TEST_MPI_NAME} COMMAND ${MPIEXEC} ${test_parameters}) endfunction() OTB-release-5.8/CMake/OTBSetStandardCompilerFlags.cmake000066400000000000000000000326251301006202600226410ustar00rootroot00000000000000# trict-null-sentinel Check the set of common warning flags supported by C and C++ compilers # check_compiler_warning_flags( ) # - variable to store valid C warning flags # - variable to store valid CXX warning flags # This internally calls the check_c_compiler_flag and check_cxx_compiler_flag macros. # To create a portable build system, it is best to not # test for platforms, but to test for features. # # Instead of testing "if Windows then do this", test for # "if the -Wno-invalid-offsetof flag works then use it". # # Typical use of this module is: # # include(CheckCompilerWarningFlags) # check_compiler_warning_flags(C_WARNING_FLAGS CXX_WARNING_FLAGS) # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_WARNING_FLAGS}") # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_WARNING_FLAGS}") include(OTB_CheckCCompilerFlag) include(OTB_CheckCXXCompilerFlag) macro( set_debug_flags ) string( TOUPPER "${CMAKE_BUILD_TYPE}" MODE ) if( "${MODE}" STREQUAL "DEBUG" ) message( STATUS "Adding -DOTB_DEBUG" ) set( CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DOTB_DEBUG" ) set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DOTB_DEBUG" ) endif() endmacro() function(check_c_compiler_warning_flags c_flag_var) set(local_c_flags "") set(flag_list "${ARGN}") foreach(flag IN LISTS flag_list) OTB_CHECK_C_COMPILER_FLAG(${flag} C_HAS_WARNING${flag}) if(${C_HAS_WARNING${flag}}) set(local_c_flags "${local_c_flags} ${flag}") endif() endforeach() set(${c_flag_var} "${local_c_flags}" PARENT_SCOPE) endfunction() function(check_cxx_compiler_warning_flags cxx_flag_var) set(local_cxx_flags "") set(flag_list "${ARGN}") foreach(flag IN LISTS flag_list) OTB_CHECK_CXX_COMPILER_FLAG(${flag} CXX_HAS_WARNING${flag}) if(${CXX_HAS_WARNING${flag}}) set(local_cxx_flags "${local_cxx_flags} ${flag}") endif() endforeach() set(${cxx_flag_var} "${local_cxx_flags}" PARENT_SCOPE) endfunction() function(check_compiler_warning_flags c_warning_flags_var cxx_warning_flags_var) set(${c_warning_flags_var} "" PARENT_SCOPE) set(${cxx_warning_flags_var} "" PARENT_SCOPE) # Check this list on C compiler only set(c_flags -Wno-uninitialized -Wno-unused-parameter ) ## On windows, the most verbose compiler options ## is reporting 1000's of wanings in windows ## header files, for now, limit the number of ## warnings to level 3 if( MSVC ) set(VerboseWarningsFlag -W3 ) ## A better solution would be to use -Wall, ## and then disable warnings one by one ## set(VerboseWarningsFlag -Wall -wd4820 -wd4682 ) else() ## with Intel compiler, the -Wall compiler options ## is reporting 1000's of remarks of trivial items ## that will only slow day-to-day operations ## specify -w2 to restrict to only warnings and errors if (${CMAKE_C_COMPILER} MATCHES "icc.*$") set(USING_INTEL_ICC_COMPILER TRUE) endif() if (${CMAKE_CXX_COMPILER} MATCHES "icpc.*$") set(USING_INTEL_ICC_COMPILER TRUE) endif() if(USING_INTEL_ICC_COMPILER) # NOTE -w2 is close to gcc's -Wall warning level, -w5 is intels -Wall warning level, and it is too verbose. set(VerboseWarningsFlag -w2 -wd1268 -wd981 -wd383 -wd1418 -wd1419 -wd2259 -wd1572 -wd424 ) #-wd424 #Needed for Intel compilers with remarki #424: extra ";" ignored #-wd383 #Needed for Intel compilers with remark #383: value copied to temporary, reference to temporary used #-wd981 #Needed for Intel compilers with remark #981: operands are evaluated in unspecified order #-wd1418 #Needed for Intel compilers with remark #1418: external function definition with no prior declaration #-wd1419 #Needed for Intel compilers with remark #1419: external declaration in primary source file #-wd1572 #Needed for Intel compilers with remark #1572: floating-point equality and inequality comparisons are unreliable #-wd2259 #Needed for Intel compilers with remark #2259: non-pointer conversion from "otb::SizeValueType={unsigned long}" to "double" may lose significant bits #-wd1268 #Needed for Intel compilers with warning #1268: support for exported templates is disabled else() set(VerboseWarningsFlag -Wall ) endif () endif() # Check this list on both C and C++ compilers set(c_and_cxx_flags ${VerboseWarningsFlag} -Wno-long-double #Needed on APPLE -Wcast-align -Wdisabled-optimization -Wextra -Wformat=2 -Winvalid-pch -Wno-format-nonliteral -Wpointer-arith -Wshadow -Wunused -Wwrite-strings -funit-at-a-time -Wno-strict-overflow ) # Check this list on C++ compiler only set(cxx_flags -Wno-deprecated -Wno-invalid-offsetof -Woverloaded-virtual -Wstrict-null-sentinel ) ##-Wno-c++0x-static-nonintegral-init ## Clang compiler likes to warn about this feature that is technically only in ## c++0x, but works on many compilers, and if it fails, then alternate methods are used check_c_compiler_warning_flags(CMAKE_C_WARNING_FLAGS ${c_flags} ${c_and_cxx_flags}) check_cxx_compiler_warning_flags(CMAKE_CXX_WARNING_FLAGS ${c_and_cxx_flags} ${cxx_flags}) set(${c_warning_flags_var} "${CMAKE_C_WARNING_FLAGS}" PARENT_SCOPE) set(${cxx_warning_flags_var} "${CMAKE_CXX_WARNING_FLAGS}" PARENT_SCOPE) endfunction() macro(check_compiler_platform_flags) # On Visual Studio 8 MS deprecated C. This removes all 1.276E1265 security # warnings if(WIN32) if(NOT MINGW) if(NOT OTB_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS) add_definitions( -D_CRT_FAR_MAPPINGS_NO_DEPRECATE -D_CRT_IS_WCTYPE_NO_DEPRECATE -D_CRT_MANAGED_FP_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_DEPRECATE_GLOBALS -D_CRT_SETERRORMODE_BEEP_SLEEP_NO_DEPRECATE -D_CRT_TIME_FUNCTIONS_NO_DEPRECATE -D_CRT_VCCLRIT_NO_DEPRECATE -D_SCL_SECURE_NO_DEPRECATE ) endif() # With MS compilers on Win64, we need the /bigobj switch, else generated # code results in objects with number of sections exceeding object file # format. # see http://msdn.microsoft.com/en-us/library/ms173499.aspx if(MSVC_VERSION GREATER 1310) set(OTB_REQUIRED_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} /bigobj") endif() endif() endif() if(WIN32) # Some libraries (e.g. vxl libs) have no dllexport markup, so we can # build full shared libraries only with the GNU toolchain. For non # gnu compilers on windows, only Common is shared. This allows for # plugin type applications to use a dll for OTBCommon which will contain # the static for Modified time. if(CMAKE_COMPILER_IS_GNUCXX) # CMake adds --enable-all-exports on Cygwin (since Cygwin is # supposed to be UNIX-like), but we need to add it explicitly for # a native windows build with the MinGW tools. if(MINGW) set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-shared -Wl,--export-all-symbols -Wl,--enable-auto-import") set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS "-shared -Wl,--export-all-symbols -Wl,--enable-auto-import") set(CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-auto-import") endif() else() # if CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS is on, then # BUILD_SHARED_LIBS works as it would on other systems if(NOT CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS) if(BUILD_SHARED_LIBS) set(OTB_LIBRARY_BUILD_TYPE "SHARED") else() set(OTB_LIBRARY_BUILD_TYPE "STATIC") endif() # turn off BUILD_SHARED_LIBS as OTB_LIBRARY_BUILD_TYPE # is used on the libraries that have markup. set(BUILD_SHARED_LIBS OFF) endif() endif() endif() #----------------------------------------------------------------------------- #OTB requires special compiler flags on some platforms. if(CMAKE_COMPILER_IS_GNUCXX) # GCC's -Warray-bounds has been shown to throw false positives with -O3 on 4.8. if(UNIX AND ( ("${CMAKE_CXX_COMPILER_VERSION}" VERSION_EQUAL "4.8") OR ("${CMAKE_CXX_COMPILER_VERSION}" VERSION_GREATER "4.8" AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9") )) set(OTB_REQUIRED_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} -Wno-array-bounds") endif() if(APPLE) option(OTB_USE_64BITS_APPLE_TRUNCATION_WARNING "Turn on warnings on 64bits to 32bits truncations." OFF) mark_as_advanced(OTB_USE_64BITS_APPLE_TRUNCATION_WARNING) execute_process(COMMAND "${CMAKE_C_COMPILER}" --version OUTPUT_VARIABLE _version ERROR_VARIABLE _version) # -fopenmp breaks compiling the HDF5 library in shared library mode # on the OS X platform -- at least with gcc 4.2 from Xcode. set(compile_flag_lists CMAKE_C_FLAGS CMAKE_CXX_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELWITHDEBINFO) foreach(listname ${compile_flag_lists}) if("${${listname}}" MATCHES ".*-fopenmp.*") string(REPLACE "-fopenmp" "" tmpFlags "${${listname}}") set(${listname} "${tmpFlags}") message("-fopenmp causes incorrect compliation of HDF, removing from ${listname}") endif() endforeach() endif() # gcc must have -msse2 option to enable sse2 support if(VNL_CONFIG_ENABLE_SSE2 OR VNL_CONFIG_ENABLE_SSE2_ROUNDING) set(OTB_REQUIRED_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} -msse2") endif() endif() #----------------------------------------------------------------------------- # for the gnu compiler a -D_PTHREADS is needed on sun # for the native compiler a -mt flag is needed on the sun if(CMAKE_SYSTEM MATCHES "SunOS.*") if(CMAKE_COMPILER_IS_GNUCXX) set(OTB_REQUIRED_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} -D_PTHREADS") set(OTB_REQUIRED_LINK_FLAGS "${OTB_REQUIRED_LINK_FLAGS} -lrt") else() set(OTB_REQUIRED_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} -mt") set(OTB_REQUIRED_C_FLAGS "${OTB_REQUIRED_C_FLAGS} -mt") endif() # Add flags for the SUN compiler to provide all the methods for std::allocator. # CHECK_CXX_SOURCE_COMPILES("-features=no%anachronisms" SUN_COMPILER) if(SUN_COMPILER) CHECK_CXX_SOURCE_COMPILES("-library=stlport4" SUN_COMPILER_HAS_STL_PORT_4) if(SUN_COMPILER_HAS_STL_PORT_4) set(OTB_REQUIRED_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} -library=stlport4") endif() endif() endif() # mingw thread support if(MINGW) set(OTB_REQUIRED_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} -mthreads") set(OTB_REQUIRED_C_FLAGS "${OTB_REQUIRED_C_FLAGS} -mthreads") set(OTB_REQUIRED_LINK_FLAGS "${OTB_REQUIRED_LINK_FLAGS} -mthreads") endif() #----------------------------------------------------------------------------- # The frename-registers option does not work due to a bug in the gnu compiler. # It must be removed or data errors will be produced and incorrect results # will be produced. This is first documented in the gcc4 man page. if(CMAKE_COMPILER_IS_GNUCXX) set(ALL_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS} ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}" ) separate_arguments(ALL_FLAGS) foreach(COMP_OPTION ${ALL_FLAGS}) if("${COMP_OPTION}" STREQUAL "-frename-registers") message(FATAL_ERROR "-frename-registers causes runtime bugs. It must be removed from your compilation options.") endif() endforeach() endif() #----------------------------------------------------------------------------- # Set the compiler-specific flag for disabling optimization. if(MSVC) set(OTB_CXX_DISABLE_OPTIMIZATION_FLAG "/Od") elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "^(GNU|Intel)$") set(OTB_CXX_DISABLE_OPTIMIZATION_FLAG "-O0") endif() if(DEFINED OTB_CXX_DISABLE_OPTIMIZATION_FLAG) CHECK_CXX_SOURCE_COMPILES(${OTB_CXX_DISABLE_OPTIMIZATION_FLAG} CXX_HAS_DISABLE_OPTIMIZATION_FLAG) endif() endmacro()#End the platform check function #----------------------------------------------------------------------------- #Check the set of warning flags the compiler supports check_compiler_warning_flags(C_WARNING_FLAGS CXX_WARNING_FLAGS) # Append OTB warnings to the CMake flags. # We do not set them in OTB_REQUIRED FLAGS because all project which # use OTB don't require these flags . set(CMAKE_C_FLAGS "${C_WARNING_FLAGS} ${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CXX_WARNING_FLAGS} ${CMAKE_CXX_FLAGS}") set_debug_flags() #----------------------------------------------------------------------------- #Check the set of platform flags the compiler supports check_compiler_platform_flags() # Usage: set_linker_stack_size_flag(otbApplicationLauncherCommandLine 10000000) # The above macro call will set LINK_FLAGS executable target named # otbApplicationLauncherCommandLine to 10Mbytes macro(set_linker_stack_size_flag exe_target requested_stack_size) # Since CMake 2.8.11, the size of the stack is not modified by CMake on # windows platform, it uses the default size: with visual compiler it is 1Mbyte # which is to lower for us (thanks to 6S code). if(MSVC) set_target_properties(${exe_target} PROPERTIES LINK_FLAGS "/STACK:${requested_stack_size}") elseif(MINGW) set_target_properties(${exe_target} PROPERTIES LINK_FLAGS "-Wl,--stack,${requested_stack_size}") endif() endmacro()OTB-release-5.8/CMake/OTB_CheckCCompilerFlag.cmake000066400000000000000000000040531301006202600215130ustar00rootroot00000000000000# - Check whether the C compiler supports a given flag. # CHECK_C_COMPILER_FLAG( ) # - the compiler flag # - variable to store the result # This internally calls the check_c_source_compiles macro. # See help for CheckCSourceCompiles for a listing of variables # that can modify the build. #============================================================================= # Copyright 2006-2010 Kitware, Inc. # Copyright 2006 Alexander Neundorf # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) include(CheckCSourceCompiles) macro (OTB_CHECK_C_COMPILER_FLAG _FLAG _RESULT) set(SAFE_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}") set(CMAKE_REQUIRED_DEFINITIONS "${_FLAG}") CHECK_C_SOURCE_COMPILES("int main(void) { return 0; }" ${_RESULT} # Some compilers do not fail with a bad flag FAIL_REGEX "warning: command line option .* is valid for .* but not for C" # Apple gcc FAIL_REGEX "unrecognized .*option" # GNU FAIL_REGEX "unknown .*option" # Clang FAIL_REGEX "ignoring unknown option" # MSVC FAIL_REGEX "warning D9002" # MSVC, any lang FAIL_REGEX "[Uu]nknown option" # HP FAIL_REGEX "[Ww]arning: [Oo]ption" # SunPro FAIL_REGEX "command option .* is not recognized" # XL FAIL_REGEX "warning #10156: ignoring option" # INTEL compilers ) set (CMAKE_REQUIRED_DEFINITIONS "${SAFE_CMAKE_REQUIRED_DEFINITIONS}") endmacro () OTB-release-5.8/CMake/OTB_CheckCXXCompilerFlag.cmake000066400000000000000000000040521301006202600217720ustar00rootroot00000000000000# - Check whether the CXX compiler supports a given flag. # CHECK_CXX_COMPILER_FLAG( ) # - the compiler flag # - variable to store the result # This internally calls the check_cxx_source_compiles macro. See help # for CheckCXXSourceCompiles for a listing of variables that can # modify the build. #============================================================================= # Copyright 2006-2010 Kitware, Inc. # Copyright 2006 Alexander Neundorf # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) include(CheckCXXSourceCompiles) macro (OTB_CHECK_CXX_COMPILER_FLAG _FLAG _RESULT) set(SAFE_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}") set(CMAKE_REQUIRED_DEFINITIONS "${_FLAG}") CHECK_CXX_SOURCE_COMPILES("int main() { return 0;}" ${_RESULT} # Some compilers do not fail with a bad flag FAIL_REGEX "unrecognized .*option" # GNU FAIL_REGEX "unknown .*option" # Clang FAIL_REGEX "ignoring unknown option" # MSVC FAIL_REGEX "warning D9002" # MSVC, any lang FAIL_REGEX "[Uu]nknown option" # HP FAIL_REGEX "[Ww]arning: [Oo]ption" # SunPro FAIL_REGEX "command option .* is not recognized" # XL FAIL_REGEX "not supported in this configuration; ignored" # AIX FAIL_REGEX "File with unknown suffix passed to linker" # PGI FAIL_REGEX "warning #10156: ignoring option" # INTEL compilers ) set (CMAKE_REQUIRED_DEFINITIONS "${SAFE_CMAKE_REQUIRED_DEFINITIONS}") endmacro () OTB-release-5.8/CMake/PreventInBuildInstalls.cmake000066400000000000000000000004511301006202600220040ustar00rootroot00000000000000string(TOLOWER "${CMAKE_INSTALL_PREFIX}" _PREFIX) string(TOLOWER "${OTB_BINARY_DIR}" _BUILD) if("${_PREFIX}" STREQUAL "${_BUILD}") message(FATAL_ERROR "The current CMAKE_INSTALL_PREFIX points at the build tree:\n" " ${CMAKE_INSTALL_PREFIX}\n" "This is not supported." ) endif() OTB-release-5.8/CMake/PreventInSourceBuilds.cmake000066400000000000000000000033341301006202600216410ustar00rootroot00000000000000# # This function will prevent in-source builds function(AssureOutOfSourceBuilds) # make sure the user doesn't play dirty with symlinks get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH) get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH) # disallow in-source builds if("${srcdir}" STREQUAL "${bindir}") message("######################################################") message("# OTB should not be configured & built in the OTB source directory") message("# You must run cmake in a build directory.") message("# For example:") message("# mkdir OTB-Sandbox ; cd OTB-Sandbox") message("# hg clone http://hg.orfeo-toolbox.org/OTB # or download & unpack the source tarball") message("# mkdir OTB-Binary ") message("# this will create the following directory structure ") message("# ") message("# OTB-Sandbox") message("# +--OTB ") message("# +--OTB-Binary ") message("# ") message("# Then you can proceed to configure and build ") message("# by using the following commands ") message("# ") message("# cd OTB-Binary") message("# ccmake ../OTB") message("# make ") message("# ") message("# NOTE: Given that you already tried to make an in-source build") message("# CMake have already created several files & directories") message("# in your source tree. run 'hg status' to find them and") message("# remove them by doing:") message("# ") message("# cd OTB-Sandbox/OTB") message("# hg purge ") message("# ") message("######################################################") message(FATAL_ERROR "Quitting configuration") endif() endfunction() AssureOutOfSourceBuilds() OTB-release-5.8/CMake/PythonCompile.py000066400000000000000000000001621301006202600175410ustar00rootroot00000000000000# By Simon Edwards # This file is in the public domain. import py_compile py_compile.main() OTB-release-5.8/CMake/RemoveTemporaryFiles.cmake.in000066400000000000000000000015731301006202600221360ustar00rootroot00000000000000# # Remove temporary files that are generated by build submissions, # cmake configure and testing # # Cleanup old dashboard submissions file(GLOB OLD_DASHBOARDS "@OTB_BINARY_DIR@/Testing/20*") foreach(OLD ${OLD_DASHBOARDS}) message(" Removing old submission in ${OLD}") file(REMOVE_RECURSE "${OLD}") endforeach() # Cleanup the Testing/Temporary directory file(REMOVE_RECURSE "@OTB_BINARY_DIR@/Testing/Temporary") # Cleanup the CMake Error and Output logs file(REMOVE "@OTB_BINARY_DIR@${CMAKE_FILES_DIRECTORY}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log") file(REMOVE "@OTB_BINARY_DIR@${CMAKE_FILES_DIRECTORY}/CMakeOutput.log") file(REMOVE "@OTB_BINARY_DIR@/CMakeOutput.log") file(REMOVE "@OTB_BINARY_DIR@${CMAKE_FILES_DIRECTORY}${CMAKE_FILES_DIRECTORY}/CMakeError.log") file(REMOVE "@OTB_BINARY_DIR@${CMAKE_FILES_DIRECTORY}/CMakeError.log") file(REMOVE "@OTB_BINARY_DIR@/CMakeError.log") OTB-release-5.8/CMake/SourceStatus.cmake000066400000000000000000000050061301006202600200450ustar00rootroot00000000000000function(repository_status root_repo_dir result_var1) if(NOT EXISTS "${root_repo_dir}/.git") return() endif() find_package(Git) if(NOT GIT_FOUND) message(STATUS "git not found. Make sure git can be found in your PATH. (source status will not be reported)") set(${result_var1}) return() endif() execute_process(COMMAND ${GIT_EXECUTABLE} config --get remote.origin.url WORKING_DIRECTORY ${root_repo_dir} OUTPUT_VARIABLE git_remote_origin_url OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) if(git_remote_origin_url) get_filename_component(dir_name ${git_remote_origin_url} NAME) else() get_filename_component(dir_name ${root_repo_dir} NAME) endif() execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --pretty=format:%H --oneline WORKING_DIRECTORY ${root_repo_dir} OUTPUT_VARIABLE last_commit_id OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) #git symbolic-ref --short -q HEAD does not work on older git version #rather than checking for git version. it is better to not use that #option and employ cmake stuff to do the work execute_process(COMMAND ${GIT_EXECUTABLE} symbolic-ref -q HEAD WORKING_DIRECTORY ${root_repo_dir} OUTPUT_VARIABLE git_symbolic_ref_output OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) set(branch_name) if(git_symbolic_ref_output) get_filename_component(branch_name ${git_symbolic_ref_output} NAME) endif() set(return_msg "${dir_name} repository info: \n") set(return_msg "${return_msg} git log -1 --oneline = [${last_commit_id}] \n") set(return_msg "${return_msg} git symbolic-ref -q HEAD = ${branch_name}") set(${result_var1} ${return_msg} PARENT_SCOPE) #print other information inside function call execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --pretty=format:%H WORKING_DIRECTORY ${root_repo_dir} OUTPUT_VARIABLE OTB_WC_REVISION OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) message(STATUS "Repository status (${dir_name}) :") message(STATUS " Repository revision is ${OTB_WC_REVISION}") execute_process(COMMAND ${GIT_EXECUTABLE} status -s WORKING_DIRECTORY ${root_repo_dir} OUTPUT_VARIABLE OTB_WC_STATUS TIMEOUT 20 OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) if(OTB_WC_STATUS) message(STATUS " Local file modifications (${dir_name}) :") string(REPLACE "\n" "\n-- " OTB_WC_STATUS_PRETTYPRINT " ${OTB_WC_STATUS}") message(WARNING "${OTB_WC_STATUS_PRETTYPRINT}") else() message(STATUS " No files modified locally (${dir_name})") endif() endfunction() OTB-release-5.8/CMake/TopologicalSort.cmake000066400000000000000000000130711301006202600205260ustar00rootroot00000000000000# Perform a reverse topological sort on the given LIST. # # topological_sort(my_list "MY_" "_EDGES") # # LIST is the name of a variable containing a list of elements to be # sorted in reverse topological order. Each element in the list has a # set of outgoing edges (for example, those other list elements that # it depends on). In the resulting reverse topological ordering # (written back into the variable named LIST), an element will come # later in the list than any of the elements that can be reached by # following its outgoing edges and the outgoing edges of any vertices # they target, recursively. Thus, if the edges represent dependencies # on build targets, for example, the reverse topological ordering is # the order in which one would build those targets. # # For each element E in this list, the edges for E are contained in # the variable named ${PREFIX}${E}${SUFFIX}. If no such variable # exists, then it is assumed that there are no edges. For example, if # my_list contains a, b, and c, one could provide a dependency graph # using the following variables: # # MY_A_EDGES b # MY_B_EDGES # MY_C_EDGES a b # # With the involcation of topological_sort shown above and these # variables, the resulting reverse topological ordering will be b, a, # c. ############################################################################## # Modified from Boost Utilities # # Copyright 2010 Kitware, Inc. ############################################################################## # Copyright 2007 Douglas Gregor # Copyright 2007 Troy Straszheim # # Distributed under the Boost Software License, Version 1.0. ############################################################################## # Boost Software License - Version 1.0 - August 17th, 2003 # # Permission is hereby granted, free of charge, to any person or organization # obtaining a copy of the software and accompanying documentation covered by # this license (the "Software") to use, reproduce, display, distribute, # execute, and transmit the Software, and to prepare derivative works of the # Software, and to permit third-parties to whom the Software is furnished to # do so, all subject to the following: # # The copyright notices in the Software and this entire statement, including # the above license grant, this restriction and the following disclaimer, # must be included in all copies of the Software, in whole or in part, and # all derivative works of the Software, unless such copies or derivative # works are solely in the form of machine-executable object code generated by # a source language processor. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT # SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE # FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. ############################################################################## function(topological_sort LIST PREFIX SUFFIX) # Clear the stack and output variable set(VERTICES "${${LIST}}") set(STACK) set(${LIST}) # Loop over all of the vertices, starting the topological sort from # each one. foreach(VERTEX ${VERTICES}) # If we haven't already processed this vertex, start a depth-first # search from where. if (NOT FOUND_${VERTEX}) # Push this vertex onto the stack with all of its outgoing edges string(REPLACE ";" " " NEW_ELEMENT "${VERTEX};${${PREFIX}${VERTEX}${SUFFIX}}") list(APPEND STACK ${NEW_ELEMENT}) # We've now seen this vertex set(FOUND_${VERTEX} TRUE) # While the depth-first search stack is not empty list(LENGTH STACK STACK_LENGTH) while(STACK_LENGTH GREATER 0) # Remove the vertex and its remaining out-edges from the top # of the stack list(GET STACK -1 OUT_EDGES) list(REMOVE_AT STACK -1) # Get the source vertex and the list of out-edges separate_arguments(OUT_EDGES) list(GET OUT_EDGES 0 SOURCE) list(REMOVE_AT OUT_EDGES 0) # While there are still out-edges remaining list(LENGTH OUT_EDGES OUT_DEGREE) while (OUT_DEGREE GREATER 0) # Pull off the first outgoing edge list(GET OUT_EDGES 0 TARGET) list(REMOVE_AT OUT_EDGES 0) if (NOT FOUND_${TARGET}) # We have not seen the target before, so we will traverse # its outgoing edges before coming back to our # source. This is the key to the depth-first traversal. # We've now seen this vertex set(FOUND_${TARGET} TRUE) # Push the remaining edges for the current vertex onto the # stack string(REPLACE ";" " " NEW_ELEMENT "${SOURCE};${OUT_EDGES}") list(APPEND STACK ${NEW_ELEMENT}) # Setup the new source and outgoing edges set(SOURCE ${TARGET}) set(OUT_EDGES ${${PREFIX}${SOURCE}${SUFFIX}}) endif() list(LENGTH OUT_EDGES OUT_DEGREE) endwhile () # We have finished all of the outgoing edges for # SOURCE; add it to the resulting list. list(APPEND ${LIST} ${SOURCE}) # Check the length of the stack list(LENGTH STACK STACK_LENGTH) endwhile() endif () endforeach() set(${LIST} ${${LIST}} PARENT_SCOPE) endfunction() OTB-release-5.8/CMake/UseJava.cmake000066400000000000000000000776121301006202600167530ustar00rootroot00000000000000# - Use Module for Java # This file provides functions for Java. It is assumed that FindJava.cmake # has already been loaded. See FindJava.cmake for information on how to # load Java into your CMake project. # # add_jar(TARGET_NAME SRC1 SRC2 .. SRCN RCS1 RCS2 .. RCSN) # # This command creates a .jar. It compiles the given source # files (SRC) and adds the given resource files (RCS) to the jar file. # If only resource files are given then just a jar file is created. # # Additional instructions: # To add compile flags to the target you can set these flags with # the following variable: # # set(CMAKE_JAVA_COMPILE_FLAGS -nowarn) # # To add a path or a jar file to the class path you can do this # with the CMAKE_JAVA_INCLUDE_PATH variable. # # set(CMAKE_JAVA_INCLUDE_PATH /usr/share/java/shibboleet.jar) # # To use a different output name for the target you can set it with: # # set(CMAKE_JAVA_TARGET_OUTPUT_NAME shibboleet.jar) # add_jar(foobar foobar.java) # # To add a VERSION to the target output name you can set it using # CMAKE_JAVA_TARGET_VERSION. This will create a jar file with the name # shibboleet-1.0.0.jar and will create a symlink shibboleet.jar # pointing to the jar with the version information. # # set(CMAKE_JAVA_TARGET_VERSION 1.2.0) # add_jar(shibboleet shibbotleet.java) # # If the target is a JNI library, utilize the following commands to # create a JNI symbolic link: # # set(CMAKE_JNI_TARGET TRUE) # set(CMAKE_JAVA_TARGET_VERSION 1.2.0) # add_jar(shibboleet shibbotleet.java) # install_jar(shibboleet ${LIB_INSTALL_DIR}/shibboleet) # install_jni_symlink(shibboleet ${JAVA_LIB_INSTALL_DIR}) # # If a single target needs to produce more than one jar from its # java source code, to prevent the accumulation of duplicate class # files in subsequent jars, set/reset CMAKE_JAR_CLASSES_PREFIX prior # to calling the add_jar() function: # # set(CMAKE_JAR_CLASSES_PREFIX com/redhat/foo) # add_jar(foo foo.java) # # set(CMAKE_JAR_CLASSES_PREFIX com/redhat/bar) # add_jar(bar bar.java) # # Target Properties: # The add_jar() functions sets some target properties. You can get these # properties with the # get_property(TARGET PROPERTY ) # command. # # INSTALL_FILES The files which should be installed. This is used by # install_jar(). # JNI_SYMLINK The JNI symlink which should be installed. # This is used by install_jni_symlink(). # JAR_FILE The location of the jar file so that you can include # it. # CLASS_DIR The directory where the class files can be found. For # example to use them with javah. # # find_jar( # name | NAMES name1 [name2 ...] # [PATHS path1 [path2 ... ENV var]] # [VERSIONS version1 [version2]] # [DOC "cache documentation string"] # ) # # This command is used to find a full path to the named jar. A cache # entry named by is created to stor the result of this command. If # the full path to a jar is found the result is stored in the variable # and the search will not repeated unless the variable is cleared. If # nothing is found, the result will be -NOTFOUND, and the search # will be attempted again next time find_jar is invoked with the same # variable. # The name of the full path to a file that is searched for is specified # by the names listed after NAMES argument. Additional search locations # can be specified after the PATHS argument. If you require special a # version of a jar file you can specify it with the VERSIONS argument. # The argument after DOC will be used for the documentation string in # the cache. # # install_jar(TARGET_NAME DESTINATION) # # This command installs the TARGET_NAME files to the given DESTINATION. # It should be called in the same scope as add_jar() or it will fail. # # install_jni_symlink(TARGET_NAME DESTINATION) # # This command installs the TARGET_NAME JNI symlinks to the given # DESTINATION. It should be called in the same scope as add_jar() # or it will fail. # # create_javadoc( # PACKAGES pkg1 [pkg2 ...] # [SOURCEPATH ] # [CLASSPATH ] # [INSTALLPATH ] # [DOCTITLE "the documentation title"] # [WINDOWTITLE "the title of the document"] # [AUTHOR TRUE|FALSE] # [USE TRUE|FALSE] # [VERSION TRUE|FALSE] # ) # # Create java documentation based on files or packages. For more # details please read the javadoc manpage. # # There are two main signatures for create_javadoc. The first # signature works with package names on a path with source files: # # Example: # create_javadoc(my_example_doc # PACKAGES com.example.foo com.example.bar # SOURCEPATH ${CMAKE_CURRENT_SOURCE_PATH} # CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH} # WINDOWTITLE "My example" # DOCTITLE "

My example

" # AUTHOR TRUE # USE TRUE # VERSION TRUE # ) # # The second signature for create_javadoc works on a given list of # files. # # create_javadoc( # FILES file1 [file2 ...] # [CLASSPATH ] # [INSTALLPATH ] # [DOCTITLE "the documentation title"] # [WINDOWTITLE "the title of the document"] # [AUTHOR TRUE|FALSE] # [USE TRUE|FALSE] # [VERSION TRUE|FALSE] # ) # # Example: # create_javadoc(my_example_doc # FILES ${example_SRCS} # CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH} # WINDOWTITLE "My example" # DOCTITLE "

My example

" # AUTHOR TRUE # USE TRUE # VERSION TRUE # ) # # Both signatures share most of the options. These options are the # same as what you can find in the javadoc manpage. Please look at # the manpage for CLASSPATH, DOCTITLE, WINDOWTITLE, AUTHOR, USE and # VERSION. # # The documentation will be by default installed to # # ${CMAKE_INSTALL_PREFIX}/share/javadoc/ # # if you don't set the INSTALLPATH. # #============================================================================= # Copyright 2010-2011 Andreas schneider # Copyright 2010 Ben Boeckel # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) function (__java_copy_file src dest comment) add_custom_command( OUTPUT ${dest} COMMAND cmake -E copy_if_different ARGS ${src} ${dest} DEPENDS ${src} COMMENT ${comment}) endfunction () # define helper scripts get_filename_component(_UseJava_LIST_DIR ${CMAKE_CURRENT_LIST_FILE} PATH) set(_JAVA_CLASS_FILELIST_SCRIPT ${_UseJava_LIST_DIR}/UseJavaClassFilelist.cmake) set(_JAVA_SYMLINK_SCRIPT ${_UseJava_LIST_DIR}/UseJavaSymlinks.cmake) function(add_jar _TARGET_NAME) set(_JAVA_SOURCE_FILES ${ARGN}) if (LIBRARY_OUTPUT_PATH) set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH}) else () set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}) endif () set(CMAKE_JAVA_INCLUDE_PATH ${CMAKE_JAVA_INCLUDE_PATH} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_JAVA_OBJECT_OUTPUT_PATH} ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH} ) if (WIN32 AND NOT CYGWIN) set(CMAKE_JAVA_INCLUDE_FLAG_SEP ";") else () set(CMAKE_JAVA_INCLUDE_FLAG_SEP ":") endif() foreach (JAVA_INCLUDE_DIR ${CMAKE_JAVA_INCLUDE_PATH}) set(CMAKE_JAVA_INCLUDE_PATH_FINAL "${CMAKE_JAVA_INCLUDE_PATH_FINAL}${CMAKE_JAVA_INCLUDE_FLAG_SEP}${JAVA_INCLUDE_DIR}") endforeach() set(CMAKE_JAVA_CLASS_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir") set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}.jar") if (CMAKE_JAVA_TARGET_OUTPUT_NAME AND CMAKE_JAVA_TARGET_VERSION) set(_JAVA_TARGET_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}-${CMAKE_JAVA_TARGET_VERSION}.jar") set(_JAVA_TARGET_OUTPUT_LINK "${CMAKE_JAVA_TARGET_OUTPUT_NAME}.jar") elseif (CMAKE_JAVA_TARGET_VERSION) set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}-${CMAKE_JAVA_TARGET_VERSION}.jar") set(_JAVA_TARGET_OUTPUT_LINK "${_TARGET_NAME}.jar") elseif (CMAKE_JAVA_TARGET_OUTPUT_NAME) set(_JAVA_TARGET_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}.jar") endif () # reset set(CMAKE_JAVA_TARGET_OUTPUT_NAME) set(_JAVA_CLASS_FILES) set(_JAVA_COMPILE_FILES) set(_JAVA_DEPENDS) set(_JAVA_RESOURCE_FILES) foreach(_JAVA_SOURCE_FILE ${_JAVA_SOURCE_FILES}) get_filename_component(_JAVA_EXT ${_JAVA_SOURCE_FILE} EXT) get_filename_component(_JAVA_FILE ${_JAVA_SOURCE_FILE} NAME_WE) get_filename_component(_JAVA_PATH ${_JAVA_SOURCE_FILE} PATH) get_filename_component(_JAVA_FULL ${_JAVA_SOURCE_FILE} ABSOLUTE) file(RELATIVE_PATH _JAVA_REL_BINARY_PATH ${CMAKE_CURRENT_BINARY_DIR} ${_JAVA_FULL}) file(RELATIVE_PATH _JAVA_REL_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${_JAVA_FULL}) string(LENGTH ${_JAVA_REL_BINARY_PATH} _BIN_LEN) string(LENGTH ${_JAVA_REL_SOURCE_PATH} _SRC_LEN) if (${_BIN_LEN} LESS ${_SRC_LEN}) set(_JAVA_REL_PATH ${_JAVA_REL_BINARY_PATH}) else () set(_JAVA_REL_PATH ${_JAVA_REL_SOURCE_PATH}) endif () get_filename_component(_JAVA_REL_PATH ${_JAVA_REL_PATH} PATH) if (_JAVA_EXT MATCHES ".java") list(APPEND _JAVA_COMPILE_FILES ${_JAVA_SOURCE_FILE}) set(_JAVA_CLASS_FILE "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_REL_PATH}/${_JAVA_FILE}.class") set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES} ${_JAVA_CLASS_FILE}) elseif (_JAVA_EXT MATCHES ".jar" OR _JAVA_EXT MATCHES ".war" OR _JAVA_EXT MATCHES ".ear" OR _JAVA_EXT MATCHES ".sar") list(APPEND CMAKE_JAVA_INCLUDE_PATH ${_JAVA_SOURCE_FILE}) elseif (_JAVA_EXT STREQUAL "") list(APPEND CMAKE_JAVA_INCLUDE_PATH ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}} ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}_CLASSPATH}) list(APPEND _JAVA_DEPENDS ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}}) else () __java_copy_file(${CMAKE_CURRENT_SOURCE_DIR}/${_JAVA_SOURCE_FILE} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE} "Copying ${_JAVA_SOURCE_FILE} to the build directory") list(APPEND _JAVA_RESOURCE_FILES ${_JAVA_SOURCE_FILE}) endif () endforeach() # create an empty java_class_filelist if (NOT EXISTS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist) file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist "") endif() if (_JAVA_COMPILE_FILES) # Compile the java files and create a list of class files add_custom_command( # NOTE: this command generates an artificial dependency file OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME} COMMAND ${Java_JAVAC_EXECUTABLE} ${CMAKE_JAVA_COMPILE_FLAGS} -classpath "${CMAKE_JAVA_INCLUDE_PATH_FINAL}" -d ${CMAKE_JAVA_CLASS_OUTPUT_PATH} ${_JAVA_COMPILE_FILES} COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME} DEPENDS ${_JAVA_COMPILE_FILES} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMENT "Building Java objects for ${_TARGET_NAME}.jar" ) add_custom_command( OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist COMMAND ${CMAKE_COMMAND} -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH} -DCMAKE_JAR_CLASSES_PREFIX="${CMAKE_JAR_CLASSES_PREFIX}" -P ${_JAVA_CLASS_FILELIST_SCRIPT} DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) endif () # create the jar file if (CMAKE_JNI_TARGET) add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} COMMAND ${Java_JAR_EXECUTABLE} -cf ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} ${_JAVA_RESOURCE_FILES} @java_class_filelist COMMAND ${CMAKE_COMMAND} -D_JAVA_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR} -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME} -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK} -P ${_JAVA_SYMLINK_SCRIPT} COMMAND ${CMAKE_COMMAND} -D_JAVA_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR} -D_JAVA_TARGET_OUTPUT_NAME=${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK} -P ${_JAVA_SYMLINK_SCRIPT} DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH} COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}" ) else () add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} COMMAND ${Java_JAR_EXECUTABLE} -cf ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} ${_JAVA_RESOURCE_FILES} @java_class_filelist COMMAND ${CMAKE_COMMAND} -D_JAVA_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR} -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME} -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK} -P ${_JAVA_SYMLINK_SCRIPT} WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH} DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}" ) endif () # Add the target and make sure we have the latest resource files. add_custom_target(${_TARGET_NAME} ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME}) set_property( TARGET ${_TARGET_NAME} PROPERTY INSTALL_FILES ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} ) if (_JAVA_TARGET_OUTPUT_LINK) set_property( TARGET ${_TARGET_NAME} PROPERTY INSTALL_FILES ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_LINK} ) if (CMAKE_JNI_TARGET) set_property( TARGET ${_TARGET_NAME} PROPERTY JNI_SYMLINK ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_LINK} ) endif () endif () set_property( TARGET ${_TARGET_NAME} PROPERTY JAR_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_JAVA_TARGET_OUTPUT_NAME} ) set_property( TARGET ${_TARGET_NAME} PROPERTY CLASSDIR ${CMAKE_JAVA_CLASS_OUTPUT_PATH} ) endfunction() function(INSTALL_JAR _TARGET_NAME _DESTINATION) get_property(__FILES TARGET ${_TARGET_NAME} PROPERTY INSTALL_FILES ) if (__FILES) install( FILES ${__FILES} DESTINATION ${_DESTINATION} ) else () message(SEND_ERROR "The target ${_TARGET_NAME} is not known in this scope.") endif () endfunction() function(INSTALL_JNI_SYMLINK _TARGET_NAME _DESTINATION) get_property(__SYMLINK TARGET ${_TARGET_NAME} PROPERTY JNI_SYMLINK ) if (__SYMLINK) install( FILES ${__SYMLINK} DESTINATION ${_DESTINATION} ) else () message(SEND_ERROR "The target ${_TARGET_NAME} is not known in this scope.") endif () endfunction() function (find_jar VARIABLE) set(_jar_names) set(_jar_files) set(_jar_versions) set(_jar_paths /usr/share/java/ /usr/local/share/java/ ${Java_JAR_PATHS}) set(_jar_doc "NOTSET") set(_state "name") foreach (arg ${ARGN}) if (${_state} STREQUAL "name") if (${arg} STREQUAL "VERSIONS") set(_state "versions") elseif (${arg} STREQUAL "NAMES") set(_state "names") elseif (${arg} STREQUAL "PATHS") set(_state "paths") elseif (${arg} STREQUAL "DOC") set(_state "doc") else () set(_jar_names ${arg}) if (_jar_doc STREQUAL "NOTSET") set(_jar_doc "Finding ${arg} jar") endif () endif () elseif (${_state} STREQUAL "versions") if (${arg} STREQUAL "NAMES") set(_state "names") elseif (${arg} STREQUAL "PATHS") set(_state "paths") elseif (${arg} STREQUAL "DOC") set(_state "doc") else () set(_jar_versions ${_jar_versions} ${arg}) endif () elseif (${_state} STREQUAL "names") if (${arg} STREQUAL "VERSIONS") set(_state "versions") elseif (${arg} STREQUAL "PATHS") set(_state "paths") elseif (${arg} STREQUAL "DOC") set(_state "doc") else () set(_jar_names ${_jar_names} ${arg}) if (_jar_doc STREQUAL "NOTSET") set(_jar_doc "Finding ${arg} jar") endif () endif () elseif (${_state} STREQUAL "paths") if (${arg} STREQUAL "VERSIONS") set(_state "versions") elseif (${arg} STREQUAL "NAMES") set(_state "names") elseif (${arg} STREQUAL "DOC") set(_state "doc") else () set(_jar_paths ${_jar_paths} ${arg}) endif () elseif (${_state} STREQUAL "doc") if (${arg} STREQUAL "VERSIONS") set(_state "versions") elseif (${arg} STREQUAL "NAMES") set(_state "names") elseif (${arg} STREQUAL "PATHS") set(_state "paths") else () set(_jar_doc ${arg}) endif () endif () endforeach () if (${_jar_names} STREQUAL "") message(FATAL_ERROR "find_jar: No name to search for given") endif () foreach (jar_name ${_jar_names}) foreach (version ${_jar_versions}) set(_jar_files ${_jar_files} ${jar_name}-${version}.jar) endforeach () set(_jar_files ${_jar_files} ${jar_name}.jar) endforeach () find_file(${VARIABLE} NAMES ${_jar_files} PATHS ${_jar_paths} DOC ${_jar_doc} NO_DEFAULT_PATH) endfunction () function(create_javadoc _target) set(_javadoc_packages) set(_javadoc_files) set(_javadoc_sourcepath) set(_javadoc_classpath) set(_javadoc_installpath "${CMAKE_INSTALL_PREFIX}/share/javadoc") set(_javadoc_doctitle) set(_javadoc_windowtitle) set(_javadoc_author FALSE) set(_javadoc_version FALSE) set(_javadoc_use FALSE) set(_state "package") foreach (arg ${ARGN}) if (${_state} STREQUAL "package") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () set(_javadoc_packages ${arg}) set(_state "packages") endif () elseif (${_state} STREQUAL "packages") if (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_packages ${arg}) endif () elseif (${_state} STREQUAL "files") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_files ${arg}) endif () elseif (${_state} STREQUAL "sourcepath") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_sourcepath ${arg}) endif () elseif (${_state} STREQUAL "classpath") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_classpath ${arg}) endif () elseif (${_state} STREQUAL "installpath") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () set(_javadoc_installpath ${arg}) endif () elseif (${_state} STREQUAL "doctitle") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () set(_javadoc_doctitle ${arg}) endif () elseif (${_state} STREQUAL "windowtitle") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () set(_javadoc_windowtitle ${arg}) endif () elseif (${_state} STREQUAL "author") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () set(_javadoc_author ${arg}) endif () elseif (${_state} STREQUAL "use") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () set(_javadoc_use ${arg}) endif () elseif (${_state} STREQUAL "version") if (${arg} STREQUAL "PACKAGES") set(_state "packages") elseif (${arg} STREQUAL "FILES") set(_state "files") elseif (${arg} STREQUAL "SOURCEPATH") set(_state "sourcepath") elseif (${arg} STREQUAL "CLASSPATH") set(_state "classpath") elseif (${arg} STREQUAL "INSTALLPATH") set(_state "installpath") elseif (${arg} STREQUAL "DOCTITLE") set(_state "doctitle") elseif (${arg} STREQUAL "WINDOWTITLE") set(_state "windowtitle") elseif (${arg} STREQUAL "AUTHOR") set(_state "author") elseif (${arg} STREQUAL "USE") set(_state "use") elseif (${arg} STREQUAL "VERSION") set(_state "version") else () set(_javadoc_version ${arg}) endif () endif () endforeach () set(_javadoc_builddir ${CMAKE_CURRENT_BINARY_DIR}/javadoc/${_target}) set(_javadoc_options -d ${_javadoc_builddir}) if (_javadoc_sourcepath) set(_start TRUE) foreach(_path ${_javadoc_sourcepath}) if (_start) set(_sourcepath ${_path}) set(_start FALSE) else () set(_sourcepath ${_sourcepath}:${_path}) endif () endforeach() set(_javadoc_options ${_javadoc_options} -sourcepath ${_sourcepath}) endif () if (_javadoc_classpath) set(_start TRUE) foreach(_path ${_javadoc_classpath}) if (_start) set(_classpath ${_path}) set(_start FALSE) else () set(_classpath ${_classpath}:${_path}) endif () endforeach() set(_javadoc_options ${_javadoc_options} -classpath "${_classpath}") endif () if (_javadoc_doctitle) set(_javadoc_options ${_javadoc_options} -doctitle '${_javadoc_doctitle}') endif () if (_javadoc_windowtitle) set(_javadoc_options ${_javadoc_options} -windowtitle '${_javadoc_windowtitle}') endif () if (_javadoc_author) set(_javadoc_options ${_javadoc_options} -author) endif () if (_javadoc_use) set(_javadoc_options ${_javadoc_options} -use) endif () if (_javadoc_version) set(_javadoc_options ${_javadoc_options} -version) endif () add_custom_target(${_target}_javadoc ALL COMMAND ${Java_JAVADOC_EXECUTABLE} ${_javadoc_options} ${_javadoc_files} ${_javadoc_packages} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) install( DIRECTORY ${_javadoc_builddir} DESTINATION ${_javadoc_installpath} ) endfunction() OTB-release-5.8/CMake/UseJavaClassFilelist.cmake000066400000000000000000000042101301006202600214150ustar00rootroot00000000000000# # This script create a list of compiled Java class files to be added to a # jar file. This avoids including cmake files which get created in the # binary directory. # #============================================================================= # Copyright 2010-2011 Andreas schneider # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) if (CMAKE_JAVA_CLASS_OUTPUT_PATH) if (EXISTS "${CMAKE_JAVA_CLASS_OUTPUT_PATH}") set(_JAVA_GLOBBED_FILES) if (CMAKE_JAR_CLASSES_PREFIX) foreach(JAR_CLASS_PREFIX ${CMAKE_JAR_CLASSES_PREFIX}) message(STATUS "JAR_CLASS_PREFIX: ${JAR_CLASS_PREFIX}") file(GLOB_RECURSE _JAVA_GLOBBED_TMP_FILES "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${JAR_CLASS_PREFIX}/*.class") if (_JAVA_GLOBBED_TMP_FILES) list(APPEND _JAVA_GLOBBED_FILES ${_JAVA_GLOBBED_TMP_FILES}) endif () endforeach() else() file(GLOB_RECURSE _JAVA_GLOBBED_FILES "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/*.class") endif () set(_JAVA_CLASS_FILES) # file(GLOB_RECURSE foo RELATIVE) is broken so we need this. foreach(_JAVA_GLOBBED_FILE ${_JAVA_GLOBBED_FILES}) file(RELATIVE_PATH _JAVA_CLASS_FILE ${CMAKE_JAVA_CLASS_OUTPUT_PATH} ${_JAVA_GLOBBED_FILE}) set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES}${_JAVA_CLASS_FILE}\n) endforeach() # write to file file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist ${_JAVA_CLASS_FILES}) else () message(SEND_ERROR "FATAL: Java class output path doesn't exist") endif () else () message(SEND_ERROR "FATAL: Can't find CMAKE_JAVA_CLASS_OUTPUT_PATH") endif () OTB-release-5.8/CMake/UseJavaSymlinks.cmake000066400000000000000000000021351301006202600204710ustar00rootroot00000000000000# # Helper script for UseJava.cmake # #============================================================================= # Copyright 2010-2011 Andreas schneider # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) if (UNIX AND _JAVA_TARGET_OUTPUT_LINK) if (_JAVA_TARGET_OUTPUT_NAME) find_program(LN_EXECUTABLE NAMES ln ) execute_process( COMMAND ${LN_EXECUTABLE} -sf "${_JAVA_TARGET_OUTPUT_NAME}" "${_JAVA_TARGET_OUTPUT_LINK}" WORKING_DIRECTORY ${_JAVA_TARGET_DIR} ) else () message(SEND_ERROR "FATAL: Can't find _JAVA_TARGET_OUTPUT_NAME") endif () endif () OTB-release-5.8/CMake/UseOTB.cmake000066400000000000000000000026331301006202600165050ustar00rootroot00000000000000# This file sets up include directories, link directories, and # compiler settings for a project to use OTB. It should not be # included directly, but rather through the OTB_USE_FILE setting # obtained from OTBConfig.cmake. # Add compiler flags needed to use OTB. set(CMAKE_C_FLAGS "${OTB_REQUIRED_C_FLAGS} ${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} ${CMAKE_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}") set(CMAKE_SHARED_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}") # Add include directories needed to use OTB. include_directories(${OTB_INCLUDE_DIRS}) # Add link directories needed to use OTB. link_directories(${OTB_LIBRARY_DIRS}) # find_package() are already done (in OTBConfig.cmake) # perform include(UseFile) for all external dependencies # ITK : don't call UseFile to avoid the include_directorties(BEFORE ...) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ITK_REQUIRED_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ITK_REQUIRED_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}") # OpenCV : no USE_FILE defined OTB-release-5.8/CMake/UseSWIGLocal.cmake000066400000000000000000000251361301006202600176100ustar00rootroot00000000000000# - SWIG module for CMake # Defines the following macros: # SWIG_ADD_MODULE(name language [ files ]) # - Define swig module with given name and specified language # SWIG_LINK_LIBRARIES(name [ libraries ]) # - Link libraries to swig module # All other macros are for internal use only. # To get the actual name of the swig module, # use: ${SWIG_MODULE_${name}_REAL_NAME}. # Set Source files properties such as CPLUSPLUS and SWIG_FLAGS to specify # special behavior of SWIG. Also global CMAKE_SWIG_FLAGS can be used to add # special flags to all swig calls. # Another special variable is CMAKE_SWIG_OUTDIR, it allows one to specify # where to write all the swig generated module (swig -outdir option) # The name-specific variable SWIG_MODULE__EXTRA_DEPS may be used # to specify extra dependencies for the generated modules. # If the source file generated by swig need some special flag you can use # set_source_files_properties( ${swig_generated_file_fullname} # PROPERTIES COMPILE_FLAGS "-bla") #============================================================================= # Copyright 2004-2009 Kitware, Inc. # Copyright 2009 Mathieu Malaterre # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distributed this file outside of CMake, substitute the full # License text for the above reference.) set(SWIG_CXX_EXTENSION "cxx") set(SWIG_EXTRA_LIBRARIES "") set(SWIG_PYTHON_EXTRA_FILE_EXTENSION "py") # # For given swig module initialize variables associated with it # macro(SWIG_MODULE_INITIALIZE name language) string(TOUPPER "${language}" swig_uppercase_language) string(TOLOWER "${language}" swig_lowercase_language) set(SWIG_MODULE_${name}_LANGUAGE "${swig_uppercase_language}") set(SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG "${swig_lowercase_language}") if("x${SWIG_MODULE_${name}_LANGUAGE}x" MATCHES "^xUNKNOWNx$") message(FATAL_ERROR "SWIG Error: Language \"${language}\" not found") endif() set(SWIG_MODULE_${name}_REAL_NAME "${name}") if("x${SWIG_MODULE_${name}_LANGUAGE}x" MATCHES "^xPYTHONx$") # when swig is used without the -interface it will produce in the module.py # a 'import _modulename' statement, which implies having a corresponding # _modulename.so (*NIX), _modulename.pyd (Win32). set(SWIG_MODULE_${name}_REAL_NAME "_${name}") endif() if("x${SWIG_MODULE_${name}_LANGUAGE}x" MATCHES "^xRUBYx$") string(TOLOWER "${name}" ruby_module_name) set(SWIG_MODULE_${name}_REAL_NAME "${ruby_module_name}") endif() if("x${SWIG_MODULE_${name}_LANGUAGE}x" MATCHES "^xPERLx$") set(SWIG_MODULE_${name}_EXTRA_FLAGS "-shadow") endif() endmacro() # # For a given language, input file, and output file, determine extra files that # will be generated. This is internal swig macro. # macro(SWIG_GET_EXTRA_OUTPUT_FILES language outfiles generatedpath infile) get_source_file_property(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename ${infile} SWIG_MODULE_NAME) if(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename STREQUAL "NOTFOUND") get_filename_component(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename "${infile}" NAME_WE) endif() foreach(it ${SWIG_${language}_EXTRA_FILE_EXTENSION}) set(${outfiles} ${${outfiles}} "${generatedpath}/${SWIG_GET_EXTRA_OUTPUT_FILES_module_basename}.${it}") endforeach() endmacro() # # Take swig (*.i) file and add proper custom commands for it # macro(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile) set(swig_full_infile ${infile}) get_filename_component(swig_source_file_path "${infile}" PATH) get_filename_component(swig_source_file_name_we "${infile}" NAME_WE) get_source_file_property(swig_source_file_generated ${infile} GENERATED) get_source_file_property(swig_source_file_cplusplus ${infile} CPLUSPLUS) get_source_file_property(swig_source_file_flags ${infile} SWIG_FLAGS) if("${swig_source_file_flags}" STREQUAL "NOTFOUND") set(swig_source_file_flags "") endif() set(swig_source_file_fullname "${infile}") if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_SOURCE_DIR}") string(REGEX REPLACE "^${CMAKE_CURRENT_SOURCE_DIR}" "" swig_source_file_relative_path "${swig_source_file_path}") else() if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_BINARY_DIR}") string(REGEX REPLACE "^${CMAKE_CURRENT_BINARY_DIR}" "" swig_source_file_relative_path "${swig_source_file_path}") set(swig_source_file_generated 1) else() set(swig_source_file_relative_path "${swig_source_file_path}") if(swig_source_file_generated) set(swig_source_file_fullname "${CMAKE_CURRENT_BINARY_DIR}/${infile}") else() set(swig_source_file_fullname "${CMAKE_CURRENT_SOURCE_DIR}/${infile}") endif() endif() endif() set(swig_generated_file_fullname "${CMAKE_CURRENT_BINARY_DIR}") if(swig_source_file_relative_path) set(swig_generated_file_fullname "${swig_generated_file_fullname}/${swig_source_file_relative_path}") endif() # If CMAKE_SWIG_OUTDIR was specified then pass it to -outdir if(CMAKE_SWIG_OUTDIR) set(swig_outdir ${CMAKE_SWIG_OUTDIR}) # it may not exist, so create it: file(MAKE_DIRECTORY ${CMAKE_SWIG_OUTDIR}) else() set(swig_outdir ${CMAKE_CURRENT_BINARY_DIR}) endif() # cleanup swig_extra_generated_files content for multi-langage wrapping support set(swig_extra_generated_files) SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE} swig_extra_generated_files "${swig_outdir}" "${infile}") set(swig_generated_file_fullname "${swig_generated_file_fullname}/${swig_source_file_name_we}") # add the language into the name of the file (i.e. TCL_wrap) # this allows for the same .i file to be wrapped into different languages set(swig_generated_file_fullname "${swig_generated_file_fullname}${SWIG_MODULE_${name}_LANGUAGE}_wrap") if(swig_source_file_cplusplus) set(swig_generated_file_fullname "${swig_generated_file_fullname}.${SWIG_CXX_EXTENSION}") else() set(swig_generated_file_fullname "${swig_generated_file_fullname}.c") endif() #message("Full path to source file: ${swig_source_file_fullname}") #message("Full path to the output file: ${swig_generated_file_fullname}") get_directory_property(cmake_include_directories INCLUDE_DIRECTORIES) set(swig_include_dirs) foreach(it ${cmake_include_directories}) set(swig_include_dirs ${swig_include_dirs} "-I${it}") endforeach() set(swig_special_flags) # default is c, so add c++ flag if it is c++ if(swig_source_file_cplusplus) set(swig_special_flags ${swig_special_flags} "-c++") endif() set(swig_extra_flags) if(SWIG_MODULE_${name}_EXTRA_FLAGS) set(swig_extra_flags ${swig_extra_flags} ${SWIG_MODULE_${name}_EXTRA_FLAGS}) endif() add_custom_command( OUTPUT "${swig_generated_file_fullname}" ${swig_extra_generated_files} COMMAND "${SWIG_EXECUTABLE}" ARGS "-${SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG}" ${swig_source_file_flags} ${CMAKE_SWIG_FLAGS} -outdir ${swig_outdir} ${swig_special_flags} ${swig_extra_flags} ${swig_include_dirs} -o "${swig_generated_file_fullname}" "${swig_source_file_fullname}" MAIN_DEPENDENCY "${swig_source_file_fullname}" DEPENDS ${SWIG_MODULE_${name}_EXTRA_DEPS} COMMENT "Swig source to generate ${SWIG_MODULE_${name}_LANGUAGE} wrapping") set_source_files_properties("${swig_generated_file_fullname}" ${swig_extra_generated_files} PROPERTIES GENERATED 1) set(${outfiles} "${swig_generated_file_fullname}" ${swig_extra_generated_files}) endmacro() # # Create Swig module # macro(SWIG_ADD_MODULE name language) SWIG_MODULE_INITIALIZE(${name} ${language}) set(swig_dot_i_sources) set(swig_other_sources) foreach(it ${ARGN}) if(${it} MATCHES ".*\\.i$") set(swig_dot_i_sources ${swig_dot_i_sources} "${it}") else() set(swig_other_sources ${swig_other_sources} "${it}") endif() endforeach() set(swig_generated_sources) foreach(it ${swig_dot_i_sources}) SWIG_ADD_SOURCE_TO_MODULE(${name} swig_generated_source ${it}) set(swig_generated_sources ${swig_generated_sources} "${swig_generated_source}") endforeach() get_directory_property(swig_extra_clean_files ADDITIONAL_MAKE_CLEAN_FILES) set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${swig_extra_clean_files};${swig_generated_sources}") add_library(${SWIG_MODULE_${name}_REAL_NAME} MODULE ${swig_generated_sources} ${swig_other_sources}) string(TOLOWER "${language}" swig_lowercase_language) if("${swig_lowercase_language}" STREQUAL "java") if(APPLE) # In java you want: # System.loadLibrary("LIBRARY"); # then JNI will look for a library whose name is platform dependent, namely # MacOS : libLIBRARY.jnilib # Windows: LIBRARY.dll # Linux : libLIBRARY.so set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES SUFFIX ".jnilib") endif() endif() if("${swig_lowercase_language}" STREQUAL "python") # this is only needed for the python case where a _modulename.so is generated set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES PREFIX "") # Python extension modules on Windows must have the extension ".pyd" # instead of ".dll" as of Python 2.5. Older python versions do support # this suffix. # http://docs.python.org/whatsnew/ports.html#SECTION0001510000000000000000 # # Windows: .dll is no longer supported as a filename extension for extension modules. # .pyd is now the only filename extension that will be searched for. # if(WIN32 AND NOT CYGWIN) set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES SUFFIX ".pyd") endif() endif() if("${swig_lowercase_language}" STREQUAL "ruby") set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES PREFIX "") if(APPLE) set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES SUFFIX ".bundle") set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES COMPILE_FLAGS "-bundle") endif() endif() endmacro() # # Like TARGET_LINK_LIBRARIES but for swig modules # macro(SWIG_LINK_LIBRARIES name) if(SWIG_MODULE_${name}_REAL_NAME) target_link_libraries(${SWIG_MODULE_${name}_REAL_NAME} ${ARGN}) else() message(SEND_ERROR "Cannot find Swig library \"${name}\".") endif() endmacro() OTB-release-5.8/CMake/cmake_uninstall.cmake.in000066400000000000000000000035121301006202600211570ustar00rootroot00000000000000if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt") return() endif() file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files) string(REGEX REPLACE "\n" ";" files "${files}") foreach(file ${files}) message(STATUS "Uninstalling $ENV{DESTDIR}${file}") if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") execute_process(COMMAND "@CMAKE_COMMAND@" -E remove "$ENV{DESTDIR}${file}" OUTPUT_VARIABLE out_var RESULT_VARIABLE res_var ) if(NOT "${res_var}" STREQUAL 0) message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") endif() else() message(STATUS "File $ENV{DESTDIR}${file} does not exist.") endif() endforeach(file) set(otb_dir_name "OTB-@OTB_VERSION_MAJOR@.@OTB_VERSION_MINOR@") set(installed_dirs) # include/OTB-X.Y directory list(APPEND installed_dirs "@CMAKE_INSTALL_PREFIX@/include/${otb_dir_name}") # lib/{otb,python} directory list(APPEND installed_dirs "@CMAKE_INSTALL_PREFIX@/lib/otb") # lib/cmake/OTB-X.Y directory list(APPEND installed_dirs "@CMAKE_INSTALL_PREFIX@/lib/cmake/${otb_dir_name}") # share/OTB-X.Y directory list(APPEND installed_dirs "@CMAKE_INSTALL_PREFIX@/share/${otb_dir_name}") # share/doc/OTB-X.Y directory list(APPEND installed_dirs "@CMAKE_INSTALL_PREFIX@/share/doc/${otb_dir_name}") foreach(installed_dir ${installed_dirs}) message(STATUS "Uninstalling ${installed_dir}") if(EXISTS "${installed_dir}" AND IS_DIRECTORY "${installed_dir}") execute_process(COMMAND "@CMAKE_COMMAND@" -E remove_directory "${installed_dir}" OUTPUT_VARIABLE out_rmdir RESULT_VARIABLE res_rmdir ) if(NOT "${res_rmdir}" STREQUAL 0) message(FATAL_ERROR "Problem when removing ${installed_dir}") endif() endif() endforeach() OTB-release-5.8/CMake/i18n_qt4.cmake000066400000000000000000000053731301006202600167570ustar00rootroot00000000000000# # Reset Qt I18N source files cache variable. macro( reset_qt4_i18n_sources ) set( OTB_QT_I18N_INCLUDE_PATH "" CACHE INTERNAL "" FORCE ) set( OTB_QT_I18N_HEADER_FILES "" CACHE INTERNAL "" FORCE ) set( OTB_QT_I18N_SOURCE_FILES "" CACHE INTERNAL "" FORCE ) set( OTB_QT_I18N_FORM_FILES "" CACHE INTERNAL "" FORCE ) endmacro() # string( REPLACE ".cxx" ".h" OTB_QT_I18N_HEADER_FILES OTB_QT_I18N_SOURCE_FILES ) # string( REPLACE ".cxx" ".ui" OTB_QT_I18N_HEADER_FILES OTB_QT_I18N_SOURCE_FILES ) # # Func function( add_to_qt4_i18n_files RESULT ) foreach( F ${ARGN} ) #message( "${F}" ) get_filename_component( ABS_FILE ${F} ABSOLUTE ) set(${RESULT} ${${RESULT}} ${ABS_FILE} CACHE INTERNAL "") endforeach() endfunction() # # macro( add_to_qt4_i18n_include_path DIRECTORY ) set(OTB_I18N_INCLUDE_PATH ${OTB_I18N_INCLUDE_PATH} ${DIRECTORY} CACHE INTERNAL "") endmacro() # # macro( add_to_qt4_i18n_headers INCLUDE_DIR ) get_filename_component( ABS_INCLUDE_DIR ${INCLUDE_DIR} ABSOLUTE ) set(OTB_QT_I18N_INCLUDE_PATH ${OTB_QT_I18N_INCLUDE_PATH} ${ABS_INCLUDE_DIR} CACHE INTERNAL "") foreach( F ${ARGN} ) string( REPLACE ".cxx" ".h" HEADER ${F} ) set( ABS_HEADER "${ABS_INCLUDE_DIR}/${HEADER}" ) if(EXISTS ${ABS_HEADER}) set(OTB_QT_I18N_HEADER_FILES ${OTB_QT_I18N_HEADER_FILES} ${ABS_HEADER} CACHE INTERNAL "") endif() endforeach() endmacro() # # Add source files to Qt I18n translation build. macro( add_to_qt4_i18n_sources ) add_to_qt4_i18n_files( OTB_QT_I18N_SOURCE_FILES ${ARGN} ) endmacro() # # Add source files to Qt I18n translation build. macro( add_to_qt4_i18n_forms ) add_to_qt4_i18n_files( OTB_QT_I18N_FORM_FILES ${ARGN} ) endmacro() # # macro( generate_qt4_project FILENAME ) message( STATUS "Generating Qt4 '${FILENAME}' project file for I18N." ) unset(_OTB_QT_I18N_INCLUDE_PATH_PRO) unset(_OTB_QT_I18N_HEADER_PRO) unset(_OTB_QT_I18N_SOURCE_PRO) unset(_OTB_QT_I18N_FORM_PRO) foreach(_path ${OTB_QT_I18N_INCLUDE_PATH}) set(_OTB_QT_I18N_INCLUDE_PATH_PRO "${_OTB_QT_I18N_INCLUDE_PATH_PRO} \"${_path}\"") endforeach() foreach(_file ${OTB_QT_I18N_HEADER_FILES}) set(_OTB_QT_I18N_HEADER_PRO "${_OTB_QT_I18N_HEADER_PRO} \"${_file}\"") endforeach() foreach(_file ${OTB_QT_I18N_SOURCE_FILES}) set(_OTB_QT_I18N_SOURCE_PRO "${_OTB_QT_I18N_SOURCE_PRO} \"${_file}\"") endforeach() foreach(_file ${OTB_QT_I18N_FORM_FILES}) set(_OTB_QT_I18N_FORM_PRO "${_OTB_QT_I18N_FORM_PRO} \"${_file}\"") endforeach() file( WRITE ${FILENAME} "# OTB autogenerated .pro file needed to generate Qt I18N translations INCLUDEPATH = ${_OTB_QT_I18N_INCLUDE_PATH_PRO} HEADERS = ${_OTB_QT_I18N_HEADER_PRO} SOURCES = ${_OTB_QT_I18N_SOURCE_PRO} FORMS = ${_OTB_QT_I18N_FORM_PRO} " ) endmacro() OTB-release-5.8/CMake/otbTestNumpy.py000066400000000000000000000000501301006202600174200ustar00rootroot00000000000000import numpy print(numpy.get_include()) OTB-release-5.8/CMake/otbcli.bat.in000066400000000000000000000012471301006202600167530ustar00rootroot00000000000000@echo off :: :: Autogenerated by OTB installation process :: DO NOT MODIFY :: set CURRENT_SCRIPT_DIR=%~dp0 if exist %CURRENT_SCRIPT_DIR%otbApplicationLauncherCommandLine.exe ( :: Prefer using the launcher inside the script dir set OTB_CLI_LAUNCHER=%CURRENT_SCRIPT_DIR%otbApplicationLauncherCommandLine.exe ) else ( :: Use the one from the PATH set OTB_CLI_LAUNCHER=otbApplicationLauncherCommandLine.exe ) setlocal :: works for install tree if exist %CURRENT_SCRIPT_DIR%../@OTB_INSTALL_APP_DIR@ ( set OTB_APPLICATION_PATH=%CURRENT_SCRIPT_DIR%../@OTB_INSTALL_APP_DIR@;%OTB_APPLICATION_PATH% ) set LC_NUMERIC=C :: start the application %OTB_CLI_LAUNCHER% %* endlocal OTB-release-5.8/CMake/otbcli.sh.in000066400000000000000000000016351301006202600166200ustar00rootroot00000000000000#!/bin/sh # # Autogenerated by OTB installation process # DO NOT MODIFY # CURRENT_SCRIPT_DIR=$(dirname "$0") if [ -e "$CURRENT_SCRIPT_DIR/otbApplicationLauncherCommandLine" ] then # Prefer using the launcher inside the script dir OTB_CLI_LAUNCHER=$CURRENT_SCRIPT_DIR/otbApplicationLauncherCommandLine else # Use the one from the PATH OTB_CLI_LAUNCHER=otbApplicationLauncherCommandLine fi # works for install tree if [ -d "$CURRENT_SCRIPT_DIR/../@OTB_INSTALL_APP_DIR@" ] then OTB_APPLICATION_PATH=$CURRENT_SCRIPT_DIR/../@OTB_INSTALL_APP_DIR@:$OTB_APPLICATION_PATH fi # export it to make it available to otbApplicationLauncherCommandLine environment export OTB_APPLICATION_PATH # avoid numerical issues caused by locale export LC_NUMERIC=C # Source GDAL_DATA, EPSG_CSV if [ -f "$CURRENT_SCRIPT_DIR/env_exports" ]; then . "$CURRENT_SCRIPT_DIR/env_exports" fi # start the application $OTB_CLI_LAUNCHER "$@" OTB-release-5.8/CMake/otbcli_app.bat.in000066400000000000000000000006211301006202600176060ustar00rootroot00000000000000@echo off :: :: Autogenerated by OTB installation process :: DO NOT MODIFY :: set CURRENT_SCRIPT_DIR=%~dp0 if exist %CURRENT_SCRIPT_DIR%otbcli.bat ( :: Prefer using the launcher inside the script dir set OTB_CLI_LAUNCHER=%CURRENT_SCRIPT_DIR%otbcli.bat ) else ( :: Use the one from the PATH set OTB_CLI_LAUNCHER=otbcli.bat ) :: start the application %OTB_CLI_LAUNCHER% @APPLICATION_NAME@ %* OTB-release-5.8/CMake/otbcli_app.sh.in000066400000000000000000000006011301006202600174500ustar00rootroot00000000000000#!/bin/sh # # Autogenerated by OTB installation process # DO NOT MODIFY # CURRENT_SCRIPT_DIR=$(dirname "$0") if [ -e "$CURRENT_SCRIPT_DIR/otbcli" ] then # Prefer using the launcher inside the script dir OTB_CLI_LAUNCHER=$CURRENT_SCRIPT_DIR/otbcli else # Use the one from the PATH OTB_CLI_LAUNCHER=otbcli fi # start the application $OTB_CLI_LAUNCHER @APPLICATION_NAME@ "$@" OTB-release-5.8/CMake/otbgui.bat.in000066400000000000000000000012141301006202600167620ustar00rootroot00000000000000@echo off :: :: Autogenerated by OTB installation process :: DO NOT MODIFY :: set CURRENT_SCRIPT_DIR=%~dp0 if exist %CURRENT_SCRIPT_DIR%otbApplicationLauncherQt.exe ( :: Prefer using the launcher inside the script dir set OTB_GUI_LAUNCHER=%CURRENT_SCRIPT_DIR%otbApplicationLauncherQt.exe ) else ( :: Use the one from the PATH set OTB_GUI_LAUNCHER=otbApplicationLauncherQt.exe ) setlocal :: works for install tree if exist %CURRENT_SCRIPT_DIR%../@OTB_INSTALL_APP_DIR@ ( set OTB_APPLICATION_PATH=%CURRENT_SCRIPT_DIR%../@OTB_INSTALL_APP_DIR@;%OTB_APPLICATION_PATH% ) set LC_NUMERIC=C :: start the application %OTB_GUI_LAUNCHER% %* endlocal OTB-release-5.8/CMake/otbgui.sh.in000066400000000000000000000016361301006202600166360ustar00rootroot00000000000000#!/bin/sh # # Autogenerated by OTB installation process # DO NOT MODIFY # CURRENT_SCRIPT_DIR=$(dirname "$0") if [ -e "$CURRENT_SCRIPT_DIR/otbApplicationLauncherQt" ] then # Prefer using the launcher inside the script dir OTB_GUI_LAUNCHER=$CURRENT_SCRIPT_DIR/otbApplicationLauncherQt else # Use the one from the PATH OTB_GUI_LAUNCHER=otbApplicationLauncherQt fi # use the default install tree path for applications if [ -d "$CURRENT_SCRIPT_DIR/../@OTB_INSTALL_APP_DIR@" ] then OTB_APPLICATION_PATH=$CURRENT_SCRIPT_DIR/../@OTB_INSTALL_APP_DIR@:$OTB_APPLICATION_PATH fi # export it to make it available to otbApplicationLauncherCommandLine environment export OTB_APPLICATION_PATH # avoid numerical issues caused by locale export LC_NUMERIC=C # Source GDAL_DATA, EPSG_CSV if [ -f "$CURRENT_SCRIPT_DIR/env_exports" ]; then . "$CURRENT_SCRIPT_DIR/env_exports" fi # start the application $OTB_GUI_LAUNCHER "$@" OTB-release-5.8/CMake/otbgui_app.bat.in000066400000000000000000000006211301006202600176230ustar00rootroot00000000000000@echo off :: :: Autogenerated by OTB installation process :: DO NOT MODIFY :: set CURRENT_SCRIPT_DIR=%~dp0 if exist %CURRENT_SCRIPT_DIR%otbgui.bat ( :: Prefer using the launcher inside the script dir set OTB_GUI_LAUNCHER=%CURRENT_SCRIPT_DIR%otbgui.bat ) else ( :: Use the one from the PATH set OTB_GUI_LAUNCHER=otbgui.bat ) :: start the application %OTB_GUI_LAUNCHER% @APPLICATION_NAME@ %* OTB-release-5.8/CMake/otbgui_app.sh.in000066400000000000000000000006011301006202600174650ustar00rootroot00000000000000#!/bin/sh # # Autogenerated by OTB installation process # DO NOT MODIFY # CURRENT_SCRIPT_DIR=$(dirname "$0") if [ -e "$CURRENT_SCRIPT_DIR/otbgui" ] then # Prefer using the launcher inside the script dir OTB_GUI_LAUNCHER=$CURRENT_SCRIPT_DIR/otbgui else # Use the one from the PATH OTB_GUI_LAUNCHER=otbgui fi # start the application $OTB_GUI_LAUNCHER @APPLICATION_NAME@ "$@" OTB-release-5.8/CMake/pre-commit000066400000000000000000000003431301006202600163750ustar00rootroot00000000000000#!/bin/sh echo 'Your work tree has not been configured for ITK development. Paste the following commands into a shell: ./Utilities/SetupForDevelopment.sh See http://www.itk.org/Wiki/ITK/Git/Develop for more details.' exit 1 OTB-release-5.8/CMake/qt.conf.in000066400000000000000000000001041301006202600162710ustar00rootroot00000000000000[Paths] Translations=@QT_TRANSLATIONS_DIR@ Plugins=@QT_PLUGINS_DIR@ OTB-release-5.8/CMakeLists.txt000066400000000000000000000466751301006202600162000ustar00rootroot00000000000000cmake_minimum_required(VERSION 2.8.11) foreach(p CMP0025 # CMake 3.0 CMP0042 # CMake 3.0 CMP0058 ) if(POLICY ${p}) cmake_policy(SET ${p} NEW) endif() endforeach() # CMP0046 : from CMake 3.0, old behaviour is more convenient if(POLICY CMP0046) cmake_policy(SET CMP0046 OLD) endif() # TODO Check if OTB cmake is compatible with CMP0054 NEW policy # CMP0054 : New policy introduce in CMake 3.1, keep old behaviour for now if(POLICY CMP0054) cmake_policy(SET CMP0054 OLD) endif() project(OTB) include(CMakeDependentOption) # # use ExternalProject include(ExternalProject) #mantis: 1193 if(APPLE) set(CMAKE_SYSTEM_FRAMEWORK_PATH "" CACHE PATH "" FORCE) endif() if( CMAKE_HOST_WIN32 ) string( LENGTH "${CMAKE_CURRENT_SOURCE_DIR}" n ) if( n GREATER 50 ) message( FATAL_ERROR "OTB source code directory path length is too long (${n} > 50)." "Please move the OTB source code directory to a directory with a shorter path." ) endif() string( LENGTH "${CMAKE_CURRENT_BINARY_DIR}" n ) if( n GREATER 50 ) message( FATAL_ERROR "OTB build directory path length is too long (${n} > 50)." "Please set the OTB build directory to a directory with a shorter path." ) endif() endif() set(OTB_CMAKE_DIR ${OTB_SOURCE_DIR}/CMake) set(CMAKE_MODULE_PATH ${OTB_CMAKE_DIR} ${CMAKE_MODULE_PATH}) include (SourceStatus) include(PreventInSourceBuilds) include(PreventInBuildInstalls) include(OTBModuleMacros) include(OTBModuleRemote) include(OTBModuleTest) include( i18n_qt4 ) reset_qt4_i18n_sources() repository_status(${PROJECT_SOURCE_DIR} OTB_GIT_STATUS_MESSAGE) #----------------------------------------------------------------------------- # Configure the default OTB_DATA_ROOT for the location of OTB Data. find_path(OTB_DATA_ROOT NAMES README-OTB-Data HINTS $ENV{OTB_DATA_ROOT} ${OTB_SOURCE_DIR}/../OTB-Data ) mark_as_advanced(OTB_DATA_ROOT) if(OTB_DATA_ROOT) repository_status(${OTB_DATA_ROOT} OTB_DATA_GIT_STATUS_MESSAGE) endif() set(main_project_name ${_OTBModuleMacros_DEFAULT_LABEL}) #----------------------------------------------------------------------------- # OTB version number. set(OTB_VERSION_MAJOR "5") set(OTB_VERSION_MINOR "8") set(OTB_VERSION_PATCH "0") set(OTB_VERSION_STRING "${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}.${OTB_VERSION_PATCH}") # Monteverdi version number (follows OTB) set( Monteverdi_VERSION_MAJOR ${OTB_VERSION_MAJOR} ) set( Monteverdi_VERSION_MINOR ${OTB_VERSION_MINOR} ) set( Monteverdi_VERSION_PATCH ${OTB_VERSION_PATCH} ) set( Monteverdi_VERSION_SUFFIX "" ) set( Monteverdi_VERSION_STRING "${Monteverdi_VERSION_MAJOR}.${Monteverdi_VERSION_MINOR}.${Monteverdi_VERSION_PATCH}${Monteverdi_VERSION_SUFFIX}" ) #----------------------------------------------------------------------------- string(TIMESTAMP OTB_BUILD_TIMESTAMP) if(NOT OTB_INSTALL_RUNTIME_DIR) set(OTB_INSTALL_RUNTIME_DIR bin) endif() if(NOT OTB_INSTALL_LIBRARY_DIR) set(OTB_INSTALL_LIBRARY_DIR lib) endif() if(NOT OTB_INSTALL_ARCHIVE_DIR) set(OTB_INSTALL_ARCHIVE_DIR lib) endif() if(NOT OTB_INSTALL_INCLUDE_DIR) set(OTB_INSTALL_INCLUDE_DIR include/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}) endif() if(NOT OTB_INSTALL_APP_DIR) set(OTB_INSTALL_APP_DIR "lib/otb/applications") endif() if(NOT OTB_INSTALL_PYTHON_DIR) set(OTB_INSTALL_PYTHON_DIR "lib/otb/python") endif() if(NOT OTB_INSTALL_JAVA_DIR) set(OTB_INSTALL_JAVA_DIR "lib/otb/java") endif() if(NOT OTB_INSTALL_DATA_DIR) set(OTB_INSTALL_DATA_DIR share/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}) endif() if(NOT OTB_INSTALL_DOC_DIR) set(OTB_INSTALL_DOC_DIR share/doc/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}) endif() if(NOT OTB_INSTALL_PACKAGE_DIR) set(OTB_INSTALL_PACKAGE_DIR "${OTB_INSTALL_LIBRARY_DIR}/cmake/OTB-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}") endif() # Override CMake's built-in add_* commands: assign LABELS to tests and targets # automatically. Depends on the CMake variable otb-module being set to the # "current" module when add_* is called. macro(verify_otb_module_is_set) if("" STREQUAL "${otb-module}") message(FATAL_ERROR "CMake variable otb-module is not set") endif() endmacro() #----------------------------------------------------------------------------- # Set a default build type if none was specified if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) message(STATUS "Setting build type to 'Release' as none was specified.") set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE) # Set the possible values of build type for cmake-gui set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo") endif() #----------------------------------------------------------------------------- # Enable running cppcheck for each module on its source and test directories. option(OTB_CPPCHECK_TEST "Run cppcheck for static code analysis" OFF) mark_as_advanced(OTB_CPPCHECK_TEST) #----------------------------------------------------------------------------- # Forbid downloading resources from the network during a build. This helps # when building on systems without network connectivity to determine which # resources much be obtained manually and made available to the build. option(OTB_FORBID_DOWNLOADS "Do not download source code or data from the network" OFF) mark_as_advanced(OTB_FORBID_DOWNLOADS) macro(otb_download_attempt_check _name) if(OTB_FORBID_DOWNLOADS) message(SEND_ERROR "Attempted to download ${_name} when OTB_FORBID_DOWNLOADS is ON") endif() endmacro() # TODO : handle shared libs on windows option(BUILD_SHARED_LIBS "Build OTB with shared libraries." ON) set(OTB_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS}) if(MSVC) option(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS "Build OTB with shared libraries." ON) set(OTB_CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ${CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS}) else() set(OTB_CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS OFF) endif() #----------------------------------------------------------------------------- # Option to activate deprecated classes option(OTB_USE_DEPRECATED "Turn on the use and test of deprecated classes" OFF) mark_as_advanced(OTB_USE_DEPRECATED) #----------------------------------------------------------------------------- # SHOW_ALL_MSG_DEBUG option option(OTB_SHOW_ALL_MSG_DEBUG "Show all debug messages (very verbose)" OFF) mark_as_advanced(OTB_SHOW_ALL_MSG_DEBUG) include(OTBSetStandardCompilerFlags) #--------------------------------------------------------------- # run try compiles and tests for OTB # TODO check if we need this #include(otbTestFriendTemplatedFunction) set(CMAKE_C_FLAGS "${OTB_REQUIRED_C_FLAGS} ${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${OTB_REQUIRED_CXX_FLAGS} ${CMAKE_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}") set(CMAKE_SHARED_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${OTB_REQUIRED_LINK_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}") # detect some C++11 keywords include(OTBCheckCpp11Keywords) # TODO BUILD_TESTING is created by default by CTest.cmake, and is ON by default. option(BUILD_TESTING "Build the testing tree." OFF) include(CTest) include( CppcheckTargets ) # Setup build locations. if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OTB_BINARY_DIR}/bin) endif() if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OTB_BINARY_DIR}/lib) endif() if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OTB_BINARY_DIR}/lib) endif() set(OTB_MODULES_DIR "${OTB_BINARY_DIR}/${OTB_INSTALL_PACKAGE_DIR}/Modules") #----------------------------------------------------------------------------- # OTB uses KWStyle for checking the coding style #include(${OTB_SOURCE_DIR}/Utilities/KWStyle/KWStyle.cmake) #----------------------------------------------------------------------------- # By default, OTB does not build the Examples that are illustrated in the Software Guide option(BUILD_EXAMPLES "Build the Examples directory." OFF) #---------------------------------------------------------------------------- set(OTB_TEST_OUTPUT_DIR "${OTB_BINARY_DIR}/Testing/Temporary") option(OTB_DATA_USE_LARGEINPUT "Use Large inputs images test." OFF) mark_as_advanced(OTB_DATA_USE_LARGEINPUT) if(OTB_DATA_USE_LARGEINPUT) find_path(OTB_DATA_LARGEINPUT_ROOT NAMES OTBData.readme HINTS $ENV{OTB_DATA_LARGEINPUT_ROOT} ) mark_as_advanced(OTB_DATA_LARGEINPUT_ROOT) endif() # Small macro to copy a file and rename it macro(otb_copy_rename _input _output) execute_process( COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_input}" "${_output}" RESULT_VARIABLE _err_code OUTPUT_QUIET ERROR_QUIET ) if(_err_code) message(FATAL_ERROR "Failed to copy file ${_input} to ${_output}") endif() endmacro() #Generate cmake variables with a set of largeinput data used in tests include(OTBManageLargeInputPaths) set(BASELINE ${OTB_DATA_ROOT}/Baseline/OTB/Images) set(BASELINE_FILES ${OTB_DATA_ROOT}/Baseline/OTB/Files) set(INPUTDATA ${OTB_DATA_ROOT}/Input) set(TEMP ${OTB_BINARY_DIR}/Testing/Temporary) set(EXAMPLEDATA ${OTB_DATA_ROOT}/Examples) set(OTBAPP_BASELINE ${OTB_DATA_ROOT}/Baseline/OTB-Applications/Images) set(OTBAPP_BASELINE_FILES ${OTB_DATA_ROOT}/Baseline/OTB-Applications/Files) set(NOTOL 0.0) set(EPSILON_1 0.1) set(EPSILON_2 0.01) set(EPSILON_3 0.001) set(EPSILON_4 0.0001) set(EPSILON_5 0.00001) set(EPSILON_6 0.000001) set(EPSILON_7 0.0000001) set(EPSILON_8 0.00000001) set(EPSILON_9 0.000000001) set(EPSILON_10 0.0000000001) set(EPSILON_11 0.00000000001) set(EPSILON_12 0.000000000001) set(EPSILON_13 0.0000000000001) set(EPSILON_14 0.00000000000001) set(EPSILON_15 0.000000000000001) # Location of OTB Example Data. set(OTB_EXAMPLE_DATA_ROOT "${OTB_SOURCE_DIR}/Examples/Data") #---------------------------------------------------------------------- # Make sure remote modules are downloaded before sorting out the module # dependencies. add_subdirectory(Modules/Remote) # Enable modules according to user inputs and the module dependency DAG. include(OTBModuleEnablement) #---------------------------------------------------------------------- # Generate OTBConfig.cmake for the build tree. set(OTB_CONFIG_CODE " set(OTB_MODULES_DIR \"${OTB_MODULES_DIR}\")") set(OTB_CONFIG_CMAKE_DIR "${OTB_SOURCE_DIR}/CMake") set(OTB_USE_FILE "${OTB_CONFIG_CMAKE_DIR}/UseOTB.cmake") set(OTB_CONFIG_TARGETS_CONDITION " AND NOT OTB_BINARY_DIR") set(OTB_CONFIG_TARGETS_FILE "${OTB_BINARY_DIR}/OTBTargets.cmake") set(OTB_CONFIG_MODULE_API_FILE "${OTB_SOURCE_DIR}/CMake/OTBModuleAPI.cmake") set(OTB_CONFIG_APPLI_MACROS_FILE "${OTB_SOURCE_DIR}/CMake/OTBApplicationMacros.cmake") configure_file(CMake/OTBConfig.cmake.in OTBConfig.cmake @ONLY) # Generate OTBConfig.cmake for the install tree. set(OTB_CONFIG_CODE " # Compute the installation prefix from this OTBConfig.cmake file location. get_filename_component(OTB_INSTALL_PREFIX \"\${CMAKE_CURRENT_LIST_FILE}\" PATH)") # Construct the proper number of get_filename_component(... PATH) # calls to compute the installation prefix. string(REGEX REPLACE "/" ";" _count "${OTB_INSTALL_PACKAGE_DIR}") foreach(p ${_count}) set(OTB_CONFIG_CODE "${OTB_CONFIG_CODE} get_filename_component(OTB_INSTALL_PREFIX \"\${OTB_INSTALL_PREFIX}\" PATH)") endforeach() set(OTB_CONFIG_CODE "${OTB_CONFIG_CODE} set(OTB_MODULES_DIR \"\${OTB_INSTALL_PREFIX}/${OTB_INSTALL_PACKAGE_DIR}/Modules\")") set(OTB_USE_FILE "\${OTB_INSTALL_PREFIX}/${OTB_INSTALL_PACKAGE_DIR}/UseOTB.cmake") set(OTB_CONFIG_CMAKE_DIR "\${OTB_INSTALL_PREFIX}/${OTB_INSTALL_PACKAGE_DIR}") set(OTB_CONFIG_TARGETS_CONDITION "") set(OTB_CONFIG_TARGETS_FILE "\${OTB_INSTALL_PREFIX}/${OTB_INSTALL_PACKAGE_DIR}/OTBTargets.cmake") set(OTB_CONFIG_MODULE_API_FILE "\${OTB_INSTALL_PREFIX}/${OTB_INSTALL_PACKAGE_DIR}/OTBModuleAPI.cmake") set(OTB_CONFIG_APPLI_MACROS_FILE "\${OTB_INSTALL_PREFIX}/${OTB_INSTALL_PACKAGE_DIR}/OTBApplicationMacros.cmake") configure_file(CMake/OTBConfig.cmake.in CMakeFiles/OTBConfig.cmake @ONLY) # TODO : port unscrustify scripts from ITK to OTB ? # #---------------------------------------------------------------------------- # # Configure maintenance scripts # configure_file(Utilities/Maintenance/doSingleKWStyleUncrustifyFix.sh.in # Utilities/Maintenance/doSingleKWStyleUncrustifyFix.sh @ONLY) #----------------------------------------------------------------------------- configure_file(CMake/OTBConfigVersion.cmake.in OTBConfigVersion.cmake @ONLY) install(FILES ${OTB_BINARY_DIR}/CMakeFiles/OTBConfig.cmake ${OTB_BINARY_DIR}/OTBConfigVersion.cmake CMake/OTBApplicationMacros.cmake CMake/OTBModuleAPI.cmake CMake/UseOTB.cmake DESTINATION ${OTB_INSTALL_PACKAGE_DIR} COMPONENT Development) get_property(OTBTargets_MODULES GLOBAL PROPERTY OTBTargets_MODULES) if(OTBTargets_MODULES) install(EXPORT OTBTargets DESTINATION ${OTB_INSTALL_PACKAGE_DIR} COMPONENT Development) else() set(CMAKE_CONFIGURABLE_FILE_CONTENT "# No targets!") configure_file(${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in ${OTB_BINARY_DIR}/CMakeFiles/OTBTargets.cmake @ONLY) install(FILES ${OTB_BINARY_DIR}/CMakeFiles/OTBTargets.cmake DESTINATION ${OTB_INSTALL_PACKAGE_DIR} COMPONENT Development) endif() # install FindXXX.cmake file(GLOB OTB_FIND_PACKAGE_SCRIPTS CMake/Find*.cmake) install(FILES ${OTB_FIND_PACKAGE_SCRIPTS} DESTINATION ${OTB_INSTALL_PACKAGE_DIR} COMPONENT Development) # TODO : install release notes, copyright notice, ... # install(FILES "LICENSE" "NOTICE" "README.txt" DESTINATION ${OTB_INSTALL_DOC_DIR} COMPONENT Runtime) install(FILES "LICENSE" DESTINATION ${OTB_INSTALL_DOC_DIR} COMPONENT Runtime) # Configure and install VERSION file configure_file(VERSION VERSION @ONLY) install(FILES ${OTB_BINARY_DIR}/VERSION DESTINATION ${OTB_INSTALL_DOC_DIR} COMPONENT Runtime) if(BUILD_TESTING) add_subdirectory(Utilities/InstallTest) endif() #----------------------------------------------------------------------------- # The subdirectories added below this line should use only the public # interface with find_package(ITK). Set ITK_DIR to use this ITK build. set(OTB_DIR "${OTB_BINARY_DIR}") if(BUILD_EXAMPLES) add_subdirectory(Examples) endif() #---------------------------------------------------------------------- # Provide an option for generating documentation. add_subdirectory(Utilities/Doxygen) add_subdirectory(Utilities/Completion) #---------------------------------------------------------------------------- # Provide a target to generate the SuperBuild archive (only for Unix) if(UNIX) add_custom_target(SuperBuild-archive COMMAND ./SuperbuildDownloadList.sh ${OTB_BINARY_DIR}/Download ${OTB_BINARY_DIR} WORKING_DIRECTORY ${OTB_SOURCE_DIR}/Utilities/Maintenance ) endif() # TODO cleanup # Create target to download data from the OTBData group. This must come after # all tests have been added that reference the group, so we put it last. #----------------------------------------------------------------------------- # uninstall target configure_file( "${CMAKE_SOURCE_DIR}/CMake/cmake_uninstall.cmake.in" "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/cmake_uninstall.cmake) # #----------------------------------------------------------------------------- # # Packaging options for Windows packages # if(WIN32 OR CMAKE_CROSSCOMPILING) # option(GENERATE_PACKAGE "Generate OTB package" OFF) # option(GENERATE_XDK "Generate XDK for OTB development" OFF) # if(GENERATE_PACKAGE OR GENERATE_XDK) # set(MXE_TARGET_DIR "" CACHE PATH "path to mxe directory") # set(PACKAGE_OTB_SRC_DIR ${OTB_SOURCE_DIR}) # add_subdirectory(${OTB_SOURCE_DIR}/SuperBuild/Packaging ${CMAKE_BINARY_DIR}/Packaging) # endif() # (GENERATE_PACKAGE OR GENERATE_XDK) # endif() # (WIN32 OR CMAKE_CROSSCOMPILING) #----------------------------------------------------------------------------- #macro to put a fixed space between key, value in summary macro(get_white_spaces var res) string(LENGTH "${var}" len) math(EXPR required_spaces "23 - ${len}") set(${res}) foreach(loop_var RANGE ${required_spaces}) set(${res} "${${res}} ") endforeach() endmacro() message("\n======================= Begin of OTB cmake summary =======================\n") if(OTB_GIT_STATUS_MESSAGE) message( ${OTB_GIT_STATUS_MESSAGE}) endif() if(OTB_DATA_GIT_STATUS_MESSAGE) message( ${OTB_DATA_GIT_STATUS_MESSAGE}) endif() set(option_list ${OTB_MODULE_ACTIVATION_OPTION_LIST}) list(SORT option_list) foreach(otb_option CMAKE_SOURCE_DIR CMAKE_BINARY_DIR CMAKE_INSTALL_PREFIX CMAKE_COMMAND CMAKE_C_COMPILER CMAKE_CXX_COMPILER CMAKE_MAKE_PROGRAM CMAKE_GENERATOR CMAKE_BUILD_TYPE CMAKE_C_FLAGS CMAKE_CXX_FLAGS OTB_HAS_CXX11 ${option_list} OTB_WRAP_PYTHON OTB_WRAP_JAVA OTB_DATA_ROOT ) get_white_spaces("${otb_option}" spaces) message("${otb_option} ${spaces} = ${${otb_option}}") endforeach() # set(modules_list_for_summary "${OTB_MODULES_ENABLED}") # list(SORT modules_list_for_summary) # string(REPLACE ";" " " modules_list_for_summary "${modules_list_for_summary}") # message("OTB_MODULES_ENABLED = ${modules_list_for_summary}") # unset(modules_list_for_summary) list(REMOVE_ITEM option_list "OTB_USE_6S" "OTB_USE_SIFTFAST" "OTB_USE_QT4") foreach(item ${option_list}) if(NOT ${item}) list(REMOVE_ITEM option_list "${item}" ) endif() endforeach() #To report non-optional dependencies inside summary list(APPEND option_list Boost) list(APPEND option_list GDAL) list(APPEND option_list GEOTIFF) list(APPEND option_list ITK) list(APPEND option_list OSSIM) list(APPEND option_list TINYXML) #RK #Q: Why these two guys here? we already have option_list #A: Because cmake case sensitivity with variables. if(OTB_USE_QT4) list(APPEND option_list QT) endif() #sort again! list(SORT option_list) foreach(dep ${option_list}) string(REGEX REPLACE "OTB_USE_" "" dep ${dep}) unset(var1_key) unset(var2_key) unset(var3_key) unset(var1_val) unset(var2_val) unset(var3_val) set(var1_key "${dep}") if(${dep}_VERSION_STRING) set(var1_val ${${dep}_VERSION_STRING}) endif() if(NOT var1_val) if(${dep}_VERSION) set(var1_val ${${dep}_VERSION}) endif() endif() if(DEFINED ${dep}_DIR) set(var2_key ${dep}_DIR) set(var2_val ${${dep}_DIR}) else() if(${dep}_INCLUDE_DIR) set(var2_key ${dep}_INCLUDE_DIR) set(var2_val ${${dep}_INCLUDE_DIR}) elseif(${dep}_INCLUDE_DIRS) set(var2_key ${dep}_INCLUDE_DIRS) set(var2_val ${${dep}_INCLUDE_DIRS}) endif() if(${dep}_LIBRARY) set(var3_key ${dep}_LIBRARY) set(var3_val ${${dep}_LIBRARY}) elseif(${dep}_LIBRARIES) set(var3_key ${dep}_LIBRARIES) set(var3_val ${${dep}_LIBRARIES}) endif() endif() get_white_spaces("${var1_key}" insert_spaces1) get_white_spaces("${var2_key}" insert_spaces2) get_white_spaces("${var3_key}" insert_spaces3) message("${var1_key} ${insert_spaces1} = ${var1_val}") if(var2_val) message("${var2_key} ${insert_spaces2} = ${var2_val}") endif() if(var3_val) message("${var3_key} ${insert_spaces3} = ${var3_val}") endif() endforeach() message("\nCMake ${CMAKE_VERSION} successfully configured ${PROJECT_NAME} using ${CMAKE_GENERATOR} generator\n") message("======================= End of OTB cmake summary =======================") #don't need this one anymore. so unset it. unset(option_list) #---------------------------------------------------------------------------- # I18N add_subdirectory( i18n ) OTB-release-5.8/CTestConfig.cmake000066400000000000000000000003551301006202600165730ustar00rootroot00000000000000set(CTEST_PROJECT_NAME "OTB") set(CTEST_NIGHTLY_START_TIME "20:00:00 CEST") set(CTEST_DROP_METHOD "https") set(CTEST_DROP_SITE "dash.orfeo-toolbox.org") set(CTEST_DROP_LOCATION "/submit.php?project=OTB") set(CTEST_DROP_SITE_CDASH TRUE) OTB-release-5.8/Copyright/000077500000000000000000000000001301006202600153665ustar00rootroot00000000000000OTB-release-5.8/Copyright/CSCopyright.txt000066400000000000000000000021251301006202600203250ustar00rootroot00000000000000Parts of the code have been developed by CS during internships and self-financed studies. Copyright (c) CS Systemes d'Information This code has been contributed to the ORFEO Toolbox (OTB) under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/CodeCopyright.txt000066400000000000000000000010701301006202600206700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ OTB-release-5.8/Copyright/CodeOTB-ITKCopyright.txt000066400000000000000000000012151301006202600216630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ OTB-release-5.8/Copyright/Copyright.txt000066400000000000000000000112101301006202600200720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are not covered by the copyright mentioned above. Here is the list of particular cases: * Portions of this code are derived from ITK. See ITKCopyright.txt for details. * Parts of the code have been developed by CS during internships and self-financed studies. See CSCopyright.txt for details. * Parts of the code that have been developped by Emmanuel Christophe. See CrispCopyright.txt for details. * Parts of the code have been developped by Gregoire Mercier. See IMTCopyright.txt for details. --------------------------- DEPENDENCIES ---------------------------------- Several utilities are mandatory dependencies used by the OTB library : * ITK : http://www.itk.org distributed under the Apache 2.0 license See ITKCopyright.txt for details. Some patched source files are embedded in OTB sources. * VXL : http://vxl.sourceforge.net distributed under a specific license (simplified BSD-like) See VXLCopyright.txt for details. * Boost : http://www.boost.org distributed under the Boost Software License 1.0 See LibBOOSTCopyright.txt for details. Some patched source files are embedded in OTB sources. * GDAL : http://www.gdal.org distributed under the X/MIT license See GDALCopyright.txt for details. * GeoTIFF : http://trac.osgeo.org/geotiff distributed under the MIT-like license See GeoTIFFCopyright.txt for details. * OpenThreads : http://www.openscenegraph.org distributed under the OpenSceneGraph Public License (OSGPL) 0.0, i.e. wxWindows Library License See OSGCopyright.txt for details. * OSSIM : http://www.ossim.org distributed under the GNU LGPL 2.1 license See OSSIMCopyright.txt * TinyXML : http://www.grinninglizard.com/tinyxml distributed under the zlib/libpng license See TinyXMLCopyright.txt Some utilities used by the OTB library are optional. The library may be built without them, but some modules will be disabled : * 6S : http://6s.ltdri.org No license information available on the website but the authors gave CNES the permission to use 6S code inside OTB and to release it under CeCILL v2 license The source code is embedded in Modules/ThirdParty/6S * Curl : http://www.curl.haxx.se distributed under the MIT-like license See CurlCopyright.txt for details * LibSVM : http://www.csie.ntu.edu.tw/~cjlin/libsvm distributed under the revised BSD license See LibSVMCopyright.txt for details * libKML : http://code.google.com/p/libkml distributed under the revised BSD license See KMLCopyright.txt for details * Mapnik : http://mapnik.org distrubuted under GNU LGPL version 2.1 Copyright : Artem Pavlenko * MuParser : http://muparser.sourceforge.net distributed under the MIT license See MuParserCopyright.txt for details. * MuParserX : http://muparserx.beltoforion.de distributed under simplified BSD license See MuParserXCopyright.txt for details. * OpenCV : http://opencv.org distributed under the revised BSD License See OpenCVCopyright.txt for details. * OpenJPEG : http://www.openjpeg.org distributed under the revised BSD license See OpenJPEGCopyright.txt for details. * Qt4 : http://www.qt.io * SiftFast : http://libsift.sourceforge.net distributed under the GNU LGPL 3.0 license the source code is embedded in Modules/ThirdParty/SiftFast/src. See Modules/ThirdParty/SiftFast/src/LICENSE for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ OTB-release-5.8/Copyright/CrispCopyright.txt000066400000000000000000000004421301006202600211000ustar00rootroot00000000000000The part of the code that have been developped by Emmanuel Christophe between October 6th, 2008 and October 5th, 2010 is under copyright from Crisp / NUS. The code have been release to the OTB project under the Apache2 license anywhere possible. See License_Apache2.txt for more details. OTB-release-5.8/Copyright/CurlCopyright.txt000066400000000000000000000020241301006202600207230ustar00rootroot00000000000000COPYRIGHT AND PERMISSION NOTICE Copyright (c) 1996 - 2015, Daniel Stenberg, . All rights reserved. Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization of the copyright holder. OTB-release-5.8/Copyright/GDALCopyright.txt000066400000000000000000000301261301006202600205310ustar00rootroot00000000000000 GDAL/OGR Licensing ================== This file attempts to include all licenses that apply within the GDAL/OGR source tree, in particular any that are supposed to be exposed to the end user for credit requirements for instance. The contents of this file can be displayed from GDAL commandline utilities using the --license commandline switch. GDAL/OGR General ---------------- In general GDAL/OGR is licensed under an MIT/X style license with the following terms: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. gdal/frmts/gtiff/tif_float.c ---------------------------- Copyright (c) 2002, Industrial Light & Magic, a division of Lucas Digital Ltd. LLC All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Industrial Light & Magic nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. gdal/frmts/hdf4/hdf-eos/* ------------------------ Copyright (C) 1996 Hughes and Applied Research Corporation Permission to use, modify, and distribute this software and its documentation for any purpose without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. gdal/frmts/pcraster/libcsf -------------------------- Copyright (c) 1997-2003, Utrecht University All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Utrecht University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. gdal/frmts/grib/degrib/* ------------------------ The degrib and g2clib source code are modified versions of code produced by NOAA NWS and are in the public domain subject to the following restrictions: http://www.weather.gov/im/softa.htm DISCLAIMER The United States Government makes no warranty, expressed or implied, as to the usefulness of the software and documentation for any purpose. The U.S. Government, its instrumentalities, officers, employees, and agents assumes no responsibility (1) for the use of the software and documentation listed below, or (2) to provide technical support to users. http://www.weather.gov/disclaimer.php The information on government servers are in the public domain, unless specifically annotated otherwise, and may be used freely by the public so long as you do not 1) claim it is your own (e.g. by claiming copyright for NWS information -- see below), 2) use it in a manner that implies an endorsement or affiliation with NOAA/NWS, or 3) modify it in content and then present it as official government material. You also cannot present information of your own in a way that makes it appear to be official government information.. The user assumes the entire risk related to its use of this data. NWS is providing this data "as is," and NWS disclaims any and all warranties, whether express or implied, including (without limitation) any implied warranties of merchantability or fitness for a particular purpose. In no event will NWS be liable to you or to any third party for any direct, indirect, incidental, consequential, special or exemplary damages or lost profit resulting from any use or misuse of this data. As required by 17 U.S.C. 403, third parties producing copyrighted works consisting predominantly of the material appearing in NWS Web pages must provide notice with such work(s) identifying the NWS material incorporated and stating that such material is not subject to copyright protection. port/cpl_minizip* ----------------- This is version 2005-Feb-10 of the Info-ZIP copyright and license. The definitive version of this document should be available at ftp://ftp.info-zip.org/pub/infozip/license.html indefinitely. Copyright (c) 1990-2005 Info-ZIP. All rights reserved. For the purposes of this copyright and license, "Info-ZIP" is defined as the following set of individuals: Mark Adler, John Bush, Karl Davis, Harald Denker, Jean-Michel Dubois, Jean-loup Gailly, Hunter Goatley, Ed Gordon, Ian Gorman, Chris Herborth, Dirk Haase, Greg Hartwig, Robert Heath, Jonathan Hudson, Paul Kienitz, David Kirschbaum, Johnny Lee, Onno van der Linden, Igor Mandrichenko, Steve P. Miller, Sergio Monesi, Keith Owens, George Petrov, Greg Roelofs, Kai Uwe Rommel, Steve Salisbury, Dave Smith, Steven M. Schweda, Christian Spieler, Cosmin Truta, Antoine Verheijen, Paul von Behren, Rich Wales, Mike White This software is provided "as is," without warranty of any kind, express or implied. In no event shall Info-ZIP or its contributors be held liable for any direct, indirect, incidental, special or consequential damages arising out of the use of or inability to use this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. Redistributions of source code must retain the above copyright notice, definition, disclaimer, and this list of conditions. 2. Redistributions in binary form (compiled executables) must reproduce the above copyright notice, definition, disclaimer, and this list of conditions in documentation and/or other materials provided with the distribution. The sole exception to this condition is redistribution of a standard UnZipSFX binary (including SFXWiz) as part of a self-extracting archive; that is permitted without inclusion of this license, as long as the normal SFX banner has not been removed from the binary or disabled. 3. Altered versions--including, but not limited to, ports to new operating systems, existing ports with new graphical interfaces, and dynamic, shared, or static library versions--must be plainly marked as such and must not be misrepresented as being the original source. Such altered versions also must not be misrepresented as being Info-ZIP releases--including, but not limited to, labeling of the altered versions with the names "Info-ZIP" (or any variation thereof, including, but not limited to, different capitalizations), "Pocket UnZip," "WiZ" or "MacZip" without the explicit permission of Info-ZIP. Such altered versions are further prohibited from misrepresentative use of the Zip-Bugs or Info-ZIP e-mail addresses or of the Info-ZIP URL(s). 4. Info-ZIP retains the right to use the names "Info-ZIP," "Zip," "UnZip," "UnZipSFX," "WiZ," "Pocket UnZip," "Pocket Zip," and "MacZip" for its own source and binary releases. gdal/ogr/ogrsf_frmts/dxf/intronurbs.cpp --------------------------------------- This code is derived from the code associated with the book "An Introduction to NURBS" by David F. Rogers. More information on the book and the code is available at: http://www.nar-associates.com/nurbs/ Copyright (c) 2009, David F. Rogers All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the David F. Rogers nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. gdal/alg/thinplatespline.cpp ---------------------------- IEEE754 log() code derived from: @(#)e_log.c 1.3 95/01/18 Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. Developed at SunSoft, a Sun Microsystems, Inc. business. Permission to use, copy, modify, and distribute this software is freely granted, provided that this notice is preserved. OTB-release-5.8/Copyright/GLFWCopyright.txt000066400000000000000000000016461301006202600205660ustar00rootroot00000000000000Copyright (c) 2002-2006 Marcus Geelnard Copyright (c) 2006-2010 Camilla Berglund This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. OTB-release-5.8/Copyright/GeoTIFFCopyright.txt000066400000000000000000000102731301006202600212060ustar00rootroot00000000000000 libgeotiff Licensing ==================== All the source code in this toolkit are either in the public domain, or under an X style license. In any event it is all considered to be free to use for any purpose (including commercial software). No credit is required though some of the code requires that the specific source code modules retain their existing copyright statements. The CSV files, and other tables derived from the EPSG coordinate system database are also free to use. In particular, no part of this code is "copyleft", nor does it imply any requirement for users to disclose this or their own source code. All components not carrying their own copyright message, but distributed with libgeotiff should be considered to be under the same license as Niles' code. --------- Code by Frank Warmerdam has this copyright notice (directly copied from X Consortium licence): * Copyright (c) 1999, Frank Warmerdam * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. ----------- Code by Niles Ritter is under this licence: * Written By: Niles D. Ritter. * * copyright (c) 1995 Niles D. Ritter * * Permission granted to use this software, so long as this copyright * notice accompanies any products derived therefrom. ----------- The EPSG Tables (from which the CSV files, and .inc files are derived) carried this statement on use of the data (from the EPSG web site): Use of the Data The user assumes the entire risk as to the accuracy and the use of this data. The data may be used, copied and distributed subject to the following conditions: 1. INFORMATION PROVIDED IN THIS DOCUMENT IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. 2. The data may be included in any commercial package provided that any commerciality is based on value added by the provider and not on a value ascribed to the EPSG dataset which is made available at no charge. The ownership of the EPSG dataset [OGP] must be acknowledged. 3. Subsets of information may be extracted from the dataset. Users are advised that coordinate reference system and coordinate transformation descriptions are incomplete unless all elements detailed as essential in OGP Surveying and Positioning Guidance Note 7-1 annex F are included. 4. Essential elements should preferably be reproduced as described in the dataset. Modification of parameter values is permitted as described in the table below to allow change to the content of the information provided that numeric equivalence is achieved. Numeric equivalence refers to the results of geodetic calculations in which the parameters are used, for example (i) conversion of ellipsoid defining parameters, or (ii) conversion of parameters between one and two standard parallel projection methods, or (iii) conversion of parameters between 7-parameter geocentric transformation methods. (EPSG provides a table at this point with some details) 5. No data that has been modified other than as permitted in these terms and conditions shall be described as or attributed to the EPSG dataset. OTB-release-5.8/Copyright/IMTCopyright.txt000066400000000000000000000022771301006202600204610ustar00rootroot00000000000000Parts of the code have been developped by Gregoire Mercier from Institut Mines-Telecom / Telecom Bretagne during CNES R&T contrats funded by the French Centre National d'Etudes Spatiales, CNES. Copyright (c) Institut Mines-Telecom This code has been integrated into the ORFEO Toolbox (OTB) under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/ITKCopyright.txt000066400000000000000000001424021301006202600204520ustar00rootroot00000000000000 Insight Segmentation and Registration Toolkit Copyright 1999-2011 Insight Software Consortium This software is distributed under the Apache 2.0 License. See LICENSE file for details. ----------------------------------------------------------------------- Historical Note: The Insight Segmentation and Registration Toolkit (ITK) was initially developed under contract to the National Library of Medicine at the National Institutes of Health. ITK is partially derived from VTK and VXL, hence some code is copyrighted accordingly (see VTKCopyright.txt and VXLCopyright.txt). The copyright of most of the files in the "Utilities" subdirectory is held by third parties who allow distributing this material under a license compatible with the one used by ITK. Please read the content of the subdirectories for specific details on those third-party licenses. You will also find details in the README.txt file under the "Copyright" subdirectory. Starting with its version ITK 3.6, The Insight Toolkit is distributed under the new and simplified BSD license approved by the Open Source Initiative (OSI) [http://www.opensource.org/licenses/bsd-license.php]. Starting with its version ITK 4, The Insight Toolkit is distributed under the Apache 2.0 License ----------------------------------------------------------------------- The Toolkit contains code from third parties that have different copyrights. They are: 1) DICOMParser: Copyright by Matt Turek. Distributed under a BSD-Like license. [This work was funded by NLM so its copyright should probably be transfered to the ISC.] 2) AnalyzeDB.h: The Mayo Clinic aggreed to distribute this file with ITK. Point of contact: Vincent Magnotta. The file was moved to Utilities/itkExtHdrs 3) PixelData: GE Copyrights, Vincent is contacting the providers of this code too. 6) Netlib: Netlib is a conglomerate of packages. Each one having different copyrights and licenses. Here is a listing of what is included inside Utilities/vxl/v3p/netlib blas: From www.netlib.org/blas : FAQ: The reference BLAS is a freely-available software package. It is available from netlib via anonymous ftp and the World Wide Web. Thus, it can be included in commercial software packages (and has been). We only ask that proper credit be given to the authors. datapac: Written by James Filliben, National Bureau of Standars. Our understanding is that the US Government cannot hold copyrights, therefore we assume that this code is in the public domain. eispack: lapack: laso: libf2c: linalg: linpack: mathews: minpack: napack: opt: temperton: tests: toms: 7) The triangle.c/h and showme.c files have been removed. Their copyright/license was incompatible with ITK and their functionality was not needed. These removed the "itknetlib" library. 8) itk_hash_map: It has copyrights by SGI and HP, but the license is consistent with BSD-like. So we simply need to acknowledge those in our general copyright. 9) itkMersenneTwisterRandomVariateGenerator: Copyright: Makoto Matsumoto and Takuji Nishimura, Copyright: Richard J. Wagner under a BSD-Like license. 10) Code/Numerics/FEM/dsrc2c.c : Copyright: 1977 IMSL Inc, no license available. Stephen Aylward removed the specific functions in this file that were copyrighted by IMSL and replaced them with other functions available in netlib. The file is now cleared from copyright concerns. 11) Code/Numerics/cvsrmvend Copyright: Greg A. Woods "Freely distributable" I guess that counts as BSD... Easy to remove if it becomes a problem, This is just a script for making easier the CVS syncs of VXL. 12) Testing/Code/Numerics/NeuralNetworks: Copyright: CADDLab at UNC Fixed now in CVS --> ISC Utilities: A) JPEG : Thomas G Lane ( BSD-Like) : DCMTK : OFFIS... and many others... but BSD-Like B) OpenJPEG : Universite Catholique de Louvain: BSD license C) NrrdIO : Gordon Kindlmann and University of Utah BSD-Like license. Clarifies that the original package "Teem" (not in ITK) is still under GPL license D) NIFTI : No copyright ? There is no mention of licensing nor copyright at the NIFTI Web site: http://nifti.nimh.nih.gov/nifti-1 However at http://niftilib.sourceforge.net it appears as "public domain" license, but in its subdirectory matlibs it has a GPL license. The matlibs subdirectory is not included in ITK. The subdirectory jlibs is public domain The subdirecotry clibs is public domain in ITK it had a subdir: fsliolib : From the FSL package: University of Oxford: NO FOR COMMERCIAL USE This code has now been removed. E) EXPAT : Thai Open Source Software Center Ltd and Clark Cooper. with BSD-Like license F) PNG : Copyright: Glen Randers-Pehrson Andreas Dilger Guy Erc Schalnat G) TIFF : Copyright Sam Leffler and Silicon Graphics H) GDCM : Copyright: CREATIS: BSD-Like License I) ZLIB : Copyright: Mark Adler J) kwsys : Copyright: Kitware : BSD-Like License K) VXL/lbfgsb http://users.eecs.northwestern.edu/~nocedal/lbfgsb.html This software is released under the BSD License Condition for Use: This software is freely available, but we expect that all publications describing work using this software , or all commercial products using it, quote at least one of the references given below. References 1. R. H. Byrd, P. Lu and J. Nocedal. A Limited Memory Algorithm for Bound Constrained Optimization, (1995), SIAM Journal on Scientific and Statistical Computing , 16, 5, pp. 1190-1208. 2. C. Zhu, R. H. Byrd and J. Nocedal. L-BFGS-B: Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (1997), ACM Transactions on Mathematical Software, Vol 23, Num. 4, pp. 550 - 560. 3. J.L. Morales and J. Nocedal. L-BFGS-B: Remark on Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (2011), to appear in ACM Transactions on Mathematical Software. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== VTK License Statement (VTKCopyright.txt) ---------------------------------------- Portions of the Insight code base are derived from the Visualization Toolkit (VTK), and hence are covered under the VTK copyright. The VTK copyright is as follows: Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither name of Ken Martin, Will Schroeder, or Bill Lorensen nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission. * Modified source versions must be plainly marked as such, and must not be misrepresented as being the original software. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. See also the VTK web site: http://www.vtk.org for more information. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== VXL License Statement (VXLCopyright.txt) ---------------------------------------- Portions of the Insight code base (the numerics package VNL) are derived from the Vision-something-Libraries (VXL), and hence are covered under the VXL copyright. The VXL copyright is as follows: Copyright (c) 2000 TargetJr Consortium GE Corporate Research and Development (GE CRD) 1 Research Circle Niskayuna, NY 12309 All Rights Reserved Reproduction rights limited as described below. Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notice and this permission notice appear in all copies of the software and related documentation, (ii) the name TargetJr Consortium (represented by GE CRD), may not be used in any advertising or publicity relating to the software without the specific, prior written permission of GE CRD, and (iii) any modifications are clearly marked and summarized in a change history log. THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE TARGETJR CONSORTIUM BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR ON ANY THEORY OF LIABILITY ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. See also the VXL web site: http://vxl.sourceforge.net/ for more information. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== Copyright (c) Biomedical Imaging Resource Mayo Clinic All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the Mayo Clinic nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 28 files covered by: Copyright (c) Silicon Graphics Computer Systems, Inc. Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Silicon Graphics makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 29 files covered by: Copyright (c) Hewlett-Packard Company Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Hewlett-Packard Company makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 9 files covered by: Copyright (c) Mark of the Unicorn, Inc. Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Mark of the Unicorn makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 38 files covered by: Copyright (c) Moscow Center for SPARC Technology Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Moscow Center for SPARC Technology makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (C) Makoto Matsumoto and Takuji Nishimura, Copyright (C) Richard J. Wagner All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of its contributors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. The original code included the following notice: When you use this, send an email to: matumoto at math dot keio dot ac dot jp with an appropriate reference to your work. It would be nice to CC: rjwagner at writeme dot com and Cokus at math dot washington dot edu when you write. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: (c) Copyright by Greg A. Woods Freely redistibutable. All other rights reserved. Return all fixes/modifications to . ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright by AT&T, Lucent Technologies and Bellcore. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that the copyright notice and this permission notice and warranty disclaimer appear in supporting documentation, and that the names of AT&T, Bell Laboratories, Lucent or Bellcore or any of their entities not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. AT&T, Lucent and Bellcore disclaim all warranties with regard to this software, including all implied warranties of merchantability and fitness. In no event shall AT&T, Lucent or Bellcore be liable for any special, indirect or consequential damages or any damages whatsoever resulting from loss of use, data or profits, whether in an action of contract, negligence or other tortious action, arising out of or in connection with the use or performance of this software. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (C) Lucent Technologies All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that the copyright notice and this permission notice and warranty disclaimer appear in supporting documentation, and that the name of Lucent or any of its entities not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (c) TargetJr Consortium GE Corporate Research and Development (GE CRD) 1 Research Circle Niskayuna, NY 12309 All Rights Reserved Reproduction rights limited as described below. Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notice and this permission notice appear in all copies of the software and related documentation, (ii) the name TargetJr Consortium (represented by GE CRD), may not be used in any advertising or publicity relating to the software without the specific, prior written permission of GE CRD, and (iii) any modifications are clearly marked and summarized in a change history log. THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE TARGETJR CONSORTIUM BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR ON ANY THEORY OF LIABILITY ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (C) General Electric Company. Permission is granted to any individual or institution to use, copy, modify, and distribute this software, provided that this complete copyright and permission notice is maintained, intact, in all copies and supporting documentation. General Electric Company, provides this software "as is" without express or implied warranty. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 5 files covered by: Copyright (C) Texas Instruments Incorporated. Permission is granted to any individual or institution to use, copy, modify, and distribute this software, provided that this complete copyright and permission notice is maintained, intact, in all copies and supporting documentation. Texas Instruments Incorporated provides this software "as is" without express or implied warranty. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 2 files covered by: Copyright (C) Texas Instruments Incorporated. Copyright (C) General Electric Company. Permission is granted to any individual or institution to use, copy, modify, and distribute this software, provided that this complete copyright and permission notice is maintained, intact, in all copies and supporting documentation. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (C) Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright by the Massachusetts Institute of Technology Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of M.I.T. not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. M.I.T. makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 98 files covered by: Copyright (c) 1999-2005 CREATIS (CREATIS = Centre de Recherche et d'Applications en Traitement de l'Image) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of CREATIS, nor the names of any contributor (CNRS, INSERM, INSA, Universite Claude-Bernard Lyon I), may be used to endorse or promote products derived from this software without specific prior written permission. * Modified source versions must be plainly marked as such, and must not be misrepresented as being the original software. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 13 files covered by: Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd and Clark Cooper Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 54 files covered by: Copyright (C) Gordon Kindlmann Copyright (C) University of Utah This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 2 files covered by: Copyright (c) David A. Clunie DBA PixelMed Publishing. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution. 3. Neither the name of PixelMed Publishing nor the names of its contributors may be used to endorse or promote products derived from this software. This software is provided by the copyright holders and contributors "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the copyright owner or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 14 files covered by: Copyright (c) 2003 Matt Turek All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of Matt Turek nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission. * Modified source versions must be plainly marked as such, and must not be misrepresented as being the original software. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 20 files covered by: * libpng versions 1.0.7, July 1, 2000, through 1.0.12, June 8, 2001, are * Copyright (c) 2000, 2001 Glenn Randers-Pehrson, and are * distributed according to the same disclaimer and license as libpng-1.0.6 * with the following individuals added to the list of Contributing Authors * * Simon-Pierre Cadieux * Eric S. Raymond * Gilles Vollant * * and with the following additions to the disclaimer: * * There is no warranty against interference with your enjoyment of the * library or against infringement. There is no warranty that our * efforts or the library will fulfill any of your particular purposes * or needs. This library is provided with all faults, and the entire * risk of satisfactory quality, performance, accuracy, and effort is with * the user. * * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson * Distributed according to the same disclaimer and license as libpng-0.96, * with the following individuals added to the list of Contributing Authors: * * Tom Lane * Glenn Randers-Pehrson * Willem van Schaik * * libpng versions 0.89, June 1996, through 0.96, May 1997, are * Copyright (c) 1996, 1997 Andreas Dilger * Distributed according to the same disclaimer and license as libpng-0.88, * with the following individuals added to the list of Contributing Authors: * * John Bowler * Kevin Bracey * Sam Bushell * Magnus Holmgren * Greg Roelofs * Tom Tanner * * libpng versions 0.5, May 1995, through 0.88, January 1996, are * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. * * For the purposes of this copyright and license, "Contributing Authors" * is defined as the following set of individuals: * * Andreas Dilger * Dave Martindale * Guy Eric Schalnat * Paul Schmidt * Tim Wegner * * The PNG Reference Library is supplied "AS IS". The Contributing Authors * and Group 42, Inc. disclaim all warranties, expressed or implied, * including, without limitation, the warranties of merchantability and of * fitness for any purpose. The Contributing Authors and Group 42, Inc. * assume no liability for direct, indirect, incidental, special, exemplary, * or consequential damages, which may result from the use of the PNG * Reference Library, even if advised of the possibility of such damage. * * Permission is hereby granted to use, copy, modify, and distribute this * source code, or portions hereof, for any purpose, without fee, subject * to the following restrictions: * * 1. The origin of this source code must not be misrepresented. * * 2. Altered versions must be plainly marked as such and * must not be misrepresented as being the original source. * * 3. This Copyright notice may not be removed or altered from * any source or altered source distribution. * * The Contributing Authors and Group 42, Inc. specifically permit, without * fee, and encourage the use of this source code as a component to * supporting the PNG file format in commercial products. If you use this * source code in a product, acknowledgment is not required but would be * appreciated. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: (c) Copyright Biomedical Imaging Resource Mayo Foundation Incorporation of components of dbh.h are by permission of the Mayo Foundation. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 2 files covered by: Copyright (C) Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (c) by University of Toronto. Written by Henry Spencer. Not derived from licensed software. Permission is granted to anyone to use this software for any purpose on any computer system, and to redistribute it freely, subject to the following restrictions: 1. The author is not responsible for the consequences of use of this software, no matter how awful, even if they arise from defects in it. 2. The origin of this software must not be misrepresented, either by explicit claim or by omission. 3. Altered versions must be plainly marked as such, and must not be misrepresented as being the original software. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 25 files covered by: Copyright (c) David Janssens Copyright (c) Yannick Verschueren Copyright (c) Francois Devaux and Antonin Descampe Copyright (c) Hervé Drolon, FreeImage Team Copyright (c) Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 4 files covered by: Copyright (c) Yannick Verschueren Copyright (c) Hervé Drolon, FreeImage Team Copyright (c) Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 8 files covered by: Copyright (c) Hervé Drolon, FreeImage Team All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 2 files covered by: Copyright (c) Francois Devaux and Antonin Descampe Copyright (c) Hervé Drolon, FreeImage Team Copyright (c) Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 78 files covered by: This software is copyright (C) 1991-1998, Thomas G. Lane. All Rights Reserved except as specified below. Permission is hereby granted to use, copy, modify, and distribute this software (or portions thereof) for any purpose, without fee, subject to these conditions: (1) If any part of the source code for this software is distributed, then this README file must be included, with this copyright and no-warranty notice unaltered; and any additions, deletions, or changes to the original files must be clearly indicated in accompanying documentation. (2) If only executable code is distributed, then the accompanying documentation must state that "this software is based in part on the work of the Independent JPEG Group". (3) Permission for use of this software is granted only if the user accepts full responsibility for any undesirable consequences; the authors accept NO LIABILITY for damages of any kind. These conditions apply to any software derived from or based on the IJG code, not just to the unmodified library. If you use our work, you ought to acknowledge us. Permission is NOT granted for the use of any IJG author's name or company name in advertising or publicity relating to this software or products derived from it. This software may be referred to only as "the Independent JPEG Group's software". We specifically permit and encourage the use of this software as the basis of commercial products, provided that all warranty or liability claims are assumed by the product vendor. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 54 files covered by: Copyright (c) Sam Leffler Copyright (c) Silicon Graphics, Inc. Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notices and this permission notice appear in all copies of the software and related documentation, and (ii) the names of Sam Leffler and Silicon Graphics may not be used in any advertising or publicity relating to the software without the specific, prior written permission of Sam Leffler and Silicon Graphics. THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (c) Greg Ward Larson Copyright (c) Silicon Graphics, Inc. Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notices and this permission notice appear in all copies of the software and related documentation, and (ii) the names of Sam Leffler, Greg Larson and Silicon Graphics may not be used in any advertising or publicity relating to the software without the specific, prior written permission of Sam Leffler, Greg Larson and Silicon Graphics. THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SAM LEFFLER, GREG LARSON OR SILICON GRAPHICS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (c) The Regents of the University of California. All rights reserved. This code is derived from software contributed to Berkeley by James A. Woods, derived from original work by Spencer Thomas and Joseph Orost. Redistribution and use in source and binary forms are permitted provided that the above copyright notice and this paragraph are duplicated in all such forms and that any documentation, advertising materials, and other materials related to such distribution and use acknowledge that the software was developed by the University of California, Berkeley. The name of the University may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 3 files covered by: Decoder support is derived, with permission, from the code in Frank Cringle's viewfax program; Copyright (C) Frank D. Cringle. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 1 file covered by: Copyright (c) Sam Leffler Copyright (c) Pixar Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notices and this permission notice appear in all copies of the software and related documentation, and (ii) the names of Pixar, Sam Leffler and Silicon Graphics may not be used in any advertising or publicity relating to the software without the specific, prior written permission of Pixar, Sam Leffler and Silicon Graphics. THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL PIXAR, SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ============== NEXT COPYRIGHT NOTICE AND LICENSE ENTRY ============== 25 files covered by: /* zlib.h -- interface of the 'zlib' general purpose compression library version 1.1.4, March 11th, 2002 Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu OTB-release-5.8/Copyright/KMLCopyright.txt000066400000000000000000000026441301006202600204510ustar00rootroot00000000000000Copyright 2008-2010 Google Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/LibBOOSTCopyright.txt000066400000000000000000000024721301006202600213420ustar00rootroot00000000000000Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. OTB-release-5.8/Copyright/LibSVMCopyright.txt000066400000000000000000000027311301006202600211170ustar00rootroot00000000000000 Copyright (c) 2000-2005 Chih-Chung Chang and Chih-Jen Lin All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither name of copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/Licence_CeCILL_V2-en.txt000066400000000000000000000511341301006202600215170ustar00rootroot00000000000000 CeCILL FREE SOFTWARE LICENSE AGREEMENT Notice This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting: * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users, * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software. The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[logiciel] L[ibre]) license are: Commissariat l'Energie Atomique - CEA, a public scientific, technical and industrial establishment, having its principal place of business at 31-33 rue de la Fdration, 75752 Paris cedex 15, France. Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange 75794 Paris cedex 16, France. Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France. Preamble The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model. The exercising of these rights is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions. In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability. In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the Software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom. This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions. Article 1 - DEFINITIONS For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning: Agreement: means this license agreement, and its possible subsequent versions and annexes. Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, "as is" when the Licensee accepts the Agreement. Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, "as is" when it is first distributed under the terms and conditions of the Agreement. Modified Software: means the Software modified by at least one Contribution. Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software. Object Code: means the binary files originating from the compilation of the Source Code. Holder: means the holder(s) of the economic rights over the Initial Software. Licensee: means the Software user(s) having accepted the Agreement. Contributor: means a Licensee having made at least one Contribution. Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement. Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules. Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software. External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run. Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space. GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc. Parties: mean both the Licensee and the Licensor. These expressions may be used both in singular and plural form. Article 2 - PURPOSE The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software. Article 3 - ACCEPTANCE 3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events: * (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium; * (ii) the first time the Licensee exercises any of the rights granted hereunder. 3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it. Article 4 - EFFECTIVE DATE AND TERM 4.1 EFFECTIVE DATE The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1. 4.2 TERM The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software. Article 5 - SCOPE OF RIGHTS GRANTED The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter. Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph. 5.1 RIGHT OF USE The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises: 1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form. 2. loading, displaying, running, or storing the Software on any or all medium. 3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder. 5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting Software. The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof. 5.3 RIGHT OF DISTRIBUTION In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means. The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter. 5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data. 5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the Modified Software become subject to all the provisions of this Agreement. The Licensee is authorized to distribute the Modified Software, in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Modified Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Modified Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data. 5.3.3 DISTRIBUTION OF EXTERNAL MODULES When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement. 5.3.4 COMPATIBILITY WITH THE GNU GPL The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL. The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, and distribute that entire code under the terms of the same version of the GNU GPL. Article 6 - INTELLECTUAL PROPERTY 6.1 OVER THE INITIAL SOFTWARE The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software. The Holder undertakes that the Initial Software will remain ruled at least by the current license, for the duration set forth in article 4.2. 6.2 OVER THE CONTRIBUTIONS A Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law. 6.3 OVER THE EXTERNAL MODULES A Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution. 6.4 JOINT PROVISIONS The Licensee expressly undertakes: 1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software; 2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not. The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis--vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors. Article 7 - RELATED SERVICES 7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software. However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor. 7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee. Article 8 - LIABILITY 8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof. 8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor. Article 9 - WARRANTY 9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users. The Licensee shall be responsible for verifying, by any or all means, the product's suitability for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties. 9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5). 9.3 The Licensee acknowledges that the Software is supplied "as is" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature. Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements. 9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark. Article 10 - TERMINATION 10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective. 10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof. Article 11 - MISCELLANEOUS 11.1 EXCUSABLE EVENTS Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc. 11.2 Any Failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently. 11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives. 11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid. 11.5 LANGUAGE The Agreement is drafted in both French and English and both versions are deemed authentic. Article 12 - NEW VERSIONS OF THE AGREEMENT 12.1 Any person is authorized to duplicate and distribute copies of this Agreement. 12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software. 12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4. Article 13 - GOVERNING LAW AND JURISDICTION 13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement. 13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party. Version 2.0 dated 2005-05-21. OTB-release-5.8/Copyright/Licence_CeCILL_V2-fr.txt000066400000000000000000000517301301006202600215260ustar00rootroot00000000000000 CONTRAT DE LICENCE DE LOGICIEL LIBRE CeCILL Avertissement Ce contrat est une licence de logiciel libre issue d'une concertation entre ses auteurs afin que le respect de deux grands principes prside sa rdaction: * d'une part, le respect des principes de diffusion des logiciels libres: accs au code source, droits tendus confrs aux utilisateurs, * d'autre part, la dsignation d'un droit applicable, le droit franais, auquel elle est conforme, tant au regard du droit de la responsabilit civile que du droit de la proprit intellectuelle et de la protection qu'il offre aux auteurs et titulaires des droits patrimoniaux sur un logiciel. Les auteurs de la licence CeCILL (pour Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre]) sont: Commissariat l'Energie Atomique - CEA, tablissement public de caractre scientifique technique et industriel, dont le sige est situ 31-33 rue de la Fdration, 75752 Paris cedex 15. Centre National de la Recherche Scientifique - CNRS, tablissement public caractre scientifique et technologique, dont le sige est situ 3 rue Michel-Ange 75794 Paris cedex 16. Institut National de Recherche en Informatique et en Automatique - INRIA, tablissement public caractre scientifique et technologique, dont le sige est situ Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex. Prambule Ce contrat est une licence de logiciel libre dont l'objectif est de confrer aux utilisateurs la libert de modification et de redistribution du logiciel rgi par cette licence dans le cadre d'un modle de diffusion en logiciel libre. L'exercice de ces liberts est assorti de certains devoirs la charge des utilisateurs afin de prserver ce statut au cours des redistributions ultrieures. L'accessibilit au code source et les droits de copie, de modification et de redistribution qui en dcoulent ont pour contrepartie de n'offrir aux utilisateurs qu'une garantie limite et de ne faire peser sur l'auteur du logiciel, le titulaire des droits patrimoniaux et les concdants successifs qu'une responsabilit restreinte. A cet gard l'attention de l'utilisateur est attire sur les risques associs au chargement, l'utilisation, la modification et/ou au dveloppement et la reproduction du logiciel par l'utilisateur tant donn sa spcificit de logiciel libre, qui peut le rendre complexe manipuler et qui le rserve donc des dveloppeurs ou des professionnels avertis possdant des connaissances informatiques approfondies. Les utilisateurs sont donc invits charger et tester l'adquation du Logiciel leurs besoins dans des conditions permettant d'assurer la scurit de leurs systmes et/ou de leurs donnes et, plus gnralement, l'utiliser et l'exploiter dans les mme conditions de scurit. Ce contrat peut tre reproduit et diffus librement, sous rserve de le conserver en l'tat, sans ajout ni suppression de clauses. Ce contrat est susceptible de s'appliquer tout logiciel dont le titulaire des droits patrimoniaux dcide de soumettre l'exploitation aux dispositions qu'il contient. Article 1 - DEFINITIONS Dans ce contrat, les termes suivants, lorsqu'ils seront crits avec une lettre capitale, auront la signification suivante: Contrat: dsigne le prsent contrat de licence, ses ventuelles versions postrieures et annexes. Logiciel: dsigne le logiciel sous sa forme de Code Objet et/ou de Code Source et le cas chant sa documentation, dans leur tat au moment de l'acceptation du Contrat par le Licenci. Logiciel Initial: dsigne le Logiciel sous sa forme de Code Source et ventuellement de Code Objet et le cas chant sa documentation, dans leur tat au moment de leur premire diffusion sous les termes du Contrat. Logiciel Modifi: dsigne le Logiciel modifi par au moins une Contribution. Code Source: dsigne l'ensemble des instructions et des lignes de programme du Logiciel et auquel l'accs est ncessaire en vue de modifier le Logiciel. Code Objet: dsigne les fichiers binaires issus de la compilation du Code Source. Titulaire: dsigne le ou les dtenteurs des droits patrimoniaux d'auteur sur le Logiciel Initial Licenci: dsigne le ou les utilisateurs du Logiciel ayant accept le Contrat. Contributeur: dsigne le Licenci auteur d'au moins une Contribution. Concdant: dsigne le Titulaire ou toute personne physique ou morale distribuant le Logiciel sous le Contrat. Contribution: dsigne l'ensemble des modifications, corrections, traductions, adaptations et/ou nouvelles fonctionnalits intgres dans le Logiciel par tout Contributeur, ainsi que tout Module Interne. Module: dsigne un ensemble de fichiers sources y compris leur documentation qui permet de raliser des fonctionnalits ou services supplmentaires ceux fournis par le Logiciel. Module Externe: dsigne tout Module, non driv du Logiciel, tel que ce Module et le Logiciel s'excutent dans des espaces d'adressages diffrents, l'un appelant l'autre au moment de leur excution. Module Interne: dsigne tout Module li au Logiciel de telle sorte qu'ils s'excutent dans le mme espace d'adressage. GNU GPL: dsigne la GNU General Public License dans sa version 2 ou toute version ultrieure, telle que publie par Free Software Foundation Inc. Parties: dsigne collectivement le Licenci et le Concdant. Ces termes s'entendent au singulier comme au pluriel. Article 2 - OBJET Le Contrat a pour objet la concession par le Concdant au Licenci d'une licence non exclusive, cessible et mondiale du Logiciel telle que dfinie ci-aprs l'article 5 pour toute la dure de protection des droits portant sur ce Logiciel. Article 3 - ACCEPTATION 3.1 L'acceptation par le Licenci des termes du Contrat est rpute acquise du fait du premier des faits suivants: * (i) le chargement du Logiciel par tout moyen notamment par tlchargement partir d'un serveur distant ou par chargement partir d'un support physique; * (ii) le premier exercice par le Licenci de l'un quelconque des droits concds par le Contrat. 3.2 Un exemplaire du Contrat, contenant notamment un avertissement relatif aux spcificits du Logiciel, la restriction de garantie et la limitation un usage par des utilisateurs expriments a t mis disposition du Licenci pralablement son acceptation telle que dfinie l'article 3.1 ci dessus et le Licenci reconnat en avoir pris connaissance. Article 4 - ENTREE EN VIGUEUR ET DUREE 4.1 ENTREE EN VIGUEUR Le Contrat entre en vigueur la date de son acceptation par le Licenci telle que dfinie en 3.1. 4.2 DUREE Le Contrat produira ses effets pendant toute la dure lgale de protection des droits patrimoniaux portant sur le Logiciel. Article 5 - ETENDUE DES DROITS CONCEDES Le Concdant concde au Licenci, qui accepte, les droits suivants sur le Logiciel pour toutes destinations et pour la dure du Contrat dans les conditions ci-aprs dtailles. Par ailleurs, si le Concdant dtient ou venait dtenir un ou plusieurs brevets d'invention protgeant tout ou partie des fonctionnalits du Logiciel ou de ses composants, il s'engage ne pas opposer les ventuels droits confrs par ces brevets aux Licencis successifs qui utiliseraient, exploiteraient ou modifieraient le Logiciel. En cas de cession de ces brevets, le Concdant s'engage faire reprendre les obligations du prsent alina aux cessionnaires. 5.1 DROIT D'UTILISATION Le Licenci est autoris utiliser le Logiciel, sans restriction quant aux domaines d'application, tant ci-aprs prcis que cela comporte: 1. la reproduction permanente ou provisoire du Logiciel en tout ou partie par tout moyen et sous toute forme. 2. le chargement, l'affichage, l'excution, ou le stockage du Logiciel sur tout support. 3. la possibilit d'en observer, d'en tudier, ou d'en tester le fonctionnement afin de dterminer les ides et principes qui sont la base de n'importe quel lment de ce Logiciel; et ceci, lorsque le Licenci effectue toute opration de chargement, d'affichage, d'excution, de transmission ou de stockage du Logiciel qu'il est en droit d'effectuer en vertu du Contrat. 5.2 DROIT D'APPORTER DES CONTRIBUTIONS Le droit d'apporter des Contributions comporte le droit de traduire, d'adapter, d'arranger ou d'apporter toute autre modification au Logiciel et le droit de reproduire le Logiciel en rsultant. Le Licenci est autoris apporter toute Contribution au Logiciel sous rserve de mentionner, de faon explicite, son nom en tant qu'auteur de cette Contribution et la date de cration de celle-ci. 5.3 DROIT DE DISTRIBUTION Le droit de distribution comporte notamment le droit de diffuser, de transmettre et de communiquer le Logiciel au public sur tout support et par tout moyen ainsi que le droit de mettre sur le march titre onreux ou gratuit, un ou des exemplaires du Logiciel par tout procd. Le Licenci est autoris distribuer des copies du Logiciel, modifi ou non, des tiers dans les conditions ci-aprs dtailles. 5.3.1 DISTRIBUTION DU LOGICIEL SANS MODIFICATION Le Licenci est autoris distribuer des copies conformes du Logiciel, sous forme de Code Source ou de Code Objet, condition que cette distribution respecte les dispositions du Contrat dans leur totalit et soit accompagne: 1. d'un exemplaire du Contrat, 2. d'un avertissement relatif la restriction de garantie et de responsabilit du Concdant telle que prvue aux articles 8 et 9, et que, dans le cas o seul le Code Objet du Logiciel est redistribu, le Licenci permette aux futurs Licencis d'accder facilement au Code Source complet du Logiciel en indiquant les modalits d'accs, tant entendu que le cot additionnel d'acquisition du Code Source ne devra pas excder le simple cot de transfert des donnes. 5.3.2 DISTRIBUTION DU LOGICIEL MODIFIE Lorsque le Licenci apporte une Contribution au Logiciel, les conditions de distribution du Logiciel Modifi sont alors soumises l'intgralit des dispositions du Contrat. Le Licenci est autoris distribuer le Logiciel Modifi, sous forme de Code Source ou de Code Objet, condition que cette distribution respecte les dispositions du Contrat dans leur totalit et soit accompagne: 1. d'un exemplaire du Contrat, 2. d'un avertissement relatif la restriction de garantie et de responsabilit du Concdant telle que prvue aux articles 8 et 9, et que, dans le cas o seul le Code Objet du Logiciel Modifi est redistribu, le Licenci permette aux futurs Licencis d'accder facilement au Code Source complet du Logiciel Modifi en indiquant les modalits d'accs, tant entendu que le cot additionnel d'acquisition du Code Source ne devra pas excder le simple cot de transfert des donnes. 5.3.3 DISTRIBUTION DES MODULES EXTERNES Lorsque le Licenci a dvelopp un Module Externe les conditions du Contrat ne s'appliquent pas ce Module Externe, qui peut tre distribu sous un contrat de licence diffrent. 5.3.4 COMPATIBILITE AVEC LA LICENCE GNU GPL Le Licenci peut inclure un code soumis aux dispositions d'une des versions de la licence GNU GPL dans le Logiciel modifi ou non et distribuer l'ensemble sous les conditions de la mme version de la licence GNU GPL. Le Licenci peut inclure le Logiciel modifi ou non dans un code soumis aux dispositions d'une des versions de la licence GNU GPL et distribuer l'ensemble sous les conditions de la mme version de la licence GNU GPL. Article 6 - PROPRIETE INTELLECTUELLE 6.1 SUR LE LOGICIEL INITIAL Le Titulaire est dtenteur des droits patrimoniaux sur le Logiciel Initial. Toute utilisation du Logiciel Initial est soumise au respect des conditions dans lesquelles le Titulaire a choisi de diffuser son oeuvre et nul autre n'a la facult de modifier les conditions de diffusion de ce Logiciel Initial. Le Titulaire s'engage ce que le Logiciel Initial reste au moins rgi par la prsente licence et ce, pour la dure vise l'article 4.2. 6.2 SUR LES CONTRIBUTIONS Le Licenci qui a dvelopp une Contribution est titulaire sur celle-ci des droits de proprit intellectuelle dans les conditions dfinies par la lgislation applicable. 6.3 SUR LES MODULES EXTERNES Le Licenci qui a dvelopp un Module Externe est titulaire sur celui-ci des droits de proprit intellectuelle dans les conditions dfinies par la lgislation applicable et reste libre du choix du contrat rgissant sa diffusion. 6.4 DISPOSITIONS COMMUNES Le Licenci s'engage expressment: 1. ne pas supprimer ou modifier de quelque manire que ce soit les mentions de proprit intellectuelle apposes sur le Logiciel; 2. reproduire l'identique lesdites mentions de proprit intellectuelle sur les copies du Logiciel modifi ou non. Le Licenci s'engage ne pas porter atteinte, directement ou indirectement, aux droits de proprit intellectuelle du Titulaire et/ou des Contributeurs sur le Logiciel et prendre, le cas chant, l'gard de son personnel toutes les mesures ncessaires pour assurer le respect des dits droits de proprit intellectuelle du Titulaire et/ou des Contributeurs. Article 7 - SERVICES ASSOCIES 7.1 Le Contrat n'oblige en aucun cas le Concdant la ralisation de prestations d'assistance technique ou de maintenance du Logiciel. Cependant le Concdant reste libre de proposer ce type de services. Les termes et conditions d'une telle assistance technique et/ou d'une telle maintenance seront alors dtermins dans un acte spar. Ces actes de maintenance et/ou assistance technique n'engageront que la seule responsabilit du Concdant qui les propose. 7.2 De mme, tout Concdant est libre de proposer, sous sa seule responsabilit, ses licencis une garantie, qui n'engagera que lui, lors de la redistribution du Logiciel et/ou du Logiciel Modifi et ce, dans les conditions qu'il souhaite. Cette garantie et les modalits financires de son application feront l'objet d'un acte spar entre le Concdant et le Licenci. Article 8 - RESPONSABILITE 8.1 Sous rserve des dispositions de l'article 8.2, le Licenci a la facult, sous rserve de prouver la faute du Concdant concern, de solliciter la rparation du prjudice direct qu'il subirait du fait du logiciel et dont il apportera la preuve. 8.2 La responsabilit du Concdant est limite aux engagements pris en application du Contrat et ne saurait tre engage en raison notamment: (i) des dommages dus l'inexcution, totale ou partielle, de ses obligations par le Licenci, (ii) des dommages directs ou indirects dcoulant de l'utilisation ou des performances du Logiciel subis par le Licenci et (iii) plus gnralement d'un quelconque dommage indirect. En particulier, les Parties conviennent expressment que tout prjudice financier ou commercial (par exemple perte de donnes, perte de bnfices, perte d'exploitation, perte de clientle ou de commandes, manque gagner, trouble commercial quelconque) ou toute action dirige contre le Licenci par un tiers, constitue un dommage indirect et n'ouvre pas droit rparation par le Concdant. Article 9 - GARANTIE 9.1 Le Licenci reconnat que l'tat actuel des connaissances scientifiques et techniques au moment de la mise en circulation du Logiciel ne permet pas d'en tester et d'en vrifier toutes les utilisations ni de dtecter l'existence d'ventuels dfauts. L'attention du Licenci a t attire sur ce point sur les risques associs au chargement, l'utilisation, la modification et/ou au dveloppement et la reproduction du Logiciel qui sont rservs des utilisateurs avertis. Il relve de la responsabilit du Licenci de contrler, par tous moyens, l'adquation du produit ses besoins, son bon fonctionnement et de s'assurer qu'il ne causera pas de dommages aux personnes et aux biens. 9.2 Le Concdant dclare de bonne foi tre en droit de concder l'ensemble des droits attachs au Logiciel (comprenant notamment les droits viss l'article 5). 9.3 Le Licenci reconnat que le Logiciel est fourni "en l'tat" par le Concdant sans autre garantie, expresse ou tacite, que celle prvue l'article 9.2 et notamment sans aucune garantie sur sa valeur commerciale, son caractre scuris, innovant ou pertinent. En particulier, le Concdant ne garantit pas que le Logiciel est exempt d'erreur, qu'il fonctionnera sans interruption, qu'il sera compatible avec l'quipement du Licenci et sa configuration logicielle ni qu'il remplira les besoins du Licenci. 9.4 Le Concdant ne garantit pas, de manire expresse ou tacite, que le Logiciel ne porte pas atteinte un quelconque droit de proprit intellectuelle d'un tiers portant sur un brevet, un logiciel ou sur tout autre droit de proprit. Ainsi, le Concdant exclut toute garantie au profit du Licenci contre les actions en contrefaon qui pourraient tre diligentes au titre de l'utilisation, de la modification, et de la redistribution du Logiciel. Nanmoins, si de telles actions sont exerces contre le Licenci, le Concdant lui apportera son aide technique et juridique pour sa dfense. Cette aide technique et juridique est dtermine au cas par cas entre le Concdant concern et le Licenci dans le cadre d'un protocole d'accord. Le Concdant dgage toute responsabilit quant l'utilisation de la dnomination du Logiciel par le Licenci. Aucune garantie n'est apporte quant l'existence de droits antrieurs sur le nom du Logiciel et sur l'existence d'une marque. Article 10 - RESILIATION 10.1 En cas de manquement par le Licenci aux obligations mises sa charge par le Contrat, le Concdant pourra rsilier de plein droit le Contrat trente (30) jours aprs notification adresse au Licenci et reste sans effet. 10.2 Le Licenci dont le Contrat est rsili n'est plus autoris utiliser, modifier ou distribuer le Logiciel. Cependant, toutes les licences qu'il aura concdes antrieurement la rsiliation du Contrat resteront valides sous rserve qu'elles aient t effectues en conformit avec le Contrat. Article 11 - DISPOSITIONS DIVERSES 11.1 CAUSE EXTERIEURE Aucune des Parties ne sera responsable d'un retard ou d'une dfaillance d'excution du Contrat qui serait d un cas de force majeure, un cas fortuit ou une cause extrieure, telle que, notamment, le mauvais fonctionnement ou les interruptions du rseau lectrique ou de tlcommunication, la paralysie du rseau lie une attaque informatique, l'intervention des autorits gouvernementales, les catastrophes naturelles, les dgts des eaux, les tremblements de terre, le feu, les explosions, les grves et les conflits sociaux, l'tat de guerre... 11.2 Le fait, par l'une ou l'autre des Parties, d'omettre en une ou plusieurs occasions de se prvaloir d'une ou plusieurs dispositions du Contrat, ne pourra en aucun cas impliquer renonciation par la Partie intresse s'en prvaloir ultrieurement. 11.3 Le Contrat annule et remplace toute convention antrieure, crite ou orale, entre les Parties sur le mme objet et constitue l'accord entier entre les Parties sur cet objet. Aucune addition ou modification aux termes du Contrat n'aura d'effet l'gard des Parties moins d'tre faite par crit et signe par leurs reprsentants dment habilits. 11.4 Dans l'hypothse o une ou plusieurs des dispositions du Contrat s'avrerait contraire une loi ou un texte applicable, existants ou futurs, cette loi ou ce texte prvaudrait, et les Parties feraient les amendements ncessaires pour se conformer cette loi ou ce texte. Toutes les autres dispositions resteront en vigueur. De mme, la nullit, pour quelque raison que ce soit, d'une des dispositions du Contrat ne saurait entraner la nullit de l'ensemble du Contrat. 11.5 LANGUE Le Contrat est rdig en langue franaise et en langue anglaise, ces deux versions faisant galement foi. Article 12 - NOUVELLES VERSIONS DU CONTRAT 12.1 Toute personne est autorise copier et distribuer des copies de ce Contrat. 12.2 Afin d'en prserver la cohrence, le texte du Contrat est protg et ne peut tre modifi que par les auteurs de la licence, lesquels se rservent le droit de publier priodiquement des mises jour ou de nouvelles versions du Contrat, qui possderont chacune un numro distinct. Ces versions ultrieures seront susceptibles de prendre en compte de nouvelles problmatiques rencontres par les logiciels libres. 12.3 Tout Logiciel diffus sous une version donne du Contrat ne pourra faire l'objet d'une diffusion ultrieure que sous la mme version du Contrat ou une version postrieure, sous rserve des dispositions de l'article 5.3.4. Article 13 - LOI APPLICABLE ET COMPETENCE TERRITORIALE 13.1 Le Contrat est rgi par la loi franaise. Les Parties conviennent de tenter de rgler l'amiable les diffrends ou litiges qui viendraient se produire par suite ou l'occasion du Contrat. 13.2 A dfaut d'accord amiable dans un dlai de deux (2) mois compter de leur survenance et sauf situation relevant d'une procdure d'urgence, les diffrends ou litiges seront ports par la Partie la plus diligente devant les Tribunaux comptents de Paris. Version 2.0 du 2005-05-21. OTB-release-5.8/Copyright/License_Apache2.txt000066400000000000000000000010141301006202600210300ustar00rootroot00000000000000Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. OTB-release-5.8/Copyright/MuParserCopyright.txt000066400000000000000000000026301301006202600215570ustar00rootroot00000000000000 __________ _____ __ __\______ \_____ _______ ______ ____ _______ / \ | | \| ___/\__ \ \_ __ \/ ___/_/ __ \\_ __ \ | Y Y \| | /| | / __ \_| | \/\___ \ \ ___/ | | \/ |__|_| /|____/ |____| (____ /|__| /____ > \___ >|__| \/ \/ \/ \/ Copyright (C) 2010 Ingo Berg Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. OTB-release-5.8/Copyright/MuParserXCopyright.txt000066400000000000000000000056451301006202600217200ustar00rootroot00000000000000######################################################################### # # # __________ ____ ___ # # _____ __ _\______ \_____ _______ ______ __________\ \/ / # # / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / # # | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ # # |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ # # \/ \/ \/ \/ \_/ # # # # Copyright (C) 2013 Ingo Berg # # # # Web: http://muparserx.beltoforion.de # # SVN: http://muparserx.googlecode.com/svn/trunk # # e-mail: muparserx@beltoforion.de # # # # The code contains contributions made by the following people: # # Martin Rotter # # # # This software is distributed under the terms of the # # BSD - Clause 2 "Simplified" or "FreeBSD" Licence (BSD-2-Clause) # # # ######################################################################### Copyright (c) 2012, Ingo Berg All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/OSGCopyright.txt000066400000000000000000000722301301006202600204540ustar00rootroot00000000000000 OpenSceneGraph Public License, Version 0.0 ========================================== Copyright (C) 2002 Robert Osfield. Everyone is permitted to copy and distribute verbatim copies of this licence document, but changing it is not allowed. OPENSCENEGRAPH PUBLIC LICENCE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION This library is free software; you can redistribute it and/or modify it under the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or later. Notes: the OSGPL is based on the LGPL, with the 4 exceptions laid out in the wxWindows section below. The LGPL is contained in the final section of this license. ------------------------------------------------------------------------------- wxWindows Library Licence, Version 3 ==================================== Copyright (C) 1998 Julian Smart, Robert Roebling [, ...] Everyone is permitted to copy and distribute verbatim copies of this licence document, but changing it is not allowed. WXWINDOWS LIBRARY LICENCE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public Licence as published by the Free Software Foundation; either version 2 of the Licence, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public Licence for more details. You should have received a copy of the GNU Library General Public Licence along with this software, usually in a file named COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. EXCEPTION NOTICE 1. As a special exception, the copyright holders of this library give permission for additional uses of the text contained in this release of the library as licenced under the wxWindows Library Licence, applying either version 3 of the Licence, or (at your option) any later version of the Licence as published by the copyright holders of version 3 of the Licence document. 2. The exception is that you may use, copy, link, modify and distribute under the user's own terms, binary object code versions of works based on the Library. 3. If you copy code from files distributed under the terms of the GNU General Public Licence or the GNU Library General Public Licence into a copy of this library, as this licence permits, the exception does not apply to the code that you add in this way. To avoid misleading anyone as to the status of such modified files, you must delete this exception notice from such code and/or adjust the licensing conditions notice accordingly. 4. If you write modifications of your own for this library, it is your choice whether to permit this exception to apply to your modifications. If you do not wish that, you must delete the exception notice from such code and/or adjust the licensing conditions notice accordingly. ------------------------------------------------------------------------------ GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! OTB-release-5.8/Copyright/OSSIMCopyright.txt000066400000000000000000000570171301006202600207240ustar00rootroot00000000000000GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 (The master copy of this license lives on the GNU website.) Copyright (C) 1991, 1999 Free Software Foundation, Inc. Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of aprogram that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from thelibrary, whereas the latter must be combined with the library in order to run. TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, andcopy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all ofthese conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library(because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler,kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a licensefrom the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographicaldistribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS OTB-release-5.8/Copyright/OTBCopyright.txt000066400000000000000000000024271301006202600204510ustar00rootroot00000000000000The ORFEO Toolbox (OTB) is developed by the French Centre National d'Etudes Spatiales, CNES. OTB is partially derived from ITK, GDAL, VXL and LibSVM, hence some code is copyrighted accordingly (see ITKCopyright.txt, GDALCopyright.txt, VXLCopyright.txt and LibSVMCopyright.txt). The OTB copyright is as follows: Copyright (c) Centre National d'Etudes Spatiales All rights reserved. The OTB is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/OpenCVCopyright.txt000066400000000000000000000033541301006202600211570ustar00rootroot00000000000000By downloading, copying, installing or using the software you agree to this license. If you do not agree to this license, do not download, install, copy or use the software. License Agreement For Open Source Computer Vision Library (3-clause BSD License) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the names of the copyright holders nor the names of the contributors may be used to endorse or promote products derived from this software without specific prior written permission. This software is provided by the copyright holders and contributors "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall copyright holders or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage. OTB-release-5.8/Copyright/OpenJPEGCopyright.txt000066400000000000000000000031721301006202600213720ustar00rootroot00000000000000 Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium Copyright (c) 2002-2011, Professor Benoit Macq Copyright (c) 2003-2011, Antonin Descampe Copyright (c) 2003-2009, Francois-Olivier Devaux Copyright (c) 2005, Herve Drolon, FreeImage Team Copyright (c) 2002-2003, Yannick Verschueren Copyright (c) 2001-2003, David Janssens All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/OpenMPICopyright.txt000066400000000000000000000112501301006202600212660ustar00rootroot00000000000000Most files in this release are marked with the copyrights of the organizations who have edited them. The copyrights below are in no particular order and generally reflect members of the Open MPI core team who have contributed code to this release. The copyrights for code used under license from other parties are included in the corresponding files. Copyright (c) 2004-2010 The Trustees of Indiana University and Indiana University Research and Technology Corporation. All rights reserved. Copyright (c) 2004-2010 The University of Tennessee and The University of Tennessee Research Foundation. All rights reserved. Copyright (c) 2004-2010 High Performance Computing Center Stuttgart, University of Stuttgart. All rights reserved. Copyright (c) 2004-2008 The Regents of the University of California. All rights reserved. Copyright (c) 2006-2010 Los Alamos National Security, LLC. All rights reserved. Copyright (c) 2006-2010 Cisco Systems, Inc. All rights reserved. Copyright (c) 2006-2010 Voltaire, Inc. All rights reserved. Copyright (c) 2006-2011 Sandia National Laboratories. All rights reserved. Copyright (c) 2006-2010 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Copyright (c) 2006-2010 The University of Houston. All rights reserved. Copyright (c) 2006-2009 Myricom, Inc. All rights reserved. Copyright (c) 2007-2008 UT-Battelle, LLC. All rights reserved. Copyright (c) 2007-2010 IBM Corporation. All rights reserved. Copyright (c) 1998-2005 Forschungszentrum Juelich, Juelich Supercomputing Centre, Federal Republic of Germany Copyright (c) 2005-2008 ZIH, TU Dresden, Federal Republic of Germany Copyright (c) 2007 Evergrid, Inc. All rights reserved. Copyright (c) 2008 Chelsio, Inc. All rights reserved. Copyright (c) 2008-2009 Institut National de Recherche en Informatique. All rights reserved. Copyright (c) 2007 Lawrence Livermore National Security, LLC. All rights reserved. Copyright (c) 2007-2009 Mellanox Technologies. All rights reserved. Copyright (c) 2006-2010 QLogic Corporation. All rights reserved. Copyright (c) 2008-2010 Oak Ridge National Labs. All rights reserved. Copyright (c) 2006-2010 Oracle and/or its affiliates. All rights reserved. Copyright (c) 2009 Bull SAS. All rights reserved. Copyright (c) 2010 ARM ltd. All rights reserved. Copyright (c) 2010-2011 Alex Brick . All rights reserved. Copyright (c) 2012 The University of Wisconsin-La Crosse. All rights reserved. Copyright (c) 2013-2016 Intel, Inc. All rights reserved. Copyright (c) 2011-2014 NVIDIA Corporation. All rights reserved. $COPYRIGHT$ Additional copyrights may follow $HEADER$ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer listed in this license in the documentation and/or other materials provided with the distribution. - Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. The copyright holders provide no reassurances that the source code provided does not infringe any patent, copyright, or any other intellectual property rights of third parties. The copyright holders disclaim any liability to any recipient for claims brought against recipient by any third party for infringement of that parties intellectual property rights. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OTB-release-5.8/Copyright/SPTWCopyright.txt000066400000000000000000000002451301006202600206160ustar00rootroot00000000000000This software is in the public domain, furnished "as is", without technical support, and with no warranty, express or implied, as to its usefulness for any purpose. OTB-release-5.8/Copyright/TinyXMLCopyright.txt000066400000000000000000000017621301006202600213320ustar00rootroot00000000000000http://www.sourceforge.net/projects/tinyxml/ Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com) TinyXML is released under the zlib license : This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. OTB-release-5.8/Copyright/VXLCopyright.txt000066400000000000000000000033301301006202600204700ustar00rootroot00000000000000Portions of the Insight code base (the numerics package VNL) are derived from the Vision-something-Libraries (VXL), and hence are covered under the VXL copyright. The VXL copyright is as follows: Copyright (c) 2000 TargetJr Consortium GE Corporate Research and Development (GE CRD) 1 Research Circle Niskayuna, NY 12309 All Rights Reserved Reproduction rights limited as described below. Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notice and this permission notice appear in all copies of the software and related documentation, (ii) the name TargetJr Consortium (represented by GE CRD), may not be used in any advertising or publicity relating to the software without the specific, prior written permission of GE CRD, and (iii) any modifications are clearly marked and summarized in a change history log. THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE TARGETJR CONSORTIUM BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR ON ANY THEORY OF LIABILITY ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. See also the VXL web site: http://vxl.sourceforge.net/ for more information. OTB-release-5.8/Examples/000077500000000000000000000000001301006202600151745ustar00rootroot00000000000000OTB-release-5.8/Examples/Application/000077500000000000000000000000001301006202600174375ustar00rootroot00000000000000OTB-release-5.8/Examples/Application/ApplicationExample.cxx000066400000000000000000000231521301006202600237450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ApplicationExample.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the creation of an application. // A new application is a class, which derives from \doxygen{otb}{Wrapper::Application} class. // We start by including the needed header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" // Software Guide : EndCodeSnippet namespace otb { // Software Guide : BeginLatex // Application class is defined in Wrapper namespace. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet namespace Wrapper { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // ExampleApplication class is derived from Application class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet class ApplicationExample : public Application // Software Guide : EndCodeSnippet { public: // Software Guide : BeginLatex // Class declaration is followed by \code{ITK} public types for the class, the superclass and // smart pointers. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ApplicationExample Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Following macros are necessary to respect ITK object factory mechanisms. Please report // to \ref{sec:FilterConventions} for additional information. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet itkNewMacro(Self) ; itkTypeMacro(ExampleApplication, otb::Application) ; // Software Guide : EndCodeSnippet private: // Software Guide : BeginLatex // \doxygen{otb}{Application} relies on three main private methods: \code{DoInit()}, \code{DoUpdate()}, and \code{DoExecute()}. // Section \ref{sec:appArchitecture} gives a description a these methods. // Software Guide : EndLatex // Software Guide : BeginLatex // \code{DoInit()} method contains class information and description, parameter set up, and example values. // Software Guide : EndLatex void DoInit() ITK_OVERRIDE { // Software Guide : BeginLatex // Application name and description are set using following methods : // \begin{description} // \item[\code{SetName()}] Name of the application. // \item[\code{SetDescription()}] Set the short description of the class. // \item[\code{SetDocName()}] Set long name of the application (that can be displayed \dots). // \item[\code{SetDocLongDescription()}] This methods is used to describe the class. // \item[\code{SetDocLimitations()}] Set known limitations (threading, invalid pixel type \dots) or bugs. // \item[\code{SetDocAuthors()}] Set the application Authors. Author List. Format : "John Doe, Winnie the Pooh" \dots // \item[\code{SetDocSeeAlso()}] If the application is related to one another, it can be mentioned. // \end{description} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SetName("Example"); SetDescription("This application opens an image and save it. " "Pay attention, it includes Latex snippets in order to generate " "software guide documentation"); SetDocName("Example"); SetDocLongDescription("The purpose of this application is " "to present parameters types," " and Application class framework. " "It is used to generate Software guide documentation" " for Application chapter example."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // \code{AddDocTag()} method categorize the application using relevant tags. // \code{Code/ApplicationEngine/otbWrapperTags.h} contains some predefined tags defined in \code{Tags} namespace. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet AddDocTag(Tags::Analysis); AddDocTag("Test"); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Application parameters declaration is done using \code{AddParameter()} method. // \code{AddParameter()} requires Parameter type, its name and description. // \doxygen{otb}{Wrapper::Application} class contains methods to set parameters characteristics. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet AddParameter(ParameterType_InputImage, "in", "Input Image"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); AddParameter(ParameterType_Empty, "boolean", "Boolean"); MandatoryOff("boolean"); AddParameter(ParameterType_Int, "int", "Integer"); MandatoryOff("int"); SetDefaultParameterInt("int", 1); SetMinimumParameterIntValue("int", 0); SetMaximumParameterIntValue("int", 10); AddParameter(ParameterType_Float, "float", "Float"); MandatoryOff("float"); SetDefaultParameterFloat("float", 0.2); SetMinimumParameterFloatValue("float", -1.0); SetMaximumParameterFloatValue("float", 15.0); AddParameter(ParameterType_String, "string", "String"); MandatoryOff("string"); AddParameter(ParameterType_InputFilename, "filename", "File name"); MandatoryOff("filename"); AddParameter(ParameterType_Directory, "directory", "Directory name"); MandatoryOff("directory"); AddParameter(ParameterType_Choice, "choice", "Choice"); AddChoice("choice.choice1", "Choice 1"); AddChoice("choice.choice2", "Choice 2"); AddChoice("choice.choice3", "Choice 3"); AddParameter(ParameterType_Float, "choice.choice1.floatchoice1" , "Float of choice1"); SetDefaultParameterFloat("choice.choice1.floatchoice1", 0.125); AddParameter(ParameterType_Float, "choice.choice3.floatchoice3" , "Float of choice3"); SetDefaultParameterFloat("choice.choice3.floatchoice3", 5.0); AddParameter(ParameterType_Group, "ingroup", "Input Group"); MandatoryOff("ingroup"); AddParameter(ParameterType_Int, "ingroup.integer", "Integer of Group"); MandatoryOff("ingroup.integer"); AddParameter(ParameterType_Group, "ingroup.images", "Input Images Group"); AddParameter(ParameterType_InputImage, "ingroup.images.inputimage" , "Input Image"); MandatoryOff("ingroup.images.inputimage"); AddParameter(ParameterType_Group, "outgroup", "Output Group"); MandatoryOff("outgroup"); AddParameter(ParameterType_OutputImage, "outgroup.outputimage" , "Output Image"); MandatoryOff("outgroup.outputimage"); AddParameter(ParameterType_InputImageList, "il", "Input image list"); MandatoryOff("il"); AddParameter(ParameterType_ListView, "cl", "Output Image channels"); AddChoice("cl.choice1", "cl.choice1"); AddChoice("cl.choice2", "cl.choice2"); MandatoryOff("cl"); AddParameter(ParameterType_RAM, "ram", "Available RAM"); SetDefaultParameterInt("ram", 256); MandatoryOff("ram"); AddParameter(ParameterType_ComplexInputImage, "cin", "Input Complex Image"); AddParameter(ParameterType_ComplexOutputImage, "cout", "Output Complex Image"); MandatoryOff("cin"); MandatoryOff("cout"); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // An example commandline is automatically generated. Method \code{SetDocExampleParameterValue()} is // used to set parameters. Dataset should be located in \code{OTB-Data/Examples} directory. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SetDocExampleParameterValue("boolean", "true"); SetDocExampleParameterValue("in", "QB_Suburb.png"); SetDocExampleParameterValue("out", "Application_Example.png"); // Software Guide : EndCodeSnippet } // Software Guide : BeginLatex // \code{DoUpdateParameters()} is called as soon as a parameter value change. Section \ref{sec:appDoUpdateParameters} // gives a complete description of this method. // Software Guide : EndLatex // Software Guide :BeginCodeSnippet void DoUpdateParameters() ITK_OVERRIDE { } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // \code{DoExecute()} contains the application core. Section \ref{sec:appDoExecute} // gives a complete description of this method. // Software Guide : EndLatex // Software Guide :BeginCodeSnippet void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); int paramInt = GetParameterInt("int"); otbAppLogDEBUG( << paramInt < #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "otbVectorImageToImageListFilter.h" // Software Guide : BeginLatex // // We start by including the needed header file. // The aim of this example is to compute the Normalized Difference Vegetation Index (NDVI) // from a multispecral image and perform a threshold on this // indice to extract area containing a dense vegetation canopy. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbBandMathImageFilter.h" // Software Guide : EndCodeSnippet int main( int argc, char* argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImageFile "; std::cerr << " outputPrettyImageFile" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // We start by the classical \code{typedef}s needed for reading and // writing the images. The \doxygen{otb}{BandMathImageFilter} class // works with \doxygen{otb}{Image} as input so we need to define additional // filters to extract each layer of the multispectral image // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorImageToImageListType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the filter: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::BandMathImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the filter, the reader, and the writer: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); writer->SetInput(filter->GetOutput()); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet reader->UpdateOutputInformation(); // Software Guide : BeginLatex // // We need now to extract now each band from the input \doxygen{otb}{VectorImage}, // it illustrates the use of the \doxygen{otb}{VectorImageToImageList}. // Each extracted layer are inputs of the \doxygen{otb}{BandMathImageFilter}: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorImageToImageListType::Pointer imageList = VectorImageToImageListType::New(); imageList->SetInput(reader->GetOutput()); imageList->UpdateOutputInformation(); const unsigned int nbBands = reader->GetOutput()->GetNumberOfComponentsPerPixel(); for(unsigned int j = 0; j < nbBands; ++j) { filter->SetNthInput(j, imageList->GetOutput()->GetNthElement(j)); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we can define the mathematical expression to perform on the layers (b1, b2, b3, b4). // The filter takes advantage of the parsing capabilities of the muParser library and // allows setting the expression as on a digital calculator. // // The expression below returns 255 if the ratio $(NIR-RED)/(NIR+RED)$ is greater than 0.4 and 0 if not. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetExpression("if((b4-b3)/(b4+b3) > 0.4, 255, 0)"); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS filter->SetExpression("((b4-b3)/(b4+b3) > 0.4) ? 255 : 0"); #else filter->SetExpression("if((b4-b3)/(b4+b3) > 0.4, 255, 0)"); #endif // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now plug the pipeline and run it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The muParser library offers also the possibility to extended existing built-in functions. For example, // you can use the OTB expression "ndvi(b3, b4)" with the filter. The mathematical expression would be in // this case \textit{if($ndvi(b3, b4)>0.4$, 255, 0)}. It will return the same result. // // Software Guide : EndLatex // Software Guide : BeginLatex // // Figure~\ref{fig:BandMathImageFilter} shows the result of the threshold over the NDVI indice // to a Quickbird image. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{qb_ExtractRoad_pretty.eps} // \includegraphics[width=0.45\textwidth]{qb_BandMath-pretty.eps} // \itkcaption[Band Math]{From left to right: // Original image, thresholded NDVI indice.} // \label{fig:BandMathImageFilter} // \end{figure} // // Software Guide : EndLatex typedef otb::Image OutputPrettyImageType; typedef otb::ImageFileWriter PrettyImageFileWriterType; typedef itk::CastImageFilter CastImageFilterType; PrettyImageFileWriterType::Pointer prettyWriter = PrettyImageFileWriterType::New(); CastImageFilterType::Pointer caster = CastImageFilterType::New(); caster->SetInput(filter->GetOutput()); prettyWriter->SetInput(caster->GetOutput()); prettyWriter->SetFileName(argv[3]); prettyWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/BandMathXImageFilterExample.cxx000066400000000000000000000217321301006202600255320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {qb_RoadExtract.tif} // OUTPUTS: {qb_BandMath-res1.tif}, {qb_BandMath-res2.tif}, {context.txt} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This filter is based on the mathematical parser library muParserX. // The built in functions and operators list is available at: // \url{http://articles.beltoforion.de/article.php?a=muparserx}. // // In order to use this filter, at least one input image is to be // set. An associated variable name can be specified or not by using // the corresponding SetNthInput method. For the jth (j=1..T) input image, if // no associated variable name has been specified, a default variable // name is given by concatenating the prefix "im" with the // corresponding input index plus one (for instance, im1 is related to the first input). // If the jth input image is multidimensional, then the variable imj represents a vector whose components are related to its bands. // In order to access the kth band, the variable observes the following pattern : imjbk. // // Software Guide : EndLatex #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : BeginLatex // // We start by including the needed header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBandMathXImageFilter.h" // Software Guide : EndCodeSnippet int main( int argc, char* argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImageFile "; std::cerr << " outputImageFile2"; std::cerr << " context.txt" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then, we set the classical \code{typedef}s needed for reading and // writing the images. The \doxygen{otb}{BandMathXImageFilter} class // works with \doxygen{otb}{VectorImage}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the filter: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::BandMathXImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the filter, the reader, and the writer: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The reader and the writer are parametrized with usual settings: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The aim of this example is to compute a simple high-pass filter. // For that purpose, we are going to perform the difference between the original signal // and its averaged version. The definition of the expression that follows is only suitable for a 4-band image. // So first, we must check this requirement: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->UpdateOutputInformation(); if (reader->GetOutput()->GetNumberOfComponentsPerPixel() !=4) itkGenericExceptionMacro(<< "Input image must have 4 bands." << std::endl); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we can define the expression. The variable im1 represents a pixel (made of 4 components) of the input image. // The variable im1b1N5x5 represents a neighborhood of size 5x5 around this pixel (and so on for each band). // The last element we need is the operator 'mean'. By setting its inputs with four neigborhoods, we tell this operator to process the four related bands. // As output, it will produce a vector of four components; this is consistent with the fact that we wish to perform a difference with im1. // // Thus, the expression is as follows: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetExpression("im1-mean(im1b1N5x5,im1b2N5x5,im1b3N5x5,im1b4N5x5)"); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that the importance of the averaging is driven by the names of the neighborhood variables. // Last thing we have to do, is to set the pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetNthInput(0,reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:BandMathXImageFilter} shows the result of our high-pass filter. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{qb_ExtractRoad_pretty.eps} // \includegraphics[width=0.45\textwidth]{qb_BandMath-res1.eps} // \itkcaption[Band Math X]{From left to right: // Original image, high-pass filter output.} // \label{fig:BandMathXImageFilter} // \end{figure} // // Software Guide : EndLatex // Software Guide : BeginLatex // // Now let's see a little bit more complex example. // The aim now is to give the central pixel a higher weight. Moreover : // - we wish to use smaller neighborhoods // - we wish to drop the 4th band // - we wish to add a given number to each band. // // First, we instantiate new filters to later make a proper pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader2 = ReaderType::New(); WriterType::Pointer writer2 = WriterType::New(); FilterType::Pointer filter2 = FilterType::New(); reader2->SetFileName(argv[1]); writer2->SetFileName(argv[3]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define a new kernel (rows are separated by semi-colons, whereas their elements are separated by commas): // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter2->SetMatrix("kernel","{ 0.1 , 0.1 , 0.1; 0.1 , 0.2 , 0.1; 0.1 , 0.1 , 0.1 }"); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We then define a new constant: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter2->SetConstant("cst",1.0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now set the expression (note the use of 'dotpr' operator, as well as the 'bands' operator which is used as a band selector): // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter2->SetExpression("bands(im1,{1,2,3})-dotpr(kernel,im1b1N3x3,im1b2N3x3,im1b3N3x3) + {cst,cst,cst}"); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is possible to export these definitions to a txt file (they will be reusable later thanks to the method ImportContext): // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter2->ExportContext(argv[4]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we set the pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter2->SetNthInput(0,reader2->GetOutput()); writer2->SetInput(filter2->GetOutput()); writer2->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:BandMathXImageFilter2} shows the result of the second filter. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{qb_ExtractRoad_pretty.eps} // \includegraphics[width=0.45\textwidth]{qb_BandMath-res2.eps} // \itkcaption[Band Math X]{From left to right: // Original image, second filter output.} // \label{fig:BandMathXImageFilter2} // \end{figure} // // Software Guide : EndLatex // Software Guide : BeginLatex // // Finally, it is strongly recommended to take a look at the cookbook, where additional information and examples can be found (http://www.orfeo-toolbox.org/packages/OTBCookBook.pdf). // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/CMakeLists.txt000066400000000000000000000030601301006202600223050ustar00rootroot00000000000000project(BasicFiltersExamples) #OTB_USE_MUPARSER is OFF if(OTBMathParser_LOADED) add_executable(BandMathFilterExample BandMathFilterExample.cxx) target_link_libraries(BandMathFilterExample ${OTB_LIBRARIES}) endif() #OTB_USE_MUPARSERX is OFF if(OTBMathParserX_LOADED) add_executable(BandMathXImageFilterExample BandMathXImageFilterExample.cxx) target_link_libraries(BandMathXImageFilterExample ${OTB_LIBRARIES}) endif() add_executable(DEMToRainbowExample DEMToRainbowExample.cxx) target_link_libraries(DEMToRainbowExample ${OTB_LIBRARIES}) add_executable(FrostImageFilter FrostImageFilter.cxx) target_link_libraries(FrostImageFilter ${OTB_LIBRARIES}) add_executable(HillShadingExample HillShadingExample.cxx) target_link_libraries(HillShadingExample ${OTB_LIBRARIES}) add_executable(IndexedToRGBExample IndexedToRGBExample.cxx) target_link_libraries(IndexedToRGBExample ${OTB_LIBRARIES}) add_executable(LeeImageFilter LeeImageFilter.cxx) target_link_libraries(LeeImageFilter ${OTB_LIBRARIES}) #OTBMeanShift depends OTBMathParser. But OTB_USE_MUPARSER is OFF if(OTBMathParser_LOADED) add_executable(MeanShiftSegmentationFilterExample MeanShiftSegmentationFilterExample.cxx) target_link_libraries(MeanShiftSegmentationFilterExample ${OTB_LIBRARIES}) endif() add_executable(PrintableImageFilterExample PrintableImageFilterExample.cxx) target_link_libraries(PrintableImageFilterExample ${OTB_LIBRARIES}) add_executable(ScalingFilterExample ScalingFilterExample.cxx) target_link_libraries(ScalingFilterExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/BasicFilters/DEMToRainbowExample.cxx000066400000000000000000000152061301006202600240440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // OUTPUTS: {DEMToRainbowImageGenerator.png} // 6.5 45.5 500 500 0.002 -0.002 ${OTB_DATA_ROOT}/Examples/DEM_srtm // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // OUTPUTS: {DEMToHotImageGenerator.png} // 6.5 45.5 500 500 0.002 -0.002 ${OTB_DATA_ROOT}/Examples/DEM_srtm hot // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // OUTPUTS: {DEMToReliefImageGenerator.png} // 6.5 45.5 500 500 0.002 -0.002 ${OTB_DATA_ROOT}/Examples/DEM_srtm relief // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // In some situation, it is desirable to represent a gray level image in color for easier // interpretation. This is particularly the case if pixel values in the image are used // to represent some data such as elevation, deformation map, // interferogram. In this case, it is important to ensure that similar // values will get similar colors. You can notice how this requirement // differ from the previous case. // // The following example illustrates the use of the \doxygen{otb}{DEMToImageGenerator} class // combined with the \doxygen{otb}{ScalarToRainbowRGBPixelFunctor}. You can refer to the // source code or to section \ref{sec:ReadDEM} for the DEM conversion to image, // we will focus on the color conversion part here. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkScalarToRGBColormapImageFilter.h" #include "otbScalarToRainbowRGBPixelFunctor.h" #include "otbDEMToImageGenerator.h" #include "otbReliefColormapFunctor.h" int main(int argc, char * argv[]) { if (argc < 9) { std::cout << argv[0] << " "; std::cout << " "; std::cout << " " << std::endl; return EXIT_FAILURE; } typedef double PixelType; typedef unsigned char UCharPixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; typedef otb::Image RGBImageType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[1]); typedef otb::DEMToImageGenerator DEMToImageGeneratorType; DEMToImageGeneratorType::Pointer demToImage = DEMToImageGeneratorType::New(); typedef DEMToImageGeneratorType::SizeType SizeType; typedef DEMToImageGeneratorType::SpacingType SpacingType; typedef DEMToImageGeneratorType::PointType PointType; otb::DEMHandler::Instance()->OpenDEMDirectory(argv[8]); PointType origin; origin[0] = ::atof(argv[2]); origin[1] = ::atof(argv[3]); demToImage->SetOutputOrigin(origin); SizeType size; size[0] = ::atoi(argv[4]); size[1] = ::atoi(argv[5]); demToImage->SetOutputSize(size); SpacingType spacing; spacing[0] = ::atof(argv[6]); spacing[1] = ::atof(argv[7]); demToImage->SetOutputSpacing(spacing); // Software Guide : BeginLatex // // As in the previous example the \doxygen{itk}{ScalarToRGBColormapImageFilter} is // the filter in charge of calling the functor we specify to do the work for // each pixel. Here it is the \doxygen{otb}{ScalarToRainbowRGBPixelFunctor}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ScalarToRGBColormapImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->UseInputImageExtremaForScalingOff(); if (argc == 9) { typedef otb::Functor::ScalarToRainbowRGBPixelFunctor ColorMapFunctorType; ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); } // Software Guide : EndCodeSnippet else { if (strcmp(argv[9], "hot") == 0) { typedef itk::Function::HotColormapFunction ColorMapFunctorType; ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); } else { typedef otb::Functor::ReliefColormapFunctor ColorMapFunctorType; ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); } } // Software Guide : BeginLatex // // And we connect the color mapper filter with the filter producing // the image of the DEM: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet colormapper->SetInput(demToImage->GetOutput()); // Software Guide : EndCodeSnippet writer->SetInput(colormapper->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Figure~\ref{fig:RAINBOW_FILTER} shows effect of applying the filter to // a gray level image. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{pretty_DEMToImageGenerator.eps} // \includegraphics[width=0.44\textwidth]{DEMToRainbowImageGenerator.eps} // \includegraphics[width=0.44\textwidth]{DEMToHotImageGenerator.eps} // \includegraphics[width=0.44\textwidth]{DEMToReliefImageGenerator.eps} // \itkcaption[Grayscale to color]{The gray level DEM extracted from SRTM // data (top-left) and the same area in color representation.} // \label{fig:RAINBOW_FILTER} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/FrostImageFilter.cxx000066400000000000000000000113431301006202600235020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {GomaSmall.png} // OUTPUTS: {GomaSmallFrostFiltered.png} // 5 0.1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{FrostImageFilter}. // This filter belongs to the family of the edge-preserving smoothing // filters which are usually used for speckle reduction in radar // images. // // This filter uses a negative exponential convolution kernel. // The output of the filter for pixel p is: // $ \hat I_{s}=\sum_{p\in\eta_{p}} m_{p}I_{p} $ // // where : $ m_{p}=\frac{KC_{s}^{2}\exp(-KC_{s}^{2}d_{s, p})}{\sum_{p\in\eta_{p}} KC_{s}^{2}\exp(-KC_{s}^{2}d_{s, p})} $ // and $ d_{s, p}=\sqrt{(i-i_{p})^2+(j-j_{p})^2} $ // // \begin{itemize} // \item $ K $ : the decrease coefficient // \item $ (i, j)$ : the coordinates of the pixel inside the region // defined by $ \eta_{s} $ // \item $ (i_{p}, j_{p})$ : the coordinates of the pixels belonging to $ \eta_{p} \subset \eta_{s} $ // \item $ C_{s}$ : the variation coefficient computed over $ \eta_{p}$ // \end{itemize} // // // // Most of this example is similar to the previous one and only the differences // will be highlighted. // // First, we need to include the header: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbFrostImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImageFile radius deramp" << std::endl; return EXIT_FAILURE; } typedef unsigned char PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined previously. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::FrostImageFilter FilterType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{FrostImageFilter}. // // \index{otb::FrostImageFilter!SetInput()} // \index{otb::FileImageReader!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{SetRadius()} defines the size of the window to // be used for the computation of the local statistics. The method // \code{SetDeramp()} sets the $K$ coefficient. // // \index{otb::FrostImageFilter!SetRadius()} // \index{otb::FrostImageFilter!SetDeramp()} // \index{SetDeramp()!otb::FrostImageFilter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::SizeType Radius; Radius[0] = atoi(argv[3]); Radius[1] = atoi(argv[3]); filter->SetRadius(Radius); filter->SetDeramp(atof(argv[4])); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:FROST_FILTER} shows the result of applying the Frost // filter to a SAR image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{GomaSmall.eps} // \includegraphics[width=0.44\textwidth]{GomaSmallFrostFiltered.eps} // \itkcaption[Frost Filter Application]{Result of applying the // \doxygen{otb}{FrostImageFilter} to a SAR image.} // \label{fig:FROST_FILTER} // \end{figure} // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{LeeImageFilter} // \end{itemize} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/HillShadingExample.cxx000066400000000000000000000165301301006202600240010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // OUTPUTS: {HillShadingExample.png}, {HillShadingColorExample.png} // 6.5 45.5 500 500 0.002 -0.002 ${OTB_DATA_ROOT}/Examples/DEM_srtm // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Visualization of digital elevation models (DEM) is often more intuitive by simulating a // lighting source and generating the corresponding shadows. This principle is called // hill shading. // // Using a simple functor \doxygen{otb}{HillShadingFunctor} and the dem image generated // using the \doxygen{otb}{DEMToImageGenerator} (refer to \ref{sec:ReadDEM}) you can easily // obtain a representation of the DEM. Better yet, using the // \doxygen{otb}{ScalarToRainbowRGBPixelFunctor}, combined with the // \doxygen{otb}{ReliefColormapFunctor} you can easily generate the classic elevation maps. // // This example will focus on the shading itself. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbDEMToImageGenerator.h" #include "otbHillShadingFilter.h" #include "itkScalarToRGBColormapImageFilter.h" #include "otbReliefColormapFunctor.h" #include "itkMultiplyImageFilter.h" #include "itkShiftScaleImageFilter.h" #include "otbWorldFile.h" int main(int argc, char * argv[]) { if (argc < 10) { std::cout << argv[0] << " " << " " << " " << " " << " [Projection Ref]" << std::endl; return EXIT_FAILURE; } typedef double PixelType; typedef unsigned char UCharPixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; typedef otb::Image RGBImageType; typedef otb::Image ScalarImageType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter ScalarWriterType; ScalarWriterType::Pointer writer = ScalarWriterType::New(); writer->SetFileName(argv[1]); WriterType::Pointer writer2 = WriterType::New(); writer2->SetFileName(argv[2]); typedef otb::DEMToImageGenerator DEMToImageGeneratorType; DEMToImageGeneratorType::Pointer demToImage = DEMToImageGeneratorType::New(); typedef DEMToImageGeneratorType::SizeType SizeType; typedef DEMToImageGeneratorType::SpacingType SpacingType; typedef DEMToImageGeneratorType::PointType PointType; otb::DEMHandler::Instance()->OpenDEMDirectory(argv[9]); PointType origin; origin[0] = ::atof(argv[3]); origin[1] = ::atof(argv[4]); demToImage->SetOutputOrigin(origin); SizeType size; size[0] = ::atoi(argv[5]); size[1] = ::atoi(argv[6]); demToImage->SetOutputSize(size); SpacingType spacing; spacing[0] = ::atof(argv[7]); spacing[1] = ::atof(argv[8]); demToImage->SetOutputSpacing(spacing); double res = 0; if ( argc > 10) { demToImage->SetOutputProjectionRef(argv[10]); res = spacing[0]; } else { //Compute the resolution (Vincenty formula) double lon1 = origin[0]; double lon2 = origin[0] + size[0] * spacing[0]; double lat1 = origin[1]; double lat2 = origin[1] + size[1] * spacing[1]; double R = 6371; // km double d = vcl_acos(vcl_sin(lat1) * vcl_sin(lat2) + vcl_cos(lat1) * vcl_cos(lat2) * vcl_cos(lon2 - lon1)) * R; res = d / vcl_sqrt(2.0); } // Software Guide : BeginLatex // // After generating the dem image as in the DEMToImageGenerator example, you can declare // the hill shading mechanism. The hill shading is implemented as a functor doing some // operations in its neighborhood. A convenient filter called \doxygen{otb}{HillShadingFilter} // is defined around this mechanism. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::HillShadingFilter HillShadingFilterType; HillShadingFilterType::Pointer hillShading = HillShadingFilterType::New(); hillShading->SetRadius(1); hillShading->SetInput(demToImage->GetOutput()); // Software Guide : EndCodeSnippet hillShading->GetFunctor().SetXRes(res); hillShading->GetFunctor().SetYRes(res); typedef itk::ShiftScaleImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetScale(255.0); rescaler->SetInput(hillShading->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef itk::ScalarToRGBColormapImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->UseInputImageExtremaForScalingOff(); typedef otb::Functor::ReliefColormapFunctor ColorMapFunctorType; ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); colormapper->SetInput(demToImage->GetOutput()); typedef itk::BinaryFunctorImageFilter > MultiplyFilterType; MultiplyFilterType::Pointer multiply = MultiplyFilterType::New(); multiply->SetInput1(colormapper->GetOutput()); multiply->SetInput2(hillShading->GetOutput()); writer2->SetInput(multiply->GetOutput()); try { writer->Update(); writer2->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } otb::WorldFile::Pointer worldFile = otb::WorldFile::New(); worldFile->SetLonOrigin(origin[0]); worldFile->SetLatOrigin(origin[1]); worldFile->SetLonSpacing(spacing[0]); worldFile->SetLatSpacing(spacing[1]); worldFile->SetImageFilename(argv[1]); worldFile->Update(); worldFile->SetImageFilename(argv[2]); worldFile->Update(); // Software Guide : BeginLatex // // Figure~\ref{fig:HILL_SHADING} shows the hill shading result from SRTM data. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{HillShadingExample.eps} // \includegraphics[width=0.44\textwidth]{HillShadingColorExample.eps} // \itkcaption[Hill shading]{Hill shading obtained from SRTM data (left) and combined with // the color representation (right)} // \label{fig:HILL_SHADING} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/IndexedToRGBExample.cxx000066400000000000000000000106461301006202600240330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {buildingExtractionIndexed.tif} // OUTPUTS: {buildingExtractionRGB.png}, {buildingExtractionIndexed_scaled.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Some algorithms produce an indexed image as output. In such images, // each pixel is given a value according to the region number it belongs to. // This value starting at 0 or 1 is usually an integer value. // Often, such images are produced by segmentation or classification algorithms. // // If such regions are easy to manipulate -- it is easier and faster to compare two integers // than a RGB value -- it is different when it comes to displaying the results. // // Here we present a convient way to convert such indexed image to a color image. In // such conversion, it is important to ensure that neighborhood region, which are // likely to have consecutive number have easily dicernable colors. This is done // randomly using a hash function by the \doxygen{itk}{ScalarToRGBPixelFunctor}. // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkScalarToRGBPixelFunctor.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char * argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0] << " "; std::cerr << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputRGBFilename = argv[2]; const char * outputScaledFilename = argv[3]; typedef otb::Image ImageType; typedef otb::Image, 2> RGBImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Software Guide : BeginLatex // // The \doxygen{itk}{UnaryFunctorImageFilter} is the filter in charge of // calling the functor we specify to do the work for each pixel. Here it is the // \doxygen{itk}{ScalarToRGBPixelFunctor}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Functor::ScalarToRGBPixelFunctor ColorMapFunctorType; typedef itk::UnaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputRGBFilename); writer->SetInput(colormapper->GetOutput()); writer->Update(); //The following is just to produce the input image for the software guide typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetInput(reader->GetOutput()); typedef otb::ImageFileWriter UCharWriterType; UCharWriterType::Pointer writer2 = UCharWriterType::New(); writer2->SetFileName(outputScaledFilename); writer2->SetInput(rescaler->GetOutput()); writer2->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:INDEXTORGB_FILTER} shows the result of the conversion // from an indexed image to a color image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{buildingExtractionIndexed_scaled.eps} // \includegraphics[width=0.44\textwidth]{buildingExtractionRGB.eps} // \itkcaption[Scaling images]{The original indexed image (left) and the // conversion to color image.} // \label{fig:INDEXTORGB_FILTER} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/LeeImageFilter.cxx000066400000000000000000000125271301006202600231170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {GomaSmall.png} // OUTPUTS: {GomaSmallLeeFiltered.png} // 3 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{LeeImageFilter}. // This filter belongs to the family of the edge-preserving smoothing // filters which are usually used for speckle reduction in radar // images. The Lee filter \cite{LeeFilter} aplies a linear regression // which minimizes the mean-square error in the frame of a // multiplicative speckle model. // // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLeeImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImageFile radius NbLooks" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LeeImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{LeeImageFilter}. // // \index{otb::LeeImageFilter!SetInput()} // \index{otb::FileImageReader!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{SetRadius()} defines the size of the window to // be used for the computation of the local statistics. The method // \code{SetNbLooks()} sets the number of looks of the input // image. // // \index{otb::LeeImageFilter!SetRadius()} // \index{otb::LeeImageFilter!SetNbLooks()} // \index{SetNbLooks()!otb::LeeImageFilter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::SizeType Radius; Radius[0] = atoi(argv[3]); Radius[1] = atoi(argv[3]); filter->SetRadius(Radius); filter->SetNbLooks(atoi(argv[4])); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:LEE_FILTER} shows the result of applying the Lee // filter to a SAR image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{GomaSmall.eps} // \includegraphics[width=0.44\textwidth]{GomaSmallLeeFiltered.eps} // \itkcaption[Lee Filter Application]{Result of applying the // \doxygen{otb}{LeeImageFilter} to a SAR image.} // \label{fig:LEE_FILTER} // \end{figure} // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{FrostImageFilter} // \end{itemize} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/MeanShiftSegmentationFilterExample.cxx000066400000000000000000000175021301006202600272150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1.png} // OUTPUTS: {MSLabeledOutput.tif}, {MSClusteredOutput.tif}, {MSLabeledOutput-pretty.png}, {MSClusteredOutput-pretty.png} // 16 16 100 100 0.1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example demonstrates the use of the // \doxygen{otb}{MeanShiftSegmentationFilter} class which implements // filtering and clustering using the mean shift algorithm // \cite{Comaniciu2002}. For a given pixel, the mean shift will // build a set of neighboring pixels within a given spatial radius // and a color range. The spatial and color center of this set is // then computed and the algorithm iterates with this new spatial and // color center. The Mean Shift can be used for edge-preserving // smoothing, or for clustering. // // Software Guide : EndLatex #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" #include "itkScalarToRGBPixelFunctor.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginLatex // // We start by including the needed header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMeanShiftSegmentationFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 11) { std::cerr << "Usage: " << argv[0] << " infname labeledfname clusteredfname labeledpretty clusteredpretty " << "spatialRadius rangeRadius minRegionSize maxiter thres" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * labeledfname = argv[2]; const char * clusteredfname = argv[3]; const char * labeledpretty = argv[4]; const char * clusteredpretty = argv[5]; const unsigned int spatialRadius = atoi(argv[6]); const double rangeRadius = atof(argv[7]); const unsigned int minRegionSize = atoi(argv[8]); const unsigned int maxiter = atoi(argv[9]); const double thres = atof(argv[10]); // Software Guide : BeginLatex // // We start by the classical \code{typedef}s needed for reading and // writing the images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef float PixelType; typedef unsigned int LabelPixelType; typedef itk::RGBPixel ColorPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabelImageType; typedef otb::Image RGBImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter LabelWriterType; typedef otb::MeanShiftSegmentationFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the filter, the reader, and 2 writers (for the // labeled and clustered images). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer1 = WriterType::New(); LabelWriterType::Pointer writer2 = LabelWriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the file names for the reader and the writers: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(infname); writer1->SetFileName(clusteredfname); writer2->SetFileName(labeledfname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now set the parameters for the filter. There are 3 main // parameters: the spatial radius used for defining the neighborhood, // the range radius used for defining the interval in the color space // and the minimum size for the regions to be kept after clustering. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetSpatialBandwidth(spatialRadius); filter->SetRangeBandwidth(rangeRadius); filter->SetMinRegionSize(minRegionSize); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Two another parameters can be set : the maximum iteration number, which defines maximum number of iteration until convergence. // Algorithm iterative scheme will stop if convergence hasn't been reached after the maximum number of iterations. // Threshold parameter defines mean-shift vector convergence value. Algorithm iterative scheme will stop if mean-shift vector is below this threshold or if iteration number reached maximum number of iterations. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetMaxIterationNumber(maxiter); filter->SetThreshold(thres); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now plug the pipeline and run it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer1->SetInput(filter->GetClusteredOutput()); writer2->SetInput(filter->GetLabelOutput()); writer1->Update(); writer2->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:MeanShiftSegmentationFilter} shows the result of applying the mean shift // to a Quickbird image. // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{ROI_QB_MUL_1.eps} // \includegraphics[width=0.40\textwidth]{MSClusteredOutput-pretty.eps} // \includegraphics[width=0.40\textwidth]{MSLabeledOutput-pretty.eps} // \itkcaption[Mean Shift]{From top to bottom and left to right: // Original image, image filtered by // mean shift after clustering , and labeled image.} // \label{fig:MeanShiftSegmentationFilter} // \end{figure} // Software Guide : EndLatex typedef otb::PrintableImageFilter PrintableFilterType; PrintableFilterType::Pointer printableImageFilter = PrintableFilterType::New(); printableImageFilter->SetChannel(1); printableImageFilter->SetChannel(2); printableImageFilter->SetChannel(3); typedef PrintableFilterType::OutputImageType OutputImageType; typedef otb::ImageFileWriter PrettyWriterType; PrettyWriterType::Pointer prettyWriter = PrettyWriterType::New(); printableImageFilter->SetInput(filter->GetClusteredOutput()); prettyWriter->SetFileName(clusteredpretty); prettyWriter->SetInput(printableImageFilter->GetOutput()); prettyWriter->Update(); typedef otb::ImageFileWriter LabelRGBWriterType; LabelRGBWriterType::Pointer labelRGBWriter = LabelRGBWriterType::New(); // Label to RGB image typedef itk::Functor::ScalarToRGBPixelFunctor FunctorType; typedef itk::UnaryFunctorImageFilter ColorLabelFilterType; ColorLabelFilterType::Pointer labelToRGB = ColorLabelFilterType::New(); labelToRGB->SetInput(filter->GetLabelOutput()); labelRGBWriter->SetFileName(labeledpretty); labelRGBWriter->SetInput(labelToRGB->GetOutput()); labelRGBWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/PrintableImageFilterExample.cxx000066400000000000000000000123651301006202600256460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {IMAGERY_SSECH.tif} // OUTPUTS: {PrintableExampleOutput1.jpg} // 1 2 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {IMAGERY_SSECH.tif} // OUTPUTS: {PrintableExampleOutput2.jpg} // 1 4 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Most of the time, satellite images have more than three spectral bands. As we // are only able to see three colors (red, green and blue), we have to find a way to // represent these images using only three bands. This is called creating a color // composition. // // Of course, any color composition will not be able to render all the information // available in the original image. As a consequence, sometimes, creating more than // one color composition will be necessary. // // If you want to obtain an image with natural colors, you have to match the wavelength // captured by the satellite with those captured by your eye: thus matching the red band // with the red color, etc. // // Some satellites (SPOT 5 is an example) do not acquire all the {\em human} spectral bands: // the blue can be missing and replaced by some other wavelength of interest for a specific application. // In these situations, another mapping has to be created. That's why, the vegetation often appears in // red in satellite images (see on left of figure~\ref{fig:PRINTABLE_FILTER}). // // The band order in the image products can be also quite tricky. It could be in the wavelength order, // as it is the case for Quickbird (1: Blue, 2: Green, 3: Red, 4: NIR), in this case, you // have to be careful to reverse the order if you want a natural display. It could also be reverse // to facilitate direct viewing, as for SPOT5 (1: NIR, 2: Red, 3: Green, 4: SWIR) but in this situations // you have to be careful when you process the image. // // Software Guide : EndLatex #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" int main(int argc, char * argv[]) { if (argc != 6) { std::cerr << "Usage: " << argv[0] << " "; std::cerr << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; int redChannelNumber = atoi(argv[3]); int greenChannelNumber = atoi(argv[4]); int blueChannelNumber = atoi(argv[5]); typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Software Guide : BeginLatex // // To easily convert the image to a {\em printable} format, i.e. 3 bands // \code{unsigned char} value, you can use the \doxygen{otb}{PrintableImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::PrintableImageFilter PrintableFilterType; PrintableFilterType::Pointer printableImageFilter = PrintableFilterType::New(); printableImageFilter->SetInput(reader->GetOutput()); printableImageFilter->SetChannel(redChannelNumber); printableImageFilter->SetChannel(greenChannelNumber); printableImageFilter->SetChannel(blueChannelNumber); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // When you create the writer to plug at the output of the \code{printableImageFilter} // you may want to use the direct type definition as it is a good way to avoid mismatch: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PrintableFilterType::OutputImageType OutputImageType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(printableImageFilter->GetOutput()); writer->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:PRINTABLE_FILTER} illustrates different color compositions for a SPOT 5 image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{PrintableExampleOutput1.eps} // \includegraphics[width=0.44\textwidth]{PrintableExampleOutput2.eps} // \itkcaption[Scaling images]{On the left, a classic SPOT5 // combination: XS3 in red, XS2 in green and XS1 in blue. On the // right another composition: XS3 in red, XS4 in green and XS2 in blue.} // \label{fig:PRINTABLE_FILTER} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/ScalingFilterExample.cxx000066400000000000000000000072401301006202600243370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Toulouse_Ortho_PAN.tif} // OUTPUTS: {QB_Toulouse_Ortho_PAN_rescaled.png}, {QB_Toulouse_Ortho_PAN_casted.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // On one hand, satellite images are commonly coded on more than 8 bits to provide // the dynamic range required from shadows to clouds. On the other hand, image formats // in use for printing and display are usually limited to 8 bits. We need to convert the value // to enable a proper display. This is usually done using linear scaling. Of course, you have // to be aware that some information is lost in the process. // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkCastImageFilter.h" int main(int argc, char * argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0] << " "; std::cerr << " " << std::endl; return EXIT_FAILURE; } typedef unsigned short InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The \doxygen{itk}{RescaleIntensityImageFilter} is used to rescale the value: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); writer->Update(); typedef itk::CastImageFilter CasterType; CasterType::Pointer caster = CasterType::New(); caster->SetInput(reader->GetOutput()); writer->SetFileName(argv[3]); writer->SetInput(caster->GetOutput()); writer->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:SCALING_FILTER} illustrates the difference between a proper scaling and // a simple truncation of the value and demonstrates why it is // important to keep this in mind. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Toulouse_Ortho_PAN_casted.eps} // \includegraphics[width=0.44\textwidth]{QB_Toulouse_Ortho_PAN_rescaled.eps} // \itkcaption[Scaling images]{On the left, the image obtained by truncated pixel values // at the dynamic acceptable for a png file (between 0 and 255). On the right, // the same image with // a proper rescaling} // \label{fig:SCALING_FILTER} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/BasicFilters/test/000077500000000000000000000000001301006202600205255ustar00rootroot00000000000000OTB-release-5.8/Examples/BasicFilters/test/CMakeLists.txt000066400000000000000000000101261301006202600232650ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/BasicFilters) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME bfTeLeeImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/GomaSmallLeeFiltered.tif ${TEMP}/GomaSmallLeeFiltered.tif Execute $ ${INPUTDATA}/GomaSmall.tif ${TEMP}/GomaSmallLeeFiltered.tif 3 1 ) # ------- FrostImageFilterTest---------- otb_add_test(NAME bfTeFrostImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/GomaSmallFrostFiltered.tif ${TEMP}/GomaSmallFrostFiltered.tif Execute $ ${INPUTDATA}/GomaSmall.tif ${TEMP}/GomaSmallFrostFiltered.tif 5 0.1 ) # ------- DEMToRainbowExampleTest ---------- otb_add_test(NAME bfTeDEMToRainbowExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/DEMToRainbowImageGenerator.png ${TEMP}/DEMToRainbowImageGenerator.png Execute $ ${TEMP}/DEMToRainbowImageGenerator.png 6.5 45.5 500 500 0.002 -0.002 ${OTB_DATA_ROOT}/Examples/DEM_srtm ) # ------- ScalingFilterExampleTest ---------- otb_add_test(NAME bfTeScalingFilterExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/QB_Toulouse_Ortho_PAN_rescaled.png ${TEMP}/QB_Toulouse_Ortho_PAN_rescaled.png ${BASELINE}/QB_Toulouse_Ortho_PAN_casted.png ${TEMP}/QB_Toulouse_Ortho_PAN_casted.png Execute $ ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/QB_Toulouse_Ortho_PAN_rescaled.png ${TEMP}/QB_Toulouse_Ortho_PAN_casted.png ) # ------- PrintableImageFilterTest---------- otb_add_test(NAME bfTePrintableImageFilterExample1Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/PrintableExampleOutput1.png ${TEMP}/PrintableExampleOutput1.png Execute $ ${INPUTDATA}/IMAGERY_SSECH.tif ${TEMP}/PrintableExampleOutput1.png 1 2 3 ) otb_add_test(NAME bfTePrintableImageFilteExample2rTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/PrintableExampleOutput2.png ${TEMP}/PrintableExampleOutput2.png Execute $ ${INPUTDATA}/IMAGERY_SSECH.tif ${TEMP}/PrintableExampleOutput2.png 1 4 2 ) # ------- IndexedToRGBExampleTest---------- otb_add_test(NAME bfTeIndexedToRGBExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/buildingExtractionRGB.png ${TEMP}/buildingExtractionRGB.png ${BASELINE}/buildingExtractionIndexed_scaled.png ${TEMP}/buildingExtractionIndexed_scaled.png Execute $ ${INPUTDATA}/buildingExtractionIndexed.tif ${TEMP}/buildingExtractionRGB.png ${TEMP}/buildingExtractionIndexed_scaled.png ) #if(OTBMathParser_LOADED) #otb_add_test(NAME bfTeMeanShiftSegmentationFilterExampleTest COMMAND ${OTB_TEST_DRIVER} #--compare-n-images ${NOTOL} 4 #${BASELINE}/MSClusteredOutput.tif #${TEMP}/MSClusteredOutput.tif #${BASELINE}/MSLabeledOutput.tif #${TEMP}/MSLabeledOutput.tif #${BASELINE}/MSLabeledOutput-pretty.png #${TEMP}/MSLabeledOutput-pretty.png #${BASELINE}/MSClusteredOutput-pretty.png #${TEMP}/MSClusteredOutput-pretty.png #Execute $ #${INPUTDATA}/ROI_QB_MUL_1.png #${TEMP}/MSLabeledOutput.tif #${TEMP}/MSClusteredOutput.tif #${TEMP}/MSLabeledOutput-pretty.png #${TEMP}/MSClusteredOutput-pretty.png #16 #16 #100 #100 #0.1 #) #endif() # ------- HillShadingExampleTest ---------- otb_add_test(NAME bfTeHillShadingExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/HillShadingExample.png ${TEMP}/HillShadingExample.png ${BASELINE}/HillShadingColorExample.png ${TEMP}/HillShadingColorExample.png Execute $ ${TEMP}/HillShadingExample.png ${TEMP}/HillShadingColorExample.png 6.8 45.3 500 500 0.002 -0.002 ${OTB_DATA_ROOT}/Examples/DEM_srtm ) OTB-release-5.8/Examples/CMakeLists.txt000066400000000000000000000150011301006202600177310ustar00rootroot00000000000000##### check if standalone project ###### if(NOT PROJECT_NAME) if(WIN32) cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR) else() cmake_minimum_required(VERSION 2.8.6 FATAL_ERROR) endif() project(OTBExamples) endif() #check if this is a standalone build? if(PROJECT_NAME STREQUAL "OTBExamples") if(BUILD_TESTING) include(CTest) endif() # dashboard build. Why do I need to see the deprecated warnings on dashboard! # It just fades the actual warnings and most importantly very annoying. if(NOT "$ENV{DASHBOARD_TEST_FROM_CTEST}" STREQUAL "") if(UNIX) if(CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-cpp") else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-#warnings") endif() #CMAKE_COMPILER_IS_GNUCXX endif() #UNIX endif() # -------------------------------------------------------------------------------- # Manage PHR data input if(OTB_DATA_USE_LARGEINPUT) set(GenericTestPHR_DATA_INPUTS ${GenericTestPHR_DATA_INPUTS} ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES-PRE/TLSE_JP2_ORTHO_DIMAPv2_PMS-N_lossy_12bits/IMG_PHR1Z_PMS_N_001/IMG_PHR1A_PMS-N_201006181052297_ORT_IPU_20111011_0619-001_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES-PRE/TLSE_TIFF_ORTHO_DIMAPv2_MS_lossless_8bits/IMG_PHR1A_MS_002/IMG_PHR1A_MS_201006181052297_ORT_IPU_20111109_7807-004_R1C1.TIF ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES-PRE/TLSE_TIFF_PRIMARY_DIMAPv2_MS_lossly_12bits/IMG_PHR1A_MS_002/IMG_PHR1A_MS_201006181052297_SEN_IPU_20111025_3077-004_R1C1.TIF ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R2C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES/LASVEGAS_JP2_DIMAPv1_PRIMARY_PMS_lossless_12bits/IMGPHR_PHR1A_SENSOR_20120217_IPU_20120217_5374-001_V1/IMG_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/PLEIADES/PARIS_JP2_DIMAPv1_ORTHO_PMS_lossless_12bits/IMGPHR_PHR1A_ORTHO_20120502_IPU_20120430_6347-003_V1/IMG_R1C1.JP2 ) set(GenericTestPHR_DATA_TYPES ${GenericTestPHR_DATA_TYPES} SIMUL_PHR_JP2_ORTHO_DIMAPv2_PMS-N_lossy_12bits SIMUL_PHR_TIFF_ORTHO_DIMAPv2_MS_lossless_8bits SIMUL_PHR_TIFF_PRIMARY_DIMAPv2_MS_lossy_12bits PHR_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits PHR_JP2_DIMAPv1_PRIMARY_PMS_lossless_12bits PHR_JP2_DIMAPv1_ORTHO_PMS_lossless_12bits ) set(GenericTestSPOT6_DATA_INPUTS ${GenericTestSPOT6_DATA_INPUTS} ${OTB_DATA_LARGEINPUT_ROOT}/SPOT6/SPOT6_Ortho_Bundle_12_bits/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201306031242000_ORT_816005101_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/SPOT6/SPOT6_Ortho_Pan-sharpened_12_bits/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_PMS_001_A/IMG_SPOT6_PMS_201305251604372_ORT_816009101_R1C1.JP2 ${OTB_DATA_LARGEINPUT_ROOT}/SPOT6/SPOT6_Primary_Bundle_12_bits/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201211100138085_SEN_816007101_R1C1.JP2 ) set(GenericTestSPOT6_DATA_TYPES ${GenericTestSPOT6_DATA_TYPES} SPOT6_Ortho_Bundle_12_bits SPOT6_Ortho_Pan-sharpened_12_bits SPOT6_Primary_Bundle_12_bits ) endif() ########################## copied from OTB/CMakeLists.txt ########################## #Generate cmake variables with a set of largeinput data used in tests set(BASELINE ${OTB_DATA_ROOT}/Baseline/OTB/Images) set(BASELINE_FILES ${OTB_DATA_ROOT}/Baseline/OTB/Files) set(INPUTDATA ${OTB_DATA_ROOT}/Input) set(TEMP ${CMAKE_BINARY_DIR}/Testing/Temporary) set(EXAMPLEDATA ${OTB_DATA_ROOT}/Examples) set(OTBAPP_BASELINE ${OTB_DATA_ROOT}/Baseline/OTB-Applications/Images) set(OTBAPP_BASELINE_FILES ${OTB_DATA_ROOT}/Baseline/OTB-Applications/Files) set(NOTOL 0.0) set(EPSILON_1 0.1) set(EPSILON_2 0.01) set(EPSILON_3 0.001) set(EPSILON_4 0.0001) set(EPSILON_5 0.00001) set(EPSILON_6 0.000001) set(EPSILON_7 0.0000001) set(EPSILON_8 0.00000001) set(EPSILON_9 0.000000001) set(EPSILON_10 0.0000000001) set(EPSILON_11 0.00000000001) set(EPSILON_12 0.000000000001) set(EPSILON_13 0.0000000000001) set(EPSILON_14 0.00000000000001) set(EPSILON_15 0.000000000000001) #----------------------------------------------------------------------------- # OTB wrapper for add_test that automatically sets the test's LABELS property # to the value of its containing module. # function(otb_add_test) set(largeinput_regex "LARGEINPUT{([^;{}\r\n]*)}") set(_depends_on_largeinput OFF) foreach(arg IN LISTS ARGN) if("x${arg}" MATCHES "${largeinput_regex}") string(REGEX REPLACE "${largeinput_regex}" "\\1" largeinput_relative_path "${arg}") set(_fullpath "${OTB_DATA_LARGEINPUT_ROOT}/${largeinput_relative_path}") list(APPEND _out_arg ${_fullpath}) set(_depends_on_largeinput ON) else() list(APPEND _out_arg ${arg}) endif() endforeach() if (_depends_on_largeinput AND NOT OTB_DATA_USE_LARGEINPUT) return() endif() add_test(${_out_arg}) if("NAME" STREQUAL "${ARGV0}") set(_iat_testname ${ARGV1}) else() set(_iat_testname ${ARGV0}) endif() if(otb-module) set(_label ${otb-module}) else() set(_label ${main_project_name}) endif() set_property(TEST ${_iat_testname} PROPERTY LABELS ${_label}) endfunction() ########################## end copied from OTB/CMakeLists.txt ########################## else() #Examples that require large input cannot be enabled when building as standalone include(${CMAKE_CURRENT_SOURCE_DIR}/../CMake/OTBManageLargeInputPaths.cmake) endif() find_package(OTB REQUIRED) include(${OTB_USE_FILE}) message(STATUS "Found OTB: ${OTB_USE_FILE}") set(OTB_TEST_DRIVER otbTestDriver) if(OTBApplicationEngine_LOADED) add_subdirectory(Application) endif() add_subdirectory(BasicFilters) add_subdirectory(ChangeDetection) add_subdirectory(Classification) add_subdirectory(DataRepresentation) add_subdirectory(DimensionReduction) add_subdirectory(DisparityMap) add_subdirectory(FeatureExtraction) add_subdirectory(Filtering) add_subdirectory(Fusion) add_subdirectory(Hyperspectral) add_subdirectory(Installation) add_subdirectory(IO) add_subdirectory(Iterators) add_subdirectory(Learning) add_subdirectory(Markov) add_subdirectory(MultiScale) add_subdirectory(OBIA) add_subdirectory(Patented) add_subdirectory(Projections) add_subdirectory(Radiometry) add_subdirectory(Registration) add_subdirectory(Segmentation) add_subdirectory(Simulation) add_subdirectory(Tutorials) OTB-release-5.8/Examples/ChangeDetection/000077500000000000000000000000001301006202600202205ustar00rootroot00000000000000OTB-release-5.8/Examples/ChangeDetection/CMakeLists.txt000066400000000000000000000024641301006202600227660ustar00rootroot00000000000000project(ChangeDetectionExamples) add_executable(ChangeDetectionFrameworkExample ChangeDetectionFrameworkExample.cxx) target_link_libraries(ChangeDetectionFrameworkExample ${OTB_LIBRARIES}) add_executable(CorrelChDet CorrelChDet.cxx) target_link_libraries(CorrelChDet ${OTB_LIBRARIES}) add_executable(DiffChDet DiffChDet.cxx) target_link_libraries(DiffChDet ${OTB_LIBRARIES}) add_executable(JHMIChDet JHMIChDet.cxx) target_link_libraries(JHMIChDet ${OTB_LIBRARIES}) add_executable(KullbackLeiblerDistanceChDet KullbackLeiblerDistanceChDet.cxx) target_link_libraries(KullbackLeiblerDistanceChDet ${OTB_LIBRARIES}) add_executable(KullbackLeiblerProfileChDet KullbackLeiblerProfileChDet.cxx) target_link_libraries(KullbackLeiblerProfileChDet ${OTB_LIBRARIES}) add_executable(KullbackLeiblerSupervizedDistanceChDet KullbackLeiblerSupervizedDistanceChDet.cxx) target_link_libraries(KullbackLeiblerSupervizedDistanceChDet ${OTB_LIBRARIES}) add_executable(LHMIChDet LHMIChDet.cxx) target_link_libraries(LHMIChDet ${OTB_LIBRARIES}) add_executable(MultivariateAlterationDetector MultivariateAlterationDetector.cxx) target_link_libraries(MultivariateAlterationDetector ${OTB_LIBRARIES}) add_executable(RatioChDet RatioChDet.cxx) target_link_libraries(RatioChDet ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/ChangeDetection/ChangeDetectionFrameworkExample.cxx000066400000000000000000000214751301006202600271730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the Change Detector framework implemented // in OTB. This framework uses the generic programming approach. All // change detection filters are // \doxygen{otb}{BinaryFunctorNeighborhoodImageFilter}s, that is, they // are filters taking two images as input and providing one image as // output. The change detection computation itself is performed on a // the neighborhood of each pixel of the input images. // // The first step required to build a change detection filter is to // include the header of the parent class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbBinaryFunctorNeighborhoodImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" #include "otbCommandProgressUpdate.h" // Software Guide : BeginLatex // // The change // detection operation itself is one of the templates of the change // detection filters and takes the form of a function, that is, // something accepting the syntax \code{foo()}. This can be // implemented using classical C/C++ functions, but it is preferable // to implement it using C++ functors. These are classical C++ classes // which overload the \code{()} operator. This allows using them with // the same syntax as C/C++ functions. // // Since change detectors operate on neighborhoods, the functor // call will take 2 arguments which are // \doxygen{itk}{ConstNeighborhoodIterator}s. // // The change detector functor is templated over the types of the // input iterators and the output result type. The core of the change // detection is implemented in the \code{operator()} section. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet template class MyChangeDetector { public: // The constructor and destructor. MyChangeDetector() {} ~MyChangeDetector() {} // Change detection operation inline TOutput operator ()(const TInput1& itA, const TInput2& itB) { TOutput result = 0.0; for (unsigned long pos = 0; pos < itA.Size(); ++pos) { result += static_cast(itA.GetPixel(pos) - itB.GetPixel(pos)); } return static_cast(result / itA.Size()); } }; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The interest of using functors is that complex operations can be // performed using internal \code{protected} class methods and that // class variables can be used to store information so different pixel // locations can access to results of previous computations. // // The next step is the definition of the change detector filter. As // stated above, this filter will inherit from // \doxygen{otb}{BinaryFunctorNeighborhoodImageFilter} which is // templated over the 2 input image types, the output image type and // the functor used to perform the change detection operation. // // Inside the class only a few \code{typedef}s and the constructors // and destructors have to be declared. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet template class ITK_EXPORT MyChangeDetectorImageFilter : public otb::BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, MyChangeDetector< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef MyChangeDetectorImageFilter Self; typedef typename otb::BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, MyChangeDetector< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); protected: MyChangeDetectorImageFilter() {} ~MyChangeDetectorImageFilter() ITK_OVERRIDE {} private: MyChangeDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Pay attention to the fact that no \code{.txx} file is needed, since // filtering operation is implemented in the // \doxygen{otb}{BinaryFunctorNeighborhoodImageFilter} class. So all // the algorithmics part is inside the functor. // // We can now write a program using the change detector. // // SoftwareGuide : EndLatex int main(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Software Guide : BeginLatex // // As usual, we start by defining the image types. The internal // computations will be performed with floating point precision, // while the output image will be stored using one byte per pixel. // // SoftwareGuide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the readers, the writer, but also the // \doxygen{itk}{RescaleIntensityImageFilter} which will be used to // rescale the result before writing it to a file. // // SoftwareGuide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The next step is declaring the filter for the change detection. // // SoftwareGuide : EndLatex // Software Guide : BeginCodeSnippet typedef MyChangeDetectorImageFilter FilterType; // Software Guide : EndCodeSnippet ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; // Software Guide : BeginLatex // // We connect the pipeline. // // SoftwareGuide : EndLatex // Software Guide : BeginCodeSnippet reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // And that is all. // // SoftwareGuide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/CorrelChDet.cxx000066400000000000000000000165221301006202600231100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkShiftScaleImageFilter.h" #include "otbCommandProgressUpdate.h" // Software Guide : BeginCommandLineArgs // INPUTS: {ERSBefore.png}, {ERSAfter.png} // OUTPUTS: {CorrChDet.tif} // 15 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the class // \doxygen{otb}{CorrelationChangeDetector} for detecting changes // between pairs of images. This filter computes the correlation coefficient in // the neighborhood of each pixel of the pair of images to be compared. This // example will use the images shown in // figure ~\ref{fig:CORRCHDETINIM}. These correspond to two ERS acquisitions before and during a flood. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{ERSBefore.eps} // \includegraphics[width=0.35\textwidth]{ERSAfter.eps} // \itkcaption[ERS Images for Change Detection]{Images used for the // change detection. Left: Before the flood. Right: during the flood.} // \label{fig:CORRCHDETINIM} // \end{figure} // // We start by including the corresponding header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbCorrelationChangeDetector.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 " << "outputImageFile radius" << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Software Guide : BeginLatex // We start by declaring the types for the two input images, the // change image and the image to be stored in a file for visualization. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now declare the types for the readers. Since the images // can be vey large, we will force the pipeline to use // streaming. For this purpose, the file writer will be // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The change detector will give a response which is normalized // between 0 and 1. Before // saving the image to a file in, for instance, PNG format, we will // rescale the results of the change detection in order to use all // the output pixel type range of values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ShiftScaleImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{CorrelationChangeDetector} is templated over // the types of the two input images and the type of the generated change // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::CorrelationChangeDetector< InputImageType1, InputImageType2, ChangeImageType> FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different elements of the pipeline can now be instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); // Software Guide : EndCodeSnippet const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[3]; // Software Guide : BeginLatex // // We set the parameters of the different elements of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); float scale = itk::NumericTraits::max(); rescaler->SetScale(scale); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The only parameter for this change detector is the radius of // the window used for computing the correlation coefficient. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetRadius(atoi(argv[4])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We build the pipeline by plugging all the elements together. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the processing time of large images can be long, it is // interesting to monitor the evolution of the computation. In // order to do so, the change detectors can use the // command/observer design pattern. This is easily done by // attaching an observer to the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); // Software Guide : EndCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // Figure \ref{fig:RESCORRCHDET} shows the result of the change // detection by local correlation. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{CorrChDet.eps} // \itkcaption[Correlation Change Detection Results]{Result of the // correlation change detector} // \label{fig:RESCORRCHDET} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/DiffChDet.cxx000066400000000000000000000172631301006202600225350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {SpotBefore.png}, {SpotAfter.png} // OUTPUTS: {DiffChDet.tif} // 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the class // \doxygen{otb}{MeanDifferenceImageFilter} for detecting changes // between pairs of images. This filter computes the mean intensity in // the neighborhood of each pixel of the pair of images to be compared // and uses the difference of means as a change indicator. This // example will use the images shown in // figure ~\ref{fig:DIFFCHDETINIM}. These correspond to the near // infrared band of two Spot acquisitions before and during a flood. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{SpotBefore.eps} // \includegraphics[width=0.35\textwidth]{SpotAfter.eps} // \itkcaption[Spot Images for Change Detection]{Images used for the // change detection. Left: Before the flood. Right: during the flood.} // \label{fig:DIFFCHDETINIM} // \end{figure} // // We start by including the corresponding header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMeanDifferenceImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkAbsImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbCommandProgressUpdate.h" int main(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 outputImageFile radius" << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Software Guide : BeginLatex // We start by declaring the types for the two input images, the // change image and the image to be stored in a file for visualization. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now declare the types for the readers and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The change detector will give positive and negative values // depending on the sign of the difference. We are usually // interested only in the asbolute value of the difference. For // this purpose, we will use the \doxygen{itk}{AbsImageFilter}. Also, before // saving the image to a file in, for instance, PNG format, we will // rescale the results of the change detection in order to use all // the output pixel type range of values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::AbsImageFilter AbsType; typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{MeanDifferenceImageFilter} is templated over // the types of the two input images and the type of the generated change // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MeanDifferenceImageFilter< InputImageType1, InputImageType2, ChangeImageType> FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different elements of the pipeline can now be instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); AbsType::Pointer absFilter = AbsType::New(); RescalerType::Pointer rescaler = RescalerType::New(); // Software Guide : EndCodeSnippet const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[3]; // Software Guide : BeginLatex // // We set the parameters of the different elements of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The only parameter for this change detector is the radius of // the window used for computing the mean of the intensities. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetRadius(atoi(argv[4])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We build the pipeline by plugging all the elements together. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); absFilter->SetInput(filter->GetOutput()); rescaler->SetInput(absFilter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the processing time of large images can be long, it is // interesting to monitor the evolution of the computation. In // order to do so, the change detectors can use the // command/observer design pattern. This is easily done by // attaching an observer to the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); // Software Guide : EndCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // Figure \ref{fig:RESDIFFCHDET} shows the result of the change // detection by difference of local means. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{DiffChDet.eps} // \itkcaption[Difference Change Detection Results]{Result of the mean // difference change detector} // \label{fig:RESDIFFCHDET} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/JHMIChDet.cxx000066400000000000000000000064701301006202600224120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkShiftScaleImageFilter.h" #include "otbJoinHistogramMIImageFilter.h" #include "otbCommandProgressUpdate.h" int main(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Declare the types of the images typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::ShiftScaleImageFilter RescalerType; // Declare the type for the filter typedef otb::JoinHistogramMIImageFilter< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetShift(itk::NumericTraits::min()); float scale = itk::NumericTraits::max() / 100.0; /*float(itk::NumericTraits< OutputPixelType >::max()+ itk::NumericTraits< InternalPixelType >::min()); */ rescaler->SetScale(scale); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/KullbackLeiblerDistanceChDet.cxx000066400000000000000000000171751301006202600263710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {GomaAvant.png}, {GomaApres.png} // OUTPUTS: {KLdistanceChDet.png} // 35 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the class // \doxygen{otb}{KullbackLeiblerDistanceImageFilter} for detecting changes // between pairs of images. This filter computes the Kullback-Leibler // distance between probability density functions (pdfs). // In fact, the Kullback-Leibler distance is itself approximated through // a cumulant-based expansion, since the pdfs are approximated through an // Edgeworth series. // The Kullback-Leibler distance is evaluated by: // \begin{multline}\label{eqKLapprox1D} // K_{\text{Edgeworth}}(X_1 | X_2) = \frac{1}{12} \frac{\kappa_{X_1; 3}^2}{\kappa_{X_1; 2}^2} // + \frac{1}{2} \left( \log \frac{\kappa_{X_2; 2}}{\kappa_{X_1; 2}} // -1+\frac{1}{\kappa_{X_2; 2}} // \left( \kappa_{X_1; 1} - \kappa_{X_2; 1} + \kappa_{X_1; 2}^{1/2} \right)^2 // \right) // - \left( \kappa_{X_2; 3} \frac{a_1}{6} + \kappa_{X_2; 4} \frac{a_2}{24} // + \kappa_{X_2; 3}^2 \frac{a_3}{72} \right) // - \frac{1}{2} \frac{ \kappa_{X_2; 3}^2}{36} // \left( // c_6 - 6 \frac{c_4}{\kappa_{X_1; 2}} + 9 \frac{c_2}{\kappa_{X_2; 2}^2} // \right) // - 10 \frac{\kappa_{X_1; 3} \kappa_{X_2; 3} // \left( \kappa_{X_1; 1} - \kappa_{X_2; 1} \right) // \left( \kappa_{X_1; 2} - \kappa_{X_2; 2} \right)}{\kappa_{X_2; 2}^6} \qquad // \end{multline} // where // \begin{align*} // a_1 &= c_3 - 3 \frac{\alpha}{\kappa_{X_2; 2}} // a_2 &= c_4 - 6 \frac{c_2}{\kappa_{X_2; 2}} + \frac{3}{\kappa_{X_2; 2}^2} // a_3 &= c_6 - 15\frac{c_4}{\kappa_{X_2; 2}} + 45\frac{c_2}{\kappa_{X_2; 2}^2} - // \frac{15}{\kappa_{X_2; 2}^3} // c_2 &= \alpha^2 + \beta^2 // c_3 &= \alpha^3 + 3 \alpha \beta^2 // c_4 &= \alpha^4 + 6 \alpha^2 \beta^2 + 3 \beta^4 // c_6 &= \alpha^6 + 15\alpha^4 \beta^2 + 45 \alpha^2 \beta^4 + 15 \beta^6 // \alpha &= \frac{\kappa_{X_1; 1} - \kappa_{X_2; 1}}{\kappa_{X_2; 2}} // \beta &= \frac{ \kappa_{X_1; 2}^{1/2} }{\kappa_{X_2; 2}}. // \end{align*} // $\kappa_{X_i; 1}$, $\kappa_{X_i; 2}$, $\kappa_{X_i; 3}$ and $\kappa_{X_i; 4}$ // are the cumulants up to order 4 of the random variable $X_i$ ($i=1, 2$). // This example will use the images shown in // figure~\ref{fig:RATCHDETINIM}. These correspond to 2 Radarsat fine // mode acquisitions before and after a lava flow resulting from a // volcanic eruption. // // The program itself is very similar to the ratio of means detector, // implemented in \doxygen{otb}{MeanRatioImageFilter}, // in section~\ref{sec:RatioOfMeans}. Nevertheless // the corresponding header file has to be used instead. // // Software Guide : EndLatex #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginCodeSnippet #include "otbKullbackLeiblerDistanceImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { try { if (argc != 5) { std::cerr << "Change detection through a Kullback-Leibler measure (which is a distance between local distributions)\n"; std::cerr << "Kullback-Leibler measure is optimized by a Edgeworth series expansion\n"; std::cerr << argv[0] << " imgAv imgAp imgResu winSize\n"; return 1; } char * fileName1 = argv[1]; char * fileName2 = argv[2]; char * fileNameOut = argv[3]; int winSize = atoi(argv[4]); const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned char OutputPixelType; typedef otb::Image ImageType; typedef otb::Image OutputImageType; // Software Guide : BeginLatex // // The \doxygen{otb}{KullbackLeiblerDistanceImageFilter} is templated over // the types of the two input images and the type of the generated change // image, in a similar way as the \doxygen{otb}{MeanRatioImageFilter}. It is // the only line to be changed from the ratio of means change detection // example to perform a change detection through a distance between // distributions... // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::KullbackLeiblerDistanceImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different elements of the pipeline can now be instantiated. Follow the // ratio of means change detector example. // // Software Guide : EndLatex typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(fileName1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(fileName2); // Software Guide : BeginLatex // // The only parameter for this change detector is the radius of // the window used for computing the cumulants. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::Pointer filter = FilterType::New(); filter->SetRadius((winSize - 1) / 2); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The pipeline is built by plugging all the elements together. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); // Software Guide : EndCodeSnippet typedef itk::RescaleIntensityImageFilter RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetInput(filter->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(fileNameOut); writer->SetInput(rescaler->GetOutput()); writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "Exception itk::ExceptionObject thrown !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } catch (...) { std::cout << "Unknown exception thrown !" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // Figure \ref{fig:RESKLDCHDET} shows the result of the change // detection by computing the Kullback-Leibler distance between // local pdf through an Edgeworth approximation. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{KLdistanceChDet.eps} // \itkcaption[Kullback-Leibler Change Detection Results]{Result of the // Kullback-Leibler change detector} // \label{fig:RESKLDCHDET} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/KullbackLeiblerProfileChDet.cxx000066400000000000000000000151331301006202600262270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {GomaAvant.png}, {GomaApres.png} // OUTPUTS: {KLProfileChDet.png} // 5 51 1 12 24 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the class // \doxygen{otb}{KullbackLeiblerProfileImageFilter} for detecting changes // between pairs of images, according to a range of window size. // This example is very similar, in its principle, to all of the change // detection examples, especially the distance between distributions one // (section~\ref{sec:KullbackLeiblerDistance}) which uses a fixed window size. // // The main differences are: // \begin{enumerate} // \item a set of window range instead of a fixed size of window; // \item an output of type \doxygen{otb}{VectorImage}. // \end{enumerate} // Then, the program begins with the \doxygen{otb}{VectorImage} and the // \doxygen{otb}{KullbackLeiblerProfileImageFilter} header files in addition // to those already details in the \doxygen{otb}{MeanRatioImageFilter} example. // // Software Guide : EndLatex #include "otbImage.h" #include "otbMultiChannelExtractROI.h" #include "otbVectorRescaleIntensityImageFilter.h" // Software Guide : BeginCodeSnippet #include "otbKullbackLeiblerProfileImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { try { if (argc != 9) { std::cerr << "Change detection based on Kullback-Leibler distance betweenlocal pdf through an Edgeworth approximation\n"; std::cerr << argv[0] << " imgAv imgAp imgResu winSizeMin winSizeMax outRedIndex outGreenIndex outBlueIndex\n"; return 1; } char * fileName1 = argv[1]; char * fileName2 = argv[2]; char * fileNameOut = argv[3]; int winSizeMin = atoi(argv[4]); int winSizeMax = atoi(argv[5]); unsigned int ri = atoi(argv[6]); unsigned int gi = atoi(argv[7]); unsigned int bi = atoi(argv[8]); const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned char OutPixelType; // Software Guide : BeginLatex // // The \doxygen{otb}{KullbackLeiblerProfileImageFilter} is templated over // the types of the two input images and the type of the generated change // image (which is now of multi-components), in a similar way as the // \doxygen{otb}{KullbackLeiblerDistanceImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::KullbackLeiblerProfileImageFilter FilterType; // Software Guide : EndCodeSnippet typedef otb::VectorImage OutVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelExtractROI ChannelSelecterType; typedef otb::VectorRescaleIntensityImageFilter RescalerType; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(fileName1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(fileName2); // Software Guide : BeginLatex // // The different elements of the pipeline can now be instantiated in the // same way as the ratio of means change detector example. // // Two parameters are now required to give the minimum and the maximum size // of the analysis window. The program will begin by performing change // detection through the smaller window size and then applying moments update // of eq.~\eqref{eqMomentN} by incrementing the radius of the analysis window // (i.e. add a ring of width 1 pixel around the current neightborhood shape). // The process is applied until the larger window size is reached. // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet FilterType::Pointer filter = FilterType::New(); filter->SetRadius((winSizeMin - 1) / 2, (winSizeMax - 1) / 2); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); // Software Guide : EndCodeSnippet ChannelSelecterType::Pointer channelSelecter = ChannelSelecterType::New(); channelSelecter->SetInput(filter->GetOutput()); channelSelecter->SetChannel(ri); channelSelecter->SetChannel(gi); channelSelecter->SetChannel(bi); RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetInput(channelSelecter->GetOutput()); OutVectorImageType::PixelType min, max; min.SetSize(3); max.SetSize(3); min.Fill(0); max.Fill(255); rescaler->SetOutputMinimum(min); rescaler->SetOutputMaximum(max); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(fileNameOut); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : BeginLatex // // Figure \ref{fig:RESKLPCHDET} shows the result of the change // detection by computing the Kullback-Leibler distance between // local pdf through an Edgeworth approximation. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{KLProfileChDet.eps} // \itkcaption[Kullback-Leibler profile Change Detection Results]{Result of the // Kullback-Leibler profile change detector, colored composition including the first, 12th and 24th // channel of the generated output.} // \label{fig:RESKLPCHDET} // \end{figure} // // Software Guide : EndLatex } catch (itk::ExceptionObject& err) { std::cout << "Exception itk::ExceptionObject thrown !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } catch (...) { std::cout << "Unknown exception thrown !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/KullbackLeiblerSupervizedDistanceChDet.cxx000066400000000000000000000115051301006202600304410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbKullbackLeiblerSupervizedDistanceImageFilter.h" int main(int argc, char * argv[]) { try { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption("--InputImage1", "Give Before image", "-1", 1, true); parser->AddOption("--InputImage2", "Give After image", "-2", 1, true); parser->AddOption("--Roi", "Give ROI image", "-r", 1, true); parser->AddOption("--winSize", "Sliding window size (def. 35)", "-w", 1, false); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); } catch (itk::ExceptionObject& err) { std::string descriptionException = err.GetDescription(); if (descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos) return EXIT_SUCCESS; if (descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos) return EXIT_SUCCESS; return EXIT_FAILURE; } /* * Types declaration */ const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned char TrainingPixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::Image TrainingImageType; typedef otb::ImageFileReader TrainingReaderType; /* * Extract command line parameters */ std::string inputImageFileName1 = parseResult->GetParameterString( "--InputImage1"); std::string inputImageFileName2 = parseResult->GetParameterString( "--InputImage2"); std::string inputTrainingImageFileName = parseResult->GetParameterString( "--Roi"); std::string outputImageFileName = parseResult->GetOutputImage(); int winSize = 35; if (parseResult->IsOptionPresent("--winSize")) winSize = parseResult->GetParameterInt("--winSize"); /* * JustDoIt */ ImageType::Pointer img1 = ImageType::New(); ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(inputImageFileName1); //reader1->Update(); img1 = reader1->GetOutput(); ImageType::Pointer img2 = ImageType::New(); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(inputImageFileName2); //reader2->Update(); img2 = reader2->GetOutput(); TrainingImageType::Pointer imgRoi = TrainingImageType::New(); TrainingReaderType::Pointer readerRoi = TrainingReaderType::New(); readerRoi->SetFileName(inputTrainingImageFileName); //readerRoi->Update(); imgRoi = readerRoi->GetOutput(); typedef otb::KullbackLeiblerSupervizedDistanceImageFilter< ImageType, ImageType, TrainingImageType, ImageType> FilterType; FilterType::Pointer changeDetector = FilterType::New(); changeDetector->SetRadius((winSize - 1) / 2); changeDetector->SetInput1(img1); changeDetector->SetInput2(img2); // Once img1 and img2 are connected, it is time to connect imgRoi // to perform the parameters estimation of the non-changed area. changeDetector->SetTrainingArea(imgRoi); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); changeDetector->AddObserver(itk::ProgressEvent(), observer); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageFileName); writer->SetInput(changeDetector->GetOutput()); writer->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/LHMIChDet.cxx000066400000000000000000000061541301006202600224130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkShiftScaleImageFilter.h" #include "otbLHMIChangeDetector.h" #include "otbCommandProgressUpdate.h" int main(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Declare the types of the images typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::ShiftScaleImageFilter RescalerType; // Declare the type for the filter typedef otb::LHMIChangeDetector< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); float scale = itk::NumericTraits::max(); rescaler->SetScale(scale); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/MultivariateAlterationDetector.cxx000066400000000000000000000206471301006202600271400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {Spot5-Gloucester-before.tif}, {Spot5-Gloucester-after.tif} // OUTPUTS: {MADOutput.tif}, {mad-input1.png}, {mad-input2.png}, {mad-output.png} // // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the class // \doxygen{otb}{MultivariateAlterationChangeDetectorImageFilter}, // which implements the Multivariate Alteration Change Detector // algorithm \cite{nielsen2007regularized}. This algorihtm allows // performing change detection from a pair multi-band images, including // images with different number of bands or modalities. Its output is // a a multi-band image of change maps, each one being unccorrelated // with the remaining. The number of bands of the output image is the // minimum number of bands between the two input images. // // The algorithm works as follows. It tries to find two linear // combinations of bands (one for each input images) which maximize // correlation, and subtract these two linear combinitation, leading // to the first change map. Then, it looks for a second set of linear // combinations which are orthogonal to the first ones, a which // maximize correlation, and use it as the second change map. This // process is iterated until no more orthogonal linear combinations // can be found. // // This algorithms has numerous advantages, such as radiometry scaling // and shifting invariance and absence of parameters, but it can not // be used on a pair of single band images (in this case the output is // simply the difference between the two images). // // We start by including the corresponding header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMultivariateAlterationDetectorImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc < 6) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 outIn1Pretty outIn2Pretty outPretty" << "outputImageFile" << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Software Guide : BeginLatex // We then define the types for the input images and for the // change image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short InputPixelType; typedef float OutputPixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now declare the types for the reader. Since the images // can be vey large, we will force the pipeline to use // streaming. For this purpose, the file writer will be // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // This is for rendering in software guide typedef otb::PrintableImageFilter InputPrintFilterType; typedef otb::PrintableImageFilter OutputPrintFilterType; typedef InputPrintFilterType::OutputImageType VisuImageType; typedef otb::ImageFileWriter VisuWriterType; // The \doxygen{otb}{MultivariateAlterationDetectorImageFilter} is templated over // the type of the input images and the type of the generated change // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MultivariateAlterationDetectorImageFilter< InputImageType,OutputImageType> MADFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different elements of the pipeline can now be instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader1 = ReaderType::New(); ReaderType::Pointer reader2 = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); MADFilterType::Pointer madFilter = MADFilterType::New(); // Software Guide : EndCodeSnippet const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[3]; const char * in1pretty = argv[4]; const char * in2pretty = argv[5]; const char * outpretty = argv[6]; // Software Guide : BeginLatex // // We set the parameters of the different elements of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We build the pipeline by plugging all the elements together. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet madFilter->SetInput1(reader1->GetOutput()); madFilter->SetInput2(reader2->GetOutput()); writer->SetInput(madFilter->GetOutput()); // Software Guide : EndCodeSnippet try { // Software Guide : BeginLatex // // And then we can trigger the pipeline update, as usual. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Here we generate the figures InputPrintFilterType::Pointer input1PrintFilter = InputPrintFilterType::New(); InputPrintFilterType::Pointer input2PrintFilter = InputPrintFilterType::New(); OutputPrintFilterType::Pointer outputPrintFilter = OutputPrintFilterType::New(); VisuWriterType::Pointer input1VisuWriter = VisuWriterType::New(); VisuWriterType::Pointer input2VisuWriter = VisuWriterType::New(); VisuWriterType::Pointer outputVisuWriter = VisuWriterType::New(); input1PrintFilter->SetInput(reader1->GetOutput()); input1PrintFilter->SetChannel(3); input1PrintFilter->SetChannel(2); input1PrintFilter->SetChannel(1); input2PrintFilter->SetInput(reader2->GetOutput()); input2PrintFilter->SetChannel(3); input2PrintFilter->SetChannel(2); input2PrintFilter->SetChannel(1); outputPrintFilter->SetInput(madFilter->GetOutput()); outputPrintFilter->SetChannel(3); outputPrintFilter->SetChannel(2); outputPrintFilter->SetChannel(1); input1VisuWriter->SetInput(input1PrintFilter->GetOutput()); input2VisuWriter->SetInput(input2PrintFilter->GetOutput()); outputVisuWriter->SetInput(outputPrintFilter->GetOutput()); input1VisuWriter->SetFileName(in1pretty); input2VisuWriter->SetFileName(in2pretty); outputVisuWriter->SetFileName(outpretty); input1VisuWriter->Update(); input2VisuWriter->Update(); outputVisuWriter->Update(); // Software Guide : BeginLatex // Figure \ref{fig:MADCHDET} shows the // results of Multivariate Alteration Detector applied to a pair of // SPOT5 images before and after a flooding event. // \begin{figure} // \center \includegraphics[width=0.32\textwidth]{mad-input1.eps} // \includegraphics[width=0.32\textwidth]{mad-input2.eps} // \includegraphics[width=0.32\textwidth]{mad-output.eps} // \itkcaption[Multivariate Alteration Detection // Results]{Result of the Multivariate Alteration Detector results on // SPOT5 data before and after flooding.} \label{fig:MADCHDET} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/RatioChDet.cxx000066400000000000000000000162421301006202600227370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {GomaAvant.png}, {GomaApres.png} // OUTPUTS: {RatioChDet.tif} // 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the class // \doxygen{otb}{MeanRatioImageFilter} for detecting changes // between pairs of images. This filter computes the mean intensity in // the neighborhood of each pixel of the pair of images to be compared // and uses the ratio of means as a change indicator. This change // indicator is then normalized between 0 and 1 by using the classical // \begin{equation} // r = 1 - min\{\frac{\mu_A}{\mu_B},\frac{\mu_B}{\mu_A} \}, // \end{equation} // where $\mu_A$ and $\mu_B$ are the local means. This // example will use the images shown in // figure ~\ref{fig:RATCHDETINIM}. These correspond to 2 Radarsat fine // mode acquisitions before and after a lava flow resulting from a // volcanic eruption. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{GomaAvant.eps} // \includegraphics[width=0.35\textwidth]{GomaApres.eps} // \itkcaption[Radarsat Images for Change Detection]{Images used for the // change detection. Left: Before the eruption. Right: after the eruption.} // \label{fig:RATCHDETINIM} // \end{figure} // // We start by including the corresponding header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMeanRatioImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkShiftScaleImageFilter.h" #include "otbCommandProgressUpdate.h" int main(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 outputImageFile radius" << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Software Guide : BeginLatex // We start by declaring the types for the two input images, the // change image and the image to be stored in a file for visualization. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now declare the types for the readers. Since the images // can be vey large, we will force the pipeline to use // streaming. For this purpose, the file writer will be // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The change detector will give a normalized result between 0 and // 1. In order to store the result in PNG format we will // rescale the results of the change detection in order to use all // the output pixel type range of values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ShiftScaleImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{MeanRatioImageFilter} is templated over // the types of the two input images and the type of the generated change // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MeanRatioImageFilter< InputImageType1, InputImageType2, ChangeImageType> FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different elements of the pipeline can now be instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); // Software Guide : EndCodeSnippet const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[3]; // Software Guide : BeginLatex // // We set the parameters of the different elements of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); float scale = itk::NumericTraits::max(); rescaler->SetScale(scale); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The only parameter for this change detector is the radius of // the window used for computing the mean of the intensities. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetRadius(atoi(argv[4])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We build the pipeline by plugging all the elements together. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // Figure \ref{fig:RESRATCHDET} shows the result of the change // detection by ratio of local means. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{RatioChDet.eps} // \itkcaption[Ratio Change Detection Results]{Result of the // ratio of means change detector} // \label{fig:RESRATCHDET} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/ChangeDetection/test/000077500000000000000000000000001301006202600211775ustar00rootroot00000000000000OTB-release-5.8/Examples/ChangeDetection/test/CMakeLists.txt000066400000000000000000000036571301006202600237520ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/ChangeDetection) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- CorrelChDetTest---------- otb_add_test(NAME cdTeCorrelChDetTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/CorrChDet.tif ${TEMP}/CorrChDet.tif Execute $ ${INPUTDATA}/ERSBefore.png ${INPUTDATA}/ERSAfter.png ${TEMP}/CorrChDet.tif 15 ) # ------- DiffChDetTest---------- otb_add_test(NAME cdTeDiffChDetTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/DiffChDet.tif ${TEMP}/DiffChDet.tif Execute $ ${INPUTDATA}/SpotBefore.png ${INPUTDATA}/SpotAfter.png ${TEMP}/DiffChDet.tif 3 ) # ------- RatioChDetTest---------- otb_add_test(NAME cdTeRatioChDetTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/RatioChDet.tif ${TEMP}/RatioChDet.tif Execute $ ${INPUTDATA}/GomaAvant.png ${INPUTDATA}/GomaApres.png ${TEMP}/RatioChDet.tif 3 ) # ------- KullbackLeiblerDistanceChDetTest---------- otb_add_test(NAME cdTeKullbackLeiblerDistanceChDetTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/KullbackLeiblerDistanceChDetTest.png ${TEMP}/KullbackLeiblerDistanceChDetTest.png Execute $ ${INPUTDATA}/GomaAvant.png ${INPUTDATA}/GomaApres.png ${TEMP}/KullbackLeiblerDistanceChDetTest.png 35 ) # ------- KullbackLeiblerProfileChDetTest---------- otb_add_test(NAME cdTeKullbackLeiblerProfileChDetTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/KullbackLeiblerProfileChDetTest.png ${TEMP}/KullbackLeiblerProfileChDetTest.png Execute $ ${INPUTDATA}/GomaAvant.png ${INPUTDATA}/GomaApres.png ${TEMP}/KullbackLeiblerProfileChDetTest.png 5 51 1 12 24 ) OTB-release-5.8/Examples/Classification/000077500000000000000000000000001301006202600201275ustar00rootroot00000000000000OTB-release-5.8/Examples/Classification/BayesianPluginClassifier.cxx000066400000000000000000000330411301006202600255730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // \index{Statistics!Bayesian plugin classifier} // \index{itk::Statistics::SampleClassifierFilter} // \index{itk::Statistics::GaussianDensityFunction} // \index{itk::Statistics::NormalVariateGenerator} // // In this example, we present a system that places measurement vectors into // two Gaussian classes. The Figure~\ref{fig:BayesianPluginClassifier} shows // all the components of the classifier system and the data flow. This system // differs with the previous k-means clustering algorithms in several // ways. The biggest difference is that this classifier uses the // \subdoxygen{itk}{Statistics}{itkGaussianMembershipFunction} as membership functions // instead of the \subdoxygen{itk}{Statistics}{EuclideanDistanceMetric}. Since the // membership function is different, the membership function requires a // different set of parameters, mean vectors and covariance matrices. We // choose the \subdoxygen{itk}{Statistics}{MeanSampleFilter} (sample mean) and the // \subdoxygen{itk}{Statistics}{CovarianceSampleFilter} (sample covariance) for the // estimation algorithms of the two parameters. If we want more robust // estimation algorithm, we can replace these estimation algorithms with more // alternatives without changing other components in the classifier system. // // It is a bad idea to use the same sample for test and training // (parameter estimation) of the parameters. However, for simplicity, in // this example, we use a sample for test and training. // // \begin{figure} // \centering // \includegraphics[width=0.9\textwidth]{BayesianPluginClassifier.eps} // \itkcaption[Bayesian plug-in classifier for two Gaussian classes]{Bayesian // plug-in classifier for two Gaussian classes.} // \protect\label{fig:BayesianPluginClassifier} // \end{figure} // // We use the \subdoxygen{itk}{Statistics}{ListSample} as the sample (test // and training). The \doxygen{itk}{Vector} is our measurement vector // class. To store measurement vectors into two separate sample // containers, we use the \subdoxygen{itk}{Statistics}{Subsample} objects. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkVector.h" #include "itkListSample.h" #include "itkSubsample.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following two files provides us the parameter estimation algorithms. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMeanSampleFilter.h" #include "itkCovarianceSampleFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following files define the components required by ITK statistical // classification framework: the decision rule, the membership // function, and the classifier. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMaximumRatioDecisionRule.h" #include "itkGaussianMembershipFunction.h" #include "itkSampleClassifierFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will fill the sample with random variables from two normal // distribution using the \subdoxygen{itk}{Statistics}{NormalVariateGenerator}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkNormalVariateGenerator.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { // Software Guide : BeginLatex // // Since the NormalVariateGenerator class only supports 1-D, we define our // measurement vector type as a one component vector. We then, create a // ListSample object for data inputs. // // We also create two Subsample objects that will store // the measurement vectors in \code{sample} into two separate // sample containers. Each Subsample object stores only the // measurement vectors belonging to a single class. This class sample // will be used by the parameter estimation algorithms. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Vector MeasurementVectorType; typedef itk::Statistics::ListSample SampleType; SampleType::Pointer sample = SampleType::New(); sample->SetMeasurementVectorSize(1); // length of measurement vectors // in the sample. typedef itk::Statistics::Subsample ClassSampleType; std::vector classSamples; for (unsigned int i = 0; i < 2; ++i) { classSamples.push_back(ClassSampleType::New()); classSamples[i]->SetSample(sample); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code snippet creates a NormalVariateGenerator // object. Since the random variable generator returns values according to // the standard normal distribution (the mean is zero, and the standard // deviation is one) before pushing random values into the \code{sample}, // we change the mean and standard deviation. We want two normal (Gaussian) // distribution data. We have two for loops. Each for loop uses different // mean and standard deviation. Before we fill the \code{sample} with the // second distribution data, we call \code{Initialize(random seed)} method, // to recreate the pool of random variables in the // \code{normalGenerator}. In the second for loop, we fill the two class // samples with measurement vectors using the \code{AddInstance()} method. // // To see the probability density plots from the two distributions, // refer to Figure~\ref{fig:TwoNormalDensityFunctionPlot}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::NormalVariateGenerator NormalGeneratorType; NormalGeneratorType::Pointer normalGenerator = NormalGeneratorType::New(); normalGenerator->Initialize(101); MeasurementVectorType mv; double mean = 100; double standardDeviation = 30; SampleType::InstanceIdentifier id = 0UL; for (unsigned int i = 0; i < 100; ++i) { mv.Fill((normalGenerator->GetVariate() * standardDeviation) + mean); sample->PushBack(mv); classSamples[0]->AddInstance(id); ++id; } normalGenerator->Initialize(3024); mean = 200; standardDeviation = 30; for (unsigned int i = 0; i < 100; ++i) { mv.Fill((normalGenerator->GetVariate() * standardDeviation) + mean); sample->PushBack(mv); classSamples[1]->AddInstance(id); ++id; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In the following code snippet, notice that the template argument for the // MeanSampleFilter and CovarianceFilter is \code{ClassSampleType} (i.e., // type of Subsample) instead of SampleType (i.e., type of ListSample). This // is because the parameter estimation algorithms are applied to the class // sample. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::MeanSampleFilter MeanEstimatorType; typedef itk::Statistics::CovarianceSampleFilter CovarianceEstimatorType; std::vector meanEstimators; std::vector covarianceEstimators; for (unsigned int i = 0; i < 2; ++i) { meanEstimators.push_back(MeanEstimatorType::New()); meanEstimators[i]->SetInput(classSamples[i]); meanEstimators[i]->Update(); covarianceEstimators.push_back(CovarianceEstimatorType::New()); covarianceEstimators[i]->SetInput(classSamples[i]); //covarianceEstimators[i]->SetMean(meanEstimators[i]->GetOutput()); covarianceEstimators[i]->Update(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We print out the estimated parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned int i = 0; i < 2; ++i) { std::cout << "class[" << i << "] " << std::endl; std::cout << " estimated mean : " << meanEstimators[i]->GetMean() << " covariance matrix : " << covarianceEstimators[i]->GetCovarianceMatrixOutput()->Get() << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After creating a SampleClassifierFilter object and a // MaximumRatioDecisionRule object, we plug in the // \code{decisionRule} and the \code{sample} to the classifier. Then, // we specify the number of classes that will be considered using // the \code{SetNumberOfClasses()} method. // // The MaximumRatioDecisionRule requires a vector of \emph{a // priori} probability values. Such \emph{a priori} probability will // be the $P(\omega_{i})$ of the following variation of the Bayes // decision rule: // \begin{equation} // \textrm{Decide } \omega_{i} \textrm{ if } // \frac{p(\overrightarrow{x}|\omega_{i})} // {p(\overrightarrow{x}|\omega_{j})} // > \frac{P(\omega_{j})}{P(\omega_{i})} \textrm{ for all } j \not= i // \label{eq:bayes2} // \end{equation} // // The remainder of the code snippet shows how to use user-specified class // labels. The classification result will be stored in a // MembershipSample object, and for each measurement vector, its // class label will be one of the two class labels, 100 and 200 // (\code{unsigned int}). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::GaussianMembershipFunction MembershipFunctionType; typedef itk::Statistics::MaximumRatioDecisionRule DecisionRuleType; DecisionRuleType::Pointer decisionRule = DecisionRuleType::New(); DecisionRuleType::PriorProbabilityVectorType aPrioris; aPrioris.push_back(classSamples[0]->GetTotalFrequency() / sample->GetTotalFrequency()); aPrioris.push_back(classSamples[1]->GetTotalFrequency() / sample->GetTotalFrequency()); decisionRule->SetPriorProbabilities(aPrioris); typedef itk::Statistics::SampleClassifierFilter ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); classifier->SetDecisionRule(dynamic_cast< itk::Statistics::DecisionRule* >( decisionRule.GetPointer())); classifier->SetInput(sample); classifier->SetNumberOfClasses(2); std::vector classLabels; classLabels.resize(2); classLabels[0] = 100; classLabels[1] = 200; typedef itk::SimpleDataObjectDecorator > ClassLabelDecoratedType; ClassLabelDecoratedType::Pointer classLabelsDecorated = ClassLabelDecoratedType::New(); classLabelsDecorated->Set(classLabels); classifier->SetClassLabels(classLabelsDecorated); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{classifier} is almost ready to perform the classification // except that it needs two membership functions that represent the two // clusters. // // In this example, we can imagine that the two clusters are modeled by two // Euclidean distance functions. The distance function (model) has only one // parameter, the mean (centroid) set by the \code{SetOrigin()} method. To // plug-in two distance functions, we call the // \code{AddMembershipFunction()} method. Then invocation of the // \code{Update()} method will perform the classification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ClassifierType::MembershipFunctionType MembershipFunctionBaseType; typedef ClassifierType::MembershipFunctionVectorObjectType::ComponentType ComponentMembershipType; // Vector Containing the membership function used ComponentMembershipType membershipFunctions; for (unsigned int i = 0; i < 2; i++) { MembershipFunctionType::Pointer curMemshpFunction = MembershipFunctionType::New(); curMemshpFunction->SetMean(meanEstimators[i]->GetMean()); curMemshpFunction->SetCovariance(covarianceEstimators[i]->GetCovarianceMatrix()); // cast the GaussianMembershipFunction in a // itk::MembershipFunctionBase membershipFunctions.push_back(dynamic_cast(curMemshpFunction.GetPointer())); } ClassifierType::MembershipFunctionVectorObjectPointer membershipVectorObject = ClassifierType::MembershipFunctionVectorObjectType::New(); membershipVectorObject->Set(membershipFunctions); classifier->SetMembershipFunctions(membershipVectorObject); classifier->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code snippet prints out pairs of a measurement vector and // its class label in the \code{sample}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const ClassifierType::MembershipSampleType* membershipSample = classifier->GetOutput(); ClassifierType::MembershipSampleType::ConstIterator iter = membershipSample->Begin(); while (iter != membershipSample->End()) { std::cout << "measurement vector = " << iter.GetMeasurementVector() << "class label = " << iter.GetClassLabel() << std::endl; ++iter; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/CMakeLists.txt000066400000000000000000000042141301006202600226700ustar00rootroot00000000000000project(ClassificationExamples) add_executable(BayesianPluginClassifier BayesianPluginClassifier.cxx) target_link_libraries(BayesianPluginClassifier ${OTB_LIBRARIES}) add_executable(ClassificationMapRegularizationExample ClassificationMapRegularizationExample.cxx) target_link_libraries(ClassificationMapRegularizationExample ${OTB_LIBRARIES}) #OTBDempsterShafer depends OTBMathParser. But OTB_USE_MUPARSER is OFF if(OTBMathParser_LOADED) add_executable(DempsterShaferFusionOfClassificationMapsExample DempsterShaferFusionOfClassificationMapsExample.cxx) target_link_libraries(DempsterShaferFusionOfClassificationMapsExample ${OTB_LIBRARIES}) endif() add_executable(ExpectationMaximizationMixtureModelEstimator ExpectationMaximizationMixtureModelEstimator.cxx) target_link_libraries(ExpectationMaximizationMixtureModelEstimator ${OTB_LIBRARIES}) add_executable(KdTreeBasedKMeansClustering KdTreeBasedKMeansClustering.cxx) target_link_libraries(KdTreeBasedKMeansClustering ${OTB_LIBRARIES}) add_executable(KMeansImageClassificationExample KMeansImageClassificationExample.cxx) target_link_libraries(KMeansImageClassificationExample ${OTB_LIBRARIES}) add_executable(MajorityVotingFusionOfClassificationMapsExample MajorityVotingFusionOfClassificationMapsExample.cxx) target_link_libraries(MajorityVotingFusionOfClassificationMapsExample ${OTB_LIBRARIES}) add_executable(ScalarImageKmeansClassifier ScalarImageKmeansClassifier.cxx) target_link_libraries(ScalarImageKmeansClassifier ${OTB_LIBRARIES}) add_executable(ScalarImageKmeansModelEstimator ScalarImageKmeansModelEstimator.cxx) target_link_libraries(ScalarImageKmeansModelEstimator ${OTB_LIBRARIES}) add_executable(ScalarImageMarkovRandomField1 ScalarImageMarkovRandomField1.cxx) target_link_libraries(ScalarImageMarkovRandomField1 ${OTB_LIBRARIES}) add_executable(SOMImageClassificationExample SOMImageClassificationExample.cxx) target_link_libraries(SOMImageClassificationExample ${OTB_LIBRARIES}) add_executable(SupervisedImageClassificationExample SupervisedImageClassificationExample.cxx) target_link_libraries(SupervisedImageClassificationExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Classification/ClassificationMapRegularizationExample.cxx000066400000000000000000000162531301006202600305070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // After having generated a classification map, it is possible to // regularize such a labeled image in order to obtain more homogeneous // areas, which makes the interpretation of its classes easier. For this // purpose, the \doxygen{otb}{NeighborhoodMajorityVotingImageFilter} was // implemented. Like a morphological filter, this filter uses majority // voting in a ball shaped neighborhood in order to set each pixel of the // classification map to the more representative label value in its // neighborhood. // // In this example we will illustrate its use. We start by including the // appropriate header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbNeighborhoodMajorityVotingImageFilter.h" // Software Guide : EndCodeSnippet #include "itkMacro.h" #include "otbImage.h" #include #include #include "otbImageFileWriter.h" #include "itkTimeProbe.h" int main(int itkNotUsed(argc), char * argv[]) { // Software Guide : BeginLatex // // Since the input image is a classification map, we will assume a // single band input image for which each pixel value is a label coded // on 8 bits as an integer between 0 and 255. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char IOLabelPixelType; // 8 bits const unsigned int Dimension = 2; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Thus, both input and output images are single band labeled images, // which are composed of the same type of pixels in this example // (unsigned char). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image IOLabelImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the neighborhood majority voting filter, // which is templated over its input and output images types and over its // structuring element type. Choosing only the input image type in the template // of this filter induces that, both input and output images types are the same // and that the structuring element is a ball // (\doxygen{itk}{BinaryBallStructuringElement}). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Neighborhood majority voting filter type typedef otb::NeighborhoodMajorityVotingImageFilter NeighborhoodMajorityVotingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the \doxygen{otb}{NeighborhoodMajorityVotingImageFilter} is a // neighborhood based image filter, it is necessary to set the structuring // element which will be used for the majority voting process. By default, the // structuring element is a ball // (\doxygen{itk}{BinaryBallStructuringElement}) with a radius defined by two sizes // (respectively along X and Y). Thus, it is possible to handle anisotropic // structuring elements such as ovals. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Binary ball Structuring Element type typedef NeighborhoodMajorityVotingFilterType::KernelType StructuringType; typedef StructuringType::RadiusType RadiusType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we define the reader and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; // Software Guide : BeginLatex // // We instantiate the \doxygen{otb}{NeighborhoodMajorityVotingImageFilter} and the // reader objects. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Neighborhood majority voting filter NeighborhoodMajorityVotingFilterType::Pointer NeighMajVotingFilter; NeighMajVotingFilter = NeighborhoodMajorityVotingFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Software Guide : EndCodeSnippet std::string KeepOriginalLabelBoolStr = argv[3]; unsigned int radiusX = atoi(argv[4]); unsigned int radiusY = atoi(argv[5]); IOLabelPixelType noDataValue = atoi(argv[6]); IOLabelPixelType undecidedValue = atoi(argv[7]); // Software Guide : BeginLatex // // The ball shaped structuring element seBall is instantiated and its // two radii along X and Y are initialized. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet StructuringType seBall; RadiusType rad; rad[0] = radiusX; rad[1] = radiusY; seBall.SetRadius(rad); seBall.CreateStructuringElement(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, this ball shaped neighborhood is used as the kernel structuring element // for the \doxygen{otb}{NeighborhoodMajorityVotingImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighMajVotingFilter->SetKernel(seBall); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Not classified input pixels are assumed to have the noDataValue label // and will keep this label in the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighMajVotingFilter->SetLabelForNoDataPixels(noDataValue); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Moreover, since the majority voting regularization may lead to not unique // majority labels in the neighborhood, it is important to define which behaviour // the filter must have in this case. For this purpose, a Boolean parameter is used // in the filter to choose whether pixels with more than one majority class are set // to undecidedValue (true), or to their Original labels (false = default value) // in the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighMajVotingFilter->SetLabelForUndecidedPixels(undecidedValue); if (KeepOriginalLabelBoolStr.compare("true") == 0) { NeighMajVotingFilter->SetKeepOriginalLabelBool(true); } else { NeighMajVotingFilter->SetKeepOriginalLabelBool(false); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline and // trigger its execution by updating the output of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighMajVotingFilter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(NeighMajVotingFilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/DempsterShaferFusionOfClassificationMapsExample.cxx000066400000000000000000000315671301006202600322650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The fusion filter \doxygen{otb}{DSFusionOfClassifiersImageFilter} is based on the Dempster // Shafer (DS) fusion framework. For each pixel, it chooses the class label \emph{Ai} for which the // belief function \emph{bel(Ai)} is maximal after the DS combination of all the available masses of // belief of all the class labels. The masses of belief (MOBs) of all the labels present in each // classification map are read from input *.CSV confusion matrix files. // Moreover, the pixels into the input classification maps to be fused which are equal to the // \emph{nodataLabel} value are ignored by the fusion process. In case of not unique class labels // with the maximal belief function, the output pixels are set to the \emph{undecidedLabel} value. // We start by including the appropriate header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageListToVectorImageFilter.h" #include "otbConfusionMatrixToMassOfBelief.h" #include "otbDSFusionOfClassifiersImageFilter.h" #include // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : BeginLatex // // We will assume unsigned short type input labeled images. We define a type for // confusion matrices as \doxygen{itk}{VariableSizeMatrix} which will be used to estimate the masses of belief of all the // class labels for each input classification map. For this purpose, the // \doxygen{otb}{ConfusionMatrixToMassOfBelief} will be used to convert each input confusion matrix // into masses of belief for each class label. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short LabelPixelType; typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef otb::ConfusionMatrixToMassOfBelief ConfusionMatrixToMassOfBeliefType; typedef ConfusionMatrixToMassOfBeliefType::MapOfClassesType MapOfClassesType; // Software Guide : EndCodeSnippet int CSVConfusionMatrixFileReader(const std::string fileName, MapOfClassesType &mapOfClassesRefClX, ConfusionMatrixType &confusionMatrixClX) { std::ifstream inFile; inFile.open(fileName.c_str()); if (!inFile) { std::cerr << "Confusion Matrix File opening problem with file:" << std::endl; std::cerr << fileName.c_str() << std::endl; return EXIT_FAILURE; } else { LabelPixelType labelRef = 0, labelProd = 0; std::string currentLine, refLabelsLine, prodLabelsLine, currentValue; const char endCommentChar = ':'; const char separatorChar = ','; const char eolChar = '\n'; std::getline(inFile, refLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, refLabelsLine, eolChar); // Gets the first line after the comment char until the End Of Line char std::getline(inFile, prodLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, prodLabelsLine, eolChar); // Gets the second line after the comment char until the End Of Line char std::istringstream issRefLabelsLine(refLabelsLine); std::istringstream issProdLabelsLine(prodLabelsLine); MapOfClassesType mapOfClassesProdClX; mapOfClassesRefClX.clear(); mapOfClassesProdClX.clear(); int itLab = 0; while (issRefLabelsLine.good()) { std::getline(issRefLabelsLine, currentValue, separatorChar); labelRef = static_cast (std::atoi(currentValue.c_str())); mapOfClassesRefClX[labelRef] = itLab; ++itLab; } itLab = 0; while (issProdLabelsLine.good()) { std::getline(issProdLabelsLine, currentValue, separatorChar); labelProd = static_cast (std::atoi(currentValue.c_str())); mapOfClassesProdClX[labelProd] = itLab; ++itLab; } unsigned int nbRefLabelsClk = mapOfClassesRefClX.size(); unsigned int nbProdLabelsClk = mapOfClassesProdClX.size(); ConfusionMatrixType confusionMatrixClXTemp; confusionMatrixClXTemp = ConfusionMatrixType(nbRefLabelsClk, nbProdLabelsClk); confusionMatrixClXTemp.Fill(0); // Reading the confusion matrix confusionMatrixClXTemp from the file for (unsigned int itRow = 0; itRow < nbRefLabelsClk; ++itRow) { //Gets the itRow^th line after the header lines with the labels std::getline(inFile, currentLine, eolChar); std::istringstream issCurrentLine(currentLine); unsigned int itCol = 0; while (issCurrentLine.good()) { std::getline(issCurrentLine, currentValue, separatorChar); confusionMatrixClXTemp(itRow, itCol) = static_cast (std::atoi(currentValue.c_str())); ++itCol; } } MapOfClassesType::iterator itMapOfClassesRef, itMapOfClassesProd; // Formatting confusionMatrixClX from confusionMatrixClXTemp in order to make confusionMatrixClX a square matrix // from the reference labels in mapOfClassesRefClX int indiceLabelRef = 0, indiceLabelProd = 0; int indiceLabelRefTemp = 0, indiceLabelProdTemp = 0; // Initialization of confusionMatrixClX confusionMatrixClX = ConfusionMatrixType(nbRefLabelsClk, nbRefLabelsClk); confusionMatrixClX.Fill(0); for (itMapOfClassesRef = mapOfClassesRefClX.begin(); itMapOfClassesRef != mapOfClassesRefClX.end(); ++itMapOfClassesRef) { // labels labelRef of mapOfClassesRefClX are already sorted labelRef = itMapOfClassesRef->first; indiceLabelRefTemp = itMapOfClassesRef->second; for (itMapOfClassesProd = mapOfClassesProdClX.begin(); itMapOfClassesProd != mapOfClassesProdClX.end(); ++itMapOfClassesProd) { // labels labelProd of mapOfClassesProdClX are already sorted labelProd = itMapOfClassesProd->first; indiceLabelProdTemp = itMapOfClassesProd->second; // If labelProd is present in mapOfClassesRefClX if (mapOfClassesRefClX.count(labelProd) != 0) { // Indice of labelProd in mapOfClassesRefClX; itMapOfClassesRef->second elements are already SORTED indiceLabelProd = mapOfClassesRefClX[labelProd]; confusionMatrixClX(indiceLabelRef, indiceLabelProd) = confusionMatrixClXTemp(indiceLabelRefTemp, indiceLabelProdTemp); } } ++indiceLabelRef; } } inFile.close(); return EXIT_SUCCESS; } int main(int argc, char * argv[]) { // Software Guide : BeginLatex // // The input labeled images to be fused are expected to be scalar images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef otb::Image LabelImageType; typedef otb::VectorImage VectorImageType; // Software Guide : EndCodeSnippet LabelPixelType nodataLabel = atoi(argv[argc - 3]); LabelPixelType undecidedLabel = atoi(argv[argc - 2]); const char * outfname = argv[argc - 1]; unsigned int nbParameters = 3; unsigned int nbClassificationMaps = (argc - 1 - nbParameters) / 2; // Software Guide : BeginLatex // // We declare an \doxygen{otb}{ImageListToVectorImageFilter} which will stack all the // input classification maps to be fused as a single VectorImage for which each // band is a classification map. This VectorImage will then be the input of the // Dempster Shafer fusion filter \doxygen{otb}{DSFusionOfClassifiersImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageList LabelImageListType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; // Software Guide : EndCodeSnippet typedef ConfusionMatrixToMassOfBeliefType::MassOfBeliefDefinitionMethod MassOfBeliefDefinitionMethod; // Software Guide : BeginLatex // // The Dempster Shafer fusion filter \doxygen{otb}{DSFusionOfClassifiersImageFilter} is declared. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Dempster Shafer typedef otb::DSFusionOfClassifiersImageFilter DSFusionOfClassifiersImageFilterType; // Software Guide : EndCodeSnippet typedef DSFusionOfClassifiersImageFilterType::VectorOfMapOfMassesOfBeliefType VectorOfMapOfMassesOfBeliefType; // Software Guide : BeginLatex // // Both reader and writer are defined. Since the images // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the fusion filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image list of input classification maps is filled. Moreover, the input // confusion matrix files are converted into masses of belief. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader; LabelImageListType::Pointer imageList = LabelImageListType::New(); ConfusionMatrixToMassOfBeliefType::Pointer confusionMatrixToMassOfBeliefFilter; confusionMatrixToMassOfBeliefFilter = ConfusionMatrixToMassOfBeliefType::New(); MassOfBeliefDefinitionMethod massOfBeliefDef; // Several parameters are available to estimate the masses of belief // from the confusion matrices: PRECISION, RECALL, ACCURACY and KAPPA massOfBeliefDef = ConfusionMatrixToMassOfBeliefType::PRECISION; VectorOfMapOfMassesOfBeliefType vectorOfMapOfMassesOfBelief; for (unsigned int itCM = 0; itCM < nbClassificationMaps; ++itCM) { std::string fileNameClassifiedImage = argv[itCM + 1]; std::string fileNameConfMat = argv[itCM + 1 + nbClassificationMaps]; reader = ReaderType::New(); reader->SetFileName(fileNameClassifiedImage); reader->Update(); imageList->PushBack(reader->GetOutput()); MapOfClassesType mapOfClassesClk; ConfusionMatrixType confusionMatrixClk; // The data (class labels and confusion matrix values) are read and // extracted from the *.CSV file with an ad-hoc file parser CSVConfusionMatrixFileReader( fileNameConfMat, mapOfClassesClk, confusionMatrixClk); // The parameters of the ConfusionMatrixToMassOfBelief filter are set confusionMatrixToMassOfBeliefFilter->SetMapOfClasses(mapOfClassesClk); confusionMatrixToMassOfBeliefFilter->SetConfusionMatrix(confusionMatrixClk); confusionMatrixToMassOfBeliefFilter->SetDefinitionMethod(massOfBeliefDef); confusionMatrixToMassOfBeliefFilter->Update(); // Vector containing ALL the K (= nbClassificationMaps) std::map // of Masses of Belief vectorOfMapOfMassesOfBelief.push_back( confusionMatrixToMassOfBeliefFilter->GetMapMassOfBelief()); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image list of input classification maps is converted into a VectorImage to // be used as input of the \doxygen{otb}{DSFusionOfClassifiersImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Image List To VectorImage ImageListToVectorImageFilterType::Pointer imageListToVectorImageFilter; imageListToVectorImageFilter = ImageListToVectorImageFilterType::New(); imageListToVectorImageFilter->SetInput(imageList); DSFusionOfClassifiersImageFilterType::Pointer dsFusionFilter; dsFusionFilter = DSFusionOfClassifiersImageFilterType::New(); // The parameters of the DSFusionOfClassifiersImageFilter are set dsFusionFilter->SetInput(imageListToVectorImageFilter->GetOutput()); dsFusionFilter->SetInputMapsOfMassesOfBelief(&vectorOfMapOfMassesOfBelief); dsFusionFilter->SetLabelForNoDataPixels(nodataLabel); dsFusionFilter->SetLabelForUndecidedPixels(undecidedLabel); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once it is plugged the pipeline triggers its execution by updating // the output of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetInput(dsFusionFilter->GetOutput()); writer->SetFileName(outfname); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/ExpectationMaximizationMixtureModelEstimator.cxx000066400000000000000000000223521301006202600317630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // \index{Statistics!Mixture model estimation} // \index{Statistics!Expectation maximization} // // \index{itk::Statistics::Gaussian\-Mixture\-Model\-Component} // \index{itk::Statistics::Expectation\-Maximization\-Mixture\-Model\-Estimator} // // In this example, we present ITK's implementation of the expectation // maximization (EM) process to generate parameter estimates for a two // Gaussian component mixture model. // // The Bayesian plug-in classifier example (see Section // \ref{sec:BayesianPluginClassifier}) used two Gaussian probability // density functions (PDF) to model two Gaussian distribution classes (two // models for two class). However, in some cases, we want to model a // distribution as a mixture of several different // distributions. Therefore, the probability density function ($p(x)$) // of a mixture model can be stated as follows : // // \begin{equation} // p(x) = \sum^{c}_{i=0}\alpha_{i}f_{i}(x) // \end{equation} // where $i$ is the index of the component, // $c$ is the number of components, // $\alpha_{i}$ is the proportion of the component, // and $f_{i}$ is the probability density function of the component. // // Now the task is to find the parameters(the component PDF's // parameters and the proportion values) to maximize the likelihood of // the parameters. If we know which component a measurement vector // belongs to, the solutions to this problem is easy to solve. // However, we don't know the membership of each measurement // vector. Therefore, we use the expectation of membership instead of // the exact membership. The EM process splits into two steps: // \begin{enumerate} // \item{ E step: calculate the expected membership values for each // measurement vector to each classes.} // \item{ M step: find the next parameter sets that maximize the // likelihood with the expected membership values and the current set of // parameters.} // \end{enumerate} // // The E step is basically a step that calculates the \emph{a posteriori} // probability for each measurement vector. // // The M step is dependent on the type of each PDF. Most of // distributions belonging to exponential family such as Poisson, // Binomial, Exponential, and Normal distributions have analytical // solutions for updating the parameter set. The // \subdoxygen{itk}{Statistics}{ExpectationMaximizationMixtureModelEstimator} // class assumes that such type of components. // // In the following example we use the \subdoxygen{itk}{Statistics}{ListSample} as // the sample (test and training). The \subdoxygen{itk}{Vector} is our measurement // vector class. To store measurement vectors into two separate sample // container, we use the \subdoxygen{itk}{Statistics}{Subsample} objects. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkVector.h" #include "itkListSample.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following two files provide us the parameter estimation algorithms. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkGaussianMixtureModelComponent.h" #include "itkExpectationMaximizationMixtureModelEstimator.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will fill the sample with random variables from two normal // distribution using the \subdoxygen{itk}{Statistics}{NormalVariateGenerator}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkNormalVariateGenerator.h" // Software Guide : EndCodeSnippet int main() { // Software Guide : BeginLatex // // Since the NormalVariateGenerator class only supports 1-D, we // define our measurement vector type as a one component vector. We // then, create a ListSample object for data inputs. // // We also create two Subsample objects that will store the // measurement vectors in the \code{sample} into two separate sample // containers. Each Subsample object stores only the // measurement vectors belonging to a single class. This // \textit{class sample} will be used by the parameter estimation // algorithms. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int numberOfClasses = 2; typedef itk::Vector MeasurementVectorType; typedef itk::Statistics::ListSample SampleType; SampleType::Pointer sample = SampleType::New(); sample->SetMeasurementVectorSize(1); // length of measurement vectors // in the sample. // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code snippet creates a NormalVariateGenerator object. // Since the random variable generator returns values according to the // standard normal distribution (the mean is zero, and the standard // deviation is one) before pushing random values into the \code{sample}, // we change the mean and standard deviation. We want two normal (Gaussian) // distribution data. We have two for loops. Each for loop uses different // mean and standard deviation. Before we fill the \code{sample} with the // second distribution data, we call \code{Initialize()} method to recreate // the pool of random variables in the \code{normalGenerator}. In the // second for loop, we fill the two class samples with measurement vectors // using the \code{AddInstance()} method. // // To see the probability density plots from the two distribution, // refer to Figure~\ref{fig:TwoNormalDensityFunctionPlot}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::NormalVariateGenerator NormalGeneratorType; NormalGeneratorType::Pointer normalGenerator = NormalGeneratorType::New(); normalGenerator->Initialize(101); MeasurementVectorType mv; double mean = 100; double standardDeviation = 30; for (unsigned int i = 0; i < 100; ++i) { mv[0] = (normalGenerator->GetVariate() * standardDeviation) + mean; sample->PushBack(mv); } normalGenerator->Initialize(3024); mean = 200; standardDeviation = 30; for (unsigned int i = 0; i < 100; ++i) { mv[0] = (normalGenerator->GetVariate() * standardDeviation) + mean; sample->PushBack(mv); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In the following code snippet notice that the template argument // for the MeanSampleFilter and CovarianceSampleFilter is // \code{ClassSampleType} (i.e., type of Subsample) instead of // \code{SampleType} (i.e., type of ListSample). This is because the // parameter estimation algorithms are applied to the class sample. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Array ParametersType; ParametersType params(2); std::vector initialParameters(numberOfClasses); params[0] = 110.0; params[1] = 800.0; initialParameters[0] = params; params[0] = 210.0; params[1] = 850.0; initialParameters[1] = params; typedef itk::Statistics::GaussianMixtureModelComponent ComponentType; std::vector components; for (unsigned int i = 0; i < numberOfClasses; ++i) { components.push_back(ComponentType::New()); (components[i])->SetSample(sample); (components[i])->SetParameters(initialParameters[i]); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We run the estimator. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::ExpectationMaximizationMixtureModelEstimator< SampleType> EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); estimator->SetSample(sample); estimator->SetMaximumIteration(200); itk::Array initialProportions(numberOfClasses); initialProportions[0] = 0.5; initialProportions[1] = 0.5; estimator->SetInitialProportions(initialProportions); for (unsigned int i = 0; i < numberOfClasses; ++i) { estimator->AddComponent((ComponentType::Superclass*) (components[i]).GetPointer()); } estimator->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We then print out the estimated parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned int i = 0; i < numberOfClasses; ++i) { std::cout << "Cluster[" << i << "]" << std::endl; std::cout << " Parameters:" << std::endl; std::cout << " " << (components[i])->GetFullParameters() << std::endl; std::cout << " Proportion: "; std::cout << " " << (estimator->GetProportions())[i] << std::endl; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/KMeansImageClassificationExample.cxx000066400000000000000000000121621301006202600271660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The K-Means classification proposed by ITK for images is limited to // scalar images and is not streamed. In this example, we show // how the use of the \doxygen{otb}{KMeansImageClassificationFilter} // allows for a simple implementation of a K-Means classification // application. We will start by including the appropirate header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbKMeansImageClassificationFilter.h" // Software Guide : EndCodeSnippet #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int nbClasses = atoi(argv[3]); // Software Guide : BeginLatex // // We will assume double precision input images and will also define // the type for the labeled pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Our classifier will be generic enough to be able to process images // with any number of bands. We read the images as // \doxygen{otb}{VectorImage}s. The labeled image will be a scalar image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the classifier filter, which is // templated over its input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::KMeansImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::KMeansParametersType KMeansParametersType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we define the reader and the writer. Since the images // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the classifier. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the classifier and the reader objects and we set // their parameters. Please note the call of the // \code{GenerateOutputInformation()} method on the reader in order to // have available the information about the input image (size, number // of bands, etc.) without needing to actually read the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The classifier needs as input the centroids of // the classes. We declare the parameter vector, and we read the // centroids from the arguments of the program. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int sampleSize = ClassificationFilterType::MaxSampleDimension; const unsigned int parameterSize = nbClasses * sampleSize; KMeansParametersType parameters; parameters.SetSize(parameterSize); parameters.Fill(0); for (unsigned int i = 0; i < nbClasses; ++i) { for (unsigned int j = 0; j < reader->GetOutput()->GetNumberOfComponentsPerPixel(); ++j) { parameters[i * sampleSize + j] = atof(argv[4 + i * reader->GetOutput()->GetNumberOfComponentsPerPixel() + j]); } } std::cout << "Parameters: " << parameters << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the parameters for the classifier, we plug the pipeline and // trigger its execution by updating the output of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetCentroids(parameters); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/KdTreeBasedKMeansClustering.cxx000066400000000000000000000362011301006202600261310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // \index{Statistics!k-means clustering (using k-d tree)} // // \index{itk::Statistics::KdTree\-Based\-Kmeans\-Estimator} // // K-means clustering is a popular clustering algorithm because it is simple // and usually converges to a reasonable solution. The k-means algorithm // works as follows: // // \begin{enumerate} // \item{Obtains the initial k means input from the user.} // \item{Assigns each measurement vector in a sample container to its // closest mean among the k number of means (i.e., update the membership of // each measurement vectors to the nearest of the k clusters).} // \item{Calculates each cluster's mean from the newly assigned // measurement vectors (updates the centroid (mean) of k clusters).} // \item{Repeats step 2 and step 3 until it meets the termination // criteria.} // \end{enumerate} // // The most common termination criteria is that if there is no // measurement vector that changes its cluster membership from the // previous iteration, then the algorithm stops. // // The \subdoxygen{itk}{Statistics}{KdTreeBasedKmeansEstimator} is a variation of // this logic. The k-means clustering algorithm is computationally very // expensive because it has to recalculate the mean at each iteration. To // update the mean values, we have to calculate the distance between k means // and each and every measurement vector. To reduce the computational burden, // the KdTreeBasedKmeansEstimator uses a special data structure: the // k-d tree (\subdoxygen{itk}{Statistics}{KdTree}) with additional // information. The additional information includes the number and the vector // sum of measurement vectors under each node under the tree architecture. // // With such additional information and the k-d tree data structure, // we can reduce the computational cost of the distance calculation // and means. Instead of calculating each measurement vectors and k // means, we can simply compare each node of the k-d tree and the k // means. This idea of utilizing a k-d tree can be found in multiple // articles \cite{Alsabti1998} \cite{Pelleg1999} // \cite{Kanungo2000}. Our implementation of this scheme follows the // article by the Kanungo et al \cite{Kanungo2000}. // // We use the \subdoxygen{itk}{Statistics}{ListSample} as the input sample, the // \doxygen{itk}{Vector} as the measurement vector. The following code // snippet includes their header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkVector.h" #include "itkListSample.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since this k-means algorithm requires a \subdoxygen{itk}{Statistics}{KdTree} // object as an input, we include the KdTree class header file. As mentioned // above, we need a k-d tree with the vector sum and the number of // measurement vectors. Therefore we use the // \subdoxygen{itk}{Statistics}{WeightedCentroidKdTreeGenerator} instead of the // \subdoxygen{itk}{Statistics}{KdTreeGenerator} that generate a k-d tree without // such additional information. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkKdTree.h" #include "itkWeightedCentroidKdTreeGenerator.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The KdTreeBasedKmeansEstimator class is the implementation of the // k-means algorithm. It does not create k clusters. Instead, it // returns the mean estimates for the k clusters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkKdTreeBasedKmeansEstimator.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To generate the clusters, we must create k instances of // \subdoxygen{itk}{Statistics}{EuclideanDistanceMetric} function as the membership // functions for each cluster and plug that---along with a sample---into an // \subdoxygen{itk}{Statistics}{SampleClassifierFilter} object to get a // \subdoxygen{itk}{Statistics}{MembershipSample} that stores pairs of measurement // vectors and their associated class labels (k labels). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMinimumDecisionRule.h" #include "itkSampleClassifierFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will fill the sample with random variables from two normal // distribution using the \subdoxygen{itk}{Statistics}{NormalVariateGenerator}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkNormalVariateGenerator.h" // Software Guide : EndCodeSnippet int main() { // Software Guide : BeginLatex // // Since the \code{NormalVariateGenerator} class only supports 1-D, we // define our measurement vector type as one component vector. We // then, create a \code{ListSample} object for data inputs. Each // measurement vector is of length 1. We set this using the // \code{SetMeasurementVectorSize()} method. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Vector MeasurementVectorType; typedef itk::Statistics::ListSample SampleType; SampleType::Pointer sample = SampleType::New(); sample->SetMeasurementVectorSize(1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code snippet creates a NormalVariateGenerator // object. Since the random variable generator returns values // according to the standard normal distribution (The mean is zero, // and the standard deviation is one), before pushing random values // into the \code{sample}, we change the mean and standard // deviation. We want two normal (Gaussian) distribution data. We have // two for loops. Each \code{for} loop uses different mean and standard // deviation. Before we fill the \code{sample} with the second // distribution data, we call \code{Initialize(random seed)} method, // to recreate the pool of random variables in the // \code{normalGenerator}. // // To see the probability density plots from the two distribution, // refer to the Figure~\ref{fig:TwoNormalDensityFunctionPlot}. // // \begin{figure} // \center // \includegraphics[width=0.8\textwidth]{TwoNormalDensityFunctionPlot.eps} // \itkcaption[Two normal distributions plot]{Two normal distributions' probability density plot // (The means are 100 and 200, and the standard deviation is 30 )} // \protect\label{fig:TwoNormalDensityFunctionPlot} // \end{figure} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::NormalVariateGenerator NormalGeneratorType; NormalGeneratorType::Pointer normalGenerator = NormalGeneratorType::New(); normalGenerator->Initialize(101); MeasurementVectorType mv; double mean = 100; double standardDeviation = 30; for (unsigned int i = 0; i < 100; ++i) { mv[0] = (normalGenerator->GetVariate() * standardDeviation) + mean; sample->PushBack(mv); } normalGenerator->Initialize(3024); mean = 200; standardDeviation = 30; for (unsigned int i = 0; i < 100; ++i) { mv[0] = (normalGenerator->GetVariate() * standardDeviation) + mean; sample->PushBack(mv); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create a k-d tree. %To see the details on the k-d tree generation, see // %the Section~\ref{sec:KdTree}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::WeightedCentroidKdTreeGenerator TreeGeneratorType; TreeGeneratorType::Pointer treeGenerator = TreeGeneratorType::New(); treeGenerator->SetSample(sample); treeGenerator->SetBucketSize(16); treeGenerator->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once we have the k-d tree, it is a simple procedure to produce k // mean estimates. // // We create the KdTreeBasedKmeansEstimator. Then, we provide the initial // mean values using the \code{SetParameters()}. Since we are dealing with // two normal distribution in a 1-D space, the size of the mean value array // is two. The first element is the first mean value, and the second is the // second mean value. If we used two normal distributions in a 2-D space, // the size of array would be four, and the first two elements would be the // two components of the first normal distribution's mean vector. We // plug-in the k-d tree using the \code{SetKdTree()}. // // The remaining two methods specify the termination condition. The // estimation process stops when the number of iterations reaches the // maximum iteration value set by the \code{SetMaximumIteration()}, or the // distances between the newly calculated mean (centroid) values and // previous ones are within the threshold set by the // \code{SetCentroidPositionChangesThreshold()}. The final step is // to call the \code{StartOptimization()} method. // // The for loop will print out the mean estimates from the estimation // process. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef TreeGeneratorType::KdTreeType TreeType; typedef itk::Statistics::KdTreeBasedKmeansEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); EstimatorType::ParametersType initialMeans(2); initialMeans[0] = 0.0; initialMeans[1] = 0.0; estimator->SetParameters(initialMeans); estimator->SetKdTree(treeGenerator->GetOutput()); estimator->SetMaximumIteration(200); estimator->SetCentroidPositionChangesThreshold(0.0); estimator->StartOptimization(); EstimatorType::ParametersType estimatedMeans = estimator->GetParameters(); for (unsigned int i = 0; i < 2; ++i) { std::cout << "cluster[" << i << "] " << std::endl; std::cout << " estimated mean : " << estimatedMeans[i] << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // If we are only interested in finding the mean estimates, we might // stop. However, to illustrate how a classifier can be formed using // the statistical classification framework. We go a little bit // further in this example. // // Since the k-means algorithm is an minimum distance classifier using // the estimated k means and the measurement vectors. We use the // EuclideanDistanceMetric class as membership functions. Our choice // for the decision rule is the // \subdoxygen{itk}{Statistics}{MinimumDecisionRule} that returns the // index of the membership functions that have the smallest value for // a measurement vector. // // After creating a SampleClassifierFilter object and a MinimumDecisionRule // object, we plug-in the \code{decisionRule} and the \code{sample} to the // classifier. Then, we must specify the number of classes that will be // considered using the \code{SetNumberOfClasses()} method. // // The remainder of the following code snippet shows how to use // user-specified class labels. The classification result will be stored in // a MembershipSample object, and for each measurement vector, its // class label will be one of the two class labels, 100 and 200 // (\code{unsigned int}). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::DistanceToCentroidMembershipFunction< MeasurementVectorType > MembershipFunctionType; typedef itk::Statistics::EuclideanDistanceMetric< MeasurementVectorType > DistanceMetricType; typedef itk::Statistics::MinimumDecisionRule DecisionRuleType; DecisionRuleType::Pointer decisionRule = DecisionRuleType::New(); typedef itk::Statistics::SampleClassifierFilter ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); classifier->SetDecisionRule(decisionRule); classifier->SetInput(sample); classifier->SetNumberOfClasses(2); typedef ClassifierType::ClassLabelVectorObjectType ClassLabelVectorObjectType; ClassLabelVectorObjectType::Pointer classLabels = ClassLabelVectorObjectType::New(); classLabels->Get().push_back(100); classLabels->Get().push_back(200); classifier->SetClassLabels(classLabels); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{classifier} is almost ready to do the classification // process except that it needs two membership functions that // represents two clusters respectively. // // In this example, the two clusters are modeled by two Euclidean distance // functions. The distance function (model) has only one parameter, its mean // (centroid) set by the \code{SetOrigin()} method. To plug-in two distance // functions, we call the \code{AddMembershipFunction()} method. Then // invocation of the \code{Update()} method will perform the // classification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ClassifierType::MembershipFunctionVectorObjectType MembershipFunctionVectorObjectType; MembershipFunctionVectorObjectType::Pointer membershipFunctions = MembershipFunctionVectorObjectType::New(); // std::vector membershipFunctions; DistanceMetricType::OriginType origin( sample->GetMeasurementVectorSize()); int index = 0; for (unsigned int i = 0; i < 2; ++i) { MembershipFunctionType::Pointer membershipFunction1 = MembershipFunctionType::New(); for (unsigned int j = 0; j < sample->GetMeasurementVectorSize(); ++j) { origin[j] = estimatedMeans[index++]; } DistanceMetricType::Pointer distanceMetric = DistanceMetricType::New(); distanceMetric->SetOrigin(origin); membershipFunction1->SetDistanceMetric( distanceMetric ); // classifier->AddMembershipFunction(membershipFunctions[i].GetPointer()); membershipFunctions->Get().push_back(membershipFunction1.GetPointer() ); } classifier->SetMembershipFunctions(membershipFunctions); classifier->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code snippet prints out the measurement vectors and // their class labels in the \code{sample}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const ClassifierType::MembershipSampleType* membershipSample = classifier->GetOutput(); ClassifierType::MembershipSampleType::ConstIterator iter = membershipSample->Begin(); while (iter != membershipSample->End()) { std::cout << "measurement vector = " << iter.GetMeasurementVector() << "class label = " << iter.GetClassLabel() << std::endl; ++iter; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/MajorityVotingFusionOfClassificationMapsExample.cxx000066400000000000000000000100701301006202600323200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The Majority Voting fusion filter \doxygen{itk}{LabelVotingImageFilter} used is based on ITK. // For each pixel, it chooses the more frequent class label among the input classification maps. // In case of not unique more frequent class labels, the output pixel is set to the \emph{undecidedLabel} value. // We start by including the appropriate header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkLabelVotingImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { // Software Guide : BeginLatex // // We will assume unsigned short type input labeled images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned short LabelPixelType; // Software Guide : EndCodeSnippet LabelPixelType undecidedLabel = atoi(argv[argc - 2]); const char * outfname = argv[argc - 1]; unsigned int nbParameters = 2; unsigned int nbClassificationMaps = (argc - 1 - nbParameters); // Software Guide : BeginLatex // // The input labeled images to be fused are expected to be scalar images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image LabelImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The Majority Voting fusion filter \doxygen{itk}{LabelVotingImageFilter} based on ITK is templated // over the input and output labeled image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Majority Voting typedef itk::LabelVotingImageFilter LabelVotingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both reader and writer are defined. Since the images // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the fusion filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input classification maps to be fused are pushed into // the \doxygen{itk}{LabelVotingImageFilter}. Moreover, the // label value for the undecided pixels (in case of not unique // majority voting) is set too. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader; LabelVotingFilterType::Pointer labelVotingFilter = LabelVotingFilterType::New(); for (unsigned int itCM = 0; itCM < nbClassificationMaps; ++itCM) { std::string fileNameClassifiedImage = argv[itCM + 1]; reader = ReaderType::New(); reader->SetFileName(fileNameClassifiedImage); reader->Update(); labelVotingFilter->SetInput(itCM, reader->GetOutput()); } labelVotingFilter->SetLabelForUndecidedPixels(undecidedLabel); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once it is plugged the pipeline triggers its execution by updating // the output of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetInput(labelVotingFilter->GetOutput()); writer->SetFileName(outfname); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/SOMImageClassificationExample.cxx000066400000000000000000000105341301006202600264470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // In previous examples, we have used the // \doxygen{otb}{SOMClassifier}, which uses the ITK classification // framework. This good for compatibility with the ITK framework, but // introduces the limitations of not being able to use streaming and // being able to know at compilation time the number of bands of the // image to be classified. In OTB we have avoided this limitation by // developing the \doxygen{otb}{SOMImageClassificationFilter}. In // this example we will illustrate its use. We start by including the // appropriate header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSOMImageClassificationFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbSOMMap.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * somfname = argv[2]; const char * outfname = argv[3]; // Software Guide : BeginLatex // // We will assume double precision input images and will also define // the type for the labeled pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Our classifier will be generic enough to be able to process images // with any number of bands. We read the images as // \doxygen{otb}{VectorImage}s. The labeled image will be a scalar image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the classifier filter, which is // templated over its input and output image types and the SOM type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SOMMap SOMMapType; typedef otb::SOMImageClassificationFilter ClassificationFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we define the readers (for the input image and theSOM) // and the writer. Since the images, // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the classifier. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader SOMReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the classifier and the reader objects and we set // the existing SOM obtained in a previous training step. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); SOMReaderType::Pointer somreader = SOMReaderType::New(); somreader->SetFileName(somfname); somreader->Update(); filter->SetMap(somreader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline and // trigger its execution by updating the output of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/ScalarImageKmeansClassifier.cxx000066400000000000000000000200441301006202600261670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {QB_Suburb_labelled.png} // 0 4 79.5097 138.136 213.846 25.9395 // NORMALIZE_EPS_OUTPUT_OF: {QB_Suburb_labelled.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example shows how to use the KMeans model for classifying the pixel of // a scalar image. // // The \subdoxygen{itk}{Statistics}{ScalarImageKmeansImageFilter} is used for taking // a scalar image and applying the K-Means algorithm in order to define classes // that represents statistical distributions of intensity values in the pixels. // The classes are then used in this filter for generating a labeled image where // every pixel is assigned to one of the classes. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkScalarImageKmeansImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0]; std::cerr << " inputScalarImage outputLabeledImage contiguousLabels"; std::cerr << " numberOfClasses mean1 mean2... meanN " << std::endl; return EXIT_FAILURE; } const char * inputImageFileName = argv[1]; // Software Guide : BeginLatex // // First we define the pixel type and dimension of the image that we intend to // classify. With this image type we can also declare the // \doxygen{otb}{ImageFileReader} needed for reading the input image, create one and // set its input filename. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef signed short PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // With the \code{ImageType} we instantiate the type of the // \doxygen{itk}{ScalarImageKmeansImageFilter} that will compute the K-Means model // and then classify the image pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ScalarImageKmeansImageFilter KMeansFilterType; KMeansFilterType::Pointer kmeansFilter = KMeansFilterType::New(); kmeansFilter->SetInput(reader->GetOutput()); const unsigned int numberOfInitialClasses = atoi(argv[4]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In general the classification will produce as output an image whose pixel // values are integers associated to the labels of the classes. Since typically // these integers will be generated in order (0, 1, 2, ...N), the output image // will tend to look very dark when displayed with naive viewers. It is // therefore convenient to have the option of spreading the label values over // the dynamic range of the output image pixel type. When this is done, the // dynamic range of the pixels is divided by the number of classes in order to // define the increment between labels. For example, an output image of 8 bits // will have a dynamic range of [0:255], and when it is used for holding four // classes, the non-contiguous labels will be (0, 64, 128, 192). The selection of // the mode to use is done with the method \code{SetUseContiguousLabels()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int useNonContiguousLabels = atoi(argv[3]); kmeansFilter->SetUseNonContiguousLabels(useNonContiguousLabels); // Software Guide : EndCodeSnippet const unsigned int argoffset = 5; if (static_cast(argc) < numberOfInitialClasses + argoffset) { std::cerr << "Error: " << std::endl; std::cerr << numberOfInitialClasses << " classes has been specified "; std::cerr << "but no enough means have been provided in the command "; std::cerr << "line arguments " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // For each one of the classes we must provide a tentative initial value for // the mean of the class. Given that this is a scalar image, each one of the // means is simply a scalar value. Note however that in a general case of // K-Means, the input image would be a vector image and therefore the means // will be vectors of the same dimension as the image pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned k = 0; k < numberOfInitialClasses; ++k) { const double userProvidedInitialMean = atof(argv[k + argoffset]); kmeansFilter->AddClassWithInitialMean(userProvidedInitialMean); } // Software Guide : EndCodeSnippet const char * outputImageFileName = argv[2]; // Software Guide : BeginLatex // // The \doxygen{itk}{ScalarImageKmeansImageFilter} is predefined for producing an 8 // bits scalar image as output. This output image contains labels associated // to each one of the classes in the K-Means algorithm. In the following lines // we use the \code{OutputImageType} in order to instantiate the type of a // \doxygen{otb}{ImageFileWriter}. Then create one, and connect it to the output of // the classification filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef KMeansFilterType::OutputImageType OutputImageType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(kmeansFilter->GetOutput()); writer->SetFileName(outputImageFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We are now ready for triggering the execution of the pipeline. This is done // by simply invoking the \code{Update()} method in the writer. This call will // propagate the update request to the reader and then to the classifier. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Problem encountered while writing "; std::cerr << " image file : " << argv[2] << std::endl; std::cerr << excp << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // At this point the classification is done, the labeled image is saved in a // file, and we can take a look at the means that were found as a result of the // model estimation performed inside the classifier filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet KMeansFilterType::ParametersType estimatedMeans = kmeansFilter->GetFinalMeans(); const unsigned int numberOfClasses = estimatedMeans.Size(); for (unsigned int i = 0; i < numberOfClasses; ++i) { std::cout << "cluster[" << i << "] "; std::cout << " estimated mean : " << estimatedMeans[i] << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{QB_Suburb_labelled.eps} // \itkcaption[Output of the KMeans classifier]{Effect of the // KMeans classifier. Left: original image. Right: image of classes.} // \label{fig:ScalarImageKMeansClassifierOutput} // \end{figure} // // Figure \ref{fig:ScalarImageKMeansClassifierOutput} // illustrates the effect of this filter with three classes. // The means can be estimated by ScalarImageKmeansModelEstimator.cxx. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/ScalarImageKmeansModelEstimator.cxx000066400000000000000000000076761301006202600270530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example shows how to compute the KMeans model of an Scalar Image. // // The \subdoxygen{itk}{Statistics}{KdTreeBasedKmeansEstimator} is used for taking // a scalar image and applying the K-Means algorithm in order to define classes // that represents statistical distributions of intensity values in the pixels. // One of the drawbacks of this technique is that the spatial // distribution of the pixels is not considered at all. It is common therefore // to combine the classification resulting from K-Means with other segmentation // techniques that will use the classification as a prior and add spatial // information to it in order to produce a better segmentation. // // Software Guide : EndLatex #include "itkKdTree.h" #include "itkKdTreeBasedKmeansEstimator.h" #include "itkWeightedCentroidKdTreeGenerator.h" #include "itkMinimumDecisionRule.h" #include "itkSampleClassifierFilter.h" #include "itkImageToListSampleAdaptor.h" #include "otbImage.h" #include "otbImageFileReader.h" int main(int argc, char * argv[]) { if (argc < 2) { std::cerr << "Missing command line arguments" << std::endl; std::cerr << "Usage : " << argv[0] << " inputImageFileName " << std::endl; return -1; } typedef unsigned char PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Problem encoutered while reading image file : " << argv[1] << std::endl; std::cerr << excp << std::endl; return -1; } // Software Guide : BeginCodeSnippet // Create a List from the scalar image typedef itk::Statistics::ImageToListSampleAdaptor AdaptorType; AdaptorType::Pointer adaptor = AdaptorType::New(); adaptor->SetImage(reader->GetOutput()); // Define the Measurement vector type from the AdaptorType // Create the K-d tree structure typedef itk::Statistics::WeightedCentroidKdTreeGenerator< AdaptorType> TreeGeneratorType; TreeGeneratorType::Pointer treeGenerator = TreeGeneratorType::New(); treeGenerator->SetSample(adaptor); treeGenerator->SetBucketSize(16); treeGenerator->Update(); typedef TreeGeneratorType::KdTreeType TreeType; typedef itk::Statistics::KdTreeBasedKmeansEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); const unsigned int numberOfClasses = 4; EstimatorType::ParametersType initialMeans(numberOfClasses); initialMeans[0] = 25.0; initialMeans[1] = 125.0; initialMeans[2] = 250.0; estimator->SetParameters(initialMeans); estimator->SetKdTree(treeGenerator->GetOutput()); estimator->SetMaximumIteration(200); estimator->SetCentroidPositionChangesThreshold(0.0); estimator->StartOptimization(); EstimatorType::ParametersType estimatedMeans = estimator->GetParameters(); for (unsigned int i = 0; i < numberOfClasses; ++i) { std::cout << "cluster[" << i << "] " << std::endl; std::cout << " estimated mean : " << estimatedMeans[i] << std::endl; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/ScalarImageMarkovRandomField1.cxx000066400000000000000000000403021301006202600263700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png}, {QB_Suburb_labelled.png} // OUTPUTS: {ScalarImageMarkovRandomField1Output.png} // 50 3 4 79.5097 138.136 213.846 25.9395 // NORMALIZE_EPS_OUTPUT_OF: {ScalarImageMarkovRandomField1Output.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example shows how to use the Markov Random Field approach for // classifying the pixel of a scalar image. // // The \subdoxygen{itk}{Statistics}{MRFImageFilter} is used for refining an initial // classification by introducing the spatial coherence of the labels. The user // should provide two images as input. The first image is the one to be // classified while the second image is an image of labels representing an // initial classification. // // Software Guide : EndLatex // Software Guide : BeginLatex // // The following headers are related to reading input images, writing the // output image, and making the necessary conversions between scalar and vector // images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "itkFixedArray.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkComposeImageFilter.h" // Software Guide : EndCodeSnippet #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The following headers are related to the statistical classification classes. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMRFImageFilter.h" #include "itkDistanceToCentroidMembershipFunction.h" #include "itkMinimumDecisionRule.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0]; std::cerr << " inputScalarImage inputLabeledImage"; std::cerr << " outputLabeledImage numberOfIterations"; std::cerr << " smoothingFactor numberOfClasses"; std::cerr << " mean1 mean2 ... meanN " << std::endl; return EXIT_FAILURE; } const char * inputImageFileName = argv[1]; const char * inputLabelImageFileName = argv[2]; const char * outputImageFileName = argv[3]; const unsigned int numberOfIterations = atoi(argv[4]); const double smoothingFactor = atof(argv[5]); const unsigned int numberOfClasses = atoi(argv[6]); const unsigned int numberOfArgumentsBeforeMeans = 7; if (static_cast(argc) < numberOfClasses + numberOfArgumentsBeforeMeans) { std::cerr << "Error: " << std::endl; std::cerr << numberOfClasses << " classes has been specified "; std::cerr << "but no enough means have been provided in the command "; std::cerr << "line arguments " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // First we define the pixel type and dimension of the image that we intend to // classify. With this image type we can also declare the // \doxygen{otb}{ImageFileReader} needed for reading the input image, create one and // set its input filename. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As a second step we define the pixel type and dimension of the image of // labels that provides the initial classification of the pixels from the first // image. This initial labeled image can be the output of a K-Means method like // the one illustrated in section \ref{sec:KMeansClassifier}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char LabelPixelType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader LabelReaderType; LabelReaderType::Pointer labelReader = LabelReaderType::New(); labelReader->SetFileName(inputLabelImageFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the Markov Random Field algorithm is defined in general for images // whose pixels have multiple components, that is, images of vector type, we // must adapt our scalar image in order to satisfy the interface expected by // the \code{MRFImageFilter}. We do this by using the // \doxygen{itk}{ScalarToArrayCastImageFilter}. With this filter we will present our // scalar image as a vector image whose vector pixels contain a single // component. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::FixedArray ArrayPixelType; typedef otb::Image ArrayImageType; typedef itk::ComposeImageFilter< ImageType, ArrayImageType> ScalarToArrayFilterType; ScalarToArrayFilterType::Pointer scalarToArrayFilter = ScalarToArrayFilterType::New(); scalarToArrayFilter->SetInput(0, reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // With the input image type \code{ImageType} and labeled image type // \code{LabelImageType} we instantiate the type of the // \doxygen{itk}{MRFImageFilter} that will apply the Markov Random Field algorithm // in order to refine the pixel classification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MRFImageFilter MRFFilterType; MRFFilterType::Pointer mrfFilter = MRFFilterType::New(); mrfFilter->SetInput(scalarToArrayFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set now some of the parameters for the MRF filter. In particular, the // number of classes to be used during the classification, the maximum number // of iterations to be run in this filter and the error tolerance that will be // used as a criterion for convergence. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet mrfFilter->SetNumberOfClasses(numberOfClasses); mrfFilter->SetMaximumNumberOfIterations(numberOfIterations); mrfFilter->SetErrorTolerance(1e-7); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The smoothing factor represents the tradeoff between fidelity to the // observed image and the smoothness of the segmented image. Typical smoothing // factors have values between 1~5. This factor will multiply the weights that // define the influence of neighbors on the classification of a given pixel. // The higher the value, the more uniform will be the regions resulting from // the classification refinement. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet mrfFilter->SetSmoothingFactor(smoothingFactor); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Given that the MRF filter needs to continually relabel the pixels, it needs // access to a set of membership functions that will measure to what degree // every pixel belongs to a particular class. The classification is performed // by the \doxygen{itk}{ImageClassifierBase} class, that is instantiated using the // type of the input vector image and the type of the labeled image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageClassifierBase< ArrayImageType, LabelImageType> SupervisedClassifierType; SupervisedClassifierType::Pointer classifier = SupervisedClassifierType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The classifier needs a decision rule to be set by the user. Note // that we must use \code{GetPointer()} in the call of the // \code{SetDecisionRule()} method because we are passing a // SmartPointer, and smart pointer cannot perform polymorphism, we // must then extract the raw pointer that is associated to the smart // pointer. This extraction is done with the GetPointer() method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::MinimumDecisionRule DecisionRuleType; DecisionRuleType::Pointer classifierDecisionRule = DecisionRuleType::New(); classifier->SetDecisionRule(classifierDecisionRule.GetPointer()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now instantiate the membership functions. In this case we use the // \subdoxygen{itk}{Statistics}{DistanceToCentroidMembershipFunction} class // templated over the pixel type of the vector image, which in our example // happens to be a vector of dimension 1. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::DistanceToCentroidMembershipFunction< ArrayPixelType> MembershipFunctionType; typedef MembershipFunctionType::Pointer MembershipFunctionPointer; double meanDistance = 0; MembershipFunctionType::CentroidType centroid(reader->GetOutput()->GetNumberOfComponentsPerPixel()); for (unsigned int i = 0; i < numberOfClasses; ++i) { MembershipFunctionPointer membershipFunction = MembershipFunctionType::New(); membershipFunction->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); centroid[0] = atof(argv[i + numberOfArgumentsBeforeMeans]); membershipFunction->SetCentroid(centroid); classifier->AddMembershipFunction(membershipFunction); meanDistance += static_cast (centroid[0]); } meanDistance /= numberOfClasses; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // and we set the neighborhood radius that will define the size of the clique // to be used in the computation of the neighbors' influence in the // classification of any given pixel. Note that despite the fact that we call // this a radius, it is actually the half size of an hypercube. That is, the // actual region of influence will not be circular but rather an N-Dimensional // box. For example, a neighborhood radius of 2 in a 3D image will result in a // clique of size 5x5x5 pixels, and a radius of 1 will result in a clique of // size 3x3x3 pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet mrfFilter->SetNeighborhoodRadius(1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We should now set the weights used for the neighbors. This is done by // passing an array of values that contains the linear sequence of weights for // the neighbors. For example, in a neighborhood of size 3x3x3, we should // provide a linear array of 9 weight values. The values are packaged in a // \code{std::vector} and are supposed to be \code{double}. The following lines // illustrate a typical set of values for a 3x3x3 neighborhood. The array is // arranged and then passed to the filter by using the method // \code{SetMRFNeighborhoodWeight()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::vector weights; weights.push_back(1.5); weights.push_back(2.0); weights.push_back(1.5); weights.push_back(2.0); weights.push_back(0.0); // This is the central pixel weights.push_back(2.0); weights.push_back(1.5); weights.push_back(2.0); weights.push_back(1.5); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We now scale weights so that the smoothing function and the image fidelity // functions have comparable value. This is necessary since the label // image and the input image can have different dynamic ranges. The fidelity // function is usually computed using a distance function, such as the // \doxygen{itk}{DistanceToCentroidMembershipFunction} or one of the other // membership functions. They tend to have values in the order of the means // specified. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double totalWeight = 0; for (std::vector::const_iterator wcIt = weights.begin(); wcIt != weights.end(); ++wcIt) { totalWeight += *wcIt; } for (std::vector::iterator wIt = weights.begin(); wIt != weights.end(); wIt++) { *wIt = static_cast ((*wIt) * meanDistance / (2 * totalWeight)); } mrfFilter->SetMRFNeighborhoodWeight(weights); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the classifier class is connected to the Markov Random Fields filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet mrfFilter->SetClassifier(classifier); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output image produced by the \doxygen{itk}{MRFImageFilter} has the same pixel // type as the labeled input image. In the following lines we use the // \code{OutputImageType} in order to instantiate the type of a // \doxygen{otb}{ImageFileWriter}. Then create one, and connect it to the output of // the classification filter after passing it through an intensity rescaler // to rescale it to an 8 bit dynamic range // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef MRFFilterType::OutputImageType OutputImageType; // Software Guide : EndCodeSnippet // Rescale outputs to the dynamic range of the display typedef otb::Image RescaledOutputImageType; typedef itk::RescaleIntensityImageFilter< OutputImageType, RescaledOutputImageType> RescalerType; RescalerType::Pointer intensityRescaler = RescalerType::New(); intensityRescaler->SetOutputMinimum(0); intensityRescaler->SetOutputMaximum(255); intensityRescaler->SetInput(mrfFilter->GetOutput()); // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(intensityRescaler->GetOutput()); writer->SetFileName(outputImageFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We are now ready for triggering the execution of the pipeline. This is done // by simply invoking the \code{Update()} method in the writer. This call will // propagate the update request to the reader and then to the MRF filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Problem encountered while writing "; std::cerr << " image file : " << argv[2] << std::endl; std::cerr << excp << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet std::cout << "Number of Iterations : "; std::cout << mrfFilter->GetNumberOfIterations() << std::endl; std::cout << "Stop condition: " << std::endl; std::cout << " (1) Maximum number of iterations " << std::endl; std::cout << " (2) Error tolerance: " << std::endl; std::cout << mrfFilter->GetStopCondition() << std::endl; // Software Guide : BeginLatex // // \begin{figure} \center // \includegraphics[width=0.44\textwidth]{ScalarImageMarkovRandomField1Output.eps} // \itkcaption[Output of the ScalarImageMarkovRandomField]{Effect of the // MRF filter.} // \label{fig:ScalarImageMarkovRandomFieldInputOutput} // \end{figure} // // Figure \ref{fig:ScalarImageMarkovRandomFieldInputOutput} // illustrates the effect of this filter with four classes. // In this example the filter was run with a smoothing factor of 3. // The labeled image was produced by ScalarImageKmeansClassifier.cxx // and the means were estimated by // ScalarImageKmeansModelEstimator.cxx described in section // \ref{sec:KMeansClassifier}. // The obtained result can be compared with the one of // figure~\ref{fig:ScalarImageKMeansClassifierOutput} to see the // interest of using the MRF approach in order to ensure the // regularization of the classified image. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/SupervisedImageClassificationExample.cxx000066400000000000000000000131521301006202600301410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // In OTB, a generic streamed filter called \doxygen{otb}{ImageClassificationFilter} // is available to classify any input multi-channel image according to an input // classification model file. This filter is generic because it works with any // classification model type (SVM, KNN, Artificial Neural Network,...) generated // within the OTB generic Machine Learning framework based on OpenCV (\cite{opencv_library}). // The input model file is smartly parsed according to its content in order to // identify which learning method was used to generate it. Once the classification // method and model are known, the input image can be classified. More details are // given in subsections \ref{ssec:LearningFromSamples} and \ref{ssec:LearningFromImages} // to generate a classification model either from samples or from images. // In this example we will illustrate its use. We start by including the // appropriate header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMachineLearningModelFactory.h" #include "otbImageClassificationFilter.h" // Software Guide : EndCodeSnippet #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * modelfname = argv[2]; const char * outfname = argv[3]; // Software Guide : BeginLatex // // We will assume double precision input images and will also define // the type for the labeled pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Our classifier is generic enough to be able to process images // with any number of bands. We read the input image as a // \doxygen{otb}{VectorImage}. The labeled image will be a scalar image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the classifier filter, which is // templated over its input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::ModelType ModelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Moreover, it is necessary to define a \doxygen{otb}{MachineLearningModelFactory} // which is templated over its input and output pixel types. This factory is used // to parse the input model file and to define which classification method to use. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MachineLearningModelFactory MachineLearningModelFactoryType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we define the reader and the writer. Since the images // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the classifier. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the classifier and the reader objects and we set // the existing model obtained in a previous training step. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input model file is parsed according to its content and the generated model // is then loaded within the \doxygen{otb}{ImageClassificationFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ModelType::Pointer model; model = MachineLearningModelFactoryType::CreateMachineLearningModel( modelfname, MachineLearningModelFactoryType::ReadMode); model->Load(modelfname); filter->SetModel(model); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline and // trigger its execution by updating the output of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Classification/test/000077500000000000000000000000001301006202600211065ustar00rootroot00000000000000OTB-release-5.8/Examples/Classification/test/CMakeLists.txt000066400000000000000000000031571301006202600236540ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Classification) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- ScalarImageMarkovRandomField1Test---------- otb_add_test(NAME clTeScalarImageMarkovRandomField1Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ScalarImageMarkovRandomField1Output.png ${TEMP}/ScalarImageMarkovRandomField1Output.png Execute $ ${INPUTDATA}/QB_Suburb.png ${INPUTDATA}/QB_Suburb_labelled.png ${TEMP}/ScalarImageMarkovRandomField1Output.png 50 3 4 79.5097 138.136 213.846 25.9395 ) # ------- ScalarImageKmeansClassifierTest---------- otb_add_test(NAME clTeScalarImageKmeansClassifierTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/QB_Suburb_labelled.png ${TEMP}/QB_Suburb_labelled.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/QB_Suburb_labelled.png 0 4 79.5097 138.136 213.846 25.9395 ) otb_add_test(NAME clTeNeighborhoodMajorityVotingImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${OTB_DATA_ROOT}/Baseline/OTB/Images/QB_1_ortho_4Cls_N_Classified_OTB_NMV_x2_y5_nodv10_undv7.tif ${TEMP}/QB_1_ortho_4Cls_N_Classified_OTB_NMV_x2_y5_nodv10_undv7_EX.tif Execute $ ${OTB_DATA_ROOT}/Input/Classification/QB_1_ortho_4Cls_N_Classified_OTB.tif ${TEMP}/QB_1_ortho_4Cls_N_Classified_OTB_NMV_x2_y5_nodv10_undv7_EX.tif false #KeepOriginalLabelBool 2 #xRadius 5 #yRadius 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels ) OTB-release-5.8/Examples/DataRepresentation/000077500000000000000000000000001301006202600207705ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/CMakeLists.txt000066400000000000000000000001441301006202600235270ustar00rootroot00000000000000add_subdirectory(Containers) add_subdirectory(Image) add_subdirectory(Mesh) add_subdirectory(Path) OTB-release-5.8/Examples/DataRepresentation/Containers/000077500000000000000000000000001301006202600230755ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Containers/CMakeLists.txt000066400000000000000000000002701301006202600256340ustar00rootroot00000000000000project(ContainersExamples) add_executable(TreeContainer TreeContainer.cxx ) target_link_libraries(TreeContainer ${ITK_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/DataRepresentation/Containers/TreeContainer.cxx000066400000000000000000000225261301006202600263720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // \index{itk::TreeContainer} // // This example shows how to use the \doxygen{itk}{TreeContainer} and the // associated TreeIterators. // The \doxygen{itk}{TreeContainer} implements the notion of tree and is // templated over the type of node so it can virtually handle any // objects. Each node is supposed to have only one parent so no cycle // is present in the tree. No checking is done to ensure a cycle-free // tree. // // Let's begin by including the appropriate header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include #include "itkTreeContainer.h" #include "itkChildTreeIterator.h" #include "itkLeafTreeIterator.h" #include "itkLevelOrderTreeIterator.h" #include "itkInOrderTreeIterator.h" #include "itkPostOrderTreeIterator.h" #include "itkRootTreeIterator.h" #include "itkTreeIteratorClone.h" // Software Guide : EndCodeSnippet int main(int, char*[]) { // Software Guide : BeginLatex // First, we create a tree of integers. // The TreeContainer is templated over the type of nodes. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef int NodeType; typedef itk::TreeContainer TreeType; TreeType::Pointer tree = TreeType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Next we set the value of the root node using \code{SetRoot()}. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet tree->SetRoot(0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Then we use the \code{Add()} function to add nodes to the tree // The first argument is the value of the new node and the second // argument is the value of the parent node. If two nodes have // the same values then the first one is picked. In this particular // case it is better to use an iterator to fill the tree. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet tree->Add(1, 0); tree->Add(2, 0); tree->Add(3, 0); tree->Add(4, 2); tree->Add(5, 2); tree->Add(6, 5); tree->Add(7, 1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We define an \doxygen{itk}{LevelOrderTreeIterator} to parse the tree in level order. // This particular iterator takes three arguments. The first one is the actual tree // to be parsed, the second one is the maximum depth level and the third one is the // starting node. The \code{GetNode()} function return a node given its value. Once // again the first node that corresponds to the value is returned. // Software Guide : EndLatex std::cout << "LevelOrderTreeIterator:" << std::endl; // Software Guide : BeginCodeSnippet itk::LevelOrderTreeIterator levelIt(tree, 10, tree->GetNode(2)); levelIt.GoToBegin(); while (!levelIt.IsAtEnd()) { std::cout << levelIt.Get() << " (" << levelIt.GetLevel() << ")" << std::endl; ++levelIt; } std::cout << std::endl; // Software Guide : EndCodeSnippet levelIt.GoToBegin(); // Software Guide : BeginLatex // The TreeIterators have useful functions to test the property of the current // pointed node. Among these functions: \code{IsLeaf{}} returns true if the current // node is a leaf, \code{IsRoot{}} returns true if the node is a root, // \code{HasParent{}} returns true if the node has a parent and // \code{CountChildren{}} returns the number of children for this particular node. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet levelIt.IsLeaf(); levelIt.IsRoot(); levelIt.HasParent(); levelIt.CountChildren(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{itk}{ChildTreeIterator} provides another way to iterate through a tree // by listing all the children of a node. // Software Guide : EndLatex std::cout << "ChildTreeIterator:" << std::endl; // Software Guide : BeginCodeSnippet itk::ChildTreeIterator childIt(tree); childIt.GoToBegin(); while (!childIt.IsAtEnd()) { std::cout << childIt.Get() << std::endl; ++childIt; } std::cout << std::endl; // Software Guide : EndCodeSnippet childIt.GoToBegin(); // Software Guide : BeginLatex // The \code{GetType()} function returns the type of iterator used. // The list of enumerated types is as follow: // PREORDER, INORDER, POSTORDER, LEVELORDER, CHILD, ROOT and LEAF. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (childIt.GetType() != itk::TreeIteratorBase::CHILD) { std::cout << "[FAILURE]" << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Every TreeIterator has a \code{Clone()} function which returns // a copy of the current iterator. Note that the user should delete // the created iterator by hand. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet childIt.GoToParent(); itk::TreeIteratorBase* childItClone = childIt.Clone(); delete childItClone; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{itk}{LeafTreeIterator} iterates through the leaves of the tree. // Software Guide : EndLatex std::cout << "LeafTreeIterator:" << std::endl; // Software Guide : BeginCodeSnippet itk::LeafTreeIterator leafIt(tree); leafIt.GoToBegin(); while (!leafIt.IsAtEnd()) { std::cout << leafIt.Get() << std::endl; ++leafIt; } std::cout << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{itk}{InOrderTreeIterator} iterates through the tree // in the order from left to right. // Software Guide : EndLatex std::cout << "InOrderTreeIterator:" << std::endl; // Software Guide : BeginCodeSnippet itk::InOrderTreeIterator InOrderIt(tree); InOrderIt.GoToBegin(); while (!InOrderIt.IsAtEnd()) { std::cout << InOrderIt.Get() << std::endl; ++InOrderIt; } std::cout << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{itk}{PreOrderTreeIterator} iterates through the tree // from left to right but do a depth first search. // Software Guide : EndLatex std::cout << "PreOrderTreeIterator:" << std::endl; // Software Guide : BeginCodeSnippet itk::PreOrderTreeIterator PreOrderIt(tree); PreOrderIt.GoToBegin(); while (!PreOrderIt.IsAtEnd()) { std::cout << PreOrderIt.Get() << std::endl; ++PreOrderIt; } std::cout << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{itk}{PostOrderTreeIterator} iterates through the tree // from left to right but goes from the leaves to the root in the search. // Software Guide : EndLatex std::cout << "PostOrderTreeIterator:" << std::endl; // Software Guide : BeginCodeSnippet itk::PostOrderTreeIterator PostOrderIt(tree); PostOrderIt.GoToBegin(); while (!PostOrderIt.IsAtEnd()) { std::cout << PostOrderIt.Get() << std::endl; ++PostOrderIt; } std::cout << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{itk}{RootTreeIterator} goes from one node to the // root. The second arguments is the starting node. Here we go from the leaf // node (value = 6) up to the root. // Software Guide : EndLatex std::cout << "RootTreeIterator:" << std::endl; // Software Guide : BeginCodeSnippet itk::RootTreeIterator RootIt(tree, tree->GetNode(6)); RootIt.GoToBegin(); while (!RootIt.IsAtEnd()) { std::cout << RootIt.Get() << std::endl; ++RootIt; } std::cout << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // All the nodes of the tree can be removed by using the // \code{Clear()} function. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet tree->Clear(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We show how to use a TreeIterator to form a tree by creating nodes. // The \code{Add()} function is used to add a node and put a value on it. // The \code{GoToChild()} is used to jump to a node. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet itk::PreOrderTreeIterator PreOrderIt2(tree); PreOrderIt2.Add(0); PreOrderIt2.Add(1); PreOrderIt2.Add(2); PreOrderIt2.Add(3); PreOrderIt2.GoToChild(2); PreOrderIt2.Add(4); PreOrderIt2.Add(5); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{itk}{TreeIteratorClone} can be used to have a generic copy of // an iterator. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::TreeIteratorBase IteratorType; typedef itk::TreeIteratorClone IteratorCloneType; itk::PreOrderTreeIterator anIterator(tree); IteratorCloneType aClone = anIterator; // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Containers/test/000077500000000000000000000000001301006202600240545ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Containers/test/CMakeLists.txt000066400000000000000000000000001301006202600266020ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Image/000077500000000000000000000000001301006202600220125ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Image/CMakeLists.txt000066400000000000000000000024141301006202600245530ustar00rootroot00000000000000project(ImageExamples) add_executable(Image1 Image1.cxx ) target_link_libraries(Image1 ${OTB_LIBRARIES}) add_executable(Image2 Image2.cxx ) target_link_libraries(Image2 ${OTB_LIBRARIES}) add_executable(Image3 Image3.cxx ) target_link_libraries(Image3 ${OTB_LIBRARIES}) add_executable(Image4 Image4.cxx ) target_link_libraries(Image4 ${OTB_LIBRARIES}) add_executable(Image5 Image5.cxx ) target_link_libraries(Image5 ${OTB_LIBRARIES}) add_executable(Image6 Image6.cxx ) target_link_libraries(Image6 ${OTB_LIBRARIES} ) add_executable(RGBImage RGBImage.cxx ) target_link_libraries(RGBImage ${OTB_LIBRARIES}) add_executable(VectorImage VectorImage.cxx ) target_link_libraries(VectorImage ${OTB_LIBRARIES}) add_executable(ImageAdaptor1 ImageAdaptor1.cxx ) target_link_libraries(ImageAdaptor1 ${OTB_LIBRARIES}) add_executable(ImageAdaptor2 ImageAdaptor2.cxx ) target_link_libraries(ImageAdaptor2 ${OTB_LIBRARIES}) add_executable(ImageAdaptor3 ImageAdaptor3.cxx ) target_link_libraries(ImageAdaptor3 ${OTB_LIBRARIES}) add_executable(ImageAdaptor4 ImageAdaptor4.cxx ) target_link_libraries(ImageAdaptor4 ${OTB_LIBRARIES}) add_executable(ImageListExample ImageListExample.cxx ) target_link_libraries(ImageListExample ${OTB_LIBRARIES} ) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/DataRepresentation/Image/Image1.cxx000066400000000000000000000136641301006202600236530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how to manually construct an \doxygen{otb}{Image} // class. The following is the minimal code needed to instantiate, declare // and create the image class. // // \index{Image!Instantiation} // \index{Image!Header} // // First, the header file of the Image class must be included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { // Software Guide : BeginLatex // // Then we must decide with what type to represent the pixels // and what the dimension of the image will be. With these two // parameters we can instantiate the image class. Here we create // a 2D image, which is what we often use in remote sensing // applications, anyway, with \code{unsigned short} pixel data. // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image can then be created by invoking the \code{New()} operator // from the corresponding image type and assigning the result // to a \doxygen{itk}{SmartPointer}. // // \index{Image!Pointer} // \index{Image!New()} // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet ImageType::Pointer image = ImageType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In OTB, images exist in combination with one or more // \emph{regions}. A region is a subset of the image and indicates a // portion of the image that may be processed by other classes in // the system. One of the most common regions is the // \emph{LargestPossibleRegion}, which defines the image in its // entirety. Other important regions found in OTB are the // \emph{BufferedRegion}, which is the portion of the image actually // maintained in memory, and the \emph{RequestedRegion}, which is // the region requested by a filter or other class when operating on // the image. // // In OTB, manually creating an image requires that the image is // instantiated as previously shown, and that regions describing the image are // then associated with it. // // A region is defined by two classes: the \doxygen{itk}{Index} and // \doxygen{itk}{Size} classes. The origin of the region within the // image with which it is associated is defined by Index. The // extent, or size, of the region is defined by Size. Index // is represented by a n-dimensional array where each component is an // integer indicating---in topological image coordinates---the initial // pixel of the image. When an image is created manually, the user is // responsible for defining the image size and the index at which the image // grid starts. These two parameters make it possible to process selected // regions. // // The starting point of the image is defined by an Index class // that is an n-dimensional array where each component is an integer // indicating the grid coordinates of the initial pixel of the image. // // \index{Image!Size} // \index{Image!SizeType} // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet ImageType::IndexType start; start[0] = 0; // first index on X start[1] = 0; // first index on Y // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The region size is represented by an array of the same dimension of the // image (using the Size class). The components of the array are // unsigned integers indicating the extent in pixels of the image along // every dimension. // // \index{Image!Index} // \index{Image!IndexType} // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet ImageType::SizeType size; size[0] = 200; // size along X size[1] = 200; // size along Y // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Having defined the starting index and the image size, these two // parameters are used to create an ImageRegion object which basically // encapsulates both concepts. The region is initialized with the // starting index and size of the image. // // \index{Image!itk::ImageRegion} // \index{Image!RegionType} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the region is passed to the \code{Image} object in // order to define its extent and origin. The \code{SetRegions} // method sets the LargestPossibleRegion, BufferedRegion, and // RequestedRegion simultaneously. Note that none of the operations // performed to this point have allocated memory for the image pixel // data. It is necessary to invoke the \code{Allocate()} method to // do this. Allocate does not require any arguments since all the // information needed for memory allocation has already been // provided by the region. // // \index{Image!Allocate()} // \index{Image!SetRegions()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet image->SetRegions(region); image->Allocate(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/Image2.cxx000066400000000000000000000127021301006202600236440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" // Software Guide : BeginLatex // // The first thing required to read an image from a file is to include // the header file of the \doxygen{otb}{ImageFileReader} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" // Software Guide : EndCodeSnippet int main(int, char * argv[]) { // Software Guide : BeginLatex // // Then, the image type should be defined by specifying the // type used to represent pixels and the dimensions of the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Using the image type, it is now possible to instantiate the image reader // class. The image type is used as a template parameter to define how the // data will be represented once it is loaded into memory. This type does // not have to correspond exactly to the type stored in the file. However, // a conversion based on C-style type casting is used, so the type chosen // to represent the data on disk must be sufficient to characterize it // accurately. Readers do not apply any transformation to the pixel data // other than casting from the pixel type of the file to the pixel type of // the ImageFileReader. The following illustrates a typical // instantiation of the ImageFileReader type. // // \index{otb::ImageFileReader!Instantiation} // \index{otb::Image!read} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The reader type can now be used to create one reader object. A // \doxygen{itk}{SmartPointer} (defined by the \code{::Pointer} // notation) is used to receive the reference to the newly created // reader. The \code{New()} // method is invoked to create an instance of the image reader. // // \index{otb::ImageFileReader!New()} // \index{otb::ImageFileReader!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The minimum information required by the reader is the filename // of the image to be loaded in memory. This is provided through // the \code{SetFileName()} method. The file format here is inferred // from the filename extension. The user may also explicitly specify the // data format explicitly using the \doxygen{itk}{ImageIO} (See // Chapter~\ref{sec:ImagReadWrite} \pageref{sec:ImagReadWrite} for more // information): // // \index{otb::ImageFileReader!SetFileName()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const char * filename = argv[1]; reader->SetFileName(filename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Reader objects are referred to as pipeline source objects; they // respond to pipeline update requests and initiate the data flow in the // pipeline. The pipeline update mechanism ensures that the reader only // executes when a data request is made to the reader and the reader has // not read any data. In the current example we explicitly invoke the // \code{Update()} method because the output of the reader is not connected // to other filters. In normal application the reader's output is connected // to the input of an image filter and the update invocation on the filter // triggers an update of the reader. The following line illustrates how an // explicit update is invoked on the reader. // // \index{otb::ImageFileReader!Update()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Access to the newly read image can be gained by calling the // \code{GetOutput()} method on the reader. This method can also be called // before the update request is sent to the reader. The reference to the // image will be valid even though the image will be empty until the reader // actually executes. // // \index{otb::ImageFileReader!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer image = reader->GetOutput(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Any attempt to access image data before the reader executes will yield // an image with no pixel data. It is likely that a program crash will // result since the image will not have been properly initialized. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/Image3.cxx000066400000000000000000000110511301006202600236410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the use of the \code{SetPixel()} and // \code{GetPixel()} methods. These two methods provide direct access to the // pixel data contained in the image. Note that these two methods are // relatively slow and should not be used in situations where // high-performance access is required. Image iterators are the appropriate // mechanism to efficiently access image pixel data. %(See // %Chapter~\ref{sec:ImageIteratorsChapter} on page // %\pageref{sec:ImageIteratorsChapter} for information about image // %iterators.) // // Software Guide : EndLatex #include "otbImage.h" int main(int, char *[]) { // First the image type should be declared typedef otb::Image ImageType; // Then the image object can be created ImageType::Pointer image = ImageType::New(); // The image region should be initialized ImageType::IndexType start; ImageType::SizeType size; size[0] = 200; // size along X size[1] = 200; // size along Y start[0] = 0; // first index on X start[1] = 0; // first index on Y ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); // Pixel data is allocated image->SetRegions(region); image->Allocate(); // The image buffer is initialized to a particular value ImageType::PixelType initialValue = 0; image->FillBuffer(initialValue); // Software Guide : BeginLatex // // The individual position of a pixel inside the image is identified by a // unique index. An index is an array of integers that defines the position // of the pixel along each coordinate dimension of the image. The IndexType // is automatically defined by the image and can be accessed using the // scope operator like \doxygen{itk}{Index}. The length of the array will match // the dimensions of the associated image. // // The following code illustrates the declaration of an index variable and // the assignment of values to each of its components. Please note that // \code{Index} does not use SmartPointers to access it. This is because // \code{Index} is a light-weight object that is not intended to be shared // between objects. It is more efficient to produce multiple copies of // these small objects than to share them using the SmartPointer // mechanism. // // The following lines declare an instance of the index type and initialize // its content in order to associate it with a pixel position in the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType pixelIndex; pixelIndex[0] = 27; // x position pixelIndex[1] = 29; // y position // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Having defined a pixel position with an index, it is then possible to // access the content of the pixel in the image. The \code{GetPixel()} // method allows us to get the value of the pixels. // // \index{otb::Image!GetPixel()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::PixelType pixelValue = image->GetPixel(pixelIndex); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{SetPixel()} method allows us to set the value of the pixel. // // \index{otb::Image!SetPixel()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet image->SetPixel(pixelIndex, pixelValue + 1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Please note that \code{GetPixel()} returns the pixel value using copy // and not reference semantics. Hence, the method cannot be used to // modify image data values. // // Remember that both \code{SetPixel()} and \code{GetPixel()} are inefficient // and should only be used for debugging or for supporting interactions like // querying pixel values by clicking with the mouse. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/Image4.cxx000066400000000000000000000242721301006202600236530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Even though OTB can be used to perform // general image processing tasks, the primary purpose of the toolkit is the // processing of remote sensing image data. In that respect, additional // information about the images is considered mandatory. In particular the // information associated with the physical spacing between pixels and the // position of the image in space with respect to some world coordinate // system are extremely important. // // Image origin and spacing are fundamental to many // applications. Registration, for example, is performed in physical // coordinates. Improperly defined spacing and origins will result in // inconsistent results in such processes. Remote sensing images with no spatial // information should not be used for image analysis, // feature extraction, GIS input, etc. In // other words, remote sensing images lacking spatial information are not only // useless but also hazardous. // // \begin{figure} \center // \includegraphics[width=\textwidth]{ImageOriginAndSpacing.eps} // \itkcaption[OTB Image Geometrical Concepts]{Geometrical concepts associated // with the OTB image.} // \label{fig:ImageOriginAndSpacing} // \end{figure} // // Figure \ref{fig:ImageOriginAndSpacing} illustrates the main geometrical // concepts associated with the \doxygen{otb}{Image}. In this figure, // circles are // used to represent the center of pixels. The value of the pixel is assumed // to exist as a Dirac Delta Function located at the pixel center. Pixel // spacing is measured between the pixel centers and can be different along // each dimension. The image origin is associated with the coordinates of the // first pixel in the image. A \emph{pixel} is considered to be the // rectangular region surrounding the pixel center holding the data // value. This can be viewed as the Voronoi region of the image grid, as // illustrated in the right side of the figure. Linear interpolation of // image values is performed inside the Delaunay region whose corners // are pixel centers. // // Software Guide : EndLatex #include "otbImage.h" #include "itkPoint.h" int main(int, char *[]) { typedef otb::Image ImageType; ImageType::Pointer image = ImageType::New(); ImageType::IndexType start; ImageType::SizeType size; size[0] = 200; // size along X size[1] = 200; // size along Y start[0] = 0; // first index on X start[1] = 0; // first index on Y ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); // Software Guide : BeginLatex // // Image spacing is represented in a \code{FixedArray} // whose size matches the dimension of the image. In order to manually set // the spacing of the image, an array of the corresponding type must be // created. The elements of the array should then be initialized with the // spacing between the centers of adjacent pixels. The following code // illustrates the methods available in the Image class for dealing with // spacing and origin. // // \index{otb::Image!Spacing} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::SpacingType spacing; // Note: measurement units (e.g., meters, feet, etc.) are defined by the application. spacing[0] = 0.70; // spacing along X spacing[1] = 0.70; // spacing along Y // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The array can be assigned to the image using // the \code{SetSpacing()} method. // // \index{otb::Image!SetSpacing()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet image->SetSpacing(spacing); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The spacing information can be retrieved from an image by using the // \code{GetSpacing()} method. This method returns a reference to a // \code{FixedArray}. The returned object can then be used to read the // contents of the array. Note the use of the \code{const} keyword to indicate // that the array will not be modified. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const ImageType::SpacingType& sp = image->GetSpacing(); std::cout << "Spacing = "; std::cout << sp[0] << ", " << sp[1] << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image origin is managed in a similar way to the spacing. A // \code{Point} of the appropriate dimension must first be // allocated. The coordinates of the origin can then be assigned to // every component. These coordinates correspond to the position of // the first pixel of the image with respect to an arbitrary // reference system in physical space. It is the user's // responsibility to make sure that multiple images used in the same // application are using a consistent reference system. This is // extremely important in image registration applications. // // The following code illustrates the creation and assignment of a variable // suitable for initializing the image origin. // // \index{otb::Image!origin} // \index{otb::Image!SetOrigin()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::PointType origin; origin[0] = 0.0; // coordinates of the origin[1] = 0.0; // first pixel in 2-D image->SetOrigin(origin); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The origin can also be retrieved from an image by using the // \code{GetOrigin()} method. This will return a reference to a // \code{Point}. The reference can be used to read the contents of // the array. Note again the use of the \code{const} keyword to indicate // that the array contents will not be modified. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const ImageType::PointType& orgn = image->GetOrigin(); std::cout << "Origin = "; std::cout << orgn[0] << ", " << orgn[1] << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the spacing and origin of the image have been initialized, the image // will correctly map pixel indices to and from physical space // coordinates. The following code illustrates how a point in physical // space can be mapped into an image index for the purpose of reading the // content of the closest pixel. // // First, a \doxygen{itk}{Point} type must be declared. The point type is // templated over the type used to represent coordinates and over the // dimension of the space. In this particular case, the dimension of the // point must match the dimension of the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Point PointType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The Point class, like an \doxygen{itk}{Index}, is a relatively small and // simple object. For this reason, it is not reference-counted like the // large data objects in OTB. Consequently, it is also not manipulated // with \doxygen{itk}{SmartPointer}s. Point objects are simply declared as // instances of any other C++ class. Once the point is declared, its // components can be accessed using traditional array notation. In // particular, the \code{[]} operator is available. For efficiency reasons, // no bounds checking is performed on the index used to access a particular // point component. It is the user's responsibility to make sure that the // index is in the range $\{0, Dimension-1\}$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointType point; point[0] = 1.45; // x coordinate point[1] = 7.21; // y coordinate // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image will map the point to an index using the values of the // current spacing and origin. An index object must be provided to // receive the results of the mapping. The index object can be // instantiated by using the \code{IndexType} defined in the Image // type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType pixelIndex; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{TransformPhysicalPointToIndex()} method of the image class // will compute the pixel index closest to the point provided. The method // checks for this index to be contained inside the current buffered pixel // data. The method returns a boolean indicating whether the resulting // index falls inside the buffered region or not. The output index should // not be used when the returned value of the method is \code{false}. // // The following lines illustrate the point to index mapping and the // subsequent use of the pixel index for accessing pixel data from the // image. // // \index{otb::Image!TransformPhysicalPointToIndex()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet bool isInside = image->TransformPhysicalPointToIndex(point, pixelIndex); if (isInside) { ImageType::PixelType pixelValue = image->GetPixel(pixelIndex); pixelValue += 5; image->SetPixel(pixelIndex, pixelValue); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Remember that \code{GetPixel()} and \code{SetPixel()} are very // inefficient methods for accessing pixel data. Image iterators should be // used when massive access to pixel data is required. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/Image5.cxx000066400000000000000000000213211301006202600236440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how to import data into the \doxygen{otb}{Image} // class. This is particularly useful for interfacing with other software // systems. Many systems use a contiguous block of memory as a buffer // for image pixel data. The current example assumes this is the case and // feeds the buffer into an \doxygen{otb}{ImportImageFilter}, thereby producing an // Image as output. // // For fun we create a synthetic image with a centered sphere in // a locally allocated buffer and pass this block of memory to the // ImportImageFilter. This example is set up so that on execution, the // user must provide the name of an output file as a command-line argument. // // \index{otb::ImportImageFilter!Instantiation} // \index{otb::ImportImageFilter!Header} // // First, the header file of the ImportImageFilter class must be // included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbImportImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileWriter.h" #include "itkRGBPixel.h" int main(int argc, char * argv[]) { if (argc < 2) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " outputImageFile" << std::endl; return 1; } // Software Guide : BeginLatex // // Next, we select the data type to use to represent the image pixels. We // assume that the external block of memory uses the same data type to // represent the pixels. // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The type of the ImportImageFilter is instantiated in the // following line. // // \index{otb::ImportImageFilter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImportImageFilter ImportFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A filter object created using the \code{New()} method is then // assigned to a \code{SmartPointer}. // // \index{otb::ImportImageFilter!Pointer} // \index{otb::ImportImageFilter!New()} // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet ImportFilterType::Pointer importFilter = ImportFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // This filter requires the user to specify the size of the image to be // produced as output. The \code{SetRegion()} method is used to this end. // The image size should exactly match the number of pixels available in the // locally allocated buffer. // // \index{otb::ImportImageFilter!SetRegion()} // \index{otb::ImportImageFilter!New()} // \index{otb::ImportImageFilter!New()} // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet ImportFilterType::SizeType size; size[0] = 200; // size along X size[1] = 200; // size along Y ImportFilterType::IndexType start; start.Fill(0); ImportFilterType::RegionType region; region.SetIndex(start); region.SetSize(size); importFilter->SetRegion(region); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The origin of the output image is specified with the \code{SetOrigin()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double origin[Dimension]; origin[0] = 0.0; // X coordinate origin[1] = 0.0; // Y coordinate importFilter->SetOrigin(origin); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The spacing of the image is passed with the \code{SetSpacing()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double spacing[Dimension]; spacing[0] = 1.0; // along X direction spacing[1] = 1.0; // along Y direction importFilter->SetSpacing(spacing); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we allocate the memory block containing the pixel data to be // passed to the ImportImageFilter. Note that we use exactly the // same size that was specified with the \code{SetRegion()} method. In a // practical application, you may get this buffer from some other library // using a different data structure to represent the images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // MODIFIED const unsigned int numberOfPixels = size[0] * size[1]; PixelType * localBuffer = new PixelType[numberOfPixels]; // Software Guide : EndCodeSnippet const double radius = 80.0; // Software Guide : BeginLatex // // Here we fill up the buffer with a binary sphere. We use simple // \code{for()} loops here similar to those found in the C or FORTRAN // programming languages. Note that otb // does not use \code{for()} loops in its internal code to access // pixels. All pixel access tasks are instead performed using // \doxygen{otb}{ImageIterator}s that support the management of // n-dimensional images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const double radius2 = radius * radius; PixelType * it = localBuffer; for (unsigned int y = 0; y < size[1]; y++) { const double dy = static_cast(y) - static_cast(size[1]) / 2.0; for (unsigned int x = 0; x < size[0]; x++) { const double dx = static_cast(x) - static_cast(size[0]) / 2.0; const double d2 = dx * dx + dy * dy; *it++ = (d2 < radius2) ? 255 : 0; } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The buffer is passed to the ImportImageFilter with the // \code{SetImportPointer()}. Note that the last argument of this method // specifies who will be responsible for deleting the memory block once it // is no longer in use. A \code{false} value indicates that the // ImportImageFilter will not try to delete the buffer when its // destructor is called. A \code{true} value, on the other hand, will allow the // filter to delete the memory block upon destruction of the import filter. // // For the ImportImageFilter to appropriately delete the // memory block, the memory must be allocated with the C++ // \code{new()} operator. Memory allocated with other memory // allocation mechanisms, such as C \code{malloc} or \code{calloc}, will not // be deleted properly by the ImportImageFilter. In // other words, it is the application programmer's responsibility // to ensure that ImportImageFilter is only given // permission to delete the C++ \code{new} operator-allocated memory. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const bool importImageFilterWillOwnTheBuffer = true; importFilter->SetImportPointer(localBuffer, numberOfPixels, importImageFilterWillOwnTheBuffer); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we can connect the output of this filter to a pipeline. // For simplicity we just use a writer here, but it could be any other filter. // // Software Guide : EndLatex typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[1]); // Software Guide : BeginCodeSnippet writer->SetInput(dynamic_cast(importFilter->GetOutput())); // Software Guide : EndCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& exp) { std::cerr << "Exception caught !" << std::endl; std::cerr << exp << std::endl; return -1; } // Software Guide : BeginLatex // // Note that we do not call \code{delete} on the buffer since we pass // \code{true} as the last argument of \code{SetImportPointer()}. Now the // buffer is owned by the ImportImageFilter. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/Image6.cxx000066400000000000000000000220041301006202600236440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how to import data into the \doxygen{otb}{Image} // class. This is particularly useful for interfacing with other software // systems. Many systems use a contiguous block of memory as a buffer // for image pixel data. The current example assumes this is the case and // feeds the buffer into an \doxygen{otb}{ImportImageFilter}, thereby producing an // Image as output. // // For fun we create a synthetic image with a centered sphere in // a locally allocated buffer and pass this block of memory to the // ImportImageFilter. This example is set up so that on execution, the // user must provide the name of an output file as a command-line argument. // // \index{otb::ImportImageFilter!Instantiation} // \index{otb::ImportImageFilter!Header} // // First, the header file of the ImportImageFilter class must be // included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbVectorImage.h" #include "otbImportVectorImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileWriter.h" #include "itkRGBPixel.h" int main(int argc, char * argv[]) { if (argc < 2) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " outputImageFile" << std::endl; return 1; } // Software Guide : BeginLatex // // Next, we select the data type to use to represent the image pixels. We // assume that the external block of memory uses the same data type to // represent the pixels. // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; const unsigned int Dimension = 2; unsigned int numberOfBands = 5; typedef otb::VectorImage ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The type of the ImportImageFilter is instantiated in the // following line. // // \index{otb::ImportImageFilter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImportVectorImageFilter ImportFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A filter object created using the \code{New()} method is then // assigned to a \code{SmartPointer}. // // \index{otb::ImportImageFilter!Pointer} // \index{otb::ImportImageFilter!New()} // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet ImportFilterType::Pointer importFilter = ImportFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // This filter requires the user to specify the size of the image to be // produced as output. The \code{SetRegion()} method is used to this end. // The image size should exactly match the number of pixels available in the // locally allocated buffer. // // \index{otb::ImportImageFilter!SetRegion()} // \index{otb::ImportImageFilter!New()} // \index{otb::ImportImageFilter!New()} // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet ImportFilterType::SizeType size; size[0] = 200; // size along X size[1] = 200; // size along Y ImportFilterType::IndexType start; start.Fill(0); ImportFilterType::RegionType region; region.SetIndex(start); region.SetSize(size); importFilter->SetRegion(region); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The origin of the output image is specified with the \code{SetOrigin()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double origin[Dimension]; origin[0] = 0.0; // X coordinate origin[1] = 0.0; // Y coordinate importFilter->SetOrigin(origin); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The spacing of the image is passed with the \code{SetSpacing()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double spacing[Dimension]; spacing[0] = 1.0; // along X direction spacing[1] = 1.0; // along Y direction importFilter->SetSpacing(spacing); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we allocate the memory block containing the pixel data to be // passed to the ImportImageFilter. Note that we use exactly the // same size that was specified with the \code{SetRegion()} method. In a // practical application, you may get this buffer from some other library // using a different data structure to represent the images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // MODIFIED const unsigned int numberOfPixels = size[0] * size[1] * numberOfBands; PixelType * localBuffer = new PixelType[numberOfPixels]; // Software Guide : EndCodeSnippet const double radius = 80.0; // Software Guide : BeginLatex // // Here we fill up the buffer with a binary sphere. We use simple // \code{for()} loops here similar to those found in the C or FORTRAN // programming languages. Note that otb // does not use \code{for()} loops in its internal code to access // pixels. All pixel access tasks are instead performed using // \doxygen{otb}{ImageIterator}s that support the management of // n-dimensional images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const double radius2 = radius * radius; PixelType * it = localBuffer; int length = 0; for (unsigned int y = 0; y < size[1]; y++) { const double dy = static_cast(y) - static_cast(size[1]) / 2.0; for (unsigned int x = 0; x < size[0]; x++) { const double dx = static_cast(x) - static_cast(size[0]) / 2.0; const double d2 = dx * dx + dy * dy; PixelType pTmp = (d2 < radius2) ? 255 : 0; for (unsigned int nbBandsTmp = 0; nbBandsTmp < numberOfBands; nbBandsTmp++) *it++ = pTmp; length++; } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The buffer is passed to the ImportImageFilter with the // \code{SetImportPointer()}. Note that the last argument of this method // specifies who will be responsible for deleting the memory block once it // is no longer in use. A \code{false} value indicates that the // ImportImageFilter will not try to delete the buffer when its // destructor is called. A \code{true} value, on the other hand, will allow the // filter to delete the memory block upon destruction of the import filter. // // For the ImportImageFilter to appropriately delete the // memory block, the memory must be allocated with the C++ // \code{new()} operator. Memory allocated with other memory // allocation mechanisms, such as C \code{malloc} or \code{calloc}, will not // be deleted properly by the ImportImageFilter. In // other words, it is the application programmer's responsibility // to ensure that ImportImageFilter is only given // permission to delete the C++ \code{new} operator-allocated memory. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const bool importImageFilterWillOwnTheBuffer = true; importFilter->SetImportPointer(localBuffer, numberOfPixels, importImageFilterWillOwnTheBuffer); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we can connect the output of this filter to a pipeline. // For simplicity we just use a writer here, but it could be any other filter. // // Software Guide : EndLatex typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[1]); ImageType* imTmp = dynamic_cast(importFilter->GetOutput()); // Software Guide : BeginCodeSnippet writer->SetInput(imTmp); // Software Guide : EndCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& exp) { std::cerr << "Exception caught !" << std::endl; std::cerr << exp << std::endl; return -1; } // Software Guide : BeginLatex // // Note that we do not call \code{delete} on the buffer since we pass // \code{true} as the last argument of \code{SetImportPointer()}. Now the // buffer is owned by the ImportImageFilter. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/ImageAdaptor1.cxx000066400000000000000000000117211301006202600251560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // //This example illustrates how the \doxygen{itk}{ImageAdaptor} can be used to cast // an image from one pixel type to another. In particular, we will // \emph{adapt} an \code{unsigned char} image to make it appear as an image of // pixel type \code{float}. // // \index{itk::ImageAdaptor!Instantiation} // \index{itk::ImageAdaptor!Header} // // We begin by including the relevant headers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "itkImageAdaptor.h" // Software Guide : EndCodeSnippet #include "itkImageRegionIteratorWithIndex.h" #include "otbImageFileReader.h" // Software Guide : BeginLatex // // First, we need to define a \emph{pixel accessor} class that does the actual // conversion. Note that in general, the only valid operations for pixel // accessors are those that only require the value of the input pixel. As // such, neighborhood type operations are not possible. A pixel accessor must // provide methods \code{Set()} and \code{Get()}, and define the types of // \code{InternalPixelType} and \code{ExternalPixelType}. The // \code{InternalPixelType} corresponds to the pixel type of the image to be // adapted (\code{unsigned char} in this example). The \code{ExternalPixelType} // corresponds to the pixel type we wish to emulate with the ImageAdaptor // (\code{float} in this case). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet class CastPixelAccessor { public: typedef unsigned char InternalType; typedef float ExternalType; static void Set(InternalType& output, const ExternalType& input) { output = static_cast(input); } static ExternalType Get(const InternalType& input) { return static_cast(input); } }; // Software Guide : EndCodeSnippet //------------------------- // // Main code // //------------------------- int main(int argc, char *argv[]) { if (argc < 2) { std::cerr << "Usage: " << std::endl; std::cerr << "ImageAdaptor1 inputFileName" << std::endl; return -1; } // Software Guide : BeginLatex // // The CastPixelAccessor class simply applies a // \code{static\_cast} to the pixel values. We now use this pixel accessor // to define the image adaptor type and create an instance using // the standard \code{New()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::ImageAdaptor ImageAdaptorType; ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also create an image reader templated over the input image type and // read the input image from file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); reader->Update(); // Software Guide : BeginLatex // // The output of the reader is then connected as the input to the image // adaptor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet adaptor->SetImage(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In the following code, we visit the image using an iterator // instantiated using the adapted image type and compute the // sum of the pixel values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it(adaptor, adaptor->GetBufferedRegion()); double sum = 0.0; it.GoToBegin(); while (!it.IsAtEnd()) { float value = it.Get(); sum += value; ++it; } // Software Guide : EndCodeSnippet std::cout << "Sum of pixels is: " << sum << std::endl; // Software Guide : BeginLatex // // Although in this example, we are just performing a simple summation, the key // concept is that access to pixels is performed as if the pixel is of type // \code{float}. Additionally, it should be noted that the adaptor is used // as if it was an actual image and not as a filter. ImageAdaptors conform // to the same API as the \doxygen{otb}{Image} class. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/ImageAdaptor2.cxx000066400000000000000000000156061301006202600251650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how to use the \doxygen{itk}{ImageAdaptor} // to access the individual components of an RGB image. In this case, we // create an ImageAdaptor that will accept a RGB image as input and // presents it as a scalar image. The pixel data // will be taken directly from the red channel of the original image. // // \index{itk::ImageAdaptor!Instantiation} // \index{itk::ImageAdaptor!Header} // // Software Guide : EndLatex #include "otbImage.h" #include "itkImageAdaptor.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // As with the previous example, the bulk of the effort in creating the image // adaptor is associated with the definition of the pixel accessor class. In // this case, the accessor converts a RGB vector to a scalar containing the // red channel component. Note that in the following, we do not need to define // the \code{Set()} method since we only expect the adaptor to be used for // reading data from the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet class RedChannelPixelAccessor { public: typedef itk::RGBPixel InternalType; typedef float ExternalType; static ExternalType Get(const InternalType& input) { return static_cast(input.GetRed()); } }; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{Get()} method simply calls the \code{GetRed()} method // defined in the \doxygen{itk}{RGBPixel} class. // // Software Guide : EndLatex //------------------------- // // Main code // //------------------------- int main(int argc, char *argv[]) { if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << "ImageAdaptor2 inputRGBFileName outputRedChannelFileName" << std::endl; return -1; } // Software Guide : BeginLatex // // Now we use the internal pixel type of the pixel accessor to define the // input image type, and then proceed to instantiate the ImageAdaptor type. // // \index{PixelAccessor!RGB red channel} // \index{itk::ImageAdaptor!RGB red channel} // \index{ImageAdaptor!RGB red channel} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef RedChannelPixelAccessor::InternalType InputPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::ImageAdaptor ImageAdaptorType; ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create an image reader and connect the output to the adaptor // as before. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); reader->Update(); // Software Guide : BeginCodeSnippet adaptor->SetImage(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create an \doxygen{itk}{RescaleIntensityImageFilter} and an // \doxygen{otb}{ImageFileWriter} to rescale the dynamic range of the pixel values // and send the extracted channel to an image file. Note that the image type // used for the rescaling filter is the \code{ImageAdaptorType} itself. That // is, the adaptor type is used in the same context as an image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // Now we connect the adaptor as the input to the rescaler and set the // parameters for the intensity rescaling. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(adaptor); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we invoke the \code{Update()} method on the writer and take // precautions to catch any exception that may be thrown during // the execution of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Exception caught " << excp << std::endl; return 1; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // ImageAdaptors for the green and blue channels can easily be implemented by // modifying the pixel accessor of the red channel and then using the // new pixel accessor for instantiating the type of an image adaptor. // The following define a green channel pixel accessor. // // \index{PixelAccessor!RGB green channel} // \index{itk::ImageAdaptor!RGB green channel} // \index{ImageAdaptor!RGB green channel} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet class GreenChannelPixelAccessor { public: typedef itk::RGBPixel InternalType; typedef float ExternalType; static ExternalType Get(const InternalType& input) { return static_cast(input.GetGreen()); } }; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A blue channel pixel accessor is similarly defined. // // \index{PixelAccessor!RGB blue channel} // \index{itk::ImageAdaptor!RGB blue channel} // \index{ImageAdaptor!RGB blue channel} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet class BlueChannelPixelAccessor { public: typedef itk::RGBPixel InternalType; typedef float ExternalType; static ExternalType Get(const InternalType& input) { return static_cast(input.GetBlue()); } }; // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/ImageAdaptor3.cxx000066400000000000000000000151361301006202600251640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the use of \doxygen{itk}{ImageAdaptor} // to obtain access to the components of a vector image. // Specifically, it shows how to manage pixel accessors containing // internal parameters. In this example we create an image of vectors by using // a gradient filter. Then, we use an image adaptor to extract one of the // components of the vector image. The vector type used by the gradient filter // is the \doxygen{itk}{CovariantVector} class. // // We start by including the relevant headers. // // \index{itk::ImageAdaptor!Instantiation} // \index{itk::ImageAdaptor!Header} // \index{itk::PixelAccessor!with parameters} // // Software Guide : EndLatex #include "otbImage.h" #include "itkImageAdaptor.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkGradientRecursiveGaussianImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A pixel accessors class may have internal parameters that affect the // operations performed on input pixel data. Image adaptors support // parameters in their internal pixel accessor by using // the assignment operator. Any pixel accessor which has internal // parameters must therefore implement the assignment operator. // The following defines a pixel accessor for extracting // components from a vector pixel. The // \code{m\_Index} member variable is used to select the vector component // to be returned. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet class VectorPixelAccessor { public: typedef itk::CovariantVector InternalType; typedef float ExternalType; void operator =(const VectorPixelAccessor& vpa) { m_Index = vpa.m_Index; } ExternalType Get(const InternalType& input) const { return static_cast(input[m_Index]); } void SetIndex(unsigned int index) { m_Index = index; } private: unsigned int m_Index; }; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{Get()} method simply returns the \emph{i}-th component of // the vector as indicated by the index. The assignment operator transfers the // value of the index member variable from one instance of the pixel accessor // to another. // // Software Guide : EndLatex //------------------------- // // Main code // //------------------------- int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Usage: " << std::endl; std::cerr << "ImageAdaptor3 inputFileName outputComponentFileName "; std::cerr << " indexOfComponentToExtract" << std::endl; return -1; } // Software Guide : BeginLatex // // In order to test the pixel accessor, we generate an image of vectors using // the \doxygen{itk}{GradientRecursiveGaussianImageFilter}. This // filter produces an output image of \doxygen{itk}{CovariantVector} pixel type. // Covariant vectors are the natural representation for gradients since they // are the equivalent of normals to iso-values manifolds. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef itk::CovariantVector VectorPixelType; typedef otb::Image VectorImageType; typedef itk::GradientRecursiveGaussianImageFilter GradientFilterType; GradientFilterType::Pointer gradient = GradientFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the ImageAdaptor using the vector image type as // the first template parameter and the pixel accessor as the second // template parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageAdaptor ImageAdaptorType; ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The index of the component to be extracted is specified // from the command line. In the following, we create the accessor, // set the index and connect the accessor to the image adaptor using // the \code{SetPixelAccessor()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorPixelAccessor accessor; accessor.SetIndex(atoi(argv[3])); adaptor->SetPixelAccessor(accessor); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create a reader to load the image specified from the // command line and pass its output as the input to the gradient filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); gradient->SetInput(reader->GetOutput()); reader->SetFileName(argv[1]); gradient->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now connect the output of the gradient filter as input to the // image adaptor. The adaptor emulates a scalar image whose pixel values // are taken from the selected component of the vector image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet adaptor->SetImage(gradient->GetOutput()); // Software Guide : EndCodeSnippet typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(adaptor); writer->SetInput(rescaler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/ImageAdaptor4.cxx000066400000000000000000000144561301006202600251710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ImageAdaptorThresholdingA.png} // 100 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ImageAdaptorThresholdingB.png} // 200 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Image adaptors can also be used to perform simple pixel-wise computations // on image data. The following example illustrates how to use the // \doxygen{itk}{ImageAdaptor} for image thresholding. // // \index{itk::ImageAdaptor!Instantiation} // \index{itk::ImageAdaptor!Header} // \index{itk::ImageAdaptor!performing computation} // \index{itk::PixelAccessor!with parameters} // \index{itk::PixelAccessor!performing computation} // // Software Guide : EndLatex #include "otbImage.h" #include "itkImageAdaptor.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // A pixel accessor for image thresholding requires that the accessor // maintain the threshold value. Therefore, it must also implement the // assignment operator to set this internal parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet class ThresholdingPixelAccessor { public: typedef unsigned char InternalType; typedef unsigned char ExternalType; ExternalType Get(const InternalType& input) const { return (input > m_Threshold) ? 1 : 0; } void SetThreshold(const InternalType threshold) { m_Threshold = threshold; } void operator =(const ThresholdingPixelAccessor& vpa) { m_Threshold = vpa.m_Threshold; } private: InternalType m_Threshold; }; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{Get()} method returns one if the input pixel is above // the threshold and zero otherwise. The assignment operator transfers // the value of the threshold member // variable from one instance of the pixel accessor to another. // // Software Guide : EndLatex //------------------------- // // Main code // //------------------------- int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Usage: " << std::endl; std::cerr << "ImageAdaptor4 inputFileName outputBinaryFileName "; std::cerr << " thresholdValue" << std::endl; return -1; } // Software Guide : BeginLatex // // To create an image adaptor, we first instantiate an image type // whose pixel type is the same as the internal pixel type of the pixel // accessor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ThresholdingPixelAccessor::InternalType PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the ImageAdaptor using the image type as the // first template parameter and the pixel accessor as the second template // parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageAdaptor ImageAdaptorType; ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The threshold value is set from the command line. A threshold // pixel accessor is created and connected to the image adaptor // in the same manner as in the previous example. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ThresholdingPixelAccessor accessor; accessor.SetThreshold(atoi(argv[3])); adaptor->SetPixelAccessor(accessor); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create a reader to load the input image and connect the output // of the reader as the input to the adaptor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->Update(); adaptor->SetImage(reader->GetOutput()); // Software Guide : EndCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(adaptor); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : BeginLatex // // \begin{figure} \center // \includegraphics[width=0.32\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.32\textwidth]{ImageAdaptorThresholdingA.eps} // \includegraphics[width=0.32\textwidth]{ImageAdaptorThresholdingB.eps} // \itkcaption[Image Adaptor for performing computations]{Using // ImageAdaptor to perform a simple image computation. An // ImageAdaptor is used to perform binary thresholding on // the input image on the left. The center image was created using a // threshold of 100, while the // image on the right corresponds to a threshold of 200.} // \label{fig:ImageAdaptorThresholding} // \end{figure} // // As before, we rescale the emulated scalar image before writing it // out to file. // Figure~\ref{fig:ImageAdaptorThresholding} illustrates the result of // applying the thresholding adaptor to a typical gray scale image using two // different threshold values. Note that the same effect could have been // achieved by using the \doxygen{itk}{BinaryThresholdImageFilter} but at the // price of holding an extra copy of the image in memory. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/ImageListExample.cxx000066400000000000000000000114411301006202600257310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the use of the \subdoxygen{otb}{ImageList} // class. This class provides the functionnalities needed in order to // integrate image lists as data objects into the OTB // pipeline. Indeed, if a \code{std::list< ImageType >} was used, the // update operations on the pipeline might not have the desired // effects. // // In this example, we will only present the basic operations which // can be applied on an \subdoxygen{otb}{ImageList} object. // // The first thing required to read an image from a file is to include // the header file of the \subdoxygen{otb}{ImageFileReader} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageList.h" // Software Guide : EndCodeSnippet #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int main(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // As usual, we start by defining the types for the pixel and image // types, as well as those for the readers and writers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the image list. The // \subdoxygen{otb}{ImageList} class is templated over the type of image // contained in it. This means that all images in a list must have the // same type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageList ImageListType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let us assume now that we want to read an image from a file and // store it in a list. The first thing to do is to instantiate the // reader and set the image file name. We effectively read the image // by calling the \code{Update()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create an image list by using the \code{New()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageListType::Pointer imageList = ImageListType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In order to store the image in the list, the \code{PushBack()} // method is used. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet imageList->PushBack(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We could repeat this operation for other readers or the outputs of // filters. We will now write an image of the list to a file. We // therefore instantiate a writer, set the image file name and set the // input image for it. This is done by calling the \code{Back()} // method of the list, which allows us to get the last element. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Getting the image from the list and writing it to file WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(imageList->Back()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Other useful methods are: // \begin{itemize} // \item \code{SetNthElement()} and \code{GetNthElement()} allow // randomly accessing any element of the list. // \item \code{Front()} to access to the first element of the list. // \item \code{Erase()} to remove an element. // \end{itemize} // // Also, iterator classes are defined in order to have an efficient // mean of moving through the list. Finally, the // \subdoxygen{otb}{ImageListToImageListFilter} is provided in order // to implement filter which operate on image lists and produce image lists. // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/RGBImage.cxx000066400000000000000000000122151301006202600241140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" // Software Guide : BeginLatex // // Thanks to the flexibility offered by the // \href{http://www.boost.org/more/generic_programming.html}{Generic // Programming} style on which OTB is based, it is possible to // instantiate images of arbitrary pixel type. The following example // illustrates how a color image with RGB pixels can be defined. // // A class intended to support the RGB pixel type is available in ITK. You // could also define your own pixel class and use it to instantiate a // custom image type. In order to use the \doxygen{itk}{RGBPixel} class, it is // necessary to include its header file. // // \index{itk::RGBPixel} // \index{itk::RGBPixel!Image} // \index{itk::RGBPixel!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkRGBPixel.h" // Software Guide : EndCodeSnippet int main(int, char * argv[]) { // Software Guide : BeginLatex // // The RGB pixel class is templated over a type used to represent each one // of the red, green and blue pixel components. A typical instantiation of the // templated class is as follows. // // \index{itk::RGBPixel!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RGBPixel PixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The type is then used as the pixel template parameter of the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image type can be used to instantiate other filter, for example, // an \doxygen{otb}{ImageFileReader} object that will read the image from a // file. // // \index{otb::ImageFileReader!RGB Image} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); const char * filename = argv[1]; reader->SetFileName(filename); reader->Update(); ImageType::Pointer image = reader->GetOutput(); ImageType::IndexType pixelIndex; pixelIndex[0] = 25; pixelIndex[1] = 35; // Software Guide : BeginLatex // // Access to the color components of the pixels can now be performed using // the methods provided by the RGBPixel class. // // \index{otb::Image!GetPixel()} // \index{itk::RGBPixel!GetRed()} // \index{itk::RGBPixel!GetGreen()} // \index{itk::RGBPixel!GetBlue()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PixelType onePixel = image->GetPixel(pixelIndex); PixelType::ValueType red = onePixel.GetRed(); PixelType::ValueType green = onePixel.GetGreen(); PixelType::ValueType blue = onePixel.GetBlue(); // Software Guide : EndCodeSnippet std::cout << "Pixel values from GetRed, GetGreen, GetBlue:" << std::endl; std::cout << "Red = " << itk::NumericTraits::PrintType(red) << std::endl; std::cout << "Green = " << itk::NumericTraits::PrintType(green) << std::endl; std::cout << "Blue = " << itk::NumericTraits::PrintType(blue) << std::endl; // Software Guide : BeginLatex // // The subindex notation can also be used since the \doxygen{itk}{RGBPixel} inherits the // \code{[]} operator from the \doxygen{itk}{FixedArray} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet red = onePixel[0]; // extract Red component green = onePixel[1]; // extract Green component blue = onePixel[2]; // extract Blue component std::cout << "Pixel values:" << std::endl; std::cout << "Red = " << itk::NumericTraits::PrintType(red) << std::endl; std::cout << "Green = " << itk::NumericTraits::PrintType(green) << std::endl; std::cout << "Blue = " << itk::NumericTraits::PrintType(blue) << std::endl; // Software Guide : EndCodeSnippet // Lets repeat that both \code{SetPixel()} and \code{GetPixel()} are // inefficient and should only be used for debugging purposes or for // implementing interactions with a graphical user interface such as // querying pixel value by clicking with the mouse. // return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/VectorImage.cxx000066400000000000000000000120141301006202600247410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Many image processing tasks require images of non-scalar pixel type. A // typical example is a multispectral image. The following code illustrates // how to instantiate and use an image whose pixels are of vector type. // // We could use the \doxygen{itk}{Vector} class to define the pixel // type. The Vector class is intended to represent a geometrical vector in // space. It is not intended to be used as an array container like the // \href{http://www.sgi.com/tech/stl/Vector.html}{\code{std::vector}} in // \href{http://www.sgi.com/tech/stl/}{STL}. If you are interested in // containers, the \doxygen{itk}{VectorContainer} class may provide the // functionality you want. // // \index{itk::Vector} // \index{itk::Vector!header} // // However, the \doxygen{itk}{Vector} is a fixed size array and it // assumes that the number of channels of the image is known at // compile time. Therefore, we prefer to use the // \doxygen{otb}{VectorImage} class which allows choosing the number // of channels of the image at runtime. The pixels will be of type // \doxygen{itk}{VariableLengthVector}. // // The first step is to include the header file of the VectorImage class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbVectorImage.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { // Software Guide : BeginLatex // // The VectorImage class is templated over the type used to represent // the coordinate in space and over the dimension of the space. In // this example, // we want to represent Pl\'eiades images which have 4 bands. // // \index{otb::VectorImage!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; typedef otb::VectorImage ImageType; // Software Guide : EndCodeSnippet // Then the image object can be created ImageType::Pointer image = ImageType::New(); // The image region should be initialized ImageType::IndexType start; ImageType::SizeType size; size[0] = 200; // size along X size[1] = 200; // size along Y start[0] = 0; // first index on X start[1] = 0; // first index on Y ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); // Pixel data is allocated image->SetRegions(region); // Software Guide : BeginLatex // Since the pixel dimensionality is chosen at runtime, one has to // pass this parameter to the image before memory allocation. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet image->SetNumberOfComponentsPerPixel(4); image->Allocate(); // Software Guide : EndCodeSnippet ImageType::IndexType pixelIndex; pixelIndex[0] = 27; // x position pixelIndex[1] = 29; // y position // Software Guide : BeginLatex // // The VariableLengthVector class overloads the operator // \code{[]}. This makes it possible to access the // Vector's components using index notation. The user must not // forget to allocate the memory for each individual pixel by using // the \code{Reserve} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::PixelType pixelValue; pixelValue.Reserve(4); pixelValue[0] = 1; // Blue component pixelValue[1] = 6; // Green component pixelValue[2] = 100; // Red component pixelValue[3] = 100; // NIR component // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now store this vector in one of the image pixels by defining an // index and invoking the \code{SetPixel()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet image->SetPixel(pixelIndex, pixelValue); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The GetPixel method can also be used to read Vectors // pixels from the image // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::PixelType value = image->GetPixel(pixelIndex); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Lets repeat that both \code{SetPixel()} and \code{GetPixel()} are // inefficient and should only be used for debugging purposes or for // implementing interactions with a graphical user interface such as // querying pixel value by clicking with the mouse. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Image/test/000077500000000000000000000000001301006202600227715ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Image/test/CMakeLists.txt000066400000000000000000000023771301006202600255420ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/DataRepresentation/Image) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- ImageAdaptor4Test---------- otb_add_test(NAME diTeImageAdaptor4Test1 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ImageAdaptorThresholdingA.png ${TEMP}/ImageAdaptorThresholdingA.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ImageAdaptorThresholdingA.png 100 ) # ------- ImageAdaptor4Test---------- otb_add_test(NAME diTeImageAdaptor4Test2 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ImageAdaptorThresholdingB.png ${TEMP}/ImageAdaptorThresholdingB.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ImageAdaptorThresholdingB.png 200 ) # ------- Image5Test---------- otb_add_test(NAME diTeImage5Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/Image5.png ${TEMP}/Image5.png Execute $ ${TEMP}/Image5.png ) # ------- Image6Test---------- otb_add_test(NAME diTeImage6Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/Image6.tif ${TEMP}/Image6.tif Execute $ ${TEMP}/Image6.tif ) OTB-release-5.8/Examples/DataRepresentation/Mesh/000077500000000000000000000000001301006202600216645ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Mesh/CMakeLists.txt000066400000000000000000000013101301006202600244170ustar00rootroot00000000000000project(MeshExamples) add_executable(Mesh1 Mesh1.cxx ) target_link_libraries(Mesh1 ${ITK_LIBRARIES}) add_executable(Mesh2 Mesh2.cxx ) target_link_libraries(Mesh2 ${ITK_LIBRARIES}) add_executable(Mesh3 Mesh3.cxx ) target_link_libraries(Mesh3 ${ITK_LIBRARIES}) add_executable(PointSet1 PointSet1.cxx ) target_link_libraries(PointSet1 ${ITK_LIBRARIES}) add_executable(PointSet2 PointSet2.cxx ) target_link_libraries(PointSet2 ${ITK_LIBRARIES}) add_executable(PointSet3 PointSet3.cxx ) target_link_libraries(PointSet3 ${ITK_LIBRARIES}) add_executable(PointSetWithVectors PointSetWithVectors.cxx ) target_link_libraries(PointSetWithVectors ${ITK_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/DataRepresentation/Mesh/Mesh1.cxx000066400000000000000000000172421301006202600233730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The \doxygen{itk}{Mesh} class is intended to represent shapes in space. It // derives from the \doxygen{itk}{PointSet} class and hence inherits all the // functionality related to points and access to the pixel-data associated // with the points. The mesh class is also n-dimensional which // allows a great flexibility in its use. // // In practice a Mesh class can be seen as a PointSet to // which cells (also known as elements) of many different dimensions and // shapes have been added. Cells in the mesh are defined in terms of the // existing points using their point-identifiers. // // In the same way as for the PointSet, two basic styles of // Meshes are available in ITK. They are referred to as \emph{static} // and \emph{dynamic}. The first one is used when the number of // points in the set can be known in advance and it is not expected // to change as a consequence of the manipulations performed on the // set. The dynamic style, on the other hand, is intended to support // insertion and removal of points in an efficient manner. The reason // for making the distinction between the two styles is to facilitate // fine tuning its behavior with the aim of optimizing // performance and memory management. In the case of the Mesh, the // dynamic/static aspect is extended to the management of cells. // // \index{itk::Mesh} // \index{itk::Mesh!Static} // \index{itk::Mesh!Dynamic} // \index{itk::Mesh!Header file} // // In order to use the Mesh class, its header file should be included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMesh.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { // Software Guide : BeginLatex // // Then, the type associated with the points must be selected and used for // instantiating the Mesh type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float PixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The Mesh type extensively uses the capabilities provided by // \href{http://www.boost.org/more/generic_programming.html}{Generic // Programming}. In particular the Mesh class is parameterized over the // PixelType and the dimension of the space. PixelType is the type of the // value associated with every point just as is done with the // PointSet. The following line illustrates a typical // instantiation of the Mesh. // // \index{itk::Mesh!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef itk::Mesh MeshType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Meshes are expected to take large amounts of memory. For this reason they // are reference counted objects and are managed using SmartPointers. The // following line illustrates how a mesh is created by invoking the // \code{New()} method of the MeshType and the resulting object is assigned // to a \doxygen{itk}{SmartPointer}. // // \index{itk::Mesh!New()} // \index{itk::Mesh!Pointer()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MeshType::Pointer mesh = MeshType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The management of points in the Mesh is exactly the same as in // the PointSet. The type point associated with the mesh can be // obtained through the \code{PointType} trait. The following code shows the // creation of points compatible with the mesh type defined above and the // assignment of values to its coordinates. // // \index{itk::Mesh!PointType} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MeshType::PointType p0; MeshType::PointType p1; MeshType::PointType p2; MeshType::PointType p3; p0[0] = -1.0; p0[1] = -1.0; // first point ( -1, -1 ) p1[0] = 1.0; p1[1] = -1.0; // second point ( 1, -1 ) p2[0] = 1.0; p2[1] = 1.0; // third point ( 1, 1 ) p3[0] = -1.0; p3[1] = 1.0; // fourth point ( -1, 1 ) // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The points can now be inserted in the Mesh using the \code{SetPoint()} // method. Note that points are copied into the mesh structure. This means // that the local instances of the points can now be modified without // affecting the Mesh content. // // \index{itk::Mesh!SetPoint()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet mesh->SetPoint(0, p0); mesh->SetPoint(1, p1); mesh->SetPoint(2, p2); mesh->SetPoint(3, p3); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The current number of points in the Mesh can be queried with the // \code{GetNumberOfPoints()} method. // // \index{itk::Mesh!GetNumberOfPoints()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The points can now be efficiently accessed using the Iterator to the // PointsContainer as it was done in the previous section for the // PointSet. First, the point iterator type is extracted through // the mesh traits. // // \index{PointsContainer!Iterator} // \index{itk::Mesh!GetPoints()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef MeshType::PointsContainer::Iterator PointsIterator; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A point iterator is initialized to the first point with the // \code{Begin()} method of the PointsContainer. // // \index{PointsContainer!Begin()} // \index{itk::Mesh!GetPoints()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsIterator pointIterator = mesh->GetPoints()->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{++} operator on the iterator is now used to advance from one // point to the next. The actual value of the Point to which the iterator is // pointing can be obtained with the \code{Value()} method. The loop for // walking through all the points is controlled by comparing the current // iterator with the iterator returned by the \code{End()} method of the // PointsContainer. The following lines illustrate the typical loop for // walking through the points. // // \index{PointsContainer!End()} // \index{PointsContainer!Iterator} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsIterator end = mesh->GetPoints()->End(); while (pointIterator != end) { MeshType::PointType p = pointIterator.Value(); // access the point std::cout << p << std::endl; // print the point ++pointIterator; // advance to next point } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Mesh/Mesh2.cxx000066400000000000000000000271621301006202600233760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // A \doxygen{itk}{Mesh} can contain a variety of cell types. Typical cells are // the \doxygen{itk}{LineCell}, \doxygen{itk}{TriangleCell}, // \doxygen{itk}{QuadrilateralCell} and // \doxygen{itk}{TetrahedronCell}. The latter will not be used very // often in the remote sensing context. Additional // flexibility is provided for managing cells at the price of a bit more of // complexity than in the case of point management. // // The following code creates a polygonal line in order to illustrate the // simplest case of cell management in a Mesh. The only cell type used here is // the LineCell. The header file of this class has to be included. // // \index{itk::LineCell!Header} // // Software Guide : EndLatex #include "itkMesh.h" // Software Guide : BeginCodeSnippet #include "itkLineCell.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { typedef float PixelType; typedef itk::Mesh MeshType; // Software Guide : BeginLatex // // In order to be consistent with the Mesh, cell types have to be configured // with a number of custom types taken from the mesh traits. The set of // traits relevant to cells are packaged by the Mesh class into the // \code{CellType} trait. This trait needs to be passed to the actual cell // types at the moment of their instantiation. The following line shows how // to extract the Cell traits from the Mesh type. // // \index{itk::Mesh!CellType} // \index{itk::Mesh!traits} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef MeshType::CellType CellType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The LineCell type can now be instantiated using the traits // taken from the Mesh. // // \index{itk::LineCell!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::LineCell LineType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The main difference in the way cells and points are managed by // the Mesh is that points are stored by copy on the // PointsContainer while cells are stored in the CellsContainer // using pointers. The reason for using pointers is that cells use // C++ polymorphism on the mesh. This means that the mesh is only // aware of having pointers to a generic cell which is the base // class of all the specific cell types. This architecture makes it // possible to combine different cell types in the same // mesh. Points, on the other hand, are of a single type and have a // small memory footprint, which makes it efficient to copy them // directly into the container. // // \index{itk::Cell!CellAutoPointer} // \index{itk::Mesh!CellAutoPointer} // \index{CellAutoPointer} // \index{itk::AutoPointer} // // Managing cells by pointers add another level of complexity to the Mesh // since it is now necessary to establish a protocol to make clear who is // responsible for allocating and releasing the cells' memory. This protocol // is implemented in the form of a specific type of pointer called the // \code{CellAutoPointer}. This pointer, based on the \doxygen{itk}{AutoPointer}, // differs in many respects from the SmartPointer. The CellAutoPointer has an // internal pointer to the actual object and a boolean flag that indicates // if the CellAutoPointer is responsible for releasing the cell memory // whenever the time comes for its own destruction. It is said that a // \code{CellAutoPointer} \emph{owns} the cell when it is responsible for // its destruction. Many CellAutoPointer can point to the same cell but at // any given time, only \textbf{one} CellAutoPointer can own the cell. // // The \code{CellAutoPointer} trait is defined in the MeshType and can be // extracted as illustrated in the following line. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef CellType::CellAutoPointer CellAutoPointer; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that the CellAutoPointer is pointing to a generic cell type. It is // not aware of the actual type of the cell, which can be for example // LineCell, TriangleCell or TetrahedronCell. This fact will influence the // way in which we access cells later on. // // At this point we can actually create a mesh and insert some points on it. // // \index{itk::Mesh!New()} // \index{itk::Mesh!SetPoint()} // \index{itk::Mesh!PointType} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MeshType::Pointer mesh = MeshType::New(); MeshType::PointType p0; MeshType::PointType p1; MeshType::PointType p2; p0[0] = -1.0; p0[1] = 0.0; p1[0] = 1.0; p1[1] = 0.0; p2[0] = 1.0; p2[1] = 1.0; mesh->SetPoint(0, p0); mesh->SetPoint(1, p1); mesh->SetPoint(2, p2); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code creates two CellAutoPointers and initializes // them with newly created cell objects. The actual cell type // created in this case is LineCell. Note that cells are // created with the normal \code{new} C++ operator. The // CellAutoPointer takes ownership of the received pointer by using // the method \code{TakeOwnership()}. Even though this may seem // verbose, it is necessary in order to make it explicit from the // code that the responsibility of memory release is assumed by the // AutoPointer. // // \index{itk::AutoPointer!TakeOwnership()} // \index{CellAutoPointer!TakeOwnership()} // \index{CellType!creation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet CellAutoPointer line0; CellAutoPointer line1; line0.TakeOwnership(new LineType); line1.TakeOwnership(new LineType); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The LineCells should now be associated with points in the mesh. This is // done using the identifiers assigned to points when they were inserted // in the mesh. Every cell type has a specific number of points that must // be associated with it.\footnote{Some cell types like polygons have a // variable number of points associated with them.} For example a // LineCell requires two points, a TriangleCell // requires three and a TetrahedronCell requires four. Cells use // an internal numbering system for points. It is simply an index in the // range $\{0, NumberOfPoints-1\}$. The association of points and cells is // done by the \code{SetPointId()} method which requires the user to // provide the internal index of the point in the cell and the // corresponding PointIdentifier in the Mesh. The internal cell index is // the first parameter of \code{SetPointId()} while the mesh // point-identifier is the second. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet line0->SetPointId(0, 0); // line between points 0 and 1 line0->SetPointId(1, 1); line1->SetPointId(0, 1); // line between points 1 and 2 line1->SetPointId(1, 2); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Cells are inserted in the mesh using the \code{SetCell()} method. It // requires an identifier and the AutoPointer to the cell. The Mesh will // take ownership of the cell to which the AutoPointer is pointing. This is // done internally by the \code{SetCell()} method. In this way, the // destruction of the CellAutoPointer will not induce the destruction of the // associated cell. // // \index{itk::Mesh!SetCell()} // \index{SetCell()!itk::Mesh} // \index{itk::Mesh!Inserting cells} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet mesh->SetCell(0, line0); mesh->SetCell(1, line1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After serving as an argument of the \code{SetCell()} method, a // CellAutoPointer no longer holds ownership of the cell. It is important // not to use this same CellAutoPointer again as argument to // \code{SetCell()} without first securing ownership of another cell. // // Software Guide : EndLatex std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl; // Software Guide : BeginLatex // // The number of Cells currently inserted in the mesh can be queried with // the \code{GetNumberOfCells()} method. // // \index{itk::Mesh!GetNumberOfCells()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::cout << "Cells = " << mesh->GetNumberOfCells() << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In a way analogous to points, cells can be accessed using Iterators to // the CellsContainer in the mesh. The trait for the cell iterator can be // extracted from the mesh and used to define a local type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef MeshType::CellsContainer::Iterator CellIterator; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then the iterators to the first and past-end cell in the mesh can be // obtained respectively with the \code{Begin()} and \code{End()} methods of // the CellsContainer. The CellsContainer of the mesh is returned by the // \code{GetCells()} method. // // \index{itk::Mesh!Iterating cells} // \index{itk::Mesh!GetCells()} // \index{CellsContainer!Begin()} // \index{CellsContainer!End()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet CellIterator cellIterator = mesh->GetCells()->Begin(); CellIterator end = mesh->GetCells()->End(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally a standard loop is used to iterate over all the cells. Note the // use of the \code{Value()} method used to get the actual pointer to the // cell from the CellIterator. Note also that the values returned are // pointers to the generic CellType. These pointers have to be down-casted // in order to be used as actual LineCell types. Safe down-casting is // performed with the \code{dynamic\_cast} operator which will throw an // exception if the conversion cannot be safely performed. // // \index{down casting} // \index{CellIterator!Value()} // \index{CellIterator!increment} // \index{itk::Mesh!CellType casting} // \index{Print()} // \index{CellType!Print()} // \index{CellType!GetNumberOfPoints()} // \index{LineCell!Print()} // \index{LineCell!GetNumberOfPoints()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (cellIterator != end) { MeshType::CellType * cellptr = cellIterator.Value(); LineType * line = dynamic_cast(cellptr); std::cout << line->GetNumberOfPoints() << std::endl; ++cellIterator; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Mesh/Mesh3.cxx000066400000000000000000000174471301006202600234040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // In the same way that custom data can be associated with points in the mesh, // it is also possible to associate custom data with cells. The type of the // data associated with the cells can be different from the data type // associated with points. By default, however, these two types are the same. // The following example illustrates how to access data associated with cells. // The approach is analogous to the one used to access point data. // // \index{itk::Mesh!Cell data} // // Software Guide : EndLatex // Software Guide : BeginLatex // // Consider the example of a mesh containing lines on which values are // associated with each line. The mesh and cell header files should be // included first. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMesh.h" #include "itkLineCell.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { // Software Guide : BeginLatex // // Then the PixelType is defined and the mesh type is instantiated with it. // // \index{itk::Mesh!Instantiation} // \index{itk::Mesh!PixelType} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float PixelType; typedef itk::Mesh MeshType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{itk}{LineCell} type can now be instantiated using the traits // taken from the Mesh. // // \index{itk::LineCell!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef MeshType::CellType CellType; typedef itk::LineCell LineType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's now create a Mesh and insert some points into it. Note that the // dimension of the points matches the dimension of the Mesh. Here we insert // a sequence of points that look like a plot of the $\log()$ function. // // \index{itk::Mesh!New()} // \index{itk::Mesh!SetPoint()} // \index{itk::Mesh!PointType} // \index{itk::Mesh!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MeshType::Pointer mesh = MeshType::New(); typedef MeshType::PointType PointType; PointType point; const unsigned int numberOfPoints = 10; for (unsigned int id = 0; id < numberOfPoints; id++) { point[0] = static_cast(id); // x point[1] = log(static_cast(id)); // y mesh->SetPoint(id, point); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A set of line cells is created and associated with the existing points by // using point identifiers. In this simple case, the point identifiers can // be deduced from cell identifiers since the line cells are ordered in the // same way. // // \index{itk::AutoPointer!TakeOwnership()} // \index{CellAutoPointer!TakeOwnership()} // \index{CellType!creation} // \index{itk::Mesh!SetCell()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet CellType::CellAutoPointer line; const unsigned int numberOfCells = numberOfPoints - 1; for (unsigned int cellId = 0; cellId < numberOfCells; cellId++) { line.TakeOwnership(new LineType); line->SetPointId(0, cellId); // first point line->SetPointId(1, cellId + 1); // second point mesh->SetCell(cellId, line); // insert the cell } // Software Guide : EndCodeSnippet std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl; std::cout << "Cells = " << mesh->GetNumberOfCells() << std::endl; // Software Guide : BeginLatex // // Data associated with cells is inserted in the \doxygen{itk}{Mesh} by using // the \code{SetCellData()} method. It requires the user to provide an // identifier and the value to be inserted. The identifier should match one // of the inserted cells. In this simple example, the square of the cell // identifier is used as cell data. Note the use of \code{static\_cast} to // \code{PixelType} in the assignment. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned int cellId = 0; cellId < numberOfCells; cellId++) { mesh->SetCellData(cellId, static_cast(cellId * cellId)); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Cell data can be read from the Mesh with the // \code{GetCellData()} method. It requires the user to provide the // identifier of the cell for which the data is to be retrieved. The user // should provide also a valid pointer to a location where the data can be // copied. // // \index{itk::Mesh!GetCellData()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned int cellId = 0; cellId < numberOfCells; cellId++) { PixelType value = itk::NumericTraits::Zero; mesh->GetCellData(cellId, &value); std::cout << "Cell " << cellId << " = " << value << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Neither \code{SetCellData()} or \code{GetCellData()} are efficient ways // to access cell data. More efficient access to cell data can be achieved // by using the Iterators built into the \code{CellDataContainer}. // Software Guide : BeginCodeSnippet typedef MeshType::CellDataContainer::ConstIterator CellDataIterator; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that the \code{ConstIterator} is used here because the data is only // going to be read. This approach is exactly the same already illustrated // for getting access to point data. The iterator to the first cell data // item can be obtained with the \code{Begin()} method of the // CellDataContainer. The past-end iterator is returned by the \code{End()} // method. The cell data container itself can be obtained from the mesh with // the method \code{GetCellData()}. // // \index{itk::Mesh!Iterating cell data} // \index{itk::Mesh!GetCellData()} // \index{CellDataContainer!Begin()} // \index{CellDataContainer!End()} // \index{CellDataContainer!Iterator} // \index{CellDataContainer!ConstIterator} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet CellDataIterator cellDataIterator = mesh->GetCellData()->Begin(); CellDataIterator end = mesh->GetCellData()->End(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally a standard loop is used to iterate over all the cell data // entries. Note the use of the \code{Value()} method used to get the actual // value of the data entry. \code{PixelType} elements are copied into the // local variable \code{cellValue}. // // \index{CellDataIterator!Value()} // \index{CellDataIterator!increment} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (cellDataIterator != end) { PixelType cellValue = cellDataIterator.Value(); std::cout << cellValue << std::endl; ++cellDataIterator; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Mesh/PointSet1.cxx000066400000000000000000000176041301006202600242460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The \code{itk::PointSet} is a basic class intended to represent geometry // in the form of a set of points in n-dimensional space. It is the base // class for the \code{itk::Mesh} providing the methods necessary to // manipulate sets of point. Points can have values associated with // them. The type of such values is defined by a template parameter of the // \code{itk::PointSet} class (i.e., \code{TPixelType}. Two basic // interaction styles of PointSets are available in ITK. These styles are // referred to as \emph{static} and \emph{dynamic}. The first style is used // when the number of points in the set is known in advance and is not // expected to change as a consequence of the manipulations performed on the // set. The dynamic style, on the other hand, is intended to support // insertion and removal of points in an efficient manner. Distinguishing // between the two styles is meant to facilitate the fine tuning of a // \code{PointSet}'s behavior while optimizing performance and memory // management. // // \index{itk::PointSet} // \index{itk::PointSet!Static} // \index{itk::PointSet!Dynamic} // // In order to use the PointSet class, its header file should be included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkPointSet.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { // Software Guide : BeginLatex // // Then we must decide what type of value to associate with the // points. This is generally called the \code{PixelType} in order to make the // terminology consistent with the \code{itk::Image}. The PointSet is also // templated over the dimension of the space in which the points are // represented. The following declaration illustrates a typical // instantiation of the PointSet class. // // \index{itk::PointSet!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A \code{PointSet} object is created by invoking the \code{New()} method // on its type. The resulting object must be assigned to a // \code{SmartPointer}. The PointSet is then reference-counted and can be // shared by multiple objects. The memory allocated for the PointSet will // be released when the number of references to the object is reduced to // zero. This simply means that the user does not need to be concerned // with invoking the \code{Delete()} method on this class. In fact, the // \code{Delete()} method should \textbf{never} be called directly within // any of the reference-counted ITK classes. // // \index{itk::PointSet!New()} // \index{itk::PointSet!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointSetType::Pointer pointsSet = PointSetType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Following the principles of Generic Programming, the \code{PointSet} class has a // set of associated defined types to ensure that interacting objects can be // declared with compatible types. This set of type definitions is // commonly known as a set of \emph{traits}. Among them we can find the // \code{PointType} type, for example. This is the type used by the point set to // represent points in space. The following declaration takes the point // type as defined in the \code{PointSet} traits and renames it to be conveniently // used in the global namespace. // // \index{itk::PointSet!PointType} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointType PointType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{PointType} can now be used to declare point objects to be // inserted in the \code{PointSet}. Points are fairly small objects, so // it is inconvenient to manage them with reference counting and smart // pointers. They are simply instantiated as typical C++ classes. The Point // class inherits the \code{[]} operator from the \code{itk::Array} class. // This makes it possible to access its components using index notation. For // efficiency's sake no bounds checking is performed during index access. It is // the user's responsibility to ensure that the index used is in the range // $\{0, Dimension-1\}$. Each of the components in the point is associated // with space coordinates. The following code illustrates how to instantiate // a point and initialize its components. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointType p0; p0[0] = -1.0; // x coordinate p0[1] = -1.0; // y coordinate // Software Guide : EndCodeSnippet PointType p1; p1[0] = 1.0; // Point 1 = { 1, -1 } p1[1] = -1.0; PointType p2; // Point 2 = { 1, 1 } p2[0] = 1.0; p2[1] = 1.0; // Software Guide : BeginLatex // // Points are inserted in the PointSet by using the \code{SetPoint()} method. // This method requires the user to provide a unique identifier for the // point. The identifier is typically an unsigned integer that will enumerate // the points as they are being inserted. The following code shows how three // points are inserted into the PointSet. // // \index{itk::PointSet!SetPoint()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet pointsSet->SetPoint(0, p0); pointsSet->SetPoint(1, p1); pointsSet->SetPoint(2, p2); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is possible to query the PointSet in order to determine how many points // have been inserted into it. This is done with the \code{GetNumberOfPoints()} // method as illustrated below. // // \index{itk::PointSet!GetNumberOfPoints()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int numberOfPoints = pointsSet->GetNumberOfPoints(); std::cout << numberOfPoints << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Points can be read from the PointSet by using the \code{GetPoint()} method // and the integer identifier. The point is stored in a pointer provided by // the user. If the identifier provided does not match an // existing point, the method will return \code{false} and the contents of the // point will be invalid. The following code illustrates point access // using defensive programming. // // \index{itk::PointSet!GetPoint()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointType pp; bool pointExists = pointsSet->GetPoint(1, &pp); if (pointExists) { std::cout << "Point is = " << pp << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \code{GetPoint()} and \code{SetPoint()} are not the most efficient methods // to access points in the PointSet. It is preferable to get direct access // to the internal point container defined by the \emph{traits} and use // iterators to walk sequentially over the list of points (as shown in // the following example). // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Mesh/PointSet2.cxx000066400000000000000000000203001301006202600242320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The \doxygen{itk}{PointSet} class uses an internal container to manage the storage of // \doxygen{itk}{Point}s. It is more efficient, in general, to manage points by using the // access methods provided directly on the points container. The following // example illustrates how to interact with the point container and how to use // point iterators. // // Software Guide : EndLatex #include "itkPointSet.h" int main(int, char *[]) { typedef itk::PointSet PointSetType; // Software Guide : BeginLatex // // The type is defined by the \emph{traits} of the PointSet // class. The following line conveniently takes the PointsContainer type // from the PointSet traits and declare it in the global namespace. // // \index{itk::PointSet!PointsContainer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointsContainer PointsContainer; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The actual type of the PointsContainer depends on what style of // PointSet is being used. The dynamic PointSet use the // \doxygen{itk}{MapContainer} while the static PointSet uses the // \doxygen{itk}{VectorContainer}. The vector and map containers are basically // ITK wrappers around the \href{http://www.sgi.com/tech/stl/}{STL} // classes \href{http://www.sgi.com/tech/stl/Map.html}{\code{std::map}} // and \href{http://www.sgi.com/tech/stl/Vector.html}{\code{std::vector}}. // By default, the PointSet uses a static style, hence the default // type of point container is an VectorContainer. Both the map // and vector container are templated over the type of the elements they // contain. In this case they are templated over PointType. // Containers are reference counted object. They are then created with the // \code{New()} method and assigned to a \doxygen{itk}{SmartPointer} after // creation. The following line creates a point container compatible with // the type of the PointSet from which the trait has been taken. // // \index{PointsContainer!New()} // \index{PointsContainer!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsContainer::Pointer points = PointsContainer::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Points can now be defined using the \code{PointType} trait from the // PointSet. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointType PointType; PointType p0; PointType p1; p0[0] = -1.0; p0[1] = 0.0; // Point 0 = {-1, 0 } p1[0] = 1.0; p1[1] = 0.0; // Point 1 = { 1, 0 } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The created points can be inserted in the PointsContainer using the // generic method \code{InsertElement()} which requires an identifier to // be provided for each point. // // \index{PointsContainer!InsertElement()} // \index{PointsContainer!InsertElement()} // \index{itk::VectorContainer!InsertElement()} // \index{itk::MapContainer!InsertElement()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int pointId = 0; points->InsertElement(pointId++, p0); points->InsertElement(pointId++, p1); // Software Guide : EndCodeSnippet PointSetType::Pointer pointSet = PointSetType::New(); // Software Guide : BeginLatex // // Finally the PointsContainer can be assigned to the PointSet. This will // substitute any previously existing PointsContainer on the PointSet. The // assignment is done using the \code{SetPoints()} method. // // \index{itk::PointSet!SetPoints()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet pointSet->SetPoints(points); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The PointsContainer object can be obtained from the PointSet using the // \code{GetPoints()} method. This method returns a pointer // to the actual container owned by the PointSet which is then assigned to // a SmartPointer. // // \index{itk::PointSet!GetPoints()} // \index{PointsContainer!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsContainer::Pointer points2 = pointSet->GetPoints(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The most efficient way to sequentially visit the points is to use the // iterators provided by PointsContainer. The \code{Iterator} type belongs // to the traits of the PointsContainer classes. It behaves pretty much like // the STL iterators.\footnote{If you dig deep enough into the code, you // will discover that these iterators are actually ITK wrappers around STL // iterators.} The Points iterator is not a reference counted class, so it // is created directly from the traits without using SmartPointers. // // \index{PointsContainer!Iterator} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointsContainer::Iterator PointsIterator; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The subsequent use of the iterator follows what you may expect from a STL // iterator. The iterator to the first point is obtained from the container // with the \code{Begin()} method and assigned to another iterator. // // \index{PointsContainer!Begin()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsIterator pointIterator = points->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{++} operator on the iterator can be used to advance from one // point to the next. The actual value of the Point to which the iterator is // pointing can be obtained with the \code{Value()} method. The loop for // walking through all the points can be controlled by comparing the current // iterator with the iterator returned by the \code{End()} method of the // PointsContainer. The following lines illustrate the typical loop for // walking through the points. // // \index{PointsContainer!End()} // \index{PointsContainer!Iterator} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsIterator end = points->End(); while (pointIterator != end) { PointType p = pointIterator.Value(); // access the point std::cout << p << std::endl; // print the point ++pointIterator; // advance to next point } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that as in STL, the iterator returned by the \code{End()} method is // not a valid iterator. This is called a past-end iterator in order to // indicate that it is the value resulting from advancing one step after // visiting the last element in the container. // // The number of elements stored in a container can be queried with the // \code{Size()} method. In the case of the PointSet, the following two // lines of code are equivalent, both of them returning the number of points // in the PointSet. // // \index{itk::PointSet!GetNumberOfPoints()} // \index{itk::PointSet!GetPoints()} // \index{PointsContainer!Size()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::cout << pointSet->GetNumberOfPoints() << std::endl; std::cout << pointSet->GetPoints()->Size() << std::endl; // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Mesh/PointSet3.cxx000066400000000000000000000222251301006202600242430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The \doxygen{itk}{PointSet} class was designed to interact with the Image class. // For this reason it was found convenient to allow the points in the set to // hold values that could be computed from images. The value associated with // the point is referred as \code{PixelType} in order to make it consistent // with image terminology. Users can define the type as they please thanks to // the flexibility offered by the Generic Programming approach used in the // toolkit. The \code{PixelType} is the first template parameter of the // PointSet. // // \index{itk::PointSet!PixelType} // // Software Guide : EndLatex #include "itkPointSet.h" int main(int, char *[]) { // Software Guide : BeginLatex // // The following code defines a particular type for a pixel type and // instantiates a PointSet class with it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short PixelType; typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet // A point set is instantiated here PointSetType::Pointer pointSet = PointSetType::New(); // Software Guide : BeginLatex // // Data can be inserted into the PointSet using the \code{SetPointData()} // method. This method requires the user to provide an identifier. The data // in question will be associated to the point holding the same identifier. // It is the user's responsibility to verify the appropriate matching between // inserted data and inserted points. The following line illustrates the use // of the \code{SetPointData()} method. // // \index{itk::PointSet!SetPointData()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int dataId = 0; PixelType value = 79; pointSet->SetPointData(dataId++, value); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Data associated with points can be read from the PointSet using the // \code{GetPointData()} method. This method requires the user to provide // the identifier to the point and a valid pointer to a location where the // pixel data can be safely written. In case the identifier does not match // any existing identifier on the PointSet the method will return // \code{false} and the pixel value returned will be invalid. It is the // user's responsibility to check the returned boolean value before // attempting to use it. // // \index{itk::PointSet!GetPointData()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const bool found = pointSet->GetPointData(dataId, &value); if (found) { std::cout << "Pixel value = " << value << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{SetPointData()} and \code{GetPointData()} methods are not the // most efficient way to get access to point data. It is far more efficient // to use the Iterators provided by the \code{PointDataContainer}. // // Data associated with points is internally stored in // \code{PointDataContainer}s. In the same way as with points, the actual // container type used depend on whether the style of the PointSet is static // or dynamic. Static point sets will use an \doxygen{itk}{VectorContainer} while // dynamic point sets will use an \doxygen{itk}{MapContainer}. The type of the // data container is defined as one of the traits in the PointSet. The // following declaration illustrates how the type can be taken from the // traits and used to conveniently declare a similar type on the global // namespace. // // \index{itk::PointSet!PointDataContainer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointDataContainer PointDataContainer; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Using the type it is now possible to create an instance of the data // container. This is a standard reference counted object, henceforth it // uses the \code{New()} method for creation and assigns the newly created // object to a SmartPointer. // // \index{PointDataContainer!New()} // \index{PointDataContainer!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointDataContainer::Pointer pointData = PointDataContainer::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Pixel data can be inserted in the container with the method // \code{InsertElement()}. This method requires an identified to be provided // for each point data. // // \index{PointDataContainer!InsertElement()} // \index{itk::VectorContainer!InsertElement()} // \index{itk::MapContainer!InsertElement()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int pointId = 0; PixelType value0 = 34; PixelType value1 = 67; pointData->InsertElement(pointId++, value0); pointData->InsertElement(pointId++, value1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally the PointDataContainer can be assigned to the PointSet. This will // substitute any previously existing PointDataContainer on the PointSet. The // assignment is done using the \code{SetPointData()} method. // // \index{itk::PointSet!SetPointData()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet pointSet->SetPointData(pointData); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The PointDataContainer can be obtained from the PointSet using the // \code{GetPointData()} method. This method returns a pointer (assigned to // a SmartPointer) to the actual container owned by the PointSet. // // \index{itk::PointSet!GetPointData()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointDataContainer::Pointer pointData2 = pointSet->GetPointData(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The most efficient way to sequentially visit the data associated with // points is to use the iterators provided by \code{PointDataContainer}. The // \code{Iterator} type belongs to the traits of the PointsContainer // classes. The iterator is not a reference counted class, so it is just // created directly from the traits without using SmartPointers. // // \index{PointDataContainer!Iterator} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointDataContainer::Iterator PointDataIterator; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The subsequent use of the iterator follows what you may expect from a STL // iterator. The iterator to the first point is obtained from the container // with the \code{Begin()} method and assigned to another iterator. // // \index{PointDataContainer!Begin()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointDataIterator pointDataIterator = pointData2->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{++} operator on the iterator can be used to advance from one // data point to the next. The actual value of the PixelType to which the // iterator is pointing can be obtained with the \code{Value()} // method. The loop for walking through all the point data can be // controlled by comparing the current iterator with the iterator returned // by the \code{End()} method of the PointsContainer. The following lines // illustrate the typical loop for walking through the point data. // // \index{PointDataContainer!End()} // \index{PointDataContainer!increment ++} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointDataIterator end = pointData2->End(); while (pointDataIterator != end) { PixelType p = pointDataIterator.Value(); // access the pixel data std::cout << p << std::endl; // print the pixel data ++pointDataIterator; // advance to next pixel/point } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that as in STL, the iterator returned by the \code{End()} method is // not a valid iterator. This is called a \emph{past-end} iterator in order // to indicate that it is the value resulting from advancing one step after // visiting the last element in the container. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Mesh/PointSetWithVectors.cxx000066400000000000000000000151441301006202600263640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how a point set can be parameterized to manage a // particular pixel type. It is quite common to associate vector values with // points for producing geometric representations or storing // multi-band information. The following code shows // how vector values can be used as pixel type on the PointSet class. The // \doxygen{itk}{Vector} class is used here as the pixel type. This class is // appropriate for representing the relative position between two points. It // could then be used to manage displacements in disparity map // estimations, for example. // // \index{itk::PointSet!Vector pixels} // // In order to use the vector class it is necessary to include its header file // along with the header of the point set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkVector.h" #include "itkPointSet.h" // Software Guide : EndCodeSnippet int main(int, char *[]) { // Software Guide : BeginLatex // // \itkpiccaption[PointSet with Vectors as PixelType]{Vectors as PixelType.\label{fig:PointSetWithVectors}} // \parpic(6cm, 4cm)[r]{\includegraphics[width=4cm]{PointSetWithVectors.eps}} // // The Vector class is templated over the type used to represent // the spatial coordinates and over the space dimension. Since the // PixelType is independent of the PointType, we are free to select any // dimension for the vectors to be used as pixel type. However, for the // sake of producing an interesting example, we will use vectors that // represent displacements of the points in the PointSet. Those vectors // are then selected to be of the same dimension as the PointSet. // // \index{itk::Vector!itk::PointSet} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef itk::Vector PixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then we use the PixelType (which are actually Vectors) to instantiate the // PointSet type and subsequently create a PointSet object. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::PointSet PointSetType; PointSetType::Pointer pointSet = PointSetType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code is generating a circle and assigning vector values // to the points. The components of the vectors in this example are // computed to represent the tangents to the circle as shown in // Figure~\ref{fig:PointSetWithVectors}. // // \index{itk::PointSet!SetPoint()} // \index{itk::PointSet!SetPointData()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointSetType::PixelType tangent; PointSetType::PointType point; unsigned int pointId = 0; const double radius = 300.0; for (unsigned int i = 0; i < 360; ++i) { const double angle = i * atan(1.0) / 45.0; point[0] = radius * sin(angle); point[1] = radius * cos(angle); tangent[0] = cos(angle); tangent[1] = -sin(angle); pointSet->SetPoint(pointId, point); pointSet->SetPointData(pointId, tangent); pointId++; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now visit all the points and use the vector on the pixel values to // apply a displacement on the points. This is along the spirit of what a // deformable model could do at each one of its iterations. // // \index{itk::PointSet!PointIterator} // \index{itk::PointSet!GetPoints()} // \index{itk::PointSet!GetPointData()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointDataContainer::ConstIterator PointDataIterator; PointDataIterator pixelIterator = pointSet->GetPointData()->Begin(); PointDataIterator pixelEnd = pointSet->GetPointData()->End(); typedef PointSetType::PointsContainer::Iterator PointIterator; PointIterator pointIterator = pointSet->GetPoints()->Begin(); PointIterator pointEnd = pointSet->GetPoints()->End(); while (pixelIterator != pixelEnd && pointIterator != pointEnd) { pointIterator.Value() = pointIterator.Value() + pixelIterator.Value(); ++pixelIterator; ++pointIterator; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that the \code{ConstIterator} was used here instead of the normal // \code{Iterator} since the pixel values are only intended to be read and // not modified. ITK supports const-correctness at the API level. // // \index{ConstIterator} // \index{const-correctness} // // Software Guide : EndLatex // Software Guide : BeginLatex // // The \doxygen{itk}{Vector} class has overloaded the \code{+} operator with // the \doxygen{itk}{Point}. In other words, vectors can be added to points in // order to produce new points. This property is exploited in the center // of the loop in order to update the points positions with a single // statement. // // \index{itk::PointSet!PointIterator} // // We can finally visit all the points and print out the new values // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet pointIterator = pointSet->GetPoints()->Begin(); pointEnd = pointSet->GetPoints()->End(); while (pointIterator != pointEnd) { std::cout << pointIterator.Value() << std::endl; ++pointIterator; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that \doxygen{itk}{Vector} is not the appropriate class for // representing normals to surfaces and gradients of functions. This is due // to the way in which vectors behave under affine transforms. ITK has a // specific class for representing normals and function gradients. This is // the \doxygen{itk}{CovariantVector} class. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Mesh/test/000077500000000000000000000000001301006202600226435ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Mesh/test/CMakeLists.txt000066400000000000000000000000001301006202600253710ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Path/000077500000000000000000000000001301006202600216645ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Path/CMakeLists.txt000066400000000000000000000003201301006202600244170ustar00rootroot00000000000000project(PathExamples) add_executable(PolyLineParametricPath1 PolyLineParametricPath1.cxx ) target_link_libraries(PolyLineParametricPath1 ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/DataRepresentation/Path/PolyLineParametricPath1.cxx000066400000000000000000000062331301006202600270550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how to use the \doxygen{itk}{PolyLineParametricPath}. // This class will typically be used for representing in a concise way the // output of an image segmentation algorithm in 2D. See section // \ref{sec:Alignments} for an example in the context of alignment // detection. The // \code{PolyLineParametricPath} however could also be used for representing // any open or close curve in N-Dimensions as a linear piece-wise approximation. // // // First, the header file of the \code{PolyLineParametricPath} class must be included. // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" // Software Guide : BeginCodeSnippet #include "itkPolyLineParametricPath.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 2) { std::cerr << "Missing arguments" << std::endl; std::cerr << "Usage: PolyLineParametricPath inputImageFileName" << std::endl; return -1; } // Software Guide : BeginLatex // // The path is instantiated over the dimension of the image. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& excp) { std::cout << "Problem reading the input image " << std::endl; std::cout << excp << std::endl; return -1; } // Software Guide : BeginCodeSnippet ImageType::ConstPointer image = reader->GetOutput(); PathType::Pointer path = PathType::New(); path->Initialize(); typedef PathType::ContinuousIndexType ContinuousIndexType; ContinuousIndexType cindex; typedef ImageType::PointType ImagePointType; ImagePointType origin = image->GetOrigin(); ImageType::SpacingType spacing = image->GetSpacing(); ImageType::SizeType size = image->GetBufferedRegion().GetSize(); ImagePointType point; point[0] = origin[0] + spacing[0] * size[0]; point[1] = origin[1] + spacing[1] * size[1]; image->TransformPhysicalPointToContinuousIndex(origin, cindex); path->AddVertex(cindex); image->TransformPhysicalPointToContinuousIndex(point, cindex); path->AddVertex(cindex); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/DataRepresentation/Path/test/000077500000000000000000000000001301006202600226435ustar00rootroot00000000000000OTB-release-5.8/Examples/DataRepresentation/Path/test/CMakeLists.txt000066400000000000000000000000001301006202600253710ustar00rootroot00000000000000OTB-release-5.8/Examples/DimensionReduction/000077500000000000000000000000001301006202600207765ustar00rootroot00000000000000OTB-release-5.8/Examples/DimensionReduction/CMakeLists.txt000066400000000000000000000011521301006202600235350ustar00rootroot00000000000000project(DimensionReductionExamples) add_executable(ICAExample ICAExample.cxx) target_link_libraries(ICAExample ${OTB_LIBRARIES}) add_executable(MaximumAutocorrelationFactor MaximumAutocorrelationFactor.cxx) target_link_libraries(MaximumAutocorrelationFactor ${OTB_LIBRARIES}) add_executable(MNFExample MNFExample.cxx) target_link_libraries(MNFExample ${OTB_LIBRARIES}) add_executable(NAPCAExample NAPCAExample.cxx) target_link_libraries(NAPCAExample ${OTB_LIBRARIES}) add_executable(PCAExample PCAExample.cxx) target_link_libraries(PCAExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/DimensionReduction/ICAExample.cxx000066400000000000000000000217261301006202600234420ustar00rootroot00000000000000 /*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {wv2_cannes_8bands.tif} // OUTPUTS: {FastICAOutput.tif}, {InverseFastICAOutput.tif}, {FastICA-input-pretty.png}, {FastICA-output-pretty.png}, {FastICA-invoutput-pretty.png} // 8 20 1. // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{FastICAImageFilter}. // This filter computes a Fast Independent Components Analysis transform. // // Like Principal Components Analysis, Independent Component Analysis // \cite{jutten1991blind} computes a set of // orthogonal linear combinations, but the criterion of Fast ICA is // different: instead of maximizing variance, it tries to maximize // statistical independence between components. // // In the Fast ICA algorithm \cite{hyvarinen1999fast}, // statistical independence is measured by evaluating non-Gaussianity // of the components, and the maximization is done in an iterative way. // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbFastICAImageFilter.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; const char * inputFileName = argv[1]; const char * outputFilename = argv[2]; const char * outputInverseFilename = argv[3]; const unsigned int numberOfPrincipalComponentsRequired(atoi(argv[7])); const char * inpretty = argv[4]; const char * outpretty = argv[5]; const char * invoutpretty = argv[6]; unsigned int numIterations = atoi(argv[8]); double mu = atof(argv[9]); // Software Guide : BeginLatex // // We start by defining the types for the images, the reader, and // the writer. We choose to work with a \doxygen{otb}{VectorImage}, // since we will produce a multi-channel image (the independent // components) from a multi-channel input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate now the image reader and we set the image file name. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type for the filter. It is templated over the input // and the output image types and also the transformation direction. The // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::FastICAImageFilter FastICAFilterType; FastICAFilterType::Pointer FastICAfilter = FastICAFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We then set the number of independent // components required as output. We can choose to get less ICs than // the number of input bands. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FastICAfilter->SetNumberOfPrincipalComponentsRequired( numberOfPrincipalComponentsRequired); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the number of iterations of the ICA algorithm. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FastICAfilter->SetNumberOfIterations(numIterations); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also set the $\mu$ parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FastICAfilter->SetMu( mu ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now instantiate the writer and set the file name for the // output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We finally plug the pipeline and trigger the ICA computation with // the method \code{Update()} of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FastICAfilter->SetInput(reader->GetOutput()); writer->SetInput(FastICAfilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \doxygen{otb}{FastICAImageFilter} allows also to compute inverse // transformation from ICA coefficients. In reverse mode, the // covariance matrix or the transformation matrix // (which may not be square) has to be given. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::FastICAImageFilter< ImageType, ImageType, otb::Transform::INVERSE > InvFastICAFilterType; InvFastICAFilterType::Pointer invFilter = InvFastICAFilterType::New(); invFilter->SetMeanValues( FastICAfilter->GetMeanValues() ); invFilter->SetStdDevValues( FastICAfilter->GetStdDevValues() ); invFilter->SetTransformationMatrix( FastICAfilter->GetTransformationMatrix() ); invFilter->SetPCATransformationMatrix( FastICAfilter->GetPCATransformationMatrix() ); invFilter->SetInput(FastICAfilter->GetOutput()); WriterType::Pointer invWriter = WriterType::New(); invWriter->SetFileName(outputInverseFilename ); invWriter->SetInput(invFilter->GetOutput() ); invWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:FastICA_FILTER} shows the result of applying forward // and reverse FastICA transformation to a 8 bands Worldview2 image. // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{FastICA-input-pretty.eps} // \includegraphics[width=0.32\textwidth]{FastICA-output-pretty.eps} // \includegraphics[width=0.32\textwidth]{FastICA-invoutput-pretty.eps} // \itkcaption[PCA Filter (forward trasnformation)]{Result of applying the // \doxygen{otb}{FastICAImageFilter} to an image. From left // to right: // original image, color composition with first three independent // components and output of the // inverse mode (the input RGB image).} // \label{fig:FastICA_FILTER} // \end{figure} // // Software Guide : EndLatex // This is for rendering in software guide typedef otb::PrintableImageFilter PrintFilterType; typedef PrintFilterType::OutputImageType VisuImageType; typedef otb::ImageFileWriter VisuWriterType; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer invertOutputPrintFilter = PrintFilterType::New(); VisuWriterType::Pointer inputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer outputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer invertOutputVisuWriter = VisuWriterType::New(); inputPrintFilter->SetInput(reader->GetOutput()); inputPrintFilter->SetChannel(5); inputPrintFilter->SetChannel(3); inputPrintFilter->SetChannel(2); outputPrintFilter->SetInput(FastICAfilter->GetOutput()); outputPrintFilter->SetChannel(1); outputPrintFilter->SetChannel(2); outputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetInput(invFilter->GetOutput()); invertOutputPrintFilter->SetChannel(5); invertOutputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetChannel(2); inputVisuWriter->SetInput(inputPrintFilter->GetOutput()); outputVisuWriter->SetInput(outputPrintFilter->GetOutput()); invertOutputVisuWriter->SetInput(invertOutputPrintFilter->GetOutput()); inputVisuWriter->SetFileName(inpretty); outputVisuWriter->SetFileName(outpretty); invertOutputVisuWriter->SetFileName(invoutpretty); inputVisuWriter->Update(); outputVisuWriter->Update(); invertOutputVisuWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/DimensionReduction/MNFExample.cxx000066400000000000000000000241011301006202600234540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {wv2_cannes_8bands.tif} // OUTPUTS: {MNFOutput.tif}, {InverseMNFOutput.tif}, {MNF-input-pretty.png}, {MNF-output-pretty.png}, {MNF-invoutput-pretty.png} // 8 1 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{MNFImageFilter}. This filter computes a Maximum // Noise Fraction transform \cite{green1988transformation} using an // efficient method based on the inner product in order to compute the // covariance matrix. // // The Maximum Noise Fraction transform is a sequence of two Principal // Component Analysis transforms. The first transform is based on an // estimated covariance matrix of the noise, and intends to whiten the // input image (noise with unit variance and no correlation between // bands). // // The second Principal Component Analysis is then applied to the // noise-whitened image, giving the Maximum Noise Fraction transform. // // In this implementation, noise is estimated from a local window. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMNFImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also need to include the header of the noise filter. // // SoftwareGuide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLocalActivityVectorImageFilter.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; const char * inputFileName = argv[1]; const char * outputFilename = argv[2]; const char * outputInverseFilename = argv[3]; const unsigned int numberOfPrincipalComponentsRequired(atoi(argv[7])); const char * inpretty = argv[4]; const char * outpretty = argv[5]; const char * invoutpretty = argv[6]; unsigned int vradius = atoi(argv[8]); bool normalization = atoi(argv[9]); // Software Guide : BeginLatex // // We start by defining the types for the images, the reader, and // the writer. We choose to work with a \doxygen{otb}{VectorImage}, // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate now the image reader and we set the image file name. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In contrast with standard Principal Component Analysis, MNF // needs an estimation of the noise correlation matrix // in the dataset prior to transformation. // // A classical approach is to use spatial gradient images // and infer the noise correlation matrix from it. // The method of noise estimation can be customized // by templating the \doxygen{otb}{MNFImageFilter} // with the desired noise estimation method. // // In this implementation, noise is estimated from a local window. // We define the type of the noise filter. // // Software Guide : EndLatex // SoftwareGuide : BeginCodeSnippet typedef otb::LocalActivityVectorImageFilter NoiseFilterType; // SoftwareGuide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type for the filter. It is templated over the input // and the output image types and also the transformation direction. The // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MNFImageFilter MNFFilterType; MNFFilterType::Pointer MNFfilter = MNFFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We then set the number of principal // components required as output. We can choose to get less PCs than // the number of input bands. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MNFfilter->SetNumberOfPrincipalComponentsRequired( numberOfPrincipalComponentsRequired); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the radius of the sliding window for noise estimation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NoiseFilterType::RadiusType radius = {{ vradius, vradius }}; MNFfilter->GetNoiseImageFilter()->SetRadius(radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Last, we can activate normalisation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MNFfilter->SetUseNormalization( normalization ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now instantiate the writer and set the file name for the // output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We finally plug the pipeline and trigger the MNF computation with // the method \code{Update()} of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MNFfilter->SetInput(reader->GetOutput()); writer->SetInput(MNFfilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \doxygen{otb}{MNFImageFilter} allows also to compute inverse // transformation from MNF coefficients. In reverse mode, the // covariance matrix or the transformation matrix // (which may not be square) has to be given. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MNFImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE > InvMNFFilterType; InvMNFFilterType::Pointer invFilter = InvMNFFilterType::New(); invFilter->SetMeanValues( MNFfilter->GetMeanValues() ); if ( normalization ) invFilter->SetStdDevValues( MNFfilter->GetStdDevValues() ); invFilter->SetTransformationMatrix( MNFfilter->GetTransformationMatrix() ); invFilter->SetInput(MNFfilter->GetOutput()); WriterType::Pointer invWriter = WriterType::New(); invWriter->SetFileName(outputInverseFilename ); invWriter->SetInput(invFilter->GetOutput() ); invWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:MNF_FILTER} shows the result of applying forward // and reverse MNF transformation to a 8 bands Worldview2 image. // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{MNF-input-pretty.eps} // \includegraphics[width=0.32\textwidth]{MNF-output-pretty.eps} // \includegraphics[width=0.32\textwidth]{MNF-invoutput-pretty.eps} // \itkcaption[PCA Filter (forward trasnformation)]{Result of applying the // \doxygen{otb}{MNFImageFilter} to an image. From left // to right: // original image, color composition with first three principal // components and output of the // inverse mode (the input RGB image).} // \label{fig:MNF_FILTER} // \end{figure} // // Software Guide : EndLatex // This is for rendering in software guide typedef otb::PrintableImageFilter PrintFilterType; typedef PrintFilterType::OutputImageType VisuImageType; typedef otb::ImageFileWriter VisuWriterType; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer invertOutputPrintFilter = PrintFilterType::New(); VisuWriterType::Pointer inputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer outputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer invertOutputVisuWriter = VisuWriterType::New(); inputPrintFilter->SetInput(reader->GetOutput()); inputPrintFilter->SetChannel(5); inputPrintFilter->SetChannel(3); inputPrintFilter->SetChannel(2); outputPrintFilter->SetInput(MNFfilter->GetOutput()); outputPrintFilter->SetChannel(1); outputPrintFilter->SetChannel(2); outputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetInput(invFilter->GetOutput()); invertOutputPrintFilter->SetChannel(5); invertOutputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetChannel(2); inputVisuWriter->SetInput(inputPrintFilter->GetOutput()); outputVisuWriter->SetInput(outputPrintFilter->GetOutput()); invertOutputVisuWriter->SetInput(invertOutputPrintFilter->GetOutput()); inputVisuWriter->SetFileName(inpretty); outputVisuWriter->SetFileName(outpretty); invertOutputVisuWriter->SetFileName(invoutpretty); inputVisuWriter->Update(); outputVisuWriter->Update(); invertOutputVisuWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/DimensionReduction/MaximumAutocorrelationFactor.cxx000066400000000000000000000142141301006202600273730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {wv2_cannes_8bands.tif} // OUTPUTS: {MAFOutput.tif}, {maf-input.png}, {maf-output.png} // // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the class // \doxygen{otb}{MaximumAutocorrelationFactorImageFilter}, which // performs a Maximum Autocorrelation Factor transform \cite{nielsen2011kernel}. Like // PCA, MAF tries to find a set of orthogonal linear transform, but // the criterion to maximize is the spatial auto-correlation rather than the // variance. // // Auto-correlation is the correlation between the component and a // unitary shifted version of the component. // // Please note that the inverse transform is not implemented yet. // // We start by including the corresponding header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMaximumAutocorrelationFactorImageFilter.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* argv[]) { char * infname = argv[1]; char * outfname = argv[2]; char * inpretty = argv[3]; char * outpretty = argv[4]; // Software Guide : BeginLatex // We then define the types for the input image and the // output image. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now declare the types for the reader. Since the images // can be very large, we will force the pipeline to use // streaming. For this purpose, the file writer will be // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // SoftwareGuide : BeginLatex // The \doxygen{otb}{MultivariateAlterationDetectorImageFilter} is templated over // the type of the input images and the type of the generated change // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MaximumAutocorrelationFactorImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different elements of the pipeline can now be instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the parameters of the different elements of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(infname); writer->SetFileName(outfname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We build the pipeline by plugging all the elements together. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And then we can trigger the pipeline update, as usual. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet // This is for rendering in software guide typedef otb::PrintableImageFilter InputPrintFilterType; typedef otb::PrintableImageFilter OutputPrintFilterType; typedef InputPrintFilterType::OutputImageType VisuImageType; typedef otb::ImageFileWriter VisuWriterType; InputPrintFilterType::Pointer inputPrintFilter = InputPrintFilterType::New(); OutputPrintFilterType::Pointer outputPrintFilter = OutputPrintFilterType::New(); VisuWriterType::Pointer inputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer outputVisuWriter = VisuWriterType::New(); inputPrintFilter->SetInput(reader->GetOutput()); inputPrintFilter->SetChannel(5); inputPrintFilter->SetChannel(3); inputPrintFilter->SetChannel(2); outputPrintFilter->SetInput(filter->GetOutput()); outputPrintFilter->SetChannel(1); outputPrintFilter->SetChannel(2); outputPrintFilter->SetChannel(3); inputVisuWriter->SetInput(inputPrintFilter->GetOutput()); outputVisuWriter->SetInput(outputPrintFilter->GetOutput()); inputVisuWriter->SetFileName(inpretty); outputVisuWriter->SetFileName(outpretty); inputVisuWriter->Update(); outputVisuWriter->Update(); // Software Guide : BeginLatex // Figure \ref{fig:MAFFIG} shows the // results of Maximum Autocorrelation Factor applied to an 8 bands // Worldview2 image. // \begin{figure} // \center \includegraphics[width=0.32\textwidth]{maf-input.eps} // \includegraphics[width=0.32\textwidth]{maf-output.eps} // \itkcaption[Maximum Autocorrelation Factor results]{Results of the // Maximum Autocorrelation Factor algorithm applied to a 8 bands // Worldview2 image (3 first components).} \label{fig:MAFFIG} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DimensionReduction/NAPCAExample.cxx000066400000000000000000000245331301006202600236670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {wv2_cannes_8bands.tif} // OUTPUTS: {NAPCAOutput.tif}, {InverseNAPCAOutput.tif}, {napca-input-pretty.png}, {napca-output-pretty.png}, {napca-invoutput-pretty.png} // 8 1 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{NAPCAImageFilter}. This filter computes a Noise-Adjusted // Principal Component Analysis transform \cite{lee1990enhancement} using an // efficient method based on the inner product in order to compute the // covariance matrix. // // The Noise-Adjusted Principal Component Analysis transform is a sequence // of two Principal Component Analysis transforms. The first transform is based // on an estimated covariance matrix of the noise, and intends to whiten the // input image (noise with unit variance and no correlation between // bands). // // The second Principal Component Analysis is then applied to the // noise-whitened image, giving the Maximum Noise Fraction transform. // Applying PCA on noise-whitened image consists in ranking Principal Components according to signal to noise ratio. // // It is basically a reformulation of the Maximum Noise Fraction algorithm. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbNAPCAImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also need to include the header of the noise filter. // // SoftwareGuide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLocalActivityVectorImageFilter.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; const char * inputFileName = argv[1]; const char * outputFilename = argv[2]; const char * outputInverseFilename = argv[3]; const unsigned int numberOfPrincipalComponentsRequired(atoi(argv[7])); const char * inpretty = argv[4]; const char * outpretty = argv[5]; const char * invoutpretty = argv[6]; unsigned int vradius = atoi(argv[8]); bool normalization = atoi(argv[9]); // Software Guide : BeginLatex // // We start by defining the types for the images, the reader and // the writer. We choose to work with a \doxygen{otb}{VectorImage}, // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate now the image reader and we set the image file name. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In contrast with standard Principal Component Analysis, NA-PCA // needs an estimation of the noise correlation matrix // in the dataset prior to transformation. // // A classical approach is to use spatial gradient images // and infer the noise correlation matrix from it. // The method of noise estimation can be customized // by templating the \doxygen{otb}{NAPCAImageFilter} // with the desired noise estimation method. // // In this implementation, noise is estimated from a local window. // We define the type of the noise filter. // // Software Guide : EndLatex // SoftwareGuide : BeginCodeSnippet typedef otb::LocalActivityVectorImageFilter NoiseFilterType; // SoftwareGuide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type for the filter. It is templated over the input // and the output image types, the noise estimation filter type, // and also the transformation direction. The // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::NAPCAImageFilter NAPCAFilterType; NAPCAFilterType::Pointer napcafilter = NAPCAFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We then set the number of principal // components required as output. We can choose to get less PCs than // the number of input bands. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet napcafilter->SetNumberOfPrincipalComponentsRequired( numberOfPrincipalComponentsRequired); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the radius of the sliding window for noise estimation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NoiseFilterType::RadiusType radius = {{ vradius, vradius }}; napcafilter->GetNoiseImageFilter()->SetRadius(radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Last, we can activate normalisation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet napcafilter->SetUseNormalization( normalization ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now instantiate the writer and set the file name for the // output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We finally plug the pipeline and trigger the NA-PCA computation with // the method \code{Update()} of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet napcafilter->SetInput(reader->GetOutput()); writer->SetInput(napcafilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \doxygen{otb}{NAPCAImageFilter} allows also to compute inverse // transformation from NA-PCA coefficients. In reverse mode, the // covariance matrix or the transformation matrix // (which may not be square) has to be given. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::NAPCAImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE > InvNAPCAFilterType; InvNAPCAFilterType::Pointer invFilter = InvNAPCAFilterType::New(); invFilter->SetMeanValues( napcafilter->GetMeanValues() ); if ( normalization ) invFilter->SetStdDevValues( napcafilter->GetStdDevValues() ); invFilter->SetTransformationMatrix( napcafilter->GetTransformationMatrix() ); invFilter->SetInput(napcafilter->GetOutput()); WriterType::Pointer invWriter = WriterType::New(); invWriter->SetFileName(outputInverseFilename ); invWriter->SetInput(invFilter->GetOutput() ); invWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:NAPCA_FILTER} shows the result of applying forward // and reverse NA-PCA transformation to a 8 bands Worldview2 image. // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{napca-input-pretty.eps} // \includegraphics[width=0.32\textwidth]{napca-output-pretty.eps} // \includegraphics[width=0.32\textwidth]{napca-invoutput-pretty.eps} // \itkcaption[PCA Filter (forward trasnformation)]{Result of applying the // \doxygen{otb}{NAPCAImageFilter} to an image. From left // to right: // original image, color composition with first three principal // components and output of the // inverse mode (the input RGB image).} // \label{fig:NAPCA_FILTER} // \end{figure} // // Software Guide : EndLatex // This is for rendering in software guide typedef otb::PrintableImageFilter PrintFilterType; typedef PrintFilterType::OutputImageType VisuImageType; typedef otb::ImageFileWriter VisuWriterType; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer invertOutputPrintFilter = PrintFilterType::New(); VisuWriterType::Pointer inputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer outputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer invertOutputVisuWriter = VisuWriterType::New(); inputPrintFilter->SetInput(reader->GetOutput()); inputPrintFilter->SetChannel(5); inputPrintFilter->SetChannel(3); inputPrintFilter->SetChannel(2); outputPrintFilter->SetInput(napcafilter->GetOutput()); outputPrintFilter->SetChannel(1); outputPrintFilter->SetChannel(2); outputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetInput(invFilter->GetOutput()); invertOutputPrintFilter->SetChannel(5); invertOutputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetChannel(2); inputVisuWriter->SetInput(inputPrintFilter->GetOutput()); outputVisuWriter->SetInput(outputPrintFilter->GetOutput()); invertOutputVisuWriter->SetInput(invertOutputPrintFilter->GetOutput()); inputVisuWriter->SetFileName(inpretty); outputVisuWriter->SetFileName(outpretty); invertOutputVisuWriter->SetFileName(invoutpretty); inputVisuWriter->Update(); outputVisuWriter->Update(); invertOutputVisuWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/DimensionReduction/PCAExample.cxx000066400000000000000000000175451301006202600234550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPrintableImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {wv2_cannes_8bands.tif} // OUTPUTS: {PCAOutput.tif}, {InversePCAOutput.tif}, {input-pretty.png}, {output-pretty.png}, {invoutput-pretty.png} // 8 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{PCAImageFilter}. // This filter computes a Principal Component Analysis using an // efficient method based on the inner product in order to compute the // covariance matrix. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbPCAImageFilter.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; const char * inputFileName = argv[1]; const char * outputFilename = argv[2]; const char * outputInverseFilename = argv[3]; const unsigned int numberOfPrincipalComponentsRequired(atoi(argv[7])); const char * inpretty = argv[4]; const char * outpretty = argv[5]; const char * invoutpretty = argv[6]; // Software Guide : BeginLatex // // We start by defining the types for the images and the reader and // the writer. We choose to work with a \doxygen{otb}{VectorImage}, // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate now the image reader and we set the image file name. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type for the filter. It is templated over the input // and the output image types and also the transformation direction. The // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::PCAImageFilter PCAFilterType; PCAFilterType::Pointer pcafilter = PCAFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The only parameter needed for the PCA is the number of principal // components required as output. Principal components are linear combination of input components // (here the input image bands), // which are selected using Singular Value Decomposition eigen vectors sorted by eigen value. // We can choose to get less Principal Components than // the number of input bands. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet pcafilter->SetNumberOfPrincipalComponentsRequired( numberOfPrincipalComponentsRequired); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now instantiate the writer and set the file name for the // output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We finally plug the pipeline and trigger the PCA computation with // the method \code{Update()} of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet pcafilter->SetInput(reader->GetOutput()); writer->SetInput(pcafilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \doxygen{otb}{PCAImageFilter} allows also to compute inverse // transformation from PCA coefficients. In reverse mode, the // covariance matrix or the transformation matrix // (which may not be square) has to be given. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::PCAImageFilter< ImageType, ImageType, otb::Transform::INVERSE > InvPCAFilterType; InvPCAFilterType::Pointer invFilter = InvPCAFilterType::New(); invFilter->SetInput(pcafilter->GetOutput()); invFilter->SetTransformationMatrix(pcafilter->GetTransformationMatrix()); WriterType::Pointer invWriter = WriterType::New(); invWriter->SetFileName(outputInverseFilename ); invWriter->SetInput(invFilter->GetOutput() ); invWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:PCA_FILTER} shows the result of applying forward // and reverse PCA transformation to a 8 bands Worldview2 image. // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{input-pretty.eps} // \includegraphics[width=0.32\textwidth]{output-pretty.eps} // \includegraphics[width=0.32\textwidth]{invoutput-pretty.eps} // \itkcaption[PCA Filter (forward trasnformation)]{Result of applying the // \doxygen{otb}{PCAImageFilter} to an image. From left // to right: // original image, color composition with first three principal // components and output of the // inverse mode (the input RGB image).} // \label{fig:PCA_FILTER} // \end{figure} // // Software Guide : EndLatex // This is for rendering in software guide typedef otb::PrintableImageFilter PrintFilterType; typedef PrintFilterType::OutputImageType VisuImageType; typedef otb::ImageFileWriter VisuWriterType; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer invertOutputPrintFilter = PrintFilterType::New(); VisuWriterType::Pointer inputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer outputVisuWriter = VisuWriterType::New(); VisuWriterType::Pointer invertOutputVisuWriter = VisuWriterType::New(); inputPrintFilter->SetInput(reader->GetOutput()); inputPrintFilter->SetChannel(5); inputPrintFilter->SetChannel(3); inputPrintFilter->SetChannel(2); outputPrintFilter->SetInput(pcafilter->GetOutput()); outputPrintFilter->SetChannel(1); outputPrintFilter->SetChannel(2); outputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetInput(invFilter->GetOutput()); invertOutputPrintFilter->SetChannel(5); invertOutputPrintFilter->SetChannel(3); invertOutputPrintFilter->SetChannel(2); inputVisuWriter->SetInput(inputPrintFilter->GetOutput()); outputVisuWriter->SetInput(outputPrintFilter->GetOutput()); invertOutputVisuWriter->SetInput(invertOutputPrintFilter->GetOutput()); inputVisuWriter->SetFileName(inpretty); outputVisuWriter->SetFileName(outpretty); invertOutputVisuWriter->SetFileName(invoutpretty); inputVisuWriter->Update(); outputVisuWriter->Update(); invertOutputVisuWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/DimensionReduction/test/000077500000000000000000000000001301006202600217555ustar00rootroot00000000000000OTB-release-5.8/Examples/DimensionReduction/test/CMakeLists.txt000066400000000000000000000000001301006202600245030ustar00rootroot00000000000000OTB-release-5.8/Examples/DisparityMap/000077500000000000000000000000001301006202600176025ustar00rootroot00000000000000OTB-release-5.8/Examples/DisparityMap/CMakeLists.txt000066400000000000000000000014671301006202600223520ustar00rootroot00000000000000project(DisparityMapExamples) add_executable(FineRegistrationImageFilterExample FineRegistrationImageFilterExample.cxx) target_link_libraries(FineRegistrationImageFilterExample ${OTB_LIBRARIES}) add_executable(NCCRegistrationFilterExample NCCRegistrationFilterExample.cxx) target_link_libraries(NCCRegistrationFilterExample ${OTB_LIBRARIES}) add_executable(SimpleDisparityMapEstimationExample SimpleDisparityMapEstimationExample.cxx) target_link_libraries(SimpleDisparityMapEstimationExample ${OTB_LIBRARIES}) #StereoReconstructionExample depends OTBMathParser. But OTB_USE_MUPARSER is OFF if(OTBMathParser_LOADED) add_executable(StereoReconstructionExample StereoReconstructionExample.cxx) target_link_libraries(StereoReconstructionExample ${OTB_LIBRARIES}) endif() if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/DisparityMap/FineRegistrationImageFilterExample.cxx000066400000000000000000000257211301006202600272360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {StereoFixed.png}, {StereoMoving.png} // OUTPUTS: {fcDisplacementFieldOutput-horizontal.png}, {fcDisplacementFieldOutput-vertical.png}, {fcCorrelFieldOutput.png}, {fcDResampledOutput2.png} // 1.0 5 3 0.1 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {StereoFixed.png}, {StereoMoving.png} // OUTPUTS: {fcMRSDDisplacementFieldOutput-horizontal.png}, {fcMRSDDisplacementFieldOutput-vertical.png}, {fcMRSDCorrelFieldOutput.png}, {fcMRSDDResampledOutput2.png} // 1.0 5 3 0.1 mrsd // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example demonstrates the use of the \doxygen{otb}{FineRegistrationImageFilter}. This filter performs deformation estimation // using the classical extrema of image-to-image metric look-up in a search window. // // The first step toward the use of these filters is to include the proper header files. // // Software Guide : EndLatex #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRecursiveGaussianImageFilter.h" #include "otbWarpImageFilter.h" #include "itkMeanReciprocalSquareDifferenceImageToImageMetric.h" // Software Guide : BeginCodeSnippet #include "otbFineRegistrationImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageOfVectorsToMonoChannelExtractROI.h" #include "itkRescaleIntensityImageFilter.h" #include "itkCastImageFilter.h" #include int main(int argc, char** argv) { if (argc < 11) { std::cerr << "Usage: " << argv[0]; std::cerr << " fixedFileName movingFileName fieldOutNameHorizontal fieldOutNameVertical fieldMetric warped "; std::cerr << "smoothingSigma metricRadius explorationRadius subpixelPrecision"; return EXIT_FAILURE; } const unsigned int ImageDimension = 2; typedef double PixelType; typedef itk::Vector DisplacementPixelType; typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; // Software Guide : BeginLatex // // Several type of \doxygen{otb}{Image} are required to represent the input image, the metric field, // and the deformation field. // // Software Guide : EndLatex //Allocate Images // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image MetricImageType; typedef otb::Image DisplacementFieldType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader InputReaderType; InputReaderType::Pointer fReader = InputReaderType::New(); fReader->SetFileName(argv[1]); InputReaderType::Pointer mReader = InputReaderType::New(); mReader->SetFileName(argv[2]); // Software Guide : BeginLatex // // To make the metric estimation more robust, the first // required step is to blur the input images. This is done using the // \doxygen{itk}{RecursiveGaussianImageFilter}: // // Software Guide : EndLatex //Blur input images // Software Guide : BeginCodeSnippet typedef itk::RecursiveGaussianImageFilter InputBlurType; InputBlurType::Pointer fBlur = InputBlurType::New(); fBlur->SetInput(fReader->GetOutput()); fBlur->SetSigma(atof(argv[7])); InputBlurType::Pointer mBlur = InputBlurType::New(); mBlur->SetInput(mReader->GetOutput()); mBlur->SetSigma(atof(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we declare and instantiate the \doxygen{otb}{FineCorrelationImageFilter} which is going to perform the registration: // // Software Guide : EndLatex //Create the filter // Software Guide : BeginCodeSnippet typedef otb::FineRegistrationImageFilter RegistrationFilterType; RegistrationFilterType::Pointer registrator = RegistrationFilterType::New(); registrator->SetMovingInput(mBlur->GetOutput()); registrator->SetFixedInput(fBlur->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Some parameters need to be specified to the filter: // \begin{itemize} // \item The area where the search is performed. This area is defined by its radius: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef RegistrationFilterType::SizeType RadiusType; RadiusType searchRadius; searchRadius[0] = atoi(argv[8]); searchRadius[1] = atoi(argv[8]); registrator->SetSearchRadius(searchRadius); // Software Guide : EndCodeSnippet std::cout << "Exploration radius " << registrator->GetSearchRadius() << std::endl; // Software Guide : BeginLatex // // \item The window used to compute the local metric. This window is also defined by its radius: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RadiusType metricRadius; metricRadius[0] = atoi(argv[9]); metricRadius[1] = atoi(argv[9]); registrator->SetRadius(metricRadius); // Software Guide : EndCodeSnippet std::cout << "Metric radius " << registrator->GetRadius() << std::endl; // Software Guide : BeginLatex // // We need to set the sub-pixel accuracy we want to obtain: // // Software Guide : EndLatex registrator->SetConvergenceAccuracy(atof(argv[10])); // Software Guide : BeginLatex // // The default matching metric used by the \doxygen{FineRegistrationImageFilter} is standard correlation. // However, we may also use any other image-to-image metric provided by ITK. For instance, here is how we // would use the \doxygen{itk}{MutualInformationImageToImageMetric} (do not forget to include the proper header). // // Software Guide : EndLatex if(argc > 11) { // Software Guide : BeginCodeSnippet typedef itk::MeanReciprocalSquareDifferenceImageToImageMetric MRSDMetricType; MRSDMetricType::Pointer mrsdMetric = MRSDMetricType::New(); registrator->SetMetric(mrsdMetric); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{itk}{MutualInformationImageToImageMetric} produces low value for poor matches, therefore, the filter has // to maximize the metric : // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registrator->MinimizeOff(); // Software Guide : EndCodeSnippet } // Software Guide : BeginLatex // // \end{itemize} // The execution of the \doxygen{otb}{FineRegistrationImageFilter} will be triggered by // the \code{Update()} call on the writer at the end of the // pipeline. Make sure to use a // \doxygen{otb}{ImageFileWriter} if you want to benefit // from the streaming features. // // Software Guide : EndLatex typedef otb::ImageOfVectorsToMonoChannelExtractROI ChannelExtractionFilterType; ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New(); channelExtractor->SetInput(registrator->GetOutputDisplacementField()); channelExtractor->SetChannel(1); typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer fieldRescaler = RescalerType::New(); fieldRescaler->SetInput(channelExtractor->GetOutput()); fieldRescaler->SetOutputMaximum(255); fieldRescaler->SetOutputMinimum(0); typedef otb::ImageFileWriter DFWriterType; DFWriterType::Pointer dfWriter = DFWriterType::New(); dfWriter->SetFileName(argv[3]); dfWriter->SetInput(fieldRescaler->GetOutput()); dfWriter->Update(); channelExtractor->SetChannel(2); dfWriter->SetFileName(argv[4]); dfWriter->Update(); typedef otb::WarpImageFilter WarperType; WarperType::Pointer warper = WarperType::New(); InputImageType::PixelType padValue = 4.0; warper->SetInput(mReader->GetOutput()); warper->SetDisplacementField(registrator->GetOutputDisplacementField()); warper->SetEdgePaddingValue(padValue); typedef itk::RescaleIntensityImageFilter MetricRescalerType; MetricRescalerType::Pointer metricRescaler = MetricRescalerType::New(); metricRescaler->SetInput(registrator->GetOutput()); metricRescaler->SetOutputMinimum(0); metricRescaler->SetOutputMaximum(255); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer1 = WriterType::New(); writer1->SetInput(metricRescaler->GetOutput()); writer1->SetFileName(argv[5]); writer1->Update(); typedef itk::CastImageFilter CastFilterType; CastFilterType::Pointer caster = CastFilterType::New(); caster->SetInput(warper->GetOutput()); WriterType::Pointer writer2 = WriterType::New(); writer2->SetFileName(argv[6]); writer2->SetInput(caster->GetOutput()); writer2->Update(); // Software Guide : BeginLatex // // Figure~\ref{fig:FineCorrelationImageFilterOUTPUT} shows the result of // applying the \doxygen{otb}{FineRegistrationImageFilter}. // // \begin{figure} // \center // \includegraphics[width=0.2\textwidth]{StereoFixed.eps} // \includegraphics[width=0.2\textwidth]{StereoMoving.eps} // \includegraphics[width=0.2\textwidth]{fcCorrelFieldOutput.eps} // \includegraphics[width=0.2\textwidth]{fcMRSDCorrelFieldOutput.eps} // \includegraphics[width=0.2\textwidth]{fcDResampledOutput2.eps} // \includegraphics[width=0.2\textwidth]{fcMRSDDResampledOutput2.eps} // \includegraphics[width=0.2\textwidth]{fcDisplacementFieldOutput-horizontal.eps} // \includegraphics[width=0.2\textwidth]{fcMRSDDisplacementFieldOutput-horizontal.eps} // \itkcaption[Displacement field and resampling from fine registration]{From left // to right and top to bottom: fixed input image, moving image with a low stereo angle, // local correlation field, local mean reciprocal square difference field, // resampled image based on correlation, resampled image based on mean reciprocal square difference, // estimated epipolar deformation using on correlation, // estimated epipolar deformation using mean reciprocal square difference. // } // \label{fig:FineCorrelationImageFilterOUTPUT} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DisparityMap/NCCRegistrationFilterExample.cxx000066400000000000000000000203631301006202600260120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {StereoFixed.png}, {StereoMoving.png} // OUTPUTS: {deformationFieldOutput-horizontal.png}, {deformationFieldOutput-vertical.png}, {resampledOutput2.png} // 5 1.0 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example demonstrates the use of the \doxygen{otb}{NCCRegistrationFilter}. This filter performs deformation estimation // by optimising a PDE based on the normalized correlation coefficient. It uses the finite difference solver hierarchy. // // The first step toward the use of these filters is to include the proper header files. // // Software Guide : EndLatex #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbCommandLineArgumentParser.h" // Software Guide : BeginCodeSnippet #include "otbNCCRegistrationFilter.h" #include "itkRecursiveGaussianImageFilter.h" #include "otbWarpImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageOfVectorsToMonoChannelExtractROI.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkCastImageFilter.h" #include int main(int argc, char** argv) { if (argc != 9) { std::cerr << "Usage: " << argv[0]; std::cerr << " fixedFileName movingFileName fieldOutNameHorizontal fieldOutNameVertical imageOutName "; std::cerr << "explorationSize bluringSigma nbIterations "; return EXIT_FAILURE; } const unsigned int ImageDimension = 2; typedef double PixelType; typedef itk::Vector DisplacementPixelType; typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; // Software Guide : BeginLatex // // Several type of \doxygen{otb}{Image} are required to represent the reference image (fixed) // the image we want to register (moving) and the deformation field. // // Software Guide : EndLatex //Allocate Images // Software Guide : BeginCodeSnippet typedef otb::Image MovingImageType; typedef otb::Image FixedImageType; typedef otb::Image DisplacementFieldType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader FixedReaderType; FixedReaderType::Pointer fReader = FixedReaderType::New(); fReader->SetFileName(argv[1]); typedef otb::ImageFileReader MovingReaderType; MovingReaderType::Pointer mReader = MovingReaderType::New(); mReader->SetFileName(argv[2]); // Software Guide : BeginLatex // // To make the correlation estimation more robust, the first // required step is to blur the input images. This is done using the // \doxygen{itk}{RecursiveGaussianImageFilter}: // // Software Guide : EndLatex //Blur input images // Software Guide : BeginCodeSnippet typedef itk::RecursiveGaussianImageFilter FixedBlurType; FixedBlurType::Pointer fBlur = FixedBlurType::New(); fBlur->SetInput(fReader->GetOutput()); fBlur->SetSigma(atof(argv[7])); typedef itk::RecursiveGaussianImageFilter MovingBlurType; MovingBlurType::Pointer mBlur = MovingBlurType::New(); mBlur->SetInput(mReader->GetOutput()); mBlur->SetSigma(atof(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we need to instantiate the NCCRegistrationFilter which is going to perform the registration: // // Software Guide : EndLatex //Create the filter // Software Guide : BeginCodeSnippet typedef otb::NCCRegistrationFilter RegistrationFilterType; RegistrationFilterType::Pointer registrator = RegistrationFilterType::New(); registrator->SetMovingImage(mBlur->GetOutput()); registrator->SetFixedImage(fBlur->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Some parameters need to be specified to the NCCRegistrationFilter: // \begin{itemize} // \item The area where the search is performed. This area is defined by its radius: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef RegistrationFilterType::RadiusType RadiusType; RadiusType radius; radius[0] = atoi(argv[6]); radius[1] = atoi(argv[6]); registrator->SetNCCRadius(radius); // Software Guide : EndCodeSnippet std::cout << "NCC radius " << registrator->GetNCCRadius() << std::endl; // Software Guide : BeginLatex // // \item The number of iterations for the PDE resolution: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registrator->SetNumberOfIterations(atoi(argv[8])); // Software Guide : EndCodeSnippet // registrator->GetDisplacementField(); // Software Guide : BeginLatex // // \end{itemize} // The execution of the NCCRegistrationFilter will be triggered by // the \code{Update()} call on the writer at the end of the // pipeline. Make sure to use a // \doxygen{otb}{ImageFileWriter} if you want to benefit // from the streaming features. // // Software Guide : EndLatex typedef otb::ImageOfVectorsToMonoChannelExtractROI ChannelExtractionFilterType; ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New(); channelExtractor->SetInput(registrator->GetOutput()); channelExtractor->SetChannel(1); typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer fieldRescaler = RescalerType::New(); fieldRescaler->SetInput(channelExtractor->GetOutput()); fieldRescaler->SetOutputMaximum(255); fieldRescaler->SetOutputMinimum(0); typedef otb::ImageFileWriter DFWriterType; DFWriterType::Pointer dfWriter = DFWriterType::New(); dfWriter->SetFileName(argv[3]); dfWriter->SetInput(fieldRescaler->GetOutput()); dfWriter->Update(); channelExtractor->SetChannel(2); dfWriter->SetFileName(argv[4]); dfWriter->Update(); typedef otb::WarpImageFilter WarperType; WarperType::Pointer warper = WarperType::New(); MovingImageType::PixelType padValue = 4.0; warper->SetInput(mReader->GetOutput()); warper->SetDisplacementField(registrator->GetOutput()); warper->SetEdgePaddingValue(padValue); typedef itk::CastImageFilter CastFilterType; CastFilterType::Pointer caster = CastFilterType::New(); caster->SetInput(warper->GetOutput()); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[5]); writer->SetInput(caster->GetOutput()); writer->Update(); // Software Guide : BeginLatex // // Figure~\ref{fig:NCCRegistrationFilterOUTPUT} shows the result of // applying the disparity map estimation. // // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{StereoFixed.eps} // \includegraphics[width=0.40\textwidth]{StereoMoving.eps} // \includegraphics[width=0.40\textwidth]{deformationFieldOutput-horizontal.eps} // \includegraphics[width=0.40\textwidth]{deformationFieldOutput-vertical.eps} // \itkcaption[Displacement field and resampling from NCC registration]{From left // to right and top to bottom: fixed input image, moving image with a low stereo angle, // estimated deformation field in the horizontal direction, estimated deformation field in the vertical direction.} // \label{fig:NCCRegistrationFilterOUTPUT} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DisparityMap/SimpleDisparityMapEstimationExample.cxx000066400000000000000000000444071301006202600274700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {StereoFixed.png}, {StereoMoving.png} // OUTPUTS: {deformationFieldOutput.png}, {resampledMovingOutput.png} // 5 5 9 7 10 100 0.8 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example demonstrates the use of the \doxygen{otb}{DisparityMapEstimationMethod}, along with // the \doxygen{otb}{NearestPointDisplacementFieldGenerator}. The first filter performs deformation estimation // according to a given transform, using embedded ITK registration framework. It takes as input a possibly non regular // point set and produces a point set with associated point data representing the deformation. // // The second filter generates a deformation field by using nearest neighbor interpolation on the deformation values from // the point set. More advanced methods for deformation field interpolation are also available. // // The first step toward the use of these filters is to include the proper header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbDisparityMapEstimationMethod.h" #include "itkTranslationTransform.h" #include "itkNormalizedCorrelationImageToImageMetric.h" #include "itkWindowedSincInterpolateImageFunction.h" #include "itkGradientDescentOptimizer.h" #include "otbBSplinesInterpolateDisplacementFieldGenerator.h" #include "otbWarpImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" int main(int argc, char* argv[]) { if (argc != 12) { std::cerr << "Usage: " << argv[0]; std::cerr << " fixedFileName movingFileName fieldOutName imageOutName "; std::cerr << "pointSetStepX pointSetStepY explorationSize windowSize learningRate "; std::cerr << "nbIterations metricThreshold"; return EXIT_FAILURE; } const unsigned int Dimension = 2; // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We choose to do // all the computation in floating point precision and rescale the results // between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. Please note that // the \doxygen{otb}{NearestPointDisplacementFieldGenerator} generates a // \doxygen{otb}{VectorImage} to represent the deformation field in both // image directions. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The next step is to define the transform we have chosen to model the deformation. In this // example the deformation is modeled as a \doxygen{itk}{TranslationTransform}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::TranslationTransform TransformType; typedef TransformType::ParametersType ParametersType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then we define the metric we will use to evaluate the local registration between the fixed and // the moving image. In this example we chose the \doxygen{itk}{NormalizedCorrelationImageToImageMetric}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::NormalizedCorrelationImageToImageMetric MetricType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Disparity map estimation implies evaluation of the moving image at non-grid position. Therefore, an // interpolator is needed. In this example we chose the \doxygen{itk}{WindowedSincInterpolateImageFunction}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Function::HammingWindowFunction<3> WindowFunctionType; typedef itk::ZeroFluxNeumannBoundaryCondition ConditionType; typedef itk::WindowedSincInterpolateImageFunction InterpolatorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To perform local registration, an optimizer is needed. In this example we chose the // \doxygen{itk}{GradientDescentOptimizer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientDescentOptimizer OptimizerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we will define the point set to represent the point where to compute local disparity. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet typedef PointSetType::PointType PointType; // Software Guide : BeginLatex // // Now we define the disparity map estimation filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::DisparityMapEstimationMethod DMEstimationType; typedef DMEstimationType::SizeType SizeType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input image reader also has to be defined. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Two readers are instantiated : one for the fixed image, and one for the moving image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer fixedReader = ReaderType::New(); ReaderType::Pointer movingReader = ReaderType::New(); fixedReader->SetFileName(argv[1]); movingReader->SetFileName(argv[2]); fixedReader->UpdateOutputInformation(); movingReader->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will the create a regular point set where to compute the local disparity. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SizeType fixedSize = fixedReader->GetOutput()->GetLargestPossibleRegion().GetSize(); unsigned int NumberOfXNodes = (fixedSize[0] - 2 * atoi(argv[7]) - 1) / atoi(argv[5]); unsigned int NumberOfYNodes = (fixedSize[1] - 2 * atoi(argv[7]) - 1) / atoi(argv[6]); ImageType::IndexType firstNodeIndex; firstNodeIndex[0] = atoi(argv[7]); firstNodeIndex[1] = atoi(argv[7]); PointSetType::Pointer nodes = PointSetType::New(); unsigned int nodeCounter = 0; for (unsigned int x = 0; x < NumberOfXNodes; x++) { for (unsigned int y = 0; y < NumberOfYNodes; y++) { PointType p; p[0] = firstNodeIndex[0] + x*atoi(argv[5]); p[1] = firstNodeIndex[1] + y*atoi(argv[6]); nodes->SetPoint(nodeCounter++, p); } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We build the transform, interpolator, metric and optimizer for the disparity map // estimation filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); optimizer->MinimizeOn(); optimizer->SetLearningRate(atof(argv[9])); optimizer->SetNumberOfIterations(atoi(argv[10])); InterpolatorType::Pointer interpolator = InterpolatorType::New(); MetricType::Pointer metric = MetricType::New(); metric->SetSubtractMean(true); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We then set up the disparity map estimation filter. This filter will perform a local registration at each // point of the given point set using the ITK registration framework. It will produce a point set whose point data // reflects the disparity locally around the associated point. // // Point data will contains the following data : // // \begin{enumerate} // \item{The final metric value found in the registration process, } // \item{the deformation value in the first image direction, } // \item{the deformation value in the second image direction, } // \item{the final parameters of the transform.} // \end{enumerate} // // Please note that in the case of a \doxygen{itk}{TranslationTransform}, the deformation values and // the transform parameters are the same. // // Software Guide : EndLatex // Software Guide :BeginCodeSnippet DMEstimationType::Pointer dmestimator = DMEstimationType::New(); dmestimator->SetTransform(transform); dmestimator->SetOptimizer(optimizer); dmestimator->SetInterpolator(interpolator); dmestimator->SetMetric(metric); SizeType windowSize, explorationSize; explorationSize.Fill(atoi(argv[7])); windowSize.Fill(atoi(argv[8])); dmestimator->SetWinSize(windowSize); dmestimator->SetExploSize(explorationSize); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The initial transform parameters can be set via the \code{SetInitialTransformParameters()} method. // In our case, we simply fill the parameter array with null values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet DMEstimationType::ParametersType initialParameters(transform->GetNumberOfParameters()); initialParameters[0] = 0.0; initialParameters[1] = 0.0; dmestimator->SetInitialTransformParameters(initialParameters); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we can set the input for the deformation field estimation filter. Fixed image can be set using the \code{SetFixedImage()} // method, moving image can be set using the \code{SetMovingImage()}, and input point set can be set using the // \code{SetPointSet()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet dmestimator->SetFixedImage(fixedReader->GetOutput()); dmestimator->SetMovingImage(movingReader->GetOutput()); dmestimator->SetPointSet(nodes); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the estimation has been performed by the \doxygen{otb}{DisparityMapEstimationMethod}, one can generate // the associated deformation field (that means translation in first and second image direction). // It will be represented as a \doxygen{otb}{VectorImage}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage DisplacementFieldType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // For the deformation field estimation, we will use the \doxygen{otb}{BSplinesInterpolateDisplacementFieldGenerator}. // This filter will perform a nearest neighbor interpolation on the deformation values in the point set data. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::BSplinesInterpolateDisplacementFieldGenerator GeneratorType; // Software GUide : EndCodeSnippet // Software Guide : BeginLatex // // The disparity map estimation filter is instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet GeneratorType::Pointer generator = GeneratorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We must then specify the input point set using the \code{SetPointSet()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet generator->SetPointSet(dmestimator->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // One must also specify the origin, size and spacing of the output deformation field. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet generator->SetOutputOrigin(fixedReader->GetOutput()->GetOrigin()); generator->SetOutputSpacing(fixedReader->GetOutput()->GetSpacing()); generator->SetOutputSize(fixedReader->GetOutput() ->GetLargestPossibleRegion().GetSize()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The local registration process can lead to wrong deformation values and transform parameters. To Select only // points in point set for which the registration process was successful, one can set a threshold on the final metric // value : points for which the absolute final metric value is below this threshold will be discarded. This // threshold can be set with the \code{SetMetricThreshold()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet generator->SetMetricThreshold(atof(argv[11])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{NNearestPointsLinearInterpolateDisplacementFieldGenerator} // \item \doxygen{otb}{BSplinesInterpolateDisplacementFieldGenerator} // \item \doxygen{otb}{NearestTransformDisplacementFieldGenerator} // \item \doxygen{otb}{NNearestTransformsLinearInterpolateDisplacementFieldGenerator} // \item \doxygen{otb}{BSplinesInterpolateTransformDisplacementFieldGenerator} // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginLatex // // Now we can warp our fixed image according to the estimated deformation field. This will be performed by the // \doxygen{itk}{WarpImageFilter}. First, we define this filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::WarpImageFilter ImageWarperType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then we instantiate it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageWarperType::Pointer warper = ImageWarperType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the input image to warp using the \code{SetInput()} method, and the deformation field // using the \code{SetDisplacementField()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet warper->SetInput(movingReader->GetOutput()); warper->SetDisplacementField(generator->GetOutput()); warper->SetOutputOrigin(fixedReader->GetOutput()->GetOrigin()); warper->SetOutputSpacing(fixedReader->GetOutput()->GetSpacing()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In order to write the result to a PNG file, we will rescale it on a proper range. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer outputRescaler = RescalerType::New(); outputRescaler->SetInput(warper->GetOutput()); outputRescaler->SetOutputMaximum(255); outputRescaler->SetOutputMinimum(0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now write the image to a file. The filters are executed by invoking // the \code{Update()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer outputWriter = WriterType::New(); outputWriter->SetInput(outputRescaler->GetOutput()); outputWriter->SetFileName(argv[4]); outputWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also want to write the deformation field along the first direction to a file. // To achieve this we will use the \doxygen{otb}{MultiToMonoChannelExtractROI} filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MultiToMonoChannelExtractROI ChannelExtractionFilterType; ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New(); channelExtractor->SetInput(generator->GetOutput()); channelExtractor->SetChannel(1); RescalerType::Pointer fieldRescaler = RescalerType::New(); fieldRescaler->SetInput(channelExtractor->GetOutput()); fieldRescaler->SetOutputMaximum(255); fieldRescaler->SetOutputMinimum(0); WriterType::Pointer fieldWriter = WriterType::New(); fieldWriter->SetInput(fieldRescaler->GetOutput()); fieldWriter->SetFileName(argv[3]); fieldWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:SIMPLEDISPARITYMAPESTIMATIONOUTPUT} shows the result of applying disparity map estimation on a stereo pair // using a regular point set, followed by deformation field estimation using Splines and fixed image resampling. // // \begin{figure} // \center // \includegraphics[width=0.20\textwidth]{StereoFixed.eps} // \includegraphics[width=0.20\textwidth]{StereoMoving.eps} // \includegraphics[width=0.20\textwidth]{deformationFieldOutput.eps} // \includegraphics[width=0.20\textwidth]{resampledMovingOutput.eps} // \itkcaption[Displacement field and resampling from disparity map estimation]{From left // to right and top to bottom: fixed input image, moving image with a sinusoid deformation, // estimated deformation field in the horizontal direction, resampled moving image.} // \label{fig:SIMPLEDISPARITYMAPESTIMATIONOUTPUT} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DisparityMap/StereoReconstructionExample.cxx000066400000000000000000000434211301006202600260510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {sensor_stereo_left.tif}, {sensor_stereo_right.tif} // OUTPUTS: {elevationOutput.tif},{elevationOutputPrintable.png} // 140 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example demonstrates the use of the stereo reconstruction chain // from an image pair. The images are assumed to come from the same sensor // but with different positions. The approach presented here has the // following steps: // \begin{itemize} // \item Epipolar resampling of the image pair // \item Dense disparity map estimation // \item Projection of the disparities on an existing Digital Elevation Model (DEM) // \end{itemize} // It is important to note that this method requires the sensor models with // a pose estimate for each image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbStereorectificationDisplacementFieldSource.h" #include "otbStreamingWarpImageFilter.h" #include "otbBandMathImageFilter.h" #include "otbSubPixelDisparityImageFilter.h" #include "otbDisparityMapMedianFilter.h" #include "otbDisparityMapToDEMFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBCOInterpolateImageFunction.h" #include "itkUnaryFunctorImageFilter.h" #include "itkVectorCastImageFilter.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbDEMHandler.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 6) { std::cerr << "Usage: " << argv[0]; std::cerr << " sensorImage1 sensorImage2 outputDEM outputDEMPNG"; std::cerr << "averageElevation " << std::endl; return EXIT_FAILURE; } typedef otb::Image FloatImageType; typedef otb::VectorImage FloatVectorImageType; typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileWriter WriterType; typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::ImageFileWriter OutputWriterType; // Software Guide : BeginLatex // This example demonstrates the use of the following filters : // \begin{itemize} // \item \doxygen{otb}{StereorectificationDisplacementFieldSource} // \item \doxygen{otb}{StreamingWarpImageFilter} // \item \doxygen{otb}{PixelWiseBlockMatchingImageFilter} // \item \doxygen{otb}{otbSubPixelDisparityImageFilter} // \item \doxygen{otb}{otbDisparityMapMedianFilter} // \item \doxygen{otb}{DisparityMapToDEMFilter} // \end{itemize} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::StereorectificationDisplacementFieldSource DisplacementFieldSourceType; typedef itk::Vector DisplacementType; typedef otb::Image DisplacementFieldType; typedef itk::VectorCastImageFilter DisplacementFieldCastFilterType; typedef otb::StreamingWarpImageFilter WarpFilterType; typedef otb::BCOInterpolateImageFunction BCOInterpolationType; typedef otb::Functor::NCCBlockMatching NCCBlockMatchingFunctorType; typedef otb::PixelWiseBlockMatchingImageFilter NCCBlockMatchingFilterType; typedef otb::BandMathImageFilter BandMathFilterType; typedef otb::SubPixelDisparityImageFilter NCCSubPixelDisparityFilterType; typedef otb::DisparityMapMedianFilter MedianFilterType; typedef otb::DisparityMapToDEMFilter DisparityToElevationFilterType; // Software Guide : EndCodeSnippet double avgElevation = atof(argv[5]); otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(avgElevation); ImageReaderType::Pointer leftReader = ImageReaderType::New(); ImageReaderType::Pointer rightReader = ImageReaderType::New(); leftReader->SetFileName(argv[1]); rightReader->SetFileName(argv[2]); // Software Guide : BeginLatex // The image pair is supposed to be in sensor geometry. From two images covering // nearly the same area, one can estimate a common epipolar geometry. In this geometry, // an altitude variation corresponds to an horizontal shift between the two images. // The filter \doxygen{otb}{StereorectificationDisplacementFieldSource} computes the // deformation grids for each image. // // These grids are sampled in epipolar geometry. They have two bands, containing // the position offset (in physical space units) between the current epipolar // point and the corresponding sensor point in horizontal and vertical // direction. They can be computed at a lower resolution than sensor // resolution. The application \code{StereoRectificationGridGenerator} also // provides a simple tool to generate the epipolar grids for your image pair. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet DisplacementFieldSourceType::Pointer m_DisplacementFieldSource = DisplacementFieldSourceType::New(); m_DisplacementFieldSource->SetLeftImage(leftReader->GetOutput()); m_DisplacementFieldSource->SetRightImage(rightReader->GetOutput()); m_DisplacementFieldSource->SetGridStep(4); m_DisplacementFieldSource->SetScale(1.0); //m_DisplacementFieldSource->SetAverageElevation(avgElevation); m_DisplacementFieldSource->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Then, the sensor images can be resampled in epipolar geometry, using the // \doxygen{otb}{StreamingWarpImageFilter}. The application // \code{GridBasedImageResampling} also gives an easy access to this filter. The user // can choose the epipolar region to resample, as well as the resampling step // and the interpolator. // // Note that the epipolar image size can be retrieved from the stereo rectification grid // filter. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FloatImageType::SpacingType epipolarSpacing; epipolarSpacing[0] = 1.0; epipolarSpacing[1] = 1.0; FloatImageType::SizeType epipolarSize; epipolarSize = m_DisplacementFieldSource->GetRectifiedImageSize(); FloatImageType::PointType epipolarOrigin; epipolarOrigin[0] = 0.0; epipolarOrigin[1] = 0.0; FloatImageType::PixelType defaultValue = 0; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The deformation grids are casted into deformation fields, then the left // and right sensor images are resampled. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet DisplacementFieldCastFilterType::Pointer m_LeftDisplacementFieldCaster = DisplacementFieldCastFilterType::New(); m_LeftDisplacementFieldCaster->SetInput(m_DisplacementFieldSource->GetLeftDisplacementFieldOutput()); m_LeftDisplacementFieldCaster->GetOutput()->UpdateOutputInformation(); BCOInterpolationType::Pointer leftInterpolator = BCOInterpolationType::New(); leftInterpolator->SetRadius(2); WarpFilterType::Pointer m_LeftWarpImageFilter = WarpFilterType::New(); m_LeftWarpImageFilter->SetInput(leftReader->GetOutput()); m_LeftWarpImageFilter->SetDisplacementField(m_LeftDisplacementFieldCaster->GetOutput()); m_LeftWarpImageFilter->SetInterpolator(leftInterpolator); m_LeftWarpImageFilter->SetOutputSize(epipolarSize); m_LeftWarpImageFilter->SetOutputSpacing(epipolarSpacing); m_LeftWarpImageFilter->SetOutputOrigin(epipolarOrigin); m_LeftWarpImageFilter->SetEdgePaddingValue(defaultValue); DisplacementFieldCastFilterType::Pointer m_RightDisplacementFieldCaster = DisplacementFieldCastFilterType::New(); m_RightDisplacementFieldCaster->SetInput(m_DisplacementFieldSource->GetRightDisplacementFieldOutput()); m_RightDisplacementFieldCaster->GetOutput()->UpdateOutputInformation(); BCOInterpolationType::Pointer rightInterpolator = BCOInterpolationType::New(); rightInterpolator->SetRadius(2); WarpFilterType::Pointer m_RightWarpImageFilter = WarpFilterType::New(); m_RightWarpImageFilter->SetInput(rightReader->GetOutput()); m_RightWarpImageFilter->SetDisplacementField(m_RightDisplacementFieldCaster->GetOutput()); m_RightWarpImageFilter->SetInterpolator(rightInterpolator); m_RightWarpImageFilter->SetOutputSize(epipolarSize); m_RightWarpImageFilter->SetOutputSpacing(epipolarSpacing); m_RightWarpImageFilter->SetOutputOrigin(epipolarOrigin); m_RightWarpImageFilter->SetEdgePaddingValue(defaultValue); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Since the resampling produces black regions around the image, it is useless // to estimate disparities on these \textit{no-data} regions. We use a \doxygen{otb}{BandMathImageFilter} // to produce a mask on left and right epipolar images. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet BandMathFilterType::Pointer m_LBandMathFilter = BandMathFilterType::New(); m_LBandMathFilter->SetNthInput(0,m_LeftWarpImageFilter->GetOutput(),"inleft"); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS std::string leftExpr = "inleft != 0 ? 255 : 0"; #else std::string leftExpr = "if(inleft != 0,255,0)"; #endif m_LBandMathFilter->SetExpression(leftExpr); BandMathFilterType::Pointer m_RBandMathFilter = BandMathFilterType::New(); m_RBandMathFilter->SetNthInput(0,m_RightWarpImageFilter->GetOutput(),"inright"); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS std::string rightExpr = "inright != 0 ? 255 : 0"; #else std::string rightExpr = "if(inright != 0,255,0)"; #endif m_RBandMathFilter->SetExpression(rightExpr); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Once the two sensor images have been resampled in epipolar geometry, the // disparity map can be computed. The approach presented here is a 2D matching // based on a pixel-wise metric optimization. This approach doesn't give the best // results compared to global optimization methods, but it is suitable for // streaming and threading on large images. // // The major filter used for this step is \doxygen{otb}{PixelWiseBlockMatchingImageFilter}. // The metric is computed on a window centered around the tested epipolar position. // It performs a pixel-to-pixel matching between the two epipolar images. The output disparities // are given as index offset from left to right position. The following features are available // in this filter: // \begin{itemize} // \item Available metrics : SSD, NCC and $L^{p}$ pseudo norm (computed on a square window) // \item Rectangular disparity exploration area. // \item Input masks for left and right images (optional). // \item Output metric values (optional). // \item Possibility to use input disparity estimate (as a uniform value or a full map) and an // exploration radius around these values to reduce the size of the exploration area (optional). // \end{itemize} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NCCBlockMatchingFilterType::Pointer m_NCCBlockMatcher = NCCBlockMatchingFilterType::New(); m_NCCBlockMatcher->SetLeftInput(m_LeftWarpImageFilter->GetOutput()); m_NCCBlockMatcher->SetRightInput(m_RightWarpImageFilter->GetOutput()); m_NCCBlockMatcher->SetRadius(3); m_NCCBlockMatcher->SetMinimumHorizontalDisparity(-24); m_NCCBlockMatcher->SetMaximumHorizontalDisparity(0); m_NCCBlockMatcher->SetMinimumVerticalDisparity(0); m_NCCBlockMatcher->SetMaximumVerticalDisparity(0); m_NCCBlockMatcher->MinimizeOff(); m_NCCBlockMatcher->SetLeftMaskInput(m_LBandMathFilter->GetOutput()); m_NCCBlockMatcher->SetRightMaskInput(m_RBandMathFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Some other filters have been added to enhance these \textit{pixel-to-pixel} disparities. The filter // \doxygen{otb}{SubPixelDisparityImageFilter} can estimate the disparities with sub-pixel // precision. Several interpolation methods can be used : parabolic fit, triangular fit, and // dichotomy search. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NCCSubPixelDisparityFilterType::Pointer m_NCCSubPixFilter = NCCSubPixelDisparityFilterType::New(); m_NCCSubPixFilter->SetInputsFromBlockMatchingFilter(m_NCCBlockMatcher); m_NCCSubPixFilter->SetRefineMethod(NCCSubPixelDisparityFilterType::DICHOTOMY); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The filter \doxygen{otb}{DisparityMapMedianFilter} can be used to remove outliers. It has two // parameters: // \begin{itemize} // \item The radius of the local neighborhood to compute the median // \item An incoherence threshold to reject disparities whose distance from the local median // is superior to the threshold. // \end{itemize} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MedianFilterType::Pointer m_HMedianFilter = MedianFilterType::New(); m_HMedianFilter->SetInput(m_NCCSubPixFilter->GetHorizontalDisparityOutput()); m_HMedianFilter->SetRadius(2); m_HMedianFilter->SetIncoherenceThreshold(2.0); m_HMedianFilter->SetMaskInput(m_LBandMathFilter->GetOutput()); MedianFilterType::Pointer m_VMedianFilter = MedianFilterType::New(); m_VMedianFilter->SetInput(m_NCCSubPixFilter->GetVerticalDisparityOutput()); m_VMedianFilter->SetRadius(2); m_VMedianFilter->SetIncoherenceThreshold(2.0); m_VMedianFilter->SetMaskInput(m_LBandMathFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The application \code{PixelWiseBlockMatching} contains all these filters and // provides a single interface to compute your disparity maps. // // The disparity map obtained with the previous step usually gives a good idea of // the altitude profile. However, it is more useful to study altitude with a DEM (Digital // Elevation Model) representation. // // The filter \doxygen{otb}{DisparityMapToDEMFilter} performs this last step. The behavior // of this filter is to : // \begin{itemize} // \item Compute the DEM extent from the left sensor image envelope (spacing is set by the user) // \item Compute the left and right rays corresponding to each valid disparity // \item Compute the intersection with the \textit{mid-point} method // \item If the 3D point falls inside a DEM cell and has a greater elevation than the // current height, the cell height is updated // \end{itemize} // The rule of keeping the highest elevation makes sense for buildings seen from the side // because the roof edges elevation has to be kept. However this rule is not suited for // noisy disparities. // // The application \code{DisparityMapToElevationMap} also gives an example of use. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet DisparityToElevationFilterType::Pointer m_DispToElev = DisparityToElevationFilterType::New(); m_DispToElev->SetHorizontalDisparityMapInput(m_HMedianFilter->GetOutput()); m_DispToElev->SetVerticalDisparityMapInput(m_VMedianFilter->GetOutput()); m_DispToElev->SetLeftInput(leftReader->GetOutput()); m_DispToElev->SetRightInput(rightReader->GetOutput()); m_DispToElev->SetLeftEpipolarGridInput(m_DisplacementFieldSource->GetLeftDisplacementFieldOutput()); m_DispToElev->SetRightEpipolarGridInput(m_DisplacementFieldSource->GetRightDisplacementFieldOutput()); m_DispToElev->SetElevationMin(avgElevation-10.0); m_DispToElev->SetElevationMax(avgElevation+80.0); m_DispToElev->SetDEMGridStep(2.5); m_DispToElev->SetDisparityMaskInput(m_LBandMathFilter->GetOutput()); //m_DispToElev->SetAverageElevation(avgElevation); WriterType::Pointer m_DEMWriter = WriterType::New(); m_DEMWriter->SetInput(m_DispToElev->GetOutput()); m_DEMWriter->SetFileName(argv[3]); m_DEMWriter->Update(); RescalerType::Pointer fieldRescaler = RescalerType::New(); fieldRescaler->SetInput(m_DispToElev->GetOutput()); fieldRescaler->SetOutputMaximum(255); fieldRescaler->SetOutputMinimum(0); OutputWriterType::Pointer fieldWriter = OutputWriterType::New(); fieldWriter->SetInput(fieldRescaler->GetOutput()); fieldWriter->SetFileName(argv[4]); fieldWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:STEREORECONSTRUCTIONOUTPUT} shows the result of applying // terrain reconstruction based using pixel-wise block matching, sub-pixel // interpolation and DEM estimation using a pair of Pleiades images over the // \textit{Stadium} in Toulouse, France. // \begin{figure} // \center // \includegraphics[width=0.4\textwidth]{elevationOutputPrintable.eps} // \itkcaption[From stereo pair to elevation]{DEM image estimated from the disparity.} // \label{fig:STEREORECONSTRUCTIONOUTPUT} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/DisparityMap/test/000077500000000000000000000000001301006202600205615ustar00rootroot00000000000000OTB-release-5.8/Examples/DisparityMap/test/CMakeLists.txt000066400000000000000000000021421301006202600233200ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/DisparityMap) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- SimpleDisparityMapEstimationExampleTest ---------- otb_add_test(NAME dmTeSimpleDisparityMapEstimationExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/deformationFieldOutput.png ${TEMP}/deformationFieldOutput.png ${BASELINE}/resampledMovingOutput.png ${TEMP}/resampledMovingOutput.png Execute $ ${INPUTDATA}/StereoFixed.png ${INPUTDATA}/StereoMoving.png ${TEMP}/deformationFieldOutput.png ${TEMP}/resampledMovingOutput.png 100 10 15 10 10 250 0.9 ) if(OTBMathParser_LOADED) #otb_add_test(NAME dmTeStereoReconstructionExampleTest COMMAND ${OTB_TEST_DRIVER} #--compare-image ${NOTOL} #${BASELINE}/elevationOutput.tif #${TEMP}/elevationOutput.tif #Execute $ #${INPUTDATA}/sensor_stereo_left.tif #${INPUTDATA}/sensor_stereo_right.tif #${TEMP}/elevationOutput.tif #${TEMP}/elevationOutputPrintable.png #140 #) endif() OTB-release-5.8/Examples/FeatureExtraction/000077500000000000000000000000001301006202600206305ustar00rootroot00000000000000OTB-release-5.8/Examples/FeatureExtraction/AlignmentsExample.cxx000066400000000000000000000153141301006202600247750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {QB_SuburbAlign.png} // 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{ImageToPathListAlignFilter}. // This filter allows extracting meaninful alignments. Alignments // (that is edges and lines) are detected using the {\em Gestalt} // approach proposed by Desolneux et al. \cite{desolneux}. In this // context, an event is // considered meaningful if the expectation of its occurrence would be // very small in a random image. One can thus consider that in a // random image the direction of the gradient of a given point is // uniformly distributed, and that neighbouring pixels have a very low // probability of having the same gradient direction. This algorithm // gives a set of straight line segments defined by the two extremity // coordinates under the form of a \code{std::list} of // \code{itk::PolyLineParametricPath}. // // The first step required to use this filter is to include its header. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageToPathListAlignFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // In order to visualize the detected alignments, we will use the // facility class \doxygen{otb}{DrawPathFilter} which draws a // \code{itk::PolyLineParametricPath} on top of a given image. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkPolyLineParametricPath.h" #include "otbDrawPathFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include #include int main(int argc, char *argv[]) { if (argc != 4) { std::cout << "Usage : " << argv[0] << " inputImage outputImage epsilon" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned short InputPixelType; typedef unsigned short OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); reader->Update(); // Software Guide : BeginLatex // // The \doxygen{otb}{ImageToPathListAlignFilter} is templated over the // input image type and the output path type, so we start by // defining: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::PolyLineParametricPath PathType; typedef otb::ImageToPathListAlignFilter ListAlignFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next, we build the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ListAlignFilterType::Pointer alignFilter = ListAlignFilterType::New(); alignFilter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can choose the number of accepted false alarms in the // detection with the method \code{SetEps()} for which the parameter // is of the form $-log10(\text{max. number of false alarms})$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet alignFilter->SetEps(atoi(argv[3])); // Software Guide : EndCodeSnippet alignFilter->Update(); // Software Guide : BeginLatex // // As stated, above, the \doxygen{otb}{DrawPathFilter}, is useful for // drawint the detected alignments. This class is templated over // the input image and path types and also on the output image // type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::DrawPathFilter DrawPathFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We will now go through the list of detected paths and feed them // to the \doxygen{otb}{DrawPathFilter} inside a loop. We will use a list // iterator inside a \code{while} statement. // Software Guide : BeginCodeSnippet typedef ListAlignFilterType::OutputPathListType ListType; ListType* pathList = alignFilter->GetOutput(); ListType::Iterator listIt = pathList->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define a dummy image will be iteratively fed to the // \doxygen{otb}{DrawPathFilter} after the drawing of each alignment. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputImageType::Pointer backgroundImage = reader->GetOutput(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We iterate through the list and write the result to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (listIt != pathList->End()) { DrawPathFilterType::Pointer drawPathFilter = DrawPathFilterType::New(); drawPathFilter->SetImageInput(backgroundImage); drawPathFilter->SetInputPath(listIt.Get()); drawPathFilter->SetValue(itk::NumericTraits::max()); drawPathFilter->Update(); backgroundImage = drawPathFilter->GetOutput(); ++listIt; } writer->SetInput(backgroundImage); // Software Guide : EndCodeSnippet writer->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:Align} shows the result of applying the alignment // detection to a small patch extracted from a VHR image. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.35\textwidth]{QB_SuburbAlign.eps} // \itkcaption[Alignment Detection Application]{Result of applying the // \doxygen{otb}{ImageToPathListAlignFilter} to a VHR image of a suburb.} // \label{fig:Align} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/AsymmetricFusionOfLineDetectorExample.cxx000066400000000000000000000160341301006202600307640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {amst.png} // OUTPUTS: {amstLineFusion.png} // 5 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{AssymmetricFusionOfLineDetectorImageFilter}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbAssymmetricFusionOfLineDetectorImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputEdgesImageFile length width" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::AssymmetricFusionOfLineDetectorImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The same is done for the rescaler and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RescalerType::Pointer rescaler = RescalerType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The \code{itk::RescaleIntensityImageFilter} needs to know which // is the minimu and maximum values of the output generated // image. Those can be chosen in a generic way by using the // \code{NumericTraits} functions, since they are templated over // the pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{AsymmetricFusionOfDetectorImageFilter}. The pipeline is built as follows. // // \index{otb::AsymmetricFusionOfDetectorImageFilter!SetInput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The methods \code{SetLengthLine()} and \code{SetWidthLine()} // allow setting the minimum length and the typical witdh of the // lines which are to be detected. // // \index{otb::AsymmetricFusionOfDetector!SetWidthLine()} // \index{otb::AsymmetricFusionOfDetector!SetLengthLine()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetLengthLine(atoi(argv[3])); filter->SetWidthLine(atoi(argv[4])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter is executed by invoking the \code{Update()} method. If the // filter is part of a larger image processing pipeline, calling // \code{Update()} on a downstream filter will also trigger update of this // filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:LINEFUSION_FILTER} // shows the result of applying the AsymmetricFusionOf edge detector filter // to a SAR image. \begin{figure} \center // \includegraphics[width=0.25\textwidth]{amst.eps} // \includegraphics[width=0.25\textwidth]{amstLineFusion.eps} // \itkcaption[Line Correlation Detector Application]{Result of applying // the \doxygen{otb}{AsymmetricFusionOfDetectorImageFilter} to a SAR // image. From left to right : original image, line intensity.} \label{fig:LINEFUSION_FILTER} \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/CMakeLists.txt000066400000000000000000000073561301006202600234030ustar00rootroot00000000000000project(FeatureExtractionExamples) add_executable(AsymmetricFusionOfLineDetectorExample AsymmetricFusionOfLineDetectorExample.cxx) target_link_libraries(AsymmetricFusionOfLineDetectorExample ${OTB_LIBRARIES}) add_executable(CloudDetectionExample CloudDetectionExample.cxx) target_link_libraries(CloudDetectionExample ${OTB_LIBRARIES}) add_executable(ComplexMomentPathExample ComplexMomentPathExample.cxx) target_link_libraries(ComplexMomentPathExample ${OTB_LIBRARIES}) add_executable(ComplexMomentsImageFunctionExample ComplexMomentsImageFunctionExample.cxx) target_link_libraries(ComplexMomentsImageFunctionExample ${OTB_LIBRARIES}) add_executable(CorrelationLineDetectorExample CorrelationLineDetectorExample.cxx) target_link_libraries(CorrelationLineDetectorExample ${OTB_LIBRARIES}) add_executable(EdgeDensityExample EdgeDensityExample.cxx) target_link_libraries(EdgeDensityExample ${OTB_LIBRARIES}) #OTBRoadExtraction depends OTBMathParser. But OTB_USE_MUPARSER is OFF if(OTBMathParser_LOADED) add_executable(ExtractRoadByStepsExample ExtractRoadByStepsExample.cxx) target_link_libraries(ExtractRoadByStepsExample ${OTB_LIBRARIES}) add_executable(ExtractRoadExample ExtractRoadExample.cxx) target_link_libraries(ExtractRoadExample ${OTB_LIBRARIES}) add_executable(ParallelLineDetectionExample ParallelLineDetectionExample.cxx) target_link_libraries(ParallelLineDetectionExample ${OTB_LIBRARIES}) add_executable(AlignmentsExample AlignmentsExample.cxx) target_link_libraries(AlignmentsExample ${OTB_LIBRARIES}) endif() add_executable(ExtractSegmentsByStepsExample ExtractSegmentsByStepsExample.cxx) target_link_libraries(ExtractSegmentsByStepsExample ${OTB_LIBRARIES}) add_executable(ExtractSegmentsExample ExtractSegmentsExample.cxx) target_link_libraries(ExtractSegmentsExample ${OTB_LIBRARIES}) add_executable(FlusserMomentsImageFunctionExample FlusserMomentsImageFunctionExample.cxx) target_link_libraries(FlusserMomentsImageFunctionExample ${OTB_LIBRARIES}) add_executable(HarrisExample HarrisExample.cxx) target_link_libraries(HarrisExample ${OTB_LIBRARIES}) add_executable(HuMomentsImageFunctionExample HuMomentsImageFunctionExample.cxx) target_link_libraries(HuMomentsImageFunctionExample ${OTB_LIBRARIES}) if (Module_OTBVectorDataRendering AND OTB_USE_MAPNIK) add_executable(LineSegmentDetectorExample LineSegmentDetectorExample.cxx) target_link_libraries(LineSegmentDetectorExample ${OTB_LIBRARIES}) add_executable(RightAngleDetectionExample RightAngleDetectionExample.cxx) target_link_libraries(RightAngleDetectionExample ${OTB_LIBRARIES}) endif() add_executable(LocalHoughExample LocalHoughExample.cxx) target_link_libraries(LocalHoughExample ${OTB_LIBRARIES}) add_executable(PanTexExample PanTexExample.cxx) target_link_libraries(PanTexExample ${OTB_LIBRARIES}) add_executable(RatioLineDetectorExample RatioLineDetectorExample.cxx) target_link_libraries(RatioLineDetectorExample ${OTB_LIBRARIES}) add_executable(SeamCarvingExample SeamCarvingExample.cxx) target_link_libraries(SeamCarvingExample ${OTB_LIBRARIES}) add_executable(SeamCarvingOtherExample SeamCarvingOtherExample.cxx) target_link_libraries(SeamCarvingOtherExample ${OTB_LIBRARIES}) add_executable(SFSExample SFSExample.cxx) target_link_libraries(SFSExample ${OTB_LIBRARIES}) add_executable(SURFExample SURFExample.cxx) target_link_libraries(SURFExample ${OTB_LIBRARIES}) add_executable(TextureExample TextureExample.cxx) target_link_libraries(TextureExample ${OTB_LIBRARIES}) add_executable(ThresholdToPointSetExample ThresholdToPointSetExample.cxx) target_link_libraries(ThresholdToPointSetExample ${OTB_LIBRARIES}) add_executable(TouziEdgeDetectorExample TouziEdgeDetectorExample.cxx) target_link_libraries(TouziEdgeDetectorExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/FeatureExtraction/CloudDetectionExample.cxx000066400000000000000000000221641301006202600256020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {CloudsOnReunion.tif} // OUTPUTS: {CloudDetectionOutput.tif} , {pretty_CloudsOnReunion.png} , {pretty_CloudDetectionOutput.png} // 553 467 734 581 0.4 0.6 1.0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The cloud detection functor is a processing chain composed by the // computation of a spectral angle (with SpectralAngleFunctor). The // result is multiplied by a gaussian factor (with // CloudEstimatorFunctor) and finally thresholded to obtain a binary // image (with CloudDetectionFilter). However, modifications can be // added in the pipeline to adapt to a particular situation. // // This example demonstrates the use of the // \doxygen{otb}{CloudDetectionFilter}. This filter uses the spectral // angle principle to measure the radiometric gap between a reference // pixel and the other pixels of the image. // // The first step toward the use of this filter is the inclusion of // the proper header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbCloudDetectionFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbMultiChannelExtractROI.h" int main(int argc, char * argv[]) { if (argc != 12) { std::cerr << "Usage: " << argv[0]; std::cerr << "inputFileName outputFileName printableInputFileName printableOutputFileName"; std::cerr << "firstPixelComponent secondPixelComponent thirdPixelComponent fourthPixelComponent "; std::cerr << "variance "; std::cerr << "minThreshold maxThreshold " << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the images. We choose to do // all the computations in double precision. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double InputPixelType; typedef double OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the // dimension. Please note that the // \doxygen{otb}{CloudDetectionFilter} needs an // \doxygen{otb}{VectorImage} as input to handle multispectral // images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage VectorImageType; typedef VectorImageType::PixelType VectorPixelType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define the functor type that the filter will use. We use the // \doxygen{otb}{CloudDetectionFunctor}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Functor::CloudDetectionFunctor FunctorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we can define the \doxygen{otb}{CloudDetectionFilter} that // takes a multi-spectral image as input and produces a binary // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::CloudDetectionFilter CloudDetectionFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in // order to read image data from a file. Then, an // \doxygen{otb}{ImageFileWriter} is instantiated in order to write // the output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different filters composing our pipeline are created by invoking their // \code{New()} methods, assigning the results to smart pointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); CloudDetectionFilterType::Pointer cloudDetection = CloudDetectionFilterType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); cloudDetection->SetInput(reader->GetOutput()); // Software Guide : BeginLatex // // The \doxygen{otb}{CloudDetectionFilter} needs to have a reference // pixel corresponding to the spectral content likely to represent a // cloud. This is done by passing a pixel to the filter. Here we // suppose that the input image has four spectral bands. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorPixelType referencePixel; referencePixel.SetSize(4); referencePixel.Fill(0.); referencePixel[0] = (atof(argv[5])); referencePixel[1] = (atof(argv[6])); referencePixel[2] = (atof(argv[7])); referencePixel[3] = (atof(argv[8])); cloudDetection->SetReferencePixel(referencePixel); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We must also set the variance parameter of the filter and the // parameter of the gaussian functor. The bigger the value, the // more tolerant the detector will be. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet cloudDetection->SetVariance(atof(argv[9])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The minimum and maximum thresholds are set to binarise the final result. // These values have to be between 0 and 1. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet cloudDetection->SetMinThreshold(atof(argv[10])); cloudDetection->SetMaxThreshold(atof(argv[11])); // Software Guide : EndCodeSnippet // Software Guide : BeginCodeSnippet writer->SetFileName(argv[2]); writer->SetInput(cloudDetection->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:CLOUDDETECTION_FILTER} shows the result of applying // the cloud detection filter to a cloudy image. // \begin{figure} \center // \includegraphics[width=0.44\textwidth]{pretty_CloudsOnReunion.eps} // \includegraphics[width=0.44\textwidth]{pretty_CloudDetectionOutput.eps} // \itkcaption[Cloud Detection Example]{From left to right : original image, cloud mask resulting from processing.} // \label{fig:CLOUDDETECTION_FILTER} // \end{figure} // // Software Guide : EndLatex // Pretty image creation for printing typedef otb::Image OutputPrettyImageType; typedef otb::VectorImage InputPrettyImageType; typedef otb::ImageFileWriter WriterPrettyOutputType; typedef otb::ImageFileWriter WriterPrettyInputType; typedef itk::RescaleIntensityImageFilter RescalerOutputType; typedef otb::VectorRescaleIntensityImageFilter RescalerInputType; typedef otb::MultiChannelExtractROI ChannelExtractorType; ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); RescalerInputType::Pointer inputRescaler = RescalerInputType::New(); WriterPrettyInputType::Pointer prettyInputWriter = WriterPrettyInputType::New(); selecter->SetInput(reader->GetOutput()); selecter->SetChannel(3); selecter->SetChannel(2); selecter->SetChannel(1); inputRescaler->SetInput(selecter->GetOutput()); VectorPixelType minimum, maximum; minimum.SetSize(3); maximum.SetSize(3); minimum.Fill(0); maximum.Fill(255); inputRescaler->SetOutputMinimum(minimum); inputRescaler->SetOutputMaximum(maximum); prettyInputWriter->SetFileName(argv[3]); prettyInputWriter->SetInput(inputRescaler->GetOutput()); RescalerOutputType::Pointer outputRescaler = RescalerOutputType::New(); WriterPrettyOutputType::Pointer prettyOutputWriter = WriterPrettyOutputType::New(); outputRescaler->SetInput(cloudDetection->GetOutput()); outputRescaler->SetOutputMinimum(0); outputRescaler->SetOutputMaximum(255); prettyOutputWriter->SetFileName(argv[4]); prettyOutputWriter->SetInput(outputRescaler->GetOutput()); prettyInputWriter->Update(); prettyOutputWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ComplexMomentPathExample.cxx000066400000000000000000000073561301006202600263070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" // Software Guide : BeginCommandLineArgs // 1 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The complex moments can be computed on images, but sometimes we are // interested in computing them on shapes extracted from images by // segmentation algorithms. These shapes can be represented by // \doxygen{itk}{Path}s. This example illustrates the use of the // \doxygen{otb}{ComplexMomentPathFunction} for the computation of // complex geometric moments on ITK paths. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbComplexMomentPathFunction.h" // Software Guide : EndCodeSnippet #include "itkPolyLineParametricPath.h" int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " p q" << std::endl; return EXIT_FAILURE; } unsigned int P((unsigned char) ::atoi(argv[1])); unsigned int Q((unsigned char) ::atoi(argv[2])); // Software Guide : BeginLatex // // The \doxygen{otb}{ComplexMomentPathFunction} is templated over the // input path type and the output complex type value, so we start by // defining: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef std::complex ComplexType; typedef otb::ComplexMomentPathFunction CMType; CMType::Pointer cmFunction = CMType::New(); // Software Guide : EndCodeSnippet PathType::Pointer path = PathType::New(); path->Initialize(); typedef PathType::ContinuousIndexType ContinuousIndexType; ContinuousIndexType cindex; // Draw a square: path->Initialize(); cindex[0] = 30; cindex[1] = 30; path->AddVertex(cindex); cindex[0] = 30; cindex[1] = 130; path->AddVertex(cindex); cindex[0] = 130; cindex[1] = 130; path->AddVertex(cindex); cindex[0] = 130; cindex[1] = 30; path->AddVertex(cindex); // Software Guide : BeginLatex // // Next, we set the parameters of the plug the input path into the complex moment function // and we set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet cmFunction->SetInputPath(path); cmFunction->SetQ(Q); cmFunction->SetP(P); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Since the paths are defined in physical coordinates, we do not // need to set the center for the moment computation as we did // with the \doxygen{otb}{ComplexMomentImageFunction}. The same // applies for the size of the neighborhood around the // center pixel for the moment computation. The moment computation // is triggered by calling the \code{Evaluate} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ComplexType Result = cmFunction->Evaluate(); std::cout << "The moment of order (" << P << "," << Q << ") is equal to " << Result << std::endl; // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ComplexMomentsImageFunctionExample.cxx000066400000000000000000000067741301006202600303310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // 2 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{ComplexMomentsImageFunction}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbComplexMomentsImageFunction.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " p q" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; unsigned int P((unsigned char) ::atoi(argv[2])); unsigned int Q((unsigned char) ::atoi(argv[3])); typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Software Guide : BeginLatex // // The \doxygen{otb}{ComplexMomentImageFunction} is templated over the // input image type and the output complex type value, so we start by // defining: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ComplexMomentsImageFunction CMType; typedef CMType::OutputType OutputType; CMType::Pointer cmFunction = CMType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next, we plug the input image into the complex moment function // and we set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->Update(); cmFunction->SetInputImage(reader->GetOutput()); cmFunction->SetQmax(Q); cmFunction->SetPmax(P); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We can chose the pixel of the image which will used as center // for the moment computation // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputImageType::IndexType center; center[0] = 50; center[1] = 50; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We can also choose the size of the neighborhood around the // center pixel for the moment computation. // // Software Guide : EndLatex cmFunction->SetNeighborhoodRadius(15); // Software Guide : BeginLatex // In order to get the value of the moment, we call the // \code{EvaluateAtIndex} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OutputType Result = cmFunction->EvaluateAtIndex(center); std::cout << "The moment of order (" << P << "," << Q << ") is equal to " << Result.at(P).at(Q) << std::endl; // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/CorrelationLineDetectorExample.cxx000066400000000000000000000176611301006202600274660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {amst.png} // OUTPUTS: {amstLineCorrelations.png}, {amstLineCorrelationDirections.png} // 5 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{CorrelationLineDetectorImageFilter}. // This filter is used for line detection in SAR images. Its principle // is described in \cite{tup-98}: a line is detected if two parallel // edges are present in the images. These edges are detected with the // correlation of means detector. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLineCorrelationDetectorImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 6) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputEdgesImageFile outputDirectionsImageFile length width" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LineCorrelationDetectorImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The same is done for the rescaler and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RescalerType::Pointer rescaler = RescalerType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The \code{itk::RescaleIntensityImageFilter} needs to know which // is the minimu and maximum values of the output generated // image. Those can be chosen in a generic way by using the // \code{NumericTraits} functions, since they are templated over // the pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{LineCorrelationDetectorImageFilter}. The pipeline is built as follows. // // \index{otb::LineCorrelationDetectorImageFilter!SetInput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The methods \code{SetLengthLine()} and \code{SetWidthLine()} // allow setting the minimum length and the typical witdh of the // lines which are to be detected. // // \index{otb::LineCorrelationDetector!SetWidthLine()} // \index{otb::LineCorrelationDetector!SetLengthLine()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetLengthLine(atoi(argv[4])); filter->SetWidthLine(atoi(argv[5])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter is executed by invoking the \code{Update()} method. If the // filter is part of a larger image processing pipeline, calling // \code{Update()} on a downstream filter will also trigger update of this // filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // We can also obtain the direction of the lines by invoking the // \code{GetOutputDirections()} method. // Software Guide : EndLatex writer->SetFileName(argv[3]); // Software Guide : BeginCodeSnippet rescaler->SetInput(filter->GetOutputDirection()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex Figure~\ref{fig:LINECORRELATION_FILTER} // shows the result of applying the LineCorrelation edge detector filter // to a SAR image. \begin{figure} \center // \includegraphics[width=0.25\textwidth]{amst.eps} // \includegraphics[width=0.25\textwidth]{amstLineCorrelations.eps} // \includegraphics[width=0.25\textwidth]{amstLineCorrelationDirections.eps} // \itkcaption[Line Correlation Detector Application]{Result of applying // the \doxygen{otb}{LineCorrelationDetectorImageFilter} to a SAR // image. From left to right : original image, line intensity and // edge orientation.} \label{fig:LINECORRELATION_FILTER} \end{figure} // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{LineCorrelationDetectorImageFilter} // \end{itemize} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/EdgeDensityExample.cxx000066400000000000000000000165211301006202600251010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {suburb2.jpeg} // OUTPUTS: {EdgeDensityOutput.tif}, {PrettyEdgeDensityOutput.png} // 7 50 10 1.0 0.01 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{EdgeDensityImageFilter}. // This filter computes a local density of edges on an image and can // be useful to detect man made objects or urban areas, for // instance. The filter has been implemented in a generic way, so that // the way the edges are detected and the way their density is // computed can be chosen by the user. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbEdgeDensityImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will also include the header files for the edge detector (a // Canny filter) and the density estimation (a simple count on a // binary image). // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkCannyEdgeDetectionImageFilter.h" #include "otbBinaryImageDensityFunction.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const char * prettyfilename = argv[3]; const unsigned int radius = atoi(argv[4]); /*--*/ const unsigned int Dimension = 2; typedef float PixelType; /** Variables for the canny detector*/ const PixelType upperThreshold = static_cast(atof(argv[5])); const PixelType lowerThreshold = static_cast(atof(argv[6])); const double variance = atof(argv[7]); const double maximumError = atof(argv[8]); // Software Guide : BeginLatex // // As usual, we start by defining the types for the images, the reader // and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define now the type for the function which will be used by the // edge density filter to estimate this density. Here we choose a // function which counts the number of non null pixels per area. The // function takes as template the type of the image to be processed. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::BinaryImageDensityFunction CountFunctionType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // These {\em non null pixels} will be the result of an edge // detector. We use here the classical Canny edge detector, which is // templated over the input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CannyEdgeDetectionImageFilter CannyDetectorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we can define the type for the edge density filter which // takes as template the input and output image types, the edge // detector type, and the count function type.. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::EdgeDensityImageFilter EdgeDensityFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the different processing objects of the // pipeline using the \code{New()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); EdgeDensityFilterType::Pointer filter = EdgeDensityFilterType::New(); CannyDetectorType::Pointer cannyFilter = CannyDetectorType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The edge detection filter needs to be instantiated because we // need to set its parameters. This is what we do here for the Canny // filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet cannyFilter->SetUpperThreshold(upperThreshold); cannyFilter->SetLowerThreshold(lowerThreshold); cannyFilter->SetVariance(variance); cannyFilter->SetMaximumError(maximumError); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After that, we can pass the edge detector to the filter which // will be used it internally. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetDetector(cannyFilter); filter->SetNeighborhoodRadius(radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we set the file names for the input and the output // images and we plug the pipeline. The \code{Update()} method of // the writer will trigger the processing. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(infname); writer->SetFileName(outfname); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:EDGEDENSITY_FILTER} shows the result of applying // the edge density filter to an image. // \begin{figure} // \center // \includegraphics[width=0.25\textwidth]{suburb2.eps} // \includegraphics[width=0.25\textwidth]{PrettyEdgeDensityOutput.eps} // \itkcaption[Edge Density Filter]{Result of applying the // \doxygen{otb}{EdgeDensityImageFilter} to an image. From left to right : // original image, edge density.} // \label{fig:EDGEDENSITY_FILTER} // \end{figure} // // Software Guide : EndLatex /************* Image for printing **************/ typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(filter->GetOutput()); typedef otb::ImageFileWriter OutputWriterType; OutputWriterType::Pointer outwriter = OutputWriterType::New(); outwriter->SetFileName(prettyfilename); outwriter->SetInput(rescaler->GetOutput()); outwriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ExtractRoadByStepsExample.cxx000066400000000000000000000532371301006202600264340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the details of the \doxygen{otb}{RoadExtractionFilter}. // This filter, described in the previous section, is a composite filter that includes // all the steps below. Individual filters can be replaced to design a road detector // targeted at SAR images for example. // // Software Guide : EndLatex #include "otbPolyLineParametricPathWithValue.h" #include "otbSpectralAngleDistanceImageFilter.h" #include "itkGradientRecursiveGaussianImageFilter.h" #include "otbNeighborhoodScalarProductFilter.h" #include "otbRemoveIsolatedByDirectionFilter.h" #include "otbRemoveWrongDirectionFilter.h" #include "otbNonMaxRemovalByDirectionFilter.h" #include "otbVectorizationPathListFilter.h" #include "otbSimplifyPathListFilter.h" #include "otbBreakAngularPathListFilter.h" #include "otbRemoveTortuousPathListFilter.h" #include "otbLinkPathListFilter.h" #include "otbLikelihoodPathListFilter.h" #include "otbDrawPathListFilter.h" #include "otbLikelihoodPathListFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkSqrtImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "itkAddImageFilter.h" #include "itkSubtractImageFilter.h" #include "itkRGBPixel.h" #include "itkComposeImageFilter.h" #include "itkThresholdImageFilter.h" #include "itkSigmoidImageFilter.h" #include "itkThresholdImageFilter.h" #include "itkBinaryBallStructuringElement.h" #include "itkGrayscaleDilateImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {qb_RoadExtract.tif} // OUTPUTS: {ExtractRoadByStepsExampleOutput.jpg}, {qb_ExtractRoad_pretty.jpg} // 337 557 432 859 0.00005 1.0 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {qb_RoadExtract2.tif} // OUTPUTS: {ExtractRoadByStepsExampleOutput2.jpg}, {qb_ExtractRoad_pretty2.jpg} // 228 316 207 282 0.00005 1.0 // Software Guide : EndCommandLineArgs int main(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned char OutputPixelType; typedef itk::CovariantVector VectorPixelType; typedef otb::Image InternalImageType; typedef otb::VectorImage MultiSpectralImageType; typedef otb::Image VectorImageType; typedef otb::PolyLineParametricPathWithValue PathType; typedef otb::ImageFileReader MultispectralReaderType; MultispectralReaderType::Pointer multispectralReader = MultispectralReaderType::New(); multispectralReader->SetFileName(argv[1]); // Create an 3 band image for the software guide typedef otb::VectorImage OutputVectorImageType; typedef otb::ImageFileWriter VectorWriterType; typedef otb::VectorRescaleIntensityImageFilter VectorRescalerType; typedef otb::MultiChannelExtractROI ChannelExtractorType; // The GenerateOutputInformation() information is required here so // that the number of component per pixel is update and known to set // up the maximum and minimum values for the rescaling filter multispectralReader->GenerateOutputInformation(); OutputVectorImageType::PixelType minimum, maximum; minimum.SetSize( multispectralReader->GetOutput()->GetNumberOfComponentsPerPixel()); maximum.SetSize( multispectralReader->GetOutput()->GetNumberOfComponentsPerPixel()); minimum.Fill(0); maximum.Fill(255); VectorRescalerType::Pointer vr = VectorRescalerType::New(); vr->SetInput(multispectralReader->GetOutput()); vr->SetOutputMinimum(minimum); vr->SetOutputMaximum(maximum); vr->SetClampThreshold(0.01); ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); selecter->SetInput(vr->GetOutput()); selecter->SetExtractionRegion( multispectralReader->GetOutput()->GetLargestPossibleRegion()); selecter->SetChannel(3); selecter->SetChannel(2); selecter->SetChannel(1); VectorWriterType::Pointer vectWriter = VectorWriterType::New(); vectWriter->SetFileName(argv[3]); vectWriter->SetInput(selecter->GetOutput()); vectWriter->Update(); MultiSpectralImageType::PixelType pixelRef; pixelRef.SetSize(4); pixelRef[0] = atoi(argv[4]); pixelRef[1] = atoi(argv[5]); pixelRef[2] = atoi(argv[6]); pixelRef[3] = atoi(argv[7]); double resolution = 0.6; //to get directly from metadata double alpha = atof(argv[9]); // Software Guide : BeginLatex // // The spectral angle is used to compute a grayscale image from the // multispectral original image using // \doxygen{otb}{SpectralAngleDistanceImageFilter}. The spectral // angle is illustrated on // Figure~\ref{fig:RoadExtractionSpectralAngleDiagram}. Pixels // corresponding to roads are in darker color. // // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{RoadExtractionSpectralAngleDiagram.eps} // \itkcaption[Spectral Angle]{Illustration of the spectral angle // for one pixel of a three-band image. One of the vector is the // reference pixel and the other is the current pixel.} // \label{fig:RoadExtractionSpectralAngleDiagram} // \end{figure} // // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SpectralAngleDistanceImageFilter SAFilterType; SAFilterType::Pointer saFilter = SAFilterType::New(); saFilter->SetReferencePixel(pixelRef); saFilter->SetInput(multispectralReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A square root is applied to the spectral angle image in order to enhance contrast between // darker pixels (which are pixels of interest) with \doxygen{itk}{SqrtImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::SqrtImageFilter SqrtFilterType; SqrtFilterType::Pointer sqrtFilter = SqrtFilterType::New(); sqrtFilter->SetInput(saFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Use the Gaussian gradient filter compute the gradient in x and y direction // respectively // (\doxygen{itk}{GradientRecursiveGaussianImageFilter}). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double sigma = alpha * (1.2 / resolution + 1); typedef itk::GradientRecursiveGaussianImageFilter GradientFilterType; GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); gradientFilter->SetSigma(sigma); gradientFilter->SetInput(sqrtFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Compute the scalar product of the neighboring pixels and keep the // minimum value and the direction with \doxygen{otb}{NeighborhoodScalarProductFilter}. // This is the line detector described // in \cite{Lacroix1998}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::NeighborhoodScalarProductFilter NeighborhoodScalarProductType; NeighborhoodScalarProductType::Pointer scalarFilter = NeighborhoodScalarProductType::New(); scalarFilter->SetInput(gradientFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The resulting image is passed to the \doxygen{otb}{RemoveIsolatedByDirectionFilter} // filter to remove pixels // with no neighbor having the same direction. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::RemoveIsolatedByDirectionFilter RemoveIsolatedByDirectionType; RemoveIsolatedByDirectionType::Pointer removeIsolatedByDirectionFilter = RemoveIsolatedByDirectionType::New(); removeIsolatedByDirectionFilter->SetInput(scalarFilter->GetOutput()); removeIsolatedByDirectionFilter ->SetInputDirection(scalarFilter->GetOutputDirection()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We remove pixels having a direction corresponding to bright lines // as we know that after the spectral angle, roads are in darker color // with the \doxygen{otb}{RemoveWrongDirectionFilter} filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::RemoveWrongDirectionFilter RemoveWrongDirectionType; RemoveWrongDirectionType::Pointer removeWrongDirectionFilter = RemoveWrongDirectionType::New(); removeWrongDirectionFilter->SetInput( removeIsolatedByDirectionFilter->GetOutput()); removeWrongDirectionFilter->SetInputDirection( scalarFilter->GetOutputDirection()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We remove pixels which are not maximum on the direction // perpendicular to the road direction with the \doxygen{otb}{NonMaxRemovalByDirectionFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::NonMaxRemovalByDirectionFilter NonMaxRemovalByDirectionType; NonMaxRemovalByDirectionType::Pointer nonMaxRemovalByDirectionFilter = NonMaxRemovalByDirectionType::New(); nonMaxRemovalByDirectionFilter->SetInput( removeWrongDirectionFilter->GetOutput()); nonMaxRemovalByDirectionFilter ->SetInputDirection(scalarFilter->GetOutputDirection()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Extracted road are vectorized into polylines with \doxygen{otb}{VectorizationPathListFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorizationPathListFilter VectorizationFilterType; VectorizationFilterType::Pointer vectorizationFilter = VectorizationFilterType::New(); vectorizationFilter->SetInput(nonMaxRemovalByDirectionFilter->GetOutput()); vectorizationFilter->SetInputDirection(scalarFilter->GetOutputDirection()); vectorizationFilter->SetAmplitudeThreshold(atof(argv[8])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // However, this vectorization is too simple and need to be refined // to be usable. First, we remove all aligned points to make one segment with // \doxygen{otb}{SimplifyPathListFilter}. // Then we break the polylines which have sharp angles as they are probably // not road with \doxygen{otb}{BreakAngularPathListFilter}. // Finally we remove path which are too short with \doxygen{otb}{RemoveTortuousPathListFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SimplifyPathListFilter SimplifyPathType; SimplifyPathType::Pointer simplifyPathListFilter = SimplifyPathType::New(); simplifyPathListFilter->GetFunctor().SetTolerance(1.0); simplifyPathListFilter->SetInput(vectorizationFilter->GetOutput()); typedef otb::BreakAngularPathListFilter BreakAngularPathType; BreakAngularPathType::Pointer breakAngularPathListFilter = BreakAngularPathType::New(); breakAngularPathListFilter->SetMaxAngle(otb::CONST_PI / 8.); breakAngularPathListFilter->SetInput(simplifyPathListFilter->GetOutput()); typedef otb::RemoveTortuousPathListFilter RemoveTortuousPathType; RemoveTortuousPathType::Pointer removeTortuousPathListFilter = RemoveTortuousPathType::New(); removeTortuousPathListFilter->GetFunctor().SetThreshold(1.0); removeTortuousPathListFilter->SetInput(breakAngularPathListFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Polylines within a certain range are linked (\doxygen{otb}{LinkPathListFilter}) to // try to fill gaps due to occultations by vehicules, trees, etc. before simplifying // polylines (\doxygen{otb}{SimplifyPathListFilter}) and // removing the shortest ones with \doxygen{otb}{RemoveTortuousPathListFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LinkPathListFilter LinkPathType; LinkPathType::Pointer linkPathListFilter = LinkPathType::New(); linkPathListFilter->SetDistanceThreshold(25.0 / resolution); linkPathListFilter->SetAngularThreshold(otb::CONST_PI / 8); linkPathListFilter->SetInput(removeTortuousPathListFilter->GetOutput()); SimplifyPathType::Pointer simplifyPathListFilter2 = SimplifyPathType::New(); simplifyPathListFilter2->GetFunctor().SetTolerance(1.0); simplifyPathListFilter2->SetInput(linkPathListFilter->GetOutput()); RemoveTortuousPathType::Pointer removeTortuousPathListFilter2 = RemoveTortuousPathType::New(); removeTortuousPathListFilter2->GetFunctor().SetThreshold(10.0); removeTortuousPathListFilter2->SetInput(simplifyPathListFilter2->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A value can be associated with each polyline according to pixel values // under the polyline with \doxygen{otb}{LikelihoodPathListFilter}. A higher value // will mean a higher Likelihood to be a road. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LikelihoodPathListFilter PathListToPathListWithValueType; PathListToPathListWithValueType::Pointer pathListConverter = PathListToPathListWithValueType::New(); pathListConverter->SetInput(removeTortuousPathListFilter2->GetOutput()); pathListConverter->SetInputImage(nonMaxRemovalByDirectionFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A black background image is built to draw the path on. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InternalImageType::Pointer output = InternalImageType::New(); output->CopyInformation(multispectralReader->GetOutput()); output->SetRegions(output->GetLargestPossibleRegion()); output->Allocate(); output->FillBuffer(0.0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Polylines are drawn on a black background image with \doxygen{otb}{DrawPathListFilter}. // The \code{SetUseIternalValues()} tell the drawing filter to draw the path with its Likelihood // value. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::DrawPathListFilter DrawPathType; DrawPathType::Pointer drawPathListFilter = DrawPathType::New(); drawPathListFilter->SetInput(output); drawPathListFilter->SetInputPath(pathListConverter->GetOutput()); drawPathListFilter->SetUseInternalPathValue(true); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output from the drawing filter contains very small values (Likelihood values). Therefore // the image has to be rescaled to be viewed. The whole pipeline is executed by invoking // the \code{Update()} method on this last filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMaximum(255); rescaler->SetOutputMinimum(0); rescaler->SetInput(drawPathListFilter->GetOutput()); rescaler->Update(); // Software Guide : EndCodeSnippet // this small piece of code aims at producing a pretty RGB png result image. typedef otb::MultiToMonoChannelExtractROI ChannelExtractionFilterType; typedef itk::AddImageFilter AddFilterType; typedef itk::SubtractImageFilter SubtractFilterType; typedef itk::ThresholdImageFilter ThresholdFilterType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image RGBImageType; typedef itk::ComposeImageFilter ComposeFilterType; typedef otb::ImageFileWriter RGBWriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef itk::GrayscaleDilateImageFilter DilateFilterType; StructuringElementType se; se.SetRadius(1); se.CreateStructuringElement(); // Filters definitions ChannelExtractionFilterType::Pointer channelExtractor1 = ChannelExtractionFilterType::New(); ChannelExtractionFilterType::Pointer channelExtractor2 = ChannelExtractionFilterType::New(); ChannelExtractionFilterType::Pointer channelExtractor3 = ChannelExtractionFilterType::New(); AddFilterType::Pointer addFilter = AddFilterType::New(); SubtractFilterType::Pointer subtract2 = SubtractFilterType::New(); SubtractFilterType::Pointer subtract3 = SubtractFilterType::New(); ThresholdFilterType::Pointer threshold11 = ThresholdFilterType::New(); ThresholdFilterType::Pointer threshold21 = ThresholdFilterType::New(); ThresholdFilterType::Pointer threshold31 = ThresholdFilterType::New(); ThresholdFilterType::Pointer threshold12 = ThresholdFilterType::New(); ThresholdFilterType::Pointer threshold22 = ThresholdFilterType::New(); ThresholdFilterType::Pointer threshold32 = ThresholdFilterType::New(); ComposeFilterType::Pointer composer = ComposeFilterType::New(); RGBWriterType::Pointer writer = RGBWriterType::New(); DilateFilterType::Pointer dilater = DilateFilterType::New(); dilater->SetInput(rescaler->GetOutput()); dilater->SetKernel(se); // Extract each channel channelExtractor1->SetInput(vr->GetOutput()); channelExtractor2->SetInput(vr->GetOutput()); channelExtractor3->SetInput(vr->GetOutput()); channelExtractor1->SetChannel(3); channelExtractor2->SetChannel(2); channelExtractor3->SetChannel(1); // Add the path to the red component addFilter->SetInput1(channelExtractor1->GetOutput()); addFilter->SetInput2(dilater->GetOutput()); subtract2->SetInput1(channelExtractor2->GetOutput()); subtract2->SetInput2(dilater->GetOutput()); subtract3->SetInput1(channelExtractor3->GetOutput()); subtract3->SetInput2(dilater->GetOutput()); // Threshold outside the [0, 255] range threshold11->SetInput(addFilter->GetOutput()); threshold11->ThresholdBelow(0); threshold11->SetOutsideValue(0); threshold12->SetInput(threshold11->GetOutput()); threshold12->ThresholdAbove(255); threshold12->SetOutsideValue(255); threshold21->SetInput(subtract2->GetOutput()); threshold21->ThresholdBelow(0); threshold21->SetOutsideValue(0); threshold22->SetInput(threshold21->GetOutput()); threshold22->ThresholdAbove(255); threshold22->SetOutsideValue(255); threshold31->SetInput(subtract3->GetOutput()); threshold31->ThresholdBelow(0); threshold31->SetOutsideValue(0); threshold32->SetInput(threshold31->GetOutput()); threshold32->ThresholdAbove(255); threshold32->SetOutsideValue(255); // Compose the output image composer->SetInput(0, threshold12->GetOutput()); composer->SetInput(1, threshold22->GetOutput()); composer->SetInput(2, threshold32->GetOutput()); // Write the new rgb image writer->SetInput(composer->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // // Figures~\ref{fig:ROADEXTRACTIONBYSTEPS} and \ref{fig:ROADEXTRACTIONBYSTEPS2} // show the result of applying // the road extraction by steps to a fusionned Quickbird image. The result image // is a RGB composition showing the extracted path in red. Full processing took // about 3 seconds for each image. // // \begin{figure}[htbp] // \center // \includegraphics[width=0.44\textwidth]{qb_ExtractRoad_pretty.eps} // \includegraphics[width=0.44\textwidth]{ExtractRoadByStepsExampleOutput.eps} // \itkcaption[Road extraction filter application]{Result of applying // the road extraction by steps pipeline to a fusionned Quickbird // image. From left to right : original image, extracted road with their // Likelihood values.} // \label{fig:ROADEXTRACTIONBYSTEPS} // \end{figure} // // \begin{figure}[htbp] // \center // \includegraphics[width=0.44\textwidth]{qb_ExtractRoad_pretty2.eps} // \includegraphics[width=0.44\textwidth]{ExtractRoadByStepsExampleOutput2.eps} // \itkcaption[Road extraction filter application]{Result of applying // the road extraction by steps pipeline to a fusionned Quickbird // image. From left to right : original image, extracted road with their // Likelihood values.} // \label{fig:ROADEXTRACTIONBYSTEPS2} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ExtractRoadExample.cxx000066400000000000000000000333351301006202600251170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {qb_RoadExtract.tif} // OUTPUTS: {ExtractRoadOutput.png} // 337 557 432 859 1.0 0.00005 1.0 0.39269 1.0 10.0 25. // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The easiest way to use the road extraction filter provided by OTB is to use the composite // filter. If a modification in the pipeline is required to adapt to a particular situation, // the step by step example, described in the next section can be adapted. // // This example demonstrates the use of the \doxygen{otb}{RoadExtractionFilter}. // This filter is a composite filter achieving road extraction according to the algorithm // adapted by E. Christophe and J. Inglada \cite{Christophe2007} from an original method // proposed in \cite{Lacroix1998}. // // The first step toward the use of this filter is the inclusion of the proper header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbPolyLineParametricPathWithValue.h" #include "otbRoadExtractionFilter.h" #include "otbDrawPathListFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbMath.h" #include "itkInvertIntensityImageFilter.h" #include "itkGrayscaleDilateImageFilter.h" #include "itkBinaryBallStructuringElement.h" int main(int argc, char * argv[]) { if (argc != 14) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputFileName outputFileName firstPixelComponent secondPixelComponent "; std::cerr << "thirdPixelComponent fourthPixelComponent alpha amplitudeThrehsold tolerance "; std::cerr << "angularThreshold-maxAngle firstMeanDistanceThreshold secondMeanDistanceThreshold "; std::cerr << "distanceThreshold" << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We choose to do // all the computation in floating point precision and rescale the results // between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double InputPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. Please note that // the \doxygen{otb}{RoadExtractionFilter} needs an \doxygen{otb}{VectorImage} as input // to handle multispectral images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage InputVectorImageType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type of the polyline that the filter produces. We use the // \doxygen{otb}{PolyLineParametricPathWithValue}, which allows the filter to produce // a likehood value along with each polyline. The filter is able to produce // \doxygen{itk}{PolyLineParametricPath} as well. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::PolyLineParametricPathWithValue PathType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we can define the \doxygen{otb}{RoadExtractionFilter} that takes a multi-spectral // image as input and produces a list of polylines. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::RoadExtractionFilter RoadExtractionFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also define an \doxygen{otb}{DrawPathListFilter} to draw the output // polylines on an image, taking their likehood values into account. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::DrawPathListFilter DrawPathFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The intensity rescaling of the results will be carried out by the // \doxygen{itk}{RescaleIntensityImageFilter} which is templated by the // input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. Then, an \doxygen{otb}{ImageFileWriter} // is instantiated in order to write the output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different filters composing our pipeline are created by invoking their // \code{New()} methods, assigning the results to smart pointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); RoadExtractionFilterType::Pointer roadExtractionFilter = RoadExtractionFilterType::New(); DrawPathFilterType::Pointer drawingFilter = DrawPathFilterType::New(); RescalerType::Pointer rescaleFilter = RescalerType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The \doxygen{otb}{RoadExtractionFilter} needs to have a reference pixel // corresponding to the spectral content likely to represent a road. This is done // by passing a pixel to the filter. Here we suppose that the input image // has four spectral bands. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputVectorImageType::PixelType ReferencePixel; ReferencePixel.SetSize(4); ReferencePixel.SetElement(0, ::atof(argv[3])); ReferencePixel.SetElement(1, ::atof(argv[4])); ReferencePixel.SetElement(2, ::atof(argv[5])); ReferencePixel.SetElement(3, ::atof(argv[6])); roadExtractionFilter->SetReferencePixel(ReferencePixel); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We must also set the alpha parameter of the filter which allows us to tune the width of the roads // we want to extract. Typical value is $1.0$ and should be working in most situations. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet roadExtractionFilter->SetAlpha(atof(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // All other parameter should not influence the results too much in most situation and can // be kept at the default value. // // The amplitude threshold parameter tunes the sensitivity of the vectorization step. A typical // value is $5 \cdot 10^{-5}$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet roadExtractionFilter->SetAmplitudeThreshold(atof(argv[8])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The tolerance threshold tunes the sensitivity of the path simplification step. // Typical value is $1.0$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet roadExtractionFilter->SetTolerance(atof(argv[9])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Roads are not likely to have sharp turns. Therefore we set the max angle parameter, // as well as the link angular threshold. The value is typically $\frac{\pi}{8}$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet roadExtractionFilter->SetMaxAngle(atof(argv[10])); roadExtractionFilter->SetAngularThreshold(atof(argv[10])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{RoadExtractionFilter} performs two odd path removing operations at different stage of // its execution. The first mean distance threshold and the second mean distance threshold set their criterion // for removal. Path are removed if their mean distance between nodes is to small, since such path coming // from previous filters are likely to be tortuous. The first removal operation as a typical mean distance // threshold parameter of $1.0$, and the second of $10.0$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet roadExtractionFilter->SetFirstMeanDistanceThreshold(atof(argv[11])); roadExtractionFilter->SetSecondMeanDistanceThreshold(atof(argv[12])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{RoadExtractionFilter} is able to link path whose ends are near // according to an euclidean distance criterion. The threshold for this distance // to link a path is the distance threshold parameter. A typical value is $25$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet roadExtractionFilter->SetDistanceThreshold(atof(argv[13])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will now create a black background image to draw the resulting polyline on. // To achieve this we need to know the size of our input image. Therefore we trigger the // \code{GenerateOutputInformation()} of the reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->GenerateOutputInformation(); InputImageType::Pointer blackBackground = InputImageType::New(); blackBackground->CopyInformation(reader->GetOutput()); blackBackground->SetRegions(blackBackground->GetLargestPossibleRegion()); blackBackground->Allocate(); blackBackground->FillBuffer(0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We tell the \doxygen{otb}{DrawPathListFilter} to try to use the likehood value // embedded within the polyline as a value for drawing this polyline if possible. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet drawingFilter->UseInternalPathValueOn(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{itk::RescaleIntensityImageFilter} needs to know which // is the minimum and maximum values of the output generated // image. Those can be chosen in a generic way by using the // \code{NumericTraits} functions, since they are templated over // the pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaleFilter->SetOutputMinimum(itk::NumericTraits::min()); rescaleFilter->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now it is time for some pipeline wiring. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet roadExtractionFilter->SetInput(reader->GetOutput()); drawingFilter->SetInput(blackBackground); drawingFilter->SetInputPath(roadExtractionFilter->GetOutput()); rescaleFilter->SetInput(drawingFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The update of the pipeline is triggered by the \code{Update()} method // of the rescale intensity filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaleFilter->Update(); // Software Guide : EndCodeSnippet // output image enhancement typedef itk::BinaryBallStructuringElement StructuringElementType; typedef itk::GrayscaleDilateImageFilter DilateFilterType; typedef itk::InvertIntensityImageFilter InvertFilterType; StructuringElementType se; se.SetRadius(1); se.CreateStructuringElement(); DilateFilterType::Pointer dilater = DilateFilterType::New(); dilater->SetInput(rescaleFilter->GetOutput()); dilater->SetKernel(se); InvertFilterType::Pointer invertFilter = InvertFilterType::New(); invertFilter->SetInput(dilater->GetOutput()); writer->SetFileName(argv[2]); writer->SetInput(invertFilter->GetOutput()); writer->Update(); // Software Guide : BeginLatex // // Figure~\ref{fig:ROADEXTRACTION_FILTER} shows the result of applying // the road extraction filter to a fusionned Quickbird image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{qb_ExtractRoad_pretty.eps} // \includegraphics[width=0.44\textwidth]{ExtractRoadOutput.eps} // \itkcaption[Road extraction filter application]{Result of applying // the \doxygen{otb}{RoadExtractionFilter} to a fusionned Quickbird // image. From left to right : original image, extracted road with their // likehood values (color are inverted for display).} // \label{fig:ROADEXTRACTION_FILTER} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ExtractSegmentsByStepsExample.cxx000066400000000000000000000216731301006202600273330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {amst.png} // OUTPUTS: {amstSegmentExtractionBySteps.png} // 10 3 10 0.5 10 10 3 10 0.5 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{ExtractSegmentsImageFilter}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLineRatioDetectorImageFilter.h" #include "otbPixelSuppressionByDirectionImageFilter.h" #include "otbLocalHoughFilter.h" #include "otbFillGapsFilter.h" #include "otbDrawLineSpatialObjectListFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 12) { for (int i = 0; i < argc; ++i) std::cerr << argv[i] << std::endl; std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputSegmentsImageFile length width "; std::cerr << " PixelSuppressionRadiusX PixelSuppressionAngularBeam "; std::cerr << " LocalHoughRadiusX LocalHoughRadiusY LocalHoughNumberOfLines"; std::cerr << " FillGapsRadius FillGapsAngularBeam" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LineRatioDetectorImageFilter DetectorType; typedef otb::PixelSuppressionByDirectionImageFilter PixelSuppressionType; typedef otb::LocalHoughFilter LocalHoughType; typedef otb::FillGapsFilter FillGapsType; typedef otb::DrawLineSpatialObjectListFilter DrawLineListType; typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); DetectorType::Pointer detector = DetectorType::New(); PixelSuppressionType::Pointer pixelSuppression = PixelSuppressionType::New(); LocalHoughType::Pointer localHough = LocalHoughType::New(); FillGapsType::Pointer fillGaps = FillGapsType::New(); DrawLineListType::Pointer drawLineList = DrawLineListType::New(); RescalerType::Pointer rescaler = RescalerType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The same is done for the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{ExtractSegmentsImageFilter}. The pipeline is built as follows. // // \index{otb::ExtractSegmentsImageFilter!SetInput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet detector->SetInput(reader->GetOutput()); pixelSuppression->SetInputImage(detector->GetOutput()); pixelSuppression->SetInputImageDirection(detector->GetOutputDirection()); rescaler->SetInput(pixelSuppression->GetOutput()); localHough->SetInput(rescaler->GetOutput()); fillGaps->SetInput (localHough->GetOutput()); drawLineList->SetInput(reader->GetOutput()); drawLineList->SetInputLineSpatialObjectList(fillGaps->GetOutput()); writer->SetInput(drawLineList->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The methods \code{SetLengthLine()} and \code{SetWidthLine()} // allow setting the minimum length and the typical witdh of the // lines which are to be detected. // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet detector->SetLengthLine(atoi(argv[3])); detector->SetWidthLine(atoi(argv[4])); unsigned int PixelSuppressionRadiusX((unsigned int) ::atoi(argv[5])); float PixelSuppressionAngularBeam((float) ::atof(argv[6])); unsigned int LocalHoughRadiusX((unsigned int) ::atoi(argv[7])); unsigned int LocalHoughRadiusY((unsigned int) ::atoi(argv[8])); unsigned int LocalHoughNumberOfLines((unsigned int) ::atoi(argv[9])); float FillGapsRadius((float) ::atoi(argv[10])); float FillGapsAngularBeam((float) ::atof(argv[11])); PixelSuppressionType::SizeType PixelSuppressionRadius; PixelSuppressionRadius[0] = PixelSuppressionRadiusX; PixelSuppressionRadius[1] = PixelSuppressionRadiusX; pixelSuppression->SetRadius(PixelSuppressionRadius); pixelSuppression->SetAngularBeam(PixelSuppressionAngularBeam); PixelSuppressionType::SizeType LocalHoughRadius; LocalHoughRadius[0] = LocalHoughRadiusX; LocalHoughRadius[1] = LocalHoughRadiusY; localHough->SetRadius(LocalHoughRadius); localHough->SetNumberOfLines(LocalHoughNumberOfLines); fillGaps->SetRadius(FillGapsRadius); fillGaps->SetAngularBeam(FillGapsAngularBeam); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // \textbf{FIXME: set the methods} // \index{otb::AsymmetricFusionOfDetector!SetWidthLine()} // \index{otb::AsymmetricFusionOfDetector!SetLengthLine()} // The filter is executed by invoking the \code{Update()} method. If the // filter is part of a larger image processing pipeline, calling // \code{Update()} on a downstream filter will also trigger update of this // filter. // // Software Guide : EndLatex writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // We can also obtain the direction of the lines by invoking the // \code{GetOutputDirections()} method. \textbf{FIXME : implement // the method!!} // Software Guide : EndLatex // Software Guide : BeginLatex Figure~\ref{fig:LINECORRELATION_FILTER} // shows the result of applying the AsymmetricFusionOf edge detector filter // to a SAR image. \begin{figure} \center // \includegraphics[width=0.25\textwidth]{amst.eps} // \includegraphics[width=0.25\textwidth]{amstSegmentExtractionBySteps.eps} // \itkcaption[Line Correlation Detector Application]{Result of applying // the \doxygen{otb}{AsymmetricFusionOfDetectorImageFilter} to a SAR // image. From left to right : original image, line intensity and // edge orientation.} \label{fig:LINECORRELATION_FILTER} \end{figure} // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{AsymmetricFusionOfDetectorImageFilter} // \end{itemize} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ExtractSegmentsExample.cxx000066400000000000000000000215231301006202600260130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {amst.png} // OUTPUTS: {amstSegmentExtraction.png} // 10 3 10 0.5 10 10 3 10 0.5 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{ExtractSegmentsImageFilter}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbExtractSegmentsImageFilter.h" #include "otbLineRatioDetectorImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 12) { for (int i = 0; i < argc; ++i) std::cerr << argv[i] << std::endl; std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputSegmentsImageFile length width "; std::cerr << " PixelSuppressionRadiusX PixelSuppressionAngularBeam "; std::cerr << " LocalHoughRadiusX LocalHoughRadiusY LocalHoughNumberOfLines"; std::cerr << " FillGapsRadius FillGapsAngularBeam" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LineRatioDetectorImageFilter DetectorType; typedef otb::ExtractSegmentsImageFilter ExtractorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); DetectorType::Pointer detector = DetectorType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The same is done for the rescaler and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RescalerType::Pointer rescaler = RescalerType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The \code{itk::RescaleIntensityImageFilter} needs to know which // is the minimu and maximum values of the output generated // image. Those can be chosen in a generic way by using the // \code{NumericTraits} functions, since they are templated over // the pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{ExtractSegmentsImageFilter}. The pipeline is built as follows. // // \index{otb::ExtractSegmentsImageFilter!SetInput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet detector->SetInput(reader->GetOutput()); extractor->SetInputImage(detector->GetOutput()); extractor->SetInputImageDirection(detector->GetOutputDirection()); extractor->SetLineValue(0.); rescaler->SetInput(extractor->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The methods \code{SetLengthLine()} and \code{SetWidthLine()} // allow setting the minimum length and the typical witdh of the // lines which are to be detected. // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet detector->SetLengthLine(atoi(argv[3])); detector->SetWidthLine(atoi(argv[4])); unsigned int PixelSuppressionRadiusX((unsigned int) ::atoi(argv[5])); float PixelSuppressionAngularBeam((float) ::atof(argv[6])); unsigned int LocalHoughRadiusX((unsigned int) ::atoi(argv[7])); unsigned int LocalHoughRadiusY((unsigned int) ::atoi(argv[8])); unsigned int LocalHoughNumberOfLines((unsigned int) ::atoi(argv[9])); float FillGapsRadius((float) ::atoi(argv[10])); float FillGapsAngularBeam((float) ::atof(argv[11])); ExtractorType::SizeType PixelSuppressionRadius; PixelSuppressionRadius[0] = PixelSuppressionRadiusX; PixelSuppressionRadius[1] = PixelSuppressionRadiusX; extractor->SetPixelSuppressionRadius(PixelSuppressionRadius); extractor->SetPixelSuppressionAngularBeam(PixelSuppressionAngularBeam); ExtractorType::SizeType LocalHoughRadius; LocalHoughRadius[0] = LocalHoughRadiusX; LocalHoughRadius[1] = LocalHoughRadiusY; extractor->SetLocalHoughRadius(LocalHoughRadius); extractor->SetLocalHoughNumberOfLines(LocalHoughNumberOfLines); extractor->SetFillGapsRadius(FillGapsRadius); extractor->SetFillGapsAngularBeam(FillGapsAngularBeam); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // \textbf{FIXME: set the methods} // \index{otb::AsymmetricFusionOfDetector!SetWidthLine()} // \index{otb::AsymmetricFusionOfDetector!SetLengthLine()} // The filter is executed by invoking the \code{Update()} method. If the // filter is part of a larger image processing pipeline, calling // \code{Update()} on a downstream filter will also trigger update of this // filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet extractor->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex Figure~\ref{fig:LINECORRELATION_FILTER} // shows the result of applying the AsymmetricFusionOf edge detector filter // to a SAR image. \begin{figure} \center // \includegraphics[width=0.25\textwidth]{amst.eps} // \includegraphics[width=0.25\textwidth]{amstSegmentExtraction.eps} // \itkcaption[Line Correlation Detector Application]{Result of applying // the \doxygen{otb}{AsymmetricFusionOfDetectorImageFilter} to a SAR // image. From left to right : original image, line intensity and // edge orientation.} \label{fig:LINECORRELATION_FILTER} \end{figure} // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{AsymmetricFusionOfDetectorImageFilter} // \end{itemize} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/FlusserMomentsImageFunctionExample.cxx000066400000000000000000000075741301006202600303440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{FlusserMomentsImageFunction}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbFlusserMomentsImageFunction.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " neighborhood_radius" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const unsigned int radius = atoi(argv[2]); typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Software Guide : BeginLatex // // The \doxygen{otb}{FlusserMomentsImageFunction} is templated over the // input image type and the output (real) type value, so we start by // defining: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::FlusserMomentsImageFunction FlusserType; typedef FlusserType::OutputType MomentType; FlusserType::Pointer fmFunction = FlusserType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We can choose the region and the pixel of the image which will // used as coordinate origin // for the moment computation // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputImageType::RegionType region; InputImageType::SizeType size; InputImageType::IndexType start; start[0] = 0; start[1] = 0; size[0] = 50; size[1] = 50; reader->Update(); InputImageType::Pointer image = reader->GetOutput(); region.SetIndex(start); region.SetSize(size); image->SetRegions(region); image->Update(); InputImageType::IndexType center; center[0] = start[0] + size[0] / 2; center[1] = start[1] + size[1] / 2; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next, we plug the input image into the complex moment function // and we set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fmFunction->SetInputImage(image); fmFunction->SetNeighborhoodRadius(radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // In order to get the value of the moment, we call the // \code{EvaluateAtIndex} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MomentType Result = fmFunction->EvaluateAtIndex(center); for (unsigned int j=0; j<11; ++j) { std::cout << "The moment of order " << j+1 << " is equal to " << Result[j] << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{FlusserPathFunction} // \end{itemize} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/HarrisExample.cxx000066400000000000000000000165561301006202600241350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {ROISpot5Harris.png} // 1.5 2 0.1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{HarrisImageFilter}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Software Guide : EndCodeSnippet #include "otbHarrisImageToPointSetFilter.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char *argv[]) { if (argc != 6) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputHarrisImageFile sigmaD sigmaI alpha" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; double SigmaD((double) ::atof(argv[3])); double SigmaI((double) ::atof(argv[4])); double Alpha((double) ::atof(argv[5])); typedef float InputPixelType; const unsigned int Dimension = 2; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The \doxygen{otb}{HarrisImageFilter} is templated over the // input and output image types, so we start by // defining: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::HarrisImageFilter HarrisFilterType; // Software Guide : EndCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); HarrisFilterType::Pointer harris = HarrisFilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); harris->SetInput(reader->GetOutput()); // Software Guide : BeginLatex // // The \doxygen{otb}{HarrisImageFilter} needs some parameters to // operate. The derivative computation is performed by a // convolution with the derivative of a Gaussian kernel of // variance $\sigma_D$ (derivation scale) and // the smoothing of the image is performed by convolving with a // Gaussian kernel of variance $\sigma_I$ (integration // scale). This allows the computation of the following matrix: // \begin{equation} // \mu(\mathbf{x},\sigma_I,\sigma_D) = \sigma_D^2 g(\sigma_I)\star // \left[\begin{array}{cc} L_x^2(\mathbf{x},\sigma_D) & // L_xL_y(\mathbf{x},\sigma_D)\\ L_xL_y(\mathbf{x},\sigma_D)& // L_y^2(\mathbf{x},\sigma_D) \end{array}\right] // \end{equation} // The output of the detector is $$det(\mu) - \alpha trace^2(\mu).$$ // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet harris->SetSigmaD(SigmaD); harris->SetSigmaI(SigmaI); harris->SetAlpha(Alpha); // Software Guide : EndCodeSnippet rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); rescaler->SetInput(harris->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:Harris} shows the result of applying the interest // point detector to a small patch extracted from a Spot 5 image. // \begin{figure} // \center // \includegraphics[width=0.25\textwidth]{ROISpot5.eps} // \includegraphics[width=0.25\textwidth]{ROISpot5Harris.eps} // \itkcaption[Harris Filter Application]{Result of applying the // \doxygen{otb}{HarrisImageFilter} to a Spot 5 image.} // \label{fig:Harris} // \end{figure} // // The output of the \doxygen{otb}{HarrisImageFilter} is an image // where, for each pixel, we obtain the intensity of the // detection. Often, the user may want to get access to the set of // points for which the output of the detector is higher than a // given threshold. This can be obtained by using the // \doxygen{otb}{HarrisImageToPointSetFilter}. This filter is only // templated over the input image type, the output being a // \doxygen{itk}{PointSet} with pixel type equal to the image pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::HarrisImageToPointSetFilter FunctionType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare now the filter and a pointer to the output point set. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef FunctionType::OutputPointSetType OutputPointSetType; FunctionType::Pointer harrisPoints = FunctionType::New(); OutputPointSetType::Pointer pointSet = OutputPointSetType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{HarrisImageToPointSetFilter} takes the same // parameters as the \doxygen{otb}{HarrisImageFilter} and an // additional parameter : the threshold for the point selection. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet harrisPoints->SetInput(0, reader->GetOutput()); harrisPoints->SetSigmaD(SigmaD); harrisPoints->SetSigmaI(SigmaI); harrisPoints->SetAlpha(Alpha); harrisPoints->SetLowerThreshold(10); pointSet = harrisPoints->GetOutput(); // Software Guide : EndCodeSnippet harrisPoints->Update(); // Software Guide : BeginLatex // // We can now iterate through the obtained pointset and access // the coordinates of the points. We start by accessing the // container of the points which is encapsulated into the point // set (see section \ref{sec:PointSetSection} for more // information on using \doxygen{itk}{PointSet}s) and declaring // an iterator to it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef OutputPointSetType::PointsContainer ContainerType; ContainerType* pointsContainer = pointSet->GetPoints(); typedef ContainerType::Iterator IteratorType; IteratorType itList = pointsContainer->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we get the points coordinates // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (itList != pointsContainer->End()) { typedef OutputPointSetType::PointType OutputPointType; OutputPointType pCoordinate = (itList.Value()); std::cout << pCoordinate << std::endl; ++itList; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/HuMomentsImageFunctionExample.cxx000066400000000000000000000075011301006202600272630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{HuMomentsImageFunction}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbHuMomentsImageFunction.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " moment_number" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const unsigned int radius = atoi(argv[2]); typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Software Guide : BeginLatex // // The \doxygen{otb}{HuImageFunction} is templated over the // input image type and the output (real) type value, so we start by // defining: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::HuMomentsImageFunction HuType; typedef HuType::OutputType MomentType; HuType::Pointer hmFunction = HuType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We can choose the region and the pixel of the image which will // used as coordinate origin // for the moment computation // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputImageType::RegionType region; InputImageType::SizeType size; InputImageType::IndexType start; start[0] = 0; start[1] = 0; size[0] = 50; size[1] = 50; reader->Update(); InputImageType::Pointer image = reader->GetOutput(); region.SetIndex(start); region.SetSize(size); image->SetRegions(region); image->Update(); InputImageType::IndexType center; center[0] = start[0] + size[0] / 2; center[1] = start[1] + size[1] / 2; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next, we plug the input image into the complex moment function // and we set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet hmFunction->SetInputImage(image); hmFunction->SetNeighborhoodRadius(radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // In order to get the value of the moment, we call the // \code{EvaluateAtIndex} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MomentType Result = hmFunction->EvaluateAtIndex(center); for (unsigned int j=0; j<7; ++j) { std::cout << "The moment of order " << j+1 << " is equal to " << Result[j] << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{HuPathFunction} // \end{itemize} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/LineSegmentDetectorExample.cxx000066400000000000000000000135761301006202600266100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbVectorDataToMapFilter.h" #include "otbAlphaBlendingFunctor.h" #include "itkBinaryFunctorImageFilter.h" #include "otbImageFileWriter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {Scene.png} // OUTPUTS: {LSDOutput.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{LineSegmentDetector}\cite{LSD}, also known as {\em Lucy in the // Sky with Diamonds}. // This filter is designed to extract segments in mono channel images. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLineSegmentDetector.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef unsigned char InputPixelType; typedef double PrecisionType; const unsigned int Dimension = 2; // Software Guide : BeginLatex // // As usual, we start by defining the types for the input image and // the image file reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the reader and set the file name for the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define now the type for the segment detector filter. It is // templated over the input image type and the precision with which // the coordinates of the detected segments will be given. It is // recommended to set this precision to a real type. The output of the // filter will be a \doxygen{otb}{VectorData}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LineSegmentDetector LsdFilterType; LsdFilterType::Pointer lsdFilter = LsdFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In order to be able to display the results, we will draw the // detected segments on top of the input image. For this matter, we // will use a \doxygen{otb}{VectorDataToMapFilter} which // is templated over the input vector data type and the output image // type, and a combination of a \doxygen{itk}{binaryFunctorImageFilter} // and the \doxygen{otb}{Functor}{AlphaBlendingFunctor}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorData VectorDataType; typedef otb::VectorDataToMapFilter VectorDataRendererType; VectorDataRendererType::Pointer vectorDataRenderer = VectorDataRendererType::New(); typedef otb::Functor::AlphaBlendingFunctor FunctorType; typedef itk::BinaryFunctorImageFilter BlendingFilterType; BlendingFilterType::Pointer blendingFilter = BlendingFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the writer, instantiate it and set // the file name for the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet lsdFilter->SetInput(reader->GetOutput()); vectorDataRenderer->SetInput(lsdFilter->GetOutput()); vectorDataRenderer->SetSize(reader->GetOutput()->GetLargestPossibleRegion().GetSize()); vectorDataRenderer->SetRenderingStyleType(VectorDataRendererType::Binary); blendingFilter->SetInput1(reader->GetOutput()); blendingFilter->SetInput2(vectorDataRenderer->GetOutput()); blendingFilter->GetFunctor().SetAlpha(0.25); writer->SetInput(blendingFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Before calling the \code{Update()} method of the writer in order to // trigger the pipeline execution, we call the // \doxygen{GenerateOutputInformation()} of the reader, so the LSD // filter gets the information about image size and spacing. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->GenerateOutputInformation(); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:LSD} shows the result of applying the line segment // detection to an image. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{Scene.eps} // \includegraphics[width=0.35\textwidth]{LSDOutput.eps} // \itkcaption[LSD Application]{Result of applying the // \doxygen{otb}{LineSegmentDetector} to an image.} // \label{fig:LSD} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/LocalHoughExample.cxx000066400000000000000000000146301301006202600247210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {detected_lines.png} // OUTPUTS: {detected_local_hough.png} // 30 10 1 50 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{ExtractSegmentsImageFilter}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLocalHoughFilter.h" #include "otbDrawLineSpatialObjectListFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 7) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImageFile LocalHoughRadius LocalHoughOverlap LocalHoughNumberOfLines LocalHoughThreshold" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LocalHoughFilter LocalHoughType; typedef otb::DrawLineSpatialObjectListFilter DrawLineListType; // Software Guide : EndCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); LocalHoughType::Pointer localHough = LocalHoughType::New(); DrawLineListType::Pointer drawLineList = DrawLineListType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The same is done for the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); unsigned int LocalHoughRadiusX((unsigned int) ::atoi(argv[3])); unsigned int LocalHoughRadiusY((unsigned int) ::atoi(argv[3])); unsigned int LocalHoughOverlapX((unsigned int) ::atoi(argv[4])); unsigned int LocalHoughOverlapY((unsigned int) ::atoi(argv[4])); unsigned int LocalHoughNumberOfLines((unsigned int) ::atoi(argv[5])); float LocalHoughThreshold((float) ::atoi(argv[6])); LocalHoughType::SizeType LocalHoughRadius; LocalHoughRadius[0] = LocalHoughRadiusX; LocalHoughRadius[1] = LocalHoughRadiusY; LocalHoughType::SizeType LocalHoughOverlap; LocalHoughOverlap[0] = LocalHoughOverlapX; LocalHoughOverlap[1] = LocalHoughOverlapY; localHough->SetRadius(LocalHoughRadius); localHough->SetOverlap(LocalHoughOverlap); localHough->SetNumberOfLines(LocalHoughNumberOfLines); localHough->SetThreshold(LocalHoughThreshold); // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{ExtractSegmentsImageFilter}. The pipeline is built as follows. // // \index{otb::ExtractSegmentsImageFilter!SetInput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet localHough->SetInput(reader->GetOutput()); drawLineList->SetInput(reader->GetOutput()); drawLineList->SetInputLineSpatialObjectList(localHough->GetOutput()); writer->SetFileName(argv[2]); writer->SetInput(drawLineList->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:LOCAL_HOUGH} // shows the result of applying the \doxygen{otb}{LocalHoughImageFilter}. // \begin{figure} \center // \includegraphics[width=0.25\textwidth]{detected_lines.eps} // \includegraphics[width=0.25\textwidth]{detected_local_hough.eps} // \itkcaption[Line Correlation Detector Application]{Result of applying // the \doxygen{otb}{LocalHoughImageFilter}. From left to right : // original image, extracted segments.} \label{fig:LOCAL_HOUGH} \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/PanTexExample.cxx000066400000000000000000000135231301006202600240730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1.png} // OUTPUTS: {PanTexOutput.tif}, {pretty_PanTexInput.png}, {pretty_PanTexOutput.png} // Software Guide : EndCommandLineArgs #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{ScalarImageToPanTexTextureFilter}. This texture parameter was // first introduced in \cite{PanTex} and is very useful for urban area // detection. // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{ScalarImageToTexturesFilter} // \item \doxygen{otb}{ScalarImageToAdvancedTexturesFilter} // \end{itemize} // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbScalarImageToPanTexTextureFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { // Parse command line parameters if (argc != 5) { std::cerr << "Usage: " << argv[0] << " "; std::cerr << " "; std::cerr << std::endl; return EXIT_FAILURE; } const char* infname = argv[1]; const char* outfname = argv[2]; const char* inprettyfname = argv[3]; const char* outprettyfname = argv[4]; typedef double PixelType; const int Dimension = 2; typedef otb::Image ImageType; // Software Guide : BeginLatex // // After defining the types for the pixels and the images used in the // example, we define the type for the PanTex filter. It is // templated by the input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ScalarImageToPanTexTextureFilter PanTexTextureFilterType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); writer->SetFileName(outfname); // Software Guide : BeginLatex // // We can now instatiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PanTexTextureFilterType::Pointer textureFilter = PanTexTextureFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we set the parameters of the filter.The radius of // the neighborhood to compute the texture. // The number of bins per axis for histogram generation (it is the // size of the co-occurrence matrix). Moreover, we have to specify // the Min/Max in the input image. In the example, image Min/Max is set // by the user to 0 and 255. Alternatively you can use the class \doxygen{itk}{MinimumMaximumImageCalculator} // to calculate these values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PanTexTextureFilterType::SizeType sradius; sradius.Fill(4); textureFilter->SetNumberOfBinsPerAxis(8); textureFilter->SetRadius(sradius); textureFilter->SetInputImageMinimum(0); textureFilter->SetInputImageMaximum(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now plug the pipeline and trigger the execution by calling // the \code{Update} method of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet textureFilter->SetInput(reader->GetOutput()); writer->SetInput(textureFilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:PANTEXFILTER} shows the result of applying // the PanTex computation. // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{pretty_PanTexInput.eps} // \includegraphics[width=0.40\textwidth]{pretty_PanTexOutput.eps} // \itkcaption[PanTex Filter]{Result of applying the // \doxygen{otb}{ScalarImageToPanTexTextureFilter} to an image. From left to right: // original image, PanTex feature.} // \label{fig:PANTEXFILTER} // \end{figure} // // Software Guide : EndLatex // Pretty image creation for printing typedef otb::Image OutputPrettyImageType; typedef otb::ImageFileWriter WriterPrettyOutputType; typedef itk::RescaleIntensityImageFilter RescalerOutputType; RescalerOutputType::Pointer outputRescaler = RescalerOutputType::New(); WriterPrettyOutputType::Pointer prettyOutputWriter = WriterPrettyOutputType::New(); outputRescaler->SetInput(textureFilter->GetOutput()); outputRescaler->SetOutputMinimum(0); outputRescaler->SetOutputMaximum(255); prettyOutputWriter->SetFileName(outprettyfname); prettyOutputWriter->SetInput(outputRescaler->GetOutput()); prettyOutputWriter->Update(); outputRescaler->SetInput(reader->GetOutput()); outputRescaler->SetOutputMinimum(0); outputRescaler->SetOutputMaximum(255); prettyOutputWriter->SetFileName(inprettyfname); prettyOutputWriter->SetInput(outputRescaler->GetOutput()); prettyOutputWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ParallelLineDetectionExample.cxx000066400000000000000000000147031301006202600271000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // OUTPUTS: {Lines.png}, {ParallelLines.png} // 20 2 10 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the details of the \doxygen{otb}{ParallelLinePathListFilter}. // // // Software Guide : EndLatex #include "itkPolyLineParametricPath.h" #include "otbDrawPathListFilter.h" #include "otbParallelLinePathListFilter.h" #include "otbImage.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 6) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " outputImage "; std::cerr << " outputParallelLineImage "; std::cerr << " distThreshParallel angThreshParallel commonDistThreshParallel" << std::endl; return EXIT_FAILURE; } double distThreshParallel = atof(argv[3]); double angThreshParallel = atof(argv[4]); double commonDistThreshParallel = atof(argv[5]); //We start by creating an empty image const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; ImageType::Pointer image = ImageType::New(); ImageType::IndexType start; start[0] = 0; start[1] = 0; ImageType::SizeType size; size[0] = 600; size[1] = 300; ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); image->SetRegions(region); image->Allocate(); image->FillBuffer(itk::NumericTraits::Zero); // We create some lines typedef itk::PolyLineParametricPath PathType; typedef otb::ObjectList PathListType; PathListType::Pointer lineList = PathListType::New(); typedef PathType::ContinuousIndexType ContinuousIndexType; ContinuousIndexType cindex; /*-----*/ PathType::Pointer aLine = PathType::New(); aLine->Initialize(); cindex[0] = 1; cindex[1] = 41; aLine->AddVertex(cindex); cindex[0] = 175; cindex[1] = 204; aLine->AddVertex(cindex); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 60; cindex[1] = 18; aLine->AddVertex(cindex); cindex[0] = 203; cindex[1] = 164; aLine->AddVertex(cindex); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 174; cindex[1] = 99; aLine->AddVertex(cindex); cindex[0] = 281; cindex[1] = 1; aLine->AddVertex(cindex); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 3; cindex[1] = 233; aLine->AddVertex(cindex); cindex[0] = 191; cindex[1] = 227; aLine->AddVertex(cindex); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 254; cindex[1] = 279; aLine->AddVertex(cindex); cindex[0] = 351; cindex[1] = 110; aLine->AddVertex(cindex); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 270; cindex[1] = 287; aLine->AddVertex(cindex); cindex[0] = 368; cindex[1] = 120; aLine->AddVertex(cindex); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 355; cindex[1] = 204; aLine->AddVertex(cindex); cindex[0] = 528; cindex[1] = 199; aLine->AddVertex(cindex); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 437; cindex[1] = 243; aLine->AddVertex(cindex); cindex[0] = 591; cindex[1] = 237; aLine->AddVertex(cindex); lineList->PushBack(aLine); // Polylines are drawn on a black typedef otb::DrawPathListFilter DrawPathType; DrawPathType::Pointer drawPathListFilter = DrawPathType::New(); drawPathListFilter->SetInput(image); drawPathListFilter->SetInputPath(lineList); drawPathListFilter->SetPathValue(itk::NumericTraits::max()); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(drawPathListFilter->GetOutput()); writer->SetFileName(argv[1]); writer->Update(); // Parallel lines are detected. A minimum common length, an angular // threshold and a maximum distance threshold have to specified. // The input is a pathList of the previously extracted line segments. typedef otb::ParallelLinePathListFilter ParallelLinePathType; ParallelLinePathType::Pointer parallelLinePathListFilter = ParallelLinePathType::New(); parallelLinePathListFilter->SetDistanceThreshold(distThreshParallel); parallelLinePathListFilter->SetAngularThreshold(angThreshParallel); parallelLinePathListFilter->SetCommonDistanceThreshold( commonDistThreshParallel); parallelLinePathListFilter->SetInput(lineList); parallelLinePathListFilter->Update(); // A black background image is built to draw the path on. ImageType::Pointer outputParallel = ImageType::New(); outputParallel->SetRegions(image->GetLargestPossibleRegion()); outputParallel->Allocate(); outputParallel->FillBuffer(itk::NumericTraits::Zero); // Parallel lines are drawn on a black background image with \doxygen{otb}{DrawPathListFilter}. // The \code{SetUseIternalValues()} tells the drawing filter to draw the path with its likelihood // value. //typedef otb::DrawPathListFilter DrawPathType; DrawPathType::Pointer drawPathListFilterParallel = DrawPathType::New(); drawPathListFilterParallel->SetInput(outputParallel); drawPathListFilterParallel->SetInputPath( parallelLinePathListFilter->GetOutput()); drawPathListFilter->SetPathValue(itk::NumericTraits::max()); drawPathListFilterParallel->SetUseInternalPathValue(false); // Write the Line image WriterType::Pointer writerParallel = WriterType::New(); writerParallel->SetInput(drawPathListFilterParallel->GetOutput()); writerParallel->SetFileName(argv[2]); writerParallel->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/RatioLineDetectorExample.cxx000066400000000000000000000175061301006202600262610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {amst.png} // OUTPUTS: {amstLineRatios.png}, {amstLineRatioDirections.png} // 5 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{RatioLineDetectorImageFilter}. // This filter is used for line detection in SAR images. Its principle // is described in \cite{tup-98}: a line is detected if two parallel // edges are present in the images. These edges are detected with the // ratio of means detector. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLineRatioDetectorImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 6) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputEdgesImageFile outputDirectionsImageFile length width" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LineRatioDetectorImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The same is done for the rescaler and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RescalerType::Pointer rescaler = RescalerType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The \code{itk::RescaleIntensityImageFilter} needs to know which // is the minimu and maximum values of the output generated // image. Those can be chosen in a generic way by using the // \code{NumericTraits} functions, since they are templated over // the pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{LineRatioDetectorImageFilter}. The pipeline is built as follows. // // \index{otb::LineRatioDetectorImageFilter!SetInput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The methods \code{SetLengthLine()} and \code{SetWidthLine()} // allow setting the minimum length and the typical witdh of the // lines which are to be detected. // // \index{otb::LineRatioDetector!SetWidthLine()} // \index{otb::LineRatioDetector!SetLengthLine()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetLengthLine(atoi(argv[4])); filter->SetWidthLine(atoi(argv[5])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter is executed by invoking the \code{Update()} method. If the // filter is part of a larger image processing pipeline, calling // \code{Update()} on a downstream filter will also trigger update of this // filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // We can also obtain the direction of the lines by invoking the // \code{GetOutputDirection()} method. // Software Guide : EndLatex writer->SetFileName(argv[3]); // Software Guide : BeginCodeSnippet rescaler->SetInput(filter->GetOutputDirection()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex Figure~\ref{fig:LINERATIO_FILTER} // shows the result of applying the LineRatio edge detector filter // to a SAR image. \begin{figure} \center // \includegraphics[width=0.25\textwidth]{amst.eps} // \includegraphics[width=0.25\textwidth]{amstLineRatios.eps} // \includegraphics[width=0.25\textwidth]{amstLineRatioDirections.eps} // \itkcaption[Line Ratio Detector Application]{Result of applying // the \doxygen{otb}{LineRatioDetectorImageFilter} to a SAR // image. From left to right : original image, line intensity and // edge orientation.} \label{fig:LINERATIO_FILTER} \end{figure} // // \relatedClasses // \begin{itemize} // \item \doxygen{otb}{LineCorrelationDetectorImageFilter} // \end{itemize} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/RightAngleDetectionExample.cxx000066400000000000000000000210461301006202600265560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbLineSegmentDetector.h" #include "otbVectorDataToMapFilter.h" #include "otbAlphaBlendingFunctor.h" #include "itkBinaryFunctorImageFilter.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbVectorDataFileWriter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {Scene.png} // OUTPUTS: {RighAngleOutput.tif}, {PrettyRighAngleInput.png}, {PrettyRighAngleOutput.png} // 0.1 20 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{VectorDataToRightAngleVectorDataFilter}. // This filter detects the right angles in an image by exploiting the // output of a line detection algorithm. Typically the // \doxygen{otb}{LineSegmentDetector} class will be used. The right // angle detection algorithm is described in detail in // \cite{RightAngleDetection}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbVectorDataToRightAngleVectorDataFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const char * inprettyfname = argv[3]; const char * outprettyfname = argv[4]; double angleThreshold = atof(argv[5]); double distanceThreshold = atof(argv[6]); const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef double PrecisionType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); WriterType::Pointer writer = WriterType::New(); // Software Guide : BeginLatex // // After defining, as usual, the types for the input image and the // image reader, we define the specific types needed for this // example. First of all, we will use a vector data // to store the detected lines which will be provided by the line // segment detector. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorData VectorDataType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The right angle detector's output is a vector data where each point // gives the coordinate of the detected angle. // // Next, We define the type for the line segment detector. A detailed // example for this detector can be found in section \ref{sec:LSD}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LineSegmentDetector LsdFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can finally define the type for the right angle detection // filter. This filter is templated over the input vector data type // provided by the line segment detector. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataToRightAngleVectorDataFilter RightAngleFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the line segment detector and the right angle detector. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LsdFilterType::Pointer lsdFilter = LsdFilterType::New(); RightAngleFilterType::Pointer rightAngleFilter = RightAngleFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet lsdFilter->SetInput(reader->GetOutput()); rightAngleFilter->SetInput(lsdFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // You can choose how far the right angle segments can be, and the tolerance // to consider an angle between two segments as an right one. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rightAngleFilter->SetAngleThreshold(angleThreshold); rightAngleFilter->SetDistanceThreshold(distanceThreshold); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will now draw the right angles on top of the input image. For // this, we will draw the detected points on top of the input // image. For this matter, we will use a // \doxygen{otb}{VectorDataToMapFilter} which is templated over // the input vector data type and the output image type, and a // combination of a \doxygen{itk}{binaryFunctorImageFilter} // and the \doxygen{otb}{Functor}{UnaryFunctorImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataToMapFilter VectorDataRendererType; VectorDataRendererType::Pointer vectorDataRenderer = VectorDataRendererType::New(); typedef otb::Functor::AlphaBlendingFunctor FunctorType; typedef itk::BinaryFunctorImageFilter BlendingFilterType; BlendingFilterType::Pointer blendingFilter = BlendingFilterType::New(); vectorDataRenderer->SetInput(1, lsdFilter->GetOutput()); vectorDataRenderer->SetInput(rightAngleFilter->GetOutput()); vectorDataRenderer->SetSize(reader->GetOutput()->GetLargestPossibleRegion().GetSize()); vectorDataRenderer->SetOrigin(reader->GetOutput()->GetOrigin()); vectorDataRenderer->SetSpacing(reader->GetOutput()->GetSpacing()); vectorDataRenderer->SetRenderingStyleType(VectorDataRendererType::Binary); blendingFilter->SetInput1(reader->GetOutput()); blendingFilter->SetInput2(vectorDataRenderer->GetOutput()); blendingFilter->GetFunctor().SetAlpha(0.25); writer->SetInput(blendingFilter->GetOutput()); writer->SetFileName(outfname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Before calling the \code{Update()} method of the writer in order to // trigger the pipeline execution, we call the // \doxygen{GenerateOutputInformation()} of the reader, so the // filter gets the information about image size and spacing. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->GenerateOutputInformation(); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:RIGHTANGLE_FILTER} shows the result of applying // the right angle detection filter to an image. // \begin{figure} // \center // \includegraphics[width=0.25\textwidth]{PrettyRighAngleInput.eps} // \includegraphics[width=0.25\textwidth]{PrettyRighAngleOutput.eps} // \itkcaption[Right Angle Detection Filter]{Result of applying the // \doxygen{otb}{LineSegmentDetector} and the // \doxygen{otb}{VectorDataToRightAngleVectorDataFilter} to an image. From left to right : // original image, detected right angles.} // \label{fig:RIGHTANGLE_FILTER} // \end{figure} // // Software Guide : EndLatex /************** images for printing *********/ typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter OutputWriterType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); OutputWriterType::Pointer outwriter = OutputWriterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(reader->GetOutput()); outwriter->SetInput(rescaler->GetOutput()); outwriter->SetFileName(inprettyfname); outwriter->Update(); rescaler->SetInput(blendingFilter->GetOutput()); outwriter->SetInput(rescaler->GetOutput()); outwriter->SetFileName(outprettyfname); outwriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/SFSExample.cxx000066400000000000000000000213031301006202600233220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {suburb2.jpeg} // OUTPUTS: {SFSLengthOutput.tif}, {SFSWidthOutput.tif}, {SFSMeanOutput.tif}, {SFSRatioOutput.tif}, {SFSSDOutput.tif}, {SFSPsiOutput.tif}, {SFSLengthPrettyOutput.tif}, {SFSWidthPrettyOutput.tif}, {SFSMeanPrettyOutput.tif}, {SFSRatioPrettyOutput.tif}, {SFSSDPrettyOutput.tif}, {SFSPsiPrettyOutput.tif} // 20 50 8 4 0.6 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{SFSTexturesImageFilter}. // This filter computes the Structural Feature Set as described in // \cite{SFS}. These features are textural parameters which give // information about the structure of lines passing through each pixel // of the image. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSFSTexturesImageFilter.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; const unsigned int Dimension = 2; std::string inName = argv[1]; std::string outNameLength = argv[2]; std::string outNameWidth = argv[3]; std::string outNameWMean = argv[4]; std::string outNameRatio = argv[5]; std::string outNameSD = argv[6]; std::string outNamePsi = argv[7]; std::string lengthprettyfname = argv[8]; std::string widthprettyfname = argv[9]; std::string wmeanprettyfname = argv[10]; std::string ratioprettyfname = argv[11]; std::string sdprettyfname = argv[12]; std::string psiprettyfname = argv[13]; PixelType spectThresh = atof(argv[14]); unsigned int spatialThresh = atoi(argv[15]); unsigned int dirNb = atoi(argv[16]); unsigned int maxConsideration = atoi(argv[17]); double alpha = atof(argv[18]); // Software Guide : BeginLatex // // As with every OTB program, we start by defining the types for the // images, the readers and the writers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The we can instantiate the type for the SFS filter, which is // templated over the input and output pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SFSTexturesImageFilter SFSFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After that, we can instantiate the filter. We will also instantiate // the reader and one writer for each output image, since the SFS // filter generates 6 different features. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SFSFilterType::Pointer filter = SFSFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writerLength = WriterType::New(); WriterType::Pointer writerWidth = WriterType::New(); WriterType::Pointer writerWMean = WriterType::New(); WriterType::Pointer writerRatio = WriterType::New(); WriterType::Pointer writerSD = WriterType::New(); WriterType::Pointer writerPsi = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(inName); // Software Guide : BeginLatex // // The SFS filter has several parameters which have to be // selected. They are: // \begin{enumerate} // \item a spectral threshold to decide if 2 neighboring pixels are // connected; //\item a spatial threshold defining the maximum length for an // extracted line; //\item the number of directions which will be analyzed (the first // one is to the right and they are equally distributed between 0 and // $2\pi$); // \item the $\alpha$ parameter fort the $\omega-mean$ feature; // \item the RatioMax parameter fort the $\omega-mean$ feature. // \end{enumerate} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetSpectralThreshold(spectThresh); filter->SetSpatialThreshold(spatialThresh); filter->SetNumberOfDirections(dirNb); filter->SetRatioMaxConsiderationNumber(maxConsideration); filter->SetAlpha(alpha); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In order to disable the computation of a feature, the // \code{SetFeatureStatus} parameter can be used. The $true$ value // enables the feature (default behavior) and the $false$ value // disables the computation. Therefore, the following line is useless, // but is given here as an example. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetFeatureStatus(SFSFilterType::PSI, true); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we plug the pipeline using all the writers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writerLength->SetFileName(outNameLength); writerLength->SetInput(filter->GetLengthOutput()); writerLength->Update(); writerWidth->SetFileName(outNameWidth); writerWidth->SetInput(filter->GetWidthOutput()); writerWidth->Update(); writerWMean->SetFileName(outNameWMean); writerWMean->SetInput(filter->GetWMeanOutput()); writerWMean->Update(); writerRatio->SetFileName(outNameRatio); writerRatio->SetInput(filter->GetRatioOutput()); writerRatio->Update(); writerSD->SetFileName(outNameSD); writerSD->SetInput(filter->GetSDOutput()); writerSD->Update(); writerPsi->SetFileName(outNamePsi); writerPsi->SetInput(filter->GetPSIOutput()); writerPsi->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:SFS_FILTER} shows the result of applying // the SFS computation to an image // \begin{figure} // \center // \includegraphics[width=0.25\textwidth]{suburb2.eps} // \includegraphics[width=0.25\textwidth]{SFSLengthPrettyOutput.eps} // \includegraphics[width=0.25\textwidth]{SFSWidthPrettyOutput.eps} // \includegraphics[width=0.25\textwidth]{SFSMeanPrettyOutput.eps} // \includegraphics[width=0.25\textwidth]{SFSRatioPrettyOutput.eps} // \includegraphics[width=0.25\textwidth]{SFSSDPrettyOutput.eps} // \includegraphics[width=0.25\textwidth]{SFSPsiPrettyOutput.eps} // \itkcaption[Right Angle Detection Filter]{Result of applying the // \doxygen{otb}{SFSTexturesImageFilter} to an image. From left to // right and top to bottom: original image, length, width, // $\omega$-mean, ratio, SD and Psi structural features. // original image, .} // \label{fig:SFS_FILTER} // \end{figure} // // Software Guide : EndLatex /************** pretty images for printing *********/ typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::ImageFileWriter OutputWriterType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); OutputWriterType::Pointer outWriter = OutputWriterType::New(); outWriter->SetInput(rescaler->GetOutput()); rescaler->SetInput(filter->GetLengthOutput()); outWriter->SetFileName(lengthprettyfname); outWriter->Update(); rescaler->SetInput(filter->GetWidthOutput()); outWriter->SetFileName(widthprettyfname); outWriter->Update(); rescaler->SetInput(filter->GetWMeanOutput()); outWriter->SetFileName(wmeanprettyfname); outWriter->Update(); rescaler->SetInput(filter->GetRatioOutput()); outWriter->SetFileName(ratioprettyfname); outWriter->Update(); rescaler->SetInput(filter->GetSDOutput()); outWriter->SetFileName(sdprettyfname); outWriter->Update(); rescaler->SetInput(filter->GetPSIOutput()); outWriter->SetFileName(psiprettyfname); outWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/SURFExample.cxx000066400000000000000000000265161301006202600234610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {ROISpot5SURF.png} // 3 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{ImageToSURFKeyPointSetFilter}. The Speed-Up Robust // Features (or SURF) is an algorithm in computer vision to detect and // describe local features in images. The algorithm is detailed in // \cite{SURF}. The applications of SURF are the same as those for // SIFT. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageToSURFKeyPointSetFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" #include #include int main(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0]; std::cerr << " InputImage OutputImage octaves scales" << std::endl; return 1; } const char * infname = argv[1]; const char * outputImageFilename = argv[2]; const unsigned int octaves = atoi(argv[3]); const unsigned int scales = atoi(argv[4]); const unsigned int Dimension = 2; // Software Guide : BeginLatex // // We will start by defining the required types. We will work with a // scalar image of float pixels. We also define the corresponding // image reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float RealType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The SURF descriptors will be stored in a point set containing the // vector of features. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The SURF filter itself is templated over the input image and the // generated point set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageToSURFKeyPointSetFilter ImageToFastSURFKeyPointSetFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageToFastSURFKeyPointSetFilterType::Pointer filter = ImageToFastSURFKeyPointSetFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the filter and set the number of scales for the SURF // computation. We can afterwards run the processing with the // \code{Update()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the SURF are computed, we may want to draw them on top of the // input image. In order to do this, we will create the following RGB // image and the corresponding writer: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; OutputImageType::Pointer outputImage = OutputImageType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the regions of the image by copying the information from the // input image and we allocate the memory for the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet outputImage->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now proceed to copy the input image into the output one // using region iterators. The input image is a grey level one. The // output image will be made of color crosses for each SURF on top of // the grey level input image. So we start by copying the grey level // values on each of the 3 channels of the color image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet itk::ImageRegionIterator iterOutput( outputImage, outputImage-> GetLargestPossibleRegion()); itk::ImageRegionIterator iterInput(reader->GetOutput(), reader->GetOutput()-> GetLargestPossibleRegion()); for (iterOutput.GoToBegin(), iterInput.GoToBegin(); !iterOutput.IsAtEnd(); ++iterOutput, ++iterInput) { OutputImageType::PixelType rgbPixel; rgbPixel.SetRed(static_cast(iterInput.Get())); rgbPixel.SetGreen(static_cast(iterInput.Get())); rgbPixel.SetBlue(static_cast(iterInput.Get())); iterOutput.Set(rgbPixel); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We are now going to plot color crosses on the output image. We will // need to define offsets (top, bottom, left and right) with respect // to the SURF position in order to draw the cross segments. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::OffsetType t = {{ 0, 1}}; ImageType::OffsetType b = {{ 0, -1}}; ImageType::OffsetType l = {{ 1, 0}}; ImageType::OffsetType r = {{-1, 0}}; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we are going to access the point set generated by the SURF // filter. The points are stored into a points container that we are // going to walk through using an iterator. These are the types needed // for this task: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the iterator to the beginning of the point set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the information about image size and spacing before drawing // the crosses. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::SpacingType spacing = reader->GetOutput()->GetSpacing(); ImageType::PointType origin = reader->GetOutput()->GetOrigin(); //OutputImageType::SizeType size = outputImage->GetLargestPossibleRegion().GetSize(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we iterate through the SURF set: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (pIt != filter->GetOutput()->GetPoints()->End()) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the pixel coordinates for each SURF by using the // \code{Value()} method on the point set iterator. We use the // information about size and spacing in order to convert the physical // coordinates of the point into pixel coordinates. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType index; index[0] = static_cast(vcl_floor( static_cast( (pIt.Value()[0] - origin[0]) / spacing[0] + 0.5 ))); index[1] = static_cast(vcl_floor( static_cast( (pIt.Value()[1] - origin[1]) / spacing[1] + 0.5 ))); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create a green pixel. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OutputImageType::PixelType keyPixel; keyPixel.SetRed(0); keyPixel.SetGreen(255); keyPixel.SetBlue(0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We draw the crosses using the offsets and checking that we are // inside the image, since SURFs on the image borders would cause an // out of bounds pixel access. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (outputImage->GetLargestPossibleRegion().IsInside(index)) { outputImage->SetPixel(index, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + t)) outputImage-> SetPixel(index + t, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + b)) outputImage-> SetPixel(index + b, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + l)) outputImage-> SetPixel(index + l, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + r)) outputImage-> SetPixel(index + r, keyPixel); } ++pIt; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we write the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageFilename); writer->SetInput(outputImage); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:SURFFast} shows the result of applying the SURF // point detector to a small patch extracted from a Spot 5 image. // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{ROISpot5.eps} // \includegraphics[width=0.40\textwidth]{ROISpot5SURF.eps} // \itkcaption[SURF Application]{Result of applying the // \doxygen{otb}{ImageToSURFKeyPointSetFilter} to a Spot 5 // image.} // \label{fig:SURFFast} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/SeamCarvingExample.cxx000066400000000000000000000175231301006202600250770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the details of the seam carving operation. // References to this method can be found in \cite{Avidan07}. This example // details the use of \doxygen{otb}{ImageToCarvingPathFilter} and // \doxygen{otb}{RemoveCarvingPathFilter}. // // In this example, a loop is defined to remove a vertical or horizontal seam // at each step of the algorithm. The seam with the minimum energy is chosen. // // Software Guide : EndLatex // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {SeamCarvingExampleOutput.png} // 50 // Software Guide : EndCommandLineArgs #include "otbImage.h" #include "itkPolyLineParametricPath.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkGradientMagnitudeImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbDrawPathFilter.h" #include "otbImageToCarvingPathFilter.h" #include "otbRemoveCarvingPathFilter.h" #include "itkImageDuplicator.h" int main(int itkNotUsed(argc), char * argv[]) { typedef float InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::Image OutputImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * filenamereader = argv[1]; reader->SetFileName(filenamereader); const char * filenamewriter = argv[2]; writer->SetFileName(filenamewriter); int iteration = atoi(argv[3]); // Software Guide : BeginLatex // // Energy is computed according to the gradient of the image, thus an // \doxygen{itk}{GradientMagnitudeImageFilter} is instantiated // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientMagnitudeImageFilter GradientType; GradientType::Pointer gradient = GradientType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{ImageToCarvingPathFilter} compute the seam of minimum // energy according to lines or columns of the image. Later, as we will // choose the best option between the two, we need two of these filters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageToCarvingPathFilter CarvingFilterType; CarvingFilterType::Pointer carvingFilterVert = CarvingFilterType::New(); CarvingFilterType::Pointer carvingFilterHor = CarvingFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{RemoveCarvingPathFilter} will really resize the image // deleting the path. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::RemoveCarvingPathFilter RemoveCarvingPathFilterType; RemoveCarvingPathFilterType::Pointer removeCarvingPath = RemoveCarvingPathFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As we are going to iterate through the filters, we need to disconnect the // pipeline at one point and store the image somewhere. For that purpose, we // use an \doxygen{itk}{ImageDuplicator} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageDuplicator duplicatorType; duplicatorType::Pointer duplicator = duplicatorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now that all elements have been instantiated, we start to plug the pipeline // and to define the loop. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->Update(); duplicator->SetInputImage(reader->GetOutput()); duplicator->Update(); double energyVert, energyHor; for (int i = 0; i < iteration; ++i) { gradient->SetInput(duplicator->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Two carving filters processed the gradient image to find the minimum // vertical seam and the minimum horizontal seam. Note that the // \code{UpdateLargestPossibleRegion()} need to be used as the size of the // input image will be different in each loop. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet carvingFilterVert->SetInput(gradient->GetOutput()); carvingFilterVert->SetDirection(0); carvingFilterVert->UpdateLargestPossibleRegion(); energyVert = carvingFilterVert->GetEnergyPerPix(); carvingFilterHor->SetInput(gradient->GetOutput()); carvingFilterHor->SetDirection(1); carvingFilterHor->UpdateLargestPossibleRegion(); energyHor = carvingFilterHor->GetEnergyPerPix(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The vertical or the horizontal seam with the minimal energy is chosen. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (energyVert < energyHor) { removeCarvingPath->SetInput(duplicator->GetOutput()); removeCarvingPath->SetInputPath(carvingFilterVert->GetOutput()); removeCarvingPath->SetDirection(0); removeCarvingPath->UpdateLargestPossibleRegion(); } else { removeCarvingPath->SetInput(duplicator->GetOutput()); removeCarvingPath->SetInputPath(carvingFilterHor->GetOutput()); removeCarvingPath->SetDirection(1); removeCarvingPath->UpdateLargestPossibleRegion(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The duplicator filter keep the results for the next loop // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet duplicator->SetInputImage(removeCarvingPath->GetOutput()); duplicator->Update(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the resulting image is saved on an image file as usual // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetInput(duplicator->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:SEAMCARVING_FILTER} shows the result of applying // the seam carving filter to a satellite image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.38\textwidth]{SeamCarvingExampleOutput.eps} // \itkcaption[Seam carving filter application]{Result of applying // the \doxygen{otb}{ImageToCarvingPathFilter} followed by the // \doxygen{otb}{RemoveCarvingPathFilter} to Quickbird // image. From left to right : original image, reduced image removing the 50 // seams with the lowest energy.} // \label{fig:SEAMCARVING_FILTER} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/SeamCarvingOtherExample.cxx000066400000000000000000000156651301006202600261060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{AddCarvingPathFilter}, // the opposite of the \doxygen{otb}{RemoveCarvingPathFilter}. // // Here, we use this filter combined with the \doxygen{otb}{DrawPathFilter} to // output the image with the removed seam in white. // // Most of the code is similar to the previous example. // // Software Guide : EndLatex // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {SeamCarvingOtherExampleOutput.png} // 50 // Software Guide : EndCommandLineArgs #include "otbImage.h" #include "itkPolyLineParametricPath.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkGradientMagnitudeImageFilter.h" #include "otbDrawPathFilter.h" #include "otbImageToCarvingPathFilter.h" #include "otbRemoveCarvingPathFilter.h" #include "otbAddCarvingPathFilter.h" #include "itkImageDuplicator.h" #include "otbObjectList.h" int main(int itkNotUsed(argc), char * argv[]) { typedef float InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::Image OutputImageType; typedef itk::PolyLineParametricPath PathType; // Software Guide : BeginLatex // // We need to define a list to keep the path in memory until the end of // the seam carving process. This is done using an \doxygen{otb}{ObjectList} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ObjectList PathListType; PathListType::Pointer pathList = PathListType::New(); // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * filenamereader = argv[1]; reader->SetFileName(filenamereader); const char * filenamewriter = argv[2]; writer->SetFileName(filenamewriter); int iteration = atoi(argv[3]); // Software Guide : BeginLatex // // We instantiate the different filters of the pipeline as before. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientMagnitudeImageFilter GradientType; GradientType::Pointer gradient = GradientType::New(); typedef otb::ImageToCarvingPathFilter CarvingFilterType; CarvingFilterType::Pointer carvingFilter = CarvingFilterType::New(); typedef otb::DrawPathFilter DrawPathFilterType; DrawPathFilterType::Pointer drawPathFilter = DrawPathFilterType::New(); typedef otb::RemoveCarvingPathFilter RemoveCarvingPathFilterType; RemoveCarvingPathFilterType::Pointer removeCarvingPath = RemoveCarvingPathFilterType::New(); typedef otb::AddCarvingPathFilter AddCarvingPathFilterType; AddCarvingPathFilterType::Pointer addCarvingPath = AddCarvingPathFilterType::New(); typedef itk::ImageDuplicator duplicatorType; duplicatorType::Pointer duplicator = duplicatorType::New(); reader->Update(); duplicator->SetInputImage(reader->GetOutput()); duplicator->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The loop to shorten the image is similar to the previous one. Here we // decide to remove alternatively one vertical and one horizontal seam. At // each iteration, we save the seam on the list using the \code{PushBack()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (int i = 0; i < iteration; ++i) { gradient->SetInput(duplicator->GetOutput()); carvingFilter->SetInput(gradient->GetOutput()); carvingFilter->SetDirection(i % 2); removeCarvingPath->SetInput(duplicator->GetOutput()); removeCarvingPath->SetInputPath(carvingFilter->GetOutput()); removeCarvingPath->SetDirection(i % 2); removeCarvingPath->UpdateLargestPossibleRegion(); pathList->PushBack(carvingFilter->GetOutput()); carvingFilter->GetOutput()->DisconnectPipeline(); duplicator->SetInputImage(removeCarvingPath->GetOutput()); duplicator->Update(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The next loop will put back the seam using the // \doxygen{otb}{AddCarvingPathFilter} and drawing it with the // \doxygen{otb}{DrawPathFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (int i = iteration - 1; i >= 0; i--) { addCarvingPath->SetInput(duplicator->GetOutput()); addCarvingPath->SetInputPath(pathList->GetNthElement(i)); addCarvingPath->SetDirection(i % 2); addCarvingPath->UpdateLargestPossibleRegion(); drawPathFilter->SetInput(addCarvingPath->GetOutput()); drawPathFilter->SetInputPath(pathList->GetNthElement(i)); drawPathFilter->UpdateLargestPossibleRegion(); duplicator->SetInputImage(drawPathFilter->GetOutput()); duplicator->Update(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the resulting image is saved on an image file as usual // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetInput(duplicator->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:SEAMCARVING2_FILTER} shows the result of applying // the seam carving filter to a satellite image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{SeamCarvingOtherExampleOutput.eps} // \itkcaption[Seam carving filter application]{Illustration of the minimum // seams alternatively vertical and horizontal on a Quickbird // image. From left to right : original image, image with the 25 vertical // seams and the 25 horizontal seams.} // \label{fig:SEAMCARVING2_FILTER} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/TextureExample.cxx000066400000000000000000000151041301006202600243310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ADS40RoiSmall.png} // OUTPUTS: {TextureOutput.tif}, {pretty_TextureOutput.png} // 2 1 1 // Software Guide : EndCommandLineArgs #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Pretty RGB output #include "otbVectorImage.h" #include "otbImageToVectorImageCastFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step required to use the filter is to include the header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbScalarImageToTexturesFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { // Parse command line parameters if (argc != 7) { std::cerr << "Usage: " << argv[0] << " "; std::cerr << " "; std::cerr << " "; std::cerr << std::endl; return EXIT_FAILURE; } const char* infname = argv[1]; const char* outfname = argv[2]; const char* outprettyfname = argv[3]; const unsigned int radius = static_cast(atoi(argv[4])); const unsigned int xOffset = static_cast(atoi(argv[5])); const unsigned int yOffset = static_cast(atoi(argv[6])); typedef double PixelType; const int Dimension = 2; typedef otb::Image ImageType; // Software Guide : BeginLatex // // After defining the types for the pixels and the images used in the // example, we define the types for the textures filter. It is // templated by the input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ScalarImageToTexturesFilter TexturesFilterType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); writer->SetFileName(outfname); // Software Guide : BeginLatex // // We can now instantiate the filters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet TexturesFilterType::Pointer texturesFilter = TexturesFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The texture filters takes at least 2 parameters: the radius of the // neighborhood on which the texture will be computed and the offset // used. Texture features are bivariate statistics, that is, they are // computed using pair of pixels. Each texture feature is defined for // an offset defining the pixel pair. // // The radius parameter can be passed to the filter as a scalar // parameter if the neighborhood is square, or as \code{SizeType} in // any case. // // The offset is always an array of N values, where N is the number of // dimensions of the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ImageType::SizeType SizeType; SizeType sradius; sradius.Fill(radius); texturesFilter->SetRadius(sradius); typedef ImageType::OffsetType OffsetType; OffsetType offset; offset[0] = xOffset; offset[1] = yOffset; texturesFilter->SetOffset(offset); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The textures filter will automatically derive the optimal // bin size for co-occurences histogram, but they need to know // the input image minimum and maximum. These values can be set // like this : // Software Guide : EndLatex // Software Guide : BeginCodeSnippet texturesFilter->SetInputImageMinimum(0); texturesFilter->SetInputImageMaximum(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To tune co-occurence histogram resolution, you can use // the SetNumberOfBinsPerAxis() method. // // Software Guide : EndLatex // Software Guide : BeginLatex // // We can now plug the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet texturesFilter->SetInput(reader->GetOutput()); writer->SetInput(texturesFilter->GetInertiaOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:TEXTUREFUNCTOR} shows the result of applying // the contrast texture computation. // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{ADS40RoiSmall.eps} // \includegraphics[width=0.40\textwidth]{pretty_TextureOutput.eps} // \itkcaption[Results of applying Haralick contrast]{Result of applying the // \doxygen{otb}{ScalarImageToTexturesFilter} to an image. From left to right : // original image, contrast.} // \label{fig:TEXTUREFUNCTOR} // \end{figure} // // Software Guide : EndLatex // Pretty image creation for printing typedef otb::VectorImage VectorImageType; typedef otb::VectorImage PrettyVectorImageType; typedef otb::ImageFileWriter WriterPrettyOutputType; typedef otb::ImageToVectorImageCastFilter VectorCastFilterType; typedef otb::VectorRescaleIntensityImageFilter RescalerOutputType; RescalerOutputType::Pointer outputRescaler = RescalerOutputType::New(); WriterPrettyOutputType::Pointer prettyOutputWriter = WriterPrettyOutputType::New(); VectorCastFilterType::Pointer vectorCastFilter = VectorCastFilterType::New(); vectorCastFilter->SetInput(texturesFilter->GetInertiaOutput()); outputRescaler->SetInput(vectorCastFilter->GetOutput()); PrettyVectorImageType::PixelType min(1), max(1); min.Fill(0); max.Fill(255); outputRescaler->SetOutputMinimum(min); outputRescaler->SetOutputMaximum(max); prettyOutputWriter->SetFileName(outprettyfname); prettyOutputWriter->SetInput(outputRescaler->GetOutput()); prettyOutputWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/ThresholdToPointSetExample.cxx000066400000000000000000000123061301006202600266170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // 250 252 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Sometimes, it may be more valuable not to get an image from the threshold // step but rather a list of coordinates. This can be done with the // \doxygen{otb}{ThresholdImageToPointSetFilter}. // // The following example illustrates the use of the // \doxygen{otb}{ThresholdImageToPointSetFilter} which provide a list of points // within given thresholds. Points set are described in section // \ref{sec:PointSetSection} on page \pageref{sec:PointSetSection}. // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" // Software Guide : BeginLatex // // The first step required to use this filter is to include the header // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbThresholdImageToPointSetFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 3) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " lowerThreshold upperThreshold" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The next step is to decide which pixel types to use for the input image // and the Point Set as well as their dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A reader is instantiated to read the input image // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); const char * filenamereader = argv[1]; reader->SetFileName(filenamereader); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the parameters from the command line for the threshold filter. The // lower and upper thresholds parameters are similar to those of the // \doxygen{itk}{BinaryThresholdImageFilter} (see Section // \ref{sec:BinaryThresholdingImageFilter} on page // \pageref{sec:BinaryThresholdingImageFilter} for more information). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet int lowerThreshold = atoi(argv[2]); int upperThreshold = atoi(argv[3]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then we create the ThresholdImageToPointSetFilter and we pass the // parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ThresholdImageToPointSetFilter FilterThresholdType; FilterThresholdType::Pointer filterThreshold = FilterThresholdType::New(); filterThreshold->SetLowerThreshold(lowerThreshold); filterThreshold->SetUpperThreshold(upperThreshold); filterThreshold->SetInput(0, reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To manipulate and display the result of this filter, we manually // instantiate a point set and we call the \code{Update()} method on the // threshold filter to trigger the pipeline execution. // // After this step, the \code{pointSet} variable contains the point set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointSetType::Pointer pointSet = PointSetType::New(); pointSet = filterThreshold->GetOutput(); filterThreshold->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To display each point, we create an iterator on the list of points, // which is accessible through the method \code{GetPoints()} of the PointSet. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointsContainer ContainerType; ContainerType* pointsContainer = pointSet->GetPoints(); typedef ContainerType::Iterator IteratorType; IteratorType itList = pointsContainer->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A while loop enable us to through the list a display the coordinate of // each point. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (itList != pointsContainer->End()) { std::cout << itList.Value() << std::endl; ++itList; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/TouziEdgeDetectorExample.cxx000066400000000000000000000203341301006202600262630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {amst.png} // OUTPUTS: {amstTouziEdges.png}, {amstTouziDirections.png} // 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{TouziEdgeDetectorImageFilter}. // This filter belongs to the family of the fixed false alarm rate // edge detectors but it is appropriate for SAR images, where the // speckle noise is considered as multiplicative. By analogy with the // classical gradient-based edge detectors which are suited to the // additive noise case, this filter computes a ratio of local means in // both sides of the edge \cite{touzi88}. In order to have a // normalized response, the following computation is performed : // \begin{equation} // r = 1 - min\{\frac{\mu_A}{\mu_B},\frac{\mu_B}{\mu_A} \}, // \end{equation} // where $\mu_A$ and $\mu_B$ are the local means computed at both // sides of the edge. In order to detect edges with any orientation, // $r$ is computed for the 4 principal directions and the maximum // response is kept. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbTouziEdgeDetectorImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputEdgesImageFile outputDirectionsImageFile radius" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The images are defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::TouziEdgeDetectorImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The same is done for the rescaler and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RescalerType::Pointer rescaler = RescalerType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The \code{itk::RescaleIntensityImageFilter} needs to know which // is the minimu and maximum values of the output generated // image. Those can be chosen in a generic way by using the // \code{NumericTraits} functions, since they are templated over // the pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{otb}{TouziEdgeDetectorImageFilter}. The pipeline is built as follows. // // \index{otb::TouziEdgeDetectorImageFilter!SetInput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{SetRadius()} defines the size of the window to // be used for the computation of the local means. // // \index{otb::LeeImageFilter!SetRadius()} // \index{otb::LeeImageFilter!NbLooks()} // \index{SetNbLooks()!otb::LeeImageFilter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::SizeType Radius; Radius[0] = atoi(argv[4]); Radius[1] = atoi(argv[4]); filter->SetRadius(Radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter is executed by invoking the \code{Update()} method. If the // filter is part of a larger image processing pipeline, calling // \code{Update()} on a downstream filter will also trigger update of this // filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // We can also obtain the direction of the edges by invoking the // \code{GetOutputDirection()} method. // Software Guide : EndLatex writer->SetFileName(argv[3]); // Software Guide : BeginCodeSnippet rescaler->SetInput(filter->GetOutputDirection()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:TOUZI_FILTER} shows the result of applying the Touzi // edge detector // filter to a SAR image. // \begin{figure} // \center // \includegraphics[width=0.25\textwidth]{amst.eps} // \includegraphics[width=0.25\textwidth]{amstTouziEdges.eps} // \includegraphics[width=0.25\textwidth]{amstTouziDirections.eps} // \itkcaption[Touzi Edge Detector Application]{Result of applying the // \doxygen{otb}{TouziEdgeDetectorImageFilter} to a SAR image. From left to right : // original image, edge intensity and edge orientation.} // \label{fig:TOUZI_FILTER} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/FeatureExtraction/test/000077500000000000000000000000001301006202600216075ustar00rootroot00000000000000OTB-release-5.8/Examples/FeatureExtraction/test/CMakeLists.txt000066400000000000000000000162371301006202600243600ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/FeatureExtraction) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- CorrelationLineDetectorExampleTest---------- otb_add_test(NAME feTeCorrelationLineDetectorExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/amstLineCorrelations.png ${TEMP}/amstLineCorrelations.png ${BASELINE}/amstLineCorrelationDirections.png ${TEMP}/amstLineCorrelationDirections.png Execute $ ${INPUTDATA}/amst.png ${TEMP}/amstLineCorrelations.png ${TEMP}/amstLineCorrelationDirections.png 5 1 ) # ------- LocalHoughExampleTest---------- otb_add_test(NAME feTeLocalHoughExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/detected_local_hough.png ${TEMP}/detected_local_hough.png Execute $ ${INPUTDATA}/detected_lines.png ${TEMP}/detected_local_hough.png 30 10 1 50 ) # ------- HarrisExampleTest---------- otb_add_test(NAME feTeHarrisExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ROISpot5Harris.png ${TEMP}/ROISpot5Harris.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/ROISpot5Harris.png 1.5 2 0.1 ) # ------- TouziEdgeDetectorExampleTest---------- otb_add_test(NAME feTeTouziEdgeDetectorExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/amstTouziEdges.png ${TEMP}/amstTouziEdges.png ${BASELINE}/amstTouziDirections.png ${TEMP}/amstTouziDirections.png Execute $ ${INPUTDATA}/amst.png ${TEMP}/amstTouziEdges.png ${TEMP}/amstTouziDirections.png 3 ) # ------- ExtractSegmentsByStepsExampleTest---------- otb_add_test(NAME feTeExtractSegmentsByStepsExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/amstSegmentExtractionBySteps.png ${TEMP}/amstSegmentExtractionBySteps.png Execute $ ${INPUTDATA}/amst_ers1.ima.extrait.419_187_70_66.hdr ${TEMP}/amstSegmentExtractionBySteps.png 10 3 10 0.5 10 10 3 10 0.5 ) # ------- AsymmetricFusionOfLineDetectorExampleTest---------- otb_add_test(NAME feTeAsymmetricFusionOfLineDetectorExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/amstLineFusion.png ${TEMP}/amstLineFusion.png Execute $ ${INPUTDATA}/amst.png ${TEMP}/amstLineFusion.png 5 1 ) # ------- ExtractSegmentsExampleTest---------- otb_add_test(NAME feTeExtractSegmentsExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/amstSegmentExtraction.png ${TEMP}/amstSegmentExtraction.png Execute $ ${INPUTDATA}/amst_ers1.ima.extrait.419_187_70_66.hdr ${TEMP}/amstSegmentExtraction.png 10 3 10 0.5 10 10 3 10 0.5 ) # ------- RatioLineDetectorExampleTest---------- otb_add_test(NAME feTeRatioLineDetectorExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/amstLineRatios.png ${TEMP}/amstLineRatios.png ${BASELINE}/amstLineRatioDirections.png ${TEMP}/amstLineRatioDirections.png Execute $ ${INPUTDATA}/amst.png ${TEMP}/amstLineRatios.png ${TEMP}/amstLineRatioDirections.png 5 1 ) # ------- AlignmentsExampleTest---------- if(OTBMathParser_LOADED) otb_add_test(NAME feTeAlignmentsExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/QB_SuburbAlign.png ${TEMP}/QB_SuburbAlign.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/QB_SuburbAlign.png 5 ) # ------- RoadExtractionExamplesTest---------- otb_add_test(NAME feTeExtractRoadByStepsExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/qb_ExtractRoad_pretty.png ${TEMP}/qb_ExtractRoad_pretty.png ${BASELINE}/ExtractRoadByStepsExampleOutput.png ${TEMP}/ExtractRoadByStepsExampleOutput.png Execute $ ${INPUTDATA}/qb_RoadExtract.tif ${TEMP}/ExtractRoadByStepsExampleOutput.png ${TEMP}/qb_ExtractRoad_pretty.png 337 557 432 859 0.00005 1.0 ) otb_add_test(NAME feTeExtractRoadExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/ExtractRoadExampleOutput.png ${TEMP}/ExtractRoadExampleOutput.png Execute $ ${INPUTDATA}/qb_RoadExtract.tif ${TEMP}/ExtractRoadExampleOutput.png 337 557 432 859 1.0 0.00005 1.0 0.39269 1.0 10.0 25. ) endif() # ------- SeamCarvingExamplesTest---------- otb_add_test(NAME feTeSeamCarvingExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/SeamCarvingExampleOutput.png ${TEMP}/SeamCarvingExampleOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/SeamCarvingExampleOutput.png 50 ) otb_add_test(NAME feTeSeamCarvingOtherExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/SeamCarvingOtherExampleOutput.png ${TEMP}/SeamCarvingOtherExampleOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/SeamCarvingOtherExampleOutput.png 50 ) #otb_add_test(NAME feTeImageToSIFTKeyPointSetFilterTest COMMAND ${OTB_TEST_DRIVER} # --compare-image ${NOTOL} # ${BASELINE}/ImageToSIFTKeyPointSetFilterOutput.png # ${TEMP}/ImageToSIFTKeyPointSetFilterOutput.png # Execute $ # ${INPUTDATA}/Scene.png # ${TEMP}/ImageToSIFTKeyPointSetFilterOutput.png # 6 3 0.08 10 #) # ------- CloudDetectionExampleTest---------- otb_add_test(NAME feTeCloudDetectionExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/CloudDetectionOutput.png ${TEMP}/PrettyCloudDetectionOutput.png Execute $ ${INPUTDATA}/CloudsOnReunion.tif ${TEMP}/CloudDetectionOutput.tif ${TEMP}/PrettyCloudDetectionInput.png ${TEMP}/PrettyCloudDetectionOutput.png 553 467 734 581 0.4 0.6 1.0 ) if (Module_OTBVectorDataRendering AND OTB_USE_MAPNIK) # ------- Line Segment Detector test---------- otb_add_test(NAME feTeLineSegmentDetectorExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/feTeLineSegmentDetectorExampleOutput.png ${TEMP}/feTeLineSegmentDetectorExampleOutput.png Execute $ ${INPUTDATA}/Scene.png ${TEMP}/feTeLineSegmentDetectorExampleOutput.png ) # ------- Right Angle Detection test---------- otb_add_test(NAME feTeRightAngleDetectionExample COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/feTeRightAngleDetectionExampleOutput.png ${TEMP}/feTeRightAngleDetectionExampleOutput.png Execute $ ${INPUTDATA}/Scene.png ${TEMP}/feTeRightAngleDetectionExampleOutput.png ${TEMP}/PrettyRightAngleInput.png ${TEMP}/PrettyRightAngleOutput.png 0.1 10. ) endif() OTB-release-5.8/Examples/Filtering/000077500000000000000000000000001301006202600171175ustar00rootroot00000000000000OTB-release-5.8/Examples/Filtering/BinaryThresholdImageFilter.cxx000066400000000000000000000207071301006202600250630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {BinaryThresholdImageFilterOutput.png} // 150 180 0 255 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \itkpiccaption[BinaryThresholdImageFilter transfer function]{Transfer function // of the BinaryThresholdImageFilter. // \label{fig:BinaryThresholdTransferFunction}} // \parpic(8cm, 5cm)[r]{\includegraphics[width=7cm]{BinaryThresholdTransferFunction.eps}} // // This example illustrates the use of the binary threshold image filter. // This filter is used to transform an image into a binary image by changing // the pixel values according to the rule illustrated in // Figure~\ref{fig:BinaryThresholdTransferFunction}. The user defines two // thresholds---Upper and Lower---and two intensity values---Inside and // Outside. For each pixel in the input image, the value of the pixel is // compared with the lower and upper thresholds. If the pixel value is inside // the range defined by $[Lower, Upper]$ the output pixel is assigned the // InsideValue. Otherwise the output pixels are assigned to the OutsideValue. // Thresholding is commonly applied as the last operation of a segmentation // pipeline. // // \index{itk::Binary\-Threshold\-Image\-Filter!Instantiation} // \index{itk::Binary\-Threshold\-Image\-Filter!Header} // // The first step required to use the \doxygen{itk}{BinaryThresholdImageFilter} is // to include its header file. // // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkBinaryThresholdImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc < 7) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputImageFile outputImageFile "; std::cerr << " lowerThreshold upperThreshold "; std::cerr << " outsideValue insideValue " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The next step is to decide which pixel types to use for the input and output // images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input and output image types are now defined using their respective // pixel types and dimensions. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter type can be instantiated using the input and output image // types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryThresholdImageFilter< InputImageType, OutputImageType> FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. (See Section \ref{sec:IO} on page // \pageref{sec:IO} for more information about reading // and writing data.) // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the output // image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to \doxygen{itk}{SmartPointer}s. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // BinaryThresholdImageFilter. // // \index{itk::Binary\-Threshold\-Image\-Filter!SetInput()} // \index{otb::FileImageReader!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{SetOutsideValue()} defines the intensity value to be // assigned to those pixels whose intensities are outside the range defined // by the lower and upper thresholds. The method \code{SetInsideValue()} // defines the intensity value to be assigned to pixels with intensities // falling inside the threshold range. // // \index{itk::Binary\-Threshold\-Image\-Filter!SetOutsideValue()} // \index{itk::Binary\-Threshold\-Image\-Filter!SetInsideValue()} // \index{SetOutsideValue()!itk::Binary\-Threshold\-Image\-Filter} // \index{SetInsideValue()!itk::Binary\-Threshold\-Image\-Filter} // // Software Guide : EndLatex const OutputPixelType outsideValue = atoi(argv[5]); const OutputPixelType insideValue = atoi(argv[6]); // Software Guide : BeginCodeSnippet filter->SetOutsideValue(outsideValue); filter->SetInsideValue(insideValue); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The methods \code{SetLowerThreshold()} and \code{SetUpperThreshold()} // define the range of the input image intensities that will be transformed // into the \code{InsideValue}. Note that the lower and upper thresholds are // values of the type of the input image pixels, while the inside and // outside values are of the type of the output image pixels. // // Software Guide : EndLatex const InputPixelType lowerThreshold = atoi(argv[3]); const InputPixelType upperThreshold = atoi(argv[4]); // Software Guide : BeginCodeSnippet filter->SetLowerThreshold(lowerThreshold); filter->SetUpperThreshold(upperThreshold); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The execution of the filter is triggered by invoking the \code{Update()} // method. If the filter's output has been passed as input to subsequent // filters, the \code{Update()} call on any posterior filters in the // pipeline will indirectly trigger the update of this filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{ROISpot5.eps} // \includegraphics[width=0.44\textwidth]{BinaryThresholdImageFilterOutput.eps} // \itkcaption[BinaryThresholdImageFilter output]{Effect of the // BinaryThresholdImageFilter on a ROI of a Spot 5 image.} // \label{fig:BinaryThresholdImageFilterInputOutput} // \end{figure} // // Figure \ref{fig:BinaryThresholdImageFilterInputOutput} illustrates the // effect of this filter on a ROI of a Spot 5 image of an // agricultural area. This // figure shows the limitations of this filter for performing segmentation // by itself. These limitations are particularly noticeable in noisy images // and in images lacking spatial uniformity. // // \relatedClasses // \begin{itemize} // \item \doxygen{itk}{ThresholdImageFilter} // \end{itemize} // // Software Guide : EndLatex writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/CMakeLists.txt000066400000000000000000000061201301006202600216560ustar00rootroot00000000000000project(FilteringExamples) add_executable(BinaryThresholdImageFilter BinaryThresholdImageFilter.cxx) target_link_libraries(BinaryThresholdImageFilter ${OTB_LIBRARIES}) add_executable(CannyEdgeDetectionImageFilter CannyEdgeDetectionImageFilter.cxx) target_link_libraries(CannyEdgeDetectionImageFilter ${OTB_LIBRARIES}) add_executable(CompositeFilterExample CompositeFilterExample.cxx) target_link_libraries(CompositeFilterExample ${OTB_LIBRARIES}) add_executable(DanielssonDistanceMapImageFilter DanielssonDistanceMapImageFilter.cxx) target_link_libraries(DanielssonDistanceMapImageFilter ${OTB_LIBRARIES}) add_executable(DerivativeImageFilter DerivativeImageFilter.cxx) target_link_libraries(DerivativeImageFilter ${OTB_LIBRARIES}) add_executable(DiscreteGaussianImageFilter DiscreteGaussianImageFilter.cxx) target_link_libraries(DiscreteGaussianImageFilter ${OTB_LIBRARIES}) add_executable(GeometriesChangeSpatialReference GeometriesChangeSpatialReference.cxx) target_link_libraries(GeometriesChangeSpatialReference ${OTB_LIBRARIES}) add_executable(GeometriesFilter GeometriesFilter.cxx) target_link_libraries(GeometriesFilter ${OTB_LIBRARIES}) add_executable(GradientAnisotropicDiffusionImageFilter GradientAnisotropicDiffusionImageFilter.cxx) target_link_libraries(GradientAnisotropicDiffusionImageFilter ${OTB_LIBRARIES}) add_executable(GradientMagnitudeImageFilter GradientMagnitudeImageFilter.cxx) target_link_libraries(GradientMagnitudeImageFilter ${OTB_LIBRARIES}) add_executable(GradientMagnitudeRecursiveGaussianImageFilter GradientMagnitudeRecursiveGaussianImageFilter.cxx) target_link_libraries(GradientMagnitudeRecursiveGaussianImageFilter ${OTB_LIBRARIES}) add_executable(LaplacianRecursiveGaussianImageFilter1 LaplacianRecursiveGaussianImageFilter1.cxx) target_link_libraries(LaplacianRecursiveGaussianImageFilter1 ${OTB_LIBRARIES}) add_executable(LaplacianRecursiveGaussianImageFilter2 LaplacianRecursiveGaussianImageFilter2.cxx) target_link_libraries(LaplacianRecursiveGaussianImageFilter2 ${OTB_LIBRARIES}) add_executable(MathematicalMorphologyBinaryFilters MathematicalMorphologyBinaryFilters.cxx) target_link_libraries(MathematicalMorphologyBinaryFilters ${OTB_LIBRARIES}) add_executable(MathematicalMorphologyGrayscaleFilters MathematicalMorphologyGrayscaleFilters.cxx) target_link_libraries(MathematicalMorphologyGrayscaleFilters ${OTB_LIBRARIES}) add_executable(MeanImageFilter MeanImageFilter.cxx) target_link_libraries(MeanImageFilter ${OTB_LIBRARIES}) add_executable(MedianImageFilter MedianImageFilter.cxx) target_link_libraries(MedianImageFilter ${OTB_LIBRARIES}) add_executable(SecondDerivativeRecursiveGaussianImageFilter SecondDerivativeRecursiveGaussianImageFilter.cxx) target_link_libraries(SecondDerivativeRecursiveGaussianImageFilter ${OTB_LIBRARIES}) add_executable(ThresholdImageFilter ThresholdImageFilter.cxx) target_link_libraries(ThresholdImageFilter ${OTB_LIBRARIES}) if (Module_OTBVectorDataRendering) add_executable(RasterizationExample RasterizationExample.cxx) target_link_libraries(RasterizationExample ${OTB_LIBRARIES}) endif() if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Filtering/CannyEdgeDetectionImageFilter.cxx000066400000000000000000000112571301006202600254560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {CannyEdgeDetectorImageFilterOutput.png} // 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example introduces the use of the // \doxygen{itk}{CannyEdgeDetectionImageFilter}. This filter is widely used for // edge detection since it is the optimal solution satisfying the constraints // of good sensitivity, localization and noise robustness. // // \index{itk::CannyEdgeDetectionImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step required for using this filter is to include its header file // // \index{itk::CannyEdgeDetectionImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkCannyEdgeDetectionImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImage outputImage [variance]" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; float variance = 2.0; if (argc > 3) { variance = atof(argv[3]); } typedef unsigned char CharPixelType; // IO typedef double RealPixelType; // Operations const unsigned int Dimension = 2; typedef otb::Image CharImageType; typedef otb::Image RealImageType; // Software Guide : BeginLatex // // As the Canny filter works with real values, we can instantiated the reader using // an image with pixels as double. This does not imply anything on the real image // coding format which will be cast into double. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescaleFilter; // Software Guide : BeginLatex // // The \doxygen{itk}{CannyEdgeDetectionImageFilter} is instantiated using the float image type. // // \index{itk::CannyEdgeDetectionImageFilter} // // Software Guide : EndLatex typedef itk::CannyEdgeDetectionImageFilter CannyFilter; //Setting the IO ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); RescaleFilter::Pointer rescale = RescaleFilter::New(); //Setting the ITK pipeline filter CannyFilter::Pointer cannyFilter = CannyFilter::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); //The output of an edge filter is 0 or 1 rescale->SetOutputMinimum(0); rescale->SetOutputMaximum(255); cannyFilter->SetInput(reader->GetOutput()); cannyFilter->SetVariance(variance); rescale->SetInput(cannyFilter->GetOutput()); writer->SetInput(rescale->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{ROISpot5.eps} // \includegraphics[width=0.44\textwidth]{CannyEdgeDetectorImageFilterOutput.eps} // \itkcaption[CannyEdgeDetectorImageFilter output]{Effect of the // CannyEdgeDetectorImageFilter on a ROI of a Spot 5 image.} // \label{fig:CannyEdgeDetectorImageFilterInputOutput} // \end{figure} // // Figure \ref{fig:CannyEdgeDetectorImageFilterInputOutput} illustrates the // effect of this filter on a ROI of a Spot 5 image of an // agricultural area. // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/CompositeFilterExample.cxx000066400000000000000000000211341301006202600242700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The composite filter we will build combines three filters: a gradient // magnitude operator, which will calculate the first-order derivative of // the image; a thresholding step to select edges over a given strength; // and finally a rescaling filter, to ensure the resulting image data is // visible by scaling the intensity to the full spectrum of the output // image type. // // Since this filter takes an image and produces another image (of // identical type), we will specialize the ImageToImageFilter: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we include headers for the component filters: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkUnaryFunctorImageFilter.h" #include "itkGradientMagnitudeImageFilter.h" #include "itkThresholdImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : EndCodeSnippet #include "itkNumericTraits.h" #include "otbImage.h" // Software Guide : BeginLatex // // Now we can declare the filter itself. It is within the OTB namespace, // and we decide to make it use the same image type for both input and // output, thus the template declaration needs only one parameter. // Deriving from \code{ImageToImageFilter} provides default behavior for // several important aspects, notably allocating the output image (and // making it the same dimensions as the input). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet namespace otb { template class ITK_EXPORT CompositeExampleImageFilter : public itk::ImageToImageFilter { public: // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we have the standard declarations, used for object creation with // the object factory: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef CompositeExampleImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // Software Guide : EndCodeSnippet /** Method for creation through object factory */ itkNewMacro(Self); /** Run-time type information */ itkTypeMacro(CompositeExampleImageFilter, itk::ImageToImageFilter); /** Display */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; // Software Guide : BeginLatex // // Here we declare an alias (to save typing) for the image's pixel type, // which determines the type of the threshold value. We then use the // convenience macros to define the Get and Set methods for this parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef typename TImageType::PixelType PixelType; itkGetMacro(Threshold, PixelType); itkSetMacro(Threshold, PixelType); // Software Guide : EndCodeSnippet protected: CompositeExampleImageFilter(); // Software Guide : BeginLatex // // Now we can declare the component filter types, templated over the // enclosing image type: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet protected: typedef itk::ThresholdImageFilter ThresholdType; typedef itk::GradientMagnitudeImageFilter GradientType; typedef itk::RescaleIntensityImageFilter RescalerType; // Software Guide : EndCodeSnippet void GenerateData() ITK_OVERRIDE; private: CompositeExampleImageFilter(Self &); // intentionally not implemented void operator =(const Self&); // intentionally not implemented // Software Guide : BeginLatex // // The component filters are declared as data members, all using the smart // pointer types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typename GradientType::Pointer m_GradientFilter; typename ThresholdType::Pointer m_ThresholdFilter; typename RescalerType::Pointer m_RescaleFilter; PixelType m_Threshold; }; } /* namespace otb */ // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The constructor sets up the pipeline, which involves creating the // stages, connecting them together, and setting default parameters. // // Software Guide : EndLatex namespace otb { // Software Guide : BeginCodeSnippet template CompositeExampleImageFilter ::CompositeExampleImageFilter() { m_GradientFilter = GradientType::New(); m_ThresholdFilter = ThresholdType::New(); m_RescaleFilter = RescalerType::New(); m_ThresholdFilter->SetInput(m_GradientFilter->GetOutput()); m_RescaleFilter->SetInput(m_ThresholdFilter->GetOutput()); m_Threshold = 1; m_RescaleFilter->SetOutputMinimum( itk::NumericTraits::NonpositiveMin()); m_RescaleFilter->SetOutputMaximum(itk::NumericTraits::max()); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{GenerateData()} is where the composite magic happens. First, // we connect the first component filter to the inputs of the composite // filter (the actual input, supplied by the upstream stage). Then we // graft the output of the last stage onto the output of the composite, // which ensures the filter regions are updated. We force the composite // pipeline to be processed by calling \code{Update()} on the final stage, // then graft the output back onto the output of the enclosing filter, so // it has the result available to the downstream filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet template void CompositeExampleImageFilter:: GenerateData() { m_GradientFilter->SetInput(this->GetInput()); m_ThresholdFilter->ThresholdBelow(this->m_Threshold); m_RescaleFilter->GraftOutput(this->GetOutput()); m_RescaleFilter->Update(); this->GraftOutput(m_RescaleFilter->GetOutput()); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally we define the \code{PrintSelf} method, which (by convention) // prints the filter parameters. Note how it invokes the superclass to // print itself first, and also how the indentation prefixes each line. // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet template void CompositeExampleImageFilter:: PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Threshold:" << this->m_Threshold << std::endl; } } /* end namespace otb */ // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is important to note that in the above example, none of the internal // details of the pipeline were exposed to users of the class. The interface // consisted of the Threshold parameter (which happened to change the value in // the component filter) and the regular ImageToImageFilter interface. This // example pipeline is illustrated in // Figure~\ref{fig:CompositeExamplePipeline}. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char* argv[]) { if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile" << std::endl; return EXIT_FAILURE; } typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::CompositeExampleImageFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); filter->SetThreshold(20); writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); try { writer->Update(); } catch (itk::ExceptionObject e) { std::cerr << "Error: " << e << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/DanielssonDistanceMapImageFilter.cxx000066400000000000000000000165501301006202600261730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {FivePoints.png} // OUTPUTS: {DanielssonDistanceMapImageFilterOutput1.png} // OUTPUTS: {DanielssonDistanceMapImageFilterOutput2.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{itk}{DanielssonDistanceMapImageFilter}. This filter generates a // distance map from the input image using the algorithm developed by // Danielsson \cite{Danielsson1980}. As secondary outputs, a Voronoi // partition of the input elements is produced, as well as a vector image // with the components of the distance vector to the closest point. The input // to the map is assumed to be a set of points on the input image. Each // point/pixel is considered to be a separate entity even if they share the // same gray level value. // // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!Instantiation} // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!Header} // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkConnectedComponentImageFilter.h" #include "itkDanielssonDistanceMapImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputImageFile outputDistanceMapImageFile "; std::cerr << " outputVoronoiMapImageFilter "; std::cerr << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel types to use for the input and output // images. Since the output will contain distances measured in pixels, the // pixel type should be able to represent at least the width of the image, // or said in $N-D$ terms, the maximum extension along all the dimensions. // The input and output image types are now defined using their respective // pixel type and dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; typedef unsigned short OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter type can be instantiated using the input and output image // types defined above. A filter object is created with the \code{New()} // method. // // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!instantiation} // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!New()} // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ConnectedComponentImageFilter< InputImageType, InputImageType> ConnectedType; ConnectedType::Pointer connectedComponents = ConnectedType::New(); typedef itk::DanielssonDistanceMapImageFilter< InputImageType, OutputImageType, OutputImageType> FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet typedef itk::RescaleIntensityImageFilter< OutputImageType, OutputImageType> RescalerType; RescalerType::Pointer scaler = RescalerType::New(); // // Reader and Writer types are instantiated. // typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // The input to the filter is taken from a reader and its output is passed // to a \doxygen{itk}{RescaleIntensityImageFilter} and then to a writer. // // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!SetInput()} // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet connectedComponents->SetInput(reader->GetOutput()); filter->SetInput(connectedComponents->GetOutput()); scaler->SetInput(filter->GetOutput()); writer->SetInput(scaler->GetOutput()); // Software Guide : EndCodeSnippet scaler->SetOutputMaximum(65535L); scaler->SetOutputMinimum(0L); // Software Guide : BeginLatex // // The type of input image has to be specified. In this case, a binary // image is selected. // // \index{itk::Danielsson\-Distance\-MapImage\-Filter!InputIsBinaryOn()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->InputIsBinaryOff(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{FivePoints.eps} // \includegraphics[width=0.32\textwidth]{DanielssonDistanceMapImageFilterOutput1.eps} // \includegraphics[width=0.32\textwidth]{DanielssonDistanceMapImageFilterOutput2.eps} // \itkcaption[DanielssonDistanceMapImageFilter // output]{DanielssonDistanceMapImageFilter output. Set of pixels, distance // map and Voronoi partition.} // \label{fig:DanielssonDistanceMapImageFilterInputOutput} // \end{figure} // // Figure \ref{fig:DanielssonDistanceMapImageFilterInputOutput} illustrates // the effect of this filter on a binary image with a set of points. The // input image is shown at left, the distance map at the center and the // Voronoi partition at right. This filter computes distance maps in // N-dimensions and is therefore capable of producing $N-D$ Voronoi // partitions. // // \index{Voronoi partitions} // \index{Voronoi partitions!itk::Danielsson\-Distance\-Map\-Image\-Filter} // // Software Guide : EndLatex writer->Update(); const char * voronoiMapFileName = argv[3]; // Software Guide : BeginLatex // // The Voronoi map is obtained with the \code{GetVoronoiMap()} method. In // the lines below we connect this output to the intensity rescaler and // save the result in a file. // // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!GetVoronoiMap()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet scaler->SetInput(filter->GetVoronoiMap()); writer->SetFileName(voronoiMapFileName); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Execution of the writer is triggered by the invocation of the // \code{Update()} method. Since this method can potentially throw // exceptions it must be placed in a \code{try/catch} block. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/DerivativeImageFilter.cxx000066400000000000000000000133661301006202600240670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {DerivativeImageFilterFloatOutput.hdr} // OUTPUTS: {DerivativeImageFilterOutput.png} // 1 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The \doxygen{itk}{DerivativeImageFilter} is used for computing the partial // derivative of an image, the derivative of an image along a particular axial // direction. // // \index{itk::DerivativeImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The header file corresponding to this filter should be included first. // // \index{itk::DerivativeImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkDerivativeImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 6) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile normalizedOutputImageFile "; std::cerr << " derivativeOrder direction" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Next, the pixel types for the input and output images must be defined and, with // them, the image types can be instantiated. Note that it is important to // select a signed type for the image, since the values of the derivatives // will be positive as well as negative. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef float OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // Using the image types, it is now possible to define the filter type // and create the filter object. // // \index{itk::DerivativeImageFilter!instantiation} // \index{itk::DerivativeImageFilter!New()} // \index{itk::DerivativeImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::DerivativeImageFilter< InputImageType, OutputImageType> FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The order of the derivative is selected with the \code{SetOrder()} // method. The direction along which the derivative will be computed is // selected with the \code{SetDirection()} method. // // \index{itk::DerivativeImageFilter!SetOrder()} // \index{itk::DerivativeImageFilter!SetDirection()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetOrder(atoi(argv[4])); filter->SetDirection(atoi(argv[5])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input to the filter can be taken from any other filter, for example // a reader. The output can be passed down the pipeline to other filters, // for example, a writer. An update call on any downstream filter will // trigger the execution of the derivative filter. // // \index{itk::DerivativeImageFilter!SetInput()} // \index{itk::DerivativeImageFilter!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{ROISpot5.eps} // \includegraphics[width=0.44\textwidth]{DerivativeImageFilterOutput.eps} // \itkcaption[Effect of the Derivative filter.]{Effect of the // Derivative filter.} // \label{fig:DerivativeImageFilterOutput} // \end{figure} // // Figure \ref{fig:DerivativeImageFilterOutput} illustrates the effect of // the DerivativeImageFilter. The derivative // is taken along the $x$ direction. The sensitivity to noise in the image // is evident from this result. // // Software Guide : EndLatex typedef otb::Image WriteImageType; typedef itk::RescaleIntensityImageFilter< OutputImageType, WriteImageType> NormalizeFilterType; typedef otb::ImageFileWriter NormalizedWriterType; NormalizeFilterType::Pointer normalizer = NormalizeFilterType::New(); NormalizedWriterType::Pointer normalizedWriter = NormalizedWriterType::New(); normalizer->SetInput(filter->GetOutput()); normalizedWriter->SetInput(normalizer->GetOutput()); normalizer->SetOutputMinimum(0); normalizer->SetOutputMaximum(255); normalizedWriter->SetFileName(argv[3]); normalizedWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/DiscreteGaussianImageFilter.cxx000066400000000000000000000170671301006202600252240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {DiscreteGaussianImageFilterOutput.png} // 4 9 // Software Guide : EndCommandLineArgs // // Software Guide : BeginLatex // // \itkpiccaption[DiscreteGaussianImageFilter Gaussian diagram.]{Discretized // Gaussian.\label{fig:DiscretizedGaussian}} // \parpic(7cm, 4cm)[r]{\includegraphics[width=6cm]{DiscreteGaussian.eps}} // // The \doxygen{itk}{DiscreteGaussianImageFilter} computes the convolution of the // input image with a Gaussian kernel. This is done in $ND$ by taking // advantage of the separability of the Gaussian kernel. A one-dimensional // Gaussian function is discretized on a convolution kernel. The size of the // kernel is extended until there are enough discrete points in the Gaussian // to ensure that a user-provided maximum error is not exceeded. Since the // size of the kernel is unknown a priori, it is necessary to impose a limit to // its growth. The user can thus provide a value to be the maximum admissible // size of the kernel. Discretization error is defined as the difference // between the area under the discrete Gaussian curve (which has finite // support) and the area under the continuous Gaussian. // // Gaussian kernels in ITK are constructed according to the theory of Tony // Lindeberg \cite{Lindeberg1994} so that smoothing and derivative operations // commute before and after discretization. In other words, finite difference // derivatives on an image $I$ that has been smoothed by convolution with the // Gaussian are equivalent to finite differences computed on $I$ by convolving // with a derivative of the Gaussian. // // \index{itk::DiscreteGaussianImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step required to use this filter is to include its header file. // // \index{itk::DiscreteGaussianImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkDiscreteGaussianImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile variance maxKernelWidth " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Types should be chosen for the pixels of the input and output images. // Image types can be instantiated using the pixel type and dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef float OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The discrete Gaussian filter type is instantiated using the // input and output image types. A corresponding filter object is created. // // \index{itk::DiscreteGaussianImageFilter!instantiation} // \index{itk::DiscreteGaussianImageFilter!New()} // \index{itk::DiscreteGaussianImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::DiscreteGaussianImageFilter< InputImageType, OutputImageType> FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The input image can be obtained from the output of another // filter. Here, an image reader is used as its input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet const double gaussianVariance = atof(argv[3]); const unsigned int maxKernelWidth = atoi(argv[4]); // Software Guide : BeginLatex // // The filter requires the user to provide a value for the variance // associated with the Gaussian kernel. The method \code{SetVariance()} is // used for this purpose. The discrete Gaussian is constructed as a // convolution kernel. The maximum kernel size can be set by the user. Note // that the combination of variance and kernel-size values may result in a // truncated Gaussian kernel. // // \index{itk::DiscreteGaussianImageFilter!SetVariance()} // \index{itk::DiscreteGaussianImageFilter!SetMaximumKernelWidth()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetVariance(gaussianVariance); filter->SetMaximumKernelWidth(maxKernelWidth); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the filter is executed by invoking the \code{Update()} method. // // \index{itk::DiscreteGaussianImageFilter!Update()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // If the output of this filter has been connected to other filters down // the pipeline, updating any of the downstream filters would have // triggered the execution of this one. For example, a writer could have // been used after the filter. // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef itk::RescaleIntensityImageFilter< OutputImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); // Software Guide : BeginCodeSnippet rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{DiscreteGaussianImageFilterOutput.eps} // \itkcaption[DiscreteGaussianImageFilter output]{Effect of the // DiscreteGaussianImageFilter.} // \label{fig:DiscreteGaussianImageFilterInputOutput} // \end{figure} // // Figure~\ref{fig:DiscreteGaussianImageFilterInputOutput} illustrates the // effect of this filter. // // Note that large Gaussian variances will produce large convolution kernels // and correspondingly slower computation times. Unless a high degree of // accuracy is required, it may be more desirable to use the approximating // \doxygen{itk}{RecursiveGaussianImageFilter} with large variances. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/GeometriesChangeSpatialReference.cxx000066400000000000000000000167701301006202600262240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesToGeometriesFilter.h" #include #include #include "otbGeometriesSet.h" #include "otbOGRGeometryWrapper.h" /*===========================================================================*/ /*=========================[ Reprojection functor ]==========================*/ /*===========================================================================*/ namespace internal { struct Deleters { void operator()(OGRCoordinateTransformation *p) const { OCTDestroyCoordinateTransformation(p); } void operator()(OGRSpatialReference *p) const { #if GDAL_VERSION_NUM >= 1700 OGRSpatialReference::DestroySpatialReference(p); #else #warning the following resource release may crash, please update your version of GDAL delete p; // note there is no garanty #endif } }; } // internal namespace struct ReprojectTransformationFunctor { typedef OGRGeometry TransformedElementType; otb::ogr::UniqueGeometryPtr operator()(OGRGeometry const* in) const; void SetTransformation(OGRSpatialReference & in, OGRSpatialReference & out) { m_reprojector.reset(OGRCreateCoordinateTransformation(&in, &out)); } private: boost::interprocess::unique_ptr m_reprojector; }; otb::ogr::UniqueGeometryPtr ReprojectTransformationFunctor::operator()(OGRGeometry const* in) const { otb::ogr::UniqueGeometryPtr out(in ? in->clone() : ITK_NULLPTR); if (out) { const OGRErr err = out->transform(m_reprojector.get()); if (err != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot reproject a geometry: " << CPLGetLastErrorMsg()); } } return otb::move(out); } /*===========================================================================*/ /*==========================[ reprojection filter ]==========================*/ /*===========================================================================*/ class MyReprojectionFilter : public otb::DefaultGeometriesToGeometriesFilter { public: typedef MyReprojectionFilter Self; typedef otb::DefaultGeometriesToGeometriesFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(MyReprojectionFilter, otb::DefaultGeometriesToGeometriesFilter); void SetOutputSpatialReference(std::string const& srs); void UpdateTransformation(OGRSpatialReference &in) { (*this)->SetTransformation(in, *m_osr); } protected: /** Default constructor. */ MyReprojectionFilter(){ } /** Destructor. */ ~MyReprojectionFilter() ITK_OVERRIDE{ } private: OGRSpatialReference* DoDefineNewLayerSpatialReference(otb::ogr::Layer const& itkNotUsed(source)) const ITK_OVERRIDE { return m_osr.get(); } boost::interprocess::unique_ptr m_osr; }; void MyReprojectionFilter::SetOutputSpatialReference(std::string const& srs) { OGRSpatialReference outSrs; char *name = const_cast(srs.c_str()); OGRErr ret = outSrs.importFromWkt(&name); if (ret) { ret = outSrs.importFromProj4(name); } if (ret) { ret = outSrs.importFromEPSG(atoi(name)); } if (ret) { std::cout << "Error : spatial reference system not recognized ("< [] -srs \n"; } std::string inputFile; std::string outputFile; std::string srs; bool workingInplace; bool outputIsStdout; }; int main (int argc, char **argv) { if (argc < 2) { return EXIT_FAILURE; } try { const Options options(argc, argv); otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( options.inputFile, options.workingInplace ? otb::ogr::DataSource::Modes::Update_LayerOverwrite : otb::ogr::DataSource::Modes::Read); otb::ogr::DataSource::Pointer output = options.workingInplace ? input : options.outputIsStdout ? ITK_NULLPTR : otb::ogr::DataSource::New( options.outputFile, otb::ogr::DataSource::Modes::Update_LayerCreateOnly); std::cout << "input: " << otb::ogr::version_proxy::GetFileListAsStringVector(&input->ogr())[0] << " should be: " << options.inputFile << "\n"; if (output) { std::cout << "output: " << otb::ogr::version_proxy::GetFileListAsStringVector(&output->ogr())[0] << " should be: " << options.outputFile << "\n"; } // std::cout << "\n"; FilterType::Pointer filter = FilterType::New(); // TODO: this make no sense for in-place transformations filter->SetOutputSpatialReference(options.srs); filter->UpdateTransformation( *(const_cast(input->GetLayer(0).GetSpatialRef())) ); if (!options.workingInplace) { otb::GeometriesSet::Pointer in_set = otb::GeometriesSet::New(input); filter->SetInput(in_set); } if (output) { otb::GeometriesSet::Pointer out_set = otb::GeometriesSet::New(output); filter->SetOutput(out_set); out_set->Update(); } else { filter->UpdateOutputData(ITK_NULLPTR); assert(filter->GetOutput() && "output not set"); filter->GetOutput()->Print(std::cout, 0); } return EXIT_SUCCESS; } catch (std::exception const& e) { std::cerr << e.what() << "\n"; } return EXIT_FAILURE; } OTB-release-5.8/Examples/Filtering/GeometriesFilter.cxx000066400000000000000000000072641301006202600231250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesToGeometriesFilter.h" #include #include #include "otbGeometriesSet.h" /*===========================================================================*/ /*=============================[ SwapXYFunctor ]=============================*/ /*===========================================================================*/ struct SwapXYFunctor { typedef OGRGeometry TransformedElementType; otb::ogr::UniqueGeometryPtr operator()(OGRGeometry const* in) const { otb::ogr::UniqueGeometryPtr out(in ? in->clone() : ITK_NULLPTR); if (out) { #if GDAL_VERSION_NUM >= 1900 out->swapXY(); #else assert(!"Sorry, This example filter requires GDAL v1.9.0 or later"); #endif } return otb::move(out); } }; /*===========================================================================*/ /*=================================[ main ]==================================*/ /*===========================================================================*/ typedef otb::DefaultGeometriesToGeometriesFilter FilterType; int main (int argc, char **argv) { if (argc < 2) { std::cerr << argv[0] << " inputGeometriesFile [outputGeometriesFile]" << std::endl; return EXIT_FAILURE; } try { const bool workingInplace = argc == 2; const bool outputIsStdout = !workingInplace && !strcmp(argv[2], "-"); const std::string inputFile = argv[1]; const std::string outputFile = workingInplace ? argv[1] : argv[2]; otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( inputFile, workingInplace ? otb::ogr::DataSource::Modes::Update_LayerOverwrite : otb::ogr::DataSource::Modes::Read); otb::ogr::DataSource::Pointer output = workingInplace ? input : outputIsStdout ? ITK_NULLPTR : otb::ogr::DataSource::New( outputFile, otb::ogr::DataSource::Modes::Update_LayerCreateOnly); std::cout << "input: " << otb::ogr::version_proxy::GetFileListAsStringVector(&input->ogr())[0] << " should be: " << inputFile << "\n"; if (output) { std::cout << "output: " << otb::ogr::version_proxy::GetFileListAsStringVector(&output->ogr())[0] << " should be: " << outputFile << "\n"; } // std::cout << "\n"; FilterType::Pointer filter = FilterType::New(); if (!workingInplace) { otb::GeometriesSet::Pointer in_set = otb::GeometriesSet::New(input); filter->SetInput(in_set); } if (output) { otb::GeometriesSet::Pointer out_set = otb::GeometriesSet::New(output); filter->SetOutput(out_set); out_set->Update(); } else { filter->UpdateOutputData(ITK_NULLPTR); assert(filter->GetOutput() && "output not set"); filter->GetOutput()->Print(std::cout, 0); } return EXIT_SUCCESS; } catch (std::exception const& e) { std::cerr << e.what() << "\n"; } return EXIT_FAILURE; } OTB-release-5.8/Examples/Filtering/GradientAnisotropicDiffusionImageFilter.cxx000066400000000000000000000165761301006202600276120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {GradientAnisotropicDiffusionImageFilterOutput.png} // 5 0.125 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // The \doxygen{itk}{GradientAnisotropicDiffusionImageFilter} implements an // $N$-dimensional version of the classic Perona-Malik anisotropic diffusion // equation for scalar-valued images \cite{Perona1990}. // // The conductance term for this implementation is chosen as a function of the // gradient magnitude of the image at each point, reducing the strength of // diffusion at edge pixels. // // \begin{equation} // C(\mathbf{x}) = e^{-(\frac{\parallel \nabla U(\mathbf{x}) \parallel}{K})^2} // \end{equation} // // The numerical implementation of this equation is similar to that described // in the Perona-Malik paper \cite{Perona1990}, but uses a more robust technique // for gradient magnitude estimation and has been generalized to $N$-dimensions. // // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step required to use this filter is to include its header file. // // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkGradientAnisotropicDiffusionImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 6) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile "; std::cerr << "numberOfIterations timeStep conductance" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Types should be selected based on the pixel types required for the // input and output images. The image types are defined using the pixel // type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef float OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The filter type is now instantiated using both the input image and the // output image types. The filter object is created by the \code{New()} // method. // // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!instantiation} // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!New()} // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientAnisotropicDiffusionImageFilter< InputImageType, OutputImageType> FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The input image can be obtained from the output of another filter. Here, // an image reader is used as source. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet const unsigned int numberOfIterations = atoi(argv[3]); const double timeStep = atof(argv[4]); const double conductance = atof(argv[5]); // Software Guide : BeginLatex // // This filter requires three parameters, the number of iterations to be // performed, the time step and the conductance parameter used in the // computation of the level set evolution. These parameters are set using // the methods \code{SetNumberOfIterations()}, \code{SetTimeStep()} and // \code{SetConductanceParameter()} respectively. The filter can be // executed by invoking Update(). // // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!Update()} // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!SetTimeStep()} // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!SetConductanceParameter()} // \index{itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter!SetNumberOfIterations()} // \index{SetTimeStep()!itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter} // \index{SetNumberOfIterations()!itk::Gradient\-Anisotropic\-Diffusion\-Image\-Filter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetNumberOfIterations(numberOfIterations); filter->SetTimeStep(timeStep); filter->SetConductanceParameter(conductance); filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A typical value for the time step is $0.125$. The number of // iterations is typically set to $5$; more iterations result in // further smoothing and will increase the computing time linearly. // // Software Guide : EndLatex // // The output of the filter is rescaled here and then sent to a writer. // typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef itk::RescaleIntensityImageFilter< OutputImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : BeginLatex // // \begin{figure} \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{GradientAnisotropicDiffusionImageFilterOutput.eps} // \itkcaption[GradientAnisotropicDiffusionImageFilter output]{Effect of the // GradientAnisotropicDiffusionImageFilter.} // \label{fig:GradientAnisotropicDiffusionImageFilterInputOutput} // \end{figure} // // Figure // \ref{fig:GradientAnisotropicDiffusionImageFilterInputOutput} // illustrates the effect of this filter. In this example the // filter was run with a time step of $0.125$, and $5$ iterations. // The figure shows how homogeneous regions are // smoothed and // edges are preserved. // // \relatedClasses // \begin{itemize} // \item \doxygen{itk}{BilateralImageFilter} // \item \doxygen{itk}{CurvatureAnisotropicDiffusionImageFilter} // \item \doxygen{itk}{CurvatureFlowImageFilter} // \end{itemize} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/GradientMagnitudeImageFilter.cxx000066400000000000000000000160321301006202600253510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {GradientMagnitudeImageFilterOutput.png} // Software Guide : EndCommandLineArgs // // Software Guide : BeginLatex // // The magnitude of the image gradient is extensively used in image analysis, // mainly to help in the determination of object contours and the // separation of homogeneous regions. The // \doxygen{itk}{GradientMagnitudeImageFilter} computes the magnitude of the // image gradient at each pixel location using a simple finite differences // approach. For example, in the case of $2D$ the computation is equivalent // to convolving the image with masks of type // // \begin{center} // \begin{picture}(200, 50) // \put( 5.0, 32.0){\framebox(30.0, 15.0){-1}} // \put(35.0, 32.0){\framebox(30.0, 15.0){0}} // \put(65.0, 32.0){\framebox(30.0, 15.0){1}} // \put(105.0, 17.0){\framebox(20.0, 15.0){1}} // \put(105.0, 32.0){\framebox(20.0, 15.0){0}} // \put(105.0, 47.0){\framebox(20.0, 15.0){-1}} // \end{picture} // \end{center} // // then adding the sum of their squares and computing the square root of the sum. // // This filter will work on images of any dimension thanks to the internal // use of \doxygen{itk}{NeighborhoodIterator} and \doxygen{itk}{NeighborhoodOperator}. // // \index{itk::GradientMagnitudeImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step required to use this filter is to include its header file. // // \index{itk::GradientMagnitudeImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkGradientMagnitudeImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Types should be chosen for the pixels of the input and output images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef float OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input and output image types can be defined using the pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The type of the gradient magnitude filter is defined by the // input image and the output image types. // // \index{itk::GradientMagnitudeImageFilter!instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientMagnitudeImageFilter< InputImageType, OutputImageType> FilterType; // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // A filter object is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // \index{itk::GradientMagnitudeImageFilter!New()} // \index{itk::GradientMagnitudeImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input image can be obtained from the output of another filter. Here, // the source is an image reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the filter is executed by invoking the \code{Update()} method. // // \index{itk::GradientMagnitudeImageFilter!Update()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // If the output of this filter has been connected to other filters in a // pipeline, updating any of the downstream filters will also trigger an // update of this filter. For example, the gradient magnitude filter may be // connected to an image writer. // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef itk::RescaleIntensityImageFilter< OutputImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); // Software Guide : BeginCodeSnippet rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{ROISpot5.eps} // \includegraphics[width=0.44\textwidth]{GradientMagnitudeImageFilterOutput.eps} // \itkcaption[GradientMagnitudeImageFilter output]{Effect of the // GradientMagnitudeImageFilter.} // \label{fig:GradientMagnitudeImageFilterInputOutput} // \end{figure} // // Figure \ref{fig:GradientMagnitudeImageFilterInputOutput} // illustrates the effect of the gradient magnitude. The figure // shows the sensitivity of this filter to noisy data. // // Attention should be paid to the image type chosen to represent the output // image since the dynamic range of the gradient magnitude image is usually // smaller than the dynamic range of the input image. As always, there are // exceptions to this rule, for example, images of man-made objects // that contain high // contrast objects. // // This filter does not apply any smoothing to the image before computing the // gradients. The results can therefore be very sensitive to noise and may // not be best choice for scale space analysis. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/GradientMagnitudeRecursiveGaussianImageFilter.cxx000066400000000000000000000203231301006202600307320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {GradientMagnitudeRecursiveGaussianImageFilterOutput3.png} // 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {GradientMagnitudeRecursiveGaussianImageFilterOutput5.png} // 5 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Differentiation is an ill-defined operation over digital data. In practice // it is convenient to define a scale in which the differentiation should be // performed. This is usually done by preprocessing the data with a smoothing // filter. It has been shown that a Gaussian kernel is the most convenient // choice for performing such smoothing. By choosing a particular value for // the standard deviation ($\sigma$) of the Gaussian, an associated scale is // selected that ignores high frequency content, commonly considered image // noise. // // The \doxygen{itk}{GradientMagnitudeRecursiveGaussianImageFilter} computes the // magnitude of the image gradient at each pixel location. The computational // process is equivalent to first smoothing the image by convolving it with a // Gaussian kernel and then applying a differential operator. The user // selects the value of $\sigma$. // // Internally this is done by applying an IIR \footnote{Infinite Impulse // Response} filter that approximates a convolution with the derivative of the // Gaussian kernel. Traditional convolution will produce a more accurate // result, but the IIR approach is much faster, especially using large // $\sigma$s \cite{Deriche1990, Deriche1993}. // // GradientMagnitudeRecursiveGaussianImageFilter will work on images of // any dimension by taking advantage of the natural separability of the // Gaussian kernel and its derivatives. // // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step required to use this filter is to include its header // file. // // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkGradientMagnitudeRecursiveGaussianImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile sigma" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Types should be instantiated based on the pixels of the input and // output images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef float OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // With them, the input and output image types can be instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The filter type is now instantiated using both the input image and the // output image types. // // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< InputImageType, OutputImageType> FilterType; // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // A filter object is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter!New()} // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input image can be obtained from the output of another filter. Here, // an image reader is used as source. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The standard deviation of the Gaussian smoothing kernel is now set. // // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter!SetSigma()} // \index{SetSigma()!itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter} // // Software Guide : EndLatex const double sigma = atof(argv[3]); // Software Guide : BeginCodeSnippet filter->SetSigma(sigma); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally the filter is executed by invoking the \code{Update()} method. // // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter!Update()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // If connected to other filters in a pipeline, this filter will // automatically update when any downstream filters are updated. For // example, we may connect this gradient magnitude filter to an image file // writer and then update the writer. // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef itk::RescaleIntensityImageFilter< OutputImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); // Software Guide : BeginCodeSnippet rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{GradientMagnitudeRecursiveGaussianImageFilterOutput3.eps} // \includegraphics[width=0.44\textwidth]{GradientMagnitudeRecursiveGaussianImageFilterOutput5.eps} // \itkcaption[GradientMagnitudeRecursiveGaussianImageFilter output]{Effect of // the GradientMagnitudeRecursiveGaussianImageFilter.} // \label{fig:GradientMagnitudeRecursiveGaussianImageFilterInputOutput} // \end{figure} // // Figure // \ref{fig:GradientMagnitudeRecursiveGaussianImageFilterInputOutput} // illustrates the effect of this filter using $\sigma$ values of $3$ (left) and $5$ // (right). The figure shows how the sensitivity to noise can be // regulated by selecting an appropriate $\sigma$. This type of // scale-tunable filter is suitable for performing scale-space analysis. // // Attention should be paid to the image type chosen to represent the output // image since the dynamic range of the gradient magnitude image is usually // smaller than the dynamic range of the input image. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/LaplacianRecursiveGaussianImageFilter1.cxx000066400000000000000000000311161301006202600273060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {LaplacianRecursiveGaussianImageFilteroutput3.hdr} // 3 // OUTPUTS: {LaplacianRecursiveGaussianImageFilterOutput3.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {LaplacianRecursiveGaussianImageFilteroutput5.hdr} // 5 // OUTPUTS: {LaplacianRecursiveGaussianImageFilterOutput5.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates how to use the // \doxygen{itk}{RecursiveGaussianImageFilter} for computing the // Laplacian of an // image. // // \index{itk::RecursiveGaussianImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkAddImageFilter.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginLatex // // The first step required to use this filter is to include its header file. // // \index{itk::RecursiveGaussianImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkRecursiveGaussianImageFilter.h" // Software Guide : EndCodeSnippet #include "itkRescaleIntensityImageFilter.h" int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile sigma [RescaledOutputImageFile] " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Types should be selected on the desired input and output pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef float OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input and output image types are instantiated using the pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The filter type is now instantiated using both the input image and the // output image types. // // \index{itk::RecursiveGaussianImageFilter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RecursiveGaussianImageFilter< InputImageType, OutputImageType> FilterType; // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // This filter applies the approximation of the convolution along a single // dimension. It is therefore necessary to concatenate several of these filters // to produce smoothing in all directions. In this example, we create a pair // of filters since we are processing a $2D$ image. The filters are // created by invoking the \code{New()} method and assigning the result to // a \doxygen{itk}{SmartPointer}. // // We need two filters for computing the X component of the Laplacian and // two other filters for computing the Y component. // // \index{itk::RecursiveGaussianImageFilter!New()} // \index{itk::RecursiveGaussianImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::Pointer filterX1 = FilterType::New(); FilterType::Pointer filterY1 = FilterType::New(); FilterType::Pointer filterX2 = FilterType::New(); FilterType::Pointer filterY2 = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since each one of the newly created filters has the potential to perform // filtering along any dimension, we have to restrict each one to a // particular direction. This is done with the \code{SetDirection()} method. // // \index{RecursiveGaussianImageFilter!SetDirection()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filterX1->SetDirection(0); // 0 --> X direction filterY1->SetDirection(1); // 1 --> Y direction filterX2->SetDirection(0); // 0 --> X direction filterY2->SetDirection(1); // 1 --> Y direction // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{itk}{RecursiveGaussianImageFilter} can approximate the // convolution with the Gaussian or with its first and second // derivatives. We select one of these options by using the // \code{SetOrder()} method. Note that the argument is an \code{enum} whose // values can be \code{ZeroOrder}, \code{FirstOrder} and // \code{SecondOrder}. For example, to compute the $x$ partial derivative we // should select \code{FirstOrder} for $x$ and \code{ZeroOrder} for // $y$. Here we want only to smooth in $x$ and $y$, so we select // \code{ZeroOrder} in both directions. // // \index{RecursiveGaussianImageFilter!SetOrder()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filterX1->SetOrder(FilterType::ZeroOrder); filterY1->SetOrder(FilterType::SecondOrder); filterX2->SetOrder(FilterType::SecondOrder); filterY2->SetOrder(FilterType::ZeroOrder); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // There are two typical ways of normalizing Gaussians depending on their // application. For scale-space analysis it is desirable to use a // normalization that will preserve the maximum value of the input. This // normalization is represented by the following equation. // // \begin{equation} // \frac{ 1 }{ \sigma \sqrt{ 2 \pi } } // \end{equation} // // In applications that use the Gaussian as a solution of the diffusion // equation it is desirable to use a normalization that preserve the // integral of the signal. This last approach can be seen as a conservation // of mass principle. This is represented by the following equation. // // \begin{equation} // \frac{ 1 }{ \sigma^2 \sqrt{ 2 \pi } } // \end{equation} // // The \doxygen{itk}{RecursiveGaussianImageFilter} has a boolean flag that allows // users to select between these two normalization options. Selection is // done with the method \code{SetNormalizeAcrossScale()}. Enable this flag // to analyzing an image across scale-space. In the current example, this // setting has no impact because we are actually renormalizing the output to // the dynamic range of the reader, so we simply disable the flag. // // \index{RecursiveGaussianImageFilter!SetNormalizeAcrossScale()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const bool normalizeAcrossScale = false; filterX1->SetNormalizeAcrossScale(normalizeAcrossScale); filterY1->SetNormalizeAcrossScale(normalizeAcrossScale); filterX2->SetNormalizeAcrossScale(normalizeAcrossScale); filterY2->SetNormalizeAcrossScale(normalizeAcrossScale); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input image can be obtained from the output of another // filter. Here, an image reader is used as the source. The image is passed to // the $x$ filter and then to the $y$ filter. The reason for keeping these // two filters separate is that it is usual in scale-space applications to // compute not only the smoothing but also combinations of derivatives at // different orders and smoothing. Some factorization is possible when // separate filters are used to generate the intermediate results. Here // this capability is less interesting, though, since we only want to smooth // the image in all directions. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filterX1->SetInput(reader->GetOutput()); filterY1->SetInput(filterX1->GetOutput()); filterY2->SetInput(reader->GetOutput()); filterX2->SetInput(filterY2->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is now time to select the $\sigma$ of the Gaussian used to // smooth the data. Note that $\sigma$ must be passed to both // filters and that sigma is considered to be in the units of the // image spacing. That is, at the moment of applying the smoothing // process, the filter will take into account the spacing values // defined in the image. // // \index{itk::RecursiveGaussianImageFilter!SetSigma()} // \index{SetSigma()!itk::RecursiveGaussianImageFilter} // // Software Guide : EndLatex const double sigma = atof(argv[3]); // Software Guide : BeginCodeSnippet filterX1->SetSigma(sigma); filterY1->SetSigma(sigma); filterX2->SetSigma(sigma); filterY2->SetSigma(sigma); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally the two components of the Laplacian should be added together. The // \doxygen{itk}{AddImageFilter} is used for this purpose. // // \index{itk::AddImageFilter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::AddImageFilter< OutputImageType, OutputImageType, OutputImageType> AddFilterType; AddFilterType::Pointer addFilter = AddFilterType::New(); addFilter->SetInput1(filterY1->GetOutput()); addFilter->SetInput2(filterX2->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filters are triggered by invoking \code{Update()} on the Add filter // at the end of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { addFilter->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The resulting image could be saved to a file using the // \doxygen{otb}{ImageFileWriter} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(addFilter->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{LaplacianRecursiveGaussianImageFilterOutput3.eps} // \includegraphics[width=0.44\textwidth]{LaplacianRecursiveGaussianImageFilterOutput5.eps} // \itkcaption[Output of the RecursiveGaussianImageFilter.]{Effect of the // RecursiveGaussianImageFilter.} // \label{fig:LaplacianRecursiveGaussianImageFilterInputOutput} // \end{figure} // // Figure~\ref{fig:LaplacianRecursiveGaussianImageFilterInputOutput} illustrates the // effect of this filter using // $\sigma$ values of $3$ (left) and $5$ (right). The figure shows how the // attenuation of noise can be regulated by selecting the appropriate // standard deviation. This type of scale-tunable filter is suitable for // performing scale-space analysis. // // Software Guide : EndLatex // Rescale float outputs to png for inclusion in the Software guide // if (argc > 4) { typedef unsigned char CharPixelType; typedef otb::Image CharImageType; typedef itk::RescaleIntensityImageFilter RescaleFilterType; RescaleFilterType::Pointer rescale = RescaleFilterType::New(); rescale->SetInput(addFilter->GetOutput()); rescale->SetOutputMinimum(0); rescale->SetOutputMaximum(255); typedef otb::ImageFileWriter CharWriterType; CharWriterType::Pointer charWriter = CharWriterType::New(); charWriter->SetFileName(argv[4]); charWriter->SetInput(rescale->GetOutput()); charWriter->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/LaplacianRecursiveGaussianImageFilter2.cxx000066400000000000000000000200441301006202600273050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {LaplacianRecursiveGaussianImageFilter2output3.hdr} // 3 // OUTPUTS: {LaplacianRecursiveGaussianImageFilter2Output3.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {LaplacianRecursiveGaussianImageFilter2output5.hdr} // 5 // OUTPUTS: {LaplacianRecursiveGaussianImageFilter2Output5.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The previous exampled showed how to use the // \doxygen{itk}{RecursiveGaussianImageFilter} for computing the equivalent of a // Laplacian of an image after smoothing with a Gaussian. The elements used // in this previous example have been packaged together in the // \doxygen{itk}{LaplacianRecursiveGaussianImageFilter} in order to simplify its // usage. This current example shows how to use this convenience filter for // achieving the same results as the previous example. // // \index{itk::LaplacianRecursiveGaussianImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginLatex // // The first step required to use this filter is to include its header file. // // \index{itk::LaplacianRecursiveGaussianImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkLaplacianRecursiveGaussianImageFilter.h" // Software Guide : EndCodeSnippet #include "itkRescaleIntensityImageFilter.h" int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile sigma [RescaledOutputImageFile] " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Types should be selected on the desired input and output pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef float OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input and output image types are instantiated using the pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The filter type is now instantiated using both the input image and the // output image types. // // \index{itk::RecursiveGaussianImageFilter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::LaplacianRecursiveGaussianImageFilter< InputImageType, OutputImageType> FilterType; // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // This filter packages all the components illustrated in the previous // example. The filter is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // \index{itk::LaplacianRecursiveGaussianImageFilter!New()} // \index{itk::LaplacianRecursiveGaussianImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::Pointer laplacian = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The option for normalizing across scale space can also be selected in this filter. // // \index{LaplacianRecursiveGaussianImageFilter!SetNormalizeAcrossScale()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet laplacian->SetNormalizeAcrossScale(false); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input image can be obtained from the output of another // filter. Here, an image reader is used as the source. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet laplacian->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is now time to select the $\sigma$ of the Gaussian used to // smooth the data. Note that $\sigma$ must be passed to both // filters and that sigma is considered to be in the units of the // image spacing. That is, at the moment of applying the smoothing // process, the filter will take into account the spacing values // defined in the image. // // \index{itk::LaplacianRecursiveGaussianImageFilter!SetSigma()} // \index{SetSigma()!itk::LaplacianRecursiveGaussianImageFilter} // // Software Guide : EndLatex const double sigma = atof(argv[3]); // Software Guide : BeginCodeSnippet laplacian->SetSigma(sigma); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally the pipeline is executed by invoking the \code{Update()} method. // // \index{itk::LaplacianRecursiveGaussianImageFilter!Update()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { laplacian->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // The image can also be saved into a file, by using the ImageFileWriter. // typedef float WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(laplacian->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{LaplacianRecursiveGaussianImageFilter2Output3.eps} // \includegraphics[width=0.44\textwidth]{LaplacianRecursiveGaussianImageFilter2Output5.eps} // \itkcaption[Output of the LaplacianRecursiveGaussianImageFilter.]{Effect of the // LaplacianRecursiveGaussianImageFilter.} // \label{fig:RecursiveGaussianImageFilter2InputOutput} // \end{figure} // // Figure~\ref{fig:RecursiveGaussianImageFilter2InputOutput} illustrates the // effect of this filter using // $\sigma$ values of $3$ (left) and $5$ (right). The figure shows how the // attenuation of noise can be regulated by selecting the appropriate // standard deviation. This type of scale-tunable filter is suitable for // performing scale-space analysis. // // Software Guide : EndLatex // Rescale float outputs to png for inclusion in the Software guide // if (argc > 4) { typedef unsigned char CharPixelType; typedef otb::Image CharImageType; typedef itk::RescaleIntensityImageFilter RescaleFilterType; RescaleFilterType::Pointer rescale = RescaleFilterType::New(); rescale->SetInput(laplacian->GetOutput()); rescale->SetOutputMinimum(0); rescale->SetOutputMaximum(255); typedef otb::ImageFileWriter CharWriterType; CharWriterType::Pointer charWriter = CharWriterType::New(); charWriter->SetFileName(argv[4]); charWriter->SetInput(rescale->GetOutput()); charWriter->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/MathematicalMorphologyBinaryFilters.cxx000066400000000000000000000236211301006202600270160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {MathematicalMorphologyBinaryErosionOutput.png} // OUTPUTS: {MathematicalMorphologyBinaryDilationOutput.png} // 150 180 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following section illustrates the use of filters that perform basic // mathematical morphology operations on binary images. The // \doxygen{itk}{BinaryErodeImageFilter} and \doxygen{itk}{BinaryDilateImageFilter} are // described here. The filter names clearly specify the type of image on which // they operate. The header files required to construct a simple example of // the use of the mathematical morphology filters are included below. // // \index{itk::BinaryDilateImageFilter!header} // \index{itk::BinaryErodeImageFilter!header} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkBinaryErodeImageFilter.h" #include "itkBinaryDilateImageFilter.h" #include "itkBinaryBallStructuringElement.h" // Software Guide : EndCodeSnippet #include "itkBinaryThresholdImageFilter.h" int main(int argc, char * argv[]) { if (argc < 6) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile "; std::cerr << " outputImageFileErosion outputImageFileDilation"; std::cerr << " lowerThreshold upperThreshold " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The following code defines the input and output pixel types and their // associated image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryThresholdImageFilter ThresholdFilterType; // Software Guide : BeginLatex // // Mathematical morphology operations are implemented by applying an // operator over the neighborhood of each input pixel. The combination of // the rule and the neighborhood is known as \emph{structuring // element}. Although some rules have become de facto standards for image // processing, there is a good deal of freedom as to what kind of // algorithmic rule should be applied to the neighborhood. The // implementation in ITK follows the typical rule of minimum for // erosion and maximum for dilation. // // The structuring element is implemented as a NeighborhoodOperator. In // particular, the default structuring element is the // \doxygen{itk}{BinaryBallStructuringElement} class. This class is instantiated // using the pixel type and dimension of the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryBallStructuringElement< InputPixelType, Dimension> StructuringElementType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The structuring element type is then used along with the input and output // image types for instantiating the type of the filters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryErodeImageFilter< InputImageType, OutputImageType, StructuringElementType> ErodeFilterType; typedef itk::BinaryDilateImageFilter< InputImageType, OutputImageType, StructuringElementType> DilateFilterType; // Software Guide : EndCodeSnippet // Creation of Reader and Writer filters ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writerDilation = WriterType::New(); WriterType::Pointer writerErosion = WriterType::New(); ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New(); // Software Guide : BeginLatex // // The filters can now be created by invoking the \code{New()} method and // assigning the result to \doxygen{itk}{SmartPointer}s. // // \index{itk::BinaryDilateImageFilter!New()} // \index{itk::BinaryErodeImageFilter!New()} // \index{itk::BinaryDilateImageFilter!Pointer} // \index{itk::BinaryErodeImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ErodeFilterType::Pointer binaryErode = ErodeFilterType::New(); DilateFilterType::Pointer binaryDilate = DilateFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The structuring element is not a reference counted class. Thus it is // created as a C++ stack object instead of using \code{New()} and // SmartPointers. The radius of the neighborhood associated with the // structuring element is defined with the \code{SetRadius()} method and the // \code{CreateStructuringElement()} method is invoked in order to // initialize the operator. The resulting structuring element is passed to // the mathematical morphology filter through the \code{SetKernel()} method, // as illustrated below. // // \index{itk::BinaryBallStructuringElement!SetRadius()} // \index{itk::BinaryBallStructuringElement!CreateStructuringElement()} // \index{itk::BinaryDilateImageFilter!SetKernel()} // \index{itk::BinaryErodeImageFilter!SetKernel()} // \index{SetRadius()!itk::BinaryBallStructuringElement} // \index{SetKernel()!itk::BinaryDilateImageFilter} // \index{SetKernel()!itk::BinaryErodeImageFilter} // \index{SetRadius()!itk::BinaryBallStructuringElement} // \index{CreateStructuringElement()!itk::BinaryBallStructuringElement} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet StructuringElementType structuringElement; structuringElement.SetRadius(1); // 3x3 structuring element structuringElement.CreateStructuringElement(); binaryErode->SetKernel(structuringElement); binaryDilate->SetKernel(structuringElement); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); writerErosion->SetFileName(argv[2]); writerDilation->SetFileName(argv[3]); // Software Guide : BeginLatex // // A binary image is provided as input to the filters. This image might be, // for example, the output of a binary threshold image filter. // // Software Guide : EndLatex const InputPixelType lowerThreshold = atoi(argv[4]); const InputPixelType upperThreshold = atoi(argv[5]); // Software Guide : BeginCodeSnippet thresholder->SetInput(reader->GetOutput()); InputPixelType background = 0; InputPixelType foreground = 255; thresholder->SetOutsideValue(background); thresholder->SetInsideValue(foreground); thresholder->SetLowerThreshold(lowerThreshold); thresholder->SetUpperThreshold(upperThreshold); // Software Guide : EndCodeSnippet // Software Guide : BeginCodeSnippet binaryErode->SetInput(thresholder->GetOutput()); binaryDilate->SetInput(thresholder->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The values that correspond to ``objects'' in the binary image are // specified with the methods \code{SetErodeValue()} and // \code{SetDilateValue()}. The value passed to these methods will be // considered the value over which the dilation and erosion rules will // apply. // // \index{itk::BinaryDilateImageFilter!SetDilateValue()} // \index{itk::BinaryErodeImageFilter!SetErodeValue()} // \index{SetDilateValue()!itk::BinaryDilateImageFilter} // \index{SetErodeValue()!itk::BinaryErodeImageFilter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet binaryErode->SetErodeValue(foreground); binaryDilate->SetDilateValue(foreground); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter is executed by invoking its \code{Update()} method, or by // updating any downstream filter, like, for example, an image writer. // // \index{itk::BinaryDilateImageFilter!Update()} // \index{itk::BinaryErodeImageFilter!Update()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writerDilation->SetInput(binaryDilate->GetOutput()); writerDilation->Update(); // Software Guide : EndCodeSnippet writerErosion->SetInput(binaryErode->GetOutput()); writerErosion->Update(); // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{BinaryThresholdImageFilterOutput.eps} // \includegraphics[width=0.32\textwidth]{MathematicalMorphologyBinaryErosionOutput.eps} // \includegraphics[width=0.32\textwidth]{MathematicalMorphologyBinaryDilationOutput.eps} // \itkcaption[Effect of erosion and dilation in a binary image.]{Effect of // erosion and dilation in a binary image.} // \label{fig:MathematicalMorphologyBinaryFilters} // \end{figure} // // Figure \ref{fig:MathematicalMorphologyBinaryFilters} illustrates the // effect of the erosion and dilation filters. The figure shows how these operations can be used to remove // spurious details from segmented images. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/MathematicalMorphologyGrayscaleFilters.cxx000066400000000000000000000207501301006202600275040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {MathematicalMorphologyGrayscaleErosionOutput.png} // OUTPUTS: {MathematicalMorphologyGrayscaleDilationOutput.png} // 150 180 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following section illustrates the use of filters for performing basic // mathematical morphology operations on grayscale images. The // \doxygen{itk}{GrayscaleErodeImageFilter} and // \doxygen{itk}{GrayscaleDilateImageFilter} are covered in this example. The // filter names clearly specify the type of image on which they operate. // The header files required for a simple example of the use of // grayscale mathematical morphology filters are presented below. // // \index{itk::GrayscaleDilateImageFilter!header} // \index{itk::GrayscaleErodeImageFilter!header} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkGrayscaleErodeImageFilter.h" #include "itkGrayscaleDilateImageFilter.h" #include "itkBinaryBallStructuringElement.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile "; std::cerr << " outputImageFileErosion outputImageFileDilation" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The following code defines the input and output pixel types and their // associated image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : BeginLatex // // Mathematical morphology operations are based on the application of an // operator over a neighborhood of each input pixel. The combination of // the rule and the neighborhood is known as \emph{structuring // element}. Although some rules have become the de facto standard in image // processing there is a good deal of freedom as to what kind of // algorithmic rule should be applied on the neighborhood. The // implementation in ITK follows the typical rule of minimum for // erosion and maximum for dilation. // // The structuring element is implemented as a // \doxygen{itk}{NeighborhoodOperator}. In particular, the default // structuring element is the // \doxygen{itk}{BinaryBallStructuringElement} class. This class is // instantiated using the pixel type and dimension of the input // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryBallStructuringElement< InputPixelType, Dimension> StructuringElementType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The structuring element type is then used along with the input and output // image types for instantiating the type of the filters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GrayscaleErodeImageFilter< InputImageType, OutputImageType, StructuringElementType> ErodeFilterType; typedef itk::GrayscaleDilateImageFilter< InputImageType, OutputImageType, StructuringElementType> DilateFilterType; // Software Guide : EndCodeSnippet // Creation of Reader and Writer filters ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writerDilation = WriterType::New(); WriterType::Pointer writerErosion = WriterType::New(); // Software Guide : BeginLatex // // The filters can now be created by invoking the \code{New()} method and // assigning the result to SmartPointers. // // \index{itk::GrayscaleDilateImageFilter!New()} // \index{itk::GrayscaleErodeImageFilter!New()} // \index{itk::GrayscaleDilateImageFilter!Pointer} // \index{itk::GrayscaleErodeImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ErodeFilterType::Pointer grayscaleErode = ErodeFilterType::New(); DilateFilterType::Pointer grayscaleDilate = DilateFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The structuring element is not a reference counted class. Thus it is // created as a C++ stack object instead of using \code{New()} and // SmartPointers. The radius of the neighborhood associated with the // structuring element is defined with the \code{SetRadius()} method and the // \code{CreateStructuringElement()} method is invoked in order to initialize the // operator. The resulting structuring element is passed to the // mathematical morphology filter through the \code{SetKernel()} method, as // illustrated below. // // \index{itk::BinaryBallStructuringElement!SetRadius()} // \index{itk::BinaryBallStructuringElement!CreateStructuringElement()} // \index{itk::GrayscaleDilateImageFilter!SetKernel()} // \index{itk::GrayscaleErodeImageFilter!SetKernel()} // \index{SetRadius()!itk::BinaryBallStructuringElement} // \index{SetKernel()!itk::GrayscaleDilateImageFilter} // \index{SetKernel()!itk::GrayscaleErodeImageFilter} // \index{SetRadius()!itk::BinaryBallStructuringElement} // \index{CreateStructuringElement()!itk::BinaryBallStructuringElement} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet StructuringElementType structuringElement; structuringElement.SetRadius(1); // 3x3 structuring element structuringElement.CreateStructuringElement(); grayscaleErode->SetKernel(structuringElement); grayscaleDilate->SetKernel(structuringElement); // Software Guide : EndCodeSnippet reader->SetFileName(argv[1]); writerErosion->SetFileName(argv[2]); writerDilation->SetFileName(argv[3]); // Software Guide : BeginLatex // // A grayscale image is provided as input to the filters. This // image might be, for example, the output of a reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet grayscaleErode->SetInput(reader->GetOutput()); grayscaleDilate->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter is executed by invoking its \code{Update()} method, or by // updating any downstream filter, like, for example, an image writer. // // \index{itk::GrayscaleDilateImageFilter!Update()} // \index{itk::GrayscaleErodeImageFilter!Update()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writerDilation->SetInput(grayscaleDilate->GetOutput()); writerDilation->Update(); // Software Guide : EndCodeSnippet writerErosion->SetInput(grayscaleErode->GetOutput()); writerErosion->Update(); // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.32\textwidth]{MathematicalMorphologyGrayscaleErosionOutput.eps} // \includegraphics[width=0.32\textwidth]{MathematicalMorphologyGrayscaleDilationOutput.eps} // \itkcaption[Effect of erosion and dilation in a grayscale image.]{Effect of // erosion and dilation in a grayscale image.} // \label{fig:MathematicalMorphologyGrayscaleFilters} // \end{figure} // // Figure \ref{fig:MathematicalMorphologyGrayscaleFilters} // illustrates the effect of the erosion and dilation filters. The // figure shows how these operations can be used to remove spurious // details from segmented images. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/MeanImageFilter.cxx000066400000000000000000000144151301006202600226410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {MeanImageFilterOutput.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The \doxygen{itk}{MeanImageFilter} is commonly used for noise // reduction. The filter computes the value of each output pixel by // finding the statistical mean of the neighborhood of the // corresponding input pixel. The following figure illustrates the // local effect of the MeanImageFilter. The statistical mean of the // neighborhood on the left is passed as the output value associated // with the pixel at the center of the neighborhood. // // \begin{center} // \begin{picture}(200, 46) // \put( 5.0, 0.0 ){\framebox(30.0, 15.0){25}} // \put( 35.0, 0.0 ){\framebox(30.0, 15.0){30}} // \put( 65.0, 0.0 ){\framebox(30.0, 15.0){32}} // \put( 5.0, 15.0 ){\framebox(30.0, 15.0){27}} // \put( 35.0, 15.0 ){\framebox(30.0, 15.0){25}} // \put( 65.0, 15.0 ){\framebox(30.0, 15.0){29}} // \put( 5.0, 30.0 ){\framebox(30.0, 15.0){28}} // \put( 35.0, 30.0 ){\framebox(30.0, 15.0){26}} // \put( 65.0, 30.0 ){\framebox(30.0, 15.0){50}} // \put( 100.0, 22.0 ){\vector(1, 0){20.0}} // \put( 125.0, 15.0 ){\framebox(34.0, 15.0){30.22}} // \put( 160.0, 22.0 ){\vector(1, 0){20.0}} // \put( 185.0, 15.0 ){\framebox(30.0, 15.0){30}} // \end{picture} // \end{center} // // Note that this algorithm is sensitive to the presence of outliers in the // neighborhood. This filter will work on images of any dimension thanks to // the internal use of \doxygen{itk}{SmartNeighborhoodIterator} and // \doxygen{itk}{NeighborhoodOperator}. The size of the neighborhood over which // the mean is computed can be set by the user. // // \index{itk::MeanImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginLatex // // The header file corresponding to this filter should be included first. // // \index{itk::MeanImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMeanImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then the pixel types for input and output image must be defined and, with // them, the image types can be instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // Using the image types it is now possible to instantiate the filter type // and create the filter object. // // \index{itk::MeanImageFilter!instantiation} // \index{itk::MeanImageFilter!New()} // \index{itk::MeanImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MeanImageFilter< InputImageType, OutputImageType> FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The size of the neighborhood is defined along every dimension by // passing a \code{SizeType} object with the corresponding values. The // value on each dimension is used as the semi-size of a rectangular // box. For example, in $2D$ a size of \(1, 2\) will result in a $3 \times // 5$ neighborhood. // // \index{itk::MeanImageFilter!Radius} // \index{itk::MeanImageFilter!Neighborhood} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputImageType::SizeType indexRadius; indexRadius[0] = 1; // radius along x indexRadius[1] = 1; // radius along y filter->SetRadius(indexRadius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input to the filter can be taken from any other filter, for example // a reader. The output can be passed down the pipeline to other filters, // for example, a writer. An update call on any downstream filter will // trigger the execution of the mean filter. // // \index{itk::MeanImageFilter!SetInput()} // \index{itk::MeanImageFilter!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{MeanImageFilterOutput.eps} // \itkcaption[Effect of the MedianImageFilter]{Effect of the MeanImageFilter.} // \label{fig:MeanImageFilterOutput} // \end{figure} // // Figure \ref{fig:MeanImageFilterOutput} illustrates the effect of this // filter using neighborhood radii of // \(1, 1\) which corresponds to a $ 3 \times 3 $ classical neighborhood. // It can be seen from this picture that edges are rapidly degraded by the // diffusion of intensity values among neighbors. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/MedianImageFilter.cxx000066400000000000000000000143461301006202600231610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {MedianImageFilterOutput.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The \doxygen{itk}{MedianImageFilter} is commonly used as a robust approach for // noise reduction. This filter is particularly efficient against // \emph{salt-and-pepper} noise. In other words, it is robust to the presence // of gray-level outliers. MedianImageFilter computes the value of each output // pixel as the statistical median of the neighborhood of values around the // corresponding input pixel. The following figure illustrates the local // effect of this filter. The statistical median of the // neighborhood on the left is passed as the output value associated with the // pixel at the center of the neighborhood. // // // \begin{center} // \begin{picture}(200, 46) // \put( 5.0, 0.0 ){\framebox(30.0, 15.0){25}} // \put( 35.0, 0.0 ){\framebox(30.0, 15.0){30}} // \put( 65.0, 0.0 ){\framebox(30.0, 15.0){32}} // \put( 5.0, 15.0 ){\framebox(30.0, 15.0){27}} // \put( 35.0, 15.0 ){\framebox(30.0, 15.0){25}} // \put( 65.0, 15.0 ){\framebox(30.0, 15.0){29}} // \put( 5.0, 30.0 ){\framebox(30.0, 15.0){28}} // \put( 35.0, 30.0 ){\framebox(30.0, 15.0){26}} // \put( 65.0, 30.0 ){\framebox(30.0, 15.0){50}} // \put( 100.0, 22.0 ){\vector(1, 0){20.0}} // \put( 125.0, 15.0 ){\framebox(30.0, 15.0){28}} // \end{picture} // \end{center} // // // This filter will work on images of any dimension thanks to the internal // use of \doxygen{itk}{NeighborhoodIterator} and // \doxygen{itk}{NeighborhoodOperator}. The size of the neighborhood over which // the median is computed can be set by the user. // // \index{itk::MedianImageFilter} // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginLatex // // The header file corresponding to this filter should be included first. // // \index{itk::MedianImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMedianImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then the pixel and image types of the input and output must be defined. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // Using the image types, it is now possible to define the filter type // and create the filter object. // // \index{itk::MedianImageFilter!instantiation} // \index{itk::MedianImageFilter!New()} // \index{itk::MedianImageFilter!Pointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MedianImageFilter< InputImageType, OutputImageType> FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The size of the neighborhood is defined along every dimension by // passing a \code{SizeType} object with the corresponding values. The // value on each dimension is used as the semi-size of a rectangular // box. For example, in $2D$ a size of \(1, 2\) will result in a $3 \times // 5$ neighborhood. // // \index{itk::MedianImageFilter!Radius} // \index{itk::MedianImageFilter!Neighborhood} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputImageType::SizeType indexRadius; indexRadius[0] = 1; // radius along x indexRadius[1] = 1; // radius along y filter->SetRadius(indexRadius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input to the filter can be taken from any other filter, for example // a reader. The output can be passed down the pipeline to other filters, // for example, a writer. An update call on any downstream filter will // trigger the execution of the median filter. // // \index{itk::MedianImageFilter!SetInput()} // \index{itk::MedianImageFilter!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{MedianImageFilterOutput.eps} // \itkcaption[Effect of the Median filter.]{Effect of the MedianImageFilter.} // \label{fig:MedianImageFilterOutput} // \end{figure} // // Figure \ref{fig:MedianImageFilterOutput} illustrates the effect of the MedianImageFilter // filter a neighborhood radius of // \(1, 1\), which corresponds to a $ 3 \times 3 $ classical neighborhood. // The filtered image demonstrates the moderate tendency of the median // filter to preserve edges. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/RasterizationExample.cxx000066400000000000000000000202761301006202600240240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {w002n44e.shp} // OUTPUTS: {ArcachonRasterizedCoastline.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The \doxygen{otb}{VectorDataToMapFilter} allows performing // rasterization of a given vector data as a binary mask. This example // will demonstrate how to use this filter to perform rasterization of // the SRTM water body masks available here: // \url{http://dds.cr.usgs.gov/srtm/version2_1/SWBD/}. // // First step to use this filter is to include the appropriate headers: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbVectorData.h" #include "otbImage.h" #include "otbVectorDataToMapFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileWriter.h" #include "otbVectorDataProjectionFilter.h" #include "itkRGBAPixel.h" #include "itkChangeLabelImageFilter.h" #include "otbVectorDataFileReader.h" int main(int argc, char * argv[]) { // Software Guide : BeginLatex // // Then, we need to define the appropriate VectorData and Image // type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::VectorData<> VectorDataType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Using these typedefs, we can define and instantiate the // \doxygen{otb}{VectorDataToMapFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataToMapFilter VectorDataToMapFilterType; VectorDataToMapFilterType::Pointer vectorDataRendering = VectorDataToMapFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will also define a \doxygen{otb}{VectorDataFileReader} to read // the VectorData, as well as a // \doxygen{otb}{VectorDataProjectionFilter} to reproject our data // in a given map projection. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet std::string projectionRefWkt = "PROJCS[\"WGS 84 / UTM zone 30N\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.01745329251994328, AUTHORITY[\"EPSG\",\"9122\"]], AUTHORITY[\"EPSG\",\"4326\"]], UNIT[\"metre\", 1, AUTHORITY[\"EPSG\",\"9001\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", -3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], AUTHORITY[\"EPSG\",\"32630\"], AXIS[\"Easting\", EAST], AXIS[\"Northing\", NORTH]]"; // Software Guide : BeginLatex // // Next step is to specify the map projection in which to reproject // our vector. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet projection->SetOutputProjectionRef(projectionRefWkt); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the input vector can be pretty big, we will perform an // extract of the region of interest using the // \doxygen{otb}{VectorDataExtractROI}. // // The first step is to define the region of interest. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::RemoteSensingRegion RegionType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; origin[0] = 633602; //UL easting origin[1] = 4961679; //UL northing ImageType::SpacingType spacing; spacing[0] = 56; spacing[1] = -56; RegionType region; RegionType::SizeType sizeInUnit; sizeInUnit[0] = size[0] * spacing[0]; sizeInUnit[1] = size[1] * spacing[1]; region.SetSize(sizeInUnit); region.SetOrigin(origin); region.SetRegionProjection(projectionRefWkt); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we define and set-up the // \doxygen{otb}{VectorDataExtractROI} filter using the region. // // Software Guide : EndLatex // Software Guide :: BeginCodeSnippet typedef otb::VectorDataExtractROI ExtractROIType; ExtractROIType::Pointer extractROI = ExtractROIType::New(); extractROI->SetRegion(region); extractROI->SetInput(projection->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we can plug the the ROI filter to the // \doxygen{otb}{VectorDataToMapFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet vectorDataRendering->SetInput(extractROI->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since we are interested in binary rendering, we need to set the // appropriate rendering style. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet vectorDataRendering->SetRenderingStyleType(VectorDataToMapFilterType::Binary); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The rendering filter will return a binary image with label 0 when // outside the rasterized vector features and 255 when inside. To // get a fancier rendering we will substitute a blue color to the // foreground value and green to the background value. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RGBAPixel RGBAPixelType; typedef otb::Image RGBAImageType; typedef itk::ChangeLabelImageFilter ChangeLabelImageFilterType; ChangeLabelImageFilterType::Pointer changeLabelFilter = ChangeLabelImageFilterType::New(); RGBAPixelType green, blue; green.SetAlpha(255); green.SetGreen(255); blue.SetAlpha(255); blue.SetBlue(255); changeLabelFilter->SetChange(0, blue); changeLabelFilter->SetChange(255, green); changeLabelFilter->SetInput(vectorDataRendering->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Last step is to write the image to the disk using a // \doxygen{otb}{ImageFileWriter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(changeLabelFilter->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.4\textwidth]{ArcachonRasterizedCoastline.eps} // \itkcaption[Rasterized SRTM water bodies near Arcachon, France.]{Rasterized SRTM water bodies near Arcachon, France.} // \label{fig:RasterizationFilterOutput} // \end{figure} // // Figure \ref{fig:RasterizationFilterOutput} illustrates the use // of the rasterization filter on SRTM water bodies mask near // Arcachon in France. Ocean appears in blue while land appears in green. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/SecondDerivativeRecursiveGaussianImageFilter.cxx000066400000000000000000000117171301006202600306040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how to compute second derivatives of // an image using the \doxygen{itk}{RecursiveGaussianImageFilter}. // // In this example, all the second derivatives are computed independently in // the same way as if they were intended to be used for building the Hessian // matrix of the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkRecursiveGaussianImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkImageDuplicator.h" #include "otbImage.h" #include int main(int argc, char * argv[]) { if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImage outputPrefix [sigma] " << std::endl; return EXIT_FAILURE; } typedef float PixelType; typedef float OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::ImageDuplicator DuplicatorType; typedef itk::RecursiveGaussianImageFilter< ImageType, ImageType> FilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); DuplicatorType::Pointer duplicator = DuplicatorType::New(); reader->SetFileName(argv[1]); std::string outputPrefix = argv[2]; std::string outputFileName; try { reader->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Problem reading the input file" << std::endl; std::cerr << excp << std::endl; return EXIT_FAILURE; } FilterType::Pointer ga = FilterType::New(); FilterType::Pointer gb = FilterType::New(); FilterType::Pointer gc = FilterType::New(); ga->SetDirection(0); gb->SetDirection(1); gc->SetDirection(2); if (argc > 3) { const float sigma = atof(argv[3]); ga->SetSigma(sigma); gb->SetSigma(sigma); gc->SetSigma(sigma); } ga->SetZeroOrder(); gb->SetZeroOrder(); gc->SetSecondOrder(); ImageType::Pointer inputImage = reader->GetOutput(); ga->SetInput(inputImage); gb->SetInput(ga->GetOutput()); gc->SetInput(gb->GetOutput()); duplicator->SetInputImage(gc->GetOutput()); gc->Update(); duplicator->Update(); ImageType::Pointer Izz = duplicator->GetOutput(); writer->SetInput(Izz); outputFileName = outputPrefix + "-Izz.hdr"; writer->SetFileName(outputFileName.c_str()); writer->Update(); gc->SetDirection(1); // gc now works along Y gb->SetDirection(2); // gb now works along Z gc->Update(); duplicator->Update(); ImageType::Pointer Iyy = duplicator->GetOutput(); writer->SetInput(Iyy); outputFileName = outputPrefix + "-Iyy.hdr"; writer->SetFileName(outputFileName.c_str()); writer->Update(); gc->SetDirection(0); // gc now works along X ga->SetDirection(1); // ga now works along Y gc->Update(); duplicator->Update(); ImageType::Pointer Ixx = duplicator->GetOutput(); writer->SetInput(Ixx); outputFileName = outputPrefix + "-Ixx.hdr"; writer->SetFileName(outputFileName.c_str()); writer->Update(); ga->SetDirection(0); gb->SetDirection(1); gc->SetDirection(2); ga->SetZeroOrder(); gb->SetFirstOrder(); gc->SetFirstOrder(); gc->Update(); duplicator->Update(); ImageType::Pointer Iyz = duplicator->GetOutput(); writer->SetInput(Iyz); outputFileName = outputPrefix + "-Iyz.hdr"; writer->SetFileName(outputFileName.c_str()); writer->Update(); ga->SetDirection(1); gb->SetDirection(0); gc->SetDirection(2); ga->SetZeroOrder(); gb->SetFirstOrder(); gc->SetFirstOrder(); gc->Update(); duplicator->Update(); ImageType::Pointer Ixz = duplicator->GetOutput(); writer->SetInput(Ixz); outputFileName = outputPrefix + "-Ixz.hdr"; writer->SetFileName(outputFileName.c_str()); writer->Update(); ga->SetDirection(2); gb->SetDirection(0); gc->SetDirection(1); ga->SetZeroOrder(); gb->SetFirstOrder(); gc->SetFirstOrder(); gc->Update(); duplicator->Update(); ImageType::Pointer Ixy = duplicator->GetOutput(); writer->SetInput(Ixy); outputFileName = outputPrefix + "-Ixy.hdr"; writer->SetFileName(outputFileName.c_str()); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/ThresholdImageFilter.cxx000066400000000000000000000231601301006202600237120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {ThresholdImageFilterOutputBelow.png} // OUTPUTS: {ThresholdImageFilterOutputAbove.png} // OUTPUTS: {ThresholdImageFilterOutputOutside.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[height=5cm]{ThresholdTransferFunctionBelow.eps} // \includegraphics[height=5cm]{ThresholdImageFilterOutputBelow.eps} // \itkcaption[ThresholdImageFilter using the threshold-below // mode.]{ThresholdImageFilter using the threshold-below mode.} // \label{fig:ThresholdTransferFunctionBelow} // \end{figure} // // \begin{figure} // \center // \includegraphics[height=5cm]{ThresholdTransferFunctionAbove.eps} // \includegraphics[height=5cm]{ThresholdImageFilterOutputAbove.eps} // \itkcaption[ThresholdImageFilter using the threshold-above // mode]{ThresholdImageFilter using the threshold-above mode.} // \label{fig:ThresholdTransferFunctionAbove} // \end{figure} // // \begin{figure} // \center // \includegraphics[height=5cm]{ThresholdTransferFunctionOutside.eps} // \includegraphics[height=5cm]{ThresholdImageFilterOutputOutside.eps} // \itkcaption[ThresholdImageFilter using the threshold-outside // mode]{ThresholdImageFilter using the threshold-outside mode.} // \label{fig:ThresholdTransferFunctionOutside} // \end{figure} // // This example illustrates the use of the \doxygen{itk}{ThresholdImageFilter}. // This filter can be used to transform the intensity levels of an image in // three different ways. // // \begin{itemize} // // \item First, the user can define a single threshold. Any pixels with values // below this threshold will be replaced by a user defined value, called here the // \code{OutsideValue}. Pixels with values above the threshold remain // unchanged. This type of thresholding is illustrated in // Figure~\ref{fig:ThresholdTransferFunctionBelow}. // // \item Second, the user can define a particular threshold such that all the // pixels with values above the threshold will be replaced by the // \code{OutsideValue}. Pixels with values below the threshold remain // unchanged. This is illustrated in Figure~\ref{fig:ThresholdTransferFunctionAbove}. // // \item Third, the user can provide two thresholds. All the pixels with // intensity values inside the range defined by the two thresholds will remain // unchanged. Pixels with values outside this range will be assigned to the // \code{OutsideValue}. This is illustrated in // Figure~\ref{fig:ThresholdTransferFunctionOutside}. // // \end{itemize} // // The following methods choose among the three operating modes of the filter. // // \begin{itemize} // \item \texttt{ThresholdBelow()} // \item \texttt{ThresholdAbove()} // \item \texttt{ThresholdOutside()} // \end{itemize} // // \index{itk::ThresholdImageFilter!Instantiation} // \index{itk::ThresholdImageFilter!Header} // \index{itk::ThresholdImageFilter!ThresholdAbove()} // \index{itk::ThresholdImageFilter!ThresholdBelow()} // \index{itk::ThresholdImageFilter!ThresholdOutside()} // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkThresholdImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc < 5) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImageFile1 outputImageFile2 outputImageFile3" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. This filter is // templated over a single image type because the algorithm only modifies // pixel values outside the specified range, passing the rest through // unchanged. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image is defined using the pixel type and the dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter can be instantiated using the image type defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ThresholdImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // \doxygen{itk}{ThresholdImageFilter}. // // \index{itk::ThresholdImageFilter!SetInput()} // \index{itk::FileImageReader!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{SetOutsideValue()} defines the intensity value to be // assigned to those pixels whose intensities are outside the range defined // by the lower and upper thresholds. // // \index{itk::ThresholdImageFilter!SetOutsideValue()} // \index{SetOutsideValue()!itk::ThresholdImageFilter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetOutsideValue(0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{ThresholdBelow()} defines the intensity value below // which pixels of the input image will be changed to the \code{OutsideValue}. // // \index{itk::ThresholdImageFilter!ThresholdBelow()} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->ThresholdBelow(40); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter is executed by invoking the \code{Update()} method. If the // filter is part of a larger image processing pipeline, calling // \code{Update()} on a downstream filter will also trigger update of this // filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[2]); writer->Update(); // Software Guide : BeginLatex // // The output of this example is shown in // Figure~\ref{fig:ThresholdTransferFunctionBelow}. The second operating mode of // the filter is now enabled by calling the method // \code{ThresholdAbove()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->ThresholdAbove(100); filter->SetOutsideValue(255); filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[3]); writer->Update(); // Software Guide : BeginLatex // // Updating the filter with this new setting produces the output shown in // Figure~\ref{fig:ThresholdTransferFunctionAbove}. The third operating // mode of the filter is enabled by calling \code{ThresholdOutside()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->ThresholdOutside(40, 100); filter->SetOutsideValue(0); filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[4]); writer->Update(); // Software Guide : BeginLatex // // The output of this third, ``band-pass'' thresholding mode is shown in // Figure~\ref{fig:ThresholdTransferFunctionOutside}. // // The examples in this // section also illustrate the limitations of the thresholding filter for performing // segmentation by itself. These limitations are particularly noticeable // in noisy images and in images lacking spatial uniformity. // // \relatedClasses // \begin{itemize} // \item \doxygen{itk}{BinaryThresholdImageFilter} // \end{itemize} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Filtering/test/000077500000000000000000000000001301006202600200765ustar00rootroot00000000000000OTB-release-5.8/Examples/Filtering/test/CMakeLists.txt000066400000000000000000000174131301006202600226440ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Filtering) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- MathematicalMorphologyBinaryFiltersTest---------- otb_add_test(NAME fiTeMathematicalMorphologyBinaryFiltersTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/MathematicalMorphologyBinaryErosionOutput.png ${TEMP}/MathematicalMorphologyBinaryErosionOutput.png ${BASELINE}/MathematicalMorphologyBinaryDilationOutput.png ${TEMP}/MathematicalMorphologyBinaryDilationOutput.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/MathematicalMorphologyBinaryErosionOutput.png ${TEMP}/MathematicalMorphologyBinaryDilationOutput.png 150 180 ) # ------- DanielssonDistanceMapImageFilterTest---------- otb_add_test(NAME fiTeDanielssonDistanceMapImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/DanielssonDistanceMapImageFilterOutput1.png ${TEMP}/DanielssonDistanceMapImageFilterOutput1.png ${BASELINE}/DanielssonDistanceMapImageFilterOutput2.png ${TEMP}/DanielssonDistanceMapImageFilterOutput2.png Execute $ ${INPUTDATA}/FivePoints.png ${TEMP}/DanielssonDistanceMapImageFilterOutput1.png ${TEMP}/DanielssonDistanceMapImageFilterOutput2.png ) # ------- MeanImageFilterTest---------- otb_add_test(NAME fiTeMeanImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/MeanImageFilterOutput.png ${TEMP}/MeanImageFilterOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/MeanImageFilterOutput.png ) # ------- ThresholdImageFilterTest---------- otb_add_test(NAME fiTeThresholdImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 3 ${BASELINE}/ThresholdImageFilterOutputBelow.png ${TEMP}/ThresholdImageFilterOutputBelow.png ${BASELINE}/ThresholdImageFilterOutputAbove.png ${TEMP}/ThresholdImageFilterOutputAbove.png ${BASELINE}/ThresholdImageFilterOutputOutside.png ${TEMP}/ThresholdImageFilterOutputOutside.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/ThresholdImageFilterOutputBelow.png ${TEMP}/ThresholdImageFilterOutputAbove.png ${TEMP}/ThresholdImageFilterOutputOutside.png ) # ------- GradientMagnitudeRecursiveGaussianImageFilterTest---------- otb_add_test(NAME fiTeGradientMagnitudeRecursiveGaussianImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/GradientMagnitudeRecursiveGaussianImageFilterOutput5.png ${TEMP}/GradientMagnitudeRecursiveGaussianImageFilterOutput5.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/GradientMagnitudeRecursiveGaussianImageFilterOutput5.png 5 ) # ------- GradientAnisotropicDiffusionImageFilterTest---------- otb_add_test(NAME fiTeGradientAnisotropicDiffusionImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/GradientAnisotropicDiffusionImageFilterOutput.png ${TEMP}/GradientAnisotropicDiffusionImageFilterOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/GradientAnisotropicDiffusionImageFilterOutput.png 5 0.125 3 ) # ------- GradientMagnitudeImageFilterTest---------- otb_add_test(NAME fiTeGradientMagnitudeImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/GradientMagnitudeImageFilterOutput.png ${TEMP}/GradientMagnitudeImageFilterOutput.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/GradientMagnitudeImageFilterOutput.png ) # ------- MathematicalMorphologyGrayscaleFiltersTest---------- otb_add_test(NAME fiTeMathematicalMorphologyGrayscaleFiltersTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/MathematicalMorphologyGrayscaleErosionOutput.png ${TEMP}/MathematicalMorphologyGrayscaleErosionOutput.png ${BASELINE}/MathematicalMorphologyGrayscaleDilationOutput.png ${TEMP}/MathematicalMorphologyGrayscaleDilationOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/MathematicalMorphologyGrayscaleErosionOutput.png ${TEMP}/MathematicalMorphologyGrayscaleDilationOutput.png 150 180 ) # ------- LaplacianRecursiveGaussianImageFilter1Test---------- otb_add_test(NAME fiTeLaplacianRecursiveGaussianImageFilter1Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/LaplacianRecursiveGaussianImageFilteroutput5.hdr ${TEMP}/LaplacianRecursiveGaussianImageFilteroutput5.hdr ${BASELINE}/LaplacianRecursiveGaussianImageFilterOutput5.png ${TEMP}/LaplacianRecursiveGaussianImageFilterOutput5.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/LaplacianRecursiveGaussianImageFilteroutput5.hdr 5 ${TEMP}/LaplacianRecursiveGaussianImageFilterOutput5.png ) # ------- LaplacianRecursiveGaussianImageFilter2Test---------- otb_add_test(NAME fiTeLaplacianRecursiveGaussianImageFilter2Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/LaplacianRecursiveGaussianImageFilter2output5.hdr ${TEMP}/LaplacianRecursiveGaussianImageFilter2output5.hdr ${BASELINE}/LaplacianRecursiveGaussianImageFilter2Output5.png ${TEMP}/LaplacianRecursiveGaussianImageFilter2Output5.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/LaplacianRecursiveGaussianImageFilter2output5.hdr 5 ${TEMP}/LaplacianRecursiveGaussianImageFilter2Output5.png ) # ------- CannyEdgeDetectionImageFilterTest---------- otb_add_test(NAME fiTeCannyEdgeDetectionImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/CannyEdgeDetectorImageFilterOutput.png ${TEMP}/CannyEdgeDetectorImageFilterOutput.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/CannyEdgeDetectorImageFilterOutput.png 2 ) # ------- DiscreteGaussianImageFilterTest---------- otb_add_test(NAME fiTeDiscreteGaussianImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/DiscreteGaussianImageFilterOutput.png ${TEMP}/DiscreteGaussianImageFilterOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/DiscreteGaussianImageFilterOutput.png 4 9 ) # ------- MedianImageFilterTest---------- otb_add_test(NAME fiTeMedianImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/MedianImageFilterOutput.png ${TEMP}/MedianImageFilterOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/MedianImageFilterOutput.png ) # ------- BinaryThresholdImageFilterTest---------- otb_add_test(NAME fiTeBinaryThresholdImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/BinaryThresholdImageFilterOutput.png ${TEMP}/BinaryThresholdImageFilterOutput.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/BinaryThresholdImageFilterOutput.png 150 180 0 255 ) # ------- DerivativeImageFilterTest---------- otb_add_test(NAME fiTeDerivativeImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/DerivativeImageFilterFloatOutput.hdr ${TEMP}/DerivativeImageFilterFloatOutput.hdr ${BASELINE}/DerivativeImageFilterOutput.png ${TEMP}/DerivativeImageFilterOutput.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/DerivativeImageFilterFloatOutput.hdr ${TEMP}/DerivativeImageFilterOutput.png 1 0 ) OTB-release-5.8/Examples/Fusion/000077500000000000000000000000001301006202600164375ustar00rootroot00000000000000OTB-release-5.8/Examples/Fusion/BayesianFusionImageFilter.cxx000066400000000000000000000311301301006202600242110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {multiSpect.tif} , {multiSpectInterp.tif}, {panchro.tif} // OUTPUTS: {BayesianFusion_0.9999.tif} , {pretty_BayesianFusion_0.9999.png} , {pretty_multiSpect_0.9999.png} , {pretty_multiSpectInterp_0.9999.png} , {pretty_panchro_0.9999.png} // 0.9999 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {multiSpect.tif} , {multiSpectInterp.tif}, {panchro.tif} // OUTPUTS: {BayesianFusion_0.5.tif} , {pretty_BayesianFusion_0.5.png} , {pretty_multiSpect_0.5.png} , {pretty_multiSpectInterp_0.5.png} , {pretty_panchro_0.5.png} // 0.5 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{otb::BayesianFusionFilter} // \index{otb::BayesianFusionFilter!header} // // The following example illustrates the use of the // \doxygen{otb}{BayesianFusionFilter}. The Bayesian data fusion // relies on the idea that variables of interest, denoted as vector $\mathbf{Z}$, // cannot be directly observed. They are linked to the observable variables // $\mathbf{Y}$ through the following error-like model. // // \begin{equation} // \mathbf{Y} = g(\mathbf{Z}) + \mathbf{E} // \end{equation} // // where g($\mathbf{Z}$) is a set of functionals and $\mathbf{E}$ is a // vector of random errors that are stochastically independent from $\mathbf{Z}$. // This algorithm uses elementary probability calculus, and several assumptions to compute // the data fusion. For more explication see Fasbender, Radoux and Bogaert's // publication \cite{JRadoux}. // Three images are used : // \begin{itemize} // \item a panchromatic image, // \item a multispectral image resampled at the panchromatic image spatial resolution, // \item a multispectral image resampled at the panchromatic image spatial resolution, // using, e.g. a cubic interpolator. // \item a float : $\lambda$, the meaning of the weight to be given to the panchromatic // image compared to the multispectral one. // \end{itemize} // // Let's look at the minimal code required to use this algorithm. First, the following header // defining the otb::BayesianFusionFilter class must be included. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbBayesianFusionFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "itkCastImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char *argv[]) { if (argc < 10) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputMultiSpectralImage inputMultiSpectralInterpolatedImage " << "inputPanchromatiqueImage outputImage outputImagePrinted " << "msPrinted msiPrinted panchroPrinted lambda" << std::endl; return 1; } // Software Guide : BeginLatex // // The image types are now defined using pixel types and particular // dimension. The panchromatic image is defined as an \doxygen{otb}{Image} // and the multispectral one as \doxygen{otb}{VectorImage}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double InternalPixelType; const unsigned int Dimension = 2; typedef otb::Image PanchroImageType; typedef otb::VectorImage MultiSpecImageType; // Software Guide : EndCodeSnippet typedef double OutputPixelType; typedef otb::VectorImage OutputImageType; // We instantiate reader and writer types // typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderVectorType::Pointer multiSpectReader = ReaderVectorType::New(); ReaderVectorType::Pointer multiSpectInterpReader = ReaderVectorType::New(); ReaderType::Pointer panchroReader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); multiSpectReader->SetFileName(argv[1]); multiSpectInterpReader->SetFileName(argv[2]); panchroReader->SetFileName(argv[3]); writer->SetFileName(argv[4]); // Software Guide : BeginLatex // // The Bayesian data fusion filter type is instantiated using the images types as // a template parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::BayesianFusionFilter BayesianFusionFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next the filter is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet BayesianFusionFilterType::Pointer bayesianFilter = BayesianFusionFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now the multi spectral image, the interpolated multi spectral image and // the panchromatic image are given as inputs to the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet bayesianFilter->SetMultiSpect(multiSpectReader->GetOutput()); bayesianFilter->SetMultiSpectInterp(multiSpectInterpReader->GetOutput()); bayesianFilter->SetPanchro(panchroReader->GetOutput()); writer->SetInput(bayesianFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The BayesianFusionFilter requires defining one parameter : $\lambda$. // The $\lambda$ parameter can be used to tune the fusion toward either a high color // consistency or sharp details. Typical $\lambda$ value range in $[0.5, 1[$, where higher // values yield sharper details. by default $\lambda$ is set at 0.9999. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet bayesianFilter->SetLambda(atof(argv[9])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is recommended to place update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet // Create an 3 band images for the software guide typedef unsigned char OutputPixelType2; typedef otb::VectorImage OutputVectorImageType; typedef otb::ImageFileWriter VectorWriterType; typedef otb::VectorRescaleIntensityImageFilter VectorRescalerType; typedef otb::VectorRescaleIntensityImageFilter VectorRescalerBayesianType; typedef otb::ImageToVectorImageCastFilter CasterType; typedef otb::MultiChannelExtractROI ChannelExtractorType; multiSpectReader->GenerateOutputInformation(); multiSpectInterpReader->GenerateOutputInformation(); CasterType::Pointer cast = CasterType::New(); cast->SetInput(panchroReader->GetOutput()); OutputVectorImageType::PixelType minimum, maximum; minimum.SetSize(multiSpectReader->GetOutput()->GetNumberOfComponentsPerPixel()); maximum.SetSize(multiSpectReader->GetOutput()->GetNumberOfComponentsPerPixel()); minimum.Fill(0); maximum.Fill(255); VectorRescalerType::Pointer vrms = VectorRescalerType::New(); VectorRescalerType::Pointer vrmsi = VectorRescalerType::New(); VectorRescalerBayesianType::Pointer vrb = VectorRescalerBayesianType::New(); vrms->SetInput(multiSpectReader->GetOutput()); vrms->SetOutputMinimum(minimum); vrms->SetOutputMaximum(maximum); vrms->SetClampThreshold(0.01); vrmsi->SetInput(multiSpectInterpReader->GetOutput()); vrmsi->SetOutputMinimum(minimum); vrmsi->SetOutputMaximum(maximum); vrmsi->SetClampThreshold(0.01); vrb->SetInput(bayesianFilter->GetOutput()); vrb->SetOutputMinimum(minimum); vrb->SetOutputMaximum(maximum); vrb->SetClampThreshold(0.01); VectorRescalerType::Pointer rp = VectorRescalerType::New(); rp->SetInput(cast->GetOutput()); minimum.SetSize(1); maximum.SetSize(1); minimum.Fill(0); maximum.Fill(255); rp->SetOutputMinimum(minimum); rp->SetOutputMaximum(maximum); rp->SetClampThreshold(0.01); ChannelExtractorType::Pointer selecterms = ChannelExtractorType::New(); ChannelExtractorType::Pointer selectermsi = ChannelExtractorType::New(); ChannelExtractorType::Pointer selecterf = ChannelExtractorType::New(); selecterms->SetInput(vrms->GetOutput()); // selecterms->SetExtractionRegion(multiSpectReader->GetOutput()->GetLargestPossibleRegion()); selecterms->SetChannel(2); selecterms->SetChannel(3); selecterms->SetChannel(4); selectermsi->SetInput(vrmsi->GetOutput()); // selectermsi->SetExtractionRegion(multiSpectInterpReader->GetOutput()->GetLargestPossibleRegion()); selectermsi->SetChannel(2); selectermsi->SetChannel(3); selectermsi->SetChannel(4); selecterf->SetInput(vrb->GetOutput()); //selecterf->SetExtractionRegion(bayesianFilter->GetOutput()->GetLargestPossibleRegion()); selecterf->SetChannel(2); selecterf->SetChannel(3); selecterf->SetChannel(4); VectorWriterType::Pointer vectWriterms = VectorWriterType::New(); VectorWriterType::Pointer vectWritermsi = VectorWriterType::New(); VectorWriterType::Pointer vectWriterf = VectorWriterType::New(); VectorWriterType::Pointer vectWriterp = VectorWriterType::New(); vectWriterf->SetFileName(argv[5]); vectWriterf->SetInput(selecterf->GetOutput()); vectWriterms->SetFileName(argv[6]); vectWriterms->SetInput(selecterms->GetOutput()); vectWritermsi->SetFileName(argv[7]); vectWritermsi->SetInput(selectermsi->GetOutput()); vectWriterp->SetFileName(argv[8]); vectWriterp->SetInput(rp->GetOutput()); try { vectWriterms->Update(); vectWritermsi->Update(); vectWriterf->Update(); vectWriterp->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Let's now run this example using as input the images // \code{multiSpect.tif} , \code{multiSpectInterp.tif} and \code{panchro.tif} // provided in the directory \code{Examples/Data}. The results // obtained for 2 different values for $\lambda$ are shown in figure // \ref{fig:BayesianImageFusionFilterInput}. // // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{pretty_multiSpect_0.5.eps} // \includegraphics[width=0.24\textwidth]{pretty_multiSpectInterp_0.5.eps} // \includegraphics[width=0.24\textwidth]{pretty_panchro_0.5.eps} // \itkcaption[Bayesian Data Fusion Example inputs]{Input // images used for this example (\copyright European Space Imaging).} // \label{fig:BayesianImageFusionFilterInput} // \end{figure} // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{pretty_BayesianFusion_0.5.eps} // \includegraphics[width=0.24\textwidth]{pretty_BayesianFusion_0.9999.eps} // \itkcaption[Bayesian Data Fusion results]{Fusion results // for the Bayesian Data Fusion filter for $\lambda = 0.5$ on the left and $\lambda = 0.9999$ on the right.} // \label{fig:BayesianImageFusionFilterOutput} // \end{figure} // // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Fusion/CMakeLists.txt000066400000000000000000000005241301006202600212000ustar00rootroot00000000000000project(FusionExamples) add_executable(BayesianFusionImageFilter BayesianFusionImageFilter.cxx) target_link_libraries(BayesianFusionImageFilter ${OTB_LIBRARIES}) add_executable(PanSharpeningExample PanSharpeningExample.cxx) target_link_libraries(PanSharpeningExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Fusion/PanSharpeningExample.cxx000066400000000000000000000151611301006202600232400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Toulouse_Ortho_PAN.tif}, {QB_Toulouse_Ortho_XS.tif} // OUTPUTS: {QB_Toulouse_Ortho_PXS.tif} // OUTPUTS: {pretty_QB_Toulouse_Ortho_PXS.png} // OUTPUTS: {pretty_QB_Toulouse_Ortho_PAN.png} // OUTPUTS: {pretty_QB_Toulouse_Ortho_XS.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Here we are illustrating the use of the // \doxygen{otb}{SimpleRcsPanSharpeningFusionImageFilter} for PAN-sharpening. // This example takes a PAN and the corresponding XS images as input. These // images are supposed to be registered. // // The fusion operation is defined as // // \begin{equation} // \frac{XS}{\mathrm{Filtered}(PAN)} PAN // \end{equation} // // Software Guide : EndLatex // Software Guide : BeginLatex // // Figure~\ref{fig:PANSHARP_FILTER} shows the result of applying // this PAN sharpening filter to a Quickbird image. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{pretty_QB_Toulouse_Ortho_PAN.eps} // \includegraphics[width=0.44\textwidth]{pretty_QB_Toulouse_Ortho_XS.eps} // \includegraphics[width=0.44\textwidth]{pretty_QB_Toulouse_Ortho_PXS.eps} // \itkcaption[Pan sharpening]{Result of applying // the \doxygen{otb}{SimpleRcsPanSharpeningFusionImageFilter} to // orthorectified Quickbird // image. From left to right : original PAN image, original XS image and the // result of the PAN sharpening} // \label{fig:PANSHARP_FILTER} // \end{figure} // // Software Guide : EndLatex // Software Guide : BeginLatex // // We start by including the required header and declaring the main function: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSimpleRcsPanSharpeningFusionImageFilter.h" // Software Guide : EndCodeSnippet #include "otbPrintableImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageToVectorImageCastFilter.h" // Software Guide : BeginCodeSnippet int main(int argc, char* argv[]) { // Software Guide : EndCodeSnippet if (argc < 7) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputPanchromatiqueImage inputMultiSpectralImage outputImage outputImagePrinted panchroPrinted msPrinted" << std::endl; return 1; } // Software Guide : BeginLatex // // We declare the different image type used here as well as the image reader. // Note that, the reader for the PAN image is templated by an // \doxygen{otb}{Image} while the XS reader uses an // \doxygen{otb}{VectorImage}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderVectorType; typedef otb::VectorImage VectorIntImageType; ReaderVectorType::Pointer readerXS = ReaderVectorType::New(); ReaderType::Pointer readerPAN = ReaderType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We pass the filenames to the readers // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet readerPAN->SetFileName(argv[1]); readerXS->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the fusion filter an set its inputs using the readers: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SimpleRcsPanSharpeningFusionImageFilter FusionFilterType; FusionFilterType::Pointer fusion = FusionFilterType::New(); fusion->SetPanInput(readerPAN->GetOutput()); fusion->SetXsInput(readerXS->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we declare the writer and call its \code{Update()} method to // trigger the full pipeline execution. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(fusion->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet typedef otb::PrintableImageFilter PrintableImageType; PrintableImageType::Pointer printable = PrintableImageType::New(); typedef otb::VectorImage VectorCharImageType; typedef otb::ImageFileWriter PNGWriterType; PNGWriterType::Pointer pngwriter = PNGWriterType::New(); printable->SetInput(fusion->GetOutput()); printable->SetChannel(3); printable->SetChannel(2); printable->SetChannel(1); pngwriter->SetFileName(argv[4]); pngwriter->SetInput(printable->GetOutput()); pngwriter->Update(); typedef otb::PrintableImageFilter PrintableImageType2; PrintableImageType2::Pointer printable2 = PrintableImageType2::New(); printable2->SetInput(readerXS->GetOutput()); printable2->SetChannel(3); printable2->SetChannel(2); printable2->SetChannel(1); pngwriter->SetFileName(argv[6]); pngwriter->SetInput(printable2->GetOutput()); pngwriter->Update(); typedef otb::ImageToVectorImageCastFilter VectorCastFilterType; VectorCastFilterType::Pointer vectorCastFilter = VectorCastFilterType::New(); PNGWriterType::Pointer pngwriterPan = PNGWriterType::New(); vectorCastFilter->SetInput(readerPAN->GetOutput()); PrintableImageType2::Pointer printable3 = PrintableImageType2::New(); printable3->SetInput(vectorCastFilter->GetOutput()); printable3->SetChannel(1); printable3->SetChannel(1); printable3->SetChannel(1); pngwriterPan->SetFileName(argv[5]); pngwriterPan->SetInput(printable3->GetOutput()); pngwriterPan->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Fusion/test/000077500000000000000000000000001301006202600174165ustar00rootroot00000000000000OTB-release-5.8/Examples/Fusion/test/CMakeLists.txt000066400000000000000000000021431301006202600221560ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Fusion) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME fuTeBayesianFusionImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/ImageBayesianFusion.tif ${TEMP}/ImageBayesianFusion.tif Execute $ ${INPUTDATA}/multiSpect.tif ${INPUTDATA}/multiSpectInterp.tif ${INPUTDATA}/panchro.tif ${TEMP}/ImageBayesianFusion.tif ${TEMP}/ImageBayesianFusion1.png ${TEMP}/ImageBayesianFusion2.png ${TEMP}/ImageBayesianFusion3.png ${TEMP}/ImageBayesianFusion4.png 0.9999 ) otb_add_test(NAME fuTePanSharpeningExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/PanSharpeningExampleTest.tif ${TEMP}/PanSharpeningExampleTest.tif Execute $ ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif ${TEMP}/PanSharpeningExampleTest.tif ${TEMP}/PanSharpeningExampleTest1.png ${TEMP}/PanSharpeningExampleTest2.png ${TEMP}/PanSharpeningExampleTest3.png ) OTB-release-5.8/Examples/Hyperspectral/000077500000000000000000000000001301006202600200215ustar00rootroot00000000000000OTB-release-5.8/Examples/Hyperspectral/CMakeLists.txt000066400000000000000000000003501301006202600225570ustar00rootroot00000000000000project(HyperspectralExamples) add_executable(HyperspectralUnmixingExample HyperspectralUnmixingExample.cxx) target_link_libraries(HyperspectralUnmixingExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Hyperspectral/HyperspectralUnmixingExample.cxx000066400000000000000000000200301301006202600264200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" // Software Guide : BeginCommandLineArgs // INPUTS: {Indian_pines_corrected.tif} // OUTPUTS: {Indian_pines_Unmixing_Output.tif}, {UnmixingbandOutput1.png}, {UnmixingbandOutput2.png}, {UnmixingbandOutput3.png} // 16 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{VcaImageFilter} and \doxygen{otb}{UnConstrainedLeastSquareImageFilter}. // The VCA filter computes endmembers using the Vertex Component Analysis // and UCLS performs unmixing on the input image using these endmembers. // // The first step required to use these filters is to include its header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbVcaImageFilter.h" #include "otbUnConstrainedLeastSquareImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 7) { std::cerr << "Usage: " << argv[0]; std::cerr << "inputFileName outputFileName outputPrettyFilename1 outputPrettyFilename2 outputPrettyFilename3 EstimatenumberOfEndmembers" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int estimateNumberOfEndmembers = atoi(argv[6]); const unsigned int Dimension = 2; typedef double PixelType; // Software Guide : BeginLatex // // We start by defining the types for the images and the reader and // the writer. We choose to work with a \doxygen{otb}{VectorImage}, // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet typedef otb::VectorRescaleIntensityImageFilter RescalerType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; // Software Guide : BeginLatex // // We instantiate now the image reader and we set the image file name. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Software Guide : EndCodeSnippet reader->UpdateOutputInformation(); // Software Guide : BeginLatex // // For now we need to rescale the input image between 0 and 1 to // perform the unmixing algorithm. We use the // \doxygen{otb}{VectorRescaleIntensityImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetInput(reader->GetOutput()); ImageType::PixelType minPixel, maxPixel; minPixel.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); maxPixel.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); minPixel.Fill(0.); maxPixel.Fill(1.); rescaler->SetOutputMinimum(minPixel); rescaler->SetOutputMaximum(maxPixel); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type for the VCA filter. It is templated over the input // image type. The only parameter is the number of endmembers which // needs to be estimated. // We can now the instantiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VCAImageFilter VCAFilterType; VCAFilterType::Pointer vca = VCAFilterType::New(); vca->SetNumberOfEndmembers(estimateNumberOfEndmembers); vca->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We transform the output estimate endmembers to a matrix representation // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorImageToMatrixImageFilterType::Pointer endMember2Matrix = VectorImageToMatrixImageFilterType::New(); endMember2Matrix->SetInput(vca->GetOutput()); endMember2Matrix->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now procedd to the unmixing algorithm.Parameters // needed are the input image and the endmembers matrix. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::UnConstrainedLeastSquareImageFilter UCLSUnmixingFilterType; UCLSUnmixingFilterType::Pointer unmixer = UCLSUnmixingFilterType::New(); unmixer->SetInput(rescaler->GetOutput()); unmixer->SetMatrix(endMember2Matrix->GetMatrix()); // Software Guide : EndCodeSnippet unmixer->SetNumberOfThreads(1); // FIXME : currently buggy // Software Guide : BeginLatex // // We now instantiate the writer and set the file name for the // output image and trigger the unmixing computation with the \code{Update()} of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetInput(unmixer->GetOutput()); writer->SetFileName(outfname); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:UNMIXING_FILTER} shows the result of applying unmixing // to an AVIRIS image (220 bands). This dataset is freely available // at \url{http://www.ehu.es/ccwintco/index.php/Hyperspectral_Remote_Sensing_Scenes#Indian_Pines} // \begin{figure} // \center // \includegraphics[width=0.25\textwidth]{UnmixingbandOutput1.eps} // \includegraphics[width=0.25\textwidth]{UnmixingbandOutput2.eps} // \includegraphics[width=0.25\textwidth]{UnmixingbandOutput3.eps} // \itkcaption[Unmixing Filter]{Result of applying the // \doxygen{otb}{VcaImageFilter} and \doxygen{otb}{UnConstrainedLeastSquareImageFilter} to an image. From left // to right and top to bottom: // first abundance map band, second abundance map band, third abundance map band.} // \label{fig:UNMIXING_FILTER} // \end{figure} // // Software Guide : EndLatex typedef otb::Image MonoImageType; typedef otb::MultiToMonoChannelExtractROI ExtractROIFilterType; typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter PrettyRescalerType; typedef otb::ImageFileWriter WriterType2; for (unsigned int cpt = 0; cpt < 3; ++cpt) { ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); PrettyRescalerType::Pointer prettyRescaler = PrettyRescalerType::New(); WriterType2::Pointer writer2 = WriterType2::New(); extractROIFilter->SetInput(unmixer->GetOutput()); extractROIFilter->SetChannel(cpt + 1); prettyRescaler->SetInput(extractROIFilter->GetOutput()); prettyRescaler->SetOutputMinimum(0); prettyRescaler->SetOutputMaximum(255); writer2->SetInput(prettyRescaler->GetOutput()); writer2->SetFileName(argv[cpt + 3]); writer2->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Hyperspectral/test/000077500000000000000000000000001301006202600210005ustar00rootroot00000000000000OTB-release-5.8/Examples/Hyperspectral/test/CMakeLists.txt000066400000000000000000000016171301006202600235450ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Hyperspectral) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME siTvHyperspectralExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 3 ${BASELINE}/siTvHyperspectralUnmixingExampleTestBand1.png ${TEMP}/siTvHyperspectralUnmixingExampleTestBand1.png ${BASELINE}/siTvHyperspectralUnmixingExampleTestBand2.png ${TEMP}/siTvHyperspectralUnmixingExampleTestBand2.png ${BASELINE}/siTvHyperspectralUnmixingExampleTestBand3.png ${TEMP}/siTvHyperspectralUnmixingExampleTestBand3.png Execute $ LARGEINPUT{AVIRIS/Indian_pines_corrected.tif} ${TEMP}/siTvHyperspectralUnmixingExampleTest.tif ${TEMP}/siTvHyperspectralUnmixingExampleTestBand1.png ${TEMP}/siTvHyperspectralUnmixingExampleTestBand2.png ${TEMP}/siTvHyperspectralUnmixingExampleTestBand3.png 16 ) OTB-release-5.8/Examples/IO/000077500000000000000000000000001301006202600155035ustar00rootroot00000000000000OTB-release-5.8/Examples/IO/CMakeLists.txt000066400000000000000000000044331301006202600202470ustar00rootroot00000000000000project(IOExamples) add_executable(ComplexImageReadWrite ComplexImageReadWrite.cxx) target_link_libraries(ComplexImageReadWrite ${OTB_LIBRARIES}) add_executable(DEMHandlerExample DEMHandlerExample.cxx) target_link_libraries(DEMHandlerExample ${OTB_LIBRARIES}) add_executable(DEMToImageGenerator DEMToImageGenerator.cxx) target_link_libraries(DEMToImageGenerator ${OTB_LIBRARIES}) add_executable(ExplicitStreamingExample ExplicitStreamingExample.cxx) target_link_libraries(ExplicitStreamingExample ${OTB_LIBRARIES}) add_executable(ExtractROI ExtractROI.cxx) target_link_libraries(ExtractROI ${OTB_LIBRARIES}) add_executable(HDFReaderExample HDFReaderExample.cxx) target_link_libraries(HDFReaderExample ${OTB_LIBRARIES}) add_executable(ImageReadCastWrite ImageReadCastWrite.cxx) target_link_libraries(ImageReadCastWrite ${OTB_LIBRARIES}) add_executable(ImageReadRegionOfInterestWrite ImageReadRegionOfInterestWrite.cxx) target_link_libraries(ImageReadRegionOfInterestWrite ${OTB_LIBRARIES}) add_executable(ImageReadWrite ImageReadWrite.cxx) target_link_libraries(ImageReadWrite ${OTB_LIBRARIES}) add_executable(ImageSeriesIOExample ImageSeriesIOExample.cxx) target_link_libraries(ImageSeriesIOExample ${OTB_LIBRARIES}) if(OTBlibkml_LOADED) add_executable(ImageToKmzAndMapFileProductExample ImageToKmzAndMapFileProductExample.cxx) target_link_libraries(ImageToKmzAndMapFileProductExample ${OTB_LIBRARIES}) endif() add_executable(MetadataExample MetadataExample.cxx) target_link_libraries(MetadataExample ${OTB_LIBRARIES}) add_executable(MultibandImageReadWrite MultibandImageReadWrite.cxx) target_link_libraries(MultibandImageReadWrite ${OTB_LIBRARIES}) add_executable(OGRWrappersExample OGRWrappersExample.cxx) target_link_libraries(OGRWrappersExample ${OTB_LIBRARIES}) add_executable(RGBImageReadWrite RGBImageReadWrite.cxx) target_link_libraries(RGBImageReadWrite ${OTB_LIBRARIES}) add_executable(StreamingImageReadWrite StreamingImageReadWrite.cxx) target_link_libraries(StreamingImageReadWrite ${OTB_LIBRARIES}) add_executable(TileMapImageIOExample TileMapImageIOExample.cxx) target_link_libraries(TileMapImageIOExample ${OTB_LIBRARIES}) add_executable(VectorDataIOExample VectorDataIOExample.cxx) target_link_libraries(VectorDataIOExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/IO/ComplexImageReadWrite.cxx000066400000000000000000000101201301006202600224020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates how to read and write an image of pixel type // \code{std::complex}. The complex type is defined as an integral part of the // C++ language. // // We start by including the headers of the complex class, the image, and the // reader and writer classes. // // \index{otb::ImageFileRead!Complex images} // \index{otb::ImageFileWrite!Complex images} // \index{Complex images!Instantiation} // \index{Complex images!Reading} // \index{Complex images!Writing} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { // Verify the number of parameters in the command line if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The image dimension and pixel type must be declared. In this case we use the // \code{std::complex<>} as the pixel type. Using the dimension and pixel type // we proceed to instantiate the image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image file reader and writer types are instantiated using the image // type. We can then create objects for both of them. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Filenames should be provided for both the reader and the writer. In this // particular example we take those filenames from the command line arguments. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Here we simply connect the output of the reader as input to the writer. // This simple program could be used for converting complex images from one // fileformat to another. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The execution of this short pipeline is triggered by invoking the Update() // method of the writer. This invocation must be placed inside a try/catch // block since its execution may result in exceptions being thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // For a more interesting use of this code, you may want to add a filter in // between the reader and the writer and perform any complex image to complex // image operation. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/DEMHandlerExample.cxx000066400000000000000000000122721301006202600214520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // ${OTB_DATA_ROOT}/Input/srtm_directory ${OTB_DATA_ROOT}/Input/DEM/egm96.grd // 40 8.434583 44.647083 383.580313671 0.001 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // OTB relies on OSSIM for elevation handling. Since release 3.16, there is a // single configuration class \doxygen{otb}{DEMHandler} to manage elevation (in // image projections or localization functions for example). This configuration // is managed by the a proper instantiation and parameters setting of this // class. These instantiations must be done before any call to geometric // filters or functionalities. Ossim internal accesses to elevation are also // configured by this class and this will ensure consistency throughout the // library. // // Software Guide : EndLatex #include "otbDEMHandler.h" int main(int argc, char * argv[]) { if(argc!=8) { std::cerr<<"Usage: "<SetDefaultHeightAboveEllipsoid(defaultHeight); if(!demHandler->IsValidDEMDirectory(demdir.c_str())) { std::cerr<<"IsValidDEMDirectory("<OpenDEMDirectory(demdir); demHandler->OpenGeoidFile(geoid); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now retrieve height above ellipsoid or height above Mean Sea Level // (MSL) using the methods \code{GetHeightAboveEllipsoid()} and // \code{GetHeightAboveMSL()}. Outputs of these methods depend on the // configuration of the class \doxygen{otb}{DEMHandler} and the different // cases are: // // For \code{GetHeightAboveEllipsoid()}: // // \begin{itemize} // \item DEM and geoid both available: $dem\_value + geoid\_offset$ // \item No DEM but geoid available: geoid\_offset // \item DEM available, but no geoid: dem\_value // \item No DEM and no geoid available: default height above ellipsoid // \end{itemize} // // For \code{GetHeightAboveMSL()}: // // \begin{itemize} // \item DEM and geoid both available: srtm\_value // \item No DEM but geoid available: $0$ // \item DEM available, but no geoid: srtm\_value // \item No DEM and no geoid available: $0$ // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::DEMHandler::PointType point; point[0] = longitude; point[1] = latitude; double height = -32768; height = demHandler->GetHeightAboveMSL(point); std::cout<<"height above MSL ("<GetHeightAboveEllipsoid(point); std::cout<<"height above ellipsoid ("<tolerance) { std::cerr<<"Target value is "< tolerance ("< ImageType; // Software Guide : EndCodeSnippet // The writer is defined typedef otb::ImageFileWriter WriterType; // Software Guide : BeginLatex // // The DEMToImageGenerator is defined using the image pixel // type as a template parameter. After that, the object can be instancied. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::DEMToImageGenerator DEMToImageGeneratorType; DEMToImageGeneratorType::Pointer object = DEMToImageGeneratorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Input parameter types are defined to set the value in the \doxygen{otb}{DEMToImageGenerator}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef DEMToImageGeneratorType::SizeType SizeType; typedef DEMToImageGeneratorType::SpacingType SpacingType; typedef DEMToImageGeneratorType::PointType PointType; // Software Guide : EndCodeSnippet // Instantiating writer WriterType::Pointer writer = WriterType::New(); // Software Guide : BeginLatex // // The path to the DEM folder is given to the \doxygen{otb}{DEMHandler}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::DEMHandler::Instance()->OpenDEMDirectory(folderPath); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The origin (Longitude/Latitude) of the output image in the DEM is given to the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointType origin; origin[0] = ::atof(argv[3]); origin[1] = ::atof(argv[4]); object->SetOutputOrigin(origin); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The size (in Pixel) of the output image is given to the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SizeType size; size[0] = ::atoi(argv[5]); size[1] = ::atoi(argv[6]); object->SetOutputSize(size); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The spacing (step between to consecutive pixel) is given to the filter. // By default, this spacing is set at 0.001. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SpacingType spacing; spacing[0] = ::atof(argv[7]); spacing[1] = ::atof(argv[8]); object->SetOutputSpacing(spacing); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output image name is given to the writer and // the filter output is linked to the writer input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetFileName(outputName); writer->SetInput(object->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is recommended to place update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "Exception itk::ExceptionObject thrown !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet catch (...) { std::cout << "Unknown exception thrown !" << std::endl; return EXIT_FAILURE; } // Pretty image creation for the printing typedef otb::Image OutputPrettyImageType; typedef otb::ImageFileWriter WriterPrettyType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef itk::ThresholdImageFilter ThresholderType; ThresholderType::Pointer thresholder = ThresholderType::New(); RescalerType::Pointer rescaler = RescalerType::New(); WriterPrettyType::Pointer prettyWriter = WriterPrettyType::New(); thresholder->SetInput(object->GetOutput()); thresholder->SetOutsideValue(0.0); thresholder->ThresholdBelow(0.0); thresholder->Update(); rescaler->SetInput(thresholder->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); prettyWriter->SetFileName(argv[2]); prettyWriter->SetInput(rescaler->GetOutput()); try { prettyWriter->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; // Software Guide : BeginLatex // // Let's now run this example using as input the SRTM data contained in // \code{DEM\_srtm} folder. Figure \ref{fig:DEMToImageGenerator} // shows the obtained DEM. Invalid data values -- hidden areas due // to SAR shadowing -- are set to zero. // // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{pretty_DEMToImageGenerator.eps} // \itkcaption[DEM To Image generator Example]{DEMToImageGenerator image.} // \label{fig:DEMToImageGenerator} // \end{figure} // // Software Guide : EndLatex } OTB-release-5.8/Examples/IO/ExplicitStreamingExample.cxx000066400000000000000000000141211301006202600231750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "itkImageRegionConstIterator.h" // Software Guide : BeginLatex // // Usually, the streaming process is hidden within the pipeline. This // allows the user to get rid of the annoying task of splitting the // images into tiles, and so on. However, for some kinds of // processing, we do not really need a pipeline: no writer is needed, // only read access to pixel values is wanted. In these cases, one // has to explicitly set up the streaming procedure. Fortunately, OTB // offers a high level of abstraction for this task. We will need to // include the following header files: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbRAMDrivenAdaptativeStreamingManager.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 2) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile " << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; typedef float PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ImageReaderType; // Software Guide : BeginLatex // // The \doxygen{otb}{RAMDrivenAdaptativeStreamingManager} class manages the streaming // approaches which are possible with the image type over which it is // templated. The class \doxygen{itk}{ImageRegionSplitter} is // templated over the number of dimensions of the image and will // perform the actual image splitting. More information on splitter can be // found in section~\ref{sec:Splitters} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // typedef otb::StreamingTraits StreamingTraitsType; // typedef itk::ImageRegionSplitter<2> SplitterType; typedef otb::RAMDrivenAdaptativeStreamingManager StreamingManagerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once a region of the image is available, we will use classical // region iterators to get the pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ImageType::RegionType RegionType; typedef itk::ImageRegionConstIterator IteratorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the image file reader, but in order to avoid // reading the whole image, we call the // \code{GenerateOutputInformation()} method instead of the // \code{Update()} one. \code{GenerateOutputInformation()} will make // available the information about sizes, band, resolutions, // etc. After that, we can access the largest possible region of the // input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageReaderType::Pointer reader = ImageReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); RegionType largestRegion = reader->GetOutput()->GetLargestPossibleRegion(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set up now the local streaming capabilities by asking the // streaming traits to compute the number of regions to split the // image into given the splitter, the user defined number of lines, // and the input image information. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet /* SplitterType::Pointer splitter = SplitterType::New(); unsigned int numberOfStreamDivisions = StreamingTraitsType::CalculateNumberOfStreamDivisions( reader->GetOutput(), largestRegion, splitter, otb::SET_BUFFER_NUMBER_OF_LINES, 0, 0, nbLinesForStreaming); // Software Guide : EndCodeSnippet std::cout << "The images will be streamed into " << numberOfStreamDivisions << " parts." << std::endl; */ StreamingManagerType::Pointer streamingManager = StreamingManagerType::New(); const int availableRAM = 128; streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->PrepareStreaming(reader->GetOutput(), largestRegion); const unsigned long numberOfStreamDivisions = streamingManager->GetNumberOfSplits(); // Software Guide : BeginLatex // // We can now get the split regions and iterate through them. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int piece = 0; RegionType streamingRegion; for (piece = 0; piece < numberOfStreamDivisions; piece++) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the region // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet /*streamingRegion = splitter->GetSplit(piece, numberOfStreamDivisions, largestRegion); */ streamingRegion = streamingManager->GetSplit(piece); std::cout << "Processing region: " << streamingRegion << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We ask the reader to provide the region. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->GetOutput()->SetRequestedRegion(streamingRegion); reader->GetOutput()->PropagateRequestedRegion(); reader->GetOutput()->UpdateOutputData(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare an iterator and walk through the region. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet IteratorType it(reader->GetOutput(), streamingRegion); it.GoToBegin(); while (!it.IsAtEnd()) { std::cout << it.Get() << std::endl; ++it; } // Software Guide : EndCodeSnippet } return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/ExtractROI.cxx000066400000000000000000000214661301006202600202240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {IMAGERY_SSECH.tif} // OUTPUTS: {ROI_IMAGERY_RGB.png}, {ROI_IMAGERY_MIR.png} // 0 0 100 100 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example shows the use of the // \doxygen{otb}{MultiChannelExtractROI} and // \doxygen{otb}{MultiToMonoChannelExtractROI} which allow the // extraction of ROIs from multiband images stored into // \doxygen{otb}{VectorImage}s. The first one povides a Vector Image // as output, while the second one provides a classical // \doxygen{otb}{Image} with a scalar pixel type. The present example // shows how to extract a ROI from a 4-band SPOT 5 image and to // produce a first multi-band 3-channel image and a second // mono-channel one for the SWIR band. // We start by including the needed header files. // \index{otb::ExtractROI!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" #include "otbMultiToMonoChannelExtractROI.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { // R\'ecuperation de arguments if (argc < 7) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFileRGB outputImageFileLastBand startX startY sizeX sizeY" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The program arguments define the image file names as well as the // rectangular area to be extracted. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const char * inputFilename = argv[1]; const char * outputFilenameRGB = argv[2]; const char * outputFilenameMIR = argv[3]; unsigned int startX((unsigned int) ::atoi(argv[4])); unsigned int startY((unsigned int) ::atoi(argv[5])); unsigned int sizeX((unsigned int) ::atoi(argv[6])); unsigned int sizeY((unsigned int) ::atoi(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As usual, we define the input and output pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // First of all, we extract the multiband part by using the // \doxygen{otb}{MultiChannelExtractROI} class, which is templated // over the input and output pixel types. This class in not // templated over the images types in order to force these images // to be of \doxygen{otb}{VectorImage} type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MultiChannelExtractROI ExtractROIFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create the extractor filter by using the \code{New} method of // the class and we set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); extractROIFilter->SetStartX(startX); extractROIFilter->SetStartY(startY); extractROIFilter->SetSizeX(sizeX); extractROIFilter->SetSizeY(sizeY); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We must tell the filter which are the channels to be used. When // selecting contiguous bands, we can use the // \code{SetFirstChannel} and the \code{SetLastChannel}. Otherwise, // we select individual channels by using the \code{SetChannel} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet extractROIFilter->SetFirstChannel(1); extractROIFilter->SetLastChannel(3); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will use the OTB readers and writers for file access. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the number of bands of the input image is dynamically set // at runtime, the \code{UpdateOutputInformation} method of the reader must be // called before using the extractor filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); writer->SetFileName(outputFilenameRGB); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can then build the pipeline as usual. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet extractROIFilter->SetInput(reader->GetOutput()); writer->SetInput(extractROIFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And execute the pipeline by calling the \code{Update} method of // the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The usage of the \doxygen{otb}{MultiToMonoChannelExtractROI} is // similar to the one of the \doxygen{otb}{MultiChannelExtractROI} // described above. // // The goal now is to extract an ROI from a multi-band image and // generate a mono-channel image as output. // // We could use the \doxygen{otb}{MultiChannelExtractROI} and // select a single channel, but using the // \doxygen{otb}{MultiToMonoChannelExtractROI} we generate a // \doxygen{otb}{Image} instead of an // \doxygen{otb}{VectorImage}. This is useful from a computing and // memory usage point of view. // This class is also templated over the pixel types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MultiToMonoChannelExtractROI ExtractROIMonoFilterType; // Software Guide : EndCodeSnippet ExtractROIMonoFilterType::Pointer extractROIMonoFilter = ExtractROIMonoFilterType::New(); extractROIMonoFilter->SetStartX(startX); extractROIMonoFilter->SetStartY(startY); extractROIMonoFilter->SetSizeX(sizeX); extractROIMonoFilter->SetSizeY(sizeY); // Software Guide : BeginLatex // // For this filter, only one output channel has to be selected. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet extractROIMonoFilter->SetChannel(4); // Software Guide : EndCodeSnippet typedef otb::ImageFileReader monoReaderType; typedef otb::ImageFileWriter monoWriterType; monoReaderType::Pointer monoReader = monoReaderType::New(); monoWriterType::Pointer monoWriter = monoWriterType::New(); monoReader->SetFileName(inputFilename); monoReader->Update(); //Necessaire pour connaitre le nombre de canaux dans l'image monoWriter->SetFileName(outputFilenameMIR); extractROIMonoFilter->SetInput(monoReader->GetOutput()); monoWriter->SetInput(extractROIMonoFilter->GetOutput()); monoWriter->Update(); // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{IMAGERY_SSECH.eps} // \itkcaption[Initial SPOT 5 image]{Quicklook of the original SPOT // 5 image.} // \label{fig:IMAGERY_SSECH} // \end{figure} // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{ROI_IMAGERY_RGB.eps} // \includegraphics[width=0.44\textwidth]{ROI_IMAGERY_MIR.eps} // \itkcaption[ROI of a SPOT5 image]{Result of the // extraction. Left: 3-channel image. Right: mono-band image.} // \label{fig:ROI_IMAGERY} // \end{figure} // // Figure \ref{fig:ROI_IMAGERY} illustrates the result of the // application of both extraction filters on the image presented in // figure \ref{fig:IMAGERY_SSECH}. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/HDFReaderExample.cxx000066400000000000000000000140541301006202600212730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {GSSTF_NCEP.2b.2008.12.31.he5} // OUTPUTS: {HDFReaderExample.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example describes how to read a MODIS image(Moderate-resolution Imaging Spectroradiometer) // .This scientific instrument was launched into Earth orbit by NASA. // The MODIS image format is HDF (Hierarchical Data Format). This // format is widely use to store remote sensing images. // HDF format is designed to store and organize large amounts of numerical data // including multidimensional arrays, raster images, and tables. // A specific feature of this format is that it works with container // structures which can hold datasets and other groups. It implies that // access to these structures in OTB presents some adaptations compare // to other image formats. // OTB is using GDAL to support HDF. HDF4 and HDF5 supports in Gdal is // not activated by default. You need to download the HDF run-time // libraries and compile Gdal by adding the support of these formats. You can // find more information here : \url{http://trac.osgeo.org/gdal/wiki/HDF} // // // The first step toward the use of these filters is to include the proper header files. // // Software Guide : EndLatex #include // Software Guide : BeginCodeSnippet #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int itkNotUsed(argc), char * argv[]) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need now to declare the data types that we will be using and instantiate the // reader (which is a \doxygen{otb}{PointSetFileReader}). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader HDFReaderType; typedef otb::ImageFileWriter HDFWriterType; HDFReaderType::Pointer reader = HDFReaderType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // If you specify the path name of the hdf file, by default the reader will open the first dataset in the container. // Otherwise, there are 2 ways to access HDF subdatasets in OTB. The basic idea is to concatenate the subdataset // name or number to the input filename. The ':' character is the standard separator in the input filename. // For example myfile.hdf:SubdatasetName or myfile.hdf:SubdatasetNumber // In this example we will access the first dataset of the MODIS MOD09Q1G_EVI.A2006233.h07v03.005.2008338190308.hdf:0 // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const std::string inputFilename (argv[1]); const std::string outputFilename (argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // You can access to subdatasets' information available in the HDF file using // the \code{GetSubDatasetInfo} method of \doxygen{otb}{GDALImageIO}. // It allows storing HDF subdatasets names and descriptions in vector of string. // You can find below how to print the name and the description // of all the subdatasets. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::GDALImageIO::Pointer readerGDAL = otb::GDALImageIO::New(); readerGDAL->SetFileName(inputFilename.c_str()); std::vector vectSubdatasetNames; std::vector vectorSubdatasetDescriptions; if (readerGDAL->CanReadFile(inputFilename.c_str())) { if (readerGDAL->GetSubDatasetInfo(vectSubdatasetNames, vectorSubdatasetDescriptions)) { // Fill vDataset with subdataset descriptor info for( unsigned int itSubDataset = 0; itSubDataset < (unsigned int) vectorSubdatasetDescriptions.size(); itSubDataset++ ) { std::cout << "Dataset Number " << itSubDataset << " name is: " << vectSubdatasetNames[itSubDataset].c_str() << " and description is: " << vectSubdatasetNames[itSubDataset].c_str() << std::endl; } } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then we write the first dataset of the MODIS product. As explained above, // we instantiate the reader with the correct input filename. // // Software Guide : EndLatex HDFWriterType::Pointer writer = HDFWriterType::New(); // Software Guide : BeginCodeSnippet std::ostringstream out; out << inputFilename; out << ":"; out << 0; reader->SetFileName(out.str()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can then built the pipeline And execute it by calling the \code{Update} method of // the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetFileName(outputFilename.c_str()); writer->SetInput(reader->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{HDFReaderExample0.eps} // \itkcaption[HDF Dataset]{Quicklook of the first dataset extraction of MODIS product.} // \label{fig:IMAGERY_HDF_0} // \end{figure} // // // Figures \ref{fig:IMAGERY_HDF_0} illustrates the extraction of MODIS // subdataset through \doxygen{otb}{ImageFileReader}. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/ImageReadCastWrite.cxx000066400000000000000000000140431301006202600216750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Given that \href{http://www.itk.org}{ITK} and OTB are based on the Generic // Programming paradigm, most of the types are defined at compilation // time. It is sometimes important to anticipate conversion between different // types of images. The following example illustrates the common case of // reading an image of one pixel type and writing it on a different pixel // type. This process not only involves casting but also rescaling the image // intensity since the dynamic range of the input and output pixel types can // be quite different. The \doxygen{itk}{RescaleIntensityImageFilter} is used // here to linearly rescale the image values. // // The first step in this example is to include the appropriate headers. // // \index{otb::ImageFileReader!header} // \index{otb::ImageFileWriter!header} // \index{itk::RescaleIntensityImageFilter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" int main(int argc, char * argv[]) { // Verify the number of parameters in the command line if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then, as usual, a decision should be made about the pixel type that // should be used to represent the images. Note that when reading an // image, this pixel type \textbf{is not necessarily} the pixel type of // the image stored in the file. Instead, it is the type that will be // used to store the image as soon as it is read into memory. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the types of the reader and writer. These two // classes are parameterized over the image type. // // \index{otb::ImageFileReader!Instantiation} // \index{otb::ImageFileWriter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Below we instantiate the RescaleIntensityImageFilter class that will // linearly scale the image intensities. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter< InputImageType, OutputImageType> FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A filter object is constructed and the minimum and maximum values of // the output are selected using the SetOutputMinimum() and // SetOutputMaximum() methods. // // \index{itk::RescaleIntensityImageFilter!SetOutputMinimum()} // \index{itk::RescaleIntensityImageFilter!SetOutputMaximum()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FilterType::Pointer filter = FilterType::New(); filter->SetOutputMinimum(0); filter->SetOutputMaximum(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we create the reader and writer and connect the pipeline. // // \index{otb::ImageFileReader!New()} // \index{otb::ImageFileWriter!New()} // \index{otb::ImageFileReader!SmartPointer} // \index{otb::ImageFileWriter!SmartPointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // // Here we recover the file names from the command line arguments // const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // The name of the files to be read and written are passed with the // SetFileName() method. // // \index{otb::ImageFileReader!SetFileName()} // \index{otb::ImageFileWriter!SetFileName()} // \index{SetFileName()!otb::ImageFileReader} // \index{SetFileName()!otb::ImageFileWriter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally we trigger the execution of the pipeline with the Update() // method on the writer. The output image will then be the scaled and cast // version of the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/ImageReadRegionOfInterestWrite.cxx000066400000000000000000000143351301006202600242350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example should arguably be placed in the filtering // chapter. However its usefulness for typical IO operations makes it // interesting to mention here. The purpose of this example is to read and // image, extract a subregion and write this subregion to a file. This is a // common task when we want to apply a computationally intensive method to // the region of interest of an image. // // As usual with OTB IO, we begin by including the appropriate header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{ExtractROI} is the filter used to extract a // region from an image. Its header is included below. // // \index{otb::ExtractROI!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbExtractROI.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { // Verify the number of parameters in the command line if (argc < 7) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; std::cerr << " startX startY sizeX sizeY" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Image types are defined below. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The types for the \doxygen{otb}{ImageFileReader} and \doxygen{otb}{ImageFileWriter} // are instantiated using the image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The ExtractROI type is instantiated using // the input and output pixel types. Using the pixel types as // template parameters instead of the image types allows // restricting the use of this class to \doxygen{otb}{Image}s which // are used with scalar pixel types. See section // \ref{sec:ExtractROI} for the extraction of ROIs on // \doxygen{otb}{VectorImage}s. A filter object is created with the // New() method and assigned to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ExtractROI FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The ExtractROI requires a region to be // defined by the user. This is done by defining a rectangle with // the following methods (the filter assumes that a 2D image is // being processed, for N-D region extraction, you can use the // \doxygen{itk}{RegionOfInterestImageFilter} class). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetStartX(atoi(argv[3])); filter->SetStartY(atoi(argv[4])); filter->SetSizeX(atoi(argv[5])); filter->SetSizeY(atoi(argv[6])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Below, we create the reader and writer using the New() method and // assigning the result to a SmartPointer. // // \index{otb::ImageFileReader!New()} // \index{otb::ImageFileWriter!New()} // \index{otb::ImageFileReader!SmartPointer} // \index{otb::ImageFileWriter!SmartPointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // // Here we recover the file names from the command line arguments // const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // The name of the file to be read or written is passed with the // SetFileName() method. // // \index{otb::ImageFileReader!SetFileName()} // \index{otb::ImageFileWriter!SetFileName()} // \index{SetFileName()!otb::ImageFileReader} // \index{SetFileName()!otb::ImageFileWriter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Below we connect the reader, filter and writer to form the data // processing pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally we execute the pipeline by invoking Update() on the writer. The // call is placed in a \code{try/catch} block in case exceptions are // thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/ImageReadWrite.cxx000066400000000000000000000200041301006202600210540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The classes responsible for reading and writing images are located at the // beginning and end of the data processing pipeline. These classes are // known as data sources (readers) and data sinks (writers). // Generally speaking they are referred to as filters, although readers have // no pipeline input and writers have no pipeline output. // // The reading of images is managed by the class \doxygen{otb}{ImageFileReader} // while writing is performed by the class \doxygen{otb}{ImageFileWriter}. These // two classes are independent of any particular file format. The actual low // level task of reading and writing specific file formats is done behind // the scenes by a family of classes of type // \doxygen{itk}{ImageIO}. Actually, the OTB image Readers and // Writers are very similar to those of ITK, but provide new // functionnalities which are specific to remote sensing images. // // The first step for performing reading and writing is to include the // following headers. // // \index{otb::ImageFileReader} // \index{otb::ImageFileReader!header} // // \index{otb::ImageFileWriter} // \index{otb::ImageFileWriter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" int main(int argc, char * argv[]) { // Verify the number of parameters in the command line if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then, as usual, a decision must be made about the type of pixel used to // represent the image processed by the pipeline. Note that when reading // and writing images, the pixel type of the image \textbf{is not // necessarily} the same as the pixel type stored in the file. Your // choice of the pixel type (and hence template parameter) should be // driven mainly by two considerations: // // \begin{itemize} // \item It should be possible to cast the file pixel type in the file to // the pixel type you select. This casting will be performed using the // standard C-language rules, so you will have to make sure that the // conversion does not result in information being lost. // \item The pixel type in memory should be appropriate to the type of // processing you intended to apply on the images. // \end{itemize} // // A typical selection for remote sensing images is illustrated in // the following lines. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that the dimension of the image in memory should match the one of // the image in file. There are a couple of special cases in which this // condition may be relaxed, but in general it is better to ensure that both // dimensions match. This is not a real issue in remote sensing, // unless you want to consider multi-band images as volumes (3D) of data. // // We can now instantiate the types of the reader and writer. These two // classes are parameterized over the image type. // // \index{otb::ImageFileReader!Instantiation} // \index{otb::ImageFileWriter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we create one object of each type using the New() method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // \index{otb::ImageFileReader!New()} // \index{otb::ImageFileWriter!New()} // \index{otb::ImageFileReader!SmartPointer} // \index{otb::ImageFileWriter!SmartPointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Here we recover the file names from the command line arguments // const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // The name of the file to be read or written is passed with the // SetFileName() method. // // \index{otb::ImageFileReader!SetFileName()} // \index{otb::ImageFileWriter!SetFileName()} // \index{SetFileName()!otb::ImageFileReader} // \index{SetFileName()!otb::ImageFileWriter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now connect these readers and writers to filters to create a // pipeline. For example, we can create a short pipeline by passing // the output of the reader directly to the input of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // At first view, this may seem as a quite useless program, but it is // actually implementing a powerful file format conversion tool! The // execution of the pipeline is triggered by the invocation of the // \code{Update()} methods in one of the final objects. In this case, the final // data pipeline object is the writer. It is a wise practice of defensive // programming to insert any \code{Update()} call inside a \code{try/catch} block // in case exceptions are thrown during the execution of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that exceptions should only be caught by pieces of code that know // what to do with them. In a typical application this \code{catch} block // should probably reside on the GUI code. The action on the \code{catch} // block could inform the user about the failure of the IO operation. // // The IO architecture of the toolkit makes it possible to avoid explicit // specification of the file format used to read or write // images.\footnote{In this example no file format is specified; this // program can be used as a general file conversion utility.} The object // factory mechanism enables the ImageFileReader and ImageFileWriter to // determine (at run-time) with which file format it is working // with. Typically, file formats are chosen based on the filename // extension, but the architecture supports arbitrarily complex processes // to determine whether a file can be read or written. Alternatively, the // user can specify the data file format by explicit instantiation and // assignment the appropriate \doxygen{itk}{ImageIO} subclass. // // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/ImageSeriesIOExample.cxx000066400000000000000000000127001301006202600221700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include // Software Guide : BeginLatex // // This example shows how to read a list of images and concatenate // them into a vector image. We will write a program which is able to // perform this operation taking advantage of the streaming // functionnalities of the processing pipeline. We will assume that // all the input images have the same size and a single band. // // The following header files will be needed: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet int main(int argc, char** argv) { if (argc < 4) { std::cerr << "Usage: " << argv[0]; std::cerr << "outputImage image1 image2 ... " << std::endl; } const unsigned int NbImages = argc - 2; std::cout << "Concat of " << NbImages << " images into a multi-band image " << std::endl; // Software Guide : BeginLatex // // We will start by defining the types for the input images and the // associated readers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short int PixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ImageReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will use a list of image file readers in order to open all the // input images at once. For this, we use the // \doxygen{otb}{ObjectList} object and we template it over the type // of the readers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ObjectList ReaderListType; ReaderListType::Pointer readerList = ReaderListType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will also build a list of input images in order to store the // smart pointers obtained at the output of each reader. This allows // us to build a pipeline without really reading the images and using // lots of RAM. The \doxygen{otb}{ImageList} object will be used. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageList ImageListType; ImageListType::Pointer imageList = ImageListType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now loop over the input image list in order to populate the // reader list and the input image list. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned int i = 0; i < NbImages; ++i) { ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[i + 2]); std::cout << "Adding image " << argv[i + 2] << std::endl; imageReader->UpdateOutputInformation(); imageList->PushBack(imageReader->GetOutput()); readerList->PushBack(imageReader); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // All the input images will be concatenated into a single output // vector image. For this matter, we will use the // \doxygen{otb}{ImageListToVectorImageFilter} which is templated // over the input image list type and the output vector image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage VectorImageType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; ImageListToVectorImageFilterType::Pointer iL2VI = ImageListToVectorImageFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the image list as input of the filter and use a // \doxygen{otb}{ImageFileWriter} to write the result image // to a file, so that the streaming capabilities of all the readers // and the filter are used. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet iL2VI->SetInput(imageList); typedef otb::ImageFileWriter ImageWriterType; ImageWriterType::Pointer imageWriter = ImageWriterType::New(); imageWriter->SetFileName(argv[1]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can tune the size of the image tiles, so that the // total memory footprint of the pipeline is constant // for any execution of the program. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned long memoryConsumptionInMB = 10; std::cout << "Memory consumption: " << memoryConsumptionInMB << std::endl; imageWriter->SetAutomaticTiledStreaming(memoryConsumptionInMB); imageWriter->SetInput(iL2VI->GetOutput()); imageWriter->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/ImageToKmzAndMapFileProductExample.cxx000066400000000000000000000163251301006202600250030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example demonstrates the use of the // \doxygen{otb}{KmzProductWriter} and the // \doxygen{otb}{MapFileProductWriter}. // The first filter is intended to produce Kmz file (Google Earth // Readable), and the second one is intended to produce map files // callable through a WMS (Web Map Service) service. In this example // we will use a file with no meta-data, use the // \doxygen{otb}{GGCPToRPCSensorModelImageFilter} in order to // approximate a rpc model, and then use our filters to produce a kmz // and MapFile products. // Note that the \doxygen{otb}{KmzProductWriter} and the // \doxygen{otb}{MapFileProductWriter} can only process inputs with a // non empty geographical information. // // The first step toward the use of these filters is to include the // proper header files: the one for the rpc sensor estimation filter and // the one defining the procedure for creating kmz files and finally // the header concerning the MapProduct writer. // // Software Guide : EndLatex #include "otbMacro.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" // Software Guide : BeginCodeSnippet #include "otbKmzProductWriter.h" #include "otbMapFileProductWriter.h" #include "otbGCPsToRPCSensorModelImageFilter.h" // Software Guide : EndCodeSnippet // int main(int argc, char* argv[]) { if (argc < 6) { std::cerr << "Usage: " << argv[0] << " infname outfname kmzFileName " <<"a1x a1y b1x b1y b1z ... aNx aNy aNz bNx bNy bNz" << std::endl; return EXIT_FAILURE; } else if ((argc - 7) % 5 != 0) { std::cerr << "Inconsistent GCPs description!" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // We will start by defining the types for the image and the image file // reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); otb::DEMHandler::Instance()->OpenDEMDirectory(argv[6]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now proceed to declare the type for the rpc sensor model // estimation filter. The class \doxygen{otb}{GGCPToRPCSensorModelImageFilter} is // templated over the input image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::GCPsToRPCSensorModelImageFilter GCPsToSensorModelFilterType; typedef GCPsToSensorModelFilterType::Point2DType Point2DType; typedef GCPsToSensorModelFilterType::Point3DType Point3DType; GCPsToSensorModelFilterType::Pointer rpcEstimator = GCPsToSensorModelFilterType::New(); rpcEstimator->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet unsigned int nbGCPs = (argc - 6) / 5; std::cout << "Receiving " << nbGCPs << " from command line." << std::endl; for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { // Software Guide : BeginLatex // // Here, we set all the Ground Control Points associated to the image // indexes. This is the entry of the rpc sensor model // estimator. Every time a GCP is added, the output image information // or its keywordlist is updated. In general, a dozen of GCPs are // needed to estimate an accurate sensor model. The points are added // via the method AddGCP(PointType2D, PointType3D). The outpput image // obtained have the needed meta-data information for the rest of the // process. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet Point2DType sensorPoint; sensorPoint[0] = atof(argv[7 + gcpId * 5]); sensorPoint[1] = atof(argv[8 + gcpId * 5]); Point3DType geoPoint; geoPoint[0] = atof(argv[9 + 5 * gcpId]); geoPoint[1] = atof(argv[10 + 5 * gcpId]); geoPoint[2] = atof(argv[11+ 5 * gcpId]); rpcEstimator->AddGCP(sensorPoint, geoPoint); // Software Guide : EndCodeSnippet std::cout << "Adding GCP sensor: " << sensorPoint << " <-> geo: " << geoPoint << std::endl; } rpcEstimator->GetOutput()->UpdateOutputInformation(); std::cout << "Residual ground error: " << rpcEstimator->GetRMSGroundError() << std::endl; // Software Guide : BeginLatex // // The last step of the chain, is to export the image to a Google // Earth understandable format using the KmzProductWriter. Note that // the writer can add legends via the method // AddLegend(std::string description, ImageType * legend) and a logo in // the kmz using SetLogo(ImageType*). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::KmzProductWriter KmzProductWriterType; KmzProductWriterType::Pointer kmzWriter = KmzProductWriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we trigger the kmz writing by calling the \code{Update()} // method on the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet kmzWriter->SetInput(rpcEstimator->GetOutput()); kmzWriter->SetPath(argv[2]); kmzWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The Mapfile is the heart of MapServer. It defines the relationships // between objects, points MapServer (http://mapserver.org/) to where // data are located and defines how things are to be drawn. The class // \doxygen{otb}{MapFileProductWriter} allow producing the mapserver // configuration file, the tiles to draw, and shapefiles describing // the tiles and where to find them. // The Mapfile writer allow setting the complete path to the mapfile // via SetFileName(std::string), the path where to store the tiles via // the method SetShapeIndexPath() and finally the path to the cgi-bin // to use via the method SetGCIPath(). // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MapFileProductWriter MapFileProductWriterType; MapFileProductWriterType::Pointer mapWriter = MapFileProductWriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The user can also specify a Spatial Reference System Identifier // (SRID) to choose his projection. In this example we choose WGS84 to // project our datas in. The SRID relative to WGS84 is 4326. // Finally, we trigger the MapFile writing by calling the // \code{Update()} method on the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet mapWriter->SetInput(rpcEstimator->GetOutput()); mapWriter->SetFileName(argv[3]); mapWriter->SetShapeIndexPath(argv[4]); mapWriter->SetCGIPath(argv[5]); mapWriter->SetSRID(4326); mapWriter->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/MetadataExample.cxx000066400000000000000000000141311301006202600212630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // SoftwareGuide: BeginLatex // // This example illustrates the access to metadata image information // with OTB. By metadata, we mean data which is typically stored with // remote sensing images, like geographical coordinates of pixels, // pixel spacing or resolution, etc. Of course, the availability of // these data depends on the image format used and on the fact that // the image producer must fill the available metadata fields. The // image formats which typically support metadata are for example // CEOS and GeoTiff. // // The metadata support is embedded in OTB's IO functionnalities and // is accessible through the \doxygen{otb}{Image} and // \doxygen{otb}{VectorImage} classes. You should avoid using the // \doxygen{itk}{Image} class if you want to have metadata support. // // SoftwareGuide: EndLatex #include "itkMacro.h" #include #include #include #include "otbImage.h" #include "otbImageFileReader.h" int main(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputAsciiFilename = argv[2]; // SoftwareGuide: BeginLatex // // This simple example will consist on reading an image from a file // and writing the metadata to an output ASCII file. As usual we // start by defining the types needed for the image to be read. // // SoftwareGuide: EndLatex // SoftwareGuide : BeginCodeSnippet typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; // SoftwareGuide : EndCodeSnippet // SoftwareGuide: BeginLatex // // We can now instantiate the reader and get a pointer to the input image. // // SoftwareGuide: EndLatex // SoftwareGuide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); InputImageType::Pointer image = InputImageType::New(); reader->SetFileName(inputFilename); reader->Update(); image = reader->GetOutput(); // SoftwareGuide : EndCodeSnippet // SoftwareGuide: BeginLatex // // Once the image has been read, we can access the metadata // information. We will copy this information to an ASCII file, so we // create an output file stream for this purpose. // // SoftwareGuide: EndLatex // SoftwareGuide : BeginCodeSnippet std::ofstream file; file.open(outputAsciiFilename); // SoftwareGuide : EndCodeSnippet // SoftwareGuide: BeginLatex // // We can now call the different available methods for accessing the // metadata. Useful methods are : // \begin{itemize} // \item \code{GetSpacing}: the sampling step; // \item \code{GetOrigin}: the coordinates of the origin of the image; // \item \code{GetProjectionRef}: the image projection reference; // \item \code{GetGCPProjection}: the projection for the eventual // ground control points; // \item \code{GetGCPCount}: the number of GCPs available; // \end{itemize} // // SoftwareGuide: EndLatex // SoftwareGuide : BeginCodeSnippet file << "Spacing " << image->GetSpacing() << std::endl; file << "Origin " << image->GetOrigin() << std::endl; file << "Projection REF " << image->GetProjectionRef() << std::endl; file << "GCP Projection " << image->GetGCPProjection() << std::endl; unsigned int GCPCount = image->GetGCPCount(); file << "GCP Count " << image->GetGCPCount() << std::endl; // SoftwareGuide : EndCodeSnippet // SoftwareGuide: BeginLatex // // One can also get the GCPs by number, as well as their coordinates // in image and geographical space. // // SoftwareGuide: EndLatex // SoftwareGuide : BeginCodeSnippet for (unsigned int GCPnum = 0; GCPnum < GCPCount; GCPnum++) { file << "GCP[" << GCPnum << "] Id " << image->GetGCPId(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Info " << image->GetGCPInfo(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Row " << image->GetGCPRow(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Col " << image->GetGCPCol(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] X " << image->GetGCPX(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Y " << image->GetGCPY(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Z " << image->GetGCPZ(GCPnum) << std::endl; file << "----------------" << std::endl; } // SoftwareGuide : EndCodeSnippet // SoftwareGuide: BeginLatex // // If a geographical transformation is available, it can be recovered // as follows. // // SoftwareGuide: EndLatex // SoftwareGuide : BeginCodeSnippet InputImageType::VectorType tab = image->GetGeoTransform(); file << "Geo Transform " << std::endl; for (unsigned int i = 0; i < tab.size(); ++i) { file << " " << i << " -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetUpperLeftCorner(); file << "Corners " << std::endl; for (unsigned int i = 0; i < tab.size(); ++i) { file << " UL[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetUpperRightCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " UR[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetLowerLeftCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " LL[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetLowerRightCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " LR[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); file.close(); // SoftwareGuide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/MultibandImageReadWrite.cxx000066400000000000000000000116741301006202600227310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The \doxygen{otb}{Image} class with a vector pixel type could be // used for representing multispectral images, with one band per // vector component, however, this is not a practical way, since the // dimensionality of the vector must be known at compile time. OTB // offers the \doxygen{otb}{VectorImage} where the dimensionality of // the vector stored for each pixel can be chosen at runtime. This is // needed for the image file readers in order to dynamically set the // number of bands of an image read from a file. // // The OTB Readers and Writers are able to deal with // \doxygen{otb}{VectorImage}s transparently for the user. // // The first step for performing reading and writing is to include the // following headers. // // \index{otb::ImageFileReader} // \index{otb::ImageFileReader!header} // // \index{otb::ImageFileWriter} // \index{otb::ImageFileWriter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbVectorImage.h" int main(int argc, char * argv[]) { // Verify the number of parameters in the command line if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then, as usual, a decision must be made about the type of pixel used to // represent the image processed by the pipeline. The pixel type // corresponds to the scalar type stored in the vector // components. Therefore, for a multiband Pl\'eiades image we will // do: // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short PixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the types of the reader and writer. These two // classes are parameterized over the image type. // // \index{otb::ImageFileReader!Instantiation} // \index{otb::ImageFileWriter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we create one object of each type using the New() method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // \index{otb::ImageFileReader!New()} // \index{otb::ImageFileWriter!New()} // \index{otb::ImageFileReader!SmartPointer} // \index{otb::ImageFileWriter!SmartPointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Here we recover the file names from the command line arguments // const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // The name of the file to be read or written is passed with the // SetFileName() method. // // \index{otb::ImageFileReader!SetFileName()} // \index{otb::ImageFileWriter!SetFileName()} // \index{SetFileName()!otb::ImageFileReader} // \index{SetFileName()!otb::ImageFileWriter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now connect these readers and writers to filters to create a // pipeline. The only thig to take care of is, when executing the // program, choosing an output image file format which supports // multiband images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/OGRWrappersExample.cxx000066400000000000000000000320711301006202600217210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Starting with the version 3.14.0 of the OTB library, a wrapper around OGR API // is provided. The purposes of the wrapper are: // \begin{itemize} // \item to permit OTB to handle very large vector data sets; // \item and to offer a modern (in the // \href{http://en.wikipedia.org/wiki/RAII}{RAII} sense) interface to handle // vector data. // \end{itemize} // // As OGR already provides a rich set of geometric related data, as well as the // algorithms to manipulate and serialize them, we've decided to wrap it into a // new \emph{exception-safe} interface. // // This example illustrates the use of OTB's OGR wrapper framework. This // program takes a source of polygons (a shape file for instance) as input and // produces a datasource of multi-polygons as output. // // We will start by including the header files for the OGR wrapper classes, // plus other header files that are out of scope here. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbOGRDataSourceWrapper.h" // Software Guide : EndCodeSnippet #include // EXIT_* // Software Guide : BeginLatex // // The following declarations will permit to merge the // \subdoxygen{otb}{ogr}{Field}s from each \subdoxygen{otb}{ogr}{Feature} into // list-fields. We'll get back to this point later. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include #include #include #include "otbJoinContainer.h" typedef std::vector IntList_t; typedef std::vector StringList_t; typedef std::vector RealList_t; // TODO: handle non recognized fields typedef boost::variant AnyListField_t; typedef std::vector AnyListFieldList_t; AnyListFieldList_t prepareNewFields( OGRFeatureDefn /*const*/& defn, otb::ogr::Layer & destLayer); void printField( otb::ogr::Field const& field, AnyListField_t const& newListField); void assignField( otb::ogr::Field field, AnyListField_t const& newListFieldValue); void pushFieldsToFieldLists( otb::ogr::Feature const& inputFeature, AnyListFieldList_t & field); // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputFile outputFile" << std::endl; return EXIT_FAILURE; } try { // Software Guide : BeginLatex // // We caw now instantiate first the input \subdoxygen{otb}{ogr}{DataSource}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::ogr::DataSource::Pointer source = otb::ogr::DataSource::New( argv[1], otb::ogr::DataSource::Modes::Read); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And then, we can instantiate the output \subdoxygen{otb}{ogr}{DataSource} and // its unique \subdoxygen{otb}{ogr}{Layer} multi-polygons. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::ogr::DataSource::Pointer destination = otb::ogr::DataSource::New( argv[2], otb::ogr::DataSource::Modes::Update_LayerCreateOnly); otb::ogr::Layer destLayer = destination->CreateLayer( argv[2], ITK_NULLPTR, wkbMultiPolygon); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The data obtained from the reader mimics the interface of // \code{OGRDataSource}. To access the geometric objects stored, we need first // to iterate on the \subdoxygen{otb}{ogr}{Layer}s from the // \subdoxygen{otb}{ogr}{DataSource}, then on the \subdoxygen{otb}{ogr}{Feature} // from each layer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // for (auto const& inputLayer : *source) for (otb::ogr::DataSource::const_iterator lb=source->begin(), le=source->end() ; lb != le ; ++lb) { otb::ogr::Layer const& inputLayer = *lb; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In this example we will only read polygon objects from the input // file before writing them to the output file. As all features from a // layer share the same geometric type, we can filter on the layer // geometric type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (inputLayer.GetGeomType() != wkbPolygon) { std::cout << "Warning: Ignoring layer: "; inputLayer.PrintSelf(std::cout, 2); continue; // skip to next layer } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In order to prepare the fields for the new layer, we first need to extract // the fields definition from the input layer in order to deduce the new fields // of the result layer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OGRFeatureDefn & sourceFeatureDefn = inputLayer.GetLayerDefn(); AnyListFieldList_t fields = prepareNewFields(sourceFeatureDefn, destLayer); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The result layer will contain only one feature, per input layer, that stores // a multi-polygon shape. All geometric shapes are plain \code{OGRGeometry} // objects. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OGRMultiPolygon destGeometry; // todo: use UniqueGeometryPtr // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The transformation algorithm is as simple as aggregating all the polygons // from the features from the input layer into the destination multi-polygon // geometric object. // // Note that \subdoxygen{otb}{ogr}{Feature}\code{::GetGeometry()} provides a // direct access to a non-mutable \code{OGRGeometry} pointer and that // \code{OGRGeometryCollection::addGeometry()} copies the received pointer. As // a consequence, the following code is optimal regarding the geometric objects // manipulated. // // This is also at this point that we fetch the field values from the input // features to accumulate them into the \code{fields} list. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // for (auto const& inputFeature : inputLayer) for (otb::ogr::Layer::const_iterator fb=inputLayer.begin(), fe=inputLayer.end() ; fb != fe ; ++fb) { otb::ogr::Feature const& inputFeature = *fb; destGeometry.addGeometry(inputFeature.GetGeometry()); pushFieldsToFieldLists(inputFeature,fields); } // for each feature // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then the new geometric object can be added to a new feature, that will be // eventually added to the destination layer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::ogr::Feature newFeature(destLayer.GetLayerDefn()); newFeature.SetGeometry(&destGeometry); // SetGeom -> copies // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set here the fields of the new feature with the ones accumulated over the // features from the input layer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (size_t i=0, N=sourceFeatureDefn.GetFieldCount(); i!=N; ++i) { printField(newFeature[i], fields[i]); assignField(newFeature[i], fields[i]); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally we add (with \subdoxygen{otb}{ogr}{Layer}\code{::CreateFeature()} // the new feature to the destination layer, and we can process the next layer // from the input datasource. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet destLayer.CreateFeature(newFeature); // adds feature to the layer } // for each layer // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } catch (std::exception const& e) { std::cerr << e.what() << "\n"; } return EXIT_FAILURE; } // Software Guide : BeginLatex // // In order to \emph{simplify} the manipulation of \subdoxygen{otb}{ogr}{Field}s // and to avoid copy-paste for each possible case of field-type, this example // relies on // \href{http://www.boost.org/doc/libs/release/doc/html/variant.html}{boost.Variant}. // // As such, we have defined \code{AnyListField\_t} as a variant type on all // possible types of field. Then, the manipulation of the variant field values is // done through the templatized functions // \subdoxygen{otb}{ogr}{Field}\code{::SetValue<>()} and // \subdoxygen{otb}{ogr}{Field}\code{::GetValue<>()}, from the various // variant-visitors. // // Before using the visitors, we need to operate a switch on the exact type of // each field from the input layers. An empty field-values container is first // added to the set of fields containers. Finally, the destination layer is // completed with a new field of the right deduced type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet AnyListFieldList_t prepareNewFields( OGRFeatureDefn /*const*/& defn, otb::ogr::Layer & destLayer) { AnyListFieldList_t fields; for (int i=0, N=defn.GetFieldCount(); i!=N; ++i) { const char* name = defn.GetFieldDefn(i)->GetNameRef(); OGRFieldType type = static_cast(-1); switch (defn.GetFieldDefn(i)->GetType()) { case OFTInteger: fields.push_back (IntList_t()); type = OFTIntegerList; break; case OFTString: fields.push_back (StringList_t()); type = OFTStringList; break; case OFTReal: fields.push_back (RealList_t()); type = OFTRealList; break; default: std::cerr << "Unsupported field type: " << OGRFieldDefn::GetFieldTypeName(defn.GetFieldDefn(i)->GetType()) << " for " << name << "\n"; break; } OGRFieldDefn newFieldDefn(name, type); // name is duplicated here => no dangling pointer destLayer.CreateField(newFieldDefn, false); } return fields; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The first visitor, \code{PushVisitor()}, takes the value from one field // and pushes it into a container of list-variant. The type of the field to // fetch is deduced from the type of the values stored in the container. It is // called by \code{pushFieldsToFieldLists()}, that for each field of the input // feature applies the visitor on the container. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet struct PushVisitor : boost::static_visitor<> { PushVisitor(otb::ogr::Field const& f) : m_f(f) {} template void operator()(T & container) const { typedef typename T::value_type value_type; value_type const value = m_f.GetValue(); container.push_back(value); } private: otb::ogr::Field const& m_f; }; void pushFieldsToFieldLists( otb::ogr::Feature const& inputFeature, AnyListFieldList_t & fields) { // For each field for (size_t i=0, N=inputFeature.GetSize(); i!=N; ++i) { otb::ogr::Field field = inputFeature[i]; boost::apply_visitor(PushVisitor(field), fields[i]); } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A second simple visitor, \code{PrintVisitor}, is defined to trace the // values of each field (which contains a list of typed data (integers, strings // or reals). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet struct PrintVisitor : boost::static_visitor<> { template void operator()(T const& container) const { otb::Join(std::cout, container, ", "); } }; void printField(otb::ogr::Field const& field, AnyListField_t const& newListField) { std::cout << field.GetName() << " -> "; boost::apply_visitor(PrintVisitor(), newListField); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The third visitor, \code{SetFieldVisitor}, sets the field of the // destination features, which have been accumulated in the list of typed // values. // // Software Guide : BeginCodeSnippet struct SetFieldVisitor : boost::static_visitor<> { SetFieldVisitor(otb::ogr::Field f) : m_f(f) {} // operator() from visitors are expected to be const template void operator()(T const& container) const { m_f.SetValue(container); } private: otb::ogr::Field mutable m_f; // this is a proxy -> a reference in a sort }; void assignField(otb::ogr::Field field, AnyListField_t const& newListFieldValue) { boost::apply_visitor(SetFieldVisitor(field), newListFieldValue); } // Software Guide : EndCodeSnippet // Software Guide : EndLatex // // Software Guide : BeginLatex // // Note that this example does not handle the case when the input layers don't // share a same fields-definition. // // Software Guide : EndLatex OTB-release-5.8/Examples/IO/RGBImageReadWrite.cxx000066400000000000000000000072421301006202600214200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // RGB images are commonly used for representing data acquired from // multispectral sensors. This example // illustrates how to read and write RGB color images to and from a file. // This requires the following headers as shown. // // \index{itk::RGBPixel!Image} // \index{RGB!writing Image} // \index{RGB!reading Image} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkRGBPixel.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { // Verify the number of parameters in the command line if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputRGBImageFile outputRGBImageFile " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The \doxygen{itk}{RGBPixel} class is templated over the type used to // represent each one of the red, green and blue components. A typical // instantiation of the RGB image class might be as follows. // // \index{itk::RGBPixel!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RGBPixel PixelType; typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image type is used as a template parameter to instantiate // the reader and writer. // // \index{otb::ImageFileReader!RGB Image} // \index{otb::ImageFileWriter!RGB Image} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // The filenames of the input and output files must be provided to the // reader and writer respectively. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet ImageType::Pointer image = reader->GetOutput(); writer->SetInput(image); // Software Guide : BeginLatex // // Finally, execution of the pipeline can be triggered by invoking the // \code{Update()} method in the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // You may have noticed that apart from the declaration of the // \code{PixelType} there is nothing in this code that is specific for RGB // images. All the actions required to support color images are implemented // internally in the \doxygen{itk}{ImageIO} objects. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/StreamingImageReadWrite.cxx000066400000000000000000000144301301006202600227340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // As we have seen, the reading of images is managed by the class \doxygen{otb}{ImageFileReader} // while writing is performed by the class // \doxygen{otb}{ImageFileWriter}. ITK's pipeline implements // streaming. That means that a filter for which the // \code{ThreadedGenerateData} method is implemented, will only produce the // data for the region requested by the following filter in the // pipeline. Therefore, in order to use the streaming functionality // one needs to use a filter at the end of the pipeline which // requests for adjacent regions of the image to be processed. In // ITK, the \doxygen{itk}{StreamingImageFilter} class is used for // this purpose. However, ITK does not implement streaming from/to // files. This means that even if the pipeline has a small memory // footprint, the images have to be stored in memory at least after // the read operation and before the write operation. // // OTB implements read/write streaming. For the image file reading, // this is transparent for the programmer, and if a streaming loop is // used at the end of the pipeline, the read operation will be // streamed. For the file writing, the // \doxygen{otb}{ImageFileWriter} has to be used. // // The first step for performing streamed reading and writing is to include the // following headers. // // \index{otb::ImageFileReader} // \index{otb::ImageFileReader!header} // // \index{otb::ImageFileWriter} // \index{otb::ImageFileWriter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" int main(int argc, char * argv[]) { // Verify the number of parameters in the command line if (argc < 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Then, as usual, a decision must be made about the type of pixel used to // represent the image processed by the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the types of the reader and writer. These two // classes are parameterized over the image type. We will rescale // the intensities of the as an example of intermediate processing step. // // \index{otb::ImageFileWriter!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we create one object of each type using the New() method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // \index{otb::ImageFileReader!New()} // \index{otb::ImageFileWriter!New()} // \index{otb::StreamingImageFileReader!SmartPointer} // \index{otb::ImageFileWriter!SmartPointer} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); RescalerType::Pointer rescaler = RescalerType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Here we recover the file names from the command line arguments // const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // The name of the file to be read or written is passed with the // SetFileName() method. We also choose the range of intensities // for the rescaler. // // \index{otb::ImageFileReader!SetFileName()} // \index{otb::ImageFileWriter!SetFileName()} // \index{SetFileName()!otb::ImageFileReader} // \index{SetFileName()!otb::ImageFileWriter} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(inputFilename); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now connect these readers and writers to filters to create a // pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rescaler->SetInput(reader->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now trigger the pipeline execution by calling the // \code{Update} method on the writer. // // Software Guide : EndLatex try { // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The writer will ask its preceding filter to provide different // portions of the image. Each filter in the pipeline will do the // same until the request arrives to the reader. In this way, the // pipeline will be executed for each requested region and the // whole input image will be read, processed and written without // being fully loaded in memory. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/TileMapImageIOExample.cxx000066400000000000000000000203511301006202600222720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {osmfile.otb} // OUTPUTS: {openStreetMap-Toulouse.png} // ${GeneratedFolder} 1.4835345 43.55968261 13 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {osmfile.otb} // OUTPUTS: {openStreetMap-Singapore.png} // ${GeneratedFolder} 103.780646 1.297643 13 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // First, we need to include several headers. There will be a bit of // manual work going on here. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkRGBPixel.h" #include "otbImageFileReader.h" #include "otbTileMapImageIO.h" #include "otbInverseSensorModel.h" #include "otbForwardSensorModel.h" #include "otbExtractROI.h" #include "otbImageFileWriter.h" #include "otbTileMapTransform.h" #include "otbWorldFile.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 7) { std::cout << argv[0] << " " << " " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // We retrieve the input parameters: // \begin{itemize} // \item the input filename is a simple text file specifying the access // modality to open street map data; // \item the output file is the image where you want to save the result; // \item the cache directory is necessary to keep the data retrieved from // the internet. It can also be reused to minimize network access; // \item longitude of the center of the scene; // \item latitude of the center of the scene; // \item depth which is inversely related to the resolution: when you increase // the depth by one, you divide the resolution by two. // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::string inputFilename = argv[1]; std::string outputFilename = argv[2]; std::string cacheDirectory = argv[3]; double lon = atof(argv[4]); double lat = atof(argv[5]); int depth = atoi(argv[6]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now instantiate the reader. As some parameters need to be given to the // IO which is an \doxygen{otb}{TileMapImageIO}, we need to manually create it: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::TileMapImageIO ImageIOType; ImageIOType::Pointer tileIO = ImageIOType::New(); ReaderType::Pointer readerTile = ReaderType::New(); tileIO->SetDepth(depth); tileIO->SetCacheDirectory(cacheDirectory); readerTile->SetImageIO(tileIO); readerTile->SetFileName(inputFilename); readerTile->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we potentially have an image of several Peta-Bytes covering the whole world // in the reader // that's why we don't want to do an update before extracting a specific // area. // // The coordinates are referred with an origin at the North Pole and the // change date meridian in Mercator projection. So we need to translate the latitude // and the longitude in this funny coordinate system: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::TileMapTransform TransformType; TransformType::Pointer transform = TransformType::New(); transform->SetDepth(depth); typedef itk::Point PointType; PointType lonLatPoint; lonLatPoint[0] = lon; lonLatPoint[1] = lat; PointType tilePoint; tilePoint = transform->TransformPoint(lonLatPoint); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // This enables us to use the \doxygen{otb}{ExtractROI} to retrieve only // the area of interest and to avoid crashing our memory-limited computer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet long int startX = static_cast(tilePoint[0]); long int startY = static_cast(tilePoint[1]); long int sizeX = 500; long int sizeY = 500; std::cerr << startX << ", " << startY << std::endl; std::cerr << sizeX << ", " << sizeY << std::endl; typedef otb::ExtractROI ExtractROIFilterType; ExtractROIFilterType::Pointer extractROIOsmFilter = ExtractROIFilterType::New(); extractROIOsmFilter->SetStartX(startX - sizeX / 2); extractROIOsmFilter->SetStartY(startY - sizeY / 2); extractROIOsmFilter->SetSizeX(sizeX); extractROIOsmFilter->SetSizeY(sizeY); extractROIOsmFilter->SetInput(readerTile->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we just plug this to the writer to save our nice map of // the area: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(extractROIOsmFilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also want to create the associated world file to be able to use this // new image in a GIS system. For this, we need to compute the coordinates // of the top left corner and the spacing in latitude and longitude. // // For that, we use the inverse transform to convert the corner coordinates into // latitude and longitude. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::TileMapTransform InverseTransformType; InverseTransformType::Pointer transformInverse = InverseTransformType::New(); transformInverse->SetDepth(depth); double lonUL, latUL, lonSpacing, latSpacing; tilePoint[0] = startX - sizeX / 2; tilePoint[1] = startY - sizeY / 2; lonLatPoint = transformInverse->TransformPoint(tilePoint); lonUL = lonLatPoint[0]; latUL = lonLatPoint[1]; tilePoint[0] = startX + sizeX / 2; tilePoint[1] = startY + sizeY / 2; lonLatPoint = transformInverse->TransformPoint(tilePoint); lonSpacing = (lonLatPoint[0] - lonUL) / (sizeX - 1); latSpacing = (lonLatPoint[1] - latUL) / (sizeY - 1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now that we have all the information, we can write the world file // which has the wld extension. This is a simple text file containing // the coordinates of the center of the top left pixel and the x and y // spacing. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::WorldFile::Pointer worldFile = otb::WorldFile::New(); worldFile->SetImageFilename(outputFilename); worldFile->SetLonOrigin(lonUL); worldFile->SetLatOrigin(latUL); worldFile->SetLonSpacing(lonSpacing); worldFile->SetLatSpacing(latSpacing); worldFile->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:TILEMAPIMAGEIOEXAMPLE} shows the output images created from // open street map data. // // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{openStreetMap-Toulouse.eps} // \includegraphics[width=0.45\textwidth]{openStreetMap-Singapore.eps} // \itkcaption[Open street map]{Map created from open street map showing the OTB headquarters} // \label{fig:TILEMAPIMAGEIOEXAMPLE} // \end{figure} // // If your street is missing, go and improve the map by adding it yourself. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/IO/VectorDataIOExample.cxx000066400000000000000000000175401301006202600220360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Unfortunately, many vector data formats do not // share the models for the data they represent. However, in some // cases, when simple data is stored, it can be decomposed in simple // objects as for instance polylines, polygons and points. This is // the case for the Shapefile and the KML (Keyhole Markup Language) formats, // for instance. // // Even though specific reader/writer for Shapefile and the Google KML // are available in OTB, we designed a generic approach for the IO of // this kind of data. // The reader/writer for VectorData in OTB is able to access a variety of // vector file formats (all OGR supported formats) // // In section \ref{sec:VectorDataProjection}, you will find more information on // how projections work for the vector data and how you can export // the results obtained with OTB to the real world. // // This example illustrates the use of OTB's vector data IO // framework. // // We will start by including the header files for the classes // describing the vector data and the corresponding reader and writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will also need to include the header files for the classes // which model the individual objects that we get from the vector // data structure. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkPreOrderTreeIterator.h" #include "otbObjectList.h" #include "otbPolygon.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << "inputFile outputFile" << std::endl; return EXIT_FAILURE; } typedef unsigned short int PixelType; // Software Guide : BeginLatex // // We define the types for the vector data structure and the // corresponding file reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the reader and read the data. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The vector data obtained from the reader will provide a tree of // nodes containing the actual objects of the scene. This tree will // be accessed using an \doxygen{itk}{PreOrderTreeIterator}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef VectorDataType::DataTreeType DataTreeType; typedef itk::PreOrderTreeIterator TreeIteratorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In this example we will only read polygon objects from the input // file before writing them to the output file. We define the type // for the polygon object as well as an iterator to the vertices. The // polygons obtained will be stored in an \doxygen{otb}{ObjectList}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Polygon PolygonType; typedef otb::ObjectList PolygonListType; PolygonListType::Pointer polygonList = PolygonListType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the data tree and instantiate an iterator to walk through it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet TreeIteratorType it(reader->GetOutput()->GetDataTree()); it.GoToBegin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We check that the current object is a polygon using the // \code{IsPolygonFeature()} method and get its exterior ring in // order to store it into the list. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (!it.IsAtEnd()) { if (it.Get()->IsPolygonFeature()) { polygonList->PushBack(it.Get()->GetPolygonExteriorRing()); } ++it; } // Software Guide : EndCodeSnippet polygonList->PushBack(PolygonType::New()); // Software Guide : BeginLatex // // Before writing the polygons to the output file, we have to build // the vector data structure. This structure will be built up of // nodes. We define the types needed for that. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorDataType::Pointer outVectorData = VectorDataType::New(); typedef VectorDataType::DataNodeType DataNodeType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We fill the data structure with the nodes. The root node is a // document which is composed of folders. A list of polygons can be // seen as a multi polygon object. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); document->SetNodeId("polygon"); DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); DataNodeType::Pointer multiPolygon = DataNodeType::New(); multiPolygon->SetNodeType(otb::FEATURE_MULTIPOLYGON); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We assign these objects to the data tree stored by the vector data object. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet DataTreeType::Pointer tree = outVectorData->GetDataTree(); DataNodeType::Pointer root = tree->GetRoot()->Get(); tree->Add(document, root); tree->Add(folder, document); tree->Add(multiPolygon, folder); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now iterate through the polygon list and fill the vector // data structure. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (PolygonListType::Iterator pit = polygonList->Begin(); pit != polygonList->End(); ++pit) { DataNodeType::Pointer newPolygon = DataNodeType::New(); newPolygon->SetPolygonExteriorRing(pit.Get()); tree->Add(newPolygon, multiPolygon); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally we write the vector data to a file using a generic // \doxygen{otb}{VectorDataFileWriter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(outVectorData); writer->SetFileName(argv[2]); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; // Software Guide : BeginLatex // // This example can convert an ESRI Shapefile to // a MapInfo File but you can also access with the same OTB source code // to a PostgreSQL datasource, using a connection string as : // PG:"dbname='databasename' host='addr' port='5432' user='x' password='y'" // Starting with GDAL 1.6.0, the set of tables to be scanned can be overridden // by specifying tables=schema.table. // Software Guide : EndLatex } OTB-release-5.8/Examples/IO/test/000077500000000000000000000000001301006202600164625ustar00rootroot00000000000000OTB-release-5.8/Examples/IO/test/CMakeLists.txt000066400000000000000000000064521301006202600212310ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/IO) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- ExtractROITest---------- otb_add_test(NAME ioTeExtractROITest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/ROI_IMAGERY_RGB.png ${TEMP}/ROI_IMAGERY_RGB.png ${BASELINE}/ROI_IMAGERY_MIR.png ${TEMP}/ROI_IMAGERY_MIR.png Execute $ ${INPUTDATA}/IMAGERY_SSECH.tif ${TEMP}/ROI_IMAGERY_RGB.png ${TEMP}/ROI_IMAGERY_MIR.png 0 0 100 100 ) otb_add_test(NAME ioTeDEMToImageGeneratorTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_5} ${BASELINE}/DEMToImageGenerator.tif ${TEMP}/DEMToImageGenerator.tif Execute $ ${TEMP}/DEMToImageGenerator.tif ${TEMP}/pretty_DEMToImageGenerator.png 6.5 45.5 500 500 0.002 -0.002 ${INPUTDATA}/DEM_srtm ) otb_add_test(NAME prTeDEMHandlerExampleTest COMMAND ${OTB_TEST_DRIVER} Execute $ ${INPUTDATA}/DEM_srtm ${INPUTDATA}/DEM_srtm/egm96.grd 40 8.434583 44.647083 383.580313671 0.001 ) if(OTBlibkml_LOADED) otb_add_test(NAME ioTeImageToKmzAndMapFileProductExample COMMAND ${OTB_TEST_DRIVER} Execute $ ${OTB_DATA_ROOT}/Input/Haiti1_sr10.jpeg ${TEMP}/ioTeHaitiKmzProduct.kmz ${TEMP}/mapserverExample/ioTeHaitiMapFileProduct.map ${TEMP}/mapserverExample/shapeindex http://localhost/cgi-bin/mapserv ${INPUTDATA}/DEM_srtm 198.000000 199.000000 -72.351257 18.555075 0.000000 196.000000 194.000000 -72.352051 18.556946 0.000000 208.000000 157.000000 -72.346130 18.574358 0.000000 215.000000 143.000000 -72.342377 18.580441 0.000000 243.000000 141.000000 -72.328964 18.581335 0.000000 256.000000 93.000000 -72.322571 18.602974 0.000000 349.000000 140.000000 -72.278343 18.580887 0.000000 289.000000 144.000000 -72.306908 18.579464 0.000000 210.000000 247.000000 -72.345741 18.532839 0.000000 194.000000 247.000000 -72.353317 18.532595 0.00000 164.000000 241.000000 -72.367691 18.535810 0.000000 144.000000 245.000000 -72.377457 18.534243 0.000000 69.000000 201.000000 -72.413315 18.554974 0.000000 74.000000 237.000000 -72.410934 18.538496 0.000000 86.000000 280.000000 -72.405739 18.518456 0.000000 193.000000 286.000000 -72.353920 18.515240 0.000000 334.000000 282.000000 -72.286240 18.515160 0.000000 373.000000 177.000000 -72.267570 18.563681 0.000000 368.000000 158.000000 -72.269203 18.572529 0.000000 350.000000 93.000000 -72.282402 18.602425 0.000000 343.000000 86.000000 -72.280792 18.605862 0.000000 282.000000 71.000000 -72.309692 18.613203 0.000000 189.000000 36.000000 -72.354301 18.629776 0.000000 399.000000 264.000000 -72.255020 18.523664 0.000000 42.000000 232.000000 -72.426552 18.540876 0.000000 ) set_property(TEST ioTeImageToKmzAndMapFileProductExample PROPERTY RESOURCE_LOCK web_access) endif() otb_add_test(NAME ioTeTileMapImageIOExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image 10.0 ${BASELINE}/openStreetMap.png ${TEMP}/openStreetMap.png Execute $ ${INPUTDATA}/osmfile.otb ${TEMP}/openStreetMap.png ${TEMP} 1.4835345 43.55968261 12 ) OTB-release-5.8/Examples/Installation/000077500000000000000000000000001301006202600176355ustar00rootroot00000000000000OTB-release-5.8/Examples/Installation/CMakeLists.txt000066400000000000000000000002611301006202600223740ustar00rootroot00000000000000project(InstallationExamples) add_executable(HelloWorld HelloWorld.cxx) target_link_libraries(HelloWorld ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Installation/HelloWorld.cxx000066400000000000000000000031341301006202600224350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The following code is an implementation of a small OTB // program. It tests including header files and linking with OTB // libraries. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include int main() { typedef otb::Image ImageType; ImageType::Pointer image = ImageType::New(); std::cout << "OTB Hello World !" << std::endl; return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // This code instantiates an image whose pixels are represented with // type \code{unsigned short}. The image is then constructed and assigned to a // \doxygen{itk}{SmartPointer}. Although later in the text we will discuss // \code{SmartPointer}'s in detail, for now think of it as a handle on an // instance of an object (see section \ref{sec:SmartPointers} for more // information). The \doxygen{itk}{Image} class will be described in // Section~\ref{sec:ImageSection}. // // Software Guide : EndLatex OTB-release-5.8/Examples/Installation/test/000077500000000000000000000000001301006202600206145ustar00rootroot00000000000000OTB-release-5.8/Examples/Installation/test/CMakeLists.txt000066400000000000000000000000001301006202600233420ustar00rootroot00000000000000OTB-release-5.8/Examples/Iterators/000077500000000000000000000000001301006202600171505ustar00rootroot00000000000000OTB-release-5.8/Examples/Iterators/CMakeLists.txt000066400000000000000000000041431301006202600217120ustar00rootroot00000000000000project(IteratorsExamples) add_executable(ImageLinearIteratorWithIndex2 ImageLinearIteratorWithIndex2.cxx) target_link_libraries(ImageLinearIteratorWithIndex2 ${OTB_LIBRARIES}) add_executable(ImageLinearIteratorWithIndex ImageLinearIteratorWithIndex.cxx) target_link_libraries(ImageLinearIteratorWithIndex ${OTB_LIBRARIES}) add_executable(ImageRandomConstIteratorWithIndex ImageRandomConstIteratorWithIndex.cxx) target_link_libraries(ImageRandomConstIteratorWithIndex ${OTB_LIBRARIES}) add_executable(ImageRegionIterator ImageRegionIterator.cxx) target_link_libraries(ImageRegionIterator ${OTB_LIBRARIES}) add_executable(ImageRegionIteratorWithIndex ImageRegionIteratorWithIndex.cxx) target_link_libraries(ImageRegionIteratorWithIndex ${OTB_LIBRARIES}) add_executable(ImageSliceIteratorWithIndex ImageSliceIteratorWithIndex.cxx) target_link_libraries(ImageSliceIteratorWithIndex ${OTB_LIBRARIES}) add_executable(IteratorsExamples IteratorsExamples.cxx) target_link_libraries(IteratorsExamples ${OTB_LIBRARIES}) add_executable(NeighborhoodIterators1 NeighborhoodIterators1.cxx) target_link_libraries(NeighborhoodIterators1 ${OTB_LIBRARIES}) add_executable(NeighborhoodIterators2 NeighborhoodIterators2.cxx) target_link_libraries(NeighborhoodIterators2 ${OTB_LIBRARIES}) add_executable(NeighborhoodIterators3 NeighborhoodIterators3.cxx) target_link_libraries(NeighborhoodIterators3 ${OTB_LIBRARIES}) add_executable(NeighborhoodIterators4 NeighborhoodIterators4.cxx) target_link_libraries(NeighborhoodIterators4 ${OTB_LIBRARIES}) add_executable(NeighborhoodIterators5 NeighborhoodIterators5.cxx) target_link_libraries(NeighborhoodIterators5 ${OTB_LIBRARIES}) add_executable(NeighborhoodIterators6 NeighborhoodIterators6.cxx) target_link_libraries(NeighborhoodIterators6 ${OTB_LIBRARIES}) add_executable(ShapedNeighborhoodIterators1 ShapedNeighborhoodIterators1.cxx) target_link_libraries(ShapedNeighborhoodIterators1 ${OTB_LIBRARIES}) add_executable(ShapedNeighborhoodIterators2 ShapedNeighborhoodIterators2.cxx) target_link_libraries(ShapedNeighborhoodIterators2 ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Iterators/ImageLinearIteratorWithIndex.cxx000066400000000000000000000170361301006202600254160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The \doxygen{itk}{ImageLinearIteratorWithIndex} is designed for line-by-line // processing of an image. It walks a linear path along a selected image // direction parallel to one of the coordinate axes of the image. This // iterator conceptually breaks an image into a set of parallel lines // that span the selected image dimension. // // \index{Iterators!and image lines} // // Like all image iterators, movement of the // ImageLinearIteratorWithIndex is constrained within an // image region $R$. The line $\ell$ through which the iterator moves is // defined by selecting a direction and an origin. The line $\ell$ // extends from the origin to the upper boundary of $R$. The origin can be // moved to any position along the lower boundary of $R$. // // Several additional methods are defined for this iterator to control movement // of the iterator along the line $\ell$ and movement of the origin of $\ell$. // // %Might need a figure here to describe this iterator. // // \begin{itemize} // // \index{itk::ImageLinearIteratorWithIndex!NextLine()} // // \item \textbf{\code{NextLine()}} Moves the iterator to the beginning pixel // location of the next line in the image. The origin of the next line is // determined by incrementing the current origin along the fastest increasing // dimension of the subspace of the image that excludes the selected dimension. // // // \index{itk::ImageLinearIteratorWithIndex!PreviousLine()} // // \item \textbf{\code{PreviousLine()}} Moves the iterator to the \emph{last valid // pixel location} in the previous line. The origin of the previous line is // determined by decrementing the current origin along the fastest increasing // dimension of the subspace of the image that excludes the selected dimension. // // \index{itk::ImageLinearIteratorWithIndex!GoToBeginOfLine()} // \index{itk::ImageLinearIteratorWithIndex!GoToReverseBeginOfLine()} // // \item \textbf{\code{GoToBeginOfLine()}} Moves the iterator to the beginning // pixel of the current line. // // \item \textbf{\code{GoToEndOfLine()}} Move the iterator to // \emph{one past} the last valid pixel of the current line. // // // \index{itk::ImageLinearIteratorWithIndex!IsAtReverseEndOfLine()} // \index{itk::ImageLinearIteratorWithIndex!IsAtEndOfLine()} // // \item \textbf{\code{IsAtReverseEndOfLine()}} // Returns true if the iterator points // to \emph{one position before} the beginning pixel of the current line. // // \item \textbf{\code{IsAtEndOfLine()}} // Returns true if the iterator points to // \emph{one position past} the last valid pixel of the current line. // \end{itemize} // // The following code example shows how to use the // ImageLinearIteratorWithIndex. It implements the same algorithm as // in the previous example, flipping an image across its $x$-axis. Two line // iterators are iterated in opposite directions across the $x$-axis. // After each line is traversed, the iterator origins are stepped along // the $y$-axis to the // next line. // // \index{itk::ImageLinearIteratorWithIndex!example of using|(} // // Headers for both the const and non-const versions are needed. // // Software Guide : EndLatex #include "otbImage.h" #include "itkRGBPixel.h" // Software Guide : BeginCodeSnippet #include "itkImageLinearIteratorWithIndex.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { // Verify the number of parameters on the command line. if (argc < 3) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile" << std::endl; return -1; } // Software Guide : BeginLatex // // The RGB image and pixel types are defined as in the previous example. The // ImageLinearIteratorWithIndex class and its const version each have // single template parameters, the image type. // // Software Guide : EndLatex const unsigned int Dimension = 2; typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; // Software Guide : BeginCodeSnippet typedef itk::ImageLinearIteratorWithIndex IteratorType; typedef itk::ImageLinearConstIteratorWithIndex ConstIteratorType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ImageType::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); inputImage = reader->GetOutput(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught a !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // After reading the input image, we allocate an output image that of the same // size, spacing, and origin. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer outputImage = ImageType::New(); outputImage->SetRegions(inputImage->GetRequestedRegion()); outputImage->CopyInformation(inputImage); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we create the two iterators. The const iterator walks the input image, // and the non-const iterator walks the output image. The iterators are // initialized over the same region. The direction of iteration is set to 0, // the $x$ dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConstIteratorType inputIt(inputImage, inputImage->GetRequestedRegion()); IteratorType outputIt(outputImage, inputImage->GetRequestedRegion()); inputIt.SetDirection(0); outputIt.SetDirection(0); // Software Guide : EndCodeSnippet // Software Guide: BeginLatex // // Each line in the input is copied to the output. The input iterator moves // forward across columns while the output iterator moves backwards. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); outputIt.NextLine(), inputIt.NextLine()) { inputIt.GoToBeginOfLine(); outputIt.GoToEndOfLine(); --outputIt; while (!inputIt.IsAtEndOfLine()) { outputIt.Set(inputIt.Get()); ++inputIt; --outputIt; } } // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(outputImage); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // Running this example on \code{ROI\_QB\_MUL\_1.tif} produces // the same output image shown in // Figure~\ref{fig:ImageRegionIteratorWithIndexExample}. // // \index{itk::ImageLinearIteratorWithIndex!example of using|)} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/ImageLinearIteratorWithIndex2.cxx000066400000000000000000000130651301006202600254760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example shows how to use the \doxygen{itk}{ImageLinearIteratorWithIndex} for // computing the mean across time of a 4D image where the first three // dimensions correspond to spatial coordinates and the fourth dimension // corresponds to time. The result of the mean across time is to be stored in a // 3D image. // // \index{Iterators!and 4D images} // \index{ImageLinearIteratorWithIndex!4D images} // // Software Guide : EndLatex #include "otbImage.h" // Software Guide : BeginCodeSnippet #include "itkImageLinearConstIteratorWithIndex.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { // Verify the number of parameters on the command line. if (argc < 3) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " input4DImageFile output3DImageFile" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // First we declare the types of the images // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; typedef otb::Image Image3DType; typedef otb::Image Image4DType; typedef otb::ImageFileReader Reader4DType; typedef otb::ImageFileWriter Writer3DType; Reader4DType::Pointer reader4D = Reader4DType::New(); reader4D->SetFileName(argv[1]); try { reader4D->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Error writing the image" << std::endl; std::cerr << excp << std::endl; return EXIT_FAILURE; } Image4DType::ConstPointer image4D = reader4D->GetOutput(); Image3DType::Pointer image3D = Image3DType::New(); typedef Image3DType::IndexType Index3DType; typedef Image3DType::SizeType Size3DType; typedef Image3DType::RegionType Region3DType; typedef Image3DType::SpacingType Spacing3DType; typedef Image3DType::PointType Origin3DType; typedef Image4DType::IndexType Index4DType; typedef Image4DType::SizeType Size4DType; typedef Image4DType::SpacingType Spacing4DType; typedef Image4DType::PointType Origin4DType; Index3DType index3D; Size3DType size3D; Spacing3DType spacing3D; Origin3DType origin3D; Image4DType::RegionType region4D = image4D->GetBufferedRegion(); Index4DType index4D = region4D.GetIndex(); Size4DType size4D = region4D.GetSize(); Spacing4DType spacing4D = image4D->GetSpacing(); Origin4DType origin4D = image4D->GetOrigin(); for (unsigned int i = 0; i < 3; ++i) { size3D[i] = size4D[i]; index3D[i] = index4D[i]; spacing3D[i] = spacing4D[i]; origin3D[i] = origin4D[i]; } image3D->SetSpacing(spacing3D); image3D->SetOrigin(origin3D); Region3DType region3D; region3D.SetIndex(index3D); region3D.SetSize(size3D); image3D->SetRegions(region3D); image3D->Allocate(); typedef itk::NumericTraits::AccumulateType SumType; typedef itk::NumericTraits::RealType MeanType; const unsigned int timeLength = region4D.GetSize()[3]; typedef itk::ImageLinearConstIteratorWithIndex< Image4DType> IteratorType; IteratorType it(image4D, region4D); it.SetDirection(3); // Walk along time dimension it.GoToBegin(); while (!it.IsAtEnd()) { SumType sum = itk::NumericTraits::Zero; it.GoToBeginOfLine(); index4D = it.GetIndex(); while (!it.IsAtEndOfLine()) { sum += it.Get(); ++it; } MeanType mean = static_cast(sum) / static_cast(timeLength); index3D[0] = index4D[0]; index3D[1] = index4D[1]; index3D[2] = index4D[2]; image3D->SetPixel(index3D, static_cast(mean)); it.NextLine(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As you can see, we avoid to use a 3D iterator to walk // over the mean image. The reason is that there is no // guarantee that the 3D iterator will walk in the same // order as the 4D. Iterators just adhere to their contract // of visiting all the pixel, but do not enforce any particular // order for the visits. The linear iterator guarantees to // visit the pixels along a line of the image in the order // in which they are placed in the line, but do not states // in what order one line will be visited with respect to // other lines. Here we simply take advantage of knowing // the first three components of the 4D iterator index, // and use them to place the resulting mean value in the // output 3D image. // // Software Guide : EndLatex Writer3DType::Pointer writer3D = Writer3DType::New(); writer3D->SetFileName(argv[2]); writer3D->SetInput(image3D); try { writer3D->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Error writing the image" << std::endl; std::cerr << excp << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/ImageRandomConstIteratorWithIndex.cxx000066400000000000000000000124721301006202600264320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // \doxygen{itk}{ImageRandomConstIteratorWithIndex} was developed to randomly // sample pixel values. When incremented or decremented, it jumps to a random // location in its image region. // // \index{itk::Image\-Random\-Const\-Iterator\-With\-Index!sample size} // \index{itk::Image\-Random\-Const\-Iterator\-With\-Index!begin and end positions} // // The user must specify a sample size when creating this iterator. The sample // size, rather than a specific image index, defines the end position for the // iterator. \code{IsAtEnd()} returns // \code{true} when the current sample number equals the sample size. // \code{IsAtBegin()} returns \code{true} when the current sample number equals // zero. An important difference from other image iterators is that // ImageRandomConstIteratorWithIndex may visit the same pixel // more than once. // // \index{itk::Image\-Random\-Const\-Iterator\-With\-Index!example of using|(} // \index{itk::Image\-Random\-Const\-Iterator\-With\-Index!and statistics} // Let's use the random iterator to estimate some simple image statistics. The next // example calculates an estimate of the arithmetic mean of pixel values. // // First, include the appropriate header and declare pixel and image types. // // Software Guide : EndLatex #include "otbImage.h" // Software Guide : BeginCodeSnippet #include "itkImageRandomConstIteratorWithIndex.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { // Verify the number of parameters on the command line. if (argc < 3) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile numberOfSamples" << std::endl; return -1; } // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned short PixelType; typedef otb::Image ImageType; typedef itk::ImageRandomConstIteratorWithIndex ConstIteratorType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; ImageType::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); inputImage = reader->GetOutput(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // The input image has been read as \code{inputImage}. We now create an // iterator with a number of samples set by command line argument. The call to // \code{ReinitializeSeed} seeds the random number generator. The iterator is // initialized over the entire valid image region. // // \index{itk::Image\-Random\-Const\-Iterator\-With\-Index!SetNumberOfSamples()} // \index{itk::Image\-Random\-Const\-Iterator\-With\-Index!ReinitializeSeed()} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConstIteratorType inputIt(inputImage, inputImage->GetRequestedRegion()); inputIt.SetNumberOfSamples(::atoi(argv[2])); inputIt.ReinitializeSeed(); // Software Guide : EndCodeSnippet // Software Guide: BeginLatex // // Now take the specified number of samples and calculate their average value. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet float mean = 0.0f; for (inputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt) { mean += static_cast(inputIt.Get()); } mean = mean / ::atof(argv[2]); // Software Guide : EndCodeSnippet std::cout << "Mean estimate with " << argv[2] << " samples is " << mean << std::endl; // Software Guide : BeginLatex // // Table~\ref{fig:ImageRandomConstIteratorWithIndexExample} shows the results // of running this example on several of the data files from // \code{Examples/Data} with a range of sample sizes. // // \begin{table} // \begin{center} // \begin{tabular}[]{rc|c|c|c} // & \multicolumn{4}{c}{\emph{Sample Size}} \\ & \code{\textbf{10}} & \code{\textbf{100}} // & \code{\textbf{1000}} // & \code{\textbf{10000}} \\ \cline{2-5} // \code{RatLungSlice1.mha} & 50.5 & 52.4 & 53.0 & 52.4 \\ \code{RatLungSlice2.mha} // & 46.7 & 47.5 & 47.4 & 47.6 \\ \code{BrainT1Slice.png} // & 47.2 & 64.1 & 68.0 & 67.8 \\ \end{tabular} // \protect\label{fig:ImageRandomConstIteratorWithIndexExample} // \itkcaption[ImageRandomConstIteratorWithIndex usage]{Estimates of mean image pixel // value using the ImageRandomConstIteratorWithIndex at different sample // sizes.} // \end{center} // \end{table} // // \index{itk::Image\-Random\-Const\-Iterator\-With\-Index!example of using|)} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/ImageRegionIterator.cxx000066400000000000000000000212331301006202600235750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ImageRegionIteratorOutput.png} // 10 10 110 140 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{Iterators!speed} // The \doxygen{itk}{ImageRegionIterator} is optimized for // iteration speed and is the first choice for iterative, pixel-wise operations // when location in the image is not // important. ImageRegionIterator is the least specialized of the ITK // image iterator classes. It implements all of the methods described in the // preceding section. // // The following example illustrates the use of // \doxygen{itk}{ImageRegionConstIterator} and ImageRegionIterator. // Most of the code constructs introduced apply to other ITK iterators as // well. This simple application crops a subregion from an image by copying // its pixel values into to a second, smaller image. // // \index{Iterators!and image regions} // \index{itk::ImageRegionIterator!example of using|(} // We begin by including the appropriate header files. // Software Guide : EndLatex #include "otbImage.h" // Software Guide : BeginCodeSnippet #include "itkImageRegionIterator.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { // Verify the number of parameters on the command line. if (argc < 7) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile startX startY sizeX sizeY" << std::endl; return -1; } // Software Guide : BeginLatex // // Next we define a pixel type and corresponding image type. ITK iterator // classes expect the image type as their template parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::ImageRegionConstIterator ConstIteratorType; typedef itk::ImageRegionIterator IteratorType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : BeginLatex // // Information about the subregion to copy is read from the command line. The // subregion is defined by an \doxygen{itk}{ImageRegion} object, with a starting // grid index and a size (Section~\ref{sec:ImageSection}). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::RegionType inputRegion; ImageType::RegionType::IndexType inputStart; ImageType::RegionType::SizeType size; inputStart[0] = ::atoi(argv[3]); inputStart[1] = ::atoi(argv[4]); size[0] = ::atoi(argv[5]); size[1] = ::atoi(argv[6]); inputRegion.SetSize(size); inputRegion.SetIndex(inputStart); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The destination region in the output image is defined using the input region // size, but a different start index. The starting index for the destination // region is the corner of the newly generated image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::RegionType outputRegion; ImageType::RegionType::IndexType outputStart; outputStart[0] = 0; outputStart[1] = 0; outputRegion.SetSize(size); outputRegion.SetIndex(outputStart); // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return -1; } // Check that the region is contained within the input image. if (!reader->GetOutput()->GetRequestedRegion().IsInside(inputRegion)) { std::cerr << "Error" << std::endl; std::cerr << "The region " << inputRegion << "is not contained within the input image region " << reader->GetOutput()->GetRequestedRegion() << std::endl; return -1; } // Software Guide : BeginLatex // // After reading the input image and checking that the desired subregion is, // in fact, contained in the input, we allocate an output image. It is // fundamental to set valid values to some of the basic image information // during the copying process. // In particular, the starting index of the output region // is now filled up with zero values and the coordinates of the physical // origin are computed as a shift from the origin of the input image. This is // quite important since it will allow us to later // register the extracted region against the original image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer outputImage = ImageType::New(); outputImage->SetRegions(outputRegion); const ImageType::SpacingType& spacing = reader->GetOutput()->GetSpacing(); const ImageType::PointType& inputOrigin = reader->GetOutput()->GetOrigin(); double outputOrigin[Dimension]; for (unsigned int i = 0; i < Dimension; ++i) { outputOrigin[i] = inputOrigin[i] + spacing[i] * inputStart[i]; } outputImage->SetSpacing(spacing); outputImage->SetOrigin(outputOrigin); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \index{Iterators!construction of} \index{Iterators!and image regions} // The necessary images and region definitions are now in place. All that is // left to do is to create the iterators and perform the copy. Note that image // iterators are not accessed via smart pointers so they are light-weight // objects that are instantiated on the stack. Also notice how the input and // output iterators are defined over the \emph{same corresponding region}. Though the // images are different sizes, they both contain the same target subregion. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConstIteratorType inputIt(reader->GetOutput(), inputRegion); IteratorType outputIt(outputImage, outputRegion); for (inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt) { outputIt.Set(inputIt.Get()); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \index{Iterators!image dimensionality} // The \code{for} loop above is a common // construct in ITK/OTB. The beauty of these four lines of code is that they are // equally valid for one, two, three, or even ten dimensional data, and no // knowledge of the size of the image is necessary. Consider the ugly // alternative of ten nested \code{for} loops for traversing an image. // // Software Guide : EndLatex WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(outputImage); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return -1; } // Software Guide : BeginLatex // // Let's run this example on the image \code{QB\_Suburb.png} found // in \code{Examples/Data}. The command line arguments specify the // input and output file names, then the $x$, $y$ origin and the $x$, $y$ size // of the cropped subregion. // // \small // \begin{verbatim} // ImageRegionIterator QB_Suburb.png ImageRegionIteratorOutput.png 20 70 210 140 // \end{verbatim} // \normalsize // // The output is the cropped subregion shown in // Figure~\ref{fig:ImageRegionIteratorOutput}. // // \begin{figure} // \centering // \includegraphics[width=0.4\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.3\textwidth]{ImageRegionIteratorOutput.eps} // \itkcaption[Copying an image subregion using ImageRegionIterator]{Cropping a // region from an image. The original image is shown at left. The image on // the right is the result of applying the ImageRegionIterator example code.} // \protect\label{fig:ImageRegionIteratorOutput} // \end{figure} // // \index{itk::ImageRegionIterator!example of using|)} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/ImageRegionIteratorWithIndex.cxx000066400000000000000000000140141301006202600254200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_2.tif} // OUTPUTS: {ImageRegionIteratorWithIndexOutput.jpg} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{Iterators!speed} // The ``WithIndex'' family of iterators was designed for algorithms that // use both the value and the location of image pixels in calculations. Unlike // \doxygen{itk}{ImageRegionIterator}, which calculates an index only when // asked for, \doxygen{itk}{ImageRegionIteratorWithIndex} maintains its // index location as a member variable that is updated during the increment or // decrement process. Iteration speed is penalized, but the index queries are // more efficient. // // \index{itk::ImageRegionIteratorWithIndex!example of using|(} // // The following example illustrates the use of // ImageRegionIteratorWithIndex. The algorithm mirrors // a 2D image across its $x$-axis (see \doxygen{itk}{FlipImageFilter} for an ND // version). The algorithm makes extensive use of the \code{GetIndex()} // method. // // We start by including the proper header file. // // Software Guide : EndLatex #include "otbImage.h" #include "itkRGBPixel.h" // Software Guide : BeginCodeSnippet #include "itkImageRegionIteratorWithIndex.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { // Verify the number of parameters on the command line. if (argc < 3) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile" << std::endl; return -1; } // Software Guide : BeginLatex // // For this example, we will use an RGB pixel type so that we can process color // images. Like most other ITK image iterator, // ImageRegionIteratorWithIndex class expects the image type as its // single template parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; typedef itk::ImageRegionIteratorWithIndex IteratorType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ImageType::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); inputImage = reader->GetOutput(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // An \code{ImageType} smart pointer called \code{inputImage} points to the // output of the image reader. After updating the image reader, we can // allocate an output image of the same size, spacing, and origin as the // input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer outputImage = ImageType::New(); outputImage->SetRegions(inputImage->GetRequestedRegion()); outputImage->CopyInformation(inputImage); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we create the iterator that walks the output image. This algorithm // requires no iterator for the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet IteratorType outputIt(outputImage, outputImage->GetRequestedRegion()); // Software Guide : EndCodeSnippet // Software Guide: BeginLatex // // This axis flipping algorithm works by iterating through the output image, // querying the iterator for its index, and copying the value from the input // at an index mirrored across the $x$-axis. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType requestedIndex = outputImage->GetRequestedRegion().GetIndex(); ImageType::SizeType requestedSize = outputImage->GetRequestedRegion().GetSize(); for (outputIt.GoToBegin(); !outputIt.IsAtEnd(); ++outputIt) { ImageType::IndexType idx = outputIt.GetIndex(); idx[0] = requestedIndex[0] + requestedSize[0] - 1 - idx[0]; outputIt.Set(inputImage->GetPixel(idx)); } // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(outputImage); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // Let's run this example on the image \code{ROI\_QB\_MUL\_2.tif} found in // the \code{Examples/Data} directory. // Figure~\ref{fig:ImageRegionIteratorWithIndexExample} shows how the original // image has been mirrored across its $x$-axis in the output. // // \begin{figure} \center // \includegraphics[width=0.44\textwidth]{ROI_QB_MUL_2.eps} // \includegraphics[width=0.44\textwidth]{ImageRegionIteratorWithIndexOutput.eps} // \itkcaption[Using the ImageRegionIteratorWithIndex]{Results of using // ImageRegionIteratorWithIndex to mirror an image across an axis. The original // image is shown at left. The mirrored output is shown at right.} // \label{fig:ImageRegionIteratorWithIndexExample} // \end{figure} // // \index{itk::ImageRegionIteratorWithIndex!example of using|)} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/ImageSliceIteratorWithIndex.cxx000066400000000000000000000260751301006202600252460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // \index{Iterators!and image slices} // // The \doxygen{ImageSliceIteratorWithIndex} class is an extension of // \doxygen{ImageLinearIteratorWithIndex} from iteration along lines to // iteration along both lines \emph{and planes} in an image. // A \emph{slice} is a 2D // plane spanned by two vectors pointing along orthogonal coordinate axes. The // slice orientation of the slice iterator is defined by specifying its two // spanning axes. // // \begin{itemize} // \index{itk::Image\-Slice\-Iterator\-With\-Index!SetFirstDirection()} // \item \textbf{\code{SetFirstDirection()}} // Specifies the first coordinate axis // direction of the slice plane. // // \index{itk::Image\-Slice\-Iterator\-With\-Index!SetSecondDirection()} // \item \textbf{\code{SetSecondDirection()}} // Specifies the second coordinate axis // direction of the slice plane. // \end{itemize} // // Several new methods control movement from slice to slice. // // \begin{itemize} // // \index{itk::Image\-Slice\-Iterator\-With\-Index!NextSlice()} // \item \textbf{\code{NextSlice()}} Moves the iterator to the beginning pixel // location of the next slice in the image. The origin of the next slice is // calculated by incrementing the current origin index along the fastest // increasing dimension of the image subspace which excludes the first and // second dimensions of the iterator. // // \index{itk::Image\-Slice\-Iterator\-With\-Index!PreviousSlice()} // \item \textbf{\code{PreviousSlice()}} Moves the iterator to the \emph{last // valid pixel location} in the previous slice. The origin of the previous // slice is calculated by decrementing the current origin index along the // fastest increasing dimension of the image subspace which excludes the first // and second dimensions of the iterator. // // \index{itk::Image\-Slice\-Iterator\-With\-Index!IsAtReverseEndOfSlice()} // \item \textbf{\code{IsAtReverseEndOfSlice()}} Returns true if the iterator // points to \emph{one position before} the beginning pixel of the current // slice. // // \index{itk::Image\-Slice\-Iterator\-With\-Index!IsAtEndOfSlice()} // \item \textbf{\code{IsAtEndOfSlice()}} Returns true if the iterator points // to \emph{one position past} the last valid pixel of the current slice. // // \end{itemize} // // The slice iterator moves line by line using \code{NextLine()} and // \code{PreviousLine()}. The line direction is parallel to the \emph{second} // coordinate axis direction of the slice plane (see also // Section~\ref{sec:itkImageLinearIteratorWithIndex}). // // \index{itk::Image\-Slice\-Iterator\-With\-Index!example of using|(} // The next code example calculates the maximum intensity projection along one // of the coordinate axes of an image volume. The algorithm is straightforward // using ImageSliceIteratorWithIndex because we can coordinate // movement through a slice of the 3D input image with movement through the 2D // planar output. // // Here is how the algorithm works. For each 2D slice of the input, iterate // through all the pixels line by line. Copy a pixel value to the corresponding // position in the 2D output image if it is larger than the value already // contained there. When all slices have been processed, the output image is // the desired maximum intensity projection. // // We include a header for the const version of the slice iterator. For writing // values to the 2D projection image, we use the linear iterator from the // previous section. The linear iterator is chosen because it can be set to // follow the same path in its underlying 2D image that the slice iterator // follows over each slice of the 3D image. // // Software Guide : EndLatex #include "otbImage.h" #include "vnl/vnl_math.h" // Software Guide : BeginCodeSnippet #include "itkImageSliceConstIteratorWithIndex.h" #include "itkImageLinearIteratorWithIndex.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { // Verify the number of parameters on the command line. if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile projectionDirection" << std::endl; return -1; } // Software Guide : BeginLatex // // The pixel type is defined as \code{unsigned short}. For this application, // we need two image types, a 3D image for the input, and a 2D image for the // intensity projection. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short PixelType; typedef otb::Image ImageType2D; typedef otb::Image ImageType3D; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A slice iterator type is defined to walk the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageLinearIteratorWithIndex LinearIteratorType; typedef itk::ImageSliceConstIteratorWithIndex SliceIteratorType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ImageType3D::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); inputImage = reader->GetOutput(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // The projection direction is read from the command line. The projection image // will be the size of the 2D plane orthogonal to the projection direction. // Its spanning vectors are the two remaining coordinate axes in the volume. // These axes are recorded in the \code{direction} array. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int projectionDirection = static_cast(::atoi(argv[3])); unsigned int i, j; unsigned int direction[2]; for (i = 0, j = 0; i < 3; ++i) { if (i != projectionDirection) { direction[j] = i; ++j; } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \code{direction} array is now used to define the projection image size // based on the input image size. The output image is created so that its // common dimension(s) with the input image are the same size. For example, // if we project along the $x$ axis of the input, the size and origin of the // $y$ axes of the input and output will match. This makes the code slightly // more complicated, but prevents a counter-intuitive rotation of the output. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType2D::RegionType region; ImageType2D::RegionType::SizeType size; ImageType2D::RegionType::IndexType index; ImageType3D::RegionType requestedRegion = inputImage->GetRequestedRegion(); index[direction[0]] = requestedRegion.GetIndex()[direction[0]]; index[1 - direction[0]] = requestedRegion.GetIndex()[direction[1]]; size[direction[0]] = requestedRegion.GetSize()[direction[0]]; size[1 - direction[0]] = requestedRegion.GetSize()[direction[1]]; region.SetSize(size); region.SetIndex(index); ImageType2D::Pointer outputImage = ImageType2D::New(); outputImage->SetRegions(region); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we create the necessary iterators. The const slice iterator walks // the 3D input image, and the non-const linear iterator walks the 2D output // image. The iterators are initialized to walk the same linear path through // a slice. Remember that the \emph{second} direction of the slice iterator // defines the direction that linear iteration walks within a slice. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SliceIteratorType inputIt(inputImage, inputImage->GetRequestedRegion()); LinearIteratorType outputIt(outputImage, outputImage->GetRequestedRegion()); inputIt.SetFirstDirection(direction[1]); inputIt.SetSecondDirection(direction[0]); outputIt.SetDirection(1 - direction[0]); // Software Guide : EndCodeSnippet // Software Guide: BeginLatex // // Now we are ready to compute the projection. The first step is to initialize // all of the projection values to their nonpositive minimum value. The // projection values are then updated row by row from the first slice of the // input. At the end of the first slice, the input iterator steps to the first // row in the next slice, while the output iterator, whose underlying image // consists of only one slice, rewinds to its first row. The process repeats // until the last slice of the input is processed. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet outputIt.GoToBegin(); while (!outputIt.IsAtEnd()) { while (!outputIt.IsAtEndOfLine()) { outputIt.Set(itk::NumericTraits::NonpositiveMin()); ++outputIt; } outputIt.NextLine(); } inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { while (!inputIt.IsAtEndOfSlice()) { while (!inputIt.IsAtEndOfLine()) { outputIt.Set(vnl_math_max(outputIt.Get(), inputIt.Get())); ++inputIt; ++outputIt; } outputIt.NextLine(); inputIt.NextLine(); } outputIt.GoToBegin(); inputIt.NextSlice(); } // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(outputImage); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : BeginLatex // // Running this example code on the 3D image // \code{Examples/Data/BrainProtonDensity3Slices.mha} using the $z$-axis as // the axis of projection gives the image shown in // Figure~\ref{fig:ImageSliceIteratorWithIndexOutput}. // // \begin{figure} // \centering // \includegraphics[width=0.4\textwidth]{ImageSliceIteratorWithIndexOutput.eps} // \itkcaption[Maximum intensity projection using ImageSliceIteratorWithIndex]{The // maximum intensity projection through three slices of a volume.} // \protect\label{fig:ImageSliceIteratorWithIndexOutput} // \end{figure} // // // \index{itk::Image\-Slice\-Iterator\-With\-Index!example of using|)} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/IteratorsExamples.cxx000066400000000000000000000023371301006202600233540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // this file defines the Iterator Examples for the test driver // and all it expects is that you have a function called RegisterTests #include #include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(ImageLinearIteratorWithIndexTest); REGISTER_TEST(ImageRandomConstIteratorWithIndexTest); REGISTER_TEST(ImageSliceIteratorWithIndexTest); } #undef main #define main ImageLinearIteratorWithIndexTest #include "ImageLinearIteratorWithIndex.cxx" #undef main #define main ImageRandomConstIteratorWithIndexTest #include "ImageRandomConstIteratorWithIndex.cxx" #undef main #define main ImageSliceIteratorWithIndexTest #include "ImageSliceIteratorWithIndex.cxx" OTB-release-5.8/Examples/Iterators/NeighborhoodIterators1.cxx000066400000000000000000000211621301006202600242630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_PAN_1.tif} // OUTPUTS: {NeighborhoodIterators1a.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example uses the \doxygen{itk}{NeighborhoodIterator} to implement a simple // Sobel edge detection algorithm \cite{Gonzalez1993}. The algorithm uses the // neighborhood iterator to iterate through an input image and calculate a // series of finite difference derivatives. Since the derivative results // cannot be written back to the input image without affecting later // calculations, they are written instead to a second, output image. Most // neighborhood processing algorithms follow this read-only model on their // inputs. // // We begin by including the proper header files. The // \doxygen{itk}{ImageRegionIterator} will be used to write the results of // computations to the output image. A const version of the neighborhood // iterator is used because the input image is read-only. // // Software Guide : EndLatex #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" // Software Guide : EndCodeSnippet int main(int argc, char *argv[]) { if (argc < 3) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile" << std::endl; return -1; } // Software Guide : BeginLatex // // The finite difference calculations // in this algorithm require floating point values. Hence, we define the image // pixel type to be \code{float} and the file reader will // automatically cast fixed-point data to \code{float}. // // We declare the iterator types using the image type as // the template parameter. The second template parameter of the // neighborhood iterator, which specifies // the boundary condition, has been omitted because the default condition is // appropriate for this algorithm. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::ImageRegionIterator IteratorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code creates and executes the OTB image reader. // The \code{Update} // call on the reader object is surrounded by the standard \code{try/catch} // blocks to handle any exceptions that may be thrown by the reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now create a neighborhood iterator to range over the output of the // reader. For Sobel edge-detection in 2D, we need a square iterator that // extends one pixel away from the neighborhood center in every dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighborhoodIteratorType::RadiusType radius; radius.Fill(1); NeighborhoodIteratorType it(radius, reader->GetOutput(), reader->GetOutput()->GetRequestedRegion()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code creates an output image and iterator. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer output = ImageType::New(); output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); IteratorType out(output, reader->GetOutput()->GetRequestedRegion()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Sobel edge detection uses weighted finite difference calculations to // construct an edge magnitude image. Normally the edge magnitude is the // root sum of squares of partial derivatives in all directions, but for // simplicity this example only calculates the $x$ component. The result is a // derivative image biased toward maximally vertical edges. // // The finite differences are computed from pixels at six locations in the // neighborhood. In this example, we use the iterator \code{GetPixel()} // method to query the values from their offsets in the neighborhood. // The example in Section~\ref{sec:NeighborhoodExample2} uses convolution // with a Sobel kernel instead. // // Six positions in the neighborhood are necessary for the finite difference // calculations. These positions are recorded in \code{offset1} through // \code{offset6}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighborhoodIteratorType::OffsetType offset1 = {{-1, -1}}; NeighborhoodIteratorType::OffsetType offset2 = {{1, -1}}; NeighborhoodIteratorType::OffsetType offset3 = {{-1, 0 }}; NeighborhoodIteratorType::OffsetType offset4 = {{1, 0}}; NeighborhoodIteratorType::OffsetType offset5 = {{-1, 1}}; NeighborhoodIteratorType::OffsetType offset6 = {{1, 1}}; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is equivalent to use the six corresponding integer array indices instead. // For example, the offsets \code{(-1, -1)} and \code{(1, -1)} are // equivalent to the integer indices \code{0} and \code{2}, respectively. // // The calculations are done in a \code{for} loop that moves the input and // output iterators synchronously across their respective images. The // \code{sum} variable is used to sum the results of the finite differences. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (it.GoToBegin(), out.GoToBegin(); !it.IsAtEnd(); ++it, ++out) { float sum; sum = it.GetPixel(offset2) - it.GetPixel(offset1); sum += 2.0 * it.GetPixel(offset4) - 2.0 * it.GetPixel(offset3); sum += it.GetPixel(offset6) - it.GetPixel(offset5); out.Set(sum); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The last step is to write the output buffer to an image file. Writing is // done inside a \code{try/catch} block to handle any exceptions. The output // is rescaled to intensity range $[0, 255]$ and cast to unsigned char so that // it can be saved and visualized as a PNG image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter< ImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(output); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The center image of Figure~\ref{fig:NeighborhoodExamples1} shows the // output of the Sobel algorithm applied to // \code{Examples/Data/ROI\_QB\_PAN\_1.tif}. // // \begin{figure} \centering // \includegraphics[width=0.45\textwidth]{ROI_QB_PAN_1.eps} // \includegraphics[width=0.45\textwidth]{NeighborhoodIterators1a.eps} // \itkcaption[Sobel edge detection results]{Applying the Sobel operator to an image (left) produces $x$ (right) derivative image.} // \protect\label{fig:NeighborhoodExamples1} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/NeighborhoodIterators2.cxx000066400000000000000000000151001301006202600242570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" // Software Guide : BeginLatex // // In this example, the Sobel edge-detection routine is rewritten using // convolution filtering. Convolution filtering is a standard image processing // technique that can be implemented numerically as the inner product of all // image neighborhoods with a convolution kernel \cite{Gonzalez1993} // \cite{Castleman1996}. In ITK, we use a class of objects called // \emph{neighborhood operators} as convolution kernels and a special function // object called \doxygen{itk}{NeighborhoodInnerProduct} to calculate inner // products. // // The basic ITK convolution filtering routine is to step through the image // with a neighborhood iterator and use NeighborhoodInnerProduct to // find the inner product of each neighborhood with the desired kernel. The // resulting values are written to an output image. This example uses a // neighborhood operator called the \doxygen{itk}{SobelOperator}, but all // neighborhood operators can be convolved with images using this basic // routine. Other examples of neighborhood operators include derivative // kernels, Gaussian kernels, and morphological // operators. \doxygen{itk}{NeighborhoodOperatorImageFilter} is a generalization of // the code in this section to ND images and arbitrary convolution kernels. // // We start writing this example by including the header files for the Sobel // kernel and the inner product function. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkSobelOperator.h" #include "itkNeighborhoodInnerProduct.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile direction" << std::endl; return -1; } typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::ImageRegionIterator IteratorType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } ImageType::Pointer output = ImageType::New(); output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); IteratorType out(output, reader->GetOutput()->GetRequestedRegion()); // Software Guide : BeginLatex // // \index{convolution!kernels} // \index{convolution!operators} // \index{iterators!neighborhood!and convolution} // // Refer to the previous example for a description of reading the input image and // setting up the output image and iterator. // // The following code creates a Sobel operator. The Sobel operator requires // a direction for its partial derivatives. This direction is read from the command line. // Changing the direction of the derivatives changes the bias of the edge // detection, i.e. maximally vertical or maximally horizontal. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet itk::SobelOperator sobelOperator; sobelOperator.SetDirection(::atoi(argv[3])); sobelOperator.CreateDirectional(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The neighborhood iterator is initialized as before, except that now it takes // its radius directly from the radius of the Sobel operator. The inner // product function object is templated over image type and requires no // initialization. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighborhoodIteratorType::RadiusType radius = sobelOperator.GetRadius(); NeighborhoodIteratorType it(radius, reader->GetOutput(), reader->GetOutput()-> GetRequestedRegion()); itk::NeighborhoodInnerProduct innerProduct; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Using the Sobel operator, inner product, and neighborhood iterator objects, // we can now write a very simple \code{for} loop for performing convolution // filtering. As before, out-of-bounds pixel values are supplied automatically // by the iterator. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (it.GoToBegin(), out.GoToBegin(); !it.IsAtEnd(); ++it, ++out) { out.Set(innerProduct(it, sobelOperator)); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output is rescaled and written as in the previous example. Applying // this example in the $x$ and $y$ directions produces the images at the center // and right of Figure~\ref{fig:NeighborhoodExamples1}. Note that x-direction // operator produces the same output image as in the previous example. // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter< ImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(output); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/NeighborhoodIterators3.cxx000066400000000000000000000204131301006202600242630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" // Software Guide : BeginLatex // // This example illustrates a technique for improving the efficiency of // neighborhood calculations by eliminating unnecessary bounds checking. As // described in Section~\ref{sec:NeighborhoodIterators}, the neighborhood // iterator automatically enables or disables bounds checking based on the // iteration region in which it is initialized. By splitting our image into // boundary and non-boundary regions, and then processing each region using a // different neighborhood iterator, the algorithm will only perform // bounds-checking on those pixels for which it is actually required. This // trick can provide a significant speedup for simple algorithms such as our // Sobel edge detection, where iteration speed is a critical. // // Splitting the image into the necessary regions is an easy task when you use // the \doxygen{itk}{ImageBoundaryFacesCalculator}. The face // calculator is so named because it returns a list of the ``faces'' of the ND // dataset. Faces are those regions whose pixels all lie within a distance $d$ // from the boundary, where $d$ is the radius of the neighborhood stencil used // for the numerical calculations. In other words, faces are those regions // where a neighborhood iterator of radius $d$ will always overlap the boundary // of the image. The face calculator also returns the single \emph{inner} // region, in which out-of-bounds values are never required and bounds checking // is not necessary. // // The face calculator object is defined in \code{itkNeighborhoodAlgorithm.h}. // We include this file in addition to those from the previous two examples. // // Software Guide : EndLatex #include "itkSobelOperator.h" #include "itkNeighborhoodInnerProduct.h" // Software Guide : BeginCodeSnippet #include "itkNeighborhoodAlgorithm.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile direction" << std::endl; return -1; } typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::ImageRegionIterator IteratorType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } ImageType::Pointer output = ImageType::New(); output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); itk::SobelOperator sobelOperator; sobelOperator.SetDirection(::atoi(argv[3])); sobelOperator.CreateDirectional(); itk::NeighborhoodInnerProduct innerProduct; // Software Guide : BeginLatex // // First we load the input image and create the output image and inner product // function as in the previous examples. The image iterators will be created // in a later step. Next we create a face calculator object. An empty list is // created to hold the regions that will later on be returned by the face // calculator. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::NeighborhoodAlgorithm ::ImageBoundaryFacesCalculator FaceCalculatorType; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The face calculator function is invoked by passing it an image pointer, an // image region, and a neighborhood radius. The image pointer is the same // image used to initialize the neighborhood iterator, and the image region is // the region that the algorithm is going to process. The radius is the radius // of the iterator. // // Notice that in this case the image region is given as the region of the // \emph{output} image and the image pointer is given as that of the // \emph{input} image. This is important if the input and output images differ // in size, i.e. the input image is larger than the output image. ITK // and OTB image // filters, for example, operate on data from the input image but only generate // results in the \code{RequestedRegion} of the output image, which may be // smaller than the full extent of the input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet faceList = faceCalculator(reader->GetOutput(), output->GetRequestedRegion(), sobelOperator.GetRadius()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The face calculator has returned a list of $2N+1$ regions. The first element // in the list is always the inner region, which may or may not be important // depending on the application. For our purposes it does not matter because // all regions are processed the same way. We use an iterator to traverse the // list of faces. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FaceCalculatorType::FaceListType::iterator fit; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now rewrite the main loop of the previous example so that each region in the // list is processed by a separate iterator. The iterators \code{it} and // \code{out} are reinitialized over each region in turn. Bounds checking is // automatically enabled for those regions that require it, and disabled for // the region that does not. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet IteratorType out; NeighborhoodIteratorType it; for (fit = faceList.begin(); fit != faceList.end(); ++fit) { it = NeighborhoodIteratorType(sobelOperator.GetRadius(), reader->GetOutput(), *fit); out = IteratorType(output, *fit); for (it.GoToBegin(), out.GoToBegin(); !it.IsAtEnd(); ++it, ++out) { out.Set(innerProduct(it, sobelOperator)); } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output is written as before. Results for this example are the same as // the previous example. You may not notice the speedup except on larger // images. When moving to 3D and higher dimensions, the effects are greater // because the volume to surface area ratio is usually larger. In other // words, as the number of interior pixels increases relative to the number of // face pixels, there is a corresponding increase in efficiency from disabling // bounds checking on interior pixels. // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter< ImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(output); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/NeighborhoodIterators4.cxx000066400000000000000000000173551301006202600242770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {NeighborhoodIterators4a.png} // 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {NeighborhoodIterators4b.png} // 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {NeighborhoodIterators4c.png} // 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {NeighborhoodIterators4d.png} // 5 // Software Guide : EndCommandLineArgs #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkNeighborhoodInnerProduct.h" // Software Guide : BeginLatex // // We now introduce a variation on convolution filtering that is useful when a // convolution kernel is separable. In this example, we create a different // neighborhood iterator for each axial direction of the image and then take // separate inner products with a 1D discrete Gaussian kernel. // The idea of using several neighborhood iterators at once has applications // beyond convolution filtering and may improve efficiency when the size of // the whole neighborhood relative to the portion of the neighborhood used // in calculations becomes large. // // The only new class necessary for this example is the Gaussian operator. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkGaussianOperator.h" // Software Guide : EndCodeSnippet int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile sigma" << std::endl; return -1; } typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::ImageRegionIterator IteratorType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } ImageType::Pointer output = ImageType::New(); output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); itk::NeighborhoodInnerProduct innerProduct; typedef itk::NeighborhoodAlgorithm ::ImageBoundaryFacesCalculator FaceCalculatorType; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; FaceCalculatorType::FaceListType::iterator fit; IteratorType out; NeighborhoodIteratorType it; // Software Guide : BeginLatex // The Gaussian operator, like the Sobel operator, is instantiated with a pixel // type and a dimensionality. Additionally, we set the variance of the // Gaussian, which has been read from the command line as standard deviation. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet itk::GaussianOperator gaussianOperator; gaussianOperator.SetVariance(::atof(argv[3]) * ::atof(argv[3])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The only further changes from the previous example are in the main loop. // Once again we use the results from face calculator to construct a loop that // processes boundary and non-boundary image regions separately. Separable // convolution, however, requires an additional, outer loop over all the image // dimensions. The direction of the Gaussian operator is reset at each // iteration of the outer loop using the new dimension. The iterators change // direction to match because they are initialized with the radius of the // Gaussian operator. // // Input and output buffers are swapped at each iteration so that the output of // the previous iteration becomes the input for the current iteration. The swap // is not performed on the last iteration. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer input = reader->GetOutput(); for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { gaussianOperator.SetDirection(i); gaussianOperator.CreateDirectional(); faceList = faceCalculator(input, output->GetRequestedRegion(), gaussianOperator.GetRadius()); for (fit = faceList.begin(); fit != faceList.end(); ++fit) { it = NeighborhoodIteratorType(gaussianOperator.GetRadius(), input, *fit); out = IteratorType(output, *fit); for (it.GoToBegin(), out.GoToBegin(); !it.IsAtEnd(); ++it, ++out) { out.Set(innerProduct(it, gaussianOperator)); } } // Swap the input and output buffers if (i != ImageType::ImageDimension - 1) { ImageType::Pointer tmp = input; input = output; output = tmp; } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output is rescaled and written as in the previous examples. // Figure~\ref{fig:NeighborhoodExample4} shows the results of Gaussian blurring // the image \code{Examples/Data/QB\_Suburb.png} using increasing // kernel widths. // // \begin{figure} // \centering // \includegraphics[width=0.23\textwidth]{NeighborhoodIterators4a.eps} // \includegraphics[width=0.23\textwidth]{NeighborhoodIterators4b.eps} // \includegraphics[width=0.23\textwidth]{NeighborhoodIterators4c.eps} // \includegraphics[width=0.23\textwidth]{NeighborhoodIterators4d.eps} // \itkcaption[Gaussian blurring by convolution filtering]{Results of // convolution filtering with a Gaussian kernel of increasing standard // deviation $\sigma$ (from left to right, $\sigma = 0$, $\sigma = 1$, $\sigma // = 2$, $\sigma = 5$). Increased blurring reduces contrast and changes the // average intensity value of the image, which causes the image to appear // brighter when rescaled.} // \protect\label{fig:NeighborhoodExample4} // \end{figure} // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter< ImageType, WriteImageType> RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(output); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/NeighborhoodIterators5.cxx000066400000000000000000000172761301006202600243020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkGaussianOperator.h" #include "itkNeighborhoodInnerProduct.h" // Software Guide : BeginLatex // // This example introduces slice-based neighborhood processing. A slice, in // this context, is a 1D path through an ND neighborhood. Slices are defined // for generic arrays by the \code{std::slice} class as a start index, a step // size, and an end index. Slices simplify the implementation of certain // neighborhood calculations. They also provide a mechanism for taking inner // products with subregions of neighborhoods. // // Suppose, for example, that we want to take partial derivatives in the $y$ // direction of a neighborhood, but offset those derivatives by one pixel // position along the positive $x$ direction. For a $3\times3$, 2D // neighborhood iterator, we can construct an \code{std::slice}, \code{(start = // 2, stride = 3, end = 8)}, that represents the neighborhood offsets $(1, // -1)$, $(1, 0)$, $(1, 1)$ (see Figure~\ref{fig:NeighborhoodIteratorFig2}). If we // pass this slice as an extra argument to the // \doxygen{NeighborhoodInnerProduct} function, then the inner product is taken // only along that slice. This ``sliced'' inner product with a 1D // \doxygen{DerivativeOperator} gives the desired derivative. // // The previous separable Gaussian filtering example can be rewritten using // slices and slice-based inner products. In general, slice-based processing // is most useful when doing many different calculations on the same // neighborhood, where defining multiple iterators as in // Section~\ref{sec:NeighborhoodExample4} becomes impractical or inefficient. // Good examples of slice-based neighborhood processing can be found in any of // the ND anisotropic diffusion function objects, such as // \doxygen{CurvatureNDAnisotropicDiffusionFunction}. // // Software Guide : EndLatex int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile sigma" << std::endl; return -1; } typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::ImageRegionIterator IteratorType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } ImageType::Pointer output = ImageType::New(); output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); itk::NeighborhoodInnerProduct innerProduct; typedef itk::NeighborhoodAlgorithm ::ImageBoundaryFacesCalculator FaceCalculatorType; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; FaceCalculatorType::FaceListType::iterator fit; IteratorType out; NeighborhoodIteratorType it; // Software Guide: BeginLatex // // The first difference between this example and the previous example is that // the Gaussian operator is only initialized once. Its direction is not // important because it is only a 1D array of coefficients. // // Software Guide: EndLatex // Software Guide : BeginCodeSnippet itk::GaussianOperator gaussianOperator; gaussianOperator.SetDirection(0); gaussianOperator.SetVariance(::atof(argv[3]) * ::atof(argv[3])); gaussianOperator.CreateDirectional(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we need to define a radius for the iterator. The radius in all // directions matches that of the single extent of the Gaussian operator, // defining a square neighborhood. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighborhoodIteratorType::RadiusType radius; radius.Fill(gaussianOperator.GetRadius()[0]); // Software Guide EndCodeSnippet // Software Guide : BeginLatex // // The inner product and face calculator are defined for the main processing // loop as before, but now the iterator is reinitialized each iteration with // the square \code{radius} instead of the radius of the operator. The // inner product is taken using a slice along the axial direction corresponding // to the current iteration. Note the use of \code{GetSlice()} to return the // proper slice from the iterator itself. \code{GetSlice()} can only be used // to return the slice along the complete extent of the axial direction of a // neighborhood. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer input = reader->GetOutput(); faceList = faceCalculator(input, output->GetRequestedRegion(), radius); for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { for (fit = faceList.begin(); fit != faceList.end(); ++fit) { it = NeighborhoodIteratorType(radius, input, *fit); out = IteratorType(output, *fit); for (it.GoToBegin(), out.GoToBegin(); !it.IsAtEnd(); ++it, ++out) { out.Set(innerProduct(it.GetSlice(i), it, gaussianOperator)); } } // Swap the input and output buffers if (i != ImageType::ImageDimension - 1) { ImageType::Pointer tmp = input; input = output; output = tmp; } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // This technique produces exactly the same results as the previous example. A // little experimentation, however, will reveal that it is less efficient since // the neighborhood iterator is keeping track of extra, unused pixel locations // for each iteration, while the previous example only references those pixels // that it needs. In cases, however, where an algorithm takes multiple // derivatives or convolution products over the same neighborhood, slice-based // processing can increase efficiency and simplify the implementation. // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(output); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/NeighborhoodIterators6.cxx000066400000000000000000000206601301006202600242720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkFastMarchingImageFilter.h" #include "itkAddImageFilter.h" // Software Guide : BeginCommandLineArgs // OUTPUTS: {NeighborhoodIterators6a.png} // 100 100 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // OUTPUTS: {NeighborhoodIterators6b.png} // 50 150 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // OUTPUTS: {NeighborhoodIterators6c.png} // 150 50 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Some image processing routines do not need to visit every pixel in an // image. Flood-fill and connected-component algorithms, for example, only // visit pixels that are locally connected to one another. Algorithms // such as these can be efficiently written using the random access // capabilities of the neighborhood iterator. // // The following example finds local minima. Given a seed point, we can search // the neighborhood of that point and pick the smallest value $m$. While $m$ // is not at the center of our current neighborhood, we move in the direction // of $m$ and repeat the analysis. Eventually we discover a local minimum and // stop. This algorithm is made trivially simple in ND using an ITK // neighborhood iterator. // // To illustrate the process, we create an image that descends everywhere to a // single minimum: a positive distance transform to a point. The details of // creating the distance transform are not relevant to the discussion of // neighborhood iterators, but can be found in the source code of this // example. Some noise has been added to the distance transform image for // additional interest. // // Software Guide : EndLatex int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " outputImageFile startX startY" << std::endl; return -1; } typedef float PixelType; typedef otb::Image ImageType; typedef itk::NeighborhoodIterator NeighborhoodIteratorType; typedef itk::FastMarchingImageFilter FastMarchingFilterType; FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New(); typedef FastMarchingFilterType::NodeContainer NodeContainer; typedef FastMarchingFilterType::NodeType NodeType; NodeContainer::Pointer seeds = NodeContainer::New(); ImageType::IndexType seedPosition; seedPosition[0] = 128; seedPosition[1] = 128; const double initialDistance = 1.0; NodeType node; const double seedValue = -initialDistance; ImageType::SizeType size = {{256, 256}}; node.SetValue(seedValue); node.SetIndex(seedPosition); seeds->Initialize(); seeds->InsertElement(0, node); fastMarching->SetTrialPoints(seeds); fastMarching->SetSpeedConstant(1.0); itk::AddImageFilter::Pointer adder = itk::AddImageFilter::New(); // Allocate the noise image ImageType::Pointer noise = ImageType::New(); ImageType::RegionType noiseRegion; noiseRegion.SetSize(size); noise->SetRegions(noiseRegion); noise->Allocate(); // Fill the noise image itk::ImageRegionIterator itNoise(noise, noiseRegion); itNoise.GoToBegin(); // Random number seed unsigned int sample_seed = 12345; double u = 0.; double rnd = 0.; double dMin = -.7; double dMax = .8; while(!itNoise.IsAtEnd()) { sample_seed = ( sample_seed * 16807 ) % 2147483647L; u = static_cast< double >( sample_seed ) / 2147483711UL; rnd = ( 1.0 - u ) * dMin + u * dMax; itNoise.Set( (PixelType)rnd ); ++itNoise; } adder->SetInput1(noise); adder->SetInput2(fastMarching->GetOutput()); try { fastMarching->SetOutputSize(size); fastMarching->Update(); adder->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } ImageType::Pointer input = adder->GetOutput(); // Software Guide : BeginLatex // // The variable \code{input} is the pointer to the distance transform image. // The local minimum algorithm is initialized with a seed point read from the // command line. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType index; index[0] = ::atoi(argv[2]); index[1] = ::atoi(argv[3]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Next we create the neighborhood iterator and position it at the seed point. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NeighborhoodIteratorType::RadiusType radius; radius.Fill(1); NeighborhoodIteratorType it(radius, input, input->GetRequestedRegion()); it.SetLocation(index); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Searching for the local minimum involves finding the minimum in the current // neighborhood, then shifting the neighborhood in the direction of that // minimum. The \code{for} loop below records the \doxygen{itk}{Offset} of the // minimum neighborhood pixel. The neighborhood iterator is then moved using // that offset. When a local minimum is detected, \code{flag} will remain // false and the \code{while} loop will exit. Note that this code is // valid for an image of any dimensionality. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet bool flag = true; while (flag == true) { NeighborhoodIteratorType::OffsetType nextMove; nextMove.Fill(0); flag = false; PixelType min = it.GetCenterPixel(); for (unsigned i = 0; i < it.Size(); ++i) { if (it.GetPixel(i) < min) { min = it.GetPixel(i); nextMove = it.GetOffset(i); flag = true; } } it.SetCenterPixel(255.0); it += nextMove; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:NeighborhoodExample6} shows the results of the algorithm // for several seed points. The white line is the path of the iterator from // the seed point to the minimum in the center of the image. The effect of the // additive noise is visible as the small perturbations in the paths. // // \begin{figure} \centering // \includegraphics[width=0.3\textwidth]{NeighborhoodIterators6a.eps} // \includegraphics[width=0.3\textwidth]{NeighborhoodIterators6b.eps} // \includegraphics[width=0.3\textwidth]{NeighborhoodIterators6c.eps} // \itkcaption[Finding local minima]{Paths traversed by the neighborhood // iterator from different seed points to the local minimum. // The true minimum is at the center // of the image. The path of the iterator is shown in white. The effect of // noise in the image is seen as small perturbations in each path. } // \protect\label{fig:NeighborhoodExample6} \end{figure} // // Software Guide : EndLatex typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(input); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[1]); writer->SetInput(rescaler->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/ShapedNeighborhoodIterators1.cxx000066400000000000000000000174111301006202600254120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkNeighborhoodAlgorithm.h" #include // Software Guide : BeginLatex // // This example uses \doxygen{itk}{ShapedNeighborhoodIterator} to implement a binary // erosion algorithm. If we think of an image $I$ as a set of pixel indices, // then erosion of $I$ by a smaller set $E$, called the \emph{structuring // element}, is the set of all indices at locations $x$ in $I$ such that when // $E$ is positioned at $x$, every element in $E$ is also contained in $I$. // // This type of algorithm is easy to implement with shaped neighborhood // iterators because we can use the iterator itself as the structuring element // $E$ and move it sequentially through all positions $x$. The result at $x$ // is obtained by checking values in a simple iteration loop through the // neighborhood stencil. // // We need two iterators, a shaped iterator for the input image and a regular // image iterator for writing results to the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkConstShapedNeighborhoodIterator.h" #include "itkImageRegionIterator.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile element_radius" << std::endl; return -1; } // Software Guide : BeginLatex // // Since we are working with binary images in this example, an \code{unsigned // char} pixel type will do. The image and iterator types are defined using // the pixel type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::ConstShapedNeighborhoodIterator< ImageType > ShapedNeighborhoodIteratorType; typedef itk::ImageRegionIterator IteratorType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } ImageType::Pointer output = ImageType::New(); output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); // Software Guide : BeginLatex // // Refer to the examples in Section~\ref{sec:itkNeighborhoodIterator} or the // source code of this example for a description of how to read the input image // and allocate a matching output image. // // The size of the structuring element is read from the command line and used // to define a radius for the shaped neighborhood iterator. Using the method // developed in section~\ref{sec:itkNeighborhoodIterator} to minimize bounds // checking, the iterator itself is not initialized until entering the // main processing loop. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int element_radius = ::atoi(argv[3]); ShapedNeighborhoodIteratorType::RadiusType radius; radius.Fill(element_radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The face calculator object introduced in // Section~\ref{sec:NeighborhoodExample3} is created and used as before. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator< ImageType> FaceCalculatorType; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; FaceCalculatorType::FaceListType::iterator fit; faceList = faceCalculator(reader->GetOutput(), output->GetRequestedRegion(), radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we initialize some variables and constants. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet IteratorType out; const PixelType background_value = 0; const PixelType foreground_value = 255; const float rad = static_cast(element_radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The outer loop of the algorithm is structured as in previous neighborhood // iterator examples. Each region in the face list is processed in turn. As each new // region is processed, the input and output iterators are initialized on that // region. // // The shaped iterator that ranges over the input is our structuring element // and its active stencil must be created accordingly. For this example, the // structuring element is shaped like a circle of radius // \code{element\_radius}. Each of the appropriate neighborhood offsets is // activated in the double \code{for} loop. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (fit = faceList.begin(); fit != faceList.end(); ++fit) { ShapedNeighborhoodIteratorType it(radius, reader->GetOutput(), *fit); out = IteratorType(output, *fit); // Creates a circular structuring element by activating all the pixels less // than radius distance from the center of the neighborhood. for (float y = -rad; y <= rad; y++) { for (float x = -rad; x <= rad; x++) { ShapedNeighborhoodIteratorType::OffsetType off; float dis = ::sqrt(x * x + y * y); if (dis <= rad) { off[0] = static_cast(x); off[1] = static_cast(y); it.ActivateOffset(off); } } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The inner loop, which implements the erosion algorithm, is fairly simple. // The \code{for} loop steps the input and output iterators through their // respective images. At each step, the active stencil of the shaped iterator // is traversed to determine whether all pixels underneath the stencil contain // the foreground value, i.e. are contained within the set $I$. Note the use // of the stencil iterator, \code{ci}, in performing this check. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Implements erosion for (it.GoToBegin(), out.GoToBegin(); !it.IsAtEnd(); ++it, ++out) { ShapedNeighborhoodIteratorType::ConstIterator ci; bool flag = true; for (ci = it.Begin(); ci != it.End(); ci++) { if (ci.Get() == background_value) { flag = false; break; } } if (flag == true) { out.Set(foreground_value); } else { out.Set(background_value); } } } // Software Guide : EndCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(output); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/ShapedNeighborhoodIterators2.cxx000066400000000000000000000130731301006202600254130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // SoftwareGuide : BeginCommandLineArgs // INPUTS: {BinaryImage.png} // OUTPUTS: {ShapedNeighborhoodIterators1b.png} // 4 // SoftwareGuide : EndCommandLineArgs #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkConstShapedNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Missing parameters. " << std::endl; std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile element_radius" << std::endl; return -1; } typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ConstShapedNeighborhoodIterator ShapedNeighborhoodIteratorType; typedef itk::ImageRegionIterator IteratorType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); unsigned int element_radius = ::atoi(argv[3]); try { reader->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } ImageType::Pointer output = ImageType::New(); output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator FaceCalculatorType; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; FaceCalculatorType::FaceListType::iterator fit; ShapedNeighborhoodIteratorType::RadiusType radius; radius.Fill(element_radius); faceList = faceCalculator(reader->GetOutput(), output->GetRequestedRegion(), radius); IteratorType out; const float rad = static_cast(element_radius); const PixelType background_value = 0; const PixelType foreground_value = 255; for (fit = faceList.begin(); fit != faceList.end(); ++fit) { ShapedNeighborhoodIteratorType it(radius, reader->GetOutput(), *fit); out = IteratorType(output, *fit); // Creates a circular structuring element by activating all the pixels less // than radius distance from the center of the neighborhood. for (float y = -rad; y <= rad; y++) { for (float x = -rad; x <= rad; x++) { ShapedNeighborhoodIteratorType::OffsetType off; float dis = ::sqrt(x * x + y * y); if (dis <= rad) { off[0] = static_cast(x); off[1] = static_cast(y); it.ActivateOffset(off); } } } // Software Guide : BeginLatex // // The logic of the inner loop can be rewritten to perform // dilation. Dilation of the set $I$ by $E$ is the set of all $x$ such that // $E$ positioned at $x$ contains at least one element in $I$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Implements dilation for (it.GoToBegin(), out.GoToBegin(); !it.IsAtEnd(); ++it, ++out) { ShapedNeighborhoodIteratorType::ConstIterator ci; bool flag = false; for (ci = it.Begin(); ci != it.End(); ci++) { if (ci.Get() != background_value) { flag = true; break; } } if (flag == true) { out.Set(foreground_value); } else { out.Set(background_value); } } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output image is written and visualized directly as a binary image of // \code{unsigned chars}. Figure~\ref{fig:ShapedNeighborhoodExample2} // illustrates the results of dilation on the image // \code{Examples/Data/BinaryImage.png}. Applying erosion and dilation // in sequence effects the morphological operations of opening and closing. // // \begin{figure} \centering // \includegraphics[width=0.18\textwidth]{BinaryImage.eps} // %\includegraphics[width=0.18\textwidth]{ShapedNeighborhoodIterators1a.eps} // \includegraphics[width=0.18\textwidth]{ShapedNeighborhoodIterators1b.eps} // %\includegraphics[width=0.18\textwidth]{ShapedNeighborhoodIterators1c.eps} // %\includegraphics[width=0.18\textwidth]{ShapedNeighborhoodIterators1d.eps} // \itkcaption[Binary image morphology]{The effects of morphological operations // on a binary image using a circular structuring element of size 4. // Left: original image. Right: dilation.} // \protect\label{fig:ShapedNeighborhoodExample2} // \end{figure} // // Software Guide : EndLatex typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(output); try { writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Iterators/test/000077500000000000000000000000001301006202600201275ustar00rootroot00000000000000OTB-release-5.8/Examples/Iterators/test/CMakeLists.txt000066400000000000000000000101121301006202600226620ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Iterators) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- ImageRegionIteratorWithIndexTest---------- otb_add_test(NAME itTeImageRegionIteratorWithIndexTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ImageRegionIteratorWithIndexOutput.png ${TEMP}/ImageRegionIteratorWithIndexOutput.png Execute $ ${INPUTDATA}/ROI_QB_MUL_2.tif ${TEMP}/ImageRegionIteratorWithIndexOutput.png ) # ------- NeighborhoodIterators1Test---------- otb_add_test(NAME itTeNeighborhoodIterators1Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators1a.png ${TEMP}/NeighborhoodIterators1a.png Execute $ ${INPUTDATA}/ROI_QB_PAN_1.tif ${TEMP}/NeighborhoodIterators1a.png ) # ------- NeighborhoodIterators4Test---------- otb_add_test(NAME itTeNeighborhoodIterators4aTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators4a.png ${TEMP}/NeighborhoodIterators4a.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/NeighborhoodIterators4a.png 0 ) # ------- NeighborhoodIterators4Test---------- otb_add_test(NAME itTeNeighborhoodIterators4bTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators4b.png ${TEMP}/NeighborhoodIterators4b.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/NeighborhoodIterators4b.png 1 ) # ------- NeighborhoodIterators4Test---------- otb_add_test(NAME itTeNeighborhoodIterators4cTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators4c.png ${TEMP}/NeighborhoodIterators4c.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/NeighborhoodIterators4c.png 2 ) # ------- NeighborhoodIterators4Test---------- otb_add_test(NAME itTeNeighborhoodIterators4dTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators4d.png ${TEMP}/NeighborhoodIterators4d.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/NeighborhoodIterators4d.png 5 ) # ------- NeighborhoodIterators6Test---------- otb_add_test(NAME itTeNeighborhoodIterators6aTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators6a.png ${TEMP}/NeighborhoodIterators6a.png Execute $ ${TEMP}/NeighborhoodIterators6a.png 100 100 ) # ------- NeighborhoodIterators6Test---------- otb_add_test(NAME itTeNeighborhoodIterators6bTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators6b.png ${TEMP}/NeighborhoodIterators6b.png Execute $ ${TEMP}/NeighborhoodIterators6b.png 50 150 ) # ------- NeighborhoodIterators6Test---------- otb_add_test(NAME itTeNeighborhoodIterators6cTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodIterators6c.png ${TEMP}/NeighborhoodIterators6c.png Execute $ ${TEMP}/NeighborhoodIterators6c.png 150 50 ) # ------- ImageRegionIteratorTest---------- otb_add_test(NAME itTeImageRegionIteratorTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ImageRegionIteratorOutput.png ${TEMP}/ImageRegionIteratorOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ImageRegionIteratorOutput.png 10 10 110 140 ) # ------- ShapedNeighborhoodIterators2Test---------- otb_add_test(NAME itTeShapedNeighborhoodIterators2Test COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ShapedNeighborhoodIterators1b.png ${TEMP}/ShapedNeighborhoodIterators1b.png Execute $ ${INPUTDATA}/BinaryImage.png ${TEMP}/ShapedNeighborhoodIterators1b.png 4 ) OTB-release-5.8/Examples/Learning/000077500000000000000000000000001301006202600167335ustar00rootroot00000000000000OTB-release-5.8/Examples/Learning/CMakeLists.txt000066400000000000000000000036421301006202600215000ustar00rootroot00000000000000project(LearningExamples) add_executable(GenerateTrainingImageExample GenerateTrainingImageExample.cxx) target_link_libraries(GenerateTrainingImageExample ${OTB_LIBRARIES}) add_executable(SEMModelEstimatorExample SEMModelEstimatorExample.cxx) target_link_libraries(SEMModelEstimatorExample ${OTB_LIBRARIES}) add_executable(SOMClassifierExample SOMClassifierExample.cxx) target_link_libraries(SOMClassifierExample ${OTB_LIBRARIES}) add_executable(SOMExample SOMExample.cxx) target_link_libraries(SOMExample ${OTB_LIBRARIES}) if(OTBLibSVM_LOADED) add_executable(SVMImageClassificationExample SVMImageClassificationExample.cxx) target_link_libraries(SVMImageClassificationExample ${OTB_LIBRARIES}) add_executable(SVMImageEstimatorClassificationMultiExample SVMImageEstimatorClassificationMultiExample.cxx) target_link_libraries(SVMImageEstimatorClassificationMultiExample ${OTB_LIBRARIES}) add_executable(SVMImageModelEstimatorExample SVMImageModelEstimatorExample.cxx) target_link_libraries(SVMImageModelEstimatorExample ${OTB_LIBRARIES}) add_executable(SVMPointSetClassificationExample SVMPointSetClassificationExample.cxx) target_link_libraries(SVMPointSetClassificationExample ${OTB_LIBRARIES}) add_executable(SVMPointSetExample SVMPointSetExample.cxx) target_link_libraries(SVMPointSetExample ${OTB_LIBRARIES}) add_executable(SVMPointSetModelEstimatorExample SVMPointSetModelEstimatorExample.cxx) target_link_libraries(SVMPointSetModelEstimatorExample ${OTB_LIBRARIES}) endif() if(OTBOpenCV_LOADED) add_executable(TrainMachineLearningModelFromImagesExample TrainMachineLearningModelFromImagesExample.cxx) target_link_libraries(TrainMachineLearningModelFromImagesExample ${OTB_LIBRARIES}) add_executable(TrainMachineLearningModelFromSamplesExample TrainMachineLearningModelFromSamplesExample.cxx) target_link_libraries(TrainMachineLearningModelFromSamplesExample ${OTB_LIBRARIES}) endif() if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Learning/GenerateTrainingImageExample.cxx000066400000000000000000000106261301006202600251710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_4.tif}, {LearningROIs.txt} // OUTPUTS: {ROI_QB_MUL_4_training.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates how to generate a training image for an // image supervised classification. // // Software Guide : EndLatex #include "itkNumericTraits.h" #include "otbImage.h" #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "itkImageRegionIterator.h" #include #include #include int main(int argc, char *argv[]) { if (argc != 4) { std::cout << "Usage : " << argv[0] << " inputImage roiFile outputTrainingImage" << std::endl; return EXIT_FAILURE; } const char * imageFilename = argv[1]; const char * roiFilename = argv[2]; const char * outputFilename = argv[3]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(imageFilename); writer->SetFileName(outputFilename); reader->Update(); // We allocate the output image OutputImageType::Pointer trainingImage = OutputImageType::New(); // Declare the type of the index to access images typedef itk::Index myIndexType; // Declare the type of the size typedef itk::Size mySizeType; // Declare the type of the Region typedef itk::ImageRegion myRegionType; // Define their size, and start index mySizeType size; size[0] = reader->GetOutput()->GetRequestedRegion().GetSize()[0]; size[1] = reader->GetOutput()->GetRequestedRegion().GetSize()[1]; myIndexType start; start[0] = 0; start[1] = 0; myRegionType region; region.SetIndex(start); region.SetSize(size); // Initialize Image B trainingImage->SetLargestPossibleRegion(region); trainingImage->SetBufferedRegion(region); trainingImage->SetRequestedRegion(region); trainingImage->Allocate(); OutputPixelType pix; pix = itk::NumericTraits::Zero; trainingImage->FillBuffer(pix); // For each line of the ROIs file, we create a region iterator and // assign the value of the labels to the pixels std::ifstream roisFile; roisFile.open(roiFilename); unsigned int nbRois = 0; roisFile >> nbRois; std::cout << "Nb of ROIS " << int(nbRois) << std::endl; while (!roisFile.fail() && (nbRois > 0)) { --nbRois; OutputPixelType label = 0; unsigned long xUL, yUL, xBR, yBR, tmp_label = 0; roisFile >> tmp_label; roisFile >> xUL; roisFile >> yUL; roisFile >> xBR; roisFile >> yBR; label = static_cast(tmp_label); std::cout << "Label : " << int(label) << std::endl; std::cout << "( " << xUL << " , " << yUL << " )" << std::endl; std::cout << "( " << xBR << " , " << yBR << " )" << std::endl; // Region creation start[0] = xUL; start[1] = yUL; size[0] = xBR - xUL; size[1] = yBR - yUL; region.SetSize(size); region.SetIndex(start); // Iterator creation typedef itk::ImageRegionIterator IteratorType; IteratorType it(trainingImage, region); it.GoToBegin(); // Iteration and pixel value assignment while (!it.IsAtEnd()) { it.Set(static_cast(label)); //std::cout << (int)static_cast(label) << " -- "; //std::cout << (int)it.Get() << std::endl; ++it; } } writer->SetInput(trainingImage); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SEMModelEstimatorExample.cxx000066400000000000000000000222471301006202600242770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_4.tif} // OUTPUTS: {SEMClassif.png} // 4 40 5 // Software Guide : EndCommandLineArgs // // Software Guide : BeginLatex // // In this example, we present OTB's implementation of SEM, through the class // \doxygen{otb}{SEMClassifier}. This class performs a stochastic version // of the EM algorithm, but instead of inheriting from // \doxygen{itk}{ExpectationMaximizationMixtureModelEstimator}, we chose to // inherit from \subdoxygen{itk}{Statistics}{ListSample< TSample >}, // in the same way as \doxygen{otb}{SVMClassifier}. // // The program begins with \doxygen{otb}{VectorImage} and outputs // \doxygen{itb}{Image}. Then appropriate header files have to be included: // // Software Guide : EndLatex #include #include "itkVector.h" #include "itkVariableLengthVector.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \doxygen{otb}{SEMClassifier} performs estimation of mixture to fit the // initial histogram. Actually, mixture of Gaussian pdf can be performed. // Those generic pdf are treated in // \subdoxygen{otb}{Statistics}{ModelComponentBase}. The Gaussian model // is taken in charge with the class // \subdoxygen{otb}{Statistics}{GaussianModelComponent}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSEMClassifier.h" // Software Guide : EndCodeSnippet int main(int argc, char * argv[]) { try { if (argc != 6) { std::cerr << "Unsupervised Image Segmentation with SEM approach\n"; std::cerr << argv[0] << " imageIn imgClassif num_of_class "; std::cerr << "nbIteration size_of_the_neighborhood\n"; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Input/Output images type are define in a classical way. // In fact, a \doxygen{itk}{VariableLengthVector} is to be // considered for the templated \code{MeasurementVectorType}, which // will be used in the \code{ListSample} interface. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet char * fileNameIn = argv[1]; char * fileNameImgInit = ITK_NULLPTR; char * fileNameOut = argv[2]; int numberOfClasses = atoi(argv[3]); int numberOfIteration = atoi(argv[4]); int neighborhood = atoi(argv[5]); double terminationThreshold = 1e-5; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(fileNameIn); reader->Update(); // Software Guide : BeginLatex // // Once the input image is opened, the classifier may be initialised by // \code{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SEMClassifier ClassifType; ClassifType::Pointer classifier = ClassifType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, it follows, classical initializations of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet classifier->SetNumberOfClasses(numberOfClasses); classifier->SetMaximumIteration(numberOfIteration); classifier->SetNeighborhood(neighborhood); classifier->SetTerminationThreshold(terminationThreshold); classifier->SetSample(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // When an initial segmentation is available, the classifier may use it // as image (of type \code{OutputImageType}) or as a // \doxygen{itk}{SampleClassifier} result (of type // \subdoxygen{itk}{Statistics}{MembershipSample< SampleType >}). // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (fileNameImgInit != ITK_NULLPTR) { typedef otb::ImageFileReader ImgInitReaderType; ImgInitReaderType::Pointer segReader = ImgInitReaderType::New(); segReader->SetFileName(fileNameImgInit); segReader->Update(); classifier->SetClassLabels(segReader->GetOutput()); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // By default, \doxygen{otb}{SEMClassifier} performs initialization of // \code{ModelComponentBase} by as many instantiation of // \subdoxygen{otb}{Statistics}{GaussianModelComponent} as the number of // classes to estimate in the mixture. Nevertheless, the user may add specific // distribution into the mixture estimation. It is permitted by the use of // \code{AddComponent} for the given class number and the specific distribution. // Software Guide : EndLatex std::cerr << "Explicit component initialization\n"; // Software Guide : BeginCodeSnippet typedef ClassifType::ClassSampleType ClassSampleType; typedef otb::Statistics::GaussianModelComponent GaussianType; for (int i = 0; i < numberOfClasses; ++i) { GaussianType::Pointer model = GaussianType::New(); classifier->AddComponent(i, model); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the pipeline is instantiated. The segmentation by itself may be // launched by using the \code{Update} function. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { classifier->Update(); } // Software Guide : EndCodeSnippet catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught in " << argv[0] << "!\n"; std::cerr << err << std::endl; return -1; } // Software Guide : BeginLatex // // The segmentation may outputs a result of type // \subdoxygen{itk}{Statistics}{MembershipSample< SampleType >} as it is the // case for the \doxygen{otb}{SVMClassifier}. But when using // \code{GetOutputImage} the output is directly an Image. // // Only for visualization purposes, we choose to rescale the image of // classes before saving it to a file. We will use the // \doxygen{itk}{RescaleIntensityImageFilter} for this purpose. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); rescaler->SetInput(classifier->GetOutputImage()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(fileNameOut); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure \ref{fig:RESSEMCLASSIF} shows the result of the SEM segmentation // with 4 different classes and a contextual neighborhood of 3 pixels. // \begin{figure} // \center // \includegraphics[width=0.6\textwidth]{SEMClassif.eps} // \itkcaption[SEM Classification results]{SEM Classification results.} // \label{fig:RESSEMCLASSIF} // \end{figure} // // As soon as the segmentation is performed by an iterative stochastic // process, it is worth verifying the output status: does the segmentation // ends when it has converged or just at the limit of the iteration numbers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::cerr << "Program terminated with a "; if (classifier->GetTerminationCode() == ClassifType::CONVERGED) std::cerr << "converged "; else std::cerr << "not-converged "; std::cerr << "code...\n"; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The text output gives for each class the parameters of the pdf (e.g. mean // of each component of the class and there covariance matrix, in the case of a // Gaussian mixture model). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet classifier->Print(std::cerr); // Software Guide : EndCodeSnippet } catch (itk::ExceptionObject& err) { std::cerr << "Exception itk::ExceptionObject thrown !\n"; std::cerr << err << std::endl; return EXIT_FAILURE; } catch (...) { std::cerr << "Unknown exception thrown !\n"; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SOMClassifierExample.cxx000066400000000000000000000210371301006202600234410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbSOMMap.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkImageRegionIterator.h" #include "itkListSample.h" // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1.png}, {ROI_QB_MUL_SOM.png} // OUTPUTS: {ROI_QB_MUL_SOMCLASS.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the use of the // \doxygen{otb}{SOMClassifier} class for performing a classification // using an existing Kohonen's Self Organizing. Actually, the SOM // classification consists only in the attribution of the winner // neuron index to a given feature vector. // // We will use the SOM created in section \ref{sec:SOMColorTable} and // we will assume that each neuron represents a class in the image. // // The first thing to do is include the header file for the // class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSOMClassifier.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 4) { std::cout << "Usage : " << argv[0] << " inputImage modelFile outputImage" << std::endl; return EXIT_FAILURE; } const char * imageFilename = argv[1]; const char * mapFilename = argv[2]; const char * outputFilename = argv[3]; typedef double InputPixelType; typedef unsigned char LabelPixelType; const unsigned int Dimension = 2; typedef itk::VariableLengthVector PixelType; // Software Guide : BeginLatex // // As for the SOM learning step, we must define the types for the // \code{otb::SOMMap}, and therefore, also for the distance to be // used. We will also define the type for the SOM reader, which is // actually an \subdoxygen{otb}{ImageFileReader} which the appropriate // image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; typedef otb::ImageFileReader SOMReaderType; // Software Guide : EndCodeSnippet typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; // Software Guide : BeginLatex // // The classification will be performed by the // \subdoxygen{otb}{SOMClassifier}, which, as most of the // classifiers, works on // \subdoxygen{itk}{Statistics}{ListSample}s. In order to be able // to perform an image classification, we will need to use the // \subdoxygen{itk}{Statistics}{ImageToListAdaptor} which is // templated over the type of image to be adapted. The // \code{SOMClassifier} is templated over the sample type, the SOMMap // type and the pixel type for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::ListSample SampleType; typedef otb::SOMClassifier ClassifierType; // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // The result of the classification will be stored on an image and // saved to a file. Therefore, we define the types needed for this step. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We can now start reading the input image and the SOM given as // inputs to the program. We instantiate the readers as usual. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFilename); reader->Update(); SOMReaderType::Pointer somreader = SOMReaderType::New(); somreader->SetFileName(mapFilename); somreader->Update(); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // The conversion of the input data from image to list sample is // easily done using the adaptor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SampleType::Pointer sample = SampleType::New(); itk::ImageRegionIterator it(reader->GetOutput(), reader->GetOutput()-> GetLargestPossibleRegion()); sample->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); it.GoToBegin(); while (!it.IsAtEnd()) { sample->PushBack(it.Get()); ++it; } // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // The classifier can now be instantiated. The input data is set by // using the \code{SetSample()} method and the SOM si set using the // \code{SetMap()} method. The classification is triggered by using // the \code{Update()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifierType::Pointer classifier = ClassifierType::New(); classifier->SetSample(sample.GetPointer()); classifier->SetMap(somreader->GetOutput()); classifier->Update(); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // Once the classification has been performed, the sample list // obtained at the output of the classifier must be converted into an // image. We create the image as follows : // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OutputImageType::Pointer outputImage = OutputImageType::New(); outputImage->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); outputImage->Allocate(); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We can now get a pointer to the classification result. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifierType::OutputType* membershipSample = classifier->GetOutput(); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // And we can declare the iterators pointing to the front and the // back of the sample list. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We also declare an \subdoxygen{itk}{ImageRegionIterator} in order // to fill the output image with the class labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageRegionIterator OutputIteratorType; OutputIteratorType outIt(outputImage, outputImage->GetLargestPossibleRegion()); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We iterate through the sample list and the output image and assign // the label values to the image pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet outIt.GoToBegin(); while (m_iter != m_last && !outIt.IsAtEnd()) { outIt.Set(m_iter.GetClassLabel()); ++m_iter; ++outIt; } // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // Finally, we write the classified image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(outputImage); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure \ref{fig:SOMMAPCLASS} shows the result of the SOM classification. // \begin{figure} // \center // \includegraphics[width=0.35\textwidth]{ROI_QB_MUL_1.eps} // \includegraphics[width=0.2\textwidth]{ROI_QB_MUL_SOM.eps} // \includegraphics[width=0.35\textwidth]{ROI_QB_MUL_SOMCLASS.eps} // \itkcaption[SOM Image Classification]{Result of the SOM // learning. Left: RGB image. Center: SOM. Right: Classified Image} // \label{fig:SOMMAPCLASS} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SOMExample.cxx000066400000000000000000000354601301006202600214410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1.png} // OUTPUTS: {ROI_QB_MUL_SOM.png}, {ROI_QB_MUL_SOMACT.png} // 4 4 4 4 20 1.0 0.1 128 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the use of the // \doxygen{otb}{SOM} class for building Kohonen's Self Organizing // Maps. // // We will use the SOM in order to build a color table from an input // image. Our input image is coded with $3\times 8$ bits and we would // like to code it with only 16 levels. We will use the SOM in order // to learn which are the 16 most representative RGB values of the // input image and we will assume that this is the optimal color table // for the image. // // The first thing to do is include the header file for the // class. We will also need the header files for the map itself and // the activation map builder whose utility will be explained at the // end of the example. // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSOMMap.h" #include "otbSOM.h" #include "otbSOMActivationBuilder.h" // Software Guide : EndCodeSnippet #include "itkMacro.h" #include "itkVectorExpandImageFilter.h" #include "itkVectorNearestNeighborInterpolateImageFunction.h" #include "itkExpandImageFilter.h" #include "itkNearestNeighborInterpolateImageFunction.h" #include "otbPerBandVectorImageFilter.h" #include "otbPrintableImageFilter.h" // Software Guide : BeginLatex // Since the \doxygen{otb}{SOM} class uses a distance, we will need to // include the header file for the one we want to use // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkListSample.h" int main(int itkNotUsed(argc), char* argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const char * actMapFileName = argv[3]; unsigned int sizeX = atoi(argv[4]); unsigned int sizeY = atoi(argv[5]); unsigned int neighInitX = atoi(argv[6]); unsigned int neighInitY = atoi(argv[7]); unsigned int nbIterations = atoi(argv[8]); double betaInit = atof(argv[9]); double betaEnd = atof(argv[10]); double initValue = atof(argv[11]); // Software Guide : BeginLatex // // The Self Organizing Map itself is actually an N-dimensional image // where each pixel contains a neuron. In our case, we decide to build // a 2-dimensional SOM, where the neurons store RGB values with // floating point precision. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PixelType VectorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The distance that we want to apply between the RGB values is the // Euclidean one. Of course we could choose to use other type of // distance, as for instance, a distance defined in any other color space. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::EuclideanDistanceMetric DistanceType; // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We can now define the type for the map. The \subdoxygen{otb}{SOMMap} // class is templated over the neuron type -- \code{PixelType} here // --, the distance type and the number of dimensions. Note that the // number of dimensions of the map could be different from the one of // the images to be processed. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SOMMap MapType; // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We are going to perform the learning directly on the pixels of the // input image. Therefore, the image type is defined using the same // pixel type as we used for the map. We also define the type for the // imge file reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // Since the \doxygen{otb}{SOM} class works on lists of samples, it // will need to access the input image through an adaptor. Its type is // defined as follows: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::ListSample SampleListType; // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We can now define the type for the SOM, which is templated over the // input sample list and the type of the map to be produced and the two // functors that hold the training behavior. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Functor::CzihoSOMLearningBehaviorFunctor LearningBehaviorFunctorType; typedef otb::Functor::CzihoSOMNeighborhoodBehaviorFunctor NeighborhoodBehaviorFunctorType; typedef otb::SOM SOMType; // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // As an alternative to standard \code{SOMType}, one can decide to use // an \doxygen{otb}{PeriodicSOM}, which behaves like \doxygen{otb}{SOM} but // is to be considered to as a torus instead of a simple map. Hence, the // neighborhood behavior of the winning neuron does not depend on its location // on the map... // \doxygen{otb}{PeriodicSOM} is defined in otbPeriodicSOM.h. // // We can now start building the pipeline. The first step is to // instantiate the reader and pass its output to the adaptor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); reader->Update(); SampleListType::Pointer sampleList = SampleListType::New(); sampleList->SetMeasurementVectorSize(reader->GetOutput()->GetVectorLength()); itk::ImageRegionIterator imgIter (reader->GetOutput(), reader->GetOutput()-> GetBufferedRegion()); imgIter.GoToBegin(); itk::ImageRegionIterator imgIterEnd (reader->GetOutput(), reader->GetOutput()-> GetBufferedRegion()); imgIterEnd.GoToEnd(); do { sampleList->PushBack(imgIter.Get()); ++imgIter; } while (imgIter != imgIterEnd); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We can now instantiate the SOM algorithm and set the sample list as input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SOMType::Pointer som = SOMType::New(); som->SetListSample(sampleList); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // We use a \code{SOMType::SizeType} array in order to set the sizes // of the map. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SOMType::SizeType size; size[0] = sizeX; size[1] = sizeY; som->SetMapSize(size); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // The initial size of the neighborhood of each neuron is set in the // same way. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SOMType::SizeType radius; radius[0] = neighInitX; radius[1] = neighInitY; som->SetNeighborhoodSizeInit(radius); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // The other parameters are the number of iterations, the initial and // the final values for the learning rate -- $\beta$ -- and the // maximum initial value for the neurons (the map will be randomly // initialized). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet som->SetNumberOfIterations(nbIterations); som->SetBetaInit(betaInit); som->SetBetaEnd(betaEnd); som->SetMaxWeight(static_cast(initValue)); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // Now comes the initialization of the functors. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LearningBehaviorFunctorType learningFunctor; learningFunctor.SetIterationThreshold(radius, nbIterations); som->SetBetaFunctor(learningFunctor); NeighborhoodBehaviorFunctorType neighborFunctor; som->SetNeighborhoodSizeFunctor(neighborFunctor); som->Update(); // Software Guide : EndCodeSnippet // // Software Guide : BeginLatex // // Finally, we set up the las part of the pipeline where the plug the // output of the SOM into the writer. The learning procedure is // triggered by calling the \code{Update()} method on the writer. // Since the map is itself an image, we can write it to disk with an // \doxygen{otb}{ImageFileWriter}. // // Software Guide : EndLatex //Just for visualization purposes, we zoom the image, and pass it to the printable image filter typedef otb::Image SingleImageType; typedef itk::ExpandImageFilter ExpandType; typedef otb::PerBandVectorImageFilter VectorExpandType; typedef itk::NearestNeighborInterpolateImageFunction InterpolatorType; typedef otb::PrintableImageFilter PrintableFilterType; typedef otb::ImageFileWriter PrintableWriterType; InterpolatorType::Pointer interpolator = InterpolatorType::New(); VectorExpandType::Pointer expand = VectorExpandType::New(); ExpandType::Pointer scalarExpand = ExpandType::New(); scalarExpand->SetExpandFactors(40); scalarExpand->SetInterpolator(interpolator); //scalarExpand->SetEdgePaddingValue(255); expand->SetFilter(scalarExpand); expand->SetInput(som->GetOutput()); expand->UpdateOutputInformation(); PrintableFilterType::Pointer printFilter = PrintableFilterType::New(); printFilter->SetInput(expand->GetOutput()); printFilter->SetChannel(1); printFilter->SetChannel(2); printFilter->SetChannel(3); PrintableWriterType::Pointer printWriter = PrintableWriterType::New(); printWriter->SetInput(printFilter->GetOutput()); printWriter->SetFileName(outputFileName); printWriter->Update(); // Software Guide : BeginLatex // Figure \ref{fig:SOMMAP} shows the result of the SOM learning. Since // we have performed a learning on RGB pixel values, the produced SOM // can be interpreted as an optimal color table for the input // image. It can be observed that the obtained colors are // topologically organised, so similar colors are also close in the // map. This topological organisation can be exploited to further // reduce the number of coding levels of the pixels without // performing a new learning: we can subsample the map to get a new // color table. Also, a bilinear interpolation between the neurons can // be used to increase the number of coding levels. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{ROI_QB_MUL_1.eps} // \includegraphics[width=0.2\textwidth]{ROI_QB_MUL_SOM.eps} // \includegraphics[width=0.2\textwidth]{ROI_QB_MUL_SOMACT.eps} // \itkcaption[SOM Image Classification]{Result of the SOM // learning. Left: RGB image. Center: SOM. Right: Activation map} // \label{fig:SOMMAP} // \end{figure} // Software Guide : EndLatex // Software Guide : BeginLatex // // We can now compute the activation map for the input image. The // activation map tells us how many times a given neuron is activated // for the set of examples given to the map. The activation map is // stored as a scalar image and an integer pixel type is usually enough. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter ActivationWriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In a similar way to the \doxygen{otb}{SOM} class the // \doxygen{otb}{SOMActivationBuilder} is templated over the sample // list given as input, the SOM map type and the activation map to be // built as output. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SOMActivationBuilder SOMActivationBuilderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the activation map builder and set as input the SOM // map build before and the image (using the adaptor). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SOMActivationBuilderType::Pointer somAct = SOMActivationBuilderType::New(); somAct->SetInput(som->GetOutput()); somAct->SetListSample(sampleList); somAct->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The final step is to write the activation map to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (actMapFileName != ITK_NULLPTR) { ActivationWriterType::Pointer actWriter = ActivationWriterType::New(); actWriter->SetFileName(actMapFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The righthand side of figure \ref{fig:SOMMAP} shows the activation // map obtained. // // Software Guide : EndLatex //Just for visualization purposes, we zoom the image. typedef itk::ExpandImageFilter ExpandType2; typedef itk::NearestNeighborInterpolateImageFunction InterpolatorType2; InterpolatorType2::Pointer interpolator2 = InterpolatorType2::New(); ExpandType2::Pointer expand2 = ExpandType2::New(); expand2->SetInput(somAct->GetOutput()); expand2->SetExpandFactors(20); expand2->SetInterpolator(interpolator2); //expand2->SetEdgePaddingValue(255); expand2->UpdateOutputInformation(); actWriter->SetInput(expand2->GetOutput()); actWriter->Update(); } else { std::cerr << "The activation map file name is null" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMGenericKernelImageClassificationExample.cxx000066400000000000000000000133631301006202600277230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" // Software Guide : BeginLatex // This example illustrates the modifications to be added to use the // \doxygen{otb}{SVMClassifier} class for performing SVM // classification on images with a user-defined kernel. // In this example, we will use an SVM model estimated in the previous // section to separate between water and non-water pixels by using the RGB // values only. // The first thing to do is include the header file for the // class as well as the header of the appropriated kernel to be used. // // // Software Guide : EndLatex #include "itkImageToListSampleAdaptor.h" // Software Guide : BeginCodeSnippet #include "otbSVMClassifier.h" #include "otbMixturePolyRBFKernelFunctor.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 4) { std::cout << "Usage : " << argv[0] << " inputImage outputImage modelFile " << std::endl; return EXIT_FAILURE; } const char * imageFilename = argv[1]; const char * modelFilename = argv[3]; const char * outputFilename = argv[2]; typedef double PixelType; typedef int LabelPixelType; const unsigned int Dimension = 2; typedef otb::Image, Dimension> InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFilename); reader->Update(); typedef itk::Statistics::ImageToListSampleAdaptor SampleType; SampleType::Pointer sample = SampleType::New(); sample->SetImage(reader->GetOutput()); // Software Guide : BeginLatex // // We need to declare the SVM model which is to be used by the // classifier. The SVM model is templated over the type of value used // for the measures and the type of pixel used for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMModel ModelType; ModelType::Pointer model = ModelType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After instantiation, we can load a model saved to a file (see // section \ref{ssec:LearningFromImages} for an example of model // estimation and storage to a file). // // When using a user defined kernel, an explicit instantiation has // to be performed. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::MixturePolyRBFKernelFunctor myKernel; model->SetKernelFunctor(&myKernel); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, the rest of the classification program remains unchanged. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet model->LoadModel(modelFilename); // Software Guide : EndCodeSnippet typedef otb::SVMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); int numberOfClasses = model->GetNumberOfClasses(); classifier->SetNumberOfClasses(numberOfClasses); classifier->SetModel(model); classifier->SetInput(sample.GetPointer()); classifier->Update(); typedef ClassifierType::ClassLabelType OutputPixelType; typedef otb::Image OutputImageType; OutputImageType::Pointer outputImage = OutputImageType::New(); typedef itk::Index myIndexType; typedef itk::Size mySizeType; typedef itk::ImageRegion myRegionType; mySizeType size; size[0] = reader->GetOutput()->GetRequestedRegion().GetSize()[0]; size[1] = reader->GetOutput()->GetRequestedRegion().GetSize()[1]; myIndexType start; start[0] = 0; start[1] = 0; myRegionType region; region.SetIndex(start); region.SetSize(size); outputImage->SetRegions(region); outputImage->Allocate(); ClassifierType::OutputType* membershipSample = classifier->GetOutput(); ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); typedef itk::ImageRegionIterator OutputIteratorType; OutputIteratorType outIt(outputImage, outputImage->GetBufferedRegion()); outIt.GoToBegin(); while (m_iter != m_last && !outIt.IsAtEnd()) { outIt.Set(m_iter.GetClassLabel()); ++m_iter; ++outIt; } typedef otb::Image FileImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); rescaler->SetInput(outputImage); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(rescaler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMGenericKernelImageModelEstimatorExample.cxx000066400000000000000000000120751301006202600277170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // This example illustrates the modifications to be added to the // use of \doxygen{otb}{SVMImageModelEstimator} in order to add a // user defined kernel. This initial program has been explained in section // \ref{ssec:LearningFromImages}. // // The first thing to do is to include the header file for the new kernel. // // Software Guide : EndLatex #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include // Software Guide : BeginCodeSnippet #include "otbSVMImageModelEstimator.h" #include "otbMixturePolyRBFKernelFunctor.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" int main(int argc, char* argv[]) { if (argc != 4) { std::cerr << "Usage : " << argv[0] << " inputImage mask modelFile\n"; return EXIT_FAILURE; } const char* inputImageFileName = argv[1]; const char* trainingImageFileName = argv[2]; const char* outputModelFileName = argv[3]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image TrainingImageType; typedef otb::SVMImageModelEstimator EstimatorType; typedef otb::ImageFileReader InputReaderType; typedef otb::ImageFileReader TrainingReaderType; InputReaderType::Pointer inputReader = InputReaderType::New(); TrainingReaderType::Pointer trainingReader = TrainingReaderType::New(); inputReader->SetFileName(inputImageFileName); trainingReader->SetFileName(trainingImageFileName); inputReader->Update(); trainingReader->Update(); // Software Guide : BeginLatex // // Once the \doxygen{otb}{SVMImageModelEstimator} is instantiated, // it is possible to add the new kernel and its parameters. // // Then in addition to the initial code: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet EstimatorType::Pointer svmEstimator = EstimatorType::New(); svmEstimator->SetSVMType(C_SVC); svmEstimator->SetInputImage(inputReader->GetOutput()); svmEstimator->SetTrainingImage(trainingReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The instantiation of the kernel is to be implemented. The kernel which is // used here is a linear combination of a polynomial kernel and an RBF one. // It is written as $$\mu k_1(x, y) + (1-\mu) k_2(x, y)$$ with // $k_1(x, y)=\left( \gamma_1 x\cdot y + c_0 \right) ^d$ and // $k_2(x, y) = \exp\left( - \gamma_2 \| x-y\|^2 \right)$. Then, the specific // parameters of this kernel are: // \begin{itemize} // \item \code{Mixture} ($\mu$), // \item \code{GammaPoly} ($\gamma_1$), // \item \code{CoefPoly} ($c_0$), // \item \code{DegreePoly} ($d$), // \item \code{GammaRBF} ($\gamma_2$). // \end{itemize} // Their instantiations are achieved through the use of the \code{SetValue} // function. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::MixturePolyRBFKernelFunctor myKernel; myKernel.SetValue("Mixture", 0.5); myKernel.SetValue("GammaPoly", 1.0); myKernel.SetValue("CoefPoly", 0.0); myKernel.SetValue("DegreePoly", 1); myKernel.SetValue("GammaRBF", 1.5); myKernel.Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the kernel's parameters are affected and the kernel updated, // the connection to \doxygen{otb}{SVMImageModelEstimator} takes place here. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet svmEstimator->SetKernelFunctor(&myKernel); svmEstimator->SetKernelType(GENERIC); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The model estimation procedure is triggered by calling the // estimator's \code{Update} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet svmEstimator->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The rest of the code remains unchanged... // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet svmEstimator->SaveModel(outputModelFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In the file \code{outputModelFileName} a specific line will appear when using a // generic kernel. It gives the name of the kernel and its parameters name and value. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMImageClassificationExample.cxx000066400000000000000000000240411301006202600252600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1.png} // OUTPUTS: {ROI_QB_MUL_1_SVN_CLASS.png} // ${OTB_DATA_ROOT}/Examples/svm_image_model.svm // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the use of the // \doxygen{otb}{SVMClassifier} class for performing SVM // classification on images. // In this example, we will use an SVM model estimated in the example // of section \ref{sec:LearningWithImages} // to separate between water and non-water pixels by using the RGB // values only. The images used for this example are shown in // figure~\ref{fig:SVMROIS}. // The first thing to do is include the header file for the // class. Since the \doxygen{otb}{SVMClassifier} takes // \doxygen{itk}{ListSample}s as input, the class // \doxygen{itk}{PointSetToListAdaptor} is needed. // // // Software Guide : EndLatex #include "itkImageToListSampleAdaptor.h" // Software Guide : BeginCodeSnippet #include "otbSVMClassifier.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 4) { std::cout << "Usage : " << argv[0] << " inputImage outputImage modelFile " << std::endl; return EXIT_FAILURE; } const char * imageFilename = argv[1]; const char * modelFilename = argv[3]; const char * outputFilename = argv[2]; // Software Guide : BeginLatex // // In the framework of supervised learning and classification, we will // always use feature vectors for the characterization of the // classes. On the other hand, the class labels are scalar // values. Here, we start by defining the type of the features as the // \code{PixelType}, which will be used to define the feature // \code{VectorType}. We also declare the type for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PixelType; typedef int LabelPixelType; // Software Guide : EndCodeSnippet const unsigned int Dimension = 2; // Software Guide : BeginLatex // // We can now proceed to define the image type used for storing the // features. We also define the reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image, Dimension> InputImageType; typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now read the image by calling the \code{Update} method of the reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFilename); reader->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image has now to be transformed to a sample which // is compatible with the classification framework. We will use a // \doxygen{itk}{Statistics::ImageToListSampleAdaptor} for this // task. This class is templated over the image type used for // storing the measures. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::ImageToListSampleAdaptor SampleType; SampleType::Pointer sample = SampleType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After instantiation, we can set the image as an imput of our // sample adaptor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet sample->SetImage(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we need to declare the SVM model which is to be used by the // classifier. The SVM model is templated over the type of value used // for the measures and the type of pixel used for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMModel ModelType; ModelType::Pointer model = ModelType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After instantiation, we can load a model saved to a file (see // section \ref{sec:LearningWithImages} for an example of model // estimation and storage to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet model->LoadModel(modelFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We have now all the elements to create a classifier. The classifier // is templated over the sample type (the type of the data to be // classified) and the label type (the type of the output of the classifier). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the classifier parameters : number of classes, SVM model, // the sample data. And we trigger the classification process by // calling the \code{Update} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet int numberOfClasses = model->GetNumberOfClasses(); classifier->SetNumberOfClasses(numberOfClasses); classifier->SetModel(model); classifier->SetInput(sample.GetPointer()); classifier->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After the classification step, we usually want to get the // results. The classifier gives an output under the form of a sample // list. This list supports the classical STL iterators. Therefore, we // will create an output image and fill it up with the results of the // classification. The pixel type of the output image is the same as // the one used for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ClassifierType::ClassLabelType OutputPixelType; typedef otb::Image OutputImageType; OutputImageType::Pointer outputImage = OutputImageType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We allocate the memory for the output image using the information // from the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Index myIndexType; typedef itk::Size mySizeType; typedef itk::ImageRegion myRegionType; mySizeType size; size[0] = reader->GetOutput()->GetRequestedRegion().GetSize()[0]; size[1] = reader->GetOutput()->GetRequestedRegion().GetSize()[1]; myIndexType start; start[0] = 0; start[1] = 0; myRegionType region; region.SetIndex(start); region.SetSize(size); outputImage->SetRegions(region); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now declare the iterators on the list that we get at the // output of the classifier as well as the iterator to fill the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifierType::OutputType* membershipSample = classifier->GetOutput(); ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); typedef itk::ImageRegionIterator OutputIteratorType; OutputIteratorType outIt(outputImage, outputImage->GetBufferedRegion()); outIt.GoToBegin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will iterate through the list, get the labels and assign pixel // values to the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (m_iter != m_last && !outIt.IsAtEnd()) { outIt.Set(m_iter.GetClassLabel()); ++m_iter; ++outIt; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Only for visualization purposes, we choose to rescale the image of // classes before saving it to a file. We will use the // \doxygen{itk}{RescaleIntensityImageFilter} for this purpose. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image FileImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); rescaler->SetInput(outputImage); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now create an image file writer and save the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure \ref{fig:SVMCLASS} shows the result of the SVM classification. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{ROI_QB_MUL_1.eps} // \includegraphics[width=0.45\textwidth]{ROI_QB_MUL_1_SVN_CLASS.eps} // \itkcaption[SVM Image Classification]{Result of the SVM // classification . Left: RGB image. Right: image of classes.} // \label{fig:SVMCLASS} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMImageEstimatorClassificationMultiExample.cxx000066400000000000000000000315601301006202600301670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1.png}, {ROI_mask_multi.png} // OUTPUTS: {ROI_QB_MUL_1_SVN_CLASS_MULTI.png}, {ROI_QB_MUL_1_SVN_CLASS_MULTI_Rescaled.jpg} // NORMALIZE_EPS_OUTPUT_OF: {ROI_mask_multi.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the OTB's multi-class SVM // capabilities. The theory behind this kind of classification is out // of the scope of this guide. In OTB, the multi-class SVM // classification is used in the same way as the two-class // one. Figure~\ref{fig:SVMROISMULTI} shows the image to be classified // and the associated ground truth, which is composed of 4 classes. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{ROI_QB_MUL_1.eps} // \includegraphics[width=0.45\textwidth]{ROI_mask_multi.eps} // \itkcaption[SVM Image Model Estimation]{Images used for the // estimation of the SVM model. Left: RGB image. Right: image of labels.} // \label{fig:SVMROISMULTI} // \end{figure} // The following header files are needed for the program: // Software Guide : EndLatex #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include // Software Guide : BeginCodeSnippet #include "otbSVMImageModelEstimator.h" #include "itkImageToListSampleAdaptor.h" #include "otbSVMClassifier.h" // Software Guide : EndCodeSnippet #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkScalarToRGBPixelFunctor.h" #include "otbImageFileReader.h" int main(int itkNotUsed(argc), char *argv[]) { const char* inputImageFileName = argv[1]; const char* trainingImageFileName = argv[2]; const char* outputImageFileName = argv[3]; const char* outputRescaledImageFileName = argv[4]; // const char* outputModelFileName = argv[4]; // Software Guide : BeginLatex // // We define the types for the input and training images. Even if the // input image will be an RGB image, we can read it as a 3 component // vector image. This simplifies the interfacing with OTB's SVM // framework. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image TrainingImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{SVMImageModelEstimator} class is templated over // the input (features) and the training (labels) images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMImageModelEstimator EstimatorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As usual, we define the readers for the images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader InputReaderType; typedef otb::ImageFileReader TrainingReaderType; InputReaderType::Pointer inputReader = InputReaderType::New(); TrainingReaderType::Pointer trainingReader = TrainingReaderType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We read the images. It is worth to note that, in order to ensure // the pipeline coherence, the output of the objects which precede the // model estimator in the pipeline, must be up to date, so we call // the corresponding \code{Update} methods. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet inputReader->SetFileName(inputImageFileName); trainingReader->SetFileName(trainingImageFileName); inputReader->Update(); trainingReader->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the model estimator and set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet EstimatorType::Pointer svmEstimator = EstimatorType::New(); svmEstimator->SetInputImage(inputReader->GetOutput()); svmEstimator->SetTrainingImage(trainingReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The model estimation procedure is triggered by calling the // estimator's \code{Update} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet svmEstimator->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now proceed to the image classification. We start by // declaring the type of the image to be classified. ITK's // classification framework needs the type of the pixel to be of // fixed type, so we declare the following types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image, Dimension> ClassifyImageType; typedef otb::ImageFileReader ClassifyReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now read the image by calling the \code{Update} method of the reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifyReaderType::Pointer cReader = ClassifyReaderType::New(); cReader->SetFileName(inputImageFileName); cReader->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The image has now to be transformed to a sample which // is compatible with the classification framework. We will use a // \doxygen{itk}{Statistics::ImageToListSampleAdaptor} for this // task. This class is templated over the image type used for // storing the measures. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::ImageToListSampleAdaptor SampleType; SampleType::Pointer sample = SampleType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After instantiation, we can set the image as an imput of our // sample adaptor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet sample->SetImage(cReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we need to declare the SVM model which is to be used by the // classifier. The SVM model is templated over the type of value used // for the measures and the type of pixel used for the labels. The // model is obtained from the model estimator by calling the // \code{GetModel} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef InputPixelType LabelPixelType; typedef otb::SVMModel ModelType; ModelType::Pointer model = svmEstimator->GetModel(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We have now all the elements to create a classifier. The classifier // is templated over the sample type (the type of the data to be // classified) and the label type (the type of the output of the classifier). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the classifier parameters : number of classes, SVM model, // the sample data. And we trigger the classification process by // calling the \code{Update} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet int numberOfClasses = model->GetNumberOfClasses(); classifier->SetNumberOfClasses(numberOfClasses); classifier->SetModel(model); classifier->SetInput(sample.GetPointer()); classifier->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After the classification step, we usually want to get the // results. The classifier gives an output under the form of a sample // list. This list supports the classical STL iterators. Therefore, we // will create an output image and fill it up with the results of the // classification. The pixel type of the output image is the same as // the one used for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ClassifierType::ClassLabelType OutputPixelType; typedef otb::Image OutputImageType; OutputImageType::Pointer outputImage = OutputImageType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We allocate the memory for the output image using the information // from the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Index myIndexType; typedef itk::Size mySizeType; typedef itk::ImageRegion myRegionType; mySizeType size; size[0] = cReader->GetOutput()->GetRequestedRegion().GetSize()[0]; size[1] = cReader->GetOutput()->GetRequestedRegion().GetSize()[1]; myIndexType start; start[0] = 0; start[1] = 0; myRegionType region; region.SetIndex(start); region.SetSize(size); outputImage->SetRegions(region); outputImage->Allocate(); std::cout << "---" << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now declare the iterators on the list that we get at the // output of the classifier as well as the iterator to fill the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifierType::OutputType* membershipSample = classifier->GetOutput(); ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); typedef itk::ImageRegionIterator OutputIteratorType; OutputIteratorType outIt(outputImage, outputImage->GetBufferedRegion()); outIt.GoToBegin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will iterate through the list, get the labels and assign pixel // values to the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (m_iter != m_last && !outIt.IsAtEnd()) { outIt.Set(m_iter.GetClassLabel()); ++m_iter; ++outIt; } std::cout << "---" << std::endl; // Software Guide : EndCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageFileName); writer->SetInput(outputImage); writer->Update(); // Software Guide : BeginLatex // // Only for visualization purposes, we choose a color mapping to the image of // classes before saving it to a file. The // \subdoxygen{itk}{Functor}{ScalarToRGBPixelFunctor} class is a special // function object designed to hash a scalar value into an // \doxygen{itk}{RGBPixel}. Plugging this functor into the // \doxygen{itk}{UnaryFunctorImageFilter} creates an image filter for that // converts scalar images to RGB images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RGBPixel RGBPixelType; typedef otb::Image RGBImageType; typedef itk::Functor::ScalarToRGBPixelFunctor ColorMapFunctorType; typedef itk::UnaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->SetInput(outputImage); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now create an image file writer and save the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterRescaledType; WriterRescaledType::Pointer writerRescaled = WriterRescaledType::New(); writerRescaled->SetFileName(outputRescaledImageFileName); writerRescaled->SetInput(colormapper->GetOutput()); writerRescaled->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure \ref{fig:SVMCLASSMULTI} shows the result of the SVM classification. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{ROI_QB_MUL_1.eps} // \includegraphics[width=0.45\textwidth]{ROI_QB_MUL_1_SVN_CLASS_MULTI_Rescaled.eps} // \itkcaption[SVM Image Classification]{Result of the SVM // classification . Left: RGB image. Right: image of classes.} // \label{fig:SVMCLASSMULTI} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMImageModelEstimatorExample.cxx000066400000000000000000000115331301006202600252570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1.png}, {ROI_mask.png} // OUTPUTS: {svm_image_model.svn} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the use of the // \doxygen{otb}{SVMImageModelEstimator} class. This class allows the // estimation of a SVM model (supervised learning) from a feature // image and an image of labels. In this example, we will train an SVM // to separate between water and non-water pixels by using the RGB // values only. The images used for this example are shown in // figure~\ref{fig:SVMROIS}. // \begin{figure} // \center // \includegraphics[width=0.45\textwidth]{ROI_QB_MUL_1.eps} // \includegraphics[width=0.45\textwidth]{ROI_mask.eps} // \itkcaption[SVM Image Model Estimation]{Images used for the // estimation of the SVM model. Left: RGB image. Right: image of labels.} // \label{fig:SVMROIS} // \end{figure} // The first thing to do is include the header file for the class. // // Software Guide : EndLatex #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include // Software Guide : BeginCodeSnippet #include "otbSVMImageModelEstimator.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" int main(int itkNotUsed(argc), char* argv[]) { const char* inputImageFileName = argv[1]; const char* trainingImageFileName = argv[2]; const char* outputModelFileName = argv[3]; // Software Guide : BeginLatex // // We define the types for the input and training images. Even if the // input image will be an RGB image, we can read it as a 3 component // vector image. This simplifies the interfacing with OTB's SVM // framework. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image TrainingImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{SVMImageModelEstimator} class is templated over // the input (features) and the training (labels) images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMImageModelEstimator EstimatorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As usual, we define the readers for the images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader InputReaderType; typedef otb::ImageFileReader TrainingReaderType; InputReaderType::Pointer inputReader = InputReaderType::New(); TrainingReaderType::Pointer trainingReader = TrainingReaderType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We read the images. It is worth to note that, in order to ensure // the pipeline coherence, the output of the objects which precede the // model estimator in the pipeline, must be up to date, so we call // the corresponding \code{Update} methods. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet inputReader->SetFileName(inputImageFileName); trainingReader->SetFileName(trainingImageFileName); inputReader->Update(); trainingReader->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the model estimator and set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet EstimatorType::Pointer svmEstimator = EstimatorType::New(); svmEstimator->SetInputImage(inputReader->GetOutput()); svmEstimator->SetTrainingImage(trainingReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The model estimation procedure is triggered by calling the // estimator's \code{Update} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet svmEstimator->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the estimated model can be saved to a file for later use. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet svmEstimator->SaveModel(outputModelFileName); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMPointSetClassificationExample.cxx000066400000000000000000000224131301006202600260040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {svm_model.svn} // OUTPUTS: // Software Guide : EndCommandLineArgs #include "itkMacro.h" #include #include // Software Guide : BeginLatex // This example illustrates the use of the // \doxygen{otb}{SVMClassifier} class for performing SVM // classification on pointsets. // The first thing to do is include the header file for the // class. Since the \doxygen{otb}{SVMClassifier} takes // \doxygen{itk}{ListSample}s as input, the class // \doxygen{itk}{PointSetToListSampleAdaptor} is needed. // // We start by including the needed header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkPointSetToListSampleAdaptor.h" #include "otbSVMClassifier.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* argv[]) { // Software Guide : BeginLatex // // In the framework of supervised learning and classification, we will // always use feature vectors for the characterization of the // classes. On the other hand, the class labels are scalar // values. Here, we start by defining the type of the features as the // \code{PixelType}, which will be used to define the feature // \code{VectorType}. We also declare the type for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef std::vector InputVectorType; typedef int LabelPixelType; // Software Guide : EndCodeSnippet const unsigned int Dimension = 2; // Software Guide : BeginLatex // // We can now proceed to define the point sets used for storing the // features and the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::PointSet MeasurePointSetType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will need to get access to the data stored in the point sets, so // we define the appropriate for the points and the points containers // used by the point sets (see the section \ref{sec:PointSetSection} // for more information on how to use point sets). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef MeasurePointSetType::PointType MeasurePointType; typedef MeasurePointSetType::PointsContainer MeasurePointsContainer; MeasurePointSetType::Pointer tPSet = MeasurePointSetType::New(); MeasurePointsContainer::Pointer tCont = MeasurePointsContainer::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need now to build the test set for the SVM. In this // simple example, we will build a SVM who classes points depending on // which side of the line $x=y$ they are located. We start by // generating 500 random points. // // Software Guide : EndLatex srand(0); unsigned int pointId; // Software Guide : BeginCodeSnippet int lowest = 0; int range = 1000; for (pointId = 0; pointId < 100; pointId++) { MeasurePointType tP; int x_coord = lowest + static_cast(range * (rand() / (RAND_MAX + 1.0))); int y_coord = lowest + static_cast(range * (rand() / (RAND_MAX + 1.0))); std::cout << "coords : " << x_coord << " " << y_coord << std::endl; tP[0] = x_coord; tP[1] = y_coord; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We push the features in the vector after a normalization which is // useful for SVM convergence. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputVectorType measure; measure.push_back(static_cast((x_coord * 1.0 - lowest) / range)); measure.push_back(static_cast((y_coord * 1.0 - lowest) / range)); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we insert the points in the points container. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet tCont->InsertElement(pointId, tP); tPSet->SetPointData(pointId, measure); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After the loop, we set the points container to the point set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet tPSet->SetPoints(tCont); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the pointset is ready, we must transform it to a sample which // is compatible with the classification framework. We will use a // \doxygen{itk}{Statistics::PointSetToListSampleAdaptor} for this // task. This class is templated over the point set type used for // storing the measures. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::PointSetToListSampleAdaptor SampleType; SampleType::Pointer sample = SampleType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After instantiation, we can set the point set as an imput of our // sample adaptor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet sample->SetPointSet(tPSet); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we need to declare the SVM model which is to be used by the // classifier. The SVM model is templated over the type of value used // for the measures and the type of pixel used for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMModel ModelType; ModelType::Pointer model = ModelType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After instantiation, we can load a model saved to a file (see // section \ref{sec:LearningWithPointSets} for an example of model // estimation and storage to a file). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet model->LoadModel(argv[1]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We have now all the elements to create a classifier. The classifier // is templated over the sample type (the type of the data to be // classified) and the label type (the type of the output of the classifier). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the classifier parameters : number of classes, SVM model, // the sample data. And we trigger the classification process by // calling the \code{Update} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet int numberOfClasses = model->GetNumberOfClasses(); classifier->SetNumberOfClasses(numberOfClasses); classifier->SetModel(model); classifier->SetInput(sample.GetPointer()); classifier->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After the classification step, we usually want to get the // results. The classifier gives an output under the form of a sample // list. This list supports the classical STL iterators. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifierType::OutputType* membershipSample = classifier->GetOutput(); ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will iterate through the list, get the labels and compute the // classification error. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double error = 0.0; pointId = 0; while (m_iter != m_last) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the label for each point. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ClassifierType::ClassLabelType label = m_iter.GetClassLabel(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we compare it to the corresponding one of the test set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputVectorType measure; tPSet->GetPointData(pointId, &measure); ClassifierType::ClassLabelType expectedLabel; if (measure[0] < measure[1]) expectedLabel = -1; else expectedLabel = 1; double dist = fabs(measure[0] - measure[1]); if (label != expectedLabel) error++; std::cout << int(label) << "/" << int(expectedLabel) << " --- " << dist << std::endl; ++pointId; ++m_iter; } std::cout << "Error = " << error / pointId << " % " << std::endl; // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMPointSetExample.cxx000066400000000000000000000142761301006202600231400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbSVMPointSetModelEstimator.h" #include "itkPointSetToListSampleAdaptor.h" #include "otbSVMClassifier.h" int main(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef float InputPixelType; typedef std::vector InputVectorType; typedef int LabelPixelType; const unsigned int Dimension = 2; typedef itk::PointSet MeasurePointSetType; typedef itk::PointSet LabelPointSetType; MeasurePointSetType::Pointer mPSet = MeasurePointSetType::New(); LabelPointSetType::Pointer lPSet = LabelPointSetType::New(); typedef MeasurePointSetType::PointType MeasurePointType; typedef LabelPointSetType::PointType LabelPointType; typedef MeasurePointSetType::PointsContainer MeasurePointsContainer; typedef LabelPointSetType::PointsContainer LabelPointsContainer; MeasurePointsContainer::Pointer mCont = MeasurePointsContainer::New(); LabelPointsContainer::Pointer lCont = LabelPointsContainer::New(); /* We learn the y>x | y(range * (rand() / (RAND_MAX + 1.0))); int y_coord = lowest + static_cast(range * (rand() / (RAND_MAX + 1.0))); std::cout << "coords : " << x_coord << " " << y_coord << std::endl; mP[0] = x_coord; mP[1] = y_coord; lP[0] = x_coord; lP[1] = y_coord; InputVectorType measure; measure.push_back(static_cast((x_coord * 1.0 - lowest) / range)); measure.push_back(static_cast((y_coord * 1.0 - lowest) / range)); LabelPixelType label; if (x_coord < y_coord) label = 0; else label = 1; std::cout << "Label : " << label << std::endl; std::cout << "Measures : " << measure[0] << " " << measure[1] << std::endl; mCont->InsertElement(pointId, mP); mPSet->SetPointData(pointId, measure); lCont->InsertElement(pointId, lP); lPSet->SetPointData(pointId, label); } mPSet->SetPoints(mCont); lPSet->SetPoints(lCont); typedef otb::SVMPointSetModelEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); estimator->SetInputPointSet(mPSet); estimator->SetTrainingPointSet(lPSet); estimator->Update(); std::cout << "Saving model" << std::endl; estimator->SaveModel("model.svm"); // Build the test set MeasurePointSetType::Pointer tPSet = MeasurePointSetType::New(); MeasurePointsContainer::Pointer tCont = MeasurePointsContainer::New(); for (pointId = 0; pointId < 100; pointId++) { MeasurePointType tP; int x_coord = lowest + static_cast(range * (rand() / (RAND_MAX + 1.0))); int y_coord = lowest + static_cast(range * (rand() / (RAND_MAX + 1.0))); std::cout << "coords : " << x_coord << " " << y_coord << std::endl; tP[0] = x_coord; tP[1] = y_coord; InputVectorType measure; measure.push_back(static_cast((x_coord * 1.0 - lowest) / range)); measure.push_back(static_cast((y_coord * 1.0 - lowest) / range)); std::cout << "Measures : " << measure[0] << " " << measure[1] << std::endl; tCont->InsertElement(pointId, tP); tPSet->SetPointData(pointId, measure); } tPSet->SetPoints(tCont); // Classify typedef itk::Statistics::PointSetToListSampleAdaptor SampleType; SampleType::Pointer sample = SampleType::New(); sample->SetPointSet(tPSet); std::cout << "Sample set to Adaptor" << std::endl; /** preparing classifier and decision rule object */ typedef otb::SVMModel ModelType; ModelType::Pointer model = estimator->GetModel(); int numberOfClasses = model->GetNumberOfClasses(); std::cout << "Classification for " << numberOfClasses << " classes " << std::endl; typedef otb::SVMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); classifier->SetNumberOfClasses(numberOfClasses); classifier->SetModel(model); classifier->SetInput(sample.GetPointer()); classifier->Update(); /* Build the class map */ std::cout << "Output image creation" << std::endl; std::cout << "classifier get output" << std::endl; ClassifierType::OutputType* membershipSample = classifier->GetOutput(); std::cout << "Sample iterators" << std::endl; ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); double error = 0.0; pointId = 0; while (m_iter != m_last) { ClassifierType::ClassLabelType label = m_iter.GetClassLabel(); InputVectorType measure; tPSet->GetPointData(pointId, &measure); ClassifierType::ClassLabelType expectedLabel; if (measure[0] < measure[1]) expectedLabel = 0; else expectedLabel = 1; double dist = fabs(measure[0] - measure[1]); if (label != expectedLabel) error++; std::cout << int(label) << "/" << int(expectedLabel) << " --- " << dist << std::endl; ++pointId; ++m_iter; } std::cout << "Error = " << error / pointId << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/SVMPointSetModelEstimatorExample.cxx000066400000000000000000000175371301006202600260140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include #include // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{SVMPointSetModelEstimator} in order to perform the // SVM learning from an \doxygen{itk}{PointSet} data structure. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSVMPointSetModelEstimator.h" // Software Guide : EndCodeSnippet int main(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { // Software Guide : BeginLatex // // In the framework of supervised learning and classification, we will // always use feature vectors for the characterization of the // classes. On the other hand, the class labels are scalar // values. Here, we start by defining the type of the features as the // \code{PixelType}, which will be used to define the feature // \code{VectorType}. We also declare the type for the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float PixelType; typedef std::vector VectorType; typedef int LabelPixelType; // Software Guide : EndCodeSnippet const unsigned int Dimension = 2; // Software Guide : BeginLatex // // We can now proceed to define the point sets used for storing the // features and the labels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::PointSet FeaturePointSetType; typedef itk::PointSet LabelPointSetType; FeaturePointSetType::Pointer fPSet = FeaturePointSetType::New(); LabelPointSetType::Pointer lPSet = LabelPointSetType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will need to get access to the data stored in the point sets, so // we define the appropriate for the points and the points containers // used by the point sets (see the section \ref{sec:PointSetSection} // for more information oin haw to use point sets). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef FeaturePointSetType::PointType FeaturePointType; typedef LabelPointSetType::PointType LabelPointType; typedef FeaturePointSetType::PointsContainer FeaturePointsContainer; typedef LabelPointSetType::PointsContainer LabelPointsContainer; FeaturePointsContainer::Pointer fCont = FeaturePointsContainer::New(); LabelPointsContainer::Pointer lCont = LabelPointsContainer::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need now to build the training set for the SVM learning. In this // simple example, we will build a SVM who classes points depending on // which side of the line $x=y$ they are located. We start by // generating 500 random points. // // Software Guide : EndLatex /* We learn the y>x | y(range * (rand() / (RAND_MAX + 1.0))); int y_coord = lowest + static_cast(range * (rand() / (RAND_MAX + 1.0))); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the coordinates of the points. They are the same for the // feature vector and for the label. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fP[0] = x_coord; fP[1] = y_coord; lP[0] = x_coord; lP[1] = y_coord; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We push the features in the vector after a normalization which is // useful for SVM convergence. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorType feature; feature.push_back(static_cast((x_coord * 1.0 - lowest) / range)); feature.push_back(static_cast((y_coord * 1.0 - lowest) / range)); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We decide on the label for each point. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LabelPixelType label; if (x_coord < y_coord) label = -1; else label = 1; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we insert the points in the points containers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fCont->InsertElement(pointId, fP); fPSet->SetPointData(pointId, feature); lCont->InsertElement(pointId, lP); lPSet->SetPointData(pointId, label); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After the loop, we set the points containers to the point sets. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fPSet->SetPoints(fCont); lPSet->SetPoints(lCont); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Up to now, we have only prepared the data for the SVM learning. We // can now create the SVM model estimator. This class is templated // over the feature and the label point set types. // \index{otb::SVMPointSetModelEstimator} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMPointSetModelEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The next step consists in setting the point sets for the estimator // and the number of classes for the model. The feture point set is // set using the \code{SetInputPointSet} and the label point set is // set with the \code{SetTrainingPointSet} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet estimator->SetInputPointSet(fPSet); estimator->SetTrainingPointSet(lPSet); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The model estimation is triggered by calling the \code{Update} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet estimator->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we can save the result of the learning to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet estimator->SaveModel("svm_model.svm"); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{otbSVMModel} class provides several accessors in // order to get some information about the result of the learning // step. For instance, one can get the number of support vectors kept // to define the separation surface by using the // \code{GetNumberOfSupportVectors()}. This can be very useful to // detect some kind of overlearning (the number of support vectors is // close to the number of examples). One can also get the SVs // themselves by calling the \code {GetSupportVectors()}. The $\alpha$ // values for the support vectors can be accessed by using the // \code{GetAlpha()} method. Finally the \code{Evaluate()} method will // return the result of the classification of a sample and the // \code{EvaluateHyperplaneDistance()} will return the distance of // the sample to the separating surface (or surfaces in the case of // multi-class problems). // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Learning/TrainMachineLearningModelFromImagesExample.cxx000066400000000000000000000157051301006202600277600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_1_ortho.tif}, {VectorData_QB1.shp} // OUTPUTS: {clLIBSVMModelQB1.libsvm} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates the use of the // \doxygen{otb}{MachineLearningModel} class. This class allows the // estimation of a classification model (supervised learning) from images. In this example, we will train an SVM // with 4 classes. We start by including the appropriate header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // List sample generator #include "otbListSampleGenerator.h" // Extract a ROI of the vectordata #include "otbVectorDataIntoImageProjectionFilter.h" // SVM model Estimator #include "otbSVMMachineLearningModel.h" // Software Guide : EndCodeSnippet // Image #include "otbVectorImage.h" #include "otbVectorData.h" // Reader #include "otbImageFileReader.h" #include "otbVectorDataFileReader.h" // Normalize the samples //#include "otbShiftScaleSampleListFilter.h" int main(int itkNotUsed(argc), char* argv[]) { const char* inputImageFileName = argv[1]; const char* trainingShpFileName = argv[2]; const char* outputModelFileName = argv[3]; typedef unsigned int InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorData VectorDataType; typedef otb::ImageFileReader InputReaderType; typedef otb::VectorDataFileReader VectorDataReaderType; // Software Guide : BeginLatex // // In this framework, we must transform the input samples store in a vector // data into a \subdoxygen{itk}{Statistics}{ListSample} which is the structure // compatible with the machine learning classes. On the one hand, we are using feature vectors // for the characterization of the classes, and on the other hand, the class labels // are scalar values. We first re-project the input vector data over the input image, using the // \doxygen{otb}{VectorDataIntoImageProjectionFilter} class. To convert the // input samples store in a vector data into a // \subdoxygen{itk}{Statistics}{ListSample}, we use the // \doxygen{otb}{ListSampleGenerator} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // VectorData projection filter typedef otb::VectorDataIntoImageProjectionFilter VectorDataReprojectionType; InputReaderType::Pointer inputReader = InputReaderType::New(); inputReader->SetFileName(inputImageFileName); InputImageType::Pointer image = inputReader->GetOutput(); image->UpdateOutputInformation(); // Read the Vectordata VectorDataReaderType::Pointer vectorReader = VectorDataReaderType::New(); vectorReader->SetFileName(trainingShpFileName); vectorReader->Update(); VectorDataType::Pointer vectorData = vectorReader->GetOutput(); vectorData->Update(); VectorDataReprojectionType::Pointer vdreproj = VectorDataReprojectionType::New(); vdreproj->SetInputImage(image); vdreproj->SetInput(vectorData); vdreproj->SetUseOutputSpacingAndOriginFromImage(false); vdreproj->Update(); typedef otb::ListSampleGenerator ListSampleGeneratorType; ListSampleGeneratorType::Pointer sampleGenerator; sampleGenerator = ListSampleGeneratorType::New(); sampleGenerator->SetInput(image); sampleGenerator->SetInputVectorData(vdreproj->GetOutput()); sampleGenerator->SetClassKey("Class"); sampleGenerator->Update(); // Software Guide : EndCodeSnippet //std::cout << "Number of classes: " << sampleGenerator->GetNumberOfClasses() << std::endl; // typedef ListSampleGeneratorType::ListSampleType ListSampleType; // typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleFilterType; // // Shift scale the samples // ShiftScaleFilterType::Pointer trainingShiftScaleFilter = ShiftScaleFilterType::New(); // trainingShiftScaleFilter->SetInput(concatenateTrainingSamples->GetOutput()); // trainingShiftScaleFilter->SetShifts(meanMeasurementVector); // trainingShiftScaleFilter->SetScales(stddevMeasurementVector); // trainingShiftScaleFilter->Update(); // Software Guide : BeginLatex // // Now, we need to declare the machine learning model which will be used by the // classifier. In this example, we train an SVM model. The // \doxygen{otb}{SVMMachineLearningModel} class inherits from the pure virtual // class \doxygen{otb}{MachineLearningModel} which is templated over the type of // values used for the measures and the type of pixels used for the labels. Most // of the classification and regression algorithms available through this // interface in OTB is based on the OpenCV library \cite{opencv_library}. Specific methods // can be used to set classifier parameters. In the case of SVM, we set here the type // of the kernel. Other parameters are let with their default values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMMachineLearningModel SVMType; SVMType::Pointer SVMClassifier = SVMType::New(); SVMClassifier->SetInputListSample(sampleGenerator->GetTrainingListSample()); SVMClassifier->SetTargetListSample(sampleGenerator->GetTrainingListLabel()); SVMClassifier->SetKernelType(CvSVM::LINEAR); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The machine learning interface is generic and gives access to other classifiers. We now train the // SVM model using the \code{Train} and save the model to a text file using the // \code{Save} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SVMClassifier->Train(); SVMClassifier->Save(outputModelFileName); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // You can now use the \code{Predict} method which takes a // \subdoxygen{itk}{Statistics}{ListSample} as input and estimates the label of each // input sample using the model. Finally, the // \doxygen{otb}{ImageClassificationModel} inherits from the // \doxygen{itk}{ImageToImageFilter} and allows classifying pixels in the // input image by predicting their labels using a model. // // Software Guide : EndLatex } OTB-release-5.8/Examples/Learning/TrainMachineLearningModelFromSamplesExample.cxx000066400000000000000000000152141301006202600301520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {1000}, {4}, {5}, {121212} // OUTPUTS: {clSVMModelFromSamples.svm} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{SVMMachineLearningModel} class, which inherits from the // \doxygen{otb}{MachineLearningModel} class. This class allows the // estimation of a classification model (supervised learning) from samples. In this example, we will train an SVM model // with 4 output classes, from 1000 randomly generated training samples, each of them having 7 components. // We start by including the appropriate header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // List sample generator #include "otbListSampleGenerator.h" // Random number generator // SVM model Estimator #include "otbSVMMachineLearningModel.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { /* if (argc != 6) { std::cerr << "Usage: " << argv[0] << " nbSamples nbSampleComponents nbClasses inputSeed outputModelFileName" << std::endl; return EXIT_FAILURE; } */ if (argc != 2) { std::cerr << "Usage: " << argv[0] << " outputModelFileName" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // The input parameters of the sample generator and of the SVM classifier are initialized. // Software Guide : EndLatex /* int nbSamples = atoi(argv[1]); int nbSampleComponents = atoi(argv[2]); int nbClasses = atoi(argv[3]); unsigned int inputSeed = atoi(argv[4]); */ // Software Guide : BeginCodeSnippet int nbSamples = 1000; int nbSampleComponents = 7; int nbClasses = 4; // Software Guide : EndCodeSnippet // unsigned int inputSeed = 121212; const char* outputModelFileName = argv[1]; //argv[5]; // Software Guide : BeginLatex // Two lists are generated into a \subdoxygen{itk}{Statistics}{ListSample} which is the structure // used to handle both lists of samples and of labels for the machine learning classes derived from // \doxygen{otb}{MachineLearningModel}. The first list is composed of feature vectors representing // multi-component samples, and the second one is filled with their corresponding class labels. The // list of labels is composed of scalar values. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Input related typedefs typedef float InputValueType; typedef itk::VariableLengthVector InputSampleType; typedef itk::Statistics::ListSample InputListSampleType; // Target related typedefs typedef int TargetValueType; typedef itk::FixedArray TargetSampleType; typedef itk::Statistics::ListSample TargetListSampleType; InputListSampleType::Pointer InputListSample = InputListSampleType::New(); TargetListSampleType::Pointer TargetListSample = TargetListSampleType::New(); InputListSample->SetMeasurementVectorSize(nbSampleComponents); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // In this example, the list of multi-component training samples is randomly filled with a random number // generator based on the \subdoxygen{itk}{Statistics}{MersenneTwisterRandomVariateGenerator} class. // Each component's value is generated from a normal law centered around the corresponding class label of // each sample multiplied by 100, with a standard deviation of 10. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen; randGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance(); // Filling the two input training lists for (int i = 0; i < nbSamples; ++i) { InputSampleType sample; TargetValueType label = (i % nbClasses) + 1; // Multi-component sample randomly filled from a normal law for each component sample.SetSize(nbSampleComponents); for (int itComp = 0; itComp < nbSampleComponents; ++itComp) { sample[itComp] = randGen->GetNormalVariate(100 * label, 10); } InputListSample->PushBack(sample); TargetListSample->PushBack(label); } // Software Guide : EndCodeSnippet // Displays the corresponding values (not into the Software Guide) for (int i = 0; i < nbSamples; ++i) { std::cout << i + 1 << "-label = " << TargetListSample->GetMeasurementVector(i) << std::endl; std::cout << "sample = " << InputListSample->GetMeasurementVector(i) << std::endl << std::endl; } // Software Guide : BeginLatex //Once both sample and label lists are generated, the second step consists in //declaring the machine learning classifier. In our case we use an SVM model //with the help of the \doxygen{otb}{SVMMachineLearningModel} class which is //derived from the \doxygen{otb}{MachineLearningModel} class. //This pure virtual class is based on the machine learning framework of the //OpenCV library (\cite{opencv_library}) which handles other classifiers than //the SVM. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SVMMachineLearningModel SVMType; SVMType::Pointer SVMClassifier = SVMType::New(); SVMClassifier->SetInputListSample(InputListSample); SVMClassifier->SetTargetListSample(TargetListSample); SVMClassifier->SetKernelType(CvSVM::LINEAR); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the classifier is parametrized with both input lists and default parameters, except // for the kernel type in our example of SVM model estimation, the model // training is computed with the \code{Train} method. Finally, the \code{Save} method // exports the model to a text file. All the available classifiers based on OpenCV are // implemented with these interfaces. Like for the SVM model training, the other classifiers // can be parametrized with specific settings. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SVMClassifier->Train(); SVMClassifier->Save(outputModelFileName); // Software Guide : EndCodeSnippet } OTB-release-5.8/Examples/Learning/test/000077500000000000000000000000001301006202600177125ustar00rootroot00000000000000OTB-release-5.8/Examples/Learning/test/CMakeLists.txt000066400000000000000000000061711301006202600224570ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Learning) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- SVMImageClassificationExampleTest---------- if(OTBLibSVM_LOADED) otb_add_test(NAME leTeSVMImageClassificationExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ROI_QB_MUL_1_SVN_CLASS.png ${TEMP}/ROI_QB_MUL_1_SVN_CLASS.png Execute $ ${INPUTDATA}/ROI_QB_MUL_1.png ${TEMP}/ROI_QB_MUL_1_SVN_CLASS.png ${OTB_DATA_ROOT}/Examples/svm_image_model.svm ) # ------- SVMImageEstimatorClassificationMultiExampleTest---------- otb_add_test(NAME leTeSVMImageEstimatorClassificationMultiExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png ${TEMP}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png Execute $ ${INPUTDATA}/ROI_QB_MUL_1.png ${INPUTDATA}/ROI_mask_multi.png ${TEMP}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png ${TEMP}/ROI_QB_MUL_1_SVN_CLASS_MULTI_Rescaled.png ) # ------- SVMImageModelEstimatorExampleTest---------- otb_add_test(NAME leTeSVMImageModelEstimatorExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-ascii ${EPSILON_3} ${BASELINE}/svm_image_model.svn ${TEMP}/svm_image_model.svn --ignore-lines-with 2 probA probB Execute $ ${INPUTDATA}/ROI_QB_MUL_1.png ${INPUTDATA}/ROI_mask.png ${TEMP}/svm_image_model.svn ) endif() # ------- GenerateTrainingImageExampleTest---------- otb_add_test(NAME leTeGenerateTrainingImageExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ROI_QB_MUL_4_training.png ${TEMP}/ROI_QB_MUL_4_training.png Execute $ ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/LearningROIs.txt ${TEMP}/ROI_QB_MUL_4_training.png ) # ------- SOMExampleTest---------- otb_add_test(NAME leTeSOMExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/ROI_QB_MUL_SOM.png ${TEMP}/ROI_QB_MUL_SOM.png ${BASELINE}/ROI_QB_MUL_SOMACT.png ${TEMP}/ROI_QB_MUL_SOMACT.png Execute $ ${INPUTDATA}/ROI_QB_MUL_1.png ${TEMP}/ROI_QB_MUL_SOM.png ${TEMP}/ROI_QB_MUL_SOMACT.png 4 4 4 4 15 1.0 0.1 128 ) # ------- SOMClassifierExampleTest---------- otb_add_test(NAME leTeSOMClassifierExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/ROI_QB_MUL_extractSOMCLASS.tif ${TEMP}/ROI_QB_MUL_extractSOMCLASS.tif Execute $ ${INPUTDATA}/ROI_QB_MUL_1_extract.tif ${INPUTDATA}/ROI_QB_MUL_extractSOM.tif ${TEMP}/ROI_QB_MUL_extractSOMCLASS.tif ) # ------- SEMModelEstimatorExampleTest---------- otb_add_test(NAME leTeSEMModelEstimatorExampleTest COMMAND ${OTB_TEST_DRIVER} # --compare-image ${NOTOL} # ${BASELINE}/ROI_QB_MUL_SEMMODEL_ESTIMATOR.png # ${TEMP}/ROI_QB_MUL_SEMMODEL_ESTIMATOR.png Execute $ ${INPUTDATA}/ROI_QB_MUL_1.tif ${TEMP}/ROI_QB_MUL_SEMMODEL_ESTIMATOR.png 4 40 5 ) OTB-release-5.8/Examples/Markov/000077500000000000000000000000001301006202600164335ustar00rootroot00000000000000OTB-release-5.8/Examples/Markov/CMakeLists.txt000066400000000000000000000014421301006202600211740ustar00rootroot00000000000000project(MarkovExamples) add_executable(MarkovClassification1Example MarkovClassification1Example.cxx) target_link_libraries(MarkovClassification1Example ${OTB_LIBRARIES}) add_executable(MarkovClassification2Example MarkovClassification2Example.cxx) target_link_libraries(MarkovClassification2Example ${OTB_LIBRARIES}) add_executable(MarkovClassification3Example MarkovClassification3Example.cxx) target_link_libraries(MarkovClassification3Example ${OTB_LIBRARIES}) add_executable(MarkovRegularizationExample MarkovRegularizationExample.cxx) target_link_libraries(MarkovRegularizationExample ${OTB_LIBRARIES}) add_executable(MarkovRestorationExample MarkovRestorationExample.cxx) target_link_libraries(MarkovRestorationExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Markov/MarkovClassification1Example.cxx000066400000000000000000000242571301006202600247010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {MarkovRandomField1.png} // 1.0 20 1.0 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the details of the \doxygen{otb}{MarkovRandomFieldFilter}. // This filter is an application of the Markov Random Fields for classification, // segmentation or restoration. // // This example applies the \doxygen{otb}{MarkovRandomFieldFilter} to // classify an image into four classes defined by their mean and variance. The // optimization is done using an Metropolis algorithm with a random sampler. The // regularization energy is defined by a Potts model and the fidelity by a // Gaussian model. // // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbMarkovRandomFieldFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step toward the use of this filter is the inclusion of the proper // header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMRFEnergyPotts.h" #include "otbMRFEnergyGaussianClassification.h" #include "otbMRFOptimizerMetropolis.h" #include "otbMRFSamplerRandom.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 7) { std::cerr << "Missing Parameters " << argc << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage output lambda iterations optimizerTemperature" << std::endl; std::cerr << " useRandomValue" << std::endl; return 1; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with double precision. // The labelled image is of type unsigned char which allows up to 256 different // classes. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double InternalPixelType; typedef unsigned char LabelledPixelType; typedef otb::Image InputImageType; typedef otb::Image LabelledImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define a reader for the image to be classified, an initialization for the // classification (which could be random) and a writer for the final // classification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we define the different classes necessary for the Markov classification. // A \doxygen{otb}{MarkovRandomFieldFilter} is instantiated, this is the // main class which connect the other to do the Markov classification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MarkovRandomFieldFilter MarkovRandomFieldFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{MRFSamplerRandomMAP}, which derives from the // \doxygen{otb}{MRFSampler}, is instantiated. The sampler is in charge of // proposing a modification for a given site. The // \doxygen{otb}{MRFSamplerRandomMAP}, randomly pick one possible value // according to the MAP probability. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFSamplerRandom SamplerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{MRFOptimizerMetropoli}, which derives from the // \doxygen{otb}{MRFOptimizer}, is instantiated. The optimizer is in charge // of accepting or rejecting the value proposed by the sampler. The // \doxygen{otb}{MRFSamplerRandomMAP}, accept the proposal according to the // variation of energy it causes and a temperature parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFOptimizerMetropolis OptimizerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Two energy, deriving from the \doxygen{otb}{MRFEnergy} class need to be instantiated. One energy // is required for the regularization, taking into account the relashionship between neighborhing pixels // in the classified image. Here it is done with the \doxygen{otb}{MRFEnergyPotts} which implement // a Potts model. // // The second energy is for the fidelity to the original data. Here it is done with an // \doxygen{otb}{MRFEnergyGaussianClassification} class, which defines a gaussian model for the data. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFEnergyPotts EnergyRegularizationType; typedef otb::MRFEnergyGaussianClassification EnergyFidelityType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different filters composing our pipeline are created by invoking their // \code{New()} methods, assigning the results to smart pointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); SamplerType::Pointer sampler = SamplerType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Parameter for the \doxygen{otb}{MRFEnergyGaussianClassification} class, meand // and standard deviation are created. // // Software Guide : EndLatex if ((bool) (atoi(argv[6])) == true) { // Overpass random calculation(for test only): sampler->InitializeSeed(0); optimizer->InitializeSeed(1); markovFilter->InitializeSeed(2); } // Software Guide : BeginCodeSnippet unsigned int nClass = 4; energyFidelity->SetNumberOfParameters(2 * nClass); EnergyFidelityType::ParametersType parameters; parameters.SetSize(energyFidelity->GetNumberOfParameters()); parameters[0] = 10.0; //Class 0 mean parameters[1] = 10.0; //Class 0 stdev parameters[2] = 80.0; //Class 1 mean parameters[3] = 10.0; //Class 1 stdev parameters[4] = 150.0; //Class 2 mean parameters[5] = 10.0; //Class 2 stdev parameters[6] = 220.0; //Class 3 mean parameters[7] = 10.0; //Class 3 stde energyFidelity->SetParameters(parameters); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Parameters are given to the different class an the sampler, optimizer and // energies are connected with the Markov filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OptimizerType::ParametersType param(1); param.Fill(atof(argv[5])); optimizer->SetParameters(param); markovFilter->SetNumberOfClasses(nClass); markovFilter->SetMaximumNumberOfIterations(atoi(argv[4])); markovFilter->SetErrorTolerance(0.0); markovFilter->SetLambda(atof(argv[3])); markovFilter->SetNeighborhoodRadius(1); markovFilter->SetEnergyRegularization(energyRegularization); markovFilter->SetEnergyFidelity(energyFidelity); markovFilter->SetOptimizer(optimizer); markovFilter->SetSampler(sampler); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The pipeline is connected. An \doxygen{itk}{RescaleIntensityImageFilter} // rescale the classified image before saving it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet markovFilter->SetInput(reader->GetOutput()); typedef itk::RescaleIntensityImageFilter RescaleType; RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); rescaleFilter->SetInput(markovFilter->GetOutput()); writer->SetInput(rescaleFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the pipeline execution is trigerred. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:MRF_CLASSIFICATION1} shows the output of the Markov Random // Field classification after 20 iterations with a // random sampler and a Metropolis optimizer. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{MarkovRandomField1.eps} // \itkcaption[MRF restoration]{Result of applying // the \doxygen{otb}{MarkovRandomFieldFilter} to an extract from a PAN Quickbird // image for classification. The result is obtained after 20 iterations with a // random sampler and a Metropolis optimizer. From left to right : original image, // classification.} // \label{fig:MRF_CLASSIFICATION1} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Markov/MarkovClassification2Example.cxx000066400000000000000000000147471301006202600247050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {MarkovRandomField2.png} // 1.0 5 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Using a similar structure as the previous program and the same energy // function, we are now going to slightly alter the program to use a // different sampler and optimizer. The proposed sample is proposed // randomly according to the MAP probability and the optimizer is the // ICM which accept the proposed sample if it enable a reduction of // the energy. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbMarkovRandomFieldFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // First, we need to include header specific to these class: // // Software Guide : EndLatex #include "otbMRFEnergyPotts.h" #include "otbMRFEnergyGaussianClassification.h" // Software Guide : BeginCodeSnippet #include "otbMRFSamplerRandomMAP.h" #include "otbMRFOptimizerICM.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 6) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage output lambda iterations" << std::endl; std::cerr << " useRandomValue" << std::endl; return 1; } const unsigned int Dimension = 2; typedef double InternalPixelType; typedef unsigned char LabelledPixelType; typedef otb::Image InputImageType; typedef otb::Image LabelledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); typedef otb::MarkovRandomFieldFilter MarkovRandomFieldFilterType; // Software Guide : BeginLatex // // And to declare these new type: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFSamplerRandomMAP SamplerType; // typedef otb::MRFSamplerRandom< InputImageType, LabelledImageType> SamplerType; // Software Guide : EndCodeSnippet // Software Guide : BeginCodeSnippet typedef otb::MRFOptimizerICM OptimizerType; // Software Guide : EndCodeSnippet typedef otb::MRFEnergyPotts EnergyRegularizationType; typedef otb::MRFEnergyGaussianClassification EnergyFidelityType; MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); SamplerType::Pointer sampler = SamplerType::New(); if ((bool) (atoi(argv[5])) == true) { // Overpass random calculation(for test only): sampler->InitializeSeed(0); markovFilter->InitializeSeed(1); } unsigned int nClass = 4; energyFidelity->SetNumberOfParameters(2 * nClass); EnergyFidelityType::ParametersType parameters; parameters.SetSize(energyFidelity->GetNumberOfParameters()); parameters[0] = 10.0; //Class 0 mean parameters[1] = 10.0; //Class 0 stdev parameters[2] = 80.0; //Class 1 mean parameters[3] = 10.0; //Class 1 stdev parameters[4] = 150.0; //Class 2 mean parameters[5] = 10.0; //Class 2 stdev parameters[6] = 220.0; //Class 3 mean parameters[7] = 10.0; //Class 3 stde energyFidelity->SetParameters(parameters); // Software Guide : BeginLatex // // As the \doxygen{otb}{MRFOptimizerICM} does not have any parameters, // the call to \code{optimizer->SetParameters()} must be removed // // Software Guide : EndLatex markovFilter->SetNumberOfClasses(nClass); markovFilter->SetMaximumNumberOfIterations(atoi(argv[4])); markovFilter->SetErrorTolerance(0.0); markovFilter->SetLambda(atof(argv[3])); markovFilter->SetNeighborhoodRadius(1); markovFilter->SetEnergyRegularization(energyRegularization); markovFilter->SetEnergyFidelity(energyFidelity); markovFilter->SetOptimizer(optimizer); markovFilter->SetSampler(sampler); markovFilter->SetInput(reader->GetOutput()); typedef itk::RescaleIntensityImageFilter RescaleType; RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); rescaleFilter->SetInput(markovFilter->GetOutput()); writer->SetInput(rescaleFilter->GetOutput()); writer->Update(); // Software Guide : BeginLatex // // Apart from these, no further modification is required. // // Software Guide : EndLatex // Software Guide : BeginLatex // // Figure~\ref{fig:MRF_CLASSIFICATION2} shows the output of the Markov Random // Field classification after 5 iterations with a // MAP random sampler and an ICM optimizer. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{MarkovRandomField2.eps} // \itkcaption[MRF restoration]{Result of applying // the \doxygen{otb}{MarkovRandomFieldFilter} to an extract from a PAN Quickbird // image for classification. The result is obtained after 5 iterations with a // MAP random sampler and an ICM optimizer. From left to right : original image, // classification.} // \label{fig:MRF_CLASSIFICATION2} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Markov/MarkovClassification3Example.cxx000066400000000000000000000265531301006202600247040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {MarkovRandomField3_gray_value.png}, {MarkovRandomField3_color_value.png} // 1.0 20 1.0 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the details of the MarkovRandomFieldFilter by using the Fisher distribution // to model the likelihood energy. // This filter is an application of the Markov Random Fields for classification. // // This example applies the MarkovRandomFieldFilter to // classify an image into four classes defined by their Fisher distribution parameters L, M and mu. // The optimization is done using a Metropolis algorithm with a random sampler. The // regularization energy is defined by a Potts model and the fidelity or likelihood energy is modelled by a // Fisher distribution. // The parameter of the Fisher distribution was determined for each class in a supervised step. // ( See the File OtbParameterEstimatioOfFisherDistribution ) // This example is a contribution from Jan Wegner. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbMarkovRandomFieldFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkScalarToRGBPixelFunctor.h" #include "otbMRFEnergyPotts.h" #include "otbMRFEnergyFisherClassification.h" #include "otbMRFOptimizerMetropolis.h" #include "otbMRFSamplerRandom.h" int main(int argc, char* argv[] ) { if( argc != 8 ) { std::cerr << "Missing Parameters "<< argc << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage output_gray_label output_color_label lambda iterations " "optimizerTemperature useRandomValue " << std::endl; return 1; } // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We // choose to make all computations with double precision. // The labeled image is of type unsigned char which allows up to 256 different // classes. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double InternalPixelType; typedef unsigned char LabelledPixelType; typedef otb::Image InputImageType; typedef otb::Image LabelledImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define a reader for the image to be classified, an initialization for the // classification (which could be random) and a writer for the final // classification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader< InputImageType > ReaderType; typedef otb::ImageFileWriter< LabelledImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const char * outputRescaledImageFileName = argv[3]; reader->SetFileName( inputFilename ); writer->SetFileName( outputFilename ); // Software Guide : BeginLatex // // Finally, we define the different classes necessary for the Markov classification. // A MarkovRandomFieldFilter is instantiated, this is the // main class which connect the other to do the Markov classification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MarkovRandomFieldFilter MarkovRandomFieldFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An MRFSamplerRandomMAP, which derives from the // MRFSampler, is instantiated. The sampler is in charge of // proposing a modification for a given site. The // MRFSamplerRandomMAP, randomly pick one possible value // according to the MAP probability. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFSamplerRandom< InputImageType, LabelledImageType> SamplerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An MRFOptimizerMetropolis, which derives from the // MRFOptimizer, is instantiated. The optimizer is in charge // of accepting or rejecting the value proposed by the sampler. The // MRFSamplerRandomMAP, accept the proposal according to the // variation of energy it causes and a temperature parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFOptimizerMetropolis OptimizerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Two energy, deriving from the MRFEnergy class need to be instantiated. One energy // is required for the regularization, taking into account the relationship between neighboring pixels // in the classified image. Here it is done with the MRFEnergyPotts, which implements // a Potts model. // // The second energy is used for the fidelity to the original data. Here it is done with a // MRFEnergyFisherClassification class, which defines a Fisher distribution to model the data. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFEnergyPotts EnergyRegularizationType; typedef otb::MRFEnergyFisherClassification EnergyFidelityType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The different filters composing our pipeline are created by invoking their // New() methods, assigning the results to smart pointers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); SamplerType::Pointer sampler = SamplerType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Parameter for the MRFEnergyFisherClassification class are created. The shape parameters M, L // and the weighting parameter mu are computed in a supervised step // // Software Guide : EndLatex if ((bool)(atoi(argv[6])) == true) { // Overpass random calculation(for test only): sampler->InitializeSeed(0); optimizer->InitializeSeed(1); markovFilter->InitializeSeed(1); } // Software Guide : BeginCodeSnippet unsigned int nClass =4; energyFidelity->SetNumberOfParameters(3*nClass); EnergyFidelityType::ParametersType parameters; parameters.SetSize(energyFidelity->GetNumberOfParameters()); //Class 0 parameters[0] = 12.353042; //Class 0 mu parameters[1] = 2.156422; //Class 0 L parameters[2] = 4.920403; //Class 0 M //Class 1 parameters[3] = 72.068291; //Class 1 mu parameters[4] = 11.000000; //Class 1 L parameters[5] = 50.950001; //Class 1 M //Class 2 parameters[6] = 146.665985; //Class 2 mu parameters[7] = 11.000000; //Class 2 L parameters[8] = 50.900002; //Class 2 M //Class 3 parameters[9] = 200.010132; //Class 3 mu parameters[10] = 11.000000; //Class 3 L parameters[11] = 50.950001; //Class 3 M energyFidelity->SetParameters(parameters); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Parameters are given to the different classes and the sampler, optimizer and // energies are connected with the Markov filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OptimizerType::ParametersType param(1); param.Fill(atof(argv[6])); optimizer->SetParameters(param); markovFilter->SetNumberOfClasses(nClass); markovFilter->SetMaximumNumberOfIterations(atoi(argv[5])); markovFilter->SetErrorTolerance(0.0); markovFilter->SetLambda(atof(argv[4])); markovFilter->SetNeighborhoodRadius(1); markovFilter->SetEnergyRegularization(energyRegularization); markovFilter->SetEnergyFidelity(energyFidelity); markovFilter->SetOptimizer(optimizer); markovFilter->SetSampler(sampler); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The pipeline is connected. An itkRescaleIntensityImageFilter // rescales the classified image before saving it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet markovFilter->SetInput(reader->GetOutput()); typedef itk::RescaleIntensityImageFilter < LabelledImageType, LabelledImageType > RescaleType; RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); rescaleFilter->SetInput( markovFilter->GetOutput() ); writer->SetInput( rescaleFilter->GetOutput() ); writer->Update(); // Software Guide : EndCodeSnippet //convert output image to color typedef itk::RGBPixel RGBPixelType; typedef otb::Image RGBImageType; typedef itk::Functor::ScalarToRGBPixelFunctor ColorMapFunctorType; typedef itk::UnaryFunctorImageFilter< LabelledImageType, RGBImageType, ColorMapFunctorType> ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->SetInput( rescaleFilter->GetOutput() ); // Software Guide : BeginLatex // // We can now create an image file writer and save the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterRescaledType; WriterRescaledType::Pointer writerRescaled = WriterRescaledType::New(); writerRescaled->SetFileName( outputRescaledImageFileName ); writerRescaled->SetInput( colormapper->GetOutput() ); writerRescaled->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:MRF_CLASSIFICATION3} shows the output of the Markov Random // Field classification into four classes using the // Fisher-distribution as likelihood term. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{MarkovRandomField3_color_value.eps} // \itkcaption[MRF restoration]{Result of applying // the \doxygen{otb}{MarkovRandomFieldFilter} to an extract from a PAN Quickbird // image for classification into four classes using the Fisher-distribution as // likehood term. From left to right : original image, // classification.} // \label{fig:MRF_CLASSIFICATION3} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Markov/MarkovRegularizationExample.cxx000066400000000000000000000145771301006202600246700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_1_SVN_CLASS_MULTI.png} // OUTPUTS: {MarkovRegularization.png}, {MarkovRegularization-scaled.png} // 0.2 20 0.0 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{MarkovRandomFieldFilter}. // to regularize a classification obtained previously by another classifier. Here // we will apply the regularization to the output of an SVM classifier presented // in \ref{ssec:LearningFromImages}. // // The reference image and the starting image are both going to be the original // classification. Both regularization and fidelity energy are defined by Potts model. // // The convergence of the Markov Random Field is done with a random sampler // and a Metropolis model as in example 1. As you should get use to the general // program structure to use the MRF framework, we are not going to repeat the entire // example. However, remember you can find the full source code for this example // in your OTB source directory. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbMarkovRandomFieldFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkLabelStatisticsImageFilter.h" #include "otbMRFEnergyPotts.h" #include "otbMRFOptimizerMetropolis.h" #include "otbMRFSamplerRandom.h" int main(int argc, char* argv[]) { if (argc != 8) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputClassificationImage outputClassification outputClassificationScaled lambda iterations temperature " << std::endl; std::cerr << " useRandomValue" << std::endl; return 1; } const unsigned int Dimension = 2; typedef unsigned char LabelledPixelType; typedef otb::Image LabelledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const char * outputScaledFilename = argv[3]; reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); typedef otb::MarkovRandomFieldFilter MarkovRandomFieldFilterType; typedef otb::MRFSamplerRandom SamplerType; typedef otb::MRFOptimizerMetropolis OptimizerType; typedef otb::MRFEnergyPotts EnergyRegularizationType; typedef otb::MRFEnergyPotts EnergyFidelityType; MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); SamplerType::Pointer sampler = SamplerType::New(); if ((bool) (atoi(argv[7])) == true) { // Overpass random calculation(for test only): sampler->InitializeSeed(0); optimizer->InitializeSeed(1); markovFilter->InitializeSeed(2); } // Software Guide : BeginLatex // // To find the number of classes available in the original image we use the // \doxygen{itk}{LabelStatisticsImageFilter} and more particularly the method // \code{GetNumberOfLabels()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::LabelStatisticsImageFilter LabelledStatType; LabelledStatType::Pointer labelledStat = LabelledStatType::New(); labelledStat->SetInput(reader->GetOutput()); labelledStat->SetLabelInput(reader->GetOutput()); labelledStat->Update(); unsigned int nClass = labelledStat->GetNumberOfLabels(); // Software Guide : EndCodeSnippet optimizer->SetSingleParameter(0.0); markovFilter->SetNumberOfClasses(nClass); markovFilter->SetMaximumNumberOfIterations(atoi(argv[5])); markovFilter->SetErrorTolerance(0.0); markovFilter->SetLambda(atof(argv[4])); markovFilter->SetNeighborhoodRadius(1); markovFilter->SetEnergyRegularization(energyRegularization); markovFilter->SetEnergyFidelity(energyFidelity); markovFilter->SetOptimizer(optimizer); markovFilter->SetSampler(sampler); markovFilter->SetTrainingInput(reader->GetOutput()); markovFilter->SetInput(reader->GetOutput()); writer->SetInput(markovFilter->GetOutput()); writer->Update(); typedef itk::RescaleIntensityImageFilter RescaleType; RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); rescaleFilter->SetInput(markovFilter->GetOutput()); writer->SetFileName(outputScaledFilename); writer->SetInput(rescaleFilter->GetOutput()); writer->Update(); // Software Guide : BeginLatex // // Figure~\ref{fig:MRF_REGULARIZATION} shows the output of the Markov Random // Field regularization on the classification output of another method. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{MarkovRegularization.eps} // \includegraphics[width=0.44\textwidth]{MarkovRegularization-scaled.eps} // \itkcaption[MRF restoration]{Result of applying // the \doxygen{otb}{MarkovRandomFieldFilter} to regularized the result of another // classification. From left to right : original classification, regularized // classification} // \label{fig:MRF_REGULARIZATION} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Markov/MarkovRestorationExample.cxx000066400000000000000000000174251301006202600241750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png}, {QB_Suburb.png} // OUTPUTS: {MarkovRestoration.png} // 10.0 30 1.0 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The Markov Random Field framework can be used to apply an edge preserving // filtering, thus playing a role of restoration. // // This example applies the \doxygen{otb}{MarkovRandomFieldFilter} for // image restoration. The structure of the example is similar to the other MRF example. // The original image is assumed to be coded in one byte, thus 256 states // are possible for each pixel. The only other modifications reside in the energy // function chosen for the fidelity and for the regularization. // // For the regularization energy function, we choose an edge preserving function: // // \begin{equation} // \Phi(u) = \frac{u^2}{1+u^2} // \end{equation} // // and for the fidelity function, we choose a gaussian model. // // The starting state of the Markov Random Field is given by the image itself // as the final state should not be too far from it. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbMarkovRandomFieldFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginLatex // // The first step toward the use of this filter is the inclusion of the proper // header files: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMRFEnergyEdgeFidelity.h" #include "otbMRFEnergyGaussian.h" #include "otbMRFOptimizerMetropolis.h" #include "otbMRFSamplerRandom.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 8) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage inputInitialization output lambda iterations optimizerTemperature" << std::endl; std::cerr << " useRandomValue" << std::endl; return 1; } // Software Guide : BeginLatex // // We declare the usual types: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double InternalPixelType; typedef unsigned char LabelledPixelType; typedef otb::Image InputImageType; typedef otb::Image LabelledImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need to declare an additional reader for the initial state of the // MRF. This reader has to be instantiated on the LabelledImageType. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderLabelledType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); ReaderLabelledType::Pointer reader2 = ReaderLabelledType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * labelledFilename = argv[2]; const char * outputFilename = argv[3]; reader->SetFileName(inputFilename); reader2->SetFileName(labelledFilename); writer->SetFileName(outputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare all the necessary types for the MRF: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MarkovRandomFieldFilter MarkovRandomFieldFilterType; typedef otb::MRFSamplerRandom SamplerType; typedef otb::MRFOptimizerMetropolis OptimizerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The regularization and the fidelity energy are declared and instantiated: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MRFEnergyEdgeFidelity EnergyRegularizationType; typedef otb::MRFEnergyGaussian EnergyFidelityType; // Software Guide : EndCodeSnippet // Software Guide : BeginCodeSnippet MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); SamplerType::Pointer sampler = SamplerType::New(); // Software Guide : EndCodeSnippet if ((bool) (atoi(argv[7])) == true) { // Overpass random calculation(for test only): sampler->InitializeSeed(0); optimizer->InitializeSeed(1); markovFilter->InitializeSeed(2); } // Software Guide : BeginLatex // // The number of possible states for each pixel is 256 as the image is assumed // to be coded on one byte and we pass the parameters to the markovFilter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int nClass = 256; optimizer->SetSingleParameter(atof(argv[6])); markovFilter->SetNumberOfClasses(nClass); markovFilter->SetMaximumNumberOfIterations(atoi(argv[5])); markovFilter->SetErrorTolerance(0.0); markovFilter->SetLambda(atof(argv[4])); markovFilter->SetNeighborhoodRadius(1); markovFilter->SetEnergyRegularization(energyRegularization); markovFilter->SetEnergyFidelity(energyFidelity); markovFilter->SetOptimizer(optimizer); markovFilter->SetSampler(sampler); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The original state of the MRF filter is passed through the // \code{SetTrainingInput()} method: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet markovFilter->SetTrainingInput(reader2->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we plug the pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet markovFilter->SetInput(reader->GetOutput()); typedef itk::RescaleIntensityImageFilter RescaleType; RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); rescaleFilter->SetInput(markovFilter->GetOutput()); writer->SetInput(rescaleFilter->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:MRF_RESTORATION} shows the output of the Markov Random // Field restoration. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{MarkovRestoration.eps} // \itkcaption[MRF restoration]{Result of applying // the \doxygen{otb}{MarkovRandomFieldFilter} to an extract from a PAN Quickbird // image for restoration. From left to right : original image, restaured image // with edge preservation.} // \label{fig:MRF_RESTORATION} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Markov/test/000077500000000000000000000000001301006202600174125ustar00rootroot00000000000000OTB-release-5.8/Examples/Markov/test/CMakeLists.txt000066400000000000000000000042101301006202600221470ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Markov) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME maTeMarkovClassification1ExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/MarkovClassification1.png ${TEMP}/MarkovClassification1.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/MarkovClassification1.png 1.0 20 1.0 1 #true to use always the same rand() sample, false otherwise ) otb_add_test(NAME maTeMarkovClassification2ExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/MarkovClassification2.png ${TEMP}/MarkovClassification2.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/MarkovClassification2.png 1.0 5 1 # true to use always the same rand() sample, false otherwise ) otb_add_test(NAME maTeMarkovClassification3ExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/MarkovClassification3.png ${TEMP}/MarkovClassification3.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/MarkovClassification3.png ${TEMP}/MarkovClassification3_1.png 1.0 20 1.0 1 ) otb_add_test(NAME maTeMarkovRestorationExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/MarkovRestoration.png ${TEMP}/MarkovRestoration.png Execute $ ${INPUTDATA}/QB_Suburb.png ${INPUTDATA}/QB_Suburb.png ${TEMP}/MarkovRestoration.png 10.0 30.0 1. 1 # true to use always the same rand() sample, false otherwise ) otb_add_test(NAME maTeMarkovRegularizationExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/MarkovRegularization-scaled.png ${TEMP}/MarkovRegularization-scaled.png Execute $ ${INPUTDATA}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png ${TEMP}/MarkovRegularization.png ${TEMP}/MarkovRegularization-scaled.png 0.2 20 0.0 1 # true to use always the same rand() sample, false otherwis ) OTB-release-5.8/Examples/MultiScale/000077500000000000000000000000001301006202600172365ustar00rootroot00000000000000OTB-release-5.8/Examples/MultiScale/CMakeLists.txt000066400000000000000000000014531301006202600220010ustar00rootroot00000000000000project(MultiScaleExamples) add_executable(MorphologicalPyramidAnalysisFilterExample MorphologicalPyramidAnalysisFilterExample.cxx) target_link_libraries(MorphologicalPyramidAnalysisFilterExample ${OTB_LIBRARIES}) add_executable(MorphologicalPyramidSegmentationExample MorphologicalPyramidSegmentationExample.cxx) target_link_libraries(MorphologicalPyramidSegmentationExample ${OTB_LIBRARIES}) add_executable(MorphologicalPyramidSegmenterExample MorphologicalPyramidSegmenterExample.cxx) target_link_libraries(MorphologicalPyramidSegmenterExample ${OTB_LIBRARIES}) add_executable(MorphologicalPyramidSynthesisFilterExample MorphologicalPyramidSynthesisFilterExample.cxx) target_link_libraries(MorphologicalPyramidSynthesisFilterExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/MultiScale/MorphologicalPyramidAnalysisFilterExample.cxx000066400000000000000000000261201301006202600302760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {suburb2.jpeg} // OUTPUTS: {suburb2_an_1.jpeg}, {suburb2_an_2.jpeg}, {suburb2_an_3.jpeg}, {suburb2_an_4.jpeg} // OUTPUTS: {suburb2_sf_1.jpeg}, {suburb2_sf_2.jpeg}, {suburb2_sf_3.jpeg}, {suburb2_sf_4.jpeg} // OUTPUTS: {suburb2_if_1.jpeg}, {suburb2_if_2.jpeg}, {suburb2_if_3.jpeg}, {suburb2_if_4.jpeg} // OUTPUTS: {suburb2_id_1.jpeg}, {suburb2_id_2.jpeg}, {suburb2_id_3.jpeg}, {suburb2_id_4.jpeg} // OUTPUTS: {suburb2_sd_1.jpeg}, {suburb2_sd_2.jpeg}, {suburb2_sd_3.jpeg}, {suburb2_sd_4.jpeg} // 4 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{MorphologicalPyramidAnalyseFilter}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMorphologicalPyramidAnalysisFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The mathematical morphology filters to be used have also to be // included here. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkMacro.h" int main(int argc, char * argv[]) { if (argc != 24) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImagePrefix iterations decimationRatio" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const unsigned int numberOfLevels = atoi(argv[22]); const float decimationRatio = atof(argv[23]); // Software Guide : BeginLatex // // As usual, we start by defining the types needed for the pixels, the // images, the image reader and the image writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we define the types needed for the morphological filters which // will be used to build the morphological pyramid. The first thing to // do is define the structuring element, which in our case, will be a // \doxygen{itk}{BinaryBallStructuringElement} which is templated over // the pixel type and the dimension of the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryBallStructuringElement StructuringElementType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type of the filter to be used by the // morphological pyramid. In this case, we choose to use an // \doxygen{otb}{OpeningClosingMorphologicalFilter} which is just the // concatenation of an opening and a closing. This filter is templated // over the input and output image types and the structuring element // type that we just define above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can finally define the type of the morpholoical pyramid // filter. The filter is templated over the input and output image // types and the {\em lowpas} morphological filter to be used. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MorphologicalPyramidAnalysisFilter PyramidFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the \doxygen{otb}{MorphologicalPyramidAnalyseFilter} // generates a list of images as output, it is useful to have an // iterator to access the images. This is done as follows : // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PyramidFilterType::OutputImageListType::Iterator ImageListIterator; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the reader in order to access the input // image which has to be analysed. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the morphological pyramid analysis filter and set // its parameters which are: //\begin{itemize} // \item the number of iterations or levels of the pyramid; // \item the subsample scale or decimation factor between two // successive pyramid levels. //\end{itemize} // After that, we plug the pipeline and run it by calling the // \code{Update()} method. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PyramidFilterType::Pointer pyramid = PyramidFilterType::New(); pyramid->SetNumberOfLevels(numberOfLevels); pyramid->SetDecimationRatio(decimationRatio); pyramid->SetInput(reader->GetOutput()); pyramid->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The morphological pyramid has 5 // types of output: // \begin{itemize} // \item the analysed image at each level of the pyramid through the // \code{GetOutput()} method; // \item the brighter details extracted from the filtering operation through the // \code{GetSupFilter()} method; // \item the darker details extracted from the filtering operation through the // \code{GetInfFilter()} method; // \item the brighter details extracted from the resampling operation through the // \code{GetSupDeci()} method; // \item the darker details extracted from the resampling operation through the // \code{GetInfDeci()} method; // to decimation // \end{itemize} // Each one of these methods provides a list of images (one for each // level of analysis), so we can iterate through the image lists by // using iterators. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageListIterator itAnalyse = pyramid->GetOutput()->Begin(); ImageListIterator itSupFilter = pyramid->GetSupFilter()->Begin(); ImageListIterator itInfFilter = pyramid->GetInfFilter()->Begin(); ImageListIterator itInfDeci = pyramid->GetSupDeci()->Begin(); ImageListIterator itSupDeci = pyramid->GetInfDeci()->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate a writer and use it to write all the images // to files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); int i = 1; // Writing the results images std::cout << (itAnalyse != (pyramid->GetOutput()->End())) << std::endl; while (itAnalyse != pyramid->GetOutput()->End()) { writer->SetInput(itAnalyse.Get()); writer->SetFileName(argv[0 * 4 + i + 1]); writer->Update(); writer->SetInput(itSupFilter.Get()); writer->SetFileName(argv[1 * 4 + i + 1]); writer->Update(); writer->SetInput(itInfFilter.Get()); writer->SetFileName(argv[2 * 4 + i + 1]); writer->Update(); writer->SetInput(itInfDeci.Get()); writer->SetFileName(argv[3 * 4 + i + 1]); writer->Update(); writer->SetInput(itSupDeci.Get()); writer->SetFileName(argv[4 * 4 + i + 1]); writer->Update(); ++itAnalyse; ++itSupFilter; ++itInfFilter; ++itInfDeci; ++itSupDeci; ++i; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure \ref{fig:PYR_IM} shows the test image to be processed by the // morphological pyramid. // \begin{figure} // \center // \includegraphics[width=0.5\textwidth]{suburb2.eps} // \itkcaption[Morphological pyramid analysis]{Test image for the // morphological pyramid.} // \label{fig:PYR_IM} // \end{figure} // // Figure \ref{fig:PYR_AN} shows the 4 levels of analysis of the image. // \begin{figure} // \center // \includegraphics[width=0.20\textwidth]{suburb2_an_1.eps} // \includegraphics[width=0.20\textwidth]{suburb2_an_2.eps} // \includegraphics[width=0.20\textwidth]{suburb2_an_3.eps} // \includegraphics[width=0.20\textwidth]{suburb2_an_4.eps} // \itkcaption[Morphological pyramid analysis]{Result of the // analysis for 4 levels of the pyramid.} // \label{fig:PYR_AN} // \end{figure} // // Figure \ref{fig:PYR_SF} shows the 4 levels of bright details. // \begin{figure} // \center // \includegraphics[width=0.20\textwidth]{suburb2_sf_1.eps} // \includegraphics[width=0.20\textwidth]{suburb2_sf_2.eps} // \includegraphics[width=0.20\textwidth]{suburb2_sf_3.eps} // \includegraphics[width=0.20\textwidth]{suburb2_sf_4.eps} // \itkcaption[Morphological pyramid analysis]{Bright details for 4 levels of the pyramid.} // \label{fig:PYR_SF} // \end{figure} // // Figure \ref{fig:PYR_IF} shows the 4 levels of dark details. // \begin{figure} // \center // \includegraphics[width=0.20\textwidth]{suburb2_if_1.eps} // \includegraphics[width=0.20\textwidth]{suburb2_if_2.eps} // \includegraphics[width=0.20\textwidth]{suburb2_if_3.eps} // \includegraphics[width=0.20\textwidth]{suburb2_if_4.eps} // \itkcaption[Morphological pyramid analysis]{Dark details for 4 levels of the pyramid.} // \label{fig:PYR_IF} // \end{figure} // // Figure \ref{fig:PYR_ID} shows the 4 levels of bright decimation details. // \begin{figure} // \center // \includegraphics[width=0.20\textwidth]{suburb2_id_1.eps} // \includegraphics[width=0.20\textwidth]{suburb2_id_2.eps} // \includegraphics[width=0.20\textwidth]{suburb2_id_3.eps} // \includegraphics[width=0.20\textwidth]{suburb2_id_4.eps} // \itkcaption[Morphological pyramid analysis]{Bright decimation details for 4 levels of the pyramid.} // \label{fig:PYR_ID} // \end{figure} // // Figure \ref{fig:PYR_SD} shows the 4 levels of dark decimation details. // \begin{figure} // \center // \includegraphics[width=0.20\textwidth]{suburb2_sd_1.eps} // \includegraphics[width=0.20\textwidth]{suburb2_sd_2.eps} // \includegraphics[width=0.20\textwidth]{suburb2_sd_3.eps} // \includegraphics[width=0.20\textwidth]{suburb2_sd_4.eps} // \itkcaption[Morphological pyramid analysis]{Dark decimation details for 4 levels of the pyramid.} // \label{fig:PYR_SD} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/MultiScale/MorphologicalPyramidSegmentationExample.cxx000066400000000000000000000205401301006202600300020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{MorphologicalSegmentationFilter}. This filter // performs a segmentation of the details \code{supFilter} and // \code{infFilter} extracted with the morphological pyramid. The // segmentation algorithm used is based on seeds extraction using the // \doxygen{otb}{ImageToPointSetFilter}, followed by a connected // threshold segmentation using the // \doxygen{itk}{ConnectedThresholdImageFilter}. The threshold for seeds // extraction and segmentation are computed using quantiles. A pre // processing step is applied by multiplying the full resolution // brighter details (resp. darker details) with the original image // (resp. the inverted original image). This performs an enhancement of // the regions contour precision. The details from the pyramid are set // via the \code{SetBrighterDetails()} and \code{SetDarkerDetails()} // methods. The brighter and darker details depend on the filter used // in the pyramid analysis. If the // \doxygen{otb}{OpeningClosingMorphologicalFilter} filter is used, // then the brighter details are those from the \code{supFilter} image // list, whereas if the // \doxygen{otb}{ClosingOpeningMorphologicalFilter} filter is used, // the brighter details are those from the \code{infFilter} list. The // output of the segmentation filter is a single segmentation images // list, containing first the brighter details segmentation from // higher scale to lower, and then the darker details in the same // order. The attention of the user is drawn to the fact that since // the label filter used internally will deal with a large number of // labels, the \code{OutputPixelType} is required to be sufficiently // precise. Unsigned short or Unsigned long would be a good choice, // unless the user has a very good reason to think that a less precise // type will be sufficient. The first step to use this filter is to // include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMorphologicalPyramidSegmentationFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The mathematical morphology filters to be used have also to be // included here, as well as the morphological pyramid analysis filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbMorphologicalPyramidAnalysisFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkMacro.h" int main(int itkNotUsed(argc), char * argv[]) { const char* inputFilename = argv[1]; const char* outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; const unsigned int numberOfLevels = atoi(argv[4]); const double decimationRatio = atof(argv[5]); const float seedsQuantile = atof(argv[6]); const float segmentationQuantile = atof(argv[7]); const unsigned int minObjectSize = atoi(argv[8]); // Software Guide : BeginLatex // // As usual, we start by defining the types for the pixels, the // images, the reader and the writer. We also define the types needed // for the morphological pyramid analysis. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned short OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; typedef otb::MorphologicalPyramidAnalysisFilter PyramidFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type for the // \doxygen{otb}{MorphologicalPyramidSegmentationFilter} which is // templated over the input and output image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MorphologicalPyramidSegmentationFilter SegmentationFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the output of the segmentation filter is a list of images, // we define an iterator type which will be used to access the // segmented images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef SegmentationFilterType::OutputImageListIteratorType OutputListIteratorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following code snippet shows how to read the input image and // perform the morphological pyramid analysis. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); PyramidFilterType::Pointer pyramid = PyramidFilterType::New(); pyramid->SetNumberOfLevels(numberOfLevels); pyramid->SetDecimationRatio(decimationRatio); pyramid->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the segmentation filter and set its // parameters. As one can see, the \code{SetReferenceImage()} is used to // pass the original image in order to obtain sharp region // boundaries. Using the \code{SetBrighterDetails()} and // \code{SetDarkerDetails()} the output of the analysis is passed to the // filter. Finally, the parameters for the segmentation are set by // using the \code{SetSeedsQuantile()}, // \code{SetConnectedThresholdQuantile()} and // \code{SetMinimumObjectSize()} methods. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SegmentationFilterType::Pointer segmentation = SegmentationFilterType::New(); segmentation->SetReferenceImage(reader->GetOutput()); segmentation->SetBrighterDetails(pyramid->GetSupFilter()); segmentation->SetDarkerDetails(pyramid->GetInfFilter()); segmentation->SetSeedsQuantile(seedsQuantile); segmentation->SetConnectedThresholdQuantile(segmentationQuantile); segmentation->SetMinimumObjectSize(minObjectSize); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The pipeline is executed bu calling the \code{Update()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet segmentation->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we get an iterator to the list generated as output for the // segmentation and we use it to iterate through the list and write // the images to files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OutputListIteratorType it = segmentation->GetOutput()->Begin(); WriterType::Pointer writer; int index = 1; std::stringstream oss; while (it != segmentation->GetOutput()->End()) { oss << outputFilenamePrefix << index << "." << outputFilenameSuffix; writer = WriterType::New(); writer->SetInput(it.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); std::cout << oss.str() << " file written." << std::endl; oss.str(""); ++index; ++it; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The user will pay attention to the fact that the list contains // first the brighter details segmentation from // higher scale to lower, and then the darker details in the same // order. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/MultiScale/MorphologicalPyramidSegmenterExample.cxx000066400000000000000000000164411301006202600273030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {msPyrMRToMS_IKO_Halles_4_2_sf_full.tif}, {ROI_IKO_PAN_LesHalles.tif} // OUTPUTS: {outputPyrSegmented.tif} // 0 0.9 0.9 10 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \subdoxygen{otb}{MorphologicalPyramid}{Segmenter}. This class performs // the segmentation of a detail image extracted from a morphological // pyramid analysis. The Segmentation is performed using the // \doxygen{itk}{ConnectedThresholdImageFilter}. The seeds are // extracted from the image using the // \doxygen{otb}{ImageToPointSetFilter}. The thresolds are set by // using quantiles computed with the HistogramGenerator. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMorphologicalPyramidSegmenter.h" // Software Guide : EndCodeSnippet #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkScalarToRGBPixelFunctor.h" int main(int itkNotUsed(argc), char * argv[]) { const char* inputFilename = argv[1]; const char* originalFilename = argv[2]; const char* outputFilename1 = argv[3]; const bool segmentDark = atoi(argv[4]); const float seedsQuantile = atof(argv[5]); const float segmentationQuantile = atof(argv[6]); const unsigned int minObjectSize = atoi(argv[7]); // Software Guide : BeginLatex // // As usual, we start by defining the types needed for the pixels, the // images, the image reader and the image writer. Note that, for this // example, an RGB image will be created to store the results of the // segmentation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned short LabelPixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image InputImageType; typedef otb::Image LabelImageType; typedef otb::Image RGBImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define now the segmenter. Please pay attention to the fact that // this class belongs to the \code{morphologicalPyramid} namespace. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MorphologicalPyramid::Segmenter SegmenterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the readers which will give us access to the image // of details produced by the morphological pyramid analysis and the // original image (before analysis) which is used in order to produce // segmented regions which are sharper than what would have been // obtained with the detail image only. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(originalFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the segmenter and set its parameters as follows. We // plug the output of the readers for the details image and the // original image; we set the boolean variable which controls whether // the segmented details are bright or dark; we set the quantile used // to threshold the details image in order to obtain the seed points // for the segmentation; we set the quantile for setting the threshold // for the region growing segmentation; and finally, we set the // minimum size for a segmented region to be kept in the final result. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SegmenterType::Pointer segmenter = SegmenterType::New(); segmenter->SetDetailsImage(reader->GetOutput()); segmenter->SetOriginalImage(reader2->GetOutput()); segmenter->SetSegmentDarkDetailsBool(segmentDark); segmenter->SetSeedsQuantile(seedsQuantile); segmenter->SetConnectedThresholdQuantile(segmentationQuantile); segmenter->SetMinimumObjectSize(minObjectSize); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output of the segmenter is an image of integer // labels, where a label denotes membership of a pixel in a particular // segmented region. This value is usually coded using 16 bits. // This format is not practical for visualization, so // for the purposes of this example, we will convert it to RGB pixels. RGB // images have the advantage that they can be saved as a simple png file // and viewed using any standard image viewer software. The // \subdoxygen{itk}{Functor}{ScalarToRGBPixelFunctor} class is a special // function object designed to hash a scalar value into an // \doxygen{itk}{RGBPixel}. Plugging this functor into the // \doxygen{itk}{UnaryFunctorImageFilter} creates an image filter for that // converts scalar images to RGB images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Functor::ScalarToRGBPixelFunctor ColorMapFunctorType; typedef itk::UnaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now plug the final segment of the pipeline by using the // color mapper and the image file writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet colormapper->SetInput(segmenter->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(colormapper->GetOutput()); writer->SetFileName(outputFilename1); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure \ref{fig:PYR_SEGDET} shows the results of the segmentation // of the image of bright details obtained with the morphological // pyramid analysis. // \begin{figure} // \center // \includegraphics[width=0.30\textwidth]{ROI_IKO_PAN_LesHalles.eps} // \includegraphics[width=0.30\textwidth]{msPyrMRToMS_IKO_Halles_4_2_sf_full.eps} // \includegraphics[width=0.30\textwidth]{outputPyrSegmented.eps} // \itkcaption[Morphological pyramid analysis]{Morphological pyramid // segmentation. From left to right: original image, image of bright // details and result of the sementation.} // \label{fig:PYR_SEGDET} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/MultiScale/MorphologicalPyramidSynthesisFilterExample.cxx000066400000000000000000000214231301006202600305050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" // Software Guide : BeginCommandLineArgs // INPUTS: {suburb2.jpeg} // OUTPUTS: {suburb2_synthesis.jpeg} // 4 2 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{MorphologicalPyramidSynthesisFilter}. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMorphologicalPyramidSynthesisFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The mathematical morphology filters to be used have also to be // included here, as well as the // \doxygen{otb}{MorphologicalPyramidAnalyseFilter} in order to // perform the analysis step. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMorphologicalPyramidAnalysisFilter.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int main(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " inputImageFile "; std::cerr << " outputImageFile iterations decimationRatio" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const unsigned int numberOfLevels = atoi(argv[3]); const float decimationRatio = atof(argv[4]); // Software Guide : BeginLatex // // As usual, we start by defining the types needed for the pixels, the // images, the image reader and the image writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we define the types needed for the morphological filters which // will be used to build the morphological pyramid. The first thing to // do is define the structuring element, which in our case, will be a // \doxygen{itk}{BinaryBallStructuringElement} which is templated over // the pixel type and the dimension of the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryBallStructuringElement StructuringElementType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type of the filter to be used by the // morphological pyramid. In this case, we choose to use an // \doxygen{otb}{OpeningClosingMorphologicalFilter} which is just the // concatenation of an opening and a closing. This filter is theplated // over the input and output image types and the structurung element // type that we just define above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the type of the morpholoical pyramid // filter. The filter is templated over the input and output mage // types and the {\em lowpas} morphological filter to be used. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MorphologicalPyramidAnalysisFilter PyramidAnalysisFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can finally define the type of the morpholoical pyramid synthesis // filter. The filter is templated over the input and output mage // types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MorphologicalPyramidSynthesisFilter PyramidSynthesisFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the reader in order to access the input // image which has to be analysed. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the morphological pyramid analysis filter and set // its parameters which are: //\begin{itemize} // \item the number of iterations or levels of the pyramid; // \item the subsample scale or decimation factor between two // successive pyramid levels. //\end{itemize} // After that, we plug the pipeline and run it by calling the // \code{Update()} method. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PyramidAnalysisFilterType::Pointer pyramidAnalysis = PyramidAnalysisFilterType::New(); pyramidAnalysis->SetNumberOfLevels(numberOfLevels); pyramidAnalysis->SetDecimationRatio(decimationRatio); pyramidAnalysis->SetInput(reader->GetOutput()); pyramidAnalysis->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the analysis step is finished we can proceed to the synthesis // of the image from its different levels of decomposition. // The morphological pyramid has 5 // types of output: // \begin{itemize} // \item the Analysisd image at each level of the pyramid through the // \code{GetOutput()} method; // \item the brighter details extracted from the filtering operation through the // \code{GetSupFilter()} method; // \item the darker details extracted from the filtering operation through the // \code{GetInfFilter()} method; // \item the brighter details extracted from the resampling operation through the // \code{GetSupDeci()} method; // \item the darker details extracted from the resampling operation through the // \code{GetInfDeci()} method; // to decimation // \end{itemize} // This outputs can be used as input of the synthesis filter by using // the appropriate methods. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PyramidSynthesisFilterType::Pointer pyramidSynthesis = PyramidSynthesisFilterType::New(); pyramidSynthesis->SetInput(pyramidAnalysis->GetOutput()->Back()); pyramidSynthesis->SetSupFilter(pyramidAnalysis->GetSupFilter()); pyramidSynthesis->SetSupDeci(pyramidAnalysis->GetSupDeci()); pyramidSynthesis->SetInfFilter(pyramidAnalysis->GetInfFilter()); pyramidSynthesis->SetInfDeci(pyramidAnalysis->GetInfDeci()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After that, we plug the pipeline and run it by calling the // \code{Update()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet pyramidSynthesis->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We finally instatiate a the writer in order to save the result // image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(pyramidSynthesis->GetOutput()->Back()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the synthesis operation is applied on the result of the // analysis, the input and the output images should be identical. This // is the case as shown in figure \ref{fig:PYR_ANSYN}. // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{suburb2.eps} // \includegraphics[width=0.44\textwidth]{suburb2_synthesis.eps} // \itkcaption[Morphological pyramid analysis and synthesis]{Result of // the morphological pyramid analysis and synthesis. Left: original // image. Right: result of applying the analysis and the synthesis steps.} // \label{fig:PYR_ANSYN} // \end{figure} // // Of course, in a real application, a specific processing will be // applied after the analysis and before the synthesis to, for // instance, denoise the image by removing pixels at the finer scales, etc. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/MultiScale/test/000077500000000000000000000000001301006202600202155ustar00rootroot00000000000000OTB-release-5.8/Examples/MultiScale/test/CMakeLists.txt000066400000000000000000000067311301006202600227640ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/MultiScale) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- MorphologicalPyramidAnalysisFilterExampleTest ---------- otb_add_test(NAME msTeMorphologicalPyramidAnalysisFilterExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 20 ${BASELINE}/suburb2_an_1.jpeg ${TEMP}/suburb2_an_1.jpeg ${BASELINE}/suburb2_an_2.jpeg ${TEMP}/suburb2_an_2.jpeg ${BASELINE}/suburb2_an_3.jpeg ${TEMP}/suburb2_an_3.jpeg ${BASELINE}/suburb2_an_4.jpeg ${TEMP}/suburb2_an_4.jpeg ${BASELINE}/suburb2_sf_1.jpeg ${TEMP}/suburb2_sf_1.jpeg ${BASELINE}/suburb2_sf_2.jpeg ${TEMP}/suburb2_sf_2.jpeg ${BASELINE}/suburb2_sf_3.jpeg ${TEMP}/suburb2_sf_3.jpeg ${BASELINE}/suburb2_sf_4.jpeg ${TEMP}/suburb2_sf_4.jpeg ${BASELINE}/suburb2_if_1.jpeg ${TEMP}/suburb2_if_1.jpeg ${BASELINE}/suburb2_if_2.jpeg ${TEMP}/suburb2_if_2.jpeg ${BASELINE}/suburb2_if_3.jpeg ${TEMP}/suburb2_if_3.jpeg ${BASELINE}/suburb2_if_4.jpeg ${TEMP}/suburb2_if_4.jpeg ${BASELINE}/suburb2_id_1.jpeg ${TEMP}/suburb2_id_1.jpeg ${BASELINE}/suburb2_id_2.jpeg ${TEMP}/suburb2_id_2.jpeg ${BASELINE}/suburb2_id_3.jpeg ${TEMP}/suburb2_id_3.jpeg ${BASELINE}/suburb2_id_4.jpeg ${TEMP}/suburb2_id_4.jpeg ${BASELINE}/suburb2_sd_1.jpeg ${TEMP}/suburb2_sd_1.jpeg ${BASELINE}/suburb2_sd_2.jpeg ${TEMP}/suburb2_sd_2.jpeg ${BASELINE}/suburb2_sd_3.jpeg ${TEMP}/suburb2_sd_3.jpeg ${BASELINE}/suburb2_sd_4.jpeg ${TEMP}/suburb2_sd_4.jpeg Execute $ ${INPUTDATA}/suburb2.jpeg ${TEMP}/suburb2_an_1.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_an_2.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_an_3.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_an_4.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sf_1.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sf_2.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sf_3.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sf_4.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_if_1.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_if_2.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_if_3.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_if_4.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_id_1.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_id_2.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_id_3.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_id_4.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sd_1.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sd_2.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sd_3.jpeg?&gdal:co:QUALITY=95 ${TEMP}/suburb2_sd_4.jpeg?&gdal:co:QUALITY=95 4 2 ) # ------- MorphologicalPyramidSynthesisFilterExampleTest ---------- otb_add_test(NAME msTeMorphologicalPyramidSynthesisFilterExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/suburb2_synthesis.jpeg ${TEMP}/suburb2_synthesis.jpeg Execute $ ${INPUTDATA}/suburb2.jpeg ${TEMP}/suburb2_synthesis.jpeg?&gdal:co:QUALITY=95 4 2 ) # ------- MorphologicalPyramidSegmenterExampleTest ---------- otb_add_test(NAME msTeMorphologicalPyramidSegmenterExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/outputPyrSegmented.tif ${TEMP}/outputPyrSegmented.tif Execute $ ${INPUTDATA}/msPyrMRToMS_IKO_Halles_4_2_sf_full.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/outputPyrSegmented.tif 0 0.9 0.9 10 ) OTB-release-5.8/Examples/OBIA/000077500000000000000000000000001301006202600157065ustar00rootroot00000000000000OTB-release-5.8/Examples/OBIA/CMakeLists.txt000066400000000000000000000016231301006202600204500ustar00rootroot00000000000000project(OBIAExamples) add_executable(HooverMetricsEstimation HooverMetricsEstimation.cxx) target_link_libraries(HooverMetricsEstimation ${OTB_LIBRARIES}) add_executable(ImageToLabelToImage ImageToLabelToImage.cxx) target_link_libraries(ImageToLabelToImage ${OTB_LIBRARIES}) add_executable(KeepNObjects KeepNObjects.cxx) target_link_libraries(KeepNObjects ${OTB_LIBRARIES}) add_executable(LabelMapToVectorData LabelMapToVectorData.cxx) target_link_libraries(LabelMapToVectorData ${OTB_LIBRARIES}) if(OTBMathParser_LOADED) add_executable(RadiometricAttributesLabelMapFilterExample RadiometricAttributesLabelMapFilterExample.cxx) target_link_libraries(RadiometricAttributesLabelMapFilterExample ${OTB_LIBRARIES}) endif() add_executable(ShapeAttributeComputation ShapeAttributeComputation.cxx) target_link_libraries(ShapeAttributeComputation ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/OBIA/HooverMetricsEstimation.cxx000066400000000000000000000213651301006202600232670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {maur_GT.tif}, {maur_labelled.tif} // OUTPUTS: {maur_colored_GT.tif} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following example shows how to compare two segmentations, using Hoover // metrics. For instance, it can be used to compare a segmentation produced // by your algorithm against a partial ground truth segmentation. In this // example, the ground truth segmentation will be referred by the letters GT // whereas the machine segmentation will be referred by MS. // // The estimation of Hoover metrics is done with two filters : // \doxygen{otb}{HooverMatrixFilter} and \doxygen{otb}{HooverInstanceFilter}. // The first one produces a matrix containing the number of overlapping pixels // between MS regions and GT regions. The second one classifies each region among // four types (called Hoover instances): // \begin{itemize} // \item Correct detection : a region is matched with an other one in the // opposite segmentation, because they cover nearly the same area. // \item Over-segmentation : a GT region is matched with a group of MS // regions because they cover nearly the same area. // \item Under-segmentation : a MS region is matched with a group of GT // regions because they cover nearly the same area. // \item Missed detection (for GT regions) or Noise (for MS region) : // un-matched regions. // \end{itemize} // Note that a region can be tagged with two types. When the Hoover instance // have been found, the instance filter computes overall scores for each // category : they are the Hoover metrics \footnote{see http://www.trop.mips.uha.fr/pdf/ORASIS-2009.pdf}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbHooverMatrixFilter.h" #include "otbHooverInstanceFilter.h" #include "otbLabelMapToAttributeImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkLabelImageToLabelMapFilter.h" int main(int argc, char* argv[]) { if(argc != 4) { std::cerr << "Usage: " << argv[0]; std::cerr << " segmentationGT segmentationMS outputAttributeImage" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // The filters \doxygen{otb}{HooverMatrixFilter} and \doxygen{otb}{HooverInstanceFilter} // are designed to handle \doxygen{itk}{LabelMap} images, made with \doxygen{otb}{AttributesMapLabelObject}. // This type of label object allows storing generic attributes. Each region can store // a set of attributes: in this case, Hoover instances and metrics will be stored. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::HooverMatrixFilter HooverMatrixFilterType; typedef otb::HooverInstanceFilter InstanceFilterType; typedef otb::Image ImageType; typedef itk::LabelImageToLabelMapFilter ImageToLabelMapFilterType; typedef otb::VectorImage VectorImageType; typedef otb::LabelMapToAttributeImageFilter AttributeImageFilterType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileWriter WriterType; ImageReaderType::Pointer gt_reader = ImageReaderType::New(); gt_reader->SetFileName(argv[1]); ImageReaderType::Pointer ms_reader = ImageReaderType::New(); ms_reader->SetFileName(argv[2]); // Software Guide : BeginLatex // The first step is to convert the images to label maps : we use // \doxygen{itk}{LabelImageToLabelMapFilter}. The background value sets // the label value of regions considered as background: there is no label object for the // background region. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageToLabelMapFilterType::Pointer gt_filter = ImageToLabelMapFilterType::New(); gt_filter->SetInput(gt_reader->GetOutput()); gt_filter->SetBackgroundValue(0); ImageToLabelMapFilterType::Pointer ms_filter = ImageToLabelMapFilterType::New(); ms_filter->SetInput(ms_reader->GetOutput()); ms_filter->SetBackgroundValue(0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The Hoover matrix filter has to be updated here. This matrix must be computed // before being given to the instance filter. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet HooverMatrixFilterType::Pointer hooverFilter = HooverMatrixFilterType::New(); hooverFilter->SetGroundTruthLabelMap(gt_filter->GetOutput()); hooverFilter->SetMachineSegmentationLabelMap(ms_filter->GetOutput()); hooverFilter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The instance filter computes the Hoover metrics for each region. These metrics // are stored as attributes in each label object. The threshold parameter // corresponds to the overlapping ratio above which two regions can be matched. // The extended attributes can be used if the user wants to keep a trace of the // associations between MS and GT regions : i.e. if a GT region has been matched // as a correct detection, it will carry an attribute containing the label value // of the associated MS region (the same principle goes for other types of instance). // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InstanceFilterType::Pointer instances = InstanceFilterType::New(); instances->SetGroundTruthLabelMap(gt_filter->GetOutput()); instances->SetMachineSegmentationLabelMap(ms_filter->GetOutput()); instances->SetThreshold(0.75); instances->SetHooverMatrix(hooverFilter->GetHooverConfusionMatrix()); instances->SetUseExtendedAttributes(false); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The \doxygen{otb}{LabelMapToAttributeImageFilter} is designed to extract attributes // values from a label map and output them in the channels of a vector image. We set // the attribute to plot in each channel. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet AttributeImageFilterType::Pointer attributeImageGT = AttributeImageFilterType::New(); attributeImageGT->SetInput(instances->GetOutputGroundTruthLabelMap()); attributeImageGT->SetAttributeForNthChannel(0, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RC)); attributeImageGT->SetAttributeForNthChannel(1, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RF)); attributeImageGT->SetAttributeForNthChannel(2, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RA)); attributeImageGT->SetAttributeForNthChannel(3, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RM)); WriterType::Pointer writer = WriterType::New(); writer->SetInput(attributeImageGT->GetOutput()); writer->SetFileName(argv[3]); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The output image contains for each GT region its correct detection score ("RC", band 1), // its over-segmentation score ("RF", band 2), its under-segmentation score ("RA", band 3) // and its missed detection score ("RM", band 4). // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::cout << "Mean RC ="<< instances->GetMeanRC() << std::endl; std::cout << "Mean RF ="<< instances->GetMeanRF() << std::endl; std::cout << "Mean RA ="<< instances->GetMeanRA() << std::endl; std::cout << "Mean RM ="<< instances->GetMeanRM() << std::endl; std::cout << "Mean RN ="<< instances->GetMeanRN() << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The Hoover scores are also computed for the whole segmentations. Here is some explanation about the score names : // C = correct, F = fragmentation, A = aggregation, M = missed, N = noise. // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/OBIA/ImageToLabelToImage.cxx000066400000000000000000000132301301006202600221640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {MSLabeledOutput.tif} // OUTPUTS: {OBIAI2L2IOutput.tif}, {OBIAI2L2IInputPretty.png}, {OBIAI2L2IOutputPretty.png} // 1 1108 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example shows the basic approach for the transformation of a // segmented (labeled) image into a LabelObjectMap and then back to // an image. For this matter we will need the following header files // which contain the basic classes. // // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkBinaryImageToLabelMapFilter.h" #include "itkLabelMapToLabelImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char * argv[]) { if (argc != 8) { std::cerr << "usage: " << argv[0] << " input output inPretty outPretty conn fg bg" << std::endl; exit(1); } // Software Guide : BeginLatex // // The image types are defined using pixel types and // dimension. The input image is defined as an \doxygen{otb}{Image}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const int dim = 2; typedef unsigned short PixelType; typedef otb::Image ImageType; typedef itk::LabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As usual, the reader is instantiated and // the input image is set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then the binary image is transformed to a collection // of label objects. Arguments are: // \begin{itemize} // \item \code{FullyConnected}: Set whether the connected // components are defined strictly by face connectivity or by // face+edge+vertex connectivity. Default is FullyConnectedOff. // \item \code{InputForegroundValue/OutputBackgroundValue}: Specify the // pixel value of input/output of the foreground/background. // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryImageToLabelMapFilter I2LType; I2LType::Pointer i2l = I2LType::New(); i2l->SetInput(reader->GetOutput()); i2l->SetFullyConnected(atoi(argv[5])); i2l->SetInputForegroundValue(atoi(argv[6])); i2l->SetOutputBackgroundValue(atoi(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then the inverse process is used to recreate a image of labels. // The \doxygen{itk}{LabelMapToLabelImageFilter} converts a // LabelMap to a labeled image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::LabelMapToLabelImageFilter L2IType; L2IType::Pointer l2i = L2IType::New(); l2i->SetInput(i2l->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output can be passed to a writer. The invocation // of the \code{Update()} method on the writer triggers the // execution of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(l2i->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); // Software Guide : EndCodeSnippet // Pretty image creation for the printing typedef otb::Image OutputPrettyImageType; typedef otb::ImageFileWriter WriterPrettyType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); WriterPrettyType::Pointer prettyWriter = WriterPrettyType::New(); rescaler->SetInput(reader->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); prettyWriter->SetFileName(argv[3]); prettyWriter->SetInput(rescaler->GetOutput()); prettyWriter->Update(); rescaler->SetInput(l2i->GetOutput()); prettyWriter->SetFileName(argv[4]); prettyWriter->SetInput(rescaler->GetOutput()); prettyWriter->Update(); // Software Guide : BeginLatex // // Figure~\ref{fig:ImageToLabel} shows the effect of transforming an // image into a label object map and back to an image // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{OBIAI2L2IInputPretty.eps} // \includegraphics[width=0.44\textwidth]{OBIAI2L2IOutputPretty.eps} // \itkcaption[Image to Label Object Map]{Transforming an // image (left) into a label object map and back to an image (right).} // \label{fig:ImageToLabel} // \end{figure} // Software Guide : EndLatex return 0; } OTB-release-5.8/Examples/OBIA/KeepNObjects.cxx000066400000000000000000000073221301006202600207520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {MSLabeledOutput.tif} // OUTPUTS: {OBIAShapeAttribute1.txt} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example shows the // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkSimpleFilterWatcher.h" //#include "itkLabelStatisticsKeepNObjectsImageFilter.h" #include "itkLabelImageToLabelMapFilter.h" #include "itkStatisticsLabelMapFilter.h" #include "itkStatisticsKeepNObjectsLabelMapFilter.h" #include "itkLabelMapToLabelImageFilter.h" int main(int argc, char * argv[]) { if (argc != 8) { std::cerr << "usage: " << argv[0] << " input input output background nb reverseOrdering attribute" << std::endl; // std::cerr << " : " << std::endl; exit(1); } const int dim = 3; typedef unsigned char PixelType; typedef otb::Image IType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(argv[2]); typedef itk::StatisticsLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::LabelImageToLabelMapFilter LabelizerType; typedef itk::StatisticsLabelMapFilter LabelObjectValuatorType; typedef itk::StatisticsKeepNObjectsLabelMapFilter KeepNObjectsType; typedef itk::LabelMapToLabelImageFilter BinarizerType; LabelizerType::Pointer labelizer = LabelizerType::New(); labelizer->SetInput(reader->GetOutput()); labelizer->SetBackgroundValue(atoi(argv[4])); LabelObjectValuatorType::Pointer valuator = LabelObjectValuatorType::New(); valuator->SetInput(labelizer->GetOutput()); valuator->SetFeatureImage(reader2->GetOutput()); valuator->SetLabelImage(reader->GetOutput()); valuator->SetComputeHistogram(false); KeepNObjectsType::Pointer opening = KeepNObjectsType::New(); opening->SetInput(valuator->GetOutput()); opening->SetNumberOfObjects(atoi(argv[5])); opening->SetReverseOrdering(atoi(argv[6])); opening->SetAttribute(argv[7]); BinarizerType::Pointer binarizer = BinarizerType::New(); binarizer->SetInput(opening->GetOutput()); /* typedef itk::LabelStatisticsKeepNObjectsImageFilter< IType, IType > LabelOpeningType; LabelOpeningType::Pointer opening = LabelOpeningType::New(); opening->SetInput( reader->GetOutput() ); opening->SetFeatureImage( reader2->GetOutput() ); opening->SetBackgroundValue( atoi(argv[4]) ); opening->SetNumberOfObjects( atoi(argv[5]) ); opening->SetReverseOrdering( atoi(argv[6]) ); opening->SetAttribute( argv[7] ); itk::SimpleFilterWatcher watcher(opening, "filter"); */ typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(binarizer->GetOutput()); writer->SetFileName(argv[3]); writer->Update(); return 0; } OTB-release-5.8/Examples/OBIA/LabelMapToVectorData.cxx000066400000000000000000000140511301006202600223700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {rcc8_mire1.png} // OUTPUTS: {rcc8_mire2_vectorizer.shp} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{otb::LabelMapToVectorDataFilter} // // // This class vectorizes a LabelObject to a VectorData. // // The \doxygen{otb}{LabelMapToVectorDataFilter} converts an \doxygen{itk}{LabelMap} to an // \doxygen{otb}{VectorData} where all the pixels get the attribute // value of the label object they belong to. // It uses the class \doxygen{otb}{LabelObjectToPolygonFunctor} which // follows a finite state machine described in \cite{Francis2000}. // // Only polygon conversion is available yet. // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include #include #include "otbImage.h" // Software Guide : BeginLatex // // These are the main header files which need to be included: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbLabelMapToVectorDataFilter.h" #include "otbAttributesMapLabelObject.h" // Software Guide : EndCodeSnippet #include "itkLabelImageToLabelMapFilter.h" int main(int argc, char * argv[]) { /** Use the labelObjecttopolygon functor (not thread safe) only polygon conversion is available yet*/ if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputImageFile outputVectorfile(shp)" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; // Software Guide : BeginLatex // // The image types are defined using pixel types and // dimension. The input image is defined as an \doxygen{itk}{Image}, // the output is a \doxygen{otb}{VectorData}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image LabeledImageType; typedef otb::VectorData VectorDataType; // Software Guide : EndCodeSnippet // We instantiate reader and writer types typedef otb::ImageFileReader LabeledReaderType; typedef otb::VectorDataFileWriter WriterType; // Label map typedef // Software Guide : BeginLatex // // The Attribute Label Map is // instantiated using the image pixel types as template parameters. // The LabelObjectToPolygonFunctor is instantiated with LabelObjectType and PolygonType. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::LabelImageToLabelMapFilter LabelMapFilterType; // Software Guide : EndCodeSnippet LabeledReaderType::Pointer lreader = LabeledReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : BeginLatex // Now the reader and writer are instantiated and // the input image is set and a name is given to the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet lreader->SetFileName(infname); writer->SetFileName(outfname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, the input image is converted to a map of label objects. // Here each white region connected regions are converted. So the background is define all zero pixels. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LabelMapFilterType::Pointer labelMapFilter = LabelMapFilterType::New(); labelMapFilter->SetInput(lreader->GetOutput()); labelMapFilter->SetBackgroundValue(itk::NumericTraits::min()); labelMapFilter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, the \doxygen{otb}{LabelMapToVectorDataFilter} is instantiated. This is // the main filter which performs the vectorization. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LabelMapToVectorDataFilter LabelMapToVectorDataFilterType; LabelMapToVectorDataFilterType::Pointer MyFilter = LabelMapToVectorDataFilterType::New(); MyFilter->SetInput(labelMapFilter->GetOutput()); MyFilter->Update(); MyFilter->GetOutput()->SetProjectionRef( lreader->GetOutput()->GetProjectionRef()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output can be passed to a writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetInput(MyFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. As usual, it is recommended to place update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); return EXIT_SUCCESS; } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/OBIA/RadiometricAttributesLabelMapFilterExample.cxx000066400000000000000000000272071301006202600270330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {qb_RoadExtract.tif} // OUTPUTS: {OBIARadiometricAttribute1.png}, {qb_ExtractRoad_Radiometry_pretty.jpg} // STATS::Band1::Mean 0 0.5 16 16 50 1.0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example shows the basic approach to perform object based analysis on a image. // The input image is firstly segmented using the \doxygen{otb}{MeanShiftSegmentationFilter} // Then each segmented region is converted to a Map of labeled objects. // Afterwards the \doxygen{otb}{otbMultiChannelRAndNIRIndexImageFilter} computes // radiometric attributes for each object. In this example the NDVI is computed. // The computed feature is passed to the \doxygen{otb}{BandsStatisticsAttributesLabelMapFilter} // which computes statistics over the resulting band. // Therefore, region's statistics over each band can be access by concatening // STATS, the band number and the statistical attribute separated by colons. In this example // the mean of the first band (which contains the NDVI) is access over all the regions // with the attribute: 'STATS::Band1::Mean'. // // Software Guide : EndLatex #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMeanShiftSegmentationFilter.h" #include "itkLabelImageToLabelMapFilter.h" #include "otbShapeAttributesLabelMapFilter.h" #include "otbBandsStatisticsAttributesLabelMapFilter.h" #include "itkLabelMapToBinaryImageFilter.h" #include "otbMultiChannelExtractROI.h" #include "otbAttributesMapOpeningLabelMapFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" #include "otbImageToVectorImageCastFilter.h" int main(int argc, char * argv[]) { if (argc != 11) { std::cerr << "Usage: " << argv[0] << " reffname outfname outprettyfname attribute_name "; std::cerr << "lowerThan tresh spatialRadius rangeRadius minregionsize scale" << std::endl; return EXIT_FAILURE; } const char * reffname = argv[1]; const char * outfname = argv[2]; const char * outprettyfname = argv[3]; const char * attr = argv[4]; bool lowerThan = atoi(argv[5]); double thresh = atof(argv[6]); const unsigned int spatialRadius = atoi(argv[7]); const double rangeRadius = atof(argv[8]); const unsigned int minRegionSize = atoi(argv[9]); /* const double scale = atoi(argv[10]); */ const unsigned int Dimension = 2; // Labeled image type typedef unsigned int LabelType; typedef unsigned char MaskPixelType; typedef double PixelType; typedef otb::Image LabeledImageType; typedef otb::Image MaskImageType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::VectorImage OutputVectorImageType; typedef otb::ImageFileReader LabeledReaderType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader VectorReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter VectorWriterType; typedef otb::VectorRescaleIntensityImageFilter VectorRescalerType; typedef otb::MultiChannelExtractROI ChannelExtractorType; // Label map typedef typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::LabelImageToLabelMapFilter LabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeLabelMapFilterType; typedef otb::BandsStatisticsAttributesLabelMapFilter RadiometricLabelMapFilterType; typedef otb::AttributesMapOpeningLabelMapFilter OpeningLabelMapFilterType; typedef itk::LabelMapToBinaryImageFilter LabelMapToBinaryImageFilterType; typedef otb::MultiChannelRAndNIRIndexImageFilter NDVIImageFilterType; typedef otb::ImageToVectorImageCastFilter ImageToVectorImageCastFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(reffname); LabeledReaderType::Pointer lreader = LabeledReaderType::New(); lreader->SetFileName(reffname); VectorReaderType::Pointer vreader = VectorReaderType::New(); vreader->SetFileName(reffname); vreader->Update(); // Software Guide : BeginLatex // // Firstly, segment the input image by using the Mean Shift algorithm (see \ref{sec:MeanShift} for deeper // explanations). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MeanShiftSegmentationFilter FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetSpatialBandwidth(spatialRadius); filter->SetRangeBandwidth(rangeRadius); filter->SetMinRegionSize(minRegionSize); filter->SetThreshold(0.1); filter->SetMaxIterationNumber(100); // Software Guide : EndCodeSnippet // For non regression tests, set the number of threads to 1 // because MeanShift results depends on the number of threads filter->SetNumberOfThreads(1); // Software Guide : BeginLatex // // The \doxygen{otb}{MeanShiftSegmentationFilter} type is instantiated using the image // types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(vreader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{itk}{LabelImageToLabelMapFilter} type is instantiated using the output // of the \doxygen{otb}{MeanShiftSegmentationFilter}. This filter produces a labeled image // where each segmented region has a unique label. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LabelMapFilterType::Pointer labelMapFilter = LabelMapFilterType::New(); labelMapFilter->SetInput(filter->GetLabelOutput()); labelMapFilter->SetBackgroundValue(itk::NumericTraits::min()); ShapeLabelMapFilterType::Pointer shapeLabelMapFilter = ShapeLabelMapFilterType::New(); shapeLabelMapFilter->SetInput(labelMapFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Instantiate the \doxygen{otb}{RadiometricLabelMapFilterType} to // compute statistics of the feature image on each label object. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet RadiometricLabelMapFilterType::Pointer radiometricLabelMapFilter = RadiometricLabelMapFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Feature image could be one of the following image: // \begin{itemize} // \item GEMI // \item NDVI // \item IR // \item IC // \item IB // \item NDWI2 // \item Intensity // \end{itemize} // // Input image must be convert to the desired coefficient. // In our case, statistics are computed on the NDVI coefficient on each label object. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NDVIImageFilterType:: Pointer ndviImageFilter = NDVIImageFilterType::New(); ndviImageFilter->SetRedIndex(3); ndviImageFilter->SetNIRIndex(4); ndviImageFilter->SetInput(vreader->GetOutput()); ImageToVectorImageCastFilterType::Pointer ndviVectorImageFilter = ImageToVectorImageCastFilterType::New(); ndviVectorImageFilter->SetInput(ndviImageFilter->GetOutput()); radiometricLabelMapFilter->SetInput(shapeLabelMapFilter->GetOutput()); radiometricLabelMapFilter->SetFeatureImage(ndviVectorImageFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{AttributesMapOpeningLabelMapFilter} will perform the selection. // There are three parameters. \code{AttributeName} specifies the radiometric attribute, \code{Lambda} // controls the thresholding of the input and \code{ReverseOrdering} make this filter to remove the // object with an attribute value greater than \code{Lambda} instead. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OpeningLabelMapFilterType::Pointer opening = OpeningLabelMapFilterType::New(); opening->SetInput(radiometricLabelMapFilter->GetOutput()); opening->SetAttributeName(attr); opening->SetLambda(thresh); opening->SetReverseOrdering(lowerThan); opening->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, Label objects selected are transform in a Label Image using the // \doxygen{itk}{LabelMapToLabelImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LabelMapToBinaryImageFilterType::Pointer labelMap2LabeledImage = LabelMapToBinaryImageFilterType::New(); labelMap2LabeledImage->SetInput(opening->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we declare the writer and call its \code{Update()} method to // trigger the full pipeline execution. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(labelMap2LabeledImage->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet OutputVectorImageType::PixelType minimum, maximum; minimum.SetSize(vreader->GetOutput()->GetNumberOfComponentsPerPixel()); maximum.SetSize(vreader->GetOutput()->GetNumberOfComponentsPerPixel()); minimum.Fill(0); maximum.Fill(255); VectorRescalerType::Pointer vr = VectorRescalerType::New(); vr->SetInput(filter->GetClusteredOutput()); vr->SetOutputMinimum(minimum); vr->SetOutputMaximum(maximum); vr->SetClampThreshold(0.01); ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); selecter->SetInput(vr->GetOutput()); selecter->SetExtractionRegion(vreader->GetOutput()->GetLargestPossibleRegion()); selecter->SetChannel(3); selecter->SetChannel(2); selecter->SetChannel(1); VectorWriterType::Pointer vectWriter = VectorWriterType::New(); vectWriter->SetFileName(outprettyfname); vectWriter->SetInput(selecter->GetOutput()); vectWriter->Update(); return EXIT_SUCCESS; } // Software Guide : BeginLatex // // Figure~\ref{fig:RADIOMETRIC_LABEL_MAP_FILTER} shows the result of applying // the object selection based on radiometric attributes. // \begin{figure} [htbp] // \center // \includegraphics[width=0.44\textwidth]{qb_ExtractRoad_Radiometry_pretty.eps} // \includegraphics[width=0.44\textwidth]{OBIARadiometricAttribute1.eps} // \itkcaption[Object based extraction based on ]{Vegetation mask resulting from processing.} // \label{fig:RADIOMETRIC_LABEL_MAP_FILTER} // \end{figure} // // Software Guide : EndLatex OTB-release-5.8/Examples/OBIA/ShapeAttributeComputation.cxx000066400000000000000000000121211301006202600235760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {qb_RoadExtract2.tif} // OUTPUTS: {OBIAShapeAttribute.txt} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This basic example shows how compute shape attributes at the object level. // The input image is firstly converted into a set of regions ( // \doxygen{itk}{ShapeLabelObject}), some attribute values of each // object are computed and then saved to an ASCII file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkShapeLabelObject.h" #include "itkLabelImageToLabelMapFilter.h" #include "itkShapeLabelMapFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "usage: " << argv[0] << " input outputcentroidlist" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The image types are defined using pixel types and // dimensions. The input image is defined as an \doxygen{otb}{Image}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const int dim = 2; typedef unsigned long PixelType; typedef otb::Image ImageType; typedef unsigned long LabelType; typedef itk::ShapeLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::LabelImageToLabelMapFilter ConverterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Firstly, the image reader is instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Here the \doxygen{itk}{ShapeLabelObject} type // is chosen in order to read some attributes related to the shape // of the objects, by opposition to the content of the object, with // the \doxygen{itk}{StatisticsLabelObject}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ShapeLabelMapFilter ShapeFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input image is converted in a collection of objects // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConverterType::Pointer converter = ConverterType::New(); converter->SetInput(reader->GetOutput()); converter->SetBackgroundValue(itk::NumericTraits::min()); ShapeFilterType::Pointer shape = ShapeFilterType::New(); shape->SetInput(converter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Update the shape filter, so its output will be up to date. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet shape->Update(); // Software Guide : EndCodeSnippet std::cout << "Nb. objects conv. " << converter->GetOutput()->GetNumberOfLabelObjects() << std::endl; std::cout << "Nb. objects shape " << shape->GetOutput()->GetNumberOfLabelObjects() << std::endl; // Software Guide : BeginLatex // // Then, we can read the attribute values we're interested in. The \doxygen{itk}{BinaryImageToShapeLabelMapFilter} // produces consecutive labels, so we can use a for loop and \code{GetLabelObject()} method to retrieve // the label objects. If the labels are not consecutive, the \code{GetNthLabelObject()} method must be // use instead of \code{GetLabelObject()}, or an iterator on the label // object container of the label map. // In this example, we write 2 shape attributes of each object to a text file (the size and the centroid coordinates). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::ofstream outfile(argv[2]); LabelMapType::Pointer labelMap = shape->GetOutput(); for (unsigned long label = 1; label <= labelMap->GetNumberOfLabelObjects(); label++) { // We don't need a SmartPointer of the label object here, // because the reference is kept in the label map. const LabelObjectType * labelObject = labelMap->GetLabelObject(label); outfile << label << "\t" << labelObject->GetPhysicalSize() << "\t" << labelObject->GetCentroid() << std::endl; } outfile.close(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/OBIA/test/000077500000000000000000000000001301006202600166655ustar00rootroot00000000000000OTB-release-5.8/Examples/OBIA/test/CMakeLists.txt000066400000000000000000000027251301006202600214330ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/OBIA) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME trTeOBIAImageToLabelToImageTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/OBIAI2L2IOutput.tif ${TEMP}/OBIAI2L2IOutput.tif Execute $ ${INPUTDATA}/MSLabeledOutput.tif ${TEMP}/OBIAI2L2IOutput.tif ${TEMP}/OBIAI2L2IInPretty.png ${TEMP}/OBIAI2L2IOutPretty.png 1 1108 0 ) otb_add_test(NAME trTeOBIAShapeAttributeComputationTest COMMAND ${OTB_TEST_DRIVER} --compare-ascii ${EPSILON_3} ${BASELINE}/OBIAShapeAttribute.txt ${TEMP}/OBIAShapeAttribute.txt Execute $ ${INPUTDATA}/MSLabeledOutput.tif ${TEMP}/OBIAShapeAttribute.txt ) #if(OTBMathParser_LOADED) #otb_add_test(NAME trTeOBIARadiometricAttributesLabelMapFilterTest COMMAND ${OTB_TEST_DRIVER} #--compare-image ${NOTOL} #${BASELINE}/OBIARadiometricAttributes.png #${TEMP}/OBIARadiometricAttributes.png #Execute $ #${INPUTDATA}/qb_RoadExtract.tif #${TEMP}/OBIARadiometricAttributes.png #${TEMP}/qb_RoadExtract_Radiometry_pretty.png #STATS::Band1::Mean #0 #0.5 #16 #16 #50 #1.0 #) #endif() otb_add_test(NAME trTeLabelMapToVectorData COMMAND ${OTB_TEST_DRIVER} Execute $ ${INPUTDATA}/rcc8_mire1.png ${TEMP}/rcc8_mire2_vectorizer.shp ) OTB-release-5.8/Examples/Patented/000077500000000000000000000000001301006202600167405ustar00rootroot00000000000000OTB-release-5.8/Examples/Patented/CMakeLists.txt000066400000000000000000000013511301006202600215000ustar00rootroot00000000000000project(PatentedExamples) add_executable(EstimateAffineTransformationExample EstimateAffineTransformationExample.cxx) target_link_libraries(EstimateAffineTransformationExample ${OTB_LIBRARIES}) if (OTBSiftFast_LOADED) add_executable(SIFTDisparityMapEstimation SIFTDisparityMapEstimation.cxx) target_link_libraries(SIFTDisparityMapEstimation ${OTB_LIBRARIES}) add_executable(SIFTExample SIFTExample.cxx) target_link_libraries(SIFTExample ${OTB_LIBRARIES}) add_executable(SIFTDensityExample SIFTDensityExample.cxx) target_link_libraries(SIFTDensityExample ${OTB_LIBRARIES}) add_executable(SIFTFastExample SIFTFastExample.cxx) target_link_libraries(SIFTFastExample ${OTB_LIBRARIES}) endif() if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Patented/EstimateAffineTransformationExample.cxx000066400000000000000000000273151301006202600266230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png}, {QB_SuburbR10X13Y17.png} // OUTPUTS: {AffineTransformationOutput.png}, {AffineTransformationTxtOutput.txt} // 2 3 0 0 0.3 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example demonstrates the use of the // \doxygen{otb}{KeyPointSetsMatchingFilter} for transformation // estimation between 2 images. The idea here is to match SIFTs extracted from both the // fixed and the moving images. The use of SIFTs is demonstrated in // section \ref{sec:SIFTDetector}. The // \doxygen{otb}{LeastSquareAffineTransformEstimator} will be used // to generate a transformation field by using // mean square optimisation to estimate // an affine transform from the point set. // // The first step toward the use of these filters is to include the // appropriate header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbKeyPointSetsMatchingFilter.h" #include "otbImageToSIFTKeyPointSetFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "otbLeastSquareAffineTransformEstimator.h" #include "itkResampleImageFilter.h" int main(int argc, char* argv[]) { if (argc != 11) { std::cerr << "Usage: " << argv[0]; std::cerr << " fixedFileName movingFileName resamplingImageFileName transfofname octaves scales threshold ratio secondOrderThreshold useBackMatching" << std::endl; return EXIT_FAILURE; } const char * fixedfname = argv[1]; const char * movingfname = argv[2]; const char * outputImageFilename = argv[3]; const char * outputTransformationFilename = argv[4]; const unsigned int octaves = atoi(argv[5]); const unsigned int scales = atoi(argv[6]); float threshold = atof(argv[7]); float ratio = atof(argv[8]); const double secondOrderThreshold = atof(argv[9]); const bool useBackMatching = atoi(argv[10]); const unsigned int Dimension = 2; // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We choose to do // all the computations in floating point precision and rescale the results // between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double RealType; typedef unsigned char OutputPixelType; typedef otb::Image ImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The SIFTs obtained for the matching will be stored in vector // form inside a point set. So we need the following types: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter for computing the SIFTs has a type defined as follows: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageToSIFTKeyPointSetFilter ImageToSIFTKeyPointSetFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Although many choices for evaluating the distances during the // matching procedure exist, we choose here to use a simple // Euclidean distance. We can then define the type for the matching filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::KeyPointSetsMatchingFilter EuclideanDistanceMetricMatchingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following type is needed for dealing with the matched points. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef EuclideanDistanceMetricMatchingFilterType::LandmarkListType LandmarkListType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type for the image reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Two readers are instantiated : one for the fixed image, and one // for the moving image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer fixedReader = ReaderType::New(); ReaderType::Pointer movingReader = ReaderType::New(); fixedReader->SetFileName(fixedfname); movingReader->SetFileName(movingfname); fixedReader->UpdateOutputInformation(); movingReader->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will now instantiate the 2 SIFT filters and the filter used // for the matching of the points. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageToSIFTKeyPointSetFilterType::Pointer filter1 = ImageToSIFTKeyPointSetFilterType::New(); ImageToSIFTKeyPointSetFilterType::Pointer filter2 = ImageToSIFTKeyPointSetFilterType::New(); EuclideanDistanceMetricMatchingFilterType::Pointer euclideanMatcher = EuclideanDistanceMetricMatchingFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline and set the parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter1->SetInput(fixedReader->GetOutput()); filter2->SetInput(movingReader->GetOutput()); filter1->SetOctavesNumber(octaves); filter1->SetScalesNumber(scales); filter1->SetDoGThreshold(threshold); filter1->SetEdgeThreshold(ratio); filter2->SetOctavesNumber(octaves); filter2->SetScalesNumber(scales); filter2->SetDoGThreshold(threshold); filter2->SetEdgeThreshold(ratio); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We use a simple Euclidean distance to select // matched points. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet euclideanMatcher->SetInput1(filter1->GetOutput()); euclideanMatcher->SetInput2(filter2->GetOutput()); euclideanMatcher->SetDistanceThreshold(secondOrderThreshold); euclideanMatcher->SetUseBackMatching(useBackMatching); euclideanMatcher->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The matched points will be stored into a landmark list. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LandmarkListType::Pointer landmarkList; landmarkList = euclideanMatcher->GetOutput(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Apply Mean square algorithm // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Point MyPointType; typedef otb::LeastSquareAffineTransformEstimator EstimatorType; // instantiation of the estimator of the affine transformation EstimatorType::Pointer estimator = EstimatorType::New(); std::cout << "landmark list size " << landmarkList->Size() << std::endl; for (LandmarkListType::Iterator it = landmarkList->Begin(); it != landmarkList->End(); ++it) { estimator->AddTiePoints(it.Get()->GetPoint1(), it.Get()->GetPoint2()); } // Trigger computation estimator->Compute(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Resample the initial image with the transformation evaluated // // Software Guide : EndLatex // Software Guide : BeginLatex // // It is common, as the last step of a registration task, to use // the resulting transform to map the moving image into the fixed // image space. This is easily done with the // \doxygen{itk}{ResampleImageFilter}. First, a ResampleImageFilter // type is instantiated using the image types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ResampleImageFilter< ImageType, OutputImageType> ResampleFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A resampling filter is created and the moving image is connected as // its input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ResampleFilterType::Pointer resampler = ResampleFilterType::New(); resampler->SetInput(movingReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The Transform that is produced as output do not need to be inversed because // we apply here the resampling algorithm to the "moving" image // to produce the fixed image. // // Software Guide : EndLatex // Write the transformation to a file std::ofstream ofs; ofs.open(outputTransformationFilename); // Set floatfield to format properly ofs.setf(std::ios::fixed, std::ios::floatfield); ofs.precision(10); ofs << "Transformation" << std::endl; ofs << "Estimated affine matrix: " << std::endl; ofs << estimator->GetMatrix() << std::endl; ofs << "Estimated affine offset: " << std::endl; ofs << estimator->GetOffset() << std::endl; ofs << "RMS error: " << std::endl; ofs << estimator->GetRMSError() << std::endl; ofs << "Relative residual: " << std::endl; ofs << estimator->GetRelativeResidual() << std::endl; ofs.close(); // Software Guide : BeginCodeSnippet ImageType::Pointer fixedImage = fixedReader->GetOutput(); resampler->SetTransform(estimator->GetAffineTransform()); resampler->SetSize(fixedImage->GetLargestPossibleRegion().GetSize()); resampler->SetOutputOrigin(fixedImage->GetOrigin()); resampler->SetOutputSpacing(fixedImage->GetSpacing()); resampler->SetDefaultPixelValue(100); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Write resampled image to png // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(resampler->GetOutput()); writer->SetFileName(outputImageFilename); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Figure~\ref{fig:SIFTDME} shows the result of the resampled image using the // estimated transformation based on SIFT points // // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.40\textwidth]{QB_SuburbR10X13Y17.eps} // \includegraphics[width=0.40\textwidth]{AffineTransformationOutput.eps} // \itkcaption[Estimation of affine transformation using least square optimisation from SIFT points]{From left // to right and top to bottom: fixed input image, moving image, // resampled moving image.} // \label{fig:SIFTDME} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Patented/SIFTDensityExample.cxx000066400000000000000000000157431301006202600231170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // Software Guide : BeginCommandLineArgs // INPUTS: {suburb2.jpeg} // OUTPUTS: {SIFTDensityOutput.tif}, {PrettySIFTDensityOutput.png} // 3 3 7 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{otb}{KeyPointDensityImageFilter}. // This filter computes a local density of keypoints (SIFT or SURF, // for instance) on an image and can // be useful to detect man made objects or urban areas, for // instance. The filter has been implemented in a generic way, so that // the way the keypoints are detected can be chosen by the user. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbKeyPointDensityImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageToSIFTKeyPointSetFilter.h" int main(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const char * prettyfname = argv[3]; const unsigned int scales = atoi(argv[4]); const unsigned int octaves = atoi(argv[5]); const unsigned int radius = atoi(argv[6]); const unsigned int Dimension = 2; typedef float PixelType; // Software Guide : BeginLatex // // As usual, we start by defining the types for the images, the reader // and the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define now the type for the keypoint detection. The keypoints // will be stored in vector form (they may contain many descriptors) // into a point set. The filter for detecting the SIFT is templated // over the input image type and the output pointset type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter DetectorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now define the filter which will compute the SIFT // density. It will be templated over the input and output image // types and the SIFT detector. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::KeyPointDensityImageFilter FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can instantiate the reader and the writer as wella s the // filter and the detector. The detector needs to be instantiated in // order to set its parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); DetectorType::Pointer detector = DetectorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the file names for the input and the output images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(infname); writer->SetFileName(outfname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the parameters for the SIFT detector (the number of // octaves and the number of scales per octave). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet detector->SetOctavesNumber(octaves); detector->SetScalesNumber(scales); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we pass the detector to the filter and we set the radius for // the density estimation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetDetector(detector); filter->SetNeighborhoodRadius(radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We trigger the execution by calling th \code{Update()} method on // the writer, but before that we run the // \code{GenerateOutputInformation()} on the reader so the filter // gets the information about the image size (needed for the SIFT // computation). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->GenerateOutputInformation(); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:SIFTDENSITY_FILTER} shows the result of applying // the key point density filter to an image using the SIFT // detector. The main difference with respect to figure // \ref{fig:EDGEDENSITY_FILTER} is that for SIFTS, individual trees // contribute to the density. // \begin{figure} // \center // \includegraphics[width=0.25\textwidth]{suburb2.eps} // \includegraphics[width=0.25\textwidth]{PrettySIFTDensityOutput.eps} // \itkcaption[SIFT Density Filter]{Result of applying the // \doxygen{otb}{KeypointDensityImageFilter} to an image. From left // to right : // original image, SIF density.} // \label{fig:SIFTDENSITY_FILTER} // \end{figure} // // Software Guide : EndLatex /************* Image for printing **************/ typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(filter->GetOutput()); typedef otb::ImageFileWriter OutputWriterType; OutputWriterType::Pointer outwriter = OutputWriterType::New(); outwriter->SetFileName(prettyfname); outwriter->SetInput(rescaler->GetOutput()); outwriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Patented/SIFTDisparityMapEstimation.cxx000066400000000000000000000332421301006202600246210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png}, {ROISpot5Warped.png} // OUTPUTS: {SIFTdeformationFieldOutput.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example demonstrates the use of the // \doxygen{otb}{KeyPointSetsMatchingFilter} for disparity map // estimation. The idea here is to match SIFTs extracted from both the // fixed and the moving images. The use of SIFTs is demonstrated in // section \ref{sec:SIFTDetector}. The // \doxygen{itk}{DisplacementFieldSource} will be used // to generate a deformation field by using // interpolation on the deformation values from the point set. More // advanced methods for deformation field interpolation are also // available. // // The first step toward the use of these filters is to include the // appropriate header files. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbKeyPointSetsMatchingFilter.h" #include "otbSiftFastImageFilter.h" #include "itkLandmarkDisplacementFieldSource.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkPointSet.h" #include "otbMultiToMonoChannelExtractROI.h" int main(int argc, char* argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0]; std::cerr << "fixedFileName movingFileName fieldOutName" << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; // Software Guide : BeginLatex // // Then we must decide what pixel type to use for the image. We choose to do // all the computations in floating point precision and rescale the results // between 0 and 255 in order to export PNG images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double RealType; typedef unsigned char OutputPixelType; typedef otb::Image ImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The SIFTs obtained for the matching will be stored in vector // form inside a point set. So we need the following types: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter for computing the SIFTs has a type defined as follows: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SiftFastImageFilter ImageToSIFTKeyPointSetFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Although many choices for evaluating the distances during the // matching procedure exist, we choose here to use a simple // Euclidean distance. We can then define the type for the matching filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::KeyPointSetsMatchingFilter EuclideanDistanceMetricMatchingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The following types are needed for dealing with the matched points. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointType PointType; typedef std::pair MatchType; typedef std::vector MatchVectorType; typedef EuclideanDistanceMetricMatchingFilterType::LandmarkListType LandmarkListType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We define the type for the image reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Two readers are instantiated : one for the fixed image, and one // for the moving image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer fixedReader = ReaderType::New(); ReaderType::Pointer movingReader = ReaderType::New(); fixedReader->SetFileName(argv[1]); movingReader->SetFileName(argv[2]); fixedReader->UpdateOutputInformation(); movingReader->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will now instantiate the 2 SIFT filters and the filter used // for the matching of the points. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageToSIFTKeyPointSetFilterType::Pointer filter1 = ImageToSIFTKeyPointSetFilterType::New(); ImageToSIFTKeyPointSetFilterType::Pointer filter2 = ImageToSIFTKeyPointSetFilterType::New(); EuclideanDistanceMetricMatchingFilterType::Pointer euclideanMatcher = EuclideanDistanceMetricMatchingFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the pipeline and set the parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double secondOrderThreshold = 0.5; bool useBackMatching = 0; filter1->SetInput(0, fixedReader->GetOutput()); filter1->SetScalesNumber(3); filter2->SetInput(0, movingReader->GetOutput()); filter2->SetScalesNumber(3); filter1->SetNumberOfThreads(1); filter2->SetNumberOfThreads(1); euclideanMatcher->SetInput1(filter1->GetOutput()); euclideanMatcher->SetInput2(filter2->GetOutput()); euclideanMatcher->SetDistanceThreshold(secondOrderThreshold); euclideanMatcher->SetUseBackMatching(useBackMatching); euclideanMatcher->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The matched points will be stored into a landmark list. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LandmarkListType::Pointer landmarkList; landmarkList = euclideanMatcher->GetOutput(); // Software Guide : EndCodeSnippet MatchVectorType trueSecondOrder; for (LandmarkListType::Iterator it = landmarkList->Begin(); it != landmarkList->End(); ++it) { PointType point1 = it.Get()->GetPoint1(); PointType point2 = it.Get()->GetPoint2(); trueSecondOrder.push_back(MatchType(point1, point2)); } // Displaying the matches typedef itk::RescaleIntensityImageFilter PrintableFilterType; PrintableFilterType::Pointer printable1 = PrintableFilterType::New(); PrintableFilterType::Pointer printable2 = PrintableFilterType::New(); printable1->SetInput(fixedReader->GetOutput()); printable1->SetOutputMinimum(0); printable1->SetOutputMaximum(255); printable1->Update(); printable2->SetInput(movingReader->GetOutput()); printable2->SetOutputMinimum(0); printable2->SetOutputMaximum(255); printable2->Update(); typedef otb::Image, 2> RGBImageType; RGBImageType::Pointer rgbimage1 = RGBImageType::New(); rgbimage1->SetRegions(printable1->GetOutput()->GetLargestPossibleRegion()); rgbimage1->Allocate(); itk::ImageRegionIterator outIt1( rgbimage1, rgbimage1-> GetLargestPossibleRegion()); itk::ImageRegionIterator inIt1( printable1->GetOutput(), printable1->GetOutput()->GetLargestPossibleRegion()); outIt1.GoToBegin(); inIt1.GoToBegin(); while (!inIt1.IsAtEnd() && !outIt1.IsAtEnd()) { itk::RGBPixel pixel; pixel.SetRed(inIt1.Get()); pixel.SetGreen(inIt1.Get()); pixel.SetBlue(inIt1.Get()); outIt1.Set(pixel); ++inIt1; ++outIt1; } RGBImageType::Pointer rgbimage2 = RGBImageType::New(); rgbimage2->SetRegions(printable2->GetOutput()->GetLargestPossibleRegion()); rgbimage2->Allocate(); itk::ImageRegionIterator outIt2(rgbimage2, rgbimage2->GetLargestPossibleRegion()); itk::ImageRegionIterator inIt2(printable2->GetOutput(), printable2->GetOutput()->GetLargestPossibleRegion()); outIt2.GoToBegin(); inIt2.GoToBegin(); while (!inIt2.IsAtEnd() && !outIt2.IsAtEnd()) { itk::RGBPixel pixel; pixel.SetRed(inIt2.Get()); pixel.SetGreen(inIt2.Get()); pixel.SetBlue(inIt2.Get()); outIt2.Set(pixel); ++inIt2; ++outIt2; } // Software Guide : BeginLatex // // The landmarks are used for building a deformation field. The // deformation field is an image of vectors created by the // \doxygen{itk}{DisplacementFieldSource} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Vector VectorType; typedef otb::Image DisplacementFieldType; typedef itk::LandmarkDisplacementFieldSource DisplacementSourceType; DisplacementSourceType::Pointer deformer = DisplacementSourceType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The deformation field needs information about the extent and // spacing of the images on which it is defined. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::ConstPointer fixedImage = fixedReader->GetOutput(); deformer->SetOutputSpacing(fixedImage->GetSpacing()); deformer->SetOutputOrigin(fixedImage->GetOrigin()); deformer->SetOutputRegion(fixedImage->GetLargestPossibleRegion()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will need some intermediate variables in order to pass the // matched SIFTs to the deformation field source. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef DisplacementSourceType::LandmarkContainer LandmarkContainerType; typedef DisplacementSourceType::LandmarkPointType LandmarkPointType; LandmarkContainerType::Pointer sourceLandmarks = LandmarkContainerType::New(); LandmarkContainerType::Pointer targetLandmarks = LandmarkContainerType::New(); LandmarkPointType sourcePoint; LandmarkPointType targetPoint; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now iterate through the list of matched points and store // them in the intermediate landmark sets. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int pointId = 0; for (LandmarkListType::Iterator it = landmarkList->Begin(); it != landmarkList->End(); ++it) { PointType point1 = it.Get()->GetPoint1(); PointType point2 = it.Get()->GetPoint2(); sourcePoint[0] = point1[0]; sourcePoint[1] = point1[1]; targetPoint[0] = point2[0]; targetPoint[1] = point2[1]; sourceLandmarks->InsertElement(pointId, sourcePoint); targetLandmarks->InsertElement(pointId, targetPoint); ++pointId; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We pass the landmarks to the deformer and we run it. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet deformer->SetSourceLandmarks(sourceLandmarks.GetPointer()); deformer->SetTargetLandmarks(targetLandmarks.GetPointer()); deformer->UpdateLargestPossibleRegion(); DisplacementFieldType::ConstPointer deformationField = deformer->GetOutput(); deformer->Update(); // Software Guide : EndCodeSnippet ImageType::Pointer outdf = ImageType::New(); outdf->SetRegions(fixedReader->GetOutput()->GetLargestPossibleRegion()); outdf->Allocate(); itk::ImageRegionIterator outIt(outdf, outdf->GetLargestPossibleRegion()); itk::ImageRegionIterator inIt( deformer->GetOutput(), deformer->GetOutput()->GetLargestPossibleRegion()); outIt.GoToBegin(); inIt.GoToBegin(); while (!inIt.IsAtEnd() && !outIt.IsAtEnd()) { //std::cout << inIt.Get() << std::endl; outIt.Set(inIt.Get()[1]); ++inIt; ++outIt; } typedef itk::RescaleIntensityImageFilter RescaleType; RescaleType::Pointer rescaler = RescaleType::New(); rescaler->SetInput(outdf); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(rescaler->GetOutput()); writer->SetFileName(argv[3]); writer->Update(); // Software Guide : BeginLatex // // Figure~\ref{fig:SIFTDME} shows the result of applying the SIFT // disparity map estimation. Only the horizontal component of the // deformation is shown. // // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{ROISpot5.eps} // \includegraphics[width=0.40\textwidth]{ROISpot5Warped.eps} // \includegraphics[width=0.40\textwidth]{SIFTdeformationFieldOutput.eps} // \itkcaption[Displacement field from SIFT disparity map estimation]{From left // to right and top to bottom: fixed input image, moving image with a deformation, // estimated deformation field in the horizontal direction.} // \label{fig:SIFTDME} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Patented/SIFTExample.cxx000066400000000000000000000240051301006202600215460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {ROISpot5SIFT0.png} // "SIFT0.txt" 2 3 0 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {ROISpot5SIFT1.png} // "SIFT1.txt" 2 3 1 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {ROISpot5SIFT2.png} // "SIFT2.txt" 2 3 2 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {QB_SuburbSIFT5.png} // "SIFT2.txt" 2 3 5 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_SuburbRotated10.png} // OUTPUTS: {QB_SuburbSIFT5Rotated10.png} // "SIFT2.txt" 2 3 5 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{ImageToSIFTKeyPointSetFilter}. // The Scale-Invariant Feature Transform (or SIFT) is an algorithm in // computer vision to detect and describe local features in // images. The algorithm was published by David Lowe // \cite{LoweSIFT}. The detection and description of local image // features can help in object recognition and image registration. The // SIFT features are local and based on the appearance of the object // at particular interest points, and are invariant to image scale and // rotation. They are also robust to changes in illumination, noise, // occlusion and minor changes in viewpoint. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageToSIFTKeyPointSetFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" #include #include int main(int argc, char * argv[]) { if (argc != 8) { std::cerr << "Usage: " << argv[0]; std::cerr << " InputImage OutputImage OutputSIFTFile octaves scales threshold ratio" << std::endl; return 1; } const char * infname = argv[1]; const char * outfname = argv[3]; const char * outputImageFilename = argv[2]; const unsigned int octaves = atoi(argv[4]); const unsigned int scales = atoi(argv[5]); float threshold = atof(argv[6]); float ratio = atof(argv[7]); typedef float RealType; const unsigned int Dimension = 2; // Software Guide : BeginLatex // The \doxygen{otb}{ImageToSIFTKeyPointSetFilter} is templated over // its input image type and the output point set type. Therefore, we // start by defining the needed types. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter ImageToSIFTKeyPointSetFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Since the SIFT detector produces a point set, we will need // iterators for the coordinates of the points and the data associated // with them. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We can now instantiate the reader and the SIFT filter and plug the pipeline. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); ImageToSIFTKeyPointSetFilterType::Pointer filter = ImageToSIFTKeyPointSetFilterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The SIFT filter needs the following parameters: // \begin{itemize} // \item the number of octaves, that is, the number of levels of undersampling, // \item the number of scales (blurring) per octave, // \item the low contrast threshold to be applied to each point for the detection // on the difference of Gaussians image, // \item the threshold on the responses to consider a point as an edge. // \end{itemize} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->SetDoGThreshold(threshold); filter->SetEdgeThreshold(ratio); // Software Guide : EndCodeSnippet filter->Update(); // Software Guide : BeginLatex // Figure~\ref{fig:SIFT} shows the result of applying the SIFT // point detector to a small patch extracted from a Spot 5 image // using different threshold values. // \begin{figure} // \center // \includegraphics[width=0.22\textwidth]{ROISpot5.eps} // \includegraphics[width=0.22\textwidth]{ROISpot5SIFT0.eps} // \includegraphics[width=0.22\textwidth]{ROISpot5SIFT1.eps} // \includegraphics[width=0.22\textwidth]{ROISpot5SIFT2.eps} // \itkcaption[SIFT Application]{Result of applying the // \doxygen{otb}{ImageToSIFTKeyPointSetFilter} to a Spot 5 // image. Left to right: original image and SIFT with thresholds 0, // 1 and 2 respectively.} // \label{fig:SIFT} // \end{figure} // Figure~\ref{fig:SIFT2} shows the result of applying the SIFT // point detector to a small patch extracted from a Spot 5 image // using different threshold values. // \begin{figure} // \center // \includegraphics[width=0.30\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.30\textwidth]{QB_SuburbSIFT5.eps} // \includegraphics[width=0.30\textwidth]{QB_SuburbSIFT5Rotated10.eps} // \itkcaption[SIFT Application]{Result of applying the // \doxygen{otb}{ImageToSIFTKeyPointSetFilter} to a high resolution image // image. Left to right: original image and SIFT on the original // and a rotated image respectively.} // \label{fig:SIFT2} // \end{figure} // Software Guide : EndLatex // //Building the output image for visualization ImageType::OffsetType t = {{ 0, 1}}; ImageType::OffsetType b = {{ 0, -1}}; ImageType::OffsetType r = {{ 1, 0}}; ImageType::OffsetType l = {{-1, 0}}; typedef itk::RGBPixel RGBPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; OutputImageType::Pointer outputImage = OutputImageType::New(); OutputImageType::RegionType region; OutputImageType::SizeType outputSize; outputSize = reader->GetOutput()->GetLargestPossibleRegion().GetSize(); region.SetSize(outputSize); OutputImageType::IndexType indexStart; indexStart[0] = 0; indexStart[1] = 0; region.SetIndex(indexStart); outputImage->SetRegions(region); outputImage->Allocate(); itk::ImageRegionIterator iterOutput(outputImage, reader->GetOutput()-> GetLargestPossibleRegion()); for (iterOutput.GoToBegin(); !iterOutput.IsAtEnd(); ++iterOutput) { ImageType::IndexType index = iterOutput.GetIndex(); ImageType::PixelType grayPix = reader->GetOutput()->GetPixel(index); OutputImageType::PixelType rgbPixel; rgbPixel.SetRed(static_cast(grayPix)); rgbPixel.SetGreen(static_cast(grayPix)); rgbPixel.SetBlue(static_cast(grayPix)); iterOutput.Set(rgbPixel); } PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); ImageType::SpacingType spacing = reader->GetOutput()->GetSpacing(); ImageType::PointType origin = reader->GetOutput()->GetOrigin(); OutputImageType::SizeType size = outputImage->GetLargestPossibleRegion().GetSize(); while (pIt != filter->GetOutput()->GetPoints()->End()) { ImageType::IndexType index; index[0] = (unsigned int) (vcl_floor ((double) ((pIt.Value()[0] - origin[0]) / spacing[0] + 0.5))); index[1] = (unsigned int) (vcl_floor ((double) ((pIt.Value()[1] - origin[1]) / spacing[1] + 0.5))); OutputImageType::PixelType keyPixel; keyPixel.SetRed(0); keyPixel.SetGreen(255); keyPixel.SetBlue(0); if ( static_cast(index[1]) < static_cast(size[1]) && static_cast(index[0]) < static_cast(size[0])) { outputImage->SetPixel(index, keyPixel); if (static_cast(index[1]) < static_cast(size[1] - 1)) outputImage->SetPixel( index + t, keyPixel); if (index[1] > 0) outputImage->SetPixel(index + b, keyPixel); if (static_cast(index[0]) < static_cast(size[0] - 1)) outputImage->SetPixel( index + r, keyPixel); if (index[0] > 0) outputImage->SetPixel(index + l, keyPixel); } ++pIt; } std::ofstream outfile(outfname); outfile << filter; outfile.close(); WriterType::Pointer writer = WriterType::New(); writer->SetInput(outputImage); writer->SetFileName(outputImageFilename); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Patented/SIFTFastExample.cxx000066400000000000000000000267251301006202600223770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROISpot5.png} // OUTPUTS: {ROISpot5SIFTFast.png} // 3 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{otb}{SiftFastImageFilter}. // The Scale-Invariant Feature Transform (or SIFT) is an algorithm in // computer vision to detect and describe local features in // images. The algorithm was published by David Lowe // \cite{LoweSIFT}. The detection and description of local image // features can help in object recognition and image registration. The // SIFT features are local and based on the appearance of the object // at particular interest points, and are invariant to image scale and // rotation. They are also robust to changes in illumination, noise, // occlusion and minor changes in viewpoint. // // The first step required to use this filter is to include its header file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSiftFastImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" #include #include int main(int argc, char * argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0]; std::cerr << " InputImage OutputImage scales" << std::endl; return 1; } const char * infname = argv[1]; const char * outputImageFilename = argv[2]; const unsigned int scales = atoi(argv[3]); const unsigned int Dimension = 2; // Software Guide : BeginLatex // // We will start by defining the required types. We will work with a // scalar image of float pixels. We also define the corresponding // image reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float RealType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The SIFT descriptors will be stored in a point set containing the // vector of features. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The SIFT filter itself is templated over the input image and the // generated point set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SiftFastImageFilter ImageToFastSIFTKeyPointSetFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate the filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageToFastSIFTKeyPointSetFilterType::Pointer filter = ImageToFastSIFTKeyPointSetFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We plug the filter and set the number of scales for the SIFT // computation. We can afterwards run the processing with the // \code{Update()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); filter->SetScalesNumber(scales); filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the SIFT are computed, we may want to draw them on top of the // input image. In order to do this, we will create the following RGB // image and the corresponding writer: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; OutputImageType::Pointer outputImage = OutputImageType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the regions of the image by copying the information from the // input image and we allocate the memory for the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet outputImage->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now proceed to copy the input image into the output one // using region iterators. The input image is a grey level one. The // output image will be made of color crosses for each SIFT on top of // the grey level input image. So we start by copying the grey level // values on each of the 3 channels of the color image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet itk::ImageRegionIterator iterOutput( outputImage, outputImage-> GetLargestPossibleRegion()); itk::ImageRegionIterator iterInput(reader->GetOutput(), reader->GetOutput()-> GetLargestPossibleRegion()); for (iterOutput.GoToBegin(), iterInput.GoToBegin(); !iterOutput.IsAtEnd(); ++iterOutput, ++iterInput) { OutputImageType::PixelType rgbPixel; rgbPixel.SetRed(static_cast(iterInput.Get())); rgbPixel.SetGreen(static_cast(iterInput.Get())); rgbPixel.SetBlue(static_cast(iterInput.Get())); iterOutput.Set(rgbPixel); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We are now going to plot color crosses on the output image. We will // need to define offsets (top, bottom, left and right) with respect // to the SIFT position in order to draw the cross segments. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::OffsetType t = {{ 0, 1}}; ImageType::OffsetType b = {{ 0, -1}}; ImageType::OffsetType l = {{ 1, 0}}; ImageType::OffsetType r = {{-1, 0}}; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we are going to access the point set generated by the SIFT // filter. The points are stored into a points container that we are // going to walk through using an iterator. These are the types needed // for this task: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the iterator to the beginning of the point set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the information about image size and spacing before drawing // the crosses. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::SpacingType spacing = reader->GetOutput()->GetSpacing(); ImageType::PointType origin = reader->GetOutput()->GetOrigin(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we iterate through the SIFT set: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet while (pIt != filter->GetOutput()->GetPoints()->End()) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the pixel coordinates for each SIFT by using the // \code{Value()} method on the point set iterator. We use the // information about size and spacing in order to convert the physical // coordinates of the point into pixel coordinates. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType index; index[0] = static_cast(vcl_floor( static_cast( (pIt.Value()[0] - origin[0]) / spacing[0] + 0.5 ))); index[1] = static_cast(vcl_floor( static_cast( (pIt.Value()[1] - origin[1]) / spacing[1] + 0.5 ))); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create a green pixel. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OutputImageType::PixelType keyPixel; keyPixel.SetRed(0); keyPixel.SetGreen(255); keyPixel.SetBlue(0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We draw the crosses using the offsets and checking that we are // inside the image, since SIFTs on the image borders would cause an // out of bounds pixel access. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (outputImage->GetLargestPossibleRegion().IsInside(index)) { outputImage->SetPixel(index, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + t)) outputImage-> SetPixel(index + t, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + b)) outputImage-> SetPixel(index + b, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + l)) outputImage-> SetPixel(index + l, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + r)) outputImage-> SetPixel(index + r, keyPixel); } ++pIt; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we write the image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageFilename); writer->SetInput(outputImage); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Figure~\ref{fig:SIFTFast} shows the result of applying the SIFT // point detector to a small patch extracted from a Spot 5 image. // \begin{figure} // \center // \includegraphics[width=0.40\textwidth]{ROISpot5.eps} // \includegraphics[width=0.40\textwidth]{ROISpot5SIFTFast.eps} // \itkcaption[SIFT Application]{Result of applying the // \doxygen{otb}{SiftFastImageFilter} to a Spot 5 // image.} // \label{fig:SIFTFast} // \end{figure} // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Patented/test/000077500000000000000000000000001301006202600177175ustar00rootroot00000000000000OTB-release-5.8/Examples/Patented/test/CMakeLists.txt000066400000000000000000000025221301006202600224600ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Patented) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # -----EstimateAffineTransformationExampleTest--------- otb_add_test(NAME dmTeEstimateAffineTransformationExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/EstimateAffineTransformationOutput.png ${TEMP}/AffineTransformationOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${INPUTDATA}/QB_SuburbR10X13Y17.png ${TEMP}/AffineTransformationOutput.png ${TEMP}/AffineTransformationTxtOutput.txt 2 3 0 0 0.5 1 ) # -----SIFTDisparityMapEstimationTest--------- if(Module_OTBSiftFast) otb_add_test(NAME dmTeSIFTDisparityMapEstimationTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/SIFTdeformationFieldOutput.png ${TEMP}/SIFTdeformationFieldOutput.png Execute $ ${INPUTDATA}/ROISpot5.png ${INPUTDATA}/ROISpot5Warped.png ${TEMP}/SIFTdeformationFieldOutput.png ) otb_add_test(NAME feTeSIFTFastExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/ROISpot5SiftFast.png ${TEMP}/ROISpot5SiftFast.png Execute $ ${INPUTDATA}/ROISpot5.png ${TEMP}/ROISpot5SiftFast.png 3 ) endif() OTB-release-5.8/Examples/Projections/000077500000000000000000000000001301006202600174735ustar00rootroot00000000000000OTB-release-5.8/Examples/Projections/CMakeLists.txt000066400000000000000000000024461301006202600222410ustar00rootroot00000000000000project(ProjectionsExamples) add_executable(CoordinateToNameExample CoordinateToNameExample.cxx) target_link_libraries(CoordinateToNameExample ${OTB_LIBRARIES}) add_executable(EstimateRPCSensorModelExample EstimateRPCSensorModelExample.cxx) target_link_libraries(EstimateRPCSensorModelExample ${OTB_LIBRARIES}) add_executable(GeometriesProjectionExample GeometriesProjectionExample.cxx) target_link_libraries(GeometriesProjectionExample ${OTB_LIBRARIES}) add_executable(MapProjectionExample MapProjectionExample.cxx) target_link_libraries(MapProjectionExample ${OTB_LIBRARIES}) add_executable(OrthoRectificationExample OrthoRectificationExample.cxx) target_link_libraries(OrthoRectificationExample ${OTB_LIBRARIES}) add_executable(PlaceNameToLonLatExample PlaceNameToLonLatExample.cxx) target_link_libraries(PlaceNameToLonLatExample ${OTB_LIBRARIES}) add_executable(SensorModelExample SensorModelExample.cxx) target_link_libraries(SensorModelExample ${OTB_LIBRARIES}) add_executable(VectorDataExtractROIExample VectorDataExtractROIExample.cxx) target_link_libraries(VectorDataExtractROIExample ${OTB_LIBRARIES}) add_executable(VectorDataProjectionExample VectorDataProjectionExample.cxx) target_link_libraries(VectorDataProjectionExample ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Projections/CoordinateToNameExample.cxx000066400000000000000000000025401301006202600247270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCoordinateToName.h" int main(int argc, char* argv[]) { if (argc != 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * outFileName = argv[3]; otb::CoordinateToName::Pointer conv = otb::CoordinateToName::New(); conv->SetLon(atof(argv[1])); conv->SetLat(atof(argv[2])); conv->Evaluate(); std::string name = conv->GetPlaceName(); std::string country = conv->GetCountryName(); std::cout << "Nearby place: " << name << std::endl; std::cout << "Country: " << country << std::endl; std::ofstream file; file.open(outFileName); file << "Nearby place: " << name << std::endl; file << "Country: " << country << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/EstimateRPCSensorModelExample.cxx000066400000000000000000000133571301006202600260370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // \index{otb::GCPsToRPCSensorModelImageFilter} // \index{otb::GCPsToRPCSensorModelImageFilter!header} // // // The following example illustrates the application of estimation // of a sensor model to an image (limited to a RPC sensor model for now). // The \doxygen{otb}{GCPsToRPCSensorModelImageFilter} estimates a RPC // sensor model from a list of user defined GCPs. Internally, it uses // an ossimRpcSolver, which performs the estimation using the well // known least-square method. // Let's look at the minimal code required to use this // algorithm. First, the following header defining the // \doxygen{otb}{GCPsToRPCSensorModelImageFilter} class must be // included. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbGCPsToRPCSensorModelImageFilter.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc < 3) { std::cerr << "Usage: " << argv[0] << " infname outfname a1x a1y b1x b1y b1z ... aNx aNy bNx bNy bNz" << std::endl; return EXIT_FAILURE; } else if ((argc - 3) % 5 != 0) { std::cerr << "Inconsistent GCPs description!" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; // Software Guide : BeginLatex // // We declare the image type based on a particular pixel type and // dimension. In this case the \code{float} type is used for the pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::GCPsToRPCSensorModelImageFilter GCPsToSensorModelFilterType; typedef GCPsToSensorModelFilterType::Point2DType Point2DType; typedef GCPsToSensorModelFilterType::Point3DType Point3DType; // Software Guide : EndCodeSnippet // We instantiate reader and writer types ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Software Guide : BeginLatex // // The \doxygen{otb}{GCPsToRPCSensorModelImageFilter} is instantiated. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet GCPsToSensorModelFilterType::Pointer rpcEstimator = GCPsToSensorModelFilterType::New(); rpcEstimator->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We retrieve the command line parameters and put them in the // correct variables. Firstly, We determine the number of GCPs // set from the command line parameters and they are stored in: // \begin{itemize} // \item \doxygen{otb}{Point3DType} : Store the sensor point (3D ground point) // \item \doxygen{otb}{Point2DType} : Pixel associated in the image (2D physical coordinates) // Here we do not use DEM or MeanElevation. It is also possible to give a 2D // ground point and use the DEM or MeanElevation to get // the corresponding elevation. // \end{itemize} // Software Guide : EndLatex unsigned int nbGCPs = (argc - 3) / 5; std::cout << "Receiving " << nbGCPs << " from command line." << std::endl; // Software Guide : BeginCodeSnippet for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { Point2DType sensorPoint; sensorPoint[0] = atof(argv[3 + gcpId * 5]); sensorPoint[1] = atof(argv[4 + gcpId * 5]); Point3DType geoPoint; geoPoint[0] = atof(argv[5 + 5 * gcpId]); geoPoint[1] = atof(argv[6 + 5 * gcpId]); geoPoint[2] = atof(argv[7 + 5 * gcpId]); std::cout << "Adding GCP sensor: " << sensorPoint << " <-> geo: " << geoPoint << std::endl; rpcEstimator->AddGCP(sensorPoint, geoPoint); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Note that the \doxygen{otb}{GCPsToRPCSensorModelImageFilter} needs // at least 20 GCPs to estimate a proper RPC sensor model, // although no warning will be reported to the user if // the number of GCPs is lower than 20. // Actual estimation of the sensor model takes place in the // \code{GenerateOutputInformation()} method. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet rpcEstimator->GetOutput()->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The result of the RPC model estimation and the residual ground // error is then save in a txt file. Note that This filter does // not modify the image buffer, but only the metadata. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::ofstream ofs; ofs.open(outfname); // Set floatfield to format properly ofs.setf(std::ios::fixed, std::ios::floatfield); ofs.precision(10); ofs << (ImageType::Pointer) rpcEstimator->GetOutput() << std::endl; ofs << "Residual ground error: " << rpcEstimator->GetRMSGroundError() << std::endl; ofs.close(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The output image can be now given to the \doxygen{otb}{orthorectificationFilter}. // Note that this filter allows also to import GCPs from the image // metadata, if any. // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/GeometriesProjectionExample.cxx000066400000000000000000000131521301006202600256750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Instead of using \doxygen{otb}{VectorData} to apply projections as // explained in \ref{sec:VectorDataProjection}, we can also \emph{directly} work // on OGR data types thanks to \doxygen{otb}{GeometriesProjectionFilter}. // // This example demonstrates how to proceed with this alternative set of vector // data types. // // Software Guide : EndLatex #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" #include "otbImage.h" #include "otbImageFileReader.h" int main(int argc, char* argv[]) { if (argc < 4) { std::cerr << argv[0] << " \n"; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Declare the geometries type that you would like to use in your // application. Unlike \doxygen{otb}{VectorData}, \doxygen{otb}{GeometriesSet} // is a single type for any kind of geometries set (OGR data source, or OGR // layer). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // First, declare and instantiate the data source // \subdoxygen{otb}{ogr}{DataSource}. Then, encapsulate this data source into // a \doxygen{otb}{GeometriesSet}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( argv[1], otb::ogr::DataSource::Modes::Read); InputGeometriesType::Pointer in_set = InputGeometriesType::New(input); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need the image only to retrieve its projection information, // i.e. map projection or sensor model parameters. Hence, the image // pixels won't be read, only the header information using the // \code{UpdateOutputInformation()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{GeometriesProjectionFilter} will do the work of // converting the geometries coordinates. It is usually a good idea // to use it when you design applications reading or saving vector // data. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::GeometriesProjectionFilter GeometriesFilterType; GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Information concerning the original projection of the vector data // will be automatically retrieved from the metadata. Nothing else // is needed from you: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(in_set); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Information about the target projection is retrieved directly from // the image: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // necessary for sensors filter->SetOutputKeywordList(imageReader->GetOutput()->GetImageKeywordlist()); // necessary for sensors filter->SetOutputOrigin(imageReader->GetOutput()->GetOrigin()); // necessary for sensors filter->SetOutputSpacing(imageReader->GetOutput()->GetSpacing()); // ~ wkt filter->SetOutputProjectionRef( imageReader->GetOutput()->GetProjectionRef()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the result is saved into a new vector file. // Unlike other OTB filters, \doxygen{otb}{GeometriesProjectionFilter} expects // to be given a valid output geometries set where to store the result of its // processing -- otherwise the result will be an in-memory data source, and // not stored in a file nor a data base. // // Then, the processing is started by calling \code{Update()}. The actual // serialization of the results is guaranteed to be completed when the output // geometries set object goes out of scope, or when \code{SyncToDisk} is // called. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New( argv[3], otb::ogr::DataSource::Modes::Update_LayerCreateOnly); OutputGeometriesType::Pointer out_set = OutputGeometriesType::New(output); filter->SetOutput(out_set); filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once again, it is worth noting that none of this code is specific to the // vector data format. Whether you pass a shapefile, or a KML file, the // correct driver will be automatically instantiated. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/MapProjectionExample.cxx000066400000000000000000000162231301006202600243110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // OUTPUTS: {mapProjectionExample-output.txt} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Map projection is an important issue when working with satellite // images. In the orthorectification process, converting between // geographic and cartographic coordinates is a key step. In this // process, everything is integrated and you don't need to know the // details. // // However, sometimes, you need to go hands-on and find out the // nitty-gritty details. This example shows you how to play with map // projections in OTB and how to convert coordinates. In most cases, // the underlying work is done by OSSIM. // // First, we start by including the otbMapProjections header. In this // file, over 30 projections are defined and ready to use. It is easy // to add new one. // // The otbGenericMapProjection enables you to instantiate a map // projection from a WKT (Well Known Text) string, which is popular // with OGR for example. // // Software Guide : EndLatex #include #include // Software Guide : BeginCodeSnippet #include "otbMapProjections.h" #include "otbGenericMapProjection.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc < 2) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // We retrieve the command line parameters and put them in the // correct variables. The transforms are going to work with an // \doxygen{itk}{Point}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const char * outFileName = argv[1]; itk::Point point; point[0] = 1.4835345; point[1] = 43.55968261; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output of this program will be saved in a text file. We also want // to make sure that the precision of the digits will be enough. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::ofstream file; file.open(outFileName); file << std::setprecision(15); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate our first map projection. Here, it is a // UTM projection. We also need to provide the information about // the zone and the hemisphere for the projection. These are // specific to the UTM projection. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::UtmForwardProjection::Pointer utmProjection = otb::UtmForwardProjection::New(); utmProjection->SetZone(31); utmProjection->SetHemisphere('N'); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The TransformPoint() method returns the coordinates of the point in the // new projection. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet file << "Forward UTM projection: " << std::endl; file << point << " -> "; file << utmProjection->TransformPoint(point); file << std::endl << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We follow the same path for the Lambert93 projection: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::Lambert93ForwardProjection::Pointer lambertProjection = otb::Lambert93ForwardProjection::New(); file << "Forward Lambert93 projection: " << std::endl; file << point << " -> "; file << lambertProjection->TransformPoint(point); file << std::endl << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // If you followed carefully the previous examples, you've noticed // that the target projections have been directly coded, which means // that they can't be changed at run-time. What happens if you don't // know the target projection when you're writing the program? It // can depend on some input provided by the user (image, // shapefile). // // In this situation, you can use the // \doxygen{otb}{GenericMapProjection}. It will accept a string to // set the projection. This string should be in the WKT format. // // For example: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\"," "GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563," "AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0]," "AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]]," "UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]]," "AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST]," "AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"]," "PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3]," "PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000]," "PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // This string is then passed to the projection using the // \code{SetWkt()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::GenericMapProjection GenericMapProjection; GenericMapProjection::Pointer genericMapProjection = GenericMapProjection::New(); genericMapProjection->SetWkt(projectionRefWkt); file << "Forward generic projection: " << std::endl; file << point << " -> "; file << genericMapProjection->TransformPoint(point); file << std::endl << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And of course, we don't forget to close the file: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet file.close(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The final output of the program should be: // // \begin{verbatim} // Forward UTM projection: // [1.4835345, 43.55968261] -> [377522.448427013, 4824086.71129131] // // Forward Lambert93 projection: // [1.4835345, 43.55968261] -> [577437.889798954, 6274578.791561] // // Forward generic projection: // [1.4835345, 43.55968261] -> [377522.448427013, 4824086.71129131] // \end{verbatim} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/OrthoRectificationExample.cxx000066400000000000000000000143671301006202600253450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : BeginLatex // // This example demonstrates the use of the // \doxygen{otb}{OrthoRectificationFilter}. This filter is intended to // orthorectify images which are in a distributor format with the // appropriate meta-data describing the sensor model. In this example, // we will choose to use an UTM projection for the output image. // // The first step toward the use of these filters is to include the // proper header files: the one for the ortho-rectification filter and // the one defining the different projections available in OTB. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbOrthoRectificationFilter.h" #include "otbMapProjections.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 11) { std::cout << argv[0] << " (should be negative since origin is upper left)>" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // We will start by defining the types for the images, the image file // reader and the image file writer. The writer will be a // \doxygen{otb}{ImageFileWriter} which will allow us to set // the number of stream divisions we want to apply when writing the // output image, which can be very large. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now proceed to declare the type for the ortho-rectification // filter. The class \doxygen{otb}{OrthoRectificationFilter} is // templated over the input and the output image types as well as over // the cartographic projection. We define therefore the // type of the projection we want, which is an UTM projection for this case. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::UtmInverseProjection utmMapProjectionType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; OrthoRectifFilterType::Pointer orthoRectifFilter = OrthoRectifFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we need to // instantiate the map projection, set the {\em zone} and {\em hemisphere} // parameters and pass this projection to the orthorectification filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet utmMapProjectionType::Pointer utmMapProjection = utmMapProjectionType::New(); utmMapProjection->SetZone(atoi(argv[3])); utmMapProjection->SetHemisphere(*(argv[4])); orthoRectifFilter->SetMapProjection(utmMapProjection); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We then wire the input image to the orthorectification filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet orthoRectifFilter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Using the user-provided information, we define the output region // for the image generated by the orthorectification filter. // We also define the spacing of the deformation grid where actual // deformation values are estimated. Choosing a bigger deformation field // spacing will speed up computation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType start; start[0] = 0; start[1] = 0; orthoRectifFilter->SetOutputStartIndex(start); ImageType::SizeType size; size[0] = atoi(argv[7]); size[1] = atoi(argv[8]); orthoRectifFilter->SetOutputSize(size); ImageType::SpacingType spacing; spacing[0] = atof(argv[9]); spacing[1] = atof(argv[10]); orthoRectifFilter->SetOutputSpacing(spacing); ImageType::SpacingType gridSpacing; gridSpacing[0] = 2.*atof(argv[9]); gridSpacing[1] = 2.*atof(argv[10]); orthoRectifFilter->SetDisplacementFieldSpacing(gridSpacing); ImageType::PointType origin; origin[0] = strtod(argv[5], ITK_NULLPTR); origin[1] = strtod(argv[6], ITK_NULLPTR); orthoRectifFilter->SetOutputOrigin(origin); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now set plug the ortho-rectification filter to the writer // and set the number of tiles we want to split the output image in // for the writing step. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetInput(orthoRectifFilter->GetOutput()); writer->SetAutomaticTiledStreaming(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we trigger the pipeline execution by calling the // \code{Update()} method on the writer. Please note that the // ortho-rectification filter is derived from the // \doxygen{otb}{StreamingResampleImageFilter} in order to be able to // compute the input image regions which are needed to build the // output image. Since the resampler applies a geometric // transformation (scale, rotation, etc.), this region computation is // not trivial. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/PlaceNameToLonLatExample.cxx000066400000000000000000000043771301006202600250100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // This example will show how to retrieve the longitude and latitude from // a place using the name of the city or the address. For that, we will // use the \doxygen{otb}{PlaceNameToLonLat} class. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbPlaceNameToLonLat.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 2) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // You instantiate the class and pass the name you want to look for as a // std::string to the SetPlaceName method. // // The call to evaluate will trigger the retrival process. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::PlaceNameToLonLat::Pointer pn2LL = otb::PlaceNameToLonLat::New(); pn2LL->SetPlaceName(std::string(argv[1])); pn2LL->Evaluate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To get the data, you can simply call the GetLon and GetLat methods. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double lon = pn2LL->GetLon(); double lat = pn2LL->GetLat(); std::cout << "Latitude: " << lat << std::endl; std::cout << "Longitude: " << lon << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // If you tried with a string such as "Toulouse" -- a city where the // heart of OTB relies -- you should obtain something // like: // // \begin{verbatim} // Latitude: 43.6044 // Longitude: 1.44295 // \end{verbatim} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/SensorModelExample.cxx000066400000000000000000000365321301006202600237760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkExtractImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkLinearInterpolateImageFunction.h" // Software Guide : BeginLatex // // This example illustrates how to use the sensor model read from // image meta-data in order to perform ortho-rectification. This is a // very basic, step-by-step example, so you understand the different // components involved in the process. When performing real // ortho-rectifications, you can use the example presented in section // \ref{sec:OrthorectificationwithOTB}. // // We will start by including the header file for the inverse sensor model. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbInverseSensorModel.h" // Software Guide : EndCodeSnippet int main(int argc, char* argv[]) { if (argc != 8) { std::cout << argv[0] << " " << " " << " " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // As explained before, the first thing to do is to create the sensor // model in order to transform the ground coordinates in sensor // geometry coordinates. The geoetric model will automatically be // created by the image file reader. So we begin by declaring the // types for the input image and the image reader. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); ImageType::Pointer inputImage = reader->GetOutput(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We have just instantiated the reader and set the file name, but the // image data and meta-data has not yet been accessed by it. Since we // need the creation of the sensor model and all the image information // (size, spacing, etc.), but we do not want to read the pixel data -- // it could be huge -- we just ask the reader to generate the output // information needed. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->GenerateOutputInformation(); std::cout << "Original input imagine spacing: " << reader->GetOutput()->GetSpacing() << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now instantiate the sensor model -- an inverse one, since we // want to convert ground coordinates to sensor geometry. Note that // the choice of the specific model (SPOT5, Ikonos, etc.) is done by // the reader and we only need to instantiate a generic model. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::InverseSensorModel ModelType; ModelType::Pointer model = ModelType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The model is parameterized by passing to it the {\em keyword list} // containing the needed information. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet model->SetImageGeometry(reader->GetOutput()->GetImageKeywordlist()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since we can not be sure that the image we read actually has sensor // model information, we must check for the model validity. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (model->IsValidSensorModel() == false) { std::cerr << "Unable to create a model" << std::endl; return 1; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The types for the input and output coordinate points can be now // declared. The same is done for the index types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ModelType::OutputPointType inputPoint; typedef itk::Point PointType; PointType outputPoint; ImageType::IndexType currentIndex; ImageType::IndexType currentIndexBis; ImageType::IndexType pixelIndexBis; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will now create the output image over which we will iterate in // order to transform ground coordinates to sensor coordinates and get // the corresponding pixel values. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::Pointer outputImage = ImageType::New(); ImageType::PixelType pixelValue; ImageType::IndexType start; start[0] = 0; start[1] = 0; ImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The spacing in y direction is negative since origin is the upper left corner. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::SpacingType spacing; spacing[0] = 0.00001; spacing[1] = -0.00001; ImageType::PointType origin; origin[0] = strtod(argv[3], ITK_NULLPTR); //longitude origin[1] = strtod(argv[4], ITK_NULLPTR); //latitude ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); outputImage->SetOrigin(origin); outputImage->SetRegions(region); outputImage->SetSpacing(spacing); outputImage->Allocate(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will now instantiate an extractor filter in order to get input // regions by manual tiling. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ExtractImageFilter ExtractType; ExtractType::Pointer extract = ExtractType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the transformed coordinates in sensor geometry may not be // integer ones, we will need an interpolator to retrieve the pixel // values (note that this assumes that the input image was correctly // sampled by the acquisition system). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::LinearInterpolateImageFunction InterpolatorType; InterpolatorType::Pointer interpolator = InterpolatorType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We proceed now to create the image writer. We will also use a // writer plugged to the output of the extractor filter which will // write the temporary extracted regions. This is just for monitoring // the process. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image CharImageType; typedef otb::ImageFileWriter CharWriterType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer extractorWriter = WriterType::New(); CharWriterType::Pointer writer = CharWriterType::New(); extractorWriter->SetFileName("image_temp.jpeg"); extractorWriter->SetInput(extract->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the output pixel type and the input pixel type are different, // we will need to rescale the intensity values before writing them to // a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(10); rescaler->SetOutputMaximum(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The tricky part starts here. Note that this example is only // intended for educationnal purposes and that you do not need to proceed // as this. See the example in section // \ref{sec:OrthorectificationwithOTB} in order to code // ortho-rectification chains in a very simple way. // // You want to go on? OK. You have been warned. // // We will start by declaring an image region iterator and some // convenience variables. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageRegionIteratorWithIndex IteratorType; unsigned int NumberOfStreamDivisions; if (atoi(argv[7]) == 0) { NumberOfStreamDivisions = 10; } else { NumberOfStreamDivisions = atoi(argv[7]); } unsigned int count = 0; unsigned int It, j, k; int max_x, max_y, min_x, min_y; ImageType::IndexType iterationRegionStart; ImageType::SizeType iteratorRegionSize; ImageType::RegionType iteratorRegion; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The loop starts here. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (count = 0; count < NumberOfStreamDivisions; count++) { iteratorRegionSize[0] = atoi(argv[5]); if (count == NumberOfStreamDivisions - 1) { iteratorRegionSize[1] = (atoi(argv[6])) - ((int) (((atoi(argv[6])) / NumberOfStreamDivisions) + 0.5)) * (count); iterationRegionStart[1] = (atoi(argv[5])) - (iteratorRegionSize[1]); } else { iteratorRegionSize[1] = (int) (((atoi(argv[6])) / NumberOfStreamDivisions) + 0.5); iterationRegionStart[1] = count * iteratorRegionSize[1]; } iterationRegionStart[0] = 0; iteratorRegion.SetSize(iteratorRegionSize); iteratorRegion.SetIndex(iterationRegionStart); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create an array for storing the pixel indexes. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int pixelIndexArrayDimension = iteratorRegionSize[0] * iteratorRegionSize[1] * 2; int *pixelIndexArray = new int[pixelIndexArrayDimension]; int *currentIndexArray = new int[pixelIndexArrayDimension]; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We create an iterator for each piece of the image, and we iterate // over them. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet IteratorType outputIt(outputImage, iteratorRegion); It = 0; for (outputIt.GoToBegin(); !outputIt.IsAtEnd(); ++outputIt) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We get the current index. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet currentIndex = outputIt.GetIndex(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We transform the index to physical coordinates. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet outputImage->TransformIndexToPhysicalPoint(currentIndex, outputPoint); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We use the sensor model to get the pixel coordinates in the input // image and we transform this coordinates to an index. Then we store // the index in the array. Note that the \code{TransformPoint()} // method of the model has been overloaded so that it can be used with // a 3D point when the height of the ground point is known (DEM availability). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet inputPoint = model->TransformPoint(outputPoint); pixelIndexArray[It] = static_cast(inputPoint[0]); pixelIndexArray[It + 1] = static_cast(inputPoint[1]); currentIndexArray[It] = static_cast(currentIndex[0]); currentIndexArray[It + 1] = static_cast(currentIndex[1]); It = It + 2; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // At this point, we have stored all the indexes we need for the piece // of image we are processing. We can now compute the bounds of the // area in the input image we need to extract. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet max_x = pixelIndexArray[0]; min_x = pixelIndexArray[0]; max_y = pixelIndexArray[1]; min_y = pixelIndexArray[1]; for (j = 0; j < It; ++j) { if (j % 2 == 0 && pixelIndexArray[j] > max_x) { max_x = pixelIndexArray[j]; } if (j % 2 == 0 && pixelIndexArray[j] < min_x) { min_x = pixelIndexArray[j]; } if (j % 2 != 0 && pixelIndexArray[j] > max_y) { max_y = pixelIndexArray[j]; } if (j % 2 != 0 && pixelIndexArray[j] < min_y) { min_y = pixelIndexArray[j]; } } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We can now set the parameters for the extractor using a little bit // of margin in order to cope with irregular geometric distortions // which could be due to topography, for instance. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::RegionType extractRegion; ImageType::IndexType extractStart; if (min_x < 10 && min_y < 10) { extractStart[0] = 0; extractStart[1] = 0; } else { extractStart[0] = min_x - 10; extractStart[1] = min_y - 10; } ImageType::SizeType extractSize; extractSize[0] = (max_x - min_x) + 20; extractSize[1] = (max_y - min_y) + 20; extractRegion.SetSize(extractSize); extractRegion.SetIndex(extractStart); extract->SetExtractionRegion(extractRegion); extract->SetInput(reader->GetOutput()); extractorWriter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We give the input image to the interpolator and we loop through the // index array in order to get the corresponding pixel values. Note // that for every point we check whether it is inside the extracted region. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet interpolator->SetInputImage(extract->GetOutput()); for (k = 0; k < It / 2; ++k) { pixelIndexBis[0] = pixelIndexArray[2 * k]; pixelIndexBis[1] = pixelIndexArray[2 * k + 1]; currentIndexBis[0] = currentIndexArray[2 * k]; currentIndexBis[1] = currentIndexArray[2 * k + 1]; if (interpolator->IsInsideBuffer(pixelIndexBis)) { pixelValue = int(interpolator->EvaluateAtIndex(pixelIndexBis)); } else { pixelValue = 0; } outputImage->SetPixel(currentIndexBis, pixelValue); } delete[] pixelIndexArray; delete[] currentIndexArray; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // So we are done. We can now write the output image to a file after // performing the intensity rescaling. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetFileName(argv[2]); rescaler->SetInput(outputImage); writer->SetInput(rescaler->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/VectorDataExtractROIExample.cxx000066400000000000000000000113611301006202600254760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // There is some vector data sets widely available on the internet. These data // sets can be huge, covering an entire country, with hundreds of thousands // objects. // // Most of the time, you won't be interested in the whole area and would like // to focuss only on the area corresponding to your satellite image. // // The \doxygen{otb}{VectorDataExtractROI} is able to extract the area corresponding // to your satellite image, even if the image is still in sensor geometry (provided // the sensor model is supported by OTB). Let's see how we can do that. // // This example demonstrates the use of the // \doxygen{otb}{VectorDataExtractROI}. // // Software Guide : EndLatex #include "otbVectorData.h" #include "otbVectorDataExtractROI.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImageMetadataInterfaceFactory.h" #include "otbImage.h" #include "otbImageFileReader.h" int main(int argc, char* argv[]) { if (argc < 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * inVectorName = argv[1]; const char * inImageName = argv[2]; const char * outVectorName = argv[3]; typedef double Type; typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef otb::RemoteSensingRegion TypedRegion; typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(inImageName); imageReader->UpdateOutputInformation(); // Software Guide : BeginLatex // // After the usual declaration (you can check the source file for the details), // we can declare the \doxygen{otb}{VectorDataExtractROI}: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataExtractROI FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we need to specify the region to extract. This region is a bit special as // it contains also information related to its reference system (cartographic projection // or sensor model projection). We retrieve all these information from the image // we gave as an input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet TypedRegion region; TypedRegion::SizeType size; TypedRegion::IndexType index; size[0] = imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[0] * imageReader->GetOutput()->GetSpacing()[0]; size[1] = imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[1] * imageReader->GetOutput()->GetSpacing()[1]; index[0] = imageReader->GetOutput()->GetOrigin()[0] - 0.5 * imageReader->GetOutput()->GetSpacing()[0]; index[1] = imageReader->GetOutput()->GetOrigin()[1] - 0.5 * imageReader->GetOutput()->GetSpacing()[1]; region.SetSize(size); region.SetOrigin(index); otb::ImageMetadataInterfaceBase::Pointer imageMetadataInterface = otb::ImageMetadataInterfaceFactory::CreateIMI( imageReader->GetOutput()->GetMetaDataDictionary()); region.SetRegionProjection( imageMetadataInterface->GetProjectionRef()); region.SetKeywordList(imageReader->GetOutput()->GetImageKeywordlist()); filter->SetRegion(region); // Software Guide : EndCodeSnippet VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); VectorDataWriterType::Pointer writer = VectorDataWriterType::New(); reader->SetFileName(inVectorName); writer->SetFileName(outVectorName); // Software Guide : BeginLatex // // And finally, we can plug the filter in the pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/VectorDataProjectionExample.cxx000066400000000000000000000127431301006202600256330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Let's assume that you have a KML file (hence in geographical coordinates) // that you would like to superpose to some image with a specific map projection. // Of course, you could use the handy ogr2ogr tool to do that, but it won't // integrate so seamlessly into your OTB application. // // You can also suppose that the image on which you want to superpose // the data is not in a specific map projection but a raw image from a // particular sensor. Thanks to OTB, the same code below will be able // to do the appropriate conversion. // // This example demonstrates the use of the // \doxygen{otb}{VectorDataProjectionFilter}. // // Software Guide : EndLatex #include "otbVectorDataProjectionFilter.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImage.h" #include "otbImageFileReader.h" int main(int argc, char* argv[]) { if (argc < 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Declare the vector data type that you would like to use in your // application. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorData InputVectorDataType; typedef otb::VectorData OutputVectorDataType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Declare and instantiate the vector data reader: // \doxygen{otb}{VectorDataFileReader}. The call to the // \code{UpdateOutputInformation()} method fill up the header information. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need the image only to retrieve its projection information, // i.e. map projection or sensor model parameters. Hence, the image // pixels won't be read, only the header information using the // \code{UpdateOutputInformation()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{VectorDataProjectionFilter} will do the work of // converting the vector data coordinates. It is usually a good idea // to use it when you design applications reading or saving vector // data. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataProjectionFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Information concerning the original projection of the vector data // will be automatically retrieved from the metadata. Nothing else // is needed from you: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet vectorDataProjection->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Information about the target projection is retrieved directly from // the image: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet vectorDataProjection->SetOutputKeywordList( imageReader->GetOutput()->GetImageKeywordlist()); vectorDataProjection->SetOutputOrigin( imageReader->GetOutput()->GetOrigin()); vectorDataProjection->SetOutputSpacing( imageReader->GetOutput()->GetSpacing()); vectorDataProjection->SetOutputProjectionRef( imageReader->GetOutput()->GetProjectionRef()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the result is saved into a new vector file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::VectorDataFileWriter VectorDataFileWriterType; VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is worth noting that none of this code is specific to the // vector data format. Whether you pass a shapefile, or a KML file, // the correct driver will be automatically instantiated. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Projections/test/000077500000000000000000000000001301006202600204525ustar00rootroot00000000000000OTB-release-5.8/Examples/Projections/test/CMakeLists.txt000066400000000000000000000074501301006202600232200ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Projections) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME prTeOrthoRectificationExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/panOrthoToul.tif ${TEMP}/panOrthoToul.tif Execute $ LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/panOrthoToul.tif 31 N 375000 4828100 500 500 0.6 -0.6 ) otb_add_test(NAME prTeOrthoRectificationExampleXSTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/xsOrthoToul.tif ${TEMP}/xsOrthoToul.tif Execute $ LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TEMP}/xsOrthoToul.tif 31 N 375000 4828100 500 500 0.6 -0.6 ) otb_add_test(NAME prTeMapProjectionExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-ascii ${EPSILON_7} ${BASELINE}/mapProjectionExample.txt ${TEMP}/mapProjectionExample.txt Execute $ ${TEMP}/mapProjectionExample.txt ) otb_add_test(NAME prTeVectorDataProjectionExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-ogr ${NOTOL} ${BASELINE}/vectorDataProjectionExample.shp ${TEMP}/vectorDataProjectionExample.shp Execute $ ${OTB_DATA_ROOT}/Input/Capitole-Shadows.kml LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/vectorDataProjectionExample.shp ) otb_add_test(NAME prTeGeometriesProjectionTest COMMAND ${OTB_TEST_DRIVER} --compare-ogr ${NOTOL} ${BASELINE}/geometriesProjectionExample.shp ${TEMP}/geometriesProjectionExample.shp Execute $ ${OTB_DATA_ROOT}/Input/Capitole-Shadows.shp LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/geometriesProjectionExample.shp ) #TODO change the example by using a SPOT4 roamnia otb_add_test(NAME prTeEstimateRPCSensorModelExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-ascii ${EPSILON_4} ${BASELINE}/otbGCPsToRPCSensorModelImageFilterWithoutDEMOutput.txt ${TEMP}/otbGCPsToRPCSensorModelImageFilterWithoutDEMOutput.txt --ignore-lines-with 6 PipelineMTime ImportImageContaine Source: Image Time: Pointer: Execute $ LARGEINPUT{SPOT4/RIO_DE_JANEIRO/IMAG_01.DAT} ${TEMP}/otbGCPsToRPCSensorModelImageFilterWithoutDEMOutput.txt 1199 1259 -22.76847 -43.168043 0. 1497 727 -22.688931 -43.066686 0. 699 1146 -22.7254 -43.288651 0. 1379 2457 -22.986073 -43.193502 0. 2592 1846 -22.932684 -42.854215 0. 1430 1797 -22.872988 -43.136813 0. 587 2654 -22.983847 -43.393297 0. 2398 2422 -23.025664 -42.928778 0. 1436 2946 -23.074483 -43.192431 0. 963 2915 -23.047382 -43.310011 0. 1081 1024 -22.721919 -43.18523 0. 1395 1213 -22.769191 -43.116752 0. 1781 2202 -22.959556 -43.069911 0. 2803 1942 -22.958868 -42.808235 0. 980 2734 -22.99534 -43.309672 0. 713 2754 -23.007862 -43.365307 0. 72 2955 -23.012153 -43.541331 0. 2884 1898 -22.954691 -42.786188 0. 2539 47 -22.616041 -42.777877 0. 577 183 -22.551654 -43.271813 0. ) otb_add_test(NAME prTePlaceNameToLonLatExampleTest COMMAND ${OTB_TEST_DRIVER} Execute $ Toulouse ) otb_add_test(NAME prTeCoordinateToNameExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-ascii ${NOTOL} ${BASELINE}/CoordinateToNameExample.txt ${TEMP}/CoordinateToNameExample.txt Execute $ 103.78 1.29 ${TEMP}/CoordinateToNameExample.txt ) OTB-release-5.8/Examples/README.txt000066400000000000000000000017221301006202600166740ustar00rootroot00000000000000OTB Examples Directory ---------------------- This directory contains simple, companion examples to the ORFEO Toolbox (OTB). These examples are designed to demonstrate features of the system; they are not meant to be significant applications of the software. Specifically, the purpose of these examples is as follows: * Provide simple, minimalist examples of important features of OTB and how to use them. The examples have minimal dependencies on outside packages; and if they do, there should be CMake flags to turn them off. * Provide a consistent set of examples that will work in conjunctions with the OTB Software Guide. * Provide a consistent set of examples that will work with OTB tutorials and courses. * Make sure that the code is well documented, of consistent style, and always up-to-date with the current OTB code. To learn the software from these examples, you may wish to refer to the "ORFEO Toolbox Software Guide". OTB-release-5.8/Examples/Radiometry/000077500000000000000000000000001301006202600173135ustar00rootroot00000000000000OTB-release-5.8/Examples/Radiometry/ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000256521301006202600321100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {VegetationIndex.hd} // OUTPUTS: {ARVIMultiChannelRAndBAndNIRVegetationIndex.tif} , {pretty_VegetationIndex.png} , {pretty_ARVIMultiChannelRAndBAndNIRVegetationIndex.png} // 1 3 2 0.6 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{otb::MultiChannelRAndBAndNIRIndexImageFilter} // \index{otb::MultiChannelRAndBAndNIRIndexImageFilter!header} // \index{otb::VegetationIndices} // \index{otb::VegetationIndices!header} // // // The following example illustrates the use of the // \doxygen{otb}{MultiChannelRAndBAndNIRIndexImageFilter} with the // use of the Atmospherically Resistant Vegetation Index (ARVI) \subdoxygen{otb}{Functor}{ARVI}. ARVI // is an improved version of the NDVI that is more robust to the // atmospheric effect. In addition to the red and NIR channels (used // in the NDVI), the ARVI takes advantage of the presence of the blue // channel to accomplish a self-correction process for the atmospheric // effect on the red channel. For this, it uses the difference in the // radiance between the blue and the red channels to correct the // radiance in the red channel. Let's define $\rho_{NIR}^{*}$, // $\rho_{r}^{*}$, $\rho_{b}^{*}$ the normalized radiances (that is to // say the radiance normalized to reflectance units) of red, blue and // NIR channels respectively. $\rho_{rb}^{*}$ is defined as // // \begin{equation} // \rho_{rb}^{*} = \rho_{r}^{*} - \gamma*(\rho_{b}^{*} - \rho_{r}^{*}) // \end{equation} // // The ARVI expression is // // \begin{equation} // \mathbf{ARVI} = \frac{\rho_{NIR}^{*}-\rho_{rb}^{*}}{\rho_{NIR}^{*}+\rho_{rb}^{*}} // \end{equation} // // // This formula can be simplified with : // // \begin{equation} // \mathbf{ARVI} = \frac{ L_{NIR}-L_{rb} }{ L_{NIR}+L_{rb} } // \end{equation} // // For more details, refer to Kaufman and Tanre' work \cite{ARVI}. // // \relatedClasses // \begin{itemize} // \item \subdoxygen{otb}{Functor}{TSARVI} // \item \subdoxygen{otb}{Functor}{EVI} // \end{itemize} // With the \doxygen{otb}{MultiChannelRAndBAndNIRIndexImageFilter} class the // input has to be a multi channel image and the user has to specify index channel // of the red, blue and NIR channel. // // Let's look at the minimal code required to use this algorithm. First, the following header // defining the \doxygen{otb}{MultiChannelRAndBAndNIRIndexImageFilter} // class must be included. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMultiChannelRAndBAndNIRIndexImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbMultiChannelExtractROI.h" #include "itkThresholdImageFilter.h" int main(int argc, char *argv[]) { if (argc < 8) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage , outputImage , prettyInput , prettyOutput , redChannel , blueChannel , nirChannel , gama" << std::endl; return 1; } // Software Guide : BeginLatex // // The image types are now defined using pixel types and // dimension. The input image is defined as an \doxygen{otb}{VectorImage}, // the output is a \doxygen{otb}{Image}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double InputPixelType; typedef float OutputPixelType; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // We instantiate reader and writer types typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : BeginLatex // // The ARVI (Atmospherically Resistant Vegetation Index) is // instantiated using the image pixel types as template parameters. // Note that we also can use other functors which operate with the // Red, Blue and Nir channels such as EVI, ARVI and TSARVI. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Functor::ARVI FunctorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The // \doxygen{otb}{MultiChannelRAndBAndNIRIndexImageFilter} // type is defined using the image types and the ARVI functor as // template parameters. We then instantiate the filter itself. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MultiChannelRAndBAndNIRIndexImageFilter MultiChannelRAndBAndNIRIndexImageFilterType; MultiChannelRAndBAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndBAndNIRIndexImageFilterType::New(); // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : BeginLatex // // Now the input image is set and a name is given to the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The three used index bands (red, blue and NIR) are declared. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetRedIndex(::atoi(argv[5])); filter->SetBlueIndex(::atoi(argv[6])); filter->SetNIRIndex(::atoi(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The $\gamma$ parameter is set. The // \doxygen{otb}{MultiChannelRAndBAndNIRIndexImageFilter} // class sets the default value of $\gamma$ to $0.5$. This parameter // is used to reduce the atmospheric effect on a global scale. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->GetFunctor().SetGamma(::atof(argv[8])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter input is linked to the reader output and // the filter output is linked to the writer input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is recommended to place update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } // Pretty image creation for the printing typedef otb::Image OutputPrettyImageType; typedef otb::VectorImage OutputVectorPrettyImageType; typedef otb::ImageFileWriter WriterVectorPrettyType; typedef otb::ImageFileWriter WriterPrettyType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::VectorRescaleIntensityImageFilter VectorRescalerType; typedef otb::MultiChannelExtractROI ChannelExtractorType; VectorRescalerType::Pointer vectRescaler = VectorRescalerType::New(); ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); WriterVectorPrettyType::Pointer vectPrettyWriter = WriterVectorPrettyType::New(); OutputVectorPrettyImageType::PixelType minimum, maximum; minimum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); maximum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); minimum.Fill(0); maximum.Fill(255); vectRescaler->SetOutputMinimum(minimum); vectRescaler->SetOutputMaximum(maximum); vectRescaler->SetClampThreshold(0.01); vectRescaler->SetInput(reader->GetOutput()); selecter->SetInput(vectRescaler->GetOutput()); selecter->SetChannel(1); selecter->SetChannel(2); selecter->SetChannel(3); vectPrettyWriter->SetFileName(argv[3]); vectPrettyWriter->SetInput(selecter->GetOutput()); typedef itk::ThresholdImageFilter ThresholderType; ThresholderType::Pointer thresholder = ThresholderType::New(); thresholder->SetInput(filter->GetOutput()); thresholder->SetOutsideValue(1.0); thresholder->ThresholdOutside(0.0, 1.0); thresholder->Update(); RescalerType::Pointer rescaler = RescalerType::New(); WriterPrettyType::Pointer prettyWriter = WriterPrettyType::New(); rescaler->SetInput(thresholder->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); prettyWriter->SetFileName(argv[4]); prettyWriter->SetInput(rescaler->GetOutput()); try { prettyWriter->Update(); vectPrettyWriter->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; // Software Guide : BeginLatex // // Let's now run this example using as input the image // \code{IndexVegetation.hd} (image kindly and free of charge given // by SISA and CNES) and $\gamma$=0.6 provided in the // directory \code{Examples/Data}. // // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{pretty_VegetationIndex.eps} // \includegraphics[width=0.24\textwidth]{pretty_ARVIMultiChannelRAndBAndNIRVegetationIndex.eps} // \itkcaption[ARVI Example]{ARVI result on the right with the left image in input.} // \label{fig:ARVIMultiChannelRAndBAndNIRIndexImageFilter} // \end{figure} // // Software Guide : EndLatex } OTB-release-5.8/Examples/Radiometry/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000241371301006202600317700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {verySmallFSATSW.tif} // OUTPUTS: {AVIMultiChannelRAndGAndNIRVegetationIndex.tif} , {pretty_FSATSW.png} , {pretty_AVIMultiChannelRAndGAndNIRVegetationIndex.png} // 3 2 4 660 560 830 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{otb::MultiChannelRAndGAndNIRIndexImageFilter} // \index{otb::MultiChannelRAndGAndNIRIndexImageFilter!header} // \index{otb::VegetationIndex} // \index{otb::VegetationIndex!header} // // // The following example illustrates the use of the // otb::MultiChannelRAndGAndNIR VegetationIndexImageFilter with the // use of the Angular Vegetation Index (AVI). // The equation for the Angular Vegetation Index involves the gren, red // and near infra-red bands. $\lambda_1$, $\lambda_2$ and $\lambda_3$ are the mid-band // wavelengths for the green, red and NIR bands and $\tan^{-1}$ is the arctangent function. // // The AVI expression is // // \begin{equation} // \mathbf{A_1} = \frac{\lambda_3-\lambda_2}{\lambda_2} // \end{equation} // \begin{equation} // \mathbf{A_2} = \frac{\lambda_2-\lambda_1}{\lambda_2} // \end{equation} // // \begin{equation} // \mathbf{AVI} = \tan^{-1}\left({\frac{A_1}{NIR-R}}\right) + \tan^{-1}\left({\frac{A_2}{G-R}}\right) // \end{equation} // // For more details, refer to Plummer work \cite{AVI}. // // With the // \doxygen{otb}{MultiChannelRAndGAndNIRIndexImageFilter} // class the input has to be a multi channel image and the user has to // specify the channel index of the red, green and NIR channel. // // Let's look at the minimal code required to use this // algorithm. First, the following header defining the // \doxygen{otb}{MultiChannelRAndGAndNIRIndexImageFilter} // class must be included. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMultiChannelRAndGAndNIRIndexImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbMultiChannelExtractROI.h" #include "itkThresholdImageFilter.h" int main(int argc, char *argv[]) { if (argc < 11) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage , outputImage , prettyInput , prettyOutput , redChannel , greenChannel , nirChannel ,"; std::cerr << " lambdaR, lambdaG, lambdaNIR " << std::endl; return 1; } // Software Guide : BeginLatex // // The image types are now defined using pixel types and // dimension. The input image is defined as an \doxygen{otb}{VectorImage}, // the output is a \doxygen{otb}{Image}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double InputPixelType; typedef float OutputPixelType; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // We instantiate reader and writer types typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : BeginLatex // // The AVI (Angular Vegetation Index) is // instantiated using the image pixel types as template parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Functor::AVI FunctorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The // \doxygen{otb}{MultiChannelRAndGAndNIRIndexImageFilter} // type is defined using the image types and the AVI functor as // template parameters. We then instantiate the filter itself. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MultiChannelRAndGAndNIRIndexImageFilter MultiChannelRAndGAndNIRIndexImageFilterType; MultiChannelRAndGAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndGAndNIRIndexImageFilterType::New(); // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : BeginLatex // // Now the input image is set and a name is given to the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The three used index bands (red, green and NIR) are declared. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetRedIndex(::atoi(argv[5])); filter->SetGreenIndex(::atoi(argv[6])); filter->SetNIRIndex(::atoi(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The $\lambda$ R, G and NIR parameters are set. The // \doxygen{otb}{MultiChannelRAndGAndNIRIndexImageFilter} // class sets the default values of $\lambda$ to $660$, $560$ and // $830$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->GetFunctor().SetLambdaR(::atof(argv[8])); filter->GetFunctor().SetLambdaG(::atof(argv[9])); filter->GetFunctor().SetLambdaNir(::atof(argv[10])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter input is linked to the reader output and // the filter output is linked to the writer input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is recommended to place update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } // Pretty image creation for the printing typedef otb::Image OutputPrettyImageType; typedef otb::VectorImage OutputVectorPrettyImageType; typedef otb::ImageFileWriter WriterVectorPrettyType; typedef otb::ImageFileWriter WriterPrettyType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::VectorRescaleIntensityImageFilter VectorRescalerType; typedef otb::MultiChannelExtractROI ChannelExtractorType; VectorRescalerType::Pointer vectRescaler = VectorRescalerType::New(); ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); WriterVectorPrettyType::Pointer vectPrettyWriter = WriterVectorPrettyType::New(); OutputVectorPrettyImageType::PixelType minimum, maximum; minimum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); maximum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); minimum.Fill(0); maximum.Fill(255); vectRescaler->SetOutputMinimum(minimum); vectRescaler->SetOutputMaximum(maximum); // vectRescaler->SetClampThreshold(1); vectRescaler->SetInput(reader->GetOutput()); selecter->SetInput(vectRescaler->GetOutput()); selecter->SetChannel(3); selecter->SetChannel(2); selecter->SetChannel(1); vectPrettyWriter->SetFileName(argv[3]); vectPrettyWriter->SetInput(selecter->GetOutput()); typedef itk::ThresholdImageFilter ThresholderType; ThresholderType::Pointer thresholder = ThresholderType::New(); thresholder->SetInput(filter->GetOutput()); thresholder->SetOutsideValue(1.0); thresholder->ThresholdOutside(-1.0, 0.05); thresholder->Update(); RescalerType::Pointer rescaler = RescalerType::New(); WriterPrettyType::Pointer prettyWriter = WriterPrettyType::New(); rescaler->SetInput(thresholder->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); prettyWriter->SetFileName(argv[4]); prettyWriter->SetInput(rescaler->GetOutput()); try { prettyWriter->Update(); vectPrettyWriter->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; // Software Guide : BeginLatex // // Let's now run this example using as input the image // \code{verySmallFSATSW.tif} provided in the // directory \code{Examples/Data}. // // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{pretty_FSATSW.eps} // \includegraphics[width=0.24\textwidth]{pretty_AVIMultiChannelRAndGAndNIRVegetationIndex.eps} // \itkcaption[AVI Example]{AVI result on the right with the left image in input.} // \label{fig:AVIMultiChannelRAndGAndNIRIndexImageFilter} // \end{figure} // // Software Guide : EndLatex } OTB-release-5.8/Examples/Radiometry/AtmosphericCorrectionSequencement.cxx000066400000000000000000000644221301006202600267320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {Romania_Extract.tif} // OUTPUTS: {AtmosphericCorrectionSequencement.tif} // ${OTB_DATA_ROOT}/Examples/atmosphericCorrectionSequencement_alpha_beta.txt ${OTB_DATA_ROOT}/Examples/atmosphericCorrectionSequencement_solar_illumination.txt ${OTB_DATA_ROOT}/Examples/atmosphericCorrectionSequencement_wavelength_spectral_bands_spot4_1.txt 27.3 4 12 152.7 2.5 -77.0 1013. 2.48134 0.34400 1 0.199854 2 0.020 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{otb::MultiChannelRAndBAndNIRVegetationIndexImageFilter} // \index{otb::MultiChannelRAndBAndNIRVegetationIndexImageFilter!header} // \index{otb::VegetationIndex} // \index{otb::VegetationIndex!header} // // // The following example illustrates the application of atmospheric corrections to // an optical multispectral image similar to Pleiades. // These corrections are made in four steps : // \begin{itemize} // \item digital number to luminance correction; // \item luminance to refletance image conversion; // \item atmospheric correction for TOA (top of atmosphere) to TOC (top of canopy) // reflectance estimation; // \item correction of the adjacency effects taking into account the neighborhood contribution. // \end{itemize} // // The manipulation of each class used for the different steps and the // link with the 6S radiometry library will be explained. In particular, // the API modifications that have been made in version 4.2 will be // detailed. There was several reasons behind these modifications : // \begin{itemize} // \item fix design issues in the framework that were causing trouble // when setting the atmospheric parameters // \item allow the computation of the radiative terms by other libraries // than 6S (such as SMAC method). // \item allow the users of the OpticalCalibration application to set // and override each correction parameter. // \end{itemize} // // Let's look at the minimal code required to use this // algorithm. First, the following header defining the // \doxygen{otb}{AtmosphericCorrectionSequencement} class must be // included. For the numerical to luminance image, luminance to // refletance image, and reflectance to atmospheric correction image // corrections and the neighborhood correction, four header files are // required. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageToLuminanceImageFilter.h" #include "otbLuminanceToReflectanceImageFilter.h" #include "otbReflectanceToSurfaceReflectanceImageFilter.h" #include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // In version 4.2, the class \code{SurfaceAdjacencyEffect6SCorrectionSchemeFilter} // has been renamed into \doxygen{otb}{SurfaceAdjacencyEffectCorrectionSchemeFilter}, // but it still does the same thing. // // This chain uses the 6S radiative // transfer code to compute radiative terms (for instance upward and // downward transmittance). The inputs needed are separated into // two categories : // \begin{itemize} // \item The atmospheric correction parameters : physical parameters of the // atmosphere when the image was taken (for instance : atmospheric pressure, // water vapour amount, aerosol data, ...). They are stored in the class // \footnote{Before version 4.2, this class was storing all correction // parameters} \doxygen{otb}{AtmosphericCorrectionParameters}. // \item The acquisition correction parameters : sensor related information // about the way the image was taken, usually available with the image // metadata (for instance : solar angles, spectral // sensitivity, ...). They are stored in the class // \doxygen{otb}{ImageMetadataCorrectionParameters}. // \end{itemize} // // The class \doxygen{otb}{RadiometryCorrectionParametersToAtmisphericRadiativeTerms} // computes the radiative terms using these two types of parameters. It // contains a single static method that calls the 6S library. The header // also includes the classes to manipulate correction parameters and radiative // terms. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Software Guide : EndCodeSnippet #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include int main(int argc, char *argv[]) { if (argc != 19) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0] << std::endl; std::cerr << " inputImage outputImage atmosphericCorrectionSequencement_alpha_beta.txt atmosphericCorrectionSequencement_solar_illumination.txt atmosphericCorrectionSequencement_wavelength_spectral_bands_spot4_1.txt SolarZenithalAngle day month SolarAzimuthalAngle ViewingZenithalAngle ViewingAzimuthalAngle AtmosphericPresure WaterVaporAmount OzoneAmount AerosolModel AerosolOpticalThickness WindowRadiusForAdjacencyCorrection PixelSpacing" << std::endl; std::cerr << std::endl; return 1; } // Software Guide : BeginLatex // // Image types are now defined using pixel types and // dimension. The input image is defined as an \doxygen{otb}{VectorImage}, // the output image is a \doxygen{otb}{VectorImage}. To simplify, input and // output image types are the same one. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; // Software Guide : EndCodeSnippet // We instantiate reader and writer types typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); // Software Guide : BeginLatex // // The \code{GenerateOutputInformation()} reader method is called // to know the number of component per pixel of the image. It is // recommended to // place \code{GenerateOutputInformation} calls in a \code{try/catch} block in case // errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(argv[1]); try { reader->GenerateOutputInformation(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); //------------------------------- // Software Guide : BeginLatex // // The \doxygen{otb}{ImageToLuminanceImageFilter} // type is defined and instancied. This class uses a functor applied // to each component of each pixel ($\mathbf{X^{k}}$) whose formula is: // // \begin{equation} // \mathbf{L_{TOA}^{k}} = \frac{ X^{k} } { \alpha_{k} } + \beta_{k}. // \end{equation} // // Where : // \begin{itemize} // \item $\mathbf{L_{TOA}^{k}}$ is the incident luminance (in // $W.m^{-2}.sr^{-1}.\mu m^{-1}$); // \item $\mathbf{X^{k}}$ is the measured digital number (ie. the input image pixel component); // \item $\alpha_{k}$ is the absolute calibration gain for the channel k; // \item $\beta_{k}$ is the absolute calibration bias for the channel k. // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageToLuminanceImageFilter ImageToLuminanceImageFilterType; ImageToLuminanceImageFilterType::Pointer filterImageToLuminance = ImageToLuminanceImageFilterType::New(); // Software Guide : EndCodeSnippet typedef ImageToLuminanceImageFilterType::VectorType VectorType; VectorType alpha(nbOfComponent); VectorType beta(nbOfComponent); alpha.Fill(0); beta.Fill(0); std::ifstream fin; fin.open(argv[3]); double dalpha(0.), dbeta(0.); for (unsigned int i = 0; i < nbOfComponent; ++i) { fin >> dalpha; fin >> dbeta; alpha[i] = dalpha; beta[i] = dbeta; } fin.close(); // Software Guide : BeginLatex // Here, $\alpha$ and $\beta$ are read from an ASCII file given in input, // stored in a vector and passed to the class. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filterImageToLuminance->SetAlpha(alpha); filterImageToLuminance->SetBeta(beta); // Software Guide : EndCodeSnippet //------------------------------- // Software Guide : BeginLatex // // The \doxygen{otb}{LuminanceToReflectanceImageFilter} // type is defined and instancied. // This class used a functor applied to each component of each pixel // of the luminance filter output ($\mathbf{L_{TOA}^{k}}$): // // \begin{equation} // \rho_{TOA}^{k} = \frac{ \pi.\mathbf{L_{TOA}^{k}} } { E_{S}^{k}.cos(\theta_{S}).d/d_{0} }. // \end{equation} // // Where : // \begin{itemize} // \item $\mathbf{\rho_{TOA}^{k}}$ is the reflectance measured by the sensor; // \item $\theta_{S}$ is the zenithal solar angle in degrees; // \item $E_{S}^{k}$ is the solar illumination out of the atmosphere measured at a distance // $d_{0}$ from the Earth; // \item $d/d_{0}$ is the ratio between the Earth-Sun distance at // the acquisition date and the mean Earth-Sun distance. The ratio can be directly // given to the class or computed using a 6S routine. TODO // In the last case (that is the one of this example), the user has to precise // the month and the day of the acquisition. // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LuminanceToReflectanceImageFilter LuminanceToReflectanceImageFilterType; LuminanceToReflectanceImageFilterType::Pointer filterLuminanceToReflectance = LuminanceToReflectanceImageFilterType::New(); // Software Guide : EndCodeSnippet typedef LuminanceToReflectanceImageFilterType::VectorType VectorType; VectorType solarIllumination(nbOfComponent); solarIllumination.Fill(0); fin.open(argv[4]); double dsolarIllumination(0.); for (unsigned int i = 0; i < nbOfComponent; ++i) { fin >> dsolarIllumination; solarIllumination[i] = dsolarIllumination; } fin.close(); // Software Guide : BeginLatex // The solar illumination is read from a ASCII file given in input, // stored in a vector // and given to the class. // Day, month and zenital solar angle are inputs and can be directly given to the class. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filterLuminanceToReflectance->SetZenithalSolarAngle( static_cast(atof(argv[6]))); filterLuminanceToReflectance->SetDay(atoi(argv[7])); filterLuminanceToReflectance->SetMonth(atoi(argv[8])); filterLuminanceToReflectance->SetSolarIllumination(solarIllumination); // Software Guide : EndCodeSnippet //------------------------------- // Software Guide : BeginLatex // // At this step of the chain, radiative information are nedeed to compute // the contribution of the atmosphere (such as atmosphere transmittance // and reflectance). Those information will be computed from different // correction parameters stored in \doxygen{otb}{AtmosphericCorrectionParameters} // and \doxygen{otb}{ImageMetadataCorrectionParameters} instances. // These {\em containers} will be given to the static function \texttt{Compute} // from \doxygen{otb}{RadiometryCorrectionParametersToAtmosphericRadiativeTerms} // class, which will call a 6S routine that will compute the needed // radiometric information and store them in a // \doxygen{otb}{AtmosphericRadiativeTerms} class instance. // For this, // \doxygen{otb}{RadiometryCorrectionParametersToAtmosphericRadiativeTerms}, // \doxygen{otb}{AtmosphericCorrectionParameters}, // \doxygen{otb}{ImageMetadataCorrectionParameters} and // \doxygen{otb}{AtmosphericRadiativeTerms} // types are defined and instancied. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms RadiometryCorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmosphericCorrectionParametersType; typedef otb::ImageMetadataCorrectionParameters AcquisitionCorrectionParametersType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; // Software Guide : EndCodeSnippet typedef AtmosphericCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; AtmosphericCorrectionParametersType::Pointer dataAtmosphericCorrectionParameters = AtmosphericCorrectionParametersType::New(); AcquisitionCorrectionParametersType::Pointer dataAcquisitionCorrectionParameters = AcquisitionCorrectionParametersType::New(); AtmosphericRadiativeTermsType::Pointer dataAtmosphericRadiativeTerms = AtmosphericRadiativeTermsType::New(); float minSpectralValue(0.); float maxSpectralValue(0.); float userStep(0.); float value(0.); unsigned int nbBands(0); unsigned int nbValuesPerBand(0); std::string sString; ValuesVectorType vector; fin.open(argv[5]); fin >> nbBands; for (unsigned int i = 0; i < nbBands; ++i) { vector.clear(); fin >> sString; fin >> minSpectralValue; fin >> maxSpectralValue; fin >> userStep; fin >> nbValuesPerBand; for (unsigned int j = 0; j < nbValuesPerBand; ++j) { fin >> value; vector.push_back(value); } FilterFunctionValuesType::Pointer functionValues = FilterFunctionValuesType::New(); functionValues->SetFilterFunctionValues(vector); functionValues->SetMinSpectralValue(minSpectralValue); functionValues->SetMaxSpectralValue(maxSpectralValue); functionValues->SetUserStep(userStep); dataAcquisitionCorrectionParameters->SetWavelengthSpectralBandWithIndex( i, functionValues); } fin.close(); // Software Guide : BeginLatex // // The \doxygen{otb}{ImageMetadataCorrectionParameters} class stores // several parameters that are generally present in the image metadata : // \begin{itemize} // \item The zenithal and azimutal solar angles that describe the solar incidence // configuration (in degrees); // \item The zenithal and azimuthal viewing angles that describe the viewing // direction (in degrees); // \item The month and the day of the acquisition; // \item The filter function that is the values of the filter function for one // spectral band, from $\lambda_{inf}$ to $\lambda_{sup}$ by step of 2.5 nm. // One filter function by channel is required. // This last parameter are read in text files, the other one are directly given to the class. // \end{itemize} // // When this container is not set in the ReflectanceToSurfaceReflectance // filter, it is automatically filled using the image metadata. The // following lines show that it is also possible to set the values manually. // // Software Guide : EndLatex // Set parameters // Software Guide : BeginCodeSnippet dataAcquisitionCorrectionParameters->SetSolarZenithalAngle( static_cast(atof(argv[6]))); dataAcquisitionCorrectionParameters->SetSolarAzimutalAngle( static_cast(atof(argv[9]))); dataAcquisitionCorrectionParameters->SetViewingZenithalAngle( static_cast(atof(argv[10]))); dataAcquisitionCorrectionParameters->SetViewingAzimutalAngle( static_cast(atof(argv[11]))); dataAcquisitionCorrectionParameters->SetMonth(atoi(argv[8])); dataAcquisitionCorrectionParameters->SetDay(atoi(argv[7])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{AtmosphericCorrectionParameters} class stores // physical parameters of the atmosphere that are not impacted // by the viewing angles of the image : // \begin{itemize} // \item The atmospheric pressure; // \item The water vapor amount, that is, the total water vapor content over vertical // atmospheric column; // \item The ozone amount that is the Stratospheric ozone layer content; // \item The aerosol model that is the kind of particles (no aerosol, continental, // maritime, urban, desertic); // \item The aerosol optical thickness at 550 nm that is the is the Radiative impact // of aerosol for the reference wavelength 550 nm; // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet dataAtmosphericCorrectionParameters->SetAtmosphericPressure( static_cast(atof(argv[12]))); dataAtmosphericCorrectionParameters->SetWaterVaporAmount( static_cast(atof(argv[13]))); dataAtmosphericCorrectionParameters->SetOzoneAmount( static_cast(atof(argv[14]))); AerosolModelType aerosolModel = static_cast(::atoi(argv[15])); dataAtmosphericCorrectionParameters->SetAerosolModel(aerosolModel); dataAtmosphericCorrectionParameters->SetAerosolOptical( static_cast(atof(argv[16]))); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once those parameters are loaded, they are used by the 6S library // to compute the needed radiometric information. The // RadiometryCorrectionParametersToAtmosphericRadiativeTerms class // provides a static function to perform this step\footnote{Before version // 4.2, it was done with the filter // AtmosphericCorrectionParametersTo6SAtmosphericRadiativeTerms}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet AtmosphericRadiativeTermsType::Pointer atmosphericRadiativeTerms = RadiometryCorrectionParametersToRadiativeTermsType::Compute( dataAtmosphericCorrectionParameters, dataAcquisitionCorrectionParameters); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output is stored inside an instance of the // \doxygen{otb}{AtmosphericRadiativeTerms} class. // This class contains (for each channel of the image) // \begin{itemize} // \item The Intrinsic atmospheric reflectance that takes into account for the molecular scattering // and the aerosol scattering attenuated by water vapor absorption; // \item The spherical albedo of the atmosphere; // \item The total gaseous transmission (for all species); // \item The total transmittance of the atmosphere from sun to ground (downward transmittance) // and from ground to space sensor (upward transmittance). // \end{itemize} // // Software Guide : EndLatex //------------------------------- // Software Guide : BeginLatex // Atmospheric corrections can now start. // First, an instance of \doxygen{otb}{ReflectanceToSurfaceReflectanceImageFilter} is created. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ReflectanceToSurfaceReflectanceImageFilter ReflectanceToSurfaceReflectanceImageFilterType; ReflectanceToSurfaceReflectanceImageFilterType::Pointer filterReflectanceToSurfaceReflectanceImageFilter = ReflectanceToSurfaceReflectanceImageFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The aim of the atmospheric correction is to invert the surface reflectance // (for each pixel of the input image) from the TOA reflectance and from simulations // of the atmospheric radiative functions corresponding to the geometrical conditions // of the observation and to the atmospheric components. // The process required to be applied on each pixel of the image, band by band with // the following formula: // // \begin{equation} // \rho_{S}^{unif} = \frac{ \mathbf{A} }{ 1 + Sx\mathbf{A} } // \end{equation} // Where, // \begin{equation} // \mathbf{A} = \frac{ \rho_{TOA} - \rho_{atm} }{ T(\mu_{S}).T(\mu_{V}).t_{g}^{all gas} } // \end{equation} // // With : // \begin{itemize} // \item $\rho_{TOA}$ is the reflectance at the top of the atmosphere; // \item $\rho_{S}^{unif}$ is the ground reflectance under assumption // of a lambertian surface and an uniform environment; // \item $\rho_{atm}$ is the intrinsic atmospheric reflectance; // \item $t_{g}^{all gas}$ is the spherical albedo of the atmosphere; // \item $T(\mu_{S})$ is the downward transmittance; // \item $T(\mu_{V})$ is the upward transmittance. // \end{itemize} // All those parameters are contained in the AtmosphericRadiativeTerms // container. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filterReflectanceToSurfaceReflectanceImageFilter-> SetAtmosphericRadiativeTerms(atmosphericRadiativeTerms); // Software Guide : EndCodeSnippet //------------------------------- // Software Guide : BeginLatex // Next (and last step) is the neighborhood correction. // For this, the SurfaceAdjacencyEffectCorrectionSchemeFilter class is used. // The previous surface reflectance inversion is performed under the assumption of a // homogeneous ground environment. The following step allows correcting the adjacency // effect on the radiometry of pixels. The method is based on the decomposition of // the observed signal as the summation of the own contribution of the target pixel and // of the contributions of neighbored pixels moderated by their distance to the target pixel. // A simplified relation may be : // \begin{equation} // \rho{S} = \frac{ \rho_{S}^{unif}.T(\mu_{V}) - <\rho{S}>.t_{d}(\mu_{V}) }{ exp(-\delta/\mu_{V}) } // \end{equation} // With : // \begin{itemize} // \item $\rho_{S}^{unif}$ is the ground reflectance under assumption of an homogeneous environment; // \item $T(\mu_{V})$ is the upward transmittance; // \item $t_{d}(\mu_{S})$ is the upward diffus transmittance; // \item $exp(-\delta/\mu_{V})$ is the upward direct transmittance; // \item $\rho_{S}$ is the environment contribution to the pixel target reflectance in the total // observed signal. // \begin{equation} // \rho{S} = \sum{j}\sum{i}f(r(i, j))\times \rho_{S}^{unif}(i, j) // \end{equation} // where, // \begin{itemize} // \item r(i, j) is the distance between the pixel(i, j) and the central pixel of the window in $km$; // \item f(r) is the global environment function. // \begin{equation} // f(r) = \frac{t_{d}^{R}(\mu_{V}).f_{R}(r)+t_{d}^{A}(\mu_{V}).f_{A}(r)}{ t_{d}(\mu_{V}) } // \end{equation} // \end{itemize} // \end{itemize} // The neighborhood consideration window size is given by the window radius. // // An instance of \doxygen{otb}{SurfaceAdjacencyEffectCorrectionSchemeFilter} // is created. This class has an interface quite similar to // \doxygen{otb}{ReflectanceToSurfaceReflectance}. They both need radiative terms // (\doxygen{otb}{AtmosphericRadiativeTerms}), so it is possible to compute // them outside the filter and set them directly in the filter. The other // solution is to give as input the two parameters containers ("atmospheric" // and "acquisition" parameters), then the filter will compute the radiative // terms internally. If the "acquisition" correction parameters are not // present, the filter will try to get them from the image metadata. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SurfaceAdjacencyEffectCorrectionSchemeFilter SurfaceAdjacencyEffectCorrectionSchemeFilterType; SurfaceAdjacencyEffectCorrectionSchemeFilterType::Pointer filterSurfaceAdjacencyEffectCorrectionSchemeFilter = SurfaceAdjacencyEffectCorrectionSchemeFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Four inputs are needed to compute the neighborhood contribution: // \begin{itemize} // \item The radiative terms (stored in the AtmosphericRadiativeTerms container); // \item The zenithal viewing angle; // \item The neighborhood window radius; // \item The pixel spacing in kilometers. // \end{itemize} // // Software Guide : EndLatex filterSurfaceAdjacencyEffectCorrectionSchemeFilter-> SetAtmosphericRadiativeTerms(atmosphericRadiativeTerms); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetZenithalViewingAngle( dataAcquisitionCorrectionParameters->GetViewingZenithalAngle()); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetWindowRadius(atoi(argv [17])); filterSurfaceAdjacencyEffectCorrectionSchemeFilter-> SetPixelSpacingInKilometers(static_cast(atof(argv[18]))); //------------------------------- WriterType::Pointer writer = WriterType::New(); // Software Guide : BeginLatex // // At this step, each filter of the chain is instancied and every one has its // input parameters set. A name can be given to the output image, each filter // can be linked to the next one and create the final processing chain. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetFileName(argv[2]); filterImageToLuminance->SetInput(reader->GetOutput()); filterLuminanceToReflectance->SetInput(filterImageToLuminance->GetOutput()); filterReflectanceToSurfaceReflectanceImageFilter->SetInput( filterLuminanceToReflectance->GetOutput()); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetInput( filterReflectanceToSurfaceReflectanceImageFilter->GetOutput()); writer->SetInput( filterSurfaceAdjacencyEffectCorrectionSchemeFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is recommended to place this call in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Radiometry/CMakeLists.txt000066400000000000000000000016271301006202600220610ustar00rootroot00000000000000project(RadiometryExamples) add_executable(ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx) target_link_libraries(ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter ${OTB_LIBRARIES}) #OTBOpticalCalibration -> OTB6S if(OTB6S_LOADED) add_executable(AtmosphericCorrectionSequencement AtmosphericCorrectionSequencement.cxx) target_link_libraries(AtmosphericCorrectionSequencement ${OTB_LIBRARIES}) endif() add_executable(AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx) target_link_libraries(AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter ${OTB_LIBRARIES}) add_executable(NDVIRAndNIRVegetationIndexImageFilter NDVIRAndNIRVegetationIndexImageFilter.cxx) target_link_libraries(NDVIRAndNIRVegetationIndexImageFilter ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Radiometry/NDVIRAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000216151301006202600270510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {NDVI_2.hdr} , {NDVI_3.hdr} // OUTPUTS: {NDVIRAndNIRVegetationIndex.tif} , {pretty_Red.png} , {pretty_NIR.png} , {pretty_NDVIRAndNIRVegetationIndex.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{otb::RAndNIRIndexImageFilter} // \index{otb::VegetationIndicesFunctor} // \index{otb::VegetationIndicesFunctor!header} // // The following example illustrates the use of the // \doxygen{otb}{RAndNIRIndexImageFilter} with the use of the Normalized // Difference Vegatation Index (NDVI). // NDVI computes the difference between the NIR channel, noted $L_{NIR}$, and the red channel, // noted $L_{r}$ radiances reflected from the surface and transmitted through the atmosphere: // // \begin{equation} // \mathbf{NDVI} = \frac{L_{NIR}-L_{r}}{L_{NIR}+L_{r}} // \end{equation} // // \relatedClasses // \begin{itemize} // \item \subdoxygen{otb}{Functor}{RVI} // \item \subdoxygen{otb}{Functor}{PVI} // \item \subdoxygen{otb}{Functor}{SAVI} // \item \subdoxygen{otb}{Functor}{TSAVI} // \item \subdoxygen{otb}{Functor}{MSAVI} // \item \subdoxygen{otb}{Functor}{GEMI} // \item \subdoxygen{otb}{Functor}{WDVI} // \item \subdoxygen{otb}{Functor}{IPVI} // \item \subdoxygen{otb}{Functor}{TNDVI} // \end{itemize} // With the \doxygen{otb}{RAndNIRIndexImageFilter} class the filter // inputs are one channel images: one inmage represents the NIR channel, the // the other the NIR channel. // // Let's look at the minimal code required to use this algorithm. First, the following header // defining the \doxygen{otb}{RAndNIRIndexImageFilter} // class must be included. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbRAndNIRIndexImageFilter.h" // Software Guide : EndCodeSnippet #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char *argv[]) { if (argc < 6) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage1 , inputImage2 , outputImage , prettyinputImage1 , prettyinputImage2 , prettyOutput" << std::endl; return 1; } // Software Guide : BeginLatex // // The image types are now defined using pixel types the // dimension. Input and output images are defined as \doxygen{otb}{Image}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef double InputPixelType; typedef float OutputPixelType; typedef otb::Image InputRImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // We instantiate reader and writer types typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : BeginLatex // // The NDVI (Normalized Difference Vegetation Index) is instantiated using // the images pixel type as template parameters. It is // implemented as a functor class which will be passed as a // parameter to an \doxygen{otb}{RAndNIRIndexImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Functor::NDVI FunctorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The \doxygen{otb}{RAndNIRIndexImageFilter} type is instantiated using the images // types and the NDVI functor as template parameters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::RAndNIRIndexImageFilter RAndNIRIndexImageFilterType; // Software Guide : EndCodeSnippet // Instantiating object RAndNIRIndexImageFilterType::Pointer filter = RAndNIRIndexImageFilterType::New(); RReaderType::Pointer readerR = RReaderType::New(); NIRReaderType::Pointer readerNIR = NIRReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Software Guide : BeginLatex // // Now the input images are set and a name is given to the output image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet readerR->SetFileName(argv[1]); readerNIR->SetFileName(argv[2]); writer->SetFileName(argv[3]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the processing pipeline: filter inputs are linked to // the reader output and the filter output is linked to the writer // input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInputR(readerR->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is recommended to place \code{update()} calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } // Pretty image creation for the printing typedef otb::Image OutputPrettyImageType; typedef otb::ImageFileWriter WriterPrettyType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef itk::RescaleIntensityImageFilter RescalerRType; typedef itk::RescaleIntensityImageFilter RescalerNIRType; RescalerType::Pointer rescaler = RescalerType::New(); WriterPrettyType::Pointer prettyWriter = WriterPrettyType::New(); rescaler->SetInput(filter->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); prettyWriter->SetFileName(argv[6]); prettyWriter->SetInput(rescaler->GetOutput()); RescalerRType::Pointer rescalerR = RescalerRType::New(); RescalerNIRType::Pointer rescalerNIR = RescalerNIRType::New(); WriterPrettyType::Pointer prettyWriterR = WriterPrettyType::New(); WriterPrettyType::Pointer prettyWriterNIR = WriterPrettyType::New(); rescalerR->SetInput(readerR->GetOutput()); rescalerR->SetOutputMinimum(0); rescalerR->SetOutputMaximum(255); prettyWriterR->SetFileName(argv[4]); prettyWriterR->SetInput(rescalerR->GetOutput()); rescalerNIR->SetInput(readerNIR->GetOutput()); rescalerNIR->SetOutputMinimum(0); rescalerNIR->SetOutputMaximum(255); prettyWriterNIR->SetFileName(argv[5]); prettyWriterNIR->SetInput(rescalerNIR->GetOutput()); try { prettyWriter->Update(); prettyWriterNIR->Update(); prettyWriterR->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } catch (...) { std::cout << "Unknown exception !" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Let's now run this example using as input the images // \code{NDVI\_3.hdr} and \code{NDVI\_4.hdr} (images kindly and free of charge given by SISA and CNES) // provided in the directory \code{Examples/Data}. // // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{pretty_Red.eps} // \includegraphics[width=0.24\textwidth]{pretty_NIR.eps} // \includegraphics[width=0.24\textwidth]{pretty_NDVIRAndNIRVegetationIndex.eps} // \itkcaption[ARVI Example]{NDVI input images on the left (Red channel and NIR channel), on the right the result of the algorithm.} // \label{fig:NDVIRAndNIRIndex} // \end{figure} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Radiometry/test/000077500000000000000000000000001301006202600202725ustar00rootroot00000000000000OTB-release-5.8/Examples/Radiometry/test/CMakeLists.txt000066400000000000000000000065471301006202600230460ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Radiometry) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter ------------------------------ otb_add_test(NAME raTeARVIMultiChannelRAndBAndNIRVegetationIndexImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/ARVIMultiChannelRAndBAndNIRVegetationIndex.tif ${TEMP}/ARVIMultiChannelRAndBAndNIRVegetationIndex.tif Execute $ ${INPUTDATA}/poupees_sub.png ${TEMP}/ARVIMultiChannelRAndBAndNIRVegetationIndex.tif ${TEMP}/ARVIMultiChannelRAndBAndNIRVegetationIndex3.tif ${TEMP}/ARVIMultiChannelRAndBAndNIRVegetationIndex2.tif 1 2 3 0.6 # Gamma parameter ) # ------- AVIMultiChannelRAndGAndNIRVegetationIndexImageFilterTest ------------------------------ otb_add_test(NAME raTeAVIMultiChannelRAndGAndNIRVegetationIndexImageFilterTest COMMAND ${OTB_TEST_DRIVER} #--compare-image ${NOTOL} # ${BASELINE}/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilterTest.tif # ${TEMP}/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilterTest.tif Execute $ ${INPUTDATA}/qb_toulouse_sub.tif ${TEMP}/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilterTest.tif ${TEMP}/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilterTest2.png ${TEMP}/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilterTest3.png 3 2 4 # indices of the channels 660. 560. 830. # lambdaR, lambdaG, lambdaNir ) # ------- NDVIRAndNIRVegetationIndexImageFilter ------------------------------ otb_add_test(NAME raTeNDVIRAndNIRVegetationIndexImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/NDVIRAndNIRVegetationIndex.tif ${TEMP}/NDVIRAndNIRVegetationIndex.tif Execute $ ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${TEMP}/NDVIRAndNIRVegetationIndex.tif ${TEMP}/NDVIRAndNIRVegetationIndex2.tif ${TEMP}/NDVIRAndNIRVegetationIndex3.tif ${TEMP}/NDVIRAndNIRVegetationIndex4.tif ) if(OTBOpticalCalibration_LOADED) otb_add_test(NAME raTeAtmosphericCorrectionSequencementTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${BASELINE}/Example_RomaniaAtmosphericCorrectionSequencement.tif ${TEMP}/Example_RomaniaAtmosphericCorrectionSequencement.tif Execute $ ${INPUTDATA}/Romania_Extract.tif ${TEMP}/Example_RomaniaAtmosphericCorrectionSequencement.tif ${INPUTDATA}/atmosphericCorrectionSequencement_alpha_beta.txt ${INPUTDATA}/atmosphericCorrectionSequencement_solar_illumination.txt ${INPUTDATA}/atmosphericCorrectionSequencement_wavelength_spectral_bands_spot4_1.txt # ImageToLuminance parameters # LuminanceToReflectance parameters 27.3 #solar azimuthal elevation 4 #day 12 #month # AtmosphericCorrectionParametersTo6SAtmosphericRadiativeTerms parameters 152.7 2.5 -77.0 1013. 2.48134 0.34400 1 0.199854 # ReflectanceToSurfaceReflectance parameters # SurfaceAdjacencyEffect6SCorrectionSchemeFilter parameters 2 # Radius; 0.020 # pixel spacing in kilometers ) endif()OTB-release-5.8/Examples/Registration/000077500000000000000000000000001301006202600176465ustar00rootroot00000000000000OTB-release-5.8/Examples/Registration/CMakeLists.txt000066400000000000000000000010531301006202600224050ustar00rootroot00000000000000project(RegistrationExamples) add_executable(ImageRegistration1 ImageRegistration1.cxx) target_link_libraries(ImageRegistration1 ${OTB_LIBRARIES}) add_executable(ImageRegistration2 ImageRegistration2.cxx) target_link_libraries(ImageRegistration2 ${OTB_LIBRARIES}) add_executable(ImageRegistration5 ImageRegistration5.cxx) target_link_libraries(ImageRegistration5 ${OTB_LIBRARIES}) add_executable(ImageRegistration9 ImageRegistration9.cxx) target_link_libraries(ImageRegistration9 ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Registration/ImageRegistration1.cxx000066400000000000000000000741341301006202600241010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // INPUTS: {QB_Suburb13x17y.png} // OUTPUTS: {ImageRegistration1Output.png} // OUTPUTS: {ImageRegistration1DifferenceAfter.png} // OUTPUTS: {ImageRegistration1DifferenceBefore.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the image registration framework in // ITK/OTB. It should be read as a "Hello World" for registration. Which // means that for now, you don't ask ``why?''. Instead, use the example as an // introduction to the elements that are typically involved in solving an image // registration problem. // // \index{otb::Image!Instantiation} // \index{otb::Image!Header} // // A registration method requires the following set of components: two input // images, a transform, a metric, an interpolator and an optimizer. Some of // these components are parameterized by the image type for which the // registration is intended. The following header files provide declarations // of common types used for these components. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkImageRegistrationMethod.h" #include "itkTranslationTransform.h" #include "itkMeanSquaresImageToImageMetric.h" #include "itkRegularStepGradientDescentOptimizer.h" #include "otbImage.h" // Software Guide : EndCodeSnippet #include "itkUnaryFunctorImageFilter.h" #include "itkMeanImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkResampleImageFilter.h" #include "itkCastImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkSubtractImageFilter.h" class CommandIterationUpdate : public itk::Command { public: typedef CommandIterationUpdate Self; typedef itk::Command Superclass; typedef itk::SmartPointer Pointer; itkNewMacro(Self); protected: CommandIterationUpdate() {} public: typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef const OptimizerType * OptimizerPointer; void Execute(itk::Object *caller, const itk::EventObject& event) ITK_OVERRIDE { Execute((const itk::Object *) caller, event); } void Execute(const itk::Object * object, const itk::EventObject& event) ITK_OVERRIDE { OptimizerPointer optimizer = dynamic_cast(object); if (!itk::IterationEvent().CheckEvent(&event)) { return; } std::cout << optimizer->GetCurrentIteration() << " = "; std::cout << optimizer->GetValue() << " : "; std::cout << optimizer->GetCurrentPosition() << std::endl; } }; int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " fixedImageFile movingImageFile "; std::cerr << "outputImagefile [differenceImageAfter]"; std::cerr << "[differenceImageBefore]" << std::endl; return 1; } // Software Guide : BeginLatex // // The types of each one of the components in the registration methods should // be instantiated first. With that purpose, we start by selecting the image // dimension and the type used for representing image pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef float PixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The types of the input images are instantiated by the following lines. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image FixedImageType; typedef otb::Image MovingImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The transform that will map the fixed image space into the moving image // space is defined below. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::TranslationTransform TransformType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An optimizer is required to explore the parameter space of the transform // in search of optimal values of the metric. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RegularStepGradientDescentOptimizer OptimizerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The metric will compare how well the two images match each other. Metric // types are usually parameterized by the image types as it can be seen in // the following type declaration. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MeanSquaresImageToImageMetric< FixedImageType, MovingImageType> MetricType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, the type of the interpolator is declared. The interpolator will // evaluate the intensities of the moving image at non-grid positions. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::LinearInterpolateImageFunction< MovingImageType, double> InterpolatorType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The registration method type is instantiated using the types of the // fixed and moving images. This class is responsible for interconnecting // all the components that we have described so far. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ImageRegistrationMethod< FixedImageType, MovingImageType> RegistrationType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Each one of the registration components is created using its // \code{New()} method and is assigned to its respective // \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MetricType::Pointer metric = MetricType::New(); TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Each component is now connected to the instance of the registration method. // \index{itk::RegistrationMethod!SetMetric()} // \index{itk::RegistrationMethod!SetOptimizer()} // \index{itk::RegistrationMethod!SetTransform()} // \index{itk::RegistrationMethod!SetFixedImage()} // \index{itk::RegistrationMethod!SetMovingImage()} // \index{itk::RegistrationMethod!SetInterpolator()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registration->SetMetric(metric); registration->SetOptimizer(optimizer); registration->SetTransform(transform); registration->SetInterpolator(interpolator); // Software Guide : EndCodeSnippet typedef otb::ImageFileReader FixedImageReaderType; typedef otb::ImageFileReader MovingImageReaderType; FixedImageReaderType::Pointer fixedImageReader = FixedImageReaderType::New(); MovingImageReaderType::Pointer movingImageReader = MovingImageReaderType::New(); fixedImageReader->SetFileName(argv[1]); movingImageReader->SetFileName(argv[2]); // Software Guide : BeginLatex // // Since we are working with high resolution images and expected // shifts are larger than the resolution, we will need to smooth // the images in order to avoid the optimizer to get stucked on // local minima. In order to do this, we will use a simple mean filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MeanImageFilter< FixedImageType, FixedImageType> FixedFilterType; typedef itk::MeanImageFilter< MovingImageType, MovingImageType> MovingFilterType; FixedFilterType::Pointer fixedFilter = FixedFilterType::New(); MovingFilterType::Pointer movingFilter = MovingFilterType::New(); FixedImageType::SizeType indexFRadius; indexFRadius[0] = 4; // radius along x indexFRadius[1] = 4; // radius along y fixedFilter->SetRadius(indexFRadius); MovingImageType::SizeType indexMRadius; indexMRadius[0] = 4; // radius along x indexMRadius[1] = 4; // radius along y movingFilter->SetRadius(indexMRadius); fixedFilter->SetInput(fixedImageReader->GetOutput()); movingFilter->SetInput(movingImageReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we can plug the output of the smoothing filters at the input // of the registration method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registration->SetFixedImage(fixedFilter->GetOutput()); registration->SetMovingImage(movingFilter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The registration can be restricted to consider only a particular region // of the fixed image as input to the metric computation. This region is // defined with the \code{SetFixedImageRegion()} method. You could use this // feature to reduce the computational time of the registration or to avoid // unwanted objects present in the image from affecting the registration outcome. // In this example we use the full available content of the image. This // region is identified by the \code{BufferedRegion} of the fixed image. // Note that for this region to be valid the reader must first invoke its // \code{Update()} method. // // \index{itk::ImageRegistrationMethod!SetFixedImageRegion()} // \index{otb::Image!GetBufferedRegion()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fixedFilter->Update(); registration->SetFixedImageRegion( fixedFilter->GetOutput()->GetBufferedRegion()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The parameters of the transform are initialized by passing them in an // array. This can be used to setup an initial known correction of the // misalignment. In this particular case, a translation transform is // being used for the registration. The array of parameters for this // transform is simply composed of the translation values along each // dimension. Setting the values of the parameters to zero // initializes the transform to an \emph{Identity} transform. Note that the // array constructor requires the number of elements to be passed as an // argument. // // \index{itk::TranslationTransform!GetNumberOfParameters()} // \index{itk::RegistrationMethod!SetInitialTransformParameters()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef RegistrationType::ParametersType ParametersType; ParametersType initialParameters(transform->GetNumberOfParameters()); initialParameters[0] = 0.0; // Initial offset in mm along X initialParameters[1] = 0.0; // Initial offset in mm along Y registration->SetInitialTransformParameters(initialParameters); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // At this point the registration method is ready for execution. The // optimizer is the component that drives the execution of the // registration. However, the ImageRegistrationMethod class // orchestrates the ensemble to make sure that everything is in place // before control is passed to the optimizer. // // It is usually desirable to fine tune the parameters of the optimizer. // Each optimizer has particular parameters that must be interpreted in the // context of the optimization strategy it implements. The optimizer used in // this example is a variant of gradient descent that attempts to prevent it // from taking steps that are too large. At each iteration, this optimizer // will take a step along the direction of the \doxygen{itk}{ImageToImageMetric} // derivative. The initial length of the step is defined by the user. Each // time the direction of the derivative abruptly changes, the optimizer // assumes that a local extrema has been passed and reacts by reducing the // step length by a half. After several reductions of the step length, the // optimizer may be moving in a very restricted area of the transform // parameter space. The user can define how small the step length should be // to consider convergence to have been reached. This is equivalent to defining // the precision with which the final transform should be known. // // The initial step length is defined with the method // \code{SetMaximumStepLength()}, while the tolerance for convergence is // defined with the method \code{SetMinimumStepLength()}. // // \index{itk::Regular\-Setp\-Gradient\-Descent\-Optimizer!SetMaximumStepLength()} // \index{itk::Regular\-Step\-Gradient\-Descent\-Optimizer!SetMinimumStepLength()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet optimizer->SetMaximumStepLength(3); optimizer->SetMinimumStepLength(0.01); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In case the optimizer never succeeds reaching the desired // precision tolerance, it is prudent to establish a limit on the number of // iterations to be performed. This maximum number is defined with the // method \code{SetNumberOfIterations()}. // // \index{itk::Regular\-Setp\-Gradient\-Descent\-Optimizer!SetNumberOfIterations()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet optimizer->SetNumberOfIterations(200); // Software Guide : EndCodeSnippet // Connect an observer CommandIterationUpdate::Pointer observer = CommandIterationUpdate::New(); optimizer->AddObserver(itk::IterationEvent(), observer); // Software Guide : BeginLatex // // The registration process is triggered by an invocation to the // \code{Update()} method. If something goes wrong during the // initialization or execution of the registration an exception will be // thrown. We should therefore place the \code{Update()} method // inside a \code{try/catch} block as illustrated in the following lines. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { registration->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return -1; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In a real life application, you may attempt to recover from the error by // taking more effective actions in the catch block. Here we are simply // printing out a message and then terminating the execution of the program. // // Software Guide : EndLatex // Software Guide : BeginLatex // // The result of the registration process is an array of parameters that // defines the spatial transformation in an unique way. This final result is // obtained using the \code{GetLastTransformParameters()} method. // // \index{itk::RegistrationMethod!GetLastTransformParameters()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ParametersType finalParameters = registration->GetLastTransformParameters(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In the case of the \doxygen{itk}{TranslationTransform}, there is a // straightforward interpretation of the parameters. Each element of the // array corresponds to a translation along one spatial dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const double TranslationAlongX = finalParameters[0]; const double TranslationAlongY = finalParameters[1]; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The optimizer can be queried for the actual number of iterations // performed to reach convergence. The \code{GetCurrentIteration()} // method returns this value. A large number of iterations may be an // indication that the maximum step length has been set too small, which // is undesirable since it results in long computational times. // // \index{itk::Regular\-Setp\-Gradient\-Descent\-Optimizer!GetCurrentIteration()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int numberOfIterations = optimizer->GetCurrentIteration(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The value of the image metric corresponding to the last set of parameters // can be obtained with the \code{GetValue()} method of the optimizer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const double bestValue = optimizer->GetValue(); // Software Guide : EndCodeSnippet // Print out results // std::cout << "Result = " << std::endl; std::cout << " Translation X = " << TranslationAlongX << std::endl; std::cout << " Translation Y = " << TranslationAlongY << std::endl; std::cout << " Iterations = " << numberOfIterations << std::endl; std::cout << " Metric value = " << bestValue << std::endl; // Software Guide : BeginLatex // // Let's execute this example over two of the images provided in // \code{Examples/Data}: // // \begin{itemize} // \item \code{QB\_Suburb.png} // \item \code{QB\_Suburb13x17y.png} // \end{itemize} // // The second image is the result of intentionally translating the first // image by $(13, 17)$ pixels. Both images have unit-spacing and // are shown in Figure \ref{fig:FixedMovingImageRegistration1}. The // registration takes 18 iterations and the resulting transform parameters are: // // \begin{verbatim} // Translation X = 12.0192 // Translation Y = 16.0231 // \end{verbatim} // // As expected, these values match quite well the misalignment that we // intentionally introduced in the moving image. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{QB_Suburb13x17y.eps} // \itkcaption[Fixed and Moving images in registration framework]{Fixed and // Moving image provided as input to the registration method.} // \label{fig:FixedMovingImageRegistration1} // \end{figure} // // // Software Guide : EndLatex // Software Guide : BeginLatex // // It is common, as the last step of a registration task, to use // the resulting transform to map the moving image into the fixed // image space. This is easily done with the // \doxygen{itk}{ResampleImageFilter}. First, a ResampleImageFilter // type is instantiated using the image types. It is convenient to // use the fixed image type as the output type since it is likely // that the transformed moving image will be compared with the // fixed image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ResampleImageFilter< MovingImageType, FixedImageType> ResampleFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A resampling filter is created and the moving image is connected as // its input. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ResampleFilterType::Pointer resampler = ResampleFilterType::New(); resampler->SetInput(movingImageReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The Transform that is produced as output of the Registration method is // also passed as input to the resampling filter. Note the use of the // methods \code{GetOutput()} and \code{Get()}. This combination is needed // here because the registration method acts as a filter whose output is a // transform decorated in the form of a \doxygen{itk}{DataObject}. For details in // this construction you may want to read the documentation of the // \doxygen{itk}{DataObjectDecorator}. // // \index{itk::ImageRegistrationMethod!Resampling image} // \index{itk::ImageRegistrationMethod!Pipeline} // \index{itk::ImageRegistrationMethod!DataObjectDecorator} // \index{itk::ImageRegistrationMethod!GetOutput()} // \index{itk::DataObjectDecorator!Use in Registration} // \index{itk::DataObjectDecorator!Get()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet resampler->SetTransform(registration->GetOutput()->Get()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The // ResampleImageFilter requires additional parameters to be specified, in // particular, the spacing, origin and size of the output image. The default // pixel value is also set to a distinct gray level in order to highlight // the regions that are mapped outside of the moving image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FixedImageType::Pointer fixedImage = fixedImageReader->GetOutput(); resampler->SetSize(fixedImage->GetLargestPossibleRegion().GetSize()); resampler->SetOutputOrigin(fixedImage->GetOrigin()); resampler->SetOutputSpacing(fixedImage->GetSpacing()); resampler->SetDefaultPixelValue(100); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{ImageRegistration1Output.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration1DifferenceBefore.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration1DifferenceAfter.eps} // \itkcaption[HelloWorld registration output images]{Mapped moving image and its // difference with the fixed image before and after registration} // \label{fig:ImageRegistration1Output} // \end{figure} // // Software Guide : EndLatex // Software Guide : BeginLatex // // The output of the filter is passed to a writer that will store the // image in a file. An \doxygen{itk}{CastImageFilter} is used to convert the // pixel type of the resampled image to the final type used by the // writer. The cast and writer filters are instantiated below. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::CastImageFilter CastFilterType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filters are created by invoking their \code{New()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer = WriterType::New(); CastFilterType::Pointer caster = CastFilterType::New(); // Software Guide : EndCodeSnippet writer->SetFileName(argv[3]); // Software Guide : BeginLatex // // The filters are connected together and the \code{Update()} method of the // writer is invoked in order to trigger the execution of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet caster->SetInput(resampler->GetOutput()); writer->SetInput(caster->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=\textwidth]{ImageRegistration1Pipeline.eps} // \itkcaption[Pipeline structure of the registration example]{Pipeline // structure of the registration example.} // \label{fig:ImageRegistration1Pipeline} // \end{figure} // // // Software Guide : EndLatex // Software Guide : BeginLatex // // The fixed image and the transformed moving image can easily be compared // using the \doxygen{itk}{SubtractImageFilter}. This pixel-wise filter computes // the difference between homologous pixels of its two input images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::SubtractImageFilter< FixedImageType, FixedImageType, FixedImageType> DifferenceFilterType; DifferenceFilterType::Pointer difference = DifferenceFilterType::New(); difference->SetInput1(fixedImageReader->GetOutput()); difference->SetInput2(resampler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that the use of subtraction as a method for comparing the images is // appropriate here because we chose to represent the images using a pixel // type \code{float}. A different filter would have been used if the pixel // type of the images were any of the \code{unsigned} integer type. // // Software Guide : EndLatex // Software Guide : BeginLatex // // Since the differences between the two images may correspond to very low // values of intensity, we rescale those intensities with a // \doxygen{itk}{RescaleIntensityImageFilter} in order to make them more visible. // This rescaling will also make possible to visualize the negative values // even if we save the difference image in a file format that only support // unsigned pixel values\footnote{This is the case of PNG, BMP, JPEG and // TIFF among other common file formats.}. We also reduce the // \code{DefaultPixelValue} to ``1'' in order to prevent that value from // absorbing the dynamic range of the differences between the two images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter< FixedImageType, OutputImageType> RescalerType; RescalerType::Pointer intensityRescaler = RescalerType::New(); intensityRescaler->SetInput(difference->GetOutput()); intensityRescaler->SetOutputMinimum(0); intensityRescaler->SetOutputMaximum(255); resampler->SetDefaultPixelValue(1); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Its output can be passed to another writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(intensityRescaler->GetOutput()); // Software Guide : EndCodeSnippet if (argc > 4) { writer2->SetFileName(argv[4]); writer2->Update(); } // Software Guide : BeginLatex // // For the purpose of comparison, the difference between the fixed image and // the moving image before registration can also be computed by simply // setting the transform to an identity transform. Note that the resampling // is still necessary because the moving image does not necessarily have the // same spacing, origin and number of pixels as the fixed image. Therefore a // pixel-by-pixel operation cannot in general be performed. The resampling // process with an identity transform will ensure that we have a // representation of the moving image in the grid of the fixed image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet TransformType::Pointer identityTransform = TransformType::New(); identityTransform->SetIdentity(); resampler->SetTransform(identityTransform); // Software Guide : EndCodeSnippet if (argc > 5) { writer2->SetFileName(argv[5]); writer2->Update(); } // Software Guide : BeginLatex // // The complete pipeline structure of the current example is presented in // Figure~\ref{fig:ImageRegistration1Pipeline}. The components of the // registration method are depicted as well. Figure // \ref{fig:ImageRegistration1Output} (left) shows the result of resampling // the moving image in order to map it onto the fixed image space. The top // and right borders of the image appear in the gray level selected with the // \code{SetDefaultPixelValue()} in the ResampleImageFilter. The center // image shows the difference between the fixed image and the original // moving image. That is, the difference before the registration is // performed. The right image shows the difference between the fixed image // and the transformed moving image. That is, after the registration has // been performed. Both difference images have been rescaled in intensity // in order to highlight those pixels where differences exist. Note that // the final registration is still off by a fraction of a pixel, which // results in bands around edges of anatomical structures to appear in the // difference image. A perfect registration would have produced a null // difference image. // // Software Guide : EndLatex // oftware Guide : BegSinLatex // // \begin{figure} // \center // \includegraphics[height=0.44\textwidth]{ImageRegistration1TraceTranslations.eps} // \includegraphics[height=0.44\textwidth]{ImageRegistration1TraceMetric.eps} // \itkcaption[Trace of translations and metrics during registration]{The sequence // of translations and metric values at each iteration of the optimizer.} // \label{fig:ImageRegistration1Trace} // \end{figure} // // It is always useful to keep in mind that registration is essentially an // optimization problem. Figure \ref{fig:ImageRegistration1Trace} helps to // reinforce this notion by showing the trace of translations and values of // the image metric at each iteration of the optimizer. It can be seen from // the top figure that the step length is reduced progressively as the // optimizer gets closer to the metric extrema. The bottom plot clearly // shows how the metric value decreases as the optimization advances. The // log plot helps to highlight the normal oscillations of the optimizer // around the extrema value. // // Software Guide : End Latex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Registration/ImageRegistration2.cxx000066400000000000000000000504631301006202600241010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {RamsesROISmall.png}, {ADS40RoiSmall.png} // OUTPUTS: {ImageRegistration2Output.png}, {ImageRegistration2CheckerboardBefore.png}, {ImageRegistration2CheckerboardAfter.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following simple example illustrates how multiple imaging modalities can // be registered using the ITK registration framework. The first difference // between this and previous examples is the use of the // \doxygen{itk}{MutualInformationImageToImageMetric} as the cost-function to be // optimized. The second difference is the use of the // \doxygen{itk}{GradientDescentOptimizer}. Due to the stochastic nature of the // metric computation, the values are too noisy to work successfully with the // \doxygen{itk}{RegularStepGradientDescentOptimizer}. Therefore, we will use the // simpler GradientDescentOptimizer with a user defined learning rate. The // following headers declare the basic components of this registration method. // // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkImageRegistrationMethod.h" #include "itkTranslationTransform.h" #include "itkMutualInformationImageToImageMetric.h" #include "itkGradientDescentOptimizer.h" #include "otbImage.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // One way to simplify the computation of the mutual information is // to normalize the statistical distribution of the two input images. The // \doxygen{itk}{NormalizeImageFilter} is the perfect tool for this task. // It rescales the intensities of the input images in order to produce an // output image with zero mean and unit variance. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkNormalizeImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Additionally, low-pass filtering of the images to be registered will also // increase robustness against noise. In this example, we will use the // \doxygen{itk}{DiscreteGaussianImageFilter} for that purpose. The // characteristics of this filter have been discussed in Section // \ref{sec:BlurringFilters}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkDiscreteGaussianImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkResampleImageFilter.h" #include "itkCastImageFilter.h" #include "itkCheckerBoardImageFilter.h" // The following section of code implements a Command observer // that will monitor the evolution of the registration process. // #include "itkCommand.h" class CommandIterationUpdate : public itk::Command { public: typedef CommandIterationUpdate Self; typedef itk::Command Superclass; typedef itk::SmartPointer Pointer; itkNewMacro(Self); protected: CommandIterationUpdate() {} public: typedef itk::GradientDescentOptimizer OptimizerType; typedef const OptimizerType * OptimizerPointer; void Execute(itk::Object *caller, const itk::EventObject& event) ITK_OVERRIDE { Execute((const itk::Object *) caller, event); } void Execute(const itk::Object * object, const itk::EventObject& event) ITK_OVERRIDE { OptimizerPointer optimizer = dynamic_cast(object); if (!itk::IterationEvent().CheckEvent(&event)) { return; } std::cout << optimizer->GetCurrentIteration() << " "; std::cout << optimizer->GetValue() << " "; std::cout << optimizer->GetCurrentPosition() << std::endl; } }; int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " fixedImageFile movingImageFile "; std::cerr << "outputImagefile "; std::cerr << "[checkerBoardBefore] [checkerBoardAfter]" << std::endl; return 1; } // Software Guide : BeginLatex // // The moving and fixed images types should be instantiated first. // // Software Guide : EndLatex // // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef unsigned short PixelType; typedef otb::Image FixedImageType; typedef otb::Image MovingImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It is convenient to work with an internal image type because mutual // information will perform better on images with a normalized statistical // distribution. The fixed and moving images will be normalized and // converted to this internal type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; typedef otb::Image InternalImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The rest of the image registration components are instantiated as // illustrated in Section \ref{sec:IntroductionImageRegistration} with // the use of the \code{InternalImageType}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::TranslationTransform TransformType; typedef itk::GradientDescentOptimizer OptimizerType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef itk::ImageRegistrationMethod RegistrationType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The mutual information metric type is instantiated using the image // types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MutualInformationImageToImageMetric< InternalImageType, InternalImageType> MetricType; // Software Guide : EndCodeSnippet TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); registration->SetOptimizer(optimizer); registration->SetTransform(transform); registration->SetInterpolator(interpolator); // Software Guide : BeginLatex // // The metric is created using the \code{New()} method and then // connected to the registration object. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MetricType::Pointer metric = MetricType::New(); registration->SetMetric(metric); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The metric requires a number of parameters to be selected, including // the standard deviation of the Gaussian kernel for the fixed image // density estimate, the standard deviation of the kernel for the moving // image density and the number of samples use to compute the densities // and entropy values. Details on the concepts behind the computation of // the metric can be found in Section // \ref{sec:MutualInformationMetric}. Experience has // shown that a kernel standard deviation of $0.4$ works well for images // which have been normalized to a mean of zero and unit variance. We // will follow this empirical rule in this example. // // \index{itk::Mutual\-Information\-Image\-To\-Image\-Metric!SetFixedImageStandardDeviation()} // \index{itk::Mutual\-Information\-Image\-To\-Image\-Metric!SetMovingImageStandardDeviation()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet metric->SetFixedImageStandardDeviation(0.4); metric->SetMovingImageStandardDeviation(0.4); // Software Guide : EndCodeSnippet typedef otb::ImageFileReader FixedImageReaderType; typedef otb::ImageFileReader MovingImageReaderType; FixedImageReaderType::Pointer fixedImageReader = FixedImageReaderType::New(); MovingImageReaderType::Pointer movingImageReader = MovingImageReaderType::New(); fixedImageReader->SetFileName(argv[1]); movingImageReader->SetFileName(argv[2]); // Software Guide : BeginLatex // // The normalization filters are instantiated using the fixed and moving // image types as input and the internal image type as output. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::NormalizeImageFilter< FixedImageType, InternalImageType > FixedNormalizeFilterType; typedef itk::NormalizeImageFilter< MovingImageType, InternalImageType > MovingNormalizeFilterType; FixedNormalizeFilterType::Pointer fixedNormalizer = FixedNormalizeFilterType::New(); MovingNormalizeFilterType::Pointer movingNormalizer = MovingNormalizeFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The blurring filters are declared using the internal image type as both // the input and output types. In this example, we will set the variance // for both blurring filters to $2.0$. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::DiscreteGaussianImageFilter< InternalImageType, InternalImageType > GaussianFilterType; GaussianFilterType::Pointer fixedSmoother = GaussianFilterType::New(); GaussianFilterType::Pointer movingSmoother = GaussianFilterType::New(); fixedSmoother->SetVariance(4.0); movingSmoother->SetVariance(4.0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output of the readers becomes the input to the normalization // filters. The output of the normalization filters is connected as // input to the blurring filters. The input to the registration method // is taken from the blurring filters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fixedNormalizer->SetInput(fixedImageReader->GetOutput()); movingNormalizer->SetInput(movingImageReader->GetOutput()); fixedSmoother->SetInput(fixedNormalizer->GetOutput()); movingSmoother->SetInput(movingNormalizer->GetOutput()); registration->SetFixedImage(fixedSmoother->GetOutput()); registration->SetMovingImage(movingSmoother->GetOutput()); // Software Guide : EndCodeSnippet fixedNormalizer->Update(); FixedImageType::RegionType fixedImageRegion = fixedNormalizer->GetOutput()->GetBufferedRegion(); registration->SetFixedImageRegion(fixedImageRegion); typedef RegistrationType::ParametersType ParametersType; ParametersType initialParameters(transform->GetNumberOfParameters()); initialParameters[0] = 0.0; // Initial offset in mm along X initialParameters[1] = 0.0; // Initial offset in mm along Y registration->SetInitialTransformParameters(initialParameters); // Software Guide : BeginLatex // // We should now define the number of spatial samples to be considered in // the metric computation. Note that we were forced to postpone this setting // until we had done the preprocessing of the images because the number of // samples is usually defined as a fraction of the total number of pixels in // the fixed image. // // The number of spatial samples can usually be as low as $1\%$ of the total // number of pixels in the fixed image. Increasing the number of samples // improves the smoothness of the metric from one iteration to another and // therefore helps when this metric is used in conjunction with optimizers // that rely of the continuity of the metric values. The trade-off, of // course, is that a larger number of samples result in longer computation // times per every evaluation of the metric. // // It has been demonstrated empirically that the number of samples is not a // critical parameter for the registration process. When you start fine // tuning your own registration process, you should start using high values // of number of samples, for example in the range of $20\%$ to $50\%$ of the // number of pixels in the fixed image. Once you have succeeded to register // your images you can then reduce the number of samples progressively until // you find a good compromise on the time it takes to compute one evaluation // of the Metric. Note that it is not useful to have very fast evaluations // of the Metric if the noise in their values results in more iterations // being required by the optimizer to converge. // // \index{itk::Mutual\-Information\-Image\-To\-Image\-Metric!SetNumberOfSpatialSamples()} // \index{itk::Mutual\-Information\-Image\-To\-Image\-Metric!Trade-offs} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int numberOfPixels = fixedImageRegion.GetNumberOfPixels(); const unsigned int numberOfSamples = static_cast(numberOfPixels * 0.01); metric->SetNumberOfSpatialSamples(numberOfSamples); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since larger values of mutual information indicate better matches than // smaller values, we need to maximize the cost function in this example. // By default the GradientDescentOptimizer class is set to minimize the // value of the cost-function. It is therefore necessary to modify its // default behavior by invoking the \code{MaximizeOn()} method. // Additionally, we need to define the optimizer's step size using the // \code{SetLearningRate()} method. // // \index{itk::Gradient\-Descent\-Optimizer!MaximizeOn()} // \index{itk::Image\-Registration\-Method!Maximize vs Minimize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet optimizer->SetLearningRate(150.0); optimizer->SetNumberOfIterations(300); optimizer->MaximizeOn(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Note that large values of the learning rate will make the optimizer // unstable. Small values, on the other hand, may result in the optimizer // needing too many iterations in order to walk to the extrema of the cost // function. The easy way of fine tuning this parameter is to start with // small values, probably in the range of $\{5.0, 10.0\}$. Once the other // registration parameters have been tuned for producing convergence, you // may want to revisit the learning rate and start increasing its value until // you observe that the optimization becomes unstable. The ideal value for // this parameter is the one that results in a minimum number of iterations // while still keeping a stable path on the parametric space of the // optimization. Keep in mind that this parameter is a multiplicative factor // applied on the gradient of the Metric. Therefore, its effect on the // optimizer step length is proportional to the Metric values themselves. // Metrics with large values will require you to use smaller values for the // learning rate in order to maintain a similar optimizer behavior. // // Software Guide : EndLatex // Create the Command observer and register it with the optimizer. // CommandIterationUpdate::Pointer observer = CommandIterationUpdate::New(); optimizer->AddObserver(itk::IterationEvent(), observer); try { registration->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return -1; } ParametersType finalParameters = registration->GetLastTransformParameters(); double TranslationAlongX = finalParameters[0]; double TranslationAlongY = finalParameters[1]; unsigned int numberOfIterations = optimizer->GetCurrentIteration(); double bestValue = optimizer->GetValue(); // Print out results // std::cout << std::endl; std::cout << "Result = " << std::endl; std::cout << " Translation X = " << TranslationAlongX << std::endl; std::cout << " Translation Y = " << TranslationAlongY << std::endl; std::cout << " Iterations = " << numberOfIterations << std::endl; std::cout << " Metric value = " << bestValue << std::endl; std::cout << " Numb. Samples = " << numberOfSamples << std::endl; // Software Guide : BeginLatex // // Let's execute this example over two of the images provided in // \code{Examples/Data}: // // \begin{itemize} // \item \code{RamsesROISmall.png} // \item \code{ADS40RoiSmall.png} // \end{itemize} // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{RamsesROISmall.eps} // \includegraphics[width=0.44\textwidth]{ADS40RoiSmall.eps} // \itkcaption[Multi-Modality Registration Inputs]{A SAR image // (fixed image) and an aerial // photograph // (moving image) are provided as input to the registration method.} // \label{fig:FixedMovingImageRegistration2} // \end{figure} // // // Software Guide : EndLatex typedef itk::ResampleImageFilter< MovingImageType, FixedImageType> ResampleFilterType; TransformType::Pointer finalTransform = TransformType::New(); finalTransform->SetParameters(finalParameters); ResampleFilterType::Pointer resample = ResampleFilterType::New(); resample->SetTransform(finalTransform); resample->SetInput(movingImageReader->GetOutput()); FixedImageType::Pointer fixedImage = fixedImageReader->GetOutput(); resample->SetSize(fixedImage->GetLargestPossibleRegion().GetSize()); resample->SetOutputOrigin(fixedImage->GetOrigin()); resample->SetOutputSpacing(fixedImage->GetSpacing()); resample->SetDefaultPixelValue(100); typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::CastImageFilter< FixedImageType, OutputImageType> CastFilterType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); CastFilterType::Pointer caster = CastFilterType::New(); writer->SetFileName(argv[3]); caster->SetInput(resample->GetOutput()); writer->SetInput(caster->GetOutput()); writer->Update(); // Generate checkerboards before and after registration // typedef itk::CheckerBoardImageFilter CheckerBoardFilterType; CheckerBoardFilterType::Pointer checker = CheckerBoardFilterType::New(); checker->SetInput1(fixedImage); checker->SetInput2(resample->GetOutput()); caster->SetInput(checker->GetOutput()); writer->SetInput(caster->GetOutput()); // Before registration TransformType::Pointer identityTransform = TransformType::New(); identityTransform->SetIdentity(); resample->SetTransform(identityTransform); if (argc > 4) { writer->SetFileName(argv[4]); writer->Update(); } // After registration resample->SetTransform(finalTransform); if (argc > 5) { writer->SetFileName(argv[5]); writer->Update(); } // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{ImageRegistration2Output.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration2CheckerboardBefore.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration2CheckerboardAfter.eps} // \itkcaption[Multi-Modality Registration outputs]{Mapped moving image (left) // and composition of fixed and moving images before (center) and after // (right) registration.} // \label{fig:ImageRegistration2Output} // \end{figure} // // The moving image after resampling is presented on the left // side of Figure \ref{fig:ImageRegistration2Output}. The center and right // figures present a checkerboard composite of the fixed and // moving images before and after registration. Since the real // deformation between the 2 images is not simply a shift, some // registration errors remain, but the left part of the images is // correctly registered. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Registration/ImageRegistration5.cxx000066400000000000000000000572041301006202600241040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // INPUTS: {QB_SuburbRotated10.png} // OUTPUTS: {ImageRegistration5Output.png} // OUTPUTS: {ImageRegistration5DifferenceBefore.png} // OUTPUTS: {ImageRegistration5DifferenceAfter.png} // 0.1 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // INPUTS: {QB_SuburbR10X13Y17.png} // OUTPUTS: {ImageRegistration5Output2.png} // OUTPUTS: {ImageRegistration5DifferenceBefore2.png} // OUTPUTS: {ImageRegistration5DifferenceAfter2.png} // 1.0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{itk}{CenteredRigid2DTransform} // for performing rigid registration in $2D$. The example code is for the // most part identical to that presented in Section // \ref{sec:IntroductionImageRegistration}. The main difference is the use // of the CenteredRigid2DTransform here instead of the // \doxygen{itk}{TranslationTransform}. // // \index{itk::CenteredRigid2DTransform} // // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" #include "itkImageRegistrationMethod.h" #include "itkMeanSquaresImageToImageMetric.h" #include "itkRegularStepGradientDescentOptimizer.h" #include "otbImage.h" #include "itkMeanImageFilter.h" // Software Guide : BeginLatex // // In addition to the headers included in previous examples, the // following header must also be included. // // \index{itk::CenteredRigid2DTransform!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkCenteredRigid2DTransform.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkResampleImageFilter.h" #include "itkSubtractImageFilter.h" #include "itkRescaleIntensityImageFilter.h" // The following section of code implements a Command observer // that will monitor the evolution of the registration process. // #include "itkCommand.h" class CommandIterationUpdate : public itk::Command { public: typedef CommandIterationUpdate Self; typedef itk::Command Superclass; typedef itk::SmartPointer Pointer; itkNewMacro(Self); protected: CommandIterationUpdate() {} public: typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef const OptimizerType * OptimizerPointer; void Execute(itk::Object *caller, const itk::EventObject& event) ITK_OVERRIDE { Execute((const itk::Object *) caller, event); } void Execute(const itk::Object * object, const itk::EventObject& event) ITK_OVERRIDE { OptimizerPointer optimizer = dynamic_cast(object); if (!itk::IterationEvent().CheckEvent(&event)) { return; } std::cout << optimizer->GetCurrentIteration() << " "; std::cout << optimizer->GetValue() << " "; std::cout << optimizer->GetCurrentPosition() << std::endl; } }; int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " fixedImageFile movingImageFile "; std::cerr << " outputImagefile [differenceAfterRegistration] "; std::cerr << " [differenceBeforeRegistration] "; std::cerr << " [initialStepLength] " << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image FixedImageType; typedef otb::Image MovingImageType; // Software Guide : BeginLatex // // The transform type is instantiated using the code below. The only // template parameter for this class is the representation type of the // space coordinates. // // \index{itk::CenteredRigid2DTransform!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CenteredRigid2DTransform TransformType; // Software Guide : EndCodeSnippet typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef itk::MeanSquaresImageToImageMetric MetricType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef itk::ImageRegistrationMethod RegistrationType; MetricType::Pointer metric = MetricType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); registration->SetMetric(metric); registration->SetOptimizer(optimizer); registration->SetInterpolator(interpolator); // Software Guide : BeginLatex // // The transform object is constructed below and passed to the registration // method. // // \index{itk::CenteredRigid2DTransform!New()} // \index{itk::CenteredRigid2DTransform!Pointer} // \index{itk::RegistrationMethod!SetTransform()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet TransformType::Pointer transform = TransformType::New(); registration->SetTransform(transform); // Software Guide : EndCodeSnippet typedef otb::ImageFileReader FixedImageReaderType; typedef otb::ImageFileReader MovingImageReaderType; FixedImageReaderType::Pointer fixedImageReader = FixedImageReaderType::New(); MovingImageReaderType::Pointer movingImageReader = MovingImageReaderType::New(); fixedImageReader->SetFileName(argv[1]); movingImageReader->SetFileName(argv[2]); // Software Guide : BeginLatex // // Since we are working with high resolution images and expected // shifts are larger than the resolution, we will need to smooth // the images in order to avoid the optimizer to get stucked on // local minima. In order to do this, we will use a simple mean filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MeanImageFilter< FixedImageType, FixedImageType> FixedFilterType; typedef itk::MeanImageFilter< MovingImageType, MovingImageType> MovingFilterType; FixedFilterType::Pointer fixedFilter = FixedFilterType::New(); MovingFilterType::Pointer movingFilter = MovingFilterType::New(); FixedImageType::SizeType indexFRadius; indexFRadius[0] = 4; // radius along x indexFRadius[1] = 4; // radius along y fixedFilter->SetRadius(indexFRadius); MovingImageType::SizeType indexMRadius; indexMRadius[0] = 4; // radius along x indexMRadius[1] = 4; // radius along y movingFilter->SetRadius(indexMRadius); fixedFilter->SetInput(fixedImageReader->GetOutput()); movingFilter->SetInput(movingImageReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we can plug the output of the smoothing filters at the input // of the registration method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registration->SetFixedImage(fixedFilter->GetOutput()); registration->SetMovingImage(movingFilter->GetOutput()); // Software Guide : EndCodeSnippet fixedImageReader->Update(); registration->SetFixedImageRegion( fixedImageReader->GetOutput()->GetBufferedRegion()); // Software Guide : BeginLatex // // In this example, the input images are taken from readers. The code // below updates the readers in order to ensure that the image parameters // (size, origin and spacing) are valid when used to initialize the // transform. We intend to use the center of the fixed image as the // rotation center and then use the vector between the fixed image center // and the moving image center as the initial translation to be applied // after the rotation. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fixedImageReader->Update(); movingImageReader->Update(); // Software Guide : EndCodeSnippet typedef FixedImageType::SpacingType SpacingType; typedef FixedImageType::PointType OriginType; typedef FixedImageType::RegionType RegionType; typedef FixedImageType::SizeType SizeType; // Software Guide : BeginLatex // // The center of rotation is computed using the origin, size and spacing of // the fixed image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FixedImageType::Pointer fixedImage = fixedImageReader->GetOutput(); const SpacingType fixedSpacing = fixedImage->GetSpacing(); const OriginType fixedOrigin = fixedImage->GetOrigin(); const RegionType fixedRegion = fixedImage->GetLargestPossibleRegion(); const SizeType fixedSize = fixedRegion.GetSize(); TransformType::InputPointType centerFixed; centerFixed[0] = fixedOrigin[0] + fixedSpacing[0] * fixedSize[0] / 2.0; centerFixed[1] = fixedOrigin[1] + fixedSpacing[1] * fixedSize[1] / 2.0; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The center of the moving image is computed in a similar way. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MovingImageType::Pointer movingImage = movingImageReader->GetOutput(); const SpacingType movingSpacing = movingImage->GetSpacing(); const OriginType movingOrigin = movingImage->GetOrigin(); const RegionType movingRegion = movingImage->GetLargestPossibleRegion(); const SizeType movingSize = movingRegion.GetSize(); TransformType::InputPointType centerMoving; centerMoving[0] = movingOrigin[0] + movingSpacing[0] * movingSize[0] / 2.0; centerMoving[1] = movingOrigin[1] + movingSpacing[1] * movingSize[1] / 2.0; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The most straightforward method of initializing the transform parameters // is to configure the transform and then get its parameters with the // method \code{GetParameters()}. Here we initialize the transform by // passing the center of the fixed image as the rotation center with the // \code{SetCenter()} method. Then the translation is set as the vector // relating the center of the moving image to the center of the fixed // image. This last vector is passed with the method // \code{SetTranslation()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet transform->SetCenter(centerFixed); transform->SetTranslation(centerMoving - centerFixed); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's finally initialize the rotation with a zero angle. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet transform->SetAngle(0.0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we pass the current transform's parameters as the initial // parameters to be used when the registration process starts. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registration->SetInitialTransformParameters(transform->GetParameters()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Keeping in mind that the scale of units in rotation and translation is // quite different, we take advantage of the scaling functionality provided // by the optimizers. We know that the first element of the parameters array // corresponds to the angle that is measured in radians, while the other // parameters correspond to translations that are measured in the // units of the spacin (pixels in our case). // For this reason we use small factors in the scales associated with // translations and the coordinates of the rotation center . // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef OptimizerType::ScalesType OptimizerScalesType; OptimizerScalesType optimizerScales(transform->GetNumberOfParameters()); const double translationScale = 1.0 / 1000.0; optimizerScales[0] = 1.0; optimizerScales[1] = translationScale; optimizerScales[2] = translationScale; optimizerScales[3] = translationScale; optimizerScales[4] = translationScale; optimizer->SetScales(optimizerScales); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we set the normal parameters of the optimization method. In this // case we are using an \doxygen{itk}{RegularStepGradientDescentOptimizer}. // Below, we define the optimization parameters like the relaxation factor, // initial step length, minimal step length and number of iterations. These // last two act as stopping criteria for the optimization. // // \index{Regular\-Step\-Gradient\-Descent\-Optimizer!SetRelaxationFactor()} // \index{Regular\-Step\-Gradient\-Descent\-Optimizer!SetMaximumStepLength()} // \index{Regular\-Step\-Gradient\-Descent\-Optimizer!SetMinimumStepLength()} // \index{Regular\-Step\-Gradient\-Descent\-Optimizer!SetNumberOfIterations()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double initialStepLength = 0.1; // Software Guide : EndCodeSnippet if (argc > 6) { initialStepLength = atof(argv[6]); } // Software Guide : BeginCodeSnippet optimizer->SetRelaxationFactor(0.6); optimizer->SetMaximumStepLength(initialStepLength); optimizer->SetMinimumStepLength(0.001); optimizer->SetNumberOfIterations(200); // Software Guide : EndCodeSnippet // Create the Command observer and register it with the optimizer. // CommandIterationUpdate::Pointer observer = CommandIterationUpdate::New(); optimizer->AddObserver(itk::IterationEvent(), observer); try { registration->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } OptimizerType::ParametersType finalParameters = registration->GetLastTransformParameters(); const double finalAngle = finalParameters[0]; const double finalRotationCenterX = finalParameters[1]; const double finalRotationCenterY = finalParameters[2]; const double finalTranslationX = finalParameters[3]; const double finalTranslationY = finalParameters[4]; const unsigned int numberOfIterations = optimizer->GetCurrentIteration(); const double bestValue = optimizer->GetValue(); // Print out results // const double finalAngleInDegrees = finalAngle * 45.0 / atan(1.0); std::cout << "Result = " << std::endl; std::cout << " Angle (radians) = " << finalAngle << std::endl; std::cout << " Angle (degrees) = " << finalAngleInDegrees << std::endl; std::cout << " Center X = " << finalRotationCenterX << std::endl; std::cout << " Center Y = " << finalRotationCenterY << std::endl; std::cout << " Translation X = " << finalTranslationX << std::endl; std::cout << " Translation Y = " << finalTranslationY << std::endl; std::cout << " Iterations = " << numberOfIterations << std::endl; std::cout << " Metric value = " << bestValue << std::endl; // Software Guide : BeginLatex // // Let's execute this example over two of the images provided in // \code{Examples/Data}: // // \begin{itemize} // \item \code{QB\_Suburb.png} // \item \code{QB\_SuburbRotated10.png} // \end{itemize} // // The second image is the result of intentionally rotating the first image // by $10$ degrees around the geometrical center of the image. Both images // have unit-spacing and are shown in Figure // \ref{fig:FixedMovingImageRegistration5}. The registration takes $21$ // iterations and produces the results: // // \begin{center} // \begin{verbatim} // [0.176168, 134.515, 103.011, -0.00182313, 0.0717891] // \end{verbatim} // \end{center} // // These results are interpreted as // // \begin{itemize} // \item Angle = $0.176168$ radians // \item Center = $( 134.515 , 103.011 )$ pixels // \item Translation = $( -0.00182313, 0.0717891 )$ pixels // \end{itemize} // // As expected, these values match the misalignment intentionally introduced // into the moving image quite well, since $10$ degrees is about $0.174532$ // radians. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{QB_SuburbRotated10.eps} // \itkcaption[Rigid2D Registration input images]{Fixed and moving images // are provided as input to the registration method using the CenteredRigid2D // transform.} // \label{fig:FixedMovingImageRegistration5} // \end{figure} // // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{ImageRegistration5Output.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration5DifferenceBefore.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration5DifferenceAfter.eps} // \itkcaption[Rigid2D Registration output images]{Resampled moving image // (left). Differences between the fixed and moving images, before (center) // and after (right) registration using the CenteredRigid2D transform.} // \label{fig:ImageRegistration5Outputs} // \end{figure} // // Figure \ref{fig:ImageRegistration5Outputs} shows from left to right the // resampled moving image after registration, the difference between fixed // and moving images before registration, and the difference between fixed // and resampled moving image after registration. It can be seen from the // last difference image that the rotational component has been solved but // that a small centering misalignment persists. // // Software Guide : EndLatex typedef itk::ResampleImageFilter< MovingImageType, FixedImageType> ResampleFilterType; TransformType::Pointer finalTransform = TransformType::New(); finalTransform->SetParameters(finalParameters); ResampleFilterType::Pointer resample = ResampleFilterType::New(); resample->SetTransform(finalTransform); resample->SetInput(movingImageReader->GetOutput()); resample->SetSize(fixedImage->GetLargestPossibleRegion().GetSize()); resample->SetOutputOrigin(fixedImage->GetOrigin()); resample->SetOutputSpacing(fixedImage->GetSpacing()); resample->SetDefaultPixelValue(100); typedef otb::ImageFileWriter WriterFixedType; WriterFixedType::Pointer writer = WriterFixedType::New(); writer->SetFileName(argv[3]); writer->SetInput(resample->GetOutput()); try { writer->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "ExceptionObject while writing the resampled image !" << std::endl; std::cerr << excp << std::endl; return EXIT_FAILURE; } typedef otb::Image DifferenceImageType; typedef itk::SubtractImageFilter< FixedImageType, FixedImageType, DifferenceImageType> DifferenceFilterType; DifferenceFilterType::Pointer difference = DifferenceFilterType::New(); typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter< DifferenceImageType, OutputImageType> RescalerType; RescalerType::Pointer intensityRescaler = RescalerType::New(); intensityRescaler->SetOutputMinimum(0); intensityRescaler->SetOutputMaximum(255); difference->SetInput1(fixedImageReader->GetOutput()); difference->SetInput2(resample->GetOutput()); resample->SetDefaultPixelValue(1); intensityRescaler->SetInput(difference->GetOutput()); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(intensityRescaler->GetOutput()); try { // Compute the difference image between the // fixed and moving image after registration. if (argc > 4) { writer2->SetFileName(argv[5]); writer2->Update(); } // Compute the difference image between the // fixed and resampled moving image after registration. TransformType::Pointer identityTransform = TransformType::New(); identityTransform->SetIdentity(); resample->SetTransform(identityTransform); if (argc > 5) { writer2->SetFileName(argv[4]); writer2->Update(); } } catch (itk::ExceptionObject& excp) { std::cerr << "Error while writing difference images" << std::endl; std::cerr << excp << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // Let's now consider the case in which rotations and translations are // present in the initial registration, as in the following pair // of images: // // \begin{itemize} // \item \code{QB\_Suburb.png} // \item \code{QB\_SuburbR10X13Y17.png} // \end{itemize} // // The second image is the result of intentionally rotating the first image // by $10$ degrees and then translating it $13$ pixels in $X$ and // $17$ pixels in $Y$. // Both images have unit-spacing and are shown in Figure // \ref{fig:FixedMovingImageRegistration5b}. In order to accelerate // convergence it is convenient to use a larger step length as shown here. // // \code{optimizer->SetMaximumStepLength( 1.0 ); } // // The registration now takes $34$ iterations and produces the following // results: // // \begin{center} // \begin{verbatim} // [0.176125, 135.553, 102.159, -11.9102, -15.8045] // \end{verbatim} // \end{center} // // These parameters are interpreted as // // \begin{itemize} // \item Angle = $0.176125$ radians // \item Center = $( 135.553 , 102.159 )$ millimeters // \item Translation = $( -11.9102 , -15.8045 )$ millimeters // \end{itemize} // // These values approximately match the initial misalignment intentionally // introduced into the moving image, since $10$ degrees is about $0.174532$ // radians. The horizontal translation is well resolved while the vertical // translation ends up being off by about one millimeter. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{QB_SuburbR10X13Y17.eps} // \itkcaption[Rigid2D Registration input images]{Fixed and moving images // provided as input to the registration method using the CenteredRigid2D // transform.} // \label{fig:FixedMovingImageRegistration5b} // \end{figure} // // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{ImageRegistration5Output2.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration5DifferenceBefore2.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration5DifferenceAfter2.eps} // \itkcaption[Rigid2D Registration output images]{Resampled moving image // (left). Differences between the fixed and moving images, before (center) // and after (right) registration with the CenteredRigid2D transform.} // \label{fig:ImageRegistration5Outputs2} // \end{figure} // // Figure \ref{fig:ImageRegistration5Outputs2} shows the output of the // registration. The rightmost image of this figure shows the difference // between the fixed image and the resampled moving image after registration. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Registration/ImageRegistration9.cxx000066400000000000000000000511211301006202600241000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // INPUTS: {QB_SuburbR10X13Y17.png} // OUTPUTS: {ImageRegistration9Output.png} // OUTPUTS: {ImageRegistration9DifferenceBefore.png} // OUTPUTS: {ImageRegistration9DifferenceAfter.png} // 1.0 300 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the \doxygen{itk}{AffineTransform} // for performing registration. The example code is, for the most part, // identical to previous ones. // The main difference is the use of the AffineTransform here instead of the // \doxygen{itk}{CenteredRigid2DTransform}. We will focus on the most // relevant changes in the current code and skip the basic elements already // explained in previous examples. // // \index{itk::AffineTransform} // // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" #include "itkImageRegistrationMethod.h" #include "itkMeanSquaresImageToImageMetric.h" #include "itkRegularStepGradientDescentOptimizer.h" #include "otbImage.h" #include "itkCenteredTransformInitializer.h" // Software Guide : BeginLatex // // Let's start by including the header file of the AffineTransform. // // \index{itk::AffineTransform!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkAffineTransform.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkResampleImageFilter.h" #include "itkCastImageFilter.h" #include "itkSubtractImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkMeanImageFilter.h" // // The following piece of code implements an observer // that will monitor the evolution of the registration process. // #include "itkCommand.h" class CommandIterationUpdate : public itk::Command { public: typedef CommandIterationUpdate Self; typedef itk::Command Superclass; typedef itk::SmartPointer Pointer; itkNewMacro(Self); protected: CommandIterationUpdate() {} public: typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef const OptimizerType * OptimizerPointer; void Execute(itk::Object *caller, const itk::EventObject& event) ITK_OVERRIDE { Execute((const itk::Object *) caller, event); } void Execute(const itk::Object * object, const itk::EventObject& event) ITK_OVERRIDE { OptimizerPointer optimizer = dynamic_cast(object); if (!itk::IterationEvent().CheckEvent(&event)) { return; } std::cout << optimizer->GetCurrentIteration() << " "; std::cout << optimizer->GetValue() << " "; std::cout << optimizer->GetCurrentPosition(); // Print the angle for the trace plot vnl_matrix p(2, 2); p[0][0] = (double) optimizer->GetCurrentPosition()[0]; p[0][1] = (double) optimizer->GetCurrentPosition()[1]; p[1][0] = (double) optimizer->GetCurrentPosition()[2]; p[1][1] = (double) optimizer->GetCurrentPosition()[3]; vnl_svd svd(p); vnl_matrix r(2, 2); r = svd.U() * vnl_transpose(svd.V()); double angle = asin(r[1][0]); std::cout << " AffineAngle: " << angle * 45.0 / atan(1.0) << std::endl; } }; int main(int argc, char *argv[]) { if (argc < 4) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " fixedImageFile movingImageFile " << std::endl; std::cerr << " outputImagefile [differenceBeforeRegistration] " << std::endl; std::cerr << " [differenceAfterRegistration] " << std::endl; std::cerr << " [stepLength] [maxNumberOfIterations] " << std::endl; return 1; } // Software Guide : BeginLatex // // We define then the types of the images to be registered. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image FixedImageType; typedef otb::Image MovingImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The transform type is instantiated using the code below. The template // parameters of this class are the representation type of the space // coordinates and the space dimension. // // \index{itk::AffineTransform!Instantiation} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::AffineTransform< double, Dimension> TransformType; // Software Guide : EndCodeSnippet typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef itk::MeanSquaresImageToImageMetric< FixedImageType, MovingImageType> MetricType; typedef itk::LinearInterpolateImageFunction< MovingImageType, double> InterpolatorType; typedef itk::ImageRegistrationMethod< FixedImageType, MovingImageType> RegistrationType; MetricType::Pointer metric = MetricType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); registration->SetMetric(metric); registration->SetOptimizer(optimizer); registration->SetInterpolator(interpolator); // Software Guide : BeginLatex // // The transform object is constructed below and passed to the registration // method. // // \index{itk::AffineTransform!New()} // \index{itk::AffineTransform!Pointer} // \index{itk::RegistrationMethod!SetTransform()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet TransformType::Pointer transform = TransformType::New(); registration->SetTransform(transform); // Software Guide : EndCodeSnippet typedef otb::ImageFileReader FixedImageReaderType; typedef otb::ImageFileReader MovingImageReaderType; FixedImageReaderType::Pointer fixedImageReader = FixedImageReaderType::New(); MovingImageReaderType::Pointer movingImageReader = MovingImageReaderType::New(); fixedImageReader->SetFileName(argv[1]); movingImageReader->SetFileName(argv[2]); // Software Guide : BeginLatex // // Since we are working with high resolution images and expected // shifts are larger than the resolution, we will need to smooth // the images in order to avoid the optimizer to get stucked on // local minima. In order to do this, we will use a simple mean filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::MeanImageFilter< FixedImageType, FixedImageType> FixedFilterType; typedef itk::MeanImageFilter< MovingImageType, MovingImageType> MovingFilterType; FixedFilterType::Pointer fixedFilter = FixedFilterType::New(); MovingFilterType::Pointer movingFilter = MovingFilterType::New(); FixedImageType::SizeType indexFRadius; indexFRadius[0] = 4; // radius along x indexFRadius[1] = 4; // radius along y fixedFilter->SetRadius(indexFRadius); MovingImageType::SizeType indexMRadius; indexMRadius[0] = 4; // radius along x indexMRadius[1] = 4; // radius along y movingFilter->SetRadius(indexMRadius); fixedFilter->SetInput(fixedImageReader->GetOutput()); movingFilter->SetInput(movingImageReader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we can plug the output of the smoothing filters at the input // of the registration method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registration->SetFixedImage(fixedFilter->GetOutput()); registration->SetMovingImage(movingFilter->GetOutput()); // Software Guide : EndCodeSnippet fixedImageReader->Update(); registration->SetFixedImageRegion( fixedImageReader->GetOutput()->GetBufferedRegion()); // Software Guide : BeginLatex // // In this example, we use the // \doxygen{itk}{CenteredTransformInitializer} helper class in order to compute // a reasonable value for the initial center of rotation and the // translation. The initializer is set to use the center of mass of each // image as the initial correspondence correction. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CenteredTransformInitializer< TransformType, FixedImageType, MovingImageType> TransformInitializerType; TransformInitializerType::Pointer initializer = TransformInitializerType::New(); initializer->SetTransform(transform); initializer->SetFixedImage(fixedImageReader->GetOutput()); initializer->SetMovingImage(movingImageReader->GetOutput()); initializer->MomentsOn(); initializer->InitializeTransform(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we pass the parameters of the current transform as the initial // parameters to be used when the registration process starts. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet registration->SetInitialTransformParameters( transform->GetParameters()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Keeping in mind that the scale of units in scaling, rotation and // translation are quite different, we take advantage of the scaling // functionality provided by the optimizers. We know that the first $N // \times N$ elements of the parameters array correspond to the rotation // matrix factor, the next $N$ correspond to the rotation center, and the // last $N$ are the components of the translation to be applied after // multiplication with the matrix is performed. // // Software Guide : EndLatex double translationScale = 1.0 / 1000.0; if (argc > 8) { translationScale = atof(argv[8]); } // Software Guide : BeginCodeSnippet typedef OptimizerType::ScalesType OptimizerScalesType; OptimizerScalesType optimizerScales(transform->GetNumberOfParameters()); optimizerScales[0] = 1.0; optimizerScales[1] = 1.0; optimizerScales[2] = 1.0; optimizerScales[3] = 1.0; optimizerScales[4] = translationScale; optimizerScales[5] = translationScale; optimizer->SetScales(optimizerScales); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also set the usual parameters of the optimization method. In this // case we are using an // \doxygen{itk}{RegularStepGradientDescentOptimizer}. Below, we define the // optimization parameters like initial step length, minimal step length // and number of iterations. These last two act as stopping criteria for // the optimization. // // Software Guide : EndLatex double steplength = 0.1; if (argc > 6) { steplength = atof(argv[6]); } unsigned int maxNumberOfIterations = 300; if (argc > 7) { maxNumberOfIterations = atoi(argv[7]); } // Software Guide : BeginCodeSnippet optimizer->SetMaximumStepLength(steplength); optimizer->SetMinimumStepLength(0.0001); optimizer->SetNumberOfIterations(maxNumberOfIterations); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also set the optimizer to do minimization by calling the // \code{MinimizeOn()} method. // // \index{itk::Regular\-Step\-Gradient\-Descent\-Optimizer!MinimizeOn()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet optimizer->MinimizeOn(); // Software Guide : EndCodeSnippet // Create the Command observer and register it with the optimizer. // CommandIterationUpdate::Pointer observer = CommandIterationUpdate::New(); optimizer->AddObserver(itk::IterationEvent(), observer); // Software Guide : BeginLatex // // Finally we trigger the execution of the registration method by calling // the \code{Update()} method. The call is placed in a \code{try/catch} // block in case any exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { registration->Update(); } catch (itk::ExceptionObject& err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return -1; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Once the optimization converges, we recover the parameters from the // registration method. This is done with the // \code{GetLastTransformParameters()} method. We can also recover the // final value of the metric with the \code{GetValue()} method and the // final number of iterations with the \code{GetCurrentIteration()} // method. // // \index{itk::RegistrationMethod!GetValue()} // \index{itk::RegistrationMethod!GetCurrentIteration()} // \index{itk::RegistrationMethod!GetLastTransformParameters()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OptimizerType::ParametersType finalParameters = registration->GetLastTransformParameters(); const double finalRotationCenterX = transform->GetCenter()[0]; const double finalRotationCenterY = transform->GetCenter()[1]; const double finalTranslationX = finalParameters[4]; const double finalTranslationY = finalParameters[5]; const unsigned int numberOfIterations = optimizer->GetCurrentIteration(); const double bestValue = optimizer->GetValue(); // Software Guide : EndCodeSnippet // Print out results // std::cout << "Result = " << std::endl; std::cout << " Center X = " << finalRotationCenterX << std::endl; std::cout << " Center Y = " << finalRotationCenterY << std::endl; std::cout << " Translation X = " << finalTranslationX << std::endl; std::cout << " Translation Y = " << finalTranslationY << std::endl; std::cout << " Iterations = " << numberOfIterations << std::endl; std::cout << " Metric value = " << bestValue << std::endl; //Compute the rotation angle and scaling from SVD of the matrix // \todo Find a way to figure out if the scales are along X or along Y. // VNL returns the eigenvalues ordered from largest to smallest. vnl_matrix p(2, 2); p[0][0] = (double) finalParameters[0]; p[0][1] = (double) finalParameters[1]; p[1][0] = (double) finalParameters[2]; p[1][1] = (double) finalParameters[3]; vnl_svd svd(p); vnl_matrix r(2, 2); r = svd.U() * vnl_transpose(svd.V()); double angle = asin(r[1][0]); std::cout << " Scale 1 = " << svd.W(0) << std::endl; std::cout << " Scale 2 = " << svd.W(1) << std::endl; std::cout << " Angle (degrees) = " << angle * 45.0 / atan(1.0) << std::endl; // Software Guide : BeginLatex // // Let's execute this example over two of the images provided in // \code{Examples/Data}: // // \begin{itemize} // \item \code{QB\_Suburb.png} // \item \code{QB\_SuburbR10X13Y17.png} // \end{itemize} // // The second image is the result of intentionally rotating the first // image by $10$ degrees and then translating by $(13, 17)$. Both images // have unit-spacing and are shown in Figure // \ref{fig:FixedMovingImageRegistration9}. We execute the code using the // following parameters: step length=1.0, translation scale= 0.0001 and // maximum number of iterations = 300. With these images and parameters // the registration takes $83$ iterations and produces // // \begin{center} // \begin{verbatim} // 20.2134 [0.983291, -0.173507, 0.174626, 0.983028, -12.1899, -16.0882] // \end{verbatim} // \end{center} // // These results are interpreted as // // \begin{itemize} // \item Iterations = 83 // \item Final Metric = 20.2134 // \item Center = $( 134.152, 104.067 )$ pixels // \item Translation = $( -12.1899, -16.0882 )$ pixels // \item Affine scales = $(0.999024, 0.997875)$ // \end{itemize} // // The second component of the matrix values is usually associated with // $\sin{\theta}$. We obtain the rotation through SVD of the affine // matrix. The value is $10.0401$ degrees, which is approximately the // intentional misalignment of $10.0$ degrees. // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{QB_SuburbR10X13Y17.eps} // \itkcaption[AffineTransform registration]{Fixed and moving images // provided as input to the registration method using the AffineTransform.} // \label{fig:FixedMovingImageRegistration9} // \end{figure} // // // \begin{figure} // \center // \includegraphics[width=0.32\textwidth]{ImageRegistration9Output.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration9DifferenceBefore.eps} // \includegraphics[width=0.32\textwidth]{ImageRegistration9DifferenceAfter.eps} // \itkcaption[AffineTransform output images]{The resampled moving image // (left), and the difference between the fixed and moving images before (center) // and after (right) registration with the // AffineTransform transform.} // \label{fig:ImageRegistration9Outputs} // \end{figure} // // Figure \ref{fig:ImageRegistration9Outputs} shows the output of the // registration. The right most image of this figure shows the squared // magnitude difference between the fixed image and the resampled // moving image. // Software Guide : EndLatex // The following code is used to dump output images to files. // They illustrate the final results of the registration. // We will resample the moving image and write out the difference image // before and after registration. We will also rescale the intensities of the // difference images, so that they look better! typedef itk::ResampleImageFilter< MovingImageType, FixedImageType> ResampleFilterType; TransformType::Pointer finalTransform = TransformType::New(); finalTransform->SetCenter(transform->GetCenter()); finalTransform->SetParameters(finalParameters); ResampleFilterType::Pointer resampler = ResampleFilterType::New(); resampler->SetTransform(finalTransform); resampler->SetInput(movingImageReader->GetOutput()); FixedImageType::Pointer fixedImage = fixedImageReader->GetOutput(); resampler->SetSize(fixedImage->GetLargestPossibleRegion().GetSize()); resampler->SetOutputOrigin(fixedImage->GetOrigin()); resampler->SetOutputSpacing(fixedImage->GetSpacing()); resampler->SetDefaultPixelValue(100); typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::CastImageFilter< FixedImageType, OutputImageType> CastFilterType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); CastFilterType::Pointer caster = CastFilterType::New(); writer->SetFileName(argv[3]); caster->SetInput(resampler->GetOutput()); writer->SetInput(caster->GetOutput()); writer->Update(); typedef itk::SubtractImageFilter< FixedImageType, FixedImageType, FixedImageType> DifferenceFilterType; DifferenceFilterType::Pointer difference = DifferenceFilterType::New(); difference->SetInput1(fixedImageReader->GetOutput()); difference->SetInput2(resampler->GetOutput()); WriterType::Pointer writer2 = WriterType::New(); typedef itk::RescaleIntensityImageFilter< FixedImageType, OutputImageType> RescalerType; RescalerType::Pointer intensityRescaler = RescalerType::New(); intensityRescaler->SetInput(difference->GetOutput()); intensityRescaler->SetOutputMinimum(0); intensityRescaler->SetOutputMaximum(255); writer2->SetInput(intensityRescaler->GetOutput()); resampler->SetDefaultPixelValue(1); // Compute the difference image between the // fixed and resampled moving image. if (argc > 5) { writer2->SetFileName(argv[5]); writer2->Update(); } typedef itk::IdentityTransform IdentityTransformType; IdentityTransformType::Pointer identity = IdentityTransformType::New(); // Compute the difference image between the // fixed and moving image before registration. if (argc > 4) { resampler->SetTransform(identity); writer2->SetFileName(argv[4]); writer2->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Examples/Registration/test/000077500000000000000000000000001301006202600206255ustar00rootroot00000000000000OTB-release-5.8/Examples/Registration/test/CMakeLists.txt000066400000000000000000000036111301006202600233660ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Registration) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME reTeImageRegistration1ExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/ImageRegistration1Output.png ${TEMP}/ImageRegistration1Output.png Execute $ ${INPUTDATA}/QB_Suburb.png ${INPUTDATA}/QB_Suburb13x17y.png ${TEMP}/ImageRegistration1Output.png ${TEMP}/ImageRegistration1DifferenceAfter.png ${TEMP}/ImageRegistration1DifferenceBefore.png ) otb_add_test(NAME reTeImageRegistration2ExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/ImageRegistration2Output.png ${TEMP}/ImageRegistration2Output.png Execute $ ${INPUTDATA}/RamsesROISmall.png ${INPUTDATA}/ADS40RoiSmall.png ${TEMP}/ImageRegistration2Output.png ${TEMP}/ImageRegistration2CheckerboardBefore.png ${TEMP}/ImageRegistration2CheckerboardAfter.png ) otb_add_test(NAME reTeImageRegistration5Cas1ExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/ImageRegistration5Output1.png ${TEMP}/ImageRegistration5Output1.png Execute $ ${INPUTDATA}/QB_Suburb.png ${INPUTDATA}/QB_SuburbRotated10.png ${TEMP}/ImageRegistration5Output1.png ${TEMP}/ImageRegistration5DifferenceBefore1.png ${TEMP}/ImageRegistration5DifferenceAfter1.png ) otb_add_test(NAME reTeImageRegistration5Cas2ExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/ImageRegistration5Output2.png ${TEMP}/ImageRegistration5Output2.png Execute $ ${INPUTDATA}/QB_Suburb.png ${INPUTDATA}/QB_SuburbR10X13Y17.png ${TEMP}/ImageRegistration5Output2.png ${TEMP}/ImageRegistration5DifferenceBefore2.png ${TEMP}/ImageRegistration5DifferenceAfter2.png ) OTB-release-5.8/Examples/Segmentation/000077500000000000000000000000001301006202600176315ustar00rootroot00000000000000OTB-release-5.8/Examples/Segmentation/CMakeLists.txt000066400000000000000000000033051301006202600223720ustar00rootroot00000000000000project(SegmentationExamples) add_executable(ConfidenceConnected ConfidenceConnected.cxx) target_link_libraries(ConfidenceConnected ${OTB_LIBRARIES}) add_executable(ConnectedThresholdImageFilter ConnectedThresholdImageFilter.cxx) target_link_libraries(ConnectedThresholdImageFilter ${OTB_LIBRARIES}) add_executable(FastMarchingImageFilter FastMarchingImageFilter.cxx) target_link_libraries(FastMarchingImageFilter ${OTB_LIBRARIES}) add_executable(IsolatedConnectedImageFilter IsolatedConnectedImageFilter.cxx) target_link_libraries(IsolatedConnectedImageFilter ${OTB_LIBRARIES}) add_executable(LabelizeNeighborhoodConnectedImageFilter LabelizeNeighborhoodConnectedImageFilter.cxx) target_link_libraries(LabelizeNeighborhoodConnectedImageFilter ${OTB_LIBRARIES}) add_executable(NeighborhoodConnectedImageFilter NeighborhoodConnectedImageFilter.cxx) target_link_libraries(NeighborhoodConnectedImageFilter ${OTB_LIBRARIES}) add_executable(OtsuMultipleThresholdImageFilter OtsuMultipleThresholdImageFilter.cxx) target_link_libraries(OtsuMultipleThresholdImageFilter ${OTB_LIBRARIES}) add_executable(OtsuThresholdImageFilter OtsuThresholdImageFilter.cxx) target_link_libraries(OtsuThresholdImageFilter ${OTB_LIBRARIES}) if(OTBMathParser_LOADED) add_executable(StreamingMeanShiftSegmentation StreamingMeanShiftSegmentation.cxx) target_link_libraries(StreamingMeanShiftSegmentation ${OTB_LIBRARIES}) endif() add_executable(VectorConfidenceConnected VectorConfidenceConnected.cxx) target_link_libraries(VectorConfidenceConnected ${OTB_LIBRARIES}) add_executable(WatershedSegmentation WatershedSegmentation.cxx) target_link_libraries(WatershedSegmentation ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Segmentation/ConfidenceConnected.cxx000066400000000000000000000331751301006202600242460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ConfidenceConnectedOutput1.png} // 110 38 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ConfidenceConnectedOutput2.png} // 118 100 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ConfidenceConnectedOutput3.png} // 169 146 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // \index{itk::FloodFillIterator!In Region Growing} // \index{itk::ConfidenceConnectedImageFilter} // \index{itk::ConfidenceConnectedImageFilter!header} // // The following example illustrates the use of the // \doxygen{itk}{ConfidenceConnectedImageFilter}. The criterion used by the // ConfidenceConnectedImageFilter is based on simple statistics of the // current region. First, the algorithm computes the mean and standard // deviation of intensity values for all the pixels currently included in the // region. A user-provided factor is used to multiply the standard deviation // and define a range around the mean. Neighbor pixels whose intensity values // fall inside the range are accepted and included in the region. When no // more neighbor pixels are found that satisfy the criterion, the algorithm // is considered to have finished its first iteration. At that point, the // mean and standard deviation of the intensity levels are recomputed using // all the pixels currently included in the region. This mean and standard // deviation defines a new intensity range that is used to visit current // region neighbors and evaluate whether their intensity falls inside the // range. This iterative process is repeated until no more pixels are added // or the maximum number of iterations is reached. The following equation // illustrates the inclusion criterion used by this filter, // // \begin{equation} // I(\mathbf{X}) \in [ m - f \sigma , m + f \sigma ] // \end{equation} // // where $m$ and $\sigma$ are the mean and standard deviation of the region // intensities, $f$ is a factor defined by the user, $I()$ is the image and // $\mathbf{X}$ is the position of the particular neighbor pixel being // considered for inclusion in the region. // // Let's look at the minimal code required to use this algorithm. First, the // following header defining the \doxygen{itk}{ConfidenceConnectedImageFilter} class // must be included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkConfidenceConnectedImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" // Software Guide : BeginLatex // // Noise present in the image can reduce the capacity of this filter to grow // large regions. When faced with noisy images, it is usually convenient to // pre-process the image by using an edge-preserving smoothing filter. In this particular example we use the // \doxygen{itk}{CurvatureFlowImageFilter}, hence we need to include its header // file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkCurvatureFlowImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { if (argc < 5) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage outputImage seedX seedY " << std::endl; return 1; } // Software Guide : BeginLatex // // We now define the image type using a pixel type and a particular // dimension. In this case the \code{float} type is used for the pixels due // to the requirements of the smoothing filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; const unsigned int Dimension = 2; typedef otb::Image InternalImageType; // Software Guide : EndCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::CastImageFilter CastingFilterType; CastingFilterType::Pointer caster = CastingFilterType::New(); // We instantiate reader and writer types // typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // The smoothing filter type is instantiated using the image type as // a template parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CurvatureFlowImageFilter CurvatureFlowImageFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next the filter is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet CurvatureFlowImageFilterType::Pointer smoothing = CurvatureFlowImageFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now declare the type of the region growing filter. In this case it is // the ConfidenceConnectedImageFilter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ConfidenceConnectedImageFilter ConnectedFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we construct one filter of this class using the \code{New()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConnectedFilterType::Pointer confidenceConnected = ConnectedFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now it is time to create a simple, linear pipeline. A file reader is // added at the beginning of the pipeline and a cast filter and writer are // added at the end. The cast filter is required here to convert // \code{float} pixel types to integer types since only a few image file // formats support \code{float} types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetInput(reader->GetOutput()); confidenceConnected->SetInput(smoothing->GetOutput()); caster->SetInput(confidenceConnected->GetOutput()); writer->SetInput(caster->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The CurvatureFlowImageFilter requires defining two parameters. The // following are typical values. However they may have to // be adjusted depending on the amount of noise present in the input // image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetNumberOfIterations(5); smoothing->SetTimeStep(0.125); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The ConfidenceConnectedImageFilter requires defining two parameters. // First, the factor $f$ that the defines how large the range of // intensities will be. Small values of the multiplier will restrict the // inclusion of pixels to those having very similar intensities to those // in the current region. Larger values of the multiplier will relax the // accepting condition and will result in more generous growth of the // region. Values that are too large will cause the region to grow into // neighboring regions that may actually belong to separate // structures. // // \index{itk::ConfidenceConnectedImageFilter!SetMultiplier()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet confidenceConnected->SetMultiplier(2.5); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The number of iterations is specified based on the homogeneity of the // intensities of the object to be segmented. Highly // homogeneous regions may only require a couple of iterations. Regions // with ramp effect, may // require more iterations. In practice, it seems to be more important to // carefully select the multiplier factor than the number of iterations. // However, keep in mind that there is no reason to assume that this // algorithm should converge to a stable region. It is possible that by // letting the algorithm run for more iterations the region will end up // engulfing the entire image. // // \index{itk::ConfidenceConnectedImageFilter!SetNumberOfIterations()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet confidenceConnected->SetNumberOfIterations(5); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output of this filter is a binary image with zero-value pixels // everywhere except on the extracted region. The intensity value to be // set inside the region is selected with the method // \code{SetReplaceValue()} // // \index{itk::ConfidenceConnectedImageFilter!SetReplaceValue()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet confidenceConnected->SetReplaceValue(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The initialization of the algorithm requires the user to provide a seed // point. It is convenient to select this point to be placed in a // \emph{typical} region of the structure to be segmented. A // small neighborhood around the seed point will be used to compute the // initial mean and standard deviation for the inclusion criterion. The // seed is passed in the form of a \doxygen{itk}{Index} to the \code{SetSeed()} // method. // // \index{itk::ConfidenceConnectedImageFilter!SetSeed()} // \index{itk::ConfidenceConnectedImageFilter!SetInitialNeighborhoodRadius()} // // Software Guide : EndLatex InternalImageType::IndexType index; index[0] = atoi(argv[3]); index[1] = atoi(argv[4]); // Software Guide : BeginCodeSnippet confidenceConnected->SetSeed(index); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The size of the initial neighborhood around the seed is defined with the // method \code{SetInitialNeighborhoodRadius()}. The neighborhood will be // defined as an $N$-dimensional rectangular region with $2r+1$ pixels on // the side, where $r$ is the value passed as initial neighborhood radius. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet confidenceConnected->SetInitialNeighborhoodRadius(2); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is recommended to place update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's now run this example using as input the image // \code{QB\_Suburb.png} provided in the directory // \code{Examples/Data}. We can easily segment // structures by providing seeds in the appropriate locations. For example // // \begin{table} // \begin{center} // \begin{tabular}{|l|c|c|c|c|} // \hline // Structure & Seed Index & Lower & Upper & Output Image \\ \hline // Road & $(110, 38)$ & 50 & 100 & Second from left in Figure \ref{fig:ConnectedThresholdOutput} \\ \hline // Shadow & $(118, 100)$ & 0 & 10 & Third from left in Figure \ref{fig:ConnectedThresholdOutput} \\ \hline // Building & $(169, 146)$ & 220 & 255 & Fourth from left in Figure \ref{fig:ConnectedThresholdOutput} \\ \hline // \end{tabular} // \end{center} // \itkcaption[ConnectedThreshold example parameters]{Parameters used for // segmenting some structures shown in // Figure~\ref{fig:ConnectedThresholdOutput} with the filter // \doxygen{itk}{ConnectedThresholdImageFilter}.\label{tab:ConfidenceConnectedThresholdOutput}} // \end{table} // // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.24\textwidth]{ConfidenceConnectedOutput1.eps} // \includegraphics[width=0.24\textwidth]{ConfidenceConnectedOutput2.eps} // \includegraphics[width=0.24\textwidth]{ConfidenceConnectedOutput3.eps} // \itkcaption[ConfidenceConnected segmentation results]{Segmentation results // for the ConfidenceConnected filter for various seed points.} // \label{fig:ConfidenceConnectedOutput} // \end{figure} // // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/ConnectedThresholdImageFilter.cxx000066400000000000000000000307221301006202600262510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ConnectedThresholdOutput1.png} // 110 38 50 100 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ConnectedThresholdOutput2.png} // 118 100 0 10 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {ConnectedThresholdOutput3.png} // 169 146 220 255 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following example illustrates the use of the // \doxygen{itk}{ConnectedThresholdImageFilter}. This filter uses the // flood fill iterator. Most of the algorithmic complexity of a region // growing method comes from visiting neighboring pixels. The flood // fill iterator assumes this responsibility and greatly simplifies // the implementation of the region growing algorithm. Thus the // algorithm is left to establish a criterion to decide whether a // particular pixel should be included in the current region or not. // // \index{itk::FloodFillIterator!In Region Growing} // \index{itk::ConnectedThresholdImageFilter} // \index{itk::ConnectedThresholdImageFilter!header} // // The criterion used by the ConnectedThresholdImageFilter is based on an // interval of intensity values provided by the user. Values of lower and // upper threshold should be provided. The region growing algorithm includes // those pixels whose intensities are inside the interval. // // \begin{equation} // I(\mathbf{X}) \in [ \mbox{lower}, \mbox{upper} ] // \end{equation} // // Let's look at the minimal code required to use this algorithm. First, the // following header defining the ConnectedThresholdImageFilter class // must be included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkConnectedThresholdImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" // Software Guide : BeginLatex // // Noise present in the image can reduce the capacity of this filter to grow // large regions. When faced with noisy images, it is usually convenient to // pre-process the image by using an edge-preserving smoothing filter. In this particular example we use the // \doxygen{itk}{CurvatureFlowImageFilter}, hence we need to include its header // file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkCurvatureFlowImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { if (argc < 7) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage outputImage seedX seedY lowerThreshold upperThreshold" << std::endl; return 1; } // Software Guide : BeginLatex // // We declare the image type based on a particular pixel type and // dimension. In this case the \code{float} type is used for the pixels // due to the requirements of the smoothing filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; const unsigned int Dimension = 2; typedef otb::Image InternalImageType; // Software Guide : EndCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::CastImageFilter CastingFilterType; CastingFilterType::Pointer caster = CastingFilterType::New(); // We instantiate reader and writer types // typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // // The smoothing filter is instantiated using the image type as // a template parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CurvatureFlowImageFilter CurvatureFlowImageFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then the filter is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet CurvatureFlowImageFilterType::Pointer smoothing = CurvatureFlowImageFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now declare the type of the region growing filter. In this case it is // the ConnectedThresholdImageFilter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ConnectedThresholdImageFilter ConnectedFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then we construct one filter of this class using the \code{New()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConnectedFilterType::Pointer connectedThreshold = ConnectedFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now it is time to connect a simple, linear pipeline. A file reader is // added at the beginning of the pipeline and a cast filter and writer // are added at the end. The cast filter is required to convert // \code{float} pixel types to integer types since only a few image file // formats support \code{float} types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetInput(reader->GetOutput()); connectedThreshold->SetInput(smoothing->GetOutput()); caster->SetInput(connectedThreshold->GetOutput()); writer->SetInput(caster->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The CurvatureFlowImageFilter requires a couple of parameters to // be defined. The following are typical values, however // they may have to be adjusted depending on the amount of noise present in // the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetNumberOfIterations(5); smoothing->SetTimeStep(0.125); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The ConnectedThresholdImageFilter has two main parameters to be // defined. They are the lower and upper thresholds of the interval in // which intensity values should fall in order to be included in the // region. Setting these two values too close will not allow enough // flexibility for the region to grow. Setting them too far apart will // result in a region that engulfs the image. // // \index{itk::ConnectedThresholdImageFilter!SetUpper()} // \index{itk::ConnectedThresholdImageFilter!SetLower()} // // Software Guide : EndLatex const InternalPixelType lowerThreshold = atof(argv[5]); const InternalPixelType upperThreshold = atof(argv[6]); // Software Guide : BeginCodeSnippet connectedThreshold->SetLower(lowerThreshold); connectedThreshold->SetUpper(upperThreshold); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output of this filter is a binary image with zero-value pixels // everywhere except on the extracted region. The intensity value set // inside the region is selected with the method \code{SetReplaceValue()} // // \index{itk::ConnectedThresholdImageFilter!SetReplaceValue()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet connectedThreshold->SetReplaceValue( itk::NumericTraits::max()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The initialization of the algorithm requires the user to provide a seed // point. It is convenient to select this point to be placed in a // \emph{typical} region of the structure to be segmented. The // seed is passed in the form of a \doxygen{itk}{Index} to the \code{SetSeed()} // method. // // \index{itk::ConnectedThresholdImageFilter!SetSeed()} // // Software Guide : EndLatex InternalImageType::IndexType index; index[0] = atoi(argv[3]); index[1] = atoi(argv[4]); // Software Guide : BeginCodeSnippet connectedThreshold->SetSeed(index); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is usually wise to put update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's run this example using as input the image // \code{QB\_Suburb.png} provided in the directory // \code{Examples/Data}. We can easily segment the major // structures by providing seeds in the appropriate locations and defining // values for the lower and upper thresholds. // Figure~\ref{fig:ConnectedThresholdOutput} illustrates several examples of // segmentation. The parameters used are presented in // Table~\ref{tab:ConnectedThresholdOutput}. // // \begin{table} // \begin{center} // \begin{tabular}{|l|c|c|c|c|} // \hline // Structure & Seed Index & Lower & Upper & Output Image \\ \hline // Road & $(110, 38)$ & 50 & 100 & Second from left in Figure \ref{fig:ConnectedThresholdOutput} \\ \hline // Shadow & $(118, 100)$ & 0 & 10 & Third from left in Figure \ref{fig:ConnectedThresholdOutput} \\ \hline // Building & $(169, 146)$ & 220 & 255 & Fourth from left in Figure \ref{fig:ConnectedThresholdOutput} \\ \hline // \end{tabular} // \end{center} // \itkcaption[ConnectedThreshold example parameters]{Parameters used for // segmenting some structures shown in // Figure~\ref{fig:ConnectedThresholdOutput} with the filter // \doxygen{itk}{ConnectedThresholdImageFilter}.\label{tab:ConnectedThresholdOutput}} // \end{table} // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.24\textwidth]{ConnectedThresholdOutput1.eps} // \includegraphics[width=0.24\textwidth]{ConnectedThresholdOutput2.eps} // \includegraphics[width=0.24\textwidth]{ConnectedThresholdOutput3.eps} // \itkcaption[ConnectedThreshold segmentation results]{Segmentation results // for the ConnectedThreshold filter for various seed points.} // \label{fig:ConnectedThresholdOutput} // \end{figure} // // Notice that some objects are not being completely segmented. This // illustrates the vulnerability of the region growing methods when the // structures to be segmented do not have a homogeneous // statistical distribution over the image space. You may want to // experiment with different values of the lower and upper thresholds to // verify how the accepted region will extend. // // Another option for segmenting regions is to take advantage of the // functionality provided by the ConnectedThresholdImageFilter for // managing multiple seeds. The seeds can be passed one by one to the // filter using the \code{AddSeed()} method. You could imagine a user // interface in which an operator clicks on multiple points of the object // to be segmented and each selected point is passed as a seed to this // filter. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/FastMarchingImageFilter.cxx000066400000000000000000000673531301006202600250520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {FastMarchingImageFilterOutput5.png} // 91 176 0.5 -0.5 3.0 10000 10000 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {FastMarchingImageFilterOutput6.png} // 118 100 1.0 -0.5 3.0 10000 10000 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {FastMarchingImageFilterOutput7.png} // OUTPUTS: [FastMarchingFilterOutput1.png] // OUTPUTS: [FastMarchingFilterOutput2.png] // OUTPUTS: [FastMarchingFilterOutput3.png] // 145 21 0.5 -0.5 3.0 10000 10000 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // When the differential equation governing the level set evolution has // a very simple form, a fast evolution algorithm called fast marching // can be used. // // The following example illustrates the use of the // \doxygen{itk}{FastMarchingImageFilter}. This filter implements a fast marching // solution to a simple level set evolution problem. In this example, the // speed term used in the differential equation is expected to be provided by // the user in the form of an image. This image is typically computed as a // function of the gradient magnitude. Several mappings are popular in the // literature, for example, the negative exponential $exp(-x)$ and the // reciprocal $1/(1+x)$. In the current example we decided to use a Sigmoid // function since it offers a good deal of control parameters that can be // customized to shape a nice speed image. // // The mapping should be done in such a way that the propagation speed of the // front will be very low close to high image gradients while it will move // rather fast in low gradient areas. This arrangement will make the contour // propagate until it reaches the edges of anatomical structures in the image // and then slow down in front of those edges. The output of the // FastMarchingImageFilter is a \emph{time-crossing map} that // indicates, for each pixel, how much time it would take for the front to // arrive at the pixel location. // // \begin{figure} \center // \includegraphics[width=\textwidth]{FastMarchingCollaborationDiagram1.eps} // \itkcaption[FastMarchingImageFilter collaboration diagram]{Collaboration // diagram of the FastMarchingImageFilter applied to a segmentation task.} // \label{fig:FastMarchingCollaborationDiagram} // \end{figure} // // The application of a threshold in the output image is then equivalent to // taking a snapshot of the contour at a particular time during its evolution. // It is expected that the contour will take a longer time to cross over // the edges of a particular structure. This should result in large // changes on the time-crossing map values close to the structure edges. // Segmentation is performed with this filter by locating a time range in which // the contour was contained for a long time in a region of the image space. // // Figure~\ref{fig:FastMarchingCollaborationDiagram} shows the major components // involved in the application of the FastMarchingImageFilter to a // segmentation task. It involves an initial stage of smoothing using the // \doxygen{itk}{CurvatureAnisotropicDiffusionImageFilter}. The smoothed image is // passed as the input to the // \doxygen{itk}{GradientMagnitudeRecursiveGaussianImageFilter} and then to the // \doxygen{itk}{SigmoidImageFilter}. Finally, the output of the // FastMarchingImageFilter is passed to a // \doxygen{itk}{BinaryThresholdImageFilter} in order to produce a binary mask // representing the segmented object. // // The code in the following example illustrates the typical setup of a // pipeline for performing segmentation with fast marching. First, the input // image is smoothed using an edge-preserving filter. Then the magnitude of its // gradient is computed and passed to a sigmoid filter. The result of the // sigmoid filter is the image potential that will be used to affect the speed // term of the differential equation. // // Let's start by including the following headers. First we include the header // of the CurvatureAnisotropicDiffusionImageFilter that will be used // for removing noise from the input image. // // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkCurvatureAnisotropicDiffusionImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The headers of the GradientMagnitudeRecursiveGaussianImageFilter and // SigmoidImageFilter are included below. Together, these two filters will // produce the image potential for regulating the speed term in the // differential equation describing the evolution of the level set. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkGradientMagnitudeRecursiveGaussianImageFilter.h" #include "itkSigmoidImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Of course, we will need the \doxygen{otb}{Image} class and the // FastMarchingImageFilter class. Hence we include their headers. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "itkFastMarchingImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The time-crossing map resulting from the FastMarchingImageFilter // will be thresholded using the BinaryThresholdImageFilter. We // include its header here. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkBinaryThresholdImageFilter.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Reading and writing images will be done with the \doxygen{otb}{ImageFileReader} // and \doxygen{otb}{ImageFileWriter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" // Software Guide : EndCodeSnippet // The \doxygen{itk}{RescaleIntensityImageFilter} is used to renormailize the // output of filters before sending them to files. // #include "itkRescaleIntensityImageFilter.h" int main(int argc, char *argv[]) { if (argc < 10) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage outputImage seedX seedY"; std::cerr << " Sigma SigmoidAlpha SigmoidBeta TimeThreshold StoppingValue" << std::endl; return 1; } // Software Guide : BeginLatex // // We now define the image type using a pixel type and a particular // dimension. In this case the \code{float} type is used for the pixels due // to the requirements of the smoothing filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; const unsigned int Dimension = 2; typedef otb::Image InternalImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output image, on the other hand, is declared to be binary. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The type of the BinaryThresholdImageFilter filter is // instantiated below using the internal image type and the output image // type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryThresholdImageFilter ThresholdingFilterType; ThresholdingFilterType::Pointer thresholder = ThresholdingFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The upper threshold passed to the BinaryThresholdImageFilter // will define the time snapshot that we are taking from the time-crossing // map. // Software Guide : EndLatex const InternalPixelType timeThreshold = atof(argv[8]); // Software Guide : BeginCodeSnippet thresholder->SetLowerThreshold(0.0); thresholder->SetUpperThreshold(timeThreshold); thresholder->SetOutsideValue(0); thresholder->SetInsideValue(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We instantiate reader and writer types in the following lines. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // The RescaleIntensityImageFilter type is declared below. This filter will // renormalize image before sending them to writers. // typedef itk::RescaleIntensityImageFilter< InternalImageType, OutputImageType> CastFilterType; // Software Guide : BeginLatex // // The CurvatureAnisotropicDiffusionImageFilter type is // instantiated using the internal image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CurvatureAnisotropicDiffusionImageFilter< InternalImageType, InternalImageType> SmoothingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, the filter is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The types of the // GradientMagnitudeRecursiveGaussianImageFilter and // SigmoidImageFilter are instantiated using the internal image // type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< InternalImageType, InternalImageType> GradientFilterType; typedef itk::SigmoidImageFilter< InternalImageType, InternalImageType> SigmoidFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The corresponding filter objects are instantiated with the // \code{New()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet GradientFilterType::Pointer gradientMagnitude = GradientFilterType::New(); SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The minimum and maximum values of the SigmoidImageFilter output are // defined with the methods \code{SetOutputMinimum()} and // \code{SetOutputMaximum()}. In our case, we want these two values to be // $0.0$ and $1.0$ respectively in order to get a nice speed image to feed // to the FastMarchingImageFilter. %Additional details on the use of // %the SigmoidImageFilter are presented in // %Section~\ref{sec:IntensityNonLinearMapping}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet sigmoid->SetOutputMinimum(0.0); sigmoid->SetOutputMaximum(1.0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now declare the type of the FastMarchingImageFilter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::FastMarchingImageFilter FastMarchingFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we construct one filter of this class using the \code{New()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filters are now connected in a pipeline shown in // Figure~\ref{fig:FastMarchingCollaborationDiagram} using the following // lines. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetInput(reader->GetOutput()); gradientMagnitude->SetInput(smoothing->GetOutput()); sigmoid->SetInput(gradientMagnitude->GetOutput()); fastMarching->SetInput(sigmoid->GetOutput()); thresholder->SetInput(fastMarching->GetOutput()); writer->SetInput(thresholder->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The CurvatureAnisotropicDiffusionImageFilter class requires a couple // of parameters to be defined. The following are typical values. However they may have to be adjusted depending on the amount of // noise present in the input image. %This filter has been discussed in // %Section~\ref{sec:GradientAnisotropicDiffusionImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetTimeStep(0.125); smoothing->SetNumberOfIterations(10); smoothing->SetConductanceParameter(2.0); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The GradientMagnitudeRecursiveGaussianImageFilter performs the // equivalent of a convolution with a Gaussian kernel followed by a // derivative operator. The sigma of this Gaussian can be used to control // the range of influence of the image edges. %This filter has been discussed // %in Section~\ref{sec:GradientMagnitudeRecursiveGaussianImageFilter} // // \index{itk::Gradient\-Magnitude\-Recursive\-Gaussian\-Image\-Filter!SetSigma()} // // Software Guide : EndLatex const double sigma = atof(argv[5]); // Software Guide : BeginCodeSnippet gradientMagnitude->SetSigma(sigma); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The SigmoidImageFilter class requires two parameters to define the linear // transformation to be applied to the sigmoid argument. These parameters // are passed using the \code{SetAlpha()} and \code{SetBeta()} methods. In // the context of this example, the parameters are used to intensify the // differences between regions of low and high values in the speed image. In // an ideal case, the speed value should be $1.0$ in the homogeneous regions // and the value should decay rapidly to $0.0$ // around the edges of structures. The heuristic for finding the values is // the following. From the gradient magnitude image, let's call $K1$ the // minimum value along the contour of the structure to be // segmented. Then, let's call $K2$ an average value of the gradient // magnitude in the middle of the structure. These two values indicate the // dynamic range that we want to map to the interval $[0:1]$ in the speed // image. We want the sigmoid to map $K1$ to $0.0$ and $K2$ to $1.0$. Given // that $K1$ is expected to be higher than $K2$ and we want to map those // values to $0.0$ and $1.0$ respectively, we want to select a negative // value for alpha so that the sigmoid function will also do an inverse // intensity mapping. This mapping will produce a speed image such that the // level set will march rapidly on the homogeneous region and will // definitely stop on the contour. The suggested value for beta is // $(K1+K2)/2$ while the suggested value for alpha is $(K2-K1)/6$, which // must be a negative number. In our simple example the values are provided // by the user from the command line arguments. The user can estimate these // values by observing the gradient magnitude image. // // Software Guide : EndLatex const double alpha = atof(argv[6]); const double beta = atof(argv[7]); // Software Guide : BeginCodeSnippet sigmoid->SetAlpha(alpha); sigmoid->SetBeta(beta); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The FastMarchingImageFilter requires the user to provide a seed point // from which the contour will expand. The user can actually pass not only // one seed point but a set of them. A good set of seed points increases // the chances of segmenting a complex object without missing parts. The // use of multiple seeds also helps to reduce the amount of time needed by // the front to visit a whole object and hence reduces the risk of leaks // on the edges of regions visited earlier. For example, when segmenting // an elongated object, it is undesirable to place a single seed at one // extreme of the object since the front will need a long time to // propagate to the other end of the object. Placing several seeds along // the axis of the object will probably be the best strategy to ensure // that the entire object is captured early in the expansion of the // front. One of the important properties of level sets is their natural // ability to fuse several fronts implicitly without any extra // bookkeeping. The use of multiple seeds takes good advantage of this // property. // // \index{itk::FastMarchingImageFilter!Multiple seeds} // // The seeds are passed stored in a container. The type of this // container is defined as \code{NodeContainer} among the // FastMarchingImageFilter traits. // // \index{itk::FastMarchingImageFilter!Nodes} // \index{itk::FastMarchingImageFilter!NodeContainer} // \index{itk::FastMarchingImageFilter!NodeType} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef FastMarchingFilterType::NodeContainer NodeContainer; typedef FastMarchingFilterType::NodeType NodeType; NodeContainer::Pointer seeds = NodeContainer::New(); // Software Guide : EndCodeSnippet InternalImageType::IndexType seedPosition; seedPosition[0] = atoi(argv[3]); seedPosition[1] = atoi(argv[4]); // Software Guide : BeginLatex // // Nodes are created as stack variables and initialized with a value and an // \doxygen{itk}{Index} position. // // \index{itk::FastMarchingImageFilter!Seed initialization} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet NodeType node; const double seedValue = 0.0; node.SetValue(seedValue); node.SetIndex(seedPosition); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The list of nodes is initialized and then every node is inserted using // the \code{InsertElement()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet seeds->Initialize(); seeds->InsertElement(0, node); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The set of seed nodes is now passed to the FastMarchingImageFilter with // the method \code{SetTrialPoints()}. // // \index{itk::FastMarchingImageFilter!SetTrialPoints()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fastMarching->SetTrialPoints(seeds); // Software Guide : EndCodeSnippet // Here we configure all the writers required to see the intermediate // outputs of the pipeline. This is added here only for // pedagogical/debugging purposes. These intermediate output are normally not // required. Only the output of the final thresholding filter should be // relevant. Observing intermediate output is helpful in the process of // fine tuning the parameters of filters in the pipeline. // CastFilterType::Pointer caster1 = CastFilterType::New(); CastFilterType::Pointer caster2 = CastFilterType::New(); CastFilterType::Pointer caster3 = CastFilterType::New(); CastFilterType::Pointer caster4 = CastFilterType::New(); WriterType::Pointer writer1 = WriterType::New(); WriterType::Pointer writer2 = WriterType::New(); WriterType::Pointer writer3 = WriterType::New(); WriterType::Pointer writer4 = WriterType::New(); caster1->SetInput(smoothing->GetOutput()); writer1->SetInput(caster1->GetOutput()); writer1->SetFileName("FastMarchingFilterOutput1.png"); caster1->SetOutputMinimum(0); caster1->SetOutputMaximum(255); writer1->Update(); caster2->SetInput(gradientMagnitude->GetOutput()); writer2->SetInput(caster2->GetOutput()); writer2->SetFileName("FastMarchingFilterOutput2.png"); caster2->SetOutputMinimum(0); caster2->SetOutputMaximum(255); writer2->Update(); caster3->SetInput(sigmoid->GetOutput()); writer3->SetInput(caster3->GetOutput()); writer3->SetFileName("FastMarchingFilterOutput3.png"); caster3->SetOutputMinimum(0); caster3->SetOutputMaximum(255); writer3->Update(); caster4->SetInput(fastMarching->GetOutput()); writer4->SetInput(caster4->GetOutput()); writer4->SetFileName("FastMarchingFilterOutput4.png"); caster4->SetOutputMinimum(0); caster4->SetOutputMaximum(255); // Software Guide : BeginLatex // // The FastMarchingImageFilter requires the user to specify the // size of the image to be produced as output. This is done using the // \code{SetOutputSize()}. Note that the size is obtained here from the // output image of the smoothing filter. The size of this image is valid // only after the \code{Update()} methods of this filter has been called // directly or indirectly. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fastMarching->SetOutputSize( reader->GetOutput()->GetBufferedRegion().GetSize()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Since the front representing the contour will propagate continuously // over time, it is desirable to stop the process once a certain time has // been reached. This allows us to save computation time under the // assumption that the region of interest has already been computed. The // value for stopping the process is defined with the method // \code{SetStoppingValue()}. In principle, the stopping value should be a // little bit higher than the threshold value. // // \index{itk::FastMarchingImageFilter!SetStoppingValue()} // // Software Guide : EndLatex const double stoppingTime = atof(argv[9]); // Software Guide : BeginCodeSnippet fastMarching->SetStoppingValue(stoppingTime); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. As usual, the call is placed in a // \code{try/catch} block should any errors occur or exceptions be thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet writer4->Update(); // The following writer type is used to save the output of the // time-crossing map in a file with appropriate pixel representation. The // advantage of saving this image in native format is that it can be used // with a viewer to help determine an appropriate threshold to be used on // the output of the \code{fastmarching} filter. // typedef otb::ImageFileWriter InternalWriterType; InternalWriterType::Pointer mapWriter = InternalWriterType::New(); mapWriter->SetInput(fastMarching->GetOutput()); mapWriter->SetFileName("FastMarchingFilterOutput4.tif"); mapWriter->Update(); InternalWriterType::Pointer speedWriter = InternalWriterType::New(); speedWriter->SetInput(sigmoid->GetOutput()); speedWriter->SetFileName("FastMarchingFilterOutput3.tif"); speedWriter->Update(); InternalWriterType::Pointer gradientWriter = InternalWriterType::New(); gradientWriter->SetInput(gradientMagnitude->GetOutput()); gradientWriter->SetFileName("FastMarchingFilterOutput2.tif"); gradientWriter->Update(); // Software Guide : BeginLatex // // Now let's run this example using the input image // \code{QB\_Suburb.png} provided in the directory // \code{Examples/Data}. We can easily segment // structures by providing seeds in the appropriate locations. The following // table presents the parameters used for some structures. // // \begin{table} // \begin{center} // \begin{tabular}{|l|c|c|c|c|c|c|p{2cm}|} // \hline // Structure & Seed Index & $\sigma$ & $\alpha$ & $\beta$ & Threshold & Output Image from left \\ \hline // Road & $(91, 176)$ & 0.5 & -0.5 & 3.0 & 100 & First \\ \hline // Shadow & $(118, 100)$ & 1.0 & -0.5 & 3.0 & 100 & Second \\ \hline // Building & $(145, 21)$ & 0.5 & -0.5 & 3.0 & 100 & Third \\ \hline // \end{tabular} // \end{center} // \itkcaption[FastMarching segmentation example parameters]{Parameters used // for segmenting some structures shown in // Figure~\ref{fig:FastMarchingImageFilterOutput2} using the filter // FastMarchingImageFilter. All of them used a stopping value of // 100.\label{tab:FastMarchingImageFilterOutput2}} // \end{table} // // Figure~\ref{fig:FastMarchingImageFilterOutput} presents the intermediate // outputs of the pipeline illustrated in // Figure~\ref{fig:FastMarchingCollaborationDiagram}. They are from left to // right: the output of the anisotropic diffusion filter, the gradient // magnitude of the smoothed image and the sigmoid of the gradient magnitude // which is finally used as the speed image for the // FastMarchingImageFilter. // // \begin{figure} \center // \includegraphics[height=0.30\textwidth]{QB_Suburb.eps} // \includegraphics[height=0.30\textwidth]{FastMarchingFilterOutput1.eps} // \includegraphics[height=0.30\textwidth]{FastMarchingFilterOutput2.eps} // \includegraphics[height=0.30\textwidth]{FastMarchingFilterOutput3.eps} // \itkcaption[FastMarchingImageFilter intermediate output]{Images generated by // the segmentation process based on the FastMarchingImageFilter. From left // to right and top to bottom: input image to be segmented, image smoothed with an // edge-preserving smoothing filter, gradient magnitude of the smoothed // image, sigmoid of the gradient magnitude. This last image, the sigmoid, is // used to compute the speed term for the front propagation } // \label{fig:FastMarchingImageFilterOutput} // \end{figure} // // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{FastMarchingImageFilterOutput5.eps} // \includegraphics[width=0.24\textwidth]{FastMarchingImageFilterOutput6.eps} // \includegraphics[width=0.24\textwidth]{FastMarchingImageFilterOutput7.eps} // \itkcaption[FastMarchingImageFilter segmentations]{Images generated by the // segmentation process based on the FastMarchingImageFilter. From left to // right: segmentation of the road, shadow, building.} // \label{fig:FastMarchingImageFilterOutput2} // \end{figure} // // \relatedClasses // \begin{itemize} // \item \doxygen{itk}{ShapeDetectionLevelSetImageFilter} // \item \doxygen{itk}{GeodesicActiveContourLevelSetImageFilter} // \item \doxygen{itk}{ThresholdSegmentationLevelSetImageFilter} // \item \doxygen{itk}{CannySegmentationLevelSetImageFilter} // \item \doxygen{itk}{LaplacianSegmentationLevelSetImageFilter} // \end{itemize} // // See the ITK Software Guide for examples of the use of these classes. // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/IsolatedConnectedImageFilter.cxx000066400000000000000000000226151301006202600260630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {IsolatedConnectedImageFilterOutput1.png} // 61 140 150 63 43 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following example illustrates the use of the // \doxygen{itk}{IsolatedConnectedImageFilter}. This filter is a close variant of // the \doxygen{itk}{ConnectedThresholdImageFilter}. In this filter two seeds and a // lower threshold are provided by the user. The filter will grow a region // connected to the first seed and \textbf{not connected} to the second one. In // order to do this, the filter finds an intensity value that could be used as // upper threshold for the first seed. A binary search is used to find the // value that separates both seeds. // // This example closely follows the previous ones. Only the relevant pieces // of code are highlighted here. // // Software Guide : EndLatex // Software Guide : BeginLatex // // The header of the IsolatedConnectedImageFilter is included below. // // \index{itk::Isolated\-Connected\-Image\-Filter!header} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkIsolatedConnectedImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "itkCurvatureFlowImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { if (argc < 8) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage outputImage seedX1 seedY1"; std::cerr << " lowerThreshold seedX2 seedY2" << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // We define the image type using a pixel type and a particular // dimension. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; const unsigned int Dimension = 2; typedef otb::Image InternalImageType; // Software Guide : EndCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::CastImageFilter CastingFilterType; CastingFilterType::Pointer caster = CastingFilterType::New(); // We instantiate reader and writer types // typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); typedef itk::CurvatureFlowImageFilter CurvatureFlowImageFilterType; CurvatureFlowImageFilterType::Pointer smoothing = CurvatureFlowImageFilterType::New(); // Software Guide : BeginLatex // // The IsolatedConnectedImageFilter is instantiated in the lines below. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::IsolatedConnectedImageFilter ConnectedFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // One filter of this class is constructed using the \code{New()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConnectedFilterType::Pointer isolatedConnected = ConnectedFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now it is time to connect the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetInput(reader->GetOutput()); isolatedConnected->SetInput(smoothing->GetOutput()); caster->SetInput(isolatedConnected->GetOutput()); writer->SetInput(caster->GetOutput()); // Software Guide : EndCodeSnippet smoothing->SetNumberOfIterations(5); smoothing->SetTimeStep(0.125); // Software Guide : BeginLatex // // The IsolatedConnectedImageFilter expects the user to specify a // threshold and two seeds. In this example, we take all of them from the // command line arguments. // // \index{itk::Isolated\-Connected\-Image\-Filter!SetLower()} // \index{itk::Isolated\-Connected\-Image\-Filter!SetSeed1()} // \index{itk::Isolated\-Connected\-Image\-Filter!SetSeed2()} // // Software Guide : EndLatex InternalImageType::IndexType indexSeed1; indexSeed1[0] = atoi(argv[3]); indexSeed1[1] = atoi(argv[4]); const InternalPixelType lowerThreshold = atof(argv[5]); InternalImageType::IndexType indexSeed2; indexSeed2[0] = atoi(argv[6]); indexSeed2[1] = atoi(argv[7]); // Software Guide : BeginCodeSnippet isolatedConnected->SetLower(lowerThreshold); isolatedConnected->SetSeed1(indexSeed1); isolatedConnected->SetSeed2(indexSeed2); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As in the \doxygen{itk}{ConnectedThresholdImageFilter} we must now specify // the intensity value to be set on the output pixels and at least one // seed point to define the initial region. // // \index{itk::Isolated\-Connected\-Image\-Filter!SetReplaceValue()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet isolatedConnected->SetReplaceValue(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The intensity value allowing us to separate both regions can be // recovered with the method \code{GetIsolatedValue()} // // \index{itk::Isolated\-Connected\-Image\-Filter!GetIsolatedValue()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet std::cout << "Isolated Value Found = "; std::cout << isolatedConnected->GetIsolatedValue() << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's now run this example using the image // \code{QB\_Suburb.png} provided in the directory // \code{Examples/Data}. We can easily segment // structures by providing seed pairs in the appropriate locations and // defining values for the lower threshold. It is important to keep in // mind in this and the previous examples that the segmentation is being // performed in the smoothed version of the image. The selection of // threshold values should therefore be performed in the smoothed image // since the distribution of intensities could be quite different from // that of the input image. As a reminder of this fact, Figure // \ref{fig:IsolatedConnectedImageFilterOutput} presents, from left to // right, the input image and the result of smoothing with the // \doxygen{itk}{CurvatureFlowImageFilter} followed by segmentation results. // // This filter is intended to be used in cases where adjacent // structures are difficult to separate. Selecting one seed in one structure // and the other seed in the adjacent structure creates the appropriate // setup for computing the threshold that will separate both structures. // Table~\ref{tab:IsolatedConnectedImageFilterOutput} presents the // parameters used to obtain the images shown in // Figure~\ref{fig:IsolatedConnectedImageFilterOutput}. // // \begin{table} // \begin{center} // \begin{tabular}{|l|c|c|c|c|} // \hline // Adjacent Structures & Seed1 & Seed2 & Lower & Isolated value found \\ \hline // Gray matter vs White matter & $(61, 140)$ & $(63, 43)$ & $150$ & $183.31$ \\ \hline // \end{tabular} // \end{center} // \itkcaption[IsolatedConnectedImageFilter example parameters]{Parameters // used for separating white matter from gray matter in // Figure~\ref{fig:IsolatedConnectedImageFilterOutput} using the // IsolatedConnectedImageFilter.\label{tab:IsolatedConnectedImageFilterOutput}} // \end{table} // // \begin{figure} \center // \includegraphics[width=0.32\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.32\textwidth]{IsolatedConnectedImageFilterOutput0.eps} // \includegraphics[width=0.32\textwidth]{IsolatedConnectedImageFilterOutput1.eps} // \itkcaption[IsolatedConnected segmentation results]{Segmentation results of // the IsolatedConnectedImageFilter.} // \label{fig:IsolatedConnectedImageFilterOutput} // \end{figure} // // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/LabelizeNeighborhoodConnectedImageFilter.cxx000066400000000000000000000064261301006202600304000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {LabelizeNeighborhoodConnectedImageFilterOutput.png} // 170 170 // 80 80 // Software Guide : EndCommandLineArgs #include #include "itkScalarToRGBPixelFunctor.h" #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "otbLabelizeNeighborhoodConnectedImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc < 7) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] \ << " inputImageFile outputImageFile " \ << "seedLowerThreshold seedUpperThreshold " \ << "deltaLower deltaUpper " << std::endl; return EXIT_FAILURE; } // Arguments char* inputImageName = argv[1]; char* outputImageName = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef itk::RGBPixel ColorPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image RGBImageType; InputPixelType lowerThreshold((InputPixelType) ::atoi(argv[3])); InputPixelType upperThreshold((InputPixelType) ::atoi(argv[4])); InputPixelType deltaLower((InputPixelType) ::atoi(argv[5])); InputPixelType deltaUpper((InputPixelType) ::atoi(argv[6])); // Reader typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Writer typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageName); // Labelize filter typedef otb::LabelizeNeighborhoodConnectedImageFilter LabelizeFilterType; LabelizeFilterType::Pointer filter = LabelizeFilterType::New(); filter->SetLowerThreshold(lowerThreshold); filter->SetUpperThreshold(upperThreshold); filter->SetLowerThresholdDelta(deltaLower); filter->SetUpperThresholdDelta(deltaUpper); // Label to RGB image typedef itk::Functor::ScalarToRGBPixelFunctor FunctorType; typedef itk::UnaryFunctorImageFilter ColorLabelFilterType; ColorLabelFilterType::Pointer labelToRGB = ColorLabelFilterType::New(); filter->SetInput(reader->GetOutput()); labelToRGB->SetInput(filter->GetOutput()); writer->SetInput(labelToRGB->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/NeighborhoodConnectedImageFilter.cxx000066400000000000000000000304341301006202600267240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {NeighborhoodConnectedThresholdOutput1.png} // 110 38 50 100 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {NeighborhoodConnectedThresholdOutput2.png} // 118 100 0 10 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {NeighborhoodConnectedThresholdOutput3.png} // 169 146 220 255 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following example illustrates the use of the // \doxygen{itk}{NeighborhoodConnectedImageFilter}. This filter is a close variant // of the \doxygen{itk}{ConnectedThresholdImageFilter}. On one hand, the // ConnectedThresholdImageFilter accepts a pixel in the region if its intensity // is in the interval defined by two user-provided threshold values. The // NeighborhoodConnectedImageFilter, on the other hand, will only accept a // pixel if \textbf{all} its neighbors have intensities that fit in the // interval. The size of the neighborhood to be considered around each pixel is // defined by a user-provided integer radius. // // The reason for considering the neighborhood intensities instead of only the // current pixel intensity is that small structures are less likely to be // accepted in the region. The operation of this filter is equivalent to // applying the ConnectedThresholdImageFilter followed by mathematical // morphology erosion using a structuring element of the same shape as // the neighborhood provided to the NeighborhoodConnectedImageFilter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkNeighborhoodConnectedImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" // Software Guide : BeginLatex // // The \doxygen{itk}{CurvatureFlowImageFilter} is used here to smooth the image // while preserving edges. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkCurvatureFlowImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { if (argc < 7) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage outputImage seedX seedY lowerThreshold upperThreshold" << std::endl; return 1; } // Software Guide : BeginLatex // // We now define the image type using a particular pixel type and image // dimension. In this case the \code{float} type is used for the pixels due // to the requirements of the smoothing filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InternalPixelType; const unsigned int Dimension = 2; typedef otb::Image InternalImageType; // Software Guide : EndCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::CastImageFilter CastingFilterType; CastingFilterType::Pointer caster = CastingFilterType::New(); // We instantiate reader and writer types // typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // The smoothing filter type is instantiated using the image type as // a template parameter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CurvatureFlowImageFilter CurvatureFlowImageFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, the filter is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet CurvatureFlowImageFilterType::Pointer smoothing = CurvatureFlowImageFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We now declare the type of the region growing filter. In this case it is // the NeighborhoodConnectedImageFilter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::NeighborhoodConnectedImageFilter ConnectedFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // One filter of this class is constructed using the \code{New()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConnectedFilterType::Pointer neighborhoodConnected = ConnectedFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now it is time to create a simple, linear data processing pipeline. A // file reader is added at the beginning of the pipeline and a cast // filter and writer are added at the end. The cast filter is required // to convert \code{float} pixel types to integer types since only a // few image file formats support \code{float} types. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetInput(reader->GetOutput()); neighborhoodConnected->SetInput(smoothing->GetOutput()); caster->SetInput(neighborhoodConnected->GetOutput()); writer->SetInput(caster->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The CurvatureFlowImageFilter requires a couple of parameters to // be defined. The following are typical values for $2D$ images. However // they may have to be adjusted depending on the amount of noise present in // the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet smoothing->SetNumberOfIterations(5); smoothing->SetTimeStep(0.125); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The NeighborhoodConnectedImageFilter requires that two main parameters // are specified. They are the lower and upper thresholds of the interval // in which intensity values must fall to be included in the // region. Setting these two values too close will not allow enough // flexibility for the region to grow. Setting them too far apart will // result in a region that engulfs the image. // // \index{itk::NeighborhoodConnectedImageFilter!SetLower()} // \index{itk::NeighborhoodConnectedImageFilter!SetUppder()} // // Software Guide : EndLatex const InternalPixelType lowerThreshold = atof(argv[5]); const InternalPixelType upperThreshold = atof(argv[6]); // Software Guide : BeginCodeSnippet neighborhoodConnected->SetLower(lowerThreshold); neighborhoodConnected->SetUpper(upperThreshold); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Here, we add the crucial parameter that defines the neighborhood size // used to determine whether a pixel lies in the region. The larger the // neighborhood, the more stable this filter will be against noise in the // input image, but also the longer the computing time will be. Here we // select a filter of radius $2$ along each dimension. This results in a // neighborhood of $5 \times 5$ pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InternalImageType::SizeType radius; radius[0] = 2; // two pixels along X radius[1] = 2; // two pixels along Y neighborhoodConnected->SetRadius(radius); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // As in the ConnectedThresholdImageFilter we must now provide the // intensity value to be used for the output pixels accepted in the region // and at least one seed point to define the initial region. // // \index{itk::NeighborhoodConnectedImageFilter!SetSeed()} // \index{itk::NeighborhoodConnectedImageFilter!SetReplaceValue()} // // Software Guide : EndLatex InternalImageType::IndexType index; index[0] = atoi(argv[3]); index[1] = atoi(argv[4]); // Software Guide : BeginCodeSnippet neighborhoodConnected->SetSeed(index); neighborhoodConnected->SetReplaceValue(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is usually wise to put update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excep) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's run this example using as input the image // \code{QB\_Suburb.png} provided in the directory // \code{Examples/Data}. We can easily segment the major // structures by providing seeds in the appropriate locations and defining // values for the lower and upper thresholds. // Figure~\ref{fig:NeighborhoodConnectedThresholdOutput} illustrates several examples of // segmentation. The parameters used are presented in // Table~\ref{tab:NeighborhoodConnectedThresholdOutput}. // // \begin{table} // \begin{center} // \begin{tabular}{|l|c|c|c|c|} // \hline // Structure & Seed Index & Lower & Upper & Output Image \\ \hline // Road & $(110, 38)$ & 50 & 100 & Second from left in Figure \ref{fig:NeighborhoodConnectedThresholdOutput} \\ \hline // Shadow & $(118, 100)$ & 0 & 10 & Third from left in Figure \ref{fig:NeighborhoodConnectedThresholdOutput} \\ \hline // Building & $(169, 146)$ & 220 & 255 & Fourth from left in Figure \ref{fig:NeighborhoodConnectedThresholdOutput} \\ \hline // \end{tabular} // \end{center} // \itkcaption[NeighborhoodConnectedThreshold example parameters]{Parameters used for // segmenting some structures shown in // Figure~\ref{fig:NeighborhoodConnectedThresholdOutput} with the filter // \doxygen{itk}{NeighborhoodConnectedThresholdImageFilter}.\label{tab:NeighborhoodConnectedThresholdOutput}} // \end{table} // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.24\textwidth]{NeighborhoodConnectedThresholdOutput1.eps} // \includegraphics[width=0.24\textwidth]{NeighborhoodConnectedThresholdOutput2.eps} // \includegraphics[width=0.24\textwidth]{NeighborhoodConnectedThresholdOutput3.eps} // \itkcaption[NeighborhoodConnectedThreshold segmentation results]{Segmentation results // for the NeighborhoodConnectedThreshold filter for various seed points.} // \label{fig:NeighborhoodConnectedThresholdOutput} // \end{figure} // // As with the ConnectedThresholdImageFilter, several seeds could // be provided to the filter by using the \code{AddSeed()} method. // Compare the output of Figure // \ref{fig:NeighborhoodConnectedThresholdOutput} with those of Figure // \ref{fig:ConnectedThresholdOutput} produced by the // ConnectedThresholdImageFilter. You may want to play with the // value of the neighborhood radius and see how it affect the smoothness of // the segmented object borders, the size of the segmented region and how // much that costs in computing time. // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/OtsuMultipleThresholdImageFilter.cxx000066400000000000000000000155351301006202600270220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {OtsuMultipleThresholdsOutput000.png}, {OtsuMultipleThresholdsOutput001.png}, {OtsuMultipleThresholdsOutput002.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // This example illustrates how to use the \doxygen{itk}{OtsuMultipleThresholdsCalculator}. // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkOtsuMultipleThresholdsCalculator.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkScalarImageToHistogramGenerator.h" #include "itkBinaryThresholdImageFilter.h" #include "itkNumericTraits.h" #include int main(int argc, char * argv[]) { if (argc < 2) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputImageFile outputImageFileName1 [OutputImageFilename2 ...] " << std::endl; return EXIT_FAILURE; } //Convenience typedefs typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : BeginLatex // OtsuMultipleThresholdsCalculator calculates thresholds for a give histogram // so as to maximize the between-class variance. We use // ScalarImageToHistogramGenerator to generate histograms // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Statistics::ScalarImageToHistogramGenerator ScalarImageToHistogramGeneratorType; typedef itk::OtsuMultipleThresholdsCalculator< ScalarImageToHistogramGeneratorType::HistogramType> CalculatorType; // Software Guide : EndCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Software Guide : BeginLatex // Once thresholds are computed we will use BinaryThresholdImageFilter to // segment the input image into segments. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::BinaryThresholdImageFilter FilterType; // Software Guide : EndCodeSnippet //Create using static New() method // Software Guide : BeginCodeSnippet ScalarImageToHistogramGeneratorType::Pointer scalarImageToHistogramGenerator = ScalarImageToHistogramGeneratorType::New(); CalculatorType::Pointer calculator = CalculatorType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); //Set Properties // Software Guide : BeginCodeSnippet scalarImageToHistogramGenerator->SetNumberOfBins(128); int nbThresholds = argc - 2; calculator->SetNumberOfThresholds(nbThresholds); // Software Guide : EndCodeSnippet const OutputPixelType outsideValue = 0; const OutputPixelType insideValue = 255; filter->SetOutsideValue(outsideValue); filter->SetInsideValue(insideValue); //Connect Pipeline reader->SetFileName(argv[1]); // Software Guide : BeginLatex // The pipeline will look as follows: // Software Guide : EndLatex // Software Guide : BeginCodeSnippet scalarImageToHistogramGenerator->SetInput(reader->GetOutput()); calculator->SetInputHistogram(scalarImageToHistogramGenerator->GetOutput()); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet //Invoke pipeline try { reader->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Exception thrown while reading image" << excp << std::endl; } scalarImageToHistogramGenerator->Compute(); try { calculator->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Exception thrown " << excp << std::endl; } // Software Guide : BeginLatex // Thresholds are obtained using the \code{GetOutput} method // \index{itk::OtsuMultipleThresholdsCalculator!GetOutput()} // Software Guide : EndLatex //Get Thresholds // Software Guide : BeginCodeSnippet const CalculatorType::OutputType& thresholdVector = calculator->GetOutput(); CalculatorType::OutputType::const_iterator itNum = thresholdVector.begin(); // Software Guide : EndCodeSnippet //Threshold into separate segments and write out as binary images double lowerThreshold = 0; double upperThreshold; unsigned int counter = 0; // Software Guide : BeginCodeSnippet for (; itNum < thresholdVector.end(); itNum++) { std::cout << "OtsuThreshold[" << (int) (itNum - thresholdVector.begin()) << "] = " << static_cast::PrintType> (*itNum) << std::endl; upperThreshold = (*itNum); filter->SetLowerThreshold(static_cast (lowerThreshold)); filter->SetUpperThreshold(static_cast (upperThreshold)); lowerThreshold = upperThreshold; writer->SetFileName(argv[2 + counter]); ++counter; // Software Guide : EndCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& excp) { std::cerr << "Exception thrown " << excp << std::endl; } // Software Guide : BeginCodeSnippet } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{OtsuMultipleThresholdsOutput000.eps} // \includegraphics[width=0.44\textwidth]{OtsuMultipleThresholdsOutput001.eps} // \includegraphics[width=0.44\textwidth]{OtsuMultipleThresholdsOutput002.eps} // \itkcaption[OtsuThresholdImageFilter output]{Effect of the OtsuMultipleThresholdImageFilter.} // \label{fig:OtsuMultipleThresholdImageFilterInputOutput} // \end{figure} // // Figure \ref{fig:OtsuMultipleThresholdImageFilterInputOutput} illustrates the // effect of this filter. // // \relatedClasses // \begin{itemize} // \item \doxygen{itk}{ThresholdImageFilter} // \end{itemize} // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/OtsuThresholdImageFilter.cxx000066400000000000000000000163451301006202600253060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {OtsuThresholdImageFilterOutput.png} // 255 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates how to use the \doxygen{itk}{OtsuThresholdImageFilter}. // // Software Guide : EndLatex #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkOtsuThresholdImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc < 5) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputImageFile outputImageFile "; std::cerr << " insideValue outsideValue " << std::endl; return EXIT_FAILURE; } // Software Guide : BeginLatex // // The next step is to decide which pixel types to use for the input and output // images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The input and output image types are now defined using their respective // pixel types and dimensions. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filter type can be instantiated using the input and output image // types defined above. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::OtsuThresholdImageFilter< InputImageType, OutputImageType> FilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. (See Section \ref{sec:IO} on page // \pageref{sec:IO} for more information about reading // and writing data.) // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the output // image to a file. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to \doxygen{itk}{SmartPointer}s. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); reader->SetFileName(argv[1]); // Software Guide : BeginLatex // // The image obtained with the reader is passed as input to the // OtsuThresholdImageFilter. // // \index{itk::Otsu\-Threshold\-Image\-Filter!SetInput()} // \index{otb::FileImageReader!GetOutput()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{SetOutsideValue()} defines the intensity value to be // assigned to those pixels whose intensities are outside the range defined // by the lower and upper thresholds. The method \code{SetInsideValue()} // defines the intensity value to be assigned to pixels with intensities // falling inside the threshold range. // // \index{itk::Otsu\-Threshold\-Image\-Filter!SetOutsideValue()} // \index{itk::Otsu\-Threshold\-Image\-Filter!SetInsideValue()} // \index{SetOutsideValue()!itk::Otsu\-Threshold\-Image\-Filter} // \index{SetInsideValue()!itk::Otsu\-Threshold\-Image\-Filter} // // Software Guide : EndLatex const OutputPixelType outsideValue = atoi(argv[3]); const OutputPixelType insideValue = atoi(argv[4]); // Software Guide : BeginCodeSnippet filter->SetOutsideValue(outsideValue); filter->SetInsideValue(insideValue); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The method \code{SetNumberOfHistogramBins()} defines the number of bins // to be used for computing the histogram. This histogram will be used // internally in order to compute the Otsu threshold. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetNumberOfHistogramBins(128); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The execution of the filter is triggered by invoking the \code{Update()} // method. If the filter's output has been passed as input to subsequent // filters, the \code{Update()} call on any posterior filters in the // pipeline will indirectly trigger the update of this filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We print out here the Threshold value that was computed internally by the // filter. For this we invoke the \code{GetThreshold} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet int threshold = filter->GetThreshold(); std::cout << "Threshold = " << threshold << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{QB_Suburb.eps} // \includegraphics[width=0.44\textwidth]{OtsuThresholdImageFilterOutput.eps} // \itkcaption[OtsuThresholdImageFilter output]{Effect of the OtsuThresholdImageFilter.} // \label{fig:OtsuThresholdImageFilterInputOutput} // \end{figure} // // Figure \ref{fig:OtsuThresholdImageFilterInputOutput} illustrates the // effect of this filter. This // figure shows the limitations of this filter for performing segmentation // by itself. These limitations are particularly noticeable in noisy images // and in images lacking spatial uniformity. // // \relatedClasses // \begin{itemize} // \item \doxygen{itk}{ThresholdImageFilter} // \end{itemize} // // Software Guide : EndLatex writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/StreamingMeanShiftSegmentation.cxx000066400000000000000000000272511301006202600264720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The following example illustrates how to segment very large images // using the \doxygen{otb}{StreamingImageToOGRLayerSegmentationFilter}. This filter is // templated over the segmentation filter that will be used to segment each tile // of the input image. In this example we will use the \doxygen{otb}{MeanShiftSegmentationFilter}. // The labeled output image of each tile is then vectorized (using a filter based on GDALPolygonize) // and stored into a \doxygen{otb}{ogr}{Layer} within the \doxygen{otb}{ogr}{DataSource} // set as input. Finally a fusion filter, \doxygen{otb}{OGRLayerStreamStitchingFilter}, is used to merge polygons // at tile border. // // Let's take a look at the code. // First we include all the needed headers // Software Guide : EndLatex #include // Software Guide : BeginCodeSnippet #include "otbStreamingImageToOGRLayerSegmentationFilter.h" #include "otbOGRLayerStreamStitchingFilter.h" #include "otbMeanShiftSegmentationFilter.h" // Software Guide : EndCodeSnippet #include "otbVectorImage.h" #include "otbImageFileReader.h" int main(int argc, char *argv[]) { if (argc != 13) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage maskImage outputVec layerName TileDimension" << "spatialRadius rangeRadius minObjectSize filterSmallObj minSize" << "SimplifyFlag Tolerance" << std::endl; return EXIT_FAILURE; } const char * imageName = argv[1]; const char * maskName = argv[2]; const char * dataSourceName = argv[3]; const char * layerName = argv[4]; const unsigned int tileSize = atoi(argv[5]); const unsigned int spatialRadius = atoi(argv[6]); const double rangeRadius = atof(argv[7]); const unsigned int minimumObjectSize = atoi(argv[8]); const bool filterSmallObj = atoi(argv[9]); const unsigned int minSize = atoi(argv[10]); const bool simplify = atoi(argv[11]); const double tolerance = atof(argv[12]); const std::string fieldName("DN"); // Software Guide : BeginLatex // // We now declare the image and pixel types used as input of the MeanShiftFilter. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef float InputPixelType; typedef unsigned int LabelPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::Image LabelImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then the mean shift segmentation filter is declared using the Image type declared previsouly. // The StreamingVectorizedSegmentation is templated over the mean shift filter, the input image type and the output vector data type // Software Guide : EndLatex // Software Guide : BeginCodeSnippet //typedef otb::MeanShiftSmoothingImageFilter MeanShiftImageFilterType; typedef otb::MeanShiftSegmentationFilter SegmentationFilterType; typedef otb::StreamingImageToOGRLayerSegmentationFilter StreamingVectorizedSegmentationType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally we define a Reader on the input image and a mask reader. // All pixels in the mask with a value of 0 will not be considered suitable for vectorization. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader MaskReaderType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we have declared all type needed for the pipeline, we instantiate the different filters, // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReaderType::Pointer reader = ReaderType::New(); MaskReaderType::Pointer maskReader = MaskReaderType::New(); StreamingVectorizedSegmentationType::Pointer filter = StreamingVectorizedSegmentationType::New(); // Software Guide : EndCodeSnippet reader->SetFileName(imageName); reader->UpdateOutputInformation(); maskReader->SetFileName(maskName); maskReader->UpdateOutputInformation(); // Software Guide : BeginLatex // // The instantiation of the DataSource is slightly different as usual. // In fact the \code{New()} method on a \doxygen{otb}{ogr}{DataSource} can be called with or without parameters. // Without parameters, the \code{New()} method instantiate a "Memory" DataSource, which means all the data are stored in memory. // This is not useful in case of large scale segmentation as it will result in millions of polygons kept in memory ... // However the \code{New()} method can also take a filename (\code{std::String}) parameter. Then either the file already exists // and the corresponding ogr driver is used to open the file, or it doesn't exists and then it is created. // Here we used a non existing filename to create a new file in writing mode. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::ogr::DataSource::Pointer ogrDS = otb::ogr::DataSource::New(dataSourceName, otb::ogr::DataSource::Modes::Update_LayerCreateOnly); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next, we will create the layer inside the DataSource that will // hold the polygons from the vectorized segmentation. First, we // need to retrieve the spatial reference from the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OGRSpatialReference oSRS(reader->GetOutput()->GetProjectionRef().c_str()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we can create the layer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet otb::ogr::Layer ogrLayer = ogrDS->CreateLayer(layerName,&oSRS,wkbMultiPolygon); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Last, we need to create a field inside the layer that will hold // the identifier of the polygons. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OGRFieldDefn ogrField(fieldName.c_str(),OFTInteger); ogrLayer.CreateField(ogrField,true); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we set the parameters to the segmentation filter.The \doxygen{otb}{MeanShiftSegmentationFilter} // has three main parameters, the spatial radius, the range radius and the minimum object size. // We use the \code{GetSegmentationFilter()} method on the \doxygen{otb}{StreamingVectorizedSegmentation} // to get a pointer to the segmentation filter. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->GetSegmentationFilter()->SetSpatialBandwidth(spatialRadius); filter->GetSegmentationFilter()->SetRangeBandwidth(rangeRadius); filter->GetSegmentationFilter()->SetMinRegionSize(minimumObjectSize); filter->GetSegmentationFilter()->SetThreshold(0.1); filter->GetSegmentationFilter()->SetMaxIterationNumber(100); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then we set parameters to the \doxygen{otb}{StreamingVectorizedSegmentation} filter. // These parameters are : // \begin{itemize} // \item tile size : use \code{SetTileDimensionTiledStreaming()} for square tile or \code{SetNumberOfLinesStrippedStreaming()} // for Strip. // \item field name : name of the field that will contained the label values. (default is "DN"). // \item start label : first label. Each polygons have a unique label (incremented by one). // \item option to filter small polygons (default to false). // \item minimum object size : in case filter small polygons option is True // \item simplify option : simplification of polygon vertex (default to false).This can reduced very efficiently the size // of the output file with no real impact on the results. // \item simplification tolerance // \end{itemize} // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->GetStreamer()->SetTileDimensionTiledStreaming(tileSize); filter->SetFieldName(fieldName); filter->SetStartLabel(1); filter->SetFilterSmallObject(filterSmallObj); filter->SetMinimumObjectSize(minSize); filter->SetSimplify(simplify); filter->SetSimplificationTolerance(tolerance); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally we connect the pipeline // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); filter->SetInputMask(maskReader->GetOutput()); filter->SetOGRLayer(ogrLayer); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And call the \code{Initialize()} method (needed to create the output layer in the datasource) // before calling the \code{Update()} method. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Initialize(); filter->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The segmentation is done, but as it works tile by tile, we need to fusion polygons at tile border. // We use the \doxygen{otb}{OGRLayerStreamStitchingFilter}. This filter uses a simple fusion strategy. // Polygons that have the largest intersection over a tile are fusioned. Each polygon can be fusioned // only once per tile border (row and column). // Let's look at the code for fusioning. // As usual we declared and instantiate the \doxygen{otb}{OGRLayerStreamStitchingFilter}. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::OGRLayerStreamStitchingFilter FusionFilterType; FusionFilterType::Pointer fusionFilter = FusionFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Next we set the input image and the input \doxygen{otb}{ogr}{Layer}. // The image is internally used in the filter to compute coordinates of streaming tiles. // The DataSource is the one containing the segmentation results. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fusionFilter->SetInput(reader->GetOutput()); fusionFilter->SetOGRLayer(ogrLayer); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // We set the size of the tile used, // which may be different from the one we set in the // \doxygen{otb}{StreamingVectorizedSegmentation} filter but can be // retrieved using the \code{GetStreamSize()} method. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fusionFilter->SetStreamSize(filter->GetStreamSize()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Finally we call the \code{GenerateData()} method to launch the processing. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet fusionFilter->GenerateData(); // Software Guide : EndCodeSnippet return EXIT_SUCCESS; } OTB-release-5.8/Examples/Segmentation/VectorConfidenceConnected.cxx000066400000000000000000000271761301006202600254350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {VisibleWomanEyeSlice.png} // OUTPUTS: {VectorConfidenceConnectedOutput1.png} // 70 120 7 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {VisibleWomanEyeSlice.png} // OUTPUTS: {VectorConfidenceConnectedOutput2.png} // 23 93 7 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {VisibleWomanEyeSlice.png} // OUTPUTS: {VectorConfidenceConnectedOutput3.png} // 66 66 3 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the confidence connected concept // applied to images with vector pixel types. The confidence connected // algorithm is implemented for vector images in the class // \doxygen{VectorConfidenceConnected}. The basic difference between the // scalar and vector version is that the vector version uses the covariance // matrix instead of a variance, and a vector mean instead of a scalar mean. // The membership of a vector pixel value to the region is measured using the // Mahalanobis distance as implemented in the class // \subdoxygen{Statistics}{MahalanobisDistanceThresholdImageFunction}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkVectorConfidenceConnectedImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRGBPixel.h" int main( int argc, char *argv[] ) { if( argc < 7 ) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage outputImage multiplier iterations seedX1 seedY1 seedX2 seedY2 ..." << std::endl; return 1; } // Software Guide : BeginLatex // // We now define the image type using a particular pixel type and // dimension. In this case the \code{float} type is used for the pixels // due to the requirements of the smoothing filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned char PixelComponentType; typedef itk::RGBPixel< PixelComponentType > InputPixelType; const unsigned int Dimension = 2; typedef otb::Image< InputPixelType, Dimension > InputImageType; // Software Guide : EndCodeSnippet typedef unsigned char OutputPixelType; typedef otb::Image< OutputPixelType, Dimension > OutputImageType; // We instantiate reader and writer types // typedef otb::ImageFileReader< InputImageType > ReaderType; typedef otb::ImageFileWriter< OutputImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName( argv[1] ); writer->SetFileName( argv[2] ); // Software Guide : BeginLatex // // We now declare the type of the region growing filter. In this case it // is the \doxygen{VectorConfidenceConnectedImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::VectorConfidenceConnectedImageFilter< InputImageType, OutputImageType > ConnectedFilterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we construct one filter of this class using the \code{New()} // method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ConnectedFilterType::Pointer confidenceConnected = ConnectedFilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next we create a simple, linear data processing pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet confidenceConnected->SetInput( reader->GetOutput() ); writer->SetInput( confidenceConnected->GetOutput() ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The VectorConfidenceConnectedImageFilter requires specifying two // parameters. First, the multiplier factor $f$ defines how large the // range of intensities will be. Small values of the multiplier will // restrict the inclusion of pixels to those having similar intensities to // those already in the current region. Larger values of the multiplier // relax the accepting condition and result in more generous growth of the // region. Values that are too large will cause the region to grow into // neighboring regions that may actually belong to separate anatomical // structures. // // \index{itk::Vector\-Confidence\-Connected\-Image\-Filter!SetMultiplier()} // // Software Guide : EndLatex const double multiplier = atof( argv[3] ); // Software Guide : BeginCodeSnippet confidenceConnected->SetMultiplier( multiplier ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The number of iterations is typically determined based on the // homogeneity of the image intensity representing the anatomical // structure to be segmented. Highly homogeneous regions may only require // a couple of iterations. Regions with ramp effects, like MRI images with // inhomogeneous fields, may require more iterations. In practice, it seems // to be more relevant to carefully select the multiplier factor than the // number of iterations. However, keep in mind that there is no reason to // assume that this algorithm should converge to a stable region. It is // possible that by letting the algorithm run for more iterations the // region will end up engulfing the entire image. // // \index{itk::Vector\-Confidence\-Connected\-Image\-Filter!SetNumberOfIterations()} // // Software Guide : EndLatex const unsigned int iterations = atoi( argv[4] ); // Software Guide : BeginCodeSnippet confidenceConnected->SetNumberOfIterations( iterations ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output of this filter is a binary image with zero-value pixels // everywhere except on the extracted region. The intensity value to be // put inside the region is selected with the method // \code{SetReplaceValue()} // // \index{itk::Vector\-Confidence\-Connected\-Image\-Filter!SetReplaceValue()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet confidenceConnected->SetReplaceValue( 255 ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The initialization of the algorithm requires the user to provide a seed // point. This point should be placed in a \emph{typical} region of the // anatomical structure to be segmented. A small neighborhood around the // seed point will be used to compute the initial mean and standard // deviation for the inclusion criterion. The seed is passed in the form // of a \doxygen{Index} to the \code{SetSeed()} method. // // \index{itk::Vector\-Confidence\-Connected\-Image\-Filter!SetSeed()} // \index{itk::Vector\-Confidence\-Connected\-Image\-Filter!SetInitialNeighborhoodRadius()} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet InputImageType::IndexType index; for (int i = 5; i < argc; i += 2) { index[0] = atoi( argv[i] ); index[1] = atoi( argv[i + 1] ); std::cout << "Adding seed : " << index << std::endl; confidenceConnected->AddSeed( index ); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The size of the initial neighborhood around the seed is defined with the // method \code{SetInitialNeighborhoodRadius()}. The neighborhood will be // defined as an $N$-Dimensional rectangular region with $2r+1$ pixels on // the side, where $r$ is the value passed as initial neighborhood radius. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet confidenceConnected->SetInitialNeighborhoodRadius( 3 ); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The invocation of the \code{Update()} method on the writer triggers the // execution of the pipeline. It is usually wise to put update calls in a // \code{try/catch} block in case errors occur and exceptions are thrown. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { writer->Update(); } catch( itk::ExceptionObject & excep ) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now let's run this example using as input the image // \code{VisibleWomanEyeSlice.png} provided in the directory // \code{Examples/Data}. We can easily segment the major anatomical // structures by providing seeds in the appropriate locations. For example, // // \begin{center} // \begin{tabular}{|l|c|c|c|c|} // \hline // Structure & Seed Index & Multiplier & Iterations & Output Image \\ \hline // Rectum & $(70, 120)$ & 7 & 1 & Second from left in Figure \ref{fig:VectorConfidenceConnectedOutput} \\ \hline // Rectum & $(23, 93)$ & 7 & 1 & Third from left in Figure \ref{fig:VectorConfidenceConnectedOutput} \\ \hline // Vitreo & $(66, 66)$ & 3 & 1 & Fourth from left in Figure \ref{fig:VectorConfidenceConnectedOutput} \\ \hline // \end{tabular} // \end{center} // // \begin{figure} \center // \includegraphics[width=0.24\textwidth]{VisibleWomanEyeSlice.eps} // \includegraphics[width=0.24\textwidth]{VectorConfidenceConnectedOutput1.eps} // \includegraphics[width=0.24\textwidth]{VectorConfidenceConnectedOutput2.eps} // \includegraphics[width=0.24\textwidth]{VectorConfidenceConnectedOutput3.eps} // \itkcaption[VectorConfidenceConnected segmentation results]{Segmentation results of // the VectorConfidenceConnected filter for various seed points.} // \label{fig:VectorConfidenceConnectedOutput} // \end{figure} // // The coloration of muscular tissue makes it easy to distinguish them from // the surrounding anatomical structures. The optic vitrea on the other hand // has a coloration that is not very homogeneous inside the eyeball and // does not allow generating a full segmentation based only on color. // // Software Guide : EndLatex // Software Guide : BeginLatex // // The values of the final mean vector and covariance matrix used for the // last iteration can be queried using the methods \code{GetMean()} and // \code{GetCovariance()}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef ConnectedFilterType::MeanVectorType MeanVectorType; const MeanVectorType & mean = confidenceConnected->GetMean(); std::cout << "Mean vector = " << std::endl; std::cout << mean << std::endl; typedef ConnectedFilterType::CovarianceMatrixType CovarianceMatrixType; const CovarianceMatrixType & covariance = confidenceConnected->GetCovariance(); std::cout << "Covariance matrix = " << std::endl; std::cout << covariance << std::endl; // Software Guide : EndCodeSnippet return 0; } OTB-release-5.8/Examples/Segmentation/WatershedSegmentation.cxx000066400000000000000000000260771301006202600246750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_3.tif} // OUTPUTS: {WatershedSegmentation1Output1.png} // 2 10 0 0.05 1 // Software Guide : EndCommandLineArgs // Software Guide : BeginCommandLineArgs // INPUTS: {ROI_QB_MUL_3.tif} // OUTPUTS: {WatershedSegmentation1Output2.png} // 2 10 0.001 0.15 0 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // The following example illustrates how to preprocess and segment images // using the \doxygen{itk}{WatershedImageFilter}. Note that the care with which // the data is preprocessed will greatly affect the quality of your result. // Typically, the best results are obtained by preprocessing the original // image with an edge-preserving diffusion filter, such as one of the // anisotropic diffusion filters, or with the bilateral image filter. As // noted in Section~\ref{sec:AboutWatersheds}, the height function used as // input should be created such that higher positive values correspond to // object boundaries. A suitable height function for many applications can // be generated as the gradient magnitude of the image to be segmented. // // The \doxygen{itk}{VectorGradientMagnitudeAnisotropicDiffusionImageFilter} class // is used to smooth the image and the // \doxygen{itk}{VectorGradientMagnitudeImageFilter} is used to generate the // height function. We begin by including all preprocessing filter header // files and the header file for the WatershedImageFilter. We // use the vector versions of these filters because the input data is a color // image. // // // Software Guide : EndLatex #include #include "itkUnaryFunctorImageFilter.h" // Software Guide : BeginCodeSnippet #include "itkVectorGradientAnisotropicDiffusionImageFilter.h" #include "itkVectorGradientMagnitudeImageFilter.h" #include "itkWatershedImageFilter.h" // Software Guide : EndCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVectorCastImageFilter.h" #include "itkScalarToRGBPixelFunctor.h" int main(int argc, char *argv[]) { if (argc < 8) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage outputImage conductanceTerm diffusionIterations lowerThreshold outputScaleLevel gradientMode " << std::endl; return 1; } // Software Guide : BeginLatex // // We now declare the image and pixel types to use for instantiation of the // filters. All of these filters expect real-valued pixel types in order to // work properly. The preprocessing stages are done directly on the // vector-valued data and the segmentation is done using floating point // scalar data. Images are converted from RGB pixel type to // numerical vector type using \doxygen{itk}{VectorCastImageFilter}. // Please pay attention to the fact that we are using // \doxygen{itk}{Image}s since the // \doxygen{itk}{VectorGradientMagnitudeImageFilter} has some // internal typedefs which make polymorfism impossible. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RGBPixel RGBPixelType; typedef otb::Image RGBImageType; typedef itk::Vector VectorPixelType; typedef itk::Image VectorImageType; typedef itk::Image LabeledImageType; typedef itk::Image ScalarImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The various image processing filters are declared using the types created // above and eventually used in the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader FileReaderType; typedef itk::VectorCastImageFilter CastFilterType; typedef itk::VectorGradientAnisotropicDiffusionImageFilter DiffusionFilterType; typedef itk::VectorGradientMagnitudeImageFilter GradientMagnitudeFilterType; typedef itk::WatershedImageFilter WatershedFilterType; // Software Guide : EndCodeSnippet typedef otb::ImageFileWriter FileWriterType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetFileName(argv[1]); CastFilterType::Pointer caster = CastFilterType::New(); // Software Guide : BeginLatex // // Next we instantiate the filters and set their parameters. The first // step in the image processing pipeline is diffusion of the color input // image using an anisotropic diffusion filter. For this class of filters, // the CFL condition requires that the time step be no more than 0.25 for // two-dimensional images, and no more than 0.125 for three-dimensional // images. The number of iterations and the conductance term will be taken // from the command line. See // Section~\ref{sec:EdgePreservingSmoothingFilters} for more information on // the ITK anisotropic diffusion filters. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet DiffusionFilterType::Pointer diffusion = DiffusionFilterType::New(); diffusion->SetNumberOfIterations(atoi(argv[4])); diffusion->SetConductanceParameter(atof(argv[3])); diffusion->SetTimeStep(0.125); diffusion->SetUseImageSpacing(false); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The ITK gradient magnitude filter for vector-valued images can optionally // take several parameters. Here we allow only enabling or disabling // of principal component analysis. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet GradientMagnitudeFilterType::Pointer gradient = GradientMagnitudeFilterType::New(); gradient->SetUsePrincipleComponents(atoi(argv[7])); gradient->SetUseImageSpacingOff(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally we set up the watershed filter. There are two parameters. // \code{Level} controls watershed depth, and \code{Threshold} controls the // lower thresholding of the input. Both parameters are set as a // percentage (0.0 - 1.0) of the maximum depth in the input image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet WatershedFilterType::Pointer watershed = WatershedFilterType::New(); watershed->SetLevel(atof(argv[6])); watershed->SetThreshold(atof(argv[5])); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The output of WatershedImageFilter is an image of unsigned long integer // labels, where a label denotes membership of a pixel in a particular // segmented region. This format is not practical for visualization, so // for the purposes of this example, we will convert it to RGB pixels. RGB // images have the advantage that they can be saved as a simple png file // and viewed using any standard image viewer software. The // \subdoxygen{itk}{Functor}{ScalarToRGBPixelFunctor} class is a special // function object designed to hash a scalar value into an // \doxygen{itk}{RGBPixel}. Plugging this functor into the // \doxygen{itk}{UnaryFunctorImageFilter} creates an image filter for that // converts scalar images to RGB images. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::Functor::ScalarToRGBPixelFunctor ColorMapFunctorType; typedef itk::UnaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); // Software Guide : EndCodeSnippet FileWriterType::Pointer writer = FileWriterType::New(); writer->SetFileName(argv[2]); // Software Guide : BeginLatex // // The filters are connected into a single pipeline, with readers and // writers at each end. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet caster->SetInput(reader->GetOutput()); diffusion->SetInput(caster->GetOutput()); gradient->SetInput(diffusion->GetOutput()); watershed->SetInput(gradient->GetOutput()); colormapper->SetInput(watershed->GetOutput()); writer->SetInput(colormapper->GetOutput()); // Software Guide : EndCodeSnippet try { writer->Update(); } catch (itk::ExceptionObject& e) { std::cerr << e << std::endl; } return EXIT_SUCCESS; } // // Software Guide : BeginLatex // // \begin{figure} \center // \includegraphics[width=0.32\textwidth]{ROI_QB_MUL_3.eps} // \includegraphics[width=0.32\textwidth]{WatershedSegmentation1Output1.eps} // \includegraphics[width=0.32\textwidth]{WatershedSegmentation1Output2.eps} // \itkcaption[Watershed segmentation output]{Segmented RGB image. At left is the original image. The // image in the middle was generated with parameters: conductance = 2.0, // iterations = 10, threshold = 0.0, level = 0.05, principal components = on. // The image on the right was generated with parameters: conductance = 2.0, // iterations = 10, threshold = 0.001, level = 0.15, principal components = // off. } \label{fig:outputWatersheds} \end{figure} // // // Tuning the filter parameters for any particular application is a process // of trial and error. The \emph{threshold} parameter can be used to great // effect in controlling oversegmentation of the image. Raising the // threshold will generally reduce computation time and produce output with // fewer and larger regions. The trick in tuning parameters is to consider // the scale level of the objects that you are trying to segment in the // image. The best time/quality trade-off will be achieved when the image is // smoothed and thresholded to eliminate features just below the desired // scale. // // Figure~\ref{fig:outputWatersheds} shows output from the example code. Note that a critical difference between the two // segmentations is the mode of the gradient magnitude calculation. // // A note on the computational complexity of the watershed algorithm is // warranted. Most of the complexity of the ITK implementation lies in // generating the hierarchy. Processing times for this stage are non-linear // with respect to the number of catchment basins in the initial segmentation. // This means that the amount of information contained in an image is more // significant than the number of pixels in the image. A very large, but very // flat input take less time to segment than a very small, but very detailed // input. // // Software Guide : EndLatex OTB-release-5.8/Examples/Segmentation/test/000077500000000000000000000000001301006202600206105ustar00rootroot00000000000000OTB-release-5.8/Examples/Segmentation/test/CMakeLists.txt000066400000000000000000000240321301006202600233510ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Segmentation) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- IsolatedConnectedImageFilterTest---------- otb_add_test(NAME seTeIsolatedConnectedImageFilterTest2 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/IsolatedConnectedImageFilterOutput1.png ${TEMP}/IsolatedConnectedImageFilterOutput1.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/IsolatedConnectedImageFilterOutput1.png 61 140 150 63 43 ) # ------- FastMarchingImageFilterTest---------- otb_add_test(NAME seTeFastMarchingImageFilterTest1 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/FastMarchingImageFilterOutput5.png ${TEMP}/FastMarchingImageFilterOutput5.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/FastMarchingImageFilterOutput5.png 91 176 0.5 -0.5 3.0 10000 10000 ) # ------- FastMarchingImageFilterTest---------- otb_add_test(NAME seTeFastMarchingImageFilterTest2 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/FastMarchingImageFilterOutput6.png ${TEMP}/FastMarchingImageFilterOutput6.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/FastMarchingImageFilterOutput6.png 118 100 1.0 -0.5 3.0 10000 10000 ) # ------- FastMarchingImageFilterTest---------- otb_add_test(NAME seTeFastMarchingImageFilterTest3 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/FastMarchingImageFilterOutput7.png ${TEMP}/FastMarchingImageFilterOutput7.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/FastMarchingImageFilterOutput7.png 145 21 0.5 -0.5 3.0 10000 10000 ) # ------- OtsuThresholdImageFilterTest---------- otb_add_test(NAME seTeOtsuThresholdImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/OtsuThresholdImageFilterOutput.png ${TEMP}/OtsuThresholdImageFilterOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/OtsuThresholdImageFilterOutput.png 255 0 ) # ------- ConfidenceConnectedTest---------- otb_add_test(NAME seTeConfidenceConnectedTest1 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ConfidenceConnectedOutput1.png ${TEMP}/ConfidenceConnectedOutput1.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ConfidenceConnectedOutput1.png 110 38 ) # ------- ConfidenceConnectedTest---------- otb_add_test(NAME seTeConfidenceConnectedTest2 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ConfidenceConnectedOutput2.png ${TEMP}/ConfidenceConnectedOutput2.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ConfidenceConnectedOutput2.png 118 100 ) # ------- ConfidenceConnectedTest---------- otb_add_test(NAME seTeConfidenceConnectedTest3 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ConfidenceConnectedOutput3.png ${TEMP}/ConfidenceConnectedOutput3.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ConfidenceConnectedOutput3.png 169 146 ) # ------- VectorConfidenceConnectedTest---------- otb_add_test(NAME seTeVectorConfidenceConnectedTest1 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/VectorConfidenceConnectedOutput1.png ${TEMP}/VectorConfidenceConnectedOutput1.png Execute $ ${INPUTDATA}/maur_rgb.png ${TEMP}/VectorConfidenceConnectedOutput1.png 3.5 # multiplier 10 # iterations 113 234 # seed index ) otb_add_test(NAME seTeVectorConfidenceConnectedTest2 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/VectorConfidenceConnectedOutput2.png ${TEMP}/VectorConfidenceConnectedOutput2.png Execute $ ${INPUTDATA}/maur_rgb.png ${TEMP}/VectorConfidenceConnectedOutput2.png 3.5 # multiplier 10 # iterations 216 30 # seed index ) otb_add_test(NAME seTeVectorConfidenceConnectedTest3 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/VectorConfidenceConnectedOutput3.png ${TEMP}/VectorConfidenceConnectedOutput3.png Execute $ ${INPUTDATA}/maur_rgb.png ${TEMP}/VectorConfidenceConnectedOutput3.png 3.5 # multiplier 10 # iterations 113 234 # seed 1 57 217 # seed 2 136 190 # seed 3 ) # ------- NeighborhoodConnectedImageFilterTest---------- otb_add_test(NAME seTeNeighborhoodConnectedImageFilterTest1 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodConnectedThresholdOutput1.png ${TEMP}/NeighborhoodConnectedThresholdOutput1.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/NeighborhoodConnectedThresholdOutput1.png 110 38 50 100 ) # ------- NeighborhoodConnectedImageFilterTest---------- otb_add_test(NAME seTeNeighborhoodConnectedImageFilterTest2 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodConnectedThresholdOutput2.png ${TEMP}/NeighborhoodConnectedThresholdOutput2.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/NeighborhoodConnectedThresholdOutput2.png 118 100 0 10 ) # ------- NeighborhoodConnectedImageFilterTest---------- otb_add_test(NAME seTeNeighborhoodConnectedImageFilterTest3 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/NeighborhoodConnectedThresholdOutput3.png ${TEMP}/NeighborhoodConnectedThresholdOutput3.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/NeighborhoodConnectedThresholdOutput3.png 169 146 220 255 ) # ------- WatershedSegmentationTest---------- #This first implementation of the WatershedSegmentationTest was commented because #it is duplicated below with the same name but with different input parameters. #Moreover, NO baseline file for this first implementation is available in the #OTB-Data directory. #otb_add_test(NAME seTeWatershedSegmentationTest1 COMMAND ${OTB_TEST_DRIVER} # --compare-n-images ${NOTOL} 1 # ${BASELINE}/WatershedSegmentation1Output1.png # ${TEMP}/WatershedSegmentation1Output1.png # Execute $ # ${INPUTDATA}/ROI_QB_MUL_3.tif # ${TEMP}/WatershedSegmentation1Output1.png # 2 10 0 0.05 1 #) # ------- WatershedSegmentationTest---------- #otb_add_test(NAME seTeWatershedSegmentationTest2 COMMAND ${OTB_TEST_DRIVER} #--compare-n-images ${NOTOL} 1 #${BASELINE}/WatershedSegmentation1Output2.png #${TEMP}/WatershedSegmentation1Output2.png #Execute $ #${INPUTDATA}/ROI_QB_MUL_3.tif #${TEMP}/WatershedSegmentation1Output2.png #2 10 0.001 0.15 0 #) # ------- ConnectedThresholdImageFilterTest---------- otb_add_test(NAME seTeConnectedThresholdImageFilterTest1 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ConnectedThresholdOutput1.png ${TEMP}/ConnectedThresholdOutput1.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ConnectedThresholdOutput1.png 110 38 50 100 ) # ------- ConnectedThresholdImageFilterTest---------- otb_add_test(NAME seTeConnectedThresholdImageFilterTest2 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ConnectedThresholdOutput2.png ${TEMP}/ConnectedThresholdOutput2.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ConnectedThresholdOutput2.png 118 100 0 10 ) # ------- ConnectedThresholdImageFilterTest---------- otb_add_test(NAME seTeConnectedThresholdImageFilterTest3 COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/ConnectedThresholdOutput3.png ${TEMP}/ConnectedThresholdOutput3.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/ConnectedThresholdOutput3.png 169 146 220 255 ) # ------- OtsuMultipleThresholdImageFilterTest---------- otb_add_test(NAME seTeOtsuMultipleThresholdImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 3 ${BASELINE}/OtsuMultipleThresholdsOutput000.png ${TEMP}/OtsuMultipleThresholdsOutput000.png ${BASELINE}/OtsuMultipleThresholdsOutput001.png ${TEMP}/OtsuMultipleThresholdsOutput001.png ${BASELINE}/OtsuMultipleThresholdsOutput002.png ${TEMP}/OtsuMultipleThresholdsOutput002.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/OtsuMultipleThresholdsOutput000.png ${TEMP}/OtsuMultipleThresholdsOutput001.png ${TEMP}/OtsuMultipleThresholdsOutput002.png ) # ------- LabelizeNeighborhoodConnectedImageFilterTest---------- otb_add_test(NAME seTeLabelizeNeighborhoodConnectedImageFilterTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 1 ${BASELINE}/LabelizeNeighborhoodConnectedImageFilterOutput.png ${TEMP}/LabelizeNeighborhoodConnectedImageFilterOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/LabelizeNeighborhoodConnectedImageFilterOutput.png 170 170 80 80 ) # ------- StreamingMeanShiftSegmentationTest ---------- if(OTBMathParser_LOADED) otb_add_test(NAME seTeStreamingMeanShiftSegmentationTest COMMAND ${OTB_TEST_DRIVER} # --compare-ogr ${NOTOL} # ${BASELINE_FILES}/seTeStreamingMeanShiftSegmentationTest.shp # ${TEMP}/seTeStreamingMeanShiftSegmentationTest.shp Execute $ ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${INPUTDATA}/QB_Toulouse_Ortho_PAN_Mask.tif ${TEMP}/seTeStreamingMeanShiftSegmentationTest.shp NewLayer 100 5 15. 100 1 #filter small object 50 #minimum size of object 1 #Simplify Flag 0.2 #Simplification tolerance ) endif() OTB-release-5.8/Examples/Simulation/000077500000000000000000000000001301006202600173205ustar00rootroot00000000000000OTB-release-5.8/Examples/Simulation/CMakeLists.txt000066400000000000000000000010401301006202600220530ustar00rootroot00000000000000project(SimulationExamples) #OTBSimulation -> OTBOpticalCalibration -> OTB6S if(OTB6S_LOADED) add_executable(LAIAndPROSAILToSensorResponse LAIAndPROSAILToSensorResponse.cxx) target_link_libraries(LAIAndPROSAILToSensorResponse ${OTB_LIBRARIES}) add_executable(ProsailModel ProsailModel.cxx) target_link_libraries(ProsailModel ${OTB_LIBRARIES}) endif() add_executable(LAIFromNDVIImageTransform LAIFromNDVIImageTransform.cxx) target_link_libraries(LAIFromNDVIImageTransform ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Simulation/LAIAndPROSAILToSensorResponse.cxx000066400000000000000000000672701301006202600253560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // // INPUTS: {LAIverySmallFSATSW.tif, Simu_label_LAI.png, Simu_mask_LAI_1.png, label-params-SO-2006-Level-2.txt, acqui-params.txt, rep6S.dat} // OUTPUTS: {siTvLAIAndPROSAILToSensorResponse.tif} // 5 // Software Guide : EndCommandLineArgs // // Software Guide : BeginLatex // // The following code is an example of Sensor spectral response image generated using image of labeled objects image, objects properties (vegetation classes are handled using PROSAIL model, non-vegetation classes // are characterized using \href{http://speclib.jpl.nasa.gov/}{Aster database} characteristics provided by a text file), acquisition parameters, sensor characteristics, and LAI (Leaf Area Index) image. // // Sensor RSR is modeled by 6S (Second Simulation of a Satellite Signal in the Solar Spectrum) model \cite{Vermote1997}. Detailed information about 6S can be found \href{http://6s.ltdri.org/6S_code2_thiner_stuff/6S_Manual_Part_1.pdf}{here}. // // Let's look at the minimal code required to use this algorithm. First, the // following headers must be included. // // Software Guide : EndLatex #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbVectorDataFileReader.h" #include "otbStandardWriterWatcher.h" #include "itkImageRegionConstIterator.h" #include "otbMultiChannelExtractROI.h" #include "itkOrImageFilter.h" // Software Guide : BeginCodeSnippet #include "otbLeafParameters.h" #include "otbReduceSpectralResponse.h" #include "otbImageSimulationMethod.h" #include "otbSpatialisationFilter.h" #include "otbAttributesMapLabelObject.h" #include "itkTernaryFunctorImageFilter.h" #include "otbRAndNIRIndexImageFilter.h" #include "otbVectorDataToLabelMapWithAttributesFilter.h" // Software Guide : EndCodeSnippet namespace otb { // Software Guide : BeginLatex // // \code{ImageUniqueValuesCalculator} class is defined here. Method \code{GetUniqueValues()} returns an array with all values contained in an image. // This class is implemented and used to test if all labels in labeled image are present in label parameter file. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet template < class TImage > class ITK_EXPORT ImageUniqueValuesCalculator : public itk::Object { public: typedef ImageUniqueValuesCalculator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(ImageUniqueValuesCalculator, itk::Object); itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); typedef typename TImage::PixelType PixelType; typedef TImage ImageType; typedef std::vector ArrayType; typedef typename ImageType::Pointer ImagePointer; typedef typename ImageType::ConstPointer ImageConstPointer; virtual void SetImage( const ImageType * image ) { if ( m_Image != image ) { m_Image = image; this->Modified(); } } ArrayType GetUniqueValues() const { ArrayType uniqueValues; if( !m_Image ) { return uniqueValues; } itk::ImageRegionConstIterator< ImageType > it( m_Image, m_Image->GetRequestedRegion() ); uniqueValues.push_back(it.Get()); ++it; while( !it.IsAtEnd() ) { if( std::find(uniqueValues.begin(), uniqueValues.end(), it.Get()) == uniqueValues.end()) { uniqueValues.push_back(it.Get()); } ++it; } return uniqueValues; } protected: ImageUniqueValuesCalculator() { m_Image = ITK_NULLPTR; } ~ImageUniqueValuesCalculator() ITK_OVERRIDE { } void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << indent << "Image: " << m_Image.GetPointer() << std::endl; } private: ImageUniqueValuesCalculator(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented ImageConstPointer m_Image; }; // class ImageUniqueValuesCalculator // EndCodeSnippet namespace Functor { // Software Guide : BeginLatex // // \code{ProsailSimulatorFunctor} functor is defined here. // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet template class ProsailSimulatorFunctor // Software Guide : EndCodeSnippet { public: /** Standard class typedefs */ // Software Guide : BeginLatex // // \code{ProsailSimulatorFunctor} functor is defined here. // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef TLAI LAIPixelType; typedef TLabel LabelPixelType; typedef TMask MaskPixelType; typedef TOutput OutputPixelType; typedef TLabelSpectra LabelSpectraType; typedef TLabelParameter LabelParameterType; typedef TAcquistionParameter AcquistionParameterType; typedef TSatRSR SatRSRType; typedef typename SatRSRType::Pointer SatRSRPointerType; typedef typename otb::ProspectModel ProspectType; typedef typename otb::SailModel SailType; typedef double PrecisionType; typedef std::pair PairType; typedef typename std::vector VectorPairType; typedef otb::SpectralResponse ResponseType; typedef ResponseType::Pointer ResponsePointerType; typedef otb::ReduceSpectralResponse ReduceResponseType; typedef typename ReduceResponseType::Pointer ReduceResponseTypePointerType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // In this example spectra are generated form $400$ to $2400nm$. the number of simulated band is set by \code{SimNbBands} value. // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet static const unsigned int SimNbBands = 2000; // Software Guide : EndCodeSnippet /** Constructor */ ProsailSimulatorFunctor() { m_SatRSR = SatRSRType::New(); m_InvertedMask = false; } /** Destructor */ ~ProsailSimulatorFunctor() { } ; void SetInvertedMask(bool ivm) { m_InvertedMask = ivm; } /** Implementation of the () operator*/ inline OutputPixelType operator ()(const LAIPixelType &lai, const LabelPixelType& label, const MaskPixelType& mask) { // Software Guide : BeginLatex // // mask value is read to know if the pixel have to be calculated, it is set to 0 otherwise. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet OutputPixelType pix; pix.SetSize(m_SatRSR->GetNbBands()); if ((!mask && !m_InvertedMask) || (mask && m_InvertedMask)) { for (unsigned int i = 0; i < m_SatRSR->GetNbBands(); i++) pix[i] = static_cast (0); return pix; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Object reflectance \code{hxSpectrum} is calculated. If object label correspond to vegetation label then Prosail code is used, aster database is used otherwise. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet VectorPairType hxSpectrum; for (unsigned int i = 0; i < SimNbBands; i++) { PairType resp; resp.first = static_cast ((400.0 + i) / 1000); hxSpectrum.push_back(resp); } // either the spectrum has to be simulated by Prospect+Sail if (m_LabelParameters.find(label) != m_LabelParameters.end()) { ProspectType::Pointer prospect = ProspectType::New(); prospect->SetInput(m_LabelParameters[label]); SailType::Pointer sail = SailType::New(); sail->SetLAI(lai); sail->SetAngl(m_AcquisitionParameters[std::string("Angl")]); sail->SetPSoil(m_AcquisitionParameters[std::string("PSoil")]); sail->SetSkyl(m_AcquisitionParameters[std::string("Skyl")]); sail->SetHSpot(m_AcquisitionParameters[std::string("HSpot")]); sail->SetTTS(m_AcquisitionParameters[std::string("TTS")]); sail->SetTTO(m_AcquisitionParameters[std::string("TTO")]); sail->SetPSI(m_AcquisitionParameters[std::string("PSI")]); sail->SetReflectance(prospect->GetReflectance()); sail->SetTransmittance(prospect->GetTransmittance()); sail->Update(); for (unsigned int i = 0; i < SimNbBands; i++) { hxSpectrum[i].second = static_cast (sail->GetHemisphericalReflectance()->GetResponse()[i].second); } } // or the spectra has been set from outside the functor (ex. bare soil, etc.) else if (m_LabelSpectra.find(label) != m_LabelSpectra.end()) { for (unsigned int i = 0; i < SimNbBands; i++) hxSpectrum[i].second = static_cast (m_LabelSpectra[label][i]); } // or the class does not exist else { for (unsigned int i = 0; i < SimNbBands; i++) hxSpectrum[i].second = static_cast (0); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Spectral response \code{aResponse} is set using \code{hxSpectrum}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ResponseType::Pointer aResponse = ResponseType::New(); aResponse->SetResponse(hxSpectrum); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Satellite RSR is initialized and set with \code{aResponse}. Reflectance // mode is used in this case to take into account solar irradiance into // spectral response reduction. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ReduceResponseTypePointerType reduceResponse = ReduceResponseType::New(); reduceResponse->SetInputSatRSR(m_SatRSR); reduceResponse->SetInputSpectralResponse(aResponse); reduceResponse->SetReflectanceMode(true); reduceResponse->CalculateResponse(); VectorPairType reducedResponse = reduceResponse->GetReduceResponse()->GetResponse(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \code{pix} value is returned for desired Satellite bands // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned int i = 0; i < m_SatRSR->GetNbBands(); i++) pix[i] = static_cast (reducedResponse[i].second); return pix; // Software Guide : EndCodeSnippet } bool operator !=(const ProsailSimulatorFunctor& other) const { return (m_AcquisitionParameters != other.m_AcquisitionParameters || m_LabelParameters != other.m_LabelParameters); } bool operator ==(const ProsailSimulatorFunctor& other) const { return (m_AcquisitionParameters == other.m_AcquisitionParameters && m_LabelParameters == other.m_LabelParameters); } /** The spectra associated with labels are supposed to have the same * sampling as a Prosail simulation, that is, 2000 bands starting at * 400nm up to 2400 nm*/ inline void SetLabelSpectra(const TLabelSpectra& lSpectra) { m_LabelSpectra = lSpectra; } inline void SetLabelParameters(const TLabelParameter& lParameters) { m_LabelParameters = lParameters; } inline void SetAcquisitionParameters(const TAcquistionParameter& aParameters) { m_AcquisitionParameters = aParameters; } inline void SetRSR(const SatRSRPointerType rsr) { m_SatRSR = rsr; } inline SatRSRPointerType GetRSR() const { return m_SatRSR; } protected: /** Spectra associated to labels*/ LabelSpectraType m_LabelSpectra; /** Prospect+sail parameters to labels*/ LabelParameterType m_LabelParameters; /** Prospect+sail acquisition parameters*/ AcquistionParameterType m_AcquisitionParameters; /** Satellite Relative spectral response*/ SatRSRPointerType m_SatRSR; /** Simulate pixels with mask != 0 ==> m_InvertedMask = false; */ bool m_InvertedMask; }; } // namespace Functor // Software Guide : BeginLatex // // \code{TernaryFunctorImageFilterWithNBands} class is defined here. // This class inherits form \doxygen{itk::TernaryFunctorImageFilter} with additional nuber of band parameters. // It's implementation is done to process Label, LAI, and mask image with Simulation functor. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet template class ITK_EXPORT TernaryFunctorImageFilterWithNBands : public itk::TernaryFunctorImageFilter< TInputImage1, TInputImage2, TInputImage3, TOutputImage, TFunctor > { public: typedef TernaryFunctorImageFilterWithNBands Self; typedef itk::TernaryFunctorImageFilter< TInputImage1, TInputImage2, TInputImage3, TOutputImage, TFunctor > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(TernaryFunctorImageFilterWithNBands, SuperClass); /** Accessors for the number of bands*/ itkSetMacro(NumberOfOutputBands, unsigned int); itkGetConstMacro(NumberOfOutputBands, unsigned int); protected: TernaryFunctorImageFilterWithNBands() {} ~TernaryFunctorImageFilterWithNBands() ITK_OVERRIDE {} void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( m_NumberOfOutputBands ); } private: TernaryFunctorImageFilterWithNBands(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfOutputBands; }; // EndCodeSnippet } int main(int argc, char *argv[]) { char *cmifname = ITK_NULLPTR; if (argc != 10) { if (argc == 11) // cloud mask filename optional parameter { cmifname = argv[10]; } else { std::cerr << "Wrong Parameters " << std::endl; return EXIT_FAILURE; } } char * laiifname = argv[1]; char * outfname = argv[2]; char * lifname = argv[3]; char * mifname = argv[4]; char * lpfname = argv[5]; char * apfname = argv[6]; char * rsfname = argv[7]; unsigned int nbBands = static_cast (atoi(argv[8])); char * rootPath = argv[9]; // Read the label parameter file. It is assumed to have the form // label 1 Cab Car CBrown Cw Cm N --> for vegetation classes // label 0 /path/to/spectra/file --> for other classes // Software Guide : BeginLatex // // input images typedef are presented below. This example uses \code{double} LAI image, \code{binary} mask and // cloud mask, and \code{integer} label image // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double LAIPixelType; typedef unsigned short LabelType; typedef unsigned short MaskPixelType; typedef float OutputPixelType; // Image typedef typedef otb::Image LAIImageType; typedef otb::Image LabelImageType; typedef otb::Image MaskImageType; typedef otb::VectorImage SimulatedImageType; // Software Guide : EndCodeSnippet // reader typedef typedef otb::ImageFileReader LAIReaderType; typedef otb::ImageFileReader LabelReaderType; typedef otb::ImageFileReader MaskReaderType; // Software Guide : BeginCodeSnippet // Software Guide : BeginLatex // // Leaf parameters typedef is defined. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LeafParameters LeafParametersType; typedef LeafParametersType::Pointer LeafParametersPointerType; typedef std::map LabelParameterMapType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Sensor spectral response typedef is defined // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PrecisionType; typedef std::vector SpectraType; typedef std::map SpectraParameterType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Acquisition response typedef is defined // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef std::map AcquistionParsType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Satellite typedef is defined // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SatelliteRSR SatRSRType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Filter type is the specific \code{TernaryFunctorImageFilterWithNBands} defined below with specific functor. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Functor::ProsailSimulatorFunctor SimuFunctorType; typedef otb::TernaryFunctorImageFilterWithNBands SimulatorType; // Software Guide : EndCodeSnippet // Read the acquisition parameter file which is like // Angl val // PSoil val // Skyl val // HSpot val // TTS val // TTO val // PSI val // Software Guide : BeginLatex // // Acquisition parameters are loaded using text file. A detailed definition of acquisition parameters can // be found in class \doxygen{SailModel}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet AcquistionParsType acquistionPars; acquistionPars[std::string("Angl")] = 0.0; acquistionPars[std::string("PSoil")] = 0.0; acquistionPars[std::string("Skyl")] = 0.0; acquistionPars[std::string("HSpot")] = 0.0; acquistionPars[std::string("TTS")] = 0.0; acquistionPars[std::string("TTO")] = 0.0; acquistionPars[std::string("PSI")] = 0.0; std::ifstream acquistionParsFile; try { acquistionParsFile.open(apfname); } catch (...) { std::cerr << "Could not open file " << apfname << std::endl; return EXIT_FAILURE; } //unsigned int acPar = 0; while (acquistionParsFile.good()) { std::string line; std::getline(acquistionParsFile, line); std::stringstream ss(line); std::string parName; ss >> parName; double parValue; ss >> parValue; acquistionPars[parName] = parValue; } acquistionParsFile.close(); //Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Label parameters are loaded using text file. // Two type of object characteristic can be found. If label corresponds to vegetation class, // then leaf parameters are loaded. // A detailed definition of leaf parameters can be found in class \doxygen{otb}{LeafParameters} class. // Otherwise object reflectance is generated from $400$ to $2400nm$ using \href{http://speclib.jpl.nasa.gov/}{Aster database}. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LabelParameterMapType labelParameters; std::ifstream labelParsFile; SpectraParameterType spectraParameters; try { labelParsFile.open(lpfname, std::ifstream::in); } catch (...) { std::cerr << "Could not open file " << lpfname << std::endl; return EXIT_FAILURE; } while (labelParsFile.good()) { char fileLine[256]; labelParsFile.getline(fileLine, 256); if (fileLine[0] != '#') { std::stringstream ss(fileLine); unsigned short label; ss >> label; unsigned short paramsOrSpectra; ss >> paramsOrSpectra; if (paramsOrSpectra == 1) { double Cab; ss >> Cab; double Car; ss >> Car; double CBrown; ss >> CBrown; double Cw; ss >> Cw; double Cm; ss >> Cm; double N; ss >> N; LeafParametersType::Pointer leafParams = LeafParametersType::New(); leafParams->SetCab(Cab); leafParams->SetCar(Car); leafParams->SetCBrown(CBrown); leafParams->SetCw(Cw); leafParams->SetCm(Cm); leafParams->SetN(N); labelParameters[label] = leafParams; } else { std::string spectraFilename = rootPath; ss >> spectraFilename; spectraFilename = rootPath + spectraFilename; typedef otb::SpectralResponse ResponseType; ResponseType::Pointer resp = ResponseType::New(); // Coefficient 100 since Aster database is given in % reflectance resp->Load(spectraFilename, 100.0); SpectraType spec; for (unsigned int i = 0; i < SimuFunctorType::SimNbBands; i++) //Prosail starts at 400 and lambda in Aster DB is in micrometers spec.push_back (static_cast ((*resp)((i + 400.0) / 1000.0))); spectraParameters[label] = spec; } } } labelParsFile.close(); //Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // LAI image is read. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LAIReaderType::Pointer laiReader = LAIReaderType::New(); laiReader->SetFileName(laiifname); laiReader->Update(); LAIImageType::Pointer laiImage = laiReader->GetOutput(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Label image is then read. Label image is processed using \code{ImageUniqueValuesCalculator} in order to check if all the labels are present in the labelParameters file. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LabelReaderType::Pointer labelReader = LabelReaderType::New(); labelReader->SetFileName(lifname); labelReader->Update(); LabelImageType::Pointer labelImage = labelReader->GetOutput(); typedef otb::ImageUniqueValuesCalculator UniqueCalculatorType; UniqueCalculatorType::Pointer uniqueCalculator = UniqueCalculatorType::New(); uniqueCalculator->SetImage(labelImage); UniqueCalculatorType::ArrayType uniqueVals = uniqueCalculator->GetUniqueValues(); if (uniqueVals.empty()) { std::cerr << "No label value found!"<< std::endl; return EXIT_FAILURE; } std::cout << "Labels are " << std::endl; UniqueCalculatorType::ArrayType::const_iterator uvIt = uniqueVals.begin(); while (uvIt != uniqueVals.end()) { std::cout << (*uvIt) << ", "; ++uvIt; } std::cout << std::endl; uvIt = uniqueVals.begin(); while (uvIt != uniqueVals.end()) { if (labelParameters.find(static_cast (*uvIt)) == labelParameters.end() && spectraParameters.find(static_cast (*uvIt)) == spectraParameters.end() && static_cast (*uvIt) != 0) { std::cout << "label " << (*uvIt) << " not found in " << lpfname << std::endl; return EXIT_FAILURE; } ++uvIt; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Mask image is read. If cloud mask is filename is given, a new mask image is generated with masks concatenation. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MaskReaderType::Pointer miReader = MaskReaderType::New(); miReader->SetFileName(mifname); miReader->UpdateOutputInformation(); MaskImageType::Pointer maskImage = miReader->GetOutput(); if (cmifname != ITK_NULLPTR) { MaskReaderType::Pointer cmiReader = MaskReaderType::New(); cmiReader->SetFileName(cmifname); cmiReader->UpdateOutputInformation(); typedef itk::OrImageFilter OrType; OrType::Pointer orfilter = OrType::New(); orfilter->SetInput1(miReader->GetOutput()); orfilter->SetInput2(cmiReader->GetOutput()); orfilter->Update(); maskImage = orfilter->GetOutput(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // A test is done. All images must have the same size. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (laiImage->GetLargestPossibleRegion().GetSize()[0] != labelImage->GetLargestPossibleRegion().GetSize()[0] || laiImage->GetLargestPossibleRegion().GetSize()[1] != labelImage->GetLargestPossibleRegion().GetSize()[1] || laiImage->GetLargestPossibleRegion().GetSize()[0] != maskImage->GetLargestPossibleRegion().GetSize()[0] || laiImage->GetLargestPossibleRegion().GetSize()[1] != maskImage->GetLargestPossibleRegion().GetSize()[1]) { std::cerr << "Image of labels, mask and LAI image must have the same size" << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Satellite RSR (Reduced Spectral Response) is defined using filename and band number given by command line arguments. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SatRSRType::Pointer satRSR = SatRSRType::New(); satRSR->SetNbBands(nbBands); satRSR->SetSortBands(false); satRSR->Load(rsfname); for (unsigned int i = 0; i < nbBands; ++i) std::cout << i << " " << (satRSR->GetRSR())[i]->GetInterval().first << " " << (satRSR->GetRSR())[i]->GetInterval().second << std::endl; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // At this step all initialization have been done. The next step is to implement and initialize simulation functor \code{ProsailSimulatorFunctor}. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SimuFunctorType simuFunctor; simuFunctor.SetLabelParameters(labelParameters); simuFunctor.SetLabelSpectra(spectraParameters); simuFunctor.SetAcquisitionParameters(acquistionPars); simuFunctor.SetRSR(satRSR); simuFunctor.SetInvertedMask(true); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Inputs and Functor are plugged to simulator filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet SimulatorType::Pointer simulator = SimulatorType::New(); simulator->SetInput1(laiImage); simulator->SetInput2(labelImage); simulator->SetInput3(maskImage); simulator->SetFunctor(simuFunctor); simulator->SetNumberOfOutputBands(nbBands); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The invocation of the \code{Update()} method triggers the // execution of the pipeline. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet simulator->Update(); // Software Guide : EndCodeSnippet // Write output image to disk typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(simulator->GetOutput()); // writer->SetBufferNumberOfLinesDivisions(nbStreams); otb::StandardWriterWatcher watcher(writer, simulator, "Simulation"); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Examples/Simulation/LAIFromNDVIImageTransform.cxx000066400000000000000000000140301301006202600246130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // // INPUTS: {verySmallFSATSW.tif} // OUTPUTS: {siTvLAIFromNDVIImageTransformExampleTest_verySmallFSATSW.tif}, {verySmallFSATSW_visu.png}, {siTvLAIFromNDVIImageTransformExampleTest_verySmallFSATSW_visu.png} // 1 4 // Software Guide : EndCommandLineArgs // // Software Guide : BeginLatex // // This example presents a way to generate LAI (Leaf Area Index) image using formula dedicated to Formosat2. // LAI Image is used as an input in Image Simulation process. // // Let's look at the minimal code required to use this algorithm. First, the // following headers must be included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbMultiChannelRAndNIRIndexImageFilter.h" // Software Guide : EndCodeSnippet #include "otbCommandLineArgumentParser.h" #include "otbImage.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char *argv[]) { if (argc != 7) { std::cerr << "Wrong Parameters " << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::Image ImageVisuType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter VisuWriterType; typedef otb::ImageFileWriter InWriterType; // Software Guide : BeginLatex // // Filter type is a generic \doxygen{otb}{MultiChannelRAndNIRIndexImageFilter} using Formosat2 specific LAI // \doxygen{otb}{LAIFromNDVIFormosat2Functor}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Functor::LAIFromNDVIFormosat2Functor FunctorType; typedef otb::MultiChannelRAndNIRIndexImageFilter MultiChannelRAndNIRIndexImageFilterType; // Software Guide : EndCodeSnippet // Instantiating object // Software Guide : BeginLatex // // Next the filter is created by invoking the \code{New()}~method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet MultiChannelRAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndNIRIndexImageFilterType::New(); // Software Guide : EndCodeSnippet ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); InWriterType::Pointer inWriter = InWriterType::New(); VisuWriterType::Pointer visuWriter = VisuWriterType::New(); char * InputName = argv[1]; char * OutputName1 = argv[2]; char * OutputName2 = argv[3]; char * OutputName3 = argv[4]; reader->SetFileName(InputName); // Software Guide : BeginLatex // // filter input is set with input image // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // then red and nir channels index are set using \code{SetRedIndex()} and \code{SetNIRIndex()} // // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet unsigned int redChannel = static_cast (atoi(argv[5])); unsigned int nirChannel = static_cast (atoi(argv[6])); filter->SetRedIndex(redChannel); filter->SetNIRIndex(nirChannel); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The invocation of the \code{Update()} method triggers the // execution of the pipeline. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->Update(); // Software Guide : EndCodeSnippet writer->SetFileName(OutputName1); writer->SetInput(filter->GetOutput()); writer->Update(); //rescale data inWriter->SetFileName(OutputName2); //typedef itk::RescaleIntensityImageFilter RescalerType; //RescalerType::Pointer rescaler = RescalerType::New(); //rescaler->SetInput(reader->GetOutput()); //rescaler->SetOutputMinimum(0); //rescaler->SetOutputMaximum(255); inWriter->SetInput(reader->GetOutput()); inWriter->Update(); visuWriter->SetFileName(OutputName3); typedef itk::RescaleIntensityImageFilter RescalerTypeOut; RescalerTypeOut::Pointer rescaler = RescalerTypeOut::New(); rescaler->SetInput(filter->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); visuWriter->SetInput(rescaler->GetOutput()); visuWriter->Update(); // Software Guide : BeginLatex // \begin{figure} // \center // \includegraphics[width=0.44\textwidth]{verySmallFSATSW_visu.eps} // \includegraphics[width=0.44\textwidth]{siTvLAIFromNDVIImageTransformExampleTest_verySmallFSATSW_visu.eps} // \itkcaption[LAIFromNDVIImageTransform Filter]{LAI generation \emph{(right)} from NDVI applied on Formosat 2 Image \emph{(left)} .} // \label{fig:LAIFromNDVIImageTransform} // \end{figure} // // Figure \ref{fig:LAIFromNDVIImageTransform} illustrates the LAI generation using Formosat 2 data. // // // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Simulation/ProsailModel.cxx000066400000000000000000000174131301006202600224440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: // 30.0 10.0 0.0 0.015 0.009 1.2 2 50 1 70 0.2 30 0 0 // OUTPUTS: SailReflTest.txt // Software Guide : EndCommandLineArgs // // Software Guide : BeginLatex // // This example presents how to use PROSAIL (Prospect + Sail) model to generate // viewing reflectance from leaf parameters, vegetation, and viewing parameters. // Output can be used to simulate image for example. // // Let's look at the minimal code required to use this algorithm. First, the // following headers must be included. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbSailModel.h" #include "otbProspectModel.h" // Software Guide : EndCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char *argv[]) { if (argc < 16) { std::cerr << "Missing Parameters " << std::endl; return EXIT_FAILURE; } char * OutputName = argv[15]; // Software Guide : BeginLatex // // We now define leaf parameters, which characterize vegetation composition. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::LeafParameters LeafParametersType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Next the parameters variable is created by invoking the \code{New()}~method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet LeafParametersType::Pointer leafParams = LeafParametersType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Leaf characteristics is then set. // Input parameters are : // \begin{itemize} // \item Chlorophyll concentration (Cab) in $\mu g/cm^2$. // \item Carotenoid concentration (Car) in $\mu g/cm^2$. // \item Brown pigment content (CBrown) in arbitrary unit. // \item Water thickness EWT (Cw) in $cm$. // \item Dry matter content LMA (Cm) in $g/cm^2$. // \item Leaf structure parameter (N). // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double Cab = static_cast (atof(argv[1])); double Car = static_cast (atof(argv[2])); double CBrown = static_cast (atof(argv[3])); double Cw = static_cast (atof(argv[4])); double Cm = static_cast (atof(argv[5])); double N = static_cast (atof(argv[6])); leafParams->SetCab(Cab); leafParams->SetCar(Car); leafParams->SetCBrown(CBrown); leafParams->SetCw(Cw); leafParams->SetCm(Cm); leafParams->SetN(N); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Leaf parameters are used as prospect input // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ProspectModel ProspectType; ProspectType::Pointer prospect = ProspectType::New(); prospect->SetInput(leafParams); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we use SAIL model to generate transmitance and reflectance spectrum. SAIL model is created by invoking // the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. // // Software Guide : EndLatex // Software Guide : BeginLatex // // sail input parameters are : // \begin{itemize} // \item leaf area index (LAI). // \item average leaf angle (Angle) in $\deg$. // \item soil coefficient (PSoil). // \item diffuse/direct radiation (Skyl). // \item hot spot (HSpot). // \item solar zenith angle (TTS) in $\deg$. // \item observer zenith angle (TTO) in $\deg$. // \item azimuth (PSI) in $\deg$. // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet double LAI = static_cast (atof(argv[7])); double Angle = static_cast (atof(argv[8])); double PSoil = static_cast (atof(argv[9])); double Skyl = static_cast (atof(argv[10])); double HSpot = static_cast (atof(argv[11])); double TTS = static_cast (atof(argv[12])); double TTO = static_cast (atof(argv[13])); double PSI = static_cast (atof(argv[14])); typedef otb::SailModel SailType; SailType::Pointer sail = SailType::New(); sail->SetLAI(LAI); sail->SetAngl(Angle); sail->SetPSoil(PSoil); sail->SetSkyl(Skyl); sail->SetHSpot(HSpot); sail->SetTTS(TTS); sail->SetTTO(TTO); sail->SetPSI(PSI); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Reflectance and Transmittance are set with prospect output. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet sail->SetReflectance(prospect->GetReflectance()); sail->SetTransmittance(prospect->GetTransmittance()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // The invocation of the \code{Update()} method triggers the // execution of the pipeline. // Software Guide : EndLatex // Software Guide : BeginCodeSnippet sail->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // \emph{GetViewingReflectance} method provides viewing reflectance vector (size $Nx2$, where $N$ is the number of sampled wavelength values, columns corresponds respectively to wavelength and viewing reflectance) by calling \emph{GetResponse}. // \emph{GetHemisphericalReflectance} method provides hemispherical reflectance vector (size $Nx2$, where $N$ is the number ofsampled wavelength values, columns corresponds to wavelength and hemispherical reflectance) by calling \emph{GetResponse}. // // Note that PROSAIL simulation are done for 2100 samples starting from 400nm up to 2500nm // Software Guide : EndLatex // Software Guide : BeginCodeSnippet for (unsigned int i = 0; i < sail->GetViewingReflectance()->Size(); ++i) { std::cout << "wavelength : "; std::cout << sail->GetViewingReflectance()->GetResponse()[i].first; std::cout << ". Viewing reflectance "; std::cout << sail->GetViewingReflectance()->GetResponse()[i].second; std::cout << ". Hemispherical reflectance "; std::cout << sail->GetHemisphericalReflectance()->GetResponse()[i].second; std::cout << std::endl; } // Software Guide : EndCodeSnippet std::ofstream outputFile(OutputName, std::ios::out); for (unsigned int i = 0; i < sail->GetHemisphericalReflectance()->Size(); ++i) { outputFile << sail->GetViewingReflectance()->GetResponse()[i].second << " "; outputFile << sail->GetHemisphericalReflectance()->GetResponse()[i].second<< std::endl; } // Software Guide : BeginLatex // // here you can found example parameters : // \begin{itemize} // \item Cab 30.0 // \item Car 10.0 // \item CBrown 0.0 // \item Cw 0.015 // \item Cm 0.009 // \item N 1.2 // \item LAI 2 // \item Angle 50 // \item PSoil 1 // \item Skyl 70 // \item HSpot 0.2 // \item TTS 30 // \item TTO 0 // \item PSI 0 // \end{itemize} // // More information and data about leaf properties can be found at \emph{St\'{e}phane Jacquemoud} \href{http://teledetection.ipgp.jussieu.fr/opticleaf/}{OPTICLEAF} website. // Software Guide : EndLatex return EXIT_SUCCESS; } OTB-release-5.8/Examples/Simulation/test/000077500000000000000000000000001301006202600202775ustar00rootroot00000000000000OTB-release-5.8/Examples/Simulation/test/CMakeLists.txt000066400000000000000000000036771301006202600230540ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Simulation) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) # ------- ProsailModelExampleTest ---------- #OTBSimulation -> OTBOpticalCalibration -> OTB6S if(OTB6S_LOADED) otb_add_test(NAME siTvProsailModelExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-ascii ${EPSILON_3} ${BASELINE}/siTvProsailModelExampleTest.txt ${TEMP}/siTvProsailModelExampleTest.txt Execute $ 30.0 #cab 10.0 #car 0.0 #CBrown 0.015 #Cw 0.009 #Cm 1.2 #N 2 #LAI 50 #Angl 1 #PSoil 70 #Skyl 0.2 #HSpot 30 #TTS 0 #TTO 0 #PSI ${TEMP}/siTvProsailModelExampleTest.txt ) otb_add_test(NAME siTvLAIAndPROSAILToSensorResponseExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${OTBAPP_BASELINE}/siTvLAIAndPROSAILToSensorResponseSmall.tif ${TEMP}/siTvLAIAndPROSAILToSensorResponseSmall.tif Execute $ ${OTB_DATA_ROOT}/Input/LAIveryverySmallFSATSW.tif ${TEMP}/siTvLAIAndPROSAILToSensorResponseSmall.tif ${OTB_DATA_ROOT}/Input/Simu_label_LAI_small.png ${OTB_DATA_ROOT}/Input/Simu_mask_LAI_0_small.png ${OTB_DATA_ROOT}/Input/label-params-SO-2006-Level-2.txt ${OTB_DATA_ROOT}/Input/acqui-params.txt ${OTB_DATA_ROOT}/Input/Radiometry/FORMOSAT2/RSI/rep6S.dat 5 ${OTB_DATA_ROOT}/Input/ ) endif() otb_add_test(NAME siTvLAIFromNDVIImageTransformExampleTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${EPSILON_8} ${OTB_DATA_ROOT}/Baseline/OTB/Images/raRAndNIRVegetationIndex_LAIFromNDVIFormosat2_verySmallFSATSWcRcNir.tif ${TEMP}/siTvLAIFromNDVIImageTransformExampleTest_verySmallFSATSW.tif Execute $ ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/siTvLAIFromNDVIImageTransformExampleTest_verySmallFSATSW.tif ${TEMP}/verySmallFSATSW_visu.png ${TEMP}/siTvLAIFromNDVIImageTransformExampleTest_verySmallFSATSW_visu.png 1 # red 4 # nir ) OTB-release-5.8/Examples/Tutorials/000077500000000000000000000000001301006202600171625ustar00rootroot00000000000000OTB-release-5.8/Examples/Tutorials/CMakeLists.txt000066400000000000000000000014771301006202600217330ustar00rootroot00000000000000project(TutorialsExamples) add_executable(FilteringPipeline FilteringPipeline.cxx) target_link_libraries(FilteringPipeline ${OTB_LIBRARIES}) add_executable(HelloWorldOTB HelloWorldOTB.cxx) target_link_libraries(HelloWorldOTB ${OTB_LIBRARIES}) add_executable(Multispectral Multispectral.cxx) target_link_libraries(Multispectral ${OTB_LIBRARIES}) add_executable(OrthoFusion OrthoFusion.cxx) target_link_libraries(OrthoFusion ${OTB_LIBRARIES}) add_executable(Pipeline Pipeline.cxx) target_link_libraries(Pipeline ${OTB_LIBRARIES}) add_executable(ScalingPipeline ScalingPipeline.cxx) target_link_libraries(ScalingPipeline ${OTB_LIBRARIES}) add_executable(SmarterFilteringPipeline SmarterFilteringPipeline.cxx) target_link_libraries(SmarterFilteringPipeline ${OTB_LIBRARIES}) if(BUILD_TESTING) add_subdirectory(test) endif() OTB-release-5.8/Examples/Tutorials/FilteringPipeline.cxx000066400000000000000000000060661301006202600233270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {TutorialsFilteringPipelineOutput.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // // We are going to use the \doxygen{itk}{GradientMagnitudeImageFilter} // to compute the gradient of the image. The beginning of the file is // similar to the Pipeline.cxx. // // We include the required headers, without forgetting to add the header // for the \doxygen{itk}{GradientMagnitudeImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkGradientMagnitudeImageFilter.h" int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " " << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the image type, the reader and the writer as // before: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we have to declare the filter. It is templated with the // input image type and the output image type like many filters // in OTB. Here we are using the same type for the input and the // output images: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::GradientMagnitudeImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's plug the pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we trigger the pipeline execution calling the \code{Update()} // method on the writer // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet OTB-release-5.8/Examples/Tutorials/HelloWorldOTB.cxx000066400000000000000000000030441301006202600223270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // The following code is an implementation of a small OTB // program. It tests including header files and linking with OTB // libraries. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include int main(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Image ImageType; ImageType::Pointer image = ImageType::New(); std::cout << "OTB Hello World !" << std::endl; return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // This code instantiates an image whose pixels are represented with // type \code{unsigned short}. The image is then created and assigned to a // \doxygen{itk}{SmartPointer}. Later in the text we will discuss // \code{SmartPointer}s in detail, for now think of it as a handle on an // instance of an object (see section \ref{sec:SmartPointers} for more // information). // // Software Guide : EndLatex OTB-release-5.8/Examples/Tutorials/Multispectral.cxx000066400000000000000000000167301301006202600225450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {qb_RoadExtract.tif} // OUTPUTS: {qb_blue.tif}, {qb_shiftscale.tif} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // First, we are going to use \doxygen{otb}{VectorImage} instead of the now // traditional \doxygen{otb}{Image}. So we include the required header: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We also include some other header which will be useful later. Note that we // are still using the \doxygen{otb}{Image} in this example for some of the // output. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "itkShiftScaleImageFilter.h" #include "otbPerBandVectorImageFilter.h" int main(int argc, char * argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0] << " " << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We want to read a multispectral image so we declare the image type and the // reader. As we have done in the previous example we get the filename from // the command line. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef unsigned short int PixelType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Sometime, you need to process only one spectral band of the image. To get // only one of the spectral band we use the // \doxygen{otb}{MultiToMonoChannelExtractROI}. The declaration is as usual: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::MultiToMonoChannelExtractROI ExtractChannelType; ExtractChannelType::Pointer extractChannel = ExtractChannelType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need to pass the parameters to the filter for the extraction. This // filter also allow extracting only a spatial subset of the image. However, // we will extract the whole channel in this case. // // To do that, we need to pass the desired region using the // \code{SetExtractionRegion()} (method such as \code{SetStartX}, // \code{SetSizeX} are also available). We get the region from the reader with // the \code{GetLargestPossibleRegion()} method. Before doing that we need to // read the metadata from the file: this is done by calling the // \code{UpdateOutputInformation()} on the reader's output. The difference with the // \code{Update()} is that the pixel array is not allocated (yet !) and reduce // the memory usage. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->UpdateOutputInformation(); extractChannel->SetExtractionRegion( reader->GetOutput()->GetLargestPossibleRegion()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We chose the channel number to extract (starting from 1) and we plug the // pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet extractChannel->SetChannel(3); extractChannel->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To output this image, we need a writer. As the output of the // \doxygen{otb}{MultiToMonoChannelExtractROI} is a \doxygen{otb}{Image}, we // need to template the writer with this type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(extractChannel->GetOutput()); writer->Update(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // After this, we have a one band image that we can process with most OTB // filters. // // In some situation, you may want to apply the same process to all bands of // the image. You don't have to extract each band and process them separately. // There is several situations: // // \begin{itemize} // \item the filter (or the combination of filters) you want to use are doing // operations that are well defined for \doxygen{itk}{VariableLengthVector} // (which is the pixel type), then you don't have to do anything special. // \item if this is not working, you can look for the equivalent filter // specially designed for vector images. // \item some of the filter you need to use applies operations undefined for // \doxygen{itk}{VariableLengthVector}, then you can use the // \doxygen{otb}{PerBandVectorImageFilter} specially designed for this // purpose. // \end{itemize} // // Let's see how this filter is working. We chose to apply the // \doxygen{itk}{ShiftScaleImageFilter} to each of the spectral band. We start // by declaring the filter on a normal \doxygen{otb}{Image}. Note that we // don't need to specify any input for this filter. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::ShiftScaleImageFilter ShiftScaleType; ShiftScaleType::Pointer shiftScale = ShiftScaleType::New(); shiftScale->SetScale(0.5); shiftScale->SetShift(10); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the \doxygen{otb}{PerBandVectorImageFilter} which has three // template: the input image type, the output image type and the filter type // to apply to each band. // // The filter is selected using the \code{SetFilter()} method and the input // by the usual \code{SetInput()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::PerBandVectorImageFilter VectorFilterType; VectorFilterType::Pointer vectorFilter = VectorFilterType::New(); vectorFilter->SetFilter(shiftScale); vectorFilter->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we just have to save the image using a writer templated over an // \doxygen{otb}{VectorImage}: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter VectorWriterType; VectorWriterType::Pointer writerVector = VectorWriterType::New(); writerVector->SetFileName(argv[3]); writerVector->SetInput(vectorFilter->GetOutput()); writerVector->Update(); return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet OTB-release-5.8/Examples/Tutorials/OrthoFusion.cxx000066400000000000000000000165621301006202600221770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginLatex // // Start by including some necessary headers and with the // usual \code{main} declaration. Apart from the classical header related to // image input and output. We need the headers related to the fusion and the // orthorectification. One header is also required to be able to process // vector images (the XS one) with the orthorectification. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbOrthoRectificationFilter.h" #include "otbGenericMapProjection.h" #include "otbSimpleRcsPanSharpeningFusionImageFilter.h" #include "otbStandardFilterWatcher.h" int main(int argc, char* argv[]) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We initialize ossim which is required for the orthorectification and we // check that all parameters are provided. Basically, we need: // \begin{itemize} // \item the name of the input PAN image; // \item the name of the input XS image; // \item the desired name for the output; // \item as the coordinates are given in UTM, we need the UTM zone number; // \item of course, we need the UTM coordinates of the final image; // \item the size in pixels of the final image; // \item and the sampling of the final image. // \end{itemize} // // We check that all those parameters are provided. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (argc != 12) { std::cout << argv[0] << " "; std::cout << " "; std::cout << " "; std::cout << " "; std::cout << " "; std::cout << "" << std::endl; return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the different images, readers and writer: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::Image DoubleImageType; typedef otb::VectorImage DoubleVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader VectorReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer readerPAN = ReaderType::New(); VectorReaderType::Pointer readerXS = VectorReaderType::New(); WriterType::Pointer writer = WriterType::New(); readerPAN->SetFileName(argv[1]); readerXS->SetFileName(argv[2]); writer->SetFileName(argv[3]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the projection (here we chose the UTM projection, other choices // are possible) and retrieve the parameters from the command line: // \begin{itemize} // \item the UTM zone // \item the hemisphere // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::GenericMapProjection InverseProjectionType; InverseProjectionType::Pointer utmMapProjection = InverseProjectionType::New(); utmMapProjection->SetWkt("Utm"); utmMapProjection->SetParameter("Zone", argv[4]); utmMapProjection->SetParameter("Hemisphere", argv[5]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We will need to pass several parameters to the orthorectification // concerning the desired output region: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet ImageType::IndexType start; start[0] = 0; start[1] = 0; ImageType::SizeType size; size[0] = atoi(argv[8]); size[1] = atoi(argv[9]); ImageType::SpacingType spacing; spacing[0] = atof(argv[10]); spacing[1] = atof(argv[11]); ImageType::PointType origin; origin[0] = strtod(argv[6], ITK_NULLPTR); origin[1] = strtod(argv[7], ITK_NULLPTR); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the orthorectification filter. And provide the different // parameters: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::OrthoRectificationFilter OrthoRectifFilterType; OrthoRectifFilterType::Pointer orthoRectifPAN = OrthoRectifFilterType::New(); orthoRectifPAN->SetMapProjection(utmMapProjection); orthoRectifPAN->SetInput(readerPAN->GetOutput()); orthoRectifPAN->SetOutputStartIndex(start); orthoRectifPAN->SetOutputSize(size); orthoRectifPAN->SetOutputSpacing(spacing); orthoRectifPAN->SetOutputOrigin(origin); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // Now we are able to have the orthorectified area from the PAN image. We just // have to follow a similar process for the XS image. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::OrthoRectificationFilter VectorOrthoRectifFilterType; VectorOrthoRectifFilterType::Pointer orthoRectifXS = VectorOrthoRectifFilterType::New(); orthoRectifXS->SetMapProjection(utmMapProjection); orthoRectifXS->SetInput(readerXS->GetOutput()); orthoRectifXS->SetOutputStartIndex(start); orthoRectifXS->SetOutputSize(size); orthoRectifXS->SetOutputSpacing(spacing); orthoRectifXS->SetOutputOrigin(origin); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It's time to declare the fusion filter and set its inputs: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::SimpleRcsPanSharpeningFusionImageFilter FusionFilterType; FusionFilterType::Pointer fusion = FusionFilterType::New(); fusion->SetPanInput(orthoRectifPAN->GetOutput()); fusion->SetXsInput(orthoRectifXS->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And we can plug it to the writer. To be able to process the images by // tiles, we use the \code{SetAutomaticTiledStreaming()} method of the writer. // We trigger the pipeline execution with the \code{Update()} method. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetInput(fusion->GetOutput()); writer->SetAutomaticTiledStreaming(); otb::StandardFilterWatcher watcher(writer, "OrthoFusion"); writer->Update(); return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet OTB-release-5.8/Examples/Tutorials/Pipeline.cxx000066400000000000000000000065131301006202600214600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {TutorialsPipelineOutput.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // Start by including some necessary headers and with the // usual \code{main} declaration: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " " << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Declare the image as an \doxygen{otb}{Image}, the pixel type // is declared as an unsigned char (one byte) and the image is specified as // having two dimensions. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::Image ImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To read the image, we need an \doxygen{otb}{ImageFileReader} // which is templated with the image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Then, we need an \doxygen{otb}{ImageFileWriter} // also templated with the image type. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The filenames are passed as arguments to the program. We keep it // simple for now and we don't check their validity. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now that we have all the elements, we connect the pipeline, // pluging the output of the reader to the input of the writer. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->SetInput(reader->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we trigger the pipeline execution calling the Update() // method on the last element of the pipeline. The last element will make // sure to update all previous elements in the pipeline. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet OTB-release-5.8/Examples/Tutorials/ScalingPipeline.cxx000066400000000000000000000113161301006202600227560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {TutorialsScalingPipelineOutput.png} // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // This example illustrates the use of the // \doxygen{itk}{RescaleIntensityImageFilter} to convert // the result for proper display. // // We include the required header including the header // for the \doxygen{itk}{CannyEdgeDetectionImageFilter} and the // \doxygen{itk}{RescaleIntensityImageFilter}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCannyEdgeDetectionImageFilter.h" #include "itkRescaleIntensityImageFilter.h" int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " " << std::endl; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We need to declare two different image types, one for the internal // processing and one to output the results: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PixelType; typedef otb::Image ImageType; typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We declare the reader with the image template using the pixel type // double. It is worth noticing that this instantiation does not imply // anything about the type of the input image. The original image can be // anything, the reader will just convert the result to double. // // The writer is templated with the unsigned char image to be able to save // the result on one byte images (like png for example). // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we are declaring the edge detection filter which is going to work with // double input and output. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::CannyEdgeDetectionImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Here comes the interesting part: we declare the // \doxygen{itk}{RescaleIntensityImageFilter}. The input // image type is the output type of the edge detection // filter. The output type is the same as the input type // of the writer. // // Desired minimum and maximum values for the output are // specified by the methods \code{SetOutputMinimum()} and // \code{SetOutputMaximum()}. // // This filter will actually rescale all the pixels of // the image but also cast the type of these pixels. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's plug the pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // And finally, we trigger the pipeline execution calling the Update() // method on the writer // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet OTB-release-5.8/Examples/Tutorials/SmarterFilteringPipeline.cxx000066400000000000000000000236601301006202600246640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Software Guide : BeginCommandLineArgs // INPUTS: {QB_Suburb.png} // OUTPUTS: {TutorialsSmarterFilteringPipelineOutput.png} // -d 1.5 -i 2 -a 0.1 // Software Guide : EndCommandLineArgs // Software Guide : BeginLatex // // // We are going to use the \doxygen{otb}{HarrisImageFilter} // to find the points of interest in one image. // // The derivative computation is performed by a // convolution with the derivative of a Gaussian kernel of // variance $\sigma_D$ (derivation scale) and // the smoothing of the image is performed by convolving with a // Gaussian kernel of variance $\sigma_I$ (integration // scale). This allows the computation of the following matrix: // // \[ // \mu(\mathbf{x},\sigma_I,\sigma_D) = \sigma_D^2 g(\sigma_I)\star // \left[\begin{array}{cc} L_x^2(\mathbf{x},\sigma_D) & // L_xL_y^2(\mathbf{x},\sigma_D)\\ L_xL_y^2(\mathbf{x},\sigma_D)& // L_y^2(\mathbf{x},\sigma_D) \end{array}\right] // \] // // The output of the detector is $\mathrm{det}(\mu) - \alpha // \mathrm{trace}^2(\mu)$. // // We want to set 3 parameters of this filter through the command line: // $\sigma_D$ (SigmaD), $\sigma_I$ (SigmaI) and $\alpha$ (Alpha). // // We are also going to do the things properly and catch the exceptions. // // Let first add the two following headers: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "itkMacro.h" #include "otbCommandLineArgumentParser.h" // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // The first one is to handle the exceptions, the second one to help us // parse the command line. // // We include the other required headers, without forgetting to add the header // for the \doxygen{otb}{HarrisImageFilter}. Then we start the usual main // function. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbHarrisImageFilter.h" int main(int argc, char * argv[]) { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // To handle the exceptions properly, we need to put all the instructions // inside a \code{try}. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet try { // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we can declare the \doxygen{otb}{CommandLineArgumentParser} which is // going to parse the command line, select the proper variables, handle the // missing compulsory arguments and print an error message if necessary. // // Let's declare the parser: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // It's now time to tell the parser what are the options we want. Special //options are available for input and output images with the // \code{AddInputImage()} and \code{AddOutputImage()} methods. // // For the other options, we need to use the \code{AddOption()} method. // This method allows us to specify // \begin{itemize} // \item the name of the option // \item a message to explain the meaning of this option // \item a shortcut for this option // \item the number of expected parameters for this option // \item whether or not this option is compulsory // \end{itemize} // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet parser->SetProgramDescription( "This program applies a Harris detector on the input image"); parser->AddInputImage(); parser->AddOutputImage(); parser->AddOption("--SigmaD", "Set the sigmaD parameter. Default is 1.0.", "-d", 1, false); parser->AddOption("--SigmaI", "Set the sigmaI parameter. Default is 1.0.", "-i", 1, false); parser->AddOption("--Alpha", "Set the alpha parameter. Default is 1.0.", "-a", 1, false); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now that the parser has all this information, it can actually look at // the command line to parse it. We have to do this within a \code{try} - // \code{catch} loop to handle exceptions nicely. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); } catch (itk::ExceptionObject& err) { std::string descriptionException = err.GetDescription(); if (descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos) { return EXIT_SUCCESS; } if (descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos) { return EXIT_SUCCESS; } return EXIT_FAILURE; } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now, we can declare the image type, the reader and the writer as // before: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef double PixelType; typedef otb::Image ImageType; typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We are getting the filenames for the input and the output // images directly from the parser: // // Software Guide : BeginLatex // Software Guide : BeginCodeSnippet reader->SetFileName(parseResult->GetInputImage().c_str()); writer->SetFileName(parseResult->GetOutputImage().c_str()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Now we have to declare the filter. It is templated with the // input image type and the output image type like many filters // in OTB. Here we are using the same type for the input and the // output images: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef otb::HarrisImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We set the filter parameters from the parser. The method // \code{IsOptionPresent()} let us know if an optional option // was provided in the command line. // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet if (parseResult->IsOptionPresent("--SigmaD")) filter->SetSigmaD( parseResult->GetParameterDouble("--SigmaD")); if (parseResult->IsOptionPresent("--SigmaI")) filter->SetSigmaI( parseResult->GetParameterDouble("--SigmaI")); if (parseResult->IsOptionPresent("--Alpha")) filter->SetAlpha( parseResult->GetParameterDouble("--Alpha")); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We add the rescaler filter as before // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Let's plug the pipeline: // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet filter->SetInput(reader->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // We trigger the pipeline execution calling the \code{Update()} // method on the writer // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet writer->Update(); } // Software Guide : EndCodeSnippet // Software Guide : BeginLatex // // Finally, we have to handle exceptions we may have raised before // // Software Guide : EndLatex // Software Guide : BeginCodeSnippet catch (itk::ExceptionObject& err) { std::cout << "Following otbException catch :" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } catch (std::bad_alloc& err) { std::cout << "Exception bad_alloc : " << (char*) err.what() << std::endl; return EXIT_FAILURE; } catch (...) { std::cout << "Unknown Exception found !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } // Software Guide : EndCodeSnippet OTB-release-5.8/Examples/Tutorials/test/000077500000000000000000000000001301006202600201415ustar00rootroot00000000000000OTB-release-5.8/Examples/Tutorials/test/CMakeLists.txt000066400000000000000000000047621301006202600227120ustar00rootroot00000000000000set(BASELINE ${OTB_DATA_ROOT}/Baseline/Examples/Tutorials) set(INPUTDATA ${OTB_DATA_ROOT}/Examples) otb_add_test(NAME trTeTutorialsHelloWorld COMMAND ${OTB_TEST_DRIVER} Execute $ ) otb_add_test(NAME trTeTutorialsPipelineTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/TutorialsPipelineOutput.png ${TEMP}/TutorialsPipelineOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/TutorialsPipelineOutput.png ) otb_add_test(NAME trTeTutorialsFilteringPipelineTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/TutorialsFilteringPipelineOutput.png ${TEMP}/TutorialsFilteringPipelineOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/TutorialsFilteringPipelineOutput.png ) otb_add_test(NAME trTeTutorialsScalingPipelineTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/TutorialsScalingPipelineOutput.png ${TEMP}/TutorialsScalingPipelineOutput.png Execute $ ${INPUTDATA}/QB_Suburb.png ${TEMP}/TutorialsScalingPipelineOutput.png ) otb_add_test(NAME trTeTutorialsMultispectralTest COMMAND ${OTB_TEST_DRIVER} --compare-n-images ${NOTOL} 2 ${BASELINE}/MultispectralOutput1.tif ${TEMP}/MultispectralOutput1.tif ${BASELINE}/MultispectralOutput2.tif ${TEMP}/MultispectralOutput2.tif Execute $ ${INPUTDATA}/qb_RoadExtract.tif ${TEMP}/MultispectralOutput1.tif ${TEMP}/MultispectralOutput2.tif ) otb_add_test(NAME trTeTutorialsSmarterFilteringPipelineTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/TutorialsSmarterFilteringPipelineOutput.png ${TEMP}/TutorialsSmarterFilteringPipelineOutput.png Execute $ -in ${INPUTDATA}/QB_Suburb.png -out ${TEMP}/TutorialsSmarterFilteringPipelineOutput.png -d 1.5 -i 2 -a 0.1 ) otb_add_test(NAME trTeTutorialsOrthoFusionTest COMMAND ${OTB_TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/TutorialsOrthoFusionOutput.tif ${TEMP}/TutorialsOrthoFusionOutput.tif Execute $ LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TEMP}/TutorialsOrthoFusionOutput.tif 31 N 375000 4828100 500 500 0.6 -0.6 ) OTB-release-5.8/LICENSE000066400000000000000000000511341301006202600144270ustar00rootroot00000000000000 CeCILL FREE SOFTWARE LICENSE AGREEMENT Notice This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting: * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users, * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software. The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[logiciel] L[ibre]) license are: Commissariat l'Energie Atomique - CEA, a public scientific, technical and industrial establishment, having its principal place of business at 31-33 rue de la Fdration, 75752 Paris cedex 15, France. Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange 75794 Paris cedex 16, France. Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France. Preamble The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model. The exercising of these rights is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions. In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability. In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the Software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom. This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions. Article 1 - DEFINITIONS For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning: Agreement: means this license agreement, and its possible subsequent versions and annexes. Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, "as is" when the Licensee accepts the Agreement. Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, "as is" when it is first distributed under the terms and conditions of the Agreement. Modified Software: means the Software modified by at least one Contribution. Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software. Object Code: means the binary files originating from the compilation of the Source Code. Holder: means the holder(s) of the economic rights over the Initial Software. Licensee: means the Software user(s) having accepted the Agreement. Contributor: means a Licensee having made at least one Contribution. Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement. Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules. Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software. External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run. Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space. GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc. Parties: mean both the Licensee and the Licensor. These expressions may be used both in singular and plural form. Article 2 - PURPOSE The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software. Article 3 - ACCEPTANCE 3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events: * (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium; * (ii) the first time the Licensee exercises any of the rights granted hereunder. 3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it. Article 4 - EFFECTIVE DATE AND TERM 4.1 EFFECTIVE DATE The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1. 4.2 TERM The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software. Article 5 - SCOPE OF RIGHTS GRANTED The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter. Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph. 5.1 RIGHT OF USE The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises: 1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form. 2. loading, displaying, running, or storing the Software on any or all medium. 3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder. 5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting Software. The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof. 5.3 RIGHT OF DISTRIBUTION In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means. The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter. 5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data. 5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the Modified Software become subject to all the provisions of this Agreement. The Licensee is authorized to distribute the Modified Software, in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Modified Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Modified Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data. 5.3.3 DISTRIBUTION OF EXTERNAL MODULES When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement. 5.3.4 COMPATIBILITY WITH THE GNU GPL The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL. The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, and distribute that entire code under the terms of the same version of the GNU GPL. Article 6 - INTELLECTUAL PROPERTY 6.1 OVER THE INITIAL SOFTWARE The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software. The Holder undertakes that the Initial Software will remain ruled at least by the current license, for the duration set forth in article 4.2. 6.2 OVER THE CONTRIBUTIONS A Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law. 6.3 OVER THE EXTERNAL MODULES A Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution. 6.4 JOINT PROVISIONS The Licensee expressly undertakes: 1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software; 2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not. The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis--vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors. Article 7 - RELATED SERVICES 7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software. However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor. 7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee. Article 8 - LIABILITY 8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof. 8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor. Article 9 - WARRANTY 9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users. The Licensee shall be responsible for verifying, by any or all means, the product's suitability for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties. 9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5). 9.3 The Licensee acknowledges that the Software is supplied "as is" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature. Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements. 9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark. Article 10 - TERMINATION 10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective. 10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof. Article 11 - MISCELLANEOUS 11.1 EXCUSABLE EVENTS Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc. 11.2 Any Failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently. 11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives. 11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid. 11.5 LANGUAGE The Agreement is drafted in both French and English and both versions are deemed authentic. Article 12 - NEW VERSIONS OF THE AGREEMENT 12.1 Any person is authorized to duplicate and distribute copies of this Agreement. 12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software. 12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4. Article 13 - GOVERNING LAW AND JURISDICTION 13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement. 13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party. Version 2.0 dated 2005-05-21. OTB-release-5.8/Modules/000077500000000000000000000000001301006202600150265ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/000077500000000000000000000000001301006202600165715ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/BoostAdapters/000077500000000000000000000000001301006202600213435ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/BoostAdapters/CMakeLists.txt000066400000000000000000000000541301006202600241020ustar00rootroot00000000000000project(OTBBoostAdapters) otb_module_impl() OTB-release-5.8/Modules/Adapters/BoostAdapters/include/000077500000000000000000000000001301006202600227665ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otbBoostDox.h000066400000000000000000000015221301006202600254050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoostDox_h #define otbBoostDox_h /**\defgroup boost Boost alike helpers * \ingroup Thematic * \brief Various helpers that are likelly to end-up in boost by themselves eventually. * \see http://www.boost.org/ * @{ */ namespace boost { } //@} #endif // otbBoostDox_h OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otbJoinContainer.h000066400000000000000000000035511301006202600264120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbJoinContainer_h #define otbJoinContainer_h // #include #include #include // #include #include #include #include namespace otb { /**\ingroup Common * Joins elements from a range into a stream. * \tparam TRange range type, see boost.Range * to see what qualifies as an \em Range. * \param os destination stream * \param[in] range Range to print * \param[in] separator Separator string to use between elements. * * \return the stream * \throw None At least, this function is exception neutral. */ template inline std::ostream & Join(std::ostream &os, TRange const& range, std::string const& separator) { if (!boost::empty(range)) { typename boost::range_iterator::type first = boost::begin(range); typename boost::range_iterator::type const last = boost::end(range); os << *first; for (++first; first!=last; ++first) { os << separator << *first; } } return os; } } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION // #include "otbJoinContainer.txx" #endif #endif // otbJoinContainer_h OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otbStringUtils.h000066400000000000000000000110331301006202600261310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStringUtils_h #define otbStringUtils_h #include #include #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #include #include #include #include #pragma GCC diagnostic pop #else #include #include #include #include #endif namespace otb { namespace Utils { template inline Res LexicalCast(In const& in, std::string const& kind) { try { return boost::lexical_cast(in); } catch (boost::bad_lexical_cast &) { std::ostringstream oss; oss << "Cannot decode '" << in << "' as this is not a valid value for '" << kind << "'"; throw std::runtime_error(oss.str()); } } /**\ingroup Utils * Converts a delimiter separated string into a collection of \c T's. * \tparam Collection type. It shall define \c value_type and \c push_back() * \param[out] ret output collection. * \param[in] str input string * \param[in] errmsg a msg complement used to build the error message to be shown if there is \c lexical_cast exception. See \c otb:Utils::LexicalCast(). * \param delims delimitter characters (space is default) * \throw std::bad_alloc in case of exhausted memory * \throw std::runtime_error in case an element from the input string cannot be converted into a valid \c T instance. * \pre delims shall not be null (untested) * * \see \c otb::Utils::LexicalCast() */ template void ConvertStringToVector(std::string const &str, T& ret, std::string const& errmsg, const char * delims=" ") { typedef std::vector > ListType; ListType split; boost::split(split, str, boost::is_any_of(delims)); for(size_t i = 0; i < split.size(); i++) { typename T::value_type value = LexicalCast (split[i], errmsg); ret.push_back(value); } } /**\ingroup Utils * split a given std::string of into key value based on given delimitter * string. default delimitter is '='. If the string does not have a delimitter * the key is set to input string and value is set to defValue. * \param[in] str input string * \param key[out] An std::string reference where key will be stored * \param value[out] a reference of \cT where value will be stored * \param defValue[in] a default value if there is no delimitter fo * \param[in] errmsg a msg complement used to build the error message to be shown if there is \c lexical_cast exception. See \cotb:Utils::LexicalCast(). * \param delims delimitter characters (space is default) * \throw std::bad_alloc in case of exhausted memory * \throw std::runtime_error in case an element from the input string cannot be converted into a valid \c T instance. * \pre delims shall not be null (untested) * * \see \c otb::Utils::LexicalCast() */ template void SplitStringToSingleKeyValue(const std::string& str, std::string& key, T& value, const T& defValue, std::string const& errmsg, const std::string delims="=") { typedef boost::iterator_range BoostRangeIteratorType; typedef std::list< BoostRangeIteratorType > ListType; ListType split; boost::split( split, str, boost::is_any_of(delims), boost::token_compress_on ); typename ListType::iterator it = split.begin(); BoostRangeIteratorType kIt = boost::trim_copy((*it)); key.assign( kIt.begin(), kIt.end()); ++it; if( it != split.end()) { value = LexicalCast(boost::trim_copy(*it), errmsg); ++it; } else { value = defValue; } } } // end namespace Utils } // end namespace otb #endif //otbStringUtils_h OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otb_boost_expint_header.h000066400000000000000000000016161301006202600300340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_boost_expint_header_h #define otb_boost_expint_header_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include #pragma GCC diagnostic pop #else #include #endif #endif OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otb_boost_graph_header.h000066400000000000000000000020421301006202600276200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_boost_graph_header_h #define otb_boost_graph_header_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wcast-align" #pragma GCC diagnostic ignored "-Wunused-parameter" #include #include #pragma GCC diagnostic pop #else #include #include #endif #endif OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otb_boost_math_gamma_header.h000066400000000000000000000016241301006202600306170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_boost_math_gamma_header_h #define otb_boost_math_gamma_header_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include #pragma GCC diagnostic pop #else #include #endif #endif OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otb_boost_math_normal_header.h000066400000000000000000000017701301006202600310270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_boost_math_normal_header_h #define otb_boost_math_normal_header_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wmissing-field-initializers" #include #pragma GCC diagnostic pop #else #include #endif #endif OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otb_boost_string_header.h000066400000000000000000000017121301006202600300300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_boost_string_header_h #define otb_boost_string_header_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include #include #pragma GCC diagnostic pop #else #include #include #endif #endif OTB-release-5.8/Modules/Adapters/BoostAdapters/include/otb_boost_tokenizer_header.h000066400000000000000000000016461301006202600305420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_boost_tokenizer_header_h #define otb_boost_tokenizer_header_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include #include #pragma GCC diagnostic pop #else #include #include #endif #endif OTB-release-5.8/Modules/Adapters/BoostAdapters/otb-module.cmake000066400000000000000000000002311301006202600244100ustar00rootroot00000000000000set(DOCUMENTATION "Adapters for the Boost library.") otb_module(OTBBoostAdapters DEPENDS OTBBoost DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Adapters/CurlAdapters/000077500000000000000000000000001301006202600211625ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/CurlAdapters/CMakeLists.txt000066400000000000000000000001331301006202600237170ustar00rootroot00000000000000project(OTBCurlAdapters) set(OTBCurlAdapters_LIBRARIES OTBCurlAdapters) otb_module_impl() OTB-release-5.8/Modules/Adapters/CurlAdapters/include/000077500000000000000000000000001301006202600226055ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/CurlAdapters/include/otbCurlHelper.h000066400000000000000000000055631301006202600255410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCurlHelper_h #define otbCurlHelper_h #include "otbCurlHelperInterface.h" namespace otb { /** * \class CurlHelper * \brief Class to use the curl capabilities from OTB * * This class is responsible for behaving properly when curl is * not available, i.e. the compilation should pass, the runtime should * not segfault but of course, the behavior will be different. * * * \ingroup OTBCurlAdapters */ class OTBCurlAdapters_EXPORT CurlHelper : public CurlHelperInterface { public: /** Standard class typedefs. */ typedef CurlHelper Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef CurlHelperInterface Superclass; itkTypeMacro(CurlHelper, CurlHelperInterface); itkNewMacro(Self); bool TestUrlAvailability(const std::string& url) const ITK_OVERRIDE; bool IsCurlReturnHttpError(const std::string& url) const; int RetrieveFile(const std::ostringstream& urlStream, std::string filename) const ITK_OVERRIDE; int RetrieveFile(const std::string& urlString, std::string filename) const ITK_OVERRIDE; int RetrieveUrlInMemory(const std::string& urlString, std::string& output) const ITK_OVERRIDE; int RetrieveFileMulti(const std::vector& listURLs, const std::vector& listFiles, int maxConnect) const ITK_OVERRIDE; itkGetMacro(Timeout,long int); itkSetMacro(Timeout,long int); protected: CurlHelper() : m_Browser("Mozilla/5.0 (Windows; U; Windows NT 6.0; en-GB; rv:1.8.1.11) " "Gecko/20071127 Firefox/2.0.0.11"), m_Timeout(10) {} ~CurlHelper() ITK_OVERRIDE {} private: CurlHelper(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Need to use our writing function to handle windows segfaults // Need to be static cause the CURL_OPT is expecting a pure C // function or a static c++ method. static size_t CallbackWriteDataToFile(void* ptr, size_t size, size_t nmemb, void* data); static size_t CallbackWriteDataToStringStream(void* ptr, size_t size, size_t nmemb, void* data); static size_t CallbackWriteDataDummy(void* ptr, size_t size, size_t nmemb, void* data); // Browser Agent used std::string m_Browser; long int m_Timeout; }; } #endif OTB-release-5.8/Modules/Adapters/CurlAdapters/include/otbCurlHelperInterface.h000066400000000000000000000043161301006202600273550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCurlHelperInterface_h #define otbCurlHelperInterface_h #include #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBCurlAdaptersExport.h" namespace otb { /** * \class CurlHelperInterface * \brief Class to use the curl capabilities from OTB * * This class implement the interface of the curl access allowing for * different implementation to be used (include stubs for test). * * * \ingroup OTBCurlAdapters */ class OTBCurlAdapters_EXPORT CurlHelperInterface : public itk::Object { public: /** Standard class typedefs. */ typedef CurlHelperInterface Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Object Superclass; itkTypeMacro(CurlHelperInterface, itk::Object); virtual bool TestUrlAvailability(const std::string& url) const = 0; virtual int RetrieveFile(const std::ostringstream& urlStream, std::string filename) const = 0; virtual int RetrieveFile(const std::string& urlString, std::string filename) const = 0; virtual int RetrieveUrlInMemory(const std::string& urlString, std::string& output) const = 0; virtual int RetrieveFileMulti(const std::vector& listURLs, const std::vector& listFiles, int maxConnect) const = 0; static bool IsCurlAvailable(); static bool IsCurlMultiAvailable(); protected: CurlHelperInterface() {} ~CurlHelperInterface() ITK_OVERRIDE {} private: CurlHelperInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } #endif OTB-release-5.8/Modules/Adapters/CurlAdapters/include/otbCurlHelperStub.h000066400000000000000000000037601301006202600263740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCurlHelperStub_h #define otbCurlHelperStub_h #include "otbCurlHelperInterface.h" namespace otb { /** * \class CurlHelperStub * \brief Class to test classes using the curl capabilities from OTB * * This class is available only for testing purposes * * * \ingroup OTBCurlAdapters */ class ITK_ABI_EXPORT CurlHelperStub : public CurlHelperInterface { public: /** Standard class typedefs. */ typedef CurlHelperStub Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef CurlHelperInterface Superclass; itkTypeMacro(CurlHelperStub, CurlHelperInterface); itkNewMacro(Self); bool TestUrlAvailability(const std::string& url) const ITK_OVERRIDE; int RetrieveUrlInMemory(const std::string& urlString, std::string& output) const ITK_OVERRIDE; int RetrieveFile(const std::ostringstream& urlStream, std::string filename) const ITK_OVERRIDE; int RetrieveFile(const std::string& urlString, std::string filename) const ITK_OVERRIDE; int RetrieveFileMulti(const std::vector& listURLs, const std::vector& listFiles, int maxConnect) const ITK_OVERRIDE; protected: CurlHelperStub() {} ~CurlHelperStub() ITK_OVERRIDE {} private: CurlHelperStub(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } #endif OTB-release-5.8/Modules/Adapters/CurlAdapters/otb-module.cmake000066400000000000000000000003721301006202600242350ustar00rootroot00000000000000set(DOCUMENTATION "Adapters for the Curl library.") otb_module(OTBCurlAdapters ENABLE_SHARED DEPENDS OTBCommon OTBITK OPTIONAL_DEPENDS OTBCurl TEST_DEPENDS OTBTestKernel OTBTinyXML DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Adapters/CurlAdapters/src/000077500000000000000000000000001301006202600217515ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/CurlAdapters/src/CMakeLists.txt000066400000000000000000000005351301006202600245140ustar00rootroot00000000000000set(OTBCurlAdapters_SRC otbCurlHelperStub.cxx otbCurlHelper.cxx otbCurlHelperInterface.cxx ) add_library(OTBCurlAdapters ${OTBCurlAdapters_SRC}) target_link_libraries(OTBCurlAdapters ${OTBCommon_LIBRARIES} ) if (OTBCurl_ENABLED) target_link_libraries(OTBCurlAdapters ${OTBCurl_LIBRARIES}) endif() otb_module_target(OTBCurlAdapters) OTB-release-5.8/Modules/Adapters/CurlAdapters/src/otbCurlHelper.cxx000066400000000000000000000403041301006202600252500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include #include "otbConfigure.h" // for OTB_USE_CURL #include "otbMacro.h" #include "otbCurlHelper.h" #ifdef OTB_USE_CURL # include "otb_curl.h" #endif namespace otb { #ifdef OTB_USE_CURL /** * Class to handle the CURLcode and CURLMCode and throw exceptions when needed */ class CurlHandleError { public: /** Processing CURLcode */ static void ProcessCURLcode(CURLcode curlCode) { if(curlCode != CURLE_OK) { itkGenericExceptionMacro(<<" Curl Error : "<< curl_easy_strerror(curlCode)); } } /** Processing CURLMcode */ static void ProcessCURLcode(CURLMcode curlMCode) { if(curlMCode != CURLM_OK) { itkGenericExceptionMacro(<<" CurlM Error : "<< curl_multi_strerror(curlMCode)); } } }; /** * Resource class that create and clean the curl environment proprely * in case of a thrown exception */ class CurlResource : public itk::LightObject { public: /** Standard class typedefs. */ typedef CurlResource Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::LightObject Superclass; itkTypeMacro(CurlResource, itk::LightObject); itkNewMacro(Self); /** Get the curl object */ CURL * GetCurlResource() { return m_Curl; } protected: CurlResource() { m_Curl = curl_easy_init(); if (!m_Curl) { itkExceptionMacro(<<" otbCurlHelper::CurlResource Curl handle init error."); } } ~CurlResource() ITK_OVERRIDE { curl_easy_cleanup(m_Curl); } private: CURL * m_Curl; // prevent copying and assignment; not implemented CurlResource (const CurlResource &); CurlResource & operator= (const CurlResource &); }; //end of class CurlResource #ifdef OTB_CURL_MULTI_AVAILABLE /** * Resource class that create and clean the curl multi environment * proprely in case of a thrown exception */ class CurlMultiResource : public itk::LightObject { public: /** Standard class typedefs. */ typedef CurlMultiResource Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::LightObject Superclass; itkTypeMacro(CurlMultiResource, itk::LightObject); itkNewMacro(Self); CURLM * GetCurlMultiResource() { return m_Curl; } protected: CurlMultiResource() { m_Curl = curl_multi_init(); if (!m_Curl) { itkExceptionMacro(<<" otbCurlHelper::CurlMultiResource Curl multi handle init error."); } } ~CurlMultiResource() ITK_OVERRIDE { curl_multi_cleanup(m_Curl); } private: CURLM * m_Curl; // prevent copying and assignment; not implemented CurlMultiResource (const CurlMultiResource &); CurlMultiResource & operator= (const CurlMultiResource &); }; //end of class CurlMultiResource #endif // OTB_CURL_MULTI_AVAILABLE /** * Resource class that create FILE * and close the FILE * descriptor * proprely in case of a thrown exception */ class CurlFileDescriptorResource : public itk::LightObject { public: /** Standard class typedefs. */ typedef CurlFileDescriptorResource Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::LightObject Superclass; itkTypeMacro(CurlFileDescriptorResource, itk::LightObject); itkNewMacro(Self); FILE * GetFileResource() { return m_File; } void OpenFile(const char* infname) { m_File = fopen(infname, "wb"); if (m_File == ITK_NULLPTR) { itkExceptionMacro(<<" otbCurlHelper::FileResource : failed to open the file ."<< infname); } } protected: CurlFileDescriptorResource(){} ~CurlFileDescriptorResource() ITK_OVERRIDE { fclose(m_File); } private: FILE * m_File; // prevent copying and assignment; not implemented CurlFileDescriptorResource (const CurlFileDescriptorResource &); CurlFileDescriptorResource & operator= (const CurlFileDescriptorResource &); }; //end of class FileResource #endif // OTB_USE_CURL bool CurlHelper::TestUrlAvailability(const std::string& url) const { (void)url; #ifdef OTB_USE_CURL // Set up a curl resource CurlResource::Pointer curlResource = CurlResource::New(); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_USERAGENT, m_Browser.data())); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_URL, url.data())); // Set the dummy write function CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_WRITEFUNCTION, &Self::CallbackWriteDataDummy)); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_MAXFILESIZE, 1)); // Perform requet CURLcode easyPerformResult = curl_easy_perform(curlResource->GetCurlResource()); otbMsgDevMacro(<< "CurlHelper::TestUrlAvailability : curl_easy_perform returned " << easyPerformResult << " --> " << curl_easy_strerror(easyPerformResult)); // Check the curl_easy_perform return code : actually we tests only // the availability of the url, so if the file requested size is less // than 1 byte, and the url is valid it returns CURLE_OK, or if the // url is valid and the file size is greater than 1 byte it returns // the error CURLE_FILESIZE_EXCEEDED if ( easyPerformResult == CURLE_OK || easyPerformResult == CURLE_FILESIZE_EXCEEDED ) { return true; } return false; #else otbMsgDevMacro(<< "Curl is not available, compile with OTB_USE_CURL to ON"); return false; #endif } bool CurlHelper::IsCurlReturnHttpError(const std::string& url) const { #ifdef OTB_USE_CURL // Set up a curl resource CurlResource::Pointer curlResource = CurlResource::New(); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_USERAGENT, m_Browser.data())); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_URL, url.data())); // Set the dummy write function CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_WRITEFUNCTION, &Self::CallbackWriteDataDummy)); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_MAXFILESIZE, 1)); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_FAILONERROR, 1)); // Perform requet CURLcode easyPerformResult = curl_easy_perform(curlResource->GetCurlResource()); if ( easyPerformResult == CURLE_HTTP_RETURNED_ERROR ) { return true; } return false; #else (void)url; otbMsgDevMacro(<< "Curl is not available, compile with OTB_USE_CURL to ON"); return false; #endif } int CurlHelper::RetrieveUrlInMemory(const std::string& url, std::string& output) const { #ifdef OTB_USE_CURL otbMsgDevMacro(<< "Retrieving: " << url); CURLcode res = CURLE_OK; CurlResource::Pointer curlResource = CurlResource::New(); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_URL, url.c_str())); // Settimeout CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_TIMEOUT, m_Timeout)); // Use our writing static function to avoid file descriptor // pointer crash on windows CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_WRITEFUNCTION, &Self::CallbackWriteDataToStringStream)); // Say the file where to write the received data std::ostringstream* outputStream = new std::ostringstream; CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_WRITEDATA, (void*) outputStream)); // Perform request CurlHandleError::ProcessCURLcode(curl_easy_perform(curlResource->GetCurlResource())); // Save output output = outputStream->str(); otbMsgDevMacro("curl output : " << output); // Clean up delete outputStream; otbMsgDevMacro(<< " -> " << res); return res; #else (void)url; (void)output; otbMsgDevMacro(<< "Curl is not available, compile with OTB_USE_CURL to ON"); return -1; #endif } int CurlHelper::RetrieveFile(const std::ostringstream& urlStream, std::string filename) const { return RetrieveFile(urlStream.str(), filename); } int CurlHelper::RetrieveFile(const std::string& urlString, std::string filename) const { #ifdef OTB_USE_CURL CURLcode res = CURLE_OK; CurlResource::Pointer curlResource = CurlResource::New(); CurlFileDescriptorResource::Pointer output_file = CurlFileDescriptorResource::New(); output_file->OpenFile(filename.c_str()); char url[256]; int len = static_cast(urlString.size()); strncpy( url, urlString.c_str(), len + 1 ); otbMsgDevMacro(<< "Retrieving ( CurlHelper::RetrieveFile ): " << url ); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_URL, url)); // Set timeout CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_TIMEOUT, m_Timeout)); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_FRESH_CONNECT, 1)); CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_NOSIGNAL, 1)); // Use our writing static function to avoid file descriptor // pointer crash on windows CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_WRITEFUNCTION, &Self::CallbackWriteDataToFile)); // Say the file where to write the received data CurlHandleError::ProcessCURLcode(curl_easy_setopt(curlResource->GetCurlResource(), CURLOPT_WRITEDATA, (void*) output_file->GetFileResource())); CurlHandleError::ProcessCURLcode(curl_easy_perform(curlResource->GetCurlResource())); otbMsgDevMacro(<< " -> " << res); return res; #else (void)urlString; (void)filename; otbMsgDevMacro(<< "Curl is not available, compile with OTB_USE_CURL to ON"); return -1; #endif } int CurlHelper::RetrieveFileMulti(const std::vector& listURLs, const std::vector& listFilename, int maxConnect) const { #ifdef OTB_USE_CURL #if 0 //#ifdef OTB_CURL_MULTI_AVAILABLE otbMsgDevMacro(<< "Using curl multi"); // Initialize curl handle resource CurlMultiResource::Pointer multiHandle = CurlMultiResource::New(); std::vector listCurlHandles; std::vector listFiles; std::vector::const_iterator filename; filename = listFilename.begin(); while (filename != listFilename.end()) { CurlFileDescriptorResource::Pointer lOutputFile = CurlFileDescriptorResource::New(); lOutputFile->OpenFile((*filename).c_str()); // Add file to vector listFiles.push_back(lOutputFile); ++filename; } listCurlHandles.clear(); std::vector::const_iterator url; std::vector::const_iterator file; url = listURLs.begin(); file = listFiles.begin(); while ((url != listURLs.end()) && (file != listFiles.end())) { otbMsgDevMacro(<< "Retrieving: " << (*url).data()); CurlResource::Pointer lEasyHandle = CurlResource::New(); // Param easy handle CurlHandleError::ProcessCURLcode(curl_easy_setopt(lEasyHandle->GetCurlResource(), CURLOPT_USERAGENT, m_Browser.data())); CurlHandleError::ProcessCURLcode(curl_easy_setopt(lEasyHandle->GetCurlResource(), CURLOPT_URL, (*url).data())); CurlHandleError::ProcessCURLcode(curl_easy_setopt(lEasyHandle->GetCurlResource(), CURLOPT_WRITEFUNCTION, &Self::CallbackWriteDataToFile)); CurlHandleError::ProcessCURLcode(curl_easy_setopt(lEasyHandle->GetCurlResource(), CURLOPT_WRITEDATA, (void*) (*file)->GetFileResource())); // Add easy handle to multi handle CurlHandleError::ProcessCURLcode(curl_multi_add_handle(multiHandle->GetCurlMultiResource(), lEasyHandle->GetCurlResource())); // Add handle to vector listCurlHandles.push_back(lEasyHandle); ++url; ++file; } //fetch tiles // Configure multi handle - set the maximum connections CurlHandleError::ProcessCURLcode(curl_multi_setopt(multiHandle->GetCurlMultiResource(), CURLMOPT_MAXCONNECTS, maxConnect)); CurlHandleError::ProcessCURLcode(curl_multi_setopt(multiHandle->GetCurlMultiResource(), CURLMOPT_PIPELINING, 0)); // Perform int lStillRunning; while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(multiHandle->GetCurlMultiResource(), &lStillRunning)); // Now get that URL while (lStillRunning) { struct timeval timeout; int rc; // Return code fd_set fdread; fd_set fdwrite; fd_set fdexcep; int maxfd; FD_ZERO(&fdread); FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); /* set a suitable timeout to play around with */ timeout.tv_sec = 0; timeout.tv_usec = 1; /* get file descriptors from the transfers */ CurlHandleError::ProcessCURLcode(curl_multi_fdset(multiHandle->GetCurlMultiResource(), &fdread, &fdwrite, &fdexcep, &maxfd)); rc = select(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout); switch (rc) { case -1: /* select error */ break; case 0: /* timeout */ default: /* timeout or readable/writable sockets */ while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(multiHandle->GetCurlMultiResource(), &lStillRunning)); break; } } int remaining_msgs = 1; int error = 0; CURLMsg *msg; while (remaining_msgs) { msg = curl_multi_info_read(multiHandle->GetCurlMultiResource(), &remaining_msgs); if (msg != NULL) { if (CURLE_OK != msg->data.result) error = 1; } } if (error != 0) { itkExceptionMacro(<< "otbCurlHelper: Error occurs while perform Multi handle"); } // Cleanup listFiles.clear(); listCurlHandles.clear(); return 0; #else (void)maxConnect; //fallback on non curl multi otbMsgDevMacro(<< "Curl multi is not available, fallback on standard"); std::vector::const_iterator url; std::vector::const_iterator file; url = listURLs.begin(); file = listFilename.begin(); int res = 0; int resTmp = -1; while ((url != listURLs.end()) && (file != listFilename.end())) { resTmp = RetrieveFile(*url, *file); if (res == 0) res = resTmp; ++url; ++file; } return res; #endif #else (void)maxConnect; (void)listURLs; (void)listFilename; otbMsgDevMacro(<< "Curl is not available, compile with OTB_USE_CURL to ON"); return -1; #endif } size_t CurlHelper::CallbackWriteDataToFile(void* ptr, size_t size, size_t nmemb, void* data) { size_t written; FILE * fDescriptor = (FILE *) (data); written = fwrite(ptr, size, nmemb, fDescriptor); return written; } /* size_t CurlHelper::CallbackWriteDataToCharVector(void *ptr, size_t size, size_t nmemb, void *data) { register int realsize = (int)(size * nmemb); std::vector *vec = static_cast*>(data); const char* chPtr = static_cast(ptr); vec->insert(vec->end(), chPtr, chPtr + realsize); return realsize; } */ size_t CurlHelper::CallbackWriteDataToStringStream(void *ptr, size_t size, size_t nmemb, void *data) { std::ostringstream& stream = *reinterpret_cast(data); stream << reinterpret_cast(ptr); return size * nmemb; } size_t CurlHelper::CallbackWriteDataDummy(void *itkNotUsed(ptr), size_t size, size_t nmemb, void *itkNotUsed(data)) { return size * nmemb; } } OTB-release-5.8/Modules/Adapters/CurlAdapters/src/otbCurlHelperInterface.cxx000066400000000000000000000021251301006202600270700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbConfigure.h" // for OTB_USE_CURL #include "otbCurlHelperInterface.h" #ifdef OTB_USE_CURL #include "otb_curl.h" #endif namespace otb { bool CurlHelperInterface::IsCurlAvailable() { #ifdef OTB_USE_CURL const bool curlAvailable = true; #else const bool curlAvailable = false; #endif return curlAvailable; } bool CurlHelperInterface::IsCurlMultiAvailable() { #ifdef OTB_CURL_MULTI_AVAILABLE const bool curlMultiAvailable = true; #else const bool curlMultiAvailable = false; #endif return curlMultiAvailable; } } OTB-release-5.8/Modules/Adapters/CurlAdapters/src/otbCurlHelperStub.cxx000066400000000000000000000060651301006202600261140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbCurlHelperStub.h" #include #include namespace otb { bool CurlHelperStub::TestUrlAvailability(const std::string& itkNotUsed(url)) const { itkExceptionMacro(<< "otbCurlHelperStub: method undefined"); return -1; } int CurlHelperStub::RetrieveUrlInMemory(const std::string& url, std::string& output) const { if (url.compare("http://api.geonames.org/findNearbyPlaceName?lat=1.29&lng=103.78&username=otbteam") == 0) { output = "\n" "\n" "\n" "Kent Ridge\n" "Kent Ridge\n" "1.29306\n" "103.78444\n" "1880515\n" "SG\n" "Singapore\n" "P\n" "PPLX\n" "0.59959\n" "\n" "\n"; return 0; } itkExceptionMacro(<< "otbCurlHelperStub: value not recognized by stub"); return -1; } int CurlHelperStub::RetrieveFile(const std::ostringstream& urlStream, std::string filename) const { if (urlStream.str().compare("http://api.geonames.org/findNearbyPlaceName?lat=1.29&lng=103.78&username=otbteam") == 0) { std::ofstream file; file.open(filename.c_str()); file << "\n" "\n" "\n" "Kent Ridge\n" "Kent Ridge\n" "1.29306\n" "103.78444\n" "1880515\n" "SG\n" "Singapore\n" "P\n" "PPLX\n" "0.59959\n" "\n" "\n"; file.close(); return 0; } itkExceptionMacro(<< "otbCurlHelperStub: value not recognized by stub"); return -1; } int CurlHelperStub::RetrieveFile(const std::string& itkNotUsed(urlString), std::string itkNotUsed(filename)) const { itkExceptionMacro(<< "otbCurlHelperStub: method undefined"); return -1; } int CurlHelperStub::RetrieveFileMulti(const std::vector& itkNotUsed(listURLs), const std::vector& itkNotUsed(listFiles), int itkNotUsed(maxConnect)) const { itkExceptionMacro(<< "otbCurlHelperStub: method undefined"); return -1; } } OTB-release-5.8/Modules/Adapters/CurlAdapters/test/000077500000000000000000000000001301006202600221415ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/CurlAdapters/test/CMakeLists.txt000066400000000000000000000010161301006202600246770ustar00rootroot00000000000000otb_module_test() set(OTBCurlAdaptersTests otbCurlAdaptersTestDriver.cxx otbIsNightlyRevision.cxx ) add_executable(otbCurlAdaptersTestDriver ${OTBCurlAdaptersTests}) target_link_libraries(otbCurlAdaptersTestDriver ${OTBCurlAdapters-Test_LIBRARIES}) otb_module_target_label(otbCurlAdaptersTestDriver) # Is*Revision tests are removed. see JIRA OTB-1052 #the building of testdriver otbCurlAdaptersTestDriver is kept just #for the sake of linking libcurl with OTB to ensure curl (superbuild/system) #is fine for usage with OTB OTB-release-5.8/Modules/Adapters/CurlAdapters/test/otbCurlAdaptersTestDriver.cxx000066400000000000000000000001311301006202600277720ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbIsNightlyRevision); } OTB-release-5.8/Modules/Adapters/CurlAdapters/test/otbIsNightlyRevision.cxx000066400000000000000000000033501301006202600270240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otb_tinyxml.h" #include "otbCurlHelper.h" int otbIsNightlyRevision(int argc, char * argv[]) { if (argc != 3) { std::cerr << argv[0] << " revision_number http_address_of_nightlynumber" << std::endl; return EXIT_FAILURE; } std::string wcRevision = argv[1]; std::string nightlyRevisionUrl = argv[2]; otb::CurlHelper::Pointer curl = otb::CurlHelper::New(); std::string curlOutput; curl->RetrieveUrlInMemory(nightlyRevisionUrl, curlOutput); std::string nightlyRevision; TiXmlDocument doc; doc.Parse(curlOutput.c_str()); TiXmlHandle docHandle(&doc); TiXmlElement* commitChild = docHandle.FirstChild("html").FirstChild("body").Child("div",3).FirstChild("table").Child("tr",4).Child("td",1).Element(); if (commitChild) { if (strcmp(commitChild->Attribute("class"),"sha1") == 0) { nightlyRevision = std::string(commitChild->GetText()); } } if (nightlyRevision == wcRevision) { return EXIT_SUCCESS; } else { std::cerr << "Nightly revision is " << nightlyRevision << " but working copy revision is " << wcRevision << std::endl; return EXIT_FAILURE; } } OTB-release-5.8/Modules/Adapters/GdalAdapters/000077500000000000000000000000001301006202600211245ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/GdalAdapters/CMakeLists.txt000066400000000000000000000001331301006202600236610ustar00rootroot00000000000000project(OTBGdalAdapters) set(OTBGdalAdapters_LIBRARIES OTBGdalAdapters) otb_module_impl() OTB-release-5.8/Modules/Adapters/GdalAdapters/include/000077500000000000000000000000001301006202600225475ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbGdalDataTypeBridge.h000066400000000000000000000036621301006202600270540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGdalDataTypeBridge_h #define otbGdalDataTypeBridge_h #include #include "gdal.h" namespace otb { namespace GdalDataTypeBridge { template GDALDataType GetGDALDataType() { if (typeid(Type) == typeid(char)) { return GDT_Byte; } else if (typeid(Type) == typeid(unsigned char)) { return GDT_Byte; } else if (typeid(Type) == typeid(unsigned short)) { return GDT_UInt16; } else if (typeid(Type) == typeid(short)) { return GDT_Int16; } else if (typeid(Type) == typeid(int)) { return GDT_Int32; } else if (typeid(Type) == typeid(unsigned int)) { return GDT_UInt32; } else if (typeid(Type) == typeid(long)) { if( sizeof(long) == 8 ) { //itkWarningMacro(<< "Cast a long (64 bits) image into an int (32 bits) one.") } return GDT_Int32; } else if (typeid(Type) == typeid(unsigned long)) { if( sizeof(unsigned long) == 8 ) { //itkWarningMacro(<< "Cast an unsigned long (64 bits) image into an unsigned int (32 bits) one.") } return GDT_UInt32; } else if (typeid(Type) == typeid(float)) { return GDT_Float32; } else if (typeid(Type) == typeid(double)) { return GDT_Float64; } else { return GDT_Byte; } } } // End namespace GdalDataTypeBridge } // End namespace otb #endif OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbGeometriesSet.h000066400000000000000000000125001301006202600262020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeometriesSet_h #define otbGeometriesSet_h #include // #include "otbOGRLayerWrapper.h" #include "otbOGRDataSourceWrapper.h" #include "otbImageReference.h" namespace otb { /**\ingroup gGeometry * \class GeometriesSet * \brief Common ITK type to manipulate any set of geometries: a \c otb::ogr::DataSource, or a \c otb::ogr::Layer. * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ class OTBGdalAdapters_EXPORT GeometriesSet : public itk::DataObject { public: /**\name Standard ITK typedefs */ //@{ typedef GeometriesSet Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //@} /**\name Standard macros */ //@{ /** Run-time type information (and related methods). */ itkTypeMacro(GeometriesSet, itk::DataObject); //@} /**\name Factory functions */ //@{ /** ITK method for creation through the object factory. */ itkNewMacro(Self); /// Direct builder from an existing \c otb::DataSource. static Pointer New(ogr::DataSource::Pointer datasource); /// Direct builder from an existing \c otb::Layer. static Pointer New(ogr::Layer layer); //@} /**\name Geometries accessors */ //@{ void Set(ogr::DataSource::Pointer datasource); void Set(ogr::Layer layer); //@} /**\name Application of a command to a geometries set, through a visitor */ //@{ template typename Visitor::result_type /** * Unary visiting function to apply a visitor on any kind of geometies set. * * As a \c GeometriesSet contains either a \c otb::ogr::DataSource, or a \c * otb::ogr::Layer, one needs to apply a function on either kind of data. * This can be done thanks to a specialization of \c boost::static_visitor<> * that has a const \c operator() that takes either one (or two in case of * binary visitors) \c otb::DataSource or \c otb::Layer as parameter(s). * * \throw Whatever is thrown by the actual visitor. * \tparam Visitor type of the visitor functor. * \param[in] visitor Functor visitor that shal derive from \c * boost::static_visitor. */ apply(Visitor const& visitor) { return boost::apply_visitor(visitor, m_GeometriesSet); } /** * \copydoc apply(Visitor const& visitor) */ template typename Visitor::result_type apply(Visitor const& visitor) const { return boost::apply_visitor(visitor, m_GeometriesSet); } /** * Binary visiting function to apply a visitor on any kind of geometies set. * \copydetails apply(Visitor const& visitor) * \param[in] visitable other geometries set to visit along side with the * current geometries set instance. */ template typename Visitor::result_type apply(Visitor const& visitor, Self & visitable) { return boost::apply_visitor(visitor, m_GeometriesSet, visitable.m_GeometriesSet); } /** * \copydoc apply(Visitor const& visitor, Self& visitable) */ template typename Visitor::result_type apply(Visitor const& visitor, Self /*const*/& visitable) const { return boost::apply_visitor(visitor, m_GeometriesSet, visitable.m_GeometriesSet); } //@} /** Does it contain a geometries set ?. */ bool IsSet() const; /**\name Image reference (spacing + origin) */ //@{ typedef ogr::ImageReference ImageReference; /** \em ImageReference setter. */ void SetImageReference(ImageReference const& imageReference) { m_ImageReference = imageReference; } /** \em ImageReference getter. */ ImageReference const& GetImageReference() const { return m_ImageReference; } //@} protected: /** Default constructor. * This actual geometries set is an in-memory \c otb::ogr::DataSource. * It needs to be set to a set of geometries if you expect to serialize it or * work on a \c otb::Layer. * * When using this construction path, you'll likelly need to \c Set() the * actual geometries set. */ GeometriesSet(); /** Init constructor from a \c otb::DataSource. */ GeometriesSet(ogr::DataSource::Pointer datasource); /** Init constructor from a \c otb::Layer. */ GeometriesSet(ogr::Layer layer); /** Destructor. */ ~GeometriesSet() ITK_OVERRIDE; /** Prints self to stream. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: typedef boost::variant AnyGeometriesSetType; AnyGeometriesSetType m_GeometriesSet; ImageReference m_ImageReference; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION // #include "otbGeometriesSet.txx" #endif #endif // otbGeometriesSet_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbGeometriesSource.h000066400000000000000000000105731301006202600267170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeometriesSource_h #define otbGeometriesSource_h #include #include "itkProcessObject.h" #include "itkMacro.h" #include "OTBGdalAdaptersExport.h" // Forward declarations namespace otb { namespace ogr { class DataSource; class Layer; } // ogr namespace class GeometriesSet; } // otb namespace /**\defgroup GeometriesFilters Filters of geometries sets * \ingroup gGeometry Filters * Filters of geometries sets. */ namespace otb { /**\ingroup GeometriesFilters * \class GeometriesSource * Source of geometries & Root of the geometries filters hierarchy. * This class provides a kind of \em reader for geometries sets. * * Unlike others filters, the \em output has to be built from outside and given * to the \c GeometriesSource. If no \em output has been defined at the moment * the filter begins processing, by default the \c ogr::DataSource will have * have an \em in-memory storage. * * \internal * This particular behaviour is the consequence that, to exist, a \c * ogr::DataSource needs to know how it is stored. We could have permitted to * work on an \em in-memory \c ogr::DataSource, and then store the result into * another \em on-disk \c ogr::DataSource. This wouldn't have been efficient at * all. Hence the design adopted. * * \note As OGR data sources don't support multiple re-rentrant access, a \c * ogr::DataSource can't be grafted, and as a consequence, \c GeometriesSource * subtypes can't be grafted as well. * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ class OTBGdalAdapters_EXPORT GeometriesSource : public itk::ProcessObject, boost::noncopyable { public: /**\name Standard ITK typedefs */ //@{ typedef GeometriesSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; //@} /**\name I/O typedefs */ //@{ typedef GeometriesSet OutputGeometriesType; // typedef GeometriesSet::Pointer OutputGeometriesPointer; //@} /**\name Standard macros */ //@{ /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GeometriesSource, itk::ProcessObject); //@} /**\name GeometriesSet Output property. */ //@{ /** Overriding \c GetOutput() functions */ virtual OutputGeometriesType* GetOutput(void); /** Overriding \c GetOutput() functions */ virtual OutputGeometriesType* GetOutput(DataObjectPointerArraySizeType idx); /** * Output mutator. * \param[in,out] output \c GeometriesSource where output result will be * written. * \param[in] idx index of the output assigned to the \c GeometriesSource. * * \throw std::bad_alloc if no new output can be added. */ virtual void SetOutput(OutputGeometriesType* output, DataObjectPointerArraySizeType idx = 0); using Superclass::SetOutput; //@} /** \c ProcessObject hook Specialized for \c GeometriesSource. * This function makes sure the output(s) is (/are) allocated before * initializing them. * \post GetOutput() != NULL */ void PrepareOutputs() ITK_OVERRIDE; protected: /** Default constructor. * \post Required number of outputs == 1 */ GeometriesSource(); /** Destructor. * Does nothing. */ ~GeometriesSource() ITK_OVERRIDE; /** Ensures that the output geometries are allocated before processing. * If the output hasn't been set, at this point, the default output geometries * set will be an in-memory \c ogr::DataSource. * \post GetOutput() != NULL */ virtual void DoAllocateOutputs(); }; } // end namespace otb #endif // otbGeometriesSource_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbGeometriesToGeometriesFilter.h000066400000000000000000000355501301006202600312350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeometriesToGeometriesFilter_h #define otbGeometriesToGeometriesFilter_h /**\ingroup GeometriesFilters * \file otbGeometriesToGeometriesFilter.h * \since OTB v 3.14.0 * Commons definitions for geometries filter definition. * This file contains all the main classes required to define new geometries * transformations. */ #include "otbGeometriesSource.h" #include #include #include #include "otbOGRLayerWrapper.h" #include "otbMacro.h" // forward declarations namespace otb { namespace internal { struct ProcessVisitor; } } // otb::internal namespace namespace otb { /**\ingroup GeometriesFilters * \class GeometriesToGeometriesFilter * Root abstract class for all geometries to geometries filters. * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ class OTBGdalAdapters_EXPORT GeometriesToGeometriesFilter : public GeometriesSource { public: /**\name Standard ITK typedefs */ //@{ typedef GeometriesToGeometriesFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //@} /**\name I/O typedefs */ //@{ typedef GeometriesSet InputGeometriesType; typedef GeometriesSet OutputGeometriesType; // typedef GeometriesSet::Pointer InputGeometriesPointer; // typedef GeometriesSet::Pointer OutputGeometriesPointer; //@} /**\name Standard ITK macros */ //@{ /** Run-time type information (and related methods). */ itkTypeMacro(GeometriesToGeometriesFilter, GeometriesSource); //@} /**\name Single input GeometriesSet property */ //@{ using Superclass::SetInput; virtual void SetInput(const InputGeometriesType *input); const InputGeometriesType * GetInput(void); //@} protected: /** Default constructor. * Does nothing. */ GeometriesToGeometriesFilter(); /** Destructor. * Does nothing. */ ~GeometriesToGeometriesFilter() ITK_OVERRIDE; /** Processes the input to fill the output. * This is the main processing function. It either works \em in-place or by * \em copying the transformed input \c Feature s into the output. */ void GenerateData(void) ITK_OVERRIDE; private: /** \e In-place processing function. * \param[in,out] inout the geometries set that'll be modified by the filter. * \pre The filter must have been initialized */ void Process(OutputGeometriesType &inout); /** \e By-copy processing function. * \param[in] source the geometries set to transform * \param[out] destination the resulting geometries set. * \pre The filter must have been initialized * \pre The \c destination must be ready to receive a result. */ void Process(InputGeometriesType const& source, OutputGeometriesType &destination); /**\name Filter specialization hooks. * Filter specialization hooks. * These functions are meant to be specialized by the actual filter. */ //@{ /** * Hook that actually filters an OGR \c Layer. * \param[in] source Input layer * \param[in,out] destination Output layer * * \note When source == destination, it means this is an inplace * filter. */ virtual void DoProcessLayer(ogr::Layer const& source, ogr::Layer & destination) const=0; /** * Hook used to determine the \c OGRSpatialReference when creating a new layer. * \param[in] source source \c Layer for reference (in case it has relevant * information). * \return a new \c OGRSpatialReference that the client code shall release * with the appropriate OGR function. * \return 0 by default. * \todo Return a unique_ptr. */ virtual OGRSpatialReference* DoDefineNewLayerSpatialReference(ogr::Layer const& source) const; /** * Hook used to determine the type of the new layer. * \param[in] source source \c Layer. * \return by default the same type as the one from the \c source \c Layer. */ virtual OGRwkbGeometryType DoDefineNewLayerGeometryType(ogr::Layer const& source) const; /** * Hook used to determine the options for creating a new layer. * \param[in] source source \c Layer for reference (in case it has relevant * information). * \return nothing by default. */ virtual std::vector DoDefineNewLayerOptions(ogr::Layer const& source) const; /** * Hook used to define the fields of the new layer. * \param[in] source source \c Layer -- for reference * \param[in,out] dest destination \c Layer */ virtual void DoDefineNewLayerFields(ogr::Layer const& source, ogr::Layer & dest) const = 0; /** Hook used to conclude the initialization phase. * As ITK doesn't follow a the constructor set the object in a final, and * ready to be used, state, this step is required to do that once all * filter attributes have been set. * * The default implementation does nothing. */ virtual void DoFinalizeInitialization() {} //@} /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ void DoFinalizeInitialisation() { otbWarningMacro( << "DoFinalizeInitialisation has been deprecated. Please use DoFinalizeInitialization() instead"); this->DoFinalizeInitialization(); } friend struct otb::internal::ProcessVisitor; }; /**\ingroup GeometriesFilters * Helper class to operate an exact copy of the fields from a source layer. * \since OTB v 3.14.0 */ struct OTBGdalAdapters_EXPORT FieldCopyTransformation { OGRFeatureDefn & getDefinition(ogr::Layer & outLayer) const { return outLayer.GetLayerDefn(); } /** * In-place transformation: does nothing. * \throw Nothing */ void fieldsTransform(ogr::Feature const& itkNotUsed(inoutFeature)) const { // default => do nothing for in-place transformation } /** * By-Copy transformation: copies all fields. * \param [in] inFeature input \c Feature * \param [in,out] outFeature output \c Feature * * \throw itk::ExceptionObject if the fields cannot be copied. */ void fieldsTransform(ogr::Feature const& inFeature, ogr::Feature & outFeature) const; /** * Defines the fields in the destination layer. * The default action is to copy all fieds from one layer to another. * \param [in] source source \c Layer * \param [in,out] dest destination \c Layer * \throw itk::ExceptionObject in case the operation can't succeed. */ void DefineFields(ogr::Layer const& source, ogr::Layer & dest) const; private: /** Associative table to know how fields are mapped from one layer to another. * This table is necessary as: * - some data source drivers add their own fields (as a consequence, the * number of fields differ between two layers). * - other data source drivers truncate the name of the fields (as a * consequence, we can't rely on field names). * \todo \c std::map may not be the fastest structure available => use a * (sorted?) vector of pairs of ints, and search with a simple \c std::find * (as we can expect the number of fields to be quite low). */ mutable std::map m_SourceToDestFieldIndicesMap; }; /**\ingroup GeometriesFilters * \class TransformationFunctorDispatcher * Policy to call the transformation functor on \c OGRGeometry (even when the * actual transformed element is a \c ogr::Layer). * \tparam TransformationFunctor actual transformation functor * \tparam TransformedElementType geometries to transform. * This policy-class is specialized for \c ogr::Layer and \c OGRGeometry. * * This functor dispatcher is meant to work: * - on a single \c ogr::Layer (in that case, it acts as a in-place filter). * - or on a pair of \c ogr::Layer s (in that case, it acts as a copy filter). * * Specializations are expected to provide: * - a typedef \c TransformedElementType which is expected to match \c * TransformationFunctor::TransformedElementType; * - one overload of \c operator() one that takes a reference to a \c ogr::Layer * for \em in-place transformation; * - another overload of \c operator() one that takes a const reference, and a * reference to \c ogr::Layer for \em by-copy transformation; * - and one overload to operator->() that returns a pointer to the * actual \c TransformationFunctor. * \since OTB v 3.14.0 * \todo Add a specialization for \c ogr::Feature. * * \ingroup OTBGdalAdapters */ template struct TransformationFunctorDispatcher { }; /**\ingroup GeometriesFilters * Specialization for \c ogr::Layer. * It simply forwards the call to the internal functor that'll have to do all * the transformation work. * * If you need to change the number of elements in a layer, use a \c * TransformationFunctor that works on layers. The dispatching mechanism will * automatically end up here. * \tparam TransformationFunctor actual transformation functor * \since OTB v 3.14.0 */ template struct TransformationFunctorDispatcher : FieldTransformationPolicy { typedef typename TransformationFunctor::TransformedElementType TransformedElementType; BOOST_MPL_ASSERT((boost::is_same)); TransformationFunctorDispatcher() { } TransformationFunctorDispatcher(TransformationFunctor functor) : m_functor(functor){ } void operator()(ogr::Layer const& in, ogr::Layer & out) const; void operator()(ogr::Layer & inout) const; TransformationFunctor * operator->() { return &m_functor; } private: TransformationFunctor m_functor; }; /**\ingroup GeometriesFilters * Specialization for \c OGRGeometry. * \tparam TransformationFunctor actual transformation functor * * In this case, the \c TransformationFunctor works on \c OGRGeometry (instead * of \c ogr::Layer). The default behaviour provided is to loop on all the \c * ogr::Feature s of the original layer, and for each feature: * - build a new one (in case of the \emm by-copy policy), * - build a new geometry thanks to the \c TransformationFunctor, which will be * assigned to the output feature, * - transform the fields from the input layer, * - and update the feature in the output layer. * * \note In the case of the \em by-copy policy, fields transformation cannot * change the number of fields nor their nature. Only field values may be * modified. * \since OTB v 3.14.0 */ template struct TransformationFunctorDispatcher : FieldTransformationPolicy { typedef typename TransformationFunctor::TransformedElementType TransformedElementType; BOOST_MPL_ASSERT((boost::is_same)); TransformationFunctorDispatcher() { } TransformationFunctorDispatcher(TransformationFunctor functor) : m_functor(functor){} void operator()(ogr::Layer const& in, ogr::Layer & out) const; void operator()(ogr::Layer & inout) const; TransformationFunctor * operator->() { return &m_functor; } private: TransformationFunctor m_functor; }; /**\ingroup GeometriesFilters * \class DefaultGeometriesToGeometriesFilter * Generic helper class to filter geometries sets given a transformation functor. * This generic class provides the default behaviour for most filters that we * may need to implement. * * Thanks to it, we just need to provide a \c TransformationFunctor, and a \c * FieldTransformationPolicy (if the default no-transformation policy is not * what we need). * \since OTB v 3.14.0 * \todo Find a better name * * \ingroup OTBGdalAdapters */ template class ITK_EXPORT DefaultGeometriesToGeometriesFilter : public GeometriesToGeometriesFilter , public TransformationFunctorDispatcher { public: /**\name Standard ITK typedefs */ //@{ typedef DefaultGeometriesToGeometriesFilter Self; typedef GeometriesToGeometriesFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //@} /**\name Class typedefs */ //@{ typedef TransformationFunctor TransformationFunctorType; typedef typename TransformationFunctor::TransformedElementType TransformedElementType; typedef TransformationFunctorDispatcher TransformationFunctorDispatcherType; //@} /**\name Standard macros */ //@{ /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DefaultGeometriesToGeometriesFilter, GeometriesToGeometriesFilter); //@} protected: /** Default constructor. */ DefaultGeometriesToGeometriesFilter(); /** Destructor. */ ~DefaultGeometriesToGeometriesFilter() ITK_OVERRIDE; /** * Hook that actually filters an OGR \c Layer. * \param[in] source Input layer * \param[in,out] destination Output layer * * This specialization just forwards the transformation to the \c * m_TransformationFunctor. * \note When source == destination, it means this is an \em in-place * filter. */ void DoProcessLayer(ogr::Layer const& source, ogr::Layer & destination) const ITK_OVERRIDE; /** * Hook used to define the fields of the new layer. * \param[in] source source \c Layer -- for reference * \param[in,out] dest destination \c Layer * * Just forwards the fields definition to the \c FieldTransformationPolicy * inherited from the \c TransformationFunctorDispatcherType. */ void DoDefineNewLayerFields(ogr::Layer const& source, ogr::Layer & dest) const ITK_OVERRIDE { this->DefineFields(source, dest); } }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGeometriesToGeometriesFilter.txx" #endif #endif // otbGeometriesToGeometriesFilter_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbGeometriesToGeometriesFilter.txx000066400000000000000000000110771301006202600316270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeometriesToGeometriesFilter_txx #define otbGeometriesToGeometriesFilter_txx /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesToGeometriesFilter.h" /*===========================================================================*/ /*==================[ DefaultGeometriesToGeometriesFilter ]==================*/ /*===========================================================================*/ template inline otb::DefaultGeometriesToGeometriesFilter::DefaultGeometriesToGeometriesFilter() {} template inline /*virtual*/ otb::DefaultGeometriesToGeometriesFilter::~DefaultGeometriesToGeometriesFilter() {} template inline /*virtual*/ void otb::DefaultGeometriesToGeometriesFilter::DoProcessLayer( otb::ogr::Layer const& source, otb::ogr::Layer & destination) const { if (source != destination) { (*this)(source, destination); // if TransformedElementType == layer // m_TransformationFunctor(source, destination); // if TransformedElementType == layer } else { // m_TransformationFunctor(destination); // if TransformedElementType == layer (*this)(destination); // if TransformedElementType == layer } } /*===========================================================================*/ /*================[ TransformationFunctorDispatcher ]=================*/ /*===========================================================================*/ template inline void otb::TransformationFunctorDispatcher::operator()( otb::ogr::Layer const& in, otb::ogr::Layer & out) const { m_functor(in, out); } template inline void otb::TransformationFunctorDispatcher::operator()( otb::ogr::Layer & inout) const { m_functor(inout); } /*===========================================================================*/ /*=============[ TransformationFunctorDispatcher ]==============*/ /*===========================================================================*/ template inline void otb::TransformationFunctorDispatcher::operator()( otb::ogr::Layer const& in, otb::ogr::Layer & out) const { OGRFeatureDefn & defn = out.GetLayerDefn(); for (ogr::Layer::const_iterator b = in.begin(), e = in.end(); b != e; ++b) { ogr::Feature const feat = *b; ogr::UniqueGeometryPtr g = m_functor(feat.GetGeometry()); ogr::Feature dest(defn); dest.SetGeometryDirectly(otb::move(g)); this->fieldsTransform(feat, dest); out.CreateFeature(dest); } } template inline void otb::TransformationFunctorDispatcher::operator()( otb::ogr::Layer & inout) const { // OGRFeatureDefn & defn = inout.GetLayerDefn(); // NB: We can't iterate with begin()/end() as SetFeature may invalidate the // iterators depending of the underlying drivers // => we use start_at(), i.e. SetNextByIndex() for (int i=0, N=inout.GetFeatureCount(true); i!=N; ++i) { ogr::Feature feat = *inout.start_at(i); this->fieldsTransform(feat); ogr::UniqueGeometryPtr g = m_functor(feat.GetGeometry()); feat.SetGeometryDirectly(otb::move(g)); inout.SetFeature(feat); } } #endif OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbImageReference.h000066400000000000000000000110711301006202600262660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageReference_h #define otbImageReference_h #include "itkPoint.h" namespace otb { namespace ogr { /**\ingroup gGeometry * \class ImageReference * \todo See how mix it with the \c otb::ogr::DataSource wrapper as it was * with \c VectorData. * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ template class ImageReference { public: typedef TPrecision PrecisionType; enum { Dimension = 2 }; /**\name Standard ITK typedefs */ //@{ bool GetDebug() const { return m_Holder.GetDebug(); } //@} /**\name Template-parameters typedefs */ //@{ typedef itk::Vector SpacingType; typedef itk::Point OriginType; typedef itk::Point PointType; //@} inline const char * GetNameOfClass() { return "ImageReference"; } /** Default constructor. * \post m_Spacing = {1,1} * \post m_Origin = {0,0} */ ImageReference(itk::Object const& holder) : m_Holder(holder) { m_Spacing.Fill(1); m_Origin.Fill(0); } /** Init constructor. * \post m_Spacing = spacing * \post m_Origin = origin */ ImageReference(SpacingType const& spacing, OriginType const& origin, itk::Object const& holder) : m_Holder(holder) , m_Spacing(spacing), m_Origin(origin) { } void Modified() const { m_Holder.Modified(); } /**\name Origin property * Represents the origin of the geometries in the image coordinates system. */ //@{ itkGetConstReferenceMacro(Origin, OriginType); //!< Origin getter. itkSetMacro(Origin, OriginType); //!< Origin setter. void SetOrigin(const TPrecision origin[Dimension]) //!< Origin setter. { const OriginType p(origin); this->SetOrigin(p); } //@} /**\name Spacing property * Spacing of the geometries to put in the corresponding image coordinates. */ //@{ itkGetConstReferenceMacro(Spacing, SpacingType); //!< Spacing getter. void SetSpacing(const SpacingType& spacing) //!< Spacing setter. { // itkDebugMacro("setting Spacing to " << spacing); if (this->m_Spacing != spacing) { this->m_Spacing = spacing; this->Modified(); } } void SetSpacing(const TPrecision spacing[Dimension]) //!< Spacing setter. { const SpacingType s(spacing); this->SetSpacing(s); } //@} /** * Projects a point from the Data Source coordinates system to the image * coordinates system. * \param[in] point point in Data Source coordinates system * \param[out] physicalPoint point in the image coordinates system. * \throw None */ void TransformPointToPhysicalPoint(const PointType& point, PointType& physicalPoint) const { for (size_t i=0; i!=Dimension; ++i) physicalPoint[i] = point[i] * m_Spacing[i] + m_Origin[i]; } /** * Projects a point from the Data Source coordinates system to the image * coordinates system. * \param[in] point point in Data Source coordinates system * \return the point projected in the image coordinates system. * \throw None */ void TransformPointToPhysicalPoint(const PointType& point) const { // why no loop on VDimension ? PointType physicalPoint; for (size_t i=0; i!=Dimension; ++i) physicalPoint[i] = point[i] * m_Spacing[i] + m_Origin[i]; return physicalPoint; } /** * Assignment operator. * \param[in] rhs source data to be copied. * \throw None * \internal * Required because of the hack to provide a \c GetDebug() function which is * required by \c itkTypeMacro. */ ImageReference& operator=(ImageReference const& rhs) { m_Spacing = rhs.m_Spacing; m_Origin = rhs.m_Origin; return *this; } private: itk::Object const& m_Holder; SpacingType m_Spacing; OriginType m_Origin; }; } // ogr namespace } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION // #include "otbImageReference.txx" #endif #endif // otbImageReference_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGR.h000066400000000000000000000025041301006202600240550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGR_h #define otbOGR_h namespace otb { /**\defgroup gGeometry Geometry * \ingroup Thematic * \brief Classes and functions aimed toward the manipulation of set of geometric objects. * This module mainly provides an encapsulation of OGR API. * @{ */ namespace ogr { } //@} } // namespace otb #include "otbOGRDriversInit.h" #include "otbOGRDataSourceWrapper.h" // #include "otbOGRLayerWrapper.h" // implicit // #include "otbOGRFeatureWrapper.h" // implicit // #include "otbOGRFieldWrapper.h" // implicit // #include "otbOGRGeometryWrapper.h" // implicit /**\ingroup gGeometry * \file otbOGR.h * \brief How to include all include files dedicated to OGR encapsulation in OTB... */ #endif // otbOGR_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRDataSourceWrapper.h000066400000000000000000000517251301006202600274020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDataSourceWrapper_h #define otbOGRDataSourceWrapper_h #include // to implement copy_const #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include #include #include #include #pragma GCC diagnostic pop #else #include #include #include #include #endif #include "itkDataObject.h" #include "itkMacro.h" // itkNewMacro #include "itkObjectFactory.h" // that should have been included by itkMacro.h #include "otbOGRLayerWrapper.h" #include "otbOGRVersionProxy.h" class OGRLayer; class OGRSpatialReference; class OGRGeometry; // #include "ogr_core.h" // OGRwkbGeometryType, included from Layer namespace otb { namespace ogr { /**\ingroup gGeometry * \class DataSource * \brief Collection of geometric objects. * * This class is meant to supersede \c otb::VectorData class. It provides * an encapsulation of OGR classes. In that particular case, it's an * encapsulation of \c GDALDataset. * * \note Not meant to be inherited. * \note This class has an entity semantics: \em non-copyable, nor \em * assignable. * \note \c OGRRegisterAll() is implicitly called on construction. * * \note The following functions haven't been encapsulated (yet?): * - \c SetStyleTable() & \c GetStyleTable() * - \c SetDriver() & \c GetDriver() * - all functions related to the reference count. * \since OTB v 3.14.0 * \internal As the class is not meant to be inherited, no new function is virtual. * * \ingroup OTBGdalAdapters */ #include "OTBGdalAdaptersExport.h" class OTBGdalAdapters_EXPORT DataSource : public itk::DataObject , public boost::noncopyable { public: /**\name Standard ITK typedefs */ //@{ typedef DataSource Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //@} /**\name Standard macros */ //@{ /** Default builder. * This builder function creates a new \c DataSource with its default * constructor. The actual \c GDALDataset is using the in-memory * \c OGRSFDriver: \c OGRMemDriver. * * \throw itk::ExceptionObject if the inner \c GDALDataset cannot be * opened. * * \note \c OGRRegisterAll() is implicitly called on construction. * \see \c DataSource() */ itkNewMacro(Self); itkTypeMacro(DataSource, DataObject); //@} /**\name Creation functions */ //@{ /** * I/O modes for \c DataSources. * \note Read/Write mode should have been read | write, but actually * OGR data source are always at least in read mode. */ struct Modes { enum type { Invalid, Read, ///< Open data source in read-only mode Overwrite, ///< Open data source in overwrite mode ///< ///< Data source is deleted if it exists ///< and a new data source is created ///< Warning : this can delete a whole database ///< if the existing datasource contains a list of layers Update_LayerOverwrite, ///< Open data source in update mode with layers being overwritten ///< ///< When requesting a layer, it is opened in overwrite mode ///< with OVERWRITE=YES creation option. ///< If the layer does not exists, it is created on the fly Update_LayerUpdate, ///< Open data source in update mode with layers being updated ///< ///< New geometries are added to existing layers. ///< If the layer does not exists, it is created on the fly Update_LayerCreateOnly,///< Open data source in update mode with layers being created only ///< ///< This option prevents the loss of data. ///< One can open an existing database with existing layer, and ///< and add new layers to it. ///< Only non-existing layers can be requested MAX__ }; }; /** * Builder from an existing named data source. * \param[in] datasourcename OGR identifier of the data source * \param[in] mode opening mode (read or read-write) * \return a newly created \c DataSource. * \throw itk::ExceptionObject if the inner \c GDALDataset cannot be * opened. * \note \c OGRRegisterAll() is implicitly called on construction * \see \c DataSource(GDALDataset *) */ static Pointer New(std::string const& datasourcename, Modes::type mode = Modes::Read); /** * Builder from a built \c GDALDataset. * \param[in,out] source \c GDALDataset already constructed. * \return a newly created \c DataSource that assumes ownership of \c * source. * \throw Nothing * \note \c OGRRegisterAll() is supposed to have been called before building * \c source. * \note No condition is assumed on the non-nullity of \c source. * \see \c DataSource(GDALDataset *) */ static Pointer New(ogr::version_proxy::GDALDatasetType * sourcemode, Modes::type mode = Modes::Read); //@} /**\name Projection Reference property */ //@{ #if 0 void SetProjectionRef(const std::string& projectionRef); std::string GetProjectionRef() const; #endif //@} /** Clears the data source. * \post The \c GDALDataset owned is destroyed with the dedicated function * from OGR %API. * \post m_DataSource = 0 */ bool Clear(); /**\name Iteration */ //@{ /**\ingroup gGeometry * \class layer_iter * \brief Implementation class for \c Layer iterator. * \sa \c otb::ogr::Layer::iterator * \sa \c otb::ogr::Layer::const_iterator * \note Naming policy is compliant with C++ standard as the iterator * functions are as well. This will permit transparent integration with all * standard and boost algorithms, and C++11 for-range loops for * instance. * \see http://www.boost.org/doc/libs/1_49_0/libs/iterator/doc/iterator_facade.html#tutorial-example * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ template class layer_iter : public boost::iterator_facade, Value, boost::random_access_traversal_tag, Value> { struct enabler {}; /** Const-synchronized type of the \c DataSource container. * \internal * The definition of a new series of functions \c boost::copy_const, * \c boost::copy_cv, etc have been discussed * on boost mailing-list. However nothing seems to have been undertaken * in this way, even if a ticket has been * opened. * * So here is the hard-coded result of what \c boost::copy_const would have * given in order to avoid any licensing issue. */ typedef typename boost::mpl::if_ , otb::ogr::DataSource const , otb::ogr::DataSource >::type container_type; public: layer_iter(container_type & datasource, size_t index); layer_iter(); template layer_iter( layer_iter const& other, typename boost::enable_if , enabler >::type = enabler() ); private: friend class boost::iterator_core_access; template friend class layer_iter; template bool equal(layer_iter const& other) const; void increment(); Value dereference() const; container_type * m_DataSource; size_t m_index; }; template friend class layer_iter; typedef layer_iter iterator; typedef layer_iter const_iterator; const_iterator begin () const { return cbegin(); } const_iterator end () const { return cend (); } const_iterator cbegin() const; const_iterator cend () const; iterator begin (); iterator end (); //@} /** Returns the number of elements in the Data Source. * \param[in] doForceComputation indicates whether the size shall be * computed on each layer even so it's expensive to do so. * * \return the number of features in the Data Source, -1 if count is unknown * \throw None * \sa \c OGRLayer::GetFeatureCount() */ int Size(bool doForceComputation) const; /** Retrieves the union of the extents of all layers. * \param[out] ulx reference to upper-left x coordinate of the extent * \param[out] uly reference to upper-left y coordinate of the extent * \param[out] lrx reference to lower-right x coordinate of the extent * \param[out] uly reference to lower-right y coordinate of the extent * \param[in] force Force computation of layers extents if not available. May * force the driver to walk all geometries to compute the extent. * \return The Wkt of the extent projection (which is the wkt of the first * layer SRS) * \throw itk::ExceptionObject if the layers extents can not be retrieved. */ std::string GetGlobalExtent(double & ulx, double & uly, double & lrx, double & lry, bool force = false) const; /** Retrieves the union of the extents of all layers. * \param[in] force Force computation of layers extents if not available. May * force the driver to walk all geometries to compute the extent. * \param[out] outwkt The Wkt of the extent projection (which is the wkt of * the first layer SRS); if null, nothing is returned this way * \return the extent of all layers * \throw itk::ExceptionObject if the layers extents can not be retrieved. */ OGREnvelope GetGlobalExtent(bool force = false, std::string * outwkt=ITK_NULLPTR) const; /** Grafts data and information from one data source to another. * \deprecated \c OGRLayer has an embedded input iterator. As a consequence, * the layer cannot support multiple access to its elements. * * This is a convenience function to setup a second data source with all the * meta information of another data source and use the same underlying \c * GDALDataset. */ void Graft(const itk::DataObject *data) ITK_OVERRIDE; /** * Resets current data source with the one in parameter. * \param[in,out] source source \c GDALDataset that this instance will own. * \throw None * \post Assumes ownership of the \c source. */ void Reset(ogr::version_proxy::GDALDatasetType * source); /**\name Layers modification */ //@{ /** * Creates a new layer. * \param[in] name name for the layer * \param poSpatialRef the coordinate system to use for the new layer, * or NULL if no coordinate system is available. * \param[in] eGType the geometry type for the layer. Use wkbUnknown * if there are no constraints on the types * geometry to be written. * \param[in] papszOptions a StringList of name=value options. Options are * driver specific. * * \return a proxy on the \c OGRLayer created. * \throw itk::ExceptionObject in case the layer cannot be created on the * data source. * * \note A \em proxy-class is returned instead of a plain \c OGRLayer is * order to encapsulate all lifetime management of the \c OGRLayer obtained * (i.e. never to be destroyed). If you want to delete a layer obtained * with \c CreateLayer(), you must use \c DeleteLayer(). * \note The \c papszOptions parameter may later become a \c * std::vector. * \sa \c GDALDataset::CreateLayer() */ Layer CreateLayer( std::string const& name, OGRSpatialReference * poSpatialRef = ITK_NULLPTR, OGRwkbGeometryType eGType = wkbUnknown, std::vector const& papszOptions = std::vector()); /** * Deletes the i-th layer from the data source. * \param[in] i layer index * * \throw itk::ExceptionObject in case the index is out of range * \throw itk::ExceptionObject if the layer cannot be deleted from the data * source. * * \pre The data source must support the delete operation. * \pre The index \c i must be in range [0, GetLayersCount()). * \sa \c GDALDataset::DeleteLayer() */ void DeleteLayer(size_t i); /** * Copies a layer. * \param[in] srcLayer Source layer to copy. It may come from another \c * DataSource. * \param[in] newName Name of the new layer * \param[in] papszOptions Creation options * * \return a proxy on the \c OGRLayer created. * \throw itk::ExceptionObject in case the layer cannot be created on the * data source. * * \note A \em proxy-class is returned instead of a plain \c OGRLayer in * order to encapsulate all lifetime management of the \c OGRLayer obtained * (i.e. never to be destroyed). If you want to delete a layer obtained * with \c CreateLayer(), you must use \c DeleteLayer(). * \note The \c papszOptions parameter may later become a \c * std::vector. * \sa \c GDALDataset::CopyLayer() */ Layer CopyLayer( Layer & srcLayer, std::string const& newName, char ** papszOptions = ITK_NULLPTR); //@} /**\name Layers access *\note As the following accessors are not inlined, they aren't optimized. */ //@{ /** Returns the number of layers. * \sa \c GDALDataset::GetLayersCount() */ int GetLayersCount() const; /** * Unchecked Accessor to a given layer. * \param[in] i index of the layer to access * \return the layer requested. * \pre i < GetLayersCount(), an assertion will be fired otherwise. * \pre The layer must be available, an assertion will be fired otherwise. * \throw None * \note Use \c GetLayerUnchecked() if invalid indices are programming * errors, or if null layers are to be expected. */ Layer GetLayer(size_t i); /**\copydoc otb::ogr::DataSource::GetLayer(size_t) */ Layer const GetLayer(size_t i) const; /** * Unchecked Accessor to a given layer. * \param[in] name name of the layer to search * \return the layer requested, possibly a null one. * \throw None * \note Use \c GetLayerChecked(std::string const&) if you'd rather have * an exception instead of testing whether the layer obtained is valid. */ Layer GetLayer(std::string const& name); /**\copydoc otb::ogr::DataSource::GetLayer(std::string const&) */ Layer const GetLayer(std::string const& name) const; /** * Checked Accessor to a given layer. * \param[in] i index of the layer to access * \return a reference to the layer requested. * \pre i < GetLayersCount(), an exception is raised otherwise. * \pre The layer must available, an exception is raised otherwise. * \note Use \c GetLayer() if invalid indices, and null layers, are expected * to be programming errors. * \throw None */ Layer GetLayerChecked(size_t i); /**\copydoc otb::ogr::DataSource::GetLayerChecked() */ Layer const GetLayerChecked(size_t i) const; /** * Checked Accessor to a given layer. * \param[in] name name of the layer to search * \return the layer requested, possibly a null one. * \throw itk::ExceptionObject if there exist no layer by that name * \note Use \c GetLayer(std::string const&) if you'd rather test the * obtained layer instead of catching an exception. */ Layer GetLayerChecked(std::string const& name); /**\copydoc otb::ogr::DataSource::GetLayerChecked(std::string const&) */ Layer const GetLayerChecked(std::string const& name) const; /** * Executes the statement.. * \param[in] statement textual description of the SQL statement. * \param[in] poSpatialFilter \c Geometry representing a spatial filter -- may be null. * \param[in] pszDialect allows control of the statement dialect. If set to * NULL, the OGR SQL engine will be used, except for * RDBMS drivers that will use their dedicated SQL * engine, unless OGRSQL is explicitly passed as the * dialect. * \return a new \c Layer that contains the matching \c Features. In case of * error, or no matching result sets, a \em null Layer will be returned. * Check for \c Layer's validity before doing anything else. * \throw None even when there is an error -- OGR can not report errors, * neither this wrapping. * \note The returned \c Layer will be automatically collected on its * destruction; i.e. unlike OGR API, no need to explicitly call \c * GDALDataset::ReleaseResultSet(). * \sa \c GDALDataset::ExecuteSQL() */ Layer ExecuteSQL( std::string const& statement, OGRGeometry * poSpatialFilter, char const* pszDialect); //@} struct boolean{ int i; }; /** Can the data source be used (ie not null). * * Hack to provide a boolean operator that is convertible only to a * boolean expression to be used in \c if tests. * \see Imperfect C++, Matthew Wilson, Addisson-Welsey, par 24.6 */ operator int boolean ::* () const { return m_DataSource ? &boolean::i : ITK_NULLPTR; } /** Flushes all changes to disk. * \throw itd::ExceptionObject in case the flush operation failed. * \sa \c GDALDataset::SyncToDisk() */ void SyncToDisk(); /** Returns whether a capability is avalaible. * \param[in] capabilityName name of the capability to check. * \throw None * \sa \c GDALDataset::TestCapability() */ bool HasCapability(std::string const& capabilityName) const; /** Access to raw \c GDALDataset. * This function provides an abstraction leak in case deeper control on the * underlying \c GDALDataset is required. * \pre The underlying \c GDALDataset must be valid, i.e. * m_DataSource != 0, an assertion is fired otherwise. * \warning You must under no circonstance try to delete the \c GDALDataset * obtained this way. */ ogr::version_proxy::GDALDatasetType & ogr(); protected: /** Default constructor. * The actual \c GDALDataset is using the in-memory \c * OGRSFDriver: \c OGRMemDriver. * \throw itk::ExceptionObject if the inner \c GDALDataset cannot be * opened. * * \note \c OGRRegisterAll() is implicitly called on construction * \see \c DataSource::New() */ DataSource(); /** Init constructor. * \post The newly constructed object owns the \c source parameter. */ DataSource(ogr::version_proxy::GDALDatasetType * source, Modes::type mode); /** Destructor. * \post The \c GDALDataset owned is released (if not null). */ ~DataSource() ITK_OVERRIDE; static Pointer OpenDataSource(std::string const& datasourceName, Modes::type mode); /** Prints self into stream. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** * Internal unchecked accessor to a given layer. * \param[in] i index of the layer to access * \return a reference to the layer requested. * \pre i < GetLayersCount(), return 0 otherwise * \pre The layer must available, 0 is returned otherwise. * \throw None * \internal this function is a simple encapsulation of \c * GDALDataset::GetLayer(). */ OGRLayer* GetLayerUnchecked(size_t i); /** @copydoc OGRLayer* otb::ogr::DataSource::GetLayerUnchecked(size_t i) */ OGRLayer* GetLayerUnchecked(size_t i) const; bool IsLayerModifiable(size_t i) const; bool IsLayerModifiable(std::string const& name) const; size_t GetLayerID(std::string const& name) const; int GetLayerIDUnchecked(std::string const& name) const; /** Get a string describing the dataset */ std::string GetDatasetDescription() const; private: ogr::version_proxy::GDALDatasetType *m_DataSource; Modes::type m_OpenMode; int m_FirstModifiableLayerID; }; // end class DataSource } } // end namespace otb::ogr #if 0 // Either this, or inheriting from noncopyable is required for DataSource to be // compatible with BOOST_FOREACH namespace boost { namespace foreach { template struct is_noncopyable; // forward declaration template <> struct is_noncopyable : mpl::true_ {}; }} #endif #ifndef OTB_MANUAL_INSTANTIATION #include "otbOGRDataSourceWrapper.txx" #endif #endif // otbOGRDataSourceWrapper_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRDataSourceWrapper.txx000066400000000000000000000101531301006202600277640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /**\ingroup Geometry * \file otbOGRDataSourceWrapper.txx * \internal this file is meant to be included by otbOGRDataSourceWrapper.h */ #ifndef otbOGRDataSourceWrapper_txx #define otbOGRDataSourceWrapper_txx #include "otbOGRDataSourceWrapper.h" /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include #include "itkMacro.h" // itk::ExceptionObject #include "ogrsf_frmts.h" // OGRDataSource & OGRLayer /*===========================================================================*/ /*=========================[ otb::ogr::DataSource ]==========================*/ /*===========================================================================*/ // These function definitions are inline so assert() will be expanded according // to the compilation mode of the client code. inline otb::ogr::version_proxy::GDALDatasetType & otb::ogr::DataSource::ogr() { assert(m_DataSource && "GDALDataset not initialized"); return *m_DataSource; } inline otb::ogr::Layer otb::ogr::DataSource::GetLayer(size_t i) { assert(int(i) < GetLayersCount() && "Out-of-range index"); OGRLayer * layer_ptr = GetLayerUnchecked(i); assert(layer_ptr && "No layer returned by OGR"); return otb::ogr::Layer(layer_ptr, IsLayerModifiable(i)); } inline otb::ogr::Layer const otb::ogr::DataSource::GetLayer(size_t i) const { return const_cast (this)->GetLayer(i); } inline otb::ogr::Layer const otb::ogr::DataSource::GetLayer(std::string const& name) const { return const_cast (this)->GetLayer(name); } inline otb::ogr::Layer const otb::ogr::DataSource::GetLayerChecked(size_t i) const { return const_cast (this)->GetLayerChecked(i); } inline OGRLayer* otb::ogr::DataSource::GetLayerUnchecked(size_t i) const { return const_cast (this)->GetLayerUnchecked(i); } /*===========================================================================*/ /*====================[ otb::ogr::DataSource/iterators ]=====================*/ /*===========================================================================*/ template otb::ogr::DataSource::layer_iter::layer_iter(container_type & datasource, size_t index) : m_DataSource(&datasource), m_index(index) {} template otb::ogr::DataSource::layer_iter::layer_iter() : m_DataSource(0), m_index(0) {} template template otb::ogr::DataSource::layer_iter::layer_iter( otb::ogr::DataSource::layer_iter const& other, typename boost::enable_if , enabler >::type ) : m_DataSource(other.m_DataSource), m_index(other.m_index) {} template template bool otb::ogr::DataSource::layer_iter::equal(layer_iter const& other) const { return m_DataSource == other.m_DataSource && other.m_index == m_index; } template void otb::ogr::DataSource::layer_iter::increment() { assert(m_DataSource && int(m_index) < m_DataSource->GetLayersCount() && "cannot increment past end()"); ++m_index; } template Value otb::ogr::DataSource::layer_iter::dereference() const { assert(m_DataSource && int(m_index) < m_DataSource->GetLayersCount() && "cannot dereference past end()"); return Value(m_DataSource->GetLayerUnchecked(m_index), m_DataSource->IsLayerModifiable(m_index)); } #endif // otbOGRDataSourceWrapper_txx OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRDriversInit.h000066400000000000000000000030331301006202600262360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDriversInit_h #define otbOGRDriversInit_h #include #include "OTBGdalAdaptersExport.h" namespace otb { namespace ogr { /**\ingroup Geometry * Singleton-like class to provide lazy-registering of all \c OGRDriver's. * * Call * \code * otb::ogr::Drivers::Init(); * \endcode * before using classes wrapping OGR. * *

Properties
* - Follows Meyer's Singleton design. * - Implicitly initialized with a default constructor * - MT-Safe in C++11, and some compilers like GCC (not on old releases of * VC++) * - Non-copyable */ class OTBGdalAdapters_EXPORT Drivers : private boost::noncopyable { /** \name Singleton related functions */ //@{ public: static Drivers & Init(); private: /** Constructor. * Calls \c OGRRegisterAll(). */ Drivers(); /** Destructor. * Calls \c OGRCleanupAll(). */ ~Drivers(); //@} }; } } // end namespace otb::ogr #endif // otbOGRDriversInit_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRFeatureWrapper.h000066400000000000000000000313561301006202600267410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRFeatureWrapper_h #define otbOGRFeatureWrapper_h // #include // std::ostream& #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #else #include #endif // #include "itkIndent.h", included from field #include "otbOGRFieldWrapper.h" #include "otbOGRGeometryWrapper.h" class OGRFeature; class OGRFeatureDefn; namespace otb { namespace ogr { class Feature; OTBGdalAdapters_EXPORT bool operator==(Feature const& lhs, Feature const& rhs); /**\ingroup gGeometry * \class Feature proxy class. * \brief Geometric objet with descriptive fields. * * It provides an encapsulation of OGR classes. In that particular case, it's an * encapsulation of \c OGRFeature. * * \note This class is a proxy class on top of an \c OGRLayer. * \note It can be copied, and assigned. New instances will share the underlying * \c OGRLayer: \c Feature assignment will just make one \c Feature proxy point * to another \c OGRFeature. In order to truly assign from one to another, use * \c SetFrom, or \c Clone in order to duplicate the current feature. * \note The default constructor is disabled on purpose. * \note The destructor automatically generated does everything that is * expected. * \invariant m_Feature != 0 Actually, this isn't a true invariant per * se, as it may be null in some cases, for instance to define mark the \c * Layer::end() iterator. * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ class OTBGdalAdapters_EXPORT Feature { public: /**\name Construction, copy and destruction */ //@{ /** * Construction from a definition. * \param[in] definition definition of the fields of the feature. * \throw None * * \post m_Feature != 0 * \post \c definition internal reference count is incremented * \warning DO NOT destroy the definition while it is relied upon by features. * \internal The OGR feature is created with the ad'hoc function from OGR API. * \sa \c OGRFeature::CreateFeature() * \todo See whether wrapping \c OGRFeatureDefn makes sense */ Feature(OGRFeatureDefn & definition); /** * Construction from a pre-existing \c OGRFeature. * \param[in,out] feature pre-existing feature that will be owned by the * wrapper. * \throw None * \pre The feature is expected to have been built with OGR API. * \internal * As all functions form \c OGRLayer returns features that are meant to be be * of the responsibility of the client code, this constructor is perfect. It * has been used in \c Layer interface to return features. */ Feature(OGRFeature * feature); /** * Destructor. * \throw None * \internal The OGR feature is released with the ad'hoc function from OGR API. * \sa \c OGRFeature::DestroyFeature() */ ~Feature(); /** * Duplicates the current feature. * \return a duplicita of \c *this. * \throw None * \invariant m_Feature != 0 * * As \c Feature is a proxy class that shares its underlying \c OGRFeature, * this function represents the only way to duplicate a feature. * \sa \c OGRFeature::Clone() */ Feature Clone() const; /** * Assigns a pre-existing feature to the current one. * \param[in] rhs pre-existing feature to assign ourseleves from. * \param[in] map integer list of the fields to duplicated (default: all) * \param[in] mustForgive tells whether the operation should continue despite * lacking output fields matching some of the source fields. * * \throw itk::ExceptionObject if no value is transferred * \sa \c OGRFeature::SetFrom() */ void SetFrom(Feature const& rhs, int *map, bool mustForgive = true); /** \copydoc Feature::SetFrom(Feature const&, int *, bool mustForgive); */ void SetFrom(Feature const& rhs, bool mustForgive = true); //@} /** Prints self into stream. */ void PrintSelf(std::ostream &os, itk::Indent indent) const; /** Access to raw \c OGRFeature. * This function provides an abstraction leak in case deeper control on the * underlying \c OGRFeature is required. * \invariant The underlying \c OGRFeature must be valid, i.e. * m_DataSource != 0, an assertion is fired otherwise. * \warning You must under no circonstance try to delete the \c OGRFeature * obtained this way. */ OGRFeature & ogr() const; /** \copydoc Feature::ogr() const */ OGRFeature & ogr(); /** Abstraction leak to the internal shared \c OGRFeature. * \throw None * \internal * This function is meant to link a \c Field to the \c OGRFeature where it is * stored, without introducing a cyclic dependency, nor deporting the fields * R/W to \c Feature interface. */ boost::shared_ptr & sptr() {return m_Feature; } /** \copydoc Feature::sptr() */ boost::shared_ptr const& sptr() const {return m_Feature; } /** * Obtains feature ID.. * \return its ID, or \c OGRNullFID if none has been assigned. * \throw None * \invariant m_Feature != 0 * \sa \c OGRFeature::GetFID() */ long GetFID() const; /** * %Feature ID setter. * \param[in] fid new id. * \throw itk::ExceptionObject if it cannot be set. * \invariant m_Feature != 0 * \sa \c OGRFeature::SetFID() */ void SetFID(long fid); /** * %Feature definition accessor. * \return a reference to the internal definition. * \throw None * \invariant m_Feature != 0 * \sa \c OGRFeature::GetDefnRef() */ OGRFeatureDefn& GetDefn() const; /**\name Fields * Fields access. * Unlike original OGR API, the access to the fields of a feature is done * directly from the \c Field interface, and not the \c Feature interface. * * Ones first need to iterate on the fields of a feature, and then use the * appropriate setter/getter to access to each field. */ //@{ /** * Returns the number of fields. * \invariant m_Feature != 0 * \sa \c OGRFeature::GetFieldCount() */ int GetSize() const; /** * Read-Write access to the i-th field. * \invariant m_Feature != 0 * \pre index < GetSize() * \throw None */ Field operator[](int index); /** * Read-only access to the i-th field. * \invariant m_Feature != 0 * \pre index < GetSize() * \throw None */ Field const operator[](int index) const; /** * Read-Write access to a field by name. * \invariant m_Feature != 0 * \throw itk::ExceptionObject if no field named \c name exists. */ Field operator[](std::string const& name); /** * Read-Only access to a field by name. * \invariant m_Feature != 0 * \throw itk::ExceptionObject if no field named \c name exists. */ Field const operator[](std::string const& name) const; /** Accessor to the definition of the i-th field. * \invariant m_Feature != 0 * \pre index < GetSize() * \throw None * \sa \c OGRFeature::GetFieldDefnRef() */ FieldDefn GetFieldDefn(int index) const; /** Accessor to the definition of a field gven its name. * \invariant m_Feature != 0 * \throw itk::ExceptionObject if no field named \c name exists. * \sa \c OGRFeature::GetFieldDefnRef() */ FieldDefn GetFieldDefn(std::string const& name) const; //@} /**\name Geometries * \todo We should detect whether the official C++11 \c std::unique_ptr<> is * available instead of always using boost.interprocess.unique_ptr<>. * \internal * \c OGRGeometry pointers are used and not references are used because the * current geometry can be unset. */ //@{ /** * Changes the current geometry. * \param[in] geometry Pointer to an existing geometry, null to dismiss any * geometry. * \post The input \c OGRGeometry is copied (cloned actually). * \throw itk::ExceptionObject on failure. * \invariant m_Feature != 0 * \sa \c OGRFeature::SetGeometry() */ void SetGeometry(OGRGeometry const* geometry); /** * Accessor to the internal \c OGRGeometry stored. * * \return The result may be null if no geometry is associated to the feature. * \return In any case the result shall not be modified. * \throw None * \invariant m_Feature != 0 * \sa \c OGRFeature::GetGeometryRef() */ OGRGeometry const* GetGeometry() const; /** * Changes the current geometry (transfers ownership). * \param[in] geometry Unique-pointer to an existing geometry, null to * dismiss any geometry. * \post Ownership of the input \c OGRGeometry is given to the feature. * \post GetGeometry() == initial_geometry * \post The user is no longer responsible of the input geometry, even on * failure of the operation. In that case, the geometry would have been * definitivelly destroyed with the ad'hoc function (\c * OGRGeometryFactory::destroyGeometry()). * \throw itk::ExceptionObject on failure. * \invariant m_Feature != 0 * \sa \c OGRFeature::SetGeometryDirectly() */ void SetGeometryDirectly(UniqueGeometryPtr geometry); /** * Steals the geometry stored.. * * \return A unique-pointer to a \c OGRGeometry that is now of the * responsibility of the caller. * \post GetGeometry() == 0 * \throw None * \invariant m_Feature != 0 * \sa \c OGRFeature::StealGeometry() * \internal * The \c UniqueGeometryPtr RAII wrapper will know how to correctly destroy * the \c OGRGeometry instance. */ UniqueGeometryPtr StealGeometry(); //@} /** * Tells whether two features are equal. * \return whether both are null or equal. * \throw None * \sa \c OGRFeature::Equals() * \internal * Used to determine when two \c Layer::iterator (\c Layer::feature_iter) are * equal. */ friend bool otb::ogr::operator==(Feature const& lhs, Feature const& rhs); OGRFeature const* addr() const { return m_Feature.get(); } private: /**\name Unchecked definitions * All the definitions that follow do the real work. However, they are not the * exposed public functions. The design of this class follows the principle * behind the NVI (Non-Virtual Interface) pattern: * - The public functions are inlined and check invariants and preconditions, * - While the private functions do the work. */ //@{ Feature UncheckedClone() const; void UncheckedSetFrom(Feature const& rhs, int *map, bool mustForgive = true); void UncheckedSetFrom(Feature const& rhs, bool mustForgive = true); void UncheckedPrintSelf(std::ostream &os, itk::Indent indent) const; Field UncheckedGetElement(int index); Field UncheckedGetElement(std::string const& name); FieldDefn UncheckedGetFieldDefn(int index) const; FieldDefn UncheckedGetFieldDefn(std::string const& name) const; int UncheckedGetFieldIndex(std::string const& name) const; long UncheckedGetFID() const; void UncheckedSetFID(long fid); OGRFeatureDefn& UncheckedGetDefn() const; void UncheckedSetGeometryDirectly(UniqueGeometryPtr geometry); UniqueGeometryPtr UncheckedStealGeometry(); OGRGeometry const* UncheckedGetGeometry() const; void UncheckedSetGeometry(OGRGeometry const* geometry); //@} /** Searches the index of a field given a name. * \invariant m_Feature != 0 * \throw itk::ExceptionObject if no field named \c name exists. */ int GetFieldIndex(std::string const& name) const; /** * Checks whether the internal \c OGRFeature is non null. * Fires an assertion otherwise. * \internal * Used by all the functions of \c Feature. As the definition of this function * is inlined, \c assert() actual behaviour will be conditionned by the * compilation mode (\em debug or \em release; or more exactly on \c NDEBUG * precompiler directive). */ void CheckInvariants() const; /** Internal pointer to the shared \c OGRFeature. */ boost::shared_ptr m_Feature; }; } // ogr namespace } // otb namespace #ifndef OTB_MANUAL_INSTANTIATION #include "otbOGRFeatureWrapper.txx" #endif #endif // otbOGRFeatureWrapper_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRFeatureWrapper.txx000066400000000000000000000131371301006202600273320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRFeatureWrapper_txx #define otbOGRFeatureWrapper_txx /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbOGRFeatureWrapper.h" #include #include #if BOOST_VERSION >= 104800 # include // since 1.48 #else # include #endif namespace otb { #if BOOST_VERSION >= 104800 using boost::move; #else using boost::interprocess::move; #endif } /*===========================================================================*/ /*================================[ Feature ]================================*/ /*===========================================================================*/ inline otb::ogr::Feature otb::ogr::Feature::Clone() const { CheckInvariants(); return UncheckedClone(); } inline void otb::ogr::Feature::SetFrom(Feature const& rhs, bool mustForgive) { CheckInvariants(); UncheckedSetFrom(rhs, mustForgive); } inline void otb::ogr::Feature::SetFrom(Feature const& rhs, int * map, bool mustForgive) { CheckInvariants(); UncheckedSetFrom(rhs, map, mustForgive); } /*===========================================================================*/ /*================================[ Fields ]=================================*/ /*===========================================================================*/ inline otb::ogr::Field otb::ogr::Feature::operator[](int index) { assert(index < GetSize() && "out of range field-index."); // also calls CheckInvariants(); return UncheckedGetElement(index); } inline otb::ogr::Field const otb::ogr::Feature::operator[](int index) const { return const_cast(this)->operator[](index); } inline otb::ogr::Field otb::ogr::Feature::operator[](std::string const& name) { CheckInvariants(); return UncheckedGetElement(name); } inline otb::ogr::Field const otb::ogr::Feature::operator[](std::string const& name) const { return const_cast(this)->operator[](name); } inline otb::ogr::FieldDefn otb::ogr::Feature::GetFieldDefn(int index) const { assert(index < GetSize() && "out of range field-index."); // also calls CheckInvariants(); return UncheckedGetFieldDefn(index); } inline otb::ogr::FieldDefn otb::ogr::Feature::GetFieldDefn(std::string const& name) const { CheckInvariants(); return UncheckedGetFieldDefn(name); } inline int otb::ogr::Feature::GetFieldIndex(std::string const& name) const { CheckInvariants(); return UncheckedGetFieldIndex(name); } /*===========================================================================*/ /*==============================[ Properties ]===============================*/ /*===========================================================================*/ inline long otb::ogr::Feature::GetFID() const { CheckInvariants(); return UncheckedGetFID(); } inline void otb::ogr::Feature::SetFID(long fid) { CheckInvariants(); UncheckedSetFID(fid); } inline OGRFeatureDefn& otb::ogr::Feature::GetDefn() const { CheckInvariants(); return UncheckedGetDefn(); } /*===========================================================================*/ /*==============================[ Geometries ]===============================*/ /*===========================================================================*/ inline void otb::ogr::Feature::SetGeometryDirectly(UniqueGeometryPtr geometry) { CheckInvariants(); #if !defined(NDEBUG) OGRGeometry * g = geometry.get(); #endif UncheckedSetGeometryDirectly(otb::move(geometry)); assert((m_Feature->GetGeometryRef() == g) && "The new geometry hasn't been set as expected"); assert(!geometry && "UniqueGeometryPtr hasn't released its pointer"); } inline otb::ogr::UniqueGeometryPtr otb::ogr::Feature::StealGeometry() { CheckInvariants(); UniqueGeometryPtr res = UncheckedStealGeometry(); itkAssertOrThrowMacro(!m_Feature->GetGeometryRef(), "Geometry hasn't been properly stolen"); return otb::move(res); } inline void otb::ogr::Feature::SetGeometry(OGRGeometry const* geometry) { CheckInvariants(); UncheckedSetGeometry(geometry); } inline OGRGeometry const* otb::ogr::Feature::GetGeometry() const { CheckInvariants(); return UncheckedGetGeometry(); } /*===========================================================================*/ /*=================================[ Misc ]==================================*/ /*===========================================================================*/ inline OGRFeature & otb::ogr::Feature::ogr() const { // not returning a OGRFeature const& because OGR is not const-correct CheckInvariants(); return *m_Feature; } inline OGRFeature & otb::ogr::Feature::ogr() { CheckInvariants(); return *m_Feature; } inline void otb::ogr::Feature::PrintSelf(std::ostream & os, itk::Indent indent) const { CheckInvariants(); UncheckedPrintSelf(os, indent); } inline void otb::ogr::Feature::CheckInvariants() const { assert(m_Feature && "OGRFeature can't be null"); } #endif // otbOGRFeatureWrapper_txx OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRFieldWrapper.h000066400000000000000000000156521301006202600263720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRFieldWrapper_h #define otbOGRFieldWrapper_h #include #include class OGRFieldDefn; class OGRFeature; #if defined(_MSC_VER) #pragma warning ( push ) #pragma warning ( disable: 4251 ) #include "ogr_core.h" // OGR enums #pragma warning ( pop ) #else #include "ogr_core.h" // OGR enums #endif #include "itkIndent.h" #include "OTBGdalAdaptersExport.h" namespace otb { namespace ogr { /*===========================================================================*/ /*===========================[ Field definition ]============================*/ /*===========================================================================*/ /**\ingroup gGeometry * \class FieldDefn * \brief Encapsulation of \c OGRFieldDefn: field definition. * \invariant m_Definition != 0 * \invariant \c m_Definition lifetime is of the responsibility of the owning \c * \c OGRFeatureDefn. * \sa OGRFieldDefn * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ class OTBGdalAdapters_EXPORT FieldDefn { public: FieldDefn(OGRFieldDefn& definition) : m_Definition(&definition){ } std::string GetName() const; //!< Field name accessor. OGRFieldType GetType() const; //!< Field type accessor. OGRFieldDefn & ogr() { return *m_Definition; } OGRFieldDefn & ogr() const { return *m_Definition; } private: /**Pointer to the actual definition. * \internal pointer in order to support assignments */ OGRFieldDefn * m_Definition; }; inline bool operator==(FieldDefn const& lhs, FieldDefn const& rhs) { return lhs.GetName() == rhs.GetName() && lhs.GetType() == rhs.GetType(); } OTBGdalAdapters_EXPORT std::ostream & operator<<(std::ostream & os, FieldDefn const& defn); /*===========================================================================*/ /*=================================[ Field ]=================================*/ /*===========================================================================*/ class Feature; /**\ingroup gGeometry * \class Field * \brief Encapsulation of \c OGRField * Instances of \c Field are expected to be built from an existing \c Feature * with which they'll share their owning \c OGRFeature. * * A \c Field instance works as a proxy. Copying a field will only have it share * the actual \c OGRField between several instances. In order to copy a field * value from another field, use \c Field::assign(). * * \invariant m_Feature shall be valid (i.e. not wrapping a null \c * OGRFeature). * \invariant m_index < m_Feature->GetFieldCount(). * \invariant m_Feature->GetFieldDefnRef(m_index) != 0. * \sa OGRField * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ class OTBGdalAdapters_EXPORT Field { public: /** * Constructor. * \param[in,out] feature \c Feature from which the field is. * \param[in] index Index of the field in the \c Feature. * \throw None */ Field(Feature & feature, int index); /// %Field definition accessor. FieldDefn const& GetDefinition() const { return m_Definition; } /// %Field type accessor. OGRFieldType GetType() const { return m_Definition.GetType(); } /// %Field name accessor. std::string GetName() const { return m_Definition.GetName(); } /// Tells whether the field value has been set. bool HasBeenSet() const; /// Unsets the value of the field. void Unset() const; /** * Value setter. * \param[in] value New value for the field. * \throw None * \pre \c value's kind must match the field's type. * \internal * This function automagically decodes the type of the parameter in order to * use the ad'hoc setter from \c OGRFeature. */ template void SetValue(T const& value); /** * Value getter. * \tparam T expected type for the stored value. * \throw None * \pre \c T must match the field's type. * \pre The field must have set. * \internal * This function automagically deduce the ad'hoc getter (from \c OGRFeature) * from \c T. */ template T GetValue() const; /** Prints self into stream. */ std::ostream & PrintSelf(std::ostream&os, itk::Indent indent) const; /** Copies a field. * As \c Field is a proxy type, this function is the only possible way to copy a field. * * First, the field must be defined with a definition, then it could be set * from another field value. * \code * Field srcField = srcFeature[42]; * Feature dstFeature(layerDefinition); * Field dst(dstFeature, 12); * dstField.Assign(srcField); * \endcode */ void Assign(Field const& f); /** Access to the raw underlying OGR data. * This function provides an abstraction leak in case deeper control on the * underlying \c OGRFeature is required. * \warning You must under no circonstance try to delete the \c OGRField * obtained this way. */ OGRField & ogr() const; /** \copydoc Field::ogr() const */ OGRField & ogr(); private: /**\name Unchecked definitions * All the definitions that follow do the real work. However, they are not the * exposed public functions. The design of this class follows the principle * behind the NVI (Non-Virtual Interface) pattern: * - The public functions are inlined and check invariants and preconditions, * - While the private functions do the work. */ //@{ bool UncheckedHasBeenSet() const; void UncheckedUnset() const; std::ostream & UncheckedPrintSelf(std::ostream&os, itk::Indent indent) const; void UncheckedAssign(Field const& f); //@} /** * Internal function to check class invariants. * If any invariant is broken, an assertion will be fired. * \internal * This function is defined inlined in order to be able to inhibit invariants * checking depending on the compilation mode (on \c NDEBUG preprocessor * define actually). */ void CheckInvariants() const; /// Definition of the field. FieldDefn m_Definition; /// Link to the actual \c OGRFeature in charge of the fields. boost::shared_ptr & m_Feature; /** Index of the field according to the feature definition. * \internal * All the fields decoding is at the wrong place (\c OGRFeature instead of * \c OGRField) => need for an index. */ int m_index; }; } } // end namespace otb::ogr #ifndef OTB_MANUAL_INSTANTIATION #include "otbOGRFieldWrapper.txx" #endif #endif // otbOGRFieldWrapper_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRFieldWrapper.txx000066400000000000000000000413741301006202600267660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRFieldWrapper_txx #define otbOGRFieldWrapper_txx /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbOGRFieldWrapper.h" #include "otbConfigure.h" #include #include #include #include #include #include #include #include // #include #include #include #include // #include "boost/type_traits/is_array.hpp" #include "boost/type_traits/is_contiguous.h" // from OTB actually #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "ogr_feature.h" // OGRFeature::*field_getters #pragma GCC diagnostic pop #else #include "ogr_feature.h" // OGRFeature::*field_getters #endif #include "cpl_string.h" // CSLCount #include "otbOGRHelpers.h" /*===========================================================================*/ /*================[ Associations C++ types -> OGR functions ]================*/ /*===========================================================================*/ namespace otb { namespace ogr { /**\ingroup gGeometry * \defgroup GeometryInternals Geometry Internals * \since OTB v 3.14.0 */ /**\ingroup GeometryInternals * Namespace used to host internal meta-prog definitions. * \since OTB v 3.14.0 */ namespace internal { // namespace internal namespace mpl = boost::mpl; /**\ingroup GeometryInternals * Associative map of C++ types to OGR field types (\c OGRFieldType). * \internal Relies on Boost.MPL * \since OTB v 3.14.0 * \todo \c OFTBinary, \c OFTDate, \c OFTTime and \c OFTDateTime are not managed * yet. */ typedef mpl::map < mpl::pair > , mpl::pair , mpl::int_ > , mpl::pair > , mpl::pair , mpl::int_ > , mpl::pair > , mpl::pair > , mpl::pair > , mpl::pair, mpl::int_ > #ifdef OTB_USE_GDAL_20 , mpl::pair > , mpl::pair, mpl::int_ > #endif // OFTBinary // OFTDate // OFTTime // OFTDateTime > FieldType_Map; /**\ingroup GeometryInternals * \class MemberGetterPtr * Type for hosting simple member-function pointers to field getters. * \tparam T type of field according to OGR API. * \tparam ptr_to_function member function pointer to a field getter from \c * OGRFeature. * \tparam FinalReturnType type of the field according to OTB wrappers (default * = T) * * \internal * This is a hack to pass a member function pointer as template-parameter. * \since OTB v 3.14.0 */ template < typename T , T ( OGRFeature::*ptr_to_function )(int) , typename FinalReturnType = T > class MemberGetterPtr { public: static FinalReturnType call(OGRFeature &f, int index) { return (f.*ptr_to_function)(index); } }; /**\ingroup GeometryInternals * \class StringListMemberGetterPtr * Type for hosting member-function pointers to string-list field getters. * \tparam FinalReturnType type of the field according to OTB wrappers (default * = T) * * \internal * This ITK_OVERRIDE is required because of the particular nature of the * char** type chosen by OGR API, plus the fact this is the only * const-correct getter... * \since OTB v 3.14.0 */ template < typename FinalReturnType = std::vector > class StringListMemberGetterPtr { public: static FinalReturnType call(OGRFeature &f, int index) { char ** sl = f.GetFieldAsStringList(index); FinalReturnType res(sl, sl+CSLCount(sl)); return res; } }; /**\ingroup GeometryInternals * \class MemberSetterPtr * Type for hosting simple member-function pointers to field setters. * \tparam T type of field according to OGR API. * \tparam ptr_to_function member function pointer to a field setter from \c * OGRFeature. * = T) * * \internal * This is a hack to pass a member function pointer as template-parameter. * \since OTB v 3.14.0 */ template < typename T , void ( OGRFeature::*ptr_to_function )(int, T value) , typename ActualParamType = T > class MemberSetterPtr { public: static void call(OGRFeature &f, int index, T const& value) { (f.*ptr_to_function)(index, value); } }; /**\ingroup GeometryInternals * \class MemberContainerGetterPtr * Type for hosting simple member-function pointers to list-field getters. * \tparam T type of field according to OGR API. * \tparam ptr_to_function member function pointer to a list-field getter from * \c OGRFeature. * \tparam FinalReturnType type of the list-field according to OTB wrappers * (default = std::vector) * * \internal * This is a hack to pass a member function pointer as template-parameter. * \since OTB v 3.14.0 */ template < typename T , T const* ( OGRFeature::*ptr_to_function )(int, int*) , typename FinalReturnType = std::vector > class MemberContainerGetterPtr { public: static FinalReturnType call(OGRFeature &f, int index) { int nb = 0; T const* raw_container = (f.*ptr_to_function)(index, &nb); const FinalReturnType res(raw_container+0, raw_container+nb); return res; } }; /*===========================================================================*/ /**\ingroup GeometryInternals * \class TagDispatchMemberContainerSetterPtr * \brief Dispatcher function for the Field Setter. * The container-field setters from OGR API have a C API. This dispatcher will * check whether the parameter container has a contiguous storage. If so it will * directly inject the address of the first element of the contiguous container * in the OGR C API. If not, the container will be converted into a container * with contiguous storage. * \since OTB v 3.14.0 */ template < typename T , void ( OGRFeature::*ptr_to_function )(int, int, T*) // not const-correct , typename ActualParamType = std::vector , bool Is_contiguous = boost::is_contiguous::value > class TagDispatchMemberContainerSetterPtr; /**\ingroup GeometryInternals */ template < typename T , void ( OGRFeature::*ptr_to_function )(int, int, T*) // not const-correct , typename ActualParamType > class TagDispatchMemberContainerSetterPtr { public: static void call(OGRFeature &f, int index, ActualParamType const& container) { const int nb = boost::size(container); (f.*ptr_to_function)(index, nb, const_cast (&container[0])); } }; /**\ingroup GeometryInternals */ template < typename T , void ( OGRFeature::*ptr_to_function )(int, int, T*) // not const-correct , typename ActualParamType > class TagDispatchMemberContainerSetterPtr { public: static void call(OGRFeature &f, int index, ActualParamType const& container) { const int nb = boost::size(container); std::vector v(boost::begin(container), boost::end(container)); (f.*ptr_to_function)(index, nb, &v[0]); } }; /**\ingroup GeometryInternals * \class StringListMemberSetterPtr * Type for hosting member-function pointers to string-list field setters. * \tparam ActualParamType type of the field according to OTB wrappers (default * = T) * * \internal * This ITK_OVERRIDE is required because of the particular nature of the * char** type chosen by OGR API. * \since OTB v 3.14.0 */ template < typename ActualParamType > class StringListMemberSetterPtr { public: static void call(OGRFeature &f, int index, ActualParamType const& container) { f.SetField(index, StringListConverter(container).to_ogr()); } }; /**\ingroup GeometryInternals * \class MemberContainerSetterPtr * Type for hosting simple member-function pointers to list-field setters. * \tparam T type of field according to OGR API. * \tparam ptr_to_function member function pointer to a list-field setter from * \c OGRFeature. * \tparam FinalReturnType type of the list-field according to OTB wrappers * (default = std::vector) * * \internal * This is a hack to pass a member function pointer as template-parameter. * \since OTB v 3.14.0 */ template < typename T , void ( OGRFeature::*ptr_to_function )(int, int, T*) // not const-correct , typename ActualParamType = std::vector > class MemberContainerSetterPtr { public: static void call(OGRFeature &f, int index, ActualParamType const& container) { TagDispatchMemberContainerSetterPtr< T ,ptr_to_function ,ActualParamType , boost::is_contiguous::value >::call(f, index, container); } }; /**\ingroup GeometryInternals * Associative map of OGR field types (\c OGRFieldType) to their associated * getters. * \internal Relies on Boost.MPL * \since OTB v 3.14.0 */ typedef mpl::map < mpl::pair, MemberGetterPtr > , mpl::pair, MemberContainerGetterPtr > , mpl::pair, MemberGetterPtr > , mpl::pair, MemberContainerGetterPtr > , mpl::pair, MemberGetterPtr > , mpl::pair, StringListMemberGetterPtr > > #ifdef OTB_USE_GDAL_20 , mpl::pair, MemberGetterPtr > , mpl::pair, MemberContainerGetterPtr > #endif > FieldGetters_Map; /**\ingroup GeometryInternals * Associative map of OGR field types (\c OGRFieldType) to their associated * setters. * \internal Relies on Boost.MPL * \since OTB v 3.14.0 */ typedef mpl::map < mpl::pair, MemberSetterPtr > , mpl::pair, MemberContainerSetterPtr > , mpl::pair, MemberSetterPtr > , mpl::pair, MemberContainerSetterPtr > , mpl::pair, MemberSetterPtr > , mpl::pair, StringListMemberSetterPtr > > #ifdef OTB_USE_GDAL_20 , mpl::pair, MemberSetterPtr > , mpl::pair, MemberContainerSetterPtr > #endif > FieldSetters_Map; /**\ingroup GeometryInternals * \class CppToOGRConverter_trait * \brief Trait class for converting C++ types into OGR field setter compatible types. * \tparam T initial C++ type * \return C compatible type for OGR API. * \note C static arrays become pointers (in order to support literal strings) * \note C++ \c std::string becomes char const* * \since OTB v 3.14.0 */ template struct CppToOGRConverter_trait { typedef T type; static T const& convert(T const& value) { return value; } }; /**\ingroup GeometryInternals * \brief Specialisation for C static arrays. */ template struct CppToOGRConverter_trait { typedef T* type; static T const* convert(const T value[N]) { return &value[0]; } }; /**\ingroup GeometryInternals * \brief Specialisation for C++ \c std::string. */ template <> struct CppToOGRConverter_trait { typedef char* type; static char const* convert(std::string const& value) { return value.c_str(); } }; } // namespace internal } } // end namespace otb::ogr /*===========================================================================*/ /*=======================[ otb::ogr::Field functions ]=======================*/ /*===========================================================================*/ inline void otb::ogr::Field::CheckInvariants() const { assert(m_Feature && "OGR Fields must be associated to a valid feature"); assert(m_index < m_Feature->GetFieldCount() && "Out-of-range index for a OGR field"); assert(m_Feature->GetFieldDefnRef(m_index) && "No definition available for the OGR field"); } template inline void otb::ogr::Field::SetValue(T const& value) { CheckInvariants(); typedef internal::CppToOGRConverter_trait Converter; typedef typename Converter::type InterfaceType; // uncomment the next line to debug the InterfaceType computed // boost::mpl::print::type> interface_type; (void) interface_type; BOOST_MPL_ASSERT_MSG(!boost::is_array::value, InterFaceType_Cant_Be_An_array, (T, InterfaceType)); typedef typename boost::mpl::at::type Kind; BOOST_MPL_ASSERT_MSG(!(boost::is_same::value), UNEXPECTED_KIND_TYPE, (T, InterfaceType, Kind)); //const int VALUE = Kind::value; assert(m_Definition.GetType() == Kind::value && "OGR field type mismatches the type of new field value"); typedef typename boost::mpl::at::type SetterType; // If you experience a static assertion failure in the line below, it means // the type of the parameter is not supported to set a field. BOOST_MPL_ASSERT_NOT((boost::is_same)); SetterType::call(*m_Feature, m_index, Converter::convert(value)); } template inline T otb::ogr::Field::GetValue() const { CheckInvariants(); assert(HasBeenSet() && "Cannot access the value of a field that hasn't been set"); typedef typename boost::mpl::at::type Kind; //const int VALUE = Kind::value; BOOST_STATIC_ASSERT(!(boost::is_same::value)); assert(m_Definition.GetType() == Kind::value && "OGR field type mismatches the type of requested field value"); typedef typename boost::mpl::at::type GetterType; // If you experience a static assertion failure in the line below, it means // the field cannot be extracted into the type requested. BOOST_STATIC_ASSERT(!(boost::is_same::value)); return GetterType::call(*m_Feature, m_index); } inline std::ostream & otb::ogr::Field::PrintSelf( std::ostream& os, itk::Indent indent) const { CheckInvariants(); return UncheckedPrintSelf(os, indent); } inline bool otb::ogr::Field::HasBeenSet() const { CheckInvariants(); return UncheckedHasBeenSet(); } inline void otb::ogr::Field::Unset() const { CheckInvariants(); UncheckedUnset(); } inline void otb::ogr::Field::Assign(Field const& f) { CheckInvariants(); f.CheckInvariants(); assert(f.GetType() == this->GetType() && "Cannot assign from a field that doesn't have the same definition"); // We can't assume the following as sometimes field names are altered by the // datasource driver; for instance, shp driver truncates field names to 8 // characters. // assert(f.GetDefinition() == this->GetDefinition() && "Cannot assign from a field that doesn't have the same definition"); UncheckedAssign(f); CheckInvariants(); } inline OGRField & otb::ogr::Field::ogr() const { return const_cast (this)->ogr(); } inline OGRField & otb::ogr::Field::ogr() { CheckInvariants(); OGRField * f = m_Feature->GetRawFieldRef(m_index); assert(f && "The field obtained shall not be null"); return *f; } #endif // otbOGRFieldWrapper_txx OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRGeometriesVisitor.h000066400000000000000000000063071301006202600274660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRGeometriesVisitor_h #define otbOGRGeometriesVisitor_h #include #include #include #include #include "ogr_geometry.h" namespace otb { namespace ogr { /**\ingroup boost * \brief propagation of const-qualifier. * \note This type traits is likelly to appear in boost at some point in time. * \note As a consequence, it follows C++ standard and boost naming policy. * \since OTB v 3.14.0 * @{ */ template struct propagate_const { typedef Tout type; }; template struct propagate_const { typedef typename boost::add_const::type type; }; /** @} */ #define TRY_APPLY(TYPE, geometry, functor) \ if (typename propagate_const::type * dc_##TYPE \ = dynamic_cast::type*>(geometry))\ {\ return functor(dc_##TYPE); \ } /**\ingroup gGeometry * External polymorphic call of functions on \c OGRGeometry. * This helper function tries to polymorphically dispatch the call of a function * on the right \c OGRGeometry subtype. * \internal * In a perfect world, \c OGRGeometry would have provided a visitor to extend * the number of functions to polymorphically %apply on them. As this isn't the * case, \c apply executes many downcasts until it finds the right subtype. * * \tparam TResult type of the result * \tparam TGeometry matched an \c OGRGeometry that may or may not be const * qualified. * \tparam TFunctor functor to apply on the geometry. * \todo Support a list of types to check * \since OTB v 3.14.0 */ template TResult apply(TGeometry * geometry, TFunctor functor) { BOOST_MPL_ASSERT((boost::is_same::type >)); TRY_APPLY(OGRPoint, geometry, functor) else TRY_APPLY(OGRLinearRing, geometry, functor) else TRY_APPLY(OGRLineString, geometry, functor) // else TRY_APPLY(OGRCurve, geometry, functor) else TRY_APPLY(OGRPolygon, geometry, functor) // else TRY_APPLY(OGRSurface, geometry, functor) else TRY_APPLY(OGRMultiLineString, geometry, functor) else TRY_APPLY(OGRMultiPoint, geometry, functor) else TRY_APPLY(OGRMultiPolygon, geometry, functor) else TRY_APPLY(OGRGeometryCollection, geometry, functor) { // functor(geometry); } return TResult(); // keep compiler happy } } // ogr namespace } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION // #include "otbOGRGeometriesVisitor.txx" #endif #endif // otbOGRGeometriesVisitor_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRGeometryWrapper.h000066400000000000000000000153251301006202600271370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRGeometryWrapper_h #define otbOGRGeometryWrapper_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #else #include #endif #include "OTBGdalAdaptersExport.h" class OGRGeometry; namespace otb { namespace ogr { namespace internal { /**\ingroup GeometryInternals * Deleter dedicated to \c OGRGeometry. * \internal * Unlike OGR, works as a no-op on null geometries. * * Unlike the other deleters used, the type of this one needs to be known in the * header file in order to define the type \c UniqueGeometryPtr. As a * consequence, it is not in an anonymous namespace , but in \c * otb::ogr::internal. */ struct OTBGdalAdapters_EXPORT GeometryDeleter { void operator()(OGRGeometry* p); }; } // internal namespace // we don't encapsulate OGRGeometry, but please, don't create new geometries with a new. /**\ingroup gGeometry * \defgroup OGRGeometryWrapper OGRGeometry Wrappers * %Helper definition to handle \c OGRGeometry objects. * * \note %OTB doesn't provide anything on top of \c OGRGeometryFactory to create * new factories. Please, never create new \c OGRGeometry by hand with * new operator as there is no garanty they'll get destroyed within the * proper memory context when released from an owning \c OGRFeature. * * Thus, always use \c OGRGeometryFactory functions to create new geometries. * You can then manage their lifetime manually or rely on \c UniqueGeometryPtr * that provides a non-copyable, but movable RAII wrapper around \c OGRGeometry. * \since OTB v 3.14.0 * @{ */ /** * Smart-pointer over \c OGRGeometry, with \em move-semantics. * In a few words: * - When a function receives a \em unique_ptr<>, it implicitly assumes * responsibility of the received pointer. * - When a function returns a \em unique_ptr<>, the client code implicitly * assumes responsibility of the returned pointer. * - When exiting a scope, the pointer is destroyed. Which means, as long as we * keep using \em unique_ptr<> around functions calls, there is no need to * burden our mind with the lifetime of the encapsulated pointers. * - Moreover, we can specify how pointers are deleted; property that we * exploit to use the ad'hoc destruction function from OGR API, see \c * GeometryDeleter. * * \see http://www2.research.att.com/~bs/C++0xFAQ.html#rval about \em move-semantics. * \see http://www2.research.att.com/~bs/C++0xFAQ.html#std-unique_ptr about \c * std::unique_ptr<> * \see GOTW \#103, \#104 about \c unique_ptr<> as well: http://herbsutter.com/gotw/_103/ * * \note You may experiment difficulties to copy \c UniqueGeometryPtr. This is * likelly to be normal. You'll have to emulate \c std::move() with \c * boost::move() (with Boost v1.48+, or with \c boost::interprocess::move() * otherwise). Check for instance \c Feature::StealGeometry(), or \c * Feature::SetGeometryDirectly() to see examples. * * \internal * This should be defined on top of C++11 \c std::unique_ptr<>. By the mean * time, we are using an emulation provided in boost.interprocess. * \todo When CMake provides a way to detect C++11 features, use a \c #ifdef to * use the correct type. */ typedef boost::interprocess::unique_ptr UniqueGeometryPtr; ///Do these features intersect? OTBGdalAdapters_EXPORT bool Intersects (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Returns wheither if two geometries are equivalent. OTBGdalAdapters_EXPORT bool Equals (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Tests for disjointness. OTBGdalAdapters_EXPORT bool Disjoint (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Tests for touching. OTBGdalAdapters_EXPORT bool Touches (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Tests for crossing. OTBGdalAdapters_EXPORT bool Crosses (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Tests for containment. OTBGdalAdapters_EXPORT bool Within (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Tests for containment. OTBGdalAdapters_EXPORT bool Contains (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Tests for overlap. OTBGdalAdapters_EXPORT bool Overlaps (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Computes distance between two geometries. OTBGdalAdapters_EXPORT double Distance (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Computes intersection. OTBGdalAdapters_EXPORT UniqueGeometryPtr Intersection (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Computes union. OTBGdalAdapters_EXPORT UniqueGeometryPtr Union (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Computes union using cascading. OTBGdalAdapters_EXPORT UniqueGeometryPtr UnionCascaded (OGRGeometry const& this_); /// Computes difference. OTBGdalAdapters_EXPORT UniqueGeometryPtr Difference (OGRGeometry const& lhs, OGRGeometry const& rhs); /// Computes symmetric difference. OTBGdalAdapters_EXPORT UniqueGeometryPtr SymDifference (OGRGeometry const& lhs, OGRGeometry const& rhs); // -1.8 /** Simplifies Geometry. * This function tries to uses the best simplication algorithm available in the * current version of GDAL. Best in the sense of topology preservation. * i.e. With GDAL v1.8.0, \c OGRGeometry::Simplify() is used; with GDAL v1.9.0+, * \c OGRGeometry::SimplifyPreserveTopology() is used. * \pre Requires GDAL 1.8.0 * \sa \c OGRGeometry::Simplify() * \sa \c OGRGeometry::SimplifyPreserveTopology() */ OTBGdalAdapters_EXPORT UniqueGeometryPtr Simplify(OGRGeometry const& g, double tolerance); /** Simplifies Geometry with no guarantee of preserving the geometry. * \pre Requires GDAL 1.8.0 * \sa \c OGRGeometry::Simplify() */ OTBGdalAdapters_EXPORT UniqueGeometryPtr SimplifyDontPreserveTopology(OGRGeometry const& g, double tolerance); /** Simplifies Geometry while preserving topology. * \pre Requires GDAL 1.9.0 * \sa \c OGRGeometry::SimplifyPreserveTopology() */ OTBGdalAdapters_EXPORT UniqueGeometryPtr SimplifyPreserveTopology(OGRGeometry const& g, double tolerance); /** @} */ } } // end namespace otb::ogr #ifndef OTB_MANUAL_INSTANTIATION // #include "otbOGRGeometryWrapper.txx" #endif #endif // otbOGRGeometryWrapper_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRHelpers.h000066400000000000000000000060641301006202600254050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRHelpers_h #define otbOGRHelpers_h #include "itkMacro.h" #include #include #include #include #include #include #include #include #if ! defined(NDEBUG) #include "cpl_string.h" // CSLCount #endif #include "OTBGdalAdaptersExport.h" namespace otb { namespace ogr { /**\ingroup gGeometry * \class StringListConverter * \brief Helper class to convert a set of standard C++ string into char** as OGR API expects. *

Usage:

* \code * std::vector options; * options.push_back(....); * new otb::ogr::DataSource("name.shp", StringListConverter(options).to_ogr()); * \endcode * \since OTB v 3.14.0 * \todo Have \c DataSource constructor receive a * std::vector, or even more precide types. * \internal * This helper is implemented as a class (and in consequence as an object) in * order to ensure the temporary vector of char* survives the call of * \c to_ogr(). Even when used as suggested by the example above, the vector * survives till the ; at the end of the instruction. * * \ingroup OTBGdalAdapters */ struct OTBGdalAdapters_EXPORT StringListConverter { template /** * Init constructor. * \tparam ContainerType Any container matching C++ convention for * standard containers (have a \c value_type, \c begin(), \c end()). * \param[in] strings list of strings to convert * * \throw std::bad_alloc * Prepares \c m_raw with to contain a list of strings that can be seen as a * 0-terminated array of char*. */ explicit StringListConverter(ContainerType const& strings) { BOOST_MPL_ASSERT((boost::is_same)); m_raw.reserve(boost::size(strings)+1); for (typename ContainerType::const_iterator b = boost::begin(strings), e = boost::end(strings); b != e; ++b) { m_raw.push_back(b->c_str()); } m_raw.push_back(ITK_NULLPTR); assert(CSLCount(const_cast (&m_raw[0])) == static_cast(boost::size(strings))); } /** * Access to the OGR compliant list of strings. */ char ** to_ogr() const { return m_raw.size() == 1 ? ITK_NULLPTR : const_cast (&m_raw[0]); } private: std::vector m_raw; }; } // ogr namespace } // end namespace otb #endif // otbOGRHelpers_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRLayerWrapper.h000066400000000000000000000470451301006202600264240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRLayerWrapper_h #define otbOGRLayerWrapper_h // #include // std::ostream& #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include #include #include #pragma GCC diagnostic pop #else #include #include #include #endif // #include "itkIndent.h", included from field #include "otbOGRFeatureWrapper.h" #include "otbOGRVersionProxy.h" // #include "ogr_core.h" // OGRwkbGeometryType, included from feature -> field // Forward declarations class OGRLayer; class OGRGeometry; class OGRFeatureDefn; namespace otb { namespace ogr { class DataSource; class Layer; /**\ingroup gGeometry * Compares layers identities. * \return whether the two layers are in fact the same. */ OTBGdalAdapters_EXPORT bool operator==(Layer const& lhs, Layer const& rhs); /**\ingroup gGeometry * \class Layer * \brief %Layer of geometric objets. * * It provides an encapsulation of OGR classes. In that particular case, it's an * encapsulation of \c OGRLayer. * * \note This class is a proxy class on top of an \c OGRLayer. * \note It can be copied, and assigned. New instances will share the underlying * \c OGRLayer. * \note When created from a \c otb::ogr::DataSource::ExecuteSQL(), it will * automatically manage the release of the underlying \c OGRLayer. * \note The default constructor is disabled on purpose. * \note The destructor automatically generated does everything that is * expected. * * \todo Find a way to be notified when the related \c OGRDataSource is released * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ class OTBGdalAdapters_EXPORT Layer { public: /**\name ITK standard definitions */ //@{ typedef Layer Self; const char *GetNameOfClass() const {return "Layer"; } //@} #if 0 typedef itk::SmartPointer DataSourcePtr; #endif /**\name Construction */ //@{ /** * Init constructor with a layer owned by a DataSource. * \param layer \c OGRLayer instance that is owned by a DataSource. * \param datasource Pointer to the actual data source. * \throw None * On destruction of the proxy class, the internal \c OGRLayer is left alone. * * \warning If the datasource hosting the layer (built with this constructor) * is deleted, the layer won't be usable anymore. Unfortunately, there is no * mean to report this to this layer proxy. */ Layer(OGRLayer* layer, bool modifiable); /** * Init constructor for layers that need to be released. * \param layer \c OGRLayer owned by the client code. * \param sourceInChargeOfLifeTime reference to the actual \c GDALDataset * that knows how to release the layer. * \post In this case, \c m_datasource is left null: we suppose (for now, that * the layer won't need access to the datasource meta-information). * * \throw None * \internal * This constructor is meant to be used for wrapping layers coming from \c * OGRDataSource::ExecuteSQL(). It's actually the constructor called by \c * DataSource::ExecuteSQL(). */ Layer(OGRLayer* layer, otb::ogr::version_proxy::GDALDatasetType& sourceInChargeOfLifeTime, bool modifiable); //@} /**\name Features collection */ //@{ /** Returns the number of elements in the layer. * \param[in] doForceCompuation indicates whether the size shall be computed * even so it's expensive to do so. * * \return the number of features in the layer, -1 if count is unknown * \throw None * \sa \c OGRLayer::GetFeatureCount() */ int GetFeatureCount(bool doForceComputation) const; /** * Adds a pre-existing \c Feature to the layer. * \param[in,out] feature feature to add. Upon successful completion, the feature * id will be updated (unless it was previously set) * * \throw itk::ExceptionObject if the feature can't be added. * \sa \c OGRLayer::CreateFeature() * \internal * Whilst the \c Feature id is updated, it is not the same feature than the * one stored in the layer. In other words, \c Feature is still in charge of * the actual \c OGRFeature (in case it was), and the feature added is of the * responsibility of the layer. */ void CreateFeature(Feature feature); /** * Removes a feature identified by its id from the \c Layer. * \param[in] nFID feature id. * * \throw itk::ExceptionObject if the feature can't be added. * \warning Calls to this function will invalidate any feature iterator * previously obtained. * \sa \c OGRFeature::DeleteFeature() */ void DeleteFeature(long nFID); /** * Finds a feature from its id. * \param[in] nFID feature id. * * \return a RAII capsule around the \c OGRFeature stored in the layer and * that matches the requested id. * \throw itk::ExceptionObject if nFID is null * * \pre \c nFID value cannot be \c OGRNullFID * \post Result's \c GetFID() equals \c nFID * \warning Calls to this function will invalidate any feature iterator * previously obtained. * \sa \c OGRFeature::GetFeature() * \internal * The feature obtained is owned by the \c Feature instance. */ Feature GetFeature(long nFID); /** * Changes a \c Feature in the Layer. * \param[in,out] feature feature to set. Upon successful completion, the feature * id will be updated (in case it was previously set) * * \throw itk::ExceptionObject if the feature can't be set. * \pre The Layer needs to support OLCRandomWrite capability. * \sa \c OGRLayer::SetFeature() * \warning Calls to this function may invalidate any feature iterator * previously obtained depending on the actual \c OGRDriver. * \internal * Whilst the \c Feature id is updated, it is not the same feature than the * one stored in the layer. In other words, \c Feature is still in charge of * the actual \c OGRFeature (in case it was), and the feature added is of the * responsibility of the layer. */ void SetFeature(Feature feature); //@} /** Returns the name given to the layer, if any. */ std::string GetName() const; /** Retrieves the extent of the layer. * \param[in] force Force computation of the extent if not available. May * force the driver to walk all geometries to compute the extent. * \return the extent of the layer * \throw itk::ExceptionObject if the extent can not be retrieved. */ OGREnvelope GetExtent(bool force = false) const; /** Retrieves the extent of the layer. * \param[out] ulx reference to upper-left x coordinate of the extent * \param[out] uly reference to upper-left y coordinate of the extent * \param[out] lrx reference to lower-right x coordinate of the extent * \param[out] uly reference to lower-right y coordinate of the extent * \param[in] force Force computation of the extent if not available. May * force the driver to walk all geometries to compute the extent. * \throw itk::ExceptionObject if the extent can not be retrieved. */ void GetExtent(double & ulx, double & uly, double & lrx, double & lry, bool force = false) const; /** Prints self into stream. */ void PrintSelf(std::ostream& os, itk::Indent indent) const; /**\copydoc operator int boolean ::* () const */ struct boolean{ int i; }; /** Can the layer be used (ie not null). * * Hack to provide a boolean operator that is convertible only to a * boolean expression to be used in \c if tests. * @see Imperfect C++, Matthew Wilson, Addisson-Welsey, par 24.6 */ operator int boolean ::* () const { return m_Layer ? &boolean::i : ITK_NULLPTR; } /** Access to raw \c OGRLayer. * This function provides an abstraction leak in case deeper control on the * underlying \c OGRLayer is required. * \pre The underlying \c OGRLayer must be valid, i.e. * m_Layer != 0, an assertion is fired otherwise. * \warning You must under no circonstance try to delete the \c OGRLayer * obtained this way. */ OGRLayer & ogr(); /**\name Spatial filter property * \todo We'll see later if a Geometry capsule is defined, or a * \c nondeletable<> pointer type. * \internal * The I/O geometry is an undeletable pointer, that may be null (hence the * need of pointers instead of references). */ //@{ /** * Returns a reference to the current spatial filter, if any. * * \return a reference to the current spatial filter. Spatial filter that isn't * supposed to be modified this way. Use \c SetSpatialFilter or \c * SetSpatialFilterRect for this purpose. * \throw None * \sa \c OGRLayer::GetSpatialFilter() */ OGRGeometry const* GetSpatialFilter() const; /** * Sets the current spatial filter. * Replaces the current spatial filter with a clone of the one passed as * parameter. Thus the parameter remains of the responsibility of the caller. * * The spatial filter is used to filter the \c Feature's obtained when iterating * on the layer. * \param[in] spatialFilter new spatial filter definition, NULL clears the * filter. * \throw None * \note OGR warns us that the test may be incorrectly implemented, and that * we may have false-positives, but no missed shapes. * \sa \c OGRLayer::SetSpatialFilter() */ void SetSpatialFilter(OGRGeometry const* spatialFilter); /** Sets a new rectangular spatial filter. * Defines the new filter as a rectangular shape. * * The coordinates used shall be in the same referential as the layer as the * whole (as returned by \c GetSpatialRef()). * \sa \c OGRLayer::SetSpatialFilterRect() */ void SetSpatialFilterRect(double dfMinX, double dfMinY, double dfMaxX, double dfMaxY); //@} /** Spatial Reference property. * \note Read-only property. In order to set this property, you'll have to * create a new layer with a spatial reference. * \internal the I/O spatial reference is an undeletable pointer, that may be null. */ OGRSpatialReference const* GetSpatialRef() const; /** Returns the projection ref associated with the layer. * \return The projection ref (wkt string) associated with the layer */ std::string GetProjectionRef() const; /**\name Iteration */ //@{ /**\ingroup gGeometry * \class feature_iter * \brief Implementation class for \c Feature iterator. * This iterator is a single pass iterator. We may fetch the \c * Feature referenced by an iterator previously stored, but never resume the * iteration after a call to \c Layer::begin(), \c Layer::start_at(), \c * Layer::CreateFeature(), \c Layer::DeleteFeature(), \c Layer::GetFeature(), * \c Layer::SetFeature(), nor fork the iteration. * \code * iterator b = begin(); * iterator i = std::advance(b, 1); * b++; // this is invalid * \endcode * \internal * \sa \c otb::ogr::Layer::iterator * \sa \c otb::ogr::Layer::const_iterator * \note Naming policy is compliant with C++ standard as the iterator * functions are as well. This will permit transparent integration with all * standard and boost algorithms, and C++11 for-range loops for * instance. * \see http://www.boost.org/doc/libs/1_49_0/libs/iterator/doc/iterator_facade.html#tutorial-example * \since OTB v 3.14.0 * * \ingroup OTBGdalAdapters */ template class feature_iter : public boost::iterator_facade, Value, boost::single_pass_traversal_tag> { struct enabler {}; public: feature_iter() : m_Layer(ITK_NULLPTR), m_Crt(ITK_NULLPTR) {} explicit feature_iter(otb::ogr::Layer & layer) : m_Layer(&layer), m_Crt(layer.GetNextFeature()) {} template feature_iter( feature_iter const& other, typename boost::enable_if >::type* = ITK_NULLPTR ) : m_Layer(other.m_Layer), m_Crt(other.m_Crt) {} private: friend class boost::iterator_core_access; template friend class feature_iter; template bool equal(feature_iter const& other) const { return other.m_Crt == m_Crt; } void increment() { assert(m_Layer && "cannot increment end()"); m_Crt = m_Layer->GetNextFeature(); } Value & dereference() const { return m_Crt; } otb::ogr::Layer * m_Layer; otb::ogr::Feature mutable m_Crt; }; template friend class feature_iter; /// Features %iterator. typedef feature_iter iterator; /// Features const %iterator. typedef feature_iter const_iterator; /** Returns a single-pass %iterator to the start of the sequence. * \sa \c feature_iter */ const_iterator cbegin() const; /** Returns the %end %iterator of the sequence. */ const_iterator cend () const { return iterator(); } /**\copydoc cbegin */ const_iterator begin () const { return cbegin(); } /**\copydoc cend */ const_iterator end () const { return cend (); } /**\copydoc cbegin */ iterator begin (); /**\copydoc cend */ iterator end () { return iterator(); } /** Returns a single-pass %iterator to the i-th \c Feature of the * sequence. * \sa \c feature_iter * Depending of the actual driver (i.e. \c OGRDriver), this may be done in O(N). */ const_iterator cstart_at(GIntBig index) const; /** \copydoc cstart_at */ const_iterator start_at (GIntBig index) const { return cstart_at(index); } /** \copydoc cstart_at */ iterator start_at (GIntBig index); //@} /**\name Features definition * \todo Shall we instead inhibit the declaration of the functions when GDAL * version does not match? */ //@{ /** Returns a reference to the layer definition. * \warning The definition obtained shall not be modified. Use the \c *Field * functions instead. * \internal * The return type shall have been const, but unfortunately \c OGRFeatureDefn * is not const-correct. * \sa \c OGRLayer::GetLayerDefn() */ OGRFeatureDefn & GetLayerDefn() const; /** * Adds a new field given its definition. * \param[in] field field definition * \param[in] bApproxOK If true, the field may be created in a slightly * different form depending on the limitations of the format driver. * * \pre This function shall not be called while there are \c Feature in * existence that were obtained or created with the previous layer definition. * \throw itk::ExceptionObject if the new field cannot be created * \sa \c OGRLayer::CreateField() * \warning Calls to this function may invalidate any feature iterator * previously obtained depending on the actual \c OGRDriver. * \todo Move to use \c otb::ogr::FieldDefn */ void CreateField(FieldDefn const& field, bool bApproxOK = true); /** * Deletes a field. * \param[in] fieldIndex index of the field to remove. * * \pre This function shall not be called while there are \c Feature in * existence that were obtained or created with the previous layer definition. * \throw itk::ExceptionObject if the new field cannot be deleted * \sa \c OGRLayer::DeleteField() * \pre To be available, this function requires OTB to be compiled against OGR * v1.9.0 at least. */ void DeleteField(int fieldIndex); /** * Changes the definition of the i-th field. * \param[in] fieldIndex index of the field to change * \param[in,out] newFieldDefn definition of the new field. * \param[in] nFlags combination of \c ALTER_NAME_FLAG, \c ALTER_TYPE_FLAG * and \c ALTER_WIDTH_PRECISION_FLAG to indicate which of the name and/or type * and/or width and precision fields from the new field definition must be * taken into account. * * \pre This function shall not be called while there are \c Feature in * existence that were obtained or created with the previous layer definition. * \throw itk::ExceptionObject if the new field cannot be modified * \sa \c OGRLayer::AlterFieldDefn() * \pre To be available, this function requires OTB to be compiled against OGR * v1.9.0 at least. * \todo Move to use \c otb::ogr::FieldDefn */ void AlterFieldDefn(size_t fieldIndex, FieldDefn const& newFieldDefn, int nFlags); /** * Moves a field from one position to another. * \param[in] oldPos old field index position * \param[in] newPos new field index position * * \pre This function shall not be called while there are \c Feature in * existence that were obtained or created with the previous layer definition. * \throw itk::ExceptionObject if the new field cannot be modified * \sa \c OGRLayer::ReorderField() * \pre To be available, this function requires OTB to be compiled against OGR * v1.9.0 at least. */ void ReorderField(size_t oldPos, size_t newPos); /** * Reorder all the fields of the layer. * \param[in] map array that tells the new position of each field. * * \pre This function shall not be called while there are \c Feature in * existence that were obtained or created with the previous layer definition. * \throw itk::ExceptionObject if the new field cannot be modified * \sa \c OGRLayer::ReorderFields() * \pre To be available, this function requires OTB to be compiled against OGR * v1.9.0 at least. */ void ReorderFields(int *map); /** * Sets which fields can be omitted when retrieving features from the layer. * \param[in] fieldNames 0-terminated array of the field names to ignore when * fetching features from the layer. 0 to clear the list. * end * * Besides field names of the layers, the following special fields can be * passed: "OGR_GEOMETRY" to ignore geometry and "OGR_STYLE" to ignore layer * style. * * By default, no fields are ignored. * \throw itk::ExceptionObject if the new field cannot be modified * \sa \c OGRLayer::SetIgnoredFields() */ void SetIgnoredFields(char const** fieldNames); //@} /** Returns the type of the geometry stored. * \sa \c OGRLayer::GetGeomType() */ OGRwkbGeometryType GetGeomType() const; friend bool otb::ogr::operator==(Layer const& lhs, Layer const& rhs); private: /** * Internal encapsulation of \c OGRLayer::GetNextFeature(). * * \return the next \c OGRFeature of the layer, encapsulated in a \c Feature. * \throw None * \internal * Required to implement iterators without exposing/including \c OGRFeature * class definition. */ Feature GetNextFeature(); /** Data implementation. * \internal * The actual %layer implementation belongs to the \c otb::Layer object, * unless this is the result of \c ExecuteSQL(). In that case a deleter is set * to correctly release the layer. */ boost::shared_ptr m_Layer; bool m_Modifiable; #if 0 /** Related DataSource. * Needed to access OTB meta information. */ DataSourcePtr m_DataSource; #endif }; inline bool operator!=(Layer const& lhs, Layer const& rhs) { return ! (lhs == rhs); } } } // end namespace otb::ogr #ifndef OTB_MANUAL_INSTANTIATION // #include "otbLayerWrapper.txx" #endif #endif // otbOGRLayerWrapper_h OTB-release-5.8/Modules/Adapters/GdalAdapters/include/otbOGRVersionProxy.h000066400000000000000000000131371301006202600264710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRVersionProxy_h #define otbOGRVersionProxy_h #include #include #include "otbConfigure.h" #include "itkMacro.h" #ifdef OTB_USE_GDAL_20 class GDALDataset; class GDALDriver; #else class OGRDataSource; class OGRSFDriver; #endif #include "OTBGdalAdaptersExport.h" namespace otb { namespace ogr { namespace version_proxy { /** * This namespace holds proxy functions hiding interface changes in gdal 2.0 * * This namespace holds proxy functions hiding interface changes in OGR * dataset between gdal 1.x (x>10) and gdal 2.x. It defines a common * interface that should be used in place of calling directly the * wrapped gdal functions. * * Whenever GDALDataset and GDALDriver have to be used to open a * vector dataset (or OGRDataSource an OGRSFDriver for gdal 1.x), one * should use ogr::version_proxy types GDALDatasetType and * GDALDriverType. * * See function documentation for details. */ #ifdef OTB_USE_GDAL_20 typedef GDALDataset GDALDatasetType; typedef GDALDriver GDALDriverType; #else typedef OGRDataSource GDALDatasetType; typedef OGRSFDriver GDALDriverType; #endif /** * This function opens a file, possibly in read-only mode, and returns * a dataset. * * Calls OGRSFDriverRegistrar::Open for gdal 1.x implementation and GDALopenEx for * gdal 2.x implementation. * \param filename Filename of the file to open * \param readOnly: If true, dataset is open in read-only mode. * \return NULL if file could not be open. */ OTBGdalAdapters_EXPORT GDALDatasetType * Open(const char * filename, bool readOnly = true); /** * This function closes a dataset. * * Calls OGRDataSource::DestroyDataSource for gdal 1.x * implementation and GDALClose for gdal 2.x implementation. * * \param dataset Pointer to the dataset to close. Will not be * checked for null pointer. */ OTBGdalAdapters_EXPORT void Close(GDALDatasetType * dataset); /** * This function creates a new dataset. * * Calls OGRSFDriver::CreateDataSource for gdal 1.x implementation * and GDALDriver::Create with (0,0) raster size for gdal 2.x * implementation * * \param driver Pointer to the driver used for creation. Will not * be checked for null pointer. * * \param name Name of the dataset to create. * * \return NULL if dataset could not be created. */ OTBGdalAdapters_EXPORT GDALDatasetType * Create(GDALDriverType * driver, const char * name); /** * This function physically deletes an existing dataset. * * Calls OGRDataSource::DeleteDataSource for gdal 1.x implementation * and GDALDriver::Delete for gdal 2.x implementation. * * \param name Name of the dataset to destroy. */ OTBGdalAdapters_EXPORT bool Delete(const char * name); /** * This function returns a pointer to the driver from its name. * * Calls OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName() for * gdal 1.x implementation and * GetGDALDriverManager()->GetDriverByName() for gdal 2.x * implementation. * * \param name Name of the driver to retrieve * * \return NULL if no driver could be retrieved. */ OTBGdalAdapters_EXPORT GDALDriverType * GetDriverByName(const char * name); OTBGdalAdapters_EXPORT std::string GetDriverNameFromDataSource(const GDALDatasetType * ds); /** * Sync dataset to disk. * * Calls OGRDataSource::SyncToDisk() for gdal 1.x implementation and * GDALDataset::FlushCache() for gdal 2.x implementation. * * \param dataset Pointer to the dataset to sync. Will not be * checked for null pointer. * * \return True if sync went on without any error. */ OTBGdalAdapters_EXPORT bool SyncToDisk(GDALDatasetType * dataset); /** * \return The name of the dataset class behind the implementation * (OGRDataSource for gdal 1.x and GdalDataset for gdal 2.x) */ OTBGdalAdapters_EXPORT std::string GetDatasetClassName(); /** * \return The name of the driver class behind the implementation * (OGRSFDriver for gdal 1.x and GDALDriver for gdal 2.x) */ OTBGdalAdapters_EXPORT std::string GetDriverClassName(); /** * Return the list of files composing the dataset. * * Calls OGRDataSource::GetName() and wrap in string vector for gdal * 1.x implementation, and GDALDataset::GetFileList and wrap in * string vector for gdal 2.x implementation. * * \param dataset Pointer to the dataset to get the file list from. Will not be * checked for null pointer. * * \return A vector of string containing the list of files. */ OTBGdalAdapters_EXPORT std::vector GetFileListAsStringVector(GDALDatasetType * dataset); /** * Return the list of available drivers. * * Calls OGRSFDriverRegistrar::GetRegistrar() for gdal 1.x * implementation and GetGDALDriverManager() for gdal 2.x * implementation. * * \return A vector of string containing the list of available drivers. */ OTBGdalAdapters_EXPORT std::vector GetAvailableDriversAsStringVector(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Adapters/GdalAdapters/otb-module.cmake000066400000000000000000000003641301006202600242000ustar00rootroot00000000000000set(DOCUMENTATION "Adapters for the Gdal Library ( for reading and writing ).") otb_module(OTBGdalAdapters ENABLE_SHARED DEPENDS OTBBoostAdapters OTBBoost OTBCommon OTBGDAL OTBITK DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Adapters/GdalAdapters/src/000077500000000000000000000000001301006202600217135ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/GdalAdapters/src/CMakeLists.txt000066400000000000000000000012671301006202600244610ustar00rootroot00000000000000set(OTBGdalAdapters_SRC otbOGRFieldWrapper.cxx otbGeometriesSet.cxx otbOGRFeatureWrapper.cxx otbOGRLayerWrapper.cxx otbOGRGeometryWrapper.cxx otbGeometriesSource.cxx otbOGRDriversInit.cxx otbGeometriesToGeometriesFilter.cxx otbOGRDataSourceWrapper.cxx ) if(OTB_USE_GDAL_20) set(OTBGdalAdapters_SRC ${OTBGdalAdapters_SRC} otbOGRVersionProxy2x.cxx) else(Otb_use_gdal_20) set(OTBGdalAdapters_SRC ${OTBGdalAdapters_SRC} otbOGRVersionProxy1x.cxx) endif(OTB_USE_GDAL_20) add_library(OTBGdalAdapters ${OTBGdalAdapters_SRC}) target_link_libraries(OTBGdalAdapters ${OTBBoost_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBGDAL_LIBRARIES} ) otb_module_target(OTBGdalAdapters) OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbGeometriesSet.cxx000066400000000000000000000122631301006202600257270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesSet.h" #include /*===========================================================================*/ /*================================[ Helpers ]================================*/ /*===========================================================================*/ namespace otb { namespace ogr { namespace internal { /**\ingroup GeometryInternals * Access shim: itk smart-pointer to reference. * \param[in] ds itk smart pointer * \return a reference to the pointee. * \throw None * \pre ds != 0 * \since OTB v 3.14.0 */ template inline DataType & getRef(typename itk::SmartPointer const& ds) { assert(ds && "unexpected nil datasource"); return *ds; } /**\ingroup GeometryInternals * Access shim: const layer to reference. * \param[in] layer layer proxy * \return the layer proxy * \throw None * \since OTB v 3.14.0 */ inline otb::ogr::Layer const& getRef(otb::ogr::Layer const& layer) { return layer; } /**\ingroup GeometryInternals * Access shim: layer to reference. * \param[in] layer layer proxy * \return the layer proxy * \throw None * \since OTB v 3.14.0 */ inline otb::ogr::Layer & getRef(otb::ogr::Layer & layer) { return layer; } } } } // otb::ogr::internal namespaces /*===========================================================================*/ /*=======================[ Setting and construction ]========================*/ /*===========================================================================*/ otb::GeometriesSet::GeometriesSet() : m_GeometriesSet(otb::ogr::DataSource::New()) , m_ImageReference(*this) { } otb::GeometriesSet::GeometriesSet(ogr::DataSource::Pointer datasource) : m_GeometriesSet(datasource) , m_ImageReference(*this) { assert(datasource && "unexpected nil datasource"); } otb::GeometriesSet::GeometriesSet(ogr::Layer layer) : m_GeometriesSet(layer) , m_ImageReference(*this) { } /*static*/ otb::GeometriesSet::Pointer otb::GeometriesSet::New(ogr::DataSource::Pointer datasource) { Pointer res = new Self(datasource); res->UnRegister(); return res; } /*static*/ otb::GeometriesSet::Pointer otb::GeometriesSet::New(ogr::Layer layer) { Pointer res = new Self(layer); res->UnRegister(); return res; } /*virtual*/ otb::GeometriesSet::~GeometriesSet() { } void otb::GeometriesSet::Set(ogr::Layer layer) { assert(layer && "unexpected nil layer"); m_GeometriesSet = layer; } void otb::GeometriesSet::Set(ogr::DataSource::Pointer datasource) { assert(datasource && "unexpected nil datasource"); m_GeometriesSet = datasource; } /*===========================================================================*/ /*=================================[ IsSet ]=================================*/ /*===========================================================================*/ namespace otb { namespace ogr { namespace internal { /**\ingroup GeometryInternals * Visitor (functor) to test whether a geometries set is non-null. * \param[in] gs geometries set * \throw None * \since OTB v 3.14.0 */ struct IsSetTester : boost::static_visitor { template bool operator()(T const& gs) const { return getRef(gs); } }; } } } // otb::ogr::internal namespaces bool otb::GeometriesSet::IsSet() const { return this->apply(ogr::internal::IsSetTester()); } /*===========================================================================*/ /*===============================[ Printing ]================================*/ /*===========================================================================*/ namespace otb { namespace ogr { namespace internal { /**\ingroup GeometryInternals * Visitor (functor) to print a geometries set. * \param[in] gs geometries set * \throw None * \since OTB v 3.14.0 */ struct Printer : boost::static_visitor<> { Printer(std::ostream& os, itk::Indent indent) : m_os(os), m_indent(indent) {} void operator()(otb::ogr::Layer layer) const { assert(layer && "unexpected nil layer..."); layer.PrintSelf(m_os, m_indent); } void operator()(otb::ogr::DataSource::Pointer datasource) const { assert(datasource && "unexpected nil datasource..."); datasource->Print(m_os, m_indent); } private: std::ostream &m_os; itk::Indent m_indent; }; } } } // otb::ogr::internal namespaces void otb::GeometriesSet::PrintSelf(std::ostream& os, itk::Indent indent) const { this->apply(ogr::internal::Printer(os, indent)); } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbGeometriesSource.cxx000066400000000000000000000054631301006202600264400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesSource.h" #include "otbGeometriesSet.h" /*===========================================================================*/ /*==============================[ other stuff ]==============================*/ /*===========================================================================*/ otb::GeometriesSource::GeometriesSource() { Superclass::SetNumberOfRequiredOutputs(1); // The following line has for side effect to set of DataSource with the wrong // type as default value instead of a plain nil // smartpointer... => NO // Superclass::SetNthOutput(0, 0); // Moreover, the default, and correct, value will be set in DoAllocateOutputs if // nothing is set by then => nothing more to do. } /*virtual*/ otb::GeometriesSource::~GeometriesSource() { } /*virtual*/ otb::GeometriesSource::OutputGeometriesType* otb::GeometriesSource::GetOutput(void ) { return static_cast (Superclass::GetOutput(0)); } /*virtual*/ otb::GeometriesSource::OutputGeometriesType* otb::GeometriesSource::GetOutput(DataObjectPointerArraySizeType idx) { return static_cast (Superclass::GetOutput(idx)); } /*virtual*/ void otb::GeometriesSource::SetOutput(OutputGeometriesType* output, DataObjectPointerArraySizeType idx/* = 0 */) { Superclass::SetNthOutput(idx, output); } /*virtual*/ void otb::GeometriesSource::DoAllocateOutputs() { // The default behaviour is to prepare a in-memory OGR datasource in case // filters are piped. // In the filter is meant to produce a file, use SetOutput, or the New(string) // function to built the GeometriesSource and filters if (!GetOutput() || !GetOutput()->IsSet()) { GeometriesSet::Pointer gs = GeometriesSet::New(); // in-memory DataSource assert(gs); this->SetOutput(gs); ///\todo Check whether we need to increase the count of the \c GeometriesSet as ///it'll get reelased at the end of function the scope. } } /*virtual*/ void otb::GeometriesSource::PrepareOutputs() { DoAllocateOutputs(); Superclass::PrepareOutputs(); } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbGeometriesToGeometriesFilter.cxx000066400000000000000000000221761301006202600307540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesToGeometriesFilter.h" #include #include "otbGeometriesSet.h" #include "itkTimeProbe.h" #include "otbMacro.h" /*===========================================================================*/ /*============================[ ProcessVisitor ]=============================*/ /*===========================================================================*/ /**\ingroup GeometriesFilters * \class ProcessVisitor * Internal class used to dispatch filters on either \c ogr::DataSource, or \c * ogr::Layer. * As \c GeometriesSet is a variant that can contain either a \c ogr::DataSource * or a \c ogr::Layer, we need a way to dispatch filtering operations on the * right type. This is done thanks to \c ProcessVisitor. * \since OTB v 3.14.0 */ struct otb::internal::ProcessVisitor : boost::static_visitor<> { ProcessVisitor(otb::GeometriesToGeometriesFilter const& filter) : m_filter(filter) {} /** * Processes layers (\em by-copy). * \param[in] source source layer * \param[in,out] destination destination layer. * \throw WhatEver the filter throws. * * This is the \em leaf operation that forwards the call to the polymorphic * \c GeometriesToGeometriesFilter::DoProcessLayer() function. */ void operator()(otb::ogr::Layer const& source, otb::ogr::Layer & destination) const { m_filter.DoProcessLayer(source, destination); } /** * Processes data sources (\em by-copy). * \param[in] source source data source * \param[in,out] destination destination data source * \throw WhatEver the filter throws. * \throw itk::ExceptionObject if the construction of a new layer fails * * For each layer in the \c source, this operation: * - builds a new layer in the \c destination data source (according to the * choices made in the actual specialization of \c * GeometriesToGeometriesFilter regarding layer options, layer spatial * reference, geometries type, ...); * - defines new fileds in the new layer; * - and finally processes the layer thanks to the polymorphic \c * GeometriesToGeometriesFilter::DoProcessLayer() function. */ void operator()(otb::ogr::DataSource::Pointer source, otb::ogr::DataSource::Pointer destination) const { assert(source && "can't filter a nil datasource"); assert(destination && "can't filter to a nil datasource"); for (otb::ogr::DataSource::const_iterator b = source->begin(), e = source->end() ; b != e ; ++b ) { otb::ogr::Layer const& sourceLayer = *b; assert(sourceLayer && "unexpected nil source layer"); otb::ogr::Layer destLayer = destination->CreateLayer( sourceLayer.GetName(), m_filter.DoDefineNewLayerSpatialReference(sourceLayer), m_filter.DoDefineNewLayerGeometryType(sourceLayer), m_filter.DoDefineNewLayerOptions(sourceLayer) ); m_filter.DoDefineNewLayerFields(sourceLayer, destLayer); m_filter.DoProcessLayer(sourceLayer, destLayer); } } /** * Processes layers (\em in-place). * \param[in,out] inout layer to modify * \throw WhatEver the filter throws. * * This is the \em leaf operation that forwards the call to the polymorphic * \c GeometriesToGeometriesFilter::DoProcessLayer() function. */ void operator()(otb::ogr::Layer & inout) const { m_filter.DoProcessLayer(inout, inout); } /** * Processes data sources (\em in-place). * \param[in,out] inout data source to modify * \throw WhatEver the filter throws. * * This operation finally processes each layer of the \c source thanks to the * polymorphic \c GeometriesToGeometriesFilter::DoProcessLayer() function. */ void operator()(otb::ogr::DataSource::Pointer inout) const { assert(inout && "can't filter a nil datasource"); for (otb::ogr::DataSource::iterator b = inout->begin(), e = inout->end(); b != e; ++b) { otb::ogr::Layer layer = *b; assert(layer && "unexpected nil source layer"); m_filter.DoProcessLayer(layer, layer); } } /** * Fall-back visiting function for invalid mixed transformations (layer -> * datasource). * The only transformations accepted are * - layer -> layer, * - and data source -> data source. */ template void operator()(GT1 const&, GT2 &) const { assert(!"You shall not mix DataSources and Layers in GeometriesToGeometriesFilter"); itkGenericExceptionMacro(<<"You shall not mix DataSources and Layers in GeometriesToGeometriesFilter"); } private: otb::GeometriesToGeometriesFilter const& m_filter; }; /*===========================================================================*/ /*=====================[ GeometriesToGeometriesFilter ]======================*/ /*===========================================================================*/ otb::GeometriesToGeometriesFilter::GeometriesToGeometriesFilter() { } /*virtual*/ otb::GeometriesToGeometriesFilter::~GeometriesToGeometriesFilter() { } /*virtual*/ void otb::GeometriesToGeometriesFilter::SetInput( const InputGeometriesType * input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput( 0, const_cast(input)); } const otb::GeometriesToGeometriesFilter::InputGeometriesType * otb::GeometriesToGeometriesFilter::GetInput(void ) { return static_cast (Superclass::GetInput(0)); } /*virtual*/ void otb::GeometriesToGeometriesFilter::Process( InputGeometriesType const& source, OutputGeometriesType & destination) { // si layer, appelle virt process layer // si DS, loop et appelle virt process layer source.apply(internal::ProcessVisitor(*this), destination); } /*virtual*/ void otb::GeometriesToGeometriesFilter::Process( OutputGeometriesType & inout) { // si layer, appelle virt process layer // si DS, loop et appelle virt process layer inout.apply(internal::ProcessVisitor(*this)); } /*virtual*/ void otb::GeometriesToGeometriesFilter::GenerateData(void ) { this->DoAllocateOutputs(); this->DoFinalizeInitialization(); InputGeometriesType::ConstPointer input = this->GetInput(); // assert(input && "Cann't filter to a nil geometries set"); OutputGeometriesType::Pointer output = this->GetOutput(); assert(output && "Cann't filter a nil geometries set"); // Start recursive processing itk::TimeProbe chrono; chrono.Start(); if (input) { this->Process(*input, *output); } else { this->Process(*output); } chrono.Stop(); otbMsgDevMacro(<< "GeometriesToGeometriesFilter: geometries processed in " << chrono.GetMean() << " seconds."); } /*virtual*/ OGRSpatialReference* otb::GeometriesToGeometriesFilter::DoDefineNewLayerSpatialReference( ogr::Layer const& itkNotUsed(source)) const { return ITK_NULLPTR; } /*virtual*/ OGRwkbGeometryType otb::GeometriesToGeometriesFilter::DoDefineNewLayerGeometryType( ogr::Layer const& source) const { return source.GetGeomType(); } /*virtual*/ std::vector otb::GeometriesToGeometriesFilter::DoDefineNewLayerOptions( ogr::Layer const& itkNotUsed(source)) const { return std::vector(); } /*===========================================================================*/ /*========================[ FieldCopyTransformation ]========================*/ /*===========================================================================*/ void otb::FieldCopyTransformation::DefineFields( otb::ogr::Layer const& source, otb::ogr::Layer & dest) const { OGRFeatureDefn & inDefinition = source.GetLayerDefn(); OGRFeatureDefn & outDefinition = dest.GetLayerDefn(); for (int i=0,N=inDefinition.GetFieldCount(); i!=N; ++i) { dest.CreateField(*inDefinition.GetFieldDefn(i)); // assume the definition is updated automatically m_SourceToDestFieldIndicesMap[i] = outDefinition.GetFieldCount()-1; } } void otb::FieldCopyTransformation::fieldsTransform( otb::ogr::Feature const& inFeature, otb::ogr::Feature & outFeature) const { // default => copy all fields for copy transformation // The following can't be assumed because of Drivers like KML that always add // two fields: "Description" and "Name" //assert(inFeature.GetSize() == outFeature.GetSize()); for (int i=0,N=inFeature.GetSize(); i!=N; ++i) { int const indexNewField = m_SourceToDestFieldIndicesMap[i]; outFeature[indexNewField].Assign(inFeature[i]); } } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRDataSourceWrapper.cxx000066400000000000000000000530641301006202600271170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRDataSourceWrapper.h" // standard includes #include #include #include #include // toupper #include #include #include #include // ITK includes #include "itkMacro.h" // itkExceptionMacro #include "itkExceptionObject.h" #include "itksys/SystemTools.hxx" // OTB includes #include "otbOGRDriversInit.h" #include "otbSystem.h" // OGR includes /*===========================================================================*/ /*=======================[ construction/destruction ]========================*/ /*===========================================================================*/ bool otb::ogr::DataSource::Clear() { Reset(ITK_NULLPTR); return true; } void otb::ogr::DataSource::Reset(otb::ogr::version_proxy::GDALDatasetType * source) { if (m_DataSource) { // OGR makes a pointless check for non-nullity in // GDALDataset::DestroyDataSource (pointless because "delete 0" is // perfectly valid -> it's a no-op) ogr::version_proxy::Close(m_DataSource); // void, noexcept } m_DataSource = source; } namespace { // Anonymous namespace /**\ingroup GeometryInternals * \brief Type for associating filename extension with OGR driver names. * \since OTB v 3.14.0 */ struct ExtensionDriverAssociation { char const* extension; char const* driverName; bool Matches(std::string const& ext) const { return ext == extension; } }; /**\ingroup GeometryInternals * \brief Associative table of filename extension -> OGR driver names. * \since OTB v 3.14.0 */ const ExtensionDriverAssociation k_ExtensionDriverMap[] = { {".SHP", "ESRI Shapefile"}, {".TAB", "MapInfo File"}, {".GML", "GML"}, {".GMT", "OGR_GMT"}, {".GPX", "GPX"}, {".SQLITE", "SQLite"}, {".KML", "KML"}, }; /**\ingroup GeometryInternals * \brief Returns the OGR driver name associated to a filename. * \since OTB v 3.14.0 * \note Relies on the driver name associated to the filename extension in \c * k_ExtensionDriverMap. * \note As a special case, filenames starting with "PG:" are bound to * "PostgreSQL". */ char const* DeduceDriverName(std::string filename) { std::transform(filename.begin(), filename.end(), filename.begin(), (int (*)(int))toupper); if (0 == strncmp(filename.c_str(), "PG:", 3)) { return "PostgreSQL"; } const std::string extension = itksys::SystemTools::GetFilenameLastExtension(filename); ExtensionDriverAssociation const* whichIt = std::find_if( boost::begin(k_ExtensionDriverMap), boost::end(k_ExtensionDriverMap), boost::bind(&ExtensionDriverAssociation::Matches, _1, extension)); if (whichIt == boost::end(k_ExtensionDriverMap)) { return ITK_NULLPTR; // nothing found } return whichIt->driverName; } } // Anonymous namespace otb::ogr::DataSource::DataSource() : m_DataSource(ITK_NULLPTR), m_OpenMode(Modes::Update_LayerUpdate), m_FirstModifiableLayerID(0) { Drivers::Init(); ogr::version_proxy::GDALDriverType * d = ogr::version_proxy::GetDriverByName("Memory"); assert(d && "OGR Memory driver not found"); m_DataSource = ogr::version_proxy::Create(d,"in-memory"); if (!m_DataSource) { itkExceptionMacro(<< "Failed to create OGRMemDataSource: " << CPLGetLastErrorMsg()); } } otb::ogr::DataSource::DataSource(otb::ogr::version_proxy::GDALDatasetType * source, Modes::type mode) : m_DataSource(source), m_OpenMode(mode), m_FirstModifiableLayerID(0) { m_FirstModifiableLayerID = GetLayersCount(); } otb::ogr::DataSource::Pointer otb::ogr::DataSource::OpenDataSource(std::string const& datasourceName, Modes::type mode) { bool update = (mode != Modes::Read); ogr::version_proxy::GDALDatasetType * source = ogr::version_proxy::Open(datasourceName.c_str(),!update); if (!source) { // In read mode, this is a failure // In write mode (Overwrite and Update), create the data source transparently if (mode == Modes::Read) { itkGenericExceptionMacro(<< "Failed to open GDALDataset file " << datasourceName<<" : " << CPLGetLastErrorMsg()); } // Hand made factory based on file extension. char const* driverName = DeduceDriverName(datasourceName); if (!driverName) { itkGenericExceptionMacro(<< "No OGR driver known to OTB to create and handle a DataSource named <" <."); } ogr::version_proxy::GDALDriverType * d = ogr::version_proxy::GetDriverByName(driverName); if(!d) { itkGenericExceptionMacro(<<"Could not create OGR driver "< (driver name: <" << driverName<<">: " << CPLGetLastErrorMsg()); } } return otb::ogr::DataSource::New(source, mode); } void DeleteDataSource(std::string const& datasourceName) { bool ret = otb::ogr::version_proxy::Delete(datasourceName.c_str()); if (!ret) { itkGenericExceptionMacro(<< "Deletion of data source " << datasourceName << " failed: " << CPLGetLastErrorMsg()); } } otb::ogr::DataSource::Pointer otb::ogr::DataSource::New(std::string const& datasourceName, Modes::type mode) { if (mode < Modes::Read || mode >= Modes::MAX__) { itkGenericExceptionMacro(<< "Wrong mode when opening " << datasourceName); } Drivers::Init(); ogr::version_proxy::GDALDatasetType * ds = ogr::version_proxy::Open(datasourceName.c_str(),true); bool ds_exists = (ds!=ITK_NULLPTR); ogr::version_proxy::Close(ds); if (ds_exists && mode == Modes::Overwrite) { DeleteDataSource(datasourceName); } return OpenDataSource(datasourceName, mode); } /*static*/ otb::ogr::DataSource::Pointer otb::ogr::DataSource::New(otb::ogr::version_proxy::GDALDatasetType * source, Modes::type mode) { Pointer res = new DataSource(source, mode); res->UnRegister(); return res; } /*virtual*/ otb::ogr::DataSource::~DataSource() { Clear(); } /*===========================================================================*/ /*================================[ layers ]=================================*/ /*===========================================================================*/ otb::ogr::DataSource::const_iterator otb::ogr::DataSource::cbegin() const { return const_iterator(*this, 0); } otb::ogr::DataSource::const_iterator otb::ogr::DataSource::cend() const { return const_iterator(*this, GetLayersCount()); } otb::ogr::DataSource::iterator otb::ogr::DataSource::begin() { return iterator(*this, 0); } otb::ogr::DataSource::iterator otb::ogr::DataSource::end() { return iterator(*this, GetLayersCount()); } otb::ogr::Layer otb::ogr::DataSource::CreateLayer( std::string const& name, OGRSpatialReference * poSpatialRef/* = NULL */, OGRwkbGeometryType eGType/* = wkbUnknown */, std::vector const& papszOptions/* = NULL */) { assert(m_DataSource && "Datasource not initialized"); // In read mode, try to return an existing layer. // and throw if not found if (m_OpenMode == Modes::Read) { otb::ogr::Layer l = GetLayerChecked(name); // will throw if not existing itkGenericOutputMacro(<< "Requesting layer creation in read-only GDALDataset. Returning the existing layer"); return l; } // Other mode : Check if the layer already exists. otb::ogr::Layer layer = GetLayer(name); // won't throw on failure switch (m_OpenMode) { case Modes::Update_LayerOverwrite: { // First delete the layer if (layer) { DeleteLayer(GetLayerID(name)); } // Then create it OGRLayer * ol = m_DataSource->CreateLayer( name.c_str(), poSpatialRef, eGType, otb::ogr::StringListConverter(papszOptions).to_ogr()); if (!ol) { itkGenericExceptionMacro(<< "Failed to create the layer <"< in the GDALDataset file <" << GetDatasetDescription() <<">: " << CPLGetLastErrorMsg()); } const bool modifiable = true; return Layer(ol, modifiable); } break; case Modes::Overwrite: case Modes::Update_LayerUpdate: { if (layer) { return layer; } else { // Then create it OGRLayer * ol = m_DataSource->CreateLayer( name.c_str(), poSpatialRef, eGType, otb::ogr::StringListConverter(papszOptions).to_ogr()); if (!ol) { itkGenericExceptionMacro(<< "Failed to create the layer <"< in the GDALDataset file <" << GetDatasetDescription() <<">: " << CPLGetLastErrorMsg()); } const bool modifiable = true; return Layer(ol, modifiable); } } break; case Modes::Update_LayerCreateOnly: { // The layer exists. Returns it // It will be non-modifiable if already existing at GDALDataset creation time if (layer) { return layer; } // Case where the layer does not exists OGRLayer * ol = m_DataSource->CreateLayer( name.c_str(), poSpatialRef, eGType, otb::ogr::StringListConverter(papszOptions).to_ogr()); if (!ol) { itkGenericExceptionMacro(<< "Failed to create the layer <"< in the GDALDataset file <" << GetDatasetDescription() <<">: " << CPLGetLastErrorMsg()); } const bool modifiable = true; return Layer(ol, modifiable); } break; default : assert(false && "Should never be there"); itkGenericExceptionMacro(<< "GDALDataset opening mode not supported"); break; } itkGenericExceptionMacro(<< "GDALDataset opening mode not supported"); return Layer(ITK_NULLPTR, false); // keep compiler happy } otb::ogr::Layer otb::ogr::DataSource::CopyLayer( Layer & srcLayer, std::string const& newName, char ** papszOptions/* = NULL */) { assert(m_DataSource && "Datasource not initialized"); switch (m_OpenMode) { case Modes::Invalid: assert(false && "Invalid GDALDataset opening mode"); itkGenericExceptionMacro(<< "Invalid GDALDataset opening mode"); break; case Modes::Read: itkGenericExceptionMacro(<< "GDALDataset is opened in Read mode : cannot create a layer"); break; default: break; } OGRLayer * l0 = &srcLayer.ogr(); OGRLayer * ol = m_DataSource->CopyLayer(l0, newName.c_str(), papszOptions); if (!ol) { itkGenericExceptionMacro(<< "Failed to copy the layer <" << srcLayer.GetName() << "> into the new layer <" < in the GDALDataset file <" << GetDatasetDescription() <<">: " << CPLGetLastErrorMsg()); } const bool modifiable = true; Layer l(ol, modifiable); return l; } void otb::ogr::DataSource::DeleteLayer(size_t i) { assert(m_DataSource && "Datasource not initialized"); switch (m_OpenMode) { case Modes::Invalid: assert(false && "Invalid GDALDataset opening mode"); itkGenericExceptionMacro(<< "Invalid GDALDataset opening mode"); break; case Modes::Read: itkGenericExceptionMacro(<< "GDALDataset is opened in Read mode : cannot delete a layer"); break; case Modes::Update_LayerCreateOnly: itkGenericExceptionMacro(<< "GDALDataset is opened in Update_LayerCreateOnly mode : cannot delete a layer"); break; default: break; } const int nb_layers = GetLayersCount(); if (int(i) >= nb_layers) { itkExceptionMacro(<< "Cannot delete " << i << "th layer in the GDALDataset <" << GetDatasetDescription() << "> as it contains only " << nb_layers << "layers."); } const OGRErr err = m_DataSource->DeleteLayer(int(i)); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Cannot delete " << i << "th layer in the GDALDataset <" << GetDatasetDescription() << ">: " << CPLGetLastErrorMsg()); } } bool otb::ogr::DataSource::IsLayerModifiable(size_t i) const { assert(m_DataSource && "Datasource not initialized"); switch(m_OpenMode) { case Modes::Read: return false; case Modes::Update_LayerCreateOnly: return int(i) >= m_FirstModifiableLayerID; default: return true; } } bool otb::ogr::DataSource::IsLayerModifiable(std::string const& layername) const { assert(m_DataSource && "Datasource not initialized"); switch(m_OpenMode) { case Modes::Read: return false; case Modes::Update_LayerCreateOnly: { const int id = this->GetLayerIDUnchecked(layername); return id >= m_FirstModifiableLayerID; } default: return true; } } int otb::ogr::DataSource::GetLayerIDUnchecked(std::string const& name) const { assert(m_DataSource && "Datasource not initialized"); for (int i = 0, N = GetLayersCount(); i < N; i++) { OGRLayer * raw_layer = GetLayerUnchecked(i); // wrapping to give access to GetName() that doesn't exist with all version of gdal/ogr Layer layer(raw_layer, false); if (layer.GetName() == name) { return i; } } return -1; } size_t otb::ogr::DataSource::GetLayerID(std::string const& name) const { int const id = GetLayerIDUnchecked(name); if (id < 0) { itkExceptionMacro( << "Cannot fetch any layer named <" << name << "> in the GDALDataset <" << GetDatasetDescription() << ">: " << CPLGetLastErrorMsg()); } return 0; // keep compiler happy } otb::ogr::Layer otb::ogr::DataSource::GetLayerChecked(size_t i) { assert(m_DataSource && "Datasource not initialized"); const int nb_layers = GetLayersCount(); if (int(i) >= nb_layers) { itkExceptionMacro(<< "Cannot fetch " << i << "th layer in the GDALDataset <" << GetDatasetDescription() << "> as it contains only " << nb_layers << "layers."); } OGRLayer * layer_ptr = m_DataSource->GetLayer(int(i)); if (!layer_ptr) { itkExceptionMacro( << "Unexpected error: cannot fetch " << i << "th layer in the GDALDataset <" << GetDatasetDescription() << ">: " << CPLGetLastErrorMsg()); } return otb::ogr::Layer(layer_ptr, IsLayerModifiable(i)); } OGRLayer* otb::ogr::DataSource::GetLayerUnchecked(size_t i) { assert(m_DataSource && "Datasource not initialized"); OGRLayer * layer_ptr = m_DataSource->GetLayer(int(i)); return layer_ptr; } otb::ogr::Layer otb::ogr::DataSource::GetLayer(std::string const& name) { assert(m_DataSource && "Datasource not initialized"); OGRLayer * layer_ptr = m_DataSource->GetLayerByName(name.c_str()); return otb::ogr::Layer(layer_ptr, layer_ptr ? IsLayerModifiable(name) : false); } otb::ogr::Layer otb::ogr::DataSource::GetLayerChecked(std::string const& name) { assert(m_DataSource && "Datasource not initialized"); OGRLayer * layer_ptr = m_DataSource->GetLayerByName(name.c_str()); if (!layer_ptr) { itkExceptionMacro( << "Cannot fetch any layer named <" << name << "> in the GDALDataset <" << GetDatasetDescription() << ">: " << CPLGetLastErrorMsg()); } return otb::ogr::Layer(layer_ptr, IsLayerModifiable(name)); } int otb::ogr::DataSource::GetLayersCount() const { assert(m_DataSource && "Datasource not initialized"); return m_DataSource->GetLayerCount(); } otb::ogr::Layer otb::ogr::DataSource::ExecuteSQL( std::string const& statement, OGRGeometry * poSpatialFilter, char const* pszDialect) { assert(m_DataSource && "Datasource not initialized"); const bool modifiable = false; OGRLayer * layer_ptr = m_DataSource->ExecuteSQL( statement.c_str(), poSpatialFilter, pszDialect); if (!layer_ptr) { #if defined(PREFER_EXCEPTION) itkExceptionMacro( << "Unexpected error: cannot execute the SQL request <" << statement << "> in the GDALDataset <" << GetDatasetDescription() << ">: " << CPLGetLastErrorMsg()); #else // Cannot use the deleter made for result sets obtained from // GDALDataset::ExecuteSQL because it checks for non-nullity.... // *sigh* return otb::ogr::Layer(ITK_NULLPTR, modifiable); #endif } return otb::ogr::Layer(layer_ptr, *m_DataSource, modifiable); } /*===========================================================================*/ /*===============================[ features ]================================*/ /*===========================================================================*/ namespace { // Anonymous namespace /**\ingroup GeometryInternals * \brief %Functor used to accumulate the sizes of the layers in a \c DataSource. * \since OTB v 3.14.0 */ struct AccuLayersSizes { AccuLayersSizes(bool doForceComputation) : m_doForceComputation(doForceComputation) { } int operator()(int accumulated, otb::ogr::Layer const& layer) const { const int loc_size = layer.GetFeatureCount(m_doForceComputation); return loc_size < 0 ? loc_size : loc_size+accumulated; } private: bool m_doForceComputation; }; } // Anonymous namespace int otb::ogr::DataSource::Size(bool doForceComputation) const { return std::accumulate(begin(),end(), 0, AccuLayersSizes(doForceComputation)); } /*===========================================================================*/ /*=================================[ Misc ]==================================*/ /*===========================================================================*/ OGREnvelope otb::ogr::DataSource::GetGlobalExtent(bool force/* = false */, std::string *outwkt) const { assert(m_DataSource && "Datasource not initialized"); const_iterator lit = this->begin(); if(lit==this->end()) { itkGenericExceptionMacro(<< "Cannot compute global extent because there are no layers in the DataSource"); } const OGRSpatialReference * ref_srs = lit->GetSpatialRef(); OGREnvelope sExtent = lit->GetExtent(force); if (outwkt) { *outwkt = lit->GetProjectionRef(); } ++lit; for(; lit!=this->end(); ++lit) { OGREnvelope cExtent = lit->GetExtent(force); // may throw const OGRSpatialReference * current_srs = lit->GetSpatialRef(); // If both srs are valid and if they are different if(ref_srs && current_srs && current_srs->IsSame(ref_srs) == 0) { // Reproject cExtent in ref_srs // OGRCreateCoordinateTransformation is not const-correct OGRCoordinateTransformation * coordTransformation = OGRCreateCoordinateTransformation( const_cast(current_srs), const_cast(ref_srs)); coordTransformation->Transform(1,&cExtent.MinX,&cExtent.MinY); coordTransformation->Transform(1,&cExtent.MaxX,&cExtent.MaxY); const double real_minx = std::min(cExtent.MinX,cExtent.MaxX); const double real_miny = std::min(cExtent.MinY,cExtent.MaxY); const double real_maxx = std::max(cExtent.MinX,cExtent.MaxX); const double real_maxy = std::max(cExtent.MinY,cExtent.MaxY); cExtent.MinX = real_minx; cExtent.MinY = real_miny; cExtent.MaxX = real_maxx; cExtent.MaxY = real_maxy; #if GDAL_VERSION_NUM >= 1700 OGRCoordinateTransformation::DestroyCT(coordTransformation); #else #warning the following resource release may crash, please update your version of GDAL delete coordTransformation; // note there is no garanty #endif } // else: If srs are invalid, we assume that extent are coherent // Merge with previous layers' extent sExtent.Merge(cExtent); } // for each layer return sExtent; } std::string otb::ogr::DataSource::GetGlobalExtent(double & ulx, double & uly, double & lrx, double & lry, bool force) const { std::string outwkt; const OGREnvelope sExtent = GetGlobalExtent(force, &outwkt); ulx = sExtent.MinX; uly = sExtent.MinY; lrx = sExtent.MaxX; lry = sExtent.MaxY; return outwkt; } /*virtual*/ void otb::ogr::DataSource::PrintSelf( std::ostream& os, itk::Indent indent) const { assert(m_DataSource && "Datasource not initialized"); BOOST_FOREACH(Layer const& l, *this) { l.PrintSelf(os, indent); } } /*virtual*/ void otb::ogr::DataSource::Graft(const itk::DataObject * itkNotUsed(data)) { assert(! "Disabled to check if it makes sense..."); } bool otb::ogr::DataSource::HasCapability(std::string const& capabilityName) const { assert(m_DataSource && "Datasource not initialized"); return m_DataSource->TestCapability(capabilityName.c_str()); } void otb::ogr::DataSource::SyncToDisk() { assert(m_DataSource && "Datasource not initialized"); bool ret = otb::ogr::version_proxy::SyncToDisk(m_DataSource); if(!ret) { itkExceptionMacro( << "Cannot flush the pending of the OGRDataSource <" << GetDatasetDescription() << ">: " << CPLGetLastErrorMsg()); } } std::string otb::ogr::DataSource::GetDatasetDescription() const { std::vector files = otb::ogr::version_proxy::GetFileListAsStringVector(m_DataSource); std::string description = ""; for(std::vector::const_iterator it = files.begin();it!=files.end();++it) description+=(*it)+", "; return description; } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRDriversInit.cxx000066400000000000000000000015121301006202600257550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRDriversInit.h" #include "ogr_api.h" /*static*/ otb::ogr::Drivers & otb::ogr::Drivers::Init() { static Drivers theInstance; return theInstance; } otb::ogr::Drivers::Drivers() { OGRRegisterAll(); } otb::ogr::Drivers::~Drivers() { OGRCleanupAll(); } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRFeatureWrapper.cxx000066400000000000000000000155571301006202600264650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbOGRFeatureWrapper.h" #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "ogr_feature.h" #pragma GCC diagnostic pop #else #include "ogr_feature.h" #endif #include "cpl_error.h" #include "itkMacro.h" /*===========================================================================*/ /*======================[ Construction / Destruction ]=======================*/ /*===========================================================================*/ otb::ogr::Feature::Feature(OGRFeatureDefn & definition) : m_Feature( OGRFeature::CreateFeature(&definition), boost::bind(&OGRFeature::DestroyFeature, _1)) { CheckInvariants(); } otb::ogr::Feature::Feature(OGRFeature * feature) { if (feature) { m_Feature.reset(feature, boost::bind(&OGRFeature::DestroyFeature, _1)); } // else default is perfect -> delete null } otb::ogr::Feature::~Feature() { } otb::ogr::Feature otb::ogr::Feature::UncheckedClone() const { const Feature res(m_Feature->Clone()); return res; } void otb::ogr::Feature::UncheckedSetFrom(Feature const& rhs, bool mustForgive) { const OGRErr res = m_Feature->SetFrom(&rhs.ogr(), mustForgive); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<<"Cannot assign from another feature: " << CPLGetLastErrorMsg()); } } void otb::ogr::Feature::UncheckedSetFrom(Feature const& rhs, int * map, bool mustForgive) { #if GDAL_VERSION_NUM >= 1900 const OGRErr res = m_Feature->SetFrom(&rhs.ogr(), map, mustForgive); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<<"Cannot assign from another feature: " << CPLGetLastErrorMsg()); } #else itkGenericExceptionMacro("OGRLayer::SetFrom(feature, fieldmap, forgive) is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB.") #endif } /*===========================================================================*/ /*=================================[ Misc ]==================================*/ /*===========================================================================*/ void otb::ogr::Feature::UncheckedPrintSelf(std::ostream & os, itk::Indent indent) const { const int nbFields = m_Feature->GetFieldCount(); os << indent << "+"; os << " " << nbFields << " fields\n"; indent = indent.GetNextIndent(); for (int i=0; i!=nbFields; ++i) { assert(ogr().GetFieldDefnRef(i) && "No definition associated to the i-th field"); Field const& field = (*this)[i]; field.PrintSelf(os, indent); } } bool otb::ogr::operator==(otb::ogr::Feature const& lhs, otb::ogr::Feature const& rhs) { // special case: they may be null (end() mark) // OGR is not const correct ... OGRFeature * l = const_cast(lhs.m_Feature.get()); OGRFeature * r = const_cast(rhs.m_Feature.get()); return (l == r ) // incl. ==0 || (l && r && l->Equal(r)) // must be non-null to compare them with Equal ; } /*===========================================================================*/ /*================================[ Fields ]=================================*/ /*===========================================================================*/ int otb::ogr::Feature::GetSize() const { return ogr().GetFieldCount(); } otb::ogr::Field otb::ogr::Feature::UncheckedGetElement(int index) { Field field(*this, index); return field; } otb::ogr::Field otb::ogr::Feature::UncheckedGetElement(std::string const& name) { const int index = GetFieldIndex(name); return this->operator[](index); } otb::ogr::FieldDefn otb::ogr::Feature::UncheckedGetFieldDefn(int index) const { return FieldDefn(*m_Feature->GetFieldDefnRef(index)); } otb::ogr::FieldDefn otb::ogr::Feature::UncheckedGetFieldDefn(std::string const& name) const { const int index = GetFieldIndex(name); if (index < 0) { itkGenericExceptionMacro(<<"no field named <"<"); } return this->GetFieldDefn(index); } int otb::ogr::Feature ::UncheckedGetFieldIndex(std::string const& name) const { const int index = m_Feature->GetFieldIndex(name.c_str()); if (index < 0) { itkGenericExceptionMacro(<<"No field named <"< in feature"); } return index; } /*===========================================================================*/ /*==============================[ Properties ]===============================*/ /*===========================================================================*/ long otb::ogr::Feature::UncheckedGetFID() const { return m_Feature->GetFID(); } void otb::ogr::Feature::UncheckedSetFID(long fid) { const OGRErr res = m_Feature->SetFID(fid); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<<"Cannot Set FID to "<GetDefnRef(); } /*===========================================================================*/ /*==============================[ Geometries ]===============================*/ /*===========================================================================*/ void otb::ogr::Feature::UncheckedSetGeometryDirectly(UniqueGeometryPtr geometry) { OGRGeometry * g = geometry.get(); const OGRErr res = m_Feature->SetGeometryDirectly(g); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<<"Cannot set (directly) the geometry: " << CPLGetLastErrorMsg()); } geometry.release(); // success => commit the transaction (after any exception thrown) } otb::ogr::UniqueGeometryPtr otb::ogr::Feature::UncheckedStealGeometry() { OGRGeometry * g = m_Feature->StealGeometry(); return UniqueGeometryPtr(g); } void otb::ogr::Feature::UncheckedSetGeometry(OGRGeometry const* geometry) { // OGR copies the input geometry => should have been const const OGRErr res = m_Feature->SetGeometry(const_cast (geometry)); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<<"Cannot set the geometry: " << CPLGetLastErrorMsg()); } } OGRGeometry const* otb::ogr::Feature::UncheckedGetGeometry() const { return m_Feature->GetGeometryRef(); } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRFieldWrapper.cxx000066400000000000000000000131651301006202600261060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "ogr_feature.h" #pragma GCC diagnostic pop #elif defined(_MSC_VER) #pragma warning ( push ) #pragma warning ( disable: 4251 ) #include "ogr_feature.h" #pragma warning ( pop ) #else #include "ogr_feature.h" #endif #include "otbOGRFeatureWrapper.h" #include "otbJoinContainer.h" #include /*===========================================================================*/ /*===========================[ Static Assertions ]===========================*/ /*===========================================================================*/ namespace otb { namespace ogr { namespace internal { BOOST_STATIC_ASSERT(!(boost::is_same< MemberGetterPtr, MemberGetterPtr >::value )); BOOST_STATIC_ASSERT(!(boost::is_same< int, float >::value)); BOOST_STATIC_ASSERT(!(boost::is_same< mpl::int_::type, mpl::int_::type >::value )); BOOST_STATIC_ASSERT(!(boost::is_same< mpl::at, mpl::void_ >::value )); BOOST_STATIC_ASSERT(!(boost::is_same< mpl::at, mpl::int_ >::value )); BOOST_STATIC_ASSERT(!(boost::is_same< mpl::at::type, mpl::at::type >::value )); BOOST_STATIC_ASSERT(( mpl::at::type::value != mpl::at::type::value )); BOOST_STATIC_ASSERT(!(boost::is_same< mpl::at >, mpl::at > >::value )); BOOST_MPL_ASSERT((boost::is_array)); BOOST_MPL_ASSERT_NOT((boost::is_array >)); BOOST_MPL_ASSERT_NOT((boost::is_array >)); BOOST_STATIC_ASSERT((boost::is_contiguous::value)); BOOST_STATIC_ASSERT((boost::is_contiguous::value)); BOOST_STATIC_ASSERT((boost::is_contiguous >::value)); BOOST_STATIC_ASSERT((boost::is_contiguous >::value)); BOOST_MPL_ASSERT((boost::is_same::type >)); BOOST_MPL_ASSERT((boost::is_same::type >)); BOOST_MPL_ASSERT_NOT((boost::is_same)); } } } // end namespace otb::ogr /*===========================================================================*/ /*===============================[ FieldDefn ]===============================*/ /*===========================================================================*/ std::string otb::ogr::FieldDefn::GetName() const { assert(m_Definition && "No field definition wrapped"); return m_Definition->GetNameRef(); } OGRFieldType otb::ogr::FieldDefn::GetType() const { assert(m_Definition && "No field definition wrapped"); return m_Definition->GetType(); } std::ostream & otb::ogr::operator<<(std::ostream & os, otb::ogr::FieldDefn const& defn) { return os << defn.GetName() << " (" << OGRFieldDefn::GetFieldTypeName(defn.GetType()) << ")"; } /*===========================================================================*/ /*=================================[ Field ]=================================*/ /*===========================================================================*/ otb::ogr::Field::Field(otb::ogr::Feature & feature, int index) : m_Definition(*feature.ogr().GetFieldDefnRef(index)) , m_Feature(feature.sptr()) , m_index(index) { CheckInvariants(); } std::ostream & otb::ogr::Field::UncheckedPrintSelf( std::ostream& os, itk::Indent indent) const { //const itk::Indent one_indent = itk::Indent().GetNextIndent(); // os << indent << "|" << one_indent << "+ "; os << indent << this->GetName() << ": "; switch (this->GetType()) { case OFTInteger: os << this->GetValue(); break; case OFTIntegerList: os << '{'; otb::Join(os, this->GetValue >(), ", ") << '}'; break; case OFTReal : os << this->GetValue(); break; case OFTRealList: os << '{'; otb::Join(os, this->GetValue >(), ", ") << '}'; break; case OFTString : os << this->GetValue(); break; default: os << "??? -> " << this->GetType(); break; } os << " (" << OGRFieldDefn::GetFieldTypeName(this->GetType()) << ")"; os << "\n"; return os; } bool otb::ogr::Field::UncheckedHasBeenSet() const { return m_Feature->IsFieldSet(m_index); } void otb::ogr::Field::UncheckedUnset() const { m_Feature->UnsetField(m_index); } void otb::ogr::Field::UncheckedAssign(Field const& f) { if (f.HasBeenSet()) { OGRField & of = f.ogr(); m_Feature->SetField(m_index, &of); // OGR API copies *of } else // not sure OGR setField handle the case where new fields are unset { this->Unset(); } } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRGeometryWrapper.cxx000066400000000000000000000116361301006202600266570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbOGRGeometryWrapper.h" #include "ogr_geometry.h" #if GDAL_VERSION_NUM < 1900 # include "itkMacro.h" #endif #ifdef _MSC_VER // warning conversion int -> bool #pragma warning ( disable : 4800 ) #endif /*===========================================================================*/ /*================================[ Deleter ]================================*/ /*===========================================================================*/ void otb::ogr::internal::GeometryDeleter::operator()(OGRGeometry* p) { if (p) { // OGR refuses delete 0... OGRGeometryFactory::destroyGeometry (p); } } /*===========================================================================*/ /*======================[ Double dispatched functions ]======================*/ /*===========================================================================*/ bool otb::ogr::Intersects(OGRGeometry const& lhs, OGRGeometry const& rhs) { // OGRGeometry::Intersects is not const-correct ... return lhs.Intersects(const_cast (&rhs)); } bool otb::ogr::Equals(OGRGeometry const& lhs, OGRGeometry const& rhs) { // OGRGeometry::Equals is not const-correct ... return lhs.Equals(const_cast (&rhs)); } bool otb::ogr::Disjoint(OGRGeometry const& lhs, OGRGeometry const& rhs) { return lhs.Disjoint(&rhs); } bool otb::ogr::Touches(OGRGeometry const& lhs, OGRGeometry const& rhs) { return lhs.Touches(&rhs); } bool otb::ogr::Crosses(OGRGeometry const& lhs, OGRGeometry const& rhs) { return lhs.Crosses(&rhs); } bool otb::ogr::Within(OGRGeometry const& lhs, OGRGeometry const& rhs) { return lhs.Within(&rhs); } bool otb::ogr::Contains(OGRGeometry const& lhs, OGRGeometry const& rhs) { return lhs.Contains(&rhs); } bool otb::ogr::Overlaps(OGRGeometry const& lhs, OGRGeometry const& rhs) { return lhs.Overlaps(&rhs); } double otb::ogr::Distance(OGRGeometry const& lhs, OGRGeometry const& rhs) { return lhs.Distance(&rhs); } otb::ogr::UniqueGeometryPtr otb::ogr::Intersection(OGRGeometry const& lhs, OGRGeometry const& rhs) { return UniqueGeometryPtr(lhs.Intersection(&rhs)); } otb::ogr::UniqueGeometryPtr otb::ogr::Union(OGRGeometry const& lhs, OGRGeometry const& rhs) { return UniqueGeometryPtr(lhs.Union(&rhs)); } otb::ogr::UniqueGeometryPtr otb::ogr::UnionCascaded(OGRGeometry const& this_) { #if GDAL_VERSION_NUM >= 1800 return UniqueGeometryPtr(this_.UnionCascaded()); #else itkGenericExceptionMacro("OGRGeometry::UnionCascaded is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.8.0, and recompile OTB."); #endif } otb::ogr::UniqueGeometryPtr otb::ogr::Difference(OGRGeometry const& lhs, OGRGeometry const& rhs) { return UniqueGeometryPtr(lhs.Difference(&rhs)); } otb::ogr::UniqueGeometryPtr otb::ogr::SymDifference(OGRGeometry const& lhs, OGRGeometry const& rhs) { #if GDAL_VERSION_NUM >= 1800 return UniqueGeometryPtr(lhs.SymDifference(&rhs)); #else return UniqueGeometryPtr(lhs.SymmetricDifference(&rhs)); #endif } otb::ogr::UniqueGeometryPtr otb::ogr::SimplifyDontPreserveTopology(OGRGeometry const& g, double tolerance) { #if GDAL_VERSION_NUM >= 1800 return UniqueGeometryPtr(g.Simplify(tolerance)); #else itkGenericExceptionMacro("OGRGeometry::Simplify is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.8.0, and recompile OTB."); #endif } otb::ogr::UniqueGeometryPtr otb::ogr::SimplifyPreserveTopology(OGRGeometry const& g, double tolerance) { #if GDAL_VERSION_NUM >= 1900 return UniqueGeometryPtr(g.SimplifyPreserveTopology(tolerance)); #else itkGenericExceptionMacro("OGRGeometry::Simplify is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB."); #endif } otb::ogr::UniqueGeometryPtr otb::ogr::Simplify(OGRGeometry const& g, double tolerance) { #if GDAL_VERSION_NUM >= 1900 return UniqueGeometryPtr(g.SimplifyPreserveTopology(tolerance)); #elif GDAL_VERSION_NUM >= 1800 return UniqueGeometryPtr(g.Simplify(tolerance)); #else itkGenericExceptionMacro("OGRGeometry::Simplify(PreserveTopology) is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB."); #endif } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRLayerWrapper.cxx000066400000000000000000000327251301006202600261420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "gdal_priv.h"// GDALDataset #pragma GCC diagnostic pop #elif defined(_MSC_VER) #pragma warning ( push ) #pragma warning ( disable: 4251 ) #include "gdal_priv.h" // GDALDataset #pragma warning ( pop ) #else #include "gdal_priv.h" // GDALDataset #endif #include "otbOGRDataSourceWrapper.h" /*===========================================================================*/ /*======================[ Construction & Destruction ]=======================*/ /*===========================================================================*/ namespace { // Anonymous namespace /**\ingroup GeometryInternals * Deleter for \c boost::shared_ptr<> that doesn't delete. * This is required for \c OGRLayer s that belong to \c OGRDataSource. * \internal Unlike OGR, works as a no-op on null geometries. */ struct LeaveAloneDeleter { void operator()(OGRLayer*) const {} }; } // Anonymous namespace otb::ogr::Layer::Layer(OGRLayer* layer, bool modifiable) : m_Layer(layer, LeaveAloneDeleter()) , m_Modifiable(modifiable) #if 0 , m_DataSource(datasource) #endif { } otb::ogr::Layer::Layer(OGRLayer* layer, otb::ogr::version_proxy::GDALDatasetType& sourceInChargeOfLifeTime, bool modifiable) : m_Layer(layer, boost::bind(&otb::ogr::version_proxy::GDALDatasetType::ReleaseResultSet, boost::ref(sourceInChargeOfLifeTime), _1)) , m_Modifiable(modifiable) { assert(layer && "A null OGRlayer cannot belong to an OGRDataSource" ); // OGR always refuses "delete 0". *sigh* } /*===========================================================================*/ /*===============================[ Features ]================================*/ /*===========================================================================*/ int otb::ogr::Layer::GetFeatureCount(bool doForceComputation) const { assert(m_Layer && "Can't ask the features count on an invalid layer"); return m_Layer->GetFeatureCount(doForceComputation); } otb::ogr::Feature otb::ogr::Layer::GetNextFeature() { assert(m_Layer && "OGRLayer not initialized"); OGRFeature * f = m_Layer->GetNextFeature(); return f; } otb::ogr::Layer::iterator otb::ogr::Layer::begin() { assert(m_Layer && "OGRLayer not initialized"); m_Layer->ResetReading(); return iterator(*this); } otb::ogr::Layer::const_iterator otb::ogr::Layer::cbegin() const { assert(m_Layer && "OGRLayer not initialized"); m_Layer->ResetReading(); return const_iterator(*const_cast (this)); } otb::ogr::Layer::iterator otb::ogr::Layer::start_at(GIntBig index) { assert(m_Layer && "OGRLayer not initialized"); m_Layer->SetNextByIndex(index); return iterator(*this); } otb::ogr::Layer::const_iterator otb::ogr::Layer::cstart_at(GIntBig index) const { assert(m_Layer && "OGRLayer not initialized"); m_Layer->SetNextByIndex(index); return const_iterator(*const_cast (this)); } void otb::ogr::Layer::CreateFeature(Feature feature) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot create a new feature in the layer <" <: layer is not modifiable"); } const OGRErr res = m_Layer->CreateFeature(&feature.ogr()); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot create a new feature in the layer <" <: " << CPLGetLastErrorMsg()); } } void otb::ogr::Layer::DeleteFeature(long nFID) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot create a new feature in the layer <" <: layer is not modifiable"); } const OGRErr res = m_Layer->DeleteFeature(nFID); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot delete the feature <"< in the layer <" <: " << CPLGetLastErrorMsg()); } } otb::ogr::Feature otb::ogr::Layer::GetFeature(long nFID) { assert(m_Layer && "OGRLayer not initialized"); if (nFID == OGRNullFID) { itkGenericExceptionMacro(<< "Invalid feature null id GetFeature() in the layer <"<."); } const Feature feat = m_Layer->GetFeature(nFID); return feat; } void otb::ogr::Layer::SetFeature(Feature feature) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot create a new feature in the layer <" <: layer is not modifiable"); } const OGRErr res = m_Layer->SetFeature(&feature.ogr()); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot update a feature in the layer <" <: " << CPLGetLastErrorMsg()); } } /*===========================================================================*/ /*=================================[ Misc ]==================================*/ /*===========================================================================*/ std::string otb::ogr::Layer::GetName() const { assert(m_Layer && "null layer"); #if GDAL_VERSION_NUM >= 1800 return m_Layer->GetName(); #else return GetLayerDefn().GetName(); #endif } OGREnvelope otb::ogr::Layer::GetExtent(bool force/* = false */) const { assert(m_Layer && "OGRLayer not initialized"); OGREnvelope sExtent; const OGRErr res = m_Layer->GetExtent(&sExtent,force); if(res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot retrieve extent of layer <" <: " << CPLGetLastErrorMsg()); } return sExtent; } void otb::ogr::Layer::GetExtent(double& ulx, double& uly, double& lrx, double& lry, bool force) const { const OGREnvelope sExtent = GetExtent(force); ulx = sExtent.MinX; uly = sExtent.MinY; lrx = sExtent.MaxX; lry = sExtent.MaxY; } OGRLayer & otb::ogr::Layer::ogr() { assert(m_Layer && "OGRLayer not initialized"); return *m_Layer; } void otb::ogr::Layer::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "+"; if (m_Layer) // in case for odd reason the layer that should exist can't be found { os << "Layer <" << GetName() << "> of "<< OGRGeometryTypeToName(GetGeomType()) <<"\n"; indent = indent.GetNextIndent(); BOOST_FOREACH(Feature f, *this) { f.PrintSelf(os, indent); } } else { os << "null Layer\n"; } } /*===========================================================================*/ /*============================[ Spatial Filter ]=============================*/ /*===========================================================================*/ OGRGeometry const* otb::ogr::Layer::GetSpatialFilter() const { assert(m_Layer && "OGRLayer not initialized"); OGRGeometry* spatialFilter = m_Layer->GetSpatialFilter(); return spatialFilter; } void otb::ogr::Layer::SetSpatialFilter(OGRGeometry const* spatialFilter) { assert(m_Layer && "OGRLayer not initialized"); // const_cast because OGR is not 100% const-correct m_Layer->SetSpatialFilter(const_cast (spatialFilter)); } void otb::ogr::Layer::SetSpatialFilterRect( double dfMinX, double dfMinY, double dfMaxX, double dfMaxY) { assert(m_Layer && "OGRLayer not initialized"); m_Layer->SetSpatialFilterRect(dfMinX, dfMinY, dfMaxX, dfMaxY); } OGRSpatialReference const* otb::ogr::Layer::GetSpatialRef() const { assert(m_Layer && "OGRLayer not initialized"); return m_Layer->GetSpatialRef(); } std::string otb::ogr::Layer::GetProjectionRef() const { assert(m_Layer && "OGRLayer not initialized"); char * wkt = ITK_NULLPTR; OGRSpatialReference const* srs = GetSpatialRef(); if(srs) { const OGRErr res = srs->exportToWkt(&wkt); if(res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot convert spatial reference to wkt string for layer <" <: " << CPLGetLastErrorMsg()); } assert(wkt); const std::string stringWkt(wkt); // According to documentation, argument of exportToWkt() should be freed CPLFree(wkt); return stringWkt; } return ""; } /*===========================================================================*/ /*==========================[ Feature Definition ]===========================*/ /*===========================================================================*/ OGRFeatureDefn & otb::ogr::Layer::GetLayerDefn() const { assert(m_Layer && "OGRLayer not initialized"); return *const_cast (m_Layer.get())->GetLayerDefn(); } void otb::ogr::Layer::CreateField( FieldDefn const& field, bool bApproxOK/* = true */) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot create a new field in the layer <" <: layer is not modifiable"); } const OGRErr res = m_Layer->CreateField(&field.ogr(), bApproxOK); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot create a field in the layer <" <: " << CPLGetLastErrorMsg()); } } void otb::ogr::Layer::DeleteField(int fieldIndex) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot delete field in the layer <" <: layer is not modifiable"); } #if GDAL_VERSION_NUM < 1900 itkGenericExceptionMacro("OGRLayer::DeleteField is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB.") #else const OGRErr res = m_Layer->DeleteField(fieldIndex); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot delete the "<: " << CPLGetLastErrorMsg()); } #endif } void otb::ogr::Layer::AlterFieldDefn( size_t fieldIndex, FieldDefn const& newFieldDefn, int nFlags) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot alter field definition in the layer <" <: layer is not modifiable"); } #if GDAL_VERSION_NUM < 1900 itkGenericExceptionMacro("OGRLayer::AlterFieldDefn is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB.") #else const OGRErr res = m_Layer->AlterFieldDefn( int(fieldIndex), &newFieldDefn.ogr(), nFlags); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot alter the "<: " << CPLGetLastErrorMsg()); } #endif } void otb::ogr::Layer::ReorderField(size_t oldPos, size_t newPos) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot reorder fields in the layer <" <: layer is not modifiable"); } #if GDAL_VERSION_NUM < 1900 itkGenericExceptionMacro("OGRLayer::ReorderField is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB.") #else const OGRErr res = m_Layer->ReorderField(int(oldPos), int(newPos)); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot move the "<: " << CPLGetLastErrorMsg()); } #endif } void otb::ogr::Layer::ReorderFields(int * map) { assert(m_Layer && "OGRLayer not initialized"); if (!m_Modifiable) { itkGenericExceptionMacro(<< "Cannot reorder fields in the layer <" <: layer is not modifiable"); } #if GDAL_VERSION_NUM < 1900 itkGenericExceptionMacro("OGRLayer::ReorderField is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB.") #else const OGRErr res = m_Layer->ReorderFields(map); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot reorder the fields of the layer <" <: " << CPLGetLastErrorMsg()); } #endif } void otb::ogr::Layer::SetIgnoredFields(char const** fieldNames) { assert(m_Layer && "OGRLayer not initialized"); #if GDAL_VERSION_NUM >= 1900 const OGRErr res = m_Layer->SetIgnoredFields(fieldNames); if (res != OGRERR_NONE) { itkGenericExceptionMacro(<< "Cannot set fields to ignore on the layer <" <: " << CPLGetLastErrorMsg()); } #else itkGenericExceptionMacro("OGRLayer::SetIgnoredFields is not supported by OGR v" << GDAL_VERSION_NUM << ". Upgrade to a version >= 1.9.0, and recompile OTB.") #endif } OGRwkbGeometryType otb::ogr::Layer::GetGeomType() const { assert(m_Layer && "OGRLayer not initialized"); #if GDAL_VERSION_NUM < 1800 return GetLayerDefn().GetGeomType(); #else return m_Layer->GetGeomType(); #endif } bool otb::ogr::operator==(Layer const& lhs, Layer const& rhs) { const bool equal = lhs.m_Layer.get() == rhs.m_Layer.get(); return equal; } OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRVersionProxy1x.cxx000066400000000000000000000052551301006202600264630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRVersionProxy.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "ogrsf_frmts.h" #pragma GCC diagnostic pop #else #include "ogrsf_frmts.h" #endif namespace otb { namespace ogr { namespace version_proxy { GDALDatasetType * Open(const char * filename, bool readOnly) { return OGRSFDriverRegistrar::Open(filename,!readOnly); } void Close(GDALDatasetType * dataset) { OGRDataSource::DestroyDataSource(dataset); } GDALDatasetType * Create(GDALDriverType * driver, const char * name) { GDALDatasetType * ds = driver->CreateDataSource(name); if(ds) ds->SetDriver(driver); return ds; } bool Delete(const char * name) { // Open dataset GDALDatasetType * poDS = Open(name,false); GDALDriverType * poDriver = ITK_NULLPTR; if(poDS) { poDriver = poDS->GetDriver(); Close(poDS); } if(poDriver && poDriver->TestCapability(ODrCDeleteDataSource)) { OGRErr ret = poDriver->DeleteDataSource(name); return (ret == OGRERR_NONE); } return false; } GDALDriverType * GetDriverByName(const char * name) { return OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(name); } std::string GetDatasetClassName() { return std::string("OGRDataSource"); } std::string GetDriverClassName() { return std::string("OGRSFDriver"); } std::vector GetFileListAsStringVector(GDALDatasetType * dataset) { std::vector ret; ret.push_back(std::string(dataset->GetName())); return ret; } bool SyncToDisk(GDALDatasetType * dataset) { const OGRErr res= dataset->SyncToDisk(); return (res == OGRERR_NONE); } std::vector GetAvailableDriversAsStringVector() { std::vector ret; int nbDrivers = OGRSFDriverRegistrar::GetRegistrar()->GetDriverCount(); for(int i = 0; i < nbDrivers;++i) { ret.push_back(OGRSFDriverRegistrar::GetRegistrar()->GetDriver(i)->GetName()); } return ret; } std::string GetDriverNameFromDataSource(const GDALDatasetType * ds) { return std::string(const_cast(ds)->GetDriver()->GetName()); } } } } // end namespace OTB-release-5.8/Modules/Adapters/GdalAdapters/src/otbOGRVersionProxy2x.cxx000066400000000000000000000062001301006202600264530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRVersionProxy.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "gdal_priv.h" #pragma GCC diagnostic pop #else #include "gdal_priv.h" #endif namespace otb { namespace ogr { namespace version_proxy { GDALDatasetType * Open(const char * filename, bool readOnly) { return (GDALDatasetType *)GDALOpenEx(filename, (readOnly? GDAL_OF_READONLY : GDAL_OF_UPDATE) | GDAL_OF_VECTOR,NULL,NULL,NULL); } void Close(GDALDatasetType * dataset) { GDALClose(dataset); } GDALDatasetType * Create(GDALDriverType * driver, const char * name) { return driver->Create(name,0,0,0,GDT_Unknown,NULL); } bool Delete(const char * name) { // Open dataset GDALDatasetType * poDS = otb::ogr::version_proxy::Open(name,false); GDALDriverType * poDriver = NULL; if(poDS) { poDriver = poDS->GetDriver(); Close(poDS); } if(poDriver) { OGRErr ret = poDriver->Delete(name); return (ret == OGRERR_NONE); } return false; } GDALDriverType * GetDriverByName(const char * name) { return GetGDALDriverManager()->GetDriverByName(name); } std::string GetDatasetClassName() { return std::string("GDALDataset"); } std::string GetDriverClassName() { return std::string("GDALDriver"); } namespace raii { // This class is used in the next function, so as to prevent any // resource leak on char ** returned by dataset->GetFileList() class CharPPCapsule { public: CharPPCapsule(char ** in) : m_P(in) {} const char ** P() const { return const_cast(m_P); } ~CharPPCapsule() { if(m_P) CSLDestroy(m_P); } private: char ** m_P; }; } std::vector GetFileListAsStringVector(GDALDatasetType * dataset) { std::vector ret; raii::CharPPCapsule capsule(dataset->GetFileList()); std::string files_str=""; if(capsule.P()) { unsigned int i = 0; while(capsule.P()[i]!=NULL) { ret.push_back(std::string(capsule.P()[i])); ++i; } } return ret; } bool SyncToDisk(GDALDatasetType * dataset) { dataset->FlushCache(); return true; } std::vector GetAvailableDriversAsStringVector() { std::vector ret; int nbDrivers = GetGDALDriverManager()->GetDriverCount(); for(int i = 0; i < nbDrivers;++i) { ret.push_back(GDALGetDriverShortName(GetGDALDriverManager()->GetDriver(i))); } return ret; } std::string GetDriverNameFromDataSource(const GDALDatasetType * ds) { return std::string(const_cast(ds)->GetDriverName()); } } } } // end namespace OTB-release-5.8/Modules/Adapters/GdalAdapters/test/000077500000000000000000000000001301006202600221035ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/GdalAdapters/test/CMakeLists.txt000066400000000000000000000011771301006202600246510ustar00rootroot00000000000000otb_module_test() if (Boost_UNIT_TEST_FRAMEWORK_FOUND) add_executable(otbOGRTests otbOGRDataSourceWrapperNew.cxx) target_link_libraries( otbOGRTests ${OTBGdalAdapters-Test_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} ) add_test(NAME coTuOGRDataSourceWrapperNew COMMAND otbOGRTests coTuOGRDataSourceWrapperNew WORKING_DIRECTORY ${TEMP}) endif() add_executable(otbOGRTestsIO otbOGRDataSourceWrapperIO.cxx) target_link_libraries(otbOGRTestsIO ${OTBGdalAdapters-Test_LIBRARIES}) add_test(NAME coTuOGRDataSourceWrapperIO COMMAND otbOGRTestsIO ${INPUTDATA}/ToulousePoints-examples.shp ) OTB-release-5.8/Modules/Adapters/GdalAdapters/test/otbOGRDataSourceWrapperIO.cxx000066400000000000000000000032721301006202600275330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbOGRDataSourceWrapper.h" #include // EXIT_FAILURE #include using namespace otb; /*===========================================================================*/ /*==============================[ other stuff ]==============================*/ /*===========================================================================*/ // int otbOGRDataSourceNew (int argc, char **argv) int main(int argc, char **argv) { if (argc < 2) { std::cerr << "otbOGRDataSourceNew \n"; return EXIT_FAILURE; } ogr::DataSource::Pointer ds = ogr::DataSource::New(argv[1]); std::cout << "file:\t" << argv[1] << std::endl; std::cout << "nb layers:\t" << ds->GetLayersCount() << std::endl; std::cout << "nb features(0):\t" << ds->Size(false) << std::endl; std::cout << "nb features(1):\t" << ds->Size(true) << std::endl; ds->Print(std::cout); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/GdalAdapters/test/otbOGRDataSourceWrapperNew.cxx000066400000000000000000000662451301006202600277660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #define BOOST_TEST_MODULE "otb::org::DataSource creation unit testing" #define BOOST_TEST_DYN_LINK #include #include #include "otb_boost_string_header.h" #include "itksys/SystemTools.hxx" #include "otbOGRDataSourceWrapper.h" using namespace otb; /**\ingroup gGeometry * \file otbOGRDataSourceWrapperNew.cxx * *\todo Test: CopyLayer from one datasource to another *\todo Test: read datasource *\todo Test: write datasource */ /*===========================================================================*/ /*===============================[ Constants ]===============================*/ /*===========================================================================*/ const std::string k_one = "one"; const std::string k_two = "two"; /*const*/ OGRFieldDefn k_f0_("OFTInteger", OFTInteger); /*const*/ OGRFieldDefn k_f1_("OFTReal", OFTReal); /*const*/ OGRFieldDefn k_f2_("OFTString", OFTString); /*const*/ OGRFieldDefn k_f3_("OFTIntegerList", OFTIntegerList); /*const*/ OGRFieldDefn k_f4_("OFTRealList", OFTRealList); /*const*/ OGRFieldDefn k_f5_("OFTStringList", OFTStringList); ogr::FieldDefn k_f0(k_f0_); ogr::FieldDefn k_f1(k_f1_); ogr::FieldDefn k_f2(k_f2_); ogr::FieldDefn k_f3(k_f3_); ogr::FieldDefn k_f4(k_f4_); ogr::FieldDefn k_f5(k_f5_); /*===========================================================================*/ /*==================================[ UTs ]==================================*/ /*===========================================================================*/ BOOST_AUTO_TEST_CASE(OGRDataSource_new_empty) { ogr::DataSource::Pointer ds = ogr::DataSource::New(); BOOST_ASSERT(ds); BOOST_CHECK_EQUAL(ds->GetLayersCount(), 0); BOOST_CHECK_EQUAL(ds->Size(false), 0); BOOST_CHECK_EQUAL(ds->Size(true), 0); BOOST_CHECK_THROW(ds->GetLayerChecked(0), itk::ExceptionObject); } BOOST_AUTO_TEST_CASE(OGRDataSource_mem_add_n_del_layer) { ogr::DataSource::Pointer ds = ogr::DataSource::New(); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(k_one); BOOST_CHECK_EQUAL(ds->GetLayersCount(), 1); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 0); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 0); ogr::Layer l0 = ds->GetLayerChecked(0); BOOST_CHECK_THROW(ds->GetLayerChecked(1), itk::ExceptionObject); BOOST_CHECK_EQUAL(l.GetName(), k_one); BOOST_CHECK_EQUAL(l0.GetName(), k_one); BOOST_CHECK_EQUAL(l0.GetName(), k_one); BOOST_CHECK_EQUAL(ds->GetLayer(k_one).GetName(), k_one); BOOST_CHECK_EQUAL(ds->GetLayerChecked(k_one).GetName(), k_one); BOOST_ASSERT(! ds->GetLayer(k_two)); BOOST_CHECK_THROW(ds->GetLayerChecked(k_two), itk::ExceptionObject); ogr::Layer l2 = ds -> CreateLayer(k_two); BOOST_CHECK_EQUAL(ds->GetLayersCount(), 2); BOOST_CHECK_EQUAL(ds->Size(false), 0); BOOST_CHECK_EQUAL(ds->Size(true), 0); BOOST_CHECK_EQUAL(ds->GetLayer(0).GetName(), k_one); BOOST_CHECK_EQUAL(ds->GetLayer(1).GetName(), k_two); BOOST_CHECK_EQUAL(ds->GetLayer(k_two).GetName(), k_two); BOOST_CHECK_THROW(ds->GetLayerChecked(2), itk::ExceptionObject); ds->DeleteLayer(0); BOOST_CHECK_EQUAL(ds->GetLayersCount(), 1); BOOST_CHECK_EQUAL(ds->GetLayer(0).GetName(), k_two); BOOST_CHECK_THROW(ds->GetLayerChecked(1), itk::ExceptionObject); BOOST_CHECK_EQUAL(ds->Size(false), 0); BOOST_CHECK_EQUAL(ds->Size(true), 0); } BOOST_AUTO_TEST_CASE(OGRDataSource_new_exceptions) { BOOST_CHECK_THROW(ogr::DataSource::New("name-that-shall-not-exist.shp", ogr::DataSource::Modes::Read), itk::ExceptionObject); BOOST_CHECK_THROW(ogr::DataSource::New("unsupported.extension", ogr::DataSource::Modes::Overwrite), itk::ExceptionObject); } BOOST_AUTO_TEST_CASE(OGRDataSource_new_shp) { if (boost::unit_test::framework::master_test_suite().argc < 2) { BOOST_THROW_EXCEPTION( std::runtime_error("not enough arguments") ); } const std::string k_shp = boost::unit_test::framework::master_test_suite().argv[1]; const std::string k_one_ = k_shp; ogr::DataSource::Pointer ds = ogr::DataSource::New(k_shp+".shp", ogr::DataSource::Modes::Overwrite); BOOST_CHECK_EQUAL(ds->GetLayersCount(), 0); ogr::Layer l = ds -> CreateLayer(k_one_); BOOST_CHECK_EQUAL(ds->GetLayersCount(), 1); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 0); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 0); ogr::Layer l0 = ds->GetLayerChecked(0); BOOST_CHECK_THROW(ds->GetLayerChecked(1), itk::ExceptionObject); BOOST_CHECK_EQUAL(l.GetName(), k_one_); BOOST_CHECK_EQUAL(l0.GetName(), k_one_); BOOST_CHECK_EQUAL(l0.GetName(), k_one_); BOOST_CHECK_EQUAL(ds->GetLayer(k_one_).GetName(), k_one_); BOOST_CHECK_EQUAL(ds->GetLayerChecked(k_one_).GetName(), k_one_); BOOST_ASSERT(! ds->GetLayer(k_two)); BOOST_CHECK_THROW(ds->GetLayerChecked(k_two), itk::ExceptionObject); // no multi layer as it will create other shape files, with the name of the // layer as the name of the shape file, whilst the name of the first layer is // forced to be the name of the datasource... // BOOST_CHECK_THROW(ds -> CreateLayer(k_two), itk::ExceptionObject); // BOOST_CHECK_EQUAL(ds->GetLayersCount(), 1); } BOOST_AUTO_TEST_CASE(OGRDataSource_shp_overwrite) { if (boost::unit_test::framework::master_test_suite().argc < 2) { BOOST_THROW_EXCEPTION( std::runtime_error("not enough arguments") ); } const std::string k_name = boost::unit_test::framework::master_test_suite().argv[1]; const std::string workingdir = k_name + "/shp"; // Create an empty temporary directory for the test if ( itksys::SystemTools::FileExists(workingdir.c_str()) ) { itksys::SystemTools::RemoveADirectory(workingdir.c_str()); } itksys::SystemTools::MakeDirectory(workingdir.c_str()); std::string filename = workingdir + "/" + k_name + ".shp"; filename = itksys::SystemTools::ConvertToOutputPath(filename.c_str()); const std::string layer1 = k_name; // Cannot create read data source if file does not exists BOOST_CHECK_THROW(ogr::DataSource::New(filename, ogr::DataSource::Modes::Read), itk::ExceptionObject); // Check invalid modes BOOST_CHECK_THROW(ogr::DataSource::New(filename, ogr::DataSource::Modes::Invalid), itk::ExceptionObject); BOOST_CHECK_THROW(ogr::DataSource::New(filename, ogr::DataSource::Modes::MAX__), itk::ExceptionObject); // Overwrite mode supports the creation of file if it does not exists { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Overwrite); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1, ITK_NULLPTR, wkbPoint); OGRFeatureDefn & defn = l.GetLayerDefn(); l.CreateField(k_f0); l.CreateField(k_f1); ogr::Feature f(defn); f[0].SetValue(42); f[1].SetValue(42.0); const OGRPoint p(42, 42); f.SetGeometry(&p); l.CreateFeature(f); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 1); } // Read file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> GetLayerChecked(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 42); BOOST_CHECK_EQUAL(f[1].GetValue(), 42.0); ogr::UniqueGeometryPtr p = f.StealGeometry(); const OGRPoint ref(42, 42); BOOST_CHECK(ogr::Equals(*p, ref)); } // Now really test overwriting the file already exists) { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Overwrite); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1, ITK_NULLPTR, wkbPoint); OGRFeatureDefn & defn = l.GetLayerDefn(); l.CreateField(k_f0); l.CreateField(k_f1); ogr::Feature f(defn); f[0].SetValue(43); f[1].SetValue(43.0); const OGRPoint p(43, 43); f.SetGeometry(&p); l.CreateFeature(f); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 1); } // Read file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> GetLayerChecked(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p = f.StealGeometry(); const OGRPoint ref(43, 43); BOOST_CHECK(ogr::Equals(*p, ref)); } // Open in Update_LayerUpdate { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Update_LayerUpdate); // Check that we can read the file BOOST_ASSERT(ds); ogr::Layer l = ds -> GetLayerChecked(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p = f.StealGeometry(); const OGRPoint ref(43, 43); BOOST_CHECK(ogr::Equals(*p, ref)); // Add a second feature ogr::Feature f2(l.GetLayerDefn()); f2[0].SetValue(44); f2[1].SetValue(44.0); const OGRPoint p2(44, 44); f2.SetGeometry(&p2); l.CreateFeature(f2); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 2); } // Read the file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> GetLayerChecked(0); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 2); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p1 = f.StealGeometry(); const OGRPoint ref1(43, 43); BOOST_CHECK(ogr::Equals(*p1, ref1)); f = l.GetFeature(1); BOOST_CHECK_EQUAL(f[0].GetValue(), 44); BOOST_CHECK_EQUAL(f[1].GetValue(), 44.0); ogr::UniqueGeometryPtr p2 = f.StealGeometry(); const OGRPoint ref2(44, 44); BOOST_CHECK(ogr::Equals(*p2, ref2)); } // Open in Update_LayerCreateOnly { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Update_LayerCreateOnly); // Check that we can read the file BOOST_ASSERT(ds); ogr::Layer l = ds -> GetLayerChecked(0); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 2); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p1 = f.StealGeometry(); const OGRPoint ref1(43, 43); BOOST_CHECK(ogr::Equals(*p1, ref1)); f = l.GetFeature(1); BOOST_CHECK_EQUAL(f[0].GetValue(), 44); BOOST_CHECK_EQUAL(f[1].GetValue(), 44.0); ogr::UniqueGeometryPtr p2 = f.StealGeometry(); const OGRPoint ref2(44, 44); BOOST_CHECK(ogr::Equals(*p2, ref2)); // Cannot modify a layer which already exists std::string name = l.GetName(); ogr::Layer createdlayer = ds->CreateLayer(name); OGRFeatureDefn & defn = l.GetLayerDefn(); ogr::Feature f2(defn); f2[0].SetValue(45); f2[1].SetValue(45.0); const OGRPoint p(45, 45); f2.SetGeometry(&p); BOOST_CHECK_THROW(l.CreateFeature(f2), itk::ExceptionObject); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 2); } // Read the file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> GetLayerChecked(0); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 2); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p1 = f.StealGeometry(); const OGRPoint ref1(43, 43); BOOST_CHECK(ogr::Equals(*p1, ref1)); f = l.GetFeature(1); BOOST_CHECK_EQUAL(f[0].GetValue(), 44); BOOST_CHECK_EQUAL(f[1].GetValue(), 44.0); ogr::UniqueGeometryPtr p2 = f.StealGeometry(); const OGRPoint ref2(44, 44); BOOST_CHECK(ogr::Equals(*p2, ref2)); } #if 0 // shp files do not support Update_LayerOverwrite // Open in Update_LayerOverwrite { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Update_LayerOverwrite); // Check that we can read the file BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1); BOOST_ASSERT(l.GetFeatureCount(true) == 2); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p1 = f.StealGeometry(); const OGRPoint ref1(43, 43); BOOST_CHECK(ogr::Equals(*p1, ref1)); f = l.GetFeature(1); BOOST_CHECK_EQUAL(f[0].GetValue(), 44); BOOST_CHECK_EQUAL(f[1].GetValue(), 44.0); ogr::UniqueGeometryPtr p2 = f.StealGeometry(); const OGRPoint ref2(44, 44); BOOST_CHECK(ogr::Equals(*p2, ref2)); // Add a new feature ogr::Feature f3(l.GetLayerDefn()); f3[0].SetValue(45); f3[1].SetValue(45.0); const OGRPoint p3(45, 45); f3.SetGeometry(&p3); l.CreateFeature(f3); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 1); } // Read file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> GetLayerChecked(0); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Feature f = l.GetFeature(0); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p1 = f.StealGeometry(); const OGRPoint ref1(43, 43); BOOST_CHECK(ogr::Equals(*p1, ref1)); f = l.GetFeature(1); BOOST_CHECK_EQUAL(f[0].GetValue(), 44); BOOST_CHECK_EQUAL(f[1].GetValue(), 44.0); ogr::UniqueGeometryPtr p2 = f.StealGeometry(); const OGRPoint ref2(44, 44); BOOST_CHECK(ogr::Equals(*p2, ref2)); } #endif } BOOST_AUTO_TEST_CASE(OGRDataSource_sqlite_overwrite) { if (boost::unit_test::framework::master_test_suite().argc < 2) { BOOST_THROW_EXCEPTION( std::runtime_error("not enough arguments") ); } const std::string k_name = boost::unit_test::framework::master_test_suite().argv[1]; const std::string workingdir = k_name + "/sqlite"; // Create an empty temporary directory for the test if ( itksys::SystemTools::FileExists(workingdir.c_str()) ) { itksys::SystemTools::RemoveADirectory(workingdir.c_str()); } itksys::SystemTools::MakeDirectory(workingdir.c_str()); std::string filename = workingdir + "/" + k_name + ".sqlite"; filename = itksys::SystemTools::ConvertToOutputPath(filename.c_str()); const std::string layer1 = boost::algorithm::to_lower_copy(k_name); // Cannot create read data source if file does not exists BOOST_CHECK_THROW(ogr::DataSource::New(filename, ogr::DataSource::Modes::Read), itk::ExceptionObject); // Check invalid modes BOOST_CHECK_THROW(ogr::DataSource::New(filename, ogr::DataSource::Modes::Invalid), itk::ExceptionObject); BOOST_CHECK_THROW(ogr::DataSource::New(filename, ogr::DataSource::Modes::MAX__), itk::ExceptionObject); // Overwrite mode supports the creation of file if it does not exists { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Overwrite); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1, ITK_NULLPTR, wkbPoint); OGRFeatureDefn & defn = l.GetLayerDefn(); l.CreateField(k_f0); l.CreateField(k_f1); ogr::Feature f(defn); f[0].SetValue(42); f[1].SetValue(42.0); const OGRPoint p(42, 42); f.SetGeometry(&p); l.CreateFeature(f); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 1); } // Read file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds->GetLayerChecked(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Feature f = *l.begin(); BOOST_CHECK_EQUAL(f[0].GetValue(), 42); BOOST_CHECK_EQUAL(f[1].GetValue(), 42.0); ogr::UniqueGeometryPtr p = f.StealGeometry(); const OGRPoint ref(42, 42); BOOST_CHECK(ogr::Equals(*p, ref)); } // Now really test overwriting the file already exists) { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Overwrite); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1, ITK_NULLPTR, wkbPoint); OGRFeatureDefn & defn = l.GetLayerDefn(); l.CreateField(k_f0); l.CreateField(k_f1); ogr::Feature f(defn); f[0].SetValue(43); f[1].SetValue(43.0); const OGRPoint p(43, 43); f.SetGeometry(&p); l.CreateFeature(f); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 1); } // Read file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Feature f = *l.begin(); BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p = f.StealGeometry(); const OGRPoint ref(43, 43); BOOST_CHECK(ogr::Equals(*p, ref)); } // Open in Update_LayerUpdate { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Update_LayerUpdate); // Check that we can read the file BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Layer::iterator fIt = l.begin(); ogr::Feature f = *fIt; BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p = f.StealGeometry(); const OGRPoint ref(43, 43); BOOST_CHECK(ogr::Equals(*p, ref)); // Add a second feature ogr::Feature f2(l.GetLayerDefn()); f2[0].SetValue(44); f2[1].SetValue(44.0); const OGRPoint p2(44, 44); f2.SetGeometry(&p2); l.CreateFeature(f2); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 2); } // Read the file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 2); ogr::Layer::iterator fIt = l.begin(); ogr::Feature f = *fIt; BOOST_CHECK_EQUAL(f[0].GetValue(), 43); BOOST_CHECK_EQUAL(f[1].GetValue(), 43.0); ogr::UniqueGeometryPtr p1 = f.StealGeometry(); const OGRPoint ref1(43, 43); BOOST_CHECK(ogr::Equals(*p1, ref1)); f = *++fIt; BOOST_CHECK_EQUAL(f[0].GetValue(), 44); BOOST_CHECK_EQUAL(f[1].GetValue(), 44.0); ogr::UniqueGeometryPtr p2 = f.StealGeometry(); const OGRPoint ref2(44, 44); BOOST_CHECK(ogr::Equals(*p2, ref2)); } // Open in Update_LayerOverwrite { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Update_LayerOverwrite); // Check that we can read the file BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1, ITK_NULLPTR, wkbPoint); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 0); // OGRFeatureDefn & defn = l.GetLayerDefn(); l.CreateField(k_f0); l.CreateField(k_f1); // Add a new feature ogr::Feature f3(l.GetLayerDefn()); f3[0].SetValue(45); f3[1].SetValue(45.0); const OGRPoint p3(45, 45); f3.SetGeometry(&p3); l.CreateFeature(f3); BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 1); } // Read file we have written { ogr::DataSource::Pointer ds = ogr::DataSource::New(filename, ogr::DataSource::Modes::Read); BOOST_ASSERT(ds); ogr::Layer l = ds -> CreateLayer(layer1); BOOST_CHECK_EQUAL(l.GetFeatureCount(true), 1); ogr::Layer::iterator fIt = l.begin(); ogr::Feature f = *fIt; BOOST_CHECK_EQUAL(f[0].GetValue(), 45); BOOST_CHECK_EQUAL(f[1].GetValue(), 45.0); ogr::UniqueGeometryPtr p1 = f.StealGeometry(); const OGRPoint ref1(45, 45); BOOST_CHECK(ogr::Equals(*p1, ref1)); } } BOOST_AUTO_TEST_CASE(Add_n_Del_Fields) { ogr::DataSource::Pointer ds = ogr::DataSource::New(); ogr::Layer l = ds -> CreateLayer(k_one); ogr::Layer l0 = ds->GetLayerChecked(0); OGRFeatureDefn & defn = l.GetLayerDefn(); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 0); l.CreateField(k_f0); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 1); l.CreateField(k_f1); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 2); l.CreateField(k_f2); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 3); l.CreateField(k_f3); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 4); l.CreateField(k_f4); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 5); l.CreateField(k_f5); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 6); { ogr::FieldDefn f0(*defn.GetFieldDefn(0)); BOOST_CHECK_EQUAL(f0, k_f0); ogr::FieldDefn f1(*defn.GetFieldDefn(1)); BOOST_CHECK_EQUAL(f1, k_f1); ogr::FieldDefn f2(*defn.GetFieldDefn(2)); BOOST_CHECK_EQUAL(f2, k_f2); ogr::FieldDefn f3(*defn.GetFieldDefn(3)); BOOST_CHECK_EQUAL(f3, k_f3); ogr::FieldDefn f4(*defn.GetFieldDefn(4)); BOOST_CHECK_EQUAL(f4, k_f4); ogr::FieldDefn f5(*defn.GetFieldDefn(5)); BOOST_CHECK_EQUAL(f5, k_f5); BOOST_CHECK_EQUAL(defn.GetFieldDefn(6), (void*)ITK_NULLPTR); } #if GDAL_VERSION_NUM >= 1900 l.DeleteField(1); BOOST_CHECK_EQUAL(defn.GetFieldCount(), 5); { ogr::FieldDefn f0(*defn.GetFieldDefn(0)); BOOST_CHECK_EQUAL(f0, k_f0); ogr::FieldDefn f1(*defn.GetFieldDefn(1)); BOOST_CHECK_EQUAL(f1, k_f2); ogr::FieldDefn f2(*defn.GetFieldDefn(2)); BOOST_CHECK_EQUAL(f2, k_f3); ogr::FieldDefn f3(*defn.GetFieldDefn(3)); BOOST_CHECK_EQUAL(f3, k_f4); ogr::FieldDefn f4(*defn.GetFieldDefn(4)); BOOST_CHECK_EQUAL(f4, k_f5); } #endif // todo: add reoder tests } BOOST_AUTO_TEST_CASE(Add_n_Read_Fields) { ogr::DataSource::Pointer ds = ogr::DataSource::New(); ogr::Layer l = ds -> CreateLayer(k_one); ogr::Layer l0 = ds->GetLayerChecked(0); OGRFeatureDefn & defn = l.GetLayerDefn(); l.CreateField(k_f0); l.CreateField(k_f1); l.CreateField(k_f2); l.CreateField(k_f3); l.CreateField(k_f4); l.CreateField(k_f5); ogr::Feature g0(defn); const int NbFields = defn.GetFieldCount(); BOOST_CHECK_EQUAL(NbFields, g0.GetSize()); for (int i=0; i!=NbFields; ++i) { BOOST_ASSERT(!g0[i].HasBeenSet()); } // ----[ int ogr::Field f0 = g0[0]; #if GDAL_VERSION_NUM >= 1800 BOOST_CHECK_EQUAL(f0.GetName(), k_f0.GetName()); #endif f0.SetValue(42); BOOST_ASSERT(f0.HasBeenSet()); BOOST_CHECK_EQUAL(f0.GetValue(), 42); BOOST_CHECK_EQUAL(g0[0].GetValue(), 42); // BOOST_CHECK_EQUAL((*l.begin())[0].GetValue(), 42); // BOOST_CHECK_assert_FAILS(f0.GetValue(), itk::ExceptionObject); // ----[ double ogr::Field f1 = g0["OFTReal"]; #if GDAL_VERSION_NUM >= 1800 BOOST_CHECK_EQUAL(f1.GetName(), k_f1.GetName()); #endif // f1.SetValue(42); // need to support types promotion f1.SetValue(42.0); // need to support types promotion BOOST_ASSERT(f1.HasBeenSet()); BOOST_CHECK_EQUAL(f1.GetValue(), 42.0); // ----[ string ogr::Field f2 = g0["OFTString"]; #if GDAL_VERSION_NUM >= 1800 BOOST_CHECK_EQUAL(f2.GetName(), k_f2.GetName()); #endif f2.SetValue(("foobar")); // need to support types promotion BOOST_ASSERT(f2.HasBeenSet()); BOOST_CHECK_EQUAL(f2.GetValue(), "foobar"); f2.Unset(); BOOST_ASSERT(!f2.HasBeenSet()); f2.SetValue(std::string("foo")); BOOST_ASSERT(f2.HasBeenSet()); BOOST_CHECK_EQUAL(f2.GetValue(), "foo"); // ----[ list of ints { ogr::Field f3 = g0["OFTIntegerList"]; std::vector v0; v0.push_back(42); v0.push_back(12); f3.SetValue(v0); std::vector w0 = f3.GetValue >(); BOOST_CHECK_EQUAL_COLLECTIONS(v0.begin(),v0.end(),w0.begin(),w0.end()); } // ----[ list of doubles { ogr::Field f4 = g0["OFTRealList"]; std::vector v1; v1.push_back(42); v1.push_back(12); f4.SetValue(v1); std::vector w1 = f4.GetValue >(); BOOST_CHECK_EQUAL_COLLECTIONS(v1.begin(),v1.end(),w1.begin(),w1.end()); } // ----[ list of string { ogr::Field f5 = g0["OFTStringList"]; std::vector v2; v2.push_back("42"); v2.push_back("12"); f5.SetValue(v2); std::vector w2 = f5.GetValue >(); BOOST_CHECK_EQUAL_COLLECTIONS(v2.begin(),v2.end(),w2.begin(),w2.end()); } } BOOST_AUTO_TEST_CASE(OGRDataSource_new_shp_with_features) { const std::string k_shp = "SomeShapeFileWithFeatures"; ogr::DataSource::Pointer ds = ogr::DataSource::New(k_shp+".shp", ogr::DataSource::Modes::Overwrite); ogr::Layer l = ds -> CreateLayer(k_one, ITK_NULLPTR, wkbPoint); OGRFeatureDefn & defn = l.GetLayerDefn(); l.CreateField(k_f0); ogr::Feature g0(defn); g0[0].SetValue(42); l.CreateFeature(g0); } BOOST_AUTO_TEST_CASE(Local_Geometries) { ogr::UniqueGeometryPtr gp (OGRGeometryFactory::createGeometry(wkbPoint)); BOOST_REQUIRE(gp); OGRPoint * p = dynamic_cast(gp.get()); BOOST_REQUIRE(p); p->setX(0); p->setY(0); OGRPoint x0(-10, 0); OGRPoint x1(+10, 0); OGRLineString X; X.addPoint(&x0); X.addPoint(&x1); OGRPoint y0(0, -10); OGRPoint y1(0, +10); OGRLineString Y; Y.addPoint(&y0); Y.addPoint(&y1); ogr::UniqueGeometryPtr i = ogr::Intersection(X, Y); BOOST_CHECK(ogr::Equals(*i, *p)); BOOST_CHECK(ogr::Equals(*i, *gp)); } BOOST_AUTO_TEST_CASE(Add_n_Read_Geometries) { ogr::DataSource::Pointer ds = ogr::DataSource::New(); ogr::Layer l = ds -> CreateLayer(k_one, ITK_NULLPTR, wkbPoint); OGRFeatureDefn & defn = l.GetLayerDefn(); for (int u=-10; u!=10; ++u) { ogr::Feature f(defn); const OGRPoint p(u, u); f.SetGeometry(&p); l.CreateFeature(f); } BOOST_CHECK_EQUAL(l.GetFeatureCount(false), 20); int u=-10; BOOST_FOREACH(ogr::Feature f, l) { const OGRPoint ref(u, u); ogr::UniqueGeometryPtr p = f.StealGeometry(); BOOST_REQUIRE(p); BOOST_CHECK(! f.GetGeometry()); BOOST_CHECK(ogr::Equals(*p, ref)); f.SetGeometryDirectly(otb::move(p)); BOOST_CHECK(!p); ++u; } } #if 0 BOOST_AUTO_TEST_CASE(OGRDataSource_new_shp_with_features_raw) { const std::string k_shp = "SomeShapeFileWithFeaturesRaw"; const std::string k_one = k_shp; OGRSFDriver * dr = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("ESRI Shapefile"); BOOST_ASSERT(dr); OGRDataSource * ds = dr->CreateDataSource((k_shp+".shp").c_str()); BOOST_ASSERT(ds); OGRLayer * l = ds -> CreateLayer(k_one.c_str(), 0, wkbPoint); BOOST_ASSERT(l); l->CreateField(&k_f0_); OGRFeatureDefn * defn = l->GetLayerDefn(); BOOST_ASSERT(defn); OGRFeature * g0 = OGRFeature::CreateFeature(defn); BOOST_ASSERT(g0); g0 -> SetField(0, 42); l->CreateFeature(g0); OGRFeature::DestroyFeature(g0); OGRDataSource::DestroyDataSource(ds); } #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/000077500000000000000000000000001301006202600211475ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OSSIMAdapters/CMakeLists.txt000066400000000000000000000001361301006202600237070ustar00rootroot00000000000000project(OTBOSSIMAdapters) set(OTBOSSIMAdapters_LIBRARIES OTBOSSIMAdapters) otb_module_impl() OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/000077500000000000000000000000001301006202600225725ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbDEMConvertAdapter.h000066400000000000000000000027761301006202600267330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDEMConvertAdapter_h #define otbDEMConvertAdapter_h #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBOSSIMAdaptersExport.h" namespace otb { class OTBOSSIMAdapters_EXPORT DEMConvertAdapter: public itk::Object { public: /** Standard class typedefs. */ typedef DEMConvertAdapter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(EllipsoidAdapter, itk::Object); int Convert(std::string tempFilename, std::string output); protected: DEMConvertAdapter(); ~DEMConvertAdapter() ITK_OVERRIDE; private: DEMConvertAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbDEMHandler.h000066400000000000000000000137031301006202600253570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDEMHandler_h #define otbDEMHandler_h #include #include #include "itkIndent.h" #include "itkObject.h" #include "itkObjectFactory.h" #include "itkPoint.h" #include "OTBOSSIMAdaptersExport.h" class ossimElevManager; namespace otb { /** \class DEMHandler * * \brief Single access point for DEM data retrieval * * This class is the single configuration and access point for * elevation handling in images projections and localization * functions. Since this class is a singleton, the New() method is * deprecated and will be removed in future release. Please use the * DEMHandler::Instance() method instead. * * Please be aware that a proper instantiation and parameter setting * of this class is advised before any call to geometric filters or * functionalities. Ossim internal accesses to elevation are also * configured by this class and this will ensure consistency * throughout the library. * * The class allows configuring a directory containing DEM tiles * (DTED or SRTM supported) using the OpenDEMDirectory() method. The * OpenGeoidFile() method allows inputting a geoid file as well. Last, * a default height above ellipsoid can be set using the * SetDefaultHeightAboveEllipsoid() method. * * The class allows retrieving either height above ellipsoid or * height above Mean Sea Level (MSL). * * Here is the complete description of both methods output depending * on the class configuration for the SRTM DEM (in the following, no * SRTM means DEMDirectory not set, or no coverage for point, or * srtm_value is no_data). * * GetHeightAboveEllipsoid(): * - SRTM and geoid both available: srtm_value + geoid_offset * - No SRTM but geoid available: geoid_offset * - SRTM available, but no geoid: srtm_value * - No SRTM and no geoid available: default height above ellipsoid * * GetHeightAboveMSL(): * - SRTM and geoid both available: srtm_value * - No SRTM but geoid available: 0 * - SRTM available, but no geoid: srtm_value * - No SRTM and no geoid available: 0 * * Please note that OSSIM internal calls for sensor modeling use the * height above ellipsoid, and follow the same logic as the * GetHeightAboveEllipsoid() method. * * DEM directory can either contain DTED or SRTM formats. * \ingroup Images * * * \ingroup OTBOSSIMAdapters */ class OTBOSSIMAdapters_EXPORT DEMHandler : public itk::Object { public: /** Standard class typedefs. */ typedef DEMHandler Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Point PointType; /** Retrieve the singleton instance */ static Pointer Instance(); /** Run-time type information (and related methods). */ itkTypeMacro(DEMHandler, Object); /** Try to open the DEM directory. */ virtual void OpenDEMDirectory(const char* DEMDirectory); virtual void OpenDEMDirectory(const std::string& DEMDirectory); /** return true if the directory contain DEM */ virtual bool IsValidDEMDirectory(const char* DEMDirectory); /** * \brief Open geoid file given its filename or throw an exception * if geoid-file could not be loaded. * * \param geoidFile The filename of the geoid-file. * * \return true if geoid file has been changed or * false if geod-file have been set before and could * not be changed. */ virtual bool OpenGeoidFile(const char* geoidFile); /** * \brief Open geoid file given its filename or throw an exception * if geoid-file could not be loaded. * * \param geoidFile The filename of the geoid-file. * * \return true if geoid file has been changed or * false if geod-file have been set before and could * not be changed. */ virtual bool OpenGeoidFile(const std::string& geoidFile); /** Compute the height above MSL(Mean Sea Level) of a geographic point. */ virtual double GetHeightAboveMSL(double lon, double lat) const; virtual double GetHeightAboveMSL(const PointType& geoPoint) const; /** Compute the height above ellipsoid of a geographic point. */ virtual double GetHeightAboveEllipsoid(double lon, double lat) const; virtual double GetHeightAboveEllipsoid(const PointType& geoPoint) const; /** Set the default height above ellipsoid in case no information is available*/ virtual void SetDefaultHeightAboveEllipsoid(double h); /** Set the default height above ellipsoid in case no information is available*/ double GetDefaultHeightAboveEllipsoid() const; /** * \return The number of elevation databases in the * ossimElevManager. */ unsigned int GetDEMCount() const; /** Get DEM directory */ std::string GetDEMDirectory(unsigned int idx = 0) const; /** Get Goid file */ std::string GetGeoidFile() const; /** * \brief Remove all the ossimElevationDatabases from the * ossimElevManager. */ void ClearDEMs(); protected: DEMHandler(); ~DEMHandler() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; // Ossim does not allow retrieving the geoid file path // We therefore must keep it on our side std::string m_GeoidFile; // Ossim does not allow retrieving the default height above // ellipsoid We therefore must keep it on our side double m_DefaultHeightAboveEllipsoid; static Pointer m_Singleton; }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbDateTimeAdapter.h000066400000000000000000000044471301006202600264560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDateTimeAdapter_h #define otbDateTimeAdapter_h #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBOSSIMAdaptersExport.h" class ossimLocalTm; //class ossimDate; //class ossimTime; namespace otb { /** \class DateTimeAdapter * \brief This is a dummy class to the ossimLocalTm class * * This class provide functions to define, compare and measure times and dates. * * * \ingroup OTBOSSIMAdapters **/ class OTBOSSIMAdapters_EXPORT DateTimeAdapter : public itk::Object { public: /** Standard class typedefs. */ typedef DateTimeAdapter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DateTimeAdapter, itk::Object); /** Year Accessor*/ int GetYear(); /** Month Accessor*/ int GetMonth(); /** Day Accessor*/ int GetDay(); /** Hour Accessor*/ int GetHour(); /** Minute Accessor*/ int GetMinute(); /** Seconds Accessor*/ double GetSeconds() const; /** Set the date and time from an Iso8601 string * Return true if the date is valid */ bool SetFromIso8601(const std::string &date); /** Return the delta with an other date, expressed in seconds */ double GetDeltaInSeconds(const DateTimeAdapter *pastDate); // TODO : add print self function protected: DateTimeAdapter(); ~DateTimeAdapter() ITK_OVERRIDE; private: DateTimeAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ossimLocalTm *m_LocalTm; }; // TODO add extern '<<' function } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbEllipsoidAdapter.h000066400000000000000000000042521301006202600267000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEllipsoidAdapter_h #define otbEllipsoidAdapter_h #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBOSSIMAdaptersExport.h" class ossimEllipsoid; namespace otb { /** \class EllipsoidAdapter * \brief class providing the interface to the ossimEllipsoid * * This is a class to be used internally instead of introducing a dependence on * ossimEllipsoid * * \todo{Add the support for different ellipsoid models} * * * \ingroup OTBOSSIMAdapters **/ class OTBOSSIMAdapters_EXPORT EllipsoidAdapter: public itk::Object { public: /** Standard class typedefs. */ typedef EllipsoidAdapter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(EllipsoidAdapter, itk::Object); /** Convert a XYZ coordinate into a lon, lat, height on the ellipsoid */ void XYZToLonLatHeight(double x, double y, double z, double& lon, double& lat, double& h) const; /** Convert a lon, lat, height on the ellipsoid into a XYZ geocentric system*/ void LonLatHeightToXYZ(double lon, double lat, double h, double& x, double& y, double& z) const; protected: EllipsoidAdapter(); ~EllipsoidAdapter() ITK_OVERRIDE; private: EllipsoidAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ossimEllipsoid* m_Ellipsoid; }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbFilterFunctionValues.h000066400000000000000000000104521301006202600275650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFilterFunctionValues_h #define otbFilterFunctionValues_h #include #include #include "itkDataObject.h" #include "itkObjectFactory.h" #include "itkMacro.h" #include "OTBOSSIMAdaptersExport.h" namespace otb { /** \class FilterFunctionValues * \brief This class contains the values of the filter function for the processed spectral band. * * The step between 2 values is 0.0025 micro meter. The class contains the min and the max value. * Those value can be directly read from the image metadatas. * * \ingroup IO * * \ingroup OTBOSSIMAdapters */ class OTBOSSIMAdapters_EXPORT FilterFunctionValues : public itk::DataObject { public: /** Standard typedefs */ typedef FilterFunctionValues Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(FilterFunctionValues, DataObject); /** Creation through object factory macro */ itkNewMacro(Self); typedef float WavelengthSpectralBandType; typedef std::vector ValuesVectorType; /** Set vector that contains the filter function value. */ void SetFilterFunctionValues(const ValuesVectorType& vect) { m_FilterFunctionValues = vect; this->Modified(); } /** Get vector that contains the filter function value. */ const ValuesVectorType& GetFilterFunctionValues() const { return m_FilterFunctionValues; } /** Get vector that contains the filter function value 6S. */ void SetFilterFunctionValues6S(const ValuesVectorType& vect) { m_FilterFunctionValues6S = vect; this->Modified(); } /** Get vector that contains the filter function value 6S. */ const ValuesVectorType& GetFilterFunctionValues6S() const { return m_FilterFunctionValues6S; } /** Set minimum spectral value. */ itkSetMacro(MinSpectralValue, WavelengthSpectralBandType); /** Get minimum spectral value. */ itkGetMacro(MinSpectralValue, WavelengthSpectralBandType); /** Set maximum spectral value. This value is automatically computed.*/ itkSetMacro(MaxSpectralValue, WavelengthSpectralBandType); /** Get maximum spectral value. This value is automatically computed.*/ itkGetMacro(MaxSpectralValue, WavelengthSpectralBandType); /** Set user step between each wavelength spectral band values. */ itkSetMacro(UserStep, WavelengthSpectralBandType); /** Get user step between each wavelength spectral band values. */ itkGetMacro(UserStep, WavelengthSpectralBandType); /** Compute the center wavelength value for the filter */ WavelengthSpectralBandType GetCenterSpectralValue() const; protected: /** Constructor */ FilterFunctionValues(); /** Destructor */ ~FilterFunctionValues() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: FilterFunctionValues(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Vector that contains the filter function value. */ ValuesVectorType m_FilterFunctionValues; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. If the UserStep is 0.0025 micro m, then m_FilterFunctionValues is identical as m_FilterFunctionValues6S */ ValuesVectorType m_FilterFunctionValues6S; /** Minimum spectral value (in micro m). */ WavelengthSpectralBandType m_MinSpectralValue; /** Maximum spectral value (in micro m). */ WavelengthSpectralBandType m_MaxSpectralValue; /** User step between each wavelength spectral band values. (in micro micro m) */ WavelengthSpectralBandType m_UserStep; }; } //end namespace #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbGeometricSarSensorModelAdapter.h000066400000000000000000000047161301006202600315200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeometricSarSensorModelAdapter_h #define otbGeometricSarSensorModelAdapter_h #include #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBOSSIMAdaptersExport.h" namespace ossimplugins { class ossimGeometricSarSensorModel; class JSDDateTime; } namespace otb { class ImageKeywordlist; /** * \class GeometricSarSensorModelAdapter * \brief Wrapper class to access the platform Geometric Sar * Sensor Modelposition from ossim. * * This class is intended to be used in an InSAR setting to get * information relative to the baseline. If necessary, it could be * extended to non SAR models, but the optical ossim classes would * need to be modified. * * \ingroup OTBOSSIMAdapters **/ class OTBOSSIMAdapters_EXPORT GeometricSarSensorModelAdapter: public itk::Object { public: /** Standard class typedefs. */ typedef GeometricSarSensorModelAdapter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GeometricSarSensorModelAdapter, itk::Object); void CreateSensorModel(const ImageKeywordlist& image_kwl); /** Get the platform position and speed for a given line. */ void GetPlatformPositionAtLine( double line, std::vector& position, std::vector& speed); /** Get the platform time for a given line. */ ossimplugins::JSDDateTime getTime(double line); protected: GeometricSarSensorModelAdapter(); ~GeometricSarSensorModelAdapter() ITK_OVERRIDE; private: GeometricSarSensorModelAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ossimplugins::ossimGeometricSarSensorModel* m_SensorModel; }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbImageKeywordlist.h000066400000000000000000000111671301006202600267410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageKeywordlist_h #define otbImageKeywordlist_h #include #include #include "gdal.h" #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBOSSIMAdaptersExport.h" //forward declaration class ossimKeywordlist; namespace otb { namespace internal { /** * Converts index coordinates from OTB into OSSIM. It is intended for sensor * images where the centre of the top-left pixel is expected to be : * [0.5,0.5] in OTB physical space * [ 0 , 0 ] in OSSIM * \param[in] val coordinate value to modify (along X or Y) */ inline double ConvertToOSSIMFrame(double val) { return (val - 0.5); } /** * Converts index coordinates from OSSIM into OTB. It is intended for sensor * images where the centre of the top-left pixel is expected to be : * [0.5,0.5] in OTB physical space * [ 0 , 0 ] in OSSIM * \param[in] val coordinate value to modify (along X or Y) */ inline double ConvertFromOSSIMFrame(double val) { return (val + 0.5); } } // namespace internal /** \class ImageKeywordlist * \brief Storage and conversion for OSSIM metadata * * \sa ImageSeriesReader * \sa ImageIOBase * * \ingroup Projections * * * \ingroup OTBOSSIMAdapters */ class OTBOSSIMAdapters_EXPORT ImageKeywordlist { public: /** Standard class typedefs. */ typedef ImageKeywordlist Self; //virtual const char *GetNameOfClass() const //{return "ImageKeywordlist"; } typedef std::map KeywordlistMap; typedef KeywordlistMap::size_type KeywordlistMapSizeType; /** Get the internal map container */ const KeywordlistMap& GetKeywordlist() const { return m_Keywordlist; } void SetKeywordlist(const ossimKeywordlist& kwl); void Clear(void) { m_Keywordlist.clear(); } KeywordlistMapSizeType Empty() const { return m_Keywordlist.empty(); } KeywordlistMapSizeType GetSize(void) const { return m_Keywordlist.size(); } /** Get the Data object descriptor corresponding to the given key */ const std::string& GetMetadataByKey(const std::string& key) const; /** return true if the key is in the dictionary */ bool HasKey(const std::string& key) const; /** Clear a given field of the keyword list */ virtual void ClearMetadataByKey(const std::string& key); virtual void AddKey(const std::string& key, const std::string& value); virtual void convertToOSSIMKeywordlist(ossimKeywordlist& kwl) const; /** try to convert the image keywordlist into a GDALRpcInfo structure * return true if successful, false otherwise */ virtual bool convertToGDALRPC(GDALRPCInfo &rpc) const; virtual void Print(std::ostream& os, itk::Indent indent = 0) const; ImageKeywordlist(); virtual ~ImageKeywordlist(); ImageKeywordlist(const Self &); void operator =(const Self&); bool operator ==(const Self&) const; inline bool operator != ( const Self & ) const; protected: /** Methods invoked by Print() to print information about the object * Typically not called by the user (use Print() * instead) but used in the hierarchical print process to combine the * output of several classes. */ virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; private: /** Geo information are in this map */ KeywordlistMap m_Keywordlist; // char m_Delimiter; // void operator=(const Self&); //purposely not implemented }; OTBOSSIMAdapters_EXPORT std::ostream & operator <<(std::ostream& os, const ImageKeywordlist& kwl); // Free function to handle the keywordlist <-> files OTBOSSIMAdapters_EXPORT ImageKeywordlist ReadGeometryFromImage(const std::string& filename, bool checkRpcTag=true); OTBOSSIMAdapters_EXPORT ImageKeywordlist ReadGeometryFromGEOMFile(const std::string& filename); OTBOSSIMAdapters_EXPORT ImageKeywordlist ReadGeometryFromRPCTag(const std::string& filename); OTBOSSIMAdapters_EXPORT void WriteGeometry(const ImageKeywordlist& otb_kwl, const std::string& filename); inline bool ImageKeywordlist ::operator !=( const Self & p ) const { return !this->operator == ( p ); } } //namespace otb #endif // otbImageKeywordlist_h OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbMapProjectionAdapter.h000066400000000000000000000070051301006202600275250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMapProjectionAdapter_h #define otbMapProjectionAdapter_h #include #include #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBOSSIMAdaptersExport.h" #include "otbMacro.h" class ossimProjection; namespace otb { /** * \class MapProjectionAdapter * \brief Wrapper class to group all dependencies to ossim for map projection * * This class is NOT intended to be used outside of OTB. Use the * GenericMapProjection. If you feel that you need to use it directly, * think again! * * \sa GenericMapProjection * \ingroup Projection * * * \ingroup OTBOSSIMAdapters **/ class OTBOSSIMAdapters_EXPORT MapProjectionAdapter: public itk::Object { public: /** Standard class typedefs. */ typedef MapProjectionAdapter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef ossimProjection* InternalMapProjectionPointer; typedef const ossimProjection* InternalMapProjectionConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MapProjectionAdapter, itk::Object); InternalMapProjectionPointer GetMapProjection(); InternalMapProjectionConstPointer GetMapProjection() const; std::string GetWkt() const; void SetWkt(const std::string& projectionRefWkt); void SetParameter(const std::string& key, const std::string& value); std::string GetParameter(const std::string& key) const; bool InstantiateProjection(); /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ bool InstanciateProjection() { otbWarningMacro( << "InstanciateProjection has been deprecated. Please use InstanciateProjection() instead"); return this->InstantiateProjection(); } void InverseTransform(double x, double y, double z, double& lon, double& lat, double& h); void ForwardTransform(double lon, double lat, double h, double& x, double& y, double& z); void PrintMap() const; protected: MapProjectionAdapter(); ~MapProjectionAdapter() ITK_OVERRIDE; private: MapProjectionAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void ApplyParametersToProjection(); InternalMapProjectionPointer m_MapProjection; std::string m_ProjectionRefWkt; // Hold the parameters specified directly from the user of the class // Consistency is done from ParameterStore -> MapProjection // But NOT MapProjection -> ParameterStore // so DO NOT use that to read the projection parameters typedef std::map StoreType; StoreType m_ParameterStore; bool m_ReinstanciateProjection; }; // Some useful free functions related to ossim namespace Utils { int OTBOSSIMAdapters_EXPORT GetZoneFromGeoPoint(double lon, double lat); } } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbMetaDataKey.h000066400000000000000000000100221301006202600255740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMetaDataKey_h #define otbMetaDataKey_h #include #include #include "itkDataObject.h" #include "itkVariableLengthVector.h" #include "OTBOSSIMAdaptersExport.h" namespace otb { /** \namespace MetaDataKey * Definition of the key of metadata used in the metadata dictionary. */ namespace MetaDataKey { extern OTBOSSIMAdapters_EXPORT char const* DriverShortNameKey; extern OTBOSSIMAdapters_EXPORT char const* DriverLongNameKey; extern OTBOSSIMAdapters_EXPORT char const* ProjectionRefKey; extern OTBOSSIMAdapters_EXPORT char const* GCPProjectionKey; extern OTBOSSIMAdapters_EXPORT char const* GCPParametersKey; extern OTBOSSIMAdapters_EXPORT char const* GCPCountKey; extern OTBOSSIMAdapters_EXPORT char const* GeoTransformKey; extern OTBOSSIMAdapters_EXPORT char const* MetadataKey; extern OTBOSSIMAdapters_EXPORT char const* SubMetadataKey; extern OTBOSSIMAdapters_EXPORT char const* UpperLeftCornerKey; extern OTBOSSIMAdapters_EXPORT char const* UpperRightCornerKey; extern OTBOSSIMAdapters_EXPORT char const* LowerLeftCornerKey; extern OTBOSSIMAdapters_EXPORT char const* LowerRightCornerKey; extern OTBOSSIMAdapters_EXPORT char const* ColorTableNameKey; extern OTBOSSIMAdapters_EXPORT char const* ColorEntryCountKey; extern OTBOSSIMAdapters_EXPORT char const* ColorEntryAsRGBKey; extern OTBOSSIMAdapters_EXPORT char const* OSSIMKeywordlistKey; extern OTBOSSIMAdapters_EXPORT char const* OSSIMKeywordlistDelimiterKey; extern OTBOSSIMAdapters_EXPORT char const* VectorDataKeywordlistKey; extern OTBOSSIMAdapters_EXPORT char const* VectorDataKeywordlistDelimiterKey; extern OTBOSSIMAdapters_EXPORT char const* ResolutionFactor; extern OTBOSSIMAdapters_EXPORT char const* SubDatasetIndex; extern OTBOSSIMAdapters_EXPORT char const* CacheSizeInBytes; extern OTBOSSIMAdapters_EXPORT char const* TileHintX; extern OTBOSSIMAdapters_EXPORT char const* TileHintY; extern OTBOSSIMAdapters_EXPORT char const * NoDataValueAvailable; extern OTBOSSIMAdapters_EXPORT char const * NoDataValue; enum KeyType { TSTRING, TENTIER, TDOUBLE, TOTB_GCP, TVECTOR, TOSSIMKEYWORDLIST, TVECTORDATAKEYWORDLIST, TBOOLVECTOR }; /* typedef struct { std::string keyname; KeyType type; } KeyTypeDef; */ struct KeyTypeDef { std::string keyname; KeyType type; KeyTypeDef() {} KeyTypeDef(const std::string& _keyname, const KeyType& _type) { keyname = _keyname; type = _type; } }; KeyType OTBOSSIMAdapters_EXPORT GetKeyType(const std::string& name); typedef std::vector VectorType; typedef std::vector BoolVectorType; typedef itk::VariableLengthVector VariableLengthVectorType; } /** \class OTB_GCP * * \brief This OTB_GCP class is used to manage the GCP parameters * in OTB. * * * \ingroup OTBOSSIMAdapters */ class OTBOSSIMAdapters_EXPORT OTB_GCP { public: /** Unique identifier, often numeric */ std::string m_Id; /** Informational message or "" */ std::string m_Info; /** Pixel (x) location of GCP on raster */ double m_GCPCol; /** Line (y) location of GCP on raster */ double m_GCPRow; /** X position of GCP in georeferenced space */ double m_GCPX; /** Y position of GCP in georeferenced space */ double m_GCPY; /** Elevation of GCP, or zero if not known */ double m_GCPZ; OTB_GCP(); ~OTB_GCP(); void Print(std::ostream& os) const; }; } // end namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbPlatformPositionAdapter.h000066400000000000000000000047031301006202600302660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPlatformPositionAdapter_h #define otbPlatformPositionAdapter_h #include #include "itkObject.h" #include "itkObjectFactory.h" #include "OTBOSSIMAdaptersExport.h" namespace ossimplugins { class ossimGeometricSarSensorModel; class JSDDateTime; } namespace otb { class ImageKeywordlist; /** * \class PlatformPositionAdapter * \brief Wrapper class to access the platform position from ossim * * This class is intended to be used in an InSAR setting to get * information relative to the baseline. If necessary, it could be * extended to non SAR models, but the optical ossim classes would * need to be modified. * * \ingroup OTBOSSIMAdapters **/ class OTBOSSIMAdapters_EXPORT PlatformPositionAdapter: public itk::Object { public: /** Standard class typedefs. */ typedef PlatformPositionAdapter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PlatformPositionAdapter, itk::Object); void CreateSensorModel(const ImageKeywordlist& image_kwl); /** Get the platform position and speed for a given line. */ void GetPlatformPosition( double line, std::vector& position, std::vector& speed); /** Get the platform position at a given date and time. */ void GetPlatformPositionAtTime( ossimplugins::JSDDateTime time, std::vector& position, std::vector& speed); protected: PlatformPositionAdapter(); ~PlatformPositionAdapter() ITK_OVERRIDE; private: PlatformPositionAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ossimplugins::ossimGeometricSarSensorModel* m_SensorModel; }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbRPCSolverAdapter.h000066400000000000000000000054611301006202600265760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRPCSolverAdapter_h #define otbRPCSolverAdapter_h #include #include "itkObject.h" #include "itkObjectFactory.h" #include "itkPoint.h" #include "itkSize.h" #include "OTBOSSIMAdaptersExport.h" class ossimRpcSolver; namespace otb { class ImageKeywordlist; /** \class RPCSolverAdapter * \brief This is a dummy class to expose the RPC solving function * * This class defines some typedefs and exposes the RPC solving functions. * * \sa GCPsToRPCSensorModelImageFilter * * \ingroup OTBOSSIMAdapters **/ class OTBOSSIMAdapters_EXPORT RPCSolverAdapter { public: /** Standard class typedefs. */ typedef RPCSolverAdapter Self; typedef itk::Point Point2DType; typedef itk::Point Point3DType; typedef std::pair GCPType; typedef std::vector GCPsContainerType; /** Solve RPC modelling from a set of GCPs and image bounds. * The estimated RPC model is written in a keywordlist understood * by other OTB and classes (like GenericRSTransform for instance). * Please note that at least 20 points are required to estimate the * RPC model. Between 20 and 40 points, the estimated model will * not provide elevation support, since there are not enough points * to estimate all the coefficients. Starting at 40 points, a full * RPC model is estimated. */ static void Solve(const GCPsContainerType& gcpContainer, double& rmsError, ImageKeywordlist& otb_kwl); /** Solve RPC modelling from a set of GCPs and image bounds. The * estimated RPC model is written to a geom file. */ static bool Solve(const GCPsContainerType& gcpContainer, double& rmsError, const std::string & outgeom); private: RPCSolverAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented RPCSolverAdapter(); // purposely not implemented, this class defines // typedefs and exposes static methods virtual ~RPCSolverAdapter(); // purposely not implemented, this class defines // typedefs and exposes static methods }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/include/otbSensorModelAdapter.h000066400000000000000000000077641301006202600272210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSensorModelAdapter_h #define otbSensorModelAdapter_h #include "otbDEMHandler.h" class ossimProjection; class ossimTieGptSet; namespace otb { class ImageKeywordlist; /** * \class SensorModelAdapter * \brief Wrapper class to group all dependencies to ossim for sensor models * * This class is NOT intended to be used outside of OTB. Use the * InverseSensorModel and ForwardSensorModel. If you feel that you need to use * it directly, think again! * * \sa InverseSensorModel * \sa ForwardSensorModel * \ingroup Projection * * * \ingroup OTBOSSIMAdapters **/ class OTBOSSIMAdapters_EXPORT SensorModelAdapter: public itk::Object { public: /** Standard class typedefs. */ typedef SensorModelAdapter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef ossimProjection* InternalMapProjectionPointer; typedef const ossimProjection* InternalMapProjectionConstPointer; typedef ossimTieGptSet* InternalTiePointsContainerPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SensorModelAdapter, itk::Object); /** Create the projection ( m_Model). Called by the SetImageGeometry methods */ void CreateProjection(const ImageKeywordlist& image_kwl); // FIXME check if it should be protected instead /** Forward sensor modelling with elevation (above ellipsoid) provided by the user */ void ForwardTransformPoint(double x, double y, double z, double& lon, double& lat, double& h) const; /** Forward sensor modelling with elevation (above ellipsoid) estimated by the * algorithm */ void ForwardTransformPoint(double x, double y, double& lon, double& lat, double& h) const; /** Inverse sensor modelling with elevation (above ellipsoid) provided by the user */ void InverseTransformPoint(double lon, double lat, double h, double& x, double& y, double& z) const; /** Inverse sensor modelling with elevation (above ellipsoid) from DEMHandler */ void InverseTransformPoint(double lon, double lat, double& x, double& y, double& z) const; /** Add a tie point with elevation (above ellipsoid) provided by the user */ void AddTiePoint(double x, double y, double z, double lon, double lat); /** Add a tie point with elevation (above ellipsoid) from DEMHandler */ void AddTiePoint(double x, double y, double lon, double lat); /** Clear all tie points */ void ClearTiePoints(); /** Optimize sensor model with respect to tie points */ double Optimize(); /** Is sensor model valid method. return false if the m_SensorModel is null*/ bool IsValidSensorModel() const; /** Read geom file and instantiate sensor model */ bool ReadGeomFile(const std::string & infile); /** Write geom file corresponding to sensor model */ bool WriteGeomFile(const std::string& outfile); protected: SensorModelAdapter(); ~SensorModelAdapter() ITK_OVERRIDE; private: SensorModelAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InternalMapProjectionPointer m_SensorModel; InternalTiePointsContainerPointer m_TiePoints; /** Object that read and use DEM */ DEMHandler::Pointer m_DEMHandler; }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OSSIMAdapters/otb-module.cmake000066400000000000000000000010241301006202600242150ustar00rootroot00000000000000set(DOCUMENTATION "Adapters for the OSSIM library (geospatial library used to process imagery, maps, terrain, and vector data). It is used inside OTB for several purposes: sensor models (especially RPC), metadata parsers, DEM handlers, and so on.") otb_module(OTBOSSIMAdapters ENABLE_SHARED DEPENDS OTBOpenThreads OTBITK OTBCommon OTBGDAL OTBOssimPlugins OTBOssim TEST_DEPENDS OTBTestKernel OTBImageBase OTBImageIO OTBTransform OTBProjection DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/000077500000000000000000000000001301006202600217365ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/CMakeLists.txt000066400000000000000000000011661301006202600245020ustar00rootroot00000000000000set(OTBOSSIMAdapters_SRC otbDEMHandler.cxx otbImageKeywordlist.cxx otbGeometricSarSensorModelAdapter.cxx otbSensorModelAdapter.cxx otbPlatformPositionAdapter.cxx otbDEMConvertAdapter.cxx otbRPCSolverAdapter.cxx otbDateTimeAdapter.cxx otbMapProjectionAdapter.cxx otbFilterFunctionValues.cxx otbMetaDataKey.cxx otbEllipsoidAdapter.cxx ) add_library(OTBOSSIMAdapters ${OTBOSSIMAdapters_SRC}) target_link_libraries(OTBOSSIMAdapters ${OTBGDAL_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBOssim_LIBRARIES} ${OTBOssimPlugins_LIBRARIES} ${OTBOpenThreads_LIBRARIES} ) otb_module_target(OTBOSSIMAdapters) OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbDEMConvertAdapter.cxx000066400000000000000000000115141301006202600264400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDEMConvertAdapter.h" #include "itkMacro.h" // OSSIM include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/base/ossimKeywordNames.h" #include "ossim/base/ossimStdOutProgress.h" #include "ossim/base/ossimFilename.h" #include "ossim/base/ossimKeywordlist.h" #include "ossim/imaging/ossimJpegWriter.h" #include "ossim/imaging/ossimImageHandler.h" #include "ossim/imaging/ossimImageSource.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #include "ossim/imaging/ossimImageWriterFactoryRegistry.h" #include "ossim/imaging/ossimImageWriterFactory.h" #include "ossim/imaging/ossimImageFileWriter.h" #include "ossim/imaging/ossimCacheTileSource.h" #include "ossim/imaging/ossimBandSelector.h" #include "ossim/imaging/ossimCibCadrgTileSource.h" #pragma GCC diagnostic pop #else #include "ossim/base/ossimKeywordNames.h" #include "ossim/base/ossimStdOutProgress.h" #include "ossim/base/ossimFilename.h" #include "ossim/base/ossimKeywordlist.h" #include "ossim/imaging/ossimJpegWriter.h" #include "ossim/imaging/ossimImageHandler.h" #include "ossim/imaging/ossimImageSource.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #include "ossim/imaging/ossimImageWriterFactoryRegistry.h" #include "ossim/imaging/ossimImageWriterFactory.h" #include "ossim/imaging/ossimImageFileWriter.h" #include "ossim/imaging/ossimCacheTileSource.h" #include "ossim/imaging/ossimBandSelector.h" #include "ossim/imaging/ossimCibCadrgTileSource.h" #endif namespace otb { DEMConvertAdapter::DEMConvertAdapter() {} DEMConvertAdapter::~DEMConvertAdapter() {} int DEMConvertAdapter::Convert(std::string tempFilename, std::string output) { // Keyword list to initialize image writers with. ossimKeywordlist kwl; const char* PREFIX = "imagewriter."; // Define the output file type std::string output_type("general_raster_bsq_envi"); kwl.add(PREFIX, ossimKeywordNames::TYPE_KW, output_type.c_str(), true); // Get an image handler for the input file. ossimRefPtr ih = ossimImageHandlerRegistry::instance()->open(ossimString(tempFilename)); // Initialize the if (ih->getErrorStatus() == ossimErrorCodes::OSSIM_ERROR) { itkExceptionMacro("Error reading image: " << tempFilename << "Exiting application..."); return EXIT_FAILURE; } ih->initialize(); ossimRefPtr source = ih.get(); ossimRefPtr bs = ITK_NULLPTR; // Get the image rectangle for the rrLevel selected. ossimIrect output_rect; output_rect = source->getBoundingRect(0); ossimRefPtr writer = ossimImageWriterFactoryRegistry::instance()->createWriter(kwl, PREFIX); writer->connectMyInputTo(0, source.get()); writer->open(ossimFilename(output)); // Add a listener to get percent complete. ossimStdOutProgress prog(0, true); writer->addListener(&prog); if (writer->getErrorStatus() == ossimErrorCodes::OSSIM_OK) { if( (ih->getOutputScalarType() != OSSIM_UCHAR) && (PTR_CAST(ossimJpegWriter, writer.get()) ) ) { writer->setScaleToEightBitFlag(true); } ossimRefPtr cache = new ossimCacheTileSource; ossimIpt tileWidthHeight(ih->getImageTileWidth(), ih->getImageTileHeight()); // only use the cache if its stripped if(static_cast(tileWidthHeight.x) == ih->getBoundingRect().width()) { cache->connectMyInputTo(0, source.get()); cache->setTileSize(tileWidthHeight); writer->connectMyInputTo(0, cache.get()); } else { writer->connectMyInputTo(0, source.get()); } writer->initialize(); writer->setAreaOfInterest(output_rect); // Set the output rectangle. try { writer->execute(); } catch(std::exception& e) { std::cerr << "std::exception thrown:" << std::endl; std::cerr << e.what() << std::endl; itkExceptionMacro("Error occurs writing the output image..."); return EXIT_FAILURE; } } else { itkExceptionMacro("Error detected in the image writer..."); return EXIT_FAILURE; } return EXIT_SUCCESS; } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbDEMHandler.cxx000066400000000000000000000170541301006202600251010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDEMHandler.h" #include "otbMacro.h" #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/elevation/ossimElevManager.h" #include "ossim/base/ossimGeoidManager.h" #include "ossim/base/ossimFilename.h" #include "ossim/base/ossimDirectory.h" #include "ossim/base/ossimGeoidEgm96.h" #include "ossim/base/ossimRefPtr.h" #include #pragma GCC diagnostic pop #else #include "ossim/elevation/ossimElevManager.h" #include "ossim/base/ossimGeoidManager.h" #include "ossim/base/ossimFilename.h" #include "ossim/base/ossimDirectory.h" #include "ossim/base/ossimGeoidEgm96.h" #include "ossim/base/ossimRefPtr.h" #include #endif namespace otb { /** Initialize the singleton */ DEMHandler::Pointer DEMHandler::m_Singleton = ITK_NULLPTR; DEMHandler::Pointer DEMHandler::Instance() { if(m_Singleton.GetPointer() == ITK_NULLPTR) { m_Singleton = itk::ObjectFactory::Create(); if(m_Singleton.GetPointer() == ITK_NULLPTR) { m_Singleton = new DEMHandler; } m_Singleton->UnRegister(); } return m_Singleton; } DEMHandler ::DEMHandler() : m_GeoidFile(""), m_DefaultHeightAboveEllipsoid(0) { assert( ossimElevManager::instance()!=NULL ); ossimElevManager::instance()->setDefaultHeightAboveEllipsoid(m_DefaultHeightAboveEllipsoid); // Force geoid fallback ossimElevManager::instance()->setUseGeoidIfNullFlag(true); } void DEMHandler ::OpenDEMDirectory(const char* DEMDirectory) { assert( ossimElevManager::instance()!=NULL ); ossimFilename ossimDEMDir( DEMDirectory ); if (!ossimElevManager::instance()->loadElevationPath(ossimDEMDir)) { // In ossim elevation database factory code, the // ossimImageElevationDatabase is explicitly disabled by a #if 0 // guard, because it causes problem when loading ossim related // application. Therefore, we explicitly call // ossimImageElevationDatabase here to allow for general elevation // images support. ossimRefPtr imageElevationDatabase = new ossimImageElevationDatabase; if(!imageElevationDatabase->open(DEMDirectory)) { itkExceptionMacro("Failed to open DEM Directory: " << ossimDEMDir); } else { otbMsgDevMacro(<< "DEM directory contains general elevation image files: " << ossimDEMDir); ossimElevManager::instance()->addDatabase(imageElevationDatabase.get()); } } } void DEMHandler ::ClearDEMs() { assert( ossimElevManager::instance()!=NULL ); ossimElevManager::instance()->clear(); } void DEMHandler ::OpenDEMDirectory(const std::string& DEMDirectory) { OpenDEMDirectory(DEMDirectory.c_str()); } bool DEMHandler ::IsValidDEMDirectory(const char* DEMDirectory) { assert( ossimElevManager::instance()!=NULL ); //Try to load elevation source bool result = ossimElevManager::instance()->loadElevationPath(DEMDirectory); if (!result) { // we explicitly call ossimImageElevationDatabase here to allow for general elevation // images support and test the open method to check if the directory . ossimRefPtr imageElevationDatabase = new ossimImageElevationDatabase; result = imageElevationDatabase->open(DEMDirectory); } return result; } bool DEMHandler ::OpenGeoidFile(const char* geoidFile) { if ((ossimGeoidManager::instance()->findGeoidByShortName("geoid1996")) == ITK_NULLPTR) { otbMsgDevMacro(<< "Opening geoid: " << geoidFile); ossimFilename geoid(geoidFile); ossimRefPtr geoidPtr = new ossimGeoidEgm96(geoid); if (geoidPtr->getErrorStatus() == ossimErrorCodes::OSSIM_OK) { // Ossim does not allow retrieving the geoid file path // We therefore must keep it on our side m_GeoidFile = geoidFile; otbMsgDevMacro(<< "Geoid successfully opened"); ossimGeoidManager::instance()->addGeoid(geoidPtr); geoidPtr.release(); // The previous flag will be ignored if // defaultHeightAboveEllipsoid is not NaN assert( ossimElevManager::instance()!=NULL ); ossimElevManager::instance()->setDefaultHeightAboveEllipsoid(ossim::nan()); return true; } else { otbMsgDevMacro(<< "Failure opening geoid"); geoidPtr.release(); itkExceptionMacro( << "Failed to open geoid file: '" << geoidFile << "'" ); return false; } } return false; } bool DEMHandler ::OpenGeoidFile(const std::string& geoidFile) { return OpenGeoidFile(geoidFile.c_str()); } double DEMHandler ::GetHeightAboveMSL(double lon, double lat) const { double height; ossimGpt ossimWorldPoint; ossimWorldPoint.lon = lon; ossimWorldPoint.lat = lat; assert( ossimElevManager::instance()!=NULL ); height = ossimElevManager::instance()->getHeightAboveMSL(ossimWorldPoint); return height; } double DEMHandler ::GetHeightAboveMSL(const PointType& geoPoint) const { return GetHeightAboveMSL(geoPoint[0], geoPoint[1]); } double DEMHandler ::GetHeightAboveEllipsoid(double lon, double lat) const { double height; ossimGpt ossimWorldPoint; ossimWorldPoint.lon = lon; ossimWorldPoint.lat = lat; assert( ossimElevManager::instance()!=NULL ); height = ossimElevManager::instance()->getHeightAboveEllipsoid(ossimWorldPoint); return height; } double DEMHandler ::GetHeightAboveEllipsoid(const PointType& geoPoint) const { return GetHeightAboveEllipsoid(geoPoint[0], geoPoint[1]); } void DEMHandler ::SetDefaultHeightAboveEllipsoid(double h) { // Ossim does not allow retrieving the default height above // ellipsoid We therefore must keep it on our side m_DefaultHeightAboveEllipsoid = h; assert( ossimElevManager::instance()!=NULL ); ossimElevManager::instance()->setDefaultHeightAboveEllipsoid(h); } double DEMHandler ::GetDefaultHeightAboveEllipsoid() const { // Ossim does not allow retrieving the default height above // ellipsoid We therefore must keep it on our side return m_DefaultHeightAboveEllipsoid; } unsigned int DEMHandler ::GetDEMCount() const { assert( ossimElevManager::instance()!=NULL ); return ossimElevManager::instance()->getNumberOfElevationDatabases(); } std::string DEMHandler::GetDEMDirectory(unsigned int idx) const { std::string demDir = ""; if(ossimElevManager::instance()->getNumberOfElevationDatabases() > 0) { assert( ossimElevManager::instance()!=NULL ); demDir = ossimElevManager::instance()->getElevationDatabase(idx)->getConnectionString().string(); } return demDir; } std::string DEMHandler::GetGeoidFile() const { // Ossim does not allow retrieving the geoid file path // We therefore must keep it on our side return m_GeoidFile; } void DEMHandler ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "DEMHandler" << std::endl; } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbDateTimeAdapter.cxx000066400000000000000000000030211301006202600261600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDateTimeAdapter.h" #include "ossim/base/ossimDate.h" namespace otb { DateTimeAdapter::DateTimeAdapter() { m_LocalTm = new ossimLocalTm(0); } DateTimeAdapter::~DateTimeAdapter() { if (m_LocalTm != ITK_NULLPTR) { delete m_LocalTm; } } int DateTimeAdapter::GetYear() { return m_LocalTm->getYear(); } int DateTimeAdapter::GetMonth() { return m_LocalTm->getMonth(); } int DateTimeAdapter::GetDay() { return m_LocalTm->getDay(); } int DateTimeAdapter::GetHour() { return m_LocalTm->getHour(); } int DateTimeAdapter::GetMinute() { return m_LocalTm->getMin(); } double DateTimeAdapter::GetSeconds() const { return static_cast(m_LocalTm->getSec()) + m_LocalTm->getFractionalSecond(); } bool DateTimeAdapter::SetFromIso8601(const std::string &date) { return m_LocalTm->setIso8601(date); } double DateTimeAdapter::GetDeltaInSeconds(const DateTimeAdapter *pastDate) { return ( this->GetSeconds() - pastDate->GetSeconds() ); } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbEllipsoidAdapter.cxx000066400000000000000000000032661301006202600264230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbEllipsoidAdapter.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/base/ossimEllipsoid.h" #pragma GCC diagnostic pop #else #include "ossim/base/ossimEllipsoid.h" #endif namespace otb { EllipsoidAdapter::EllipsoidAdapter() { m_Ellipsoid = new ossimEllipsoid(); } EllipsoidAdapter::~EllipsoidAdapter() { if (m_Ellipsoid != ITK_NULLPTR) { delete m_Ellipsoid; } } void EllipsoidAdapter::XYZToLonLatHeight(double x, double y, double z, double& lon, double& lat, double& h) const { // Note the lat/lon convension for ossim vs lon/lat for OTB m_Ellipsoid->XYZToLatLonHeight(x, y, z, lat, lon, h); } void EllipsoidAdapter::LonLatHeightToXYZ(double lon, double lat, double h, double& x, double& y, double& z) const { // Note the lat/lon convension for ossim vs lon/lat for OTB m_Ellipsoid->latLonHeightToXYZ(lat, lon, h, x, y, z); } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbFilterFunctionValues.cxx000066400000000000000000000054771301006202600273170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFilterFunctionValues.h" #include namespace otb { /*********************** FilterFunctionValues **************************/ FilterFunctionValues ::FilterFunctionValues() { m_MinSpectralValue = 0.3; m_MaxSpectralValue = 1; // Fill with 1. Size 3 for 6S interpolation m_FilterFunctionValues = ValuesVectorType(280, 1.); m_UserStep = 0.0025; } FilterFunctionValues::WavelengthSpectralBandType FilterFunctionValues ::GetCenterSpectralValue() const { // The computation is done by taking the weighted average of the // filter. The computation is done each time the value is requested. // It is anticipated that this method won't be called much and that // the cost will be negligible compared to the rest of the processing WavelengthSpectralBandType total = 0; for (unsigned int i = 0; i < m_FilterFunctionValues6S.size(); ++i) { total += m_FilterFunctionValues6S[i]; } unsigned int centerIndex = 0; WavelengthSpectralBandType total2 = 0; for (centerIndex = 0; centerIndex < m_FilterFunctionValues6S.size(); ++centerIndex) { total2 += m_FilterFunctionValues6S[centerIndex]; if (total2 > total / 2) break; } return m_MinSpectralValue + 0.0025 * centerIndex; } /**PrintSelf method */ void FilterFunctionValues ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "Minimum spectral value : " << m_MinSpectralValue << std::endl; os << indent << "Maximum spectral value : " << m_MaxSpectralValue << std::endl; os << indent << "Wavelength spectral band step: " << m_UserStep << std::endl; os << indent << "Filter function values: " << std::endl; os << std::scientific; for (unsigned int i = 0; i < m_FilterFunctionValues.size(); ++i) { if ( i%6 == 0 && i >= 6) { os << std::endl; } os << indent << m_FilterFunctionValues[i]; } os << std::endl; //Default notation for floating point value can be selected by //calling str.unsetf(ios_base::floatfield) os.unsetf(std::ios_base::floatfield); // os << indent << "6S Filter function values: " << std::endl; // for (unsigned int i = 0; i < m_FilterFunctionValues6S.size(); ++i) // { // os << indent << m_FilterFunctionValues6S[i] << std::endl; // } } } // end namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbGeometricSarSensorModelAdapter.cxx000066400000000000000000000046651301006202600312420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeometricSarSensorModelAdapter.h" #include "otbMacro.h" #include "otbImageKeywordlist.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/ossimGeometricSarSensorModel.h" #include "ossim/projection/ossimProjection.h" #include "ossim/ossimPluginProjectionFactory.h" #include "ossim/otb/JSDDateTime.h" #pragma GCC diagnostic pop #else #include "ossim/ossimGeometricSarSensorModel.h" #include "ossim/projection/ossimProjection.h" #include "ossim/ossimPluginProjectionFactory.h" #include "ossim/otb/JSDDateTime.h" #endif namespace otb { GeometricSarSensorModelAdapter::GeometricSarSensorModelAdapter(): m_SensorModel(ITK_NULLPTR) { } GeometricSarSensorModelAdapter::~GeometricSarSensorModelAdapter() { if (m_SensorModel != ITK_NULLPTR) { delete m_SensorModel; m_SensorModel = ITK_NULLPTR; } } void GeometricSarSensorModelAdapter::CreateSensorModel(const ImageKeywordlist& image_kwl) { ossimKeywordlist geom; image_kwl.convertToOSSIMKeywordlist(geom); otbMsgDevMacro(<< "CreateSensorModel()"); otbMsgDevMacro(<< "* type: " << geom.find("type")); ossimProjection* sensor = ossimplugins::ossimPluginProjectionFactory::instance()->createProjection(geom); m_SensorModel = dynamic_cast(sensor); if (!m_SensorModel) { otbMsgDevMacro(<< "CreateSensorModel() failed"); } } ossimplugins::JSDDateTime GeometricSarSensorModelAdapter::getTime(double line) { return m_SensorModel->getTime(line); } void GeometricSarSensorModelAdapter::GetPlatformPositionAtLine( double line, std::vector& position, std::vector& speed) { m_SensorModel->getPlatformPositionAtLine(line, position, speed); } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbImageKeywordlist.cxx000066400000000000000000000401331301006202600264530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageKeywordlist.h" #include #include "otbMacro.h" #include "gdal_priv.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/base/ossimKeywordlist.h" #include "ossim/base/ossimString.h" #include "ossim/ossimPluginProjectionFactory.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #include "ossim/ossimTileMapModel.h" #include "ossim/projection/ossimProjectionFactoryRegistry.h" #include "ossim/projection/ossimRpcModel.h" #pragma GCC diagnostic pop #else #include "ossim/base/ossimKeywordlist.h" #include "ossim/base/ossimString.h" #include "ossim/ossimPluginProjectionFactory.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #include "ossim/ossimTileMapModel.h" #include "ossim/projection/ossimProjectionFactoryRegistry.h" #include "ossim/projection/ossimRpcModel.h" #endif #include "otbSensorModelAdapter.h" #include #include namespace otb { ImageKeywordlist ::ImageKeywordlist() { } ImageKeywordlist ::ImageKeywordlist(const Self& p) : m_Keywordlist(p.m_Keywordlist) { } ImageKeywordlist ::~ImageKeywordlist() { } void ImageKeywordlist:: operator =(const Self& p) { m_Keywordlist = p.m_Keywordlist; } bool ImageKeywordlist ::operator ==(const Self& p) const { return m_Keywordlist == p.m_Keywordlist; } void ImageKeywordlist:: SetKeywordlist(const ossimKeywordlist& kwl) { m_Keywordlist = kwl.getMap(); } const std::string& ImageKeywordlist:: GetMetadataByKey(const std::string& key) const { // Search for the key in the output map KeywordlistMap::const_iterator it = m_Keywordlist.find(key); // If the key can not be found, throw an exception if (it == m_Keywordlist.end()) { itkGenericExceptionMacro(<< "Keywordlist has no output with key " << key); } // Then if everything is ok, return the ossimString return it->second; } bool ImageKeywordlist:: HasKey(const std::string& key) const { KeywordlistMap::const_iterator it = m_Keywordlist.find(key); return (it != m_Keywordlist.end()); } void ImageKeywordlist:: ClearMetadataByKey(const std::string& key) { m_Keywordlist[key] = ""; } void ImageKeywordlist:: AddKey(const std::string& key, const std::string& value) { m_Keywordlist[key] = value; } void ImageKeywordlist:: convertToOSSIMKeywordlist(ossimKeywordlist& kwl) const { kwl.getMap() = m_Keywordlist; } bool ImageKeywordlist:: convertToGDALRPC(GDALRPCInfo &rpc) const { /* ossimRpcModel::loadState() actually expects certain keyword values to be * present in the keywordlist. So We check a single keyword value * (polynomial_format) first. Even though it is not enough to ensure a valid * ossimRpcModel by checking for presence of one single key but atleast we * are sure about not to create an ossimRpcModel. * * The current mechanism creates ossimRpcModel instance, calls loadState() * and fails. The below check for 'polynomial_format' save us from creating * an ossimRpcModel which will be invalid if the 'polynomial_format' is not * present. */ if( m_Keywordlist.find("polynomial_format") != m_Keywordlist.end() ) { ossimKeywordlist geom_kwl; this->convertToOSSIMKeywordlist(geom_kwl); ossimRefPtr rpcModel = new ossimRpcModel; if (rpcModel->loadState(geom_kwl)) { ossimRpcModel::rpcModelStruct ossimRpcStruct; rpcModel->getRpcParameters(ossimRpcStruct); if (ossimRpcStruct.type == 'B') { rpc.dfSAMP_OFF = ossimRpcStruct.sampOffset; rpc.dfLINE_OFF = ossimRpcStruct.lineOffset; rpc.dfSAMP_SCALE = ossimRpcStruct.sampScale; rpc.dfLINE_SCALE = ossimRpcStruct.lineScale; rpc.dfLAT_OFF = ossimRpcStruct.latOffset; rpc.dfLONG_OFF = ossimRpcStruct.lonOffset; rpc.dfHEIGHT_OFF = ossimRpcStruct.hgtOffset; rpc.dfLAT_SCALE = ossimRpcStruct.latScale; rpc.dfLONG_SCALE = ossimRpcStruct.lonScale; rpc.dfHEIGHT_SCALE = ossimRpcStruct.hgtScale; memcpy(rpc.adfLINE_NUM_COEFF, ossimRpcStruct.lineNumCoef, sizeof(double) * 20); memcpy(rpc.adfLINE_DEN_COEFF, ossimRpcStruct.lineDenCoef, sizeof(double) * 20); memcpy(rpc.adfSAMP_NUM_COEFF, ossimRpcStruct.sampNumCoef, sizeof(double) * 20); memcpy(rpc.adfSAMP_DEN_COEFF, ossimRpcStruct.sampDenCoef, sizeof(double) * 20); return true; } } } return false; } void ImageKeywordlist:: Print(std::ostream& os, itk::Indent indent) const { this->PrintSelf(os, indent.GetNextIndent()); } void ImageKeywordlist:: PrintSelf(std::ostream& os, itk::Indent indent) const { ossimKeywordlist kwl; convertToOSSIMKeywordlist(kwl); os << indent << " Ossim Keyword list:" << std::endl; os << indent << kwl; } std::ostream & operator <<(std::ostream& os, const ImageKeywordlist& kwl) { kwl.Print(os); return os; } ImageKeywordlist ReadGeometry(const std::string& filename) { return ReadGeometryFromImage(filename); } ImageKeywordlist ReadGeometryFromImage(const std::string& filename, bool checkRpcTag) { // Trying to read ossim MetaData bool hasMetaData = false; ossimKeywordlist geom_kwl; // = new ossimKeywordlist(); ImageKeywordlist otb_kwl; /****************************************************/ /* First try : test the OSSIM plugins factory */ /****************************************************/ { /** Before, the pluginfactory was tested if the ossim one returned false. But in the case TSX, the images tif were considered as ossimQuickbirdTiffTileSource thus a TSX tif image wasn't read with TSX Model. We don't use the ossimRegisteryFactory because the default include factory contains ossimQuickbirdTiffTileSource. */ boost::scoped_ptr projection(ossimplugins::ossimPluginProjectionFactory::instance() ->createProjection(ossimFilename(filename.c_str()), 0)); if (projection) { otbMsgDevMacro(<< "OSSIM plugin projection instantiated ! "); hasMetaData = projection->saveState(geom_kwl); otb_kwl.SetKeywordlist(geom_kwl); } } /***********************************************/ /* Second try : the OSSIM projection factory */ /***********************************************/ if (!hasMetaData) { boost::scoped_ptr handler(ossimImageHandlerRegistry::instance() ->open(ossimFilename(filename.c_str()))); if (handler) { otbMsgDevMacro(<< "OSSIM Open Image SUCCESS ! "); // Add ossimPlugins model ossimProjectionFactoryRegistry::instance()->registerFactory(ossimplugins::ossimPluginProjectionFactory::instance()); ossimRefPtr geom = handler->getImageGeometry(); if (geom.valid()) { ossimProjection const* projection = geom->getProjection(); if (projection) { hasMetaData = projection->saveState(geom_kwl); // if the handler has found a sensor model, copy the tags found if (hasMetaData && dynamic_cast(projection)) { otbMsgDevMacro(<<"OSSIM sensor projection instantiated ! "); otb_kwl.SetKeywordlist(geom_kwl); // geom_kwl.print(std::cout); } else { hasMetaData = false; } } // projection } // geom.valid } // handler } /**********************************************************/ /* Third try : look for external geom file and RPC tags */ /**********************************************************/ if (!hasMetaData) { // If still no metadata, try the ".geom" file ossimFilename ossimGeomFile = ossimFilename(filename).setExtension(".geom"); otb_kwl = ReadGeometryFromGEOMFile(ossimGeomFile); // also check any RPC tags ImageKeywordlist rpc_kwl; if (checkRpcTag) { rpc_kwl = ReadGeometryFromRPCTag(filename); } if (otb_kwl.HasKey("type")) { // external geom has a "type" keyword std::string geomType(otb_kwl.GetMetadataByKey("type")); ossimProjection *testProj = ossimProjectionFactoryRegistry::instance() ->createProjection(ossimString(geomType)); if (dynamic_cast(testProj)) { // "type" keyword corresponds to a sensor model : don't erase it if (rpc_kwl.GetSize() > 0) { rpc_kwl.ClearMetadataByKey("type"); } ossimKeywordlist ossim_test_kwl; otb_kwl.convertToOSSIMKeywordlist(ossim_test_kwl); testProj = ossimProjectionFactoryRegistry::instance() ->createProjection(ossim_test_kwl); if (testProj) { // external geom contains a valid sensor geometry hasMetaData = true; } } } // copy keywords found in RPC tags if the external geom is not valid if (!hasMetaData && rpc_kwl.GetSize() > 0) { const ImageKeywordlist::KeywordlistMap &kwlMap = rpc_kwl.GetKeywordlist(); for (ImageKeywordlist::KeywordlistMap::const_iterator it = kwlMap.begin(); it != kwlMap.end(); ++it) { if (it->second != "") { otb_kwl.AddKey(it->first , it->second); } } hasMetaData = true; } } // In some corner cases, ossim is unable to create a ossimImageHandler // instance for the provided file. // This can happen for TIFF+geom files where the ossimTiffTileSource // fails when trying to open the TIFF file (for example // because ossim is compiled with a libtiff without BigTIFF support // and when the actual TIFF file exceeds the Large File limit). // In such cases, we don't actually need ossim to interpret the TIFF file, // and just want a valid ossimKeywordlist corresponding to a sensor model. // Here is implemented a shortcut used as a fallback scenario, // where we bypass the ossimImageHandlerRegistry // and directly create a ossimKeywordlist from the ".geom" file. // We then verify it is a valid sensor model by using otb::SensorModelAdapter // which uses ossimSensorModelFactory and ossimPluginProjectionFactory internally, // thus by-passing the need for a valid ossimImageHandler. if (!hasMetaData) { otbMsgDevMacro(<< "OSSIM MetaData not present ! "); } else { otbMsgDevMacro(<< "OSSIM MetaData present ! "); //otbMsgDevMacro(<< geom_kwl); } return otb_kwl; } ImageKeywordlist ReadGeometryFromGEOMFile(const std::string& filename) { ossimKeywordlist geom_kwl; ImageKeywordlist otb_kwl; ossimFilename ossimGeomFile = ossimFilename(filename); if (ossimGeomFile.exists() && ossimGeomFile.isFile()) { // Interpret the geom file as a KWL ossimKeywordlist kwl(ossimGeomFile); // Check that the geom file results in a valid ossimKeywordlist if (kwl.getErrorStatus() == ossimErrorCodes::OSSIM_OK) { // // Be sure there is a corresponding instance of ossimSensorModel // // which understands this kwl // SensorModelAdapter::Pointer sensorModel = SensorModelAdapter::New(); // ImageKeywordlist otbkwl; // otbkwl.SetKeywordlist(kwl); // sensorModel->CreateProjection(otbkwl); // // if (sensorModel->IsValidSensorModel()) // { // geom_kwl = kwl; // } geom_kwl = kwl; } } otb_kwl.SetKeywordlist(geom_kwl); return otb_kwl; } ImageKeywordlist ReadGeometryFromRPCTag(const std::string& filename) { ossimKeywordlist geom_kwl; ImageKeywordlist otb_kwl; // try to use GeoTiff RPC tag if present. // Warning : RPC in subdatasets are not supported GDALDriverH identifyDriverH = GDALIdentifyDriver(filename.c_str(), ITK_NULLPTR); if(identifyDriverH == ITK_NULLPTR) { // If no driver has identified the dataset, don't try to open it and exit return otb_kwl; } GDALDatasetH datasetH = GDALOpen(filename.c_str(), GA_ReadOnly); if (datasetH != ITK_NULLPTR) { GDALDataset* dataset = static_cast(datasetH); GDALRPCInfo rpcStruct; if (GDALExtractRPCInfo(dataset->GetMetadata("RPC"),&rpcStruct)) { otbMsgDevMacro(<<"RPC Coeff found"); std::vector lineNumCoefs; std::vector lineDenCoefs; std::vector sampNumCoefs; std::vector sampDenCoefs; for (unsigned int k=0; k<20; ++k) { lineNumCoefs.push_back(rpcStruct.adfLINE_NUM_COEFF[k]); lineDenCoefs.push_back(rpcStruct.adfLINE_DEN_COEFF[k]); sampNumCoefs.push_back(rpcStruct.adfSAMP_NUM_COEFF[k]); sampDenCoefs.push_back(rpcStruct.adfSAMP_DEN_COEFF[k]); } ossimRefPtr rpcModel = new ossimRpcModel; rpcModel->setAttributes( rpcStruct.dfSAMP_OFF, rpcStruct.dfLINE_OFF, rpcStruct.dfSAMP_SCALE, rpcStruct.dfLINE_SCALE, rpcStruct.dfLAT_OFF, rpcStruct.dfLONG_OFF, rpcStruct.dfHEIGHT_OFF, rpcStruct.dfLAT_SCALE, rpcStruct.dfLONG_SCALE, rpcStruct.dfHEIGHT_SCALE, sampNumCoefs, sampDenCoefs, lineNumCoefs, lineDenCoefs); double errorBias = 0.0; double errorRand = 0.0; // setup other metadata rpcModel->setPositionError(errorBias,errorRand,true); ossimDrect rectangle(0.0, 0.0, static_cast(dataset->GetRasterXSize()-1), static_cast(dataset->GetRasterYSize()-1)); rpcModel->setImageRect(rectangle); ossimDpt size; size.line = rectangle.height(); size.samp = rectangle.width(); rpcModel->setImageSize(size); // Compute 4 corners and reference point rpcModel->updateModel(); double heightOffset = rpcStruct.dfHEIGHT_OFF; ossimGpt ulGpt, urGpt, lrGpt, llGpt; ossimGpt refGndPt; rpcModel->lineSampleHeightToWorld(rectangle.ul(), heightOffset, ulGpt); rpcModel->lineSampleHeightToWorld(rectangle.ur(), heightOffset, urGpt); rpcModel->lineSampleHeightToWorld(rectangle.lr(), heightOffset, lrGpt); rpcModel->lineSampleHeightToWorld(rectangle.ll(), heightOffset, llGpt); rpcModel->setGroundRect(ulGpt,urGpt,lrGpt,llGpt); rpcModel->lineSampleHeightToWorld(rectangle.midPoint(), heightOffset, refGndPt); rpcModel->setRefGndPt(refGndPt); // compute ground sampling distance try { // Method can throw ossimException. rpcModel->computeGsd(); } catch (const ossimException& itkNotUsed(e)) { otbMsgDevMacro(<< "OSSIM Compute ground sampling distance FAILED ! "); } if (rpcModel->saveState(geom_kwl)) { otb_kwl.SetKeywordlist(geom_kwl); } } GDALClose(datasetH); } return otb_kwl; } void WriteGeometry(const ImageKeywordlist& otb_kwl, const std::string& filename) { // Write the image keyword list if any ossimKeywordlist geom_kwl; otb_kwl.convertToOSSIMKeywordlist(geom_kwl); if (geom_kwl.getSize() > 0) { otbMsgDevMacro(<< "Exporting keywordlist ..."); ossimFilename geomFileName(filename); geomFileName.setExtension(".geom"); geom_kwl.write(geomFileName.chars()); } } } //namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbMapProjectionAdapter.cxx000066400000000000000000000403561301006202600272520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMapProjectionAdapter.h" #include #include "otbMacro.h" #include "otbUtils.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/projection/ossimMapProjection.h" #include "ossim/projection/ossimMapProjectionFactory.h" #include "ossim/base/ossimGpt.h" #include "ossim/base/ossimDpt.h" #include "ossim/projection/ossimProjection.h" #include "ossim/base/ossimEllipsoid.h" #include "ossim/base/ossimEllipsoidFactory.h" #include "ossim/base/ossimString.h" #include "gdal/ossimOgcWktTranslator.h" #include "ossim/projection/ossimUtmProjection.h" #include "ossim/projection/ossimLambertConformalConicProjection.h" #include "ossim/projection/ossimTransMercatorProjection.h" #include "ossim/projection/ossimEckert4Projection.h" #include "ossim/projection/ossimMollweidProjection.h" #include "ossim/projection/ossimSinusoidalProjection.h" #include "ossim/support_data/ossimSpaceImagingGeom.h" #include "ossim/base/ossimKeywordNames.h" #pragma GCC diagnostic pop #else #include "ossim/projection/ossimMapProjection.h" #include "ossim/projection/ossimMapProjectionFactory.h" #include "ossim/base/ossimGpt.h" #include "ossim/base/ossimDpt.h" #include "ossim/projection/ossimProjection.h" #include "ossim/base/ossimEllipsoid.h" #include "ossim/base/ossimEllipsoidFactory.h" #include "ossim/base/ossimString.h" #include "gdal/ossimOgcWktTranslator.h" #include "ossim/projection/ossimUtmProjection.h" #include "ossim/projection/ossimLambertConformalConicProjection.h" #include "ossim/projection/ossimTransMercatorProjection.h" #include "ossim/projection/ossimEckert4Projection.h" #include "ossim/projection/ossimMollweidProjection.h" #include "ossim/projection/ossimSinusoidalProjection.h" #include "ossim/support_data/ossimSpaceImagingGeom.h" #include "ossim/base/ossimKeywordNames.h" #endif namespace otb { MapProjectionAdapter::MapProjectionAdapter(): m_MapProjection(ITK_NULLPTR), m_ProjectionRefWkt(""), m_ReinstanciateProjection(true) { } MapProjectionAdapter::~MapProjectionAdapter() { if (m_MapProjection != ITK_NULLPTR) { delete m_MapProjection; } } MapProjectionAdapter::InternalMapProjectionPointer MapProjectionAdapter::GetMapProjection() { itkDebugMacro("returning MapProjection address " << this->m_MapProjection); if ((m_ReinstanciateProjection) || (m_MapProjection == ITK_NULLPTR)) { this->InstantiateProjection(); } return this->m_MapProjection; } MapProjectionAdapter::InternalMapProjectionConstPointer MapProjectionAdapter::GetMapProjection() const { itkDebugMacro("returning MapProjection address " << this->m_MapProjection); if ((m_ReinstanciateProjection) || (m_MapProjection == ITK_NULLPTR)) { itkExceptionMacro(<< "m_MapProjection not up-to-date, call InstantiateProjection() first"); } return this->m_MapProjection; } std::string MapProjectionAdapter::GetWkt() const { ossimKeywordlist kwl; this->GetMapProjection(); if (m_MapProjection == ITK_NULLPTR) { return ""; } m_MapProjection->saveState(kwl); ossimOgcWktTranslator wktTranslator; std::string wkt; wkt = wktTranslator.fromOssimKwl(kwl).chars(); return wkt; } void MapProjectionAdapter::SetWkt(const std::string& projectionRefWkt) { this->m_ProjectionRefWkt = projectionRefWkt; m_ReinstanciateProjection = true; this->InstantiateProjection(); //Should not be needed, but it is... this->Modified(); } void MapProjectionAdapter::SetParameter(const std::string& key, const std::string& value) { m_ParameterStore[key] = value; m_ReinstanciateProjection = true; this->InstantiateProjection(); //Should not be needed, but it is... this->Modified(); } std::string MapProjectionAdapter::GetParameter(const std::string& key) const { // Please refer to the note in the header filer // we do NOT want to read from m_ParameterStore here! std::string projectionName = this->GetMapProjection()->getClassName().string(); // Start by matching generic parameters const ossimMapProjection* projection = dynamic_cast(this->GetMapProjection()); if (key.compare("Origin") == 0) { return Utils::ConvertToString(projection->origin()); } if (key.compare("FalseNorthing") == 0) { return Utils::ConvertToString(projection->getFalseNorthing()); } if (key.compare("FalseEasting") == 0) { return Utils::ConvertToString(projection->getFalseEasting()); } if (key.compare("StandardParallel1") == 0) { return Utils::ConvertToString(projection->getStandardParallel1()); } if (key.compare("StandardParallel2") == 0) { return Utils::ConvertToString(projection->getStandardParallel2()); } if (key.compare("A") == 0) { return Utils::ConvertToString(projection->getA()); } if (key.compare("B") == 0) { return Utils::ConvertToString(projection->getB()); } if (key.compare("F") == 0) { return Utils::ConvertToString(projection->getF()); } if (key.compare("MetersPerPixel") == 0) { return Utils::ConvertToString(projection->getMetersPerPixel()); } if (key.compare("DecimalDegreesPerPixel") == 0) { return Utils::ConvertToString(projection->getDecimalDegreesPerPixel()); } // Apply parameters to transmercator if (projectionName.compare("ossimTransMercatorProjection") == 0) { const ossimTransMercatorProjection* tmProjection = dynamic_cast(this->GetMapProjection()); if (key.compare("ScaleFactor") == 0) { return Utils::ConvertToString(tmProjection->getScaleFactor()); } } // Apply parameters to Utm if (projectionName.compare("ossimUtmProjection") == 0) { const ossimUtmProjection* utmProjection = dynamic_cast(this->GetMapProjection()); if (key.compare("Zone") == 0) { return Utils::ConvertToString(utmProjection->getZone()); } if (key.compare("Hemisphere") == 0) { return Utils::ConvertToString(utmProjection->getHemisphere()); } } return ""; } bool MapProjectionAdapter::InstantiateProjection() { if ((this->m_ReinstanciateProjection) || (m_MapProjection == ITK_NULLPTR)) { ossimKeywordlist kwl; ossimOgcWktTranslator wktTranslator; bool projectionInformationAvailable = wktTranslator.toOssimKwl(m_ProjectionRefWkt, kwl); if (projectionInformationAvailable) { //we don't want to have a ossimEquDistCylProjection here: //see discussion in May 2009 on ossim list; //a better solution might be available... std::string projectionString(kwl.find("type")); if (projectionString.find("ossimEquDistCylProjection") != string::npos) { otbMsgDevMacro(<< "WARNING: Not instantiating a ossimEquDistCylProjection: " << projectionString); otbMsgDevMacro(<< "Wkt was: " << kwl); otbMsgDevMacro(<< "From RefWkt: " << m_ProjectionRefWkt); return false; } m_MapProjection = ossimMapProjectionFactory::instance()->createProjection(kwl); } else { otbMsgDevMacro(<< "WARNING: Impossible to create the projection from Wkt: " << m_ProjectionRefWkt); otbMsgDevMacro(<< "Trying with string as a string (ossimUtmProjection or Utm would qualify"); // Trying directly with the m_ProjectionRefWkt (is // ossimUtmProjection for example) ossimString name(m_ProjectionRefWkt); m_MapProjection = ossimMapProjectionFactory::instance()->createProjection(name); if (m_MapProjection == ITK_NULLPTR) { // Trying directly extending the m_ProjectionRefWkt (convert the // Utm to ossimUtmProjection for example) ossimString extendedName("ossim"); extendedName += m_ProjectionRefWkt; extendedName += "Projection"; m_MapProjection = ossimMapProjectionFactory::instance()->createProjection(extendedName); } if (m_MapProjection == ITK_NULLPTR) return false; } this->m_ReinstanciateProjection = false; this->ApplyParametersToProjection(); return true; } return false; } void MapProjectionAdapter::InverseTransform(double x, double y, double z, double& lon, double& lat, double& h) { if (m_MapProjection == ITK_NULLPTR) { otbMsgDevMacro(<< "WARNING: Using identity"); lon = x; lat = y; h = z; return; } ossimDpt ossimDPoint(x, y); //map projection ossimGpt ossimGPoint; ossimGPoint = this->GetMapProjection()->inverse(ossimDPoint); ossimGPoint.changeDatum(ossimDatumFactory::instance()->wgs84()); lon = ossimGPoint.lon; lat = ossimGPoint.lat; h = z; } void MapProjectionAdapter::ForwardTransform(double lon, double lat, double h, double& x, double& y, double& z) { if (m_MapProjection == ITK_NULLPTR) { otbMsgDevMacro(<< "WARNING: Using identity"); x = lon; y = lat; z = h; return; } ossimGpt ossimGPoint(lat, lon, h); //map projection ossimDpt ossimDPoint; ossimDPoint = this->GetMapProjection()->forward(ossimGPoint); x = ossimDPoint.x; y = ossimDPoint.y; z = h; } void MapProjectionAdapter::ApplyParametersToProjection() { // Start by identifying the projection, that will be necessary for // the casting. std::string projectionName = this->GetMapProjection()->getClassName().string(); StoreType::const_iterator it; // Apply standard map projection parameters ossimMapProjection* projection = dynamic_cast(this->GetMapProjection()); // Set up origin const ossimDatum* datum = ossimDatumFactory::instance()->wgs84(); //default value it = m_ParameterStore.find("Datum"); if (it != m_ParameterStore.end()) { datum = ossimDatumFactory::instance()->create((*it).second); projection->setDatum(datum); } StoreType::const_iterator itX = m_ParameterStore.find("OriginX"); StoreType::const_iterator itY = m_ParameterStore.find("OriginY"); StoreType::const_iterator itZ = m_ParameterStore.find("OriginZ"); if (itX != m_ParameterStore.end() && itY != m_ParameterStore.end()) { double originX = atof((*itX).second.c_str()); double originY = atof((*itY).second.c_str()); double originZ = 0; if (itZ != m_ParameterStore.end()) { originZ = atof((*itZ).second.c_str()); } ossimGpt origin(originY, originX, originZ, datum); projection->setOrigin(origin); } // Set up resolution StoreType::const_iterator itResMeterX = m_ParameterStore.find("MetersPerPixelX"); StoreType::const_iterator itResMeterY = m_ParameterStore.find("MetersPerPixelY"); if (itResMeterX != m_ParameterStore.end() && itResMeterY != m_ParameterStore.end()) { double resMeterX = atof((*itResMeterX).second.c_str()); double resMeterY = atof((*itResMeterY).second.c_str()); ossimDpt resMeter(resMeterX, resMeterY); projection->setMetersPerPixel(resMeter); } // Apply parameters to LambertConformalConic if (projectionName.compare("ossimLambertConformalConicProjection") == 0) { ossimLambertConformalConicProjection* lccProjection = dynamic_cast(this->GetMapProjection()); it = m_ParameterStore.find("FalseNorthing"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); lccProjection->setFalseNorthing(value); } it = m_ParameterStore.find("FalseEasting"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); lccProjection->setFalseEasting(value); } it = m_ParameterStore.find("StandardParallel1"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); lccProjection->setStandardParallel1(value); } it = m_ParameterStore.find("StandardParallel2"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); lccProjection->setStandardParallel2(value); } } // Apply parameters to Eckert4 if (projectionName.compare("ossimEckert4Projection") == 0) { ossimEckert4Projection* e4Projection = dynamic_cast(this->GetMapProjection()); it = m_ParameterStore.find("FalseNorthing"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); e4Projection->setFalseNorthing(value); } it = m_ParameterStore.find("FalseEasting"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); e4Projection->setFalseEasting(value); } } // Apply parameters to Mollweid if (projectionName.compare("ossimMollweidProjection") == 0) { ossimMollweidProjection* mProjection = dynamic_cast(this->GetMapProjection()); it = m_ParameterStore.find("FalseNorthing"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); mProjection->setFalseNorthing(value); } it = m_ParameterStore.find("FalseEasting"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); mProjection->setFalseEasting(value); } } // Apply parameters to Sinusoidal if (projectionName.compare("ossimSinusoidalProjection") == 0) { ossimSinusoidalProjection* sProjection = dynamic_cast(this->GetMapProjection()); it = m_ParameterStore.find("FalseNorthing"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); sProjection->setFalseNorthing(value); } it = m_ParameterStore.find("FalseEasting"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); sProjection->setFalseEasting(value); } } // Apply parameters to transmercator if (projectionName.compare("ossimTransMercatorProjection") == 0) { ossimTransMercatorProjection* tmProjection = dynamic_cast (this->GetMapProjection()); it = m_ParameterStore.find("ScaleFactor"); if (it != m_ParameterStore.end()) { double scale = atof((*it).second.c_str()); tmProjection->setScaleFactor(scale); } it = m_ParameterStore.find("FalseNorthing"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); tmProjection->setFalseNorthing(value); } it = m_ParameterStore.find("FalseEasting"); if (it != m_ParameterStore.end()) { double value = atof((*it).second.c_str()); tmProjection->setFalseEasting(value); } } // Apply parameters to Utm if (projectionName.compare("ossimUtmProjection") == 0) { ossimUtmProjection* utmProjection = dynamic_cast(this->GetMapProjection()); it = m_ParameterStore.find("Zone"); if (it != m_ParameterStore.end()) { int zone = atoi((*it).second.c_str()); utmProjection->setZone(zone); } it = m_ParameterStore.find("Hemisphere"); if (it != m_ParameterStore.end()) { utmProjection->setHemisphere((*it).second[0]); } } } void MapProjectionAdapter::PrintMap() const { m_MapProjection->print(std::cout); std::cout << "Parameter store:\n"; for (StoreType::const_iterator it = m_ParameterStore.begin(); it != m_ParameterStore.end(); ++it) { std::cout << " " << (*it).first << ": " << (*it).second << "\n"; } } namespace Utils { int GetZoneFromGeoPoint(double lon, double lat) { //use ossim to handle the special case of UTM ossimGpt point(lat, lon); ossimUtmProjection projection; int zone = projection.computeZone(point); return zone; } } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbMetaDataKey.cxx000066400000000000000000000125341301006202600253250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMetaDataKey.h" #define NBKEYS 24 namespace otb { namespace MetaDataKey { char const* DriverShortNameKey = "DriverShortName"; char const* DriverLongNameKey = "DriverLongName"; char const* ProjectionRefKey = "ProjectionRef"; char const* GCPProjectionKey = "GCPProjection"; char const* GCPParametersKey = "GCP_"; char const* GCPCountKey = "GCPCount"; char const* GeoTransformKey = "GeoTransform"; char const* MetadataKey = "Metadata_"; char const* SubMetadataKey = "SubMetadata_"; char const* UpperLeftCornerKey = "UpperLeftCorner"; char const* UpperRightCornerKey = "UpperRightCorner"; char const* LowerLeftCornerKey = "LowerLeftCorner"; char const* LowerRightCornerKey = "LowerRightCorner"; char const* ColorTableNameKey = "ColorTableName"; char const* ColorEntryCountKey = "ColorEntryCount"; char const* ColorEntryAsRGBKey = "ColorEntryAsRGB"; char const* OSSIMKeywordlistKey = "OSSIMKeywordlist"; char const* OSSIMKeywordlistDelimiterKey = "OSSIMKeywordlistDelimiter"; char const* VectorDataKeywordlistKey = "VectorDataKeywordlist"; char const* VectorDataKeywordlistDelimiterKey = "VectorDataKeywordlistDelimiter"; char const* ResolutionFactor = "ResolutionFactor"; char const* SubDatasetIndex = "SubDatasetIndex"; char const* CacheSizeInBytes = "CacheSizeInBytes"; char const* TileHintX = "TileHintX"; char const* TileHintY = "TileHintY"; char const * NoDataValueAvailable = "NoDataValueAvailable"; char const * NoDataValue = "NoDataValue"; } const MetaDataKey::KeyTypeDef Types[] = { MetaDataKey::KeyTypeDef(MetaDataKey::DriverShortNameKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::DriverLongNameKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::ProjectionRefKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::GCPProjectionKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::GCPParametersKey, MetaDataKey::TOTB_GCP), MetaDataKey::KeyTypeDef(MetaDataKey::GCPCountKey, MetaDataKey::TENTIER), MetaDataKey::KeyTypeDef(MetaDataKey::GeoTransformKey, MetaDataKey::TVECTOR), MetaDataKey::KeyTypeDef(MetaDataKey::MetadataKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::UpperLeftCornerKey, MetaDataKey::TVECTOR), MetaDataKey::KeyTypeDef(MetaDataKey::UpperRightCornerKey, MetaDataKey::TVECTOR), MetaDataKey::KeyTypeDef(MetaDataKey::LowerLeftCornerKey, MetaDataKey::TVECTOR), MetaDataKey::KeyTypeDef(MetaDataKey::LowerRightCornerKey, MetaDataKey::TVECTOR), MetaDataKey::KeyTypeDef(MetaDataKey::ColorTableNameKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::ColorEntryCountKey, MetaDataKey::TENTIER), MetaDataKey::KeyTypeDef(MetaDataKey::ColorEntryAsRGBKey, MetaDataKey::TVECTOR), MetaDataKey::KeyTypeDef(MetaDataKey::OSSIMKeywordlistKey, MetaDataKey::TOSSIMKEYWORDLIST), MetaDataKey::KeyTypeDef(MetaDataKey::OSSIMKeywordlistDelimiterKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::VectorDataKeywordlistKey, MetaDataKey::TVECTORDATAKEYWORDLIST), MetaDataKey::KeyTypeDef(MetaDataKey::VectorDataKeywordlistDelimiterKey, MetaDataKey::TSTRING), MetaDataKey::KeyTypeDef(MetaDataKey::ResolutionFactor, MetaDataKey::TENTIER), MetaDataKey::KeyTypeDef(MetaDataKey::SubDatasetIndex, MetaDataKey::TENTIER), MetaDataKey::KeyTypeDef(MetaDataKey::CacheSizeInBytes, MetaDataKey::TENTIER), MetaDataKey::KeyTypeDef(MetaDataKey::TileHintX, MetaDataKey::TENTIER), MetaDataKey::KeyTypeDef(MetaDataKey::TileHintY, MetaDataKey::TENTIER), MetaDataKey::KeyTypeDef(MetaDataKey::NoDataValueAvailable, MetaDataKey::TVECTOR), MetaDataKey::KeyTypeDef(MetaDataKey::NoDataValue, MetaDataKey::TVECTOR) }; MetaDataKey::KeyType MetaDataKey::GetKeyType(const std::string& name) { MetaDataKey::KeyType ktype(MetaDataKey::TSTRING); for (unsigned int i = 0; i < NBKEYS; ++i) { if ( name.find(Types[i].keyname) != std::string::npos ) { ktype = Types[i].type; break; } } return (ktype); } OTB_GCP::OTB_GCP() : m_GCPCol(0), m_GCPRow(0), m_GCPX(0), m_GCPY(0), m_GCPZ(0) { } OTB_GCP::~OTB_GCP() { } void OTB_GCP::Print(std::ostream& os) const { os << " GCP Id = " << this->m_Id << std::endl; os << " GCP Info = " << this->m_Info << std::endl; os << " GCP (Row, Col) = (" << this->m_GCPRow << "," << this->m_GCPCol << ")" << std::endl; os << " GCP (X, Y, Z) = (" << this->m_GCPX << "," << this->m_GCPY << "," << this->m_GCPZ << ")" << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbPlatformPositionAdapter.cxx000066400000000000000000000041131301006202600300000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPlatformPositionAdapter.h" #include "otbMacro.h" #include "otbImageKeywordlist.h" #include "ossim/ossimGeometricSarSensorModel.h" #include "ossim/otb/PlatformPosition.h" #include "ossim/projection/ossimProjection.h" #include "ossim/ossimPluginProjectionFactory.h" namespace otb { PlatformPositionAdapter::PlatformPositionAdapter(): m_SensorModel(ITK_NULLPTR) { } PlatformPositionAdapter::~PlatformPositionAdapter() { if (m_SensorModel != ITK_NULLPTR) { delete m_SensorModel; m_SensorModel = ITK_NULLPTR; } } void PlatformPositionAdapter::CreateSensorModel(const ImageKeywordlist& image_kwl) { ossimKeywordlist geom; image_kwl.convertToOSSIMKeywordlist(geom); otbMsgDevMacro(<< "CreateSensorModel()"); otbMsgDevMacro(<< "* type: " << geom.find("type")); ossimProjection* sensor = ossimplugins::ossimPluginProjectionFactory::instance()->createProjection(geom); m_SensorModel = dynamic_cast(sensor); if (!m_SensorModel) { otbMsgDevMacro(<< "CreateSensorModel() failed"); } } void PlatformPositionAdapter::GetPlatformPosition( double line, std::vector& position, std::vector& speed) { m_SensorModel->getPlatformPositionAtLine(line, position, speed); } void PlatformPositionAdapter::GetPlatformPositionAtTime( ossimplugins::JSDDateTime time, std::vector& position, std::vector& speed) { m_SensorModel->get_platformPosition()->getPlatformPositionAtTime(time, position, speed); } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbRPCSolverAdapter.cxx000066400000000000000000000111731301006202600263120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRPCSolverAdapter.h" #include "otbImageKeywordlist.h" #include "otbMacro.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/projection/ossimRpcSolver.h" #include "ossim/projection/ossimProjection.h" #include "ossim/projection/ossimRpcProjection.h" #include "ossim/imaging/ossimImageGeometry.h" #pragma GCC diagnostic pop #else #include "ossim/projection/ossimRpcSolver.h" #include "ossim/projection/ossimProjection.h" #include "ossim/projection/ossimRpcProjection.h" #include "ossim/imaging/ossimImageGeometry.h" #endif namespace otb { RPCSolverAdapter::RPCSolverAdapter() {} RPCSolverAdapter::~RPCSolverAdapter() {} void RPCSolverAdapter::Solve(const GCPsContainerType& gcpContainer, double& rmsError, ImageKeywordlist& otb_kwl) { // TODO: for now, this is a simple transfer of what was done in the // GCPsToRPCSensorModelImageFilter. We might find some way to improve that. // The vector where geo and sensor points are stored std::vector sensorPoints; std::vector geoPoints; // Temporary points variable ossimDpt sensorPoint; ossimGpt geoPoint; // Retrieve the additional GCPs GCPsContainerType::const_iterator gcpIt; for (gcpIt = gcpContainer.begin(); gcpIt != gcpContainer.end(); ++gcpIt) { // Check if point is inside bounds // Fill sensor point sensorPoint = ossimDpt( internal::ConvertToOSSIMFrame(gcpIt->first[0]), internal::ConvertToOSSIMFrame(gcpIt->first[1])); // Fill geo point (lat, lon, elev) geoPoint = ossimGpt(gcpIt->second[1], gcpIt->second[0], gcpIt->second[2]); // Add the sensor point to the list sensorPoints.push_back(sensorPoint); // Add the geo point to the list geoPoints.push_back(geoPoint); } // Check for enough points if(sensorPoints.size() < 20) { itkGenericExceptionMacro(<<"At least 20 points are required to estimate the 40 parameters of a RPC model without elevation support, and 40 are required to estimate the 80 parameters of a RPC model with elevation support. Only "< rpcSolver = new ossimRpcSolver(useElevation, false); // Call the solve method rpcSolver->solveCoefficients(sensorPoints, geoPoints); rmsError = rpcSolver->getRmsError(); // Retrieve the output RPC projection ossimRefPtr rpcProjection = dynamic_cast(rpcSolver->createRpcProjection()->getProjection()); // Export the sensor model in an ossimKeywordlist ossimKeywordlist geom_kwl; rpcProjection->saveState(geom_kwl); // Build an otb::ImageKeywordList otb_kwl.SetKeywordlist(geom_kwl); } bool RPCSolverAdapter::Solve(const GCPsContainerType& gcpContainer, double& rmsError, const std::string & outgeom) { // Declare an empty keywordlist ImageKeywordlist otb_kwl; // Call the Solve method that actually does the solving Solve(gcpContainer,rmsError,otb_kwl); // Write the keywordlist to disk ossimKeywordlist kwl; otb_kwl.convertToOSSIMKeywordlist(kwl); return kwl.write(outgeom.c_str()); } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/src/otbSensorModelAdapter.cxx000066400000000000000000000204021301006202600267200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSensorModelAdapter.h" #include #include "otbMacro.h" #include "otbImageKeywordlist.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #include "ossim/projection/ossimProjection.h" #include "ossim/projection/ossimSensorModelFactory.h" #include "ossim/projection/ossimSensorModel.h" #include "ossim/projection/ossimRpcProjection.h" #include "ossim/ossimPluginProjectionFactory.h" #include "ossim/base/ossimTieGptSet.h" #pragma GCC diagnostic pop #else #include "ossim/projection/ossimProjection.h" #include "ossim/projection/ossimSensorModelFactory.h" #include "ossim/projection/ossimSensorModel.h" #include "ossim/projection/ossimRpcProjection.h" #include "ossim/ossimPluginProjectionFactory.h" #include "ossim/base/ossimTieGptSet.h" #endif namespace otb { SensorModelAdapter::SensorModelAdapter(): m_SensorModel(ITK_NULLPTR), m_TiePoints(ITK_NULLPTR) // FIXME keeping the original value but... { m_DEMHandler = DEMHandler::Instance(); m_TiePoints = new ossimTieGptSet(); } SensorModelAdapter::~SensorModelAdapter() { delete m_SensorModel; delete m_TiePoints; } void SensorModelAdapter::CreateProjection(const ImageKeywordlist& image_kwl) { ossimKeywordlist geom; image_kwl.convertToOSSIMKeywordlist(geom); otbMsgDevMacro(<< "CreateProjection()"); otbMsgDevMacro(<< "* type: " << geom.find("type")); m_SensorModel = ossimSensorModelFactory::instance()->createProjection(geom); if (m_SensorModel == ITK_NULLPTR) { m_SensorModel = ossimplugins::ossimPluginProjectionFactory::instance()->createProjection(geom); } } bool SensorModelAdapter::IsValidSensorModel() const { return m_SensorModel != ITK_NULLPTR; } void SensorModelAdapter::ForwardTransformPoint(double x, double y, double z, double& lon, double& lat, double& h) const { if (this->m_SensorModel == ITK_NULLPTR) { itkExceptionMacro(<< "ForwardTransformPoint(): Invalid sensor model (m_SensorModel pointer is null)"); } ossimDpt ossimPoint( internal::ConvertToOSSIMFrame(x), internal::ConvertToOSSIMFrame(y)); ossimGpt ossimGPoint; this->m_SensorModel->lineSampleHeightToWorld(ossimPoint,z, ossimGPoint); lon = ossimGPoint.lon; lat = ossimGPoint.lat; h = ossimGPoint.hgt; } void SensorModelAdapter::ForwardTransformPoint(double x, double y, double& lon, double& lat, double& h) const { if (this->m_SensorModel == ITK_NULLPTR) { itkExceptionMacro(<< "ForwardTransformPoint(): Invalid sensor model (m_SensorModel pointer is null)"); } ossimDpt ossimPoint( internal::ConvertToOSSIMFrame(x), internal::ConvertToOSSIMFrame(y)); ossimGpt ossimGPoint; this->m_SensorModel->lineSampleToWorld(ossimPoint, ossimGPoint); lon = ossimGPoint.lon; lat = ossimGPoint.lat; h = ossimGPoint.hgt; } void SensorModelAdapter::InverseTransformPoint(double lon, double lat, double h, double& x, double& y, double& z) const { if (this->m_SensorModel == ITK_NULLPTR) { itkExceptionMacro(<< "InverseTransformPoint(): Invalid sensor model (m_SensorModel pointer is null)"); } // Initialize with value from the function parameters ossimGpt ossimGPoint(lat, lon, h); ossimDpt ossimDPoint; this->m_SensorModel->worldToLineSample(ossimGPoint, ossimDPoint); x = internal::ConvertFromOSSIMFrame(ossimDPoint.x); y = internal::ConvertFromOSSIMFrame(ossimDPoint.y); z = ossimGPoint.height(); } void SensorModelAdapter::InverseTransformPoint(double lon, double lat, double& x, double& y, double& z) const { if (this->m_SensorModel == ITK_NULLPTR) { itkExceptionMacro(<< "InverseTransformPoint(): Invalid sensor model (m_SensorModel pointer is null)"); } // Get elevation from DEMHandler double h = m_DEMHandler->GetHeightAboveEllipsoid(lon,lat); // Initialize with value from the function parameters ossimGpt ossimGPoint(lat, lon, h); ossimDpt ossimDPoint; this->m_SensorModel->worldToLineSample(ossimGPoint, ossimDPoint); x = internal::ConvertFromOSSIMFrame(ossimDPoint.x); y = internal::ConvertFromOSSIMFrame(ossimDPoint.y); z = ossimGPoint.height(); } void SensorModelAdapter::AddTiePoint(double x, double y, double z, double lon, double lat) { // Create the tie point ossimDpt imagePoint( internal::ConvertToOSSIMFrame(x), internal::ConvertToOSSIMFrame(y)); ossimGpt ossimGPoint(lat, lon, z); // Add the tie point to the container m_TiePoints->addTiePoint(new ossimTieGpt(ossimGPoint,imagePoint,0)); } void SensorModelAdapter::AddTiePoint(double x, double y, double lon, double lat) { // Create the tie point ossimDpt imagePoint( internal::ConvertToOSSIMFrame(x), internal::ConvertToOSSIMFrame(y)); // Get elevation from DEMHandler double z = m_DEMHandler->GetHeightAboveEllipsoid(lon,lat); ossimGpt ossimGPoint(lat, lon, z); // Add the tie point to the container m_TiePoints->addTiePoint(new ossimTieGpt(ossimGPoint,imagePoint,0)); } void SensorModelAdapter::ClearTiePoints() { m_TiePoints->clearTiePoints(); } double SensorModelAdapter::Optimize() { double precision = 0.; // If tie points and model are allocated if(m_SensorModel != ITK_NULLPTR) { // try to retrieve a sensor model ossimSensorModel * sensorModel = dynamic_cast(m_SensorModel); ossimRpcProjection * simpleRpcModel = dynamic_cast(m_SensorModel); //Handle exceptions if ( (sensorModel == ITK_NULLPTR ) && (simpleRpcModel == ITK_NULLPTR ) ) itkExceptionMacro(<< "Optimize(): error, both dynamic_cast from ossimProjection* to ossimSensorModel* / ossimRpcProjection* failed."); if(sensorModel != ITK_NULLPTR ) { // Call optimize fit precision = sensorModel->optimizeFit(*m_TiePoints); } else if (simpleRpcModel != ITK_NULLPTR) { // Call optimize fit precision = simpleRpcModel->optimizeFit(*m_TiePoints); } } // Return the precision return precision; } bool SensorModelAdapter::ReadGeomFile(const std::string & infile) { ossimKeywordlist geom; geom.add(infile.c_str()); m_SensorModel = ossimSensorModelFactory::instance()->createProjection(geom); if (m_SensorModel == ITK_NULLPTR) { m_SensorModel = ossimplugins::ossimPluginProjectionFactory::instance()->createProjection(geom); } // otbMsgDevMacro(<< "ReadGeomFile("< " << m_SensorModel); return (m_SensorModel != ITK_NULLPTR); } bool SensorModelAdapter::WriteGeomFile(const std::string & outfile) { // If tie points and model are allocated if(m_SensorModel != ITK_NULLPTR) { // try to retrieve a sensor model ossimSensorModel * sensorModel = dynamic_cast(m_SensorModel); ossimRpcProjection * simpleRpcModel = dynamic_cast(m_SensorModel); //Handle exceptions if ( (sensorModel == ITK_NULLPTR ) && (simpleRpcModel == ITK_NULLPTR ) ) itkExceptionMacro(<< "Optimize(): error, both dynamic_cast from ossimProjection* to ossimSensorModel* / ossimRpcProjection* failed."); ossimKeywordlist geom; bool success = false; if(sensorModel != ITK_NULLPTR ) { // Save state success = sensorModel->saveState(geom); } else if (simpleRpcModel != ITK_NULLPTR) { // Save state success = simpleRpcModel->saveState(geom); } if(success) { return geom.write(outfile.c_str()); } } return false; } } // namespace otb OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/000077500000000000000000000000001301006202600221265ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/CMakeLists.txt000066400000000000000000000344161301006202600246760ustar00rootroot00000000000000otb_module_test() set(OTBOSSIMAdaptersTests otbOSSIMAdaptersTestDriver.cxx otbTestImageKeywordlist.cxx otbOssimJpegFileResourceLeakTest.cxx otbMapProjectionAdapterTest.cxx otbOssimElevManagerTest2.cxx otbOssimElevManagerTest4.cxx otbGeometricSarSensorModelAdapter.cxx otbPlatformPositionAdapter.cxx otbDEMHandlerTest.cxx otbRPCSolverAdapterTest.cxx ) add_executable(otbOSSIMAdaptersTestDriver ${OTBOSSIMAdaptersTests}) target_link_libraries(otbOSSIMAdaptersTestDriver ${OTBOSSIMAdapters-Test_LIBRARIES}) otb_module_target_label(otbOSSIMAdaptersTestDriver) # Tests Declaration #KEYWORDLIST : OPTICAL SENSORS set(NAME_TESTS "pleiades-1" "ikonos-1" "rapideye-1" "quickbird-1" "spot6-1" "worldview2-1" "spot5-1" "geoeye1-1" ) set(IMG LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2} LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_nir_0000000.tif} LARGEINPUT{RAPIDEYE/level1B/2008-12-25T005918_RE3_1B-NAC_397971_12345_band3.ntf} LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} LARGEINPUT{SPOT6/600143101-Primary-Bundle-JP2-LOSSLESS/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201212071020271_SEN_600143101_R1C1.JP2} LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} LARGEINPUT{GEOEYE/MARCILLOLES/po_350134_bgrn_0000001.tif} ) set(NEEDEDKW "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #PLEIADES "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #IKONOS "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #RAPIDEYE "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #QB "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #SPOT6 "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #WORLDVIEW2 "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #SPOT5 "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff support_data.physical_gain support_data.physical_bias support_data.solar_irradiance support_data.image_date support_data.elevation_angle" #geoeye1 ) set(TOLS "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #PLEIADES "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #IKONOS "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #RAPIDEYE "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #QB "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #SPOT6 "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #WORLDVIEW2 "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #SPOT5 "1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6" #geoeye1 ) set(TESTNB 0 ) foreach( file ${NAME_TESTS} ) list(GET IMG ${TESTNB} current_img ) list(GET NEEDEDKW ${TESTNB} current_neededkw ) list(GET TOLS ${TESTNB} current_tols ) list(GET NAME_TESTS ${TESTNB} current_name ) math(EXPR TESTNB "${TESTNB} + 1") otb_add_test(NAME ioTvTestImageKeywordlist_${current_name} COMMAND otbOSSIMAdaptersTestDriver otbTestImageKeywordlist ${current_img} ${current_neededkw} ${current_tols} ${current_name}.geom 0 # 1 : Check all keywords (ignore argv[2] and argv[3]) / 0 : Only check the needed keywords ) endforeach() #KEYWORDLIST : RADAR SENSORS set(NAME_TESTS "radarsat2-1" "terrasarx-1" "sentinel1-1" "envisat-asar-1" "radarsat1-1" "ers2-1" ) set(IMG LARGEINPUT{RADARSAT2/ALTONA/Fine_Quad-Pol_Dataset/PK6621_DK406_FQ9_20080405_124900_HH_VV_HV_VH_SLC_Altona/imagery_VH.tif} LARGEINPUT{TERRASARX/2008-03-21_GrandCanyon_SSC/TSX1_SAR__SSC______SM_S_SRA_20080321T133220_20080321T133228/IMAGEDATA/IMAGE_HH_SRA_strip_011.cos} LARGEINPUT{SENTINEL1/S1A_S6_SLC__1SSV_20150619T195043/measurement/s1a-s6-slc-vv-20150619t195043-20150619t195101-006447-00887d-001.tiff} LARGEINPUT{ENVISAT_ASAR_SCENE01/ASA_APS_1PNDPA20030821_7713.N1} LARGEINPUT{RADARSAT1/SARDEGNA/scene01/dat_01.001} LARGEINPUT{SAR_ERS2_SLCI_SCENE1/DAT_01.001} ) set(TESTNB 0 ) foreach( file ${NAME_TESTS} ) list(GET IMG ${TESTNB} current_img ) list(GET NAME_TESTS ${TESTNB} current_name ) math(EXPR TESTNB "${TESTNB} + 1") otb_add_test(NAME ioTvTestImageKeywordlist_${current_name} COMMAND otbOSSIMAdaptersTestDriver otbTestImageKeywordlist ${current_img} "Foo" "Foo" ${current_name}.geom 1 # 1 : Check all keywords (ignore argv[2] and argv[3]) / 0 : Only check the needed keywords ) endforeach() otb_add_test(NAME ioTvOssimJpegFileResourceLeak COMMAND otbOSSIMAdaptersTestDriver otbOssimJpegFileResourceLeakTest ${INPUTDATA}/poupees.jpg 1200 ) otb_add_test(NAME ioTvMapProjectionAdapterTest COMMAND otbOSSIMAdaptersTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvMapProjectionAdapterTest.txt ${TEMP}/ioTvMapProjectionAdapterTest.txt otbMapProjectionAdapterTest ${TEMP}/ioTvMapProjectionAdapterTest.txt ) otb_add_test(NAME prTvossimElevManagerTest2 COMMAND otbOSSIMAdaptersTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/prTvossimElevManagerTest2.txt ${TEMP}/prTvossimElevManagerTest2.txt otbOssimElevManagerTest2 ${INPUTDATA}/DEM/srtm_directory ${TEMP}/prTvossimElevManagerTest2.txt 6.5 44.5 0.002 500 ) otb_add_test(NAME prTvossimElevManagerTest4 COMMAND otbOSSIMAdaptersTestDriver --compare-image ${EPSILON_9} ${BASELINE}/prTvossimElevManagerTest4 ${TEMP}/prTvossimElevManagerTest4.hdr otbOssimElevManagerTest4 ${INPUTDATA}/DEM/srtm_directory ${TEMP}/prTvossimElevManagerTest4 -1.8 52 0.02 -0.018 232 422 ) #commented below test. these are moved to dev_sar_tsx branch for further checks # otb_add_test(NAME uaTvGeometricSarSensorModelAdapterTest COMMAND otbOSSIMAdaptersTestDriver # --compare-ascii ${EPSILON_9} # ${BASELINE_FILES}/uaTvGeometricSarSensorModelAdapterTest.txt # ${TEMP}/uaTvGeometricSarSensorModelAdapterTest.txt # otbGeometricSarSensorModelAdapterTest # LARGEINPUT{TERRASARX/2008-03-10_GrandCanyon_SSC//TSX1_SAR__SSC______SM_S_SRA_20080310T133220_20080310T133228/TSX1_SAR__SSC______SM_S_SRA_20080310T133220_20080310T133228.xml} # ${TEMP}/uaTvGeometricSarSensorModelAdapterTest.txt) # otb_add_test(NAME uaTvPlatformPositionComputeBaselineTest COMMAND otbOSSIMAdaptersTestDriver # --compare-ascii ${EPSILON_9} # ${BASELINE_FILES}/uaTvPlatformPositionComputeBaselineTest.txt # ${TEMP}/uaTvPlatformPositionComputeBaselineTest.txt # otbPlatformPositionComputeBaselineTest # LARGEINPUT{TERRASARX/2008-03-10_GrandCanyon_SSC//TSX1_SAR__SSC______SM_S_SRA_20080310T133220_20080310T133228/TSX1_SAR__SSC______SM_S_SRA_20080310T133220_20080310T133228.xml} # ${TEMP}/uaTvPlatformPositionComputeBaselineTest.txt) otb_add_test(NAME uaTvGeometricSarSensorModelAdapterNew COMMAND otbOSSIMAdaptersTestDriver otbGeometricSarSensorModelAdapterNewTest) otb_add_test(NAME uaTvPlatformPositionComputeBaselineNew COMMAND otbOSSIMAdaptersTestDriver otbPlatformPositionComputeBaselineNewTest) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_NoSRTM_NoGeoid_NoData COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest no no 40 8.687917 44.237917 0 40 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveMSL_NoSRTM_Geoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest no ${INPUTDATA}/DEM/egm96.grd 40 8.434583 44.647083 1 0 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_BadSRTM_Geoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/poupeesTIF/ ${INPUTDATA}/DEM/egm96.grd 40 8.434583 44.647083 0 383.580313671 0.001 ) set_property(TEST uaTvDEMHandler_AboveEllipsoid_BadSRTM_Geoid PROPERTY WILL_FAIL 1) otb_add_test(NAME uaTvDEMHandler_AboveMSL_NoSRTM_NoGeoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest no no 40 8.434583 44.647083 1 0 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_NoSRTM_Geoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest no ${INPUTDATA}/DEM/egm96.grd 40 8.434583 44.647083 0 44.067113 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_SRTM_Geoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 40 8.434583 44.647083 0 383.580313671 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveMSL_SRTM_NoGeoid_NoSRTMCoverage COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ no 20 10. # Point not covered 10. # Point not covered 1 0 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_SRTM_NoGeoid_NoSRTMCoverage COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ no 20 10. # Point not covered 10. # Point not covered 0 20 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveMSL_SRTM_NoGeoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ no 40 8.434583 44.647083 1 339.513 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_SRTM_NoGeoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ no 40 8.434583 44.647083 0 339.513 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_SRTM_Geoid_NoData COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 40 8.687917 44.237917 0 45.7464 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_SRTM_BadGeoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/poupees.jpg 40 8.434583 44.647083 0 339.513 0.001 ) set_property(TEST uaTvDEMHandler_AboveEllipsoid_SRTM_BadGeoid PROPERTY WILL_FAIL true) otb_add_test(NAME uaTvDEMHandler_AboveMSL_SRTM_NoGeoid_NoData COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ no 40 8.687917 44.237917 1 0 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_BDALTI_TIF_NoGeoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest LARGEINPUT{BD_ALTI/} no 800 7.283262 48.598675 0 869 1 ) otb_add_test(NAME uaTvDEMHandler_AboveMSL_SRTM_Geoid_NoData COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 40 8.687917 44.237917 1 0 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveMSL_NoSRTM_NoGeoid_NoData COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest no no 40 8.687917 44.237917 1 0 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveMSL_SRTM_Geoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 40 8.434583 44.647083 1 339.513 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_NoSRTM_NoGeoid COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest no no 40 8.434583 44.647083 0 40 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveMSL_SRTM_Geoid_NoSRTMCoverage COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 20 10. # Point not covered 10. # Point not covered 1 0 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_SRTM_Geoid_NoSRTMCoverage COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 20 10. # Point not covered 10. # Point not covered 0 21.569 # Geoid offset 0.001 ) otb_add_test(NAME uaTvDEMHandler_AboveEllipsoid_SRTM_NoGeoid_NoData COMMAND otbOSSIMAdaptersTestDriver otbDEMHandlerTest ${INPUTDATA}/DEM/srtm_directory/ no 40 8.687917 44.237917 0 40 0.001 ) otb_add_test(NAME uaTvRPCSolverAdapterNoDEMValidationTest COMMAND otbOSSIMAdaptersTestDriver otbRPCSolverAdapterTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} 10 0.25 0.35 no no ) otb_add_test(NAME uaTvRPCSolverAdapterNotEnoughPointsForElevationTest COMMAND otbOSSIMAdaptersTestDriver otbRPCSolverAdapterTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} 5 0.25 0.35 no no ) otb_add_test(NAME uaTvRPCSolverAdapterNotEnoughPointsTest COMMAND otbOSSIMAdaptersTestDriver otbRPCSolverAdapterTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} 4 0.25 0.35 ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd ) if (OTB_DATA_USE_LARGEINPUT) set_property(TEST uaTvRPCSolverAdapterNotEnoughPointsTest PROPERTY WILL_FAIL TRUE) endif() #otb_add_test(NAME uaTvRPCSolverAdapterOutGeomTest COMMAND otbOSSIMAdaptersTestDriver #--compare-ascii ${EPSILON_9} #${BASELINE_FILES}/uaTvRPCSolverAdapterOutGeomTest.geom #${TEMP}/uaTvRPCSolverAdapterOutGeomTest.geom #otbRPCSolverAdapterTest #LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} #10 0.25 0.35 #${INPUTDATA}/DEM/srtm_directory/ #${INPUTDATA}/DEM/egm96.grd #${TEMP}/uaTvRPCSolverAdapterOutGeomTest.geom #) otb_add_test(NAME uaTvRPCSolverAdapterValidationTest COMMAND otbOSSIMAdaptersTestDriver otbRPCSolverAdapterTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} 10 0.25 0.35 ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd ) OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbDEMHandlerTest.cxx000066400000000000000000000057701301006202600261330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDEMHandler.h" int otbDEMHandlerTest(int argc, char * argv[]) { if(argc!=9) { std::cerr<<"Usage: "<SetDefaultHeightAboveEllipsoid(defaultHeight); bool fail = false; std::cout<IsValidDEMDirectory(demdir.c_str())) { std::cerr<<"IsValidDEMDirectory("<OpenDEMDirectory(demdir); std::cout<<"GetDEMDirectory() = "<GetDEMDirectory()<OpenGeoidFile(geoid); } catch( const std::exception & exception ) { std::cout << "Exception thrown while opening geod-file '" << geoid << "':" << std::endl << exception.what(); fail = true; } std::cout<<"GetGeoidFile() = "<GetGeoidFile()<GetHeightAboveMSL(point); std::cout<<"height above MSL ("<GetHeightAboveEllipsoid(point); std::cout<<"height above ellipsoid ("<tolerance) { std::cerr<<"Target value is "< tolerance ("< #include "otbImage.h" #include "otbImageFileReader.h" #include "otbGeometricSarSensorModelAdapter.h" int otbGeometricSarSensorModelAdapterNewTest(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef otb::GeometricSarSensorModelAdapter SarSensorModelType; SarSensorModelType::Pointer masterPlatform = SarSensorModelType::New(); return EXIT_SUCCESS; } int otbGeometricSarSensorModelAdapterTest(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " imageFile output" << std::endl; return EXIT_FAILURE; } typedef std::complex PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer image = ReaderType::New(); image->SetFileName(argv[1]); image->UpdateOutputInformation(); typedef otb::GeometricSarSensorModelAdapter SarSensorModelType; SarSensorModelType::Pointer imageSarModel = SarSensorModelType::New(); imageSarModel->CreateSensorModel(image->GetOutput()->GetImageKeywordlist()); std::vector imagePosition; std::vector imageSpeed; imagePosition.resize(3); imageSpeed.resize(3); imageSarModel->GetPlatformPositionAtLine(0, imagePosition, imageSpeed); std::ofstream file; file.open(argv[2]); file << std::setprecision(15); file << "Image:\n"; //file << "Start Time: " << masterSarModel->getTime(0)<< " m\n"; file << "Pos X: " << imagePosition[0] << " m\n"; file << "Pos Y: " << imagePosition[1] << " m\n"; file << "Pos Z: " << imagePosition[2] << " m\n"; file << "Spd X: " << imageSpeed[0] << " m/s\n"; file << "Spd Y: " << imageSpeed[1] << " m/s\n"; file << "Spd Z: " << imageSpeed[2] << " m/s\n"; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbMapProjectionAdapterTest.cxx000066400000000000000000000167521301006202600303050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMapProjectionAdapter.h" int otbMapProjectionAdapterTest(int itkNotUsed(argc), char* argv[]) { const char * outFileName = argv[1]; std::ofstream file; file.open(outFileName); file << std::setprecision(15); { /** Test the ability to instantiate a projection from a wkt string*/ std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; otb::MapProjectionAdapter::Pointer genericMapProjection = otb::MapProjectionAdapter::New(); genericMapProjection->SetWkt(projectionRefWkt); file << "Instantiating from : " << projectionRefWkt << std::endl; file << genericMapProjection->GetWkt() << std::endl << std::endl; double lon = 1.44; double lat = 43.6050; double h = 10; double x = 0; double y = 0; double z = 0; genericMapProjection->ForwardTransform(lon, lat, h, x, y, z); file << "Forward projection: " << std::endl; file << lon << ", " << lat << ", " << h << " -> "; file << x << ", " << y << ", " << z; file << std::endl << std::endl; genericMapProjection->InverseTransform(x, y, z, lon, lat, h); file << "Inverse projection: " << std::endl; file << x << ", " << y << ", " << z << " -> "; file << lon << ", " << lat << ", " << h; file << std::endl << std::endl; } { /** Test the ability to instantiate a projection from an ossim string*/ std::string projectionRefWkt ="ossimUtmProjection"; otb::MapProjectionAdapter::Pointer genericMapProjection = otb::MapProjectionAdapter::New(); genericMapProjection->SetWkt(projectionRefWkt); file << "Instantiating from : " << projectionRefWkt << std::endl; file << genericMapProjection->GetWkt() << std::endl << std::endl; double lon = 1.44; double lat = 43.6050; double h = 10; double x = 0; double y = 0; double z = 0; genericMapProjection->ForwardTransform(lon, lat, h, x, y, z); file << "Forward projection: " << std::endl; file << lon << ", " << lat << ", " << h << " -> "; file << x << ", " << y << ", " << z; file << std::endl << std::endl; genericMapProjection->InverseTransform(x, y, z, lon, lat, h); file << "Inverse projection: " << std::endl; file << x << ", " << y << ", " << z << " -> "; file << lon << ", " << lat << ", " << h; file << std::endl << std::endl; } { /** Test the ability to instantiate a projection from an short string*/ std::string projectionRefWkt ="Utm"; otb::MapProjectionAdapter::Pointer genericMapProjection = otb::MapProjectionAdapter::New(); genericMapProjection->SetWkt(projectionRefWkt); file << "Instantiating from : " << projectionRefWkt << std::endl; file << genericMapProjection->GetWkt() << std::endl << std::endl; double lon = 1.44; double lat = 43.6050; double h = 10; double x = 0; double y = 0; double z = 0; genericMapProjection->ForwardTransform(lon, lat, h, x, y, z); file << "Forward projection: " << std::endl; file << lon << ", " << lat << ", " << h << " -> "; file << x << ", " << y << ", " << z; file << std::endl << std::endl; genericMapProjection->InverseTransform(x, y, z, lon, lat, h); file << "Inverse projection: " << std::endl; file << x << ", " << y << ", " << z << " -> "; file << lon << ", " << lat << ", " << h; file << std::endl << std::endl; } { /** Test the ability to instantiate a projection from an short string*/ std::string projectionRefWkt ="Mercator"; otb::MapProjectionAdapter::Pointer genericMapProjection = otb::MapProjectionAdapter::New(); genericMapProjection->SetWkt(projectionRefWkt); file << "Instantiating from : " << projectionRefWkt << std::endl; file << genericMapProjection->GetWkt() << std::endl << std::endl; double lon = 1.44; double lat = 43.6050; double h = 10; double x = 0; double y = 0; double z = 0; genericMapProjection->ForwardTransform(lon, lat, h, x, y, z); file << "Forward projection: " << std::endl; file << lon << ", " << lat << ", " << h << " -> "; file << x << ", " << y << ", " << z; file << std::endl << std::endl; genericMapProjection->InverseTransform(x, y, z, lon, lat, h); file << "Inverse projection: " << std::endl; file << x << ", " << y << ", " << z << " -> "; file << lon << ", " << lat << ", " << h; file << std::endl << std::endl; } { /** Test the ability to instantiate a projection from an short string*/ std::string projectionRefWkt ="LambertConformalConic"; otb::MapProjectionAdapter::Pointer genericMapProjection = otb::MapProjectionAdapter::New(); genericMapProjection->SetWkt(projectionRefWkt); file << "Instantiating from : " << projectionRefWkt << std::endl; file << genericMapProjection->GetWkt() << std::endl << std::endl; double lon = 1.44; double lat = 43.6050; double h = 10; double x = 0; double y = 0; double z = 0; genericMapProjection->ForwardTransform(lon, lat, h, x, y, z); file << "Forward projection: " << std::endl; file << lon << ", " << lat << ", " << h << " -> "; file << x << ", " << y << ", " << z; file << std::endl << std::endl; genericMapProjection->InverseTransform(x, y, z, lon, lat, h); file << "Inverse projection: " << std::endl; file << x << ", " << y << ", " << z << " -> "; file << lon << ", " << lat << ", " << h; file << std::endl << std::endl; } { /** Test the ability to instantiate an Utm projection in a different zone */ std::string projectionRefWkt ="Utm"; otb::MapProjectionAdapter::Pointer genericMapProjection = otb::MapProjectionAdapter::New(); genericMapProjection->SetWkt(projectionRefWkt); genericMapProjection->SetParameter("Zone", "46"); genericMapProjection->SetParameter("Hemisphere", "S"); file << "Instantiating from : " << projectionRefWkt << " with some extra parameters" << std::endl; file << genericMapProjection->GetWkt() << std::endl << std::endl; double lon = 91.44; double lat = -43.6050; double h = 10; double x = 0; double y = 0; double z = 0; genericMapProjection->ForwardTransform(lon, lat, h, x, y, z); file << "Forward projection: " << std::endl; file << lon << ", " << lat << ", " << h << " -> "; file << x << ", " << y << ", " << z; file << std::endl << std::endl; genericMapProjection->InverseTransform(x, y, z, lon, lat, h); file << "Inverse projection: " << std::endl; file << x << ", " << y << ", " << z << " -> "; file << lon << ", " << lat << ", " << h; file << std::endl << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbOSSIMAdaptersTestDriver.cxx000066400000000000000000000011111301006202600277430ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbTestImageKeywordlist); REGISTER_TEST(otbOssimJpegFileResourceLeakTest); REGISTER_TEST(otbMapProjectionAdapterTest); REGISTER_TEST(otbOssimElevManagerTest2); REGISTER_TEST(otbOssimElevManagerTest4); REGISTER_TEST(otbGeometricSarSensorModelAdapterNewTest); REGISTER_TEST(otbGeometricSarSensorModelAdapterTest); REGISTER_TEST(otbPlatformPositionComputeBaselineNewTest); REGISTER_TEST(otbPlatformPositionComputeBaselineTest); REGISTER_TEST(otbDEMHandlerTest); REGISTER_TEST(otbRPCSolverAdapterTest); } OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbOssimElevManagerTest2.cxx000066400000000000000000000041411301006202600275020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/elevation/ossimElevManager.h" #include "ossim/base/ossimFilename.h" #pragma GCC diagnostic pop #else #include "ossim/elevation/ossimElevManager.h" #include "ossim/base/ossimFilename.h" #endif #include "itkPoint.h" int otbOssimElevManagerTest2(int argc, char* argv[]) { if (argc != 7) { std::cout << "Usage: " << std::endl; std::cout << argv[0] << " srtmDir outfname originX originY spacingX sizeX " << std::endl; return EXIT_FAILURE; } const ossimFilename srtmDir(argv[1]); const char * outfname = argv[2]; typedef itk::Point PointType; PointType origin; double spacing; int size; origin[0] = atof(argv[3]); origin[1] = atof(argv[4]); spacing = atof(argv[5]); size = atoi(argv[6]); ossimElevManager * elevManager = ossimElevManager::instance(); elevManager->loadElevationPath(srtmDir); std::ofstream file; file.open(outfname); for (int i = 0; i < size; ++i) { PointType point; point[0] = origin[0] + i * spacing; point[1] = origin[1]; ossimGpt ossimWorldPoint; ossimWorldPoint.lon = point[0]; ossimWorldPoint.lat = point[1]; double height = elevManager->getHeightAboveMSL(ossimWorldPoint); file << point << " -> " << height << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbOssimElevManagerTest4.cxx000066400000000000000000000074531301006202600275150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/elevation/ossimElevManager.h" #include "ossim/base/ossimFilename.h" #pragma GCC diagnostic pop #else #include "ossim/elevation/ossimElevManager.h" #include "ossim/base/ossimFilename.h" #endif int otbOssimElevManagerTest4(int argc, char* argv[]) { if (argc != 9) { std::cout << "Usage: " << std::endl; std::cout << argv[0] << " srtmDir outfname originX originY spacingX spacingY sizeX sizeY" << std::endl; return EXIT_FAILURE; } const ossimFilename srtmDir(argv[1]); const char * outfname = argv[2]; double origin[2]; double spacing[2]; int size[2]; origin[0] = atof(argv[3]); origin[1] = atof(argv[4]); spacing[0] = atof(argv[5]); spacing[1] = atof(argv[6]); size[0] = atoi(argv[7]); size[1] = atoi(argv[8]); double* image = new double[size[0] * size[1]]; ossimElevManager * elevManager = ossimElevManager::instance(); elevManager->loadElevationPath(srtmDir); for (int j = 0; j < size[1]; ++j) { for (int i = 0; i < size[0]; ++i) { double point[2]; point[0] = origin[0] + i * spacing[0]; point[1] = origin[1] + j * spacing[1]; ossimGpt ossimWorldPoint; ossimWorldPoint.lon = point[0]; ossimWorldPoint.lat = point[1]; double height = elevManager->getHeightAboveMSL(ossimWorldPoint); if (!ossim::isnan(height)) { // Fill the image image[i + j * size[0]] = height; } else { // Back to the MNT default value image[i + j * size[0]] = 0; } } } std::ofstream file; std::cout << outfname << std::endl; file.open(outfname, ios::binary | ios::out); file.write(reinterpret_cast(image), sizeof(double) * size[0] * size[1]); file.close(); delete[] image; //Create the header std::stringstream headerName; headerName << outfname << ".hdr"; std::ofstream headerFile; headerFile.open(headerName.str().c_str()); headerFile << "ENVI" << std::endl; headerFile << "samples = " << size[0] << std::endl; headerFile << "lines = " << size[1] << std::endl; headerFile << "bands = 1" << std::endl; headerFile << "header offset = 0" << std::endl; headerFile << "file type = ENVI Standard" << std::endl; headerFile << "data type = 5" << std::endl; headerFile << "interleave = bsq" << std::endl; headerFile << "byte order = 0" << std::endl; headerFile << std::endl; headerFile.close(); //Check for the index 216, 51 (difference of 4 in the output) { int i = 216; int j = 51; double point[2]; point[0] = origin[0] + i * spacing[0]; point[1] = origin[1] + j * spacing[1]; ossimGpt ossimWorldPoint; ossimWorldPoint.lon = point[0]; ossimWorldPoint.lat = point[1]; double height = elevManager->getHeightAboveMSL(ossimWorldPoint); std::cout << "Output value at (216, 51): " << height << std::endl; std::cout << "At lon: " << ossimWorldPoint.lon << " , lat: " << ossimWorldPoint.lat << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbOssimJpegFileResourceLeakTest.cxx000066400000000000000000000035321301006202600312270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include #include #include #pragma GCC diagnostic pop #else #include #include #include #endif // This test demonstrate that handler->close() does not release the file descriptor for jpeg files. int otbOssimJpegFileResourceLeakTest(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage:" << std::endl; std::cerr << argv[0] << " infname nbReading" << std::endl; return 1; } const char * infname = argv[1]; const unsigned int nbReading = atoi(argv[2]); for (unsigned int i = 0; i < nbReading; ++i) { // Create the handler ossimImageHandler * handler = ossimImageHandlerRegistry::instance()->open(ossimFilename(infname)); if (!handler) { std::cerr << "Failed to open image " << i << " times." << std::endl; return 1; } handler->close(); } return 0; } OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbPlatformPositionAdapter.cxx000066400000000000000000000046141301006202600301760ustar00rootroot00000000000000/*========================================================================= Copyright 2011 Emmanuel Christophe Contributed to ORFEO Toolbox under license Apache 2 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. =========================================================================*/ #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbPlatformPositionAdapter.h" int otbPlatformPositionComputeBaselineNewTest(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef otb::PlatformPositionAdapter PlatformType; PlatformType::Pointer masterPlatform = PlatformType::New(); return EXIT_SUCCESS; } int otbPlatformPositionComputeBaselineTest(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " imageFile output" << std::endl; return EXIT_FAILURE; } typedef std::complex PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer image = ReaderType::New(); image->SetFileName(argv[1]); image->UpdateOutputInformation(); typedef otb::PlatformPositionAdapter PlatformType; PlatformType::Pointer imagePlatform = PlatformType::New(); imagePlatform->CreateSensorModel(image->GetOutput()->GetImageKeywordlist()); std::vector imagePosition; std::vector imageSpeed; imagePosition.resize(3); imageSpeed.resize(3); imagePlatform->GetPlatformPosition(0, imagePosition, imageSpeed); std::ofstream file; file.open(argv[2]); file << std::setprecision(15); file << "Image:\n"; file << "Pos X: " << imagePosition[0] << " m\n"; file << "Pos Y: " << imagePosition[1] << " m\n"; file << "Pos Z: " << imagePosition[2] << " m\n"; file << "Spd X: " << imageSpeed[0] << " m/s\n"; file << "Spd Y: " << imageSpeed[1] << " m/s\n"; file << "Spd Z: " << imageSpeed[2] << " m/s\n"; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/OSSIMAdapters/test/otbRPCSolverAdapterTest.cxx000066400000000000000000000143101301006202600273360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbGenericRSTransform.h" #include "otbGeographicalDistance.h" #include "itkEuclideanDistanceMetric.h" #include "otbSensorModelAdapter.h" #include "otbRPCSolverAdapter.h" typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::GenericRSTransform<> RSTranformType; typedef otb::RPCSolverAdapter::Point2DType Point2DType; typedef otb::RPCSolverAdapter::Point3DType Point3DType; typedef otb::GenericRSTransform RSTranform3dType; typedef itk::Statistics::EuclideanDistanceMetric EuclideanDistanceMetricType; typedef otb::GeographicalDistance GeoDistanceType; int otbRPCSolverAdapterTest(int argc, char* argv[]) { if (argc < 7) { std::cout << "Usage: test_driver input grid_size geo_tol img_tol dem_dir geoid" << std::endl; return EXIT_FAILURE; } // This test takes a sensor model (possibly a rpc one), use it to // generate gcps and estimate a rpc model. It then checks the // precision of both forward and inverse transform std::string infname = argv[1]; const unsigned int gridSize = atoi(argv[2]); const double geoTol = atof(argv[3]); const double imgTol = atof(argv[4]); const std::string demdir = argv[5]; const std::string geoid = argv[6]; if (gridSize == 0) { std::cerr << "Grid size is null!" << std::endl; return EXIT_FAILURE; } std::cout<<"GeoTol: "<SetDefaultHeightAboveEllipsoid(0); if(demdir!="no") demHandler->OpenDEMDirectory(demdir); if(geoid!="no") demHandler->OpenGeoidFile(geoid); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->UpdateOutputInformation(); RSTranformType::Pointer fwd2dTransform = RSTranformType::New(); fwd2dTransform->SetInputKeywordList(reader->GetOutput()->GetImageKeywordlist()); fwd2dTransform->InstantiateTransform(); ImageType::SizeType size = reader->GetOutput()->GetLargestPossibleRegion().GetSize(); unsigned int stepx = size[0]/gridSize; unsigned int stepy = size[1]/gridSize; otb::RPCSolverAdapter::GCPsContainerType gcps; // Generate gcps for(unsigned int i = 0; i < gridSize; ++i) { for(unsigned int j = 0; j < gridSize; ++j) { ImageType::IndexType currentIndex; currentIndex[0] = i*stepx; currentIndex[1] = j*stepy; Point2DType currentPoint, currentWgs84Point; reader->GetOutput()->TransformIndexToPhysicalPoint(currentIndex,currentPoint); currentWgs84Point = fwd2dTransform->TransformPoint(currentPoint); double height = otb::DEMHandler::Instance()->GetHeightAboveEllipsoid(currentWgs84Point); Point3DType current3DWgs84Point; current3DWgs84Point[0] = currentWgs84Point[0]; current3DWgs84Point[1] = currentWgs84Point[1]; current3DWgs84Point[2] = height; gcps.push_back(std::make_pair(currentPoint,current3DWgs84Point)); std::cout<first<<") = "<TransformPoint(groundPoint2dRef); double imgRes = euclideanDistanceMetric->Evaluate(imgPoint,it->first); if(imgRes>imgTol) { fail = true; std::cerr<<"Imprecise result with inverse estimated model: inv("<first<<" error: "< #include #include #include double convertStringToDouble(const std::string& s) { std::istringstream i(s); double x; if (!(i >> x)) return 0; return x; } int otbTestImageKeywordlist(int argc, char* argv[]) { if (argc != 6) { std::cout << argv[0] << " " <<" " << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; const char* inputFilename = argv[1]; std::istringstream issNeededKw(argv[2]); std::istringstream issTols(argv[3]); char * outGeomFilename = argv[4]; bool checkAllKw = argv[5]; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); otb::ImageKeywordlist kwlist = reader->GetOutput()->GetImageKeywordlist(); if (!(kwlist.GetSize() > 0)) { std::cerr<<"Error : imageKeywordlist is empty."<second); KeywordlistMapType::iterator it = kwmap2.find(kwlistIt->first); if (it != kwmap2.end() ) { val2 = convertStringToDouble(it->second); } else { std::cerr << "Error : couldn't find key " << kwlistIt->first << " in reloaded keyword list." << std::endl; return EXIT_FAILURE; } if ( fabs( val2 - val1 ) > 0.01 ) { std::cerr << "Error : orig key/value (" << kwlistIt->first << " " << kwlistIt->second << ")"<< std::endl << "reloaded key/value (" << kwlistIt->first << " " << kwmap2[kwlistIt->first] << ")"<< std::endl; return EXIT_FAILURE; } ++kwlistIt; } } else // Check only needed keywords { // #1 keywordlist, only check the needed keywords /*-------------------------------------*/ //Split the string into many tokens, with whitespaces as separators std::list neededKw; copy(std::istream_iterator(issNeededKw), std::istream_iterator(), back_inserter(neededKw)); std::list missingKw; for(std::list::iterator neededIt=neededKw.begin(); neededIt!=neededKw.end(); ++neededIt) { bool foundNeededKw = false; for(KeywordlistMapType::iterator kwlistIt=kwmap.begin(); kwlistIt!=kwmap.end(); ++kwlistIt) { std::size_t found = kwlistIt->first.find(*neededIt); if (found!=std::string::npos) { foundNeededKw = true; } } if (!foundNeededKw) missingKw.push_back(*neededIt); } if ( (neededKw.size()>0) && (missingKw.size()>0) ) { std::cerr << "Error : some keywords were not found; missing keywords : " << std::endl; for (std::list::iterator itm = missingKw.begin(); itm != missingKw.end(); ++itm) std::cerr << *itm << std::endl; return EXIT_FAILURE; } /*-------------------------------------*/ // #2 Write keywordlist, read it, compare it to the original list WriteGeometry(kwlist,outGeomFilename); otb::ImageKeywordlist kwlist2 = otb::ReadGeometryFromGEOMFile(outGeomFilename); KeywordlistMapType kwmap2 = kwlist2.GetKeywordlist(); //Split the string into many tokens, with whitespaces as separators std::list tols; copy(std::istream_iterator(issTols), std::istream_iterator(), back_inserter(tols)); if (tols.size() != neededKw.size() ) { std::cerr << "Error : needed keywords list should have the same size as the tolerances one (needed / tols): " << neededKw.size() << " " << tols.size() << std::endl; return EXIT_FAILURE; } std::map mapKwTol; std::pair::iterator,bool> ret; std::list::iterator tolsIt=tols.begin(); std::list::iterator neededKwIt=neededKw.begin(); while ( (tolsIt!=tols.end()) && (neededKwIt!=neededKw.end()) ) { mapKwTol.insert( std::pair(*neededKwIt, convertStringToDouble(*tolsIt) ) ); ++tolsIt; ++neededKwIt; } if (kwmap.size() != kwmap2.size() ) { std::cerr << "Error : keyword lists don't have the same size (orig / reloaded): " << kwmap.size() << " / " << kwmap2.size() << std::endl; return EXIT_FAILURE; } for(std::list::iterator neededIt=neededKw.begin(); neededIt!=neededKw.end(); ++neededIt) { KeywordlistMapType::iterator kwlistIt = kwmap.begin(); KeywordlistMapType::iterator kwlistIt2 = kwmap2.begin(); while ( (kwlistIt!=kwmap.end()) && (kwlistIt2!=kwmap2.end()) ) { std::size_t found = kwlistIt->first.find(*neededIt); if (found!=std::string::npos) // keyword found { if ( fabs( convertStringToDouble(kwlistIt->second) - convertStringToDouble(kwlistIt2->second)) > mapKwTol[*neededIt] ) { std::cerr << "Error : orig key/value (" << kwlistIt->first << " " << kwlistIt->second << ")"<< std::endl << "reloaded key/value (" << kwlistIt2->first << " " << kwlistIt2->second << ")"<< std::endl; return EXIT_FAILURE; } } ++kwlistIt; ++kwlistIt2; } } } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/000077500000000000000000000000001301006202600224715ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/CMakeLists.txt000066400000000000000000000001601301006202600252260ustar00rootroot00000000000000project(OTBOpenThreadsAdapters) set(OTBOpenThreadsAdapters_LIBRARIES OTBOpenThreadsAdapters) otb_module_impl() OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/include/000077500000000000000000000000001301006202600241145ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/include/otbThreads.h000066400000000000000000000017201301006202600263640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbThreads_h #define otbThreads_h namespace otb { /** \class Threads * \brief Operation from open threads that are used in Monteverdi * * Implement the sleep operation from openthreads to remove Monteverdi * dependence to openthreads at compile time. * * * \ingroup OTBOpenThreadsAdapters */ class Threads { public: static int Sleep(unsigned int microsec); }; } // namespace otb #endif OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/otb-module.cmake000066400000000000000000000003531301006202600255430ustar00rootroot00000000000000set(DOCUMENTATION "Adapters for the OpenThreads library (thread interface for C++).") otb_module(OTBOpenThreadsAdapters DEPENDS OTBOpenThreads TEST_DEPENDS OTBITK OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/src/000077500000000000000000000000001301006202600232605ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/src/CMakeLists.txt000066400000000000000000000003611301006202600260200ustar00rootroot00000000000000set(OTBOpenThreadsAdapters_SRC otbThreads.cxx ) add_library(OTBOpenThreadsAdapters ${OTBOpenThreadsAdapters_SRC}) target_link_libraries(OTBOpenThreadsAdapters ${OTBOpenThreads_LIBRARIES} ) otb_module_target(OTBOpenThreadsAdapters) OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/src/otbThreads.cxx000066400000000000000000000013441301006202600261050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbThreads.h" #include namespace otb { int Threads::Sleep(unsigned int microsec) { return OpenThreads::Thread::microSleep(microsec); } } OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/test/000077500000000000000000000000001301006202600234505ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/test/CMakeLists.txt000066400000000000000000000007131301006202600262110ustar00rootroot00000000000000otb_module_test() set(OTBOpenThreadsAdaptersTests otbOpenThreadsAdaptersTestDriver.cxx otbThreadsTest.cxx ) add_executable(otbOpenThreadsAdaptersTestDriver ${OTBOpenThreadsAdaptersTests}) target_link_libraries(otbOpenThreadsAdaptersTestDriver ${OTBOpenThreadsAdapters-Test_LIBRARIES}) otb_module_target_label(otbOpenThreadsAdaptersTestDriver) # Tests Declaration otb_add_test(NAME ioTvThreadsTest COMMAND otbOpenThreadsAdaptersTestDriver otbThreadsTest) OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/test/otbOpenThreadsAdaptersTestDriver.cxx000066400000000000000000000001231301006202600326110ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbThreadsTest); } OTB-release-5.8/Modules/Adapters/OpenThreadsAdapters/test/otbThreadsTest.cxx000066400000000000000000000013631301006202600271360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbThreads.h" #include "itkMacro.h" int otbThreadsTest(int itkNotUsed(argc), char* itkNotUsed(argv) []) { otb::Threads::Sleep(10); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Adapters/QtAdapters/000077500000000000000000000000001301006202600206415ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/QtAdapters/CMakeLists.txt000066400000000000000000000001321301006202600233750ustar00rootroot00000000000000project( OTBQtAdapters ) set( OTBQtAdapters_LIBRARIES OTBQtAdapters) otb_module_impl() OTB-release-5.8/Modules/Adapters/QtAdapters/include/000077500000000000000000000000001301006202600222645ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/QtAdapters/include/otbQtAdapters.h000066400000000000000000000146041301006202600252170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQtAdapters_h #define otbQtAdapters_h #include "OTBQtAdaptersExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include #endif //tag=QT4-boost-compatibility // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } // // Internal classes pre-declaration. namespace otb { } // end namespace 'otb' /*****************************************************************************/ /* TYPE DEFINITION SECTION */ namespace otb { } // end of namespace otb. /*****************************************************************************/ /* FUNCTION DECLARATION SECTION */ namespace otb { /** * \brief This is a convenience static method that will return an * existing directory path selected by the user. * * This method stores the last accepted directory for next call. * * \see http://qt-project.org/doc/qt-4.8/qfiledialog.html#getExistingDirectory * * \param parent Parent widget of that QFileDialog. * \param caption Title-bar caption of that QFileDialog. * \param dir Directory location where to pick path. * \param options of that QFileDialog. * * \return The selected path or an null QString if QFileDialog has * been rejected. */ QString OTBQtAdapters_EXPORT GetExistingDirectory( QWidget * p = 0, const QString & caption = QString(), const QString & dir = QString(), QFileDialog::Options options = QFileDialog::ShowDirsOnly ); /** * \brief This is a convenience static method that will return an * existing filename selected by the user. * * This method stores the last accepted directory for next call. * * \see http://qt-project.org/doc/qt-4.8/qfiledialog.html#getOpenFileName * * \param parent Parent widget of that QFileDialog. * \param caption Title-bar caption of that QFileDialog. * \param dir Directory location where to pick path. * \param filter Filename filter (e.g. wildcards). * \param selectedFilter Filter which has been selected by the user. * \param options Options of that QFileDialog. * * \return The selected filename or an null QString if QFileDialog has * been rejected. */ QString OTBQtAdapters_EXPORT GetOpenFileName( QWidget * p =0, const QString & caption = QString(), const QString & dir = QString(), const QString & filter = QString(), QString * selectedFilter = 0, QFileDialog::Options options = 0 ); /** * \brief This is a convenience static method that will return a * list of existing filenames selected by the user. * * This method stores the last accepted directory for next call. * * \see http://qt-project.org/doc/qt-4.8/qfiledialog.html#getOpenFileNames * * \param parent Parent widget of that QFileDialog. * \param caption Title-bar caption of that QFileDialog. * \param dir Directory location where to pick path. * \param filter Filename filter (e.g. wildcards). * \param selectedFilter Filter which has been selected by the user. * \param options of that QFileDialog. * * \return The selected filename list or an empty QStringLIst if * QFileDialog has been rejected. */ QStringList OTBQtAdapters_EXPORT GetOpenFileNames( QWidget * p =0, const QString & caption = QString(), const QString & dir = QString(), const QString & filter = QString(), QString * selectedFilter = 0, QFileDialog::Options options = 0 ); /** * \brief This is a convenience static method that will return a * filename selected by the user. This file does not have to exist. * * This method stores the last accepted directory for next call. * * \see http://qt-project.org/doc/qt-4.8/qfiledialog.html#getSaveFileName * * \param parent Parent widget of that QFileDialog. * \param caption Title-bar caption of that QFileDialog. * \param dir Directory location where to pick path. * \param filter Filename filter (e.g. wildcards). * \param selectedFilter Filter which has been selected by the user. * \param options of that QFileDialog. * * \return The selected filename list or an empty QStringLIst if * QFileDialog has been rejected. */ QString OTBQtAdapters_EXPORT GetSaveFileName( QWidget * p =0, const QString & caption = QString(), const QString & dir = QString(), const QString & filter = QString(), QString * selectedFilter = 0, QFileDialog::Options options = 0 ); /** * \return Working directory of Qt-based applications (see * http://doc.qt.io/qt-4.8/qdir.html#currentPath). */ QString OTBQtAdapters_EXPORT GetWorkingDir(); /** * \brief Set working directory for Qt-based applications (see * http://doc.qt.io/qt-4.8/qdir.html#setCurrent). * * \param path Path to working directory. * * \return true if working directory has successfully * been changed. */ bool OTBQtAdapters_EXPORT SetWorkingDir( const QString & path ); /** * \brief Static path to the last directory used in file dialogs */ static QString RecentDirectory; } // end namespace 'otb'. /*****************************************************************************/ /* INLINE SECTION */ namespace otb { } // end namespace 'otb'. #endif // otbQtAdapters_h OTB-release-5.8/Modules/Adapters/QtAdapters/otb-module.cmake000066400000000000000000000002231301006202600237070ustar00rootroot00000000000000set( DOCUMENTATION "Adapters for the Qt Library.") otb_module( OTBQtAdapters ENABLE_SHARED DEPENDS OTBQt4 DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Adapters/QtAdapters/src/000077500000000000000000000000001301006202600214305ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/QtAdapters/src/CMakeLists.txt000066400000000000000000000007131301006202600241710ustar00rootroot00000000000000set( OTBQtAdapters_SRC otbQtAdapters.cxx ) set( OTBQtAdapters_HEADERS_MOC # otbQtAdapters.h ) add_to_qt4_i18n_sources( ${OTBQtAdapters_SRCS} ) add_to_qt4_i18n_headers( "../include" ${OTBQtAdapters_SRCS} ) qt4_wrap_cpp( OTBQtAdapters_SRC_MOC ${OTBQtAdapters_HEADERS_MOC} ) add_library( OTBQtAdapters ${OTBQtAdapters_SRC} ${OTBQtAdapters_SRC_MOC}) target_link_libraries( OTBQtAdapters ${OTBQt4_LIBRARIES} ) otb_module_target( OTBQtAdapters ) OTB-release-5.8/Modules/Adapters/QtAdapters/src/otbQtAdapters.cxx000066400000000000000000000113531301006202600247340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbQtAdapters.h" #include /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) namespace otb { /* TRANSLATOR otb::QtAdapters Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ QString GetExistingDirectory( QWidget * p, const QString& caption, const QString& dir, QFileDialog::Options options ) { QString path( QFileDialog::getExistingDirectory( p, caption.isEmpty() ? QObject::tr( "Select directory..." ) : caption, dir.isEmpty() ? RecentDirectory : dir, options ) ); if( !path.isNull() ) { // Absolute path expected from QFileDialog SetWorkingDir( path ); } return path; } /*****************************************************************************/ QString GetOpenFileName( QWidget * p, const QString& caption, const QString& dir, const QString& filter, QString* selectedFilter, QFileDialog::Options options ) { QString filename( QFileDialog::getOpenFileName( p, caption.isEmpty() ? QObject::tr( "Open file..." ) : caption, dir.isEmpty() ? RecentDirectory : dir, filter, selectedFilter, options ) ); // Absolute path expected from QFileDialog if( !filename.isNull() ) SetWorkingDir( filename ); return filename; } /*****************************************************************************/ QStringList GetOpenFileNames( QWidget * p, const QString & caption, const QString & dir, const QString & filter, QString * selectedFilter, QFileDialog::Options options ) { QStringList filenames( QFileDialog::getOpenFileNames( p, caption.isEmpty() ? QObject::tr( "Open file..." ) : caption, dir.isEmpty() ? RecentDirectory : dir, filter, selectedFilter, options ) ); // Absolute path expected from QFileDialog if( !filenames.isEmpty() ) SetWorkingDir( filenames.back() ); return filenames; } /*****************************************************************************/ QString GetSaveFileName( QWidget * p, const QString & caption, const QString & dir, const QString & filter, QString * selectedFilter, QFileDialog::Options options ) { QString filename( QFileDialog::getSaveFileName( p, caption.isEmpty() ? QObject::tr( "Save file..." ) : caption, dir.isEmpty() ? RecentDirectory : dir, filter, selectedFilter, options ) ); // Absolute path expected from QFileDialog if( !filename.isNull() ) SetWorkingDir( filename ); return filename; } /*****************************************************************************/ QString GetWorkingDir() { return RecentDirectory; } /*****************************************************************************/ bool SetWorkingDir( const QString & filepath ) { assert( !filepath.isEmpty() ); QFileInfo finfo( filepath ); #if 0 return QDir::setCurrent( finfo.isDir() ? filepath : finfo.path() ); #else // TODO : add mutex if needed QString dir = finfo.isDir() ? filepath : finfo.path(); if ( !QFileInfo(dir).isDir() ) return false; RecentDirectory = finfo.isDir() ? filepath : finfo.path(); return true; #endif } } // end namespace 'otb' OTB-release-5.8/Modules/Adapters/QtAdapters/test/000077500000000000000000000000001301006202600216205ustar00rootroot00000000000000OTB-release-5.8/Modules/Adapters/QtAdapters/test/CMakeLists.txt000066400000000000000000000001041301006202600243530ustar00rootroot00000000000000otb_module_test() # include_directories( ${OTBCommon_BINARY_DIR} ) OTB-release-5.8/Modules/Applications/000077500000000000000000000000001301006202600174545ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppChangeDetection/000077500000000000000000000000001301006202600231415ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppChangeDetection/CMakeLists.txt000066400000000000000000000000611301006202600256760ustar00rootroot00000000000000project(OTBAppChangeDetection) otb_module_impl() OTB-release-5.8/Modules/Applications/AppChangeDetection/app/000077500000000000000000000000001301006202600237215ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppChangeDetection/app/CMakeLists.txt000066400000000000000000000004311301006202600264570ustar00rootroot00000000000000set(OTBAppChangeDetection_LINK_LIBS ${OTBApplicationEngine_LIBRARIES} ${OTBChangeDetection_LIBRARIES} ) otb_create_application( NAME MultivariateAlterationDetector SOURCES otbMultivariateAlterationDetector.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppChangeDetection/app/otbMultivariateAlterationDetector.cxx000066400000000000000000000131631301006202600333410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultivariateAlterationDetectorImageFilter.h" namespace otb { namespace Wrapper { class MultivariateAlterationDetector: public Application { public: /** Standard class typedefs. */ typedef MultivariateAlterationDetector Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(MultivariateAlterationDetector, otb::Wrapper::Application); private: void DoInit() ITK_OVERRIDE { SetName("MultivariateAlterationDetector"); SetDescription("Multivariate Alteration Detector"); // Documentation SetDocName("Multivariate alteration detector"); SetDocLongDescription("This application detects change between two given images."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" This filter implements the Multivariate Alteration Detector, based " " on the following work: \n" " A. A. Nielsen and K. Conradsen, Multivariate alteration detection" " (mad) in multispectral, bi-temporal image data: a new approach to" " change detection studies, Remote Sens. Environ., vol. 64," " pp. 1-19, (1998) \n" " \n" " Multivariate Alteration Detector takes two images as inputs and " " produce a set of N change maps as a VectorImage (where N is the " " maximum of number of bands in first and second image) with the " " following properties: \n" " - Change maps are differences of a pair of linear combinations of " " bands from image 1 and bands from image 2 chosen to maximize the " " correlation. \n" " - Each change map is orthogonal to the others. \n" " \n" " This is a statistical method which can handle different modalities " " and even different bands and number of bands between images. \n" " \n" " If numbers of bands in image 1 and 2 are equal, then change maps " " are sorted by increasing correlation. If number of bands is " " different, the change maps are sorted by decreasing correlation. \n" " \n" " The GetV1() and GetV2() methods allow retrieving the linear " " combinations used to generate the Mad change maps as a vnl_matrix of " " double, and the GetRho() method allows retrieving the correlation " " associated to each Mad change maps as a vnl_vector. \n" " \n" " This filter has been implemented from the Matlab code kindly made " " available by the authors here: \n" " http://www2.imm.dtu.dk/~aa/software.html \n" " \n" " Both cases (same and different number of bands) have been validated " " by comparing the output image to the output produced by the Matlab " " code, and the reference images for testing have been generated from " " the Matlab code using Octave." ); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in1", "Input Image 1"); SetParameterDescription("in1","Image which describe initial state of the scene."); AddParameter(ParameterType_InputImage, "in2", "Input Image 2"); SetParameterDescription("in2","Image which describe scene after perturbations."); AddParameter(ParameterType_OutputImage, "out", "Change Map"); SetParameterDescription("out","Image of detected changes."); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in1", "Spot5-Gloucester-before.tif"); SetDocExampleParameterValue("in2", "Spot5-Gloucester-after.tif"); SetDocExampleParameterValue("out", "detectedChangeImage.tif"); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { typedef otb::MultivariateAlterationDetectorImageFilter< FloatVectorImageType, FloatVectorImageType> ChangeFilterType; ChangeFilterType::Pointer changeFilter = ChangeFilterType::New(); changeFilter->SetInput1(GetParameterImage("in1")); changeFilter->SetInput2(GetParameterImage("in2")); changeFilter->GetOutput()->UpdateOutputInformation(); otbAppLogINFO("Input 1 mean: "<GetMean1()); otbAppLogINFO("Input 2 mean: "<GetMean2()); otbAppLogINFO("Input 1 transform: "<GetV1()); otbAppLogINFO("Input 2 transform: "<GetV2()); otbAppLogINFO("Rho: "<GetRho()); m_Ref = changeFilter; SetParameterOutputImage("out", changeFilter->GetOutput()); } itk::LightObject::Pointer m_Ref; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::MultivariateAlterationDetector) OTB-release-5.8/Modules/Applications/AppChangeDetection/otb-module.cmake000066400000000000000000000004221301006202600262100ustar00rootroot00000000000000set(DOCUMENTATION "Change detection application (see also ChangeDetection module).") otb_module(OTBAppChangeDetection DEPENDS OTBApplicationEngine OTBChangeDetection TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppChangeDetection/test/000077500000000000000000000000001301006202600241205ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppChangeDetection/test/CMakeLists.txt000066400000000000000000000012651301006202600266640ustar00rootroot00000000000000otb_module_test() #----------- MultivariateAlterationDetector TESTS ---------------- otb_test_application(NAME apTvChMultivariateAlterationDetector APP MultivariateAlterationDetector OPTIONS -in1 ${INPUTDATA}/Spot5-Gloucester-before.tif -in2 ${INPUTDATA}/Spot5-Gloucester-after.tif -out ${TEMP}/apTvChMultivariateAlterationDetectorSameNbBands.tif VALID --compare-image 0.025 ${BASELINE}/cdTvMultivariateAlterationDetectorImageFilterOutputSameNbBands.tif ${TEMP}/apTvChMultivariateAlterationDetectorSameNbBands.tif) OTB-release-5.8/Modules/Applications/AppClassification/000077500000000000000000000000001301006202600230505ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppClassification/CMakeLists.txt000066400000000000000000000000601301006202600256040ustar00rootroot00000000000000project(OTBAppClassification) otb_module_impl() OTB-release-5.8/Modules/Applications/AppClassification/app/000077500000000000000000000000001301006202600236305ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppClassification/app/CMakeLists.txt000066400000000000000000000076751301006202600264070ustar00rootroot00000000000000set(OTBAppClassification_LINK_LIBS ${OTBVectorDataBase_LIBRARIES} ${OTBConversion_LIBRARIES} ${OTBStatistics_LIBRARIES} ${OTBColorMap_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBInterpolation_LIBRARIES} ${OTBMajorityVoting_LIBRARIES} ${OTBVectorDataIO_LIBRARIES} ${OTBSOM_LIBRARIES} ${OTBSVMLearning_LIBRARIES} ${OTBLearningBase_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBIndices_LIBRARIES} ${OTBMathParser_LIBRARIES} ${OTBDempsterShafer_LIBRARIES} ${OTBGdalAdapters_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBIOXML_LIBRARIES} ${OTBVectorDataManipulation_LIBRARIES} ${OTBStreaming_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBObjectList_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_create_application( NAME ComputeOGRLayersFeaturesStatistics SOURCES otbComputeOGRLayersFeaturesStatistics.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME SOMClassification SOURCES otbSOMClassification.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ImageClassifier SOURCES otbImageClassifier.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME TrainOGRLayersClassifier SOURCES otbTrainOGRLayersClassifier.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME TrainVectorClassifier SOURCES otbTrainVectorClassifier.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ComputeConfusionMatrix SOURCES otbComputeConfusionMatrix.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME FusionOfClassifications SOURCES otbFusionOfClassifications.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ComputePolylineFeatureFromImage SOURCES otbComputePolylineFeatureFromImage.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME KMeansClassification SOURCES otbKMeansClassification.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME TrainImagesClassifier SOURCES otbTrainImagesClassifier.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME TrainRegression SOURCES otbTrainRegression.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME PredictRegression SOURCES otbPredictRegression.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME DSFuzzyModelEstimation SOURCES otbDSFuzzyModelEstimation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ClassificationMapRegularization SOURCES otbClassificationMapRegularization.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME OGRLayerClassifier SOURCES otbOGRLayerClassifier.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ComputeImagesStatistics SOURCES otbComputeImagesStatistics.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME VectorDataDSValidation SOURCES otbVectorDataDSValidation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME PolygonClassStatistics SOURCES otbPolygonClassStatistics.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME SampleSelection SOURCES otbSampleSelection.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME SampleExtraction SOURCES otbSampleExtraction.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME MultiImageSamplingRate SOURCES otbMultiImageSamplingRate.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppClassification/app/otbClassificationMapRegularization.cxx000066400000000000000000000201351301006202600333730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Wrappers #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" // Majority Voting filter includes #include "otbNeighborhoodMajorityVotingImageFilter.h" namespace otb { namespace Wrapper { class ClassificationMapRegularization : public Application { public: /** Standard class typedefs. */ typedef ClassificationMapRegularization Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ClassificationMapRegularization, otb::Application); /** Filters typedef */ typedef UInt16ImageType IOLabelImageType; // Neighborhood majority voting filter type typedef otb::NeighborhoodMajorityVotingImageFilter NeighborhoodMajorityVotingFilterType; // Binary ball Structuring Element type typedef NeighborhoodMajorityVotingFilterType::KernelType StructuringType; typedef StructuringType::RadiusType RadiusType; private: void DoInit() ITK_OVERRIDE { SetName("ClassificationMapRegularization"); SetDescription("Filters the input labeled image using Majority Voting in a ball shaped neighbordhood."); SetDocName("Classification Map Regularization"); SetDocLongDescription("This application filters the input labeled image (with a maximal class label = 65535) using Majority Voting in a ball shaped neighbordhood. Majority Voting takes the more representative value of all the pixels identified by the ball shaped structuring element and then sets the center pixel to this majority label value.\n\ -NoData is the label of the NOT classified pixels in the input image. These input pixels keep their NoData label in the output image.\n\ -Pixels with more than 1 majority class are marked as Undecided if the parameter 'ip.suvbool == true', or keep their Original labels otherwise."); SetDocLimitations("The input image must be a single band labeled image (with a maximal class label = 65535). The structuring element radius must have a minimum value equal to 1 pixel. Please note that the Undecided value must be different from existing labels in the input labeled image."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("Documentation of the ClassificationMapRegularization application."); AddDocTag(Tags::Learning); AddDocTag(Tags::Analysis); /** GROUP IO CLASSIFICATION */ AddParameter(ParameterType_Group,"io","Input and output images"); SetParameterDescription("io","This group of parameters allows setting input and output images for classification map regularization by Majority Voting."); AddParameter(ParameterType_InputImage, "io.in", "Input classification image"); SetParameterDescription( "io.in", "The input labeled image to regularize."); AddParameter(ParameterType_OutputImage, "io.out", "Output regularized image"); SetParameterDescription( "io.out", "The output regularized labeled image."); SetDefaultOutputPixelType( "io.out", ImagePixelType_uint8); AddParameter(ParameterType_Group,"ip","Regularization parameters"); SetParameterDescription("ip","This group allows setting parameters for classification map regularization by Majority Voting."); AddParameter(ParameterType_Int, "ip.radius", "Structuring element radius (in pixels)"); SetParameterDescription("ip.radius", "The radius of the ball shaped structuring element (expressed in pixels). By default, 'ip.radius = 1 pixel'."); SetDefaultParameterInt("ip.radius", 1.0); AddParameter(ParameterType_Empty, "ip.suvbool", "Multiple majority: Undecided(X)/Original"); SetParameterDescription("ip.suvbool", "Pixels with more than 1 majority class are marked as Undecided if this parameter is checked (true), or keep their Original labels otherwise (false). Please note that the Undecided value must be different from existing labels in the input labeled image. By default, 'ip.suvbool = false'."); AddParameter(ParameterType_Int, "ip.nodatalabel", "Label for the NoData class"); SetParameterDescription("ip.nodatalabel", "Label for the NoData class. Such input pixels keep their NoData label in the output image. By default, 'ip.nodatalabel = 0'."); SetDefaultParameterInt("ip.nodatalabel", 0.0); AddParameter(ParameterType_Int, "ip.undecidedlabel", "Label for the Undecided class"); SetParameterDescription("ip.undecidedlabel", "Label for the Undecided class. By default, 'ip.undecidedlabel = 0'."); SetDefaultParameterInt("ip.undecidedlabel", 0.0); AddParameter(ParameterType_Empty, "ip.onlyisolatedpixels", "Process isolated pixels only"); SetParameterDescription("ip.onlyisolatedpixels", "Only pixels whose label is unique in the neighbordhood will be processed. By default, 'ip.onlyisolatedpixels = false'."); AddParameter(ParameterType_Int, "ip.isolatedthreshold", "Threshold for isolated pixels"); SetParameterDescription("ip.isolatedthreshold", "Maximum number of neighbours with the same label as the center pixel to consider that it is an isolated pixel. By default, 'ip.isolatedthreshold = 1'."); SetDefaultParameterInt("ip.isolatedthreshold", 1); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("io.in", "clLabeledImageQB123_1.tif"); SetDocExampleParameterValue("io.out", "clLabeledImageQB123_1_CMR_r2_nodl_10_undl_7.tif"); SetDocExampleParameterValue("ip.radius", "2"); SetDocExampleParameterValue("ip.suvbool", "true"); SetDocExampleParameterValue("ip.onlyisolatedpixels", "true"); SetDocExampleParameterValue("ip.nodatalabel", "10"); SetDocExampleParameterValue("ip.undecidedlabel", "7"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { // Majority Voting m_NeighMajVotingFilter = NeighborhoodMajorityVotingFilterType::New(); // Load input labeled image to regularize UInt16ImageType::Pointer inImage = GetParameterUInt16Image("io.in"); // Neighborhood majority voting filter settings RadiusType rad; rad[0] = GetParameterInt("ip.radius"); rad[1] = GetParameterInt("ip.radius"); StructuringType seBall; seBall.SetRadius(rad); seBall.CreateStructuringElement(); m_NeighMajVotingFilter->SetKernel(seBall); m_NeighMajVotingFilter->SetInput(inImage); m_NeighMajVotingFilter->SetLabelForNoDataPixels(GetParameterInt("ip.nodatalabel")); m_NeighMajVotingFilter->SetLabelForUndecidedPixels(GetParameterInt("ip.undecidedlabel")); // Set to Undecided label if NOT unique Majority Voting if (IsParameterEnabled("ip.suvbool")) { m_NeighMajVotingFilter->SetKeepOriginalLabelBool(false); } // Keep Original label value if NOT unique Majority Voting else { m_NeighMajVotingFilter->SetKeepOriginalLabelBool(true); } // Process isolated pixels only if (IsParameterEnabled("ip.onlyisolatedpixels")) { m_NeighMajVotingFilter->SetOnlyIsolatedPixels(true); m_NeighMajVotingFilter->SetIsolatedThreshold(GetParameterInt("ip.isolatedthreshold")); } else { m_NeighMajVotingFilter->SetOnlyIsolatedPixels(false); } /** REGULARIZATION OF CLASSIFICATION */ SetParameterOutputImage("io.out", m_NeighMajVotingFilter->GetOutput()); }// END DoExecute() NeighborhoodMajorityVotingFilterType::Pointer m_NeighMajVotingFilter; }; // END class ClassificationMapRegularization }// END namespace wrapper }// END namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::ClassificationMapRegularization) OTB-release-5.8/Modules/Applications/AppClassification/app/otbComputeConfusionMatrix.cxx000066400000000000000000000417771301006202600315660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbOGRDataSourceToLabelImageFilter.h" #include "itkImageRegionConstIterator.h" #include "otbRAMDrivenAdaptativeStreamingManager.h" #include "otbConfusionMatrixMeasurements.h" namespace otb { namespace Wrapper { class ComputeConfusionMatrix : public Application { public: /** Standard class typedefs. */ typedef ComputeConfusionMatrix Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ComputeConfusionMatrix, otb::Application); typedef itk::ImageRegionConstIterator ImageIteratorType; typedef otb::OGRDataSourceToLabelImageFilter RasterizeFilterType; typedef RAMDrivenAdaptativeStreamingManager RAMDrivenAdaptativeStreamingManagerType; typedef Int32ImageType::RegionType RegionType; typedef int ClassLabelType; typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef std::map< ClassLabelType, std::map > OutputConfusionMatrixType; // filter type typedef otb::ConfusionMatrixMeasurements ConfusionMatrixMeasurementsType; typedef ConfusionMatrixMeasurementsType::MapOfClassesType MapOfClassesType; typedef ConfusionMatrixMeasurementsType::MeasurementType MeasurementType; private: void DoInit() ITK_OVERRIDE { SetName("ComputeConfusionMatrix"); SetDescription("Computes the confusion matrix of a classification"); // Documentation SetDocName("Confusion matrix Computation"); SetDocLongDescription("This application computes the confusion matrix of a classification map relatively to a ground truth. " "This ground truth can be given as a raster or a vector data. Only reference and produced pixels with values different " "from NoData are handled in the calculation of the confusion matrix. The confusion matrix is organized the following way: " "rows = reference labels, columns = produced labels. In the header of the output file, the reference and produced class labels " "are ordered according to the rows/columns of the confusion matrix."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription( "in", "The input classification image." ); AddParameter(ParameterType_OutputFilename, "out", "Matrix output"); SetParameterDescription("out", "Filename to store the output matrix (csv format)"); AddParameter(ParameterType_Choice,"ref","Ground truth"); SetParameterDescription("ref","Choice of ground truth format"); AddChoice("ref.raster","Ground truth as a raster image"); AddChoice("ref.vector","Ground truth as a vector data file"); AddParameter(ParameterType_InputImage,"ref.raster.in","Input reference image"); SetParameterDescription("ref.raster.in","Input image containing the ground truth labels"); AddParameter(ParameterType_InputFilename,"ref.vector.in","Input reference vector data"); SetParameterDescription("ref.vector.in", "Input vector data of the ground truth"); AddParameter(ParameterType_String,"ref.vector.field","Field name"); SetParameterDescription("ref.vector.field","Field name containing the label values"); SetParameterString("ref.vector.field","Class"); MandatoryOff("ref.vector.field"); DisableParameter("ref.vector.field"); AddParameter(ParameterType_Int,"nodatalabel","Value for nodata pixels"); SetParameterDescription("nodatalabel", "Label for the NoData class. Such input pixels will be discarded from the " "ground truth and from the input classification map. By default, 'nodatalabel = 0'."); SetDefaultParameterInt("nodatalabel",0); MandatoryOff("nodatalabel"); DisableParameter("nodatalabel"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "clLabeledImageQB1.tif"); SetDocExampleParameterValue("out", "ConfusionMatrix.csv"); SetDocExampleParameterValue("ref", "vector"); SetDocExampleParameterValue("ref.vector.in","VectorData_QB1_bis.shp"); SetDocExampleParameterValue("ref.vector.field","Class"); SetDocExampleParameterValue("nodatalabel","255"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } std::string LogConfusionMatrix(MapOfClassesType* mapOfClasses, ConfusionMatrixType* matrix) { // Compute minimal width size_t minwidth = 0; for (unsigned int i = 0; i < matrix->Rows(); i++) { for (unsigned int j = 0; j < matrix->Cols(); j++) { std::ostringstream os; os << (*matrix)(i,j); size_t size = os.str().size(); if (size > minwidth) { minwidth = size; } } } MapOfClassesType::const_iterator it = mapOfClasses->begin(); MapOfClassesType::const_iterator end = mapOfClasses->end(); for(; it != end; ++it) { std::ostringstream os; os << "[" << it->first << "]"; size_t size = os.str().size(); if (size > minwidth) { minwidth = size; } } // Generate matrix string, with 'minwidth' as size specifier std::ostringstream os; // Header line for (size_t i = 0; i < minwidth; ++i) os << " "; os << " "; it = mapOfClasses->begin(); end = mapOfClasses->end(); for(; it != end; ++it) { //os << "[" << it->first << "]" << " "; os << "[" << std::setw(minwidth - 2) << it->first << "]" << " "; } os << std::endl; // Each line of confusion matrix it = mapOfClasses->begin(); for (unsigned int i = 0; i < matrix->Rows(); i++) { ClassLabelType label = it->first; os << "[" << std::setw(minwidth - 2) << label << "]" << " "; for (unsigned int j = 0; j < matrix->Cols(); j++) { os << std::setw(minwidth) << (*matrix)(i,j) << " "; } os << std::endl; ++it; } otbAppLogINFO("Confusion matrix (rows = reference labels, columns = produced labels):\n" << os.str()); return os.str(); } void DoExecute() ITK_OVERRIDE { Int32ImageType* input = this->GetParameterInt32Image("in"); std::string field; int nodata = this->GetParameterInt("nodatalabel"); Int32ImageType::Pointer reference; otb::ogr::DataSource::Pointer ogrRef; RasterizeFilterType::Pointer rasterizeReference = RasterizeFilterType::New(); if (GetParameterString("ref") == "raster") { reference = this->GetParameterInt32Image("ref.raster.in"); } else { ogrRef = otb::ogr::DataSource::New(GetParameterString("ref.vector.in"), otb::ogr::DataSource::Modes::Read); field = this->GetParameterString("ref.vector.field"); rasterizeReference->AddOGRDataSource(ogrRef); rasterizeReference->SetOutputParametersFromImage(input); rasterizeReference->SetBackgroundValue(nodata); rasterizeReference->SetBurnAttribute(field.c_str()); reference = rasterizeReference->GetOutput(); reference->UpdateOutputInformation(); } // Prepare local streaming RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); int availableRAM = GetParameterInt("ram"); streamingManager->SetAvailableRAMInMB(availableRAM); float bias = 2.0; // empiric value; streamingManager->SetBias(bias); streamingManager->PrepareStreaming(input, input->GetLargestPossibleRegion()); unsigned long numberOfStreamDivisions = streamingManager->GetNumberOfSplits(); otbAppLogINFO("Number of stream divisions : "<GetSplit(index); input->SetRequestedRegion(streamRegion); input->PropagateRequestedRegion(); input->UpdateOutputData(); reference->SetRequestedRegion(streamRegion); reference->PropagateRequestedRegion(); reference->UpdateOutputData(); ImageIteratorType itInput(input, streamRegion); itInput.GoToBegin(); ImageIteratorType itRef(reference, streamRegion); itRef.GoToBegin(); while (!itRef.IsAtEnd()) { labelRef = static_cast (itRef.Get()); labelProd = static_cast (itInput.Get()); // Extraction of the reference/produced class labels if ((labelRef != nodata) && (labelProd != nodata)) { // If the current labels have not been added to their respective mapOfClasses yet if (mapOfClassesRef.insert(MapOfClassesType::value_type(labelRef, itLabelRef)).second) { ++itLabelRef; } if (mapOfClassesProd.insert(MapOfClassesType::value_type(labelProd, itLabelProd)).second) { ++itLabelProd; } // Filling of m_Matrix m_Matrix[labelRef][labelProd]++; } // END if ((labelRef != nodata) && (labelProd != nodata)) ++itRef; ++itInput; } } // END of for (unsigned int index = 0; index < numberOfStreamDivisions; index++) ///////////////////////////////////////////// // Filling the 2 headers for the output file const std::string commentRefStr = "#Reference labels (rows):"; const std::string commentProdStr = "#Produced labels (columns):"; const char separatorChar = ','; std::ostringstream ossHeaderRefLabels, ossHeaderProdLabels; // Filling ossHeaderRefLabels for the output file ossHeaderRefLabels << commentRefStr; MapOfClassesType::iterator itMapOfClassesRefEnd = mapOfClassesRef.end(); itMapOfClassesRef = mapOfClassesRef.begin(); int indexLabelRef = 0; while (itMapOfClassesRef != itMapOfClassesRefEnd) { // labels labelRef of mapOfClassesRef are already sorted labelRef = itMapOfClassesRef->first; // SORTING the itMapOfClassesRef->second items of mapOfClassesRef mapOfClassesRef[labelRef] = indexLabelRef; otbAppLogINFO("mapOfClassesRef[" << labelRef << "] = " << mapOfClassesRef[labelRef]); ossHeaderRefLabels << labelRef; ++itMapOfClassesRef; if (itMapOfClassesRef != itMapOfClassesRefEnd) { ossHeaderRefLabels << separatorChar; } else { ossHeaderRefLabels << std::endl; } ++indexLabelRef; } // Filling ossHeaderProdLabels for the output file ossHeaderProdLabels << commentProdStr; MapOfClassesType::iterator itMapOfClassesProdEnd = mapOfClassesProd.end(); itMapOfClassesProd = mapOfClassesProd.begin(); int indexLabelProd = 0; while (itMapOfClassesProd != itMapOfClassesProdEnd) { // labels labelProd of mapOfClassesProd are already sorted labelProd = itMapOfClassesProd->first; // SORTING the itMapOfClassesProd->second items of mapOfClassesProd mapOfClassesProd[labelProd] = indexLabelProd; otbAppLogINFO("mapOfClassesProd[" << labelProd << "] = " << mapOfClassesProd[labelProd]); ossHeaderProdLabels << labelProd; ++itMapOfClassesProd; if (itMapOfClassesProd != itMapOfClassesProdEnd) { ossHeaderProdLabels << separatorChar; } else { ossHeaderProdLabels << std::endl; } ++indexLabelProd; } std::ofstream outFile; outFile.open(this->GetParameterString("out").c_str()); outFile << std::fixed; outFile.precision(10); ///////////////////////////////////// // Writing the 2 headers outFile << ossHeaderRefLabels.str(); outFile << ossHeaderProdLabels.str(); ///////////////////////////////////// // Initialization of the Confusion Matrix for the application LOG and for measurements int nbClassesRef = mapOfClassesRef.size(); int nbClassesProd = mapOfClassesProd.size(); // Formatting m_MatrixLOG from m_Matrix in order to make m_MatrixLOG a square matrix // from the reference labels in mapOfClassesRef indexLabelRef = 0; int indexLabelProdInRef = 0; // Initialization of m_MatrixLOG m_MatrixLOG.SetSize(nbClassesRef, nbClassesRef); m_MatrixLOG.Fill(0); for (itMapOfClassesRef = mapOfClassesRef.begin(); itMapOfClassesRef != itMapOfClassesRefEnd; ++itMapOfClassesRef) { // labels labelRef of mapOfClassesRef are already sorted labelRef = itMapOfClassesRef->first; indexLabelProd = 0; for (itMapOfClassesProd = mapOfClassesProd.begin(); itMapOfClassesProd != itMapOfClassesProdEnd; ++itMapOfClassesProd) { // labels labelProd of mapOfClassesProd are already sorted labelProd = itMapOfClassesProd->first; // If labelProd is present in mapOfClassesRef if (mapOfClassesRef.count(labelProd) != 0) { // Index of labelProd in mapOfClassesRef; itMapOfClassesRef->second elements are now SORTED indexLabelProdInRef = mapOfClassesRef[labelProd]; m_MatrixLOG(indexLabelRef, indexLabelProdInRef) = m_Matrix[labelRef][labelProd]; } /////////////////////////////////////////////////////////// // Writing the ordered confusion matrix in the output file outFile << m_Matrix[labelRef][labelProd]; if (indexLabelProd < (nbClassesProd - 1)) { outFile << separatorChar; } else { outFile << std::endl; } /////////////////////////////////////////////////////////// ++indexLabelProd; } m_Matrix[labelRef].clear(); ++indexLabelRef; } // m_Matrix is cleared in order to remove old results in case of successive runs of the GUI application m_Matrix.clear(); outFile.close(); otbAppLogINFO("Reference class labels ordered according to the rows of the output confusion matrix: " << ossHeaderRefLabels.str()); otbAppLogINFO("Produced class labels ordered according to the columns of the output confusion matrix: " << ossHeaderProdLabels.str()); //otbAppLogINFO("Output confusion matrix (rows = reference labels, columns = produced labels):\n" << m_MatrixLOG); LogConfusionMatrix(&mapOfClassesRef, &m_MatrixLOG); // Measurements of the Confusion Matrix parameters ConfusionMatrixMeasurementsType::Pointer confMatMeasurements = ConfusionMatrixMeasurementsType::New(); confMatMeasurements->SetMapOfClasses(mapOfClassesRef); confMatMeasurements->SetConfusionMatrix(m_MatrixLOG); confMatMeasurements->Compute(); for (itMapOfClassesRef = mapOfClassesRef.begin(); itMapOfClassesRef != itMapOfClassesRefEnd; ++itMapOfClassesRef) { labelRef = itMapOfClassesRef->first; indexLabelRef = itMapOfClassesRef->second; otbAppLogINFO("Precision of class [" << labelRef << "] vs all: " << confMatMeasurements->GetPrecisions()[indexLabelRef]); otbAppLogINFO("Recall of class [" << labelRef << "] vs all: " << confMatMeasurements->GetRecalls()[indexLabelRef]); otbAppLogINFO("F-score of class [" << labelRef << "] vs all: " << confMatMeasurements->GetFScores()[indexLabelRef] << std::endl); } otbAppLogINFO("Precision of the different classes: " << confMatMeasurements->GetPrecisions()); otbAppLogINFO("Recall of the different classes: " << confMatMeasurements->GetRecalls()); otbAppLogINFO("F-score of the different classes: " << confMatMeasurements->GetFScores() << std::endl); otbAppLogINFO("Kappa index: " << confMatMeasurements->GetKappaIndex()); otbAppLogINFO("Overall accuracy index: " << confMatMeasurements->GetOverallAccuracy()); }// END Execute() ConfusionMatrixType m_MatrixLOG; OutputConfusionMatrixType m_Matrix; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ComputeConfusionMatrix) OTB-release-5.8/Modules/Applications/AppClassification/app/otbComputeImagesStatistics.cxx000066400000000000000000000143641301006202600317060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbStatisticsXMLFileWriter.h" #include "otbStreamingStatisticsVectorImageFilter.h" #include namespace otb { namespace Wrapper { class ComputeImagesStatistics: public Application { public: /** Standard class typedefs. */ typedef ComputeImagesStatistics Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ComputeImagesStatistics, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("ComputeImagesStatistics"); SetDescription("Computes global mean and standard deviation for each band from a set of images and optionally saves the results in an XML file."); SetDocName("Compute Images second order statistics"); SetDocLongDescription("This application computes a global mean and standard deviation for each band of a set of images and optionally saves the results in an XML file. The output XML is intended to be used an input for the TrainImagesClassifier application to normalize samples before learning."); SetDocLimitations("Each image of the set must contain the same bands as the others (i.e. same types, in the same order)."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("Documentation of the TrainImagesClassifier application."); AddDocTag(Tags::Learning); AddDocTag(Tags::Analysis); AddParameter(ParameterType_InputImageList, "il", "Input images"); SetParameterDescription( "il", "List of input images filenames." ); AddParameter(ParameterType_Float, "bv", "Background Value"); SetParameterDescription( "bv", "Background value to ignore in statistics computation." ); MandatoryOff("bv"); AddParameter(ParameterType_OutputFilename, "out", "Output XML file"); SetParameterDescription( "out", "XML filename where the statistics are saved for future reuse." ); MandatoryOff("out"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("il", "QB_1_ortho.tif"); SetDocExampleParameterValue("out", "EstimateImageStatisticsQB1.xml"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { //Statistics estimator typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVImageFilterType; // Samples typedef double ValueType; typedef itk::VariableLengthVector MeasurementType; unsigned int nbSamples = 0; unsigned int nbBands = 0; // Build a Measurement Vector of mean MeasurementType mean; // Build a MeasurementVector of variance MeasurementType variance; FloatVectorImageListType* imageList = GetParameterImageList("il"); //Iterate over all input images for (unsigned int imageId = 0; imageId < imageList->Size(); ++imageId) { FloatVectorImageType* image = imageList->GetNthElement(imageId); if (nbBands == 0) { nbBands = image->GetNumberOfComponentsPerPixel(); } else if (nbBands != image->GetNumberOfComponentsPerPixel()) { itkExceptionMacro(<< "The image #" << imageId + 1 << " has " << image->GetNumberOfComponentsPerPixel() << " bands, while the image #1 has " << nbBands ); } FloatVectorImageType::SizeType size = image->GetLargestPossibleRegion().GetSize(); //Set the measurement vectors size if it's the first iteration if (imageId == 0) { mean.SetSize(nbBands); mean.Fill(0.); variance.SetSize(nbBands); variance.Fill(0.); } // Compute Statistics of each VectorImage StreamingStatisticsVImageFilterType::Pointer statsEstimator = StreamingStatisticsVImageFilterType::New(); std::ostringstream processName; processName << "Processing Image (" << imageId+1 << "/" << imageList->Size() << ")"; AddProcess(statsEstimator->GetStreamer(), processName.str().c_str()); statsEstimator->SetInput(image); statsEstimator->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); if( HasValue( "bv" )==true ) { statsEstimator->SetIgnoreUserDefinedValue(true); statsEstimator->SetUserIgnoredValue(GetParameterFloat("bv")); } statsEstimator->Update(); mean += statsEstimator->GetMean(); for (unsigned int itBand = 0; itBand < nbBands; itBand++) { variance[itBand] += (size[0] * size[1] - 1) * (statsEstimator->GetCovariance())(itBand, itBand); } //Increment nbSamples nbSamples += size[0] * size[1]; } //Divide by the number of input images to get the mean over all layers mean /= imageList->Size(); //Apply the pooled variance formula variance /= (nbSamples - imageList->Size()); MeasurementType stddev; stddev.SetSize(nbBands); stddev.Fill(0.); for (unsigned int i = 0; i < variance.GetSize(); ++i) { stddev[i] = vcl_sqrt(variance[i]); } if( HasValue( "out" )==true ) { // Write the Statistics via the statistic writer typedef otb::StatisticsXMLFileWriter StatisticsWriter; StatisticsWriter::Pointer writer = StatisticsWriter::New(); writer->SetFileName(GetParameterString("out")); writer->AddInput("mean", mean); writer->AddInput("stddev", stddev); writer->Update(); } else { otbAppLogINFO("Mean: "< namespace otb { namespace Wrapper { class ComputeOGRLayersFeaturesStatistics : public Application { public: typedef ComputeOGRLayersFeaturesStatistics Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self) ; itkTypeMacro(ComputeOGRLayersFeaturesStatistics, otb::Application) ; private: void DoInit() ITK_OVERRIDE { SetName("ComputeOGRLayersFeaturesStatistics"); SetDescription("Compute statistics of the features in a set of OGR Layers"); SetDocName("ComputeOGRLayersFeaturesStatistics"); SetDocLongDescription("Compute statistics (mean and standard deviation) of the features in a set of OGR Layers, and write them in an XML file. This XML file can then be used by the training application."); SetDocLimitations("Experimental. For now only shapefiles are supported."); SetDocAuthors("David Youssefi during internship at CNES"); SetDocSeeAlso("OGRLayerClassifier,TrainOGRLayersClassifier"); AddDocTag(Tags::Segmentation); AddParameter(ParameterType_InputVectorData, "inshp", "Name of the input shapefile"); SetParameterDescription("inshp","Name of the input shapefile"); AddParameter(ParameterType_OutputFilename, "outstats", "XML file containing mean and variance of each feature."); SetParameterDescription("outstats", "XML file containing mean and variance of each feature."); AddParameter(ParameterType_ListView, "feat", "List of features to consider for statistics."); SetParameterDescription("feat","List of features to consider for statistics."); // Doc example parameter settings SetDocExampleParameterValue("inshp", "vectorData.shp"); SetDocExampleParameterValue("outstats", "results.xml"); SetDocExampleParameterValue("feat", "perimeter"); } void DoUpdateParameters() ITK_OVERRIDE { if ( HasValue("inshp") ) { std::string shapefile = GetParameterString("inshp"); otb::ogr::DataSource::Pointer ogrDS; otb::ogr::Layer layer(ITK_NULLPTR, false); OGRSpatialReference oSRS(""); std::vector options; ogrDS = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Read); std::string layername = itksys::SystemTools::GetFilenameName(shapefile); layername = layername.substr(0,layername.size()-4); layer = ogrDS->GetLayer(0); otb::ogr::Feature feature = layer.ogr().GetNextFeature(); ClearChoices("feat"); for(int iField=0; iFieldGetNameRef(); key = item; key.erase(std::remove(key.begin(), key.end(), ' '), key.end()); std::transform(key.begin(), key.end(), key.begin(), tolower); key="feat."+key; AddChoice(key,item); } } } void DoExecute() ITK_OVERRIDE { clock_t tic = clock(); std::string shapefile = GetParameterString("inshp"); std::string XMLfile = GetParameterString("outstats"); otb::ogr::DataSource::Pointer source = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Read); otb::ogr::Layer layer = source->GetLayer(0); bool goesOn = true; otb::ogr::Feature feature = layer.ogr().GetNextFeature(); typedef double ValueType; typedef itk::VariableLengthVector MeasurementType; std::vector featValue; const std::vector::size_type nbFeatures = GetSelectedItems("feat").size(); if(feature.addr()) while(goesOn) { MeasurementType mv; mv.SetSize(nbFeatures); for(unsigned int idx=0; idx < nbFeatures; ++idx) mv[idx] = feature.ogr().GetFieldAsDouble(GetSelectedItems("feat")[idx]); featValue.push_back(mv); feature = layer.ogr().GetNextFeature(); goesOn = feature.addr() != ITK_NULLPTR; } MeasurementType mean; mean.SetSize(nbFeatures); MeasurementType stddev; stddev.SetSize(nbFeatures); for(unsigned int featIt=0; featIt StatisticsWriter; StatisticsWriter::Pointer writer = StatisticsWriter::New(); writer->SetFileName(XMLfile); writer->AddInput("mean", mean); writer->AddInput("stddev", stddev); writer->Update(); clock_t toc = clock(); otbAppLogINFO( "Elapsed: "<< ((double)(toc - tic) / CLOCKS_PER_SEC)<<" seconds."); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ComputeOGRLayersFeaturesStatistics) OTB-release-5.8/Modules/Applications/AppClassification/app/otbComputePolylineFeatureFromImage.cxx000066400000000000000000000233361301006202600333230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbVectorImage.h" #include "otbWrapperApplicationFactory.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "itkPreOrderTreeIterator.h" #include "otbVectorDataIntoImageProjectionFilter.h" #include "otbVectorDataTransformFilter.h" #include "itkAffineTransform.h" #include "otbParserConditionDataNodeFeatureFunction.h" #include "otbNDVIDataNodeFeatureFunction.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class ComputePolylineFeatureFromImage: public Application { public: /** Standard class typedefs. */ typedef ComputePolylineFeatureFromImage Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // Images typedef FloatVectorImageType::PixelType PixelType; typedef FloatVectorImageType ImageType; // VectorData typedef VectorData<> VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::ValuePrecisionType PrecisionType; typedef DataNodeType::PrecisionType CoordRepType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef VectorDataIntoImageProjectionFilter VectorDataIntoImageProjType; typedef VectorDataProjectionFilter VectorDataProjectionFilterType; typedef ParserConditionDataNodeFeatureFunction ParserConditionFeatureFunctionType; /** Standard macro */ itkNewMacro(Self) ; itkTypeMacro(ComputePolylineFeatureFromImage, otb::Application) ; private: void DoInit() ITK_OVERRIDE { SetName("ComputePolylineFeatureFromImage"); SetDescription("This application compute for each studied polyline, contained in the input VectorData, the chosen descriptors."); SetDocName("Compute Polyline Feature From Image"); SetDocLongDescription("The first step in the classifier fusion based validation is to compute, for each studied polyline, the chosen descriptors. "); SetDocLimitations("Since it does not rely on streaming process, take care of the size of input image before launching application."); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "An image to compute the descriptors on."); AddParameter(ParameterType_InputVectorData, "vd", "Vector Data"); SetParameterDescription("vd", "Vector data containing the polylines where the features will be computed."); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); AddParameter(ParameterType_String, "expr", "Feature expression"); SetParameterDescription("expr", "The feature formula (b1 < 0.3) where b1 is the standard name of input image first band"); AddParameter(ParameterType_String, "field", "Feature name"); SetParameterDescription("field", "The field name corresponding to the feature codename (NONDVI, ROADSA...)"); AddParameter(ParameterType_OutputVectorData, "out", "Output Vector Data"); SetParameterDescription("out", "The output vector data containing polylines with a new field"); // Doc example parameter settings SetDocExampleParameterValue("in", "NDVI.TIF"); SetDocExampleParameterValue("vd", "roads_ground_truth.shp"); SetDocExampleParameterValue("expr", "\"(b1 > 0.4)\""); SetDocExampleParameterValue("field", "NONDVI"); SetDocExampleParameterValue("out", "PolylineFeatureFromImage_LI_NONDVI_gt.shp"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { // Vector Data into Image projection FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); try { inImage->Update(); } catch (...) { itkGenericExceptionMacro(<< "Error during image update, maybe your image is to big."); } otbAppLogDEBUG( << "Starting PolylineFeature extraction process" ) // Vector Data into Image projection //// Read the Vectordata VectorDataType* inVectorData = GetParameterVectorData("vd"); inVectorData->Update(); //// Projection VectorDataIntoImageProjType::Pointer vprojIm = VectorDataIntoImageProjType::New(); vprojIm->SetInputVectorData(inVectorData); vprojIm->SetInputImage(inImage); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); vprojIm->SetUseOutputSpacingAndOriginFromImage(true); // we want index as input; vprojIm->Update(); // Add description ParserConditionFeatureFunctionType::Pointer vdescriptor = ParserConditionFeatureFunctionType::New(); vdescriptor->SetExpression(GetParameterString("expr")); vdescriptor->SetInputImage(inImage); m_OutVectorData = VectorDataType::New(); // Retrieving root node DataNodeType::Pointer root = m_OutVectorData->GetDataTree()->GetRoot()->Get(); // Create the document node DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree m_OutVectorData->GetDataTree()->Add(document, root); // Create the folder node DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree m_OutVectorData->GetDataTree()->Add(folder, document); TreeIteratorType itVector(vprojIm->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { vdescriptor->SetInputImage(inImage); if (!itVector.Get()->IsRoot() && !itVector.Get()->IsDocument() && !itVector.Get()->IsFolder()) { DataNodeType::Pointer currentGeometry = itVector.Get(); currentGeometry->SetFieldAsDouble(GetParameterString("field"), (double) (vdescriptor->Evaluate(*(currentGeometry.GetPointer()))[0])); m_OutVectorData->GetDataTree()->Add(currentGeometry, folder); } ++itVector; } /* * Reprojection of the output VectorData * * The output of VectorDataToRoadDescription is in image index coordinates * * 3 cases : * - input image has no geo-information : pass through * - input image is in cartographic projection : apply image spacing and origin, and set the ProjectionRef * - input image is in sensor model geometry : reproject in WGS84 * */ std::string projRef = inImage->GetProjectionRef(); ImageKeywordlist kwl; itk::ExposeMetaData(inImage->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwl); if (!projRef.empty()) { // image is in cartographic projection // apply spacing and origin + set projection WKT // The VectorData in output of the chain is in image index coordinate, // and the projection information is lost // Apply an affine transform to apply image origin and spacing, // and arbitrarily set the ProjectionRef to the input image ProjectionRef typedef itk::AffineTransform TransformType; typedef otb::VectorDataTransformFilter VDTransformType; TransformType::ParametersType params; params.SetSize(6); params[0] = inImage->GetSpacing()[0]; params[1] = 0; params[2] = 0; params[3] = inImage->GetSpacing()[1]; params[4] = inImage->GetOrigin()[0]; params[5] = inImage->GetOrigin()[1]; TransformType::Pointer transform = TransformType::New(); transform->SetParameters(params); VDTransformType::Pointer vdTransform = VDTransformType::New(); vdTransform->SetTransform(transform); vdTransform->SetInput(m_OutVectorData); vdTransform->Update(); m_ProjectedVectorData = vdTransform->GetOutput(); m_ProjectedVectorData->SetProjectionRef(inImage->GetProjectionRef()); } else if (kwl.GetSize() > 0) { // image is in sensor model geometry // Reproject VectorData in image projection VectorDataProjectionFilterType::Pointer vproj = VectorDataProjectionFilterType::New(); vproj->SetInput(m_OutVectorData); vproj->SetOutputKeywordList(inImage->GetImageKeywordlist()); vproj->SetOutputProjectionRef(inImage->GetProjectionRef()); vproj->SetOutputOrigin(inImage->GetOrigin()); vproj->SetOutputSpacing(inImage->GetSpacing()); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); vproj->Update(); m_ProjectedVectorData = vproj->GetOutput(); } else { // no georeferencing information m_ProjectedVectorData = m_OutVectorData; } // Set the output vectorData SetParameterOutputVectorData("out", m_ProjectedVectorData); }; VectorDataType::Pointer m_ProjectedVectorData; VectorDataType::Pointer m_OutVectorData; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ComputePolylineFeatureFromImage) OTB-release-5.8/Modules/Applications/AppClassification/app/otbDSFuzzyModelEstimation.cxx000066400000000000000000000370461301006202600314670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbWrapperStringListParameter.h" #include "otbImageToEnvelopeVectorDataFilter.h" #include "otbVectorDataToRandomLineGenerator.h" #include "itkAmoebaOptimizer.h" #include "otbStandardDSCostFunction.h" namespace otb { namespace Wrapper { #include "itkCommand.h" class CommandIterationUpdate : public itk::Command { public: typedef CommandIterationUpdate Self; typedef itk::Command Superclass; typedef itk::SmartPointer Pointer; itkNewMacro( Self ); protected: CommandIterationUpdate() {}; public: typedef itk::AmoebaOptimizer OptimizerType; typedef const OptimizerType * OptimizerPointer; void Execute(itk::Object *caller, const itk::EventObject & event) ITK_OVERRIDE { Execute( (const itk::Object *)caller, event); } void Execute(const itk::Object * object, const itk::EventObject & event) ITK_OVERRIDE { OptimizerPointer optimizer = dynamic_cast< OptimizerPointer >( object ); if( ! itk::IterationEvent().CheckEvent( &event ) ) { return; } std::ostringstream message; message << optimizer->GetCachedValue() << " "; message << optimizer->GetCachedCurrentPosition() << std::endl; std::cout< Pointer; typedef itk::SmartPointer ConstPointer; typedef VectorData VectorDataType; typedef VectorDataType::DataTreeType DataTreeType; typedef VectorDataType::DataNodeType DataNodeType; typedef VectorDataType::ValuePrecisionType PrecisionType; typedef VectorDataType::PrecisionType CoordRepType; typedef otb::Wrapper::StringListParameter::StringListType StringListType; typedef otb::VectorDataToDSValidatedVectorDataFilter ValidationFilterType; typedef otb::StandardDSCostFunction CostFunctionType; typedef CostFunctionType::LabelSetType LabelSetType; typedef itk::AmoebaOptimizer OptimizerType; typedef otb::FuzzyDescriptorsModelManager::DescriptorsModelType DescriptorsModelType; typedef otb::FuzzyDescriptorsModelManager::DescriptorListType DescriptorListType; typedef itk::PreOrderTreeIterator TreeIteratorType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(DSFuzzyModelEstimation, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("DSFuzzyModelEstimation"); SetDescription("Estimate feature fuzzy model parameters using 2 vector data (ground truth samples and wrong samples)."); SetDocName("Fuzzy Model estimation"); SetDocLongDescription("Estimate feature fuzzy model parameters using 2 vector data (ground truth samples and wrong samples)."); SetDocLimitations("None."); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputVectorData, "psin", "Input Positive Vector Data"); SetParameterDescription("psin", "Ground truth vector data for positive samples"); AddParameter(ParameterType_InputVectorData, "nsin", "Input Negative Vector Data"); SetParameterDescription("nsin", "Ground truth vector data for negative samples"); AddParameter(ParameterType_StringList, "belsup", "Belief Support"); SetParameterDescription("belsup", "Dempster Shafer study hypothesis to compute belief"); AddParameter(ParameterType_StringList, "plasup", "Plausibility Support"); SetParameterDescription("plasup", "Dempster Shafer study hypothesis to compute plausibility"); AddParameter(ParameterType_String, "cri", "Criterion"); SetParameterDescription("cri", "Dempster Shafer criterion (by default (belief+plausibility)/2)"); MandatoryOff("cri"); SetParameterString("cri","((Belief + Plausibility)/2.)"); AddParameter(ParameterType_Float,"wgt","Weighting"); SetParameterDescription("wgt","Coefficient between 0 and 1 to promote undetection or false detections (default 0.5)"); MandatoryOff("wgt"); SetParameterFloat("wgt", 0.5); AddParameter(ParameterType_InputFilename,"initmod","initialization model"); SetParameterDescription("initmod","Initialization model (xml file) to be used. If the xml initialization model is set, the descriptor list is not used (specified using the option -desclist)"); MandatoryOff("initmod"); AddParameter(ParameterType_StringList, "desclist","Descriptor list"); SetParameterDescription("desclist","List of the descriptors to be used in the model (must be specified to perform an automatic initialization)"); MandatoryOff("desclist"); SetParameterString("desclist",""); AddParameter(ParameterType_Int,"maxnbit","Maximum number of iterations"); MandatoryOff("maxnbit"); SetParameterDescription("maxnbit","Maximum number of optimizer iteration (default 200)"); SetParameterInt("maxnbit", 200); AddParameter(ParameterType_Empty,"optobs","Optimizer Observer"); SetParameterDescription("optobs","Activate the optimizer observer"); MandatoryOff("optobs"); AddParameter(ParameterType_OutputFilename,"out","Output filename"); SetParameterDescription("out","Output model file name (xml file) contains the optimal model to perform information fusion."); // Doc example parameter settings SetDocExampleParameterValue("psin", "cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp"); SetDocExampleParameterValue("nsin", "cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_wr.shp"); SetDocExampleParameterValue("belsup", "\"ROADSA\""); SetDocExampleParameterValue("plasup", "\"NONDVI\" \"ROADSA\" \"NOBUIL\""); SetDocExampleParameterValue("initmod", "Dempster-Shafer/DSFuzzyModel_Init.xml"); SetDocExampleParameterValue("maxnbit", "4"); SetDocExampleParameterValue("optobs", "true"); SetDocExampleParameterValue("out", "DSFuzzyModelEstimation.xml"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent // .. // } void DoExecute() ITK_OVERRIDE { //Instantiate m_CostFunction = CostFunctionType::New(); m_Optimizer = OptimizerType::New(); //Read the vector datas VectorDataType::Pointer psVectorData = GetParameterVectorData("psin"); psVectorData->Update(); VectorDataType::Pointer nsVectorData = GetParameterVectorData("nsin"); nsVectorData->Update(); // Load the initial descriptor model DescriptorListType descList; DescriptorsModelType descMod; if (IsParameterEnabled("initmod")) { std::string descModFile = GetParameterString("initmod"); descMod = FuzzyDescriptorsModelManager::Read(descModFile.c_str()); descList = FuzzyDescriptorsModelManager::GetDescriptorList(descMod); } else { StringListType stringList = GetParameterStringList("desclist"); int nbsdDesc = stringList.size(); for (int i = 0; i < nbsdDesc; i++) { descList.push_back(stringList[i]); } } m_CostFunction->SetDescriptorList(descList); // Compute statistics of all the descriptors std::vector accFirstOrderPS, accSecondOrderPS, minPS, maxPS; accFirstOrderPS.resize(descList.size()); accSecondOrderPS.resize(descList.size()); std::fill(accFirstOrderPS.begin(), accFirstOrderPS.end(), 0); std::fill(accSecondOrderPS.begin(), accSecondOrderPS.end(), 0); minPS.resize(descList.size()); maxPS.resize(descList.size()); unsigned int accNbElemPS = 0; TreeIteratorType itVectorPS(psVectorData->GetDataTree()); for (itVectorPS.GoToBegin(); !itVectorPS.IsAtEnd(); ++itVectorPS) { if (!itVectorPS.Get()->IsRoot() && !itVectorPS.Get()->IsDocument() && !itVectorPS.Get()->IsFolder()) { DataNodeType::Pointer currentGeometry = itVectorPS.Get(); for (unsigned int i = 0; i < descList.size(); ++i) { double desc = currentGeometry->GetFieldAsDouble(descList[i]); accFirstOrderPS[i] += desc; accSecondOrderPS[i] += desc * desc; if (desc < minPS[i]) { minPS[i] = desc; } if (desc > maxPS[i]) { maxPS[i] = desc; } } accNbElemPS++; } } if (accNbElemPS == 0) { otbAppLogFATAL(<< "Error : no element found in positive vector data!"); } TreeIteratorType itVectorNS(nsVectorData->GetDataTree()); std::vector accFirstOrderNS, accSecondOrderNS, minNS, maxNS; minNS.resize(descList.size()); maxNS.resize(descList.size()); accFirstOrderNS.resize(descList.size()); accSecondOrderNS.resize(descList.size()); std::fill(accFirstOrderNS.begin(), accFirstOrderNS.end(), 0); std::fill(accSecondOrderNS.begin(), accSecondOrderNS.end(), 0); std::fill(minNS.begin(), minNS.end(), 1); std::fill(maxNS.begin(), maxNS.end(), 0); unsigned int accNbElemNS = 0; for (itVectorNS.GoToBegin(); !itVectorNS.IsAtEnd(); ++itVectorNS) { if (!itVectorNS.Get()->IsRoot() && !itVectorNS.Get()->IsDocument() && !itVectorNS.Get()->IsFolder()) { DataNodeType::Pointer currentGeometry = itVectorNS.Get(); for (unsigned int i = 0; i < descList.size(); ++i) { double desc = currentGeometry->GetFieldAsDouble(descList[i]); accFirstOrderNS[i] += desc; accSecondOrderNS[i] += desc * desc; if (desc < minNS[i]) { minNS[i] = desc; } if (desc > maxNS[i]) { maxNS[i] = desc; } } accNbElemNS++; } } if (accNbElemNS == 0) { otbAppLogFATAL(<< "Error : no element found in negative vector data!"); } otbAppLogINFO( << "Descriptors Stats : "); otbAppLogINFO( << "Positive Samples"); for (unsigned int i = 0; i < descList.size(); ++i) { double mean = accFirstOrderPS[i] / accNbElemPS; double stddev = vcl_sqrt(accSecondOrderPS[i] / accNbElemPS - mean * mean); otbAppLogINFO( << descList[i] << " : " << mean << " +/- " << stddev << " (min: " << minPS[i] << " max: " << maxPS[i] << ")"<< std::endl); } otbAppLogINFO( << "Negative Samples" << std::endl); for (unsigned int i = 0; i < descList.size(); ++i) { double mean = accFirstOrderNS[i] / accNbElemNS; double stddev = vcl_sqrt(accSecondOrderNS[i] / accNbElemNS - mean * mean); otbAppLogINFO(<< descList[i] << " : " << mean << " +/- " << stddev << " (min: " << minNS[i] << " max: " << maxNS[i] << ")"<< std::endl); } OptimizerType::ParametersType initialPosition(4 * descList.size()); if (IsParameterEnabled("initmod")) { for (unsigned int i = 0; i < 4; i++) { for (unsigned int j = 0; j < descList.size(); j++) { initialPosition.SetElement( i + 4 * j, otb::FuzzyDescriptorsModelManager::GetDescriptor(descList[j].c_str(), descMod).second[i]); } } } else { for (unsigned int j = 0; j < descList.size(); j++) { initialPosition.SetElement((j * 4), std::min(minNS[j], maxPS[j])); initialPosition.SetElement((j * 4) + 2, std::max(minNS[j], maxPS[j])); initialPosition.SetElement( (j * 4) + 1, 0.5 * (initialPosition.GetElement((j * 4)) + initialPosition.GetElement((j * 4) + 2))); initialPosition.SetElement((j * 4) + 3, 0.95); } } otbAppLogINFO(<<"Initial model: "<SetBeliefHypothesis(Bhyp); stringList = GetParameterStringList("plasup"); nbSet = stringList.size(); for (int i = 0; i < nbSet; i++) { std::string str = stringList[i]; Phyp.insert(str); } m_CostFunction->SetPlausibilityHypothesis(Phyp); m_CostFunction->SetWeight(GetParameterFloat("wgt")); m_CostFunction->SetCriterionFormula(GetParameterString("cri")); m_CostFunction->SetGTVectorData(psVectorData); m_CostFunction->SetNSVectorData(nsVectorData); //Optimizer m_Optimizer->SetCostFunction(m_CostFunction); m_Optimizer->SetMaximumNumberOfIterations(GetParameterInt("maxnbit")); OptimizerType::ParametersType simplexDelta(m_CostFunction->GetNumberOfParameters()); simplexDelta.Fill(0.1); m_Optimizer->AutomaticInitialSimplexOff(); m_Optimizer->SetInitialSimplexDelta(simplexDelta); m_Optimizer->SetInitialPosition(initialPosition); // Create the Command observer and register it with the optimizer. CommandIterationUpdate::Pointer observer = CommandIterationUpdate::New(); if (IsParameterEnabled("optobs")) { m_Optimizer->AddObserver(itk::IterationEvent(), observer); } try { // do the optimization m_Optimizer->StartOptimization(); } catch (itk::ExceptionObject& err) { // An error has occurred in the optimization. // Update the parameters otbAppLogFATAL("ERROR: Exception Caught : "<< err.GetDescription() << std::endl << "numberOfIterations : " << m_Optimizer->GetOptimizer()->get_num_evaluations() << std::endl << "Results : " << m_Optimizer->GetCurrentPosition() << std::endl); } // get the results const unsigned int numberOfIterations = m_Optimizer->GetOptimizer()->get_num_evaluations(); otbAppLogINFO("numberOfIterations : " << numberOfIterations << std::endl); otbAppLogINFO("Results : " << m_Optimizer->GetCurrentPosition() << std::endl); for (unsigned int i = 0; i < descList.size(); i++) { otb::FuzzyDescriptorsModelManager::ParameterType tmpParams; for (unsigned int j = 0; j < 4; j++) { tmpParams.push_back(m_Optimizer->GetCurrentPosition()[(i * 4) + j]); } otb::FuzzyDescriptorsModelManager::AddDescriptor(descList[i], tmpParams, m_Model); } otb::FuzzyDescriptorsModelManager::Save(GetParameterString("out"), m_Model); }; CostFunctionType::Pointer m_CostFunction; OptimizerType::Pointer m_Optimizer; otb::FuzzyDescriptorsModelManager::DescriptorsModelType m_Model; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::DSFuzzyModelEstimation) OTB-release-5.8/Modules/Applications/AppClassification/app/otbFusionOfClassifications.cxx000066400000000000000000000501771301006202600316620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "itkLabelVotingImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbDSFusionOfClassifiersImageFilter.h" #include "otbImageListToVectorImageFilter.h" #include "otbConfusionMatrixToMassOfBelief.h" #include #include #include "otbImageList.h" namespace otb { enum { Method_Majority_Voting, Method_Dempster_Shafer }; enum { Mode_MOB_Precision, Mode_MOB_Recall, Mode_MOB_Accuracy, Mode_MOB_Kappa }; namespace Wrapper { class FusionOfClassifications: public Application { public: /** Standard class typedefs. */ typedef FusionOfClassifications Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef UInt16VectorImageType VectorImageType; typedef UInt16ImageType IOLabelImageType; typedef IOLabelImageType::InternalPixelType LabelPixelType; typedef otb::MultiToMonoChannelExtractROI ConverterType; // Majority Voting typedef itk::LabelVotingImageFilter LabelVotingFilterType; // Dempster Shafer typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef otb::ConfusionMatrixToMassOfBelief ConfusionMatrixToMassOfBeliefType; typedef ConfusionMatrixToMassOfBeliefType::MapOfClassesType MapOfClassesType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; typedef ConfusionMatrixToMassOfBeliefType::MassOfBeliefDefinitionMethod MassOfBeliefDefinitionMethod; typedef otb::DSFusionOfClassifiersImageFilter DSFusionOfClassifiersImageFilterType; typedef DSFusionOfClassifiersImageFilterType::VectorOfMapOfMassesOfBeliefType VectorOfMapOfMassesOfBeliefType; typedef DSFusionOfClassifiersImageFilterType::LabelMassMapType LabelMassMapType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(FusionOfClassifications, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("FusionOfClassifications"); SetDescription("Fuses several classifications maps of the same image on the basis of class labels."); SetDocName("Fusion of Classifications"); SetDocLongDescription("This application allows you to fuse several classification maps and produces a single more robust classification map. " "Fusion is done either by mean of Majority Voting, or with the Dempster Shafer combination method on class labels.\n\n" " - MAJORITY VOTING: for each pixel, the class with the highest number of votes is selected.\n" " - DEMPSTER SHAFER: for each pixel, the class label for which the Belief Function is maximal is selected. This Belief Function is calculated " "by mean of the Dempster Shafer combination of Masses of Belief, and indicates the belief that each input classification map presents for each label " "value. Moreover, the Masses of Belief are based on the input confusion matrices of each classification map, either by using the PRECISION or RECALL " "rates, or the OVERALL ACCURACY, or the KAPPA coefficient. Thus, each input classification map needs to be associated with its corresponding input " "confusion matrix file for the Dempster Shafer fusion.\n" " - Input pixels with the NODATA label are not handled in the fusion of classification maps. Moreover, pixels for which all the input classifiers are set to NODATA " "keep this value in the output fused image.\n" " - In case of number of votes equality, the UNDECIDED label is attributed to the pixel.\n"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("ImageClassifier application"); AddDocTag(Tags::Learning); AddDocTag(Tags::Analysis); AddParameter(ParameterType_InputImageList, "il", "Input classifications"); SetParameterDescription( "il", "List of input classification maps to fuse. Labels in each classification image must represent the same class." ); /** GROUP FUSION METHOD */ AddParameter(ParameterType_Choice, "method", "Fusion method"); SetParameterDescription("method", "Selection of the fusion method and its parameters."); // Majority Voting AddChoice("method.majorityvoting","Majority Voting"); SetParameterDescription("method.majorityvoting","Fusion of classification maps by majority voting for each output pixel."); // Dempster Shafer AddChoice("method.dempstershafer","Dempster Shafer combination"); SetParameterDescription("method.dempstershafer","Fusion of classification maps by the Dempster Shafer combination method for each output pixel."); AddParameter(ParameterType_InputFilenameList, "method.dempstershafer.cmfl", "Confusion Matrices"); SetParameterDescription("method.dempstershafer.cmfl", "A list of confusion matrix files (*.CSV format) to define the masses of belief and the class labels. Each file should be formatted the following way: " "the first line, beginning with a '#' symbol, should be a list of the class labels present in the corresponding input classification image, organized in the same order as the confusion matrix rows/columns."); AddParameter(ParameterType_Choice, "method.dempstershafer.mob", "Mass of belief measurement"); SetParameterDescription("method.dempstershafer.mob","Type of confusion matrix measurement used to compute the masses of belief of each classifier."); AddChoice("method.dempstershafer.mob.precision","Precision"); SetParameterDescription("method.dempstershafer.mob.precision","Masses of belief = Precision rates of each classifier (one rate per class label)."); AddChoice("method.dempstershafer.mob.recall", "Recall"); SetParameterDescription("method.dempstershafer.mob.recall", "Masses of belief = Recall rates of each classifier (one rate per class label)."); AddChoice("method.dempstershafer.mob.accuracy", "Overall Accuracy"); SetParameterDescription("method.dempstershafer.mob.accuracy", "Mass of belief = Overall Accuracy of each classifier (one unique value for all the class labels)."); AddChoice("method.dempstershafer.mob.kappa", "Kappa"); SetParameterDescription("method.dempstershafer.mob.kappa", "Mass of belief = Kappa coefficient of each classifier (one unique value for all the class labels)."); AddParameter(ParameterType_Int, "nodatalabel", "Label for the NoData class"); SetParameterDescription("nodatalabel", "Label for the NoData class. Such input pixels keep their NoData label in the output image and are not handled in the fusion process. By default, 'nodatalabel = 0'."); SetDefaultParameterInt("nodatalabel", 0); //MandatoryOff("nodatalabel"); AddParameter(ParameterType_Int,"undecidedlabel","Label for the Undecided class"); SetParameterDescription("undecidedlabel","Label for the Undecided class. Pixels with more than 1 fused class are marked as Undecided. Please note that the Undecided value must be different from existing " "labels in the input classifications. By default, 'undecidedlabel = 0'."); SetDefaultParameterInt("undecidedlabel",0); AddParameter(ParameterType_OutputImage,"out","The output classification image"); SetParameterDescription("out","The output classification image resulting from the fusion of the input classification images."); SetDefaultOutputPixelType("out",ImagePixelType_uint8); // Doc example parameter settings SetDocExampleParameterValue("il", "classification1.tif classification2.tif classification3.tif"); SetDocExampleParameterValue("method", "dempstershafer"); SetDocExampleParameterValue("method.dempstershafer.cmfl", "classification1.csv classification2.csv classification3.csv"); SetDocExampleParameterValue("method.dempstershafer.mob", "precision"); SetDocExampleParameterValue("nodatalabel","0"); SetDocExampleParameterValue("undecidedlabel","10"); SetDocExampleParameterValue("out","classification_fused.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } int CSVConfusionMatrixFileReader(const std::string fileName, MapOfClassesType &mapOfClassesRefClX, ConfusionMatrixType &confusionMatrixClX) { std::ifstream inFile; inFile.open(fileName.c_str()); if (!inFile) { std::cerr << "Confusion Matrix File opening problem with file:" << std::endl; std::cerr << fileName.c_str() << std::endl; return EXIT_FAILURE; } else { LabelPixelType labelRef = 0, labelProd = 0; std::string currentLine, refLabelsLine, prodLabelsLine, currentValue; const char endCommentChar = ':'; const char separatorChar = ','; const char eolChar = '\n'; std::getline(inFile, refLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, refLabelsLine, eolChar); // Gets the first line after the comment char until the End Of Line char std::getline(inFile, prodLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, prodLabelsLine, eolChar); // Gets the second line after the comment char until the End Of Line char std::istringstream issRefLabelsLine(refLabelsLine); std::istringstream issProdLabelsLine(prodLabelsLine); MapOfClassesType mapOfClassesProdClX; mapOfClassesRefClX.clear(); mapOfClassesProdClX.clear(); int itLab = 0; while (issRefLabelsLine.good()) { std::getline(issRefLabelsLine, currentValue, separatorChar); labelRef = static_cast (std::atoi(currentValue.c_str())); mapOfClassesRefClX[labelRef] = itLab; ++itLab; } itLab = 0; while (issProdLabelsLine.good()) { std::getline(issProdLabelsLine, currentValue, separatorChar); labelProd = static_cast (std::atoi(currentValue.c_str())); mapOfClassesProdClX[labelProd] = itLab; ++itLab; } unsigned int nbRefLabelsClk = mapOfClassesRefClX.size(); unsigned int nbProdLabelsClk = mapOfClassesProdClX.size(); ConfusionMatrixType confusionMatrixClXTemp; confusionMatrixClXTemp = ConfusionMatrixType(nbRefLabelsClk, nbProdLabelsClk); confusionMatrixClXTemp.Fill(0); // Reading the confusion matrix confusionMatrixClXTemp from the file for (unsigned int itRow = 0; itRow < nbRefLabelsClk; ++itRow) { //Gets the itRow^th line after the header lines with the labels std::getline(inFile, currentLine, eolChar); std::istringstream issCurrentLine(currentLine); unsigned int itCol = 0; while (issCurrentLine.good()) { std::getline(issCurrentLine, currentValue, separatorChar); confusionMatrixClXTemp(itRow, itCol) = static_cast (std::atoi(currentValue.c_str())); ++itCol; } } MapOfClassesType::iterator itMapOfClassesRef, itMapOfClassesProd; // Formatting confusionMatrixClX from confusionMatrixClXTemp in order to make confusionMatrixClX a square matrix // from the reference labels in mapOfClassesRefClX int indiceLabelRef = 0, indiceLabelProd = 0; int indiceLabelRefTemp = 0, indiceLabelProdTemp = 0; // Initialization of confusionMatrixClX confusionMatrixClX = ConfusionMatrixType(nbRefLabelsClk, nbRefLabelsClk); confusionMatrixClX.Fill(0); for (itMapOfClassesRef = mapOfClassesRefClX.begin(); itMapOfClassesRef != mapOfClassesRefClX.end(); ++itMapOfClassesRef) { // labels labelRef of mapOfClassesRefClX are already sorted labelRef = itMapOfClassesRef->first; indiceLabelRefTemp = itMapOfClassesRef->second; for (itMapOfClassesProd = mapOfClassesProdClX.begin(); itMapOfClassesProd != mapOfClassesProdClX.end(); ++itMapOfClassesProd) { // labels labelProd of mapOfClassesProdClX are already sorted labelProd = itMapOfClassesProd->first; indiceLabelProdTemp = itMapOfClassesProd->second; // If labelProd is present in mapOfClassesRefClX if (mapOfClassesRefClX.count(labelProd) != 0) { // Indice of labelProd in mapOfClassesRefClX; itMapOfClassesRef->second elements are already SORTED indiceLabelProd = mapOfClassesRefClX[labelProd]; confusionMatrixClX(indiceLabelRef, indiceLabelProd) = confusionMatrixClXTemp(indiceLabelRefTemp, indiceLabelProdTemp); } } ++indiceLabelRef; } } inFile.close(); return EXIT_SUCCESS; } void DoExecute() ITK_OVERRIDE { // Clear any previous filter m_Filters.clear(); FloatVectorImageListType* imageList = GetParameterImageList("il"); if (GetParameterInt("method") == Method_Majority_Voting) { otbAppLogINFO("Fusion by Majority Voting"); LabelVotingFilterType::Pointer labelVotingFilter = LabelVotingFilterType::New(); labelVotingFilter->SetLabelForUndecidedPixels(GetParameterInt("undecidedlabel")); m_Filters.push_back(labelVotingFilter.GetPointer()); //Iterate over all input images for (unsigned int imageId = 0; imageId < imageList->Size(); ++imageId) { FloatVectorImageType* image = imageList->GetNthElement(imageId); ConverterType::Pointer converter = ConverterType::New(); converter->SetInput(image); converter->SetChannel(1); labelVotingFilter->SetInput(imageId, converter->GetOutput()); // Register filter m_Filters.push_back(converter.GetPointer()); } SetParameterOutputImage("out", labelVotingFilter->GetOutput()); }// END Fusion by Majority Voting ////////////////////////////////////////////////////////////////////////////////////////////////////////////// else { if (GetParameterInt("method") == Method_Dempster_Shafer) { otbAppLogINFO("Fusion with the Dempster Shafer method"); ImageListType::Pointer imageListTemp = ImageListType::New(); ConfusionMatrixToMassOfBeliefType::Pointer confusionMatrixToMassOfBeliefFilter = ConfusionMatrixToMassOfBeliefType::New(); DSFusionOfClassifiersImageFilterType::Pointer dsFusionOfClassifiersImageFilter = DSFusionOfClassifiersImageFilterType::New(); dsFusionOfClassifiersImageFilter->SetLabelForUndecidedPixels(GetParameterInt("undecidedlabel")); m_Filters.push_back(confusionMatrixToMassOfBeliefFilter.GetPointer()); m_Filters.push_back(dsFusionOfClassifiersImageFilter.GetPointer()); std::vector confusionMatricesFilenameList = GetParameterStringList("method.dempstershafer.cmfl"); MassOfBeliefDefinitionMethod massOfBeliefDefMethod; //setting default to suppress warning massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; switch (GetParameterInt("method.dempstershafer.mob")) { case Mode_MOB_Precision: { otbAppLogINFO("Masses of belief = PRECISION rates of each classifier (one rate per class label)"); massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; } break; case Mode_MOB_Recall: { otbAppLogINFO("Masses of belief = RECALL rates of each classifier (one rate per class label)"); massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::RECALL; } break; case Mode_MOB_Accuracy: { otbAppLogINFO("Mass of belief = OVERALL ACCURACY of each classifier (one unique rate for all the class labels)"); massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::ACCURACY; } break; case Mode_MOB_Kappa: { otbAppLogINFO("Mass of belief = KAPPA coefficient of each classifier (one unique rate for all the class labels)"); massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::KAPPA; } break; } //Iterate over all input images VectorOfMapOfMassesOfBeliefType vectorOfMapOfMassesOfBelief; for (unsigned int imageId = 0; imageId < imageList->Size(); ++imageId) { FloatVectorImageType* image = imageList->GetNthElement(imageId); ConverterType::Pointer converter = ConverterType::New(); converter->SetInput(image); converter->SetChannel(1); imageListTemp->PushBack(converter->GetOutput()); MapOfClassesType mapOfClassesClk; ConfusionMatrixType confusionMatrixClk; CSVConfusionMatrixFileReader(confusionMatricesFilenameList[imageId], mapOfClassesClk, confusionMatrixClk); confusionMatrixToMassOfBeliefFilter->SetMapOfClasses(mapOfClassesClk); confusionMatrixToMassOfBeliefFilter->SetConfusionMatrix(confusionMatrixClk); confusionMatrixToMassOfBeliefFilter->SetDefinitionMethod(massOfBeliefDefMethod); confusionMatrixToMassOfBeliefFilter->Update(); // Vector containing ALL the K (= nbClassifiers) std::map of Masses of Belief vectorOfMapOfMassesOfBelief.push_back(confusionMatrixToMassOfBeliefFilter->GetMapMassOfBelief()); // Register filter m_Filters.push_back(converter.GetPointer()); } // ********************************************** // Image List To VectorImage // ********************************************** ImageListToVectorImageFilterType::Pointer imageListToVectorImageFilter = ImageListToVectorImageFilterType::New(); imageListToVectorImageFilter->SetInput(imageListTemp); imageListToVectorImageFilter->Update(); otbAppLogINFO("Number of input classification maps: " << imageListToVectorImageFilter->GetOutput()->GetNumberOfComponentsPerPixel()); otbAppLogINFO("Number of input confusion matrix files: " << vectorOfMapOfMassesOfBelief.size()); LabelMassMapType::iterator itMap; for (unsigned int k = 0; k < vectorOfMapOfMassesOfBelief.size(); ++k) { LabelMassMapType mapOfMassesOfBelief = vectorOfMapOfMassesOfBelief[k]; otbAppLogINFO("Classifier[" << k << "]: "); otbAppLogINFO("\tConfusion Matrix file_" << k << ": " << confusionMatricesFilenameList[k]); for (itMap = mapOfMassesOfBelief.begin(); itMap != mapOfMassesOfBelief.end(); ++itMap) { otbAppLogINFO("\t\tMassOfBelief_Cl_" << k << "[label_" << itMap->first << "] = " << itMap->second ); } otbAppLogINFO(""); } // DSFusionOfClassifiersImageFilter Inputs dsFusionOfClassifiersImageFilter->SetInput(imageListToVectorImageFilter->GetOutput()); dsFusionOfClassifiersImageFilter->SetInputMapsOfMassesOfBelief(&vectorOfMapOfMassesOfBelief); dsFusionOfClassifiersImageFilter->SetLabelForNoDataPixels(GetParameterInt("nodatalabel")); dsFusionOfClassifiersImageFilter->SetLabelForUndecidedPixels(GetParameterInt("undecidedlabel")); //dsFusionOfClassifiersImageFilter->Update(); SetParameterOutputImage("out", dsFusionOfClassifiersImageFilter->GetOutput()); }// END Fusion with the Dempster Shafer method } } std::vector m_Filters; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::FusionOfClassifications) OTB-release-5.8/Modules/Applications/AppClassification/app/otbImageClassifier.cxx000066400000000000000000000236211301006202600301140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbChangeLabelImageFilter.h" #include "otbStandardWriterWatcher.h" #include "otbStatisticsXMLFileReader.h" #include "otbShiftScaleVectorImageFilter.h" #include "otbImageClassificationFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageToVectorImageCastFilter.h" #include "otbMachineLearningModelFactory.h" namespace otb { namespace Wrapper { class ImageClassifier : public Application { public: /** Standard class typedefs. */ typedef ImageClassifier Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ImageClassifier, otb::Application); /** Filters typedef */ typedef UInt16ImageType OutputImageType; typedef UInt8ImageType MaskImageType; typedef itk::VariableLengthVector MeasurementType; typedef otb::StatisticsXMLFileReader StatisticsReader; typedef otb::ShiftScaleVectorImageFilter RescalerType; typedef otb::ImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::Pointer ClassificationFilterPointerType; typedef ClassificationFilterType::ModelType ModelType; typedef ModelType::Pointer ModelPointerType; typedef ClassificationFilterType::ValueType ValueType; typedef ClassificationFilterType::LabelType LabelType; typedef otb::MachineLearningModelFactory MachineLearningModelFactoryType; typedef ClassificationFilterType::ConfidenceImageType ConfidenceImageType; protected: ~ImageClassifier() ITK_OVERRIDE { MachineLearningModelFactoryType::CleanFactories(); } private: void DoInit() ITK_OVERRIDE { SetName("ImageClassifier"); SetDescription("Performs a classification of the input image according to a model file."); // Documentation SetDocName("Image Classification"); SetDocLongDescription("This application performs an image classification based on a model file produced by the TrainImagesClassifier application. Pixels of the output image will contain the class labels decided by the classifier (maximal class label = 65535). The input pixels can be optionally centered and reduced according to the statistics file produced by the ComputeImagesStatistics application. An optional input mask can be provided, in which case only input image pixels whose corresponding mask value is greater than 0 will be classified. The remaining of pixels will be given the label 0 in the output image."); SetDocLimitations("The input image must have the same type, order and number of bands than the images used to produce the statistics file and the SVM model file. If a statistics file was used during training by the TrainImagesClassifier, it is mandatory to use the same statistics file for classification. If an input mask is used, its size must match the input image size."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("TrainImagesClassifier, ValidateImagesClassifier, ComputeImagesStatistics"); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription( "in", "The input image to classify."); AddParameter(ParameterType_InputImage, "mask", "Input Mask"); SetParameterDescription( "mask", "The mask allows restricting classification of the input image to the area where mask pixel values are greater than 0."); MandatoryOff("mask"); AddParameter(ParameterType_InputFilename, "model", "Model file"); SetParameterDescription("model", "A model file (produced by TrainImagesClassifier application, maximal class label = 65535)."); AddParameter(ParameterType_InputFilename, "imstat", "Statistics file"); SetParameterDescription("imstat", "A XML file containing mean and standard deviation to center and reduce samples before classification (produced by ComputeImagesStatistics application)."); MandatoryOff("imstat"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription( "out", "Output image containing class labels"); SetDefaultOutputPixelType( "out", ImagePixelType_uint8); AddParameter(ParameterType_OutputImage, "confmap", "Confidence map"); SetParameterDescription( "confmap", "Confidence map of the produced classification. The confidence index depends on the model : \n" " - LibSVM : difference between the two highest probabilities (needs a model with probability estimates, so that classes probabilities can be computed for each sample)\n" " - OpenCV\n" " * Boost : sum of votes\n" " * DecisionTree : (not supported)\n" " * GradientBoostedTree : (not supported)\n" " * KNearestNeighbors : number of neighbors with the same label\n" " * NeuralNetwork : difference between the two highest responses\n" " * NormalBayes : (not supported)\n" " * RandomForest : Confidence (proportion of votes for the majority class). Margin (normalized difference of the votes of the 2 majority classes) is not available for now.\n" " * SVM : distance to margin (only works for 2-class models)\n"); SetDefaultOutputPixelType( "confmap", ImagePixelType_double); MandatoryOff("confmap"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_1_ortho.tif"); SetDocExampleParameterValue("imstat", "EstimateImageStatisticsQB1.xml"); SetDocExampleParameterValue("model", "clsvmModelQB1.svm"); SetDocExampleParameterValue("out", "clLabeledImageQB1.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { // Load input image FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); // Load svm model otbAppLogINFO("Loading model"); m_Model = MachineLearningModelFactoryType::CreateMachineLearningModel(GetParameterString("model"), MachineLearningModelFactoryType::ReadMode); if (m_Model.IsNull()) { otbAppLogFATAL(<< "Error when loading model " << GetParameterString("model") << " : unsupported model type"); } m_Model->Load(GetParameterString("model")); otbAppLogINFO("Model loaded"); // Normalize input image (optional) StatisticsReader::Pointer statisticsReader = StatisticsReader::New(); MeasurementType meanMeasurementVector; MeasurementType stddevMeasurementVector; m_Rescaler = RescalerType::New(); // Classify m_ClassificationFilter = ClassificationFilterType::New(); m_ClassificationFilter->SetModel(m_Model); // Normalize input image if asked if(IsParameterEnabled("imstat") ) { otbAppLogINFO("Input image normalization activated."); // Load input image statistics statisticsReader->SetFileName(GetParameterString("imstat")); meanMeasurementVector = statisticsReader->GetStatisticVectorByName("mean"); stddevMeasurementVector = statisticsReader->GetStatisticVectorByName("stddev"); otbAppLogINFO( "mean used: " << meanMeasurementVector ); otbAppLogINFO( "standard deviation used: " << stddevMeasurementVector ); // Rescale vector image m_Rescaler->SetScale(stddevMeasurementVector); m_Rescaler->SetShift(meanMeasurementVector); m_Rescaler->SetInput(inImage); m_ClassificationFilter->SetInput(m_Rescaler->GetOutput()); } else { otbAppLogINFO("Input image normalization deactivated."); m_ClassificationFilter->SetInput(inImage); } if(IsParameterEnabled("mask")) { otbAppLogINFO("Using input mask"); // Load mask image and cast into LabeledImageType MaskImageType::Pointer inMask = GetParameterUInt8Image("mask"); m_ClassificationFilter->SetInputMask(inMask); } SetParameterOutputImage("out", m_ClassificationFilter->GetOutput()); // output confidence map if (IsParameterEnabled("confmap") && HasValue("confmap")) { m_ClassificationFilter->SetUseConfidenceMap(true); if (m_Model->HasConfidenceIndex()) { SetParameterOutputImage("confmap",m_ClassificationFilter->GetOutputConfidence()); } else { otbAppLogWARNING("Confidence map requested but the classifier doesn't support it!"); this->DisableParameter("confmap"); } } } ClassificationFilterType::Pointer m_ClassificationFilter; ModelPointerType m_Model; RescalerType::Pointer m_Rescaler; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ImageClassifier) OTB-release-5.8/Modules/Applications/AppClassification/app/otbKMeansClassification.cxx000066400000000000000000000415441301006202600311230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbVectorImage.h" #include "otbStreamingTraits.h" #include "itkImageRegionConstIterator.h" #include "itkListSample.h" #include "itkWeightedCentroidKdTreeGenerator.h" #include "itkKdTreeBasedKmeansEstimator.h" #include "otbStreamingShrinkImageFilter.h" #include "otbChangeLabelImageFilter.h" #include "otbRAMDrivenStrippedStreamingManager.h" #include "otbChangeLabelImageFilter.h" #include "itkLabelToRGBImageFilter.h" #include "otbReliefColormapFunctor.h" #include "itkScalarToRGBColormapImageFilter.h" namespace otb { namespace Wrapper { namespace Functor { template class KMeansFunctor { public: /** operator */ TLabel operator ()(const TSample& sample) const { typename CentroidMapType::const_iterator it = m_CentroidsMap.begin(); if (it == m_CentroidsMap.end()) { return 0; } TLabel resp = it->first; double minDist = m_Distance->Evaluate(sample, it->second); ++it; while (it != m_CentroidsMap.end()) { double dist = m_Distance->Evaluate(sample, it->second); if (dist < minDist) { resp = it->first; minDist = dist; } ++it; } return resp; } /** Add a new centroid */ void AddCentroid(const TLabel& label, const TSample& centroid) { m_CentroidsMap[label] = centroid; } /** Constructor */ KMeansFunctor() : m_CentroidsMap(), m_Distance() { m_Distance = DistanceType::New(); } bool operator !=(const KMeansFunctor& other) const { return m_CentroidsMap != other.m_CentroidsMap; } private: typedef std::map CentroidMapType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; CentroidMapType m_CentroidsMap; typename DistanceType::Pointer m_Distance; }; } typedef FloatImageType::PixelType PixelType; typedef UInt16ImageType LabeledImageType; typedef UInt16VectorImageType VectorImageType; typedef VectorImageType::PixelType VectorPixelType; typedef UInt8RGBImageType RGBImageType; typedef RGBImageType::PixelType RGBPixelType; typedef LabeledImageType::PixelType LabelType; typedef FloatVectorImageType::PixelType SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::WeightedCentroidKdTreeGenerator TreeGeneratorType; typedef TreeGeneratorType::KdTreeType TreeType; typedef itk::Statistics::KdTreeBasedKmeansEstimator EstimatorType; typedef RAMDrivenStrippedStreamingManager RAMDrivenStrippedStreamingManagerType; typedef itk::ImageRegionConstIterator IteratorType; typedef itk::ImageRegionConstIterator LabeledIteratorType; typedef otb::StreamingShrinkImageFilter ImageSamplingFilterType; typedef otb::StreamingShrinkImageFilter MaskSamplingFilterType; typedef Functor::KMeansFunctor KMeansFunctorType; typedef itk::UnaryFunctorImageFilter KMeansFilterType; // Manual label LUT typedef otb::ChangeLabelImageFilter ChangeLabelFilterType; // Continuous LUT mapping typedef itk::ScalarToRGBColormapImageFilter ColorMapFilterType; typedef otb::Functor::ReliefColormapFunctor ReliefColorMapFunctorType; typedef otb::ImageMetadataInterfaceBase ImageMetadataInterfaceType; class KMeansClassification: public Application { public: /** Standard class typedefs. */ typedef KMeansClassification Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(KMeansClassification, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("KMeansClassification"); SetDescription("Unsupervised KMeans image classification"); SetDocName("Unsupervised KMeans image classification"); SetDocLongDescription("Performs unsupervised KMeans image classification."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Segmentation); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image to classify."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image containing the class indexes."); SetDefaultOutputPixelType("out",ImagePixelType_uint8); AddRAMParameter(); AddParameter(ParameterType_InputImage, "vm", "Validity Mask"); SetParameterDescription("vm", "Validity mask. Only non-zero pixels will be used to estimate KMeans modes."); MandatoryOff("vm"); AddParameter(ParameterType_Int, "ts", "Training set size"); SetParameterDescription("ts", "Size of the training set (in pixels)."); SetDefaultParameterInt("ts", 100); MandatoryOff("ts"); AddParameter(ParameterType_Int, "nc", "Number of classes"); SetParameterDescription("nc", "Number of modes, which will be used to generate class membership."); SetDefaultParameterInt("nc", 5); AddParameter(ParameterType_Int, "maxit", "Maximum number of iterations"); SetParameterDescription("maxit", "Maximum number of iterations for the learning step."); SetDefaultParameterInt("maxit", 1000); MandatoryOff("maxit"); AddParameter(ParameterType_Float, "ct", "Convergence threshold"); SetParameterDescription("ct", "Convergence threshold for class centroid (L2 distance, by default 0.0001)."); SetDefaultParameterFloat("ct", 0.0001); MandatoryOff("ct"); AddParameter(ParameterType_OutputFilename, "outmeans", "Centroid filename"); SetParameterDescription("outmeans", "Output text file containing centroid positions"); MandatoryOff("outmeans"); AddRANDParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_1_ortho.tif"); SetDocExampleParameterValue("ts", "1000"); SetDocExampleParameterValue("nc", "5"); SetDocExampleParameterValue("maxit", "1000"); SetDocExampleParameterValue("ct", "0.0001"); SetDocExampleParameterValue("out", "ClassificationFilterOutput.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // test of input image // if (HasValue("in")) { // input image FloatVectorImageType::Pointer inImage = GetParameterImage("in"); RAMDrivenStrippedStreamingManagerType::Pointer streamingManager = RAMDrivenStrippedStreamingManagerType::New(); int availableRAM = GetParameterInt("ram"); streamingManager->SetAvailableRAMInMB(availableRAM); float bias = 1.5; // empirical value streamingManager->SetBias(bias); FloatVectorImageType::RegionType largestRegion = inImage->GetLargestPossibleRegion(); FloatVectorImageType::SizeType largestRegionSize = largestRegion.GetSize(); streamingManager->PrepareStreaming(inImage, largestRegion); unsigned long nbDivisions = streamingManager->GetNumberOfSplits(); unsigned long largestPixNb = largestRegionSize[0] * largestRegionSize[1]; unsigned long maxPixNb = largestPixNb / nbDivisions; if (GetParameterInt("ts") > static_cast (maxPixNb)) { otbAppLogWARNING("The available RAM is too small to process this sample size of " << GetParameterInt("ts") << " pixels. The sample size will be reduced to " << maxPixNb << " pixels." << std::endl); this->SetParameterInt("ts", maxPixNb); } this->SetMaximumParameterIntValue("ts", maxPixNb); } } void DoExecute() ITK_OVERRIDE { GetLogger()->Debug("Entering DoExecute\n"); m_InImage = GetParameterImage("in"); m_InImage->UpdateOutputInformation(); UInt8ImageType::Pointer maskImage; std::ostringstream message(""); int nbsamples = GetParameterInt("ts"); const unsigned int nbClasses = GetParameterInt("nc"); /*******************************************/ /* Sampling data */ /*******************************************/ otbAppLogINFO("-- SAMPLING DATA --"<UpdateOutputInformation(); bool maskFlag = IsParameterEnabled("vm"); if (maskFlag) { otbAppLogINFO("sample choice using mask "<UpdateOutputInformation(); if (m_InImage->GetLargestPossibleRegion() != maskImage->GetLargestPossibleRegion()) { GetLogger()->Error("Mask image and input image have different sizes."); return; } } // Training sample lists ListSampleType::Pointer sampleList = ListSampleType::New(); sampleList->SetMeasurementVectorSize(m_InImage->GetNumberOfComponentsPerPixel()); //unsigned int init_means_index = 0; // Sample dimension and max dimension const unsigned int nbComp = m_InImage->GetNumberOfComponentsPerPixel(); unsigned int sampleSize = nbComp; unsigned int totalSamples = 0; // sampleSize = std::min(nbComp, maxDim); EstimatorType::ParametersType initialMeans(nbComp * nbClasses); initialMeans.Fill(0); // use image and mask shrink ImageSamplingFilterType::Pointer imageSampler = ImageSamplingFilterType::New(); imageSampler->SetInput(m_InImage); double theoricNBSamplesForKMeans = nbsamples; const double upperThresholdNBSamplesForKMeans = 1000 * 1000; const double actualNBSamplesForKMeans = std::min(theoricNBSamplesForKMeans, upperThresholdNBSamplesForKMeans); otbAppLogINFO(<< actualNBSamplesForKMeans << " is the maximum sample size that will be used." << std::endl); const double shrinkFactor = vcl_floor( vcl_sqrt( m_InImage->GetLargestPossibleRegion().GetNumberOfPixels() / actualNBSamplesForKMeans)); imageSampler->SetShrinkFactor(shrinkFactor); imageSampler->Update(); MaskSamplingFilterType::Pointer maskSampler; LabeledIteratorType m_MaskIt; if (maskFlag) { maskSampler = MaskSamplingFilterType::New(); maskSampler->SetInput(maskImage); maskSampler->SetShrinkFactor(shrinkFactor); maskSampler->Update(); m_MaskIt = LabeledIteratorType(maskSampler->GetOutput(), maskSampler->GetOutput()->GetLargestPossibleRegion()); m_MaskIt.GoToBegin(); } // Then, build the sample list IteratorType it(imageSampler->GetOutput(), imageSampler->GetOutput()->GetLargestPossibleRegion()); it.GoToBegin(); SampleType min; SampleType max; SampleType sample; //first sample itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen=itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance(); //randGen->Initialize(); if (maskFlag) { while (!it.IsAtEnd() && !m_MaskIt.IsAtEnd() && (m_MaskIt.Get() <= 0)) { ++it; ++m_MaskIt; } // If the mask is empty after the subsampling if (m_MaskIt.IsAtEnd()) { GetLogger()->Error("The mask image is empty after subsampling. Please increase the training set size."); return; } } min = it.Get(); max = it.Get(); sample = it.Get(); sampleList->PushBack(sample); ++it; if (maskFlag) { ++m_MaskIt; } totalSamples = 1; bool selectSample; while (!it.IsAtEnd()) { if (maskFlag) { selectSample = (m_MaskIt.Get() > 0); ++m_MaskIt; } else selectSample = true; if (selectSample) { totalSamples++; sample = it.Get(); sampleList->PushBack(sample); for (unsigned int i = 0; i < nbComp; ++i) { if (min[i] > sample[i]) { min[i] = sample[i]; } if (max[i] < sample[i]) { max[i] = sample[i]; } } } ++it; } // Next, initialize centroids by random sampling in the generated // list of samples for (unsigned int classIndex = 0; classIndex < nbClasses; ++classIndex) { SampleType newCentroid = sampleList->GetMeasurementVector(randGen->GetIntegerVariate(sampleList->Size()-1)); for (unsigned int compIndex = 0; compIndex < sampleSize; ++compIndex) { initialMeans[compIndex + classIndex * sampleSize] = newCentroid[compIndex]; } } otbAppLogINFO(<< totalSamples << " samples will be used as estimator input." << std::endl); /*******************************************/ /* Learning */ /*******************************************/ otbAppLogINFO("-- LEARNING --" << std::endl); otbAppLogINFO("Initial centroids are: " << std::endl); message.str(""); message << std::endl; for (unsigned int i = 0; i < nbClasses; i++) { message << "Class " << i << ": "; for (unsigned int j = 0; j < sampleSize; j++) { message << std::setw(8) << initialMeans[i * sampleSize + j] << " "; } message << std::endl; } message << std::endl; GetLogger()->Info(message.str()); message.str(""); otbAppLogINFO("Starting optimization." << std::endl); EstimatorType::Pointer estimator = EstimatorType::New(); TreeGeneratorType::Pointer treeGenerator = TreeGeneratorType::New(); treeGenerator->SetSample(sampleList); treeGenerator->SetBucketSize(10000); treeGenerator->Update(); estimator->SetParameters(initialMeans); estimator->SetKdTree(treeGenerator->GetOutput()); int maxIt = GetParameterInt("maxit"); estimator->SetMaximumIteration(maxIt); estimator->SetCentroidPositionChangesThreshold(GetParameterFloat("ct")); estimator->StartOptimization(); EstimatorType::ParametersType estimatedMeans = estimator->GetParameters(); otbAppLogINFO("Optimization completed." ); if (estimator->GetCurrentIteration() == maxIt) { otbAppLogWARNING("The estimator reached the maximum iteration number." << std::endl); } message.str(""); message << "Estimated centroids are: " << std::endl; message << std::endl; for (unsigned int i = 0; i < nbClasses; i++) { message << "Class " << i << ": "; for (unsigned int j = 0; j < sampleSize; j++) { message << std::setw(8) << estimatedMeans[i * sampleSize + j] << " "; } message << std::endl; } message << std::endl; message << "Learning completed." << std::endl; message << std::endl; GetLogger()->Info(message.str()); /*******************************************/ /* Classification */ /*******************************************/ otbAppLogINFO("-- CLASSIFICATION --" << std::endl); // Finally, update the KMeans filter KMeansFunctorType functor; for (unsigned int classIndex = 0; classIndex < nbClasses; ++classIndex) { SampleType centroid(sampleSize); for (unsigned int compIndex = 0; compIndex < sampleSize; ++compIndex) { centroid[compIndex] = estimatedMeans[compIndex + classIndex * sampleSize]; } functor.AddCentroid(classIndex, centroid); } m_KMeansFilter = KMeansFilterType::New(); m_KMeansFilter->SetFunctor(functor); m_KMeansFilter->SetInput(m_InImage); // optional saving option -> lut if (IsParameterEnabled("outmeans")) { std::ofstream file; file.open(GetParameterString("outmeans").c_str()); for (unsigned int i = 0; i < nbClasses; i++) { for (unsigned int j = 0; j < sampleSize; j++) { file << std::setw(8) << estimatedMeans[i * sampleSize + j] << " "; } file << std::endl; } file.close(); } SetParameterOutputImage("out", m_KMeansFilter->GetOutput()); } // KMeans filter KMeansFilterType::Pointer m_KMeansFilter; FloatVectorImageType::Pointer m_InImage; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::KMeansClassification) OTB-release-5.8/Modules/Applications/AppClassification/app/otbMultiImageSamplingRate.cxx000066400000000000000000000407651301006202600314410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbSamplingRateCalculatorList.h" #include "otbStatisticsXMLFileReader.h" namespace otb { namespace Wrapper { class MultiImageSamplingRate : public Application { public: /** Standard class typedefs. */ typedef MultiImageSamplingRate Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(MultiImageSamplingRate, otb::Application); /** typedef */ typedef otb::SamplingRateCalculatorList RateCalculatorListType; typedef RateCalculatorListType::ClassCountMapType ClassCountMapType; typedef RateCalculatorListType::MapRateType MapRateType; typedef itk::VariableLengthVector MeasurementType; typedef otb::StatisticsXMLFileReader XMLReaderType; private: MultiImageSamplingRate() { m_CalculatorList = RateCalculatorListType::New(); } void DoInit() { SetName("MultiImageSamplingRate"); SetDescription("Compute sampling rate for an input set of images."); // Documentation SetDocName("Multi-image sampling rate estimation"); SetDocLongDescription("The application computes sampling rates for a set of" " input images. Before calling this application, each pair of image and " "training vectors has to be analysed with the application " "PolygonClassStatistics. The statistics file is then used to compute the " "sampling rates for each class in each image. Several types of sampling " " are implemented. Each one is a combination of a mono-image strategy " "and a multi-image mode. The mono-image strategies are :\n\n" " * smallest (default) : select the same number of sample in each " "class so that the smallest one is fully sampled.\n" " * constant : select the same number of samples N in each class " "(with N below or equal to the size of the smallest class).\n" " * byclass : set the required number for each class manually, with an " "input CSV file (first column is class name, second one is the required " "samples number).\n\n" "The multi-image modes (mim) are proportional, equal and custom. The custom " "mode lets the users choose the distribution of samples among the " "images. The different behaviours are described below. Ti(c) and Ni(c) " " refers resp. to the total number and needed number of samples in " "image i for class c. Let's call L the total number of images.\n" " * strategy = all\n\n" " - Same behaviour for all modes : take all samples\n\n" " * strategy = constant :" " let's call M the global number of samples required per class." " For each image i and each class c:\n\n" " - if mim = proportional, then Ni( c ) = M * Ti( c ) / sum_k( Tk(c) )\n\n" " - if mim = equal , then Ni( c ) = M / L\n\n" " - if mim = custom , then Ni( c ) = Mi where Mi is the custom requested number of samples for image i\n\n" " * strategy = byClass :" " let's call M(c) the global number of samples for class c)." " For each image i and each class c:\n\n" " - if mim = proportional, then Ni( c ) = M(c) * Ti( c ) / sum_k( Tk(c) )\n\n" " - if mim = equal , then Ni( c ) = M(c) / L\n\n" " - if mim = custom , then Ni( c ) = Mi(c) where Mi(c) is the custom requested number of samples for image i and class c\n\n" " * strategy = percent :" " For each image i and each class c:\n\n" " - if mim = proportional, then Ni( c ) = p * Ti( c ) where p is the global percentage of samples\n\n" " - if mim = equal , then Ni( c ) = p * sum_k(Tk(c)]/L where p is the global percentage of samples\n\n" " - if mim = custom , then Ni( c ) = p(i) * Ti(c) where p(i) is the percentage of samples for image i. c\n\n" " * strategy = total :" " For each image i and each class c:\n\n" " - if mim = proportional, then Ni( c ) = total * (sum_k(Ti(k))/sum_kl(Tl(k))) * (Ti(c)/sum_k(Ti(k))) where total is the total number of samples specified.\n\n" " - if mim = equal , then Ni( c ) = (total / L) * (Ti(c)/sum_k(Ti(k))) where total is the total number of samples specified.\n\n" " - if mim = custom , then Ni( c ) = total(i) * (Ti(c)/sum_k(Ti(k))) where total(i) is the total number of samples specified for image i. \n\n" " * strategy = smallest class\n\n" " - if mim = proportional, then the smallest class size (computed globally) is used for the strategy constant+proportional.\n\n" " - if mim = equal , then the smallest class size (computed globally) is used for the strategy constant+equal.\n\n" " - if mim = custom , then the smallest class is computed and used for each image separately.\n\n" ); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputFilenameList, "il", "Input statistics"); SetParameterDescription("il", "List of statistics files for each input image."); AddParameter(ParameterType_OutputFilename, "out", "Output sampling rates"); SetParameterDescription("out","Output filename storing sampling rates (CSV " "format with class name, required samples, total samples, and rate). " "The given filename will be used with a suffix to indicate the " "corresponding input index (for instance: rates.csv will give rates_1.csv" ", rates_2.csv, ...)."); AddParameter(ParameterType_Choice, "strategy", "Sampling strategy"); AddChoice("strategy.byclass","Set samples count for each class"); SetParameterDescription("strategy.byclass","Set samples count for each class"); AddParameter(ParameterType_InputFilenameList, "strategy.byclass.in", "Number of samples by class"); SetParameterDescription("strategy.byclass.in", "Number of samples by class " "(CSV format with class name in 1st column and required samples in the 2nd)." "In the case of the custom multi-image mode, several inputs may be given for each image."); AddChoice("strategy.constant","Set the same samples counts for all classes"); SetParameterDescription("strategy.constant","Set the same samples counts for all classes"); AddParameter(ParameterType_String, "strategy.constant.nb", "Number of samples for all classes"); SetParameterDescription("strategy.constant.nb", "Number of samples for all classes." "In the case of the custom multi-image mode, several values can be given for each image."); AddChoice("strategy.smallest","Set same number of samples for all classes, with the smallest class fully sampled"); SetParameterDescription("strategy.smallest","Set same number of samples for all classes, with the smallest class fully sampled"); AddChoice("strategy.percent","Use a percentage of the samples available for each class"); SetParameterDescription("strategy.percent","Use a percentage of the samples available for each class"); AddParameter(ParameterType_String,"strategy.percent.p","The percentage(s) to use"); SetParameterDescription("strategy.percent.p","The percentage(s) to use " "In the case of the custom multi-image mode, several values can be given for each image."); AddChoice("strategy.total","Set the total number of samples to generate, and use class proportions."); SetParameterDescription("strategy.total","Set the total number of samples to generate, and use class proportions."); AddParameter(ParameterType_String,"strategy.total.v","The number of samples to generate"); SetParameterDescription("strategy.total.v","The number of samples to generate" "In the case of the custom multi-image mode, several values can be given for each image."); AddChoice("strategy.all","Take all samples"); SetParameterDescription("strategy.all","Take all samples"); // Default strategy : smallest SetParameterString("strategy","smallest"); AddParameter(ParameterType_Choice, "mim", "Multi-Image Mode"); AddChoice("mim.proportional", "Proportional"); SetParameterDescription("mim.proportional","Split proportionally the required number of samples"); AddChoice("mim.equal", "equal"); SetParameterDescription("mim.equal","Split equally the required number of samples"); AddChoice("mim.custom", "Custom"); SetParameterDescription("mim.custom","Split the required number of samples following user choice."); // Doc example parameter settings SetDocExampleParameterValue("il", "stats_1.xml stats_2.xml"); SetDocExampleParameterValue("out", "rates.csv"); SetDocExampleParameterValue("strategy", "smallest"); SetDocExampleParameterValue("mim","proportional"); } void DoUpdateParameters() { } void DoExecute() { // Clear state m_CalculatorList->Clear(); std::vector inputs = this->GetParameterStringList("il"); unsigned int nbInputs = inputs.size(); XMLReaderType::Pointer statReader = XMLReaderType::New(); for (unsigned int i=0 ; iPushBack(otb::SamplingRateCalculator::New()); statReader->SetFileName(inputs[i]); ClassCountMapType classCount = statReader->GetStatisticMapByName("samplesPerClass"); m_CalculatorList->SetNthClassCount(i,classCount); } // Cautions : direct mapping between the enum PartitionType and the choice order RateCalculatorListType::PartitionType partitionMode = static_cast(this->GetParameterInt("mim")); unsigned int minParamSize = 1; if (partitionMode == RateCalculatorListType::CUSTOM) { // Check we have enough inputs for the custom mode minParamSize = nbInputs; } switch (this->GetParameterInt("strategy")) { // byclass case 0: { std::vector requiredFiles = this->GetParameterStringList("strategy.byclass.in"); std::vector requiredCounts; if (requiredFiles.size() < minParamSize) { otbAppLogFATAL("Missing arguments in strategy.byclass.in to process sampling rates"); } otbAppLogINFO("Sampling strategy : set number of samples for each class"); for (unsigned int i=0 ; iSetNbOfSamplesByClass(requiredCounts, partitionMode); } break; // constant case 1: { std::vector parts = itksys::SystemTools::SplitString(this->GetParameterString("strategy.constant.nb"),' '); std::vector countList; for (unsigned int i=0 ; i(parts[i])); } } if (countList.size() < minParamSize) { otbAppLogFATAL("Missing arguments in strategy.constant.nb to process sampling rates"); } otbAppLogINFO("Sampling strategy : set a constant number of samples for all classes"); m_CalculatorList->SetNbOfSamplesAllClasses(countList, partitionMode); } break; // percent case 2: { std::vector parts = itksys::SystemTools::SplitString(this->GetParameterString("strategy.percent.p"),' '); std::vector percentList; for (unsigned int i=0 ; i(parts[i])); if(percentList.back()<0 || percentList.back()>1) { otbAppLogFATAL("Percent parameter should be in range [0,1]"); } } } if (percentList.size() < minParamSize) { otbAppLogFATAL("Missing arguments in strategy.percent.p to process sampling rates"); } otbAppLogINFO("Sampling strategy : set a percentage of samples to be used."); m_CalculatorList->SetPercentageOfSamples(percentList, partitionMode); } break; // total case 3: { std::vector parts = itksys::SystemTools::SplitString(this->GetParameterString("strategy.total.v"),' '); std::vector totalList; for (unsigned int i=0 ; i(parts[i])); } } if (totalList.size() < minParamSize) { otbAppLogFATAL("Missing arguments in strategy.total.v to process sampling rates"); } otbAppLogINFO("Sampling strategy : set a constant number of samples for all classes"); m_CalculatorList->SetTotalNumberOfSamples(totalList, partitionMode); } break; // smallest class case 4: { otbAppLogINFO("Sampling strategy : fit the number of samples based on the smallest class"); m_CalculatorList->SetMinimumNbOfSamplesByClass(partitionMode); } break; // all samples case 5: { otbAppLogINFO("Sampling strategy : take all samples"); m_CalculatorList->SetAllSamples(partitionMode); } break; default: otbAppLogFATAL("Strategy mode unknown :"<GetParameterString("strategy")); break; } std::ostringstream oss; std::string outputPath(this->GetParameterString("out")); std::string outputBase = outputPath.substr(0, outputPath.find_last_of('.')); std::string outputExt = outputPath.substr(outputPath.find_last_of('.'), std::string::npos); unsigned int overflowCount = 0; for (unsigned int i=0 ; iGetRatesByClass(i); MapRateType::const_iterator itRates = rates.begin(); for(; itRates != rates.end(); ++itRates) { otb::SamplingRateCalculator::TripletType tpt = itRates->second; oss << itRates->first << "\t" << tpt.Required << "\t" << tpt.Tot << "\t" << tpt.Rate; if (tpt.Required > tpt.Tot) { overflowCount++; oss << "\t[OVERFLOW]"; } oss << std::endl; } otbAppLogINFO("Sampling rates for image "<< i+1 <<" : " << oss.str()); // Output results to disk oss.str(std::string("")); oss << outputBase << "_" << i+1 << outputExt; m_CalculatorList->GetNthElement(i)->Write(oss.str()); } if (overflowCount) { std::string plural(overflowCount>1?"s":""); otbAppLogWARNING(<< overflowCount << " case"< namespace otb { namespace Wrapper { class OGRLayerClassifier : public Application { public: typedef OGRLayerClassifier Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self) ; itkTypeMacro(OGRLayerClassifier, otb::Application) ; private: void DoInit() ITK_OVERRIDE { SetName("OGRLayerClassifier"); SetDescription("Classify an OGR layer based on a machine learning model and a list of features to consider."); SetDocName("OGRLayerClassifier"); SetDocLongDescription("This application will apply a trained machine learning model on the selected feature to get a classification of each geometry contained in an OGR layer. The list of feature must match the list used for training. The predicted label is written in the user defined field for each geometry."); SetDocLimitations("Experimental. Only shapefiles are supported for now."); SetDocAuthors("David Youssefi during internship at CNES"); SetDocSeeAlso("ComputeOGRLayersFeaturesStatistics,TrainOGRLayersClassifier"); AddDocTag(Tags::Segmentation); AddParameter(ParameterType_InputVectorData, "inshp", "Name of the input shapefile"); SetParameterDescription("inshp","Name of the input shapefile"); AddParameter(ParameterType_InputFilename, "instats", "XML file containing mean and variance of each feature."); SetParameterDescription("instats", "XML file containing mean and variance of each feature."); AddParameter(ParameterType_OutputFilename, "insvm", "Input model filename."); SetParameterDescription("insvm", "Input model filename."); AddParameter(ParameterType_ListView, "feat", "Features"); SetParameterDescription("feat","Features to be calculated"); AddParameter(ParameterType_String,"cfield","Field containing the predicted class."); SetParameterDescription("cfield","Field containing the predicted class"); SetParameterString("cfield","predicted"); // Doc example parameter settings SetDocExampleParameterValue("inshp", "vectorData.shp"); SetDocExampleParameterValue("instats", "meanVar.xml"); SetDocExampleParameterValue("insvm", "svmModel.svm"); SetDocExampleParameterValue("feat", "perimeter"); SetDocExampleParameterValue("cfield", "predicted"); } void DoUpdateParameters() ITK_OVERRIDE { if ( HasValue("inshp") ) { std::string shapefile = GetParameterString("inshp"); otb::ogr::DataSource::Pointer ogrDS; otb::ogr::Layer layer(ITK_NULLPTR, false); OGRSpatialReference oSRS(""); std::vector options; ogrDS = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Read); std::string layername = itksys::SystemTools::GetFilenameName(shapefile); layername = layername.substr(0,layername.size()-4); layer = ogrDS->GetLayer(0); otb::ogr::Feature feature = layer.ogr().GetNextFeature(); ClearChoices("feat"); for(int iField=0; iFieldGetNameRef(); key = item; key.erase(std::remove(key.begin(), key.end(), ' '), key.end()); std::transform(key.begin(), key.end(), key.begin(), tolower); key="feat."+key; AddChoice(key,item); } } } void DoExecute() ITK_OVERRIDE { #ifdef OTB_USE_LIBSVM clock_t tic = clock(); std::string shapefile = GetParameterString("inshp").c_str(); std::string XMLfile = GetParameterString("instats").c_str(); std::string modelfile = GetParameterString("insvm").c_str(); typedef double ValueType; typedef itk::VariableLengthVector MeasurementType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::StatisticsXMLFileReader StatisticsReader; typedef unsigned int LabelPixelType; typedef itk::FixedArray LabelSampleType; typedef itk::Statistics::ListSample LabelListSampleType; typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleFilterType; StatisticsReader::Pointer statisticsReader = StatisticsReader::New(); statisticsReader->SetFileName(XMLfile); MeasurementType meanMeasurementVector = statisticsReader->GetStatisticVectorByName("mean"); MeasurementType stddevMeasurementVector = statisticsReader->GetStatisticVectorByName("stddev"); otb::ogr::DataSource::Pointer source = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Read); otb::ogr::Layer layer = source->GetLayer(0); bool goesOn = true; otb::ogr::Feature feature = layer.ogr().GetNextFeature(); ListSampleType::Pointer input = ListSampleType::New(); LabelListSampleType::Pointer target = LabelListSampleType::New(); const int nbFeatures = GetSelectedItems("feat").size(); input->SetMeasurementVectorSize(nbFeatures); if(feature.addr()) while(goesOn) { MeasurementType mv; mv.SetSize(nbFeatures); for(int idx=0; idx < nbFeatures; ++idx) mv[idx] = feature.ogr().GetFieldAsDouble(GetSelectedItems("feat")[idx]); input->PushBack(mv); target->PushBack(feature.ogr().GetFieldAsInteger("class")); feature = layer.ogr().GetNextFeature(); goesOn = feature.addr() != ITK_NULLPTR; } ShiftScaleFilterType::Pointer trainingShiftScaleFilter = ShiftScaleFilterType::New(); trainingShiftScaleFilter->SetInput(input); trainingShiftScaleFilter->SetShifts(meanMeasurementVector); trainingShiftScaleFilter->SetScales(stddevMeasurementVector); trainingShiftScaleFilter->Update(); ListSampleType::Pointer listSample; LabelListSampleType::Pointer labelListSample; listSample = trainingShiftScaleFilter->GetOutput(); labelListSample = target; ListSampleType::Pointer trainingListSample = listSample; LabelListSampleType::Pointer trainingLabeledListSample = labelListSample; typedef otb::LibSVMMachineLearningModel LibSVMType; LibSVMType::Pointer libSVMClassifier = LibSVMType::New(); libSVMClassifier->SetInputListSample(trainingListSample); libSVMClassifier->SetTargetListSample(trainingLabeledListSample); libSVMClassifier->Load(modelfile); libSVMClassifier->PredictAll(); otb::ogr::DataSource::Pointer source2 = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Update_LayerUpdate); otb::ogr::Layer layer2 = source2->GetLayer(0); OGRFieldDefn predictedField(GetParameterString("cfield").c_str(), OFTInteger); layer2.CreateField(predictedField, true); bool goesOn2 = true; layer2.ogr().ResetReading(); otb::ogr::Feature feature2 = layer2.ogr().GetNextFeature(); unsigned int count=0; if(feature2.addr()) while(goesOn2) { feature2.ogr().SetField(GetParameterString("cfield").c_str(),(int)labelListSample->GetMeasurementVector(count)[0]); layer2.SetFeature(feature2); feature2 = layer2.ogr().GetNextFeature(); goesOn2 = feature2.addr() != ITK_NULLPTR; count++; } const OGRErr err = layer2.ogr().CommitTransaction(); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Unable to commit transaction for OGR layer " << layer2.ogr().GetName() << "."); } source2->SyncToDisk(); clock_t toc = clock(); otbAppLogINFO( "Elapsed: "<< ((double)(toc - tic) / CLOCKS_PER_SEC)<<" seconds."); #else otbAppLogFATAL("Module LIBSVM is not installed. You should consider turning OTB_USE_LIBSVM on during cmake configuration."); #endif } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::OGRLayerClassifier) OTB-release-5.8/Modules/Applications/AppClassification/app/otbPolygonClassStatistics.cxx000066400000000000000000000155461301006202600315640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbOGRDataToClassStatisticsFilter.h" #include "otbStatisticsXMLFileWriter.h" #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" namespace otb { namespace Wrapper { class PolygonClassStatistics : public Application { public: /** Standard class typedefs. */ typedef PolygonClassStatistics Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(PolygonClassStatistics, otb::Application); /** Filters typedef */ typedef otb::OGRDataToClassStatisticsFilter FilterType; typedef otb::StatisticsXMLFileWriter StatWriterType; typedef otb::GeometriesSet GeometriesType; typedef otb::GeometriesProjectionFilter ProjectionFilterType; private: PolygonClassStatistics() { } void DoInit() ITK_OVERRIDE { SetName("PolygonClassStatistics"); SetDescription("Computes statistics on a training polygon set."); // Documentation SetDocName("Polygon Class Statistics"); SetDocLongDescription("The application processes a set of geometries " "intended for training (they should have a field giving the associated " "class). The geometries are analysed against a support image to compute " "statistics : \n" " - number of samples per class\n" " - number of samples per geometry\n" "An optional raster mask can be used to discard samples. Different types" " of geometry are supported : polygons, lines, points. The behaviour is " "different for each type of geometry :\n" " - polygon: select pixels whose center is inside the polygon\n" " - lines : select pixels intersecting the line\n" " - points : select closest pixel to the point\n"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "InputImage"); SetParameterDescription("in", "Support image that will be classified"); AddParameter(ParameterType_InputImage, "mask", "InputMask"); SetParameterDescription("mask", "Validity mask (only pixels corresponding to a mask value greater than 0 will be used for statistics)"); MandatoryOff("mask"); AddParameter(ParameterType_InputFilename, "vec", "Input vectors"); SetParameterDescription("vec","Input geometries to analyse"); AddParameter(ParameterType_OutputFilename, "out", "Output Statistics"); SetParameterDescription("out","Output file to store statistics (XML format)"); AddParameter(ParameterType_String, "field", "Field Name"); SetParameterDescription("field","Name of the field carrying the class name in the input vectors."); MandatoryOff("field"); SetParameterString("field", "class"); AddParameter(ParameterType_Int, "layer", "Layer Index"); SetParameterDescription("layer", "Layer index to read in the input vector file."); MandatoryOff("layer"); SetDefaultParameterInt("layer",0); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "support_image.tif"); SetDocExampleParameterValue("vec", "variousVectors.sqlite"); SetDocExampleParameterValue("field", "label"); SetDocExampleParameterValue("out","polygonStat.xml"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do } void DoExecute() ITK_OVERRIDE { otb::ogr::DataSource::Pointer vectors = otb::ogr::DataSource::New(this->GetParameterString("vec")); std::string fieldName = this->GetParameterString("field"); // Reproject geometries FloatVectorImageType::Pointer inputImg = this->GetParameterImage("in"); std::string imageProjectionRef = inputImg->GetProjectionRef(); FloatVectorImageType::ImageKeywordlistType imageKwl = inputImg->GetImageKeywordlist(); std::string vectorProjectionRef = vectors->GetLayer(GetParameterInt("layer")).GetProjectionRef(); otb::ogr::DataSource::Pointer reprojVector = vectors; GeometriesType::Pointer inputGeomSet; ProjectionFilterType::Pointer geometriesProjFilter; GeometriesType::Pointer outputGeomSet; bool doReproj = true; // don't reproject for these cases if (vectorProjectionRef.empty() || (imageProjectionRef == vectorProjectionRef) || (imageProjectionRef.empty() && imageKwl.GetSize() == 0)) doReproj = false; if (doReproj) { inputGeomSet = GeometriesType::New(vectors); reprojVector = otb::ogr::DataSource::New(); outputGeomSet = GeometriesType::New(reprojVector); // Filter instantiation geometriesProjFilter = ProjectionFilterType::New(); geometriesProjFilter->SetInput(inputGeomSet); if (imageProjectionRef.empty()) { geometriesProjFilter->SetOutputKeywordList(inputImg->GetImageKeywordlist()); // nec qd capteur } geometriesProjFilter->SetOutputProjectionRef(imageProjectionRef); geometriesProjFilter->SetOutput(outputGeomSet); otbAppLogINFO("Reprojecting input vectors..."); geometriesProjFilter->Update(); } FilterType::Pointer filter = FilterType::New(); filter->SetInput(this->GetParameterImage("in")); if (IsParameterEnabled("mask") && HasValue("mask")) { filter->SetMask(this->GetParameterImage("mask")); } filter->SetOGRData(reprojVector); filter->SetFieldName(fieldName); filter->SetLayerIndex(this->GetParameterInt("layer")); filter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(filter->GetStreamer(),"Analyse polygons..."); filter->Update(); FilterType::ClassCountMapType &classCount = filter->GetClassCountOutput()->Get(); FilterType::PolygonSizeMapType &polySize = filter->GetPolygonSizeOutput()->Get(); StatWriterType::Pointer statWriter = StatWriterType::New(); statWriter->SetFileName(this->GetParameterString("out")); statWriter->AddInputMap("samplesPerClass",classCount); statWriter->AddInputMap("samplesPerVector",polySize); statWriter->Update(); } }; } // end of namespace Wrapper } // end of namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::PolygonClassStatistics) OTB-release-5.8/Modules/Applications/AppClassification/app/otbPredictRegression.cxx000066400000000000000000000247061301006202600305250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "itkUnaryFunctorImageFilter.h" #include "otbChangeLabelImageFilter.h" #include "otbStandardWriterWatcher.h" #include "otbStatisticsXMLFileReader.h" #include "otbShiftScaleVectorImageFilter.h" #include "otbImageClassificationFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageToVectorImageCastFilter.h" #include "otbMachineLearningModelFactory.h" namespace otb { namespace Functor { /** * simple affine function : y = ax+b */ template class AffineFunctor { public: typedef double InternalType; // constructor AffineFunctor() : m_A(1.0),m_B(0.0) {} // destructor virtual ~AffineFunctor() {} void SetA(InternalType a) { m_A = a; } void SetB(InternalType b) { m_B = b; } inline TOutput operator()(const TInput & x) const { return static_cast( static_cast(x)*m_A + m_B); } private: InternalType m_A; InternalType m_B; }; } namespace Wrapper { class PredictRegression : public Application { public: /** Standard class typedefs. */ typedef PredictRegression Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(PredictRegression, otb::Application); /** Filters typedef */ typedef UInt8ImageType MaskImageType; typedef itk::VariableLengthVector MeasurementType; typedef otb::StatisticsXMLFileReader StatisticsReader; typedef otb::ShiftScaleVectorImageFilter RescalerType; typedef itk::UnaryFunctorImageFilter< FloatImageType, FloatImageType, otb::Functor::AffineFunctor > OutputRescalerType; typedef otb::ImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::Pointer ClassificationFilterPointerType; typedef ClassificationFilterType::ModelType ModelType; typedef ModelType::Pointer ModelPointerType; typedef ClassificationFilterType::ValueType ValueType; typedef ClassificationFilterType::LabelType LabelType; typedef otb::MachineLearningModelFactory MachineLearningModelFactoryType; protected: ~PredictRegression() ITK_OVERRIDE { MachineLearningModelFactoryType::CleanFactories(); } private: void DoInit() ITK_OVERRIDE { SetName("PredictRegression"); SetDescription("Performs a prediction of the input image according to a regression model file."); // Documentation SetDocName("Predict Regression"); SetDocLongDescription("This application predict output values from an input" " image, based on a regression model file produced by" " the TrainRegression application. Pixels of the " "output image will contain the predicted values from" "the regression model (single band). The input pixels" " can be optionally centered and reduced according " "to the statistics file produced by the " "ComputeImagesStatistics application. An optional " "input mask can be provided, in which case only " "input image pixels whose corresponding mask value " "is greater than 0 will be processed. The remaining" " of pixels will be given the value 0 in the output" " image."); SetDocLimitations("The input image must contain the feature bands used for" " the model training (without the predicted value). " "If a statistics file was used during training by the " "TrainRegression, it is mandatory to use the same " "statistics file for prediction. If an input mask is " "used, its size must match the input image size."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("TrainRegression, ComputeImagesStatistics"); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription( "in", "The input image to predict."); // TODO : use CSV input/output ? AddParameter(ParameterType_InputImage, "mask", "Input Mask"); SetParameterDescription( "mask", "The mask allow restricting " "classification of the input image to the area where mask pixel values " "are greater than 0."); MandatoryOff("mask"); AddParameter(ParameterType_InputFilename, "model", "Model file"); SetParameterDescription("model", "A regression model file (produced by " "TrainRegression application)."); AddParameter(ParameterType_InputFilename, "imstat", "Statistics file"); SetParameterDescription("imstat", "A XML file containing mean and standard" " deviation to center and reduce samples before prediction " "(produced by ComputeImagesStatistics application). If this file contains" "one more band than the sample size, the last stat of last band will be" "applied to expand the output predicted value"); MandatoryOff("imstat"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription( "out", "Output image containing predicted values"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_1_ortho.tif"); SetDocExampleParameterValue("imstat", "EstimateImageStatisticsQB1.xml"); SetDocExampleParameterValue("model", "clsvmModelQB1.svm"); SetDocExampleParameterValue("out", "clLabeledImageQB1.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { // Load input image FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); unsigned int nbFeatures = inImage->GetNumberOfComponentsPerPixel(); // Load svm model otbAppLogINFO("Loading model"); m_Model = MachineLearningModelFactoryType::CreateMachineLearningModel(GetParameterString("model"), MachineLearningModelFactoryType::ReadMode); if (m_Model.IsNull()) { otbAppLogFATAL(<< "Error when loading model " << GetParameterString("model") << " : unsupported model type"); } m_Model->Load(GetParameterString("model")); m_Model->SetRegressionMode(true); otbAppLogINFO("Model loaded"); // Classify m_ClassificationFilter = ClassificationFilterType::New(); m_ClassificationFilter->SetModel(m_Model); FloatImageType::Pointer outputImage = m_ClassificationFilter->GetOutput(); // Normalize input image if asked if(IsParameterEnabled("imstat") ) { otbAppLogINFO("Input image normalization activated."); // Normalize input image (optional) StatisticsReader::Pointer statisticsReader = StatisticsReader::New(); MeasurementType meanMeasurementVector; MeasurementType stddevMeasurementVector; m_Rescaler = RescalerType::New(); // Load input image statistics statisticsReader->SetFileName(GetParameterString("imstat")); meanMeasurementVector = statisticsReader->GetStatisticVectorByName("mean"); stddevMeasurementVector = statisticsReader->GetStatisticVectorByName("stddev"); otbAppLogINFO( "mean used: " << meanMeasurementVector ); otbAppLogINFO( "standard deviation used: " << stddevMeasurementVector ); if (meanMeasurementVector.Size() == nbFeatures + 1) { double outMean = meanMeasurementVector[nbFeatures]; double outStdDev = stddevMeasurementVector[nbFeatures]; meanMeasurementVector.SetSize(nbFeatures,false); stddevMeasurementVector.SetSize(nbFeatures,false); m_OutRescaler = OutputRescalerType::New(); m_OutRescaler->SetInput(m_ClassificationFilter->GetOutput()); m_OutRescaler->GetFunctor().SetA(outStdDev); m_OutRescaler->GetFunctor().SetB(outMean); outputImage = m_OutRescaler->GetOutput(); } else if (meanMeasurementVector.Size() != nbFeatures) { otbAppLogFATAL("Wrong number of components in statistics file : "<SetScale(stddevMeasurementVector); m_Rescaler->SetShift(meanMeasurementVector); m_Rescaler->SetInput(inImage); m_ClassificationFilter->SetInput(m_Rescaler->GetOutput()); } else { otbAppLogINFO("Input image normalization deactivated."); m_ClassificationFilter->SetInput(inImage); } if(IsParameterEnabled("mask")) { otbAppLogINFO("Using input mask"); // Load mask image and cast into LabeledImageType MaskImageType::Pointer inMask = GetParameterUInt8Image("mask"); m_ClassificationFilter->SetInputMask(inMask); } SetParameterOutputImage("out", outputImage); } ClassificationFilterType::Pointer m_ClassificationFilter; ModelPointerType m_Model; RescalerType::Pointer m_Rescaler; OutputRescalerType::Pointer m_OutRescaler; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::PredictRegression) OTB-release-5.8/Modules/Applications/AppClassification/app/otbSOMClassification.cxx000066400000000000000000000317031301006202600303770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbSOMMap.h" #include "otbSOM.h" #include "otbSOMImageClassificationFilter.h" #include "otbRAMDrivenAdaptativeStreamingManager.h" #include "itkImageRegionConstIterator.h" #include "itkImageRandomNonRepeatingConstIteratorWithIndex.h" namespace otb { namespace Wrapper { class SOMClassification : public Application { public: /** Standard class typedefs. */ typedef SOMClassification Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SOMClassification, otb::Application); /** Filters typedef */ typedef UInt16ImageType LabeledImageType; typedef itk::VariableLengthVector SampleType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::SOM EstimatorType; typedef RAMDrivenAdaptativeStreamingManager RAMDrivenAdaptativeStreamingManagerType; typedef FloatVectorImageType::RegionType RegionType; typedef itk::ImageRegionConstIterator IteratorType; typedef itk::ImageRegionConstIterator LabeledIteratorType; typedef itk::ImageRegionConstIterator SOMIteratorType; typedef otb::SOMImageClassificationFilter ClassificationFilterType; private: SOMClassification() { m_UseMask = false; m_Classifier = ClassificationFilterType::New(); } void DoInit() ITK_OVERRIDE { SetName("SOMClassification"); SetDescription("SOM image classification."); // Documentation SetDocName("SOM Classification"); SetDocLongDescription("Unsupervised Self Organizing Map image classification."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Segmentation); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "InputImage"); SetParameterDescription("in", "Input image to classify."); AddParameter(ParameterType_OutputImage, "out", "OutputImage"); SetParameterDescription("out", "Output classified image (each pixel contains the index of its corresponding vector in the SOM)."); SetDefaultOutputPixelType("out",ImagePixelType_uint8); AddParameter(ParameterType_InputImage, "vm", "ValidityMask"); SetParameterDescription("vm", "Validity mask (only pixels corresponding to a mask value greater than 0 will be used for learning)"); MandatoryOff("vm"); AddParameter(ParameterType_Float, "tp", "TrainingProbability"); SetParameterDescription("tp", "Probability for a sample to be selected in the training set"); MandatoryOff("tp"); AddParameter(ParameterType_Int, "ts", "TrainingSetSize"); SetParameterDescription("ts", "Maximum training set size (in pixels)"); MandatoryOff("ts"); AddParameter(ParameterType_OutputImage, "som", "SOM Map"); SetParameterDescription("som","Output image containing the Self-Organizing Map"); MandatoryOff("som"); AddParameter(ParameterType_Int, "sx", "SizeX"); SetParameterDescription("sx", "X size of the SOM map"); MandatoryOff("sx"); AddParameter(ParameterType_Int, "sy", "SizeY"); SetParameterDescription("sy", "Y size of the SOM map"); MandatoryOff("sy"); AddParameter(ParameterType_Int, "nx", "NeighborhoodX"); SetParameterDescription("nx", "X size of the initial neighborhood in the SOM map"); MandatoryOff("nx"); AddParameter(ParameterType_Int, "ny", "NeighborhoodY"); SetParameterDescription("ny", "Y size of the initial neighborhood in the SOM map"); MandatoryOff("nx"); AddParameter(ParameterType_Int, "ni", "NumberIteration"); SetParameterDescription("ni", "Number of iterations for SOM learning"); MandatoryOff("ni"); AddParameter(ParameterType_Float, "bi", "BetaInit"); SetParameterDescription("bi", "Initial learning coefficient"); MandatoryOff("bi"); AddParameter(ParameterType_Float, "bf", "BetaFinal"); SetParameterDescription("bf", "Final learning coefficient"); MandatoryOff("bf"); AddParameter(ParameterType_Float, "iv", "InitialValue"); SetParameterDescription("iv", "Maximum initial neuron weight"); MandatoryOff("iv"); AddRAMParameter(); // TODO : replace StreamingLines by RAM param ? AddRANDParameter(); // Default parameters SetDefaultParameterFloat("tp", 1.0); SetDefaultParameterInt("sx", 32); SetDefaultParameterInt("sy", 32); SetDefaultParameterInt("nx", 10); SetDefaultParameterInt("ny", 10); SetDefaultParameterInt("ni", 5); SetDefaultParameterFloat("bi", 1.0); SetDefaultParameterFloat("bf", 0.1); SetDefaultParameterFloat("iv", 0.0); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_1_ortho.tif"); SetDocExampleParameterValue("out","SOMClassification.tif"); SetDocExampleParameterValue("tp", "1.0"); SetDocExampleParameterValue("ts","16384"); SetDocExampleParameterValue("sx", "32"); SetDocExampleParameterValue("sy", "32"); SetDocExampleParameterValue("nx", "10"); SetDocExampleParameterValue("ny", "10"); SetDocExampleParameterValue("ni", "5"); SetDocExampleParameterValue("bi", "1.0"); SetDocExampleParameterValue("bf", "0.1"); SetDocExampleParameterValue("iv", "0"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do } void DoExecute() ITK_OVERRIDE { // initiating random number generation itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance(); FloatVectorImageType::Pointer input = GetParameterImage("in"); LabeledImageType::Pointer mask; m_UseMask = false; if (HasValue("vm")) { mask = GetParameterUInt16Image("vm"); if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) { otbAppLogFATAL("Mask image and input image have different sizes."); } m_UseMask = true; } /*******************************************/ /* Sampling data */ /*******************************************/ otbAppLogINFO("-- SAMPLING DATA --"); RegionType largestRegion = input->GetLargestPossibleRegion(); // Setting up local streaming capabilities RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); int availableRAM = GetParameterInt("ram"); streamingManager->SetAvailableRAMInMB(availableRAM); float bias = 2.0; // empiric value; streamingManager->SetBias(bias); streamingManager->PrepareStreaming(input, largestRegion); unsigned long numberOfStreamDivisions = streamingManager->GetNumberOfSplits(); otbAppLogINFO("The images will be streamed into "<SetMeasurementVectorSize(input->GetNumberOfComponentsPerPixel()); const double trainingProb = static_cast(GetParameterFloat("tp")); unsigned int nbsamples; if (HasValue("ts")) { nbsamples = GetParameterInt("ts"); } else { nbsamples = largestRegion.GetNumberOfPixels(); } // Sample dimension and max dimension unsigned int sampleSize = input->GetNumberOfComponentsPerPixel(); unsigned int totalSamples = 0; otbAppLogINFO("The following sample size will be used: "<GetSplit(piece); //otbAppLogINFO("Processing region: "<SetRequestedRegion(streamingRegion); input->PropagateRequestedRegion(); input->UpdateOutputData(); IteratorType it(input, streamingRegion); it.GoToBegin(); if (m_UseMask) { mask->SetRequestedRegion(streamingRegion); mask->PropagateRequestedRegion(); mask->UpdateOutputData(); LabeledIteratorType maskIt(mask, streamingRegion); maskIt.GoToBegin(); // Loop on the image and the mask while ( !it.IsAtEnd() && !maskIt.IsAtEnd() && (totalSamples0) { if (randomGen->GetVariateWithClosedRange() < trainingProb) { SampleType newSample; newSample.SetSize(sampleSize); // build the sample newSample.Fill(0); for (unsigned int i = 0; iPushBack(newSample); ++totalSamples; ++localNbSamples; } } ++it; ++maskIt; } index++; // we could break out of the while loop here, once the entire image has been streamed once if (index == numberOfStreamDivisions) index = 0; } else { // Loop on the image while ( !it.IsAtEnd() && (totalSamplesGetVariateWithClosedRange() < trainingProb) { SampleType newSample; newSample.SetSize(sampleSize); // build the sample newSample.Fill(0); for (unsigned int i = 0; iPushBack(newSample); ++totalSamples; ++localNbSamples; } ++it; } index++; // we could break out of the while loop here, once the entire image has been streamed once if (index == numberOfStreamDivisions) index = 0; } } otbAppLogINFO("The final training set contains "<SetListSample(sampleList); EstimatorType::SizeType size; size[0]=GetParameterInt("sx"); size[1]=GetParameterInt("sy"); estimator->SetMapSize(size); EstimatorType::SizeType radius; radius[0] = GetParameterInt("nx"); radius[1] = GetParameterInt("ny"); estimator->SetNeighborhoodSizeInit(radius); estimator->SetNumberOfIterations(GetParameterInt("ni")); estimator->SetBetaInit(GetParameterFloat("bi")); estimator->SetBetaEnd(GetParameterFloat("bf")); estimator->SetMaxWeight(GetParameterFloat("iv")); AddProcess(estimator,"Learning"); estimator->Update(); m_SOMMap = estimator->GetOutput(); if (HasValue("som")) { otbAppLogINFO("-- Using Leaning image --"); SetParameterOutputImage("som", m_SOMMap); } /*******************************************/ /* Classification */ /*******************************************/ otbAppLogINFO("-- CLASSIFICATION --"); m_Classifier->SetInput(input); m_Classifier->SetMap(m_SOMMap); if (m_UseMask) m_Classifier->SetInputMask(mask); AddProcess(m_Classifier,"Classification"); SetParameterOutputImage("out", m_Classifier->GetOutput()); } bool m_UseMask; SOMMapType::Pointer m_SOMMap; ClassificationFilterType::Pointer m_Classifier; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::SOMClassification) OTB-release-5.8/Modules/Applications/AppClassification/app/otbSampleExtraction.cxx000066400000000000000000000135701301006202600303510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbImageSampleExtractorFilter.h" namespace otb { namespace Wrapper { class SampleExtraction : public Application { public: /** Standard class typedefs. */ typedef SampleExtraction Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SampleExtraction, otb::Application); /** Filters typedef */ typedef otb::ImageSampleExtractorFilter FilterType; private: SampleExtraction() {} void DoInit() { SetName("SampleExtraction"); SetDescription("Extracts samples values from an image."); // Documentation SetDocName("Sample Extraction"); SetDocLongDescription("The application extracts samples values from an" "image using positions contained in a vector data file. "); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "InputImage"); SetParameterDescription("in", "Support image"); AddParameter(ParameterType_InputFilename, "vec", "Input sampling positions"); SetParameterDescription("vec","Vector data file containing sampling" "positions. (OGR format)"); AddParameter(ParameterType_OutputFilename, "out", "Output samples"); SetParameterDescription("out","Output vector data file storing sample" "values (OGR format). If not given, the input vector data file is updated"); MandatoryOff("out"); AddParameter(ParameterType_Choice, "outfield", "Output field names"); SetParameterDescription("outfield", "Choice between naming method for output fields"); AddChoice("outfield.prefix","Use a prefix and an incremental counter"); SetParameterDescription("outfield.prefix","Use a prefix and an incremental counter"); AddParameter(ParameterType_String, "outfield.prefix.name", "Output field prefix"); SetParameterDescription("outfield.prefix.name","Prefix used to form the field names that" "will contain the extracted values."); SetParameterString("outfield.prefix.name", "value_"); AddChoice("outfield.list","Use the given name list"); SetParameterDescription("outfield.list","Use the given name list"); AddParameter(ParameterType_StringList, "outfield.list.names", "Output field names"); SetParameterDescription("outfield.list.names","Full list of output field names."); AddParameter(ParameterType_String, "field", "Field Name"); SetParameterDescription("field","Name of the field carrying the class" "name in the input vectors. This field is copied to output."); MandatoryOff("field"); SetParameterString("field", "class"); AddParameter(ParameterType_Int, "layer", "Layer Index"); SetParameterDescription("layer", "Layer index to read in the input vector file."); MandatoryOff("layer"); SetDefaultParameterInt("layer",0); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "support_image.tif"); SetDocExampleParameterValue("vec", "sample_positions.sqlite"); SetDocExampleParameterValue("outfield","prefix"); SetDocExampleParameterValue("outfield.prefix.name","band_"); SetDocExampleParameterValue("field", "label"); SetDocExampleParameterValue("out","sample_values.sqlite"); } void DoUpdateParameters() { // Nothing to do } void DoExecute() { ogr::DataSource::Pointer vectors; ogr::DataSource::Pointer output; if (IsParameterEnabled("out") && HasValue("out")) { vectors = ogr::DataSource::New(this->GetParameterString("vec")); output = ogr::DataSource::New(this->GetParameterString("out"), ogr::DataSource::Modes::Overwrite); } else { // Update mode vectors = ogr::DataSource::New(this->GetParameterString("vec"), ogr::DataSource::Modes::Update_LayerUpdate); output = vectors; } std::vector nameList; std::string namePrefix(""); if (this->GetParameterString("outfield").compare("prefix") == 0) { namePrefix = this->GetParameterString("outfield.prefix.name"); } else if (this->GetParameterString("outfield").compare("list") == 0) { nameList = this->GetParameterStringList("outfield.list.names"); } else { otbAppLogFATAL("Unknown output field option : " << this->GetParameterString("outfield")); } FilterType::Pointer filter = FilterType::New(); filter->SetInput(this->GetParameterImage("in")); filter->SetLayerIndex(this->GetParameterInt("layer")); filter->SetSamplePositions(vectors); filter->SetOutputSamples(output); filter->SetClassFieldName(this->GetParameterString("field")); filter->SetOutputFieldPrefix(namePrefix); filter->SetOutputFieldNames(nameList); filter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(filter->GetStreamer(),"Extracting sample values..."); filter->Update(); output->SyncToDisk(); } }; } // end of namespace Wrapper } // end of namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::SampleExtraction) OTB-release-5.8/Modules/Applications/AppClassification/app/otbSampleSelection.cxx000066400000000000000000000423471301006202600301620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbSamplingRateCalculator.h" #include "otbOGRDataToSamplePositionFilter.h" #include "otbStatisticsXMLFileReader.h" #include "otbRandomSampler.h" #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" namespace otb { namespace Wrapper { class SampleSelection : public Application { public: /** Standard class typedefs. */ typedef SampleSelection Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SampleSelection, otb::Application); /** typedef */ typedef otb::OGRDataToSamplePositionFilter< FloatVectorImageType, UInt8ImageType, otb::PeriodicSampler> PeriodicSamplerType; typedef otb::OGRDataToSamplePositionFilter< FloatVectorImageType, UInt8ImageType, otb::RandomSampler> RandomSamplerType; typedef otb::SamplingRateCalculator RateCalculatorType; typedef std::map ClassCountMapType; typedef RateCalculatorType::MapRateType MapRateType; typedef itk::VariableLengthVector MeasurementType; typedef otb::StatisticsXMLFileReader XMLReaderType; typedef otb::GeometriesSet GeometriesType; typedef otb::GeometriesProjectionFilter ProjectionFilterType; private: SampleSelection() { m_Periodic = PeriodicSamplerType::New(); m_Random = RandomSamplerType::New(); m_ReaderStat = XMLReaderType::New(); m_RateCalculator = RateCalculatorType::New(); } void DoInit() { SetName("SampleSelection"); SetDescription("Selects samples from a training vector data set."); // Documentation SetDocName("Sample Selection"); SetDocLongDescription("The application selects a set of samples from geometries " "intended for training (they should have a field giving the associated " "class). \n\nFirst of all, the geometries must be analyzed by the PolygonClassStatistics application " "to compute statistics about the geometries, which are summarized in an xml file. " "\nThen, this xml file must be given as input to this application (parameter instats).\n\n" "The input support image and the input training vectors shall be given in " "parameters 'in' and 'vec' respectively. Only the sampling grid (origin, size, spacing)" "will be read in the input image.\n" "There are several strategies to select samples (parameter strategy) : \n\n" " - smallest (default) : select the same number of sample in each class" " so that the smallest one is fully sampled.\n" " - constant : select the same number of samples N in each class" " (with N below or equal to the size of the smallest class).\n" " - byclass : set the required number for each class manually, with an input CSV file" " (first column is class name, second one is the required samples number).\n\n" " - percent: set a target global percentage of samples to use. Class proportions will be respected. \n\n" " - total: set a target total number of samples to use. Class proportions will be respected. \n\n" "There is also a choice on the sampling type to performs : \n\n" " - periodic : select samples uniformly distributed\n" " - random : select samples randomly distributed\n\n" "Once the strategy and type are selected, the application outputs samples positions" "(parameter out).\n\n" "The other parameters to look at are : \n\n" " - layer : index specifying from which layer to pick geometries.\n" " - field : set the field name containing the class.\n" " - mask : an optional raster mask can be used to discard samples.\n" " - outrates : allows outputting a CSV file that summarizes the sampling rates for each class.\n" "\nAs with the PolygonClassStatistics application, different types of geometry are supported : " "polygons, lines, points. \nThe behavior of this application is different for each type of geometry : \n\n" " - polygon: select points whose center is inside the polygon\n" " - lines : select points intersecting the line\n" " - points : select closest point to the provided point\n"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Learning); AddParameter(ParameterType_InputImage, "in", "InputImage"); SetParameterDescription("in", "Support image that will be classified"); AddParameter(ParameterType_InputImage, "mask", "InputMask"); SetParameterDescription("mask", "Validity mask (only pixels corresponding to a mask value greater than 0 will be used for statistics)"); MandatoryOff("mask"); AddParameter(ParameterType_InputFilename, "vec", "Input vectors"); SetParameterDescription("vec","Input geometries to analyse"); AddParameter(ParameterType_OutputFilename, "out", "Output vectors"); SetParameterDescription("out","Output resampled geometries"); AddParameter(ParameterType_InputFilename, "instats", "Input Statistics"); SetParameterDescription("instats","Input file storing statistics (XML format)"); AddParameter(ParameterType_OutputFilename, "outrates", "Output rates"); SetParameterDescription("outrates","Output rates (CSV formatted)"); MandatoryOff("outrates"); AddParameter(ParameterType_Choice, "sampler", "Sampler type"); SetParameterDescription("sampler", "Type of sampling (periodic, pattern based, random)"); AddChoice("sampler.periodic","Periodic sampler"); SetParameterDescription("sampler.periodic","Takes samples regularly spaced"); AddParameter(ParameterType_Int, "sampler.periodic.jitter","Jitter amplitude"); SetParameterDescription("sampler.periodic.jitter", "Jitter amplitude added during sample selection (0 = no jitter)"); SetDefaultParameterInt("sampler.periodic.jitter",0); MandatoryOff("sampler.periodic.jitter"); AddChoice("sampler.random","Random sampler"); SetParameterDescription("sampler.random","The positions to select are randomly shuffled."); AddParameter(ParameterType_Choice, "strategy", "Sampling strategy"); AddChoice("strategy.byclass","Set samples count for each class"); SetParameterDescription("strategy.byclass","Set samples count for each class"); AddParameter(ParameterType_InputFilename, "strategy.byclass.in", "Number of samples by class"); SetParameterDescription("strategy.byclass.in", "Number of samples by class " "(CSV format with class name in 1st column and required samples in the 2nd."); AddChoice("strategy.constant","Set the same samples counts for all classes"); SetParameterDescription("strategy.constant","Set the same samples counts for all classes"); AddParameter(ParameterType_Int, "strategy.constant.nb", "Number of samples for all classes"); SetParameterDescription("strategy.constant.nb", "Number of samples for all classes"); AddChoice("strategy.percent","Use a percentage of the samples available for each class"); SetParameterDescription("strategy.percent","Use a percentage of the samples available for each class"); AddParameter(ParameterType_Float,"strategy.percent.p","The percentage to use"); SetParameterDescription("strategy.percent.p","The percentage to use"); SetMinimumParameterFloatValue("strategy.percent.p",0); SetMaximumParameterFloatValue("strategy.percent.p",1); SetDefaultParameterFloat("strategy.percent.p",0.5); AddChoice("strategy.total","Set the total number of samples to generate, and use class proportions."); SetParameterDescription("strategy.total","Set the total number of samples to generate, and use class proportions."); AddParameter(ParameterType_Int,"strategy.total.v","The number of samples to generate"); SetParameterDescription("strategy.total.v","The number of samples to generate"); SetMinimumParameterIntValue("strategy.total.v",1); SetDefaultParameterInt("strategy.total.v",1000); AddChoice("strategy.smallest","Set same number of samples for all classes, with the smallest class fully sampled"); SetParameterDescription("strategy.smallest","Set same number of samples for all classes, with the smallest class fully sampled"); AddChoice("strategy.all","Take all samples"); SetParameterDescription("strategy.all","Take all samples"); // Default strategy : smallest SetParameterString("strategy","smallest"); AddParameter(ParameterType_String, "field", "Field Name"); SetParameterDescription("field","Name of the field carrying the class name in the input vectors."); MandatoryOff("field"); SetParameterString("field", "class"); AddParameter(ParameterType_Int, "layer", "Layer Index"); SetParameterDescription("layer", "Layer index to read in the input vector file."); MandatoryOff("layer"); SetDefaultParameterInt("layer",0); AddRAMParameter(); AddRANDParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "support_image.tif"); SetDocExampleParameterValue("vec", "variousVectors.sqlite"); SetDocExampleParameterValue("field", "label"); SetDocExampleParameterValue("instats","apTvClPolygonClassStatisticsOut.xml"); SetDocExampleParameterValue("out","resampledVectors.sqlite"); } void DoUpdateParameters() { } void DoExecute() { // Clear state m_RateCalculator->ClearRates(); m_Periodic->GetFilter()->ClearOutputs(); m_Random->GetFilter()->ClearOutputs(); // Setup ram m_Periodic->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); m_Random->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); m_ReaderStat->SetFileName(this->GetParameterString("instats")); ClassCountMapType classCount = m_ReaderStat->GetStatisticMapByName("samplesPerClass"); m_RateCalculator->SetClassCount(classCount); switch (this->GetParameterInt("strategy")) { // byclass case 0: { otbAppLogINFO("Sampling strategy : set number of samples for each class"); ClassCountMapType requiredCount = otb::SamplingRateCalculator::ReadRequiredSamples(this->GetParameterString("strategy.byclass.in")); m_RateCalculator->SetNbOfSamplesByClass(requiredCount); } break; // constant case 1: { otbAppLogINFO("Sampling strategy : set a constant number of samples for all classes"); m_RateCalculator->SetNbOfSamplesAllClasses(GetParameterInt("strategy.constant.nb")); } break; // percent case 2: { otbAppLogINFO("Sampling strategy: set a percentage of samples for each class."); m_RateCalculator->SetPercentageOfSamples(this->GetParameterFloat("strategy.percent.p")); } break; // total case 3: { otbAppLogINFO("Sampling strategy: set the total number of samples to generate, use classes proportions."); m_RateCalculator->SetTotalNumberOfSamples(this->GetParameterInt("strategy.total.v")); } break; // smallest class case 4: { otbAppLogINFO("Sampling strategy : fit the number of samples based on the smallest class"); m_RateCalculator->SetMinimumNbOfSamplesByClass(); } break; // all samples case 5: { otbAppLogINFO("Sampling strategy : take all samples"); m_RateCalculator->SetAllSamples(); } break; default: otbAppLogFATAL("Strategy mode unknown :"<GetParameterString("strategy")); break; } if (IsParameterEnabled("outrates") && HasValue("outrates")) { m_RateCalculator->Write(this->GetParameterString("outrates")); } MapRateType rates = m_RateCalculator->GetRatesByClass(); std::ostringstream oss; oss << " className requiredSamples totalSamples rate" << std::endl; MapRateType::const_iterator itRates = rates.begin(); unsigned int overflowCount = 0; for(; itRates != rates.end(); ++itRates) { otb::SamplingRateCalculator::TripletType tpt = itRates->second; oss << itRates->first << "\t" << tpt.Required << "\t" << tpt.Tot << "\t" << tpt.Rate; if (tpt.Required > tpt.Tot) { overflowCount++; oss << "\t[OVERFLOW]"; } oss << std::endl; } otbAppLogINFO("Sampling rates : " << oss.str()); if (overflowCount) { std::string plural(overflowCount>1?"s":""); otbAppLogWARNING(<< overflowCount << " case"<GetParameterString("vec")); // Reproject geometries FloatVectorImageType::Pointer inputImg = this->GetParameterImage("in"); std::string imageProjectionRef = inputImg->GetProjectionRef(); FloatVectorImageType::ImageKeywordlistType imageKwl = inputImg->GetImageKeywordlist(); std::string vectorProjectionRef = vectors->GetLayer(GetParameterInt("layer")).GetProjectionRef(); otb::ogr::DataSource::Pointer reprojVector = vectors; GeometriesType::Pointer inputGeomSet; ProjectionFilterType::Pointer geometriesProjFilter; GeometriesType::Pointer outputGeomSet; bool doReproj = true; // don't reproject for these cases if (vectorProjectionRef.empty() || (imageProjectionRef == vectorProjectionRef) || (imageProjectionRef.empty() && imageKwl.GetSize() == 0)) doReproj = false; if (doReproj) { inputGeomSet = GeometriesType::New(vectors); reprojVector = otb::ogr::DataSource::New(); outputGeomSet = GeometriesType::New(reprojVector); // Filter instantiation geometriesProjFilter = ProjectionFilterType::New(); geometriesProjFilter->SetInput(inputGeomSet); if (imageProjectionRef.empty()) { geometriesProjFilter->SetOutputKeywordList(inputImg->GetImageKeywordlist()); // nec qd capteur } geometriesProjFilter->SetOutputProjectionRef(imageProjectionRef); geometriesProjFilter->SetOutput(outputGeomSet); otbAppLogINFO("Reprojecting input vectors..."); geometriesProjFilter->Update(); } // Create output dataset for sample positions otb::ogr::DataSource::Pointer outputSamples = otb::ogr::DataSource::New(this->GetParameterString("out"),otb::ogr::DataSource::Modes::Overwrite); switch (this->GetParameterInt("sampler")) { // periodic case 0: { PeriodicSamplerType::SamplerParameterType param; param.Offset = 0; param.MaxJitter = this->GetParameterInt("sampler.periodic.jitter"); m_Periodic->SetInput(this->GetParameterImage("in")); m_Periodic->SetOGRData(reprojVector); m_Periodic->SetOutputPositionContainerAndRates(outputSamples, rates); m_Periodic->SetFieldName(this->GetParameterString("field")); m_Periodic->SetLayerIndex(this->GetParameterInt("layer")); m_Periodic->SetSamplerParameters(param); if (IsParameterEnabled("mask") && HasValue("mask")) { m_Periodic->SetMask(this->GetParameterImage("mask")); } m_Periodic->GetStreamer()->SetAutomaticTiledStreaming(this->GetParameterInt("ram")); AddProcess(m_Periodic->GetStreamer(),"Selecting positions with periodic sampler..."); m_Periodic->Update(); } break; // random case 1: { m_Random->SetInput(this->GetParameterImage("in")); m_Random->SetOGRData(reprojVector); m_Random->SetOutputPositionContainerAndRates(outputSamples, rates); m_Random->SetFieldName(this->GetParameterString("field")); m_Random->SetLayerIndex(this->GetParameterInt("layer")); if (IsParameterEnabled("mask") && HasValue("mask")) { m_Random->SetMask(this->GetParameterImage("mask")); } m_Random->GetStreamer()->SetAutomaticTiledStreaming(this->GetParameterInt("ram")); AddProcess(m_Random->GetStreamer(),"Selecting positions with random sampler..."); m_Random->Update(); } break; default: otbAppLogFATAL("Sampler type unknown :"<GetParameterString("sampler")); break; } } RateCalculatorType::Pointer m_RateCalculator; PeriodicSamplerType::Pointer m_Periodic; RandomSamplerType::Pointer m_Random; XMLReaderType::Pointer m_ReaderStat; }; } // end of namespace Wrapper } // end of namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::SampleSelection) OTB-release-5.8/Modules/Applications/AppClassification/app/otbTrainImagesClassifier.cxx000066400000000000000000000605701301006202600313010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLearningApplicationBase.h" #include "otbWrapperApplicationFactory.h" #include "otbListSampleGenerator.h" // Statistic XML Reader #include "otbStatisticsXMLFileReader.h" // Validation #include "otbConfusionMatrixCalculator.h" #include "itkTimeProbe.h" #include "otbStandardFilterWatcher.h" // Normalize the samples #include "otbShiftScaleSampleListFilter.h" // List sample concatenation #include "otbConcatenateSampleListFilter.h" // Balancing ListSample #include "otbListSampleToBalancedListSampleFilter.h" // VectorData projection filter // Extract a ROI of the vectordata #include "otbVectorDataIntoImageProjectionFilter.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class TrainImagesClassifier: public LearningApplicationBase { public: /** Standard class typedefs. */ typedef TrainImagesClassifier Self; typedef LearningApplicationBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self) itkTypeMacro(TrainImagesClassifier, otb::Wrapper::LearningApplicationBase) typedef Superclass::SampleType SampleType; typedef Superclass::ListSampleType ListSampleType; typedef Superclass::TargetSampleType TargetSampleType; typedef Superclass::TargetListSampleType TargetListSampleType; typedef Superclass::SampleImageType SampleImageType; typedef SampleImageType::PixelType PixelType; // SampleList manipulation typedef otb::ListSampleGenerator ListSampleGeneratorType; typedef otb::Statistics::ConcatenateSampleListFilter ConcatenateListSampleFilterType; typedef otb::Statistics::ConcatenateSampleListFilter ConcatenateLabelListSampleFilterType; // Statistic XML file Reader typedef otb::StatisticsXMLFileReader StatisticsReader; // Enhance List Sample typedef otb::Statistics::ListSampleToBalancedListSampleFilter BalancingListSampleFilterType; typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleFilterType; // Estimate performance on validation sample typedef otb::ConfusionMatrixCalculator ConfusionMatrixCalculatorType; typedef ConfusionMatrixCalculatorType::ConfusionMatrixType ConfusionMatrixType; typedef ConfusionMatrixCalculatorType::MapOfIndicesType MapOfIndicesType; typedef ConfusionMatrixCalculatorType::ClassLabelType ClassLabelType; // VectorData projection filter typedef otb::VectorDataProjectionFilter VectorDataProjectionFilterType; // Extract ROI typedef otb::VectorDataIntoImageProjectionFilter VectorDataReprojectionType; protected: //using Superclass::AddParameter; //friend void InitSVMParams(TrainImagesClassifier & app); private: void DoInit() ITK_OVERRIDE { SetName("TrainImagesClassifier"); SetDescription( "Train a classifier from multiple pairs of images and training vector data."); // Documentation SetDocName("Train a classifier from multiple images"); SetDocLongDescription( "This application performs a classifier training from multiple pairs of input images and training vector data. " "Samples are composed of pixel values in each band optionally centered and reduced using an XML statistics file produced by " "the ComputeImagesStatistics application.\n The training vector data must contain polygons with a positive integer field " "representing the class label. The name of this field can be set using the \"Class label field\" parameter. Training and validation " "sample lists are built such that each class is equally represented in both lists. One parameter allows controlling the ratio " "between the number of samples in training and validation sets. Two parameters allow managing the size of the training and " "validation sets per class and per image.\n Several classifier parameters can be set depending on the chosen classifier. In the " "validation process, the confusion matrix is organized the following way: rows = reference labels, columns = produced labels. " "In the header of the optional confusion matrix output file, the validation (reference) and predicted (produced) class labels" " are ordered according to the rows/columns of the confusion matrix.\n This application is based on LibSVM and OpenCV Machine Learning " "(2.3.1 and later)."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("OpenCV documentation for machine learning http://docs.opencv.org/modules/ml/doc/ml.html "); //Group IO AddParameter(ParameterType_Group, "io", "Input and output data"); SetParameterDescription("io", "This group of parameters allows setting input and output data."); AddParameter(ParameterType_InputImageList, "io.il", "Input Image List"); SetParameterDescription("io.il", "A list of input images."); AddParameter(ParameterType_InputVectorDataList, "io.vd", "Input Vector Data List"); SetParameterDescription("io.vd", "A list of vector data to select the training samples."); AddParameter(ParameterType_InputFilename, "io.imstat", "Input XML image statistics file"); MandatoryOff("io.imstat"); SetParameterDescription("io.imstat", "Input XML file containing the mean and the standard deviation of the input images."); AddParameter(ParameterType_OutputFilename, "io.confmatout", "Output confusion matrix"); SetParameterDescription("io.confmatout", "Output file containing the confusion matrix (.csv format)."); MandatoryOff("io.confmatout"); AddParameter(ParameterType_OutputFilename, "io.out", "Output model"); SetParameterDescription("io.out", "Output file containing the model estimated (.txt format)."); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); //Group Sample list AddParameter(ParameterType_Group, "sample", "Training and validation samples parameters"); SetParameterDescription("sample", "This group of parameters allows you to set training and validation sample lists parameters."); AddParameter(ParameterType_Int, "sample.mt", "Maximum training sample size per class"); //MandatoryOff("mt"); SetDefaultParameterInt("sample.mt", 1000); SetParameterDescription("sample.mt", "Maximum size per class (in pixels) of the training sample list (default = 1000) (no limit = -1). If equal to -1, then the maximal size of the available training sample list per class will be equal to the surface area of the smallest class multiplied by the training sample ratio."); AddParameter(ParameterType_Int, "sample.mv", "Maximum validation sample size per class"); // MandatoryOff("mv"); SetDefaultParameterInt("sample.mv", 1000); SetParameterDescription("sample.mv", "Maximum size per class (in pixels) of the validation sample list (default = 1000) (no limit = -1). If equal to -1, then the maximal size of the available validation sample list per class will be equal to the surface area of the smallest class multiplied by the validation sample ratio."); AddParameter(ParameterType_Int, "sample.bm", "Bound sample number by minimum"); SetDefaultParameterInt("sample.bm", 1); SetParameterDescription("sample.bm", "Bound the number of samples for each class by the number of available samples by the smaller class. Proportions between training and validation are respected. Default is true (=1)."); AddParameter(ParameterType_Empty, "sample.edg", "On edge pixel inclusion"); SetParameterDescription("sample.edg", "Takes pixels on polygon edge into consideration when building training and validation samples."); MandatoryOff("sample.edg"); AddParameter(ParameterType_Float, "sample.vtr", "Training and validation sample ratio"); SetParameterDescription("sample.vtr", "Ratio between training and validation samples (0.0 = all training, 1.0 = all validation) (default = 0.5)."); SetParameterFloat("sample.vtr", 0.5); AddParameter(ParameterType_String, "sample.vfn", "Name of the discrimination field"); SetParameterDescription("sample.vfn", "Name of the field used to discriminate class labels in the input vector data files."); SetParameterString("sample.vfn", "Class"); Superclass::DoInit(); AddRANDParameter(); // Doc example parameter settings SetDocExampleParameterValue("io.il", "QB_1_ortho.tif"); SetDocExampleParameterValue("io.vd", "VectorData_QB1.shp"); SetDocExampleParameterValue("io.imstat", "EstimateImageStatisticsQB1.xml"); SetDocExampleParameterValue("sample.mv", "100"); SetDocExampleParameterValue("sample.mt", "100"); SetDocExampleParameterValue("sample.vtr", "0.5"); SetDocExampleParameterValue("sample.edg", "false"); SetDocExampleParameterValue("sample.vfn", "Class"); SetDocExampleParameterValue("classifier", "libsvm"); SetDocExampleParameterValue("classifier.libsvm.k", "linear"); SetDocExampleParameterValue("classifier.libsvm.c", "1"); SetDocExampleParameterValue("classifier.libsvm.opt", "false"); SetDocExampleParameterValue("io.out", "svmModelQB1.txt"); SetDocExampleParameterValue("io.confmatout", "svmConfusionMatrixQB1.csv"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void LogConfusionMatrix(ConfusionMatrixCalculatorType* confMatCalc) { ConfusionMatrixCalculatorType::ConfusionMatrixType matrix = confMatCalc->GetConfusionMatrix(); // Compute minimal width size_t minwidth = 0; for (unsigned int i = 0; i < matrix.Rows(); i++) { for (unsigned int j = 0; j < matrix.Cols(); j++) { std::ostringstream os; os << matrix(i, j); size_t size = os.str().size(); if (size > minwidth) { minwidth = size; } } } MapOfIndicesType mapOfIndices = confMatCalc->GetMapOfIndices(); MapOfIndicesType::const_iterator it = mapOfIndices.begin(); MapOfIndicesType::const_iterator end = mapOfIndices.end(); for (; it != end; ++it) { std::ostringstream os; os << "[" << it->second << "]"; size_t size = os.str().size(); if (size > minwidth) { minwidth = size; } } // Generate matrix string, with 'minwidth' as size specifier std::ostringstream os; // Header line for (size_t i = 0; i < minwidth; ++i) os << " "; os << " "; it = mapOfIndices.begin(); end = mapOfIndices.end(); for (; it != end; ++it) { os << "[" << it->second << "]" << " "; } os << std::endl; // Each line of confusion matrix for (unsigned int i = 0; i < matrix.Rows(); i++) { ConfusionMatrixCalculatorType::ClassLabelType label = mapOfIndices[i]; os << "[" << std::setw(minwidth - 2) << label << "]" << " "; for (unsigned int j = 0; j < matrix.Cols(); j++) { os << std::setw(minwidth) << matrix(i, j) << " "; } os << std::endl; } otbAppLogINFO("Confusion matrix (rows = reference labels, columns = produced labels):\n" << os.str()); } void DoExecute() ITK_OVERRIDE { //Create training and validation for list samples and label list samples ConcatenateLabelListSampleFilterType::Pointer concatenateTrainingLabels = ConcatenateLabelListSampleFilterType::New(); ConcatenateListSampleFilterType::Pointer concatenateTrainingSamples = ConcatenateListSampleFilterType::New(); ConcatenateLabelListSampleFilterType::Pointer concatenateValidationLabels = ConcatenateLabelListSampleFilterType::New(); ConcatenateListSampleFilterType::Pointer concatenateValidationSamples = ConcatenateListSampleFilterType::New(); SampleType meanMeasurementVector; SampleType stddevMeasurementVector; // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this, "elev"); //-------------------------- // Load measurements from images unsigned int nbBands = 0; //Iterate over all input images FloatVectorImageListType* imageList = GetParameterImageList("io.il"); VectorDataListType* vectorDataList = GetParameterVectorDataList("io.vd"); vdreproj = VectorDataReprojectionType::New(); //Iterate over all input images for (unsigned int imgIndex = 0; imgIndex < imageList->Size(); ++imgIndex) { std::ostringstream oss1, oss2; oss1 << "Reproject polygons for image " << (imgIndex+1) << " ..."; oss2 << "Extract samples from image " << (imgIndex+1) << " ..."; FloatVectorImageType::Pointer image = imageList->GetNthElement(imgIndex); image->UpdateOutputInformation(); if (imgIndex == 0) { nbBands = image->GetNumberOfComponentsPerPixel(); } // read the Vectordata vdreproj->SetInputImage(image); vdreproj->SetInput(vectorDataList->GetNthElement(imgIndex)); vdreproj->SetUseOutputSpacingAndOriginFromImage(false); AddProcess(vdreproj, oss1.str()); vdreproj->Update(); //Sample list generator ListSampleGeneratorType::Pointer sampleGenerator = ListSampleGeneratorType::New(); sampleGenerator->SetInput(image); sampleGenerator->SetInputVectorData(vdreproj->GetOutput()); sampleGenerator->SetClassKey(GetParameterString("sample.vfn")); sampleGenerator->SetMaxTrainingSize(GetParameterInt("sample.mt")); sampleGenerator->SetMaxValidationSize(GetParameterInt("sample.mv")); sampleGenerator->SetValidationTrainingProportion(GetParameterFloat("sample.vtr")); sampleGenerator->SetBoundByMin(GetParameterInt("sample.bm")!=0); // take pixel located on polygon edge into consideration if (IsParameterEnabled("sample.edg")) { sampleGenerator->SetPolygonEdgeInclusion(true); } AddProcess(sampleGenerator, oss2.str()); sampleGenerator->Update(); TargetListSampleType::Pointer trainLabels = sampleGenerator->GetTrainingListLabel(); ListSampleType::Pointer trainSamples = sampleGenerator->GetTrainingListSample(); TargetListSampleType::Pointer validLabels = sampleGenerator->GetValidationListLabel(); ListSampleType::Pointer validSamples = sampleGenerator->GetValidationListSample(); trainLabels->DisconnectPipeline(); trainSamples->DisconnectPipeline(); validLabels->DisconnectPipeline(); validSamples->DisconnectPipeline(); //Concatenate training and validation samples from the image concatenateTrainingLabels->AddInput(trainLabels); concatenateTrainingSamples->AddInput(trainSamples); concatenateValidationLabels->AddInput(validLabels); concatenateValidationSamples->AddInput(validSamples); } // Update AddProcess(concatenateValidationLabels, "Concatenate samples ..."); concatenateTrainingSamples->Update(); concatenateTrainingLabels->Update(); concatenateValidationSamples->Update(); concatenateValidationLabels->Update(); if (concatenateTrainingSamples->GetOutput()->Size() == 0) { otbAppLogFATAL("No training samples, cannot perform SVM training."); } if (concatenateValidationSamples->GetOutput()->Size() == 0) { otbAppLogWARNING("No validation samples."); } if (IsParameterEnabled("io.imstat")) { StatisticsReader::Pointer statisticsReader = StatisticsReader::New(); statisticsReader->SetFileName(GetParameterString("io.imstat")); meanMeasurementVector = statisticsReader->GetStatisticVectorByName("mean"); stddevMeasurementVector = statisticsReader->GetStatisticVectorByName("stddev"); } else { meanMeasurementVector.SetSize(nbBands); meanMeasurementVector.Fill(0.); stddevMeasurementVector.SetSize(nbBands); stddevMeasurementVector.Fill(1.); } // Shift scale the samples ShiftScaleFilterType::Pointer trainingShiftScaleFilter = ShiftScaleFilterType::New(); trainingShiftScaleFilter->SetInput(concatenateTrainingSamples->GetOutput()); trainingShiftScaleFilter->SetShifts(meanMeasurementVector); trainingShiftScaleFilter->SetScales(stddevMeasurementVector); AddProcess(trainingShiftScaleFilter, "Normalize training samples ..."); trainingShiftScaleFilter->Update(); ListSampleType::Pointer validationListSample=ListSampleType::New(); //Test if the validation test is empty if ( concatenateValidationSamples->GetOutput()->Size() != 0 ) { ShiftScaleFilterType::Pointer validationShiftScaleFilter = ShiftScaleFilterType::New(); validationShiftScaleFilter->SetInput(concatenateValidationSamples->GetOutput()); validationShiftScaleFilter->SetShifts(meanMeasurementVector); validationShiftScaleFilter->SetScales(stddevMeasurementVector); AddProcess(validationShiftScaleFilter, "Normalize validation samples ..."); validationShiftScaleFilter->Update(); validationListSample = validationShiftScaleFilter->GetOutput(); } ListSampleType::Pointer listSample; TargetListSampleType::Pointer labelListSample; //-------------------------- // Balancing training sample (if needed) // if (IsParameterEnabled("sample.b")) // { // // Balance the list sample. // otbAppLogINFO("Number of training samples before balancing: " << concatenateTrainingSamples->GetOutput()->Size()) // BalancingListSampleFilterType::Pointer balancingFilter = BalancingListSampleFilterType::New(); // balancingFilter->SetInput(trainingShiftScaleFilter->GetOutput()); // balancingFilter->SetInputLabel(concatenateTrainingLabels->GetOutput()); // balancingFilter->SetBalancingFactor(GetParameterInt("sample.b")); // balancingFilter->Update(); // listSample = balancingFilter->GetOutput(); // labelListSample = balancingFilter->GetOutputLabelSampleList(); // otbAppLogINFO("Number of samples after balancing: " << balancingFilter->GetOutput()->Size()); // } // else // { listSample = trainingShiftScaleFilter->GetOutput(); labelListSample = concatenateTrainingLabels->GetOutput(); otbAppLogINFO("Number of training samples: " << concatenateTrainingSamples->GetOutput()->Size()); // } //-------------------------- // Split the data set into training/validation set ListSampleType::Pointer trainingListSample = listSample; TargetListSampleType::Pointer trainingLabeledListSample = labelListSample; TargetListSampleType::Pointer validationLabeledListSample = concatenateValidationLabels->GetOutput(); otbAppLogINFO("Size of training set: " << trainingListSample->Size()); otbAppLogINFO("Size of validation set: " << validationListSample->Size()); otbAppLogINFO("Size of labeled training set: " << trainingLabeledListSample->Size()); otbAppLogINFO("Size of labeled validation set: " << validationLabeledListSample->Size()); //-------------------------- // Estimate model //-------------------------- this->Train(trainingListSample,trainingLabeledListSample,GetParameterString("io.out")); //-------------------------- // Performances estimation //-------------------------- TargetListSampleType::Pointer predictedList = TargetListSampleType::New(); ListSampleType::Pointer performanceListSample=ListSampleType::New(); TargetListSampleType::Pointer performanceLabeledListSample=TargetListSampleType::New(); //Test the input validation set size if(validationLabeledListSample->Size() != 0) { performanceListSample = validationListSample; performanceLabeledListSample = validationLabeledListSample; } else { otbAppLogWARNING("The validation set is empty. The performance estimation is done using the input training set in this case."); performanceListSample = trainingListSample; performanceLabeledListSample = trainingLabeledListSample; } this->Classify(performanceListSample, predictedList, GetParameterString("io.out")); ConfusionMatrixCalculatorType::Pointer confMatCalc = ConfusionMatrixCalculatorType::New(); otbAppLogINFO("Predicted list size : " << predictedList->Size()); otbAppLogINFO("ValidationLabeledListSample size : " << performanceLabeledListSample->Size()); confMatCalc->SetReferenceLabels(performanceLabeledListSample); confMatCalc->SetProducedLabels(predictedList); confMatCalc->Compute(); otbAppLogINFO("training performances"); LogConfusionMatrix(confMatCalc); for (unsigned int itClasses = 0; itClasses < confMatCalc->GetNumberOfClasses(); itClasses++) { ConfusionMatrixCalculatorType::ClassLabelType classLabel = confMatCalc->GetMapOfIndices()[itClasses]; otbAppLogINFO("Precision of class [" << classLabel << "] vs all: " << confMatCalc->GetPrecisions()[itClasses]); otbAppLogINFO("Recall of class [" << classLabel << "] vs all: " << confMatCalc->GetRecalls()[itClasses]); otbAppLogINFO( "F-score of class [" << classLabel << "] vs all: " << confMatCalc->GetFScores()[itClasses] << "\n"); } otbAppLogINFO("Global performance, Kappa index: " << confMatCalc->GetKappaIndex()); if (this->HasValue("io.confmatout")) { // Writing the confusion matrix in the output .CSV file MapOfIndicesType::iterator itMapOfIndicesValid, itMapOfIndicesPred; ClassLabelType labelValid = 0; ConfusionMatrixType confusionMatrix = confMatCalc->GetConfusionMatrix(); MapOfIndicesType mapOfIndicesValid = confMatCalc->GetMapOfIndices(); unsigned int nbClassesPred = mapOfIndicesValid.size(); ///////////////////////////////////////////// // Filling the 2 headers for the output file const std::string commentValidStr = "#Reference labels (rows):"; const std::string commentPredStr = "#Produced labels (columns):"; const char separatorChar = ','; std::ostringstream ossHeaderValidLabels, ossHeaderPredLabels; // Filling ossHeaderValidLabels and ossHeaderPredLabels for the output file ossHeaderValidLabels << commentValidStr; ossHeaderPredLabels << commentPredStr; itMapOfIndicesValid = mapOfIndicesValid.begin(); while (itMapOfIndicesValid != mapOfIndicesValid.end()) { // labels labelValid of mapOfIndicesValid are already sorted in otbConfusionMatrixCalculator labelValid = itMapOfIndicesValid->second; otbAppLogINFO("mapOfIndicesValid[" << itMapOfIndicesValid->first << "] = " << labelValid); ossHeaderValidLabels << labelValid; ossHeaderPredLabels << labelValid; ++itMapOfIndicesValid; if (itMapOfIndicesValid != mapOfIndicesValid.end()) { ossHeaderValidLabels << separatorChar; ossHeaderPredLabels << separatorChar; } else { ossHeaderValidLabels << std::endl; ossHeaderPredLabels << std::endl; } } std::ofstream outFile; outFile.open(this->GetParameterString("io.confmatout").c_str()); outFile << std::fixed; outFile.precision(10); ///////////////////////////////////// // Writing the 2 headers outFile << ossHeaderValidLabels.str(); outFile << ossHeaderPredLabels.str(); ///////////////////////////////////// unsigned int indexLabelValid = 0, indexLabelPred = 0; for (itMapOfIndicesValid = mapOfIndicesValid.begin(); itMapOfIndicesValid != mapOfIndicesValid.end(); ++itMapOfIndicesValid) { indexLabelPred = 0; for (itMapOfIndicesPred = mapOfIndicesValid.begin(); itMapOfIndicesPred != mapOfIndicesValid.end(); ++itMapOfIndicesPred) { // Writing the confusion matrix (sorted in otbConfusionMatrixCalculator) in the output file outFile << confusionMatrix(indexLabelValid, indexLabelPred); if (indexLabelPred < (nbClassesPred - 1)) { outFile << separatorChar; } else { outFile << std::endl; } ++indexLabelPred; } ++indexLabelValid; } outFile.close(); } // END if (this->HasValue("io.confmatout")) // TODO: implement hyperplane distance classifier and performance validation (cf. object detection) ? } VectorDataReprojectionType::Pointer vdreproj; }; } // end namespace Wrapper } // end namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::TrainImagesClassifier) OTB-release-5.8/Modules/Applications/AppClassification/app/otbTrainOGRLayersClassifier.cxx000066400000000000000000000202551301006202600316770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbOGRDataSourceWrapper.h" #include "otbOGRFeatureWrapper.h" #include "otbStatisticsXMLFileWriter.h" #include "itkVariableLengthVector.h" #include "otbStatisticsXMLFileReader.h" #include "itkListSample.h" #include "otbShiftScaleSampleListFilter.h" #ifdef OTB_USE_LIBSVM #include "otbLibSVMMachineLearningModel.h" #endif #include namespace otb { namespace Wrapper { class TrainOGRLayersClassifier : public Application { public: typedef TrainOGRLayersClassifier Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self) ; itkTypeMacro(TrainOGRLayersClassifier, otb::Application) ; private: void DoInit() ITK_OVERRIDE { SetName("TrainOGRLayersClassifier"); SetDescription("Train a SVM classifier based on labeled geometries and a list of features to consider."); SetDocName("TrainOGRLayersClassifier (DEPRECATED)"); SetDocLongDescription("This application trains a SVM classifier based on " "labeled geometries and a list of features to consider for classification." " This application is deprecated, prefer using TrainVectorClassifier which" " offers access to all the classifiers."); SetDocLimitations("Experimental. For now only shapefiles are supported. Tuning of SVM classifier is not available."); SetDocAuthors("David Youssefi during internship at CNES"); SetDocSeeAlso("OGRLayerClassifier,ComputeOGRLayersFeaturesStatistics"); AddDocTag(Tags::Segmentation); AddParameter(ParameterType_InputVectorData, "inshp", "Name of the input shapefile"); SetParameterDescription("inshp","Name of the input shapefile"); AddParameter(ParameterType_InputFilename, "instats", "XML file containing mean and variance of each feature."); SetParameterDescription("instats", "XML file containing mean and variance of each feature."); AddParameter(ParameterType_OutputFilename, "outsvm", "Output model filename."); SetParameterDescription("outsvm", "Output model filename."); AddParameter(ParameterType_ListView, "feat", "List of features to consider for classification."); SetParameterDescription("feat","List of features to consider for classification."); AddParameter(ParameterType_String,"cfield","Field containing the class id for supervision"); SetParameterDescription("cfield","Field containing the class id for supervision. Only geometries with this field available will be taken into account."); SetParameterString("cfield","class"); // Doc example parameter settings SetDocExampleParameterValue("inshp", "vectorData.shp"); SetDocExampleParameterValue("instats", "meanVar.xml"); SetDocExampleParameterValue("outsvm", "svmModel.svm"); SetDocExampleParameterValue("feat", "perimeter"); SetDocExampleParameterValue("cfield", "predicted"); } void DoUpdateParameters() ITK_OVERRIDE { if ( HasValue("inshp") ) { std::string shapefile = GetParameterString("inshp"); otb::ogr::DataSource::Pointer ogrDS; otb::ogr::Layer layer(ITK_NULLPTR, false); OGRSpatialReference oSRS(""); std::vector options; ogrDS = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Read); std::string layername = itksys::SystemTools::GetFilenameName(shapefile); layername = layername.substr(0,layername.size()-4); layer = ogrDS->GetLayer(0); otb::ogr::Feature feature = layer.ogr().GetNextFeature(); ClearChoices("feat"); for(int iField=0; iFieldGetNameRef(); key = item; key.erase(std::remove(key.begin(), key.end(), ' '), key.end()); std::transform(key.begin(), key.end(), key.begin(), tolower); key="feat."+key; AddChoice(key,item); } } } void DoExecute() ITK_OVERRIDE { #ifdef OTB_USE_LIBSVM clock_t tic = clock(); std::string shapefile = GetParameterString("inshp"); std::string XMLfile = GetParameterString("instats"); std::string modelfile = GetParameterString("outsvm"); typedef double ValueType; typedef itk::VariableLengthVector MeasurementType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::StatisticsXMLFileReader StatisticsReader; typedef unsigned int LabelPixelType; typedef itk::FixedArray LabelSampleType; typedef itk::Statistics::ListSample LabelListSampleType; typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleFilterType; StatisticsReader::Pointer statisticsReader = StatisticsReader::New(); statisticsReader->SetFileName(XMLfile); MeasurementType meanMeasurementVector = statisticsReader->GetStatisticVectorByName("mean"); MeasurementType stddevMeasurementVector = statisticsReader->GetStatisticVectorByName("stddev"); otb::ogr::DataSource::Pointer source = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Read); otb::ogr::Layer layer = source->GetLayer(0); bool goesOn = true; otb::ogr::Feature feature = layer.ogr().GetNextFeature(); ListSampleType::Pointer input = ListSampleType::New(); LabelListSampleType::Pointer target = LabelListSampleType::New(); const int nbFeatures = GetSelectedItems("feat").size(); input->SetMeasurementVectorSize(nbFeatures); if(feature.addr()) while(goesOn) { if(feature.ogr().IsFieldSet(feature.ogr().GetFieldIndex(GetParameterString("cfield").c_str()))) { MeasurementType mv; mv.SetSize(nbFeatures); for(int idx=0; idx < nbFeatures; ++idx) mv[idx] = feature.ogr().GetFieldAsDouble(GetSelectedItems("feat")[idx]); input->PushBack(mv); target->PushBack(feature.ogr().GetFieldAsInteger(GetParameterString("cfield").c_str())); } feature = layer.ogr().GetNextFeature(); goesOn = feature.addr() != ITK_NULLPTR; } ShiftScaleFilterType::Pointer trainingShiftScaleFilter = ShiftScaleFilterType::New(); trainingShiftScaleFilter->SetInput(input); trainingShiftScaleFilter->SetShifts(meanMeasurementVector); trainingShiftScaleFilter->SetScales(stddevMeasurementVector); trainingShiftScaleFilter->Update(); ListSampleType::Pointer listSample; LabelListSampleType::Pointer labelListSample; listSample = trainingShiftScaleFilter->GetOutput(); labelListSample = target; ListSampleType::Pointer trainingListSample = listSample; LabelListSampleType::Pointer trainingLabeledListSample = labelListSample; typedef otb::LibSVMMachineLearningModel LibSVMType; LibSVMType::Pointer libSVMClassifier = LibSVMType::New(); libSVMClassifier->SetInputListSample(trainingListSample); libSVMClassifier->SetTargetListSample(trainingLabeledListSample); libSVMClassifier->SetParameterOptimization(true); libSVMClassifier->SetC(1.0); libSVMClassifier->SetKernelType(LINEAR); libSVMClassifier->Train(); libSVMClassifier->Save(modelfile); clock_t toc = clock(); otbAppLogINFO( "Elapsed: "<< ((double)(toc - tic) / CLOCKS_PER_SEC)<<" seconds."); #else otbAppLogFATAL("Module LIBSVM is not installed. You should consider turning OTB_USE_LIBSVM on during cmake configuration."); #endif } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::TrainOGRLayersClassifier) OTB-release-5.8/Modules/Applications/AppClassification/app/otbTrainRegression.cxx000066400000000000000000000510251301006202600302020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLearningApplicationBase.h" #include "otbWrapperApplicationFactory.h" #include "otbListSampleGenerator.h" #include "otbImageToEnvelopeVectorDataFilter.h" #include "itkPreOrderTreeIterator.h" // Statistic XML Reader #include "otbStatisticsXMLFileReader.h" #include "itkTimeProbe.h" #include "otbStandardFilterWatcher.h" // Normalize the samples #include "otbShiftScaleSampleListFilter.h" // List sample concatenation #include "otbConcatenateSampleListFilter.h" // Balancing ListSample #include "otbListSampleToBalancedListSampleFilter.h" #include "itkMersenneTwisterRandomVariateGenerator.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class TrainRegression: public LearningApplicationBase { public: /** Standard class typedefs. */ typedef TrainRegression Self; typedef LearningApplicationBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self) itkTypeMacro(TrainRegression, otb::Wrapper::LearningApplicationBase) typedef Superclass::SampleType SampleType; typedef Superclass::ListSampleType ListSampleType; typedef Superclass::TargetSampleType TargetSampleType; typedef Superclass::TargetListSampleType TargetListSampleType; typedef Superclass::SampleImageType SampleImageType; typedef SampleImageType::PixelType PixelType; // SampleList manipulation typedef otb::ListSampleGenerator ListSampleGeneratorType; typedef otb::Statistics::ConcatenateSampleListFilter ConcatenateListSampleFilterType; typedef otb::Statistics::ConcatenateSampleListFilter ConcatenateLabelListSampleFilterType; // Statistic XML file Reader typedef otb::StatisticsXMLFileReader StatisticsReader; // Enhance List Sample typedef otb::Statistics::ListSampleToBalancedListSampleFilter BalancingListSampleFilterType; typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleFilterType; typedef otb::ImageToEnvelopeVectorDataFilter EnvelopeFilterType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; protected: TrainRegression() { this->m_RegressionFlag = true; } private: void DoInit() ITK_OVERRIDE { SetName("TrainRegression"); SetDescription( "Train a classifier from multiple images to perform regression."); // Documentation SetDocName("Train a regression model"); SetDocLongDescription( "This application trains a classifier from multiple input images or a csv " "file, in order to perform regression. Predictors are composed of pixel " "values in each band optionally centered and reduced using an XML " "statistics file produced by the ComputeImagesStatistics application.\n " "The output value for each predictor is assumed to be the last band " "(or the last column for CSV files). Training and validation predictor " "lists are built such that their size is inferior to maximum bounds given " "by the user, and the proportion corresponds to the balance parameter. " "Several classifier parameters can be set depending on the chosen " "classifier. In the validation process, the mean square error is computed\n" " This application is based on LibSVM and on OpenCV Machine Learning " "classifiers, and is compatible with OpenCV 2.3.1 and later."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("OpenCV documentation for machine learning http://docs.opencv.org/modules/ml/doc/ml.html "); //Group IO AddParameter(ParameterType_Group, "io", "Input and output data"); SetParameterDescription("io", "This group of parameters allows setting input and output data."); AddParameter(ParameterType_InputImageList, "io.il", "Input Image List"); SetParameterDescription("io.il", "A list of input images. First (n-1) bands should contain the predictor. The last band should contain the output value to predict."); AddParameter(ParameterType_InputFilename, "io.csv", "Input CSV file"); SetParameterDescription("io.csv","Input CSV file containing the predictors, and the output values in last column. Only used when no input image is given"); MandatoryOff("io.csv"); AddParameter(ParameterType_InputFilename, "io.imstat", "Input XML image statistics file"); MandatoryOff("io.imstat"); SetParameterDescription("io.imstat", "Input XML file containing the mean and the standard deviation of the input images."); AddParameter(ParameterType_OutputFilename, "io.out", "Output regression model"); SetParameterDescription("io.out", "Output file containing the model estimated (.txt format)."); AddParameter(ParameterType_Float,"io.mse","Mean Square Error"); SetParameterDescription("io.mse","Mean square error computed with the validation predictors"); SetParameterRole("io.mse",Role_Output); DisableParameter("io.mse"); //Group Sample list AddParameter(ParameterType_Group, "sample", "Training and validation samples parameters"); SetParameterDescription("sample", "This group of parameters allows you to set training and validation sample lists parameters."); AddParameter(ParameterType_Int, "sample.mt", "Maximum training predictors"); //MandatoryOff("mt"); SetDefaultParameterInt("sample.mt", 1000); SetParameterDescription("sample.mt", "Maximum number of training predictors (default = 1000) (no limit = -1)."); AddParameter(ParameterType_Int, "sample.mv", "Maximum validation predictors"); // MandatoryOff("mv"); SetDefaultParameterInt("sample.mv", 1000); SetParameterDescription("sample.mv", "Maximum number of validation predictors (default = 1000) (no limit = -1)."); AddParameter(ParameterType_Float, "sample.vtr", "Training and validation sample ratio"); SetParameterDescription("sample.vtr", "Ratio between training and validation samples (0.0 = all training, 1.0 = all validation) (default = 0.5)."); SetParameterFloat("sample.vtr", 0.5); Superclass::DoInit(); AddRANDParameter(); // Doc example parameter settings SetDocExampleParameterValue("io.il", "training_dataset.tif"); SetDocExampleParameterValue("io.out", "regression_model.txt"); SetDocExampleParameterValue("io.imstat", "training_statistics.xml"); SetDocExampleParameterValue("classifier", "libsvm"); } void DoUpdateParameters() ITK_OVERRIDE { if (HasValue("io.csv") && IsParameterEnabled("io.csv")) { MandatoryOff("io.il"); } else { MandatoryOn("io.il"); } } void ParseCSVPredictors(std::string path, ListSampleType* outputList) { std::ifstream ifs; ifs.open(path.c_str()); unsigned int nbCols = 0; char sep = '\t'; std::istringstream iss; SampleType elem; while(!ifs.eof()) { std::string line; std::getline(ifs,line); // filter current line while (!line.empty() && (line[0] == ' ' || line[0] == '\t')) { line.erase(line.begin()); } while (!line.empty() && ( *(line.end()-1) == ' ' || *(line.end()-1) == '\t' || *(line.end()-1) == '\r')) { line.erase(line.end()-1); } // Avoid commented lines or too short ones if (!line.empty() && line[0] != '#') { std::vector words = itksys::SystemTools::SplitString(line.c_str(),sep); if (nbCols == 0) { // detect separator and feature size if (words.size() < 2) { sep = ' '; words = itksys::SystemTools::SplitString(line.c_str(),sep); } if (words.size() < 2) { sep = ';'; words = itksys::SystemTools::SplitString(line.c_str(),sep); } if (words.size() < 2) { sep = ','; words = itksys::SystemTools::SplitString(line.c_str(),sep); } if (words.size() < 2) { otbAppLogFATAL(<< "Can't parse CSV file : less than 2 columns or invalid separator (valid separators are tab, space, comma and semi-colon)"); } nbCols = words.size(); elem.SetSize(nbCols,false); outputList->SetMeasurementVectorSize(nbCols); } else if (words.size() != nbCols ) { otbAppLogWARNING(<< "Skip CSV line, wrong number of columns : got "<> elem[i]; } outputList->PushBack(elem); } } ifs.close(); } void DoExecute() ITK_OVERRIDE { GetLogger()->Debug("Entering DoExecute\n"); //Create training and validation for list samples and label list samples ConcatenateListSampleFilterType::Pointer concatenateTrainingSamples = ConcatenateListSampleFilterType::New(); ConcatenateListSampleFilterType::Pointer concatenateValidationSamples = ConcatenateListSampleFilterType::New(); SampleType meanMeasurementVector; SampleType stddevMeasurementVector; //-------------------------- // Load measurements from images unsigned int nbBands = 0; unsigned int nbFeatures = 0; //Iterate over all input images FloatVectorImageListType* imageList = GetParameterImageList("io.il"); //Iterate over all input images for (unsigned int imgIndex = 0; imgIndex < imageList->Size(); ++imgIndex) { FloatVectorImageType::Pointer image = imageList->GetNthElement(imgIndex); image->UpdateOutputInformation(); if (imgIndex == 0) { nbBands = image->GetNumberOfComponentsPerPixel(); nbFeatures = static_cast(static_cast(nbBands) - 1); if (nbBands < 2) { otbAppLogFATAL(<< "Need at least two bands per image, got "<GetNumberOfComponentsPerPixel()) { otbAppLogFATAL(<< "Image has a different number of components than " "the first one, expected "<GetNumberOfComponentsPerPixel()); } } } // Extract image envelope to feed in sampleGenerator EnvelopeFilterType::Pointer envelopeFilter = EnvelopeFilterType::New(); envelopeFilter->SetInput(image); envelopeFilter->SetSamplingRate(0); if (!image->GetProjectionRef().empty()) { envelopeFilter->SetOutputProjectionRef(image->GetProjectionRef()); } // Setup the DEM Handler // otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); envelopeFilter->Update(); VectorDataType::Pointer envelope = envelopeFilter->GetOutput(); TreeIteratorType itVector(envelope->GetDataTree()); for (itVector.GoToBegin(); !itVector.IsAtEnd(); ++itVector) { if (itVector.Get()->IsPolygonFeature()) { itVector.Get()->SetFieldAsInt(std::string("class"),1); } } //Sample list generator ListSampleGeneratorType::Pointer sampleGenerator = ListSampleGeneratorType::New(); sampleGenerator->SetInput(image); sampleGenerator->SetInputVectorData(envelope); sampleGenerator->SetClassKey("class"); sampleGenerator->SetMaxTrainingSize(GetParameterInt("sample.mt")); sampleGenerator->SetMaxValidationSize(GetParameterInt("sample.mv")); sampleGenerator->SetValidationTrainingProportion(GetParameterFloat("sample.vtr")); sampleGenerator->SetBoundByMin(false); sampleGenerator->SetPolygonEdgeInclusion(true); sampleGenerator->Update(); //Concatenate training and validation samples from the image concatenateTrainingSamples->AddInput(sampleGenerator->GetTrainingListSample()); concatenateValidationSamples->AddInput(sampleGenerator->GetValidationListSample()); } // if no input image, try CSV if (imageList->Size() == 0) { if (HasValue("io.csv") && IsParameterEnabled("io.csv")) { ListSampleType::Pointer csvListSample = ListSampleType::New(); this->ParseCSVPredictors(this->GetParameterString("io.csv"), csvListSample); unsigned int totalCSVSize = csvListSample->Size(); if (totalCSVSize == 0) { otbAppLogFATAL("No input image and empty CSV file. Missing input data"); } nbBands = csvListSample->GetMeasurementVectorSize(); nbFeatures = static_cast(static_cast(nbBands) - 1); ListSampleType::Pointer csvTrainListSample = ListSampleType::New(); ListSampleType::Pointer csvValidListSample = ListSampleType::New(); csvTrainListSample->SetMeasurementVectorSize(nbBands); csvValidListSample->SetMeasurementVectorSize(nbBands); double ratio = this->GetParameterFloat("sample.vtr"); int trainSize = static_cast(static_cast(totalCSVSize)*(1.0-ratio)); int validSize = static_cast(static_cast(totalCSVSize)*(ratio)); if (trainSize > this->GetParameterInt("sample.mt")) { trainSize = this->GetParameterInt("sample.mt"); } if (validSize > this->GetParameterInt("sample.mv")) { validSize = this->GetParameterInt("sample.mv"); } double probaTrain = static_cast(trainSize)/static_cast(totalCSVSize); double probaValid = static_cast(validSize)/static_cast(totalCSVSize); RandomGeneratorType::Pointer randomGenerator = RandomGeneratorType::GetInstance(); for (unsigned int i=0; iGetUniformVariate(0.0, 1.0); if (random < probaTrain) { csvTrainListSample->PushBack(csvListSample->GetMeasurementVector(i)); } else if (random < probaTrain + probaValid) { csvValidListSample->PushBack(csvListSample->GetMeasurementVector(i)); } } concatenateTrainingSamples->AddInput(csvTrainListSample); concatenateValidationSamples->AddInput(csvValidListSample); } } // Update concatenateTrainingSamples->Update(); concatenateValidationSamples->Update(); if (concatenateTrainingSamples->GetOutput()->Size() == 0) { otbAppLogFATAL("No training samples, cannot perform training."); } if (concatenateValidationSamples->GetOutput()->Size() == 0) { otbAppLogWARNING("No validation samples."); } if (IsParameterEnabled("io.imstat")) { StatisticsReader::Pointer statisticsReader = StatisticsReader::New(); statisticsReader->SetFileName(GetParameterString("io.imstat")); meanMeasurementVector = statisticsReader->GetStatisticVectorByName("mean"); stddevMeasurementVector = statisticsReader->GetStatisticVectorByName("stddev"); // handle stat file without output normalization if (meanMeasurementVector.Size() == nbFeatures) { meanMeasurementVector.SetSize(nbBands,false); meanMeasurementVector[nbFeatures] = 0.0; stddevMeasurementVector.SetSize(nbBands,false); stddevMeasurementVector[nbFeatures] = 1.0; } } else { meanMeasurementVector.SetSize(nbBands); meanMeasurementVector.Fill(0.); stddevMeasurementVector.SetSize(nbBands); stddevMeasurementVector.Fill(1.); } // Shift scale the samples ShiftScaleFilterType::Pointer trainingShiftScaleFilter = ShiftScaleFilterType::New(); trainingShiftScaleFilter->SetInput(concatenateTrainingSamples->GetOutput()); trainingShiftScaleFilter->SetShifts(meanMeasurementVector); trainingShiftScaleFilter->SetScales(stddevMeasurementVector); trainingShiftScaleFilter->Update(); ListSampleType::Pointer rawValidationListSample=ListSampleType::New(); //Test if the validation test is empty if ( concatenateValidationSamples->GetOutput()->Size() != 0 ) { ShiftScaleFilterType::Pointer validationShiftScaleFilter = ShiftScaleFilterType::New(); validationShiftScaleFilter->SetInput(concatenateValidationSamples->GetOutput()); validationShiftScaleFilter->SetShifts(meanMeasurementVector); validationShiftScaleFilter->SetScales(stddevMeasurementVector); validationShiftScaleFilter->Update(); rawValidationListSample = validationShiftScaleFilter->GetOutput(); } // Split between predictors and output values ListSampleType::Pointer rawlistSample = trainingShiftScaleFilter->GetOutput(); ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(nbFeatures); listSample->Resize(rawlistSample->Size()); TargetListSampleType::Pointer labelListSample = TargetListSampleType::New(); labelListSample->SetMeasurementVectorSize(1); labelListSample->Resize(rawlistSample->Size()); ListSampleType::Pointer validationListSample = ListSampleType::New(); validationListSample->SetMeasurementVectorSize(nbFeatures); validationListSample->Resize(rawValidationListSample->Size()); TargetListSampleType::Pointer validationLabeledListSample = TargetListSampleType::New(); validationLabeledListSample->SetMeasurementVectorSize(1); validationLabeledListSample->Resize(rawValidationListSample->Size()); ListSampleType::MeasurementVectorType elem; TargetListSampleType::MeasurementVectorType outElem; for (ListSampleType::InstanceIdentifier i=0; iSize() ; ++i) { elem = rawlistSample->GetMeasurementVector(i); outElem[0] = elem[nbFeatures]; labelListSample->SetMeasurementVector(i,outElem); elem.SetSize(nbFeatures,false); listSample->SetMeasurementVector(i,elem); } for (ListSampleType::InstanceIdentifier i=0; iSize() ; ++i) { elem = rawValidationListSample->GetMeasurementVector(i); outElem[0] = elem[nbFeatures]; validationLabeledListSample->SetMeasurementVector(i,outElem); elem.SetSize(nbFeatures,false); validationListSample->SetMeasurementVector(i,elem); } otbAppLogINFO("Number of training samples: " << concatenateTrainingSamples->GetOutput()->Size()); //-------------------------- // Split the data set into training/validation set ListSampleType::Pointer trainingListSample = listSample; TargetListSampleType::Pointer trainingLabeledListSample = labelListSample; otbAppLogINFO("Size of training set: " << trainingListSample->Size()); otbAppLogINFO("Size of validation set: " << validationListSample->Size()); //-------------------------- // Estimate model //-------------------------- this->Train(trainingListSample,trainingLabeledListSample,GetParameterString("io.out")); //-------------------------- // Performances estimation //-------------------------- ListSampleType::Pointer performanceListSample; TargetListSampleType::Pointer predictedList = TargetListSampleType::New(); predictedList->SetMeasurementVectorSize(1); TargetListSampleType::Pointer performanceLabeledListSample; //Test the input validation set size if(validationLabeledListSample->Size() != 0) { performanceListSample = validationListSample; performanceLabeledListSample = validationLabeledListSample; } else { otbAppLogWARNING("The validation set is empty. The performance estimation is done using the input training set in this case."); performanceListSample = trainingListSample; performanceLabeledListSample = trainingLabeledListSample; } this->Classify(performanceListSample, predictedList, GetParameterString("io.out")); otbAppLogINFO("Training performances"); double mse=0.0; TargetListSampleType::MeasurementVectorType predictedElem; for (TargetListSampleType::InstanceIdentifier i=0; iSize() ; ++i) { outElem = performanceLabeledListSample->GetMeasurementVector(i); predictedElem = predictedList->GetMeasurementVector(i); mse += (outElem[0] - predictedElem[0]) * (outElem[0] - predictedElem[0]); } mse /= static_cast(performanceListSample->Size()); otbAppLogINFO("Mean Square Error = "<SetParameterFloat("io.mse",mse); } }; } // end namespace Wrapper } // end namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::TrainRegression) OTB-release-5.8/Modules/Applications/AppClassification/app/otbTrainVectorClassifier.cxx000066400000000000000000000500541301006202600313320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbLearningApplicationBase.h" #include "otbOGRDataSourceWrapper.h" #include "otbOGRFeatureWrapper.h" #include "otbStatisticsXMLFileWriter.h" #include "itkVariableLengthVector.h" #include "otbStatisticsXMLFileReader.h" #include "itkListSample.h" #include "otbShiftScaleSampleListFilter.h" // Validation #include "otbConfusionMatrixCalculator.h" #include #include namespace otb { namespace Wrapper { /** Utility function to negate std::isalnum */ bool IsNotAlphaNum(char c) { return !std::isalnum(c); } class TrainVectorClassifier : public LearningApplicationBase { public: typedef TrainVectorClassifier Self; typedef LearningApplicationBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self) itkTypeMacro(Self, Superclass) typedef Superclass::SampleType SampleType; typedef Superclass::ListSampleType ListSampleType; typedef Superclass::TargetListSampleType TargetListSampleType; typedef Superclass::SampleImageType SampleImageType; typedef double ValueType; typedef itk::VariableLengthVector MeasurementType; typedef otb::StatisticsXMLFileReader StatisticsReader; typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleFilterType; // Estimate performance on validation sample typedef otb::ConfusionMatrixCalculator ConfusionMatrixCalculatorType; typedef ConfusionMatrixCalculatorType::ConfusionMatrixType ConfusionMatrixType; typedef ConfusionMatrixCalculatorType::MapOfIndicesType MapOfIndicesType; typedef ConfusionMatrixCalculatorType::ClassLabelType ClassLabelType; private: void DoInit() { SetName("TrainVectorClassifier"); SetDescription("Train a classifier based on labeled geometries and a list of features to consider."); SetDocName("Train Vector Classifier"); SetDocLongDescription("This application trains a classifier based on " "labeled geometries and a list of features to consider for classification."); SetDocLimitations(" "); SetDocAuthors("OTB Team"); SetDocSeeAlso(" "); //Group IO AddParameter(ParameterType_Group, "io", "Input and output data"); SetParameterDescription("io", "This group of parameters allows setting input and output data."); AddParameter(ParameterType_InputVectorDataList, "io.vd", "Input Vector Data"); SetParameterDescription("io.vd", "Input geometries used for training (note : all geometries from the layer will be used)"); AddParameter(ParameterType_InputFilename, "io.stats", "Input XML image statistics file"); MandatoryOff("io.stats"); SetParameterDescription("io.stats", "XML file containing mean and variance of each feature."); AddParameter(ParameterType_OutputFilename, "io.confmatout", "Output confusion matrix"); SetParameterDescription("io.confmatout", "Output file containing the confusion matrix (.csv format)."); MandatoryOff("io.confmatout"); AddParameter(ParameterType_OutputFilename, "io.out", "Output model"); SetParameterDescription("io.out", "Output file containing the model estimated (.txt format)."); AddParameter(ParameterType_ListView, "feat", "Field names for training features."); SetParameterDescription("feat","List of field names in the input vector data to be used as features for training."); AddParameter(ParameterType_String,"cfield","Field containing the class id for supervision"); SetParameterDescription("cfield","Field containing the class id for supervision. " "Only geometries with this field available will be taken into account."); SetParameterString("cfield","class"); AddParameter(ParameterType_Int, "layer", "Layer Index"); SetParameterDescription("layer", "Index of the layer to use in the input vector file."); MandatoryOff("layer"); SetDefaultParameterInt("layer",0); AddParameter(ParameterType_Group, "valid", "Validation data"); SetParameterDescription("valid", "This group of parameters defines validation data."); AddParameter(ParameterType_InputVectorDataList, "valid.vd", "Validation Vector Data"); SetParameterDescription("valid.vd", "Geometries used for validation " "(must contain the same fields used for training, all geometries from the layer will be used)"); MandatoryOff("valid.vd"); AddParameter(ParameterType_Int, "valid.layer", "Layer Index"); SetParameterDescription("valid.layer", "Index of the layer to use in the validation vector file."); MandatoryOff("valid.layer"); SetDefaultParameterInt("valid.layer",0); // Add parameters for the classifier choice Superclass::DoInit(); AddRANDParameter(); // Doc example parameter settings SetDocExampleParameterValue("io.vd", "vectorData.shp"); SetDocExampleParameterValue("io.stats", "meanVar.xml"); SetDocExampleParameterValue("io.out", "svmModel.svm"); SetDocExampleParameterValue("feat", "perimeter area width"); SetDocExampleParameterValue("cfield", "predicted"); } void DoUpdateParameters() { if ( HasValue("io.vd") ) { std::vector vectorFileList = GetParameterStringList("io.vd"); ogr::DataSource::Pointer ogrDS = ogr::DataSource::New(vectorFileList[0], ogr::DataSource::Modes::Read); ogr::Layer layer = ogrDS->GetLayer(this->GetParameterInt("layer")); ogr::Feature feature = layer.ogr().GetNextFeature(); ClearChoices("feat"); for(int iField=0; iFieldGetNameRef(); key = item; std::string::iterator end = std::remove_if(key.begin(),key.end(),IsNotAlphaNum); std::transform(key.begin(), end, key.begin(), tolower); key="feat."+key.substr(0, end - key.begin()); AddChoice(key,item); } } } void LogConfusionMatrix(ConfusionMatrixCalculatorType* confMatCalc) { ConfusionMatrixCalculatorType::ConfusionMatrixType matrix = confMatCalc->GetConfusionMatrix(); // Compute minimal width size_t minwidth = 0; for (unsigned int i = 0; i < matrix.Rows(); i++) { for (unsigned int j = 0; j < matrix.Cols(); j++) { std::ostringstream os; os << matrix(i, j); size_t size = os.str().size(); if (size > minwidth) { minwidth = size; } } } MapOfIndicesType mapOfIndices = confMatCalc->GetMapOfIndices(); MapOfIndicesType::const_iterator it = mapOfIndices.begin(); MapOfIndicesType::const_iterator end = mapOfIndices.end(); for (; it != end; ++it) { std::ostringstream os; os << "[" << it->second << "]"; size_t size = os.str().size(); if (size > minwidth) { minwidth = size; } } // Generate matrix string, with 'minwidth' as size specifier std::ostringstream os; // Header line for (size_t i = 0; i < minwidth; ++i) os << " "; os << " "; it = mapOfIndices.begin(); end = mapOfIndices.end(); for (; it != end; ++it) { os << "[" << it->second << "]" << " "; } os << std::endl; // Each line of confusion matrix for (unsigned int i = 0; i < matrix.Rows(); i++) { ConfusionMatrixCalculatorType::ClassLabelType label = mapOfIndices[i]; os << "[" << std::setw(minwidth - 2) << label << "]" << " "; for (unsigned int j = 0; j < matrix.Cols(); j++) { os << std::setw(minwidth) << matrix(i, j) << " "; } os << std::endl; } otbAppLogINFO("Confusion matrix (rows = reference labels, columns = produced labels):\n" << os.str()); } void DoExecute() { typedef int LabelPixelType; typedef itk::FixedArray LabelSampleType; typedef itk::Statistics::ListSample LabelListSampleType; // Prepare selected field names (their position may change between two inputs) std::vector selectedIdx = GetSelectedItems("feat"); const unsigned int nbFeatures = selectedIdx.size(); std::vector fieldNames = GetChoiceNames("feat"); std::vector selectedNames(nbFeatures); for (unsigned int i=0 ; i featureFieldIndex(nbFeatures, -1); int cFieldIndex = -1; // List of available fields std::ostringstream oss; for (unsigned int i=0 ; iSetFileName(XMLfile); meanMeasurementVector = statisticsReader->GetStatisticVectorByName("mean"); stddevMeasurementVector = statisticsReader->GetStatisticVectorByName("stddev"); } else { meanMeasurementVector.SetSize(nbFeatures); meanMeasurementVector.Fill(0.); stddevMeasurementVector.SetSize(nbFeatures); stddevMeasurementVector.Fill(1.); } ListSampleType::Pointer input = ListSampleType::New(); LabelListSampleType::Pointer target = LabelListSampleType::New(); input->SetMeasurementVectorSize(nbFeatures); std::vector vectorFileList = GetParameterStringList("io.vd"); for (unsigned int k=0 ; kGetLayer(this->GetParameterInt("layer")); ogr::Feature feature = layer.ogr().GetNextFeature(); bool goesOn = feature.addr() != 0; if (!goesOn) { otbAppLogWARNING("The layer "<PushBack(mv); target->PushBack(feature.ogr().GetFieldAsInteger(cFieldIndex)); } feature = layer.ogr().GetNextFeature(); goesOn = feature.addr() != 0; } } ShiftScaleFilterType::Pointer trainingShiftScaleFilter = ShiftScaleFilterType::New(); trainingShiftScaleFilter->SetInput(input); trainingShiftScaleFilter->SetShifts(meanMeasurementVector); trainingShiftScaleFilter->SetScales(stddevMeasurementVector); trainingShiftScaleFilter->Update(); ListSampleType::Pointer trainingListSample= trainingShiftScaleFilter->GetOutput(); TargetListSampleType::Pointer trainingLabeledListSample = target; //-------------------------- // Estimate model //-------------------------- this->Train(trainingListSample,trainingLabeledListSample,GetParameterString("io.out")); //-------------------------- // Performances estimation //-------------------------- ListSampleType::Pointer validationListSample=ListSampleType::New(); TargetListSampleType::Pointer validationLabeledListSample = TargetListSampleType::New(); // Import validation data if (HasValue("valid.vd") && IsParameterEnabled("valid.vd")) { input = ListSampleType::New(); target = LabelListSampleType::New(); input->SetMeasurementVectorSize(nbFeatures); std::vector validFileList = this->GetParameterStringList("valid.vd"); for (unsigned int k=0 ; kGetLayer(this->GetParameterInt("valid.layer")); ogr::Feature feature = layer.ogr().GetNextFeature(); bool goesOn = feature.addr() != 0; if (!goesOn) { otbAppLogWARNING("The layer "<PushBack(mv); target->PushBack(feature.ogr().GetFieldAsInteger(cFieldIndex)); } feature = layer.ogr().GetNextFeature(); goesOn = feature.addr() != 0; } } ShiftScaleFilterType::Pointer validShiftScaleFilter = ShiftScaleFilterType::New(); validShiftScaleFilter->SetInput(input); validShiftScaleFilter->SetShifts(meanMeasurementVector); validShiftScaleFilter->SetScales(stddevMeasurementVector); validShiftScaleFilter->Update(); validationListSample = validShiftScaleFilter->GetOutput(); validationLabeledListSample = target; } //Test the input validation set size TargetListSampleType::Pointer predictedList = TargetListSampleType::New(); ListSampleType::Pointer performanceListSample; TargetListSampleType::Pointer performanceLabeledListSample; if(validationLabeledListSample->Size() != 0) { performanceListSample = validationListSample; performanceLabeledListSample = validationLabeledListSample; } else { otbAppLogWARNING("The validation set is empty. The performance estimation is done using the input training set in this case."); performanceListSample = trainingListSample; performanceLabeledListSample = trainingLabeledListSample; } this->Classify(performanceListSample, predictedList, GetParameterString("io.out")); ConfusionMatrixCalculatorType::Pointer confMatCalc = ConfusionMatrixCalculatorType::New(); otbAppLogINFO("Predicted list size : " << predictedList->Size()); otbAppLogINFO("ValidationLabeledListSample size : " << performanceLabeledListSample->Size()); confMatCalc->SetReferenceLabels(performanceLabeledListSample); confMatCalc->SetProducedLabels(predictedList); confMatCalc->Compute(); otbAppLogINFO("training performances"); LogConfusionMatrix(confMatCalc); for (unsigned int itClasses = 0; itClasses < confMatCalc->GetNumberOfClasses(); itClasses++) { ConfusionMatrixCalculatorType::ClassLabelType classLabel = confMatCalc->GetMapOfIndices()[itClasses]; otbAppLogINFO("Precision of class [" << classLabel << "] vs all: " << confMatCalc->GetPrecisions()[itClasses]); otbAppLogINFO("Recall of class [" << classLabel << "] vs all: " << confMatCalc->GetRecalls()[itClasses]); otbAppLogINFO( "F-score of class [" << classLabel << "] vs all: " << confMatCalc->GetFScores()[itClasses] << "\n"); } otbAppLogINFO("Global performance, Kappa index: " << confMatCalc->GetKappaIndex()); if (this->HasValue("io.confmatout")) { // Writing the confusion matrix in the output .CSV file MapOfIndicesType::iterator itMapOfIndicesValid, itMapOfIndicesPred; ClassLabelType labelValid = 0; ConfusionMatrixType confusionMatrix = confMatCalc->GetConfusionMatrix(); MapOfIndicesType mapOfIndicesValid = confMatCalc->GetMapOfIndices(); unsigned int nbClassesPred = mapOfIndicesValid.size(); ///////////////////////////////////////////// // Filling the 2 headers for the output file const std::string commentValidStr = "#Reference labels (rows):"; const std::string commentPredStr = "#Produced labels (columns):"; const char separatorChar = ','; std::ostringstream ossHeaderValidLabels, ossHeaderPredLabels; // Filling ossHeaderValidLabels and ossHeaderPredLabels for the output file ossHeaderValidLabels << commentValidStr; ossHeaderPredLabels << commentPredStr; itMapOfIndicesValid = mapOfIndicesValid.begin(); while (itMapOfIndicesValid != mapOfIndicesValid.end()) { // labels labelValid of mapOfIndicesValid are already sorted in otbConfusionMatrixCalculator labelValid = itMapOfIndicesValid->second; otbAppLogINFO("mapOfIndicesValid[" << itMapOfIndicesValid->first << "] = " << labelValid); ossHeaderValidLabels << labelValid; ossHeaderPredLabels << labelValid; ++itMapOfIndicesValid; if (itMapOfIndicesValid != mapOfIndicesValid.end()) { ossHeaderValidLabels << separatorChar; ossHeaderPredLabels << separatorChar; } else { ossHeaderValidLabels << std::endl; ossHeaderPredLabels << std::endl; } } std::ofstream outFile; outFile.open(this->GetParameterString("io.confmatout").c_str()); outFile << std::fixed; outFile.precision(10); ///////////////////////////////////// // Writing the 2 headers outFile << ossHeaderValidLabels.str(); outFile << ossHeaderPredLabels.str(); ///////////////////////////////////// unsigned int indexLabelValid = 0, indexLabelPred = 0; for (itMapOfIndicesValid = mapOfIndicesValid.begin(); itMapOfIndicesValid != mapOfIndicesValid.end(); ++itMapOfIndicesValid) { indexLabelPred = 0; for (itMapOfIndicesPred = mapOfIndicesValid.begin(); itMapOfIndicesPred != mapOfIndicesValid.end(); ++itMapOfIndicesPred) { // Writing the confusion matrix (sorted in otbConfusionMatrixCalculator) in the output file outFile << confusionMatrix(indexLabelValid, indexLabelPred); if (indexLabelPred < (nbClassesPred - 1)) { outFile << separatorChar; } else { outFile << std::endl; } ++indexLabelPred; } ++indexLabelValid; } outFile.close(); } // END if (this->HasValue("io.confmatout")) } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::TrainVectorClassifier) OTB-release-5.8/Modules/Applications/AppClassification/app/otbVectorDataDSValidation.cxx000066400000000000000000000126261301006202600313660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataToDSValidatedVectorDataFilter.h" #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbWrapperStringListParameter.h" namespace otb { namespace Wrapper { class VectorDataDSValidation: public Application { public: /** Standard class typedefs. */ typedef VectorDataDSValidation Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef double PrecisionType; typedef otb::VectorData VectorDataType; typedef otb::VectorDataToDSValidatedVectorDataFilter VectorDataValidationFilterType; typedef VectorDataValidationFilterType::LabelSetType LabelSetType; typedef FuzzyDescriptorsModelManager::DescriptorsModelType DescriptorsModelType; typedef otb::Wrapper::StringListParameter::StringListType StringListType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(VectorDataDSValidation, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("VectorDataDSValidation"); SetDescription("Vector data validation based on the fusion of features using Dempster-Shafer evidence theory framework."); SetDocName("Vector Data validation"); SetDocLongDescription("This application validates or unvalidate the studied samples using the Dempster-Shafer theory."); SetDocLimitations("None."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("http://en.wikipedia.org/wiki/Dempster-Shafer_theory"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputVectorData, "in", "Input Vector Data"); SetParameterDescription("in", "Input vector data to validate"); AddParameter(ParameterType_InputFilename, "descmod", "Descriptors model filename"); SetParameterDescription("descmod", "Fuzzy descriptors model (xml file)"); AddParameter(ParameterType_StringList, "belsup", "Belief Support"); SetParameterDescription("belsup", "Dempster Shafer study hypothesis to compute belief"); AddParameter(ParameterType_StringList, "plasup", "Plausibility Support"); SetParameterDescription("plasup", "Dempster Shafer study hypothesis to compute plausibility"); AddParameter(ParameterType_String, "cri", "Criterion"); SetParameterDescription("cri", "Dempster Shafer criterion (by default (belief+plausibility)/2)"); MandatoryOff("cri"); SetParameterString("cri", "((Belief + Plausibility)/2.)"); AddParameter(ParameterType_Float, "thd", "Criterion threshold"); SetParameterDescription("thd", "Criterion threshold (default 0.5)"); MandatoryOff("thd"); SetParameterFloat("thd", 0.5); AddParameter(ParameterType_OutputVectorData, "out", "Output Vector Data"); SetParameterDescription("out", "Output VectorData containing only the validated samples"); // Doc example parameter settings SetDocExampleParameterValue("in", "cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp"); SetDocExampleParameterValue("belsup", "cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp"); SetDocExampleParameterValue("descmod", "DSFuzzyModel.xml"); SetDocExampleParameterValue("out", "VectorDataDSValidation.shp"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent // .. // } void DoExecute() ITK_OVERRIDE { //Read the vector data VectorDataType::Pointer inVectorData = GetParameterVectorData("in"); inVectorData->Update(); // Load the descriptors model std::string descModFile = GetParameterString("descmod"); DescriptorsModelType descMod = FuzzyDescriptorsModelManager::Read(descModFile.c_str()); LabelSetType Bhyp, Phyp; int nbSet; StringListType stringList = GetParameterStringList("belsup"); nbSet = stringList.size(); for (int i = 0; i < nbSet; i++) { std::string str = stringList[i]; Bhyp.insert(str); } stringList = GetParameterStringList("plasup"); nbSet = stringList.size(); for (int i = 0; i < nbSet; i++) { std::string str = stringList[i]; Phyp.insert(str); } // Process m_ValidationFilter = VectorDataValidationFilterType::New(); m_ValidationFilter->SetInput(inVectorData); m_ValidationFilter->SetDescriptorModels(descMod); m_ValidationFilter->SetBeliefHypothesis(Bhyp); m_ValidationFilter->SetPlausibilityHypothesis(Phyp); m_ValidationFilter->SetCriterionFormula(GetParameterString("cri")); m_ValidationFilter->SetCriterionThreshold(GetParameterFloat("thd")); // Set the output image SetParameterOutputVectorData("out", m_ValidationFilter->GetOutput()); }; VectorDataValidationFilterType::Pointer m_ValidationFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::VectorDataDSValidation); OTB-release-5.8/Modules/Applications/AppClassification/include/000077500000000000000000000000001301006202600244735ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppClassification/include/otbLearningApplicationBase.h000066400000000000000000000236711301006202600321000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLearningApplicationBase_h #define otbLearningApplicationBase_h #include "otbConfigure.h" #include "otbWrapperApplication.h" #include // ListSample #include "itkListSample.h" #include "itkVariableLengthVector.h" //Estimator #include "otbMachineLearningModelFactory.h" #ifdef OTB_USE_OPENCV #include "otbKNearestNeighborsMachineLearningModel.h" #include "otbRandomForestsMachineLearningModel.h" // OpenCV SVM implementation is buggy with linear kernel // Users should use the libSVM implementation instead. //#include "otbSVMMachineLearningModel.h" #include "otbBoostMachineLearningModel.h" #include "otbDecisionTreeMachineLearningModel.h" #include "otbGradientBoostedTreeMachineLearningModel.h" #include "otbNormalBayesMachineLearningModel.h" #include "otbNeuralNetworkMachineLearningModel.h" #endif #ifdef OTB_USE_LIBSVM #include "otbLibSVMMachineLearningModel.h" #endif #ifdef OTB_USE_SHARK #include "otbSharkRandomForestsMachineLearningModel.h" #endif namespace otb { namespace Wrapper { /** \class LearningApplicationBase * \brief LearningApplicationBase is the base class for application that * use machine learning model. * * This base class offers a DoInit() method to initialize all the parameters * related to machine learning models. They will all be in the choice parameter * named "classifier". The class also offers generic Train() and Classify() * methods. The classes derived from LearningApplicationBase only need these * 3 methods to handle the machine learning model. * * There are multiple machine learning models in OTB, some imported * from OpenCV and one imported from LibSVM. They all have * different parameters. The purpose of this class is to handle the * creation of all parameters related to machine learning models (in * DoInit() ), and to dispatch the calls to specific train functions * in function Train(). * * This class is templated over scalar types for input and output values. * Typically, the input value type will be either float of double. The choice * of an output value type depends on the learning mode. This base class * supports both classification and regression modes. For classification * (enabled by default), the output value type corresponds to a class * identifier so integer types suit well. For regression, the output value * should not be an integer type, but rather a floating point type. In addition, * an application deriving this base class for regression should initialize * the m_RegressionFlag to true in their constructor. * * \sa TrainImagesClassifier * \sa TrainRegression * * \ingroup OTBAppClassification */ template class LearningApplicationBase: public Application { public: /** Standard class typedefs. */ typedef LearningApplicationBase Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkTypeMacro(LearningApplicationBase, otb::Application) typedef TInputValue InputValueType; typedef TOutputValue OutputValueType; typedef otb::VectorImage SampleImageType; typedef typename SampleImageType::PixelType PixelType; // Machine Learning models typedef otb::MachineLearningModelFactory< InputValueType, OutputValueType> ModelFactoryType; typedef typename ModelFactoryType::MachineLearningModelTypePointer ModelPointerType; typedef typename ModelFactoryType::MachineLearningModelType ModelType; typedef typename ModelType::InputSampleType SampleType; typedef typename ModelType::InputListSampleType ListSampleType; typedef typename ModelType::TargetSampleType TargetSampleType; typedef typename ModelType::TargetListSampleType TargetListSampleType; typedef typename ModelType::TargetValueType TargetValueType; #ifdef OTB_USE_OPENCV typedef otb::RandomForestsMachineLearningModel RandomForestType; typedef otb::KNearestNeighborsMachineLearningModel KNNType; // OpenCV SVM implementation is buggy with linear kernel // Users should use the libSVM implementation instead. // typedef otb::SVMMachineLearningModel SVMType; typedef otb::BoostMachineLearningModel BoostType; typedef otb::DecisionTreeMachineLearningModel DecisionTreeType; typedef otb::GradientBoostedTreeMachineLearningModel GradientBoostedTreeType; typedef otb::NeuralNetworkMachineLearningModel NeuralNetworkType; typedef otb::NormalBayesMachineLearningModel NormalBayesType; #endif #ifdef OTB_USE_LIBSVM typedef otb::LibSVMMachineLearningModel LibSVMType; #endif #ifdef OTB_USE_SHARK typedef otb::SharkRandomForestsMachineLearningModel SharkRandomForestType; #endif protected: LearningApplicationBase(); ~LearningApplicationBase() ITK_OVERRIDE; /** Generic method to train and save the machine learning model. This method * uses specific train methods depending on the chosen model.*/ void Train(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); /** Generic method to load a model file and use it to classify a sample list*/ void Classify(typename ListSampleType::Pointer validationListSample, typename TargetListSampleType::Pointer predictedList, std::string modelPath); /** Init method that creates all the parameters for machine learning models */ void DoInit(); /** Flag to switch between classification and regression mode. * False by default, child classes may change it in their constructor */ bool m_RegressionFlag; private: /** Specific Init and Train methods for each machine learning model */ //@{ #ifdef OTB_USE_LIBSVM void InitLibSVMParams(); void TrainLibSVM(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); #endif #ifdef OTB_USE_OPENCV void InitBoostParams(); // OpenCV SVM implementation is buggy with linear kernel // Users should use the libSVM implementation instead. // void InitSVMParams(); void InitDecisionTreeParams(); void InitGradientBoostedTreeParams(); void InitNeuralNetworkParams(); void InitNormalBayesParams(); void InitRandomForestsParams(); void InitKNNParams(); void TrainBoost(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); // OpenCV SVM implementation is buggy with linear kernel // Users should use the libSVM implementation instead. // void TrainSVM(typename ListSampleType::Pointer trainingListSample, // typename TargetListSampleType::Pointer trainingLabeledListSample, // std::string modelPath); void TrainDecisionTree(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); void TrainGradientBoostedTree(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); void TrainNeuralNetwork(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); void TrainNormalBayes(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); void TrainRandomForests(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); void TrainKNN(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); #endif #ifdef OTB_USE_SHARK void InitSharkRandomForestsParams(); void TrainSharkRandomForests(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath); #endif //@} }; } } #ifndef OTB_MANUAL_INSTANTIATION #include "otbLearningApplicationBase.txx" #ifdef OTB_USE_OPENCV #include "otbTrainBoost.txx" #include "otbTrainDecisionTree.txx" #include "otbTrainGradientBoostedTree.txx" #include "otbTrainKNN.txx" #include "otbTrainNeuralNetwork.txx" #include "otbTrainNormalBayes.txx" #include "otbTrainRandomForests.txx" // OpenCV SVM implementation is buggy with linear kernel // Users should use the libSVM implementation instead. //#include "otbTrainSVM.txx" #endif #ifdef OTB_USE_LIBSVM #include "otbTrainLibSVM.txx" #endif #ifdef OTB_USE_SHARK #include "otbTrainSharkRandomForests.txx" #endif #endif #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbLearningApplicationBase.txx000066400000000000000000000161051301006202600324660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLearningApplicationBase_txx #define otbLearningApplicationBase_txx #include "otbLearningApplicationBase.h" // only need this filter as a dummy process object #include "otbRGBAPixelConverter.h" namespace otb { namespace Wrapper { template LearningApplicationBase ::LearningApplicationBase() : m_RegressionFlag(false) { } template LearningApplicationBase ::~LearningApplicationBase() { ModelFactoryType::CleanFactories(); } template void LearningApplicationBase ::DoInit() { AddDocTag(Tags::Learning); // main choice parameter that will contain all machine learning options AddParameter(ParameterType_Choice, "classifier", "Classifier to use for the training"); SetParameterDescription("classifier", "Choice of the classifier to use for the training."); //Group LibSVM #ifdef OTB_USE_LIBSVM InitLibSVMParams(); #endif #ifdef OTB_USE_OPENCV // OpenCV SVM implementation is buggy with linear kernel // Users should use the libSVM implementation instead. // InitSVMParams(); if (!m_RegressionFlag) { InitBoostParams(); // Regression not supported } InitDecisionTreeParams(); InitGradientBoostedTreeParams(); InitNeuralNetworkParams(); if (!m_RegressionFlag) { InitNormalBayesParams(); // Regression not supported } InitRandomForestsParams(); InitKNNParams(); #endif #ifdef OTB_USE_SHARK InitSharkRandomForestsParams(); #endif } template void LearningApplicationBase ::Classify(typename ListSampleType::Pointer validationListSample, typename TargetListSampleType::Pointer predictedList, std::string modelPath) { // Setup fake reporter RGBAPixelConverter::Pointer dummyFilter = RGBAPixelConverter::New(); dummyFilter->SetProgress(0.0f); this->AddProcess(dummyFilter,"Classify..."); dummyFilter->InvokeEvent(itk::StartEvent()); // load a machine learning model from file and predict the input sample list ModelPointerType model = ModelFactoryType::CreateMachineLearningModel(modelPath, ModelFactoryType::ReadMode); if (model.IsNull()) { otbAppLogFATAL(<< "Error when loading model " << modelPath); } model->Load(modelPath); model->SetRegressionMode(this->m_RegressionFlag); model->SetInputListSample(validationListSample); model->SetTargetListSample(predictedList); model->PredictAll(); // update reporter dummyFilter->UpdateProgress(1.0f); dummyFilter->InvokeEvent(itk::EndEvent()); } template void LearningApplicationBase ::Train(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { // Setup fake reporter RGBAPixelConverter::Pointer dummyFilter = RGBAPixelConverter::New(); dummyFilter->SetProgress(0.0f); this->AddProcess(dummyFilter,"Training model..."); dummyFilter->InvokeEvent(itk::StartEvent()); // get the name of the chosen machine learning model const std::string modelName = GetParameterString("classifier"); // call specific train function if (modelName == "libsvm") { #ifdef OTB_USE_LIBSVM TrainLibSVM(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module LIBSVM is not installed. You should consider turning OTB_USE_LIBSVM on during cmake configuration."); #endif } if(modelName == "sharkrf") { #ifdef OTB_USE_SHARK TrainSharkRandomForests(trainingListSample,trainingLabeledListSample,modelPath); #else otbAppLogFATAL("Module SharkLearning is not installed. You should consider turning OTB_USE_SHARK on during cmake configuration."); #endif } // OpenCV SVM implementation is buggy with linear kernel // Users should use the libSVM implementation instead. // else if (modelName == "svm") // { // #ifdef OTB_USE_OPENCV // TrainSVM(trainingListSample, trainingLabeledListSample, modelPath); // #else // otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); // #endif // } else if (modelName == "boost") { #ifdef OTB_USE_OPENCV TrainBoost(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); #endif } else if (modelName == "dt") { #ifdef OTB_USE_OPENCV TrainDecisionTree(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); #endif } else if (modelName == "gbt") { #ifdef OTB_USE_OPENCV TrainGradientBoostedTree(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); #endif } else if (modelName == "ann") { #ifdef OTB_USE_OPENCV TrainNeuralNetwork(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); #endif } else if (modelName == "bayes") { #ifdef OTB_USE_OPENCV TrainNormalBayes(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); #endif } else if (modelName == "rf") { #ifdef OTB_USE_OPENCV TrainRandomForests(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); #endif } else if (modelName == "knn") { #ifdef OTB_USE_OPENCV TrainKNN(trainingListSample, trainingLabeledListSample, modelPath); #else otbAppLogFATAL("Module OPENCV is not installed. You should consider turning OTB_USE_OPENCV on during cmake configuration."); #endif } // update reporter dummyFilter->UpdateProgress(1.0f); dummyFilter->InvokeEvent(itk::EndEvent()); } } } #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainBoost.txx000066400000000000000000000075441301006202600300430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainBoost_txx #define otbTrainBoost_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitBoostParams() { AddChoice("classifier.boost", "Boost classifier"); SetParameterDescription("classifier.boost", "This group of parameters allows setting Boost classifier parameters. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/boosting.html}."); //BoostType AddParameter(ParameterType_Choice, "classifier.boost.t", "Boost Type"); AddChoice("classifier.boost.t.discrete", "Discrete AdaBoost"); AddChoice("classifier.boost.t.real", "Real AdaBoost (technique using confidence-rated predictions " "and working well with categorical data)"); AddChoice("classifier.boost.t.logit", "LogitBoost (technique producing good regression fits)"); AddChoice("classifier.boost.t.gentle", "Gentle AdaBoost (technique setting less weight on outlier data points " "and, for that reason, being often good with regression data)"); SetParameterString("classifier.boost.t", "real"); SetParameterDescription("classifier.boost.t", "Type of Boosting algorithm."); //Do not expose SplitCriteria //WeakCount AddParameter(ParameterType_Int, "classifier.boost.w", "Weak count"); SetParameterInt("classifier.boost.w", 100); SetParameterDescription("classifier.boost.w","The number of weak classifiers."); //WeightTrimRate AddParameter(ParameterType_Float, "classifier.boost.r", "Weight Trim Rate"); SetParameterFloat("classifier.boost.r", 0.95); SetParameterDescription("classifier.boost.r","A threshold between 0 and 1 used to save computational time. " "Samples with summary weight <= (1 - weight_trim_rate) do not participate in the next iteration of training. " "Set this parameter to 0 to turn off this functionality."); //MaxDepth : Not sure that this parameter has to be exposed. AddParameter(ParameterType_Int, "classifier.boost.m", "Maximum depth of the tree"); SetParameterInt("classifier.boost.m", 1); SetParameterDescription("classifier.boost.m","Maximum depth of the tree."); } template void LearningApplicationBase ::TrainBoost(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename BoostType::Pointer boostClassifier = BoostType::New(); boostClassifier->SetRegressionMode(this->m_RegressionFlag); boostClassifier->SetInputListSample(trainingListSample); boostClassifier->SetTargetListSample(trainingLabeledListSample); boostClassifier->SetBoostType(GetParameterInt("classifier.boost.t")); boostClassifier->SetWeakCount(GetParameterInt("classifier.boost.w")); boostClassifier->SetWeightTrimRate(GetParameterFloat("classifier.boost.r")); boostClassifier->SetMaxDepth(GetParameterInt("classifier.boost.m")); boostClassifier->Train(); boostClassifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainDecisionTree.txx000066400000000000000000000121221301006202600313160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainDecisionTree_txx #define otbTrainDecisionTree_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitDecisionTreeParams() { AddChoice("classifier.dt", "Decision Tree classifier"); SetParameterDescription("classifier.dt", "This group of parameters allows setting Decision Tree classifier parameters. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/decision_trees.html}."); //MaxDepth AddParameter(ParameterType_Int, "classifier.dt.max", "Maximum depth of the tree"); SetParameterInt("classifier.dt.max", 65535); SetParameterDescription( "classifier.dt.max", "The training algorithm attempts to split each node while its depth is smaller than the maximum " "possible depth of the tree. The actual depth may be smaller if the other termination criteria are met, and/or " "if the tree is pruned."); //MinSampleCount AddParameter(ParameterType_Int, "classifier.dt.min", "Minimum number of samples in each node"); SetParameterInt("classifier.dt.min", 10); SetParameterDescription("classifier.dt.min", "If the number of samples in a node is smaller than this parameter, " "then this node will not be split."); //RegressionAccuracy AddParameter(ParameterType_Float, "classifier.dt.ra", "Termination criteria for regression tree"); SetParameterFloat("classifier.dt.ra", 0.01); SetParameterDescription("classifier.dt.min", "If all absolute differences between an estimated value in a node " "and the values of the train samples in this node are smaller than this regression accuracy parameter, " "then the node will not be split."); //UseSurrogates : don't need to be exposed ! //AddParameter(ParameterType_Empty, "classifier.dt.sur", "Surrogate splits will be built"); //SetParameterDescription("classifier.dt.sur","These splits allow working with missing data and compute variable importance correctly."); //MaxCategories AddParameter(ParameterType_Int, "classifier.dt.cat", "Cluster possible values of a categorical variable into K <= cat clusters to find a suboptimal split"); SetParameterInt("classifier.dt.cat", 10); SetParameterDescription( "classifier.dt.cat", "Cluster possible values of a categorical variable into K <= cat clusters to find a suboptimal split."); //CVFolds AddParameter(ParameterType_Int, "classifier.dt.f", "K-fold cross-validations"); SetParameterInt("classifier.dt.f", 10); SetParameterDescription( "classifier.dt.f", "If cv_folds > 1, then it prunes a tree with K-fold cross-validation where K is equal to cv_folds."); //Use1seRule AddParameter(ParameterType_Empty, "classifier.dt.r", "Set Use1seRule flag to false"); SetParameterDescription( "classifier.dt.r", "If true, then a pruning will be harsher. This will make a tree more compact and more resistant to the training data noise but a bit less accurate."); //TruncatePrunedTree AddParameter(ParameterType_Empty, "classifier.dt.t", "Set TruncatePrunedTree flag to false"); SetParameterDescription("classifier.dt.t", "If true, then pruned branches are physically removed from the tree."); //Priors are not exposed. } template void LearningApplicationBase ::TrainDecisionTree(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename DecisionTreeType::Pointer classifier = DecisionTreeType::New(); classifier->SetRegressionMode(this->m_RegressionFlag); classifier->SetInputListSample(trainingListSample); classifier->SetTargetListSample(trainingLabeledListSample); classifier->SetMaxDepth(GetParameterInt("classifier.dt.max")); classifier->SetMinSampleCount(GetParameterInt("classifier.dt.min")); classifier->SetRegressionAccuracy(GetParameterFloat("classifier.dt.ra")); classifier->SetMaxCategories(GetParameterInt("classifier.dt.cat")); classifier->SetCVFolds(GetParameterInt("classifier.dt.f")); if (IsParameterEnabled("classifier.dt.r")) { classifier->SetUse1seRule(false); } if (IsParameterEnabled("classifier.dt.t")) { classifier->SetTruncatePrunedTree(false); } classifier->Train(); classifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainGradientBoostedTree.txx000066400000000000000000000113641301006202600326450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainGradientBoostedTree_txx #define otbTrainGradientBoostedTree_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitGradientBoostedTreeParams() { AddChoice("classifier.gbt", "Gradient Boosted Tree classifier"); SetParameterDescription( "classifier.gbt", "This group of parameters allows setting Gradient Boosted Tree classifier parameters. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/gradient_boosted_trees.html}."); if (m_RegressionFlag) { AddParameter(ParameterType_Choice, "classifier.gbt.t", "Loss Function Type"); SetParameterDescription("classifier.gbt.t","Type of loss functionused for training."); AddChoice("classifier.gbt.t.sqr","Squared Loss"); AddChoice("classifier.gbt.t.abs","Absolute Loss"); AddChoice("classifier.gbt.t.hub","Huber Loss"); } //WeakCount AddParameter(ParameterType_Int, "classifier.gbt.w", "Number of boosting algorithm iterations"); SetParameterInt("classifier.gbt.w", 200); SetParameterDescription( "classifier.gbt.w", "Number \"w\" of boosting algorithm iterations, with w*K being the total number of trees in " "the GBT model, where K is the output number of classes."); //Shrinkage AddParameter(ParameterType_Float, "classifier.gbt.s", "Regularization parameter"); SetParameterFloat("classifier.gbt.s", 0.01); SetParameterDescription("classifier.gbt.s", "Regularization parameter."); //SubSamplePortion AddParameter(ParameterType_Float, "classifier.gbt.p", "Portion of the whole training set used for each algorithm iteration"); SetParameterFloat("classifier.gbt.p", 0.8); SetParameterDescription( "classifier.gbt.p", "Portion of the whole training set used for each algorithm iteration. The subset is generated randomly."); //MaxDepth AddParameter(ParameterType_Int, "classifier.gbt.max", "Maximum depth of the tree"); SetParameterInt("classifier.gbt.max", 3); SetParameterDescription( "classifier.gbt.max", "The training algorithm attempts to split each node while its depth is smaller than the maximum " "possible depth of the tree. The actual depth may be smaller if the other termination criteria are met, and/or " "if the tree is pruned."); //UseSurrogates : don't need to be exposed ! //AddParameter(ParameterType_Empty, "classifier.gbt.sur", "Surrogate splits will be built"); //SetParameterDescription("classifier.gbt.sur","These splits allow working with missing data and compute variable importance correctly."); } template void LearningApplicationBase ::TrainGradientBoostedTree(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename GradientBoostedTreeType::Pointer classifier = GradientBoostedTreeType::New(); classifier->SetRegressionMode(this->m_RegressionFlag); classifier->SetInputListSample(trainingListSample); classifier->SetTargetListSample(trainingLabeledListSample); classifier->SetWeakCount(GetParameterInt("classifier.gbt.w")); classifier->SetShrinkage(GetParameterFloat("classifier.gbt.s")); classifier->SetSubSamplePortion(GetParameterFloat("classifier.gbt.p")); classifier->SetMaxDepth(GetParameterInt("classifier.gbt.max")); if (m_RegressionFlag) { switch (GetParameterInt("classifier.gbt.t")) { case 0: // SQUARED_LOSS classifier->SetLossFunctionType(CvGBTrees::SQUARED_LOSS); break; case 1: // ABSOLUTE_LOSS classifier->SetLossFunctionType(CvGBTrees::ABSOLUTE_LOSS); break; case 2: // HUBER_LOSS classifier->SetLossFunctionType(CvGBTrees::HUBER_LOSS); break; default: classifier->SetLossFunctionType(CvGBTrees::SQUARED_LOSS); break; } } else { classifier->SetLossFunctionType(CvGBTrees::DEVIANCE_LOSS); } classifier->Train(); classifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainKNN.txx000066400000000000000000000057171301006202600274030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainKNN_txx #define otbTrainKNN_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitKNNParams() { AddChoice("classifier.knn", "KNN classifier"); SetParameterDescription("classifier.knn", "This group of parameters allows setting KNN classifier parameters. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/k_nearest_neighbors.html}."); //K parameter AddParameter(ParameterType_Int, "classifier.knn.k", "Number of Neighbors"); SetParameterInt("classifier.knn.k", 32); SetParameterDescription("classifier.knn.k","The number of neighbors to use."); if (this->m_RegressionFlag) { // Decision rule : mean / median AddParameter(ParameterType_Choice, "classifier.knn.rule", "Decision rule"); SetParameterDescription("classifier.knn.rule", "Decision rule for regression output"); AddChoice("classifier.knn.rule.mean", "Mean of neighbors values"); SetParameterDescription("classifier.knn.rule.mean","Returns the mean of neighbors values"); AddChoice("classifier.knn.rule.median", "Median of neighbors values"); SetParameterDescription("classifier.knn.rule.median","Returns the median of neighbors values"); } } template void LearningApplicationBase ::TrainKNN(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename KNNType::Pointer knnClassifier = KNNType::New(); knnClassifier->SetRegressionMode(this->m_RegressionFlag); knnClassifier->SetInputListSample(trainingListSample); knnClassifier->SetTargetListSample(trainingLabeledListSample); knnClassifier->SetK(GetParameterInt("classifier.knn.k")); if (this->m_RegressionFlag) { std::string decision = this->GetParameterString("classifier.knn.rule"); if (decision == "mean") { knnClassifier->SetDecisionRule(KNNType::KNN_MEAN); } else if (decision == "median") { knnClassifier->SetDecisionRule(KNNType::KNN_MEDIAN); } } knnClassifier->Train(); knnClassifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainLibSVM.txx000066400000000000000000000134221301006202600300410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainLibSVM_txx #define otbTrainLibSVM_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitLibSVMParams() { AddChoice("classifier.libsvm", "LibSVM classifier"); SetParameterDescription("classifier.libsvm", "This group of parameters allows setting SVM classifier parameters."); AddParameter(ParameterType_Choice, "classifier.libsvm.k", "SVM Kernel Type"); AddChoice("classifier.libsvm.k.linear", "Linear"); AddChoice("classifier.libsvm.k.rbf", "Gaussian radial basis function"); AddChoice("classifier.libsvm.k.poly", "Polynomial"); AddChoice("classifier.libsvm.k.sigmoid", "Sigmoid"); SetParameterString("classifier.libsvm.k", "linear"); SetParameterDescription("classifier.libsvm.k", "SVM Kernel Type."); AddParameter(ParameterType_Choice, "classifier.libsvm.m", "SVM Model Type"); SetParameterDescription("classifier.libsvm.m", "Type of SVM formulation."); if (this->m_RegressionFlag) { AddChoice("classifier.libsvm.m.epssvr", "Epsilon Support Vector Regression"); AddChoice("classifier.libsvm.m.nusvr", "Nu Support Vector Regression"); SetParameterString("classifier.libsvm.m", "epssvr"); } else { AddChoice("classifier.libsvm.m.csvc", "C support vector classification"); AddChoice("classifier.libsvm.m.nusvc", "Nu support vector classification"); AddChoice("classifier.libsvm.m.oneclass", "Distribution estimation (One Class SVM)"); SetParameterString("classifier.libsvm.m", "csvc"); } AddParameter(ParameterType_Float, "classifier.libsvm.c", "Cost parameter C"); SetParameterFloat("classifier.libsvm.c", 1.0); SetParameterDescription( "classifier.libsvm.c", "SVM models have a cost parameter C (1 by default) to control the trade-off between training errors and forcing rigid margins."); AddParameter(ParameterType_Empty, "classifier.libsvm.opt", "Parameters optimization"); MandatoryOff("classifier.libsvm.opt"); SetParameterDescription("classifier.libsvm.opt", "SVM parameters optimization flag."); AddParameter(ParameterType_Empty, "classifier.libsvm.prob", "Probability estimation"); MandatoryOff("classifier.libsvm.prob"); SetParameterDescription("classifier.libsvm.prob", "Probability estimation flag."); if (this->m_RegressionFlag) { AddParameter(ParameterType_Float, "classifier.libsvm.eps", "Epsilon"); SetParameterFloat("classifier.libsvm.eps", 1e-3); AddParameter(ParameterType_Float, "classifier.libsvm.nu", "Nu"); SetParameterFloat("classifier.libsvm.nu", 0.5); } } template void LearningApplicationBase ::TrainLibSVM(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename LibSVMType::Pointer libSVMClassifier = LibSVMType::New(); libSVMClassifier->SetRegressionMode(this->m_RegressionFlag); libSVMClassifier->SetInputListSample(trainingListSample); libSVMClassifier->SetTargetListSample(trainingLabeledListSample); //SVM Option //TODO : Add other options ? if (IsParameterEnabled("classifier.libsvm.opt")) { libSVMClassifier->SetParameterOptimization(true); } if (IsParameterEnabled("classifier.libsvm.prob")) { libSVMClassifier->SetDoProbabilityEstimates(true); } libSVMClassifier->SetC(GetParameterFloat("classifier.libsvm.c")); switch (GetParameterInt("classifier.libsvm.k")) { case 0: // LINEAR libSVMClassifier->SetKernelType(LINEAR); break; case 1: // RBF libSVMClassifier->SetKernelType(RBF); break; case 2: // POLY libSVMClassifier->SetKernelType(POLY); break; case 3: // SIGMOID libSVMClassifier->SetKernelType(SIGMOID); break; default: // DEFAULT = LINEAR libSVMClassifier->SetKernelType(LINEAR); break; } if (this->m_RegressionFlag) { switch (GetParameterInt("classifier.libsvm.m")) { case 0: // EPSILON_SVR libSVMClassifier->SetSVMType(EPSILON_SVR); break; case 1: // NU_SVR libSVMClassifier->SetSVMType(NU_SVR); break; default: libSVMClassifier->SetSVMType(EPSILON_SVR); break; } libSVMClassifier->SetEpsilon(GetParameterFloat("classifier.libsvm.eps")); libSVMClassifier->SetNu(GetParameterFloat("classifier.libsvm.nu")); } else { switch (GetParameterInt("classifier.libsvm.m")) { case 0: // C_SVC libSVMClassifier->SetSVMType(C_SVC); break; case 1: // NU_SVC libSVMClassifier->SetSVMType(NU_SVC); break; case 2: // ONE_CLASS libSVMClassifier->SetSVMType(ONE_CLASS); break; default: libSVMClassifier->SetSVMType(C_SVC); break; } } libSVMClassifier->Train(); libSVMClassifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainNeuralNetwork.txx000066400000000000000000000224541301006202600315520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainNeuralNetwork_txx #define otbTrainNeuralNetwork_txx #include #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitNeuralNetworkParams() { AddChoice("classifier.ann", "Artificial Neural Network classifier"); SetParameterDescription("classifier.ann", "This group of parameters allows setting Artificial Neural Network classifier parameters. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/neural_networks.html}."); //TrainMethod AddParameter(ParameterType_Choice, "classifier.ann.t", "Train Method Type"); AddChoice("classifier.ann.t.reg", "RPROP algorithm"); AddChoice("classifier.ann.t.back", "Back-propagation algorithm"); SetParameterString("classifier.ann.t", "reg"); SetParameterDescription("classifier.ann.t", "Type of training method for the multilayer perceptron (MLP) neural network."); //LayerSizes //There is no ParameterType_IntList, so i use a ParameterType_StringList and convert it. /*std::vector layerSizes; layerSizes.push_back("100"); layerSizes.push_back("100"); */ AddParameter(ParameterType_StringList, "classifier.ann.sizes", "Number of neurons in each intermediate layer"); //SetParameterStringList("classifier.ann.sizes", layerSizes); SetParameterDescription("classifier.ann.sizes", "The number of neurons in each intermediate layer (excluding input and output layers)."); //ActivateFunction AddParameter(ParameterType_Choice, "classifier.ann.f", "Neuron activation function type"); AddChoice("classifier.ann.f.ident", "Identity function"); AddChoice("classifier.ann.f.sig", "Symmetrical Sigmoid function"); AddChoice("classifier.ann.f.gau", "Gaussian function (Not completely supported)"); SetParameterString("classifier.ann.f", "sig"); SetParameterDescription("classifier.ann.f", "Neuron activation function."); //Alpha AddParameter(ParameterType_Float, "classifier.ann.a", "Alpha parameter of the activation function"); SetParameterFloat("classifier.ann.a", 1.); SetParameterDescription("classifier.ann.a", "Alpha parameter of the activation function (used only with sigmoid and gaussian functions)."); //Beta AddParameter(ParameterType_Float, "classifier.ann.b", "Beta parameter of the activation function"); SetParameterFloat("classifier.ann.b", 1.); SetParameterDescription("classifier.ann.b", "Beta parameter of the activation function (used only with sigmoid and gaussian functions)."); //BackPropDWScale AddParameter(ParameterType_Float, "classifier.ann.bpdw", "Strength of the weight gradient term in the BACKPROP method"); SetParameterFloat("classifier.ann.bpdw", 0.1); SetParameterDescription( "classifier.ann.bpdw", "Strength of the weight gradient term in the BACKPROP method. The recommended value is about 0.1."); //BackPropMomentScale AddParameter(ParameterType_Float, "classifier.ann.bpms", "Strength of the momentum term (the difference between weights on the 2 previous iterations)"); SetParameterFloat("classifier.ann.bpms", 0.1); SetParameterDescription( "classifier.ann.bpms", "Strength of the momentum term (the difference between weights on the 2 previous iterations). " "This parameter provides some inertia to smooth the random fluctuations of the weights. " "It can vary from 0 (the feature is disabled) to 1 and beyond. The value 0.1 or so is good enough."); //RegPropDW0 AddParameter(ParameterType_Float, "classifier.ann.rdw", "Initial value Delta_0 of update-values Delta_{ij} in RPROP method"); SetParameterFloat("classifier.ann.rdw", 0.1); SetParameterDescription("classifier.ann.rdw", "Initial value Delta_0 of update-values Delta_{ij} in RPROP method (default = 0.1)."); //RegPropDWMin AddParameter(ParameterType_Float, "classifier.ann.rdwm", "Update-values lower limit Delta_{min} in RPROP method"); SetParameterFloat("classifier.ann.rdwm", 1e-7); SetParameterDescription( "classifier.ann.rdwm", "Update-values lower limit Delta_{min} in RPROP method. It must be positive (default = 1e-7)."); //TermCriteriaType AddParameter(ParameterType_Choice, "classifier.ann.term", "Termination criteria"); AddChoice("classifier.ann.term.iter", "Maximum number of iterations"); AddChoice("classifier.ann.term.eps", "Epsilon"); AddChoice("classifier.ann.term.all", "Max. iterations + Epsilon"); SetParameterString("classifier.ann.term", "all"); SetParameterDescription("classifier.ann.term", "Termination criteria."); //Epsilon AddParameter(ParameterType_Float, "classifier.ann.eps", "Epsilon value used in the Termination criteria"); SetParameterFloat("classifier.ann.eps", 0.01); SetParameterDescription("classifier.ann.eps", "Epsilon value used in the Termination criteria."); //MaxIter AddParameter(ParameterType_Int, "classifier.ann.iter", "Maximum number of iterations used in the Termination criteria"); SetParameterInt("classifier.ann.iter", 1000); SetParameterDescription("classifier.ann.iter", "Maximum number of iterations used in the Termination criteria."); } template void LearningApplicationBase ::TrainNeuralNetwork(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename NeuralNetworkType::Pointer classifier = NeuralNetworkType::New(); classifier->SetRegressionMode(this->m_RegressionFlag); classifier->SetInputListSample(trainingListSample); classifier->SetTargetListSample(trainingLabeledListSample); switch (GetParameterInt("classifier.ann.t")) { case 0: // RPROP classifier->SetTrainMethod(CvANN_MLP_TrainParams::RPROP); break; case 1: // BACKPROP classifier->SetTrainMethod(CvANN_MLP_TrainParams::BACKPROP); break; default: // DEFAULT = RPROP classifier->SetTrainMethod(CvANN_MLP_TrainParams::RPROP); break; } std::vector layerSizes; std::vector sizes = GetParameterStringList("classifier.ann.sizes"); unsigned int nbImageBands = trainingListSample->GetMeasurementVectorSize(); layerSizes.push_back(nbImageBands); for (unsigned int i = 0; i < sizes.size(); i++) { unsigned int nbNeurons = boost::lexical_cast(sizes[i]); layerSizes.push_back(nbNeurons); } unsigned int nbClasses = 0; if (this->m_RegressionFlag) { layerSizes.push_back(1); } else { std::set labelSet; TargetSampleType currentLabel; for (unsigned int itLab = 0; itLab < trainingLabeledListSample->Size(); ++itLab) { currentLabel = trainingLabeledListSample->GetMeasurementVector(itLab); labelSet.insert(currentLabel[0]); } nbClasses = labelSet.size(); layerSizes.push_back(nbClasses); } classifier->SetLayerSizes(layerSizes); switch (GetParameterInt("classifier.ann.f")) { case 0: // ident classifier->SetActivateFunction(CvANN_MLP::IDENTITY); break; case 1: // sig classifier->SetActivateFunction(CvANN_MLP::SIGMOID_SYM); break; case 2: // gaussian classifier->SetActivateFunction(CvANN_MLP::GAUSSIAN); break; default: // DEFAULT = RPROP classifier->SetActivateFunction(CvANN_MLP::SIGMOID_SYM); break; } classifier->SetAlpha(GetParameterFloat("classifier.ann.a")); classifier->SetBeta(GetParameterFloat("classifier.ann.b")); classifier->SetBackPropDWScale(GetParameterFloat("classifier.ann.bpdw")); classifier->SetBackPropMomentScale(GetParameterFloat("classifier.ann.bpms")); classifier->SetRegPropDW0(GetParameterFloat("classifier.ann.rdw")); classifier->SetRegPropDWMin(GetParameterFloat("classifier.ann.rdwm")); switch (GetParameterInt("classifier.ann.term")) { case 0: // CV_TERMCRIT_ITER classifier->SetTermCriteriaType(CV_TERMCRIT_ITER); break; case 1: // CV_TERMCRIT_EPS classifier->SetTermCriteriaType(CV_TERMCRIT_EPS); break; case 2: // CV_TERMCRIT_ITER + CV_TERMCRIT_EPS classifier->SetTermCriteriaType(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS); break; default: // DEFAULT = CV_TERMCRIT_ITER + CV_TERMCRIT_EPS classifier->SetTermCriteriaType(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS); break; } classifier->SetEpsilon(GetParameterFloat("classifier.ann.eps")); classifier->SetMaxIter(GetParameterInt("classifier.ann.iter")); classifier->Train(); classifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainNormalBayes.txx000066400000000000000000000034011301006202600311550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainNormalBayes_txx #define otbTrainNormalBayes_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitNormalBayesParams() { AddChoice("classifier.bayes", "Normal Bayes classifier"); SetParameterDescription("classifier.bayes", "Use a Normal Bayes Classifier. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/normal_bayes_classifier.html}."); } template void LearningApplicationBase ::TrainNormalBayes(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename NormalBayesType::Pointer classifier = NormalBayesType::New(); classifier->SetRegressionMode(this->m_RegressionFlag); classifier->SetInputListSample(trainingListSample); classifier->SetTargetListSample(trainingLabeledListSample); classifier->Train(); classifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainRandomForests.txx000066400000000000000000000132271301006202600315360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainRandomForests_txx #define otbTrainRandomForests_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitRandomForestsParams() { AddChoice("classifier.rf", "Random forests classifier"); SetParameterDescription("classifier.rf", "This group of parameters allows setting Random Forests classifier parameters. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/random_trees.html}."); //MaxDepth AddParameter(ParameterType_Int, "classifier.rf.max", "Maximum depth of the tree"); SetParameterInt("classifier.rf.max", 5); SetParameterDescription( "classifier.rf.max", "The depth of the tree. A low value will likely underfit and conversely a high value will likely overfit. " "The optimal value can be obtained using cross validation or other suitable methods."); //MinSampleCount AddParameter(ParameterType_Int, "classifier.rf.min", "Minimum number of samples in each node"); SetParameterInt("classifier.rf.min", 10); SetParameterDescription( "classifier.rf.min", "If the number of samples in a node is smaller than this parameter, " "then the node will not be split. A reasonable value is a small percentage of the total data e.g. 1 percent."); //RegressionAccuracy AddParameter(ParameterType_Float, "classifier.rf.ra", "Termination Criteria for regression tree"); SetParameterFloat("classifier.rf.ra", 0.); SetParameterDescription("classifier.rf.ra", "If all absolute differences between an estimated value in a node " "and the values of the train samples in this node are smaller than this regression accuracy parameter, " "then the node will not be split."); //UseSurrogates : don't need to be exposed ! //AddParameter(ParameterType_Empty, "classifier.rf.sur", "Surrogate splits will be built"); //SetParameterDescription("classifier.rf.sur","These splits allow working with missing data and compute variable importance correctly."); //MaxNumberOfCategories AddParameter(ParameterType_Int, "classifier.rf.cat", "Cluster possible values of a categorical variable into K <= cat clusters to find a suboptimal split"); SetParameterInt("classifier.rf.cat", 10); SetParameterDescription( "classifier.rf.cat", "Cluster possible values of a categorical variable into K <= cat clusters to find a suboptimal split."); //Priors are not exposed. //CalculateVariableImportance not exposed //MaxNumberOfVariables AddParameter(ParameterType_Int, "classifier.rf.var", "Size of the randomly selected subset of features at each tree node"); SetParameterInt("classifier.rf.var", 0); SetParameterDescription( "classifier.rf.var", "The size of the subset of features, randomly selected at each tree node, that are used to find the best split(s). " "If you set it to 0, then the size will be set to the square root of the total number of features."); //MaxNumberOfTrees AddParameter(ParameterType_Int, "classifier.rf.nbtrees", "Maximum number of trees in the forest"); SetParameterInt("classifier.rf.nbtrees", 100); SetParameterDescription( "classifier.rf.nbtrees", "The maximum number of trees in the forest. Typically, the more trees you have, the better the accuracy. " "However, the improvement in accuracy generally diminishes and reaches an asymptote for a certain number of trees. " "Also to keep in mind, increasing the number of trees increases the prediction time linearly."); //ForestAccuracy AddParameter(ParameterType_Float, "classifier.rf.acc", "Sufficient accuracy (OOB error)"); SetParameterFloat("classifier.rf.acc", 0.01); SetParameterDescription("classifier.rf.acc","Sufficient accuracy (OOB error)."); //TerminationCriteria not exposed } template void LearningApplicationBase ::TrainRandomForests(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename RandomForestType::Pointer classifier = RandomForestType::New(); classifier->SetRegressionMode(this->m_RegressionFlag); classifier->SetInputListSample(trainingListSample); classifier->SetTargetListSample(trainingLabeledListSample); classifier->SetMaxDepth(GetParameterInt("classifier.rf.max")); classifier->SetMinSampleCount(GetParameterInt("classifier.rf.min")); classifier->SetRegressionAccuracy(GetParameterFloat("classifier.rf.ra")); classifier->SetMaxNumberOfCategories(GetParameterInt("classifier.rf.cat")); classifier->SetMaxNumberOfVariables(GetParameterInt("classifier.rf.var")); classifier->SetMaxNumberOfTrees(GetParameterInt("classifier.rf.nbtrees")); classifier->SetForestAccuracy(GetParameterFloat("classifier.rf.acc")); classifier->Train(); classifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainSVM.txx000066400000000000000000000256761301006202600274300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainSVM_txx #define otbTrainSVM_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitSVMParams() { AddChoice("classifier.svm", "SVM classifier (OpenCV)"); SetParameterDescription("classifier.svm", "This group of parameters allows setting SVM classifier parameters. " "See complete documentation here \\url{http://docs.opencv.org/modules/ml/doc/support_vector_machines.html}."); AddParameter(ParameterType_Choice, "classifier.svm.m", "SVM Model Type"); SetParameterDescription("classifier.svm.m", "Type of SVM formulation."); if (this->m_RegressionFlag) { AddChoice("classifier.svm.m.epssvr", "Epsilon Support Vector Regression"); AddChoice("classifier.svm.m.nusvr", "Nu Support Vector Regression"); SetParameterString("classifier.svm.m", "epssvr"); } else { AddChoice("classifier.svm.m.csvc", "C support vector classification"); AddChoice("classifier.svm.m.nusvc", "Nu support vector classification"); AddChoice("classifier.svm.m.oneclass", "Distribution estimation (One Class SVM)"); SetParameterString("classifier.svm.m", "csvc"); } AddParameter(ParameterType_Choice, "classifier.svm.k", "SVM Kernel Type"); AddChoice("classifier.svm.k.linear", "Linear"); AddChoice("classifier.svm.k.rbf", "Gaussian radial basis function"); AddChoice("classifier.svm.k.poly", "Polynomial"); AddChoice("classifier.svm.k.sigmoid", "Sigmoid"); SetParameterString("classifier.svm.k", "linear"); SetParameterDescription("classifier.svm.k", "SVM Kernel Type."); AddParameter(ParameterType_Float, "classifier.svm.c", "Cost parameter C"); SetParameterFloat("classifier.svm.c", 1.0); SetParameterDescription( "classifier.svm.c", "SVM models have a cost parameter C (1 by default) to control the trade-off between training errors and forcing rigid margins."); AddParameter(ParameterType_Float, "classifier.svm.nu", "Parameter nu of a SVM optimization problem (NU_SVC / ONE_CLASS)"); SetParameterFloat("classifier.svm.nu", 0.0); SetParameterDescription("classifier.svm.nu", "Parameter nu of a SVM optimization problem."); if (this->m_RegressionFlag) { AddParameter(ParameterType_Float, "classifier.svm.p", "Parameter epsilon of a SVM optimization problem (EPS_SVR)"); SetParameterFloat("classifier.svm.p", 1.0); SetParameterDescription("classifier.svm.p", "Parameter epsilon of a SVM optimization problem (EPS_SVR)."); AddParameter(ParameterType_Choice, "classifier.svm.term", "Termination criteria"); SetParameterDescription("classifier.svm.term","Termination criteria for iterative algorithm"); AddChoice("classifier.svm.term.iter", "Stops when maximum iteration is reached."); AddChoice("classifier.svm.term.eps", "Stops when accuracy is lower than epsilon."); AddChoice("classifier.svm.term.all", "Stops when either iteration or epsilon criteria is true"); AddParameter(ParameterType_Float, "classifier.svm.iter", "Maximum iteration"); SetParameterFloat("classifier.svm.iter", 1000); SetParameterDescription("classifier.svm.iter", "Maximum number of iterations (corresponds to the termination criteria 'iter')."); AddParameter(ParameterType_Float, "classifier.svm.eps", "Epsilon accuracy threshold"); SetParameterFloat("classifier.svm.eps", FLT_EPSILON); SetParameterDescription("classifier.svm.eps", "Epsilon accuracy (corresponds to the termination criteria 'eps')."); } AddParameter(ParameterType_Float, "classifier.svm.coef0", "Parameter coef0 of a kernel function (POLY / SIGMOID)"); SetParameterFloat("classifier.svm.coef0", 0.0); SetParameterDescription("classifier.svm.coef0", "Parameter coef0 of a kernel function (POLY / SIGMOID)."); AddParameter(ParameterType_Float, "classifier.svm.gamma", "Parameter gamma of a kernel function (POLY / RBF / SIGMOID)"); SetParameterFloat("classifier.svm.gamma", 1.0); SetParameterDescription("classifier.svm.gamma", "Parameter gamma of a kernel function (POLY / RBF / SIGMOID)."); AddParameter(ParameterType_Float, "classifier.svm.degree", "Parameter degree of a kernel function (POLY)"); SetParameterFloat("classifier.svm.degree", 1.0); SetParameterDescription("classifier.svm.degree", "Parameter degree of a kernel function (POLY)."); AddParameter(ParameterType_Empty, "classifier.svm.opt", "Parameters optimization"); MandatoryOff("classifier.svm.opt"); SetParameterDescription("classifier.svm.opt", "SVM parameters optimization flag.\n-If set to True, then the optimal SVM parameters will be estimated. " "Parameters are considered optimal by OpenCV when the cross-validation estimate of the test set error is minimal. " "Finally, the SVM training process is computed 10 times with these optimal parameters over subsets corresponding to 1/10th of " "the training samples using the k-fold cross-validation (with k = 10).\n-If set to False, the SVM classification process will be " "computed once with the currently set input SVM parameters over the training samples.\n-Thus, even with identical input SVM " "parameters and a similar random seed, the output SVM models will be different according to the method used (optimized or not) " "because the samples are not identically processed within OpenCV."); } template void LearningApplicationBase ::TrainSVM(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename SVMType::Pointer SVMClassifier = SVMType::New(); SVMClassifier->SetRegressionMode(this->m_RegressionFlag); SVMClassifier->SetInputListSample(trainingListSample); SVMClassifier->SetTargetListSample(trainingLabeledListSample); switch (GetParameterInt("classifier.svm.k")) { case 0: // LINEAR SVMClassifier->SetKernelType(CvSVM::LINEAR); std::cout << "CvSVM::LINEAR = " << CvSVM::LINEAR << std::endl; break; case 1: // RBF SVMClassifier->SetKernelType(CvSVM::RBF); std::cout << "CvSVM::RBF = " << CvSVM::RBF << std::endl; break; case 2: // POLY SVMClassifier->SetKernelType(CvSVM::POLY); std::cout << "CvSVM::POLY = " << CvSVM::POLY << std::endl; break; case 3: // SIGMOID SVMClassifier->SetKernelType(CvSVM::SIGMOID); std::cout << "CvSVM::SIGMOID = " << CvSVM::SIGMOID << std::endl; break; default: // DEFAULT = LINEAR SVMClassifier->SetKernelType(CvSVM::LINEAR); std::cout << "CvSVM::LINEAR = " << CvSVM::LINEAR << std::endl; break; } if (this->m_RegressionFlag) { switch (GetParameterInt("classifier.svm.m")) { case 0: // EPS_SVR SVMClassifier->SetSVMType(CvSVM::EPS_SVR); std::cout<<"CvSVM::EPS_SVR = "<SetSVMType(CvSVM::NU_SVR); std::cout<<"CvSVM::NU_SVR = "<SetSVMType(CvSVM::EPS_SVR); std::cout << "CvSVM::EPS_SVR = " << CvSVM::EPS_SVR << std::endl; break; } } else { switch (GetParameterInt("classifier.svm.m")) { case 0: // C_SVC SVMClassifier->SetSVMType(CvSVM::C_SVC); std::cout << "CvSVM::C_SVC = " << CvSVM::C_SVC << std::endl; break; case 1: // NU_SVC SVMClassifier->SetSVMType(CvSVM::NU_SVC); std::cout << "CvSVM::NU_SVC = " << CvSVM::NU_SVC << std::endl; break; case 2: // ONE_CLASS SVMClassifier->SetSVMType(CvSVM::ONE_CLASS); std::cout << "CvSVM::ONE_CLASS = " << CvSVM::ONE_CLASS << std::endl; break; default: // DEFAULT = C_SVC SVMClassifier->SetSVMType(CvSVM::C_SVC); std::cout << "CvSVM::C_SVC = " << CvSVM::C_SVC << std::endl; break; } } SVMClassifier->SetC(GetParameterFloat("classifier.svm.c")); SVMClassifier->SetNu(GetParameterFloat("classifier.svm.nu")); if (this->m_RegressionFlag) { SVMClassifier->SetP(GetParameterFloat("classifier.svm.p")); switch (GetParameterInt("classifier.svm.term")) { case 0: // ITER SVMClassifier->SetTermCriteriaType(CV_TERMCRIT_ITER); break; case 1: // EPS SVMClassifier->SetTermCriteriaType(CV_TERMCRIT_EPS); break; case 2: // ITER+EPS SVMClassifier->SetTermCriteriaType(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS); break; default: SVMClassifier->SetTermCriteriaType(CV_TERMCRIT_ITER); break; } SVMClassifier->SetMaxIter(GetParameterInt("classifier.svm.iter")); SVMClassifier->SetEpsilon(GetParameterFloat("classifier.svm.eps")); } SVMClassifier->SetCoef0(GetParameterFloat("classifier.svm.coef0")); SVMClassifier->SetGamma(GetParameterFloat("classifier.svm.gamma")); SVMClassifier->SetDegree(GetParameterFloat("classifier.svm.degree")); if (IsParameterEnabled("classifier.svm.opt")) { SVMClassifier->SetParameterOptimization(true); } SVMClassifier->Train(); SVMClassifier->Save(modelPath); // Update the displayed parameters in the GUI after the training process, for further use of them SetParameterFloat("classifier.svm.c", static_cast (SVMClassifier->GetOutputC())); SetParameterFloat("classifier.svm.nu", static_cast (SVMClassifier->GetOutputNu())); if (this->m_RegressionFlag) { SetParameterFloat("classifier.svm.p", static_cast (SVMClassifier->GetOutputP())); } SetParameterFloat("classifier.svm.coef0", static_cast (SVMClassifier->GetOutputCoef0())); SetParameterFloat("classifier.svm.gamma", static_cast (SVMClassifier->GetOutputGamma())); SetParameterFloat("classifier.svm.degree", static_cast (SVMClassifier->GetOutputDegree())); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/include/otbTrainSharkRandomForests.txx000066400000000000000000000077541301006202600325370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTrainSharkRandomForests_txx #define otbTrainSharkRandomForests_txx #include "otbLearningApplicationBase.h" namespace otb { namespace Wrapper { template void LearningApplicationBase ::InitSharkRandomForestsParams() { AddChoice("classifier.sharkrf", "Shark Random forests classifier"); SetParameterDescription("classifier.sharkrf", "This group of parameters allows setting Shark Random Forests classifier parameters. " "See complete documentation here \\url{http://image.diku.dk/shark/doxygen_pages/html/classshark_1_1_r_f_trainer.html}.\n It is noteworthy that training is parallel."); //MaxNumberOfTrees AddParameter(ParameterType_Int, "classifier.sharkrf.nbtrees", "Maximum number of trees in the forest"); SetParameterInt("classifier.sharkrf.nbtrees", 100); SetParameterDescription( "classifier.sharkrf.nbtrees", "The maximum number of trees in the forest. Typically, the more trees you have, the better the accuracy. " "However, the improvement in accuracy generally diminishes and reaches an asymptote for a certain number of trees. " "Also to keep in mind, increasing the number of trees increases the prediction time linearly."); //NodeSize AddParameter(ParameterType_Int, "classifier.sharkrf.nodesize", "Min size of the node for a split"); SetParameterInt("classifier.sharkrf.nodesize", 25); SetParameterDescription( "classifier.sharkrf.nodesize", "If the number of samples in a node is smaller than this parameter, " "then the node will not be split. A reasonable value is a small percentage of the total data e.g. 1 percent."); //MTry AddParameter(ParameterType_Int, "classifier.sharkrf.mtry", "Number of features tested at each node"); SetParameterInt("classifier.sharkrf.mtry", 0); SetParameterDescription( "classifier.sharkrf.mtry", "The number of features (variables) which will be tested at each node in " "order to compute the split. If set to zero, the square root of the number of " "features is used."); //OOB Ratio AddParameter(ParameterType_Float, "classifier.sharkrf.oobr", "Out of bound ratio"); SetParameterFloat("classifier.sharkrf.oobr", 0.66); SetParameterDescription("classifier.sharkrf.oobr", "Set the fraction of the original training dataset to use as the out of bag sample." "A good default value is 0.66. "); } template void LearningApplicationBase ::TrainSharkRandomForests(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath) { typename SharkRandomForestType::Pointer classifier = SharkRandomForestType::New(); classifier->SetRegressionMode(this->m_RegressionFlag); classifier->SetInputListSample(trainingListSample); classifier->SetTargetListSample(trainingLabeledListSample); classifier->SetNodeSize(GetParameterInt("classifier.sharkrf.nodesize")); classifier->SetOobRatio(GetParameterFloat("classifier.sharkrf.oobr")); classifier->SetNumberOfTrees(GetParameterInt("classifier.sharkrf.nbtrees")); classifier->SetMTry(GetParameterInt("classifier.sharkrf.mtry")); classifier->Train(); classifier->Save(modelPath); } } //end namespace wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Applications/AppClassification/otb-module.cmake000066400000000000000000000012031301006202600261150ustar00rootroot00000000000000set(DOCUMENTATION "Classification application.") otb_module(OTBAppClassification DEPENDS OTBVectorDataBase OTBConversion OTBStatistics OTBColorMap OTBBoost OTBInterpolation OTBMajorityVoting OTBVectorDataIO OTBSOM OTBSupervised OTBApplicationEngine OTBIndices OTBMathParser OTBITK OTBDempsterShafer OTBGdalAdapters OTBProjection OTBImageBase OTBIOXML OTBVectorDataManipulation OTBStreaming OTBImageManipulation OTBObjectList OTBCommon OTBSampling TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppClassification/test/000077500000000000000000000000001301006202600240275ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppClassification/test/CMakeLists.txt000066400000000000000000001533021301006202600265730ustar00rootroot00000000000000otb_module_test() #----------- ComputeOGRLayersFeaturesStatistics TESTS ---------------- otb_test_application(NAME apTvClComputeOGRLayersFeaturesStatistics APP ComputeOGRLayersFeaturesStatistics OPTIONS -inshp ${INPUTDATA}/Classification/apTvClLabeledVector.shp -feat meanB0 meanB1 meanB2 meanB3 varB0 varB1 varB2 varB3 -outstats ${TEMP}/apTvClComputeOGRLayersFeaturesStatistics.xml VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvClComputeOGRLayersFeaturesStatistics.xml ${TEMP}/apTvClComputeOGRLayersFeaturesStatistics.xml) #----------- SOMClassification TESTS ---------------- otb_test_application(NAME apTvClSOMClassificationSmall APP SOMClassification OPTIONS -in ${INPUTDATA}/poupees_sub.png -rand 121212 -out ${TEMP}/apTvClSOMClassificationSmall.tif uint16 VALID --compare-image ${NOTOL} ${BASELINE}/apTvClSOMClassificationSmall.tif ${TEMP}/apTvClSOMClassificationSmall.tif) otb_test_application(NAME apTvClSOMClassificationFull APP SOMClassification OPTIONS -in ${INPUTDATA}/poupees_sub.png -out ${TEMP}/apTvClSOMClassificationFull.tif uint16 -vm ${INPUTDATA}/poupees_sub_c1.png -tp 0.8 -ts 13000 -som ${TEMP}/apTvClSOMClassificationMap.hdr -sx 30 -sy 30 -nx 9 -ny 9 -ni 5 -bi 1.0 -bf 0.1 -iv 0 -rand 121212 VALID --compare-n-images ${NOTOL} 2 ${BASELINE}/apTvClSOMClassificationFull.tif ${TEMP}/apTvClSOMClassificationFull.tif ${BASELINE}/apTvClSOMClassificationMap.hdr ${TEMP}/apTvClSOMClassificationMap.hdr) #----------- ImageClassifier TESTS ---------------- # Input file types set(raster_input_format ".tif") set(vector_input_format ".shp") set(stat_input_format ".xml") # Input file depending on classifier set(libsvm_input "") set(svm_input "") set(boost_input "Water_Vegetation") set(dt_input "") set(gbt_input "") set(ann_input "") set(bayes_input "") set(rf_input "") set(knn_input "") # Output type set(raster_output_format ".tif") set(raster_output_option "uint8") # Output model type depending on classifier set(libsvm_output_format ".libsvm") set(svm_output_format ".svm") set(boost_output_format ".boost") set(dt_output_format ".dt") set(gbt_output_format ".gbt") set(ann_output_format ".ann") set(bayes_output_format ".bayes") set(rf_output_format ".rf") set(knn_output_format ".knn") set(sharkrf_output_format ".txt") # Training algorithms parameters set(libsvm_parameters "-classifier.libsvm.opt" "true" "-classifier.libsvm.prob" "true") #set(svm_parameters "-classifier.svm.opt" "true") set(boost_parameters "") set(dt_parameters "") set(gbt_parameters "") set(ann_parameters "-classifier.ann.sizes" "100") set(bayes_parameters "") set(rf_parameters "") set(knn_parameters "") set(sharkrf_parameters "") # Validation depending on mode set(ascii_comparison --compare-ascii ${EPSILON_6}) set(raster_comparison --compare-image ${NOTOL}) set(raster_comparison_two --compare-n-images ${NOTOL} 2) # Reference ffiles depending on modes set(ascii_ref_path ${OTBAPP_BASELINE_FILES}) set(raster_ref_path ${OTBAPP_BASELINE}) set(classifierList) #if(OTB_USE_LIBSVM) #list(APPEND classifierList "LIBSVM") #endif() if(OTB_USE_OPENCV) #list(APPEND classifierList "SVM" "BOOST" "DT" "GBT" "ANN" "BAYES" "RF" "KNN") list(APPEND classifierList "BOOST" "DT" "GBT" "ANN" "BAYES" "RF" "KNN") endif() if(OTB_USE_SHARK) list(APPEND classifierList "SHARKRF") endif() set(classifier_with_confmap "LIBSVM" "BOOST" "KNN" "ANN" "RF") # This is a black list for classifier that can not have a baseline # because they are using randomness and seed can not be set set(classifier_without_baseline "SHARKRF") # Loop on classifiers foreach(classifier ${classifierList}) string(TOLOWER ${classifier} lclassifier) # Derive output file name set(OUTMODELFILE cl${classifier}_ModelQB1${${lclassifier}_output_format}) set(OUTRASTER cl${classifier}LabeledImageQB1${raster_output_format}) set(OUTCONFMAP cl${classifier}ConfidenceMapQB1${raster_output_format}) list(FIND classifier_without_baseline ${classifier} _classifier_has_baseline) if(${_classifier_has_baseline} EQUAL -1) set(valid ${ascii_comparison} ${ascii_ref_path}/${OUTMODELFILE} ${TEMP}/${OUTMODELFILE}) else() set(valid "") endif() otb_test_application( NAME apTvClTrainMethod${classifier}ImagesClassifierQB1 APP TrainImagesClassifier OPTIONS -io.il ${INPUTDATA}/Classification/QB_1_ortho${raster_input_format} -io.vd ${INPUTDATA}/Classification/VectorData_${${lclassifier}_input}QB1${vector_input_format} -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB1${stat_input_format} -classifier ${lclassifier} ${${lclassifier}_parameters} -io.out ${TEMP}/${OUTMODELFILE} -rand 121212 VALID ${valid} ) if(${_classifier_has_baseline} EQUAL -1) set(valid ${ascii_comparison} ${ascii_ref_path}/${OUTMODELFILE} ${TEMP}/OutXML1_${OUTMODELFILE}) else() set(valid "") endif() otb_test_application( NAME apTvClTrainMethod${classifier}ImagesClassifierQB1_OutXML1 APP TrainImagesClassifier OPTIONS -io.il ${INPUTDATA}/Classification/QB_1_ortho${raster_input_format} -io.vd ${INPUTDATA}/Classification/VectorData_${${lclassifier}_input}QB1${vector_input_format} -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB1${stat_input_format} -classifier ${lclassifier} ${${lclassifier}_parameters} -io.out ${TEMP}/OutXML1_${OUTMODELFILE} -rand 121212 -outxml ${TEMP}/cl${classifier}_OutXML1.xml VALID ${valid} ) if(${_classifier_has_baseline} EQUAL -1) set(valid ${ascii_comparison} ${ascii_ref_path}/${OUTMODELFILE} ${TEMP}/OutXML2_${OUTMODELFILE}) else() set(valid "") endif() otb_test_application( NAME apTvClTrainMethod${classifier}ImagesClassifierQB1_InXML1 APP TrainImagesClassifier OPTIONS -inxml ${INPUTDATA}/cl${classifier}_OutXML1.xml -io.il ${INPUTDATA}/Classification/QB_1_ortho${raster_input_format} -io.vd ${INPUTDATA}/Classification/VectorData_${${lclassifier}_input}QB1${vector_input_format} -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB1${stat_input_format} -io.out ${TEMP}/OutXML2_${OUTMODELFILE} VALID ${valid} ) #set_tests_properties(apTvClTrainMethod${classifier}ImagesClassifierQB1_InXML1 PROPERTIES DEPENDS apTvClTrainMethod${classifier}ImagesClassifierQB1_OutXML1) list(FIND classifier_with_confmap ${classifier} _classifier_has_confmap) if(${_classifier_has_confmap} EQUAL -1) otb_test_application( NAME apTvClMethod${classifier}ImageClassifierQB1 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho${raster_input_format} -model ${INPUTDATA}/Classification/${OUTMODELFILE} -imstat ${INPUTDATA}/Classification/clImageStatisticsQB1${stat_input_format} -out ${TEMP}/${OUTRASTER} ${raster_output_option} VALID ${raster_comparison} ${raster_ref_path}/${OUTRASTER} ${TEMP}/${OUTRASTER} ) else() otb_test_application( NAME apTvClMethod${classifier}ImageClassifierQB1 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho${raster_input_format} -model ${INPUTDATA}/Classification/${OUTMODELFILE} -imstat ${INPUTDATA}/Classification/clImageStatisticsQB1${stat_input_format} -out ${TEMP}/${OUTRASTER} ${raster_output_option} -confmap ${TEMP}/${OUTCONFMAP} VALID ${raster_comparison_two} ${raster_ref_path}/${OUTRASTER} ${TEMP}/${OUTRASTER} ${raster_ref_path}/${OUTCONFMAP} ${TEMP}/${OUTCONFMAP} ) endif() endforeach() if(OTB_USE_LIBSVM) otb_test_application(NAME apTvClImageSVMClassifierQB2 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_2_ortho.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB1.xml -model ${INPUTDATA}/Classification/clsvmModelQB1.svm -out ${TEMP}/clLabeledImageQB2.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB2.tif ${TEMP}/clLabeledImageQB2.tif) otb_test_application(NAME apTvClImageSVMClassifierQB3 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_3_ortho.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB1.xml -model ${INPUTDATA}/Classification/clsvmModelQB1.svm -out ${TEMP}/clLabeledImageQB3.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB3.tif ${TEMP}/clLabeledImageQB3.tif) otb_test_application(NAME apTvClImageSVMClassifierQB1 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB1.xml -model ${INPUTDATA}/Classification/clsvmModelQB1.svm -out ${TEMP}/clLabeledImageQB1.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB1.tif ${TEMP}/clLabeledImageQB1.tif) otb_test_application(NAME apTvClImageSVMClassifierQB456_6 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_6_extract.tif -mask ${INPUTDATA}/Classification/QB_6_mask.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB456.xml -model ${INPUTDATA}/Classification/clsvmModelQB456.svm -out ${TEMP}/clLabeledImageQB456_6.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB456_6.tif ${TEMP}/clLabeledImageQB456_6.tif) otb_test_application(NAME apTvClImageSVMClassifierQB456_4 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_4_extract.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB456.xml -model ${INPUTDATA}/Classification/clsvmModelQB456.svm -out ${TEMP}/clLabeledImageQB456_4.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB456_4.tif ${TEMP}/clLabeledImageQB456_4.tif) otb_test_application(NAME apTvClImageSVMClassifierQB456_5 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_5_extract.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB456.xml -model ${INPUTDATA}/Classification/clsvmModelQB456.svm -out ${TEMP}/clLabeledImageQB456_5.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB456_5.tif ${TEMP}/clLabeledImageQB456_5.tif) otb_test_application(NAME apTvClImageSVMClassifierQB123_6 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_6_extract.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB123.xml -model ${INPUTDATA}/Classification/clsvmModelQB123.svm -out ${TEMP}/clLabeledImageQB123_6.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB123_6.tif ${TEMP}/clLabeledImageQB123_6.tif) otb_test_application(NAME apTvClImageSVMClassifierQB456_1 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB456.xml -model ${INPUTDATA}/Classification/clsvmModelQB456.svm -out ${TEMP}/clLabeledImageQB456_1.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB456_1.tif ${TEMP}/clLabeledImageQB456_1.tif) otb_test_application(NAME apTvClImageSVMClassifierQB123_3 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_3_ortho.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB123.xml -model ${INPUTDATA}/Classification/clsvmModelQB123.svm -out ${TEMP}/clLabeledImageQB123_3.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB123_3.tif ${TEMP}/clLabeledImageQB123_3.tif) otb_test_application(NAME apTvClImageSVMClassifierQB123_2 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_2_ortho.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB123.xml -model ${INPUTDATA}/Classification/clsvmModelQB123.svm -out ${TEMP}/clLabeledImageQB123_2.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB123_2.tif ${TEMP}/clLabeledImageQB123_2.tif) otb_test_application(NAME apTvClImageSVMClassifierQB123_1 APP ImageClassifier OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho.tif -imstat ${INPUTDATA}/Classification/clImageStatisticsQB123.xml -model ${INPUTDATA}/Classification/clsvmModelQB123.svm -out ${TEMP}/clLabeledImageQB123_1.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB123_1.tif ${TEMP}/clLabeledImageQB123_1.tif) endif() #----------- TrainOGRLayersClassifier TESTS ---------------- otb_test_application(NAME apTvClTrainOGRLayersClassifier APP TrainOGRLayersClassifier OPTIONS -inshp ${INPUTDATA}/Classification/apTvClLabeledVector.shp -feat meanB0 meanB1 meanB2 meanB3 varB0 varB1 varB2 varB3 -instats ${TEMP}/apTvClComputeOGRLayersFeaturesStatistics.xml -outsvm ${TEMP}/apTvClModel.svm VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvClModel.svm ${TEMP}/apTvClModel.svm) set_tests_properties(apTvClTrainOGRLayersClassifier PROPERTIES DEPENDS apTvClComputeOGRLayersFeaturesStatistics) #----------- ComputeConfusionMatrix TESTS ---------------- otb_test_application(NAME apTvComputeConfusionMatrixV APP ComputeConfusionMatrix OPTIONS -in ${OTBAPP_BASELINE}/clLabeledImageQB123_1.tif -ref vector -ref.vector.in ${INPUTDATA}/Classification/VectorData_QB1_ter.shp -ref.vector.field Class -out ${TEMP}/apTvComputeConfusionMatrixTconfusionVOut.csv VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvComputeConfusionMatrixTconfusionVOut.csv ${TEMP}/apTvComputeConfusionMatrixTconfusionVOut.csv) otb_test_application(NAME apTvComputeConfusionMatrixExtraReferenceLabelsV APP ComputeConfusionMatrix OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho_C7.tif -ref vector -ref.vector.in ${INPUTDATA}/Classification/VectorData_QB1_ter.shp -ref.vector.field Class -out ${TEMP}/apTvComputeConfusionMatrixExtraRefLabelsVOut.csv VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvComputeConfusionMatrixExtraRefLabelsVOut.csv ${TEMP}/apTvComputeConfusionMatrixExtraRefLabelsVOut.csv) otb_test_application(NAME apTvComputeConfusionMatrixExtraReferenceLabelsR APP ComputeConfusionMatrix OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho_C7.tif -ref raster -ref.raster.in ${INPUTDATA}/Classification/clLabeledImageQB456_1_NoData_255.tif -nodatalabel 255 -out ${TEMP}/apTvComputeConfusionMatrixExtraRefLabelsROut.csv VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvComputeConfusionMatrixExtraRefLabelsROut.csv ${TEMP}/apTvComputeConfusionMatrixExtraRefLabelsROut.csv) otb_test_application(NAME apTvComputeConfusionMatrixR APP ComputeConfusionMatrix OPTIONS -in ${OTBAPP_BASELINE}/clLabeledImageQB123_1.tif -ref raster -ref.raster.in ${INPUTDATA}/Classification/clLabeledImageQB456_1_NoData_255.tif -nodatalabel 255 -out ${TEMP}/apTvComputeConfusionMatrixTconfusionROut.csv VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvComputeConfusionMatrixTconfusionROut.csv ${TEMP}/apTvComputeConfusionMatrixTconfusionROut.csv) otb_test_application(NAME apTvComputeConfusionMatrixExtraProducedLabelsR APP ComputeConfusionMatrix OPTIONS -in ${INPUTDATA}/Classification/clLabeledImageQB456_1_NoData_255.tif -ref raster -ref.raster.in ${INPUTDATA}/Classification/QB_1_ortho_C8.tif -nodatalabel 255 -out ${TEMP}/apTvComputeConfusionMatrixExtraProdLabelsROut.csv VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvComputeConfusionMatrixExtraProdLabelsROut.csv ${TEMP}/apTvComputeConfusionMatrixExtraProdLabelsROut.csv) #----------- FusionOfClassifications TESTS ---------------- otb_test_application(NAME apTvFusionOfClassificationsDSPrecision6Inputs APP FusionOfClassifications OPTIONS -il ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif -method dempstershafer -method.dempstershafer.cmfl ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv -method.dempstershafer.mob precision -nodatalabel 10 -undecidedlabel 7 -out ${TEMP}/apTvFusionOfClassificationsDS6InputsPrecisionOutput.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_PRECISION.tif ${TEMP}/apTvFusionOfClassificationsDS6InputsPrecisionOutput.tif) otb_test_application(NAME apTvFusionOfClassificationsMV3Inputs APP FusionOfClassifications OPTIONS -il ${INPUTDATA}/Classification/clLabeledImageQB123_1.tif ${INPUTDATA}/Classification/clLabeledImageQB456_1.tif ${INPUTDATA}/Classification/clLabeledImageQB1.tif -method majorityvoting -undecidedlabel 100 -out ${TEMP}/apTvFusionOfClassificationsMV3InputsOutput.tif uint16 VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/apTvFusionOfClassifications3InputsOutput.tif ${TEMP}/apTvFusionOfClassificationsMV3InputsOutput.tif) otb_test_application(NAME apTvFusionOfClassificationsDSKappa6Inputs APP FusionOfClassifications OPTIONS -il ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif -method dempstershafer -method.dempstershafer.cmfl ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv -method.dempstershafer.mob kappa -nodatalabel 10 -undecidedlabel 7 -out ${TEMP}/apTvFusionOfClassificationsDS6InputsKappaOutput.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_KAPPA.tif ${TEMP}/apTvFusionOfClassificationsDS6InputsKappaOutput.tif) otb_test_application(NAME apTvFusionOfClassificationsDSRecall6Inputs APP FusionOfClassifications OPTIONS -il ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif -method dempstershafer -method.dempstershafer.cmfl ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv -method.dempstershafer.mob recall -nodatalabel 10 -undecidedlabel 7 -out ${TEMP}/apTvFusionOfClassificationsDS6InputsRecallOutput.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_RECALL.tif ${TEMP}/apTvFusionOfClassificationsDS6InputsRecallOutput.tif) otb_test_application(NAME apTvFusionOfClassificationsDSAccuracy6Inputs APP FusionOfClassifications OPTIONS -il ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif -method dempstershafer -method.dempstershafer.cmfl ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv -method.dempstershafer.mob accuracy -nodatalabel 10 -undecidedlabel 7 -out ${TEMP}/apTvFusionOfClassificationsDS6InputsAccuracyOutput.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_ACCURACY.tif ${TEMP}/apTvFusionOfClassificationsDS6InputsAccuracyOutput.tif) otb_test_application(NAME apTvFusionOfClassificationsMV2Inputs APP FusionOfClassifications OPTIONS -il ${INPUTDATA}/Classification/clLabeledImageQB123_1.tif ${INPUTDATA}/Classification/clLabeledImageQB456_1.tif -method majorityvoting -undecidedlabel 100 -out ${TEMP}/apTvFusionOfClassificationsMV2InputsOutput.tif uint16 VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/apTvFusionOfClassifications2InputsOutput.tif ${TEMP}/apTvFusionOfClassificationsMV2InputsOutput.tif) #----------- ComputePolylineFeatureFromImage TESTS ---------------- otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_wr APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/NDVI.TIF} -vd LARGEINPUT{DEMPSTER-SHAFER/wrongroads.shp} -expr "(b1 > 0.4)" -field "NONDVI" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_wr.shp) # FIXME cascade dependencies to largeinput repository if(OTB_DATA_USE_LARGEINPUT) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_RoadExtractionApplication APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/SpectralAngleRoad.TIF} -vd ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_RoadExtractionApplication.shp -expr "(b1 > 0.25)" -field "ROADSA" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_RoadExtractionApplication.shp) set_tests_properties(apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_RoadExtractionApplication PROPERTIES DEPENDS apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_RoadExtractionApplication) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_wr APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/SpectralAngleRoad.TIF} -vd ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_wr.shp -expr "(b1 > 0.25)" -field "ROADSA" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_wr.shp) set_tests_properties(apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_wr PROPERTIES DEPENDS apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_wr) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_wr APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/BUILDINGS.TIF} -vd ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_wr.shp -expr "(b1 == 0)" -field "NOBUIL" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_wr.shp VALID --compare-ogr 0.0 ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_wr.shp ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_wr.shp) set_tests_properties(apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_wr PROPERTIES DEPENDS apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_wr) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_RoadExtractionApplication APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/NDVI.TIF} -vd LARGEINPUT{DEMPSTER-SHAFER/road_extraction.shp} -expr "(b1 > 0.4)" -field "NONDVI" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_RoadExtractionApplication.shp) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_gt APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/NDVI.TIF} -vd LARGEINPUT{DEMPSTER-SHAFER/roads_ground_truth.shp} -expr "(b1 > 0.4)" -field NONDVI -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage.shp) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_gt APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/SpectralAngleRoad.TIF} -vd ${TEMP}/apTvCdbComputePolylineFeatureFromImage.shp -expr "(b1 > 0.25)" -field "ROADSA" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_gt.shp) set_tests_properties(apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_gt PROPERTIES DEPENDS apTvCdbComputePolylineFeatureFromImage_LI_NONDVI_gt) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_gt APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/BUILDINGS.TIF} -vd ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_gt.shp -expr "(b1 == 0)" -field "NOBUIL" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp VALID --compare-ogr 0.0 ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp) set_tests_properties(apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_gt PROPERTIES DEPENDS apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_gt) otb_test_application(NAME apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_RoadExtractionApplication APP ComputePolylineFeatureFromImage OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/BUILDINGS.TIF} -vd ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_RoadExtractionApplication.shp -expr "(b1 == 0)" -field "NOBUIL" -out ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_RoadExtractionApplication.shp VALID --compare-ogr 0.0 ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_RoadExtractionApplication.shp ${TEMP}/apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_RoadExtractionApplication.shp) set_tests_properties(apTvCdbComputePolylineFeatureFromImage_LI_NOBUIL_RoadExtractionApplication PROPERTIES DEPENDS apTvCdbComputePolylineFeatureFromImage_LI_ROADSA_RoadExtractionApplication) endif() #----------- KMeansClassification TESTS ---------------- otb_test_application(NAME apTvClKMeansImageClassification APP KMeansClassification OPTIONS -in ${INPUTDATA}/qb_RoadExtract.img -vm ${INPUTDATA}/qb_RoadExtract_mask.png -ts 30000 -nc 5 -maxit 10000 -ct 0.0000001 -rand 121212 -out ${TEMP}/apTvClKMeansImageClassificationFilterOutput.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/apTvClKMeansImageClassificationFilterOutput.tif ${TEMP}/apTvClKMeansImageClassificationFilterOutput.tif ) #----------- TrainImagesClassifier TESTS ---------------- if(OTB_USE_LIBSVM) otb_test_application(NAME apTvClTrainSVMImagesClassifierQB1_allOpt_InXML APP TrainImagesClassifier OPTIONS -inxml ${INPUTDATA}/clsvmModelQB1_OutXML.xml -io.il ${INPUTDATA}/Classification/QB_1_ortho.tif -io.vd ${INPUTDATA}/Classification/VectorData_QB1.shp -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB1.xml -sample.mv 100 -sample.mt 100 -sample.vtr 0.5 -classifier.libsvm.opt true -rand 121212 -io.out ${TEMP}/clsvmModelQB1_allOpt_InXML.svm VALID ${ascii_comparison} ${OTBAPP_BASELINE_FILES}/clsvmModelQB1.svm ${TEMP}/clsvmModelQB1_allOpt_InXML.svm) otb_test_application(NAME apTvClTrainSVMImagesClassifierQB1_OutXML APP TrainImagesClassifier OPTIONS -io.il ${INPUTDATA}/Classification/QB_1_ortho.tif -io.vd ${INPUTDATA}/Classification/VectorData_QB1.shp -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB1.xml -classifier libsvm -classifier.libsvm.opt true -io.out ${TEMP}/clsvmModelQB1_OutXML.svm -rand 121212 -outxml ${TEMP}/clsvmModelQB1_OutXML.xml VALID ${ascii_comparison} ${OTBAPP_BASELINE_FILES}/clsvmModelQB1.svm ${TEMP}/clsvmModelQB1_OutXML.svm) otb_test_application(NAME apTvClTrainSVMImagesClassifierQB123 APP TrainImagesClassifier OPTIONS -io.il ${INPUTDATA}/Classification/QB_1_ortho.tif ${INPUTDATA}/Classification/QB_2_ortho.tif ${INPUTDATA}/Classification/QB_3_ortho.tif -io.vd ${INPUTDATA}/Classification/VectorData_QB1.shp ${INPUTDATA}/Classification/VectorData_QB2.shp ${INPUTDATA}/Classification/VectorData_QB3.shp -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB123.xml -classifier libsvm -classifier.libsvm.opt true -io.out ${TEMP}/clsvmModelQB123.svm -rand 121212) # RK: 09/2016. same reason explained for leTvSVMImageModelEstimatorTrainWithOptimization test # VALID --compare-ascii ${NOTOL} # ${OTBAPP_BASELINE_FILES}/clsvmModelQB123.svm # ${TEMP}/clsvmModelQB123.svm otb_test_application(NAME apTvClTrainSVMImagesClassifierQB1 APP TrainImagesClassifier OPTIONS -io.il ${INPUTDATA}/Classification/QB_1_ortho.tif -io.vd ${INPUTDATA}/Classification/VectorData_QB1.shp -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB1.xml -classifier libsvm -classifier.libsvm.opt true -io.out ${TEMP}/clsvmModelQB1.svm -rand 121212 VALID ${ascii_comparison} ${OTBAPP_BASELINE_FILES}/clsvmModelQB1.svm ${TEMP}/clsvmModelQB1.svm) otb_test_application(NAME apTvClTrainSVMImagesClassifierQB456 APP TrainImagesClassifier OPTIONS -io.il ${INPUTDATA}/Classification/QB_4_extract.tif ${INPUTDATA}/Classification/QB_5_extract.tif ${INPUTDATA}/Classification/QB_6_extract.tif -io.vd ${INPUTDATA}/Classification/VectorData_QB4.shp ${INPUTDATA}/Classification/VectorData_QB5.shp ${INPUTDATA}/Classification/VectorData_QB6.shp -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB456.xml -classifier libsvm -classifier.libsvm.opt true -io.out ${TEMP}/clsvmModelQB456.svm -rand 121212) # RK: 09/2016. same reason explained for leTvSVMImageModelEstimatorTrainWithOptimization test # VALID --compare-ascii ${NOTOL} # ${OTBAPP_BASELINE_FILES}/clsvmModelQB456.svm # ${TEMP}/clsvmModelQB456.svm otb_test_application(NAME apTvClTrainSVMImagesClassifierQB1_allOpt APP TrainImagesClassifier OPTIONS -io.il ${INPUTDATA}/Classification/QB_1_ortho.tif -io.vd ${INPUTDATA}/Classification/VectorData_QB1.shp -io.imstat ${INPUTDATA}/Classification/clImageStatisticsQB1.xml -classifier libsvm -sample.mv 100 -sample.mt 100 -sample.vtr 0.5 -classifier.libsvm.opt true -rand 121212 -io.out ${TEMP}/clsvmModelQB1_allOpt.svm VALID ${ascii_comparison} ${OTBAPP_BASELINE_FILES}/clsvmModelQB1.svm ${TEMP}/clsvmModelQB1_allOpt.svm) endif() #----------- DSFuzzyModelEstimation TESTS ---------------- otb_test_application(NAME apTvCdbDSFuzzyModelEstimation_LI_autoInit APP DSFuzzyModelEstimation OPTIONS -psin ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp -nsin ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_wr.shp -belsup "ROADSA" -plasup "NONDVI" "ROADSA" "NOBUIL" -desclist "NONDVI" "ROADSA" "NOBUIL" -maxnbit 4 -optobs true -out ${TEMP}/apTvCdbDSFuzzyModelEstimatorOutput_LI_autoInit.xml) otb_test_application(NAME apTvCdbDSFuzzyModelEstimation_LI APP DSFuzzyModelEstimation OPTIONS -psin ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp -nsin ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_wr.shp -belsup "ROADSA" -plasup "NONDVI" "ROADSA" "NOBUIL" -initmod ${OTB_DATA_ROOT}/Input/Dempster-Shafer/DSFuzzyModel_Init.xml -maxnbit 4 -optobs true -out ${TEMP}/apTvCdbDSFuzzyModelEstimatorOutput_LI.xml) #----------- ClassificationMapRegularization TESTS ---------------- otb_test_application(NAME apTvClassificationMapRegularization APP ClassificationMapRegularization OPTIONS -io.in ${OTBAPP_BASELINE}/clLabeledImageQB123_1.tif -io.out ${TEMP}/clLabeledImageQB123_1_CMR_r2_nodl_10_undl_7.tif -ip.radius 2 -ip.suvbool true -ip.nodatalabel 10 -ip.undecidedlabel 7 VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledImageQB123_1_CMR_r2_nodl_10_undl_7.tif ${TEMP}/clLabeledImageQB123_1_CMR_r2_nodl_10_undl_7.tif) #----------- OGRLayerClassifier TESTS ---------------- #----------- ComputeImagesStatistics TESTS ---------------- otb_test_application(NAME apTvClComputeImagesStatisticsQB1 APP ComputeImagesStatistics OPTIONS -il ${INPUTDATA}/Classification/QB_1_ortho.tif -out ${TEMP}/apTvClEstimateImageStatisticsQB1.xml VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/clImageStatisticsQB1.xml ${TEMP}/apTvClEstimateImageStatisticsQB1.xml) otb_test_application(NAME apTvClComputeImagesStatisticsQB456 APP ComputeImagesStatistics OPTIONS -il ${INPUTDATA}/Classification/QB_4_extract.tif ${INPUTDATA}/Classification/QB_5_extract.tif ${INPUTDATA}/Classification/QB_6_extract.tif -out ${TEMP}/apTvClEstimateImageStatisticsQB456.xml VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/clImageStatisticsQB456.xml ${TEMP}/apTvClEstimateImageStatisticsQB456.xml) otb_test_application(NAME apTvClComputeImagesStatisticsQB123 APP ComputeImagesStatistics OPTIONS -il ${INPUTDATA}/Classification/QB_1_ortho.tif ${INPUTDATA}/Classification/QB_2_ortho.tif ${INPUTDATA}/Classification/QB_3_ortho.tif -out ${TEMP}/apTvClEstimateImageStatisticsQB123.xml VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/clImageStatisticsQB123.xml ${TEMP}/apTvClEstimateImageStatisticsQB123.xml) #----------- VectorDataDSValidation TESTS ---------------- otb_test_application(NAME cdbTvVectorDataDSValidationGroundTruth_LI APP VectorDataDSValidation OPTIONS -in ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp -belsup "ROADSA" -plasup "NONDVI" "ROADSA" "NOBUIL" -descmod ${OTB_DATA_ROOT}/Input/Dempster-Shafer/DSFuzzyModel.xml -out ${TEMP}/cdbTvVectorDataDSValidationOutpout_LI_gt.shp VALID --compare-ogr 0.0 ${OTBAPP_BASELINE_FILES}/cdbTvVectorDataDSValidationOutpout_LI_gt.shp ${TEMP}/cdbTvVectorDataDSValidationOutpout_LI_gt.shp) otb_test_application(NAME apTvCdbVectorDataDSValidationRoadExtractionApplication_LI APP VectorDataDSValidation OPTIONS -in ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_RoadExtractionApplication.shp -belsup "ROADSA" -plasup "NONDVI" "ROADSA" "NOBUIL" -descmod ${OTB_DATA_ROOT}/Input/Dempster-Shafer/DSFuzzyModel.xml -out ${TEMP}/apTvCdbVectorDataDSValidationOutpout_LI_RoadExtractionApplication.shp) otb_test_application(NAME cdbTvVectorDataDSValidationWrongRoads_LI APP VectorDataDSValidation OPTIONS -in ${OTBAPP_BASELINE_FILES}/cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_wr.shp -belsup "ROADSA" -plasup "NONDVI" "ROADSA" "NOBUIL" -descmod ${OTB_DATA_ROOT}/Input/Dempster-Shafer/DSFuzzyModel.xml -out ${TEMP}/cdbTvVectorDataDSValidationOutpout_LI_wr.shp VALID --compare-ogr 0.0 ${OTBAPP_BASELINE_FILES}/cdbTvVectorDataDSValidationOutpout_LI_wr.shp ${TEMP}/cdbTvVectorDataDSValidationOutpout_LI_wr.shp) if(OTB_USE_OPENCV) #----------- TrainRegression TESTS ---------------- # y = 0.01*x^2 + 1.5*x - 300 otb_test_application(NAME apTvClTrainRegressionTest_monovar APP TrainRegression OPTIONS -io.il ${INPUTDATA}/QB_Toulouse_Ortho_regression.tif -io.imstat ${INPUTDATA}/QB_Toulouse_Ortho_regression.xml -io.out ${TEMP}/apTvClTrainRegressionTest_monovar.rf -sample.mt 20000 -sample.mv 20000 -sample.vtr 0.5 -rand 121212 -classifier rf -classifier.rf.ra 0.0001 -classifier.rf.max 6 -classifier.rf.acc 0.0005 VALID ${ascii_comparison} ${OTBAPP_BASELINE_FILES}/apTvClTrainRegressionTest_monovar.rf ${TEMP}/apTvClTrainRegressionTest_monovar.rf) #----------- PredictRegression TESTS ---------------- otb_test_application(NAME apTvClPredictRegressionTest_monovar APP PredictRegression OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -model ${OTBAPP_BASELINE_FILES}/apTvClTrainRegressionTest_monovar.rf -imstat ${INPUTDATA}/QB_Toulouse_Ortho_regression.xml -out ${TEMP}/apTvClPredictRegressionTest_monovar.tif VALID --compare-image 1 ${OTBAPP_BASELINE}/apTvClPredictRegressionTest_monovar.tif ${TEMP}/apTvClPredictRegressionTest_monovar.tif) endif() #----------- PolygonClassStatistics TESTS ---------------- otb_test_application(NAME apTvClPolygonClassStatisticsTest APP PolygonClassStatistics OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho.tif -vec ${INPUTDATA}/Classification/VectorData_QB1.shp -field Class -out ${TEMP}/apTvClPolygonClassStatisticsOut.xml VALID --compare-ascii ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvClPolygonClassStatisticsOut.xml ${TEMP}/apTvClPolygonClassStatisticsOut.xml) #----------- SampleSelection TESTS ----------------------- otb_test_application(NAME apTvClSampleSelection APP SampleSelection OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho.tif -vec ${INPUTDATA}/Classification/VectorData_QB1.shp -field Class -out ${TEMP}/apTvClSampleSelectionOut.sqlite -instats ${OTBAPP_BASELINE_FILES}/apTvClPolygonClassStatisticsOut.xml -outrates ${TEMP}/apTvClSampleSelectionOutRates.txt -strategy byclass -strategy.byclass.in ${INPUTDATA}/Classification/sampling_required.csv -sampler periodic VALID --compare-ogr ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvClSampleSelectionOut.sqlite ${TEMP}/apTvClSampleSelectionOut.sqlite) #----------- SampleExtraction TESTS ----------------------- otb_test_application(NAME apTvClSampleExtraction APP SampleExtraction OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho.tif -vec ${INPUTDATA}/Classification/apTvClSampleSelectionOut.sqlite -field Class -out ${TEMP}/apTvClSampleExtractionOut.sqlite VALID --compare-ogr ${NOTOL} ${OTBAPP_BASELINE_FILES}/apTvClSampleExtractionOut.sqlite ${TEMP}/apTvClSampleExtractionOut.sqlite) #----------- TrainVectorClassifier TESTS ---------------- if(OTB_USE_OPENCV) otb_test_application(NAME apTvClTrainVectorClassifier APP TrainVectorClassifier OPTIONS -io.vd ${INPUTDATA}/Classification/apTvClSampleExtractionOut.sqlite -feat value_0 value_1 value_2 value_3 -cfield class -classifier rf -io.confmatout ${TEMP}/apTvClTrainVectorClassifierConfMat.txt -io.out ${TEMP}/apTvClTrainVectorClassifierModel.rf VALID ${ascii_comparison} ${OTBAPP_BASELINE_FILES}/apTvClTrainVectorClassifierModel.rf ${TEMP}/apTvClTrainVectorClassifierModel.rf) endif() #------------ MultiImageSamplingRate TESTS ---------------- otb_test_application( NAME apTvClMultiImageSamplingRate APP MultiImageSamplingRate OPTIONS -il ${INPUTDATA}/Classification/vector_stats_QB1.xml ${INPUTDATA}/Classification/vector_stats_QB2.xml ${INPUTDATA}/Classification/vector_stats_QB3.xml -out ${TEMP}/apTvClMultiImageSamplingRate_out.csv -strategy constant -strategy.constant.nb "300" -mim proportional VALID --compare-n-ascii ${NOTOL} 3 ${OTBAPP_BASELINE_FILES}/apTvClMultiImageSamplingRate_out_1.csv ${TEMP}/apTvClMultiImageSamplingRate_out_1.csv ${OTBAPP_BASELINE_FILES}/apTvClMultiImageSamplingRate_out_2.csv ${TEMP}/apTvClMultiImageSamplingRate_out_2.csv ${OTBAPP_BASELINE_FILES}/apTvClMultiImageSamplingRate_out_3.csv ${TEMP}/apTvClMultiImageSamplingRate_out_3.csv ) OTB-release-5.8/Modules/Applications/AppDescriptors/000077500000000000000000000000001301006202600224165ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppDescriptors/CMakeLists.txt000066400000000000000000000000551301006202600251560ustar00rootroot00000000000000project(OTBAppDescriptors) otb_module_impl() OTB-release-5.8/Modules/Applications/AppDescriptors/app/000077500000000000000000000000001301006202600231765ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppDescriptors/app/CMakeLists.txt000066400000000000000000000005671301006202600257460ustar00rootroot00000000000000set(OTBAppDescriptors_LINK_LIBS ${OTBGdalAdapters_LIBRARIES} ${OTBDescriptors_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBGDAL_LIBRARIES} ) otb_create_application( NAME HomologousPointsExtraction SOURCES otbHomologousPointsExtraction.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppDescriptors/app/otbHomologousPointsExtraction.cxx000066400000000000000000000526511301006202600320310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" #ifdef OTB_USE_SIFTFAST #include "otbSiftFastImageFilter.h" #else #include "otbImageToSIFTKeyPointSetFilter.h" #endif #include "otbImageToSURFKeyPointSetFilter.h" #include "otbKeyPointSetsMatchingFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbKeyPointSetsMatchingFilter.h" #include "otbGenericRSTransform.h" #include "otbOGRDataSourceWrapper.h" #include "ogrsf_frmts.h" namespace otb { namespace Wrapper { class HomologousPointsExtraction: public Application { public: /** Standard class typedefs. */ typedef HomologousPointsExtraction Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef FloatVectorImageType::PixelType RealVectorType; typedef FloatVectorImageType::InternalPixelType ValueType; typedef itk::PointSet PointSetType; // This is ugly ... #ifdef OTB_USE_SIFTFAST typedef SiftFastImageFilter SiftFilterType; #else typedef ImageToSIFTKeyPointSetFilter SiftFilterType; #endif typedef ImageToSURFKeyPointSetFilter SurfFilterType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::KeyPointSetsMatchingFilter MatchingFilterType; typedef MatchingFilterType::LandmarkListType LandmarkListType; typedef PointSetType::PointType PointType; typedef otb::MultiToMonoChannelExtractROI ExtractChannelFilterType; typedef otb::GenericRSTransform<> RSTransformType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(HomologousPointsExtraction, otb::Wrapper::Application); private: void DoInit() ITK_OVERRIDE { SetName("HomologousPointsExtraction"); SetDocName("Homologous points extraction"); SetDescription("Compute homologous points between images using keypoints"); SetDocLongDescription("This application allows computing homologous points between images using keypoints. " " SIFT or SURF keypoints can be used and the band on which keypoints are computed can be set independently for both images." " The application offers two modes :" " the first is the full mode where keypoints are extracted from the full extent of both images" " (please note that in this mode large image file are not supported). " "The second mode, called geobins, allows one to set-up spatial binning to get fewer points" " spread across the entire image. " "In this mode, the corresponding spatial bin in the second image is estimated using geographical" " transform or sensor modelling, and is padded according to the user defined precision. Last, in" " both modes the application can filter matches whose colocalisation in first image exceed this precision. " "The elevation parameters are to deal more precisely with sensor modelling in case of sensor geometry data. " "The outvector option allows creating a vector file with segments corresponding to the localisation error between the matches." " It can be useful to assess the precision of a registration for instance." " The vector file is always reprojected to EPSG:4326 to allow display in a GIS." " This is done via reprojection or by applying the image sensor models."); // Documentation SetDocName("Homologous Points Extraction"); SetDocLimitations("Full mode does not handle large images."); SetDocSeeAlso("RefineSensorModel"); SetDocAuthors("OTB-Team"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in1", "Input Image 1"); SetParameterDescription("in1"," First input image"); AddParameter(ParameterType_Int,"band1","Input band 1"); SetParameterDescription("band1","Index of the band from input image 1 to use for keypoints extraction"); SetMinimumParameterIntValue("band1",1); SetDefaultParameterInt("band1",1); AddParameter(ParameterType_InputImage, "in2", "Input Image 2"); SetParameterDescription("in2"," Second input image"); AddParameter(ParameterType_Int,"band2","Input band 2"); SetParameterDescription("band2","Index of the band from input image 1 to use for keypoints extraction"); SetMinimumParameterIntValue("band2",1); SetDefaultParameterInt("band2",1); AddParameter(ParameterType_Choice,"algorithm","Keypoints detection algorithm"); SetParameterDescription("algorithm","Choice of the detection algorithm to use"); AddChoice("algorithm.surf","SURF algorithm"); AddChoice("algorithm.sift","SIFT algorithm"); AddParameter(ParameterType_Float,"threshold","Distance threshold for matching"); SetParameterDescription("threshold","The distance threshold for matching."); SetMinimumParameterFloatValue("threshold",0.0); SetDefaultParameterFloat("threshold",0.6); AddParameter(ParameterType_Empty,"backmatching","Use back-matching to filter matches."); SetParameterDescription("backmatching","If set to true, matches should be consistent in both ways."); MandatoryOff("backmatching"); DisableParameter("backmatching"); AddParameter(ParameterType_Choice,"mode","Keypoints search mode"); AddChoice("mode.full","Extract and match all keypoints (no streaming)"); SetParameterDescription("mode.full","Extract and match all keypoints, loading both images entirely into memory"); AddChoice("mode.geobins","Search keypoints in small spatial bins regularly spread across first image"); SetParameterDescription("mode.geobins","This method allows retrieving a set of tie points regulary spread across image 1. Corresponding bins in image 2 are retrieved using sensor and geographical information if available. The first bin position takes into account the margin parameter. Bins are cropped to the largest image region shrunk by the margin parameter for both in1 and in2 images."); AddParameter(ParameterType_Int,"mode.geobins.binsize","Size of bin"); SetParameterDescription("mode.geobins.binsize","Radius of the spatial bin in pixels"); SetDefaultParameterInt("mode.geobins.binsize",256); SetMinimumParameterIntValue("mode.geobins.binsize",1); AddParameter(ParameterType_Int,"mode.geobins.binsizey","Size of bin (y direction)"); SetParameterDescription("mode.geobins.binsizey","Radius of the spatial bin in pixels (y direction). If not set, the mode.geobins.binsize value is used."); SetMinimumParameterIntValue("mode.geobins.binsizey",1); MandatoryOff("mode.geobins.binsizey"); AddParameter(ParameterType_Int,"mode.geobins.binstep","Steps between bins"); SetParameterDescription("mode.geobins.binstep","Steps between bins in pixels"); SetDefaultParameterInt("mode.geobins.binstep",256); SetMinimumParameterIntValue("mode.geobins.binstep",1); AddParameter(ParameterType_Int,"mode.geobins.binstepy","Steps between bins (y direction)"); SetParameterDescription("mode.geobins.binstepy","Steps between bins in pixels (y direction). If not set, the mode.geobins.binstep value is used."); SetMinimumParameterIntValue("mode.geobins.binstepy",1); MandatoryOff("mode.geobins.binstepy"); AddParameter(ParameterType_Int,"mode.geobins.margin","Margin from image border to start/end bins (in pixels)"); SetParameterDescription("mode.geobins.margin","Margin from image border to start/end bins (in pixels)"); SetMinimumParameterIntValue("mode.geobins.margin",0); SetDefaultParameterInt("mode.geobins.margin",10); AddParameter(ParameterType_Float,"precision","Estimated precision of the colocalisation function (in pixels)."); SetParameterDescription("precision","Estimated precision of the colocalisation function in pixels"); SetDefaultParameterFloat("precision",0.); AddParameter(ParameterType_Empty,"mfilter","Filter points according to geographical or sensor based colocalisation"); SetParameterDescription("mfilter","If enabled, this option allows one to filter matches according to colocalisation from sensor or geographical information, using the given tolerancy expressed in pixels"); AddParameter(ParameterType_Empty,"2wgs84","If enabled, points from second image will be exported in WGS84"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); AddParameter(ParameterType_OutputFilename,"out","Output file with tie points"); SetParameterDescription("out","File containing the list of tie points"); AddParameter(ParameterType_OutputFilename,"outvector","Output vector file with tie points"); SetParameterDescription("outvector","File containing segments representing matches "); MandatoryOff("outvector"); DisableParameter("outvector"); // Doc example parameter settings SetDocExampleParameterValue("in1", "sensor_stereo_left.tif"); SetDocExampleParameterValue("in2","sensor_stereo_right.tif"); SetDocExampleParameterValue("mode","full"); SetDocExampleParameterValue("out","homologous.txt"); } void DoUpdateParameters() ITK_OVERRIDE { } void Match(FloatImageType * im1, FloatImageType * im2, RSTransformType * rsTransform, RSTransformType * rsTransform1ToWGS84,RSTransformType * rsTransform2ToWGS84, std::ofstream & file, OGRMultiLineString * mls = ITK_NULLPTR) { MatchingFilterType::Pointer matchingFilter = MatchingFilterType::New(); if(GetParameterString("algorithm")=="sift") { otbAppLogINFO("Using SIFT points"); SiftFilterType::Pointer sift1 = SiftFilterType::New(); sift1->SetInput(im1); SiftFilterType::Pointer sift2 = SiftFilterType::New(); sift2->SetInput(im2); sift1->Update(); otbAppLogINFO("Found " << sift1->GetOutput()->GetNumberOfPoints()<<" sift points in image 1."); sift2->Update(); otbAppLogINFO("Found " << sift2->GetOutput()->GetNumberOfPoints()<<" sift points in image 2."); matchingFilter->SetInput1(sift1->GetOutput()); matchingFilter->SetInput2(sift2->GetOutput()); } else if(GetParameterString("algorithm")=="surf") { SurfFilterType::Pointer surf1 = SurfFilterType::New(); surf1->SetInput(im1); SurfFilterType::Pointer surf2 = SurfFilterType::New(); surf2->SetInput(im2); otbAppLogINFO("Doing update"); surf1->Update(); otbAppLogINFO("Found " << surf1->GetOutput()->GetNumberOfPoints()<<" surf points in image 1."); surf2->Update(); otbAppLogINFO("Found " << surf2->GetOutput()->GetNumberOfPoints()<<" surf points in image 2."); matchingFilter->SetInput1(surf1->GetOutput()); matchingFilter->SetInput2(surf2->GetOutput()); matchingFilter->SetDistanceThreshold(GetParameterFloat("threshold")); matchingFilter->SetUseBackMatching(IsParameterEnabled("backmatching")); } try { matchingFilter->Update(); LandmarkListType::Pointer landmarks = matchingFilter->GetOutput(); otbAppLogINFO("Found " << landmarks->Size() <<" homologous points."); unsigned int discarded = 0; for (LandmarkListType::Iterator it = landmarks->Begin(); it != landmarks->End(); ++it) { PointType point1 = it.Get()->GetPoint1(); PointType point2 = it.Get()->GetPoint2(); double error = 0; PointType pprime1,pprime2; bool filtered = false; if(IsParameterEnabled("mfilter")) { pprime1 = rsTransform->TransformPoint(point1); error = vcl_sqrt((point2[0]-pprime1[0])*(point2[0]-pprime1[0])+(point2[1]-pprime1[1])*(point2[1]-pprime1[1])); if(error>GetParameterFloat("precision")*vcl_sqrt(vcl_abs(im2->GetSpacing()[0]*im2->GetSpacing()[1]))) { filtered = true; } } if(!filtered) { if(IsParameterEnabled("2wgs84")) { pprime2 = rsTransform2ToWGS84->TransformPoint(point2); file<TransformPoint(point1); pprime2 = rsTransform2ToWGS84->TransformPoint(point2); OGRLineString ls; ls.addPoint(pprime1[0],pprime1[1]); ls.addPoint(pprime2[0],pprime2[1]); mls->addGeometry(&ls); } } else { ++discarded; } } otbAppLogINFO(<GetParameterImage("in1"); FloatVectorImageType::Pointer image2 = this->GetParameterImage("in2"); // Setting up RS Transform RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetInputKeywordList(image1->GetImageKeywordlist()); rsTransform->SetInputProjectionRef(image1->GetProjectionRef()); rsTransform->SetOutputKeywordList(image2->GetImageKeywordlist()); rsTransform->SetOutputProjectionRef(image2->GetProjectionRef()); RSTransformType::Pointer rsTransform1ToWGS84 = RSTransformType::New(); rsTransform1ToWGS84->SetInputKeywordList(image1->GetImageKeywordlist()); rsTransform1ToWGS84->SetInputProjectionRef(image1->GetProjectionRef()); RSTransformType::Pointer rsTransform2ToWGS84 = RSTransformType::New(); rsTransform2ToWGS84->SetInputKeywordList(image2->GetImageKeywordlist()); rsTransform2ToWGS84->SetInputProjectionRef(image2->GetProjectionRef()); // Setting up output file std::ofstream file; file.open(GetParameterString("out").c_str()); file<SetInput(image1); extractChannel1->SetChannel(GetParameterInt("band1")); ExtractChannelFilterType::Pointer extractChannel2 = ExtractChannelFilterType::New(); extractChannel2->SetInput(image2); extractChannel2->SetChannel(GetParameterInt("band2")); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); rsTransform->InstantiateTransform(); rsTransform1ToWGS84->InstantiateTransform(); rsTransform2ToWGS84->InstantiateTransform(); if(GetParameterString("mode")=="full") { // Launch detection on whole images Match(extractChannel1->GetOutput(),extractChannel2->GetOutput(),rsTransform,rsTransform1ToWGS84,rsTransform2ToWGS84,file,&mls); } else if(GetParameterString("mode")=="geobins") { // Compute binning on first image FloatImageType::SizeType size = image1->GetLargestPossibleRegion().GetSize(); unsigned int bin_size_x = GetParameterInt("mode.geobins.binsize"); unsigned int bin_size_y = bin_size_x; unsigned int image_border_margin = GetParameterInt("mode.geobins.margin"); if(IsParameterEnabled("mode.geobins.binsizey")) { bin_size_y = GetParameterInt("mode.geobins.binsizey"); } unsigned int bin_step_x = GetParameterInt("mode.geobins.binstep"); unsigned int bin_step_y = bin_step_x; if(IsParameterEnabled("mode.geobins.binstepy")) { bin_step_y = GetParameterInt("mode.geobins.binstepy"); } unsigned int nb_bins_x = static_cast(vcl_ceil(static_cast(size[0]-2*image_border_margin)/(bin_size_x + bin_step_x))); unsigned int nb_bins_y = static_cast(vcl_ceil(static_cast(size[1]-2*image_border_margin)/(bin_size_y + bin_step_y))); for(unsigned int i = 0; iGetLargestPossibleRegion(); largestRegion.ShrinkByRadius(image_border_margin); region1.Crop(largestRegion); otbAppLogINFO("("<SetExtractionRegion(region1); // We need to find the corresponding region in image 2 itk::ContinuousIndex ul_i, ur_i, lr_i, ll_i; FloatImageType::PointType ul1, ur1, ll1, lr1, p1, p2, p3, p4; itk::ContinuousIndex i1, i2, i3, i4, i_min, i_max; ul_i[0] = static_cast(startx) - 0.5; ul_i[1] = static_cast(starty) - 0.5; ur_i = ul_i; lr_i = ul_i; ll_i = ul_i; ur_i[0] += static_cast(bin_size_x); lr_i[0] += static_cast(bin_size_x); lr_i[1] += static_cast(bin_size_y); ll_i[1] += static_cast(bin_size_y); image1->TransformContinuousIndexToPhysicalPoint(ul_i,ul1); image1->TransformContinuousIndexToPhysicalPoint(ur_i,ur1); image1->TransformContinuousIndexToPhysicalPoint(lr_i,lr1); image1->TransformContinuousIndexToPhysicalPoint(ll_i,ll1); p1 = rsTransform->TransformPoint(ul1); p2 = rsTransform->TransformPoint(ur1); p3 = rsTransform->TransformPoint(lr1); p4 = rsTransform->TransformPoint(ll1); image2->TransformPhysicalPointToContinuousIndex(p1,i1); image2->TransformPhysicalPointToContinuousIndex(p2,i2); image2->TransformPhysicalPointToContinuousIndex(p3,i3); image2->TransformPhysicalPointToContinuousIndex(p4,i4); i_min[0] = std::min(std::min(i1[0],i2[0]),std::min(i3[0],i4[0])); i_min[1] = std::min(std::min(i1[1],i2[1]),std::min(i3[1],i4[1])); i_max[0] = std::max(std::max(i1[0],i2[0]),std::max(i3[0],i4[0])); i_max[1] = std::max(std::max(i1[1],i2[1]),std::max(i3[1],i4[1])); FloatImageType::IndexType index2; FloatImageType::SizeType size2; index2[0] = vcl_floor(i_min[0]); index2[1] = vcl_floor(i_min[1]); size2[0] = vcl_ceil(i_max[0]-i_min[0]); size2[1] = vcl_ceil(i_max[1]-i_min[1]); FloatImageType::RegionType region2; region2.SetIndex(index2); region2.SetSize(size2); region2.PadByRadius(static_cast(GetParameterInt("precision"))); FloatImageType::RegionType largestRegion2 = image2->GetLargestPossibleRegion(); largestRegion2.ShrinkByRadius(image_border_margin); if(region2.Crop(largestRegion2)) { otbAppLogINFO("Corresponding region2 is "<SetExtractionRegion(region2); Match(extractChannel1->GetOutput(),extractChannel2->GetOutput(),rsTransform,rsTransform1ToWGS84,rsTransform2ToWGS84,file,&mls); } else { otbAppLogINFO("Corresponding region2 is out of range: "<CreateLayer("matches", &oSRS, wkbMultiLineString); OGRFeatureDefn & defn = layer.GetLayerDefn(); ogr::Feature feature(defn); feature.SetGeometry(&mls); layer.CreateFeature(feature); } } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::HomologousPointsExtraction) OTB-release-5.8/Modules/Applications/AppDescriptors/otb-module.cmake000066400000000000000000000005021301006202600254640ustar00rootroot00000000000000set(DOCUMENTATION "Descritors application( see also Descriptors module).") otb_module(OTBAppDescriptors DEPENDS OTBGdalAdapters OTBDescriptors OTBTransform OTBApplicationEngine OTBImageBase OTBGDAL TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppDescriptors/test/000077500000000000000000000000001301006202600233755ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppDescriptors/test/CMakeLists.txt000066400000000000000000000060041301006202600261350ustar00rootroot00000000000000otb_module_test() #----------- HomologousPointsExtraction TESTS ---------------- otb_test_application(NAME apTvHomologousPointsExtractionGeoBinsAnisotropic APP HomologousPointsExtraction OPTIONS -in1 ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -in2 ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -algorithm surf -mode geobins -mode.geobins.binsize 100 -mode.geobins.binsizey 150 -mode.geobins.binstep 25 -mode.geobins.binstepy 10 -mode.geobins.margin 12 -mfilter 1 -precision 10 -2wgs84 1 -elev.dem ${INPUTDATA}/DEM/srtm_directory -elev.geoid ${INPUTDATA}/DEM/egm96.grd -out ${TEMP}/apTvHomologousPointsExtractionGeoBinsAnisotropic.txt VALID --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/apTvHomologousPointsExtractionGeoBinsAnisotropic.txt ${TEMP}/apTvHomologousPointsExtractionGeoBinsAnisotropic.txt) otb_test_application(NAME apTvHomologousPointsExtractionFull APP HomologousPointsExtraction OPTIONS -in1 ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -in2 ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -algorithm surf -out ${TEMP}/apTvHomologousPointsExtractionFull.txt VALID --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/apTvHomologousPointsExtractionFull.txt ${TEMP}/apTvHomologousPointsExtractionFull.txt) otb_test_application(NAME apTvHomologousPointsExtractionGeoBins APP HomologousPointsExtraction OPTIONS -in1 ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -in2 ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -algorithm surf -mode geobins -mode.geobins.binsize 100 -mode.geobins.binstep 25 -mode.geobins.margin 12 -mfilter 1 -precision 10 -2wgs84 1 -elev.dem ${INPUTDATA}/DEM/srtm_directory -elev.geoid ${INPUTDATA}/DEM/egm96.grd -out ${TEMP}/apTvHomologousPointsExtractionGeoBins.txt VALID --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/apTvHomologousPointsExtractionGeoBins.txt ${TEMP}/apTvHomologousPointsExtractionGeoBins.txt) OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/000077500000000000000000000000001301006202600247625ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/CMakeLists.txt000066400000000000000000000000711301006202600275200ustar00rootroot00000000000000project(OTBAppDimensionalityReduction) otb_module_impl() OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/app/000077500000000000000000000000001301006202600255425ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/app/CMakeLists.txt000066400000000000000000000005341301006202600303040ustar00rootroot00000000000000set(OTBAppDimensionalityReduction_LINK_LIBS ${OTBImageManipulation_LIBRARIES} ${OTBStatistics_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBDimensionalityReduction_LIBRARIES} ) otb_create_application( NAME DimensionalityReduction SOURCES otbDimensionalityReduction.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/app/otbDimensionalityReduction.cxx000066400000000000000000000451521301006202600336470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMaximumAutocorrelationFactorImageFilter.h" #include "otbNAPCAImageFilter.h" #include "otbLocalActivityVectorImageFilter.h" #include "otbMaximumAutocorrelationFactorImageFilter.h" #include "otbFastICAImageFilter.h" //#include "otbVirtualDimensionality.h" #include "otbStreamingMinMaxVectorImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" namespace otb { namespace Wrapper { class DimensionalityReduction: public Application { public: /** Standard class typedefs. */ typedef DimensionalityReduction Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // Dimensionality reduction typedef typedef otb::MaximumAutocorrelationFactorImageFilter MAFFilterType; typedef itk::ImageToImageFilter DimensionalityReductionFilter; // Reduction dimensio filters typedef otb::PCAImageFilter PCAForwardFilterType; typedef otb::PCAImageFilter PCAInverseFilterType; //typedef otb::PCAImageFilter< FloatVectorImageType, FloatVectorImageType, otb::Transform::FORWARD > typedef otb::LocalActivityVectorImageFilter NoiseFilterType; typedef otb::NAPCAImageFilter NAPCAForwardFilterType; typedef otb::NAPCAImageFilter NAPCAInverseFilterType; typedef otb::MaximumAutocorrelationFactorImageFilter MAFForwardFilterType; typedef otb::FastICAImageFilter ICAForwardFilterType; typedef otb::FastICAImageFilter ICAInverseFilterType; typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef StreamingStatisticsVectorImageFilterType::MatrixObjectType::ComponentType MatrixType; //typedef otb::VirtualDimensionality VDFilterType; // output rescale typedef otb::StreamingMinMaxVectorImageFilter MinMaxFilterType; typedef otb::VectorRescaleIntensityImageFilter RescaleImageFilterType; /** Standard macro */ itkNewMacro(Self) ; itkTypeMacro(DimensionalityReduction, otb::Wrapper::Application) ; private: void DoInit() ITK_OVERRIDE { SetName("DimensionalityReduction"); SetDescription("Perform Dimension reduction of the input image."); SetDocName("Dimensionality reduction"); SetDocLongDescription("Performs dimensionality reduction on input image. PCA,NA-PCA,MAF,ICA methods are available. It is also possible to compute the inverse transform to reconstruct the image. It is also possible to optionnaly export the transformation matrix to a text file."); SetDocLimitations("This application does not provide the inverse transform and the transformation matrix export for the MAF."); SetDocAuthors("OTB-Team"); SetDocSeeAlso( "\"Kernel maximum autocorrelation factor and minimum noise fraction transformations,\" IEEE Transactions on Image Processing, vol. 20, no. 3, pp. 612-624, (2011)"); AddDocTag(Tags::DimensionReduction); AddDocTag(Tags::Filter); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to apply dimensionality reduction."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "output image. Components are ordered by decreasing eigenvalues."); MandatoryOff("out"); AddParameter(ParameterType_Group, "rescale", "Rescale Output."); MandatoryOff("rescale"); // AddChoice("rescale.no","No rescale"); // AddChoice("rescale.minmax","rescale to min max value"); AddParameter(ParameterType_Float, "rescale.outmin", "Output min value"); AddParameter(ParameterType_Float, "rescale.outmax", "Output max value"); SetDefaultParameterFloat("rescale.outmin", 0.0); SetParameterDescription("rescale.outmin", "Minimum value of the output image."); SetDefaultParameterFloat("rescale.outmax", 255.0); SetParameterDescription("rescale.outmax", "Maximum value of the output image."); AddParameter(ParameterType_OutputImage, "outinv", " Inverse Output Image"); SetParameterDescription("outinv", "reconstruct output image."); MandatoryOff("outinv"); AddParameter(ParameterType_Choice, "method", "Algorithm"); SetParameterDescription("method", "Selection of the reduction dimension method."); AddChoice("method.pca", "PCA"); SetParameterDescription("method.pca", "Principal Component Analysis."); AddChoice("method.napca", "NA-PCA"); SetParameterDescription("method.napca", "Noise Adjusted Principal Component Analysis."); AddParameter(ParameterType_Int, "method.napca.radiusx", "Set the x radius of the sliding window."); SetMinimumParameterIntValue("method.napca.radiusx", 1); SetDefaultParameterInt("method.napca.radiusx", 1); AddParameter(ParameterType_Int, "method.napca.radiusy", "Set the y radius of the sliding window."); SetMinimumParameterIntValue("method.napca.radiusy", 1); SetDefaultParameterInt("method.napca.radiusy", 1); AddChoice("method.maf", "MAF"); SetParameterDescription("method.maf", "Maximum Autocorrelation Factor."); AddChoice("method.ica", "ICA"); SetParameterDescription("method.ica", "Independent Component Analysis."); AddParameter(ParameterType_Int, "method.ica.iter", "number of iterations "); SetMinimumParameterIntValue("method.ica.iter", 1); SetDefaultParameterInt("method.ica.iter", 20); MandatoryOff("method.ica.iter"); AddParameter(ParameterType_Float, "method.ica.mu", "Give the increment weight of W in [0, 1]"); SetMinimumParameterFloatValue("method.ica.mu", 0.); SetMaximumParameterFloatValue("method.ica.mu", 1.); SetDefaultParameterFloat("method.ica.mu", 1.); MandatoryOff("method.ica.mu"); //AddChoice("method.vd","virual Dimension"); //SetParameterDescription("method.vd","Virtual Dimension."); //MandatoryOff("method"); AddParameter(ParameterType_Int, "nbcomp", "Number of Components."); SetParameterDescription("nbcomp", "Number of relevant components kept. By default all components are kept."); SetDefaultParameterInt("nbcomp", 0); MandatoryOff("nbcomp"); SetMinimumParameterIntValue("nbcomp", 0); AddParameter(ParameterType_Empty, "normalize", "Normalize."); SetParameterDescription("normalize", "center AND reduce data before Dimensionality reduction."); MandatoryOff("normalize"); AddParameter(ParameterType_OutputFilename, "outmatrix", "Transformation matrix output (text format)"); SetParameterDescription("outmatrix", "Filename to store the transformation matrix (csv format)"); MandatoryOff("outmatrix"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "cupriteSubHsi.tif"); SetDocExampleParameterValue("out", "FilterOutput.tif"); SetDocExampleParameterValue("method", "pca"); } void DoUpdateParameters() ITK_OVERRIDE { if (HasValue("in")) { FloatVectorImageType::Pointer inImage = this->GetParameterImage("in"); inImage->UpdateOutputInformation(); // Update the values of the channels to be selected unsigned int nbComponents = inImage->GetNumberOfComponentsPerPixel(); unsigned int nbComp = static_cast (GetParameterInt("nbcomp")); if (nbComp > nbComponents) { SetParameterInt("nbcomp", nbComponents); otbAppLogINFO( << "number of selected components can't exceed image dimension : "<GetParameterString("outinv").size()!= 0) { otbAppLogWARNING(<<"This application only provides the forward transform for the MAF method."); this->SetParameterString("outinv", ""); } this->DisableParameter("outinv"); if (this->GetParameterString("outmatrix").size()!= 0) { otbAppLogWARNING(<<"No transformation matrix available for MAF method."); this->SetParameterString("outmatrix", ""); } this->DisableParameter("outmatrix"); FloatVectorImageType::Pointer inImage = this->GetParameterImage("in"); inImage->UpdateOutputInformation(); // Update the values of the channels to be selected unsigned int nbComponents = inImage->GetNumberOfComponentsPerPixel(); unsigned int nbComp = static_cast (GetParameterInt("nbcomp")); if ((nbComp != 0) && (nbComp != nbComponents)) { SetParameterInt("nbcomp", nbComponents); otbAppLogINFO( << "all components are kept when using MAF filter method."); } } } void DoExecute() ITK_OVERRIDE { // Get Parameters int nbComp = GetParameterInt("nbcomp"); bool normalize = IsParameterEnabled("normalize"); bool rescale = IsParameterEnabled("rescale"); bool invTransform = HasValue("outinv") && IsParameterEnabled("outinv"); switch (GetParameterInt("method")) { // PCA Algorithm case 0: { otbAppLogDEBUG( << "PCA Algorithm "); PCAForwardFilterType::Pointer filter = PCAForwardFilterType::New(); m_ForwardFilter = filter; PCAInverseFilterType::Pointer invFilter = PCAInverseFilterType::New(); m_InverseFilter = invFilter; filter->SetInput(GetParameterFloatVectorImage("in")); filter->SetNumberOfPrincipalComponentsRequired(nbComp); filter->SetUseNormalization(normalize); m_ForwardFilter->GetOutput()->UpdateOutputInformation(); if (invTransform) { invFilter->SetInput(m_ForwardFilter->GetOutput()); if (normalize) { otbAppLogINFO( << "Normalization MeanValue:"<GetMeanValues() ); invFilter->SetMeanValues(filter->GetMeanValues()); // By default normalization by std dev is deactivated in //forward filter, and GetStdDevValues() returns an empty //vector, which confuses the invFilter. //invFilter->SetStdDevValues(filter->GetStdDevValues()); } invFilter->SetTransformationMatrix(filter->GetTransformationMatrix()); m_TransformationMatrix = invFilter->GetTransformationMatrix(); } m_TransformationMatrix = filter->GetTransformationMatrix(); break; } case 1: { otbAppLogDEBUG( << "NA-PCA Algorithm "); // NA-PCA unsigned int radiusX = static_cast (GetParameterInt("method.napca.radiusx")); unsigned int radiusY = static_cast (GetParameterInt("method.napca.radiusy")); // Noise filtering NoiseFilterType::RadiusType radius = { { radiusX, radiusY } }; NAPCAForwardFilterType::Pointer filter = NAPCAForwardFilterType::New(); m_ForwardFilter = filter; NAPCAInverseFilterType::Pointer invFilter = NAPCAInverseFilterType::New(); m_InverseFilter = invFilter; filter->SetInput(GetParameterFloatVectorImage("in")); filter->SetNumberOfPrincipalComponentsRequired(nbComp); filter->SetUseNormalization(normalize); filter->GetNoiseImageFilter()->SetRadius(radius); m_ForwardFilter->GetOutput()->UpdateOutputInformation(); if (invTransform) { otbAppLogDEBUG( << "Compute Inverse Transform"); invFilter->SetInput(m_ForwardFilter->GetOutput()); otbAppLogINFO( << "Normalization MeanValue:"<GetMeanValues() ); invFilter->SetMeanValues(filter->GetMeanValues()); if (normalize) { otbAppLogINFO( << "Normalization StdDevValue:"<GetStdDevValues() ); invFilter->SetStdDevValues(filter->GetStdDevValues()); } invFilter->SetUseNormalization(normalize); invFilter->SetTransformationMatrix(filter->GetTransformationMatrix()); m_TransformationMatrix = invFilter->GetTransformationMatrix(); } m_TransformationMatrix = filter->GetTransformationMatrix(); break; } case 2: { otbAppLogDEBUG( << "MAF Algorithm "); MAFForwardFilterType::Pointer filter = MAFForwardFilterType::New(); m_ForwardFilter = filter; filter->SetInput(GetParameterFloatVectorImage("in")); otbAppLogINFO( << "V :"<GetV()<<"Auto-Correlation :"<GetAutoCorrelation() ); break; } case 3: { otbAppLogDEBUG( << "Fast ICA Algorithm "); unsigned int nbIterations = static_cast (GetParameterInt("method.ica.iter")); double mu = static_cast (GetParameterFloat("method.ica.mu")); ICAForwardFilterType::Pointer filter = ICAForwardFilterType::New(); m_ForwardFilter = filter; ICAInverseFilterType::Pointer invFilter = ICAInverseFilterType::New(); m_InverseFilter = invFilter; filter->SetInput(GetParameterFloatVectorImage("in")); filter->SetNumberOfPrincipalComponentsRequired(nbComp); filter->SetNumberOfIterations(nbIterations); filter->SetMu(mu); m_ForwardFilter->GetOutput()->UpdateOutputInformation(); if (invTransform) { otbAppLogDEBUG( << "Compute Inverse Transform"); invFilter->SetInput(m_ForwardFilter->GetOutput()); otbAppLogINFO( << "Normalization MeanValue:"<GetMeanValues() ); invFilter->SetMeanValues(filter->GetMeanValues()); otbAppLogINFO( << "Normalization StdDevValue:"<GetStdDevValues() ); invFilter->SetStdDevValues(filter->GetStdDevValues()); invFilter->SetPCATransformationMatrix(filter->GetPCATransformationMatrix()); invFilter->SetTransformationMatrix(filter->GetTransformationMatrix()); } m_TransformationMatrix = filter->GetTransformationMatrix(); break; } /* case 4: { otbAppLogDEBUG( << "VD Algorithm"); break; }*/ default: { otbAppLogFATAL(<<"non defined method "<DisableParameter("outinv"); otbAppLogWARNING(<<"This application only provides the forward transform for the MAF method."); } else SetParameterOutputImage("outinv", m_InverseFilter->GetOutput()); } //Write transformation matrix if (this->GetParameterString("outmatrix").size() != 0) { if (GetParameterInt("method") == 2) //MAF or VD { otbAppLogWARNING(<<"No transformation matrix available for MAF."); } else { //Write transformation matrix std::ofstream outFile; outFile.open(this->GetParameterString("outmatrix").c_str()); outFile << std::fixed; outFile.precision(10); outFile << m_TransformationMatrix; outFile.close(); } } if (!rescale) { SetParameterOutputImage("out", m_ForwardFilter->GetOutput()); } else { otbAppLogDEBUG( << "Rescaling " ) otbAppLogDEBUG( << "Starting Min/Max computation" ) m_MinMaxFilter = MinMaxFilterType::New(); m_MinMaxFilter->SetInput(m_ForwardFilter->GetOutput()); //m_MinMaxFilter->GetStreamer()->SetNumberOfLinesStrippedStreaming(50); m_MinMaxFilter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(m_MinMaxFilter->GetStreamer(), "Min/Max computing"); m_MinMaxFilter->Update(); otbAppLogDEBUG( << "Min/Max computation done : min=" << m_MinMaxFilter->GetMinimum() << " max=" << m_MinMaxFilter->GetMaximum() ) FloatVectorImageType::PixelType inMin, inMax; m_RescaleFilter = RescaleImageFilterType::New(); m_RescaleFilter->SetInput(m_ForwardFilter->GetOutput()); m_RescaleFilter->SetInputMinimum(m_MinMaxFilter->GetMinimum()); m_RescaleFilter->SetInputMaximum(m_MinMaxFilter->GetMaximum()); FloatVectorImageType::PixelType outMin, outMax; outMin.SetSize(m_ForwardFilter->GetOutput()->GetNumberOfComponentsPerPixel()); outMax.SetSize(m_ForwardFilter->GetOutput()->GetNumberOfComponentsPerPixel()); outMin.Fill(GetParameterFloat("rescale.outmin")); outMax.Fill(GetParameterFloat("rescale.outmax")); m_RescaleFilter->SetOutputMinimum(outMin); m_RescaleFilter->SetOutputMaximum(outMax); m_RescaleFilter->UpdateOutputInformation(); SetParameterOutputImage("out", m_RescaleFilter->GetOutput()); } } MinMaxFilterType::Pointer m_MinMaxFilter; RescaleImageFilterType::Pointer m_RescaleFilter; DimensionalityReductionFilter::Pointer m_ForwardFilter; DimensionalityReductionFilter::Pointer m_InverseFilter; MatrixType m_TransformationMatrix; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::DimensionalityReduction) OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/otb-module.cmake000066400000000000000000000005351301006202600300360ustar00rootroot00000000000000set(DOCUMENTATION "Dimensionality reduction application( see also DimensionalityReduction module).") otb_module(OTBAppDimensionalityReduction DEPENDS OTBImageManipulation OTBStatistics OTBApplicationEngine OTBDimensionalityReduction TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/test/000077500000000000000000000000001301006202600257415ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppDimensionalityReduction/test/CMakeLists.txt000066400000000000000000000020721301006202600305020ustar00rootroot00000000000000otb_module_test() #----------- DimensionalityReduction TESTS ---------------- otb_test_application(NAME apTvFEDimensionalityReductionMAF APP DimensionalityReduction OPTIONS -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/apTvFEDimensionalityReductionMAF.tif -method maf VALID --compare-image 0.025 ${BASELINE}/bfTvMaximumAutocorrelationFactorImageFilterOutput.tif ${TEMP}/apTvFEDimensionalityReductionMAF.tif) otb_test_application(NAME apTvFEDimensionalityReductionPCA APP DimensionalityReduction OPTIONS -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/apTvChDimensionalityReductionPCA.tif -method pca VALID --compare-image 0.025 ${BASELINE}/bfTvPCAImageFilter3.tif ${TEMP}/apTvChDimensionalityReductionPCA.tif) OTB-release-5.8/Modules/Applications/AppEdge/000077500000000000000000000000001301006202600207615ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppEdge/CMakeLists.txt000066400000000000000000000000461301006202600235210ustar00rootroot00000000000000project(OTBAppEdge) otb_module_impl() OTB-release-5.8/Modules/Applications/AppEdge/app/000077500000000000000000000000001301006202600215415ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppEdge/app/CMakeLists.txt000066400000000000000000000007661301006202600243120ustar00rootroot00000000000000set(OTBAppEdge_LINK_LIBS ${OTBStatistics_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBEdge_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ) otb_create_application( NAME LineSegmentDetection SOURCES otbLineSegmentDetection.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME EdgeExtraction SOURCES otbEdgeExtraction.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppEdge/app/otbEdgeExtraction.cxx000066400000000000000000000157341301006202600257110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "itkGradientMagnitudeImageFilter.h" #include "itkSobelEdgeDetectionImageFilter.h" //#include "itkCannyEdgeDetectionImageFilter.h" #include "otbTouziEdgeDetectorImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" namespace otb { namespace Wrapper { class EdgeExtraction : public Application { public: /** Standard class typedefs. */ typedef EdgeExtraction Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef MultiToMonoChannelExtractROI ExtractorFilterType; typedef itk::GradientMagnitudeImageFilter GradientFilterType; typedef itk::SobelEdgeDetectionImageFilter SobelFilterType; //typedef itk::CannyEdgeDetectionImageFilter // CannyFilterType; typedef TouziEdgeDetectorImageFilter TouziFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(EdgeExtraction, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("EdgeExtraction"); SetDescription("Computes edge features on every pixel of the input image selected channel"); // Documentation SetDocName("Edge Feature Extraction"); SetDocLongDescription("This application computes edge features on a mono band image"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otb class"); AddDocTag("Edge"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to compute the features on."); AddParameter(ParameterType_Int, "channel", "Selected Channel"); SetParameterDescription("channel", "The selected channel index"); SetDefaultParameterInt("channel", 1); SetMinimumParameterIntValue("channel", 1); AddRAMParameter(); AddParameter(ParameterType_Choice, "filter", "Edge feature"); SetParameterDescription("filter", "Choice of edge feature"); //Gradient Section AddChoice("filter.gradient", "Gradient"); //Sobel Section AddChoice("filter.sobel", "Sobel"); //Touzi Section AddChoice("filter.touzi", "Touzi"); AddParameter(ParameterType_Int, "filter.touzi.xradius", "The X Radius"); SetDefaultParameterInt("filter.touzi.xradius", 1); AddParameter(ParameterType_Int, "filter.touzi.yradius", "The Y Radius"); SetDefaultParameterInt("filter.touzi.yradius", 1); //Canny Section /* AddChoice("filter.canny", "Canny"); AddParameter(ParameterType_Float, "filter.canny.variance", ""); SetDefaultParameterFloat("filter.canny.variance", 1.0); AddParameter(ParameterType_Float, "filter.canny.maximumerror", ""); SetDefaultParameterFloat("filter.canny.maximumerror", 0.01); AddParameter(ParameterType_Float, "filter.canny.upperthreshold", ""); SetDefaultParameterFloat("filter.canny.upperthreshold", 15.0); AddParameter(ParameterType_Float, "filter.canny.lowerthreshold", ""); SetDefaultParameterFloat("filter.canny.lowerthreshold", 3.0); */ AddParameter(ParameterType_OutputImage, "out", "Feature Output Image"); SetParameterDescription("out", "Output image containing the edge features."); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("channel", "1"); SetDocExampleParameterValue("out", "Edges.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); int nbChan = inImage->GetNumberOfComponentsPerPixel(); if( GetParameterInt("channel") > nbChan ) { otbAppLogCRITICAL("Selected band is not available..."); return; } const std::string edgeType = GetParameterString("filter"); m_ExtractorFilter = ExtractorFilterType::New(); m_ExtractorFilter->SetInput(inImage); m_ExtractorFilter->SetStartX(inImage->GetLargestPossibleRegion().GetIndex(0)); m_ExtractorFilter->SetStartY(inImage->GetLargestPossibleRegion().GetIndex(1)); m_ExtractorFilter->SetSizeX(inImage->GetLargestPossibleRegion().GetSize(0)); m_ExtractorFilter->SetSizeY(inImage->GetLargestPossibleRegion().GetSize(1)); m_ExtractorFilter->SetChannel(GetParameterInt("channel")); m_ExtractorFilter->UpdateOutputInformation(); m_GradientFilter = GradientFilterType::New(); m_SobelFilter = SobelFilterType::New(); m_TouziFilter = TouziFilterType::New(); //m_CannyFilter = CannyFilterType::New(); if( edgeType == "gradient" ) { m_GradientFilter->SetInput(const_cast(m_ExtractorFilter->GetOutput())); SetParameterOutputImage("out", m_GradientFilter->GetOutput()); } if( edgeType == "sobel" ) { m_SobelFilter->SetInput(const_cast(m_ExtractorFilter->GetOutput())); SetParameterOutputImage("out", m_SobelFilter->GetOutput()); } if( edgeType == "touzi" ) { m_TouziFilter->SetInput(const_cast(m_ExtractorFilter->GetOutput())); TouziFilterType::SizeType rad; rad[0] = this->GetParameterInt("filter.touzi.xradius"); rad[1] = this->GetParameterInt("filter.touzi.yradius"); m_TouziFilter->SetRadius(rad); SetParameterOutputImage("out", m_TouziFilter->GetOutput()); } /* if( edgeType == "canny" ) { m_CannyFilter->SetInput(const_cast(m_ExtractorFilter->GetOutput())); m_CannyFilter->SetVariance(GetParameterFloat("filter.canny.variance")); m_CannyFilter->SetMaximumError(GetParameterFloat("filter.canny.maximumerror")); m_CannyFilter->SetUpperThreshold(GetParameterFloat("filter.canny.upperthreshold")); m_CannyFilter->SetLowerThreshold(GetParameterFloat("filter.canny.lowerthreshold")); SetParameterOutputImage("out", m_CannyFilter->GetOutput()); } */ } ExtractorFilterType::Pointer m_ExtractorFilter; GradientFilterType::Pointer m_GradientFilter; SobelFilterType::Pointer m_SobelFilter; TouziFilterType::Pointer m_TouziFilter; //CannyFilterType::Pointer m_CannyFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::EdgeExtraction) OTB-release-5.8/Modules/Applications/AppEdge/app/otbLineSegmentDetection.cxx000066400000000000000000000151101301006202600270410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbStreamingLineSegmentDetector.h" #include "otbVectorImageToAmplitudeImageFilter.h" #include "otbStreamingStatisticsImageFilter.h" #include "itkShiftScaleImageFilter.h" #include "otbVectorDataProjectionFilter.h" #include "otbVectorDataTransformFilter.h" #include "itkAffineTransform.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class LineSegmentDetection: public Application { public: /** Standard class typedefs. */ typedef LineSegmentDetection Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(LineSegmentDetection, otb::Wrapper::Application); private: void DoInit() ITK_OVERRIDE { SetName("LineSegmentDetection"); SetDescription("Detect line segments in raster"); // Documentation SetDocName("Line segment detection"); SetDocLongDescription("This application detects locally straight contours in a image. It is based on Burns, Hanson, and Riseman method and use an a contrario validation approach (Desolneux, Moisan, and Morel). The algorithm was published by Rafael Gromponevon Gioi, Jérémie Jakubowicz, Jean-Michel Morel and Gregory Randall.\n The given approach computes gradient and level lines of the image and detects aligned points in line support region. The application allows exporting the detected lines in a vector data."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("On Line demonstration of the LSD algorithm is available here: http://www.ipol.im/pub/algo/gjmr_line_segment_detector/\n"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in"," Input image on which lines will be detected."); AddParameter(ParameterType_OutputVectorData, "out", "Output Detected lines"); SetParameterDescription("out"," Output detected line segments (vector data)."); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); AddParameter(ParameterType_Empty, "norescale", "No rescaling in [0, 255]"); SetParameterDescription("norescale","By default, the input image amplitude is rescaled between [0,255]. Turn on this parameter to skip rescaling"); MandatoryOff("norescale"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Suburb.png"); SetDocExampleParameterValue("out", "LineSegmentDetection.shp"); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { typedef otb::VectorImageToAmplitudeImageFilter VectorImageToAmplitudeImageFilterType; typedef otb::StreamingStatisticsImageFilter StreamingStatisticsImageFilterType; typedef itk::ShiftScaleImageFilter ShiftScaleImageFilterType; typedef otb::StreamingLineSegmentDetector < FloatImageType >::FilterType LSDFilterType; VectorImageToAmplitudeImageFilterType::Pointer amplitudeConverter = VectorImageToAmplitudeImageFilterType::New(); amplitudeConverter->SetInput( GetParameterImage("in") ); FloatImageType::Pointer image = amplitudeConverter->GetOutput(); StreamingStatisticsImageFilterType::Pointer stats = StreamingStatisticsImageFilterType::New(); ShiftScaleImageFilterType::Pointer shiftScale = ShiftScaleImageFilterType::New(); // Default behavior is to do the rescaling if ( !IsParameterEnabled("norescale") ) { stats->SetInput(amplitudeConverter->GetOutput()); stats->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(stats->GetStreamer(), "Image statistics"); stats->Update(); FloatImageType::PixelType min = stats->GetMinimum(); FloatImageType::PixelType max = stats->GetMaximum(); shiftScale->SetInput(amplitudeConverter->GetOutput()); shiftScale->SetShift( -min ); shiftScale->SetScale( 255.0 / (max - min) ); image = shiftScale->GetOutput(); } LSDFilterType::Pointer lsd = LSDFilterType::New(); lsd->GetFilter()->SetInput(image); lsd->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(lsd->GetStreamer(), "Running Line Segment Detector"); lsd->Update(); /* * Reprojection of the output VectorData * * The output of LSDFilterType is in image physical coordinates, * projection WKT applied if the input image has one * * We need to reproject in WGS84 if the input image is in sensor model geometry */ std::string projRef = GetParameterImage("in")->GetProjectionRef(); ImageKeywordlist kwl = GetParameterImage("in")->GetImageKeywordlist(); VectorDataType::Pointer vd = lsd->GetFilter()->GetOutputVectorData(); VectorDataType::Pointer projectedVD = vd; if ( projRef.empty() && kwl.GetSize() > 0 ) { // image is in sensor model geometry // Reproject VectorData in image projection typedef otb::VectorDataProjectionFilter VectorDataProjectionFilterType; VectorDataProjectionFilterType::Pointer vproj = VectorDataProjectionFilterType::New(); vproj->SetInput(vd); vproj->SetInputKeywordList(GetParameterImage("in")->GetImageKeywordlist()); //vproj->SetInputOrigin(GetParameterImage("in")->GetOrigin()); //vproj->SetInputSpacing(GetParameterImage("in")->GetSpacing()); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); AddProcess(vproj, "Reprojecting output vector data"); vproj->Update(); projectedVD = vproj->GetOutput(); } SetParameterOutputVectorData("out", projectedVD); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::LineSegmentDetection) OTB-release-5.8/Modules/Applications/AppEdge/otb-module.cmake000066400000000000000000000005231301006202600240320ustar00rootroot00000000000000set(DOCUMENTATION "Edge detection and extraction application (see also Edge module).") otb_module(OTBAppEdge DEPENDS OTBStatistics OTBITK OTBImageBase OTBApplicationEngine OTBEdge OTBImageManipulation OTBProjection TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppEdge/test/000077500000000000000000000000001301006202600217405ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppEdge/test/CMakeLists.txt000066400000000000000000000031431301006202600245010ustar00rootroot00000000000000otb_module_test() #----------- LineSegmentDetection TESTS ---------------- otb_test_application(NAME apTvFeLineSegmentDetectionNoRescale APP LineSegmentDetection OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/ROI_QB_TOULOUSE.TIF} -out ${TEMP}/feTvLineSegmentDetection_LI_NoRescale.shp -norescale true VALID --compare-ogr ${EPSILON_9} ${OTBAPP_BASELINE_FILES}/feTvLineSegmentDetection_LI_NoRescale.shp ${TEMP}/feTvLineSegmentDetection_LI_NoRescale.shp) otb_test_application(NAME apTvFeLineSegmentDetection APP LineSegmentDetection OPTIONS -in LARGEINPUT{DEMPSTER-SHAFER/ROI_QB_TOULOUSE.TIF} -out ${TEMP}/feTvLineSegmentDetection_LI.shp VALID --compare-ogr ${EPSILON_9} ${OTBAPP_BASELINE_FILES}/feTvLineSegmentDetection_LI.shp ${TEMP}/feTvLineSegmentDetection_LI.shp) #----------- EdgeExtraction TESTS ---------------- otb_test_application(NAME apTvFEEdgeExtraction APP EdgeExtraction OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -channel 1 -filter sobel -out ${TEMP}/apTvFEEdgeExtraction.tif VALID --compare-image ${NOTOL} ${BASELINE}/apTvFEEdgeExtraction.tif ${TEMP}/apTvFEEdgeExtraction.tif) OTB-release-5.8/Modules/Applications/AppFiltering/000077500000000000000000000000001301006202600220405ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppFiltering/CMakeLists.txt000066400000000000000000000000531301006202600245760ustar00rootroot00000000000000project(OTBAppFiltering) otb_module_impl() OTB-release-5.8/Modules/Applications/AppFiltering/app/000077500000000000000000000000001301006202600226205ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppFiltering/app/CMakeLists.txt000066400000000000000000000006471301006202600253670ustar00rootroot00000000000000set(OTBAppFiltering_LINK_LIBS ${OTBImageNoise_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBImageBase_LIBRARIES} ) otb_create_application( NAME Despeckle SOURCES otbDespeckle.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME Smoothing SOURCES otbSmoothing.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppFiltering/app/otbDespeckle.cxx000066400000000000000000000171061301006202600257550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbFrostImageFilter.h" #include "otbLeeImageFilter.h" #include "otbGammaMAPImageFilter.h" #include "otbKuanImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" namespace otb { namespace Wrapper { class Despeckle : public Application { public: /** Standard class typedefs. */ typedef Despeckle Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ImageToImageFilter SpeckleFilterType; typedef LeeImageFilter LeeFilterType; typedef FrostImageFilter FrostFilterType; typedef GammaMAPImageFilter GammaMAPFilterType; typedef KuanImageFilter KuanFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Despeckle, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("Despeckle"); SetDescription("Perform speckle noise reduction on SAR image."); // Documentation SetDocName("Despeckle"); SetDocLongDescription("This application reduce speckle noise. Four methods are available: Lee, Frost, GammaMAP and Kuan."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::SAR); AddDocTag(Tags::Filter); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image."); AddRAMParameter(); AddParameter(ParameterType_Choice,"filter","speckle filtering method"); AddChoice("filter.lee","Lee"); SetParameterDescription("filter.lee","Lee filter"); AddChoice("filter.frost","Frost"); SetParameterDescription("filter.frost","Frost filter"); AddChoice("filter.gammamap","GammaMap"); SetParameterDescription("filter.gammamap","GammaMap filter"); AddChoice("filter.kuan","Kuan"); SetParameterDescription("filter.kuan","Kuan filter"); AddParameter(ParameterType_Int,"filter.lee.rad","Radius"); SetParameterDescription("filter.lee.rad","Radius for lee filter"); AddParameter(ParameterType_Float,"filter.lee.nblooks","nb looks"); SetParameterDescription("filter.lee.nblooks","Nb looks for lee filter"); AddParameter(ParameterType_Int,"filter.frost.rad","Radius"); SetParameterDescription("filter.frost.rad","Radius for frost filter"); AddParameter(ParameterType_Float,"filter.frost.deramp","deramp"); SetParameterDescription("filter.frost.deramp","Decrease factor declaration"); AddParameter(ParameterType_Int,"filter.gammamap.rad","Radius"); SetParameterDescription("filter.gammamap.rad","Radius for GammaMAP filter"); AddParameter(ParameterType_Float,"filter.gammamap.nblooks","nb looks"); SetParameterDescription("filter.gammamap.nblooks","Nb looks for GammaMAP filter"); AddParameter(ParameterType_Int,"filter.kuan.rad","Radius"); SetParameterDescription("filter.kuan.rad","Radius for Kuan filter"); AddParameter(ParameterType_Float,"filter.kuan.nblooks","nb looks"); SetParameterDescription("filter.kuan.nblooks","Nb looks for Kuan filter"); // Default values SetDefaultParameterInt("filter.lee.rad", 1); SetDefaultParameterFloat("filter.lee.nblooks", 1.); SetDefaultParameterInt("filter.frost.rad", 1); SetDefaultParameterFloat("filter.frost.deramp", 0.1); SetDefaultParameterInt("filter.gammamap.rad", 1); SetDefaultParameterFloat("filter.gammamap.nblooks", 1.); // Doc example parameter settings SetDocExampleParameterValue("in", "sar.tif"); SetDocExampleParameterValue("filter","lee"); SetDocExampleParameterValue("filter.lee.rad", "5"); SetDocExampleParameterValue("out", "despeckle.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType* inVImage = GetParameterImage("in"); // Transform to otb::Image typedef otb::Image InternalFloatImageType; typedef otb::MultiToMonoChannelExtractROI ExtractFilterType; ExtractFilterType::Pointer channelSelect = ExtractFilterType::New(); m_Ref.push_back(channelSelect.GetPointer()); channelSelect->SetChannel(1); channelSelect->SetInput(inVImage); channelSelect->UpdateOutputInformation(); InternalFloatImageType::Pointer inImage = channelSelect->GetOutput(); inImage->UpdateOutputInformation(); switch (GetParameterInt("filter")) { case 0: { LeeFilterType::Pointer filter = LeeFilterType::New(); m_Ref.push_back(filter.GetPointer()); filter->SetInput(inImage); LeeFilterType::SizeType lradius; lradius.Fill(GetParameterInt("filter.lee.rad")); filter->SetRadius(lradius); filter->SetNbLooks(GetParameterFloat("filter.lee.nblooks")); otbAppLogINFO( << "Lee filter" ); m_SpeckleFilter = filter; break; } case 1: { FrostFilterType::Pointer filter = FrostFilterType::New(); m_Ref.push_back(filter.GetPointer()); filter->SetInput(inImage); FrostFilterType::SizeType lradius; lradius.Fill(GetParameterInt("filter.frost.rad")); filter->SetRadius(lradius); filter->SetDeramp(GetParameterFloat("filter.frost.deramp")); otbAppLogINFO( << "Frost filter" ); m_SpeckleFilter = filter; break; } case 2: { GammaMAPFilterType::Pointer filter = GammaMAPFilterType::New(); m_Ref.push_back(filter.GetPointer()); filter->SetInput(inImage); GammaMAPFilterType::SizeType lradius; lradius.Fill(GetParameterInt("filter.gammamap.rad")); filter->SetRadius(lradius); filter->SetNbLooks(GetParameterFloat("filter.gammamap.nblooks")); otbAppLogINFO( << "GammaMAP filter" ); m_SpeckleFilter = filter; break; } case 3: { KuanFilterType::Pointer filter = KuanFilterType::New(); m_Ref.push_back(filter.GetPointer()); filter->SetInput(inImage); KuanFilterType::SizeType lradius; lradius.Fill(GetParameterInt("filter.kuan.rad")); filter->SetRadius(lradius); filter->SetNbLooks(GetParameterFloat("filter.kuan.nblooks")); otbAppLogINFO( << "Kuan filter" ); m_SpeckleFilter = filter; break; } default: { otbAppLogFATAL(<<"non defined speckle reduction filter "<GetOutput()); } std::vector m_Ref; SpeckleFilterType::Pointer m_SpeckleFilter; }; } //end namespace Wrapper } //end namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::Despeckle) OTB-release-5.8/Modules/Applications/AppFiltering/app/otbSmoothing.cxx000066400000000000000000000166731301006202600260350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "itkMeanImageFilter.h" #include "itkDiscreteGaussianImageFilter.h" #include "itkGradientAnisotropicDiffusionImageFilter.h" #include "otbPerBandVectorImageFilter.h" namespace otb { namespace Wrapper { enum { Smoothing_Mean, Smoothing_Gaussian, Smoothing_Anisotropic }; typedef otb::Image ImageType; class Smoothing : public Application { public: /** Standard class typedefs. */ typedef Smoothing Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Smoothing, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("Smoothing"); SetDescription("Apply a smoothing filter to an image"); SetDocName("Smoothing"); SetDocLongDescription("This application applies smoothing filter to an image." " Either gaussian, mean, or anisotropic diffusion are available."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Filter); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image to smooth."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output smoothed image."); AddRAMParameter(); AddParameter(ParameterType_Choice, "type", "Smoothing Type"); SetParameterDescription("type", "Smoothing kernel to apply"); AddChoice("type.mean", "Mean"); AddParameter(ParameterType_Radius, "type.mean.radius", "Radius"); SetParameterDescription("type.mean.radius", "Mean radius (in pixels)"); SetDefaultParameterInt("type.mean.radius", 2); AddChoice("type.gaussian", "Gaussian"); AddParameter(ParameterType_Float, "type.gaussian.radius", "Radius"); SetParameterDescription("type.gaussian.radius", "Gaussian radius (in pixels)"); SetDefaultParameterFloat("type.gaussian.radius", 2.0); AddChoice("type.anidif", "Anisotropic Diffusion"); AddParameter(ParameterType_Float, "type.anidif.timestep", "Time Step"); SetParameterDescription("type.anidif.timestep", "Diffusion equation time step"); AddParameter(ParameterType_Int, "type.anidif.nbiter", "Nb Iterations"); SetParameterDescription("type.anidif.nbiter", "Number of iterations"); AddParameter(ParameterType_Float, "type.anidif.conductance", "Conductance"); SetParameterDescription("type.anidif.nbiter", "Controls the sensitivity of the conductance term"); SetDefaultParameterFloat("type.anidif.timestep", 0.125); SetDefaultParameterInt("type.anidif.nbiter", 10); SetDefaultParameterInt("type.anidif.conductance", 1.); SetParameterString("type", "anidif"); // Doc example parameter settings SetExampleComment("Image smoothing using a mean filter.", 0); SetDocExampleParameterValue("in", "Romania_Extract.tif"); SetDocExampleParameterValue("out", "smoothedImage_mean.png uchar"); SetDocExampleParameterValue("type", "mean"); unsigned int exId = AddExample( "Image smoothing using an anisotropic diffusion filter." ); SetDocExampleParameterValue("in", "Romania_Extract.tif", exId); SetDocExampleParameterValue("out", "smoothedImage_ani.png float", exId); SetDocExampleParameterValue("type", "anidif", exId); SetDocExampleParameterValue("type.anidif.timestep", "0.1", exId); SetDocExampleParameterValue("type.anidif.nbiter", "5", exId); SetDocExampleParameterValue("type.anidif.conductance", "1.5", exId); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { GetLogger()->Debug("Entering DoExecute\n"); FloatVectorImageType::Pointer inImage = GetParameterImage("in"); switch ( GetParameterInt("type") ) { case Smoothing_Mean: { GetLogger()->Debug("Using mean"); typedef itk::MeanImageFilter MeanFilterType; typedef otb::PerBandVectorImageFilter PerBandMeanFilterType; PerBandMeanFilterType::Pointer perBand = PerBandMeanFilterType::New(); perBand->SetInput(inImage); MeanFilterType::InputSizeType radius; radius.Fill( GetParameterInt("type.mean.radius") ); perBand->GetFilter()->SetRadius(radius); perBand->UpdateOutputInformation(); m_FilterRef = perBand; SetParameterOutputImage("out", perBand->GetOutput()); } break; case Smoothing_Gaussian: { GetLogger()->Debug("Using gaussian"); typedef itk::DiscreteGaussianImageFilter DiscreteGaussianFilterType; typedef otb::PerBandVectorImageFilter PerBandDiscreteGaussianFilterType; PerBandDiscreteGaussianFilterType::Pointer perBand = PerBandDiscreteGaussianFilterType::New(); perBand->SetInput(inImage); double radius = GetParameterFloat("type.gaussian.radius"); double variance = radius * radius; perBand->GetFilter()->SetVariance(variance); perBand->GetFilter()->SetUseImageSpacing(false); perBand->UpdateOutputInformation(); m_FilterRef = perBand; SetParameterOutputImage("out", perBand->GetOutput()); } break; case Smoothing_Anisotropic: { GetLogger()->Debug("Using anisotropic diffusion"); typedef itk::GradientAnisotropicDiffusionImageFilter GradientAnisotropicDiffusionFilterType; typedef otb::PerBandVectorImageFilter PerBandGradientAnisotropicDiffusionFilterType; PerBandGradientAnisotropicDiffusionFilterType::Pointer perBand = PerBandGradientAnisotropicDiffusionFilterType::New(); perBand->SetInput(inImage); const int aniDifNbIter = GetParameterInt("type.anidif.nbiter"); perBand->GetFilter()->SetNumberOfIterations(static_cast(aniDifNbIter)); const float aniDifTimeStep = GetParameterFloat("type.anidif.timestep"); perBand->GetFilter()->SetTimeStep(static_cast(aniDifTimeStep)); perBand->GetFilter()->SetConductanceParameter(GetParameterFloat("type.anidif.conductance")); perBand->GetFilter()->SetUseImageSpacing(false); perBand->UpdateOutputInformation(); m_FilterRef = perBand; SetParameterOutputImage("out", perBand->GetOutput()); } break; } } itk::LightObject::Pointer m_FilterRef; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::Smoothing) OTB-release-5.8/Modules/Applications/AppFiltering/otb-module.cmake000066400000000000000000000004231301006202600251100ustar00rootroot00000000000000set(DOCUMENTATION "Basic filters application.") otb_module(OTBAppFiltering DEPENDS OTBImageNoise OTBImageManipulation OTBITK OTBApplicationEngine OTBImageBase TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppFiltering/test/000077500000000000000000000000001301006202600230175ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppFiltering/test/CMakeLists.txt000066400000000000000000000075731301006202600255730ustar00rootroot00000000000000otb_module_test() #----------- Despeckle TESTS ---------------- #----------- Smoothing TESTS ---------------- otb_test_application(NAME apTvUtSmoothingTest_InXML APP Smoothing OPTIONS -inxml ${INPUTDATA}/apTvUtSmoothingTest_OutXML.xml -in ${INPUTDATA}/poupees.tif -out ${TEMP}/apTvUtSmoothingTest_InXML.tif -type mean VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtSmoothingTest.tif ${TEMP}/apTvUtSmoothingTest_InXML.tif) otb_test_application(NAME apTvUtSmoothingTest APP Smoothing OPTIONS -in ${INPUTDATA}/poupees.tif -out ${TEMP}/apTvUtSmoothingTest.tif -type mean VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtSmoothingTest.tif ${TEMP}/apTvUtSmoothingTest.tif) otb_test_application(NAME apTvUtSmoothingTest_OutXML APP Smoothing OPTIONS -in ${INPUTDATA}/poupees.tif -out ${TEMP}/apTvUtSmoothingTest_OutXML.tif -type mean -outxml ${TEMP}/apTvUtSmoothingTest_OutXML.xml VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtSmoothingTest.tif ${TEMP}/apTvUtSmoothingTest_OutXML.tif) otb_test_application(NAME apTvDespeckleLee APP Despeckle OPTIONS -in ${INPUTDATA}/GomaAvant.tif -out ${TEMP}/bfFiltreLee_05_05_12_app.tif -filter lee -filter.lee.rad 5 -filter.lee.nblooks 12 VALID --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreLee_05_05_12.tif ${TEMP}/bfFiltreLee_05_05_12_app.tif) otb_test_application(NAME apTvDespeckleFrost APP Despeckle OPTIONS -in ${INPUTDATA}/GomaAvant.tif -out ${TEMP}/bfFiltreFrost_05_05_12_app.tif -filter frost -filter.frost.rad 5 -filter.frost.deramp 0.1 VALID --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreFrost_05_05_12_app.tif ${TEMP}/bfFiltreFrost_05_05_12_app.tif) otb_test_application(NAME apTvDespeckleGammaMAP APP Despeckle OPTIONS -in ${INPUTDATA}/GomaAvant.tif -out ${TEMP}/bfFiltreGammaMAP_05_05_12_app.tif -filter gammamap -filter.gammamap.rad 5 -filter.gammamap.nblooks 12 VALID --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreGammaMAP_05_05_12.tif ${TEMP}/bfFiltreGammaMAP_05_05_12_app.tif) otb_test_application(NAME apTvDespeckleKuan APP Despeckle OPTIONS -in ${INPUTDATA}/GomaAvant.tif -out ${TEMP}/bfFiltreKuan_05_05_12_app.tif -filter kuan -filter.kuan.rad 5 -filter.kuan.nblooks 12 VALID --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreKuan_05_05_12.tif ${TEMP}/bfFiltreKuan_05_05_12_app.tif) OTB-release-5.8/Modules/Applications/AppFusion/000077500000000000000000000000001301006202600213605ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppFusion/CMakeLists.txt000066400000000000000000000000501301006202600241130ustar00rootroot00000000000000project(OTBAppFusion) otb_module_impl() OTB-release-5.8/Modules/Applications/AppFusion/app/000077500000000000000000000000001301006202600221405ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppFusion/app/CMakeLists.txt000066400000000000000000000007401301006202600247010ustar00rootroot00000000000000set(OTBAppFusion_LINK_LIBS ${OTBImageBase_LIBRARIES} ${OTBInterpolation_LIBRARIES} ${OTBPanSharpening_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBProjection_LIBRARIES} ) otb_create_application( NAME BundleToPerfectSensor SOURCES otbBundleToPerfectSensor.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME Pansharpening SOURCES otbPansharpening.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppFusion/app/otbBundleToPerfectSensor.cxx000066400000000000000000000241651301006202600276200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbGenericRSResampleImageFilter.h" #include "otbGridResampleImageFilter.h" #include "otbImportGeoInformationImageFilter.h" #include "otbBCOInterpolateImageFunction.h" #include "otbSimpleRcsPanSharpeningFusionImageFilter.h" #include "itkFixedArray.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" #include "otbPleiadesPToXSAffineTransformCalculator.h" namespace otb { namespace Wrapper { class BundleToPerfectSensor : public Application { public: /** Standard class typedefs. */ typedef BundleToPerfectSensor Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(BundleToPerfectSensor, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("BundleToPerfectSensor"); SetDescription("Perform P+XS pansharpening"); // Documentation SetDocName("Bundle to perfect sensor"); SetDocLongDescription("This application performs P+XS pansharpening. The default mode use Pan and XS sensor models to estimate the transformation to superimpose XS over Pan before the fusion (\"default mode\"). The application provides also a PHR mode for Pleiades images which does not use sensor models as Pan and XS products are already coregistered but only estimate an affine transformation to superimpose XS over the Pan.Note that this option is automatically activated in case Pleiades images are detected as input."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Geometry); AddDocTag(Tags::Pansharpening); AddParameter(ParameterType_InputImage, "inp", "Input PAN Image"); SetParameterDescription("inp"," Input panchromatic image."); AddParameter(ParameterType_InputImage, "inxs", "Input XS Image"); SetParameterDescription("inxs"," Input XS image."); AddParameter(ParameterType_OutputImage, "out", "Output image"); SetParameterDescription("out"," Output image."); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); // Superposition mode AddParameter(ParameterType_Choice,"mode", "Mode"); SetParameterDescription("mode", "Superimposition mode"); AddChoice("mode.default", "Default mode"); SetParameterDescription("mode.default", "Default superimposition mode : " "uses any projection reference or sensor model found in the images"); AddChoice("mode.phr", "Pleiades mode"); SetParameterDescription("mode.phr", "Pleiades superimposition mode, " "designed for the case of a P+XS bundle in SENSOR geometry. It uses" " a simple transform on the XS image : a scaling and a residual " "translation."); AddParameter(ParameterType_Float, "lms", "Spacing of the deformation field"); SetParameterDescription("lms"," Spacing of the deformation field. Default is 10 times the PAN image spacing."); AddRAMParameter(); MandatoryOff("lms"); // Doc example parameter settings SetDocExampleParameterValue("inp", "QB_Toulouse_Ortho_PAN.tif"); SetDocExampleParameterValue("inxs", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("out", "BundleToPerfectSensor.png uchar"); } void DoUpdateParameters() ITK_OVERRIDE { if(!HasUserValue("mode") && HasValue("inp") && HasValue("inxs") && otb::PleiadesPToXSAffineTransformCalculator::CanCompute(GetParameterImage("inp"),GetParameterImage("inxs"))) { otbAppLogWARNING("Forcing PHR mode with PHR data. You need to add \"-mode default\" to force the default mode with PHR images."); SetParameterString("mode","phr"); } } void DoExecute() ITK_OVERRIDE { FloatVectorImageType* panchroV = GetParameterImage("inp"); FloatVectorImageType* xs = GetParameterImage("inxs"); if ( panchroV->GetNumberOfComponentsPerPixel() != 1 ) { itkExceptionMacro(<< "The panchromatic image must be a single channel image") } // Transform the PAN image to otb::Image typedef otb::Image InternalImageType; typedef otb::MultiToMonoChannelExtractROI ExtractFilterType; ExtractFilterType::Pointer channelSelect = ExtractFilterType::New(); m_Ref.push_back(channelSelect.GetPointer()); channelSelect->SetChannel(1); channelSelect->SetInput(panchroV); channelSelect->UpdateOutputInformation(); InternalImageType::Pointer panchro = channelSelect->GetOutput(); typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::GenericRSResampleImageFilter ResamplerType; typedef otb::GridResampleImageFilter BasicResamplerType; typedef otb::ImportGeoInformationImageFilter ImportGeoInformationFilterType; typedef otb::SimpleRcsPanSharpeningFusionImageFilter FusionFilterType; // Resample filter ResamplerType::Pointer resampler = ResamplerType::New(); m_Ref.push_back(resampler.GetPointer()); BasicResamplerType::Pointer basicResampler = BasicResamplerType::New(); m_Ref.push_back(basicResampler.GetPointer()); ImportGeoInformationFilterType::Pointer geoImport = ImportGeoInformationFilterType::New(); m_Ref.push_back(geoImport.GetPointer()); InterpolatorType::Pointer interpolator = InterpolatorType::New(); resampler->SetInterpolator(interpolator); basicResampler->SetInterpolator(interpolator); // Fusion filter FusionFilterType::Pointer fusionFilter = FusionFilterType::New(); m_Ref.push_back(fusionFilter.GetPointer()); fusionFilter->SetPanInput(panchro); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // Set up output image information FloatVectorImageType::SpacingType spacing = panchro->GetSpacing(); FloatVectorImageType::IndexType start = panchro->GetLargestPossibleRegion().GetIndex(); FloatVectorImageType::SizeType size = panchro->GetLargestPossibleRegion().GetSize(); FloatVectorImageType::PointType origin = panchro->GetOrigin(); FloatVectorImageType::PixelType defaultValue; itk::NumericTraits::SetLength(defaultValue, xs->GetNumberOfComponentsPerPixel()); if(GetParameterString("mode") == "default") { otbAppLogINFO("Using the default mode"); if(IsParameterEnabled("lms") && HasValue("lms")) { double defScalarSpacing = GetParameterFloat("lms"); otbAppLogINFO(<< "Generating coarse deformation field (spacing="<SetDisplacementFieldSpacing(defSpacing); } else { FloatVectorImageType::SpacingType defSpacing; defSpacing[0]=10*spacing[0]; defSpacing[1]=10*spacing[1]; resampler->SetDisplacementFieldSpacing(defSpacing); } resampler->SetInput(xs); resampler->SetOutputOrigin(origin); resampler->SetOutputSpacing(spacing); resampler->SetOutputSize(size); resampler->SetOutputStartIndex(start); resampler->SetOutputKeywordList(panchro->GetImageKeywordlist()); resampler->SetOutputProjectionRef(panchro->GetProjectionRef()); resampler->SetEdgePaddingValue(defaultValue); fusionFilter->SetXsInput(resampler->GetOutput()); } else if(GetParameterString("mode")=="phr") { otbAppLogINFO("Using the PHR mode"); otb::PleiadesPToXSAffineTransformCalculator::TransformType::OffsetType offset = otb::PleiadesPToXSAffineTransformCalculator::ComputeOffset(GetParameterImage("inp"), GetParameterImage("inxs")); origin+=offset; origin[0]=origin[0]/4; origin[1]=origin[1]/4; basicResampler->SetOutputOrigin(origin); basicResampler->SetInput(xs); basicResampler->SetOutputOrigin(origin); FloatVectorImageType::SpacingType xsSpacing = GetParameterImage("inxs")->GetSpacing(); xsSpacing*=0.25; basicResampler->SetOutputSpacing(xsSpacing); basicResampler->SetOutputSize(size); basicResampler->SetOutputStartIndex(start); basicResampler->SetEdgePaddingValue(defaultValue); geoImport->SetInput(basicResampler->GetOutput()); geoImport->SetSource(panchro); fusionFilter->SetXsInput(geoImport->GetOutput()); // Set the profRef & Keywordlist from Pan into the resampled XS image basicResampler->UpdateOutputInformation(); itk::MetaDataDictionary& dict = basicResampler->GetOutput()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, panchro->GetProjectionRef()); itk::EncapsulateMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, panchro->GetImageKeywordlist()); } else { otbAppLogWARNING("Unknown mode"); } SetParameterOutputImage("out", fusionFilter->GetOutput()); } std::vector m_Ref; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::BundleToPerfectSensor) OTB-release-5.8/Modules/Applications/AppFusion/app/otbPansharpening.cxx000066400000000000000000000203511301006202600261670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "itkUnaryFunctorImageFilter.h" #include "itkVectorIndexSelectionCastImageFilter.h" #include "otbGenericRSResampleImageFilter.h" #include "otbBCOInterpolateImageFunction.h" #include "otbSimpleRcsPanSharpeningFusionImageFilter.h" #include "otbBayesianFusionFilter.h" #include "otbGenericRSResampleImageFilter.h" #include "otbBCOInterpolateImageFunction.h" #include "otbLmvmPanSharpeningFusionImageFilter.h" #include "itkFixedArray.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class Pansharpening : public Application { public: /** Standard class typedefs. */ typedef Pansharpening Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ImageToImageFilter FusionFilterType; typedef otb::SimpleRcsPanSharpeningFusionImageFilter SimpleRCSFilterType; typedef otb::LmvmPanSharpeningFusionImageFilter LmvmFilterType; typedef otb::BayesianFusionFilter BayesianFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::GenericRSResampleImageFilter ResamplerType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Pansharpening, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("Pansharpening"); SetDescription("Perform P+XS pansharpening"); // Documentation SetDocName("Pansharpening"); SetDocLongDescription("This application performs P+XS pansharpening. Pansharpening is a process of merging high-resolution panchromatic and lower resolution multispectral imagery to create a single high-resolution color image. Algorithms available in the applications are: RCS, bayesian fusion and Local Mean and Variance Matching(LMVM)."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Geometry); AddDocTag(Tags::Pansharpening); AddParameter(ParameterType_InputImage, "inp", "Input PAN Image"); SetParameterDescription("inp"," Input panchromatic image."); AddParameter(ParameterType_InputImage, "inxs", "Input XS Image"); SetParameterDescription("inxs"," Input XS image."); AddParameter(ParameterType_OutputImage, "out", "Output image"); SetParameterDescription("out"," Output image."); AddParameter(ParameterType_Choice, "method", "Algorithm"); SetParameterDescription("method", "Selection of the pan-sharpening method."); AddChoice("method.rcs", "RCS"); SetParameterDescription("method.rcs", "Simple RCS Pan sharpening operation."); AddChoice("method.lmvm", "LMVM"); SetParameterDescription("method.lmvm", "Local Mean and Variance Matching (LMVM) Pan sharpening."); AddParameter(ParameterType_Int, "method.lmvm.radiusx", "X radius" ); SetParameterDescription("method.lmvm.radiusx","Set the x radius of the sliding window." ); SetMinimumParameterIntValue("method.lmvm.radiusx", 1); SetDefaultParameterInt("method.lmvm.radiusx", 3); AddParameter(ParameterType_Int, "method.lmvm.radiusy", "Y radius"); SetParameterDescription("method.lmvm.radiusy", "Set the y radius of the sliding window."); SetMinimumParameterIntValue("method.lmvm.radiusy", 1); SetDefaultParameterInt("method.lmvm.radiusy", 3); AddChoice("method.bayes", "Bayesian"); SetParameterDescription("method.bayes", "Bayesian fusion."); AddParameter(ParameterType_Float, "method.bayes.lambda", "Weight"); SetParameterDescription("method.bayes.lambda", "Set the weighting value."); SetMinimumParameterFloatValue("method.bayes.lambda", 0); SetDefaultParameterFloat("method.bayes.lambda", 0.9999); AddParameter(ParameterType_Float, "method.bayes.s", "S coefficient"); SetParameterDescription("method.bayes.s", "Set the S coefficient."); SetMinimumParameterFloatValue("method.bayes.s", 1); SetDefaultParameterFloat("method.bayes.s", 1); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("inp", "QB_Toulouse_Ortho_PAN.tif"); SetDocExampleParameterValue("inxs", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("out", "Pansharpening.tif uint16"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType* panchroV = GetParameterImage("inp"); if ( panchroV->GetNumberOfComponentsPerPixel() != 1 ) { itkExceptionMacro(<< "The panchromatic image must be a single channel image") } // Transform the PAN image to otb::Image typedef otb::Image InternalFloatImageType; typedef itk::VectorIndexSelectionCastImageFilter VectorIndexSelectionCastImageFilterType; VectorIndexSelectionCastImageFilterType::Pointer channelSelect = VectorIndexSelectionCastImageFilterType::New(); m_Ref.push_back(channelSelect.GetPointer()); channelSelect->SetIndex(0); channelSelect->SetInput(panchroV); channelSelect->UpdateOutputInformation(); InternalFloatImageType::Pointer panchro = channelSelect->GetOutput(); FloatVectorImageType* xs = GetParameterImage("inxs"); switch (GetParameterInt("method")) { case 0: { SimpleRCSFilterType::Pointer filter = SimpleRCSFilterType::New(); m_Ref.push_back(filter.GetPointer()); filter->SetPanInput(panchro); filter->SetXsInput(xs); filter->UpdateOutputInformation(); otbAppLogINFO( << "Simple RCS algorithm" ); m_FusionFilter = filter; break; } case 1: { LmvmFilterType::Pointer filter = LmvmFilterType::New(); filter->SetXsInput(xs); filter->SetPanInput(panchro); double radiusx = static_cast (GetParameterInt("method.lmvm.radiusx")); double radiusy = static_cast (GetParameterInt("method.lmvm.radiusy")); InternalFloatImageType::SizeType radius; radius[0] = radiusx; radius[1] = radiusy; filter->SetRadius(radius); itk::Array filterCoeffs; filterCoeffs.SetSize((2 * radius[0] + 1) * (2 * radius[1] + 1)); filterCoeffs.Fill(1); filter->SetFilter(filterCoeffs); filter->UpdateOutputInformation(); otbAppLogINFO( << "Lmvm algorithm" ); m_FusionFilter = filter; break; } case 2: { BayesianFilterType::Pointer filter = BayesianFilterType::New(); double lambda = static_cast (GetParameterFloat("method.bayes.lambda")); double s = static_cast (GetParameterFloat("method.bayes.s")); filter->SetS(s); filter->SetLambda(lambda); filter->SetMultiSpect(xs); filter->SetMultiSpectInterp(xs); filter->SetPanchro(panchro); filter->UpdateOutputInformation(); otbAppLogINFO( << "Bayesian fusion algorithm" ); m_FusionFilter = filter; break; } default: { otbAppLogFATAL(<<"non defined method "<GetOutput()); } std::vector m_Ref; FusionFilterType::Pointer m_FusionFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::Pansharpening) OTB-release-5.8/Modules/Applications/AppFusion/otb-module.cmake000066400000000000000000000004551301006202600244350ustar00rootroot00000000000000set(DOCUMENTATION "Fusion of classifications application.") otb_module(OTBAppFusion DEPENDS OTBITK OTBPanSharpening OTBImageBase OTBApplicationEngine OTBProjection OTBInterpolation TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppFusion/test/000077500000000000000000000000001301006202600223375ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppFusion/test/CMakeLists.txt000066400000000000000000000057241301006202600251070ustar00rootroot00000000000000otb_module_test() #----------- BundleToPerfectSensor TESTS ---------------- otb_test_application(NAME apTvPrBundleToPerfectSensor APP BundleToPerfectSensor OPTIONS -inp ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -inxs ${INPUTDATA}/QB_Toulouse_Ortho_XS_ROI_170x230.tif -elev.dem ${INPUTDATA}/DEM/srtm_directory -out ${TEMP}/apTvPrBundleToPerfectSensor.tif int16 VALID --compare-image ${EPSILON_7} ${BASELINE}/apTvPrBundleToPerfectSensor.tif ${TEMP}/apTvPrBundleToPerfectSensor.tif) otb_test_application(NAME apTvPrBundleToPerfectSensor_phr APP BundleToPerfectSensor OPTIONS -inp ${INPUTDATA}/phr_pan.tif -inxs ${INPUTDATA}/phr_xs.tif -out ${TEMP}/apTvPrBundleToPerfectSensorPHR.tif int16 VALID --compare-image ${EPSILON_7} ${BASELINE}/apTvPrBundleToPerfectSensorPHR.tif ${TEMP}/apTvPrBundleToPerfectSensorPHR.tif) #----------- Pansharpening TESTS ---------------- otb_test_application(NAME apTvFuPansharpening_LMVM APP Pansharpening OPTIONS -inp ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -inxs ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -out ${TEMP}/apTvFuPanSharpeningLmvm.tif double -method lmvm -method.lmvm.radiusx 5 -method.lmvm.radiusy 5 VALID --compare-image ${EPSILON_6} ${BASELINE}/fuTvLmvmPanSharpeningFusion.tif ${TEMP}/apTvFuPanSharpeningLmvm.tif ) otb_test_application(NAME apTvFuPansharpening_Bayes APP Pansharpening OPTIONS -inp ${INPUTDATA}/panchro.tif -inxs ${INPUTDATA}/multiSpectInterp.tif -out ${TEMP}/apTvFuPanSharpeningBayes.tif double -method bayes VALID --compare-image ${EPSILON_6} ${BASELINE}/apTvFuPanSharpeningBayes.tif ${TEMP}/apTvFuPanSharpeningBayes.tif ) otb_test_application(NAME apTvFuPansharpening_RCS APP Pansharpening OPTIONS -inp ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -inxs ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -out ${TEMP}/apTvFuPanSharpeningRcs.tif double -method rcs VALID --compare-image ${EPSILON_6} ${BASELINE}/fuTvRcsPanSharpeningFusion.tif ${TEMP}/apTvFuPanSharpeningRcs.tif ) OTB-release-5.8/Modules/Applications/AppHyperspectral/000077500000000000000000000000001301006202600227425ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppHyperspectral/CMakeLists.txt000066400000000000000000000000571301006202600255040ustar00rootroot00000000000000project(OTBAppHyperspectral) otb_module_impl() OTB-release-5.8/Modules/Applications/AppHyperspectral/app/000077500000000000000000000000001301006202600235225ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppHyperspectral/app/CMakeLists.txt000066400000000000000000000007411301006202600262640ustar00rootroot00000000000000set(OTBAppHyperspectral_LINK_LIBS ${OTBStatistics_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBEndmembersExtraction_LIBRARIES} ${OTBUnmixing_LIBRARIES} ) otb_create_application( NAME HyperspectralUnmixing SOURCES otbHyperspectralUnmixing.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME VertexComponentAnalysis SOURCES otbVertexComponentAnalysis.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppHyperspectral/app/otbHyperspectralUnmixing.cxx000066400000000000000000000207641301006202600313300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbUnConstrainedLeastSquareImageFilter.h" #include "otbISRAUnmixingImageFilter.h" #include "otbNCLSUnmixingImageFilter.h" //#include "otbFCLSUnmixingImageFilter.h" #include "otbMDMDNMFImageFilter.h" namespace otb { namespace Wrapper { typedef otb::UnConstrainedLeastSquareImageFilter UCLSUnmixingFilterType; typedef otb::ISRAUnmixingImageFilter ISRAUnmixingFilterType; typedef otb::NCLSUnmixingImageFilter NCLSUnmixingFilterType; //typedef otb::FCLSUnmixingImageFilter FCLSUnmixingFilterType; typedef otb::MDMDNMFImageFilter MDMDNMFUnmixingFilterType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; typedef vnl_vector VectorType; typedef vnl_matrix MatrixType; enum DimReductionMethod { DimReductionMethod_NONE, DimReductionMethod_PCA, DimReductionMethod_MNF }; enum DimensionalityEstimationMethod { DimensionalityEstimationMethod_ELM }; enum EndmembersEstimationMethod { EndmembersEstimationMethod_VCA }; enum UnMixingMethod { UnMixingMethod_UCLS, //UnMixingMethod_FCLS, UnMixingMethod_NCLS, UnMixingMethod_ISRA, UnMixingMethod_MDMDNMF, }; const char* UnMixingMethodNames [] = { "UCLS", "FCLS", "NCLS", "ISRA", "MDMDNMF", }; class HyperspectralUnmixing : public Application { public: /** Standard class typedefs. */ typedef HyperspectralUnmixing Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(HyperspectralUnmixing, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("HyperspectralUnmixing"); SetDescription("Estimate abundance maps from an hyperspectral image and a set of endmembers."); // Documentation SetDocName("Hyperspectral data unmixing"); SetDocLongDescription("The application applies a linear unmixing algorithm to an hyperspectral data cube. This method supposes that the mixture between materials in the scene is macroscopic and simulates a linear mixing model of spectra.\nThe Linear Mixing Model (LMM) acknowledges that reflectance spectrum associated with each pixel is a linear combination of pure materials in the recovery area, commonly known as endmembers. Endmembers can be estimated using the VertexComponentAnalysis application.\nThe application allows one to estimate the abundance maps with several algorithms : Unconstrained Least Square (ucls), Fully Constrained Least Square (fcls), Image Space Reconstruction Algorithm (isra) and Non-negative constrained Least Square (ncls) and Minimum Dispersion Constrained Non Negative Matrix Factorization (MDMDNMF).\n"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("VertexComponentAnalysis"); AddDocTag(Tags::Hyperspectral); AddParameter(ParameterType_InputImage, "in", "Input Image Filename"); SetParameterDescription("in","The hyperspectral data cube to unmix"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out","The output abundance map"); AddParameter(ParameterType_InputImage, "ie", "Input endmembers"); SetParameterDescription("ie","The endmembers (estimated pure pixels) to use for unmixing. Must be stored as a multispectral image, where each pixel is interpreted as an endmember"); AddParameter(ParameterType_Choice, "ua", "Unmixing algorithm"); SetParameterDescription("ua", "The algorithm to use for unmixing"); MandatoryOff("ua"); AddChoice("ua.ucls", "UCLS"); SetParameterDescription("ua.ucls", "Unconstrained Least Square"); // AddChoice("ua.fcls", "FCLS"); // SetParameterDescription("ua.fcls", "Fully constrained Least Square"); AddChoice("ua.ncls", "NCLS"); SetParameterDescription("ua.ncls", "Non-negative constrained Least Square"); AddChoice("ua.isra", "ISRA"); SetParameterDescription("ua.isra", "Image Space Reconstruction Algorithm"); AddChoice("ua.mdmdnmf", "MDMDNMF"); SetParameterDescription("ua.mdmdnmf", "Minimum Dispersion Constrained Non Negative Matrix Factorization"); SetParameterString("ua", "ucls"); // Doc example parameter settings SetDocExampleParameterValue("in", "cupriteSubHsi.tif"); SetDocExampleParameterValue("ie", "cupriteEndmembers.tif"); SetDocExampleParameterValue("out", "HyperspectralUnmixing.tif double"); SetDocExampleParameterValue("ua", "ucls"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { m_ProcessObjects.clear(); DoubleVectorImageType::Pointer inputImage = GetParameterDoubleVectorImage("in"); DoubleVectorImageType::Pointer endmembersImage = GetParameterDoubleVectorImage("ie"); /* * Transform Endmembers image to matrix representation */ otbAppLogINFO("Endmembers extracted"); otbAppLogINFO("Converting endmembers to matrix"); VectorImageToMatrixImageFilterType::Pointer endMember2Matrix = VectorImageToMatrixImageFilterType::New(); endMember2Matrix->SetInput(endmembersImage); endMember2Matrix->Update(); MatrixType endMembersMatrix = endMember2Matrix->GetMatrix(); otbAppLogINFO("Endmembers matrix : " << endMembersMatrix); /* * Unmix */ DoubleVectorImageType::Pointer abundanceMap; switch ( static_cast(GetParameterInt("ua")) ) { case UnMixingMethod_UCLS: { otbAppLogINFO("UCLS Unmixing"); UCLSUnmixingFilterType::Pointer unmixer = UCLSUnmixingFilterType::New(); unmixer->SetInput(inputImage); unmixer->SetMatrix(endMembersMatrix); unmixer->SetNumberOfThreads(1); // FIXME : currently buggy abundanceMap = unmixer->GetOutput(); m_ProcessObjects.push_back(unmixer.GetPointer()); } break; case UnMixingMethod_ISRA: { otbAppLogINFO("ISRA Unmixing"); ISRAUnmixingFilterType::Pointer unmixer = ISRAUnmixingFilterType::New(); unmixer->SetInput(inputImage); unmixer->SetEndmembersMatrix(endMembersMatrix); abundanceMap = unmixer->GetOutput(); m_ProcessObjects.push_back(unmixer.GetPointer()); } break; case UnMixingMethod_NCLS: { otbAppLogINFO("NCLS Unmixing"); NCLSUnmixingFilterType::Pointer unmixer = NCLSUnmixingFilterType::New(); unmixer->SetInput(inputImage); unmixer->SetEndmembersMatrix(endMembersMatrix); abundanceMap = unmixer->GetOutput(); m_ProcessObjects.push_back(unmixer.GetPointer()); } break; /* case UnMixingMethod_FCLS: { otbAppLogINFO("FCLS Unmixing"); FCLSUnmixingFilterType::Pointer unmixer = FCLSUnmixingFilterType::New(); unmixer->SetInput(inputImage); unmixer->SetEndmembersMatrix(endMembersMatrix); abundanceMap = unmixer->GetOutput(); m_ProcessObjects.push_back(unmixer.GetPointer()); } break; */ case UnMixingMethod_MDMDNMF: { otbAppLogINFO("MDMD-NMF Unmixing"); MDMDNMFUnmixingFilterType::Pointer unmixer = MDMDNMFUnmixingFilterType::New(); unmixer->SetInput(inputImage); unmixer->SetEndmembersMatrix(endMembersMatrix); abundanceMap = unmixer->GetOutput(); m_ProcessObjects.push_back(unmixer.GetPointer()); } break; default: break; } SetParameterOutputImage("out", abundanceMap); } std::vector m_ProcessObjects; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::HyperspectralUnmixing) OTB-release-5.8/Modules/Applications/AppHyperspectral/app/otbVertexComponentAnalysis.cxx000066400000000000000000000065141301006202600316250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbVcaImageFilter.h" namespace otb { namespace Wrapper { typedef otb::VCAImageFilter VCAFilterType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; class VertexComponentAnalysis : public Application { public: /** Standard class typedefs. */ typedef VertexComponentAnalysis Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(VertexComponentAnalysis, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("VertexComponentAnalysis"); SetDescription("Find endmembers in hyperspectral images with Vertex Component Analysis"); // Documentation SetDocName("Vertex Component Analysis"); SetDocLongDescription("Applies the Vertex Component Analysis to an hyperspectral image to extract endmembers"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Hyperspectral); AddDocTag(Tags::DimensionReduction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in","Input hyperspectral data cube"); AddParameter(ParameterType_Int, "ne", "Number of endmembers"); SetParameterDescription("ne","The number of endmembers to extract from the data cube"); SetParameterInt("ne", 1); MandatoryOn("ne"); AddParameter(ParameterType_OutputImage, "outendm", "Output Endmembers"); SetParameterDescription("outendm","The endmebers, stored in a one-line multi-spectral image, each pixel representing an endmember"); MandatoryOn("outendm"); AddRANDParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "cupriteSubHsi.tif"); SetDocExampleParameterValue("ne", "5"); SetDocExampleParameterValue("outendm", "VertexComponentAnalysis.tif double"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { DoubleVectorImageType::Pointer inputImage = GetParameterDoubleVectorImage("in"); DoubleVectorImageType::Pointer endmembersImage; const unsigned int nbEndmembers = GetParameterInt("ne"); VCAFilterType::Pointer vca = VCAFilterType::New(); vca->SetNumberOfEndmembers(nbEndmembers); vca->SetInput(inputImage); endmembersImage = vca->GetOutput(); m_Ref = vca.GetPointer(); SetParameterOutputImage("outendm", endmembersImage); } itk::LightObject::Pointer m_Ref; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::VertexComponentAnalysis) OTB-release-5.8/Modules/Applications/AppHyperspectral/otb-module.cmake000066400000000000000000000004151301006202600260130ustar00rootroot00000000000000set(DOCUMENTATION "Unmixing application.") otb_module(OTBAppHyperspectral DEPENDS OTBStatistics OTBApplicationEngine OTBEndmembersExtraction OTBUnmixing TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppHyperspectral/test/000077500000000000000000000000001301006202600237215ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppHyperspectral/test/CMakeLists.txt000066400000000000000000000035401301006202600264630ustar00rootroot00000000000000otb_module_test() #----------- HyperspectralUnmixing TESTS ---------------- otb_test_application(NAME apTvHyHyperspectralUnmixing_UCLS APP HyperspectralUnmixing OPTIONS -in ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif -ie ${INPUTDATA}/Hyperspectral/synthetic/endmembers.tif -out ${TEMP}/apTvHyHyperspectralUnmixing_UCLS.tif double -ua ucls VALID --compare-image ${EPSILON_9} ${BASELINE}/apTvHyHyperspectralUnmixing_UCLS.tif ${TEMP}/apTvHyHyperspectralUnmixing_UCLS.tif) otb_test_application(NAME apTvHyHyperspectralUnmixing_NCLS APP HyperspectralUnmixing OPTIONS -in ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif -ie ${INPUTDATA}/Hyperspectral/synthetic/endmembers.tif -out ${TEMP}/apTvHyHyperspectralUnmixing_NCLS.tif double -ua ncls VALID --compare-image ${EPSILON_9} ${BASELINE}/apTvHyHyperspectralUnmixing_NCLS.tif ${TEMP}/apTvHyHyperspectralUnmixing_NCLS.tif) #----------- VertexComponentAnalysis TESTS ---------------- otb_test_application(NAME apTvHyVertexComponentAnalysis APP VertexComponentAnalysis OPTIONS -in ${OTB_DATA_ROOT}/Input/Hyperspectral/synthetic/hsi_cube.tif -ne 5 -rand 121212 -outendm ${TEMP}/apTvHyVertexComponentAnalysis.tif double VALID --compare-image ${EPSILON_9} ${BASELINE}/TvHyVertexComponentAnalysisImage.tif ${TEMP}/apTvHyVertexComponentAnalysis.tif ) OTB-release-5.8/Modules/Applications/AppImageUtils/000077500000000000000000000000001301006202600221605ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppImageUtils/CMakeLists.txt000066400000000000000000000000541301006202600247170ustar00rootroot00000000000000project(OTBAppImageUtils) otb_module_impl() OTB-release-5.8/Modules/Applications/AppImageUtils/app/000077500000000000000000000000001301006202600227405ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppImageUtils/app/CMakeLists.txt000066400000000000000000000047431301006202600255100ustar00rootroot00000000000000set(OTBAppImageUtils_LINK_LIBS ${OTBStatistics_LIBRARIES} ${OTBColorMap_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBStreaming_LIBRARIES} ${OTBCarto_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBCurlAdapters_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBMathParser_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBInterpolation_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_create_application( NAME DownloadSRTMTiles SOURCES otbDownloadSRTMTiles.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME Convert SOURCES otbConvert.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME PixelValue SOURCES otbPixelValue.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ExtractROI SOURCES otbExtractROI.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME Rescale SOURCES otbRescale.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME TileFusion SOURCES otbTileFusion.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ReadImageInfo SOURCES otbReadImageInfo.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME Quicklook SOURCES otbQuicklook.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME DEMConvert SOURCES otbDEMConvert.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ConcatenateImages SOURCES otbConcatenateImages.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME MultiResolutionPyramid SOURCES otbMultiResolutionPyramid.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ColorMapping SOURCES otbColorMapping.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME CompareImages SOURCES otbCompareImages.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME SplitImage SOURCES otbSplitImage.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ManageNoData SOURCES otbManageNoData.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbColorMapping.cxx000066400000000000000000001022401301006202600265620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include #include // Include different method for color mapping #include "otbChangeLabelImageFilter.h" #include "itkLabelToRGBImageFilter.h" #include "itkScalarToRGBColormapImageFilter.h" #include "otbReliefColormapFunctor.h" #include "otbRAMDrivenAdaptativeStreamingManager.h" #include "otbStreamingShrinkImageFilter.h" #include "itkListSample.h" #include "otbListSampleToHistogramListGenerator.h" #include "itkVariableLengthVector.h" #include "itkImageRegionConstIterator.h" #include "otbUnaryFunctorImageFilter.h" #include "itkBinaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "otbStreamingStatisticsMapFromLabelImageFilter.h" #include "otbMacro.h" namespace otb { namespace Functor { // Functor to compare RGB values template class VectorLexicographicCompare { public: bool operator()(const TInput& l, const TInput& r) const { unsigned int size = ( l.Size() < r.Size() ? l.Size() : r.Size()); for (unsigned int i=0; i < size; ++i) { if (l[i] < r[i]) { return true; } else if (l[i] > r[i]) { return false; } } return false; } }; // Functor to map vectors template class VectorMapping { public: typedef typename TOutput::ValueType ValueType; VectorMapping() : m_OutputSize(0) {} virtual ~VectorMapping() {} typedef std::map > ChangeMapType; void SetOutputSize(unsigned int nb) { m_OutputSize = nb; } unsigned int GetOutputSize() { return m_OutputSize; } bool operator !=(const VectorMapping& other) const { if (m_ChangeMap != other.m_ChangeMap) { return true; } return false; } bool operator ==(const VectorMapping& other) const { return !(*this != other); } TOutput GetChange(const TInput& original) { return m_ChangeMap[original]; } void SetChange(const TInput& original, const TOutput& result) { m_ChangeMap[original] = result; } void SetChangeMap(const ChangeMapType& changeMap) { m_ChangeMap = changeMap; } void ClearChangeMap() { m_ChangeMap.clear(); } void SetNotFoundValue(const TOutput& notFoundValue) { m_NotFoundValue = notFoundValue; } TOutput GetNotFoundValue() { return m_NotFoundValue; } inline TOutput operator ()(const TInput& A) { TOutput out; out.SetSize(m_OutputSize); if (m_ChangeMap.find(A) != m_ChangeMap.end()) { out = m_ChangeMap[A]; } else { out = m_NotFoundValue; } return out; } private: ChangeMapType m_ChangeMap; unsigned int m_OutputSize; // number of components in output image TOutput m_NotFoundValue; }; } namespace Wrapper { class ColorMapping: public Application { public: /** Standard class typedefs. */ typedef ColorMapping Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ColorMapping, otb::Application); typedef FloatImageType::PixelType PixelType; typedef UInt16ImageType LabelImageType; typedef LabelImageType::PixelType LabelType; typedef UInt8VectorImageType VectorImageType; typedef VectorImageType::PixelType VectorPixelType; typedef UInt8RGBImageType RGBImageType; typedef RGBImageType::PixelType RGBPixelType; typedef UInt16VectorImageType LabelVectorImageType; typedef LabelVectorImageType::PixelType LabelVectorType; typedef itk::NumericTraits ::ValueType ScalarType; typedef itk::VariableLengthVector SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::ImageRegionConstIterator IteratorType; typedef itk::ImageRegionConstIterator LabelIteratorType; // Manual label LUT typedef otb::ChangeLabelImageFilter ChangeLabelFilterType; // Segmentation contrast maximisation LUT typedef itk::LabelToRGBImageFilter LabelToRGBFilterType; // Continuous LUT mapping typedef itk::ScalarToRGBColormapImageFilter ColorMapFilterType; typedef otb::Functor::ReliefColormapFunctor ReliefColorMapFunctorType; // Image support LUT typedef RAMDrivenAdaptativeStreamingManager RAMDrivenAdaptativeStreamingManagerType; typedef otb::StreamingShrinkImageFilter ImageSamplingFilterType; typedef itk::Statistics::DenseFrequencyContainer2 DFContainerType; typedef itk::NumericTraits::RealType RealScalarType; typedef itk::VariableLengthVector InternalPixelType; typedef otb::ListSampleToHistogramListGenerator HistogramFilterType; //typedef itk::Statistics::Histogram // HistogramType; typedef HistogramFilterType::HistogramType HistogramType; typedef HistogramFilterType::HistogramListType HistogramListType; typedef HistogramType::Pointer HistogramPointerType; typedef otb::ImageMetadataInterfaceBase ImageMetadataInterfaceType; typedef otb::StreamingStatisticsMapFromLabelImageFilter StreamingStatisticsMapFromLabelImageFilterType; // Inverse mapper for color->label operation typedef otb::UnaryFunctorImageFilter > ColorToLabelFilterType; // Streaming the input image for color->label operation typedef RGBImageType::RegionType RegionType; typedef itk::ImageRegionConstIterator RGBImageIteratorType; // Caster to convert a FloatImageType to LabelImageType typedef itk::CastImageFilter CasterToLabelImageType; private: void DoInit() ITK_OVERRIDE { SetName("ColorMapping"); SetDescription("Maps an input label image to 8-bits RGB using look-up tables."); SetDocName("Color Mapping"); SetDocLongDescription("This application allows one to map a label image to a 8-bits RGB image (in both ways) using different methods.\n" " -The custom method allows one to use a custom look-up table. The look-up table is loaded " "from a text file where each line describes an entry. The typical use of this method is to colorise a " "classification map.\n -The continuous method allows mapping a range of values in a scalar input image " "to a colored image using continuous look-up table, in order to enhance image interpretation. Several " "look-up tables can been chosen with different color ranges.\n-The optimal method computes an optimal " "look-up table. When processing a segmentation label image (label to color), the color difference between" " adjacent segmented regions is maximized. When processing an unknown color image (color to label), all " "the present colors are mapped to a continuous label list.\n - The support image method uses a color support " "image to associate an average color to each region."); SetDocLimitations("The segmentation optimal method does not support streaming, and thus large images. The operation color to label " "is not implemented for the methods continuous LUT and support image LUT.\n ColorMapping using support image is not threaded."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("ImageSVMClassifier"); AddDocTag("Utilities"); AddDocTag(Tags::Manip); AddDocTag(Tags::Meta); AddDocTag(Tags::Learning); // Build lut map m_LutMap["Red"]=ColorMapFilterType::Red; m_LutMap["Green"]=ColorMapFilterType::Green; m_LutMap["Blue"]=ColorMapFilterType::Blue; m_LutMap["Grey"]=ColorMapFilterType::Grey; m_LutMap["Hot"]=ColorMapFilterType::Hot; m_LutMap["Cool"]=ColorMapFilterType::Cool; m_LutMap["Spring"]=ColorMapFilterType::Spring; m_LutMap["Summer"]=ColorMapFilterType::Summer; m_LutMap["Autumn"]=ColorMapFilterType::Autumn; m_LutMap["Winter"]=ColorMapFilterType::Winter; m_LutMap["Copper"]=ColorMapFilterType::Copper; m_LutMap["Jet"]=ColorMapFilterType::Jet; m_LutMap["HSV"]=ColorMapFilterType::HSV; m_LutMap["OverUnder"]=ColorMapFilterType::OverUnder; AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image filename"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out","Output image filename"); SetDefaultOutputPixelType("out",ImagePixelType_uint8); // --- OPERATION --- : Label to color / Color to label AddParameter(ParameterType_Choice, "op", "Operation"); SetParameterDescription("op","Selection of the operation to execute (default is : label to color)."); AddChoice("op.labeltocolor","Label to color"); AddChoice("op.colortolabel","Color to label"); AddParameter(ParameterType_Int, "op.colortolabel.notfound","Not Found Label"); SetParameterDescription("op.colortolabel.notfound","Label to use for unknown colors."); SetDefaultParameterInt("op.colortolabel.notfound", 404); MandatoryOff("op.colortolabel.notfound"); // --- MAPPING METHOD --- AddParameter(ParameterType_Choice, "method", "Color mapping method"); SetParameterDescription("method","Selection of color mapping methods and their parameters."); // Custom LUT AddChoice("method.custom","Color mapping with custom labeled look-up table"); SetParameterDescription("method.custom","Apply a user-defined look-up table to a labeled image. Look-up table is loaded from a text file."); AddParameter(ParameterType_InputFilename, "method.custom.lut", "Look-up table file"); SetParameterDescription("method.custom.lut", "An ASCII file containing the look-up table\n" "with one color per line\n" "(for instance the line '1 255 0 0' means that all pixels with label 1 will be replaced by RGB color 255 0 0)\n" "Lines beginning with a # are ignored"); // Continuous LUT AddChoice("method.continuous","Color mapping with continuous look-up table"); SetParameterDescription("method.continuous","Apply a continuous look-up table to a range of input values."); AddParameter(ParameterType_Choice,"method.continuous.lut","Look-up tables"); SetParameterDescription("method.continuous.lut","Available look-up tables."); AddChoice("method.continuous.lut.red","Red"); AddChoice("method.continuous.lut.green","Green"); AddChoice("method.continuous.lut.blue","Blue"); AddChoice("method.continuous.lut.grey","Grey"); AddChoice("method.continuous.lut.hot","Hot"); AddChoice("method.continuous.lut.cool","Cool"); AddChoice("method.continuous.lut.spring","Spring"); AddChoice("method.continuous.lut.summer","Summer"); AddChoice("method.continuous.lut.autumn","Autumn"); AddChoice("method.continuous.lut.winter","Winter"); AddChoice("method.continuous.lut.copper","Copper"); AddChoice("method.continuous.lut.jet","Jet"); AddChoice("method.continuous.lut.hsv","HSV"); AddChoice("method.continuous.lut.overunder","OverUnder"); AddChoice("method.continuous.lut.relief","Relief"); AddParameter(ParameterType_Float,"method.continuous.min","Mapping range lower value"); SetParameterDescription("method.continuous.min","Set the lower input value of the mapping range."); SetParameterFloat("method.continuous.min", 0.); AddParameter(ParameterType_Float,"method.continuous.max","Mapping range higher value"); SetParameterDescription("method.continuous.max","Set the higher input value of the mapping range."); SetParameterFloat("method.continuous.max", 255.); // Optimal LUT AddChoice("method.optimal","Compute an optimized look-up table"); SetParameterDescription("method.optimal","[label to color] Compute an optimal look-up table such that neighboring labels" " in a segmentation are mapped to highly contrasted colors. " "[color to label] Searching all the colors present in the image to compute a continuous label list"); AddParameter(ParameterType_Int,"method.optimal.background", "Background label"); SetParameterDescription("method.optimal.background","Value of the background label"); SetParameterInt("method.optimal.background", 0); SetMinimumParameterIntValue("method.optimal.background", 0); SetMaximumParameterIntValue("method.optimal.background", 255); // Support image LUT AddChoice("method.image","Color mapping with look-up table calculated on support image"); AddParameter(ParameterType_InputImage, "method.image.in", "Support Image"); SetParameterDescription("method.image.in", "Support image filename. For each label, the LUT is calculated from the mean pixel value in the support image, over the corresponding labeled areas." " First of all, the support image is normalized with extrema rejection"); AddParameter(ParameterType_Float, "method.image.nodatavalue", "NoData value"); SetParameterDescription("method.image.nodatavalue","NoData value for each channel of the support image, which will not be handled in the LUT estimation. If NOT checked, ALL the pixel values of the support image will be handled in the LUT estimation."); MandatoryOff("method.image.nodatavalue"); SetParameterFloat("method.image.nodatavalue", 0); DisableParameter("method.image.nodatavalue"); AddParameter(ParameterType_Int, "method.image.low", "lower quantile"); SetParameterDescription("method.image.low","lower quantile for image normalization"); MandatoryOff("method.image.low"); SetParameterInt("method.image.low", 2); SetMinimumParameterIntValue("method.image.low", 0); SetMaximumParameterIntValue("method.image.low", 100); AddParameter(ParameterType_Int, "method.image.up", "upper quantile"); SetParameterDescription("method.image.up","upper quantile for image normalization"); MandatoryOff("method.image.up"); SetParameterInt("method.image.up", 2); SetMinimumParameterIntValue("method.image.up", 0); SetMaximumParameterIntValue("method.image.up", 100); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "ROI_QB_MUL_1_SVN_CLASS_MULTI.png"); SetDocExampleParameterValue("method", "custom"); SetDocExampleParameterValue("method.custom.lut", "ROI_QB_MUL_1_SVN_CLASS_MULTI_PNG_ColorTable.txt"); SetDocExampleParameterValue("out", "Colorized_ROI_QB_MUL_1_SVN_CLASS_MULTI.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Make sure the operation color->label is not called with methods continuous or image. // These methods are not implemented for this operation yet. if (GetParameterInt("op")==1) { if (GetParameterInt("method")==1 || GetParameterInt("method")==3) { otbAppLogWARNING("Override method : use optimal"); SetParameterInt("method", 2); } } } void DoExecute() ITK_OVERRIDE { if(GetParameterInt("op")==0) { ComputeLabelToColor(); } else if(GetParameterInt("op")==1) { ComputeColorToLabel(); } } void ComputeLabelToColor() { if (GetParameterInt("method") == 0) { otbAppLogINFO("Color mapping with custom labeled look-up table"); m_CasterToLabelImage = CasterToLabelImageType::New(); m_CasterToLabelImage->SetInput(GetParameterFloatImage("in")); m_CasterToLabelImage->InPlaceOn(); m_CustomMapper = ChangeLabelFilterType::New(); m_CustomMapper->SetInput(m_CasterToLabelImage->GetOutput()); m_CustomMapper->SetNumberOfComponentsPerPixel(3); ReadLutFromFile(true); SetParameterOutputImage("out", m_CustomMapper->GetOutput()); } else if (GetParameterInt("method") == 1) { otbAppLogINFO("Color mapping with continuous look-up table"); m_ContinuousColorMapper = ColorMapFilterType::New(); m_ContinuousColorMapper->SetInput(GetParameterFloatImage("in")); // Disable automatic scaling m_ContinuousColorMapper->UseInputImageExtremaForScalingOff(); // Set the lut std::string lutTmp = GetParameterString("method.continuous.lut"); std::string lutNameParam = "method.continuous.lut." + lutTmp; std::string lut = GetParameterName(lutNameParam); otbAppLogINFO("LUT: "<SetColormap(reliefFunctor); } else { m_ContinuousColorMapper->SetColormap((ColorMapFilterType::ColormapEnumType) m_LutMap[lut]); } m_ContinuousColorMapper->GetColormap()->SetMinimumInputValue(GetParameterFloat("method.continuous.min")); m_ContinuousColorMapper->GetColormap()->SetMaximumInputValue(GetParameterFloat("method.continuous.max")); SetParameterOutputImage("out", m_ContinuousColorMapper->GetOutput()); } else if (GetParameterInt("method") == 2) { otbAppLogINFO("Color mapping with an optimized look-up table"); m_CasterToLabelImage = CasterToLabelImageType::New(); m_CasterToLabelImage->SetInput(GetParameterFloatImage("in")); m_CasterToLabelImage->InPlaceOn(); m_SegmentationColorMapper = LabelToRGBFilterType::New(); m_SegmentationColorMapper->SetInput(m_CasterToLabelImage->GetOutput()); m_SegmentationColorMapper->SetBackgroundValue(GetParameterInt("method.optimal.background")); SetParameterOutputImage("out", m_SegmentationColorMapper->GetOutput()); } else if (GetParameterInt("method") == 3) { otbAppLogINFO("Color mapping with a look-up table computed on support image "); // image normalisation of the sampling FloatVectorImageType::Pointer supportImage = this->GetParameterImage("method.image.in"); //supportImage->UpdateOutputInformation(); //normalisation //first of all resampling //calculate split number RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); int availableRAM = GetParameterInt("ram"); streamingManager->SetAvailableRAMInMB(availableRAM); float bias = 2.0; // empiric value; streamingManager->SetBias(bias); FloatVectorImageType::RegionType largestRegion = supportImage->GetLargestPossibleRegion(); FloatVectorImageType::SizeType largestRegionSize = largestRegion.GetSize(); streamingManager->PrepareStreaming(supportImage, largestRegion); unsigned long nbDivisions = streamingManager->GetNumberOfSplits(); unsigned long largestPixNb = largestRegionSize[0] * largestRegionSize[1]; unsigned long maxPixNb = largestPixNb / nbDivisions; ImageSamplingFilterType::Pointer imageSampler = ImageSamplingFilterType::New(); imageSampler->SetInput(supportImage); double theoricNBSamplesForKMeans = maxPixNb; const double upperThresholdNBSamplesForKMeans = 1000 * 1000; const double actualNBSamplesForKMeans = std::min(theoricNBSamplesForKMeans, upperThresholdNBSamplesForKMeans); const double shrinkFactor = vcl_floor( vcl_sqrt( supportImage->GetLargestPossibleRegion().GetNumberOfPixels() / actualNBSamplesForKMeans)); imageSampler->SetShrinkFactor(shrinkFactor); imageSampler->Update(); otbAppLogINFO(<GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels()<<"" " sample will be used to estimate extrema value for outliers rejection."<GetOutput(); histogramSource->SetRequestedRegion(imageSampler->GetOutput()->GetLargestPossibleRegion()); // Iterate on the image itk::ImageRegionConstIterator it(histogramSource, histogramSource->GetBufferedRegion()); // declare a list to store the samples ListSampleType::Pointer listSample = ListSampleType::New(); listSample->Clear(); //unsigned int sampleSize = VisualizationPixelTraits::PixelSize(it.Get()); unsigned int sampleSize = itk::NumericTraits::GetLength(it.Get()); listSample->SetMeasurementVectorSize(sampleSize); // Fill the samples list for (it.GoToBegin(); !it.IsAtEnd(); ++it) { SampleType sample(sampleSize); //VisualizationPixelTraits::Convert(it.Get(), sample); listSample->PushBack(it.Get()); } // assign listSample HistogramFilterType::Pointer histogramFilter = HistogramFilterType::New(); histogramFilter->SetListSample(listSample); histogramFilter->SetNumberOfBins(255); if (this->IsParameterEnabled("method.image.nodatavalue") == true) { // NoData value extraction for the support image float noDataValue = this->GetParameterFloat("method.image.nodatavalue"); otbAppLogINFO(" The NoData value: "<SetNoDataValue(noDataValue); histogramFilter->NoDataFlagOn(); } else { otbAppLogINFO(" The NoData value of the support image is disabled. Thus, all the values will be handled in the LUT estimation."<NoDataFlagOff(); } // Generate histogramFilter->Update(); const HistogramListType * histogramList = histogramFilter->GetOutput(); ImageMetadataInterfaceType::Pointer metadataInterface = ImageMetadataInterfaceFactory::CreateIMI(supportImage->GetMetaDataDictionary()); std::vector RGBIndex; if (supportImage->GetNumberOfComponentsPerPixel() < 3) { RGBIndex.push_back(0); RGBIndex.push_back(0); RGBIndex.push_back(0); } else RGBIndex = metadataInterface->GetDefaultDisplay(); otbAppLogINFO(" RGB index are "<GetNumberOfComponentsPerPixel()); maxVal.SetSize(supportImage->GetNumberOfComponentsPerPixel()); for (unsigned int index = 0; index < supportImage->GetNumberOfComponentsPerPixel(); index++) { minVal.SetElement(index, static_cast (histogramList->GetNthElement(index)->Quantile(0, static_cast (this->GetParameterInt("method.image.low"))/ 100.0))); maxVal.SetElement(index, static_cast (histogramList->GetNthElement(index)->Quantile(0, (100.0- static_cast (this->GetParameterInt("method.image.up")))/ 100.0))); } m_CasterToLabelImage = CasterToLabelImageType::New(); m_CasterToLabelImage->SetInput(GetParameterFloatImage("in")); m_CasterToLabelImage->InPlaceOn(); m_StatisticsMapFromLabelImageFilter = StreamingStatisticsMapFromLabelImageFilterType::New(); m_StatisticsMapFromLabelImageFilter->SetInput(GetParameterImage("method.image.in")); m_StatisticsMapFromLabelImageFilter->SetInputLabelImage(m_CasterToLabelImage->GetOutput()); m_StatisticsMapFromLabelImageFilter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(m_StatisticsMapFromLabelImageFilter->GetStreamer(), "Computing statistics on labels..."); m_StatisticsMapFromLabelImageFilter->Update(); StreamingStatisticsMapFromLabelImageFilterType::MeanValueMapType labelToMeanIntensityMap = m_StatisticsMapFromLabelImageFilter->GetMeanValueMap(); m_RBGFromImageMapper = ChangeLabelFilterType::New(); m_RBGFromImageMapper->SetInput(m_CasterToLabelImage->GetOutput()); m_RBGFromImageMapper->SetNumberOfComponentsPerPixel(3); StreamingStatisticsMapFromLabelImageFilterType::MeanValueMapType::const_iterator mapIt = labelToMeanIntensityMap.begin(); FloatVectorImageType::PixelType meanValue; otbAppLogINFO("The map contains :"<first; meanValue = mapIt->second; //meanValue.Size() is null if label is not present in label image if (meanValue.Size() != supportImage->GetNumberOfComponentsPerPixel()) { color.Fill(0.0); } else { for (int RGB = 0; RGB < 3; RGB++) { unsigned int dispIndex = RGBIndex[RGB]; // Convert the radiometric value to [0, 255] // using the clamping from histogram cut // Since an UInt8 output value is expected, the rounding instruction is used (floor(x+0.5) as rounding method) double val = vcl_floor((255 * (meanValue[dispIndex] - minVal[dispIndex]) / (maxVal[dispIndex] - minVal[dispIndex])) + 0.5); val = val < 0.0 ? 0.0 : ( val > 255.0 ? 255.0 : val ); color[RGB] = static_cast(val); } } otbMsgDevMacro(<<"Adding color mapping " << clabel << " -> [" << (int) color[0] << " " << (int) color[1] << " "<< (int) color[2] << " ]"); m_RBGFromImageMapper->SetChange(clabel, color); } SetParameterOutputImage("out", m_RBGFromImageMapper->GetOutput()); } } void ComputeColorToLabel() { if (GetParameterInt("method")==1 || GetParameterInt("method")==3) { otbAppLogWARNING("Case not implemented"); return; } RGBImageType::Pointer input = GetParameterUInt8RGBImage("in"); m_InverseMapper = ColorToLabelFilterType::New(); m_InverseMapper->SetInput(input); m_InverseMapper->GetFunctor().SetOutputSize(1); LabelVectorType notFoundValue(1); notFoundValue[0] = GetParameterInt("op.colortolabel.notfound"); m_InverseMapper->GetFunctor().SetNotFoundValue(notFoundValue); if(GetParameterInt("method")==0) { otbAppLogINFO("Color mapping with custom labeled look-up table"); ReadLutFromFile(false); SetParameterOutputImage("out", m_InverseMapper->GetOutput()); } else if(GetParameterInt("method")==2) { otbAppLogINFO("Color mapping with an optimized look-up table"); // Safe mode : the LUT is computed with the colors found in the image std::set > colorList; RGBPixelType background; background.Fill(0); //we assume the background will be black LabelType currentLabel; currentLabel = GetParameterInt("method.optimal.background"); colorList.insert(background); LabelVectorType currentVectorLabel(1); currentVectorLabel[0] = currentLabel; m_InverseMapper->GetFunctor().SetChange(background, currentVectorLabel); ++currentLabel; // Setting up local streaming capabilities RegionType largestRegion = input->GetLargestPossibleRegion(); RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); int availableRAM = GetParameterInt("ram"); streamingManager->SetAvailableRAMInMB(availableRAM); float bias = 2.0; // empiric value; streamingManager->SetBias(bias); streamingManager->PrepareStreaming(input, largestRegion); unsigned long numberOfStreamDivisions = streamingManager->GetNumberOfSplits(); otbAppLogINFO("Number of divisions : "<GetSplit(index); input->SetRequestedRegion(streamingRegion); input->PropagateRequestedRegion(); input->UpdateOutputData(); RGBImageIteratorType it(input, streamingRegion); it.GoToBegin(); while ( !it.IsAtEnd()) { // if the color isn't registered, it is added to the color map if (colorList.find(it.Get())==colorList.end()) { colorList.insert(it.Get()); currentVectorLabel[0] = currentLabel; m_InverseMapper->GetFunctor().SetChange(it.Get(), currentVectorLabel); ++currentLabel; } ++it; } } SetParameterOutputImage("out", m_InverseMapper->GetOutput()); } } void ReadLutFromFile(bool putLabelBeforeColor) { std::ifstream ifs; ifs.open(GetParameterString("method.custom.lut").c_str()); if (!ifs) { itkExceptionMacro("Can not read file " << GetParameterString("method.custom.lut") << std::endl); } otbAppLogINFO("Parsing color map file " << GetParameterString("method.custom.lut") << "." << std::endl); RGBPixelType rgbcolor; LabelVectorType cvlabel(1); while (!ifs.eof()) { std::string line; std::getline(ifs, line); // Avoid commented lines or too short ones if (!line.empty() && line[0] != '#') { // retrieve the label std::string::size_type length; std::string::size_type pos = line.find_first_not_of(" \t;,", 0); if (pos == std::string::npos) continue; std::string::size_type nextpos = line.find_first_of(" \t;,", pos); if (nextpos == std::string::npos) continue; length = nextpos - pos; LabelType clabel = atoi(line.substr(pos, length).c_str()); // Retrieve the color VectorPixelType color(3); color.Fill(0); unsigned int i; for (i = 0; i < 3; ++i) { if (nextpos == std::string::npos) break; pos = line.find_first_not_of(" \t;,", nextpos); if (pos == std::string::npos) break; nextpos = line.find_first_of(" \t;,", pos); length = ( nextpos == std::string::npos ? std::string::npos : nextpos - pos ); int value = atoi(line.substr(pos, length).c_str()); if (value < 0 || value > 255) otbAppLogWARNING("WARNING: color value outside 8-bits range (<0 or >255). Value will be clamped." << std::endl); color[i] = static_cast (value); } // test if 3 values have been parsed if (i < 3) continue; otbAppLogINFO("Adding color mapping " << clabel << " -> [" << (int) color[0] << " " << (int) color[1] << " "<< (int) color[2] << " ]" << std::endl); if(putLabelBeforeColor) { m_CustomMapper->SetChange(clabel, color); } else { cvlabel[0] = clabel; rgbcolor[0] = static_cast(color[0]); rgbcolor[1] = static_cast(color[1]); rgbcolor[2] = static_cast(color[2]); m_InverseMapper->GetFunctor().SetChange(rgbcolor, cvlabel); } } } ifs.close(); } ChangeLabelFilterType::Pointer m_CustomMapper; ColorMapFilterType::Pointer m_ContinuousColorMapper; LabelToRGBFilterType::Pointer m_SegmentationColorMapper; std::map m_LutMap; ChangeLabelFilterType::Pointer m_RBGFromImageMapper; StreamingStatisticsMapFromLabelImageFilterType::Pointer m_StatisticsMapFromLabelImageFilter; ColorToLabelFilterType::Pointer m_InverseMapper; CasterToLabelImageType::Pointer m_CasterToLabelImage; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ColorMapping) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbCompareImages.cxx000066400000000000000000000222041301006202600267050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbStreamingCompareImageFilter.h" namespace otb { namespace Wrapper { class CompareImages : public Application { public: /** Standard class typedefs. */ typedef CompareImages Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(CompareImages, otb::Application); /** Filters typedef */ typedef otb::MultiToMonoChannelExtractROI ExtractROIMonoFilterType; typedef otb::StreamingCompareImageFilter StreamingCompareImageFilterType; private: void DoInit() ITK_OVERRIDE { SetName("CompareImages"); SetDescription("Estimator between 2 images."); // Documentation SetDocName("Images comparison"); SetDocLongDescription("This application computes MSE (Mean Squared Error), MAE (Mean Absolute Error) and PSNR (Peak Signal to Noise Ratio) between the channel of two images (reference and measurement). The user has to set the used channel and can specify a ROI."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("BandMath application, ImageStatistics"); AddDocTag("Statistics"); AddParameter(ParameterType_Group, "ref", "Reference image properties"); AddParameter(ParameterType_InputImage, "ref.in", "Reference image"); SetParameterDescription("ref.in", "Image used as reference in the comparison"); AddParameter(ParameterType_Int, "ref.channel", "Reference image channel"); SetParameterDescription("ref.channel", "Used channel for the reference image"); SetDefaultParameterInt("ref.channel", 1); SetMinimumParameterIntValue("ref.channel", 1); AddParameter(ParameterType_Group, "meas", "Measured image properties"); AddParameter(ParameterType_InputImage, "meas.in", "Measured image"); SetParameterDescription("meas.in", "Image used as measured in the comparison"); AddParameter(ParameterType_Int, "meas.channel", "Measured image channel"); SetParameterDescription("meas.channel", "Used channel for the measured image"); SetDefaultParameterInt("meas.channel", 1); SetMinimumParameterIntValue("meas.channel", 1); AddParameter(ParameterType_Group, "roi", "Region Of Interest (relative to reference image)"); AddParameter(ParameterType_Int, "roi.startx", "Start X"); SetDefaultParameterInt("roi.startx", 0); SetMinimumParameterIntValue("roi.startx", 0); SetParameterDescription("roi.startx", "ROI start x position."); AddParameter(ParameterType_Int, "roi.starty", "Start Y"); SetDefaultParameterInt("roi.starty", 0); SetMinimumParameterIntValue("roi.starty", 0); SetParameterDescription("roi.starty", "ROI start y position."); AddParameter(ParameterType_Int, "roi.sizex", "Size X"); SetDefaultParameterInt("roi.sizex", 0); SetMinimumParameterIntValue("roi.sizex", 1); SetParameterDescription("roi.sizex","Size along x in pixels."); AddParameter(ParameterType_Int, "roi.sizey", "Size Y"); SetDefaultParameterInt("roi.sizey", 0); SetMinimumParameterIntValue("roi.sizey", 1); SetParameterDescription("roi.sizey","Size along y in pixels."); AddParameter(ParameterType_Float, "mse", "MSE"); SetParameterDescription("mse", "Mean Squared Error value"); SetParameterRole("mse", Role_Output ); AddParameter(ParameterType_Float, "mae", "MAE"); SetParameterDescription("mae", "Mean Absolute Error value"); SetParameterRole("mae", Role_Output ); AddParameter(ParameterType_Float, "psnr", "PSNR"); SetParameterDescription("psnr", "Peak Signal to Noise Ratio value"); SetParameterRole("psnr", Role_Output); AddParameter(ParameterType_Float, "count", "count"); SetParameterDescription("count", "Nb of pixels which are different"); SetParameterRole("count", Role_Output); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("ref.in", "GomaApres.png"); SetDocExampleParameterValue("ref.channel", "1"); SetDocExampleParameterValue("meas.in", "GomaAvant.png"); SetDocExampleParameterValue("meas.channel", "2"); SetDocExampleParameterValue("roi.startx", "20"); SetDocExampleParameterValue("roi.starty", "30"); SetDocExampleParameterValue("roi.sizex", "150"); SetDocExampleParameterValue("roi.sizey", "200"); } void DoUpdateParameters() ITK_OVERRIDE { // Set channel interval if( HasValue("ref.in") ) { SetMaximumParameterIntValue("ref.channel", this->GetParameterImage("ref.in")->GetNumberOfComponentsPerPixel()); } if( HasValue("meas.in") ) { SetMaximumParameterIntValue("meas.channel", this->GetParameterImage("meas.in")->GetNumberOfComponentsPerPixel()); } // ROI if ( HasValue("ref.in") ) { FloatVectorImageType::RegionType largestRegion = this->GetParameterImage("ref.in")->GetLargestPossibleRegion(); // Put the limit of the index and the size relative the image SetMinimumParameterIntValue("roi.sizex", 1); SetMaximumParameterIntValue("roi.sizex", largestRegion.GetSize(0)); SetMinimumParameterIntValue("roi.sizey", 1); SetMaximumParameterIntValue("roi.sizey", largestRegion.GetSize(1)); SetMinimumParameterIntValue("roi.startx", 0); SetMaximumParameterIntValue("roi.startx", largestRegion.GetSize(0) - 1); SetMinimumParameterIntValue("roi.starty", 0); SetMaximumParameterIntValue("roi.starty", largestRegion.GetSize(1) - 1); } } void DoExecute() ITK_OVERRIDE { // Init filters m_ExtractRefFilter = ExtractROIMonoFilterType::New(); m_ExtractMeasFilter = ExtractROIMonoFilterType::New(); m_CompareFilter = StreamingCompareImageFilterType::New(); // Get input image pointers FloatVectorImageType::Pointer refIm = this->GetParameterImage("ref.in"); FloatVectorImageType::Pointer measIm = this->GetParameterImage("meas.in"); // Get the region of interest FloatVectorImageType::RegionType region; region.SetIndex(0, GetParameterInt("roi.startx")); region.SetIndex(1, GetParameterInt("roi.starty")); region.SetSize(0, GetParameterInt("roi.sizex")); region.SetSize(1, GetParameterInt("roi.sizey")); if (region.GetNumberOfPixels() == 0) { otbAppLogINFO( << "Using whole reference image since the ROI contains no pixels or is not specified" ); region = GetParameterImage("ref.in")->GetLargestPossibleRegion(); } otbAppLogDEBUG( << "Region of interest used for comparison : " << region ); if( !region.Crop(refIm->GetLargestPossibleRegion()) || !region.Crop(measIm->GetLargestPossibleRegion()) ) { otbAppLogFATAL( << "ROI is not contained in the images regions"); } m_ExtractRefFilter->SetInput( refIm ); m_ExtractMeasFilter->SetInput( measIm ); m_ExtractRefFilter->SetExtractionRegion(region); m_ExtractMeasFilter->SetExtractionRegion(region); // Set channels to extract otbAppLogINFO( << "reference image channel "<GetParameterInt("ref.channel")<<" is compared with measured image channel "<GetParameterInt("meas.channel")); m_ExtractRefFilter->SetChannel( this->GetParameterInt("ref.channel") ); m_ExtractMeasFilter->SetChannel( this->GetParameterInt("meas.channel") ); // Compute comparison m_CompareFilter->SetInput1(m_ExtractRefFilter->GetOutput()); m_CompareFilter->SetInput2(m_ExtractMeasFilter->GetOutput()); m_CompareFilter->SetPhysicalSpaceCheck(false); m_CompareFilter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(m_CompareFilter->GetStreamer(), "Comparing..."); m_CompareFilter->Update(); // Show result otbAppLogINFO( << "MSE: " << m_CompareFilter->GetMSE() ); otbAppLogINFO( << "MAE: " << m_CompareFilter->GetMAE() ); otbAppLogINFO( << "PSNR: " << m_CompareFilter->GetPSNR() ); otbAppLogINFO( << "Number of Pixel different: " << m_CompareFilter->GetDiffCount() ); SetParameterFloat( "mse", m_CompareFilter->GetMSE() ); SetParameterFloat( "mae", m_CompareFilter->GetMAE() ); SetParameterFloat( "psnr", m_CompareFilter->GetPSNR() ); SetParameterFloat( "count", m_CompareFilter->GetDiffCount() ); } ExtractROIMonoFilterType::Pointer m_ExtractRefFilter; ExtractROIMonoFilterType::Pointer m_ExtractMeasFilter; StreamingCompareImageFilterType::Pointer m_CompareFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::CompareImages) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbConcatenateImages.cxx000066400000000000000000000114751301006202600275530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbImageListToVectorImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageList.h" namespace otb { namespace Wrapper { class ConcatenateImages : public Application { public: /** Standard class typedefs. */ typedef ConcatenateImages Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ConcatenateImages, otb::Application); /** Filters typedef */ typedef otb::ImageList ImageListType; typedef ImageListToVectorImageFilter ListConcatenerFilterType; typedef MultiToMonoChannelExtractROI ExtractROIFilterType; typedef ObjectList ExtractROIFilterListType; private: void DoInit() ITK_OVERRIDE { SetName("ConcatenateImages"); SetDescription("Concatenate a list of images of the same size into a single multi-channel one."); // Documentation SetDocName("Images Concatenation"); SetDocLongDescription("This application performs images channels concatenation. It will walk the input image list (single or multi-channel) and generates a single multi-channel image. The channel order is the one of the list."); SetDocLimitations("All input images must have the same size."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("Rescale application, Convert"); AddDocTag(Tags::Manip); AddDocTag("Concatenation"); AddDocTag("Multi-channel"); m_Concatener = ListConcatenerFilterType::New(); m_ExtractorList = ExtractROIFilterListType::New(); m_ImageList = ImageListType::New(); AddParameter(ParameterType_InputImageList, "il", "Input images list"); SetParameterDescription("il", "The list of images to concatenate"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "The concatenated output image"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("il", "GomaAvant.png GomaApres.png"); SetDocExampleParameterValue("out", "otbConcatenateImages.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent // Reinitialize the object m_Concatener = ListConcatenerFilterType::New(); m_ImageList = ImageListType::New(); m_ExtractorList = ExtractROIFilterListType::New(); } void DoExecute() ITK_OVERRIDE { // Get the input image list FloatVectorImageListType::Pointer inList = this->GetParameterImageList("il"); if( inList->Size() == 0 ) { itkExceptionMacro("No input Image set..."); } inList->GetNthElement(0)->UpdateOutputInformation(); FloatVectorImageType::SizeType size = inList->GetNthElement(0)->GetLargestPossibleRegion().GetSize(); // Split each input vector image into image // and generate an mono channel image list for( unsigned int i=0; iSize(); i++ ) { FloatVectorImageType::Pointer vectIm = inList->GetNthElement(i); vectIm->UpdateOutputInformation(); if( size != vectIm->GetLargestPossibleRegion().GetSize() ) { itkExceptionMacro("Input Image size mismatch..."); } for( unsigned int j=0; jGetNumberOfComponentsPerPixel(); j++) { ExtractROIFilterType::Pointer extractor = ExtractROIFilterType::New(); extractor->SetInput( vectIm ); extractor->SetChannel( j+1 ); extractor->UpdateOutputInformation(); m_ExtractorList->PushBack( extractor ); m_ImageList->PushBack( extractor->GetOutput() ); } } m_Concatener->SetInput( m_ImageList ); SetParameterOutputImage("out", m_Concatener->GetOutput()); } ListConcatenerFilterType::Pointer m_Concatener; ExtractROIFilterListType::Pointer m_ExtractorList; ImageListType::Pointer m_ImageList; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ConcatenateImages) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbConvert.cxx000066400000000000000000000303721301006202600256160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "itkCastImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "itkCastImageFilter.h" #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbStreamingShrinkImageFilter.h" #include "itkListSample.h" #include "otbListSampleToHistogramListGenerator.h" #include "itkImageRegionConstIterator.h" namespace otb { namespace Wrapper { namespace Functor { template< class TScalar > class ITK_EXPORT LogFunctor { public: LogFunctor(){}; ~LogFunctor(){}; TScalar operator() (const TScalar& v) const { return vcl_log(v); } }; } // end namespace Functor class Convert : public Application { public: /** Standard class typedefs. */ typedef Convert Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Convert, otb::Application); /** Filters typedef */ typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::DenseFrequencyContainer2 DFContainerType; typedef ListSampleToHistogramListGenerator HistogramsGeneratorType; typedef StreamingShrinkImageFilter ShrinkFilterType; typedef Functor::LogFunctor TransferLogFunctor; typedef UnaryImageFunctorWithVectorImageFilter TransferLogType; private: void DoInit() ITK_OVERRIDE { SetName("Convert"); SetDescription("Convert an image to a different format, eventually rescaling the data" " and/or changing the pixel type."); // Documentation SetDocName("Image Conversion"); SetDocLongDescription("This application performs an image pixel type conversion (short, ushort, uchar, int, uint, float and double types are handled). The output image is written in the specified format (ie. that corresponds to the given extension).\n The conversion can include a rescale using the image 2 percent minimum and maximum values. The rescale can be linear or log2."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("Rescale"); AddDocTag("Conversion"); AddDocTag("Image Dynamic"); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImage, "in", "Input image"); SetParameterDescription("in", "Input image"); AddParameter(ParameterType_Choice, "type", "Rescale type"); SetParameterDescription("type", "Transfer function for the rescaling"); AddChoice("type.none", "None"); AddChoice("type.linear", "Linear"); AddChoice("type.log2", "Log2"); SetParameterString("type", "none"); AddParameter(ParameterType_Float,"type.linear.gamma","Gamma correction factor"); SetParameterDescription("type.linear.gamma","Gamma correction factor"); SetDefaultParameterFloat("type.linear.gamma",1.0); MandatoryOff("type.linear.gamma"); AddParameter(ParameterType_InputImage, "mask", "Input mask"); SetParameterDescription("mask", "The masked pixels won't be used to adapt the dynamic (the mask must have the same dimensions as the input image)"); MandatoryOff("mask"); DisableParameter("mask"); AddParameter(ParameterType_Group,"hcp","Histogram Cutting Parameters"); SetParameterDescription("hcp","Parameters to cut the histogram edges before rescaling"); AddParameter(ParameterType_Float, "hcp.high", "High Cut Quantile"); SetParameterDescription("hcp.high", "Quantiles to cut from histogram high values before computing min/max rescaling (in percent, 2 by default)"); MandatoryOff("hcp.high"); SetDefaultParameterFloat("hcp.high", 2.0); DisableParameter("hcp.high"); AddParameter(ParameterType_Float, "hcp.low", "Low Cut Quantile"); SetParameterDescription("hcp.low", "Quantiles to cut from histogram low values before computing min/max rescaling (in percent, 2 by default)"); MandatoryOff("hcp.low"); SetDefaultParameterFloat("hcp.low", 2.0); DisableParameter("hcp.low"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("out", "otbConvertWithScalingOutput.png uint8"); SetDocExampleParameterValue("type", "linear"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } template void GenericDoExecute() { typename TImageType::Pointer castIm; std::string rescaleType = this->GetParameterString("type"); if( (rescaleType != "none") && (rescaleType != "linear") && (rescaleType != "log2") ) { itkExceptionMacro("Unknown rescale type "<GetParameterImage("in"); } else { FloatVectorImageType::Pointer input = this->GetParameterImage("in"); FloatVectorImageType::Pointer mask; bool useMask = false; if (IsParameterEnabled("mask")) { mask = this->GetParameterImage("mask"); useMask = true; } const unsigned int nbComp(input->GetNumberOfComponentsPerPixel()); typedef otb::VectorRescaleIntensityImageFilter RescalerType; typename TImageType::PixelType minimum; typename TImageType::PixelType maximum; minimum.SetSize(nbComp); maximum.SetSize(nbComp); minimum.Fill( itk::NumericTraits::min() ); maximum.Fill( itk::NumericTraits::max() ); typename RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(minimum); rescaler->SetOutputMaximum(maximum); // We need to subsample the input image in order to estimate its // histogram typename ShrinkFilterType::Pointer shrinkFilter = ShrinkFilterType::New(); // Shrink factor is computed so as to load a quicklook of 1000 // pixels square at most typename FloatVectorImageType::SizeType imageSize = input->GetLargestPossibleRegion().GetSize(); unsigned int shrinkFactor = std::max(imageSize[0], imageSize[1]) < 1000 ? 1 : std::max(imageSize[0], imageSize[1])/1000; otbAppLogDEBUG( << "Shrink factor used to compute Min/Max: "<SetShrinkFactor(shrinkFactor); shrinkFilter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(shrinkFilter->GetStreamer(), "Computing shrink Image for min/max estimation..."); if ( rescaleType == "log2") { //define the transfer log m_TransferLog = TransferLogType::New(); m_TransferLog->SetInput(input); m_TransferLog->UpdateOutputInformation(); shrinkFilter->SetInput(m_TransferLog->GetOutput()); rescaler->SetInput(m_TransferLog->GetOutput()); shrinkFilter->Update(); } else { shrinkFilter->SetInput(input); rescaler->SetInput(input); shrinkFilter->Update(); } ShrinkFilterType::Pointer maskShrinkFilter = ShrinkFilterType::New(); if (useMask) { maskShrinkFilter->SetShrinkFactor(shrinkFactor); maskShrinkFilter->SetInput(mask); maskShrinkFilter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); maskShrinkFilter->Update(); } otbAppLogDEBUG( << "Shrink done" ); otbAppLogDEBUG( << "Evaluating input Min/Max..." ); itk::ImageRegionConstIterator it(shrinkFilter->GetOutput(), shrinkFilter->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionConstIterator itMask; if (useMask) { itMask = itk::ImageRegionConstIterator(maskShrinkFilter->GetOutput(),maskShrinkFilter->GetOutput()->GetLargestPossibleRegion()); } typename ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(input->GetNumberOfComponentsPerPixel()); // Now we generate the list of samples if (useMask) { // Remove masked pixels it.GoToBegin(); itMask.GoToBegin(); while (!it.IsAtEnd()) { // float values, so the threshold is set to 0.5 if (itMask.Get()[0] < 0.5) { listSample->PushBack(it.Get()); } ++it; ++itMask; } } else { for(it.GoToBegin(); !it.IsAtEnd(); ++it) { listSample->PushBack(it.Get()); } } // if all pixels were masked, we assume a wrong mask and then include all image if (listSample->Size() == 0) { otbAppLogINFO( << "All pixels were masked, the application assume a wrong mask and include all the image"); for(it.GoToBegin(); !it.IsAtEnd(); ++it) { listSample->PushBack(it.Get()); } } // And then the histogram typename HistogramsGeneratorType::Pointer histogramsGenerator = HistogramsGeneratorType::New(); histogramsGenerator->SetListSample(listSample); histogramsGenerator->SetNumberOfBins(255); histogramsGenerator->NoDataFlagOn(); histogramsGenerator->Update(); // And extract the lower and upper quantile typename FloatVectorImageType::PixelType inputMin(nbComp), inputMax(nbComp); for(unsigned int i = 0; i < nbComp; ++i) { inputMin[i] = histogramsGenerator->GetOutput()->GetNthElement(i)->Quantile(0, 0.01 * GetParameterFloat("hcp.low")); inputMax[i] = histogramsGenerator->GetOutput()->GetNthElement(i)->Quantile(0, 1.0 - 0.01 * GetParameterFloat("hcp.high")); } otbAppLogDEBUG( << std::setprecision(5) << "Min/Max computation done : min=" << inputMin << " max=" << inputMax ); rescaler->AutomaticInputMinMaxComputationOff(); rescaler->SetInputMinimum(inputMin); rescaler->SetInputMaximum(inputMax); if ( rescaleType == "linear") { rescaler->SetGamma(GetParameterFloat("type.linear.gamma")); } m_TmpFilter = rescaler; castIm = rescaler->GetOutput(); } SetParameterOutputImage("out", castIm); } void DoExecute() ITK_OVERRIDE { switch ( this->GetParameterOutputImagePixelType("out") ) { case ImagePixelType_uint8: GenericDoExecute(); break; case ImagePixelType_int16: GenericDoExecute(); break; case ImagePixelType_uint16: GenericDoExecute(); break; case ImagePixelType_int32: GenericDoExecute(); break; case ImagePixelType_uint32: GenericDoExecute(); break; case ImagePixelType_float: GenericDoExecute(); break; case ImagePixelType_double: GenericDoExecute(); break; default: itkExceptionMacro("Unknown pixel type "<GetParameterOutputImagePixelType("out")<<"."); break; } } itk::ProcessObject::Pointer m_TmpFilter; TransferLogType::Pointer m_TransferLog; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::Convert) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbDEMConvert.cxx000066400000000000000000000134471301006202600261500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbDEMConvertAdapter.h" #include "itkImageIOFactory.h" namespace otb { namespace Wrapper { class DEMConvert : public Application { public: /** Standard class typedefs. */ typedef DEMConvert Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(DEMConvert, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("DEMConvert"); SetDescription("Converts a geo-referenced DEM image into a general raster file compatible with OTB DEM handling."); SetDocName("DEM Conversion"); SetDocLongDescription("In order to be understood by the Orfeo ToolBox and the underlying OSSIM library, a geo-referenced Digital Elevation Model image can be converted into a general raster image, which consists in 3 files with the following extensions: .ras, .geom and .omd. Once converted, you have to place these files in a separate directory, and you can then use this directory to set the \"DEM Directory\" parameter of a DEM based OTB application or filter."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImage, "in", "Input geo-referenced DEM"); SetParameterDescription("in", "Input geo-referenced DEM to convert to general raster format."); AddParameter(ParameterType_OutputFilename, "out", "Prefix of the output files"); std::ostringstream oss; oss << "will be used to get the prefix (name withtout extensions) of the files to write. "; oss << "Three files - prefix.geom, prefix.omd and prefix.ras - will be generated."; SetParameterDescription("out", oss.str()); //MandatoryOn("out"); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_Elev.tif"); SetDocExampleParameterValue("out", "outputDEM"); } void DoUpdateParameters() ITK_OVERRIDE { // nothing to update } /* The main is simple : read image using OTB and write it as a tif. * Read this tif using OSSIM and convert it as a general raster file * (.ras, .geom and . omd) */ void DoExecute() ITK_OVERRIDE { // Load input image FloatVectorImageType::Pointer inImage = GetParameterImage("in"); // Set temporary tif filename (for ossim) std::string ofname = GetParameterString("out"); std::string path = itksys::SystemTools::GetFilenamePath(ofname); std::string fname = itksys::SystemTools::GetFilenameWithoutExtension(ofname); std::string tempFilename = path+"/"+fname+"_DEMConvert.tif"; std::string tempFilenameGeom = path+"/"+fname+"_DEMConvert.geom"; // Generate the tif image using OTB while keeping the same pixel // type then the input image // Initialize an outputParameter and set its output pixeltype OutputImageParameter::Pointer paramOut = OutputImageParameter::New(); std::ostringstream osswriter; osswriter<< "writing temporary tif file"; // Set the filename of the current output image paramOut->SetFileName(tempFilename); paramOut->SetValue(inImage); // Set the output pixel type ImageIOBase::Pointer imageIO = ImageIOFactory::CreateImageIO( GetParameterString("in").c_str(), ImageIOFactory::ReadMode); std::string componentTypeInfo(imageIO->GetComponentTypeInfo().name()); if( componentTypeInfo == typeid(unsigned char).name()) { paramOut->SetPixelType(ImagePixelType_uint8); } else if( componentTypeInfo == typeid(unsigned short).name()) { paramOut->SetPixelType(ImagePixelType_uint16); } else if( componentTypeInfo == typeid(short).name()) { paramOut->SetPixelType(ImagePixelType_int16); } else if( componentTypeInfo == typeid(unsigned int).name()) { paramOut->SetPixelType(ImagePixelType_uint32); } else if( componentTypeInfo == typeid(int).name()) { paramOut->SetPixelType(ImagePixelType_int32); } else if( componentTypeInfo == typeid(float).name()) { paramOut->SetPixelType(ImagePixelType_float); } else if( componentTypeInfo == typeid(double).name()) { paramOut->SetPixelType(ImagePixelType_double); } else { itkExceptionMacro("This application doesn't support image pixel type " << componentTypeInfo); } // Add the tempfilename to be written paramOut->InitializeWriters(); AddProcess(paramOut->GetWriter(), osswriter.str()); paramOut->Write(); // Set the output ras file std::string output = path+"/"+fname+".ras"; DEMConvertAdapter::Pointer DEMConverter = DEMConvertAdapter::New(); DEMConverter->Convert(tempFilename, output); // remove the temprorary tif file if( !itksys::SystemTools::RemoveFile(tempFilename.c_str()) ) { itkExceptionMacro("Problem while removing the file " << tempFilename); } // remove the geom file if any if( itksys::SystemTools::FileExists(tempFilenameGeom.c_str()) && !itksys::SystemTools::RemoveFile(tempFilenameGeom.c_str())) { itkExceptionMacro("Problem while removing the Geom file " << tempFilenameGeom); } } }; } // namespace otb } OTB_APPLICATION_EXPORT(otb::Wrapper::DEMConvert) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbDownloadSRTMTiles.cxx000066400000000000000000000364131301006202600274560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbGenericRSTransform.h" #include "otbCurlHelper.h" namespace otb { enum { Mode_Download, Mode_List }; const std::string SRTMServerPath = "http://dds.cr.usgs.gov/srtm/version2_1/SRTM3/"; const char* USGSContinentDir[] = {"Africa", "Australia", "Eurasia", "Islands", "North_America", "South_America"}; const std::vector USGSContinentList(USGSContinentDir, USGSContinentDir + sizeof(USGSContinentDir)/sizeof(USGSContinentDir[0])); const std::string HGTExtension = ".hgt.zip"; const std::string HGTExtensionSimulation = ".hgt"; namespace Wrapper { class DownloadSRTMTiles : public Application { public: /** Standard class typedefs. */ typedef DownloadSRTMTiles Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::GenericRSTransform<> RSTransformType; typedef FloatVectorImageType::IndexType IndexType; typedef FloatVectorImageType::PointType PointType; typedef FloatVectorImageType::SizeType SizeType; typedef FloatVectorImageType::SpacingType SpacingType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(DownloadSRTMTiles, otb::Application); private: int m_Mode; DownloadSRTMTiles() : m_Mode(Mode_Download) {} bool SRTMTileExists(const std::string & url) const { switch ( m_Mode ) { case Mode_Download: { CurlHelper::Pointer curl = CurlHelper::New(); curl->SetTimeout(0); return !curl->IsCurlReturnHttpError(url); } break; case Mode_List: { return itksys::SystemTools::FileExists(url.c_str()); } default : break; } return false; } void DoInit() ITK_OVERRIDE { SetName("DownloadSRTMTiles"); SetDescription("Download or list SRTM tiles related to a set of images"); // Documentation SetDocName("Download or list SRTM tiles related to a set of images"); SetDocLongDescription("This application allows selecting the appropriate SRTM tiles that covers a list of images. It builds a list of the required tiles. Two modes are available: the first one download those tiles from the USGS SRTM3 website (http://dds.cr.usgs.gov/srtm/version2_1/SRTM3/), the second one list those tiles in a local directory. In both cases, you need to indicate the directory in which directory tiles will be download or the location of local SRTM files."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag("Utilities"); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImageList, "il", "Input images list"); SetParameterDescription("il", "The list of images on which you want to determine corresponding SRTM tiles."); // UserDefined values AddParameter(ParameterType_Choice, "mode", "Download/List corresponding SRTM tiles."); //MandatoryOn("mode"); AddChoice("mode.download", "Download"); SetParameterDescription("mode.download","Download corresponding tiles on USGE server."); AddParameter(ParameterType_Directory, "mode.download.outdir", "Output directory"); SetParameterDescription("mode.download.outdir", "Directory where zipped tiles will be save. You'll need to unzip all tile files before using them in your application."); AddChoice("mode.list", "List tiles"); SetParameterDescription("mode.list","List tiles in an existing local directory."); AddParameter(ParameterType_Directory, "mode.list.indir", "Input directory"); SetParameterDescription("mode.list.indir", "Input directory where SRTM tiles can are located."); // Doc example parameter settings SetDocExampleParameterValue("il", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("mode", "list"); SetDocExampleParameterValue("mode.list.indir", "/home/user/srtm_dir/"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { //Get the mode m_Mode = GetParameterInt("mode"); // Get the input image list FloatVectorImageListType::Pointer inList = this->GetParameterImageList("il"); if( inList->Size() == 0 ) { itkExceptionMacro("No input Image set..."); } inList->GetNthElement(0)->UpdateOutputInformation(); std::set listTilesVector; std::set tiles; for( unsigned int i=0; iSize(); i++ ) { FloatVectorImageType::Pointer inImage = inList->GetNthElement(i); inImage->UpdateOutputInformation(); RSTransformType::Pointer rsTransformToWGS84 = RSTransformType::New(); rsTransformToWGS84->SetInputKeywordList(inImage->GetImageKeywordlist()); rsTransformToWGS84->SetInputProjectionRef(inImage->GetProjectionRef()); rsTransformToWGS84->SetOutputProjectionRef(static_cast (otb::GeoInformationConversion::ToWKT(4326))); rsTransformToWGS84->InstantiateTransform(); const SizeType size = inImage->GetLargestPossibleRegion().GetSize(); const PointType origin=inImage->GetOrigin(); const SpacingType spacing=inImage->GetSpacing(); PointType upperLeft; upperLeft[0] = origin[0]; upperLeft[1] = origin[1]; PointType upperLeftWGS84 = rsTransformToWGS84->TransformPoint(upperLeft); otbAppLogDEBUG(<< "upperLeftWGS84 " << upperLeftWGS84); PointType upperRight; upperRight[0] = origin[0]+ (size[0] - 1) * spacing[0]; upperRight[1] = origin[1]; PointType upperRightWGS84 = rsTransformToWGS84->TransformPoint(upperRight); otbAppLogDEBUG(<< "upperRightWGS84 " << upperRightWGS84); PointType lowerLeft; lowerLeft[0] = origin[0]; lowerLeft[1] = origin[1]+ (size[1] - 1) * spacing[1]; PointType lowerLeftWGS84 = rsTransformToWGS84->TransformPoint(lowerLeft); otbAppLogDEBUG(<< "lowerLeftWGS84 " << lowerLeftWGS84); PointType lowerRight; lowerRight[0] = origin[0] + (size[0] - 1) * spacing[0]; lowerRight[1] = origin[1] + (size[1] - 1) * spacing[1]; PointType lowerRightWGS84 = rsTransformToWGS84->TransformPoint(lowerRight); otbAppLogDEBUG(<< "lowerRightWGS84 " << lowerRightWGS84); // the iterator constructor can also be used to construct from arrays: const double Longitude[] = {upperLeftWGS84[0],upperRightWGS84[0],lowerLeftWGS84[0],lowerRightWGS84[0]}; const double Latitude[] = {upperLeftWGS84[1],upperRightWGS84[1],lowerLeftWGS84[1],lowerRightWGS84[1]}; std::vector vecLong (Longitude, Longitude + sizeof(Longitude) / sizeof(double) ); std::vector vecLat (Latitude, Latitude + sizeof(Latitude) / sizeof(double) ); std::vector absVecLong; absVecLong.resize(vecLong.size()); // allocate space std::vector absVecLat; absVecLat.resize(vecLat.size()); // allocate space std::vector::iterator AbsLongit=absVecLong.begin(); for (std::vector::const_iterator it=vecLong.begin(); it!=vecLong.end(); ++it) { *AbsLongit = vcl_abs(*it); ++AbsLongit; } std::vector::iterator AbsLatit=absVecLat.begin(); for (std::vector::const_iterator it=vecLat.begin(); it!=vecLat.end(); ++it) { *AbsLatit = vcl_abs(*it); ++AbsLatit; } const unsigned int distMinLong = std::distance(absVecLong.begin(), min_element (absVecLong.begin(),absVecLong.end())); const unsigned int distMaxLong = std::distance(absVecLong.begin(), max_element (absVecLong.begin(),absVecLong.end())); const unsigned int distMinLat = std::distance(absVecLat.begin(), min_element (absVecLat.begin(),absVecLat.end())); const unsigned int distMaxLat = std::distance(absVecLat.begin(), max_element (absVecLat.begin(),absVecLat.end())); //find corresponding tiled for initialization //FIXME recode this properly int floorMinLong = 0; int floorMaxLong = 0; int floorMinLat = 0; int floorMaxLat = 0; if (vecLong.at(distMinLong) <= vecLong.at(distMaxLong)) { floorMinLong = std::floor(vecLong.at(distMinLong)); floorMaxLong = std::floor(vecLong.at(distMaxLong)); } else { floorMinLong = std::floor(vecLong.at(distMaxLong)); floorMaxLong = std::floor(vecLong.at(distMinLong)); } if (vecLat.at(distMinLat) <= vecLat.at(distMaxLat)) { floorMinLat = std::floor(vecLat.at(distMinLat)); floorMaxLat = std::floor(vecLat.at(distMaxLat)); } else { floorMinLat = std::floor(vecLat.at(distMaxLat)); floorMaxLat = std::floor(vecLat.at(distMinLat)); } //Construct SRTM tile filename based on min/max lat/long for (int k = floorMinLat; k <= floorMaxLat; ++k) { for (int j = floorMinLong; j <= floorMaxLong; ++j) { std::ostringstream ossOutput; if (k < 0) { ossOutput << "S"; } else { ossOutput << "N"; } if (vcl_abs(k) <= 9) { ossOutput << "0"; } ossOutput << vcl_abs(k); if (j < 0) { ossOutput << "W"; } else { ossOutput << "E"; } if (vcl_abs(j) >= 10 && vcl_abs(j) < 100) { ossOutput << "0"; } else if (vcl_abs(j) <= 9) { ossOutput << "00"; } ossOutput << vcl_abs(j); tiles.insert(ossOutput.str()); } } } //iterate over all tiles to build URLs for(std::set::const_iterator it= tiles.begin(); it!=tiles.end(); ++it) { switch ( m_Mode ) { case Mode_Download: { //Build URL bool findURL = false; std::string url; for(std::vector::const_iterator contIt= USGSContinentList.begin(); contIt!=USGSContinentList.end(); ++contIt) { std::ostringstream urlStream; CurlHelper::Pointer curl = CurlHelper::New(); curl->SetTimeout(0); urlStream << SRTMServerPath; urlStream << *contIt; urlStream << "/"; urlStream << *it; urlStream << HGTExtension; url = urlStream.str(); if (!curl->IsCurlReturnHttpError( urlStream.str())) { findURL = true; break; } else { //try down casing the url std::string lowerIt = *it; std::transform(it->begin(), it->end(), lowerIt.begin(), ::tolower); urlStream.clear(); urlStream << SRTMServerPath; urlStream << *contIt; urlStream << "/"; urlStream << lowerIt; urlStream << HGTExtension; if (!curl->IsCurlReturnHttpError( urlStream.str())) { tiles.erase(*it); tiles.insert(lowerIt); //urls.insert(urlStream.str()); findURL = true; break; } else { //upcase all std::string upperIt = *it; std::transform(it->begin(), it->end(), upperIt.begin(), ::toupper); urlStream.clear(); urlStream << SRTMServerPath; urlStream << *contIt; urlStream << "/"; urlStream << upperIt; urlStream << HGTExtension; if (!curl->IsCurlReturnHttpError( urlStream.str())) { tiles.erase(*it); tiles.insert(upperIt); //urls.insert(urlStream.str()); findURL = true; break; } } } } if (!findURL) { itkExceptionMacro(<< url <<" not found!"); } otbAppLogINFO(<< "Found Tile on USGS server at URL: " << url); // TODO use the RetrieveUrlInMemory? In this case need to adapt the // timeout const std::string outDir = GetParameterString("mode.download.outdir"); std::ostringstream oss; oss<SetTimeout(0); curlReq->RetrieveFile(url, GetParameterString("mode.download.outdir") + "/" + *it + HGTExtension); //TODO unzip here (can do this in memory?) } break; case Mode_List: { bool findURL = false; std::ostringstream listStream; listStream << "Corresponding SRTM tiles: "; listStream << GetParameterString("mode.list.indir") + "/"; if ( this->SRTMTileExists(GetParameterString("mode.list.indir") + "/" + *it + HGTExtensionSimulation) ) { listStream << *it + HGTExtensionSimulation << " "; findURL = true; } else { //try down casing the url std::string lowerIt = *it; std::transform(it->begin(), it->end(), lowerIt.begin(), ::tolower); if ( this->SRTMTileExists(GetParameterString("mode.list.indir") + "/" + lowerIt + HGTExtensionSimulation) ) { tiles.erase(*it); tiles.insert(lowerIt); findURL = true; } else { //upcase all std::string upperIt = *it; std::transform(it->begin(), it->end(), upperIt.begin(), ::toupper); if (this->SRTMTileExists(GetParameterString("mode.list.indir") + "/" + lowerIt + HGTExtensionSimulation) ) { tiles.erase(*it); tiles.insert(upperIt); findURL = true; } } } if (!findURL) { itkExceptionMacro(<< "Tile " << *it + HGTExtensionSimulation <<" not found in " << GetParameterString("mode.list.indir") << " !"); } otbAppLogINFO( << listStream.str()); } break; } } } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::DownloadSRTMTiles) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbExtractROI.cxx000066400000000000000000000262341301006202600261640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultiChannelExtractROI.h" #include "otbStandardFilterWatcher.h" #include "otbWrapperNumericalParameter.h" #include "otbWrapperListViewParameter.h" #include "otbWrapperTypes.h" #include "otbWrapperElevationParametersHandler.h" #include "otbGenericRSTransform.h" namespace otb { namespace Wrapper { class ExtractROI : public Application { public: /** Standard class typedefs. */ typedef ExtractROI Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::GenericRSTransform<> RSTransformType; typedef RSTransformType::InputPointType Point3DType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ExtractROI, otb::Application); /** Filters typedef */ typedef otb::MultiChannelExtractROI ExtractROIFilterType; private: void DoInit() ITK_OVERRIDE { SetName("ExtractROI"); SetDescription("Extract a ROI defined by the user."); // Documentation SetDocName("Extract ROI"); SetDocLongDescription("This application extracts a Region Of Interest with user defined size, or reference image."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image."); AddRAMParameter(); AddParameter(ParameterType_Choice,"mode","Extraction mode"); AddChoice("mode.standard","Standard"); SetParameterDescription("mode.standard","In standard mode, extract is done according the coordinates entered by the user"); AddChoice("mode.fit","Fit"); SetParameterDescription("mode.fit","In fit mode, extract is made to best fit a reference image."); AddParameter(ParameterType_InputImage,"mode.fit.ref","Reference image"); SetParameterDescription("mode.fit.ref","Reference image to define the ROI"); // Elevation ElevationParametersHandler::AddElevationParameters(this,"mode.fit.elev"); AddParameter(ParameterType_Int, "startx", "Start X"); SetParameterDescription("startx", "ROI start x position."); AddParameter(ParameterType_Int, "starty", "Start Y"); SetParameterDescription("starty", "ROI start y position."); AddParameter(ParameterType_Int, "sizex", "Size X"); SetParameterDescription("sizex","size along x in pixels."); AddParameter(ParameterType_Int, "sizey", "Size Y"); SetParameterDescription("sizey","size along y in pixels."); // Default values SetDefaultParameterInt("startx", 0); SetDefaultParameterInt("starty", 0); SetDefaultParameterInt("sizex", 0); SetDefaultParameterInt("sizey", 0); // Channelist Parameters AddParameter(ParameterType_ListView, "cl", "Output Image channels"); SetParameterDescription("cl","Channels to write in the output image."); // Doc example parameter settings SetDocExampleParameterValue("in", "VegetationIndex.hd"); SetDocExampleParameterValue("startx", "40"); SetDocExampleParameterValue("starty", "250"); SetDocExampleParameterValue("sizex", "150"); SetDocExampleParameterValue("sizey", "150"); SetDocExampleParameterValue("out", "ExtractROI.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Update the sizes only if the user has not defined a size if ( HasValue("in") ) { ExtractROIFilterType::InputImageType* inImage = GetParameterImage("in"); ExtractROIFilterType::InputImageType::RegionType largestRegion = inImage->GetLargestPossibleRegion(); if (!HasUserValue("sizex") && !HasUserValue("sizey") ) { SetParameterInt("sizex", largestRegion.GetSize()[0]); SetParameterInt("sizey", largestRegion.GetSize()[1]); } unsigned int nbComponents = inImage->GetNumberOfComponentsPerPixel(); ListViewParameter *clParam = dynamic_cast(GetParameterByKey("cl")); // Update the values of the channels to be selected if nbComponents is changed if (clParam != ITK_NULLPTR && clParam->GetNbChoices() != nbComponents) { ClearChoices("cl"); for (unsigned int idx = 0; idx < nbComponents; ++idx) { std::ostringstream key, item; key<<"cl.channel"<CropRegionOfInterest()) { // Put the index of the ROI to origin and try to crop again SetParameterInt("startx", 0); SetParameterInt("starty", 0); this->CropRegionOfInterest(); } } if(GetParameterString("mode")=="fit") { this->SetParameterRole("startx",Role_Output); this->SetParameterRole("starty",Role_Output); this->SetParameterRole("sizex",Role_Output); this->SetParameterRole("sizey",Role_Output); this->DisableParameter("startx"); this->DisableParameter("starty"); this->DisableParameter("sizex"); this->DisableParameter("sizey"); } else if(GetParameterString("mode")=="standard") { this->SetParameterRole("startx",Role_Input); this->SetParameterRole("starty",Role_Input); this->SetParameterRole("sizex",Role_Input); this->SetParameterRole("sizey",Role_Input); this->EnableParameter("startx"); this->EnableParameter("starty"); this->EnableParameter("sizex"); this->EnableParameter("sizey"); } } bool CropRegionOfInterest() { FloatVectorImageType::RegionType region; region.SetSize(0, GetParameterInt("sizex")); region.SetSize(1, GetParameterInt("sizey")); region.SetIndex(0, GetParameterInt("startx")); region.SetIndex(1, GetParameterInt("starty")); if ( HasValue("in") ) { if (region.Crop(GetParameterImage("in")->GetLargestPossibleRegion())) { SetParameterInt("sizex", region.GetSize(0)); SetParameterInt("sizey", region.GetSize(1)); SetParameterInt("startx", region.GetIndex(0)); SetParameterInt("starty", region.GetIndex(1)); return true; } } return false; } void DoExecute() ITK_OVERRIDE { ExtractROIFilterType::InputImageType* inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); if(GetParameterString("mode")=="fit") { // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"mode.fit.elev"); FloatVectorImageType::Pointer referencePtr = this->GetParameterImage("mode.fit.ref"); referencePtr->UpdateOutputInformation(); RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetInputKeywordList(referencePtr->GetImageKeywordlist()); rsTransform->SetInputProjectionRef(referencePtr->GetProjectionRef()); rsTransform->SetOutputKeywordList(inImage->GetImageKeywordlist()); rsTransform->SetOutputProjectionRef(inImage->GetProjectionRef()); rsTransform->InstantiateTransform(); FloatVectorImageType::IndexType uli_ref,uri_ref,lli_ref,lri_ref; uli_ref = referencePtr->GetLargestPossibleRegion().GetIndex(); uri_ref = uli_ref; uri_ref[0]+=referencePtr->GetLargestPossibleRegion().GetSize()[0]; lli_ref = uli_ref; lli_ref[1]+=referencePtr->GetLargestPossibleRegion().GetSize()[1]; lri_ref = lli_ref; lri_ref[0]+=referencePtr->GetLargestPossibleRegion().GetSize()[0]; FloatVectorImageType::PointType ulp_ref,urp_ref,llp_ref,lrp_ref; referencePtr->TransformIndexToPhysicalPoint(uli_ref,ulp_ref); referencePtr->TransformIndexToPhysicalPoint(uri_ref,urp_ref); referencePtr->TransformIndexToPhysicalPoint(lli_ref,llp_ref); referencePtr->TransformIndexToPhysicalPoint(lri_ref,lrp_ref); FloatVectorImageType::PointType ulp_out, urp_out, llp_out,lrp_out; ulp_out = rsTransform->TransformPoint(ulp_ref); urp_out = rsTransform->TransformPoint(urp_ref); llp_out = rsTransform->TransformPoint(llp_ref); lrp_out = rsTransform->TransformPoint(lrp_ref); FloatVectorImageType::IndexType uli_out, uri_out, lli_out, lri_out; inImage->TransformPhysicalPointToIndex(ulp_out,uli_out); inImage->TransformPhysicalPointToIndex(urp_out,uri_out); inImage->TransformPhysicalPointToIndex(llp_out,lli_out); inImage->TransformPhysicalPointToIndex(lrp_out,lri_out); FloatVectorImageType::IndexType uli, lri; uli[0] = std::min(std::min(uli_out[0],uri_out[0]),std::min(lli_out[0],lri_out[0])); uli[1] = std::min(std::min(uli_out[1],uri_out[1]),std::min(lli_out[1],lri_out[1])); lri[0] = std::max(std::max(uli_out[0],uri_out[0]),std::max(lli_out[0],lri_out[0])); lri[1] = std::max(std::max(uli_out[1],uri_out[1]),std::max(lli_out[1],lri_out[1])); SetParameterInt("startx",uli[0]); SetParameterInt("starty",uli[1]); SetParameterInt("sizex",lri[0]-uli[0]); SetParameterInt("sizey",lri[1]-uli[1]); this->CropRegionOfInterest(); } m_ExtractROIFilter = ExtractROIFilterType::New(); m_ExtractROIFilter->SetInput(inImage); m_ExtractROIFilter->SetStartX(GetParameterInt("startx")); m_ExtractROIFilter->SetStartY(GetParameterInt("starty")); m_ExtractROIFilter->SetSizeX(GetParameterInt("sizex")); m_ExtractROIFilter->SetSizeY(GetParameterInt("sizey")); for (unsigned int idx = 0; idx < GetSelectedItems("cl").size(); ++idx) { m_ExtractROIFilter->SetChannel(GetSelectedItems("cl")[idx] + 1 ); } SetParameterOutputImage("out", m_ExtractROIFilter->GetOutput()); } ExtractROIFilterType::Pointer m_ExtractROIFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ExtractROI) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbManageNoData.cxx000066400000000000000000000210311301006202600264450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbImageToNoDataMaskFilter.h" #include "otbChangeNoDataValueFilter.h" #include "itkMaskImageFilter.h" #include "otbVectorImageToImageListFilter.h" #include "otbImageListToVectorImageFilter.h" #include "otbChangeInformationImageFilter.h" namespace otb { namespace Wrapper { class ManageNoData : public Application { public: /** Standard class typedefs. */ typedef ManageNoData Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ManageNoData, otb::Application); /** Filters typedef */ typedef otb::ImageToNoDataMaskFilter FilterType; typedef otb::ChangeNoDataValueFilter ChangeNoDataFilterType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorToListFilterType; typedef otb::ImageListToVectorImageFilter ListToVectorFilterType; typedef itk::MaskImageFilter MaskFilterType; typedef otb::ChangeInformationImageFilter ChangeInfoFilterType; private: void DoInit() ITK_OVERRIDE { SetName("ManageNoData"); SetDescription("Manage No-Data"); // Documentation SetDocName("No Data management"); SetDocLongDescription("This application has two modes. The first allows building a mask of no-data pixels from the no-data flags read from the image file. The second allows updating the change the no-data value of an image (pixels value and metadata). This last mode also allows replacing NaN in images with a proper no-data value. To do so, one should activate the NaN is no-data option."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("BanMath"); AddDocTag("Conversion"); AddDocTag("Image Dynamic"); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImage, "in", "Input image"); SetParameterDescription("in", "Input image"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image"); AddParameter(ParameterType_Empty,"usenan", "Consider NaN as no-data"); SetParameterDescription("usenan","If active, the application will consider NaN as no-data values as well"); MandatoryOff("usenan"); DisableParameter("usenan"); AddParameter(ParameterType_Choice,"mode","No-data handling mode"); SetParameterDescription("mode","Allows choosing between different no-data handling options"); AddChoice("mode.buildmask","Build a no-data Mask"); AddParameter(ParameterType_Float,"mode.buildmask.inv","Inside Value"); SetParameterDescription("mode.buildmask.inv","Value given in the output mask to pixels that are not no data pixels"); SetDefaultParameterInt("mode.buildmask.inv",1); AddParameter(ParameterType_Float,"mode.buildmask.outv","Outside Value"); SetParameterDescription("mode.buildmask.outv","Value given in the output mask to pixels that are no data pixels"); SetDefaultParameterInt("mode.buildmask.outv",0); AddChoice("mode.changevalue","Change the no-data value"); AddParameter(ParameterType_Float,"mode.changevalue.newv","The new no-data value"); SetParameterDescription("mode.changevalue.newv","The new no-data value"); SetDefaultParameterInt("mode.changevalue.newv",0); AddChoice("mode.apply","Apply a mask as no-data"); SetParameterDescription("mode.apply","Apply an external mask to an image using the no-data value of the input image"); AddParameter(ParameterType_InputImage, "mode.apply.mask", "Mask image"); SetParameterDescription("mode.apply.mask","Mask to be applied on input image (valid pixels have non null values)"); AddParameter(ParameterType_Float, "mode.apply.ndval", "Nodata value used"); SetParameterDescription("mode.apply.ndval","No Data value used according to the mask image"); SetDefaultParameterFloat("mode.apply.ndval", 0.0); SetParameterString("mode","buildmask"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("out", "QB_Toulouse_Ortho_XS_nodatamask.tif uint8"); SetDocExampleParameterValue("mode.buildmask.inv", "255"); SetDocExampleParameterValue("mode.buildmask.outv", "0"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inputPtr = this->GetParameterImage("in"); m_Filter = FilterType::New(); m_Filter->SetInsideValue(this->GetParameterFloat("mode.buildmask.inv")); m_Filter->SetOutsideValue(this->GetParameterFloat("mode.buildmask.outv")); m_Filter->SetNaNIsNoData(IsParameterEnabled("usenan")); m_Filter->SetInput(inputPtr); m_ChangeNoDataFilter = ChangeNoDataFilterType::New(); m_ChangeNoDataFilter->SetInput(inputPtr); m_ChangeNoDataFilter->SetNaNIsNoData(IsParameterEnabled("usenan")); std::vector newNoData(inputPtr->GetNumberOfComponentsPerPixel(),GetParameterFloat("mode.changevalue.newv")); m_ChangeNoDataFilter->SetNewNoDataValues(newNoData); if(GetParameterString("mode") == "buildmask") { SetParameterOutputImage("out",m_Filter->GetOutput()); } else if(GetParameterString("mode") == "changevalue") { SetParameterOutputImage("out",m_ChangeNoDataFilter->GetOutput()); } else if (GetParameterString("mode") == "apply") { m_MaskFilters.clear(); UInt8ImageType::Pointer maskPtr = this->GetParameterImage("mode.apply.mask"); unsigned int nbBands = inputPtr->GetNumberOfComponentsPerPixel(); itk::MetaDataDictionary &dict = inputPtr->GetMetaDataDictionary(); std::vector flags; std::vector values; bool ret = otb::ReadNoDataFlags(dict,flags,values); if (!ret) { flags.resize(nbBands,true); values.resize(nbBands,GetParameterFloat("mode.apply.ndval")); } m_V2L = VectorToListFilterType::New(); m_V2L->SetInput(inputPtr); ImageListType::Pointer inputList = m_V2L->GetOutput(); inputList->UpdateOutputInformation(); ImageListType::Pointer outputList = ImageListType::New(); for (unsigned int i=0 ; iSetInput(inputList->GetNthElement(i)); masker->SetMaskImage(maskPtr); masker->SetMaskingValue(0); masker->SetOutsideValue(values[i]); outputList->PushBack(masker->GetOutput()); m_MaskFilters.push_back(masker); } else { outputList->PushBack(inputList->GetNthElement(i)); } } m_L2V = ListToVectorFilterType::New(); m_L2V->SetInput(outputList); if (!ret) { m_MetaDataChanger = ChangeInfoFilterType::New(); m_MetaDataChanger->SetInput(m_L2V->GetOutput()); m_MetaDataChanger->SetOutputMetaData >(otb::MetaDataKey::NoDataValueAvailable,&flags); m_MetaDataChanger->SetOutputMetaData >(otb::MetaDataKey::NoDataValue,&values); SetParameterOutputImage("out",m_MetaDataChanger->GetOutput()); } else { SetParameterOutputImage("out",m_L2V->GetOutput()); } } } FilterType::Pointer m_Filter; ChangeNoDataFilterType::Pointer m_ChangeNoDataFilter; std::vector m_MaskFilters; VectorToListFilterType::Pointer m_V2L; ListToVectorFilterType::Pointer m_L2V; ChangeInfoFilterType::Pointer m_MetaDataChanger; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ManageNoData) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbMultiResolutionPyramid.cxx000066400000000000000000000163511301006202600307030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbPerBandVectorImageFilter.h" #include "itkDiscreteGaussianImageFilter.h" #include "itkShrinkImageFilter.h" namespace otb { namespace Wrapper { class MultiResolutionPyramid : public Application { public: /** Standard class typedefs. */ typedef MultiResolutionPyramid Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(MultiResolutionPyramid, otb::Application); /** Image and filters typedef */ typedef itk::DiscreteGaussianImageFilter SmoothingImageFilterType; typedef otb::PerBandVectorImageFilter SmoothingVectorImageFilterType; typedef itk::ShrinkImageFilter ShrinkFilterType; private: void DoInit() ITK_OVERRIDE { SetName("MultiResolutionPyramid"); SetDescription("Build a multi-resolution pyramid of the image."); // Documentation SetDocName("Multi Resolution Pyramid"); SetDocLongDescription("This application builds a multi-resolution pyramid of the input image. User can specified the number of levels of the pyramid and the subsampling factor. To speed up the process, you can use the fast scheme option"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag("Conversion"); AddDocTag(Tags::Manip); AddDocTag(Tags::Multi); AddDocTag("Util"); AddParameter(ParameterType_InputImage, "in", "Input Image"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out","will be used to get the prefix and the extension of the images to write"); AddRAMParameter(); AddParameter(ParameterType_Int, "level", "Number Of Levels"); SetDefaultParameterInt("level", 1); SetParameterDescription( "level", "Number of levels in the pyramid (default is 1)."); SetMinimumParameterIntValue("level", 1); AddParameter(ParameterType_Int, "sfactor", "Subsampling factor"); SetDefaultParameterInt("sfactor", 2); SetParameterDescription( "sfactor", "Subsampling factor between each level of the pyramid (default is 2)."); AddParameter(ParameterType_Float, "vfactor", "Variance factor"); SetDefaultParameterFloat("vfactor", 0.6); SetParameterDescription( "vfactor", "Variance factor use in smoothing. It is multiplied by the subsampling factor of each level in the pyramid (default is 0.6)."); // Boolean Fast scheme AddParameter(ParameterType_Empty, "fast", "Use Fast Scheme"); std::ostringstream desc; desc<<"If used, this option allows one to speed-up computation by iteratively" <<" subsampling previous level of pyramid instead of processing the full input."; SetParameterDescription("fast", desc.str()); MandatoryOff("fast"); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("out", "multiResolutionImage.tif"); SetDocExampleParameterValue("level", "1"); SetDocExampleParameterValue("sfactor", "2"); SetDocExampleParameterValue("vfactor", "0.6"); SetDocExampleParameterValue("fast", "false"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent // Reinitialize the internal process used } void DoExecute() ITK_OVERRIDE { // Initializing the process m_SmoothingFilter = SmoothingVectorImageFilterType::New(); m_ShrinkFilter = ShrinkFilterType::New(); // Extract Parameters unsigned int nbLevels = GetParameterInt("level"); unsigned int shrinkFactor = GetParameterInt("sfactor"); double varianceFactor = GetParameterFloat("vfactor"); bool fastScheme = IsParameterEnabled("fast"); // Get the input image FloatVectorImageType::Pointer inImage = GetParameterImage("in"); // Get the Initial Output Image FileName std::string path, fname, ext; std::string ofname = GetParameterString("out"); // Get the extension and the prefix of the filename path = itksys::SystemTools::GetFilenamePath(ofname); fname = itksys::SystemTools::GetFilenameWithoutExtension(ofname); ext = itksys::SystemTools::GetFilenameExtension(ofname); unsigned int currentLevel = 1; unsigned int currentFactor = shrinkFactor; while(currentLevel <= nbLevels) { otbAppLogDEBUG( << "Processing level " << currentLevel << " with shrink factor "<SetInput(inImage); // According to // http://www.ipol.im/pub/algo/gjmr_line_segment_detector/ // This is a good balance between blur and aliasing double variance = varianceFactor * static_cast(currentFactor); m_SmoothingFilter->GetFilter()->SetVariance(variance); m_ShrinkFilter->SetInput(m_SmoothingFilter->GetOutput()); m_ShrinkFilter->SetShrinkFactors(currentFactor); if(!fastScheme) { currentFactor *= shrinkFactor; } else { otbAppLogWARNING("fast scheme enabled : not implemented for the moment "); } // Create an output parameter to write the current output image OutputImageParameter::Pointer paramOut = OutputImageParameter::New(); // build the current image filename std::ostringstream oss; if (!path.empty()) { oss <SetFileName(oss.str()); otbAppLogINFO(<< "File: "<GetFileName() << " will be written."); paramOut->SetValue(m_ShrinkFilter->GetOutput()); paramOut->SetPixelType(this->GetParameterOutputImagePixelType("out")); // Add the current level to be written paramOut->InitializeWriters(); AddProcess(paramOut->GetWriter(), osswriter.str()); paramOut->Write(); ++currentLevel; } // Disable this parameter since the images have already been produced DisableParameter("out"); } SmoothingVectorImageFilterType::Pointer m_SmoothingFilter; ShrinkFilterType::Pointer m_ShrinkFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::MultiResolutionPyramid) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbPixelValue.cxx000066400000000000000000000113111301006202600262440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultiChannelExtractROI.h" namespace otb { namespace Wrapper { class PixelValue : public Application { public: /** Standard class typedefs. */ typedef PixelValue Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::MultiChannelExtractROI ExtractROIFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(PixelValue, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("PixelValue"); SetDescription("Get the value of a pixel."); // Documentation SetDocName("Pixel Value"); SetDocLongDescription("Get the value of a pixel.\nPay attention, index starts at 0."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag("Utilities"); AddDocTag("Coordinates"); AddDocTag("Raster"); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image"); AddParameter(ParameterType_Int,"coordx","Col index"); SetParameterDescription("coordx","Column index of the wanted pixel (starts at 0)."); SetMinimumParameterIntValue("coordx", 0); AddParameter(ParameterType_Int,"coordy","Line index"); SetParameterDescription("coordy","Line index of the wanted pixel (starts at 0)."); SetMinimumParameterIntValue("coordy", 0); AddParameter(ParameterType_ListView,"cl","Channels"); SetParameterDescription("cl","Displayed channels"); MandatoryOff("cl"); AddParameter(ParameterType_String,"value","Pixel Value"); SetParameterDescription("value", "Pixel radiometric value"); SetParameterRole("value", Role_Output); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("coordx", "50"); SetDocExampleParameterValue("coordy", "100"); SetDocExampleParameterValue("cl", "Channel1"); } void DoUpdateParameters() ITK_OVERRIDE { if ( HasValue("in") ) { ExtractROIFilterType::InputImageType* inImage = GetParameterImage("in"); // Update the values of the channels to be selected unsigned int nbComponents = inImage->GetNumberOfComponentsPerPixel(); ClearChoices("cl"); for (unsigned int idx = 0; idx < nbComponents; ++idx) { std::ostringstream key, item; key<<"cl.channel"<GetLargestPossibleRegion(); SetMaximumParameterIntValue("coordx", largestRegion.GetSize(0)-1); SetMaximumParameterIntValue("coordy", largestRegion.GetSize(1)-1); } } void DoExecute() ITK_OVERRIDE { std::ostringstream ossOutput; FloatVectorImageType::Pointer inImage = GetParameterImage("in"); ExtractROIFilterType::Pointer extractor = ExtractROIFilterType::New(); extractor->SetInput(inImage); // Create the region FloatVectorImageType::IndexType id; id[0] = GetParameterInt("coordx"); id[1] = GetParameterInt("coordy"); FloatVectorImageType::SizeType size; size.Fill(0); FloatVectorImageType::RegionType region; region.SetSize(size); region.SetIndex(id); extractor->SetExtractionRegion(region); // Extract the channels if needed if ( GetParameterByKey("cl")->GetActive() ) { for (unsigned int idx = 0; idx < GetSelectedItems("cl").size(); ++idx) { extractor->SetChannel(GetSelectedItems("cl")[idx] + 1 ); } } extractor->Update(); // Display the pixel value id.Fill(0); std::ostringstream oss; oss << extractor->GetOutput()->GetPixel(id)< Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Quicklook, otb::Application); /** Typedefs */ typedef float InputPixelType; typedef float OutputPixelType; typedef otb::MultiChannelExtractROI< InputPixelType, OutputPixelType > ExtractROIFilterType; typedef ExtractROIFilterType::InputImageType InputImageType; typedef ExtractROIFilterType::OutputImageType OutputImageType; typedef otb::StreamingShrinkImageFilter ShrinkImageFilterType; private: void DoInit() ITK_OVERRIDE { SetName("Quicklook"); SetDescription("Generates a subsampled version of an image extract"); SetDocName("Quick Look"); SetDocLongDescription("Generates a subsampled version of an extract of an image defined by ROIStart and ROISize.\n " "This extract is subsampled using the ratio OR the output image Size."); SetDocLimitations(" This application does not provide yet the optimal way to decode coarser level of resolution from JPEG2000 images (like in Monteverdi).\n" "Trying to subsampled huge JPEG200 image with the application will lead to poor performances for now."); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription( "in", "The image to read" ); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription( "out" , "The subsampled image" ); AddParameter(ParameterType_ListView, "cl", "Channel List"); SetParameterDescription( "cl" , "Selected channels" ); MandatoryOff("cl"); AddParameter(ParameterType_Int, "rox", "ROI Origin X"); SetParameterDescription( "rox" , "first point of ROI in x-direction" ); MandatoryOff("rox"); AddParameter(ParameterType_Int, "roy", "ROI Origin Y"); SetParameterDescription( "roy" , "first point of ROI in y-direction" ); MandatoryOff("roy"); AddParameter(ParameterType_Int, "rsx", "ROI Size X"); SetParameterDescription( "rsx" , "size of ROI in x-direction" ); MandatoryOff("rsx"); AddParameter(ParameterType_Int, "rsy", "ROI Size Y"); SetParameterDescription( "rsy" , "size of ROI in y-direction" ); MandatoryOff("rsy"); AddParameter(ParameterType_Int, "sr", "Sampling ratio"); SetParameterDescription( "sr" , "Sampling Ratio, default is 2" ); SetDefaultParameterInt("sr", 2); SetMinimumParameterIntValue("sr", 1); MandatoryOff("sr"); AddParameter(ParameterType_Int, "sx", "Size X"); SetParameterDescription( "sx" , "quicklook size in x-direction (used if no sampling ration is given)" ); MandatoryOff("sx"); DisableParameter("sx"); AddParameter(ParameterType_Int, "sy", "Size Y"); SetParameterDescription( "sy" , "quicklook size in y-direction (used if no sampling ration is given)" ); MandatoryOff("sy"); DisableParameter("sy"); SetDefaultParameterInt("rox", 0); SetDefaultParameterInt("roy", 0); SetDefaultParameterInt("rsx", 0); SetDefaultParameterInt("rsy", 0); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("out", "quicklookImage.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Update the sizes only if the user does not defined a size if ( HasValue("in") ) { InputImageType::Pointer inImage = GetParameterImage("in"); InputImageType::RegionType largestRegion = inImage->GetLargestPossibleRegion(); // Update the values of the channels to be selected unsigned int nbComponents = inImage->GetNumberOfComponentsPerPixel(); if (nbComponents != GetChoiceKeys("cl").size()) { ClearChoices("cl"); for (unsigned int idx = 0; idx < nbComponents; ++idx) { std::ostringstream key, item; key<<"cl.channel"<CropRegionOfInterest()) { // Put the index of the ROI to origin and try to crop again SetParameterInt("rox", 0); SetParameterInt("roy", 0); this->CropRegionOfInterest(); } } } bool CropRegionOfInterest() { FloatVectorImageType::RegionType region; region.SetSize(0, GetParameterInt("rsx")); region.SetSize(1, GetParameterInt("rsy")); region.SetIndex(0, GetParameterInt("rox")); region.SetIndex(1, GetParameterInt("roy")); if ( HasValue("in") ) { if (region.Crop(GetParameterImage("in")->GetLargestPossibleRegion())) { SetParameterInt("rsx", region.GetSize(0)); SetParameterInt("rsy", region.GetSize(1)); SetParameterInt("rox", region.GetIndex(0)); SetParameterInt("roy", region.GetIndex(1)); return true; } } return false; } void DoExecute() ITK_OVERRIDE { InputImageType::Pointer inImage = GetParameterImage("in"); m_ExtractROIFilter = ExtractROIFilterType::New(); m_ResamplingFilter = ShrinkImageFilterType::New(); // The image on which the quicklook will be generated // Will eventually be the m_ExtractROIFilter output if (HasUserValue("rox") || HasUserValue("roy") || HasUserValue("rsx") || HasUserValue("rsy") || (GetSelectedItems("cl").size() > 0)) { m_ExtractROIFilter->SetInput(inImage); m_ExtractROIFilter->SetStartX(GetParameterInt("rox")); m_ExtractROIFilter->SetStartY(GetParameterInt("roy")); m_ExtractROIFilter->SetSizeX(GetParameterInt("rsx")); m_ExtractROIFilter->SetSizeY(GetParameterInt("rsy")); if ((GetSelectedItems("cl").size() > 0)) { for (unsigned int idx = 0; idx < GetSelectedItems("cl").size(); ++idx) { m_ExtractROIFilter->SetChannel(GetSelectedItems("cl")[idx] + 1 ); } } else { unsigned int nbComponents = inImage->GetNumberOfComponentsPerPixel(); for (unsigned int idx = 0; idx < nbComponents; ++idx) { m_ExtractROIFilter->SetChannel(idx + 1); } } m_ResamplingFilter->SetInput( m_ExtractROIFilter->GetOutput() ); } else { m_ResamplingFilter->SetInput(inImage); } unsigned int Ratio = static_cast(GetParameterInt("sr")); unsigned int SamplingRatioX = 1; unsigned int SamplingRatioY = 1; if ( !HasUserValue("sr") ) { if ( IsParameterEnabled("sx") && IsParameterEnabled("sy") ) { SamplingRatioX = GetParameterInt("rsx") / GetParameterInt("sx"); SamplingRatioY = GetParameterInt("rsy") / GetParameterInt("sy"); if (SamplingRatioX > Ratio) Ratio = SamplingRatioX; if (SamplingRatioY > Ratio) Ratio = SamplingRatioY; } else { if ( IsParameterEnabled("sx") ) { Ratio = GetParameterInt("rsx") / GetParameterInt("sx"); } if ( IsParameterEnabled("sy") ) { Ratio = GetParameterInt("rsy") / GetParameterInt("sy"); } } } if ( Ratio < 1) { otbAppLogFATAL( << "Error in SizeX and/or SizeY : ratio must be greater than 1."); return; } otbAppLogINFO( << "Ratio used: "<SetShrinkFactor( Ratio ); m_ResamplingFilter->Update(); SetParameterOutputImage("out", m_ResamplingFilter->GetOutput()); } ExtractROIFilterType::Pointer m_ExtractROIFilter; ShrinkImageFilterType::Pointer m_ResamplingFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::Quicklook) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbReadImageInfo.cxx000066400000000000000000000525111301006202600266270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbCoordinateToName.h" #include "otbGroundSpacingImageFunction.h" #include "vnl/vnl_random.h" namespace otb { namespace Wrapper { class ReadImageInfo : public Application { public: /** Standard class typedefs. */ typedef ReadImageInfo Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::GroundSpacingImageFunction GroundSpacingImageType; typedef GroundSpacingImageType::FloatType FloatType; typedef GroundSpacingImageType::ValueType ValueType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ReadImageInfo, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("ReadImageInfo"); SetDescription("Get information about the image"); // Documentation SetDocName("Read image information"); SetDocLongDescription("Display information about the input image like: image size, origin, spacing, metadata, projections..."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag("Utilities"); AddDocTag(Tags::Manip); AddDocTag(Tags::Meta); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image to analyse"); AddParameter(ParameterType_Empty, "keywordlist", "Display the OSSIM keywordlist"); SetParameterDescription("keywordlist", "Output the OSSIM keyword list. It contains metadata information (sensor model, geometry ). Information is stored in keyword list (pairs of key/value)"); DisableParameter("keywordlist"); MandatoryOff("keywordlist"); AddParameter(ParameterType_OutputFilename, "outkwl", "Write the OSSIM keywordlist to a geom file"); SetParameterDescription("outkwl", "This option allows extracting the OSSIM keywordlist of the image into a geom file."); MandatoryOff("outkwl"); //Create output parameters to store image information AddParameter(ParameterType_Int,"indexx","Start index X"); SetParameterDescription("indexx","X start index"); SetParameterRole("indexx", Role_Output); AddParameter(ParameterType_Int,"indexy","Start index Y"); SetParameterDescription("indexy","Y start index"); SetParameterRole("indexy", Role_Output); AddParameter(ParameterType_Int,"sizex","Size X"); SetParameterDescription("sizex","X size (in pixels)"); SetParameterRole("sizex", Role_Output); AddParameter(ParameterType_Int,"sizey","Size Y"); SetParameterDescription("sizey","Y size (in pixels)"); SetParameterRole("sizey", Role_Output); AddParameter(ParameterType_Float,"spacingx","Pixel Size X"); SetParameterDescription("spacingx", "Pixel size along X (in physical units)"); SetParameterRole("spacingx", Role_Output); AddParameter(ParameterType_Float,"spacingy","Pixel Size Y"); SetParameterDescription("spacingy", "Pixel size along Y (in physical units)"); SetParameterRole("spacingy", Role_Output); AddParameter(ParameterType_Float,"originx","Image Origin X"); SetParameterDescription("originx", "Origin along X"); SetParameterRole("originx", Role_Output); AddParameter(ParameterType_Float,"originy","Image Origin Y"); SetParameterDescription("originy", "Origin along Y"); SetParameterRole("originy", Role_Output); AddParameter(ParameterType_Float,"estimatedgroundspacingx","Estimated ground spacing X"); SetParameterDescription("estimatedgroundspacingx", "Estimated ground spacing along X (in meters)."); SetParameterRole("estimatedgroundspacingx", Role_Output); AddParameter(ParameterType_Float,"estimatedgroundspacingy","Estimated ground spacing Y"); SetParameterDescription("estimatedgroundspacingy", "Estimated ground spacing along Y (in meters)."); SetParameterRole("estimatedgroundspacingy", Role_Output); AddParameter(ParameterType_Int,"numberbands","Number Of Bands"); SetParameterDescription("numberbands", "Number of bands"); SetParameterRole("numberbands", Role_Output); AddParameter(ParameterType_String,"sensor","Sensor id"); SetParameterDescription("sensor", "Sensor identifier"); SetParameterRole("sensor", Role_Output); AddParameter(ParameterType_String,"id","Image id"); SetParameterDescription("id", "Image identifier"); SetParameterRole("id", Role_Output); EnableParameter("id"); AddParameter(ParameterType_String,"time","Acquisition time"); SetParameterDescription("time", "Acquisition time."); SetParameterRole("time", Role_Output); EnableParameter("time"); AddParameter(ParameterType_Float,"ullat","Upper left latitude"); SetParameterDescription("ullat", "Latitude of the upper left corner."); SetParameterRole("ullat", Role_Output); SetDefaultParameterFloat("ullat", 0); AddParameter(ParameterType_Float,"ullon","Upper left longitude"); SetParameterDescription("ullon", "Longitude of the upper left corner."); SetParameterRole("ullon", Role_Output); SetDefaultParameterFloat("ullon", 0); AddParameter(ParameterType_Float,"urlat","Upper right latitude"); SetParameterDescription("urlat", "Latitude of the upper right corner."); SetParameterRole("urlat", Role_Output); SetDefaultParameterFloat("urlat", 0); AddParameter(ParameterType_Float,"urlon","Upper right longitude"); SetParameterDescription("urlon", "Longitude of the upper right corner."); SetParameterRole("urlon", Role_Output); SetDefaultParameterFloat("urlon", 0); AddParameter(ParameterType_Float,"lrlat","Lower right latitude"); SetParameterDescription("lrlat", "Latitude of the lower right corner."); SetParameterRole("lrlat", Role_Output); SetDefaultParameterFloat("lrlat", 0); AddParameter(ParameterType_Float,"lrlon","Lower right longitude"); SetParameterDescription("lrlon", "Longitude of the lower right corner."); SetParameterRole("lrlon", Role_Output); SetDefaultParameterFloat("lrlon", 0); AddParameter(ParameterType_Float,"lllat","Lower left latitude"); SetParameterDescription("lllat", "Latitude of the lower left corner."); SetParameterRole("lllat", Role_Output); SetDefaultParameterFloat("lllat", 0); AddParameter(ParameterType_Float,"lllon","Lower left longitude"); SetParameterDescription("lllon", "Longitude of the lower left corner."); SetParameterRole("lllon", Role_Output); SetDefaultParameterFloat("lllon", 0); AddParameter(ParameterType_String,"town", "Nearest town"); SetParameterDescription("town", "Main town near center of image"); SetParameterRole("town", Role_Output); EnableParameter("town"); AddParameter(ParameterType_String,"country","Country"); SetParameterDescription("country", "Country of the image"); SetParameterRole("country", Role_Output); EnableParameter("country"); AddParameter(ParameterType_Group, "rgb", "Default RGB Display"); SetParameterDescription("rgb","This group of parameters provide information about the default rgb composition."); AddParameter(ParameterType_Int, "rgb.r", "Red Band"); SetParameterDescription("rgb.r","Red band Number"); SetDefaultParameterInt("rgb.r", 1); SetParameterRole("rgb.r", Role_Output); AddParameter(ParameterType_Int, "rgb.g", "Green Band"); SetParameterDescription("rgb.g","Green band Number"); SetDefaultParameterInt("rgb.g", 2); SetParameterRole("rgb.g", Role_Output); AddParameter(ParameterType_Int, "rgb.b", "Blue Band"); SetParameterDescription("rgb.b","Blue band Number"); SetDefaultParameterInt("rgb.b", 3); SetParameterRole("rgb.b", Role_Output); AddParameter(ParameterType_String,"projectionref","Projection"); SetParameterDescription("projectionref", "Projection Coordinate System"); SetParameterRole("projectionref", Role_Output); EnableParameter("projectionref"); AddParameter(ParameterType_String,"keyword","Keywordlist"); SetParameterDescription("keyword","Image keyword list"); SetParameterRole("keyword", Role_Output); EnableParameter("keyword"); AddParameter(ParameterType_Group, "gcp", "Ground Control Points information"); SetParameterDescription("gcp","This group of parameters provide information about all GCPs."); SetParameterRole("gcp", Role_Output); AddParameter(ParameterType_Int, "gcp.count", "GCPs Number"); SetParameterDescription("gcp.count", "Number of GCPs"); SetDefaultParameterInt("gcp.count", 0); SetParameterRole("gcp.count", Role_Output); EnableParameter("gcp.count"); AddParameter(ParameterType_String,"gcp.proj", "GCP Projection"); SetParameterDescription("gcp.proj", "Projection Coordinate System for GCPs"); SetParameterRole("gcp.proj", Role_Output); EnableParameter("gcp.proj"); AddParameter(ParameterType_StringList,"gcp.ids", "GCPs Id"); SetParameterDescription("gcp.ids", "GCPs identifier"); SetParameterRole("gcp.ids", Role_Output); EnableParameter("gcp.ids"); AddParameter(ParameterType_StringList,"gcp.info", "GCPs Info"); SetParameterDescription("gcp.info", "GCPs Information"); SetParameterRole("gcp.info", Role_Output); EnableParameter("gcp.info"); AddParameter(ParameterType_StringList,"gcp.imcoord", "GCPs Image Coordinates"); SetParameterDescription("gcp.imcoord", "GCPs Image coordinates"); SetParameterRole("gcp.imcoord", Role_Output); EnableParameter("gcp.imcoord"); AddParameter(ParameterType_StringList, "gcp.geocoord", "GCPs Geographic Coordinates"); SetParameterDescription("gcp.geocoord", "GCPs Geographic Coordinates"); SetParameterRole("gcp.geocoord", Role_Output); EnableParameter("gcp.geocoord"); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_XS.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { std::ostringstream ossOutput; FloatVectorImageType::Pointer inImage = GetParameterImage("in"); ossOutput << std::endl << "Image general information:" << std::endl; // Read information typedef otb::ImageMetadataInterfaceBase ImageMetadataInterfaceType; ImageMetadataInterfaceType::Pointer metadataInterface = ImageMetadataInterfaceFactory::CreateIMI(inImage->GetMetaDataDictionary()); //Get number of bands SetParameterInt("numberbands", inImage->GetNumberOfComponentsPerPixel()); ossOutput << "\tNumber of bands : " << GetParameterInt("numberbands") << std::endl; std::vector noDataValueAvailable; bool ret = itk::ExposeMetaData >(inImage->GetMetaDataDictionary(),MetaDataKey::NoDataValueAvailable,noDataValueAvailable); std::vector noDataValues; itk::ExposeMetaData >(inImage->GetMetaDataDictionary(),MetaDataKey::NoDataValue,noDataValues); ossOutput<<"\tNo data flags :"; if(ret) { for(unsigned int b = 0;b< inImage->GetNumberOfComponentsPerPixel();++b) { ossOutput<<"\n\t\tBand "<GetLargestPossibleRegion().GetIndex()[0]); SetParameterInt("indexy", inImage->GetLargestPossibleRegion().GetIndex()[1]); ossOutput << "\tStart index : [" << GetParameterInt("indexx") << "," << GetParameterInt("indexy") << "]" << std::endl; //Get image size SetParameterInt("sizex", inImage->GetLargestPossibleRegion().GetSize()[0]); SetParameterInt("sizey", inImage->GetLargestPossibleRegion().GetSize()[1]); ossOutput << "\tSize : [" << GetParameterInt("sizex") << "," << GetParameterInt("sizey") << "]" << std::endl; //Get image origin SetParameterFloat("originx", inImage->GetOrigin()[0]); SetParameterFloat("originy", inImage->GetOrigin()[1]); ossOutput << "\tOrigin : [" << GetParameterFloat("originx") << "," << GetParameterFloat("originy") << "]" << std::endl; //Get image spacing SetParameterFloat("spacingx", inImage->GetSpacing()[0]); SetParameterFloat("spacingy", inImage->GetSpacing()[1]); ossOutput << "\tSpacing : [" << GetParameterFloat("spacingx") << "," << GetParameterFloat("spacingy") << "]" << std::endl; //Estimate ground spacing GroundSpacingImageType::Pointer groundSpacing = GroundSpacingImageType::New(); groundSpacing->SetInputImage(inImage); FloatType approxGroundSpacing; approxGroundSpacing.Fill(itk::NumericTraits::Zero); FloatVectorImageType::IndexType index; vnl_random rand(12345); index[0] = static_cast(rand.lrand32(0, inImage->GetLargestPossibleRegion().GetSize()[0])); index[1] = static_cast(rand.lrand32(0, inImage->GetLargestPossibleRegion().GetSize()[1])); approxGroundSpacing = groundSpacing->EvaluateAtIndex(index); //Get image estimated ground spacing (in m) SetParameterFloat("estimatedgroundspacingx", approxGroundSpacing[0]); SetParameterFloat("estimatedgroundspacingy", approxGroundSpacing[1]); ossOutput << "\tEstimated ground spacing (in meters): [" << GetParameterFloat("estimatedgroundspacingx") << "," << GetParameterFloat("estimatedgroundspacingy") << "]" << std::endl; ossOutput << std::endl << "Image acquisition information:" << std::endl; SetParameterString("sensor", metadataInterface->GetSensorID()); ossOutput << "\tSensor : "; if (!GetParameterString("sensor").empty()) ossOutput << GetParameterString("sensor"); ossOutput << std::endl; ossOutput << "\tImage identification number: "; if (metadataInterface->GetImageKeywordlist().HasKey("image_id")) { SetParameterString("id", metadataInterface->GetImageKeywordlist().GetMetadataByKey("image_id")); ossOutput << GetParameterString("id"); } ossOutput << std::endl; SetParameterString("projectionref", metadataInterface->GetProjectionRef()); if (!GetParameterString("projectionref").empty()) ossOutput << "\tImage projection : " << GetParameterString("projectionref") << std::endl; // Format acquisition time //Test if this information is available and silently catch //associated exception try { std::ostringstream osstime; osstime<GetYear()<<"-"; if(metadataInterface->GetMonth()<10) osstime<<"0"; osstime<GetMonth()<<"-"; if(metadataInterface->GetDay()<10) osstime<<"0"; osstime<GetDay()<<"T"; if(metadataInterface->GetHour()<10) osstime<<"0"; osstime<GetHour()<<":"; if(metadataInterface->GetMinute()<10) osstime<<"0"; osstime<GetMinute(); osstime<<":00"; SetParameterString("time", osstime.str()); ossOutput << "\tAcquisition time : " << GetParameterString("time") << std::endl; } catch ( itk::ExceptionObject & /*err*/ ) { } try { double ullat = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("ul_lat").c_str()); double ullon = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("ul_lon").c_str()); double urlat = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("ur_lat").c_str()); double urlon = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("ur_lon").c_str()); double lrlat = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("lr_lat").c_str()); double lrlon = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("lr_lon").c_str()); double lllat = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("ll_lat").c_str()); double lllon = atof(metadataInterface->GetImageKeywordlist().GetMetadataByKey("ll_lon").c_str()); double centerlat = 0.25*(ullat+urlat+lrlat+lllat); double centerlon = 0.25*(ullon+urlon+lrlon+lllon); CoordinateToName::Pointer coord2name = CoordinateToName::New(); coord2name->SetLat(centerlat); coord2name->SetLon(centerlon); coord2name->Evaluate(); if( !coord2name->GetCountryName().empty() ) { SetParameterString("country", coord2name->GetCountryName()); ossOutput << "\tCountry : " << GetParameterString("country") << std::endl; } else SetParameterString("country", "Not available"); if( !coord2name->GetPlaceName().empty() ) { SetParameterString("town", coord2name->GetPlaceName()); ossOutput << "\tTown : " << GetParameterString("town") << std::endl; } else SetParameterString("town", "Not available"); // Retrieve footprint SetParameterFloat("ullat", ullat); SetParameterFloat("ullon", ullon); SetParameterFloat("urlat", urlat); SetParameterFloat("urlon", urlon); SetParameterFloat("lrlat", lrlat); SetParameterFloat("lrlon", lrlon); SetParameterFloat("lllat", lllat); SetParameterFloat("lllon", lllon); ossOutput << std::endl << "Image footprint coordinates:" << std::endl; ossOutput << "\tUpper left corner (latitude, longitude) = [" << GetParameterFloat("ullat") << "," << GetParameterFloat("ullon") << "]" << std::endl; ossOutput << "\tUpper right corner (latitude, longitude) = [" << GetParameterFloat("urlat") << "," << GetParameterFloat("urlon") << "]" << std::endl; ossOutput << "\tLower left corner (latitude, longitude) = [" << GetParameterFloat("lllat") << "," << GetParameterFloat("lllon") << "]" << std::endl; ossOutput << "\tLower right corner (latitude, longitude) = [" << GetParameterFloat("lrlat") << "," << GetParameterFloat("lrlon") << "]" << std::endl; } catch ( itk::ExceptionObject & /*err*/ ) { } SetParameterInt("rgb.r", metadataInterface->GetDefaultDisplay()[0]); SetParameterInt("rgb.g", metadataInterface->GetDefaultDisplay()[1]); SetParameterInt("rgb.b", metadataInterface->GetDefaultDisplay()[2]); ossOutput << std::endl << "Image default RGB composition:" << std::endl; ossOutput << "\t[R, G, B] = [" << GetParameterInt("rgb.r") << "," << GetParameterInt("rgb.g") << "," << GetParameterInt("rgb.b") << "]" << std::endl; SetParameterInt("gcp.count", metadataInterface->GetGCPCount()); SetParameterString("gcp.proj", metadataInterface->GetGCPProjection()); ossOutput << std::endl << "Ground control points information:" << std::endl; ossOutput << "\tNumber of GCPs = " << GetParameterInt("gcp.count") << std::endl; ossOutput << "\tGCPs projection = " << GetParameterString("gcp.proj") << std::endl; std::vector gcp_ids; std::vector gcp_imcoord; std::vector gcp_geocoord; std::vector gcp_infos; for(int gcpIdx = 0; gcpIdx < GetParameterInt("gcp.count"); ++ gcpIdx) { if (gcpIdx == 0) ossOutput << "\tGCP individual information:" << std::endl; gcp_ids.push_back(metadataInterface->GetGCPId(gcpIdx)); gcp_infos.push_back(metadataInterface->GetGCPInfo(gcpIdx)); std::ostringstream oss; oss << "[" << metadataInterface->GetGCPCol(gcpIdx) << ", " << metadataInterface->GetGCPRow(gcpIdx) << "]"; gcp_imcoord.push_back(oss.str()); oss.str(""); oss << "[" << metadataInterface->GetGCPX(gcpIdx) << ", " << metadataInterface->GetGCPY(gcpIdx) <<", " << metadataInterface->GetGCPZ(gcpIdx) << "]"; gcp_geocoord.push_back(oss.str()); ossOutput << "\t\tID =" << gcp_ids.back() << std::endl; ossOutput << "\t\tInfo =" << gcp_infos.back() << std::endl; ossOutput << "\t\tImage coordinates =" << gcp_imcoord.back() << std::endl; ossOutput << "\t\tGround coordinates =" << gcp_geocoord.back() << std::endl; } SetParameterStringList("gcp.ids", gcp_ids); SetParameterStringList("gcp.imcoord", gcp_imcoord); SetParameterStringList("gcp.geocoord", gcp_geocoord); SetParameterStringList("gcp.info", gcp_infos); if ( IsParameterEnabled("keywordlist") ) { std::ostringstream osskeywordlist; osskeywordlist<GetImageKeywordlist() << std::endl; SetParameterString("keyword", osskeywordlist.str()); ossOutput << std::endl << "Image OSSIM keywordlist (optional):" << std::endl; ossOutput << "\t" << GetParameterString("keyword") << std::endl; } //Display image information in the dedicated logger otbAppLogINFO( << ossOutput.str() ); if(IsParameterEnabled("outkwl")) { WriteGeometry(metadataInterface->GetImageKeywordlist(),GetParameterString("outkwl")); } } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ReadImageInfo) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbRescale.cxx000066400000000000000000000106051301006202600255510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbStreamingMinMaxVectorImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" namespace otb { namespace Wrapper { class Rescale : public Application { public: /** Standard class typedefs. */ typedef Rescale Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Rescale, otb::Application); /** Filters typedef */ typedef otb::StreamingMinMaxVectorImageFilter MinMaxFilterType; typedef otb::VectorRescaleIntensityImageFilter RescaleImageFilterType; private: void DoInit() ITK_OVERRIDE { SetName("Rescale"); SetDescription("Rescale the image between two given values."); SetDocName("Rescale Image"); SetDocLongDescription("This application scales the given image pixel intensity between two given values. " "By default min (resp. max) value is set to 0 (resp. 255)."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription( "in", "The image to scale." ); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription( "out" , "The rescaled image filename." ); AddRAMParameter(); AddParameter(ParameterType_Float, "outmin", "Output min value"); AddParameter(ParameterType_Float, "outmax", "Output max value"); SetDefaultParameterFloat("outmin", 0.0); SetParameterDescription( "outmin", "Minimum value of the output image." ); SetDefaultParameterFloat("outmax", 255.0); SetParameterDescription( "outmax", "Maximum value of the output image." ); MandatoryOff("outmin"); MandatoryOff("outmax"); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_PAN.tif"); SetDocExampleParameterValue("out", "rescaledImage.png uchar"); SetDocExampleParameterValue("outmin", "0"); SetDocExampleParameterValue("outmax", "255"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); otbAppLogDEBUG( << "Starting Min/Max computation" ) m_MinMaxFilter = MinMaxFilterType::New(); m_MinMaxFilter->SetInput( inImage ); m_MinMaxFilter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(m_MinMaxFilter->GetStreamer(), "Min/Max computing"); m_MinMaxFilter->Update(); otbAppLogDEBUG( << "Min/Max computation done : min=" << m_MinMaxFilter->GetMinimum() << " max=" << m_MinMaxFilter->GetMaximum() ) FloatVectorImageType::PixelType inMin, inMax; m_RescaleFilter = RescaleImageFilterType::New(); m_RescaleFilter->SetInput( inImage ); m_RescaleFilter->SetInputMinimum( m_MinMaxFilter->GetMinimum() ); m_RescaleFilter->SetInputMaximum( m_MinMaxFilter->GetMaximum() ); FloatVectorImageType::PixelType outMin, outMax; outMin.SetSize( inImage->GetNumberOfComponentsPerPixel() ); outMax.SetSize( inImage->GetNumberOfComponentsPerPixel() ); outMin.Fill( GetParameterFloat("outmin") ); outMax.Fill( GetParameterFloat("outmax") ); m_RescaleFilter->SetOutputMinimum( outMin ); m_RescaleFilter->SetOutputMaximum( outMax ); m_RescaleFilter->UpdateOutputInformation(); SetParameterOutputImage("out", m_RescaleFilter->GetOutput()); } RescaleImageFilterType::Pointer m_RescaleFilter; MinMaxFilterType::Pointer m_MinMaxFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::Rescale) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbSplitImage.cxx000066400000000000000000000106741301006202600262370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultiToMonoChannelExtractROI.h" namespace otb { namespace Wrapper { class SplitImage : public Application { public: /** Standard class typedefs. */ typedef SplitImage Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SplitImage, Application); /** Filters typedef */ typedef otb::MultiToMonoChannelExtractROI FilterType; private: void DoInit() ITK_OVERRIDE { SetName("SplitImage"); SetDescription("Split a N multiband image into N images"); SetDocName("Split Image"); SetDocLongDescription("This application splits a N-bands image into N mono-band images. The output images filename will be generated from the output parameter. Thus if the input image has 2 channels, and the user has set an output outimage.tif, the generated images will be outimage_0.tif and outimage_1.tif"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in","Input multiband image filename."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output filename that will be used to get the prefix and the extension of the output images to write"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "VegetationIndex.hd"); SetDocExampleParameterValue("out", "splitImage.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } void DoExecute() ITK_OVERRIDE { // Get the input image FloatVectorImageType::Pointer inImage = GetParameterImage("in"); // Get the path/fileWithoutextension/extension of the output images filename std::string path, fname, ext; std::string ofname = GetParameterString("out"); // Get the extension and the prefix of the filename path = itksys::SystemTools::GetFilenamePath(ofname); fname = itksys::SystemTools::GetFilenameWithoutExtension(ofname); ext = itksys::SystemTools::GetFilenameExtension(ofname); // Set the extract filter input image m_Filter = FilterType::New(); m_Filter->SetInput(inImage); for (unsigned int i = 0; i < inImage->GetNumberOfComponentsPerPixel(); ++i) { // Set the channel to extract m_Filter->SetChannel(i+1); // build the current output filename std::ostringstream oss; if (!path.empty()) { oss <SetFileName(oss.str()); otbAppLogINFO(<< "File: "<GetFileName() << " will be written."); paramOut->SetValue(m_Filter->GetOutput()); paramOut->SetPixelType(this->GetParameterOutputImagePixelType("out")); // Add the current level to be written paramOut->InitializeWriters(); AddProcess(paramOut->GetWriter(), osswriter.str()); paramOut->Write(); } // Disable the output Image parameter to avoid writing // the last image (Application::ExecuteAndWriteOutput method) DisableParameter("out"); } FilterType::Pointer m_Filter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::SplitImage) OTB-release-5.8/Modules/Applications/AppImageUtils/app/otbTileFusion.cxx000066400000000000000000000063701301006202600262600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbTileImageFilter.h" namespace otb { namespace Wrapper { class TileFusion : public Application { public: /** Standard class typedefs. */ typedef TileFusion Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(TileFusion, otb::Application); typedef otb::TileImageFilter TileFilterType; private: void DoInit() ITK_OVERRIDE { SetName("TileFusion"); SetDescription("Fusion of an image made of several tile files."); // Documentation SetDocName("Image Tile Fusion"); SetDocLongDescription("Concatenate several tile files into a single image file."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Manip); AddParameter(ParameterType_InputImageList, "il", "Input Tile Images"); SetParameterDescription("il", "Input tiles to concatenate (in lexicographic order : (0,0) (1,0) (0,1) (1,1))."); AddParameter(ParameterType_Int, "cols", "Number of tile columns"); SetParameterDescription("cols", "Number of columns in the tile array"); AddParameter(ParameterType_Int, "rows", "Number of tile rows"); SetParameterDescription("rows", "Number of rows in the tile array"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output entire image"); // Doc example parameter settings SetDocExampleParameterValue("il", "Scene_R1C1.tif Scene_R1C2.tif Scene_R2C1.tif Scene_R2C2.tif"); SetDocExampleParameterValue("cols","2"); SetDocExampleParameterValue("rows","2"); SetDocExampleParameterValue("out", "EntireImage.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to be done } void DoExecute() ITK_OVERRIDE { // Get the input image list FloatVectorImageListType::Pointer tileList = this->GetParameterImageList("il"); if( tileList->Size() == 0 ) { itkExceptionMacro("No input Image set..."); } m_FusionFilter = TileFilterType::New(); TileFilterType::SizeType layout; layout[0] = this->GetParameterInt("cols"); layout[1] = this->GetParameterInt("rows"); m_FusionFilter->SetLayout(layout); for (unsigned int i=0; i<(layout[0]*layout[1]); i++) { m_FusionFilter->SetInput(i,tileList->GetNthElement(i)); } SetParameterOutputImage("out", m_FusionFilter->GetOutput()); } TileFilterType::Pointer m_FusionFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::TileFusion) OTB-release-5.8/Modules/Applications/AppImageUtils/otb-module.cmake000066400000000000000000000006711301006202600252350ustar00rootroot00000000000000set(DOCUMENTATION "Image utils and handling application.") otb_module(OTBAppImageUtils DEPENDS OTBApplicationEngine OTBCarto OTBColorMap OTBCommon OTBCurlAdapters OTBITK OTBImageBase OTBImageManipulation OTBOSSIMAdapters OTBObjectList OTBProjection OTBStatistics OTBStreaming OTBTransform TEST_DEPENDS OTBCommandLine OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppImageUtils/test/000077500000000000000000000000001301006202600231375ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppImageUtils/test/CMakeLists.txt000066400000000000000000000437171301006202600257130ustar00rootroot00000000000000otb_module_test() #----------- DownloadSRTMTiles TESTS ---------------- otb_test_application(NAME apTuUtDownloadSRTMTiles APP DownloadSRTMTiles OPTIONS -il LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} -mode list -mode.list.indir ${INPUTDATA}/DEM/srtm_directory ) #----------- Convert TESTS ---------------- otb_test_application(NAME apTvUtConvertBasic APP Convert OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -out ${TEMP}/apTvUtConvertBasicOutput.tif VALID --compare-image ${NOTOL} ${INPUTDATA}/apTvUtConvertBasicOutput.tif ${TEMP}/apTvUtConvertBasicOutput.tif ) otb_test_application(NAME apTuUtConvertExtendedFilename_writer APP Convert OPTIONS -in ${INPUTDATA}/ToulouseExtract_WithGeom.tif -out ${TEMP}/apTvUtGeomExtendedFilename.tif?&gdal:co:TILED=YES&writegeom=false ) otb_test_application(NAME apTvUtConvertWithScaling APP Convert OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -out ${TEMP}/apTvUtConvertWithScalingOutput.tif uint8 -type linear VALID --compare-image ${NOTOL} ${INPUTDATA}/apTvUtConvertWithScalingOutput.tif ${TEMP}/apTvUtConvertWithScalingOutput.tif ) otb_test_application(NAME apTvUtConvertExtendedFilename_readerGEOM APP Convert OPTIONS -in ${INPUTDATA}/ToulouseExtract_WithGeom.tif?&geom=${INPUTDATA}/ToulouseExtract_ModifiedGeom.geom -out ${TEMP}/apTvUtGeomExtendedFilename.tif VALID --compare-ascii ${EPSILON_7} ${INPUTDATA}/ToulouseExtract_ModifiedGeom.geom ${TEMP}/apTvUtGeomExtendedFilename.geom) #----------- PixelInfo TESTS ---------------- #----------- ExtractROI TESTS ---------------- otb_test_application(NAME apTvUtExtractROISizeTooBig APP ExtractROI OPTIONS -in ${INPUTDATA}/couleurs_extrait.png -out ${TEMP}/apTvUtExtractROISizeTooBig.tif -sizex 1000000 VALID --compare-image ${NOTOL} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/apTvUtExtractROISizeTooBig.tif) otb_test_application(NAME apTvUtExtractROISizeNULL APP ExtractROI OPTIONS -in ${INPUTDATA}/couleurs_extrait.png -out ${TEMP}/apTvUtExtractROISizeNULL.tif -sizex 0 VALID --compare-image ${NOTOL} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/apTvUtExtractROISizeNULL.tif) otb_test_application(NAME apTvUtExtractROIRightInputFile APP ExtractROI OPTIONS -in ${INPUTDATA}/couleurs_extrait.png -out ${TEMP}/apTvUtExtractROIRightInputFile.tif VALID --compare-image ${NOTOL} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/apTvUtExtractROIRightInputFile.tif) #----------- Rescale TESTS ---------------- otb_test_application(NAME apTvUtRescaleTest APP Rescale OPTIONS -in ${INPUTDATA}/poupees.tif -out ${TEMP}/apTvUtRescaleTest.png uint8 -outmin 20 -outmax 150 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtRescaleTest.png ${TEMP}/apTvUtRescaleTest.png) #----------- TileFusion TESTS ---------------- otb_test_application(NAME apTvUtTileFusion APP TileFusion OPTIONS -il ${EXAMPLEDATA}/Scene_R1C1.png ${EXAMPLEDATA}/Scene_R1C2.png ${EXAMPLEDATA}/Scene_R2C1.png ${EXAMPLEDATA}/Scene_R2C2.png -cols 2 -rows 2 -out ${TEMP}/apTvUtTileFusion.png uint8 VALID --compare-image ${NOTOL} ${EXAMPLEDATA}/Scene.png ${TEMP}/apTvUtTileFusion.png) #----------- ReadImageInfo TESTS ---------------- otb_test_application(NAME apTuUtReadImageInfoExtendedFilename_reader APP ReadImageInfo OPTIONS -in ${INPUTDATA}/ToulouseExtract_WithGeom.tif?&skipgeom=true&skipcarto=true ) set(TESTNAME "gd-pleiades-1" #LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2} "gd-wv2-1" #LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} "gd-spot6-1" #LARGEINPUT{SPOT6/600143101-Primary-Bundle-JP2-LOSSLESS/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201212071020271_SEN_600143101_R1C1.JP2} "gd-qb-1" #LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} "gd-ikonos-1" #LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_nir_0000000.tif} "gd-rapideye-1" #LARGEINPUT{RAPIDEYE/level1B/2008-12-25T005918_RE3_1B-NAC_397971_12345_band3.ntf} ) set(IMG LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2} LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} LARGEINPUT{SPOT6/600143101-Primary-Bundle-JP2-LOSSLESS/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201212071020271_SEN_600143101_R1C1.JP2} LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_nir_0000000.tif} LARGEINPUT{RAPIDEYE/level1B/2008-12-25T005918_RE3_1B-NAC_397971_12345_band3.ntf} ) set( GEOM_TESTNB 0) foreach( file ${IMG} ) list(GET TESTNAME ${GEOM_TESTNB} current_testname ) math(EXPR GEOM_TESTNB "${GEOM_TESTNB} + 1") otb_test_application(NAME apTuReadImageInfoTest_${current_testname} APP ReadImageInfo OPTIONS -in ${file} -outkwl ${TEMP}/apTvUtReadImageInfoTest_${current_testname}.geom #No baseline, just check that the process finished well ) endforeach() #----------- Quicklook TESTS ---------------- otb_test_application(NAME apTvUtQuicklookROI1Channel APP Quicklook OPTIONS -in ${INPUTDATA}/couleurs_extrait.png -out ${TEMP}/apTvUtQuicklookROI1Channel.tif -cl Channel1 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtQuicklookROI1Channel.tif ${TEMP}/apTvUtQuicklookROI1Channel.tif ) otb_test_application(NAME apTvUtQuicklookSpot5 APP Quicklook OPTIONS -in LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} -out ${TEMP}/apTvUtQuicklookSpot5.img -cl Channel1 Channel2 Channel3 -rox 10 -roy 10 -rsx 100 -rsy 200 -sr 2 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtQuicklookSpot5.tif ${TEMP}/apTvUtQuicklookSpot5.img ) #----------- DEMConvert TESTS ---------------- #----------- ConcatenateImages TESTS ---------------- otb_test_application(NAME apTvUtConcatenateImages APP ConcatenateImages OPTIONS -il ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${INPUTDATA}/poupees_sub_c3.png -out ${TEMP}/apTvUtConcatenateImages.png VALID --compare-image ${NOTOL} ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/apTvUtConcatenateImages.png) otb_test_application(NAME apTvUtConcatenateImages_1Image APP ConcatenateImages OPTIONS -il ${INPUTDATA}/poupees_c1 -out ${TEMP}/apTvUtConcatenateImages_1Image.tif VALID --compare-image ${NOTOL} ${INPUTDATA}/poupees_c1 ${TEMP}/apTvUtConcatenateImages_1Image.tif) #----------- MultiResolutionPyramid TESTS ---------------- #----------- PixelValue TESTS ---------------- OTB_TEST_APPLICATION(NAME apTvUtPixelValue APP PixelValue OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -coordx 30 -coordy 30 -cl Channel1 Channel3 Channel4 TESTENVOPTIONS ${TEMP}/apTvUtPixelValue.txt VALID --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/apTvUtPixelValue.txt ${TEMP}/apTvUtPixelValue.txt ) #----------- ColorMapping TESTS ---------------- otb_test_application(NAME apTvUtColorMappingLabelToColorCustomLUT APP ColorMapping OPTIONS -in ${INPUTDATA}/labelImage_UnsignedChar.tif -method custom -method.custom.lut ${INPUTDATA}/labelImage_UnsignedChar_lut.dat -out ${TEMP}/apTvUtColorMappingLabelToColorCustomLUT.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtColorMappingLabelToColorCustomLUT.tif ${TEMP}/apTvUtColorMappingLabelToColorCustomLUT.tif) otb_test_application(NAME apTvUtColorMappingColorToLabelOptimalLUTQB APP ColorMapping OPTIONS -in ${BASELINE}/apTvUtColorMappingLabelToColorOptimalLUTQB.tif -method optimal -op colortolabel -op.colortolabel.notfound 0 -out ${TEMP}/apTvUtColorMappingColorToLabelOptimalLUTQB.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtColorMappingColorToLabelOptimalLUTQB.tif ${TEMP}/apTvUtColorMappingColorToLabelOptimalLUTQB.tif) otb_test_application(NAME apTvUtColorMappingLabelToColorCustomLUTQB APP ColorMapping OPTIONS -in ${EXAMPLEDATA}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png -method custom -method.custom.lut ${INPUTDATA}/ROI_QB_MUL_1_SVN_CLASS_MULTI_PNG_ColorTable.txt -out ${TEMP}/apTvUtColorMappingLabelToColorCustomLUTQB.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtColorMappingLabelToColorCustomLUTQB.tif ${TEMP}/apTvUtColorMappingLabelToColorCustomLUTQB.tif) otb_test_application(NAME apTvUtColorMappingColorToLabelOptimalLUT APP ColorMapping OPTIONS -in ${BASELINE}/apTvUtColorMappingLabelToColorOptimalLUT.tif -op colortolabel -op.colortolabel.notfound 255 -method optimal -out ${TEMP}/apTvUtColorMappingColorToLabelOptimalLUT.tif uint8 VALID --compare-image ${NOTOL} ${INPUTDATA}/labelImage_UnsignedChar.tif ${TEMP}/apTvUtColorMappingColorToLabelOptimalLUT.tif) otb_test_application(NAME apTvUtColorMappingLabelToColorOptimalLUTQB APP ColorMapping OPTIONS -in ${EXAMPLEDATA}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png -method optimal -out ${TEMP}/apTvUtColorMappingLabelToColorOptimalLUTQB.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtColorMappingLabelToColorOptimalLUTQB.tif ${TEMP}/apTvUtColorMappingLabelToColorOptimalLUTQB.tif) otb_test_application(NAME apTvUtColorMappingColorToLabelCustomLUTQB APP ColorMapping OPTIONS -in ${BASELINE}/apTvUtColorMappingLabelToColorCustomLUTQB.tif -op colortolabel -op.colortolabel.notfound 0 -method custom -method.custom.lut ${INPUTDATA}/ROI_QB_MUL_1_SVN_CLASS_MULTI_PNG_ColorTable.txt -out ${TEMP}/apTvUtColorMappingColorToLabelCustomLUTQB.tif uint8 VALID --compare-image ${NOTOL} ${EXAMPLEDATA}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png ${TEMP}/apTvUtColorMappingColorToLabelCustomLUTQB.tif) otb_test_application(NAME apTvUtColorMappingLabelToColorContinuousLUTJet APP ColorMapping OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -method continuous -method.continuous.lut jet -method.continuous.min 100 -method.continuous.max 500 -out ${TEMP}/QB_Toulouse_Ortho_PAN_LUTJet.tif uint8 VALID --compare-image ${EPSILON_7} ${BASELINE}/apTvUtColorMappingContinuousLUTJet.tif ${TEMP}/QB_Toulouse_Ortho_PAN_LUTJet.tif) otb_test_application(NAME apTvUtColorMappingLabelToColorSupportImage APP ColorMapping OPTIONS -in ${EXAMPLEDATA}/ROI_QB_MUL_1_SVN_CLASS_MULTI.png -method image -method.image.in ${EXAMPLEDATA}/ROI_QB_MUL_1.tif -out ${TEMP}/apTvUtColorMappingLabelToColorSupportImage.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtColorMappingLabelToColorSupportImage.tif ${TEMP}/apTvUtColorMappingLabelToColorSupportImage.tif) otb_test_application(NAME apTvUtColorMappingLabelToColorOptimalLUT APP ColorMapping OPTIONS -in ${INPUTDATA}/labelImage_UnsignedChar.tif -method optimal -out ${TEMP}/apTvUtColorMappingLabelToColorOptimalLUT.tif uint8 VALID --compare-image ${NOTOL} ${BASELINE}/apTvUtColorMappingLabelToColorOptimalLUT.tif ${TEMP}/apTvUtColorMappingLabelToColorOptimalLUT.tif) OTB_TEST_APPLICATION(NAME apTvClLabeledImageColorMappingQB123_1 APP ColorMapping OPTIONS -in ${OTBAPP_BASELINE}/clLabeledImageQB123_1.tif -method custom -method.custom.lut ${INPUTDATA}/Classification/ColorTable.txt -out ${TEMP}/clLabeledFancyImageQB123_1.tif VALID --compare-image ${NOTOL} ${OTBAPP_BASELINE}/clLabeledFancyImageQB123_1.tif ${TEMP}/clLabeledFancyImageQB123_1.tif) #----------- CompareImages TESTS ---------------- otb_test_application(NAME apTvUtCompareImagesNoROI APP CompareImages OPTIONS -ref.in ${INPUTDATA}/GomaAvant.png -meas.in ${INPUTDATA}/GomaApres.png TESTENVOPTIONS ${TEMP}/apTvUtCompareImagesNoROI.txt VALID --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/apTvUtCompareImagesNoROI.txt ${TEMP}/apTvUtCompareImagesNoROI.txt) otb_test_application(NAME apTvUtCompareImages APP CompareImages OPTIONS -ref.in ${INPUTDATA}/poupees.tif -ref.channel 2 -meas.in ${INPUTDATA}/brain.png -meas.channel 1 -roi.startx 20 -roi.starty 15 -roi.sizex 150 -roi.sizey 200 TESTENVOPTIONS ${TEMP}/apTvUtCompareImages.txt VALID --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/apTvUtCompareImages.txt ${TEMP}/apTvUtCompareImages.txt) #----------- SplitImage TESTS ---------------- otb_test_application(NAME apTvUtSplitImage APP SplitImage OPTIONS -in ${INPUTDATA}/poupees_sub.png -out ${TEMP}/apTvUtSplitImageOutput.tif VALID --compare-n-images ${NOTOL} 3 ${INPUTDATA}/poupees_sub_c1.png ${TEMP}/apTvUtSplitImageOutput_0.tif ${INPUTDATA}/poupees_sub_c2.png ${TEMP}/apTvUtSplitImageOutput_1.tif ${INPUTDATA}/poupees_sub_c3.png ${TEMP}/apTvUtSplitImageOutput_2.tif) OTB-release-5.8/Modules/Applications/AppIndices/000077500000000000000000000000001301006202600214735ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppIndices/CMakeLists.txt000066400000000000000000000000511301006202600242270ustar00rootroot00000000000000project(OTBAppIndices) otb_module_impl() OTB-release-5.8/Modules/Applications/AppIndices/app/000077500000000000000000000000001301006202600222535ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppIndices/app/CMakeLists.txt000066400000000000000000000004161301006202600250140ustar00rootroot00000000000000set(OTBAppIndices_LINK_LIBS ${OTBIndices_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_create_application( NAME RadiometricIndices SOURCES otbRadiometricIndices.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppIndices/app/otbRadiometricIndices.cxx000066400000000000000000000653611301006202600272600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" #include "otbMultiChannelGAndRIndexImageFilter.h" #include "otbMultiChannelRAndGAndNIRIndexImageFilter.h" #include "otbMultiChannelRAndBAndNIRIndexImageFilter.h" #include "otbMultiChannelRAndGAndNIRIndexImageFilter.h" #include "otbWaterIndicesFunctor.h" #include "otbBuiltUpIndicesFunctor.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "otbWrapperNumericalParameter.h" namespace otb { namespace Wrapper { class RadiometricIndices: public Application { public: /** Standard class typedefs. */ typedef RadiometricIndices Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(RadiometricIndices, otb::Wrapper::Application); /** Output containers typedef */ typedef ObjectList FilterListType; typedef ImageList ImageListType; typedef ImageListToVectorImageFilter ImageListToVectorImageFilterType; /** Radiometric water indices functors typedef */ typedef Functor::SRWI SRWIFunctorType; typedef Functor::NDWI NDWIFunctorType; typedef Functor::NDWI2 NDWI2FunctorType; typedef Functor::MNDWI MNDWIFunctorType; typedef Functor::NDPI NDPIFunctorType; typedef Functor::NDTI NDTIFunctorType; //typedef Functor::WaterSqrtSpectralAngleFunctor WaterSqrtSpectralAngleFunctor; /** Radiometric vegetation indices functors typedef */ typedef Functor::NDVI NDVIFunctor; typedef Functor::TNDVI TNDVIFunctor; typedef Functor::RVI RVIFunctor; typedef Functor::SAVI SAVIFunctor; typedef Functor::TSAVI TSAVIFunctor; typedef Functor::MSAVI MSAVIFunctor; typedef Functor::MSAVI2 MSAVI2Functor; typedef Functor::GEMI GEMIFunctor; typedef Functor::IPVI IPVIFunctor; typedef Functor::LAIFromNDVILogarithmic LAIFromNDVILogFunctor; typedef Functor::LAIFromReflectancesLinear LAIFromReflLinearFunctor; typedef Functor::LAIFromNDVIFormosat2Functor LAIFromNDVIFormoFunctor; /** Radiometric soil indices functors typedef */ typedef Functor::IR IRFunctor; typedef Functor::IC ICFunctor; typedef Functor::IB IBFunctor; typedef Functor::IB2 IB2Functor; /** Radiometric built up indices functors typedef */ typedef Functor::NDBI NDBIFunctor; /** Radiometric indices filters typedef */ typedef itk::UnaryFunctorImageFilter NDWIFilterType; typedef itk::UnaryFunctorImageFilter NDWI2FilterType; typedef itk::UnaryFunctorImageFilter MNDWIFilterType; typedef itk::UnaryFunctorImageFilter NDPIFilterType; typedef itk::UnaryFunctorImageFilter NDTIFilterType; typedef itk::UnaryFunctorImageFilter SRWIFilterType; typedef MultiChannelRAndNIRIndexImageFilter NDVIFilterType; typedef MultiChannelRAndNIRIndexImageFilter TNDVIFilterType; typedef MultiChannelRAndNIRIndexImageFilter RVIFilterType; typedef MultiChannelRAndNIRIndexImageFilter SAVIFilterType; typedef MultiChannelRAndNIRIndexImageFilter TSAVIFilterType; typedef MultiChannelRAndNIRIndexImageFilter MSAVIFilterType; typedef MultiChannelRAndNIRIndexImageFilter MSAVI2FilterType; typedef MultiChannelRAndNIRIndexImageFilter GEMIFilterType; typedef MultiChannelRAndNIRIndexImageFilter IPVIFilterType; typedef MultiChannelRAndNIRIndexImageFilter LAIFromNDVILogFilterType; typedef MultiChannelRAndNIRIndexImageFilter LAIFromReflLinearFilterType; typedef MultiChannelRAndNIRIndexImageFilter LAIFromNDVIFormoFilterType; typedef itk::UnaryFunctorImageFilter RIFilterType; typedef itk::UnaryFunctorImageFilter CIFilterType; typedef itk::UnaryFunctorImageFilter BIFilterType; typedef itk::UnaryFunctorImageFilter BI2FilterType; struct indiceSpec { std::string key; std::string item; std::string description; std::string type; std::string chan1; std::string chan2; std::string chan3; }; private: void DoInit() ITK_OVERRIDE { SetName("RadiometricIndices"); SetDescription("Compute radiometric indices."); // Documentation SetDocName("Radiometric Indices"); SetDocLongDescription("This application computes radiometric indices using the relevant channels of the input image. The output is a multi band image into which each channel is one of the selected indices."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otbVegetationIndicesFunctor, otbWaterIndicesFunctor and otbSoilIndicesFunctor classes"); AddDocTag("Radiometric Indices"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Radiometric indices output image"); AddRAMParameter(); AddParameter(ParameterType_Group, "channels", "Channels selection"); SetParameterDescription("channels", "Channels selection"); AddParameter(ParameterType_Int, "channels.blue", "Blue Channel"); SetParameterDescription("channels.blue", "Blue channel index"); SetDefaultParameterInt("channels.blue", 1); AddParameter(ParameterType_Int, "channels.green", "Green Channel"); SetParameterDescription("channels.green", "Green channel index"); SetDefaultParameterInt("channels.green", 1); AddParameter(ParameterType_Int, "channels.red", "Red Channel"); SetParameterDescription("channels.red", "Red channel index"); SetDefaultParameterInt("channels.red", 1); AddParameter(ParameterType_Int, "channels.nir", "NIR Channel"); SetParameterDescription("channels.nir", "NIR channel index"); SetDefaultParameterInt("channels.nir", 1); AddParameter(ParameterType_Int, "channels.mir", "Mir Channel"); SetParameterDescription("channels.mir", "Mir channel index"); SetDefaultParameterInt("channels.mir", 1); //AddParameter(ParameterType_Int, "channels.rho860", "Rho860 Channel"); //SetParameterDescription("channels.rho860", "860nm band channel index"); //SetDefaultParameterInt("channels.rho860", 1); //AddParameter(ParameterType_Int, "channels.rho1240", "Rho1240 Channel"); //SetParameterDescription("channels.rho1240", "1240nm band channel index"); //SetDefaultParameterInt("channels.rho1240", 1); AddParameter(ParameterType_ListView, "list", "Available Radiometric Indices"); SetParameterDescription("list","List of available radiometric indices with their relevant channels in brackets:\n\ Vegetation:NDVI - Normalized difference vegetation index (Red, NIR)\n\ Vegetation:TNDVI - Transformed normalized difference vegetation index (Red, NIR)\n\ Vegetation:RVI - Ratio vegetation index (Red, NIR)\n\ Vegetation:SAVI - Soil adjusted vegetation index (Red, NIR)\n\ Vegetation:TSAVI - Transformed soil adjusted vegetation index (Red, NIR)\n\ Vegetation:MSAVI - Modified soil adjusted vegetation index (Red, NIR)\n\ Vegetation:MSAVI2 - Modified soil adjusted vegetation index 2 (Red, NIR)\n\ Vegetation:GEMI - Global environment monitoring index (Red, NIR)\n\ Vegetation:IPVI - Infrared percentage vegetation index (Red, NIR)\n\ \n\ Water:NDWI - Normalized difference water index (Gao 1996) (NIR, MIR)\n\ Water:NDWI2 - Normalized difference water index (Mc Feeters 1996) (Green, NIR)\n\ Water:MNDWI - Modified normalized difference water index (Xu 2006) (Green, MIR)\n\ Water:NDPI - Normalized difference pond index (Lacaux et al.) (MIR, Green)\n\ Water:NDTI - Normalized difference turbidity index (Lacaux et al.) (Red, Green)\n\ \n\ Soil:RI - Redness index (Red, Green)\n\ Soil:CI - Color index (Red, Green)\n\ Soil:BI - Brightness index (Red, Green)\n\ Soil:BI2 - Brightness index 2 (NIR, Red, Green)"); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("list", "Vegetation:NDVI Vegetation:RVI Vegetation:IPVI"); SetDocExampleParameterValue("out", "RadiometricIndicesImage.tif"); m_Map.clear(); // Add Available choices indiceSpec s_NDVI; s_NDVI.key = "list.ndvi"; s_NDVI.item = "Vegetation:NDVI"; s_NDVI.description = ""; s_NDVI.type = "NDVI"; s_NDVI.chan1 = "red"; s_NDVI.chan2 = "nir"; s_NDVI.chan3 = ""; m_Map.push_back(s_NDVI); indiceSpec s_TNDVI; s_TNDVI.key = "list.tndvi"; s_TNDVI.item = "Vegetation:TNDVI"; s_TNDVI.description = ""; s_TNDVI.type = "TNDVI"; s_TNDVI.chan1 = "red"; s_TNDVI.chan2 = "nir"; s_TNDVI.chan3 = ""; m_Map.push_back(s_TNDVI); indiceSpec s_RVI; s_RVI.key = "list.rvi"; s_RVI.item = "Vegetation:RVI"; s_RVI.description = ""; s_RVI.type = "RVI"; s_RVI.chan1 = "red"; s_RVI.chan2 = "nir"; s_RVI.chan3 = ""; m_Map.push_back(s_RVI); indiceSpec s_SAVI; s_SAVI.key = "list.savi"; s_SAVI.item = "Vegetation:SAVI"; s_SAVI.description = ""; s_SAVI.type = "SAVI"; s_SAVI.chan1 = "red"; s_SAVI.chan2 = "nir"; s_SAVI.chan3 = ""; m_Map.push_back(s_SAVI); indiceSpec s_TSAVI; s_TSAVI.key = "list.tsavi"; s_TSAVI.item = "Vegetation:TSAVI"; s_TSAVI.description = ""; s_TSAVI.type = "TSAVI"; s_TSAVI.chan1 = "red"; s_TSAVI.chan2 = "nir"; s_TSAVI.chan3 = ""; m_Map.push_back(s_TSAVI); indiceSpec s_MSAVI; s_MSAVI.key = "list.msavi"; s_MSAVI.item = "Vegetation:MSAVI"; s_MSAVI.description = ""; s_MSAVI.type = "MSAVI"; s_MSAVI.chan1 = "red"; s_MSAVI.chan2 = "nir"; s_MSAVI.chan3 = ""; m_Map.push_back(s_MSAVI); indiceSpec s_MSAVI2; s_MSAVI2.key = "list.msavi2"; s_MSAVI2.item = "Vegetation:MSAVI2"; s_MSAVI2.description = ""; s_MSAVI2.type = "MSAVI2"; s_MSAVI2.chan1 = "red"; s_MSAVI2.chan2 = "nir"; s_MSAVI2.chan3 = ""; m_Map.push_back(s_MSAVI2); indiceSpec s_GEMI; s_GEMI.key = "list.gemi"; s_GEMI.item = "Vegetation:GEMI"; s_GEMI.description = ""; s_GEMI.type = "GEMI"; s_GEMI.chan1 = "red"; s_GEMI.chan2 = "nir"; s_GEMI.chan3 = ""; m_Map.push_back(s_GEMI); indiceSpec s_IPVI; s_IPVI.key = "list.ipvi"; s_IPVI.item = "Vegetation:IPVI"; s_IPVI.description = ""; s_IPVI.type = "IPVI"; s_IPVI.chan1 = "red"; s_IPVI.chan2 = "nir"; s_IPVI.chan3 = ""; m_Map.push_back(s_IPVI); indiceSpec s_LAIFromNDVILog; s_LAIFromNDVILog.key = "list.laindvilog"; s_LAIFromNDVILog.item = "Vegetation:LAIFromNDVILog"; s_LAIFromNDVILog.description = ""; s_LAIFromNDVILog.type = "LAIFromNDVILog"; s_LAIFromNDVILog.chan1 = "red"; s_LAIFromNDVILog.chan2 = "nir"; s_LAIFromNDVILog.chan3 = ""; m_Map.push_back(s_LAIFromNDVILog); indiceSpec s_LAIFromReflLinear; s_LAIFromReflLinear.key = "list.lairefl"; s_LAIFromReflLinear.item = "Vegetation:LAIFromReflLinear"; s_LAIFromReflLinear.description = ""; s_LAIFromReflLinear.type = "LAIFromReflLinear"; s_LAIFromReflLinear.chan1 = "red"; s_LAIFromReflLinear.chan2 = "nir"; s_LAIFromReflLinear.chan3 = ""; m_Map.push_back(s_LAIFromReflLinear); indiceSpec s_LAIFromNDVIFormo; s_LAIFromNDVIFormo.key = "list.laindviformo"; s_LAIFromNDVIFormo.item = "Vegetation:LAIFromNDVIFormo"; s_LAIFromNDVIFormo.description = ""; s_LAIFromNDVIFormo.type = "LAIFromNDVIFormo"; s_LAIFromNDVIFormo.chan1 = "red"; s_LAIFromNDVIFormo.chan2 = "nir"; s_LAIFromNDVIFormo.chan3 = ""; m_Map.push_back(s_LAIFromNDVIFormo); indiceSpec s_NDWI; s_NDWI.key = "list.ndwi"; s_NDWI.item = "Water:NDWI"; s_NDWI.description = ""; s_NDWI.type = "NDWI"; s_NDWI.chan1 = "nir"; s_NDWI.chan2 = "mir"; s_NDWI.chan3 = ""; m_Map.push_back(s_NDWI); indiceSpec s_NDWI2; s_NDWI2.key = "list.ndwi2"; s_NDWI2.item = "Water:NDWI2"; s_NDWI2.description = ""; s_NDWI2.type = "NDWI2"; s_NDWI2.chan1 = "green"; s_NDWI2.chan2 = "nir"; s_NDWI2.chan3 = ""; m_Map.push_back(s_NDWI2); indiceSpec s_MNDWI; s_MNDWI.key = "list.mndwi"; s_MNDWI.item = "Water:MNDWI"; s_MNDWI.description = ""; s_MNDWI.type = "MNDWI"; s_MNDWI.chan1 = "green"; s_MNDWI.chan2 = "mir"; s_MNDWI.chan3 = ""; m_Map.push_back(s_MNDWI); indiceSpec s_NDPI; s_NDPI.key = "list.ndpi"; s_NDPI.item = "Water:NDPI"; s_NDPI.description = ""; s_NDPI.type = "NDPI"; s_NDPI.chan1 = "mir"; s_NDPI.chan2 = "green"; s_NDPI.chan3 = ""; m_Map.push_back(s_NDPI); indiceSpec s_NDTI; s_NDTI.key = "list.ndti"; s_NDTI.item = "Water:NDTI"; s_NDTI.description = ""; s_NDTI.type = "NDTI"; s_NDTI.chan1 = "red"; s_NDTI.chan2 = "green"; s_NDTI.chan3 = ""; m_Map.push_back(s_NDTI); indiceSpec s_SRWI; s_SRWI.key = "list.srwi"; s_SRWI.item = "Water:SRWI"; s_SRWI.description = ""; s_SRWI.type = "SRWI"; s_SRWI.chan1 = "rho860"; s_SRWI.chan2 = "rho1240"; s_SRWI.chan3 = ""; //m_Map.push_back(s_SRWI); indiceSpec s_RI; s_RI.key = "list.ri"; s_RI.item = "Soil:RI"; s_RI.description = ""; s_RI.type = "RI"; s_RI.chan1 = "red"; s_RI.chan2 = "green"; s_RI.chan3 = ""; m_Map.push_back(s_RI); indiceSpec s_CI; s_CI.key = "list.ci"; s_CI.item = "Soil:CI"; s_CI.description = ""; s_CI.type = "CI"; s_CI.chan1 = "red"; s_CI.chan2 = "green"; s_CI.chan3 = ""; m_Map.push_back(s_CI); indiceSpec s_BI; s_BI.key = "list.bi"; s_BI.item = "Soil:BI"; s_BI.description = ""; s_BI.type = "BI"; s_BI.chan1 = "red"; s_BI.chan2 = "green"; s_BI.chan3 = ""; m_Map.push_back(s_BI); indiceSpec s_BI2; s_BI2.key = "list.bi2"; s_BI2.item = "Soil:BI2"; s_BI2.description = ""; s_BI2.type = "BI2"; s_BI2.chan1 = "nir"; s_BI2.chan2 = "red"; s_BI2.chan3 = "green"; m_Map.push_back(s_BI2); ClearChoices("list"); for ( unsigned int i=0; iGetFunctor().SetIndex1(this->GetParameterInt(oss.str()));\ oss.str(""); \ oss<<"channels."<GetFunctor().SetIndex2(this->GetParameterInt(oss.str()));\ l_##type##Filter->SetInput(inImage); \ m_FilterList->PushBack( l_##type##Filter ); \ m_ImageList->PushBack( l_##type##Filter->GetOutput() ); \ otbAppLogINFO(<< m_Map[GetSelectedItems("list")[idx]].item << " added.");\ } #define otbRadiometricVegetationIndicesMacro( type ) \ { \ type##FilterType::Pointer l_##type##Filter = type##FilterType::New(); \ std::ostringstream oss; \ oss<<"channels."<SetRedIndex(this->GetParameterInt(oss.str())); \ oss.str(""); \ oss<<"channels."<SetNIRIndex(this->GetParameterInt(oss.str())); \ l_##type##Filter->SetInput(inImage); \ m_FilterList->PushBack( l_##type##Filter ); \ m_ImageList->PushBack( l_##type##Filter->GetOutput() ); \ otbAppLogINFO(<GetFunctor().SetRedIndex(this->GetParameterInt(oss.str()));\ oss.str(""); \ oss<<"channels."<GetFunctor().SetGreenIndex(this->GetParameterInt(oss.str()));\ l_##type##Filter->SetInput(inImage); \ m_FilterList->PushBack( l_##type##Filter ); \ m_ImageList->PushBack( l_##type##Filter->GetOutput() ); \ otbAppLogINFO(<< m_Map[GetSelectedItems("list")[idx]].item << " added.");\ } void DoExecute() ITK_OVERRIDE { int nbChan = GetParameterImage("in")->GetNumberOfComponentsPerPixel(); if ( (this->GetParameterInt("channels.blue") <= nbChan) && (this->GetParameterInt("channels.green") <= nbChan) && (this->GetParameterInt("channels.red") <= nbChan) && (this->GetParameterInt("channels.nir") <= nbChan) && (this->GetParameterInt("channels.mir") <= nbChan)) { m_FilterList = FilterListType::New(); m_ImageList = ImageListType::New(); m_Concatener = ImageListToVectorImageFilterType::New(); FloatVectorImageType* inImage = GetParameterImage("in"); for (unsigned int idx = 0; idx < GetSelectedItems("list").size(); ++idx) { if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:NDVI") otbRadiometricVegetationIndicesMacro(NDVI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:TNDVI") otbRadiometricVegetationIndicesMacro(TNDVI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:RVI") otbRadiometricVegetationIndicesMacro(RVI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:SAVI") otbRadiometricVegetationIndicesMacro(SAVI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:TSAVI") otbRadiometricVegetationIndicesMacro(TSAVI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:MSAVI") otbRadiometricVegetationIndicesMacro(MSAVI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:MSAVI2") otbRadiometricVegetationIndicesMacro(MSAVI2); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:GEMI") otbRadiometricVegetationIndicesMacro(GEMI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:IPVI") otbRadiometricVegetationIndicesMacro(IPVI); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:LAIFromNDVILog") otbRadiometricVegetationIndicesMacro(LAIFromNDVILog); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:LAIFromReflLinear") otbRadiometricVegetationIndicesMacro(LAIFromReflLinear); if (m_Map[GetSelectedItems("list")[idx]].item == "Vegetation:LAIFromNDVIFormo") otbRadiometricVegetationIndicesMacro(LAIFromNDVIFormo); if (m_Map[GetSelectedItems("list")[idx]].item == "Water:NDWI") otbRadiometricWaterIndicesMacro(NDWI); if (m_Map[GetSelectedItems("list")[idx]].item == "Water:NDWI2") otbRadiometricWaterIndicesMacro(NDWI2); if (m_Map[GetSelectedItems("list")[idx]].item == "Water:MNDWI") otbRadiometricWaterIndicesMacro(MNDWI); if (m_Map[GetSelectedItems("list")[idx]].item == "Water:NDPI") otbRadiometricWaterIndicesMacro(NDPI); if (m_Map[GetSelectedItems("list")[idx]].item == "Water:NDTI") otbRadiometricWaterIndicesMacro(NDTI); if (m_Map[GetSelectedItems("list")[idx]].item == "Water:SRWI") otbRadiometricWaterIndicesMacro(SRWI); if (m_Map[GetSelectedItems("list")[idx]].item == "Soil:RI") otbRadiometricSoilIndicesMacro(RI); if (m_Map[GetSelectedItems("list")[idx]].item == "Soil:CI") otbRadiometricSoilIndicesMacro(CI); if (m_Map[GetSelectedItems("list")[idx]].item == "Soil:BI") otbRadiometricSoilIndicesMacro(BI); if (m_Map[GetSelectedItems("list")[idx]].item == "Soil:BI2") { BI2FilterType::Pointer l_BI2Filter = BI2FilterType::New(); std::ostringstream oss; oss<<"channels."<GetFunctor().SetNIRIndex(this->GetParameterInt(oss.str())); oss.str(""); oss<<"channels."<GetFunctor().SetRedIndex(this->GetParameterInt(oss.str())); oss.str(""); oss<<"channels."<GetFunctor().SetGreenIndex(this->GetParameterInt(oss.str())); l_BI2Filter->SetInput(inImage); m_FilterList->PushBack( l_BI2Filter ); m_ImageList->PushBack( l_BI2Filter->GetOutput() ); otbAppLogINFO(<< m_Map[GetSelectedItems("list")[idx]].item << " added."); } } if( m_ImageList->Size() == 0 ) { itkExceptionMacro(<< "No indices selected..."); } m_Concatener->SetInput( m_ImageList ); m_Concatener->UpdateOutputInformation(); SetParameterOutputImage("out", m_Concatener->GetOutput()); } else { itkExceptionMacro(<< "At least one needed channel has an invalid index"); } } FilterListType::Pointer m_FilterList; ImageListType::Pointer m_ImageList; ImageListToVectorImageFilterType::Pointer m_Concatener; std::vector m_Map; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::RadiometricIndices) OTB-release-5.8/Modules/Applications/AppIndices/otb-module.cmake000066400000000000000000000004011301006202600245370ustar00rootroot00000000000000set(DOCUMENTATION "Classical indices (NDVI, NDWI,) application.") otb_module(OTBAppIndices DEPENDS OTBIndices OTBApplicationEngine OTBObjectList TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppIndices/test/000077500000000000000000000000001301006202600224525ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppIndices/test/CMakeLists.txt000066400000000000000000000024611301006202600252150ustar00rootroot00000000000000otb_module_test() #----------- RadiometricIndices TESTS ---------------- otb_test_application(NAME apTvFERadiometricIndices_veg APP RadiometricIndices OPTIONS -in ${INPUTDATA}/veryverySmallFSATSW.tif -channels.red 3 -channels.green 2 -channels.nir 4 -list Vegetation:NDVI Vegetation:RVI Vegetation:IPVI -out ${TEMP}/apTvFERadiometricIndices_veg.tif VALID --compare-image ${NOTOL} ${BASELINE}/apTvRIRadiometricVegetationIndices.tif ${TEMP}/apTvFERadiometricIndices_veg.tif) otb_test_application(NAME apTvFERadiometricIndices_wat APP RadiometricIndices OPTIONS -in ${INPUTDATA}/veryverySmallFSATSW.tif -list Water:NDWI2 -channels.red 3 -channels.green 2 -channels.nir 4 -out ${TEMP}/apTvFERadiometricIndices_wat.tif VALID --compare-image ${NOTOL} ${BASELINE}/apTvRIRadiometricWaterIndices_.tif ${TEMP}/apTvFERadiometricIndices_wat.tif) OTB-release-5.8/Modules/Applications/AppKMZ/000077500000000000000000000000001301006202600205565ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppKMZ/CMakeLists.txt000066400000000000000000000000451301006202600233150ustar00rootroot00000000000000project(OTBAppKMZ) otb_module_impl() OTB-release-5.8/Modules/Applications/AppKMZ/app/000077500000000000000000000000001301006202600213365ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppKMZ/app/CMakeLists.txt000066400000000000000000000003001301006202600240670ustar00rootroot00000000000000set(OTBAppImageUtils_LINK_LIBS ${OTBKMZWriter_LIBRARIES} ) otb_create_application( NAME KmzExport SOURCES otbKmzExport.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppKMZ/app/otbKmzExport.cxx000066400000000000000000000102351301006202600245330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbKmzProductWriter.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class KmzExport : public Application { public: /** Standard class typedefs. */ typedef KmzExport Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(KmzExport, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("KmzExport"); SetDescription("Export the input image in a KMZ product."); // Documentation SetDocName("Image to KMZ Export"); SetDocLongDescription("This application exports the input image in a kmz product that can be display in the Google Earth software. The user can set the size of the product size, a logo and a legend to the product. Furthemore, to obtain a product that fits the relief, a DEM can be used."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("Conversion"); AddDocTag("KMZ"); AddDocTag("Export"); AddParameter(ParameterType_InputImage, "in", "Input image"); SetParameterDescription("in", "Input image"); AddParameter(ParameterType_OutputFilename, "out", "Output .kmz product"); SetParameterDescription("out", "Output Kmz product directory (with .kmz extension)"); AddParameter(ParameterType_Int, "tilesize", "Tile Size"); SetParameterDescription("tilesize", "Size of the tiles in the kmz product, in number of pixels (default = 512)."); SetDefaultParameterInt("tilesize", 512); MandatoryOff("tilesize"); AddParameter(ParameterType_InputImage, "logo", "Image logo"); SetParameterDescription("logo", "Path to the image logo to add to the KMZ product."); MandatoryOff("logo"); AddParameter(ParameterType_InputImage, "legend", "Image legend"); SetParameterDescription("legend", "Path to the image legend to add to the KMZ product."); MandatoryOff("legend"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract2.tif"); SetDocExampleParameterValue("out", "otbKmzExport.kmz"); SetDocExampleParameterValue("logo", "otb_big.png"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } void DoExecute() ITK_OVERRIDE { typedef otb::KmzProductWriter KmzProductWriterType; // Second part : Image To Kmz KmzProductWriterType::Pointer kmzWriter = KmzProductWriterType::New(); kmzWriter->SetInput( this->GetParameterImage("in") ); kmzWriter->SetPath( this->GetParameterString("out") ); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // If the tile size is set if( this->HasValue("tilesize") ) { if (this->GetParameterInt("tilesize") >= 0) kmzWriter->SetTileSize( this->GetParameterInt("tilesize") ); else itkExceptionMacro(<< "The tile size should be a positive value."); } // Add the logo if any if( this->HasValue("logo") ) { kmzWriter->SetLogo( this->GetParameterImage("logo") ); } // Add the legend if any if( this->HasValue("legend") ) { kmzWriter->AddLegend( this->GetParameterImage("legend") ); } // trigger the writing kmzWriter->Update(); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::KmzExport) OTB-release-5.8/Modules/Applications/AppKMZ/otb-module.cmake000066400000000000000000000003411301006202600236250ustar00rootroot00000000000000set(DOCUMENTATION "KMZ generation related applications.") otb_module(OTBAppKMZ DEPENDS OTBApplicationEngine OTBKMZWriter TEST_DEPENDS OTBCommandLine OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppKMZ/test/000077500000000000000000000000001301006202600215355ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppKMZ/test/CMakeLists.txt000066400000000000000000000022361301006202600243000ustar00rootroot00000000000000otb_module_test() #----------- KmzExport TESTS ---------------- otb_test_application(NAME apTvUtKmzExport APP KmzExport OPTIONS -in ${INPUTDATA}/qb_RoadExtract.img -out ${TEMP}/apTvUtKmzExport.kmz -logo ${INPUTDATA}/cnes.png -legend ${INPUTDATA}/otb_big.png -elev.dem ${INPUTDATA}/DEM/srtm_directory) set_property(TEST apTvUtKmzExport PROPERTY RESOURCE_LOCK kmz_tmp_dir) otb_test_application(NAME apTvUtKmzExport1Band APP KmzExport OPTIONS #-in /media/otbnas/public/Data/Saterre/data/cumulLAI.tif -in ${INPUTDATA}/QB_PAN_ROI_1000_100.tif -out ${TEMP}/apTvUtKmzExport1Band.kmz -logo ${INPUTDATA}/cnes.png -legend ${INPUTDATA}/otb_big.png -elev.dem ${INPUTDATA}/DEM/srtm_directory -tilesize 50) # needed to see the bug mantis #773 set_property(TEST apTvUtKmzExport1Band PROPERTY RESOURCE_LOCK kmz_tmp_dir) OTB-release-5.8/Modules/Applications/AppMathParser/000077500000000000000000000000001301006202600221635ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMathParser/CMakeLists.txt000066400000000000000000000000551301006202600247230ustar00rootroot00000000000000project(OTBAppMathParser) otb_module_impl() OTB-release-5.8/Modules/Applications/AppMathParser/app/000077500000000000000000000000001301006202600227435ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMathParser/app/CMakeLists.txt000066400000000000000000000004371301006202600255070ustar00rootroot00000000000000set(OTBAppMathParser_LINK_LIBS ${OTBApplicationEngine_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBMathParser_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_create_application( NAME BandMath SOURCES otbBandMath.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppMathParser/app/otbBandMath.cxx000066400000000000000000000164471301006202600256660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbBandMathImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbObjectList.h" namespace otb { namespace Wrapper { class BandMath : public Application { public: /** Standard class typedefs. */ typedef BandMath Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(BandMath, otb::Application); typedef otb::MultiToMonoChannelExtractROI ExtractROIFilterType; typedef otb::ObjectList ExtractROIFilterListType; typedef otb::BandMathImageFilter BandMathImageFilterType; private: void DoInit() ITK_OVERRIDE { SetName("BandMath"); SetDescription("Perform a mathematical operation on monoband images"); SetDocName("Band Math"); SetDocLongDescription("This application performs a mathematical operation on monoband images." "Mathematical formula interpretation is done via MuParser libraries.\n" "For MuParser version superior to 2.0 uses '&&' and '||' logical operators, and ternary operator 'boolean_expression ? if_true : if_false'\n" "For older version of MuParser (prior to v2) use 'and' and 'or' logical operators, and ternary operator 'if(; ; )'.\n" "The list of features and operators is available on MuParser website: http://muparser.sourceforge.net/\n" ); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag("Util"); AddParameter(ParameterType_InputImageList, "il", "Input image list"); SetParameterDescription("il", "Image list to perform computation on."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out","Output image."); AddRAMParameter(); AddParameter(ParameterType_String, "exp", "Expression"); SetParameterDescription("exp", "The mathematical expression to apply. \nUse im1b1 for the first band, im1b2 for the second one..."); // Doc example parameter settings SetDocExampleParameterValue("il", "verySmallFSATSW_r.tif verySmallFSATSW_nir.tif verySmallFSATSW.tif"); SetDocExampleParameterValue("out", "apTvUtBandMathOutput.tif"); SetDocExampleParameterValue("exp", "\"cos(im1b1) > cos(im2b1) ? im3b1 : im3b2 \""); } void DoUpdateParameters() ITK_OVERRIDE { // Check if the expression is correctly set if (HasValue("il")) { LiveCheck(); } } void LiveCheck() { // Initialize a bandMath Filter first m_ChannelExtractorList = ExtractROIFilterListType::New(); m_Filter = BandMathImageFilterType::New(); FloatVectorImageListType::Pointer inList = GetParameterImageList("il"); unsigned int nbInputs = inList->Size(); unsigned int imageId = 0, bandId = 0; for (unsigned int i = 0; i < nbInputs; i++) { FloatVectorImageType::Pointer currentImage = inList->GetNthElement(i); currentImage->UpdateOutputInformation(); for (unsigned int j = 0; j < currentImage->GetNumberOfComponentsPerPixel(); j++) { std::ostringstream tmpParserVarName; tmpParserVarName << "im" << imageId + 1 << "b" << j + 1; m_ExtractROIFilter = ExtractROIFilterType::New(); m_ExtractROIFilter->SetInput(currentImage); m_ExtractROIFilter->SetChannel(j + 1); m_ExtractROIFilter->GetOutput()->UpdateOutputInformation(); m_ChannelExtractorList->PushBack(m_ExtractROIFilter); m_Filter->SetNthInput(bandId, m_ChannelExtractorList->Back()->GetOutput(), tmpParserVarName.str()); bandId++; } imageId++; } otb::Parser::Pointer dummyParser = otb::Parser::New(); std::vector dummyVars; std::string success = "The expression is Valid"; SetParameterDescription("exp", success); std::ostringstream failure; if (HasValue("exp")) { // Setup the dummy parser for (unsigned int i = 0; i < bandId; i++) { dummyVars.push_back(1.); dummyParser->DefineVar(m_Filter->GetNthInputName(i), &(dummyVars.at(i))); } dummyParser->SetExpr(GetParameterString("exp")); // Check the expression try { dummyParser->Eval(); } catch(itk::ExceptionObject& err) { // Change the parameter description to be able to have the // parser errors in the tooltip SetParameterDescription("exp", err.GetDescription()); } } } void DoExecute() ITK_OVERRIDE { // Get the input image list FloatVectorImageListType::Pointer inList = GetParameterImageList("il"); // checking the input images list validity const unsigned int nbImages = inList->Size(); if (nbImages == 0) { itkExceptionMacro("No input Image set...; please set at least one input image"); } m_ChannelExtractorList = ExtractROIFilterListType::New(); m_Filter = BandMathImageFilterType::New(); unsigned int bandId = 0; unsigned int imageId = 0; for (unsigned int i = 0; i < nbImages; i++) { FloatVectorImageType::Pointer currentImage = inList->GetNthElement(i); currentImage->UpdateOutputInformation(); otbAppLogINFO( << "Image #" << i + 1 << " has " << currentImage->GetNumberOfComponentsPerPixel() << " components" << std::endl ); for (unsigned int j = 0; j < currentImage->GetNumberOfComponentsPerPixel(); j++) { std::ostringstream tmpParserVarName; tmpParserVarName << "im" << imageId + 1 << "b" << j + 1; m_ExtractROIFilter = ExtractROIFilterType::New(); m_ExtractROIFilter->SetInput(currentImage); m_ExtractROIFilter->SetChannel(j + 1); m_ExtractROIFilter->GetOutput()->UpdateOutputInformation(); m_ChannelExtractorList->PushBack(m_ExtractROIFilter); m_Filter->SetNthInput(bandId, m_ChannelExtractorList->Back()->GetOutput(), tmpParserVarName.str()); bandId++; } imageId++; } m_Filter->SetExpression(GetParameterString("exp")); // Set the output image SetParameterOutputImage("out", m_Filter->GetOutput()); } ExtractROIFilterType::Pointer m_ExtractROIFilter; ExtractROIFilterListType::Pointer m_ChannelExtractorList; BandMathImageFilterType::Pointer m_Filter; }; } // namespace Wrapper } // namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::BandMath) OTB-release-5.8/Modules/Applications/AppMathParser/otb-module.cmake000066400000000000000000000002671301006202600252410ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBAppMathParser DEPENDS OTBApplicationEngine OTBImageBase OTBMathParser OTBObjectList DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppMathParser/test/000077500000000000000000000000001301006202600231425ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMathParser/test/CMakeLists.txt000066400000000000000000000012351301006202600257030ustar00rootroot00000000000000otb_module_test() #----------- BandMath TESTS ---------------- otb_test_application(NAME apTvUtBandMath APP BandMath OPTIONS -il ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${INPUTDATA}/poupees_sub.png -out ${TEMP}/apTvUtBandMathOutput.tif -exp "cos(im1b1)+im2b1*im3b1-im3b2+ndvi(im3b3,im3b4)" VALID --compare-image ${NOTOL} ${INPUTDATA}/apTvUtBandMathOutput.tif ${TEMP}/apTvUtBandMathOutput.tif) OTB-release-5.8/Modules/Applications/AppMathParserX/000077500000000000000000000000001301006202600223135ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMathParserX/CMakeLists.txt000066400000000000000000000000561301006202600250540ustar00rootroot00000000000000project(OTBAppMathParserX) otb_module_impl() OTB-release-5.8/Modules/Applications/AppMathParserX/app/000077500000000000000000000000001301006202600230735ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMathParserX/app/CMakeLists.txt000066400000000000000000000004071301006202600256340ustar00rootroot00000000000000set(OTBAppMathParserX_LINK_LIBS ${OTBApplicationEngine_LIBRARIES} ${OTBMathParserX_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_create_application( NAME BandMathX SOURCES otbBandMathX.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppMathParserX/app/otbBandMathX.cxx000066400000000000000000000341301301006202600261330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbObjectList.h" #include "otbBandMathXImageFilter.h" #include "otbMultiChannelExtractROI.h" #include "itksys/SystemTools.hxx" namespace otb { namespace Wrapper { class BandMathX : public Application { public: /** Standard class typedefs. */ typedef BandMathX Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(BandMathX, otb::Application); typedef otb::MultiChannelExtractROI MultiChannelExtractorType; typedef otb::BandMathXImageFilter BandMathImageFilterType; private: void DoInit() ITK_OVERRIDE { SetName("BandMathX"); SetDescription("This application performs mathematical operations on multiband images.\n" "Mathematical formula interpretation is done via muParserX library : http://articles.beltoforion.de/article.php?a=muparserx"); SetDocName("Band Math X"); SetDocLongDescription("The goal of this documentation is to give the user some hints about the syntax used in this application.\n" "The syntax is mainly constrained by the muparserx library, which can be considered as the core of the application.\n" "\n\n" "- Fundamentals:\n\n" "The default prefix name for variables related to the ith input is 'im(i+1)'(note the indexing from 1 to N, for N inputs). \n" "The following list summaries the available variables for input #0 (and so on for every input): \n" "\n" "im1 --> a pixel from first input, made of n components (n bands)\n" "im1bj --> jth component of a pixel from first input (first band is indexed by 1)\n" "im1bjNkxp --> a neighbourhood ('N') of pixels of the jth component from first input, of size kxp\n" "im1PhyX and im1PhyY --> spacing of first input in X and Y directions (horizontal and vertical)\n" "im1bjMean im1bjMin im1bjMax im1bjSum im1bjVar --> mean, min, max, sum, variance of jth band from first input (global statistics)\n" "\nMoreover, we also have the following generic variables:\n" "idxX and idxY --> indices of the current pixel\n" "\n" "Always keep in mind that this application only addresses mathematically well-defined formulas.\n" "For instance, it is not possible to add vectors of different dimensions (this implies the addition of a row vector with a column vector),\n" "or add a scalar to a vector or a matrix, or divide two vectors, and so on...\n" "Thus, it is important to remember that a pixel of n components is always represented as a row vector.\n" "\n" "Example :\n\n" " im1 + im2 (1)\n" "\nrepresents the addition of pixels from first and second inputs. This expression is consistent only if\n" "both inputs have the same number of bands.\n" "Note that it is also possible to use the following expressions to obtain the same result:\n" "\n" " im1b1 + im2b1 \n" " im1b2 + im2b2 (2)\n" " ..." "\n\nNevertheless, the first expression is by far much pleaseant. We call this new functionality the 'batch mode'\n" "(performing the same operation in a band-to-band fashion).\n" "\n\n" "- Operations involving neighborhoods of pixels:\n\n" "Another new fonctionnality is the possibility to perform operations that involve neighborhoods of pixels.\n" "Variable related to such neighborhoods are always defined following the pattern imIbJNKxP, where: \n" "- I is an number identifying the image input (remember, input #0 = im1, and so on)\n" "- J is an number identifying the band (remember, first band is indexed by 1)\n" "- KxP are two numbers that represent the size of the neighborhood (first one is related to the horizontal direction)\n" "All neighborhood are centered, thus K and P must be odd numbers.\n" "Many operators come with this new functionality: dotpr, mean var median min max...\n" "For instance, if im1 represents the pixel of 3 bands image:\n\n" " im1 - mean(im1b1N5x5,im1b2N5x5,im1b3N5x5) (3)\n" "\ncould represent a high pass filter (Note that by implying three neighborhoods, the operator mean returns a row vector of three components.\n" "It is a typical behaviour for many operators of this application).\n" "\n\n" "- Operators:\n\n" "In addition to the previous operators, other operators are available:\n" "- existing operators/functions from muParserX, that were not originally defined for vectors and\n" "matrices (for instance cos, sin, ...). These new operators/ functions keep the original names to which we added the prefix 'v' for vector (vcos, vsin, ...).\n" "- mult, div and pow operators, that perform element-wise multiplication, division or exponentiation of vector/matrices (for instance im1 div im2)\n" "- mlt, dv and pw operators, that perform multiplication, division or exponentiation of vector/matrices by a scalar (for instance im1 dv 2.0)\n" "- bands, which is a very useful operator. It allows selecting specific bands from an image, and/or to rearrange them in a new vector;\n" "for instance bands(im1,{1,2,1,1}) produces a vector of 4 components made of band 1, band 2, band 1 and band 1 values from the first input.\n" "Note that curly brackets must be used in order to select the desired band indices.\n" "... and so on.\n" "\n\n" "- Application itself:\n\n" "The application takes the following parameters :\n" "- Setting the list of inputs can be done with the 'il' parameter.\n" "- Setting expressions can be done with the 'exp' parameter (see also limitations section below).\n" "- Setting constants can be done with the 'incontext' parameter. User must provide a txt file with a specific syntax: #type name value\n" "An example of such a file is given below:\n\n" "#F expo 1.1\n" "#M kernel1 { 0.1 , 0.2 , 0.3; 0.4 , 0.5 , 0.6; 0.7 , 0.8 , 0.9; 1 , 1.1 , 1.2; 1.3 , 1.4 , 1.5 }\n" "\nAs we can see, #I/#F allows the definition of an integer/float constant, whereas #M allows the definition of a vector/matrix.\n" "In the latter case, elements of a row must be separated by commas, and rows must be separated by semicolons.\n" "It is also possible to define expressions within the same txt file, with the pattern #E expr. For instance (two expressions; see also limitations section below):\n\n" "#E $dotpr(kernel1,im1b1N3x5); im2b1^expo$\n" "\n- The 'outcontext' parameter allows saving user's constants and expressions (context).\n" "- Setting the output image can be done with the 'out' parameter (multi-outputs is not implemented yet).\n" "\n\n" "Finally, we strongly recommend that the reader takes a look at the cookbook, where additional information can be found (http://www.orfeo-toolbox.org/packages/OTBCookBook.pdf).\n" ); SetDocLimitations("The application is currently unable to produce one output image per expression, contrary to otbBandMathXImageFilter.\n" "Separating expressions by semi-colons (; ) will concatenate their results into a unique multiband output image. "); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag("Util"); AddParameter(ParameterType_InputImageList, "il", "Input image list"); SetParameterDescription("il", "Image list to perform computation on."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out","Output image."); AddRAMParameter(); AddParameter(ParameterType_String, "exp", "Expressions"); SetParameterDescription("exp", "Mathematical expression to apply."); AddParameter(ParameterType_InputFilename, "incontext", "Import context"); SetParameterDescription("incontext", "A txt file containing user's constants and expressions."); MandatoryOff("incontext"); AddParameter(ParameterType_OutputFilename, "outcontext", "Export context"); SetParameterDescription("outcontext", "A txt file where to save user's constants and expressions."); MandatoryOff("outcontext"); // Doc example parameter settings SetDocExampleParameterValue("il", "verySmallFSATSW_r.tif verySmallFSATSW_nir.tif verySmallFSATSW.tif"); SetDocExampleParameterValue("out", "apTvUtBandMathOutput.tif"); SetDocExampleParameterValue("exp", "\"cos(im1b1)+im2b1*im3b1-im3b2+ndvi(im3b3, im3b4)\""); } void DoUpdateParameters() ITK_OVERRIDE { // check if input context should be used bool useContext = this->ContextCheck(); // Check if the expression is correctly set if (HasValue("il") && HasValue("exp")) { this->LiveCheck(useContext); } } bool ContextCheck(void) { bool useContext = false; if (IsParameterEnabled("incontext") && HasValue("incontext")) { std::string contextPath = GetParameterString("incontext"); // check that file exists if (itksys::SystemTools::FileExists(contextPath.c_str(),true)) { BandMathImageFilterType::Pointer dummyFilter = BandMathImageFilterType::New(); dummyFilter->SetManyExpressions(false); try { dummyFilter->ImportContext(contextPath); useContext = true; } catch(itk::ExceptionObject& err) { //trick to prevent unreferenced local variable warning on MSVC (void)err; // silent catch useContext = false; } if (useContext) { // only set the first expression, 'ManyExpression' is disabled. this->SetParameterString("exp",dummyFilter->GetExpression(0)); } } } return useContext; } void LiveCheck(bool useContext=false) { BandMathImageFilterType::Pointer dummyFilter = BandMathImageFilterType::New(); dummyFilter->SetManyExpressions(false); std::vector extractors; FloatVectorImageListType::Pointer inList = GetParameterImageList("il"); for (unsigned int i = 0; i < inList->Size(); i++) { FloatVectorImageType::Pointer inImg = inList->GetNthElement(i); FloatVectorImageType::RegionType largestRegion = inImg->GetLargestPossibleRegion(); unsigned int nbChannels = inImg->GetNumberOfComponentsPerPixel(); MultiChannelExtractorType::Pointer extract = MultiChannelExtractorType::New(); extractors.push_back(extract); extract->SetInput(inImg); extract->SetStartX(largestRegion.GetIndex(0)); extract->SetStartY(largestRegion.GetIndex(1)); // Set extract size to 1 in case of global stats computation extract->SetSizeX(1); extract->SetSizeY(1); for (unsigned int j=0 ; jSetChannel(j+1); } dummyFilter->SetNthInput(i,extract->GetOutput()); } if (useContext) { dummyFilter->ImportContext(GetParameterString("incontext")); } else { dummyFilter->SetExpression(GetParameterString("exp")); } try { dummyFilter->UpdateOutputInformation(); SetParameterDescription("exp", "Valid expression"); } catch(itk::ExceptionObject& err) { // Change the parameter description to be able to have the // parser errors in the tooltip SetParameterDescription("exp", err.GetDescription()); } } void DoExecute() ITK_OVERRIDE { // Get the input image list FloatVectorImageListType::Pointer inList = GetParameterImageList("il"); // checking the input images list validity const unsigned int nbImages = inList->Size(); if (nbImages == 0) { itkExceptionMacro("No input Image set...; please set at least one input image"); } if ( (!IsParameterEnabled("exp")) && (!IsParameterEnabled("incontext")) ) { itkExceptionMacro("No expression set...; please set and enable at least one one expression"); } m_Filter = BandMathImageFilterType::New(); m_Filter->SetManyExpressions(false); for (unsigned int i = 0; i < nbImages; i++) { FloatVectorImageType::Pointer currentImage = inList->GetNthElement(i); currentImage->UpdateOutputInformation(); otbAppLogINFO( << "Image #" << i + 1 << " has " << currentImage->GetNumberOfComponentsPerPixel() << " components"); m_Filter->SetNthInput(i,currentImage); } bool useContext = this->ContextCheck(); std::string expStr = GetParameterString("exp"); if (useContext) { otbAppLogINFO("Using input context : " << expStr ); m_Filter->ImportContext(GetParameterString("incontext")); } else { otbAppLogINFO("Using expression : " << expStr ); m_Filter->SetExpression(expStr); } if ( IsParameterEnabled("outcontext") && HasValue("outcontext") ) m_Filter->ExportContext(GetParameterString("outcontext")); // Set the output image SetParameterOutputImage("out", m_Filter->GetOutput()); } BandMathImageFilterType::Pointer m_Filter; }; } // namespace Wrapper } // namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::BandMathX) OTB-release-5.8/Modules/Applications/AppMathParserX/otb-module.cmake000066400000000000000000000002501301006202600253610ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBAppMathParserX DEPENDS OTBApplicationEngine OTBMathParserX OTBObjectList DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppMathParserX/test/000077500000000000000000000000001301006202600232725ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMathParserX/test/CMakeLists.txt000066400000000000000000000012361301006202600260340ustar00rootroot00000000000000otb_module_test() #----------- BandMathX TESTS ---------------- otb_test_application(NAME apTvUtBandMathX APP BandMathX OPTIONS -il ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${INPUTDATA}/poupees_sub.png -out ${TEMP}/apTvUtBandMathXOutput.tif -incontext ${INPUTDATA}/apTvUtExportBandMathX.txt VALID --compare-image ${NOTOL} ${INPUTDATA}/apTvUtBandMathOutput.tif ${TEMP}/apTvUtBandMathXOutput.tif) OTB-release-5.8/Modules/Applications/AppMoments/000077500000000000000000000000001301006202600215375ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMoments/CMakeLists.txt000066400000000000000000000000511301006202600242730ustar00rootroot00000000000000project(OTBAppMoments) otb_module_impl() OTB-release-5.8/Modules/Applications/AppMoments/app/000077500000000000000000000000001301006202600223175ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMoments/app/CMakeLists.txt000066400000000000000000000004311301006202600250550ustar00rootroot00000000000000set(OTBAppMoments_LINK_LIBS ${OTBMoments_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ) otb_create_application( NAME LocalStatisticExtraction SOURCES otbLocalStatisticExtraction.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppMoments/app/otbLocalStatisticExtraction.cxx000066400000000000000000000107341301006202600305400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbRadiometricMomentsImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "itkTimeProbe.h" namespace otb { namespace Wrapper { class LocalStatisticExtraction : public Application { public: /** Standard class typedefs. */ typedef LocalStatisticExtraction Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef MultiToMonoChannelExtractROI ExtractorFilterType; typedef RadiometricMomentsImageFilter FilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(LocalStatisticExtraction, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("LocalStatisticExtraction"); SetDescription("Computes local statistical moments on every pixel in the selected channel of the input image"); // Documentation SetDocName("Local Statistic Extraction"); SetDocLongDescription("This application computes the 4 local statistical moments on every pixel in the selected channel of the input image, over a specified neighborhood. The output image is multi band with one statistical moment (feature) per band. Thus, the 4 output features are the Mean, the Variance, the Skewness and the Kurtosis. They are provided in this exact order in the output image."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otbRadiometricMomentsImageFunction class"); AddDocTag("Statistics"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to compute the features on."); AddParameter(ParameterType_Int, "channel", "Selected Channel"); SetParameterDescription("channel", "The selected channel index"); SetDefaultParameterInt("channel", 1); SetMinimumParameterIntValue("channel", 1); AddRAMParameter(); AddParameter(ParameterType_Int, "radius", "Neighborhood radius"); SetParameterDescription("radius", "The computational window radius."); SetMinimumParameterIntValue("radius",1); SetDefaultParameterInt("radius",3); AddParameter(ParameterType_OutputImage, "out", "Feature Output Image"); SetParameterDescription("out", "Output image containing the local statistical moments."); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("channel", "1"); SetDocExampleParameterValue("radius", "3"); SetDocExampleParameterValue("out", "Statistics.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); int nbChan = inImage->GetNumberOfComponentsPerPixel(); if( GetParameterInt("channel") > nbChan ) { otbAppLogCRITICAL("Selected band is not available..."); return; } m_ExtractorFilter = ExtractorFilterType::New(); m_ExtractorFilter->SetInput(inImage); m_ExtractorFilter->SetStartX(inImage->GetLargestPossibleRegion().GetIndex(0)); m_ExtractorFilter->SetStartY(inImage->GetLargestPossibleRegion().GetIndex(1)); m_ExtractorFilter->SetSizeX(inImage->GetLargestPossibleRegion().GetSize(0)); m_ExtractorFilter->SetSizeY(inImage->GetLargestPossibleRegion().GetSize(1)); m_ExtractorFilter->SetChannel(GetParameterInt("channel")); m_ExtractorFilter->UpdateOutputInformation(); m_Filter = FilterType::New(); m_Filter->SetInput(m_ExtractorFilter->GetOutput()); m_Filter->SetRadius(GetParameterInt("radius")); m_Filter->UpdateOutputInformation(); SetParameterOutputImage("out", m_Filter->GetOutput()); } ExtractorFilterType::Pointer m_ExtractorFilter; FilterType::Pointer m_Filter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::LocalStatisticExtraction) OTB-release-5.8/Modules/Applications/AppMoments/otb-module.cmake000066400000000000000000000004231301006202600246070ustar00rootroot00000000000000set(DOCUMENTATION "Geometric moments (for pattern recognition) application.") otb_module(OTBAppMoments DEPENDS OTBMoments OTBImageBase OTBApplicationEngine OTBITK TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppMoments/test/000077500000000000000000000000001301006202600225165ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMoments/test/CMakeLists.txt000066400000000000000000000011441301006202600252560ustar00rootroot00000000000000otb_module_test() #----------- LocalStatisticExtraction TESTS ---------------- otb_test_application(NAME apTvFELocalStatisticExtraction APP LocalStatisticExtraction OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -channel 1 -radius 3 -out ${TEMP}/apTvFELocalStatisticExtraction.tif VALID --compare-image ${NOTOL} ${BASELINE}/feTvRadiometricMomentsImageFilter.tif ${TEMP}/apTvFELocalStatisticExtraction.tif) OTB-release-5.8/Modules/Applications/AppMorphology/000077500000000000000000000000001301006202600222545ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMorphology/CMakeLists.txt000066400000000000000000000000541301006202600250130ustar00rootroot00000000000000project(OTBAppMorphology) otb_module_impl() OTB-release-5.8/Modules/Applications/AppMorphology/app/000077500000000000000000000000001301006202600230345ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMorphology/app/CMakeLists.txt000066400000000000000000000007261301006202600256010ustar00rootroot00000000000000set(OTBAppMorphology_LINK_LIBS ${OTBImageBase_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_create_application( NAME BinaryMorphologicalOperation SOURCES otbBinaryMorphologicalOperation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME GrayScaleMorphologicalOperation SOURCES otbGrayScaleMorphologicalOperation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppMorphology/app/otbBinaryMorphologicalOperation.cxx000066400000000000000000000275051301006202600321230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "itkBinaryBallStructuringElement.h" #include "itkBinaryCrossStructuringElement.h" #include "itkBinaryDilateImageFilter.h" #include "itkBinaryErodeImageFilter.h" #include "itkBinaryMorphologicalOpeningImageFilter.h" #include "itkBinaryMorphologicalClosingImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "itkTimeProbe.h" namespace otb { namespace Wrapper { class BinaryMorphologicalOperation : public Application { public: /** Standard class typedefs. */ typedef BinaryMorphologicalOperation Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef MultiToMonoChannelExtractROI ExtractorFilterType; typedef itk::BinaryBallStructuringElement BallStructuringType; typedef BallStructuringType::RadiusType RadiusType; typedef BallStructuringType::Superclass StructuringType; typedef itk::BinaryCrossStructuringElement CrossStructuringType; typedef itk::BinaryDilateImageFilter DilateFilterType; typedef itk::BinaryErodeImageFilter ErodeFilterType; typedef itk::BinaryMorphologicalOpeningImageFilter OpeningFilterType; typedef itk::BinaryMorphologicalClosingImageFilter ClosingFilterType; typedef ImageList ImageListType; typedef ImageListToVectorImageFilter ImageListToVectorImageFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(BinaryMorphologicalOperation, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("BinaryMorphologicalOperation"); SetDescription("Performs morphological operations on an input image channel"); // Documentation SetDocName("Binary Morphological Operation"); SetDocLongDescription("This application performs binary morphological operations on a mono band image"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("itkBinaryDilateImageFilter, itkBinaryErodeImageFilter, itkBinaryMorphologicalOpeningImageFilter and itkBinaryMorphologicalClosingImageFilter classes"); AddDocTag("MorphologicalOperations"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to be filtered."); AddParameter(ParameterType_OutputImage, "out", "Feature Output Image"); SetParameterDescription("out", "Output image containing the filtered output image."); AddParameter(ParameterType_Int, "channel", "Selected Channel"); SetParameterDescription("channel", "The selected channel index"); SetDefaultParameterInt("channel", 1); SetMinimumParameterIntValue("channel", 1); AddRAMParameter(); AddParameter(ParameterType_Choice, "structype", "Structuring Element Type"); SetParameterDescription("structype", "Choice of the structuring element type"); //Ball AddChoice("structype.ball", "Ball"); AddParameter(ParameterType_Int, "structype.ball.xradius", "The Structuring Element X Radius"); SetParameterDescription("structype.ball.xradius", "The Structuring Element X Radius"); SetDefaultParameterInt("structype.ball.xradius", 5); AddParameter(ParameterType_Int, "structype.ball.yradius", "The Structuring Element Y Radius"); SetParameterDescription("structype.ball.yradius", "The Structuring Element Y Radius"); SetDefaultParameterInt("structype.ball.yradius", 5); //Cross AddChoice("structype.cross", "Cross"); AddParameter(ParameterType_Choice, "filter", "Morphological Operation"); SetParameterDescription("filter", "Choice of the morphological operation"); //Dilate AddChoice("filter.dilate", "Dilate"); AddParameter(ParameterType_Float, "filter.dilate.foreval", "Foreground Value"); SetParameterDescription("filter.dilate.foreval", "The Foreground Value"); SetDefaultParameterFloat("filter.dilate.foreval", 1.0); AddParameter(ParameterType_Float, "filter.dilate.backval", "Background Value"); SetParameterDescription("filter.dilate.backval", "The Background Value"); SetDefaultParameterFloat("filter.dilate.backval", 0.0); //Erode AddChoice("filter.erode", "Erode"); AddParameter(ParameterType_Float, "filter.erode.foreval", "Foreground Value"); SetParameterDescription("filter.erode.foreval", "The Foreground Value"); SetDefaultParameterFloat("filter.erode.foreval", 1.0); AddParameter(ParameterType_Float, "filter.erode.backval", "Background Value"); SetParameterDescription("filter.erode.backval", "The Background Value"); SetDefaultParameterFloat("filter.erode.backval", 0.0); //Opening AddChoice("filter.opening", "Opening"); AddParameter(ParameterType_Float, "filter.opening.foreval", "Foreground Value"); SetParameterDescription("filter.opening.foreval", "The Foreground Value"); SetDefaultParameterFloat("filter.opening.foreval", 1.0); AddParameter(ParameterType_Float, "filter.opening.backval", "Background Value"); SetParameterDescription("filter.opening.backval", "The Background Value"); SetDefaultParameterFloat("filter.opening.backval", 0.0); //Closing AddChoice("filter.closing", "Closing"); AddParameter(ParameterType_Float, "filter.closing.foreval", "Foreground Value"); SetParameterDescription("filter.closing.foreval", "The Foreground Value"); SetDefaultParameterFloat("filter.closing.foreval", 1.0); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("out", "opened.tif"); SetDocExampleParameterValue("channel", "1"); SetDocExampleParameterValue("structype.ball.xradius", "5"); SetDocExampleParameterValue("structype.ball.yradius", "5"); SetDocExampleParameterValue("filter", "erode"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); int nBComp = inImage->GetNumberOfComponentsPerPixel(); if( GetParameterInt("channel") > nBComp ) { itkExceptionMacro(<< "The specified channel index is invalid."); } m_ExtractorFilter = ExtractorFilterType::New(); m_ExtractorFilter->SetInput(inImage); m_ExtractorFilter->SetStartX(inImage->GetLargestPossibleRegion().GetIndex(0)); m_ExtractorFilter->SetStartY(inImage->GetLargestPossibleRegion().GetIndex(1)); m_ExtractorFilter->SetSizeX(inImage->GetLargestPossibleRegion().GetSize(0)); m_ExtractorFilter->SetSizeY(inImage->GetLargestPossibleRegion().GetSize(1)); m_ExtractorFilter->SetChannel(GetParameterInt("channel")); m_ExtractorFilter->UpdateOutputInformation(); if(GetParameterString("structype") == "ball") { BallStructuringType se; RadiusType rad; rad[0] = this->GetParameterInt("structype.ball.xradius"); rad[1] = this->GetParameterInt("structype.ball.yradius"); se.SetRadius(rad); se.CreateStructuringElement(); if(GetParameterString("filter") == "dilate") { m_DilFilter = DilateFilterType::New(); m_DilFilter->SetKernel(se); m_DilFilter->SetInput(m_ExtractorFilter->GetOutput()); m_DilFilter->SetForegroundValue(GetParameterFloat("filter.dilate.foreval")); m_DilFilter->SetBackgroundValue(GetParameterFloat("filter.dilate.backval")); SetParameterOutputImage("out", m_DilFilter->GetOutput()); } if(GetParameterString("filter") == "erode") { m_EroFilter = ErodeFilterType::New(); m_EroFilter->SetKernel(se); m_EroFilter->SetInput(m_ExtractorFilter->GetOutput()); m_EroFilter->SetForegroundValue(GetParameterFloat("filter.erode.foreval")); m_EroFilter->SetBackgroundValue(GetParameterFloat("filter.erode.backval")); SetParameterOutputImage("out", m_EroFilter->GetOutput()); } if(GetParameterString("filter") == "opening") { m_OpeFilter = OpeningFilterType::New(); m_OpeFilter->SetKernel(se); m_OpeFilter->SetInput(m_ExtractorFilter->GetOutput()); m_OpeFilter->SetForegroundValue(GetParameterFloat("filter.opening.foreval")); m_OpeFilter->SetBackgroundValue(GetParameterFloat("filter.opening.backval")); SetParameterOutputImage("out", m_OpeFilter->GetOutput()); } if(GetParameterString("filter") == "closing") { m_CloFilter = ClosingFilterType::New(); m_CloFilter->SetKernel(se); m_CloFilter->SetInput(m_ExtractorFilter->GetOutput()); m_CloFilter->SetForegroundValue(GetParameterFloat("filter.closing.foreval")); SetParameterOutputImage("out", m_CloFilter->GetOutput()); } } if(GetParameterString("structype") == "cross") { CrossStructuringType se; se.CreateStructuringElement(); if(GetParameterString("filter") == "dilate") { m_DilFilter = DilateFilterType::New(); m_DilFilter->SetKernel(se); m_DilFilter->SetInput(m_ExtractorFilter->GetOutput()); m_DilFilter->SetForegroundValue(GetParameterFloat("filter.dilate.foreval")); m_DilFilter->SetBackgroundValue(GetParameterFloat("filter.dilate.backval")); SetParameterOutputImage("out", m_DilFilter->GetOutput()); } if(GetParameterString("filter") == "erode") { m_EroFilter = ErodeFilterType::New(); m_EroFilter->SetKernel(se); m_EroFilter->SetInput(m_ExtractorFilter->GetOutput()); m_EroFilter->SetForegroundValue(GetParameterFloat("filter.erode.foreval")); m_EroFilter->SetBackgroundValue(GetParameterFloat("filter.erode.backval")); SetParameterOutputImage("out", m_EroFilter->GetOutput()); } if(GetParameterString("filter") == "opening") { m_OpeFilter = OpeningFilterType::New(); m_OpeFilter->SetKernel(se); m_OpeFilter->SetInput(m_ExtractorFilter->GetOutput()); m_OpeFilter->SetForegroundValue(GetParameterFloat("filter.opening.foreval")); m_OpeFilter->SetBackgroundValue(GetParameterFloat("filter.opening.backval")); SetParameterOutputImage("out", m_OpeFilter->GetOutput()); } if(GetParameterString("filter") == "closing") { m_CloFilter = ClosingFilterType::New(); m_CloFilter->SetKernel(se); m_CloFilter->SetInput(m_ExtractorFilter->GetOutput()); m_CloFilter->SetForegroundValue(GetParameterFloat("filter.closing.foreval")); SetParameterOutputImage("out", m_CloFilter->GetOutput()); } } } ExtractorFilterType::Pointer m_ExtractorFilter; DilateFilterType::Pointer m_DilFilter; ErodeFilterType::Pointer m_EroFilter; OpeningFilterType::Pointer m_OpeFilter; ClosingFilterType::Pointer m_CloFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::BinaryMorphologicalOperation) OTB-release-5.8/Modules/Applications/AppMorphology/app/otbGrayScaleMorphologicalOperation.cxx000066400000000000000000000224661301006202600325520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "itkBinaryBallStructuringElement.h" #include "itkBinaryCrossStructuringElement.h" #include "itkGrayscaleDilateImageFilter.h" #include "itkGrayscaleErodeImageFilter.h" #include "itkGrayscaleMorphologicalOpeningImageFilter.h" #include "itkGrayscaleMorphologicalClosingImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "itkTimeProbe.h" namespace otb { namespace Wrapper { class GrayScaleMorphologicalOperation : public Application { public: /** Standard class typedefs. */ typedef GrayScaleMorphologicalOperation Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef MultiToMonoChannelExtractROI ExtractorFilterType; typedef itk::BinaryBallStructuringElement BallStructuringType; typedef BallStructuringType::RadiusType RadiusType; typedef BallStructuringType::Superclass StructuringType; typedef itk::BinaryCrossStructuringElement CrossStructuringType; typedef itk::GrayscaleDilateImageFilter DilateFilterType; typedef itk::GrayscaleErodeImageFilter ErodeFilterType; typedef itk::GrayscaleMorphologicalOpeningImageFilter OpeningFilterType; typedef itk::GrayscaleMorphologicalClosingImageFilter ClosingFilterType; typedef ImageList ImageListType; typedef ImageListToVectorImageFilter ImageListToVectorImageFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(GrayScaleMorphologicalOperation, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("GrayScaleMorphologicalOperation"); SetDescription("Performs morphological operations on a grayscale input image"); // Documentation SetDocName("Grayscale Morphological Operation"); SetDocLongDescription("This application performs grayscale morphological operations on a mono band image"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("itkGrayscaleDilateImageFilter, itkGrayscaleErodeImageFilter, itkGrayscaleMorphologicalOpeningImageFilter and itkGrayscaleMorphologicalClosingImageFilter classes"); AddDocTag("MorphologicalOperations"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to be filtered."); AddParameter(ParameterType_OutputImage, "out", "Feature Output Image"); SetParameterDescription("out", "Output image containing the filtered output image."); AddParameter(ParameterType_Int, "channel", "Selected Channel"); SetParameterDescription("channel", "The selected channel index"); SetDefaultParameterInt("channel", 1); SetMinimumParameterIntValue("channel", 1); AddRAMParameter(); AddParameter(ParameterType_Choice, "structype", "Structuring Element Type"); SetParameterDescription("structype", "Choice of the structuring element type"); //Ball AddChoice("structype.ball", "Ball"); AddParameter(ParameterType_Int, "structype.ball.xradius", "The Structuring Element X Radius"); SetParameterDescription("structype.ball.xradius", "The Structuring Element X Radius"); SetDefaultParameterInt("structype.ball.xradius", 5); AddParameter(ParameterType_Int, "structype.ball.yradius", "The Structuring Element Y Radius"); SetParameterDescription("structype.ball.yradius", "The Structuring Element Y Radius"); SetDefaultParameterInt("structype.ball.yradius", 5); //Cross AddChoice("structype.cross", "Cross"); AddParameter(ParameterType_Choice, "filter", "Morphological Operation"); SetParameterDescription("filter", "Choice of the morphological operation"); //Dilate AddChoice("filter.dilate", "Dilate"); //Erode AddChoice("filter.erode", "Erode"); //Opening AddChoice("filter.opening", "Opening"); //Closing AddChoice("filter.closing", "Closing"); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("out", "opened.tif"); SetDocExampleParameterValue("channel", "1"); SetDocExampleParameterValue("structype.ball.xradius", "5"); SetDocExampleParameterValue("structype.ball.yradius", "5"); SetDocExampleParameterValue("filter", "erode"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); int nBComp = inImage->GetNumberOfComponentsPerPixel(); if( GetParameterInt("channel") > nBComp ) { itkExceptionMacro(<< "The specified channel index is invalid."); } m_ExtractorFilter = ExtractorFilterType::New(); m_ExtractorFilter->SetInput(inImage); m_ExtractorFilter->SetStartX(inImage->GetLargestPossibleRegion().GetIndex(0)); m_ExtractorFilter->SetStartY(inImage->GetLargestPossibleRegion().GetIndex(1)); m_ExtractorFilter->SetSizeX(inImage->GetLargestPossibleRegion().GetSize(0)); m_ExtractorFilter->SetSizeY(inImage->GetLargestPossibleRegion().GetSize(1)); m_ExtractorFilter->SetChannel(GetParameterInt("channel")); m_ExtractorFilter->UpdateOutputInformation(); if(GetParameterString("structype") == "ball") { BallStructuringType se; RadiusType rad; rad[0] = this->GetParameterInt("structype.ball.xradius"); rad[1] = this->GetParameterInt("structype.ball.yradius"); se.SetRadius(rad); se.CreateStructuringElement(); if(GetParameterString("filter") == "dilate") { m_DilFilter = DilateFilterType::New(); m_DilFilter->SetKernel(se); m_DilFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_DilFilter->GetOutput()); } if(GetParameterString("filter") == "erode") { m_EroFilter = ErodeFilterType::New(); m_EroFilter->SetKernel(se); m_EroFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_EroFilter->GetOutput()); } if(GetParameterString("filter") == "opening") { m_OpeFilter = OpeningFilterType::New(); m_OpeFilter->SetKernel(se); m_OpeFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_OpeFilter->GetOutput()); } if(GetParameterString("filter") == "closing") { m_CloFilter = ClosingFilterType::New(); m_CloFilter->SetKernel(se); m_CloFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_CloFilter->GetOutput()); } } if(GetParameterString("structype") == "cross") { CrossStructuringType se; se.CreateStructuringElement(); if(GetParameterString("filter") == "dilate") { m_DilFilter = DilateFilterType::New(); m_DilFilter->SetKernel(se); m_DilFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_DilFilter->GetOutput()); } if(GetParameterString("filter") == "erode") { m_EroFilter = ErodeFilterType::New(); m_EroFilter->SetKernel(se); m_EroFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_EroFilter->GetOutput()); } if(GetParameterString("filter") == "opening") { m_OpeFilter = OpeningFilterType::New(); m_OpeFilter->SetKernel(se); m_OpeFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_OpeFilter->GetOutput()); } if(GetParameterString("filter") == "closing") { m_CloFilter = ClosingFilterType::New(); m_CloFilter->SetKernel(se); m_CloFilter->SetInput(m_ExtractorFilter->GetOutput()); SetParameterOutputImage("out", m_CloFilter->GetOutput()); } } } ExtractorFilterType::Pointer m_ExtractorFilter; DilateFilterType::Pointer m_DilFilter; ErodeFilterType::Pointer m_EroFilter; OpeningFilterType::Pointer m_OpeFilter; ClosingFilterType::Pointer m_CloFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::GrayScaleMorphologicalOperation) OTB-release-5.8/Modules/Applications/AppMorphology/otb-module.cmake000066400000000000000000000003701301006202600253250ustar00rootroot00000000000000set(DOCUMENTATION "Morphomath application.") otb_module(OTBAppMorphology DEPENDS OTBImageBase OTBObjectList OTBITK OTBApplicationEngine TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppMorphology/test/000077500000000000000000000000001301006202600232335ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppMorphology/test/CMakeLists.txt000066400000000000000000000031001301006202600257650ustar00rootroot00000000000000otb_module_test() #----------- BinaryMorphologicalOperation TESTS ---------------- otb_test_application(NAME apTvFEBinaryMorphologicalOperation APP BinaryMorphologicalOperation OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN_Mask.tif -channel 1 -structype ball -structype.ball.xradius 10 -filter opening -filter.opening.foreval 1.0 -filter.opening.backval 0.0 -out ${TEMP}/apTvFEBinaryMorphologicalOperation.tif VALID --compare-image ${NOTOL} ${BASELINE}/apTvFEBinaryMorphologicalOperation.tif ${TEMP}/apTvFEBinaryMorphologicalOperation.tif) #----------- GrayScaleMorphologicalOperation TESTS ---------------- otb_test_application(NAME apTvFEGrayScaleMorphologicalOperation APP GrayScaleMorphologicalOperation OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -channel 1 -structype ball -structype.ball.xradius 10 -filter opening -out ${TEMP}/apTvFEGrayScaleMorphologicalOperation.tif VALID --compare-image ${NOTOL} ${BASELINE}/apTvFEGrayScaleMorphologicalOperation.tif ${TEMP}/apTvFEGrayScaleMorphologicalOperation.tif) OTB-release-5.8/Modules/Applications/AppOpticalCalibration/000077500000000000000000000000001301006202600236605ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppOpticalCalibration/CMakeLists.txt000066400000000000000000000000641301006202600264200ustar00rootroot00000000000000project(OTBAppOpticalCalibration) otb_module_impl() OTB-release-5.8/Modules/Applications/AppOpticalCalibration/app/000077500000000000000000000000001301006202600244405ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppOpticalCalibration/app/CMakeLists.txt000066400000000000000000000005101301006202600271740ustar00rootroot00000000000000set(OTBAppOpticalCalibration_LINK_LIBS ${OTBOpticalCalibration_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ) otb_create_application( NAME OpticalCalibration SOURCES otbOpticalCalibration.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppOpticalCalibration/app/otbOpticalCalibration.cxx000066400000000000000000001265221301006202600314440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbImageToLuminanceImageFilter.h" #include "otbLuminanceToReflectanceImageFilter.h" #include "otbLuminanceToImageImageFilter.h" #include "otbReflectanceToLuminanceImageFilter.h" #include "otbReflectanceToSurfaceReflectanceImageFilter.h" #include "itkMultiplyImageFilter.h" #include "otbClampVectorImageFilter.h" #include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h" #include "otbGroundSpacingImageFunction.h" #include "vnl/vnl_random.h" #include #include #include #include namespace otb { enum { Level_IM_TOA, Level_TOA_IM, Level_TOC }; enum { Aerosol_NoAerosol, Aerosol_Continental, Aerosol_Maritime, Aerosol_Urban, Aerosol_Desertic, }; namespace Wrapper { class OpticalCalibration : public Application { public: /** Standard class typedefs. */ typedef OpticalCalibration Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(OpticalCalibration, Application); typedef ImageToLuminanceImageFilter ImageToLuminanceImageFilterType; typedef LuminanceToReflectanceImageFilter LuminanceToReflectanceImageFilterType; typedef LuminanceToImageImageFilter LuminanceToImageImageFilterType; typedef ReflectanceToLuminanceImageFilter ReflectanceToLuminanceImageFilterType; typedef itk::MultiplyImageFilter ScaleFilterOutDoubleType; typedef otb::ClampVectorImageFilter ClampFilterType; typedef ReflectanceToSurfaceReflectanceImageFilter ReflectanceToSurfaceReflectanceImageFilterType; typedef ReflectanceToSurfaceReflectanceImageFilterType::FilterFunctionValuesType FilterFunctionValuesType; typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef otb::AtmosphericCorrectionParameters::Pointer AtmoCorrectionParametersPointerType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef otb::ImageMetadataCorrectionParameters::Pointer AcquiCorrectionParametersPointerType; typedef otb::SurfaceAdjacencyEffectCorrectionSchemeFilter SurfaceAdjacencyEffectCorrectionSchemeFilterType; typedef otb::GroundSpacingImageFunction GroundSpacingImageType; typedef DoubleVectorImageType::IndexType IndexType; typedef GroundSpacingImageType::FloatType FloatType; typedef GroundSpacingImageType::ValueType ValueType; typedef IndexType::IndexValueType IndexValueType; private: std::string m_inImageName; bool m_currentEnabledStateOfFluxParam; void DoInit() ITK_OVERRIDE { SetName("OpticalCalibration"); SetDescription("Perform optical calibration TOA/TOC (Top Of Atmosphere/Top Of Canopy). Supported sensors: QuickBird, Ikonos, WorldView2, Formosat, Spot5, Pleiades, Spot6, Spot7. For other sensors the application also allows providing calibration parameters manually."); // Documentation SetDocName("Optical calibration"); SetDocLongDescription("The application allows converting pixel values from DN (for Digital Numbers) to reflectance. Calibrated values are called surface reflectivity and its values lie in the range [0, 1].\nThe first level is called Top Of Atmosphere (TOA) reflectivity. It takes into account the sensor gain, sensor spectral response and the solar illuminations.\nThe second level is called Top Of Canopy (TOC) reflectivity. In addition to sensor gain and solar illuminations, it takes into account the optical thickness of the atmosphere, the atmospheric pressure, the water vapor amount, the ozone amount, as well as the composition and amount of aerosol gasses.\nIt is also possible to indicate an AERONET file which contains atmospheric parameters (version 1 and version 2 of Aeronet file are supported. Note that computing TOC reflectivity will internally compute first TOA and then TOC reflectance. \n" "\n--------------------------\n\n" "If the sensor is not supported by the metadata interface factory of OTB, users still have the possibility to give the needed parameters to the application.\n" "For TOA conversion, these parameters are : \n" "- day and month of acquisition, or flux normalization coefficient;\n" "- sun elevation angle;\n" "- gains and biases, one pair of values for each band (passed by a file);\n" "- solar illuminations, one value for each band (passed by a file).\n\n" "For the conversion from DN (for Digital Numbers) to spectral radiance (or 'TOA radiance') L, the following formula is used :\n\n" "(1)\tL(b) = DN(b)/gain(b)+bias(b)\t(in W/m2/steradians/micrometers)\twith b being a band ID.\n\n" "These values are provided by the user thanks to a simple txt file with two lines, one for the gains and one for the biases.\n" "Each value must be separated with colons (:), with eventual spaces. Blank lines are not allowed. If a line begins with the '#' symbol, then it is considered as comments.\n" "Note that sometimes, the values provided by certain metadata files assume the formula L(b) = gain(b)*DC(b)+bias(b).\n" "In this case, be sure to provide the inverse gain values so that the application can correctly interpret them.\n\n" "In order to convert TOA radiance to TOA reflectance, the following formula is used :\n\n" "(2)\tR(b) = (pi*L(b)*d*d) / (ESUN(b)*cos(θ))\t(no dimension)\twhere : \n\n" "- L(b) is the spectral radiance for band b \n" "- pi is the famous mathematical constant (3.14159...) \n" "- d is the earth-sun distance (in astronomical units) and depends on the acquisition's day and month \n" "- ESUN(b) is the mean TOA solar irradiance (or solar illumination) in W/m2/micrometers\n" "- θ is the solar zenith angle in degrees.\n\n" "Note that the application asks for the solar elevation angle, and will perform the conversion to the zenith angle itself (zenith_angle = 90 - elevation_angle , units : degrees).\n" "Note also that ESUN(b) not only depends on the band b, but also on the spectral sensitivity of the sensor in this particular band. " "In other words, the influence of spectral sensitivities is included within the ESUN different values.\n" "These values are provided by the user thanks to a txt file following the same convention as before.\n" "Instead of providing the date of acquisition, the user can also provide a flux normalization coefficient 'fn'. " "The formula used instead will be the following : \n\n" "(3) \tR(b) = (pi*L(b)) / (ESUN(b)*fn*fn*cos(θ)) \n\n" "Whatever the formula used (2 or 3), the user should pay attention to the interpretation of the parameters he will provide to the application, " "by taking into account the original formula that the metadata files assumes.\n\n" "Below, we give two examples of txt files containing information about gains/biases and solar illuminations :\n\n" "- gainbias.txt :\n\n" "# Gain values for each band. Each value must be separated with colons (:), with eventual spaces. Blank lines not allowed.\n" "10.4416 : 9.529 : 8.5175 : 14.0063\n" "# Bias values for each band.\n" "0.0 : 0.0 : 0.0 : 0.0\n\n" "- solarillumination.txt : \n\n" "# Solar illumination values in watt/m2/micron ('micron' means actually 'for each band').\n" "# Each value must be separated with colons (:), with eventual spaces. Blank lines not allowed.\n" "1540.494123 : 1826.087443 : 1982.671954 : 1094.747446\n\n" "Finally, the 'Logs' tab provides useful messages that can help the user in knowing the process different status." ); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("The OTB CookBook"); AddDocTag(Tags::Calibration); AddParameter(ParameterType_InputImage, "in", "Input"); SetParameterDescription("in", "Input image filename (values in DN)"); AddParameter(ParameterType_OutputImage, "out", "Output"); SetParameterDescription("out","Output calibrated image filename"); AddRAMParameter(); AddParameter(ParameterType_Choice, "level", "Calibration Level"); AddChoice("level.toa", "Image to Top Of Atmosphere reflectance"); AddChoice("level.toatoim", "TOA reflectance to Image"); AddChoice("level.toc", "Image to Top Of Canopy reflectance (atmospheric corrections)"); SetParameterString("level", "toa"); AddParameter(ParameterType_Empty, "milli", "Convert to milli reflectance"); SetParameterDescription("milli", "Flag to use milli-reflectance instead of reflectance.\n" "This allows saving the image with integer pixel type (in the range [0, 1000] instead of floating point in the range [0, 1]. In order to do that, use this option and set the output pixel type (-out filename double for example)"); DisableParameter("milli"); MandatoryOff("milli"); AddParameter(ParameterType_Empty, "clamp", "Clamp of reflectivity values between [0, 100]"); SetParameterDescription("clamp", "Clamping in the range [0, 100]. It can be useful to preserve area with specular reflectance."); EnableParameter("clamp"); MandatoryOff("clamp"); //Acquisition parameters AddParameter(ParameterType_Group,"acqui","Acquisition parameters"); SetParameterDescription("acqui","This group allows setting the parameters related to the acquisition conditions."); //Minute AddParameter(ParameterType_Int, "acqui.minute", "Minute"); SetParameterDescription("acqui.minute", "Minute (0-59)"); SetMinimumParameterIntValue("acqui.minute", 0); SetMaximumParameterIntValue("acqui.minute", 59); SetDefaultParameterInt("acqui.minute", 0); //Hour AddParameter(ParameterType_Int, "acqui.hour", "Hour"); SetParameterDescription("acqui.hour", "Hour (0-23)"); SetMinimumParameterIntValue("acqui.hour", 0); SetMaximumParameterIntValue("acqui.hour", 23); SetDefaultParameterInt("acqui.hour", 12); //Day AddParameter(ParameterType_Int, "acqui.day", "Day"); SetParameterDescription("acqui.day", "Day (1-31)"); SetMinimumParameterIntValue("acqui.day", 1); SetMaximumParameterIntValue("acqui.day", 31); SetDefaultParameterInt("acqui.day", 1); //Month AddParameter(ParameterType_Int, "acqui.month", "Month"); SetParameterDescription("acqui.month", "Month (1-12)"); SetMinimumParameterIntValue("acqui.month", 1); SetMaximumParameterIntValue("acqui.month", 12); SetDefaultParameterInt("acqui.month", 1); //Year AddParameter(ParameterType_Int, "acqui.year", "Year"); SetParameterDescription("acqui.year", "Year"); SetDefaultParameterInt("acqui.year", 2000); //Flux normalization coefficient AddParameter(ParameterType_Float, "acqui.fluxnormcoeff", "Flux Normalization"); SetParameterDescription("acqui.fluxnormcoeff", "Flux Normalization Coefficient"); SetMinimumParameterFloatValue("acqui.fluxnormcoeff", 0.); MandatoryOff("acqui.fluxnormcoeff"); AddParameter(ParameterType_Group,"acqui.sun","Sun angles"); SetParameterDescription("acqui.sun","This group contains the sun angles"); //Sun elevation angle AddParameter(ParameterType_Float, "acqui.sun.elev", "Sun elevation angle (deg)"); SetParameterDescription("acqui.sun.elev", "Sun elevation angle (in degrees)"); SetMinimumParameterFloatValue("acqui.sun.elev", 0.); SetMaximumParameterFloatValue("acqui.sun.elev", 120.); SetDefaultParameterFloat("acqui.sun.elev",90.0); //Sun azimuth angle AddParameter(ParameterType_Float, "acqui.sun.azim", "Sun azimuth angle (deg)"); SetParameterDescription("acqui.sun.azim", "Sun azimuth angle (in degrees)"); SetMinimumParameterFloatValue("acqui.sun.azim", 0.); SetMaximumParameterFloatValue("acqui.sun.azim", 360.); SetDefaultParameterFloat("acqui.sun.azim",0.0); AddParameter(ParameterType_Group,"acqui.view","Viewing angles"); SetParameterDescription("acqui.view","This group contains the sensor viewing angles"); //Viewing elevation angle AddParameter(ParameterType_Float, "acqui.view.elev", "Viewing elevation angle (deg)"); SetParameterDescription("acqui.view.elev", "Viewing elevation angle (in degrees)"); SetMinimumParameterFloatValue("acqui.view.elev", 0.); SetMaximumParameterFloatValue("acqui.view.elev", 120.); SetDefaultParameterFloat("acqui.view.elev",90.0); //Viewing azimuth angle AddParameter(ParameterType_Float, "acqui.view.azim", "Viewing azimuth angle (deg)"); SetParameterDescription("acqui.view.azim", "Viewing azimuth angle (in degrees)"); SetMinimumParameterFloatValue("acqui.view.azim", 0.); SetMaximumParameterFloatValue("acqui.view.azim", 360.); SetDefaultParameterFloat("acqui.view.azim",0.0); //Gain & bias AddParameter(ParameterType_InputFilename, "acqui.gainbias", "Gains | biases"); SetParameterDescription("acqui.gainbias", "Gains | biases"); MandatoryOff("acqui.gainbias"); //Solar illuminations AddParameter(ParameterType_InputFilename, "acqui.solarilluminations", "Solar illuminations"); SetParameterDescription("acqui.solarilluminations", "Solar illuminations (one value per band)"); MandatoryOff("acqui.solarilluminations"); //Atmospheric parameters (TOC) AddParameter(ParameterType_Group,"atmo","Atmospheric parameters (for TOC)"); SetParameterDescription("atmo","This group allows setting the atmospheric parameters."); AddParameter(ParameterType_Choice, "atmo.aerosol", "Aerosol Model"); AddChoice("atmo.aerosol.noaersol", "No Aerosol Model"); AddChoice("atmo.aerosol.continental", "Continental"); AddChoice("atmo.aerosol.maritime", "Maritime"); AddChoice("atmo.aerosol.urban", "Urban"); AddChoice("atmo.aerosol.desertic", "Desertic"); AddParameter(ParameterType_Float, "atmo.oz", "Ozone Amount"); SetParameterDescription("atmo.oz", "Ozone Amount"); AddParameter(ParameterType_Float, "atmo.wa", "Water Vapor Amount"); SetParameterDescription("atmo.wa", "Water Vapor Amount (in saturation fraction of water)"); AddParameter(ParameterType_Float, "atmo.pressure", "Atmospheric Pressure"); SetParameterDescription("atmo.pressure", "Atmospheric Pressure (in hPa)"); AddParameter(ParameterType_Float, "atmo.opt", "Aerosol Optical Thickness"); SetParameterDescription("atmo.opt", "Aerosol Optical Thickness"); SetDefaultParameterFloat("atmo.oz", 0.); SetDefaultParameterFloat("atmo.wa", 2.5); SetDefaultParameterFloat("atmo.pressure", 1030.); SetDefaultParameterFloat("atmo.opt", 0.2); MandatoryOff("atmo.oz"); MandatoryOff("atmo.wa"); MandatoryOff("atmo.pressure"); MandatoryOff("atmo.opt"); AddParameter(ParameterType_InputFilename, "atmo.aeronet", "Aeronet File"); SetParameterDescription("atmo.aeronet","Aeronet file containing atmospheric parameters"); MandatoryOff("atmo.aeronet"); AddParameter(ParameterType_InputFilename, "atmo.rsr", "Relative Spectral Response File"); std::ostringstream oss; oss << "Sensor relative spectral response file"<GetMetaDataDictionary(); OpticalImageMetadataInterface::Pointer lImageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI(dict); std::string IMIName( lImageMetadataInterface->GetNameOfClass() ) , IMIOptDfltName("OpticalDefaultImageMetadataInterface"); if ( (IMIName != IMIOptDfltName)) { ossOutput << "Sensor detected: " << lImageMetadataInterface->GetSensorID() << std::endl; itk::VariableLengthVector vlvector; std::stringstream ss; ossOutput << "Parameters extract from input image: "<< std::endl << "\tAcquisition Day: " << lImageMetadataInterface->GetDay() << std::endl << "\tAcquisition Month: " << lImageMetadataInterface->GetMonth() << std::endl << "\tAcquisition Year: " << lImageMetadataInterface->GetYear() << std::endl << "\tAcquisition Sun Elevation Angle: " << lImageMetadataInterface->GetSunElevation() << std::endl << "\tAcquisition Sun Azimuth Angle: " << lImageMetadataInterface->GetSunAzimuth() << std::endl << "\tAcquisition Viewing Elevation Angle: " << lImageMetadataInterface->GetSatElevation() << std::endl << "\tAcquisition Viewing Azimuth Angle: " << lImageMetadataInterface->GetSatAzimuth() << std::endl; vlvector = lImageMetadataInterface->GetPhysicalGain(); ossOutput << "\tAcquisition gain (per band): "; for(unsigned int k=0; kGetPhysicalBias(); ossOutput << "\tAcquisition bias (per band): "; for(unsigned int k=0; kGetSolarIrradiance(); ossOutput << "\tSolar Irradiance (per band): "; for(unsigned int k=0; kGetMinute()); } if (HasUserValue("acqui.hour")) ossOutput << "Acquisition Hour already set by user: no overload" <GetHour()); } if (HasUserValue("acqui.day")) ossOutput << "Acquisition Day already set by user: no overload" <GetDay()); if (IsParameterEnabled("acqui.fluxnormcoeff")) DisableParameter("acqui.day"); } if (HasUserValue("acqui.month")) ossOutput << "Acquisition Month already set by user: no overload" <GetMonth()); if (IsParameterEnabled("acqui.fluxnormcoeff")) DisableParameter("acqui.month"); } if (HasUserValue("acqui.year")) ossOutput << "Acquisition Year already set by user: no overload" <GetYear()); } if (HasUserValue("acqui.sun.elev")) ossOutput << "Acquisition Sun Elevation Angle already set by user: no overload" <GetSunElevation()); if (HasUserValue("acqui.sun.azim")) ossOutput << "Acquisition Sun Azimuth Angle already set by user: no overload" <GetSunAzimuth()); if (HasUserValue("acqui.view.elev")) ossOutput << "Acquisition Viewing Elevation Angle already set by user: no overload" <GetSatElevation()); if (HasUserValue("acqui.view.azim")) ossOutput << "Acquisition Viewing Azimuth Angle already set by user: no overload" <GetSatAzimuth()); // Set default value so that they are stored somewhere even if // they are overloaded by user values SetDefaultParameterInt("acqui.minute", lImageMetadataInterface->GetMinute()); SetDefaultParameterInt("acqui.hour", lImageMetadataInterface->GetHour()); SetDefaultParameterInt("acqui.day", lImageMetadataInterface->GetDay()); SetDefaultParameterInt("acqui.month", lImageMetadataInterface->GetMonth()); SetDefaultParameterInt("acqui.year", lImageMetadataInterface->GetYear()); SetDefaultParameterFloat("acqui.sun.elev", lImageMetadataInterface->GetSunElevation()); SetDefaultParameterFloat("acqui.sun.azim", lImageMetadataInterface->GetSunAzimuth()); SetDefaultParameterFloat("acqui.view.elev", lImageMetadataInterface->GetSatElevation()); SetDefaultParameterFloat("acqui.view.azim", lImageMetadataInterface->GetSatAzimuth()); } else { // Switch gain , bias and solar illumination to mandatory since // they are not given in the image loaded EnableParameter("acqui.gainbias"); EnableParameter("acqui.solarilluminations"); MandatoryOn("acqui.gainbias"); MandatoryOn("acqui.solarilluminations"); ossOutput << "Sensor unknown!"<< std::endl; ossOutput << "Additional parameters are necessary, please provide them (cf. documentation)!"<< std::endl; /*GetLogger()->Info("\n-------------------------------------------------------------\n" "Sensor ID : unknown...\n" "The application didn't manage to find an appropriate metadata interface; " "custom values must be provided in order to perform TOA conversion.\nPlease, set the following fields :\n" "- day and month of acquisition, or flux normalization coefficient;\n" "- sun elevation angle;\n" "- gains and biases for each band (passed by a file, see documentation);\n" "- solar illuminationss for each band (passed by a file, see documentation).\n" "-------------------------------------------------------------\n"); */ } //Estimate ground spacing in kilometers GroundSpacingImageType::Pointer groundSpacing = GroundSpacingImageType::New(); groundSpacing->SetInputImage(inImage); IndexType index; vnl_random rand; index[0] = static_cast(rand.lrand32(0, inImage->GetLargestPossibleRegion().GetSize()[0])); index[1] = static_cast(rand.lrand32(0, inImage->GetLargestPossibleRegion().GetSize()[1])); FloatType tmpSpacing = groundSpacing->EvaluateAtIndex(index); const float spacingInKilometers = (std::max(tmpSpacing[0], tmpSpacing[1])) / 1000.; SetDefaultParameterFloat("atmo.pixsize",spacingInKilometers); if (!HasUserValue("atmo.pixsize")) SetParameterFloat("atmo.pixsize",spacingInKilometers); } } // Manage the case where fluxnormcoeff is modified by user if (m_currentEnabledStateOfFluxParam != IsParameterEnabled("acqui.fluxnormcoeff")) { if (IsParameterEnabled("acqui.fluxnormcoeff")) { ossOutput << std::endl << "Flux Normalization Coefficient will be used" << std::endl; DisableParameter("acqui.day"); DisableParameter("acqui.month"); MandatoryOff("acqui.day"); MandatoryOff("acqui.month"); MandatoryOn("acqui.fluxnormcoeff"); m_currentEnabledStateOfFluxParam = true; } else { ossOutput << std::endl << "Day and Month will be used" << std::endl; EnableParameter("acqui.day"); EnableParameter("acqui.month"); MandatoryOn("acqui.day"); MandatoryOn("acqui.month"); MandatoryOff("acqui.fluxnormcoeff"); m_currentEnabledStateOfFluxParam = false; } } if (!ossOutput.str().empty()) otbAppLogINFO(<< ossOutput.str()); } void DoExecute() ITK_OVERRIDE { //Main filters instantiations m_ImageToLuminanceFilter = ImageToLuminanceImageFilterType::New(); m_LuminanceToReflectanceFilter = LuminanceToReflectanceImageFilterType::New(); m_ReflectanceToSurfaceReflectanceFilter = ReflectanceToSurfaceReflectanceImageFilterType::New(); m_ReflectanceToLuminanceFilter = ReflectanceToLuminanceImageFilterType::New(); m_LuminanceToImageFilter = LuminanceToImageImageFilterType::New(); //Other instantiations m_ScaleFilter = ScaleFilterOutDoubleType::New(); //m_ScaleFilter->InPlaceOn(); m_ClampFilter = ClampFilterType::New(); m_paramAcqui = AcquiCorrectionParametersType::New(); m_paramAtmo = AtmoCorrectionParametersType::New(); FloatVectorImageType::Pointer inImage = GetParameterFloatVectorImage("in"); // Prepare a metadata interface on the input image. itk::MetaDataDictionary dict = inImage->GetMetaDataDictionary(); OpticalImageMetadataInterface::Pointer lImageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI(dict); std::string IMIName( lImageMetadataInterface->GetNameOfClass() ); std::string IMIOptDfltName("OpticalDefaultImageMetadataInterface"); // Set (Date and Day) OR FluxNormalizationCoef to corresponding filters if ( !IsParameterEnabled("acqui.fluxnormcoeff") ) { m_LuminanceToReflectanceFilter->SetDay(GetParameterInt("acqui.day")); m_LuminanceToReflectanceFilter->SetMonth(GetParameterInt("acqui.month")); m_ReflectanceToLuminanceFilter->SetDay(GetParameterInt("acqui.day")); m_ReflectanceToLuminanceFilter->SetMonth(GetParameterInt("acqui.month")); } else { m_LuminanceToReflectanceFilter->SetFluxNormalizationCoefficient(GetParameterFloat("acqui.fluxnormcoeff")); m_ReflectanceToLuminanceFilter->SetFluxNormalizationCoefficient(GetParameterFloat("acqui.fluxnormcoeff")); } // Set Sun Elevation Angle to corresponding filters m_LuminanceToReflectanceFilter->SetElevationSolarAngle(GetParameterFloat("acqui.sun.elev")); m_ReflectanceToLuminanceFilter->SetElevationSolarAngle(GetParameterFloat("acqui.sun.elev")); // Set Gain and Bias to corresponding filters if (IsParameterEnabled("acqui.gainbias") && HasValue("acqui.gainbias")) { // Try to retrieve information from file provided by user std::string filename(GetParameterString("acqui.gainbias")); std::ifstream file(filename.c_str(), std::ios::in); if(file) { std::string line; unsigned int numLine = 0; while (getline(file, line)) { // clean line std::string::size_type startPos = line.find_first_not_of(std::string(" \t\n\r")); if (startPos == std::string::npos) continue; line = line.substr(startPos); if (line[0]!='#') { numLine++; std::vector values; std::istringstream iss(line); std::string value; double dvalue; while ( getline( iss, value, ':' ) ) { std::istringstream iss2(value); iss2 >> dvalue; values.push_back(dvalue); } itk::VariableLengthVector vlvector; vlvector.SetData(values.data(),values.size(),false); switch (numLine) { case 1 : m_ImageToLuminanceFilter->SetAlpha(vlvector); m_LuminanceToImageFilter->SetAlpha(vlvector); GetLogger()->Info("Trying to get gains/biases information... OK (1/2)\n"); break; case 2 : m_ImageToLuminanceFilter->SetBeta(vlvector); m_LuminanceToImageFilter->SetBeta(vlvector); GetLogger()->Info("Trying to get gains/biases information... OK (2/2)\n"); break; default : itkExceptionMacro(<< "File : " << filename << " contains wrong number of lines (needs two, one for gains and one for biases)"); } } } file.close(); } else itkExceptionMacro(<< "File : " << filename << " couldn't be opened"); } else { //Try to retrieve information from image metadata if (IMIName != IMIOptDfltName) { m_ImageToLuminanceFilter->SetAlpha(lImageMetadataInterface->GetPhysicalGain()); m_LuminanceToImageFilter->SetAlpha(lImageMetadataInterface->GetPhysicalGain()); m_ImageToLuminanceFilter->SetBeta(lImageMetadataInterface->GetPhysicalBias()); m_LuminanceToImageFilter->SetBeta(lImageMetadataInterface->GetPhysicalBias()); } else itkExceptionMacro(<< "Please, provide a type of sensor supported by OTB for automatic metadata extraction! "); } // Set Solar Illumination to corresponding filters if (IsParameterEnabled("acqui.solarilluminations") && HasValue("acqui.solarilluminations")) { // Try to retrieve information from file provided by user std::string filename(GetParameterString("acqui.solarilluminations")); std::ifstream file(filename.c_str(), std::ios::in); if(file) { std::string line; while (getline(file, line)) { // clean line std::string::size_type startPos = line.find_first_not_of(std::string(" \t\n\r")); if (startPos == std::string::npos) continue; line = line.substr(startPos); if (line[0]!='#') { std::vector values; std::istringstream iss(line); std::string value; double dvalue; while ( getline( iss, value, ':' ) ) { std::istringstream iss2(value); iss2 >> dvalue; values.push_back(dvalue); } itk::VariableLengthVector vlvector; vlvector.SetData(values.data(),values.size(),false); m_LuminanceToReflectanceFilter->SetSolarIllumination(vlvector); m_ReflectanceToLuminanceFilter->SetSolarIllumination(vlvector); } } file.close(); } else itkExceptionMacro(<< "File : " << filename << " couldn't be opened"); } else { //Try to retrieve information from image metadata if (IMIName != IMIOptDfltName) { m_LuminanceToReflectanceFilter->SetSolarIllumination(lImageMetadataInterface->GetSolarIrradiance()); m_ReflectanceToLuminanceFilter->SetSolarIllumination(lImageMetadataInterface->GetSolarIrradiance()); } else itkExceptionMacro(<< "Please, provide a type of sensor supported by OTB for automatic metadata extraction! "); } // Set acquisition parameters m_paramAcqui->SetYear(GetParameterInt("acqui.year")); m_paramAcqui->SetMonth(GetParameterInt("acqui.month")); m_paramAcqui->SetDay(GetParameterInt("acqui.day")); m_paramAcqui->SetSolarZenithalAngle(90.0 - GetParameterFloat("acqui.sun.elev")); m_paramAcqui->SetSolarAzimutalAngle(GetParameterFloat("acqui.sun.azim")); m_paramAcqui->SetViewingZenithalAngle(90.0 - GetParameterFloat("acqui.view.elev")); m_paramAcqui->SetViewingAzimutalAngle(GetParameterFloat("acqui.view.azim")); switch ( GetParameterInt("level") ) { case Level_IM_TOA: { GetLogger()->Info("Compute Top of Atmosphere reflectance\n"); //Pipeline m_ImageToLuminanceFilter->SetInput(inImage); m_LuminanceToReflectanceFilter->SetInput(m_ImageToLuminanceFilter->GetOutput()); if (IsParameterEnabled("clamp")) { GetLogger()->Info("Clamp values between [0, 100]\n"); } m_LuminanceToReflectanceFilter->SetUseClamp(IsParameterEnabled("clamp")); m_LuminanceToReflectanceFilter->UpdateOutputInformation(); m_ScaleFilter->SetInput(m_LuminanceToReflectanceFilter->GetOutput()); } break; case Level_TOA_IM: { GetLogger()->Info("Convert Top of Atmosphere reflectance to image DN\n"); //Pipeline m_ReflectanceToLuminanceFilter->SetInput(inImage); m_LuminanceToImageFilter->SetInput(m_ReflectanceToLuminanceFilter->GetOutput()); m_LuminanceToImageFilter->UpdateOutputInformation(); m_ScaleFilter->SetInput(m_LuminanceToImageFilter->GetOutput()); } break; case Level_TOC: { GetLogger()->Info("Compute Top of Canopy reflectance\n"); //Pipeline m_ImageToLuminanceFilter->SetInput(inImage); m_LuminanceToReflectanceFilter->SetInput(m_ImageToLuminanceFilter->GetOutput()); m_ReflectanceToSurfaceReflectanceFilter->SetInput(m_LuminanceToReflectanceFilter->GetOutput()); m_ReflectanceToSurfaceReflectanceFilter->SetAcquiCorrectionParameters(m_paramAcqui); m_ReflectanceToSurfaceReflectanceFilter->SetAtmoCorrectionParameters(m_paramAtmo); //AerosolModelType aeroMod = AtmosphericCorrectionParametersType::NO_AEROSOL; switch ( GetParameterInt("atmo.aerosol") ) { case Aerosol_Desertic: { // Aerosol_Desertic correspond to 4 in the enum but actually in // the class atmosphericParam it is known as parameter 5 m_paramAtmo->SetAerosolModel(static_cast(5)); } break; default: { m_paramAtmo->SetAerosolModel(static_cast(GetParameterInt("atmo.aerosol"))); } break; } // Set the atmospheric param m_paramAtmo->SetOzoneAmount(GetParameterFloat("atmo.oz")); m_paramAtmo->SetWaterVaporAmount(GetParameterFloat("atmo.wa")); m_paramAtmo->SetAtmosphericPressure(GetParameterFloat("atmo.pressure")); m_paramAtmo->SetAerosolOptical(GetParameterFloat("atmo.opt")); // Relative Spectral Response File if (IsParameterEnabled("atmo.rsr")) { if ( !(GetParameterString("atmo.rsr") == "") ) m_paramAcqui->LoadFilterFunctionValue(GetParameterString("atmo.rsr")); else otbAppLogFATAL("Please, set a sensor relative spectral response file."); } else if (IMIName != IMIOptDfltName) { //Avoid to call GetSpectralSensitivity() multiple times OpticalImageMetadataInterface::WavelengthSpectralBandVectorType spectralSensitivity = lImageMetadataInterface->GetSpectralSensitivity(); if (spectralSensitivity->Size() > 0) m_paramAcqui->SetWavelengthSpectralBand(spectralSensitivity); } // Check that m_paramAcqui contains a real spectral profile. if (m_paramAcqui->GetWavelengthSpectralBand()->Size() == 0) { otbAppLogWARNING("No relative spectral response found, using " "default response (constant between 0.3 and 1.0µm)"); AcquiCorrectionParametersType::WavelengthSpectralBandVectorType spectralDummy; spectralDummy->Clear(); for (unsigned int i = 0; i < inImage->GetNumberOfComponentsPerPixel(); ++i) { spectralDummy->PushBack(FilterFunctionValues::New()); } } // Aeronet file if (IsParameterEnabled("atmo.aeronet")) { GetLogger()->Info("Use Aeronet file to retrieve atmospheric parameters\n"); m_paramAtmo->SetAeronetFileName(GetParameterString("atmo.aeronet")); m_paramAtmo->UpdateAeronetData(GetParameterInt("acqui.year"), GetParameterInt("acqui.month"), GetParameterInt("acqui.day"), GetParameterInt("acqui.hour"), GetParameterInt("acqui.minute"), 0.4); } m_ReflectanceToSurfaceReflectanceFilter->UpdateOutputInformation(); m_ReflectanceToSurfaceReflectanceFilter->SetIsSetAtmosphericRadiativeTerms(false); m_ReflectanceToSurfaceReflectanceFilter->SetUseGenerateParameters(true); m_ReflectanceToSurfaceReflectanceFilter->GenerateParameters(); m_ReflectanceToSurfaceReflectanceFilter->SetUseGenerateParameters(false); // std::ostringstream oss_atmo; // oss_atmo << "Atmospheric parameters: " << std::endl; // oss_atmo << m_AtmosphericParam; // GetLogger()->Info(oss_atmo.str()); std::ostringstream oss; oss.str(""); oss << std::endl << m_paramAtmo; AtmosphericRadiativeTerms::Pointer atmoTerms = m_ReflectanceToSurfaceReflectanceFilter->GetAtmosphericRadiativeTerms(); oss << std::endl << std::endl << atmoTerms << std::endl; GetLogger()->Info("Atmospheric correction parameters compute by 6S : " + oss.str()); bool adjComputation=false; if (IsParameterEnabled("atmo.radius")) { GetLogger()->Info("Compute adjacency effects\n"); adjComputation=true; //Compute adjacency effect m_SurfaceAdjacencyEffectCorrectionSchemeFilter = SurfaceAdjacencyEffectCorrectionSchemeFilterType::New(); m_SurfaceAdjacencyEffectCorrectionSchemeFilter->SetInput(m_ReflectanceToSurfaceReflectanceFilter->GetOutput()); m_SurfaceAdjacencyEffectCorrectionSchemeFilter-> SetAtmosphericRadiativeTerms( m_ReflectanceToSurfaceReflectanceFilter->GetAtmosphericRadiativeTerms()); m_SurfaceAdjacencyEffectCorrectionSchemeFilter->SetZenithalViewingAngle( m_paramAcqui->GetViewingZenithalAngle()); m_SurfaceAdjacencyEffectCorrectionSchemeFilter->SetWindowRadius(GetParameterInt("atmo.radius")); m_SurfaceAdjacencyEffectCorrectionSchemeFilter-> SetPixelSpacingInKilometers(GetParameterFloat("atmo.pixsize")); m_SurfaceAdjacencyEffectCorrectionSchemeFilter->UpdateOutputInformation(); } //Rescale the surface reflectance in milli-reflectance if (!IsParameterEnabled("clamp")) { if (!adjComputation) m_ScaleFilter->SetInput(m_ReflectanceToSurfaceReflectanceFilter->GetOutput()); else m_ScaleFilter->SetInput(m_SurfaceAdjacencyEffectCorrectionSchemeFilter->GetOutput()); } else { GetLogger()->Info("Clamp values between [0, 100]\n"); if (!adjComputation) m_ClampFilter->SetInput(m_ReflectanceToSurfaceReflectanceFilter->GetOutput()); else m_ClampFilter->SetInput(m_SurfaceAdjacencyEffectCorrectionSchemeFilter->GetOutput()); m_ClampFilter->ClampOutside(0.0, 1.0); m_ScaleFilter->SetInput(m_ClampFilter->GetOutput()); } } break; } // Output Image double scale = 1.; if (IsParameterEnabled("milli")) { GetLogger()->Info("Use milli-reflectance\n"); if ( (GetParameterInt("level") == Level_IM_TOA) || (GetParameterInt("level") == Level_TOC) ) scale =1000.; if (GetParameterInt("level") == Level_TOA_IM) scale=1. / 1000.; } m_ScaleFilter->SetConstant(scale); SetParameterOutputImage("out", m_ScaleFilter->GetOutput()); } //Keep object references as a members of the class, else the pipeline will be broken after exiting DoExecute(). ImageToLuminanceImageFilterType ::Pointer m_ImageToLuminanceFilter; LuminanceToReflectanceImageFilterType::Pointer m_LuminanceToReflectanceFilter; ReflectanceToLuminanceImageFilterType::Pointer m_ReflectanceToLuminanceFilter; LuminanceToImageImageFilterType::Pointer m_LuminanceToImageFilter; ReflectanceToSurfaceReflectanceImageFilterType::Pointer m_ReflectanceToSurfaceReflectanceFilter; ScaleFilterOutDoubleType::Pointer m_ScaleFilter; AtmoCorrectionParametersPointerType m_paramAtmo; AcquiCorrectionParametersPointerType m_paramAcqui; ClampFilterType::Pointer m_ClampFilter; SurfaceAdjacencyEffectCorrectionSchemeFilterType::Pointer m_SurfaceAdjacencyEffectCorrectionSchemeFilter; }; }// namespace Wrapper } // namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::OpticalCalibration) OTB-release-5.8/Modules/Applications/AppOpticalCalibration/otb-module.cmake000066400000000000000000000004531301006202600267330ustar00rootroot00000000000000set(DOCUMENTATION "Optical calibration application.") otb_module(OTBAppOpticalCalibration DEPENDS OTBOpticalCalibration OTBImageManipulation OTBITK OTBApplicationEngine OTBProjection TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppOpticalCalibration/test/000077500000000000000000000000001301006202600246375ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppOpticalCalibration/test/CMakeLists.txt000066400000000000000000000135241301006202600274040ustar00rootroot00000000000000otb_module_test() #----------- OpticalCalibration TESTS ---------------- otb_test_application(NAME apTvRaOpticalCalibration_QuickbirdXS APP OpticalCalibration OPTIONS -in ${INPUTDATA}/QB_MUL_ROI_1000_100.tif -level toa -clamp false -out ${TEMP}/apTvRaOpticalCalibration_QuickbirdXS.tif VALID --compare-image ${EPSILON_7} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdXS.tif ${TEMP}/apTvRaOpticalCalibration_QuickbirdXS.tif ) otb_test_application(NAME apTvRaOpticalCalibration_WV2PAN APP OpticalCalibration OPTIONS -in ${INPUTDATA}/WV2_PAN_ROI_1000_100.tif -level toa -out ${TEMP}/apTvRaOpticalCalibration_WV2PAN.tif VALID --compare-image ${EPSILON_7} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoWV2PAN.tif ${TEMP}/apTvRaOpticalCalibration_WV2PAN.tif ) otb_test_application(NAME apTvRaOpticalCalibration_WV2Multi APP OpticalCalibration OPTIONS -in ${INPUTDATA}/WV2_MUL_ROI_1000_100.tif -level toa -out ${TEMP}/apTvRaOpticalCalibration_WV2Multi.tif VALID --compare-image ${EPSILON_7} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoWV2Multi.tif ${TEMP}/apTvRaOpticalCalibration_WV2Multi.tif ) otb_test_application(NAME apTvRaOpticalCalibration_Formosat APP OpticalCalibration OPTIONS -in ${INPUTDATA}/FORMOSAT_ROI_1000_100.tif -level toa -out ${TEMP}/apTvRaOpticalCalibration_Formosat.img VALID --compare-image ${EPSILON_7} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoFormosat.tif ${TEMP}/apTvRaOpticalCalibration_Formosat.img ) otb_test_application(NAME apTvRaOpticalCalibration_QuickbirdPAN APP OpticalCalibration OPTIONS -in ${INPUTDATA}/QB_PAN_ROI_1000_100.tif -level toa -out ${TEMP}/apTvRaOpticalCalibration_QuickbirdPAN.tif VALID --compare-image ${EPSILON_7} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdPAN.tif ${TEMP}/apTvRaOpticalCalibration_QuickbirdPAN.tif ) otb_test_application(NAME apTvRaOpticalCalibration_Spot5 APP OpticalCalibration OPTIONS -in ${INPUTDATA}/SPOT5_ROI_1000_100.tif -level toa -out ${TEMP}/apTvRaOpticalCalibration_Spot5.img VALID --compare-image ${EPSILON_7} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoSpot5.tif ${TEMP}/apTvRaOpticalCalibration_Spot5.img ) otb_test_application(NAME apTvRaOpticalCalibration_UnknownSensor APP OpticalCalibration OPTIONS -in ${EXAMPLEDATA}/Romania_Extract.tif -out ${TEMP}/apTvRaOpticalCalibration_Spot4_UnknownSensor_test.tif -level toc -acqui.gainbias ${INPUTDATA}/apTvRaOpticalCalibrationUnknownSensorGainsBiases2.txt -acqui.day 4 -acqui.month 12 -acqui.sun.elev 62.7 -acqui.sun.azim 152.7 -acqui.view.elev 87.5 -acqui.view.azim -77.0 -acqui.solarilluminations ${INPUTDATA}/apTvRaOpticalCalibrationUnknownSensorSolarIllumations2.txt -atmo.rsr ${INPUTDATA}/apTvRaOpticalCalibrationUnknownSensorRSR.txt -atmo.pressure 1013.0 -atmo.wa 2.48134 -atmo.oz 0.34400 -atmo.aerosol continental -atmo.opt 0.199854 -atmo.radius 2 -atmo.pixsize 0.02 -milli false -clamp false VALID --compare-image ${EPSILON_6} ${OTB_DATA_ROOT}/Baseline/Examples/Radiometry/Example_RomaniaAtmosphericCorrectionSequencement.tif ${TEMP}/apTvRaOpticalCalibration_Spot4_UnknownSensor_test.tif ) otb_test_application(NAME apTvRaOpticalCalibration_Reverse_UnknownSensor APP OpticalCalibration OPTIONS -in ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdXS.tif -out ${TEMP}/apTvRaOpticalCalibration_Rev_QB-XS_UnknownSensor_test.tif -level toatoim -acqui.gainbias ${INPUTDATA}/apTvRaOpticalCalibrationUnknownSensorGainsBiases.txt -acqui.day 1 -acqui.month 4 -acqui.sun.elev 48.6 -acqui.solarilluminations ${INPUTDATA}/apTvRaOpticalCalibrationUnknownSensorSolarIllumations.txt -milli false -clamp false VALID --compare-image ${EPSILON_6} ${INPUTDATA}/QB_MUL_ROI_1000_100.tif ${TEMP}/apTvRaOpticalCalibration_Rev_QB-XS_UnknownSensor_test.tif ) otb_test_application(NAME apTvRaOpticalCalibration_Ikonos APP OpticalCalibration OPTIONS -in ${INPUTDATA}/IKONOS_BLOSSEVILLE_ROI_1000_100.tif -level toa -out ${TEMP}/apTvRaOpticalCalibration_Ikonos.tif VALID --compare-image ${EPSILON_7} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoIkonos.tif ${TEMP}/apTvRaOpticalCalibration_Ikonos.tif ) OTB-release-5.8/Modules/Applications/AppProjection/000077500000000000000000000000001301006202600222315ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppProjection/CMakeLists.txt000066400000000000000000000000541301006202600247700ustar00rootroot00000000000000project(OTBAppProjection) otb_module_impl() OTB-release-5.8/Modules/Applications/AppProjection/app/000077500000000000000000000000001301006202600230115ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppProjection/app/CMakeLists.txt000066400000000000000000000040231301006202600255500ustar00rootroot00000000000000set(OTBAppProjection_LINK_LIBS ${OTBGdalAdapters_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBCarto_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBMathParser_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBGDAL_LIBRARIES} ${OTBInterpolation_LIBRARIES} ) otb_create_application( NAME OrthoRectification SOURCES otbOrthoRectification.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ConvertCartoToGeoPoint SOURCES otbConvertCartoToGeoPoint.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME GenerateRPCSensorModel SOURCES otbGenerateRPCSensorModel.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME GridBasedImageResampling SOURCES otbGridBasedImageResampling.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME VectorDataReprojection SOURCES otbVectorDataReprojection.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ObtainUTMZoneFromGeoPoint SOURCES otbObtainUTMZoneFromGeoPoint.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME RefineSensorModel SOURCES otbRefineSensorModel.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME RigidTransformResample SOURCES otbRigidTransformResample.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ImageEnvelope SOURCES otbImageEnvelope.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ConvertSensorToGeoPoint SOURCES otbConvertSensorToGeoPoint.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME Superimpose SOURCES otbSuperimpose.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppProjection/app/otbConvertCartoToGeoPoint.cxx000066400000000000000000000106201301006202600306220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include #include #include "otbWrapperNumericalParameter.h" #include "otbWrapperMapProjectionParametersHandler.h" #include "otbImageToGenericRSOutputParameters.h" namespace otb { namespace Wrapper { class ConvertCartoToGeoPoint : public Application { public: /** Standard class typedefs. */ typedef ConvertCartoToGeoPoint Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ConvertCartoToGeoPoint, otb::Application); typedef otb::GenericRSTransform<> TransformType; private: void DoInit() ITK_OVERRIDE { SetName("ConvertCartoToGeoPoint"); SetDescription("Convert cartographic coordinates to geographic one."); // Documentation SetDocName("Cartographic to geographic coordinates conversion"); SetDocLongDescription("This application computes the geographic coordinates from a cartographic one. User has to give the X and Y coordinate and the cartographic projection (UTM/LAMBERT/LAMBERT2/LAMBERT93/SINUS/ECKERT4/TRANSMERCATOR/MOLLWEID/SVY21)."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Coordinates); AddDocTag(Tags::Geometry); AddParameter(ParameterType_Group, "carto", "Input cartographic coordinates"); AddParameter(ParameterType_Float, "carto.x", "X cartographic coordinates"); SetParameterDescription("carto.x", "X cartographic coordinates in the specified projection."); AddParameter(ParameterType_Float, "carto.y", "Y cartographic coordinates"); SetParameterDescription("carto.y", "Y cartographic coordinates in the specified projection."); // Add the MapProjectionParameters MapProjectionParametersHandler::AddMapProjectionParameters(this, "mapproj"); AddParameter(ParameterType_Float, "long", "Output long"); SetParameterDescription("long", "Point longitude coordinates."); SetParameterRole("long", Role_Output); AddParameter(ParameterType_Float, "lat", "Output lat"); SetParameterDescription("lat", "Point latitude coordinates."); SetParameterRole("lat", Role_Output); // Doc example parameter settings SetDocExampleParameterValue("carto.x", "367074.625"); SetDocExampleParameterValue("carto.y", "4835740"); SetDocExampleParameterValue("mapproj", "utm"); SetDocExampleParameterValue("mapproj.utm.northhem", "true"); SetDocExampleParameterValue("mapproj.utm.zone", "31"); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { // Get the projectionRef std::string inputProjRef = MapProjectionParametersHandler::GetProjectionRefFromChoice(this, "mapproj"); // Instantiate a GenericRSTransform // Input : coordiante system picked up by the user // Output : WGS84 corresponding to epsg code 4326 TransformType::Pointer transform = TransformType::New(); transform->SetInputProjectionRef(inputProjRef); transform->SetOutputProjectionRef(otb::GeoInformationConversion::ToWKT(4326)); transform->InstantiateTransform(); TransformType::InputPointType cartoPoint; TransformType::OutputPointType geoPoint; cartoPoint[0] = GetParameterFloat("carto.x"); cartoPoint[1] = GetParameterFloat("carto.y"); geoPoint = transform->TransformPoint(cartoPoint); otbAppLogINFO( << std::setprecision(10) << "Cartographic Point (x , y) : (" << cartoPoint[0] << ", " << cartoPoint[1] << ")" ); otbAppLogINFO( << std::setprecision(10) << "Geographic Point (Long, Lat) : (" << geoPoint[0] << ", " << geoPoint[1] << ")" ); SetParameterFloat( "long", geoPoint[0] ); SetParameterFloat( "lat", geoPoint[1] ); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ConvertCartoToGeoPoint) OTB-release-5.8/Modules/Applications/AppProjection/app/otbConvertSensorToGeoPoint.cxx000066400000000000000000000120151301006202600310230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbForwardSensorModel.h" #include "otbCoordinateToName.h" namespace otb { namespace Wrapper { class ConvertSensorToGeoPoint : public Application { public: /** Standard class typedefs. */ typedef ConvertSensorToGeoPoint Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ConvertSensorToGeoPoint, otb::Application); /** Filters typedef */ typedef otb::ForwardSensorModel ModelType; typedef itk::Point PointType; private: void DoInit() ITK_OVERRIDE { SetName("ConvertSensorToGeoPoint"); SetDescription("Sensor to geographic coordinates conversion."); // Documentation SetDocName("Convert Sensor Point To Geographic Point"); SetDocLongDescription("This Application converts a sensor point of an input image to a geographic point using the Forward Sensor Model of the input image."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("ConvertCartoToGeoPoint application, otbObtainUTMZoneFromGeoPoint"); AddDocTag(Tags::Geometry); AddParameter(ParameterType_InputImage, "in", "Sensor image"); SetParameterDescription("in", "Input sensor image."); AddParameter(ParameterType_Group, "input", "Point Coordinates"); AddParameter(ParameterType_Float, "input.idx","X value of desired point"); SetParameterDescription("input.idx", "X coordinate of the point to transform."); SetDefaultParameterFloat("input.idx",0.0); AddParameter(ParameterType_Float, "input.idy","Y value of desired point"); SetParameterDescription("input.idy", "Y coordinate of the point to transform."); SetDefaultParameterFloat("input.idy",0.0); // Output with Output Role AddParameter(ParameterType_Group, "output", "Geographic Coordinates"); AddParameter(ParameterType_Float, "output.idx","Output Point Longitude"); SetParameterDescription("output.idx", "Output point longitude coordinate."); AddParameter(ParameterType_Float, "output.idy","Output Point Latitude"); SetParameterDescription("output.idy", "Output point latitude coordinate."); AddParameter(ParameterType_String,"output.town","Main town near the coordinates computed"); SetParameterDescription("output.town", "Nearest main town of the computed geographic point."); AddParameter(ParameterType_String,"output.country","Country of the image"); SetParameterDescription("output.country", "Country of the input image"); // Set the parameter role for the output parameters SetParameterRole("output.idx", Role_Output ); SetParameterRole("output.idy", Role_Output ); SetParameterRole("output.town", Role_Output ); SetParameterRole("output.country", Role_Output ); // Doc example parameter settings SetDocExampleParameterValue("in","QB_TOULOUSE_MUL_Extract_500_500.tif"); SetDocExampleParameterValue("input.idx","200"); SetDocExampleParameterValue("input.idy","200"); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { // Get input Image FloatVectorImageType::Pointer inImage = GetParameterImage("in"); // Instantiate a ForwardSensor Model ModelType::Pointer model = ModelType::New(); model->SetImageGeometry(inImage->GetImageKeywordlist()); if ( model->IsValidSensorModel() == false ) { itkGenericExceptionMacro(<< "Unable to create a model"); } // Convert the desired point itk::ContinuousIndex inIndex; PointType point; inIndex[0] = GetParameterFloat("input.idx"); inIndex[1] = GetParameterFloat("input.idy"); inImage->TransformContinuousIndexToPhysicalPoint(inIndex,point); ModelType::OutputPointType outputPoint; outputPoint = model->TransformPoint(point); // Set the value computed SetParameterFloat("output.idx", outputPoint[0]); SetParameterFloat("output.idy", outputPoint[1]); // Set the town and the neaerest city CoordinateToName::Pointer coord2name = CoordinateToName::New(); coord2name->SetLon(outputPoint[0]); coord2name->SetLat(outputPoint[1]); coord2name->Evaluate(); SetParameterString("output.town", coord2name->GetPlaceName()); SetParameterString("output.country", coord2name->GetCountryName()); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ConvertSensorToGeoPoint) OTB-release-5.8/Modules/Applications/AppProjection/app/otbGenerateRPCSensorModel.cxx000066400000000000000000000226051301006202600305210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Wrappers #include "otbWrapperApplicationFactory.h" #include "otbWrapperChoiceParameter.h" #include "otbWrapperElevationParametersHandler.h" #include "otbWrapperMapProjectionParametersHandler.h" #include "otbSensorModelAdapter.h" #include "otbRPCSolverAdapter.h" #include "itkEuclideanDistanceMetric.h" #include "otbGenericRSTransform.h" #include "otbOGRDataSourceWrapper.h" #include "ogrsf_frmts.h" namespace otb { namespace Wrapper { class GenerateRPCSensorModel : public Application { public: /** Standard class typedefs. */ typedef GenerateRPCSensorModel Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::RPCSolverAdapter::Point3DType Point3DType; typedef otb::RPCSolverAdapter::Point2DType Point2DType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::RPCSolverAdapter::GCPType TiePointType; typedef otb::RPCSolverAdapter::GCPsContainerType TiePointsType; typedef otb::GenericRSTransform RSTransformType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(GenerateRPCSensorModel, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("GenerateRPCSensorModel"); SetDescription("Generate a RPC sensor model from a list of Ground Control Points."); SetDocName("Generate a RPC sensor model"); SetDocLongDescription("This application generates a RPC sensor model from a list of Ground Control Points. At least 20 points are required for estimation wihtout elevation support, and 40 points for estimation with elevation support. Elevation support will be automatically deactivated if an insufficient amount of points is provided. The application can optionnaly output a file containing accuracy statistics for each point, and a vector file containing segments represening points residues. The map projection parameter allows defining a map projection in which the accuracy is evaluated."); AddDocTag(Tags::Geometry); SetDocLimitations("None"); SetDocSeeAlso("OrthoRectication,HomologousPointsExtraction,RefineSensorModel"); SetDocAuthors("OTB-Team"); AddParameter(ParameterType_OutputFilename,"outgeom","Output geom file"); SetParameterDescription("outgeom","Geom file containing the generated RPC sensor model"); AddParameter(ParameterType_InputFilename,"inpoints","Input file containing tie points"); SetParameterDescription("inpoints","Input file containing tie points. Points are stored in following format: col row lon lat. Line beginning with # are ignored."); AddParameter(ParameterType_OutputFilename,"outstat","Output file containing output precision statistics"); SetParameterDescription("outstat","Output file containing the following info: ref_lon ref_lat elevation predicted_lon predicted_lat x_error_ref(meters) y_error_ref(meters) global_error_ref(meters) x_error(meters) y_error(meters) overall_error(meters)"); MandatoryOff("outstat"); DisableParameter("outstat"); AddParameter(ParameterType_OutputFilename,"outvector","Output vector file with residues"); SetParameterDescription("outvector","File containing segments representing residues"); MandatoryOff("outvector"); DisableParameter("outvector"); // Build the Output Map Projection MapProjectionParametersHandler::AddMapProjectionParameters(this, "map"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); // Doc example parameter settings SetDocExampleParameterValue("outgeom","output.geom"); SetDocExampleParameterValue("inpoints","points.txt"); SetDocExampleParameterValue("map","epsg"); SetDocExampleParameterValue("map.epsg.code","32631"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { OGRMultiLineString mls; // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // Parse the input file for ground control points std::ifstream ifs; ifs.open(GetParameterString("inpoints").c_str()); TiePointsType tiepoints; while(!ifs.eof()) { std::string line; std::getline(ifs,line); double x,y,z,lat,lon; // Avoid commented lines or too short ones if (!line.empty() && line[0] != '#') { // retrieve the x component std::string::size_type pos = 0; std::string::size_type nextpos = line.find_first_of("\t", pos); x = atof(line.substr(pos, nextpos).c_str()); pos = nextpos + 1; nextpos = line.find_first_of("\t", pos); y = atof(line.substr(pos, nextpos).c_str()); pos = nextpos + 1; nextpos = line.find_first_of("\t", pos); lon = atof(line.substr(pos, nextpos).c_str()); pos = nextpos + 1; nextpos = line.find_first_of("\t", pos); lat = atof(line.substr(pos, nextpos).c_str()); z = otb::DEMHandler::Instance()->GetHeightAboveEllipsoid(lon,lat); otbAppLogINFO("Adding tie point x="<ReadGeomFile(GetParameterString("outgeom")); double rmse = 0; double rmsex = 0; double rmsey = 0; double meanx = 0; double meany = 0; DistanceType::Pointer distance = DistanceType::New(); RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetOutputProjectionRef(MapProjectionParametersHandler::GetProjectionRefFromChoice(this, "map")); rsTransform->InstantiateTransform(); std::ofstream ofs; ofs<ForwardTransformPoint(it->first[0],it->first[1],it->second[2],tmpPoint[0],tmpPoint[1],tmpPoint[2]); tmpPoint = rsTransform->TransformPoint(tmpPoint); ref[0] = it->second[0]; ref[1] = it->second[1]; ref[2] = it->second[2]; ref = rsTransform->TransformPoint(ref); OGRLineString ls; ls.addPoint(tmpPoint[0],tmpPoint[1]); ls.addPoint(ref[0],ref[1]); mls.addGeometry(&ls); double gerror = distance->Evaluate(ref,tmpPoint); double xerror = ref[0]-tmpPoint[0]; double yerror = ref[1]-tmpPoint[1]; if(IsParameterEnabled("outstat")) ofs<second[2]<<"\t"<CreateLayer("matches", &oSRS, wkbMultiLineString); OGRFeatureDefn & defn = layer.GetLayerDefn(); ogr::Feature feature(defn); feature.SetGeometry(&mls); layer.CreateFeature(feature); } } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::GenerateRPCSensorModel) OTB-release-5.8/Modules/Applications/AppProjection/app/otbGridBasedImageResampling.cxx000066400000000000000000000304341301006202600310570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbStreamingWarpImageFilter.h" #include "itkLinearInterpolateImageFunction.h" #include "otbBCOInterpolateImageFunction.h" #include "itkNearestNeighborInterpolateImageFunction.h" #include "otbBandMathImageFilter.h" #include "otbConcatenateVectorImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageToVectorImageCastFilter.h" #include "itkVectorCastImageFilter.h" namespace otb { enum { Interpolator_NNeighbor, Interpolator_Linear, Interpolator_BCO }; namespace Wrapper { class GridBasedImageResampling : public Application { public: /** Standard class typedefs. */ typedef GridBasedImageResampling Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Vector DisplacementType; typedef otb::Image DisplacementFieldType; typedef itk::VectorCastImageFilter DisplacementFieldCastFilterType; typedef otb::StreamingWarpImageFilter WarpFilterType; typedef otb::MultiToMonoChannelExtractROI ExtractFilterType; typedef otb::BandMathImageFilter BandMathFilterType; typedef otb::ImageToVectorImageCastFilter VectorCastFilterType; typedef otb::ConcatenateVectorImageFilter ConcatenateFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(GridBasedImageResampling, otb::Application); private: GridBasedImageResampling() { // Instantiate warp filter m_WarpImageFilter = WarpFilterType::New(); m_BandMathX = BandMathFilterType::New(); m_BandMathY = BandMathFilterType::New(); m_ExtractX = ExtractFilterType::New(); m_ExtractY = ExtractFilterType::New(); m_VectorCastX = VectorCastFilterType::New(); m_VectorCastY = VectorCastFilterType::New(); m_Concatenate = ConcatenateFilterType::New(); m_DisplacementFieldCaster = DisplacementFieldCastFilterType::New(); } void DoInit() ITK_OVERRIDE { SetName("GridBasedImageResampling"); SetDescription("Resamples an image according to a resampling grid"); SetDocName("Grid Based Image Resampling"); SetDocLongDescription("This application allows performing image resampling from an input resampling grid."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); AddDocTag(Tags::Geometry); SetDocSeeAlso("otbStereorecificationGridGeneration"); AddParameter(ParameterType_Group,"io","Input and output data"); SetParameterDescription("io","This group of parameters allows setting the input and output images."); AddParameter(ParameterType_InputImage,"io.in","Input image"); SetParameterDescription("io.in","The input image to resample"); AddParameter(ParameterType_OutputImage, "io.out", "Output Image"); SetParameterDescription("io.out","The resampled output image"); AddParameter(ParameterType_Group,"grid","Resampling grid parameters"); AddParameter(ParameterType_InputImage,"grid.in","Input resampling grid"); SetParameterDescription("grid.in","The resampling grid"); AddParameter(ParameterType_Choice, "grid.type", "Grid Type"); SetParameterDescription("grid.type","allows one to choose between two grid types"); AddChoice("grid.type.def","Displacement grid: $G(x_out,y_out) = (x_in-x_out, y_in-y_out)$"); SetParameterDescription("grid.type.def","A deformation grid contains at each grid position the offset to apply to this position in order to get to the corresponding point in the input image to resample"); AddChoice("grid.type.loc","Localisation grid: $G(x_out,y_out) = (x_in, y_in)$"); SetParameterDescription("grid.type.loc","A localisation grid contains at each grid position the corresponding position in the input image to resample"); AddParameter(ParameterType_Group, "out", "Output Image parameters"); SetParameterDescription("out","Parameters of the output image"); AddParameter(ParameterType_Float, "out.ulx", "Upper Left X"); SetParameterDescription("out.ulx","X Coordinate of the upper-left pixel of the output resampled image"); SetDefaultParameterFloat("out.ulx",0); AddParameter(ParameterType_Float, "out.uly", "Upper Left Y"); SetParameterDescription("out.uly","Y Coordinate of the upper-left pixel of the output resampled image"); SetDefaultParameterFloat("out.uly",0); AddParameter(ParameterType_Int, "out.sizex", "Size X"); SetParameterDescription("out.sizex","Size of the output resampled image along X (in pixels)"); AddParameter(ParameterType_Int, "out.sizey", "Size Y"); SetParameterDescription("out.sizey","Size of the output resampled image along Y (in pixels)"); AddParameter(ParameterType_Float, "out.spacingx", "Pixel Size X"); SetParameterDescription("out.spacingx","Size of each pixel along X axis"); SetDefaultParameterFloat("out.spacingx",1.); AddParameter(ParameterType_Float, "out.spacingy", "Pixel Size Y"); SetParameterDescription("out.spacingy","Size of each pixel along Y axis"); SetDefaultParameterFloat("out.spacingy",1.); AddParameter(ParameterType_Float,"out.default","Default value"); SetParameterDescription("out.default","The default value to give to pixel that falls outside of the input image."); SetDefaultParameterFloat("out.default",0); // Interpolators AddParameter(ParameterType_Choice, "interpolator", "Interpolation"); SetParameterDescription("interpolator","This group of parameters allows one to define how the input image will be interpolated during resampling."); AddChoice("interpolator.nn", "Nearest Neighbor interpolation"); SetParameterDescription("interpolator.nn","Nearest neighbor interpolation leads to poor image quality, but it is very fast."); AddChoice("interpolator.linear", "Linear interpolation"); SetParameterDescription("interpolator.linear","Linear interpolation leads to average image quality but is quite fast"); AddChoice("interpolator.bco", "Bicubic interpolation"); AddParameter(ParameterType_Radius, "interpolator.bco.radius", "Radius for bicubic interpolation"); SetParameterDescription("interpolator.bco.radius","This parameter allows controlling the size of the bicubic interpolation filter. If the target pixel size is higher than the input pixel size, increasing this parameter will reduce aliasing artifacts."); SetDefaultParameterInt("interpolator.bco.radius", 2); SetParameterString("interpolator","bco"); AddRAMParameter(); // Doc example SetDocExampleParameterValue("io.in","ROI_IKO_PAN_LesHalles_sub.tif"); SetDocExampleParameterValue("io.out","ROI_IKO_PAN_LesHalles_sub_resampled.tif uint8"); SetDocExampleParameterValue("grid.in","ROI_IKO_PAN_LesHalles_sub_deformation_field.tif"); SetDocExampleParameterValue("out.sizex","256"); SetDocExampleParameterValue("out.sizey","256"); SetDocExampleParameterValue("grid.type","def"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here } void DoExecute() ITK_OVERRIDE { // Get the input image FloatVectorImageType* inImage = GetParameterImage("io.in"); // Get the resampling grid FloatVectorImageType * inGrid = GetParameterImage("grid.in"); if(inGrid->GetNumberOfComponentsPerPixel() != 2) { itkExceptionMacro(<<"Number of components of the grid is not 2, this is probably not an image of 2D resampling grid."); } // In case of localisation grid, we must internally convert to // deformation grid, which is the only type handled by StreamingWarpImageFilter if(GetParameterString("grid.type") == "loc") { GetLogger()->Info("Grid interpreted as a location grid."); m_ExtractX->SetInput(inGrid); m_ExtractX->SetChannel(1); m_BandMathX->SetNthInput(0,m_ExtractX->GetOutput(),"locX"); m_BandMathX->SetExpression("locX-idxPhyX"); m_ExtractY->SetInput(inGrid); m_ExtractY->SetChannel(2); m_BandMathY->SetNthInput(0,m_ExtractY->GetOutput(),"locY"); m_BandMathY->SetExpression("locY-idxPhyY"); m_VectorCastX->SetInput(m_BandMathX->GetOutput()); m_Concatenate->SetInput1(m_VectorCastX->GetOutput()); m_VectorCastY->SetInput(m_BandMathY->GetOutput()); m_Concatenate->SetInput2(m_VectorCastY->GetOutput()); m_DisplacementFieldCaster->SetInput(m_Concatenate->GetOutput()); } else { GetLogger()->Info("Grid interpreted as a deformation grid."); m_DisplacementFieldCaster->SetInput(inGrid); } m_DisplacementFieldCaster->GetOutput()->UpdateOutputInformation(); m_WarpImageFilter->SetDisplacementField(m_DisplacementFieldCaster->GetOutput()); // Set inputs m_WarpImageFilter->SetInput(inImage); // Get Interpolator switch ( GetParameterInt("interpolator") ) { case Interpolator_Linear: { typedef itk::LinearInterpolateImageFunction LinearInterpolationType; LinearInterpolationType::Pointer interpolator = LinearInterpolationType::New(); m_WarpImageFilter->SetInterpolator(interpolator); } break; case Interpolator_NNeighbor: { typedef itk::NearestNeighborInterpolateImageFunction NearestNeighborInterpolationType; NearestNeighborInterpolationType::Pointer interpolator = NearestNeighborInterpolationType::New(); m_WarpImageFilter->SetInterpolator(interpolator); } break; case Interpolator_BCO: { typedef otb::BCOInterpolateImageFunction BCOInterpolationType; BCOInterpolationType::Pointer interpolator = BCOInterpolationType::New(); interpolator->SetRadius(GetParameterInt("interpolator.bco.radius")); m_WarpImageFilter->SetInterpolator(interpolator); } break; } // Set Output information WarpFilterType::SizeType size; size[0] = GetParameterInt("out.sizex"); size[1] = GetParameterInt("out.sizey"); m_WarpImageFilter->SetOutputSize(size); WarpFilterType::SpacingType spacing; spacing[0] = GetParameterFloat("out.spacingx"); spacing[1] = GetParameterFloat("out.spacingy"); m_WarpImageFilter->SetOutputSpacing(spacing); WarpFilterType::PointType ul; ul[0] = GetParameterFloat("out.ulx"); ul[1] = GetParameterFloat("out.uly"); m_WarpImageFilter->SetOutputOrigin(ul); // Build the default pixel FloatVectorImageType::PixelType defaultValue; defaultValue.SetSize(inImage->GetNumberOfComponentsPerPixel()); defaultValue.Fill(GetParameterFloat("out.default")); m_WarpImageFilter->SetEdgePaddingValue(defaultValue); // Output Image SetParameterOutputImage("io.out", m_WarpImageFilter->GetOutput()); } WarpFilterType::Pointer m_WarpImageFilter; ExtractFilterType::Pointer m_ExtractX; ExtractFilterType::Pointer m_ExtractY; BandMathFilterType::Pointer m_BandMathX; BandMathFilterType::Pointer m_BandMathY; VectorCastFilterType::Pointer m_VectorCastX; VectorCastFilterType::Pointer m_VectorCastY; ConcatenateFilterType::Pointer m_Concatenate; DisplacementFieldCastFilterType::Pointer m_DisplacementFieldCaster; }; } // End namespace Wrapper } // End namepsace otb OTB_APPLICATION_EXPORT(otb::Wrapper::GridBasedImageResampling) OTB-release-5.8/Modules/Applications/AppProjection/app/otbImageEnvelope.cxx000066400000000000000000000065041301006202600267670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbImageToEnvelopeVectorDataFilter.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class ImageEnvelope : public Application { public: /** Standard class typedefs. */ typedef ImageEnvelope Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ImageEnvelope, otb::Application); /** Filters typedef */ typedef otb::ImageToEnvelopeVectorDataFilter EnvelopeFilterType; private: void DoInit() ITK_OVERRIDE { SetName("ImageEnvelope"); SetDescription("Extracts an image envelope."); // Documentation SetDocName("Image Envelope"); SetDocLongDescription("Build a vector data containing the polygon of the image envelope."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Geometry); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "Input image."); AddParameter(ParameterType_OutputVectorData, "out", "Output Vector Data"); SetParameterDescription("out", "Vector data file containing the envelope"); AddParameter(ParameterType_Int, "sr", "Sampling Rate"); SetParameterDescription("sr", "Sampling rate for image edges (in pixel)"); SetDefaultParameterInt("sr",0); MandatoryOff("sr"); DisableParameter("sr"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); AddParameter(ParameterType_String, "proj", "Projection"); SetParameterDescription("proj", "Projection to be used to compute the envelope (default is WGS84)"); MandatoryOff("proj"); // Doc example parameter settings SetDocExampleParameterValue("in", "QB_TOULOUSE_MUL_Extract_500_500.tif"); SetDocExampleParameterValue("out", "ImageEnvelope.shp"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to be done } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer input = GetParameterImage("in"); m_Envelope = EnvelopeFilterType::New(); m_Envelope->SetInput(input); m_Envelope->SetSamplingRate(GetParameterInt("sr")); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); if (HasValue("proj")) { m_Envelope->SetOutputProjectionRef(GetParameterString("proj")); } SetParameterOutputVectorData("out", m_Envelope->GetOutput()); } EnvelopeFilterType::Pointer m_Envelope; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ImageEnvelope) OTB-release-5.8/Modules/Applications/AppProjection/app/otbObtainUTMZoneFromGeoPoint.cxx000066400000000000000000000051151301006202600311730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMapProjections.h" #include "otbUtils.h" namespace otb { namespace Wrapper { class ObtainUTMZoneFromGeoPoint : public Application { public: /** Standard class typedefs. */ typedef ObtainUTMZoneFromGeoPoint Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ObtainUTMZoneFromGeoPoint, otb::Application); private: ObtainUTMZoneFromGeoPoint() { } ~ObtainUTMZoneFromGeoPoint() ITK_OVERRIDE { } void DoInit() ITK_OVERRIDE { SetName("ObtainUTMZoneFromGeoPoint"); SetDescription("UTM zone determination from a geographic point."); // Documentation SetDocName("Obtain UTM Zone From Geo Point"); SetDocLongDescription("This application returns the UTM zone of an input geographic point."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Coordinates); AddParameter(ParameterType_Float, "lat", "Latitude"); SetParameterDescription("lat", "Latitude value of desired point."); AddParameter(ParameterType_Float, "lon", "Longitude"); SetParameterDescription("lon", "Longitude value of desired point."); AddParameter(ParameterType_Int,"utm","UTMZone"); SetParameterDescription("utm","UTM Zone"); MandatoryOff("utm"); SetParameterRole("utm", Role_Output); SetExampleComment("Obtain a UTM Zone", 0); SetDocExampleParameterValue("lat","10.0"); SetDocExampleParameterValue("lon","124.0"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do } void DoExecute() ITK_OVERRIDE { int utmZone = otb::Utils::GetZoneFromGeoPoint(GetParameterFloat("lon"), GetParameterFloat("lat")); SetParameterInt("utm", utmZone); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ObtainUTMZoneFromGeoPoint) OTB-release-5.8/Modules/Applications/AppProjection/app/otbOrthoRectification.cxx000066400000000000000000001040011301006202600300350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbWrapperNumericalParameter.h" #include "otbImageToGenericRSOutputParameters.h" #include "otbGenericRSResampleImageFilter.h" #include "itkLinearInterpolateImageFunction.h" #include "otbBCOInterpolateImageFunction.h" #include "itkNearestNeighborInterpolateImageFunction.h" // MapProjection handler #include "otbWrapperMapProjectionParametersHandler.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" #include "otbGeographicalDistance.h" namespace otb { enum { Interpolator_BCO, Interpolator_NNeighbor, Interpolator_Linear }; enum { Mode_UserDefined, Mode_AutomaticSize, Mode_AutomaticSpacing, Mode_OutputROI, Mode_OrthoFit }; const float DefaultGridSpacingMeter = 4.0; namespace Wrapper { class OrthoRectification : public Application { public: /** Standard class typedefs. */ typedef OrthoRectification Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(OrthoRectification, otb::Application); /** Generic Remote Sensor Resampler */ typedef otb::GenericRSResampleImageFilter ResampleFilterType; /** Interpolators typedefs*/ typedef itk::LinearInterpolateImageFunction LinearInterpolationType; typedef itk::NearestNeighborInterpolateImageFunction NearestNeighborInterpolationType; typedef otb::BCOInterpolateImageFunction BCOInterpolationType; private: void DoInit() ITK_OVERRIDE { SetName("OrthoRectification"); std::ostringstream oss; oss << "This application allows ortho-rectification of optical images from supported sensors." << std::endl; SetDescription(oss.str()); // Documentation SetDocName("Ortho-rectification"); oss.str(""); oss<<"An inverse sensor model is built from the input image metadata to convert geographical to raw geometry coordinates. "; oss<<"This inverse sensor model is then combined with the chosen map projection to build a global coordinate mapping grid. Last, this grid is used to resample using the chosen interpolation algorithm. "; oss<<"A Digital Elevation Model can be specified to account for terrain deformations. "< OutputParametersEstimatorType; OutputParametersEstimatorType::Pointer genericRSEstimator = OutputParametersEstimatorType::New(); if(IsParameterEnabled("outputs.isotropic")) { genericRSEstimator->EstimateIsotropicSpacingOn(); } else { genericRSEstimator->EstimateIsotropicSpacingOff(); } genericRSEstimator->SetInput(inImage); genericRSEstimator->SetOutputProjectionRef(m_OutputProjectionRef); genericRSEstimator->Compute(); // Fill the Gui with the computed parameters if (!HasUserValue("outputs.sizex")) SetParameterInt("outputs.sizex", genericRSEstimator->GetOutputSize()[0]); if (!HasUserValue("outputs.sizey")) SetParameterInt("outputs.sizey", genericRSEstimator->GetOutputSize()[1]); if (!HasUserValue("outputs.spacingx")) SetParameterFloat("outputs.spacingx", genericRSEstimator->GetOutputSpacing()[0]); if (!HasUserValue("outputs.spacingy")) SetParameterFloat("outputs.spacingy", genericRSEstimator->GetOutputSpacing()[1]); if (!HasUserValue("outputs.ulx")) SetParameterFloat("outputs.ulx", genericRSEstimator->GetOutputOrigin()[0] - 0.5 * genericRSEstimator->GetOutputSpacing()[0]); if (!HasUserValue("outputs.uly")) SetParameterFloat("outputs.uly", genericRSEstimator->GetOutputOrigin()[1] - 0.5 * genericRSEstimator->GetOutputSpacing()[1]); if (!HasUserValue("outputs.lrx")) SetParameterFloat("outputs.lrx", GetParameterFloat("outputs.ulx") + GetParameterFloat("outputs.spacingx") * static_cast(GetParameterInt("outputs.sizex"))); if (!HasUserValue("outputs.lry")) SetParameterFloat("outputs.lry", GetParameterFloat("outputs.uly") + GetParameterFloat("outputs.spacingy") * static_cast(GetParameterInt("outputs.sizey"))); // Handle the spacing and size field following the mode // chose by the user switch (GetParameterInt("outputs.mode") ) { case Mode_UserDefined: { // Automatic set to off except lower right coordinates AutomaticValueOff("outputs.ulx"); AutomaticValueOff("outputs.uly"); AutomaticValueOff("outputs.sizex"); AutomaticValueOff("outputs.sizey"); AutomaticValueOff("outputs.spacingx"); AutomaticValueOff("outputs.spacingy"); AutomaticValueOn("outputs.lrx"); AutomaticValueOn("outputs.lry"); // Enable all the parameters except lower right coordinates EnableParameter("outputs.ulx"); EnableParameter("outputs.uly"); EnableParameter("outputs.spacingx"); EnableParameter("outputs.spacingy"); EnableParameter("outputs.sizex"); EnableParameter("outputs.sizey"); DisableParameter("outputs.lrx"); DisableParameter("outputs.lry"); DisableParameter("outputs.ortho"); // Make all the parameters in this mode mandatory except lower right coordinates MandatoryOn("outputs.ulx"); MandatoryOn("outputs.uly"); MandatoryOn("outputs.spacingx"); MandatoryOn("outputs.spacingy"); MandatoryOn("outputs.sizex"); MandatoryOn("outputs.sizey"); MandatoryOff("outputs.lrx"); MandatoryOff("outputs.lry"); MandatoryOff("outputs.ortho"); // Update lower right SetParameterFloat("outputs.lrx", GetParameterFloat("outputs.ulx") + GetParameterFloat("outputs.spacingx") * static_cast(GetParameterInt("outputs.sizex"))); SetParameterFloat("outputs.lry", GetParameterFloat("outputs.uly") + GetParameterFloat("outputs.spacingy") * static_cast(GetParameterInt("outputs.sizey"))); } break; case Mode_AutomaticSize: { // Disable the size fields DisableParameter("outputs.ulx"); DisableParameter("outputs.uly"); DisableParameter("outputs.sizex"); DisableParameter("outputs.sizey"); EnableParameter("outputs.spacingx"); EnableParameter("outputs.spacingy"); DisableParameter("outputs.lrx"); DisableParameter("outputs.lry"); DisableParameter("outputs.ortho"); // Update the automatic value mode of each filed AutomaticValueOn("outputs.ulx"); AutomaticValueOn("outputs.uly"); AutomaticValueOn("outputs.sizex"); AutomaticValueOn("outputs.sizey"); AutomaticValueOff("outputs.spacingx"); AutomaticValueOff("outputs.spacingy"); AutomaticValueOn("outputs.lrx"); AutomaticValueOn("outputs.lry"); // Adapat the status of the param to this mode MandatoryOff("outputs.ulx"); MandatoryOff("outputs.uly"); MandatoryOn("outputs.spacingx"); MandatoryOn("outputs.spacingy"); MandatoryOff("outputs.sizex"); MandatoryOff("outputs.sizey"); MandatoryOff("outputs.lrx"); MandatoryOff("outputs.lry"); MandatoryOff("outputs.ortho"); ResampleFilterType::SpacingType spacing; spacing[0] = GetParameterFloat("outputs.spacingx"); spacing[1] = GetParameterFloat("outputs.spacingy"); genericRSEstimator->ForceSpacingTo(spacing); genericRSEstimator->Compute(); // Set the processed size relative to this forced spacing SetParameterInt("outputs.sizex", genericRSEstimator->GetOutputSize()[0]); SetParameterInt("outputs.sizey", genericRSEstimator->GetOutputSize()[1]); // Reset Origin to default SetParameterFloat("outputs.ulx", genericRSEstimator->GetOutputOrigin()[0] - 0.5 * genericRSEstimator->GetOutputSpacing()[0]); SetParameterFloat("outputs.uly", genericRSEstimator->GetOutputOrigin()[1] - 0.5 * genericRSEstimator->GetOutputSpacing()[1]); // Update lower right SetParameterFloat("outputs.lrx", GetParameterFloat("outputs.ulx") + GetParameterFloat("outputs.spacingx") * static_cast(GetParameterInt("outputs.sizex"))); SetParameterFloat("outputs.lry", GetParameterFloat("outputs.uly") + GetParameterFloat("outputs.spacingy") * static_cast(GetParameterInt("outputs.sizey"))); } break; case Mode_AutomaticSpacing: { // Disable the spacing fields and enable the size fields DisableParameter("outputs.ulx"); DisableParameter("outputs.uly"); DisableParameter("outputs.spacingx"); DisableParameter("outputs.spacingy"); EnableParameter("outputs.sizex"); EnableParameter("outputs.sizey"); DisableParameter("outputs.lrx"); DisableParameter("outputs.lry"); DisableParameter("outputs.ortho"); // Update the automatic value mode of each filed AutomaticValueOn("outputs.ulx"); AutomaticValueOn("outputs.uly"); AutomaticValueOn("outputs.spacingx"); AutomaticValueOn("outputs.spacingy"); AutomaticValueOff("outputs.sizex"); AutomaticValueOff("outputs.sizey"); AutomaticValueOn("outputs.lrx"); AutomaticValueOn("outputs.lry"); // Adapat the status of the param to this mode MandatoryOff("outputs.ulx"); MandatoryOff("outputs.uly"); MandatoryOff("outputs.spacingx"); MandatoryOff("outputs.spacingy"); MandatoryOn("outputs.sizex"); MandatoryOn("outputs.sizey"); MandatoryOff("outputs.lrx"); MandatoryOff("outputs.lry"); MandatoryOff("outputs.ortho"); ResampleFilterType::SizeType size; size[0] = GetParameterInt("outputs.sizex"); size[1] = GetParameterInt("outputs.sizey"); genericRSEstimator->ForceSizeTo(size); genericRSEstimator->Compute(); // Set the processed spacing relative to this forced size SetParameterFloat("outputs.spacingx", genericRSEstimator->GetOutputSpacing()[0]); SetParameterFloat("outputs.spacingy", genericRSEstimator->GetOutputSpacing()[1]); // Reset Origin to default SetParameterFloat("outputs.ulx", genericRSEstimator->GetOutputOrigin()[0] - 0.5 * genericRSEstimator->GetOutputSpacing()[0]); SetParameterFloat("outputs.uly", genericRSEstimator->GetOutputOrigin()[1] - 0.5 * genericRSEstimator->GetOutputSpacing()[1]); // Update lower right SetParameterFloat("outputs.lrx", GetParameterFloat("outputs.ulx") + GetParameterFloat("outputs.spacingx") * static_cast(GetParameterInt("outputs.sizex"))); SetParameterFloat("outputs.lry", GetParameterFloat("outputs.uly") + GetParameterFloat("outputs.spacingy") * static_cast(GetParameterInt("outputs.sizey"))); } break; case Mode_OutputROI: { // Set the size according to the output ROI EnableParameter("outputs.ulx"); EnableParameter("outputs.uly"); DisableParameter("outputs.sizex"); DisableParameter("outputs.sizey"); EnableParameter("outputs.spacingx"); EnableParameter("outputs.spacingy"); EnableParameter("outputs.lrx"); EnableParameter("outputs.lry"); DisableParameter("outputs.ortho"); // Update the automatic value mode of each filed AutomaticValueOff("outputs.ulx"); AutomaticValueOff("outputs.uly"); AutomaticValueOn("outputs.sizex"); AutomaticValueOn("outputs.sizey"); AutomaticValueOff("outputs.spacingx"); AutomaticValueOff("outputs.spacingy"); AutomaticValueOff("outputs.lrx"); AutomaticValueOff("outputs.lry"); // Adapt the status of the param to this mode MandatoryOn("outputs.ulx"); MandatoryOn("outputs.uly"); MandatoryOn("outputs.spacingx"); MandatoryOn("outputs.spacingy"); MandatoryOff("outputs.sizex"); MandatoryOff("outputs.sizey"); MandatoryOn("outputs.lrx"); MandatoryOn("outputs.lry"); MandatoryOff("outputs.ortho"); ResampleFilterType::SpacingType spacing; spacing[0] = GetParameterFloat("outputs.spacingx"); spacing[1] = GetParameterFloat("outputs.spacingy"); // Set the processed size relative to this forced spacing if (vcl_abs(spacing[0]) > 0.0) SetParameterInt("outputs.sizex", static_cast(vcl_ceil((GetParameterFloat("outputs.lrx")-GetParameterFloat("outputs.ulx"))/spacing[0]))); if (vcl_abs(spacing[1]) > 0.0) SetParameterInt("outputs.sizey", static_cast(vcl_ceil((GetParameterFloat("outputs.lry")-GetParameterFloat("outputs.uly"))/spacing[1]))); } break; case Mode_OrthoFit: { // Make all the parameters in this mode mandatory MandatoryOff("outputs.ulx"); MandatoryOff("outputs.uly"); MandatoryOff("outputs.spacingx"); MandatoryOff("outputs.spacingy"); MandatoryOff("outputs.sizex"); MandatoryOff("outputs.sizey"); MandatoryOff("outputs.lrx"); MandatoryOff("outputs.lry"); MandatoryOn("outputs.ortho"); // Disable the parameters DisableParameter("outputs.ulx"); DisableParameter("outputs.uly"); DisableParameter("outputs.spacingx"); DisableParameter("outputs.spacingy"); DisableParameter("outputs.sizex"); DisableParameter("outputs.sizey"); DisableParameter("outputs.lrx"); DisableParameter("outputs.lry"); EnableParameter("outputs.ortho"); if (HasValue("outputs.ortho")) { // Automatic set to on AutomaticValueOn("outputs.ulx"); AutomaticValueOn("outputs.uly"); AutomaticValueOn("outputs.sizex"); AutomaticValueOn("outputs.sizey"); AutomaticValueOn("outputs.spacingx"); AutomaticValueOn("outputs.spacingy"); AutomaticValueOn("outputs.lrx"); AutomaticValueOn("outputs.lry"); // input image FloatVectorImageType::Pointer inOrtho = GetParameterImage("outputs.ortho"); ResampleFilterType::OriginType orig = inOrtho->GetOrigin(); ResampleFilterType::SpacingType spacing = inOrtho->GetSpacing(); ResampleFilterType::SizeType size = inOrtho->GetLargestPossibleRegion().GetSize(); SetParameterInt("outputs.sizex",size[0]); SetParameterInt("outputs.sizey",size[1]); SetParameterFloat("outputs.spacingx",spacing[0]); SetParameterFloat("outputs.spacingy",spacing[1]); SetParameterFloat("outputs.ulx", orig[0] - 0.5 * spacing[0]); SetParameterFloat("outputs.uly", orig[1] - 0.5 * spacing[1]); // Update lower right SetParameterFloat("outputs.lrx", GetParameterFloat("outputs.ulx") + GetParameterFloat("outputs.spacingx") * static_cast(GetParameterInt("outputs.sizex"))); SetParameterFloat("outputs.lry", GetParameterFloat("outputs.uly") + GetParameterFloat("outputs.spacingy") * static_cast(GetParameterInt("outputs.sizey"))); } } break; } // switch (GetParameterInt("outputs.mode") ) if (!HasUserValue("opt.gridspacing")) { // Update opt.gridspacing // In case output coordinate system is WG84, if (m_OutputProjectionRef == otb::GeoInformationConversion::ToWKT(4326)) { // How much is 4 meters in degrees ? typedef itk::Point FloatPointType; FloatPointType point1, point2; typedef otb::GeographicalDistance GeographicalDistanceType; GeographicalDistanceType::Pointer geoDistanceCalculator = GeographicalDistanceType::New(); // center point1[0] = GetParameterFloat("outputs.ulx") + GetParameterFloat("outputs.spacingx") * GetParameterInt("outputs.sizex") / 2; point1[1] = GetParameterFloat("outputs.uly") + GetParameterFloat("outputs.spacingy") * GetParameterInt("outputs.sizey") / 2; // center + [1,0] point2[0] = point1[0] + GetParameterFloat("outputs.spacingx"); point2[1] = point1[1]; double xgroundspacing = geoDistanceCalculator->Evaluate(point1, point2); otbAppLogINFO( "Output X ground spacing in meter = " << xgroundspacing ); // center + [0,1] point2[0] = point1[0]; point2[1] = point1[1] + GetParameterFloat("outputs.spacingy"); double ygroundspacing = geoDistanceCalculator->Evaluate(point1, point2); otbAppLogINFO( "Output Y ground spacing in meter = " << ygroundspacing ); double xgridspacing = DefaultGridSpacingMeter * GetParameterFloat("outputs.spacingx") / xgroundspacing; double ygridspacing = DefaultGridSpacingMeter * GetParameterFloat("outputs.spacingy") / ygroundspacing; otbAppLogINFO( << DefaultGridSpacingMeter << " meters in X direction correspond roughly to " << xgridspacing << " degrees" ); otbAppLogINFO( << DefaultGridSpacingMeter << " meters in Y direction correspond roughly to " << ygridspacing << " degrees" ); // Use the smallest spacing (more precise grid) double optimalSpacing = std::min( vcl_abs(xgridspacing), vcl_abs(ygridspacing) ); otbAppLogINFO( "Setting grid spacing to " << optimalSpacing ); SetParameterFloat("opt.gridspacing", optimalSpacing); } else // if (m_OutputProjectionRef == otb::GeoInformationConversion::ToWKT(4326)) { SetParameterFloat("opt.gridspacing", DefaultGridSpacingMeter); } // if (m_OutputProjectionRef == otb::GeoInformationConversion::ToWKT(4326)) } // if (!HasUserValue("opt.gridspacing")) } // if (HasValue("io.in")) } void DoExecute() ITK_OVERRIDE { // Get the input image FloatVectorImageType* inImage = GetParameterImage("io.in"); // Resampler Instantiation m_ResampleFilter = ResampleFilterType::New(); m_ResampleFilter->SetInput(inImage); // Set the output projection Ref m_ResampleFilter->SetInputProjectionRef(inImage->GetProjectionRef()); m_ResampleFilter->SetInputKeywordList(inImage->GetImageKeywordlist()); m_ResampleFilter->SetOutputProjectionRef(m_OutputProjectionRef); // Check size if (GetParameterInt("outputs.sizex") <= 0 || GetParameterInt("outputs.sizey") <= 0) { otbAppLogCRITICAL("Wrong value : negative size : ("< 0.) { otbAppLogWARNING(<<"Wrong value for outputs.spacingy: Pixel size along Y axis should be negative, (outputs.spacingy=" < LinearInterpolationType; LinearInterpolationType::Pointer interpolator = LinearInterpolationType::New(); m_ResampleFilter->SetInterpolator(interpolator); } break; case Interpolator_NNeighbor: { typedef itk::NearestNeighborInterpolateImageFunction NearestNeighborInterpolationType; NearestNeighborInterpolationType::Pointer interpolator = NearestNeighborInterpolationType::New(); m_ResampleFilter->SetInterpolator(interpolator); } break; case Interpolator_BCO: { typedef otb::BCOInterpolateImageFunction BCOInterpolationType; BCOInterpolationType::Pointer interpolator = BCOInterpolationType::New(); interpolator->SetRadius(GetParameterInt("interpolator.bco.radius")); m_ResampleFilter->SetInterpolator(interpolator); } break; } // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // If activated, generate RPC model if(IsParameterEnabled("opt.rpc")) { m_ResampleFilter->EstimateInputRpcModelOn(); m_ResampleFilter->SetInputRpcGridSize( GetParameterInt("opt.rpc") ); otbAppLogINFO("Generating RPC modeling with " << GetParameterInt("opt.rpc") << " points per axis"); } // Set Output information ResampleFilterType::SizeType size; size[0] = GetParameterInt("outputs.sizex"); size[1] = GetParameterInt("outputs.sizey"); m_ResampleFilter->SetOutputSize(size); otbAppLogINFO("Generating output with size = " << size); ResampleFilterType::SpacingType spacing; spacing[0] = GetParameterFloat("outputs.spacingx"); spacing[1] = GetParameterFloat("outputs.spacingy"); m_ResampleFilter->SetOutputSpacing(spacing); otbAppLogINFO("Generating output with pixel spacing = " << spacing); ResampleFilterType::OriginType origin; origin[0] = GetParameterFloat("outputs.ulx") + 0.5 * GetParameterFloat("outputs.spacingx"); origin[1] = GetParameterFloat("outputs.uly") + 0.5 * GetParameterFloat("outputs.spacingy"); m_ResampleFilter->SetOutputOrigin(origin); otbAppLogINFO("Generating output with origin = " << origin); // Build the default pixel FloatVectorImageType::PixelType defaultValue; defaultValue.SetSize(inImage->GetNumberOfComponentsPerPixel()); defaultValue.Fill(GetParameterFloat("outputs.default")); m_ResampleFilter->SetEdgePaddingValue(defaultValue); otbAppLogINFO("Area outside input image bounds will have a pixel value of " << defaultValue); // Displacement Field spacing ResampleFilterType::SpacingType gridSpacing; if (IsParameterEnabled("opt.gridspacing")) { gridSpacing[0] = GetParameterFloat("opt.gridspacing"); gridSpacing[1] = -GetParameterFloat("opt.gridspacing"); otbAppLogINFO("Using a deformation grid with a physical spacing of " << GetParameterFloat("opt.gridspacing")); // Predict size of deformation grid ResampleFilterType::SizeType deformationGridSize; deformationGridSize[0] = static_cast(vcl_abs( GetParameterInt("outputs.sizex") * GetParameterFloat("outputs.spacingx") / GetParameterFloat("opt.gridspacing") )); deformationGridSize[1] = static_cast(vcl_abs( GetParameterInt("outputs.sizey") * GetParameterFloat("outputs.spacingy") / GetParameterFloat("opt.gridspacing") )); otbAppLogINFO("Using a deformation grid of size " << deformationGridSize); if (deformationGridSize[0] * deformationGridSize[1] == 0) { otbAppLogFATAL("Deformation grid degenerated (size of 0). " "You shall set opt.gridspacing appropriately. " "opt.gridspacing units are the same as outputs.spacing units"); } if (vcl_abs(GetParameterFloat("opt.gridspacing")) < vcl_abs(GetParameterFloat("outputs.spacingx")) || vcl_abs(GetParameterFloat("opt.gridspacing")) < vcl_abs(GetParameterFloat("outputs.spacingy")) ) { otbAppLogWARNING("Spacing of deformation grid should be at least equal to " "spacing of output image. Otherwise, computation time will be slow, " "and precision of output will not be better. " "You shall set opt.gridspacing appropriately. " "opt.gridspacing units are the same as outputs.spacing units"); } m_ResampleFilter->SetDisplacementFieldSpacing(gridSpacing); } // Output Image SetParameterOutputImage("io.out", m_ResampleFilter->GetOutput()); } ResampleFilterType::Pointer m_ResampleFilter; std::string m_OutputProjectionRef; }; } // namespace Wrapper } // namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::OrthoRectification) OTB-release-5.8/Modules/Applications/AppProjection/app/otbRefineSensorModel.cxx000066400000000000000000000265621301006202600276400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Wrappers #include "otbWrapperApplicationFactory.h" #include "otbWrapperChoiceParameter.h" #include "otbWrapperElevationParametersHandler.h" #include "otbWrapperMapProjectionParametersHandler.h" #include "otbSensorModelAdapter.h" #include "itkPoint.h" #include "itkEuclideanDistanceMetric.h" #include "otbGenericRSTransform.h" #include "otbOGRDataSourceWrapper.h" #include "ogrsf_frmts.h" namespace otb { namespace Wrapper { class RefineSensorModel : public Application { public: /** Standard class typedefs. */ typedef RefineSensorModel Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Point PointType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef std::pair TiePointType; typedef std::vector TiePointsType; typedef otb::GenericRSTransform RSTransformType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(RefineSensorModel, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("RefineSensorModel"); SetDescription("Perform least-square fit of a sensor model to a set of tie points"); SetDocName("Refine Sensor Model"); SetDocLongDescription("This application reads a geom file containing a sensor model and a text file containing a list of ground control point, and performs a least-square fit of the sensor model adjustable parameters to these tie points. It produces an updated geom file as output, as well as an optional ground control points based statistics file and a vector file containing residues. The output geom file can then be used to ortho-rectify the data more accurately. Plaease note that for a proper use of the application, elevation must be correctly set (including DEM and geoid file). The map parameters allows one to choose a map projection in which the accuracy will be estimated in meters."); AddDocTag(Tags::Geometry); SetDocLimitations("None"); SetDocSeeAlso("OrthoRectification,HomologousPointsExtraction"); SetDocAuthors("OTB-Team"); AddParameter(ParameterType_InputFilename,"ingeom","Input geom file"); SetParameterDescription("ingeom","Geom file containing the sensor model to refine"); AddParameter(ParameterType_OutputFilename,"outgeom","Output geom file"); SetParameterDescription("outgeom","Geom file containing the refined sensor model"); AddParameter(ParameterType_InputFilename,"inpoints","Input file containing tie points"); SetParameterDescription("inpoints","Input file containing tie points. Points are stored in following format: row col lon lat. Line beginning with # are ignored."); AddParameter(ParameterType_OutputFilename,"outstat","Output file containing output precision statistics"); SetParameterDescription("outstat","Output file containing the following info: ref_lon ref_lat elevation predicted_lon predicted_lat x_error_ref(meters) y_error_ref(meters) global_error_ref(meters) x_error(meters) y_error(meters) overall_error(meters)"); MandatoryOff("outstat"); DisableParameter("outstat"); AddParameter(ParameterType_OutputFilename,"outvector","Output vector file with residues"); SetParameterDescription("outvector","File containing segments representing residues"); MandatoryOff("outvector"); DisableParameter("outvector"); // Build the Output Map Projection MapProjectionParametersHandler::AddMapProjectionParameters(this, "map"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); // Doc example parameter settings SetDocExampleParameterValue("ingeom", "input.geom"); SetDocExampleParameterValue("outgeom","output.geom"); SetDocExampleParameterValue("inpoints","points.txt"); SetDocExampleParameterValue("map","epsg"); SetDocExampleParameterValue("map.epsg.code","32631"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { OGRMultiLineString mls; otb::SensorModelAdapter::Pointer sm = otb::SensorModelAdapter::New(); otb::SensorModelAdapter::Pointer sm_ref = otb::SensorModelAdapter::New(); // Read the geom file sm->ReadGeomFile(GetParameterString("ingeom")); sm_ref->ReadGeomFile(GetParameterString("ingeom")); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // Parse the input file for ground control points std::ifstream ifs; ifs.open(GetParameterString("inpoints").c_str()); TiePointsType tiepoints; while(!ifs.eof()) { std::string line; std::getline(ifs,line); double x,y,z,lat,lon; // Avoid commented lines or too short ones if (!line.empty() && line[0] != '#') { // retrieve the x component std::string::size_type pos = 0; std::string::size_type nextpos = line.find_first_of("\t", pos); x = atof(line.substr(pos, nextpos).c_str()); pos = nextpos + 1; nextpos = line.find_first_of("\t", pos); y = atof(line.substr(pos, nextpos).c_str()); pos = nextpos + 1; nextpos = line.find_first_of("\t", pos); lon = atof(line.substr(pos, nextpos).c_str()); pos = nextpos + 1; nextpos = line.find_first_of("\t", pos); lat = atof(line.substr(pos, nextpos).c_str()); z = otb::DEMHandler::Instance()->GetHeightAboveEllipsoid(lon,lat); otbAppLogINFO("Adding tie point x="<Optimize(); otbAppLogINFO("Done.\n"); sm->WriteGeomFile(GetParameterString("outgeom")); double rmse = 0; double rmsex = 0; double rmsey = 0; double meanx = 0; double meany = 0; double rmse_ref = 0; double rmsex_ref = 0; double rmsey_ref = 0; double meanx_ref = 0; double meany_ref = 0; DistanceType::Pointer distance = DistanceType::New(); RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetOutputProjectionRef(MapProjectionParametersHandler::GetProjectionRefFromChoice(this, "map")); rsTransform->InstantiateTransform(); std::ofstream ofs; ofs<ForwardTransformPoint(it->first[0],it->first[1],it->first[2],tmpPoint[0],tmpPoint[1],tmpPoint[2]); sm_ref->ForwardTransformPoint(it->first[0],it->first[1],it->first[2],tmpPoint_ref[0],tmpPoint_ref[1],tmpPoint_ref[2]); tmpPoint = rsTransform->TransformPoint(tmpPoint); tmpPoint_ref = rsTransform->TransformPoint(tmpPoint_ref); ref[0] = it->second[0]; ref[1] = it->second[1]; ref[2] = it->second[2]; ref = rsTransform->TransformPoint(ref); OGRLineString ls; ls.addPoint(tmpPoint[0],tmpPoint[1]); ls.addPoint(ref[0],ref[1]); mls.addGeometry(&ls); double gerror = distance->Evaluate(ref,tmpPoint); double xerror = ref[0]-tmpPoint[0]; double yerror = ref[1]-tmpPoint[1]; double gerror_ref = distance->Evaluate(ref,tmpPoint_ref); double xerror_ref = ref[0]-tmpPoint_ref[0]; double yerror_ref = ref[1]-tmpPoint_ref[1]; if(IsParameterEnabled("outstat")) ofs<first[2]<<"\t"<CreateLayer("matches", &oSRS, wkbMultiLineString); OGRFeatureDefn & defn = layer.GetLayerDefn(); ogr::Feature feature(defn); feature.SetGeometry(&mls); layer.CreateFeature(feature); } } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::RefineSensorModel) OTB-release-5.8/Modules/Applications/AppProjection/app/otbRigidTransformResample.cxx000066400000000000000000000456261301006202600307020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbBCOInterpolateImageFunction.h" #include "itkNearestNeighborInterpolateImageFunction.h" //Transform #include "otbCompositeTransform.h" #include "itkScalableAffineTransform.h" #include "itkTranslationTransform.h" #include "itkScaleTransform.h" #include "itkCenteredRigid2DTransform.h" #include "otbStreamingResampleImageFilter.h" #include "otbGridResampleImageFilter.h" namespace otb { enum { Interpolator_NNeighbor, Interpolator_Linear, Interpolator_BCO }; enum { Transform_Identity, Transform_Translation, Transform_Rotation, }; namespace Wrapper { class RigidTransformResample : public Application { public: /** Standard class typedefs. */ typedef RigidTransformResample Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); typedef itk::TranslationTransform TransformType; typedef otb::StreamingResampleImageFilter ResampleFilterType; typedef otb::GridResampleImageFilter GridResampleFilterType; typedef itk::ScalableAffineTransform ScalableTransformType; typedef ScalableTransformType::OutputVectorType OutputVectorType; /** Rotation transform */ typedef itk::CenteredRigid2DTransform< double > RotationTransformType; typedef RotationTransformType::ScalarType ScalarType; itkTypeMacro(RigidTransformResample, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("RigidTransformResample"); SetDescription("Resample an image with a rigid transform"); // Documentation SetDocName("Image resampling with a rigid transform"); SetDocLongDescription("This application performs a parametric transform on the input image. Scaling, translation and rotation with scaling factor are handled." " Parameters of the transform is expressed in physical units, thus particular attention must be paid on pixel size (value, and sign). Moreover transform is expressed from input space to output space (on the contrary ITK Transforms are expressed form output space to input space). "); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("Translation"); AddDocTag("Conversion"); AddDocTag(Tags::Geometry); AddParameter(ParameterType_InputImage, "in", "Input image"); SetParameterDescription("in","The input image to translate."); AddParameter(ParameterType_OutputImage, "out", "Output image"); SetParameterDescription("out","The transformed output image."); //Transform AddParameter(ParameterType_Group,"transform","Transform parameters"); SetParameterDescription("transform","This group of parameters allows setting the transformation to apply."); AddParameter(ParameterType_Choice, "transform.type", "Type of transformation"); SetParameterDescription("transform.type","Type of transformation. Available transformations are spatial scaling, translation and rotation with scaling factor"); AddChoice("transform.type.id", "id"); SetParameterDescription("transform.type.id","Spatial scaling"); AddParameter(ParameterType_Float,"transform.type.id.scalex", "X scaling"); SetParameterDescription("transform.type.id.scalex","Scaling factor between the output X spacing and the input X spacing"); SetDefaultParameterFloat("transform.type.id.scalex",1.); AddParameter(ParameterType_Float,"transform.type.id.scaley", "Y scaling"); SetParameterDescription("transform.type.id.scaley","Scaling factor between the output Y spacing and the input Y spacing"); SetDefaultParameterFloat("transform.type.id.scaley",1.); AddChoice("transform.type.translation", "translation"); SetParameterDescription("transform.type.translation","translation"); AddParameter(ParameterType_Float,"transform.type.translation.tx", "The X translation (in physical units)"); SetParameterDescription("transform.type.translation.tx","The translation value along X axis (in physical units)."); SetDefaultParameterFloat("transform.type.translation.tx",0.); AddParameter(ParameterType_Float,"transform.type.translation.ty", "The Y translation (in physical units)"); SetParameterDescription("transform.type.translation.ty","The translation value along Y axis (in physical units)"); SetDefaultParameterFloat("transform.type.translation.ty",0.); AddParameter(ParameterType_Float,"transform.type.translation.scalex", "X scaling"); SetParameterDescription("transform.type.translation.scalex","Scaling factor between the output X spacing and the input X spacing"); SetDefaultParameterFloat("transform.type.translation.scalex",1.); AddParameter(ParameterType_Float,"transform.type.translation.scaley", "Y scaling"); SetParameterDescription("transform.type.translation.scaley","Scaling factor between the output Y spacing and the input Y spacing"); SetDefaultParameterFloat("transform.type.translation.scaley",1.); AddChoice("transform.type.rotation", "rotation"); SetParameterDescription("transform.type.rotation","rotation"); AddParameter(ParameterType_Float, "transform.type.rotation.angle", "Rotation angle"); SetParameterDescription("transform.type.rotation.angle","The rotation angle in degree (values between -180 and 180)"); SetDefaultParameterFloat("transform.type.rotation.angle",0.); AddParameter(ParameterType_Float, "transform.type.rotation.scalex", "X scaling"); SetParameterDescription("transform.type.rotation.scalex","Scale factor between the X spacing of the rotated output image and the X spacing of the unrotated image"); SetDefaultParameterFloat("transform.type.rotation.scalex",1.); AddParameter(ParameterType_Float, "transform.type.rotation.scaley", "Y scaling"); SetParameterDescription("transform.type.rotation.scaley","Scale factor between the Y spacing of the rotated output image and the Y spacing of the unrotated image"); SetDefaultParameterFloat("transform.type.rotation.scaley",1.); // Interpolators AddParameter(ParameterType_Choice, "interpolator", "Interpolation"); SetParameterDescription("interpolator","This group of parameters allows one to define how the input image will be interpolated during resampling."); AddChoice("interpolator.nn", "Nearest Neighbor interpolation"); SetParameterDescription("interpolator.nn","Nearest neighbor interpolation leads to poor image quality, but it is very fast."); AddChoice("interpolator.linear", "Linear interpolation"); SetParameterDescription("interpolator.linear","Linear interpolation leads to average image quality but is quite fast"); AddChoice("interpolator.bco", "Bicubic interpolation"); AddParameter(ParameterType_Radius, "interpolator.bco.radius", "Radius for bicubic interpolation"); SetParameterDescription("interpolator.bco.radius","This parameter allows controlling the size of the bicubic interpolation filter. If the target pixel size is higher than the input pixel size, increasing this parameter will reduce aliasing artifacts."); SetDefaultParameterInt("interpolator.bco.radius", 2); SetParameterString("interpolator","bco"); // RAM available AddRAMParameter("ram"); SetParameterDescription("ram","This allows setting the maximum amount of RAM available for processing. As the writing task is time consuming, it is better to write large pieces of data, which can be achieved by increasing this parameter (pay attention to your system capabilities)"); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_toulouse_sub.tif"); SetDocExampleParameterValue("out", "rigitTransformImage.tif"); SetDocExampleParameterValue("transform.type", "rotation"); SetDocExampleParameterValue("transform.type.rotation.angle", "20"); SetDocExampleParameterValue("transform.type.rotation.scalex", "2."); SetDocExampleParameterValue("transform.type.rotation.scaley", "2."); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType* inputImage = GetParameterImage("in"); m_Resampler = ResampleFilterType::New(); m_GridResampler = GridResampleFilterType::New(); m_Resampler->SetInput(inputImage); m_GridResampler->SetInput(inputImage); // Get Interpolator switch ( GetParameterInt("interpolator") ) { case Interpolator_Linear: { typedef itk::LinearInterpolateImageFunction LinearInterpolationType; LinearInterpolationType::Pointer interpolator = LinearInterpolationType::New(); m_Resampler->SetInterpolator(interpolator); } break; case Interpolator_NNeighbor: { typedef itk::NearestNeighborInterpolateImageFunction NearestNeighborInterpolationType; NearestNeighborInterpolationType::Pointer interpolator = NearestNeighborInterpolationType::New(); m_Resampler->SetInterpolator(interpolator); } break; case Interpolator_BCO: { typedef otb::BCOInterpolateImageFunction BCOInterpolationType; BCOInterpolationType::Pointer interpolator = BCOInterpolationType::New(); interpolator->SetRadius(GetParameterInt("interpolator.bco.radius")); m_Resampler->SetInterpolator(interpolator); } break; } // Get Transform switch ( GetParameterInt("transform.type") ) { case Transform_Identity: { m_GridResampler->SetOutputParametersFromImage( inputImage ); // Scale Transform OutputVectorType scale; scale[0] = 1.0 / GetParameterFloat("transform.type.id.scalex"); scale[1] = 1.0 / GetParameterFloat("transform.type.id.scaley"); // Evaluate spacing FloatVectorImageType::SpacingType spacing = inputImage->GetSpacing(); FloatVectorImageType::SpacingType OutputSpacing; OutputSpacing[0] = spacing[0] * scale[0]; OutputSpacing[1] = spacing[1] * scale[1]; m_GridResampler->SetOutputSpacing(OutputSpacing); FloatVectorImageType::PointType origin = inputImage->GetOrigin(); FloatVectorImageType::PointType outputOrigin; outputOrigin[0] = origin[0] + 0.5 * spacing[0] * (scale[0] - 1.0); outputOrigin[1] = origin[1] + 0.5 * spacing[1] * (scale[1] - 1.0); m_GridResampler->SetOutputOrigin(outputOrigin); // Evaluate size ResampleFilterType::SizeType recomputedSize; recomputedSize[0] = inputImage->GetLargestPossibleRegion().GetSize()[0] / scale[0]; recomputedSize[1] = inputImage->GetLargestPossibleRegion().GetSize()[1] / scale[1]; m_GridResampler->SetOutputSize(recomputedSize); otbAppLogINFO( << "Output image size : " << recomputedSize ); // Output Image SetParameterOutputImage("out", m_GridResampler->GetOutput()); } break; case Transform_Translation: { m_Resampler->SetOutputParametersFromImage(inputImage); TransformType::Pointer transform = TransformType::New(); TransformType::OutputVectorType offset; offset[0] = -1.0 * GetParameterFloat("transform.type.translation.tx"); // Offset is inverted to make transform from input cs. to output cs. offset[1] = -1.0 * GetParameterFloat("transform.type.translation.ty"); otbAppLogINFO( << "Offset (inverted to respect ITK transform convention e.g. from output space to input space) : " << offset ); transform->SetOffset(offset); // Scale Transform OutputVectorType scale; scale[0] = 1.0 / GetParameterFloat("transform.type.translation.scalex"); scale[1] = 1.0 / GetParameterFloat("transform.type.translation.scaley"); // Evaluate spacing FloatVectorImageType::SpacingType spacing = inputImage->GetSpacing(); FloatVectorImageType::SpacingType OutputSpacing; OutputSpacing[0] = spacing[0] * scale[0]; OutputSpacing[1] = spacing[1] * scale[1]; m_Resampler->SetOutputSpacing(OutputSpacing); FloatVectorImageType::PointType origin = inputImage->GetOrigin(); FloatVectorImageType::PointType outputOrigin; outputOrigin[0] = origin[0] + 0.5 * spacing[0] * (scale[0] - 1.0); outputOrigin[1] = origin[1] + 0.5 * spacing[1] * (scale[1] - 1.0); m_Resampler->SetOutputOrigin(outputOrigin); ResampleFilterType::SizeType recomputedSize; recomputedSize[0] = inputImage->GetLargestPossibleRegion().GetSize()[0] / scale[0]; recomputedSize[1] = inputImage->GetLargestPossibleRegion().GetSize()[1] / scale[1]; m_Resampler->SetOutputSize(recomputedSize); otbAppLogINFO( << "Output image size : " << recomputedSize ); m_Resampler->SetTransform(transform); // Output Image SetParameterOutputImage("out", m_Resampler->GetOutput()); } break; case Transform_Rotation: { ScalableTransformType::Pointer transform = ScalableTransformType::New(); FloatVectorImageType::SizeType inSize = inputImage->GetLargestPossibleRegion().GetSize(); FloatVectorImageType::SpacingType spacing = inputImage->GetSpacing(); itk::ContinuousIndex ULindex(inputImage->GetLargestPossibleRegion().GetIndex()); ULindex[0] += -0.5; ULindex[1] += -0.5; itk::ContinuousIndex center, URindex, LRindex, LLindex; center[0] = ULindex[0] + static_cast(inSize[0]) / 2.0; center[1] = ULindex[1] + static_cast(inSize[1]) / 2.0; URindex = ULindex; LRindex = ULindex; LLindex = ULindex; URindex[0] += inSize[0]; LRindex[0] += inSize[0]; LRindex[1] += inSize[1]; LLindex[1] += inSize[1]; FloatVectorImageType::PointType centerPoint; inputImage->TransformContinuousIndexToPhysicalPoint(center, centerPoint); //image boundary FloatVectorImageType::PointType ULpoint, URpoint, LRpoint, LLpoint; inputImage->TransformContinuousIndexToPhysicalPoint(ULindex, ULpoint); inputImage->TransformContinuousIndexToPhysicalPoint(URindex, URpoint); inputImage->TransformContinuousIndexToPhysicalPoint(LRindex, LRpoint); inputImage->TransformContinuousIndexToPhysicalPoint(LLindex, LLpoint); // Scale Transform OutputVectorType scale; scale[0] = 1.0 / GetParameterFloat("transform.type.rotation.scalex"); scale[1] = 1.0 / GetParameterFloat("transform.type.rotation.scaley"); //angle of rotation ScalarType rot_angle = GetParameterFloat("transform.type.rotation.angle"); if (rot_angle < -180 || rot_angle > 180) { itkExceptionMacro(<<"The rotation angle must value be between -180 and 180."); } transform->SetIdentity(); if(spacing[0] > 0 && spacing[1] > 0) transform->Rotate2D( rot_angle * CONST_PI_180 ); else transform->Rotate2D( - rot_angle * CONST_PI_180 ); transform->SetCenter( centerPoint ); // transform->Scale( scale ); // Scaling is done by modification of the output spacing //inverse transform ScalableTransformType::Pointer inverseTransform = ScalableTransformType::New(); transform->GetInverse(inverseTransform); m_Resampler->SetTransform(transform); FloatVectorImageType::PointType ULpointTrans, URpointTrans, LRpointTrans, LLpointTrans; ULpointTrans=inverseTransform->TransformPoint(ULpoint); URpointTrans=inverseTransform->TransformPoint(URpoint); LRpointTrans=inverseTransform->TransformPoint(LRpoint); LLpointTrans=inverseTransform->TransformPoint(LLpoint); //compute min and max std::vector voutput; voutput.push_back(ULpointTrans); voutput.push_back(URpointTrans); voutput.push_back(LRpointTrans); voutput.push_back(LLpointTrans); double minX = voutput[0][0]; double maxX = voutput[0][0]; double minY = voutput[0][1]; double maxY = voutput[0][1]; for(unsigned int i = 1; i voutput[i][0] ) { minX = voutput[i][0]; } if ( minY > voutput[i][1] ) { minY = voutput[i][1]; } // Sizes if ( maxX < voutput[i][0] ) { maxX = voutput[i][0]; } if ( maxY < voutput[i][1] ) { maxY = voutput[i][1]; } } FloatVectorImageType::PointType outputOrig; if( spacing[0] > 0 ) outputOrig[0] = minX; else outputOrig[0] = maxX; if( spacing[1] > 0 ) outputOrig[1] = minY; else outputOrig[1] = maxY; //size of output image FloatVectorImageType::PointType size; size[0]=vcl_abs(maxX-minX); size[1]=vcl_abs(maxY-minY); // Evaluate spacing FloatVectorImageType::SpacingType OutputSpacing; OutputSpacing[0] = scale[0] * spacing[0]; OutputSpacing[1] = scale[1] * spacing[1]; m_Resampler->SetOutputSpacing(OutputSpacing); outputOrig[0] += 0.5 * OutputSpacing[0]; outputOrig[1] += 0.5 * OutputSpacing[1]; m_Resampler->SetOutputOrigin(outputOrig); // Evaluate size ResampleFilterType::SizeType recomputedSize; recomputedSize[0] = static_cast(vcl_floor(vcl_abs(size[0]/OutputSpacing[0]))); recomputedSize[1] = static_cast(vcl_floor(vcl_abs(size[1]/OutputSpacing[1]))); m_Resampler->SetOutputSize( recomputedSize ); otbAppLogINFO( << "Output image size : " << recomputedSize ); // Output Image SetParameterOutputImage("out", m_Resampler->GetOutput()); } break; } FloatVectorImageType::PixelType defaultValue; itk::NumericTraits::SetLength(defaultValue, inputImage->GetNumberOfComponentsPerPixel()); m_Resampler->SetEdgePaddingValue(defaultValue); m_GridResampler->SetEdgePaddingValue(defaultValue); m_Resampler->UpdateOutputInformation(); m_GridResampler->UpdateOutputInformation(); } ResampleFilterType::Pointer m_Resampler; GridResampleFilterType::Pointer m_GridResampler; }; //class } //namespace wrapper } //namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::RigidTransformResample) OTB-release-5.8/Modules/Applications/AppProjection/app/otbSuperimpose.cxx000066400000000000000000000255501301006202600265640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbGenericRSResampleImageFilter.h" #include "otbGridResampleImageFilter.h" #include "otbImportGeoInformationImageFilter.h" #include "otbBCOInterpolateImageFunction.h" #include "itkNearestNeighborInterpolateImageFunction.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" #include "otbPleiadesPToXSAffineTransformCalculator.h" namespace otb { enum { Interpolator_BCO, Interpolator_NNeighbor, Interpolator_Linear }; namespace Wrapper { class Superimpose : public Application { public: /** Standard class typedefs. */ typedef Superimpose Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Superimpose, Application); typedef unsigned short int PixelType; typedef itk::LinearInterpolateImageFunction LinInterpolatorType; typedef itk::NearestNeighborInterpolateImageFunction NNInterpolatorType; typedef otb::BCOInterpolateImageFunction BCOInterpolatorType; typedef otb::GenericRSResampleImageFilter ResamplerType; typedef otb::ImportGeoInformationImageFilter ImportGeoInformationFilterType; typedef itk::ScalableAffineTransform TransformType; typedef otb::GridResampleImageFilter BasicResamplerType; private: void DoInit() ITK_OVERRIDE { SetName("Superimpose"); SetDescription("Using available image metadata, project one image onto another one"); // Documentation SetDocName("Superimpose sensor"); SetDocLongDescription("This application performs the projection of an image into the geometry of another one."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Geometry); AddDocTag("Superimposition"); AddParameter(ParameterType_InputImage, "inr", "Reference input"); SetParameterDescription("inr","The input reference image."); AddParameter(ParameterType_InputImage, "inm", "The image to reproject"); SetParameterDescription("inm","The image to reproject into the geometry of the reference input."); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); AddParameter(ParameterType_Float, "lms", "Spacing of the deformation field"); SetParameterDescription("lms","Generate a coarser deformation field with the given spacing"); SetDefaultParameterFloat("lms", 4.); MandatoryOff("lms"); AddParameter(ParameterType_OutputImage, "out", "Output image"); SetParameterDescription("out","Output reprojected image."); // Superposition mode AddParameter(ParameterType_Choice,"mode", "Mode"); SetParameterDescription("mode", "Superimposition mode"); AddChoice("mode.default", "Default mode"); SetParameterDescription("mode.default", "Default superimposition mode : " "uses any projection reference or sensor model found in the images"); AddChoice("mode.phr", "Pleiades mode"); SetParameterDescription("mode.phr", "Pleiades superimposition mode, " "designed for the case of a P+XS bundle in SENSOR geometry. It uses" " a simple transform on the XS image : a scaling and a residual " "translation."); // Interpolators AddParameter(ParameterType_Choice, "interpolator", "Interpolation"); SetParameterDescription("interpolator","This group of parameters allows defining how the input image will be interpolated during resampling."); AddChoice("interpolator.bco", "Bicubic interpolation"); SetParameterDescription("interpolator.bco", "Bicubic interpolation leads to very good image quality but is slow."); AddParameter(ParameterType_Radius, "interpolator.bco.radius", "Radius for bicubic interpolation"); SetParameterDescription("interpolator.bco.radius","This parameter allows controlling the size of the bicubic interpolation filter. If the target pixel size is higher than the input pixel size, increasing this parameter will reduce aliasing artifacts."); SetDefaultParameterInt("interpolator.bco.radius", 2); AddChoice("interpolator.nn", "Nearest Neighbor interpolation"); SetParameterDescription("interpolator.nn","Nearest neighbor interpolation leads to poor image quality, but it is very fast."); AddChoice("interpolator.linear", "Linear interpolation"); SetParameterDescription("interpolator.linear","Linear interpolation leads to average image quality but is quite fast"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("inr", "QB_Toulouse_Ortho_PAN.tif"); SetDocExampleParameterValue("inm", "QB_Toulouse_Ortho_XS.tif"); SetDocExampleParameterValue("out", "SuperimposedXS_to_PAN.tif"); } void DoUpdateParameters() ITK_OVERRIDE { if(!HasUserValue("mode") && HasValue("inr") && HasValue("inm") && otb::PleiadesPToXSAffineTransformCalculator::CanCompute(GetParameterImage("inr"),GetParameterImage("inm"))) { otbAppLogWARNING("Forcing PHR mode with PHR data. You need to add \"-mode default\" to force the default mode with PHR images."); SetParameterString("mode","phr"); } } void DoExecute() ITK_OVERRIDE { // Get the inputs FloatVectorImageType* refImage = GetParameterImage("inr"); FloatVectorImageType* movingImage = GetParameterImage("inm"); // Resample filter m_Resampler = ResamplerType::New(); m_BasicResampler = BasicResamplerType::New(); m_GeoImport = ImportGeoInformationFilterType::New(); // Get Interpolator switch ( GetParameterInt("interpolator") ) { case Interpolator_Linear: { LinInterpolatorType::Pointer interpolator = LinInterpolatorType::New(); m_Resampler->SetInterpolator(interpolator); m_BasicResampler->SetInterpolator(interpolator); } break; case Interpolator_NNeighbor: { NNInterpolatorType::Pointer interpolator = NNInterpolatorType::New(); m_Resampler->SetInterpolator(interpolator); m_BasicResampler->SetInterpolator(interpolator); } break; case Interpolator_BCO: { BCOInterpolatorType::Pointer interpolator = BCOInterpolatorType::New(); interpolator->SetRadius(GetParameterInt("interpolator.bco.radius")); m_Resampler->SetInterpolator(interpolator); m_BasicResampler->SetInterpolator(interpolator); } break; } // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // Set up output image information FloatVectorImageType::SpacingType spacing = refImage->GetSpacing(); FloatVectorImageType::IndexType start = refImage->GetLargestPossibleRegion().GetIndex(); FloatVectorImageType::SizeType size = refImage->GetLargestPossibleRegion().GetSize(); FloatVectorImageType::PointType origin = refImage->GetOrigin(); FloatVectorImageType::PixelType defaultValue; itk::NumericTraits::SetLength(defaultValue, movingImage->GetNumberOfComponentsPerPixel()); if(GetParameterString("mode")=="default") { if(IsParameterEnabled("lms")) { float defScalarSpacing = vcl_abs(GetParameterFloat("lms")); otbAppLogDEBUG("Generating coarse deformation field (spacing="<SetDisplacementFieldSpacing(defSpacing); } // Setup transform through projRef and Keywordlist m_Resampler->SetInputKeywordList(movingImage->GetImageKeywordlist()); m_Resampler->SetInputProjectionRef(movingImage->GetProjectionRef()); m_Resampler->SetOutputKeywordList(refImage->GetImageKeywordlist()); m_Resampler->SetOutputProjectionRef(refImage->GetProjectionRef()); m_Resampler->SetInput(movingImage); m_Resampler->SetOutputOrigin(origin); m_Resampler->SetOutputSpacing(spacing); m_Resampler->SetOutputSize(size); m_Resampler->SetOutputStartIndex(start); m_Resampler->SetEdgePaddingValue(defaultValue); // Set the output image SetParameterOutputImage("out", m_Resampler->GetOutput()); } else if(GetParameterString("mode")=="phr") { otbAppLogINFO("Using the PHR mode"); otb::PleiadesPToXSAffineTransformCalculator::TransformType::OffsetType offset = otb::PleiadesPToXSAffineTransformCalculator::ComputeOffset(GetParameterImage("inr"), GetParameterImage("inm")); m_BasicResampler->SetInput(movingImage); origin+=offset; origin[0]=origin[0]/4; origin[1]=origin[1]/4; m_BasicResampler->SetOutputOrigin(origin); FloatVectorImageType::SpacingType xsSpacing = GetParameterImage("inm")->GetSpacing(); xsSpacing*=0.25; m_BasicResampler->SetOutputSpacing(xsSpacing); m_BasicResampler->SetOutputSize(size); m_Resampler->SetOutputStartIndex(start); m_BasicResampler->SetEdgePaddingValue(defaultValue); m_GeoImport->SetInput(m_BasicResampler->GetOutput()); m_GeoImport->SetSource(refImage); // Set the output image SetParameterOutputImage("out", m_GeoImport->GetOutput()); } else { otbAppLogWARNING("Unknown mode"); } } ResamplerType::Pointer m_Resampler; BasicResamplerType::Pointer m_BasicResampler; ImportGeoInformationFilterType::Pointer m_GeoImport; }; } // end namespace Wrapper } // end namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::Superimpose) OTB-release-5.8/Modules/Applications/AppProjection/app/otbVectorDataReprojection.cxx000066400000000000000000000155621301006202600306730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbWrapperNumericalParameter.h" #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" // MapProjection handler #include "otbWrapperMapProjectionParametersHandler.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class VectorDataReprojection : public Application { public: /** Standard class typedefs. */ typedef VectorDataReprojection Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** filter typedef **/ typedef otb::GeometriesProjectionFilter ProjectionFilterType; typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; /** Standard macro */ itkNewMacro(Self) ; itkTypeMacro(VectorDataReprojection, otb::Application) ; private: void DoInit() ITK_OVERRIDE { SetName("VectorDataReprojection"); std::ostringstream oss; oss << "Reproject a vector data using support image projection reference" ", or a user specified map projection" << std::endl; SetDescription(oss.str()); // Documentation SetDocName("Vector Data reprojection"); oss.str(""); oss <<" This application allows reprojecting a vector data using support image projection reference" ", or a user given map projection." << std::endl; oss <<" If given, image keywordlist can be added to reprojected vectordata."; SetDocLongDescription(oss.str()); SetDocLimitations(" "); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Geometry); AddDocTag(Tags::Vector); AddDocTag(Tags::Coordinates); // Set the parameters AddParameter(ParameterType_Group, "in", "Input data"); AddParameter(ParameterType_InputFilename, "in.vd", "Input vector data"); SetParameterDescription("in.vd", "The input vector data to reproject"); AddParameter(ParameterType_InputImage, "in.kwl", "Use image keywords list"); SetParameterDescription("in.kwl", "Optional input image to fill vector data with image kwl."); MandatoryOff("in.kwl"); DisableParameter("in.kwl"); AddParameter(ParameterType_Group, "out", "Output data"); AddParameter(ParameterType_OutputFilename, "out.vd", "Output vector data"); SetParameterDescription("out.vd", "The reprojected vector data"); // output projection choice AddParameter(ParameterType_Choice, "out.proj", "Output Projection choice"); AddChoice("out.proj.image", "Use image projection ref"); SetParameterDescription("out.proj.image", "Vector data will be reprojected in image projection ref."); AddParameter(ParameterType_InputImage, "out.proj.image.in", "Image used to get projection map"); SetParameterDescription("out.proj.image.in", "Projection map will be found using image metadata"); AddChoice("out.proj.user", "User defined projection"); MapProjectionParametersHandler::AddMapProjectionParameters(this, "out.proj.user.map"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); // Doc example parameter settings SetDocExampleParameterValue("in.vd", "VectorData_QB1.shp"); SetDocExampleParameterValue("out.proj", "image"); SetDocExampleParameterValue("out.proj.image.in", "ROI_QB_MUL_1.tif"); SetDocExampleParameterValue("out.vd","reprojected_vd.shp"); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { GetLogger()->Debug("Entering DoExecute\n"); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // Get the input image otb::ogr::DataSource::Pointer OGRDSin = otb::ogr::DataSource::New(GetParameterString("in.vd"), otb::ogr::DataSource::Modes::Read); m_InputGeomSet = InputGeometriesType::New(OGRDSin); // Filter instantiation m_GeometriesProjFilter = ProjectionFilterType::New(); m_GeometriesProjFilter->SetInput(m_InputGeomSet); if (HasValue("in.kwl")) { FloatVectorImageType::Pointer inImage = GetParameterFloatVectorImage("in.kwl"); m_GeometriesProjFilter->SetInputOrigin(inImage->GetOrigin()); // nec qd capteur m_GeometriesProjFilter->SetInputSpacing(inImage->GetSpacing()); // nec qd capteur m_GeometriesProjFilter->SetInputKeywordList(inImage->GetImageKeywordlist()); //otbAppLogINFO(<<"kwl."<SetOutputOrigin(outImage->GetOrigin()); // nec qd capteur m_GeometriesProjFilter->SetOutputSpacing(outImage->GetSpacing()); // nec qd capteur m_OutputProjectionRef = outImage->GetProjectionRef(); // ~ wkt if (m_OutputProjectionRef.empty()) { m_GeometriesProjFilter->SetOutputKeywordList(outImage->GetImageKeywordlist()); // nec qd capteur } } else { // LogFATAl } } else { // Get the output projection Ref m_OutputProjectionRef = MapProjectionParametersHandler::GetProjectionRefFromChoice(this, "out.proj.user.map"); } otbAppLogINFO(<<"Geometries reprojection with following projection reference :" <SetOutputProjectionRef(m_OutputProjectionRef); OGRDSout = otb::ogr::DataSource::New(GetParameterString("out.vd"), otb::ogr::DataSource::Modes::Update_LayerOverwrite); m_OutputGeomSet = OutputGeometriesType::New(OGRDSout); m_GeometriesProjFilter->SetOutput(m_OutputGeomSet); m_GeometriesProjFilter->Update(); OGRDSout->SyncToDisk(); } otb::ogr::DataSource::Pointer OGRDSout; std::string m_OutputProjectionRef; ImageKeywordlist m_KeywordList; InputGeometriesType::Pointer m_InputGeomSet; OutputGeometriesType::Pointer m_OutputGeomSet; //FloatVectorImageType::Pointer m_inImage; // FloatVectorImageType::Pointer m_outImage; ProjectionFilterType::Pointer m_GeometriesProjFilter; }; } // namespace Wrapper } // namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::VectorDataReprojection) OTB-release-5.8/Modules/Applications/AppProjection/otb-module.cmake000066400000000000000000000006661301006202600253120ustar00rootroot00000000000000set(DOCUMENTATION "Projection application (see also Projection module).") otb_module(OTBAppProjection DEPENDS OTBGdalAdapters OTBImageManipulation OTBProjection OTBImageBase OTBTransform OTBOSSIMAdapters OTBCarto OTBApplicationEngine OTBMathParser OTBCommon OTBInterpolation OTBGDAL OTBITK TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppProjection/test/000077500000000000000000000000001301006202600232105ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppProjection/test/CMakeLists.txt000066400000000000000000000450641301006202600257610ustar00rootroot00000000000000otb_module_test() #----------- OrthoRectification TESTS ---------------- otb_test_application(NAME apTvPrOrthorectification_UTM_OutXML1 APP OrthoRectification OPTIONS -io.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} -io.out ${TEMP}/apTvPrOrthorectifTest_UTM_OutXML1.tif -elev.dem ${INPUTDATA}/DEM/srtm_directory/ -outputs.ulx 374100.8 -outputs.uly 4829184.8 -outputs.sizex 500 -outputs.sizey 500 -outputs.spacingx 0.5 -outputs.spacingy -0.5 -map utm -opt.gridspacing 4 # Spacing of the deformation field equal to 4 meters -outxml ${TEMP}/apTvPrOrthorectifTest_UTM_OutXML1.xml -interpolator linear VALID --compare-image ${EPSILON_4} ${BASELINE}/owTvOrthorectifTest_UTM.tif ${TEMP}/apTvPrOrthorectifTest_UTM_OutXML1.tif) otb_test_application(NAME apTvPrOrthorectification_UTM_InXML1 APP OrthoRectification OPTIONS -inxml ${INPUTDATA}/apTvPrOrthorectifTest_UTM_OutXML1.xml -io.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} -io.out ${TEMP}/apTvPrOrthorectifTest_UTM_InXML1.tif -elev.dem ${INPUTDATA}/DEM/srtm_directory/ VALID --compare-image ${EPSILON_4} ${BASELINE}/owTvOrthorectifTest_UTM.tif ${TEMP}/apTvPrOrthorectifTest_UTM_InXML1.tif) #otb_test_application(NAME apTvPrOrthorectification_DEMTIF_UTM_InXML1 #APP OrthoRectification #OPTIONS #-inxml ${INPUTDATA}/apTvPrOrthorectifTest_DEMTIF_UTM_OutXML1.xml #-io.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} #-io.out ${TEMP}/apTvPrOrthorectifTest_DEMTIF_UTM_InXML1.tif #-elev.dem ${INPUTDATA}/DEM/tif_directory/ #VALID --compare-image ${EPSILON_4} #${BASELINE}/owTvOrthorectifTest_UTM.tif #${TEMP}/apTvPrOrthorectifTest_DEMTIF_UTM_InXML1.tif) otb_test_application(NAME apTvPrOrthorectification_WGS84 APP OrthoRectification OPTIONS -io.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} -io.out ${TEMP}/apTvPrOrthorectifTest_WGS84.tif -elev.dem ${INPUTDATA}/DEM/srtm_directory/ -outputs.ulx 1.35404 -outputs.uly 43.65414 -outputs.sizex 500 -outputs.sizey 500 -outputs.spacingx 0.00000621314 -outputs.spacingy -0.00000621314 -map wgs -opt.gridspacing 0.00001242628 # Spacing of the deformation field equal to |2*outputs.spacingx| degrees -interpolator linear VALID --compare-image ${EPSILON_4} ${BASELINE}/owTvOrthorectifTest_WGS84.tif ${TEMP}/apTvPrOrthorectifTest_WGS84.tif ) otb_test_application(NAME apTvPrOrthorectification_UTM APP OrthoRectification OPTIONS -io.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} -io.out ${TEMP}/apTvPrOrthorectifTest_UTM.tif -elev.dem ${INPUTDATA}/DEM/srtm_directory/ -outputs.ulx 374100.8 -outputs.uly 4829184.8 -outputs.sizex 500 -outputs.sizey 500 -outputs.spacingx 0.5 -outputs.spacingy -0.5 -map utm -opt.gridspacing 4 # Spacing of the displacement field equal to 4 meters -interpolator linear VALID --compare-image ${EPSILON_4} ${BASELINE}/owTvOrthorectifTest_UTM.tif ${TEMP}/apTvPrOrthorectifTest_UTM.tif) #otb_test_application(NAME apTvPrOrthorectification_DEMTIF_UTM_OutXML1 #APP OrthoRectification #OPTIONS -io.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} #-io.out ${TEMP}/apTvPrOrthorectifTest_DEMTIF_UTM_OutXML1.tif #-elev.dem ${INPUTDATA}/DEM/tif_directory/ #-outputs.ulx 374100.8 #-outputs.uly 4829184.8 #-outputs.sizex 500 #-outputs.sizey 500 #-outputs.spacingx 0.5 #-outputs.spacingy -0.5 #-map utm #-opt.gridspacing 4 # Spacing of the deformation field equal to 4 meters #-outxml ${TEMP}/apTvPrOrthorectifTest_DEMTIF_UTM_OutXML1.xml #-interpolator linear #VALID --compare-image ${EPSILON_4} #${BASELINE}/owTvOrthorectifTest_UTM.tif #${TEMP}/apTvPrOrthorectifTest_DEMTIF_UTM_OutXML1.tif) #otb_test_application(NAME apTvPrOrthorectification_DEMTIF_UTM #APP OrthoRectification #OPTIONS -io.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} #-io.out ${TEMP}/apTvPrOrthorectifTest_DEMTIF_UTM.tif #-elev.dem ${INPUTDATA}/DEM/tif_directory/ #-outputs.ulx 374100.8 #-outputs.uly 4829184.8 #-outputs.sizex 500 #-outputs.sizey 500 #-outputs.spacingx 0.5 #-outputs.spacingy -0.5 #-map utm #-opt.gridspacing 4 # Spacing of the deformation field equal to 4 meters #-interpolator linear #VALID --compare-image ${EPSILON_4} #${BASELINE}/owTvOrthorectifTest_UTM.tif #${TEMP}/apTvPrOrthorectifTest_DEMTIF_UTM.tif) #----------- ConvertCartoToGeoPoint TESTS ---------------- otb_test_application(NAME apTvPrConvertCartoToGeoPoint APP ConvertCartoToGeoPoint OPTIONS -carto.x 374100.828 -carto.y 4829184.806 -mapproj utm -mapproj.utm.northhem true -mapproj.utm.zone 31 TESTENVOPTIONS ${TEMP}/apTvPrConvertCartoToGeoPoint.txt VALID --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/apTvPrConvertCartoToGeoPoint.txt ${TEMP}/apTvPrConvertCartoToGeoPoint.txt) #----------- GenerateRPCSensorModel TESTS ---------------- otb_test_application(NAME apTvPrGenerateRPCSensorModel APP GenerateRPCSensorModel OPTIONS -inpoints ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500_in_tie_points.txt -outgeom ${TEMP}/apTvPrGenerateRPCSensorModelGeomOutput.geom -outstat ${TEMP}/apTvPrGenerateRPCSensorModelStatsOutput.txt -outvector ${TEMP}/apTvPrGenerateRPCSensorModelVectorOutput.shp -map utm -map.utm.zone 31 -map.utm.northhem 1 -elev.dem ${INPUTDATA}/DEM/srtm_directory -elev.geoid ${INPUTDATA}/DEM/egm96.grd VALID --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/apTvPrGenerateRPCSensorModelGeomOutput.geom ${TEMP}/apTvPrGenerateRPCSensorModelGeomOutput.geom) #----------- GridBasedImageResampling TESTS ---------------- otb_test_application(NAME apTuDmGridBasedImageResamplingLeftTest APP GridBasedImageResampling OPTIONS -io.in ${EXAMPLEDATA}/sensor_stereo_left.tif -io.out ${TEMP}/apTvDmGridBasedImageResamplingLeftTest.tif -grid.in ${INPUTDATA}/sensor_stereo_rectif_left.tif -out.sizex 158 -out.sizey 158 ) otb_test_application(NAME apTuDmGridBasedImageResamplingRightTest APP GridBasedImageResampling OPTIONS -io.in ${EXAMPLEDATA}/sensor_stereo_right.tif -io.out ${TEMP}/apTvDmGridBasedImageResamplingRightTest.tif -grid.in ${INPUTDATA}/sensor_stereo_rectif_right.tif -out.sizex 158 -out.sizey 158 ) #----------- VectorDataReprojection TESTS ---------------- otb_test_application(NAME apTuPrVectorDataReprojectionFromImageToMap APP VectorDataReprojection OPTIONS -in.vd ${INPUTDATA}/ToulousePointsUTM31N.shp -in.kwl ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -out.vd ${TEMP}/apTvPrVectorDataReprojectionFromImageToMap.shp -out.proj user -out.proj.user.map utm -out.proj.user.map.utm.northhem true -out.proj.user.map.utm.zone 31) otb_test_application(NAME apTvPrVectorDataReprojectionFromMapToMap APP VectorDataReprojection OPTIONS -in.vd ${INPUTDATA}/ToulousePoints-examples.shp -out.vd ${TEMP}/apTvPrVectorDataReprojectionFromMapToMap.shp -out.proj user -out.proj.user.map lambert93 VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToMap.sqlite ${TEMP}/apTvPrVectorDataReprojectionFromMapToMap.shp) otb_test_application(NAME apTvPrVectorDataReprojectionFromMapToImage APP VectorDataReprojection OPTIONS -in.vd ${INPUTDATA}/ToulousePoints-examples.shp -out.vd ${TEMP}/apTvPrVectorDataReprojectionFromMapToImage.shp -out.proj image -out.proj.image.in ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToImage.shp ${TEMP}/apTvPrVectorDataReprojectionFromMapToImage.shp) otb_test_application(NAME apTvPrVectorDataReprojectionFromMapToSensor APP VectorDataReprojection OPTIONS -in.vd ${INPUTDATA}/ToulousePoints-examples.shp -out.vd ${TEMP}/apTvPrVectorDataReprojectionFromMapToSensor.shp -out.proj image -out.proj.image.in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToSensor.shp ${TEMP}/apTvPrVectorDataReprojectionFromMapToSensor.shp) otb_test_application(NAME apTvPrVectorDataReprojectionFromMapToMap2 APP VectorDataReprojection OPTIONS -in.vd ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToMap.sqlite -out.vd ${TEMP}/apTvPrVectorDataReprojectionFromMapToMap2.sqlite -out.proj user -out.proj.user.map utm -out.proj.user.map.utm.northhem true -out.proj.user.map.utm.zone 31 VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvPrVectorDataReprojectionFromMapToMap2.sqlite ${TEMP}/apTvPrVectorDataReprojectionFromMapToMap2.sqlite) otb_test_application(NAME apTvPrVectorDataReprojectionFromMapToGeo APP VectorDataReprojection OPTIONS -in.vd ${INPUTDATA}/ToulousePoints-examples.shp -out.vd ${TEMP}/apTvPrVectorDataReprojectionFromMapToGeo.kml -out.proj user -out.proj.user.map wgs VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToGeo.kml ${TEMP}/apTvPrVectorDataReprojectionFromMapToGeo.kml) otb_test_application(NAME apTuPrVectorDataReprojectionFromGeoToMap APP VectorDataReprojection OPTIONS -in.vd ${INPUTDATA}/ToulousePointsWGS.sqlite -out.vd ${TEMP}/apTvPrVectorDataReprojectionFromGeoToMap.shp -out.proj image -out.proj.image.in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif) #----------- ObtainUTMZoneFromGeoPoint TESTS ---------------- otb_test_application(NAME apTvPrObtainUTMZoneFromGeoPoint APP ObtainUTMZoneFromGeoPoint OPTIONS -lat 10.0 -lon 124.0 TESTENVOPTIONS ${TEMP}/apTvPrObtainUTMZoneFromGeoPoint.txt VALID --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/apTvPrObtainUTMZoneFromGeoPoint.txt ${TEMP}/apTvPrObtainUTMZoneFromGeoPoint.txt) #----------- RefineSensorModel TESTS ---------------- otb_test_application(NAME apTvPrRefineSensorModel APP RefineSensorModel OPTIONS -ingeom ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.geom -inpoints ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500_in_tie_points.txt -outgeom ${TEMP}/apTvPrRefineSensorModelGeomOutput.geom -outstat ${TEMP}/apTvPrRefineSensorModelStatsOutput.txt -outvector ${TEMP}/apTvPrRefineSensorModelVectorOutput.shp -map utm -map.utm.zone 31 -map.utm.northhem 1 -elev.dem ${INPUTDATA}/DEM/srtm_directory -elev.geoid ${INPUTDATA}/DEM/egm96.grd VALID --compare-ascii 0.1 ${BASELINE_FILES}/apTvPrRefineSensorModelGeomOutput.geom ${TEMP}/apTvPrRefineSensorModelGeomOutput.geom) otb_test_application(NAME apTvPrRefineSensorModel2 APP RefineSensorModel OPTIONS -ingeom ${INPUTDATA}/s1a-iw-grd-vh-20150210t060009-20150210t060034-004557-0059a3-002.geom -inpoints ${INPUTDATA}/pts_idV5.txt -outgeom ${TEMP}/apTvPrRefineSensorModelGeomOutput2.geom VALID --compare-ascii 0.1 ${BASELINE_FILES}/apTvPrRefineSensorModelGeomOutput2.geom ${TEMP}/apTvPrRefineSensorModelGeomOutput2.geom) #----------- RigidTransformResample TESTS ---------------- otb_test_application(NAME apTvPrRigidTransformResample APP RigidTransformResample OPTIONS -in ${INPUTDATA}/poupees.tif -out ${TEMP}/apTvPrRigidTransformResampleTest.tif -transform.type translation -transform.type.translation.tx -5 -transform.type.translation.ty 5 -interpolator nn VALID --compare-image ${NOTOL} ${BASELINE}/owTvRigidTransformResampleTest.tif ${TEMP}/apTvPrRigidTransformResampleTest.tif) #----------- ImageEnvelope TESTS ---------------- otb_test_application(NAME apTvPrImageEnvelopeTest APP ImageEnvelope OPTIONS -in ${EXAMPLEDATA}/sensor_stereo_left.tif -out ${TEMP}/apTvPrImageEnvelopeTest.shp VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvPrImageEnvelopeTest.shp ${TEMP}/apTvPrImageEnvelopeTest.shp) #----------- ConvertSensorToGeoPoint TESTS ---------------- otb_test_application(NAME apTvPrConvertSensorToGeoPoint APP ConvertSensorToGeoPoint OPTIONS -in ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -input.idx 500 -input.idy 500 TESTENVOPTIONS ${TEMP}/apTvPrConvertSensorToGeoPoint.txt VALID --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/apTvPrConvertSensorToGeoPoint.txt ${TEMP}/apTvPrConvertSensorToGeoPoint.txt) #----------- Superimpose TESTS ---------------- otb_test_application(NAME apTvPrSuperimpose APP Superimpose OPTIONS -inr ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -inm ${INPUTDATA}/QB_Toulouse_Ortho_XS_ROI_170x230.tif -elev.dem ${INPUTDATA}/DEM/srtm_directory -out ${TEMP}/apTvPrSuperimpose.tif int16 VALID --compare-image ${EPSILON_7} ${BASELINE}/apTvPrSuperimpose.tif ${TEMP}/apTvPrSuperimpose.tif) otb_test_application(NAME apTvPrSuperimpose_phr APP Superimpose OPTIONS -inr ${INPUTDATA}/phr_pan.tif -inm ${INPUTDATA}/phr_xs.tif -out ${TEMP}/apTvPrSuperimposePHR.tif int16 VALID --compare-image ${EPSILON_7} ${BASELINE}/apTvPrSuperimposePHR.tif ${TEMP}/apTvPrSuperimposePHR.tif) OTB-release-5.8/Modules/Applications/AppSARCalibration/000077500000000000000000000000001301006202600227125ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARCalibration/CMakeLists.txt000066400000000000000000000000601301006202600254460ustar00rootroot00000000000000project(OTBAppSARCalibration) otb_module_impl() OTB-release-5.8/Modules/Applications/AppSARCalibration/app/000077500000000000000000000000001301006202600234725ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARCalibration/app/CMakeLists.txt000066400000000000000000000006321301006202600262330ustar00rootroot00000000000000set(OTBAppSARCalibration_LINK_LIBS ${OTBSARCalibration_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ) otb_create_application( NAME SarRadiometricCalibration SOURCES otbSarRadiometricCalibration.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME SARCalibration SOURCES otbSARCalibration.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppSARCalibration/app/otbSARCalibration.cxx000066400000000000000000000110541301006202600275210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbSarRadiometricCalibrationToImageFilter.h" namespace otb { namespace Wrapper { class SARCalibration : public Application { public: /** Standard class typedefs. */ typedef SARCalibration Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SARCalibration, otb::Application); typedef otb::SarRadiometricCalibrationToImageFilter CalibrationFilterType; private: void DoInit() ITK_OVERRIDE { SetName("SARCalibration"); SetDescription("Perform radiometric calibration of SAR images. Following sensors are supported: TerraSAR-X, Sentinel1 and Radarsat-2.Both Single Look Complex(SLC) and detected products are supported as input.\n"); // Documentation SetDocName("SAR Radiometric calibration"); SetDocLongDescription("The objective of SAR calibration is to provide imagery in which the pixel values can be directly related to the radar backscatter of the scene. This application allows computing Sigma Naught (Radiometric Calibration) for TerraSAR-X, Sentinel1 L1 and Radarsat-2 sensors. Metadata are automatically retrieved from image products.The application supports complex and non-complex images (SLC or detected products).\n"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Calibration); AddDocTag(Tags::SAR); AddParameter(ParameterType_ComplexInputImage, "in", "Input Image"); SetParameterDescription("in", "Input complex image"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output calibrated image. This image contains the backscatter (sigmaNought) of the input image."); AddRAMParameter(); AddParameter(ParameterType_Empty, "noise", "Disable Noise"); SetParameterDescription("noise", "Flag to disable noise. For 5.2.0 release, the noise values are only read by TerraSARX product."); MandatoryOff("noise"); AddParameter(ParameterType_Choice, "lut", "Lookup table sigma /gamma/ beta/ DN."); SetParameterDescription("lut", "Lookup table values are not available with all SAR products. Products that provide lookup table with metadata are: Sentinel1, Radarsat2."); AddChoice("lut.sigma", "Use sigma nought lookup"); SetParameterDescription("lut.sigma","Use Sigma nought lookup value from product metadata"); AddChoice("lut.gamma", "Use gamma nought lookup"); SetParameterDescription("lut.gamma","Use Gamma nought lookup value from product metadata"); AddChoice("lut.beta", "Use beta nought lookup"); SetParameterDescription("lut.beta","Use Beta nought lookup value from product metadata"); AddChoice("lut.dn", "Use DN value lookup"); SetParameterDescription("lut.dn","Use DN value lookup value from product metadata"); SetDefaultParameterInt("lut", 0); // Doc example parameter settings SetDocExampleParameterValue("in", "RSAT_imagery_HH.tif"); SetDocExampleParameterValue("out", "SarRadiometricCalibration.tif" ); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { // Get the input complex image ComplexFloatImageType* floatComplexImage = GetParameterComplexFloatImage("in"); // Set the filer input m_CalibrationFilter = CalibrationFilterType::New(); m_CalibrationFilter->SetInput(floatComplexImage); if (IsParameterEnabled("noise")) { m_CalibrationFilter->SetEnableNoise(false); } short lut = 0; lut = GetParameterInt("lut"); m_CalibrationFilter->SetLookupSelected(lut); // Set the output image SetParameterOutputImage("out", m_CalibrationFilter->GetOutput()); } CalibrationFilterType::Pointer m_CalibrationFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::SARCalibration) OTB-release-5.8/Modules/Applications/AppSARCalibration/app/otbSarRadiometricCalibration.cxx000066400000000000000000000115031301006202600320030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbSarRadiometricCalibrationToImageFilter.h" namespace otb { namespace Wrapper { class SarRadiometricCalibration : public Application { public: /** Standard class typedefs. */ typedef SarRadiometricCalibration Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SarRadiometricCalibration, otb::Application); typedef otb::SarRadiometricCalibrationToImageFilter CalibrationFilterType; private: void DoInit() ITK_OVERRIDE { SetName("SarRadiometricCalibration"); SetDescription("Perform radiometric calibration of SAR images. Following sensors are supported: TerraSAR-X, Sentinel1 and Radarsat-2.Both Single Look Complex(SLC) and detected products are supported as input.\n"); // Documentation SetDocName("SAR Radiometric calibration (DEPRECATED)"); SetDocLongDescription("The objective of SAR calibration is to provide imagery in which the pixel values can be directly related to the radar backscatter of the scene. This application allows computing Sigma Naught (Radiometric Calibration) for TerraSAR-X, Sentinel1 L1 and Radarsat-2 sensors. Metadata are automatically retrieved from image products.The application supports complex and non-complex images (SLC or detected products).\n"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Calibration); AddDocTag(Tags::SAR); AddParameter(ParameterType_ComplexInputImage, "in", "Input Image"); SetParameterDescription("in", "Input complex image"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output calibrated image. This image contains the backscatter (sigmaNought) of the input image."); AddRAMParameter(); AddParameter(ParameterType_Empty, "noise", "Disable Noise"); SetParameterDescription("noise", "Flag to disable noise. For 5.2.0 release, the noise values are only read by TerraSARX product."); MandatoryOff("noise"); AddParameter(ParameterType_Choice, "lut", "Lookup table sigma /gamma/ beta/ DN."); SetParameterDescription("lut", "Lookup table values are not available with all SAR products. Products that provide lookup table with metadata are: Sentinel1, Radarsat2."); AddChoice("lut.sigma", "Use sigma nought lookup"); SetParameterDescription("lut.sigma","Use Sigma nought lookup value from product metadata"); AddChoice("lut.gamma", "Use gamma nought lookup"); SetParameterDescription("lut.gamma","Use Gamma nought lookup value from product metadata"); AddChoice("lut.beta", "Use beta nought lookup"); SetParameterDescription("lut.beta","Use Beta nought lookup value from product metadata"); AddChoice("lut.dn", "Use DN value lookup"); SetParameterDescription("lut.dn","Use DN value lookup value from product metadata"); SetDefaultParameterInt("lut", 0); // Doc example parameter settings SetDocExampleParameterValue("in", "RSAT_imagery_HH.tif"); SetDocExampleParameterValue("out", "SarRadiometricCalibration.tif" ); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { otbAppLogWARNING("This application is deprecated, it will be renamed in next" " version of OTB. Please consider using the renamed copy SARCalibration." " Parameters and behaviour are identic."); // Get the input complex image ComplexFloatImageType* floatComplexImage = GetParameterComplexFloatImage("in"); // Set the filer input m_CalibrationFilter = CalibrationFilterType::New(); m_CalibrationFilter->SetInput(floatComplexImage); if (IsParameterEnabled("noise")) { m_CalibrationFilter->SetEnableNoise(false); } short lut = 0; lut = GetParameterInt("lut"); m_CalibrationFilter->SetLookupSelected(lut); // Set the output image SetParameterOutputImage("out", m_CalibrationFilter->GetOutput()); } CalibrationFilterType::Pointer m_CalibrationFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::SarRadiometricCalibration) OTB-release-5.8/Modules/Applications/AppSARCalibration/otb-module.cmake000066400000000000000000000003551301006202600257660ustar00rootroot00000000000000set(DOCUMENTATION "SAR Calibration application.") otb_module(OTBAppSARCalibration DEPENDS OTBSARCalibration OTBApplicationEngine TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppSARCalibration/test/000077500000000000000000000000001301006202600236715ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARCalibration/test/CMakeLists.txt000066400000000000000000000016371301006202600264400ustar00rootroot00000000000000otb_module_test() #----------- SarRadiometricCalibration TESTS ---------------- otb_test_application(NAME apTvRaSarRadiometricCalibration_SENTINEL1 APP SARCalibration OPTIONS -in ${INPUTDATA}/SENTINEL1_SLC_S6_1S_extract_300_300.tif?&geom=${INPUTDATA}/SENTINEL1_SLC_S6_1S_extract_300_300.geom -out ${TEMP}/apTvRaSarRadiometricCalibration_SENTINEL1.tif VALID --compare-image ${NOTOL} ${BASELINE}/raTvSarRadiometricCalibration_SENTINEL1.tif ${TEMP}/apTvRaSarRadiometricCalibration_SENTINEL1.tif ) otb_test_application(NAME apTvRaSarRadiometricCalibration_RADARSAT2 APP SARCalibration OPTIONS -in ${INPUTDATA}/RADARSAT2_ALTONA_300_300_VV.tif?&geom=${INPUTDATA}/RADARSAT2_ALTONA_300_300_VV.geom -out ${TEMP}/apTvRaSarRadiometricCalibration_RADARSAT2.tif VALID --compare-image ${EPSILON_5} ${BASELINE}/raTvSarRadiometricCalibration_RADARSAT2.tif ${TEMP}/apTvRaSarRadiometricCalibration_RADARSAT2.tif ) OTB-release-5.8/Modules/Applications/AppSARDecompositions/000077500000000000000000000000001301006202600234625ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARDecompositions/CMakeLists.txt000066400000000000000000000000631301006202600262210ustar00rootroot00000000000000project(OTBAppSARDecompositions) otb_module_impl() OTB-release-5.8/Modules/Applications/AppSARDecompositions/app/000077500000000000000000000000001301006202600242425ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARDecompositions/app/CMakeLists.txt000066400000000000000000000004661301006202600270100ustar00rootroot00000000000000set(OTBAppFiltering_LINK_LIBS ${OTBPolarimetry_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBImageBase_LIBRARIES} ) otb_create_application( NAME SARDecompositions SOURCES otbSARDecompositions.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppSARDecompositions/app/otbSARDecompositions.cxx000066400000000000000000000256451301006202600310540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbReciprocalHAlphaImageFilter.h" #include "otbReciprocalBarnesDecompImageFilter.h" #include "otbReciprocalHuynenDecompImageFilter.h" #include "otbReciprocalPauliDecompImageFilter.h" #include "otbSinclairReciprocalImageFilter.h" #include "otbSinclairToReciprocalCoherencyMatrixFunctor.h" #include "otbPerBandVectorImageFilter.h" #include "itkMeanImageFilter.h" #include "otbNRIBandImagesToOneNComplexBandsImage.h" #include "otbImageListToVectorImageFilter.h" #include "otbImageList.h" namespace otb { namespace Wrapper { class SARDecompositions : public Application { public: /** Standard class typedefs. */ typedef SARDecompositions Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::Functor::SinclairToReciprocalCoherencyMatrixFunctor FunctorType; typedef SinclairReciprocalImageFilter SRFilterType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::PerBandVectorImageFilter PerBandMeanFilterType; //typedef otb::NRIBandImagesToOneNComplexBandsImage NRITOOneCFilterType; typedef otb::ImageList ImageListType; typedef ImageListToVectorImageFilter ListConcatenerFilterType; typedef otb::ReciprocalHAlphaImageFilter HAFilterType; typedef otb::ReciprocalBarnesDecompImageFilter BarnesFilterType; typedef otb::ReciprocalHuynenDecompImageFilter HuynenFilterType; typedef otb::ReciprocalPauliDecompImageFilter PauliFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SARDecompositions, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("SARDecompositions"); SetDescription("From one-band complex images (each one related to an element of the Sinclair matrix), returns the selected decomposition."); // Documentation SetDocName("SARDecompositions"); SetDocLongDescription("From one-band complex images (HH, HV, VH, VV), returns the selected decomposition.\n \n" "All the decompositions implemented are intended for the mono-static case (transmitter and receiver are co-located).\n" "There are two kinds of decomposition : coherent ones and incoherent ones.\n" "In the coherent case, only the Pauli decomposition is available.\n" "In the incoherent case, there the decompositions available : Huynen, Barnes, and H-alpha-A.\n" "User must provide three one-band complex images HH, HV or VH, and VV (mono-static case <=> HV = VH).\n" "Incoherent decompositions consist in averaging 3x3 complex coherency/covariance matrices; the user must provide the size of the averaging window, thanks to the parameter inco.kernelsize.\n " ); SetDocLimitations("Some decompositions output real images, while this application outputs complex images for general purpose.\n" "Users should pay attention to extract the real part of the results provided by this application.\n"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("SARPolarMatrixConvert, SARPolarSynth"); AddDocTag(Tags::SAR); AddParameter(ParameterType_ComplexInputImage, "inhh", "Input Image"); SetParameterDescription("inhh", "Input image (HH)"); AddParameter(ParameterType_ComplexInputImage, "inhv", "Input Image"); SetParameterDescription("inhv", "Input image (HV)"); MandatoryOff("inhv"); AddParameter(ParameterType_ComplexInputImage, "invh", "Input Image"); SetParameterDescription("invh", "Input image (VH)"); MandatoryOff("invh"); AddParameter(ParameterType_ComplexInputImage, "invv", "Input Image"); SetParameterDescription("invv", "Input image (VV)"); AddParameter(ParameterType_ComplexOutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image"); AddParameter(ParameterType_Choice, "decomp", "Decompositions"); AddChoice("decomp.haa","H-alpha-A incoherent decomposition"); SetParameterDescription("decomp.haa","H-alpha-A incoherent decomposition"); AddChoice("decomp.barnes","Barnes incoherent decomposition"); SetParameterDescription("decomp.barnes","Barnes incoherent decomposition"); AddChoice("decomp.huynen","Huynen incoherent decomposition"); SetParameterDescription("decomp.huynen","Huynen incoherent decomposition"); AddChoice("decomp.pauli","Pauli coherent decomposition"); SetParameterDescription("decomp.pauli","Pauli coherent decomposition"); AddParameter(ParameterType_Group,"inco","Incoherent decompositions"); SetParameterDescription("inco","This group allows setting parameters related to the incoherent decompositions."); AddParameter(ParameterType_Int, "inco.kernelsize", "Kernel size for spatial incoherent averaging."); SetParameterDescription("inco.kernelsize", "Minute (0-59)"); SetMinimumParameterIntValue("inco.kernelsize", 1); SetDefaultParameterInt("inco.kernelsize", 3); MandatoryOff("inco.kernelsize"); AddRAMParameter(); // Default values SetDefaultParameterInt("decomp", 0); // H-alpha-A // Doc example parameter settings SetDocExampleParameterValue("inhh", "HH.tif"); SetDocExampleParameterValue("invh", "VH.tif"); SetDocExampleParameterValue("invv", "VV.tif"); SetDocExampleParameterValue("decomp", "haa"); SetDocExampleParameterValue("out", "HaA.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { bool inhv = HasUserValue("inhv"); bool invh = HasUserValue("invh"); if ( (!inhv) && (!invh) ) otbAppLogFATAL( << "Parameter inhv or invh not set. Please provide a HV or a VH complex image."); m_SRFilter = SRFilterType::New(); m_HAFilter = HAFilterType::New(); m_MeanFilter = PerBandMeanFilterType::New(); MeanFilterType::InputSizeType radius; m_BarnesFilter = BarnesFilterType::New(); m_HuynenFilter = HuynenFilterType::New(); m_PauliFilter = PauliFilterType::New(); m_Concatener = ListConcatenerFilterType::New(); m_ImageList = ImageListType::New(); switch (GetParameterInt("decomp")) { case 0: // H-alpha-A if (inhv) m_SRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("inhv")); else if (invh) m_SRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("invh")); m_SRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_SRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); radius.Fill( GetParameterInt("inco.kernelsize") ); m_MeanFilter->GetFilter()->SetRadius(radius); m_MeanFilter->SetInput(m_SRFilter->GetOutput()); m_HAFilter->SetInput(m_MeanFilter->GetOutput()); SetParameterComplexOutputImage("out", m_HAFilter->GetOutput() ); break; case 1: // Barnes if (inhv) m_SRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("inhv")); else if (invh) m_SRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("invh")); m_SRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_SRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); radius.Fill( GetParameterInt("inco.kernelsize") ); m_MeanFilter->GetFilter()->SetRadius(radius); m_MeanFilter->SetInput(m_SRFilter->GetOutput()); m_BarnesFilter->SetInput(m_MeanFilter->GetOutput()); SetParameterComplexOutputImage("out", m_BarnesFilter->GetOutput() ); break; case 2: // Huynen if (inhv) m_SRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("inhv")); else if (invh) m_SRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("invh")); m_SRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_SRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); radius.Fill( GetParameterInt("inco.kernelsize") ); m_MeanFilter->GetFilter()->SetRadius(radius); m_MeanFilter->SetInput(m_SRFilter->GetOutput()); m_HuynenFilter->SetInput(m_MeanFilter->GetOutput()); SetParameterComplexOutputImage("out", m_HuynenFilter->GetOutput() ); break; case 3: // Pauli m_ImageList->PushBack(GetParameterComplexDoubleImage("inhh")); if (inhv) m_ImageList->PushBack(GetParameterComplexDoubleImage("inhv")); else if (invh) m_ImageList->PushBack(GetParameterComplexDoubleImage("invh")); m_ImageList->PushBack(GetParameterComplexDoubleImage("invv")); m_Concatener->SetInput( m_ImageList ); m_PauliFilter->SetInput(m_Concatener->GetOutput()); SetParameterComplexOutputImage("out", m_PauliFilter->GetOutput() ); break; } } //MCPSFilterType::Pointer m_MCPSFilter; SRFilterType::Pointer m_SRFilter; HAFilterType::Pointer m_HAFilter; BarnesFilterType::Pointer m_BarnesFilter; HuynenFilterType::Pointer m_HuynenFilter; PauliFilterType::Pointer m_PauliFilter; PerBandMeanFilterType::Pointer m_MeanFilter; ListConcatenerFilterType::Pointer m_Concatener; ImageListType::Pointer m_ImageList; }; } //end namespace Wrapper } //end namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::SARDecompositions) OTB-release-5.8/Modules/Applications/AppSARDecompositions/otb-module.cmake000066400000000000000000000004341301006202600265340ustar00rootroot00000000000000set(DOCUMENTATION "Basic filters application.") otb_module(OTBAppSARDecompositions DEPENDS OTBPolarimetry OTBImageManipulation OTBITK OTBApplicationEngine OTBImageBase TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppSARDecompositions/test/000077500000000000000000000000001301006202600244415ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARDecompositions/test/CMakeLists.txt000066400000000000000000000032001301006202600271740ustar00rootroot00000000000000otb_module_test() #----------- SARDecompositions TESTS ---------------- otb_test_application(NAME apTvSARDecompositionsHAAlpha APP SARDecompositions OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -decomp haa -out ${TEMP}/apTvReciprocalHAlpha.tif ) otb_test_application(NAME apTvSARDecompositionsBarnes APP SARDecompositions OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -decomp barnes -out ${TEMP}/apTvReciprocalBarnes.tif ) otb_test_application(NAME apTvSARDecompositionsHuynen APP SARDecompositions OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -decomp huynen -out ${TEMP}/apTvReciprocalHuynen.tif ) otb_test_application(NAME apTvSARDecompositionsPauli APP SARDecompositions OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -decomp pauli -out ${TEMP}/apTvReciprocalPauli.tif ) OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/000077500000000000000000000000001301006202600242665ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/CMakeLists.txt000066400000000000000000000000671301006202600270310ustar00rootroot00000000000000project(OTBAppSARPolarMatrixConvert) otb_module_impl() OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/app/000077500000000000000000000000001301006202600250465ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/app/CMakeLists.txt000066400000000000000000000004761301006202600276150ustar00rootroot00000000000000set(OTBAppFiltering_LINK_LIBS ${OTBPolarimetry_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBImageBase_LIBRARIES} ) otb_create_application( NAME SARPolarMatrixConvert SOURCES otbSARPolarMatrixConvert.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/app/otbSARPolarMatrixConvert.cxx000066400000000000000000000707651301006202600324670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" //monostatic case #include "otbSinclairReciprocalImageFilter.h" #include "otbSinclairToReciprocalCoherencyMatrixFunctor.h" #include "otbSinclairToReciprocalCovarianceMatrixFunctor.h" #include "otbSinclairToReciprocalCircularCovarianceMatrixFunctor.h" #include "otbReciprocalCoherencyToReciprocalMuellerImageFilter.h" #include "otbReciprocalCovarianceToCoherencyDegreeImageFilter.h" #include "otbReciprocalCovarianceToReciprocalCoherencyImageFilter.h" #include "otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter.h" //bistatic case #include "otbSinclairImageFilter.h" #include "otbSinclairToCoherencyMatrixFunctor.h" #include "otbSinclairToCovarianceMatrixFunctor.h" #include "otbSinclairToCircularCovarianceMatrixFunctor.h" #include "otbSinclairToMuellerMatrixFunctor.h" #include "otbMuellerToReciprocalCovarianceImageFilter.h" #include "otbMuellerToPolarisationDegreeAndPowerImageFilter.h" namespace otb { namespace Wrapper { class SARPolarMatrixConvert : public Application { public: /** Standard class typedefs. */ typedef SARPolarMatrixConvert Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //Monostatic case typedef otb::Functor::SinclairToReciprocalCoherencyMatrixFunctor RCoherencyFunctorType; typedef otb::Functor::SinclairToReciprocalCovarianceMatrixFunctor RCovarianceFunctorType; typedef otb::Functor::SinclairToReciprocalCircularCovarianceMatrixFunctor RCircularCovarianceFunctorType; typedef SinclairReciprocalImageFilter RCohSRFilterType; typedef SinclairReciprocalImageFilter RCovSRFilterType; typedef SinclairReciprocalImageFilter RCCSRFilterType; typedef otb::ReciprocalCoherencyToReciprocalMuellerImageFilter RCRMFilterType; typedef otb::ReciprocalCovarianceToCoherencyDegreeImageFilter RCCDFilterType; typedef otb::ReciprocalCovarianceToReciprocalCoherencyImageFilter RCRCFilterType; typedef otb::ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter RLCRCCFilterType; //Bistatic case typedef otb::Functor::SinclairToCoherencyMatrixFunctor CoherencyFunctorType; typedef otb::Functor::SinclairToCovarianceMatrixFunctor CovarianceFunctorType; typedef otb::Functor::SinclairToCircularCovarianceMatrixFunctor CircularCovarianceFunctorType; typedef otb::Functor::SinclairToMuellerMatrixFunctor MuellerFunctorType; typedef SinclairImageFilter CohSRFilterType; typedef SinclairImageFilter CovSRFilterType; typedef SinclairImageFilter CCSRFilterType; typedef SinclairImageFilter MSRFilterType; typedef otb::MuellerToReciprocalCovarianceImageFilter MRCFilterType; typedef otb::MuellerToPolarisationDegreeAndPowerImageFilter MPDPFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SARPolarMatrixConvert, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("SARPolarMatrixConvert"); SetDescription("This applications allows converting classical polarimetric matrices to each other."); // Documentation SetDocName("SARPolarMatrixConvert"); SetDocLongDescription( "This application allows converting classical polarimetric matrices to each other.\n" "For instance, it is possible to get the coherency matrix from the Sinclar one, or the Mueller matrix from the coherency one.\n" "The filters used in this application never handle matrices, but images where each band is related to their elements.\n" "As most of the time SAR polarimetry handles symmetric/hermitian matrices, only the relevant elements are stored, so that the images representing them have a minimal number of bands.\n" "For instance, the coherency matrix size is 3x3 in the monostatic case, and 4x4 in the bistatic case : it will thus be stored in a 6-band or a 10-band complex image (the diagonal and the upper elements of the matrix).\n" "\n" "The Sinclair matrix is a special case : it is always represented as 3 or 4 one-band complex images (for mono- or bistatic case).\n" "The available conversions are listed below:\n" "\n--- Monostatic case ---\n" "1 msinclairtocoherency --> Sinclair matrix to coherency matrix (input : 3 x 1 complex channel (HH, HV or VH, VV) | output : 6 complex channels)\n" "2 msinclairtocovariance --> Sinclair matrix to covariance matrix (input : 3 x 1 complex channel (HH, HV or VH, VV) | output : 6 complex channels)\n" "3 msinclairtocircovariance --> Sinclair matrix to circular covariance matrix (input : 3 x 1 complex channel (HH, HV or VH, VV) | output : 6 complex channels)\n" "4 mcoherencytomueller --> Coherency matrix to Mueller matrix (input : 6 complex channels | 16 real channels)\n" "5 mcovariancetocoherencydegree --> Covariance matrix to coherency degree (input : 6 complex channels | 3 complex channels)\n" "6 mcovariancetocoherency --> Covariance matrix to coherency matrix (input : 6 complex channels | 6 complex channels)\n" "7 mlinearcovariancetocircularcovariance --> Covariance matrix to circular covariance matrix (input : 6 complex channels | output : 6 complex channels)\n" "\n--- Bistatic case ---\n" "8 bsinclairtocoherency --> Sinclair matrix to coherency matrix (input : 4 x 1 complex channel (HH, HV, VH, VV) | 10 complex channels)\n" "9 bsinclairtocovariance --> Sinclair matrix to covariance matrix (input : 4 x 1 complex channel (HH, HV, VH, VV) | output : 10 complex channels)\n" "10 bsinclairtocircovariance --> Sinclair matrix to circular covariance matrix (input : 4 x 1 complex channel (HH, HV, VH, VV) | output : 10 complex channels)\n" "\n--- Both cases ---\n" "11 sinclairtomueller --> Sinclair matrix to Mueller matrix (input : 4 x 1 complex channel (HH, HV, VH, VV) | output : 16 real channels)\n" "12 muellertomcovariance --> Mueller matrix to covariance matrix (input : 16 real channels | output : 6 complex channels)\n" "13 muellertopoldegandpower --> Mueller matrix to polarization degree and power (input : 16 real channels | output : 4 real channels)\n" ); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("SARPolarSynth, SARDecompositions"); AddDocTag(Tags::SAR); AddParameter(ParameterType_ComplexInputImage, "inc", "Input : multi-band complex image"); SetParameterDescription("inc", "Input : multi-band complex image"); MandatoryOff("inc"); AddParameter(ParameterType_InputImage, "inf", "Input : multi-band real image"); SetParameterDescription("inf", "Input : multi-band real image"); MandatoryOff("inf"); AddParameter(ParameterType_ComplexInputImage, "inhh", "Input : one-band complex image (HH)"); SetParameterDescription("inhh", "Input : one-band complex image (HH)"); MandatoryOff("inhh"); AddParameter(ParameterType_ComplexInputImage, "inhv", "Input : one-band complex image (HV)"); SetParameterDescription("inhv", "Input : one-band complex image (HV)"); MandatoryOff("inhv"); AddParameter(ParameterType_ComplexInputImage, "invh", "Input : one-band complex image (VH)"); SetParameterDescription("invh", "Input : one-band complex image (VH)"); MandatoryOff("invh"); AddParameter(ParameterType_ComplexInputImage, "invv", "Input : one-band complex image (VV)"); SetParameterDescription("invv", "Input : one-band complex image (VV)"); MandatoryOff("invv"); AddParameter(ParameterType_ComplexOutputImage, "outc", "Output Complex Image"); SetParameterDescription("outc", "Output Complex image."); MandatoryOff("outc"); AddParameter(ParameterType_OutputImage, "outf", "Output Real Image"); SetParameterDescription("outf", "Output Real image."); MandatoryOff("outf"); AddParameter(ParameterType_Choice, "conv", "Conversion"); //Monostatic case // #1 // SinclairToReciprocalCoherency AddChoice("conv.msinclairtocoherency","1 Monostatic : Sinclair matrix to coherency matrix (complex output)"); SetParameterDescription("conv.msinclairtocoherency","1 Monostatic :Sinclair matrix to coherency matrix (complex output)"); // #2 // SinclairToReciprocalCovariance AddChoice("conv.msinclairtocovariance","2 Monostatic : Sinclair matrix to covariance matrix (complex output)"); SetParameterDescription("conv.msinclairtocovariance","2 Monostatic : Sinclair matrix to covariance matrix (complex output)"); // #3 // SinclairToReciprocalCircularCovariance AddChoice("conv.msinclairtocircovariance","3 Monostatic : Sinclair matrix to circular covariance matrix (complex output)"); SetParameterDescription("conv.msinclairtocircovariance","3 Monostatic : Sinclair matrix to circular covariance matrix (complex output)"); // #4 // ReciprocalCoherencyToReciprocalMuellerImageFilter AddChoice("conv.mcoherencytomueller","4 Monostatic : Coherency matrix to Mueller matrix"); SetParameterDescription("conv.mcoherencytomueller","4 Monostatic : Coherency matrix to Mueller matrix"); // #5 // ReciprocalCovarianceToCoherencyDegreeImageFilter AddChoice("conv.mcovariancetocoherencydegree","5 Monostatic : Covariance matrix to coherency degree "); SetParameterDescription("conv.mcovariancetocoherencydegree","5 Monostatic : Covariance matrix to coherency degree "); // #6 // ReciprocalCovarianceToReciprocalCoherencyImageFilter AddChoice("conv.mcovariancetocoherency","6 Monostatic : Covariance matrix to coherency matrix (complex output)"); SetParameterDescription("conv.mcovariancetocoherency","6 Monostatic : Covariance matrix to coherency matrix (complex output)"); // #7 // ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter AddChoice("conv.mlinearcovariancetocircularcovariance","7 Monostatic : Covariance matrix to circular covariance matrix (complex output)"); SetParameterDescription("conv.mlinearcovariancetocircularcovariance","7 Monostatic : Covariance matrix to circular covariance matrix (complex output)"); // #8 // MuellerToReciprocalCovarianceImageFilter AddChoice("conv.muellertomcovariance","8 Bi/mono : Mueller matrix to monostatic covariance matrix"); SetParameterDescription("conv.muellertomcovariance","8 Bi/mono : Mueller matrix to monostatic covariance matrix"); //Bistatic case // #9 // SinclairToCoherency AddChoice("conv.bsinclairtocoherency","9 Bistatic : Sinclair matrix to coherency matrix (complex output)"); SetParameterDescription("conv.bsinclairtocoherency","9 Bistatic : Sinclair matrix to coherency matrix (complex output)"); // #10 // SinclairToCovariance AddChoice("conv.bsinclairtocovariance","10 Bistatic : Sinclair matrix to covariance matrix (complex output)"); SetParameterDescription("conv.bsinclairtocovariance","10 Bistatic : Sinclair matrix to covariance matrix (complex output)"); // #11 // SinclairToCircularCovariance AddChoice("conv.bsinclairtocircovariance","11 Bistatic : Sinclair matrix to circular covariance matrix (complex output)"); SetParameterDescription("conv.bsinclairtocircovariance","11 Bistatic : Sinclair matrix to circular covariance matrix (complex output)"); //Both case // #12 // SinclairToMueller AddChoice("conv.sinclairtomueller","12 Bi/mono : Sinclair matrix to Mueller matrix"); SetParameterDescription("conv.sinclairtomueller","12 Bi/mono : Sinclair matrix to Mueller matrix"); // #13 // MuellerToPolarisationDegreeAndPowerImageFilter AddChoice("conv.muellertopoldegandpower","13 Bi/mono : Mueller matrix to polarisation degree and power"); SetParameterDescription("conv.muellertopoldegandpower","13 Bi/mono : Mueller matrix to polarisation degree and power"); AddRAMParameter(); // Default values SetDefaultParameterInt("conv", 0); // SinclairToReciprocalCoherency // Doc example parameter settings SetDocExampleParameterValue("inhh", "HH.tif"); SetDocExampleParameterValue("invh", "VH.tif"); SetDocExampleParameterValue("invv", "VV.tif"); SetDocExampleParameterValue("conv", "msinclairtocoherency"); SetDocExampleParameterValue("outc", "mcoherency.tif"); } void DoUpdateParameters() ITK_OVERRIDE { int convType = GetParameterInt("conv"); if ( (convType>=0) && (convType<=2)) //msinclairtocoherency msinclairtocovariance msinclairtocircovariance { GetParameterByKey("inc")->SetActive(false); GetParameterByKey("inf")->SetActive(false); GetParameterByKey("inhh")->SetActive(true); GetParameterByKey("inhv")->SetActive(true); GetParameterByKey("invh")->SetActive(true); GetParameterByKey("invv")->SetActive(true); GetParameterByKey("outc")->SetActive(true); GetParameterByKey("outf")->SetActive(false); } else if ( (convType>=3) && (convType<=6)) // mcoherencytomueller mcovariancetocoherencydegree mcovariancetocoherency mlinearcovariancetocircularcovariance { GetParameterByKey("inc")->SetActive(true); GetParameterByKey("inf")->SetActive(false); GetParameterByKey("inhh")->SetActive(false); GetParameterByKey("inhv")->SetActive(false); GetParameterByKey("invh")->SetActive(false); GetParameterByKey("invv")->SetActive(false); if (convType == 3) { GetParameterByKey("outc")->SetActive(false); GetParameterByKey("outf")->SetActive(true); } else { GetParameterByKey("outc")->SetActive(true); GetParameterByKey("outf")->SetActive(false); } } else if ( convType==7) // muellertomcovariance { GetParameterByKey("inc")->SetActive(false); GetParameterByKey("inf")->SetActive(true); GetParameterByKey("inhh")->SetActive(false); GetParameterByKey("inhv")->SetActive(false); GetParameterByKey("invh")->SetActive(false); GetParameterByKey("invv")->SetActive(false); GetParameterByKey("outc")->SetActive(true); GetParameterByKey("outf")->SetActive(false); } else if ( (convType>=8) && (convType<=11)) // bsinclairtocoherency bsinclairtocovariance bsinclairtocircovariance sinclairtomueller { GetParameterByKey("inc")->SetActive(false); GetParameterByKey("inf")->SetActive(false); GetParameterByKey("inhh")->SetActive(true); GetParameterByKey("inhv")->SetActive(true); GetParameterByKey("invh")->SetActive(true); GetParameterByKey("invv")->SetActive(true); if (convType == 11) { GetParameterByKey("outc")->SetActive(false); GetParameterByKey("outf")->SetActive(true); } else { GetParameterByKey("outc")->SetActive(true); GetParameterByKey("outf")->SetActive(false); } } else if ( convType==12 ) // muellertopoldegandpower { GetParameterByKey("inc")->SetActive(false); GetParameterByKey("inf")->SetActive(true); GetParameterByKey("inhh")->SetActive(false); GetParameterByKey("inhv")->SetActive(false); GetParameterByKey("invh")->SetActive(false); GetParameterByKey("invv")->SetActive(false); GetParameterByKey("outc")->SetActive(false); GetParameterByKey("outf")->SetActive(true); } } void DoExecute() ITK_OVERRIDE { //**************************************** //* Check inputs and outputs consistency * //**************************************** bool inc = HasUserValue("inc"); bool inf = HasUserValue("inf"); bool inhh = HasUserValue("inhh"); bool inhv = HasUserValue("inhv"); bool invh = HasUserValue("invh"); bool invv = HasUserValue("invv"); bool outc = HasUserValue("outc"); bool outf = HasUserValue("outf"); int convType = GetParameterInt("conv"); if ( (!outc) && (!outf) ) otbAppLogFATAL( << "No output image provided; please, set the parameter 'outc' or 'outf'."); if ( (convType>=0) && (convType<=2)) //msinclairtocoherency msinclairtocovariance msinclairtocircovariance { if ( (!inhv) && (!invh) ) otbAppLogFATAL( << "Parameter 'inhv' or 'invh' not set."); if ( !inhh ) otbAppLogFATAL( << "Parameter 'inhh' not set."); if ( !invv ) otbAppLogFATAL( << "Parameter 'invv' not set."); } else if ( (convType>=3) && (convType<=6)) // mcoherencytomueller mcovariancetocoherencydegree mcovariancetocoherency mlinearcovariancetocircularcovariance { if ( !inc ) otbAppLogFATAL( << "Parameter 'inc' not set."); } else if ( (convType>=8) && (convType<=11)) // bsinclairtocoherency bsinclairtocovariance bsinclairtocircovariance sinclairtomueller { if ( (!inhh) || (!inhv) || (!invh) || (!invv) ) otbAppLogFATAL( << "Please, ensure that HH, HV, VH and VV complex images have been provided (parameters inhh, inhv, invh, invv)."); } else if ( (convType==7) || (convType==12) ) // muellertomcovariance muellertopoldegandpower { if ( !inf ) otbAppLogFATAL( << "Parameter 'inf' not set."); } switch (GetParameterInt("conv")) { //*************************************** //* MONOSTATIC * //*************************************** case 0: // SinclairToReciprocalCoherency m_RCohSRFilter = RCohSRFilterType::New(); if (inhv) m_RCohSRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("inhv")); else if (invh) m_RCohSRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("invh")); m_RCohSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_RCohSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); SetParameterComplexOutputImage("outc", m_RCohSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels break; case 1: // SinclairToReciprocalCovariance m_RCovSRFilter = RCovSRFilterType::New(); if (inhv) m_RCovSRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("inhv")); else if (invh) m_RCovSRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("invh")); m_RCovSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_RCovSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); SetParameterComplexOutputImage("outc", m_RCovSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels break; case 2: // SinclairToReciprocalCircularCovariance m_RCCSRFilter = RCCSRFilterType::New(); if (inhv) m_RCCSRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("inhv")); else if (invh) m_RCCSRFilter->SetInputHV_VH(GetParameterComplexDoubleImage("invh")); m_RCCSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_RCCSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); SetParameterComplexOutputImage("outc", m_RCCSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels break; case 3: // ReciprocalCoherencyToReciprocalMuellerImageFilter m_RCRMFilter = RCRMFilterType::New(); m_RCRMFilter->SetInput(GetParameterComplexDoubleVectorImage("inc")); SetParameterOutputImage("outf", m_RCRMFilter->GetOutput() ); // input : 6 complex channels | 16 real channels break; case 4: // ReciprocalCovarianceToCoherencyDegreeImageFilter m_RCCDFilter = RCCDFilterType::New(); m_RCCDFilter->SetInput(GetParameterComplexDoubleVectorImage("inc")); SetParameterComplexOutputImage("outc", m_RCCDFilter->GetOutput() ); // input : 6 complex channels | 3 complex channels break; case 5: // ReciprocalCovarianceToReciprocalCoherencyImageFilter m_RCRCFilter = RCRCFilterType::New(); m_RCRCFilter->SetInput(GetParameterComplexDoubleVectorImage("inc")); SetParameterComplexOutputImage("outc", m_RCRCFilter->GetOutput() ); // input : 6 complex channels | 6 complex channels break; case 6: // ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter m_RLCRCCFilter = RLCRCCFilterType::New(); m_RLCRCCFilter->SetInput(GetParameterComplexDoubleVectorImage("inc")); SetParameterComplexOutputImage("outc", m_RLCRCCFilter->GetOutput() ); // input : 6 complex channels | output : 6 complex channels break; case 7: // MuellerToReciprocalCovarianceImageFilter m_MRCFilter = MRCFilterType::New(); m_MRCFilter->SetInput(GetParameterDoubleVectorImage("inf")); SetParameterComplexOutputImage("outc", m_MRCFilter->GetOutput() ); // input : 16 real channels | output : 6 complex channels break; //*************************************** //* BISTATIC * //*************************************** case 8: // SinclairToCoherency m_CohSRFilter = CohSRFilterType::New(); m_CohSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_CohSRFilter->SetInputHV(GetParameterComplexDoubleImage("inhv")); m_CohSRFilter->SetInputVH(GetParameterComplexDoubleImage("invh")); m_CohSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); SetParameterComplexOutputImage("outc", m_CohSRFilter->GetOutput() ); // input : 4 x 1 complex channel | 10 complex channels break; case 9: // SinclairToCovariance m_CovSRFilter = CovSRFilterType::New(); m_CovSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_CovSRFilter->SetInputHV(GetParameterComplexDoubleImage("inhv")); m_CovSRFilter->SetInputVH(GetParameterComplexDoubleImage("invh")); m_CovSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); SetParameterComplexOutputImage("outc", m_CovSRFilter->GetOutput() ); // input : 4 x 1 complex channel | output : 10 complex channels break; case 10: // SinclairToCircularCovariance m_CCSRFilter = CCSRFilterType::New(); m_CCSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_CCSRFilter->SetInputHV(GetParameterComplexDoubleImage("inhv")); m_CCSRFilter->SetInputVH(GetParameterComplexDoubleImage("invh")); m_CCSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); SetParameterComplexOutputImage("outc", m_CCSRFilter->GetOutput() ); // input : 4 x 1 complex channel | output : 10 complex channels break; //*************************************** //* BOTH CASES * //*************************************** case 11: // SinclairToMueller m_MSRFilter = MSRFilterType::New(); m_MSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh")); m_MSRFilter->SetInputHV(GetParameterComplexDoubleImage("inhv")); m_MSRFilter->SetInputVH(GetParameterComplexDoubleImage("invh")); m_MSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv")); SetParameterOutputImage("outf", m_MSRFilter->GetOutput() ); // input : 4 x 1 complex channel | output : 16 real channels break; case 12: // MuellerToPolarisationDegreeAndPowerImageFilter m_MPDPFilter = MPDPFilterType::New(); m_MPDPFilter->SetInput(GetParameterDoubleVectorImage("inf")); SetParameterOutputImage("outf", m_MPDPFilter->GetOutput() ); // input : 16 real channels | output : 4 real channels break; } } //Monostatic RCohSRFilterType::Pointer m_RCohSRFilter; RCovSRFilterType::Pointer m_RCovSRFilter; RCCSRFilterType::Pointer m_RCCSRFilter; RCRMFilterType::Pointer m_RCRMFilter; RCCDFilterType::Pointer m_RCCDFilter; RCRCFilterType::Pointer m_RCRCFilter; RLCRCCFilterType::Pointer m_RLCRCCFilter; //Bistatic CohSRFilterType::Pointer m_CohSRFilter; CovSRFilterType::Pointer m_CovSRFilter; CCSRFilterType::Pointer m_CCSRFilter; MSRFilterType::Pointer m_MSRFilter; //Both cases MRCFilterType::Pointer m_MRCFilter; MPDPFilterType::Pointer m_MPDPFilter; }; } //end namespace Wrapper } //end namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::SARPolarMatrixConvert) OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/otb-module.cmake000066400000000000000000000004401301006202600273350ustar00rootroot00000000000000set(DOCUMENTATION "Basic filters application.") otb_module(OTBAppSARPolarMatrixConvert DEPENDS OTBPolarimetry OTBImageManipulation OTBITK OTBApplicationEngine OTBImageBase TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/test/000077500000000000000000000000001301006202600252455ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARPolarMatrixConvert/test/CMakeLists.txt000066400000000000000000000134031301006202600300060ustar00rootroot00000000000000otb_module_test() #----------- SARPolarMatrixConvert TESTS ---------------- #1 otb_test_application(NAME apTvSARPolarMatrixConvertRecCoherency APP SARPolarMatrixConvert OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -conv msinclairtocoherency -outc ${TEMP}/apTvSARPolarMatrixConvertRecCoherency.tif ) #2 otb_test_application(NAME apTvSARPolarMatrixConvertRecCovariance APP SARPolarMatrixConvert OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -conv msinclairtocovariance -outc ${TEMP}/apTvSARPolarMatrixConvertRecCovariance.tif ) #3 otb_test_application(NAME apTvSARPolarMatrixConvertRecCirCovariance APP SARPolarMatrixConvert OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -conv msinclairtocircovariance -outc ${TEMP}/apTvSARPolarMatrixConvertRecCirCovariance.tif ) #4 otb_test_application(NAME apTvSARPolarMatrixConvertRecCohToMueller APP SARPolarMatrixConvert OPTIONS -inc ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif -conv mcoherencytomueller -outf ${TEMP}/apTvSARPolarMatrixConvertRecCohToMueller.tif ) #5 otb_test_application(NAME apTvSARPolarMatrixConvertRecCovToCohDeg APP SARPolarMatrixConvert OPTIONS -inc ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif -conv mcovariancetocoherencydegree -outc ${TEMP}/apTvSARPolarMatrixConvertRecCovToCohDeg.tif ) #6 otb_test_application(NAME apTvSARPolarMatrixConvertRecCovToRecCoh APP SARPolarMatrixConvert OPTIONS -inc ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif -conv mcovariancetocoherency -outc ${TEMP}/apTvSARPolarMatrixConvertRecCovToRecCoh.tif ) #7 otb_test_application(NAME apTvSARPolarMatrixConvertRecLinCovToRecCirCov APP SARPolarMatrixConvert OPTIONS -inc ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif -conv mlinearcovariancetocircularcovariance -outc ${TEMP}/apTvSARPolarMatrixConvertRecCovToRecCoh.tif ) #8 otb_test_application(NAME apTvSARPolarMatrixConvertMuellerToRecCov APP SARPolarMatrixConvert OPTIONS -inf ${BASELINE}/saTvSinclairImageFilter_SinclairToMueller.tif -conv muellertomcovariance -outc ${TEMP}/apTvSARPolarMatrixConvertMuellerToRecCov.tif ) #9 otb_test_application(NAME apTvSARPolarMatrixConvertBiSincToCoherency APP SARPolarMatrixConvert OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invh ${INPUTDATA}/RSAT_imageryC_VH.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -conv bsinclairtocoherency -outc ${TEMP}/apTvSARPolarMatrixConvertBiSincToCoherency.tif ) #10 otb_test_application(NAME apTvSARPolarMatrixConvertBiSincToCovariance APP SARPolarMatrixConvert OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invh ${INPUTDATA}/RSAT_imageryC_VH.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -conv bsinclairtocovariance -outc ${TEMP}/apTvSARPolarMatrixConvertBiSincToCovariance.tif ) #11 otb_test_application(NAME apTvSARPolarMatrixConvertBiSincToCirCovariance APP SARPolarMatrixConvert OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invh ${INPUTDATA}/RSAT_imageryC_VH.tif -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -conv bsinclairtocircovariance -outc ${TEMP}/apTvSARPolarMatrixConvertBiSincToCirCovariance.tif ) #12 otb_test_application(NAME apTvSARPolarMatrixConvertSincToMueller APP SARPolarMatrixConvert OPTIONS -inhh ${INPUTDATA}/RSAT_imageryC_HH.tif -inhv ${INPUTDATA}/RSAT_imageryC_HV.tif -invh ${INPUTDATA}/RSAT_imageryC_HV.tif #monostatic -invv ${INPUTDATA}/RSAT_imageryC_VV.tif -conv sinclairtomueller -outf ${TEMP}/apTvSARPolarMatrixConvertSincToMueller.tif ) #13 otb_test_application(NAME apTvSARPolarMatrixConvertMuellerToPolDeGPow APP SARPolarMatrixConvert OPTIONS -inf ${BASELINE}/saTvSinclairImageFilter_SinclairToMueller.tif -conv muellertopoldegandpower -outf ${TEMP}/apTvSARPolarMatrixConvertMuellerToPolDeGPow.tif ) OTB-release-5.8/Modules/Applications/AppSARPolarSynth/000077500000000000000000000000001301006202600225665ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARPolarSynth/CMakeLists.txt000066400000000000000000000000571301006202600253300ustar00rootroot00000000000000project(OTBAppSARPolarSynth) otb_module_impl() OTB-release-5.8/Modules/Applications/AppSARPolarSynth/app/000077500000000000000000000000001301006202600233465ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARPolarSynth/app/CMakeLists.txt000066400000000000000000000004561301006202600261130ustar00rootroot00000000000000set(OTBAppFiltering_LINK_LIBS ${OTBPolarimetry_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBImageBase_LIBRARIES} ) otb_create_application( NAME SARPolarSynth SOURCES otbSARPolarSynth.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppSARPolarSynth/app/otbSARPolarSynth.cxx000066400000000000000000000210371301006202600272530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultiChannelsPolarimetricSynthesisFilter.h" namespace otb { namespace Wrapper { class SARPolarSynth : public Application { public: /** Standard class typedefs. */ typedef SARPolarSynth Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef MultiChannelsPolarimetricSynthesisFilter MCPSFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SARPolarSynth, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("SARPolarSynth"); SetDescription("Gives, for each pixel, the power that would have been received by a SAR system with a basis different from the classical (H,V) one (polarimetric synthetis)."); // Documentation SetDocName("SARPolarSynth"); SetDocLongDescription("This application gives, for each pixel, the power that would have been received by a SAR system with a basis different from the classical (H,V) one (polarimetric synthetis).\n" "The new basis A and B are indicated through two Jones vectors, defined by the user thanks to orientation (psi) and ellipticity (khi) parameters.\n" "These parameters are namely psii, khii, psir and khir. The suffixes (i) and (r) refer to the transmitting antenna and the receiving antenna respectively.\n" "Orientations and ellipticities are given in degrees, and are between -90/90 degrees and -45/45 degrees respectively.\n " "\n" "Four polarization architectures can be processed : \n\n" "1. HH_HV_VH_VV : full polarization, general bistatic case.\n" "2. HH_HV_VV or HH_VH_VV : full polarization, monostatic case (transmitter and receiver are co-located).\n" "3. HH_HV : dual polarization.\n" "4. VH_VV : dual polarization.\n\n" "The application takes a complex vector image as input, where each band correspond to a particular emission/reception polarization scheme.\n" "User must comply with the band order given above, since the bands are used to build the Sinclair matrix.\n" "\n" "In order to determine the architecture, the application first relies on the number of bands of the input image.\n\n" "1. Architecture HH_HV_VH_VV is the only one with four bands, there is no possible confusion.\n" "2. Concerning HH_HV_VV and HH_VH_VV architectures, both correspond to a three channels image. But they are processed in the same way, as the Sinclair matrix is symmetric in the monostatic case.\n" "3. Finally, the two last architectures (dual polarizations), can't be distinguished only by the number of bands of the input image." " User must then use the parameters emissionh and emissionv to indicate the architecture of the system : emissionh=1 and emissionv=0 --> HH_HV, emissionh=0 and emissionv=1 --> VH_VV.\n" "\nNote : if the architecture is HH_HV, khii and psii are automatically both set to 0 degree; if the architecture is VH_VV, khii and psii are automatically set to 0 degree and 90 degrees respectively.\n" "\n" "It is also possible to force the calculation to co-polar or cross-polar modes.\n" "In the co-polar case, values for psir and khir will be ignored and forced to psii and khii; same as the cross-polar mode, where khir and psir will be forced to (psii + 90 degrees) and -khii.\n" "\n" "Finally, the result of the polarimetric synthetis is expressed in the power domain, through a one-band scalar image.\n" "Note: this application doesn't take into account the terms which do not depend on the polarization of the antennas. \n" "The parameter gain can be used for this purpose.\n" "\n" "More details can be found in the OTB CookBook (SAR processing chapter)."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("SARDecompositions, SARPolarMatrixConvert"); AddDocTag(Tags::SAR); AddParameter(ParameterType_ComplexInputImage, "in", "Input Image"); SetParameterDescription("in", "Input image."); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image."); AddParameter(ParameterType_Float,"psii","psii"); SetParameterDescription("psii","Orientation (transmitting antenna)"); SetMinimumParameterFloatValue("psii",-90.0); SetMaximumParameterFloatValue("psii",90.0); AddParameter(ParameterType_Float,"khii","khii"); SetParameterDescription("khii","Ellipticity (transmitting antenna)"); SetMinimumParameterFloatValue("khii",-45.0); SetMaximumParameterFloatValue("khii",45.0); AddParameter(ParameterType_Float,"psir","psir"); SetParameterDescription("psir","Orientation (receiving antenna)"); SetMinimumParameterFloatValue("psir",-90.0); SetMaximumParameterFloatValue("psir",90.0); AddParameter(ParameterType_Float,"khir","khir"); SetParameterDescription("khir","Ellipticity (receiving antenna)"); SetMinimumParameterFloatValue("khir",-45.0); SetMaximumParameterFloatValue("khir",45.0); AddParameter(ParameterType_Int,"emissionh","Emission H"); SetParameterDescription("emissionh","This parameter is useful in determining the polarization architecture (dual polarization case)."); SetMinimumParameterIntValue("emissionh",0); SetMaximumParameterIntValue("emissionh",1); MandatoryOff("emissionh"); AddParameter(ParameterType_Int,"emissionv","Emission V"); SetParameterDescription("emissionv","This parameter is useful in determining the polarization architecture (dual polarization case)."); SetMinimumParameterIntValue("emissionv",0); SetMaximumParameterIntValue("emissionv",1); MandatoryOff("emissionv"); AddParameter(ParameterType_Choice, "mode", "Forced mode"); AddChoice("mode.none","None"); SetParameterDescription("mode.none","None"); AddChoice("mode.co","Copolarization"); SetParameterDescription("mode.none","Copolarization"); AddChoice("mode.cross","Crosspolarization"); SetParameterDescription("mode.cross","Crosspolarization"); AddRAMParameter(); // Default values SetDefaultParameterFloat("psii", 0.); SetDefaultParameterFloat("khii", 0.); SetDefaultParameterFloat("psir", 0.); SetDefaultParameterFloat("khir", 0.); SetDefaultParameterInt("emissionh", 0); SetDefaultParameterInt("emissionv", 0); SetDefaultParameterFloat("mode", 0); // Doc example parameter settings SetDocExampleParameterValue("in", "sar.tif"); SetDocExampleParameterValue("psii","15."); SetDocExampleParameterValue("khii", "5."); SetDocExampleParameterValue("psir","-25."); SetDocExampleParameterValue("khir", "10."); SetDocExampleParameterValue("out", "newbasis.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { m_MCPSFilter = MCPSFilterType::New(); m_MCPSFilter->SetPsiI(GetParameterFloat("psii")); m_MCPSFilter->SetKhiI(GetParameterFloat("khii")); m_MCPSFilter->SetPsiR(GetParameterFloat("psir")); m_MCPSFilter->SetKhiR(GetParameterFloat("khir")); m_MCPSFilter->SetEmissionH(GetParameterInt("emissionh")); m_MCPSFilter->SetEmissionV(GetParameterInt("emissionv")); m_MCPSFilter->SetMode(GetParameterInt("mode")); ComplexDoubleVectorImageType* inVImage = GetParameterComplexDoubleVectorImage("in"); inVImage->UpdateOutputInformation(); int nbBands = inVImage->GetNumberOfComponentsPerPixel(); otbAppLogINFO( << "nbBands = " << nbBands); m_MCPSFilter->SetInput(inVImage); SetParameterOutputImage("out", m_MCPSFilter->GetOutput()); } //std::vector m_Ref; MCPSFilterType::Pointer m_MCPSFilter; }; } //end namespace Wrapper } //end namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::SARPolarSynth) OTB-release-5.8/Modules/Applications/AppSARPolarSynth/otb-module.cmake000066400000000000000000000004301301006202600256340ustar00rootroot00000000000000set(DOCUMENTATION "Basic filters application.") otb_module(OTBAppSARPolarSynth DEPENDS OTBPolarimetry OTBImageManipulation OTBITK OTBApplicationEngine OTBImageBase TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppSARPolarSynth/test/000077500000000000000000000000001301006202600235455ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSARPolarSynth/test/CMakeLists.txt000066400000000000000000000010211301006202600262770ustar00rootroot00000000000000otb_module_test() #----------- PolarSynth TESTS ---------------- otb_test_application(NAME apTvSARPolarSynth APP SARPolarSynth OPTIONS -in ${INPUTDATA}/RSAT2_AltonaExtract_1000_1000_100_100.hdr -out ${TEMP}/resApMultiPolarimetricSynthesis1.tif -psii 10.0 -khii 0.0 -psir 0.0 -khir 0.0 ) OTB-release-5.8/Modules/Applications/AppSegmentation/000077500000000000000000000000001301006202600225525ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSegmentation/CMakeLists.txt000066400000000000000000000000561301006202600253130ustar00rootroot00000000000000project(OTBAppSegmentation) otb_module_impl() OTB-release-5.8/Modules/Applications/AppSegmentation/app/000077500000000000000000000000001301006202600233325ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSegmentation/app/CMakeLists.txt000066400000000000000000000032461301006202600260770ustar00rootroot00000000000000set(OTBAppSegmentation_LINK_LIBS ${OTBVectorDataBase_LIBRARIES} ${OTBLabelMap_LIBRARIES} ${OTBConversion_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBImageIO_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBWatersheds_LIBRARIES} ${OTBGdalAdapters_LIBRARIES} ${OTBSmoothing_LIBRARIES} ${OTBMetrics_LIBRARIES} ${OTBOGRProcessing_LIBRARIES} ${OTBStatistics_LIBRARIES} ${OTBMeanShift_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBCCOBIA_LIBRARIES} ${OTBMathParser_LIBRARIES} ${OTBMorphologicalProfiles_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_create_application( NAME Segmentation SOURCES otbSegmentation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ConnectedComponentSegmentation SOURCES otbConnectedComponentSegmentation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME LSMSSegmentation SOURCES otbLSMSSegmentation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME LSMSVectorization SOURCES otbLSMSVectorization.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME LSMSSmallRegionsMerging SOURCES otbLSMSSmallRegionsMerging.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME HooverCompareSegmentation SOURCES otbHooverCompareSegmentation.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME MeanShiftSmoothing SOURCES otbMeanShiftSmoothing.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppSegmentation/app/otbConnectedComponentSegmentation.cxx000066400000000000000000000200211301006202600327210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbVectorData.h" #include "otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.h" #include "otbVectorDataProjectionFilter.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class ConnectedComponentSegmentation : public Application { public: /** Standard class typedefs. */ typedef ConnectedComponentSegmentation Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ConnectedComponentSegmentation, otb::Application); /** Typedefs */ typedef float InputPixelType; static const unsigned int Dimension = 2; typedef otb::VectorImage InputVectorImageType; typedef otb::Image LabelImageType; typedef otb::Image MaskImageType; typedef otb::VectorData VectorDataType; typedef VectorDataType::Pointer VectorDataPointerType; typedef otb::StreamingConnectedComponentSegmentationOBIAToVectorDataFilter < InputVectorImageType, LabelImageType, MaskImageType, VectorDataType > SegmentationFilterType; typedef otb::VectorDataProjectionFilter VectorDataProjectionFilterType; private: void DoInit() ITK_OVERRIDE { SetName("ConnectedComponentSegmentation"); SetDescription("Connected component segmentation and object based image filtering of the input image according to user-defined criterions."); SetDocName("Connected Component Segmentation"); SetDocLongDescription("This application allows one to perform a masking, connected components segmentation and object based image filtering. First and optionally, a mask can be built based on user-defined criterions to select pixels of the image which will be segmented. Then a connected component segmentation is performed with a user defined criterion to decide whether two neighbouring pixels belong to the same segment or not. After this segmentation step, an object based image filtering is applied using another user-defined criterion reasoning on segment properties, like shape or radiometric attributes. " "Criterions are mathematical expressions analysed by the MuParser library (http://muparser.sourceforge.net/). For instance, expression \"((b1>80) and intensity>95)\" will merge two neighbouring pixel in a single segment if their intensity is more than 95 and their value in the first image band is more than 80. See parameters documentation for a list of available attributes. The output of the object based image filtering is vectorized and can be written in shapefile or KML format. If the input image is in raw geometry, resulting polygons will be transformed to WGS84 using sensor modelling before writing, to ensure consistency with GIS software. For this purpose, a Digital Elevation Model can be provided to the application. The whole processing is done on a per-tile basis for large images, so this application can handle images of arbitrary size."); SetDocLimitations("Due to the tiling scheme in case of large images, some segments can be arbitrarily split across multiple tiles."); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Analysis); AddDocTag(Tags::Segmentation); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The image to segment."); AddParameter(ParameterType_OutputVectorData, "out", "Output Shape"); SetParameterDescription("out", "The segmentation shape."); AddParameter(ParameterType_String, "mask", "Mask expression"); SetParameterDescription("mask", "Mask mathematical expression (only if support image is given)"); MandatoryOff("mask"); DisableParameter("mask"); AddParameter(ParameterType_String, "expr", "Connected Component Expression"); SetParameterDescription("expr", "Formula used for connected component segmentation"); AddParameter(ParameterType_Int, "minsize", "Minimum Object Size"); SetParameterDescription("minsize", "Min object size (area in pixel)"); SetDefaultParameterInt("minsize", 2); SetMinimumParameterIntValue("minsize", 1); MandatoryOff("minsize"); AddParameter(ParameterType_String, "obia", "OBIA Expression"); SetParameterDescription("obia", "OBIA mathematical expression"); MandatoryOff("obia"); DisableParameter("obia"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in", "ROI_QB_MUL_4.tif"); SetDocExampleParameterValue("mask", "\"((b1>80)*intensity>95)\""); SetDocExampleParameterValue("expr", "\"distance<10\""); SetDocExampleParameterValue("minsize", "15"); SetDocExampleParameterValue("obia", "\"SHAPE_Elongation>8\""); SetDocExampleParameterValue("out", "ConnectedComponentSegmentation.shp"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } void DoExecute() ITK_OVERRIDE { InputVectorImageType::Pointer inputImage = GetParameterImage("in"); m_Connected = SegmentationFilterType::FilterType::New(); m_Connected->GetFilter()->SetInput(inputImage); if (IsParameterEnabled("mask") && HasValue("mask")) m_Connected->GetFilter()->SetMaskExpression(GetParameterString("mask")); m_Connected->GetFilter()->SetConnectedComponentExpression(GetParameterString("expr")); m_Connected->GetFilter()->SetMinimumObjectSize(GetParameterInt("minsize")); if (IsParameterEnabled("obia") && HasValue("obia")) m_Connected->GetFilter()->SetOBIAExpression(GetParameterString("obia")); m_Connected->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(m_Connected->GetStreamer(),"Computing segmentation"); m_Connected->Update(); /* * Reprojection of the output VectorData * * The output of the filter is in image physical coordinates, * projection WKT applied if the input image has one * * We need to reproject in WGS84 if the input image is in sensor model geometry */ std::string projRef = inputImage->GetProjectionRef(); ImageKeywordlist kwl = inputImage->GetImageKeywordlist(); VectorDataType::Pointer projectedVD = m_Connected->GetFilter()->GetOutputVectorData(); if ( projRef.empty() && kwl.GetSize() > 0 ) { // image is in sensor model geometry // Reproject VectorData in image projection m_Vproj = VectorDataProjectionFilterType::New(); m_Vproj->SetInput(m_Connected->GetFilter()->GetOutputVectorData()); m_Vproj->SetInputKeywordList(inputImage->GetImageKeywordlist()); //m_Vproj->SetInputOrigin(inputImage->GetOrigin()); //m_Vproj->SetInputSpacing(inputImage->GetSpacing()); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); m_Vproj->Update(); projectedVD = m_Vproj->GetOutput(); } SetParameterOutputVectorData("out", projectedVD); } /** Members */ SegmentationFilterType::FilterType::Pointer m_Connected; VectorDataProjectionFilterType::Pointer m_Vproj; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ConnectedComponentSegmentation) OTB-release-5.8/Modules/Applications/AppSegmentation/app/otbHooverCompareSegmentation.cxx000066400000000000000000000272121301006202600317160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbHooverMatrixFilter.h" #include "otbHooverInstanceFilter.h" #include "otbLabelMapToAttributeImageFilter.h" #include "itkLabelImageToLabelMapFilter.h" #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { // Functor to color Hoover instances template class HooverColorMapping { public: HooverColorMapping() {} virtual ~HooverColorMapping() {} typedef std::vector ColorListType; unsigned int GetOutputSize() { return 3; } void AddColor(const TOutput& color) { m_ScoreColors.push_back(color); } void SetBackground(const TOutput& bg) { m_Background = bg; } inline TOutput operator ()(const TInput& A) { TOutput out; out.SetSize(3); typename TInput::ValueType max = 0.0; unsigned int index=0; for (unsigned int i=0; i max) { index = i; max = A[i]; } } if (max > 0.01) { out = m_ScoreColors[index]; } else { out = m_Background; } return out; } private: ColorListType m_ScoreColors; TOutput m_Background; }; } // end namespace Functor namespace Wrapper { class HooverCompareSegmentation : public Application { public: /** Standard class typedefs. */ typedef HooverCompareSegmentation Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(HooverCompareSegmentation, otb::Application); typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::HooverMatrixFilter HooverMatrixFilterType; typedef UInt32ImageType ImageType; typedef FloatVectorImageType::PixelType FloatPixelType; typedef Int16VectorImageType::PixelType Int16PixelType; //typedef otb::VectorImage VectorImageType; typedef itk::LabelImageToLabelMapFilter ImageToLabelMapFilterType; typedef otb::ImageFileReader ImageReaderType; typedef HooverMatrixFilterType::MatrixType MatrixType; typedef otb::HooverInstanceFilter InstanceFilterType; typedef otb::LabelMapToAttributeImageFilter AttributeImageFilterType; typedef otb::UnaryFunctorImageFilter > HooverColorFilterType; private: void DoInit() ITK_OVERRIDE { SetName("HooverCompareSegmentation"); SetDescription("Compare two segmentations with Hoover metrics"); // Documentation SetDocName("Hoover compare segmentation"); SetDocLongDescription("This application compares a machine segmentation (MS) with a partial " "ground truth segmentation (GT). The Hoover metrics are used to estimate " "scores for correct detection, over-segmentation, under-segmentation and " "missed detection." "\n The application can output the overall Hoover scores along with colored" "images of the MS and GT segmentation showing the state of each region " "(correct detection, over-segmentation, under-segmentation, missed)" "\n The Hoover metrics are described in : Hoover et al., \"An experimental" " comparison of range image segmentation algorithms\", IEEE PAMI vol. 18, no. 7, July 1996."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otbHooverMatrixFilter, otbHooverInstanceFilter, otbLabelMapToAttributeImageFilter"); AddDocTag(Tags::Segmentation); AddParameter(ParameterType_InputImage, "ingt", "Input ground truth"); SetParameterDescription( "ingt", "A partial ground truth segmentation image." ); AddParameter(ParameterType_InputImage, "inms", "Input machine segmentation"); SetParameterDescription( "inms", "A machine segmentation image." ); AddParameter(ParameterType_Int, "bg", "Background label"); SetParameterDescription("bg", "Label value of the background in the input segmentations"); SetDefaultParameterInt("bg", 0); AddParameter(ParameterType_Float, "th", "Overlapping threshold"); SetParameterDescription("th", "Overlapping threshold used to find Hoover instances."); SetDefaultParameterFloat("th", 0.75); AddParameter(ParameterType_OutputImage, "outgt", "Colored ground truth output"); SetParameterDescription( "outgt", "The colored ground truth output image." ); SetDefaultOutputPixelType("outgt",ImagePixelType_uint8); MandatoryOff("outgt"); AddParameter(ParameterType_OutputImage, "outms", "Colored machine segmentation output"); SetParameterDescription( "outms", "The colored machine segmentation output image." ); SetDefaultOutputPixelType("outms",ImagePixelType_uint8); MandatoryOff("outms"); // TODO : add color settings ? AddParameter(ParameterType_Float, "rc", "Correct detection score"); SetParameterDescription("rc", "Overall score for correct detection (RC)"); SetParameterRole("rc", Role_Output); AddParameter(ParameterType_Float, "rf", "Over-segmentation score"); SetParameterDescription("rf", "Overall score for over segmentation (RF)"); SetParameterRole("rf", Role_Output); AddParameter(ParameterType_Float, "ra", "Under-segmentation score"); SetParameterDescription("ra", "Overall score for under segmentation (RA)"); SetParameterRole("ra", Role_Output); AddParameter(ParameterType_Float, "rm", "Missed detection score"); SetParameterDescription("rm", "Overall score for missed detection (RM)"); SetParameterRole("rm", Role_Output); // Doc example parameter settings SetDocExampleParameterValue("ingt", "maur_GT.tif"); SetDocExampleParameterValue("inms", "maur_labelled.tif"); SetDocExampleParameterValue("outgt", "maur_colored_GT.tif uint8"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { UInt32ImageType::Pointer inputGT = GetParameterUInt32Image("ingt"); UInt32ImageType::Pointer inputMS = GetParameterUInt32Image("inms"); m_GTFilter = ImageToLabelMapFilterType::New(); m_GTFilter->SetInput(inputGT); m_GTFilter->SetBackgroundValue( GetParameterInt("bg") ); m_MSFilter = ImageToLabelMapFilterType::New(); m_MSFilter->SetInput(inputMS); m_MSFilter->SetBackgroundValue( GetParameterInt("bg") ); m_HooverFilter = HooverMatrixFilterType::New(); m_HooverFilter->SetGroundTruthLabelMap(m_GTFilter->GetOutput()); m_HooverFilter->SetMachineSegmentationLabelMap(m_MSFilter->GetOutput()); m_HooverFilter->Update(); m_InstanceFilter = InstanceFilterType::New(); m_InstanceFilter->SetGroundTruthLabelMap(m_GTFilter->GetOutput()); m_InstanceFilter->SetMachineSegmentationLabelMap(m_MSFilter->GetOutput()); m_InstanceFilter->SetThreshold( GetParameterFloat("th") ); m_InstanceFilter->SetHooverMatrix( m_HooverFilter->GetHooverConfusionMatrix() ); m_InstanceFilter->SetUseExtendedAttributes(false); m_AttributeImageGT = AttributeImageFilterType::New(); m_AttributeImageGT->SetInput(m_InstanceFilter->GetOutputGroundTruthLabelMap()); m_AttributeImageGT->SetAttributeForNthChannel(0, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RC)); m_AttributeImageGT->SetAttributeForNthChannel(1, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RF)); m_AttributeImageGT->SetAttributeForNthChannel(2, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RA)); m_AttributeImageGT->SetAttributeForNthChannel(3, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RM)); m_AttributeImageMS = AttributeImageFilterType::New(); m_AttributeImageMS->SetInput(m_InstanceFilter->GetOutputMachineSegmentationLabelMap()); m_AttributeImageMS->SetAttributeForNthChannel(0, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RC)); m_AttributeImageMS->SetAttributeForNthChannel(1, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RF)); m_AttributeImageMS->SetAttributeForNthChannel(2, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RA)); //m_AttributeImageMS->SetAttributeForNthChannel(3, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RN); m_GTColorFilter = HooverColorFilterType::New(); m_GTColorFilter->SetInput(m_AttributeImageGT->GetOutput()); m_MSColorFilter = HooverColorFilterType::New(); m_MSColorFilter->SetInput(m_AttributeImageMS->GetOutput()); Int16PixelType colorPixel; colorPixel.SetSize(3); // Background : white colorPixel[0] = 255; colorPixel[1] = 255; colorPixel[2] = 255; m_GTColorFilter->GetFunctor().SetBackground(colorPixel); m_MSColorFilter->GetFunctor().SetBackground(colorPixel); // Correct detection : green colorPixel[0] = 0; colorPixel[1] = 255; colorPixel[2] = 0; m_GTColorFilter->GetFunctor().AddColor(colorPixel); m_MSColorFilter->GetFunctor().AddColor(colorPixel); // Over-segmentation : magenta colorPixel[0] = 255; colorPixel[1] = 0; colorPixel[2] = 255; m_GTColorFilter->GetFunctor().AddColor(colorPixel); m_MSColorFilter->GetFunctor().AddColor(colorPixel); // Under-segmentation : cyan colorPixel[0] = 0; colorPixel[1] = 255; colorPixel[2] = 255; m_GTColorFilter->GetFunctor().AddColor(colorPixel); m_MSColorFilter->GetFunctor().AddColor(colorPixel); // Missed detection (only for GT) : red colorPixel[0] = 255; colorPixel[1] = 0; colorPixel[2] = 0; m_GTColorFilter->GetFunctor().AddColor(colorPixel); if (HasValue("outgt")) { SetParameterOutputImage("outgt", m_GTColorFilter->GetOutput()); } if (HasValue("outms")) { SetParameterOutputImage("outms", m_MSColorFilter->GetOutput()); } m_InstanceFilter->Update(); SetParameterFloat("rc", m_InstanceFilter->GetMeanRC()); SetParameterFloat("rf", m_InstanceFilter->GetMeanRF()); SetParameterFloat("ra", m_InstanceFilter->GetMeanRA()); SetParameterFloat("rm", m_InstanceFilter->GetMeanRM()); } ImageToLabelMapFilterType::Pointer m_GTFilter; ImageToLabelMapFilterType::Pointer m_MSFilter; HooverMatrixFilterType::Pointer m_HooverFilter; InstanceFilterType::Pointer m_InstanceFilter; AttributeImageFilterType::Pointer m_AttributeImageGT; AttributeImageFilterType::Pointer m_AttributeImageMS; HooverColorFilterType::Pointer m_GTColorFilter; HooverColorFilterType::Pointer m_MSColorFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::HooverCompareSegmentation) OTB-release-5.8/Modules/Applications/AppSegmentation/app/otbLSMSSegmentation.cxx000066400000000000000000000667221301006202600277340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" #include "otbExtractROI.h" #include "otbConnectedComponentMuParserFunctor.h" #include "itkUnaryFunctorImageFilter.h" #include "itkStatisticsImageFilter.h" #include "itkChangeLabelImageFilter.h" #include "itkImageRegionConstIterator.h" #include "itkScalarConnectedComponentImageFilter.h" #include "otbConcatenateVectorImageFilter.h" #include "otbAffineFunctor.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImportGeoInformationImageFilter.h" #include #include #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbStandardWriterWatcher.h" #include namespace otb { namespace Wrapper { class LSMSSegmentation : public Application { public: typedef LSMSSegmentation Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(LSMSSegmentation, otb::Application); typedef FloatVectorImageType ImageType; typedef ImageType::InternalPixelType ImagePixelType; typedef UInt32ImageType LabelImageType; typedef LabelImageType::InternalPixelType LabelImagePixelType; typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileWriter ImageWriterType; typedef otb::ImageFileReader LabelImageReaderType; typedef otb::ImageFileWriter LabelImageWriterType; typedef otb::MultiChannelExtractROI MultiChannelExtractROIFilterType; typedef otb::ExtractROI ExtractROIFilterType; typedef otb::MultiToMonoChannelExtractROI MultiToMonoChannelExtractROIFilterType; typedef otb::Functor::ConnectedComponentMuParserFunctor CCFunctorType; typedef itk::ConnectedComponentFunctorImageFilter > CCFilterType; typedef itk::ScalarConnectedComponentImageFilter ScalarCCFilterType; typedef itk::StatisticsImageFilter StatisticsImageFilterType; typedef itk::ChangeLabelImageFilter ChangeLabelImageFilterType; typedef otb::ImportGeoInformationImageFilter ImportGeoInformationImageFilterType; typedef itk::ImageRegionConstIterator LabelImageIterator; typedef otb::ConcatenateVectorImageFilter ConcatenateType; typedef otb::Functor::AffineFunctor< LabelImagePixelType, LabelImagePixelType, LabelImagePixelType> AffineFunctorType; typedef itk::UnaryFunctorImageFilter< LabelImageType, LabelImageType, AffineFunctorType> LabelShiftFilterType; LSMSSegmentation(): m_FinalReader(),m_ImportGeoInformationFilter(),m_FilesToRemoveAfterExecute(),m_TmpDirCleanup(false){} ~LSMSSegmentation() ITK_OVERRIDE{} private: LabelImageReaderType::Pointer m_FinalReader; ImportGeoInformationImageFilterType::Pointer m_ImportGeoInformationFilter; std::vector m_FilesToRemoveAfterExecute; bool m_TmpDirCleanup; std::string CreateFileName(unsigned int row, unsigned int column, std::string label) { std::string outfname = GetParameterString("out"); std::string tilesname = itksys::SystemTools::GetFilenameWithoutExtension(outfname.c_str()); std::stringstream tileOut; tileOut< joins; if(IsParameterEnabled("tmpdir")) { std::string tmpdir = GetParameterString("tmpdir"); if(tmpdir.size() > 1 && tmpdir[tmpdir.size()-1] != '/') { tmpdir.append("/"); } joins.push_back(tmpdir); } joins.push_back(tileOut.str()); std::string currentFile = itksys::SystemTools::JoinPath(joins); return currentFile; } std::string WriteTile(LabelImageType::Pointer img, unsigned int row, unsigned int column, std::string label) { std::string currentFile = CreateFileName(row,column,label); LabelImageWriterType::Pointer imageWriter = LabelImageWriterType::New(); imageWriter->SetInput(img); imageWriter->SetFileName(currentFile); imageWriter->Update(); return currentFile; } void RemoveFile(std::string tile) { // Cleanup if(IsParameterEnabled("cleanup")) { // Try to remove the geom file if existing std::string geomfile = tile.substr(0,tile.size() - itksys::SystemTools::GetFilenameExtension(tile.c_str()).size()).append(".geom"); if(itksys::SystemTools::FileExists(geomfile.c_str())) { bool res = itksys::SystemTools::RemoveFile(geomfile.c_str()); if (!res) { otbAppLogINFO(<<"Unable to remove file "< joins; if(IsParameterEnabled("tmpdir")) { std::string tmpdir = GetParameterString("tmpdir"); if(tmpdir.size() > 1 && tmpdir[tmpdir.size()-1] != '/') { tmpdir.append("/"); } joins.push_back(tmpdir); } joins.push_back(vrtfOut.str()); std::string vrtfname = itksys::SystemTools::JoinPath(joins); otbAppLogINFO(<<"Creating temporary vrt file: "<"<"<Gray"<"<"<< itksys::SystemTools::GetFilenameName(CreateFileName(row,column,"FINAL")) <<""<1"<"<"<"<"<"<UpdateOutputInformation(); unsigned long sizeImageX = imageIn->GetLargestPossibleRegion().GetSize()[0]; unsigned long sizeImageY = imageIn->GetLargestPossibleRegion().GetSize()[1]; unsigned int nbComp = imageIn->GetNumberOfComponentsPerPixel(); unsigned int nbTilesX = sizeImageX/sizeTilesX + (sizeImageX%sizeTilesX > 0 ? 1 : 0); unsigned int nbTilesY = sizeImageY/sizeTilesY + (sizeImageY%sizeTilesY > 0 ? 1 : 0); otbAppLogINFO(<<"Number of tiles: "<SetInput(imageIn); extractROIFilter->SetStartX(startX); extractROIFilter->SetStartY(startY); extractROIFilter->SetSizeX(sizeX); extractROIFilter->SetSizeY(sizeY); extractROIFilter->Update(); //- the spatial image (final positions) if available MultiChannelExtractROIFilterType::Pointer extractROIFilter2 = MultiChannelExtractROIFilterType::New(); ConcatenateType::Pointer concat = ConcatenateType::New(); CCFilterType::Pointer ccFilter = CCFilterType::New(); if(HasValue("inpos")) { extractROIFilter2->SetInput(spatialIn); extractROIFilter2->SetStartX(startX); extractROIFilter2->SetStartY(startY); extractROIFilter2->SetSizeX(sizeX); extractROIFilter2->SetSizeY(sizeY); extractROIFilter2->Update(); //Concatenation of the two input images concat->SetInput1(extractROIFilter->GetOutput()); concat->SetInput2(extractROIFilter2->GetOutput()); concat->Update(); ccFilter->SetInput(concat->GetOutput()); } else { ccFilter->SetInput(extractROIFilter->GetOutput()); } //Expression 1 : radiometric distance < ranger std::stringstream expr; expr<<"sqrt((p1b1-p2b1)*(p1b1-p2b1)"; for(unsigned int i=1; iGetFunctor().SetExpression(expr.str()); ccFilter->Update(); //Shifting LabelShiftFilterType::Pointer labelShiftFilter = LabelShiftFilterType::New(); labelShiftFilter->SetInput(ccFilter->GetOutput()); labelShiftFilter->GetFunctor().SetA(1); labelShiftFilter->GetFunctor().SetB(regionCount); labelShiftFilter->Update(); //Maximum label calculation for the shifting StatisticsImageFilterType::Pointer stats = StatisticsImageFilterType::New(); stats->SetInput(ccFilter->GetOutput()); stats->Update(); regionCount+=stats->GetMaximum(); std::string filename = WriteTile(labelShiftFilter->GetOutput(),row,column,"SEG"); } // Step 2: create the look-up table for all overlaps otbAppLogINFO(<<"LUT creation ..."); std::vector LUT; LUT.clear(); LUT.resize(regionCount+1); for(LabelImagePixelType curLabel = 1; curLabel <= regionCount; ++curLabel) LUT[curLabel] = curLabel; for(unsigned int row = 0; row < nbTilesY; row++) { for(unsigned int column = 0; column < nbTilesX; column++) { unsigned long startX = column*sizeTilesX; unsigned long startY = row*sizeTilesY; unsigned long sizeX = vcl_min(sizeTilesX+1,sizeImageX-startX+1); unsigned long sizeY = vcl_min(sizeTilesY+1,sizeImageY-startY+1); std::string tileIn = CreateFileName(row,column,"SEG"); // Read current tile LabelImageReaderType::Pointer tileInReader = LabelImageReaderType::New(); tileInReader->SetFileName(tileIn); tileInReader->Update(); // Analyse intersection between in and up tiles if(row>0) { std::string tileUp = CreateFileName(row-1,column,"SEG"); LabelImageReaderType::Pointer tileUpReader = LabelImageReaderType::New(); tileUpReader->SetFileName(tileUp); tileUpReader->Update(); LabelImageType::IndexType pixelIndexIn; LabelImageType::IndexType pixelIndexUp; pixelIndexIn[1] = 0; pixelIndexUp[1] = sizeTilesY; for(pixelIndexIn[0]=0; pixelIndexIn[0](sizeX-1); ++pixelIndexIn[0]) { pixelIndexUp[0] = pixelIndexIn[0]; LabelImagePixelType curCanLabel = tileInReader->GetOutput()->GetPixel(pixelIndexIn); while(LUT[curCanLabel] != curCanLabel) { curCanLabel = LUT[curCanLabel]; } LabelImagePixelType adjCanLabel = tileUpReader->GetOutput()->GetPixel(pixelIndexUp); while(LUT[adjCanLabel] != adjCanLabel) { adjCanLabel = LUT[adjCanLabel]; } if(curCanLabel < adjCanLabel) { LUT[adjCanLabel] = curCanLabel; } else { LUT[LUT[curCanLabel]] = adjCanLabel; LUT[curCanLabel] = adjCanLabel; } } } // Analyse intersection between in and left tiles if(column>0) { std::string tileLeft = CreateFileName(row,column-1,"SEG"); LabelImageReaderType::Pointer tileLeftReader = LabelImageReaderType::New(); tileLeftReader->SetFileName(tileLeft); tileLeftReader->Update(); LabelImageType::IndexType pixelIndexIn; LabelImageType::IndexType pixelIndexUp; pixelIndexIn[0] = 0; pixelIndexUp[0] = sizeTilesX; for(pixelIndexIn[1]=0; pixelIndexIn[1](sizeY-1); ++pixelIndexIn[1]) { pixelIndexUp[1] = pixelIndexIn[1]; LabelImagePixelType curCanLabel = tileInReader->GetOutput()->GetPixel(pixelIndexIn); while(LUT[curCanLabel] != curCanLabel) { curCanLabel = LUT[curCanLabel]; } LabelImagePixelType adjCanLabel = tileLeftReader->GetOutput()->GetPixel(pixelIndexUp); while(LUT[adjCanLabel] != adjCanLabel) { adjCanLabel = LUT[adjCanLabel]; } if(curCanLabel < adjCanLabel) { LUT[adjCanLabel] = curCanLabel; } else { LUT[LUT[curCanLabel]] = adjCanLabel; LUT[curCanLabel] = adjCanLabel; } } } } } // Reduce LUT to canonical labels for(LabelImagePixelType label = 1; label < regionCount+1; ++label) { LabelImagePixelType can = label; while(LUT[can] != can) { can = LUT[can]; } LUT[label] = can; } otbAppLogINFO(<<"LUT size: "< sizePerRegion(regionCount+1,0); otbAppLogINFO(<<"Tiles relabelisation ..."); for(unsigned int column = 0; column < nbTilesX; ++column) { for(unsigned int row = 0; row < nbTilesY; ++row) { unsigned long startX = column*sizeTilesX; unsigned long startY = row*sizeTilesY; unsigned long sizeX = vcl_min(sizeTilesX,sizeImageX-startX); unsigned long sizeY = vcl_min(sizeTilesY,sizeImageY-startY); std::string tileIn = CreateFileName(row,column,"SEG"); LabelImageReaderType::Pointer readerIn = LabelImageReaderType::New(); readerIn->SetFileName(tileIn); // Remove extra margin now that lut is built ExtractROIFilterType::Pointer labelImage = ExtractROIFilterType::New(); labelImage->SetInput(readerIn->GetOutput()); labelImage->SetStartX(0); labelImage->SetStartY(0); labelImage->SetSizeX(sizeX); labelImage->SetSizeY(sizeY); // Relabel tile according to look-up table ChangeLabelImageFilterType::Pointer changeLabel = ChangeLabelImageFilterType::New(); changeLabel->SetInput(labelImage->GetOutput()); // Fill LUT for(LabelImagePixelType label = 1; labelSetChange(label,LUT[label]); } } // Here we need to update the filter to be able to update // region sizes table changeLabel->Update(); // Update region sizes LabelImageIterator it( changeLabel->GetOutput(), changeLabel->GetOutput()->GetLargestPossibleRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { sizePerRegion[it.Value()]+=1; } // Write tile WriteTile(changeLabel->GetOutput(),row,column,"RELAB"); // Remove previous tile (not needed anymore) readerIn = ITK_NULLPTR; // release the input file RemoveFile(tileIn); } } // Clear lut, we do not need it anymore LUT.clear(); unsigned int smallCount = 0; // Create the LUT to filter small regions and assign min labels otbAppLogINFO(<<"Small regions pruning ..."); LabelImagePixelType newLab=1; std::vector newLabels(regionCount+1,0); for(LabelImagePixelType curLabel = 1; curLabel <= regionCount; ++curLabel) { if(sizePerRegion[curLabel]SetFileName(tileIn); ChangeLabelImageFilterType::Pointer changeLabel = ChangeLabelImageFilterType::New(); changeLabel->SetInput(readerIn->GetOutput()); for(LabelImagePixelType label = 1; labelSetChange(label,newLabels[label]); } } // Write the relabeled tile std::string tmpfile = WriteTile(changeLabel->GetOutput(),row,column,"FINAL"); m_FilesToRemoveAfterExecute.push_back(tmpfile); // Clean previous tiles (not needed anymore) readerIn = ITK_NULLPTR; // release the input file RemoveFile(tileIn); } } // Clear newLabels, we do not need it anymore newLabels.clear(); // Here we write a temporary vrt file that will be used to // stitch together all the tiles std::string vrtfile = WriteVRTFile(nbTilesX,nbTilesY,sizeTilesX,sizeTilesY,sizeImageX,sizeImageY); m_FilesToRemoveAfterExecute.push_back(vrtfile); clock_t toc = clock(); otbAppLogINFO(<<"Elapsed time: "<<(double)(toc - tic) / CLOCKS_PER_SEC<<" seconds"); // Final writing m_FinalReader = LabelImageReaderType::New(); m_FinalReader->SetFileName(vrtfile); m_ImportGeoInformationFilter = ImportGeoInformationImageFilterType::New(); m_ImportGeoInformationFilter->SetInput(m_FinalReader->GetOutput()); m_ImportGeoInformationFilter->SetSource(imageIn); SetParameterOutputImage("out",m_ImportGeoInformationFilter->GetOutput()); } void AfterExecuteAndWriteOutputs() ITK_OVERRIDE { // Release input files m_FinalReader = ITK_NULLPTR; if(IsParameterEnabled("cleanup")) { otbAppLogINFO(<<"Final clean-up ..."); for(std::vector::iterator it = m_FilesToRemoveAfterExecute.begin(); it!=m_FilesToRemoveAfterExecute.end(); ++it) { RemoveFile(*it); } if(IsParameterEnabled("tmpdir") && m_TmpDirCleanup) { otbAppLogINFO(<<"Removing tmp directory "< #include #include #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbStandardWriterWatcher.h" namespace otb { namespace Wrapper { class LSMSSmallRegionsMerging : public Application { public: typedef LSMSSmallRegionsMerging Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef FloatVectorImageType ImageType; typedef ImageType::InternalPixelType ImagePixelType; typedef UInt32ImageType LabelImageType; typedef LabelImageType::InternalPixelType LabelImagePixelType; typedef otb::MultiChannelExtractROI MultiChannelExtractROIFilterType; typedef otb::ExtractROI ExtractROIFilterType; typedef otb::StreamingStatisticsImageFilter StatisticsImageFilterType; typedef itk::ImageRegionConstIterator LabelImageIterator; typedef itk::ImageRegionConstIterator ImageIterator; typedef itk::ChangeLabelImageFilter ChangeLabelImageFilterType; typedef otb::TileImageFilter TileImageFilterType; itkNewMacro(Self); itkTypeMacro(Merging, otb::Application); private: ChangeLabelImageFilterType::Pointer m_ChangeLabelFilter; void DoInit() ITK_OVERRIDE { SetName("LSMSSmallRegionsMerging"); SetDescription("Third (optional) step of the exact Large-Scale Mean-Shift segmentation workflow."); SetDocName("Exact Large-Scale Mean-Shift segmentation, step 3 (optional)"); SetDocLongDescription("This application performs the third step of the exact Large-Scale Mean-Shift segmentation workflow (LSMS). Given a segmentation result (label image) and the original image, it will merge regions whose size in pixels is lower than minsize parameter with the adjacent regions with the adjacent region with closest radiometry and acceptable size. Small regions will be processed by size: first all regions of area, which is equal to 1 pixel will be merged with adjacent region, then all regions of area equal to 2 pixels, until regions of area minsize. For large images one can use the nbtilesx and nbtilesy parameters for tile-wise processing, with the guarantees of identical results."); SetDocLimitations("This application is part of the Large-Scale Mean-Shift segmentation workflow (LSMS) and may not be suited for any other purpose."); SetDocAuthors("David Youssefi"); SetDocSeeAlso("LSMSSegmentation, LSMSVectorization, MeanShiftSmoothing"); AddDocTag(Tags::Segmentation); AddDocTag("LSMS"); AddParameter(ParameterType_InputImage, "in", "Input image"); SetParameterDescription( "in", "The input image." ); AddParameter(ParameterType_InputImage, "inseg", "Segmented image"); SetParameterDescription( "inseg", " The segmented image input. Segmented image input is the segmentation of the input image." ); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription( "out", "The output image. The output image is the input image where the minimal regions have been merged." ); SetDefaultOutputPixelType("out",ImagePixelType_uint32); AddParameter(ParameterType_Int, "minsize", "Minimum Region Size"); SetParameterDescription("minsize", "Minimum Region Size. If, after the segmentation, a region is of size lower than this criterion, the region is merged with the \"nearest\" region (radiometrically)."); SetDefaultParameterInt("minsize", 50); SetMinimumParameterIntValue("minsize", 0); MandatoryOff("minsize"); AddParameter(ParameterType_Int, "tilesizex", "Size of tiles in pixel (X-axis)"); SetParameterDescription("tilesizex", "Size of tiles along the X-axis."); SetDefaultParameterInt("tilesizex", 500); SetMinimumParameterIntValue("tilesizex", 1); AddParameter(ParameterType_Int, "tilesizey", "Size of tiles in pixel (Y-axis)"); SetParameterDescription("tilesizey", "Size of tiles along the Y-axis."); SetDefaultParameterInt("tilesizey", 500); SetMinimumParameterIntValue("tilesizey", 1); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in","smooth.tif"); SetDocExampleParameterValue("inseg","segmentation.tif"); SetDocExampleParameterValue("out","merged.tif"); SetDocExampleParameterValue("minsize","20"); SetDocExampleParameterValue("tilesizex","256"); SetDocExampleParameterValue("tilesizey","256"); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { clock_t tic = clock(); unsigned int minSize = GetParameterInt("minsize"); unsigned long sizeTilesX = GetParameterInt("tilesizex"); unsigned long sizeTilesY = GetParameterInt("tilesizey"); //Acquisition of the input image dimensions ImageType::Pointer imageIn = GetParameterImage("in"); imageIn->UpdateOutputInformation(); unsigned long sizeImageX = imageIn->GetLargestPossibleRegion().GetSize()[0], sizeImageY = imageIn->GetLargestPossibleRegion().GetSize()[1]; unsigned int numberOfComponentsPerPixel = imageIn->GetNumberOfComponentsPerPixel(); LabelImageType::Pointer labelIn = GetParameterUInt32Image("inseg"); StatisticsImageFilterType::Pointer stats = StatisticsImageFilterType::New(); stats->SetInput(labelIn); stats->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(stats->GetStreamer(), "Retrieve region count..."); stats->Update(); unsigned int regionCount=stats->GetMaximum(); std::vectornbPixels; nbPixels.clear(); nbPixels.resize(regionCount+1); for(LabelImagePixelType curLabel = 1; curLabel <= regionCount; ++curLabel) nbPixels[curLabel] = 0; ImageType::PixelType defaultValue(numberOfComponentsPerPixel); defaultValue.Fill(0); std::vectorsum(regionCount+1,defaultValue); unsigned int nbTilesX = sizeImageX/sizeTilesX + (sizeImageX%sizeTilesX > 0 ? 1 : 0); unsigned int nbTilesY = sizeImageY/sizeTilesY + (sizeImageY%sizeTilesY > 0 ? 1 : 0); otbAppLogINFO(<<"Number of tiles: "<SetInput(imageIn); imageROI->SetStartX(startX); imageROI->SetStartY(startY); imageROI->SetSizeX(sizeX); imageROI->SetSizeY(sizeY); imageROI->Update(); //Tiles extraction of the segmented image ExtractROIFilterType::Pointer labelImageROI = ExtractROIFilterType::New(); labelImageROI->SetInput(labelIn); labelImageROI->SetStartX(startX); labelImageROI->SetStartY(startY); labelImageROI->SetSizeX(sizeX); labelImageROI->SetSizeY(sizeY); labelImageROI->Update(); //Sums calculation for the mean calculation per label LabelImageIterator itLabel( labelImageROI->GetOutput(), labelImageROI->GetOutput()->GetLargestPossibleRegion()); ImageIterator itImage( imageROI->GetOutput(), imageROI->GetOutput()->GetLargestPossibleRegion()); for (itLabel.GoToBegin(), itImage.GoToBegin(); !itLabel.IsAtEnd(); ++itLabel, ++itImage) { nbPixels[itLabel.Value()]++; for(unsigned int comp = 0; comp LUT; LUT.clear(); LUT.resize(regionCount+1); for(LabelImagePixelType curLabel = 1; curLabel <= regionCount; ++curLabel) { LUT[curLabel] = curLabel; } //Minimal size region suppression otbAppLogINFO(<<"Building LUT for small regions merging ..."); for (unsigned int size=1; size LUTtmp; LUTtmp.clear(); LUTtmp.resize(regionCount+1); for(LabelImagePixelType curLabel = 1; curLabel <= regionCount; ++curLabel) { LUTtmp[curLabel] = LUT[curLabel]; } for(unsigned int row = 0; row < nbTilesY; row++) { for(unsigned int column = 0; column < nbTilesX; column++) { std::set minLabel, edgeLabel, labelMerged; std::map > adjMap; unsigned long startX = column*sizeTilesX, startY = row*sizeTilesY; unsigned long sizeX = vcl_min(sizeTilesX+size+1,sizeImageX-startX), sizeY = vcl_min(sizeTilesY+size+1,sizeImageY-startY); ExtractROIFilterType::Pointer labelImageROI = ExtractROIFilterType::New(); labelImageROI->SetInput(labelIn); labelImageROI->SetStartX(startX); labelImageROI->SetStartY(startY); labelImageROI->SetSizeX(sizeX); labelImageROI->SetSizeY(sizeY); labelImageROI->Update(); LabelImageType::IndexType pixelIndex; //"Adjacency map" creation for the region with nbPixels=="size" for(pixelIndex[0]=0; pixelIndex[0](sizeX); ++pixelIndex[0]) for(pixelIndex[1]=0; pixelIndex[1](sizeY); ++pixelIndex[1]) { LabelImagePixelType curLabel = labelImageROI->GetOutput()->GetPixel(pixelIndex); if(labelMerged.count(LUT[curLabel])) { edgeLabel.insert(LUT[curLabel]); } if((pixelIndex[0]==0)&&(startX!=0)) { edgeLabel.insert(LUT[curLabel]); } if((pixelIndex[1]==0)&&(startY!=0)) { edgeLabel.insert(LUT[curLabel]); } if(pixelIndex[0]==static_cast(sizeX)-1) { if(startX!=(nbTilesX-1)*sizeTilesX) edgeLabel.insert(LUT[curLabel]); } else { ++pixelIndex[0]; LabelImagePixelType adjLabelX = labelImageROI->GetOutput()->GetPixel(pixelIndex); --pixelIndex[0]; if(LUT[adjLabelX]!=LUT[curLabel]) { if((nbPixels[LUT[curLabel]]>0)&&(nbPixels[LUT[curLabel]]==size)) { adjMap[LUT[curLabel]].insert(LUT[adjLabelX]); minLabel.insert(LUT[curLabel]); } if((nbPixels[LUT[adjLabelX]]>0)&&(nbPixels[LUT[adjLabelX]]==size)) { adjMap[LUT[adjLabelX]].insert(LUT[curLabel]); minLabel.insert(LUT[adjLabelX]); } } } if(pixelIndex[1]==static_cast(sizeY)-1) { if(startY!=(nbTilesY-1)*sizeTilesY) edgeLabel.insert(LUT[curLabel]); } else { ++pixelIndex[1]; LabelImagePixelType adjLabelY = labelImageROI->GetOutput()->GetPixel(pixelIndex); --pixelIndex[1]; if(LUT[adjLabelY]!=LUT[curLabel]) { if((nbPixels[LUT[curLabel]]>0)&&(nbPixels[LUT[curLabel]]==size)) { adjMap[LUT[curLabel]].insert(LUT[adjLabelY]); minLabel.insert(LUT[curLabel]); } if((nbPixels[LUT[adjLabelY]]>0)&&(nbPixels[LUT[adjLabelY]]==size)) { adjMap[LUT[adjLabelY]].insert(LUT[curLabel]); minLabel.insert(LUT[adjLabelY]); } } } } //Searching the "nearest" region for(std::set::iterator itMinLabel=minLabel.begin(); itMinLabel!=minLabel.end(); ++itMinLabel) { LabelImagePixelType curLabel = *itMinLabel, adjLabel(0); double err = itk::NumericTraits::max(); if(edgeLabel.count(curLabel)==0) { if(nbPixels[curLabel]==size) { edgeLabel.insert(curLabel); for(std::set::iterator itAdjLabel=(adjMap[curLabel]).begin(); itAdjLabel!=(adjMap[curLabel]).end(); ++itAdjLabel) { double tmpError = 0; LabelImagePixelType tmpLabel = *itAdjLabel; if(tmpLabel!=curLabel) { for(unsigned int comp = 0; comp(sum[curLabel][comp])/nbPixels[curLabel]; int tmpComp = static_cast(sum[tmpLabel][comp])/nbPixels[tmpLabel]; tmpError += (curComp-tmpComp)*(curComp-tmpComp); } if(tmpErrorSetInput(labelIn); for(LabelImagePixelType label = 1; labelSetChange(label,LUT[label]); } } SetParameterOutputImage("out", m_ChangeLabelFilter->GetOutput()); clock_t toc = clock(); otbAppLogINFO(<<"Elapsed time: "<<(double)(toc - tic) / CLOCKS_PER_SEC<<" seconds"); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::LSMSSmallRegionsMerging) OTB-release-5.8/Modules/Applications/AppSegmentation/app/otbLSMSVectorization.cxx000066400000000000000000000336201301006202600301260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMultiChannelExtractROI.h" #include "otbExtractROI.h" #include "otbStreamingStatisticsImageFilter.h" #include "otbLabelImageToOGRDataSourceFilter.h" #include "otbOGRFeatureWrapper.h" #include #include namespace otb { namespace Wrapper { class LSMSVectorization : public Application { public: typedef LSMSVectorization Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef FloatVectorImageType ImageType; typedef ImageType::InternalPixelType ImagePixelType; typedef UInt32ImageType LabelImageType; typedef LabelImageType::InternalPixelType LabelImagePixelType; typedef otb::ImageFileReader LabelImageReaderType; typedef otb::MultiChannelExtractROI MultiChannelExtractROIFilterType; typedef otb::ExtractROI ExtractROIFilterType; typedef otb::StreamingStatisticsImageFilter StatisticsImageFilterType; typedef itk::ImageRegionConstIterator LabelImageIterator; typedef itk::ImageRegionConstIterator ImageIterator; typedef otb::LabelImageToOGRDataSourceFilter LabelImageToOGRDataSourceFilterType; itkNewMacro(Self); itkTypeMacro(Vectorization, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("LSMSVectorization"); SetDescription("Fourth step of the exact Large-Scale Mean-Shift segmentation workflow."); SetDocName("Exact Large-Scale Mean-Shift segmentation, step 4"); SetDocLongDescription("This application performs the fourth step of the exact Large-Scale Mean-Shift segmentation workflow (LSMS). Given a segmentation result (label image), that may have been processed for small regions merging or not, it will convert it to a GIS vector file containing one polygon per segment. Each polygon contains additional fields: mean and variance of each channels from input image (in parameter), segmentation image label, number of pixels in the polygon. For large images one can use the nbtilesx and nbtilesy parameters for tile-wise processing, with the guarantees of identical results."); SetDocLimitations("This application is part of the Large-Scale Mean-Shift segmentation workflow (LSMS) and may not be suited for any other purpose."); SetDocAuthors("David Youssefi"); SetDocSeeAlso("MeanShiftSmoothing, LSMSSegmentation, LSMSSmallRegionsMerging"); AddDocTag(Tags::Segmentation); AddDocTag("LSMS"); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription( "in", "The input image." ); AddParameter(ParameterType_InputImage, "inseg", "Segmented image"); SetParameterDescription( "inseg", " The segmented image input. Segmented image input is the segmentation of the input image." ); AddParameter(ParameterType_OutputFilename, "out", "Output GIS vector file"); SetParameterDescription( "out", "The output GIS vector file, representing the vectorized version of the segmented image where the features of the polygons are the radiometric means and variances." ); AddParameter(ParameterType_Int, "tilesizex", "Size of tiles in pixel (X-axis)"); SetParameterDescription("tilesizex", "Size of tiles along the X-axis."); SetDefaultParameterInt("tilesizex", 500); SetMinimumParameterIntValue("tilesizex", 1); AddParameter(ParameterType_Int, "tilesizey", "Size of tiles in pixel (Y-axis)"); SetParameterDescription("tilesizey", "Size of tiles along the Y-axis."); SetDefaultParameterInt("tilesizey", 500); SetMinimumParameterIntValue("tilesizey", 1); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("in","avions.tif"); SetDocExampleParameterValue("inseg","merged.tif"); SetDocExampleParameterValue("out","vector.shp"); SetDocExampleParameterValue("tilesizex","256"); SetDocExampleParameterValue("tilesizey","256"); } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { clock_t tic = clock(); std::string shapefile(GetParameterString("out")); unsigned long sizeTilesX = GetParameterInt("tilesizex"); unsigned long sizeTilesY = GetParameterInt("tilesizey"); LabelImageType::Pointer labelIn = GetParameterUInt32Image("inseg"); labelIn->UpdateOutputInformation(); unsigned long sizeImageX = labelIn->GetLargestPossibleRegion().GetSize()[0]; unsigned long sizeImageY = labelIn->GetLargestPossibleRegion().GetSize()[1]; unsigned int nbTilesX = sizeImageX/sizeTilesX + (sizeImageX%sizeTilesX > 0 ? 1 : 0); unsigned int nbTilesY = sizeImageY/sizeTilesY + (sizeImageY%sizeTilesY > 0 ? 1 : 0); otbAppLogINFO(<<"Number of tiles: "<SetInput(labelIn); stats->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(stats->GetStreamer(), "Retrieve region count..."); stats->Update(); unsigned int regionCount=stats->GetMaximum(); ImageType::Pointer imageIn = GetParameterImage("in"); imageIn->UpdateOutputInformation(); unsigned long numberOfComponentsPerPixel = imageIn->GetNumberOfComponentsPerPixel(); std::string projRef = imageIn->GetProjectionRef(); std::vectornbPixels; nbPixels.clear(); nbPixels.resize(regionCount+1); for(LabelImagePixelType curLabel = 1; curLabel <= regionCount; ++curLabel) { nbPixels[curLabel] = 0; } ImageType::PixelType defaultValue(numberOfComponentsPerPixel); defaultValue.Fill(0); std::vectorsum(regionCount+1,defaultValue); std::vectorsum2(regionCount+1,defaultValue); otb::ogr::DataSource::Pointer ogrDS; otb::ogr::Layer layer(ITK_NULLPTR, false); OGRSpatialReference oSRS(projRef.c_str()); std::vector options; ogrDS = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Overwrite); std::string layername = itksys::SystemTools::GetFilenameName(shapefile.c_str()); std::string extension = itksys::SystemTools::GetFilenameLastExtension(shapefile.c_str()); layername = layername.substr(0,layername.size()-(extension.size())); layer = ogrDS->CreateLayer(layername, &oSRS, wkbMultiPolygon, options); OGRFieldDefn labelField("label", OFTInteger); layer.CreateField(labelField, true); OGRFieldDefn nbPixelsField("nbPixels", OFTInteger); layer.CreateField(nbPixelsField, true); for(unsigned int comp = 0; compSetInput(imageIn); imageROI->SetStartX(startX); imageROI->SetStartY(startY); imageROI->SetSizeX(sizeX); imageROI->SetSizeY(sizeY); imageROI->Update(); //Tiles extraction of the segmented image ExtractROIFilterType::Pointer labelImageROI = ExtractROIFilterType::New(); labelImageROI->SetInput(labelIn); labelImageROI->SetStartX(startX); labelImageROI->SetStartY(startY); labelImageROI->SetSizeX(sizeX); labelImageROI->SetSizeY(sizeY); labelImageROI->Update(); //Sums calculation for the mean and the variance calculation per label LabelImageIterator itLabel( labelImageROI->GetOutput(), labelImageROI->GetOutput()->GetLargestPossibleRegion()); ImageIterator itImage( imageROI->GetOutput(), imageROI->GetOutput()->GetLargestPossibleRegion()); for (itLabel.GoToBegin(), itImage.GoToBegin(); !itImage.IsAtEnd(); ++itLabel, ++itImage) { nbPixels[itLabel.Value()]++; for(unsigned int comp = 0; compSetInput(labelIn); labelImageROI->SetStartX(startX); labelImageROI->SetStartY(startY); labelImageROI->SetSizeX(sizeX+1); labelImageROI->SetSizeY(sizeY+1); labelImageROI->Update(); //Raster->Vecteur conversion LabelImageToOGRDataSourceFilterType::Pointer labelToOGR = LabelImageToOGRDataSourceFilterType::New(); labelToOGR->SetInput(labelImageROI->GetOutput()); labelToOGR->SetInputMask(labelImageROI->GetOutput()); labelToOGR->SetFieldName("label"); labelToOGR->Update(); otb::ogr::DataSource::ConstPointer ogrDSTmp = labelToOGR->GetOutput(); otb::ogr::Layer layerTmp = ogrDSTmp->GetLayerChecked(0); otb::ogr::Layer::const_iterator featIt = layerTmp.begin(); for(; featIt!=layerTmp.end(); ++featIt) { otb::ogr::Feature dstFeature(layer.GetLayerDefn()); dstFeature.SetFrom( *featIt, TRUE ); layer.CreateFeature( dstFeature ); } } } //Sorting by increasing label of the features std::ostringstream sqloss; sqloss.str(""); sqloss<<"SELECT * FROM \""<ExecuteSQL(sqloss.str().c_str(), ITK_NULLPTR, ITK_NULLPTR); otb::ogr::Feature firstFeature = layerTmp.ogr().GetNextFeature(); //Geometry fusion otbAppLogINFO("Merging polygons across tiles ..."); while(firstFeature.addr()) { LabelImagePixelType curLabel = firstFeature.ogr().GetFieldAsInteger("label"); //Creation of a multipolygon where are stored the geometries to be merged OGRMultiPolygon geomToMerge; geomToMerge.addGeometry(firstFeature.GetGeometry()); bool merging = true; otb::ogr::Feature nextFeature(ITK_NULLPTR); bool haveMerged=false; while(merging) { nextFeature = layerTmp.ogr().GetNextFeature(); if(nextFeature.addr()) { LabelImagePixelType newLabel = nextFeature.ogr().GetFieldAsInteger("label"); merging=(newLabel==curLabel); //Storing of the new geometry if labels are identical if(merging) { geomToMerge.addGeometry(nextFeature.GetGeometry()); layer.DeleteFeature(nextFeature.GetFID()); haveMerged=true; } //If storing made and new label -> polygons fusion else if(haveMerged) { otb::ogr::UniqueGeometryPtr fusionPolygon = otb::ogr::UnionCascaded(geomToMerge); firstFeature.SetGeometry(fusionPolygon.get()); } } //If end of list : end of loop else { merging=false; } } //Features calculation //Number of pixels per label firstFeature.ogr().SetField("nbPixels",nbPixels[curLabel]); //Radiometric means per label for(unsigned int comp = 0; compogr().ExecuteSQL(sqloss.str().c_str(), ITK_NULLPTR, ITK_NULLPTR); } ogrDS->SyncToDisk(); clock_t toc = clock(); otbAppLogINFO(<<"Elapsed time: "<<(double)(toc - tic) / CLOCKS_PER_SEC<<" seconds"); } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::LSMSVectorization) OTB-release-5.8/Modules/Applications/AppSegmentation/app/otbMeanShiftSmoothing.cxx000066400000000000000000000144331301006202600303360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbMeanShiftSmoothingImageFilter.h" namespace otb { namespace Wrapper { class MeanShiftSmoothing : public Application { public: /** Standard class typedefs. */ typedef MeanShiftSmoothing Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::MeanShiftSmoothingImageFilter MSFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(MeanShiftSmoothing, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("MeanShiftSmoothing"); SetDescription("Perform mean shift filtering"); // Documentation SetDocName("Exact Large-Scale Mean-Shift segmentation, step 1 (smoothing)"); SetDocLongDescription("This application performs mean shift fitlering (multi-threaded)."); SetDocLimitations("With mode search option, the result will slightly depend on thread number."); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Filter); AddDocTag("LSMS"); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription( "in", "The input image." ); AddParameter(ParameterType_OutputImage, "fout", "Filtered output"); SetParameterDescription( "fout", "The filtered output image." ); AddParameter(ParameterType_OutputImage, "foutpos", "Spatial image"); SetParameterDescription( "foutpos", " The spatial image output. Spatial image output is a displacement map (pixel position after convergence)."); MandatoryOff("foutpos"); AddRAMParameter(); AddParameter(ParameterType_Int, "spatialr", "Spatial radius"); SetParameterDescription("spatialr", "Spatial radius of the neighborhood."); SetDefaultParameterInt("spatialr", 5); MandatoryOff("spatialr"); AddParameter(ParameterType_Float, "ranger", "Range radius"); SetParameterDescription("ranger", "Range radius defining the radius (expressed in radiometry unit) in the multi-spectral space."); SetDefaultParameterFloat("ranger", 15.0); MandatoryOff("ranger"); AddParameter(ParameterType_Float, "thres", "Mode convergence threshold"); SetParameterDescription("thres", "Algorithm iterative scheme will stop if mean-shift " "vector is below this threshold or if iteration number reached maximum number of iterations."); SetMinimumParameterFloatValue("thres", 0.0); SetDefaultParameterFloat("thres", 0.1); MandatoryOff("thres"); AddParameter(ParameterType_Int, "maxiter", "Maximum number of iterations"); SetParameterDescription("maxiter", "Algorithm iterative scheme will stop if convergence hasn't been reached after the maximum number of iterations."); SetDefaultParameterInt("maxiter", 100); SetMinimumParameterIntValue("maxiter", 1); MandatoryOff("maxiter"); AddParameter(ParameterType_Float, "rangeramp", "Range radius coefficient"); SetParameterDescription("rangeramp", "This coefficient makes dependent the ranger of the colorimetry of the filtered pixel : y = rangeramp*x+ranger."); SetDefaultParameterFloat("rangeramp", 0.); SetMinimumParameterFloatValue("rangeramp", 0); MandatoryOff("rangeramp"); AddParameter(ParameterType_Empty, "modesearch", "Mode search."); SetParameterDescription("modesearch", "If activated pixel iterative convergence is stopped if the path crosses an already converged pixel. Be careful, with this option, the result will slightly depend on thread number"); EnableParameter("modesearch"); // Doc example parameter settings SetDocExampleParameterValue("in", "maur_rgb.png"); SetDocExampleParameterValue("fout", "MeanShift_FilterOutput.tif"); SetDocExampleParameterValue("foutpos", "MeanShift_SpatialOutput.tif"); SetDocExampleParameterValue("spatialr", "16"); SetDocExampleParameterValue("ranger", "16"); SetDocExampleParameterValue("thres", "0.1"); SetDocExampleParameterValue("maxiter", "100"); } void DoUpdateParameters() ITK_OVERRIDE {} void DoExecute() ITK_OVERRIDE { FloatVectorImageType* input = GetParameterImage("in"); m_Filter = MSFilterType::New(); m_Filter->SetInput(input); m_Filter->SetSpatialBandwidth(GetParameterInt("spatialr")); m_Filter->SetRangeBandwidth(GetParameterFloat("ranger")); m_Filter->SetThreshold(GetParameterFloat("thres")); m_Filter->SetMaxIterationNumber(GetParameterInt("maxiter")); m_Filter->SetRangeBandwidthRamp(GetParameterFloat("rangeramp")); m_Filter->SetModeSearch(IsParameterEnabled("modesearch")); //Compute the margin used to ensure exact results (tile wise smoothing) //This margin is valid for the default uniform kernel used by the //MeanShiftSmoothing filter (bandwidth equal to radius in this case) const unsigned int margin = (m_Filter->GetMaxIterationNumber() * m_Filter->GetSpatialBandwidth()) + 1; otbAppLogINFO(<<"Margin of " << margin << " pixels applied to each tile to stabilized mean shift filtering." << std::endl); if ( margin > std::min(input->GetLargestPossibleRegion().GetSize()[0],input->GetLargestPossibleRegion().GetSize()[1]) ) { otbAppLogWARNING(<<"Margin value exceed the input image size." << std::endl); } SetParameterOutputImage("fout", m_Filter->GetOutput()); if (IsParameterEnabled("foutpos") && HasValue("foutpos")) { SetParameterOutputImage("foutpos", m_Filter->GetSpatialOutput()); } if(!IsParameterEnabled("modesearch")) { otbAppLogINFO(<<"Mode Search is disabled." << std::endl); } } MSFilterType::Pointer m_Filter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::MeanShiftSmoothing) OTB-release-5.8/Modules/Applications/AppSegmentation/app/otbSegmentation.cxx000066400000000000000000001073571301006202600272350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Wrappers #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbWrapperChoiceParameter.h" // Segmentation filters includes #include "otbMeanShiftSegmentationFilter.h" #include "otbConnectedComponentMuParserFunctor.h" #include "otbMaskMuParserFilter.h" #include "otbVectorImageToAmplitudeImageFilter.h" #include "itkGradientMagnitudeImageFilter.h" #include "otbWatershedSegmentationFilter.h" #include "otbMorphologicalProfilesSegmentationFilter.h" // Large scale vectorization framework #include "otbStreamingImageToOGRLayerSegmentationFilter.h" // Fusion filter #include "otbOGRLayerStreamStitchingFilter.h" #include "otbGeoInformationConversion.h" //Utils #include "itksys/SystemTools.hxx" namespace otb { namespace Wrapper { class Segmentation : public Application { public: /** Standard class typedefs. */ typedef Segmentation Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Images typedefs */ typedef UInt32ImageType LabelImageType; typedef UInt32ImageType MaskImageType; // Segmentation filters typedefs // Home made mean-shift typedef otb::MeanShiftSegmentationFilter MeanShiftSegmentationFilterType; // Simple connected components typedef otb::Functor::ConnectedComponentMuParserFunctor FunctorType; typedef itk::ConnectedComponentFunctorImageFilter ConnectedComponentSegmentationFilterType; typedef itk::ScalarConnectedComponentImageFilter LabeledConnectedComponentSegmentationFilterType; // Watershed typedef otb::VectorImageToAmplitudeImageFilter AmplitudeFilterType; typedef itk::GradientMagnitudeImageFilter GradientMagnitudeFilterType; typedef otb::WatershedSegmentationFilter WatershedSegmentationFilterType; // Geodesic morphology multiscale segmentation typedef otb::MorphologicalProfilesSegmentationFilter MorphologicalProfilesSegmentationFilterType; // mask filter typedef otb::MaskMuParserFilter MaskMuParserFilterType; // Vectorize filters // Home made mean-shift typedef otb::StreamingImageToOGRLayerSegmentationFilter MeanShiftVectorizedSegmentationOGRType; // Connected components typedef otb::StreamingImageToOGRLayerSegmentationFilter ConnectedComponentStreamingVectorizedSegmentationOGRType; // Morphological profiles typedef otb::StreamingImageToOGRLayerSegmentationFilter MorphoVectorizedSegmentationOGRType; typedef otb::OGRLayerStreamStitchingFilter FusionFilterType; // Watershed typedef otb::StreamingImageToOGRLayerSegmentationFilter StreamingVectorizedWatershedFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Segmentation, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("Segmentation"); SetDescription("Performs segmentation of an image, and output either a raster or a vector file. In vector mode, large input datasets are supported."); // Documentation SetDocName("Segmentation"); SetDocLongDescription("This application allows one to perform various segmentation algorithms on a multispectral image." "Available segmentation algorithms are two different versions of Mean-Shift segmentation algorithm (one being multi-threaded)," " simple pixel based connected components according to a user-defined criterion, and watershed from the gradient of the intensity" " (norm of spectral bands vector). The application has two different modes that affects the nature of its output.\n\nIn raster mode," " the output of the application is a classical image of unique labels identifying the segmented regions. The labeled output can be passed to the" " ColorMapping application to render regions with contrasted colours. Please note that this mode loads the whole input image into memory, and as such" " can not handle large images. \n\n To segment large data, one can use the vector mode. In this case, the output of the application is a" " vector file or database. The input image is split into tiles (whose size can be set using the tilesize parameter), and each tile is loaded, segmented" " with the chosen algorithm, vectorized, and written into the output file or database. This piece-wise behavior ensure that memory will never get overloaded," " and that images of any size can be processed. There are few more options in the vector mode. The simplify option allows simplifying the geometry" " (i.e. remove nodes in polygons) according to a user-defined tolerance. The stitch option tries to stitch together the polygons corresponding" " to segmented region that may have been split by the tiling scheme. "); SetDocLimitations("In raster mode, the application can not handle large input images. Stitching step of vector mode might become slow with very large input images." " \nMeanShift filter results depends on the number of threads used. \nWatershed and multiscale geodesic morphology segmentation will be performed on the amplitude " " of the input image."); SetDocAuthors("OTB-Team"); SetDocSeeAlso("MeanShiftSegmentation"); AddDocTag(Tags::Segmentation); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to segment"); AddParameter(ParameterType_Choice, "filter", "Segmentation algorithm"); SetParameterDescription("filter", "Choice of segmentation algorithm (mean-shift by default)"); AddChoice("filter.meanshift", "Mean-Shift"); SetParameterDescription( "filter.meanshift","OTB implementation of the Mean-Shift algorithm (multi-threaded)."); // MeanShift Parameters AddParameter(ParameterType_Int, "filter.meanshift.spatialr", "Spatial radius"); SetParameterDescription("filter.meanshift.spatialr", "Spatial radius of the neighborhood."); AddParameter(ParameterType_Float, "filter.meanshift.ranger", "Range radius"); SetParameterDescription("filter.meanshift.ranger", "Range radius defining the radius (expressed in radiometry unit) in the multispectral space."); AddParameter(ParameterType_Float, "filter.meanshift.thres", "Mode convergence threshold"); SetParameterDescription("filter.meanshift.thres", "Algorithm iterative scheme will stop if mean-shift " "vector is below this threshold or if iteration number reached maximum number of iterations."); AddParameter(ParameterType_Int, "filter.meanshift.maxiter", "Maximum number of iterations"); SetParameterDescription("filter.meanshift.maxiter", "Algorithm iterative scheme will stop if convergence hasn't been reached after the maximum number of iterations."); AddParameter(ParameterType_Int, "filter.meanshift.minsize", "Minimum region size"); SetParameterDescription("filter.meanshift.minsize", "Minimum size of a region (in pixel unit) in segmentation. Smaller clusters will be merged to the neighboring cluster with the closest radiometry." " If set to 0 no pruning is done."); //AddParameter(ParameterType_Empty, "filter.meanshift.useoptim", "use optimization"); //SetParameterDescription("filter.meanshift.useoptim", "Use mode optimization."); //MandatoryOff("filter.meanshift.useoptim"); SetDefaultParameterInt("filter.meanshift.spatialr", 5); SetDefaultParameterFloat("filter.meanshift.ranger", 15.0); SetDefaultParameterFloat("filter.meanshift.thres", 0.1); SetMinimumParameterFloatValue("filter.meanshift.thres", 0.1); SetDefaultParameterInt("filter.meanshift.minsize", 100); SetMinimumParameterIntValue("filter.meanshift.minsize", 0); SetDefaultParameterInt("filter.meanshift.maxiter", 100); SetMinimumParameterIntValue("filter.meanshift.maxiter", 1); //Connected component segmentation parameters AddChoice("filter.cc", "Connected components"); SetParameterDescription("filter.cc", "Simple pixel-based connected-components algorithm with a user-defined connection condition."); AddParameter(ParameterType_String, "filter.cc.expr", "Condition"); SetParameterDescription("filter.cc.expr", "User defined connection condition, written as a mathematical expression. Available variables are p(i)b(i), intensity_p(i) and distance (example of expression : distance < 10 )"); // Watershed AddChoice("filter.watershed","Watershed"); SetParameterDescription("filter.watershed","The traditional watershed algorithm. The height function is the gradient magnitude of the amplitude (square root of the sum of squared bands)."); AddParameter(ParameterType_Float,"filter.watershed.threshold","Depth Threshold"); SetParameterDescription("filter.watershed.threshold","Depth threshold Units in percentage of the maximum depth in the image."); SetDefaultParameterFloat("filter.watershed.threshold",0.01); SetMinimumParameterFloatValue("filter.watershed.threshold",0); SetMaximumParameterFloatValue("filter.watershed.threshold",1); AddParameter(ParameterType_Float,"filter.watershed.level","Flood Level"); SetParameterDescription("filter.watershed.level","flood level for generating the merge tree from the initial segmentation (between 0 and 1)"); SetDefaultParameterFloat("filter.watershed.level",0.1); SetMinimumParameterFloatValue("filter.watershed.level",0); SetMaximumParameterFloatValue("filter.watershed.level",1); AddParameter(ParameterType_Choice, "mode", "Processing mode"); SetParameterDescription("mode", "Choice of processing mode, either raster or large-scale."); AddChoice("mode.vector", "Tile-based large-scale segmentation with vector output"); SetParameterDescription("mode.vector","In this mode, the application will output a vector file or database, and process the input image piecewise. This allows performing segmentation of very large images."); AddChoice("mode.raster", "Standard segmentation with labeled raster output"); SetParameterDescription("mode.raster","In this mode, the application will output a standard labeled raster. This mode can not handle large data."); // GeoMorpho AddChoice("filter.mprofiles","Morphological profiles based segmentation"); SetParameterDescription("filter.mprofiles","Segmentation based on morphological profiles, as described in Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: A new approach for the morphological segmentation of high resolution satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, NO. 2, February 2001, p. 309-320."); AddParameter(ParameterType_Int,"filter.mprofiles.size","Profile Size"); SetParameterDescription("filter.mprofiles.size","Size of the profiles"); SetDefaultParameterInt("filter.mprofiles.size",5); SetMinimumParameterIntValue("filter.mprofiles.size",2); AddParameter(ParameterType_Int,"filter.mprofiles.start","Initial radius"); SetParameterDescription("filter.mprofiles.start","Initial radius of the structuring element (in pixels)"); SetDefaultParameterInt("filter.mprofiles.start",1); SetMinimumParameterIntValue("filter.mprofiles.start",1); AddParameter(ParameterType_Int,"filter.mprofiles.step","Radius step."); SetParameterDescription("filter.mprofiles.step","Radius step along the profile (in pixels)"); SetDefaultParameterInt("filter.mprofiles.step",1); SetMinimumParameterIntValue("filter.mprofiles.step",1); AddParameter(ParameterType_Float,"filter.mprofiles.sigma","Threshold of the final decision rule"); SetParameterDescription("filter.mprofiles.sigma","Profiles values under the threshold will be ignored."); SetDefaultParameterFloat("filter.mprofiles.sigma",1.); SetMinimumParameterFloatValue("filter.mprofiles.sigma",0.); //Raster mode parameters AddParameter(ParameterType_OutputImage, "mode.raster.out", "Output labeled image"); SetParameterDescription( "mode.raster.out", "The output labeled image."); SetDefaultOutputPixelType("mode.raster.out",ImagePixelType_uint32); //Streaming vectorization parameters AddParameter(ParameterType_OutputFilename, "mode.vector.out", "Output vector file"); SetParameterDescription("mode.vector.out", "The output vector file or database (name can be anything understood by OGR)"); AddParameter(ParameterType_Choice,"mode.vector.outmode","Writing mode for the output vector file"); SetParameterDescription("mode.vector.outmode","This allows one to set the writing behaviour for the output vector file. Please note that the actual behaviour depends on the file format."); AddChoice("mode.vector.outmode.ulco","Update output vector file, only allow creating new layers"); SetParameterDescription("mode.vector.outmode.ulco","The output vector file is opened in update mode if existing. If the output layer already exists, the application stops, leaving it untouched."); AddChoice("mode.vector.outmode.ovw","Overwrite output vector file if existing."); SetParameterDescription("mode.vector.outmode.ovw","If the output vector file already exists, it is completely destroyed (including all its layers) and recreated from scratch."); AddChoice("mode.vector.outmode.ulovw","Update output vector file, overwrite existing layer"); SetParameterDescription("mode.vector.outmode.ulovw","The output vector file is opened in update mode if existing. If the output layer already exists, it si completely destroyed and recreated from scratch."); AddChoice("mode.vector.outmode.ulu","Update output vector file, update existing layer"); SetParameterDescription("mode.vector.outmode.ulu","The output vector file is opened in update mode if existing. If the output layer already exists, the new geometries are appended to the layer."); AddParameter(ParameterType_InputImage, "mode.vector.inmask", "Mask Image"); SetParameterDescription("mode.vector.inmask", "Only pixels whose mask value is strictly positive will be segmented."); MandatoryOff("mode.vector.inmask"); AddParameter(ParameterType_Empty, "mode.vector.neighbor", "8-neighbor connectivity"); SetParameterDescription("mode.vector.neighbor", "Activate 8-Neighborhood connectivity (default is 4)."); MandatoryOff("mode.vector.neighbor"); DisableParameter("mode.vector.neighbor"); AddParameter(ParameterType_Empty,"mode.vector.stitch","Stitch polygons"); SetParameterDescription("mode.vector.stitch", "Scan polygons on each side of tiles and stitch polygons which connect by more than one pixel."); MandatoryOff("mode.vector.stitch"); EnableParameter("mode.vector.stitch"); AddParameter(ParameterType_Int, "mode.vector.minsize", "Minimum object size"); SetParameterDescription("mode.vector.minsize", "Objects whose size is below the minimum object size (area in pixels) will be ignored during vectorization."); SetDefaultParameterInt("mode.vector.minsize", 1); SetMinimumParameterIntValue("mode.vector.minsize", 1); MandatoryOff("mode.vector.minsize"); DisableParameter("mode.vector.minsize"); AddParameter(ParameterType_Float, "mode.vector.simplify", "Simplify polygons"); SetParameterDescription("mode.vector.simplify", "Simplify polygons according to a given tolerance (in pixel). This option allows reducing the size of the output file or database."); SetDefaultParameterFloat("mode.vector.simplify",0.1); MandatoryOff("mode.vector.simplify"); DisableParameter("mode.vector.simplify"); AddParameter(ParameterType_String, "mode.vector.layername", "Layer name"); SetParameterDescription("mode.vector.layername", "Name of the layer in the vector file or database (default is Layer)."); SetParameterString("mode.vector.layername", "layer"); AddParameter(ParameterType_String, "mode.vector.fieldname", "Geometry index field name"); SetParameterDescription("mode.vector.fieldname", "Name of the field holding the geometry index in the output vector file or database."); SetParameterString("mode.vector.fieldname", "DN"); AddParameter(ParameterType_Int, "mode.vector.tilesize", "Tiles size"); SetParameterDescription("mode.vector.tilesize", "User defined tiles size for tile-based segmentation. Optimal tile size is selected according to available RAM if null."); SetDefaultParameterInt("mode.vector.tilesize",1024); SetMinimumParameterIntValue("mode.vector.tilesize",0); AddParameter(ParameterType_Int, "mode.vector.startlabel", "Starting geometry index"); SetParameterDescription("mode.vector.startlabel", "Starting value of the geometry index field"); SetDefaultParameterInt("mode.vector.startlabel", 1); SetMinimumParameterIntValue("mode.vector.startlabel", 1); AddParameter(ParameterType_StringList,"mode.vector.ogroptions","OGR options for layer creation"); SetParameterDescription("mode.vector.ogroptions","A list of layer creation options in the form KEY=VALUE that will be passed directly to OGR without any validity checking. Options may depend on the file format, and can be found in OGR documentation."); MandatoryOff("mode.vector.ogroptions"); // Doc example parameter settings SetExampleComment("Example of use with vector mode and watershed segmentation",0); SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_PAN.tif"); SetDocExampleParameterValue("mode","vector"); SetDocExampleParameterValue("mode.vector.out", "SegmentationVector.sqlite"); SetDocExampleParameterValue("filter", "watershed"); AddExample("Example of use with raster mode and mean-shift segmentation"); SetDocExampleParameterValue("in", "QB_Toulouse_Ortho_PAN.tif",1); SetDocExampleParameterValue("mode","raster",1); SetDocExampleParameterValue("mode.raster.out", "SegmentationRaster.tif uint16",1); SetDocExampleParameterValue("filter", "meanshift",1); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } template FloatVectorImageType::SizeType GenericApplySegmentation(otb::StreamingImageToOGRLayerSegmentationFilter * streamingVectorizedFilter, TInputImage * inputImage, const otb::ogr::Layer& layer, const unsigned int outputNb) { // Retrieve tile size parameter const unsigned int tileSize = static_cast (this->GetParameterInt("mode.vector.tilesize")); // Retrieve the 8-connected option bool use8connected = IsParameterEnabled("mode.vector.neighbor"); // Retrieve min object size parameter const unsigned int minSize = static_cast (this->GetParameterInt("mode.vector.minsize")); // Switch on segmentation mode const std::string segModeType = GetParameterString("mode"); streamingVectorizedFilter->SetInput(inputImage); if (segModeType == "vector" && HasValue("mode.vector.inmask")) { streamingVectorizedFilter->SetInputMask(this->GetParameterUInt32Image("mode.vector.inmask")); otbAppLogINFO(<<"Use a mask as input." << std::endl); } streamingVectorizedFilter->SetOGRLayer(layer); if (tileSize != 0) { streamingVectorizedFilter->GetStreamer()->SetTileDimensionTiledStreaming(tileSize); } else { streamingVectorizedFilter->GetStreamer()->SetAutomaticTiledStreaming(); } if (use8connected) { otbAppLogINFO(<<"Use 8 connected neighborhood."<SetUse8Connected(use8connected); if (minSize > 1) { otbAppLogINFO(<<"Object with size under "<< minSize <<" will be suppressed."<SetFilterSmallObject(true); streamingVectorizedFilter->SetMinimumObjectSize(minSize); } const std::string fieldName = this->GetParameterString("mode.vector.fieldname"); // Retrieve start label parameter const unsigned int startLabel = this->GetParameterInt("mode.vector.startlabel"); streamingVectorizedFilter->SetFieldName(fieldName); streamingVectorizedFilter->SetStartLabel(startLabel); if(IsParameterEnabled("mode.vector.simplify") && GetParameterString("mode") == "vector") { streamingVectorizedFilter->SetSimplify(true); streamingVectorizedFilter->SetSimplificationTolerance(GetParameterFloat("mode.vector.simplify")); otbAppLogINFO(<<"Simplify the geometry." << std::endl); } else { streamingVectorizedFilter->SetSimplify(false); } if (segModeType == "vector") { otbAppLogINFO(<<"Large scale segmentation mode which output vector data" << std::endl); DisableParameter("mode.raster.out"); EnableParameter("mode.vector.out"); AddProcess(streamingVectorizedFilter->GetStreamer(), "Computing " + (dynamic_cast (this->GetParameterByKey("filter")))->GetChoiceKey(GetParameterInt("filter")) + " segmentation"); streamingVectorizedFilter->Initialize(); //must be called ! streamingVectorizedFilter->Update(); //must be called ! } else if (segModeType == "raster") { otbAppLogINFO(<<"Segmentation mode which output label image" << std::endl); DisableParameter("mode.vector.out"); EnableParameter("mode.raster.out"); streamingVectorizedFilter->GetSegmentationFilter()->SetInput(inputImage); SetParameterOutputImage ("mode.raster.out", dynamic_cast (streamingVectorizedFilter->GetSegmentationFilter()->GetOutputs().at(outputNb).GetPointer())); //TODO add progress reporting in raster mode // AddProcess(dynamic_cast (GetParameterByKey("mode.raster.out"))->GetWriter(), // "Computing " + (dynamic_cast // (this->GetParameterByKey("filter")))->GetChoiceKey(GetParameterInt("filter")) // + " segmentation"); streamingVectorizedFilter->GetSegmentationFilter()->Update(); } return streamingVectorizedFilter->GetStreamSize(); } void DoExecute() ITK_OVERRIDE { // Switch on segmentation mode const std::string segModeType = GetParameterString("mode"); // Switch on segmentation filter case const std::string segType = GetParameterString("filter"); otb::ogr::DataSource::Pointer ogrDS; otb::ogr::Layer layer(ITK_NULLPTR, false); std::string projRef = GetParameterFloatVectorImage("in")->GetProjectionRef(); OGRSpatialReference oSRS(projRef.c_str()); if (segModeType == "vector") { // Retrieve output filename as well as layer names std::string dataSourceName = GetParameterString("mode.vector.out"); //projection ref conversion to ESRI need to be tested in case of .shp if ((dataSourceName.find(".shp") != std::string::npos) && (!projRef.empty())) { if (!(otb::GeoInformationConversion::IsESRIValidWKT(projRef))) { otbAppLogFATAL(<<"Image projection reference "< options = GetParameterStringList("mode.vector.ogroptions"); // Create the DataSource in the appropriate mode if (outmode == "ovw") { // Create the datasource ogrDS = otb::ogr::DataSource::New(dataSourceName, otb::ogr::DataSource::Modes::Overwrite); // and create the layer since we are in overwrite mode, the // datasource is blank layer = ogrDS->CreateLayer(GetParameterString("mode.vector.layername"), &oSRS, wkbMultiPolygon, options); // And create the field OGRFieldDefn field(this->GetParameterString("mode.vector.fieldname").c_str(), OFTInteger); layer.CreateField(field, true); } else if (outmode == "ulovw") { // Create the datasource ogrDS = otb::ogr::DataSource::New(dataSourceName, otb::ogr::DataSource::Modes::Update_LayerOverwrite); // and create the layer since we are in overwrite mode, the // datasource is blank layer = ogrDS->CreateLayer(GetParameterString("mode.vector.layername"), &oSRS, wkbMultiPolygon, options); // And create the field OGRFieldDefn field(this->GetParameterString("mode.vector.fieldname").c_str(), OFTInteger); layer.CreateField(field, true); } else if (outmode == "ulu") { // Create the datasource ogrDS = otb::ogr::DataSource::New(dataSourceName, otb::ogr::DataSource::Modes::Update_LayerUpdate); // and create the layer since we are in overwrite mode, the // datasource is blank layer = ogrDS->CreateLayer(GetParameterString("mode.vector.layername"), &oSRS, wkbMultiPolygon, options); // And create the field if necessary std::string fieldName = this->GetParameterString("mode.vector.fieldname"); OGRFeatureDefn & ogrFeatureDfn = layer.GetLayerDefn(); if (-1 == ogrFeatureDfn.GetFieldIndex(fieldName.c_str())) { OGRFieldDefn field(fieldName.c_str(), OFTInteger); layer.CreateField(field, true); } } else if (outmode == "ulco") { // Create the datasource ogrDS = otb::ogr::DataSource::New(dataSourceName, otb::ogr::DataSource::Modes::Update_LayerCreateOnly); // and create the layer since we are in overwrite mode, the // datasource is blank layer = ogrDS->CreateLayer(GetParameterString("mode.vector.layername"), &oSRS, wkbMultiPolygon, options); // And create the field OGRFieldDefn field(this->GetParameterString("mode.vector.fieldname").c_str(), OFTInteger); layer.CreateField(field, true); } else { otbAppLogFATAL(<<"outmode not handled yet: "<< outmode); } } // The actual stream size used FloatVectorImageType::SizeType streamSize; if (segType == "cc") { otbAppLogINFO(<<"Use connected component segmentation."<GetSegmentationFilter()->SetMaskImage( this->GetParameterUInt32Image("mode.vector.inmask")); } ccVectorizationFilter->GetSegmentationFilter()->GetFunctor().SetExpression(GetParameterString("filter.cc.expr")); streamSize = GenericApplySegmentation ( ccVectorizationFilter, this->GetParameterFloatVectorImage( "in"), layer, 0); } else if (segType == "meanshift") { otbAppLogINFO(<<"Use threaded Mean-shift segmentation."< (this->GetParameterInt("filter.meanshift.spatialr")); const float rangeRadius = static_cast (this->GetParameterFloat("filter.meanshift.ranger")); const unsigned int minimumObjectSize = static_cast (this->GetParameterInt("filter.meanshift.minsize")); const float threshold = this->GetParameterFloat("filter.meanshift.thres"); const unsigned int maxIterNumber = static_cast (this->GetParameterInt("filter.meanshift.maxiter")); meanShiftVectorizationFilter->GetSegmentationFilter()->SetSpatialBandwidth(spatialRadius); meanShiftVectorizationFilter->GetSegmentationFilter()->SetRangeBandwidth(rangeRadius); meanShiftVectorizationFilter->GetSegmentationFilter()->SetMaxIterationNumber(maxIterNumber); meanShiftVectorizationFilter->GetSegmentationFilter()->SetThreshold(threshold); meanShiftVectorizationFilter->GetSegmentationFilter()->SetMinRegionSize(minimumObjectSize); streamSize = this->GenericApplySegmentation ( meanShiftVectorizationFilter, this->GetParameterFloatVectorImage( "in"), layer, 0); } else if (segType == "watershed") { otbAppLogINFO(<<"Using watershed segmentation."<SetInput(this->GetParameterFloatVectorImage("in")); GradientMagnitudeFilterType::Pointer gradientMagnitudeFilter = GradientMagnitudeFilterType::New(); gradientMagnitudeFilter->SetInput(amplitudeFilter->GetOutput()); StreamingVectorizedWatershedFilterType::Pointer watershedVectorizedFilter = StreamingVectorizedWatershedFilterType::New(); watershedVectorizedFilter->GetSegmentationFilter()->SetThreshold( GetParameterFloat( "filter.watershed.threshold")); watershedVectorizedFilter->GetSegmentationFilter()->SetLevel(GetParameterFloat("filter.watershed.level")); streamSize = this->GenericApplySegmentation ( watershedVectorizedFilter, gradientMagnitudeFilter->GetOutput(), layer, 0); } else if (segType == "mprofiles") { otbAppLogINFO(<<"Using multiscale geodesic morphology segmentation."<SetInput(this->GetParameterFloatVectorImage("in")); MorphoVectorizedSegmentationOGRType::Pointer morphoVectorizedSegmentation = MorphoVectorizedSegmentationOGRType::New(); morphoVectorizedSegmentation->GetSegmentationFilter()->SetProfileStart(initialValue); morphoVectorizedSegmentation->GetSegmentationFilter()->SetProfileSize(profileSize); morphoVectorizedSegmentation->GetSegmentationFilter()->SetProfileStep(step); morphoVectorizedSegmentation->GetSegmentationFilter()->SetSigma(sigma); streamSize = GenericApplySegmentation ( morphoVectorizedSegmentation, amplitudeFilter->GetOutput(), layer, 0); } else { otbAppLogFATAL(<<"non defined filtering method "<SyncToDisk(); // Stitching mode if (IsParameterEnabled("mode.vector.stitch")) { otbAppLogINFO(<<"Segmentation done, stiching polygons ..."); FusionFilterType::Pointer fusionFilter = FusionFilterType::New(); fusionFilter->SetInput(GetParameterFloatVectorImage("in")); fusionFilter->SetOGRLayer(layer); fusionFilter->SetStreamSize(streamSize); AddProcess(fusionFilter, "Stitching polygons"); fusionFilter->GenerateData(); //REPACK the Layer in case of Shapefile. //This request will remove features marked as deleted in the .dbf filename, //and recomputed FID for each features (without holes). //Note : the GetDriver() Method has not been encapsulated in otb::ogr::DataSource, //so we must access the OGR pointer by using .ogr() std::string driverName(otb::ogr::version_proxy::GetDriverNameFromDataSource(&ogrDS->ogr())); if ( driverName.find("ESRI Shapefile") != std::string::npos) { otbAppLogINFO(<<"REPACK the Shapefile ..."<ExecuteSQL(repack, ITK_NULLPTR, ITK_NULLPTR); } } } } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::Segmentation) OTB-release-5.8/Modules/Applications/AppSegmentation/otb-module.cmake000066400000000000000000000010441301006202600256220ustar00rootroot00000000000000set(DOCUMENTATION "Segmentation application.") otb_module(OTBAppSegmentation DEPENDS OTBVectorDataBase OTBOGRProcessing OTBConversion OTBStatistics OTBImageIO OTBITK OTBCCOBIA OTBWatersheds OTBTransform OTBMetrics OTBSmoothing OTBMeanShift OTBGdalAdapters OTBApplicationEngine OTBImageBase OTBCommon OTBImageManipulation OTBMorphologicalProfiles OTBLabelMap OTBProjection TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppSegmentation/test/000077500000000000000000000000001301006202600235315ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppSegmentation/test/CMakeLists.txt000066400000000000000000000323651301006202600263020ustar00rootroot00000000000000otb_module_test() #----------- Segmentation TESTS ---------------- # Segmentation algorithms parameters set(cc_parameters "-filter.cc.expr" "distance<25") set(edison_parameters "-filter.edison.spatialr" "5" "-filter.edison.ranger" "50" "-filter.edison.minsize" "10") set(meanshift_parameters "-filter.meanshift.spatialr" "5" "-filter.meanshift.ranger" "50" "-filter.meanshift.minsize" "10") set(vector_parameters "-mode.vector.tilesize" "500" "-mode.vector.minsize" "50" "-mode.vector.simplify" "0.1" "-mode.vector.outmode" "ovw") # validation option set(meanshift_option "--without-threads") # Output type dependning on mode set(raster_output_format ".tif") set(raster_output_option "uint16") set(vector_output_format ".sqlite") # Validation depending on mode set(vector_comparison --compare-ogr ${NOTOL}) set(raster_comparison --compare-image ${NOTOL}) # Reference ffiles depending on modes set(vector_ref_path ${BASELINE_FILES}) set(raster_ref_path ${BASELINE}) set(filterList "Meanshift" "CC" "Watershed") # Loop on modes foreach(mode "Raster" "Vector") string(TOLOWER ${mode} lmode) # Loop on filters foreach(filter ${filterList}) string(TOLOWER ${filter} lfilter) # Derive output file name set(OUTFILE apTvSeSegmentation${filter}${mode}${${lmode}_output_format}) if(NOT (${filter} STREQUAL "Meanshift" AND ${mode} STREQUAL "Raster")) OTB_TEST_APPLICATION(NAME apTvSeSegmentation${filter}${mode} APP Segmentation OPTIONS -in ${EXAMPLEDATA}/qb_RoadExtract2.tif -filter ${lfilter} ${${lfilter}_parameters} -mode ${lmode} -mode.${lmode}.out ${TEMP}/${OUTFILE} ${${lmode}_output_option} ${${lmode}_parameters} VALID ${${lfilter}_option} ${${lmode}_comparison} ${${lmode}_ref_path}/${OUTFILE} ${TEMP}/${OUTFILE} ) endif() endforeach() endforeach() set(filter "CC") set(mode "Vector") string(TOLOWER ${filter} lfilter) # Add a test for ULOVW set(vector_parameters "-mode.vector.tilesize" "500" "-mode.vector.minsize" "50" "-mode.vector.simplify" "0.1" "-mode.vector.outmode" "ulovw") set(OUTFILE apTvSeSegmentation${filter}${mode}${${lmode}_output_format}) OTB_TEST_APPLICATION(NAME apTvSeSegmentation${filter}${mode}_ULOVW APP Segmentation OPTIONS -in ${EXAMPLEDATA}/qb_RoadExtract2.tif -filter ${lfilter} ${${lfilter}_parameters} -mode ${lmode} -mode.${lmode}.out ${TEMP}/${OUTFILE} ${${lmode}_output_option} ${${lmode}_parameters} VALID ${${lfilter}_option} ${${lmode}_comparison} ${${lmode}_ref_path}/${OUTFILE} ${TEMP}/${OUTFILE} ) set_tests_properties(apTvSeSegmentation${filter}${mode}_ULOVW PROPERTIES DEPENDS apTvSeSegmentation${filter}${mode} RESOURCE_LOCK ${OUTFILE}) # Add a test for ULU set(vector_parameters "-mode.vector.tilesize" "500" "-mode.vector.minsize" "50" "-mode.vector.simplify" "0.1" "-mode.vector.outmode" "ulu") OTB_TEST_APPLICATION(NAME apTvSeSegmentation${filter}${mode}_ULU APP Segmentation OPTIONS -in ${EXAMPLEDATA}/qb_RoadExtract2.tif -filter ${lfilter} ${${lfilter}_parameters} -mode ${lmode} -mode.${lmode}.out ${TEMP}/${OUTFILE} ${${lmode}_output_option} ${${lmode}_parameters} VALID ${${lfilter}_option} ${${lmode}_comparison} ${${lmode}_ref_path}/${OUTFILE}_ULU ${TEMP}/${OUTFILE} ) set_tests_properties(apTvSeSegmentation${filter}${mode}_ULU PROPERTIES DEPENDS apTvSeSegmentation${filter}${mode} RESOURCE_LOCK ${OUTFILE}) # Add a test for ULCO set(vector_parameters "-mode.vector.tilesize" "500" "-mode.vector.minsize" "50" "-mode.vector.simplify" "0.1" "-mode.vector.outmode" "ulco") OTB_TEST_APPLICATION(NAME apTvSeSegmentation${filter}${mode}_ULCO APP Segmentation OPTIONS -in ${EXAMPLEDATA}/qb_RoadExtract2.tif -filter ${lfilter} ${${lfilter}_parameters} -mode ${lmode} -mode.${lmode}.out ${TEMP}/${OUTFILE} ${${lmode}_output_option} ${${lmode}_parameters} VALID ${${lfilter}_option} ${${lmode}_comparison} ${${lmode}_ref_path}/${OUTFILE} ${TEMP}/${OUTFILE} ) set_tests_properties(apTvSeSegmentation${filter}${mode}_ULCO PROPERTIES DEPENDS apTvSeSegmentation${filter}${mode} WILL_FAIL TRUE RESOURCE_LOCK ${OUTFILE}) #----------- ConnectedComponentSegmentation TESTS ---------------- otb_test_application(NAME apTvCcConnectedComponentSegmentationMaskMuParserShp APP ConnectedComponentSegmentation OPTIONS -in ${INPUTDATA}/ROI_QB_MUL_4.tif -out ${TEMP}/apTvCcConnectedComponentSegmentationMaskMuParser.shp -mask "((b1>80)*intensity>95)" -expr "distance<10" -minsize 15 -obia "SHAPE_Elongation>8" VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvCcConnectedComponentSegmentationMaskMuParser.shp ${TEMP}/apTvCcConnectedComponentSegmentationMaskMuParser.shp) otb_test_application(NAME apTvCcConnectedComponentSegmentatioNoMask APP ConnectedComponentSegmentation OPTIONS -in ${INPUTDATA}/ROI_QB_MUL_4.tif -out ${TEMP}/apTvCcConnectedComponentSegmentationNoMask.shp -expr "distance<10" -minsize 15 -obia "SHAPE_Elongation>8" VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvCcConnectedComponentSegmentationNoMask.shp ${TEMP}/apTvCcConnectedComponentSegmentationNoMask.shp) #----------- MeanShiftSmoothing TESTS ---------------- otb_test_application(NAME apTvLSMS1MeanShiftSmoothingNoModeSearch APP MeanShiftSmoothing OPTIONS -in ${EXAMPLEDATA}/QB_1_ortho.tif -fout ${TEMP}/apTvLSMS1_filtered_range.tif -foutpos ${TEMP}/apTvLSMS1_filtered_spatial.tif -ranger 30 -spatialr 5 -maxiter 10 -modesearch 0 VALID --compare-n-images ${EPSILON_7} 2 ${BASELINE}/apTvLSMS1_filtered_range.tif ${TEMP}/apTvLSMS1_filtered_range.tif ${BASELINE}/apTvLSMS1_filtered_spatial.tif ${TEMP}/apTvLSMS1_filtered_spatial.tif ) otb_test_application(NAME apTuSeMeanShiftSmoothing APP MeanShiftSmoothing OPTIONS -in ${INPUTDATA}/QB_Suburb.png -fout ${TEMP}/apTvSeMeanShiftSmoothingFilter_SpectralOutput.tif -foutpos ${TEMP}/apTvSeMeanShiftSmoothingFilter_SpatialOutput.tif -spatialr 4 -ranger 25 -maxiter 10 -thres 0.1 -modesearch 0) #----------- LSMSSegmentation TESTS ---------------- otb_test_application(NAME apTvLSMS2Segmentation APP LSMSSegmentation OPTIONS -in ${TEMP}/apTvLSMS1_filtered_range.tif -inpos ${TEMP}/apTvLSMS1_filtered_spatial.tif -out ${TEMP}/apTvLSMS2_Segmentation.tif uint32 -ranger 30 -spatialr 5 -minsize 0 -tilesizex 100 -tilesizey 100 VALID --compare-image ${NOTOL} ${BASELINE}/apTvLSMS2_Segmentation.tif ${TEMP}/apTvLSMS2_Segmentation.tif ) set_property(TEST apTvLSMS2Segmentation PROPERTY DEPENDS apTvLSMS1MeanShiftSmoothingNoModeSearch) otb_test_application(NAME apTvLSMS2Segmentation_NoSmall APP LSMSSegmentation OPTIONS -in ${TEMP}/apTvLSMS1_filtered_range.tif -inpos ${TEMP}/apTvLSMS1_filtered_spatial.tif -out ${TEMP}/apTvLSMS2_Segmentation_NoSmall.tif uint32 -ranger 30 -spatialr 5 -minsize 10 -tilesizex 100 -tilesizey 100 VALID --compare-image ${NOTOL} ${BASELINE}/apTvLSMS2_Segmentation_NoSmall.tif ${TEMP}/apTvLSMS2_Segmentation_NoSmall.tif ) set_property(TEST apTvLSMS2Segmentation_NoSmall PROPERTY DEPENDS apTvLSMS1MeanShiftSmoothingNoModeSearch) #----------- LSMSSmallRegionsMerging TESTS ---------------- otb_test_application(NAME apTvLSMS3SmallRegionsMerging APP LSMSSmallRegionsMerging OPTIONS -in ${TEMP}/apTvLSMS1_filtered_range.tif -inseg ${TEMP}/apTvLSMS2_Segmentation.tif -out ${TEMP}/apTvLSMS3_Segmentation_SmallMerged.tif uint32 -minsize 10 -tilesizex 100 -tilesizey 100 VALID --compare-image ${NOTOL} ${BASELINE}/apTvLSMS3_Segmentation_SmallMerged.tif ${TEMP}/apTvLSMS3_Segmentation_SmallMerged.tif ) set_property(TEST apTvLSMS3SmallRegionsMerging PROPERTY DEPENDS apTvLSMS2Segmentation) #----------- LSMSVectorization TESTS ---------------- otb_test_application(NAME apTvLSMS4Vectorization_SmallMerged APP LSMSVectorization OPTIONS -in ${EXAMPLEDATA}/QB_1_ortho.tif -inseg ${BASELINE}/apTvLSMS3_Segmentation_SmallMerged.tif -out ${TEMP}/apTvLSMS4_Segmentation_SmallMerged.shp -tilesizex 100 -tilesizey 100 VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvLSMS4_Segmentation_SmallMerged.shp ${TEMP}/apTvLSMS4_Segmentation_SmallMerged.shp ) set_property(TEST apTvLSMS4Vectorization_SmallMerged PROPERTY DEPENDS apTvLSMS3SmallRegionsMerging) otb_test_application(NAME apTvLSMS4Vectorization_NoSmall APP LSMSVectorization OPTIONS -in ${EXAMPLEDATA}/QB_1_ortho.tif -inseg ${TEMP}/apTvLSMS2_Segmentation_NoSmall.tif -out ${TEMP}/apTvLSMS4_Segmentation_NoSmall.shp -tilesizex 100 -tilesizey 100 VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvLSMS4_Segmentation_NoSmall.shp ${TEMP}/apTvLSMS4_Segmentation_NoSmall.shp ) set_property(TEST apTvLSMS4Vectorization_NoSmall PROPERTY DEPENDS apTvLSMS2Segmentation_NoSmall) #----------- HooverCompareSegmentation TESTS ---------------- otb_test_application(NAME apTvSeHooverCompareSegmentationTest APP HooverCompareSegmentation OPTIONS -ingt ${INPUTDATA}/maur_GT.tif -inms ${INPUTDATA}/maur_labelled.tif -outgt ${TEMP}/apTvSeHooverCompareSegmentationTestOutgt.tif -outms ${TEMP}/apTvSeHooverCompareSegmentationTestOutms.tif TESTENVOPTIONS ${TEMP}/apTvSeHooverCompareSegmentationTest.txt VALID --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/apTvSeHooverCompareSegmentationTest.txt ${TEMP}/apTvSeHooverCompareSegmentationTest.txt --ignore-lines-with 2 outgt: outms: ) OTB-release-5.8/Modules/Applications/AppStereo/000077500000000000000000000000001301006202600213565ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppStereo/CMakeLists.txt000066400000000000000000000000501301006202600241110ustar00rootroot00000000000000project(OTBAppStereo) otb_module_impl() OTB-release-5.8/Modules/Applications/AppStereo/app/000077500000000000000000000000001301006202600221365ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppStereo/app/CMakeLists.txt000066400000000000000000000024321301006202600246770ustar00rootroot00000000000000set(OTBAppStereo_LINK_LIBS ${OTBStereo_LIBRARIES} ${OTBStatistics_LIBRARIES} ${OTBImageIO_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBInterpolation_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBDisplacementField_LIBRARIES} ${OTBDisparityMap_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBMathParser_LIBRARIES} ${OTBObjectList_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ) otb_create_application( NAME StereoFramework SOURCES otbStereoFramework.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME StereoRectificationGridGenerator SOURCES otbStereoRectificationGridGenerator.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME FineRegistration SOURCES otbFineRegistration.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME GeneratePlyFile SOURCES otbGeneratePlyFile.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME DisparityMapToElevationMap SOURCES otbDisparityMapToElevationMap.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME BlockMatching SOURCES otbBlockMatching.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppStereo/app/otbBlockMatching.cxx000066400000000000000000001041451301006202600261010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbVarianceImageFilter.h" #include "otbBandMathImageFilter.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "otbSubPixelDisparityImageFilter.h" #include "otbDisparityMapMedianFilter.h" namespace otb { namespace Wrapper { class BlockMatching : public Application { public: /** Standard class typedefs. */ typedef BlockMatching Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::Functor::SSDBlockMatching SSDBlockMatchingFunctorType; typedef otb::Functor::NCCBlockMatching NCCBlockMatchingFunctorType; typedef otb::Functor::LPBlockMatching LPBlockMatchingFunctorType; typedef otb::PixelWiseBlockMatchingImageFilter SSDBlockMatchingFilterType; typedef otb::PixelWiseBlockMatchingImageFilter NCCBlockMatchingFilterType; typedef otb::PixelWiseBlockMatchingImageFilter LPBlockMatchingFilterType; typedef otb::VarianceImageFilter VarianceFilterType; typedef otb::BandMathImageFilter BandMathFilterType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; typedef otb::SubPixelDisparityImageFilter SSDSubPixelDisparityFilterType; typedef otb::SubPixelDisparityImageFilter NCCSubPixelDisparityFilterType; typedef otb::SubPixelDisparityImageFilter LPSubPixelDisparityFilterType; typedef otb::DisparityMapMedianFilter MedianFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(BlockMatching, otb::Application); /** Filters typedef */ private: BlockMatching() { // Initialize filters m_SSDBlockMatcher = SSDBlockMatchingFilterType::New(); m_NCCBlockMatcher = NCCBlockMatchingFilterType::New(); m_LPBlockMatcher = LPBlockMatchingFilterType::New(); m_SSDSubPixFilter = SSDSubPixelDisparityFilterType::New(); m_NCCSubPixFilter = NCCSubPixelDisparityFilterType::New(); m_LPSubPixFilter = LPSubPixelDisparityFilterType::New(); m_LVarianceFilter = VarianceFilterType::New(); m_RVarianceFilter = VarianceFilterType::New(); m_LBandMathFilter = BandMathFilterType::New(); m_RBandMathFilter = BandMathFilterType::New(); m_OutputImageList = ImageListType::New(); m_ImageListFilter = ImageListToVectorImageFilterType::New(); m_HMedianFilter = MedianFilterType::New(); m_VMedianFilter = MedianFilterType::New(); } void DoInit() ITK_OVERRIDE { SetName("BlockMatching"); SetDescription("Performs block-matching to estimate pixel-wise disparities between two images"); SetDocName("Pixel-wise Block-Matching"); SetDocLongDescription("This application allows one to performs block-matching to estimate pixel-wise disparities " "between two images. One must chose block-matching method and input" " masks (related to the left and right input image) of pixels for which the disparity should be investigated. " "Additionally, two criteria can be optionally used to disable disparity investigation for some pixel: a " "no-data value, and a threshold on the local variance. This allows one to speed-up computation by avoiding to " "investigate disparities that will not be reliable anyway. For efficiency reasons, if the optimal metric values" " image is desired, it will be concatenated to the output image (which will then have three bands : horizontal " "disparity, vertical disparity and metric value). One can split these images afterward."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otbStereoRectificationGridGenerator"); AddDocTag(Tags::Stereo); AddParameter(ParameterType_Group,"io","Input and output data"); SetParameterDescription("io","This group of parameters allows setting the input and output images."); AddParameter(ParameterType_InputImage,"io.inleft","Left input image"); SetParameterDescription("io.inleft","The left input image (reference)"); AddParameter(ParameterType_InputImage,"io.inright","Right input image"); SetParameterDescription("io.inright","The right input (secondary)"); AddParameter(ParameterType_OutputImage, "io.out", "The output disparity map"); SetParameterDescription("io.out","An image containing the estimated disparities as well as the metric values if the option is used"); AddParameter(ParameterType_OutputImage, "io.outmask", "The output mask corresponding to all criterions"); SetParameterDescription("io.outmask","A mask image corresponding to all citerions (see masking parameters). Only required if variance threshold or nodata criterions are set."); SetDefaultOutputPixelType("io.outmask",ImagePixelType_uint8); DisableParameter("io.outmask"); MandatoryOff("io.outmask"); AddParameter(ParameterType_Empty,"io.outmetric","Output optimal metric values as well"); SetParameterDescription("io.outmetric","If used, the output image will have a second component with metric optimal values"); AddParameter(ParameterType_Group,"mask","Image masking parameters"); SetParameterDescription("mask","This group of parameters allows determining the masking parameters to prevent disparities estimation for some pixels of the left image"); AddParameter(ParameterType_InputImage,"mask.inleft","Discard left pixels from mask image"); SetParameterDescription("mask.inleft","This parameter allows providing a custom mask for the left image.Block matching will be only perform on pixels inside the mask."); MandatoryOff("mask.inleft"); AddParameter(ParameterType_InputImage,"mask.inright","Discard right pixels from mask image"); SetParameterDescription("mask.inright","This parameter allows providing a custom mask for the right image.Block matching will be perform only on pixels inside the mask."); MandatoryOff("mask.inright"); AddParameter(ParameterType_Float,"mask.nodata","Discard pixels with no-data value"); SetParameterDescription("mask.nodata","This parameter allows discarding pixels whose value is equal to the user-defined no-data value."); MandatoryOff("mask.nodata"); SetDefaultParameterFloat("mask.nodata",0.); DisableParameter("mask.nodata"); AddParameter(ParameterType_Float,"mask.variancet","Discard pixels with low local variance"); SetParameterDescription("mask.variancet","This parameter allows discarding pixels whose local variance is too small (the size of the neighborhood is given by the radius parameter)"); MandatoryOff("mask.variancet"); SetDefaultParameterFloat("mask.variancet",100.); DisableParameter("mask.variancet"); AddParameter(ParameterType_Group,"bm","Block matching parameters"); SetParameterDescription("bm","This group of parameters allow tuning the block-matching behaviour"); AddParameter(ParameterType_Choice, "bm.metric", "Block-matching metric"); AddChoice("bm.metric.ssd","Sum of Squared Distances"); SetParameterDescription("bm.metric.ssd","Sum of squared distances between pixels value in the metric window"); AddChoice("bm.metric.ncc","Normalized Cross-Correlation"); SetParameterDescription("bm.metric.ncc","Normalized Cross-Correlation between the left and right windows"); AddChoice("bm.metric.lp","Lp pseudo-norm"); SetParameterDescription("bm.metric.lp","Lp pseudo-norm between the left and right windows"); AddParameter(ParameterType_Float,"bm.metric.lp.p","p value" ); SetParameterDescription("bm.metric.lp.p", "Value of the p parameter in Lp pseudo-norm (must be positive)"); SetDefaultParameterFloat("bm.metric.lp.p", 1.0); SetMinimumParameterFloatValue("bm.metric.lp.p", 0.0); AddParameter(ParameterType_Int,"bm.radius","Radius of blocks"); SetParameterDescription("bm.radius","The radius (in pixels) of blocks in Block-Matching"); SetDefaultParameterInt("bm.radius",3); SetMinimumParameterIntValue("bm.radius",1); AddParameter(ParameterType_Int,"bm.minhd","Minimum horizontal disparity"); SetParameterDescription("bm.minhd","Minimum horizontal disparity to explore (can be negative)"); AddParameter(ParameterType_Int,"bm.maxhd","Maximum horizontal disparity"); SetParameterDescription("bm.maxhd","Maximum horizontal disparity to explore (can be negative)"); AddParameter(ParameterType_Int,"bm.minvd","Minimum vertical disparity"); SetParameterDescription("bm.minvd","Minimum vertical disparity to explore (can be negative)"); AddParameter(ParameterType_Int,"bm.maxvd","Maximum vertical disparity"); SetParameterDescription("bm.maxvd","Maximum vertical disparity to explore (can be negative)"); AddParameter(ParameterType_Choice,"bm.subpixel","Sub-pixel interpolation"); SetParameterDescription("bm.subpixel", "Estimate disparities with sub-pixel precision"); AddChoice("bm.subpixel.none", "None"); SetParameterDescription("bm.subpixel.none", "No sub-pixel "); AddChoice("bm.subpixel.parabolic", "Parabolic"); SetParameterDescription("bm.subpixel.parabolic", "Parabolic fit"); AddChoice("bm.subpixel.triangular", "Triangular"); SetParameterDescription("bm.subpixel.triangular", "Triangular fit"); AddChoice("bm.subpixel.dichotomy", "Dichotomy"); SetParameterDescription("bm.subpixel.dichotomy", "Dichotomic search"); AddParameter(ParameterType_Int,"bm.step", "Computation step"); SetParameterDescription("bm.step", "Location step between computed disparities"); SetDefaultParameterInt("bm.step",1); SetMinimumParameterIntValue("bm.step",1); MandatoryOff("bm.step"); AddParameter(ParameterType_Int,"bm.startx","X start index"); SetParameterDescription("bm.startx","X start index of the subsampled grid (wrt the input image grid)"); SetDefaultParameterInt("bm.startx",0); MandatoryOff("bm.startx"); AddParameter(ParameterType_Int,"bm.starty","Y start index"); SetParameterDescription("bm.starty","Y start index of the subsampled grid (wrt the input image grid)"); SetDefaultParameterInt("bm.starty",0); MandatoryOff("bm.starty"); AddParameter(ParameterType_Group,"bm.medianfilter","Median filtering"); SetParameterDescription("bm.medianfilter","Use a median filter to get a smooth disparity map"); AddParameter(ParameterType_Int,"bm.medianfilter.radius", "Radius"); SetParameterDescription("bm.medianfilter.radius", "Radius for median filter"); MandatoryOff("bm.medianfilter.radius"); DisableParameter("bm.medianfilter.radius"); AddParameter(ParameterType_Float,"bm.medianfilter.incoherence", "Incoherence threshold"); SetParameterDescription("bm.medianfilter.incoherence", "Incoherence threshold between original and filtered disparity"); MandatoryOff("bm.medianfilter.incoherence"); DisableParameter("bm.medianfilter.incoherence"); AddParameter(ParameterType_Choice, "bm.initdisp", "Initial disparities"); AddChoice("bm.initdisp.none", "None"); SetParameterDescription("bm.initdisp.none", "No initial disparity used"); AddChoice("bm.initdisp.uniform", "Uniform initial disparity"); SetParameterDescription("bm.initdisp.uniform", "Use an uniform initial disparity estimate"); AddParameter(ParameterType_Int, "bm.initdisp.uniform.hdisp", "Horizontal initial disparity"); SetParameterDescription("bm.initdisp.uniform.hdisp", "Value of the uniform horizontal disparity initial estimate (in pixels)"); SetDefaultParameterInt("bm.initdisp.uniform.hdisp", 0); AddParameter(ParameterType_Int, "bm.initdisp.uniform.vdisp", "Vertical initial disparity"); SetParameterDescription("bm.initdisp.uniform.vdisp", "Value of the uniform vertical disparity initial estimate (in pixels)"); SetDefaultParameterInt("bm.initdisp.uniform.vdisp", 0); AddParameter(ParameterType_Int, "bm.initdisp.uniform.hrad", "Horizontal exploration radius"); SetParameterDescription("bm.initdisp.uniform.hrad", "Horizontal exploration radius around the initial disparity estimate (in pixels)"); SetDefaultParameterInt("bm.initdisp.uniform.hrad", 0); DisableParameter("bm.initdisp.uniform.hrad"); AddParameter(ParameterType_Int, "bm.initdisp.uniform.vrad", "Vertical exploration radius"); SetParameterDescription("bm.initdisp.uniform.vrad", "Vertical exploration radius around the initial disparity estimate (in pixels)"); SetDefaultParameterInt("bm.initdisp.uniform.vrad", 0); DisableParameter("bm.initdisp.uniform.vrad"); AddChoice("bm.initdisp.maps", "Initial disparity maps"); SetParameterDescription("bm.initdisp.maps", "Use initial disparity maps"); AddParameter(ParameterType_InputImage, "bm.initdisp.maps.hmap", "Horizontal initial disparity map"); SetParameterDescription("bm.initdisp.maps.hmap", "Map of the initial horizontal disparities"); AddParameter(ParameterType_InputImage, "bm.initdisp.maps.vmap", "Vertical initial disparity map"); SetParameterDescription("bm.initdisp.maps.vmap", "Map of the initial vertical disparities"); AddParameter(ParameterType_Int, "bm.initdisp.maps.hrad", "Horizontal exploration radius"); SetParameterDescription("bm.initdisp.maps.hrad", "Horizontal exploration radius around the initial disparity estimate (in pixels)"); SetDefaultParameterInt("bm.initdisp.maps.hrad", 0); DisableParameter("bm.initdisp.maps.hrad"); AddParameter(ParameterType_Int, "bm.initdisp.maps.vrad", "Vertical exploration radius"); SetParameterDescription("bm.initdisp.maps.vrad", "Vertical exploration radius around the initial disparity estimate (in pixels)"); SetDefaultParameterInt("bm.initdisp.maps.vrad", 0); DisableParameter("bm.initdisp.maps.vrad"); //this->DebugOn(); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("io.inleft","StereoFixed.png"); SetDocExampleParameterValue("io.inright","StereoMoving.png"); SetDocExampleParameterValue("bm.minhd","-10"); SetDocExampleParameterValue("bm.maxhd","10"); SetDocExampleParameterValue("mask.variancet","10"); SetDocExampleParameterValue("io.out","MyDisparity.tif"); } void DoUpdateParameters() ITK_OVERRIDE { if(IsParameterEnabled("mask.variancet") || IsParameterEnabled("mask.nodata")) { EnableParameter("io.outmask"); } else { DisableParameter("io.outmask"); } // enforce positive radii if (GetParameterInt("bm.radius") < 1) { SetParameterInt("bm.radius",1); } if(GetParameterInt("bm.initdisp.uniform.hrad") < 0) { SetParameterInt("bm.initdisp.uniform.hrad",0); } if(GetParameterInt("bm.initdisp.uniform.vrad") < 0) { SetParameterInt("bm.initdisp.uniform.vrad",0); } if(GetParameterInt("bm.initdisp.maps.hrad") < 0) { SetParameterInt("bm.initdisp.maps.hrad",0); } if(GetParameterInt("bm.initdisp.maps.vrad") < 0) { SetParameterInt("bm.initdisp.maps.vrad",0); } } void DoExecute() ITK_OVERRIDE { FloatImageType::Pointer leftImage = GetParameterFloatImage("io.inleft"); FloatImageType::Pointer rightImage = GetParameterFloatImage("io.inright"); FloatImageType::Pointer leftmask; FloatImageType::Pointer rightmask; unsigned int radius = GetParameterInt("bm.radius"); int minhdisp = GetParameterInt("bm.minhd"); int maxhdisp = GetParameterInt("bm.maxhd"); int minvdisp = GetParameterInt("bm.minvd"); int maxvdisp = GetParameterInt("bm.maxvd"); unsigned int step = GetParameterInt("bm.step"); FloatImageType::IndexType gridIndex; gridIndex[0] = GetParameterInt("bm.startx"); gridIndex[1] = GetParameterInt("bm.starty"); std::ostringstream leftBandMathCondition; std::ostringstream rightBandMathCondition; unsigned int inputIdLeft = 0; unsigned int inputIdRight = 0; bool maskingLeft = false; bool maskingRight = false; bool useInitialDispUniform = false; bool useInitialDispMap = false; // Handle input mask if present if(IsParameterEnabled("mask.inleft")) { leftmask = GetParameterFloatImage("mask.inleft"); m_LBandMathFilter->SetNthInput(inputIdLeft,leftmask,"inmask"); maskingLeft = true; ++inputIdLeft; leftBandMathCondition<<"inmask > 0"; } if(IsParameterEnabled("mask.inright")) { rightmask = GetParameterFloatImage("mask.inright"); m_RBandMathFilter->SetNthInput(inputIdRight,rightmask,"inmask"); maskingRight = true; ++inputIdRight; rightBandMathCondition<<"inmask > 0"; } // Handle variance threshold if present if(IsParameterEnabled("mask.variancet")) { if(maskingLeft) { leftBandMathCondition<<" and "; } if(maskingRight) { rightBandMathCondition<<" and "; } // Left side m_LVarianceFilter->SetInput(leftImage); VarianceFilterType::InputSizeType vradius; vradius.Fill(radius); m_LVarianceFilter->SetRadius(vradius); m_LBandMathFilter->SetNthInput(inputIdLeft,m_LVarianceFilter->GetOutput(),"variance"); leftBandMathCondition<<"variance > "<SetInput(rightImage); m_RVarianceFilter->SetRadius(vradius); m_RBandMathFilter->SetNthInput(inputIdRight,m_RVarianceFilter->GetOutput(),"variance"); rightBandMathCondition<<"variance > "<SetNthInput(inputIdLeft,leftImage,"leftimage"); leftBandMathCondition<<"leftimage != "<SetNthInput(inputIdRight,rightImage,"rightimage"); rightBandMathCondition<<"rightimage != "<Info("Masking criterion on left image: " + leftBandMathExpression.str() + '\n'); m_LBandMathFilter->SetExpression(leftBandMathExpression.str()); } if(maskingRight) { GetLogger()->Info("Masking criterion on right image: " + rightBandMathExpression.str() + '\n'); m_RBandMathFilter->SetExpression(rightBandMathExpression.str()); } // Uniform initial disparity case if (GetParameterInt("bm.initdisp") == 1) { if (GetParameterInt("bm.initdisp.uniform.hrad") > 0 && GetParameterInt("bm.initdisp.uniform.vrad") > 0) { useInitialDispUniform = true; } } // Initial disparity map case if (GetParameterInt("bm.initdisp") == 2) { if (GetParameterInt("bm.initdisp.maps.hrad") > 0 && GetParameterInt("bm.initdisp.maps.vrad") > 0) { useInitialDispMap = true; } } FloatImageType * hdispImage; FloatImageType * vdispImage; FloatImageType * metricImage; FloatImageType * maskLeftImage; FloatImageType * maskRightImage; maskLeftImage = m_LBandMathFilter->GetOutput(); maskRightImage = m_RBandMathFilter->GetOutput(); // SSD case if(GetParameterInt("bm.metric") == 0) { m_SSDBlockMatcher->SetLeftInput(leftImage); m_SSDBlockMatcher->SetRightInput(rightImage); m_SSDBlockMatcher->SetRadius(radius); m_SSDBlockMatcher->SetStep(step); m_SSDBlockMatcher->SetGridIndex(gridIndex); m_SSDBlockMatcher->SetMinimumHorizontalDisparity(minhdisp); m_SSDBlockMatcher->SetMaximumHorizontalDisparity(maxhdisp); m_SSDBlockMatcher->SetMinimumVerticalDisparity(minvdisp); m_SSDBlockMatcher->SetMaximumVerticalDisparity(maxvdisp); AddProcess(m_SSDBlockMatcher,"SSD block matching"); if(maskingLeft) { m_SSDBlockMatcher->SetLeftMaskInput(maskLeftImage); } if(maskingRight) { m_SSDBlockMatcher->SetRightMaskInput(maskRightImage); } if(useInitialDispUniform) { FloatImageType::SizeType expRadius; expRadius[0] = GetParameterInt("bm.initdisp.uniform.hrad"); expRadius[1] = GetParameterInt("bm.initdisp.uniform.vrad"); m_SSDBlockMatcher->SetExplorationRadius(expRadius); m_SSDBlockMatcher->SetInitHorizontalDisparity(GetParameterInt("bm.initdisp.uniform.hdisp")); m_SSDBlockMatcher->SetInitVerticalDisparity(GetParameterInt("bm.initdisp.uniform.vdisp")); } if(useInitialDispMap) { FloatImageType::SizeType expRadius; expRadius[0] = GetParameterInt("bm.initdisp.maps.hrad"); expRadius[1] = GetParameterInt("bm.initdisp.maps.vrad"); m_SSDBlockMatcher->SetExplorationRadius(expRadius); m_SSDBlockMatcher->SetHorizontalDisparityInput(GetParameterFloatImage("bm.initdisp.maps.hmap")); m_SSDBlockMatcher->SetVerticalDisparityInput(GetParameterFloatImage("bm.initdisp.maps.vmap")); } if (GetParameterInt("bm.subpixel") > 0) { m_SSDSubPixFilter->SetInputsFromBlockMatchingFilter(m_SSDBlockMatcher); AddProcess(m_SSDSubPixFilter,"Sub-pixel refinement"); switch (GetParameterInt("bm.subpixel")) { case 1 : m_SSDSubPixFilter->SetRefineMethod(SSDSubPixelDisparityFilterType::PARABOLIC); break; case 2 : m_SSDSubPixFilter->SetRefineMethod(SSDSubPixelDisparityFilterType::TRIANGULAR); break; case 3 : m_SSDSubPixFilter->SetRefineMethod(SSDSubPixelDisparityFilterType::DICHOTOMY); break; default : break; } hdispImage = m_SSDSubPixFilter->GetHorizontalDisparityOutput(); vdispImage = m_SSDSubPixFilter->GetVerticalDisparityOutput(); metricImage = m_SSDSubPixFilter->GetMetricOutput(); } else { hdispImage = m_SSDBlockMatcher->GetHorizontalDisparityOutput(); vdispImage = m_SSDBlockMatcher->GetVerticalDisparityOutput(); metricImage = m_SSDBlockMatcher->GetMetricOutput(); } } // NCC case else if (GetParameterInt("bm.metric") == 1) { m_NCCBlockMatcher->SetLeftInput(leftImage); m_NCCBlockMatcher->SetRightInput(rightImage); m_NCCBlockMatcher->SetRadius(radius); m_NCCBlockMatcher->SetStep(step); m_NCCBlockMatcher->SetGridIndex(gridIndex); m_NCCBlockMatcher->SetMinimumHorizontalDisparity(minhdisp); m_NCCBlockMatcher->SetMaximumHorizontalDisparity(maxhdisp); m_NCCBlockMatcher->SetMinimumVerticalDisparity(minvdisp); m_NCCBlockMatcher->SetMaximumVerticalDisparity(maxvdisp); m_NCCBlockMatcher->MinimizeOff(); AddProcess(m_NCCBlockMatcher,"NCC block matching"); if(maskingLeft) { m_NCCBlockMatcher->SetLeftMaskInput(maskLeftImage); } if(maskingRight) { m_NCCBlockMatcher->SetRightMaskInput(maskRightImage); } if(useInitialDispUniform) { FloatImageType::SizeType expRadius; expRadius[0] = GetParameterInt("bm.initdisp.uniform.hrad"); expRadius[1] = GetParameterInt("bm.initdisp.uniform.vrad"); m_NCCBlockMatcher->SetExplorationRadius(expRadius); m_NCCBlockMatcher->SetInitHorizontalDisparity(GetParameterInt("bm.initdisp.uniform.hdisp")); m_NCCBlockMatcher->SetInitVerticalDisparity(GetParameterInt("bm.initdisp.uniform.vdisp")); } if(useInitialDispMap) { FloatImageType::SizeType expRadius; expRadius[0] = GetParameterInt("bm.initdisp.maps.hrad"); expRadius[1] = GetParameterInt("bm.initdisp.maps.vrad"); m_NCCBlockMatcher->SetExplorationRadius(expRadius); m_NCCBlockMatcher->SetHorizontalDisparityInput(GetParameterFloatImage("bm.initdisp.maps.hmap")); m_NCCBlockMatcher->SetVerticalDisparityInput(GetParameterFloatImage("bm.initdisp.maps.vmap")); } if (GetParameterInt("bm.subpixel") > 0) { m_NCCSubPixFilter->SetInputsFromBlockMatchingFilter(m_NCCBlockMatcher); AddProcess(m_NCCSubPixFilter,"Sub-pixel refinement"); switch (GetParameterInt("bm.subpixel")) { case 1 : m_NCCSubPixFilter->SetRefineMethod(NCCSubPixelDisparityFilterType::PARABOLIC); break; case 2 : m_NCCSubPixFilter->SetRefineMethod(NCCSubPixelDisparityFilterType::TRIANGULAR); break; case 3 : m_NCCSubPixFilter->SetRefineMethod(NCCSubPixelDisparityFilterType::DICHOTOMY); break; default : break; } hdispImage = m_NCCSubPixFilter->GetHorizontalDisparityOutput(); vdispImage = m_NCCSubPixFilter->GetVerticalDisparityOutput(); metricImage = m_NCCSubPixFilter->GetMetricOutput(); } else { hdispImage = m_NCCBlockMatcher->GetHorizontalDisparityOutput(); vdispImage = m_NCCBlockMatcher->GetVerticalDisparityOutput(); metricImage = m_NCCBlockMatcher->GetMetricOutput(); } } // Lp case else { m_LPBlockMatcher->SetLeftInput(leftImage); m_LPBlockMatcher->SetRightInput(rightImage); m_LPBlockMatcher->SetRadius(radius); m_LPBlockMatcher->SetStep(step); m_LPBlockMatcher->SetGridIndex(gridIndex); m_LPBlockMatcher->GetFunctor().SetP(static_cast(GetParameterFloat("bm.metric.lp.p"))); m_LPBlockMatcher->SetMinimumHorizontalDisparity(minhdisp); m_LPBlockMatcher->SetMaximumHorizontalDisparity(maxhdisp); m_LPBlockMatcher->SetMinimumVerticalDisparity(minvdisp); m_LPBlockMatcher->SetMaximumVerticalDisparity(maxvdisp); AddProcess(m_LPBlockMatcher,"Lp block matching"); if(maskingLeft) { m_LPBlockMatcher->SetLeftMaskInput(maskLeftImage); } if(maskingRight) { m_LPBlockMatcher->SetRightMaskInput(maskRightImage); } if(useInitialDispUniform) { FloatImageType::SizeType expRadius; expRadius[0] = GetParameterInt("bm.initdisp.uniform.hrad"); expRadius[1] = GetParameterInt("bm.initdisp.uniform.vrad"); m_LPBlockMatcher->SetExplorationRadius(expRadius); m_LPBlockMatcher->SetInitHorizontalDisparity(GetParameterInt("bm.initdisp.uniform.hdisp")); m_LPBlockMatcher->SetInitVerticalDisparity(GetParameterInt("bm.initdisp.uniform.vdisp")); } if(useInitialDispMap) { FloatImageType::SizeType expRadius; expRadius[0] = GetParameterInt("bm.initdisp.maps.hrad"); expRadius[1] = GetParameterInt("bm.initdisp.maps.vrad"); m_LPBlockMatcher->SetExplorationRadius(expRadius); m_LPBlockMatcher->SetHorizontalDisparityInput(GetParameterFloatImage("bm.initdisp.maps.hmap")); m_LPBlockMatcher->SetVerticalDisparityInput(GetParameterFloatImage("bm.initdisp.maps.vmap")); } if (GetParameterInt("bm.subpixel") > 0) { m_LPSubPixFilter->SetInputsFromBlockMatchingFilter(m_LPBlockMatcher); AddProcess(m_LPSubPixFilter,"Sub-pixel refinement"); switch (GetParameterInt("bm.subpixel")) { case 1 : m_LPSubPixFilter->SetRefineMethod(LPSubPixelDisparityFilterType::PARABOLIC); break; case 2 : m_LPSubPixFilter->SetRefineMethod(LPSubPixelDisparityFilterType::TRIANGULAR); break; case 3 : m_LPSubPixFilter->SetRefineMethod(LPSubPixelDisparityFilterType::DICHOTOMY); break; default : break; } hdispImage = m_LPSubPixFilter->GetHorizontalDisparityOutput(); vdispImage = m_LPSubPixFilter->GetVerticalDisparityOutput(); metricImage = m_LPSubPixFilter->GetMetricOutput(); } else { hdispImage = m_LPBlockMatcher->GetHorizontalDisparityOutput(); vdispImage = m_LPBlockMatcher->GetVerticalDisparityOutput(); metricImage = m_LPBlockMatcher->GetMetricOutput(); } } if (IsParameterEnabled("bm.medianfilter.radius") && IsParameterEnabled("bm.medianfilter.incoherence")) { otbAppLogINFO("Applies a median filter to smooth the disparity map"<SetInput(hdispImage); m_HMedianFilter->SetRadius(GetParameterInt("bm.medianfilter.radius")); m_HMedianFilter->SetIncoherenceThreshold(GetParameterFloat("bm.medianfilter.incoherence")); if (maskingLeft) { m_HMedianFilter->SetMaskInput(maskLeftImage); } hdispImage = m_HMedianFilter->GetOutput(); } if (minvdisp < maxvdisp) { m_VMedianFilter->SetInput(vdispImage); m_VMedianFilter->SetRadius(GetParameterInt("bm.medianfilter.radius")); m_VMedianFilter->SetIncoherenceThreshold(GetParameterFloat("bm.medianfilter.incoherence")); if (maskingLeft) { m_VMedianFilter->SetMaskInput(maskLeftImage); } vdispImage = m_VMedianFilter->GetOutput(); } } m_OutputImageList->Clear(); m_OutputImageList->PushBack(hdispImage); m_OutputImageList->PushBack(vdispImage); if(IsParameterEnabled("io.outmetric")) { m_OutputImageList->PushBack(metricImage); } m_ImageListFilter->SetInput(m_OutputImageList); SetParameterOutputImage("io.out",m_ImageListFilter->GetOutput()); if(IsParameterEnabled("io.outmask")) { SetParameterOutputImage("io.outmask",maskLeftImage); // The right side mask is not saved because the application computes disparities from left to right } } // SSD Block matching filter SSDBlockMatchingFilterType::Pointer m_SSDBlockMatcher; // NCC Block matching filter NCCBlockMatchingFilterType::Pointer m_NCCBlockMatcher; // Lp Block matching filter LPBlockMatchingFilterType::Pointer m_LPBlockMatcher; // SSD sub-pixel disparity filter SSDSubPixelDisparityFilterType::Pointer m_SSDSubPixFilter; // NCC sub-pixel disparity filter NCCSubPixelDisparityFilterType::Pointer m_NCCSubPixFilter; // LP sub-pixel disparity filter LPSubPixelDisparityFilterType::Pointer m_LPSubPixFilter; // Variance filter for left image VarianceFilterType::Pointer m_LVarianceFilter; // Variance filter for right image VarianceFilterType::Pointer m_RVarianceFilter; // Band-math filter for left mask BandMathFilterType::Pointer m_LBandMathFilter; // Band-math filter for right mask BandMathFilterType::Pointer m_RBandMathFilter; // The Image list ImageListType::Pointer m_OutputImageList; // Image list to VectorImage filter ImageListToVectorImageFilterType::Pointer m_ImageListFilter; // Horizontal Median filter MedianFilterType::Pointer m_HMedianFilter; // Vertical Median filter MedianFilterType::Pointer m_VMedianFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::BlockMatching) OTB-release-5.8/Modules/Applications/AppStereo/app/otbDisparityMapToElevationMap.cxx000066400000000000000000000161641301006202600306150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbDisparityMapToDEMFilter.h" #include "otbWrapperElevationParametersHandler.h" #include "otbImageList.h" #include "otbVectorImageToImageListFilter.h" namespace otb { namespace Wrapper { class DisparityMapToElevationMap : public Application { public: /** Standard class typedefs. */ typedef DisparityMapToElevationMap Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorImageToListFilterType; typedef otb::DisparityMapToDEMFilter DisparityToElevationFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(DisparityMapToElevationMap, otb::Application); /** Filters typedef */ private: DisparityMapToElevationMap() { // Initialize filters m_VectorToList = VectorImageToListFilterType::New(); m_DispToElev = DisparityToElevationFilterType::New(); } void DoInit() ITK_OVERRIDE { SetName("DisparityMapToElevationMap"); SetDescription("Projects a disparity map into a regular elevation map"); SetDocName("Disparity map to elevation map"); SetDocLongDescription("This application uses a disparity map computed from a stereo image pair to produce an " "elevation map on the ground area covered by the stereo pair. The needed inputs are : the disparity map, " "the stereo pair (in original geometry) and the epipolar deformation grids. These grids have to link the " "original geometry (stereo pair) and the epipolar geometry (disparity map). "); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otbStereoRectificationGridGenerator otbBlockMatching"); AddDocTag(Tags::Stereo); AddParameter(ParameterType_Group,"io","Input and output data"); SetParameterDescription("io","This group of parameters allows one to set input images, output images and grids."); AddParameter(ParameterType_InputImage,"io.in","Input disparity map"); SetParameterDescription("io.in","The input disparity map (horizontal disparity in first band, vertical in second)"); AddParameter(ParameterType_InputImage,"io.left","Left sensor image"); SetParameterDescription("io.left","Left image in original (sensor) geometry"); AddParameter(ParameterType_InputImage,"io.right","Right sensor image"); SetParameterDescription("io.right","Right image in original (sensor) geometry"); AddParameter(ParameterType_InputImage,"io.lgrid","Left Grid"); SetParameterDescription("io.lgrid","Left epipolar grid (deformation grid between sensor et disparity spaces)"); AddParameter(ParameterType_InputImage,"io.rgrid","Right Grid"); SetParameterDescription("io.rgrid","Right epipolar grid (deformation grid between sensor et disparity spaces)"); AddParameter(ParameterType_OutputImage,"io.out","Output elevation map"); SetParameterDescription("io.out", "Output elevation map in ground projection"); AddParameter(ParameterType_Float,"step","DEM step"); SetParameterDescription("step","Spacing of the output elevation map (in meters)"); SetDefaultParameterFloat("step",5.0); AddParameter(ParameterType_Float,"hmin","Minimum elevation expected"); SetParameterDescription("hmin","Minimum elevation expected (in meters)"); SetDefaultParameterFloat("hmin",0.0); AddParameter(ParameterType_Float,"hmax","Maximum elevation expected"); SetParameterDescription("hmax","Maximum elevation expected (in meters)"); SetDefaultParameterFloat("hmax",100.0); AddParameter(ParameterType_InputImage,"io.mask","Disparity mask"); SetParameterDescription("io.mask","Masked disparity cells won't be projected"); MandatoryOff("io.mask"); ElevationParametersHandler::AddElevationParameters(this, "elev"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("io.in","disparity.tif"); SetDocExampleParameterValue("io.left","sensor_left.tif"); SetDocExampleParameterValue("io.right","sensor_right.tif"); SetDocExampleParameterValue("io.lgrid","grid_epi_left.tif"); SetDocExampleParameterValue("io.rgrid","grid_epi_right.tif"); SetDocExampleParameterValue("io.out","dem.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inputDisp = this->GetParameterImage("io.in"); FloatVectorImageType::Pointer sensorLeft = this->GetParameterImage("io.left"); FloatVectorImageType::Pointer sensorRight = this->GetParameterImage("io.right"); FloatVectorImageType::Pointer gridLeft = this->GetParameterImage("io.lgrid"); FloatVectorImageType::Pointer gridRight = this->GetParameterImage("io.rgrid"); m_VectorToList->SetInput(inputDisp); m_VectorToList->UpdateOutputInformation(); m_DispToElev->SetHorizontalDisparityMapInput(m_VectorToList->GetOutput()->GetNthElement(0)); m_DispToElev->SetVerticalDisparityMapInput(m_VectorToList->GetOutput()->GetNthElement(1)); m_DispToElev->SetLeftInput(sensorLeft); m_DispToElev->SetRightInput(sensorRight); m_DispToElev->SetLeftEpipolarGridInput(gridLeft); m_DispToElev->SetRightEpipolarGridInput(gridRight); m_DispToElev->SetElevationMin(this->GetParameterFloat("hmin")); m_DispToElev->SetElevationMax(this->GetParameterFloat("hmax")); m_DispToElev->SetDEMGridStep(this->GetParameterFloat("step")); if (IsParameterEnabled("io.mask")) { m_DispToElev->SetDisparityMaskInput(this->GetParameterUInt8Image("io.mask")); } // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); m_DispToElev->UpdateOutputInformation(); FloatVectorImageType::RegionType outputRegion = m_DispToElev->GetOutput()->GetLargestPossibleRegion(); otbAppLogINFO(<<"Elevation map origin : [" << m_DispToElev->GetOutput()->GetOrigin()[0] << "," << m_DispToElev->GetOutput()->GetOrigin()[1] << "]" << std::endl); otbAppLogINFO(<<"Elevation map size : [" << outputRegion.GetSize()[0] << "," << outputRegion.GetSize()[1] << "]" << std::endl); this->SetParameterOutputImage("io.out",m_DispToElev->GetOutput()); } VectorImageToListFilterType::Pointer m_VectorToList; DisparityToElevationFilterType::Pointer m_DispToElev; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::DisparityMapToElevationMap) OTB-release-5.8/Modules/Applications/AppStereo/app/otbFineRegistration.cxx000066400000000000000000000461341301006202600266530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbVectorImageToIntensityImageFilter.h" #include "otbFineRegistrationImageFilter.h" #include "otbImageListToVectorImageFilter.h" #include "otbMultiChannelExtractROI.h" #include "otbStreamingWarpImageFilter.h" #include "otbImageFileReader.h" #include "itkDiscreteGaussianImageFilter.h" #include "itkAbsImageFilter.h" #include "itkNormalizedCorrelationImageToImageMetric.h" #include "itkMeanReciprocalSquareDifferenceImageToImageMetric.h" #include "itkMeanSquaresImageToImageMetric.h" #include "itkMattesMutualInformationImageToImageMetric.h" #include "itkBinaryThresholdImageFilter.h" #include "itkVectorIndexSelectionCastImageFilter.h" #include "itkFixedArray.h" namespace otb { namespace Wrapper { template class VLVToFixedArray { public: TFixedArray operator()(const TVLV& vlv) { TFixedArray output; output[0] = vlv[0]; output[1] = vlv[1]; return output; } }; class FineRegistration : public Application { public: /** Standard class typedefs. */ typedef FineRegistration Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(FineRegistration, otb::Application); /** Filters typedef */ static const unsigned int Dimension = 2; typedef double PixelType; typedef itk::FixedArray DisplacementValueType; typedef otb::Image< PixelType, Dimension > ScalarImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter IL2VIFilterType; typedef otb::Image FieldImageType; typedef otb::FineRegistrationImageFilter RegistrationFilterType; typedef itk::DiscreteGaussianImageFilter GaussianFilterType; typedef itk::VectorIndexSelectionCastImageFilter VectorImageToImageFilterType; typedef itk::AbsImageFilter AbsFilterType; typedef itk::BinaryThresholdImageFilter BinaryThresholdImageFilterType; typedef otb::VectorImageToIntensityImageFilter IntensityFilterType; typedef itk::NormalizedCorrelationImageToImageMetric NCCType; typedef itk::MeanSquaresImageToImageMetric MeanSquareType; typedef itk::MeanReciprocalSquareDifferenceImageToImageMetric MRSDType; typedef itk::MattesMutualInformationImageToImageMetric MIType; typedef otb::MultiChannelExtractROI ExtractROIFilterType; typedef VLVToFixedArray VLVToFixedArrayType; typedef itk::UnaryFunctorImageFilter CastFilterType; typedef StreamingWarpImageFilter WarpFilterType; typedef otb::ImageFileReader InternalReaderType; private: void DoInit() ITK_OVERRIDE { SetName("FineRegistration"); SetDescription("Estimate disparity map between two images."); SetDocName("Fine Registration"); SetDocLongDescription("Estimate disparity map between two images. Output image contain x offset, y offset and metric value."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Stereo); AddParameter(ParameterType_InputImage, "ref", "Reference Image"); SetParameterDescription( "ref", "The reference image." ); AddParameter(ParameterType_InputImage, "sec", "Secondary Image"); SetParameterDescription( "sec", "The secondary image." ); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription( "out", "The output image." ); AddParameter(ParameterType_Int, "erx", "Exploration Radius X"); SetParameterDescription( "erx", "The exploration radius along x (in pixels)" ); SetMinimumParameterIntValue("erx", 0); AddParameter(ParameterType_Int, "ery", "Exploration Radius Y"); SetParameterDescription( "ery", "The exploration radius along y (in pixels)" ); SetMinimumParameterIntValue("ery", 0); AddParameter(ParameterType_Int, "mrx", "Metric Radius X"); SetParameterDescription( "mrx", "Radius along x (in pixels) of the metric computation window" ); SetMinimumParameterIntValue("mrx", 0); AddParameter(ParameterType_Int, "mry", "Metric Radius Y"); SetParameterDescription( "mry", "Radius along y (in pixels) of the metric computation window" ); SetMinimumParameterIntValue("mry", 0); AddParameter(ParameterType_InputImage, "w", "Image To Warp"); SetParameterDescription( "w", "The image to warp after disparity estimation is completed" ); MandatoryOff("w"); AddParameter(ParameterType_OutputImage, "wo", "Output Warped Image"); SetParameterDescription( "wo", "The output warped image" ); MandatoryOff("wo"); AddParameter(ParameterType_Float, "cox", "Coarse Offset X"); SetParameterDescription( "cox", "Coarse offset along x (in physical space) between the two images" ); SetDefaultParameterFloat("cox", 0.0); MandatoryOff("cox"); AddParameter(ParameterType_Float, "coy", "Coarse Offset Y"); SetParameterDescription( "coy", "Coarse offset along y (in physical space) between the two images" ); SetDefaultParameterFloat("coy", 0.0); MandatoryOff("coy"); AddParameter(ParameterType_Float, "ssrx", "Sub-Sampling Rate X"); SetParameterDescription( "ssrx", "Generates a result at a coarser resolution with a given sub-sampling rate along X" ); SetDefaultParameterFloat("ssrx", 1.0); SetMinimumParameterFloatValue("ssrx", 1.0); MandatoryOff("ssrx"); AddParameter(ParameterType_Float, "ssry", "Sub-Sampling Rate Y"); SetParameterDescription( "ssry", "Generates a result at a coarser resolution with a given sub-sampling rate along Y" ); SetDefaultParameterFloat("ssry", 1.0); SetMinimumParameterFloatValue("ssry", 1.0); MandatoryOff("ssry"); AddParameter(ParameterType_Float, "rgsx", "Reference Gaussian Smoothing X"); SetParameterDescription( "rgsx", "Performs a gaussian smoothing of the reference image. Parameter is gaussian sigma (in pixels) in X direction." ); MandatoryOff("rgsx"); AddParameter(ParameterType_Float, "rgsy", "Reference Gaussian Smoothing Y"); SetParameterDescription( "rgsy", "Performs a gaussian smoothing of the reference image. Parameter is gaussian sigma (in pixels) in Y direction." ); MandatoryOff("rgsy"); AddParameter(ParameterType_Float, "sgsx", "Secondary Gaussian Smoothing X"); SetParameterDescription( "sgsx", "Performs a gaussian smoothing of the secondary image. Parameter is gaussian sigma (in pixels) in X direction." ); MandatoryOff("sgsx"); AddParameter(ParameterType_Float, "sgsy", "Secondary Gaussian Smoothing Y"); SetParameterDescription( "sgsy", "Performs a gaussian smoothing of the secondary image. Parameter is gaussian sigma (in pixels) in Y direction." ); MandatoryOff("sgsy"); AddParameter(ParameterType_String, "m", "Metric"); SetParameterDescription( "m", "Choose the metric used for block matching. Available metrics are cross-correlation (CC), cross-correlation with subtracted mean (CCSM), mean-square difference (MSD), mean reciprocal square difference (MRSD) and mutual information (MI). Default is cross-correlation" ); MandatoryOff("m"); AddParameter(ParameterType_Float, "spa", "SubPixelAccuracy"); SetParameterDescription( "spa", "Metric extrema location will be refined up to the given accuracy. Default is 0.01" ); SetDefaultParameterFloat("spa", 0.01); SetMinimumParameterFloatValue("spa", 0.0); MandatoryOff("spa"); AddParameter(ParameterType_Float, "cva", "ConvergenceAccuracy"); SetParameterDescription( "cva", "Metric extrema will be refined up to the given accuracy. Default is 0.01" ); SetDefaultParameterFloat("cva", 0.01); SetMinimumParameterFloatValue("cva", 0.0); MandatoryOff("cva"); AddParameter(ParameterType_Float, "vmlt", "Validity Mask Lower Threshold"); SetParameterDescription( "vmlt", "Lower threshold to obtain a validity mask." ); MandatoryOff("vmlt"); AddParameter(ParameterType_Float, "vmut", "Validity Mask Upper Threshold"); SetParameterDescription( "vmut", "Upper threshold to obtain a validity mask." ); MandatoryOff("vmut"); AddRAMParameter(); // Doc example parameter settings SetDocExampleParameterValue("ref", "StereoFixed.png"); SetDocExampleParameterValue("sec", "StereoMoving.png"); SetDocExampleParameterValue("out", "FineRegistration.tif"); SetDocExampleParameterValue("erx", "2"); SetDocExampleParameterValue("ery", "2"); SetDocExampleParameterValue("mrx", "3"); SetDocExampleParameterValue("mry", "3"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer refImage = GetParameterImage("ref"); // fixed FloatVectorImageType::Pointer secImage = GetParameterImage("sec"); // moved m_IntensityRef = IntensityFilterType::New(); m_IntensitySec = IntensityFilterType::New(); m_IntensityRef->SetInput(refImage); m_IntensitySec->SetInput(secImage); // Retrieve main registration parameters RegistrationFilterType::SizeType radius, sradius; RegistrationFilterType::OffsetType ssrate; sradius[0] = GetParameterInt("erx"); sradius[1] = GetParameterInt("ery"); radius[0] = GetParameterInt("mrx"); radius[1] = GetParameterInt("mry"); ssrate[0] = GetParameterFloat("ssrx"); ssrate[1] = GetParameterFloat("ssry"); RegistrationFilterType::SpacingType initialOffset; initialOffset[0] = GetParameterFloat("cox"); initialOffset[1] = GetParameterFloat("coy"); // Display info otbAppLogINFO("Reference image : "<SetRadius(radius); m_Registration->SetSearchRadius(sradius); if (IsParameterEnabled("cva") && HasValue("cva")) { double convAccuracy = static_cast(GetParameterFloat("cva")); m_Registration->SetConvergenceAccuracy(convAccuracy); otbAppLogINFO("Convergence Accuracy : "<(GetParameterFloat("spa")); m_Registration->SetSubPixelAccuracy(subPixAccuracy); otbAppLogINFO("SubPixel Accuracy : "<SetGridStep(ssrate); m_Registration->SetInitialOffset(initialOffset); if(HasValue("rgsx") && HasValue("rgsy")) { m_RefGaussianFilter = GaussianFilterType::New(); m_RefGaussianFilter->SetInput(m_IntensityRef->GetOutput()); GaussianFilterType::ArrayType sigma; sigma[0] = GetParameterFloat("rgsx"); sigma[1] = GetParameterFloat("rgsy"); m_RefGaussianFilter->SetVariance(sigma); m_RefGaussianFilter->SetUseImageSpacingOff(); otbAppLogINFO("Reference image gaussian smoothing : ON"); otbAppLogINFO("variance : "<SetFixedInput(m_RefGaussianFilter->GetOutput()); } else { otbAppLogINFO("Reference image gaussian smoothing : OFF"); m_Registration->SetFixedInput(m_IntensityRef->GetOutput()); } if(HasValue("sgsx") && HasValue("sgsy")) { m_SecGaussianFilter = GaussianFilterType::New(); m_SecGaussianFilter->SetInput(m_IntensitySec->GetOutput()); GaussianFilterType::ArrayType sigma; sigma[0] = GetParameterFloat("sgsx"); sigma[1] = GetParameterFloat("sgsy"); m_SecGaussianFilter->SetVariance(sigma); m_SecGaussianFilter->SetUseImageSpacingOff(); otbAppLogINFO("Secondary image gaussian smoothing : ON"); otbAppLogINFO("variance : "<SetMovingInput(m_SecGaussianFilter->GetOutput()); } else { otbAppLogINFO("Secondary image gaussian smoothing : OFF"); m_Registration->SetMovingInput(m_IntensitySec->GetOutput()); } // Retrieve metric name std::string metricId = "CC"; if(HasValue("m")) { metricId = GetParameterString("m"); } if(metricId == "CC") { otbAppLogINFO("Metric : Cross-correlation"); m_NCCMetricPtr = NCCType::New(); m_NCCMetricPtr->SubtractMeanOff(); m_Registration->SetMetric(m_NCCMetricPtr); m_Registration->MinimizeOn(); } else if(metricId == "CCSM") { otbAppLogINFO("Metric : Cross-correlation (mean subtracted)"); m_NCCMetricPtr = NCCType::New(); m_NCCMetricPtr->SubtractMeanOn(); m_Registration->SetMetric(m_NCCMetricPtr); m_Registration->MinimizeOn(); } else if(metricId == "MSD") { otbAppLogINFO("Metric : Mean square difference"); m_MetricPtr = MeanSquareType::New(); m_Registration->SetMetric(m_MetricPtr); m_Registration->MinimizeOn(); } else if(metricId == "MRSD") { otbAppLogINFO("Metric : Mean reciprocal square difference"); m_MetricPtr = MRSDType::New(); m_Registration->SetMetric(m_MetricPtr); m_Registration->MinimizeOff(); } else if(metricId == "MI") { otbAppLogINFO("Metric : Mutual information"); m_MetricPtr = MIType::New(); m_Registration->SetMetric(m_MetricPtr); m_Registration->MinimizeOn(); } else { itkExceptionMacro("Metric not recognized. Possible choices are: CC, CCSM, MSD, MRSD, MI"); } m_XExtractor = VectorImageToImageFilterType::New(); m_XExtractor->SetInput(m_Registration->GetOutputDisplacementField()); m_XExtractor->SetIndex(0); m_YExtractor = VectorImageToImageFilterType::New(); m_YExtractor->SetInput(m_Registration->GetOutputDisplacementField()); m_YExtractor->SetIndex(1); m_ImgList = ImageListType::New(); m_ImgList->PushBack(m_XExtractor->GetOutput()); m_ImgList->PushBack(m_YExtractor->GetOutput()); // Invert correlation to get classical rendering if(metricId == "CC" || metricId == "CCSM") { m_AbsFilter = AbsFilterType::New(); m_AbsFilter->SetInput(m_Registration->GetOutput()); m_ImgList->PushBack(m_AbsFilter->GetOutput()); } else { m_ImgList->PushBack(m_Registration->GetOutput()); } m_Registration->UpdateOutputInformation(); if(HasUserValue("vmlt") || HasUserValue("vmut")) { m_Threshold = BinaryThresholdImageFilterType::New(); if(metricId == "CC" || metricId == "CCSM") { m_Threshold->SetInput(m_AbsFilter->GetOutput()); } else { m_Threshold->SetInput(m_Registration->GetOutput()); } otbAppLogINFO("A validity mask will be produced as the 4th band (valid pixels = 1.0, not valid = 0.0)."); if(HasUserValue("vmlt")) { m_Threshold->SetLowerThreshold(GetParameterFloat("vmlt")); otbAppLogINFO("The lower threshold is set to "<SetUpperThreshold(GetParameterFloat("vmut")); otbAppLogINFO("The upper threshold is set to "<SetInsideValue(1.0); m_Threshold->SetOutsideValue(0.); m_ImgList->PushBack(m_Threshold->GetOutput()); } m_Il2vi = IL2VIFilterType::New(); m_Il2vi->SetInput(m_ImgList); AddProcess(m_Registration,"Fine Registration"); SetParameterOutputImage("out", m_Il2vi->GetOutput()); // If an image to warp has been given if (HasValue("w") && HasValue("wo")) { otbAppLogINFO("Doing warping : ON"); m_outputReader = InternalReaderType::New(); m_outputReader->SetFileName(GetParameterString("out")); m_ExtractROIFilter = ExtractROIFilterType::New(); m_ExtractROIFilter->SetChannel(1); m_ExtractROIFilter->SetChannel(2); m_ExtractROIFilter->SetInput(m_outputReader->GetOutput()); m_Cast = CastFilterType::New(); m_Cast->SetInput(m_ExtractROIFilter->GetOutput()); FloatVectorImageType::Pointer imageToWarp = GetParameterImage("w"); m_Warp = WarpFilterType::New(); m_Warp->SetDisplacementField(m_Cast->GetOutput()); m_Warp->SetInput(imageToWarp); m_Warp->SetOutputParametersFromImage(refImage); AddProcess(m_Warp,"Warp"); SetParameterOutputImage("wo", m_Warp->GetOutput()); } else { otbAppLogINFO("Doing warping : OFF"); } } IntensityFilterType::Pointer m_IntensityRef; IntensityFilterType::Pointer m_IntensitySec; RegistrationFilterType::Pointer m_Registration; GaussianFilterType::Pointer m_RefGaussianFilter, m_SecGaussianFilter; itk::ImageToImageMetric::Pointer m_MetricPtr; NCCType::Pointer m_NCCMetricPtr; // special case because of the SubtractMeanOn/Off method VectorImageToImageFilterType::Pointer m_XExtractor; VectorImageToImageFilterType::Pointer m_YExtractor; AbsFilterType::Pointer m_AbsFilter; ImageListType::Pointer m_ImgList; BinaryThresholdImageFilterType::Pointer m_Threshold; IL2VIFilterType::Pointer m_Il2vi; InternalReaderType::Pointer m_outputReader; ExtractROIFilterType::Pointer m_ExtractROIFilter; CastFilterType::Pointer m_Cast; WarpFilterType::Pointer m_Warp; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::FineRegistration) OTB-release-5.8/Modules/Applications/AppStereo/app/otbGeneratePlyFile.cxx000066400000000000000000000225331301006202600264130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbGenericRSTransform.h" #include "otbBCOInterpolateImageFunction.h" // MapProjection handler #include "otbWrapperMapProjectionParametersHandler.h" namespace otb { namespace Wrapper { class GeneratePlyFile : public Application { public: /** Standard class typedefs. */ typedef GeneratePlyFile Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(GeneratePlyFile, otb::Application); typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::GenericRSTransform RSTransformType; typedef itk::ImageRegionIteratorWithIndex IteratorType; private: GeneratePlyFile(){} void DoInit() ITK_OVERRIDE { SetName("GeneratePlyFile"); SetDescription("Generate a 3D Ply file from a DEM and a color image."); SetDocName("Ply 3D files generation"); SetDocLongDescription("Generate a 3D Ply file from a DEM and a color image."); SetDocLimitations(" "); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Geometry); AddParameter(ParameterType_InputImage,"indem","The input DEM"); SetParameterDescription("indem", "The input DEM"); AddParameter(ParameterType_Choice,"mode", "Conversion Mode"); AddChoice("mode.dem","DEM"); SetParameterDescription("mode.dem","DEM conversion mode"); AddChoice("mode.3dgrid","3D grid"); SetParameterDescription("mode.3dgrid","3D grid conversion mode"); // Build the Output Map Projection MapProjectionParametersHandler::AddMapProjectionParameters(this, "map"); AddParameter(ParameterType_InputImage,"incolor","The input color image"); SetParameterDescription("incolor", "The input color image"); AddParameter(ParameterType_OutputFilename,"out","The output Ply file"); SetParameterDescription("out","The output Ply file"); // Doc example SetDocExampleParameterValue("indem","image_dem.tif"); SetDocExampleParameterValue("out","out.ply"); SetDocExampleParameterValue("incolor","image_color.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Update the UTM zone params MapProjectionParametersHandler::InitializeUTMParameters(this, "incolor", "map"); } void DoExecute() ITK_OVERRIDE { std::string outfname = GetParameterString("out"); FloatVectorImageType::Pointer demPtr = this->GetParameterImage("indem"); demPtr->Update(); FloatVectorImageType::Pointer colorPtr = this->GetParameterImage("incolor"); // First, find the footprint in the color image IteratorType it(demPtr,demPtr->GetLargestPossibleRegion()); it.GoToBegin(); FloatImageType::IndexType lr, ul; typedef FloatImageType::IndexType::IndexValueType IndexValueType; lr.Fill(itk::NumericTraits::Zero); ul.Fill(itk::NumericTraits::Zero); bool firstLoop = true; RSTransformType::Pointer rsTransform = RSTransformType::New(); RSTransformType::Pointer toMap = RSTransformType::New(); toMap->SetOutputProjectionRef(MapProjectionParametersHandler::GetProjectionRefFromChoice(this, "map")); if(GetParameterString("mode")=="dem") { otbAppLogINFO("DEM mode"); rsTransform->SetInputProjectionRef(demPtr->GetProjectionRef()); toMap->SetInputProjectionRef(demPtr->GetProjectionRef()); } rsTransform->SetOutputProjectionRef(colorPtr->GetProjectionRef()); rsTransform->SetOutputKeywordList(colorPtr->GetImageKeywordlist()); rsTransform->InstantiateTransform(); toMap->InstantiateTransform(); unsigned long nbValidPoints = 0; // First pass is to find the color footprint while(!it.IsAtEnd()) { RSTransformType::InputPointType dem3dPoint; bool valid = true; if(GetParameterString("mode")=="dem") { FloatImageType::PointType demPoint; demPtr->TransformIndexToPhysicalPoint(it.GetIndex(),demPoint); dem3dPoint[0]=demPoint[0]; dem3dPoint[1]=demPoint[1]; dem3dPoint[2]=it.Get()[0]; if(dem3dPoint[2] <= -32768) { valid=false; } } else { dem3dPoint[0]=it.Get()[0]; dem3dPoint[1]=it.Get()[1]; dem3dPoint[2]=it.Get()[2]; if(it.Get()[4] < 1) { valid = false; } } if(valid) { ++nbValidPoints; RSTransformType::InputPointType color3dPoint = rsTransform->TransformPoint(dem3dPoint); FloatVectorImageType::PointType color2dPoint; color2dPoint[0] = color3dPoint[0]; color2dPoint[1] = color3dPoint[1]; FloatVectorImageType::IndexType color2dIndex; colorPtr->TransformPhysicalPointToIndex(color2dPoint,color2dIndex); // std::cout<<"DEM point: "<GetLargestPossibleRegion().IsInside(color2dIndex)) { if(firstLoop) { lr = color2dIndex; ul = color2dIndex; firstLoop = false; } else { ul[0] = std::min(ul[0],color2dIndex[0]); ul[1] = std::min(ul[1],color2dIndex[1]); lr[0] = std::max(lr[0],color2dIndex[0]); lr[1] = std::max(lr[1],color2dIndex[1]); } } } ++it; } FloatVectorImageType::RegionType region; region.SetIndex(ul); FloatVectorImageType::SizeType size; size[0] = static_cast(lr[0]-ul[0]); size[1] = static_cast(lr[1]-ul[1]); region.SetSize(size); otbAppLogINFO(<<"Number of valid points: "<SetRequestedRegion(region); colorPtr->Update(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); interpolator->SetInputImage(colorPtr); // Start writing ply file std::ofstream ofs(outfname.c_str()); std::ostringstream oss; oss<TransformIndexToPhysicalPoint(it.GetIndex(),demPoint); dem3dPoint[0]=demPoint[0]; dem3dPoint[1]=demPoint[1]; dem3dPoint[2]=it.Get()[0]; valid =(dem3dPoint[2] > -32768); } else { dem3dPoint[0]=it.Get()[0]; dem3dPoint[1]=it.Get()[1]; dem3dPoint[2]=it.Get()[2]; valid = (it.Get()[4]>0); } if(valid) { RSTransformType::InputPointType color3dPoint = rsTransform->TransformPoint(dem3dPoint); FloatVectorImageType::PointType color2dPoint; color2dPoint[0] = color3dPoint[0]; color2dPoint[1] = color3dPoint[1]; FloatVectorImageType::PixelType color = interpolator->Evaluate(color2dPoint); double red,green,blue; if(color.Size() == 4) { red = color[0]; green = (0.9 * color[1] + 0.1 * color[3]); blue = color[2]; } else { red = color[0]; green = red; blue = red; } // Clamp red = (red>255?255:(red<0?0:red)); green = (green>255?255:(green<0?0:green)); blue = (blue>255?255:(blue<0?0:blue)); RSTransformType::InputPointType map3dPoint; map3dPoint = toMap->TransformPoint(dem3dPoint); oss.str(""); oss< Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(StereoFramework, otb::Application); /** Filters typedefs */ typedef FloatImageType::PixelType FloatPixelType; typedef otb::StereorectificationDisplacementFieldSource DisplacementFieldSourceType; typedef itk::Vector DisplacementType; typedef otb::Image DisplacementFieldType; typedef itk::VectorCastImageFilter DisplacementFieldCastFilterType; typedef itk::InverseDisplacementFieldImageFilter InverseDisplacementFieldFilterType; typedef otb::StreamingWarpImageFilter ResampleFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::Functor::SSDBlockMatching SSDBlockMatchingFunctorType; typedef otb::Functor::SSDDivMeanBlockMatching SSDDivMeanBlockMatchingFunctorType; typedef otb::Functor::NCCBlockMatching NCCBlockMatchingFunctorType; typedef otb::Functor::LPBlockMatching LPBlockMatchingFunctorType; typedef otb::PixelWiseBlockMatchingImageFilter SSDBlockMatchingFilterType; typedef otb::PixelWiseBlockMatchingImageFilter SSDDivMeanBlockMatchingFilterType; typedef otb::PixelWiseBlockMatchingImageFilter NCCBlockMatchingFilterType; typedef otb::PixelWiseBlockMatchingImageFilter LPBlockMatchingFilterType; typedef otb::BandMathImageFilter BandMathFilterType; typedef otb::SubPixelDisparityImageFilter SSDSubPixelFilterType; typedef otb::SubPixelDisparityImageFilter SSDDivMeanSubPixelFilterType; typedef otb::SubPixelDisparityImageFilter LPSubPixelFilterType; typedef otb::SubPixelDisparityImageFilter NCCSubPixelFilterType; typedef otb::DisparityMapMedianFilter MedianFilterType; typedef otb::VarianceImageFilter VarianceFilterType; typedef otb::DisparityMapToDEMFilter DisparityToElevationFilterType; typedef otb::DEMToImageGenerator DEMToImageGeneratorType; typedef otb::StreamingMinMaxImageFilter MinMaxFilterType; typedef otb::ExtractROI ExtractFilterType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorImageToImageListFilter VectorImageToListFilterType; typedef MultiToMonoChannelExtractROI ExtractROIFilterType; typedef otb::MultiDisparityMapTo3DFilter MultiDisparityTo3DFilterType; typedef MultiDisparityTo3DFilterType::Pointer MultiDisparityTo3DFilterPointerType; typedef otb::Multi3DMapToDEMFilter Multi3DFilterType; typedef otb::DisparityTranslateFilter DisparityTranslateFilter; typedef otb::DisparityMapTo3DFilter DisparityTo3DFilter; typedef itk::VectorIndexSelectionCastImageFilter IndexSelectionCastFilterType; typedef otb::ImageListToVectorImageFilter ImageListFilterType; typedef ExtractROIFilterType::Pointer ExtractROIFilterPointerType; typedef std::vector ExtractorListType; typedef std::vector MultiDisparityTo3DFilterListType; typedef otb::BijectionCoherencyFilter BijectionFilterType; typedef itk::ImageToImageFilter FilterType; typedef otb::ImageToNoDataMaskFilter NoDataMaskFilterType; private: StereoFramework() { m_Interpolator = InterpolatorType::New(); m_Multi3DMapToDEMFilter = Multi3DFilterType::New(); } std::vector > CreateCouplesList(std::string couples) { std::vector > couplesList; FloatVectorImageListType::Pointer inList = this->GetParameterImageList("input.il"); unsigned int imageListNb = inList->Size(); if (!couples.empty()) { unsigned int i; std::vector couple; std::stringstream couplesStream(couples); while (couplesStream >> i) { if (i >= imageListNb) { otbAppLogFATAL(< couple; couple.push_back(index); couple.push_back(index + 1); couplesList.push_back(couple); } } return couplesList; } void DoInit() ITK_OVERRIDE { SetName("StereoFramework"); SetDescription("Compute the ground elevation based on one or multiple stereo pair(s)"); SetDocName("Stereo Framework"); SetDocLongDescription("Compute the ground elevation with a stereo block matching algorithm " "between one or multiple stereo pair in sensor geometry. The output is projected in " "desired geographic or cartographic map projection (UTM by default). The pipeline is made of the following steps:\n" "for each sensor pair :\n\n" "\t- compute the epipolar displacement grids from the stereo pair (direct and inverse)\n" "\t- resample the stereo pair into epipolar geometry using BCO interpolation\n" "\t- create masks for each epipolar image : remove black borders and resample" " input masks\n" "\t- compute horizontal disparities with a block matching algorithm\n" "\t- refine disparities to sub-pixel precision with a dichotomy algorithm\n" "\t- apply an optional median filter\n" "\t- filter disparities based on the correlation score and exploration bounds\n" "\t- translate disparities in sensor geometry\n" "\t convert disparity to 3D Map.\n\n" "Then fuse all 3D maps to produce DSM."); SetDocLimitations(" "); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Stereo); // Add the output parameters in a group AddParameter(ParameterType_Group, "input", "Input parameters"); SetParameterDescription("input","This group of parameters allows one to parametrize input data."); AddParameter(ParameterType_InputImageList, "input.il", "Input images list"); SetParameterDescription("input.il", "The list of images."); AddParameter(ParameterType_String, "input.co", "Couples list"); SetParameterDescription("input.co","List of index of couples im image list. Couples must be separated by a comma. (index start at 0). for example : 0 1,1 2 will process a first couple composed of the first and the second image in image list, then the first and the third image\n. note that images are handled by pairs." " if left empty couples are created from input index i.e. a first couple will be composed of the first and second image, a second couple with third and fourth image etc. (in this case image list must be even)."); MandatoryOff("input.co"); SetParameterString("input.co",""); DisableParameter("input.co"); AddParameter(ParameterType_Int, "input.channel", "Image channel used for the block matching"); SetParameterDescription("input.channel", "Used channel for block matching (used for all images)"); SetDefaultParameterInt("input.channel", 1); SetMinimumParameterIntValue("input.channel", 1); ElevationParametersHandler::AddElevationParameters(this, "elev"); // Add the output parameters in a group AddParameter(ParameterType_Group, "output", "Output parameters"); SetParameterDescription("output","This group of parameters allows one to choose the DSM resolution, nodata value, and projection parameters."); // // Build the Output Map Projection // for custom map projection MapProjectionParametersHandler::AddMapProjectionParameters(this, "map"); SetParameterString("map","wgs"); AddParameter(ParameterType_Float, "output.res","Output resolution"); SetParameterDescription("output.res","Spatial sampling distance of the output elevation : the cell size (in m)"); SetDefaultParameterFloat("output.res",1.); AddParameter(ParameterType_Float, "output.nodata","NoData value"); SetParameterDescription("output.nodata","DSM empty cells are filled with this value (optional -32768 by default)"); SetDefaultParameterFloat("output.nodata",-32768); MandatoryOff("output.nodata"); // UserDefined values AddParameter(ParameterType_Choice, "output.fusionmethod", "Method to fuse measures in each DSM cell"); SetParameterDescription("output.fusionmethod","This parameter allows one to choose the method used to fuse elevation measurements in each output DSM cell"); AddChoice("output.fusionmethod.max", "The cell is filled with the maximum measured elevation values"); AddChoice("output.fusionmethod.min", "The cell is filled with the minimum measured elevation values"); AddChoice("output.fusionmethod.mean","The cell is filled with the mean of measured elevation values"); AddChoice("output.fusionmethod.acc", "accumulator mode. The cell is filled with the the number of values (for debugging purposes)."); AddParameter(ParameterType_OutputImage,"output.out","Output DSM"); SetParameterDescription("output.out","Output elevation image"); // UserDefined values AddParameter(ParameterType_Choice, "output.mode", "Parameters estimation modes"); AddChoice("output.mode.fit", "Fit to sensor image"); SetParameterDescription("output.mode.fit", "Fit the size, origin and spacing to an existing ortho image (uses the value of outputs.ortho)"); AddChoice("output.mode.user", "User Defined"); SetParameterDescription("output.mode.user","This mode allows you to fully modify default values."); // Upper left point coordinates AddParameter(ParameterType_Float, "output.mode.user.ulx", "Upper Left X "); SetParameterDescription("output.mode.user.ulx","Cartographic X coordinate of upper-left corner (meters for cartographic projections, degrees for geographic ones)"); AddParameter(ParameterType_Float, "output.mode.user.uly", "Upper Left Y "); SetParameterDescription("output.mode.user.uly","Cartographic Y coordinate of the upper-left corner (meters for cartographic projections, degrees for geographic ones)"); // Size of the output image AddParameter(ParameterType_Int, "output.mode.user.sizex", "Size X "); SetParameterDescription("output.mode.user.sizex","Size of projected image along X (in pixels)"); AddParameter(ParameterType_Int, "output.mode.user.sizey", "Size Y "); SetParameterDescription("output.mode.user.sizey","Size of projected image along Y (in pixels)"); // Spacing of the output image AddParameter(ParameterType_Float, "output.mode.user.spacingx", "Pixel Size X "); SetParameterDescription("output.mode.user.spacingx","Size of each pixel along X axis (meters for cartographic projections, degrees for geographic ones)"); AddParameter(ParameterType_Float, "output.mode.user.spacingy", "Pixel Size Y "); SetParameterDescription("output.mode.user.spacingy","Size of each pixel along Y axis (meters for cartographic projections, degrees for geographic ones)"); // Add the output parameters in a group AddParameter(ParameterType_Group, "stereorect", "Stereorectification Grid parameters"); SetParameterDescription("stereorect","This group of parameters allows one to choose direct and inverse grid subsampling. These parameters are very useful to tune time and memory consumption."); AddParameter(ParameterType_Int,"stereorect.fwdgridstep","Step of the displacement grid (in pixels)"); SetParameterDescription("stereorect.fwdgridstep","Stereo-rectification displacement grid only varies slowly. Therefore, it is recommended to use a coarser grid (higher step value) in case of large images"); SetDefaultParameterInt("stereorect.fwdgridstep",16); MandatoryOff("stereorect.fwdgridstep"); AddParameter(ParameterType_Int, "stereorect.invgridssrate", "Sub-sampling rate for epipolar grid inversion"); SetParameterDescription("stereorect.invgridssrate","Grid inversion is an heavy process that implies spline regression on control points. To avoid eating to much memory, this parameter allows one to first sub-sample the field to invert."); SetDefaultParameterInt("stereorect.invgridssrate",10); SetMinimumParameterIntValue("stereorect.invgridssrate",1); MandatoryOff("stereorect.invgridssrate"); AddParameter(ParameterType_Group,"bm","Block matching parameters"); SetParameterDescription("bm","This group of parameters allow tuning the block-matching behavior"); AddParameter(ParameterType_Choice, "bm.metric", "Block-matching metric"); //SetDefaultParameterInt("bm.metric",3); AddChoice("bm.metric.ssdmean","Sum of Squared Distances divided by mean of block"); SetParameterDescription("bm.metric.ssdmean","derived version of Sum of Squared Distances between pixels value in the metric window (SSD divided by mean over window)"); AddChoice("bm.metric.ssd","Sum of Squared Distances"); SetParameterDescription("bm.metric.ssd","Sum of squared distances between pixels value in the metric window"); AddChoice("bm.metric.ncc","Normalized Cross-Correlation"); SetParameterDescription("bm.metric.ncc","Normalized Cross-Correlation between the left and right windows"); AddChoice("bm.metric.lp","Lp pseudo-norm"); SetParameterDescription("bm.metric.lp","Lp pseudo-norm between the left and right windows"); AddParameter(ParameterType_Float,"bm.metric.lp.p","p value" ); SetParameterDescription("bm.metric.lp.p", "Value of the p parameter in Lp pseudo-norm (must be positive)"); SetDefaultParameterFloat("bm.metric.lp.p", 1.0); SetMinimumParameterFloatValue("bm.metric.lp.p", 0.0); AddParameter(ParameterType_Int,"bm.radius","Radius of blocks for matching filter (in pixels)"); SetParameterDescription("bm.radius","The radius of blocks in Block-Matching (in pixels)"); SetDefaultParameterInt("bm.radius",2); SetMinimumParameterIntValue("bm.radius",1); MandatoryOff("bm.radius"); AddParameter(ParameterType_Float,"bm.minhoffset","Minimum altitude offset (in meters)"); SetParameterDescription("bm.minhoffset","Minimum altitude below the selected elevation source (in meters)"); //MandatoryOff("bm.minhoffset"); SetDefaultParameterFloat("bm.minhoffset",-20.0); DisableParameter("bm.minhoffset"); AddParameter(ParameterType_Float,"bm.maxhoffset","Maximum altitude offset (in meters)"); SetParameterDescription("bm.maxhoffset","Maximum altitude above the selected elevation source (in meters)"); //MandatoryOff("bm.maxhoffset"); SetDefaultParameterFloat("bm.maxhoffset",20.0); DisableParameter("bm.maxhoffset"); AddParameter(ParameterType_Group,"postproc","Postprocessing parameters"); SetParameterDescription("postproc","This group of parameters allow use optional filters."); AddParameter(ParameterType_Empty,"postproc.bij","Use bijection consistency in block matching strategy"); SetParameterDescription("postproc.bij","use bijection consistency. Right to Left correlation is computed to validate Left to Right disparities. If bijection is not found pixel is rejected."); MandatoryOff("postproc.bij"); EnableParameter("postproc.bij"); AddParameter(ParameterType_Empty,"postproc.med","Use median disparities filtering"); SetParameterDescription("postproc.med","disparities output can be filtered using median post filtering (disabled by default)."); MandatoryOff("postproc.med"); DisableParameter("postproc.med"); AddParameter(ParameterType_Float,"postproc.metrict","Correlation metric threshold"); SetParameterDescription("postproc.metrict","Use block matching metric output to discard pixels with low correlation value (disabled by default, float value)"); MandatoryOff("postproc.metrict"); SetDefaultParameterFloat("postproc.metrict",0.6); DisableParameter("postproc.metrict"); AddParameter(ParameterType_Group,"mask","Masks"); AddParameter(ParameterType_InputImage, "mask.left","Input left mask"); SetParameterDescription("mask.left","Mask for left input image"); MandatoryOff("mask.left"); DisableParameter("mask.left"); AddParameter(ParameterType_InputImage, "mask.right","Input right mask"); SetParameterDescription("mask.right","Mask for right input image"); MandatoryOff("mask.right"); DisableParameter("mask.right"); AddParameter(ParameterType_Float,"mask.variancet","Discard pixels with low local variance"); SetParameterDescription("mask.variancet","This parameter allows one to discard pixels whose local variance is too small (the size of the neighborhood is given by the radius parameter)"); MandatoryOff("mask.variancet"); SetDefaultParameterFloat("mask.variancet",50.); //DisableParameter("mask.variancet"); AddRAMParameter(); SetDocExampleParameterValue("input.il","sensor_stereo_left.tif sensor_stereo_right.tif"); SetDocExampleParameterValue("elev.default","200"); SetDocExampleParameterValue("stereorect.fwdgridstep", "8"); SetDocExampleParameterValue("stereorect.invgridssrate", "4"); SetDocExampleParameterValue("postproc.med","1"); SetDocExampleParameterValue("output.res","2.5"); SetDocExampleParameterValue("output.out","dem.tif"); } void DoUpdateParameters() ITK_OVERRIDE { if( HasValue("input.il") ) { // Get the input image list FloatVectorImageListType::Pointer inList = this->GetParameterImageList("input.il"); // Set channel interval SetMaximumParameterIntValue("input.channel", inList->GetNthElement(0)->GetNumberOfComponentsPerPixel()); } } template void SetBlockMatchingParameters(otb::PixelWiseBlockMatchingImageFilter*blockMatcherFilter, otb::PixelWiseBlockMatchingImageFilter*invBlockMatcherFilter,otb::SubPixelDisparityImageFilter*subPixelFilter, TInputImage * leftImage, TInputImage * rightImage,TInputImage * leftMask,TInputImage * rightMask,TInputImage * finalMask, const bool minimize,double minDisp,double maxDisp) { typedef TMetricFunctor MetricFunctorType; typedef otb::SubPixelDisparityImageFilter SubPixelFilterType; blockMatcherFilter->SetLeftInput(leftImage); blockMatcherFilter->SetRightInput(rightImage); blockMatcherFilter->SetLeftMaskInput(leftMask); blockMatcherFilter->SetRightMaskInput(rightMask); blockMatcherFilter->SetRadius(this->GetParameterInt("bm.radius")); blockMatcherFilter->SetMinimumHorizontalDisparity(minDisp); blockMatcherFilter->SetMaximumHorizontalDisparity(maxDisp); blockMatcherFilter->SetMinimumVerticalDisparity(0); blockMatcherFilter->SetMaximumVerticalDisparity(0); if (minimize) { blockMatcherFilter->MinimizeOn(); } else blockMatcherFilter->MinimizeOff(); if (IsParameterEnabled("postproc.bij")) { invBlockMatcherFilter->SetLeftInput(rightImage); invBlockMatcherFilter->SetRightInput(leftImage); invBlockMatcherFilter->SetLeftMaskInput(rightMask); invBlockMatcherFilter->SetRightMaskInput(leftMask); invBlockMatcherFilter->SetRadius(this->GetParameterInt("bm.radius")); invBlockMatcherFilter->SetMinimumHorizontalDisparity(-maxDisp); invBlockMatcherFilter->SetMaximumHorizontalDisparity(-minDisp); invBlockMatcherFilter->SetMinimumVerticalDisparity(0); invBlockMatcherFilter->SetMaximumVerticalDisparity(0); if (minimize) { invBlockMatcherFilter->MinimizeOn(); } else invBlockMatcherFilter->MinimizeOff(); } subPixelFilter->SetInputsFromBlockMatchingFilter(blockMatcherFilter); subPixelFilter->SetRefineMethod(SubPixelFilterType::DICHOTOMY); subPixelFilter->SetLeftMaskInput(finalMask); subPixelFilter->UpdateOutputInformation(); } void DoExecute() ITK_OVERRIDE { // Setup the DSM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this, "elev"); double underElev = this->GetParameterFloat("bm.minhoffset"); double overElev = this->GetParameterFloat("bm.maxhoffset"); m_Filters.clear(); // Get the input image list FloatVectorImageListType::Pointer inList = this->GetParameterImageList("input.il"); if (inList->Size() < 2) { itkExceptionMacro("at least two input images must be set..."); } //create pipeline for each stereo couple std::vector > couples = this->CreateCouplesList(GetParameterString("input.co")); unsigned int stereoCouples = couples.size(); m_ExtractorList.resize(inList->Size()); //TODO JGT check the mutli stereo fusion step // N MultiDisp which gives N 3D Map Then fuse N 3D Map to DSM // or // 1 MultiDisp which fuse N Disp Couples to 1 3D Map and then convert one 3D Map into DSM m_MultiDisparityTo3DFilterList.resize(stereoCouples); for (unsigned int i = 0; i < inList->Size(); i++) { m_ExtractorList[i] = ExtractROIFilterType::New(); m_ExtractorList[i]->SetInput(inList->GetNthElement(i)); m_ExtractorList[i]->SetChannel(this->GetParameterInt("input.channel")); m_ExtractorList[i]->UpdateOutputInformation(); } // Update the UTM zone params - Commented until bug fix on custom // map projections MapProjectionParametersHandler::InitializeUTMParameters(this, "input.il", "map"); // Get the output projection Ref m_OutputProjectionRef = MapProjectionParametersHandler::GetProjectionRefFromChoice(this, "map"); // m_OutputProjectionRef = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]"; //create BCO interpolator with radius 2 // used by Left and Right Resampler and Left and Right Mask REsampler m_Interpolator->SetRadius(2); m_Multi3DMapToDEMFilter->SetNumberOf3DMaps(stereoCouples); m_Multi3DMapToDEMFilter->SetNoDataValue(this->GetParameterFloat("output.nodata")); // value of ram used to compute epipolar grid double globalEpiStorageSize = 0; for (unsigned int i = 0; i < stereoCouples; i++) { std::vector couple = couples[i]; if (couple.size() > 2) { otbAppLogWARNING(<<" current couple contain more than 2 value. only first and second values will be associated to create next couple."); } otbAppLogINFO("Processing stereo couple "<GetOutput(); FloatImageType::Pointer inright = m_ExtractorList[couple[1]]->GetOutput(); m_MultiDisparityTo3DFilterList[i] = MultiDisparityTo3DFilterType::New(); DisplacementFieldSourceType::Pointer epipolarGridSource = DisplacementFieldSourceType::New(); epipolarGridSource->SetLeftImage(inleft); epipolarGridSource->SetRightImage(inright); epipolarGridSource->SetGridStep(this->GetParameterInt("stereorect.fwdgridstep")); epipolarGridSource->SetScale(1.0); if (otb::Wrapper::ElevationParametersHandler::IsDEMUsed(this, "elev") && otb::Wrapper::ElevationParametersHandler::IsGeoidUsed(this, "elev")) { epipolarGridSource->SetUseDEM(true); } epipolarGridSource->UpdateOutputInformation(); // check that displacement grids fit in 1/4 of available RAM FloatVectorImageType::SizeType gridSize = epipolarGridSource->GetLeftDisplacementFieldOutput()->GetLargestPossibleRegion().GetSize(); double storageSize = static_cast (gridSize[0]) * static_cast (gridSize[1]) * 4.0 * 8.0 / 1000000.0; globalEpiStorageSize += storageSize; if (globalEpiStorageSize > (static_cast (this->GetParameterInt("ram")))) { otbAppLogINFO(<<"Grid step for couple "<GetParameterInt("stereorect.fwdgridstep")<<" seems too be to high."); } AddProcess(epipolarGridSource, "Computing epipolar grids..."); epipolarGridSource->Update(); FloatImageType::SpacingType epiSpacing; epiSpacing[0] = 0.5 * (vcl_abs(inleft->GetSpacing()[0]) + vcl_abs(inleft->GetSpacing()[1])); epiSpacing[1] = 0.5 * (vcl_abs(inleft->GetSpacing()[0]) + vcl_abs(inleft->GetSpacing()[1])); FloatImageType::SizeType epiSize; epiSize = epipolarGridSource->GetRectifiedImageSize(); FloatImageType::PointType epiOrigin; epiOrigin[0] = 0.0; epiOrigin[1] = 0.0; FloatImageType::PixelType defaultValue = 0; double meanBaseline = epipolarGridSource->GetMeanBaselineRatio(); double minDisp = vcl_floor((-1.0) * overElev * meanBaseline / epiSpacing[0]); double maxDisp = vcl_ceil((-1.0) * underElev * meanBaseline / epiSpacing[0]); otbAppLogINFO(<<"Minimum disparity : "<SetInput(epipolarGridSource->GetLeftDisplacementFieldOutput()); leftGridCaster->Update(); DisplacementFieldType::Pointer leftDisplacement; leftDisplacement = leftGridCaster->GetOutput(); leftDisplacement->DisconnectPipeline(); m_Filters.push_back(leftDisplacement.GetPointer()); InverseDisplacementFieldFilterType::Pointer leftInverseDisplacementFieldFilter = InverseDisplacementFieldFilterType::New(); leftInverseDisplacementFieldFilter->SetInput(leftDisplacement); FloatVectorImageType::PointType lorigin = inleft->GetOrigin(); FloatVectorImageType::SpacingType lspacing = inleft->GetSpacing(); FloatVectorImageType::SizeType lsize = inleft->GetLargestPossibleRegion().GetSize(); double gridStep = epipolarGridSource->GetGridStep(); lspacing[0] *= gridStep; lspacing[1] *= gridStep; lsize[0] /= gridStep; lsize[1] /= gridStep; lsize[0] += 1; lsize[1] += 1; leftInverseDisplacementFieldFilter->SetOutputOrigin(lorigin); leftInverseDisplacementFieldFilter->SetOutputSpacing(lspacing); leftInverseDisplacementFieldFilter->SetSize(lsize); // change value leftInverseDisplacementFieldFilter->SetSubsamplingFactor(this->GetParameterInt("stereorect.invgridssrate")); AddProcess(leftInverseDisplacementFieldFilter, "Inverting left displacement field ..."); leftInverseDisplacementFieldFilter->Update(); DisplacementFieldType::Pointer leftInverseDisplacement; leftInverseDisplacement = leftInverseDisplacementFieldFilter->GetOutput(); leftInverseDisplacement->DisconnectPipeline(); m_Filters.push_back(leftInverseDisplacement.GetPointer()); ResampleFilterType::Pointer leftResampleFilter = ResampleFilterType::New(); leftResampleFilter->SetInput(inleft); leftResampleFilter->SetDisplacementField(leftDisplacement); leftResampleFilter->SetInterpolator(m_Interpolator); leftResampleFilter->SetOutputSize(epiSize); leftResampleFilter->SetOutputSpacing(epiSpacing); leftResampleFilter->SetOutputOrigin(epiOrigin); leftResampleFilter->SetEdgePaddingValue(defaultValue); m_Filters.push_back(leftResampleFilter.GetPointer()); DisplacementFieldCastFilterType::Pointer rightGridCaster = DisplacementFieldCastFilterType::New(); rightGridCaster->SetInput(epipolarGridSource->GetRightDisplacementFieldOutput()); rightGridCaster->Update(); DisplacementFieldType::Pointer rightDisplacement; rightDisplacement = rightGridCaster->GetOutput(); rightDisplacement->DisconnectPipeline(); m_Filters.push_back(rightDisplacement.GetPointer()); ResampleFilterType::Pointer rightResampleFilter = ResampleFilterType::New(); rightResampleFilter->SetInput(inright); rightResampleFilter->SetDisplacementField(rightDisplacement); rightResampleFilter->SetInterpolator(m_Interpolator); rightResampleFilter->SetOutputSize(epiSize); rightResampleFilter->SetOutputSpacing(epiSpacing); rightResampleFilter->SetOutputOrigin(epiOrigin); rightResampleFilter->SetEdgePaddingValue(defaultValue); m_Filters.push_back(rightResampleFilter.GetPointer()); // Compute masks FloatImageType::Pointer leftmask; FloatImageType::Pointer rightmask; BandMathFilterType::Pointer lBandMathFilter = BandMathFilterType::New(); BandMathFilterType::Pointer rBandMathFilter = BandMathFilterType::New(); unsigned int inputIdLeft = 0; unsigned int inputIdRight = 0; lBandMathFilter->SetNthInput(inputIdLeft, leftResampleFilter->GetOutput(), "inleft"); ++inputIdLeft; std::ostringstream leftCondition; leftCondition << "(inleft > 0)"; ResampleFilterType::Pointer leftMaskResampleFilter = ResampleFilterType::New(); if (IsParameterEnabled("mask.left") && HasValue("mask.left")) { leftmask = this->GetParameterFloatImage("mask.left"); leftMaskResampleFilter->SetInput(leftmask); leftMaskResampleFilter->SetDisplacementField(leftDisplacement); leftMaskResampleFilter->SetInterpolator(m_Interpolator); leftMaskResampleFilter->SetOutputSize(epiSize); leftMaskResampleFilter->SetOutputSpacing(epiSpacing); leftMaskResampleFilter->SetOutputOrigin(epiOrigin); leftMaskResampleFilter->SetEdgePaddingValue(defaultValue); lBandMathFilter->SetNthInput(inputIdLeft, leftMaskResampleFilter->GetOutput(), "maskleft"); ++inputIdLeft; leftCondition << " and (maskleft > 0)"; } // Handle variance threshold if present if (IsParameterEnabled("mask.variancet")) { // Left side VarianceFilterType::Pointer leftVarianceFilter = VarianceFilterType::New(); leftVarianceFilter->SetInput(leftResampleFilter->GetOutput()); VarianceFilterType::InputSizeType vradius; vradius.Fill(this->GetParameterInt("bm.radius")); leftVarianceFilter->SetRadius(vradius); lBandMathFilter->SetNthInput(inputIdLeft, leftVarianceFilter->GetOutput(), "variance"); ++inputIdLeft; leftCondition << " and variance > " << GetParameterFloat("mask.variancet"); m_Filters.push_back(leftVarianceFilter.GetPointer()); } const std::string state = "255"; const std::string elseState = "0"; std::ostringstream leftFormula; #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS leftFormula << leftCondition.str() << " ? " << state << " : " << elseState; #else leftFormula << "if(" << leftCondition.str() << "," << state << "," << elseState << ")"; #endif lBandMathFilter->SetExpression(leftFormula.str()); m_Filters.push_back(leftMaskResampleFilter.GetPointer()); rBandMathFilter->SetNthInput(inputIdRight, rightResampleFilter->GetOutput(), "inright"); ++inputIdRight; std::ostringstream rightCondition; rightCondition << "(inright > 0)"; ResampleFilterType::Pointer rightMaskResampleFilter = ResampleFilterType::New(); if (IsParameterEnabled("mask.right") && HasValue("mask.right")) { rightmask = this->GetParameterFloatImage("mask.right"); rightMaskResampleFilter->SetInput(rightmask); rightMaskResampleFilter->SetDisplacementField(rightDisplacement); rightMaskResampleFilter->SetInterpolator(m_Interpolator); rightMaskResampleFilter->SetOutputSize(epiSize); rightMaskResampleFilter->SetOutputSpacing(epiSpacing); rightMaskResampleFilter->SetOutputOrigin(epiOrigin); rightMaskResampleFilter->SetEdgePaddingValue(defaultValue); rBandMathFilter->SetNthInput(inputIdRight, rightMaskResampleFilter->GetOutput(), "maskright"); ++inputIdRight; rightCondition << " and (maskright > 0)"; } if (IsParameterEnabled("mask.variancet")) { // right side VarianceFilterType::Pointer rightVarianceFilter = VarianceFilterType::New(); rightVarianceFilter->SetInput(rightResampleFilter->GetOutput()); VarianceFilterType::InputSizeType vradius; vradius.Fill(this->GetParameterInt("bm.radius")); rightVarianceFilter->SetRadius(vradius); rBandMathFilter->SetNthInput(inputIdRight, rightVarianceFilter->GetOutput(), "variance"); ++inputIdRight; rightCondition << " and variance > " << GetParameterFloat("mask.variancet"); m_Filters.push_back(rightVarianceFilter.GetPointer()); } std::ostringstream rightFormula; #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS rightFormula << rightCondition.str() << " ? " << state << " : " << elseState; #else rightFormula << "if(" << rightCondition.str() << "," << state << "," << elseState << ")"; #endif rBandMathFilter->SetExpression(rightFormula.str()); m_Filters.push_back(rightMaskResampleFilter.GetPointer()); m_Filters.push_back(rBandMathFilter.GetPointer()); m_Filters.push_back(lBandMathFilter.GetPointer()); BandMathFilterType::Pointer finalMaskFilter; if (IsParameterEnabled("postproc.bij")) { finalMaskFilter = BandMathFilterType::New(); finalMaskFilter->SetNthInput(0, lBandMathFilter->GetOutput(), "inmask"); } else { finalMaskFilter = lBandMathFilter; } // Compute disparities FilterType* blockMatcherFilterPointer = ITK_NULLPTR; FilterType* invBlockMatcherFilterPointer = ITK_NULLPTR; FilterType* subPixelFilterPointer = ITK_NULLPTR; BijectionFilterType::Pointer bijectFilter; // pointer bool minimize = false; //switch NCCBlockMatchingFilterType::Pointer NCCBlockMatcherFilter; NCCBlockMatchingFilterType::Pointer invNCCBlockMatcherFilter; NCCSubPixelFilterType::Pointer NCCSubPixelFilter; SSDBlockMatchingFilterType::Pointer SSDBlockMatcherFilter; SSDBlockMatchingFilterType::Pointer invSSDBlockMatcherFilter; SSDSubPixelFilterType::Pointer SSDSubPixelFilter; SSDDivMeanBlockMatchingFilterType::Pointer SSDDivMeanBlockMatcherFilter; SSDDivMeanBlockMatchingFilterType::Pointer invSSDDivMeanBlockMatcherFilter; SSDDivMeanSubPixelFilterType::Pointer SSDDivMeanSubPixelFilter; LPBlockMatchingFilterType::Pointer LPBlockMatcherFilter; LPBlockMatchingFilterType::Pointer invLPBlockMatcherFilter; LPSubPixelFilterType::Pointer LPSubPixelFilter; switch (GetParameterInt("bm.metric")) { case 0: //SSDDivMean otbAppLogINFO(<<"Using robust SSD Metric for BlockMatching."); SSDDivMeanBlockMatcherFilter = SSDDivMeanBlockMatchingFilterType::New(); blockMatcherFilterPointer = SSDDivMeanBlockMatcherFilter.GetPointer(); m_Filters.push_back(blockMatcherFilterPointer); if (IsParameterEnabled("postproc.bij")) { //Reverse correlation invSSDDivMeanBlockMatcherFilter = SSDDivMeanBlockMatchingFilterType::New(); invBlockMatcherFilterPointer = invSSDDivMeanBlockMatcherFilter.GetPointer(); m_Filters.push_back(invBlockMatcherFilterPointer); } SSDDivMeanSubPixelFilter = SSDDivMeanSubPixelFilterType::New(); subPixelFilterPointer = SSDDivMeanSubPixelFilter.GetPointer(); m_Filters.push_back(SSDDivMeanSubPixelFilter.GetPointer()); minimize = true; this->SetBlockMatchingParameters ( SSDDivMeanBlockMatcherFilter, invSSDDivMeanBlockMatcherFilter, SSDDivMeanSubPixelFilter, leftResampleFilter->GetOutput(), rightResampleFilter->GetOutput(), lBandMathFilter->GetOutput(), rBandMathFilter->GetOutput(), finalMaskFilter->GetOutput(), minimize, minDisp, maxDisp); break; case 1: //SSD otbAppLogINFO(<<"Using SSD Metric for BlockMatching."); SSDBlockMatcherFilter = SSDBlockMatchingFilterType::New(); blockMatcherFilterPointer = SSDBlockMatcherFilter.GetPointer(); m_Filters.push_back(blockMatcherFilterPointer); if (IsParameterEnabled("postproc.bij")) { //Reverse correlation invSSDBlockMatcherFilter = SSDBlockMatchingFilterType::New(); invBlockMatcherFilterPointer = invSSDBlockMatcherFilter.GetPointer(); m_Filters.push_back(invBlockMatcherFilterPointer); } SSDSubPixelFilter = SSDSubPixelFilterType::New(); subPixelFilterPointer = SSDSubPixelFilter.GetPointer(); m_Filters.push_back(SSDSubPixelFilter.GetPointer()); minimize = true; this->SetBlockMatchingParameters ( SSDBlockMatcherFilter, invSSDBlockMatcherFilter, SSDSubPixelFilter, leftResampleFilter->GetOutput(), rightResampleFilter->GetOutput(), lBandMathFilter->GetOutput(), rBandMathFilter->GetOutput(), finalMaskFilter->GetOutput(), minimize, minDisp, maxDisp); break; case 2: //NCC otbAppLogINFO(<<"Using NCC Metric for BlockMatching."); NCCBlockMatcherFilter = NCCBlockMatchingFilterType::New(); blockMatcherFilterPointer = NCCBlockMatcherFilter.GetPointer(); m_Filters.push_back(blockMatcherFilterPointer); if (IsParameterEnabled("postproc.bij")) { //Reverse correlation invNCCBlockMatcherFilter = NCCBlockMatchingFilterType::New(); invBlockMatcherFilterPointer = invNCCBlockMatcherFilter.GetPointer(); m_Filters.push_back(invBlockMatcherFilterPointer); } NCCSubPixelFilter = NCCSubPixelFilterType::New(); subPixelFilterPointer = NCCSubPixelFilter.GetPointer(); m_Filters.push_back(NCCSubPixelFilter.GetPointer()); minimize = false; this->SetBlockMatchingParameters ( NCCBlockMatcherFilter, invNCCBlockMatcherFilter, NCCSubPixelFilter, leftResampleFilter->GetOutput(), rightResampleFilter->GetOutput(), lBandMathFilter->GetOutput(), rBandMathFilter->GetOutput(), finalMaskFilter->GetOutput(), minimize, minDisp, maxDisp); break; case 3: //LP otbAppLogINFO(<<"Using Lp Metric for BlockMatching."); LPBlockMatcherFilter = LPBlockMatchingFilterType::New(); LPBlockMatcherFilter->GetFunctor().SetP(static_cast (GetParameterFloat("bm.metric.lp.p"))); blockMatcherFilterPointer = LPBlockMatcherFilter.GetPointer(); m_Filters.push_back(blockMatcherFilterPointer); if (IsParameterEnabled("postproc.bij")) { //Reverse correlation invLPBlockMatcherFilter = LPBlockMatchingFilterType::New(); invLPBlockMatcherFilter->GetFunctor().SetP(static_cast (GetParameterFloat("bm.metric.lp.p"))); invBlockMatcherFilterPointer = invLPBlockMatcherFilter.GetPointer(); m_Filters.push_back(invBlockMatcherFilterPointer); } LPSubPixelFilter = LPSubPixelFilterType::New(); subPixelFilterPointer = LPSubPixelFilter.GetPointer(); m_Filters.push_back(LPSubPixelFilter.GetPointer()); minimize = false; this->SetBlockMatchingParameters ( LPBlockMatcherFilter, invLPBlockMatcherFilter, LPSubPixelFilter, leftResampleFilter->GetOutput(), rightResampleFilter->GetOutput(), lBandMathFilter->GetOutput(), rBandMathFilter->GetOutput(), finalMaskFilter->GetOutput(), minimize, minDisp, maxDisp); break; default: break; } if (IsParameterEnabled("postproc.bij")) { otbAppLogINFO(<<"Using reverse block-matching to filter incoherent disparity values."); bijectFilter = BijectionFilterType::New(); //bijectFilter->SetDirectHorizontalDisparityMapInput(blockMatcherFilter->GetHorizontalDisparityOutput()); bijectFilter->SetDirectHorizontalDisparityMapInput(blockMatcherFilterPointer->GetOutput(1)); bijectFilter->SetReverseHorizontalDisparityMapInput(invBlockMatcherFilterPointer->GetOutput(1)); //bijectFilter->SetTolerance(2); bijectFilter->SetMinHDisp(minDisp); bijectFilter->SetMaxHDisp(maxDisp); bijectFilter->SetMinVDisp(0); bijectFilter->SetMaxVDisp(0); m_Filters.push_back(bijectFilter.GetPointer()); //finalMaskFilter = BandMathFilterType::New(); //finalMaskFilter->SetNthInput(0, lBandMathFilter->GetOutput(), "inmask"); finalMaskFilter->SetNthInput(1, bijectFilter->GetOutput(), "lrrl"); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS finalMaskFilter->SetExpression("(inmask > 0 and lrrl > 0) ? 255 : 0"); #else finalMaskFilter->SetExpression("if(inmask > 0 and lrrl > 0, 255, 0)"); #endif // m_Filters.push_back(finalMaskFilter.GetPointer()); } FloatImageType::Pointer hDispOutput = subPixelFilterPointer->GetOutput(0); FloatImageType::Pointer finalMaskImage=finalMaskFilter->GetOutput(); if (IsParameterEnabled("postproc.med")) { MedianFilterType::Pointer hMedianFilter = MedianFilterType::New(); hMedianFilter->SetInput(subPixelFilterPointer->GetOutput(0)); hMedianFilter->SetRadius(2); hMedianFilter->SetIncoherenceThreshold(2.0); hMedianFilter->SetMaskInput(finalMaskFilter->GetOutput()); hMedianFilter->UpdateOutputInformation(); hDispOutput = hMedianFilter->GetOutput(); finalMaskImage = hMedianFilter->GetOutputMask(); m_Filters.push_back(hMedianFilter.GetPointer()); } DisparityTranslateFilter::Pointer disparityTranslateFilter = DisparityTranslateFilter::New(); disparityTranslateFilter->SetHorizontalDisparityMapInput(hDispOutput); disparityTranslateFilter->SetVerticalDisparityMapInput(subPixelFilterPointer->GetOutput(1)); disparityTranslateFilter->SetInverseEpipolarLeftGrid(leftInverseDisplacement); disparityTranslateFilter->SetDirectEpipolarRightGrid(rightDisplacement); // disparityTranslateFilter->SetDisparityMaskInput() disparityTranslateFilter->SetLeftSensorImageInput(inleft); disparityTranslateFilter->SetNoDataValue(-32768); disparityTranslateFilter->UpdateOutputInformation(); m_Filters.push_back(disparityTranslateFilter.GetPointer()); NoDataMaskFilterType::Pointer dispTranslateMaskFilter = NoDataMaskFilterType::New(); dispTranslateMaskFilter->SetInput(disparityTranslateFilter->GetHorizontalDisparityMapOutput()); dispTranslateMaskFilter->SetInsideValue(1); dispTranslateMaskFilter->SetOutsideValue(0); m_Filters.push_back(dispTranslateMaskFilter.GetPointer()); FloatImageType::Pointer hDispOutput2 = disparityTranslateFilter->GetHorizontalDisparityMapOutput(); FloatImageType::Pointer vDispOutput2 = disparityTranslateFilter->GetVerticalDisparityMapOutput(); FloatImageType::Pointer translatedMaskImage = dispTranslateMaskFilter->GetOutput(); if (IsParameterEnabled("postproc.med")) { MedianFilterType::Pointer hMedianFilter2 = MedianFilterType::New(); MedianFilterType::Pointer vMedianFilter2 = MedianFilterType::New(); //TODO JGT Check if medianfiltering is necessary after disparitytranslate hMedianFilter2->SetInput(disparityTranslateFilter->GetHorizontalDisparityMapOutput()); hMedianFilter2->SetRadius(2); hMedianFilter2->SetIncoherenceThreshold(2.0); hMedianFilter2->SetMaskInput(dispTranslateMaskFilter->GetOutput()); hMedianFilter2->UpdateOutputInformation(); hDispOutput2 = hMedianFilter2->GetOutput(); translatedMaskImage = hMedianFilter2->GetOutputMask(); m_Filters.push_back(hMedianFilter2.GetPointer()); vMedianFilter2->SetInput(disparityTranslateFilter->GetVerticalDisparityMapOutput()); vMedianFilter2->SetRadius(2); vMedianFilter2->SetIncoherenceThreshold(2.0); vMedianFilter2->SetMaskInput(dispTranslateMaskFilter->GetOutput()); vMedianFilter2->UpdateOutputInformation(); vDispOutput2 = vMedianFilter2->GetOutput(); m_Filters.push_back(vMedianFilter2.GetPointer()); } // transform disparity into 3D map m_MultiDisparityTo3DFilterList[i]->SetReferenceKeywordList(inleft->GetImageKeywordlist()); m_MultiDisparityTo3DFilterList[i]->SetNumberOfMovingImages(1); m_MultiDisparityTo3DFilterList[i]->SetHorizontalDisparityMapInput(0, hDispOutput2); m_MultiDisparityTo3DFilterList[i]->SetVerticalDisparityMapInput(0, vDispOutput2); m_MultiDisparityTo3DFilterList[i]->SetMovingKeywordList(0, inright->GetImageKeywordlist()); m_MultiDisparityTo3DFilterList[i]->SetDisparityMaskInput(0, translatedMaskImage); m_MultiDisparityTo3DFilterList[i]->UpdateOutputInformation(); // PARAMETER ESTIMATION double minElev = 0.0; double maxElev = 0.0; // Compute min/max elevation on DEM if (otb::Wrapper::ElevationParametersHandler::IsDEMUsed(this, "elev")) { DEMToImageGeneratorType::Pointer demToImageFilter = DEMToImageGeneratorType::New(); demToImageFilter->SetOutputParametersFromImage((m_MultiDisparityTo3DFilterList[i]->GetOutput())); MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New(); minMaxFilter->SetInput(demToImageFilter->GetOutput()); minMaxFilter->GetStreamer()->SetAutomaticTiledStreaming(this->GetParameterInt("ram")); AddProcess(minMaxFilter->GetStreamer(), "Estimating min/max elevation..."); minMaxFilter->Update(); minElev = minMaxFilter->GetMinimum(); maxElev = minMaxFilter->GetMaximum(); } else { minElev = otb::Wrapper::ElevationParametersHandler::GetDefaultElevation(this, "elev"); maxElev = otb::Wrapper::ElevationParametersHandler::GetDefaultElevation(this, "elev"); otbAppLogINFO(<<"Default elevation set for Min/Max elevation : "<SetElevationMin(minElev + underElev); //m_Multi3DMapToDEMFilter->SetNoDataValue(minElev); m_Multi3DMapToDEMFilter->SetElevationMax(maxElev + overElev); } else { if (minElev < (m_Multi3DMapToDEMFilter->GetElevationMin() - underElev)) { m_Multi3DMapToDEMFilter->SetElevationMin(minElev + underElev); //m_Multi3DMapToDEMFilter->SetNoDataValue(minElev); } if (maxElev < (m_Multi3DMapToDEMFilter->GetElevationMax() - overElev)) { m_Multi3DMapToDEMFilter->SetElevationMax(maxElev + overElev); } } // blockMatcherFilter->SetMinimumHorizontalDisparity(minDisp); // blockMatcherFilter->SetMaximumHorizontalDisparity(maxDisp); // blockMatcherFilter->SetMinimumVerticalDisparity(0); // blockMatcherFilter->SetMaximumVerticalDisparity(0); // Compute disparity mask BandMathFilterType::Pointer dispMaskFilter = BandMathFilterType::New(); dispMaskFilter->SetNthInput(0, hDispOutput, "hdisp"); dispMaskFilter->SetNthInput(1, finalMaskImage, "mask"); std::ostringstream maskCondition; maskCondition << "(hdisp > " << minDisp << ") and (hdisp < " << maxDisp << ") and (mask>0)"; if (IsParameterEnabled("postproc.metrict")) { dispMaskFilter->SetNthInput(2, subPixelFilterPointer->GetOutput(2), "metric"); maskCondition << " and (metric "; if (minimize == true) { maskCondition << " < " << this->GetParameterFloat("postproc.metrict"); } else { maskCondition << " > " << this->GetParameterFloat("postproc.metrict"); } maskCondition << ")"; } std::ostringstream maskFormula; #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS maskFormula << maskCondition.str() << " ? " << state << " : " << elseState; #else maskFormula << "if(" << maskCondition.str() << "," << state << "," << elseState << ")"; #endif otbAppLogINFO(<<"Disparity mask formula : "<SetExpression(maskFormula.str()); m_Filters.push_back(dispMaskFilter.GetPointer()); disparityTranslateFilter->SetDisparityMaskInput(dispMaskFilter->GetOutput()); m_Multi3DMapToDEMFilter->Set3DMapInput(i, m_MultiDisparityTo3DFilterList[i]->GetOutput()); } if(GetParameterInt("output.mode") == 0) { otbAppLogINFO(<<"Output DSM parameters are estimated from sensor input data."); m_Multi3DMapToDEMFilter->SetOutputParametersFrom3DMap(); } else { otbAppLogINFO(<<"DSM parameters are defined by the user."); FloatVectorImageType::IndexType start; start[0] = 0; start[1] = 0; m_Multi3DMapToDEMFilter->SetOutputStartIndex(start); FloatVectorImageType::SizeType size; size[0] = this->GetParameterInt("output.mode.user.sizex"); // X size size[1] = this->GetParameterInt("output.mode.user.sizey"); //Y size m_Multi3DMapToDEMFilter->SetOutputSize(size); FloatVectorImageType::SpacingType spacing; spacing[0] = this->GetParameterFloat("output.mode.user.spacingx"); spacing[1] = this->GetParameterFloat("output.mode.user.spacingy"); m_Multi3DMapToDEMFilter->SetOutputSpacing(spacing); FloatVectorImageType::PointType origin; origin[0] = this->GetParameterFloat("output.mode.user.ulx"); origin[1] = this->GetParameterFloat("output.mode.user.uly"); m_Multi3DMapToDEMFilter->SetOutputOrigin(origin); } otbAppLogINFO(<<"Output DSM projection reference: "<SetProjectionRef(m_OutputProjectionRef); m_Multi3DMapToDEMFilter->SetDEMGridStep(this->GetParameterFloat("output.res")); if(GetParameterString("output.fusionmethod") == "min") { m_Multi3DMapToDEMFilter ->SetCellFusionMode(otb::CellFusionMode::MIN); } else if(GetParameterString("output.fusionmethod") == "mean") { m_Multi3DMapToDEMFilter ->SetCellFusionMode(otb::CellFusionMode::MEAN); } else if(GetParameterString("output.fusionmethod") == "acc") { m_Multi3DMapToDEMFilter ->SetCellFusionMode(otb::CellFusionMode::ACC); } else { m_Multi3DMapToDEMFilter ->SetCellFusionMode(otb::CellFusionMode::MAX); } m_Multi3DMapToDEMFilter->UpdateOutputInformation(); SetParameterOutputImage("output.out", m_Multi3DMapToDEMFilter->GetOutput()); } // private filters std::vector m_Filters; InterpolatorType::Pointer m_Interpolator; MultiDisparityTo3DFilterListType m_MultiDisparityTo3DFilterList; Multi3DFilterType::Pointer m_Multi3DMapToDEMFilter; ExtractorListType m_ExtractorList; std::string m_OutputProjectionRef; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::StereoFramework) OTB-release-5.8/Modules/Applications/AppStereo/app/otbStereoRectificationGridGenerator.cxx000066400000000000000000000476051301006202600320250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbStereorectificationDisplacementFieldSource.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" #include "itkInverseDisplacementFieldImageFilter.h" #include "itkVectorCastImageFilter.h" #include "itkVectorIndexSelectionCastImageFilter.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "otbDEMToImageGenerator.h" #include "otbStreamingStatisticsImageFilter.h" namespace otb { namespace Wrapper { class StereoRectificationGridGenerator : public Application { public: /** Standard class typedefs. */ typedef StereoRectificationGridGenerator Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::StereorectificationDisplacementFieldSource DisplacementFieldSourceType; typedef itk::Vector DisplacementType; typedef otb::Image DisplacementFieldType; typedef itk::VectorCastImageFilter DisplacementFieldCastFilterType; typedef itk::InverseDisplacementFieldImageFilter InverseDisplacementFieldFilterType; typedef itk::VectorIndexSelectionCastImageFilter IndexSelectionCastFilterType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter ImageListFilterType; typedef otb::DEMToImageGenerator DEMToImageGeneratorType; typedef otb::StreamingStatisticsImageFilter StatisticsFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(StereoRectificationGridGenerator, otb::Application); private: StereoRectificationGridGenerator() { // Instantiate deformation field source m_DisplacementFieldSource = DisplacementFieldSourceType::New(); m_LeftInvertDisplacementFieldFilter = InverseDisplacementFieldFilterType::New(); m_RightInvertDisplacementFieldFilter = InverseDisplacementFieldFilterType::New(); m_LeftDisplacementFieldCaster = DisplacementFieldCastFilterType::New(); m_LeftIndexSelectionFilter1 = IndexSelectionCastFilterType::New(); m_LeftIndexSelectionFilter2 = IndexSelectionCastFilterType::New(); m_LeftImageList = ImageListType::New(); m_LeftImageListFilter = ImageListFilterType::New(); m_RightDisplacementFieldCaster = DisplacementFieldCastFilterType::New(); m_RightIndexSelectionFilter1 = IndexSelectionCastFilterType::New(); m_RightIndexSelectionFilter2 = IndexSelectionCastFilterType::New(); m_RightImageList = ImageListType::New(); m_RightImageListFilter = ImageListFilterType::New(); m_DEMToImageGenerator = DEMToImageGeneratorType::New(); m_StatisticsFilter = StatisticsFilterType::New(); } void DoInit() ITK_OVERRIDE { SetName("StereoRectificationGridGenerator"); SetDescription("Generates two deformation fields to stereo-rectify (i.e. resample in epipolar geometry) a pair of stereo images up to the sensor model precision"); SetDocName("Stereo-rectification deformation grid generator"); SetDocLongDescription("This application generates a pair of deformation grid to stereo-rectify a pair of stereo images according to sensor modelling and a mean elevation hypothesis. The deformation grids can be passed to the StereoRectificationGridGenerator application for actual resampling in epipolar geometry."); SetDocLimitations("Generation of the deformation grid is not streamable, pay attention to this fact when setting the grid step."); SetDocAuthors("OTB-Team"); AddDocTag(Tags::Stereo); SetDocSeeAlso("otbGridBasedImageResampling"); AddParameter(ParameterType_Group,"io","Input and output data"); SetParameterDescription("io","This group of parameters allows setting the input and output images."); AddParameter(ParameterType_InputImage,"io.inleft","Left input image"); SetParameterDescription("io.inleft","The left input image to resample"); AddParameter(ParameterType_InputImage,"io.inright","Right input image"); SetParameterDescription("io.inright","The right input image to resample"); AddParameter(ParameterType_OutputImage, "io.outleft", "Left output deformation grid"); SetParameterDescription("io.outleft","The output deformation grid to be used to resample the left input image"); AddParameter(ParameterType_OutputImage, "io.outright", "Right output deformation grid"); SetParameterDescription("io.outright","The output deformation grid to be used to resample the right input image"); AddParameter(ParameterType_Group,"epi","Epipolar geometry and grid parameters"); SetParameterDescription("epi","Parameters of the epipolar geometry and output grids"); ElevationParametersHandler::AddElevationParameters(this, "epi.elevation"); AddParameter(ParameterType_Group,"epi.elevation.avgdem","Average elevation computed from DEM"); SetParameterDescription("epi.elevation.avgdem","Average elevation computed from the provided DEM"); AddParameter(ParameterType_Int,"epi.elevation.avgdem.step","Sub-sampling step"); SetParameterDescription("epi.elevation.avgdem.step","Step of sub-sampling for average elevation estimation"); SetDefaultParameterInt("epi.elevation.avgdem.step",1); SetMinimumParameterIntValue("epi.elevation.avgdem.step",1); MandatoryOff("epi.elevation.avgdem.step"); DisableParameter("epi.elevation.avgdem.step"); AddParameter(ParameterType_Float,"epi.elevation.avgdem.value","Average elevation value"); SetParameterDescription("epi.elevation.avgdem.value","Average elevation value estimated from DEM"); SetParameterRole("epi.elevation.avgdem.value",Role_Output); DisableParameter("epi.elevation.avgdem.value"); AddParameter(ParameterType_Float,"epi.elevation.avgdem.mindisp","Minimum disparity from DEM"); SetParameterDescription("epi.elevation.avgdem.mindisp","Disparity corresponding to estimated minimum elevation over the left image"); SetParameterRole("epi.elevation.avgdem.mindisp",Role_Output); DisableParameter("epi.elevation.avgdem.mindisp"); AddParameter(ParameterType_Float,"epi.elevation.avgdem.maxdisp","Maximum disparity from DEM"); SetParameterDescription("epi.elevation.avgdem.maxdisp","Disparity corresponding to estimated maximum elevation over the left image"); SetParameterRole("epi.elevation.avgdem.maxdisp",Role_Output); DisableParameter("epi.elevation.avgdem.maxdisp"); AddParameter(ParameterType_Float,"epi.scale","Scale of epipolar images"); SetParameterDescription("epi.scale","The scale parameter allows generating zoomed-in (scale < 1) or zoomed-out (scale > 1) epipolar images."); SetDefaultParameterFloat("epi.scale",1.); AddParameter(ParameterType_Int,"epi.step","Step of the deformation grid (in nb. of pixels)"); SetParameterDescription("epi.step","Stereo-rectification deformation grid only varies slowly. Therefore, it is recommended to use a coarser grid (higher step value) in case of large images"); SetDefaultParameterInt("epi.step",1); AddParameter(ParameterType_Int,"epi.rectsizex","Rectified image size X"); SetParameterDescription("epi.rectsizex","The application computes the optimal rectified image size so that the whole left input image fits into the rectified area. However, due to the scale and step parameter, this size may not match the size of the deformation field output. In this case, one can use these output values."); SetParameterRole("epi.rectsizex", Role_Output); AddParameter(ParameterType_Int,"epi.rectsizey","Rectified image size Y"); SetParameterDescription("epi.rectsizey","The application computes the optimal rectified image size so that the whole left input image fits into the rectified area. However, due to the scale and step parameter, this size may not match the size of the deformation field output. In this case, one can use these output values."); SetParameterRole("epi.rectsizey", Role_Output); AddParameter(ParameterType_Float,"epi.baseline","Mean baseline ratio"); SetParameterDescription("epi.baseline","This parameter is the mean value, in pixels.meters^-1, of the baseline to sensor altitude ratio. It can be used to convert disparities to physical elevation, since a disparity of one pixel will correspond to an elevation offset of the invert of this value with respect to the mean elevation."); SetParameterRole("epi.baseline", Role_Output); AddParameter(ParameterType_Group,"inverse","Write inverse fields"); SetParameterDescription("inverse","This group of parameter allows generating the inverse fields as well"); AddParameter(ParameterType_OutputImage, "inverse.outleft", "Left inverse deformation grid"); SetParameterDescription("inverse.outleft","The output deformation grid to be used to resample the epipolar left image"); MandatoryOff("inverse.outleft"); AddParameter(ParameterType_OutputImage, "inverse.outright", "Right inverse deformation grid"); SetParameterDescription("inverse.outright","The output deformation grid to be used to resample the epipolar right image"); MandatoryOff("inverse.outright"); AddParameter(ParameterType_Int, "inverse.ssrate", "Sub-sampling rate for inversion"); SetParameterDescription("inverse.ssrate","Grid inversion is an heavy process that implies spline regression on control points. To avoid eating to much memory, this parameter allows one to first sub-sample the field to invert."); SetDefaultParameterInt("inverse.ssrate",16); SetMinimumParameterIntValue("inverse.ssrate",1); // Doc example SetDocExampleParameterValue("io.inleft","wv2_xs_left.tif"); SetDocExampleParameterValue("io.inright","wv2_xs_left.tif"); SetDocExampleParameterValue("io.outleft","wv2_xs_left_epi_field.tif"); SetDocExampleParameterValue("io.outright","wv2_xs_right_epi_field.tif"); SetDocExampleParameterValue("epi.elevation.default","400"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here } void DoExecute() ITK_OVERRIDE { m_DisplacementFieldSource->SetLeftImage(GetParameterImage("io.inleft")); m_DisplacementFieldSource->SetRightImage(GetParameterImage("io.inright")); m_DisplacementFieldSource->SetGridStep(GetParameterInt("epi.step")); m_DisplacementFieldSource->SetScale(GetParameterFloat("epi.scale")); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"epi.elevation"); if (otb::Wrapper::ElevationParametersHandler::IsGeoidUsed(this,"epi.elevation") && otb::Wrapper::ElevationParametersHandler::IsDEMUsed(this,"epi.elevation") && !IsParameterEnabled("epi.elevation.avgdem.step")) { m_DisplacementFieldSource->SetUseDEM(true); } if(IsParameterEnabled("epi.elevation.avgdem.step")) { FloatImageType::PointType origin = GetParameterImage("io.inleft")->GetOrigin(); FloatImageType::SizeType size = GetParameterImage("io.inleft")->GetLargestPossibleRegion().GetSize(); FloatImageType::SpacingType spacing = GetParameterImage("io.inleft")->GetSpacing(); size[0]/=GetParameterInt("epi.elevation.avgdem.step"); size[1]/=GetParameterInt("epi.elevation.avgdem.step"); spacing[0]*=GetParameterInt("epi.elevation.avgdem.step"); spacing[1]*=GetParameterInt("epi.elevation.avgdem.step"); m_DEMToImageGenerator->SetOutputOrigin(origin); m_DEMToImageGenerator->SetOutputSize(size); m_DEMToImageGenerator->SetOutputSpacing(spacing); m_DEMToImageGenerator->SetOutputProjectionRef(GetParameterImage("io.inleft")->GetProjectionRef()); m_DEMToImageGenerator->SetOutputKeywordList(GetParameterImage("io.inleft")->GetImageKeywordlist()); m_DEMToImageGenerator->AboveEllipsoidOn(); m_StatisticsFilter->SetInput(m_DEMToImageGenerator->GetOutput()); m_StatisticsFilter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram")); AddProcess(m_StatisticsFilter->GetStreamer(),"Computing DEM statistics ..."); m_StatisticsFilter->Update(); otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(m_StatisticsFilter->GetMean()); EnableParameter("epi.elevation.avgdem.value"); SetParameterFloat("epi.elevation.avgdem.value",m_StatisticsFilter->GetMean()); } AddProcess(m_DisplacementFieldSource, "Computing epipolar grids ..."); m_DisplacementFieldSource->Update(); SetParameterInt("epi.rectsizex",m_DisplacementFieldSource->GetRectifiedImageSize()[0]); SetParameterInt("epi.rectsizey",m_DisplacementFieldSource->GetRectifiedImageSize()[1]); SetParameterFloat("epi.baseline",m_DisplacementFieldSource->GetMeanBaselineRatio()); if(IsParameterEnabled("epi.elevation.avgdem.step")) { EnableParameter("epi.elevation.avgdem.mindisp"); otbAppLogINFO("Minimum height of averaged DEM : "<GetMinimum()); SetParameterFloat("epi.elevation.avgdem.mindisp",(m_StatisticsFilter->GetMinimum()-m_StatisticsFilter->GetMean())*m_DisplacementFieldSource->GetMeanBaselineRatio()); EnableParameter("epi.elevation.avgdem.maxdisp"); SetParameterFloat("epi.elevation.avgdem.maxdisp",(m_StatisticsFilter->GetMaximum()-m_StatisticsFilter->GetMean())*m_DisplacementFieldSource->GetMeanBaselineRatio()); otbAppLogINFO("Maximum height of averaged DEM : "<GetMaximum()); } SetParameterOutputImage("io.outleft",m_DisplacementFieldSource->GetLeftDisplacementFieldOutput()); SetParameterOutputImage("io.outright",m_DisplacementFieldSource->GetRightDisplacementFieldOutput()); // Inverse part // lots of casting here ... // Left field inversion if(IsParameterEnabled("inverse.outleft")) { m_LeftDisplacementFieldCaster->SetInput(m_DisplacementFieldSource->GetLeftDisplacementFieldOutput()); m_LeftInvertDisplacementFieldFilter->SetInput(m_LeftDisplacementFieldCaster->GetOutput()); FloatVectorImageType::PointType lorigin = GetParameterImage("io.inleft")->GetOrigin(); FloatVectorImageType::SpacingType lspacing = GetParameterImage("io.inleft")->GetSpacing(); FloatVectorImageType::SizeType lsize = GetParameterImage("io.inleft")->GetLargestPossibleRegion().GetSize(); if (lsize[0]*lsize[1]>256*256) otbAppLogWARNING("Left image's size (" << lsize[0] << "x" << lsize[1] << ") may result in a too high computational demand. Please consider setting inverse.ssrate parameter correctly (actual value is " << GetParameterInt("inverse.ssrate") << ")."); lspacing[0]*=GetParameterInt("epi.step"); lspacing[1]*=GetParameterInt("epi.step"); lsize[0]/=GetParameterInt("epi.step"); lsize[1]/=GetParameterInt("epi.step"); lsize[0]+=1; lsize[1]+=1; m_LeftInvertDisplacementFieldFilter->SetOutputOrigin(lorigin); m_LeftInvertDisplacementFieldFilter->SetOutputSpacing(lspacing); m_LeftInvertDisplacementFieldFilter->SetSize(lsize); m_LeftInvertDisplacementFieldFilter->SetSubsamplingFactor(GetParameterInt("inverse.ssrate")); AddProcess(m_LeftInvertDisplacementFieldFilter, "Inverting left deformation field ..."); m_LeftInvertDisplacementFieldFilter->Update(); m_LeftIndexSelectionFilter1->SetInput(m_LeftInvertDisplacementFieldFilter->GetOutput()); m_LeftIndexSelectionFilter1->SetIndex(0); m_LeftIndexSelectionFilter2->SetInput(m_LeftInvertDisplacementFieldFilter->GetOutput()); m_LeftIndexSelectionFilter2->SetIndex(1); m_LeftImageList->Clear(); m_LeftImageList->PushBack(m_LeftIndexSelectionFilter1->GetOutput()); m_LeftImageList->PushBack(m_LeftIndexSelectionFilter2->GetOutput()); m_LeftImageListFilter->SetInput(m_LeftImageList); SetParameterOutputImage("inverse.outleft",m_LeftImageListFilter->GetOutput()); } // Right field inversion if(IsParameterEnabled("inverse.outright")) { m_RightDisplacementFieldCaster->SetInput(m_DisplacementFieldSource->GetRightDisplacementFieldOutput()); m_RightInvertDisplacementFieldFilter->SetInput(m_RightDisplacementFieldCaster->GetOutput()); FloatVectorImageType::PointType rorigin = GetParameterImage("io.inright")->GetOrigin(); FloatVectorImageType::SpacingType rspacing = GetParameterImage("io.inright")->GetSpacing(); FloatVectorImageType::SizeType rsize = GetParameterImage("io.inright")->GetLargestPossibleRegion().GetSize(); if (rsize[0]*rsize[1]>256*256) otbAppLogWARNING("Right image's size (" << rsize[0] << "x" << rsize[1] << ") may result in a too high computational demand. Please consider setting inverse.ssrate parameter correctly (actual value is " << GetParameterInt("inverse.ssrate") << ")."); rspacing[0]*=GetParameterInt("epi.step"); rspacing[1]*=GetParameterInt("epi.step"); rsize[0]/=GetParameterInt("epi.step"); rsize[1]/=GetParameterInt("epi.step"); rsize[0]+=1; rsize[1]+=1; m_RightInvertDisplacementFieldFilter->SetOutputOrigin(rorigin); m_RightInvertDisplacementFieldFilter->SetOutputSpacing(rspacing); m_RightInvertDisplacementFieldFilter->SetSize(rsize); m_RightInvertDisplacementFieldFilter->SetSubsamplingFactor(GetParameterInt("inverse.ssrate")); AddProcess(m_RightInvertDisplacementFieldFilter, "Inverting right deformation field ..."); m_RightInvertDisplacementFieldFilter->Update(); m_RightIndexSelectionFilter1->SetInput(m_RightInvertDisplacementFieldFilter->GetOutput()); m_RightIndexSelectionFilter1->SetIndex(0); m_RightIndexSelectionFilter2->SetInput(m_RightInvertDisplacementFieldFilter->GetOutput()); m_RightIndexSelectionFilter2->SetIndex(1); m_RightImageList->Clear(); m_RightImageList->PushBack(m_RightIndexSelectionFilter1->GetOutput()); m_RightImageList->PushBack(m_RightIndexSelectionFilter2->GetOutput()); m_RightImageListFilter->SetInput(m_RightImageList); SetParameterOutputImage("inverse.outright",m_RightImageListFilter->GetOutput()); } } DisplacementFieldSourceType::Pointer m_DisplacementFieldSource; InverseDisplacementFieldFilterType::Pointer m_LeftInvertDisplacementFieldFilter; DisplacementFieldCastFilterType::Pointer m_LeftDisplacementFieldCaster; IndexSelectionCastFilterType::Pointer m_LeftIndexSelectionFilter1; IndexSelectionCastFilterType::Pointer m_LeftIndexSelectionFilter2; ImageListType::Pointer m_LeftImageList; ImageListFilterType::Pointer m_LeftImageListFilter; InverseDisplacementFieldFilterType::Pointer m_RightInvertDisplacementFieldFilter; DisplacementFieldCastFilterType::Pointer m_RightDisplacementFieldCaster; IndexSelectionCastFilterType::Pointer m_RightIndexSelectionFilter1; IndexSelectionCastFilterType::Pointer m_RightIndexSelectionFilter2; ImageListType::Pointer m_RightImageList; ImageListFilterType::Pointer m_RightImageListFilter; DEMToImageGeneratorType::Pointer m_DEMToImageGenerator; StatisticsFilterType::Pointer m_StatisticsFilter; }; } // End namespace Wrapper } // End namespace otb OTB_APPLICATION_EXPORT(otb::Wrapper::StereoRectificationGridGenerator) OTB-release-5.8/Modules/Applications/AppStereo/otb-module.cmake000066400000000000000000000006501301006202600244300ustar00rootroot00000000000000set(DOCUMENTATION "Stereo application (see also Stereo module).") otb_module(OTBAppStereo DEPENDS OTBApplicationEngine OTBDEM OTBDisparityMap OTBITK OTBImageBase OTBImageIO OTBImageManipulation OTBInterpolation OTBMathParser OTBObjectList OTBStatistics OTBStereo OTBTransform TEST_DEPENDS OTBCommandLine OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppStereo/test/000077500000000000000000000000001301006202600223355ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppStereo/test/CMakeLists.txt000066400000000000000000000172131301006202600251010ustar00rootroot00000000000000otb_module_test() #----------- StereoFramework TESTS ---------------- #otb_test_application(NAME apTvDmStereoFramework2 #APP StereoFramework #OPTIONS -input.il LARGEINPUT{PLEIADES/tristereo_Haiti_Pan/master_pan.tif} #LARGEINPUT{PLEIADES/tristereo_Haiti_Pan/slave_pan_1.tif} #LARGEINPUT{PLEIADES/tristereo_Haiti_Pan/slave_pan_2.tif} #-input.co "0 1,0 2" #-elev.dem ${OTB_DATA_ROOT}/Input/DEM/srtm_directory #-elev.geoid ${OTB_DATA_ROOT}/Input/DEM/egm96.grd #-stereorect.invgridssrate 15 #-mask.variancet 100 #-bm.maxhoffset 15 #-bm.minhoffset -15 #-bm.radius 2 #-bm.metric ssdmean #-postproc.med 1 #-postproc.bij 1 #-output.res 1. #-output.out ${TEMP}/apTvStereoFrameworkHaiti2.tif #VALID --compare-image ${EPSILON_10} #${BASELINE}/apTvStereoFrameworkHaiti2.tif #${TEMP}/apTvStereoFrameworkHaiti2.tif #) #otb_test_application(NAME apTvDmStereoFramework #APP StereoFramework #OPTIONS -input.il LARGEINPUT{PLEIADES/tristereo_Haiti_Pan/phr_haiti_xt1.tif} #LARGEINPUT{PLEIADES/tristereo_Haiti_Pan/phr_haiti_xt2.tif} #LARGEINPUT{PLEIADES/tristereo_Haiti_Pan/phr_haiti_xt3.tif} #-input.co "0 1,0 2" #-elev.dem ${OTB_DATA_ROOT}/Input/DEM/srtm_directory #-elev.geoid ${OTB_DATA_ROOT}/Input/DEM/egm96.grd #-stereorect.invgridssrate 15 #-mask.variancet 100 #-bm.maxhoffset 15 #-bm.minhoffset -15 #-bm.radius 2 #-bm.metric ssdmean #-postproc.med 1 #-postproc.bij 1 #-output.res 1. #-output.out ${TEMP}/apTvStereoFrameworkHaiti.tif #VALID --compare-image ${EPSILON_10} #${BASELINE}/apTvStereoFrameworkHaiti.tif #${TEMP}/apTvStereoFrameworkHaiti.tif #) #----------- StereoRectificationGridGenerator TESTS ---------------- otb_test_application(NAME apTvDmStereoRectificationGridGeneratorTest APP StereoRectificationGridGenerator OPTIONS -io.inleft ${EXAMPLEDATA}/sensor_stereo_left.tif -io.inright ${EXAMPLEDATA}/sensor_stereo_right.tif -io.outleft ${TEMP}/apTvDmStereoRectificationGridGeneratorLeftTest.tif -io.outright ${TEMP}/apTvDmStereoRectificationGridGeneratorRightTest.tif -inverse.outleft ${TEMP}/apTvDmStereoRectificationGridGeneratorInverseLeftTest.tif -inverse.outright ${TEMP}/apTvDmStereoRectificationGridGeneratorInverseRightTest.tif -epi.elevation.default 140 -epi.scale 1.0 -epi.step 4 VALID --compare-n-images ${EPSILON_10} 4 ${BASELINE}/apTvDmStereoRectificationGridGeneratorLeftTest.tif ${TEMP}/apTvDmStereoRectificationGridGeneratorLeftTest.tif ${BASELINE}/apTvDmStereoRectificationGridGeneratorRightTest.tif ${TEMP}/apTvDmStereoRectificationGridGeneratorRightTest.tif ${BASELINE}/apTvDmStereoRectificationGridGeneratorInverseLeftTest.tif ${TEMP}/apTvDmStereoRectificationGridGeneratorInverseLeftTest.tif ${BASELINE}/apTvDmStereoRectificationGridGeneratorInverseRightTest.tif ${TEMP}/apTvDmStereoRectificationGridGeneratorInverseRightTest.tif ) #----------- FineRegistration TESTS ---------------- otb_test_application(NAME apTvDmFineRegistrationTest APP FineRegistration OPTIONS -ref ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub.tif -sec ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub_warped_centered_rigid.tif -out ${TEMP}/apTvDmFineRegistrationTest.tif -erx 5 -ery 5 -mrx 3 -mry 3 -ssrx 8 -ssry 8 -spa 0.1 -cva 0.01 -cox -2 -vmlt 0.999 VALID --compare-image ${EPSILON_10} ${BASELINE}/apTvDmFineRegistrationTest.tif ${TEMP}/apTvDmFineRegistrationTest.tif ) #----------- GeneratePlyFile TESTS ---------------- #----------- DisparityMapToElevationMap TESTS ---------------- #otb_test_application(NAME apTvDmDisparityMapToElevationMap #APP DisparityMapToElevationMap #OPTIONS -io.in ${INPUTDATA}/sensor_stereo_blockmatching_output.tif #-io.left ${EXAMPLEDATA}/sensor_stereo_left.tif #-io.right ${EXAMPLEDATA}/sensor_stereo_right.tif #-io.lgrid ${INPUTDATA}/sensor_stereo_rectif_left.tif #-io.rgrid ${INPUTDATA}/sensor_stereo_rectif_right.tif #-io.out ${TEMP}/apTvDmDisparityMapToElevationMapTest.tif #-hmin 130 #-hmax 220 #-elev.default 140 #-step 2.5 #-io.mask ${INPUTDATA}/sensor_stereo_dmap_mask.tif #VALID --compare-image ${EPSILON_10} #${BASELINE}/../../Examples/DisparityMap/elevationOutput.tif #${TEMP}/apTvDmDisparityMapToElevationMapTest.tif #) #----------- BlockMatching TESTS ---------------- otb_test_application(NAME apTvDmBlockMatchingTest APP BlockMatching OPTIONS -io.inleft ${INPUTDATA}/sensor_stereo_left_gridbasedresampling.tif -io.inright ${INPUTDATA}/sensor_stereo_right_gridbasedresampling.tif -io.out ${TEMP}/apTvDmBlockMatchingTest.tif -bm.minhd -24 -bm.maxhd 0 -bm.minvd 0 -bm.maxvd 0 -mask.nodata 0 -bm.metric ncc -bm.subpixel dichotomy -bm.medianfilter.radius 2 -bm.medianfilter.incoherence 2.0 VALID --compare-image ${EPSILON_10} ${BASELINE}/apTvDmBlockMatchingTest.tif ${TEMP}/apTvDmBlockMatchingTest.tif ) OTB-release-5.8/Modules/Applications/AppTest/000077500000000000000000000000001301006202600210345ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppTest/CMakeLists.txt000066400000000000000000000000501301006202600235670ustar00rootroot00000000000000project(OTBAppTest) otb_module_impl() OTB-release-5.8/Modules/Applications/AppTest/app/000077500000000000000000000000001301006202600216145ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppTest/app/CMakeLists.txt000066400000000000000000000003161301006202600243540ustar00rootroot00000000000000set(OTBAppTest_LINK_LIBS ${OTBApplicationEngine_LIBRARIES} ) otb_create_application( NAME TestApplication SOURCES otbTestApplication.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppTest/app/otbTestApplication.cxx000066400000000000000000000075161301006202600261610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" namespace otb { namespace Wrapper { class TestApplication : public Application { public: /** Standard class typedefs. */ typedef TestApplication Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(TestApplication, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("TestApplication"); SetDescription("This application helps developers to test parameters types"); SetDocName("Test"); SetDocLongDescription("The purpose of this application is to test parameters types."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag("Test"); //std::cout << "TestApplication::DoInit" << std::endl; AddParameter(ParameterType_Empty, "boolean", "Boolean"); AddParameter(ParameterType_Int, "int", "Integer"); MandatoryOff("int"); AddParameter(ParameterType_Float, "float", "Float"); MandatoryOff("float"); AddParameter(ParameterType_String, "string", "String"); AddParameter(ParameterType_InputFilename, "filename", "File name"); AddParameter(ParameterType_OutputFilename, "outfilename", "Output Filename"); AddParameter(ParameterType_Directory, "directory", "Directory name"); AddParameter(ParameterType_Choice, "choice", "Choice"); AddChoice("choice.choice1", "Choice 1"); AddChoice("choice.choice2", "Choice 2"); AddChoice("choice.choice3", "Choice 3"); AddParameter(ParameterType_Float, "choice.choice1.floatchoice1", "Float of choice1"); SetDefaultParameterFloat("choice.choice1.floatchoice1", 0.125); AddParameter(ParameterType_Float, "choice.choice3.floatchoice3", "Float of choice3"); SetDefaultParameterFloat("choice.choice3.floatchoice3", 5.0); AddParameter(ParameterType_Group, "ingroup", "Input Group"); MandatoryOff("ingroup"); AddParameter(ParameterType_Float, "ingroup.integer", "Integer of Group"); AddParameter(ParameterType_Group, "ingroup.images", "Input Images Group"); AddParameter(ParameterType_InputImage, "ingroup.images.inputimage", "Input Image"); AddParameter(ParameterType_Group, "outgroup", "Output Group"); AddParameter(ParameterType_OutputImage, "outgroup.outputimage", "Output Image"); AddParameter(ParameterType_InputImageList, "il", "Input image list"); MandatoryOff("il"); AddParameter(ParameterType_ListView, "cl", "Output Image channels"); AddChoice("cl.choice1", "cl.choice1"); AddChoice("cl.choice2", "cl.choice2"); MandatoryOff("cl"); AddParameter(ParameterType_ComplexInputImage, "cin", "Input Complex Image"); AddParameter(ParameterType_ComplexOutputImage, "cout", "Output Complex Image"); // Doc example parameter settings SetDocExampleParameterValue("boolean", "true"); SetDocExampleParameterValue("filename", "myFilename.foo"); } void DoUpdateParameters() ITK_OVERRIDE { //std::cout << "TestApplication::DoUpdateParameters" << std::endl; } void DoExecute() ITK_OVERRIDE { //std::cout << "TestApplication::DoExecute" << std::endl; } }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::TestApplication) OTB-release-5.8/Modules/Applications/AppTest/otb-module.cmake000066400000000000000000000002771301006202600241130ustar00rootroot00000000000000set(DOCUMENTATION "Test application.") otb_module(OTBAppTest DEPENDS OTBApplicationEngine TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppTest/test/000077500000000000000000000000001301006202600220135ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppTest/test/CMakeLists.txt000066400000000000000000000006411301006202600245540ustar00rootroot00000000000000otb_module_test() set(OTBAppTestTests otbWrapperApplicationDocTests.cxx otbAppTestTestDriver.cxx ) add_executable(otbAppTestTestDriver ${OTBAppTestTests}) target_link_libraries(otbAppTestTestDriver ${OTBAppTest-Test_LIBRARIES}) otb_module_target_label(otbAppTestTestDriver) otb_add_test(NAME apCheckDocumentation COMMAND otbAppTestTestDriver otbWrapperApplicationDocTest ${OTB_BINARY_DIR}/lib/otb/applications) OTB-release-5.8/Modules/Applications/AppTest/test/otbAppTestTestDriver.cxx000066400000000000000000000001411301006202600266340ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbWrapperApplicationDocTest); } OTB-release-5.8/Modules/Applications/AppTest/test/otbWrapperApplicationDocTests.cxx000066400000000000000000000101701301006202600305200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperApplicationRegistry.h" using otb::Wrapper::Application; using otb::Wrapper::ApplicationRegistry; int otbWrapperApplicationDocTest(int argc, char* argv[]) { if (argc < 2) { std::cerr << "Usage : " << argv[0] << " [MODULEPATH]" << std::endl; return EXIT_FAILURE; } // Get the module path list std::list modulePathList; if (argc > 1) { std::copy(argv + 1, argv + argc, std::back_inserter(modulePathList)); // Load the path in the environment std::list::const_iterator it = modulePathList.begin(); while( it != modulePathList.end() ) { ApplicationRegistry::AddApplicationPath( *(it) ); ++it; } } bool isOK = true; // Get list of available applications std::vector list = ApplicationRegistry::GetAvailableApplications(); for (std::vector::const_iterator it = list.begin(); it != list.end(); ++it) { std::cout << "Testing documentation for application "<< (*it) << " ..." << std::endl; // Create module Application::Pointer app = ApplicationRegistry::CreateApplication(*it); // Check application availability if( app.IsNull() ) { std::cout<<"Unable to load "<GetName()) == "" ) { std::cout<<"Missing Name."<GetDocName()) == "" ) { std::cout<<"Missing Doc Name."<GetDescription()) == "" ) { std::cout<<"Missing Description."<GetDocLongDescription()) == "" ) { std::cout<<"Missing DocLongDescription."<GetDocLongDescription()).size() < 30 ) { std::cout<<"DocLongDescription too small..."<GetDocAuthors()) == "" ) { std::cout<<"Missing DocAuthors."<GetDocLimitations()) == "" ) { std::cout<<"Missing DocLimitations."<GetDocSeeAlso()) == "" ) { std::cout<<"Missing DocSeeAlso."<GetDocTags().size() == 0 ) { std::cout<<"Missing DocTags."<Init(); otb::Wrapper::DocExampleStructure::Pointer doc = app->GetDocExample(); if( doc->GetApplicationName() == "" ) { std::cout<<"Error in doc example: no aaplication name found."<GetParameterList().size() == 0 ) { std::cout<<"Error in doc example: the list of parameter is empty."<GetParameterList().size() && !hasValue ) { if( doc->GetParameterValue(count) != "" ) { hasValue = true; } count++; } if( !hasValue ) { std::cout<<"Error in doc example: no value for the example found !!!"< Pointer; typedef itk::SmartPointer ConstPointer; typedef MultiToMonoChannelExtractROI ExtractorFilterType; typedef ClampImageFilter ClampFilterType; typedef ScalarImageToTexturesFilter HarTexturesFilterType; typedef ScalarImageToAdvancedTexturesFilter AdvTexturesFilterType; typedef ScalarImageToHigherOrderTexturesFilter HigTexturesFilterType; typedef HarTexturesFilterType::SizeType RadiusType; typedef HarTexturesFilterType::OffsetType OffsetType; typedef ImageList ImageListType; typedef ImageListToVectorImageFilter ImageListToVectorImageFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(HaralickTextureExtraction, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("HaralickTextureExtraction"); SetDescription("Computes textures on every pixel of the input image selected channel"); // Documentation SetDocName("Haralick Texture Extraction"); SetDocLongDescription("This application computes Haralick, advanced and higher order textures on a mono band image"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otbScalarImageToTexturesFilter, otbScalarImageToAdvancedTexturesFilter and otbScalarImageToHigherOrderTexturesFilter classes"); AddDocTag("Textures"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to compute the features on."); AddParameter(ParameterType_Int, "channel", "Selected Channel"); SetParameterDescription("channel", "The selected channel index"); SetDefaultParameterInt("channel", 1); SetMinimumParameterIntValue("channel", 1); AddRAMParameter(); AddParameter(ParameterType_Group, "parameters", "Texture feature parameters"); SetParameterDescription("parameters","This group of parameters allows one to define texture parameters."); AddParameter(ParameterType_Int,"parameters.xrad","X Radius"); SetParameterDescription("parameters.xrad", "X Radius"); SetDefaultParameterInt("parameters.xrad", 2); AddParameter(ParameterType_Int,"parameters.yrad","Y Radius"); SetParameterDescription("parameters.yrad", "Y Radius"); SetDefaultParameterInt("parameters.yrad", 2); AddParameter(ParameterType_Int,"parameters.xoff","X Offset"); SetParameterDescription("parameters.xoff", "X Offset"); SetDefaultParameterInt("parameters.xoff", 1); AddParameter(ParameterType_Int,"parameters.yoff","Y Offset"); SetParameterDescription("parameters.yoff", "Y Offset"); SetDefaultParameterInt("parameters.yoff", 1); AddParameter(ParameterType_Float,"parameters.min","Image Minimum"); SetParameterDescription("parameters.min", "Image Minimum"); SetDefaultParameterFloat("parameters.min", 0); AddParameter(ParameterType_Float,"parameters.max","Image Maximum"); SetParameterDescription("parameters.max", "Image Maximum"); SetDefaultParameterFloat("parameters.max", 255); AddParameter(ParameterType_Int,"parameters.nbbin","Histogram number of bin"); SetParameterDescription("parameters.nbbin", "Histogram number of bin"); SetDefaultParameterInt("parameters.nbbin", 8); AddParameter(ParameterType_Choice, "texture", "Texture Set Selection"); SetParameterDescription("texture", "Choice of The Texture Set"); AddChoice("texture.simple", "Simple Haralick Texture Features"); SetParameterDescription("texture.simple","This group of parameters defines the 8 local Haralick texture feature output image.\ The image channels are: Energy, Entropy, Correlation, Inverse Difference Moment,\ Inertia, Cluster Shade, Cluster Prominence and Haralick Correlation"); AddChoice("texture.advanced", "Advanced Texture Features"); SetParameterDescription("texture.advanced","This group of parameters defines the 9 advanced texture feature output image.\ The image channels are: Mean, Variance, Sum Average, Sum Variance,\ Sum Entropy, Difference of Entropies, Difference of Variances, IC1 and IC2"); AddChoice("texture.higher", "Higher Order Texture Features"); SetParameterDescription("texture.higher","This group of parameters defines the 11 higher order texture feature output image.\ The image channels are: Short Run Emphasis, Long Run Emphasis, Grey-Level Nonuniformity, Run Length Nonuniformity, Run Percentage, \ Low Grey-Level Run Emphasis, High Grey-Level Run Emphasis, Short Run Low Grey-Level Emphasis, Short Run High Grey-Level Emphasis, \ Long Run Low Grey-Level Emphasis and Long Run High Grey-Level Emphasis"); AddParameter(ParameterType_OutputImage, "out", "Output Image"); SetParameterDescription("out", "Output image containing the selected texture features."); MandatoryOff("out"); EnableParameter("out"); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("channel", "2"); SetDocExampleParameterValue("parameters.xrad", "3"); SetDocExampleParameterValue("parameters.yrad", "3"); SetDocExampleParameterValue("texture", "simple"); SetDocExampleParameterValue("out", "HaralickTextures.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); int nBComp = inImage->GetNumberOfComponentsPerPixel(); if( GetParameterInt("channel") > nBComp ) { itkExceptionMacro(<< "The specified channel index is invalid."); } const std::string texType = GetParameterString("texture"); RadiusType radius; radius[0] = GetParameterInt("parameters.xrad"); radius[1] = GetParameterInt("parameters.yrad"); OffsetType offset; offset[0] = GetParameterInt("parameters.xoff"); offset[1] = GetParameterInt("parameters.yoff"); m_ExtractorFilter = ExtractorFilterType::New(); m_ExtractorFilter->SetInput(inImage); m_ExtractorFilter->SetStartX(inImage->GetLargestPossibleRegion().GetIndex(0)); m_ExtractorFilter->SetStartY(inImage->GetLargestPossibleRegion().GetIndex(1)); m_ExtractorFilter->SetSizeX(inImage->GetLargestPossibleRegion().GetSize(0)); m_ExtractorFilter->SetSizeY(inImage->GetLargestPossibleRegion().GetSize(1)); m_ExtractorFilter->SetChannel(GetParameterInt("channel")); m_ExtractorFilter->UpdateOutputInformation(); m_ClampFilter = ClampFilterType::New(); m_ClampFilter->SetInput(m_ExtractorFilter->GetOutput()); m_ClampFilter->SetLower(GetParameterFloat("parameters.min")); m_ClampFilter->SetUpper(GetParameterFloat("parameters.max")); m_HarTexFilter = HarTexturesFilterType::New(); m_HarImageList = ImageListType::New(); m_HarConcatener = ImageListToVectorImageFilterType::New(); m_AdvTexFilter = AdvTexturesFilterType::New(); m_AdvImageList = ImageListType::New(); m_AdvConcatener = ImageListToVectorImageFilterType::New(); m_HigTexFilter = HigTexturesFilterType::New(); m_HigImageList = ImageListType::New(); m_HigConcatener = ImageListToVectorImageFilterType::New(); if( texType == "simple" ) { m_HarTexFilter->SetInput(const_cast(m_ClampFilter->GetOutput())); m_HarTexFilter->SetRadius(radius); m_HarTexFilter->SetOffset(offset); m_HarTexFilter->SetInputImageMinimum(GetParameterFloat("parameters.min")); m_HarTexFilter->SetInputImageMaximum(GetParameterFloat("parameters.max")); m_HarTexFilter->SetNumberOfBinsPerAxis(GetParameterInt("parameters.nbbin")); m_HarTexFilter->UpdateOutputInformation(); m_HarImageList->PushBack(m_HarTexFilter->GetEnergyOutput()); m_HarImageList->PushBack(m_HarTexFilter->GetEntropyOutput()); m_HarImageList->PushBack(m_HarTexFilter->GetCorrelationOutput()); m_HarImageList->PushBack(m_HarTexFilter->GetInverseDifferenceMomentOutput()); m_HarImageList->PushBack(m_HarTexFilter->GetInertiaOutput()); m_HarImageList->PushBack(m_HarTexFilter->GetClusterShadeOutput()); m_HarImageList->PushBack(m_HarTexFilter->GetClusterProminenceOutput()); m_HarImageList->PushBack(m_HarTexFilter->GetHaralickCorrelationOutput()); m_HarConcatener->SetInput(m_HarImageList); SetParameterOutputImage("out", m_HarConcatener->GetOutput()); } if( texType == "advanced" ) { m_AdvTexFilter->SetInput(const_cast(m_ClampFilter->GetOutput())); m_AdvTexFilter->SetRadius(radius); m_AdvTexFilter->SetOffset(offset); m_AdvTexFilter->SetInputImageMinimum(GetParameterFloat("parameters.min")); m_AdvTexFilter->SetInputImageMaximum(GetParameterFloat("parameters.max")); m_AdvTexFilter->SetNumberOfBinsPerAxis(GetParameterInt("parameters.nbbin")); m_AdvImageList->PushBack(m_AdvTexFilter->GetMeanOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetVarianceOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetDissimilarityOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetSumAverageOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetSumVarianceOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetSumEntropyOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetDifferenceEntropyOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetDifferenceVarianceOutput()); m_AdvImageList->PushBack(m_AdvTexFilter->GetIC1Output()); m_AdvImageList->PushBack(m_AdvTexFilter->GetIC2Output()); m_AdvConcatener->SetInput(m_AdvImageList); SetParameterOutputImage("out", m_AdvConcatener->GetOutput()); } if( texType == "higher" ) { m_HigTexFilter->SetInput(const_cast(m_ClampFilter->GetOutput())); m_HigTexFilter->SetRadius(radius); m_HigTexFilter->SetOffset(offset); m_HigTexFilter->SetInputImageMinimum(GetParameterFloat("parameters.min")); m_HigTexFilter->SetInputImageMaximum(GetParameterFloat("parameters.max")); m_HigTexFilter->SetNumberOfBinsPerAxis(GetParameterInt("parameters.nbbin")); m_HigImageList->PushBack(m_HigTexFilter->GetShortRunEmphasisOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetLongRunEmphasisOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetGreyLevelNonuniformityOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetRunLengthNonuniformityOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetRunPercentageOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetLowGreyLevelRunEmphasisOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetHighGreyLevelRunEmphasisOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetShortRunLowGreyLevelEmphasisOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetShortRunHighGreyLevelEmphasisOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetLongRunLowGreyLevelEmphasisOutput()); m_HigImageList->PushBack(m_HigTexFilter->GetLongRunHighGreyLevelEmphasisOutput()); m_HigConcatener->SetInput(m_HigImageList); SetParameterOutputImage("out", m_HigConcatener->GetOutput()); } } ExtractorFilterType::Pointer m_ExtractorFilter; ClampFilterType::Pointer m_ClampFilter; HarTexturesFilterType::Pointer m_HarTexFilter; ImageListType::Pointer m_HarImageList; ImageListToVectorImageFilterType::Pointer m_HarConcatener; AdvTexturesFilterType::Pointer m_AdvTexFilter; ImageListType::Pointer m_AdvImageList; ImageListToVectorImageFilterType::Pointer m_AdvConcatener; HigTexturesFilterType::Pointer m_HigTexFilter; ImageListType::Pointer m_HigImageList; ImageListToVectorImageFilterType::Pointer m_HigConcatener; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::HaralickTextureExtraction) OTB-release-5.8/Modules/Applications/AppTextures/app/otbSFSTextureExtraction.cxx000066400000000000000000000156761301006202600300450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbSFSTexturesImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "itkTimeProbe.h" namespace otb { namespace Wrapper { class SFSTextureExtraction : public Application { public: /** Standard class typedefs. */ typedef SFSTextureExtraction Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef MultiToMonoChannelExtractROI ExtractorFilterType; typedef SFSTexturesImageFilter SFSTexturesFilterType; typedef ImageList ImageListType; typedef ImageListToVectorImageFilter ImageListToVectorImageFilterType; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(SFSTextureExtraction, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("SFSTextureExtraction"); SetDescription("Computes Structural Feature Set textures on every pixel of the input image selected channel"); // Documentation SetDocName("SFS Texture Extraction"); SetDocLongDescription("This application computes SFS textures on a mono band image"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("otbSFSTexturesImageFilter class"); AddDocTag("Textures"); AddDocTag(Tags::FeatureExtraction); AddParameter(ParameterType_InputImage, "in", "Input Image"); SetParameterDescription("in", "The input image to compute the features on."); AddParameter(ParameterType_Int, "channel", "Selected Channel"); SetParameterDescription("channel", "The selected channel index"); SetDefaultParameterInt("channel", 1); SetMinimumParameterIntValue("channel", 1); AddRAMParameter(); AddParameter(ParameterType_Group, "parameters", "Texture feature parameters"); SetParameterDescription("parameters","This group of parameters allows one to define SFS texture parameters.\ The available texture features are SFS'Length, SFS'Width, SFS'PSI, SFS'W-Mean, SFS'Ratio and SFS'SD.\ They are provided in this exact order in the output image."); AddParameter(ParameterType_Float,"parameters.spethre","Spectral Threshold"); SetParameterDescription("parameters.spethre", "Spectral Threshold"); SetDefaultParameterFloat("parameters.spethre", 50.0); AddParameter(ParameterType_Int,"parameters.spathre","Spatial Threshold"); SetParameterDescription("parameters.spathre", "Spatial Threshold"); SetDefaultParameterInt("parameters.spathre", 100); AddParameter(ParameterType_Int,"parameters.nbdir","Number of Direction"); SetParameterDescription("parameters.nbdir", "Number of Direction"); SetDefaultParameterInt("parameters.nbdir", 20); AddParameter(ParameterType_Float,"parameters.alpha","Alpha"); SetParameterDescription("parameters.alpha", "Alpha"); SetDefaultParameterFloat("parameters.alpha", 1.0); AddParameter(ParameterType_Int,"parameters.maxcons","Ratio Maximum Consideration Number"); SetParameterDescription("parameters.maxcons", "Ratio Maximum Consideration Number"); SetDefaultParameterInt("parameters.maxcons", 5); AddParameter(ParameterType_OutputImage, "out", "Feature Output Image"); SetParameterDescription("out", "Output image containing the SFS texture features."); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("channel", "1"); SetDocExampleParameterValue("parameters.spethre", "50.0"); SetDocExampleParameterValue("parameters.spathre", "100"); SetDocExampleParameterValue("out", "SFSTextures.tif"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here : all parameters are independent } void DoExecute() ITK_OVERRIDE { FloatVectorImageType::Pointer inImage = GetParameterImage("in"); inImage->UpdateOutputInformation(); int nBComp = inImage->GetNumberOfComponentsPerPixel(); if( GetParameterInt("channel") > nBComp ) { itkExceptionMacro(<< "The specified channel index is invalid."); } m_ExtractorFilter = ExtractorFilterType::New(); m_ExtractorFilter->SetInput(inImage); m_ExtractorFilter->SetStartX(inImage->GetLargestPossibleRegion().GetIndex(0)); m_ExtractorFilter->SetStartY(inImage->GetLargestPossibleRegion().GetIndex(1)); m_ExtractorFilter->SetSizeX(inImage->GetLargestPossibleRegion().GetSize(0)); m_ExtractorFilter->SetSizeY(inImage->GetLargestPossibleRegion().GetSize(1)); m_ExtractorFilter->SetChannel(GetParameterInt("channel")); m_ExtractorFilter->UpdateOutputInformation(); m_TexFilter = SFSTexturesFilterType::New(); m_ImageList = ImageListType::New(); m_Concatener = ImageListToVectorImageFilterType::New(); m_TexFilter->SetInput(const_cast(m_ExtractorFilter->GetOutput())); m_TexFilter->SetSpectralThreshold(GetParameterFloat("parameters.spethre")); m_TexFilter->SetSpatialThreshold(GetParameterInt("parameters.spathre")); m_TexFilter->SetNumberOfDirections(GetParameterInt("parameters.nbdir")); m_TexFilter->SetAlpha(GetParameterFloat("parameters.alpha")); m_TexFilter->SetRatioMaxConsiderationNumber(GetParameterInt("parameters.maxcons")); m_TexFilter->SetFeatureStatus(SFSTexturesFilterType::LENGTH, true); m_TexFilter->SetFeatureStatus(SFSTexturesFilterType::WIDTH, true); m_TexFilter->SetFeatureStatus(SFSTexturesFilterType::PSI, true); m_TexFilter->SetFeatureStatus(SFSTexturesFilterType::WMEAN, true); m_TexFilter->SetFeatureStatus(SFSTexturesFilterType::RATIO, true); m_TexFilter->SetFeatureStatus(SFSTexturesFilterType::SD, true); m_TexFilter->UpdateOutputInformation(); m_ImageList->PushBack(m_TexFilter->GetLengthOutput()); m_ImageList->PushBack(m_TexFilter->GetWidthOutput()); m_ImageList->PushBack(m_TexFilter->GetPSIOutput()); m_ImageList->PushBack(m_TexFilter->GetWMeanOutput()); m_ImageList->PushBack(m_TexFilter->GetRatioOutput()); m_ImageList->PushBack(m_TexFilter->GetSDOutput()); m_Concatener->SetInput(m_ImageList); SetParameterOutputImage("out", m_Concatener->GetOutput()); } ExtractorFilterType::Pointer m_ExtractorFilter; SFSTexturesFilterType::Pointer m_TexFilter; ImageListType::Pointer m_ImageList; ImageListToVectorImageFilterType::Pointer m_Concatener; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::SFSTextureExtraction) OTB-release-5.8/Modules/Applications/AppTextures/otb-module.cmake000066400000000000000000000004701301006202600250120ustar00rootroot00000000000000set(DOCUMENTATION "Textures application (see also Textures module).") otb_module(OTBAppTextures DEPENDS OTBTextures OTBITK OTBImageBase OTBApplicationEngine OTBImageManipulation OTBObjectList TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppTextures/test/000077500000000000000000000000001301006202600227175ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppTextures/test/CMakeLists.txt000066400000000000000000000023461301006202600254640ustar00rootroot00000000000000otb_module_test() #----------- HaralickTextureExtraction TESTS ---------------- otb_test_application(NAME apTvFEHaralickTextureExtraction APP HaralickTextureExtraction OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -channel 1 -texture simple -out ${TEMP}/apTvFEHaralickTextureExtraction.tif -parameters.min 127 -parameters.max 1578 VALID --compare-image ${EPSILON_15} ${BASELINE}/apTvFEHaralickTextureExtraction.tif ${TEMP}/apTvFEHaralickTextureExtraction.tif) #----------- SFSTextureExtraction TESTS ---------------- otb_test_application(NAME apTvFESFSTextureExtraction APP SFSTextureExtraction OPTIONS -in ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif -channel 1 -out ${TEMP}/apTvFESFSTextureExtraction.tif VALID --compare-image ${NOTOL} ${BASELINE}/apTvFESFSTextureExtraction.tif ${TEMP}/apTvFESFSTextureExtraction.tif) OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/000077500000000000000000000000001301006202600243705ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/CMakeLists.txt000066400000000000000000000000671301006202600271330ustar00rootroot00000000000000project(OTBAppVectorDataTranslation) otb_module_impl() OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/app/000077500000000000000000000000001301006202600251505ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/app/CMakeLists.txt000066400000000000000000000004241301006202600277100ustar00rootroot00000000000000set(OTBAppVectorDataTranslation_LINK_LIBS ${OTBConversion_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBTransform_LIBRARIES} ) otb_create_application( NAME Rasterization SOURCES otbRasterization.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/app/otbRasterization.cxx000066400000000000000000000331601301006202600312420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbGeoInformationConversion.h" #include "otbOGRDataSourceToLabelImageFilter.h" #include "otbGenericRSTransform.h" namespace otb { namespace Wrapper { class Rasterization : public Application { public: /** Standard class typedefs. */ typedef Rasterization Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Rasterization, otb::Application); /** Filters typedef */ // the application produces a binary mask : no need to use a FloatVectorImageType typedef UInt8ImageType::PointType PointType; typedef UInt8ImageType::SizeType SizeType; typedef UInt8ImageType::SpacingType SpacingType; typedef UInt8ImageType::IndexType IndexType; // Misc typedef otb::GenericRSTransform<> RSTransformType; typedef otb::PipelineMemoryPrintCalculator MemoryCalculatorType; // Exact rasterization mode typedef otb::OGRDataSourceToLabelImageFilter OGRDataSourceToMapFilterType; private: void DoInit() ITK_OVERRIDE { SetName("Rasterization"); SetDescription("Rasterize a vector dataset."); SetDocName("Rasterization"); SetDocLongDescription("This application allows reprojecting and rasterize a vector dataset. The grid of the rasterized output can be set by using a reference image, or by setting all parmeters (origin, size, spacing) by hand. In the latter case, at least the spacing (ground sampling distance) is needed (other parameters are computed automatically). The rasterized output can also be in a different projection reference system than the input dataset.\n There are two rasterize mode available in the application. The first is the binary mode: it allows rendering all pixels belonging to a geometry of the input dataset in the foreground color, while rendering the other in background color. The second one allows rendering pixels belonging to a geometry woth respect to an attribute of this geometry. The field of the attribute to render can be set by the user. In the second mode, the background value is still used for unassociated pixels."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("For now, support of input dataset with multiple layers having different projection reference system is limited."); AddDocTag(Tags::Vector); AddParameter(ParameterType_InputVectorData, "in", "Input vector dataset"); SetParameterDescription( "in", "The input vector dataset to be rasterized" ); AddParameter(ParameterType_OutputImage, "out", "Output image"); SetParameterDescription( "out", "An output image containing the rasterized vector dataset" ); AddParameter(ParameterType_InputImage, "im", "Input reference image"); SetParameterDescription( "im", "A reference image from which to import output grid and projection reference system information." ); MandatoryOff("im"); AddParameter(ParameterType_Int, "szx", "Output size x"); SetParameterDescription( "szx", "Output size along x axis (useless if support image is given)" ); MandatoryOff("szx"); SetMinimumParameterIntValue("szx",1); AddParameter(ParameterType_Int, "szy", "Output size y"); SetParameterDescription( "szy", "Output size along y axis (useless if support image is given)" ); MandatoryOff("szy"); SetMinimumParameterIntValue("szy",1); AddParameter(ParameterType_Int, "epsg", "Output EPSG code"); SetParameterDescription( "epsg", "EPSG code for the output projection reference system (EPSG 4326 for WGS84, 32631 for UTM31N...,useless if support image is given)" ); MandatoryOff("epsg"); AddParameter(ParameterType_Float, "orx", "Output Upper-left x"); SetParameterDescription( "orx", "Output upper-left corner x coordinate (useless if support image is given)" ); MandatoryOff("orx"); AddParameter(ParameterType_Float, "ory", "Output Upper-left y"); SetParameterDescription( "ory", "Output upper-left corner y coordinate (useless if support image is given)" ); MandatoryOff("ory"); AddParameter(ParameterType_Float, "spx", "Spacing (GSD) x"); SetParameterDescription( "spx", "Spacing (ground sampling distance) along x axis (useless if support image is given)" ); MandatoryOff("spx"); AddParameter(ParameterType_Float, "spy", "Spacing (GSD) y"); SetParameterDescription( "spy", "Spacing (ground sampling distance) along y axis (useless if support image is given)" ); MandatoryOff("spy"); AddParameter(ParameterType_Float,"background", "Background value"); SetParameterDescription("background","Default value for pixels not belonging to any geometry"); SetDefaultParameterFloat("background",0.); AddParameter(ParameterType_Choice,"mode","Rasterization mode"); SetParameterDescription("mode","Choice of rasterization modes"); AddChoice("mode.binary","Binary mode"); SetParameterDescription("mode.binary","In this mode, pixels within a geometry will hold the user-defined foreground value"); AddParameter(ParameterType_Float,"mode.binary.foreground","Foreground value"); SetParameterDescription("mode.binary.foreground","Value for pixels inside a geometry"); SetDefaultParameterFloat("mode.binary.foreground",255); AddChoice("mode.attribute","Attribute burning mode"); SetParameterDescription("mode.attribute","In this mode, pixels within a geometry will hold the value of a user-defined field extracted from this geometry."); AddParameter(ParameterType_String,"mode.attribute.field","The attribute field to burn"); SetParameterDescription("mode.attribute.field","Name of the attribute field to burn"); SetParameterString("mode.attribute.field","DN"); AddRAMParameter(); SetDocExampleParameterValue("in","qb_RoadExtract_classification.shp"); SetDocExampleParameterValue("out", "rasterImage.tif"); SetDocExampleParameterValue("spx","1."); SetDocExampleParameterValue("spy","1."); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do } void DoExecute() ITK_OVERRIDE { otb::ogr::DataSource::Pointer ogrDS; UInt8ImageType::Pointer referenceImage; ogrDS = otb::ogr::DataSource::New(GetParameterString("in"), otb::ogr::DataSource::Modes::Read); bool validInputProjRef = false; std::string inputProjectionRef = ""; // Retrieve extent double ulx, uly, lrx, lry; bool extentAvailable = true; try { inputProjectionRef = ogrDS->GetGlobalExtent(ulx,uly,lrx,lry); } catch(const itk::ExceptionObject&) { extentAvailable = false; } if(!extentAvailable && (!(HasValue("spx") && HasValue("spy")) || (!(HasValue("orx") && HasValue("ory"))))) { otbAppLogWARNING(<<"Failed to retrieve the spatial extent of the dataset. The application will retry in force mode, which means it might have to walk the entire dataset to determine extent. This might be a long process for large datasets. Consider setting the orx, ory, spx and spy parameters."); try { inputProjectionRef = ogrDS->GetGlobalExtent(ulx,uly,lrx,lry,true); extentAvailable = true; } catch(itk::ExceptionObject & err) { extentAvailable = false; otbAppLogFATAL(<<"Failed to retrieve the spatial extent of the dataset in force mode. The spatial extent is mandatory when orx, ory, spx and spy parameters are not set, consider setting them. Error from library: "<GetProjectionRef(); size = referenceImage->GetLargestPossibleRegion().GetSize(); origin = referenceImage->GetOrigin(); spacing = referenceImage->GetSpacing(); } else if (HasValue("spx") && HasValue("spy")) { if (HasValue("epsg")) { unsigned int RSID = GetParameterInt("epsg"); outputProjectionRef = otb::GeoInformationConversion::ToWKT(RSID); } else { outputProjectionRef = inputProjectionRef; } PointType corner; spacing[0] = GetParameterFloat("spx"); spacing[1] = GetParameterFloat("spy"); if ( HasValue("orx") && HasValue("ory")) { corner[0] = GetParameterFloat("orx"); corner[1] = GetParameterFloat("ory"); } else if(extentAvailable) { corner[0] = (spacing[0] > 0 ? ulx : lrx); corner[1] = (spacing[1] > 0 ? uly : lry); // Transform to output EPSG if(validInputProjRef) { RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetInputProjectionRef(inputProjectionRef); rsTransform->SetOutputProjectionRef(outputProjectionRef); rsTransform->InstantiateTransform(); corner = rsTransform->TransformPoint(corner); } } else { otbAppLogFATAL(<<"The orx and ory parameters are not set and the dataset extent could not be retrieved. The application can not determine the origin of the output raster"); } origin[0] = corner[0] + 0.5*spacing[0]; origin[1] = corner[1] + 0.5*spacing[1]; if (HasValue("szx") && HasValue("szy")) { size[0] = GetParameterInt("szx"); size[1] = GetParameterInt("szy"); } else if(extentAvailable) { // Transform to output EPSG PointType lrout; lrout[0] = (spacing[0] > 0 ? lrx : ulx); lrout[1] = (spacing[1] > 0 ? lry : uly); if(validInputProjRef) { RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetInputProjectionRef(inputProjectionRef); rsTransform->SetOutputProjectionRef(outputProjectionRef); rsTransform->InstantiateTransform(); lrout = rsTransform->TransformPoint(lrout); } size[0]=static_cast((lrout[0] - corner[0])/spacing[0]); size[1]=static_cast((lrout[1] - corner[1])/spacing[1]); } else { otbAppLogFATAL(<<"The szx and szy parameters are not set and the dataset extent could not be retrieved. The application can not deterimine the size of the output raster"); } } else { otbAppLogFATAL("No reference image was given, at least spx and spy parameters must be set."); } m_OGRDataSourceRendering = OGRDataSourceToMapFilterType::New(); m_OGRDataSourceRendering->AddOGRDataSource(ogrDS); m_OGRDataSourceRendering->SetOutputSize(size); m_OGRDataSourceRendering->SetOutputOrigin(origin); m_OGRDataSourceRendering->SetOutputSpacing(spacing); m_OGRDataSourceRendering->SetBackgroundValue(GetParameterFloat("background")); if(GetParameterString("mode") == "binary") { m_OGRDataSourceRendering->SetBurnAttributeMode(false); m_OGRDataSourceRendering->SetForegroundValue(GetParameterFloat("mode.binary.foreground")); } else if(GetParameterString("mode") == "attribute") { m_OGRDataSourceRendering->SetBurnAttributeMode(true); m_OGRDataSourceRendering->SetBurnAttribute(GetParameterString("mode.attribute.field")); } if(validInputProjRef) { m_OGRDataSourceRendering->SetOutputProjectionRef(outputProjectionRef); } otbAppLogINFO("Output projection reference system is: "<("out", m_OGRDataSourceRendering->GetOutput()); } OGRDataSourceToMapFilterType::Pointer m_OGRDataSourceRendering; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::Rasterization) OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/otb-module.cmake000066400000000000000000000004511301006202600274410ustar00rootroot00000000000000set(DOCUMENTATION "VectorDataTranslation application (translation, rotation and scale).") otb_module(OTBAppVectorDataTranslation DEPENDS OTBConversion OTBApplicationEngine OTBTransform TEST_DEPENDS OTBTestKernel OTBCommandLine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/test/000077500000000000000000000000001301006202600253475ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppVectorDataTranslation/test/CMakeLists.txt000066400000000000000000000121321301006202600301060ustar00rootroot00000000000000otb_module_test() #----------- Rasterization TESTS ---------------- otb_test_application(NAME apTvRsRasterizationLinesAttributeMode APP Rasterization OPTIONS -in LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} -im ${BASELINE}/apTvRsRasterizationLines.tif -out ${TEMP}/apTvRsRasterizationLinesAttributeMode.tif uint32 -background 0 -mode attribute -mode.attribute.field osm_id VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationLinesAttributeMode.tif ${TEMP}/apTvRsRasterizationLinesAttributeMode.tif) otb_test_application(NAME apTvRsRasterizationPolygons2LayersWith2SRS APP Rasterization OPTIONS -in ${INPUTDATA}/ToulouseRoad-examples_2layers_2srs.sqlite -spx 1. -spy -1. -out ${TEMP}/apTvRsRasterizationPolygons2LayersWith2SRS.tif uint8 -background 255 -mode.binary.foreground 0 VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationPolygons2LayersWith2SRS.tif ${TEMP}/apTvRsRasterizationPolygons2LayersWith2SRS.tif) otb_test_application(NAME apTvRsRasterizationLines APP Rasterization OPTIONS -in LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} -im ${BASELINE}/apTvRsRasterizationLines.tif -out ${TEMP}/apTvRsRasterizationLines.tif uint8 -background 255 -mode.binary.foreground 0 VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationLines.tif ${TEMP}/apTvRsRasterizationLines.tif) otb_test_application(NAME apTvRsRasterizationLinesStreaming APP Rasterization OPTIONS -in LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} -im ${BASELINE}/apTvRsRasterizationLines.tif -out ${TEMP}/apTvRsRasterizationLinesStreaming.tif uint8 -ram 1 -background 255 -mode.binary.foreground 0 VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationLines.tif ${TEMP}/apTvRsRasterizationLinesStreaming.tif) otb_test_application(NAME apTvRsRasterizationPolygons APP Rasterization OPTIONS -in ${INPUTDATA}/Rasterization/polgons.shp -spx 1. -spy 1. -out ${TEMP}/apTvRsRasterizationPolygons.tif uint8 -background 255 -mode.binary.foreground 0 VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationPolygons.tif ${TEMP}/apTvRsRasterizationPolygons.tif) otb_test_application(NAME apTvRsRasterizationPoints APP Rasterization OPTIONS -in LARGEINPUT{VECTOR/MidiPyrenees/points.shp} -im ${BASELINE}/apTvRsRasterizationPoints.tif -out ${TEMP}/apTvRsRasterizationPoints.tif uint8 -background 255 -mode.binary.foreground 0 VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationPoints.tif ${TEMP}/apTvRsRasterizationPoints.tif) otb_test_application(NAME apTvRsRasterizationShadowsSHP APP Rasterization OPTIONS -in ${INPUTDATA}/Capitole-Shadows.shp -im ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -out ${TEMP}/apTvRsRasterizationShadowsSHP.tif -background 255 -mode.binary.foreground 0 VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationShadowsSHP.tif ${TEMP}/apTvRsRasterizationShadowsSHP.tif) otb_test_application(NAME apTvRsRasterizationShadowsKML APP Rasterization OPTIONS -in ${INPUTDATA}/Capitole-Shadows.kml -im ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -out ${TEMP}/apTvRsRasterizationShadowsKML.tif -background 255 -mode.binary.foreground 0 VALID --compare-image ${NOTOL} ${BASELINE}/apTvRsRasterizationShadowsKML.tif ${TEMP}/apTvRsRasterizationShadowsKML.tif) OTB-release-5.8/Modules/Applications/AppVectorUtils/000077500000000000000000000000001301006202600224005ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppVectorUtils/CMakeLists.txt000066400000000000000000000000551301006202600251400ustar00rootroot00000000000000project(OTBAppVectorUtils) otb_module_impl() OTB-release-5.8/Modules/Applications/AppVectorUtils/app/000077500000000000000000000000001301006202600231605ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppVectorUtils/app/CMakeLists.txt000066400000000000000000000017111301006202600257200ustar00rootroot00000000000000set(OTBAppVectorUtils_LINK_LIBS ${OTBVectorDataBase_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBVectorDataManipulation_LIBRARIES} ${OTBCarto_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ) otb_create_application( NAME VectorDataTransform SOURCES otbVectorDataTransform.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME VectorDataExtractROI SOURCES otbVectorDataExtractROI.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME VectorDataSetField SOURCES otbVectorDataSetField.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME OSMDownloader SOURCES otbOSMDownloader.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) otb_create_application( NAME ConcatenateVectorData SOURCES otbConcatenateVectorData.cxx LINK_LIBRARIES ${${otb-module}_LIBRARIES}) OTB-release-5.8/Modules/Applications/AppVectorUtils/app/otbConcatenateVectorData.cxx000066400000000000000000000057641301006202600306260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbConcatenateVectorDataFilter.h" namespace otb { namespace Wrapper { class ConcatenateVectorData : public Application { public: /** Standard class typedefs. */ typedef ConcatenateVectorData Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(ConcatenateVectorData, otb::Application); /** VectorData Concatenate filter*/ typedef otb::ConcatenateVectorDataFilter ConcatenateFilterType; private: void DoInit() ITK_OVERRIDE { SetName("ConcatenateVectorData"); SetDescription("Concatenate VectorDatas"); SetDocName("Concatenate"); SetDocLongDescription("This application concatenates a list of VectorData to produce a unique VectorData as output." "Note that the VectorDatas must be of the same type (Storing polygons only, lines only, or points only)"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Vector); AddParameter(ParameterType_InputVectorDataList, "vd", "Input VectorDatas to concatenate"); SetParameterDescription("vd", "VectorData files to be concatenated in an unique VectorData"); AddParameter(ParameterType_OutputVectorData, "out", "Concatenated VectorData"); SetParameterDescription("out", "Output conctenated VectorData"); // Doc example parameter settings SetDocExampleParameterValue("vd", "ToulousePoints-examples.shp ToulouseRoad-examples.shp"); SetDocExampleParameterValue("out", "ConcatenatedVectorData.shp"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } void DoExecute() ITK_OVERRIDE { // Get the input VectorData list VectorDataListType* vectorDataList = GetParameterVectorDataList("vd"); // Concatenate filter object m_ConcatenateFilter = ConcatenateFilterType::New(); for (unsigned int idx = 0; idx < vectorDataList->Size(); idx++) { m_ConcatenateFilter->AddInput(vectorDataList->GetNthElement(idx)); } // Set the output SetParameterOutputVectorData("out", m_ConcatenateFilter->GetOutput()); } ConcatenateFilterType::Pointer m_ConcatenateFilter; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::ConcatenateVectorData) OTB-release-5.8/Modules/Applications/AppVectorUtils/app/otbOSMDownloader.cxx000066400000000000000000000157061301006202600270770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactory.h" #include "otbImageToEnvelopeVectorDataFilter.h" #include "otbVectorDataProperties.h" #include "otbOSMDataToVectorDataGenerator.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" namespace otb { namespace Wrapper { class OSMDownloader : public Application { public: /** Standard class typedefs. */ typedef OSMDownloader Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(OSMDownloader, otb::Application); /** Filter typedef */ typedef otb::OSMDataToVectorDataGenerator VectorDataProviderType; private: void DoInit() ITK_OVERRIDE { SetName("OSMDownloader"); SetDescription("Generate a vector data from OSM on the input image extend"); // Documentation SetDocName("Open Street Map layers importations applications"); SetDocLongDescription("Generate a vector data from Open Street Map data. A DEM could be use. By default, the entire layer is downloaded, an image can be use as support for the OSM data. The application can provide also available classes in layers . This application required an Internet access. Information about the OSM project : http://www.openstreetmap.fr/"); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso("Conversion"); AddDocTag(Tags::Meta); AddParameter(ParameterType_OutputVectorData, "out", "Output vector data"); SetParameterDescription("out", "Generated output vector data path"); AddParameter(ParameterType_InputImage, "support", "Support image"); SetParameterDescription("support", "Image used as support to estimate the models"); AddParameter(ParameterType_String, "key", "OSM tag key"); SetParameterDescription("key", "OSM tag key to extract (highway, building...)"); MandatoryOff("key"); AddParameter(ParameterType_String, "value", "OSM tag value"); SetParameterDescription("value", "OSM tag value to extract (motorway, footway...)"); MandatoryOff("value"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); AddParameter(ParameterType_Empty, "printclasses", "option to display available key/value classes"); std::ostringstream oss; oss << "Print the key/value classes available for the bounding box of the input image "<HasValue("printclasses") ) { MandatoryOn("out"); MandatoryOn("key"); } else { MandatoryOff("out"); MandatoryOff("key"); } } void DoExecute() ITK_OVERRIDE { typedef otb::ImageToEnvelopeVectorDataFilter EnvelopeFilterType; typedef otb::VectorDataProperties VectorDataPropertiesType; //Instantiate EnvelopeFilterType::Pointer envelopeFilter = EnvelopeFilterType::New(); VectorDataPropertiesType::Pointer vdProperties = VectorDataPropertiesType::New(); m_VdOSMGenerator = VectorDataProviderType::New(); // Get the support image envelopeFilter->SetInput( this->GetParameterImage("support") ); //->Output in WGS84 // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); envelopeFilter->Update(); vdProperties->SetVectorDataObject(envelopeFilter->GetOutput()); vdProperties->ComputeBoundingRegion(); double north, south, east, west; north = vdProperties->GetBoundingRegion().GetIndex()[1] + vdProperties->GetBoundingRegion().GetSize()[1]; south = vdProperties->GetBoundingRegion().GetIndex()[1]; east = vdProperties->GetBoundingRegion().GetIndex()[0] + vdProperties->GetBoundingRegion().GetSize()[0]; west = vdProperties->GetBoundingRegion().GetIndex()[0]; m_VdOSMGenerator->SetNorth(north); m_VdOSMGenerator->SetSouth(south); m_VdOSMGenerator->SetEast(east); m_VdOSMGenerator->SetWest(west); try { m_VdOSMGenerator->Update(); } catch ( itk::ExceptionObject & err ) { otbAppLogCRITICAL("Exception itk::ExceptionObject raised !"); otbAppLogCRITICAL( << err ); return; } // If the user wants to print the Key/Values present in the XML file // downloaded : if ( this->HasValue("printclasses")) { // Print the classes VectorDataProviderType::KeyMapType keymap = m_VdOSMGenerator->GetKeysMap(); VectorDataProviderType::KeyMapType::iterator it = keymap.begin(); while(it != keymap.end()) { otbAppLogINFO(" Key : "<< (*it).first<< " value : "); std::ostringstream oss; for(unsigned int i = 0; i < (*it).second.size(); i++) { oss.str(); oss << ((*it).second[i]) << " "; } otbAppLogINFO( << oss.str() ); ++it; } return; } // Get the VectorData By name if ( this->HasValue("value") ) { SetParameterOutputVectorData("out", const_cast(m_VdOSMGenerator->GetVectorDataByName(this->GetParameterString("key"), this->GetParameterString("value")))); otbAppLogINFO( << m_VdOSMGenerator->GetVectorDataByName(this->GetParameterString("key"), this->GetParameterString("value"))->Size()-3 << " elements retrieved"); } else { SetParameterOutputVectorData("out", const_cast(m_VdOSMGenerator->GetVectorDataByName(this->GetParameterString("key")))); otbAppLogINFO( << m_VdOSMGenerator->GetVectorDataByName(this->GetParameterString("key"))->Size()-3 << " elements retrieved"); } } VectorDataProviderType::Pointer m_VdOSMGenerator; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::OSMDownloader) OTB-release-5.8/Modules/Applications/AppVectorUtils/app/otbVectorDataExtractROI.cxx000066400000000000000000000132071301006202600303550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbVectorDataExtractROI.h" #include "otbVectorDataProperties.h" //Misc #include "otbRemoteSensingRegion.h" // Elevation handler #include "otbWrapperElevationParametersHandler.h" #include namespace otb { namespace Wrapper { class VectorDataExtractROI : public Application { public: /** Standard class typedefs. */ typedef VectorDataExtractROI Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(VectorDataExtractROI, otb::Application); /** Filters typedef */ // Images typedef FloatVectorImageType::PointType PointType; typedef FloatVectorImageType::IndexType IndexType; typedef FloatVectorImageType::SizeType SizeType; typedef FloatVectorImageType::SpacingType SpacingType; typedef otb::VectorDataExtractROI VectorDataExtractROIType; // Misc typedef otb::RemoteSensingRegion RemoteSensingRegionType; private: void DoInit() ITK_OVERRIDE { SetName("VectorDataExtractROI"); SetDescription("Perform an extract ROI on the input vector data according to the input image extent"); SetDocName("VectorData Extract ROI"); SetDocLongDescription("This application extracts the vector data features" " belonging to a region specified by the support " "image envelope. Any features intersecting the " "support region is copied to output. The output " "geometries are NOT cropped."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Vector); AddParameter(ParameterType_Group,"io","Input and output data"); SetParameterDescription("io", "Group containing input and output parameters"); AddParameter(ParameterType_InputVectorData, "io.vd", "Input Vector data"); SetParameterDescription("io.vd", "Input vector data"); AddParameter(ParameterType_InputImage, "io.in", "Support image"); SetParameterDescription("io.in", "Support image that specifies the extracted region"); AddParameter(ParameterType_OutputVectorData,"io.out","Output Vector data"); SetParameterDescription("io.out", "Output extracted vector data"); // Elevation ElevationParametersHandler::AddElevationParameters(this, "elev"); // Doc example parameter settings SetDocExampleParameterValue("io.in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("io.vd", "qb_RoadExtract_classification.shp"); SetDocExampleParameterValue("io.out", "apTvUtVectorDataExtractROIApplicationTest.shp"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do here for the parameters : all are independent } void DoExecute() ITK_OVERRIDE { // Get the inputs VectorDataType* vd = GetParameterVectorData("io.vd"); FloatVectorImageType* inImage = GetParameterImage("io.in"); // Extracting the VectorData m_VdExtract = VectorDataExtractROIType::New(); m_VdExtract->SetInput(vd); // Find the geographic region of interest // Get the index of the corner of the image itk::ContinuousIndex ul(inImage->GetLargestPossibleRegion().GetIndex()); PointType pul, pur, pll, plr; ul[0] += -0.5; ul[1] += -0.5; itk::ContinuousIndex ur, ll, lr; ur = ul; ll = ul; lr = ul; ur[0] += inImage->GetLargestPossibleRegion().GetSize()[0]; lr[0] += inImage->GetLargestPossibleRegion().GetSize()[0]; lr[1] += inImage->GetLargestPossibleRegion().GetSize()[1]; ll[1] += inImage->GetLargestPossibleRegion().GetSize()[1]; // Transform to physical point inImage->TransformContinuousIndexToPhysicalPoint(ul, pul); inImage->TransformContinuousIndexToPhysicalPoint(ur, pur); inImage->TransformContinuousIndexToPhysicalPoint(ll, pll); inImage->TransformContinuousIndexToPhysicalPoint(lr, plr); // Build the cartographic region RemoteSensingRegionType rsRegion; RemoteSensingRegionType::IndexType rsOrigin; RemoteSensingRegionType::SizeType rsSize; rsOrigin[0] = std::min(pul[0], plr[0]); rsOrigin[1] = std::min(pul[1], plr[1]); rsSize[0] = vcl_abs(pul[0] - plr[0]); rsSize[1] = vcl_abs(pul[1] - plr[1]); rsRegion.SetOrigin(rsOrigin); rsRegion.SetSize(rsSize); rsRegion.SetRegionProjection(inImage->GetProjectionRef()); rsRegion.SetKeywordList(inImage->GetImageKeywordlist()); // Set the cartographic region to the extract roi filter m_VdExtract->SetRegion(rsRegion); // Setup the DEM Handler otb::Wrapper::ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(this,"elev"); // Set the output vectorData SetParameterOutputVectorData("io.out", m_VdExtract->GetOutput()); } VectorDataExtractROIType::Pointer m_VdExtract; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::VectorDataExtractROI) OTB-release-5.8/Modules/Applications/AppVectorUtils/app/otbVectorDataSetField.cxx000066400000000000000000000055761301006202600301020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbVectorData.h" namespace otb { namespace Wrapper { class VectorDataSetField : public Application { public: /** Standard class typedefs. */ typedef VectorDataSetField Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(VectorDataSetField, otb::Application); private: void DoInit() ITK_OVERRIDE { SetName("VectorDataSetField"); SetDescription("Set a field in vector data."); // Documentation SetDocName("Vector data set field"); SetDocLongDescription("Set a specified field to a specified value on all features of a vector data."); SetDocLimitations("Doesn't work with KML files yet"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Vector); AddParameter(ParameterType_InputVectorData, "in", "Input"); SetParameterDescription("in", "Input Vector Data"); AddParameter(ParameterType_OutputVectorData, "out", "Output"); SetParameterDescription("out", "Output Vector Data"); AddParameter(ParameterType_String, "fn", "Field"); SetParameterDescription("fn", "Field name"); AddParameter(ParameterType_String, "fv", "Value"); SetParameterDescription("fv", "Field value"); // Doc example parameter settings SetDocExampleParameterValue("in", "qb_RoadExtract_classification.shp"); SetDocExampleParameterValue("out", "VectorDataSetField.shp"); SetDocExampleParameterValue("fn", "Info"); SetDocExampleParameterValue("fv", "Sample polygon"); } void DoUpdateParameters() ITK_OVERRIDE { // Nothing to do (for now) } void DoExecute() ITK_OVERRIDE { m_InputData = GetParameterVectorData("in"); typedef VectorDataType::DataTreeType DataTreeType; typedef itk::PreOrderTreeIterator TreeIteratorType; TreeIteratorType it(m_InputData->GetDataTree()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { it.Get()->SetFieldAsString(GetParameterAsString("fn"), GetParameterAsString("fv")); } SetParameterOutputVectorData("out", m_InputData); } VectorDataType::Pointer m_InputData; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::VectorDataSetField) OTB-release-5.8/Modules/Applications/AppVectorUtils/app/otbVectorDataTransform.cxx000066400000000000000000000152261301006202600303470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplication.h" #include "otbWrapperApplicationFactory.h" #include "otbVectorDataTransformFilter.h" #include "otbVectorDataProjectionFilter.h" #include "itkCenteredSimilarity2DTransform.h" #include "otbMath.h" namespace otb { namespace Wrapper { class VectorDataTransform : public Application { public: /** Standard class typedefs. */ typedef VectorDataTransform Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(VectorDataTransform, otb::Application); /** Convenient typedefs */ typedef otb::VectorDataTransformFilter VectorDataTransformFilterType; typedef otb::VectorDataProjectionFilter VectorDataProjectionFilterType; typedef itk::CenteredSimilarity2DTransform TransformType; private: void DoInit() ITK_OVERRIDE { SetName("VectorDataTransform"); SetDescription("Apply a transform to each vertex of the input VectorData"); SetDocName("Vector Data Transformation"); SetDocLongDescription("This application performs a transformation of an input vector data transforming each vertex in the vector data. The applied transformation manages translation, rotation and scale, and can be centered or not."); SetDocLimitations("None"); SetDocAuthors("OTB-Team"); SetDocSeeAlso(" "); AddDocTag(Tags::Vector); AddParameter(ParameterType_InputVectorData, "vd", "Input Vector data"); SetParameterDescription("vd", "Input vector data to transform"); AddParameter(ParameterType_OutputVectorData,"out","Output Vector data"); SetParameterDescription("out", "Output transformed vector data"); AddParameter(ParameterType_InputImage, "in", "Support image"); SetParameterDescription("in","Image needed as a support to the vector data"); // Transform Group AddParameter(ParameterType_Group, "transform", "Transform parameters"); SetParameterDescription("transform", "Group of parameters to define the transform"); AddParameter(ParameterType_Float, "transform.tx", "Translation X"); SetParameterDescription("transform.tx","Translation in the X direction (in pixels)"); AddParameter(ParameterType_Float, "transform.ty", "Translation Y"); SetParameterDescription("transform.ty","Translation in the Y direction (in pixels)"); SetDefaultParameterFloat("transform.tx", 0.); SetDefaultParameterFloat("transform.ty", 0.); AddParameter(ParameterType_Float, "transform.ro", "Rotation Angle"); SetParameterDescription("transform.ro","Angle of the rotation to apply in degrees"); SetDefaultParameterFloat("transform.ro", 0.); AddParameter(ParameterType_Float, "transform.centerx", "Center X"); SetParameterDescription("transform.centerx","X coordinate of the rotation center (in physical units)"); AddParameter(ParameterType_Float, "transform.centery", "Center Y"); SetParameterDescription("transform.centery","Y coordinate of the rotation center (in physical units)"); SetDefaultParameterFloat("transform.centerx", 0.); SetDefaultParameterFloat("transform.centery", 0.); AddParameter(ParameterType_Float, "transform.scale", "Scale"); SetParameterDescription("transform.scale","The scale to apply"); SetDefaultParameterFloat("transform.scale", 1.); // Doc example parameter settings SetDocExampleParameterValue("vd", "qb_RoadExtract_easyClassification.shp"); SetDocExampleParameterValue("in", "qb_RoadExtract.tif"); SetDocExampleParameterValue("out", "VectorDataTransform.shp"); SetDocExampleParameterValue("transform.ro", "5"); } void DoUpdateParameters() ITK_OVERRIDE { // nothing to update } void DoExecute() ITK_OVERRIDE { // Get the support image FloatVectorImageType* inImage = GetParameterImage("in"); // Get the VectorData to apply the transform on VectorDataType* vd = GetParameterVectorData("vd"); // Reproject the VectorData in the image coordinate system m_VectorDataProj = VectorDataProjectionFilterType::New(); m_VectorDataProj->SetInput(vd); m_VectorDataProj->SetInputProjectionRef(vd->GetProjectionRef()); m_VectorDataProj->SetOutputKeywordList(inImage->GetImageKeywordlist()); m_VectorDataProj->SetOutputProjectionRef(inImage->GetProjectionRef()); // Set up the transform m_Transform = TransformType::New(); TransformType::ParametersType parameters(6); // Get parameters if any parameters[0] = GetParameterFloat("transform.scale"); parameters[1] = CONST_PI * GetParameterFloat("transform.ro")/180.; parameters[2] = GetParameterFloat("transform.centerx"); parameters[3] = GetParameterFloat("transform.centery"); parameters[4] = inImage->GetSpacing()[0] * GetParameterFloat("transform.tx"); parameters[5] = vcl_abs(inImage->GetSpacing()[1]) * GetParameterFloat("transform.ty"); // Set the parameters to the transform m_Transform->SetParameters(parameters); m_TransformFilter = VectorDataTransformFilterType::New(); m_TransformFilter->SetInput(m_VectorDataProj->GetOutput()); m_TransformFilter->SetTransform(m_Transform); // retransform int the input vector projection m_ReverseVectorDataProj = VectorDataProjectionFilterType::New(); m_ReverseVectorDataProj->SetInput(m_TransformFilter->GetOutput()); m_ReverseVectorDataProj->SetOutputProjectionRef(vd->GetProjectionRef()); m_ReverseVectorDataProj->SetInputKeywordList(inImage->GetImageKeywordlist()); m_ReverseVectorDataProj->SetInputProjectionRef(inImage->GetProjectionRef()); // Set the output image SetParameterOutputVectorData("out", m_ReverseVectorDataProj->GetOutput()); } VectorDataTransformFilterType::Pointer m_TransformFilter; VectorDataProjectionFilterType::Pointer m_VectorDataProj; VectorDataProjectionFilterType::Pointer m_ReverseVectorDataProj; TransformType::Pointer m_Transform; }; } } OTB_APPLICATION_EXPORT(otb::Wrapper::VectorDataTransform) OTB-release-5.8/Modules/Applications/AppVectorUtils/otb-module.cmake000066400000000000000000000005111301006202600254460ustar00rootroot00000000000000set(DOCUMENTATION "VectorUtils application.") otb_module(OTBAppVectorUtils DEPENDS OTBApplicationEngine OTBCarto OTBCommon OTBITK OTBImageBase OTBProjection OTBVectorDataBase OTBVectorDataManipulation TEST_DEPENDS OTBCommandLine OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Applications/AppVectorUtils/test/000077500000000000000000000000001301006202600233575ustar00rootroot00000000000000OTB-release-5.8/Modules/Applications/AppVectorUtils/test/CMakeLists.txt000066400000000000000000000100441301006202600261160ustar00rootroot00000000000000otb_module_test() #----------- VectorDataTransform TESTS ---------------- otb_test_application(NAME apTvUtVectorDataTransform_Rotation APP VectorDataTransform OPTIONS -in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} -vd ${INPUTDATA}/ToulouseRoad-examples.shp -out ${TEMP}/apTvUtVectorDataTransform_rotation.shp -transform.ro 15 VALID --compare-ogr ${NOTOL} ${OTBAPP_BASELINE_FILES}/utTvVectorDataTransformFilter_Rotation.shp ${TEMP}/apTvUtVectorDataTransform_rotation.shp) otb_test_application(NAME apTvUtVectorDataTransform_Translation_Rotation APP VectorDataTransform OPTIONS -in LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} -vd ${INPUTDATA}/ToulouseRoad-examples.shp -out ${TEMP}/apTvUtVectorDataTransform_Translation_rotation.shp -transform.ro 15 -transform.tx 5 -transform.ty 6 VALID --compare-ogr ${NOTOL} ${OTBAPP_BASELINE_FILES}/utTvVectorDataTransformFilter_Translation_rotation.shp ${TEMP}/apTvUtVectorDataTransform_Translation_rotation.shp) #----------- VectorDataExtractROI TESTS ---------------- otb_test_application(NAME apTvUtVectorDataExtractROI APP VectorDataExtractROI OPTIONS -io.in ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif -io.vd LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} -io.out ${TEMP}/apTvUtVectorDataExtractROIApplicationTest.shp VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvUtVectorDataExtractROIApplicationTest.shp ${TEMP}/apTvUtVectorDataExtractROIApplicationTest.shp ) #----------- VectorDataSetField TESTS ---------------- otb_test_application(NAME apTvUtVectorDataSetField APP VectorDataSetField OPTIONS -in ${INPUTDATA}/ToulousePoints-examples.shp -out ${TEMP}/apTvUtVectorDataSetFieldTest.shp -fn MyField -fv MyValue VALID --compare-ogr ${NOTOL} ${BASELINE_FILES}/apTvUtVectorDataSetFieldTest.shp ${TEMP}/apTvUtVectorDataSetFieldTest.shp ) # ----------- OSMDownloader TESTS ---------------- #RK: JIRA-1078: the test is failing on once in every two days. #it doesn't make much sense to keep this test which grabs input from openstreetmap #server. So skipping them below. (2/sep/2016) # otb_test_application(NAME apTvUtOSMDownloader # APP OSMDownloader # OPTIONS -support LARGEINPUT{DEMPSTER-SHAFER/ROI_QB_TOULOUSE.TIF} # -key highway # -out ${TEMP}/apTvUtOSMDownloader.shp # VALID --compare-ogr ${NOTOL} # ${OTBAPP_BASELINE_FILES}/otbOSMDownloaderOutput.shp # ${TEMP}/apTvUtOSMDownloader.shp) #----------- ConcatenateVectorData TESTS ---------------- otb_test_application(NAME apTvUtConcatenateVectorData APP ConcatenateVectorData OPTIONS -vd ${INPUTDATA}/waterways.shp ${INPUTDATA}/france_coastline.shp -out ${TEMP}/apTvUtConcatenateVectorDataOutputTest.shp VALID --compare-ogr ${NOTOL} ${OTBAPP_BASELINE_FILES}/utTvConcatenateVectorData.shp ${TEMP}/apTvUtConcatenateVectorDataOutputTest.shp) OTB-release-5.8/Modules/Core/000077500000000000000000000000001301006202600157165ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/CommandLineParser/000077500000000000000000000000001301006202600212615ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/CommandLineParser/CMakeLists.txt000066400000000000000000000001531301006202600240200ustar00rootroot00000000000000project(OTBCommandLineParser) set(OTBCommandLineParser_LIBRARIES OTBCommandLineParser) otb_module_impl() OTB-release-5.8/Modules/Core/CommandLineParser/include/000077500000000000000000000000001301006202600227045ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/CommandLineParser/include/otbCommandLineArgumentParser.h000066400000000000000000000241611301006202600306340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCommandLineArgumentParser_h #define otbCommandLineArgumentParser_h #include #include #include #include #include "itkProcessObject.h" /** \class CommandLineArgumentParserHelpException * \brief This exception is thrown when the help menu is displayed. * * \ingroup OTBCommandLineParser */ class ITK_EXPORT CommandLineArgumentParserHelpException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(CommandLineArgumentParserHelpException, ExceptionObject); /** Constructor. */ CommandLineArgumentParserHelpException(const char *file, unsigned int line, const char* message = "Help:", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} /** Constructor. */ CommandLineArgumentParserHelpException(const std::string & file, unsigned int line, const char* message = "Help:", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} }; /** \class CommandLineArgumentParserVersionException * \brief This exception is thrown when the version is displayed. * * \ingroup OTBCommandLineParser */ class ITK_EXPORT CommandLineArgumentParserVersionException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(CommandLineArgumentParserVersionException, ExceptionObject); /** Constructor. */ CommandLineArgumentParserVersionException(const char *file, unsigned int line, const char* message = "Version:", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} /** Constructor. */ CommandLineArgumentParserVersionException(const std::string & file, unsigned int line, const char* message = "Version:", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} }; /** \class CommandLineArgumentParserArgumentErrorException * \brief This exception is thrown when the version is displayed. * * \ingroup OTBCommandLineParser */ class ITK_EXPORT CommandLineArgumentParserArgumentErrorException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(CommandLineArgumentParserArgumentErrorException, ExceptionObject); /** Constructor. */ CommandLineArgumentParserArgumentErrorException(const char *file, unsigned int line, const char* message = "Argument error:", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} /** Constructor. */ CommandLineArgumentParserArgumentErrorException(const std::string & file, unsigned int line, const char* message = "Argument error:", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} }; namespace otb { //class CommandLineArgumentParser; /** * \class CommandLineArgumentParseResult * \brief Object returned by CommandLineArgumentParser * * \see CommandLineArgumentParser * * \ingroup OTBCommandLineParser */ class ITK_EXPORT CommandLineArgumentParseResult : public itk::ProcessObject { public: typedef CommandLineArgumentParseResult Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(CommandLineArgumentParseResult, itk::ProcessObject); /** Check whether the option was passed in or not */ bool IsOptionPresent(const std::string& option) const; /** Check whether the input image option was passed in or not */ bool IsOptionInputImagePresent(void) const; /** Check whether the output image option was passed in or not */ bool IsOptionOutputImagePresent(void) const; /** Check whether the OTBTesting option was passed in or not */ bool IsOptionOTBTestingPresent(void) const; /** Get one of the parameters to the option */ // const char *GetOptionParameter(const char *option, unsigned int number = 0); int GetNumberOfParameters(const std::string& option); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; #define otbGetParameterMacro(name, type) \ virtual type GetParameter ## name (const std::string& option, unsigned int number = 0) const \ { \ std::string parameter = this->GetParameterString(option, number); \ type lValeur; \ std::stringstream flux; \ flux << parameter; \ flux >> lValeur; \ return lValeur; \ } otbGetParameterMacro(Char, char); otbGetParameterMacro(Short, short); otbGetParameterMacro(UShort, unsigned short); otbGetParameterMacro(Int, int); otbGetParameterMacro(UInt, unsigned int); otbGetParameterMacro(Long, long); otbGetParameterMacro(ULong, unsigned long); otbGetParameterMacro(Float, float); otbGetParameterMacro(Double, double); std::string GetParameterString(const std::string& option, unsigned int number = 0) const; std::string GetInputImage(void) const; std::string GetOutputImage(void) const; protected: CommandLineArgumentParseResult(); ~CommandLineArgumentParseResult() ITK_OVERRIDE; private: template TypeValeur GetParameter(const std::string& option, unsigned int number = 0) const; typedef std::vector ParameterArrayType; typedef std::map OptionMapType; void Clear(); void AddOption(const std::string & option); void AddParameter(const std::string & option, const std::string & parameter); OptionMapType m_OptionMap; friend class CommandLineArgumentParser; }; /** * \class CommandLineArgumentParser * \brief Utility to Parse command line argument. * * Usage: * - Initialize the parser: * \code * CommandLineArgumentParser parser; * parser.SetProgramDescription("This program is an example"); * parser.AddInputImage(); * parser.AddOption("--DetailedName","Help explanation","-d", 1, false); * \endcode * - Use the parser: * \code * CommandLineArgumentParseResult result; * if( parser.ParseCommandLine(argc, argv, &result) ) * { * if( result.IsOptionPresent("--DetailledName") ) * { * std::cout << "DetailedName : " << result.GetParameterString("--DetailedName") << std::endl; * ... * } * } * \endcode * * \ingroup OTBCommandLineParser */ class ITK_EXPORT CommandLineArgumentParser : public itk::ProcessObject { public: typedef CommandLineArgumentParser Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(CommandLineArgumentParser, itk::ProcessObject); /** Add an input image option */ void AddInputImage(bool obligatory = true); /** Add an output image option */ void AddOutputImage(bool obligatory = true); /** Set the program name */ itkSetStringMacro(ProgramDescription); /** Get the program name */ itkGetStringMacro(ProgramDescription); /** Add a new option with fixed number of parameters */ void AddOption(const std::string& name, const std::string& comment, const std::string& synonym = ITK_NULLPTR, int nParameters = 1, bool obligatory = true); /** Add a new option with unknown number of parameters */ void AddOptionNParams(const std::string& name, const std::string& comment, const std::string& synonym = ITK_NULLPTR, bool obligatory = true); /** Interpret options from the command line */ void ParseCommandLine(int argc, char *argv[], CommandLineArgumentParseResult * outResult, bool failOnUnknownTrailingParameters = true); protected: CommandLineArgumentParser(); ~CommandLineArgumentParser() ITK_OVERRIDE; private: void PrintUsage(std::ostream& os) const; void PrintVersion(std::ostream& os) const; bool FindOption(const std::string&, int& index); bool IsNumber(const std::string& text); /** Try processing a command line. Returns false if something breaks */ bool TryParseCommandLine(int argc, char *argv[], CommandLineArgumentParseResult * outResult, bool reportFailedMsg, bool failOnUnknownTrailingParameters); typedef struct { std::string CommonName; // option name std::string Description; // option description std::string Synonym; // shortcut bool NumberOfParametersFixed; // required number of values int NumberOfParameters; // number of values bool Obligatory; // is the option mandatory ? bool Finded; // check if the option is present } OptionType; typedef std::vector ListOptionType; ListOptionType m_OptionList; std::string m_ProgramName; std::string m_ProgramDescription; }; } #endif // otbCommandLineArgumentParser_h_ OTB-release-5.8/Modules/Core/CommandLineParser/otb-module.cmake000066400000000000000000000002501301006202600243270ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBCommandLineParser DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/CommandLineParser/src/000077500000000000000000000000001301006202600220505ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/CommandLineParser/src/CMakeLists.txt000066400000000000000000000004121301006202600246050ustar00rootroot00000000000000set(OTBCommandLineParser_SRC otbCommandLineArgumentParser.cxx ) add_library(OTBCommandLineParser ${OTBCommandLineParser_SRC}) target_link_libraries(OTBCommandLineParser ${OTBCommon_LIBRARIES} ${OTBITK_LIBRARIES} ) otb_module_target(OTBCommandLineParser) OTB-release-5.8/Modules/Core/CommandLineParser/src/otbCommandLineArgumentParser.cxx000066400000000000000000000277761301006202600303720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbCommandLineArgumentParser.h" #include #include #include "itkMacro.h" #include "otbConfigure.h" // For OTB_VERSION_STRING generated by ccmake namespace otb { // --------- CommandLineArgumentParseResult // --------- ---------------------------------------- CommandLineArgumentParseResult::CommandLineArgumentParseResult() {} CommandLineArgumentParseResult::~CommandLineArgumentParseResult() {} void CommandLineArgumentParseResult ::PrintSelf(std::ostream& itkNotUsed(os), itk::Indent itkNotUsed(indent)) const { } bool CommandLineArgumentParseResult ::IsOptionPresent(const std::string& option) const { return (m_OptionMap.find(option) != m_OptionMap.end()); } bool CommandLineArgumentParseResult ::IsOptionInputImagePresent(void) const { return (this->IsOptionPresent("--InputImage")); } bool CommandLineArgumentParseResult ::IsOptionOutputImagePresent(void) const { return (this->IsOptionPresent("--OutputImage")); } bool CommandLineArgumentParseResult ::IsOptionOTBTestingPresent(void) const { return (this->IsOptionPresent("--OTBTesting")); } std::string CommandLineArgumentParseResult ::GetParameterString(const std::string& option, unsigned int number) const { if (this->IsOptionPresent(option) == false) { std::ostringstream msg; msg << "GetParameterString(): The following '" << option << "' option is unknown !!"; CommandLineArgumentParserArgumentErrorException e(__FILE__, __LINE__); e.SetDescription(msg.str().c_str()); throw e; } OptionMapType::const_iterator it = m_OptionMap.begin(); it = m_OptionMap.find(option); ParameterArrayType pat = (*it).second; std::string lString = pat[number]; return (lString); } std::string CommandLineArgumentParseResult ::GetInputImage(void) const { return (GetParameterString("--InputImage")); } std::string CommandLineArgumentParseResult ::GetOutputImage(void) const { return (GetParameterString("--OutputImage")); } int CommandLineArgumentParseResult ::GetNumberOfParameters(const std::string& option) { assert(IsOptionPresent(option)); return (m_OptionMap[option].size()); } void CommandLineArgumentParseResult ::Clear() { m_OptionMap.clear(); } void CommandLineArgumentParseResult ::AddOption(const std::string& option) { ParameterArrayType pat; // pat.reserve(nParms); m_OptionMap[option] = pat; } void CommandLineArgumentParseResult ::AddParameter(const std::string& option, const std::string& parameter) { m_OptionMap[option].push_back(parameter); } // --------- CommandLineArgumentParser ---------------------------------------- CommandLineArgumentParser ::CommandLineArgumentParser() { AddOption("--help", "Help", "-h", 0, false); AddOption("--version", "Version", "-v", 0, false); AddOptionNParams("--OTBTesting", "Testing purposes only.", "-OTBTesting", false); m_ProgramDescription.clear(); } CommandLineArgumentParser ::~CommandLineArgumentParser() {} void CommandLineArgumentParser ::AddInputImage(bool obligatory) { AddOption("--InputImage", "input image file name ", "-in", 1, obligatory); } void CommandLineArgumentParser ::AddOutputImage(bool obligatory) { AddOption("--OutputImage", "output image file name ", "-out", 1, obligatory); } void CommandLineArgumentParser ::AddOption(const std::string& name, const std::string& comment, const std::string& synonym, int nParameters, bool obligatory) { // Create a structure for the command OptionType option; option.CommonName = name; option.Description = comment; option.Synonym = synonym; option.NumberOfParameters = nParameters; option.NumberOfParametersFixed = true; option.Obligatory = obligatory; option.Finded = false; // Add the option to the map m_OptionList.push_back(option); } void CommandLineArgumentParser ::AddOptionNParams(const std::string& name, const std::string& comment, const std::string& synonym, bool obligatory) { // Create a structure for the command OptionType option; option.CommonName = name; option.Description = comment; option.Synonym = synonym; option.NumberOfParameters = -1; option.NumberOfParametersFixed = false; option.Obligatory = obligatory; option.Finded = false; // Add the option to the map m_OptionList.push_back(option); } void CommandLineArgumentParser ::ParseCommandLine(int argc, char *argv[], CommandLineArgumentParseResult * outResult, bool failOnUnknownTrailingParameters) { bool tryParse = TryParseCommandLine(argc, argv, outResult, false, failOnUnknownTrailingParameters); bool IsHelp = outResult->IsOptionPresent("--help"); if (IsHelp) { PrintUsage(std::cout); CommandLineArgumentParserHelpException e(__FILE__, __LINE__); e.SetDescription("ParseCommandLine(): Help Parser"); throw e; } bool IsVersion = outResult->IsOptionPresent("--version"); if (IsVersion) { PrintVersion(std::cout); CommandLineArgumentParserHelpException e(__FILE__, __LINE__); e.SetDescription("ParseCommandLine(): Version Parser"); throw e; } tryParse = TryParseCommandLine(argc, argv, outResult, true, failOnUnknownTrailingParameters); if (!tryParse) { PrintUsage(std::cerr); CommandLineArgumentParserArgumentErrorException e(__FILE__, __LINE__); e.SetDescription("ParseCommandLine() argument Error"); throw e; } } bool CommandLineArgumentParser::TryParseCommandLine(int argc, char *argv[], CommandLineArgumentParseResult * outResult, bool reportFailedMsg, bool failOnUnknownTrailingParameters) { // Clear the result outResult->Clear(); int i; m_ProgramName = std::string(argv[0]); int index(0); // Go through the arguments for (i = 1; i < argc; ++i) { // Get the next argument std::string arg(argv[i]); // Check if the argument is known bool findOption = FindOption(arg, index); if (findOption == false) { if (failOnUnknownTrailingParameters) { // Unknown argument found if (reportFailedMsg == true) { std::cerr << "The following '" << arg << "' option is unknown !!" << std::endl; } return false; } else return true; } //Check the option m_OptionList[index].Finded = true; // If the number of parameters is predefined if (m_OptionList[index].NumberOfParametersFixed == true) { // Check if the number of parameters is correct int nParameters = m_OptionList[index].NumberOfParameters; if (i + nParameters >= argc) { // Too few parameters if (reportFailedMsg == true) { std::cerr << "Missing one (or more) parameter(s) for the following '" << arg << "' option." << std::endl; } return false; } // Tell the result that the option has been encountered outResult->AddOption(m_OptionList[index].CommonName); // Pass in the parameters for (int j = 0; j < nParameters; ++j, ++i) { outResult->AddParameter(m_OptionList[index].CommonName, std::string(argv[i + 1])); } } // If the number of parameters is not defined, read until the next option or the end of argv else { // Tell the result that the option has been encountered outResult->AddOption(m_OptionList[index].CommonName); bool goOnFlag(true); while (goOnFlag == true) { if (argv[i + 1] != ITK_NULLPTR) { std::string strArgv = std::string(argv[i + 1]); if (strArgv[0] == '-' ) { // Test if the string is an argument or a real if(!this->IsNumber(strArgv)) { goOnFlag = false; } else // If not an argument add it to the option list { outResult->AddParameter(m_OptionList[index].CommonName, strArgv); ++i; } } else { outResult->AddParameter(m_OptionList[index].CommonName, strArgv); ++i; } } else goOnFlag = false; // ++i; } } } // Check that all required arguments are specified for (unsigned int cpt = 0; cpt < m_OptionList.size(); ++cpt) { if ((m_OptionList[cpt].Obligatory == true) && (m_OptionList[cpt].Finded == false)) { // Too few parameters if (reportFailedMsg == true) { std::cerr << "'" << m_OptionList[cpt].CommonName << "' argument is required !!!" << std::endl; } return false; } } // Everything is correct return true; } bool CommandLineArgumentParser::IsNumber(const std::string& text) { if(text.empty()) return false; // Don't test the sign (-) unsigned int i = 1; while (text[i]) { if( text[i] != '.' && text[i] != ',') { if(!isdigit(text[i])) { return false; } } ++i; } return true; } bool CommandLineArgumentParser::FindOption(const std::string& option, int& index) { //Look through the option list bool optionFoundFlag(false); bool goOnFlag(true); unsigned int cpt(0); std::string strOption(option); while (goOnFlag == true) { if ((m_OptionList[cpt].CommonName == strOption) || (m_OptionList[cpt].Synonym == strOption)) { index = cpt; goOnFlag = false; optionFoundFlag = true; } ++cpt; if (cpt >= m_OptionList.size()) { goOnFlag = false; } } return (optionFoundFlag); } void CommandLineArgumentParser::PrintUsage(std::ostream& os) const { os << std::endl; if (!m_ProgramDescription.empty()) { os << m_ProgramDescription << std::endl << std::endl; } os << " Usage : " << m_ProgramName << std::endl; // Compute the max width for option display int largeurmax(-1); unsigned int i; for (i = 0; i < m_OptionList.size(); ++i) { int largeur = m_OptionList[i].CommonName.size() + m_OptionList[i].Synonym.size(); if (largeur > largeurmax) largeurmax = largeur; } // Check that all required arguments are present on the command line for (i = 0; i < m_OptionList.size(); ++i) { if (m_OptionList[i].CommonName != "--OTBTesting") { int largeur = m_OptionList[i].CommonName.size() + m_OptionList[i].Synonym.size(); os << " "; if (m_OptionList[i].Obligatory == false) os << "["; else os << " "; os << m_OptionList[i].CommonName; if (m_OptionList[i].Synonym.empty() == false) { os << "|" << m_OptionList[i].Synonym; } if (m_OptionList[i].Obligatory == false) os << "]"; else os << " "; //Align the text for (int b = largeur; b < largeurmax; b++) os << " "; os << " : " << m_OptionList[i].Description; if (m_OptionList[i].NumberOfParametersFixed == true) { switch (m_OptionList[i].NumberOfParameters) { case 0: break; case 1: os << " (" << m_OptionList[i].NumberOfParameters << " parameter)"; break; default: os << " (" << m_OptionList[i].NumberOfParameters << " parameters)"; break; } } else { os << " (N parameters)"; } os << std::endl; } } os << std::endl; } void CommandLineArgumentParser::PrintVersion(std::ostream& os) const { os << " OTB Version : " << OTB_VERSION_STRING << std::endl; } } OTB-release-5.8/Modules/Core/CommandLineParser/test/000077500000000000000000000000001301006202600222405ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/CommandLineParser/test/CMakeLists.txt000066400000000000000000000051241301006202600250020ustar00rootroot00000000000000otb_module_test() set(OTBCommandLineParserTests otbTestCommandLineArgumentParser.cxx otbTestCommandLineArgumentParserHelp.cxx otbTestCommandLineArgumentParserList.cxx otbTestCommandLineArgumentParserWithError.cxx otbCommandLineParserTestDriver.cxx ) add_executable(otbCommandLineParserTestDriver ${OTBCommandLineParserTests}) target_link_libraries(otbCommandLineParserTestDriver ${OTBCommandLineParser-Test_LIBRARIES}) otb_module_target_label(otbCommandLineParserTestDriver) otb_add_test(NAME coTuCmdLineArgParserDeuxEntiers_ExactNumberArg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParser -image image.png -entier 150 -double 12.25 -deuxentiers 78 56 ) otb_add_test(NAME coTuCmdLineArgParserHelpWithArg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserHelp --help -image image.png) otb_add_test(NAME coTuCmdLineArgParserHelpWithoutArg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserHelp --help) otb_add_test(NAME coTuCmdLineArgParser_List2Arg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserList -image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles 1.0 2.0) otb_add_test(NAME coTuCmdLineArgParser_List2ArgBis COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserList -image image.png -entier 150 -double 12.25 -doubles 1.0 2.0 -deuxentiers 78 56 ) otb_add_test(NAME coTuCmdLineArgParser_EmptyList COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserList -image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles) otb_add_test(NAME coTuCmdLineArgParser_List1Arg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserList -image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles 1.0 2.5) otb_add_test(NAME coTuCmdLineArgParser_List3ArgWithError COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserList -image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles 1.0 2.5 -3.5) otb_add_test(NAME coTuCmdLineArgParserDeuxEntier_LessArg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserWithError -image image.png -entier 150 -double 12.25 -deuxentiers 78 ) otb_add_test(NAME coTuCmdLineArgParser_MissingObligatoryArg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserWithError -entier 150 -double 12.25 -deuxentiers 78 56 32) otb_add_test(NAME coTuCmdLineArgParserDeuxEntier_MoreArg COMMAND otbCommandLineParserTestDriver otbTestCommandLineArgumentParserWithError -image image.png -entier 150 -double 12.25 -deuxentiers 78 56 32) OTB-release-5.8/Modules/Core/CommandLineParser/test/otbCommandLineParserTestDriver.cxx000066400000000000000000000004171301006202600310520ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbTestCommandLineArgumentParser); REGISTER_TEST(otbTestCommandLineArgumentParserHelp); REGISTER_TEST(otbTestCommandLineArgumentParserList); REGISTER_TEST(otbTestCommandLineArgumentParserWithError); } OTB-release-5.8/Modules/Core/CommandLineParser/test/otbTestCommandLineArgumentParser.cxx000066400000000000000000000033561301006202600314060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCommandLineArgumentParser.h" int otbTestCommandLineArgumentParser(int argc, char * argv[]) { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption("-image", "Nom d'une image", "-i", 1, true); parser->AddOption("-entier", "Une Valeur entiere (obligatoire)", "-e"); parser->AddOption("-deuxentiers", "Deux Valeurs entieres non obligatoire", "-dede", 2, false); parser->AddOption("-double", "Valeur reelle double", "-d"); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); parser->ParseCommandLine(argc, argv, parseResult); std::cout << "Image : " << parseResult->GetParameterString("-image") << std::endl; unsigned int lEntier = parseResult->GetParameterUInt("-entier"); std::cout << "Entier : " << lEntier << std::endl; if (parseResult->IsOptionPresent("-deuxentiers")) { std::cout << "Entier : " << lEntier << std::endl; } double lDouble = parseResult->GetParameterDouble("-double"); std::cout << "Double : " << lDouble << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/CommandLineParser/test/otbTestCommandLineArgumentParserHelp.cxx000066400000000000000000000025551301006202600322170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkMacro.h" #include "otbCommandLineArgumentParser.h" // Test de sortie en erreur int otbTestCommandLineArgumentParserHelp(int argc, char * argv[]) { try { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption("-image", "Nom d'une image", "-i", 1, true); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); parser->ParseCommandLine(argc, argv, parseResult); std::cout << "Image : " << parseResult->GetParameterString("-image") << std::endl; } catch (CommandLineArgumentParserHelpException& err) { std::cerr << err; return EXIT_SUCCESS; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Core/CommandLineParser/test/otbTestCommandLineArgumentParserList.cxx000066400000000000000000000050261301006202600322360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCommandLineArgumentParser.h" int otbTestCommandLineArgumentParserList(int argc, char * argv[]) { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption("-image", "Nom d'une image", "-i", 1, true); parser->AddOption("-entier", "Une Valeur entiere (obligatoire)", "-e"); parser->AddOption("-deuxentiers", "Deux Valeurs entieres non obligatoire", "-dede", 2, false); parser->AddOption("-double", "Valeur reelle double", "-d"); parser->AddOptionNParams("-doubles", "Liste de Valeurs reelles", "-ld", false); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); parser->ParseCommandLine(argc, argv, parseResult); std::cout << "Image : " << parseResult->GetParameterString("-image") << std::endl; //unsigned int lEntier = otb::GetParameter(parseResult,"-entier"); unsigned int lEntier = parseResult->GetParameterUInt("-entier"); std::cout << "Entier : " << lEntier << std::endl; if (parseResult->IsOptionPresent("-deuxentiers")) { //unsigned int lEntierDeux = otb::GetParameter(parseResult,"-deuxentiers", 1); unsigned int lEntierDeux = parseResult->GetParameterUInt("-deuxentiers", 1); std::cout << "Entier : " << lEntierDeux << std::endl; } //double lDouble = otb::GetParameter(parseResult,"-double"); double lDouble = parseResult->GetParameterDouble("-double"); std::cout << "Double : " << lDouble << std::endl; std::cout << "List de Double : " << parseResult->GetNumberOfParameters("-doubles") << std::endl; for (int i = 0; i < parseResult->GetNumberOfParameters("-doubles"); ++i) { //double value = otb::GetParameter(parseResult,"-doubles", i); double value = parseResult->GetParameterDouble("-doubles", i); std::cout << " " << value; } std::cout << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/CommandLineParser/test/otbTestCommandLineArgumentParserWithError.cxx000066400000000000000000000044041301006202600332470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkMacro.h" #include "otbCommandLineArgumentParser.h" int otbTestCommandLineArgumentParserWithError(int argc, char * argv[]) { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption("-image", "Nom d'une image", "-i", 1, true); parser->AddOption("-entier", "Une Valeur entiere (obligatoire)", "-e"); parser->AddOption("-deuxentiers", "Deux Valeurs entieres non obligatoire", "-dede", 2, false); parser->AddOption("-double", "Valeur reelle double", "-d"); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); std::cout << "Image : " << parseResult->GetParameterString("-image") << std::endl; //unsigned int lEntier = otb::GetParameter(parseResult,"-entier"); unsigned int lEntier = parseResult->GetParameterUInt("-entier"); std::cout << "Entier : " << lEntier << std::endl; if (parseResult->IsOptionPresent("-deuxentiers")) { //unsigned int lEntierDeux = otb::GetParameter(parseResult,"-deuxentiers", 1); unsigned int lEntierDeux = parseResult->GetParameterUInt("-deuxentiers", 1); std::cout << "Entier : " << lEntierDeux << std::endl; } //double lDouble = otb::GetParameter(parseResult,"-double"); double lDouble = parseResult->GetParameterDouble("-double"); std::cout << "Double : " << lDouble << std::endl; } catch (CommandLineArgumentParserArgumentErrorException& err) { std::cerr << err; return EXIT_SUCCESS; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Core/Common/000077500000000000000000000000001301006202600171465ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Common/CMakeLists.txt000066400000000000000000000013121301006202600217030ustar00rootroot00000000000000project(OTBCommon) configure_file(src/otbConfigure.h.in otbConfigure.h.in) file(APPEND ${OTBCommon_BINARY_DIR}/otbConfigure.h.in "/* Optional third parties activation status */\n") foreach(_otb_module_activation_option IN LISTS OTB_MODULE_ACTIVATION_OPTION_LIST) file(APPEND ${OTBCommon_BINARY_DIR}/otbConfigure.h.in "#cmakedefine ${_otb_module_activation_option}\n") endforeach() configure_file(${OTBCommon_BINARY_DIR}/otbConfigure.h.in otbConfigure.h) set(OTBCommon_INCLUDE_DIRS ${OTBCommon_BINARY_DIR} ) set(OTBCommon_LIBRARIES OTBCommon) otb_module_impl() install(FILES ${OTBCommon_BINARY_DIR}/otbConfigure.h DESTINATION ${OTBCommon_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/Core/Common/include/000077500000000000000000000000001301006202600205715ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Common/include/otbCast.h000066400000000000000000000043611301006202600223450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. *=======================================================================*/ #ifndef __otbCast_h #define __otbCast_h #include "itkSmartPointer.h" namespace otb { /** * \brief dynamic_cast<>() like operator to work with itk::SmartPointer<>. * * Works like C++ dynamic_cast<>() operator: * * DerivedClass::Pointer pointer( * itk::DynamicCast< DerivedClass >( smartPointerToBaseClass ) * ); */ template< typename T2, typename T1 > inline itk::SmartPointer< T2 > DynamicCast( const itk::SmartPointer< T1 > & p1 ) { return typename itk::SmartPointer< T2 >( dynamic_cast< typename itk::SmartPointer< T2 >::ObjectType * >( p1.GetPointer() ) ); } /** * \brief const_cast<>() like operator to work with itk::SmartPointer<>. * * Works like C++ const_cast<>() operator: * * MyClass::Pointer pointer( * itk::ConstCast< DerivedClass >( smartPointerToConstInstance ) * ); */ template< typename T2, typename T1 > inline itk::SmartPointer< const T2 > ConstCast( const itk::SmartPointer< T1 > & p1 ) { return typename itk::SmartPointer< const T2 >( const_cast< typename itk::SmartPointer< const T2 >::ObjectType * >( p1.GetPointer() ) ); } /** * \brief const_cast<>() like operator to work with itk::SmartPointer<>. * * Works like C++ const_cast<>() operator: * * MyClass::ConstPointer constPointer( * itk::ConstCast< const DerivedClass >( * smartPointerToNonConstInstance * ) * ); */ template< typename T2, typename T1 > inline itk::SmartPointer< T2 > ConstCast( const itk::SmartPointer< const T1 > & p1 ) { return typename itk::SmartPointer< T2 >( const_cast< typename itk::SmartPointer< T2 >::ObjectType * >( p1.GetPointer() ) ); } } // end namespace otb. #endif // __otbCast_h OTB-release-5.8/Modules/Core/Common/include/otbChannelSelectorFunctor.h000066400000000000000000000153001301006202600260600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbChannelSelectorFunctor_h #define otbChannelSelectorFunctor_h #include #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkRGBAPixel.h" #include "itkObject.h" #include "itkObjectFactory.h" namespace otb { namespace Function { /** \class ChannelSelectorFunctor * \brief Base class for pixel representation functions. * * \ingroup Visualization * * \sa AmplitudeFunctor PhaseFunctor * * \ingroup OTBCommon */ template class ChannelSelectorFunctor : public itk::Object { public: /** Standard class typedefs */ typedef ChannelSelectorFunctor Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory */ itkNewMacro(Self); /** Runtime information */ itkTypeMacro(ChannelSelectorFunctor, itk::Object); typedef TInputPixel PixelType; typedef typename itk::NumericTraits::ValueType ScalarType; typedef itk::VariableLengthVector VectorPixelType; typedef itk::RGBPixel RGBPixelType; typedef itk::RGBAPixel RGBAPixelType; typedef VectorPixelType OutputPixelType; typedef std::vector ChannelListType; const char *GetDescription() const {return "Channel Selection"; } virtual OutputPixelType operator ()(const VectorPixelType& inPixel) const { // otbMsgDevMacro(<<"Channel list "<< m_ChannelList[0]); OutputPixelType outPixel; outPixel.SetSize(m_ChannelList.size()); for (unsigned int i = 0; i < m_ChannelList.size(); ++i) { // assert as the verification should be done outside and only // once for the image, not for every pixel, when we reach this point // the m_ChannelList MUST be valid assert(m_ChannelList[i] < inPixel.Size()); outPixel[i] = inPixel[m_ChannelList[i]]; } return outPixel; } virtual OutputPixelType operator ()(ScalarType inPixel) const { OutputPixelType outPixel; outPixel.SetSize(1); for (unsigned int i = 0; i < m_ChannelList.size(); ++i) { assert(m_ChannelList[i] < 1); outPixel[0] = inPixel; } return outPixel; } virtual OutputPixelType operator ()(const RGBPixelType& inPixel) const { OutputPixelType outPixel; outPixel.SetSize(m_ChannelList.size()); for (unsigned int i = 0; i < m_ChannelList.size(); ++i) { assert(m_ChannelList[i] < 3); outPixel[i] = inPixel[m_ChannelList[i]]; } return outPixel; } virtual OutputPixelType operator ()(const RGBAPixelType& inPixel) const { OutputPixelType outPixel; outPixel.SetSize(m_ChannelList.size()); for (unsigned int i = 0; i < m_ChannelList.size(); ++i) { assert(m_ChannelList[i] < 4); outPixel[i] = inPixel[m_ChannelList[i]]; } return outPixel; } virtual unsigned int GetOutputSize() const { return m_ChannelList.size(); } virtual std::vector GetChannelList() const { return m_ChannelList; } virtual void SetChannelList(std::vector channels) { m_ChannelList = channels; usingDefaultParameters = false; } virtual void SetChannelIndex(unsigned int channelPosition, unsigned int channel) { if (m_ChannelList.size() < channelPosition + 1) { m_ChannelList.resize(channelPosition + 1, 0); } m_ChannelList[channelPosition] = channel; usingDefaultParameters = false; } virtual unsigned int GetChannelIndex(unsigned int channelPosition) const { if (channelPosition >= m_ChannelList.size()) { itkExceptionMacro( << "Can't get channel " << channelPosition << ", there is only " << m_ChannelList.size() << " element in the list"); } return m_ChannelList[channelPosition]; } /** Only for backward compatibility but should not be used*/ virtual void SetAllChannels(unsigned int channel) { if (m_ChannelList.size() < 3) { m_ChannelList.resize(3, 0); } m_ChannelList[0] = channel; m_ChannelList[1] = channel; m_ChannelList[2] = channel; usingDefaultParameters = false; } virtual void SetRedChannelIndex(unsigned int channel) { if (m_ChannelList.size() < 1) { m_ChannelList.resize(3, 0); } m_ChannelList[0] = channel; usingDefaultParameters = false; } virtual void SetGreenChannelIndex(unsigned int channel) { if (m_ChannelList.size() < 2) { m_ChannelList.resize(3, 0); } m_ChannelList[1] = channel; usingDefaultParameters = false; } virtual void SetBlueChannelIndex(unsigned int channel) { if (m_ChannelList.size() < 3) { m_ChannelList.resize(3, 0); } m_ChannelList[2] = channel; usingDefaultParameters = false; } virtual unsigned int GetRedChannelIndex() const { return m_ChannelList[0]; } virtual unsigned int GetGreenChannelIndex() const { return m_ChannelList[1]; } virtual unsigned int GetBlueChannelIndex() const { return m_ChannelList[2]; } virtual bool IsUsingDefaultParameters() { return usingDefaultParameters; } protected: /** Constructor */ ChannelSelectorFunctor() : usingDefaultParameters(true) { if (std::string(typeid(PixelType).name()).find("RGBAPixel") != std::string::npos) { m_ChannelList.push_back(0); m_ChannelList.push_back(1); m_ChannelList.push_back(2); m_ChannelList.push_back(3); } else if (std::string(typeid(PixelType).name()).find("RGBPixel") != std::string::npos) { m_ChannelList.push_back(0); m_ChannelList.push_back(1); m_ChannelList.push_back(2); } else if (std::string(typeid(PixelType).name()).find("VariableLengthVector") != std::string::npos) { m_ChannelList.push_back(0); } else { m_ChannelList.push_back(0); } } /** Destructor */ ~ChannelSelectorFunctor() ITK_OVERRIDE {} private: ChannelListType m_ChannelList; bool usingDefaultParameters; }; } } #endif OTB-release-5.8/Modules/Core/Common/include/otbCommandProgressUpdate.h000066400000000000000000000026051301006202600257200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCommandProgressUpdate_h #define otbCommandProgressUpdate_h #include "itkCommand.h" #include #include namespace otb { /** * \class CommandProgressUpdate * \brief TODO * * * \ingroup OTBCommon */ template class CommandProgressUpdate : public itk::Command { public: typedef CommandProgressUpdate Self; typedef itk::Command Superclass; typedef itk::SmartPointer Pointer; itkNewMacro(Self); protected: CommandProgressUpdate() {} public: typedef const TFilter * FilterPointer; void Execute(itk::Object *caller, const itk::EventObject& event) ITK_OVERRIDE; void Execute(const itk::Object * object, const itk::EventObject& event) ITK_OVERRIDE; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbCommandProgressUpdate.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbCommandProgressUpdate.txx000066400000000000000000000026001301006202600263070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCommandProgressUpdate_txx #define otbCommandProgressUpdate_txx #include "otbCommandProgressUpdate.h" namespace otb { template void CommandProgressUpdate::Execute(itk::Object *caller, const itk::EventObject& event) { Execute((const itk::Object *) caller, event); } template void CommandProgressUpdate::Execute(const itk::Object * object, const itk::EventObject& event) { FilterPointer filter = dynamic_cast(object); if (typeid(event) != typeid(itk::ProgressEvent)) { return; } int factor = 160; int val = int(filter->GetProgress() * factor); if ((val % 2) == 0) { std::cout << "|"; std::cout.flush(); } if (val == factor) { std::cout << ">"; std::cout.flush(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbComplexToIntensityImageFilter.h000066400000000000000000000061511301006202600274040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbComplexToIntensityImageFilter_h #define otbComplexToIntensityImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "vnl/vnl_math.h" namespace otb { /** \class ComplexToIntensityImageFilter * \brief Computes pixel-wise the intensity of a complex image. * * \sa ComplexToPhaseImageFilter ComplexToModulusImageFilter * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBCommon */ namespace Function { template< class TInput, class TOutput> class ComplexToIntensity { public: ComplexToIntensity() {} ~ComplexToIntensity() {} bool operator!=( const ComplexToIntensity & ) const { return false; } bool operator==( const ComplexToIntensity & other ) const { return !(*this != other); } inline TOutput operator()( const TInput & A ) const { return static_cast( A.real()*A.real() + A.imag()*A.imag() ); } }; } template class ITK_EXPORT ComplexToIntensityImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ComplexToIntensityImageFilter Self; typedef itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, Function::ComplexToIntensity< typename TInputImage::PixelType, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ComplexToIntensityImageFilter, UnaryFunctorImageFilter); typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename itk::NumericTraits< InputPixelType >::ValueType InputPixelValueType; #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(InputConvertibleToOutputCheck, (itk::Concept::Convertible)); /** End concept checking */ #endif protected: ComplexToIntensityImageFilter() {} ~ComplexToIntensityImageFilter() ITK_OVERRIDE {} private: ComplexToIntensityImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbComplexToVectorImageCastFilter.h000066400000000000000000000106001301006202600274650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbComplexToVectorImageCastFilter_h #define otbComplexToVectorImageCastFilter_h #include "itkUnaryFunctorImageFilter.h" #include "vnl/vnl_math.h" #include "itkVariableLengthVector.h" namespace otb { /** \class ComplexToVectorImageCastFilter * \brief Transform a complex image into a 2 channels vector image. * The first channel is the real part, the second the imaginary one. * * * \sa ComplexToImaginaryImageFilter * \sa ComplexToRealImageFilter * * \ingroup OTBCommon */ namespace Functor { template class SingleComplexToVector { public: typedef typename TOutput::ValueType OutputValueType; SingleComplexToVector() {} ~SingleComplexToVector() {} inline TOutput operator()( const TInput & A ) const { TOutput output; output.SetSize( 2 ); output[0] = static_cast(A.real()); output[1] = static_cast(A.imag()); return output; } }; template class VectorComplexToVector { public: typedef typename TOutput::ValueType OutputValueType; typedef typename TInput::ValueType ValueType; typedef itk::VariableLengthVector TestType; VectorComplexToVector() {} ~VectorComplexToVector() {} inline TOutput operator()( const TInput & A ) const { TOutput output; output.SetSize( 2*A.Size() ); for(unsigned int i=0; i(A[i].real()); output[2*i+1] = static_cast(A[i].imag()); } return output; } }; template< class TInput, class TOutput > class ComplexToVector { public: typedef SingleComplexToVector FunctorType; }; template< class TInput, class TOutput > class ComplexToVector, TOutput> { public: typedef VectorComplexToVector, TOutput> FunctorType; }; } template class ITK_EXPORT ComplexToVectorImageCastFilter : public itk::UnaryFunctorImageFilter::FunctorType > { public: /** Standard class typedefs. */ typedef ComplexToVectorImageCastFilter Self; typedef itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, typename Functor::ComplexToVector< typename TInputImage::PixelType, typename TOutputImage::PixelType>::FunctorType > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ComplexToVectorImageCastFilter, itk::UnaryFunctorImageFilter); typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; protected: ComplexToVectorImageCastFilter() {} ~ComplexToVectorImageCastFilter() ITK_OVERRIDE {} template bool PixelIsSingle(const T& /*dummy*/) { return true; } template bool PixelIsSingle(const itk::VariableLengthVector& /*dummy*/) { return false; } void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation(); InputPixelType dummy; if (!this->PixelIsSingle(dummy)) { this->GetOutput()->SetNumberOfComponentsPerPixel(2 * this->GetInput()->GetNumberOfComponentsPerPixel()); } } private: ComplexToVectorImageCastFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbConfigurationManager.h000066400000000000000000000051041301006202600255510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef _otbConfigurationManager_h #define _otbConfigurationManager_h #include "itkVersion.h" #if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 8) #include "itksys/FundamentalType.h" #else #include "itk_kwiml.h" #endif #include #include #include "OTBCommonExport.h" namespace otb { /** * \brief Retrieve configuration values from env var or default values * * This is a simple helper class to retrieve configuration values from * environment variables if they are set, or from default values if * not. * * Please refer to each static method documentation for available * configuration values and related environment variables. */ class OTBCommon_EXPORT ConfigurationManager { public: #if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 8) typedef ::itksysFundamentalType_UInt64 RAMValueType; #else typedef KWIML_INT_uint64_t RAMValueType; #endif /** * DEMDirectory is a directory were DEM tiles are stored. * * If environment variable OTB_DEM_DIRECTORY is defined, * returns it contents as a string * Else, returns an empty string */ static std::string GetDEMDirectory(); /** * GeoidFile is path to a geoid file. * * If environment variable OTB_GEOID_FILE is defined, * returns it contents as a string * Else, returns an empty string */ static std::string GetGeoidFile(); /** * MaxRAMHint denotes the maximum memory OTB should use for * processing, expressed in MegaBytes. * * If environment variable OTB_MAX_RAM_HINT is defined and could be * converted to int, return its content as a 64 bits unsigned int. * Else, returns default value, which is 128 Mb * */ static RAMValueType GetMaxRAMHint(); private: ConfigurationManager(); //purposely not implemented ~ConfigurationManager(); //purposely not implemented ConfigurationManager(const ConfigurationManager&); //purposely not implemented void operator =(const ConfigurationManager&); //purposely not implemented }; } #endif OTB-release-5.8/Modules/Core/Common/include/otbDecimateImageFilter.h000066400000000000000000000073431301006202600253020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecimateImageFilter_h #define otbDecimateImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" namespace otb { /** \class DecimateImageFilter * \brief Performs a down sampling of an image * * This class performs a basic down sampling of an image. On the contrary to * itk::ResampleImageFilter, it does not perform any interpolation. * * \sa ResampleImageFilter * \sa SubsampleImageRegionConstIterator * * \ingroup OTBCommon */ template class ITK_EXPORT DecimateImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef DecimateImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DecimateImageFilter, ImageToImageFilter); /** Extract dimension from input and output image. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Image typedef support. */ typedef TInputImage InputImageType; typedef typename InputImageType::RegionType InputImageRegionType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; /** Set/Get the DecimateFactor */ itkGetMacro(DecimationFactor, unsigned int); itkSetMacro(DecimationFactor, unsigned int); protected: DecimateImageFilter () { m_DecimationFactor = 1; } virtual ~DecimateImageFilter() {} /** Since input and output image are very likely to be of different size. * Region estimation functions has to be reimplemented */ virtual void CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion); virtual void CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion); /** Output image region size is not of the same dimension as the input. * That is why GenerateOutputInformation has to be redefined. */ virtual void GenerateOutputInformation(); /** Allows multithreading */ virtual void ThreadedGenerateData (const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId); virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; private: DecimateImageFilter (const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented unsigned int m_DecimationFactor; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDecimateImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbDecimateImageFilter.txx000066400000000000000000000105021301006202600256650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecimateImageFilter_txx #define otbDecimateImageFilter_txx #include "otbDecimateImageFilter.h" #include "otbMacro.h" #include "otbSubsampledImageRegionConstIterator.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template void DecimateImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "DecimationFactor = " << m_DecimationFactor << "\n"; } template void DecimateImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (GetDecimationFactor() > 1) { this->GetOutput()->CopyInformation(this->GetInput()); OutputImageRegionType newRegion; this->CallCopyInputRegionToOutputRegion(newRegion, this->GetInput()->GetLargestPossibleRegion()); this->GetOutput()->SetRegions(newRegion); for (unsigned int i = 0; i < OutputImageDimension; ++i) { otbGenericMsgDebugMacro(<< "Image Output size [" << i << "] = " << newRegion.GetSize(i)); } } } template void DecimateImageFilter ::CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) { Superclass::CallCopyOutputRegionToInputRegion(destRegion, srcRegion); typename OutputImageRegionType::IndexType srcIndex = srcRegion.GetIndex(); typename OutputImageRegionType::SizeType srcSize = srcRegion.GetSize(); typename InputImageRegionType::IndexType destIndex; typename InputImageRegionType::SizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { destIndex[i] = srcIndex[i] * GetDecimationFactor(); destSize[i] = (srcSize[i] - 1) * GetDecimationFactor() + 1; } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } template void DecimateImageFilter ::CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) { Superclass::CallCopyInputRegionToOutputRegion(destRegion, srcRegion); typename InputImageRegionType::IndexType srcIndex = srcRegion.GetIndex(); typename InputImageRegionType::SizeType srcSize = srcRegion.GetSize(); typename OutputImageRegionType::IndexType destIndex; typename OutputImageRegionType::SizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { destIndex[i] = srcIndex[i] / GetDecimationFactor(); destSize[i] = (srcSize[i] - 1) / GetDecimationFactor() + 1; } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } template void DecimateImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); SubsampledImageRegionConstIterator decimationIterator (this->GetInput(), inputRegionForThread); decimationIterator.SetSubsampleFactor(GetDecimationFactor()); decimationIterator.GoToBegin(); itk::ImageRegionIterator outputIter (this->GetOutput(), outputRegionForThread); outputIter.GoToBegin(); while (!decimationIterator.IsAtEnd() && !outputIter.IsAtEnd()) { outputIter.Set(static_cast(decimationIterator.Get())); ++outputIter; ++decimationIterator; } } } // end of namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbDotProductImageFilter.h000066400000000000000000000071761301006202600256620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDotProductImageFilter_h #define otbDotProductImageFilter_h #include "itkMacro.h" #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class DotProductFunctor * * \brief Computes the dot product against a specific vector * * * \ingroup OTBCommon */ template class DotProductFunctor { public: typedef TInput InputType; typedef TOutput OutputType; DotProductFunctor() {} virtual ~DotProductFunctor() {} bool operator !=(const DotProductFunctor& itkNotUsed(other)) const { return false; } bool operator ==(const DotProductFunctor& other) const { return !(*this != other); } const InputType& GetVector() { return m_Vector; } void SetVector(const InputType& m) { m_Vector = m; } OutputType operator ()(const InputType& in) { OutputType result = 0; for(unsigned int i = 0; i < in.Size(); ++i) { result += in[i] * m_Vector[i]; } return result; } private: InputType m_Vector; }; } /** \class DotProductImageFilter * * \brief Applies pixel-wise dot product to a VectorImage * * Given a vector, this filter outputs the dot product of each pixel of a multiband image * with respect to the specified vector * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBCommon */ template class ITK_EXPORT DotProductImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef DotProductImageFilter Self; typedef itk::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Functor::DotProductFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctorType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DotProductImageFilter, itk::UnaryFunctorImageFilter); /** Pixel types. */ typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; const InputPixelType& GetVector() { return this->GetFunctor().GetVector(); } void SetVector(const InputPixelType& p) { this->GetFunctor().SetVector(p); this->Modified(); } protected: DotProductImageFilter(); ~DotProductImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: DotProductImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDotProductImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbDotProductImageFilter.txx000066400000000000000000000020511301006202600262410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDotProductImageFilter_txx #define otbDotProductImageFilter_txx #include "otbDotProductImageFilter.h" namespace otb { /** * */ template DotProductImageFilter ::DotProductImageFilter() { } template void DotProductImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace #endif OTB-release-5.8/Modules/Core/Common/include/otbFilterWatcherBase.h000066400000000000000000000076761301006202600250250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFilterWatcherBase_h #define otbFilterWatcherBase_h #include "itkCommand.h" #include "itkProcessObject.h" #include "itkTimeProbe.h" #include "OTBCommonExport.h" namespace otb { /** \class FilterWatcherBase * \brief This class is an abstract class * Provides an interface to progress task mechanic * * Implement your callbacks * \li ShowProgress : callback called for each completed pixel * \li StartFilter : callback called at the begin of process * \li EndFilter : callback called at the end of process * * * \ingroup OTBCommon */ class OTBCommon_EXPORT FilterWatcherBase { public: /** Constructor. Takes a ProcessObject to monitor and an optional * comment string that is prepended to each event message. */ FilterWatcherBase(itk::ProcessObject* process, const char *comment = ""); /** Default constructor */ FilterWatcherBase(); /** Copy constructor */ FilterWatcherBase(const FilterWatcherBase&); /** operator= */ void operator =(const FilterWatcherBase&); /** Destructor. */ virtual ~FilterWatcherBase(); const char *GetNameOfClass() { return (m_Process.GetPointer() ? m_Process->GetNameOfClass() : "None"); } /** Methods to access member data */ /** Get a pointer to the process object being watched. */ itk::ProcessObject *GetProcess() { return m_Process.GetPointer(); } /** Get the comment for the watcher. */ std::string GetComment() { return m_Comment; } /** Get a reference to the TimeProbe */ itk::TimeProbe& GetTimeProbe() { return m_TimeProbe; } protected: /** Callback method to show the ProgressEvent */ virtual void ShowProgressCallback() { this->ShowProgress(); } /** Callback method to show the StartEvent */ virtual void StartFilterCallback() { if (!m_Started) { this->StartFilter(); m_Started = true; } } /** Callback method to show the EndEvent */ virtual void EndFilterCallback() { if (!m_Ended) { this->EndFilter(); m_Ended = true; } } /** Callback method to show the ProgressEvent */ virtual void ShowProgress() = 0; /** Callback method to show the StartEvent */ virtual void StartFilter() = 0; /** Callback method to show the EndEvent */ virtual void EndFilter() = 0; /** Computing time */ itk::TimeProbe m_TimeProbe; /** Associated comment */ std::string m_Comment; /** Abstract process object */ itk::ProcessObject::Pointer m_Process; /** Internal type */ typedef itk::SimpleMemberCommand CommandType; /** Start filter callback */ CommandType::Pointer m_StartFilterCommand; /** End filter callback */ CommandType::Pointer m_EndFilterCommand; /** Progress filter callback */ CommandType::Pointer m_ProgressFilterCommand; /** Start oberserver */ unsigned long m_StartTag; /** End observer */ unsigned long m_EndTag; /** Progress observer */ unsigned long m_ProgressTag; /** Some filters (for ex. persistents) invoke the StartEvent several times * Work around this by remembering if it was called or not */ bool m_Started; /** Some filters (for ex. persistents) invoke the EndEvent several times * Work around this by remembering if it was called or not */ bool m_Ended; private: }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbFunctionToImageFilter.h000066400000000000000000000115131301006202600256510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFunctionToImageFilter_h #define otbFunctionToImageFilter_h #include "itkInPlaceImageFilter.h" #include "itkImageFunction.h" #include "itkImageRegionIterator.h" #include "itkSize.h" #include "itkSpatialFunction.h" namespace otb { /** \class FunctionToImageFilter * \brief Evaluates a ImageFunction onto a source image * * The class walks an input image and evaluates * the function at every pixel location. The output of the spatial function * and the pixel type of the output image must be compatible. * * Like its parent ImageToImageFilter, this class functions in the filtering * pipeline and produces a unique output image. * * The function has to inherit from itkImageFunction * * \sa SpatialFunctionImageEvaluatorFilter * \sa SpatialFunctionImageFilter * \sa ImageFunction * \ingroup ImageFilters * * \ingroup OTBCommon */ template class ITK_EXPORT FunctionToImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef FunctionToImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(FunctionToImageFilter, InPlaceImageFilter); /** Some typedefs. */ /** Image size typedef. */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; /** Type of function. */ typedef TFunction FunctionType; typedef typename FunctionType::Pointer FunctionPointer; typedef typename FunctionType::OutputType FunctionValueType; typedef typename FunctionType::InputType FunctionPositionType; /** Set the internal spatial function. */ void SetFunction(FunctionType* PixelFunction) { m_PixelFunction = PixelFunction; this->Modified(); } FunctionType* GetFunction() { return m_PixelFunction; } FunctionType const* GetFunction() const { return m_PixelFunction; } /** Image dimensions */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); protected: FunctionToImageFilter(); ~FunctionToImageFilter() ITK_OVERRIDE {} /** Validate the presence of all three inputs. If one or more inputs * are missing, throw an exception. */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** SpatialFunctionImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: FunctionToImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The function that will be evaluated over the image */ FunctionPointer m_PixelFunction; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFunctionToImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbFunctionToImageFilter.txx000066400000000000000000000062041301006202600262460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFunctionToImageFilter_txx #define otbFunctionToImageFilter_txx #include "otbFunctionToImageFilter.h" #include "itkImageRegionConstIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template FunctionToImageFilter ::FunctionToImageFilter() { this->InPlaceOff(); m_PixelFunction = FunctionType::New(); } /** * Connect one of the operands for pixel-wise addition */ // template // void // FunctionToImageFilter // ::SetInput( const TInputImage *image ) // { // // The ProcessObject is not const-correct so the const_cast is required here // SetNthInput( 0, const_cast( image ) ); // } /** * BeforeThreadedGenerateData function. Validate inputs */ template void FunctionToImageFilter ::BeforeThreadedGenerateData() { InputImagePointer inputPtr = dynamic_cast((itk::ProcessObject::GetInput(0))); if (inputPtr.IsNull()) { itkExceptionMacro(<< "At least one input is missing." << " Input is missing :" << inputPtr.GetPointer(); ) } m_PixelFunction->SetInputImage(inputPtr); } /** * ThreadedGenerateData function. Performs the pixel-wise addition */ template void FunctionToImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // We use dynamic_cast since inputs are stored as DataObjects. InputImagePointer inputPtr = dynamic_cast((itk::ProcessObject::GetInput(0))); OutputImagePointer outputPtr = this->GetOutput(0); itk::ImageRegionConstIterator inputIt(inputPtr, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { outputIt.Set(static_cast(m_PixelFunction->EvaluateAtIndex(inputIt.GetIndex()))); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbImageAndVectorImageOperationFilter.h000066400000000000000000000166541301006202600303050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageAndVectorImageOperationFilter_h #define otbImageAndVectorImageOperationFilter_h #include "itkBinaryFunctorImageFilter.h" #include "itkImageToImageFilter.h" #include "otbMacro.h" namespace otb { namespace Functor { template class ITK_EXPORT ImageAndVectorImageOperationFunctor { public: typedef typename TVectorInput::ValueType InternalInputPixelType; typedef typename TOutput::ValueType InternalOutputPixelType; typedef enum {MULTIPLICATION, ADDITION, DIVISION, SUBTRACTION } OperatorType; ImageAndVectorImageOperationFunctor() { m_Operator = ADDITION; //1; }; virtual ~ImageAndVectorImageOperationFunctor(){} void SetOperator(OperatorType oper) { m_Operator = oper; } OperatorType GetOperator() { return m_Operator; } inline TOutput operator ()(const TInput& inPix, const TVectorInput& vInPix) { TOutput out; out.SetSize(vInPix.Size()); TVectorInput vInTmp = vInPix; switch (m_Operator) { case MULTIPLICATION: { vInTmp *= static_cast(inPix); break; } case ADDITION: { vInTmp += static_cast(inPix); break; } case DIVISION: { if (inPix != 0) vInTmp /= static_cast(inPix); else { vInTmp.Fill(0); } break; } case SUBTRACTION: { vInTmp -= static_cast(inPix); break; } default: { } } for (unsigned int i = 0; i < vInTmp.Size(); ++i) { out[i] = static_cast(vInTmp[i]); } return out; } protected: OperatorType m_Operator; }; } /** \class ImageAndVectorImageOperationFilter * \brief Provides simple pixel to pixel operation between Image and VectorImage. * * Apply an operation (multiplication, division, addition or subtraction) between * the input image and each channel of the vector input image. * Use SetOperation( MULTIPLICATION, ADDITION, DIVISION or SUBTRACTION ) to select the wanted operation. * Default is an addition. * * This class is templated over the input Image and VectorImage and output VectorImage types. * * \sa itkMultiplyImageFilter * \ingroup itkBinaryFunctorImageFilter * * \ingroup OTBCommon */ template class ITK_EXPORT ImageAndVectorImageOperationFilter : public itk::BinaryFunctorImageFilter > //ImageToImageFilter< TVectorInputImage, TOutputImage > { public: /** Standard class typedefs. */ typedef ImageAndVectorImageOperationFilter Self; //typedef itk::ImageToImageFilter Superclass; typedef Functor::ImageAndVectorImageOperationFunctor FunctorType; typedef itk::BinaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageAndVectorImageOperationFilter, itk::BinaryFunctorImageFilter); /** Typedef for the images. */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef TVectorInputImage VectorInputImageType; typedef typename VectorInputImageType::PixelType VectorInputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType OutputPixelType; /** Operation type typedef. */ typedef typename FunctorType::OperatorType OperatorType; /** Set the input images of this process object. */ using Superclass::SetInput; void SetInput(const InputImageType *input) ITK_OVERRIDE; void SetVectorInput(const VectorInputImageType *input); /** Get the input images of this process object. */ const InputImageType * GetInput(); const VectorInputImageType * GetVectorInput(); /** Accessors */ itkGetMacro(UseAddition, bool); itkGetMacro(UseMultiplication, bool); itkGetMacro(UseDivision, bool); itkGetMacro(UseSubtraction, bool); /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ virtual bool GetUseSubstraction() { otbWarningMacro( << "GetUseSubstraction has been deprecated. Please use GetUseSubtraction() instead"); return GetUseSubtraction(); } void UseAddition() { m_UseAddition = true; m_UseMultiplication = false; m_UseDivision = false; m_UseSubtraction = false; this->GetFunctor().SetOperator(static_cast(1)); this->Modified(); } void UseMultiplication() { m_UseAddition = false; m_UseMultiplication = true; m_UseDivision = false; m_UseSubtraction = false; this->GetFunctor().SetOperator(static_cast(0)); this->Modified(); } void UseDivision() { m_UseAddition = false; m_UseMultiplication = false; m_UseDivision = true; m_UseSubtraction = false; this->GetFunctor().SetOperator(static_cast(2)); this->Modified(); } void UseSubtraction() { m_UseAddition = false; m_UseMultiplication = false; m_UseDivision = false; m_UseSubtraction = true; this->GetFunctor().SetOperator(static_cast(3)); this->Modified(); } protected: ImageAndVectorImageOperationFilter(); ~ImageAndVectorImageOperationFilter() ITK_OVERRIDE; /** This is a source, so it must set the spacing, size, and largest possible * region for the output image that it will produce. * \sa ProcessObject::GenerateOutputInformation() */ void GenerateOutputInformation() ITK_OVERRIDE; private: ImageAndVectorImageOperationFilter(const ImageAndVectorImageOperationFilter &); //purposely not implemented void operator =(const ImageAndVectorImageOperationFilter&); //purposely not implemented bool m_UseAddition; bool m_UseMultiplication; bool m_UseDivision; bool m_UseSubtraction; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageAndVectorImageOperationFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImageAndVectorImageOperationFilter.txx000066400000000000000000000060531301006202600306710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageAndVectorImageOperationFilter_txx #define otbImageAndVectorImageOperationFilter_txx #include "otbImageAndVectorImageOperationFilter.h" #include "itkObjectFactory.h" namespace otb { template ImageAndVectorImageOperationFilter ::ImageAndVectorImageOperationFilter() { this->UseAddition(); } template ImageAndVectorImageOperationFilter ::~ImageAndVectorImageOperationFilter() { } template void ImageAndVectorImageOperationFilter ::SetInput(const InputImageType *input) { this->SetNthInput(0, const_cast(input)); } template void ImageAndVectorImageOperationFilter ::SetVectorInput(const VectorInputImageType *input) { this->SetNthInput(1, const_cast(input)); } template const typename ImageAndVectorImageOperationFilter::InputImageType * ImageAndVectorImageOperationFilter ::GetInput() { if (this->GetNumberOfInputs() < 1) return 0; return dynamic_cast(this->GetInput(0)); } template const typename ImageAndVectorImageOperationFilter::VectorInputImageType * ImageAndVectorImageOperationFilter ::GetVectorInput() { if (this->GetNumberOfInputs() < 2) return ITK_NULLPTR; return dynamic_cast(this->itk::ProcessObject::GetInput(1)); } /** * */ template void ImageAndVectorImageOperationFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel(this->GetVectorInput()->GetNumberOfComponentsPerPixel()); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbImageRegionAdaptativeSplitter.h000066400000000000000000000140651301006202600273750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageRegionAdaptativeSplitter_h #define otbImageRegionAdaptativeSplitter_h #include "itkRegion.h" #include "itkImageRegionSplitter.h" #include "itkIndex.h" #include "itkSize.h" #include "itkFastMutexLock.h" namespace otb { /** \class ImageRegionSquareTileSplitter * \brief Divide a region into several pieces. * * This region splitter tries to adapt to the tiling scheme of the * input image using the TileHint parameter. It aims at * synchronizing the streaming with the tiling scheme (in a JPEG * 2000 situation for example) so as to avoid reading the same tile * multiple times in the standard pixel-based processing scheme. * * If the requested number of splits is lower than the number of * tiles in the image region, then the splitter will derive splits * that combine several tiles in one split. If the requested number * of splits is greater than the number of tiles in the image * region, the splitter will derive splits that divide exactly one * tile. All splits from one input tiles will be spawned before * changing to a new tile, ensuring the former tile will be only * read once. * * If the TileHint is empty, or is VImageDimension is not 2, the * splitter falls back to the behaviour of * otb::ImageRegionSquareTileSplitter. * * \sa ImageRegionSquareTileSplitter * * \ingroup ITKSystemObjects * \ingroup DataProcessing * * \ingroup OTBCommon */ template class ITK_EXPORT ImageRegionAdaptativeSplitter : public itk::ImageRegionSplitter { public: /** Standard class typedefs. */ typedef ImageRegionAdaptativeSplitter Self; typedef itk::ImageRegionSplitter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageRegionAdaptativeSplitter, itk::Object); /** Dimension of the image available at compile time. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Dimension of the image available at run time. */ static unsigned int GetImageDimension() { return VImageDimension; } /** Index typedef support. An index is used to access pixel values. */ typedef itk::Index IndexType; typedef typename IndexType::IndexValueType IndexValueType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::Size SizeType; typedef typename SizeType::SizeValueType SizeValueType; /** Region typedef support. */ typedef itk::ImageRegion RegionType; typedef std::vector StreamVectorType; /** Set the TileHint parameter */ itkSetMacro(TileHint, SizeType); /** Get the TileHint parameter */ itkGetConstReferenceMacro(TileHint, SizeType); /** Set the ImageRegion parameter */ itkSetMacro(ImageRegion, RegionType); /** Get the ImageRegion parameter */ itkGetConstReferenceMacro(ImageRegion, RegionType); /** Set the requested number of splits parameter */ itkSetMacro(RequestedNumberOfSplits, unsigned int); /** Get the requested number of splits parameter */ itkGetConstReferenceMacro(RequestedNumberOfSplits, unsigned int); /** * Calling this method will set the image region and the requested * number of splits, and call the EstimateSplitMap() method if * necessary. */ unsigned int GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) ITK_OVERRIDE; /** Calling this method will set the image region and the requested * number of splits, and call the EstimateSplitMap() method if * necessary. */ RegionType GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region) ITK_OVERRIDE; /** Make the Modified() method update the IsUpToDate flag */ void Modified() const ITK_OVERRIDE { // Call superclass implementation Superclass::Modified(); // Invalidate up-to-date m_IsUpToDate = false; } protected: ImageRegionAdaptativeSplitter() : m_TileHint(), m_ImageRegion(), m_RequestedNumberOfSplits(0), m_StreamVector(), m_IsUpToDate(false) {} ~ImageRegionAdaptativeSplitter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** This methods actually estimate the split map and stores it in a vector */ void EstimateSplitMap(); ImageRegionAdaptativeSplitter(const ImageRegionAdaptativeSplitter &); //purposely not implemented void operator =(const ImageRegionAdaptativeSplitter&); //purposely not implemented // This reflects the input image tiling SizeType m_TileHint; // This contains the ImageRegion that is currently being split RegionType m_ImageRegion; // This contains the requested number of splits unsigned int m_RequestedNumberOfSplits; // This is a vector of all regions which will be split StreamVectorType m_StreamVector; // Is the splitter up-to-date ? mutable bool m_IsUpToDate; // Lock to ensure thread-safety itk::SimpleFastMutexLock m_Lock; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbImageRegionAdaptativeSplitter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImageRegionAdaptativeSplitter.txx000066400000000000000000000201621301006202600277640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageRegionAdaptativeSplitter_txx #define otbImageRegionAdaptativeSplitter_txx #include "otbImageRegionAdaptativeSplitter.h" #include "otbMath.h" #include "otbMacro.h" // Defaut when no tile hint available #include "otbImageRegionSquareTileSplitter.h" namespace otb { template unsigned int ImageRegionAdaptativeSplitter ::GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) { // Set parameters this->SetImageRegion(region); this->SetRequestedNumberOfSplits(requestedNumber); // Check if we need to compute split map agagin m_Lock.Lock(); if(!m_IsUpToDate) { // Do so if we need to this->EstimateSplitMap(); } m_Lock.Unlock(); // Return the size of the split map return m_StreamVector.size(); } template itk::ImageRegion ImageRegionAdaptativeSplitter ::GetSplit(unsigned int i, unsigned int itkNotUsed(numberOfPieces), const RegionType& region) { // Set parameters this->SetImageRegion(region); // Check if we need to compute split map agagin m_Lock.Lock(); if(!m_IsUpToDate) { // Do so if we need to this->EstimateSplitMap(); } m_Lock.Unlock(); // Return the requested split return m_StreamVector.at(i); } template void ImageRegionAdaptativeSplitter ::EstimateSplitMap() { // Clear previous split map m_StreamVector.clear(); // Handle trivial case if(m_RequestedNumberOfSplits == 1 || m_RequestedNumberOfSplits == 0) { m_StreamVector.push_back(m_ImageRegion); m_IsUpToDate = true; return; } // Handle the empty hint case and the case where VImageDimension != 2 if(m_TileHint[0] == 0 || m_TileHint[1] == 0 || VImageDimension != 2) { // In this case we fallback to the classical tile splitter typename otb::ImageRegionSquareTileSplitter::Pointer splitter = otb::ImageRegionSquareTileSplitter::New(); // Retrieve nb splits unsigned int nbSplits = splitter->GetNumberOfSplits(m_ImageRegion, m_RequestedNumberOfSplits); for(unsigned int i = 0; iGetSplit(i, m_RequestedNumberOfSplits, m_ImageRegion)); } m_IsUpToDate = true; return; } // Now we can handle the case where we have a tile hint and a // non-trivial requested number of splits SizeType tilesPerDim, splitsPerDim; IndexType firstTileCovered; // First, we need to get which tiles are covered by ROI firstTileCovered[0] = m_ImageRegion.GetIndex()[0] / m_TileHint[0]; firstTileCovered[1] = m_ImageRegion.GetIndex()[1] / m_TileHint[1]; tilesPerDim[0] = (m_ImageRegion.GetIndex()[0] + m_ImageRegion.GetSize()[0] + m_TileHint[0] -1) / m_TileHint[0] - firstTileCovered[0]; tilesPerDim[1] = (m_ImageRegion.GetIndex()[1] + m_ImageRegion.GetSize()[1] + m_TileHint[1] -1) / m_TileHint[1] - firstTileCovered[1]; unsigned int totalTiles = tilesPerDim[0] * tilesPerDim[1]; // In this case, we have to group input tiles if(totalTiles >= m_RequestedNumberOfSplits) { // Try to group splits SizeType groupTiles; groupTiles.Fill(1); unsigned int i=0; // TODO: this should not fall in infinite loop, but add more // security just in case. while(totalTiles / (groupTiles[0] * groupTiles[1]) > m_RequestedNumberOfSplits) { if(groupTiles[i] < tilesPerDim[i]) { groupTiles[i]++; } // TODO: We can be more generic here i = (i+1)%2; } splitsPerDim[0] = tilesPerDim[0] / groupTiles[0]; splitsPerDim[1] = tilesPerDim[1] / groupTiles[1]; // Handle the last small tile if any if(tilesPerDim[0] % groupTiles[0] > 0) splitsPerDim[0]++; if(tilesPerDim[1] % groupTiles[1] > 0) splitsPerDim[1]++; // Fill the tiling scheme for(unsigned int splity = 0; splity < splitsPerDim[1]; ++splity) { for(unsigned int splitx = 0; splitx < splitsPerDim[0]; ++splitx) { // Build the split RegionType newSplit; SizeType newSplitSize; IndexType newSplitIndex; newSplitSize[0] = groupTiles[0] * m_TileHint[0]; newSplitSize[1] = groupTiles[1] * m_TileHint[1]; newSplitIndex[0] = firstTileCovered[0] * m_TileHint[0] + splitx * newSplitSize[0]; newSplitIndex[1] = firstTileCovered[1] * m_TileHint[1] + splity * newSplitSize[1]; newSplit.SetIndex(newSplitIndex); newSplit.SetSize(newSplitSize); bool cropped = newSplit.Crop(m_ImageRegion); // If newSplit could not be cropped, it means that it is // outside m_ImageRegion. In this case we ignore it. if(cropped) { m_StreamVector.push_back(newSplit); } } } } // In this case, we must divide each tile else { SizeType divideTiles; divideTiles.Fill(1); unsigned int i = 1; // Exit condition if divideTiles=m_TileHint (i.e. no more subdivision available) while(totalTiles * (divideTiles[0] * divideTiles[1]) < m_RequestedNumberOfSplits && (divideTiles[0] < m_TileHint[0] || divideTiles[1] < m_TileHint[1])) { if(divideTiles[i] < m_TileHint[i]) { divideTiles[i]++; } // TODO: We can be more generic here i = (i+1)%2; } SizeType splitSize; splitSize[0] = (m_TileHint[0] + divideTiles[0] - 1)/ divideTiles[0]; splitSize[1] = (m_TileHint[1] + divideTiles[1] - 1)/ divideTiles[1]; RegionType tileHintRegion; tileHintRegion.SetSize(m_TileHint); // Fill the tiling scheme for(unsigned int tiley = 0; tiley < tilesPerDim[1]; ++tiley) { for(unsigned int tilex = 0; tilex < tilesPerDim[0]; ++tilex) { for(unsigned int divy = 0; divy < divideTiles[1]; ++divy) { for(unsigned int divx = 0; divx < divideTiles[0]; ++divx) { // Build the split RegionType newSplit; IndexType newSplitIndex; newSplitIndex[0] = (tilex + firstTileCovered[0]) * m_TileHint[0] + divx * splitSize[0]; newSplitIndex[1] = (tiley + firstTileCovered[1]) * m_TileHint[1] + divy * splitSize[1]; newSplit.SetIndex(newSplitIndex); newSplit.SetSize(splitSize); tileHintRegion.SetIndex(0, tilex * m_TileHint[0]); tileHintRegion.SetIndex(1, tiley * m_TileHint[1]); bool cropped = newSplit.Crop(m_ImageRegion); // If newSplit could not be cropped, it means that it is // outside m_ImageRegion. In this case we ignore it. if(cropped) { // check that the split stays inside its tile cropped = newSplit.Crop(tileHintRegion); if (cropped) { m_StreamVector.push_back(newSplit); } } } } } } } // Finally toggle the up-to-date flag m_IsUpToDate = true; return; } /** * */ template void ImageRegionAdaptativeSplitter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os< class ITK_EXPORT ImageRegionNonUniformMultidimensionalSplitter : public itk::ImageRegionSplitter { public: /** Standard class typedefs. */ typedef ImageRegionNonUniformMultidimensionalSplitter Self; typedef itk::ImageRegionSplitter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageRegionNonUniformMultidimensionalSplitter, ImageRegionSplitter); /** Dimension of the image available at compile time. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Index typedef support. An index is used to access pixel values. */ typedef itk::Index IndexType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::Size SizeType; /** Region typedef support. */ typedef itk::ImageRegion RegionType; /** How many pieces can the specified region be split? A given region * cannot always be divided into the requested number of pieces. For * instance, if the numberOfPieces exceeds the number of pixels along * a certain dimensions, then some splits will not be possible. This * method returns a number less than or equal to the requested number * of pieces. */ unsigned int GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) ITK_OVERRIDE; /** Get a region definition that represents the ith piece a specified region. * The "numberOfPieces" specified should be less than or equal to what * GetNumberOfSplits() returns. */ RegionType GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region) ITK_OVERRIDE; protected: ImageRegionNonUniformMultidimensionalSplitter() {} ~ImageRegionNonUniformMultidimensionalSplitter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageRegionNonUniformMultidimensionalSplitter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb // Define instantiation macro for this template. #define ITK_TEMPLATE_ImageRegionNonUniformMultidimensionalSplitter(_, EXPORT, x, y) namespace otb { \ _(1 (class EXPORT ImageRegionNonUniformMultidimensionalSplitter)) \ namespace Templates { typedef ImageRegionNonUniformMultidimensionalSplitter \ ImageRegionNonUniformMultidimensionalSplitter ## y; } \ } #if ITK_TEMPLATE_EXPLICIT # include "Templates/otbImageRegionNonUniformMultidimensionalSplitter+-.h" #endif #ifndef ITK_MANUAL_INSTANTIATION # include "otbImageRegionNonUniformMultidimensionalSplitter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImageRegionNonUniformMultidimensionalSplitter.txx000066400000000000000000000121671301006202600332400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageRegionNonUniformMultidimensionalSplitter_txx #define otbImageRegionNonUniformMultidimensionalSplitter_txx #include "otbImageRegionNonUniformMultidimensionalSplitter.h" namespace otb { /** * */ template unsigned int ImageRegionNonUniformMultidimensionalSplitter ::GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) { const SizeType& regionSize = region.GetSize(); // requested number of splits per dimension double splitsPerDimension[VImageDimension]; // ::ceil( vcl_pow((double) requestedNumber, 1.0/(double) VImageDimension)); unsigned int numberOfPiecesLeft = requestedNumber; unsigned int j, numPieces; numPieces = 1; for (j = VImageDimension; j > 0; --j) { if (regionSize[j - 1] < numberOfPiecesLeft) { splitsPerDimension[j - 1] = regionSize[j - 1]; } else { splitsPerDimension[j - 1] = numberOfPiecesLeft; } numberOfPiecesLeft = (unsigned int) ::ceil(numberOfPiecesLeft / splitsPerDimension[j - 1]); numPieces *= (unsigned int) splitsPerDimension[j - 1]; } // if a given dimension has fewer pixels that splitsPerDimension, then // only split number of pixels times // unsigned int i, numPieces; // numPieces = 1; // for (i=0; i < VImageDimension; ++i) // { // if (regionSize[i] < splitsPerDimension) // { // numPieces *= regionSize[i]; // } // else // { // numPieces *= (unsigned int) splitsPerDimension; // } // } return numPieces; } /** * */ template itk::ImageRegion ImageRegionNonUniformMultidimensionalSplitter ::GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region) { RegionType splitRegion; IndexType splitIndex; SizeType splitSize, regionSize; // Initialize the splitRegion to the requested region splitRegion = region; splitIndex = splitRegion.GetIndex(); splitSize = splitRegion.GetSize(); regionSize = region.GetSize(); // requested number of splits per dimension double splitsPerDimension[VImageDimension]; // ::ceil( vcl_pow((double) numberOfPieces, 1.0/(double) VImageDimension)); unsigned int numberOfPiecesLeft = numberOfPieces; unsigned int j; for (j = VImageDimension; j > 0; --j) { if (regionSize[j - 1] < numberOfPiecesLeft) { splitsPerDimension[j - 1] = regionSize[j - 1]; } else { splitsPerDimension[j - 1] = numberOfPiecesLeft; } numberOfPiecesLeft = (unsigned int) ::ceil(numberOfPiecesLeft / splitsPerDimension[j - 1]); } // if a given dimension has fewer pixels that splitsPerDimension, then // only split number of pixels times unsigned int splits[VImageDimension], pixelsPerSplit[VImageDimension]; unsigned int numPieces; unsigned int ijk[VImageDimension]; unsigned int offsetTable[VImageDimension]; numPieces = 1; for (j = 0; j < VImageDimension; ++j) { offsetTable[j] = numPieces; if (regionSize[j] < splitsPerDimension[j]) { splits[j] = regionSize[j]; pixelsPerSplit[j] = 1; numPieces *= regionSize[j]; } else { splits[j] = (unsigned int) splitsPerDimension[j]; pixelsPerSplit[j] = (unsigned int) ::ceil(regionSize[j] / (double) splits[j]); numPieces *= (unsigned int) splitsPerDimension[j]; } } // determine which split we are in unsigned int offset = i; for (j = VImageDimension - 1; j > 0; j--) { ijk[j] = offset / offsetTable[j]; offset -= (ijk[j] * offsetTable[j]); } ijk[0] = offset; // compute the split for (j = 0; j < VImageDimension; ++j) { splitIndex[j] += ijk[j] * pixelsPerSplit[j]; if (ijk[j] < splits[j] - 1) { splitSize[j] = pixelsPerSplit[j]; } else { // this dimension is falling off the edge of the image splitSize[j] = splitSize[j] - ijk[j] * pixelsPerSplit[j]; } } // set the split region ivars splitRegion.SetIndex(splitIndex); splitRegion.SetSize(splitSize); itkDebugMacro(" Split Piece: " << std::endl << splitRegion); return splitRegion; } /** * */ template void ImageRegionNonUniformMultidimensionalSplitter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbImageRegionSquareTileSplitter.h000066400000000000000000000130151301006202600273630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageRegionSquareTileSplitter_h #define otbImageRegionSquareTileSplitter_h #include "itkRegion.h" #include "itkImageRegionSplitter.h" #include "itkObjectFactory.h" #include "itkIndex.h" #include "itkSize.h" namespace otb { /** \class ImageRegionSquareTileSplitter * \brief Divide a region into several pieces. * * ImageRegionSquareTileSplitter divides an ImageRegion into smaller regions. * ImageRegionSquareTileSplitter is used by the StreamingImageFilter to divide a * requested output region into a series of smaller requests of the * pipeline. This object has two basic methods: GetNumberOfSplits() * and GetSplit(). * * GetNumberOfSplits() is used to determine how may subregions a given * region can be divided. You call GetNumberOfSplits with an argument * that is the number of subregions you want. If the image region can * support that number of subregions, that number is returned. * Otherwise, the maximum number of splits a region can support will * be returned. For example, if a region splitter class only divides * a region into horizontal slabs, then the maximum number of splits * will be the number of rows in the region. * * GetSplit() returns the ith of N subregions (as an ImageRegion object). * * This ImageRegionSquareTileSplitter class divides a region along the outermost * dimension. If the outermost dimension has size 1 (i.e. a volume * with a single slice), the ImageRegionSquareTileSplitter will divide the * region along the next outermost dimension. If that dimension has size 1, * the process continues with the next outermost dimension. * * Regions obtained by the ImageRegionSquareTileSplitter are aligned on a grid * with width of 256. Divisions can occur only at line defined as k*256. * * Other ImageRegionSquareTileSplitter subclasses could divide an image into * more uniform shaped regions instead of slabs. * * \sa ImageRegionMultidimensionalSplitter * * \ingroup ITKSystemObjects * \ingroup DataProcessing * * \ingroup OTBCommon */ template class ITK_EXPORT ImageRegionSquareTileSplitter : public itk::ImageRegionSplitter { public: /** Standard class typedefs. */ typedef ImageRegionSquareTileSplitter Self; typedef itk::ImageRegionSplitter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageRegionSquareTileSplitter, itk::Object); /** Dimension of the image available at compile time. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Dimension of the image available at run time. */ static unsigned int GetImageDimension() { return VImageDimension; } /** Index typedef support. An index is used to access pixel values. */ typedef itk::Index IndexType; typedef typename IndexType::IndexValueType IndexValueType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::Size SizeType; typedef typename SizeType::SizeValueType SizeValueType; /** Region typedef support. */ typedef itk::ImageRegion RegionType; /** How many pieces can the specified region be split? A given region * cannot always be divided into the requested number of pieces. For * instance, if the numberOfPieces exceeds the number of pixels along * a certain dimensions, then some splits will not be possible. */ unsigned int GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) ITK_OVERRIDE; /** Get a region definition that represents the ith piece a specified region. * The "numberOfPieces" specified should be less than or equal to what * GetNumberOfSplits() returns. */ RegionType GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region) ITK_OVERRIDE; itkGetMacro(TileSizeAlignment, unsigned int); itkSetMacro(TileSizeAlignment, unsigned int); itkGetMacro(TileDimension, unsigned int); protected: ImageRegionSquareTileSplitter() : m_SplitsPerDimension(0U), m_TileDimension(0), m_TileSizeAlignment(16) {} ~ImageRegionSquareTileSplitter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageRegionSquareTileSplitter(const ImageRegionSquareTileSplitter &); //purposely not implemented void operator =(const ImageRegionSquareTileSplitter&); //purposely not implemented itk::FixedArray m_SplitsPerDimension; unsigned int m_TileDimension; unsigned int m_TileSizeAlignment; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbImageRegionSquareTileSplitter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImageRegionSquareTileSplitter.txx000066400000000000000000000074441301006202600277700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageRegionSquareTileSplitter_txx #define otbImageRegionSquareTileSplitter_txx #include "otbImageRegionSquareTileSplitter.h" #include "otbMath.h" #include "otbMacro.h" namespace otb { template unsigned int ImageRegionSquareTileSplitter ::GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) { unsigned int theoricalNbPixelPerTile = region.GetNumberOfPixels() / requestedNumber; unsigned int theoricalTileDimension = static_cast (vcl_sqrt(static_cast(theoricalNbPixelPerTile)) ); // Take the next multiple of m_TileSizeAlignment (eventually generate more splits than requested) m_TileDimension = (theoricalTileDimension + m_TileSizeAlignment - 1) / m_TileSizeAlignment * m_TileSizeAlignment; // Minimal tile size is m_TileSizeAlignment * m_TileSizeAlignment if (m_TileDimension < m_TileSizeAlignment) { otbMsgDevMacro(<< "Warning: clamping tile size to " << m_TileSizeAlignment << " * " << m_TileSizeAlignment); m_TileDimension = m_TileSizeAlignment; } unsigned int numPieces = 1; const SizeType& regionSize = region.GetSize(); for (unsigned int j = 0; j < VImageDimension; ++j) { m_SplitsPerDimension[j] = (regionSize[j] + m_TileDimension - 1) / m_TileDimension; numPieces *= m_SplitsPerDimension[j]; } otbMsgDevMacro(<< "Tile dimension : " << m_TileDimension) otbMsgDevMacro(<< "Number of splits per dimension : " << m_SplitsPerDimension[0] << " " << m_SplitsPerDimension[1]) return numPieces; } template itk::ImageRegion ImageRegionSquareTileSplitter ::GetSplit(unsigned int i, unsigned int itkNotUsed(numberOfPieces), const RegionType& region) { RegionType splitRegion; IndexType splitIndex; // Compute the actual number of splits unsigned int numPieces = 1; for (unsigned int j = 0; j < VImageDimension; ++j) { numPieces *= m_SplitsPerDimension[j]; } // Sanity check if (i >= numPieces) { itkExceptionMacro("Asked for split number " << i << " but region contains only " << numPieces << " splits"); } // Compute the split index in the streaming grid unsigned int remaining = i; for (unsigned int j = VImageDimension - 1; j > 0; --j) { splitIndex[j] = remaining / m_SplitsPerDimension[VImageDimension - 1 - j]; remaining = remaining % m_SplitsPerDimension[VImageDimension - 1 - j]; } splitIndex[0] = remaining; // Transform the split index to the actual coordinates for (unsigned int j = 0; j < VImageDimension; ++j) { splitRegion.SetIndex(j, region.GetIndex(j) + m_TileDimension * splitIndex[j]); splitRegion.SetSize(j, m_TileDimension); } // Handle the borders splitRegion.Crop(region); return splitRegion; } /** * */ template void ImageRegionSquareTileSplitter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "SplitsPerDimension : " << m_SplitsPerDimension << std::endl; os << indent << "TileDimension : " << m_TileDimension << std::endl; os << indent << "TileSizeAlignment : " << m_TileSizeAlignment << std::endl; } } // end namespace itk #endif OTB-release-5.8/Modules/Core/Common/include/otbImageRegionTileMapSplitter.h000066400000000000000000000125051301006202600266430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageRegionTileMapSplitter_h #define otbImageRegionTileMapSplitter_h #include "itkRegion.h" #include "itkImageRegionSplitter.h" #include "itkObjectFactory.h" #include "itkIndex.h" #include "itkSize.h" namespace otb { /** \class ImageRegionTileMapSplitter * \brief Divide a region into several pieces. * * ImageRegionTileMapSplitter divides an ImageRegion into smaller regions. * ImageRegionTileMapSplitter is used by the StreamingImageFilter to divide a * requested output region into a series of smaller requests of the * pipeline. This object has two basic methods: GetNumberOfSplits() * and GetSplit(). * * GetNumberOfSplits() is used to determine how may subregions a given * region can be divided. You call GetNumberOfSplits with an argument * that is the number of subregions you want. If the image region can * support that number of subregions, that number is returned. * Otherwise, the maximum number of splits a region can support will * be returned. For example, if a region splitter class only divides * a region into horizontal slabs, then the maximum number of splits * will be the number of rows in the region. * * GetSplit() returns the ith of N subregions (as an ImageRegion object). * * This ImageRegionTileMapSplitter class divides a region along the outermost * dimension. If the outermost dimension has size 1 (i.e. a volume * with a single slice), the ImageRegionTileMapSplitter will divide the * region along the next outermost dimension. If that dimension has size 1, * the process continues with the next outermost dimension. * * Regions obtained by the ImageRegionTileMapSplitter are aligned on a grid * with width of 256. Divisions can occur only at line defined as k*256. * * Other ImageRegionTileMapSplitter subclasses could divide an image into * more uniform shaped regions instead of slabs. * * \sa ImageRegionMultidimensionalSplitter * * \ingroup ITKSystemObjects * \ingroup DataProcessing * * \ingroup OTBCommon */ template class ITK_EXPORT ImageRegionTileMapSplitter : public itk::ImageRegionSplitter { public: /** Standard class typedefs. */ typedef ImageRegionTileMapSplitter Self; typedef itk::ImageRegionSplitter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageRegionTileMapSplitter, itk::Object); /** Dimension of the image available at compile time. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Dimension of the image available at run time. */ static unsigned int GetImageDimension() { return VImageDimension; } /** Index typedef support. An index is used to access pixel values. */ typedef itk::Index IndexType; typedef typename IndexType::IndexValueType IndexValueType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::Size SizeType; typedef typename SizeType::SizeValueType SizeValueType; /** Region typedef support. */ typedef itk::ImageRegion RegionType; /** How many pieces can the specified region be split? A given region * cannot always be divided into the requested number of pieces. For * instance, if the numberOfPieces exceeds the number of pixels along * a certain dimensions, then some splits will not be possible. This * method returns a number less than or equal to the requested number * of pieces. */ unsigned int GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) ITK_OVERRIDE; /** Get a region definition that represents the ith piece a specified region. * The "numberOfPieces" specified should be less than or equal to what * GetNumberOfSplits() returns. */ RegionType GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region) ITK_OVERRIDE; protected: ImageRegionTileMapSplitter() : m_AlignStep(256){} ~ImageRegionTileMapSplitter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageRegionTileMapSplitter(const ImageRegionTileMapSplitter &); //purposely not implemented void operator =(const ImageRegionTileMapSplitter&); //purposely not implemented unsigned int m_SplitsPerDimension[VImageDimension]; unsigned int m_AlignStep; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbImageRegionTileMapSplitter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImageRegionTileMapSplitter.txx000066400000000000000000000107211301006202600272350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageRegionTileMapSplitter_txx #define otbImageRegionTileMapSplitter_txx #include "otbImageRegionTileMapSplitter.h" #include "otbMath.h" #include "otbMacro.h" namespace otb { /** * */ template unsigned int ImageRegionTileMapSplitter ::GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) { const SizeType& regionSize = region.GetSize(); const IndexType& regionIndex = region.GetIndex(); // requested number of splits per dimension unsigned int numPieces = 1; // determine the actual number of pieces that will be generated for (unsigned int j = VImageDimension; j > 0; --j) { // otbMsgDevMacro(<< "*** Dimension: " << j-1); unsigned long int remainingToDo = static_cast(vcl_ceil(static_cast(requestedNumber) / numPieces)); unsigned int maxPieces = (regionIndex[j - 1] + regionSize[j - 1] - 1) / m_AlignStep - regionIndex[j - 1] / m_AlignStep + 1; unsigned int stepPerPiece = 1; if (remainingToDo < maxPieces) { stepPerPiece = static_cast (vcl_floor(static_cast (maxPieces) / remainingToDo)); if ((remainingToDo - 1) * (stepPerPiece + 1) < maxPieces) { stepPerPiece += 1; } } unsigned int maxPieceUsed = static_cast (vcl_ceil(static_cast (maxPieces) / stepPerPiece)); m_SplitsPerDimension[j - 1] = maxPieceUsed; // otbMsgDevMacro("*** maxPieces stepPerPiece maxPieceUsed " << maxPieces // << " " << stepPerPiece << " " << maxPieceUsed); numPieces *= maxPieceUsed; } // otbMsgDevMacro("*** numPieces " << numPieces); return numPieces; } /** * */ template itk::ImageRegion ImageRegionTileMapSplitter ::GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region) { RegionType splitRegion; IndexType splitIndex, regionIndex; SizeType splitSize, regionSize; // Initialize the splitRegion to the requested region splitRegion = region; splitIndex = splitRegion.GetIndex(); splitSize = splitRegion.GetSize(); regionSize = region.GetSize(); regionIndex = region.GetIndex(); unsigned int numPieces = GetNumberOfSplits(region, numberOfPieces); if (i > numPieces) { itkDebugMacro(" Cannot Split"); return splitRegion; } unsigned int stackSize = 1; for (unsigned int j = 0; j < VImageDimension; ++j) { unsigned int slicePos = (i % (stackSize * m_SplitsPerDimension[j])) / stackSize; stackSize *= m_SplitsPerDimension[j]; unsigned int generalSplitSize = static_cast (vcl_ceil(static_cast (regionSize[j]) / (m_SplitsPerDimension[j] * m_AlignStep))) * m_AlignStep; if (slicePos == 0) { splitIndex[j] = regionIndex[j]; } else { splitIndex[j] = (regionIndex[j] / generalSplitSize + slicePos) * generalSplitSize; } if (slicePos == 0) { splitSize[j] = generalSplitSize - (regionIndex[j] % generalSplitSize); } else if (slicePos == m_SplitsPerDimension[j] - 1) { splitSize[j] = regionSize[j] - (generalSplitSize - (regionIndex[j] % generalSplitSize)) - (m_SplitsPerDimension[j] - 2) * generalSplitSize; } else { splitSize[j] = generalSplitSize; } } // set the split region ivars splitRegion.SetIndex(splitIndex); splitRegion.SetSize(splitSize); return splitRegion; } /** * */ template void ImageRegionTileMapSplitter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace itk #endif OTB-release-5.8/Modules/Core/Common/include/otbImageToModulusAndDirectionImageFilter.h000066400000000000000000000071531301006202600307500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToModulusAndDirectionImageFilter_h #define otbImageToModulusAndDirectionImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class ImageToModulusAndDirectionImageFilter * * \brief Base class for modulus and direction image filters. * * This is the base class for alls class' generate modulus and * directions outputs. * GetOutput() method return the output image modulus and * GetOutputDirection() return the output image direction * * * \ingroup OTBCommon */ template class ITK_EXPORT ImageToModulusAndDirectionImageFilter : public itk::ImageToImageFilter { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef for the classes standards. */ typedef ImageToModulusAndDirectionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(ImageToModulusAndDirectionImageFilter, itk::ImageToImageFilter); typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef TOutputImageDirection OutputImageDirectionType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Return the const output image modulus */ const OutputImageType * GetOutput() const; /** Return the output image modulus */ OutputImageType * GetOutput(); /** Return the const output image direction */ const OutputImageDirectionType * GetOutputDirection() const; /** Return the output image direction */ OutputImageDirectionType * GetOutputDirection(); void GenerateInputRequestedRegion() ITK_OVERRIDE; protected: ImageToModulusAndDirectionImageFilter(); ~ImageToModulusAndDirectionImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageToModulusAndDirectionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToModulusAndDirectionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImageToModulusAndDirectionImageFilter.txx000066400000000000000000000077071301006202600313510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToModulusAndDirectionImageFilter_txx #define otbImageToModulusAndDirectionImageFilter_txx #include "otbImageToModulusAndDirectionImageFilter.h" #include "itkProcessObject.h" namespace otb { /** * */ template ImageToModulusAndDirectionImageFilter:: ImageToModulusAndDirectionImageFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(2); this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageDirectionType::New()); } /** Return the const output image modulus */ template const typename ImageToModulusAndDirectionImageFilter::OutputImageType * ImageToModulusAndDirectionImageFilter:: GetOutput() const { if (this->GetNumberOfOutputs() < 1) { return 0; } return static_cast (this->itk::ProcessObject::GetOutput(0)); } /** Return the output image modulus */ template typename ImageToModulusAndDirectionImageFilter::OutputImageType * ImageToModulusAndDirectionImageFilter:: GetOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetOutput(0)); } /** Return the const output image direction */ template const typename ImageToModulusAndDirectionImageFilter::OutputImageDirectionType * ImageToModulusAndDirectionImageFilter:: GetOutputDirection() const { if (this->GetNumberOfOutputs() < 2) { return 0; } return static_cast (this->itk::ProcessObject::GetOutput(1)); } /** Return the output image direction */ template typename ImageToModulusAndDirectionImageFilter::OutputImageDirectionType * ImageToModulusAndDirectionImageFilter:: GetOutputDirection() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetOutput(1)); } /** * Standard "GenerateInputRequestedRegion" method */ template void ImageToModulusAndDirectionImageFilter ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); } /** * Standard "PrintSelf" method */ template void ImageToModulusAndDirectionImageFilter:: PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbImaginaryImageToComplexImageFilter.h000066400000000000000000000062421301006202600303020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImaginaryImageToComplexImageFilter_h #define otbImaginaryImageToComplexImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "vnl/vnl_math.h" namespace otb { /** \class ImaginaryImageToComplexImageFilter * \brief Computes pixel-wise the complex image of a imaginary image. * * \sa ImaginaryImageToComplexImageFilter * \ingroup Multithreaded * * \ingroup OTBCommon */ namespace Function { template< class TInputImageImaginaryPart, class TOutput> class ImaginaryToComplex { public: typedef typename TOutput::value_type OutputValueType; ImaginaryToComplex() {} ~ImaginaryToComplex() {} bool operator!=( const ImaginaryToComplex & ) const { return false; } bool operator==( const ImaginaryToComplex & other ) const { return !(*this != other); } inline TOutput operator()( const TInputImageImaginaryPart & imaginary) const { return TOutput(static_cast(0.0), static_cast(imaginary)); } }; } template class ITK_EXPORT ImaginaryImageToComplexImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ImaginaryImageToComplexImageFilter Self; typedef itk::UnaryFunctorImageFilter< TInputImageImaginaryPart, TOutputImage, Function::ImaginaryToComplex< typename TInputImageImaginaryPart::PixelType, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ImaginaryImageToComplexImageFilter, UnaryFunctorImageFilter); typedef typename TInputImageImaginaryPart::PixelType InputImaginaryPartPixelType; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename itk::NumericTraits< OutputPixelType >::ValueType OutputPixelValueType; protected: ImaginaryImageToComplexImageFilter() {} ~ImaginaryImageToComplexImageFilter() ITK_OVERRIDE {} private: ImaginaryImageToComplexImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbImportImageFilter.h000066400000000000000000000146511301006202600250410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImportImageFilter_h #define otbImportImageFilter_h #include "itkImageSource.h" namespace otb { /** \class ImportImageFilter * \brief Import data from a standard C array into an Image Type * * ImportImageFilter provides a mechanism for importing data into an Image Type. * ImportImageFilter is an image source, so it behaves like any other pipeline * object. * * This class is templated over the output Image Type * * * \ingroup OTBCommon */ template class ITK_EXPORT ImportImageFilter : public itk::ImageSource { public: /** Typedef for the output image. */ typedef TOutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::SpacingType SpacingType; typedef typename OutputImageType::PointType OriginType; /** Standard class typedefs. */ typedef ImportImageFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImportImageFilter, itk::ImageSource); /** Index typedef support. An index is used to access pixel values. */ typedef itk::Index IndexType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::Size SizeType; /** Region typedef support. A region is used to specify a * subset of an image. */ typedef itk::ImageRegion RegionType; /** Type of the output image pixel type. */ typedef typename OutputImageType::PixelType TPixel; /** Get the pointer from which the image data is imported. */ TPixel *GetImportPointer(); /** Set the pointer from which the image data is imported. "num" is * the number of pixels in the block of memory. If * "LetFilterManageMemory" is false, then the this filter will * not free the memory in its destructor and the application providing the * buffer retains the responsibility of freeing the memory for this image * data. If "LetFilterManageMemory" is true, then this class * will free the memory when this object is destroyed. */ void SetImportPointer(TPixel *ptr, unsigned long num, bool LetFilterManageMemory); /** Set the region object that defines the size and starting index * for the imported image. This will serve as the LargestPossibleRegion, * the BufferedRegion, and the RequestedRegion. * \sa ImageRegion */ void SetRegion(const RegionType& region) { if (m_Region != region) { m_Region = region; this->Modified(); } } /** Get the region object that defines the size and starting index * for the imported image. This will serve as the LargestPossibleRegion, * the BufferedRegion, and the RequestedRegion. * \sa ImageRegion */ const RegionType& GetRegion() const { return m_Region; } /** Set the spacing (size of a pixel) of the image. * \sa GetSpacing() */ itkSetVectorMacro(Spacing, const double, OutputImageType::ImageDimension); itkSetVectorMacro(Spacing, const float, OutputImageType::ImageDimension); /** Get the spacing (size of a pixel) of the image. * \sa SetSpacing() */ itkGetVectorMacro(Spacing, const double, OutputImageType::ImageDimension); void SetSpacing(const SpacingType& spacing); /** Set the origin of the image. * \sa GetOrigin() */ itkSetVectorMacro(Origin, const double, OutputImageType::ImageDimension); itkSetVectorMacro(Origin, const float, OutputImageType::ImageDimension); void SetOrigin(const OriginType& origin); /** Get the origin of the image. * \sa SetOrigin() */ itkGetVectorMacro(Origin, const double, OutputImageType::ImageDimension); typedef itk::Matrix DirectionType; /** Set the direction of the image * \sa GetDirection() */ virtual void SetDirection(const DirectionType direction); /** Get the direction of the image * \sa SetDirection */ itkGetConstReferenceMacro(Direction, DirectionType); protected: ImportImageFilter(); ~ImportImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** This filter does not actually "produce" any data, rather it "wraps" * the user supplied data into an itk::Image. */ void GenerateData() ITK_OVERRIDE; /** This is a source, so it must set the spacing, size, and largest possible * region for the output image that it will produce. * \sa ProcessObject::GenerateOutputInformation() */ void GenerateOutputInformation() ITK_OVERRIDE; /** This filter can only produce the amount of data that it is given, * so we must ITK_OVERRIDE ProcessObject::EnlargeOutputRequestedRegion() * (The default implementation of a source produces the amount of * data requested. This source, however, can only produce what it is * given.) * * \sa ProcessObject::EnlargeOutputRequestedRegion() */ void EnlargeOutputRequestedRegion(itk::DataObject *output) ITK_OVERRIDE; private: ImportImageFilter(const ImportImageFilter &); //purposely not implemented void operator =(const ImportImageFilter&); //purposely not implemented RegionType m_Region; double m_Spacing[OutputImageType::ImageDimension]; double m_Origin[OutputImageType::ImageDimension]; DirectionType m_Direction; TPixel* m_ImportPointer; bool m_FilterManageMemory; unsigned long m_Size; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImportImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImportImageFilter.txx000066400000000000000000000143341301006202600254330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImportImageFilter_txx #define otbImportImageFilter_txx #include "otbImportImageFilter.h" #include "itkObjectFactory.h" namespace otb { /** * */ template ImportImageFilter ::ImportImageFilter() { unsigned int idx; for (idx = 0; idx < TOutputImage::ImageDimension; ++idx) { m_Spacing[idx] = 1.0; m_Origin[idx] = 0.0; } m_Direction.SetIdentity(); m_ImportPointer = ITK_NULLPTR; m_FilterManageMemory = false; m_Size = 0; } /** * */ template ImportImageFilter ::~ImportImageFilter() { if (m_ImportPointer && m_FilterManageMemory) { delete[] m_ImportPointer; } } /** * */ template void ImportImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { int i; Superclass::PrintSelf(os, indent); if (m_ImportPointer) { os << indent << "Imported pointer: (" << m_ImportPointer << ")" << std::endl; } else { os << indent << "Imported pointer: (None)" << std::endl; } os << indent << "Import buffer size: " << m_Size << std::endl; os << indent << "Import buffer size: " << m_Size << std::endl; os << indent << "Filter manages memory: " << (m_FilterManageMemory ? "true" : "false") << std::endl; os << indent << "Spacing: ["; for (i = 0; i < static_cast(TOutputImage::ImageDimension) - 1; ++i) { os << m_Spacing[i] << ", "; } os << m_Spacing[i] << "]" << std::endl; os << indent << "Origin: ["; for (i = 0; i < static_cast(TOutputImage::ImageDimension) - 1; ++i) { os << m_Origin[i] << ", "; } os << m_Origin[i] << "]" << std::endl; os << indent << "Direction: " << std::endl << this->GetDirection() << std::endl; } /** * */ template void ImportImageFilter ::SetImportPointer(TPixel *ptr, unsigned long num, bool LetFilterManageMemory) { if (ptr != m_ImportPointer) { if (m_ImportPointer && m_FilterManageMemory) { delete[] m_ImportPointer; } m_ImportPointer = ptr; this->Modified(); } m_FilterManageMemory = LetFilterManageMemory; m_Size = num; } /** * */ template typename ImportImageFilter::TPixel* ImportImageFilter ::GetImportPointer() { return m_ImportPointer; } /** * */ template void ImportImageFilter ::EnlargeOutputRequestedRegion(itk::DataObject *output) { // call the superclass' implementation of this method Superclass::EnlargeOutputRequestedRegion(output); // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); // set the requested region to the largest possible region (in this case // the amount of data that we have) outputPtr->SetRequestedRegion(outputPtr->GetLargestPossibleRegion()); } /** * */ template void ImportImageFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); // we need to compute the output spacing, the output origin, the // output image size, and the output image start index outputPtr->SetSpacing(m_Spacing); outputPtr->SetOrigin(m_Origin); outputPtr->SetDirection(m_Direction); outputPtr->SetLargestPossibleRegion(m_Region); } /** * */ template void ImportImageFilter ::GenerateData() { // Normally, GenerateData() allocates memory. However, the application // provides the memory for this filter via the SetImportPointer() method. // Therefore, this filter does not call outputPtr->Allocate(). // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); // the output buffer size is set to the size specified by the user via the // SetRegion() method. outputPtr->SetBufferedRegion(outputPtr->GetLargestPossibleRegion()); // pass the pointer down to the container during each Update() since // a call to Initialize() causes the container to forget the // pointer. Note that we tell the container NOT to manage the // memory itself. This filter will properly manage the memory (as // opposed to the container) if the user wants it to. outputPtr->GetPixelContainer()->SetImportPointer(m_ImportPointer, m_Size, false); } /** * */ template void ImportImageFilter ::SetSpacing(const SpacingType& spacing) { double dspacing[TOutputImage::ImageDimension]; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { dspacing[i] = spacing[i]; } this->SetSpacing(dspacing); } /** * */ template void ImportImageFilter ::SetOrigin(const OriginType& origin) { double dorigin[TOutputImage::ImageDimension]; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { dorigin[i] = origin[i]; } this->SetOrigin(dorigin); } //---------------------------------------------------------------------------- template void ImportImageFilter ::SetDirection(const DirectionType direction) { bool modified = false; for (unsigned int r = 0; r < TOutputImage::ImageDimension; ++r) { for (unsigned int c = 0; c < TOutputImage::ImageDimension; ++c) { if (m_Direction[r][c] != direction[r][c]) { m_Direction[r][c] = direction[r][c]; modified = true; } } } if (modified) { this->Modified(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbImportVectorImageFilter.h000066400000000000000000000152531301006202600262230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImportVectorImageFilter_h #define otbImportVectorImageFilter_h #include "itkImageSource.h" namespace otb { /** \class ImportVectorImageFilter * \brief Import data from a standard C array into an Image Type * * ImportVectorImageFilter provides a mechanism for importing data into an Image Type. * ImportVectorImageFilter is an image source, so it behaves like any other pipeline * object. * * This class is templated over the output Image Type * * * \ingroup OTBCommon */ template class ITK_EXPORT ImportVectorImageFilter : public itk::ImageSource { public: /** Typedef for the output image. */ typedef TOutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::SpacingType SpacingType; typedef typename OutputImageType::PointType OriginType; /** Standard class typedefs. */ typedef ImportVectorImageFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImportVectorImageFilter, itk::ImageSource); /** Index typedef support. An index is used to access pixel values. */ typedef itk::Index IndexType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::Size SizeType; /** Region typedef support. A region is used to specify a * subset of an image. */ typedef itk::ImageRegion RegionType; /** Type of the output image pixel type. */ typedef typename OutputImageType::PixelType TOutputPixel; typedef typename TOutputPixel::ValueType TPixel; /** Get the pointer from which the image data is imported. */ TPixel *GetImportPointer(); /** Set the pointer from which the image data is imported. "num" is * the number of pixels in the block of memory. If * "LetFilterManageMemory" is false, then the this filter will * not free the memory in its destructor and the application providing the * buffer retains the responsibility of freeing the memory for this image * data. If "LetFilterManageMemory" is true, then this class * will free the memory when this object is destroyed. */ virtual void SetImportPointer(TPixel *ptr, unsigned long num, bool LetFilterManageMemory); /** Set the region object that defines the size and starting index * for the imported image. This will serve as the LargestPossibleRegion, * the BufferedRegion, and the RequestedRegion. * \sa ImageRegion */ void SetRegion(const RegionType& region) { if (m_Region != region) { m_Region = region; this->Modified(); } } /** Get the region object that defines the size and starting index * for the imported image. This will serve as the LargestPossibleRegion, * the BufferedRegion, and the RequestedRegion. * \sa ImageRegion */ const RegionType& GetRegion() const { return m_Region; } /** Set the spacing (size of a pixel) of the image. * \sa GetSpacing() */ itkSetVectorMacro(Spacing, const double, OutputImageType::ImageDimension); itkSetVectorMacro(Spacing, const float, OutputImageType::ImageDimension); /** Get the spacing (size of a pixel) of the image. * \sa SetSpacing() */ itkGetVectorMacro(Spacing, const double, OutputImageType::ImageDimension); void SetSpacing(const SpacingType& spacing); /** Set the origin of the image. * \sa GetOrigin() */ itkSetVectorMacro(Origin, const double, OutputImageType::ImageDimension); itkSetVectorMacro(Origin, const float, OutputImageType::ImageDimension); void SetOrigin(const OriginType& origin); itkGetMacro(NumberOfComponents, unsigned int); itkSetMacro(NumberOfComponents, unsigned int); /** Get the origin of the image. * \sa SetOrigin() */ itkGetVectorMacro(Origin, const double, OutputImageType::ImageDimension); typedef itk::Matrix DirectionType; /** Set the direction of the image * \sa GetDirection() */ virtual void SetDirection(const DirectionType direction); /** Get the direction of the image * \sa SetDirection */ itkGetConstReferenceMacro(Direction, DirectionType); protected: ImportVectorImageFilter(); virtual ~ImportVectorImageFilter(); void PrintSelf(std::ostream& os, itk::Indent indent) const; /** This filter does not actually "produce" any data, rather it "wraps" * the user supplied data into an itk::Image. */ virtual void GenerateData(); /** This is a source, so it must set the spacing, size, and largest possible * region for the output image that it will produce. * \sa ProcessObject::GenerateOutputInformation() */ virtual void GenerateOutputInformation(); /** This filter can only produce the amount of data that it is given, * so we must ITK_OVERRIDE ProcessObject::EnlargeOutputRequestedRegion() * (The default implementation of a source produces the amount of * data requested. This source, however, can only produce what it is * given.) * * \sa ProcessObject::EnlargeOutputRequestedRegion() */ virtual void EnlargeOutputRequestedRegion(itk::DataObject *output); private: ImportVectorImageFilter(const ImportVectorImageFilter &); //purposely not implemented void operator =(const ImportVectorImageFilter&); //purposely not implemented RegionType m_Region; double m_Spacing[OutputImageType::ImageDimension]; double m_Origin[OutputImageType::ImageDimension]; DirectionType m_Direction; TPixel* m_ImportPointer; bool m_FilterManageMemory; unsigned int m_NumberOfComponents; unsigned long m_Size; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImportVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbImportVectorImageFilter.txx000066400000000000000000000151641301006202600266200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImportVectorImageFilter_txx #define otbImportVectorImageFilter_txx #include "otbImportVectorImageFilter.h" #include "itkObjectFactory.h" namespace otb { /** * */ template ImportVectorImageFilter ::ImportVectorImageFilter() { unsigned int idx; for (idx = 0; idx < TOutputImage::ImageDimension; ++idx) { m_Spacing[idx] = 1.0; m_Origin[idx] = 0.0; } m_Direction.SetIdentity(); m_ImportPointer = 0; m_FilterManageMemory = false; m_Size = 0; } /** * */ template ImportVectorImageFilter ::~ImportVectorImageFilter() { if (m_ImportPointer && m_FilterManageMemory) { delete[] m_ImportPointer; } } /** * */ template void ImportVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { int i; Superclass::PrintSelf(os, indent); if (m_ImportPointer) { os << indent << "Imported pointer: (" << m_ImportPointer << ")" << std::endl; } else { os << indent << "Imported pointer: (None)" << std::endl; } os << indent << "Import buffer size: " << m_Size << std::endl; os << indent << "Import buffer size: " << m_Size << std::endl; os << indent << "Filter manages memory: " << (m_FilterManageMemory ? "true" : "false") << std::endl; os << indent << "Spacing: ["; for (i = 0; i < static_cast(TOutputImage::ImageDimension) - 1; ++i) { os << m_Spacing[i] << ", "; } os << m_Spacing[i] << "]" << std::endl; os << indent << "Origin: ["; for (i = 0; i < static_cast(TOutputImage::ImageDimension) - 1; ++i) { os << m_Origin[i] << ", "; } os << m_Origin[i] << "]" << std::endl; os << indent << "Direction: " << std::endl << this->GetDirection() << std::endl; } /** * */ template void ImportVectorImageFilter ::SetImportPointer(TPixel *ptr, unsigned long num, bool LetFilterManageMemory) { if (ptr != m_ImportPointer) { if (m_ImportPointer && m_FilterManageMemory) { delete[] m_ImportPointer; } m_ImportPointer = ptr; this->Modified(); } m_FilterManageMemory = LetFilterManageMemory; m_Size = num; } /** * */ template typename ImportVectorImageFilter::TPixel* ImportVectorImageFilter ::GetImportPointer() { return m_ImportPointer; } /** * */ template void ImportVectorImageFilter ::EnlargeOutputRequestedRegion(itk::DataObject *output) { // call the superclass' implementation of this method Superclass::EnlargeOutputRequestedRegion(output); // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); // set the requested region to the largest possible region (in this case // the amount of data that we have) outputPtr->SetRequestedRegion(outputPtr->GetLargestPossibleRegion()); } /** * */ template void ImportVectorImageFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); // we need to compute the output spacing, the output origin, the // output image size, and the output image start index outputPtr->SetSpacing(m_Spacing); outputPtr->SetOrigin(m_Origin); outputPtr->SetDirection(m_Direction); outputPtr->SetLargestPossibleRegion(m_Region); typename RegionType::SizeType size = m_Region.GetSize(); int numberOfBands = m_Size / (size[0] * size[1]); if (numberOfBands != static_cast(numberOfBands)) itkExceptionMacro( << "Buffer size and image size are not compatible !"); outputPtr->SetNumberOfComponentsPerPixel(numberOfBands); } /** * */ template void ImportVectorImageFilter ::GenerateData() { // Normally, GenerateData() allocates memory. However, the application // provides the memory for this filter via the SetImportPointer() method. // Therefore, this filter does not call outputPtr->Allocate(). // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); // the output buffer size is set to the size specified by the user via the // SetRegion() method. outputPtr->SetBufferedRegion(outputPtr->GetLargestPossibleRegion()); // pass the pointer down to the container during each Update() since // a call to Initialize() causes the container to forget the // pointer. Note that we tell the container NOT to manage the // memory itself. This filter will properly manage the memory (as // opposed to the container) if the user wants it to. outputPtr->GetPixelContainer()->SetImportPointer(m_ImportPointer, m_Size, false); } /** * */ template void ImportVectorImageFilter ::SetSpacing(const SpacingType& spacing) { double dspacing[TOutputImage::ImageDimension]; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { dspacing[i] = spacing[i]; } this->SetSpacing(dspacing); } /** * */ template void ImportVectorImageFilter ::SetOrigin(const OriginType& origin) { double dorigin[TOutputImage::ImageDimension]; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { dorigin[i] = origin[i]; } this->SetOrigin(dorigin); } //---------------------------------------------------------------------------- template void ImportVectorImageFilter ::SetDirection(const DirectionType direction) { bool modified = false; for (unsigned int r = 0; r < TOutputImage::ImageDimension; ++r) { for (unsigned int c = 0; c < TOutputImage::ImageDimension; ++c) { if (m_Direction[r][c] != direction[r][c]) { m_Direction[r][c] = direction[r][c]; modified = true; } } } if (modified) { this->Modified(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbMacro.h000066400000000000000000000172141301006202600225150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /** * otbMacro.h defines standard system-wide macros, constants, and other * parameters. One of its most important functions is to define macros used * to interface to instance variables in a standard fashion. */ #ifndef otbMacro_h #define otbMacro_h #include "itkMacro.h" #include "itkObject.h" #include "otbConfigure.h" /** * \namespace otb * \brief The "otb" namespace contains all Orfeo Toolbox (OTB) classes. * * There are several nested namespaces within this one. */ namespace otb { } // end namespace otb - this is here for documentation purposes /** This macro is used to print debug (or other information). They are * also used to catch errors, etc. Example usage looks like: * itkDebugMacro(<< "this is debug info" << this->SomeVariable); */ #define otbDebugMacro(x) itkDebugMacro(x) /* { if ( this->GetDebug() && *::itk::Object::GetGlobalWarningDisplay()) \ { std::ostringstream itkmsg; \ itkmsg << "Debug: In " __FILE__ ", line " << __LINE__ << "\n" \ << this->GetNameOfClass() << " (" << this << "): " x \ << "\n\n"; \ ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str()); } \ }*/ #define otbMsgDebugMacro(x) \ { \ if (this->GetDebug() && ::itk::Object::GetGlobalWarningDisplay()) \ { \ std::ostringstream itkmsg; \ itkmsg << " Msg Debug: " x << "\n"; \ ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str()); \ } \ } #ifndef NDEBUG #define otbGenericMsgDebugMacro(x) \ { \ if (::itk::Object::GetGlobalWarningDisplay()) \ { \ std::ostringstream itkmsg; \ itkmsg << " Generic Msg Debug: " x << "\n"; \ ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str()); \ } \ } #else #define otbGenericMsgDebugMacro(x) #endif #define otbGenericMsgTestingMacro(x) \ { \ std::cout x << std::endl; \ } #ifdef OTB_SHOW_ALL_MSG_DEBUG #define otbMsgDevMacro(x) \ { \ { \ std::ostringstream itkmsg; \ itkmsg << " Msg Dev: (" << __FILE__ << ":" << __LINE__ << ") " x << "\n"; \ ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str()); \ } \ } #else #define otbMsgDevMacro(x) #endif /** This macro is used to print warning information (i.e., unusual circumstance * but not necessarily fatal.) Example usage looks like: * itkWarningMacro(<< "this is warning info" << this->SomeVariable); */ #define otbWarningMacro(x) \ { \ if (itk::Object::GetGlobalWarningDisplay()) \ { \ std::ostringstream itkmsg; \ itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" \ << this->GetNameOfClass() << " (" << this << "): " x \ << "\n\n"; \ itk::OutputWindowDisplayWarningText(itkmsg.str().c_str()); \ } \ } #define otbGenericWarningMacro(x) \ { \ if (itk::Object::GetGlobalWarningDisplay()) \ { \ std::ostringstream itkmsg; \ itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << ": " x <<"\n";\ itk::OutputWindowDisplayWarningText(itkmsg.str().c_str()); \ } \ } /** This macro is used to control condition. It use ONLY by the OTB developers * */ #define otbControlConditionTestMacro(condition, message) \ { \ if ((condition)) itkGenericExceptionMacro(<< message); \ } /** Set built-in type. Creates member Set"name"() (e.g., SetVisibility()); */ #define otbSetObjectMemberMacro(object, name, type) \ virtual void Set ## name (const type _arg) \ { \ itkDebugMacro("setting member " # name " to " << _arg); \ this->m_ ## object->Set ## name(_arg); \ this->Modified(); \ } /** Get built-in type. Creates member Get"name"() (e.g., GetVisibility()); */ #define otbGetObjectMemberMacro(object, name, type) \ virtual type Get ## name () \ { \ itkDebugMacro("returning " << # name " of " << this->m_ ## object->Get ## name()); \ return this->m_ ## object->Get ## name(); \ } /** Get built-in type. Creates member Get"name"() (e.g., GetVisibility()); * This is the "const" form of the itkGetMacro. It should be used unless * the member can be changed through the "Get" access routine. */ #define otbGetObjectMemberConstMacro(object, name, type) \ virtual type Get ## name () const \ { \ itkDebugMacro("returning " << # name " of " << this->m_ ## object->Get ## name()); \ return this->m_ ## object->Get ## name(); \ } /** Get built-in type. Creates member Get"name"() (e.g., GetVisibility()); * This is the "const" form of the itkGetMacro. It should be used unless * the member can be changed through the "Get" access routine. * This versions returns a const reference to the variable. */ #define otbGetObjectMemberConstReferenceMacro(object, name, type) \ virtual const type &Get ## name () const \ { \ itkDebugMacro("returning " << # name " of " << this->m_ ## object->Get ## name()); \ return this->m_ ## object->Get ## name(); \ } /** Testing macro. This macro doesn't throw a exception if the called command * generate a itk::ExceptionObject object. For alls others use cases, the macro * generate a exception. */ #define otbTestingCheckValidCommand(command) \ { \ try \ { \ command; \ } \ catch (const std::exception&) { \ throw; } \ catch (...) \ { \ std::ostringstream message; \ message << "otb::ERROR Unknown error while running " << # command << " (catch(...) )"; \ ::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); \ throw e_; \ } \ std::cout << " Checking valid command " << # command " ok." << std::endl; \ } #define otbGenericExceptionMacro(T, x) \ { \ std::ostringstream message; \ message << "otb::ERROR: " x; \ T e_(__FILE__, __LINE__, message.str(),ITK_LOCATION); \ throw e_;\ } #define otbTestingCheckNotValidCommand(command) \ { \ int result(1); \ try \ { \ command; \ } \ catch (std::bad_alloc& err) { \ throw err; } \ catch (itk::ExceptionObject&) { std::cout << "Checking not valid Command " << # command " ok." << std::endl; \ result = 0; } \ catch (const std::exception& stde) { \ throw stde; } \ catch (...) \ { \ std::ostringstream message; \ message << "otb::ERROR Unknown error while running " << # command << " (catch(...) )"; \ ::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); \ throw e_; \ } \ if (result == 1) \ { \ std::ostringstream message; \ message << "otb::ERROR: " << # command << " should be throwing an exception."; \ ::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); \ throw e_; \ } \ } # define otbUnusedMacro(x) do { (void)sizeof(x); } while(0) // // Unused variable warnings in Debug/Release management. // see http://stackoverflow.com/questions/2290509/debug-vs-ndebug#2290616 #ifdef OTB_DEBUG # define otbUseInDebug( name ) name # define otbUseInRelease( name ) #else // NDEBUG # define otbUseInDebug( name ) # define otbUseInRelease( name ) name #endif // NDEBUG #endif //end of otbMacro.h OTB-release-5.8/Modules/Core/Common/include/otbMath.h000066400000000000000000000112231301006202600223370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMath_h #define otbMath_h /** * otbMath.h defines standard math macros, constants, and other * parameters. * All mathematics constans, functions (used in the OTB code) are the vcl version (vcl..., CONST_PI, ). */ #include "vcl_cmath.h" namespace otb { // For Windows MSVC, defines these macros. #ifdef _USE_MATH_DEFINES #define _MATH_DEFINES_DEFINED #endif /** Define constants if not define in the "vcl_cmath.h" */ /* Some useful constants. */ const double CONST_E = 2.7182818284590452354; /* e */ const double CONST_LOG2E = 1.4426950408889634074; /* log_2 e */ const double CONST_LOG10E = 0.43429448190325182765; /* log_10 e */ const double CONST_LN2 = 0.69314718055994530942; /* log_e 2 */ const double CONST_LN10 = 2.30258509299404568402; /* log_e 10 */ const double CONST_PI = 3.14159265358979323846; /* pi */ const double CONST_PI_2 = 1.57079632679489661923; /* pi/2 */ const double CONST_PI_4 = 0.78539816339744830962; /* pi/4 */ const double CONST_PI_8 = 0.39269908169872415481; /* pi/8 */ const double CONST_1_PI = 0.31830988618379067154; /* 1/pi */ const double CONST_2_PI = 0.63661977236758134308; /* 2/pi */ const double CONST_2PI = 6.28318530717958647693; /* 2*pi */ const double CONST_PI_180 = 0.01745329251994329577; /* pi/180 */ const double CONST_180_PI = 57.2957795130823208768; /* 180/pi */ const double CONST_LNPI = std::log(CONST_PI); /* ln(pi)*/ const double CONST_SQRTPI = std::sqrt(CONST_PI); /* sqrt(pi)*/ const double CONST_2_SQRTPI = 1.12837916709551257390; /* 2/sqrt(pi) */ const double CONST_SQRT2 = 1.41421356237309504880; /* sqrt(2) */ const double CONST_SQRT1_2 = 0.70710678118654752440; /* 1/sqrt(2) */ const double CONST_SQRT3 = 1.73205080756887729353; /* sqrt(3) */ const double CONST_EULER = 0.57721566490153286060; /* euler constant*/ /* The above constants are not adequate for computation using `long double's. Therefore we provide as an extension constants with similar names as a GNU extension. Provide enough digits for the 128-bit IEEE quad. */ #ifdef __USE_GNU const long double CONST_El = 2.7182818284590452353602874713526625L; /* e */ const long double CONST_LOG2El = 1.4426950408889634073599246810018921L; /* log_2 e */ const long double CONST_LOG10El = 0.4342944819032518276511289189166051L; /* log_10 e */ const long double CONST_LN2l = 0.6931471805599453094172321214581766L; /* log_e 2 */ const long double CONST_LN10l = 2.3025850929940456840179914546843642L; /* log_e 10 */ const long double CONST_PIl = 3.1415926535897932384626433832795029L; /* pi */ const long double CONST_PI_2l = 1.5707963267948966192313216916397514L; /* pi/2 */ const long double CONST_PI_4l = 0.7853981633974483096156608458198757L; /* pi/4 */ const long double CONST_PI_8l = 0.3926990816987241548078304229099379L; /* pi/8 */ const long double CONST_2_PIl = 0.6366197723675813430755350534900574L; /* 2/pi */ const long double CONST_2_SQRTPIl = 1.1283791670955125738961589031215452L; /* 2/sqrt(pi) */ const long double CONST_2PIl = 6.2831853071795864769252867665590058L; /* 2*pi */ const long double CONST_PI_180l = 0.0174532925199432957692369076848861L; /* pi/180 */ const long double CONST_180_PIl = 57.295779513082320876798154814105170L; /* 180/pi */ // Defined but not used? //const long double CONST_LNPIl = std::log(CONST_PIl); /* ln(pi)*/ //const long double CONST_SQRTPIl = std::sqrt(CONST_PIl); /* sqrt(pi)*/ const long double CONST_SQRT2l = 1.4142135623730950488016887242096981L; /* sqrt(2) */ const long double CONST_SQRT1_2l = 0.7071067811865475244008443621048490L; /* 1/sqrt(2) */ const long double CONST_SQRT3l = 1.7320508075688772935274463415058724L; /* sqrt(3) */ const long double CONST_EULERl = 0.5772156649015328606065120900824024L; /* euler constant*/ #endif template T InverseValue(const T & value) { return ((value > 0 || value < 0) ? 1/value : 0); } template T SignOfValue(const T & value) { return (value > 0) ? 1 : ((value < 0) ? -1 : 0); } } #endif OTB-release-5.8/Modules/Core/Common/include/otbModelComponentBase.h000066400000000000000000000133031301006202600251650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbModelComponentBase_h #define otbModelComponentBase_h #include #include #include "itkObject.h" #include "itkArray.h" #include "itkMembershipFunctionBase.h" namespace otb { namespace Statistics { /** \class ModelComponentBase * \brief base class for distribution representation that supports * analytical way to update the distribution parameters * * This class expects that its subclasses (distribution components) should * have analytical expressions for updating its parameters using only * the measurement vectors. * * The difference from MixtureModelComponentBase is that it does not have * the knowledge of a mixture. Hence, no weights have to define. * * This class can be considered as a macro class that encapsulates the * storage for the model (subclasses of MembershipFunctionBase) and * model parameter estimators (implementation of analytical expressions). * * Subclasses of this class should define their own distribution specific * membership function. For example, GaussianModelComponent class * defines and creates a GaussianDensityFunction object for that matter. * Subclasses should also cast such membership function object to * MembershipFunctionBase object. By doing that, users can get pointers * to membership functions from different distributional model * * \sa FIXME: StochasticExpectationMaximizationMixtureModelEstimator * * \ingroup OTBCommon */ template class ITK_EXPORT ModelComponentBase : public itk::Object { public: /**Standard class typedefs. */ typedef ModelComponentBase Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /**Standard Macros */ itkNewMacro(Self); itkTypeMacro(ModelComponentBase, Object); typedef typename TSample::MeasurementVectorType MeasurementVectorType; typedef typename TSample::MeasurementVectorSizeType MeasurementVectorSizeType; /** typedef for the MembershipFunctionBase */ typedef itk::Statistics::MembershipFunctionBase MembershipFunctionType; typedef itk::Array ParametersType; /** stores the sample pointer (does not update the estimation by itself) */ virtual void SetSample(const TSample* sample); /** returns the sample pointer */ const TSample* GetSample() const; /** returns the pointer to the membership function object. * Subclasses of this class are responsible for creating the * actual membership function objects and cast them to * MembershipFunctionBase objects */ MembershipFunctionType* GetPdfMembershipFunction(); MembershipFunctionType* GetCdfMembershipFunction(); /** stores the pointer to the membership function. * subclasses use this function to store their membership function * object after dynamic creation, when available (the Pdf part is * protected as soon as it is considered to be known for all * ModelComponent)*/ void SetCdfMembershipFunction(MembershipFunctionType* function); /** Gets/Sets the parameter(s) required for the component */ void SetParameters(const ParametersType& parameters); ParametersType GetParameters() { return m_Parameters; } /** returns the pdf of the "measurements" vector */ double Evaluate(MeasurementVectorType& measurements); double Pdf(MeasurementVectorType& measurements); /** returns the cdf of the "measurements" vector */ double Cdf(MeasurementVectorType& measurements); /** Update parameter estimation if necessary * (mainly when sample has changed) */ virtual void Update(); /** Show the parameters in a minimal form in comparison to PrintSelf */ virtual void ShowParameters(std::ostream& os, itk::Indent indent) const; // TODO: Distance entre distribution via une sorte de fonction membre... protected: ModelComponentBase(); ~ModelComponentBase() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; virtual void GenerateData(); /** stores the pointer to the membership function. * subclasses use this function to store their membership function * object after dynamic creation, when available */ void SetPdfMembershipFunction(MembershipFunctionType* function); /** Test on new data */ int IsSampleModified(); /** Set of parameters necessary for the statistical models */ ParametersType m_Parameters; private: ModelComponentBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** target sample data pointer */ const TSample* m_Sample; protected: /** SmartPointer to the membership function - here density function */ MembershipFunctionType* m_PdfFunction; /** SmartPointer to the membership function - here cumulative function */ MembershipFunctionType* m_CdfFunction; /** indicative flag of membership function's parameter changes */ int m_SampleModified; }; // end of class } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbModelComponentBase.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbModelComponentBase.txx000066400000000000000000000100731301006202600255620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbModelComponentBase_txx #define otbModelComponentBase_txx #include #include "otbMacro.h" #include "otbModelComponentBase.h" namespace otb { namespace Statistics { template ModelComponentBase ::ModelComponentBase() { m_Sample = ITK_NULLPTR; m_PdfFunction = ITK_NULLPTR; m_CdfFunction = ITK_NULLPTR; m_SampleModified = 0; } template void ModelComponentBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Sample: "; if (m_Sample != ITK_NULLPTR) { os << m_Sample << std::endl; } else { os << "not set." << std::endl; } os << indent << "Membership Function for pdf: "; if (m_PdfFunction != ITK_NULLPTR) { os << m_PdfFunction << std::endl; } else { os << "not instantiated yet." << std::endl; } os << indent << "Membership Function for cdf: "; if (m_CdfFunction != ITK_NULLPTR) { os << m_CdfFunction << std::endl; } else { os << "not instantiated yet." << std::endl; } os << indent << "Sample are modified and parameters updated: "; os << m_SampleModified << std::endl; } template void ModelComponentBase ::ShowParameters(std::ostream& os, itk::Indent indent) const { os << indent << "Generic class of model-component. Parameters :\n"; for (unsigned int i = 0; i < m_Parameters.Size(); ++i) os << indent << m_Parameters[i] << "\n"; } template void ModelComponentBase ::SetSample(const TSample* sample) { m_Sample = sample; m_SampleModified = 1; } template const TSample* ModelComponentBase ::GetSample() const { return m_Sample; } template void ModelComponentBase ::SetParameters(const ParametersType& parameters) { if (m_Parameters != parameters) m_Parameters = parameters; } template void ModelComponentBase ::SetPdfMembershipFunction(MembershipFunctionType* function) { m_PdfFunction = function; } template void ModelComponentBase ::SetCdfMembershipFunction(MembershipFunctionType* function) { m_CdfFunction = function; } template typename ModelComponentBase::MembershipFunctionType* ModelComponentBase ::GetPdfMembershipFunction() { return m_PdfFunction; } template typename ModelComponentBase::MembershipFunctionType* ModelComponentBase ::GetCdfMembershipFunction() { return m_CdfFunction; } template inline double ModelComponentBase ::Pdf(MeasurementVectorType& measurements) { return this->m_PdfFunction->Evaluate(measurements); } template inline double ModelComponentBase ::Cdf(MeasurementVectorType& measurements) { return m_CdfFunction->Evaluate(measurements); } template int ModelComponentBase ::IsSampleModified() { return m_SampleModified; } template void ModelComponentBase ::Update() { if (m_SampleModified) this->GenerateData(); m_SampleModified = 0; } template void ModelComponentBase ::GenerateData() { /** subclasses should ITK_OVERRIDE this function to perform * parameter estimation. But it allows switching m_SampleModified * when necessary. */ m_SampleModified = 0; } } // end of namespace Statistics } // end of namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbQuaternaryFunctorImageFilter.h000066400000000000000000000154651301006202600272670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQuaternaryFunctorImageFilter_h #define otbQuaternaryFunctorImageFilter_h #include "itkInPlaceImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" namespace otb { /** \class QuaternaryFunctorImageFilter * \brief Implements pixel-wise generic operation of four images. * * This class is parameterized over the types of the four input images * and the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * \sa TernaryFunctorImageFilter, BinaryFunctorImageFilter UnaryFunctorImageFilter * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBCommon */ template class ITK_EXPORT QuaternaryFunctorImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef QuaternaryFunctorImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(QuaternaryFunctorImageFilter, InPlaceImageFilter); /** Some typedefs. */ typedef TFunction FunctorType; typedef TInputImage1 Input1ImageType; typedef typename Input1ImageType::ConstPointer Input1ImagePointer; typedef typename Input1ImageType::RegionType Input1ImageRegionType; typedef typename Input1ImageType::PixelType Input1ImagePixelType; typedef TInputImage2 Input2ImageType; typedef typename Input2ImageType::ConstPointer Input2ImagePointer; typedef typename Input2ImageType::RegionType Input2ImageRegionType; typedef typename Input2ImageType::PixelType Input2ImagePixelType; typedef TInputImage3 Input3ImageType; typedef typename Input3ImageType::ConstPointer Input3ImagePointer; typedef typename Input3ImageType::RegionType Input3ImageRegionType; typedef typename Input3ImageType::PixelType Input3ImagePixelType; typedef TInputImage4 Input4ImageType; typedef typename Input4ImageType::ConstPointer Input4ImagePointer; typedef typename Input4ImageType::RegionType Input4ImageRegionType; typedef typename Input4ImageType::PixelType Input4ImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; /** Connect one of the operands for pixel-wise addition. */ void SetInput1(const TInputImage1 *image1); /** Connect one of the operands for pixel-wise addition. */ void SetInput2(const TInputImage2 *image2); /** Connect one of the operands for pixel-wise addition. */ void SetInput3(const TInputImage3 *image3); /** Connect one of the operands for pixel-wise addition. */ void SetInput4(const TInputImage4 *image4); /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer). */ FunctorType& GetFunctor(void) { return m_Functor; } /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator==() be defined on the functor * (or the compiler's default implementation of operator==() being * appropriate). */ void SetFunctor(const FunctorType& functor) { if (!(functor == m_Functor)) { m_Functor = functor; this->Modified(); } } /** Image dimensions */ itkStaticConstMacro(Input1ImageDimension, unsigned int, TInputImage1::ImageDimension); itkStaticConstMacro(Input2ImageDimension, unsigned int, TInputImage2::ImageDimension); itkStaticConstMacro(Input3ImageDimension, unsigned int, TInputImage3::ImageDimension); itkStaticConstMacro(Input4ImageDimension, unsigned int, TInputImage4::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); protected: QuaternaryFunctorImageFilter(); ~QuaternaryFunctorImageFilter() ITK_OVERRIDE {} /** Validate the presence of all three inputs. If one or more inputs * are missing, throw an exception. */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** QuaternaryFunctorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: QuaternaryFunctorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbQuaternaryFunctorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbQuaternaryFunctorImageFilter.txx000066400000000000000000000145221301006202600276540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQuaternaryFunctorImageFilter_txx #define otbQuaternaryFunctorImageFilter_txx #include "otbQuaternaryFunctorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template QuaternaryFunctorImageFilter ::QuaternaryFunctorImageFilter() { this->InPlaceOff(); } /** * Connect one of the operands for pixel-wise addition */ template void QuaternaryFunctorImageFilter ::SetInput1(const TInputImage1 *image1) { // The ProcessObject is not const-correct so the const_cast is required here this->SetNthInput(0, const_cast(image1)); } /** * Connect one of the operands for pixel-wise addition */ template void QuaternaryFunctorImageFilter ::SetInput2(const TInputImage2 *image2) { // The ProcessObject is not const-correct so the const_cast is required here this->SetNthInput(1, const_cast(image2)); } /** * Connect one of the operands for pixel-wise addition */ template void QuaternaryFunctorImageFilter ::SetInput3(const TInputImage3 *image3) { // The ProcessObject is not const-correct so the const_cast is required here this->SetNthInput(2, const_cast(image3)); } /** * Connect one of the operands for pixel-wise addition */ template void QuaternaryFunctorImageFilter ::SetInput4(const TInputImage4 *image4) { // The ProcessObject is not const-correct so the const_cast is required here this->SetNthInput(3, const_cast(image4)); } /** * BeforeThreadedGenerateData function. Validate inputs */ template void QuaternaryFunctorImageFilter ::BeforeThreadedGenerateData() { Input1ImagePointer inputPtr1 = dynamic_cast((itk::ProcessObject::GetInput(0))); Input2ImagePointer inputPtr2 = dynamic_cast((itk::ProcessObject::GetInput(1))); Input3ImagePointer inputPtr3 = dynamic_cast((itk::ProcessObject::GetInput(2))); Input4ImagePointer inputPtr4 = dynamic_cast((itk::ProcessObject::GetInput(3))); if (inputPtr1.IsNull() || inputPtr2.IsNull() || inputPtr3.IsNull() || inputPtr4.IsNull()) { itkExceptionMacro(<< "At least one input is missing." << " Input1 is " << inputPtr1.GetPointer() << ", " << " Input2 is " << inputPtr2.GetPointer() << ", " << " Input3 is " << inputPtr3.GetPointer() << ", " << " Input4 is " << inputPtr4.GetPointer()); } } /** * ThreadedGenerateData function. Performs the pixel-wise addition */ template void QuaternaryFunctorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImage1 so it cannot be used for the second or third input. Input1ImagePointer inputPtr1 = dynamic_cast((itk::ProcessObject::GetInput(0))); Input2ImagePointer inputPtr2 = dynamic_cast((itk::ProcessObject::GetInput(1))); Input3ImagePointer inputPtr3 = dynamic_cast((itk::ProcessObject::GetInput(2))); Input4ImagePointer inputPtr4 = dynamic_cast((itk::ProcessObject::GetInput(3))); OutputImagePointer outputPtr = this->GetOutput(0); itk::ImageRegionConstIterator inputIt1(inputPtr1, outputRegionForThread); itk::ImageRegionConstIterator inputIt2(inputPtr2, outputRegionForThread); itk::ImageRegionConstIterator inputIt3(inputPtr3, outputRegionForThread); itk::ImageRegionConstIterator inputIt4(inputPtr4, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt1.GoToBegin(); inputIt2.GoToBegin(); inputIt3.GoToBegin(); outputIt.GoToBegin(); while (!inputIt1.IsAtEnd()) { outputIt.Set(m_Functor(inputIt1.Get(), inputIt2.Get(), inputIt3.Get(), inputIt4.Get())); ++inputIt1; ++inputIt2; ++inputIt3; ++inputIt4; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbRGBAPixelConverter.h000066400000000000000000000113771301006202600250650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRGBAPixelConverter_h #define otbRGBAPixelConverter_h #include "itkProcessObject.h" #include "itkRGBAPixel.h" #include "itkRGBPixel.h" namespace otb { /** * \class RGBAPixelConverter * \brief Convert an itk::RGBApixel into another pixel * type * * To be usable, the desired conversion must be implemented through * partial specialisation mechanism. * * * \ingroup OTBCommon */ //RGBA to Scalar template class ITK_EXPORT RGBAPixelConverter : public itk::ProcessObject { public: /** Standard class typedefs */ typedef RGBAPixelConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(RGBAPixelConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef typename itk::RGBAPixel InputPixelType; typedef TOutputPixelType OutputPixelType; OutputPixelType Convert (InputPixelType input); protected: RGBAPixelConverter(){} ~RGBAPixelConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: RGBAPixelConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; //RGBA to RGBA template class ITK_EXPORT RGBAPixelConverter > : public itk::ProcessObject { public: /** Standard class typedefs */ typedef RGBAPixelConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(RGBAPixelConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef typename itk::RGBAPixel InputPixelType; typedef typename itk::RGBAPixel OutputPixelType; OutputPixelType Convert (InputPixelType input); protected: RGBAPixelConverter(){} ~RGBAPixelConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: RGBAPixelConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; //RGBA to RGB template class ITK_EXPORT RGBAPixelConverter > : public itk::ProcessObject { public: /** Standard class typedefs */ typedef RGBAPixelConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(RGBAPixelConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef typename itk::RGBAPixel InputPixelType; typedef typename itk::RGBPixel OutputPixelType; OutputPixelType Convert (InputPixelType input); protected: RGBAPixelConverter(){} ~RGBAPixelConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: RGBAPixelConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRGBAPixelConverter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbRGBAPixelConverter.txx000066400000000000000000000050561301006202600254560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRGBAPixelConverter_txx #define otbRGBAPixelConverter_txx #include "otbRGBAPixelConverter.h" namespace otb { //Base template typename RGBAPixelConverter ::OutputPixelType RGBAPixelConverter ::Convert(InputPixelType input) { double result; result = ( ( 2125.0 * static_cast(input[0]) + 7154.0 * static_cast(input[1]) + 0721.0 * static_cast(input[2])) / 10000.0); //alpha not supported yet return (static_cast(result)); } //RGBA to RGBA template typename RGBAPixelConverter > ::OutputPixelType RGBAPixelConverter > ::Convert(InputPixelType input) { OutputPixelType result; result[0] = static_cast(input[0]); result[1] = static_cast(input[1]); result[2] = static_cast(input[2]); result[3] = static_cast(input[3]); return result; } //RGBA to RGB template typename RGBAPixelConverter > ::OutputPixelType RGBAPixelConverter > ::Convert(InputPixelType input) { OutputPixelType result; result[0] = static_cast(input[0]); result[1] = static_cast(input[1]); result[2] = static_cast(input[2]); return result; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbRectangle.h000066400000000000000000000067211301006202600233610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRectangle_h #define otbRectangle_h #include "itkImageRegion.h" #include "itkVectorContainer.h" namespace otb { /** \class Rectangle * \brief This class represent a Rectangle. * * A rectangle is defined by the median of the width, an orientation and a width * * * \ingroup OTBCommon */ template class ITK_EXPORT Rectangle : public itk::Object { public: /** Standard typedefs */ typedef Rectangle Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TValue ValueType; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(Rectangle, itk::Object); /** Derived typedefs */ typedef itk::ContinuousIndex ContinuousIndexType; typedef ContinuousIndexType VertexType; typedef itk::VectorContainer VertexListType; typedef typename VertexListType::Pointer VertexListPointerType; typedef typename VertexListType::ConstIterator VertexListConstIteratorType; /* typedef typename Superclass::VertexType VertexType; */ /* typedef typename Superclass::VertexListType VertexListType; */ /* typedef typename VertexListType::Pointer VertexListPointerType; */ /* typedef typename Superclass::ContinuousIndexType ContinuousIndexType; */ /* typedef typename Superclass::VertexListConstIteratorType VertexListConstIteratorType; */ typedef itk::ImageRegion<2> RegionType; /** * Set/Get the parameters the a rectangle * - width and orientation */ itkGetMacro(Width, ValueType); itkSetMacro(Width, ValueType); itkSetMacro(Orientation, ValueType); itkGetMacro(Orientation, ValueType); /** * Check whether point is strictly inside the rectangle. * \param point The point to check. * \return True if the point is inside the polygon. */ bool IsInside(VertexType point) const; virtual void AddVertex(const ContinuousIndexType& vertex); /** GetBounding region*/ virtual RegionType GetBoundingRegion() const; protected: /** Constructor */ Rectangle() { m_VertexList = VertexListType::New(); }; /** Destructor */ ~Rectangle() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** */ virtual double ComputeEuclideanDistanceMetricToSegment(VertexType q1, VertexType q2, VertexType p) const; /** */ private: Rectangle(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ValueType m_Orientation; ValueType m_Width; VertexListPointerType m_VertexList; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRectangle.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbRectangle.txx000066400000000000000000000127611301006202600237560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRectangle_txx #define otbRectangle_txx #include "otbRectangle.h" namespace otb { /** * Check whether point is strictly inside the polygon. * \param point The point to check. * \return True if the point is inside the polygon. */ template bool Rectangle ::IsInside(VertexType point) const { /*Iterate through the inputVertexList*/ if (m_VertexList->Size() < 2) itkGenericExceptionMacro( << "Rectangle needs TWO vertex, up-to-date the start and the end of the segments with AdDVertex Method "); VertexListConstIteratorType it = m_VertexList->Begin(); VertexType p1 = it.Value(); ++it; VertexType p2 = it.Value(); /** Compute Length of the rectangle*/ double lengthSeg = vcl_sqrt((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1])); /** Orthogonal segment containing the middle of the segment */ VertexType middleP; middleP[0] = (p1[0] + p2[0]) / 2.; middleP[1] = (p1[1] + p2[1]) / 2.; VertexType corner; corner[0] = middleP[0] + (m_Width / 2) * vcl_sin(m_Orientation); corner[1] = middleP[1] - (m_Width / 2) * vcl_cos(m_Orientation); /** Compute the distance to the orthogonal median of the rectangle*/ if (this->ComputeEuclideanDistanceMetricToSegment(p1, p2, point) - (m_Width / 2.) < 1e-10 && this->ComputeEuclideanDistanceMetricToSegment(middleP, corner, point) - (lengthSeg / 2.) < 1e-10) return true; else return false; } /** * Method to compute the distance between a point and a segment */ template double Rectangle ::ComputeEuclideanDistanceMetricToSegment(VertexType q1, VertexType q2, VertexType p) const { double Xq1 = q1[0]; double Yq1 = q1[1]; double Xq2 = q2[0]; double Yq2 = q2[1]; double xp = p[0]; double yp = p[1]; double SegmentLength = vcl_sqrt((Xq1 - Xq2) * (Xq1 - Xq2) + (Yq1 - Yq2) * (Yq1 - Yq2)); double CrossProduct = Xq1 * Yq2 - Xq2 * Yq1; double Num = vcl_abs(xp * (Yq1 - Yq2) + yp * (Xq2 - Xq1) + CrossProduct); /** distance from Point P to Segment Q1Q2*/ return (Num / SegmentLength); } /** * Method to compute the Bounding region of a rectangle */ template typename Rectangle:: RegionType Rectangle ::GetBoundingRegion() const { VertexListConstIteratorType it = m_VertexList->Begin(); VertexType p1 = it.Value(); ++it; VertexType p2 = it.Value(); /** Compute the four corners of the recatangle*/ double dx = vcl_cos(m_Orientation); double dy = vcl_sin(m_Orientation); double halfWidth = m_Width / 2; VertexListPointerType cornersVertex = VertexListType::New(); VertexType tempCorner; tempCorner[0] = p1[0] + dy * halfWidth; tempCorner[1] = p1[1] - dx * halfWidth; cornersVertex->InsertElement(cornersVertex->Size(), tempCorner); tempCorner[0] = p1[0] - dy * halfWidth; tempCorner[1] = p1[1] + dx * halfWidth; cornersVertex->InsertElement(cornersVertex->Size(), tempCorner); tempCorner[0] = p2[0] + dy * halfWidth; tempCorner[1] = p2[1] - dx * halfWidth; cornersVertex->InsertElement(cornersVertex->Size(), tempCorner); tempCorner[0] = p2[0] - dy * halfWidth; tempCorner[1] = p2[1] + dx * halfWidth; cornersVertex->InsertElement(cornersVertex->Size(), tempCorner); /** Compute the bounding region*/ RegionType region; typename RegionType::SizeType size; typename RegionType::IndexType index; typename RegionType::IndexType maxId; size.Fill(0); index.Fill(0); maxId.Fill(0); VertexListConstIteratorType itCorners = cornersVertex->Begin(); long int x = 0, y = 0; if (cornersVertex->Size() > 0) { x = static_cast(itCorners.Value()[0]); y = static_cast(itCorners.Value()[1]); index[0] = x; index[1] = y; ++itCorners; while (itCorners != cornersVertex->End()) { x = static_cast(itCorners.Value()[0]); y = static_cast(itCorners.Value()[1]); // Index search if (x < index[0]) { index[0] = x; } if (y < index[1]) { index[1] = y; } // Max Id search for size computation if (x > maxId[0]) { maxId[0] = x; } if (y > maxId[1]) { maxId[1] = y; } ++itCorners; } size[0] = maxId[0] - index[0]; size[1] = maxId[1] - index[1]; } region.SetSize(size); region.SetIndex(index); return region; } /* * Method add vertex * */ template void Rectangle ::AddVertex(const ContinuousIndexType& vertex) { if (m_VertexList->Size() > 1) itkGenericExceptionMacro( << "Rectangle needs only TWO vertex, a width and an orientation "); m_VertexList->InsertElement(m_VertexList->Size(), vertex); } /** * PrintSelf Method */ template void Rectangle ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "Vertices: " << m_VertexList << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbStandardFilterWatcher.h000066400000000000000000000050231301006202600256730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStandardFilterWatcher_h #define otbStandardFilterWatcher_h #include "otbFilterWatcherBase.h" namespace otb { /** \class StandardFilterWatcher * \brief This class shows the percentage progress execution * of the pipeline filtering process * * This class is based on Observer design patter * Abstract class ProcessObject is the subject * Event are observers * * Usage example: * * \code * typedef itk::BinaryThresholdImageFilter FilterType; * FilterType::Pointer thresholdFilter = FilterType::New(); * * StandardFilterWatcher watcher(thresholdFilter, "Threshold"); * \endcode * * \see itk::SimpleFilterWatcher * \see otb::fltkFilterWatcher * * \ingroup OTBCommon */ class OTBCommon_EXPORT StandardFilterWatcher : public FilterWatcherBase { public: /** Constructor. Takes a ProcessObject to monitor and an optional * comment string that is prepended to each event message. */ StandardFilterWatcher(itk::ProcessObject* process, const char *comment = ""); StandardFilterWatcher(itk::ProcessObject* process, const std::string& comment = ""); /** Default constructor */ StandardFilterWatcher() : m_StarsCount(0) {}; /** Copy constructor */ StandardFilterWatcher(const StandardFilterWatcher&); /** operator= */ void operator =(const StandardFilterWatcher&); /** Get/Set number of stars */ void SetStars(int count) { m_StarsCount = count; } const int& GetStars() const { return m_StarsCount; } protected: /** Callback method to show the ProgressEvent */ void ShowProgress() ITK_OVERRIDE; /** Callback method to show the StartEvent */ void StartFilter() ITK_OVERRIDE; /** Callback method to show the EndEvent */ void EndFilter() ITK_OVERRIDE; private: /** Stars coutning */ int m_StarsCount; int m_CurrentNbStars; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbStandardOneLineFilterWatcher.h000066400000000000000000000046361301006202600271560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStandardOneLineFilterWatcher_h #define otbStandardOneLineFilterWatcher_h #include "otbFilterWatcherBase.h" namespace otb { /** \class StandardOneLineFilterWatcher * \brief This class shows the percentage progress execution * of the pipeline filtering process * * This class is based on Observer design patter * Abstract class ProcessObject is the subject * Event are observers * * Usage example: * * \code * typedef itk::BinaryThresholdImageFilter FilterType; * FilterType::Pointer thresholdFilter = FilterType::New(); * * StandardOneLineFilterWatcher watcher(thresholdFilter, "Threshold"); * \endcode * * \see itk::SimpleFilterWatcher * \see otb::fltkFilterWatcher * * \ingroup OTBCommon */ class OTBCommon_EXPORT StandardOneLineFilterWatcher : public FilterWatcherBase { public: /** Constructor. Takes a ProcessObject to monitor and an optional * comment string that is prepended to each event message. */ StandardOneLineFilterWatcher(itk::ProcessObject* process, const char *comment = ""); StandardOneLineFilterWatcher(itk::ProcessObject* process, const std::string& comment = ""); /** Default constructor */ StandardOneLineFilterWatcher(); /** Get/Set number of stars */ void SetStars(int count) { m_StarsCount = count; } const int& GetStars() const { return m_StarsCount; } protected: /** Callback method to show the ProgressEvent */ void ShowProgress() ITK_OVERRIDE; /** Callback method to show the StartEvent */ void StartFilter() ITK_OVERRIDE; /** Callback method to show the EndEvent */ void EndFilter() ITK_OVERRIDE; private: /** Stars coutning */ int m_StarsCount; int m_CurrentNbStars; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbStandardWriterWatcher.h000066400000000000000000000062371301006202600257320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStandardWriterWatcher_h #define otbStandardWriterWatcher_h #include "otbWriterWatcherBase.h" namespace otb { /** \class StandardWriterWatcher * \brief This class shows the percentage progress execution * of the pipeline filtering process * * This class is based on Observer design pattern * Abstract class ProcessObject is the subject * Event are observers * * Usage example: * * \code * typedef itk::BinaryThresholdImageWriter WriterType; * WriterType::Pointer thresholdWriter = WriterType::New(); * * StandardWriterWatcher watcher(thresholdWriter, "Threshold"); * \endcode * * \see itk::SimpleWriterWatcher * \see otb::fltkWriterWatcher * * \ingroup OTBCommon */ class OTBCommon_EXPORT StandardWriterWatcher : public WriterWatcherBase { public: /** Constructor. Takes a ProcessObject to monitor and an optional * comment string that is prepended to each event message. */ StandardWriterWatcher(itk::ProcessObject* process, const char *comment = ""); StandardWriterWatcher(itk::ProcessObject* process, itk::ProcessObject * source, const char *comment = ""); StandardWriterWatcher(itk::ProcessObject* process, const std::string& comment = ""); StandardWriterWatcher(itk::ProcessObject* process, itk::ProcessObject * source, const std::string& comment = ""); /** Default constructor */ StandardWriterWatcher() : m_StarsCount(0) {}; /** Copy constructor */ StandardWriterWatcher(const StandardWriterWatcher&); /** operator= */ void operator =(const StandardWriterWatcher&); /** Get/Set number of stars */ void SetStars(int count) { m_StarsCount = count; } const unsigned int& GetStars() const { return m_StarsCount; } protected: /** Callback method to show the ProgressEvent */ void ShowWriterProgress() ITK_OVERRIDE; /** Callback method to show the StartEvent */ void StartWriter() ITK_OVERRIDE; /** Callback method to show the EndEvent */ void EndWriter() ITK_OVERRIDE; /** Callback method to show the ProgressEvent */ void ShowFilterProgress() ITK_OVERRIDE; /** Callback method to show the StartEvent */ void StartFilter() ITK_OVERRIDE {} /** Callback method to show the EndEvent */ void EndFilter() ITK_OVERRIDE {} /** This is the method invoked by ShowFilterProgress() and ShowWriterProgress() */ virtual void ShowProgress(); private: /** Stars coutning */ unsigned int m_StarsCount; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbSubsampledImageRegionConstIterator.h000066400000000000000000000224151301006202600304020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSubsampledImageRegionConstIterator_h #define otbSubsampledImageRegionConstIterator_h #include "itkImageRegionConstIterator.h" namespace otb { /** SubsampledImageRegionConstIterator * \brief Regular subsample iterator over an image * * This iterator is a itk::ImageRegionConstIterator that perform a subsampled * scan over an image. It runs one pixel over X (in row, line, slice... dimensions), * if X is the (integer) value of the SubsampleFactor. * * Specific value of the subsample factor may be given for each dimension. * * \ingroup ImageIterator * \sa WaveletFilterBank */ template class ITK_EXPORT SubsampledImageRegionConstIterator : public itk::ImageRegionConstIterator { public: /** Standard typedef. */ typedef SubsampledImageRegionConstIterator Self; typedef itk::ImageRegionConstIterator Superclass; /** Run-time type information (and related methods). */ itkTypeMacro(SubsampledImageRegionConstIterator, ImageRegionConstIterator); /** Dimension of the image the iterator walks. This constant is needed so * functions that are templated over image iterator type (as opposed to * being templated over pixel type and dimension) can have compile time * access to the dimension of the image that the iterator walks. */ itkStaticConstMacro(ImageIteratorDimension, unsigned int, Superclass::ImageIteratorDimension); /** Index typedef support. While this was already typdef'ed in the superclass * it needs to be redone here for this subclass to compile properly with gcc. */ typedef typename Superclass::IndexType IndexType; /** Size typedef support. While this was already typdef'ed in the superclass * it needs to be redone here for this subclass to compile properly with gcc. */ typedef typename Superclass::SizeType SizeType; /** Region typedef support. */ typedef typename Superclass::RegionType RegionType; /** Image typedef support. While this was already typdef'ed in the superclass * it needs to be redone here for this subclass to compile properly with gcc. */ typedef typename Superclass::ImageType ImageType; /** Offset typedef support. This explicit redefinition allows Setting/Getting * the location of the iterator. */ //typedef typename Superclass::OffsetType OffsetType; typedef unsigned long OffsetType; /** PixelContainer typedef support. Used to refer to the container for * the pixel data. While this was already typdef'ed in the superclass * it needs to be redone here for this subclass to compile properly with gcc. */ typedef typename Superclass::PixelContainer PixelContainer; typedef typename Superclass::PixelContainerPointer PixelContainerPointer; /** Internal Pixel Type */ typedef typename Superclass::InternalPixelType InternalPixelType; /** External Pixel Type */ typedef typename Superclass::PixelType PixelType; /** Accessor type that convert data between internal and external * representations. */ typedef typename Superclass::AccessorType AccessorType; /** Index value used for pixel location */ //typedef typename Superclass::IndexValueType IndexValueType; typedef typename IndexType::IndexValueType IndexValueType; /** Default constructor. Needed since we provide a cast constructor. */ SubsampledImageRegionConstIterator(); /** Constructor establishes an iterator to walk a particular image and a * particular region of that image. */ SubsampledImageRegionConstIterator (const ImageType * ptr, const RegionType ®ion); /** Constructor that can be used to cast from an ImageIterator to an * SubsampledImageRegionConstIterator. Many routines return an ImageIterator * but for a particular task, you may want an SubsampledImageRegionConstIterator. * Rather than provide overloaded APIs that return different types of Iterators, itk * returns ImageIterators and uses constructors to cast from an * ImageIterator to a SubsampledImageRegionConstIterator. */ SubsampledImageRegionConstIterator(const itk::ImageIterator &it); /** Constructor that can be used to cast from an ImageConstIterator to an * SubsampledImageRegionConstIterator. Many routines return an ImageIterator * but for a particular task, you may want an SubsampledImageRegionConstIterator. * Rather than provide overloaded APIs that return different types of Iterators, itk * returns ImageIterators and uses constructors to cast from an * ImageIterator to a SubsampledImageRegionConstIterator. */ SubsampledImageRegionConstIterator(const itk::ImageConstIterator &it); /** Set an isotropic subsampling factor */ void SetSubsampleFactor (IndexValueType factor); /** Set / Get the subsample factor */ void SetSubsampleFactor(const IndexType& factor); const IndexType& GetSubsampleFactor() const { return this->m_SubsampleFactor; } /** Move an iterator to the beginning of the region. "Begin" is * defined as the first pixel in the region. */ void GoToBegin(); /** Move an iterator to the end of the region. "End" is defined as * one pixel past the last pixel of the region. */ void GoToEnd(); /** Is the iterator at the beginning of the region? * "Begin" is defined here as before the first pixel * of the region. * On the contrary to Superclasses, now you cannot get * *it even if IsAtBegin() is true!!! */ bool IsAtBegin(void) const { return (this->m_Offset <= m_SubSampledBeginOffset); } /** Is the iterator at the end of the region? * "End" is defined as past the last candidate pixel * of the region (under the subsample point of view). * * For instance, if in 1D, the Size is 10 with a subsample * factor of 4, the last candidate offset would be 8. */ bool IsAtEnd(void) const { return (this->m_Offset >= m_SubSampledEndOffset); } /** Set the index. * It is moved to the next available (usable) index. * \sa GetIndex */ void SetIndex(const IndexType& ind) ITK_OVERRIDE; /** Get the Index. */ IndexType GetIndex() const { return Superclass::GetIndex(); } /** Increment (prefix) the fastest moving dimension of the iterator's index. * This operator will constrain the iterator within the region (i.e. the * iterator will automatically wrap from the end of the row of the region * to the beginning of the next row of the region) up until the iterator * tries to moves past the last pixel of the region. Here, the iterator * will be set to be one pixel past the end of the region. * \sa operator++(int) */ Self & operator ++() { // On the contrary to itk::ImageRegionConstIterator, m_Offset to // not incremented before the test if (this->m_Offset + m_SubsampleFactor[0] >= this->m_SpanEndOffset) { this->Increment(); } else { // Now, the increment is performed this->m_Offset += m_SubsampleFactor[0]; } return *this; } /** Decrement (prefix) the fastest moving dimension of the iterator's index. * This operator will constrain the iterator within the region (i.e. the * iterator will automatically wrap from the beginning of the row of the region * to the end of the next row of the region) up until the iterator * tries to moves past the first pixel of the region. Here, the iterator * will be set to be one pixel past the beginning of the region. * \sa operator--(int) */ Self & operator --() { // On the contrary to itk::ImageRegionConstIterator, m_Offset // is not decremented here (it may become negative!) if (this->m_Offset < this->m_SpanBeginOffset + m_SubsampleFactor[0]) { this->Decrement(); } else { // Now we can this->m_Offset -= m_SubsampleFactor[0]; } return *this; } /** This iterator give the possibility to Set/Get the current location if scanning. * No Bound checking is performed when setting the position. */ void SetOffset(const OffsetType& offset); OffsetType GetOffset() const { return this->m_Offset; } /** GenerateOutputInformation. * In order to help copy into a new Image, give the new region parameters */ RegionType GenerateOutputInformation() const; protected: IndexType m_SubsampleFactor; unsigned long m_SubSampledBeginOffset; //unsigned long m_SubSampledReverseEndOffset; long m_SubSampledEndOffset; IndexType m_FirstUsableIndex; IndexType m_LastUsableIndex; private: void Increment(); // jump in a direction other than the fastest moving void Decrement(); // go back in a direction other than the fastest moving }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSubsampledImageRegionConstIterator.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbSubsampledImageRegionConstIterator.txx000066400000000000000000000253621301006202600310020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSubsampledImageRegionConstIterator_txx #define otbSubsampledImageRegionConstIterator_txx #include "otbSubsampledImageRegionConstIterator.h" namespace otb { template SubsampledImageRegionConstIterator ::SubsampledImageRegionConstIterator() : itk::ImageRegionConstIterator () { m_SubsampleFactor.Fill(1); m_SubSampledEndOffset = this->m_EndOffset; const IndexType& startIndex = this->m_Region.GetIndex(); const SizeType& size = this->m_Region.GetSize(); for (unsigned int i = 0; i < ImageIteratorDimension; ++i) { m_FirstUsableIndex[i] = startIndex[i]; m_LastUsableIndex[i] = startIndex[i] + static_cast(size[i] - 1); } } template SubsampledImageRegionConstIterator ::SubsampledImageRegionConstIterator (const ImageType *ptr, const RegionType& region) : itk::ImageRegionConstIterator (ptr, region) { m_SubsampleFactor.Fill(1); m_SubSampledEndOffset = this->m_EndOffset; const IndexType& startIndex = this->m_Region.GetIndex(); const SizeType& size = this->m_Region.GetSize(); for (unsigned int i = 0; i < ImageIteratorDimension; ++i) { m_FirstUsableIndex[i] = startIndex[i]; m_LastUsableIndex[i] = startIndex[i] + static_cast(size[i] - 1); } } template SubsampledImageRegionConstIterator ::SubsampledImageRegionConstIterator(const itk::ImageIterator& it) : itk::ImageRegionConstIterator(it) { m_SubsampleFactor.Fill(1); m_SubSampledEndOffset = this->m_EndOffset; const IndexType& startIndex = this->m_Region.GetIndex(); const SizeType& size = this->m_Region.GetSize(); for (unsigned int i = 0; i < ImageIteratorDimension; ++i) { m_FirstUsableIndex[i] = startIndex[i]; m_LastUsableIndex[i] = startIndex[i] + static_cast(size[i] - 1); } } template SubsampledImageRegionConstIterator ::SubsampledImageRegionConstIterator(const itk::ImageConstIterator& it) : itk::ImageRegionConstIterator(it) { m_SubsampleFactor.Fill(1); const IndexType& startIndex = this->m_Region.GetIndex(); const SizeType& size = this->m_Region.GetSize(); for (unsigned int i = 0; i < ImageIteratorDimension; ++i) { m_FirstUsableIndex[i] = startIndex[i]; m_LastUsableIndex[i] = startIndex[i] + static_cast(size[i] - 1); } m_SubSampledEndOffset = this->m_Image->ComputeOffset(m_LastUsableIndex) + 1; } template void SubsampledImageRegionConstIterator ::SetSubsampleFactor(typename IndexType::IndexValueType factor) { IndexType index; index.Fill(factor); SetSubsampleFactor(index); } template void SubsampledImageRegionConstIterator ::SetSubsampleFactor(const IndexType& factor) { this->m_SubsampleFactor = factor; // Evaluate the last possible pixel. const IndexType& startIndex = this->m_Region.GetIndex(); const SizeType& size = this->m_Region.GetSize(); for (unsigned int i = 0; i < ImageIteratorDimension; ++i) { m_FirstUsableIndex[i] = startIndex[i]; while (m_FirstUsableIndex[i] != (m_SubsampleFactor[i] * (m_FirstUsableIndex[i] / m_SubsampleFactor[i]))) { ++m_FirstUsableIndex[i]; } m_LastUsableIndex[i] = startIndex[i] + static_cast(m_SubsampleFactor[i] * ((size[i] - 1) / m_SubsampleFactor[i])); } m_SubSampledBeginOffset = this->m_Image->ComputeOffset(m_FirstUsableIndex); //m_SubSampledReverseEndOffset = m_SubSampledBeginOffset - 1; m_SubSampledEndOffset = this->m_Image->ComputeOffset(m_LastUsableIndex) + 1; } template void SubsampledImageRegionConstIterator ::GoToBegin() { this->m_Offset = m_SubSampledBeginOffset; const SizeType& size = this->m_Region.GetSize(); this->m_SpanBeginOffset = this->m_Offset; this->m_SpanEndOffset = this->m_Offset + static_cast(m_SubsampleFactor[0] * ((size[0] - 1) / m_SubsampleFactor[0])) + 1; } template void SubsampledImageRegionConstIterator ::GoToEnd() { this->m_Offset = m_SubSampledEndOffset - 1; this->m_SpanEndOffset = this->m_Offset + 1; this->m_SpanBeginOffset = this->m_Offset - m_LastUsableIndex[0]; } template void SubsampledImageRegionConstIterator ::SetIndex(const IndexType& ind) { IndexType theIndex = ind; for (unsigned int i = 0; i < ImageIteratorDimension; ++i) { while (theIndex[i] != (m_SubsampleFactor[i] * (theIndex[i] / m_SubsampleFactor[i]))) { ++theIndex[i]; } if (theIndex[i] > static_cast(this->m_Region.GetIndex()[i] + this->m_Region.GetSize()[i])) { theIndex[i] = ind[i]; while (theIndex[i] != (m_SubsampleFactor[i] * (theIndex[i] / m_SubsampleFactor[i]))) { --theIndex[i]; } if (theIndex[i] < this->m_Region.GetIndex()[i]) theIndex[i] = ind[i]; } } //Superclass::SetIndex( theIndex ); OffsetType theOffset = this->m_Image->ComputeOffset(theIndex); SetOffset(theOffset); } template void SubsampledImageRegionConstIterator ::SetOffset(const OffsetType& offset) { this->m_Offset = offset; const SizeType& size = this->m_Region.GetSize(); this->m_SpanBeginOffset = this->m_Offset; this->m_SpanEndOffset = this->m_Offset + static_cast(m_SubsampleFactor[0] * ((size[0] - 1) / m_SubsampleFactor[0])) + 1; } template typename SubsampledImageRegionConstIterator::RegionType SubsampledImageRegionConstIterator ::GenerateOutputInformation() const { IndexType startIndex = this->m_Region.GetIndex(); SizeType size = this->m_Region.GetSize(); for (unsigned int i = 0; i < ImageIteratorDimension; ++i) { startIndex[i] /= m_SubsampleFactor[i]; --size[i]; size[i] /= m_SubsampleFactor[i]; ++size[i]; } RegionType newRegion; newRegion.SetIndex(startIndex); newRegion.SetSize(size); #if 0 // #ifndef NDEBUG std::cerr << "InitialImageSize ("; for (unsigned int i = 0; i < ImageIteratorDimension - 1; ++i) std::cerr << this->m_Region.GetSize()[i] << ", "; std::cerr << this->m_Region.GetSize()[ImageIteratorDimension - 1] << ") with index ("; for (unsigned int i = 0; i < ImageIteratorDimension - 1; ++i) std::cerr << this->m_Region.GetIndex()[i] << ", "; std::cerr << this->m_Region.GetIndex()[ImageIteratorDimension - 1] << ")\n"; std::cerr << "NewRegionSize ("; for (unsigned int i = 0; i < ImageIteratorDimension - 1; ++i) std::cerr << size[i] << ", "; std::cerr << size[ImageIteratorDimension - 1] << ") with index ("; for (unsigned int i = 0; i < ImageIteratorDimension - 1; ++i) std::cerr << startIndex[i] << ", "; std::cerr << startIndex[ImageIteratorDimension - 1] << ")\n"; std::cerr << "FirstIndex ("; for (unsigned int i = 0; i < ImageIteratorDimension - 1; ++i) std::cerr << m_FirstUsableIndex[i] << ", "; std::cerr << m_FirstUsableIndex[ImageIteratorDimension - 1] << ") offset="; std::cerr << m_SubSampledBeginOffset << "\n"; std::cerr << "LastIndex ("; for (unsigned int i = 0; i < ImageIteratorDimension - 1; ++i) std::cerr << m_LastUsableIndex[i] << ", "; std::cerr << m_LastUsableIndex[ImageIteratorDimension - 1] << ") offset="; std::cerr << m_SubSampledEndOffset << "\n"; #endif return newRegion; } template void SubsampledImageRegionConstIterator ::Increment() { // Get the index of the last pixel on the span (row) IndexType ind = this->m_Image->ComputeIndex( static_cast(this->m_Offset)); const IndexType& startIndex = this->m_Region.GetIndex(); const SizeType& size = this->m_Region.GetSize(); // Increment along a row, then wrap at the end of the region row. unsigned int dim; // Check to see if we are past the last pixel in the region // Note that ++ind[0] moves to the next pixel along the row. ind[0] += m_SubsampleFactor[0]; bool done = (ind[0] > m_LastUsableIndex[0]); for (unsigned int i = 1; done && i < ImageIteratorDimension; ++i) { done = (ind[i] >= m_LastUsableIndex[i]); } // if the iterator is outside the region (but not past region end) then // we need to wrap around the region dim = 0; if (!done) { while ((dim + 1 < ImageIteratorDimension) && (ind[dim] > m_LastUsableIndex[dim])) { ind[dim] = startIndex[dim]; ++dim; ind[dim] += m_SubsampleFactor[dim]; } } this->m_Offset = this->m_Image->ComputeOffset(ind); this->m_SpanEndOffset = this->m_Offset + static_cast(m_SubsampleFactor[0] * ((size[0] - 1) / m_SubsampleFactor[0])) + 1; this->m_SpanBeginOffset = this->m_Offset; } template void SubsampledImageRegionConstIterator ::Decrement() { // Get the index of the first pixel on the span (row) IndexType ind = this->m_Image->ComputeIndex(static_cast(this->m_Offset)); const IndexType& startIndex = this->m_Region.GetIndex(); // Deccrement along a row, then wrap at the beginning of the region row. bool done; unsigned int dim; // Check to see if we are past the first pixel in the region // Note that --ind[0] moves to the previous pixel along the row. ind[0] -= m_SubsampleFactor[0]; done = (ind[0] <= startIndex[0] - 1); for (unsigned int i = 1; done && i < ImageIteratorDimension; ++i) { done = (ind[i] <= startIndex[i]); } // if the iterator is outside the region (but not past region begin) then // we need to wrap around the region dim = 0; if (!done) { while ((dim < ImageIteratorDimension - 1) && (ind[dim] < startIndex[dim])) { ind[dim] = m_LastUsableIndex[dim]; ++dim; ind[dim] -= m_SubsampleFactor[dim]; } } this->m_Offset = this->m_Image->ComputeOffset(ind); this->m_SpanEndOffset = this->m_Offset + 1; this->m_SpanBeginOffset = this->m_Offset - m_LastUsableIndex[0]; } } // end of namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbSubsampledImageRegionIterator.h000066400000000000000000000070061301006202600273720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSubsampledImageRegionIterator_h #define otbSubsampledImageRegionIterator_h #include "otbSubsampledImageRegionConstIterator.h" namespace otb { /** \class SubsampledImageRegionIterator * \brief Regular subsample iterator over an image * * This iterator is a itk::ImageRegionConstIterator that perform a subsampled * scan over an image. It runs one pixel over X (in row, line, slice... dimensions), * if X is the (integer) value of the SubsampleFactor. * * It inherits from SubsampledImageRegionConstIterator and can modify the pixel values... * * \ingroup ImageIterator * \sa SubsampledImageRegionConstIterator * * \ingroup OTBCommon */ template class ITK_EXPORT SubsampledImageRegionIterator : public SubsampledImageRegionConstIterator { public: /** Standard typedef. */ typedef SubsampledImageRegionIterator Self; typedef SubsampledImageRegionConstIterator Superclass; /** Run-time type information (and related methods). */ itkTypeMacro(SubsampledImageRegionConstIterator, SubsampledImageRegionConstIterator); itkStaticConstMacro(ImageIteratorDimension, unsigned int, Superclass::ImageIteratorDimension); // typedef redefinition from superclass typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RegionType RegionType; typedef typename Superclass::OffsetType OffsetType; typedef typename Superclass::ImageType ImageType; typedef typename Superclass::PixelContainer PixelContainer; typedef typename Superclass::PixelContainerPointer PixelContainerPointer; typedef typename Superclass::InternalPixelType InternalPixelType; typedef typename Superclass::PixelType PixelType; typedef typename Superclass::AccessorType AccessorType; typedef typename Superclass::IndexValueType IndexValueType; // Constructors SubsampledImageRegionIterator() : SubsampledImageRegionConstIterator () {} SubsampledImageRegionIterator (const ImageType * ptr, const RegionType ®ion) : SubsampledImageRegionConstIterator (ptr, region) {} SubsampledImageRegionIterator(const itk::ImageIterator &it) : SubsampledImageRegionConstIterator (it) {} SubsampledImageRegionIterator(const itk::ImageConstIterator &it) : SubsampledImageRegionConstIterator (it) {} /** Set the current pixel value */ void Set(const PixelType& value) const { this->m_PixelAccessorFunctor.Set(*(const_cast( this->m_Buffer + this->m_Offset)), value); } PixelType& Value(void) { return *(const_cast(this->m_Buffer + this->m_Offset)); } }; // end of class } // end of namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbSystem.h000066400000000000000000000036471301006202600227450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSystem_h #define otbSystem_h #include #include #include "itksys/SystemTools.hxx" #include "itkMacro.h" #include "OTBCommonExport.h" namespace otb { /** \class System * \brief System operations. * * System operations, filename or strings manipulations, etc. * * * \ingroup OTBCommon */ class OTBCommon_EXPORT System { public: /** Standard class typedefs. */ typedef System Self; /** Get the root name */ static std::string GetRootName(const std::string& filename); /** Get list of file find in a directory */ static std::vector Readdir(const std::string& pszPath); /** Parse the hdf subset name */ static bool ParseHdfSubsetName(const std::string& id, std::string& key, std::string& name); /** Parse a filename with dataset information */ static bool ParseHdfFileName(const std::string& id, std::string& file, unsigned int& datasetNum); /** Parse a filename with additional information */ static bool ParseFileNameForAdditionalInfo(const std::string& id, std::string& file, unsigned int& addNum); /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. use * ParseFileNameForAdditionalInfo instead*/ static bool ParseFileNameForAdditonalInfo (const std::string& id, std::string& file, unsigned int& addNum) { return ParseFileNameForAdditionalInfo(id, file, addNum); } }; } // namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbUnaryFunctorImageFilter.h000066400000000000000000000056001301006202600262200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorImageFilter_h #define otbUnaryFunctorImageFilter_h #include "itkUnaryFunctorImageFilter.h" namespace otb { /** * \class UnaryFunctorImageFilter * \brief Implements pixel-wise generic operation on one image. * * Add the capability to change the number of channel when operation on * VectorImage compared to the itk::UnaryFunctorImageFilter * * The number of channel is provided by the functor: TFunction::OutputSize. If * this number is lower or equal to zero, the behavior of the itk::UnaryFunctorImageFilter * remains unchanged. * * \sa itk::UnaryFunctorImageFilter * * \ingroup OTBCommon */ template class ITK_EXPORT UnaryFunctorImageFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorImageFilter, itk::UnaryFunctorImageFilter); protected: UnaryFunctorImageFilter() {}; ~UnaryFunctorImageFilter() ITK_OVERRIDE {} /** UnaryFunctorImageFilter can produce an image which has a different number of bands * than its input image. As such, UnaryFunctorImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); outputPtr->SetNumberOfComponentsPerPixel( // propagate vector length info this->GetFunctor().GetOutputSize()); } private: UnaryFunctorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbUnaryFunctorNeighborhoodVectorImageFilter.h000066400000000000000000000125561301006202600317430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorNeighborhoodVectorImageFilter_h #define otbUnaryFunctorNeighborhoodVectorImageFilter_h #include "itkInPlaceImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" namespace otb { /** \class UnaryFunctorNeighborhoodVectorImageFilter * \brief Implements neighborhood-wise generic operation of one vector image. * * This class is parameterized over the types of the input image * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBCommon */ template class ITK_EXPORT UnaryFunctorNeighborhoodVectorImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorNeighborhoodVectorImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorNeighborhoodVectorImageFilter, InPlaceImageFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::RadiusType RadiusType; /** Set/Get Radius * The main difference from itkUnaryFunctiorNeighborhoodImageFilter * and otbBinaryFunctorNeighborhoodVectorImageFilter is that the * radius may not be square... */ itkSetMacro(Radius, RadiusType); itkGetMacro(Radius, RadiusType); protected: UnaryFunctorNeighborhoodVectorImageFilter(); ~UnaryFunctorNeighborhoodVectorImageFilter() ITK_OVERRIDE { } /** UnaryFunctorNeighborhoodVectorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Since the number of components per pixel depends on the radius range, one must reimplement * this method to set the proper number of component on the filter output. */ void GenerateOutputInformation(void) ITK_OVERRIDE; RadiusType m_Radius; private: UnaryFunctorNeighborhoodVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; // end of class } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorNeighborhoodVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbUnaryFunctorNeighborhoodVectorImageFilter.txx000066400000000000000000000053751301006202600323400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorNeighborhoodVectorImageFilter_txx #define otbUnaryFunctorNeighborhoodVectorImageFilter_txx #include "otbUnaryFunctorNeighborhoodVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template UnaryFunctorNeighborhoodVectorImageFilter ::UnaryFunctorNeighborhoodVectorImageFilter() { this->SetNumberOfRequiredInputs(1); this->InPlaceOff(); for ( unsigned int i = 0; i < InputImageDimension; ++i ) m_Radius[i] = 3; } /** * Generate the output information */ template void UnaryFunctorNeighborhoodVectorImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() ); } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void UnaryFunctorNeighborhoodVectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion( inputRegionForThread, outputRegionForThread ); NeighborhoodIteratorType neighInputIt ( this->GetRadius(), this->GetInput(), inputRegionForThread ); itk::ZeroFluxNeumannBoundaryCondition nbc; neighInputIt.OverrideBoundaryCondition(&nbc); neighInputIt.GoToBegin(); itk::ImageRegionIterator outputIt ( this->GetOutput(), outputRegionForThread ); outputIt.GoToBegin(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); while ( !outputIt.IsAtEnd() && !neighInputIt.IsAtEnd() ) { outputIt.Set( m_Functor( neighInputIt ) ); ++neighInputIt; ++outputIt; progress.CompletedPixel(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbUnaryFunctorVectorImageFilter.h000066400000000000000000000113331301006202600274030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorVectorImageFilter_h #define otbUnaryFunctorVectorImageFilter_h #include "itkInPlaceImageFilter.h" namespace otb { /** \class UnaryFunctorVectorImageFilter * \brief Implements neighborhood-wise generic operation of one vector image. * * This class is parameterized over the types of the input image * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBCommon */ template class ITK_EXPORT UnaryFunctorVectorImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorVectorImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorVectorImageFilter, InPlaceImageFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } protected: UnaryFunctorVectorImageFilter(); ~UnaryFunctorVectorImageFilter() ITK_OVERRIDE { } /** UnaryFunctorVectorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Since the number of components per pixel depends on the radius range, one must reimplement * this method to set the proper number of component on the filter output. */ void GenerateOutputInformation(void) ITK_OVERRIDE; private: UnaryFunctorVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; // end of class } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbUnaryFunctorVectorImageFilter.txx000066400000000000000000000046721301006202600300070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorVectorImageFilter_txx #define otbUnaryFunctorVectorImageFilter_txx #include "otbUnaryFunctorVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template UnaryFunctorVectorImageFilter ::UnaryFunctorVectorImageFilter() { this->SetNumberOfRequiredInputs(1); this->InPlaceOff(); } /** * Generate the output information */ template void UnaryFunctorVectorImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() ); } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void UnaryFunctorVectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion( inputRegionForThread, outputRegionForThread ); itk::ImageRegionConstIterator< InputImageType > inputIt ( this->GetInput(), inputRegionForThread ); inputIt.GoToBegin(); itk::ImageRegionIterator< OutputImageType > outputIt ( this->GetOutput(), outputRegionForThread ); outputIt.GoToBegin(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); while ( !outputIt.IsAtEnd() && !inputIt.IsAtEnd() ) { outputIt.Set( m_Functor( inputIt.Get() ) ); ++inputIt; ++outputIt; progress.CompletedPixel(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbUnaryFunctorWithIndexWithOutputSizeImageFilter.h000066400000000000000000000135721301006202600327630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorWithIndexWithOutputSizeImageFilter_h #define otbUnaryFunctorWithIndexWithOutputSizeImageFilter_h #include "itkImageToImageFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkProcessObject.h" namespace otb { /** \class UnaryFunctorWithIndexWithOutputSizeImageFilter * \brief Implements neighborhood-wise generic operation on image * * This class is parameterized over the input image type * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBCommon */ template class ITK_EXPORT UnaryFunctorWithIndexWithOutputSizeImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorWithIndexWithOutputSizeImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorWithIndexWithOutputSizeImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef typename Superclass::InputImageType InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { this->Modified(); return m_Functor; } /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } typedef itk::ImageRegionConstIteratorWithIndex IteratorType; protected: /** * Constructor */ UnaryFunctorWithIndexWithOutputSizeImageFilter(); /** * Destructor */ ~UnaryFunctorWithIndexWithOutputSizeImageFilter() ITK_OVERRIDE {} /** UnaryFunctorWithIndexWithOutputSizeImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Pad the input requested region by radius */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** UnaryFunctorWithIndexWithOutputSizeImageFilter can produce an image which has a different number of bands * than its input image. As such, UnaryFunctorImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); outputPtr->SetNumberOfComponentsPerPixel( // propagate vector length info this->GetFunctor().GetOutputSize()); } private: UnaryFunctorWithIndexWithOutputSizeImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorWithIndexWithOutputSizeImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbUnaryFunctorWithIndexWithOutputSizeImageFilter.txx000066400000000000000000000075411301006202600333560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorWithIndexWithOutputSizeImageFilter_txx #define otbUnaryFunctorWithIndexWithOutputSizeImageFilter_txx #include "otbUnaryFunctorWithIndexWithOutputSizeImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template UnaryFunctorWithIndexWithOutputSizeImageFilter ::UnaryFunctorWithIndexWithOutputSizeImageFilter() { this->SetNumberOfRequiredInputs(1); } template void UnaryFunctorWithIndexWithOutputSizeImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void UnaryFunctorWithIndexWithOutputSizeImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImagePointer inputPtr = dynamic_cast(ProcessObjectType::GetInput(0)); OutputImagePointer outputPtr = this->GetOutput(0); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators IteratorType inputIt = IteratorType(inputPtr, inputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { outputIt.Set(m_Functor(inputIt.Get(), inputIt.GetIndex())); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbUniformAlphaBlendingFunctor.h000066400000000000000000000050101301006202600270340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUniformAlphaBlendingFunctor_h #define otbUniformAlphaBlendingFunctor_h #include "itkMacro.h" #include "itkNumericTraits.h" #include "otbMath.h" namespace otb { namespace Functor { /** * \class UniformAlphaBlendingFunctor * \brief Implements simple blending * For each channel the blending function is as follows: * \f[ P_{o} = \alpha P_{i1} + (1 - \alpha) P_{i2} \f] * * \ingroup OTBCommon */ template class ITK_EXPORT UniformAlphaBlendingFunctor { public: UniformAlphaBlendingFunctor(): m_Alpha(0.5) {} ~UniformAlphaBlendingFunctor(){} typedef TInputPixel InputPixelType; typedef TInputPixel2 InputPixel2Type; typedef TOutputPixel OutputPixelType; typedef typename OutputPixelType::ValueType OutputInternalPixelType; void SetAlpha(double a) { //Keep alpha between 0 and 1 m_Alpha = a<0.0?0.0:(a>1.0?1.0:a); } double GetAlpha() const { return m_Alpha; } inline OutputPixelType operator ()(InputPixelType input1, InputPixel2Type input2) const { OutputPixelType resp; resp.Fill(itk::NumericTraits::max()); resp.SetRed(static_cast(vcl_floor(m_Alpha * static_cast(input1.GetRed()) + (1 - m_Alpha) * static_cast(input2.GetRed()) + 0.5))); resp.SetGreen(static_cast(vcl_floor(m_Alpha * static_cast(input1.GetGreen()) + (1 - m_Alpha) * static_cast(input2.GetGreen()) + 0.5))); resp.SetBlue(static_cast(vcl_floor(m_Alpha * static_cast(input1.GetBlue()) + (1 - m_Alpha) * static_cast(input2.GetBlue()) + 0.5))); return resp; } protected: double m_Alpha; }; } } #endif OTB-release-5.8/Modules/Core/Common/include/otbUtils.h000066400000000000000000000021331301006202600225460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUtils_h #define otbUtils_h #include "itkMacro.h" #include "OTBCommonExport.h" namespace otb { /** \class Utils * \brief Utils operations. * * Some useful utilities in use across the library * * * \ingroup OTBCommon */ namespace Utils { /** Check that the values for lon, lat are reasonable */ bool OTBCommon_EXPORT IsLonLatValid(double lon, double lat); template inline std::string ConvertToString (const T& v) { std::stringstream s; s << v; return s.str(); } } } // namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbVariableLengthVectorConverter.h000066400000000000000000000247031301006202600274170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVariableLengthVectorConverter_h #define otbVariableLengthVectorConverter_h #include "itkProcessObject.h" #include "itkVariableLengthVector.h" #include "itkFixedArray.h" #include "itkHistogram.h" #include "itkSmartPointer.h" namespace otb { /** * \class VariableLengthVectorConverter * \brief Convert any data container type into a VariableLengthVector. * * To be usable, the desired conversion must be implemented through * partial specialisation mechanism. * * * \ingroup OTBCommon */ //Base template< class TInputType, class TPrecisionType = double > class ITK_EXPORT VariableLengthVectorConverter : public itk::ProcessObject { public: /** Standard class typedefs */ typedef VariableLengthVectorConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VariableLengthVectorConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TPrecisionType OutputPrecisionType; typedef typename itk::VariableLengthVector OutputType; typedef TInputType InputType; OutputType Convert (InputType input) { OutputType output; output.SetSize(1); output.SetElement(0, static_cast(input)); return output; } protected: VariableLengthVectorConverter(){} ~VariableLengthVectorConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << "Attempt to use inexistant implementation of the converter!" << std::endl; } private: VariableLengthVectorConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; // VariableLengthVector template< class TInternalInputType, class TPrecisionType> class ITK_EXPORT VariableLengthVectorConverter< itk::VariableLengthVector< TInternalInputType > , TPrecisionType > : public itk::ProcessObject { public: /** Standard class typedefs */ typedef VariableLengthVectorConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VariableLengthVectorConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TPrecisionType OutputPrecisionType; typedef typename itk::VariableLengthVector OutputType; typedef itk::VariableLengthVector InputType; OutputType Convert (InputType input) { return static_cast(input); } protected: VariableLengthVectorConverter(){} ~VariableLengthVectorConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << "Attempt to use inexistant implementation of the converter!" << std::endl; } private: VariableLengthVectorConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; // Real Matrix template< class TInternalInputType, class TPrecisionType > class ITK_EXPORT VariableLengthVectorConverter >, TPrecisionType> : public itk::ProcessObject { public: /** Standard class typedefs */ typedef VariableLengthVectorConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VariableLengthVectorConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TPrecisionType OutputPrecisionType; typedef typename itk::VariableLengthVector OutputType; typedef typename std::vector > InputType; OutputType Convert(InputType input); protected: VariableLengthVectorConverter(){} ~VariableLengthVectorConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << "Converter: std::vector> => VariableLengthVector" << std::endl; } private: VariableLengthVectorConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; //Complex Matrix template< class TInternalInputType, class TPrecisionType > class ITK_EXPORT VariableLengthVectorConverter > >, TPrecisionType> : public itk::ProcessObject { public: /** Standard class typedefs */ typedef VariableLengthVectorConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VariableLengthVectorConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TPrecisionType OutputPrecisionType; typedef typename itk::VariableLengthVector OutputType; typedef typename std::vector > > InputType; OutputType Convert(InputType input); protected: VariableLengthVectorConverter(){} ~VariableLengthVectorConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << "Converter: std::vector>> => VariableLengthVector" << std::endl; } private: VariableLengthVectorConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; //Fixed Array template< class TInternalInputType, unsigned int VArrayDimension, class TPrecisionType > class ITK_EXPORT VariableLengthVectorConverter, TPrecisionType> : public itk::ProcessObject { public: /** Standard class typedefs */ typedef VariableLengthVectorConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VariableLengthVectorConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TPrecisionType OutputPrecisionType; typedef typename itk::VariableLengthVector OutputType; typedef typename itk::FixedArray InputType; OutputType Convert(InputType input); protected: VariableLengthVectorConverter(){} ~VariableLengthVectorConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << "Converter: itk::FixedArray => VariableLengthVector" << std::endl; } private: VariableLengthVectorConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; //Histogram template< class TPixel, class TPrecisionType > class ITK_EXPORT VariableLengthVectorConverter >, TPrecisionType> : public itk::ProcessObject { public: /** Standard class typedefs */ typedef VariableLengthVectorConverter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VariableLengthVectorConverter, ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TPrecisionType OutputPrecisionType; typedef typename itk::VariableLengthVector OutputType; typedef typename itk::SmartPointer< itk::Statistics::Histogram > InputType; OutputType Convert(InputType input); protected: VariableLengthVectorConverter(){} ~VariableLengthVectorConverter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << "Converter: itk::Statistics::Histogram => VariableLengthVector" << std::endl; } private: VariableLengthVectorConverter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; }// namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVariableLengthVectorConverter.txx" #endif #endif OTB-release-5.8/Modules/Core/Common/include/otbVariableLengthVectorConverter.txx000066400000000000000000000074371301006202600300200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVariableLengthVectorConverter_txx #define otbVariableLengthVectorConverter_txx #include "otbVariableLengthVectorConverter.h" #include namespace otb { // Real Matrix template< class TInternalInputType, class TPrecisionType > typename VariableLengthVectorConverter< std::vector >, TPrecisionType> ::OutputType VariableLengthVectorConverter< std::vector >, TPrecisionType> ::Convert(InputType input) { unsigned int p, q; unsigned int count = 0; unsigned int rsltIdx = 0; OutputType result; p = input.size(); for (unsigned int l=0; l(input.at(i).at(j)); rsltIdx ++; } } return result; } // Complex Matrix template< class TInternalInputType, class TPrecisionType > typename VariableLengthVectorConverter< std::vector > >, TPrecisionType> ::OutputType VariableLengthVectorConverter< std::vector > >, TPrecisionType> ::Convert(InputType input) { unsigned int p, q; unsigned int count = 0; unsigned int rsltIdx = 0; OutputType result; p = input.size(); for (unsigned int l=0; l(input.at(i).at(j).real()); rsltIdx ++; result[rsltIdx] = static_cast(input.at(i).at(j).imag()); rsltIdx ++; } } return result; } // Fixed Array template< class TInternalInputType, unsigned int VArrayDimension, class TPrecisionType > typename VariableLengthVectorConverter< itk::FixedArray, TPrecisionType> ::OutputType VariableLengthVectorConverter< itk::FixedArray, TPrecisionType> ::Convert(InputType input) { unsigned int rsltIdx = 0; OutputType result; result.SetSize(VArrayDimension); for (unsigned int i=0; i(input[i]); rsltIdx ++; } return result; } // Histogram template< class TPixel, class TPrecisionType > typename VariableLengthVectorConverter< itk::SmartPointer< itk::Statistics::Histogram >, TPrecisionType> ::OutputType VariableLengthVectorConverter< itk::SmartPointer< itk::Statistics::Histogram >, TPrecisionType> ::Convert(InputType input) { unsigned int rsltIdx = 0; itk::Size<1> nbBins; OutputType result; nbBins[0] = input->GetSize()[0]; result.SetSize(nbBins[0]); for (unsigned int i=0; i(input->GetFrequency(i)); rsltIdx ++; } return result; } } // namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbVectorImageToASImageAdaptor.h000066400000000000000000000044141301006202600266640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToASImageAdaptor_h #define otbVectorImageToASImageAdaptor_h #include "itkImageAdaptor.h" #include "otbVectorImageToASPixelAccessor.h" namespace otb { /** \class VectorImageToASImageAdaptor * \brief Presents an image of pixel type Vector as being and image of * FixelArray type. * * \ingroup ImageAdaptors * * * \ingroup OTBCommon */ template class ITK_EXPORT VectorImageToASImageAdaptor : public itk::ImageAdaptor > { public: /** Standard class typedefs. */ typedef VectorImageToASImageAdaptor Self; typedef itk::ImageAdaptor > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorImageToASImageAdaptor, ImageAdaptor); /** PixelContainer typedef support. Used to construct a container for * the pixel data. */ typedef typename Superclass::PixelContainer PixelContainer; typedef typename Superclass::PixelContainerPointer PixelContainerPointer; typedef typename Superclass::PixelContainerConstPointer PixelContainerConstPointer; protected: VectorImageToASImageAdaptor() {} ~VectorImageToASImageAdaptor() ITK_OVERRIDE {} private: VectorImageToASImageAdaptor(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbVectorImageToASPixelAccessor.h000066400000000000000000000036371301006202600271010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToASPixelAccessor_h #define otbVectorImageToASPixelAccessor_h #include "itkVector.h" namespace otb { namespace Accessor { /** * \class VectorImageToASPixelAccessor * \brief Give access to a Vector pixel type as if it were a RGBPixel type. * * This class is intended to be used as parameter of * an ImageAdaptor to make an Vector image appear as being * an image of RGB pixel type. * * \sa ImageAdaptor * \ingroup ImageAdaptors * * * \ingroup OTBCommon */ template class ITK_EXPORT VectorImageToASPixelAccessor { public: /** Standard class typedefs. */ typedef VectorImageToASPixelAccessor Self; /** External typedef. It defines the external aspect * that this class will exhibit */ typedef itk::FixedArray ExternalType; /** Internal typedef. It defines the internal real * representation of data */ typedef itk::Vector InternalType; /** Write access to the VectorToRGB component */ inline void Set(InternalType& output, const ExternalType& input) const { output[0] = input[0]; output[1] = input[1]; output[2] = input[2]; } /** Read access to the VectorToRGB component */ inline ExternalType Get(const InternalType& input) const { ExternalType rgb(input.GetDataPointer()); return rgb; } private: }; } // end namespace Accessor } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/include/otbWriterWatcherBase.h000066400000000000000000000111101301006202600250260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWriterWatcherBase_h #define otbWriterWatcherBase_h #include "itkCommand.h" #include "itkProcessObject.h" #include "itkTimeProbe.h" #include "OTBCommonExport.h" namespace otb { /** \class WriterWatcherBase * \brief This class is an abstract class * Provides an interface to progress task mechanic * * Implement your callbacks * \li ShowWriterProgress : callback called for each completed tile * \li StartWriter : callback called at the begin of tile writing * \li EndWriter : callback called at the end of tile writing * \li ShowFilterProgress : callback called for each completed pixel * \li StartFilter : callback called at the begin of filter execution for a given tile * \li EndFilter : callback called at the end of filter execution for a given tile * * * \ingroup OTBCommon */ class OTBCommon_EXPORT WriterWatcherBase { public: /** Constructor. Takes a ProcessObject to monitor and an optional * comment string that is prepended to each event message. */ WriterWatcherBase(itk::ProcessObject* process, const char *comment = ""); /** This other constructor is provided so that the user can set a different processing filter than the one just before process in the pipeline */ WriterWatcherBase(itk::ProcessObject* process, itk::ProcessObject * source, const char *comment = ""); /** Default constructor */ WriterWatcherBase(); /** Copy constructor */ WriterWatcherBase(const WriterWatcherBase&); /** operator= */ void operator =(const WriterWatcherBase&); /** Destructor. */ virtual ~WriterWatcherBase(); const char *GetNameOfClass() { return (m_Process.GetPointer() ? m_Process->GetNameOfClass() : "None"); } /** Methods to access member data */ /** Get a pointer to the process object being watched. */ itk::ProcessObject *GetProcess() { return m_Process.GetPointer(); } /** Get the comment for the watcher. */ std::string GetComment() const { return m_Comment; } /** Get a reference to the TimeProbe */ itk::TimeProbe& GetTimeProbe() { return m_TimeProbe; } protected: /** Callback method to show the ProgressEvent from the writer */ virtual void ShowWriterProgress() = 0; /** Callback method to show the StartEvent from the writer*/ virtual void StartWriter() = 0; /** Callback method to show the EndEvent from the writer*/ virtual void EndWriter() = 0; /** Callback method to show the ProgressEvent from the filter */ virtual void ShowFilterProgress() = 0; /** Callback method to show the StartEvent from the filter*/ virtual void StartFilter() = 0; /** Callback method to show the EndEvent from the filter*/ virtual void EndFilter() = 0; /** Computing time */ itk::TimeProbe m_TimeProbe; /** Associated comment */ std::string m_Comment; /** Abstract process object */ itk::ProcessObject::Pointer m_Process; /** Second abstract process object representing the source */ itk::ProcessObject::Pointer m_SourceProcess; /** Internal type */ typedef itk::SimpleMemberCommand CommandType; /** Start writer callback */ CommandType::Pointer m_StartWriterCommand; /** End writer callback */ CommandType::Pointer m_EndWriterCommand; /** Progress writer callback */ CommandType::Pointer m_ProgressWriterCommand; /** Start filter callback */ CommandType::Pointer m_StartFilterCommand; /** End writer callback */ CommandType::Pointer m_EndFilterCommand; /** Progress writer callback */ CommandType::Pointer m_ProgressFilterCommand; /** Start oberserver */ unsigned long m_StartWriterTag; /** End observer */ unsigned long m_EndWriterTag; /** Progress observer */ unsigned long m_ProgressWriterTag; /** Start oberserver */ unsigned long m_StartFilterTag; /** End observer */ unsigned long m_EndFilterTag; /** Progress observer */ unsigned long m_ProgressFilterTag; private: }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Common/otb-module.cmake000066400000000000000000000005161301006202600222210ustar00rootroot00000000000000set(DOCUMENTATION "TO BE DOCUMENTED") otb_module(OTBCommon ENABLE_SHARED DEPENDS OTBBoost OTBITK #Add dependency to OTBGDAL as GDAL module need to set OTB_USE_GDAL_20 before configuring otbConfigure.h OTBGDAL TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/Common/src/000077500000000000000000000000001301006202600177355ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Common/src/CMakeLists.txt000066400000000000000000000005601301006202600224760ustar00rootroot00000000000000set(OTBCommon_SRC otbStandardFilterWatcher.cxx otbFilterWatcherBase.cxx otbSystem.cxx otbStandardWriterWatcher.cxx otbUtils.cxx otbConfigurationManager.cxx otbStandardOneLineFilterWatcher.cxx otbWriterWatcherBase.cxx ) add_library(OTBCommon ${OTBCommon_SRC}) target_link_libraries(OTBCommon ${OTBITK_LIBRARIES} ) otb_module_target(OTBCommon) OTB-release-5.8/Modules/Core/Common/src/otbConfigurationManager.cxx000066400000000000000000000025141301006202600252720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbConfigurationManager.h" #include "itksys/SystemTools.hxx" #include namespace otb { std::string ConfigurationManager::GetDEMDirectory() { std::string svalue; itksys::SystemTools::GetEnv("OTB_DEM_DIRECTORY",svalue); return svalue; } std::string ConfigurationManager::GetGeoidFile() { std::string svalue; itksys::SystemTools::GetEnv("OTB_GEOID_FILE",svalue); return svalue; } ConfigurationManager::RAMValueType ConfigurationManager::GetMaxRAMHint() { std::string svalue; RAMValueType value = 128; if(itksys::SystemTools::GetEnv("OTB_MAX_RAM_HINT",svalue)) { unsigned long int tmp = strtoul(svalue.c_str(),ITK_NULLPTR,10); if(tmp) { value = static_cast(tmp); } } return value; } } OTB-release-5.8/Modules/Core/Common/src/otbConfigure.h.in000066400000000000000000000005721301006202600231450ustar00rootroot00000000000000#define OTB_VERSION_MAJOR @OTB_VERSION_MAJOR@ #define OTB_VERSION_MINOR @OTB_VERSION_MINOR@ #define OTB_VERSION_PATCH @OTB_VERSION_PATCH@ #define OTB_VERSION_STRING "@OTB_VERSION_STRING@" #cmakedefine OTB_CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS #cmakedefine OTB_BUILD_SHARED_LIBS /* Show developer debug messages */ #cmakedefine OTB_SHOW_ALL_MSG_DEBUG #cmakedefine OTB_USE_GDAL_20 OTB-release-5.8/Modules/Core/Common/src/otbFilterWatcherBase.cxx000066400000000000000000000116501301006202600245270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFilterWatcherBase.h" namespace otb { FilterWatcherBase ::FilterWatcherBase() : m_Comment("Not watching an object"), m_Process(ITK_NULLPTR), m_StartTag(0), m_EndTag(0), m_ProgressTag(0), m_Started(false), m_Ended(false) { } FilterWatcherBase ::FilterWatcherBase(itk::ProcessObject* process, const char *comment) : m_Comment(comment), m_Process(process), m_StartTag(0), m_EndTag(0), m_ProgressTag(0), m_Started(false), m_Ended(false) { // Create a series of commands m_StartFilterCommand = CommandType::New(); m_EndFilterCommand = CommandType::New(); m_ProgressFilterCommand = CommandType::New(); // Assign the callbacks m_StartFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::StartFilterCallback); m_EndFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::EndFilterCallback); m_ProgressFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::ShowProgressCallback); // Add the commands as observers m_StartTag = m_Process->AddObserver(itk::StartEvent(), m_StartFilterCommand); m_EndTag = m_Process->AddObserver(itk::EndEvent(), m_EndFilterCommand); m_ProgressTag = m_Process->AddObserver(itk::ProgressEvent(), m_ProgressFilterCommand); } FilterWatcherBase ::FilterWatcherBase(const FilterWatcherBase& watch) { // Remove any observers we have on the old process object if (m_Process) { m_Process->RemoveAllObservers(); } // Initialize state m_TimeProbe = watch.m_TimeProbe; m_Process = watch.m_Process; m_Comment = watch.m_Comment; m_StartTag = 0; m_EndTag = 0; m_ProgressTag = 0; m_Started = false; m_Ended = false; // Create a series of commands if (m_Process) { m_StartFilterCommand = CommandType::New(); m_EndFilterCommand = CommandType::New(); m_ProgressFilterCommand = CommandType::New(); // Assign the callbacks m_StartFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::StartFilterCallback); m_EndFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::EndFilterCallback); m_ProgressFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::ShowProgressCallback); // Add the commands as observers m_StartTag = m_Process->AddObserver(itk::StartEvent(), m_StartFilterCommand); m_EndTag = m_Process->AddObserver(itk::EndEvent(), m_EndFilterCommand); m_ProgressTag = m_Process->AddObserver(itk::ProgressEvent(), m_ProgressFilterCommand); } } void FilterWatcherBase ::operator =(const FilterWatcherBase& watch) { // Remove any observers we have on the old process object if (m_Process) { m_Process->RemoveAllObservers(); } // Initialize state m_TimeProbe = watch.m_TimeProbe; m_Process = watch.m_Process; m_Comment = watch.m_Comment; m_StartTag = 0; m_EndTag = 0; m_ProgressTag = 0; // Create a series of commands if (m_Process) { m_StartFilterCommand = CommandType::New(); m_EndFilterCommand = CommandType::New(); m_ProgressFilterCommand = CommandType::New(); // Assign the callbacks m_StartFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::StartFilterCallback); m_EndFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::EndFilterCallback); m_ProgressFilterCommand->SetCallbackFunction(this, &FilterWatcherBase::ShowProgressCallback); // Add the commands as observers m_StartTag = m_Process->AddObserver(itk::StartEvent(), m_StartFilterCommand); m_EndTag = m_Process->AddObserver(itk::EndEvent(), m_EndFilterCommand); m_ProgressTag = m_Process->AddObserver(itk::ProgressEvent(), m_ProgressFilterCommand); } } FilterWatcherBase ::~FilterWatcherBase() { // Remove any observers we have on the old process object if (m_Process) { m_Process->RemoveAllObservers(); } } } // end namespace otb OTB-release-5.8/Modules/Core/Common/src/otbStandardFilterWatcher.cxx000066400000000000000000000053251301006202600254170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStandardFilterWatcher.h" namespace otb { StandardFilterWatcher ::StandardFilterWatcher(itk::ProcessObject* process, const char *comment) : FilterWatcherBase(process, comment) { m_StarsCount = 50; m_CurrentNbStars = -1; } StandardFilterWatcher ::StandardFilterWatcher(itk::ProcessObject* process, const std::string& comment) : FilterWatcherBase(process, comment.c_str()) { m_StarsCount = 50; m_CurrentNbStars = -1; } StandardFilterWatcher ::StandardFilterWatcher(const StandardFilterWatcher& watch) : FilterWatcherBase(watch) { // Initialize state m_StarsCount = watch.m_StarsCount; m_CurrentNbStars = watch.m_CurrentNbStars; } void StandardFilterWatcher ::operator =(const StandardFilterWatcher& watch) { // Initialize state FilterWatcherBase::operator=(watch); m_StarsCount = watch.m_StarsCount; m_CurrentNbStars = watch.m_CurrentNbStars; } void StandardFilterWatcher ::ShowProgress() { if (m_Process) { int progressPercent = static_cast(m_Process->GetProgress() * 100); int nbStars = static_cast(m_Process->GetProgress() * m_StarsCount); int nbBlanks = m_StarsCount - nbStars; if (nbBlanks < 0) { nbBlanks = 0; } if (nbStars > m_StarsCount) { nbStars = m_StarsCount; } if (progressPercent > 100) { progressPercent = 100; } if (nbStars > m_CurrentNbStars) { std::string stars(nbStars, '*'); std::string blanks(nbBlanks, ' '); std::cout << "\rProcessing progress: " << progressPercent << "% [" << stars << blanks << "]" << std::flush; } m_CurrentNbStars = nbStars; } } void StandardFilterWatcher ::StartFilter() { m_TimeProbe.Start(); std::cout << (m_Process.GetPointer() ? m_Process->GetNameOfClass() : "None") << " \"" << m_Comment << "\" " << std::endl; } void StandardFilterWatcher ::EndFilter() { m_TimeProbe.Stop(); std::cout << std::endl << "Filter took " << m_TimeProbe.GetMean() << " seconds." << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Core/Common/src/otbStandardOneLineFilterWatcher.cxx000066400000000000000000000050231301006202600266640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStandardOneLineFilterWatcher.h" namespace otb { StandardOneLineFilterWatcher ::StandardOneLineFilterWatcher() : m_StarsCount(50), m_CurrentNbStars(-1) { } StandardOneLineFilterWatcher ::StandardOneLineFilterWatcher(itk::ProcessObject* process, const char *comment) : FilterWatcherBase(process, comment), m_StarsCount(50), m_CurrentNbStars(-1) { } StandardOneLineFilterWatcher ::StandardOneLineFilterWatcher(itk::ProcessObject* process, const std::string& comment) : FilterWatcherBase(process, comment.c_str()), m_StarsCount(50), m_CurrentNbStars(-1) { } void StandardOneLineFilterWatcher ::ShowProgress() { if (m_Process) { int progressPercent = static_cast(m_Process->GetProgress() * 100); int nbStars = static_cast(m_Process->GetProgress() * m_StarsCount); int nbBlanks = m_StarsCount - nbStars; if (nbBlanks < 0) { nbBlanks = 0; } if (nbStars > m_StarsCount) { nbStars = m_StarsCount; } if (progressPercent > 100) { progressPercent = 100; } if (nbStars > m_CurrentNbStars) { std::string stars(nbStars, '*'); std::string blanks(nbBlanks, ' '); std::cout << "\r" << m_Comment << ": " << progressPercent << "% [" << stars << blanks << "]" << std::flush; } m_CurrentNbStars = nbStars; } } void StandardOneLineFilterWatcher ::StartFilter() { m_TimeProbe.Start(); } void StandardOneLineFilterWatcher ::EndFilter() { m_TimeProbe.Stop(); // Ensure we don't depend on std::cout configuration std::ostringstream elapsedTime; elapsedTime.precision(1); elapsedTime << m_TimeProbe.GetMean(); std::cout << " (" << elapsedTime.str() << " seconds)" << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Core/Common/src/otbStandardWriterWatcher.cxx000066400000000000000000000077071301006202600254540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStandardWriterWatcher.h" namespace otb { StandardWriterWatcher ::StandardWriterWatcher(itk::ProcessObject* process, const char *comment) : WriterWatcherBase(process, comment) { m_StarsCount = 50; } StandardWriterWatcher ::StandardWriterWatcher(itk::ProcessObject* process, itk::ProcessObject * source, const char *comment) : WriterWatcherBase(process, source, comment) { m_StarsCount = 50; } StandardWriterWatcher ::StandardWriterWatcher(itk::ProcessObject* process, const std::string& comment) : WriterWatcherBase(process, comment.c_str()) { m_StarsCount = 50; } StandardWriterWatcher ::StandardWriterWatcher(itk::ProcessObject* process, itk::ProcessObject * source, const std::string& comment) : WriterWatcherBase(process, source, comment.c_str()) { m_StarsCount = 50; } StandardWriterWatcher ::StandardWriterWatcher(const StandardWriterWatcher& watch) : WriterWatcherBase(watch) { // Initialize state m_StarsCount = watch.m_StarsCount; } void StandardWriterWatcher ::operator =(const StandardWriterWatcher& watch) { // Initialize state WriterWatcherBase::operator=(watch); m_StarsCount = watch.m_StarsCount; } void StandardWriterWatcher ::ShowWriterProgress() { this->ShowProgress(); } void StandardWriterWatcher ::ShowFilterProgress() { this->ShowProgress(); } void StandardWriterWatcher ::ShowProgress() { std::ostringstream oss; oss.str(""); oss << "\r"; if (m_SourceProcess) { double progress = m_SourceProcess->GetProgress(); int progressPercent = static_cast(progress * 100); unsigned int nbStars = static_cast(progress * m_StarsCount); if(nbStars>m_StarsCount) { nbStars = m_StarsCount; } std::string stars(nbStars, '*'); std::string blanks(m_StarsCount - nbStars, ' '); oss << "Current Tile: "; if (progressPercent < 10) { oss << " "; } if (progressPercent < 100) { oss << " "; } oss << progressPercent << "% [" << stars << blanks << "] "; } if (m_Process) { double progress = m_Process->GetProgress(); int progressPercent = static_cast(progress * 100); unsigned int nbStars = static_cast(progress * m_StarsCount); if(nbStars>m_StarsCount) { nbStars = m_StarsCount; } std::string stars(nbStars, '*'); std::string blanks(m_StarsCount - nbStars, ' '); oss << "Writing: "; if (progressPercent < 10) { oss << " "; } if (progressPercent < 100) { oss << " "; } oss << progressPercent << "% [" << stars << blanks << "]" << std::flush; } std::cout << oss.str(); } void StandardWriterWatcher ::StartWriter() { m_TimeProbe.Start(); std::cout << "Writing task: " << " \"" << m_Comment << "\" " << std::endl; std::cout << "Writer type: " << (m_Process.GetPointer() ? m_Process->GetNameOfClass() : "None") << std::endl; std::cout << "Filter type: " << (m_SourceProcess.GetPointer() ? m_SourceProcess->GetNameOfClass() : "None") << std::endl; } void StandardWriterWatcher ::EndWriter() { m_TimeProbe.Stop(); std::cout << std::endl << "Writing task took " << m_TimeProbe.GetMean() << " seconds." << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Core/Common/src/otbSystem.cxx000066400000000000000000000137571301006202600224670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSystem.h" #include // strdup #include //toupper, tolower #include #if (defined(WIN32) || defined(WIN32CE)) && !defined(__CYGWIN__) && !defined(__MINGW32__) /*===================================================================== WIN32 / MSVC++ implementation *====================================================================*/ #ifndef WIN32CE # include #else # include #endif #else /*===================================================================== POSIX (Unix) implementation *====================================================================*/ #include #include #endif namespace otb { //GetRootName from uiig library. std::string System::GetRootName(const std::string& filename) { const std::string fileExt = itksys::SystemTools::GetFilenameLastExtension(filename); // Create a base filename // i.e Image.ent --> Image if (fileExt.length() > 0) { const std::string::size_type it = filename.find_last_of(fileExt); std::string baseName(filename, 0, it - fileExt.length() + 1); return (baseName); } //Default to return same as input when the extension is nothing (Analyze) return (filename); } #if (defined(WIN32) || defined(WIN32CE)) && !defined(__CYGWIN__) && !defined(__MINGW32__) /*===================================================================== WIN32 / MSVC++ implementation *====================================================================*/ std::vector System::Readdir(const std::string& pszPath) { struct _finddata_t c_file; long hFile; std::vector listFileFind; std::string pszFileSpec; std::string path(pszPath); if (pszPath.empty() == true) path = "."; pszFileSpec = path + "\\*.*"; if ((hFile = _findfirst(pszFileSpec.c_str(), &c_file)) != -1L) { do { listFileFind.push_back(c_file.name); } while (_findnext(hFile, &c_file) == 0); _findclose(hFile); } return listFileFind; } #else /*===================================================================== POSIX (Unix) implementation *====================================================================*/ /** * Read names in a directory. * * This function abstracts access to directory contains. It returns a * list of strings containing the names of files, and directories in this * directory. The resulting string list becomes the responsibility of the * application and should be freed with CSLDestroy() when no longer needed. * * Note that no error is issued via CPLError() if the directory path is * invalid, though NULL is returned. * * @param pszPath the relative, or absolute path of a directory to read. * @return The list of entries in the directory, or NULL if the directory * doesn't exist. */ std::vector System::Readdir(const std::string& pszPath) { DIR * hDir; std::vector listFileFind; struct dirent * psDirEntry; std::string path(pszPath); if (pszPath.empty() == true) path = "."; if ((hDir = opendir(path.c_str())) != ITK_NULLPTR) { while ((psDirEntry = readdir(hDir)) != ITK_NULLPTR) { listFileFind.push_back(psDirEntry->d_name); } closedir(hDir); } return listFileFind; } #endif /** From an hdf subset name such as: * SUBDATASET_7_NAME=HDF4_EOS:EOS_GRID:"file/MOD13Q1.A2010001.h17v05.005.2010028003734.hdf":MODIS_Grid_16DAY... * it will set key to SUBDATASET_7_NAME * and name to HDF4_EOS:EOS_GRID:"file/MOD13Q1.A2010001.h17v05.005.2010028003734.hdf":MODIS_Grid_16DAY... */ bool System::ParseHdfSubsetName(const std::string& id, std::string& key, std::string& name) { std::size_t pos = id.find("="); if (pos == std::string::npos) return false; key = id.substr(0, pos); name = id.substr(pos+1, id.size() - pos - 1); return true; } /** Parse and hdf filename indicating the dataset number * if id is filelocation/file.hdf:10 * it will return filelocation/file.hdf in file * and 10 in datasetNum */ bool System::ParseHdfFileName(const std::string& id, std::string& file, unsigned int& datasetNum) { std::size_t pos = id.rfind(":"); if (pos == std::string::npos) return false; std::string datasetNumString(id.substr(pos+1, id.size() - pos - 1)); datasetNum = atoi(datasetNumString.c_str()); // a value of 0 could be the sign that the conversion failed, we need to check that the character was really 0 if (datasetNum == 0) { if (datasetNumString.compare("0") != 0) { return false; } } file = id.substr(0, pos); return true; } /** Parse a filename indicating an additional information * if id is filelocation/file.***:10 * it will return filelocation/file.*** in file * and 10 in addNum additional */ bool System::ParseFileNameForAdditionalInfo(const std::string& id, std::string& file, unsigned int& addNum) { std::size_t pos = id.rfind(":"); if (pos == std::string::npos) return false; std::string addNumString(id.substr(pos+1, id.size() - pos - 1)); addNum = atoi(addNumString.c_str()); // a value of 0 could be the sign that the conversion failed, we need to check that the character was really 0 if (addNum == 0) { if (addNumString.compare("0") != 0) { return false; } } file = id.substr(0, pos); return true; } } OTB-release-5.8/Modules/Core/Common/src/otbUtils.cxx000066400000000000000000000015151301006202600222700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbUtils.h" #include namespace otb { namespace Utils { bool IsLonLatValid(double lon, double lat) { if (lon < -180.0) return false; if (lon > 180.0) return false; if (lat < -90.0) return false; if (lat > 90.0) return false; return true; } } } OTB-release-5.8/Modules/Core/Common/src/otbWriterWatcherBase.cxx000066400000000000000000000303111301006202600245510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWriterWatcherBase.h" namespace otb { WriterWatcherBase ::WriterWatcherBase() { // Initialize state m_Comment = "Not watching any object"; m_Process = ITK_NULLPTR; m_StartFilterTag = 0; m_EndFilterTag = 0; m_ProgressFilterTag = 0; m_StartWriterTag = 0; m_EndWriterTag = 0; m_ProgressWriterTag = 0; } WriterWatcherBase ::WriterWatcherBase(itk::ProcessObject* process, const char *comment) { // Initialize state m_Process = process; m_Comment = comment; // Create a series of commands m_StartWriterCommand = CommandType::New(); m_EndWriterCommand = CommandType::New(); m_ProgressWriterCommand = CommandType::New(); m_StartFilterCommand = CommandType::New(); m_EndFilterCommand = CommandType::New(); m_ProgressFilterCommand = CommandType::New(); // Assign the callbacks m_StartFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartFilter); m_EndFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndFilter); m_ProgressFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowFilterProgress); m_StartWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartWriter); m_EndWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndWriter); m_ProgressWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowWriterProgress); // Add the commands as observers m_StartWriterTag = m_Process->AddObserver(itk::StartEvent(), m_StartWriterCommand); m_EndWriterTag = m_Process->AddObserver(itk::EndEvent(), m_EndWriterCommand); m_ProgressWriterTag = m_Process->AddObserver(itk::ProgressEvent(), m_ProgressWriterCommand); m_StartFilterTag = 0; m_EndFilterTag = 0; m_ProgressFilterTag = 0; // Try to get the filter that is wired to m_Process. if (m_Process->GetInputs()[0]->GetSource()) { m_SourceProcess = m_Process->GetInputs()[0]->GetSource(); // Add the commands as observers m_StartFilterTag = m_SourceProcess->AddObserver(itk::StartEvent(), m_StartFilterCommand); m_EndFilterTag = m_SourceProcess->AddObserver(itk::EndEvent(), m_EndFilterCommand); m_ProgressFilterTag = m_SourceProcess->AddObserver(itk::ProgressEvent(), m_ProgressFilterCommand); } } WriterWatcherBase ::WriterWatcherBase(itk::ProcessObject* process, itk::ProcessObject * source, const char *comment) { // Initialize state m_Process = process; m_Comment = comment; // Create a series of commands m_StartWriterCommand = CommandType::New(); m_EndWriterCommand = CommandType::New(); m_ProgressWriterCommand = CommandType::New(); m_StartFilterCommand = CommandType::New(); m_EndFilterCommand = CommandType::New(); m_ProgressFilterCommand = CommandType::New(); // Assign the callbacks m_StartFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartFilter); m_EndFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndFilter); m_ProgressFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowFilterProgress); m_StartWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartWriter); m_EndWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndWriter); m_ProgressWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowWriterProgress); // Add the commands as observers m_StartWriterTag = m_Process->AddObserver(itk::StartEvent(), m_StartWriterCommand); m_EndWriterTag = m_Process->AddObserver(itk::EndEvent(), m_EndWriterCommand); m_ProgressWriterTag = m_Process->AddObserver(itk::ProgressEvent(), m_ProgressWriterCommand); m_SourceProcess = source; // Add the commands as observers m_StartFilterTag = m_SourceProcess->AddObserver(itk::StartEvent(), m_StartFilterCommand); m_EndFilterTag = m_SourceProcess->AddObserver(itk::EndEvent(), m_EndFilterCommand); m_ProgressFilterTag = m_SourceProcess->AddObserver(itk::ProgressEvent(), m_ProgressFilterCommand); } WriterWatcherBase ::WriterWatcherBase(const WriterWatcherBase& watch) { // Remove any observers we have on the old process object if (m_Process) { if (m_StartWriterCommand) { m_Process->RemoveObserver(m_StartWriterTag); } if (m_EndWriterCommand) { m_Process->RemoveObserver(m_EndWriterTag); } if (m_ProgressWriterCommand) { m_Process->RemoveObserver(m_ProgressWriterTag); } } if (m_SourceProcess) { if (m_StartFilterCommand) { m_SourceProcess->RemoveObserver(m_StartFilterTag); } if (m_EndFilterCommand) { m_SourceProcess->RemoveObserver(m_EndFilterTag); } if (m_ProgressFilterCommand) { m_SourceProcess->RemoveObserver(m_ProgressFilterTag); } } // Initialize state m_TimeProbe = watch.m_TimeProbe; m_Process = watch.m_Process; m_SourceProcess = watch.m_SourceProcess; m_Comment = watch.m_Comment; m_StartFilterTag = 0; m_EndFilterTag = 0; m_ProgressFilterTag = 0; m_StartWriterTag = 0; m_EndWriterTag = 0; m_ProgressWriterTag = 0; // Create a series of commands if (m_Process) { m_StartWriterCommand = CommandType::New(); m_EndWriterCommand = CommandType::New(); m_ProgressWriterCommand = CommandType::New(); // Assign the callbacks m_StartWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartWriter); m_EndWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndWriter); m_ProgressWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowWriterProgress); // Add the commands as observers m_StartWriterTag = m_Process->AddObserver(itk::StartEvent(), m_StartWriterCommand); m_EndWriterTag = m_Process->AddObserver(itk::EndEvent(), m_EndWriterCommand); m_ProgressWriterTag = m_Process->AddObserver(itk::ProgressEvent(), m_ProgressWriterCommand); } if (m_SourceProcess) { m_StartFilterCommand = CommandType::New(); m_EndFilterCommand = CommandType::New(); m_ProgressFilterCommand = CommandType::New(); // Assign the callbacks m_StartFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartFilter); m_EndFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndFilter); m_ProgressFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowFilterProgress); // Add the commands as observers m_StartFilterTag = m_SourceProcess->AddObserver(itk::StartEvent(), m_StartFilterCommand); m_EndFilterTag = m_SourceProcess->AddObserver(itk::EndEvent(), m_EndFilterCommand); m_ProgressFilterTag = m_SourceProcess->AddObserver(itk::ProgressEvent(), m_ProgressFilterCommand); } } void WriterWatcherBase ::operator =(const WriterWatcherBase& watch) { // Remove any observers we have on the old process object if (m_Process) { if (m_StartWriterCommand) { m_Process->RemoveObserver(m_StartWriterTag); } if (m_EndWriterCommand) { m_Process->RemoveObserver(m_EndWriterTag); } if (m_ProgressWriterCommand) { m_Process->RemoveObserver(m_ProgressWriterTag); } } if (m_SourceProcess) { if (m_StartFilterCommand) { m_SourceProcess->RemoveObserver(m_StartFilterTag); } if (m_EndFilterCommand) { m_SourceProcess->RemoveObserver(m_EndFilterTag); } if (m_ProgressFilterCommand) { m_SourceProcess->RemoveObserver(m_ProgressFilterTag); } } // Initialize state m_TimeProbe = watch.m_TimeProbe; m_Process = watch.m_Process; m_SourceProcess = watch.m_SourceProcess; m_Comment = watch.m_Comment; m_StartFilterTag = 0; m_EndFilterTag = 0; m_ProgressFilterTag = 0; m_StartWriterTag = 0; m_EndWriterTag = 0; m_ProgressWriterTag = 0; // Create a series of commands if (m_Process) { m_StartWriterCommand = CommandType::New(); m_EndWriterCommand = CommandType::New(); m_ProgressWriterCommand = CommandType::New(); // Assign the callbacks m_StartWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartWriter); m_EndWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndWriter); m_ProgressWriterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowWriterProgress); // Add the commands as observers m_StartWriterTag = m_Process->AddObserver(itk::StartEvent(), m_StartWriterCommand); m_EndWriterTag = m_Process->AddObserver(itk::EndEvent(), m_EndWriterCommand); m_ProgressWriterTag = m_Process->AddObserver(itk::ProgressEvent(), m_ProgressWriterCommand); } if (m_SourceProcess) { m_StartFilterCommand = CommandType::New(); m_EndFilterCommand = CommandType::New(); m_ProgressFilterCommand = CommandType::New(); // Assign the callbacks m_StartFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::StartFilter); m_EndFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::EndFilter); m_ProgressFilterCommand->SetCallbackFunction(this, &WriterWatcherBase::ShowFilterProgress); // Add the commands as observers m_StartFilterTag = m_SourceProcess->AddObserver(itk::StartEvent(), m_StartFilterCommand); m_EndFilterTag = m_SourceProcess->AddObserver(itk::EndEvent(), m_EndFilterCommand); m_ProgressFilterTag = m_SourceProcess->AddObserver(itk::ProgressEvent(), m_ProgressFilterCommand); } } WriterWatcherBase ::~WriterWatcherBase() { // Remove any observers we have on the old process object if (m_Process) { if (m_StartWriterCommand) { m_Process->RemoveObserver(m_StartWriterTag); } if (m_EndWriterCommand) { m_Process->RemoveObserver(m_EndWriterTag); } if (m_ProgressWriterCommand) { m_Process->RemoveObserver(m_ProgressWriterTag); } } if (m_SourceProcess) { if (m_StartFilterCommand) { m_SourceProcess->RemoveObserver(m_StartFilterTag); } if (m_EndFilterCommand) { m_SourceProcess->RemoveObserver(m_EndFilterTag); } if (m_ProgressFilterCommand) { m_SourceProcess->RemoveObserver(m_ProgressFilterTag); } } } } // end namespace otb OTB-release-5.8/Modules/Core/Common/test/000077500000000000000000000000001301006202600201255ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Common/test/CMakeLists.txt000066400000000000000000000161571301006202600226770ustar00rootroot00000000000000otb_module_test() set(OTBCommonTests otbCommonTestDriver.cxx otbVariableLengthVectorConverter.cxx otbImageRegionTileMapSplitter.cxx otbImageRegionAdaptativeSplitter.cxx otbRGBAPixelConverter.cxx otbRectangle.cxx otbImageRegionNonUniformMultidimensionalSplitterNew.cxx otbSystemTest.cxx otbImageRegionSquareTileSplitter.cxx otbImageRegionTileMapSplitterNew.cxx otbImageRegionNonUniformMultidimensionalSplitter.cxx otbRectangleNew.cxx otbConfigurationManagerTest.cxx otbStandardFilterWatcherNew.cxx otbStandardOneLineFilterWatcherTest.cxx otbStandardWriterWatcher.cxx ) add_executable(otbCommonTestDriver ${OTBCommonTests}) target_link_libraries(otbCommonTestDriver ${OTBCommon-Test_LIBRARIES}) otb_module_target_label(otbCommonTestDriver) # Tests Declaration otb_add_test(NAME coTuVariableLengthVectorConverter COMMAND otbCommonTestDriver otbVariableLengthVectorConverterNew ) otb_add_test(NAME coTvImageRegionTileMapSplitter COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coImageRegionTileMapSplitter.txt ${TEMP}/coImageRegionTileMapSplitter.txt otbImageRegionTileMapSplitter ${TEMP}/coImageRegionTileMapSplitter.txt ) otb_add_test(NAME coTuImageRegionAdaptativeSplitterNew COMMAND otbCommonTestDriver otbImageRegionAdaptativeSplitterNew) otb_add_test(NAME coTvImageRegionAdaptativeSplitterStripSmallStream COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvImageRegionAdaptativeSplitterStripSmallStreamOutput.txt ${TEMP}/coTvImageRegionAdaptativeSplitterStripSmallStreamOutput.txt otbImageRegionAdaptativeSplitter 0 0 8000 8003 8000 1000 20 ${TEMP}/coTvImageRegionAdaptativeSplitterStripSmallStreamOutput.txt ) otb_add_test(NAME coTvImageRegionAdaptativeSplitterSquaredTileLargeStream COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvImageRegionAdaptativeSplitterSquaredTileLargeStreamOutput.txt ${TEMP}/coTvImageRegionAdaptativeSplitterSquaredTileLargeStreamOutput.txt otbImageRegionAdaptativeSplitter 0 0 8192 8192 2048 2048 8 ${TEMP}/coTvImageRegionAdaptativeSplitterSquaredTileLargeStreamOutput.txt ) otb_add_test(NAME coTvImageRegionAdaptativeSplitterSquaredTileSmallStream COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvImageRegionAdaptativeSplitterSquaredTileSmallStreamOutput.txt ${TEMP}/coTvImageRegionAdaptativeSplitterSquaredTileSmallStreamOutput.txt otbImageRegionAdaptativeSplitter 0 0 8192 8192 2048 2048 32 ${TEMP}/coTvImageRegionAdaptativeSplitterSquaredTileSmallStreamOutput.txt ) otb_add_test(NAME coTvImageRegionAdaptativeSplitterStripLargeStream COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvImageRegionAdaptativeSplitterStripLargeStreamOutput.txt ${TEMP}/coTvImageRegionAdaptativeSplitterStripLargeStreamOutput.txt otbImageRegionAdaptativeSplitter 0 0 8000 8003 8000 16 8 ${TEMP}/coTvImageRegionAdaptativeSplitterStripLargeStreamOutput.txt ) otb_add_test(NAME coTvImageRegionAdaptativeSplitterShiftedROILargeStream COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvImageRegionAdaptativeSplitterShiftedROILargeStreamOutput.txt ${TEMP}/coTvImageRegionAdaptativeSplitterShiftedROILargeStreamOutput.txt otbImageRegionAdaptativeSplitter 1000 1000 4000 4000 2000 2000 5 ${TEMP}/coTvImageRegionAdaptativeSplitterShiftedROILargeStreamOutput.txt ) otb_add_test(NAME coTvImageRegionAdaptativeSplitterShiftedROISmallStream COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvImageRegionAdaptativeSplitterShiftedROISmallStreamOutput.txt ${TEMP}/coTvImageRegionAdaptativeSplitterShiftedROISmallStreamOutput.txt otbImageRegionAdaptativeSplitter 1000 1000 4000 4000 2000 2000 10 ${TEMP}/coTvImageRegionAdaptativeSplitterShiftedROISmallStreamOutput.txt ) otb_add_test(NAME coTvImageRegionAdaptativeSplitterMissingLine COMMAND otbCommonTestDriver otbImageRegionAdaptativeSplitter 0 0 1000 1000 1000 1 37 ${TEMP}/coTvImageRegionAdaptativeSplitterMissingLine.txt ) otb_add_test(NAME coTvImageRegionAdaptativeSplitterDivideBlock COMMAND otbCommonTestDriver otbImageRegionAdaptativeSplitter 0 0 10 10 5 5 36 ${TEMP}/coTvImageRegionAdaptativeSplitterDivideBlock.txt ) otb_add_test(NAME coTuRGBAPixelConverter COMMAND otbCommonTestDriver otbRGBAPixelConverterNew ) otb_add_test(NAME coTvRGBAPixelConverter COMMAND otbCommonTestDriver otbRGBAPixelConverter ) otb_add_test(NAME coTvRectangle COMMAND otbCommonTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/otbRectangleTest.txt ${TEMP}/otbRectangleTest.txt otbRectangle ${TEMP}/otbRectangleTest.txt 2.12 2.35 12.54 2.45 3. 0.15 1. 1. ) otb_add_test(NAME coTuImageRegionNonUniformMultidimensionalSplitterNew COMMAND otbCommonTestDriver otbImageRegionNonUniformMultidimensionalSplitterNew ) otb_add_test(NAME coTuSystemTests_IsA_Methods COMMAND otbCommonTestDriver otbSystemTest ${OTB_DATA_ROOT}/README-OTB-Data ${OTB_DATA_ROOT} ) otb_add_test(NAME coTvParseHdfSubsetName COMMAND otbCommonTestDriver otbParseHdfSubsetName) otb_add_test(NAME coTvParseHdfFileName COMMAND otbCommonTestDriver otbParseHdfFileName) otb_add_test(NAME coTuImageRegionSquareTileSplitterNew COMMAND otbCommonTestDriver otbImageRegionSquareTileSplitterNew ) otb_add_test(NAME coTvImageRegionSquareTileSplitter COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coImageRegionSquareTileSplitter.txt ${TEMP}/coImageRegionSquareTileSplitter.txt otbImageRegionSquareTileSplitter ${TEMP}/coImageRegionSquareTileSplitter.txt ) otb_add_test(NAME coTuImageRegionTileMapSplitterNew COMMAND otbCommonTestDriver otbImageRegionTileMapSplitterNew ) otb_add_test(NAME coTvImageRegionNonUniformMultidimensionalSplitter COMMAND otbCommonTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coImageRegionNonUniformMultidimensionalSplitter.txt ${TEMP}/coImageRegionNonUniformMultidimensionalSplitter.txt otbImageRegionNonUniformMultidimensionalSplitter 45 45 # Index 1000 1500 # Size 10 # Nb split 2 # Number of slipt ${TEMP}/coImageRegionNonUniformMultidimensionalSplitter.txt ) otb_add_test(NAME coTuRectangleNew COMMAND otbCommonTestDriver otbRectangleNew) otb_add_test(NAME coTvConfigurationManagerDefault COMMAND otbCommonTestDriver otbConfigurationManagerTest 128) otb_add_test(NAME coTvConfigurationManagerEnvVar COMMAND otbTestDriver --add-before-env OTB_MAX_RAM_HINT "256" --add-before-env OTB_DEM_DIRECTORY "/path/to/dem/" --add-before-env OTB_GEOID_FILE "/path/to/geoid.file" Execute $ otbConfigurationManagerTest 256 /path/to/dem/ /path/to/geoid.file) otb_add_test(NAME coTuStandardFilterWatcherNew COMMAND otbCommonTestDriver otbStandardFilterWatcherNew ${INPUTDATA}/qb_RoadExtract.img ) otb_add_test(NAME coTuStandardOneLineFilterWatcher COMMAND otbCommonTestDriver otbStandardOneLineFilterWatcherTest ${INPUTDATA}/qb_RoadExtract.img ) otb_add_test(NAME coTvStandardWriterWatcher COMMAND otbCommonTestDriver otbStandardWriterWatcher ${INPUTDATA}/couleurs.tif ${TEMP}/coTvStandardWriterWatcherOutput.tif 20 ) OTB-release-5.8/Modules/Core/Common/test/otbCommonTestDriver.cxx000066400000000000000000000017451301006202600246310ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbVariableLengthVectorConverterNew); REGISTER_TEST(otbImageRegionTileMapSplitter); REGISTER_TEST(otbImageRegionAdaptativeSplitterNew); REGISTER_TEST(otbImageRegionAdaptativeSplitter); REGISTER_TEST(otbRGBAPixelConverterNew); REGISTER_TEST(otbRGBAPixelConverter); REGISTER_TEST(otbRectangle); REGISTER_TEST(otbImageRegionNonUniformMultidimensionalSplitterNew); REGISTER_TEST(otbSystemTest); REGISTER_TEST(otbParseHdfSubsetName); REGISTER_TEST(otbParseHdfFileName); REGISTER_TEST(otbImageRegionSquareTileSplitterNew); REGISTER_TEST(otbImageRegionSquareTileSplitter); REGISTER_TEST(otbImageRegionTileMapSplitterNew); REGISTER_TEST(otbImageRegionNonUniformMultidimensionalSplitter); REGISTER_TEST(otbRectangleNew); REGISTER_TEST(otbConfigurationManagerTest); REGISTER_TEST(otbStandardFilterWatcherNew); REGISTER_TEST(otbStandardOneLineFilterWatcherTest); REGISTER_TEST(otbStandardWriterWatcher); } OTB-release-5.8/Modules/Core/Common/test/otbConfigurationManagerTest.cxx000066400000000000000000000037101301006202600263210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbConfigurationManager.h" int otbConfigurationManagerTest(int argc, char * argv[]) { if(argc<1) { std::cerr<<"Usage: "<2)?argv[2]:""; std::string refGeoidFile = (argc>3)?argv[3]:""; otb::ConfigurationManager::RAMValueType maxRam = otb::ConfigurationManager::GetMaxRAMHint(); std::cout<<"GetMaxRAMHint(): "< const int Dimension = 2; typedef otb::ImageRegionAdaptativeSplitter SplitterType; typedef SplitterType::RegionType RegionType; typedef RegionType::SizeType SizeType; typedef RegionType::IndexType IndexType; int otbImageRegionAdaptativeSplitterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { SplitterType::Pointer splitter = SplitterType::New(); std::cout<SetTileHint(tileHint); unsigned int nbSplits = splitter->GetNumberOfSplits(region, requestedNbSplits); std::vector splits; outfile<GetSplit(i, requestedNbSplits, region); splits.push_back(tmpRegion); outfile<<"Split "< 1) { std::cout << "Index ["< int otbImageRegionNonUniformMultidimensionalSplitter(int itkNotUsed(argc), char * argv[]) { const int Dimension = 2; typedef otb::ImageRegionNonUniformMultidimensionalSplitter FilterType; typedef FilterType::IndexType IndexType; typedef FilterType::SizeType SizeType; typedef FilterType::RegionType RegionType; IndexType index; index[0] = atoi(argv[1]); index[1] = atoi(argv[2]); SizeType size; size[0] = atoi(argv[3]); size[1] = atoi(argv[4]); unsigned int nbSplitTheoric(atoi(argv[5])); unsigned int nbAsked(atoi(argv[6])); const char * outfname(argv[7]); RegionType region; region.SetSize(size); region.SetIndex(index); FilterType::Pointer filter = FilterType::New(); unsigned int nb = filter->GetNumberOfSplits(region, nbSplitTheoric); RegionType region2 = filter->GetSplit(nbAsked, nb, region); std::ofstream outfile(outfname); outfile << "Input region: " << region << std::endl; outfile << "Input NumberOfSplits: " << nbSplitTheoric << std::endl; outfile << "Output GetNumberOfSplits: " << nb << std::endl; outfile << "Output GetSplit(" << nbAsked << "," << nb << ", input region): " << std::endl; outfile << " " << region2 << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbImageRegionNonUniformMultidimensionalSplitterNew.cxx000066400000000000000000000016711301006202600332230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageRegionNonUniformMultidimensionalSplitter.h" int otbImageRegionNonUniformMultidimensionalSplitterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef otb::ImageRegionNonUniformMultidimensionalSplitter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbImageRegionSquareTileSplitter.cxx000066400000000000000000000110501301006202600272670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageRegionSquareTileSplitter.h" #include const int Dimension = 2; typedef otb::ImageRegionSquareTileSplitter SquareTileSplitterType; typedef SquareTileSplitterType::IndexType IndexType; typedef SquareTileSplitterType::SizeType SizeType; typedef SquareTileSplitterType::RegionType RegionType; int otbImageRegionSquareTileSplitterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { SquareTileSplitterType::Pointer splitter = SquareTileSplitterType::New(); std::cout << splitter << std::endl; return EXIT_SUCCESS; } int TestSplitter(const RegionType& region, unsigned int PixelSize, unsigned int MaxTileSize, std::ostream& os) { os << "----------------------------------" << std::endl; os << "Region : " << region << std::endl; os << "PixelSize : " << PixelSize << std::endl; os << "MaxTileSize : " << MaxTileSize << std::endl; SquareTileSplitterType::Pointer splitter; splitter = SquareTileSplitterType::New(); unsigned int requestedNbSplits = region.GetNumberOfPixels() * PixelSize / MaxTileSize; if (requestedNbSplits == 0) requestedNbSplits = 1; os << "Requested Number of splits : " << requestedNbSplits << std::endl; const unsigned int nbSplits = splitter->GetNumberOfSplits(region, requestedNbSplits); os << "Actual Number of splits : " << nbSplits << std::endl; RegionType split; // First split : split = splitter->GetSplit(0, nbSplits, region); os << "First Split : " << split << "(" << split.GetNumberOfPixels() * PixelSize << " bytes)" << std::endl; if (nbSplits > 1) { // Second split : split = splitter->GetSplit(1, nbSplits, region); os << "Second Split : " << split << "(" << split.GetNumberOfPixels() * PixelSize << " bytes)" << std::endl; } if (nbSplits > 2) { // Last split : split = splitter->GetSplit(nbSplits - 1, nbSplits, region); os << "Last Split : " << split << "(" << split.GetNumberOfPixels() * PixelSize << " bytes)" << std::endl; } return EXIT_SUCCESS; } int otbImageRegionSquareTileSplitter(int itkNotUsed(argc), char * argv[]) { std::ofstream outfile(argv[1]); RegionType region; // Test with a 0-based indexed region region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, 1024); region.SetSize(1, 1024); TestSplitter(region, 1, 128, outfile); TestSplitter(region, 1, 512*512, outfile); TestSplitter(region, 2, 512*512, outfile); TestSplitter(region, 4, 512*512, outfile); TestSplitter(region, 8, 512*512, outfile); // Test with a shifted region region.SetIndex(0, 42); region.SetIndex(1, 42); region.SetSize(0, 1000); region.SetSize(1, 1000); TestSplitter(region, 1, 128, outfile); TestSplitter(region, 1, 512*512, outfile); TestSplitter(region, 2, 512*512, outfile); TestSplitter(region, 4, 512*512, outfile); TestSplitter(region, 8, 512*512, outfile); // Test with a negative shift region.SetIndex(0, -42); region.SetIndex(1, -42); region.SetSize(0, 1000); region.SetSize(1, 1000); TestSplitter(region, 1, 128, outfile); TestSplitter(region, 1, 512*512, outfile); TestSplitter(region, 2, 512*512, outfile); TestSplitter(region, 4, 512*512, outfile); TestSplitter(region, 8, 512*512, outfile); // Test with a reduced size region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, 1); region.SetSize(1, 1); TestSplitter(region, 1, 128, outfile); TestSplitter(region, 1, 512*512, outfile); TestSplitter(region, 2, 512*512, outfile); TestSplitter(region, 4, 512*512, outfile); TestSplitter(region, 8, 512*512, outfile); // Test with a reduced size, shifted region.SetIndex(0, 42); region.SetIndex(1, 42); region.SetSize(0, 1); region.SetSize(1, 1); TestSplitter(region, 1, 128, outfile); TestSplitter(region, 1, 512*512, outfile); TestSplitter(region, 2, 512*512, outfile); TestSplitter(region, 4, 512*512, outfile); TestSplitter(region, 8, 512*512, outfile); outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbImageRegionTileMapSplitter.cxx000066400000000000000000000106071301006202600265530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageRegionTileMapSplitter.h" #include int otbImageRegionTileMapSplitter(int itkNotUsed(argc), char * argv[]) { const int Dimension = 2; typedef otb::ImageRegionTileMapSplitter FilterType; typedef FilterType::IndexType IndexType; typedef FilterType::SizeType SizeType; typedef FilterType::RegionType RegionType; std::ofstream outfile(argv[1]); FilterType::Pointer filter = FilterType::New(); RegionType region, region2; unsigned int nb, nbSplitTheoric, nbAsked; IndexType index; SizeType size; //Case 1 index[0] = 45; index[1] = 45; size[0] = 1000; size[1] = 1500; nbSplitTheoric = 10; nbAsked = 2; region.SetSize(size); region.SetIndex(index); nb = filter->GetNumberOfSplits(region, nbSplitTheoric); region2 = filter->GetSplit(nbAsked, nb, region); outfile << "\nCase 1 \n"; outfile << "Input region: " << region << std::endl; outfile << "Input NumberOfSplits: " << nbSplitTheoric << std::endl; outfile << "Output GetNumberOfSplits: " << nb << std::endl; outfile << "Output GetSplit(" << nbAsked << "," << nb << ", input region): " << std::endl; outfile << "Output region: " << region2 << std::endl; //Case 2 index[0] = 45; index[1] = 45; size[0] = 1048576; size[1] = 1048576; nbSplitTheoric = 16777216; nbAsked = 2; region.SetSize(size); region.SetIndex(index); nb = filter->GetNumberOfSplits(region, nbSplitTheoric); region2 = filter->GetSplit(nbAsked, nb, region); outfile << "\nCase 2 \n"; outfile << "Input region: " << region << std::endl; outfile << "Input NumberOfSplits: " << nbSplitTheoric << std::endl; outfile << "Output GetNumberOfSplits: " << nb << std::endl; outfile << "Output GetSplit(" << nbAsked << "," << nb << ", input region): " << std::endl; outfile << "Output region: " << region2 << std::endl; //Case 3 index[0] = 45; index[1] = 45; size[0] = 1048576; size[1] = 1048576; nbSplitTheoric = 23; nbAsked = 4; region.SetSize(size); region.SetIndex(index); nb = filter->GetNumberOfSplits(region, nbSplitTheoric); region2 = filter->GetSplit(nbAsked, nb, region); outfile << "\nCase 3 \n"; outfile << "Input region: " << region << std::endl; outfile << "Input NumberOfSplits: " << nbSplitTheoric << std::endl; outfile << "Output GetNumberOfSplits: " << nb << std::endl; outfile << "Output GetSplit(" << nbAsked << "," << nb << ", input region): " << std::endl; outfile << "Output region: " << region2 << std::endl; //Case 4 index[0] = 45; index[1] = 45; size[0] = 1048576; size[1] = 1024; nbSplitTheoric = 16777216; nbAsked = 16387; region.SetSize(size); region.SetIndex(index); nb = filter->GetNumberOfSplits(region, nbSplitTheoric); region2 = filter->GetSplit(nbAsked, nb, region); outfile << "\nCase 4 \n"; outfile << "Input region: " << region << std::endl; outfile << "Input NumberOfSplits: " << nbSplitTheoric << std::endl; outfile << "Output GetNumberOfSplits: " << nb << std::endl; outfile << "Output GetSplit(" << nbAsked << "," << nb << ", input region): " << std::endl; outfile << "Output region: " << region2 << std::endl; //Case 5 index[0] = 0; index[1] = 0; size[0] = 513; size[1] = 5376; nbSplitTheoric = 8; nbAsked = 9; region.SetSize(size); region.SetIndex(index); nb = filter->GetNumberOfSplits(region, nbSplitTheoric); region2 = filter->GetSplit(nbAsked, nb, region); outfile << "\nCase 5 \n"; outfile << "Input region: " << region << std::endl; outfile << "Input NumberOfSplits: " << nbSplitTheoric << std::endl; outfile << "Output GetNumberOfSplits: " << nb << std::endl; outfile << "Output GetSplit(" << nbAsked << "," << nb << ", input region): " << std::endl; outfile << "Output region: " << region2 << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbImageRegionTileMapSplitterNew.cxx000066400000000000000000000016001301006202600272160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageRegionTileMapSplitter.h" int otbImageRegionTileMapSplitterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef otb::ImageRegionTileMapSplitter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbRGBAPixelConverter.cxx000066400000000000000000000105601301006202600247650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbRGBAPixelConverter.h" int otbRGBAPixelConverterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char PixelType0; typedef double PixelType1; typedef itk::RGBAPixel PixelType2; typedef itk::RGBPixel PixelType3; typedef otb::RGBAPixelConverter ConverterType0; typedef otb::RGBAPixelConverter ConverterType1; typedef otb::RGBAPixelConverter ConverterType2; typedef otb::RGBAPixelConverter ConverterType3; // Instantiating object ConverterType0::Pointer converter0 = ConverterType0::New(); ConverterType1::Pointer converter1 = ConverterType1::New(); ConverterType2::Pointer converter2 = ConverterType2::New(); ConverterType3::Pointer converter3 = ConverterType3::New(); std::cout << converter0 << std::endl; std::cout << converter1 << std::endl; std::cout << converter2 << std::endl; std::cout << converter3 << std::endl; return EXIT_SUCCESS; } int otbRGBAPixelConverter(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned int PixelType0; typedef double PixelType1; typedef itk::RGBAPixel PixelType2; typedef itk::RGBAPixel PixelType3; typedef itk::RGBPixel PixelType4; typedef otb::RGBAPixelConverter ConverterType0; typedef otb::RGBAPixelConverter ConverterType1; typedef otb::RGBAPixelConverter ConverterType2; typedef otb::RGBAPixelConverter ConverterType3; // Instantiating object ConverterType0::Pointer converter0 = ConverterType0::New(); ConverterType1::Pointer converter1 = ConverterType1::New(); ConverterType2::Pointer converter2 = ConverterType2::New(); ConverterType3::Pointer converter3 = ConverterType3::New(); PixelType2 pixel0; pixel0[0] = 125; pixel0[1] = 105; pixel0[2] = 145; pixel0[3] = 0; ConverterType0::OutputPixelType outputPixel0 = converter0->Convert(pixel0); std::cout << "outputPixel0: " << outputPixel0 << std::endl; if(outputPixel0 != 112) { itkGenericExceptionMacro(<< "RGBA 2 unsigned int Failed"); } PixelType3 pixel1; pixel1[0] = 125.0; pixel1[1] = 105.0; pixel1[2] = 145.0; pixel1[3] = 191.0; ConverterType1::OutputPixelType outputPixel1 = converter1->Convert(pixel1); std::cout << "outputPixel1: " << outputPixel1 << std::endl; if(outputPixel1 != 112) { itkGenericExceptionMacro(<< "RGBA 2 unsigned int Failed"); } PixelType2 pixel2; pixel2[0] = 125; pixel2[1] = 105; pixel2[2] = 145; pixel2[3] = 0; ConverterType2::OutputPixelType outputPixel2 = converter2->Convert(pixel2); std::cout << "outputPixel2: " << outputPixel2 << std::endl; if(outputPixel2[0] != 125 || outputPixel2[1] != 105 || outputPixel2[2] != 145 || outputPixel2[3] != 0 ) { itkGenericExceptionMacro(<< "RGBA 2 RGBA Failed"); } PixelType2 pixel3; pixel3[0] = 125; pixel3[1] = 105; pixel3[2] = 145; pixel3[3] = 0; ConverterType3::OutputPixelType outputPixel3 = converter3->Convert(pixel3); std::cout << "outputPixel3: " << outputPixel3 << std::endl; if(outputPixel3[0] != 125 || outputPixel3[1] != 105 || outputPixel3[2] != 145) { itkGenericExceptionMacro(<< "RGBA 2 RGB Failed"); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbRectangle.cxx000066400000000000000000000035301301006202600232630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRectangle.h" #include #include int otbRectangle(int itkNotUsed(argc), char * argv[]) { const char * outfname = argv[1]; typedef otb::Rectangle<> RectangleType; typedef RectangleType::ContinuousIndexType ContinuousIndexType; // Instantiating object RectangleType::Pointer rectangle1 = RectangleType::New(); ContinuousIndexType newVertex; newVertex[0] = atof(argv[2]); newVertex[1] = atof(argv[3]); rectangle1->AddVertex(newVertex); newVertex[0] = atof(argv[4]); newVertex[1] = atof(argv[5]); rectangle1->AddVertex(newVertex); rectangle1->SetWidth(atof(argv[6])); rectangle1->SetOrientation(atof(argv[7])); /** Inside the rectangle test*/ ContinuousIndexType InsideVertex; InsideVertex[0] = atof(argv[8]); InsideVertex[1] = atof(argv[9]); std::ofstream outfile(outfname); if (rectangle1->IsInside(InsideVertex)) outfile << "The point " << InsideVertex << " Is Inside the rectangle" << std::endl; else outfile << "The point " << InsideVertex << " Is Outside the rectangle" << std::endl; outfile << "region Size" << rectangle1->GetBoundingRegion().GetSize() << std::endl; outfile << "region Origin" << rectangle1->GetBoundingRegion().GetIndex() << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbRectangleNew.cxx000066400000000000000000000015161301006202600237370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRectangle.h" int otbRectangleNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Rectangle<> RectangleType; //Instantiating object RectangleType::Pointer polygon = RectangleType::New(); std::cout << polygon << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbStandardFilterWatcherNew.cxx000066400000000000000000000040711301006202600262560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "otbStandardFilterWatcher.h" #include "itkGradientMagnitudeImageFilter.h" int otbStandardFilterWatcherNew(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); typedef itk::GradientMagnitudeImageFilter FilterType; FilterType::Pointer gradient = FilterType::New(); typedef otb::StandardFilterWatcher WatcherType; WatcherType watcher1(gradient, "Gradient"); gradient->SetInput(reader->GetOutput()); gradient->Update(); // Test copy constructor. WatcherType watcher2( watcher1 ); if ( watcher1.GetNameOfClass() != watcher2.GetNameOfClass() || watcher1.GetProcess() != watcher2.GetProcess() || watcher1.GetComment() != watcher2.GetComment() ) { std::cout << "Copy constructor failed." << std::endl; return EXIT_FAILURE; } // Test default constructor. WatcherType watcher3; // Test assignment operator. watcher3 = watcher2; if ( watcher3.GetNameOfClass() != watcher2.GetNameOfClass() || watcher3.GetProcess() != watcher2.GetProcess() || watcher3.GetComment() != watcher2.GetComment() ) { std::cout << "Operator= failed." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbStandardOneLineFilterWatcherTest.cxx000066400000000000000000000041171301006202600277170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "otbStandardOneLineFilterWatcher.h" #include "itkGradientMagnitudeImageFilter.h" int otbStandardOneLineFilterWatcherTest(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); typedef itk::GradientMagnitudeImageFilter FilterType; FilterType::Pointer gradient = FilterType::New(); typedef otb::StandardOneLineFilterWatcher WatcherType; WatcherType watcher1(gradient, "Gradient"); gradient->SetInput(reader->GetOutput()); gradient->Update(); // Test copy constructor. WatcherType watcher2( watcher1 ); if ( watcher1.GetNameOfClass() != watcher2.GetNameOfClass() || watcher1.GetProcess() != watcher2.GetProcess() || watcher1.GetComment() != watcher2.GetComment() ) { std::cout << "Copy constructor failed." << std::endl; return EXIT_FAILURE; } // Test default constructor. WatcherType watcher3; // Test assignment operator. watcher3 = watcher2; if ( watcher3.GetNameOfClass() != watcher2.GetNameOfClass() || watcher3.GetProcess() != watcher2.GetProcess() || watcher3.GetComment() != watcher2.GetComment() ) { std::cout << "Operator= failed." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbStandardWriterWatcher.cxx000066400000000000000000000061061301006202600256340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "otbStandardWriterWatcher.h" #include "itkGradientMagnitudeImageFilter.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" int otbStandardWriterWatcher(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int nbsd = atoi(argv[3]); const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::GradientMagnitudeImageFilter FilterType; typedef otb::ImageFileWriter StreamingWriterType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); FilterType::Pointer gradient = FilterType::New(); gradient->SetInput(reader->GetOutput()); StreamingWriterType::Pointer writer1 = StreamingWriterType::New(); writer1->SetNumberOfDivisionsStrippedStreaming(nbsd); writer1->SetInput(gradient->GetOutput()); writer1->SetFileName(outfname); typedef otb::StandardWriterWatcher WatcherType; WatcherType watcher1(writer1, "Gradient (streaming)"); // otb::StandardWriterWatcher watcher3(writer1, gradient, "Gradient"); // // otb::StandardWriterWatcher watcher4(watcher1); // // otb::StandardWriterWatcher watcher5 = watcher1; writer1->Update(); WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(gradient->GetOutput()); writer2->SetFileName(outfname); otb::StandardWriterWatcher watcher2(writer2, "Gradient (non streaming)"); writer2->Update(); // Test copy constructor. WatcherType watcher3( watcher1 ); if ( watcher1.GetNameOfClass() != watcher3.GetNameOfClass() || watcher1.GetProcess() != watcher3.GetProcess() || watcher1.GetComment() != watcher3.GetComment() ) { std::cout << "Copy constructor failed." << std::endl; return EXIT_FAILURE; } // Test default constructor. WatcherType watcher4; // Test assignment operator. watcher4 = watcher3; if ( watcher4.GetNameOfClass() != watcher3.GetNameOfClass() || watcher4.GetProcess() != watcher3.GetProcess() || watcher4.GetComment() != watcher3.GetComment() ) { std::cout << "Operator= failed." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbSystemTest.cxx000066400000000000000000000070711301006202600235070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itksys/SystemTools.hxx" #include "otbSystem.h" int otbSystemTest(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * inputDirName = argv[2]; std::ostringstream msg; // Check instantiation test otb::System * var(ITK_NULLPTR); var = new otb::System(); delete var; var = ITK_NULLPTR; if (itksys::SystemTools::FileExists(inputFileName, true) == false) { itkGenericExceptionMacro(<< "itksys::SystemTools::FileExists() error : the filename " << inputFileName << " is not detected."); } if (itksys::SystemTools::FileIsDirectory(inputFileName) == true) { itkGenericExceptionMacro(<< "itksys::SystemTools::FileIsDirectory() error : the filename " << inputFileName << " is detected."); } if (itksys::SystemTools::FileExists(inputDirName, true) == true) { itkGenericExceptionMacro(<< "itksys::SystemTools::FileExists() error : the dirname " << inputDirName << " is detected!!"); } if (itksys::SystemTools::FileIsDirectory(inputDirName) == false) { itkGenericExceptionMacro(<< "itksys::SystemTools::FileIsDirectory() error : the dirname " << inputDirName << " is not detected!!"); } return EXIT_SUCCESS; } int otbParseHdfSubsetName(int itkNotUsed(argc), char * itkNotUsed(argv) []) { std::string input(""); std::string key(""); std::string name(""); input = "SUBDATASET_7_NAME=HDF4_EOS:EOS_GRID:\"file/MOD13Q1.A2010001.h17v05.005.2010028003734.hdf\":MODIS_Grid_16DAY"; if ( !otb::System::ParseHdfSubsetName(input, key, name) ) return EXIT_FAILURE; if (key.compare("SUBDATASET_7_NAME") != 0) return EXIT_FAILURE; if (name.compare("HDF4_EOS:EOS_GRID:\"file/MOD13Q1.A2010001.h17v05.005.2010028003734.hdf\":MODIS_Grid_16DAY") != 0) return EXIT_FAILURE; input = "invalid"; if ( otb::System::ParseHdfSubsetName(input, key, name) ) return EXIT_FAILURE; return EXIT_SUCCESS; } int otbParseHdfFileName(int itkNotUsed(argc), char * itkNotUsed(argv) []) { std::string id(""); std::string file(""); unsigned int num(0); // Standard cases id = "/some/file.hdf:6"; if ( !otb::System::ParseHdfFileName(id, file, num) ) return EXIT_FAILURE; if (file.compare("/some/file.hdf") != 0) return EXIT_FAILURE; if ( num != 6 ) return EXIT_FAILURE; id = "/some/file.hdf:0"; if ( !otb::System::ParseHdfFileName(id, file, num) ) return EXIT_FAILURE; if (file.compare("/some/file.hdf") != 0) return EXIT_FAILURE; if ( num != 0 ) return EXIT_FAILURE; // non specified id = "/some/file.hdf"; if ( otb::System::ParseHdfFileName(id, file, num) ) return EXIT_FAILURE; // playing with windows format id = "C:\\some\\file.hdf"; if ( otb::System::ParseHdfFileName(id, file, num) ) return EXIT_FAILURE; if (num != 0) return EXIT_FAILURE; id = "C:\\some\\file.hdf:6"; if ( !otb::System::ParseHdfFileName(id, file, num) ) return EXIT_FAILURE; if (file.compare("C:\\some\\file.hdf") != 0) return EXIT_FAILURE; if ( num != 6 ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Common/test/otbVariableLengthVectorConverter.cxx000066400000000000000000000042251301006202600273230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVariableLengthVectorConverter.h" int otbVariableLengthVectorConverterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef itk::VariableLengthVector InputType0; typedef std::vector< std::vector< double > > InputType1; typedef std::vector< std::vector< std::complex< double > > > InputType2; typedef itk::FixedArray InputType3; typedef float PrecisionType; typedef otb::VariableLengthVectorConverter ConverterType0; typedef otb::VariableLengthVectorConverter ConverterType1; typedef otb::VariableLengthVectorConverter ConverterType2; typedef otb::VariableLengthVectorConverter ConverterType3; // Instantiating object ConverterType0::Pointer converter0 = ConverterType0::New(); ConverterType1::Pointer converter1 = ConverterType1::New(); ConverterType2::Pointer converter2 = ConverterType2::New(); ConverterType3::Pointer converter3 = ConverterType3::New(); std::cout << converter0 << std::endl; std::cout << converter1 << std::endl; std::cout << converter2 << std::endl; std::cout << converter3 << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ComplexImage/000077500000000000000000000000001301006202600202705ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ComplexImage/CMakeLists.txt000066400000000000000000000000541301006202600230270ustar00rootroot00000000000000project(OTBComplexImage) otb_module_impl() OTB-release-5.8/Modules/Core/ComplexImage/include/000077500000000000000000000000001301006202600217135ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ComplexImage/include/otbAmplitudePhaseToRGBFunctor.h000066400000000000000000000053301301006202600276760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAmplitudePhaseToRGBFunctor_h #define otbAmplitudePhaseToRGBFunctor_h #include "otbScalarToRainbowRGBPixelFunctor.h" #include "otbMath.h" namespace otb { namespace Functor { /** * \class AmplitudePhaseToRGBFunctor * \brief Function object to compute a color representation of a radar image. * * This class is useful for visualizing radar images with a combination of * the phase and the amplitude at the same time. * * The amplitude is used to represent the intensity of the pixel and the phase * to represent it's hue. * * Amplitude and phase can be obtained using the itk::ComplexToModulusImageFilter * and itk::ComplexToPhaseImageFilter for example. * * * \ingroup OTBComplexImage */ template class ITK_EXPORT AmplitudePhaseToRGBFunctor { public: typedef TOutput RGBPixelType; typedef typename RGBPixelType::ValueType RGBComponentType; typedef HSVToRGBFunctor HSVToRGBFunctorType; typedef TInput1 ScalarType; AmplitudePhaseToRGBFunctor() { m_Minimum = 0; m_Maximum = itk::NumericTraits::max(); }; ~AmplitudePhaseToRGBFunctor(){} void SetMaximum(ScalarType max) { this->m_Maximum = max; } void SetMinimum(ScalarType min) { this->m_Minimum = min; } inline TOutput operator ()(const TInput1& amplitude, const TInput2& coherence, const TInput3& phase) const { // std::cout << amplitude << " - " << phase << std::endl; double hinc; hinc = 0.6 / (CONST_2PI); double hue, sat, val; hue = 0.6 - (phase + CONST_PI) * hinc; sat = 0.6 * coherence + 0.3; val = itk::NumericTraits::max() / 2 * ((amplitude - m_Minimum) / (m_Maximum - m_Minimum) + 1.0); if (amplitude < m_Minimum) { val = 0; } if (amplitude > m_Maximum) { val = itk::NumericTraits::max(); } return m_HSVToRGBFunctor(hue, sat, val); } private: ScalarType m_Maximum; ScalarType m_Minimum; HSVToRGBFunctorType m_HSVToRGBFunctor; }; } } #endif OTB-release-5.8/Modules/Core/ComplexImage/otb-module.cmake000066400000000000000000000003231301006202600233370ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBComplexImage DEPENDS OTBColorMap OTBCommon TEST_DEPENDS OTBITK OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/ComplexImage/test/000077500000000000000000000000001301006202600212475ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ComplexImage/test/CMakeLists.txt000066400000000000000000000014401301006202600240060ustar00rootroot00000000000000otb_module_test() set(OTBComplexImageTests otbAmplitudePhaseToRGBFunctor.cxx otbAmplitudePhaseToRGBFunctorNew.cxx otbComplexImageTestDriver.cxx ) add_executable(otbComplexImageTestDriver ${OTBComplexImageTests}) target_link_libraries(otbComplexImageTestDriver ${OTBComplexImage-Test_LIBRARIES}) otb_module_target_label(otbComplexImageTestDriver) otb_add_test(NAME bfTvAmplitudePhaseToRGBFunctor COMMAND otbComplexImageTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvAmplitudePhaseToRGBFunctor.png ${TEMP}/bfTvAmplitudePhaseToRGBFunctor.png otbAmplitudePhaseToRGBFunctor ${INPUTDATA}/RSAT_imagery_HH.tif ${TEMP}/bfTvAmplitudePhaseToRGBFunctor.png ) otb_add_test(NAME bfTuAmplitudePhaseToRGBFunctorNew COMMAND otbComplexImageTestDriver otbAmplitudePhaseToRGBFunctorNew) OTB-release-5.8/Modules/Core/ComplexImage/test/otbAmplitudePhaseToRGBFunctor.cxx000066400000000000000000000055471301006202600276170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkTernaryFunctorImageFilter.h" #include "otbAmplitudePhaseToRGBFunctor.h" #include "itkComplexToModulusImageFilter.h" #include "itkComplexToPhaseImageFilter.h" #include "itkShiftScaleImageFilter.h" int otbAmplitudePhaseToRGBFunctor(int itkNotUsed(argc), char * argv[]) { typedef float PixelType; typedef otb::Image ImageType; typedef std::complex ComplexPixelType; typedef otb::Image ComplexImageType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image RGBImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); typedef itk::ComplexToModulusImageFilter ModulusFilterType; ModulusFilterType::Pointer modulusFilter = ModulusFilterType::New(); modulusFilter->SetInput(reader->GetOutput()); typedef itk::ComplexToPhaseImageFilter PhaseFilterType; PhaseFilterType::Pointer phaseFilter = PhaseFilterType::New(); phaseFilter->SetInput(reader->GetOutput()); typedef itk::ShiftScaleImageFilter ConstFilterType; ConstFilterType::Pointer constFilter = ConstFilterType::New(); constFilter->SetScale(0.0); constFilter->SetInput(modulusFilter->GetOutput()); typedef otb::Functor::AmplitudePhaseToRGBFunctor ColorMapFunctorType; typedef itk::TernaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->GetFunctor().SetMaximum(4000); colormapper->GetFunctor().SetMinimum(0); colormapper->SetInput1(modulusFilter->GetOutput()); colormapper->SetInput2(constFilter->GetOutput()); colormapper->SetInput3(phaseFilter->GetOutput()); colormapper->SetNumberOfThreads(1); writer->SetInput(colormapper->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ComplexImage/test/otbAmplitudePhaseToRGBFunctorNew.cxx000066400000000000000000000026411301006202600302610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkTernaryFunctorImageFilter.h" #include "otbAmplitudePhaseToRGBFunctor.h" int otbAmplitudePhaseToRGBFunctorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; typedef otb::Image ImageType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image RGBImageType; typedef otb::Functor::AmplitudePhaseToRGBFunctor ColorMapFunctorType; typedef itk::TernaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->GetFunctor().SetMaximum(150); colormapper->GetFunctor().SetMinimum(70); std::cout << colormapper << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ComplexImage/test/otbComplexImageTestDriver.cxx000066400000000000000000000002251301006202600270650ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbAmplitudePhaseToRGBFunctor); REGISTER_TEST(otbAmplitudePhaseToRGBFunctorNew); } OTB-release-5.8/Modules/Core/ImageBase/000077500000000000000000000000001301006202600175335ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ImageBase/CMakeLists.txt000066400000000000000000000001221301006202600222660ustar00rootroot00000000000000project(OTBImageBase) set(OTBImageBase_LIBRARIES OTBImageBase) otb_module_impl() OTB-release-5.8/Modules/Core/ImageBase/include/000077500000000000000000000000001301006202600211565ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ImageBase/include/otbConvertPixelBuffer.h000066400000000000000000000056721301006202600256220ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkConvertPixelBuffer.h,v $ Language: C++ Date: $Date: 2009-08-11 12:45:11 $ Version: $Revision: 1.12 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConvertPixelBuffer_h #define otbConvertPixelBuffer_h #include #include "itkObject.h" namespace otb { /** * \class ConvertPixelBuffer * \brief Class to convert blocks of data from one type to another. * * ConvertPixelBuffer uses itk::ConvertPixelBuffer to perform most of the * conversions. The monoband to complex conversion is done in this class * (different rule than in ITK). New conversions methods are also added in * this class : * ConvertComplexVectorImageToVectorImage * ConvertComplexVectorImageToVectorImageComplex * ConvertComplexToGray * * \ingroup OTBImageBase */ template < typename InputPixelType, typename OutputPixelType, class OutputConvertTraits > class ConvertPixelBuffer { public: /** Determine the output data type. */ typedef typename OutputConvertTraits::ComponentType OutputComponentType; /** General method converts from one type to another. */ static void Convert(InputPixelType* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size); static void ConvertVectorImage(InputPixelType* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size); static void ConvertComplexVectorImageToVectorImage(std::complex* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size); static void ConvertComplexVectorImageToVectorImageComplex(std::complex* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size); static void ConvertComplexToGray(std::complex* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size); protected: /** Conversions related to complex */ static void ConvertGrayToComplex(InputPixelType * inputData, OutputPixelType * OutputData, size_t size); private: ConvertPixelBuffer(); ~ConvertPixelBuffer(); }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConvertPixelBuffer.txx" #endif #endif // otbConvertPixelBuffer_h OTB-release-5.8/Modules/Core/ImageBase/include/otbConvertPixelBuffer.txx000066400000000000000000000137341301006202600262140ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkConvertPixelBuffer.txx,v $ Language: C++ Date: $Date: 2009-11-22 19:35:57 $ Version: $Revision: 1.27 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConvertPixelBuffer_txx #define otbConvertPixelBuffer_txx #include "otbConvertPixelBuffer.h" #include "itkConvertPixelBuffer.h" namespace otb { template < typename InputPixelType, typename OutputPixelType, class OutputConvertTraits > void ConvertPixelBuffer ::Convert(InputPixelType* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size) { if ((OutputConvertTraits::GetNumberOfComponents() == 2) && inputNumberOfComponents == 1) { // OTB patch : monoband to complex ConvertGrayToComplex(inputData,outputData,size); } else { // use ITK pixel buffer converter itk::ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits> ::Convert(inputData,inputNumberOfComponents,outputData,size); } } // Convert Grayscale to Complex template < typename InputPixelType, typename OutputPixelType, class OutputConvertTraits > void ConvertPixelBuffer ::ConvertGrayToComplex(InputPixelType* inputData, OutputPixelType* outputData , size_t size) { InputPixelType* endInput = inputData + size; while(inputData != endInput) { OutputConvertTraits::SetNthComponent(0, *outputData, static_cast (*inputData)); OutputConvertTraits::SetNthComponent(1, *outputData, static_cast (0.)); inputData++; outputData++; } } /* To be able to convert transparently*/ template OutputType ComplexCast(const std::complex& in, const OutputType& itkNotUsed(dummy)) { typedef typename itk::NumericTraits >::RealType RealType; typedef typename itk::NumericTraits >::ScalarRealType ScalarRealType; RealType inReal( static_cast(in.real()), static_cast(in.imag()) ); return static_cast < OutputType >( vcl_abs(inReal) ); } template std::complex ComplexCast(const std::complex& in, const std::complex& itkNotUsed(dummy)) { typedef typename itk::NumericTraits >::RealType RealType; typedef typename itk::NumericTraits >::ScalarRealType ScalarRealType; RealType inReal( static_cast(in.real()), static_cast(in.imag()) ); return static_cast < std::complex >( inReal ); } template < typename InputPixelType, typename OutputPixelType, class OutputConvertTraits > void ConvertPixelBuffer ::ConvertComplexToGray(std::complex* inputData, int itkNotUsed(inputNumberOfComponents), OutputPixelType* outputData , size_t size) { OutputPixelType dummy; std::complex* endInput = inputData + size; while(inputData != endInput) { OutputConvertTraits::SetNthComponent(0, *outputData, static_cast (ComplexCast(*inputData,dummy))); inputData++; outputData++; } } template < typename InputPixelType, typename OutputPixelType, class OutputConvertTraits > void ConvertPixelBuffer ::ConvertVectorImage(InputPixelType* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size) { itk::ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits> ::ConvertVectorImage(inputData, inputNumberOfComponents, outputData,size); } template < typename InputPixelType, typename OutputPixelType, class OutputConvertTraits > void ConvertPixelBuffer ::ConvertComplexVectorImageToVectorImage(std::complex* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size) { size_t length = size* (size_t)inputNumberOfComponents; for( size_t i=0; i< length/2; i++ ) { OutputConvertTraits::SetNthComponent( 0, *outputData, (*inputData).real()); ++outputData; OutputConvertTraits::SetNthComponent( 0, *outputData, (*inputData).imag()); ++outputData; ++inputData; } } template < typename InputPixelType, typename OutputPixelType, class OutputConvertTraits > void ConvertPixelBuffer ::ConvertComplexVectorImageToVectorImageComplex(std::complex* inputData, int inputNumberOfComponents, OutputPixelType* outputData , size_t size) { size_t length = size* (size_t)inputNumberOfComponents; OutputPixelType dummy; for( size_t i=0; i< length; i++ ) { OutputConvertTraits::SetNthComponent( 0, *outputData, ComplexCast(*inputData, dummy)); ++outputData; ++inputData; } } }// end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbDefaultConvertPixelTraits.h000066400000000000000000000425251301006202600271620ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkDefaultConvertPixelTraits.h,v $ Language: C++ Date: $Date: 2008-01-21 18:30:58 $ Version: $Revision: 1.20 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDefaultConvertPixelTraits_h #define otbDefaultConvertPixelTraits_h #include "itkOffset.h" #include "itkVector.h" #include "itkMatrix.h" namespace otb { /** \class DefaultConvertPixelTraits * \brief Traits class used to by ConvertPixels to convert blocks of pixels. * * TOutputPixelType is the destination type. The input type is inferred * by the templated static function Convert. * * This implementation does a simple assignment operator, so if you are * going from a higher bit representation to a lower bit one (int to * char), you may want to specialize and add some sort of transfer function. * * \ingroup OTBImageBase */ template class DefaultConvertPixelTraits { public: /** Determine the pixel data type. */ typedef typename PixelType::ComponentType ComponentType; /** Return the number of components per pixel. */ static unsigned int GetNumberOfComponents() { return PixelType::GetNumberOfComponents(); } /** Return the nth component of the pixel. */ static ComponentType GetNthComponent(int c, const PixelType& pixel) { return pixel.GetNthComponent(c); } /** Set the nth component of the pixel. */ static void SetNthComponent(int c, PixelType& pixel, const ComponentType& v) { pixel.SetNthComponent(c, v); } static void SetNthComponent(int itkNotUsed(c), PixelType & pixel, const PixelType& v) { pixel = v; } /** Return a single scalar value from this pixel. */ static ComponentType GetScalarValue(const PixelType& pixel) { return pixel.GetScalarValue(); } }; #define OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(type) \ template<> \ class DefaultConvertPixelTraits \ { \ public: \ typedef type ComponentType; \ static unsigned int GetNumberOfComponents() \ { \ return 1; \ } \ static void SetNthComponent(int , type& pixel, const ComponentType& v) \ { \ pixel = v; \ } \ static type GetScalarValue(const type& pixel) \ { \ return pixel; \ } \ }; OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(float) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(double) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(int) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(char) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(short) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned int) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(signed char) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned char) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned short) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(long) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned long) OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(bool) #undef OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL // // Default traits for the Offset<> pixel type // #define OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(dimension) \ template<> \ class DefaultConvertPixelTraits< itk::Offset > \ { \ public: \ typedef itk::Offset TargetType; \ typedef TargetType::OffsetValueType ComponentType; \ static unsigned int GetNumberOfComponents() \ { \ return dimension; \ } \ static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \ { \ pixel[i] = v; \ } \ static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \ { \ pixel = v; \ } \ static ComponentType GetScalarValue(const TargetType& pixel) \ { \ return pixel[0]; \ } \ }; // Define traits for Offset<> from dimensions 1 to 5 OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(1) OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(2) OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(3) OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(4) OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(5) // // Default traits for the pixel types deriving from FixedArray<> // #define OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(type,componenttype, dimension) \ template<> \ class DefaultConvertPixelTraits< type< componenttype, dimension> > \ { \ public: \ typedef type< componenttype, dimension > TargetType; \ typedef componenttype ComponentType; \ static unsigned int GetNumberOfComponents() \ { \ return dimension; \ } \ static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \ { \ pixel[i] = v; \ } \ static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \ { \ pixel = v; \ } \ static ComponentType GetScalarValue(const TargetType& pixel) \ { \ return pixel[0]; \ } \ }; \ // // // Define traits for Classed deriving from FixedArray from dimensions 1 to 6 // These classes include: Vector, CovariantVector and Point. // // #define OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, Type) \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,1) \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,2) \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,3) \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,4) \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,5) \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,6) #define OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(ArrayType) \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, char); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, signed char); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned char); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, short); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned short); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, int); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned int); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, long); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned long); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, float); \ OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, double); OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::Vector); OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::CovariantVector); OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::Point); OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::FixedArray); // // End of Traits for the classes deriving from FixedArray. // // // // Default traits for the pixel types deriving from Matrix<> // #define OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(type,componenttype,rows,cols) \ template<> \ class DefaultConvertPixelTraits< type< componenttype, rows, cols > > \ { \ public: \ typedef type< componenttype, rows, cols > TargetType; \ typedef componenttype ComponentType; \ static unsigned int GetNumberOfComponents() \ { \ return rows * cols; \ } \ static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \ { \ const unsigned int row = i / cols; \ const unsigned int col = i % cols; \ pixel[row][col] = v; \ } \ static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \ { \ pixel = v; \ } \ static ComponentType GetScalarValue(const TargetType& pixel) \ { \ return pixel[0][0]; \ } \ }; \ // // // Define traits for Classed deriving from Matrix from dimensions 1 to 6 // // #define OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, Type) \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,1,1) \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,2,2) \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,3,3) \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,4,4) \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,5,5) \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,6,6) #define OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_TYPES_MACRO(ArrayType) \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, char); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, signed char); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned char); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, short); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned short); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, int); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned int); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, long); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned long); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, float); \ OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, double); // // Add here other classes that derive from Matrix or that have the same API // OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_TYPES_MACRO(itk::Matrix); // // End of Traits for the classes deriving from Matrix. // // // // Default traits for the pixel types deriving from std::complex<> // #define OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE( componenttype ) \ template<> \ class DefaultConvertPixelTraits< ::std::complex< componenttype > > \ { \ public: \ typedef ::std::complex< componenttype> TargetType; \ typedef componenttype ComponentType; \ static unsigned int GetNumberOfComponents() \ { \ return 2; \ } \ static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \ { \ if( i == 0 ) \ { \ pixel = TargetType( v, pixel.imag() ); \ } \ else \ { \ pixel = TargetType( pixel.real(), v ); \ } \ } \ static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \ { \ pixel = v; \ } \ static ComponentType GetScalarValue(const TargetType& pixel) \ { \ /* \ * This seems to be dead code, since the complex to scalar \ * conversion is done by ConvertPixelBuffer \ * \ * Historically, it was returning std::norm, which causes \ * compilation error on MacOSX 10.9. \ * Now returns the equivalent implementation of std::norm. \ */ \ return static_cast( pixel.real()*pixel.real() \ + pixel.imag()*pixel.imag() ); \ } \ }; \ OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(float); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(double); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(signed int); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(unsigned int); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(short int); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(signed char); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(unsigned char); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(signed long); OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(unsigned long); // // End of Traits for the classes deriving from std::complex. // // } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbExtractROI.h000066400000000000000000000066401301006202600240260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtractROI_h #define otbExtractROI_h #include "otbExtractROIBase.h" #include "otbImage.h" #include "itkMacro.h" namespace otb { /** \class ExtractROI * \brief Extract a subset of a mono-channel image. * * Pixel can be of a simple type or an itk::RGBPixel, etc. * \note Parameter to this class are the input pixel type and the output * pixel type. * * * \ingroup OTBImageBase */ template class ITK_EXPORT ExtractROI : public ExtractROIBase, Image > { public: /** Standard class typedefs. */ typedef ExtractROI Self; typedef ExtractROIBase, Image > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ExtractROI, ExtractROIBase); /** Image type information. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; /** Typedef to describe the output and input image region types. */ typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::RegionType InputImageRegionType; /** Typedef to describe the type of pixel. */ typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename InputImageType::PixelType InputImagePixelType; /** Typedef to describe the output and input image index and size types. */ typedef typename OutputImageType::IndexType OutputImageIndexType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename InputImageType::SizeType InputImageSizeType; /** ImageDimension enumeration */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension); void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; protected: ExtractROI(); ~ExtractROI() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ExtractROI * * \sa ExtractROIBase::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; private: ExtractROI(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbExtractROI.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbExtractROI.txx000066400000000000000000000057371301006202600244300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtractROI_txx #define otbExtractROI_txx #include "otbExtractROI.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * */ template ExtractROI ::ExtractROI() //: ExtractROIBase< itk::Image , itk::Image >() { } /** * */ template void ExtractROI ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } /** * ExtractROI can produce an image which is a different resolution * than its input image. As such, ExtractROI needs to provide an * implementation for GenerateOutputInformation() in order to inform * the pipeline execution model. The original documentation of this * method is below. * * \sa ProcessObject::GenerateOutputInformaton() */ template void ExtractROI ::GenerateOutputInformation() { // Call to the base class method Superclass::GenerateOutputInformation(); } template void ExtractROI ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itkDebugMacro(<< "Actually executing"); // Get the input and output pointers typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define the portion of the input to walk for this thread InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators. typedef itk::ImageRegionIterator OutputIterator; typedef itk::ImageRegionConstIterator InputIterator; OutputIterator outIt(outputPtr, outputRegionForThread); InputIterator inIt(inputPtr, inputRegionForThread); // walk the output region, and sample the input image while (!outIt.IsAtEnd()) { // copy the input pixel to the output outIt.Set(inIt.Get()); ++outIt; ++inIt; progress.CompletedPixel(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbExtractROIBase.h000066400000000000000000000154071301006202600246220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtractROIBase_h #define otbExtractROIBase_h #include "itkImageToImageFilter.h" #include "itkSmartPointer.h" #include "itkExtractImageFilterRegionCopier.h" namespace otb { /** \class ExtractROIBase * \brief Base class to extract area of images. * * Extracted region can be defined by the methods SetStartX/Y (region origin) and * SetSizeX/Y (region size). If the starting point is not defined, the extracted * region start from the upper left corner of the input image. If the size is not * defined, the extracted region extend to the lower right corner of the input * image. If no parameter is defined all image is extracted. * * Alternatively, a region can be specified using the SetROI() method. * * \ingroup Common * * * \ingroup OTBImageBase */ template class ITK_EXPORT ExtractROIBase : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef ExtractROIBase Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ExtractROIBase, itk::ImageToImageFilter); /** Image type information. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Typedef to describe the output and input image region types. */ typedef typename TOutputImage::RegionType OutputImageRegionType; typedef typename TInputImage::RegionType InputImageRegionType; /** Typedef to describe the type of pixel. */ typedef typename TOutputImage::PixelType OutputImagePixelType; typedef typename TInputImage::PixelType InputImagePixelType; /** Typedef to describe the output and input image index and size types. */ typedef typename TOutputImage::IndexType OutputImageIndexType; typedef typename TInputImage::IndexType InputImageIndexType; typedef typename TOutputImage::SizeType OutputImageSizeType; typedef typename TInputImage::SizeType InputImageSizeType; /** ImageDimension enumeration */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef itk::ImageToImageFilterDetail::ExtractImageFilterRegionCopier ExtractROIBaseRegionCopierType; itkGetMacro(ExtractionRegion, InputImageRegionType); /** Give the region to extract, same effect as given m_StartX/Y and m_SizeX/Y*/ void SetExtractionRegion(InputImageRegionType roi); /** Set/Get Start methods */ itkSetMacro(StartX, unsigned long); itkGetConstMacro(StartX, unsigned long); itkSetMacro(StartY, unsigned long); itkGetConstMacro(StartY, unsigned long); /** Set/Get Size methods */ itkSetMacro(SizeX, unsigned long); itkGetConstMacro(SizeX, unsigned long); itkSetMacro(SizeY, unsigned long); itkGetConstMacro(SizeY, unsigned long); protected: ExtractROIBase(); ~ExtractROIBase() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; /** ExtractROIBase can produce an image which is a different * resolution than its input image. As such, ExtractROIBase * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; /** This function calls the actual region copier to do the mapping from * output image space to input image space. It uses a * Function object used for dispatching to various routines to * copy an output region (start index and size) to an input region. * For most filters, this is a trivial copy because most filters * require the input dimension to match the output dimension. * However, some filters like itk::ExtractROIBase can * support output images of a lower dimension that the input. * * \sa ImageToImageFilter::CallCopyRegion() */ void CallCopyOutputRegionToInputRegion(InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) ITK_OVERRIDE; /** ExtractROIBase can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() * routine which is called for each processing thread. The output * image data is allocated automatically by the superclass prior to * calling ThreadedGenerateData(). ThreadedGenerateData can only * write to the portion of the output image specified by the * parameter "outputRegionForThread" * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ // ATTENTION bizarre void ThreadedGenerateData(const OutputImageRegionType& /*outputRegionForThread*/, itk::ThreadIdType /*threadId*/) ITK_OVERRIDE { } /** Set/Get the output image region. * If any of the ExtractionRegion.Size = 0 for any particular dimension dim, * we have to collapse dimension dim. This means the output image will have * 'c' dimensions less than the input image, where c = # of * ExtractionRegion.Size = 0. */ void SetInternalExtractionRegion(InputImageRegionType extractRegion); InputImageRegionType m_ExtractionRegion; OutputImageRegionType m_OutputImageRegion; private: ExtractROIBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** X/Y coordinates of the first point of the region to extract. */ unsigned long m_StartX; unsigned long m_StartY; /** Number of X/Y pixels of the region to extract. */ unsigned long m_SizeX; unsigned long m_SizeY; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbExtractROIBase.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbExtractROIBase.txx000066400000000000000000000223671301006202600252210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtractROIBase_txx #define otbExtractROIBase_txx #include "otbExtractROIBase.h" #include "itkImageRegionIterator.h" #include "itkObjectFactory.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { /** * */ template ExtractROIBase ::ExtractROIBase() : itk::ImageToImageFilter(), m_StartX(0), m_StartY(0), m_SizeX(0), m_SizeY(0) { } /** * */ template void ExtractROIBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "ExtractionRegion: " << m_ExtractionRegion << std::endl; os << indent << "OutputImageRegion: " << m_OutputImageRegion << std::endl; } template void ExtractROIBase ::CallCopyOutputRegionToInputRegion(InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) { destRegion = srcRegion; OutputImageIndexType index = destRegion.GetIndex(); for (unsigned int i = 0; i < InputImageDimension; ++i) { index[i] += m_ExtractionRegion.GetIndex()[i]; } destRegion.SetIndex(index); } template void ExtractROIBase ::SetInternalExtractionRegion(InputImageRegionType extractRegion) { m_ExtractionRegion = extractRegion; unsigned int nonzeroSizeCount = 0; InputImageSizeType inputSize = extractRegion.GetSize(); OutputImageSizeType outputSize; OutputImageIndexType outputIndex; /** * check to see if the number of non-zero entries in the extraction region * matches the number of dimensions in the output image. **/ for (unsigned int i = 0; i < InputImageDimension; ++i) { if (inputSize[i]) { outputSize[nonzeroSizeCount] = inputSize[i]; outputIndex[nonzeroSizeCount] = 0; nonzeroSizeCount++; } } if (nonzeroSizeCount != OutputImageDimension) { itkExceptionMacro("Extraction Region not consistent with output image"); } m_OutputImageRegion.SetSize(outputSize); m_OutputImageRegion.SetIndex(outputIndex); this->Modified(); } template void ExtractROIBase ::SetExtractionRegion(InputImageRegionType roi) { m_SizeX = roi.GetSize()[0]; m_SizeY = roi.GetSize()[1]; m_StartX = roi.GetIndex()[0]; m_StartY = roi.GetIndex()[1]; this->Modified(); } template void ExtractROIBase ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr) { return; } if (!outputPtr) { return; } InputImageRegionType requestedRegion = outputPtr->GetRequestedRegion(); InputImageIndexType index = requestedRegion.GetIndex(); InputImageIndexType offset = m_ExtractionRegion.GetIndex(); for (unsigned int i = 0; i < InputImageDimension; ++i) { index[i] += offset[i]; } requestedRegion.SetIndex(index); inputPtr->SetRequestedRegion(requestedRegion); otbMsgDevMacro(<< "InputRequestedRegion (otbExtractROIBase): "); otbMsgDevMacro(<< " - index: " << requestedRegion.GetIndex()); otbMsgDevMacro(<< " - size: " << requestedRegion.GetSize()); } /** * ExtractROIBase can produce an image which is a different resolution * than its input image. As such, ExtractROIBase needs to provide an * implementation for GenerateOutputInformation() in order to inform * the pipeline execution model. The original documentation of this * method is below. * * \sa ProcessObject::GenerateOutputInformaton() */ template void ExtractROIBase ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // Compute the area to extract // If SizeX/Y == 0, then set SizeX/Y to image size typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); // Check if input exists or not before doing anything if (!inputPtr) { return; } // Get the input image //const InputImageRegionType& inputRegion = inputPtr->GetRequestedRegion(); const InputImageRegionType& inputRegion = inputPtr->GetLargestPossibleRegion(); if ((m_SizeX == 0) || (m_SizeX > (inputRegion.GetSize()[0] - m_StartX))) { m_SizeX = inputRegion.GetSize()[0] - m_StartX; } if ((m_SizeY == 0) || (m_SizeY > (inputRegion.GetSize()[1] - m_StartY))) { m_SizeY = inputRegion.GetSize()[1] - m_StartY; } InputImageIndexType start; start[0] = m_StartX; start[1] = m_StartY; InputImageSizeType size; size[0] = m_SizeX; size[1] = m_SizeY; InputImageRegionType desiredRegion; desiredRegion.SetSize(size); desiredRegion.SetIndex(start); // Call to the base class method for region initialization this->SetInternalExtractionRegion(desiredRegion); // do not call the superclass' implementation of this method since // this filter allows the input the output to be of different dimensions // get pointers to the input and output typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); // typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); if (!inputPtr) { return; } if (!outputPtr) { return; } // Set the output image size to the same value as the extraction region. outputPtr->SetLargestPossibleRegion(m_OutputImageRegion); // Set the output spacing and origin const itk::ImageBase *phyData; phyData = dynamic_cast*>(this->GetInput()); if (!phyData) { // pointer could not be cast back down itkExceptionMacro(<< "otb::ExtractROIBase::GenerateOutputInformation " << "cannot cast input to " << typeid(itk::ImageBase*).name()); } // Copy what we can from the image from spacing and origin of the input // This logic needs to be augmented with logic that select which // dimensions to copy const typename InputImageType::SpacingType& inputSpacing = inputPtr->GetSpacing(); const typename InputImageType::DirectionType& inputDirection = inputPtr->GetDirection(); const typename InputImageType::PointType& inputOrigin = inputPtr->GetOrigin(); typename OutputImageType::SpacingType outputSpacing; typename OutputImageType::DirectionType outputDirection; typename OutputImageType::PointType outputOrigin; if (static_cast(OutputImageDimension) > static_cast(InputImageDimension)) { unsigned int i; // copy the input to the output and fill the rest of the // output with zeros. for (i = 0; i < InputImageDimension; ++i) { outputSpacing[i] = inputSpacing[i]; outputOrigin[i] = inputOrigin[i] + static_cast(m_ExtractionRegion.GetIndex()[i]) * outputSpacing[i]; for (unsigned int dim = 0; dim < InputImageDimension; ++dim) { outputDirection[i][dim] = inputDirection[i][dim]; } } for (; i < OutputImageDimension; ++i) { outputSpacing[i] = 1.0; outputOrigin[i] = 0.0; for (unsigned int dim = 0; dim < InputImageDimension; ++dim) { outputDirection[i][dim] = 0.0; } outputDirection[i][i] = 1.0; } } else { // copy the non-collapsed part of the input spacing and origing to the output int nonZeroCount = 0; for (unsigned int i = 0; i < InputImageDimension; ++i) { if (m_ExtractionRegion.GetSize()[i] == 0) continue; outputSpacing[nonZeroCount] = inputSpacing[i]; outputOrigin[nonZeroCount] = inputOrigin[i] + static_cast(m_ExtractionRegion.GetIndex()[i]) * outputSpacing[i]; for (unsigned int dim = 0; dim < OutputImageDimension; ++dim) { outputDirection[nonZeroCount][dim] = inputDirection[nonZeroCount][dim]; } nonZeroCount++; } } // set the spacing and origin outputPtr->SetSpacing(outputSpacing); outputPtr->SetDirection(outputDirection); outputPtr->SetOrigin(outputOrigin); // THOMAS : dans ITK ce code est present, mais pas dans notre cas, car le nombre de composantes/pixel depend des canaux selectionnes par l'utilisateur // ce parametre est renseignes dans les classes sous-jacentes // outputPtr->SetNumberOfComponentsPerPixel( // inputPtr->GetNumberOfComponentsPerPixel() ); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbImage.h000066400000000000000000000163771301006202600230740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImage_h #define otbImage_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include "itkImage.h" #pragma GCC diagnostic pop #else #include "itkImage.h" #endif #include "otbImageMetadataInterfaceBase.h" namespace otb { /** \class Image * \brief Creation of an "otb" image which contains metadata. * * * \ingroup OTBImageBase */ template class ITK_EXPORT Image : public itk::Image { public: /** Standard class typedefs. */ typedef Image Self; typedef itk::Image Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::WeakPointer ConstWeakPointer; typedef ImageMetadataInterfaceBase::VectorType VectorType; typedef ImageMetadataInterfaceBase::ImageKeywordlistType ImageKeywordlistType; typedef ImageMetadataInterfaceBase::Pointer ImageMetadataInterfacePointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Image, itk::Image); /** Pixel typedef support. Used to declare pixel type in filters * or other operations. */ typedef typename Superclass::PixelType PixelType; /** Typedef alias for PixelType */ typedef typename Superclass::ValueType ValueType; /** Internal Pixel representation. Used to maintain a uniform API * with Image Adaptors and allow keeping a particular internal * representation of data while showing a different external * representation. */ typedef typename Superclass::InternalPixelType InternalPixelType; typedef typename Superclass::IOPixelType IOPixelType; /** Accessor type that convert data between internal and external * representations. */ //typedef itk::DefaultPixelAccessor< PixelType > AccessorType; //typedef itk::DefaultPixelAccessorFunctor< Self > AccessorFunctorType; /** Tyepdef for the functor used to access a neighborhood of pixel pointers.*/ typedef itk::NeighborhoodAccessorFunctor NeighborhoodAccessorFunctorType; /** Dimension of the image. This constant is used by functions that are * templated over image type (as opposed to being templated over pixel type * and dimension) when they need compile time access to the dimension of * the image. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Container used to store pixels in the image. */ typedef typename Superclass::PixelContainer PixelContainer; /** Index typedef support. An index is used to access pixel values. */ typedef typename Superclass::IndexType IndexType; /** Offset typedef support. An offset is used to access pixel values. */ typedef typename Superclass::OffsetType OffsetType; /** Size typedef support. A size is used to define region bounds. */ typedef typename Superclass::SizeType SizeType; /** Direction typedef support. A matrix of direction cosines. */ typedef typename Superclass::DirectionType DirectionType; /** Region typedef support. A region is used to specify a subset of an image. */ typedef typename Superclass::RegionType RegionType; /** Spacing typedef support. Spacing holds the size of a pixel. The * spacing is the geometric distance between image samples. */ typedef typename Superclass::SpacingType SpacingType; /** Origin typedef support. The origin is the geometric coordinates * of the index (0, 0). */ typedef typename Superclass::PointType PointType; /** A pointer to the pixel container. */ typedef typename PixelContainer::Pointer PixelContainerPointer; typedef typename PixelContainer::ConstPointer PixelContainerConstPointer; /** Offset typedef (relative position between indices) */ typedef typename Superclass::OffsetValueType OffsetValueType; /** Return the Pixel Accessor object */ // AccessorType GetPixelAccessor( void ) // { // return AccessorType(); // } // /** Return the Pixel Accesor object */ // const AccessorType GetPixelAccessor( void ) const // { // return AccessorType(); // } /** Return the NeighborhoodAccessor functor */ NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() { return NeighborhoodAccessorFunctorType(); } /** Return the NeighborhoodAccessor functor */ const NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() const { return NeighborhoodAccessorFunctorType(); } /** Get the projection coordinate system of the image. */ virtual std::string GetProjectionRef(void) const; virtual void SetProjectionRef(const std::string& wkt); /** Get the GCP projection coordinates of the image. */ virtual std::string GetGCPProjection(void) const; virtual unsigned int GetGCPCount(void) const; virtual OTB_GCP& GetGCPs(unsigned int GCPnum); virtual const OTB_GCP& GetGCPs(unsigned int GCPnum) const; virtual std::string GetGCPId(unsigned int GCPnum) const; virtual std::string GetGCPInfo(unsigned int GCPnum) const; virtual double GetGCPRow(unsigned int GCPnum) const; virtual double GetGCPCol(unsigned int GCPnum) const; virtual double GetGCPX(unsigned int GCPnum) const; virtual double GetGCPY(unsigned int GCPnum) const; virtual double GetGCPZ(unsigned int GCPnum) const; /** Get the six coefficients of affine geoTtransform. */ virtual VectorType GetGeoTransform(void) const; /** Get image corners. */ virtual VectorType GetUpperLeftCorner(void) const; virtual VectorType GetUpperRightCorner(void) const; virtual VectorType GetLowerLeftCorner(void) const; virtual VectorType GetLowerRightCorner(void) const; /** Get image keyword list */ virtual ImageKeywordlistType GetImageKeywordlist(void); virtual const ImageKeywordlistType GetImageKeywordlist(void) const; virtual void SetImageKeywordList(const ImageKeywordlistType& kwl); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /// Copy metadata from a DataObject void CopyInformation(const itk::DataObject *) ITK_OVERRIDE; protected: Image(); ~Image() ITK_OVERRIDE {} private: Image(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Return the ImageMetadataInterfacePointer associated to the data * and creates it on first call */ ImageMetadataInterfacePointerType GetMetaDataInterface() const; // The image metadata accessor object. Don't use it directly. Instead use GetMetaDataInterface() mutable ImageMetadataInterfacePointerType m_ImageMetadataInterface; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImage.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbImage.txx000066400000000000000000000147441301006202600234640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImage_txx #define otbImage_txx #include "otbImage.h" #include "otbImageMetadataInterfaceFactory.h" #include "itkMetaDataObject.h" namespace otb { template Image::Image() { } template std::string Image::GetProjectionRef(void) const { return (this->GetMetaDataInterface()->GetProjectionRef()); } template void Image::SetProjectionRef(const std::string& kwl) { itk::EncapsulateMetaData(this->GetMetaDataDictionary(),MetaDataKey::ProjectionRefKey,kwl); } template std::string Image::GetGCPProjection(void) const { return (this->GetMetaDataInterface()->GetGCPProjection()); } template unsigned int Image::GetGCPCount(void) const { return (this->GetMetaDataInterface()->GetGCPCount()); } template OTB_GCP& Image::GetGCPs(unsigned int GCPnum) { return (this->GetMetaDataInterface()->GetGCPs(GCPnum)); } template const OTB_GCP& Image::GetGCPs(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPs(GCPnum)); } template std::string Image::GetGCPId(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPId(GCPnum)); } template std::string Image::GetGCPInfo(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPInfo(GCPnum)); } template double Image::GetGCPRow(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPRow(GCPnum)); } template double Image::GetGCPCol(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPCol(GCPnum)); } template double Image::GetGCPX(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPX(GCPnum)); } template double Image::GetGCPY(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPY(GCPnum)); } template double Image::GetGCPZ(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPZ(GCPnum)); } template typename Image::VectorType Image::GetGeoTransform(void) const { return (this->GetMetaDataInterface()->GetGeoTransform()); } template typename Image::VectorType Image::GetUpperLeftCorner(void) const { return (this->GetMetaDataInterface()->GetUpperLeftCorner()); } template typename Image::VectorType Image::GetUpperRightCorner(void) const { return (this->GetMetaDataInterface()->GetUpperRightCorner()); } template typename Image::VectorType Image::GetLowerLeftCorner(void) const { return (this->GetMetaDataInterface()->GetLowerLeftCorner()); } template typename Image::VectorType Image::GetLowerRightCorner(void) const { return (this->GetMetaDataInterface()->GetLowerRightCorner()); } template typename Image::ImageKeywordlistType Image::GetImageKeywordlist(void) { ImageKeywordlistType kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwl); return kwl; } template void Image::SetImageKeywordList(const ImageKeywordlistType& kwl) { itk::EncapsulateMetaData(this->GetMetaDataDictionary(),MetaDataKey::OSSIMKeywordlistKey,kwl); } template const typename Image::ImageKeywordlistType Image::GetImageKeywordlist(void) const { ImageKeywordlistType kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwl); return kwl; } template void Image ::CopyInformation(const itk::DataObject * data) { Superclass::CopyInformation(data); this->itk::Object::SetMetaDataDictionary(data->GetMetaDataDictionary()); } template typename Image::ImageMetadataInterfacePointerType Image ::GetMetaDataInterface() const { if (m_ImageMetadataInterface.IsNull()) m_ImageMetadataInterface = ImageMetadataInterfaceFactory::CreateIMI(this->GetMetaDataDictionary()); return m_ImageMetadataInterface; } template void Image::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); this->GetMetaDataInterface()->PrintMetadata(os, indent, this->GetMetaDataDictionary()); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbImageFunctionAdaptor.h000066400000000000000000000111121301006202600260730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFunctionAdaptor_h #define otbImageFunctionAdaptor_h #include "itkImageFunction.h" #include "otbVariableLengthVectorConverter.h" #include namespace otb { /** * \class ImageFunctionAdaptor * \brief Adapt the output of the internal image function to be a * itk::VariableLengthVector. * * This class is templated over the ImageFunction type and the * coordinate representation type. * * * * \ingroup ImageFunctions * * \ingroup OTBImageBase */ template< class TInternalImageFunctionType, class TOutputPrecision = double > class ITK_EXPORT ImageFunctionAdaptor : public itk::ImageFunction< typename TInternalImageFunctionType::InputImageType, itk::VariableLengthVector, typename TInternalImageFunctionType::CoordRepType > { public: // Standard class typedefs. // typedef ImageFunctionAdaptor Self; typedef itk::ImageFunction< typename TInternalImageFunctionType::InputImageType, itk::VariableLengthVector, typename TInternalImageFunctionType::CoordRepType > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // Run-time type information (and related methods). // itkTypeMacro(ImageFunctionAdaptor, ImageFunction); // Method for creation through the object factory. // itkNewMacro(Self); // InputImageType typedef support. // typedef typename TInternalImageFunctionType::InputImageType InputImageType; typedef typename TInternalImageFunctionType::CoordRepType CoordRepType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef typename OutputType::ValueType OutputValueType; // InternalImageFunction related typedefs // typedef TInternalImageFunctionType InternalImageFunctionType; typedef typename InternalImageFunctionType::OutputType InternalImageFunctionOutputType; // Converter related typedefs // typedef VariableLengthVectorConverter ConverterType; // Dimension of the underlying image. // itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); // Evalulate the function at specified index // OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; // Evaluate the function at non-integer positions // OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } // Accessors // itkGetConstMacro(InternalImageFunction, typename InternalImageFunctionType::Pointer); itkSetMacro(InternalImageFunction, typename InternalImageFunctionType::Pointer); protected: ImageFunctionAdaptor(); ~ImageFunctionAdaptor() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageFunctionAdaptor(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Internal Image Function // typename InternalImageFunctionType::Pointer m_InternalImageFunction; // Converter // typename ConverterType::Pointer m_Converter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageFunctionAdaptor.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbImageFunctionAdaptor.txx000066400000000000000000000035071301006202600265000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFunctionAdaptor_txx #define otbImageFunctionAdaptor_txx #include "otbImageFunctionAdaptor.h" namespace otb { template< class TInternalImageFunctionType, class TOutputPrecision > ImageFunctionAdaptor< TInternalImageFunctionType, TOutputPrecision > ::ImageFunctionAdaptor() { m_InternalImageFunction = InternalImageFunctionType::New(); m_Converter = ConverterType::New(); } template< class TInternalImageFunctionType, class TOutputPrecision > void ImageFunctionAdaptor< TInternalImageFunctionType, TOutputPrecision > ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Internal Image Function: " << m_InternalImageFunction << std::endl; } template< class TInternalImageFunctionType, class TOutputPrecision > typename ImageFunctionAdaptor< TInternalImageFunctionType, TOutputPrecision >::OutputType ImageFunctionAdaptor< TInternalImageFunctionType, TOutputPrecision > ::EvaluateAtIndex(const IndexType& index) const { OutputType result; this->GetInternalImageFunction()->SetInputImage(this->GetInputImage()); InternalImageFunctionOutputType tmpResult = this->GetInternalImageFunction()->EvaluateAtIndex(index); result = m_Converter->Convert(tmpResult); return result; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbImageIOBase.h000066400000000000000000000531621301006202600241100ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: otbImageIOBase.h,v $ Language: C++ Date: $Date: 2009-11-29 15:51:11 $ Version: $Revision: 1.56 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageIOBase_h #define otbImageIOBase_h #include "itkLightProcessObject.h" #include "itkIndent.h" #include "itkImageIORegion.h" #include "vnl/vnl_vector.h" #include #include "OTBImageBaseExport.h" namespace otb { /** \class ImageIOBase * \brief Abstract superclass defines image IO interface. * * ImageIOBase is a class that reads and/or writes image data * of a particular format (such as PNG or raw binary). The * ImageIOBase encapsulates both the reading and writing of data. The * ImageIOBase is used by the ImageFileReader class (to read data) * and the ImageFileWriter (to write data) into a single file. The * ImageSeriesReader and ImageSeriesWriter classes are used to read * and write data (in conjunction with ImageIOBase) when the data is * represented by a series of files. Normally the user does not directly * manipulate this class other than to instantiate it, set the FileName, * and assign it to a ImageFileReader/ImageFileWriter or * ImageSeriesReader/ImageSeriesWriter. * * A Pluggable factory pattern is used this allows different kinds of readers * to be registered (even at run time) without having to modify the * code in this class. * * \sa ImageFileWriter * \sa ImageFileReader * \sa ImageSeriesWriter * \sa ImageSeriesReader * * \ingroup IOFilters * * * \ingroup OTBImageBase */ class OTBImageBase_EXPORT ImageIOBase : public itk::LightProcessObject { public: /** Standard class typedefs. */ typedef ImageIOBase Self; typedef itk::LightProcessObject Superclass; typedef itk::SmartPointer Pointer; /** Run-time type information (and related methods). */ itkTypeMacro(ImageIOBase, Superclass); /** Set/Get the name of the file to be read. */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); /** Types for managing image size and image index components. */ typedef long IndexValueType; typedef unsigned long SizeValueType; /** * \class UnknownType * Used to return information when types are unknown. * * \ingroup OTBImageBase */ class UnknownType {}; /** Enums used to manipulate the pixel type. The pixel type provides * context for automatic data conversions (for instance, RGB to * SCALAR, VECTOR to SCALAR). */ typedef enum {UNKNOWNPIXELTYPE,SCALAR,RGB,RGBA,OFFSET,VECTOR, POINT,COVARIANTVECTOR,SYMMETRICSECONDRANKTENSOR, DIFFUSIONTENSOR3D,COMPLEX,FIXEDARRAY,MATRIX} IOPixelType; /** Enums used to manipulate the component type. The component type * refers to the actual storage class associated with either a * SCALAR pixel type or elements of a compound pixel. */ typedef enum {UNKNOWNCOMPONENTTYPE,UCHAR,CHAR,USHORT,SHORT,UINT,INT, ULONG,LONG, FLOAT,DOUBLE, CSHORT, CINT, CFLOAT, CDOUBLE} IOComponentType; /** Set/Get the number of independent variables (dimensions) in the * image being read or written. Note this is not necessarily what * is written, rather the IORegion controls that. */ void SetNumberOfDimensions(unsigned int); itkGetConstMacro(NumberOfDimensions, unsigned int); /** Set/Get the image dimensions in the x, y, z, etc. directions. * GetDimensions() is typically used after reading the data; the * SetDimensions() is used prior to writing the data. */ virtual void SetDimensions(unsigned int i, unsigned int dim); virtual unsigned int GetDimensions(unsigned int i) const { return m_Dimensions[i]; } /** Set/Get the image origin on a axis-by-axis basis. The SetOrigin() method * is required when writing the image. */ virtual void SetOrigin(unsigned int i, double origin); virtual double GetOrigin(unsigned int i) const { return m_Origin[i]; } /** Set/Get the image spacing on an axis-by-axis basis. The * SetSpacing() method is required when writing the image. */ virtual void SetSpacing(unsigned int i, double spacing); virtual double GetSpacing(unsigned int i) const { return m_Spacing[i]; } /** Set/Get the image direction on an axis-by-axis basis. The * SetDirection() method is required when writing the image. */ virtual void SetDirection(unsigned int i, std::vector &direction); virtual void SetDirection(unsigned int i, vnl_vector &direction); virtual std::vector GetDirection(unsigned int i) const { return m_Direction[i]; } /** Return the directions to be assigned by default to recipient * images whose dimension is smaller than the image dimension in file. */ virtual std::vector GetDefaultDirection(unsigned int i) const; /** Specify the region of the image data to either read or * write. The IORegion specifies the part of the image to read or * write. Regions are defined with an index and a size vector. These * vectors define the start (lower-left corner) and length of the * region within the image. Make sure that the IORegion lies within * the image. */ itkSetMacro(IORegion, itk::ImageIORegion); itkGetConstReferenceMacro(IORegion, itk::ImageIORegion); /** Set/Get the type of the pixel. The PixelTypes provides context * to the IO mechanisms for data conversions. PixelTypes can be * SCALAR, RGB, RGBA, VECTOR, COVARIANTVECTOR, POINT, INDEX. If * the PIXELTYPE is SCALAR, then the NumberOfComponents should be 1. * Any other of PIXELTYPE will have more than one component. */ itkSetEnumMacro(PixelType, IOPixelType); itkGetEnumMacro(PixelType, IOPixelType); /** SetPixelTypeInfo is used by writers to convert from an ITK * strongly typed pixel to a ImageIO (weaker) typed pixel. This * function sets these PixelType, ComponentType, and * NumberOfComponents based on RTTI type_info structure passed * in. The function returns false if the pixel type is not * supported. */ virtual bool SetPixelTypeInfo(const std::type_info& ptype); /** Set/Get the component type of the image. This is always a native * type. */ itkSetEnumMacro(ComponentType,IOComponentType); itkGetEnumMacro(ComponentType,IOComponentType); virtual const std::type_info& GetComponentTypeInfo() const; /** Set/Get the number of components per pixel in the image. This may * be set by the reading process. For SCALAR pixel types, * NumberOfComponents will be 1. For other pixel types, * NumberOfComponents will be greater than or equal to one. */ itkSetMacro(NumberOfComponents,unsigned int); itkGetConstReferenceMacro(NumberOfComponents,unsigned int); /** Set/Get a boolean to use the compression or not. */ itkSetMacro(UseCompression,bool); itkGetConstMacro(UseCompression,bool); itkBooleanMacro(UseCompression); /** Set/Get a boolean to use streaming while reading or not. */ itkSetMacro(UseStreamedReading,bool); itkGetConstMacro(UseStreamedReading,bool); itkBooleanMacro(UseStreamedReading); /** Set/Get a boolean to use streaming while writing or not. */ itkSetMacro(UseStreamedWriting,bool); itkGetConstMacro(UseStreamedWriting,bool); itkBooleanMacro(UseStreamedWriting); /** Convenience method returns the IOComponentType as a string. This can be * used for writing output files. */ std::string GetComponentTypeAsString(IOComponentType) const; /** Convenience method returns the IOPixelType as a string. This can be * used for writing output files. */ std::string GetPixelTypeAsString(IOPixelType) const; /** Enums used to specify write style: whether binary or ASCII. Some * subclasses use this, some ignore it. */ typedef enum {ASCII,Binary,TypeNotApplicable} FileType; /** Enums used to specify byte order; whether Big Endian or Little Endian. * Some subclasses use this, some ignore it. */ typedef enum {BigEndian,LittleEndian,OrderNotApplicable} ByteOrder; /** These methods control whether the file is written binary or ASCII. * Many file formats (i.e., subclasses) ignore this flag. */ itkSetEnumMacro(FileType,FileType); itkGetEnumMacro(FileType,FileType); void SetFileTypeToASCII() { this->SetFileType(ASCII); } void SetFileTypeToBinary() { this->SetFileType(Binary); } /** These methods indicate the byte ordering of the file you are * trying to read in. These methods will then either swap or not * swap the bytes depending on the byte ordering of the machine it * is being run on. For example, reading in a BigEndian file on a * BigEndian machine will result in no swapping. Trying to read the * same file on a LittleEndian machine will result in swapping. * Note: most UNIX machines are BigEndian while PC's and VAX's are * LittleEndian. So if the file you are reading in was generated on * a VAX or PC, SetByteOrderToLittleEndian() otherwise * SetByteOrderToBigEndian(). Some ImageIOBase subclasses * ignore these methods. */ itkSetEnumMacro(ByteOrder,ByteOrder); itkGetEnumMacro(ByteOrder,ByteOrder); void SetByteOrderToBigEndian() { this->SetByteOrder(BigEndian); } void SetByteOrderToLittleEndian() { this->SetByteOrder(LittleEndian); } /** Convenience method returns the FileType as a string. This can be * used for writing output files. */ std::string GetFileTypeAsString(FileType) const; /** Convenience method returns the ByteOrder as a string. This can be * used for writing output files. */ std::string GetByteOrderAsString(ByteOrder) const; /** Type for representing size of bytes, and or positions along a file */ typedef std::streamoff SizeType; /** Type for representing size of bytes, and or positions along a memory buffer */ typedef size_t BufferSizeType; /** Convenient method for accessing the number of bytes to get to * the next pixel. Returns m_Strides[1]; * * Please note that this methods depends the private methods * ComputeStrides being called, otherwise this is the incorrect value. */ virtual SizeType GetPixelStride () const; /** Return the number of pixels in the image. */ SizeType GetImageSizeInPixels() const; /** Return the number of bytes in the image. */ SizeType GetImageSizeInBytes() const; /** Return the number of pixels times the number * of components in the image. */ SizeType GetImageSizeInComponents() const; /** Compute the size (in bytes) of the components of a pixel. For * example, and RGB pixel of unsigned char would have a * component size of 1 byte. This method can be invoked only after * the component type is set. */ virtual unsigned int GetComponentSize() const; /** Get the number of overviews available into the file specified * Returns: overview count, zero if none. */ virtual unsigned int GetOverviewsCount() = 0; /** Get information about overviews available into the file specified * Returns: overview info, empty if none. */ virtual std::vector GetOverviewsInfo() = 0; /** Provide hist about the output container to deal with complex pixel * type */ virtual void SetOutputImagePixelType( bool isComplexInternalPixelType, bool isVectorImage) = 0; /*-------- This part of the interfaces deals with reading data ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ virtual bool CanReadFile(const char*) = 0; /** Determine if the ImageIO can stream reading from this file. Default is false. */ virtual bool CanStreamRead() { return false; } /** Read the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ virtual void ReadImageInformation() = 0; /** Reads the data from disk into the memory buffer provided. */ virtual void Read(void* buffer) = 0; /*-------- This part of the interfaces deals with writing data ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ virtual bool CanWriteFile(const char*) = 0; /** Determine if the ImageIO can stream writing to this file. Default is false. * * There are two types of non exclusive streaming: pasteing subregions, and iterative * If true then */ virtual bool CanStreamWrite() { return false; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ virtual void WriteImageInformation() = 0; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegions has been set properly. The buffer is cast to a * pointer to the beginning of the image data. */ virtual void Write( const void* buffer) = 0; /* --- Support reading and writing data as a series of files. --- */ /** The different types of ImageIO's can support data of varying * dimensionality. For example, some file formats are strictly 2D * while others can support 2D, 3D, or even n-D. This method returns * true/false as to whether the ImageIO can support the dimension * indicated. */ virtual bool SupportsDimension(unsigned long dim) { return (dim == 2); } /** Method for supporting streaming. Given a requested region, determine what * could be the region that we can read from the file. This is called the * streamable region, which will be equal or smaller than the * LargestPossibleRegion (unless it was dimensionaly clipped) and * greater or equal to the RequestedRegion * * the resulting IORegion may be a greater dimensions the the * requested IORegion, if the the derived class is unable to read * the requested region. For example if the file has a size of [ 10, * 10, 10] but the requested region is [10, 10] the return may be 3 dimensions. */ virtual itk::ImageIORegion GenerateStreamableReadRegionFromRequestedRegion( const itk::ImageIORegion & requested ) const; /** Before this method is called all the configuration will be done, * that is Streaming/PasteRegion/Compression/Filename etc * If pasting is being used the number of requested splits is for that * region not the largest. The derived ImageIO class should verify that * the file is capable of being written with this configuration. * If pasted is enabled and is not support or does not work with the file, * then an excepetion should be thrown. * * The default implementation depends on CanStreamWrite. * If false then 1 is returned (unless pasting is indicated), so that the whole file will be updated in one region. * If true then its assumed that any arbitrary region can be written * to any file. So the users request will be respected. If a derived * class has more restictive conditions then they should be checked */ virtual unsigned int GetActualNumberOfSplitsForWriting(unsigned int numberOfRequestedSplits, const itk::ImageIORegion &pasteRegion, const itk::ImageIORegion &largestPossibleRegion); /** returns the ith IORegion * * numberOfActualSplits should be the value returned from GetActualNumberOfSplitsForWriting with the same parameters * * Derieved classes should overload this method to return a compatible region */ virtual itk::ImageIORegion GetSplitRegionForWriting(unsigned int ithPiece, unsigned int numberOfActualSplits, const itk::ImageIORegion &pasteRegion, const itk::ImageIORegion &largestPossibleRegion); /** Type for the list of strings to be used for extensions. */ typedef std::vector< std::string > ArrayOfExtensionsType; /** This method returns an array with the list of filename extensions * supported for reading by this ImageIO class. This is intended to * facilitate GUI and application level integration. */ const ArrayOfExtensionsType & GetSupportedReadExtensions() const; /** This method returns an array with the list of filename extensions * supported for writing by this ImageIO class. This is intended to * facilitate GUI and application level integration. */ const ArrayOfExtensionsType & GetSupportedWriteExtensions() const; protected: ImageIOBase(); ~ImageIOBase() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Used internally to keep track of the type of the pixel. */ IOPixelType m_PixelType; /** Used internally to keep track of the type of the component. It is set * when ComputeStrides() is invoked. */ IOComponentType m_ComponentType; /** Big or Little Endian, and the type of the file. (May be ignored.) */ ByteOrder m_ByteOrder; FileType m_FileType; /** Does the ImageIOBase object have enough info to be of use? */ bool m_Initialized; /** Filename to read */ std::string m_FileName; /** Stores the number of components per pixel. This will be 1 for * grayscale images, 3 for RGBPixel images, and 4 for RGBPixelA images. */ unsigned int m_NumberOfComponents; /** The number of independent dimensions in the image. */ unsigned int m_NumberOfDimensions; /** Should we compress the data? */ bool m_UseCompression; /** Should we use streaming for reading */ bool m_UseStreamedReading; /** Should we use streaming for writing */ bool m_UseStreamedWriting; /** The region to read or write. The region contains information about the * data within the region to read or write. */ itk::ImageIORegion m_IORegion; /** The array which stores the number of pixels in the x, y, z directions. */ std::vector< SizeValueType > m_Dimensions; /** The array which stores the spacing of pixels in the * x, y, z directions. */ std::vector m_Spacing; /** The array which stores the origin of the image. */ std::vector m_Origin; /** The arrays which store the direction cosines of the image. */ std::vector > m_Direction; /** Stores the number of bytes it takes to get to the next 'thing' * e.g. component, pixel, row, slice, etc. */ std::vector< SizeType > m_Strides; /** Return the object to an initialized state, ready to be used */ virtual void Reset(const bool freeDynamic = true); /** Resize the ImageIOBase object to new dimensions. */ void Resize(const unsigned int numDimensions, const unsigned int* dimensions); /** Compute the size (in bytes) of the pixel. For * example, and RGB pixel of unsigned char would have size 3 bytes. */ virtual unsigned int GetPixelSize() const; /** Calculates the different strides (distance from one thing to the next). * Upon return, * strides[0] = bytes to get to the next component of a pixel, * strides[1] = bytes to get to the next pixel in x direction, * strides[2] = bytes to get to the next row in y direction, * strides[3] = bytes to get to the next slice in z direction, etc. */ void ComputeStrides(); /** Convenient method for accessing number of bytes to get to the next pixel * component. Returns m_Strides[0]. */ SizeType GetComponentStride() const; /** Convenient method for accessing the number of bytes to get to the * next row. Returns m_Strides[2]. */ SizeType GetRowStride () const; /** Convenient method for accessing the number of bytes to get to the * next slice. Returns m_Strides[3]. */ SizeType GetSliceStride () const; /** Convenient method to write a buffer as ASCII text. */ void WriteBufferAsASCII(std::ostream& os, const void *buffer, IOComponentType ctype, SizeType numberOfBytesToWrite); /** Convenient method to read a buffer as ASCII text. */ void ReadBufferAsASCII(std::istream& os, void *buffer, IOComponentType ctype, SizeType numberOfBytesToBeRead); /** Convenient method to read a buffer as binary. Return true on success. */ bool ReadBufferAsBinary(std::istream& os, void *buffer, SizeType numberOfBytesToBeRead); /** Insert an extension to the list of supported extensions for reading. */ void AddSupportedReadExtension( const char * extension ); /** Insert an extension to the list of supported extensions for writing. */ void AddSupportedWriteExtension( const char * extension ); /** an implementation of ImageRegionSplitter:GetNumberOfSplits */ virtual unsigned int GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int numberOfRequestedSplits, const itk::ImageIORegion &pasteRegion) const; /** an implementation of ImageRegionSplitter:GetSplit */ virtual itk::ImageIORegion GetSplitRegionForWritingCanStreamWrite(unsigned int ithPiece, unsigned int numberOfActualSplits, const itk::ImageIORegion &pasteRegion) const; private: ImageIOBase(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented ArrayOfExtensionsType m_SupportedReadExtensions; ArrayOfExtensionsType m_SupportedWriteExtensions; }; } // end namespace itk #endif // otbImageIOBase_h OTB-release-5.8/Modules/Core/ImageBase/include/otbImageOfVectorsToMonoChannelExtractROI.h000066400000000000000000000102251301006202600312430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageOfVectorsToMonoChannelExtractROI_h #define otbImageOfVectorsToMonoChannelExtractROI_h #include "otbExtractROIBase.h" #include "otbImage.h" #include "otbVectorImage.h" #include "itkMacro.h" namespace otb { /** \class ImageOfVectorsToMonoChannelExtractROI * \brief * \todo Document this class * * \ingroup OTBImageBase */ template class ITK_EXPORT ImageOfVectorsToMonoChannelExtractROI : public ExtractROIBase { public: /** Standard class typedefs. */ typedef ImageOfVectorsToMonoChannelExtractROI Self; typedef ExtractROIBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageOfVectorsToMonoChannelExtractROI, ExtractROIBase); /** Image type information. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; /** Pixel type information */ typedef typename OutputImageType::ValueType OutputValueType; /** Typedef to describe the output and input image region types. */ typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::RegionType InputImageRegionType; /** Typedef to describe the type of pixel. */ typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename InputImageType::PixelType InputImagePixelType; /** Typedef to describe the output and input image index and size types. */ typedef typename OutputImageType::IndexType OutputImageIndexType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename InputImageType::SizeType InputImageSizeType; /** Selectionne le canal a traiter */ itkSetMacro(Channel, unsigned int); itkGetConstMacro(Channel, unsigned int); /** ImageDimension enumeration */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension); protected: ImageOfVectorsToMonoChannelExtractROI(); ~ImageOfVectorsToMonoChannelExtractROI() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ExtractImageFilter can produce an image which is a different * resolution than its input image. As such, ExtractImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; /** ExtractImageFilter can be implemented as a multithreaded filter. * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: ImageOfVectorsToMonoChannelExtractROI(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Channel to process [1...] */ unsigned int m_Channel; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageOfVectorsToMonoChannelExtractROI.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbImageOfVectorsToMonoChannelExtractROI.txx000066400000000000000000000072711301006202600316460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageOfVectorsToMonoChannelExtractROI_txx #define otbImageOfVectorsToMonoChannelExtractROI_txx #include "otbImageOfVectorsToMonoChannelExtractROI.h" namespace otb { /** * */ template ImageOfVectorsToMonoChannelExtractROI ::ImageOfVectorsToMonoChannelExtractROI() : m_Channel(1) { } /** * */ template void ImageOfVectorsToMonoChannelExtractROI ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } /** * ExtractImageFilter can produce an image which is a different resolution * than its input image. As such, ExtractImageFilter needs to provide an * implementation for GenerateOutputInformation() in order to inform * the pipeline execution model. The original documentation of this * method is below. * * \sa ProcessObject::GenerateOutputInformaton() */ template void ImageOfVectorsToMonoChannelExtractROI ::GenerateOutputInformation() { typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); // Analysis of processed channel if ((m_Channel <= 0) || (m_Channel > InputImagePixelType::Dimension)) { itkExceptionMacro(<< "otb::ExtractImImageOfVectorsToMonoChannelExtractROIageFilter::GenerateOutputInformation " << " Channel must be in the following range: [1;" << InputImagePixelType::Dimension << "] " << typeid(itk::ImageBase*).name()); } // Call base class implementation Superclass::GenerateOutputInformation(); } template void ImageOfVectorsToMonoChannelExtractROI ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itkDebugMacro(<< "Actually executing"); // Get the input and output pointers typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define the portion of the input to walk for this thread InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators. typedef itk::ImageRegionIterator OutputIterator; typedef itk::ImageRegionConstIterator InputIterator; OutputIterator outIt(outputPtr, outputRegionForThread); InputIterator inIt(inputPtr, inputRegionForThread); // Loop through the processed channels unsigned int channelIn(m_Channel - 1); InputImagePixelType pixelInput; while (!outIt.IsAtEnd()) { OutputImagePixelType pixelOutput; pixelInput = inIt.Get(); pixelOutput = static_cast(pixelInput[channelIn]); outIt.Set(pixelOutput); ++outIt; ++inIt; progress.CompletedPixel(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbMetaImageFunction.h000066400000000000000000000072551301006202600254040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMetaImageFunction_h #define otbMetaImageFunction_h #include "itkFunctionBase.h" #include "itkPoint.h" #include "itkVariableLengthVector.h" #include namespace otb { /** \class MetaImageFunction * \brief Concatenate results from multiple ImageFunction * * The MetaImageFunction class allows calling multiple ImageFunction at the same location * and to concatenate their result into a single VariableLengthVector. * * In the case of ImageFunction which do not produce VariableLengthVector, one can wrap these * function using the ImageFunctionAdaptor class, which will translate the image function output to * a VariableLengthVector. * * \ingroup ImageFunction * * \ingroup OTBImageBase */ template class ITK_EXPORT MetaImageFunction : public itk::FunctionBase, itk::VariableLengthVector > { public: // Standard class typedefs typedef MetaImageFunction Self; typedef itk::FunctionBase< itk::Point, itk::VariableLengthVector > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // New macro itkNewMacro(Self); // RTTI typeinfo itkTypeMacro(MetaImageFunction, itk::FunctionBase); // Input and output typedef typedef TCoordRep CoordRepType; typedef itk::Point PointType; typedef TOutputPrecision ValueType; typedef itk::VariableLengthVector OutputType; // Compatible functions typedefs typedef Superclass FunctionType; typedef typename FunctionType::Pointer FunctionPointerType; typedef std::vector FunctionContainerType; /** Evaluate the function at the given location */ OutputType Evaluate(const PointType & point) const ITK_OVERRIDE; /** Add a new function to the functions vector */ void AddFunction(FunctionType * function); /** Add a new function the functions vector (compatibility via adapters) */ // template void AddFunction(itk::ImageFunction * function); /** Clear functions vector */ void ClearFunctions(); /** Get the number of function registered */ unsigned int GetNumberOfFunctions() const; /** Retrieve the nth function */ FunctionType * GetNthFunction(unsigned int index); /** Remove the nth function */ void RemoveNthFunction(unsigned int index); protected: /** Constructor */ MetaImageFunction(); /** Destructor */ ~MetaImageFunction() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: MetaImageFunction(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented FunctionContainerType m_FunctionContainer; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMetaImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbMetaImageFunction.txx000066400000000000000000000076031301006202600257750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMetaImageFunction_txx #define otbMetaImageFunction_txx #include "otbMetaImageFunction.h" #include "otbImageFunctionAdaptor.h" #include namespace otb { template MetaImageFunction ::MetaImageFunction() : m_FunctionContainer() { } template MetaImageFunction ::~MetaImageFunction() { this->ClearFunctions(); } template void MetaImageFunction ::AddFunction(FunctionType * function) { m_FunctionContainer.push_back(function); } //template //void //MetaImageFunction //::AddFunction(itk::ImageFunction * function) // { // // Define the adapter // typedef itk::ImageFunction ImageFunctionType; // typedef otb::ImageFunctionAdapter AdapterType; // // typename AdapterType::Pointer adapter = AdapterType::New(); // adapte // // } template void MetaImageFunction ::ClearFunctions() { m_FunctionContainer.clear(); } template unsigned int MetaImageFunction ::GetNumberOfFunctions() const { return m_FunctionContainer.size(); } template typename MetaImageFunction ::FunctionType * MetaImageFunction ::GetNthFunction(unsigned int index) { return m_FunctionContainer.at(index); } template void MetaImageFunction ::RemoveNthFunction(unsigned int index) { typename FunctionContainerType::iterator fIt = m_FunctionContainer.begin()+index; m_FunctionContainer.erase(fIt); } template typename MetaImageFunction ::OutputType MetaImageFunction ::Evaluate(const PointType & point) const { // Build output OutputType resp; // For each function typename FunctionContainerType::const_iterator fIt = m_FunctionContainer.begin(); while(fIt != m_FunctionContainer.end()) { // Store current size unsigned int currentSize = static_cast(resp.GetSize()); // Call current function evaluation OutputType currentVector = (*fIt)->Evaluate(point); // Compute current vector size unsigned int currentVectorSize = static_cast(currentVector.GetSize()); // Enlarge the output vector resp.SetSize(currentSize + currentVectorSize, false); // Fill the output for(unsigned int i = 0; i < currentVectorSize; ++i) { resp.SetElement(currentSize+i, static_cast(currentVector[i])); } // Go to next function ++fIt; } return resp; } template void MetaImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os<GetNumberOfFunctions()< namespace otb { /** \class MultiChannelExtractROI * \brief Extract a spatial or spectral subset of a multi-channel image. * * It is possible to extract all the channels from the input image or only those specified by the user. * The SetChannel() method allows selecting one channel. * The SetFirstChannel() and SetLastChannel() methods allow the user to define a list of channels. * * \note If no channels are specified, then all channels from the input image are selected. * \note The image manipulated inside this class are of type otb::VectorImage. * * \ingroup OTBImageBase */ template class ITK_EXPORT MultiChannelExtractROI : public ExtractROIBase, VectorImage > { public: /** Standard class typedefs. */ typedef MultiChannelExtractROI Self; typedef ExtractROIBase, VectorImage > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiChannelExtractROI, ExtractROIBase); /** Image type information. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; /** Pixel type information */ typedef typename OutputImageType::InternalPixelType OutputValueType; /** Typedef to describe the output and input image region types. */ typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::RegionType InputImageRegionType; /** Typedef to describe the type of pixel. */ typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename InputImageType::PixelType InputImagePixelType; /** Typedef to describe the output and input image index and size types. */ typedef typename OutputImageType::IndexType OutputImageIndexType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename InputImageType::SizeType InputImageSizeType; void SetFirstChannel(unsigned int id); itkGetConstMacro(FirstChannel, unsigned int); void SetLastChannel(unsigned int id); itkGetConstMacro(LastChannel, unsigned int); /** Typedef Liste des canaux */ typedef typename std::vector ChannelsType; /** \return The list of processed channels */ ChannelsType GetChannels() const { return (m_Channels); } /** \return The number of processed channels */ unsigned int GetNbChannels() const { return (m_Channels.size()); } /** Select a channel to process \param channel The channel to process */ void SetChannel(unsigned int channel); /** Clear channels selection */ void ClearChannels(void); /** ImageDimension enumeration */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension); protected: MultiChannelExtractROI(); ~MultiChannelExtractROI() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** MultiChannelExtractROI can produce an image which is a different * resolution than its input image. As such, MultiChannelExtractROI * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; /** Reinitialize channels vector for multiple Update.*/ void ChannelsReInitialization(); /** If the user set m_First/LastChannel, chack avaliability or fill m_Channels Work.*/ void SetChannelsWorkWithLimits(); /** ExtractImageFilter can be implemented as a multithreaded filter. * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: MultiChannelExtractROI(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** First/ last channel to process [1...] */ unsigned int m_FirstChannel; unsigned int m_LastChannel; /** List of channels to process [1...] */ ChannelsType m_Channels; /** List of channels actually being processed [1...] */ ChannelsType m_ChannelsWorks; /** Used to know if the user has set m_First/LastChannel (1) or m_Channels (3)*/ int m_ChannelsKind; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMultiChannelExtractROI.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbMultiChannelExtractROI.txx000066400000000000000000000216041301006202600267230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelExtractROI_txx #define otbMultiChannelExtractROI_txx #include "otbMultiChannelExtractROI.h" #include "itkImageRegionIterator.h" #include "itkObjectFactory.h" #include "itkExtractImageFilterRegionCopier.h" #include "itkProgressReporter.h" namespace otb { /** * */ template MultiChannelExtractROI ::MultiChannelExtractROI() : ExtractROIBase, VectorImage >(), m_FirstChannel(0), m_LastChannel(0), m_ChannelsKind(0) { ClearChannels(); } /** * */ template void MultiChannelExtractROI ::SetChannel(unsigned int channel) { if (m_ChannelsKind == 1) { itkExceptionMacro(<< "m_Channels already set using channels interval."); } m_Channels.push_back(channel); if (m_ChannelsKind == 0) { m_ChannelsKind = 2; } this->Modified(); } template void MultiChannelExtractROI ::SetFirstChannel(unsigned int id) { if (m_ChannelsKind == 2) { itkExceptionMacro(<< "m_Channels already set using SetChannels method."); } m_FirstChannel = id; if (m_ChannelsKind == 0) { m_ChannelsKind = 1; } this->Modified(); } template void MultiChannelExtractROI ::SetLastChannel(unsigned int id) { if (m_ChannelsKind == 2) { itkExceptionMacro(<< "m_Channels already set using SetChannels method."); } m_LastChannel = id; if (m_ChannelsKind == 0) { m_ChannelsKind = 1; } this->Modified(); } /** * */ template void MultiChannelExtractROI ::ClearChannels(void) { m_FirstChannel = 0; m_LastChannel = 0; m_Channels.clear(); m_ChannelsKind = 0; m_ChannelsWorks.clear(); } /** * */ template void MultiChannelExtractROI ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void MultiChannelExtractROI ::ChannelsReInitialization() { // The following conditions can be gathered but we'd loose in comprehension m_ChannelsWorks.clear(); // First passage in the method: if (m_Channels.empty() == true) { // - User SetFirst/LastChannel() if (m_ChannelsKind == 1) { this->SetChannelsWorkWithLimits(); } else { // - User called SetChannels() if (m_Channels.empty() == true && m_ChannelsKind == 2) { m_ChannelsWorks = m_Channels; } } } // Second passage in the method: Update already donne else { // - User SetFirst/LastChannel() if (m_ChannelsKind == 1) { m_Channels.clear(); this->SetChannelsWorkWithLimits(); } else { // - User called SetChannels() if (m_ChannelsKind == 2) { m_ChannelsWorks = m_Channels; } } } } template void MultiChannelExtractROI ::SetChannelsWorkWithLimits() { if ((m_FirstChannel == 0) || (m_LastChannel == 0)) { itkExceptionMacro(<< "otb::ExtractImageFilter::GenerateOutputInformation " << "Channels must reside into [1...] " << typeid(itk::ImageBase*).name()); } if (m_FirstChannel > m_LastChannel) { itkExceptionMacro(<< "otb::ExtractImageFilter::GenerateOutputInformation " << "FirstChannel is greater than LastChannel" << typeid(itk::ImageBase*).name()); } for (unsigned int channel = m_FirstChannel; channel <= m_LastChannel; channel++) { m_ChannelsWorks.push_back(channel); } m_Channels = m_ChannelsWorks; } /** * ExtractImageFilter can produce an image which is a different resolution * than its input image. As such, ExtractImageFilter needs to provide an * implementation for GenerateOutputInformation() in order to inform * the pipeline execution model. The original documentation of this * method is below. * * \sa ProcessObject::GenerateOutputInformaton() */ template void MultiChannelExtractROI ::GenerateOutputInformation() { // Call to the superclass implementation Superclass::GenerateOutputInformation(); this->ChannelsReInitialization(); typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); unsigned int nbComponentsPerPixel = inputPtr->GetNumberOfComponentsPerPixel(); if (m_ChannelsKind != 0) { // Test if the asked channels index exists in the input image ChannelsType m_BadChannels; m_BadChannels.clear(); for (unsigned int i = 0; i < m_ChannelsWorks.size(); ++i) { if ((m_ChannelsWorks[i] < 1) || (m_ChannelsWorks[i] > nbComponentsPerPixel)) { bool isInsideBadChannels = false; for (unsigned int j = 0; j < m_BadChannels.size(); ++j) { if (m_BadChannels[j] == m_ChannelsWorks[i]) isInsideBadChannels = true; } if (!isInsideBadChannels) m_BadChannels.push_back(m_ChannelsWorks[i]); } } if (m_BadChannels.empty() == false) { std::ostringstream oss; oss << "otb::ExtractImageFilter::GenerateOutputInformation : "; oss << "Channel(s) [ "; for (unsigned int i = 0; i < m_BadChannels.size(); ++i) { oss << m_BadChannels[i] << " "; } oss << "] not authorized."; oss << " Each channel index has to be in [1," << nbComponentsPerPixel << "]."; itkExceptionMacro(<< oss.str().c_str()); } nbComponentsPerPixel = m_ChannelsWorks.size(); } // initialize the number of channels of the output image outputPtr->SetNumberOfComponentsPerPixel(nbComponentsPerPixel); } template void MultiChannelExtractROI ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itkDebugMacro(<< "Actually executing"); // Get the input and output pointers typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define the portion of the input to walk for this thread InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators. typedef itk::ImageRegionIterator OutputIterator; typedef itk::ImageRegionConstIterator InputIterator; OutputIterator outIt(outputPtr, outputRegionForThread); InputIterator inIt(inputPtr, inputRegionForThread); outIt.GoToBegin(); inIt.GoToBegin(); // if default behaviour if (m_ChannelsKind == 0) { // walk the output region, and sample the input image while (!outIt.IsAtEnd()) { outIt.Set(inIt.Get()); ++outIt; ++inIt; progress.CompletedPixel(); } } // Specific behaviour else { // for each channel to process unsigned int channelIn(0); unsigned int channelOut(0); unsigned int nbChannels(0); InputImagePixelType pixelInput; while (!outIt.IsAtEnd()) { OutputImagePixelType pixelOutput; pixelOutput.Reserve(outputPtr->GetVectorLength()); pixelInput = inIt.Get(); channelOut = 0; for (nbChannels = 0; nbChannels < m_ChannelsWorks.size(); ++nbChannels) { channelIn = m_ChannelsWorks[nbChannels] - 1; pixelOutput[channelOut] = static_cast(pixelInput[channelIn]); channelOut++; } outIt.Set(pixelOutput); ++outIt; ++inIt; progress.CompletedPixel(); } } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbMultiToMonoChannelExtractROI.h000066400000000000000000000115231301006202600274620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiToMonoChannelExtractROI_h #define otbMultiToMonoChannelExtractROI_h #include "otbExtractROIBase.h" #include "otbImage.h" #include "otbVectorImage.h" #include "itkMacro.h" namespace otb { /** \class MultiToMonoChannelExtractROI * \brief Extract a mono channel part of a multi-channel image. * * This filter extracts either all channels or only those specified by the user. * The SetChannel method allows selecting the channels to process. * \note If nothing is specified, only the first channel is processed. * \note This class is templated over the pixel types of the input and output images. * The input image has to be an otb::VectorImage, whereas the output image has to be an otb::Image. * * \ingroup OTBImageBase */ template class ITK_EXPORT MultiToMonoChannelExtractROI : // public ExtractROIBase< itk::VectorImage , itk::Image > public ExtractROIBase, Image > { public: /** Standard class typedefs. */ typedef MultiToMonoChannelExtractROI Self; // typedef ExtractROIBase< itk::VectorImage , itk::Image > Superclass; typedef ExtractROIBase, Image > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiToMonoChannelExtractROI, ExtractROIBase); /** Image type information. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; /** Pixel type information */ typedef typename OutputImageType::ValueType OutputValueType; /** Typedef to describe the output and input image region types. */ typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::RegionType InputImageRegionType; /** Typedef to describe the type of pixel. */ typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename InputImageType::PixelType InputImagePixelType; /** Typedef to describe the output and input image index and size types. */ typedef typename OutputImageType::IndexType OutputImageIndexType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename InputImageType::SizeType InputImageSizeType; /** Selectionne le canal a traiter */ itkSetMacro(Channel, unsigned int); itkGetConstMacro(Channel, unsigned int); /** ImageDimension enumeration */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension); protected: MultiToMonoChannelExtractROI(); ~MultiToMonoChannelExtractROI() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ExtractImageFilter can produce an image which is a different * resolution than its input image. As such, ExtractImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; /** ExtractImageFilter can be implemented as a multithreaded filter. * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: MultiToMonoChannelExtractROI(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Channel to process [1...] */ unsigned int m_Channel; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMultiToMonoChannelExtractROI.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbMultiToMonoChannelExtractROI.txx000066400000000000000000000073361301006202600300650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiToMonoChannelExtractROI_txx #define otbMultiToMonoChannelExtractROI_txx #include "otbMultiToMonoChannelExtractROI.h" namespace otb { /** * */ template MultiToMonoChannelExtractROI ::MultiToMonoChannelExtractROI() : ExtractROIBase, Image >(), m_Channel(1) { } /** * */ template void MultiToMonoChannelExtractROI ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } /** * ExtractImageFilter can produce an image which is a different resolution * than its input image. As such, ExtractImageFilter needs to provide an * implementation for GenerateOutputInformation() in order to inform * the pipeline execution model. The original documentation of this * method is below. * * \sa ProcessObject::GenerateOutputInformaton() */ template void MultiToMonoChannelExtractROI ::GenerateOutputInformation() { typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); // Bounds checking for the channel to process if ((m_Channel <= 0) || (m_Channel > inputPtr->GetVectorLength())) { itkExceptionMacro(<< "otb::MultiToMonoChannelExtractROI::GenerateOutputInformation " << "The selected channel must in the range [1;" << inputPtr->GetVectorLength() << "] " << typeid(itk::ImageBase*).name()); } // Calling the superclass method Superclass::GenerateOutputInformation(); } template void MultiToMonoChannelExtractROI ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itkDebugMacro(<< "Actually executing"); // Get the input and output pointers typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define the portion of the input to walk for this thread InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators. typedef itk::ImageRegionIterator OutputIterator; typedef itk::ImageRegionConstIterator InputIterator; OutputIterator outIt(outputPtr, outputRegionForThread); InputIterator inIt(inputPtr, inputRegionForThread); // Parcours des canaux a traiter const unsigned int channelIn(m_Channel - 1); while (!outIt.IsAtEnd()) { InputImagePixelType const& pixelInput = inIt.Get(); OutputImagePixelType const pixelOutput = static_cast(pixelInput[channelIn]); outIt.Set(pixelOutput); ++outIt; ++inIt; progress.CompletedPixel(); } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbRemoteSensingRegion.h000066400000000000000000000261641301006202600257730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRemoteSensingRegion_h #define otbRemoteSensingRegion_h #include #include #include "otbImageKeywordlist.h" #include "itkImageRegion.h" namespace otb { /** \class RemoteSensingRegion * \brief An RemoteSensingRegion represents a structured region of data. * * RemoteSensingRegion is an class that represents some structured portion or * piece of an Image. The RemoteSensingRegion is represented with an index and * a size in each of the n-dimensions of the image. (The index is the * corner of the image, the size is the lengths of the image in each of * the topological directions. For this class, the notion of index and origin * are the same.) * * As the size and origin can be given in various system coordinates, they contain * double values (through the use of an itk::ContinuousIndex). * * To be flexible enough, the region also contain information about the projection * in which this information is given. It can be a cartographic projection, but also * a sensor model projection (hence making it useful also with non-orthorectified * images). * * \sa VectorDataExtractROI * * \ingroup OTBImageBase */ template class ITK_EXPORT RemoteSensingRegion : public itk::Region { public: /** Standard class typedefs. */ typedef otb::RemoteSensingRegion Self; typedef itk::Region Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard part of all itk objects. */ itkTypeMacro(RemoteSensingRegion, itk : Region); /** Typedef Support*/ typedef TType Type; /** Index typedef support. An index is used to access pixel values. */ typedef itk::ContinuousIndex IndexType; typedef itk::Point PointType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::ContinuousIndex SizeType; // typedef itk::Size<2> StandardSizeType; /** ImageRegion typedef needed by the GetImageRegion() method */ typedef itk::ImageRegion<2> ImageRegionType; typename Superclass::RegionType GetRegionType() const ITK_OVERRIDE {return Superclass::ITK_STRUCTURED_REGION; } /** Constructor. RemoteSensingRegion is a lightweight object that is not reference * counted, so the constructor is public. Default dimension is 2. */ RemoteSensingRegion() { m_InputProjectionRef = ""; m_Size.Fill(0.); m_Index.Fill(0.); } /** Constructor. RemoteSensingRegion is a lightweight object that is not reference * counted, so the constructor is public. Default dimension is 2. */ RemoteSensingRegion(const itk::ImageRegion<2>®ion) { m_InputProjectionRef = ""; m_Size[0] = region.GetSize()[0]; m_Size[1] = region.GetSize()[1]; m_Index[0] = region.GetIndex()[0]; m_Index[1] = region.GetIndex()[1]; } /** Destructor. RemoteSensingRegion is a lightweight object that is not reference * counted, so the destructor is public. */ ~RemoteSensingRegion() ITK_OVERRIDE{} /** operator=. RemoteSensingRegion is a lightweight object that is not reference * counted, so operator= is public. */ void operator =(const Self& region) { m_Index = region.m_Index; m_Size = region.m_Size; m_InputProjectionRef = region.m_InputProjectionRef; m_KeywordList = region.m_KeywordList; } /** This method provides explicit conversion to itk::ImageRegion<2>, * so as to allow using RemoteSensingRegion to specify requested * region for images or images iterators. */ const ImageRegionType GetImageRegion() { ImageRegionType imageRegion; typename ImageRegionType::IndexType irIndex; typename ImageRegionType::SizeType irSize; irIndex[0] = static_cast(vcl_floor(m_Index[0])); irIndex[1] = static_cast(vcl_floor(m_Index[1])); irSize[0] = static_cast(vcl_ceil(m_Size[0])); irSize[1] = static_cast(vcl_ceil(m_Size[1])); imageRegion.SetIndex(irIndex); imageRegion.SetSize(irSize); return imageRegion; } /** Set the index defining the corner of the region. */ void SetOrigin(const IndexType& index) { m_Index = index; } /** Set the index defining the corner of the region. */ void SetOrigin(const PointType& index) { m_Index[0] = index[0]; m_Index[1] = index[1]; } /** Get index defining the corner of the region. */ const IndexType& GetOrigin() const { return m_Index; } /** Set the index defining the corner of the region. */ void SetIndex(const IndexType& index) { m_Index = index; } /** Get index defining the corner of the region. */ const IndexType& GetIndex() const { return m_Index; } /** Set the size of the region. This plus the index determines the * rectangular shape, or extent, of the region. */ void SetSize(const SizeType& size) { m_Size = size; } // void SetSize(const StandardSizeType &size) // { // m_Size[0] = size[0]; // m_Size[1] = size[1]; // } /** Get the size of the region. */ const SizeType& GetSize() const { return m_Size; } /** Convenience methods to get the size of the image in a particular * coordinate direction i. Do not try to access image sizes beyond the * the ImageDimension. */ Type GetSize(unsigned int i) const { return m_Size[i]; } Type GetOrigin(unsigned int i) const { return m_Index[i]; } void SetSize(const unsigned int i, Type size) { m_Size[i] = size; } void SetOrigin(const unsigned int i, Type idx) { m_Index[i] = idx; } const ImageKeywordlist& GetKeywordList() const { return m_KeywordList; } void SetKeywordList(const ImageKeywordlist& kwl) { this->m_KeywordList = kwl; } /** Compare two regions. */ bool operator ==(const Self& region) const { bool same = 1; same = (m_Index == region.m_Index); same = same && (m_Size == region.m_Size); return same; } /** Compare two regions. */ bool operator !=(const Self& region) const { bool same = 1; same = (m_Index == region.m_Index); same = same && (m_Size == region.m_Size); return !same; } /** Test if an index is inside */ bool IsInside(const IndexType& index) const { for (unsigned int i = 0; i < IndexType::IndexDimension; ++i) { if ((index[i] < m_Index[i]) && (index[i] < m_Index[i] + m_Size[i])) { return false; } if ((index[i] >= m_Index[i]) && (index[i] >= m_Index[i] + m_Size[i])) { return false; } } return true; } /**Get/Set InputProjectionRef std::string*/ void SetRegionProjection(const std::string& projection) {m_InputProjectionRef = projection; } std::string GetRegionProjection() { return m_InputProjectionRef; } /** * Crop */ bool Crop(const Self& region) { Type crop; bool cropPossible = true; // Can we crop? for (unsigned int i = 0; i < IndexType::IndexDimension && cropPossible; ++i) { if ( ((region.GetOrigin()[i] <= m_Index[i]) && (region.GetOrigin()[i] <= m_Index[i] + static_cast(m_Size[i])) && ((region.GetOrigin()[i] + static_cast(region.GetSize()[i])) <= m_Index[i]) && ((region.GetOrigin()[i] + static_cast(region.GetSize()[i])) <= m_Index[i] + static_cast(m_Size[i])) ) || ((region.GetOrigin()[i] >= m_Index[i]) && (region.GetOrigin()[i] >= m_Index[i] + static_cast(m_Size[i])) && ((region.GetOrigin()[i] + static_cast(region.GetSize()[i])) >= m_Index[i]) && ((region.GetOrigin()[i] + static_cast(region.GetSize()[i])) >= m_Index[i] + static_cast(m_Size[i])) ) ) { return false; } } // we can crop, so crop for (unsigned int i = 0; i < IndexType::IndexDimension; ++i) { // first check the start index if (m_Index[i] < region.GetOrigin()[i]) { // how much do we need to adjust crop = region.GetOrigin()[i] - m_Index[i]; // adjust the start index and the size of the current region m_Index[i] += crop; m_Size[i] -= static_cast(crop); } // now check the final size if (m_Index[i] + static_cast(m_Size[i]) > region.GetOrigin()[i] + static_cast(region.GetSize()[i])) { // how much do we need to adjust crop = m_Index[i] + static_cast(m_Size[i]) - region.GetOrigin()[i] - static_cast(region.GetSize()[i]); // adjust the size m_Size[i] -= static_cast(crop); } } return cropPossible; } protected: void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { os << std::setprecision(15); os << indent << "RemoteSensingRegion" << std::endl; os << indent << "Index:" << this->m_Index << std::endl; os << indent << "Size:" << this->m_Size << std::endl; os << indent << "Projection:" << this->m_InputProjectionRef << std::endl; os << indent << "Keywordlist: " << this->m_KeywordList << std::endl; } private: IndexType m_Index; SizeType m_Size; std::string m_InputProjectionRef; ImageKeywordlist m_KeywordList; //if we want to specify the region in term of sensor geometry }; //extern std::ostream & operator<<(std::ostream &os, const RemoteSensingRegion ®ion); template std::ostream & operator <<(std::ostream& os, const RemoteSensingRegion& region) { region.Print(os); return os; } template typename ImageType::RegionType TransformPhysicalRegionToIndexRegion(const RemoteSensingRegionType& region, const ImageType* image) { typename ImageType::RegionType outputRegion; typename ImageType::RegionType::IndexType index; typename ImageType::RegionType::IndexType index2; typename ImageType::PointType point; point[0] = region.GetIndex()[0]; point[1] = region.GetIndex()[1]; image->TransformPhysicalPointToIndex(point, index); point[0] = region.GetIndex()[0] + region.GetSize()[0]; point[1] = region.GetIndex()[1] + region.GetSize()[1]; image->TransformPhysicalPointToIndex(point, index2); typename ImageType::RegionType::SizeType size; size[0] = std::abs(index2[0] - index[0]); size[1] = std::abs(index2[1] - index[1]); index[0] = std::min(index2[0], index[0]); index[1] = std::min(index2[1], index[1]); outputRegion.SetIndex(index); outputRegion.SetSize(size); return outputRegion; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbVectorImage.h000066400000000000000000000165431301006202600242520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImage_h #define otbVectorImage_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include "itkVectorImage.h" #pragma GCC diagnostic pop #else #include "itkVectorImage.h" #endif #include "otbImageMetadataInterfaceBase.h" namespace otb { /** \class VectorImage * \brief Creation of an "otb" vector image which contains metadata. * * * \ingroup OTBImageBase */ template class ITK_EXPORT VectorImage : public itk::VectorImage { public: /** Standard class typedefs. */ typedef VectorImage Self; typedef itk::VectorImage Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::WeakPointer ConstWeakPointer; typedef ImageMetadataInterfaceBase::VectorType VectorType; typedef ImageMetadataInterfaceBase::ImageKeywordlistType ImageKeywordlistType; typedef ImageMetadataInterfaceBase::Pointer ImageMetadataInterfacePointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorImage, itk::VectorImage); /** Pixel typedef support. Used to declare pixel type in filters * or other operations. */ typedef typename Superclass::PixelType PixelType; /** Typedef alias for PixelType */ typedef typename Superclass::ValueType ValueType; /** Internal Pixel representation. Used to maintain a uniform API * with Image Adaptors and allow keeping a particular internal * representation of data while showing a different external * representation. */ typedef typename Superclass::InternalPixelType InternalPixelType; typedef typename Superclass::IOPixelType IOPixelType; /** Accessor type that convert data between internal and external * representations. */ //typedef itk::DefaultVectorPixelAccessor< InternalPixelType > AccessorType; /** Functor to provide a common API between DefaultPixelAccessor and * DefaultVectorPixelAccessor */ typedef itk::DefaultVectorPixelAccessorFunctor AccessorFunctorType; /** Tyepdef for the functor used to access a neighborhood of pixel pointers.*/ typedef itk::VectorImageNeighborhoodAccessorFunctor< Self> NeighborhoodAccessorFunctorType; /** Dimension of the image. This constant is used by functions that are * templated over image type (as opposed to being templated over pixel type * and dimension) when they need compile time access to the dimension of * the image. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Container used to store pixels in the image. */ typedef typename Superclass::PixelContainer PixelContainer; /** Index typedef support. An index is used to access pixel values. */ typedef typename Superclass::IndexType IndexType; /** Offset typedef support. An offset is used to access pixel values. */ typedef typename Superclass::OffsetType OffsetType; /** Size typedef support. A size is used to define region bounds. */ typedef typename Superclass::SizeType SizeType; /** Direction typedef support. A matrix of direction cosines. */ typedef typename Superclass::DirectionType DirectionType; /** Region typedef support. A region is used to specify a subset of an image. */ typedef typename Superclass::RegionType RegionType; /** Spacing typedef support. Spacing holds the size of a pixel. The * spacing is the geometric distance between image samples. */ typedef typename Superclass::SpacingType SpacingType; /** Origin typedef support. The origin is the geometric coordinates * of the index (0, 0). */ typedef typename Superclass::PointType PointType; /** Get the projection coordinate system of the image. */ virtual std::string GetProjectionRef(void) const; virtual void SetProjectionRef(const std::string& wkt); /** Get the GCP projection coordinates of the image. */ virtual std::string GetGCPProjection(void) const; virtual unsigned int GetGCPCount(void) const; virtual OTB_GCP& GetGCPs(unsigned int GCPnum); virtual const OTB_GCP& GetGCPs(unsigned int GCPnum) const; virtual std::string GetGCPId(unsigned int GCPnum) const; virtual std::string GetGCPInfo(unsigned int GCPnum) const; virtual double GetGCPRow(unsigned int GCPnum) const; virtual double GetGCPCol(unsigned int GCPnum) const; virtual double GetGCPX(unsigned int GCPnum) const; virtual double GetGCPY(unsigned int GCPnum) const; virtual double GetGCPZ(unsigned int GCPnum) const; /** Get the six coefficients of affine geoTtransform. */ virtual VectorType GetGeoTransform(void) const; /** Get image corners. */ virtual VectorType GetUpperLeftCorner(void) const; virtual VectorType GetUpperRightCorner(void) const; virtual VectorType GetLowerLeftCorner(void) const; virtual VectorType GetLowerRightCorner(void) const; /** Get image keyword list */ virtual ImageKeywordlistType GetImageKeywordlist(void); virtual const ImageKeywordlistType GetImageKeywordlist(void) const; virtual void SetImageKeywordList(const ImageKeywordlistType& kwl); /// Copy metadata from a DataObject void CopyInformation(const itk::DataObject *) ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Return the Pixel Accessor object */ // AccessorType GetPixelAccessor( void ) // { // return AccessorType( this->GetNumberOfComponentsPerPixel() ); // } // /** Return the Pixel Accesor object */ // const AccessorType GetPixelAccessor( void ) const // { // return AccessorType( this->GetNumberOfComponentsPerPixel() ); // } /** Return the NeighborhoodAccessor functor */ NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() { return NeighborhoodAccessorFunctorType(this->GetNumberOfComponentsPerPixel()); } /** Return the NeighborhoodAccessor functor */ const NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() const { return NeighborhoodAccessorFunctorType(this->GetNumberOfComponentsPerPixel()); } protected: VectorImage(); ~VectorImage() ITK_OVERRIDE {} private: VectorImage(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Return the ImageMetadataInterfacePointer associated to the data * and creates it on first call */ ImageMetadataInterfacePointerType GetMetaDataInterface() const; // The image metadata accessor object. Don't use it directly. Instead use GetMetaDataInterface() mutable ImageMetadataInterfacePointerType m_ImageMetadataInterface; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorImage.txx" #endif #endif OTB-release-5.8/Modules/Core/ImageBase/include/otbVectorImage.txx000066400000000000000000000153221301006202600246400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImage_txx #define otbVectorImage_txx #include "otbVectorImage.h" #include "otbImageMetadataInterfaceFactory.h" #include "otbImageKeywordlist.h" #include "itkMetaDataObject.h" namespace otb { template VectorImage::VectorImage() { } template std::string VectorImage::GetProjectionRef(void) const { return (this->GetMetaDataInterface()->GetProjectionRef()); } template void VectorImage::SetProjectionRef(const std::string& kwl) { itk::EncapsulateMetaData(this->GetMetaDataDictionary(),MetaDataKey::ProjectionRefKey,kwl); } template std::string VectorImage::GetGCPProjection(void) const { return (this->GetMetaDataInterface()->GetGCPProjection()); } template unsigned int VectorImage::GetGCPCount(void) const { return (this->GetMetaDataInterface()->GetGCPCount()); } template OTB_GCP& VectorImage::GetGCPs(unsigned int GCPnum) { return (this->GetMetaDataInterface()->GetGCPs(GCPnum)); } template const OTB_GCP& VectorImage::GetGCPs(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPs(GCPnum)); } template std::string VectorImage::GetGCPId(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPId(GCPnum)); } template std::string VectorImage::GetGCPInfo(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPInfo(GCPnum)); } template double VectorImage::GetGCPRow(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPRow(GCPnum)); } template double VectorImage::GetGCPCol(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPCol(GCPnum)); } template double VectorImage::GetGCPX(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPX(GCPnum)); } template double VectorImage::GetGCPY(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPY(GCPnum)); } template double VectorImage::GetGCPZ(unsigned int GCPnum) const { return (this->GetMetaDataInterface()->GetGCPZ(GCPnum)); } template typename VectorImage::VectorType VectorImage::GetGeoTransform(void) const { return (this->GetMetaDataInterface()->GetGeoTransform()); } template typename VectorImage::VectorType VectorImage::GetUpperLeftCorner(void) const { return (this->GetMetaDataInterface()->GetUpperLeftCorner()); } template typename VectorImage::VectorType VectorImage::GetUpperRightCorner(void) const { return (this->GetMetaDataInterface()->GetUpperRightCorner()); } template typename VectorImage::VectorType VectorImage::GetLowerLeftCorner(void) const { return (this->GetMetaDataInterface()->GetLowerLeftCorner()); } template typename VectorImage::VectorType VectorImage::GetLowerRightCorner(void) const { return (this->GetMetaDataInterface()->GetLowerRightCorner()); } template typename VectorImage::ImageKeywordlistType VectorImage::GetImageKeywordlist(void) { ImageKeywordlist kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwl); return kwl; } template const typename VectorImage::ImageKeywordlistType VectorImage::GetImageKeywordlist(void) const { ImageKeywordlist kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwl); return kwl; } template void VectorImage::SetImageKeywordList(const ImageKeywordlistType& kwl) { itk::EncapsulateMetaData(this->GetMetaDataDictionary(),MetaDataKey::OSSIMKeywordlistKey,kwl); } template void VectorImage ::CopyInformation(const itk::DataObject * data) { Superclass::CopyInformation(data); this->itk::Object::SetMetaDataDictionary(data->GetMetaDataDictionary()); } template typename VectorImage::ImageMetadataInterfacePointerType VectorImage ::GetMetaDataInterface() const { if (m_ImageMetadataInterface.IsNull()) m_ImageMetadataInterface = ImageMetadataInterfaceFactory::CreateIMI(this->GetMetaDataDictionary()); return m_ImageMetadataInterface; } template void VectorImage::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); this->GetMetaDataInterface()->PrintMetadata(os, indent, this->GetMetaDataDictionary()); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ImageBase/otb-module.cmake000066400000000000000000000006261301006202600226100ustar00rootroot00000000000000set(DOCUMENTATION "This module contains base classes that allow the representation of mono- and multiband images.") otb_module(OTBImageBase ENABLE_SHARED DEPENDS OTBCommon OTBITK OTBMetadata OTBOSSIMAdapters TEST_DEPENDS OTBBoost OTBDescriptors OTBImageIO OTBImageManipulation OTBMoments OTBStatistics OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/ImageBase/src/000077500000000000000000000000001301006202600203225ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ImageBase/src/CMakeLists.txt000066400000000000000000000003731301006202600230650ustar00rootroot00000000000000set(OTBImageBase_SRC otbImageIOBase.cxx ) add_library(OTBImageBase ${OTBImageBase_SRC}) target_link_libraries(OTBImageBase ${OTBCommon_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBMetadata_LIBRARIES} ) otb_module_target(OTBImageBase) OTB-release-5.8/Modules/Core/ImageBase/src/otbImageIOBase.cxx000066400000000000000000001043051301006202600236230ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: otbImageIOBase.cxx,v $ Language: C++ Date: $Date: 2010-06-14 18:55:23 $ Version: $Revision: 1.90 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbImageIOBase.h" #include "itkRGBPixel.h" #include "itkRGBAPixel.h" #include "itkOffset.h" #include "itkPoint.h" #include "itkCovariantVector.h" #include "itkDiffusionTensor3D.h" #include "itkImageRegionSplitter.h" namespace otb { ImageIOBase::ImageIOBase() : m_PixelType(SCALAR), m_ComponentType(UNKNOWNCOMPONENTTYPE), m_ByteOrder(OrderNotApplicable), m_FileType(TypeNotApplicable), m_NumberOfDimensions(0) { Reset(false); } void ImageIOBase::Reset(const bool) { m_Initialized = false; m_FileName = ""; m_NumberOfComponents = 1; for (unsigned int i=0; i < m_NumberOfDimensions; i++) { m_Dimensions[i] = 0; m_Strides[i] = 0; } m_NumberOfDimensions = 0; m_UseCompression = false; m_UseStreamedReading = false; m_UseStreamedWriting = false; } ImageIOBase::~ImageIOBase() { } const ImageIOBase::ArrayOfExtensionsType & ImageIOBase::GetSupportedWriteExtensions() const { return this->m_SupportedWriteExtensions; } const ImageIOBase::ArrayOfExtensionsType & ImageIOBase::GetSupportedReadExtensions() const { return this->m_SupportedReadExtensions; } void ImageIOBase::AddSupportedReadExtension( const char * extension ) { this->m_SupportedReadExtensions.push_back( extension ); } void ImageIOBase::AddSupportedWriteExtension( const char * extension ) { this->m_SupportedWriteExtensions.push_back( extension ); } void ImageIOBase::Resize(const unsigned int numDimensions, const unsigned int* dimensions) { m_NumberOfDimensions = numDimensions; if (dimensions != ITK_NULLPTR) { for (unsigned int i=0; i < m_NumberOfDimensions; i++) { m_Dimensions[i] = dimensions[i]; } ComputeStrides(); } } void ImageIOBase::SetDimensions(unsigned int i, unsigned int dim) { if ( i >= m_Dimensions.size() ) { itkWarningMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Dimensions.size()); itkExceptionMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Dimensions.size()); } this->Modified(); m_Dimensions[i] = dim; } void ImageIOBase::SetOrigin(unsigned int i, double origin) { if ( i >= m_Origin.size() ) { itkWarningMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Origin.size()); itkExceptionMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Origin.size()); } this->Modified(); m_Origin[i] = origin; } void ImageIOBase::SetSpacing(unsigned int i, double spacing) { if (i >= m_Spacing.size() ) { itkWarningMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Spacing.size()); itkExceptionMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Spacing.size()); } this->Modified(); m_Spacing[i] = spacing; } void ImageIOBase::SetDirection(unsigned int i, std::vector &direction) { if (i >= m_Direction.size() ) { itkWarningMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Direction.size()); itkExceptionMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Direction.size()); } this->Modified(); m_Direction[i] = direction; } void ImageIOBase::SetDirection(unsigned int i, vnl_vector &direction) { if (i >= m_Direction.size() ) { itkWarningMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Direction.size()); itkExceptionMacro("Index: " << i << " is out of bounds, expected maximum is " << m_Direction.size()); } this->Modified(); std::vector v; v.resize(m_Direction.size()); for (unsigned int j=0; j < v.size(); j++) { v[j] = direction[j]; } m_Direction[i] = v; } const std::type_info& ImageIOBase::GetComponentTypeInfo() const { switch(m_ComponentType) { case UCHAR: return typeid(unsigned char); case CHAR: return typeid(char); case USHORT: return typeid(unsigned short); case SHORT: return typeid(short); case UINT: return typeid(unsigned int); case INT: return typeid(int); case ULONG: return typeid(unsigned long); case LONG: return typeid(long); case FLOAT: return typeid(float); case DOUBLE: return typeid(double); case CSHORT: return typeid(std::complex); case CINT: return typeid(std::complex); case CFLOAT: return typeid(std::complex); case CDOUBLE: return typeid(std::complex); case UNKNOWNCOMPONENTTYPE: default: itkExceptionMacro ("Unknown component type: " << m_ComponentType); } } // // This macro enforces pixel type information to be available for all different // pixel types. // template bool itkSetPixelType(ImageIOBase *This, const std::type_info &ptype, ImageIOBase::IOComponentType ntype, T itkNotUsed( dummy ) ) { if( ptype == typeid(T) ) { This->SetNumberOfComponents(1); This->SetComponentType(ntype); This->SetPixelType(ImageIOBase::SCALAR); return true; } else if ( ptype == typeid(itk::RGBPixel) ) { This->SetNumberOfComponents(3); This->SetComponentType(ntype); This->SetPixelType(ImageIOBase::RGB); return true; } else if ( ptype == typeid(itk::RGBAPixel) ) { This->SetNumberOfComponents(4); This->SetComponentType(ntype); This->SetPixelType(ImageIOBase::RGBA); return true; } else if ( ptype == typeid(itk::Vector) ) { This->SetNumberOfComponents(2); This->SetPixelType(ImageIOBase::VECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::Vector) ) { This->SetNumberOfComponents(3); This->SetPixelType(ImageIOBase::VECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::Vector) ) { This->SetNumberOfComponents(4); This->SetPixelType(ImageIOBase::VECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::Vector) ) { This->SetNumberOfComponents(5); This->SetPixelType(ImageIOBase::VECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::Vector) ) { This->SetNumberOfComponents(6); This->SetPixelType(ImageIOBase::VECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::Vector) ) { This->SetNumberOfComponents(7); This->SetPixelType(ImageIOBase::VECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::CovariantVector) ) { This->SetNumberOfComponents(2); This->SetPixelType(ImageIOBase::COVARIANTVECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::CovariantVector) ) { This->SetNumberOfComponents(3); This->SetPixelType(ImageIOBase::COVARIANTVECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::CovariantVector) ) { This->SetNumberOfComponents(4); This->SetPixelType(ImageIOBase::COVARIANTVECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::CovariantVector) ) { This->SetNumberOfComponents(5); This->SetPixelType(ImageIOBase::COVARIANTVECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::CovariantVector) ) { This->SetNumberOfComponents(6); This->SetPixelType(ImageIOBase::COVARIANTVECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::CovariantVector) ) { This->SetNumberOfComponents(7); This->SetPixelType(ImageIOBase::COVARIANTVECTOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::FixedArray) ) { This->SetNumberOfComponents(2); This->SetPixelType(ImageIOBase::FIXEDARRAY); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::FixedArray) ) { This->SetNumberOfComponents(3); This->SetPixelType(ImageIOBase::FIXEDARRAY); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::FixedArray) ) { This->SetNumberOfComponents(4); This->SetPixelType(ImageIOBase::FIXEDARRAY); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::SymmetricSecondRankTensor) ) { This->SetNumberOfComponents(3); This->SetPixelType(ImageIOBase::SYMMETRICSECONDRANKTENSOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::SymmetricSecondRankTensor) ) { This->SetNumberOfComponents(6); This->SetPixelType(ImageIOBase::SYMMETRICSECONDRANKTENSOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::SymmetricSecondRankTensor) ) { This->SetNumberOfComponents(10); This->SetPixelType(ImageIOBase::SYMMETRICSECONDRANKTENSOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::SymmetricSecondRankTensor) ) { This->SetNumberOfComponents(15); This->SetPixelType(ImageIOBase::SYMMETRICSECONDRANKTENSOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::SymmetricSecondRankTensor) ) { This->SetNumberOfComponents(21); This->SetPixelType(ImageIOBase::SYMMETRICSECONDRANKTENSOR); This->SetComponentType(ntype); return true; } else if ( ptype == typeid(itk::DiffusionTensor3D) ) { This->SetNumberOfComponents(6); This->SetComponentType(ntype); This->SetPixelType(ImageIOBase::DIFFUSIONTENSOR3D); return true; } else if ( ptype == typeid(itk::Matrix) ) { This->SetNumberOfComponents(4); This->SetComponentType(ntype); This->SetPixelType(ImageIOBase::MATRIX); return true; } else if ( ptype == typeid(itk::Matrix) ) { This->SetNumberOfComponents(9); This->SetComponentType(ntype); This->SetPixelType(ImageIOBase::MATRIX); return true; } else if ( ptype == typeid(itk::Matrix) ) { This->SetNumberOfComponents(16); This->SetComponentType(ntype); This->SetPixelType(ImageIOBase::MATRIX); return true; } return false; } // // This macro enforces pixel type information to be available for all different // pixel types. // template bool itkSetPixelType(ImageIOBase *This, const std::type_info &ptype, ImageIOBase::IOComponentType itkNotUsed(ntype), std::complex itkNotUsed( dummy ) ) { if (ptype == typeid(std::complex)) { This->SetNumberOfComponents(1); This->SetComponentType(ImageIOBase::CSHORT); This->SetPixelType(ImageIOBase::COMPLEX); return true; } if (ptype == typeid(std::complex)) { This->SetNumberOfComponents(1); This->SetComponentType(ImageIOBase::CINT); This->SetPixelType(ImageIOBase::COMPLEX); return true; } if (ptype == typeid(std::complex)) { This->SetNumberOfComponents(1); This->SetComponentType(ImageIOBase::CFLOAT); This->SetPixelType(ImageIOBase::COMPLEX); return true; } if (ptype == typeid(std::complex)) { This->SetNumberOfComponents(1); This->SetComponentType(ImageIOBase::CDOUBLE); This->SetPixelType(ImageIOBase::COMPLEX); return true; } return false; } bool ImageIOBase::SetPixelTypeInfo(const std::type_info& ptype) { this->SetNumberOfComponents(1); this->SetPixelType(ImageIOBase::UNKNOWNPIXELTYPE); this->SetComponentType(ImageIOBase::UNKNOWNCOMPONENTTYPE); if (!itkSetPixelType(this,ptype,ImageIOBase::CHAR, char(0) ) && !itkSetPixelType(this,ptype,ImageIOBase::UCHAR, (unsigned char)0) && !itkSetPixelType(this,ptype,ImageIOBase::SHORT,(short)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::USHORT,(unsigned short)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::INT,(int)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::UINT,(unsigned int)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::LONG,(long)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::ULONG,(unsigned long)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::FLOAT,(float)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::DOUBLE,(double)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::CSHORT,(std::complex)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::CINT,(std::complex)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::CFLOAT,(std::complex)(0)) && !itkSetPixelType(this,ptype,ImageIOBase::CDOUBLE,(std::complex)(0)) ) { if ( ptype == typeid(itk::Offset<2>) ) { this->SetNumberOfComponents(2); this->SetPixelType(ImageIOBase::OFFSET); this->SetComponentType(ImageIOBase::LONG); } else if ( ptype == typeid(itk::Offset<3>) ) { this->SetNumberOfComponents(3); this->SetPixelType(ImageIOBase::OFFSET); this->SetComponentType(ImageIOBase::LONG); } else if ( ptype == typeid(itk::Offset<4>) ) { this->SetNumberOfComponents(4); this->SetPixelType(ImageIOBase::OFFSET); this->SetComponentType(ImageIOBase::LONG); } } if( this->GetPixelType() == ImageIOBase::UNKNOWNPIXELTYPE ) { itkExceptionMacro("Pixel type currently not supported. typeid.name = " << ptype.name() ); return false; } if( this->GetComponentType() == ImageIOBase::UNKNOWNCOMPONENTTYPE ) { itkExceptionMacro("Pixel Component type currently not supported. typeid.name = " << ptype.name() ); return false; } return true; } void ImageIOBase::ComputeStrides() { unsigned int i; m_Strides[0] = this->GetComponentSize(); m_Strides[1] = m_NumberOfComponents * m_Strides[0]; for (i = 2; i <= (m_NumberOfDimensions+1); i++) { m_Strides[i] = m_Dimensions[i-2] * m_Strides[i-1]; } } // Calculates the image size in PIXELS ImageIOBase::SizeType ImageIOBase ::GetImageSizeInPixels() const { unsigned int i; SizeType numPixels = 1; for (i = 0; i < m_NumberOfDimensions; i++) { numPixels *= m_Dimensions[i]; } return numPixels; } ImageIOBase::SizeType ImageIOBase ::GetImageSizeInComponents() const { return (this->GetImageSizeInPixels() * m_NumberOfComponents); } ImageIOBase::SizeType ImageIOBase ::GetImageSizeInBytes () const { return (this->GetImageSizeInComponents() * this->GetComponentSize()); } ImageIOBase::SizeType ImageIOBase ::GetComponentStride() const { return m_Strides[0]; } ImageIOBase::SizeType ImageIOBase ::GetPixelStride () const { return m_Strides[1]; } ImageIOBase::SizeType ImageIOBase ::GetRowStride () const { return m_Strides[2]; } ImageIOBase::SizeType ImageIOBase ::GetSliceStride () const { return m_Strides[3]; } void ImageIOBase::SetNumberOfDimensions(unsigned int dim) { if(dim != m_NumberOfDimensions) { m_Origin.resize( dim ); m_Spacing.resize( dim ); m_Direction.resize( dim ); m_Strides.resize( dim+2 ); m_NumberOfDimensions = dim; m_Dimensions.resize( dim ); m_Direction.resize( dim ); std::vector axis( dim ); for (unsigned int i=0; iSetDirection(i, axis); this->SetOrigin(i, 0.0); this->SetSpacing(i, 1.0); } this->Modified(); } } bool ImageIOBase ::ReadBufferAsBinary(std::istream& is, void *buffer, ImageIOBase::SizeType num) { const std::streamsize numberOfBytesToBeRead = itk::Math::CastWithRangeCheck< std::streamsize>( num ); is.read( static_cast( buffer ), numberOfBytesToBeRead ); const std::streamsize numberOfBytesRead = is.gcount(); #ifdef __APPLE_CC__ // fail() is broken in the Mac. It returns true when reaches eof(). if ( numberOfBytesRead != numberOfBytesToBeRead ) #else if ( ( numberOfBytesRead != numberOfBytesToBeRead ) || is.fail() ) #endif { return false; // read failed } return true; } unsigned int ImageIOBase::GetPixelSize() const { if (m_ComponentType == UNKNOWNCOMPONENTTYPE || m_PixelType == UNKNOWNPIXELTYPE) { itkExceptionMacro ("Unknown pixel or component type: (" << m_PixelType << ", " << m_ComponentType << ")"); return 0; } return this->GetComponentSize() * this->GetNumberOfComponents(); } unsigned int ImageIOBase::GetComponentSize() const { switch(m_ComponentType) { case UCHAR: return sizeof(unsigned char); case CHAR: return sizeof(char); case USHORT: return sizeof(unsigned short); case SHORT: return sizeof(short); case UINT: return sizeof(unsigned int); case INT: return sizeof(int); case ULONG: return sizeof(unsigned long); case LONG: return sizeof(long); case FLOAT: return sizeof(float); case DOUBLE: return sizeof(double); case CSHORT: return sizeof(std::complex); case CINT: return sizeof(std::complex); case CFLOAT: return sizeof(std::complex); case CDOUBLE: return sizeof(std::complex); case UNKNOWNCOMPONENTTYPE: default: itkExceptionMacro ("Unknown component type: " << m_ComponentType); } return 0; } std::string ImageIOBase::GetFileTypeAsString(FileType t) const { std::string s; switch(t) { case ASCII: return s = "ASCII"; case Binary: return s = "Binary"; case TypeNotApplicable: default: return s = "TypeNotApplicable"; } } std::string ImageIOBase::GetByteOrderAsString(ByteOrder t) const { std::string s; switch(t) { case BigEndian: return s = "BigEndian"; case LittleEndian: return s = "LittleEndian"; case OrderNotApplicable: default: return s = "OrderNotApplicable"; } } std::string ImageIOBase::GetComponentTypeAsString(IOComponentType t) const { std::string s; switch(t) { case UCHAR: return (s = "unsigned_char"); case CHAR: return (s = "char"); case USHORT: return (s = "unsigned_short"); case SHORT: return (s = "short"); case UINT: return (s = "unsigned_int"); case INT: return (s = "int"); case ULONG: return (s = "unsigned_long"); case LONG: return (s = "long"); case FLOAT: return (s = "float"); case DOUBLE: return (s = "double"); case CSHORT: return (s = "complex_short"); case CINT: return (s = "complex_int"); case CFLOAT: return (s = "complex_float"); case CDOUBLE: return (s = "complex_double"); case UNKNOWNCOMPONENTTYPE: default: return (s = "unknown"); } } std::string ImageIOBase::GetPixelTypeAsString(IOPixelType t) const { std::string s; switch(t) { case SCALAR: return (s = "scalar"); case VECTOR: return (s = "vector"); case COVARIANTVECTOR: return (s = "covariant_vector"); case POINT: return (s = "point"); case OFFSET: return (s = "offset"); case RGB: return (s = "rgb"); case RGBA: return (s = "rgba"); case SYMMETRICSECONDRANKTENSOR: return (s = "symmetric_second_rank_tensor"); case DIFFUSIONTENSOR3D: return (s = "diffusion_tensor_3D"); case COMPLEX: return (s = "complex"); case UNKNOWNPIXELTYPE: default: itkExceptionMacro ("Unknown pixel type: " << t); } } namespace { template void WriteBuffer(std::ostream& os, const TComponent *buffer, ImageIOBase::SizeType num) { const TComponent *ptr = buffer; typedef typename itk::NumericTraits::PrintType PrintType; for (ImageIOBase::SizeType i=0; i < num; i++) { if ( !(i%6) && i ) os << "\n"; os << PrintType(*ptr++) << " "; } } } void ImageIOBase::WriteBufferAsASCII(std::ostream& os, const void *buffer, IOComponentType ctype, ImageIOBase::SizeType numComp) { switch (ctype) { case UCHAR: { typedef const unsigned char * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case CHAR: { typedef const char * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case USHORT: { typedef const unsigned short * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case SHORT: { typedef const short * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case UINT: { typedef const unsigned int * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case INT: { typedef const int * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case ULONG: { typedef const unsigned long * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case LONG: { typedef const long * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case FLOAT: { typedef const float * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case DOUBLE: { typedef const double * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case CSHORT: { typedef const std::complex * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case CINT: { typedef const std::complex * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case CFLOAT: { typedef const std::complex * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; case CDOUBLE: { typedef const std::complex * Type; Type buf = reinterpret_cast(buffer); WriteBuffer(os, buf, numComp); } break; default: break; } } template void ReadBuffer(std::istream& is, TComponent *buffer, ImageIOBase::SizeType num) { typedef typename itk::NumericTraits::PrintType PrintType; PrintType temp; TComponent *ptr = buffer; for( ImageIOBase::SizeType i=0; i < num; i++, ptr++ ) { is >> temp; *ptr = static_cast( temp ); } } void ImageIOBase::ReadBufferAsASCII(std::istream& is, void *buffer, IOComponentType ctype, ImageIOBase::SizeType numComp) { switch (ctype) { case UCHAR: { unsigned char *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case CHAR: { char *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case USHORT: { unsigned short *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case SHORT: { short *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case UINT: { unsigned int *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case INT: { int *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case ULONG: { unsigned long *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case LONG: { long *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case FLOAT: { float *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case DOUBLE: { double *buf = reinterpret_cast(buffer); ReadBuffer(is, buf, numComp); } break; case CSHORT: { std::complex *buf = reinterpret_cast*>(buffer); ReadBuffer(is, buf, numComp); } break; case CINT: { std::complex *buf = reinterpret_cast*>(buffer); ReadBuffer(is, buf, numComp); } break; case CFLOAT: { std::complex *buf = reinterpret_cast*>(buffer); ReadBuffer(is, buf, numComp); } break; case CDOUBLE: { std::complex *buf = reinterpret_cast*>(buffer); ReadBuffer(is, buf, numComp); } break; default: break; } } unsigned int ImageIOBase::GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int numberOfRequestedSplits, const itk::ImageIORegion &pasteRegion) const { // Code from ImageRegionSplitter:GetNumberOfSplits int splitAxis; const itk::ImageIORegion::SizeType ®ionSize = pasteRegion.GetSize(); // split on the outermost dimension available splitAxis = pasteRegion.GetImageDimension() - 1; while (regionSize[splitAxis] == 1) { --splitAxis; if (splitAxis < 0) { // cannot split itkDebugMacro(" Cannot Split"); return 1; } } // determine the actual number of pieces that will be generated itk::ImageIORegion::SizeType::value_type range = regionSize[splitAxis]; int valuesPerPiece = itk::Math::Ceil(range/double(numberOfRequestedSplits)); int maxPieceUsed = itk::Math::Ceil(range/double(valuesPerPiece)) - 1; return maxPieceUsed+1; } unsigned int ImageIOBase::GetActualNumberOfSplitsForWriting(unsigned int numberOfRequestedSplits, const itk::ImageIORegion &pasteRegion, const itk::ImageIORegion &largestPossibleRegion) { if (this->CanStreamWrite()) { return GetActualNumberOfSplitsForWritingCanStreamWrite(numberOfRequestedSplits, pasteRegion); } if (pasteRegion != largestPossibleRegion) { itkExceptionMacro("Pasting is not supported! Can't write:" << this->GetFileName()); } if (numberOfRequestedSplits != 1) { itkDebugMacro("Requested more then 1 splits for streaming"); itkDebugMacro("This IO class does not support streaming!"); } return 1; } itk::ImageIORegion ImageIOBase::GetSplitRegionForWritingCanStreamWrite(unsigned int ithPiece, unsigned int numberOfActualSplits, const itk::ImageIORegion &pasteRegion) const { // Code from ImageRegionSplitter:GetSplit int splitAxis; itk::ImageIORegion splitRegion; itk::ImageIORegion::IndexType splitIndex; itk::ImageIORegion::SizeType splitSize, regionSize; // Initialize the splitRegion to the requested region splitRegion = pasteRegion; splitIndex = splitRegion.GetIndex(); splitSize = splitRegion.GetSize(); regionSize = pasteRegion.GetSize(); // split on the outermost dimension available splitAxis = pasteRegion.GetImageDimension() - 1; while (regionSize[splitAxis] == 1) { --splitAxis; if (splitAxis < 0) { // cannot split itkDebugMacro(" Cannot Split"); return splitRegion; } } // determine the actual number of pieces that will be generated itk::ImageIORegion::SizeType::value_type range = regionSize[splitAxis]; int valuesPerPiece = itk::Math::Ceil(range/(double)numberOfActualSplits); int maxPieceUsed = itk::Math::Ceil(range/(double)valuesPerPiece) - 1; // Split the region if ((int) ithPiece < maxPieceUsed) { splitIndex[splitAxis] += ithPiece*valuesPerPiece; splitSize[splitAxis] = valuesPerPiece; } if ((int) ithPiece == maxPieceUsed) { splitIndex[splitAxis] += ithPiece*valuesPerPiece; // last piece needs to process the "rest" dimension being split splitSize[splitAxis] = splitSize[splitAxis] - ithPiece*valuesPerPiece; } // set the split region ivars splitRegion.SetIndex( splitIndex ); splitRegion.SetSize( splitSize ); itkDebugMacro(" Split Piece: " << splitRegion ); return splitRegion; } itk::ImageIORegion ImageIOBase::GetSplitRegionForWriting(unsigned int ithPiece, unsigned int numberOfActualSplits, const itk::ImageIORegion &pasteRegion, const itk::ImageIORegion &largestPossibleRegion) { if (this->CanStreamWrite()) { return GetSplitRegionForWritingCanStreamWrite(ithPiece, numberOfActualSplits, pasteRegion); } return largestPossibleRegion; } /** Given a requested region, determine what could be the region that we can * read from the file. This is called the streamable region, which will be * smaller than the LargestPossibleRegion and greater or equal to the * RequestedRegion */ itk::ImageIORegion ImageIOBase ::GenerateStreamableReadRegionFromRequestedRegion( const itk::ImageIORegion & requested ) const { // // The default implementations determines that the streamable region is // equal to the minimal size of the image in the file. That is two // say the return ImageIORegion::GetImageSizeInPixels() is equal to // the number in the file. // // Since the image in the file may have a lower or higher dimension // than the image type over which the ImageFileReader is // being instantiated we must choose an image dimension which will // represent all the pixels. That is we can trim trailing 1s. unsigned int minIODimension = this->m_NumberOfDimensions; while (minIODimension) { if (this->m_Dimensions[minIODimension-1] == 1) { --minIODimension; } else { break; } } // dimension size we use to represent the region unsigned int maxDimension = minIODimension > requested.GetImageDimension() ? minIODimension : requested.GetImageDimension(); // First: allocate with the correct dimensions itk::ImageIORegion streamableRegion( maxDimension ); // Second: copy only the number of dimension that the file has. for( unsigned int i=0; i < minIODimension; i++ ) { streamableRegion.SetSize( i, this->m_Dimensions[i] ); streamableRegion.SetIndex( i, 0 ); } // Third: set the rest to the default : start = 0, size = 1 for( unsigned int j=minIODimension; j ImageIOBase ::GetDefaultDirection( unsigned int k ) const { std::vector axis; axis.resize( this->GetNumberOfDimensions() ); // Fill up with the equivalent of a line from an Identity matrix for( unsigned int r=0; rGetFileTypeAsString(m_FileType) << std::endl; os << indent << "ByteOrder: " << this->GetByteOrderAsString(m_ByteOrder) << std::endl; os << indent << "IORegion: " << std::endl; m_IORegion.Print(os, indent.GetNextIndent()); os << indent << "Number of Components/Pixel: " << m_NumberOfComponents << "\n"; os << indent << "Pixel Type: " << this->GetPixelTypeAsString(m_PixelType) << std::endl; os << indent << "Component Type: " << this->GetComponentTypeAsString(m_ComponentType) << std::endl; os << indent << "Dimensions: ( "; for (unsigned int i=0; i < m_NumberOfDimensions; i++) { os << m_Dimensions[i] << " "; } os << ")" << std::endl; os << indent << "Origin: ( "; for (unsigned int i=0; i < m_NumberOfDimensions; i++) { os << m_Origin[i] << " "; } os << ")" << std::endl; if (m_UseCompression) { os << indent << "UseCompression: On" << std::endl; } else { os << indent << "UseCompression: Off" << std::endl; } if (m_UseStreamedReading) { os << indent << "UseStreamedReading: On" << std::endl; } else { os << indent << "UseStreamedReading: Off" << std::endl; } if (m_UseStreamedWriting) { os << indent << "UseStreamedWriting: On" << std::endl; } else { os << indent << "UseStreamedWriting: Off" << std::endl; } } } //namespace itk OTB-release-5.8/Modules/Core/ImageBase/test/000077500000000000000000000000001301006202600205125ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ImageBase/test/0000307-ExtractROICompareRegionsImplementations.cxx000066400000000000000000000315461301006202600317710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkExtractImageFilter.h" #include "itkVectorIndexSelectionCastImageFilter.h" #include "otbExtractROI.h" #include "otbMultiChannelExtractROI.h" #include "otbMultiToMonoChannelExtractROI.h" typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef ImageType::RegionType RegionType; typedef ImageType::IndexType IndexType; typedef IndexType::IndexValueType IndexValueType; typedef ImageType::SizeType SizeType; typedef SizeType::SizeValueType SizeValueType; // ITK filters typedef itk::ExtractImageFilter ExtractImageFilterType; typedef itk::VectorIndexSelectionCastImageFilter VectorIndexSelectionCastImageFilterType; // OTB filters typedef otb::ExtractROI ExtractROIType; typedef otb::MultiChannelExtractROI MultiChannelExtractROIType; typedef otb::MultiToMonoChannelExtractROI MultiToMonoChannelExtractROIType; ImageType::Pointer makeImage(IndexValueType startX, IndexValueType startY, SizeValueType sizeX, SizeValueType sizeY) { ImageType::Pointer im = ImageType::New(); RegionType region; region.SetIndex(0, startX); region.SetIndex(1, startY); region.SetSize(0, sizeX); region.SetSize(1, sizeY); im->SetRegions(region); im->Allocate(); return im; } VectorImageType::Pointer makeVectorImage(IndexValueType startX, IndexValueType startY, SizeValueType sizeX, SizeValueType sizeY, int nbChannel = 3) { VectorImageType::Pointer im = VectorImageType::New(); RegionType region; region.SetIndex(0, startX); region.SetIndex(1, startY); region.SetSize(0, sizeX); region.SetSize(1, sizeY); im->SetRegions(region); im->SetNumberOfComponentsPerPixel(nbChannel); im->Allocate(); return im; } int otbITKExtractImageFilterROITestRegion(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { ImageType::Pointer in; RegionType extractionRegion; ExtractImageFilterType::Pointer extract; in = makeImage(0, 0, 100, 100); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = ExtractImageFilterType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } in = makeImage(20, 20, 100, 100); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = ExtractImageFilterType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbITKVectorIndexSelectionCastTestRegion(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { VectorImageType::Pointer in; RegionType extractionRegion; VectorIndexSelectionCastImageFilterType::Pointer extract; in = makeVectorImage(0, 0, 100, 100, 3); extract = VectorIndexSelectionCastImageFilterType::New(); extract->SetInput(in); extract->SetIndex(1); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != in->GetLargestPossibleRegion()) { return EXIT_FAILURE; } in = makeVectorImage(50, 50, 100, 100, 3); extract = VectorIndexSelectionCastImageFilterType::New(); extract->SetInput(in); extract->SetIndex(1); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != in->GetLargestPossibleRegion()) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMultiToMonoChannelExtractROITestRegion(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { VectorImageType::Pointer in; RegionType extractionRegion; MultiToMonoChannelExtractROIType::Pointer extract; in = makeVectorImage(0, 0, 100, 100, 3); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = MultiToMonoChannelExtractROIType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } in = makeVectorImage(20, 20, 100, 100, 3); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = MultiToMonoChannelExtractROIType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMultiChannelExtractROITestRegion(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { VectorImageType::Pointer in; RegionType extractionRegion; MultiChannelExtractROIType::Pointer extract; in = makeVectorImage(0, 0, 100, 100, 3); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = MultiChannelExtractROIType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } in = makeVectorImage(20, 20, 100, 100, 3); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = MultiChannelExtractROIType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbExtractROITestRegion(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { ImageType::Pointer in; RegionType extractionRegion; ExtractROIType::Pointer extract; in = makeImage(0, 0, 100, 100); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = ExtractROIType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } in = makeImage(20, 20, 100, 100); extractionRegion.SetIndex(0, 50); extractionRegion.SetIndex(1, 50); extractionRegion.SetSize(0, 10); extractionRegion.SetSize(1, 10); extract = ExtractROIType::New(); extract->SetInput(in); extract->SetExtractionRegion(extractionRegion); extract->UpdateOutputInformation(); std::cout << "Input LargestPossibleRegion : " << in->GetLargestPossibleRegion() << std::endl; std::cout << "ExtractionRegion : " << extract->GetExtractionRegion() << std::endl; std::cout << "Output LargestPossibleRegion : " << extract->GetOutput()->GetLargestPossibleRegion() << std::endl; if (extract->GetOutput()->GetLargestPossibleRegion() != extract->GetExtractionRegion()) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int main(int argc, char * argv[]) { int unitaryResult; int finalResult = EXIT_SUCCESS; std::cout << "*******************************" << std::endl; std::cout << "Starting test itk::ExtractImageFilter" << std::endl; unitaryResult = otbITKExtractImageFilterROITestRegion(argc, argv); if (unitaryResult == EXIT_FAILURE) { std::cout << "-> Testing itk::ExtractImageFilter FAILED" << std::endl; finalResult = EXIT_FAILURE; } else { std::cout << "-> Testing itk::ExtractImageFilter OK" << std::endl; } std::cout << "*******************************" << std::endl; std::cout << "Starting test itk::VectorIndexSelectionCast" << std::endl; unitaryResult = otbITKVectorIndexSelectionCastTestRegion(argc, argv); if (unitaryResult == EXIT_FAILURE) { std::cout << "-> Testing itk::VectorIndexSelectionCast FAILED" << std::endl; finalResult = EXIT_FAILURE; } else { std::cout << "-> Testing itk::VectorIndexSelectionCast OK" << std::endl; } std::cout << "*******************************" << std::endl; std::cout << "Starting test otb::MultiToMonoChannelExtractROI" << std::endl; unitaryResult = otbMultiToMonoChannelExtractROITestRegion(argc, argv); if (unitaryResult == EXIT_FAILURE) { std::cout << "-> Testing otb::MultiToMonoChannelExtractROI FAILED" << std::endl; finalResult = EXIT_FAILURE; } else { std::cout << "-> Testing otb::MultiToMonoChannelExtractROI OK" << std::endl; } std::cout << "*******************************" << std::endl; std::cout << "Starting test otb::MultiChannelExtractROI" << std::endl; unitaryResult = otbMultiChannelExtractROITestRegion(argc, argv); if (unitaryResult == EXIT_FAILURE) { std::cout << "-> Testing otb::MultiChannelExtractROI FAILED" << std::endl; finalResult = EXIT_FAILURE; } else { std::cout << "-> Testing otb::MultiChannelExtractROI OK" << std::endl; } std::cout << "*******************************" << std::endl; std::cout << "Starting test otb::ExtractROI" << std::endl; unitaryResult = otbExtractROITestRegion(argc, argv); if (unitaryResult == EXIT_FAILURE) { std::cout << "-> Testing otb::ExtractROI FAILED" << std::endl; finalResult = EXIT_FAILURE; } else { std::cout << "-> Testing otb::ExtractROI OK" << std::endl; } return finalResult; } OTB-release-5.8/Modules/Core/ImageBase/test/0000428-CastImageFilterStreaming.cxx000066400000000000000000000034741301006202600267360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkCastImageFilter.h" /** * This test reproduces a problem encountered with CastImageFilter and a streaming * writer. When the image to write is already loaded in memory and InPlaceOn() is * called, only the first stripe is repeated across the output image. * Issue number 0000428 */ int main(int argc, char* argv[]) { if (argc != 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::CastImageFilter CastFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->Update(); CastFilterType::Pointer caster = CastFilterType::New(); caster->SetInput( reader->GetOutput() ); caster->InPlaceOn(); WriterType::Pointer writer = WriterType::New(); writer->SetInput(caster->GetOutput()); writer->SetFileName(argv[2]); //writer->SetAutomaticTiledStreaming(1024); writer->SetNumberOfDivisionsStrippedStreaming(10); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/CMakeLists.txt000066400000000000000000001077611301006202600232660ustar00rootroot00000000000000otb_module_test() set(OTBImageBaseTests otbImageBaseTestDriver.cxx otbFlexibleDistanceWithMissingValue.cxx otbImageAndVectorImageOperationFilterNew.cxx otbImagePCAShapeModelEstimatorTest.cxx otbFunctionToImageFilter.cxx otbExtractROI2.cxx otbComplexToVectorImageCastFilter.cxx otbMultiChannelExtractROI.cxx otbVectorImageTest.cxx otbExtractROITestMetaData.cxx otbTestMultiExtractMultiUpdate.cxx otbExtractROI.cxx otbFunctionToImageFilterNew.cxx otbVectorImageToASImageAdaptorNew.cxx otbImageAndVectorImageOperationFilterTest.cxx otbImageOfVectorsToMonoChannelExtractROI.cxx otbImageOfVectorsToMonoChannelExtractROINew.cxx otbExtractROINew.cxx otbExtractROI_RGB.cxx otbComplexToIntensityFilterTest.cxx otbMultiToMonoChannelExtractROINew.cxx otbMultiToMonoChannelExtractROI.cxx otbImageTest.cxx otbFlexibleDistanceWithMissingValueNew.cxx otbImageFunctionAdaptor.cxx otbMultiChannelExtractROINew.cxx otbMetaImageFunction.cxx ) add_executable(otbImageBaseTestDriver ${OTBImageBaseTests}) target_link_libraries(otbImageBaseTestDriver ${OTBImageBase-Test_LIBRARIES}) otb_module_target_label(otbImageBaseTestDriver) # Tests Declaration otb_add_test(NAME bfTvFlexibleDistanceWithMissingValue COMMAND otbImageBaseTestDriver otbFlexibleDistanceWithMissingValue 0.000001 ) otb_add_test(NAME bfTuImageAndVectorImageOperationFilterNew COMMAND otbImageBaseTestDriver otbImageAndVectorImageOperationFilterNew) otb_add_test(NAME bfTvItkImagePCAShapeModelEstimatorTest COMMAND otbImageBaseTestDriver --compare-n-images ${EPSILON_7} 4 ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_eigen_vectors1.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_pc1.tif ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_eigen_vectors2.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_pc2.tif ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_eigen_vectors3.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_pc3.tif ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_mean.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_MEAN.tif otbImagePCAShapeModelEstimatorTest ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${INPUTDATA}/poupees_sub_c3.png ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_mean.tif ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_eigen_vectors1.tif ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_eigen_vectors2.tif ${TEMP}/bfITKimagePCAShapeModelEstimatorTest_eigen_vectors3.tif ) set_property(TEST bfTvItkImagePCAShapeModelEstimatorTest PROPERTY DEPENDS bfTvInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator) otb_add_test(NAME bfTvFunctionToImageFilterTest COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvFunctionToImageFilterTest.tif ${TEMP}/bfTvFunctionToImageFilterTest.tif otbFunctionToImageFilter ${INPUTDATA}/poupees_1canal.hd ${TEMP}/bfTvFunctionToImageFilterTest.tif 2 # radius ) otb_add_test(NAME coTvExtractROI2 COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coExtractROI_cthead1_26_97_209_100.png ${TEMP}/coExtractROI2_cthead1_26_97_209_100.png otbExtractROI2 ${INPUTDATA}/cthead1.png ${TEMP}/coExtractROI2_cthead1_26_97_209_100.png 26 97 209 100 ) otb_add_test(NAME bfTvComplexToVectorImageCastFilterTest COMMAND otbImageBaseTestDriver --compare-n-images ${NOTOL} 2 ${BASELINE}/bfTvComplexToVectorImageCastFilterTest.tif ${TEMP}/bfTvComplexToVectorImageCastFilterTest.tif ${BASELINE}/bfTvComplexToVectorImageCastFilterTest.tif ${TEMP}/bfTvVectorComplexToVectorImageCastFilterTest.tif otbComplexToVectorImageCastFilterTest ${INPUTDATA}/monobandComplexDouble ${TEMP}/bfTvComplexToVectorImageCastFilterTest.tif ${TEMP}/bfTvVectorComplexToVectorImageCastFilterTest.tif ) otb_add_test(NAME bfTuComplexToVectorImageCastFilterNew COMMAND otbImageBaseTestDriver otbComplexToVectorImageCastFilterNew ) otb_add_test(NAME coTvMultiChannelROI_RGB2RGB_PNG3 COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coMultiChannelExtractROI_RGB2RGB_PNG_300_10_250_50_channels_321.png ${TEMP}/coMultiChannelExtractROI_RGB2RGB_PNG_300_10_250_50_channels_321.png otbMultiChannelExtractROI ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coMultiChannelExtractROI_RGB2RGB_PNG_300_10_250_50_channels_321.png -startX 300 -startY 10 -sizeX 250 -sizeY 50 -channels 3 2 1 ) otb_add_test(NAME coTvMultiChannelROI_RGB2RGB_PNG2 COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coMultiChannelExtractROI_RGB2RGB_PNG_300_10_250_50_channels_123.png ${TEMP}/coMultiChannelExtractROI_RGB2RGB_PNG_300_10_250_50_channels_123.png otbMultiChannelExtractROI -uchar ${INPUTDATA}/couleurs_extrait.png -uchar ${TEMP}/coMultiChannelExtractROI_RGB2RGB_PNG_300_10_250_50_channels_123.png -startX 300 -startY 10 -sizeX 250 -sizeY 50 -channels 1 2 3 ) otb_add_test(NAME coTvMultiChannelROI_RGB2RGB_PNG COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coMultiChannelExtractROI_RGB2RGB_PNG.png otbMultiChannelExtractROI ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coMultiChannelExtractROI_RGB2RGB_PNG.png -channels 1 2 3 ) otb_add_test(NAME coTvMultiChannelROI_5c_BSQ COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coMultiChannelExtractROI_RGB_ENVI_poupees_303_2_134_330_channels_12321.hdr ${TEMP}/coMultiChannelExtractROI_RGB_ENVI_poupees_303_2_134_330_channels_12321.hdr otbMultiChannelExtractROI ${INPUTDATA}/poupees.hdr ${TEMP}/coMultiChannelExtractROI_RGB_ENVI_poupees_303_2_134_330_channels_12321.hdr -startX 303 -startY 2 -sizeX 134 -sizeY 330 -channels 1 2 3 2 1 ) otb_add_test(NAME coTvMultiChannelROI_RGB2NG_PNG1 COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_1.png ${TEMP}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_1.png otbMultiChannelExtractROI ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_1.png -startX 300 -startY 10 -sizeX 250 -sizeY 50 -channels 1 ) otb_add_test(NAME coTvMultiChannelROI_RGB2NG_PNG2 COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_2.png ${TEMP}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_2.png otbMultiChannelExtractROI ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_2.png -startX 300 -startY 10 -sizeX 250 -sizeY 50 -channels 2 ) otb_add_test(NAME coTvMultiChannelROI_RGB2NG_PNG3 COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_3.png ${TEMP}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_3.png otbMultiChannelExtractROI ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coMultiChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_3.png -startX 300 -startY 10 -sizeX 250 -sizeY 50 -channels 3 ) if(GDAL_HAS_HDF4) otb_add_test(NAME ioTvMultiDatasetReading2 COMMAND otbImageBaseTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiDatasetReading2.txt ${TEMP}/ioTvMultiDatasetReading2.txt --ignore-lines-with 1 Pointer: otbVectorImageTest ${INPUTDATA}/MOD09Q1G_EVI.A2006233.h07v03.005.2008338190308.hdf?&sdataidx=5 ${TEMP}/ioTvMultiDatasetReading2.txt ) otb_add_test(NAME ioTvMultiDatasetReading1 COMMAND otbImageBaseTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiDatasetReading1.txt ${TEMP}/ioTvMultiDatasetReading1.txt --ignore-lines-with 1 Pointer: otbVectorImageTest ${INPUTDATA}/MOD09Q1G_EVI.A2006233.h07v03.005.2008338190308.hdf?&sdataidx=0 ${TEMP}/ioTvMultiDatasetReading1.txt ) endif() otb_add_test(NAME coTvExtractROITestMetaData_TIFF COMMAND otbImageBaseTestDriver --compare-ascii ${NOTOL} ${TEMP}/coTvExtractROITestMetaData1.txt ${TEMP}/coTvExtractROITestMetaData2.txt --ignore-lines-with 4 Origin: Source: Image ImportImageContainer otbExtractROITestMetaData LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/coTvExtractROITestMetaData1.tif ${TEMP}/coTvExtractROITestMetaData2.tif ${TEMP}/coTvExtractROITestMetaData1.txt ${TEMP}/coTvExtractROITestMetaData2.txt ) otb_add_test(NAME coTvExtractROITestMetaData_HDR COMMAND otbImageBaseTestDriver --compare-ascii ${NOTOL} ${TEMP}/coTvExtractROITestMetaData1_hdr.txt ${TEMP}/coTvExtractROITestMetaData2_hdr.txt --ignore-lines-with 4 Origin: Source: Image ImportImageContainer otbExtractROITestMetaData LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/coTvExtractROITestMetaData1.hdr ${TEMP}/coTvExtractROITestMetaData2.hdr ${TEMP}/coTvExtractROITestMetaData1_hdr.txt ${TEMP}/coTvExtractROITestMetaData2_hdr.txt ) otb_add_test(NAME coTvMultiChannelExtractROI_Romania COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvMultiChannelExtractROI_Romania.tif ${TEMP}/coTvMultiChannelExtractROI_Romania.tif otbTestMultiExtractMultiUpdate ${INPUTDATA}/Romania_Extract.tif ${TEMP}/coTvMultiChannelExtractROI_Romania.tif 0 # startX 0 # startY 100 #sizeX 100 #sizeY 2 # first channel 3 # last channel ) otb_add_test(NAME coTvTestMultiExtractMultiUpdate COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvMultiExtractMultiUpdate.tif ${TEMP}/coTvMultiExtractMultiUpdate.tif otbTestMultiExtractMultiUpdate ${INPUTDATA}/poupees.tif ${TEMP}/coTvMultiExtractMultiUpdate.tif 70 # startX 60 # startY 50 #sizeX 50 #sizeY 1 # first channel 3 # last channel ) otb_add_test(NAME coTvExtractROI COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coExtractROI_cthead1_26_97_209_100.png ${TEMP}/coExtractROI_cthead1_26_97_209_100.png otbExtractROI ${INPUTDATA}/cthead1.png ${TEMP}/coExtractROI_cthead1_26_97_209_100.png 26 97 209 100 ) otb_add_test(NAME coTvExtractROIQB COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvExtractROIQB.png ${TEMP}/coTvExtractROIQB.png otbExtractROI ${INPUTDATA}/QB_Suburb.png ${TEMP}/coTvExtractROIQB.png 0 0 70 70 ) otb_add_test(NAME bfTuFunctionToImageFilterNew COMMAND otbImageBaseTestDriver otbFunctionToImageFilterNew ) otb_add_test(NAME coTuVectorImageToASImageAdaptorNew COMMAND otbImageBaseTestDriver otbVectorImageToASImageAdaptorNew ) otb_add_test(NAME bfTvImageAndVectorImageOperationFilterTest COMMAND otbImageBaseTestDriver --compare-n-images ${NOTOL} 4 ${BASELINE}/bfTvImageAndVectorImageOperationFilterTestAdd.tif ${TEMP}/bfTvImageAndVectorImageOperationFilterTestAdd.tif ${BASELINE}/bfTvImageAndVectorImageOperationFilterTestSub.tif ${TEMP}/bfTvImageAndVectorImageOperationFilterTestSub.tif ${BASELINE}/bfTvImageAndVectorImageOperationFilterTestMul.tif ${TEMP}/bfTvImageAndVectorImageOperationFilterTestMul.tif ${BASELINE}/bfTvImageAndVectorImageOperationFilterTestDiv.tif ${TEMP}/bfTvImageAndVectorImageOperationFilterTestDiv.tif otbImageAndVectorImageOperationFilterTest ${INPUTDATA}/checkerboard_128_128.png ${INPUTDATA}/poupees_sub.png ${TEMP}/bfTvImageAndVectorImageOperationFilterTestAdd.tif ${TEMP}/bfTvImageAndVectorImageOperationFilterTestSub.tif ${TEMP}/bfTvImageAndVectorImageOperationFilterTestMul.tif ${TEMP}/bfTvImageAndVectorImageOperationFilterTestDiv.tif ) otb_add_test(NAME coTvImageOfVectorsToMonoChannelExtractROI COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coImageOfVectorsToMonoChannelExtractROI.png ${TEMP}/coImageOfVectorsToMonoChannelExtractROI.png otbImageOfVectorsToMonoChannelExtractROI ${INPUTDATA}/couleurs_extrait.png 300 10 # Start X Y 250 50 # Size X Y 1 # Channel ${TEMP}/coImageOfVectorsToMonoChannelExtractROI.png ) otb_add_test(NAME coTuImageOfVectorsToMonoChannelExtractROINew COMMAND otbImageBaseTestDriver otbImageOfVectorsToMonoChannelExtractROINew ) otb_add_test(NAME coTuExtractROINew COMMAND otbImageBaseTestDriver otbExtractROINew) otb_add_test(NAME coTvExtractROI_RGB COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coExtractROI_RGB_300_10_200_50.png ${TEMP}/coExtractROI_RGB_300_10_200_50.png otbExtractROI_RGB ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coExtractROI_RGB_300_10_200_50.png 300 10 200 50 ) otb_add_test(NAME coTvExtractROI_QB COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvExtractROI_QB.png ${TEMP}/coTvExtractROI_QB.png otbExtractROI_RGB ${INPUTDATA}/QB_Suburb.png ${TEMP}/coTvExtractROI_QB.png 0 0 70 70 ) otb_add_test(NAME bfTvComplexToIntensityFilterTest COMMAND otbImageBaseTestDriver otbComplexToIntensityFilterTest) otb_add_test(NAME coTuMultiToMonoROINew COMMAND otbImageBaseTestDriver otbMultiToMonoChannelExtractROINew) otb_add_test(NAME coTvMultiToMonoROI_RGB2NG_PNG COMMAND otbImageBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/coMultiToMonoChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_1.png ${TEMP}/coMultiToMonoChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_1.png otbMultiToMonoChannelExtractROI ${INPUTDATA}/couleurs_extrait.png ${TEMP}/coMultiToMonoChannelExtractROI_RGB2NG_PNG_300_10_250_50_channel_1.png -startX 300 -startY 10 -sizeX 250 -sizeY 50 -channel 1 ) otb_add_test(NAME ioTvOtbImageTestSAR_ERS COMMAND otbImageBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/ioOtbImageTestSAR_ERS.txt ${TEMP}/ioOtbImageTestSAR_ERS.txt otbImageTest LARGEINPUT{SAR_ERS2_SLCI_SCENE1/} ${TEMP}/ioOtbImageTestSAR_ERS.txt) otb_add_test(NAME ioTvOtbImageTestRadarsat COMMAND otbImageBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/ioOtbImageTestRadarsat.txt ${TEMP}/ioOtbImageTestRadarsat.txt otbImageTest LARGEINPUT{RADARSAT1/GOMA/SCENE01/} ${TEMP}/ioOtbImageTestRadarsat.txt) otb_add_test(NAME bfTuFlexibleDistanceWithMissingValueNew COMMAND otbImageBaseTestDriver otbFlexibleDistanceWithMissingValueNew) otb_add_test(NAME feTvImageFunctionAdaptor COMMAND otbImageBaseTestDriver otbImageFunctionAdaptor ${INPUTDATA}/poupees.png ) otb_add_test(NAME feTuImageFunctionAdaptorNew COMMAND otbImageBaseTestDriver otbImageFunctionAdaptorNew ) otb_add_test(NAME coTuMultiChannelROINew COMMAND otbImageBaseTestDriver otbMultiChannelExtractROINew) otb_add_test(NAME feTvMetaImageFunction COMMAND otbImageBaseTestDriver --compare-ascii ${EPSILON_8} ${BASELINE_FILES}/feTvMetaImageFunction.txt ${TEMP}/feTvMetaImageFunction.txt otbMetaImageFunction ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/feTvMetaImageFunction.txt 451846.014047961 5412466.57452216 ) otb_add_test(NAME feTuMetaImageFunctionNew COMMAND otbImageBaseTestDriver otbMetaImageFunctionNew ) if(OTB_DATA_USE_LARGEINPUT) set( GenericTestPHR_TESTNB 0) foreach( current_file ${GenericTestPHR_DATA_INPUTS} ) list(GET GenericTestPHR_DATA_TYPES ${GenericTestPHR_TESTNB} current_type ) math(EXPR GenericTestPHR_TESTNB "${GenericTestPHR_TESTNB} + 1") string(REGEX MATCH "TIFF" PHR_TIFF_FILE ${current_type}) # Read info from the input file #otb_add_test(NAME ioTvVectorImageReadingInfo_${current_type} COMMAND otbImageBaseTestDriver #--ignore-order --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvMultiResolutionReading_${current_type}.txt #${TEMP}/ioTvMultiResolutionReading_${current_type}_OUT.txt #--ignore-lines-with 4 CacheSizeInBytes SubDatasetIndex Driver Corner #otbVectorImageTest #${current_file}?&resol=0 #${TEMP}/ioTvMultiResolutionReading_${current_type}_OUT.txt #) if(NOT PHR_TIFF_FILE) # Read info from the input file (res=5) #otb_add_test(NAME ioTvVectorImageReadingInfo_${current_type}_res5 COMMAND otbImageBaseTestDriver #--ignore-order --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvMultiResolutionReading_${current_type}_res5.txt #${TEMP}/ioTvMultiResolutionReading_${current_type}_res5_OUT.txt #--ignore-lines-with 4 CacheSizeInBytes Driver Corner SubDatasetIndex #otbVectorImageTest #${current_file}?&resol=5 #${TEMP}/ioTvMultiResolutionReading_${current_type}_res5_OUT.txt #) # Decode an area inside one tile otb_add_test(NAME ioTvReaderWriterJP22TIF_${current_type}_1 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioTvJP22TIF_Extract_${current_type}_1.tif ${TEMP}/ioTvJP22TIF_Extract_${current_type}_1_OUT.tif otbMultiChannelExtractROI -ushort ${current_file} -ushort ${TEMP}/ioTvJP22TIF_Extract_${current_type}_1_OUT.tif -startX 256 -startY 512 -sizeX 256 -sizeY 128 -time ) # Decode an area which need 4 tiles otb_add_test(NAME ioTvReaderWriterJP22TIF_${current_type}_2 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioTvJP22TIF_Extract_${current_type}_2.tif ${TEMP}/ioTvJP22TIF_Extract_${current_type}_2_OUT.tif otbMultiChannelExtractROI -ushort ${current_file} -ushort ${TEMP}/ioTvJP22TIF_Extract_${current_type}_2_OUT.tif -startX 2000 -startY 2000 -sizeX 256 -sizeY 128 -time ) # Decode the whole image with the lowest resolution (res=5) # (take only one channel to put the file in baseline repository) #write only a subpart of the output image using the extended parameter "box" otb_add_test(NAME ioTvReaderWriterJP22TIF_${current_type}_res5 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioTvJP22TIF_Extract_${current_type}_res5.tif ${TEMP}/ioTvJP22TIF_Extract_${current_type}_res5_OUT.tif otbMultiChannelExtractROI -ushort ${current_file}?resol=5 -ushort ${TEMP}/ioTvJP22TIF_Extract_${current_type}_res5_OUT.tif?&box=0:0:128:128 -channels 1 -time ) endif() endforeach() endif() # --- SPOT4 (CAI) --- otb_add_test(NAME ioTvMultiChannelROI_SPOT42PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT42PNG_spot4_700_60_77_489_channels_1_2_3.png ${TEMP}/ioExtractROI_SPOT42PNG_spot4_700_60_77_489_channels_1_2_3.png otbMultiChannelExtractROI LARGEINPUT{SPOT4/RIO_DE_JANEIRO/} ${TEMP}/ioExtractROI_SPOT42PNG_spot4_700_60_77_489_channels_1_2_3.png -startX 700 -startY 60 -sizeX 77 -sizeY 489 -channels 1 2 3 ) otb_add_test(NAME ioTvMultiChannelROI_SPOT42PNG_2 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT42PNG_spot4_700_60_77_489_channels_3_2_1.png ${TEMP}/ioExtractROI_SPOT42PNG_spot4_700_60_77_489_channels_3_2_1.png otbMultiChannelExtractROI LARGEINPUT{SPOT4/RIO_DE_JANEIRO/} ${TEMP}/ioExtractROI_SPOT42PNG_spot4_700_60_77_489_channels_3_2_1.png -startX 700 -startY 60 -sizeX 77 -sizeY 489 -channels 3 2 1 ) # --- ENVI --- otb_add_test(NAME ioTvMultiChannelROI_ENVI2PNG_2 COMMAND otbImageBaseTestDriver # THOMAS (provisoire) : Images OK mais erreur au DIFF ITK !!! # --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_ENVI2PNG_poupees_100_100_77_300_channels_1_2_3.png # ${TEMP}/ioExtractROI_ENVI2PNG_poupees_100_100_77_300_channels_1_2_3.png otbMultiChannelExtractROI -uchar ${INPUTDATA}/poupees.hdr -uchar ${TEMP}/ioExtractROI_ENVI2PNG_poupees_100_100_77_300_channels_1_2_3.png -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1 2 3 ) # --- SPOT5 BIL (CAI) --- # add_test(ioTvMultiChannelROI_SPOT5BIL2PNG_2COMMAND otbImageBaseTestDriver # --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT5BIL2PNG_poupees_100_100_77_300_channels_1_2_3.png # ${TEMP}/ioExtractROI_SPOT5BIL2PNG_poupees_100_100_77_300_channels_1_2_3.png # otbMultiChannelExtractROI # ${INPUTDATA}/poupeesBIL # ${TEMP}/ioExtractROI_SPOT5BIL2PNG_poupees_100_100_77_300_channels_1_2_3.png # -startX 100 -startY 100 -sizeX 77 -sizeY 300 # -channels 1 2 3 ) # --- SPOT5 (CAI) --- # --- Test sur l'image SPOT 5 4 canaux --- otb_add_test(NAME ioTvMultiChannelROI_SPOT52PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channels_1_2_3.png ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channels_1_2_3.png otbMultiChannelExtractROI LARGEINPUT{SPOT5/TEHERAN/} ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channels_1_2_3.png -startX 700 -startY 700 -sizeX 1000 -sizeY 1000 -channels 1 2 3 ) otb_add_test(NAME ioTvMultiChannelROI_SPOT52PNG_2 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_1.png ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_1.png otbMultiChannelExtractROI LARGEINPUT{SPOT5/TEHERAN/} ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_1.png -startX 700 -startY 700 -sizeX 1000 -sizeY 1000 -channels 1 ) otb_add_test(NAME ioTvMultiChannelROI_SPOT52PNG_3 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_2.png ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_2.png otbMultiChannelExtractROI LARGEINPUT{SPOT5/TEHERAN/} ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_2.png -startX 700 -startY 700 -sizeX 1000 -sizeY 1000 -channels 2 ) otb_add_test(NAME ioTvMultiChannelROI_SPOT52PNG_4 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_3.png ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_3.png otbMultiChannelExtractROI LARGEINPUT{SPOT5/TEHERAN/} ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_3.png -startX 700 -startY 700 -sizeX 1000 -sizeY 1000 -channels 3 ) otb_add_test(NAME ioTvMultiChannelROI_SPOT52PNG_5 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_4.png ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_4.png otbMultiChannelExtractROI LARGEINPUT{SPOT5/TEHERAN/} ${TEMP}/ioExtractROI_SPOT52PNG_spot5_700_700_1000_1000_channel_4.png -startX 700 -startY 700 -sizeX 1000 -sizeY 1000 -channels 4 ) # --- Ikonos PAN --- otb_add_test(NAME ioTvMultiChannelROI_IkonosPAN2PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_IkonosPAN2PNG_100_100_77_300.png ${TEMP}/ioExtractROI_IkonosPAN2PNG_100_100_77_300.png otbMultiChannelExtractROI LARGEINPUT{IKONOS/PARIS/po_79039_pan_0000000.tif} ${TEMP}/ioExtractROI_IkonosPAN2PNG_100_100_77_300.png -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1) # --- Ikonos XS --- otb_add_test(NAME ioTvMultiChannelROI_IkonosRED2PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_IkonosRED2PNG_100_100_77_300.png ${TEMP}/ioExtractROI_IkonosRED2PNG_100_100_77_300.png otbMultiChannelExtractROI LARGEINPUT{IKONOS/PARIS/po_79039_red_0000000.tif} ${TEMP}/ioExtractROI_IkonosRED2PNG_100_100_77_300.png -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1) otb_add_test(NAME ioTvMultiChannelROI_IkonosGRN2PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_IkonosGRN2PNG_100_100_77_300.png ${TEMP}/ioExtractROI_IkonosGRN2PNG_100_100_77_300.png otbMultiChannelExtractROI LARGEINPUT{IKONOS/PARIS/po_79039_grn_0000000.tif} ${TEMP}/ioExtractROI_IkonosGRN2PNG_100_100_77_300.png -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1) otb_add_test(NAME ioTvMultiChannelROI_IkonosBLU2PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_IkonosBLU2PNG_100_100_77_300.png ${TEMP}/ioExtractROI_IkonosBLU2PNG_100_100_77_300.png otbMultiChannelExtractROI LARGEINPUT{IKONOS/PARIS/po_79039_blu_0000000.tif} ${TEMP}/ioExtractROI_IkonosBLU2PNG_100_100_77_300.png -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1) otb_add_test(NAME ioTvMultiChannelROI_IkonosNIR2PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_IkonosNIR2PNG_100_100_77_300.png ${TEMP}/ioExtractROI_IkonosNIR2PNG_100_100_77_300.png otbMultiChannelExtractROI LARGEINPUT{IKONOS/PARIS/po_79039_nir_0000000.tif} ${TEMP}/ioExtractROI_IkonosNIR2PNG_100_100_77_300.png -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1) # --- LUM ---- otb_add_test(NAME ioTvMultiChannelROI_IkonosNIR2LUM COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_IkonosNIR2PNG_100_100_77_300_nogeoinfo.png ${TEMP}/ioExtractROI_IkonosNIR2LUM_100_100_77_300.lum otbMultiChannelExtractROI LARGEINPUT{IKONOS/PARIS/po_79039_nir_0000000.tif} ${TEMP}/ioExtractROI_IkonosNIR2LUM_100_100_77_300.lum -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1) # --- BSQ ---- otb_add_test(NAME ioTvMultiChannelROI_IkonosNIR2BSQ COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_IkonosNIR2PNG_100_100_77_300_nogeoinfo.png ${TEMP}/ioExtractROI_IkonosNIR2BSQ_100_100_77_300.hd otbMultiChannelExtractROI LARGEINPUT{IKONOS/PARIS/po_79039_nir_0000000.tif} ${TEMP}/ioExtractROI_IkonosNIR2BSQ_100_100_77_300.hd -startX 100 -startY 100 -sizeX 77 -sizeY 300 -channels 1) # --- Quickbird PAN --- otb_add_test(NAME ioTvMultiChannelROI_QuickbirdPAN2TIFF COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_QuickbirdPAN2TIFF_1000_1000_100_150.tif ${TEMP}/ioExtractROI_QuickbirdPAN2TIFF_1000_1000_100_150.tif otbMultiChannelExtractROI -ushort LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} -ushort ${TEMP}/ioExtractROI_QuickbirdPAN2TIFF_1000_1000_100_150.tif -startX 1000 -startY 1000 -sizeX 100 -sizeY 150 ) # --- Quickbird XS --- otb_add_test(NAME ioTvMultiChannelROI_QuickbirdXS2TIFF COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_QuickbirdXS2TIFF_1000_1000_100_150.tif ${TEMP}/ioExtractROI_QuickbirdXS2TIFF_1000_1000_100_150.tif otbMultiChannelExtractROI -ushort LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} -ushort ${TEMP}/ioExtractROI_QuickbirdXS2TIFF_1000_1000_100_150.tif -startX 1000 -startY 1000 -sizeX 100 -sizeY 150 ) if(GDAL_HAS_HDF4) # Tests which read data in HDF files. otb_add_test(NAME ioTvMultiChannelROI_HDF4_2_TIF COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_HDF2TIF_MOD09Q1G_20_25_100_150_channel_1.tif ${TEMP}/ioExtractROI_HDF2TIF_MOD09Q1G_20_25_100_150_channel_1_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/MOD09Q1G_EVI.A2006233.h07v03.005.2008338190308.hdf?&sdataidx=5 ${TEMP}/ioExtractROI_HDF2TIF_MOD09Q1G_20_25_100_150_channel_1_OUT.tif -startX 1400 -startY 3700 -sizeX 100 -sizeY 150 -channels 1 ) endif() if(GDAL_HAS_HDF5) otb_add_test(NAME ioTvMultiChannelROI_HDF5_2_TIF COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_HDF2TIF_GSSTF_NCEP_100_20_200_100_channel_1.tif ${TEMP}/ioExtractROI_HDF2TIF_GSSTF_NCEP_100_20_200_100_channel_1_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/GSSTF_NCEP.2b.2008.12.31.he5?&sdataidx=3 ${TEMP}/ioExtractROI_HDF2TIF_GSSTF_NCEP_100_20_200_100_channel_1_OUT.tif -startX 100 -startY 20 -sizeX 200 -sizeY 100 -channels 1 ) endif() # Read an area inside one tile at resolution 0 (jpeg2000 conformance file with # specific tile size at different resolution). otb_add_test(NAME ioTvMultiChannelROI_p1_06_JPEG2000_2_TIF_res0 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_p1_06.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_p1_06_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/jpeg2000_conf_p1_06.j2k?&resol=0 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_p1_06_OUT.tif ) # Only do the following test if we are using the OTB Openjpeg driver, # because gdal does not report jpeg2000 overview with size < 128 # pixel, and will therefore interpolate. if(OTB_USE_OPENJPEG) # Read an area inside one tile at resolution 4 (jpeg2000 conformance file with # specific tile size at different resolution). otb_add_test(NAME ioTvMultiChannelROI_p1_06_JPEG2000_2_TIF_res4 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_p1_06_res4.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_p1_06_res4_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/jpeg2000_conf_p1_06.j2k?&resol=4 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_p1_06_res4_OUT.tif ) endif() # Read an area inside one tile at resolution 0 (quite similar coding parameter with pleiade # except it a lossless image with no quatization style). otb_add_test(NAME ioTvMultiChannelROI_lena_JPEG2000_2_TIF_res0 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_lena_150_75_100_50.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_lena_150_75_100_50_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/lena512color.jp2?&resol=0 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_lena_150_75_100_50_OUT.tif -startX 150 -startY 75 -sizeX 100 -sizeY 50 ) # Read an area inside one tile at resolution 5 (quite similar coding parameter with pleiade # except it a lossless image with no quatization style). otb_add_test(NAME ioTvMultiChannelROI_lena_JPEG2000_2_TIF_res1 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_lena_res1.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_lena_res1_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/lena512color.jp2?&resol=1 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_lena_res1_OUT.tif ) # Read an area inside one tile at resolution 0 otb_add_test(NAME ioTvMultiChannelROI_JPEG2000_2_TIF_res0_1 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_bretagne_700_1000_50_40.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_700_1000_50_40_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/bretagne.j2k?&resol=0 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_700_1000_50_40_OUT.tif -startX 700 -startY 1000 -sizeX 50 -sizeY 40 ) # Read an area which need to decode 4 tiles at resolution 0 otb_add_test(NAME ioTvMultiChannelROI_JPEG2000_2_TIF_res0_2 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_bretagne_1260_950_40_20.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_1260_950_40_20_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/bretagne.j2k?&resol=0 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_1260_950_40_20_OUT.tif -startX 1260 -startY 950 -sizeX 40 -sizeY 20 ) # Read all the image with a resolution 3 otb_add_test(NAME ioTvMultiChannelROI_JPEG2000_2_TIF_res3 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/bretagne.j2k?&resol=3 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_OUT.tif ) # Read area inside one tile at resolution 3 otb_add_test(NAME ioTvMultiChannelROI_JPEG2000_2_TIF_res3_1 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_90_70_20_30.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_90_70_20_30_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/bretagne.j2k?&resol=3 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_90_70_20_30_OUT.tif -startX 90 -startY 70 -sizeX 20 -sizeY 30 ) # Read an area which need to decode 4 tiles at resolution 3 otb_add_test(NAME ioTvMultiChannelROI_JPEG2000_2_TIF_res3_2 COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_40_30_80_60.tif ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_40_30_80_60_OUT.tif otbMultiChannelExtractROI ${INPUTDATA}/bretagne.j2k?&resol=3 ${TEMP}/ioExtractROI_JPEG2K_2_TIF_bretagne_res3_40_30_80_60_OUT.tif -startX 40 -startY 30 -sizeX 80 -sizeY 60 ) # --- RADARSAT (GDAL) --- otb_add_test(NAME ioTvMultiMonoChannelROI_RADARSAT2ENVI COMMAND otbImageBaseTestDriver otbMultiToMonoChannelExtractROI -ushort LARGEINPUT{RADARSAT1/GOMA/SCENE01/} -ushort ${TEMP}/ioMultiMonoChannelROI_RADARSAT2ENVI_2559_3591_337_280.hdr -startX 2559 -startY 3591 -sizeX 337 -sizeY 280 ) # FIXME this test depends on an other test which requires largeinput. Need to circle the test with it(otb_data_use_large_input). It should not happen if(OTB_DATA_USE_LARGEINPUT) # --- RADARSAT (GDAL) dir name --- otb_add_test(NAME ioTvMultiMonoChannelROI_RADARSAT_ENVI2ENVI COMMAND otbImageBaseTestDriver # THOMAS (provisoire) : Images OK mais erreur au DIFF ITK !!! # --compare-image ${EPSILON_9} ${BASELINE}/ioMultiMonoChannelROI_RADARSAT2ENVI_2559_3591_337_280.hdr # ${TEMP}/ioMultiMonoChannelROI_RADARSAT_ENVI2ENVI_2559_3591_337_280_2.hdr otbMultiToMonoChannelExtractROI -ushort ${TEMP}/ioMultiMonoChannelROI_RADARSAT2ENVI_2559_3591_337_280.hdr -ushort ${TEMP}/ioMultiMonoChannelROI_RADARSAT_ENVI2ENVI_2559_3591_337_280_2.hdr -startX 0 -startY 0 -sizeX ParseHdfSubsetName337 -sizeY 280 ) set_tests_properties(ioTvMultiMonoChannelROI_RADARSAT_ENVI2ENVI PROPERTIES DEPENDS ioTvMultiMonoChannelROI_RADARSAT2ENVI) endif() # --- ENVI (GDAL) --- otb_add_test(NAME ioTvMultiMonoChannelROI_ENVI2PNG COMMAND otbImageBaseTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioMultiMonoChannelROI_ENVI2PNG_poupees_1canal_302_2_134_330.png ${TEMP}/ioMultiMonoChannelROI_ENVI2PNG_poupees_1canal_302_2_134_330.png otbMultiToMonoChannelExtractROI ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioMultiMonoChannelROI_ENVI2PNG_poupees_1canal_302_2_134_330.png -startX 302 -startY 2 -sizeX 134 -sizeY 330 -channel 1) # Tests to check if we can open JPEG2000 files specifying the resolution factor. # no access to data only PrintSelf() method. otb_add_test(NAME ioTvMultiResolutionReading0 COMMAND otbImageBaseTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiResolutionReading0.txt ${TEMP}/ioTvMultiResolutionReading0.txt --ignore-lines-with 7 VectorImage Source PipelineMTime ImportImageContainer Pointer CacheSizeInBytes SubDatasetIndex otbVectorImageTest ${INPUTDATA}/bretagne.j2k?&resol=0 ${TEMP}/ioTvMultiResolutionReading0.txt ) otb_add_test(NAME ioTvMultiResolutionReading3 COMMAND otbImageBaseTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiResolutionReading3.txt ${TEMP}/ioTvMultiResolutionReading3.txt --ignore-lines-with 7 VectorImage Source PipelineMTime ImportImageContainer Pointer CacheSizeInBytes SubDatasetIndex otbVectorImageTest ${INPUTDATA}/bretagne.j2k?&resol=3 ${TEMP}/ioTvMultiResolutionReading3.txt ) otb_add_test(NAME ioTvOtbVectorImageTestSpot5 COMMAND otbImageBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/ioOtbVectorImageTestSpot5.txt ${TEMP}/ioOtbVectorImageTestSpot5.txt otbVectorImageLegacyTest LARGEINPUT{/SPOT5/TEHERAN/} ${TEMP}/ioOtbVectorImageTestSpot5.txt) otb_add_test(NAME ioTvOtbVectorImageTestFORMOSAT2 COMMAND otbImageBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/ioOtbVectorImageTestFORMOSAT2.txt ${TEMP}/ioOtbVectorImageTestFORMOSAT2.txt otbVectorImageLegacyTest LARGEINPUT{/FORMOSAT/Sudouest_20071013_MS_fmsat/} ${TEMP}/ioOtbVectorImageTestFORMOSAT2.txt) if(GDAL_HAS_HDF5) otb_add_test(NAME ioTvOtbVectorImageTestCOSMOSKYMED COMMAND otbImageBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/ioOtbVectorImageTestCOSMOSKYMED.txt ${TEMP}/ioOtbVectorImageTestCOSMOSKYMED.txt otbVectorImageLegacyTest LARGEINPUT{/COSMOSKYMED/Toulouse_spotlight/CSKS3_GTC_B_S2_08_HH_RD_SF_20110418180325_20110418180332.h5} ${TEMP}/ioOtbVectorImageTestCOSMOSKYMED.txt) endif() otb_add_test(NAME ioTvOtbVectorImageTestRadarsat COMMAND otbImageBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/ioOtbImageTestRadarsat.txt ${TEMP}/ioOtbVectorImageTestRadarsat.txt otbVectorImageLegacyTest LARGEINPUT{/RADARSAT1/GOMA/SCENE01/} ${TEMP}/ioOtbVectorImageTestRadarsat.txt) OTB-release-5.8/Modules/Core/ImageBase/test/otbComplexToIntensityFilterTest.cxx000066400000000000000000000101521301006202600275710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbComplexToIntensityImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkSubtractImageFilter.h" int otbComplexToIntensityFilterTest(int, char* [] ) { // Define the dimension of the images const unsigned int ImageDimension = 2; // Declare the types of the images typedef std::complex InputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Declare Iterator types apropriated for each image typedef itk::ImageRegionIteratorWithIndex< InputImageType> InputIteratorType; typedef itk::ImageRegionIteratorWithIndex< OutputImageType> OutputIteratorType; // Declare the type of the index to access images typedef itk::Index IndexType; // Declare the type of the size typedef itk::Size SizeType; // Declare the type of the Region typedef itk::ImageRegion RegionType; // Create two images InputImageType::Pointer inputImage = InputImageType::New(); // Define their size, and start index SizeType size; size[0] = 2; size[1] = 2; IndexType start; start[0] = 0; start[1] = 0; RegionType region; region.SetIndex( start ); region.SetSize( size ); // Initialize Image A inputImage->SetLargestPossibleRegion( region ); inputImage->SetBufferedRegion( region ); inputImage->SetRequestedRegion( region ); inputImage->Allocate(); // Create one iterator for the Input Image (this is a light object) InputIteratorType it( inputImage, inputImage->GetBufferedRegion() ); // Initialize the content of Image A InputPixelType value( 13, 25); std::cout << "Content of the Input " << std::endl; it.GoToBegin(); while( !it.IsAtEnd() ) { it.Set( value ); std::cout << it.Get() << std::endl; ++it; } // Declare the type for the ComplexToIntensity filter typedef otb::ComplexToIntensityImageFilter< InputImageType, OutputImageType > FilterType; // Create an ADD Filter FilterType::Pointer filter = FilterType::New(); // Connect the input images filter->SetInput( inputImage ); // Get the Smart Pointer to the Filter Output OutputImageType::Pointer outputImage = filter->GetOutput(); // Execute the filter filter->Update(); // Create an iterator for going through the image output OutputIteratorType ot(outputImage, outputImage->GetRequestedRegion()); // Check the content of the result image std::cout << "Verification of the output " << std::endl; const OutputImageType::PixelType epsilon = 1e-6; ot.GoToBegin(); it.GoToBegin(); while( !ot.IsAtEnd() ) { const InputImageType::PixelType input = it.Get(); const OutputImageType::PixelType output = ot.Get(); double intensityd = input.real()*input.real() + input.imag()*input.imag(); const OutputImageType::PixelType intensity = static_cast( intensityd ); std::cout << output << " = "; std::cout << intensity << std::endl; if( vcl_fabs( intensity - output ) > epsilon ) { std::cerr << "Error in itkComplexToIntensityImageFilterTest " << std::endl; std::cerr << " intensity( " << input << ") = " << intensity << std::endl; std::cerr << " differs from " << output; std::cerr << " by more than " << epsilon << std::endl; return EXIT_FAILURE; } ++ot; ++it; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbComplexToVectorImageCastFilter.cxx000066400000000000000000000051371301006202600277720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbComplexToVectorImageCastFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbComplexToVectorImageCastFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef std::complex ComplexType; typedef otb::VectorImage CplxImageType; typedef otb::VectorImage VectorImageType; typedef otb::ComplexToVectorImageCastFilter FilterType; // Instantiating object FilterType::Pointer caster = FilterType::New(); return EXIT_SUCCESS; } int otbComplexToVectorImageCastFilterTest(int itkNotUsed(argc), char * argv[]) { typedef std::complex ComplexType; typedef otb::Image CplxImageType; typedef otb::VectorImage VCplxImageType; typedef otb::VectorImage VectorImageType; typedef otb::ComplexToVectorImageCastFilter VFilterType; typedef otb::ComplexToVectorImageCastFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader VReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating objects ReaderType::Pointer reader = ReaderType::New(); VReaderType::Pointer vreader = VReaderType::New(); WriterType::Pointer writer = WriterType::New(); WriterType::Pointer vwriter = WriterType::New(); FilterType::Pointer caster = FilterType::New(); VFilterType::Pointer vcaster = VFilterType::New(); reader->SetFileName(argv[1]); vreader->SetFileName(argv[1]); caster->SetInput(reader->GetOutput()); vcaster->SetInput(vreader->GetOutput()); writer->SetFileName(argv[2]); writer->SetInput( caster->GetOutput()); vwriter->SetFileName(argv[3]); vwriter->SetInput( vcaster->GetOutput()); writer->Update(); vwriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbExtractROI.cxx000066400000000000000000000035201301006202600237270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbExtractROI(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int startX((unsigned int) ::atoi(argv[3])); unsigned int startY((unsigned int) ::atoi(argv[4])); unsigned int sizeX((unsigned int) ::atoi(argv[5])); unsigned int sizeY((unsigned int) ::atoi(argv[6])); typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::ExtractROI FilterType; typedef FilterType::InputImageType InputImageType; typedef FilterType::OutputImageType OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; FilterType::Pointer filter = FilterType::New(); filter->SetStartX(startX); filter->SetStartY(startY); filter->SetSizeX(sizeX); filter->SetSizeY(sizeY); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbExtractROI2.cxx000066400000000000000000000040411301006202600240100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbExtractROI2(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int startX((unsigned int) ::atoi(argv[3])); unsigned int startY((unsigned int) ::atoi(argv[4])); unsigned int sizeX((unsigned int) ::atoi(argv[5])); unsigned int sizeY((unsigned int) ::atoi(argv[6])); typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::ExtractROI FilterType; typedef FilterType::InputImageType InputImageType; typedef FilterType::OutputImageType OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; FilterType::Pointer filter = FilterType::New(); typedef otb::Image ImageType; ImageType::IndexType start; start[0] = startX; start[1] = startY; ImageType::SizeType size; size[0] = sizeX; size[1] = sizeY; ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); filter->SetExtractionRegion(region); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbExtractROINew.cxx000066400000000000000000000016551301006202600244100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbExtractROI.h" int otbExtractROINew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef std::complex InputPixelType; typedef std::complex OutputPixelType; typedef otb::ExtractROI FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbExtractROITestMetaData.cxx000066400000000000000000000106261301006202600261750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itkUnaryFunctorImageFilter.h" #include "itkExtractImageFilter.h" #include "itkVectorIndexSelectionCastImageFilter.h" #include "otbExtractROI.h" #include "otbMultiChannelExtractROI.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otb_boost_string_header.h" int otbExtractROITestMetaData(int itkNotUsed(argc), char * argv[]) { typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ImageFileReaderType; typedef otb::ImageFileWriter ImageFileWriterType; typedef otb::ExtractROI ExtractROIType; ImageFileReaderType::Pointer readerInput = ImageFileReaderType::New(); ImageFileReaderType::Pointer reader00 = ImageFileReaderType::New(); ImageFileReaderType::Pointer reader57 = ImageFileReaderType::New(); ImageFileWriterType::Pointer writer00 = ImageFileWriterType::New(); ImageFileWriterType::Pointer writer57 = ImageFileWriterType::New(); ExtractROIType::Pointer extract00 = ExtractROIType::New(); ExtractROIType::Pointer extract57 = ExtractROIType::New(); // Read input file readerInput->SetFileName(argv[1]); readerInput->GenerateOutputInformation(); // Extract left up image extract00->SetInput(readerInput->GetOutput()); extract00->SetSizeX(50); extract00->SetSizeY(25); extract00->SetStartX(0); extract00->SetStartY(0); extract00->UpdateOutputInformation(); // Save left up image information std::ofstream file00; file00.open(argv[4]); file00 << static_cast(extract00->GetOutput()) << std::endl; file00.close(); // Extract image with non-zero index extract57->SetInput(readerInput->GetOutput()); extract57->SetSizeX(50); extract57->SetSizeY(25); extract57->SetStartX(5); extract57->SetStartY(7); extract57->UpdateOutputInformation(); // Save extract image information std::ofstream file57; file57.open(argv[5]); file57 << static_cast(extract57->GetOutput()) << std::endl; file57.close(); // Write left up image writer00->SetFileName(argv[2]); writer00->SetInput(extract00->GetOutput()); //writer00->SetWriteGeomFile(true); writer00->Update(); // Write image with non zero index writer57->SetFileName(argv[3]); writer57->SetInput(extract57->GetOutput()); //writer57->SetWriteGeomFile(true); writer57->Update(); // Reading image with left up index reader00->SetFileName(argv[2]); reader00->GenerateOutputInformation(); if( reader00->GetOutput()->GetProjectionRef() != "" || boost::algorithm::istarts_with(reader00->GetOutput()->GetProjectionRef(), "LOCAL_CS") ) { std::cout<<"The read generated extract from index (0, 0) must NOT contain a ProjectionReference."<GetOutput()->GetProjectionRef()<GetOutput()->GetGCPCount() == 0) { std::cout<<"The read generated extract from index (0, 0) must contain a list a GCPs.."<SetFileName(argv[3]); reader57->GenerateOutputInformation(); if( reader00->GetOutput()->GetProjectionRef() != "" || boost::algorithm::istarts_with(reader00->GetOutput()->GetProjectionRef(), "LOCAL_CS") ) { std::cout<<"The read generated extract from index (x, y) must NOT contain a ProjectionReference."<GetOutput()->GetProjectionRef()<GetOutput()->GetGCPCount() != 0) { std::cout<<"The read generated extract from index (x, y) must NOT contain a list a GCPs.."< InputPixelType; typedef itk::RGBPixel OutputPixelType; typedef otb::ExtractROI FilterType; typedef FilterType::InputImageType InputImageType; typedef FilterType::OutputImageType OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; FilterType::Pointer filter = FilterType::New(); filter->SetStartX(startX); filter->SetStartY(startY); filter->SetSizeX(sizeX); filter->SetSizeY(sizeY); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbFlexibleDistanceWithMissingValue.cxx000066400000000000000000000036461301006202600303440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkVariableLengthVector.h" #include "otbFlexibleDistanceWithMissingValue.h" int otbFlexibleDistanceWithMissingValue(int itkNotUsed(argc), char * argv[]) { typedef itk::VariableLengthVector VectorType; typedef otb::Statistics::FlexibleDistanceWithMissingValue DistanceType; const double epsilon(atof(argv[1])); float a = 2.0; float b = 0.5; unsigned int dim = 3; DistanceType::SetAlphaBeta(a, b); VectorType x(dim); x.Fill(1.); VectorType y(dim); y.Fill(2.); DistanceType::Pointer dist = DistanceType::New(); double distanceValue = dist->Evaluate(x, y); std::cout << std::setprecision(20) << std::endl; std::cout << "dim, a, b : " << dim << "," << a << "," << b << std::endl; std::cout << "dim*vcl_pow(3, b) : " << dim*vcl_pow(3, b) << std::endl; std::cout << "Distance : " << distanceValue << std::endl; std::cout << "Epsilon : " << epsilon << std::endl; std::cout << "-> Tests diff : " << vcl_abs(distanceValue - dim * vcl_pow(3, b)) << std::endl; if (vcl_abs(distanceValue - dim * vcl_pow(3, b)) < epsilon) return EXIT_SUCCESS; else return EXIT_FAILURE; } OTB-release-5.8/Modules/Core/ImageBase/test/otbFlexibleDistanceWithMissingValueNew.cxx000066400000000000000000000023451301006202600310110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itkVariableLengthVector.h" #include "otbFlexibleDistanceWithMissingValue.h" int otbFlexibleDistanceWithMissingValueNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef itk::VariableLengthVector VectorType; typedef otb::Statistics::FlexibleDistanceWithMissingValue DistanceType; float a = 1.0; float b = 0.1; DistanceType::SetAlphaBeta(a, b); DistanceType::Pointer dist = DistanceType::New(); std::cout << dist << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbFunctionToImageFilter.cxx000066400000000000000000000041231301006202600261440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbFunctionToImageFilter.h" #include "itkVarianceImageFunction.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbFunctionToImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::VarianceImageFunction FunctionType; typedef otb::FunctionToImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); FunctionType::Pointer function = FunctionType::New(); function->SetNeighborhoodRadius(atoi(argv[3])); function->SetInputImage(reader->GetOutput()); filter->SetFunction(function); writer->SetInput(filter->GetOutput()); writer->SetNumberOfDivisionsStrippedStreaming(2); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbFunctionToImageFilterNew.cxx000066400000000000000000000022671301006202600266250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbFunctionToImageFilter.h" #include "itkVarianceImageFunction.h" int otbFunctionToImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef itk::VarianceImageFunction FunctionType; typedef otb::FunctionToImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbImageAndVectorImageOperationFilterNew.cxx000066400000000000000000000025401301006202600312400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageAndVectorImageOperationFilter.h" int otbImageAndVectorImageOperationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; typedef otb::Image ScalarImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageAndVectorImageOperationFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbImageAndVectorImageOperationFilterTest.cxx000066400000000000000000000053051301006202600314300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageAndVectorImageOperationFilter.h" int otbImageAndVectorImageOperationFilterTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * invectfname = argv[2]; const char * outfnameAdd = argv[3]; const char * outfnameSub = argv[4]; const char * outfnameMul = argv[5]; const char * outfnameDiv = argv[6]; typedef double PixelType; typedef otb::Image ScalarImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader VectorReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageAndVectorImageOperationFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); VectorReaderType::Pointer vectorReader = VectorReaderType::New(); FilterType::Pointer filter = FilterType::New(); WriterType::Pointer writerAdd = WriterType::New(); WriterType::Pointer writerSub = WriterType::New(); WriterType::Pointer writerMul = WriterType::New(); WriterType::Pointer writerDiv = WriterType::New(); reader->SetFileName(infname); vectorReader->SetFileName(invectfname); filter->SetInput(reader->GetOutput()); filter->SetVectorInput(vectorReader->GetOutput()); filter->UseAddition(); writerAdd->SetInput(filter->GetOutput()); writerAdd->SetFileName(outfnameAdd); writerAdd->Update(); filter->UseSubtraction(); writerSub->SetInput(filter->GetOutput()); writerSub->SetFileName(outfnameSub); writerSub->Update(); filter->UseMultiplication(); writerMul->SetInput(filter->GetOutput()); writerMul->SetFileName(outfnameMul); writerMul->Update(); filter->UseDivision(); writerDiv->SetInput(filter->GetOutput()); writerDiv->SetFileName(outfnameDiv); writerDiv->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbImageBaseTestDriver.cxx000066400000000000000000000026621301006202600256020ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbFlexibleDistanceWithMissingValue); REGISTER_TEST(otbImageAndVectorImageOperationFilterNew); REGISTER_TEST(otbImagePCAShapeModelEstimatorTest); REGISTER_TEST(otbFunctionToImageFilter); REGISTER_TEST(otbExtractROI2); REGISTER_TEST(otbComplexToVectorImageCastFilterNew); REGISTER_TEST(otbComplexToVectorImageCastFilterTest); REGISTER_TEST(otbMultiChannelExtractROI); REGISTER_TEST(otbVectorImageLegacyTest); REGISTER_TEST(otbVectorImageTest); REGISTER_TEST(otbExtractROITestMetaData); REGISTER_TEST(otbTestMultiExtractMultiUpdate); REGISTER_TEST(otbExtractROI); REGISTER_TEST(otbFunctionToImageFilterNew); REGISTER_TEST(otbVectorImageToASImageAdaptorNew); REGISTER_TEST(otbImageAndVectorImageOperationFilterTest); REGISTER_TEST(otbImageOfVectorsToMonoChannelExtractROI); REGISTER_TEST(otbImageOfVectorsToMonoChannelExtractROINew); REGISTER_TEST(otbExtractROINew); REGISTER_TEST(otbExtractROI_RGB); REGISTER_TEST(otbComplexToIntensityFilterTest); REGISTER_TEST(otbMultiToMonoChannelExtractROINew); REGISTER_TEST(otbMultiToMonoChannelExtractROI); REGISTER_TEST(otbImageTest); REGISTER_TEST(otbFlexibleDistanceWithMissingValueNew); REGISTER_TEST(otbImageFunctionAdaptorNew); REGISTER_TEST(otbImageFunctionAdaptor); REGISTER_TEST(otbMultiChannelExtractROINew); REGISTER_TEST(otbMetaImageFunction); REGISTER_TEST(otbMetaImageFunctionNew); } OTB-release-5.8/Modules/Core/ImageBase/test/otbImageFunctionAdaptor.cxx000066400000000000000000000401651301006202600260140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbStreamingMinMaxImageFilter.h" #include "otbImageFunctionAdaptor.h" #include "otbFourierMellinDescriptorsImageFunction.h" #include "otbRealMomentsImageFunction.h" #include "otbComplexMomentsImageFunction.h" #include "otbFlusserMomentsImageFunction.h" #include "otbHuMomentsImageFunction.h" #include "otbRadiometricMomentsImageFunction.h" #include "otbLocalHistogramImageFunction.h" int otbImageFunctionAdaptorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef double PrecisionType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::FourierMellinDescriptorsImageFunction FMDFunctionType; typedef otb::RealMomentsImageFunction RMFunctionType; typedef otb::ComplexMomentsImageFunction CMFunctionType; typedef otb::FlusserMomentsImageFunction FMFunctionType; typedef otb::HuMomentsImageFunction HMFunctionType; typedef otb::RadiometricMomentsImageFunction RaMFunctionType; typedef otb::LocalHistogramImageFunction LHFunctionType; typedef otb::ImageFunctionAdaptor FMDImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor RMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor CMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor FMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor HMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor RaMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor LHImageFunctionAdaptorType; // Instantiating objects FMDImageFunctionAdaptorType::Pointer FMDadaptedFunction = FMDImageFunctionAdaptorType::New(); std::cout << FMDadaptedFunction << std::endl; RMImageFunctionAdaptorType::Pointer RMadaptedFunction = RMImageFunctionAdaptorType::New(); std::cout << RMadaptedFunction << std::endl; CMImageFunctionAdaptorType::Pointer CMadaptedFunction = CMImageFunctionAdaptorType::New(); std::cout << CMadaptedFunction << std::endl; FMImageFunctionAdaptorType::Pointer FMadaptedFunction = FMImageFunctionAdaptorType::New(); std::cout << FMadaptedFunction << std::endl; HMImageFunctionAdaptorType::Pointer HMadaptedFunction = HMImageFunctionAdaptorType::New(); std::cout << HMadaptedFunction << std::endl; RaMImageFunctionAdaptorType::Pointer RaMadaptedFunction = RaMImageFunctionAdaptorType::New(); std::cout << RaMadaptedFunction << std::endl; LHImageFunctionAdaptorType::Pointer LHadaptedFunction = LHImageFunctionAdaptorType::New(); std::cout << LHadaptedFunction << std::endl; return EXIT_SUCCESS; } int otbImageFunctionAdaptor(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; typedef double InputPixelType; typedef double PrecisionType; const unsigned int Dimension = 2; unsigned int rsltIdx = 0; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingMinMaxImageFilter MinMaxFilterType; typedef otb::FourierMellinDescriptorsImageFunction FMDFunctionType; typedef otb::RealMomentsImageFunction RMFunctionType; typedef otb::ComplexMomentsImageFunction CMFunctionType; typedef otb::FlusserMomentsImageFunction FMFunctionType; typedef otb::HuMomentsImageFunction HMFunctionType; typedef otb::RadiometricMomentsImageFunction RaMFunctionType; typedef otb::LocalHistogramImageFunction LHFunctionType; typedef otb::ImageFunctionAdaptor FMDImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor RMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor CMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor FMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor HMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor RaMImageFunctionAdaptorType; typedef otb::ImageFunctionAdaptor LHImageFunctionAdaptorType; // Instantiating objects ReaderType::Pointer reader = ReaderType::New(); MinMaxFilterType::Pointer filter = MinMaxFilterType::New(); FMDFunctionType::Pointer FMDFunction = FMDFunctionType::New(); RMFunctionType::Pointer RMFunction = RMFunctionType::New(); CMFunctionType::Pointer CMFunction = CMFunctionType::New(); FMFunctionType::Pointer FMFunction = FMFunctionType::New(); HMFunctionType::Pointer HMFunction = HMFunctionType::New(); RaMFunctionType::Pointer RaMFunction = RaMFunctionType::New(); LHFunctionType::Pointer LHFunction = LHFunctionType::New(); FMDImageFunctionAdaptorType::Pointer FMDadaptedFunction = FMDImageFunctionAdaptorType::New(); RMImageFunctionAdaptorType::Pointer RMadaptedFunction = RMImageFunctionAdaptorType::New(); CMImageFunctionAdaptorType::Pointer CMadaptedFunction = CMImageFunctionAdaptorType::New(); FMImageFunctionAdaptorType::Pointer FMadaptedFunction = FMImageFunctionAdaptorType::New(); HMImageFunctionAdaptorType::Pointer HMadaptedFunction = HMImageFunctionAdaptorType::New(); RaMImageFunctionAdaptorType::Pointer RaMadaptedFunction = RaMImageFunctionAdaptorType::New(); LHImageFunctionAdaptorType::Pointer LHadaptedFunction = LHImageFunctionAdaptorType::New(); reader->SetFileName(inputFilename); filter->SetInput(reader->GetOutput()); filter->Update(); InputImageType::IndexType index; index[0] = 100; index[1] = 100; // Content testing double error = 0.0; try { FMDFunction->SetInputImage(reader->GetOutput()); FMDFunction->SetNeighborhoodRadius(5); FMDFunction->SetPmax(5); FMDFunction->SetQmax(5); FMDFunctionType::OutputType resultFMD = FMDFunction->EvaluateAtIndex(index); FMDadaptedFunction->SetInputImage(reader->GetOutput()); FMDadaptedFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); FMDadaptedFunction->GetInternalImageFunction()->SetPmax(5); FMDadaptedFunction->GetInternalImageFunction()->SetQmax(5); FMDImageFunctionAdaptorType::OutputType resultAdaptedFMD = FMDadaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i <= 5; ++i) { for (unsigned int j = 0; j <= 5; ++j) { error += vcl_pow(vcl_abs(resultAdaptedFMD[rsltIdx] - resultFMD.at(i).at(j)), 2); std::cout << "resultAdaptedFMD : " << resultAdaptedFMD[rsltIdx] << "\t - resultFMD : " << resultFMD.at(i).at(j) << std::endl; rsltIdx++; } } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for FMDadaptedFunction() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } try { RMFunction->SetInputImage(reader->GetOutput()); RMFunction->SetNeighborhoodRadius(5); RMFunction->SetPmax(5); RMFunction->SetQmax(5); RMFunctionType::OutputType resultRM = RMFunction->EvaluateAtIndex(index); RMadaptedFunction->SetInputImage(reader->GetOutput()); RMadaptedFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); RMadaptedFunction->GetInternalImageFunction()->SetPmax(5); RMadaptedFunction->GetInternalImageFunction()->SetQmax(5); RMImageFunctionAdaptorType::OutputType resultAdaptedRM = RMadaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i <= 5; ++i) { for (unsigned int j = 0; j <= 5; ++j) { error += vcl_pow(vcl_abs(resultAdaptedRM[rsltIdx] - resultRM.at(i).at(j)), 2); std::cout << "resultAdaptedRM : " << resultAdaptedRM[rsltIdx] << "\t - resultRM : " << resultRM.at(i).at(j) << std::endl; rsltIdx++; } } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for RMFunction() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } try { CMFunction->SetInputImage(reader->GetOutput()); CMFunction->SetNeighborhoodRadius(5); CMFunction->SetPmax(5); CMFunction->SetQmax(5); CMFunctionType::OutputType resultCM = CMFunction->EvaluateAtIndex(index); CMadaptedFunction->SetInputImage(reader->GetOutput()); CMadaptedFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); CMadaptedFunction->GetInternalImageFunction()->SetPmax(5); CMadaptedFunction->GetInternalImageFunction()->SetQmax(5); CMImageFunctionAdaptorType::OutputType resultAdaptedCM = CMadaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i <= 5; ++i) { for (unsigned int j = 0; j <= 5; ++j) { error += vcl_pow(vcl_abs(resultAdaptedCM[rsltIdx] - resultCM.at(i).at(j).real()), 2); std::cout << "resultAdaptedCM : (" << resultAdaptedCM[rsltIdx] << "," << resultAdaptedCM[rsltIdx + 1] << ")" << "\t - resultCM : " << resultCM.at(i).at(j) << std::endl; rsltIdx++; error += vcl_pow(vcl_abs(resultAdaptedCM[rsltIdx] - resultCM.at(i).at(j).imag()), 2); rsltIdx++; } } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for CMadaptedFunction() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } try { FMFunction->SetInputImage(reader->GetOutput()); FMFunction->SetNeighborhoodRadius(5); FMFunctionType::OutputType resultFM = FMFunction->EvaluateAtIndex(index); FMadaptedFunction->SetInputImage(reader->GetOutput()); FMadaptedFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); FMImageFunctionAdaptorType::OutputType resultAdaptedFM = FMadaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i < 11; ++i) { error += vcl_pow(vcl_abs(resultAdaptedFM[rsltIdx] - resultFM[i]), 2); std::cout << "resultAdaptedFM : " << resultAdaptedFM[rsltIdx] << "\t - resultFM : " << resultFM[i] << std::endl; rsltIdx++; } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for FMFunction() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } try { HMFunction->SetInputImage(reader->GetOutput()); HMFunction->SetNeighborhoodRadius(5); HMFunctionType::OutputType resultHM = HMFunction->EvaluateAtIndex(index); HMadaptedFunction->SetInputImage(reader->GetOutput()); HMadaptedFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); HMImageFunctionAdaptorType::OutputType resultAdaptedHM = HMadaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i < 7; ++i) { error += vcl_pow(vcl_abs(resultAdaptedHM[rsltIdx] - resultHM[i]), 2); std::cout << "resultAdaptedHM : " << resultAdaptedHM[rsltIdx] << "\t - resultHM : " << resultHM[i] << std::endl; rsltIdx++; } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for HMFunction() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } try { RaMFunction->SetInputImage(reader->GetOutput()); RaMFunction->SetNeighborhoodRadius(5); RaMFunctionType::OutputType resultRaM = RaMFunction->EvaluateAtIndex(index); RaMadaptedFunction->SetInputImage(reader->GetOutput()); RaMadaptedFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); RaMImageFunctionAdaptorType::OutputType resultAdaptedRaM = RaMadaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i < 4; ++i) { error += vcl_pow(vcl_abs(resultAdaptedRaM[rsltIdx] - resultRaM[i]), 2); std::cout << "resultAdaptedRaM : " << resultAdaptedRaM[rsltIdx] << "\t - resultRaM : " << resultRaM[i] << std::endl; rsltIdx++; } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for RaMFunction() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } try { LHFunction->SetInputImage(reader->GetOutput()); LHFunction->SetNeighborhoodRadius(5); LHFunction->SetNumberOfHistogramBins(64); LHFunction->SetHistogramMin(filter->GetMinimum()); LHFunction->SetHistogramMax(filter->GetMaximum()); LHFunctionType::OutputType resultLH = LHFunction->EvaluateAtIndex(index); LHadaptedFunction->SetInputImage(reader->GetOutput()); LHadaptedFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); LHadaptedFunction->GetInternalImageFunction()->SetNumberOfHistogramBins(64); LHadaptedFunction->GetInternalImageFunction()->SetHistogramMin(filter->GetMinimum()); LHadaptedFunction->GetInternalImageFunction()->SetHistogramMax(filter->GetMaximum()); LHImageFunctionAdaptorType::OutputType resultAdaptedLH = LHadaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i < 64; ++i) { error += vcl_pow(vcl_abs(resultAdaptedLH[rsltIdx] - resultLH->GetFrequency(i)), 2); std::cout << "resultAdaptedLH : " << resultAdaptedLH[rsltIdx] << "\t - resultLH : " << resultLH->GetFrequency(i) << std::endl; rsltIdx++; } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for LHFunction() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } error = vcl_sqrt(error); std::cout << std::endl << "Error : " << error << std::endl << std::endl; if (error > 1E-3) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-9 -> TEST FAILLED" << std::endl ); } // Testing the use of a user defined InternalImageFunction instead // of the build-in InternalImageFunction try { FMDFunctionType::Pointer myFunction = FMDFunctionType::New(); FMDImageFunctionAdaptorType::Pointer myAdaptedFunction = FMDImageFunctionAdaptorType::New(); myFunction->SetNeighborhoodRadius(8); myFunction->SetPmax(2); myFunction->SetQmax(2); myAdaptedFunction->SetInputImage(reader->GetOutput()); myAdaptedFunction->SetInternalImageFunction(myFunction); FMDImageFunctionAdaptorType::OutputType myResult = myAdaptedFunction->EvaluateAtIndex(index); rsltIdx = 0; for (unsigned int i = 0; i <= 2; ++i) { for (unsigned int j = 0; j <= 2; ++j) { std::cout << "myResult: " << myResult[rsltIdx] << std::endl; rsltIdx++; } } std::cout << myAdaptedFunction << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for FMDFunctionType() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbImageOfVectorsToMonoChannelExtractROI.cxx000066400000000000000000000037321301006202600311570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageOfVectorsToMonoChannelExtractROI.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageOfVectorsToMonoChannelExtractROI(int itkNotUsed(argc), char * argv[]) { const int Dimension = 2; typedef unsigned char ScalarPixelType; typedef itk::Vector VectorPixelType; const char * inputImageFileName = argv[1]; const char * outputImageFileName = argv[7]; typedef otb::Image ScalarImageType; typedef otb::Image VectorImageType; typedef otb::ImageOfVectorsToMonoChannelExtractROI FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageFileName); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageFileName); // Instantiating object FilterType::Pointer object = FilterType::New(); object->SetStartX(atoi(argv[2])); object->SetStartY(atoi(argv[3])); object->SetSizeX(atoi(argv[4])); object->SetSizeY(atoi(argv[5])); object->SetChannel(atoi(argv[6])); object->SetInput(reader->GetOutput()); writer->SetInput(object->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbImageOfVectorsToMonoChannelExtractROINew.cxx000066400000000000000000000024271301006202600316310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageOfVectorsToMonoChannelExtractROI.h" int otbImageOfVectorsToMonoChannelExtractROINew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef unsigned char ScalarPixelType; typedef itk::Vector VectorPixelType; typedef otb::Image ScalarImageType; typedef otb::Image VectorImageType; typedef otb::ImageOfVectorsToMonoChannelExtractROI FilterType; // Instantiating object FilterType::Pointer object = FilterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbImagePCAShapeModelEstimatorTest.cxx000066400000000000000000000155161301006202600300130ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkImagePCAShapeModelEstimatorTest.cxx, v $ Language: C++ Date: $Date: 2008-02-03 04:05:34 $ Version: $Revision: 1.11 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Insight classes #include "otbImage.h" #include "itkVector.h" #include "vnl/vnl_matrix_fixed.h" #include "vnl/vnl_math.h" #include "itkLightProcessObject.h" #include "itkTextOutput.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkImagePCAShapeModelEstimator.h" //Data definitions #define IMGWIDTH 2 #define IMGHEIGHT 2 #define NDIMENSION 2 #define NUMTRAINIMAGES 3 #define NUMLARGESTPC 3 // class to support progress feeback class ShowProgressObject { public: ShowProgressObject(itk::LightProcessObject * o) { m_Process = o; } void ShowProgress() { std::cout << "Progress " << m_Process->GetProgress() << std::endl; } itk::LightProcessObject::Pointer m_Process; }; int otbImagePCAShapeModelEstimatorTest(int itkNotUsed(argc), char* argv[]) { /* const unsigned int numberOfPrincipalComponentsRequired(atoi(argv[1])); const unsigned int numberOfTrainingImages(atoi(argv[2])); std::vector imagesfilenames; std::vector outputimagesfilenames; int cpt(3); for(; cpt<(numberOfTrainingImages+3); ++cpt) { imagesfilenames.push_back(argv[cpt]); } int cpt2(cpt); for(; cpt<(numberOfPrincipalComponentsRequired+cpt2); ++cpt) { outputimagesfilenames.push_back(argv[cpt]); } */ itk::OutputWindow::SetInstance(itk::TextOutput::New().GetPointer()); //------------------------------------------------------ //Create 3 simple test images with //------------------------------------------------------ typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object ReaderType::Pointer reader1 = ReaderType::New(); ReaderType::Pointer reader2 = ReaderType::New(); ReaderType::Pointer reader3 = ReaderType::New(); WriterType::Pointer writer1 = WriterType::New(); WriterType::Pointer writer2 = WriterType::New(); WriterType::Pointer writer3 = WriterType::New(); WriterType::Pointer writer4 = WriterType::New(); reader1->SetFileName(argv[1]); reader2->SetFileName(argv[2]); reader3->SetFileName(argv[3]); writer1->SetFileName(argv[4]); writer2->SetFileName(argv[5]); writer3->SetFileName(argv[6]); writer4->SetFileName(argv[7]); //---------------------------------------------------------------------- // Test code for the Shape model estimator //---------------------------------------------------------------------- //---------------------------------------------------------------------- //Set the image model estimator //---------------------------------------------------------------------- typedef itk::ImagePCAShapeModelEstimator ImagePCAShapeModelEstimatorType; ImagePCAShapeModelEstimatorType::Pointer applyPCAShapeEstimator = ImagePCAShapeModelEstimatorType::New(); //---------------------------------------------------------------------- //Set the parameters of the clusterer //---------------------------------------------------------------------- applyPCAShapeEstimator->SetNumberOfTrainingImages(NUMTRAINIMAGES); applyPCAShapeEstimator->SetNumberOfPrincipalComponentsRequired(NUMLARGESTPC + 1); applyPCAShapeEstimator->SetNumberOfPrincipalComponentsRequired(NUMLARGESTPC); applyPCAShapeEstimator->SetInput(0, reader1->GetOutput()); applyPCAShapeEstimator->SetInput(1, reader2->GetOutput()); applyPCAShapeEstimator->SetInput(2, reader3->GetOutput()); applyPCAShapeEstimator->Update(); writer1->SetInput(applyPCAShapeEstimator->GetOutput(0)); writer1->Update(); writer2->SetInput(applyPCAShapeEstimator->GetOutput(1)); writer2->Update(); writer3->SetInput(applyPCAShapeEstimator->GetOutput(2)); writer3->Update(); writer4->SetInput(applyPCAShapeEstimator->GetOutput(3)); writer4->Update(); //Test the printself function to increase coverage applyPCAShapeEstimator->Print(std::cout); //Exercise TypeMacro in superclass typedef ImagePCAShapeModelEstimatorType::Superclass GenericEstimatorType; std::cout << applyPCAShapeEstimator->GenericEstimatorType::GetNameOfClass() << std::endl; //Print out the number of training images and the number of principal //components std::cout << "The number of training images are: " << applyPCAShapeEstimator->GetNumberOfTrainingImages() << std::endl; std::cout << "The number of principal components desired are: " << applyPCAShapeEstimator->GetNumberOfPrincipalComponentsRequired() << std::endl; //Print the eigen vectors vnl_vector eigenValues = applyPCAShapeEstimator->GetEigenValues(); unsigned int numEigVal = eigenValues.size(); std::cout << "Number of returned eign-values: " << numEigVal << std::endl; std::cout << "The " << applyPCAShapeEstimator->GetNumberOfPrincipalComponentsRequired() << " largest eigen values are:" << std::endl; for (unsigned int i = 0; i < vnl_math_min(numEigVal, (unsigned int) NUMLARGESTPC); ++i) { std::cout << eigenValues[i] << std::endl; } //Print the MeanImage /* OutputImageType::Pointer outImage = applyPCAShapeEstimator->GetOutput( 0 ); OutputImageIterator outImageIt( outImage, outImage->GetBufferedRegion() ); outImageIt.GoToBegin(); std::cout << "The mean image is:" << std::endl; while (!outImageIt.IsAtEnd() ) { std::cout << (double)(outImageIt.Get()) << ";" << std::endl; ++outImageIt; } std::cout << " " << std::endl; //Print the largest two eigen vectors for (unsigned int j=1; j< NUMLARGESTPC + 1; ++j ) { OutputImageType::Pointer outImage2 = applyPCAShapeEstimator->GetOutput( j ); OutputImageIterator outImage2It( outImage2, outImage2->GetBufferedRegion() ); outImage2It.GoToBegin(); std::cout << "" << std::endl; std::cout << "The eigen vector number: " << j << " is:" << std::endl; while (!outImage2It.IsAtEnd() ) { std::cout << (double) (outImage2It.Get()) << ";" << std::endl; ++outImage2It; } std::cout << " " << std::endl; } */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbImageTest.cxx000066400000000000000000000071401301006202600236270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include #include "otbImage.h" #include "otbImageFileReader.h" int otbImageTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputAsciiFilename = argv[2]; // unsigned int GCPnum((unsigned int)::atoi(argv[2])); typedef unsigned char InputPixelType; const unsigned int Dimension = 2; std::ofstream file; file.open(outputAsciiFilename); typedef otb::Image InputImageType; InputImageType::Pointer image = InputImageType::New(); typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->GenerateOutputInformation(); image = reader->GetOutput(); std::cout << "------ IMAGE --------" << std::endl; std::cout << image << std::endl; std::cout << "---------------------" << std::endl; file << "------ IMAGE --------" << std::endl; file << "Spacing " << image->GetSpacing() << std::endl; file << "Origin " << image->GetOrigin() << std::endl; file << "Projection REF " << image->GetProjectionRef() << std::endl; file << "GCP Projection " << image->GetGCPProjection() << std::endl; unsigned int GCPCount = image->GetGCPCount(); file << "GCP Count " << image->GetGCPCount() << std::endl; for (unsigned int GCPnum = 0; GCPnum < GCPCount; GCPnum++) { file << "GCP[" << GCPnum << "] Id " << image->GetGCPId(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Info " << image->GetGCPInfo(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Row " << image->GetGCPRow(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Col " << image->GetGCPCol(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] X " << image->GetGCPX(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Y " << image->GetGCPY(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Z " << image->GetGCPZ(GCPnum) << std::endl; file << "----------------" << std::endl; } InputImageType::VectorType tab = image->GetGeoTransform(); file << "Geo Transform " << std::endl; for (unsigned int i = 0; i < tab.size(); ++i) { file << " " << i << " -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetUpperLeftCorner(); file << "Corners " << std::endl; for (unsigned int i = 0; i < tab.size(); ++i) { file << " UL[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetUpperRightCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " UR[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetLowerLeftCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " LL[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetLowerRightCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " LR[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbMetaImageFunction.cxx000066400000000000000000000070771301006202600253150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMetaImageFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbFlusserMomentsImageFunction.h" #include "otbImageFunctionAdaptor.h" typedef unsigned short InputPixelType; typedef double PrecisionType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::FlusserMomentsImageFunction FlusserFunctionType; typedef otb::ImageFunctionAdaptor FunctionType; typedef otb::MetaImageFunction MetaImageFunctionType; typedef MetaImageFunctionType::PointType PointType; typedef MetaImageFunctionType::OutputType OutputType; int otbMetaImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { MetaImageFunctionType::Pointer function = MetaImageFunctionType::New(); return EXIT_SUCCESS; } int otbMetaImageFunction(int itkNotUsed(argc), char * argv[]) { // Read the input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->Update(); // Build flusser functions with different radius FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); FunctionType::Pointer function3 = FunctionType::New(); function1->SetInputImage(reader->GetOutput()); function2->SetInputImage(reader->GetOutput()); function3->SetInputImage(reader->GetOutput()); function1->GetInternalImageFunction()->SetNeighborhoodRadius(3); function2->GetInternalImageFunction()->SetNeighborhoodRadius(5); function3->GetInternalImageFunction()->SetNeighborhoodRadius(7); std::ofstream outputStream(argv[2]); MetaImageFunctionType::Pointer metaFunction = MetaImageFunctionType::New(); metaFunction->AddFunction(function1); metaFunction->AddFunction(function2); metaFunction->AddFunction(function3); outputStream<<"Initial number of functions: "<GetNumberOfFunctions()<RemoveNthFunction(2); outputStream<<"Number of functions after removing the 2nd: "<GetNumberOfFunctions()<ClearFunctions(); outputStream<<"Number of functions after clear: "<GetNumberOfFunctions()<AddFunction(function1); metaFunction->AddFunction(function2); metaFunction->AddFunction(function3); outputStream<<"Adding functions again: "<GetNumberOfFunctions()<GetNthFunction(0); PointType p; p[0] = atof(argv[3]); p[1] = atof(argv[4]); OutputType output = metaFunction->Evaluate(p); outputStream<<"Evaluate("< int generic_otbMultiChannelExtractROI(int itkNotUsed(argc), char * argv[], const char * inputFilename, const char * outputFilename) { typedef otb::MultiChannelExtractROI ExtractROIFilterType; int computeExtractTime = 0; typename ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); int cpt(0), nbcanaux(0); while (argv[cpt] != ITK_NULLPTR) { std::string strArgv(argv[cpt]); if (strArgv == "-startX") { extractROIFilter->SetStartX((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetStartX(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-startY") { extractROIFilter->SetStartY((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetStartY(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-sizeX") { extractROIFilter->SetSizeX((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetSizeX(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-sizeY") { extractROIFilter->SetSizeY((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetSizeY(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-time") { std::cout << " ->Extract time will be computed" << std::endl; computeExtractTime = 1; cpt += 1; } else if (strArgv == "-channels") { ++cpt; bool searchChannels(true); while (searchChannels == true) { if (argv[cpt] == ITK_NULLPTR) { searchChannels = false; } else // Check if we have set another option { if (argv[cpt][0] == '-') { searchChannels = false; } else { extractROIFilter->SetChannel((unsigned int) ::atoi(argv[cpt])); std::cout << " ->SetChannel(" << ::atoi(argv[cpt]) << ")" << std::endl; ++cpt; nbcanaux++; } } } } } // Resume the command line std::cout << " Selected ROI: startX " << extractROIFilter->GetStartX() << std::endl; std::cout << " startY " << extractROIFilter->GetStartY() << std::endl; std::cout << " sizeX " << extractROIFilter->GetSizeX() << std::endl; std::cout << " sizeY " << extractROIFilter->GetSizeY() << std::endl; std::cout << " Selected Channels: (" << extractROIFilter->GetNbChannels() << ") : "; typename ExtractROIFilterType::ChannelsType lChannels; lChannels = extractROIFilter->GetChannels(); for (unsigned int i = 0; i < lChannels.size(); ++i) { std::cout << lChannels[i] << " "; } std::cout << " Extracted " << nbcanaux << " channels from input image." << std::endl; // OTB-FA-00008-CS typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); extractROIFilter->SetInput(reader->GetOutput()); writer->SetInput(extractROIFilter->GetOutput()); itk::TimeProbe chrono; if (computeExtractTime) { chrono.Start(); } writer->Update(); if (computeExtractTime) { chrono.Stop(); std::cout << " Time to compute the extracted image: " << chrono.GetTotal() << " seconds" << std::endl; } std::cout << " Number of channels in the input image: " << reader->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; std::cout << " Number of channels in the output image: " << extractROIFilter->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; return EXIT_SUCCESS; } int otbMultiChannelExtractROI(int argc, char * argv[]) { std::string linputPixelType; std::string loutputPixelType; const char * inputFilename; const char * outputFilename; int cpt(1); if (argv[cpt][0] == '-') { linputPixelType = std::string(argv[cpt]); ++cpt; inputFilename = argv[cpt]; ++cpt; } else { linputPixelType = std::string("-uchar"); inputFilename = argv[cpt]; ++cpt; } if (argv[cpt][0] == '-') { loutputPixelType = std::string(argv[cpt]); ++cpt; outputFilename = argv[cpt]; ++cpt; } else { loutputPixelType = std::string("-uchar"); outputFilename = argv[cpt]; ++cpt; } argc -= cpt; argv += cpt; std::cout << " -> " << linputPixelType << " for " << inputFilename << std::endl; std::cout << " -> " << loutputPixelType << " for " << outputFilename << std::endl; std::string pixelType; if ((linputPixelType == "-uchar") && (loutputPixelType == "-uchar")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-char") && (loutputPixelType == "-char")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-ushort") && (loutputPixelType == "-ushort")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-uint")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-float")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-double") && (loutputPixelType == "-double")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); // Type -> uchar else if ((linputPixelType == "-ushort") && (loutputPixelType == "-uchar")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-uchar")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-uchar")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-double") && (loutputPixelType == "-uchar")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); // uchar -> Type else if ((linputPixelType == "-uchar") && (loutputPixelType == "-double")) return (generic_otbMultiChannelExtractROI(argc, argv, inputFilename, outputFilename)); else { std::cout << " Error : the output image format is not well defined by the command line !!!" << std::endl; std::cout << " possible values: -uchar, -char, -ushort, -uint, -float, -double" << std::endl; std::cout << " default value: -uchar" << std::endl; return EXIT_FAILURE; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Core/ImageBase/test/otbMultiChannelExtractROINew.cxx000066400000000000000000000022651301006202600267120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMultiChannelExtractROI.h" int otbMultiChannelExtractROINew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // typedef unsigned char InputPixelType; // typedef unsigned char OutputPixelType; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; typedef otb::MultiChannelExtractROI ExtractROIFilterType; ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); std::cout << extractROIFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbMultiToMonoChannelExtractROI.cxx000066400000000000000000000375601301006202600274020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiToMonoChannelExtractROI.h" template int generic_otbMultiToMonoChannelExtractROI(int itkNotUsed(argc), char * argv[], const char * inputFilename, const char * outputFilename) { typedef otb::MultiToMonoChannelExtractROI ExtractROIFilterType; typename ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); int cpt(0); while (argv[cpt] != ITK_NULLPTR) { std::string strArgv(argv[cpt]); if (strArgv == "-startX") { extractROIFilter->SetStartX((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetStartX(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-startY") { extractROIFilter->SetStartY((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetStartY(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-sizeX") { extractROIFilter->SetSizeX((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetSizeX(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-sizeY") { extractROIFilter->SetSizeY((unsigned long) ::atoi(argv[cpt + 1])); std::cout << " ->SetSizeY(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } else if (strArgv == "-channel") { extractROIFilter->SetChannel((unsigned int) ::atoi(argv[cpt + 1])); std::cout << " ->SetChannel(" << ::atoi(argv[cpt + 1]) << ")" << std::endl; cpt += 2; } } // Resume de la ligne de commande std::cout << " ROI selectionnee : startX " << extractROIFilter->GetStartX() << std::endl; std::cout << " startY " << extractROIFilter->GetStartY() << std::endl; std::cout << " sizeX " << extractROIFilter->GetSizeX() << std::endl; std::cout << " sizeY " << extractROIFilter->GetSizeY() << std::endl; std::cout << " Canal selectionne : (" << extractROIFilter->GetChannel() << ") : "; // OTB-FA-00008-CS // typedef otb::ImageFileReader< typename ExtractROIFilterType::InputImageType, itk::DefaultConvertPixelTraits< InputPixelType > > ReaderType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); //THOMAS // reader->Update(); //Necessaire pour connaitre le nombre de canaux dans l'image writer->SetFileName(outputFilename); extractROIFilter->SetInput(reader->GetOutput()); writer->SetInput(extractROIFilter->GetOutput()); writer->Update(); std::cout << " Nb canaux dans l'image d'entree : " << reader->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; std::cout << " Nb canaux dans l'image de sortie : " << extractROIFilter->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; return EXIT_SUCCESS; } int otbMultiToMonoChannelExtractROI(int argc, char * argv[]) { std::string linputPixelType; std::string loutputPixelType; const char * inputFilename; const char * outputFilename; int cpt(1); if (argv[cpt][0] == '-') { linputPixelType = std::string(argv[cpt]); ++cpt; inputFilename = argv[cpt]; ++cpt; } else { linputPixelType = std::string("-uchar"); inputFilename = argv[cpt]; ++cpt; } if (argv[cpt][0] == '-') { loutputPixelType = std::string(argv[cpt]); ++cpt; outputFilename = argv[cpt]; ++cpt; } else { loutputPixelType = std::string("-uchar"); outputFilename = argv[cpt]; ++cpt; } argc -= cpt; argv += cpt; std::cout << " -> " << linputPixelType << " pour " << inputFilename << std::endl; std::cout << " -> " << loutputPixelType << " pour " << outputFilename << std::endl; std::string pixelType; if ((linputPixelType == "-uchar") && (loutputPixelType == "-uchar")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-short") && (loutputPixelType == "-short")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-ushort") && (loutputPixelType == "-ushort")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-int") && (loutputPixelType == "-int")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-uint")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-float")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-double") && (loutputPixelType == "-double")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); // Type -> uchar else if ((linputPixelType == "-short") && (loutputPixelType == "-uchar")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-ushort") && (loutputPixelType == "-uchar")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-int") && (loutputPixelType == "-uchar")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-uchar")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-uchar")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-double") && (loutputPixelType == "-uchar")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); // Type -> ushort else if ((linputPixelType == "-uchar") && (loutputPixelType == "-ushort")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-int") && (loutputPixelType == "-ushort")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-ushort")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-ushort")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-double") && (loutputPixelType == "-ushort")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); // Type -> ushort else if ((linputPixelType == "-uchar") && (loutputPixelType == "-short")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-int") && (loutputPixelType == "-short")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-short")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-short")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-double") && (loutputPixelType == "-short")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); // Type -> int else if ((linputPixelType == "-uchar") && (loutputPixelType == "-int")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-short") && (loutputPixelType == "-int")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-ushort") && (loutputPixelType == "-int")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-int")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-int")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-double") && (loutputPixelType == "-int")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); // Type -> double else if ((linputPixelType == "-uchar") && (loutputPixelType == "-double")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-short") && (loutputPixelType == "-double")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-ushort") && (loutputPixelType == "-double")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-int") && (loutputPixelType == "-double")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-uint") && (loutputPixelType == "-double")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else if ((linputPixelType == "-float") && (loutputPixelType == "-double")) return (generic_otbMultiToMonoChannelExtractROI(argc, argv, inputFilename, outputFilename)); else { std::cout << " Error : wrong format" << std::endl; std::cout << " allowed values : -uchar, -ushort, -uint, -float, -double" << std::endl; std::cout << " default value : -uchar" << std::endl; return EXIT_FAILURE; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Core/ImageBase/test/otbMultiToMonoChannelExtractROINew.cxx000066400000000000000000000023101301006202600300350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMultiToMonoChannelExtractROI.h" int otbMultiToMonoChannelExtractROINew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // typedef unsigned char InputPixelType; // typedef unsigned char OutputPixelType; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; typedef otb::MultiToMonoChannelExtractROI ExtractROIFilterType; ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); std::cout << extractROIFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbTestMultiExtractMultiUpdate.cxx000066400000000000000000000040571301006202600274140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbMultiChannelExtractROI.h" #include "otbSystem.h" int otbTestMultiExtractMultiUpdate(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double InternPixelType; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelExtractROI ExtractInternVectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); ExtractInternVectorType::Pointer extractInternVector = ExtractInternVectorType::New(); //readerMS->UpdateOutputInformation(); extractInternVector->SetInput(reader->GetOutput()); extractInternVector->SetStartX(atoi(argv[3])); extractInternVector->SetStartY(atoi(argv[4])); extractInternVector->SetSizeX(atoi(argv[5])); extractInternVector->SetSizeY(atoi(argv[6])); extractInternVector->SetFirstChannel(atoi(argv[7])); extractInternVector->SetLastChannel(atoi(argv[8])); extractInternVector->Update(); extractInternVector->Update(); extractInternVector->Update(); writer->SetInput(extractInternVector->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbVectorImageTest.cxx000066400000000000000000000110171301006202600250100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" int otbVectorImageLegacyTest(int argc, char* argv[]) { // Verify the number of parameters in the command line if (argc < 3) { std::cout << argv[0] << " [dataset number]" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputAsciiFilename = argv[2]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); InputImageType::Pointer image = InputImageType::New(); image = reader->GetOutput(); std::ofstream file; file.open(outputAsciiFilename); std::cout << "------ IMAGE --------" << std::endl; std::cout << image << std::endl; std::cout << "---------------------" << std::endl; file << "------ IMAGE --------" << std::endl; file << "Spacing " << image->GetSpacing() << std::endl; file << "Origin " << image->GetOrigin() << std::endl; file << "Projection REF " << image->GetProjectionRef() << std::endl; file << "GCP Projection " << image->GetGCPProjection() << std::endl; unsigned int GCPCount = image->GetGCPCount(); file << "GCP Count " << image->GetGCPCount() << std::endl; for (unsigned int GCPnum = 0; GCPnum < GCPCount; GCPnum++) { file << "GCP[" << GCPnum << "] Id " << image->GetGCPId(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Info " << image->GetGCPInfo(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Row " << image->GetGCPRow(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Col " << image->GetGCPCol(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] X " << image->GetGCPX(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Y " << image->GetGCPY(GCPnum) << std::endl; file << "GCP[" << GCPnum << "] Z " << image->GetGCPZ(GCPnum) << std::endl; file << "----------------" << std::endl; } InputImageType::VectorType tab = image->GetGeoTransform(); file << "Geo Transform " << std::endl; for (unsigned int i = 0; i < tab.size(); ++i) { file << " " << i << " -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetUpperLeftCorner(); file << "Corners " << std::endl; for (unsigned int i = 0; i < tab.size(); ++i) { file << " UL[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetUpperRightCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " UR[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetLowerLeftCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " LL[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); tab = image->GetLowerRightCorner(); for (unsigned int i = 0; i < tab.size(); ++i) { file << " LR[" << i << "] -> " << tab[i] << std::endl; } tab.clear(); file.close(); return EXIT_SUCCESS; } int otbVectorImageTest(int argc, char* argv[]) { if (argc < 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputAsciiFilename = argv[2]; typedef double PixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); std::ofstream file; ImageType::Pointer image = ImageType::New(); image = reader->GetOutput(); std::cout << image << std::endl; file.open(outputAsciiFilename); file << std::setprecision(15); file << image; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ImageBase/test/otbVectorImageToASImageAdaptorNew.cxx000066400000000000000000000020111301006202600276210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImageToASImageAdaptor.h" #include "otbVectorImage.h" int otbVectorImageToASImageAdaptorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorImage ImageType; typedef otb::VectorImageToASImageAdaptor FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/000077500000000000000000000000001301006202600205455ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Interpolation/CMakeLists.txt000066400000000000000000000000541301006202600233040ustar00rootroot00000000000000project(OTBInterpolation) otb_module_impl() OTB-release-5.8/Modules/Core/Interpolation/include/000077500000000000000000000000001301006202600221705ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Interpolation/include/otbBCOInterpolateImageFunction.h000066400000000000000000000202611301006202600303320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBCOInterpolateImageFunction_h #define otbBCOInterpolateImageFunction_h #include "itkInterpolateImageFunction.h" #include "vnl/vnl_vector.h" #include "otbMath.h" #include "otbVectorImage.h" namespace otb { /** \class BCOInterpolateImageFunction * \brief Interpolate an image at specified positions using bicubic interpolation. * * BCOInterpolateImageFunction interpolates image intensity at * a non-integer pixel position. This class is templated * over the input image type and the coordinate representation type * (e.g. float or double). * * This function works for 2-dimensional images. * * This function works with both Images and VectorImages. * * Parameters are the interpolation window radius and the bicubic * optimisation coefficient alpha. * Alpha is usually set to -0.5, -0.75 or -1 (-0.5 by default). * The case alpha = -0.5 (which corresponds to the cubic Hermite * spline) is known to produce the best approximation of the original * function. * * \ingroup ImageFunctions ImageInterpolators * * \ingroup OTBInterpolation */ template< class TInputImage, class TCoordRep = double > class ITK_EXPORT BCOInterpolateImageFunctionBase : public itk::InterpolateImageFunction { public: /** Standard class typedefs. */ typedef BCOInterpolateImageFunctionBase Self; typedef itk::InterpolateImageFunction Superclass; /** Run-time type information (and related methods). */ itkTypeMacro(BCOInterpolateImageFunctionBase, InterpolateImageFunction); /** OutputType typedef support. */ typedef typename Superclass::OutputType OutputType; /** InputImageType typedef support. */ typedef typename Superclass::InputImageType InputImageType; /** InputPixelType typedef support. */ typedef typename Superclass::InputPixelType InputPixelType; /** RealType typedef support. */ typedef typename Superclass::RealType RealType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Index typedef support. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::IndexValueType IndexValueType; /** Point typedef support. */ typedef typename Superclass::PointType PointType; /** ContinuousIndex typedef support. */ typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef TCoordRep ContinuousIndexValueType; /** Coeficients container type.*/ typedef vnl_vector CoefContainerType; /** Set/Get the window radius */ virtual void SetRadius(unsigned int radius); virtual unsigned int GetRadius() const; /** Set/Get the optimisation coefficient (Common values are -0.5, -0.75 or -1.0) */ virtual void SetAlpha(double alpha); virtual double GetAlpha() const; /** Evaluate the function at a ContinuousIndex position * * Returns the linearly interpolated image intensity at a * specified point position. No bounds checking is done. * The point is assume to lie within the image buffer. * * ImageFunction::IsInsideBuffer() can be used to check bounds before * calling the method. */ OutputType EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const ITK_OVERRIDE = 0; protected: BCOInterpolateImageFunctionBase() : m_Radius(2), m_WinSize(5), m_Alpha(-0.5) {}; ~BCOInterpolateImageFunctionBase() ITK_OVERRIDE {}; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Compute the BCO coefficients. */ virtual CoefContainerType EvaluateCoef( const ContinuousIndexValueType & indexValue ) const; /** Used radius for the BCO */ unsigned int m_Radius; /** Used winsize for the BCO */ unsigned int m_WinSize; /** Optimisation Coefficient */ double m_Alpha; private: BCOInterpolateImageFunctionBase( const Self& ); //purposely not implemented void operator=( const Self& ); //purposely not implemented }; template < class TInputImage, class TCoordRep = double > class ITK_EXPORT BCOInterpolateImageFunction : public otb::BCOInterpolateImageFunctionBase< TInputImage, TCoordRep > { public: /** Standard class typedefs. */ typedef BCOInterpolateImageFunction Self; typedef BCOInterpolateImageFunctionBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkTypeMacro(BCOInterpolateImageFunction, BCOInterpolateImageFunctionBase); itkNewMacro(Self); itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); typedef typename Superclass::OutputType OutputType; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputPixelType InputPixelType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::IndexValueType IndexValueType; typedef typename Superclass::PointType PointType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::CoefContainerType CoefContainerType; OutputType EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const ITK_OVERRIDE; protected: BCOInterpolateImageFunction() {}; ~BCOInterpolateImageFunction() ITK_OVERRIDE {}; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BCOInterpolateImageFunction( const Self& ); //purposely not implemented void operator=( const Self& ); //purposely not implemented }; template < typename TPixel, unsigned int VImageDimension, class TCoordRep > class ITK_EXPORT BCOInterpolateImageFunction< otb::VectorImage , TCoordRep > : public otb::BCOInterpolateImageFunctionBase< otb::VectorImage , TCoordRep > { public: /** Standard class typedefs.*/ typedef BCOInterpolateImageFunction Self; typedef BCOInterpolateImageFunctionBase < otb::VectorImage, TCoordRep > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkTypeMacro(BCOInterpolateImageFunction, BCOInterpolateImageFunctionBase); itkNewMacro(Self); itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); typedef typename Superclass::OutputType OutputType; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputPixelType InputPixelType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::IndexValueType IndexValueType; typedef typename Superclass::PointType PointType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::CoefContainerType CoefContainerType; OutputType EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const ITK_OVERRIDE; protected: BCOInterpolateImageFunction() {}; ~BCOInterpolateImageFunction() ITK_OVERRIDE {}; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BCOInterpolateImageFunction( const Self& ); //purposely not implemented void operator=( const Self& ); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBCOInterpolateImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbBCOInterpolateImageFunction.txx000066400000000000000000000170311301006202600307270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBCOInterpolateImageFunction_txx #define otbBCOInterpolateImageFunction_txx #include "otbBCOInterpolateImageFunction.h" #include "itkNumericTraits.h" namespace otb { template void BCOInterpolateImageFunctionBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; os << indent << "Alpha: " << m_Alpha << std::endl; } template void BCOInterpolateImageFunctionBase ::SetRadius(unsigned int radius) { if (radius < 2) { itkExceptionMacro(<< "Radius must be strictly greater than 1"); } else { m_Radius = radius; m_WinSize = 2*m_Radius+1; } } template unsigned int BCOInterpolateImageFunctionBase ::GetRadius() const { return m_Radius; } template void BCOInterpolateImageFunctionBase ::SetAlpha(double alpha) { m_Alpha = alpha; } template double BCOInterpolateImageFunctionBase ::GetAlpha() const { return m_Alpha; } template typename BCOInterpolateImageFunctionBase< TInputImage, TCoordRep > ::CoefContainerType BCOInterpolateImageFunctionBase ::EvaluateCoef( const ContinuousIndexValueType & indexValue ) const { // Init BCO coefficient container CoefContainerType BCOCoef(m_WinSize, 0.); double offset, dist, position, step; offset = indexValue - itk::Math::Floor(indexValue+0.5); // Compute BCO coefficients step = 4./static_cast(2*m_Radius); position = - static_cast(m_Radius) * step; double sum = 0.0; for ( unsigned int i = 0; i < m_WinSize; ++i) { // Compute the BCO coefficients according to alpha. dist = vcl_abs(position - offset*step); if( dist <= 2. ) { if (dist <= 1.) { BCOCoef[i] = (m_Alpha + 2.)*vcl_abs(dist * dist * dist) - (m_Alpha + 3.)*dist*dist + 1; } else { BCOCoef[i] = m_Alpha*vcl_abs(dist * dist * dist) - 5 *m_Alpha*dist*dist + 8*m_Alpha*vcl_abs(dist) - 4*m_Alpha; } } else { BCOCoef[i] = 0; } sum += BCOCoef[i]; position += step; } for ( unsigned int i = 0; i < m_WinSize; ++i) BCOCoef[i] = BCOCoef[i] / sum; return BCOCoef; } template void BCOInterpolateImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template typename BCOInterpolateImageFunction< TInputImage, TCoordRep > ::OutputType BCOInterpolateImageFunction ::EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const { unsigned int dim; IndexType baseIndex; IndexType neighIndex; std::vector lineRes(this->m_WinSize, 0.); RealType value = itk::NumericTraits::Zero; CoefContainerType BCOCoefX = this->EvaluateCoef(index[0]); CoefContainerType BCOCoefY = this->EvaluateCoef(index[1]); // Compute base index = closet index for( dim = 0; dim < ImageDimension; dim++ ) { baseIndex[dim] = itk::Math::Floor< IndexValueType >( index[dim]+0.5 ); } for(unsigned int i = 0; i < this->m_WinSize; ++i ) { for(unsigned int j = 0; j < this->m_WinSize; ++j ) { // get neighbor index neighIndex[0] = baseIndex[0] + i - this->m_Radius; neighIndex[1] = baseIndex[1] + j - this->m_Radius; if( neighIndex[0] > this->m_EndIndex[0] ) { neighIndex[0] = this->m_EndIndex[0]; } if( neighIndex[0] < this->m_StartIndex[0] ) { neighIndex[0] = this->m_StartIndex[0]; } if( neighIndex[1] > this->m_EndIndex[1] ) { neighIndex[1] = this->m_EndIndex[1]; } if( neighIndex[1] < this->m_StartIndex[1] ) { neighIndex[1] = this->m_StartIndex[1]; } lineRes[i] += static_cast( this->GetInputImage()->GetPixel( neighIndex ) ) * BCOCoefY[j]; } value += lineRes[i]*BCOCoefX[i]; } return ( static_cast( value ) ); } template < typename TPixel, unsigned int VImageDimension, class TCoordRep > void BCOInterpolateImageFunction< otb::VectorImage , TCoordRep > ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template < typename TPixel, unsigned int VImageDimension, class TCoordRep > typename BCOInterpolateImageFunction< otb::VectorImage , TCoordRep > ::OutputType BCOInterpolateImageFunction< otb::VectorImage , TCoordRep > ::EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const { typedef typename itk::NumericTraits::ScalarRealType ScalarRealType; unsigned int dim; unsigned int componentNumber = this->GetInputImage()->GetNumberOfComponentsPerPixel(); IndexType baseIndex; IndexType neighIndex; std::vector< std::vector > lineRes ( this->m_WinSize, std::vector( componentNumber, itk::NumericTraits::Zero) ); std::vector< ScalarRealType > value(componentNumber,itk::NumericTraits::Zero); OutputType output; output.SetSize(componentNumber); CoefContainerType BCOCoefX = this->EvaluateCoef(index[0]); CoefContainerType BCOCoefY = this->EvaluateCoef(index[1]); //Compute base index = closet index for( dim = 0; dim < ImageDimension; dim++ ) { baseIndex[dim] = itk::Math::Floor< IndexValueType >( index[dim]+0.5 ); } for(unsigned int i = 0; i < this->m_WinSize; ++i ) { for(unsigned int j = 0; j < this->m_WinSize; ++j ) { // get neighbor index neighIndex[0] = baseIndex[0] + i - this->m_Radius; neighIndex[1] = baseIndex[1] + j - this->m_Radius; if( neighIndex[0] > this->m_EndIndex[0] ) { neighIndex[0] = this->m_EndIndex[0]; } if( neighIndex[0] < this->m_StartIndex[0] ) { neighIndex[0] = this->m_StartIndex[0]; } if( neighIndex[1] > this->m_EndIndex[1] ) { neighIndex[1] = this->m_EndIndex[1]; } if( neighIndex[1] < this->m_StartIndex[1] ) { neighIndex[1] = this->m_StartIndex[1]; } const InputPixelType & pixel = this->GetInputImage()->GetPixel( neighIndex ); for( unsigned int k = 0; k #include "itkImageLinearIteratorWithIndex.h" #include "vnl/vnl_matrix.h" #include "itkImageToImageFilter.h" namespace otb { /** \class BSplineDecompositionImageFilter * \brief This class is an evolution of the itk::BSplineDecompositionImageFilter to handle * huge images with this interpolator. For more documentation, please refer to the original * class. * \sa itk::BSplineDecompositionImageFilter * \ingroup ImageFilters * * \ingroup OTBInterpolation */ template class ITK_EXPORT BSplineDecompositionImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef BSplineDecompositionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(BSplineDecompositionImageFilter, ImageToImageFilter); /** New macro for creation of through a Smart Pointer */ itkNewMacro(Self); /** Inherit input and output image types from Superclass. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointer; typedef typename Superclass::InputImageConstPointer InputImageConstPointer; typedef typename Superclass::OutputImagePointer OutputImagePointer; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Iterator typedef support */ typedef itk::ImageLinearIteratorWithIndex OutputLinearIterator; /** Get/Sets the Spline Order, supports 0th - 5th order splines. The default * is a 3rd order spline. */ void SetSplineOrder(unsigned int SplineOrder); itkGetMacro(SplineOrder, int); protected: BSplineDecompositionImageFilter(); ~BSplineDecompositionImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; /** These are needed by the smoothing spline routine. */ std::vector m_Scratch; // temp storage for processing of Coefficients typename TInputImage::SizeType m_DataLength; // Image size unsigned int m_SplineOrder; // User specified spline order (3rd or cubic is the default) double m_SplinePoles[3]; // Poles calculated for a given spline order int m_NumberOfPoles; // number of poles double m_Tolerance; // Tolerance used for determining initial causal coefficient unsigned int m_IteratorDirection; // Direction for iterator incrementing private: BSplineDecompositionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Determines the poles given the Spline Order. */ virtual void SetPoles(); /** Converts a vector of data to a vector of Spline coefficients. */ virtual bool DataToCoefficients1D(); /** Converts an N-dimension image of data to an equivalent sized image * of spline coefficients. */ void DataToCoefficientsND(); /** Determines the first coefficient for the causal filtering of the data. */ virtual void SetInitialCausalCoefficient(double z); /** Determines the first coefficient for the anti-causal filtering of the data. */ virtual void SetInitialAntiCausalCoefficient(double z); /** Used to initialize the Coefficients image before calculation. */ void CopyImageToImage(); /** Copies a vector of data from the Coefficients image to the m_Scratch vector. */ void CopyCoefficientsToScratch(OutputLinearIterator&); /** Copies a vector of data from m_Scratch to the Coefficients image. */ void CopyScratchToCoefficients(OutputLinearIterator&); }; } // namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbBSplineDecompositionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbBSplineDecompositionImageFilter.txx000066400000000000000000000236711301006202600316550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSplineDecompositionImageFilter_txx #define otbBSplineDecompositionImageFilter_txx #include "otbBSplineDecompositionImageFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkVector.h" namespace otb { /** * Constructor */ template BSplineDecompositionImageFilter ::BSplineDecompositionImageFilter() { m_SplineOrder = 0; int SplineOrder = 3; m_Tolerance = 1e-10; // Need some guidance on this one...what is reasonable? m_IteratorDirection = 0; this->SetSplineOrder(SplineOrder); } /** * Standard "PrintSelf" method */ template void BSplineDecompositionImageFilter ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Spline Order: " << m_SplineOrder << std::endl; } template bool BSplineDecompositionImageFilter ::DataToCoefficients1D() { // See Unser, 1993, Part II, Equation 2.5, // or Unser, 1999, Box 2. for an explanation. double c0 = 1.0; if (m_DataLength[m_IteratorDirection] == 1) //Required by mirror boundaries { return false; } // Compute overall gain for (int k = 0; k < m_NumberOfPoles; ++k) { // Note for cubic splines lambda = 6 c0 = c0 * (1.0 - m_SplinePoles[k]) * (1.0 - 1.0 / m_SplinePoles[k]); } // apply the gain for (unsigned int n = 0; n < m_DataLength[m_IteratorDirection]; ++n) { m_Scratch[n] *= c0; } // loop over all poles for (int k = 0; k < m_NumberOfPoles; ++k) { // causal initialization this->SetInitialCausalCoefficient(m_SplinePoles[k]); // causal recursion for (unsigned int n = 1; n < m_DataLength[m_IteratorDirection]; ++n) { m_Scratch[n] += m_SplinePoles[k] * m_Scratch[n - 1]; } // anticausal initialization this->SetInitialAntiCausalCoefficient(m_SplinePoles[k]); // anticausal recursion for (int n = m_DataLength[m_IteratorDirection] - 2; 0 <= n; n--) { m_Scratch[n] = m_SplinePoles[k] * (m_Scratch[n + 1] - m_Scratch[n]); } } return true; } template void BSplineDecompositionImageFilter ::SetSplineOrder(unsigned int SplineOrder) { if (SplineOrder == m_SplineOrder) { return; } m_SplineOrder = SplineOrder; this->SetPoles(); this->Modified(); } template void BSplineDecompositionImageFilter ::SetPoles() { /* See Unser, 1997. Part II, Table I for Pole values */ // See also, Handbook of Medical Imaging, Processing and Analysis, Ed. Isaac N. Bankman, // 2000, pg. 416. switch (m_SplineOrder) { case 3: m_NumberOfPoles = 1; m_SplinePoles[0] = vcl_sqrt(3.0) - 2.0; break; case 0: m_NumberOfPoles = 0; break; case 1: m_NumberOfPoles = 0; break; case 2: m_NumberOfPoles = 1; m_SplinePoles[0] = vcl_sqrt(8.0) - 3.0; break; case 4: m_NumberOfPoles = 2; m_SplinePoles[0] = vcl_sqrt(664.0 - vcl_sqrt(438976.0)) + vcl_sqrt(304.0) - 19.0; m_SplinePoles[1] = vcl_sqrt(664.0 + vcl_sqrt(438976.0)) - vcl_sqrt(304.0) - 19.0; break; case 5: m_NumberOfPoles = 2; m_SplinePoles[0] = vcl_sqrt(135.0 / 2.0 - vcl_sqrt(17745.0 / 4.0)) + vcl_sqrt(105.0 / 4.0) - 13.0 / 2.0; m_SplinePoles[1] = vcl_sqrt(135.0 / 2.0 + vcl_sqrt(17745.0 / 4.0)) - vcl_sqrt(105.0 / 4.0) - 13.0 / 2.0; break; default: // SplineOrder not implemented yet. itk::ExceptionObject err(__FILE__, __LINE__); err.SetLocation(ITK_LOCATION); err.SetDescription("SplineOrder must be between 0 and 5. Requested spline order has not been implemented yet."); throw err; break; } } template void BSplineDecompositionImageFilter ::SetInitialCausalCoefficient(double z) { /* beginning InitialCausalCoefficient */ /* See Unser, 1999, Box 2 for explanation */ double sum, zn, z2n, iz; unsigned long horizon; /* this initialization corresponds to mirror boundaries */ horizon = m_DataLength[m_IteratorDirection]; zn = z; if (m_Tolerance > 0.0) { horizon = (long) vcl_ceil(log(m_Tolerance) / vcl_log(fabs(z))); } if (horizon < m_DataLength[m_IteratorDirection]) { /* accelerated loop */ sum = m_Scratch[0]; // verify this for (unsigned int n = 1; n < horizon; ++n) { sum += zn * m_Scratch[n]; zn *= z; } m_Scratch[0] = sum; } else { /* full loop */ iz = 1.0 / z; z2n = vcl_pow(z, (double) (m_DataLength[m_IteratorDirection] - 1L)); sum = m_Scratch[0] + z2n * m_Scratch[m_DataLength[m_IteratorDirection] - 1L]; z2n *= z2n * iz; for (unsigned int n = 1; n <= (m_DataLength[m_IteratorDirection] - 2); ++n) { sum += (zn + z2n) * m_Scratch[n]; zn *= z; z2n *= iz; } m_Scratch[0] = sum / (1.0 - zn * zn); } } template void BSplineDecompositionImageFilter ::SetInitialAntiCausalCoefficient(double z) { // this initialization corresponds to mirror boundaries /* See Unser, 1999, Box 2 for explanation */ // Also see erratum at http://bigwww.epfl.ch/publications/unser9902.html m_Scratch[m_DataLength[m_IteratorDirection] - 1] = (z / (z * z - 1.0)) * (z * m_Scratch[m_DataLength[m_IteratorDirection] - 2] + m_Scratch[m_DataLength[m_IteratorDirection] - 1]); } template void BSplineDecompositionImageFilter ::DataToCoefficientsND() { OutputImagePointer output = this->GetOutput(); itk::Size size = output->GetBufferedRegion().GetSize(); unsigned int count = output->GetBufferedRegion().GetNumberOfPixels() / size[0] * ImageDimension; itk::ProgressReporter progress(this, 0, count, 10); // Initialize coeffient array this->CopyImageToImage(); // Coefficients are initialized to the input data for (unsigned int n = 0; n < ImageDimension; ++n) { m_IteratorDirection = n; // Loop through each dimension // Initialize iterators OutputLinearIterator CIterator(output, output->GetBufferedRegion()); CIterator.SetDirection(m_IteratorDirection); // For each data vector while (!CIterator.IsAtEnd()) { // Copy coefficients to scratch this->CopyCoefficientsToScratch(CIterator); // Perform 1D BSpline calculations this->DataToCoefficients1D(); // Copy scratch back to coefficients. // Brings us back to the end of the line we were working on. CIterator.GoToBeginOfLine(); this->CopyScratchToCoefficients(CIterator); // m_Scratch = m_Image; CIterator.NextLine(); progress.CompletedPixel(); } } } /** * Copy the input image into the output image */ template void BSplineDecompositionImageFilter ::CopyImageToImage() { typedef itk::ImageRegionConstIteratorWithIndex InputIterator; typedef itk::ImageRegionIterator OutputIterator; typedef typename TOutputImage::PixelType OutputPixelType; InputIterator inIt(this->GetInput(), this->GetInput()->GetBufferedRegion()); OutputIterator outIt(this->GetOutput(), this->GetOutput()->GetBufferedRegion()); inIt.GoToBegin(); outIt.GoToBegin(); while (!outIt.IsAtEnd()) { outIt.Set(static_cast(inIt.Get())); ++inIt; ++outIt; } } /** * Copy the scratch to one line of the output image */ template void BSplineDecompositionImageFilter ::CopyScratchToCoefficients(OutputLinearIterator& Iter) { typedef typename TOutputImage::PixelType OutputPixelType; unsigned long j = 0; while (!Iter.IsAtEndOfLine()) { Iter.Set(static_cast(m_Scratch[j])); ++Iter; ++j; } } /** * Copy one line of the output image to the scratch */ template void BSplineDecompositionImageFilter ::CopyCoefficientsToScratch(OutputLinearIterator& Iter) { unsigned long j = 0; while (!Iter.IsAtEndOfLine()) { m_Scratch[j] = static_cast(Iter.Get()); ++Iter; ++j; } } /** * Generate data */ template void BSplineDecompositionImageFilter ::GenerateData() { // Allocate scratch memory InputImageConstPointer inputPtr = this->GetInput(); m_DataLength = inputPtr->GetBufferedRegion().GetSize(); unsigned long maxLength = 0; for (unsigned int n = 0; n < ImageDimension; ++n) { if (m_DataLength[n] > maxLength) { maxLength = m_DataLength[n]; } } m_Scratch.resize(maxLength); // Allocate memory for output image OutputImagePointer outputPtr = this->GetOutput(); outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); // Calculate actual output this->DataToCoefficientsND(); // Clean up m_Scratch.clear(); } } // namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbBSplineInterpolateImageFunction.h000066400000000000000000000162631301006202600312720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSplineInterpolateImageFunction_h #define otbBSplineInterpolateImageFunction_h #include #include "itkInterpolateImageFunction.h" #include "vnl/vnl_matrix.h" #include "otbBSplineDecompositionImageFilter.h" #include "itkConceptChecking.h" #include "itkCovariantVector.h" namespace otb { /** \class BSplineInterpolateImageFunction * \brief This class is an evolution of the itk::BSplineInterpolateImageFunction to handle * huge images with this interpolator. For more documentation, please refer to the original * class. * \sa itk::BSplineInterpolateImageFunction * \sa itk::BSplineDecompositionImageFilter * \sa otb::BSplineDecompositionImageFilter * * \ingroup ImageFunctions * * \ingroup OTBInterpolation */ template < class TImageType, class TCoordRep = double, class TCoefficientType = double> class ITK_EXPORT BSplineInterpolateImageFunction : public itk::InterpolateImageFunction { public: /** Standard class typedefs. */ typedef BSplineInterpolateImageFunction Self; typedef itk::InterpolateImageFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(BSplineInterpolateImageFunction, InterpolateImageFunction); /** New macro for creation of through a Smart Pointer */ itkNewMacro(Self); /** OutputType typedef support. */ typedef typename Superclass::OutputType OutputType; /** InputImageType typedef support. */ typedef typename Superclass::InputImageType InputImageType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Index typedef support. */ typedef typename Superclass::IndexType IndexType; /** Region typedef support */ typedef typename InputImageType::RegionType RegionType; /** ContinuousIndex typedef support. */ typedef typename Superclass::ContinuousIndexType ContinuousIndexType; /** PointType typedef support */ typedef typename Superclass::PointType PointType; /** Iterator typedef support */ typedef itk::ImageLinearIteratorWithIndex Iterator; /** Internal Coefficient typedef support */ typedef TCoefficientType CoefficientDataType; typedef itk::Image CoefficientImageType; /** Define filter for calculating the BSpline coefficients */ typedef otb::BSplineDecompositionImageFilter CoefficientFilter; typedef typename CoefficientFilter::Pointer CoefficientFilterPointer; /** Evaluate the function at a ContinuousIndex position. * * Returns the B-Spline interpolated image intensity at a * specified point position. No bounds checking is done. * The point is assume to lie within the image buffer. * * ImageFunction::IsInsideBuffer() can be used to check bounds before * calling the method. */ OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& index) const ITK_OVERRIDE; /** Derivative typedef support */ typedef itk::CovariantVector CovariantVectorType; CovariantVectorType EvaluateDerivative(const PointType& point) const { ContinuousIndexType index; this->GetInputImage()->TransformPhysicalPointToContinuousIndex(point, index); return (this->EvaluateDerivativeAtContinuousIndex(index)); } CovariantVectorType EvaluateDerivativeAtContinuousIndex( const ContinuousIndexType& x) const; /** Get/Sets the Spline Order, supports 0th - 5th order splines. The default * is a 3rd order spline. */ void SetSplineOrder(unsigned int SplineOrder); itkGetMacro(SplineOrder, int); /** Set the input image. This must be set by the user. */ void SetInputImage(const TImageType * inputData) ITK_OVERRIDE; /** Update coefficients filter. Coefficient filter are computed over the buffered region of the input image. */ virtual void UpdateCoefficientsFilter(void); protected: BSplineInterpolateImageFunction(); ~BSplineInterpolateImageFunction() ITK_OVERRIDE {} void operator =(const Self&); //purposely not implemented void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; // These are needed by the smoothing spline routine. std::vector m_Scratch; // temp storage for processing of Coefficients typename TImageType::SizeType m_DataLength; // Image size unsigned int m_SplineOrder; // User specified spline order (3rd or cubic is the default) typename CoefficientImageType::ConstPointer m_Coefficients; // Spline coefficients private: BSplineInterpolateImageFunction(const Self &); //purposely not implemented /** Determines the weights for interpolation of the value x */ void SetInterpolationWeights(const ContinuousIndexType& x, const vnl_matrix& EvaluateIndex, vnl_matrix& weights, unsigned int splineOrder) const; /** Determines the weights for the derivative portion of the value x */ void SetDerivativeWeights(const ContinuousIndexType& x, const vnl_matrix& EvaluateIndex, vnl_matrix& weights, unsigned int splineOrder) const; /** Precomputation for converting the 1D index of the interpolation neighborhood * to an N-dimensional index. */ void GeneratePointsToIndex(); /** Determines the indices to use give the splines region of support */ void DetermineRegionOfSupport(vnl_matrix& evaluateIndex, const ContinuousIndexType& x, unsigned int splineOrder) const; /** Set the indices in evaluateIndex at the boundaries based on mirror * boundary conditions. */ void ApplyMirrorBoundaryConditions(vnl_matrix& evaluateIndex, unsigned int splineOrder) const; Iterator m_CIterator; // Iterator for traversing spline coefficients. unsigned long m_MaxNumberInterpolationPoints; // number of neighborhood points used for interpolation std::vector m_PointsToIndex; // Preallocation of interpolation neighborhood indices CoefficientFilterPointer m_CoefficientFilter; RegionType m_CurrentBufferedRegion; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBSplineInterpolateImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbBSplineInterpolateImageFunction.txx000066400000000000000000000447331301006202600316710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSplineInterpolateImageFunction_txx #define otbBSplineInterpolateImageFunction_txx #include "otbBSplineInterpolateImageFunction.h" #include "itkImageLinearIteratorWithIndex.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" #include "itkVector.h" #include "itkMatrix.h" namespace otb { /** * Constructor */ template BSplineInterpolateImageFunction ::BSplineInterpolateImageFunction() { m_SplineOrder = 0; unsigned int SplineOrder = 3; m_CoefficientFilter = CoefficientFilter::New(); // ***TODO: Should we store coefficients in a variable or retrieve from filter? m_Coefficients = CoefficientImageType::New(); this->SetSplineOrder(SplineOrder); } /** * Standard "PrintSelf" method */ template void BSplineInterpolateImageFunction ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Spline Order: " << m_SplineOrder << std::endl; } template void BSplineInterpolateImageFunction ::UpdateCoefficientsFilter(void) { m_CoefficientFilter->GetOutput()->UpdateOutputInformation(); m_CoefficientFilter->GetOutput()->SetRequestedRegion(m_CoefficientFilter->GetInput()->GetBufferedRegion()); m_CoefficientFilter->GetOutput()->PropagateRequestedRegion(); m_CoefficientFilter->GetOutput()->UpdateOutputData(); m_Coefficients = m_CoefficientFilter->GetOutput(); m_CurrentBufferedRegion = m_CoefficientFilter->GetInput()->GetBufferedRegion(); } template void BSplineInterpolateImageFunction ::SetInputImage(const TImageType * inputData) { if (inputData) { m_CoefficientFilter->SetInput(inputData); // the Coefficient Filter requires that the spline order and the input data be set. // TODO: We need to ensure that this is only run once and only after both input and // spline order have been set. Should we force an update after the // splineOrder has been set also? UpdateCoefficientsFilter(); // Call the Superclass implementation after, in case the filter // pulls in more of the input image Superclass::SetInputImage(inputData); m_DataLength = inputData->GetBufferedRegion().GetSize(); } else { m_Coefficients = ITK_NULLPTR; } } template void BSplineInterpolateImageFunction ::SetSplineOrder(unsigned int SplineOrder) { if (SplineOrder == m_SplineOrder) { return; } m_SplineOrder = SplineOrder; m_CoefficientFilter->SetSplineOrder(SplineOrder); //this->SetPoles(); m_MaxNumberInterpolationPoints = 1; for (unsigned int n = 0; n < ImageDimension; ++n) { m_MaxNumberInterpolationPoints *= (m_SplineOrder + 1); } this->GeneratePointsToIndex(); } template typename BSplineInterpolateImageFunction ::OutputType BSplineInterpolateImageFunction ::EvaluateAtContinuousIndex(const ContinuousIndexType& x) const { //UpdateCoefficientsFilter(); vnl_matrix EvaluateIndex(ImageDimension, (m_SplineOrder + 1)); // compute the interpolation indexes this->DetermineRegionOfSupport(EvaluateIndex, x, m_SplineOrder); // Determine weights vnl_matrix weights(ImageDimension, (m_SplineOrder + 1)); SetInterpolationWeights(x, EvaluateIndex, weights, m_SplineOrder); //std::cout<<"EvaluateIndex: "<ApplyMirrorBoundaryConditions(EvaluateIndex, m_SplineOrder); // perform interpolation double interpolated = 0.0; IndexType coefficientIndex; // Step through eachpoint in the N-dimensional interpolation cube. for (unsigned int p = 0; p < m_MaxNumberInterpolationPoints; ++p) { // translate each step into the N-dimensional index. // IndexType pointIndex = PointToIndex( p ); double w = 1.0; for (unsigned int n = 0; n < ImageDimension; ++n) { w *= weights[n][m_PointsToIndex[p][n]]; coefficientIndex[n] = EvaluateIndex[n][m_PointsToIndex[p][n]]; // Build up ND index for coefficients. //std::cout<<"From inside: "<GetPixel(coefficientIndex); } /* double interpolated = 0.0; IndexType coefficientIndex; // Step through eachpoint in the N-dimensional interpolation cube. for (unsigned int sp = 0; sp <= m_SplineOrder; ++sp) { for (unsigned int sp1=0; sp1 <= m_SplineOrder; sp1++) { double w = 1.0; for (unsigned int n1 = 0; n1 < ImageDimension; n1++ ) { w *= weights[n1][ sp1 ]; coefficientIndex[n1] = EvaluateIndex[n1][sp]; // Build up ND index for coefficients. } interpolated += w * m_Coefficients->GetPixel(coefficientIndex); } } */ return (interpolated); } template typename BSplineInterpolateImageFunction ::CovariantVectorType BSplineInterpolateImageFunction ::EvaluateDerivativeAtContinuousIndex(const ContinuousIndexType& x) const { UpdateCoefficientsFilter(); vnl_matrix EvaluateIndex(ImageDimension, (m_SplineOrder + 1)); // compute the interpolation indexes // TODO: Do we need to revisit region of support for the derivatives? this->DetermineRegionOfSupport(EvaluateIndex, x, m_SplineOrder); // Determine weights vnl_matrix weights(ImageDimension, (m_SplineOrder + 1)); SetInterpolationWeights(x, EvaluateIndex, weights, m_SplineOrder); vnl_matrix weightsDerivative(ImageDimension, (m_SplineOrder + 1)); SetDerivativeWeights(x, EvaluateIndex, weightsDerivative, (m_SplineOrder)); // Modify EvaluateIndex at the boundaries using mirror boundary conditions this->ApplyMirrorBoundaryConditions(EvaluateIndex, m_SplineOrder); // Calculate derivative CovariantVectorType derivativeValue; double tempValue; IndexType coefficientIndex; for (unsigned int n = 0; n < ImageDimension; ++n) { derivativeValue[n] = 0.0; for (unsigned int p = 0; p < m_MaxNumberInterpolationPoints; ++p) { tempValue = 1.0; for (unsigned int n1 = 0; n1 < ImageDimension; n1++) { //coefficientIndex[n1] = EvaluateIndex[n1][sp]; coefficientIndex[n1] = EvaluateIndex[n1][m_PointsToIndex[p][n1]]; if (n1 == n) { //w *= weights[n][ m_PointsToIndex[p][n] ]; tempValue *= weightsDerivative[n1][m_PointsToIndex[p][n1]]; } else { tempValue *= weights[n1][m_PointsToIndex[p][n1]]; } } derivativeValue[n] += m_Coefficients->GetPixel(coefficientIndex) * tempValue; } derivativeValue[n] /= this->GetInputImage()->GetSpacing()[n]; // take spacing into account } return (derivativeValue); } template void BSplineInterpolateImageFunction ::SetInterpolationWeights(const ContinuousIndexType& x, const vnl_matrix& EvaluateIndex, vnl_matrix& weights, unsigned int splineOrder) const { // For speed improvements we could make each case a separate function and use // function pointers to reference the correct weight order. // Left as is for now for readability. double w, w2, w4, t, t0, t1; switch (splineOrder) { case 3: for (unsigned int n = 0; n < ImageDimension; ++n) { w = x[n] - (double) EvaluateIndex[n][1]; weights[n][3] = (1.0 / 6.0) * w * w * w; weights[n][0] = (1.0 / 6.0) + 0.5 * w * (w - 1.0) - weights[n][3]; weights[n][2] = w + weights[n][0] - 2.0 * weights[n][3]; weights[n][1] = 1.0 - weights[n][0] - weights[n][2] - weights[n][3]; } break; case 0: for (unsigned int n = 0; n < ImageDimension; ++n) { weights[n][0] = 1; // implements nearest neighbor } break; case 1: for (unsigned int n = 0; n < ImageDimension; ++n) { w = x[n] - (double) EvaluateIndex[n][0]; weights[n][1] = w; weights[n][0] = 1.0 - w; } break; case 2: for (unsigned int n = 0; n < ImageDimension; ++n) { /* x */ w = x[n] - (double) EvaluateIndex[n][1]; weights[n][1] = 0.75 - w * w; weights[n][2] = 0.5 * (w - weights[n][1] + 1.0); weights[n][0] = 1.0 - weights[n][1] - weights[n][2]; } break; case 4: for (unsigned int n = 0; n < ImageDimension; ++n) { /* x */ w = x[n] - (double) EvaluateIndex[n][2]; w2 = w * w; t = (1.0 / 6.0) * w2; weights[n][0] = 0.5 - w; weights[n][0] *= weights[n][0]; weights[n][0] *= (1.0 / 24.0) * weights[n][0]; t0 = w * (t - 11.0 / 24.0); t1 = 19.0 / 96.0 + w2 * (0.25 - t); weights[n][1] = t1 + t0; weights[n][3] = t1 - t0; weights[n][4] = weights[n][0] + t0 + 0.5 * w; weights[n][2] = 1.0 - weights[n][0] - weights[n][1] - weights[n][3] - weights[n][4]; } break; case 5: for (unsigned int n = 0; n < ImageDimension; ++n) { /* x */ w = x[n] - (double) EvaluateIndex[n][2]; w2 = w * w; weights[n][5] = (1.0 / 120.0) * w * w2 * w2; w2 -= w; w4 = w2 * w2; w -= 0.5; t = w2 * (w2 - 3.0); weights[n][0] = (1.0 / 24.0) * (1.0 / 5.0 + w2 + w4) - weights[n][5]; t0 = (1.0 / 24.0) * (w2 * (w2 - 5.0) + 46.0 / 5.0); t1 = (-1.0 / 12.0) * w * (t + 4.0); weights[n][2] = t0 + t1; weights[n][3] = t0 - t1; t0 = (1.0 / 16.0) * (9.0 / 5.0 - t); t1 = (1.0 / 24.0) * w * (w4 - w2 - 5.0); weights[n][1] = t0 + t1; weights[n][4] = t0 - t1; } break; default: // SplineOrder not implemented yet. itk::ExceptionObject err(__FILE__, __LINE__); err.SetLocation(ITK_LOCATION); err.SetDescription("SplineOrder must be between 0 and 5. Requested spline order has not been implemented yet."); throw err; break; } } template void BSplineInterpolateImageFunction ::SetDerivativeWeights(const ContinuousIndexType& x, const vnl_matrix& EvaluateIndex, vnl_matrix& weights, unsigned int splineOrder) const { // For speed improvements we could make each case a separate function and use // function pointers to reference the correct weight order. // Another possibility would be to loop inside the case statement (reducing the number // of switch statement executions to one per routine call. // Left as is for now for readability. double w, w1, w2, w3, w4, w5, t, t0, t1, t2; int derivativeSplineOrder = (int) splineOrder - 1; switch (derivativeSplineOrder) { // Calculates B(splineOrder) ( (x + 1/2) - xi) - B(splineOrder -1) ( (x - 1/2) - xi) case -1: // Why would we want to do this? for (unsigned int n = 0; n < ImageDimension; ++n) { weights[n][0] = 0.0; } break; case 0: for (unsigned int n = 0; n < ImageDimension; ++n) { weights[n][0] = -1.0; weights[n][1] = 1.0; } break; case 1: for (unsigned int n = 0; n < ImageDimension; ++n) { w = x[n] + 0.5 - (double) EvaluateIndex[n][1]; // w2 = w; w1 = 1.0 - w; weights[n][0] = 0.0 - w1; weights[n][1] = w1 - w; weights[n][2] = w; } break; case 2: for (unsigned int n = 0; n < ImageDimension; ++n) { w = x[n] + .5 - (double) EvaluateIndex[n][2]; w2 = 0.75 - w * w; w3 = 0.5 * (w - w2 + 1.0); w1 = 1.0 - w2 - w3; weights[n][0] = 0.0 - w1; weights[n][1] = w1 - w2; weights[n][2] = w2 - w3; weights[n][3] = w3; } break; case 3: for (unsigned int n = 0; n < ImageDimension; ++n) { w = x[n] + 0.5 - (double) EvaluateIndex[n][2]; w4 = (1.0 / 6.0) * w * w * w; w1 = (1.0 / 6.0) + 0.5 * w * (w - 1.0) - w4; w3 = w + w1 - 2.0 * w4; w2 = 1.0 - w1 - w3 - w4; weights[n][0] = 0.0 - w1; weights[n][1] = w1 - w2; weights[n][2] = w2 - w3; weights[n][3] = w3 - w4; weights[n][4] = w4; } break; case 4: for (unsigned int n = 0; n < ImageDimension; ++n) { w = x[n] + .5 - (double) EvaluateIndex[n][3]; t2 = w * w; t = (1.0 / 6.0) * t2; w1 = 0.5 - w; w1 *= w1; w1 *= (1.0 / 24.0) * w1; t0 = w * (t - 11.0 / 24.0); t1 = 19.0 / 96.0 + t2 * (0.25 - t); w2 = t1 + t0; w4 = t1 - t0; w5 = w1 + t0 + 0.5 * w; w3 = 1.0 - w1 - w2 - w4 - w5; weights[n][0] = 0.0 - w1; weights[n][1] = w1 - w2; weights[n][2] = w2 - w3; weights[n][3] = w3 - w4; weights[n][4] = w4 - w5; weights[n][5] = w5; } break; default: // SplineOrder not implemented yet. itk::ExceptionObject err(__FILE__, __LINE__); err.SetLocation(ITK_LOCATION); err.SetDescription( "SplineOrder (for derivatives) must be between 1 and 5. Requested spline order has not been implemented yet."); throw err; break; } } // Generates m_PointsToIndex; template void BSplineInterpolateImageFunction ::GeneratePointsToIndex() { // m_PointsToIndex is used to convert a sequential location to an N-dimension // index vector. This is precomputed to save time during the interpolation routine. m_PointsToIndex.resize(m_MaxNumberInterpolationPoints); for (unsigned int p = 0; p < m_MaxNumberInterpolationPoints; ++p) { int pp = p; unsigned long indexFactor[ImageDimension]; indexFactor[0] = 1; for (int j = 1; j < static_cast(ImageDimension); ++j) { indexFactor[j] = indexFactor[j - 1] * (m_SplineOrder + 1); } for (int j = (static_cast(ImageDimension) - 1); j >= 0; j--) { m_PointsToIndex[p][j] = pp / indexFactor[j]; pp = pp % indexFactor[j]; } } } template void BSplineInterpolateImageFunction ::DetermineRegionOfSupport(vnl_matrix& evaluateIndex, const ContinuousIndexType& x, unsigned int splineOrder) const { long indx; // compute the interpolation indexes for (unsigned int n = 0; n < ImageDimension; ++n) { if (splineOrder & 1) // Use this index calculation for odd splineOrder { indx = (long) vcl_floor((float) x[n]) - splineOrder / 2; //std::cout<<"x: "< void BSplineInterpolateImageFunction ::ApplyMirrorBoundaryConditions(vnl_matrix& evaluateIndex, unsigned int splineOrder) const { for (unsigned int n = 0; n < ImageDimension; ++n) { long dataLength = m_DataLength[n]; long dataOffset = m_CurrentBufferedRegion.GetIndex()[n]; // apply the mirror boundary conditions // TODO: We could implement other boundary options beside mirror if (m_DataLength[n] == 1) { for (unsigned int k = 0; k <= splineOrder; ++k) { evaluateIndex[n][k] = 0; } } else { for (unsigned int k = 0; k <= splineOrder; ++k) { // btw - Think about this couldn't this be replaced with a more elagent modulus method? evaluateIndex[n][k] = (evaluateIndex[n][k] < dataOffset) ? (dataOffset + (dataOffset - evaluateIndex[n][k]) % dataLength) : (evaluateIndex[n][k]); if ((long) dataLength + dataOffset <= evaluateIndex[n][k]) { evaluateIndex[n][k] = dataOffset + dataLength - (evaluateIndex[n][k] - dataOffset - dataLength) % dataLength; } } } } } } // namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbGenericInterpolateImageFunction.h000066400000000000000000000132731301006202600313100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericInterpolateImageFunction_h #define otbGenericInterpolateImageFunction_h #include "itkInterpolateImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkConstantBoundaryCondition.h" namespace otb { /** \class GenericInterpolateImageFunction * \brief Generic interpolation of an otb::Image. * * GenericInterpolateImageFunction interpolates image intensity according to a * resampling profil. * * The Initialize() method need to be call to create the filter. * * \ingroup ImageFunctions ImageInterpolators * * \ingroup OTBInterpolation */ template , class TCoordRep = double> class ITK_EXPORT GenericInterpolateImageFunction : public itk::InterpolateImageFunction { public: /** Standard class typedefs. */ typedef GenericInterpolateImageFunction Self; typedef itk::InterpolateImageFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(GenericInterpolateImageFunction, itk::InterpolateImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::OutputType OutputType; typedef typename Superclass::InputImageType InputImageType; /** Dimension underlying input image. */ //itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Index and typedef support. */ typedef typename Superclass::IndexType IndexType; typedef typename InputImageType::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef TFunction FunctionType; typedef itk::ConstNeighborhoodIterator IteratorType; /** ContinuousIndex typedef support. */ typedef typename Superclass::ContinuousIndexType ContinuousIndexType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Evaluate the function at a ContinuousIndex position * * Returns the interpolated image intensity at a * specified point position. No bounds checking is done. * The point is assume to lie within the image buffer. * * ImageFunction::IsInsideBuffer() can be used to check bounds before * calling the method. */ OutputType EvaluateAtContinuousIndex(const ContinuousIndexType& index) const ITK_OVERRIDE; /** Set/Get the window radius*/ virtual void SetRadius(unsigned int rad); virtual unsigned int GetRadius() const { return m_Function.GetRadius(); } //unsigned int GetRadius() { return this->GetFunction().GetRadius(); }; /** Set/Get the window radius*/ // Don't have to be used here, just declared for the inheritance classes. //virtual void SetWindowSize(unsigned int win){ m_WindowSize = win; }; /** Get the functor list */ virtual FunctionType& GetFunction(void) { return m_Function; } /** Initialize tables: need to be call explicitly */ virtual void Initialize(); /** Weights normalization accessors*/ itkSetMacro(NormalizeWeight, bool); itkGetMacro(NormalizeWeight, bool); protected: GenericInterpolateImageFunction(); ~GenericInterpolateImageFunction() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Call the superclass implementation and set the TablesHaveBeenGenerated * flag to false */ void Modified(void) const ITK_OVERRIDE; /** Delete tables.*/ virtual void ResetOffsetTable(); /** Initialize used tables*/ virtual void InitializeTables(); /** Fill the weight offset table*/ virtual void FillWeightOffsetTable(); private: GenericInterpolateImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Store the window radius. */ //unsigned int m_Radius; // Constant to store twice the radius unsigned int m_WindowSize; /** Used function */ FunctionType m_Function; /** Store the image dimension.*/ unsigned int m_ImageDimension; /** These members are declared mutable so that they can be regenerated seamlessly inside the EvaluateAtContinuousIndex method if they need to */ /** Size of the offset table */ mutable unsigned int m_OffsetTableSize; /** The offset array, used to keep a list of relevant * offsets in the neihborhoodIterator */ mutable unsigned int *m_OffsetTable; /** Index into the weights array for each offset */ mutable unsigned int **m_WeightOffsetTable; /** True if internal statistics have been generated */ mutable bool m_TablesHaveBeenGenerated; /** Weights normalization */ bool m_NormalizeWeight; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbGenericInterpolateImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbGenericInterpolateImageFunction.txx000066400000000000000000000232701301006202600317020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericInterpolateImageFunction_txx #define otbGenericInterpolateImageFunction_txx #include "otbGenericInterpolateImageFunction.h" #include "vnl/vnl_math.h" namespace otb { /** Constructor */ template GenericInterpolateImageFunction ::GenericInterpolateImageFunction() { m_WindowSize = 1; this->SetRadius(1); m_OffsetTable = ITK_NULLPTR; m_WeightOffsetTable = ITK_NULLPTR; m_TablesHaveBeenGenerated = false; m_NormalizeWeight = false; } /** Destructor */ template GenericInterpolateImageFunction ::~GenericInterpolateImageFunction() { this->ResetOffsetTable(); } /** Delete every tables. */ template void GenericInterpolateImageFunction ::ResetOffsetTable() { // Clear the offset table if (m_OffsetTable != ITK_NULLPTR) { delete[] m_OffsetTable; m_OffsetTable = ITK_NULLPTR; } // Clear the weights tales if (m_WeightOffsetTable != ITK_NULLPTR) { for (unsigned int i = 0; i < m_OffsetTableSize; ++i) { delete[] m_WeightOffsetTable[i]; } delete[] m_WeightOffsetTable; m_WeightOffsetTable = ITK_NULLPTR; } } template void GenericInterpolateImageFunction ::SetRadius(unsigned int rad) { //m_Radius = rad; this->GetFunction().SetRadius(rad); m_WindowSize = rad << 1; this->Modified(); } template void GenericInterpolateImageFunction ::Modified() const { Superclass::Modified(); m_TablesHaveBeenGenerated = false; } /** Initialize used tables*/ template void GenericInterpolateImageFunction ::InitializeTables() { // Compute the offset table size m_OffsetTableSize = 1; for (unsigned dim = 0; dim < ImageDimension; ++dim) { m_OffsetTableSize *= m_WindowSize; } // Allocate the offset table m_OffsetTable = new unsigned int[m_OffsetTableSize]; // Allocate the weights tables m_WeightOffsetTable = new unsigned int *[m_OffsetTableSize]; for (unsigned int i = 0; i < m_OffsetTableSize; ++i) { m_WeightOffsetTable[i] = new unsigned int[ImageDimension]; } } /** Fill the weight offset table*/ template void GenericInterpolateImageFunction ::FillWeightOffsetTable() { // Initialize the neighborhood SizeType radius; radius.Fill(this->GetRadius()); if (this->GetInputImage() != ITK_NULLPTR) { IteratorType it = IteratorType(radius, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Compute the offset tables (we ignore all the zero indices // in the neighborhood) unsigned int iOffset = 0; int empty = static_cast(this->GetRadius()); for (unsigned int iPos = 0; iPos < it.Size(); ++iPos) { // Get the offset (index) typename IteratorType::OffsetType off = it.GetOffset(iPos); // Check if the offset has zero weights bool nonzero = true; for (unsigned int dim = 0; dim < ImageDimension; ++dim) { if (off[dim] == -empty) { nonzero = false; break; } } // Only use offsets with non-zero indices if (nonzero) { // Set the offset index m_OffsetTable[iOffset] = iPos; // Set the weight table indices for (unsigned int dim = 0; dim < ImageDimension; ++dim) { m_WeightOffsetTable[iOffset][dim] = off[dim] + this->GetRadius() - 1; } // Increment the index iOffset++; } } } else { itkExceptionMacro(<< "An input has to be set"); } } /** Initialize tables: need to be call explicitly */ template void GenericInterpolateImageFunction ::Initialize() { // Delete existing tables this->ResetOffsetTable(); // Tables initialization this->InitializeTables(); // fill the weight table this->FillWeightOffsetTable(); m_TablesHaveBeenGenerated = true; } /** Evaluate at image index position */ template typename GenericInterpolateImageFunction::OutputType GenericInterpolateImageFunction ::EvaluateAtContinuousIndex(const ContinuousIndexType& index) const { if (!m_TablesHaveBeenGenerated) { itkExceptionMacro(<< "The Interpolation functor need to be explicitly intanciated with the method Initialize()"); } //unsigned int dim; IndexType baseIndex; double distance[ImageDimension]; // Compute the integer index based on the continuous one by // 'flooring' the index for (unsigned int dim = 0; dim < ImageDimension; ++dim) { // The following "if" block is equivalent to the following line without // having to call floor. // baseIndex[dim] = (long) vcl_floor(index[dim] ); if (index[dim] >= 0.0) { baseIndex[dim] = (long) index[dim]; } else { long tIndex = (long) index[dim]; if (double(tIndex) != index[dim]) { tIndex--; } baseIndex[dim] = tIndex; } distance[dim] = index[dim] - double(baseIndex[dim]); } // Position the neighborhood at the index of interest SizeType radius; radius.Fill(this->GetRadius()); IteratorType nit = IteratorType(radius, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); nit.SetLocation(baseIndex); const unsigned int twiceRadius = static_cast(2 * this->GetRadius()); /* double xWeight[ImageDimension][ twiceRadius]; */ std::vector > xWeight; xWeight.resize(ImageDimension); for (unsigned int cpt = 0; cpt < xWeight.size(); ++cpt) { xWeight[cpt].resize(twiceRadius); } for (unsigned int dim = 0; dim < ImageDimension; ++dim) { // x is the offset, hence the parameter of the kernel double x = distance[dim] + this->GetRadius(); // If distance is zero, i.e. the index falls precisely on the // pixel boundary, the weights form a delta function. /* if(distance[dim] == 0.0) { for( unsigned int i = 0; i < m_WindowSize; ++i) { xWeight[dim][i] = static_cast(i) == (static_cast(this->GetRadius()) - 1) ? 1. : 0.; } } else { */ // i is the relative offset in dimension dim. for (unsigned int i = 0; i < m_WindowSize; ++i) { // Increment the offset, taking it through the range // (dist + rad - 1, ..., dist - rad), i.e. all x // such that vcl_abs(x) <= rad x -= 1.0; // Compute the weight for this m xWeight[dim][i] = m_Function(x); } //} } if (m_NormalizeWeight == true) { for (unsigned int dim = 0; dim < ImageDimension; ++dim) { double sum = 0.; // Compute the weights sum for (unsigned int i = 0; i < m_WindowSize; ++i) { sum += xWeight[dim][i]; } if (sum != 1.) { // Normalize the weights for (unsigned int i = 0; i < m_WindowSize; ++i) { xWeight[dim][i] = xWeight[dim][i] / sum; } } } } // Iterate over the neighborhood, taking the correct set // of weights in each dimension RealType xPixelValue; itk::NumericTraits::SetLength(xPixelValue, this->GetInputImage()->GetNumberOfComponentsPerPixel()); xPixelValue=static_cast(0.0); for (unsigned int j = 0; j < m_OffsetTableSize; ++j) { // Get the offset for this neighbor unsigned int off = m_OffsetTable[j]; // Get the intensity value at the pixel RealType xVal = nit.GetPixel(off); // Multiply the intensity by each of the weights. Gotta hope // that the compiler will unwrap this loop and pipeline this! for (unsigned int dim = 0; dim < ImageDimension; ++dim) { xVal *= xWeight[dim][m_WeightOffsetTable[j][dim]]; } // Increment the pixel value xPixelValue += xVal; } // Return the interpolated value return static_cast(xPixelValue); } template void GenericInterpolateImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } //namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbProlateInterpolateImageFunction.h000066400000000000000000000410531301006202600313370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProlateInterpolateImageFunction_h #define otbProlateInterpolateImageFunction_h #include "otbGenericInterpolateImageFunction.h" #include "itkSize.h" #include "itkNumericTraits.h" #include "vnl/vnl_math.h" #include "vnl/algo/vnl_fft_1d.h" namespace otb { namespace Function { /** \class ProlateFunction * * \brief Prolate function give the value of the prolate profile following * one of the 2 image dimension. * * * \ingroup OTBInterpolation */ template class ProlateFunction { public: ProlateFunction() : m_Radius(1) { const double PROLATE_COEFFICIENTS[] = { 0.00125, 0.00124999, 0.00124998, 0.00124997, 0.00124995, 0.00124992, 0.00124989, 0.00124985, 0.0012498, 0.00124975, 0.00124969, 0.00124962, 0.00124955, 0.00124948, 0.00124939, 0.0012493, 0.00124921, 0.00124911, 0.001249, 0.00124888, 0.00124876, 0.00124864, 0.0012485, 0.00124837, 0.00124822, 0.00124807, 0.00124791, 0.00124775, 0.00124758, 0.0012474, 0.00124722, 0.00124703, 0.00124684, 0.00124664, 0.00124643, 0.00124622, 0.001246, 0.00124578, 0.00124555, 0.00124531, 0.00124507, 0.00124482, 0.00124456, 0.0012443, 0.00124403, 0.00124376, 0.00124348, 0.00124319, 0.0012429, 0.0012426, 0.0012423, 0.00124199, 0.00124167, 0.00124135, 0.00124102, 0.00124069, 0.00124035, 0.00124, 0.00123965, 0.00123929, 0.00123892, 0.00123855, 0.00123817, 0.00123779, 0.0012374, 0.001237, 0.0012366, 0.00123619, 0.00123578, 0.00123536, 0.00123494, 0.0012345, 0.00123407, 0.00123362, 0.00123317, 0.00123272, 0.00123225, 0.00123179, 0.00123131, 0.00123083, 0.00123035, 0.00122985, 0.00122936, 0.00122885, 0.00122834, 0.00122783, 0.0012273, 0.00122678, 0.00122624, 0.0012257, 0.00122516, 0.0012246, 0.00122405, 0.00122348, 0.00122291, 0.00122234, 0.00122175, 0.00122117, 0.00122057, 0.00121997, 0.00121937, 0.00121876, 0.00121814, 0.00121752, 0.00121689, 0.00121625, 0.00121561, 0.00121497, 0.00121431, 0.00121366, 0.00121299, 0.00121232, 0.00121165, 0.00121096, 0.00121028, 0.00120958, 0.00120888, 0.00120818, 0.00120747, 0.00120675, 0.00120603, 0.0012053, 0.00120457, 0.00120383, 0.00120308, 0.00120233, 0.00120157, 0.00120081, 0.00120004, 0.00119927, 0.00119849, 0.0011977, 0.00119691, 0.00119611, 0.00119531, 0.0011945, 0.00119368, 0.00119286, 0.00119204, 0.00119121, 0.00119037, 0.00118953, 0.00118868, 0.00118782, 0.00118696, 0.0011861, 0.00118523, 0.00118435, 0.00118347, 0.00118258, 0.00118169, 0.00118079, 0.00117988, 0.00117897, 0.00117805, 0.00117713, 0.00117621, 0.00117527, 0.00117433, 0.00117339, 0.00117244, 0.00117149, 0.00117053, 0.00116956, 0.00116859, 0.00116761, 0.00116663, 0.00116564, 0.00116465, 0.00116365, 0.00116265, 0.00116164, 0.00116062, 0.0011596, 0.00115858, 0.00115754, 0.00115651, 0.00115547, 0.00115442, 0.00115337, 0.00115231, 0.00115124, 0.00115018, 0.0011491, 0.00114802, 0.00114694, 0.00114585, 0.00114475, 0.00114365, 0.00114255, 0.00114143, 0.00114032, 0.0011392, 0.00113807, 0.00113694, 0.0011358, 0.00113466, 0.00113351, 0.00113236, 0.0011312, 0.00113003, 0.00112887, 0.00112769, 0.00112651, 0.00112533, 0.00112414, 0.00112295, 0.00112175, 0.00112054, 0.00111933, 0.00111812, 0.0011169, 0.00111567, 0.00111444, 0.00111321, 0.00111197, 0.00111072, 0.00110947, 0.00110822, 0.00110696, 0.00110569, 0.00110442, 0.00110315, 0.00110187, 0.00110059, 0.0010993, 0.001098, 0.0010967, 0.0010954, 0.00109409, 0.00109277, 0.00109146, 0.00109013, 0.0010888, 0.00108747, 0.00108613, 0.00108479, 0.00108344, 0.00108209, 0.00108073, 0.00107937, 0.001078, 0.00107663, 0.00107526, 0.00107387, 0.00107249, 0.0010711, 0.0010697, 0.0010683, 0.0010669, 0.00106549, 0.00106408, 0.00106266, 0.00106124, 0.00105981, 0.00105838, 0.00105694, 0.0010555, 0.00105405, 0.0010526, 0.00105115, 0.00104969, 0.00104823, 0.00104676, 0.00104528, 0.00104381, 0.00104233, 0.00104084, 0.00103935, 0.00103785, 0.00103636, 0.00103485, 0.00103334, 0.00103183, 0.00103031, 0.00102879, 0.00102727, 0.00102574, 0.0010242, 0.00102267, 0.00102112, 0.00101958, 0.00101803, 0.00101647, 0.00101491, 0.00101335, 0.00101178, 0.00101021, 0.00100863, 0.00100705, 0.00100547, 0.00100388, 0.00100228, 0.00100069, 0.000999085, 0.00099748, 0.000995871, 0.000994258, 0.00099264, 0.000991019, 0.000989394, 0.000987764, 0.000986131, 0.000984494, 0.000982852, 0.000981207, 0.000979558, 0.000977905, 0.000976248, 0.000974587, 0.000972922, 0.000971254, 0.000969581, 0.000967905, 0.000966225, 0.000964541, 0.000962853, 0.000961162, 0.000959466, 0.000957767, 0.000956065, 0.000954358, 0.000952648, 0.000950934, 0.000949217, 0.000947495, 0.00094577, 0.000944042, 0.00094231, 0.000940574, 0.000938834, 0.000937092, 0.000935345, 0.000933595, 0.000931841, 0.000930084, 0.000928323, 0.000926559, 0.000924792, 0.000923021, 0.000921246, 0.000919468, 0.000917686, 0.000915902, 0.000914113, 0.000912322, 0.000910527, 0.000908728, 0.000906927, 0.000905122, 0.000903314, 0.000901502, 0.000899687, 0.000897869, 0.000896048, 0.000894223, 0.000892395, 0.000890564, 0.00088873, 0.000886892, 0.000885052, 0.000883208, 0.000881361, 0.000879511, 0.000877658, 0.000875802, 0.000873943, 0.000872081, 0.000870216, 0.000868347, 0.000866476, 0.000864602, 0.000862724, 0.000860844, 0.000858961, 0.000857075, 0.000855186, 0.000853294, 0.000851399, 0.000849502, 0.000847601, 0.000845698, 0.000843791, 0.000841882, 0.000839971, 0.000838056, 0.000836139, 0.000834219, 0.000832296, 0.000830371, 0.000828442, 0.000826511, 0.000824578, 0.000822642, 0.000820703, 0.000818761, 0.000816817, 0.000814871, 0.000812922, 0.00081097, 0.000809016, 0.000807059, 0.000805099, 0.000803138, 0.000801173, 0.000799207, 0.000797237, 0.000795266, 0.000793292, 0.000791315, 0.000789337, 0.000787355, 0.000785372, 0.000783386, 0.000781398, 0.000779407, 0.000777415, 0.00077542, 0.000773422, 0.000771423, 0.000769421, 0.000767417, 0.000765411, 0.000763403, 0.000761393, 0.00075938, 0.000757365, 0.000755349, 0.00075333, 0.000751309, 0.000749286, 0.000747261, 0.000745234, 0.000743205, 0.000741173, 0.00073914, 0.000737105, 0.000735069, 0.00073303, 0.000730989, 0.000728946, 0.000726902, 0.000724855, 0.000722807, 0.000720757, 0.000718705, 0.000716652, 0.000714596, 0.000712539, 0.00071048, 0.000708419, 0.000706357, 0.000704293, 0.000702227, 0.00070016, 0.000698091, 0.00069602, 0.000693948, 0.000691874, 0.000689798, 0.000687721, 0.000685643, 0.000683563, 0.000681481, 0.000679398, 0.000677313, 0.000675227, 0.00067314, 0.000671051, 0.000668961, 0.000666869, 0.000664776, 0.000662681, 0.000660586, 0.000658489, 0.00065639, 0.00065429, 0.000652189, 0.000650087, 0.000647984, 0.000645879, 0.000643773, 0.000641666, 0.000639558, 0.000637448, 0.000635337, 0.000633226, 0.000631113, 0.000628999, 0.000626884, 0.000624768, 0.000622651, 0.000620533, 0.000618414, 0.000616293, 0.000614172, 0.00061205, 0.000609927, 0.000607803, 0.000605679, 0.000603553, 0.000601426, 0.000599299, 0.000597171, 0.000595042, 0.000592912, 0.000590781, 0.000588649, 0.000586517, 0.000584384, 0.000582251, 0.000580116, 0.000577981, 0.000575845, 0.000573709, 0.000571572, 0.000569434, 0.000567296, 0.000565157, 0.000563018, 0.000560878, 0.000558738, 0.000556597, 0.000554455, 0.000552313, 0.000550171, 0.000548028, 0.000545884, 0.000543741, 0.000541596, 0.000539452, 0.000537307, 0.000535162, 0.000533016, 0.00053087, 0.000528724, 0.000526578, 0.000524431, 0.000522284, 0.000520137, 0.000517989, 0.000515842, 0.000513694, 0.000511546, 0.000509398, 0.000507249, 0.000505101, 0.000502953, 0.000500804, 0.000498655, 0.000496507, 0.000494358, 0.000492209, 0.000490061, 0.000487912, 0.000485763, 0.000483615, 0.000481466, 0.000479318, 0.00047717, 0.000475021, 0.000472873, 0.000470725, 0.000468578, 0.00046643, 0.000464283, 0.000462136, 0.000459989, 0.000457842, 0.000455696, 0.00045355, 0.000451404, 0.000449259, 0.000447114, 0.000444969, 0.000442825, 0.000440681, 0.000438537, 0.000436394, 0.000434251, 0.000432109, 0.000429967, 0.000427826, 0.000425685, 0.000423545, 0.000421405, 0.000419266, 0.000417127, 0.000414989, 0.000412852, 0.000410715, 0.000408579, 0.000406443, 0.000404308, 0.000402174, 0.000400041, 0.000397908, 0.000395776, 0.000393645, 0.000391514, 0.000389385, 0.000387256, 0.000385128, 0.000383, 0.000380874, 0.000378748, 0.000376624, 0.0003745, 0.000372377, 0.000370255, 0.000368134, 0.000366014, 0.000363895, 0.000361777, 0.00035966, 0.000357544, 0.000355429, 0.000353315, 0.000351202, 0.000349091, 0.00034698, 0.000344871, 0.000342762, 0.000340655, 0.000338549, 0.000336444, 0.00033434, 0.000332238, 0.000330137, 0.000328037, 0.000325938, 0.000323841, 0.000321745, 0.00031965, 0.000317556, 0.000315464, 0.000313374, 0.000311284, 0.000309196, 0.00030711, 0.000305025, 0.000302941, 0.000300859, 0.000298778, 0.000296699, 0.000294621, 0.000292544, 0.00029047, 0.000288397, 0.000286325, 0.000284255, 0.000282186, 0.00028012, 0.000278054, 0.000275991, 0.000273929, 0.000271869, 0.00026981, 0.000267753, 0.000265698, 0.000263645, 0.000261593, 0.000259543, 0.000257495, 0.000255449, 0.000253404, 0.000251362, 0.000249321, 0.000247282, 0.000245245, 0.00024321, 0.000241176, 0.000239145, 0.000237116, 0.000235088, 0.000233062, 0.000231039, 0.000229017, 0.000226998, 0.00022498, 0.000222965, 0.000220951, 0.00021894, 0.00021693, 0.000214923, 0.000212918, 0.000210915, 0.000208914, 0.000206915, 0.000204919, 0.000202924, 0.000200932, 0.000198942, 0.000196955, 0.000194969, 0.000192986, 0.000191005, 0.000189026, 0.00018705, 0.000185076, 0.000183104, 0.000181135, 0.000179167, 0.000177203, 0.00017524, 0.000173281, 0.000171323, 0.000169368, 0.000167415, 0.000165465, 0.000163517, 0.000161572, 0.000159629, 0.000157689, 0.000155752, 0.000153816, 0.000151884, 0.000149954, 0.000148026, 0.000146101, 0.000144179 }; const size_t PROLATE_COEFFICIENTS_SIZE = sizeof(PROLATE_COEFFICIENTS) / sizeof(PROLATE_COEFFICIENTS[0]); m_OriginalProfile.reserve(PROLATE_COEFFICIENTS_SIZE); m_OriginalProfile.assign(PROLATE_COEFFICIENTS, PROLATE_COEFFICIENTS+PROLATE_COEFFICIENTS_SIZE); } ~ProlateFunction() {} typedef std::vector VectorType; // Accessors definitions void SetRadius(unsigned int rad) { m_Radius = rad; } unsigned int GetRadius() const { return m_Radius; } unsigned int GetOriginalProfileSize() const { return m_OriginalProfile.size(); } VectorType GetOriginalProfile() const { return m_OriginalProfile; } double ComputeEnergy(double resampleRatio) const; inline TOutput operator ()(const TInput& A) const { const size_t originalProfileSize = m_OriginalProfile.size(); TOutput val = itk::NumericTraits::Zero; if (A != itk::NumericTraits::Zero && vcl_abs(A) != static_cast(m_Radius) && m_Radius != 0) { double ival = static_cast(originalProfileSize - 1) * static_cast(vcl_abs(A)) / static_cast(m_Radius); double ivalFloor = vcl_floor(ival); double left = ival - ivalFloor; if (static_cast(ivalFloor) + 1 < originalProfileSize) { val = (1.0 - left) * m_OriginalProfile[static_cast(ivalFloor)] + left * m_OriginalProfile[static_cast(ivalFloor) + 1]; } else { itkGenericExceptionMacro(<< "Out of Profile limits (" << ivalFloor << " -1 > 721)"); } } else { if (A == itk::NumericTraits::Zero || m_Radius == 0) { val = m_OriginalProfile[0]; } else { if (vcl_abs(A) == static_cast(m_Radius)) { val = m_OriginalProfile[originalProfileSize - 1]; } } } return val; } private: /** Useless, only to be compatible with the GenericInterpolateImage. */ unsigned int m_Radius; /** Original prolate profile */ VectorType m_OriginalProfile; }; } //namespace Function /** \class ProlateInterpolateImageFunction * \brief Prolate interpolation of an otb::image. * * ProlateInterpolateImageFunction interpolates image intensity according to a * resampling profil. * * The Initialize() method need to be call to create the filter. * * \ingroup ImageFunctions ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double, class TInputInterpolator = double, class TOutputInterpolator = double> class ITK_EXPORT ProlateInterpolateImageFunction : public GenericInterpolateImageFunction, TBoundaryCondition, TCoordRep> { public: /** Standard class typedefs. */ typedef ProlateInterpolateImageFunction Self; typedef GenericInterpolateImageFunction, TBoundaryCondition, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ProlateInterpolateImageFunction, GenericInterpolateImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; typedef TInputInterpolator InputInterpolatorType; typedef TOutputInterpolator OutputInterpolatorType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef Function::ProlateFunction FunctionType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename std::vector VectorType; unsigned int GetOriginalProfileSize() const { return this->GetFunction().GetOriginalProfileSize; } VectorType GetOriginalProfile() const { return this->GetFunction().GetOriginalProfile(); } protected: ProlateInterpolateImageFunction(); ~ProlateInterpolateImageFunction() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ProlateInterpolateImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbProlateInterpolateImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbProlateInterpolateImageFunction.txx000066400000000000000000000060651301006202600317370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProlateInterpolateImageFunction_txx #define otbProlateInterpolateImageFunction_txx #include "otbProlateInterpolateImageFunction.h" namespace otb { namespace Function { template double ProlateFunction ::ComputeEnergy(double resampleRatio) const { vnl_vector > resampledProfile(1024); resampledProfile.fill(0); for (unsigned int i = 0; i < m_Radius + 1; ++i) { unsigned int ival = static_cast(static_cast(m_OriginalProfile.size() * i) / static_cast(m_Radius + 1)); resampledProfile[i] = m_OriginalProfile[ival]; } vnl_fft_1d v1d(1024); v1d.fwd_transform(resampledProfile); // Carrful, spectrum is symmetrical unsigned int sampleNb = static_cast(1024 / (2 * resampleRatio)); double energy = 0.; // First part of spectrum for (unsigned int j = 0; j < sampleNb + 1; ++j) { energy += std::abs(resampledProfile[j]) * std::abs(resampledProfile[j]); } // Last part of spectrum for (unsigned int j = 1023; j > 1023 - sampleNb; j--) { energy += std::abs(resampledProfile[j]) * std::abs(resampledProfile[j]); } double totalEnergy = energy; // Middle part for (unsigned int j = sampleNb + 1; j < 1023 - sampleNb + 1; ++j) { totalEnergy += std::abs(resampledProfile[j]) * std::abs(resampledProfile[j]); } return std::sqrt(energy) / std::sqrt(totalEnergy); } } // end namespace Function /** Constructor */ template ProlateInterpolateImageFunction ::ProlateInterpolateImageFunction() { //VectorType m_ResampledProfil(1, 0.); this->SetNormalizeWeight(true); } /** Destructor */ template ProlateInterpolateImageFunction ::~ProlateInterpolateImageFunction() { } template void ProlateInterpolateImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } //namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbStreamingTraits.h000066400000000000000000000114401301006202600261660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingTraits_h #define otbStreamingTraits_h #include "otbMacro.h" #include "itkBSplineInterpolateImageFunction.h" #include "itkLinearInterpolateImageFunction.h" #include "itkNearestNeighborInterpolateImageFunction.h" #include "otbWindowedSincInterpolateImageGaussianFunction.h" #include "otbWindowedSincInterpolateImageHammingFunction.h" #include "otbWindowedSincInterpolateImageCosineFunction.h" #include "otbWindowedSincInterpolateImageWelchFunction.h" #include "otbWindowedSincInterpolateImageLanczosFunction.h" #include "otbWindowedSincInterpolateImageBlackmanFunction.h" #include "otbBCOInterpolateImageFunction.h" #include "otbProlateInterpolateImageFunction.h" namespace otb { /** \class StreamingTraits * \brief This class provides internal information for streamable filters * * \note * This class is specialized for otb::VectorImage because VectorImage support less interpolator types * * \sa ImageFileWriter * \sa StreamingStatisticsImageFilter * \sa StreamingResampleImageFilter * * \ingroup OTBInterpolation */ template class ITK_EXPORT StreamingTraits { public: /** Standard class typedefs. */ typedef StreamingTraits Self; typedef TImage ImageType; /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); // ITK Interpolators typedef itk::InterpolateImageFunction InterpolationType; typedef itk::BSplineInterpolateImageFunction BSplineInterpolationType; typedef itk::LinearInterpolateImageFunction LinearInterpolationType; typedef itk::NearestNeighborInterpolateImageFunction NearestNeighborInterpolationType; // OTB Interpolators (supported for otb::Image) typedef WindowedSincInterpolateImageGaussianFunction GaussianInterpolationType; typedef WindowedSincInterpolateImageCosineFunction CosineInterpolationType; typedef WindowedSincInterpolateImageHammingFunction HammingInterpolationType; typedef WindowedSincInterpolateImageWelchFunction WelchInterpolationType; typedef WindowedSincInterpolateImageLanczosFunction LanczosInterpolationType; typedef WindowedSincInterpolateImageBlackmanFunction BlackmanInterpolationType; typedef ProlateInterpolateImageFunction ProlateInterpolationType; typedef BCOInterpolateImageFunction BCOInterpolationType; static unsigned int CalculateNeededRadiusForInterpolator(const InterpolationType* interpolator); }; /** \class StreamingTraits * \brief This class provides internal information for streamable filters * * \note * This class is specialized for otb::VectorImage because VectorImage support less interpolator types * * \sa ImageFileWriter * \sa StreamingStatisticsImageFilter * \sa StreamingResampleImageFilter * * \ingroup OTBInterpolation */ template class ITK_EXPORT StreamingTraits< otb::VectorImage > { public: /** Standard class typedefs. */ typedef StreamingTraits Self; typedef otb::VectorImage ImageType; /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); // ITK Interpolators typedef itk::InterpolateImageFunction InterpolationType; typedef itk::LinearInterpolateImageFunction LinearInterpolationType; typedef itk::NearestNeighborInterpolateImageFunction NearestNeighborInterpolationType; // OTB Interpolators (supported for otb::VectorImage) typedef WindowedSincInterpolateImageGaussianFunction GaussianInterpolationType; typedef BCOInterpolateImageFunction BCOInterpolationType; static unsigned int CalculateNeededRadiusForInterpolator(const InterpolationType* interpolator); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingTraits.txx" #endif #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbStreamingTraits.txx000066400000000000000000000105171301006202600265660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingTraits_txx #define otbStreamingTraits_txx #include "otbStreamingTraits.h" namespace otb { template unsigned int StreamingTraits ::CalculateNeededRadiusForInterpolator(const InterpolationType* interpolator) { unsigned int neededRadius = 0; std::string className; className = interpolator->GetNameOfClass(); if (className == "LinearInterpolateImageFunction") { otbMsgDevMacro(<< "Linear Interpolator"); neededRadius = 1; } else if (className == "NearestNeighborInterpolateImageFunction") { otbMsgDevMacro(<< "Nearest Neighbor Interpolator"); neededRadius = 1; } else if (className == "BSplineInterpolateImageFunction") { otbMsgDevMacro(<< "BSpline Interpolator"); neededRadius = 2; } else if (className == "ProlateInterpolateImageFunction") { otbMsgDevMacro(<< "Prolate Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "WindowedSincInterpolateImageGaussianFunction") { otbMsgDevMacro(<< "Gaussian Windowed Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "WindowedSincInterpolateImageHammingFunction") { otbMsgDevMacro(<< "Hamming Windowed Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "WindowedSincInterpolateImageCosineFunction") { otbMsgDevMacro(<< "Cosine Windowed Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "WindowedSincInterpolateImageWelchFunction") { otbMsgDevMacro(<< "Welch Windowed Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "WindowedSincInterpolateImageLanczosFunction") { otbMsgDevMacro(<< "Lanczos Windowed Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "WindowedSincInterpolateImageBlackmanFunction") { otbMsgDevMacro(<< "Blackman Windowed Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "BCOInterpolateImageFunction") { otbMsgDevMacro(<< "BCO Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } return neededRadius; } template unsigned int StreamingTraits< otb::VectorImage > ::CalculateNeededRadiusForInterpolator(const InterpolationType* interpolator) { unsigned int neededRadius = 0; std::string className; className = interpolator->GetNameOfClass(); if (className == "LinearInterpolateImageFunction") { otbMsgDevMacro(<< "Linear Interpolator"); neededRadius = 1; } else if (className == "NearestNeighborInterpolateImageFunction") { otbMsgDevMacro(<< "Nearest Neighbor Interpolator"); neededRadius = 1; } else if (className == "BSplineInterpolateImageFunction") { otbMsgDevMacro(<< "BSpline Interpolator"); neededRadius = 2; } else if (className == "WindowedSincInterpolateImageGaussianFunction") { otbMsgDevMacro(<< "Gaussian Windowed Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } else if (className == "BCOInterpolateImageFunction") { otbMsgDevMacro(<< "BCO Interpolator"); neededRadius = dynamic_cast(interpolator)->GetRadius(); } return neededRadius; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageBlackmanFunction.h000066400000000000000000000112301301006202600337510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageBlackmanFunction_h #define otbWindowedSincInterpolateImageBlackmanFunction_h #include "otbWindowedSincInterpolateImageFunctionBase.h" #include "vnl/vnl_math.h" namespace otb { namespace Function { /** * \class BlackmanWindowFunction * \brief Window function for sinc interpolation. * \f[ w(x) = 0.42 + 0.5 cos(\frac{\pi x}{m}) + 0.08 cos(\frac{2 \pi x}{m}) \f] * \sa WindowedSincInterpolateImageBlackmanFunction * * \ingroup OTBInterpolation */ template class BlackmanWindowFunction { public: void SetRadius(unsigned int radius) { m_Radius = radius; m_Factor1 = CONST_PI / static_cast(radius); m_Factor2 = 2.0 * CONST_PI / static_cast(radius); } unsigned int GetRadius() const { return m_Radius; } double GetFactor1() { return m_Factor1; } double GetFactor2() { return m_Factor2; } inline TOutput operator ()(const TInput& A) const { double x = static_cast(A); double px = CONST_PI * x; double temp = 0.42 + 0.5 * vcl_cos(x * m_Factor1) + 0.08 * vcl_cos(x * m_Factor2); return (x == 0.0) ? static_cast(temp) : static_cast(temp * vcl_sin(px) / px); } private: unsigned int m_Radius; // Equal to \f$ \frac{\pi}{m} \f$ double m_Factor1; // Equal to \f$ \frac{2 \pi}{m} \f$ double m_Factor2; }; } //namespace Function /** * \class WindowedSincInterpolateImageBlackmanFunction * \brief Use the WindowedSincInterpolateImageFunctionBase with a Blackman Function. * * \sa GenericInterpolatorImageFunction * \sa Function::GaussianWindowFunction * \sa Function::HammingWindowFunction * \sa Function::CosineWindowFunction * \sa Function::WelchWindowFunction * \sa Function::LanczosWindowFunction * \sa Function::BlackmanWindowFunction * \ingroup ImageFunctionBases ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double, class TInputInterpolator = double, class TOutputInterpolator = double> class ITK_EXPORT WindowedSincInterpolateImageBlackmanFunction : public WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> { public: /** Standard class typedefs. */ typedef WindowedSincInterpolateImageBlackmanFunction Self; typedef WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(WindowedSincInterpolateImageBlackmanFunction, WindowedSincInterpolateImageFunctionBase); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; protected: WindowedSincInterpolateImageBlackmanFunction() {}; ~WindowedSincInterpolateImageBlackmanFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: WindowedSincInterpolateImageBlackmanFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageCosineFunction.h000066400000000000000000000106161301006202600334700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageCosineFunction_h #define otbWindowedSincInterpolateImageCosineFunction_h #include "otbWindowedSincInterpolateImageFunctionBase.h" #include "vnl/vnl_math.h" namespace otb { namespace Function { /** * \class HammingWindowFunction * \brief Window function for sinc interpolation. * \f[ w(x) = 0.54 + 0.46 cos(\frac{\pi x}{m} ) \f] * \sa WindowedSincInterpolateImageCosineFunction * * \ingroup OTBInterpolation */ template class CosineWindowFunction { public: void SetRadius(unsigned int radius) { m_Radius = radius; m_Factor = CONST_PI / (2 * static_cast(radius)); } unsigned int GetRadius() const { return m_Radius; } double GetFactor() { return m_Factor; } inline TOutput operator ()(const TInput& A) const { double x = static_cast(A); double px = CONST_PI * x; double temp = vcl_cos(x * m_Factor); return (x == 0.0) ? static_cast(temp) : static_cast(temp * vcl_sin(px) / px); } private: // Equal to \f$ \frac{\pi}{2 m} \f$ double m_Factor; unsigned int m_Radius; }; } //namespace Function /** * \class WindowedSincInterpolateImageCosineFunction * \brief Use the WindowedSincInterpolateImageFunctionBase with a Cosine Function. * * \sa GenericInterpolatorImageFunction * \sa Function::GaussianWindowFunction * \sa Function::HammingWindowFunction * \sa Function::CosineWindowFunction * \sa Function::WelchWindowFunction * \sa Function::LanczosWindowFunction * \sa Function::BlackmanWindowFunction * \ingroup ImageFunctionBases ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double, class TInputInterpolator = double, class TOutputInterpolator = double> class ITK_EXPORT WindowedSincInterpolateImageCosineFunction : public WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> { public: /** Standard class typedefs. */ typedef WindowedSincInterpolateImageCosineFunction Self; typedef WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(WindowedSincInterpolateImageCosineFunction, WindowedSincInterpolateImageFunctionBase); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; protected: WindowedSincInterpolateImageCosineFunction() {}; ~WindowedSincInterpolateImageCosineFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: WindowedSincInterpolateImageCosineFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageFunctionBase.h000066400000000000000000000167421301006202600331300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageFunctionBase_h #define otbWindowedSincInterpolateImageFunctionBase_h #include "otbGenericInterpolateImageFunction.h" #include "itkSize.h" #include "otbMath.h" #include "vnl/vnl_math.h" namespace otb { /** * \class WindowedSincInterpolateImageFunctionBase * \brief Use the windowed sinc function to interpolate * * \par THEORY * * This function is intended to provide an interpolation function that * has minimum aliasing artifacts, in contrast to linear interpolation. * According to sampling theory, the infinite-support sinc filter, * whose Fourier transform is the box filter, is optimal for resampling * a function. In practice, the infinite support sinc filter is * approximated using a limited support 'windowed' sinc filter. * Most of those functions are inspired of the itk::WindowedSincInterpolateImageFunction source code. * * \par * This function is based on the following publication: * * \par * Erik H. W. Meijering, Wiro J. Niessen, Josien P. W. Pluim, * Max A. Viergever: Quantitative Comparison of Sinc-Approximating * Kernels for Medical Image Interpolation. MICCAI 1999, pp. 210-217 * * \par * In this work, several 'windows' are estimated. In two dimensions, the * interpolation at a position (x, y) is given by the following * expression: * * \par * \f[ * I(x, y) = * \sum_{i = \lfloor x \rfloor + 1 - m}^{\lfloor x \rfloor + m} * \sum_{j = \lfloor y \rfloor + 1 - m}^{\lfloor y \rfloor + m} * I_{i, j} K(x-i) K(y-j), * \f] * * \par * where m is the 'radius' of the window, (3, 4 are reasonable numbers), * and K(t) is the kernel function, composed of the sinc function and * one of several possible window functions: * * \par * \f[ * K(t) = w(t) \textrm{sinc}(t) = w(t) \frac{\sin(\pi t)}{\pi t} * \f] * * \par * Several window functions are provided here in the itk::Function * namespace. The conclusions of the referenced paper suggest to use the * Welch, Cosine, Kaiser, and Lanczos windows for m = 4, 5. These are based * on error in rotating medical images w.r.t. the linear interpolation * method. In some cases the results achieve a 20-fold improvement in * accuracy. * * \par USING THIS FILTER * * Use this filter the way you would use any ImageInterpolationFunction, * so for instance, you can plug it into the ResampleImageFilter class. * In order to initialize the filter you must choose several template * parameters. * * \par * The first (TInputImage) is the image type, that's standard. * * \par * The second (TWindowFunction) is the window function object, which you * can choose from about five different functions defined in this * header. The default is the Hamming window, which is commonly used * but not optimal according to the cited paper. * * \par * The third (TBoundaryCondition) is the boundary condition class used * to determine the values of pixels that fall off the image boundary. * This class has the same meaning here as in the NeighborhoodItetator * classes. * * \par * The fourth (TCoordRep) is again standard for interpolating functions, * and should be float or double. * * \par CAVEATS * * There are a few improvements that an enthusiasting ITK developer * could make to this filter. One issue is with the way that the kernel * is applied. The computational expense comes from two sources: * computing the kernel weights K(t) and multiplying the pixels in the * window by the kernel weights. The first is done more or less * efficiently in \f$ 2 m d \f$ operations (where d is the * dimensionality of the image). The second can be done * better. Presently, each pixel \f$ I(i, j, k) \f$ is multiplied by the * weights \f$ K(x-i), K(y-j), K(z-k) \f$ and added to the running * total. This results in \f$ d (2m)^d \f$ multiplication * operations. However, by keeping intermediate sums, it would be * possible to do the operation in \f$ O ( (2m)^d ) \f$ * operations. This would require some creative coding. In addition, in * the case when one of the coordinates is integer, the computation * could be reduced by an order of magnitude. * * \sa GenericInterpolatorImageFunctionBase * \sa LinearInterpolateImageFunctionBase ResampleImageFilter * \sa Function::HammingWindowFunction * \sa Function::CosineWindowFunction * \sa Function::WelchWindowFunction * \sa Function::LanczosWindowFunction * \sa Function::BlackmanWindowFunction * \ingroup ImageFunctionBases ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double> class ITK_EXPORT WindowedSincInterpolateImageFunctionBase : public GenericInterpolateImageFunction { public: /** Standard class typedefs. */ typedef WindowedSincInterpolateImageFunctionBase Self; typedef GenericInterpolateImageFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(WindowedSincInterpolateImageFunctionBase, GenericInterpolateImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; //typedef typename TWindowFunction FunctionType; typedef typename Superclass::FunctionType FunctionType; typedef typename std::vector VectorType; /** Compute a resampled profil according to the window size.*/ // virtual void ComputeResampledWindowedSincProfil(); protected: WindowedSincInterpolateImageFunctionBase(); ~WindowedSincInterpolateImageFunctionBase() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: WindowedSincInterpolateImageFunctionBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbWindowedSincInterpolateImageFunctionBase.txx" #endif #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageFunctionBase.txx000066400000000000000000000031071301006202600335130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageFunctionBase_txx #define otbWindowedSincInterpolateImageFunctionBase_txx #include "otbWindowedSincInterpolateImageFunctionBase.h" namespace otb { /** Constructor */ template WindowedSincInterpolateImageFunctionBase ::WindowedSincInterpolateImageFunctionBase() { } /** Destructor */ template WindowedSincInterpolateImageFunctionBase ::~WindowedSincInterpolateImageFunctionBase() { } template void WindowedSincInterpolateImageFunctionBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } //namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageGaussianFunction.h000066400000000000000000000106501301006202600340200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageGaussianFunction_h #define otbWindowedSincInterpolateImageGaussianFunction_h #include "otbWindowedSincInterpolateImageFunctionBase.h" #include "vnl/vnl_math.h" namespace otb { namespace Function { /** * \class GaussianWindowFunction * \brief Gaussian interpolation windowing function. * \f[ w(x) = exp ( -2. \frac{sigma*sigma * \pi } ) \f] * \sa otbWindowedSincInterpolateImageFunctionBase * * \ingroup OTBInterpolation */ template class GaussianWindowFunction { public: void SetRadius(unsigned int radius) { m_Radius = radius; m_Factor = -2. / (static_cast(m_Radius * m_Radius) * CONST_PI); } double GetFactor() { return m_Factor; } unsigned int GetRadius() const { return m_Radius; } inline TOutput operator ()(const TInput& A) const { double x = static_cast(A); double px = CONST_PI * x; double temp = vcl_exp(px * px * m_Factor); return (x == 0.0) ? static_cast(temp) : static_cast(temp * vcl_sin(px) / px); } private: double m_Factor; unsigned int m_Radius; }; } //namespace Function /** * \class WindowedSincInterpolateImageGaussianFunction * \brief Use the WindowedSincInterpolateImageFunctionBase with a Gaussian Function. * * \sa GenericInterpolatorImageFunction * \sa Function::GaussianWindowFunction * \sa Function::HammingWindowFunction * \sa Function::CosineWindowFunction * \sa Function::WelchWindowFunction * \sa Function::LanczosWindowFunction * \sa Function::BlackmanWindowFunction * \ingroup ImageFunctionBases ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double, class TInputInterpolator = double, class TOutputInterpolator = double> class ITK_EXPORT WindowedSincInterpolateImageGaussianFunction : public WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> { public: /** Standard class typedefs. */ typedef WindowedSincInterpolateImageGaussianFunction Self; typedef WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(WindowedSincInterpolateImageGaussianFunction, WindowedSincInterpolateImageFunctionBase); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; protected: WindowedSincInterpolateImageGaussianFunction() {}; ~WindowedSincInterpolateImageGaussianFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: WindowedSincInterpolateImageGaussianFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageHammingFunction.h000066400000000000000000000106431301006202600336300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageHammingFunction_h #define otbWindowedSincInterpolateImageHammingFunction_h #include "otbWindowedSincInterpolateImageFunctionBase.h" #include "vnl/vnl_math.h" namespace otb { namespace Function { /** * \class HammingWindowFunction * \brief Window function for sinc interpolation. * \f[ w(x) = 0.54 + 0.46 cos(\frac{\pi x}{m} ) \f] * \sa WindowedSincInterpolateImageHammingFunction * * \ingroup OTBInterpolation */ template class HammingWindowFunction { public: void SetRadius(unsigned int radius) { m_Radius = radius; m_Factor = CONST_PI / static_cast(radius); } unsigned int GetRadius() const { return m_Radius; } double GetFactor() { return m_Factor; } inline TOutput operator ()(const TInput& A) const { double x = static_cast(A); double px = CONST_PI * x; double temp = 0.54 + 0.46 * vcl_cos(x * m_Factor); return (x == 0.0) ? static_cast(temp) : static_cast(temp * vcl_sin(px) / px); } private: // Equal to \f$ \frac{\pi}{m} \f$ double m_Factor; unsigned int m_Radius; }; } //namespace Function /** * \class WindowedSincInterpolateImageHammingFunction * \brief Use the WindowedSincInterpolateImageFunctionBase with a Hamming Function. * * \sa GenericInterpolatorImageFunction * \sa Function::GaussianWindowFunction * \sa Function::HammingWindowFunction * \sa Function::CosineWindowFunction * \sa Function::WelchWindowFunction * \sa Function::LanczosWindowFunction * \sa Function::BlackmanWindowFunction * \ingroup ImageFunctionBases ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double, class TInputInterpolator = double, class TOutputInterpolator = double> class ITK_EXPORT WindowedSincInterpolateImageHammingFunction : public WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> { public: /** Standard class typedefs. */ typedef WindowedSincInterpolateImageHammingFunction Self; typedef WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(WindowedSincInterpolateImageHammingFunction, WindowedSincInterpolateImageFunctionBase); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; protected: WindowedSincInterpolateImageHammingFunction() {}; ~WindowedSincInterpolateImageHammingFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: WindowedSincInterpolateImageHammingFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageLanczosFunction.h000066400000000000000000000112031301006202600336520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageLanczosFunction_h #define otbWindowedSincInterpolateImageLanczosFunction_h #include "otbWindowedSincInterpolateImageFunctionBase.h" #include "vnl/vnl_math.h" namespace otb { namespace Function { /** * \class LanczosWindowFunction * \brief Window function for sinc interpolation. * \f[ w(x) = \textrm{sinc} ( \frac{x}{m} ) \f] * Note: Paper referenced in WindowedSincInterpolateImageFunctionBase gives * an incorrect definition of this window function. * \sa WindowedSincInterpolateImageLanczosFunction * * \ingroup OTBInterpolation */ template class LanczosWindowFunction { public: void SetRadius(unsigned int radius) { m_Radius = radius; m_Factor = CONST_PI / static_cast(radius); } unsigned int GetRadius() const { return m_Radius; } double GetFactor() { return m_Factor; } inline TOutput operator ()(const TInput& A) const { double x = static_cast(A); double px = CONST_PI * x; double temp; if (x == 0.0) { temp = 1.0; } else { double z = m_Factor * x; temp = vcl_sin(z) / z; } return (x == 0.0) ? static_cast(temp) : static_cast(temp * vcl_sin(px) / px); } private: // Equal to \f$ \frac{\pi}{m} \f$ double m_Factor; unsigned int m_Radius; }; } //namespace Function /** * \class WindowedSincInterpolateImageLanczosFunction * \brief Use the WindowedSincInterpolateImageFunctionBase with a Lanczos Function. * * \sa GenericInterpolatorImageFunction * \sa Function::GaussianWindowFunction * \sa Function::HammingWindowFunction * \sa Function::CosineWindowFunction * \sa Function::WelchWindowFunction * \sa Function::LanczosWindowFunction * \sa Function::BlackmanWindowFunction * \ingroup ImageFunctionBases ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double, class TInputInterpolator = double, class TOutputInterpolator = double> class ITK_EXPORT WindowedSincInterpolateImageLanczosFunction : public WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> { public: /** Standard class typedefs. */ typedef WindowedSincInterpolateImageLanczosFunction Self; typedef WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(WindowedSincInterpolateImageLanczosFunction, WindowedSincInterpolateImageFunctionBase); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; protected: WindowedSincInterpolateImageLanczosFunction() {}; ~WindowedSincInterpolateImageLanczosFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: WindowedSincInterpolateImageLanczosFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/include/otbWindowedSincInterpolateImageWelchFunction.h000066400000000000000000000105571301006202600333160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWindowedSincInterpolateImageWelchFunction_h #define otbWindowedSincInterpolateImageWelchFunction_h #include "otbWindowedSincInterpolateImageFunctionBase.h" #include "vnl/vnl_math.h" namespace otb { namespace Function { /** * \class WelchWindowFunction * \brief Window function for sinc interpolation. * \f[ w(x) = 1 - ( \frac{x^2}{m^2} ) \f] * \sa WindowedSincInterpolateImageWelchFunction * * \ingroup OTBInterpolation */ template class WelchWindowFunction { public: void SetRadius(unsigned int radius) { m_Radius = radius; m_Factor = 1 / static_cast(radius * radius); } unsigned int GetRadius() const { return m_Radius; } double GetFactor() { return m_Factor; } inline TOutput operator ()(const TInput& A) const { double x = static_cast(A); double px = CONST_PI * x; double temp = 1.0 - x * m_Factor * x; return (x == 0.0) ? static_cast(temp) : static_cast(temp * vcl_sin(px) / px); } private: // Equal to \f$ \frac{1}{m^2} \f$ double m_Factor; unsigned int m_Radius; }; } //namespace Function /** * \class WindowedSincInterpolateImageWelchFunction * \brief Use the WindowedSincInterpolateImageFunctionBase with a Welch Function. * * \sa GenericInterpolatorImageFunction * \sa Function::GaussianWindowFunction * \sa Function::HammingWindowFunction * \sa Function::CosineWindowFunction * \sa Function::WelchWindowFunction * \sa Function::LanczosWindowFunction * \sa Function::BlackmanWindowFunction * \ingroup ImageFunctionBases ImageInterpolators * * \ingroup OTBInterpolation */ template, class TCoordRep = double, class TInputInterpolator = double, class TOutputInterpolator = double> class ITK_EXPORT WindowedSincInterpolateImageWelchFunction : public WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> { public: /** Standard class typedefs. */ typedef WindowedSincInterpolateImageWelchFunction Self; typedef WindowedSincInterpolateImageFunctionBase, TBoundaryCondition, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(WindowedSincInterpolateImageWelchFunction, WindowedSincInterpolateImageFunctionBase); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Input and output images typedef definition. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputType OutputType; /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Superclass typedef inheritance. */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RealType RealType; typedef typename Superclass::IteratorType IteratorType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; protected: WindowedSincInterpolateImageWelchFunction() {}; ~WindowedSincInterpolateImageWelchFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: WindowedSincInterpolateImageWelchFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Interpolation/otb-module.cmake000066400000000000000000000005451301006202600236220ustar00rootroot00000000000000set(DOCUMENTATION "This module contains additional interpolation functions (compared to the ones already available in itk -see itk::InterpolateImageFunction-).") otb_module(OTBInterpolation DEPENDS OTBCommon OTBITK OTBImageBase TEST_DEPENDS OTBImageIO OTBImageManipulation OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/Interpolation/test/000077500000000000000000000000001301006202600215245ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Interpolation/test/CMakeLists.txt000066400000000000000000000246701301006202600242750ustar00rootroot00000000000000otb_module_test() set(OTBInterpolationTests otbInterpolationTestDriver.cxx otbWindowedSincInterpolateImageCosineFunctionNew.cxx otbWindowedSincInterpolateImageLanczosFunction.cxx otbWindowedSincInterpolateImageLanczosFunctionNew.cxx otbWindowedSincInterpolateImageFunctionBaseNew.cxx otbProlateInterpolateImageFunctionNew.cxx otbBSplineDecompositionImageFilterNew.cxx otbBSplineInterpolateImageFunctionNew.cxx otbWindowedSincInterpolateImageBlackmanFunction.cxx otbBSplineDecompositionImageFilter.cxx otbWindowedSincInterpolateImageWelchFunctionNew.cxx otbWindowedSincInterpolateImageGaussianFunction.cxx otbGenericInterpolateImageFunctionNew.cxx otbWindowedSincInterpolateImageBlackmanFunctionNew.cxx otbWindowedSincInterpolateImageCosineFunction.cxx otbWindowedSincInterpolateImageHammingFunction.cxx otbWindowedSincInterpolateImageWelchFunction.cxx otbBSplineInterpolateImageFunction.cxx otbWindowedSincInterpolateImageGaussianFunctionNew.cxx otbWindowedSincInterpolateImageHammingFunctionNew.cxx otbStreamingTraits.cxx otbBCOInterpolateImageFunction.cxx otbProlateInterpolateImageFunction.cxx otbProlateValidationTest.cxx ) add_executable(otbInterpolationTestDriver ${OTBInterpolationTests}) target_link_libraries(otbInterpolationTestDriver ${OTBInterpolation-Test_LIBRARIES}) otb_module_target_label(otbInterpolationTestDriver) # Tests Declaration otb_add_test(NAME bfTuWindowedSincInterpolateImageCosineFunctionNew COMMAND otbInterpolationTestDriver otbWindowedSincInterpolateImageCosineFunctionNew) otb_add_test(NAME bfTvWindowedSincInterpolateImageLanczosFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfWindowedSincInterpolateImageLanczosFunctionOutput.txt ${TEMP}/bfWindowedSincInterpolateImageLanczosFunctionOutput.txt otbWindowedSincInterpolateImageLanczosFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfWindowedSincInterpolateImageLanczosFunctionOutput.txt 3 # radius 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTuWindowedSincInterpolateImageLanczosFunctionNew COMMAND otbInterpolationTestDriver otbWindowedSincInterpolateImageLanczosFunctionNew) otb_add_test(NAME bfTuWindowedSincInterpolateImageFunctionBaseNew COMMAND otbInterpolationTestDriver otbWindowedSincInterpolateImageFunctionBaseNew) otb_add_test(NAME bfTuProlateInterpolateImageFunctionNew COMMAND otbInterpolationTestDriver otbProlateInterpolateImageFunctionNew) otb_add_test(NAME bfTuBSplineDecompositionImageFilterNew COMMAND otbInterpolationTestDriver otbBSplineDecompositionImageFilterNew) otb_add_test(NAME bfTuBSplineInterpolateImageFunctionNew COMMAND otbInterpolationTestDriver otbBSplineInterpolateImageFunctionNew) otb_add_test(NAME bfTvWindowedSincInterpolateImageBlackmanFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfWindowedSincInterpolateImageBlackmanFunctionOutput.txt ${TEMP}/bfWindowedSincInterpolateImageBlackmanFunctionOutput.txt otbWindowedSincInterpolateImageBlackmanFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfWindowedSincInterpolateImageBlackmanFunctionOutput.txt 3 # radius 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTvBSplineDecompositionImageFilter COMMAND otbInterpolationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfBSplineDecompositionImageFilterOutput.tif ${TEMP}/bfBSplineDecompositionImageFilterOutput.tif otbBSplineDecompositionImageFilter ${INPUTDATA}/poupees.tif ${TEMP}/bfBSplineDecompositionImageFilterOutput.tif ) otb_add_test(NAME bfTuWindowedSincInterpolateImageWelchFunctionNew COMMAND otbInterpolationTestDriver otbWindowedSincInterpolateImageWelchFunctionNew) otb_add_test(NAME bfTvWindowedSincInterpolateImageGaussianFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfWindowedSincInterpolateImageGaussianFunctionOutput.txt ${TEMP}/bfWindowedSincInterpolateImageGaussianFunctionOutput.txt otbWindowedSincInterpolateImageGaussianFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfWindowedSincInterpolateImageGaussianFunctionOutput.txt 3 # radius 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME coTuGenericInterpolateImageFunctionNew COMMAND otbInterpolationTestDriver otbGenericInterpolateImageFunctionNew ) otb_add_test(NAME bfTuWindowedSincInterpolateImageBlackmanFunctionNew COMMAND otbInterpolationTestDriver otbWindowedSincInterpolateImageBlackmanFunctionNew) otb_add_test(NAME bfTvWindowedSincInterpolateImageCosineFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfWindowedSincInterpolateImageCosineFunctionOutput.txt ${TEMP}/bfWindowedSincInterpolateImageCosineFunctionOutput.txt otbWindowedSincInterpolateImageCosineFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfWindowedSincInterpolateImageCosineFunctionOutput.txt 3 # radius 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTvWindowedSincInterpolateImageHammingFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfWindowedSincInterpolateImageHammingFunctionOutput.txt ${TEMP}/bfWindowedSincInterpolateImageHammingFunctionOutput.txt otbWindowedSincInterpolateImageHammingFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfWindowedSincInterpolateImageHammingFunctionOutput.txt 3 # radius 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTvWindowedSincInterpolateImageWelchFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfWindowedSincInterpolateImageWelchFunctionOutput.txt ${TEMP}/bfWindowedSincInterpolateImageWelchFunctionOutput.txt otbWindowedSincInterpolateImageWelchFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfWindowedSincInterpolateImageWelchFunctionOutput.txt 3 # radius 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTvBSplineInterpolateImageFunction COMMAND otbInterpolationTestDriver --compare-ascii ${EPSILON_7} ${BASELINE_FILES}/bfBSplineInterpolateImageFunctionOutput.txt ${TEMP}/bfBSplineInterpolateImageFunctionOutput.txt otbBSplineInterpolateImageFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfBSplineInterpolateImageFunctionOutput.txt 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTuWindowedSincInterpolateImageGaussianFunctionNew COMMAND otbInterpolationTestDriver otbWindowedSincInterpolateImageGaussianFunctionNew) otb_add_test(NAME bfTuWindowedSincInterpolateImageHammingFunctionNew COMMAND otbInterpolationTestDriver otbWindowedSincInterpolateImageHammingFunctionNew) otb_add_test(NAME bfTuStreamingTraitsVectorImage COMMAND otbInterpolationTestDriver otbStreamingTraitsVectorImage ) otb_add_test(NAME bfTuStreamingTraitsImage COMMAND otbInterpolationTestDriver otbStreamingTraitsImage ) otb_add_test(NAME bfTvBCOInterpolateImageFunctionVectorImageTest COMMAND otbInterpolationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvBCOInterpolateImageFunctionVectorImageTest.tif ${TEMP}/bfTvBCOInterpolateImageFunctionVectorImageTest.tif otbBCOInterpolateImageFunctionVectorImageTest ${INPUTDATA}/poupees.tif ${TEMP}/bfTvBCOInterpolateImageFunctionVectorImageTest.tif 4 # radius -0.5 # optimised bicubic ) otb_add_test(NAME bfTvBCOInterpolateImageFunctionTest COMMAND otbInterpolationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvBCOInterpolateImageFunctionTest.tif ${TEMP}/bfTvBCOInterpolateImageFunctionTest.tif otbBCOInterpolateImageFunctionTest ${INPUTDATA}/poupees.tif ${TEMP}/bfTvBCOInterpolateImageFunctionTest.tif 3 # radius -0.5 # optimised bicubic ) otb_add_test(NAME bfTuBCOInterpolateImageFunctionNew COMMAND otbInterpolationTestDriver otbBCOInterpolateImageFunctionNew ) otb_add_test(NAME bfTvBCOInterpolateImageFunctionOverVectorImage COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvBCOInterpolateImageFunctionOverVectorImageOutput.txt ${TEMP}/bfTvBCOInterpolateImageFunctionOverVectorImageOutput.txt otbBCOInterpolateImageFunctionOverVectorImage ${INPUTDATA}/poupees.tif ${TEMP}/bfTvBCOInterpolateImageFunctionOverVectorImageOutput.txt 3 # radius -0.5 # optimised bicubic 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTuBCOInterpolateImageFunctionOverVectorImageNew COMMAND otbInterpolationTestDriver otbBCOInterpolateImageFunctionOverVectorImageNew) otb_add_test(NAME bfTvBCOInterpolateImageFunction2 COMMAND otbInterpolationTestDriver otbBCOInterpolateImageFunction2 3 # radius -0.5 # optimised bicubic 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTvBCOInterpolateImageFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvBCOInterpolateImageFunctionOutput.txt ${TEMP}/bfTvBCOInterpolateImageFunctionOutput.txt otbBCOInterpolateImageFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfTvBCOInterpolateImageFunctionOutput.txt 3 # radius -0.5 # optimised bicubic 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTvProlateInterpolateImageFunction COMMAND otbInterpolationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfProlateInterpolateImageFunctionOutput.txt ${TEMP}/bfProlateInterpolateImageFunctionOutput.txt otbProlateInterpolateImageFunction ${INPUTDATA}/poupees.tif ${TEMP}/bfProlateInterpolateImageFunctionOutput.txt ${TEMP}/bfProlateInterpolateImageFunctionCosOutput.tif ${TEMP}/bfProlateInterpolateImageFunctionITKCosOutput.tif ${TEMP}/bfProlateInterpolateImageFunctionProOutput.tif 3 # radius 0.5 0.5 127.33 44.9 259.67 21.43 12.13 61.79 89.5 11 128 128 127.255 128.73 -1 -1 ) otb_add_test(NAME bfTvProlateValidationTest COMMAND otbInterpolationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvProlateValidationTest.tif ${TEMP}/bfTvProlateValidationTest.tif otbProlateValidationTest ${INPUTDATA}/poupees.tif ${TEMP}/bfTvProlateValidationTest.tif 3 # radius 0.5 # factor 512 # size ${TEMP}/defaultprolatevalidationtest.tif # nearest neighborhood interpolator : NOT GENERATE IN THE TEST ) OTB-release-5.8/Modules/Core/Interpolation/test/otbBCOInterpolateImageFunction.cxx000066400000000000000000000247121301006202600302460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbBCOInterpolateImageFunction.h" #include "otbImageFileReader.h" #include #include "otbImageFileWriter.h" #include "otbStreamingResampleImageFilter.h" int otbBCOInterpolateImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::BCOInterpolateImageFunction InterpolatorType; // Instantiating object InterpolatorType::Pointer interp = InterpolatorType::New(); std::cout << interp << std::endl; return EXIT_SUCCESS; } int otbBCOInterpolateImageFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int radius = atoi(argv[3]); const double alpha = atof(argv[4]); typedef otb::Image ImageType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; int i = 5; std::vector indicesList; while (i < argc && (i + 1) < argc) { ContinuousIndexType idx; idx[0] = atof(argv[i]); idx[1] = atof(argv[i + 1]); indicesList.push_back(idx); i += 2; } // Instantiating object InterpolatorType::Pointer filter = InterpolatorType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); //TODO check if necessary std::cout << "Alpha Checking : " << std::endl << filter->GetAlpha() << std::endl; filter->SetAlpha(-1.0); std::cout << filter->GetAlpha() << std::endl; filter->SetAlpha(alpha); std::cout << filter->GetAlpha() << std::endl; std::cout << "Radius Checking : " << std::endl << filter->GetRadius() << std::endl; filter->SetRadius(radius); std::cout << filter->GetRadius() << std::endl; filter->SetInputImage(reader->GetOutput()); std::ofstream file; file.open(outfname); for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << filter->EvaluateAtContinuousIndex((*it)) << std::endl; } file.close(); return EXIT_SUCCESS; } int otbBCOInterpolateImageFunction2(int argc, char * argv[]) { typedef otb::Image ImageType; ImageType::Pointer inputImage = ImageType::New(); const unsigned int N = 100; ImageType::SizeType size; size.Fill(N); ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); inputImage->SetLargestPossibleRegion( region ); inputImage->SetBufferedRegion( region ); inputImage->SetRequestedRegion( region ); inputImage->SetNumberOfComponentsPerPixel(1); inputImage->Allocate(); typedef itk::ImageRegionIterator IteratorType; IteratorType it1(inputImage, region); for (it1.GoToBegin(); !it1.IsAtEnd(); ++it1) it1.Set(1.0); const unsigned int radius = atoi(argv[1]); const double alpha = atof(argv[2]); typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; std::vector indicesList; for (int i=3; i+1 < argc; i=i+2) { ContinuousIndexType idx; idx[0] = atof(argv[i]); idx[1] = atof(argv[i + 1]); std::cout << idx[0] << " " << idx[1] << std::endl; indicesList.push_back(idx); } // Instantiating object InterpolatorType::Pointer filter = InterpolatorType::New(); ReaderType::Pointer reader = ReaderType::New(); std::cout << "Alpha Checking : " << std::endl << filter->GetAlpha() << std::endl; filter->SetAlpha(-1.0); std::cout << filter->GetAlpha() << std::endl; filter->SetAlpha(alpha); std::cout << filter->GetAlpha() << std::endl; std::cout << "Radius Checking : " << std::endl << filter->GetRadius() << std::endl; filter->SetRadius(radius); std::cout << filter->GetRadius() << std::endl; filter->SetInputImage(inputImage); for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { std::cout << (*it) << " -> " << filter->EvaluateAtContinuousIndex((*it)) << std::endl; if (vcl_abs(filter->EvaluateAtContinuousIndex((*it))-1.0)>1e-6) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbBCOInterpolateImageFunctionOverVectorImageNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorImage ImageType; typedef otb::BCOInterpolateImageFunction InterpolatorType; // Instantiating object InterpolatorType::Pointer filter = InterpolatorType::New(); return EXIT_SUCCESS; } int otbBCOInterpolateImageFunctionOverVectorImage(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int radius = atoi(argv[3]); const double alpha = atof(argv[4]); typedef otb::VectorImage ImageType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; int i = 5; std::vector indicesList; while (i < argc && (i + 1) < argc) { ContinuousIndexType idx; idx[0] = atof(argv[i]); idx[1] = atof(argv[i + 1]); indicesList.push_back(idx); i += 2; } // Instantiating object InterpolatorType::Pointer filter = InterpolatorType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); //TODO check if necessary std::cout << "Alpha Checking : " << std::endl << filter->GetAlpha() << std::endl; filter->SetAlpha(-1.0); std::cout << filter->GetAlpha() << std::endl; filter->SetAlpha(alpha); std::cout << filter->GetAlpha() << std::endl; std::cout << "Radius Checking : " << std::endl << filter->GetRadius() << std::endl; filter->SetRadius(radius); std::cout << filter->GetRadius() << std::endl; filter->SetInputImage(reader->GetOutput()); std::ofstream file; file.open(outfname); for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << filter->EvaluateAtContinuousIndex((*it)) << std::endl; } file.close(); return EXIT_SUCCESS; } int otbBCOInterpolateImageFunctionTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int radius = atoi(argv[3]); const double alpha = atof(argv[4]); typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::ImageFileWriter WriterType; // Instantiating objects ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); reader->SetFileName(infname); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(radius); interpolator->SetAlpha(alpha); resampler->SetInput(reader->GetOutput()); resampler->SetInterpolator(interpolator); StreamingResampleImageFilterType::SizeType size; size[0] = 256; size[1] = 256; resampler->SetOutputSize(size); resampler->SetOutputSpacing(2); resampler->Update(); // Result of resampler is written writer->SetInput(resampler->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } int otbBCOInterpolateImageFunctionVectorImageTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int radius = atoi(argv[3]); const double alpha = atof(argv[4]); typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::ImageFileWriter WriterType; // Instantiating objects ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); reader->SetFileName(infname); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(radius); interpolator->SetAlpha(alpha); resampler->SetInput(reader->GetOutput()); resampler->SetInterpolator(interpolator); StreamingResampleImageFilterType::SizeType size; size[0] = 256; size[1] = 256; resampler->SetOutputSize(size); resampler->SetOutputSpacing(2); resampler->Update(); // Result of resampler is written writer->SetInput(resampler->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbBSplineDecompositionImageFilter.cxx000066400000000000000000000031431301006202600311600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbBSplineDecompositionImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbBSplineDecompositionImageFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::BSplineDecompositionImageFilter BSplineDecompositionImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object BSplineDecompositionImageFilterType::Pointer filter = BSplineDecompositionImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); writer->SetFileName(outfname); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbBSplineDecompositionImageFilterNew.cxx000066400000000000000000000021401301006202600316260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbBSplineDecompositionImageFilter.h" #include "otbImage.h" int otbBSplineDecompositionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::BSplineDecompositionImageFilter BSplineDecompositionImageFilterType; // Instantiating object BSplineDecompositionImageFilterType::Pointer filter = BSplineDecompositionImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbBSplineInterpolateImageFunction.cxx000066400000000000000000000037151301006202600311770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbBSplineInterpolateImageFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" #include int otbBSplineInterpolateImageFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::BSplineInterpolateImageFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; int i = 3; std::vector indicesList; while (i < argc && (i + 1) < argc) { ContinuousIndexType idx; idx[0] = atof(argv[i]); idx[1] = atof(argv[i + 1]); indicesList.push_back(idx); i += 2; } // Instantiating object InterpolatorType::Pointer interpolator = InterpolatorType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); std::ofstream file; file.open(outfname); for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << interpolator->EvaluateAtContinuousIndex((*it)) << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbBSplineInterpolateImageFunctionNew.cxx000066400000000000000000000020621301006202600316430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbBSplineInterpolateImageFunction.h" #include "otbImage.h" int otbBSplineInterpolateImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::BSplineInterpolateImageFunction InterpolatorType; // Instantiating object InterpolatorType::Pointer filter = InterpolatorType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbGenericInterpolateImageFunctionNew.cxx000066400000000000000000000033701301006202600316660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbGenericInterpolateImageFunction.h" #include "otbImage.h" namespace Function { template class SameFunction { public: void SetRadius(unsigned int rad) { m_Radius = rad; } unsigned int GetRadius() const { return m_Radius; } inline TOutput operator ()(const TInput& A) const { return static_cast(A); } unsigned int m_Radius; }; } int otbGenericInterpolateImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; const int Dimension = 2; typedef otb::Image ImageType; typedef Function::SameFunction FunctionType; typedef itk::ConstantBoundaryCondition BoundaryConditionType; typedef double CoordRepType; typedef otb::GenericInterpolateImageFunction GenericFunctionType; // Instantiating object GenericFunctionType::Pointer generic = GenericFunctionType::New(); std::cout << generic << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbInterpolationTestDriver.cxx000066400000000000000000000034421301006202600276230ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbWindowedSincInterpolateImageCosineFunctionNew); REGISTER_TEST(otbWindowedSincInterpolateImageLanczosFunction); REGISTER_TEST(otbWindowedSincInterpolateImageLanczosFunctionNew); REGISTER_TEST(otbWindowedSincInterpolateImageFunctionBaseNew); REGISTER_TEST(otbProlateInterpolateImageFunctionNew); REGISTER_TEST(otbBSplineDecompositionImageFilterNew); REGISTER_TEST(otbBSplineInterpolateImageFunctionNew); REGISTER_TEST(otbWindowedSincInterpolateImageBlackmanFunction); REGISTER_TEST(otbBSplineDecompositionImageFilter); REGISTER_TEST(otbWindowedSincInterpolateImageWelchFunctionNew); REGISTER_TEST(otbWindowedSincInterpolateImageGaussianFunction); REGISTER_TEST(otbGenericInterpolateImageFunctionNew); REGISTER_TEST(otbWindowedSincInterpolateImageBlackmanFunctionNew); REGISTER_TEST(otbWindowedSincInterpolateImageCosineFunction); REGISTER_TEST(otbWindowedSincInterpolateImageHammingFunction); REGISTER_TEST(otbWindowedSincInterpolateImageWelchFunction); REGISTER_TEST(otbBSplineInterpolateImageFunction); REGISTER_TEST(otbWindowedSincInterpolateImageGaussianFunctionNew); REGISTER_TEST(otbWindowedSincInterpolateImageHammingFunctionNew); REGISTER_TEST(otbStreamingTraitsImage); REGISTER_TEST(otbStreamingTraitsVectorImage); REGISTER_TEST(otbBCOInterpolateImageFunction); REGISTER_TEST(otbBCOInterpolateImageFunctionNew); REGISTER_TEST(otbBCOInterpolateImageFunction2); REGISTER_TEST(otbBCOInterpolateImageFunctionOverVectorImageNew); REGISTER_TEST(otbBCOInterpolateImageFunctionOverVectorImage); REGISTER_TEST(otbBCOInterpolateImageFunctionTest); REGISTER_TEST(otbBCOInterpolateImageFunctionVectorImageTest); REGISTER_TEST(otbProlateInterpolateImageFunction); REGISTER_TEST(otbProlateValidationTest); } OTB-release-5.8/Modules/Core/Interpolation/test/otbProlateInterpolateImageFunction.cxx000066400000000000000000000121751301006202600312510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbProlateInterpolateImageFunction.h" #include "otbImageFileReader.h" #include #include "otbImageFileWriter.h" #include "itkResampleImageFilter.h" #include "otbImageFileWriter.h" #include "otbStreamingResampleImageFilter.h" #include "otbWindowedSincInterpolateImageGaussianFunction.h" #include "otbWindowedSincInterpolateImageHammingFunction.h" #include "otbWindowedSincInterpolateImageCosineFunction.h" #include "itkWindowedSincInterpolateImageFunction.h" int otbProlateInterpolateImageFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const char * cosfname = argv[3]; const char * itkcosfname = argv[4]; const char * profname = argv[5]; typedef otb::Image ImageType; typedef otb::ProlateInterpolateImageFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; unsigned int i = 7; std::vector indicesList; while (i < static_cast(argc) && (i + 1) < static_cast(argc)) { ContinuousIndexType idx; idx[0] = atof(argv[i]); idx[1] = atof(argv[i + 1]); indicesList.push_back(idx); i += 2; } // Instantiating object InterpolatorType::Pointer prolate = InterpolatorType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); prolate->SetInputImage(reader->GetOutput()); prolate->SetRadius(atoi(argv[6])); prolate->Initialize(); std::ofstream file; file.open(outfname); for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << prolate->EvaluateAtContinuousIndex((*it)) << std::endl; } file.close(); /**********************************************************/ //typedef otb::ImageFileWriter WriterType; //typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::ImageFileWriter WriterType; typedef itk::ResampleImageFilter StreamingResampleImageFilterType; WriterType::Pointer prowriter = WriterType::New(); StreamingResampleImageFilterType::Pointer proresampler = StreamingResampleImageFilterType::New(); InterpolatorType::Pointer pro = InterpolatorType::New(); // Resampler connected to input image proresampler->SetInput(reader->GetOutput()); pro->SetInputImage(reader->GetOutput()); pro->SetRadius(atoi(argv[6])); pro->Initialize(); proresampler->SetInterpolator(pro); StreamingResampleImageFilterType::SizeType size; size[0] = 512; size[1] = 512; double tutu = 1; proresampler->SetSize(size); proresampler->SetOutputSpacing(tutu); // Result of resampler is written prowriter->SetInput(proresampler->GetOutput()); //prowriter->SetNumberOfDivisionsStrippedStreaming(1); prowriter->SetFileName(profname); prowriter->Update(); typedef otb::WindowedSincInterpolateImageCosineFunction CosInterpolatorType; typedef itk::Function::CosineWindowFunction<1, double, double> itkCosType; typedef itk::WindowedSincInterpolateImageFunction itkCosInterpolatorType; WriterType::Pointer itkcoswriter = WriterType::New(); WriterType::Pointer coswriter = WriterType::New(); StreamingResampleImageFilterType::Pointer cosresampler = StreamingResampleImageFilterType::New(); StreamingResampleImageFilterType::Pointer itkcosresampler = StreamingResampleImageFilterType::New(); CosInterpolatorType::Pointer cos = CosInterpolatorType::New(); itkCosInterpolatorType::Pointer itkcos = itkCosInterpolatorType::New(); cosresampler->SetSize(size); cosresampler->SetOutputSpacing(tutu); itkcosresampler->SetSize(size); itkcosresampler->SetOutputSpacing(tutu); cosresampler->SetInput(reader->GetOutput()); cos->SetInputImage(reader->GetOutput()); cos->SetRadius(atoi(argv[6])); cos->Initialize(); cosresampler->SetInterpolator(cos); itkcosresampler->SetInput(reader->GetOutput()); itkcosresampler->SetInterpolator(itkcos); coswriter->SetInput(cosresampler->GetOutput()); coswriter->SetFileName(cosfname); itkcoswriter->SetInput(itkcosresampler->GetOutput()); itkcoswriter->SetFileName(itkcosfname); coswriter->Update(); itkcoswriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbProlateInterpolateImageFunctionNew.cxx000066400000000000000000000020511301006202600317130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbProlateInterpolateImageFunction.h" #include "otbImage.h" int otbProlateInterpolateImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::ProlateInterpolateImageFunction ProlateInterpolatorType; // Instantiating object ProlateInterpolatorType::Pointer prolate = ProlateInterpolatorType::New(); std::cout << prolate << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbProlateValidationTest.cxx000066400000000000000000000063351301006202600272450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbProlateInterpolateImageFunction.h" #include "itkNearestNeighborInterpolateImageFunction.h" #include "otbImageFileReader.h" #include #include "otbImageFileWriter.h" #include "otbStreamingResampleImageFilter.h" int otbProlateValidationTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int rad = atoi(argv[3]); const double factor = atof(argv[4]); //const char * defaultoutfname = argv[6]; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::ProlateInterpolateImageFunction InterpolatorType; //typedef InterpolatorType::FunctionType FunctionType; //typedef itk::NearestNeighborInterpolateImageFunction DefaultInterpolatorType; //DefaultInterpolatorType::Pointer def = DefaultInterpolatorType::New(); InterpolatorType::Pointer prolate = InterpolatorType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer prowriter = WriterType::New(); StreamingResampleImageFilterType::Pointer proresampler = StreamingResampleImageFilterType::New(); reader->SetFileName(infname); reader->UpdateOutputInformation(); ImageType::PointType origin = reader->GetOutput()->GetOrigin(); ImageType::SpacingType spacing = reader->GetOutput()->GetSpacing(); ImageType::SpacingType newSpacing; newSpacing[0] = spacing[0] * factor; newSpacing[1] = spacing[1] * factor; prolate->SetInputImage(reader->GetOutput()); prolate->SetRadius(rad); prolate->Initialize(); std::cout << "Originalprofilsize: " << prolate->GetFunction().GetOriginalProfileSize() << std::endl; std::cout << "Energy : " << prolate->GetFunction().ComputeEnergy(1 / factor) << std::endl; std::cout << "Radius : " << prolate->GetRadius() << std::endl; std::cout << "Factor : " << factor << std::endl; proresampler->SetInput(reader->GetOutput()); proresampler->SetInterpolator(prolate); StreamingResampleImageFilterType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[5]); proresampler->SetOutputSize(size); proresampler->SetOutputOrigin(origin); proresampler->SetOutputSpacing(newSpacing); prowriter->SetInput(proresampler->GetOutput()); prowriter->SetFileName(outfname); prowriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbStreamingTraits.cxx000066400000000000000000000046661301006202600261110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingTraits.h" #include "otbImage.h" #include const unsigned int Dimension = 2; typedef double PixelType; template void TestInstantiate() { typename TInterpolatorType::Pointer instance = TInterpolatorType::New(); std::cout << instance << std::endl; } int otbStreamingTraitsImage(int itkNotUsed(argc), char* itkNotUsed(argv) []) { // Images definition typedef otb::Image ImageType; typedef otb::StreamingTraits StreamingTraits; // Check that all internal types can be instantiated TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); return EXIT_SUCCESS; } int otbStreamingTraitsVectorImage(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Images definition typedef otb::VectorImage ImageType; typedef otb::StreamingTraits StreamingTraits; // Check that all internal types can be instantiated TestInstantiate(); TestInstantiate(); TestInstantiate(); TestInstantiate(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageBlackmanFunction.cxx000066400000000000000000000042111301006202600336610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageBlackmanFunction.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbWindowedSincInterpolateImageBlackmanFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageBlackmanFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); unsigned int i = 4; std::vector indicesList; while (i < static_cast(argc) && (i + 1) < static_cast(argc)) { ContinuousIndexType idx1; idx1[0] = atof(argv[i]); idx1[1] = atof(argv[i + 1]); indicesList.push_back(idx1); i += 2; } ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); interp->SetInputImage(reader->GetOutput()); interp->SetRadius(atoi(argv[3])); interp->Initialize(); std::ofstream file; file.open(outfname); file << "Blackman Window Function" << std::endl; for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << interp->EvaluateAtContinuousIndex((*it)) << std::endl; } file << std::endl; file.close(); return EXIT_SUCCESS; } otbWindowedSincInterpolateImageBlackmanFunctionNew.cxx000066400000000000000000000021121301006202600342520ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Interpolation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageBlackmanFunction.h" #include "otbImage.h" int otbWindowedSincInterpolateImageBlackmanFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageBlackmanFunction InterpolatorType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); std::cout << interp << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageCosineFunction.cxx000066400000000000000000000041751301006202600334020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageCosineFunction.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbWindowedSincInterpolateImageCosineFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageCosineFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); unsigned int i = 4; std::vector indicesList; while (i < static_cast(argc) && (i + 1) < static_cast(argc)) { ContinuousIndexType idx1; idx1[0] = atof(argv[i]); idx1[1] = atof(argv[i + 1]); indicesList.push_back(idx1); i += 2; } ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); interp->SetInputImage(reader->GetOutput()); interp->SetRadius(atoi(argv[3])); interp->Initialize(); std::ofstream file; file.open(outfname); file << "Cosine Window Function" << std::endl; for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << interp->EvaluateAtContinuousIndex((*it)) << std::endl; } file << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageCosineFunctionNew.cxx000066400000000000000000000021021301006202600340400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageCosineFunction.h" #include "otbImage.h" int otbWindowedSincInterpolateImageCosineFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageCosineFunction InterpolatorType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); std::cout << interp << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageFunctionBaseNew.cxx000066400000000000000000000031541301006202600335020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageFunctionBase.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" namespace Function { template class SameFunction { public: void SetRadius(unsigned int rad) { m_Radius = rad; } unsigned int GetRadius() const { return m_Radius; } inline TOutput operator ()(const TInput& A) const { return static_cast(A); } unsigned int m_Radius; }; } int otbWindowedSincInterpolateImageFunctionBaseNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef Function::SameFunction FunctionType; typedef otb::WindowedSincInterpolateImageFunctionBase WindowedSincInterpolatorType; // Instantiating object WindowedSincInterpolatorType::Pointer winInterp = WindowedSincInterpolatorType::New(); std::cout << winInterp << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageGaussianFunction.cxx000066400000000000000000000041551301006202600337320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageGaussianFunction.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbWindowedSincInterpolateImageGaussianFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; // Gaussian typedef otb::WindowedSincInterpolateImageGaussianFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); unsigned int i = 4; std::vector indicesList; while (i < static_cast(argc) && (i + 1) < static_cast(argc)) { ContinuousIndexType idx1; idx1[0] = atof(argv[i]); idx1[1] = atof(argv[i + 1]); indicesList.push_back(idx1); i += 2; } ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); interp->SetInputImage(reader->GetOutput()); interp->SetRadius(atoi(argv[3])); interp->Initialize(); std::ofstream file; file.open(outfname); file << "Gauss Window Function" << std::endl; for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << interp->EvaluateAtContinuousIndex((*it)) << std::endl; } file << std::endl; file.close(); return EXIT_SUCCESS; } otbWindowedSincInterpolateImageGaussianFunctionNew.cxx000066400000000000000000000021121301006202600343140ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Interpolation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageGaussianFunction.h" #include "otbImage.h" int otbWindowedSincInterpolateImageGaussianFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageGaussianFunction InterpolatorType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); std::cout << interp << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageHammingFunction.cxx000066400000000000000000000042031301006202600335320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageHammingFunction.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbWindowedSincInterpolateImageHammingFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageHammingFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); unsigned int i = 4; std::vector indicesList; while (i < static_cast(argc) && (i + 1) < static_cast(argc)) { ContinuousIndexType idx1; idx1[0] = atof(argv[i]); idx1[1] = atof(argv[i + 1]); indicesList.push_back(idx1); i += 2; } ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); interp->SetInputImage(reader->GetOutput()); interp->SetRadius(atoi(argv[3])); interp->Initialize(); std::ofstream file; file.open(outfname); file << "Hamming Window Function" << std::endl; for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << interp->EvaluateAtContinuousIndex((*it)) << std::endl; } file << std::endl; file.close(); return EXIT_SUCCESS; } otbWindowedSincInterpolateImageHammingFunctionNew.cxx000066400000000000000000000021061301006202600341250ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Interpolation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageHammingFunction.h" #include "otbImage.h" int otbWindowedSincInterpolateImageHammingFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageHammingFunction InterpolatorType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); std::cout << interp << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageLanczosFunction.cxx000066400000000000000000000042031301006202600335630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageLanczosFunction.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbWindowedSincInterpolateImageLanczosFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageLanczosFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); unsigned int i = 4; std::vector indicesList; while (i < static_cast(argc) && (i + 1) < static_cast(argc)) { ContinuousIndexType idx1; idx1[0] = atof(argv[i]); idx1[1] = atof(argv[i + 1]); indicesList.push_back(idx1); i += 2; } ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); interp->SetInputImage(reader->GetOutput()); interp->SetRadius(atoi(argv[3])); interp->Initialize(); std::ofstream file; file.open(outfname); file << "Lanczos Window Function" << std::endl; for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << interp->EvaluateAtContinuousIndex((*it)) << std::endl; } file << std::endl; file.close(); return EXIT_SUCCESS; } otbWindowedSincInterpolateImageLanczosFunctionNew.cxx000066400000000000000000000021061301006202600341560ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Interpolation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageLanczosFunction.h" #include "otbImage.h" int otbWindowedSincInterpolateImageLanczosFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageLanczosFunction InterpolatorType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); std::cout << interp << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageWelchFunction.cxx000066400000000000000000000041671301006202600332250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageWelchFunction.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbWindowedSincInterpolateImageWelchFunction(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageWelchFunction InterpolatorType; typedef InterpolatorType::ContinuousIndexType ContinuousIndexType; typedef otb::ImageFileReader ReaderType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); unsigned int i = 4; std::vector indicesList; while (i < static_cast(argc) && (i + 1) < static_cast(argc)) { ContinuousIndexType idx1; idx1[0] = atof(argv[i]); idx1[1] = atof(argv[i + 1]); indicesList.push_back(idx1); i += 2; } ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); interp->SetInputImage(reader->GetOutput()); interp->SetRadius(atoi(argv[3])); interp->Initialize(); std::ofstream file; file.open(outfname); file << "Welch Window Function" << std::endl; for (std::vector::iterator it = indicesList.begin(); it != indicesList.end(); ++it) { file << (*it) << " -> " << interp->EvaluateAtContinuousIndex((*it)) << std::endl; } file << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Interpolation/test/otbWindowedSincInterpolateImageWelchFunctionNew.cxx000066400000000000000000000020761301006202600336740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWindowedSincInterpolateImageWelchFunction.h" #include "otbImage.h" int otbWindowedSincInterpolateImageWelchFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::WindowedSincInterpolateImageWelchFunction InterpolatorType; // Instantiating objects InterpolatorType::Pointer interp = InterpolatorType::New(); std::cout << interp << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/000077500000000000000000000000001301006202600173735ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/LabelMap/CMakeLists.txt000066400000000000000000000000471301006202600221340ustar00rootroot00000000000000project(OTBLabelMap) otb_module_impl() OTB-release-5.8/Modules/Core/LabelMap/include/000077500000000000000000000000001301006202600210165ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/LabelMap/include/otbAttributesMapLabelObject.h000066400000000000000000000215651301006202600265600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAttributesMapLabelObject_h #define otbAttributesMapLabelObject_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include "itkShapeLabelObject.h" #pragma GCC diagnostic pop #else #include "itkShapeLabelObject.h" #endif #include "otbPolygon.h" #include namespace otb { namespace Functor { /** \class AttributesMapLabelObjectAccessor * \brief Allows accessing a given field of an AttributesMapLabelObject * * The name of the attribute to retrieve can be set by using the * SetAttributeName method. * * \sa AttributesMapLabelObject * * \ingroup OTBLabelMap */ template class ITK_EXPORT AttributesMapLabelObjectAccessor { public: // The Label Object typedef typedef TLabelObject LabelObjectType; typedef typename LabelObjectType::AttributesValueType AttributeValueType; /** * Please note that no exception catching is done here. * \param labelObject The pointer to the label object * \return The attribute value. */ inline const AttributeValueType operator ()(LabelObjectType * labelObject) const { return labelObject->GetAttribute(m_AttributeName.c_str()); } /// Set the name of the attribute to retrieve void SetAttributeName(const char * name) { m_AttributeName = name; } /// Get the the name of the attribute to retrieve const char * GetAttributeName() const { return m_AttributeName.c_str(); } /// Constructor AttributesMapLabelObjectAccessor() : m_AttributeName("") {} /// Destructor ~AttributesMapLabelObjectAccessor() {} private: /// Name of the attribute to retrieve std::string m_AttributeName; }; /** \class AttributesMapMeasurementFunctor * \brief This class allows building a measurement vector from an AttributesMapLabelObject * * It Allows selecting only a subset of the available attributes. * * \ingroup OTBLabelMap */ template class AttributesMapMeasurementFunctor { public: typedef std::vector AttributesListType; inline TMeasurementVector operator()(const TLabelObject * object) const { TMeasurementVector newSample(m_Attributes.size()); unsigned int attrIndex = 0; typename AttributesListType::const_iterator attrIt = m_Attributes.begin(); while(attrIt != m_Attributes.end()) { newSample[attrIndex] = object->GetAttribute(attrIt->c_str()); ++attrIt; ++attrIndex; } return newSample; } /** Add an attribute to the exported attributes list */ void AddAttribute(const char * attr) { m_Attributes.push_back(attr); } /** Remove an attribute from the exported attributes list */ void RemoveAttribute(const char * attr) { AttributesListType::iterator elt = std::find(m_Attributes.begin(), m_Attributes.end(), attr); if(elt!=m_Attributes.end()) { m_Attributes.erase(elt); } } /** Remove all attributes from the exported attributes list */ void ClearAttributes() { m_Attributes.clear(); } /** Get The number of exported attributes */ unsigned int GetNumberOfAttributes() { return m_Attributes.size(); } private: AttributesListType m_Attributes; }; } // end namespace Functor /** \class AttributesMapLabelObject * \brief A LabelObject with a generic attributes map * * This class derives from itk::LabelObject and extends it to * store pairs of key, value (of type TAttributesValue) in an internal * map container. * * As such it allows storing any custom attributes as necessary. * * \sa LabelObject, ShapeLabelObject, StatisticsLabelObject * * \ingroup DataRepresentation * * \ingroup OTBLabelMap */ template class ITK_EXPORT AttributesMapLabelObject : public itk::LabelObject { public: /** Standard class typedefs */ typedef AttributesMapLabelObject Self; typedef itk::LabelObject Superclass; typedef typename Superclass::LabelObjectType LabelObjectType; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::WeakPointer ConstWeakPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(AttributesMapLabelObject, LabelObject); itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /// Type of a label map using an AttributesMapLabelObject typedef itk::LabelMap LabelMapType; /// Template parameters typedef typedef TLabel LabelType; typedef TAttributesValue AttributesValueType; // Convenient inherited typedefs typedef typename Superclass::IndexType IndexType; typedef typename Superclass::LineType LineType; typedef typename Superclass::LengthType LengthType; /// Map container typedefs typedef std::map AttributesMapType; typedef typename AttributesMapType::iterator AttributesMapIteratorType; typedef typename AttributesMapType::const_iterator AttributesMapConstIteratorType; // The polygon corresponding to the label object typedef Polygon PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; /** * Set an attribute value. * If the key name already exists in the map, the value is overwritten. */ void SetAttribute(const char * name, AttributesValueType value) { m_Attributes[name] = value; } /** * Set an attribute value. * If the key name already exists in the map, the value is overwritten. */ void SetAttribute(const std::string& name, AttributesValueType value) { this->SetAttribute(name.c_str(), value); } /** * Returns the attribute corresponding to name */ AttributesValueType GetAttribute(const char * name) const { AttributesMapConstIteratorType it = m_Attributes.find(name); if (it != m_Attributes.end()) { return it->second; } else { itkExceptionMacro(<< "Could not find attribute named " << name); } } /** * Returns the total number of attributes */ unsigned int GetNumberOfAttributes() const { return m_Attributes.size(); } /** * Returns the list of available attributes */ std::vector GetAvailableAttributes() const { std::vector attributesNames; AttributesMapConstIteratorType it = m_Attributes.begin(); while (it != m_Attributes.end()) { attributesNames.push_back(it->first); ++it; } return attributesNames; } /** * This method is overloaded to add the copy of the attributes map. */ virtual void CopyAttributesFrom(const LabelObjectType * lo) { Superclass::CopyAttributesFrom(lo); // copy the data of the current type if possible const Self * src = dynamic_cast(lo); if (src == ITK_NULLPTR) { return; } m_Attributes = src->m_Attributes; } /** Return the polygon (const version) */ const PolygonType * GetPolygon() const { return m_Polygon; } /** Return the polygon (non const version) */ PolygonType * GetPolygon() { return m_Polygon; } /** Set the polygon */ void SetPolygon(PolygonType* p) { m_Polygon = p; } protected: /** Constructor */ AttributesMapLabelObject() : m_Attributes(), m_Polygon(PolygonType::New()) {} /** Destructor */ ~AttributesMapLabelObject() ITK_OVERRIDE {} /** The printself method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << indent << "Attributes: " << std::endl; for (AttributesMapConstIteratorType it = m_Attributes.begin(); it != m_Attributes.end(); ++it) { os << indent << indent << it->first << " = " << it->second << std::endl; } } private: AttributesMapLabelObject(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The attributes map */ AttributesMapType m_Attributes; /** The polygon corresponding to the label object. Caution, this * will be empty by default */ PolygonPointerType m_Polygon; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbAttributesMapLabelObjectWithClassLabel.h000066400000000000000000000107511301006202600313350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAttributesMapLabelObjectWithClassLabel_h #define otbAttributesMapLabelObjectWithClassLabel_h #include "otbAttributesMapLabelObject.h" namespace otb { /** \class AttributesMapLabelObjectWithClassLabel * \brief An AttributesMapLabelObject with an optional class label. * * The label type is defined by the template parameter TClassLabel and * accessible using the ClassLabelType typedef. * * The HasClassLabel() method returns true if the LabelObject has a * class label and false otherwise. * * The SetClassLabel() method set the class label and set the internal flag * m_HasClassLabel to true. * * The GetClassLabel() method returns the class label or an exception if m_HasClassLabel * is set to false. * * The RemoveClassLabel() method set m_HasClassLabel to false and the * class label value to a default value. * *\sa LabelObject, ShapeLabelObject, StatisticsLabelObject * * \ingroup DataRepresentation * * \ingroup OTBLabelMap */ template < class TLabel, unsigned int VImageDimension, class TAttributesValue, class TClassLabel > class ITK_EXPORT AttributesMapLabelObjectWithClassLabel : public AttributesMapLabelObject { public: /** Standard class typedefs */ typedef AttributesMapLabelObjectWithClassLabel Self; typedef AttributesMapLabelObject Superclass; typedef itk::LabelObject LabelObjectType; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::WeakPointer ConstWeakPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(AttributesMapLabelObjectWithClassLabel, AttributesMapLabelObject); itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Class label typedef */ typedef TClassLabel ClassLabelType; /** Set the class label */ void SetClassLabel(const ClassLabelType& label) { m_ClassLabel = label; m_HasClassLabel = true; } /** Get the class label. Throws an exception if no class label is * available */ const ClassLabelType & GetClassLabel() const { if(!m_HasClassLabel) { itkExceptionMacro(<<"LabelObject has no class label!"); } return m_ClassLabel; } /** \return true if a class label is available */ bool HasClassLabel() const { return m_HasClassLabel; } /** Invalidate the class label if any */ void RemoveClassLabel() { m_ClassLabel = itk::NumericTraits::Zero; m_HasClassLabel = false; } void CopyAttributesFrom( const LabelObjectType * lo ) ITK_OVERRIDE { Superclass::CopyAttributesFrom( lo ); // copy the data of the current type if possible const Self * src = dynamic_cast( lo ); if( src == ITK_NULLPTR ) { return; } m_ClassLabel = src->m_ClassLabel; m_HasClassLabel = src->m_HasClassLabel; } protected: /** Constructor */ AttributesMapLabelObjectWithClassLabel() : m_ClassLabel(itk::NumericTraits::Zero), m_HasClassLabel(false) {} /** Destructor */ ~AttributesMapLabelObjectWithClassLabel() ITK_OVERRIDE {} /** The printself method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf( os, indent ); if(m_HasClassLabel) { os< class ITK_EXPORT AttributesMapOpeningLabelMapFilter : public itk::AttributeOpeningLabelMapFilter > { public: /** Standard class typedefs. */ typedef AttributesMapOpeningLabelMapFilter Self; typedef itk::AttributeOpeningLabelMapFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::AttributeAccessorType AttributeAccessorType; /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(AttributesMapOpeningLabelMapFilter, itk::AttributeOpeningLabelMapFilter); /** Set the name of the attribute to perform opening on */ void SetAttributeName(const char * name); /** Get the name of the attribute to perform opening on */ const char * GetAttributeName(); void SetAccessor(const AttributeAccessorType& accessor); AttributeAccessorType & GetAccessor(); void GenerateData() ITK_OVERRIDE; protected: /** Constructor */ AttributesMapOpeningLabelMapFilter(); /** Destructor */ ~AttributesMapOpeningLabelMapFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: AttributesMapOpeningLabelMapFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented AttributeAccessorType m_Accessor; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAttributesMapOpeningLabelMapFilter.txx" #endif #endif // otbAttributesMapOpeningLabelMapFilter_h OTB-release-5.8/Modules/Core/LabelMap/include/otbAttributesMapOpeningLabelMapFilter.txx000066400000000000000000000062151301006202600311440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAttributesMapOpeningLabelMapFilter_txx #define otbAttributesMapOpeningLabelMapFilter_txx #include "otbAttributesMapOpeningLabelMapFilter.h" namespace otb { template AttributesMapOpeningLabelMapFilter ::AttributesMapOpeningLabelMapFilter() { } template AttributesMapOpeningLabelMapFilter ::~AttributesMapOpeningLabelMapFilter() { } /** Set the name of the attribute to perform opening on */ template void AttributesMapOpeningLabelMapFilter ::SetAttributeName(const char * name) { this->GetAccessor().SetAttributeName(name); } /** Get the name of the attribute to perform opening on */ template const char * AttributesMapOpeningLabelMapFilter ::GetAttributeName() { return this->GetAccessor().GetAttributeName(); } template void AttributesMapOpeningLabelMapFilter ::SetAccessor(const AttributeAccessorType& accessor) { m_Accessor = accessor; this->Modified(); } template typename AttributesMapOpeningLabelMapFilter::AttributeAccessorType & AttributesMapOpeningLabelMapFilter ::GetAccessor() { return m_Accessor; } template void AttributesMapOpeningLabelMapFilter ::GenerateData() { // Allocate the output this->AllocateOutputs(); typename Superclass::ImageType * output = this->GetOutput(); typename Superclass::ImageType * output2 = this->GetOutput( 1 ); // set the background value for the second output - this is not done in the superclasses output2->SetBackgroundValue( output->GetBackgroundValue() ); //AttributeAccessorType accessor; itk::ProgressReporter progress( this, 0, output->GetNumberOfLabelObjects() ); typename Superclass::ImageType::Iterator it( output ); while( ! it.IsAtEnd() ) { typename Superclass::LabelObjectType::LabelType label = it.GetLabel(); typename Superclass::LabelObjectType * labelObject = it.GetLabelObject(); if( ( !this->GetReverseOrdering() && m_Accessor( labelObject ) < this->GetLambda() ) || ( this->GetReverseOrdering() && m_Accessor( labelObject ) > this->GetLambda() ) ) { // must increment the iterator before removing the object to avoid invalidating the iterator ++it; output2->AddLabelObject( labelObject ); output->RemoveLabel( label ); } else { ++it; } progress.CompletedPixel(); } } template void AttributesMapOpeningLabelMapFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbBandsStatisticsAttributesLabelMapFilter.h000066400000000000000000000155141301006202600316170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBandsStatisticsAttributesLabelMapFilter_h #define otbBandsStatisticsAttributesLabelMapFilter_h #include "otbStatisticsAttributesLabelMapFilter.h" #include "otbMultiToMonoChannelExtractROI.h" namespace otb { namespace Functor { /** \class BandStatsAttributesLabelObjectFunctor * \brief Functor to compute bands statistics attributes. * * For one label object, this functors applies the * StatisticsAttributesLabelObjectFunctor one each feature image * provided through AddFeature() * * As such, it allows computing in one pass statistics related to * multiple features. It is used in the * BandsStatisticsAttributesLabelMapFilter. * * Features can be added, removed or cleared via the appropriate * methods. * * \sa BandsStatisticsAttributesLabelMapFilter * \sa StatisticsAttributesLabelObjectFunctor * * \ingroup OTBLabelMap */ template class BandStatsAttributesLabelObjectFunctor { public: // Self typedef typedef BandStatsAttributesLabelObjectFunctor Self; /// Typedef of the feature image type typedef typename TFeatureImage::PixelType FeatureType; /// Typedef of the label object typedef TLabelObject LabelObjectType; /// Feature image const pointer typedef typename TFeatureImage::ConstPointer FeatureImageConstPointer; /// Statistics functor typedef StatisticsAttributesLabelObjectFunctor StatsFunctorType; /// Map to store the functors typedef std::map StatsFunctorsMapType; /** Constructor */ BandStatsAttributesLabelObjectFunctor(); /** Destructor */ virtual ~BandStatsAttributesLabelObjectFunctor(); /** The comparators */ bool operator !=(const Self& self); bool operator ==(const Self& self); /** This is the functor implementation * Calling the functor on a label object * will update its statistics attributes */ inline void operator ()(LabelObjectType * lo) const; /** Add a feature with the given name */ void AddFeature(const std::string& name, const TFeatureImage * img); /** Remove the feature with this name if it exists */ bool RemoveFeature(const std::string& name); /** Get the feature image with this name */ const TFeatureImage * GetFeatureImage(const std::string& name) const; /** Clear all the features */ void ClearAllFeatures(); /** Get the number of features */ unsigned int GetNumberOfFeatures() const; /** Set the reduced attribute set */ void SetReducedAttributeSet(bool flag); /** Get the reduced attribute set */ bool GetReducedAttributeSet() const; private: /// True to compute only a reduced attribute set bool m_ReducedAttributeSet; /// The Stat functors map StatsFunctorsMapType m_StatsFunctorsMap; }; } // End namespace Functor /** \class BandsStatisticsAttributesLabelMapFilter * \brief This filter computes band statistics attributes for each object. * * Images are supposed to be compatible with otb::VectorImage * * This filter internally applies the * StatisticsAttributesLabelMapFilter on each channel independently * * The feature name is constructed as: * 'STATS' + '::' + 'Band' + band_index + '::' + statistic_name * * The ReducedAttributesSet flag allows telling the internal * statistics filter to compute only the main attributes (mean, variance, skewness and kurtosis). * * \sa MultiStatsAttributesLabelObjectFunctor AttributesMapLabelObject * * \ingroup ImageEnhancement MathematicalMorphologyImageFilters * * \ingroup OTBLabelMap */ template class ITK_EXPORT BandsStatisticsAttributesLabelMapFilter : public LabelMapFeaturesFunctorImageFilter > > { public: /** Some convenient typedefs. */ typedef TImage ImageType; typedef typename ImageType::RegionType InputImageRegionType; typedef typename ImageType::LabelObjectType LabelObjectType; typedef TFeatureImage FeatureImageType; typedef typename FeatureImageType::InternalPixelType FeatureInternalPixelType; typedef double InternalPrecisionType; typedef Image InternalImageType; /** Functor typedef */ typedef Functor::BandStatsAttributesLabelObjectFunctor FunctorType; /** Standard class typedefs. */ typedef BandsStatisticsAttributesLabelMapFilter Self; typedef LabelMapFeaturesFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename ImageType::Pointer ImagePointer; /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(BandsStatisticsAttributesLabelMapFilter, LabelMapFeaturesFunctorImageFilter); /** Set the feature image */ void SetFeatureImage(const TFeatureImage *input); /** Get the feature image */ const FeatureImageType * GetFeatureImage() const; /** Set the reduced attribute set */ void SetReducedAttributeSet(bool flag); /** Get the reduced attribute set */ bool GetReducedAttributeSet() const; itkBooleanMacro(ReducedAttributeSet); protected: /** Constructor */ BandsStatisticsAttributesLabelMapFilter(); /** Destructor */ ~BandsStatisticsAttributesLabelMapFilter() ITK_OVERRIDE {} void AllocateOutputs() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void EnlargeOutputRequestedRegion(itk::DataObject *) ITK_OVERRIDE{}; /** Before threaded data generation */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BandsStatisticsAttributesLabelMapFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // end of class } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbBandsStatisticsAttributesLabelMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbBandsStatisticsAttributesLabelMapFilter.txx000066400000000000000000000221701301006202600322070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBandsStatisticsAttributesLabelMapFilter_txx #define otbBandsStatisticsAttributesLabelMapFilter_txx #include "otbBandsStatisticsAttributesLabelMapFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkVectorIndexSelectionCastImageFilter.h" namespace otb { namespace Functor { /** Constructor */ template BandStatsAttributesLabelObjectFunctor ::BandStatsAttributesLabelObjectFunctor() : m_ReducedAttributeSet(true), m_StatsFunctorsMap() {} /** Destructor */ template BandStatsAttributesLabelObjectFunctor ::~BandStatsAttributesLabelObjectFunctor(){} /** The comparators */ template bool BandStatsAttributesLabelObjectFunctor ::operator != (const Self &self) { bool resp = true; resp = resp && (m_ReducedAttributeSet != self.m_ReducedAttributeSet); resp = resp && (m_StatsFunctorsMap != self.m_StatsFunctorsMap); return resp; } template bool BandStatsAttributesLabelObjectFunctor ::operator == (const Self &self) { return !(this != self); } /** This is the functor implementation * Calling the functor on a label object * will update its statistics attributes */ template void BandStatsAttributesLabelObjectFunctor ::operator() (LabelObjectType * lo) const { // Walk every registered functors for (typename StatsFunctorsMapType::const_iterator it = m_StatsFunctorsMap.begin(); it != m_StatsFunctorsMap.end(); ++it) { (it->second)(lo); } } /** Add a feature with the given name */ template void BandStatsAttributesLabelObjectFunctor ::AddFeature(const std::string& name, const TFeatureImage * img) { // Create a new functor StatsFunctorType newFunctor; // Set the reduced attribute set option newFunctor.SetReducedAttributeSet(m_ReducedAttributeSet); // Set the feature and its name newFunctor.SetFeatureName(name); // Set the feature image newFunctor.SetFeatureImage(img); // Add it to the map m_StatsFunctorsMap[name] = newFunctor; } /** Remove the feature with this name if it exists */ template bool BandStatsAttributesLabelObjectFunctor ::RemoveFeature(const std::string& name) { return (m_StatsFunctorsMap.erase(name) == 1); } /** Get the feature image with this name */ template const TFeatureImage * BandStatsAttributesLabelObjectFunctor ::GetFeatureImage(const std::string& name) const { if (m_StatsFunctorsMap.count(name) == 0) { itkGenericExceptionMacro(<< "No feature named " << name << " in map."); } return m_StatsFunctorsMap[name].GetFeatureImage(); } /** Clear all the features */ template void BandStatsAttributesLabelObjectFunctor ::ClearAllFeatures() { m_StatsFunctorsMap.clear(); } /** Get the number of features */ template unsigned int BandStatsAttributesLabelObjectFunctor ::GetNumberOfFeatures() const { return m_StatsFunctorsMap.size(); } /** Set the reduced attribute set */ template void BandStatsAttributesLabelObjectFunctor ::SetReducedAttributeSet(bool flag) { // Set the flag m_ReducedAttributeSet = flag; // Set the flag to all the already existing functors for (typename StatsFunctorsMapType::iterator it = m_StatsFunctorsMap.begin(); it != m_StatsFunctorsMap.end(); ++it) { it->second.SetReducedAttributeSet(m_ReducedAttributeSet); } } /** Get the reduced attribute set */ template bool BandStatsAttributesLabelObjectFunctor ::GetReducedAttributeSet() const { return m_ReducedAttributeSet; } } // End namespace Functor template BandsStatisticsAttributesLabelMapFilter ::BandsStatisticsAttributesLabelMapFilter() { this->SetNumberOfRequiredInputs(2); } /** Set the feature image */ template void BandsStatisticsAttributesLabelMapFilter ::SetFeatureImage(const TFeatureImage *input) { // Set the Nth input this->SetNthInput(1, const_cast(input)); } /** Get the feature image */ template const typename BandsStatisticsAttributesLabelMapFilter ::FeatureImageType * BandsStatisticsAttributesLabelMapFilter ::GetFeatureImage() const { return static_cast(this->itk::ProcessObject::GetInput(1)); } /** Set the reduced attribute set */ template void BandsStatisticsAttributesLabelMapFilter ::SetReducedAttributeSet(bool flag) { if (this->GetFunctor().GetReducedAttributeSet() != flag) { this->GetFunctor().SetReducedAttributeSet(flag); this->Modified(); } } /** Get the reduced attribute set */ template bool BandsStatisticsAttributesLabelMapFilter ::GetReducedAttributeSet() const { return this->GetFunctor().GetReducedAttributeSet(); } template void BandsStatisticsAttributesLabelMapFilter ::AllocateOutputs() { // if told to run in place and the types support it, if( this->GetInPlace() && this->CanRunInPlace() ) { // Graft this first input to the output. Later, we'll need to // remove the input's hold on the bulk data. // ImagePointer inputAsOutput = dynamic_cast(const_cast(this->GetInput())); if( inputAsOutput ) { this->GraftOutput( inputAsOutput ); this->GetOutput()->SetLargestPossibleRegion(this->GetOutput()->GetLargestPossibleRegion()); this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); this->GetOutput()->SetBufferedRegion(this->GetOutput()->GetBufferedRegion()); } // If there are more than one outputs, allocate the remaining outputs for (unsigned int i=1; i < this->GetNumberOfOutputs(); ++i) { ImagePointer outputPtr; outputPtr = this->GetOutput(i); outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); } } else { // Superclass::AllocateOutputs(); // copy the content of the input image to the output image (will be done by ImageSource AllocateOutputs Method) // would never occur : inputasoutput condition is always true, since output and input type is TImage for // BandsStatisticsAttributesLabelMapFilter class } } template void BandsStatisticsAttributesLabelMapFilter ::GenerateInputRequestedRegion() { itk::ImageToImageFilter::GenerateInputRequestedRegion(); } template void BandsStatisticsAttributesLabelMapFilter ::BeforeThreadedGenerateData() { // First call superclass implementation Superclass::BeforeThreadedGenerateData(); unsigned long nbComponents = this->GetFeatureImage()->GetNumberOfComponentsPerPixel(); // Clear any previous feature this->GetFunctor().ClearAllFeatures(); // Add each band of the feature image to the statistics functor for (unsigned int i = 0; i < nbComponents; ++i) { typedef itk::VectorIndexSelectionCastImageFilter VectorIndexSelectionCastImageFilterType; typename VectorIndexSelectionCastImageFilterType::Pointer band = VectorIndexSelectionCastImageFilterType::New(); band->SetInput(this->GetFeatureImage()); band->SetIndex(i); band->UpdateOutputInformation(); band->GetOutput()->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); band->Update(); std::ostringstream oss; oss << "Band" << i + 1; // [1..N] convention in feature naming this->GetFunctor().AddFeature(oss.str(), band->GetOutput()); } } template void BandsStatisticsAttributesLabelMapFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbImageToLabelMapWithAttributesFilter.h000066400000000000000000000072661301006202600307030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToLabelMapWithAttributesFilter_h #define otbImageToLabelMapWithAttributesFilter_h #include "itkShapeLabelMapFilter.h" #include "otbAttributesMapLabelObjectWithClassLabel.h" #include "otbLabelImageToLabelMapWithAdjacencyFilter.h" #include "otbShapeAttributesLabelMapFilter.h" #include "otbBandsStatisticsAttributesLabelMapFilter.h" #include "otbLabelMapWithClassLabelToClassLabelImageFilter.h" namespace otb { /** \class ImageToLabelMapWithAttributesFilter * \brief Convert a labeled image to a label map with adjacency information * and computes feature attributes for each LabelObject * * Convert a labeled image and its associated vector image * to a label map with adjacency information, and computes shape and * radiometric attributes for each LabelObject. * * It is suitable to be used with otb::LabelMapWithAdjacency * * \ingroup OTBLabelMap */ template class ITK_EXPORT ImageToLabelMapWithAttributesFilter : public itk::ImageToImageFilter< TInputImage, LabelMapWithAdjacency > { public: /** Standard class typedefs */ typedef ImageToLabelMapWithAttributesFilter Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ImageToImageFilter< TInputImage, LabelMapWithAdjacency > Superclass; /** Standard type macro */ itkTypeMacro(ImageToLabelMapWithAttributesFilter, itk::ImageToImageFilter); /** New macro*/ itkNewMacro(Self); typedef TInputImage InputImageType; typedef TLabeledImage LabeledImageType; typedef TLabelObject LabelObjectType; typedef typename LabelObjectType::LabelType LabelType; typedef LabelMapWithAdjacency LabelMapType; typedef typename LabelMapType::AdjacentLabelsContainerType AdjacentLabelsContainerType; typedef LabelImageToLabelMapWithAdjacencyFilter LabelMapFilterType; typedef ShapeAttributesLabelMapFilter ShapeLabelMapFilterType; typedef BandsStatisticsAttributesLabelMapFilter BandStatisticsLabelMapFilterType; using Superclass::SetInput; void SetInput( const InputImageType *image) ITK_OVERRIDE; virtual void SetLabeledImage( const LabeledImageType * image); const InputImageType * GetInput(void); const LabeledImageType * GetLabeledImage(); virtual LabelMapType* GetOutput(); void GenerateData() ITK_OVERRIDE; protected: /** Constructor */ ImageToLabelMapWithAttributesFilter(); /** Destructor */ ~ImageToLabelMapWithAttributesFilter() ITK_OVERRIDE{}; void GenerateInputRequestedRegion() ITK_OVERRIDE; private: ImageToLabelMapWithAttributesFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented typename LabelMapType::Pointer m_Output; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToLabelMapWithAttributesFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbImageToLabelMapWithAttributesFilter.txx000066400000000000000000000123501301006202600312650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToLabelMapWithAttributesFilter_txx #define otbImageToLabelMapWithAttributesFilter_txx #include "otbImageToLabelMapWithAttributesFilter.h" #include "itkProcessObject.h" namespace otb { template ImageToLabelMapWithAttributesFilter ::ImageToLabelMapWithAttributesFilter() { m_Output = LabelMapType::New(); this->itk::ProcessObject::SetNumberOfRequiredInputs(2); } template void ImageToLabelMapWithAttributesFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // We need all the input. typename InputImageType::Pointer input = const_cast< InputImageType * >( this->GetInput() ); if ( !input ) { return; } input->SetRequestedRegion( input->GetLargestPossibleRegion() ); } template void ImageToLabelMapWithAttributesFilter ::SetInput( const InputImageType *image) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast< InputImageType * >( image ) ); } template void ImageToLabelMapWithAttributesFilter ::SetLabeledImage( const LabeledImageType *image) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast( image ) ); } template const typename ImageToLabelMapWithAttributesFilter::InputImageType * ImageToLabelMapWithAttributesFilter ::GetInput() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } template const typename ImageToLabelMapWithAttributesFilter::LabeledImageType* ImageToLabelMapWithAttributesFilter ::GetLabeledImage() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1) ); } template typename ImageToLabelMapWithAttributesFilter ::LabelMapType* ImageToLabelMapWithAttributesFilter ::GetOutput() { return dynamic_cast< LabelMapType* > (this->Superclass::GetOutput(0)); } template void ImageToLabelMapWithAttributesFilter ::GenerateData() { typename InputImageType::Pointer inputImage = const_cast(this->GetInput()); typename LabeledImageType::Pointer labeldImage = const_cast(this->GetLabeledImage()); // Convert to label map typename LabelMapFilterType::Pointer lfilter = LabelMapFilterType::New(); lfilter->SetBackgroundValue(itk::NumericTraits::max()); lfilter->SetInput(labeldImage); // Compute shape attributes typename ShapeLabelMapFilterType::Pointer shapeLabelMapFilter = ShapeLabelMapFilterType::New(); shapeLabelMapFilter->SetInput(lfilter->GetOutput()); // Compute radiometric attributes typename BandStatisticsLabelMapFilterType::Pointer bandStatsLabelMapFilter = BandStatisticsLabelMapFilterType::New(); bandStatsLabelMapFilter->SetInput(shapeLabelMapFilter->GetOutput()); bandStatsLabelMapFilter->SetFeatureImage(inputImage); // Get the label map bandStatsLabelMapFilter->GetOutput()->SetAdjacencyMap(lfilter->GetOutput()->GetAdjacencyMap()); bandStatsLabelMapFilter->GraftOutput( this->GetOutput() ); // execute the mini-pipeline bandStatsLabelMapFilter->Update(); // graft the mini-pipeline output back onto this filter's output. this->GraftOutput( bandStatsLabelMapFilter->GetOutput() ); } } #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbKMeansAttributesLabelMapFilter.h000066400000000000000000000121241301006202600276650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKMeansAttributesLabelMapFilter_h #define otbKMeansAttributesLabelMapFilter_h #include "itkLabelMapFilter.h" #include "otbLabelMapWithClassLabelToLabeledSampleListFilter.h" #include "itkListSample.h" #include "itkWeightedCentroidKdTreeGenerator.h" #include "itkKdTreeBasedKmeansEstimator.h" namespace otb { /** \class KMeansAttributesLabelMapFilter * \brief Execute a KMeans on the attributes of a itk::LabelMap * * \ingroup OTBLabelMap */ template class ITK_EXPORT KMeansAttributesLabelMapFilter : public itk::Object { public: /** Standard class typedefs. */ typedef KMeansAttributesLabelMapFilter Self; typedef itk::LabelMapFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::LabelObjectType LabelObjectType; typedef itk::DataObject DataObjectType; typedef DataObjectType::Pointer DataObjectPointerType; // LabelObject attributes typedef typename LabelObjectType::AttributesValueType AttributesValueType; typedef typename LabelObjectType::ClassLabelType ClassLabelType; // LabelMapToSampleList typedef itk::VariableLengthVector VectorType; typedef itk::FixedArray ClassLabelVectorType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::ListSample TrainingListSampleType; typedef otb::LabelMapWithClassLabelToLabeledSampleListFilter< InputImageType, ListSampleType, TrainingListSampleType> LabelMapToSampleListFilterType; typedef typename LabelMapToSampleListFilterType::MeasurementFunctorType MeasurementFunctorType; // KMeans typedef itk::Statistics::WeightedCentroidKdTreeGenerator TreeGeneratorType; typedef typename TreeGeneratorType::KdTreeType TreeType; typedef itk::Statistics::KdTreeBasedKmeansEstimator EstimatorType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef std::vector CentroidsVectorType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(KMeansAttributesLabelMapFilter, itk::Object); /** Return the centroids resulting from the KMeans */ CentroidsVectorType& GetCentroids() { return m_Centroids; } const CentroidsVectorType& GetCentroids() const { return m_Centroids; } itkSetObjectMacro(InputLabelMap, InputImageType); itkGetObjectMacro(InputLabelMap, InputImageType); /** Set the number of classes of the input sample list. * It will be used to choose the number of centroids. * In the one-class case, 10 centroids is chosen. Otherwise, * a number of centroids equal to the number of classes */ itkSetMacro(NumberOfClasses, unsigned int); itkGetMacro(NumberOfClasses, unsigned int); MeasurementFunctorType& GetMeasurementFunctor() { return m_LabelMapToSampleListFilter->GetMeasurementFunctor(); } void SetMeasurementFunctor(MeasurementFunctorType& functor) { m_LabelMapToSampleListFilter->SetMeasurementFunctor(functor); } void Compute(); protected: KMeansAttributesLabelMapFilter(); ~KMeansAttributesLabelMapFilter() ITK_OVERRIDE {}; private: KMeansAttributesLabelMapFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented InputImagePointer m_InputLabelMap; CentroidsVectorType m_Centroids; typename LabelMapToSampleListFilterType::Pointer m_LabelMapToSampleListFilter; unsigned int m_NumberOfClasses; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKMeansAttributesLabelMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbKMeansAttributesLabelMapFilter.txx000066400000000000000000000113221301006202600302600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKMeansAttributesLabelMapFilter_txx #define otbKMeansAttributesLabelMapFilter_txx #include "otbKMeansAttributesLabelMapFilter.h" #include "itkNumericTraits.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { template KMeansAttributesLabelMapFilter ::KMeansAttributesLabelMapFilter() : m_LabelMapToSampleListFilter(LabelMapToSampleListFilterType::New()), m_NumberOfClasses(1) { } template void KMeansAttributesLabelMapFilter ::Compute() { m_LabelMapToSampleListFilter->SetInputLabelMap(m_InputLabelMap); m_LabelMapToSampleListFilter->Update(); typename ListSampleType::Pointer listSamples = const_cast(m_LabelMapToSampleListFilter->GetOutputSampleList()); typename TrainingListSampleType::Pointer trainingSamples = const_cast(m_LabelMapToSampleListFilter->GetOutputTrainingSampleList()); // Build the Kd Tree typename TreeGeneratorType::Pointer kdTreeGenerator = TreeGeneratorType::New(); kdTreeGenerator->SetSample(listSamples); kdTreeGenerator->SetBucketSize(100); kdTreeGenerator->Update(); // Randomly pick the initial means among the classes unsigned int sampleSize = listSamples->GetMeasurementVector(0).Size(); const unsigned int OneClassNbCentroids = 10; unsigned int numberOfCentroids = (m_NumberOfClasses == 1 ? OneClassNbCentroids : m_NumberOfClasses); typename EstimatorType::ParametersType initialMeans(sampleSize * m_NumberOfClasses); initialMeans.Fill(0.); if (m_NumberOfClasses > 1) { // For each class, choose a centroid as the first sample of this class encountered for (ClassLabelType classLabel = 0; classLabel < m_NumberOfClasses; ++classLabel) { typename TrainingListSampleType::ConstIterator it = trainingSamples->Begin(); // Iterate on the label list and stop when classLabel is found // TODO: add random initialization ? for (it = trainingSamples->Begin(); it != trainingSamples->End(); ++it) { std::cout <<" Training Samples is "<< it.GetMeasurementVector()[0] << std::endl; if (it.GetMeasurementVector()[0] == classLabel) break; } if (it == trainingSamples->End()) { itkExceptionMacro(<<"Unable to find a sample with class label "<< classLabel); } typename ListSampleType::InstanceIdentifier identifier = it.GetInstanceIdentifier(); const typename ListSampleType::MeasurementVectorType& centroid = listSamples->GetMeasurementVector(identifier); for (unsigned int i = 0; i < centroid.Size(); ++i) { initialMeans[classLabel * sampleSize + i] = centroid[i]; } } } else { typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; RandomGeneratorType::Pointer randomGenerator = RandomGeneratorType::GetInstance(); unsigned int nbLabelObjects = listSamples->Size(); // Choose arbitrarily OneClassNbCentroids centroids among all available LabelObject for (unsigned int centroidId = 0; centroidId < numberOfCentroids; ++centroidId) { typename ListSampleType::InstanceIdentifier identifier = randomGenerator->GetIntegerVariate(nbLabelObjects - 1); const typename ListSampleType::MeasurementVectorType& centroid = listSamples->GetMeasurementVector(identifier); for (unsigned int i = 0; i < centroid.Size(); ++i) { initialMeans[centroidId * sampleSize + i] = centroid[i]; } } } // Run the KMeans algorithm // Do KMeans estimation typename EstimatorType::Pointer estimator = EstimatorType::New(); estimator->SetParameters(initialMeans); estimator->SetKdTree(kdTreeGenerator->GetOutput()); estimator->SetMaximumIteration(10000); estimator->SetCentroidPositionChangesThreshold(0.00001); estimator->StartOptimization(); // Retrieve final centroids m_Centroids.clear(); for(unsigned int cId = 0; cId < numberOfCentroids; ++cId) { VectorType newCenter(sampleSize); for(unsigned int i = 0; i < sampleSize; ++i) { newCenter[i] = estimator->GetParameters()[cId * sampleSize + i]; } m_Centroids.push_back(newCenter); } } }// end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelImageToLabelMapWithAdjacencyFilter.h000066400000000000000000000132771301006202600313750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageToLabelMapWithAdjacencyFilter_h #define otbLabelImageToLabelMapWithAdjacencyFilter_h #include "itkImageToImageFilter.h" #include "otbLabelMapWithAdjacency.h" #include "itkLabelObject.h" namespace otb { /** \class LabelImageToLabelMapWithAdjacencyFilter * \brief convert a labeled image to a label map with adjacency information. * * * \ingroup OTBLabelMap */ template > > class ITK_EXPORT LabelImageToLabelMapWithAdjacencyFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef LabelImageToLabelMapWithAdjacencyFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::IndexType IndexType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::LabelObjectType LabelObjectType; typedef typename OutputImageType::AdjacencyMapType AdjacencyMapType; typedef typename OutputImageType::AdjacentLabelsContainerType AdjacentLabelsContainerType; typedef typename OutputImageType::LabelType LabelType; /** Const iterator over LabelObject lines */ typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(LabelImageToLabelMapWithAdjacencyFilter, ImageToImageFilter); /** * Set/Get the value used as "background" in the output image. * Defaults to NumericTraits::NonpositiveMin(). */ itkSetMacro(BackgroundValue, OutputImagePixelType); itkGetConstMacro(BackgroundValue, OutputImagePixelType); protected: /** Constructor */ LabelImageToLabelMapWithAdjacencyFilter(); /** Destructor */ ~LabelImageToLabelMapWithAdjacencyFilter() ITK_OVERRIDE {}; /** Printself */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; // class to store a RLE class RLE { public: // Location IndexType where; // Length long unsigned int length; // Label unsigned long int label; // Constructor RLE(const IndexType & w, long unsigned int l, unsigned long int la) { where = w; length = l; label = la; } }; // end class RLE // RLE Vector typedef std::vector RLEVectorType; /** LabelImageToLabelMapWithAdjacencyFilter needs the entire input be * available. Thus, it needs to provide an implementation of * GenerateInputRequestedRegion(). */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** LabelImageToLabelMapWithAdjacencyFilter will produce the entire output. */ void EnlargeOutputRequestedRegion(itk::DataObject *itkNotUsed(output)) ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; /** Add a new adjacency */ void AddAdjacency(LabelType label1, LabelType label2, itk::ThreadIdType threadId); /** Parse one line for horizontal adjacency */ void ParseLine(const RLEVectorType & line, itk::ThreadIdType threadId); /** Parse two consecutive lines for vertical adjacency */ void ParseConsecutiveLines(const RLEVectorType& line1, const RLEVectorType& line2, itk::ThreadIdType threadId); private: LabelImageToLabelMapWithAdjacencyFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented OutputImagePixelType m_BackgroundValue; typename std::vector< OutputImagePointer > m_TemporaryImages; typename std::vector m_TemporaryAdjacencyMaps; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelImageToLabelMapWithAdjacencyFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelImageToLabelMapWithAdjacencyFilter.txx000066400000000000000000000312451301006202600317640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageToLabelMapWithAdjacencyFilter_txx #define otbLabelImageToLabelMapWithAdjacencyFilter_txx #include "otbLabelImageToLabelMapWithAdjacencyFilter.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "itkImageLinearConstIteratorWithIndex.h" #include "itkImageRegionConstIteratorWithIndex.h" namespace otb { template LabelImageToLabelMapWithAdjacencyFilter ::LabelImageToLabelMapWithAdjacencyFilter() { m_BackgroundValue = itk::NumericTraits::NonpositiveMin(); } template void LabelImageToLabelMapWithAdjacencyFilter ::GenerateInputRequestedRegion() { for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { InputImagePointer input = const_cast(this->GetInput(idx)); if (!input.IsNull()) { input->SetRequestedRegionToLargestPossibleRegion(); // Check whether the input is an image of the appropriate // dimension (use ProcessObject's version of the GetInput() // method since it returns the input as a pointer to a // DataObject as opposed to the subclass version which // static_casts the input to an TInputImage). // Use the function object RegionCopier to copy the output region // to the input. The default region copier has default implementations // to handle the cases where the input and output are the same // dimension, the input a higher dimension than the output, and the // input a lower dimension than the output. InputImageRegionType inputRegion; this->CallCopyOutputRegionToInputRegion(inputRegion, this->GetOutput()->GetRequestedRegion()); input->SetRequestedRegion( inputRegion ); } } } template void LabelImageToLabelMapWithAdjacencyFilter ::EnlargeOutputRequestedRegion(itk::DataObject *) { } template void LabelImageToLabelMapWithAdjacencyFilter ::BeforeThreadedGenerateData() { // init the temp images - one per thread m_TemporaryImages.resize( this->GetNumberOfThreads() ); // Clear previous adjacency map m_TemporaryAdjacencyMaps.resize( this->GetNumberOfThreads() ); for( unsigned int i=0; iGetNumberOfThreads(); ++i ) { if( i == 0 ) { // the first one is the output image m_TemporaryImages[0] = this->GetOutput(); } else { // the other must be created m_TemporaryImages[i] = OutputImageType::New(); } // set the minimum data needed to create the objects properly m_TemporaryImages[i]->SetBackgroundValue( m_BackgroundValue ); } } template void LabelImageToLabelMapWithAdjacencyFilter ::AddAdjacency(LabelType label1, LabelType label2, itk::ThreadIdType threadId) { // Insert label1 in v neighbors if(m_TemporaryAdjacencyMaps[threadId].find(label2)!= m_TemporaryAdjacencyMaps[threadId].end()) { m_TemporaryAdjacencyMaps[threadId][label2].insert(label1); } else { AdjacentLabelsContainerType newContainer; newContainer.insert(label1); m_TemporaryAdjacencyMaps[threadId][label2]=newContainer; } // Insert label2 in label1s neighbors if(m_TemporaryAdjacencyMaps[threadId].find(label1)!=m_TemporaryAdjacencyMaps[threadId].end()) { m_TemporaryAdjacencyMaps[threadId][label1].insert(label2); } else { AdjacentLabelsContainerType newContainer; newContainer.insert(label2); m_TemporaryAdjacencyMaps[threadId][label1]=newContainer; } } template void LabelImageToLabelMapWithAdjacencyFilter ::ParseLine(const RLEVectorType & line, itk::ThreadIdType threadId) { // Get the first label typename RLEVectorType::const_iterator it = line.begin(); LabelType previousLabel = it->label; ++it; // Iterates on remaining RLE while(it!=line.end()) { // Get the new label LabelType nextLabel = it->label; // Add the adjacency this->AddAdjacency(previousLabel, nextLabel, threadId); // Store previous label previousLabel = nextLabel; ++it; } } template void LabelImageToLabelMapWithAdjacencyFilter ::ParseConsecutiveLines(const RLEVectorType& line1, const RLEVectorType & line2, itk::ThreadIdType threadId) { // Provided to disable fully connected if needed long offset = 1; // Iterate on line1 for(typename RLEVectorType::const_iterator it1 = line1.begin(); it1!=line1.end(); ++it1) { // Delimitate RLE1 long start1 = it1->where[0]; long end1 = start1 + it1->length-1; LabelType label1 = it1->label; // Iterate on line2 for(typename RLEVectorType::const_iterator it2 = line2.begin(); it2!=line2.end(); ++it2) { // Delimitate RLE2 long start2 = it2->where[0]; long end2 = start2 + it2->length-1; LabelType label2 = it2->label; // If labels are different if(label1 != label2) { //Check adjacency if( ( (start1 >= start2 - offset) && (start1 <= end2 + offset) ) || ( (end1 >= start2 - offset) && (end1 <= end2 + offset) ) || ( (start2 >= start1 - offset) && (start2 <= end1 + offset) ) || ( (end2 >= start1 - offset) && (end2 <= end1 + offset) )) { // Add the adjacency this->AddAdjacency(label1, label2, threadId); } } } } } template void LabelImageToLabelMapWithAdjacencyFilter ::ThreadedGenerateData( const OutputImageRegionType& regionForThread, itk::ThreadIdType threadId ) { itk::ProgressReporter progress( this, threadId, regionForThread.GetNumberOfPixels() ); typedef itk::ImageLinearConstIteratorWithIndex< InputImageType > InputLineIteratorType; InputLineIteratorType it( this->GetInput(), regionForThread ); it.SetDirection(0); RLEVectorType currentLine; RLEVectorType previousLine; // Parse previous line if exists typename InputImageType::RegionType previousLineRegion; typename InputImageType::SizeType previousLineRegionSize; typename InputImageType::IndexType previousLineRegionIndex; previousLineRegionIndex = regionForThread.GetIndex(); previousLineRegionIndex[1]--; previousLineRegionSize = regionForThread.GetSize(); previousLineRegionSize[1]=1; previousLineRegion.SetIndex(previousLineRegionIndex); previousLineRegion.SetSize(previousLineRegionSize); // If previous line is still in image if(previousLineRegion.Crop(this->GetInput()->GetRequestedRegion())) { // Build an iterator itk::ImageRegionConstIteratorWithIndex pIt(this->GetInput(), previousLineRegion); pIt.GoToBegin(); // Iterate on line while( !pIt.IsAtEnd() ) { const InputImagePixelType & v = pIt.Get(); if( v != m_BackgroundValue ) { // We've hit the start of a run IndexType idx = pIt.GetIndex(); long length=1; ++pIt; while( !pIt.IsAtEnd() && pIt.Get() == v ) { ++length; ++pIt; } previousLine.push_back(RLE(idx, length, v)); } else { // go the the next pixel ++pIt; } } } for( it.GoToBegin(); !it.IsAtEnd(); it.NextLine() ) { // Go to beginning of line it.GoToBeginOfLine(); // Clear the previous current line currentLine.clear(); // Iterate on line while( !it.IsAtEndOfLine() ) { const InputImagePixelType & v = it.Get(); if( v != m_BackgroundValue ) { // We've hit the start of a run IndexType idx = it.GetIndex(); long length=1; ++it; while( !it.IsAtEndOfLine() && it.Get() == v ) { ++length; ++it; } // create the run length object to go in the vector m_TemporaryImages[threadId]->SetLine( idx, length, v ); currentLine.push_back(RLE(idx, length, v)); } else { // go the the next pixel ++it; } } // if no label object is present on current line we skip the process if(currentLine.size()>0) { // Parse lines for adjacency this->ParseLine(currentLine, threadId); this->ParseConsecutiveLines(previousLine, currentLine, threadId); } // Store previous line previousLine = currentLine; } } template void LabelImageToLabelMapWithAdjacencyFilter ::AfterThreadedGenerateData() { OutputImageType * output = this->GetOutput(); // merge the lines from the temporary images in the output image // don't use the first image - that's the output image for( unsigned int i=1; iGetNumberOfThreads(); ++i ) { typedef typename OutputImageType::LabelObjectVectorType LabelObjectVectorType; const LabelObjectVectorType & labelObjectContainer = m_TemporaryImages[i]->GetLabelObjects(); for( typename LabelObjectVectorType::const_iterator it = labelObjectContainer.begin(); it != labelObjectContainer.end(); ++it ) { LabelObjectType * labelObject = *it; if( output->HasLabel( labelObject->GetLabel() ) ) { // merge the lines in the output's object //ITKv4 iterate over the 2 LabelObjects src and output typedef typename LabelObjectType::ConstLineIterator IteratorType; typename LabelObjectType::LabelObjectType * dest = output->GetLabelObject( labelObject->GetLabel() ); IteratorType srcIt; srcIt = IteratorType( labelObject ); srcIt.GoToBegin(); //ITKv4 Iterate over all lines of the source and add them to the //output labelObject (can use the insert method over the //container anymore (it is now private) while ( !srcIt.IsAtEnd() ) { dest->AddLine(srcIt.GetLine()); ++srcIt; } } else { // simply take the object output->AddLabelObject( labelObject ); } } } // Merge adjacency tables AdjacencyMapType adjMap = m_TemporaryAdjacencyMaps[0]; // For each remaining thread for(itk::ThreadIdType threadId = 1; threadId < this->GetNumberOfThreads(); ++threadId) { // For each label in the thread adjacency map for(typename AdjacencyMapType::const_iterator mit = m_TemporaryAdjacencyMaps[threadId].begin(); mit!= m_TemporaryAdjacencyMaps[threadId].end(); ++mit) { // If the label exists in the main map if(adjMap.find(mit->first) != adjMap.end()) { // We need to merge AdjacentLabelsContainerType adjLabels1 = adjMap[mit->first]; AdjacentLabelsContainerType adjLabels2 = mit->second; std::vector mergedLabels(adjLabels1.size()+adjLabels2.size(), 0); // Merge typename std::vector::const_iterator vend = set_union(adjLabels1.begin(), adjLabels1.end(), adjLabels2.begin(), adjLabels2.end(), mergedLabels.begin()); AdjacentLabelsContainerType mergedLabelsSet; for(typename std::vector::const_iterator vit = mergedLabels.begin(); vit!=vend; ++vit) { mergedLabelsSet.insert(*vit); } // Set the final result adjMap[mit->first]=mergedLabelsSet; } else { // Set the labels adjMap[mit->first]=mit->second; } } } // Set the adjacency map to the output output->SetAdjacencyMap(adjMap); // release the data in the temp images m_TemporaryImages.clear(); m_TemporaryAdjacencyMaps.clear(); } template void LabelImageToLabelMapWithAdjacencyFilter ::PrintSelf(std::ostream &os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "BackgroundValue: " << static_cast::PrintType>(m_BackgroundValue) << std::endl; } }// end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapFeaturesFunctorImageFilter.h000066400000000000000000000070161301006202600305260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapFeaturesFunctorImageFilter_h #define otbLabelMapFeaturesFunctorImageFilter_h #include "itkInPlaceLabelMapFilter.h" namespace otb { /** \class LabelMapFeaturesFunctorImageFilter * \brief This class applies a functor to compute new features * * The functor is applied on each LabelObject, enriching the * available features. * * The LabelObject type must be an AttributeMapLabelObject. * * This filter can not be instantiated on its own, since its purpose * is to provide a base class for all LabelMap attributes enriching filters * * \sa otb::AttributeMapLabelObject * \sa otb::StatisticsAttributesLabelMapFilter * \sa otb::ShapeAttributesLabelMapFilter * \sa otb::RadiometricAttributesLabelMapFilter * \sa otb::BandsStatisticsAttributesLabelMapFilter * \sa itk::InPlaceLabelMapFilter * * \ingroup ImageEnhancement MathematicalMorphologyImageFilters * * \ingroup OTBLabelMap */ template class ITK_EXPORT LabelMapFeaturesFunctorImageFilter : public itk::InPlaceLabelMapFilter { public: /** Standard class typedefs. */ typedef LabelMapFeaturesFunctorImageFilter Self; typedef itk::InPlaceLabelMapFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TImage ImageType; typedef typename ImageType::LabelObjectType LabelObjectType; typedef TFunctor FunctorType; /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Runtime information support. */ itkTypeMacro(LabelMapFeaturesFunctorImageFilter, InPlaceLabelMapFilter); /** Set the functor */ void SetFunctor(FunctorType& functor) { if (m_Functor != functor) { m_Functor = functor; this->Modified(); } } /** Get the functor (const version) */ const FunctorType& GetFunctor() const { return m_Functor; } /** Get a reference to the functor (non const version) */ FunctorType& GetFunctor() { return m_Functor; } protected: /** Constructor */ LabelMapFeaturesFunctorImageFilter() : m_Functor() {} /** Destructor */ ~LabelMapFeaturesFunctorImageFilter() ITK_OVERRIDE {} /** Threaded generate data */ void ThreadedProcessLabelObject(LabelObjectType * labelObject) ITK_OVERRIDE { // Call the functor m_Functor(labelObject); } /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { // Call superclass implementation Superclass::PrintSelf(os, indent); } private: LabelMapFeaturesFunctorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The functor */ FunctorType m_Functor; }; // end of class } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapSource.h000066400000000000000000000043231301006202600245340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapSource_h #define otbLabelMapSource_h #include "itkProcessObject.h" #include "itkMacro.h" namespace otb { /** \class LabelMapSource * \brief Base class for filter that output LabelMap * * \ingroup IO * * * \ingroup OTBLabelMap */ template class ITK_EXPORT LabelMapSource : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef LabelMapSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LabelMapSource, itk::ProcessObject); typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef TOutputLabelMap OutputLabelMapType; typedef typename TOutputLabelMap::Pointer OutputLabelMapPointer; /** Overriding GetOutput() method */ virtual OutputLabelMapType* GetOutput(void); virtual OutputLabelMapType* GetOutput(DataObjectPointerArraySizeType idx); protected: LabelMapSource(); ~LabelMapSource() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Ensure that the output vector data are cleared before processing */ virtual void AllocateOutputs(); private: LabelMapSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapSource.txx" #endif #endif // otbLabelMapSource_h OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapSource.txx000066400000000000000000000041241301006202600251270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapSource_txx #define otbLabelMapSource_txx #include "otbLabelMapSource.h" namespace otb { template LabelMapSource ::LabelMapSource() { this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, OutputLabelMapType::New().GetPointer()); } template LabelMapSource ::~LabelMapSource() { } template void LabelMapSource ::AllocateOutputs() { OutputLabelMapPointer outputPtr; // Allocate the output memory for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { outputPtr = this->GetOutput(i); //TODO Need to implement the Clear Method in the class itk::LabelMap //outputPtr->Clear(); } } template typename LabelMapSource::OutputLabelMapType * LabelMapSource ::GetOutput(void) { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } template typename LabelMapSource::OutputLabelMapType * LabelMapSource ::GetOutput(DataObjectPointerArraySizeType idx) { return static_cast (this->Superclass::GetOutput(idx)); } template void LabelMapSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapToAttributeImageFilter.h000066400000000000000000000102201301006202600276440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToAttributeImageFilter_h #define otbLabelMapToAttributeImageFilter_h #include "itkLabelMapFilter.h" #include "otbAttributesMapLabelObject.h" #include "itkVariableLengthVector.h" namespace otb { /** \class LabelMapToAttributeImageFilter * * \brief This class produces an image from attributes in a label map * * This filter is intended to work on AttributesMapLabelObject. The user chooses * the attributes to display for each channel. The output image is expected to be * a vector image. * * \ingroup OTBLabelMap */ template< class TInputImage, class TOutputImage , class TAttributeAccessor= typename Functor::AttributesMapLabelObjectAccessor< typename TInputImage::LabelObjectType > > class ITK_EXPORT LabelMapToAttributeImageFilter : public itk::LabelMapFilter< TInputImage , TOutputImage > { public: /** Standard class typedefs. */ typedef LabelMapToAttributeImageFilter Self; typedef itk::LabelMapFilter < TInputImage , TOutputImage > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard New method. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LabelMapToAttributeImageFilter, LabelMapFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType; typedef typename LabelObjectType::AttributesMapType AttributesMapType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::IndexType IndexType; typedef itk::VariableLengthVector VectorPixelType; typedef std::vector< std::string > AttributeListType; typedef TAttributeAccessor AttributeAccessorType; typedef typename AttributeAccessorType::AttributeValueType AttributeValueType; /** Get macro for background value */ itkGetConstMacro(BackgroundValue, OutputInternalPixelType); /** Set macro for background value */ itkSetMacro(BackgroundValue, OutputInternalPixelType); /** Get the current chosen attributes */ const AttributeListType & GetChosenAttributes() { return m_ChosenAttributes; } /** Set the chosen attributes */ void SetChosenAttributes(AttributeListType & newAttributes); /** Get the number of components of the output image */ unsigned int GetNumberOfComponentsPerPixel(); /** Fill the given channel with value from the given attribute */ bool SetAttributeForNthChannel(unsigned int channel, const char *attribute); /** Fill the given channel with value from the given attribute */ bool SetAttributeForNthChannel(unsigned int channel, const std::string& attribute) { return this->SetAttributeForNthChannel(channel, attribute.c_str()); } protected: LabelMapToAttributeImageFilter(); ~LabelMapToAttributeImageFilter() ITK_OVERRIDE {}; void GenerateOutputInformation() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedProcessLabelObject( LabelObjectType * labelObject ) ITK_OVERRIDE; private: /** Background pixel value */ OutputInternalPixelType m_BackgroundValue; /** List of chosen attributes */ AttributeListType m_ChosenAttributes; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapToAttributeImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapToAttributeImageFilter.txx000066400000000000000000000104121301006202600302430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToAttributeImageFilter_txx #define otbLabelMapToAttributeImageFilter_txx #include "otbLabelMapToAttributeImageFilter.h" #include "otbMacro.h" namespace otb { /** Constructor */ template LabelMapToAttributeImageFilter ::LabelMapToAttributeImageFilter() { m_ChosenAttributes.resize(0); m_BackgroundValue = static_cast(0); } template void LabelMapToAttributeImageFilter ::SetChosenAttributes(AttributeListType & newAttributes) { m_ChosenAttributes = newAttributes; } template unsigned int LabelMapToAttributeImageFilter ::GetNumberOfComponentsPerPixel() { return m_ChosenAttributes.size(); } template bool LabelMapToAttributeImageFilter ::SetAttributeForNthChannel(unsigned int channel, const char *attribute) { std::string strAttribute(attribute); if (strAttribute.size() == 0) { otbWarningMacro("Attribute name is empty"); return false; } if( channel void LabelMapToAttributeImageFilter ::GenerateOutputInformation() { if (this->GetOutput() && this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetNumberOfComponentsPerPixel(GetNumberOfComponentsPerPixel()); } } template void LabelMapToAttributeImageFilter ::BeforeThreadedGenerateData() { //first call superclass method to initialize label object container and progress Superclass::BeforeThreadedGenerateData(); unsigned int nbChannels = GetNumberOfComponentsPerPixel(); if (nbChannels == 0) { itkExceptionMacro("No attribute given"); } OutputImageType *output = this->GetOutput(); OutputPixelType backgroundPixel; backgroundPixel.SetSize(nbChannels); for (unsigned int k=0; kFillBuffer( backgroundPixel ); } template void LabelMapToAttributeImageFilter ::ThreadedProcessLabelObject( LabelObjectType * labelObject ) { unsigned int nbChannels = GetNumberOfComponentsPerPixel(); OutputImageType *output = this->GetOutput(); AttributeAccessorType accessor; OutputPixelType outPixel; outPixel.SetSize(nbChannels); for (unsigned int k=0; k(attribute); } ConstLineIteratorType lit = ConstLineIteratorType ( labelObject ); while( !lit.IsAtEnd() ) { IndexType idx = lit.GetLine().GetIndex(); unsigned long length = lit.GetLine().GetLength(); for( unsigned int i=0; iSetPixel( idx, outPixel ); idx[0]++; } ++lit; } } } #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapToLabelImageFilter.h000066400000000000000000000071061301006202600267310ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkLabelMapToLabelImageFilter.h, v $ Language: C++ Date: $Date: 2009-07-30 22:54:24 $ Version: $Revision: 1.3 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToLabelImageFilter_h #define otbLabelMapToLabelImageFilter_h #include "itkLabelMapToLabelImageFilter.h" namespace otb { /** \class LabelMapToLabelImageFilter * \brief Converts a LabelMap to a labeled image. * * LabelMapToBinaryImageFilter to a label image. * * \author Gaetan Lehmann. Biologie du Developement et de la Reproduction, INRA de Jouy-en-Josas, France. * * This implementation was taken from the Insight Journal paper: * http://hdl.handle.net/1926/584 or * http://www.insight-journal.org/browse/publication/176 * * \sa LabelMapToBinaryImageFilter, LabelMapMaskImageFilter * \ingroup ImageEnhancement MathematicalMorphologyImageFilters * \ingroup LabeledImageFilters * * \ingroup OTBLabelMap */ template class ITK_EXPORT LabelMapToLabelImageFilter : public itk::LabelMapToLabelImageFilter { public: /** Standard class typedefs. */ typedef LabelMapToLabelImageFilter Self; typedef itk::LabelMapToLabelImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::LabelObjectType LabelObjectType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::IndexType IndexType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(LabelMapToLabelImageFilter, ImageToImageFilter); protected: LabelMapToLabelImageFilter(); ~LabelMapToLabelImageFilter() {}; void GenerateInputRequestedRegion(); void EnlargeOutputRequestedRegion(itk::DataObject *){}; private: LabelMapToLabelImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; // end of class } // end namespace otb #ifndef ITK_MANUAL_INSTANTIATION #include "otbLabelMapToLabelImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapToLabelImageFilter.txx000066400000000000000000000025401301006202600273220ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkLabelMapToLabelImageFilter.txx, v $ Language: C++ Date: $Date: 2009-05-16 22:19:31 $ Version: $Revision: 1.2 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToLabelImageFilter_txx #define otbLabelMapToLabelImageFilter_txx #include "otbLabelMapToLabelImageFilter.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "itkImageRegionConstIteratorWithIndex.h" namespace otb { template LabelMapToLabelImageFilter ::LabelMapToLabelImageFilter() { } template void LabelMapToLabelImageFilter ::GenerateInputRequestedRegion() { itk::ImageToImageFilter::GenerateInputRequestedRegion(); } }// end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapToSampleListFilter.h000066400000000000000000000075631301006202600270330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToSampleListFilter_h #define otbLabelMapToSampleListFilter_h #include #include "itkProcessObject.h" #include "otbAttributesMapLabelObject.h" namespace otb { /** \class LabelMapToSampleListFilter * * \brief This class converts a LabelObjectMap to a SampleList for * learning and classification. * * The conversion from label object to measurement vector is made * through a functor. This allows supporting any kind of LabelObject * via proper redefinition of the functor. * * \ingroup OTBLabelMap */ template > class ITK_EXPORT LabelMapToSampleListFilter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef LabelMapToSampleListFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LabelMapToSampleListFilter, ProcessObject); /** template typedefs */ typedef TInputLabelMap InputLabelMapType; typedef typename InputLabelMapType::ConstPointer InputLabelMapConstPointerType; typedef typename InputLabelMapType::LabelObjectType LabelObjectType; typedef typename InputLabelMapType::ConstIterator ConstIteratorType; typedef TOutputSampleList OutputSampleListType; typedef typename OutputSampleListType::Pointer OutputSampleListPointerType; typedef typename OutputSampleListType ::MeasurementVectorType MeasurementVectorType; typedef TMeasurementFunctor MeasurementFunctorType; /** DataObject typedef*/ typedef typename Superclass::DataObjectPointer DataObjectPointerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Set/Get the input label map */ void SetInputLabelMap(const InputLabelMapType * inputLabelMap); const InputLabelMapType* GetInputLabelMap() const; /** Get the output SampleList*/ const OutputSampleListType* GetOutputSampleList(); /** Get a hook on the functor for settings */ void SetMeasurementFunctor(const MeasurementFunctorType& functor) { m_MeasurementFunctor = functor; } MeasurementFunctorType & GetMeasurementFunctor() { return m_MeasurementFunctor; } protected: LabelMapToSampleListFilter(); ~LabelMapToSampleListFilter() ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; /** Make Output */ DataObjectPointerType MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LabelMapToSampleListFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** The functor used to build the measurement vector */ MeasurementFunctorType m_MeasurementFunctor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapToSampleListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapToSampleListFilter.txx000066400000000000000000000106721301006202600274220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToSampleListFilter_txx #define otbLabelMapToSampleListFilter_txx #include "otbLabelMapToSampleListFilter.h" namespace otb { template LabelMapToSampleListFilter ::LabelMapToSampleListFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->itk::ProcessObject::SetNthOutput(0, this->MakeOutput(0).GetPointer()); } template LabelMapToSampleListFilter ::~LabelMapToSampleListFilter() { } template typename LabelMapToSampleListFilter ::DataObjectPointerType LabelMapToSampleListFilter ::MakeOutput(DataObjectPointerArraySizeType) { DataObjectPointerType output; output = static_cast(OutputSampleListType::New().GetPointer()); return output; } // Set the input labelMap template void LabelMapToSampleListFilter ::SetInputLabelMap(const InputLabelMapType * inputLabelMap ) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(inputLabelMap)); } //Get the input labelMap template const typename LabelMapToSampleListFilter ::InputLabelMapType * LabelMapToSampleListFilter ::GetInputLabelMap() const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } // Get the output SampleList template const typename LabelMapToSampleListFilter ::OutputSampleListType * LabelMapToSampleListFilter ::GetOutputSampleList() { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } template void LabelMapToSampleListFilter ::GenerateData() { // Get the input LabelMap InputLabelMapConstPointerType inputLabelMap = this->GetInputLabelMap(); // Get the output ListSample OutputSampleListPointerType outputSampleList = const_cast(this->GetOutputSampleList()); ConstIteratorType it = ConstIteratorType( inputLabelMap ); // iterate on label objects bool isFirstIteration = true; while( !it.IsAtEnd() ) { // Get the measurement vector size of the output samplelist : once // in the beginning of the iterator if( isFirstIteration ) { typename OutputSampleListType::MeasurementVectorSizeType measurementSize; measurementSize = m_MeasurementFunctor(it.GetLabelObject()).Size(); outputSampleList->SetMeasurementVectorSize(measurementSize); isFirstIteration = false; } outputSampleList->PushBack(m_MeasurementFunctor(it.GetLabelObject())); ++it; } } template void LabelMapToSampleListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapWithAdjacency.h000066400000000000000000000165201301006202600260130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapWithAdjacency_h #define otbLabelMapWithAdjacency_h #include "itkLabelMap.h" #include "otbMergeLabelObjectFunctor.h" #include namespace otb { /** \class LabelMapWithAdjacency * \brief This class is a LabelMap with additional adjacency information. * * The adjacency information is stored as a map of set of labels, in * order to avoid duplicated neighbors. * * \ingroup OTBLabelMap */ template class ITK_EXPORT LabelMapWithAdjacency : public itk::LabelMap { public: /** Standard class typedefs */ typedef LabelMapWithAdjacency Self; typedef itk::LabelMap Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::WeakPointer ConstWeakPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LabelMapWithAdjacency, LabelMap); /** Typedef of the LabelObject */ typedef TLabelObject LabelObjectType; /** Dimension of the image. This constant is used by functions that are * templated over image type (as opposed to being templated over pixel type * and dimension) when they need compile time access to the dimension of * the image. */ itkStaticConstMacro(ImageDimension, unsigned int, LabelObjectType::ImageDimension); /** Label typedef support. */ typedef typename LabelObjectType::LabelType LabelType; /** A set containing adjacent labels */ typedef std::set AdjacentLabelsContainerType; /** A map containing the set of adjacent labels per label */ typedef std::map AdjacencyMapType; /** The merging functor */ typedef Functor::MergeLabelObjectFunctor MergeFunctorType; /** A pair of labels */ typedef std::pair LabelPairType; /** A vector of pair of labels */ typedef std::vector LabelPairVectorType; /** Set/Get the adjacency map */ void SetAdjacencyMap(const AdjacencyMapType & amap) { m_AdjacencyMap = amap; } const AdjacencyMapType & GetAdjacencyMap() const { return m_AdjacencyMap; } /** Add a given label to the adjacent labels set of another label */ void AddAdjacentLabel(LabelType label1, LabelType label2) { if(m_AdjacencyMap.find(label1) != m_AdjacencyMap.end()) { m_AdjacencyMap[label1].insert(label2); } else { AdjacentLabelsContainerType newContainer; newContainer.insert(label2); m_AdjacencyMap[label1]=newContainer; } } /** Clear the adjacent labels of a given label */ void ClearAdjacentLabels(LabelType label) { if(m_AdjacencyMap.find(label) != m_AdjacencyMap.end()) { m_AdjacencyMap[label].clear(); } } /** Remove the given adjacent label from the given label */ void RemoveAdjacentLabel(LabelType label1, LabelType label2) { if(m_AdjacencyMap.find(label1) != m_AdjacencyMap.end()) { m_AdjacencyMap[label1].erase(label2); } } /** Get the set of adjacent labels from a given label */ const AdjacentLabelsContainerType & GetAdjacentLabels(LabelType label) const { typename AdjacencyMapType::const_iterator it = m_AdjacencyMap.find(label); if(it != m_AdjacencyMap.end()) { return it->second; } else { itkExceptionMacro(<<"No Adjacency set for label "<GetLabelObject(label1); typename LabelObjectType::Pointer lo2 = this->GetLabelObject(label2); // Merges label object MergeFunctorType mergeFunctor; typename LabelObjectType::Pointer loOut = mergeFunctor(lo1, lo2); // Move every occurrence of label2 to label1 in adjacency map for(typename AdjacentLabelsContainerType::iterator it = m_AdjacencyMap[label2].begin(); it != m_AdjacencyMap[label2].end(); ++it) { m_AdjacencyMap[*it].erase(label2); if(*it != label1) { m_AdjacencyMap[*it].insert(label1); m_AdjacencyMap[label1].insert(*it); } } // Remove label2 from adjancency map m_AdjacencyMap.erase(label2); // Remove label object corresponding to label2 this->RemoveLabel(label2); // Replace label object corresponding to label1 this->RemoveLabel(label1); this->AddLabelObject(loOut); } /** Merge a list of pairs of labels. For each pair, the first label * will be the one retained */ void MergeLabels(const LabelPairVectorType & labels) { LabelPairVectorType internalLabelPairs = labels; typename LabelPairVectorType::iterator lpit1, lpit2; for (lpit1 = internalLabelPairs.begin(); lpit1 != internalLabelPairs.end(); ++lpit1) { // Merge the current label pair this->MergeLabels(lpit1->first, lpit1->second); // Update the remaining label pairs for (lpit2 = lpit1 + 1; lpit2 != internalLabelPairs.end(); ++lpit2) { if (lpit2->first == lpit1->second) { lpit2->first = lpit1->first; } if (lpit2->second == lpit1->second) { lpit2->second = lpit1->first; } } } } protected: /** Constructor */ LabelMapWithAdjacency(){} /** Destructor */ ~LabelMapWithAdjacency() ITK_OVERRIDE{} /** Printself */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } /** Re-implement CopyInformation to pass the adjancency graph * through */ void CopyInformation(const itk::DataObject * data) ITK_OVERRIDE { // Call superclass implementation Superclass::CopyInformation(data); // Try to cast to LabelMapWithAdjacency const Self * selfData = dynamic_cast(data); // If cast succeed if(selfData) m_AdjacencyMap = selfData->m_AdjacencyMap; } private: LabelMapWithAdjacency(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** The adjacency map */ AdjacencyMapType m_AdjacencyMap; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapWithClassLabelToClassLabelImageFilter.h000066400000000000000000000063151301006202600325020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapWithClassLabelToClassLabelImageFilter_h #define otbLabelMapWithClassLabelToClassLabelImageFilter_h #include "itkLabelMapFilter.h" namespace otb { /** \class LabelMapWithClassLabelToClassLabelImageFilter * \brief Converts a LabelMap to an image * of class labels * * \ingroup OTBLabelMap */ template class ITK_EXPORT LabelMapWithClassLabelToClassLabelImageFilter : public itk::LabelMapFilter { public: /** Standard class typedefs. */ typedef LabelMapWithClassLabelToClassLabelImageFilter Self; typedef itk::LabelMapFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::IndexType IndexType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(LabelMapWithClassLabelToClassLabelImageFilter, ImageToImageFilter); protected: LabelMapWithClassLabelToClassLabelImageFilter(); ~LabelMapWithClassLabelToClassLabelImageFilter() ITK_OVERRIDE {}; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedProcessLabelObject( LabelObjectType * labelObject ) ITK_OVERRIDE; private: LabelMapWithClassLabelToClassLabelImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapWithClassLabelToClassLabelImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapWithClassLabelToClassLabelImageFilter.txx000066400000000000000000000041651301006202600330770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapWithClassLabelToClassLabelImageFilter_txx #define otbLabelMapWithClassLabelToClassLabelImageFilter_txx #include "otbLabelMapWithClassLabelToClassLabelImageFilter.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "itkImageRegionConstIteratorWithIndex.h" namespace otb { template LabelMapWithClassLabelToClassLabelImageFilter ::LabelMapWithClassLabelToClassLabelImageFilter() { } template void LabelMapWithClassLabelToClassLabelImageFilter ::BeforeThreadedGenerateData() { OutputImageType * output = this->GetOutput(); const InputImageType * input = this->GetInput(); output->FillBuffer( input->GetBackgroundValue() ); Superclass::BeforeThreadedGenerateData(); } template void LabelMapWithClassLabelToClassLabelImageFilter ::ThreadedProcessLabelObject( LabelObjectType * labelObject ) { typename LabelObjectType::ClassLabelType label = itk::NumericTraits::max(); if(labelObject->HasClassLabel()) { label = labelObject->GetClassLabel(); } ConstLineIteratorType lit = ConstLineIteratorType (labelObject); while( !lit.IsAtEnd() ) { IndexType idx = lit.GetLine().GetIndex(); unsigned long length = lit.GetLine().GetLength(); for( unsigned int i=0; iGetOutput()->SetPixel( idx, label ); idx[0]++; } ++lit; } } }// end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapWithClassLabelToLabeledSampleListFilter.h000066400000000000000000000112321301006202600330520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapWithClassLabelToLabeledSampleListFilter_h #define otbLabelMapWithClassLabelToLabeledSampleListFilter_h #include "otbLabelMapToSampleListFilter.h" namespace otb { /** \class LabelMapWithClassLabelToLabeledSampleListFilter * \brief This class converts a LabelObjectMap with some class labeled * objets to a SampleList and a TrainingSampleList suitable for supervised learning, * and compatible with otb::SVMSampleListModelEstimator * * The conversion from label object to measurement vector is made * through a functor. This allows supporting any kind of LabelObject * via proper redefinition of the functor. * * \sa otb::SVMSampleListModelEstimator * * \ingroup OTBLabelMap */ template > class ITK_EXPORT LabelMapWithClassLabelToLabeledSampleListFilter : public LabelMapToSampleListFilter { public: /** Standard class typedefs. */ typedef LabelMapWithClassLabelToLabeledSampleListFilter Self; typedef LabelMapToSampleListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LabelMapWithClassLabelToLabeledSampleListFilter, LabelMapToSampleListFilter); /** template typedefs */ typedef TInputLabelMap InputLabelMapType; typedef typename InputLabelMapType::ConstPointer InputLabelMapConstPointerType; typedef typename InputLabelMapType::LabelObjectType LabelObjectType; typedef typename InputLabelMapType::ConstIterator ConstIteratorType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Output sample list */ typedef TOutputSampleList OutputSampleListType; typedef typename OutputSampleListType::Pointer OutputSampleListPointerType; typedef typename OutputSampleListType ::MeasurementVectorType MeasurementVectorType; /** Output training sample list */ typedef TOutputTrainingSampleList OutputTrainingSampleListType; typedef typename OutputTrainingSampleListType::Pointer OutputTrainingSampleListPointerType; typedef typename OutputTrainingSampleListType ::MeasurementVectorType TraningVectorType; /** Measurement functor */ typedef TMeasurementFunctor MeasurementFunctorType; // DataObject type definition from superclass typedef typename Superclass::DataObjectPointerType DataObjectPointerType; // Get the output training ListSample const OutputTrainingSampleListType* GetOutputTrainingSampleList(); // Get a hook on the functor for settings void SetMeasurementFunctor(const MeasurementFunctorType& functor) { m_MeasurementFunctor = functor; } MeasurementFunctorType & GetMeasurementFunctor() { return m_MeasurementFunctor; } protected: LabelMapWithClassLabelToLabeledSampleListFilter(); ~LabelMapWithClassLabelToLabeledSampleListFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; /** Make Output */ DataObjectPointerType MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; private: LabelMapWithClassLabelToLabeledSampleListFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** The functor used to build the measurement vector */ MeasurementFunctorType m_MeasurementFunctor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapWithClassLabelToLabeledSampleListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelMapWithClassLabelToLabeledSampleListFilter.txx000066400000000000000000000124111301006202600334460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapWithClassLabelToLabeledSampleListFilter_txx #define otbLabelMapWithClassLabelToLabeledSampleListFilter_txx #include "otbLabelMapWithClassLabelToLabeledSampleListFilter.h" #include "itkDataObject.h" namespace otb { template LabelMapWithClassLabelToLabeledSampleListFilter ::LabelMapWithClassLabelToLabeledSampleListFilter() { this->SetNumberOfRequiredOutputs(2); this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer()); } template LabelMapWithClassLabelToLabeledSampleListFilter ::~LabelMapWithClassLabelToLabeledSampleListFilter() {} template typename LabelMapWithClassLabelToLabeledSampleListFilter ::DataObjectPointerType LabelMapWithClassLabelToLabeledSampleListFilter ::MakeOutput(DataObjectPointerArraySizeType idx) { DataObjectPointerType output; switch (idx) { case 0: output = static_cast(OutputSampleListType::New().GetPointer()); break; case 1: output = static_cast(OutputTrainingSampleListType::New().GetPointer()); break; default: output = static_cast(OutputSampleListType::New().GetPointer()); break; } return output; } // Get the output training sample list template const typename LabelMapWithClassLabelToLabeledSampleListFilter ::OutputTrainingSampleListType* LabelMapWithClassLabelToLabeledSampleListFilter ::GetOutputTrainingSampleList() { return dynamic_cast(this->itk::ProcessObject::GetOutput(1)); } template void LabelMapWithClassLabelToLabeledSampleListFilter ::GenerateData() { // Get input InputLabelMapConstPointerType inputLabelMap = this->GetInputLabelMap(); // Get outputs OutputSampleListPointerType outputSampleList = const_cast (this->GetOutputSampleList()); OutputTrainingSampleListPointerType outputTrainingSampleList = const_cast (this->GetOutputTrainingSampleList()); // Clear the ListSamples outputSampleList->Clear(); outputTrainingSampleList->Clear(); // Lets begin by declaring the iterator for the objects in the image. ConstIteratorType it = ConstIteratorType( inputLabelMap ); bool isFirstIteration = true; // iterate on label objects while( !it.IsAtEnd() ) { TraningVectorType label; if(it.GetLabelObject()->HasClassLabel()) { label[0]=static_cast(it.GetLabelObject()->GetClassLabel()); } else { label[0]=itk::NumericTraits::max(); } // Before pushin back the measurement vectors to the sampleList // initialize their sizes : once if( isFirstIteration ) { // initialize the output sampleList typename OutputSampleListType::MeasurementVectorSizeType measurementSize; measurementSize = m_MeasurementFunctor(it.GetLabelObject()).Size(); outputSampleList->SetMeasurementVectorSize(measurementSize); // initialize the training samplelist outputTrainingSampleList->SetMeasurementVectorSize(label.Size()); isFirstIteration = false; } outputSampleList->PushBack(m_MeasurementFunctor(it.GetLabelObject())); outputTrainingSampleList->PushBack(label); ++it; } } template void LabelMapWithClassLabelToLabeledSampleListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelObjectFieldsFunctor.h000066400000000000000000000026441301006202600265400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelObjectFieldsFunctor_h #define otbLabelObjectFieldsFunctor_h #include "itkLabelObject.h" #include namespace otb { namespace Functor { /** \class LabelObjectFieldsFunctor * \brief Returns additional OGR fields to be saved in VectorData * * \sa LabelObjectWithClassLabelFieldsFunctor * * \ingroup OTBLabelMap */ template class ITK_EXPORT LabelObjectFieldsFunctor { public: // The Label Object typedef typedef TLabelObject LabelObjectType; typedef std::map FieldsMapType; FieldsMapType operator ()(LabelObjectType * itkNotUsed(labelObject)) const { // don't return anything for standard LabelObject (label is already handled by LabelmapToVectorData) return FieldsMapType(); } }; } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelObjectToPolygonFunctor.h000066400000000000000000000156161301006202600272670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelObjectToPolygonFunctor_h #define otbLabelObjectToPolygonFunctor_h #include //TODO change this include have to define from what inherate this class #include "otbPolyLineParametricPathWithValue.h" //for vcl_abs #include "itkPoint.h" #include "itkIndex.h" namespace otb { namespace Functor { /** \class LabelObjectToPolygonFunctor * \brief This class vectorizes a LabelObject to a Polygon. * * The algorithm follows a finite states machine described in the * following paper: * * "An algorithm for the rapid computation of boundaries of run-length * encoded regions", Francis K. H. Queck, in Pattern Recognition 33 * (2000), p 1637-1649. * * Lines in the RLE are first sorted in lexicographical order (to * ensure ordered RLE), and the finite states machine tracks the edge * following 8 canonical states given by the configuration of two * consecutive raws of lines. * * Iterations are done until convergence which is guaranteed to * happen. * * Please be aware that this functor is not thread-safe. * * * \ingroup OTBLabelMap */ template class LabelObjectToPolygonFunctor { public: /** Template parameters typedefs */ typedef TLabelObject LabelObjectType; /** Const iterator over LabelObject lines */ typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType; typedef typename LabelObjectType::LineType LineType; typedef typename LineType::IndexType IndexType; typedef TPolygon PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; typedef typename PolygonType::VertexType VertexType; typedef itk::Point PointType; typedef itk::Vector SpacingType; typedef itk::Index<2> RegionIndexType; /** * \param labelObject the label object to vectorize * \return The vectorized label object as a polygon. */ inline PolygonType * operator ()(LabelObjectType * labelObject); /** Get name of class. */ const char * GetNameOfClass() { return "LabelObjectToPolygonFunctor"; } /** Set the start index of the underlying image */ void SetStartIndex(const RegionIndexType& index) { m_StartIndex = index; } /** Get the start index */ const RegionIndexType& GetStartIndex() const { return m_StartIndex; } /** Set the origin of the underlying image */ void SetOrigin(const PointType& origin) { m_Origin = origin; } /** Get the origin */ const PointType& GetOrigin() const { return m_Origin; } /** Set the spacing of the underlying image */ void SetSpacing(const SpacingType& spacing) { m_Spacing = spacing; } /** Get the spacing */ const SpacingType& GetSpacing() const { return m_Spacing; } /** Constructor */ LabelObjectToPolygonFunctor() : m_Polygon(ITK_NULLPTR), m_CurrentState(UP_LEFT), m_PositionFlag(LEFT_END), m_StartingPoint(), m_CurrentPoint(), m_CurrentRun(), m_CurrentLine(0), m_Solution(), m_LineOffset(0), m_StartIndex(), m_Origin(), m_Spacing(1.) { m_StartingPoint.Fill(0); m_CurrentPoint.Fill(0); m_CurrentRun.Fill(0); m_StartIndex.Fill(0); m_Origin.Fill(0); } /** Destructor */ virtual ~LabelObjectToPolygonFunctor(){} private: /// Internal structures typedef std::vector RunsPerLineType; typedef std::vector RunsPerLineVectorType; typedef std::vector IndexVectorType; /// Internal enums enum StateType {UP_LEFT, UP_RIGHT, DOWN_LEFT, DOWN_RIGHT}; enum PositionFlagType {LEFT_END, RIGHT_END}; /// Compare two line in the lexicographical order static bool LexicographicalLineCompare(const LineType& l1, const LineType& l2); /// Check if the given run index (index in line, line) is valid inline bool IsRunIndexValid(const IndexType& index) const; /// Check if the point lies within the range of the line inline IndexType Within(const IndexType& point, unsigned int line) const; /// Return the left-end of the run inline IndexType LeftEnd(const IndexType& runIndex) const; /// Return the right-end of the run inline IndexType RightEnd(const IndexType& runIndex) const; /** Return the right-most run whose left end lies within the range of * the given run. */ inline IndexType RightMostLeftEndInside(unsigned int line, const IndexType& point, const IndexType& run) const; /** Return the left-most run whose right end lies within the range of * the given run. */ inline IndexType LeftMostRightEndInside(unsigned int line, const IndexType& point, const IndexType& run) const; /// Walk left to update the finite states machine. inline void WalkLeft(unsigned int line, const IndexType& startPoint, const IndexType& endPoint, PolygonType * polygon, const StateType state); /// Walk right to update the finite states machine. inline void WalkRight(unsigned int line, const IndexType& startPoint, const IndexType& endPoint, PolygonType * polygon, const StateType state); // Apply origin and spacing VertexType IndexToPoint(const VertexType& index) const; PolygonPointerType m_Polygon; // Internal structure to store runs RunsPerLineVectorType m_InternalDataSet; /// The current state StateType m_CurrentState; /// The position flag PositionFlagType m_PositionFlag; // The starting point for vectorization IndexType m_StartingPoint; /// The current point for vectorization IndexType m_CurrentPoint; /// The current run for vectorization IndexType m_CurrentRun; /// The current line for vectorization int m_CurrentLine; /// The vector of vectorized boundaries IndexVectorType m_Solution; /// The line offset from start of the region unsigned int m_LineOffset; // The following will be used for coordinate transform RegionIndexType m_StartIndex; PointType m_Origin; SpacingType m_Spacing; }; // end class LabelObjectToPolygonFunctor } // end namespace Functor } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelObjectToPolygonFunctor.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelObjectToPolygonFunctor.txx000066400000000000000000000446751301006202600276720ustar00rootroot00000000000000 /*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelObjectToPolygonFunctor_txx #define otbLabelObjectToPolygonFunctor_txx #include "otbLabelObjectToPolygonFunctor.h" namespace otb { namespace Functor { template bool LabelObjectToPolygonFunctor ::LexicographicalLineCompare(const LineType& l1, const LineType& l2) { bool resp = l2.GetIndex()[1] > l1.GetIndex()[1]; resp = resp || (l2.GetIndex()[1] == l1.GetIndex()[1] && (l1.GetIndex()[0] + static_cast(l1.GetLength())) < l2.GetIndex()[0]); return resp; } template inline typename LabelObjectToPolygonFunctor ::PolygonType * LabelObjectToPolygonFunctor ::operator() (LabelObjectType * labelObject) { // Clear any previous context m_CurrentState = DOWN_LEFT; m_PositionFlag = LEFT_END; m_InternalDataSet.clear(); m_Polygon = PolygonType::New(); // Get the internal container //LineContainerType lcontainer = labelObject->GetLineContainer(); // Sort it //sort(lcontainer.begin(), lcontainer.end(), &LexicographicalLineCompare); //Use the Optimize method labelObject->Optimize(); // Step 1: Fill the internal data set // Iterates on the line container // typename LineContainerType::const_iterator lIt = lcontainer.begin(); ConstLineIteratorType lIt = ConstLineIteratorType(labelObject); lIt.GoToBegin(); // Stores the current line long currentLine = lIt.GetLine().GetIndex()[1]; long lineIndex = 0; // Push back the first line of runs RunsPerLineType firstRunsPerLine; m_InternalDataSet.push_back(firstRunsPerLine); while ( !lIt.IsAtEnd() ) { // if we are still in the same image line if (currentLine == lIt.GetLine().GetIndex()[1]) { m_InternalDataSet.back().push_back(lIt.GetLine()); } else { ++lineIndex; currentLine = lIt.GetLine().GetIndex()[1]; RunsPerLineType newRunsPerLine; newRunsPerLine.push_back(lIt.GetLine()); m_InternalDataSet.push_back(newRunsPerLine); } ++lIt; } // Begin the boundaries tracking procedure m_StartingPoint = m_InternalDataSet.at(0).at(0).GetIndex(); m_LineOffset = m_StartingPoint[1]; m_CurrentPoint = m_StartingPoint; m_CurrentRun.Fill(0); m_CurrentLine = 0; bool goesOn = true; while (goesOn) { switch (m_CurrentState) { case UP_RIGHT: { // First candidate run IndexType firstCandidateRun = Within(m_CurrentPoint, m_CurrentLine - 1); if (IsRunIndexValid(firstCandidateRun)) { // Second candidate run IndexType secondCandidateRun = RightMostLeftEndInside(m_CurrentLine, RightEnd( m_CurrentRun), firstCandidateRun); if (IsRunIndexValid(secondCandidateRun)) { // Down-Right case m_CurrentRun = secondCandidateRun; m_CurrentState = DOWN_RIGHT; m_PositionFlag = LEFT_END; WalkRight(m_CurrentLine - 1, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } else { // Up-Right case m_CurrentLine--; m_CurrentRun = firstCandidateRun; m_CurrentState = UP_RIGHT; m_PositionFlag = RIGHT_END; WalkRight(m_CurrentLine, m_CurrentPoint, RightEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } else { IndexType secondCandidateRun = LeftMostRightEndInside(m_CurrentLine - 1, RightEnd(m_CurrentRun), m_CurrentRun); if (IsRunIndexValid(secondCandidateRun)) { // Up-Left Case m_CurrentState = UP_LEFT; m_PositionFlag = RIGHT_END; WalkLeft(m_CurrentLine, m_CurrentPoint, RightEnd(secondCandidateRun), m_Polygon, m_CurrentState); m_CurrentLine--; m_CurrentRun = secondCandidateRun; } else { // Down-Left case m_CurrentState = DOWN_LEFT; m_PositionFlag = LEFT_END; WalkLeft(m_CurrentLine, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } break; } case DOWN_LEFT: { // First candidate run IndexType firstCandidateRun = Within(m_CurrentPoint, m_CurrentLine + 1); if (IsRunIndexValid(firstCandidateRun)) { // Second candidate run IndexType secondCandidateRun = LeftMostRightEndInside(m_CurrentLine, LeftEnd(m_CurrentRun), firstCandidateRun); if (IsRunIndexValid(secondCandidateRun)) { // Up-Left case m_CurrentRun = secondCandidateRun; m_CurrentState = UP_LEFT; m_PositionFlag = RIGHT_END; WalkLeft(m_CurrentLine + 1, m_CurrentPoint, RightEnd(m_CurrentRun), m_Polygon, m_CurrentState); } else { // Down-Left case m_CurrentLine++; m_CurrentRun = firstCandidateRun; m_CurrentState = DOWN_LEFT; m_PositionFlag = LEFT_END; WalkLeft(m_CurrentLine, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } else { IndexType secondCandidateRun = RightMostLeftEndInside(m_CurrentLine + 1, LeftEnd(m_CurrentRun), m_CurrentRun); if (IsRunIndexValid(secondCandidateRun)) { // Down-Right case m_CurrentRun = secondCandidateRun; m_CurrentLine++; m_CurrentState = DOWN_RIGHT; m_PositionFlag = LEFT_END; WalkRight(m_CurrentLine, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } else { // Up-Right case m_CurrentState = UP_RIGHT; m_PositionFlag = RIGHT_END; WalkRight(m_CurrentLine, m_CurrentPoint, RightEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } break; } case DOWN_RIGHT: { IndexType firstCandidateRun = Within(m_CurrentPoint, m_CurrentLine + 1); if (IsRunIndexValid(firstCandidateRun)) { IndexType secondCandidateRun = LeftMostRightEndInside(m_CurrentLine, RightEnd( m_CurrentRun), firstCandidateRun); if (IsRunIndexValid(secondCandidateRun)) { // Up-Left case m_CurrentState = UP_LEFT; m_PositionFlag = RIGHT_END; m_CurrentRun = secondCandidateRun; WalkLeft(m_CurrentLine + 1, m_CurrentPoint, RightEnd(m_CurrentRun), m_Polygon, m_CurrentState); } else { // Down-Left case m_CurrentLine++; m_CurrentRun = firstCandidateRun; m_CurrentState = DOWN_LEFT; m_PositionFlag = LEFT_END; WalkLeft(m_CurrentLine, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } else { IndexType secondCandidateRun = RightMostLeftEndInside(m_CurrentLine + 1, LeftEnd(m_CurrentRun), m_CurrentRun); if (IsRunIndexValid(secondCandidateRun)) { // Down-Right case m_CurrentLine++; m_CurrentRun = secondCandidateRun; m_CurrentState = DOWN_RIGHT; m_PositionFlag = LEFT_END; WalkRight(m_CurrentLine, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } else { // Up-Right case m_CurrentState = UP_RIGHT; m_PositionFlag = RIGHT_END; WalkRight(m_CurrentLine, m_CurrentPoint, RightEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } break; } case UP_LEFT: { IndexType firstCandidateRun = Within(m_CurrentPoint, m_CurrentLine - 1); if (IsRunIndexValid(firstCandidateRun)) { IndexType secondCandidateRun = RightMostLeftEndInside(m_CurrentLine, LeftEnd(m_CurrentRun), firstCandidateRun); if (IsRunIndexValid(secondCandidateRun)) { // Down-Right case m_CurrentRun = secondCandidateRun; m_CurrentState = DOWN_RIGHT; m_PositionFlag = LEFT_END; WalkRight(m_CurrentLine - 1, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } else { // Up-Right case m_CurrentLine--; m_CurrentRun = firstCandidateRun; m_CurrentState = UP_RIGHT; m_PositionFlag = RIGHT_END; WalkRight(m_CurrentLine, m_CurrentPoint, RightEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } else { IndexType secondCandidateRun = LeftMostRightEndInside(m_CurrentLine - 1, RightEnd(m_CurrentRun), m_CurrentRun); if (IsRunIndexValid(secondCandidateRun)) { // Up-Left case m_CurrentState = UP_LEFT; m_PositionFlag = RIGHT_END; WalkLeft(m_CurrentLine, m_CurrentPoint, RightEnd(secondCandidateRun), m_Polygon, m_CurrentState); m_CurrentLine--; m_CurrentRun = secondCandidateRun; } else { // Down-Left case m_CurrentState = DOWN_LEFT; m_PositionFlag = LEFT_END; WalkLeft(m_CurrentLine, m_CurrentPoint, LeftEnd(m_CurrentRun), m_Polygon, m_CurrentState); } } break; } } goesOn = m_CurrentPoint != m_StartingPoint; } return m_Polygon; } template inline bool LabelObjectToPolygonFunctor ::IsRunIndexValid(const IndexType& index) const { return (index[0] >= 0 && index[1] >= 0); } template inline typename LabelObjectToPolygonFunctor ::IndexType LabelObjectToPolygonFunctor ::Within(const IndexType& point, unsigned int line) const { unsigned int idx = 0; IndexType resp; resp[0] = -1; if (line >= m_InternalDataSet.size()) { resp[1] = -1; return resp; } long leftoffset = 0; long rightoffset = 0; switch (m_PositionFlag) { case LEFT_END: rightoffset = 1; break; case RIGHT_END: leftoffset = -1; break; } typename RunsPerLineType::const_iterator it = m_InternalDataSet.at(line).begin(); resp[1] = line; while (resp[0] < 0 && it != m_InternalDataSet.at(line).end()) { if (point[0] >= (it->GetIndex()[0]) + leftoffset && point[0] < (it->GetIndex()[0] + static_cast(it->GetLength())) + rightoffset) { resp[0] = idx; } ++idx; ++it; } return resp; } template inline typename LabelObjectToPolygonFunctor ::IndexType LabelObjectToPolygonFunctor ::LeftEnd(const IndexType& runIndex) const { return m_InternalDataSet.at(runIndex[1]).at(runIndex[0]).GetIndex(); } template inline typename LabelObjectToPolygonFunctor ::IndexType LabelObjectToPolygonFunctor ::RightEnd(const IndexType& runIndex) const { IndexType point = m_InternalDataSet.at(runIndex[1]).at(runIndex[0]).GetIndex(); point[0] += static_cast(m_InternalDataSet.at(runIndex[1]).at(runIndex[0]).GetLength() - 1); return point; } template inline typename LabelObjectToPolygonFunctor ::IndexType LabelObjectToPolygonFunctor ::RightMostLeftEndInside(unsigned int line, const IndexType& point, const IndexType& run) const { unsigned int idx = 0; IndexType resp; resp[0] = -1; if (line >= m_InternalDataSet.size()) { resp[1] = -1; return resp; } typename RunsPerLineType::const_iterator it = m_InternalDataSet.at(line).begin(); resp[1] = line; LineType lrun = m_InternalDataSet.at(run[1]).at(run[0]); while (resp[0] < 0 && it != m_InternalDataSet.at(line).end()) { /// Index is a the right of point if (it->GetIndex()[0] > point[0] /// Index is inside run range && it->GetIndex()[0] - 1 >= lrun.GetIndex()[0] && it->GetIndex()[0] - 1 < lrun.GetIndex()[0] + static_cast(lrun.GetLength())) { resp[0] = idx; } ++idx; ++it; } return resp; } template inline typename LabelObjectToPolygonFunctor ::IndexType LabelObjectToPolygonFunctor ::LeftMostRightEndInside(unsigned int line, const IndexType& point, const IndexType& run) const { IndexType resp; resp[0] = -1; if (line >= m_InternalDataSet.size()) { resp[1] = -1; return resp; } unsigned int idx = m_InternalDataSet.at(line).size() - 1; typename RunsPerLineType::const_reverse_iterator it = m_InternalDataSet.at(line).rbegin(); resp[1] = line; LineType lrun = m_InternalDataSet.at(run[1]).at(run[0]); while (resp[0] < 0 && it != m_InternalDataSet.at(line).rend()) { /// Index is a the left of point if (it->GetIndex()[0] + static_cast(it->GetLength()) <= point[0] /// right end is inside run range && it->GetIndex()[0] + static_cast(it->GetLength()) >= lrun.GetIndex()[0] && it->GetIndex()[0] + static_cast(it->GetLength()) < lrun.GetIndex()[0] + static_cast(lrun.GetLength())) { resp[0] = idx; } --idx; ++it; } return resp; } template void LabelObjectToPolygonFunctor ::WalkLeft(unsigned int line, const IndexType& startPoint, const IndexType& endPoint, PolygonType * polygon, const StateType state) { if( vcl_abs(static_cast(line + m_LineOffset - endPoint[1])) > 1 ) { itkExceptionMacro("End point not with +/-1 line from line") } typename PolygonType::VertexType::VectorType offset; typedef typename PolygonType::VertexType::VectorType::ValueType VectorValueType; offset.Fill(itk::NumericTraits::Zero); switch (state) { case UP_RIGHT: offset[1] = 0.5; break; case UP_LEFT: offset[1] = 0.5; break; case DOWN_RIGHT: offset[1] = -0.5; break; case DOWN_LEFT: offset[1] = -0.5; break; } switch (m_PositionFlag) { case LEFT_END: offset[0] = -0.5; break; case RIGHT_END: offset[0] = 0.5; break; } typename PolygonType::VertexType newPoint; m_CurrentPoint = startPoint; m_CurrentPoint[0] -= 1; if (m_CurrentPoint[0] > endPoint[0] + 1) { m_CurrentPoint[1] = line + m_LineOffset; newPoint = m_CurrentPoint; newPoint += offset; polygon->AddVertex(IndexToPoint(newPoint)); } // if the end point is not on line n, add an intermediate point if (static_cast(line + m_LineOffset) != endPoint[1] && m_CurrentPoint[0] > endPoint[0] + 1) { m_CurrentPoint[0] = endPoint[0] + 1; newPoint = m_CurrentPoint; newPoint += offset; polygon->AddVertex(IndexToPoint(newPoint)); } if (m_CurrentPoint != endPoint) { m_CurrentPoint = endPoint; newPoint = m_CurrentPoint; newPoint += offset; polygon->AddVertex(IndexToPoint(newPoint)); } } template void LabelObjectToPolygonFunctor ::WalkRight(unsigned int line, const IndexType& startPoint, const IndexType& endPoint, PolygonType * polygon, const StateType state) { if( vcl_abs(static_cast(line + m_LineOffset - endPoint[1])) > 1 ) { itkExceptionMacro("End point not with +/-1 line from line") } typename PolygonType::VertexType::VectorType offset; typedef typename PolygonType::VertexType::VectorType::ValueType VectorValueType; offset.Fill(itk::NumericTraits::Zero); switch (state) { case UP_RIGHT: offset[0] = 0.5; offset[1] = 0.5; break; case UP_LEFT: offset[0] = -0.5; offset[1] = 0.5; break; case DOWN_RIGHT: offset[0] = 0.5; offset[1] = -0.5; break; case DOWN_LEFT: offset[0] = -0.5; offset[1] = -0.5; break; } typename PolygonType::VertexType newPoint; m_CurrentPoint = startPoint; m_CurrentPoint[0] += 1; if (m_CurrentPoint[0] < endPoint[0] - 1) { m_CurrentPoint[1] = line + m_LineOffset; newPoint = m_CurrentPoint; newPoint += offset; polygon->AddVertex(IndexToPoint(newPoint)); } // if the end point is not on line n, add an intermediate point if (static_cast(line + m_LineOffset) != endPoint[1] && m_CurrentPoint[0] < endPoint[0] - 1) { m_CurrentPoint[0] = endPoint[0] - 1; newPoint = m_CurrentPoint; newPoint += offset; polygon->AddVertex(IndexToPoint(newPoint)); } if (m_CurrentPoint != endPoint) { m_CurrentPoint = endPoint; newPoint = m_CurrentPoint; newPoint += offset; polygon->AddVertex(IndexToPoint(newPoint)); } } // Apply origin and spacing template typename LabelObjectToPolygonFunctor ::VertexType LabelObjectToPolygonFunctor ::IndexToPoint(const VertexType& index) const { VertexType resp; // Apply origin and spacing //resp[0] = (index[0] - m_StartIndex[0]) * m_Spacing[0] + m_Origin[0]; //resp[1] = (index[1] - m_StartIndex[1]) * m_Spacing[1] + m_Origin[1]; resp[0] = index[0] * m_Spacing[0] + m_Origin[0]; resp[1] = index[1] * m_Spacing[1] + m_Origin[1]; return resp; } } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbLabelObjectWithClassLabelFieldsFunctor.h000066400000000000000000000030271301006202600313160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelObjectWithClassLabelFieldsFunctor_h #define otbLabelObjectWithClassLabelFieldsFunctor_h #include "itkLabelObject.h" #include namespace otb { namespace Functor { /** \class LabelObjectWithClassLabelFieldsFunctor * \brief Returns additional OGR fields to be saved in VectorData * * \sa LabelObjectFieldsFunctor * * \ingroup OTBLabelMap */ template class ITK_EXPORT LabelObjectWithClassLabelFieldsFunctor { public: // The Label Object typedef typedef TLabelObject LabelObjectType; typedef std::map FieldsMapType; FieldsMapType operator ()(LabelObjectType * labelObject) const { typename LabelObjectType::ClassLabelType classLabel = labelObject->GetClassLabel(); std::ostringstream oss; oss << classLabel; FieldsMapType fields; fields["Class"] = oss.str(); return fields; } }; } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbMergeLabelObjectFunctor.h000066400000000000000000000115151301006202600263660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMergeLabelObjectFunctor_h #define otbMergeLabelObjectFunctor_h #include namespace otb { namespace Functor { /** \class MergeLabelObjectFunctor * \brief Merge two LabelObjects * * This functor merges the two inputs label objects into a third label * object where the Run have been merged. The resulting label object * holds data from first input label object copied via the * CopyDataFrom() method. * * Please note that if the two input label objects are disjoint, the * resulting label object will have more than one connected component. * * This functor is thread safe. * * \ingroup OTBLabelMap */ template class MergeLabelObjectFunctor { public: /** Template parameters typedefs */ typedef TLabelObject LabelObjectType; typedef typename LabelObjectType::Pointer LabelObjectPointerType; typedef typename LabelObjectType::LineContainerType LineContainerType; typedef typename LabelObjectType::LineType LineType; typedef typename LineType::IndexType IndexType; /** * \param l1 First label object to merge (data are copied from this * one), * \param l2 Second label object to merge * \return The merged label object */ inline LabelObjectPointerType operator()(const LabelObjectType * l1, const LabelObjectType * l2) const { // Retrieve the two input line containers LineContainerType lines1 = l1->GetLineContainer(); LineContainerType lines2 = l2->GetLineContainer(); // Ensure they are sorted according to our criterion stable_sort(lines1.begin(), lines1.end(), &LexicographicalLineCompare); stable_sort(lines2.begin(), lines2.end(), &LexicographicalLineCompare); // Merge the two containers LineContainerType linesOut1(lines1.size()+lines2.size()); merge(lines1.begin(), lines1.end(), lines2.begin(), lines2.end(), linesOut1.begin(), &LexicographicalLineCompare); // Merge consecutive and overlapping lines LineContainerType linesOut2; // Initialize output final container typename LineContainerType::const_iterator lit = linesOut1.begin(); linesOut2.push_back(*lit); ++lit; // Walk the merged line container while(lit!=linesOut1.end()) { // Test if next line overlaps with current if(LinesOverlap(linesOut2.back(), *lit)) { // Merge lines LineType mline = MergesLines(linesOut2.back(), *lit); // Replace the last line by the merged line linesOut2.pop_back(); linesOut2.push_back(mline); } else { // Push back the new line linesOut2.push_back(*lit); } // fetch next line ++lit; } // Create the output label object LabelObjectPointerType resp = LabelObjectType::New(); resp->CopyAllFrom(l1); resp->GetLineContainer() = linesOut2; // Return the output label object return resp; } private: /// Compare two line in the lexicographical order with respect to /// their start index. static bool LexicographicalLineCompare(const LineType & l1, const LineType & l2) { bool resp = l2.GetIndex()[1]> l1.GetIndex()[1]; resp = resp || (l2.GetIndex()[1] == l1.GetIndex()[1] && (l1.GetIndex()[0] < l2.GetIndex()[0])); return resp; } /// Check if lines overlap (same row and one of the run end inside the /// other run) static bool LinesOverlap(const LineType & l1, const LineType & l2) { // Test if we are in same row bool sameRow = l2.GetIndex()[1] == l1.GetIndex()[1]; bool leftEndInside = (l2.GetIndex()[0]>= l1.GetIndex()[0] && l2.GetIndex()[0]<=l1.GetIndex()[0]+static_cast(l1.GetLength())); bool rightEndInside = (l1.GetIndex()[0]>= l2.GetIndex()[0] && l1.GetIndex()[0]<=l2.GetIndex()[0]+static_cast(l2.GetLength())); return (sameRow && (leftEndInside || rightEndInside)); } /// Merge two lines. l1 and l2 are supposed to be in the same row /// and to overlap. l1 is supposed to appear before l2 static const LineType MergesLines(const LineType & l1, const LineType & l2) { LineType resp; resp.SetIndex(l1.GetIndex()); unsigned long length = std::max(l1.GetLength(), l2.GetIndex()[0]+l2.GetLength()-l1.GetIndex()[0]); resp.SetLength(length); return resp; } }; // end class MergeLabelObjectFunctor } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbMinMaxAttributesLabelMapFilter.h000066400000000000000000000074441301006202600277110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMinMaxAttributesLabelMapFilter_h #define otbMinMaxAttributesLabelMapFilter_h #include "itkLabelMapFilter.h" #include "itkSimpleDataObjectDecorator.h" namespace otb { /** \class MinMaxAttributesLabelMapFilter * \brief Computes the min/max of all attributes of a LabelMap * where LabelObject type is compatible with otb::AttributesMapLabelObject * * * \ingroup OTBLabelMap */ template class ITK_EXPORT MinMaxAttributesLabelMapFilter : public itk::LabelMapFilter { public: /** Standard class typedefs. */ typedef MinMaxAttributesLabelMapFilter Self; typedef itk::LabelMapFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::LabelObjectType LabelObjectType; typedef typename InputImageType::ConstIterator ConstIteratorType; typedef typename LabelObjectType::AttributesValueType AttributesValueType; typedef typename LabelObjectType::AttributesMapType AttributesMapType; typedef itk::SimpleDataObjectDecorator AttributesMapObjectType; typedef itk::DataObject DataObjectType; typedef DataObjectType::Pointer DataObjectPointerType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(MinMaxAttributesLabelMapFilter, LabelMapFilter); /** Return the computed Minimum. */ AttributesMapType GetMinimum() const { return this->GetMinimumOutput()->Get(); } AttributesMapObjectType* GetMinimumOutput(); const AttributesMapObjectType* GetMinimumOutput() const; /** Return the computed Maximum. */ AttributesMapType GetMaximum() const { return this->GetMaximumOutput()->Get(); } AttributesMapObjectType* GetMaximumOutput(); const AttributesMapObjectType* GetMaximumOutput() const; DataObjectPointerType MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; protected: MinMaxAttributesLabelMapFilter(); ~MinMaxAttributesLabelMapFilter() ITK_OVERRIDE {}; void GenerateData() ITK_OVERRIDE; private: MinMaxAttributesLabelMapFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented //typedef typename InputImageType::LabelObjectContainerType LabelObjectContainerType; //typedef typename LabelObjectContainerType::const_iterator LabelObjectContainerConstIterator; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMinMaxAttributesLabelMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbMinMaxAttributesLabelMapFilter.txx000066400000000000000000000074231301006202600303020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMinMaxAttributesLabelMapFilter_txx #define otbMinMaxAttributesLabelMapFilter_txx #include "otbMinMaxAttributesLabelMapFilter.h" #include "itkNumericTraits.h" namespace otb { template MinMaxAttributesLabelMapFilter ::MinMaxAttributesLabelMapFilter() { this->Superclass::SetNumberOfRequiredOutputs(3); this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(2, this->MakeOutput(2).GetPointer()); } template typename MinMaxAttributesLabelMapFilter::DataObjectPointerType MinMaxAttributesLabelMapFilter ::MakeOutput(DataObjectPointerArraySizeType i) { DataObjectPointerType ret; switch (i) { case 0: ret = InputImageType::New(); break; case 1: case 2: ret = AttributesMapObjectType::New(); break; } return ret; } template typename MinMaxAttributesLabelMapFilter::AttributesMapObjectType* MinMaxAttributesLabelMapFilter ::GetMinimumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename MinMaxAttributesLabelMapFilter::AttributesMapObjectType* MinMaxAttributesLabelMapFilter ::GetMinimumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename MinMaxAttributesLabelMapFilter::AttributesMapObjectType* MinMaxAttributesLabelMapFilter ::GetMaximumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template const typename MinMaxAttributesLabelMapFilter::AttributesMapObjectType* MinMaxAttributesLabelMapFilter ::GetMaximumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template void MinMaxAttributesLabelMapFilter ::GenerateData() { std::vector attributes = this->GetLabelMap()->GetLabelObject(0)->GetAvailableAttributes(); AttributesMapType& minAttr = this->GetMinimumOutput()->Get(); AttributesMapType& maxAttr = this->GetMaximumOutput()->Get(); // create an entry in the output maps for each attribute std::vector::const_iterator valueIt; for (valueIt = attributes.begin(); valueIt != attributes.end(); ++valueIt) { minAttr[*valueIt] = itk::NumericTraits::max(); maxAttr[*valueIt] = itk::NumericTraits::NonpositiveMin(); } for(unsigned int i = 0; i < this->GetLabelMap()->GetNumberOfLabelObjects(); ++i) { LabelObjectType* labelObject =this->GetLabelMap()->GetNthLabelObject(i); std::vector::const_iterator it; for (it = attributes.begin(); it != attributes.end(); ++it) { AttributesValueType val = labelObject->GetAttribute((*it).c_str()); // Update min if (val < minAttr[*it]) minAttr[*it] = val; //Update max if (val > maxAttr[*it]) maxAttr[*it] = val; } ++it; } } }// end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbNormalizeAttributesLabelMapFilter.h000066400000000000000000000112121301006202600304440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalizeAttributesLabelMapFilter_h #define otbNormalizeAttributesLabelMapFilter_h #include "otbLabelMapFeaturesFunctorImageFilter.h" #include namespace otb { namespace Functor { /** \class NormalizeAttributesLabelObjectFunctor * \brief Functor to normalize all attributes of a LabelMap * * Given the minimum and maximum of all attributes (which can be computed with * MinMaxAttributesLabelMapFilter), this filter rescale the attributes such that * all attributes are in [0, 1] interval * * \sa MinMaxAttributesLabelMapFilter * * \ingroup OTBLabelMap */ template class NormalizeAttributesLabelObjectFunctor { public: /** Self typedef */ typedef NormalizeAttributesLabelObjectFunctor Self; /** LabelObject typedef */ typedef TLabelObject LabelObjectType; typedef typename LabelObjectType::AttributesMapType AttributesMapType; typedef typename LabelObjectType::AttributesValueType AttributesValueType; /** Constructor */ NormalizeAttributesLabelObjectFunctor(); /** Destructor */ virtual ~NormalizeAttributesLabelObjectFunctor() {} /** The comparators */ bool operator !=(const Self& self); bool operator ==(const Self& self); /** This is the functor implementation * Calling the functor on a label object * will update its shape attributes */ inline void operator ()(LabelObjectType * lo) const; void SetMinAttributesValues(const AttributesMapType& minValues) { m_Min = minValues; } void SetMaxAttributesValues(const AttributesMapType& maxValues) { m_Max = maxValues; } private: AttributesMapType m_Min; AttributesMapType m_Max; }; } /** \class NormalizeAttributesLabelMapFilter * \brief This class works with AttributesMapLabelObject, and normalizes all attributes * wrt a map of minimal and maximal attribute value, such that the resulting * attributes are in the [0, 1] interval * * \sa MinMaxAttributesLabelMapFilter * * \ingroup OTBLabelMap */ template class ITK_EXPORT NormalizeAttributesLabelMapFilter : public otb::LabelMapFeaturesFunctorImageFilter > { public: /** Template parameters typedefs */ typedef TImage ImageType; typedef typename ImageType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::AttributesMapType AttributesMapType; typedef Functor::NormalizeAttributesLabelObjectFunctor FunctorType; /** Standard class typedefs. */ typedef NormalizeAttributesLabelMapFilter Self; typedef LabelMapFeaturesFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(NormalizeAttributesLabelMapFilter, LabelMapFeaturesFunctorImageFilter); void SetMinAttributesValues(const AttributesMapType& minValues) { this->GetFunctor().SetMinAttributesValues(minValues); this->Modified(); } void SetMaxAttributesValues(const AttributesMapType& maxValues) { this->GetFunctor().SetMaxAttributesValues(maxValues); this->Modified(); } protected: /** Constructor */ NormalizeAttributesLabelMapFilter(){} /** Destructor */ ~NormalizeAttributesLabelMapFilter() ITK_OVERRIDE{} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: NormalizeAttributesLabelMapFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNormalizeAttributesLabelMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbNormalizeAttributesLabelMapFilter.txx000066400000000000000000000044071301006202600310500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalizeAttributesLabelMapFilter_txx #define otbNormalizeAttributesLabelMapFilter_txx #include "otbNormalizeAttributesLabelMapFilter.h" namespace otb { namespace Functor { template NormalizeAttributesLabelObjectFunctor ::NormalizeAttributesLabelObjectFunctor() {} /** The comparator (!=) */ template bool NormalizeAttributesLabelObjectFunctor ::operator != (const Self &other) { bool resp = (m_Min != other.m_Min) || (m_Max != other.m_Max); return resp; } /** The comparator (==)*/ template bool NormalizeAttributesLabelObjectFunctor ::operator == (const Self &self) { return !(this != self); } template void NormalizeAttributesLabelObjectFunctor ::operator() (LabelObjectType * lo) const { const std::vector& attr = lo->GetAvailableAttributes(); std::vector::const_iterator it; for (it = attr.begin(); it != attr.end(); ++it) { const AttributesValueType& value = lo->GetAttribute( (*it).c_str() ); typename AttributesMapType::const_iterator minIt = m_Min.find(*it); typename AttributesMapType::const_iterator maxIt = m_Max.find(*it); if (minIt != m_Min.end() && maxIt != m_Max.end()) { lo->SetAttribute( (*it).c_str(), (value - minIt->second)/(maxIt->second - minIt->second) ); } } } } // end namespace Functor template void NormalizeAttributesLabelMapFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbShapeAttributesLabelMapFilter.h000066400000000000000000000243441301006202600275560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbShapeAttributesLabelMapFilter_h #define otbShapeAttributesLabelMapFilter_h #include "otbLabelMapFeaturesFunctorImageFilter.h" #include "otbImage.h" #include "otbPolygon.h" #include "otbLabelObjectToPolygonFunctor.h" #include "otbFlusserPathFunction.h" #include "otbSimplifyPathFunctor.h" namespace otb { namespace Functor { /** \class ShapeAttributesLabelObjectFunctor * \brief Functor to compute shape attributes of one LabelObject. * * \sa ShapeAttributesLabelMapFilter * * \ingroup OTBLabelMap */ template class ShapeAttributesLabelObjectFunctor { public: /** Self typedef */ typedef ShapeAttributesLabelObjectFunctor Self; /** LabelObject typedef */ typedef TLabelObject LabelObjectType; /** Const iterator over LabelObject lines */ typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType; /** Labeled image type */ typedef TLabelImage LabelImageType; /** Flusser moments typedef */ typedef typename TLabelObject::PolygonType PolygonType; typedef Functor::LabelObjectToPolygonFunctor PolygonFunctorType; typedef FlusserPathFunction FlusserPathFunctionType; typedef SimplifyPathFunctor SimplifyPolygonFunctorType; typedef unsigned int DimensionType; /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TLabelObject::ImageDimension); typedef itk::ImageRegion< TLabelObject::ImageDimension > RegionType; typedef itk::Offset< TLabelObject::ImageDimension > OffsetType; /** Constructor */ ShapeAttributesLabelObjectFunctor(); /** Destructor */ virtual ~ShapeAttributesLabelObjectFunctor() {} /** The comparators */ bool operator !=(const Self& self); bool operator ==(const Self& self); /** Set the compute perimeter flag */ void SetComputePerimeter(bool flag); /** Get the compute perimeter flag */ bool GetComputePerimeter() const; /** Set the compute perimeter flag */ void SetComputeFlusser(bool flag); /** Get the compute perimeter flag */ bool GetComputeFlusser() const; /** Set the polygonalisation flag */ void SetComputePolygon(bool flag); /** Get the polygonalisation flag */ bool GetComputePolygon() const; /** Set the compute feret diameter flag */ void SetComputeFeretDiameter(bool flag); /** Get the compute feret diameter flag */ bool GetComputeFeretDiameter() const; /** Set the compute reduced attributes set flag */ void SetReducedAttributeSet(bool flag); /** Get the compute reduced attributes set flag */ bool GetReducedAttributeSet() const; /** Set the label image (used only to compute * the Feret diameter */ void SetLabelImage(const TLabelImage * image); /** Get the label image */ const TLabelImage * GetLabelImage() const; /** This is the functor implementation * Calling the functor on a label object * will update its shape attributes */ inline void operator ()(LabelObjectType * lo); private: /** Convenience internal method */ static long factorial(long n); /** Convenience internal method */ static long doubleFactorial(long n); /** Convenience internal method */ static double gammaN2p1(long n); /** Convenience internal method */ static double hyperSphereVolume(double radius); /** Convenience internal method */ static double hyperSpherePerimeter(double radius); /** Convenience internal method */ static double hyperSphereRadiusFromVolume(double volume); double ComputePerimeter(LabelObjectType *labelObject, const RegionType & region); typedef itk::Offset<2> Offset2Type; typedef itk::Offset<3> Offset3Type; typedef itk::Vector Spacing2Type; typedef itk::Vector Spacing3Type; typedef std::map MapIntercept2Type; typedef std::map MapIntercept3Type; template double PerimeterFromInterceptCount( TMapIntercept & intercepts, const TSpacing & spacing ); #if ! defined(ITK_DO_NOT_USE_PERIMETER_SPECIALIZATION) double PerimeterFromInterceptCount( MapIntercept2Type & intercepts, const Spacing2Type spacing ); double PerimeterFromInterceptCount( MapIntercept3Type & intercepts, const Spacing3Type spacing ); #endif /** Do we compute the feret diameter ? */ bool m_ComputeFeretDiameter; /** Do we compute the perimeter ? */ bool m_ComputePerimeter; /** Do we compute flusser moments ? */ bool m_ComputeFlusser; /** Do we polygonise ? */ bool m_ComputePolygon; /** Compute only a reduced attribute set */ bool m_ReducedAttributeSet; /** The label image is used to compute the feret diameter */ typename LabelImageType::ConstPointer m_LabelImage; }; } // End namespace Functor /** \class ShapeAttributesLabelMapFilter * \brief This class is a fork of the itk::ShapeLabelMapFilter working with AttributesMapLabelObject. * * The keys of the attributes inserted into the attributes map follow * the following rule: "SHAPE:NameOfAttributes". * * With respect to the original itk filter, this filter also compute * the Flusser moments for each LabelObject. * * The flag ReducedAttributesSet allows computing only non-redundant * statistics and statistics useful for classification (not spatially * dependent statitistics). Reduced set contains only Flusser moments, * physical size, elongation, Feret diameter (if activated), * perimeter (if activated) and roundness (if activated). * * For the sake of speed optimization, the original label image must * be given to the filter. If not, the filter will convert the * LabelObjectMap back to a LabelImage structure. * * \sa itk::ShapeLabelMapFilter * * \ingroup ImageEnhancement MathematicalMorphologyImageFilters * * \ingroup OTBLabelMap */ template > class ITK_EXPORT ShapeAttributesLabelMapFilter : public otb::LabelMapFeaturesFunctorImageFilter > { public: /** Template parameters typedefs */ typedef TImage ImageType; typedef typename ImageType::LabelObjectType LabelObjectType; typedef typename ImageType::RegionType InputImageRegionType; typedef TLabelImage LabelImageType; typedef Functor::ShapeAttributesLabelObjectFunctor FunctorType; /** Standard class typedefs. */ typedef ShapeAttributesLabelMapFilter Self; typedef LabelMapFeaturesFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename ImageType::Pointer ImagePointer; /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ShapeAttributesLabelMapFilter, LabelMapFeaturesFunctorImageFilter); /** * Set/Get whether the maximum Feret diameter should be computed or not. The * defaut value is false, because of the high computation time required. */ void SetComputeFeretDiameter(bool flag); bool GetComputeFeretDiameter() const; itkBooleanMacro(ComputeFeretDiameter); /** * Set/Get whether the perimeter should be computed or not. The defaut value * is false, because of the high computation time required. */ void SetComputePerimeter(bool flag); bool GetComputePerimeter() const; itkBooleanMacro(ComputePerimeter); /** * Set/Get whether the polygonalisation process should be computed or not. The default value * is true, to assure backward compatibility. */ void SetComputePolygon(bool flag); bool GetComputePolygon() const; itkBooleanMacro(ComputePolygon); /** * Set/Get whether the Flussrer moments should be computed or not. The default value * is true, to assure backward compatibility. */ void SetComputeFlusser(bool flag); bool GetComputeFlusser() const; itkBooleanMacro(ComputeFlusser); /** Set/get the ReducedAttributesSet flag */ void SetReducedAttributeSet(bool flag); bool GetReducedAttributeSet() const; itkBooleanMacro(ReducedAttributeSet); /** Set/Get the label image (this is used only to compute the Feret * diameter) */ void SetLabelImage(const TLabelImage *); const TLabelImage * GetLabelImage() const; protected: /** Constructor */ ShapeAttributesLabelMapFilter(){} /** Destructor */ ~ShapeAttributesLabelMapFilter() ITK_OVERRIDE{} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void AllocateOutputs() ITK_OVERRIDE; /** Things to to before threaded data generation */ void BeforeThreadedGenerateData() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void EnlargeOutputRequestedRegion(itk::DataObject *) ITK_OVERRIDE{}; private: ShapeAttributesLabelMapFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbShapeAttributesLabelMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbShapeAttributesLabelMapFilter.txx000066400000000000000000001230451301006202600301500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbShapeAttributesLabelMapFilter_txx #define otbShapeAttributesLabelMapFilter_txx #include "otbShapeAttributesLabelMapFilter.h" #include "itkProgressReporter.h" #include "itkConstNeighborhoodIterator.h" #include "itkConstShapedNeighborhoodIterator.h" #include "itkLabelMapToLabelImageFilter.h" #include "itkConstantBoundaryCondition.h" #include "itkGeometryUtilities.h" #include "itkConnectedComponentAlgorithm.h" #include "vnl/algo/vnl_real_eigensystem.h" #include "vnl/algo/vnl_symmetric_eigensystem.h" #include "otbMacro.h" #include namespace otb { namespace Functor { template ShapeAttributesLabelObjectFunctor ::ShapeAttributesLabelObjectFunctor() : m_ComputeFeretDiameter(false), m_ComputePerimeter(false), m_ComputeFlusser(true), m_ComputePolygon(true), m_ReducedAttributeSet(true), m_LabelImage(ITK_NULLPTR) {} /** The comparator (!=) */ template bool ShapeAttributesLabelObjectFunctor ::operator != (const Self &self) { // Initialize response bool resp = true; // Check for differences resp = resp && (m_ComputeFeretDiameter != self.m_ComputeFeretDiameter); resp = resp && (m_ComputePerimeter != self.m_ComputePerimeter); resp = resp && (m_ReducedAttributeSet != self.m_ReducedAttributeSet); resp = resp && (m_LabelImage != self.m_LabelImage); // Return return resp; } /** The comparator (==)*/ template bool ShapeAttributesLabelObjectFunctor ::operator == (const Self &self) { // Call the != implementation return !(this != self); } /** Set the compute perimeter flag */ template void ShapeAttributesLabelObjectFunctor ::SetComputePerimeter(bool flag) { m_ComputePerimeter = flag; } /** Get the compute perimeter flag */ template bool ShapeAttributesLabelObjectFunctor ::GetComputePerimeter() const { return m_ComputePerimeter; } /** Set the compute polygon flag */ template void ShapeAttributesLabelObjectFunctor ::SetComputePolygon(bool flag) { m_ComputePolygon = flag; } /** Get the compute polygon flag */ template bool ShapeAttributesLabelObjectFunctor ::GetComputePolygon() const { return m_ComputePolygon; } /** Set the compute Flusser flag */ template void ShapeAttributesLabelObjectFunctor ::SetComputeFlusser(bool flag) { m_ComputeFlusser = flag; } /** Get the compute Flusser flag */ template bool ShapeAttributesLabelObjectFunctor ::GetComputeFlusser() const { return m_ComputeFlusser; } /** Set the compute feret diameter flag */ template void ShapeAttributesLabelObjectFunctor ::SetComputeFeretDiameter(bool flag) { m_ComputeFeretDiameter = flag; } /** Get the compute feret diameter flag */ template bool ShapeAttributesLabelObjectFunctor ::GetComputeFeretDiameter() const { return m_ComputeFeretDiameter; } /** Set the compute reduced attributes set flag */ template void ShapeAttributesLabelObjectFunctor ::SetReducedAttributeSet(bool flag) { m_ReducedAttributeSet = flag; } /** Get the compute reduced attributes set flag */ template bool ShapeAttributesLabelObjectFunctor ::GetReducedAttributeSet() const { return m_ReducedAttributeSet; } /** Set the label image (used only to compute * the Feret diameter */ template void ShapeAttributesLabelObjectFunctor ::SetLabelImage(const TLabelImage * image) { m_LabelImage = image; } /** Get the label image */ template const TLabelImage * ShapeAttributesLabelObjectFunctor ::GetLabelImage() const { return m_LabelImage; } /** This is the functor implementation * Calling the functor on a label object * will update its shape attributes */ template void ShapeAttributesLabelObjectFunctor ::operator() (LabelObjectType * lo) { const typename LabelObjectType::LabelType& label = lo->GetLabel(); // TODO: compute sizePerPixel, borderMin and borderMax in BeforeThreadedGenerateData() ? // compute the size per pixel, to be used later double sizePerPixel = 1; for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { sizePerPixel *= vcl_abs(m_LabelImage->GetSpacing()[i]); } typename std::vector sizePerPixelPerDimension; for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { sizePerPixelPerDimension.push_back(sizePerPixel / vcl_abs(m_LabelImage->GetSpacing()[i])); } // compute the max the index on the border of the image typename LabelObjectType::IndexType borderMin = m_LabelImage->GetLargestPossibleRegion().GetIndex(); typename LabelObjectType::IndexType borderMax = borderMin; for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { borderMax[i] += borderMin[i] + m_LabelImage->GetLargestPossibleRegion().GetSize()[i] - 1; } // init the vars unsigned long size = 0; itk::ContinuousIndex centroid; centroid.Fill(0); typename LabelObjectType::IndexType mins; mins.Fill(itk::NumericTraits::max()); typename LabelObjectType::IndexType maxs; maxs.Fill(itk::NumericTraits::NonpositiveMin()); unsigned long sizeOnBorder = 0; double physicalSizeOnBorder = 0; itk::Matrix centralMoments; centralMoments.Fill(0); ConstLineIteratorType lit = ConstLineIteratorType(lo); lit.GoToBegin(); //lit = IteratorType( ref ); //typename LabelObjectType::LineContainerType& lineContainer = lo->GetLineContainer(); // iterate over all the lines while ( !lit.IsAtEnd() ) //for (lit = lineContainer.begin(); lit != lineContainer.end(); lit++) { const typename LabelObjectType::IndexType& idx = lit.GetLine().GetIndex(); unsigned long length = lit.GetLine().GetLength(); // update the size size += length; // update the centroid - and report the progress // first, update the axes which are not 0 for (DimensionType i = 1; i < LabelObjectType::ImageDimension; ++i) { centroid[i] += length * idx[i]; } // then, update the axis 0 centroid[0] += idx[0] * length + (length * (length - 1)) / 2.0; // update the mins and maxs for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { if (idx[i] < mins[i]) { mins[i] = idx[i]; } if (idx[i] > maxs[i]) { maxs[i] = idx[i]; } } // must fix the max for the axis 0 if (idx[0] + (long) length > maxs[0]) { maxs[0] = idx[0] + length - 1; } // object is on a border ? bool isOnBorder = false; for (DimensionType i = 1; i < LabelObjectType::ImageDimension; ++i) { if (idx[i] == borderMin[i] || idx[i] == borderMax[i]) { isOnBorder = true; break; } } if (isOnBorder) { // the line touch a border on a dimension other than 0, so // all the line touch a border sizeOnBorder += length; } else { // we must check for the dimension 0 bool isOnBorder0 = false; if (idx[0] == borderMin[0]) { // one more pixel on the border sizeOnBorder++; isOnBorder0 = true; } if (!isOnBorder0 || length > 1) { // we can check for the end of the line if (idx[0] + (long) length - 1 == borderMax[0]) { // one more pixel on the border sizeOnBorder++; } } } // physical size on border // first, the dimension 0 if (idx[0] == borderMin[0]) { // the beginning of the line physicalSizeOnBorder += sizePerPixelPerDimension[0]; } if (idx[0] + (long) length - 1 == borderMax[0]) { // and the end of the line physicalSizeOnBorder += sizePerPixelPerDimension[0]; } // then the other dimensions for (DimensionType i = 1; i < LabelObjectType::ImageDimension; ++i) { if (idx[i] == borderMin[i]) { // one border physicalSizeOnBorder += sizePerPixelPerDimension[i] * length; } if (idx[i] == borderMax[i]) { // and the other physicalSizeOnBorder += sizePerPixelPerDimension[i] * length; } } /* // moments computation // **************************************************************** // that commented code is the basic implementation. The next piece of code // give the same result in a much efficient way, by using expanded formulae // allowed by the binary case instead of loops. // **************************************************************** long endIdx0 = idx[0] + length; for( typename LabelObjectType::IndexType iidx = idx; iidx[0]TransformIndexToPhysicalPoint(iidx, pP); for(unsigned int i=0; iTransformIndexToPhysicalPoint(idx, physicalPosition); const typename TLabelImage::SpacingType& spacing = m_LabelImage->GetSpacing(); // the sum of x positions, also reused several times double sumX = length * (physicalPosition[0] + (spacing[0] * (length - 1)) / 2.0); // the real job - the sum of square of x positions // that's the central moments for dims 0, 0 centralMoments[0][0] += length * (physicalPosition[0] * physicalPosition[0] + spacing[0] * (length - 1) * ((spacing[0] * (2 * length - 1)) / 6.0 + physicalPosition[0])); // the other ones for (DimensionType i = 1; i < LabelObjectType::ImageDimension; ++i) { // do this one here to avoid the double assignment in the following loop // when i == j centralMoments[i][i] += length * physicalPosition[i] * physicalPosition[i]; // central moments are symmetrics, so avoid to compute them 2 times for (DimensionType j = i + 1; j < LabelObjectType::ImageDimension; ++j) { // note that we won't use that code if the image dimension is less than 3 // --> the tests should be in 3D at least double cm = length * physicalPosition[i] * physicalPosition[j]; centralMoments[i][j] += cm; centralMoments[j][i] += cm; } // the last moments: the ones for the dimension 0 double cm = sumX * physicalPosition[i]; centralMoments[i][0] += cm; centralMoments[0][i] += cm; } ++lit; } // final computation typename TLabelImage::SizeType regionSize; double minSize = itk::NumericTraits::max(); double maxSize = itk::NumericTraits::NonpositiveMin(); for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { centroid[i] /= size; regionSize[i] = maxs[i] - mins[i] + 1; double s = regionSize[i] * vcl_abs(m_LabelImage->GetSpacing()[i]); minSize = std::min(s, minSize); maxSize = std::max(s, maxSize); for (DimensionType j = 0; j < LabelObjectType::ImageDimension; ++j) { centralMoments[i][j] /= size; } } typename TLabelImage::RegionType region(mins, regionSize); typename TLabelImage::PointType physicalCentroid; m_LabelImage->TransformContinuousIndexToPhysicalPoint(centroid, physicalCentroid); // Center the second order moments for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { for (DimensionType j = 0; j < LabelObjectType::ImageDimension; ++j) { centralMoments[i][j] -= physicalCentroid[i] * physicalCentroid[j]; } } // Compute principal moments and axes itk::Vector principalMoments; vnl_symmetric_eigensystem eigen(centralMoments.GetVnlMatrix()); vnl_diag_matrix pm = eigen.D; for (unsigned int i = 0; i < LabelObjectType::ImageDimension; ++i) { // principalMoments[i] = 4 * vcl_sqrt( pm(i, i) ); principalMoments[i] = pm(i, i); } itk::Matrix principalAxes = eigen.V.transpose(); // Add a final reflection if needed for a proper rotation, // by multiplying the last row by the determinant vnl_real_eigensystem eigenrot(principalAxes.GetVnlMatrix()); vnl_diag_matrix > eigenval = eigenrot.D; vcl_complex det(1.0, 0.0); for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { det *= eigenval(i, i); } for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { principalAxes[LabelObjectType::ImageDimension - 1][i] *= std::real(det); } double elongation = 0; if (principalMoments[LabelObjectType::ImageDimension - 2] != 0) { elongation = vcl_sqrt(principalMoments[LabelObjectType::ImageDimension - 1] / principalMoments[LabelObjectType::ImageDimension - 2]); } double physicalSize = size * sizePerPixel; double equivalentRadius = hyperSphereRadiusFromVolume(physicalSize); double equivalentPerimeter = hyperSpherePerimeter(equivalentRadius); // compute equilalent ellipsoid radius itk::Vector ellipsoidSize; double edet = 1.0; for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { edet *= principalMoments[i]; } edet = vcl_pow(edet, 1.0 / LabelObjectType::ImageDimension); for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { ellipsoidSize[i] = 2.0 * equivalentRadius * vcl_sqrt(principalMoments[i] / edet); } if (m_ComputeFlusser) { // Flusser moments (only make sense when ImageDimension == 2) if (LabelObjectType::ImageDimension == 2) { // complex centered moments std::complex c11, c20, c12, c21, c22, c30, c31, c40; c11 = c20 = c12 = c21 = c22 = c30 = c31 = c40 = std::complex(0, 0); // Update the line iterator to the beginning lit.GoToBegin(); //for (lit = lineContainer.begin(); lit != lineContainer.end(); //lit++) while ( ! lit.IsAtEnd() ) { const typename LabelObjectType::IndexType& idx = lit.GetLine().GetIndex(); unsigned long length = lit.GetLine().GetLength(); // long endIdx0 = idx[0] + length; for (typename LabelObjectType::IndexType iidx = idx; iidx[0] < endIdx0; iidx[0]++) { typename TLabelImage::PointType cPP; m_LabelImage->TransformIndexToPhysicalPoint(iidx, cPP); cPP -= physicalCentroid.GetVectorFromOrigin(); std::complex xpiy(cPP[0], cPP[1]); // x + i y std::complex xmiy(cPP[0], -cPP[1]); // x - i y c11 += xpiy * xmiy; c20 += xpiy * xpiy; c12 += xpiy * xmiy * xmiy; c21 += xpiy * xpiy * xmiy; c30 += xpiy * xpiy * xpiy; c22 += xpiy * xpiy * xmiy * xmiy; c31 += xpiy * xpiy * xpiy * xmiy; c40 += xpiy * xpiy * xpiy * xpiy; } ++lit; } // normalize c11 /= physicalSize * physicalSize; c20 /= physicalSize * physicalSize; c12 /= vcl_pow(physicalSize, 5.0 / 2); c21 /= vcl_pow(physicalSize, 5.0 / 2); c30 /= vcl_pow(physicalSize, 5.0 / 2); c22 /= vcl_pow(physicalSize, 3); c31 /= vcl_pow(physicalSize, 3); c40 /= vcl_pow(physicalSize, 3); lo->SetAttribute("SHAPE::Flusser01", c11.real()); lo->SetAttribute("SHAPE::Flusser02", (c21 * c12).real()); lo->SetAttribute("SHAPE::Flusser03", (c20 * vcl_pow(c12, 2)).real()); lo->SetAttribute("SHAPE::Flusser04", (c20 * vcl_pow(c12, 2)).imag()); lo->SetAttribute("SHAPE::Flusser05", (c30 * vcl_pow(c12, 3)).real()); lo->SetAttribute("SHAPE::Flusser06", (c30 * vcl_pow(c12, 3)).imag()); lo->SetAttribute("SHAPE::Flusser07", c22.real()); lo->SetAttribute("SHAPE::Flusser08", (c31 * vcl_pow(c12, 2)).real()); lo->SetAttribute("SHAPE::Flusser09", (c31 * vcl_pow(c12, 2)).imag()); lo->SetAttribute("SHAPE::Flusser10", (c40 * vcl_pow(c12, 4)).real()); lo->SetAttribute("SHAPE::Flusser11", (c40 * vcl_pow(c12, 4)).imag()); } } // Set the attributes if (m_ComputePolygon) { PolygonFunctorType polygonFunctor; SimplifyPolygonFunctorType simplifyFunctor; polygonFunctor.SetStartIndex(m_LabelImage->GetLargestPossibleRegion().GetIndex()); polygonFunctor.SetOrigin(m_LabelImage->GetOrigin()); polygonFunctor.SetSpacing(m_LabelImage->GetSpacing()); typename PolygonType::Pointer polygon = simplifyFunctor(polygonFunctor(lo)); lo->SetPolygon(polygon); } // Physical size lo->SetAttribute("SHAPE::PhysicalSize", physicalSize); // Elongation lo->SetAttribute("SHAPE::Elongation", elongation); if (m_ComputeFeretDiameter) { // init the vars unsigned long ssize = 0; typedef typename std::deque IndexListType; IndexListType idxList; // Line iterator ConstLineIteratorType llit = ConstLineIteratorType(lo); llit.GoToBegin(); typedef typename itk::ConstNeighborhoodIterator NeighborIteratorType; typename TLabelImage::SizeType neighborHoodRadius; neighborHoodRadius.Fill(1); NeighborIteratorType it(neighborHoodRadius, m_LabelImage, m_LabelImage->GetBufferedRegion()); itk::ConstantBoundaryCondition lcbc; // use label + 1 to have a label different of the current label on the border lcbc.SetConstant(label + 1); it.OverrideBoundaryCondition(&lcbc); it.GoToBegin(); // iterate over all the lines while ( !llit.IsAtEnd() ) { const typename LabelObjectType::IndexType& firstIdx = llit.GetLine().GetIndex(); unsigned long length = llit.GetLine().GetLength(); long endIdx0 = firstIdx[0] + length; for (typename LabelObjectType::IndexType idx = firstIdx; idx[0] < endIdx0; idx[0]++) { // move the iterator to the new location it += idx - it.GetIndex(); // push the pixel in the list if it is on the border of the object for (unsigned i = 0; i < it.Size(); ++i) { if (it.GetPixel(i) != label) { idxList.push_back(idx); ssize++; break; } } } ++llit; } // we can now search the feret diameter double feretDiameter = 0; for (typename IndexListType::const_iterator iIt1 = idxList.begin(); iIt1 != idxList.end(); iIt1++) { typename IndexListType::const_iterator iIt2 = iIt1; for (iIt2++; iIt2 != idxList.end(); iIt2++) { // Compute the length between the 2 indexes double length = 0; for (DimensionType i = 0; i < LabelObjectType::ImageDimension; ++i) { length += vcl_pow((iIt1->operator[] (i) - iIt2->operator[] (i)) * m_LabelImage->GetSpacing()[i], 2); } if (feretDiameter < length) { feretDiameter = length; } } } // final computation feretDiameter = vcl_sqrt(feretDiameter); // finally put the values in the label object lo->SetAttribute("SHAPE::FeretDiameter", feretDiameter); } // be sure that the calculator has the perimeter estimation for that label. // The calculator may not have the label if the object is only on a border. // It will occur for sure when processing a 2D image with a 3D filter. if (m_ComputePerimeter) { double perimeter = this->ComputePerimeter(lo,region); //double perimeter = lo->ComputePerimeter(); lo->SetAttribute("SHAPE::Perimeter", perimeter); lo->SetAttribute("SHAPE::Roundness", equivalentPerimeter / perimeter); } // Complete feature set if (!m_ReducedAttributeSet) { lo->SetAttribute("SHAPE::Size", size); std::ostringstream oss; for (unsigned int dim = 0; dim < LabelObjectType::ImageDimension; ++dim) { oss.str(""); oss << "SHAPE::RegionIndex" << dim; lo->SetAttribute(oss.str().c_str(), region.GetIndex()[dim]); oss.str(""); oss << "SHAPE::RegionSize" << dim; lo->SetAttribute(oss.str().c_str(), region.GetSize()[dim]); oss.str(""); oss << "SHAPE::PhysicalCentroid" << dim; lo->SetAttribute(oss.str().c_str(), physicalCentroid[dim]); oss.str(""); oss << "SHAPE::EquivalentEllipsoidRadius" << dim; lo->SetAttribute(oss.str().c_str(), ellipsoidSize[dim]); oss.str(""); oss << "SHAPE::PrincipalMoments" << dim; lo->SetAttribute(oss.str().c_str(), principalMoments[dim]); for (unsigned int dim2 = 0; dim2 < LabelObjectType::ImageDimension; ++dim2) { oss.str(""); oss << "SHAPE::PrincipalAxis" << dim << dim2; lo->SetAttribute(oss.str().c_str(), principalAxes(dim, dim2)); } } lo->SetAttribute("SHAPE::RegionElongation", maxSize / minSize); lo->SetAttribute("SHAPE::RegionRatio", size / (double) region.GetNumberOfPixels()); lo->SetAttribute("SHAPE::SizeOnBorder", sizeOnBorder); lo->SetAttribute("SHAPE::PhysicalSizeOnBorder", physicalSizeOnBorder); lo->SetAttribute("SHAPE::EquivalentPerimeter", equivalentPerimeter); lo->SetAttribute("SHAPE::EquivalentRadius", equivalentRadius); } } template double ShapeAttributesLabelObjectFunctor ::ComputePerimeter(LabelObjectType *labelObject, const RegionType & region) { // store the lines in a N-1D image of vectors typedef std::deque< typename LabelObjectType::LineType > VectorLineType; typedef itk::Image< VectorLineType, ImageDimension - 1 > LineImageType; typename LineImageType::Pointer lineImage = LineImageType::New(); typename LineImageType::IndexType lIdx; typename LineImageType::SizeType lSize; RegionType boundingBox = region; for( DimensionType i=0; iSetRegions( elRegion ); lineImage->Allocate(); lineImage->FillBuffer( VectorLineType() ); // std::cout << "lineContainer.size(): " << lineContainer.size() << std::endl; // Iterate over all the lines and fill the image of lines typename LabelObjectType::ConstLineIterator lit( labelObject ); while( ! lit.IsAtEnd() ) { const typename TLabelObject::IndexType & idx = lit.GetLine().GetIndex(); for( DimensionType i=0; iGetPixel( lIdx ).push_back( lit.GetLine() ); ++lit; } // a data structure to store the number of intercepts on each direction typedef typename std::map MapInterceptType; MapInterceptType intercepts; // int nbOfDirections = (int)vcl_pow( 2.0, (int)ImageDimension ) - 1; // intecepts.resize(nbOfDirections + 1); // code begins at position 1 // now iterate over the vectors of lines typedef itk::ConstShapedNeighborhoodIterator< LineImageType > LineImageIteratorType; LineImageIteratorType lIt( lSize, lineImage, lRegion ); // the original, non padded region setConnectivity( &lIt, true ); for( lIt.GoToBegin(); !lIt.IsAtEnd(); ++lIt ) { const VectorLineType & ls = lIt.GetCenterPixel(); // there are two intercepts on the 0 axis for each line OffsetType no; no.Fill(0); no[0] = 1; // std::cout << no << "-> " << 2 * ls.size() << std::endl; intercepts[no] += 2 * ls.size(); // and look at the neighbors typename LineImageIteratorType::ConstIterator ci; for (ci = lIt.Begin(); ci != lIt.End(); ci++) { // std::cout << "-------------" << std::endl; // the vector of lines in the neighbor const VectorLineType & ns = ci.Get(); // prepare the offset to be stored in the intercepts map typename LineImageType::OffsetType lno = ci.GetNeighborhoodOffset(); no[0] = 0; for( DimensionType i=0; i::NonpositiveMin() // or end at NumericTraits::max() typename VectorLineType::const_iterator li = ls.begin(); typename VectorLineType::const_iterator ni = ns.begin(); itk::IndexValueType lZero = 0; itk::IndexValueType lMin = 0; itk::IndexValueType lMax = 0; itk::IndexValueType nMin = itk::NumericTraits::NonpositiveMin() + 1; itk::IndexValueType nMax = ni->GetIndex()[0] - 1; while( li!=ls.end() ) { // update the current line min and max. Neighbor line data is already up to date. lMin = li->GetIndex()[0]; lMax = lMin + li->GetLength() - 1; // add as much intercepts as intersections of the 2 lines intercepts[no] += vnl_math_max( lZero, vnl_math_min(lMax, nMax) - vnl_math_max(lMin, nMin) + 1 ); // std::cout << "============" << std::endl; // std::cout << " lMin:" << lMin << " lMax:" << lMax << " nMin:" << nMin << " nMax:" << nMax; // std::cout << " count: " << vnl_math_max( 0l, vnl_math_min(lMax, nMax) - vnl_math_max(lMin, nMin) + 1 ) << std::endl; // std::cout << " " << no << ": " << intercepts[no] << std::endl; // std::cout << vnl_math_max( lZero, vnl_math_min(lMax, nMax+1) - vnl_math_max(lMin, nMin+1) + 1 ) << std::endl; // std::cout << vnl_math_max( lZero, vnl_math_min(lMax, nMax-1) - vnl_math_max(lMin, nMin-1) + 1 ) << std::endl; // left diagonal intercepts intercepts[dno] += vnl_math_max( lZero, vnl_math_min(lMax, nMax+1) - vnl_math_max(lMin, nMin+1) + 1 ); // right diagonal intercepts intercepts[dno] += vnl_math_max( lZero, vnl_math_min(lMax, nMax-1) - vnl_math_max(lMin, nMin-1) + 1 ); // go to the next line or the next neighbor depending on where we are if(nMax <= lMax ) { // go to next neighbor nMin = ni->GetIndex()[0] + ni->GetLength(); ni++; if( ni != ns.end() ) { nMax = ni->GetIndex()[0] - 1; } else { nMax = itk::NumericTraits::max() - 1; } } else { // go to next line li++; } } } } } // compute the perimeter based on the intercept counts double perimeter = PerimeterFromInterceptCount( intercepts, m_LabelImage->GetSpacing() ); return perimeter; } template template double ShapeAttributesLabelObjectFunctor ::PerimeterFromInterceptCount( TMapIntercept & intercepts, const TSpacing & spacing ) { // std::cout << "PerimeterFromInterceptCount<>" << std::endl; double perimeter = 0.0; double pixelSize = 1.0; int dim = TSpacing::GetVectorDimension(); for ( int i = 0; i < dim; i++ ) { pixelSize *= spacing[i]; } for( int i=0; i double ShapeAttributesLabelObjectFunctor ::PerimeterFromInterceptCount( MapIntercept2Type & intercepts, const Spacing2Type spacing ) { // std::cout << "PerimeterFromInterceptCount2" << std::endl; double dx = spacing[0]; double dy = spacing[1]; Offset2Type nx = {{1, 0}}; Offset2Type ny = {{0, 1}}; Offset2Type nxy = {{1, 1}}; // std::cout << "nx: " << intercepts[nx] << std::endl; // std::cout << "ny: " << intercepts[ny] << std::endl; // std::cout << "nxy: " << intercepts[nxy] << std::endl; double perimeter = 0.0; perimeter += dy * intercepts[nx]/2.0; perimeter += dx * intercepts[ny]/2.0; perimeter += dx*dy / spacing.GetNorm() * intercepts[nxy]/2.0; perimeter *= itk::Math::pi / 4.0; return perimeter; }; template double ShapeAttributesLabelObjectFunctor ::PerimeterFromInterceptCount( MapIntercept3Type & intercepts, const Spacing3Type spacing ) { // std::cout << "PerimeterFromInterceptCount3" << std::endl; double dx = spacing[0]; double dy = spacing[1]; double dz = spacing[2]; double dxy = vcl_sqrt( spacing[0]*spacing[0] + spacing[1]*spacing[1] ); double dxz = vcl_sqrt( spacing[0]*spacing[0] + spacing[2]*spacing[2] ); double dyz = vcl_sqrt( spacing[1]*spacing[1] + spacing[2]*spacing[2] ); double dxyz = vcl_sqrt( spacing[0]*spacing[0] + spacing[1]*spacing[1] + spacing[2]*spacing[2] ); double vol = spacing[0]*spacing[1]*spacing[2]; // 'magical numbers', corresponding to area of voronoi partition on the // unit sphere, when germs are the 26 directions on the unit cube // Sum of (c1+c2+c3 + c4*2+c5*2+c6*2 + c7*4) equals 1. double c1 = 0.04577789120476 * 2; // Ox double c2 = 0.04577789120476 * 2; // Oy double c3 = 0.04577789120476 * 2; // Oz double c4 = 0.03698062787608 * 2; // Oxy double c5 = 0.03698062787608 * 2; // Oxz double c6 = 0.03698062787608 * 2; // Oyz double c7 = 0.03519563978232 * 2; // Oxyz // TODO - recompute those values if the spacing is non isotrope Offset3Type nx = {{1, 0, 0}}; Offset3Type ny = {{0, 1, 0}}; Offset3Type nz = {{0, 0, 1}}; Offset3Type nxy = {{1, 1, 0}}; Offset3Type nxz = {{1, 0, 1}}; Offset3Type nyz = {{0, 1, 1}}; Offset3Type nxyz = {{1, 1, 1}}; // std::cout << "nx: " << intercepts[nx] << std::endl; // std::cout << "ny: " << intercepts[ny] << std::endl; // std::cout << "nz: " << intercepts[nz] << std::endl; // std::cout << "nxy: " << intercepts[nxy] << std::endl; // std::cout << "nxz: " << intercepts[nxz] << std::endl; // std::cout << "nyz: " << intercepts[nyz] << std::endl; // std::cout << "nxyz: " << intercepts[nxyz] << std::endl; double perimeter = 0.0; perimeter += vol/dx * intercepts[nx]/2.0 * c1; perimeter += vol/dy * intercepts[ny]/2.0 * c2; perimeter += vol/dz * intercepts[nz]/2.0 * c3; perimeter += vol/dxy * intercepts[nxy]/2.0 * c4; perimeter += vol/dxz * intercepts[nxz]/2.0 * c5; perimeter += vol/dyz * intercepts[nyz]/2.0 * c6; perimeter += vol/dxyz * intercepts[nxyz]/2.0 * c7; perimeter *= 4; return perimeter; }; #endif /** Convenience internal method */ template long ShapeAttributesLabelObjectFunctor ::factorial(long n) { if (n < 1) { return 1; } return n * factorial(n - 1); } /** Convenience internal method */ template long ShapeAttributesLabelObjectFunctor ::doubleFactorial(long n) { if (n < 2) { return 1; } return n * doubleFactorial(n - 2); } /** Convenience internal method */ template double ShapeAttributesLabelObjectFunctor ::gammaN2p1(long n) { bool even = n % 2 == 0; if (even) { return factorial(n / 2); } else { return otb::CONST_SQRTPI * doubleFactorial(n) / vcl_pow(2, (n + 1) / 2.0); } } /** Convenience internal method */ template double ShapeAttributesLabelObjectFunctor ::hyperSphereVolume(double radius) { return vcl_pow(otb::CONST_PI, LabelObjectType::ImageDimension / 2.0) * vcl_pow(radius, LabelObjectType::ImageDimension) / gammaN2p1(LabelObjectType::ImageDimension); } /** Convenience internal method */ template double ShapeAttributesLabelObjectFunctor ::hyperSpherePerimeter(double radius) { return LabelObjectType::ImageDimension * hyperSphereVolume(radius) / radius; } /** Convenience internal method */ template double ShapeAttributesLabelObjectFunctor ::hyperSphereRadiusFromVolume(double volume) { return vcl_pow(volume * gammaN2p1(LabelObjectType::ImageDimension) / vcl_pow(otb::CONST_PI, LabelObjectType::ImageDimension / 2.0), 1.0 / LabelObjectType::ImageDimension); } } // End namespace Functor template void ShapeAttributesLabelMapFilter ::SetComputeFeretDiameter(bool flag) { if (this->GetFunctor().GetComputeFeretDiameter() != flag) { this->GetFunctor().SetComputeFeretDiameter(flag); this->Modified(); } } template bool ShapeAttributesLabelMapFilter ::GetComputeFeretDiameter() const { return this->GetFunctor().GetComputeFeretDiameter(); } template void ShapeAttributesLabelMapFilter ::SetComputePerimeter(bool flag) { if (this->GetFunctor().GetComputePerimeter() != flag) { this->GetFunctor().SetComputePerimeter(flag); this->Modified(); } } template bool ShapeAttributesLabelMapFilter ::GetComputePerimeter() const { return this->GetFunctor().GetComputePerimeter(); } template void ShapeAttributesLabelMapFilter ::SetComputePolygon(bool flag) { if (this->GetFunctor().GetComputePolygon() != flag) { this->GetFunctor().SetComputePolygon(flag); this->Modified(); } } template bool ShapeAttributesLabelMapFilter ::GetComputePolygon() const { return this->GetFunctor().GetComputePolygon(); } template void ShapeAttributesLabelMapFilter ::SetComputeFlusser(bool flag) { if (this->GetFunctor().GetComputeFlusser() != flag) { this->GetFunctor().SetComputeFlusser(flag); this->Modified(); } } template bool ShapeAttributesLabelMapFilter ::GetComputeFlusser() const { return this->GetFunctor().GetComputeFlusser(); } template void ShapeAttributesLabelMapFilter ::SetReducedAttributeSet(bool flag) { if (this->GetFunctor().GetReducedAttributeSet() != flag) { this->GetFunctor().SetReducedAttributeSet(flag); this->Modified(); } } template bool ShapeAttributesLabelMapFilter ::GetReducedAttributeSet() const { return this->GetFunctor().GetReducedAttributeSet(); } template void ShapeAttributesLabelMapFilter ::SetLabelImage(const TLabelImage * img) { if (this->GetFunctor().GetLabelImage() != img) { this->GetFunctor().SetLabelImage(img); this->Modified(); } } template const TLabelImage * ShapeAttributesLabelMapFilter ::GetLabelImage() const { return this->GetFunctor().GetLabelImage(); } template void ShapeAttributesLabelMapFilter ::AllocateOutputs() { // if told to run in place and the types support it, if( this->GetInPlace() && this->CanRunInPlace() ) { // Graft this first input to the output. Later, we'll need to // remove the input's hold on the bulk data. // ImagePointer inputAsOutput = dynamic_cast(const_cast(this->GetInput())); if( inputAsOutput ) { this->GraftOutput( inputAsOutput ); this->GetOutput()->SetLargestPossibleRegion(this->GetOutput()->GetLargestPossibleRegion()); this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); this->GetOutput()->SetBufferedRegion(this->GetOutput()->GetBufferedRegion()); } // If there are more than one outputs, allocate the remaining outputs for (unsigned int i=1; i < this->GetNumberOfOutputs(); ++i) { ImagePointer outputPtr; outputPtr = this->GetOutput(i); outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); } } else { // Superclass::AllocateOutputs(); // copy the content of the input image to the output image (will be done by ImageSource AllocateOutputs Method) // would never occur : inputasoutput condition is always true, since output and input type is TImage for // ShapeAttributesLabelMapFilter class } } template void ShapeAttributesLabelMapFilter ::GenerateInputRequestedRegion() { itk::ImageToImageFilter::GenerateInputRequestedRegion(); } template void ShapeAttributesLabelMapFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); if (!this->GetFunctor().GetLabelImage()) { // generate an image of the labelized image typedef itk::LabelMapToLabelImageFilter LCI2IType; typename LCI2IType::Pointer lci2i = LCI2IType::New(); lci2i->SetInput(this->GetInput()); // respect the number of threads of the filter lci2i->SetNumberOfThreads(this->GetNumberOfThreads()); lci2i->Update(); this->GetFunctor().SetLabelImage(lci2i->GetOutput()); } /* // delegate the computation of the perimeter to a dedicated calculator */ /* if (this->GetFunctor().GetComputePerimeter()) */ /* { */ /* typename PerimeterCalculatorType::Pointer pc = PerimeterCalculatorType::New(); */ /* pc->SetImage(this->GetFunctor().GetLabelImage()); */ /* pc->Compute(); */ /* this->GetFunctor().SetPerimeterCalculator(pc); */ /* } */ } template void ShapeAttributesLabelMapFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "ComputeFeretDiameter: " << this->GetFunctor().GetComputeFeretDiameter() << std::endl; os << indent << "ComputePerimeter: " << this->GetFunctor().GetComputePerimeter() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbStatisticsAttributesLabelMapFilter.h000066400000000000000000000146141301006202600306470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStatisticsAttributesLabelMapFilter_h #define otbStatisticsAttributesLabelMapFilter_h #include "otbLabelMapFeaturesFunctorImageFilter.h" #include "itkMatrix.h" #include "itkVector.h" namespace otb { namespace Functor { /** \class StatisticsAttributesLabelObjectFunctor * \brief Functor to compute statistics attributes of one LabelObject. * * \sa StatisticsAttributesLabelMapFilter * * \ingroup OTBLabelMap */ template class StatisticsAttributesLabelObjectFunctor { public: // Self typedef typedef StatisticsAttributesLabelObjectFunctor Self; // Matrix typedef typedef typename itk::Matrix MatrixType; // Vector typedef typedef typename itk::Vector VectorType; /// Typedef of the feature image type typedef typename TFeatureImage::PixelType FeatureType; /// Typedef of the label object typedef TLabelObject LabelObjectType; /** Const iterator over LabelObject lines */ typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType; /** Constructor */ StatisticsAttributesLabelObjectFunctor(); /** Destructor */ virtual ~StatisticsAttributesLabelObjectFunctor(); /** The comparators */ bool operator !=(const Self& self); bool operator ==(const Self& self); /** This is the functor implementation * Calling the functor on a label object * will update its statistics attributes */ inline void operator ()(LabelObjectType * lo) const; /** Set the name of the feature */ void SetFeatureName(const std::string& name); /** Get the feature name */ const std::string& GetFeatureName() const; /** Set the feature image */ void SetFeatureImage(const TFeatureImage * img); /** Get the feature image */ const TFeatureImage * GetFeatureImage() const; /** Set the reduced attribute set */ void SetReducedAttributeSet(bool flag); /** Get the reduced attribute set */ bool GetReducedAttributeSet() const; private: // The name of the feature std::string m_FeatureName; // The feature image typename TFeatureImage::ConstPointer m_FeatureImage; // True to compute only a reduced attribute set bool m_ReducedAttributeSet; }; } // End namespace Functor /** \class StatisticsAttributesLabelMapFilter * \brief This class is a fork of itk::StasticsLabelMapFilter to support AttributesMapLabelObject. * * To be able to support statistics attributes for multiple features * into the same AttributesMapLabelObject, a feature name can be * set. The key of the statistics features in the attributes map will * be "STATS::FeatureName::StatisticName". * * The flag ReducedAttributesSet allows computing only non-redundant * statistics and statistics useful for classification (not spatially * dependent statitistics). Reduced set contains only mean, variance, * skewness and kurtosis. * * \sa itk::StatisticsLabelMapFilter * * \ingroup ImageEnhancement MathematicalMorphologyImageFilters * * \ingroup OTBLabelMap */ template class ITK_EXPORT StatisticsAttributesLabelMapFilter : public LabelMapFeaturesFunctorImageFilter > { public: /** Some convenient typedefs. */ typedef TImage ImageType; typedef typename ImageType::LabelObjectType LabelObjectType; typedef TFeatureImage FeatureImageType; /** Functor typedef */ typedef Functor::StatisticsAttributesLabelObjectFunctor FunctorType; /** Standard class typedefs. */ typedef StatisticsAttributesLabelMapFilter Self; typedef LabelMapFeaturesFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(StatisticsAttributesLabelMapFilter, LabelMapFeaturesFunctorImageFilter); /** Set the feature image */ void SetFeatureImage(const TFeatureImage *input); /** Get the feature image */ const FeatureImageType * GetFeatureImage() const; /** Set Input1 (for backward compatibility) */ void SetInput1(const TImage * input); /** Get Input1 (for backward compatibility) */ const TImage * GetInput1() const; /** Set Input2 (for backward compatibility) */ void SetInput2(const TFeatureImage * input); /** Get Input2 (for backward compatibility) */ const TFeatureImage * GetInput2() const; /** Set the name of the feature */ void SetFeatureName(const std::string& name); /** Get the feature name */ const std::string& GetFeatureName() const; /** Set the reduced attribute set */ void SetReducedAttributeSet(bool flag); /** Get the reduced attribute set */ bool GetReducedAttributeSet() const; itkBooleanMacro(ReducedAttributeSet); protected: /** Constructor */ StatisticsAttributesLabelMapFilter(); /** Destructor */ ~StatisticsAttributesLabelMapFilter() ITK_OVERRIDE; /** Before threaded data generation */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: StatisticsAttributesLabelMapFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStatisticsAttributesLabelMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/LabelMap/include/otbStatisticsAttributesLabelMapFilter.txx000066400000000000000000000343551301006202600312470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStatisticsAttributesLabelMapFilter_txx #define otbStatisticsAttributesLabelMapFilter_txx #include "otbStatisticsAttributesLabelMapFilter.h" #include "vnl/algo/vnl_real_eigensystem.h" #include "vnl/algo/vnl_symmetric_eigensystem.h" namespace otb { namespace Functor { /** Constructor */ template StatisticsAttributesLabelObjectFunctor ::StatisticsAttributesLabelObjectFunctor() : m_FeatureName("Default"), m_FeatureImage(), m_ReducedAttributeSet(true) {} /** Destructor */ template StatisticsAttributesLabelObjectFunctor ::~StatisticsAttributesLabelObjectFunctor() {} /** The comparators */ template bool StatisticsAttributesLabelObjectFunctor ::operator != (const Self &self) { // Initialize response bool resp = true; resp = resp && (m_FeatureName != self.m_FeatureName); resp = resp && (m_FeatureImage != self.m_FeatureImage); // Return return resp; } template bool StatisticsAttributesLabelObjectFunctor ::operator == (const Self &self) { // Call the != implementation return !(this != self); } /** This is the functor implementation * Calling the functor on a label object * will update its statistics attributes */ template void StatisticsAttributesLabelObjectFunctor ::operator() (LabelObjectType * lo) const { ConstLineIteratorType lit = ConstLineIteratorType(lo); lit.GoToBegin(); std::ostringstream oss; FeatureType min = itk::NumericTraits::max(); FeatureType max = itk::NumericTraits::NonpositiveMin(); double sum = 0; double sum2 = 0; double sum3 = 0; double sum4 = 0; unsigned int totalFreq = 0; typename TFeatureImage::IndexType minIdx; minIdx.Fill(0); typename TFeatureImage::IndexType maxIdx; maxIdx.Fill(0); typename TFeatureImage::PointType centerOfGravity; centerOfGravity.Fill(0); MatrixType centralMoments; centralMoments.Fill(0); MatrixType principalAxes; principalAxes.Fill(0); VectorType principalMoments; principalMoments.Fill(0); // iterate over all the lines while ( !lit.IsAtEnd() ) { const typename TFeatureImage::IndexType& firstIdx = lit.GetLine().GetIndex(); unsigned long length = lit.GetLine().GetLength(); long endIdx0 = firstIdx[0] + length; for (typename TFeatureImage::IndexType idx = firstIdx; idx[0] < endIdx0; idx[0]++) { const FeatureType& v = m_FeatureImage->GetPixel(idx); ++totalFreq; // update min and max if (v <= min) { min = v; minIdx = idx; } if (v >= max) { max = v; maxIdx = idx; } //increase the sums const double v2 = v * v; sum += v; sum2 += v2; sum3 += v2 * v; sum4 += v2 * v2; if (!m_ReducedAttributeSet) { // moments typename TFeatureImage::PointType physicalPosition; m_FeatureImage->TransformIndexToPhysicalPoint(idx, physicalPosition); for (unsigned int i = 0; i < TFeatureImage::ImageDimension; ++i) { centerOfGravity[i] += physicalPosition[i] * v; centralMoments[i][i] += v * physicalPosition[i] * physicalPosition[i]; for (unsigned int j = i + 1; j < TFeatureImage::ImageDimension; ++j) { const double weight = v * physicalPosition[i] * physicalPosition[j]; centralMoments[i][j] += weight; centralMoments[j][i] += weight; } } } } ++lit; } // final computations const double mean = sum / totalFreq; const double variance = (sum2 - (sum * sum / totalFreq)) / (totalFreq - 1); const double sigma = vcl_sqrt(variance); const double mean2 = mean * mean; double skewness = 0; double kurtosis = 0; const double epsilon = 1E-10; if (vcl_abs(variance) > epsilon) { skewness = ((sum3 - 3.0 * mean * sum2) / totalFreq + 2.0 * mean * mean2) / (variance * sigma); kurtosis = ((sum4 - 4.0 * mean * sum3 + 6.0 * mean2 * sum2) / totalFreq - 3.0 * mean2 * mean2) / (variance * variance) - 3.0; } oss.str(""); oss << "STATS::" << m_FeatureName << "::Mean"; lo->SetAttribute(oss.str().c_str(), mean); oss.str(""); oss << "STATS::" << m_FeatureName << "::Variance"; lo->SetAttribute(oss.str().c_str(), variance); oss.str(""); oss << "STATS::" << m_FeatureName << "::Skewness"; lo->SetAttribute(oss.str().c_str(), skewness); oss.str(""); oss << "STATS::" << m_FeatureName << "::Kurtosis"; lo->SetAttribute(oss.str().c_str(), kurtosis); if (!m_ReducedAttributeSet) { double elongation = std::numeric_limits::quiet_NaN(); if (sum != 0) { // Normalize using the total mass for (unsigned int i = 0; i < TFeatureImage::ImageDimension; ++i) { centerOfGravity[i] /= sum; for (unsigned int j = 0; j < TFeatureImage::ImageDimension; ++j) { centralMoments[i][j] /= sum; } } // Center the second order moments for (unsigned int i = 0; i < TFeatureImage::ImageDimension; ++i) { for (unsigned int j = 0; j < TFeatureImage::ImageDimension; ++j) { centralMoments[i][j] -= centerOfGravity[i] * centerOfGravity[j]; } } // Compute principal moments and axes vnl_symmetric_eigensystem eigen(centralMoments.GetVnlMatrix()); vnl_diag_matrix pm = eigen.D; for (unsigned int i = 0; i < TFeatureImage::ImageDimension; ++i) { // principalMoments[i] = 4 * vcl_sqrt( pm(i, i) ); principalMoments[i] = pm(i, i); } principalAxes = eigen.V.transpose(); // Add a final reflection if needed for a proper rotation, // by multiplying the last row by the determinant vnl_real_eigensystem eigenrot(principalAxes.GetVnlMatrix()); vnl_diag_matrix > eigenval = eigenrot.D; vcl_complex det(1.0, 0.0); for (unsigned int i = 0; i < TFeatureImage::ImageDimension; ++i) { det *= eigenval(i, i); } for (unsigned int i = 0; i < TFeatureImage::ImageDimension; ++i) { principalAxes[TFeatureImage::ImageDimension - 1][i] *= std::real(det); } if (principalMoments[0] != 0) { // elongation = principalMoments[TFeatureImage::ImageDimension-1] / principalMoments[0]; elongation = vcl_sqrt(principalMoments[TFeatureImage::ImageDimension - 1] / principalMoments[0]); } } else { // can't compute anything in that case - just set everything to a default value // Normalize using the total mass for (unsigned int i = 0; i < TFeatureImage::ImageDimension; ++i) { centerOfGravity[i] = 0; principalMoments[i] = 0; for (unsigned int j = 0; j < TFeatureImage::ImageDimension; ++j) { principalAxes[i][j] = 0; } } } oss.str(""); oss << "STATS::" << m_FeatureName << "::Elongation"; lo->SetAttribute(oss.str().c_str(), (double) elongation); oss.str(""); oss << "STATS::" << m_FeatureName << "::Minimum"; lo->SetAttribute(oss.str().c_str(), (double) min); oss.str(""); oss << "STATS::" << m_FeatureName << "::Maximum"; lo->SetAttribute(oss.str().c_str(), (double) max); oss.str(""); oss << "STATS::" << m_FeatureName << "::Sum"; lo->SetAttribute(oss.str().c_str(), sum); oss.str(""); oss << "STATS::" << m_FeatureName << "::Sigma"; lo->SetAttribute(oss.str().c_str(), sigma); for (unsigned int dim = 0; dim < TFeatureImage::ImageDimension; ++dim) { oss.str(""); oss << "STATS::" << m_FeatureName << "::CenterOfGravity" << dim; lo->SetAttribute(oss.str().c_str(), centerOfGravity[dim]); oss.str(""); oss << "STATS::" << m_FeatureName << "::PrincipalMoments" << dim; lo->SetAttribute(oss.str().c_str(), principalMoments[dim]); oss.str(""); oss << "STATS::" << m_FeatureName << "::FirstMinimumIndex" << dim; lo->SetAttribute(oss.str().c_str(), minIdx[dim]); oss.str(""); oss << "STATS::" << m_FeatureName << "::FirstMaximumIndex" << dim; lo->SetAttribute(oss.str().c_str(), maxIdx[dim]); for (unsigned int dim2 = 0; dim2 < TFeatureImage::ImageDimension; ++dim2) { oss.str(""); oss << "STATS::" << m_FeatureName << "::PrincipalAxis" << dim << dim2; lo->SetAttribute(oss.str().c_str(), principalAxes(dim, dim2)); } } } } /** Set the name of the feature */ template void StatisticsAttributesLabelObjectFunctor ::SetFeatureName(const std::string& name) { m_FeatureName = name; } /** Get the feature name */ template const std::string& StatisticsAttributesLabelObjectFunctor ::GetFeatureName() const { return m_FeatureName; } /** Set the feature image */ template void StatisticsAttributesLabelObjectFunctor ::SetFeatureImage(const TFeatureImage * img) { m_FeatureImage = img; } /** Get the feature image */ template const TFeatureImage * StatisticsAttributesLabelObjectFunctor ::GetFeatureImage() const { return m_FeatureImage; } /** Set the reduced attribute set */ template void StatisticsAttributesLabelObjectFunctor ::SetReducedAttributeSet(bool flag) { m_ReducedAttributeSet = flag; } /** Get the reduced attribute set */ template bool StatisticsAttributesLabelObjectFunctor ::GetReducedAttributeSet() const { return m_ReducedAttributeSet; } } // End namespace Functor template StatisticsAttributesLabelMapFilter ::StatisticsAttributesLabelMapFilter() {} template StatisticsAttributesLabelMapFilter ::~StatisticsAttributesLabelMapFilter() {} /** Set the feature image */ template void StatisticsAttributesLabelMapFilter ::SetFeatureImage(const TFeatureImage *input) { // Set the Nth input this->SetNthInput(1, const_cast(input)); } /** Get the feature image */ template const typename StatisticsAttributesLabelMapFilter ::FeatureImageType * StatisticsAttributesLabelMapFilter ::GetFeatureImage() const { return static_cast(this->itk::ProcessObject::GetInput(1)); } /** Set Input1 (for backward compatibility) */ template void StatisticsAttributesLabelMapFilter ::SetInput1(const TImage * input) { this->SetInput(input); } /** Get Input1 (for backward compatibility) */ template const TImage * StatisticsAttributesLabelMapFilter ::GetInput1() const { return this->GetInput(); } /** Set Input2 (for backward compatibility) */ template void StatisticsAttributesLabelMapFilter ::SetInput2(const TFeatureImage * input) { this->SetFeatureImage(input); } /** Get Input2 (for backward compatibility) */ template const TFeatureImage * StatisticsAttributesLabelMapFilter ::GetInput2() const { return this->GetFeatureImage(); } /** Set the name of the feature */ template void StatisticsAttributesLabelMapFilter ::SetFeatureName(const std::string& name) { if (name != this->GetFunctor().GetFeatureName()) { this->GetFunctor().SetFeatureName(name); this->Modified(); } } /** Get the feature name */ template const std::string& StatisticsAttributesLabelMapFilter ::GetFeatureName() const { return this->GetFunctor().GetFeatureName(); } /** Set the reduced attribute set */ template void StatisticsAttributesLabelMapFilter ::SetReducedAttributeSet(bool flag) { if (this->GetFunctor().GetReducedAttributeSet() != flag) { this->GetFunctor().SetReducedAttributeSet(flag); this->Modified(); } } /** Get the reduced attribute set */ template bool StatisticsAttributesLabelMapFilter ::GetReducedAttributeSet() const { return this->GetFunctor().GetReducedAttributeSet(); } template void StatisticsAttributesLabelMapFilter ::BeforeThreadedGenerateData() { // First call superclass implementation Superclass::BeforeThreadedGenerateData(); // Set the feature image to the functor this->GetFunctor().SetFeatureImage(this->GetFeatureImage()); } template void StatisticsAttributesLabelMapFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace itk #endif OTB-release-5.8/Modules/Core/LabelMap/otb-module.cmake000066400000000000000000000010061301006202600224410ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes that allow label images manipulation based on object attributes. They are useful for Object-Based Image Analysis (OBIA) (analyzing images at the object level instead of working at the pixel level).") otb_module(OTBLabelMap DEPENDS OTBCommon OTBITK OTBImageBase OTBMoments OTBVectorDataBase OTBVectorDataManipulation TEST_DEPENDS OTBImageIO OTBProjection OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/LabelMap/test/000077500000000000000000000000001301006202600203525ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/LabelMap/test/CMakeLists.txt000066400000000000000000000134251301006202600231170ustar00rootroot00000000000000otb_module_test() set(OTBLabelMapTests otbLabelMapTestDriver.cxx otbAttributesMapLabelObjectWithClassLabelNew.cxx otbLabelObjectMapVectorizer.cxx otbAttributesMapOpeningLabelMapFilterNew.cxx otbLabelImageToLabelMapWithAdjacencyFilter.cxx otbStatisticsAttributesLabelMapFilterNew.cxx otbLabelObjectToPolygonFunctorNew.cxx otbLabelMapWithClassLabelToLabeledSampleListFilterNew.cxx otbAttributesMapLabelObjectNew.cxx otbLabelMapToSampleListFilterNew.cxx otbLabelMapSourceNew.cxx otbLabelMapToAttributeImageFilterNew.cxx otbImageToLabelMapWithAttributesFilter.cxx otbImageToLabelMapWithAttributesFilterNew.cxx otbKMeansAttributesLabelMapFilter.cxx otbLabelMapToSampleListFilter.cxx otbLabelMapWithClassLabelToLabeledSampleListFilter.cxx otbMinMaxAttributesLabelMapFilter.cxx otbNormalizeAttributesLabelMapFilter.cxx otbShapeAttributesLabelMapFilterNew.cxx otbBandsStatisticsAttributesLabelMapFilter.cxx ) add_executable(otbLabelMapTestDriver ${OTBLabelMapTests}) target_link_libraries(otbLabelMapTestDriver ${OTBLabelMap-Test_LIBRARIES}) otb_module_target_label(otbLabelMapTestDriver) # Tests Declaration otb_add_test(NAME obTuAttributesMapLabelObjectWithClassLabelNew COMMAND otbLabelMapTestDriver otbAttributesMapLabelObjectWithClassLabelNew) otb_add_test(NAME obTvLabelObjectMapVectorizer COMMAND otbLabelMapTestDriver otbLabelObjectMapVectorizer ${INPUTDATA}/rcc8_mire1.png rcc8_mire1_label_vectorizer.gml) otb_add_test(NAME obTuAttributesMapOpeningLabelMapFilterNew COMMAND otbLabelMapTestDriver otbAttributesMapOpeningLabelMapFilterNew) otb_add_test(NAME obTuLabelImageToLabelMapWithAdjacencyFilterNew COMMAND otbLabelMapTestDriver otbLabelImageToLabelMapWithAdjacencyFilterNew) otb_add_test(NAME obTvLabelImageToLabelMapWithAdjacencyFilter COMMAND otbLabelMapTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/obTvLabelImageToLabelMapWithAdjacencyFilterOutput.txt ${TEMP}/obTvLabelImageToLabelMapWithAdjacencyFilterOutput.txt otbLabelImageToLabelMapWithAdjacencyFilter ${INPUTDATA}/simpleLabelImage.tif ${TEMP}/obTvLabelImageToLabelMapWithAdjacencyFilterOutput.txt ) otb_add_test(NAME obTuStatisticsAttributesLabelMapFilterNew COMMAND otbLabelMapTestDriver otbStatisticsAttributesLabelMapFilterNew) otb_add_test(NAME obTuLabelObjectToPolygonFunctorNew COMMAND otbLabelMapTestDriver otbLabelObjectToPolygonFunctorNew) otb_add_test(NAME obTuLabelMapWithClassLabelToLabeledSampleListFilterNew COMMAND otbLabelMapTestDriver otbLabelMapWithClassLabelToLabeledSampleListFilterNew) otb_add_test(NAME obTuAttributesMapLabelObjectNew COMMAND otbLabelMapTestDriver otbAttributesMapLabelObjectNew) otb_add_test(NAME obTuLabelMapToSampleListFilterNew COMMAND otbLabelMapTestDriver otbLabelMapToSampleListFilterNew) otb_add_test(NAME obTuLabelMapSourceNew COMMAND otbLabelMapTestDriver otbLabelMapSourceNew) otb_add_test(NAME obTuLabelMapToAttributeImageFilterNew COMMAND otbLabelMapTestDriver otbLabelMapToAttributeImageFilterNew) otb_add_test(NAME obTvImageToLabelMapWithAttributesFilter COMMAND otbLabelMapTestDriver otbImageToLabelMapWithAttributesFilter ${INPUTDATA}/maur.tif ${INPUTDATA}/maur_labelled.tif) otb_add_test(NAME obTuImageToLabelMapWithAttributesFilterNew COMMAND otbLabelMapTestDriver otbImageToLabelMapWithAttributesFilterNew) otb_add_test(NAME obTvKMeansAttributesLabelMapFilter COMMAND otbLabelMapTestDriver otbKMeansAttributesLabelMapFilter ${INPUTDATA}/maur.tif ${INPUTDATA}/maur_labelled.tif ${TEMP}/obTvKMeansAttributesLabelMapFilter.txt) otb_add_test(NAME obTuKMeansAttributesLabelMapFilterNew COMMAND otbLabelMapTestDriver otbKMeansAttributesLabelMapFilterNew) otb_add_test(NAME obTvLabelMapToSampleListFilter COMMAND otbLabelMapTestDriver otbLabelMapToSampleListFilter ${OTB_DATA_ROOT}/Input/rcc8_mire1.png SHAPE::Flusser01 SHAPE::Flusser02 SHAPE::Flusser03 SHAPE::Flusser04 SHAPE::Flusser05 SHAPE::Flusser06 SHAPE::Flusser07 SHAPE::Flusser08 SHAPE::Flusser09 SHAPE::Flusser10 SHAPE::Flusser11) otb_add_test(NAME obTvLabelMapWithClassLabelToLabeledSampleListFilter COMMAND otbLabelMapTestDriver otbLabelMapWithClassLabelToLabeledSampleListFilter ${OTB_DATA_ROOT}/Input/rcc8_mire1.png SHAPE::Flusser01 SHAPE::Flusser02 SHAPE::Flusser03 SHAPE::Flusser04 SHAPE::Flusser05 SHAPE::Flusser06 SHAPE::Flusser07 SHAPE::Flusser08 SHAPE::Flusser09 SHAPE::Flusser10 SHAPE::Flusser11) otb_add_test(NAME obTuMinMaxAttributesLabelMapFilterNew COMMAND otbLabelMapTestDriver otbMinMaxAttributesLabelMapFilterNew) otb_add_test(NAME obTvMinMaxAttributesLabelMapFilter COMMAND otbLabelMapTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/obTvMinMaxAttributesLabelMapFilter.txt ${TEMP}/obTvMinMaxAttributesLabelMapFilter.txt otbMinMaxAttributesLabelMapFilter ${INPUTDATA}/maur.tif ${INPUTDATA}/maur_labelled.tif ${TEMP}/obTvMinMaxAttributesLabelMapFilter.txt) otb_add_test(NAME obTuNormalizeAttributesLabelMapFilterNew COMMAND otbLabelMapTestDriver otbNormalizeAttributesLabelMapFilterNew) otb_add_test(NAME obTvNormalizeAttributesLabelMapFilter COMMAND otbLabelMapTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/obTvNormalizeAttributesLabelMapFilter.txt ${TEMP}/obTvNormalizeAttributesLabelMapFilter.txt otbNormalizeAttributesLabelMapFilter ${INPUTDATA}/maur.tif ${INPUTDATA}/maur_labelled.tif ${TEMP}/obTvNormalizeAttributesLabelMapFilter.txt) otb_add_test(NAME obTuShapeAttributesLabelMapFilterNew COMMAND otbLabelMapTestDriver otbShapeAttributesLabelMapFilterNew) otb_add_test(NAME obTuBandsStatisticsAttributesLabelMapFilterNew COMMAND otbLabelMapTestDriver otbBandsStatisticsAttributesLabelMapFilterNew) otb_add_test(NAME obTvBandsStatisticsAttributesLabelMapFilter COMMAND otbLabelMapTestDriver otbBandsStatisticsAttributesLabelMapFilter ${INPUTDATA}/maur.tif ${INPUTDATA}/maur_labelled.tif ${TEMP}/obTvBandsStatisticsAttributesLabelMapFilter.txt) OTB-release-5.8/Modules/Core/LabelMap/test/otbAttributesMapLabelObjectNew.cxx000066400000000000000000000016221301006202600271310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAttributesMapLabelObject.h" int otbAttributesMapLabelObjectNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObject LabelObjectType; // instantiation LabelObjectType::Pointer object = LabelObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbAttributesMapLabelObjectWithClassLabelNew.cxx000066400000000000000000000017141301006202600317150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAttributesMapLabelObjectWithClassLabel.h" int otbAttributesMapLabelObjectWithClassLabelNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObjectWithClassLabel LabelObjectType; // instantiation LabelObjectType::Pointer object = LabelObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbAttributesMapOpeningLabelMapFilterNew.cxx000066400000000000000000000021511301006202600311240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkLabelMap.h" #include "otbAttributesMapOpeningLabelMapFilter.h" int otbAttributesMapOpeningLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::AttributesMapOpeningLabelMapFilter LabelMapFilterType; // instantiation LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbBandsStatisticsAttributesLabelMapFilter.cxx000066400000000000000000000075111301006202600315240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbAttributesMapLabelObject.h" #include "itkLabelImageToLabelMapFilter.h" #include "otbBandsStatisticsAttributesLabelMapFilter.h" const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef double DoublePixelType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::VectorImage VectorImageType; typedef otb::Image LabeledImageType; typedef LabelMapType::Iterator IteratorType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader LabeledReaderType; typedef itk::LabelImageToLabelMapFilter LabelMapFilterType; typedef otb::BandsStatisticsAttributesLabelMapFilter BandsStatisticsFilterType; int otbBandsStatisticsAttributesLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { BandsStatisticsFilterType::Pointer object = BandsStatisticsFilterType::New(); return EXIT_SUCCESS; } int otbBandsStatisticsAttributesLabelMapFilter(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * lfname = argv[2]; const char * outfname = argv[3]; // Filters instantiation ReaderType::Pointer reader = ReaderType::New(); LabeledReaderType::Pointer labeledReader = LabeledReaderType::New(); LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); BandsStatisticsFilterType::Pointer stats = BandsStatisticsFilterType::New(); // Read inputs reader->SetFileName(infname); labeledReader->SetFileName(lfname); // Make a LabelMap out of it filter->SetInput(labeledReader->GetOutput()); filter->SetBackgroundValue(itk::NumericTraits::max()); //Compute band statistics attributes stats->SetInput(filter->GetOutput()); stats->SetFeatureImage(reader->GetOutput()); stats->Update(); LabelMapType::Pointer labelMap = stats->GetOutput(); // Dump all results in the output file std::ofstream outfile(outfname); IteratorType it = IteratorType( labelMap ); while ( !it.IsAtEnd() ) { LabelType label = it.GetLabel(); LabelObjectType::Pointer labelObject = it.GetLabelObject(); outfile << "Label " << label << " : " << std::endl; std::vector attributes = labelObject->GetAvailableAttributes(); std::vector::const_iterator attrIt = attributes.begin(); std::vector::const_iterator attrEnd = attributes.end(); for (; attrIt != attrEnd; ++attrIt) { LabelObjectType::AttributesValueType value = labelObject->GetAttribute(attrIt->c_str()); outfile << " " << *attrIt << " : "<< std::fixed << std::setprecision(6) << value << std::endl; } outfile << std::endl; ++it; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbImageToLabelMapWithAttributesFilter.cxx000066400000000000000000000043221301006202600306000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageToLabelMapWithAttributesFilter.h" #include "otbImageFileReader.h" int otbImageToLabelMapWithAttributesFilter(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * lfname = argv[2]; // Convenient typedefs typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::AttributesMapLabelObjectWithClassLabel LabelObjectType; typedef otb::ImageToLabelMapWithAttributesFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader LabeledReaderType; // SmartPointer instantiation FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); LabeledReaderType::Pointer labeledReader = LabeledReaderType::New(); // Inputs reader->SetFileName(infname); reader->UpdateOutputInformation(); labeledReader->SetFileName(lfname); labeledReader->UpdateOutputInformation(); // Filter filter->SetInput(reader->GetOutput()); filter->SetLabeledImage(labeledReader->GetOutput()); filter->Update(); // tests std::vector features = filter->GetOutput()->GetNthLabelObject(0)->GetAvailableAttributes(); for(std::vector::const_iterator fit = features.begin(); fit!=features.end(); ++fit) { std::cout <<"Label " << *fit << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbImageToLabelMapWithAttributesFilterNew.cxx000066400000000000000000000023261301006202600312540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageToLabelMapWithAttributesFilter.h" int otbImageToLabelMapWithAttributesFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::AttributesMapLabelObjectWithClassLabel LabelObjectType; typedef otb::ImageToLabelMapWithAttributesFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbKMeansAttributesLabelMapFilter.cxx000066400000000000000000000104421301006202600275750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include #include #include "otbVectorImage.h" #include "itkLabelImageToLabelMapFilter.h" #include "otbImageToLabelMapWithAttributesFilter.h" #include "otbKMeansAttributesLabelMapFilter.h" const unsigned int Dim = 2; typedef unsigned short LabelType; typedef double PixelType; typedef otb::AttributesMapLabelObjectWithClassLabel LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::VectorImage VectorImageType; typedef otb::Image LabeledImageType; typedef LabelMapType::Iterator IteratorType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader LabeledReaderType; typedef itk::LabelImageToLabelMapFilter LabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeFilterType; typedef otb::KMeansAttributesLabelMapFilter KMeansAttributesLabelMapFilterType; int otbKMeansAttributesLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { KMeansAttributesLabelMapFilterType::Pointer radiometricLabelMapFilter = KMeansAttributesLabelMapFilterType::New(); return EXIT_SUCCESS; } int otbKMeansAttributesLabelMapFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * lfname = argv[2]; const char * outfname = argv[3]; // SmartPointer instantiation ReaderType::Pointer reader = ReaderType::New(); LabeledReaderType::Pointer labeledReader = LabeledReaderType::New(); LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); ShapeFilterType::Pointer shapeFilter = ShapeFilterType::New(); KMeansAttributesLabelMapFilterType::Pointer kmeansLabelMapFilter = KMeansAttributesLabelMapFilterType::New(); // Inputs reader->SetFileName(infname); reader->UpdateOutputInformation(); labeledReader->SetFileName(lfname); labeledReader->UpdateOutputInformation(); labeledReader->Update(); // Filter filter->SetInput(labeledReader->GetOutput()); filter->SetBackgroundValue(itk::NumericTraits::max()); filter->Update(); shapeFilter->SetInput(filter->GetOutput()); shapeFilter->Update(); // Labelize the objects LabelMapType::Pointer labelMap = shapeFilter->GetOutput(); IteratorType loIt = IteratorType( labelMap ); unsigned int labelObjectID = 0; while ( !loIt.IsAtEnd() ) { unsigned int classLabel = labelObjectID % 3; loIt.GetLabelObject()->SetClassLabel(classLabel); ++labelObjectID; ++loIt; } kmeansLabelMapFilter->SetInputLabelMap(labelMap); std::vector attributes = labelMap->GetLabelObject(0)->GetAvailableAttributes(); std::vector::const_iterator attrIt; for (attrIt = attributes.begin(); attrIt != attributes.end(); ++attrIt) { kmeansLabelMapFilter->GetMeasurementFunctor().AddAttribute((*attrIt).c_str()); } kmeansLabelMapFilter->SetNumberOfClasses(3); kmeansLabelMapFilter->Compute(); std::ofstream outfile(outfname); const KMeansAttributesLabelMapFilterType::CentroidsVectorType& centroids = kmeansLabelMapFilter->GetCentroids(); for (unsigned int i = 0; i < centroids.size(); ++i) { outfile << "Centroid " << i << " : " << centroids[i] << std::endl; } outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelImageToLabelMapWithAdjacencyFilter.cxx000066400000000000000000000057451301006202600313050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelImageToLabelMapWithAdjacencyFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "itkNumericTraits.h" #include typedef unsigned short LabelType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader LabelReaderType; typedef itk::LabelObject LabelObjectType; typedef otb::LabelMapWithAdjacency LabelMapType; typedef LabelMapType::ConstIterator ConstIteratorType; typedef LabelObjectType::ConstLineIterator ConstLineIteratorType; typedef otb::LabelImageToLabelMapWithAdjacencyFilter < LabelImageType, LabelMapType> FilterType; int otbLabelImageToLabelMapWithAdjacencyFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { // Instantiation FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbLabelImageToLabelMapWithAdjacencyFilter(int itkNotUsed(argc), char * argv[]) { LabelReaderType::Pointer reader = LabelReaderType::New(); reader->SetFileName(argv[1]); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetBackgroundValue(itk::NumericTraits::max()); filter->Update(); std::ofstream ofs(argv[2]); // Retrieve the label map ConstIteratorType lIt = ConstIteratorType( filter->GetOutput() ); ofs<<"Label map: "<GetLabel()<<", lines: "; while ( !lineIt.IsAtEnd() ) { ofs<<" { "<GetOutput()->GetAdjacencyMap(); for(LabelMapType::AdjacencyMapType::const_iterator it = adjMap.begin(); it!=adjMap.end(); ++it) { ofs<<"Label:\t"<first<<" adjacent with labels"; LabelMapType::AdjacentLabelsContainerType::const_iterator lit = it->second.begin(); for(; lit!=it->second.end(); ++lit) { ofs<<"\t"<<(*lit); } ofs< LabelObjectType; typedef itk::LabelMap InputLabelMapType; typedef otb::LabelMapSource LabelMapSourceType; // Instantiating LabelMapSource object LabelMapSourceType::Pointer labelMap = LabelMapSourceType::New(); std::cout << labelMap << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelMapTestDriver.cxx000066400000000000000000000026641301006202600253040ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbAttributesMapLabelObjectWithClassLabelNew); REGISTER_TEST(otbLabelObjectMapVectorizer); REGISTER_TEST(otbAttributesMapOpeningLabelMapFilterNew); REGISTER_TEST(otbLabelImageToLabelMapWithAdjacencyFilterNew); REGISTER_TEST(otbLabelImageToLabelMapWithAdjacencyFilter); REGISTER_TEST(otbStatisticsAttributesLabelMapFilterNew); REGISTER_TEST(otbLabelObjectToPolygonFunctorNew); REGISTER_TEST(otbLabelMapWithClassLabelToLabeledSampleListFilterNew); REGISTER_TEST(otbAttributesMapLabelObjectNew); REGISTER_TEST(otbLabelMapToSampleListFilterNew); REGISTER_TEST(otbLabelMapSourceNew); REGISTER_TEST(otbLabelMapToAttributeImageFilterNew); REGISTER_TEST(otbImageToLabelMapWithAttributesFilter); REGISTER_TEST(otbImageToLabelMapWithAttributesFilterNew); REGISTER_TEST(otbKMeansAttributesLabelMapFilterNew); REGISTER_TEST(otbKMeansAttributesLabelMapFilter); REGISTER_TEST(otbLabelMapToSampleListFilter); REGISTER_TEST(otbLabelMapWithClassLabelToLabeledSampleListFilter); REGISTER_TEST(otbMinMaxAttributesLabelMapFilter); REGISTER_TEST(otbMinMaxAttributesLabelMapFilterNew); REGISTER_TEST(otbNormalizeAttributesLabelMapFilter); REGISTER_TEST(otbNormalizeAttributesLabelMapFilterNew); REGISTER_TEST(otbShapeAttributesLabelMapFilterNew); REGISTER_TEST(otbBandsStatisticsAttributesLabelMapFilter); REGISTER_TEST(otbBandsStatisticsAttributesLabelMapFilterNew); } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelMapToAttributeImageFilterNew.cxx000066400000000000000000000024261301006202600302360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelMapToAttributeImageFilter.h" #include "itkLabelMap.h" #include "otbVectorImage.h" int otbLabelMapToAttributeImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::VectorImage VectorImageType; typedef otb::LabelMapToAttributeImageFilter LabelMapToAttributeImageFilterType; // instantiation LabelMapToAttributeImageFilterType::Pointer object = LabelMapToAttributeImageFilterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelMapToSampleListFilter.cxx000066400000000000000000000062621301006202600267350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkBinaryImageToLabelMapFilter.h" #include "otbShapeAttributesLabelMapFilter.h" #include "itkVariableLengthVector.h" #include "itkListSample.h" #include "otbLabelMapToSampleListFilter.h" int otbLabelMapToSampleListFilter(int argc, char* argv[]) { const char * infname = argv[1]; // Labeled image type const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader LabeledReaderType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::BinaryImageToLabelMapFilter LabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeLabelMapFilterType; typedef itk::VariableLengthVector VectorType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::LabelMapToSampleListFilter LabelMap2ListSampleFilterType; // instantiation LabeledReaderType::Pointer lreader = LabeledReaderType::New(); lreader->SetFileName(infname); LabelMapFilterType::Pointer labelMapFilter = LabelMapFilterType::New(); labelMapFilter->SetInput(lreader->GetOutput()); labelMapFilter->SetInputForegroundValue(255); ShapeLabelMapFilterType::Pointer shapeLabelMapFilter = ShapeLabelMapFilterType::New(); shapeLabelMapFilter->SetInput(labelMapFilter->GetOutput()); shapeLabelMapFilter->SetReducedAttributeSet(false); shapeLabelMapFilter->SetComputePerimeter(true); shapeLabelMapFilter->SetComputeFeretDiameter(true); shapeLabelMapFilter->Update(); LabelMap2ListSampleFilterType::Pointer filter = LabelMap2ListSampleFilterType::New(); filter->SetInputLabelMap(shapeLabelMapFilter->GetOutput()); filter->GetMeasurementFunctor().AddAttribute("test"); filter->GetMeasurementFunctor().RemoveAttribute("test"); filter->GetMeasurementFunctor().AddAttribute("test"); filter->GetMeasurementFunctor().ClearAttributes(); for(int i = 2; iGetMeasurementFunctor().AddAttribute(argv[i]); } std::cout<<"Number of attributes: "<GetMeasurementFunctor().GetNumberOfAttributes()<Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelMapToSampleListFilterNew.cxx000066400000000000000000000025571301006202600274120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkLabelMap.h" #include "otbLabelMapToSampleListFilter.h" #include "itkVariableLengthVector.h" #include "itkListSample.h" int otbLabelMapToSampleListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::VariableLengthVector VectorType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::LabelMapToSampleListFilter LabelMapFilterType; // instantiation LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelMapWithClassLabelToLabeledSampleListFilter.cxx000066400000000000000000000066751301006202600330000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkBinaryImageToLabelMapFilter.h" #include "otbAttributesMapLabelObjectWithClassLabel.h" #include "otbShapeAttributesLabelMapFilter.h" #include "itkVariableLengthVector.h" #include "itkListSample.h" #include "otbLabelMapWithClassLabelToLabeledSampleListFilter.h" int otbLabelMapWithClassLabelToLabeledSampleListFilter(int argc, char* argv[]) { const char * infname = argv[1]; // Labeled image type const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader LabeledReaderType; typedef otb::AttributesMapLabelObjectWithClassLabel LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::BinaryImageToLabelMapFilter LabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeLabelMapFilterType; typedef itk::VariableLengthVector VectorType; typedef itk::FixedArray TrainingVectorType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::ListSample TrainingListSampleType; typedef otb::LabelMapWithClassLabelToLabeledSampleListFilter LabelMap2ListSampleFilterType; // instantiation LabeledReaderType::Pointer lreader = LabeledReaderType::New(); lreader->SetFileName(infname); LabelMapFilterType::Pointer labelMapFilter = LabelMapFilterType::New(); labelMapFilter->SetInput(lreader->GetOutput()); labelMapFilter->SetInputForegroundValue(255); ShapeLabelMapFilterType::Pointer shapeLabelMapFilter = ShapeLabelMapFilterType::New(); shapeLabelMapFilter->SetInput(labelMapFilter->GetOutput()); shapeLabelMapFilter->Update(); LabelMap2ListSampleFilterType::Pointer filter = LabelMap2ListSampleFilterType::New(); filter->SetInputLabelMap(shapeLabelMapFilter->GetOutput()); filter->GetMeasurementFunctor().AddAttribute("test"); filter->GetMeasurementFunctor().RemoveAttribute("test"); filter->GetMeasurementFunctor().AddAttribute("test"); filter->GetMeasurementFunctor().ClearAttributes(); for(int i = 2; iGetMeasurementFunctor().AddAttribute(argv[i]); } std::cout<<"Number of attributes: "<GetMeasurementFunctor().GetNumberOfAttributes()<GetOutput()->GetLabelObject(1)->SetClassLabel(1); filter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelMapWithClassLabelToLabeledSampleListFilterNew.cxx000066400000000000000000000032571301006202600334430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAttributesMapLabelObjectWithClassLabel.h" #include "itkLabelMap.h" #include "otbLabelMapWithClassLabelToLabeledSampleListFilter.h" #include "itkVariableLengthVector.h" #include "itkListSample.h" int otbLabelMapWithClassLabelToLabeledSampleListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObjectWithClassLabel LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::FixedArray LabelVectorType; typedef itk::VariableLengthVector VectorType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::ListSample TrainingListSampleType; typedef otb::LabelMapWithClassLabelToLabeledSampleListFilter LabelMapFilterType; // instantiation LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelObjectMapVectorizer.cxx000066400000000000000000000130451301006202600264670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "itkLabelImageToLabelMapFilter.h" #include "otbAttributesMapLabelObject.h" #include "otbLabelObjectToPolygonFunctor.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include "otbVectorDataFileWriter.h" #include "itkTimeProbe.h" #include "itkMinimumMaximumImageCalculator.h" #include "otbCorrectPolygonFunctor.h" int otbLabelObjectMapVectorizer(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; // Labeled image type const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader LabeledReaderType; // Label map typedef typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::LabelImageToLabelMapFilter LabelMapFilterType; typedef otb::Polygon PolygonType; typedef otb::Functor::LabelObjectToPolygonFunctor FunctorType; typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileWriter WriterType; typedef otb::VectorDataProjectionFilter VectorDataFilterType; typedef itk::MinimumMaximumImageCalculator MinMaxCalculatorType; typedef otb::CorrectPolygonFunctor CorrectPolygonFunctorType; LabeledReaderType::Pointer lreader = LabeledReaderType::New(); lreader->SetFileName(infname); LabelMapFilterType::Pointer labelMapFilter = LabelMapFilterType::New(); labelMapFilter->SetInput(lreader->GetOutput()); labelMapFilter->SetBackgroundValue(itk::NumericTraits::max()); std::cout << "min: " << itk::NumericTraits::min() << std::endl; std::cout << "max: " << itk::NumericTraits::max() << std::endl; //labelMapFilter->SetBackgroundValue(0); labelMapFilter->Update(); FunctorType functor; //correct CorrectPolygonFunctorType correctPolygon; WriterType::Pointer writer = WriterType::New(); VectorDataType::Pointer data = VectorDataType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder1 = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder1->SetNodeType(otb::FOLDER); DataNodeType::Pointer root = data->GetDataTree()->GetRoot()->Get(); data->GetDataTree()->Add(document, root); data->GetDataTree()->Add(folder1, document); data->SetProjectionRef(lreader->GetOutput()->GetProjectionRef()); itk::TimeProbe chrono; // If a label is given, extract only this label if (argc == 4) { std::cout << "Label is given; Vectorizing object " << atoi(argv[3]) << std::endl; chrono.Start(); PolygonType::Pointer polygon = functor(labelMapFilter->GetOutput()->GetLabelObject(atoi(argv[3]))); chrono.Stop(); //correct polygon PolygonType::Pointer correct_polygon = correctPolygon(polygon); DataNodeType::Pointer node = DataNodeType::New(); node->SetNodeType(otb::FEATURE_POLYGON); node->SetPolygonExteriorRing(correct_polygon); data->GetDataTree()->Add(node, folder1); } // Else extract all labels else { MinMaxCalculatorType::Pointer minMax = MinMaxCalculatorType::New(); minMax->SetImage(lreader->GetOutput()); minMax->Compute(); for (LabelType label = minMax->GetMinimum(); label <= minMax->GetMaximum(); ++label) { if (labelMapFilter->GetOutput()->HasLabel(label) && label != labelMapFilter->GetOutput()->GetBackgroundValue()) { std::cout << "Vectorizing object " << label << std::endl; chrono.Start(); PolygonType::Pointer polygon = functor(labelMapFilter->GetOutput()->GetLabelObject(label)); chrono.Stop(); //correct polygon PolygonType::Pointer correct_polygon = correctPolygon(polygon); DataNodeType::Pointer node = DataNodeType::New(); node->SetNodeType(otb::FEATURE_POLYGON); node->SetPolygonExteriorRing(correct_polygon); data->GetDataTree()->Add(node, folder1); } } } std::cout << "Average vectorization time: " << chrono.GetMean() << " s." << std::endl; VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); vectorDataProjection->SetInputOrigin(lreader->GetOutput()->GetOrigin()); vectorDataProjection->SetInputSpacing(lreader->GetOutput()->GetSpacing()); vectorDataProjection->SetInput(data); writer->SetFileName(outfname); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbLabelObjectToPolygonFunctorNew.cxx000066400000000000000000000024141301006202600276400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelObjectToPolygonFunctor.h" #include "otbAttributesMapLabelObject.h" #include int otbLabelObjectToPolygonFunctorNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef otb::Polygon PolygonType; typedef otb::Functor::LabelObjectToPolygonFunctor FunctorType; //typedef FunctorType::Pointer FunctorPointerType; // Instantiation //FunctorPointerType myFunctor = FunctorType::New(); FunctorType myFunctor; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbMinMaxAttributesLabelMapFilter.cxx000066400000000000000000000074321301006202600276150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbAttributesMapLabelObject.h" #include "otbImageToLabelMapWithAttributesFilter.h" #include "otbMinMaxAttributesLabelMapFilter.h" const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef double PixelType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef otb::LabelMapWithAdjacency LabelMapType; typedef otb::VectorImage VectorImageType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader LabeledReaderType; typedef otb::LabelImageToLabelMapWithAdjacencyFilter LabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeFilterType; typedef otb::MinMaxAttributesLabelMapFilter MinMaxAttributesLabelMapFilterType; int otbMinMaxAttributesLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { MinMaxAttributesLabelMapFilterType::Pointer radiometricLabelMapFilter = MinMaxAttributesLabelMapFilterType::New(); return EXIT_SUCCESS; } int otbMinMaxAttributesLabelMapFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * lfname = argv[2]; const char * outfname = argv[3]; // SmartPointer instantiation ReaderType::Pointer reader = ReaderType::New(); LabeledReaderType::Pointer labeledReader = LabeledReaderType::New(); LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); ShapeFilterType::Pointer shapeFilter = ShapeFilterType::New(); MinMaxAttributesLabelMapFilterType::Pointer minmaxLabelMapFilter = MinMaxAttributesLabelMapFilterType::New(); // Inputs reader->SetFileName(infname); reader->UpdateOutputInformation(); labeledReader->SetFileName(lfname); labeledReader->UpdateOutputInformation(); // Filter filter->SetInput(labeledReader->GetOutput()); filter->SetBackgroundValue(itk::NumericTraits::max()); shapeFilter->SetInput(filter->GetOutput()); minmaxLabelMapFilter->SetInput(shapeFilter->GetOutput()); minmaxLabelMapFilter->Update(); std::ofstream outfile(outfname); MinMaxAttributesLabelMapFilterType::AttributesMapType minimum = minmaxLabelMapFilter->GetMinimum(); MinMaxAttributesLabelMapFilterType::AttributesMapType::const_iterator it; outfile << "Minimum : " << std::endl; for (it = minimum.begin(); it != minimum.end(); ++it) { outfile << " " << (*it).first << " : " << (*it).second << std::endl; } outfile << std::endl; MinMaxAttributesLabelMapFilterType::AttributesMapType maximum = minmaxLabelMapFilter->GetMaximum(); outfile << "Maximum : " << std::endl; for (it = maximum.begin(); it != maximum.end(); ++it) { outfile << " " << (*it).first << " : " << (*it).second << std::endl; } outfile << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbNormalizeAttributesLabelMapFilter.cxx000066400000000000000000000127761301006202600303730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbAttributesMapLabelObject.h" #include "otbImageToLabelMapWithAttributesFilter.h" #include "otbMinMaxAttributesLabelMapFilter.h" #include "otbNormalizeAttributesLabelMapFilter.h" const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef double PixelType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef otb::LabelMapWithAdjacency LabelMapType; typedef otb::VectorImage VectorImageType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader LabeledReaderType; typedef otb::LabelImageToLabelMapWithAdjacencyFilter LabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeFilterType; typedef otb::MinMaxAttributesLabelMapFilter MinMaxAttributesLabelMapFilterType; typedef otb::NormalizeAttributesLabelMapFilter NormalizeAttributesLabelMapFilterType; int otbNormalizeAttributesLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { NormalizeAttributesLabelMapFilterType::Pointer normalizeLabelMapFilter = NormalizeAttributesLabelMapFilterType::New(); return EXIT_SUCCESS; } int otbNormalizeAttributesLabelMapFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * lfname = argv[2]; const char * outfname = argv[3]; // SmartPointer instantiation ReaderType::Pointer reader = ReaderType::New(); LabeledReaderType::Pointer labeledReader = LabeledReaderType::New(); LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); ShapeFilterType::Pointer shapeFilter = ShapeFilterType::New(); MinMaxAttributesLabelMapFilterType::Pointer minmaxLabelMapFilter = MinMaxAttributesLabelMapFilterType::New(); NormalizeAttributesLabelMapFilterType::Pointer normalizeLabelMapFilter = NormalizeAttributesLabelMapFilterType::New(); MinMaxAttributesLabelMapFilterType::Pointer minmaxAfterLabelMapFilter = MinMaxAttributesLabelMapFilterType::New(); // Inputs reader->SetFileName(infname); reader->UpdateOutputInformation(); labeledReader->SetFileName(lfname); labeledReader->UpdateOutputInformation(); // Filter filter->SetInput(labeledReader->GetOutput()); filter->SetBackgroundValue(itk::NumericTraits::max()); shapeFilter->SetInput(filter->GetOutput()); minmaxLabelMapFilter->SetInput(shapeFilter->GetOutput()); minmaxLabelMapFilter->Update(); std::ofstream outfile(outfname); { MinMaxAttributesLabelMapFilterType::AttributesMapType minimum = minmaxLabelMapFilter->GetMinimum(); MinMaxAttributesLabelMapFilterType::AttributesMapType::const_iterator it; outfile<< "Minimum before normalization : " << std::endl; for (it = minimum.begin(); it != minimum.end(); ++it) { outfile << " " << (*it).first << " : " << std::fixed << std::setprecision(6) << (*it).second << std::endl; } outfile << std::endl; MinMaxAttributesLabelMapFilterType::AttributesMapType maximum = minmaxLabelMapFilter->GetMaximum(); outfile << "Maximum before normalization : " << std::endl; for (it = maximum.begin(); it != maximum.end(); ++it) { outfile << " " << (*it).first << " : " << std::fixed << std::setprecision(6) << (*it).second << std::endl; } outfile << std::endl; } normalizeLabelMapFilter->SetInput(shapeFilter->GetOutput()); normalizeLabelMapFilter->SetMinAttributesValues(minmaxLabelMapFilter->GetMinimum()); normalizeLabelMapFilter->SetMaxAttributesValues(minmaxLabelMapFilter->GetMaximum()); normalizeLabelMapFilter->Update(); minmaxAfterLabelMapFilter->SetInput(normalizeLabelMapFilter->GetOutput()); minmaxAfterLabelMapFilter->Update(); { MinMaxAttributesLabelMapFilterType::AttributesMapType minimum = minmaxAfterLabelMapFilter->GetMinimum(); MinMaxAttributesLabelMapFilterType::AttributesMapType::const_iterator it; outfile << "Minimum after normalization : " << std::endl; for (it = minimum.begin(); it != minimum.end(); ++it) { outfile << " " << (*it).first << " : " << std::fixed << std::setprecision(6) << (*it).second << std::endl; } outfile << std::endl; MinMaxAttributesLabelMapFilterType::AttributesMapType maximum = minmaxAfterLabelMapFilter->GetMaximum(); outfile << "Maximum after normalization : " << std::endl; for (it = maximum.begin(); it != maximum.end(); ++it) { outfile << " " << (*it).first << " : " << std::fixed << std::setprecision(6) << (*it).second << std::endl; } outfile << std::endl; } outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbShapeAttributesLabelMapFilterNew.cxx000066400000000000000000000022101301006202600301230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAttributesMapLabelObject.h" #include "itkLabelMap.h" #include "otbShapeAttributesLabelMapFilter.h" int otbShapeAttributesLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::ShapeAttributesLabelMapFilter LabelMapFilterType; // instantiation LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/LabelMap/test/otbStatisticsAttributesLabelMapFilterNew.cxx000066400000000000000000000023461301006202600312270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAttributesMapLabelObject.h" #include "otbStatisticsAttributesLabelMapFilter.h" #include "otbImage.h" int otbStatisticsAttributesLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Image ImageType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::StatisticsAttributesLabelMapFilter LabelMapFilterType; // instantiation LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/000077500000000000000000000000001301006202600174365ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Metadata/CMakeLists.txt000066400000000000000000000001171301006202600221750ustar00rootroot00000000000000project(OTBMetadata) set(OTBMetadata_LIBRARIES OTBMetadata) otb_module_impl() OTB-release-5.8/Modules/Core/Metadata/include/000077500000000000000000000000001301006202600210615ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Metadata/include/otbBandName.h000066400000000000000000000032461301006202600234110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBandName_h #define otbBandName_h namespace otb { namespace BandName { /** * Provides a way to identify bands when passing the parameters * to the radiometric functors.* */ enum BandName {BLUE, GREEN, RED, NIR, MIR}; enum LandsatTMBandNames {TM1, TM2, TM3, TM4, TM5, TM60, TM61, TM62, TM7}; // Note for landsat equivalence // http://landsat.gsfc.nasa.gov/news/news-archive/sci_0017.html // TM1 = Coastal // TM2 = Blue // TM3 = Green // TM4 = Red // TM5 = NIR // TM6 = SWIR1 = MIR (SPOT5) // TM7 = SWIR2 // TM8 = Panchro // TM9 = Cirrus // // Spot at // http://www.spotimage.com/web/en/233-resolution-and-spectral-bands.php // Band Number Wavelength Interval Spectral Response // 1 0.45-0.52 microm Blue-Green // 2 0.52-0.60 microm Green // 3 0.63-0.69 microm Red // 4 0.76-0.90 microm Near IR // 5 1.55-1.75 microm Mid-IR // 6 10.40-12.50 microm Thermal IR // 7 2.08-2.35 microm Mid-IR } } #endif OTB-release-5.8/Modules/Core/Metadata/include/otbDefaultImageMetadataInterface.h000066400000000000000000000147361301006202600275630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDefaultImageMetadataInterface_h #define otbDefaultImageMetadataInterface_h #include #include "OTBMetadataExport.h" #include "otbImageMetadataInterfaceBase.h" namespace otb { /** \class DefaultImageMetadataInterface * * \brief Creation of an "otb" DefaultImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT DefaultImageMetadataInterface : public ImageMetadataInterfaceBase { public: typedef DefaultImageMetadataInterface Self; typedef ImageMetadataInterfaceBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DefaultImageMetadataInterface, ImageMetadataInterfaceBase); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const { itkExceptionMacro("GetPhysicalBias not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const { itkExceptionMacro("GetPhysicalGain not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const { itkExceptionMacro("GetSolarIrradiance not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition day from the ossim metadata */ int GetDay() const ITK_OVERRIDE { itkExceptionMacro("GetDay not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition month from the ossim metadata */ int GetMonth() const ITK_OVERRIDE { itkExceptionMacro("GetMonth not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition year from the ossim metadata */ int GetYear() const ITK_OVERRIDE { itkExceptionMacro("GetYear not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition hour from the ossim metadata */ int GetHour() const ITK_OVERRIDE { itkExceptionMacro("GetHour not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition minute from the ossim metadata */ int GetMinute() const ITK_OVERRIDE { itkExceptionMacro("GetMinute not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production day from the ossim metadata */ int GetProductionDay() const ITK_OVERRIDE { itkExceptionMacro("GetProductionDay not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production month from the ossim metadata */ int GetProductionMonth() const ITK_OVERRIDE { itkExceptionMacro("GetProductionMonth not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production year from the ossim metadata */ int GetProductionYear() const ITK_OVERRIDE { itkExceptionMacro("GetProductionYear not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const { itkExceptionMacro("GetSatElevation not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const { itkExceptionMacro("GetSatElevation not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const { itkExceptionMacro("GetFirstWavelengths not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const { itkExceptionMacro("GetLastWavelengths not implemented in DefaultImageMetadataInterface, no captor type found"); } /** Get the enhanced band names */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE { itkExceptionMacro("GetEnhancedBandNames not implemented in DefaultImageMetadataInterface, no captor type found"); } bool CanRead() const ITK_OVERRIDE { // This class is the default one, it has to be able to call every metadata return true; } /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B. * * Nota : When two spectral bands are available: first band is given to the R and B channel * When one spectral band is available : the only band is given to the R, G and B channel. * */ std::vector GetDefaultDisplay() const ITK_OVERRIDE { unsigned int i = 0; std::vector rgb(3); if (this->GetNumberOfBands() == 0) { rgb[0] = 0; rgb[1] = 1; rgb[2] = 2; } else { unsigned int min; min = std::min(this->GetNumberOfBands(), static_cast (3)); while (i < min) { rgb[i] = i; ++i; } } return rgb; } protected: DefaultImageMetadataInterface(){}; ~DefaultImageMetadataInterface() ITK_OVERRIDE {} private: DefaultImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbDefaultImageMetadataInterfaceFactory.h000066400000000000000000000045171301006202600311070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDefaultImageMetadataInterfaceFactory_h #define otbDefaultImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class DefaultImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * This class only provides the method of the virtual pure class ImageMetadataInterfaceBase and throw exception for virtual method. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT DefaultImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef DefaultImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DefaultImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { DefaultImageMetadataInterfaceFactory::Pointer DefaultIMIFactory = DefaultImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(DefaultIMIFactory); } protected: DefaultImageMetadataInterfaceFactory(); ~DefaultImageMetadataInterfaceFactory() ITK_OVERRIDE; private: DefaultImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbFormosatImageMetadataInterface.h000066400000000000000000000121321301006202600277550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFormosatImageMetadataInterface_h #define otbFormosatImageMetadataInterface_h #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class FormosatImageMetadataInterface * * \brief Creation of an "otb" FormosatImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT FormosatImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef FormosatImageMetadataInterface Self; typedef ImageMetadataInterfaceBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(FormosatImageMetadataInterface, ImageMetadataInterfaceBase); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE; /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE; /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE; /** Get the imaging acquisition day from the ossim metadata : IMAGING_DATE metadata variable */ int GetDay() const ITK_OVERRIDE; /** Get the imaging acquisition month from the ossim metadata : IMAGING_DATE metadata variable */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetYear() const ITK_OVERRIDE; /** Get the imaging acquisition hour from the ossim metadata : IMAGING_DATE metadata variable */ int GetHour() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionYear() const ITK_OVERRIDE; /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE; /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE; /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE; /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE; /** Get Instrument */ std::string GetInstrument() const; /** Get the enhanced band names (here nothing because the metadata did not provide band names) */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE { return this->Superclass::GetBandName(); } /** Get Instrument Index */ unsigned int GetInstrumentIndex() const; /** This method is to handle the permutation of the spectral band by some image provider * in most cases, this method won't change the value, but for SPOT data, the bands are set up as * 2 1 0 3 in the tiff file, this method which is overloaded for SPOT enables to retrieve the * proper band. */ unsigned int BandIndexToWavelengthPosition(unsigned int i) const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE; protected: FormosatImageMetadataInterface(); ~FormosatImageMetadataInterface() ITK_OVERRIDE {} private: FormosatImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbFormosatImageMetadataInterfaceFactory.h000066400000000000000000000043071301006202600313120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFormosatImageMetadataInterfaceFactory_h #define otbFormosatImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class FormosatImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT FormosatImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef FormosatImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(FormosatImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { FormosatImageMetadataInterfaceFactory::Pointer spotIMIFactory = FormosatImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(spotIMIFactory); } protected: FormosatImageMetadataInterfaceFactory(); ~FormosatImageMetadataInterfaceFactory() ITK_OVERRIDE; private: FormosatImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbIkonosImageMetadataInterface.h000066400000000000000000000107621301006202600274340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbIkonosImageMetadataInterface_h #define otbIkonosImageMetadataInterface_h #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class IkonosImageMetadataInterface * * \brief Creation of an "otb" IkonosImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT IkonosImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef IkonosImageMetadataInterface Self; typedef ImageMetadataInterfaceBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(IkonosImageMetadataInterface, ImageMetadataInterfaceBase); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE; /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE; /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE; /** Get the imaging acquisition day from the ossim metadata : "Acquisition Date/Time" metadata variable */ int GetDay() const ITK_OVERRIDE; /** Get the imaging acquisition month from the ossim metadata : "Acquisition Date/Time" metadata variable */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : "Acquisition Date/Time" metadata variable */ int GetYear() const ITK_OVERRIDE; /** Get the imaging acquisition hour from the ossim metadata : "Acquisition Date/Time" metadata variable */ int GetHour() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : "Acquisition Date/Time" metadata variable */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : "Creation Date" metadata variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : "Creation Date" metadata variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : "Creation Date" metadata variable */ int GetProductionYear() const ITK_OVERRIDE; /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE; /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE; /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE; /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Get the enhanced band names of Ikonos data*/ std::vector GetEnhancedBandNames() const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE; protected: IkonosImageMetadataInterface(); ~IkonosImageMetadataInterface() ITK_OVERRIDE {} private: IkonosImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbIkonosImageMetadataInterfaceFactory.h000066400000000000000000000042731301006202600307640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbIkonosImageMetadataInterfaceFactory_h #define otbIkonosImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class IkonosImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT IkonosImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef IkonosImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(IkonosImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { IkonosImageMetadataInterfaceFactory::Pointer ikonosIMIFactory = IkonosImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(ikonosIMIFactory); } protected: IkonosImageMetadataInterfaceFactory(); ~IkonosImageMetadataInterfaceFactory() ITK_OVERRIDE; private: IkonosImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbImageMetadataInterfaceBase.h000066400000000000000000000163301301006202600270410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageMetadataInterfaceBase_h #define otbImageMetadataInterfaceBase_h #include #include "otbImageKeywordlist.h" #include "itkMetaDataDictionary.h" #include "otbMetaDataKey.h" #include "itkImageBase.h" #include "OTBMetadataExport.h" namespace otb { /** \class ImageMetadataInterfaceBase * * \brief Base class for captor metadata reading. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT ImageMetadataInterfaceBase : public itk::Object { public: typedef ImageMetadataInterfaceBase Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ImageMetadataInterfaceBase, itk::Object); typedef itk::ImageBase<2> ImageType; typedef itk::MetaDataDictionary MetaDataDictionaryType; typedef MetaDataKey::VectorType VectorType; typedef MetaDataKey::VariableLengthVectorType VariableLengthVectorType; typedef ImageKeywordlist ImageKeywordlistType; typedef unsigned int UnsignedIntType; typedef std::vector StringVectorType; typedef std::vector UIntVectorType; /** Set the image used to get the metadata */ void SetImage (ImageType* image) { this->SetMetaDataDictionary(image->GetMetaDataDictionary()); } /** Set the MetadataDictionary */ void SetMetaDataDictionary(const MetaDataDictionaryType& dict) { m_MetaDataDictionary = dict; } /** Get the MetadataDictionary */ const MetaDataDictionaryType& GetMetaDataDictionary() const { return m_MetaDataDictionary; } /** Get the projection coordinate system of the image. */ std::string GetProjectionRef() const; /** Get the GCP projection coordinates of the image. */ std::string GetGCPProjection() const; // otbMetadataGetMacro(GCPProjection, std::string); UnsignedIntType GetGCPCount() const; // otbMetadataGetMacro(GCPCount, unsigned int); OTB_GCP& GetGCPs(unsigned int GCPnum); //otbMetadataGetGCPnumMacro(GCPs, OTB_GCP&, GCPnum, unsigned int); std::string GetGCPId(unsigned int GCPnum) const; // otbMetadataGetGCPnumMacro(GCPId, std::string, GCPnum, unsigned int); std::string GetGCPInfo(unsigned int GCPnum) const; // otbMetadataGetGCPnumMacro(GCPInfo, std::string, GCPnum, unsigned int); double GetGCPRow(unsigned int GCPnum) const; // otbMetadataGetGCPnumMacro(GCPRow, double, GCPnum, unsigned int); double GetGCPCol(unsigned int GCPnum) const; // otbMetadataGetGCPnumMacro(GCPCol, double, GCPnum, unsigned int); double GetGCPX(unsigned int GCPnum) const; // otbMetadataGetGCPnumMacro(GCPX, double, GCPnum, unsigned int); double GetGCPY(unsigned int GCPnum) const; // otbMetadataGetGCPnumMacro(GCPY, double, GCPnum, unsigned int); double GetGCPZ(unsigned int GCPnum) const; // otbMetadataGetGCPnumMacro(GCPZ, double, GCPnum, unsigned int); /** * Get The no data flags if existing * return False otherwise */ bool GetNoDataFlags(std::vector & flags, std::vector & values) const; /** Get the six coefficients of affine geoTtransform. */ VectorType GetGeoTransform() const; // otbMetadataGetMacro(GeoTransform, VectorType); /** Get image corners. */ VectorType GetUpperLeftCorner() const; // otbMetadataGetMacro(UpperLeftCorner, VectorType); VectorType GetUpperRightCorner() const; // otbMetadataGetMacro(UpperRightCorner, VectorType); VectorType GetLowerLeftCorner() const; // otbMetadataGetMacro(LowerLeftCorner, VectorType); VectorType GetLowerRightCorner() const; // otbMetadataGetMacro(LowerRightCorner, VectorType); /** Get the ImageKeywordlist */ ImageKeywordlistType GetImageKeywordlist(); const ImageKeywordlistType GetImageKeywordlist() const; /** This method is less performant and has extra copy. Please use bool GetSensorID(std::string& ) **/ std::string const GetSensorID() const; /** Get the sensor ID from the ossim metadata */ bool GetSensorID(std::string & sensorId) const; //otbMetadataGetMacro(SensorID, std::string); /** Get the number of bands from the ossim metadata */ UnsignedIntType GetNumberOfBands() const; //otbMetadataGetMacro(NumberOfBands, unsigned int); /** Get the band name from the ossim metadata */ StringVectorType GetBandName() const; //otbMetadataGetMacro(BandName, std::vector); /** Get the x pixel spacing*/ double GetXPixelSpacing() const; //otbMetadataGetMacro(XPixelSpacing, double); /** Get the y pixel spacing*/ double GetYPixelSpacing() const; //otbMetadataGetMacro(YPixelSpacing, double); /** Get the imaging acquisition day from the ossim metadata */ virtual int GetDay() const = 0; // otbMetadataGetMacro(Day, int); /** Get the imaging acquisition month from the ossim metadata */ virtual int GetMonth() const = 0; //otbMetadataGetMacro(Month, int); /** Get the imaging acquisition year from the ossim metadata */ virtual int GetYear() const = 0; //otbMetadataGetMacro(Year, int); /** Get the imaging acquisition hour from the ossim metadata */ virtual int GetHour() const = 0; //otbMetadataGetMacro(Hour, int); /** Get the imaging acquisition minute from the ossim metadata */ virtual int GetMinute() const = 0; //otbMetadataGetMacro(Minute, int); /** Get the imaging production day from the ossim metadata */ virtual int GetProductionDay() const = 0; //otbMetadataGetMacro(ProductionDay, int); /** Get the imaging production month from the ossim metadata */ virtual int GetProductionMonth() const = 0; //otbMetadataGetMacro(ProductionMonth, int); /** Get the imaging production year from the ossim metadata */ virtual int GetProductionYear() const = 0; //otbMetadataGetMacro(ProductionYear, int); /** Convert the band names provided by ossim to the official band names */ virtual StringVectorType GetEnhancedBandNames () const = 0; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ virtual UIntVectorType GetDefaultDisplay() const = 0; virtual bool CanRead() const = 0; static void PrintMetadata(std::ostream& os, itk::Indent indent, const MetaDataDictionaryType& dict); protected: ImageMetadataInterfaceBase(); ~ImageMetadataInterfaceBase() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; MetaDataDictionaryType m_MetaDataDictionary; private: ImageMetadataInterfaceBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OTB_GCP m_GCP; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbImageMetadataInterfaceFactory.h000066400000000000000000000047131301006202600276000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageMetadataInterfaceFactory_h #define otbImageMetadataInterfaceFactory_h #include "itkObject.h" #include "otbImageMetadataInterfaceBase.h" namespace otb { /** \class ImageMetadataInterfaceFactory * \brief Create instances of ImageMetadataInterfaceFactory objects using an object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT ImageMetadataInterfaceFactory : public itk::Object { public: /** Standard class typedefs. */ typedef ImageMetadataInterfaceFactory Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class Methods used to interface with the registered factories */ /** Run-time type information (and related methods). */ itkTypeMacro(ImageMetadataInterfaceFactory, Object); /** Convenient typedefs. */ typedef ImageMetadataInterfaceBase::ImageType ImageType; typedef ImageMetadataInterfaceBase::MetaDataDictionaryType MetaDataDictionaryType; typedef ImageMetadataInterfaceBase::VectorType VectorType; typedef ImageMetadataInterfaceBase::VariableLengthVectorType VariableLengthVectorType; typedef ImageMetadataInterfaceBase::ImageKeywordlistType ImageKeywordlistType; typedef ImageMetadataInterfaceBase::Pointer ImageMetadataInterfaceBasePointerType; /** Create the appropriate ImageMetadataInterfaceFactory depending on the particulars of the file. */ static ImageMetadataInterfaceBasePointerType CreateIMI(const MetaDataDictionaryType& dict); /** Register Built-in factories */ static void RegisterBuiltInFactories(); protected: ImageMetadataInterfaceFactory(); ~ImageMetadataInterfaceFactory() ITK_OVERRIDE; private: ImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbNoDataHelper.h000066400000000000000000000121131301006202600242430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNoDataHelper_h #define otbNoDataHelper_h #include #include #include "vnl/vnl_math.h" #include #include "OTBMetadataExport.h" namespace itk { class MetaDataDictionary; } namespace otb { /** * Reads no data flag from the MetaDataDictionary dict to flags and values * vectors. Returns true upon success. */ bool OTBMetadata_EXPORT ReadNoDataFlags(const itk::MetaDataDictionary& dict, std::vector & flags, std::vector & values); /** * Write no data flags to the MetaDataDictionary dict from flags and values * vectors. Returns true upon success. */ void OTBMetadata_EXPORT WriteNoDataFlags(const std::vector & flags, const std::vector & values, itk::MetaDataDictionary& dict); /** * Test if the pixel corresponds to a no data pixel according to a * vector of no data flags, and a vector of no data values. * \param pixel The pixel to test * \param flags A vector of size > 1 containing a flag per band to * indicate if a no data value is available for this band * \param values A vector of size > 1 corresponding to the no data * value for each band. If flag is 0, the value will be ignored. * \param nanIsNoData If true, NaN values will be reported as no-data. */ template bool IsNoData(const T & pixel, const std::vector & flags, const std::vector & values, bool nanIsNoData = false) { assert(flags.size()>0); assert(values.size()>0); if(nanIsNoData && vnl_math_isnan(values[0])) return true; if(flags[0]) { return (pixel == values[0]); } else { return false; } } /** * Reads a pixel and change the no data value if it is found. No data * value is changed either if the pixel value is NaN or if the pixel * value equals the no data value and flag is true. * * \param pixel The pixel to process \param flags A vector of size > 1 * containing a flag per band to indicate if a no data value is * available for this band * \param values A vector of size > 1 corresponding to the current no data * value for each band. If flag is 0, the value will be ignored. * \param newValues A vector of size > 1 corresponding to the new no data * value for each band. If flag is 0, the value will be ignored * \param nanIsNoData If true, NaN values will be considered as no-data * and changed as well. * */ template T ChangeNoData(const T & pixel, const std::vector & flags, const std::vector & values, const std::vector & newValues, bool nanIsNoData = false) { assert(flags.size()>0); assert(values.size()>0); assert(newValues.size()>0); if(nanIsNoData && vnl_math_isnan(pixel)) { return static_cast(newValues[0]); } if(flags[0] && pixel == values[0]) { return static_cast(newValues[0]); } return pixel; } /** * Specialization of IsNoData function to handle itk::VariableLengthVector */ template bool IsNoData(const itk::VariableLengthVector & pixel, const std::vector & flags, const std::vector & values, bool nanIsNoData = false) { assert(flags.size()>=pixel.Size()); assert(values.size()>=pixel.Size()); for(unsigned int i = 0; i < pixel.Size();++i) { if((nanIsNoData && vnl_math_isnan(pixel[i])) || (flags[i] && (pixel[i] == values[i]))) { return true; } } return false; } /** * Specialization of ChangeNoData function to handle itk::VariableLengthVector */ template itk::VariableLengthVector ChangeNoData(const itk::VariableLengthVector & pixel, const std::vector & flags, const std::vector & values, const std::vector & newValues, bool nanIsNoData = false) { assert(flags.size()>=pixel.Size()); assert(values.size()>=pixel.Size()); assert(newValues.size()>=pixel.Size()); itk::VariableLengthVector outPixel(pixel.Size()); for(unsigned int i = 0; i < pixel.Size();++i) { if((nanIsNoData && vnl_math_isnan(pixel[i])) || (flags[i] && (pixel[i] == values[i]))) { outPixel[i] = newValues[i]; } else { outPixel[i] = pixel[i]; } } return outPixel; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbOpticalDefaultImageMetadataInterface.h000066400000000000000000000151071301006202600310700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOpticalDefaultImageMetadataInterface_h #define otbOpticalDefaultImageMetadataInterface_h #include "otbMacro.h" #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class OpticalDefaultImageMetadataInterface * * \brief Creation of an "otb" DefaultImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT OpticalDefaultImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef OpticalDefaultImageMetadataInterface Self; typedef OpticalImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(OpticalDefaultImageMetadataInterface, OpticalImageMetadataInterface); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE { itkExceptionMacro("GetPhysicalBias not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE { itkExceptionMacro("GetPhysicalGain not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE { itkExceptionMacro("GetSolarIrradiance not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition day from the ossim metadata */ int GetDay() const ITK_OVERRIDE { itkExceptionMacro("GetDay not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition month from the ossim metadata */ int GetMonth() const ITK_OVERRIDE { itkExceptionMacro("GetMonth not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition year from the ossim metadata */ int GetYear() const ITK_OVERRIDE { itkExceptionMacro("GetYear not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition hour from the ossim metadata */ int GetHour() const ITK_OVERRIDE { itkExceptionMacro("GetHour not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition minute from the ossim metadata */ int GetMinute() const ITK_OVERRIDE { itkExceptionMacro("GetMinute not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production day from the ossim metadata */ int GetProductionDay() const ITK_OVERRIDE { itkExceptionMacro("GetProductionDay not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production month from the ossim metadata */ int GetProductionMonth() const ITK_OVERRIDE { itkExceptionMacro("GetProductionMonth not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production year from the ossim metadata */ int GetProductionYear() const ITK_OVERRIDE { itkExceptionMacro("GetProductionYear not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE { itkExceptionMacro("GetSatElevation not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE { itkExceptionMacro("GetSatElevation not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE { itkExceptionMacro("GetFirstWavelengths not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE { itkExceptionMacro("GetLastWavelengths not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } /** Get the enhanced band names (here nothing because the sensor is not identify) */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE { std::vector nothing; return nothing; } bool CanRead() const ITK_OVERRIDE { // This class is the default one, it has to be able to call every metadata return false; } /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE { std::vector rgb(3); rgb[0] = 0; rgb[1] = 1; rgb[2] = 2; return rgb; } /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE { itkExceptionMacro("GetSpectralSensitivity not implemented in OpticalDefaultImageMetadataInterface, no captor type found"); } protected: OpticalDefaultImageMetadataInterface(){}; ~OpticalDefaultImageMetadataInterface() ITK_OVERRIDE {} private: OpticalDefaultImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbOpticalDefaultImageMetadataInterfaceFactory.h000066400000000000000000000046731301006202600324260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOpticalDefaultImageMetadataInterfaceFactory_h #define otbOpticalDefaultImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class OpticalDefaultImageMetadataInterfaceFactory * \brief Creating an instance of a OpticalImageMetadataInterface object using object factory. * This class only provides the method of the virtual pure class OpticalImageMetadataInterface and throw exception for virtual method. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT OpticalDefaultImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef OpticalDefaultImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(OpticalDefaultImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { OpticalDefaultImageMetadataInterfaceFactory::Pointer DefaultIMIFactory = OpticalDefaultImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(DefaultIMIFactory); } protected: OpticalDefaultImageMetadataInterfaceFactory(); ~OpticalDefaultImageMetadataInterfaceFactory() ITK_OVERRIDE; private: OpticalDefaultImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbOpticalImageMetadataInterface.h000066400000000000000000000077741301006202600275760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOpticalImageMetadataInterface_h #define otbOpticalImageMetadataInterface_h #include #include "otbImageMetadataInterfaceBase.h" #include "otbFilterFunctionValues.h" #include "otbObjectList.h" namespace otb { /** \class OpticalImageMetadataInterface * * \brief Class for Optical captor metadata reading. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT OpticalImageMetadataInterface : public ImageMetadataInterfaceBase { public: typedef OpticalImageMetadataInterface Self; typedef ImageMetadataInterfaceBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(OpticalImageMetadataInterface, ImageMetadataInterfaceBase); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; typedef FilterFunctionValues FilterFunctionValuesType; typedef otb::ObjectList InternalWavelengthSpectralBandVectorType; typedef InternalWavelengthSpectralBandVectorType::Pointer WavelengthSpectralBandVectorType; /** Get the sun elevation from the ossim metadata */ double GetSunElevation() const; /** Get the sun azimuth from the ossim metadata */ double GetSunAzimuth() const; /** Get the sat elevation from the ossim metadata */ virtual double GetSatElevation() const = 0; /** Get the sat azimuth from the ossim metadata */ virtual double GetSatAzimuth() const = 0; /** Get the radiometric bias from the ossim metadata */ virtual VariableLengthVectorType GetPhysicalBias() const = 0; /** Get the radiometric gain from the ossim metadata */ virtual VariableLengthVectorType GetPhysicalGain() const = 0; /** Get the solar irradiance from the ossim metadata */ virtual VariableLengthVectorType GetSolarIrradiance() const = 0; /** Get the first wavelength for the spectral band definition */ virtual VariableLengthVectorType GetFirstWavelengths() const = 0; /** Get the last wavelength for the spectral band definition */ virtual VariableLengthVectorType GetLastWavelengths() const = 0; /** Get the enhanced band names */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE = 0; /** This method is to handle the permutation of the spectral band by some image provider * in most cases, this method won't change the value, but for SPOT data, the bands are set up as * 2 1 0 3 in the tiff file, this method which is overloaded for SPOT enables to retrieve the * proper band. */ virtual unsigned int BandIndexToWavelengthPosition(unsigned int i) const; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ virtual WavelengthSpectralBandVectorType GetSpectralSensitivity () const = 0; protected: OpticalImageMetadataInterface(); ~OpticalImageMetadataInterface() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: OpticalImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbOpticalImageMetadataInterfaceFactory.h000066400000000000000000000050631301006202600311130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOpticalImageMetadataInterfaceFactory_h #define otbOpticalImageMetadataInterfaceFactory_h #include "itkObject.h" #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class OpticalImageMetadataInterfaceFactory * \brief Create instances of OpticalImageMetadataInterfaceFactory objects using an object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT OpticalImageMetadataInterfaceFactory : public itk::Object { public: /** Standard class typedefs. */ typedef OpticalImageMetadataInterfaceFactory Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class Methods used to interface with the registered factories */ /** Run-time type information (and related methods). */ itkTypeMacro(OpticalImageMetadataInterfaceFactory, Object); /** Convenient typedefs. */ typedef OpticalImageMetadataInterface::ImageType ImageType; typedef OpticalImageMetadataInterface::MetaDataDictionaryType MetaDataDictionaryType; typedef OpticalImageMetadataInterface::VectorType VectorType; typedef OpticalImageMetadataInterface::VariableLengthVectorType VariableLengthVectorType; typedef OpticalImageMetadataInterface::ImageKeywordlistType ImageKeywordlistType; typedef OpticalImageMetadataInterface::Pointer OpticalImageMetadataInterfacePointerType; /** Create the appropriate OpticalImageMetadataInterfaceFactory depending on the particulars of the file. */ static OpticalImageMetadataInterfacePointerType CreateIMI(const MetaDataDictionaryType& dict); /** Register Built-in factories */ static void RegisterBuiltInFactories(); protected: OpticalImageMetadataInterfaceFactory(); ~OpticalImageMetadataInterfaceFactory() ITK_OVERRIDE; private: OpticalImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbPleiadesImageMetadataInterface.h000066400000000000000000000120051301006202600277100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPleiadesImageMetadataInterface_h #define otbPleiadesImageMetadataInterface_h #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class PleiadesImageMetadataInterface * * \brief Creation of an "otb" PleiadesImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT PleiadesImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef PleiadesImageMetadataInterface Self; typedef OpticalImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PleiadesImageMetadataInterface, OpticalImageMetadataInterface); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE; /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE; /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE; /** Get the imaging acquisition day from the ossim metadata : IMAGING_DATE metadata variable */ int GetDay() const ITK_OVERRIDE; /** Get the imaging acquisition month from the ossim metadata : IMAGING_DATE metadata variable */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetYear() const ITK_OVERRIDE; /** Get the imaging acquisition hour from the ossim metadata : IMAGING_DATE metadata variable */ int GetHour() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionYear() const ITK_OVERRIDE; /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE; /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE; /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE; /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE; /** Get Instrument */ std::string GetInstrument() const; /** Get Instrument Index */ std::string GetInstrumentIndex() const; /** This method is to handle the permutation of the spectral band by some image provider * in most cases, this method won't change the value, but for SPOT data, the bands are set up as * 2 1 0 3 in the tiff file, this method which is overloaded for SPOT enables to retrieve the * proper band. */ unsigned int BandIndexToWavelengthPosition(unsigned int i) const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Get the enhanced band names of the Pleiades data */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE; protected: PleiadesImageMetadataInterface(); ~PleiadesImageMetadataInterface() ITK_OVERRIDE {} private: PleiadesImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbPleiadesImageMetadataInterfaceFactory.h000066400000000000000000000043171301006202600312470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPleiadesImageMetadataInterfaceFactory_h #define otbPleiadesImageMetadataInterfaceFactory_h #include "itkObjectFactoryBase.h" #include "OTBMetadataExport.h" namespace otb { /** \class PleiadesImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT PleiadesImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef PleiadesImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PleiadesImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { PleiadesImageMetadataInterfaceFactory::Pointer pleiadesIMIFactory = PleiadesImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(pleiadesIMIFactory); } protected: PleiadesImageMetadataInterfaceFactory(); ~PleiadesImageMetadataInterfaceFactory() ITK_OVERRIDE; private: PleiadesImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbQuickBirdImageMetadataInterface.h000066400000000000000000000106551301006202600300500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQuickBirdImageMetadataInterface_h #define otbQuickBirdImageMetadataInterface_h #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class QuickBirdImageMetadataInterface * * \brief Creation of an "otb" QuickBirdImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT QuickBirdImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef QuickBirdImageMetadataInterface Self; typedef ImageMetadataInterfaceBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(QuickBirdImageMetadataInterface, ImageMetadataInterfaceBase); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE; /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE; /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE; /** Get the imaging acquisition day from the ossim metadata : TLCTime metadata value */ int GetDay() const ITK_OVERRIDE; /** Get the imaging acquisition month from the ossim metadata : TLCTime metadata value */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : TLCTime metadata value */ int GetYear() const ITK_OVERRIDE; /** Get the imaging acquisition hour from the ossim metadata : TLCTime metadata value */ int GetHour() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : TLCTime metadata value */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : generationTime metadata value */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : generationTime metadata value */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : generationTime metadata value */ int GetProductionYear() const ITK_OVERRIDE; /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE; /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE; /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE; /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE; /** Get the enhanced band names of QuickBird data */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE; protected: QuickBirdImageMetadataInterface(); ~QuickBirdImageMetadataInterface() ITK_OVERRIDE {} private: QuickBirdImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbQuickBirdImageMetadataInterfaceFactory.h000066400000000000000000000043531301006202600313760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQuickBirdImageMetadataInterfaceFactory_h #define otbQuickBirdImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class QuickBirdImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT QuickBirdImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef QuickBirdImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(QuickBirdImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { QuickBirdImageMetadataInterfaceFactory::Pointer quickBirdIMIFactory = QuickBirdImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(quickBirdIMIFactory); } protected: QuickBirdImageMetadataInterfaceFactory(); ~QuickBirdImageMetadataInterfaceFactory() ITK_OVERRIDE; private: QuickBirdImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbRadarsat2ImageMetadataInterface.h000066400000000000000000000131711301006202600300120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadarsat2ImageMetadataInterface_h #define otbRadarsat2ImageMetadataInterface_h #include "otbSarImageMetadataInterface.h" namespace otb { /** \class Radarsat2ImageMetadataInterface * * \brief Creation of an "otb" Radarsat2ImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT Radarsat2ImageMetadataInterface : public SarImageMetadataInterface { public: typedef Radarsat2ImageMetadataInterface Self; typedef SarImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Radarsat2ImageMetadataInterface, SarImageMetadataInterface); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; typedef Superclass::LookupDataPointerType LookupDataPointerType; // typedef Radarsat2CalibrationLookupData::Pointer LookupDataPointerType; /*ImageMetadataInterfaceBase pure virtuals */ /** Get the imaging production day from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionYear() const ITK_OVERRIDE; /** check sensor ID */ bool CanRead() const ITK_OVERRIDE; int GetDay() const ITK_OVERRIDE; int GetMonth() const ITK_OVERRIDE; int GetYear() const ITK_OVERRIDE; int GetHour() const ITK_OVERRIDE; int GetMinute() const ITK_OVERRIDE; UIntVectorType GetDefaultDisplay() const ITK_OVERRIDE; /*SarImageMetadataInterface pure virutals rituals */ double GetPRF() const ITK_OVERRIDE; double GetRSF() const ITK_OVERRIDE; double GetRadarFrequency() const ITK_OVERRIDE; double GetCenterIncidenceAngle() const ITK_OVERRIDE; /*get lookup data for calculating backscatter */ void CreateCalibrationLookupData(const short type) ITK_OVERRIDE; protected: /* class constructor */ Radarsat2ImageMetadataInterface(); /* class desctructor */ ~Radarsat2ImageMetadataInterface() ITK_OVERRIDE {} private: Radarsat2ImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /* Helper function to parse date and time into a std::vector * using boost::split() expect date time in yyyy-mm-ddThh:mm:ss.ms * the date-time string is to be found in keywordlist with key 'key' * fills argument dateFields of type std::vector which is mutable! * TODO: move this method into base class */ void ParseDateTime(const char* key, std::vector& dateFields) const; mutable std::vector m_ProductionDateFields; mutable std::vector m_AcquisitionDateFields; }; class Radarsat2CalibrationLookupData : public SarCalibrationLookupData { public: /** Standard typedefs */ typedef Radarsat2CalibrationLookupData Self; typedef SarCalibrationLookupData Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(Radarsat2CalibrationLookupData, SarCalibrationLookupData); typedef itk::IndexValueType IndexValueType; typedef std::vector GainListType; Radarsat2CalibrationLookupData() : m_Offset(0) { } ~Radarsat2CalibrationLookupData() ITK_OVERRIDE { } void InitParameters(short type, int offset, GainListType gains) { this->SetType(type); m_Offset = offset; m_Gains = gains; } double GetValue(const IndexValueType x, const IndexValueType itkNotUsed(y)) const ITK_OVERRIDE { double lutVal = 1.0; const size_t pos = x + m_Offset; if(pos < m_Gains.size()) { lutVal = m_Gains[pos]; } else { //itkExceptionMacro( << "error: (pos < list.size() )" << pos << " < " << list.size()) } return lutVal; } void PrintSelf(std::ostream & os, itk::Indent indent) const ITK_OVERRIDE { os << indent << " offset:'" << m_Offset << "'" << std::endl; os << " referenceNoiseLevel.gain: " << std::endl; std::vector::const_iterator it = m_Gains.begin(); while (it != m_Gains.end()) { os << (*it) << " "; ++it; } os << std::endl; Superclass::PrintSelf(os, indent); } private: Radarsat2CalibrationLookupData(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented GainListType m_Gains; int m_Offset; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbRadarsat2ImageMetadataInterfaceFactory.h000066400000000000000000000042341301006202600313420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadarsat2ImageMetadataInterfaceFactory_h #define otbRadarsat2ImageMetadataInterfaceFactory_h #include "itkObjectFactoryBase.h" #include "OTBMetadataExport.h" namespace otb { /** \class Radarsat2ImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT Radarsat2ImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef Radarsat2ImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Radarsat2ImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer factory = Radarsat2ImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(factory); } protected: Radarsat2ImageMetadataInterfaceFactory(); ~Radarsat2ImageMetadataInterfaceFactory() ITK_OVERRIDE; private: Radarsat2ImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSarCalibrationLookupData.h000066400000000000000000000027171301006202600266270ustar00rootroot00000000000000#ifndef SarCalibrationLookupData_H #define SarCalibrationLookupData_H 1 #include #include #include #include #include "OTBMetadataExport.h" namespace otb { class OTBMetadata_EXPORT SarCalibrationLookupData : public itk::LightObject { public: /** Standard typedefs */ typedef SarCalibrationLookupData Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(SarCalibrationLookupData, itk::LightObject); typedef itk::IndexValueType IndexValueType; enum { SIGMA = 0, BETA, GAMMA, DN }; SarCalibrationLookupData() :m_Type(0) { } ~SarCalibrationLookupData() ITK_OVERRIDE { } virtual double GetValue(const IndexValueType itkNotUsed(x), const IndexValueType itkNotUsed(y)) const { return 1.0; } void SetType(short t) { m_Type = t; } itkGetMacro(Type, short); void PrintSelf(std::ostream & os, itk::Indent indent) const ITK_OVERRIDE { os << indent << " lookup table type:'" << m_Type << "'" << std::endl; Superclass::PrintSelf(os, indent); } private: SarCalibrationLookupData(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented short m_Type; }; } #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSarDefaultImageMetadataInterface.h000066400000000000000000000176171301006202600302320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarDefaultImageMetadataInterface_h #define otbSarDefaultImageMetadataInterface_h #include "otbMacro.h" #include "otbSarImageMetadataInterface.h" namespace otb { /** \class SarDefaultImageMetadataInterface * * \brief Creation of an "otb" DefaultImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT SarDefaultImageMetadataInterface : public SarImageMetadataInterface { public: typedef SarDefaultImageMetadataInterface Self; typedef SarImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SarDefaultImageMetadataInterface, SarImageMetadataInterface); typedef Superclass::ImageType ImageType; typedef ImageType::IndexType IndexType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; typedef itk::PointSet PointSetType; typedef PointSetType::Pointer PointSetPointer; typedef double RealType; typedef PointSetType::PointType PointType; RealType GetRadiometricCalibrationScale() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationScale() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } PointSetPointer GetRadiometricCalibrationAntennaPatternNewGain() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationAntennaPatternNewGain() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } PointSetPointer GetRadiometricCalibrationAntennaPatternOldGain() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationAntennaPatternOldGain() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } PointSetPointer GetRadiometricCalibrationIncidenceAngle() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationIncidenceAngle() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } PointSetPointer GetRadiometricCalibrationRangeSpreadLoss() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationRangeSpreadLoss() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } PointSetPointer GetRadiometricCalibrationNoise() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationNoise() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } IndexType GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } IndexType GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } IndexType GetRadiometricCalibrationIncidenceAnglePolynomialDegree() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationIncidenceAnglePolynomialDegree() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } IndexType GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } IndexType GetRadiometricCalibrationNoisePolynomialDegree() const ITK_OVERRIDE { itkExceptionMacro("GetRadiometricCalibrationNoisePolynomialDegree() not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition day from the ossim metadata */ int GetDay() const ITK_OVERRIDE { itkExceptionMacro("GetDay not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition month from the ossim metadata */ int GetMonth() const ITK_OVERRIDE { itkExceptionMacro("GetMonth not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition year from the ossim metadata */ int GetYear() const ITK_OVERRIDE { itkExceptionMacro("GetYear not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition hour from the ossim metadata */ int GetHour() const ITK_OVERRIDE { itkExceptionMacro("GetHour not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging acquisition minute from the ossim metadata */ int GetMinute() const ITK_OVERRIDE { itkExceptionMacro("GetMinute not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production day from the ossim metadata */ int GetProductionDay() const ITK_OVERRIDE { itkExceptionMacro("GetProductionDay not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production month from the ossim metadata */ int GetProductionMonth() const ITK_OVERRIDE { itkExceptionMacro("GetProductionMonth not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the imaging production year from the ossim metadata */ int GetProductionYear() const ITK_OVERRIDE { itkExceptionMacro("GetProductionYear not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the PRF */ double GetPRF() const ITK_OVERRIDE { itkExceptionMacro("GetPRF not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the RSF */ double GetRSF() const ITK_OVERRIDE { itkExceptionMacro("GetRSF not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the radar frequency */ double GetRadarFrequency() const ITK_OVERRIDE { itkExceptionMacro("GetRadarFrequency not implemented in SarDefaultImageMetadataInterface, no captor type found"); } /** Get the center incidence angle */ double GetCenterIncidenceAngle() const ITK_OVERRIDE { itkExceptionMacro("GetCenterIncidenceAngle not implemented in SarDefaultImageMetadataInterface, no captor type found"); } bool CanRead() const ITK_OVERRIDE { // This class is the default one, it has to be able to call every metadata return false; } /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ UIntVectorType GetDefaultDisplay() const ITK_OVERRIDE { UIntVectorType rgb(3); rgb[0] = 0; rgb[1] = 0; rgb[2] = 0; return rgb; } protected: SarDefaultImageMetadataInterface(){}; ~SarDefaultImageMetadataInterface() ITK_OVERRIDE {} private: SarDefaultImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSarDefaultImageMetadataInterfaceFactory.h000066400000000000000000000045731301006202600315570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarDefaultImageMetadataInterfaceFactory_h #define otbSarDefaultImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class SarDefaultImageMetadataInterfaceFactory * \brief Creating an instance of a SarImageMetadataInterface object using object factory. * This class only provides the method of the virtual pure class SarImageMetadataInterface and throw exception for virtual method. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT SarDefaultImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef SarDefaultImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SarDefaultImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { SarDefaultImageMetadataInterfaceFactory::Pointer DefaultIMIFactory = SarDefaultImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(DefaultIMIFactory); } protected: SarDefaultImageMetadataInterfaceFactory(); ~SarDefaultImageMetadataInterfaceFactory() ITK_OVERRIDE; private: SarDefaultImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSarImageMetadataInterface.h000066400000000000000000000107261301006202600267170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarImageMetadataInterface_h #define otbSarImageMetadataInterface_h #include #include #include "OTBMetadataExport.h" #include "otbImageMetadataInterfaceBase.h" #include "itkPointSet.h" #include "otbSarCalibrationLookupData.h" #include "otbStringUtils.h" namespace otb { /** \class SarImageMetadataInterface * * \brief Class for SAR captor metadata reading. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT SarImageMetadataInterface : public ImageMetadataInterfaceBase { public: typedef SarImageMetadataInterface Self; typedef ImageMetadataInterfaceBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(SarImageMetadataInterface, ImageMetadataInterfaceBase); typedef Superclass::ImageType ImageType; typedef ImageType::IndexType IndexType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; typedef Superclass::UIntVectorType UIntVectorType; typedef Superclass::StringVectorType StringVectorType; typedef itk::PointSet PointSetType; typedef PointSetType::Pointer PointSetPointer; typedef double RealType; typedef PointSetType::PointType PointType; typedef SarCalibrationLookupData LookupDataType; typedef LookupDataType::Pointer LookupDataPointerType; virtual void CreateCalibrationLookupData(const short t); const LookupDataPointerType GetCalibrationLookupData(const short type); bool HasCalibrationLookupDataFlag() const; void SetCalibrationLookupData(LookupDataType* lut) { m_SarLut = lut; } virtual RealType GetRadiometricCalibrationScale() const; virtual PointSetPointer GetRadiometricCalibrationAntennaPatternNewGain() const; virtual PointSetPointer GetRadiometricCalibrationAntennaPatternOldGain() const; virtual PointSetPointer GetRadiometricCalibrationIncidenceAngle() const; virtual PointSetPointer GetRadiometricCalibrationRangeSpreadLoss() const; virtual PointSetPointer GetRadiometricCalibrationNoise() const; virtual IndexType GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() const; virtual IndexType GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() const; virtual IndexType GetRadiometricCalibrationIncidenceAnglePolynomialDegree() const; virtual IndexType GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() const; virtual IndexType GetRadiometricCalibrationNoisePolynomialDegree() const; virtual double GetPRF() const = 0; virtual double GetRSF() const = 0; virtual double GetRadarFrequency () const = 0; virtual double GetCenterIncidenceAngle() const = 0; virtual double GetRescalingFactor() const; virtual const std::string GetProductType() const; virtual const std::string GetAcquisitionMode() const; /** Get the enhanced band names (No enhanced band name support for SAR) */ StringVectorType GetEnhancedBandNames() const ITK_OVERRIDE { StringVectorType nothing; return nothing; } protected: SarImageMetadataInterface(); ~SarImageMetadataInterface() ITK_OVERRIDE {} PointSetPointer GetConstantValuePointSet(const RealType& value) const; IndexType GetConstantPolynomialDegree() const; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; LookupDataPointerType m_SarLut; private: SarImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSarImageMetadataInterfaceFactory.h000066400000000000000000000047431301006202600302510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarImageMetadataInterfaceFactory_h #define otbSarImageMetadataInterfaceFactory_h #include "itkObject.h" #include "otbSarImageMetadataInterface.h" namespace otb { /** \class SarImageMetadataInterfaceFactory * \brief Create instances of SarImageMetadataInterfaceFactory objects using an object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT SarImageMetadataInterfaceFactory : public itk::Object { public: /** Standard class typedefs. */ typedef SarImageMetadataInterfaceFactory Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class Methods used to interface with the registered factories */ /** Run-time type information (and related methods). */ itkTypeMacro(SarImageMetadataInterfaceFactory, Object); /** Convenient typedefs. */ typedef SarImageMetadataInterface::ImageType ImageType; typedef SarImageMetadataInterface::MetaDataDictionaryType MetaDataDictionaryType; typedef SarImageMetadataInterface::VectorType VectorType; typedef SarImageMetadataInterface::VariableLengthVectorType VariableLengthVectorType; typedef SarImageMetadataInterface::ImageKeywordlistType ImageKeywordlistType; typedef SarImageMetadataInterface::Pointer SarImageMetadataInterfacePointerType; /** Create the appropriate SarImageMetadataInterfaceFactory depending on the particulars of the file. */ static SarImageMetadataInterfacePointerType CreateIMI(const MetaDataDictionaryType& dict); /** Register Built-in factories */ static void RegisterBuiltInFactories(); protected: SarImageMetadataInterfaceFactory(); ~SarImageMetadataInterfaceFactory() ITK_OVERRIDE; private: SarImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSentinel1ImageMetadataInterface.h000066400000000000000000000153771301006202600300430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSentinel1ImageMetadataInterface_h #define otbSentinel1ImageMetadataInterface_h #include "otbSarImageMetadataInterface.h" namespace otb { /** \class Sentinel1ImageMetadataInterface * * \brief Creation of an "otb" Sentinel1ImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT Sentinel1ImageMetadataInterface : public SarImageMetadataInterface { public: typedef Sentinel1ImageMetadataInterface Self; typedef SarImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Sentinel1ImageMetadataInterface, SarImageMetadataInterface); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; typedef Superclass::RealType RealType; typedef Superclass::LookupDataPointerType LookupDataPointerType; /** Get the imaging production day from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionYear() const ITK_OVERRIDE; /** check sensor ID */ bool CanRead() const ITK_OVERRIDE; int GetDay() const ITK_OVERRIDE; int GetMonth() const ITK_OVERRIDE; int GetYear() const ITK_OVERRIDE; int GetHour() const ITK_OVERRIDE; int GetMinute() const ITK_OVERRIDE; UIntVectorType GetDefaultDisplay() const ITK_OVERRIDE; /*SarImageMetadataInterface pure virutals rituals */ double GetPRF() const ITK_OVERRIDE; double GetRSF() const ITK_OVERRIDE; double GetRadarFrequency() const ITK_OVERRIDE; double GetCenterIncidenceAngle() const ITK_OVERRIDE; /*get lookup data for calculating backscatter */ void CreateCalibrationLookupData(const short type) ITK_OVERRIDE; protected: /* class ctor */ Sentinel1ImageMetadataInterface(); /* class dtor */ ~Sentinel1ImageMetadataInterface() ITK_OVERRIDE {} private: Sentinel1ImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /* Helper function to parse date and time into a std::vector * using boost::split() expect date time in yyyy-mm-ddThh:mm:ss.ms * the date-time string is to be found in keywordlist with key 'key' * fills argument dateFields of type std::vector which is mutable! * TODO: move this method into base class */ void ParseDateTime(const char* key, std::vector& dateFields) const; mutable std::vector m_ProductionDateFields; mutable std::vector m_AcquisitionDateFields; }; struct Sentinel1CalibrationStruct { public: double timeMJD; double deltaMJD; // time difference to previous MJD in the list int line; std::vector pixels; std::vector deltaPixels; std::vector vect; }; class Sentinel1CalibrationLookupData : public SarCalibrationLookupData { public: /** Standard typedefs */ typedef Sentinel1CalibrationLookupData Self; typedef SarCalibrationLookupData Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(Sentinel1CalibrationLookupData, SarCalibrationLookupData); typedef itk::IndexValueType IndexValueType; Sentinel1CalibrationLookupData() : firstLineTime(0.) , lastLineTime(0.) , numOfLines(0) , count(0) , lineTimeInterval(0.) { } ~Sentinel1CalibrationLookupData() ITK_OVERRIDE { } void InitParameters(short type, double ft, double lt, int lines, int c, std::vector const& vlist) { firstLineTime = ft; lastLineTime = lt; numOfLines = lines; count = c; calibrationVectorList = vlist; this->SetType(type); lineTimeInterval = (lt - ft) / ((lines - 1) * 1.0); } double GetValue(const IndexValueType x, const IndexValueType y) const ITK_OVERRIDE { const int calVecIdx = GetVectorIndex(y); assert(calVecIdx>=0 && calVecIdx < count-1); const Sentinel1CalibrationStruct & vec0 = calibrationVectorList[calVecIdx]; const Sentinel1CalibrationStruct & vec1 = calibrationVectorList[calVecIdx + 1]; const double azTime = firstLineTime + y * lineTimeInterval; const double muY = (azTime - vec0.timeMJD) / vec1.deltaMJD; const int pixelIdx = GetPixelIndex(x, calibrationVectorList[calVecIdx]); const double muX = (x - vec0.pixels[pixelIdx]) / vec0.deltaPixels[pixelIdx + 1]; const double lutVal = (1 - muY) * ((1 - muX) * vec0.vect[pixelIdx] + muX * vec0.vect[pixelIdx + 1]) + muY * ((1 - muX) * vec1.vect[pixelIdx] + muX * vec1.vect[pixelIdx + 1]); return lutVal; } int GetVectorIndex(int y) const { for (int i = 1; i < count; i++) { if (y < calibrationVectorList[i].line) { return i - 1; } } return -1; } int GetPixelIndex(int x, const Sentinel1CalibrationStruct& calVec) const { const int size = calVec.pixels.size(); std::vector::const_iterator wh = std::upper_bound(calVec.pixels.begin(), calVec.pixels.end(), x); return wh == calVec.pixels.end() ? size - 2 : std::distance(calVec.pixels.begin(),wh)-1; } private: Sentinel1CalibrationLookupData(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented double firstLineTime; double lastLineTime; int numOfLines; int count; std::vector calibrationVectorList; double lineTimeInterval; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSentinel1ImageMetadataInterfaceFactory.h000066400000000000000000000042341301006202600313610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSentinel1ImageMetadataInterfaceFactory_h #define otbSentinel1ImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class Sentinel1ImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT Sentinel1ImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef Sentinel1ImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Sentinel1ImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer factory = Sentinel1ImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(factory); } protected: Sentinel1ImageMetadataInterfaceFactory(); ~Sentinel1ImageMetadataInterfaceFactory() ITK_OVERRIDE; private: Sentinel1ImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSpot6ImageMetadataInterface.h000066400000000000000000000117441301006202600272060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpot6ImageMetadataInterface_h #define otbSpot6ImageMetadataInterface_h #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class Spot6ImageMetadataInterface * * \brief Creation of an "otb" Spot6ImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT Spot6ImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef Spot6ImageMetadataInterface Self; typedef OpticalImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Spot6ImageMetadataInterface, OpticalImageMetadataInterface); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE; /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE; /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE; /** Get the imaging acquisition day from the ossim metadata : IMAGING_DATE metadata variable */ int GetDay() const ITK_OVERRIDE; /** Get the imaging acquisition month from the ossim metadata : IMAGING_DATE metadata variable */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetYear() const ITK_OVERRIDE; /** Get the imaging acquisition hour from the ossim metadata : IMAGING_DATE metadata variable */ int GetHour() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionYear() const ITK_OVERRIDE; /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE; /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE; /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE; /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE; /** Get Instrument */ std::string GetInstrument() const; /** Get Instrument Index */ std::string GetInstrumentIndex() const; /** This method is to handle the permutation of the spectral band by some image provider * in most cases, this method won't change the value, but for SPOT data, the bands are set up as * 2 1 0 3 in the tiff file, this method which is overloaded for SPOT enables to retrieve the * proper band. */ unsigned int BandIndexToWavelengthPosition(unsigned int i) const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Get the enhanced band names of the Spot6 data */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE; protected: Spot6ImageMetadataInterface(); ~Spot6ImageMetadataInterface() ITK_OVERRIDE {} private: Spot6ImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSpot6ImageMetadataInterfaceFactory.h000066400000000000000000000042501301006202600305300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpot6ImageMetadataInterfaceFactory_h #define otbSpot6ImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class Spot6ImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT Spot6ImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef Spot6ImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Spot6ImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Spot6ImageMetadataInterfaceFactory::Pointer Spot6IMIFactory = Spot6ImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(Spot6IMIFactory); } protected: Spot6ImageMetadataInterfaceFactory(); ~Spot6ImageMetadataInterfaceFactory() ITK_OVERRIDE; private: Spot6ImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSpotImageMetadataInterface.h000066400000000000000000000120721301006202600271130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpotImageMetadataInterface_h #define otbSpotImageMetadataInterface_h #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class SpotImageMetadataInterface * * \brief Creation of an "otb" SpotImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT SpotImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef SpotImageMetadataInterface Self; typedef OpticalImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SpotImageMetadataInterface, OpticalImageMetadataInterface); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE; /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE; /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE; /** Get the imaging acquisition day from the ossim metadata : IMAGING_DATE metadata variable */ int GetDay() const ITK_OVERRIDE; /** Get the imaging acquisition month from the ossim metadata : IMAGING_DATE metadata variable */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetYear() const ITK_OVERRIDE; /** Get the imaging acquisition hour from the ossim metadata : IMAGING_DATE metadata variable */ int GetHour() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : IMAGING_DATE metadata variable */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : DATASET_PRODUCTION_DATE metadata variable */ int GetProductionYear() const ITK_OVERRIDE; /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE; /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE; /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE; /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE; /** Get the enhanced band names (here nothing because the metadata did not provide band names) */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE { return this->Superclass::GetBandName(); } /** Get Instrument */ std::string GetInstrument() const; /** Get Instrument Index */ unsigned int GetInstrumentIndex() const; /** This method is to handle the permutation of the spectral band by some image provider * in most cases, this method won't change the value, but for SPOT data, the bands are set up as * 2 1 0 3 in the tiff file, this method which is overloaded for SPOT enables to retrieve the * proper band. */ unsigned int BandIndexToWavelengthPosition(unsigned int i) const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE; protected: SpotImageMetadataInterface(); ~SpotImageMetadataInterface() ITK_OVERRIDE {} private: SpotImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbSpotImageMetadataInterfaceFactory.h000066400000000000000000000042331301006202600304430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpotImageMetadataInterfaceFactory_h #define otbSpotImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class SpotImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT SpotImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef SpotImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SpotImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { SpotImageMetadataInterfaceFactory::Pointer spotIMIFactory = SpotImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(spotIMIFactory); } protected: SpotImageMetadataInterfaceFactory(); ~SpotImageMetadataInterfaceFactory() ITK_OVERRIDE; private: SpotImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbTerraSarImageMetadataInterface.h000066400000000000000000000153551301006202600277200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTerraSarImageMetadataInterface_h #define otbTerraSarImageMetadataInterface_h #include #include "otbSarImageMetadataInterface.h" #include "itkImageBase.h" namespace otb { /** \class TerraSarImageMetadataInterface * * \brief Creation of an "otb" TerraSarImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT TerraSarImageMetadataInterface : public SarImageMetadataInterface { public: typedef TerraSarImageMetadataInterface Self; typedef SarImageMetadataInterface Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TerraSarImageMetadataInterface, otbSarImageMetadataInterface); typedef itk::ImageBase<2> ImageType; typedef ImageType::IndexType IndexType; typedef std::vector IndexVectorType; typedef itk::MetaDataDictionary MetaDataDictionaryType; typedef MetaDataKey::VectorType VectorType; typedef MetaDataKey::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; typedef std::vector DoubleVectorType; typedef std::vector DoubleVectorVectorType; typedef std::vector UIntVectorType; typedef Superclass::PointSetType PointSetType; typedef Superclass::PointSetPointer PointSetPointer; typedef double RealType; /** Get the imaging start acquisition day from the ossim metadata */ int GetDay() const ITK_OVERRIDE; /** Get the imaging start acquisition month from the ossim metadata */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging start acquisition year from the ossim metadata */ int GetYear() const ITK_OVERRIDE; /** Get the imaging start acquisition hour from the ossim metadata */ int GetHour() const ITK_OVERRIDE; /** Get the imaging start acquisition minute from the ossim metadata */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : generationTime variable */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : generationTime variable */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : generationTime variable */ int GetProductionYear() const ITK_OVERRIDE; /** Get the calibration.calFactor : generationTime variable */ double GetCalibrationFactor() const; /** Get the number of noise records */ unsigned int GetNumberOfNoiseRecords() const; /** Get the polynomial degree list */ UIntVectorType GetNoisePolynomialDegrees() const; /** Get the polynomial coefficient list */ DoubleVectorVectorType GetNoisePolynomialCoefficientsList() const; /** Get timeUTC noise acquisition list in Julian day */ DoubleVectorType GetNoiseTimeUTCList() const; /** Get noise minimum validity range list */ DoubleVectorType GetNoiseValidityRangeMinList() const; /** Get noise maximum validity range list */ DoubleVectorType GetNoiseValidityRangeMaxList() const; /** Get noise reference point list */ DoubleVectorType GetNoiseReferencePointList() const; /** Get the radar frequency */ double GetRadarFrequency() const ITK_OVERRIDE; /** Get the PRF */ double GetPRF() const ITK_OVERRIDE; /** Get the RSF */ double GetRSF() const ITK_OVERRIDE; /** Get the number of corner incidence angles */ unsigned int GetNumberOfCornerIncidenceAngles() const; /** Get the Mean Incidence angles */ double GetMeanIncidenceAngles() const; /** Get the center incidence angle */ double GetCenterIncidenceAngle() const ITK_OVERRIDE; /** Get the center index */ IndexType GetCenterIncidenceAngleIndex() const; /** Get the corners incidence angles */ DoubleVectorType GetCornersIncidenceAngles() const; /** Get the corners index */ IndexVectorType GetCornersIncidenceAnglesIndex() const; /** Get the constant calibration factor */ RealType GetRadiometricCalibrationScale() const ITK_OVERRIDE; PointSetPointer GetRadiometricCalibrationNoise() const ITK_OVERRIDE; IndexType GetRadiometricCalibrationNoisePolynomialDegree() const ITK_OVERRIDE; //PointSetPointer GetRadiometricCalibrationAntennaPatternOldGain() const; PointSetPointer GetRadiometricCalibrationIncidenceAngle() const ITK_OVERRIDE; IndexType GetRadiometricCalibrationIncidenceAnglePolynomialDegree() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; protected: TerraSarImageMetadataInterface(); ~TerraSarImageMetadataInterface() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Evaluate polynom with Horner scheme*/ inline double Horner(std::vector& coefficients, const double tauMinusTauRef) const; double GetStartTimeUTC() const; double GetStopTimeUTC() const; RealType GetRangeTimeFirstPixel() const; RealType GetRangeTimeLastPixel() const; /** convert a TimeUTC string to a julian day */ double ConvertStringTimeUTCToJulianDay(const std::string& value) const; /** Get the polynomial degree for a given noise record */ unsigned int GetNoisePolynomialDegrees(unsigned int noiseRecord) const; /** Get the polynomial coefficient for a given noise record */ DoubleVectorType GetNoisePolynomialCoefficients(unsigned int noiseRecord) const; /** Get timeUTC noise acquisition in Julian day for a given noise record*/ double GetNoiseTimeUTC(unsigned int noiseRecord) const; /** Get noise reference point for a given noise record */ double GetNoiseReferencePoint(unsigned int noiseRecord) const; private: TerraSarImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbTerraSarImageMetadataInterfaceFactory.h000066400000000000000000000043171301006202600312440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTerraSarImageMetadataInterfaceFactory_h #define otbTerraSarImageMetadataInterfaceFactory_h #include "OTBMetadataExport.h" #include "itkObjectFactoryBase.h" namespace otb { /** \class TerraSarImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT TerraSarImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef TerraSarImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TerraSarImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { TerraSarImageMetadataInterfaceFactory::Pointer TerraSarIMIFactory = TerraSarImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(TerraSarIMIFactory); } protected: TerraSarImageMetadataInterfaceFactory(); ~TerraSarImageMetadataInterfaceFactory() ITK_OVERRIDE; private: TerraSarImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbWorldView2ImageMetadataInterface.h000066400000000000000000000107121301006202600301710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWorldView2ImageMetadataInterface_h #define otbWorldView2ImageMetadataInterface_h #include "otbOpticalImageMetadataInterface.h" namespace otb { /** \class WorldView2ImageMetadataInterface * * \brief Creation of an "otb" WorldView2ImageMetadataInterface that gets metadata. * * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT WorldView2ImageMetadataInterface : public OpticalImageMetadataInterface { public: typedef WorldView2ImageMetadataInterface Self; typedef ImageMetadataInterfaceBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(WorldView2ImageMetadataInterface, ImageMetadataInterfaceBase); typedef Superclass::ImageType ImageType; typedef Superclass::MetaDataDictionaryType MetaDataDictionaryType; typedef Superclass::VectorType VectorType; typedef Superclass::VariableLengthVectorType VariableLengthVectorType; typedef Superclass::ImageKeywordlistType ImageKeywordlistType; /** Get the radiometric bias from the ossim metadata */ VariableLengthVectorType GetPhysicalBias() const ITK_OVERRIDE; /** Get the radiometric gain from the ossim metadata */ VariableLengthVectorType GetPhysicalGain() const ITK_OVERRIDE; /** Get the solar irradiance from the ossim metadata */ VariableLengthVectorType GetSolarIrradiance() const ITK_OVERRIDE; /** Get the imaging acquisition day from the ossim metadata : TLCTime metadata value */ int GetDay() const ITK_OVERRIDE; /** Get the imaging acquisition month from the ossim metadata : TLCTime metadata value */ int GetMonth() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : TLCTime metadata value */ int GetYear() const ITK_OVERRIDE; /** Get the imaging acquisition hour from the ossim metadata : TLCTime metadata value */ int GetHour() const ITK_OVERRIDE; /** Get the imaging acquisition year from the ossim metadata : TLCTime metadata value */ int GetMinute() const ITK_OVERRIDE; /** Get the imaging production day from the ossim metadata : generationTime metadata value */ int GetProductionDay() const ITK_OVERRIDE; /** Get the imaging production month from the ossim metadata : generationTime metadata value */ int GetProductionMonth() const ITK_OVERRIDE; /** Get the imaging production year from the ossim metadata : generationTime metadata value */ int GetProductionYear() const ITK_OVERRIDE; /** Get the sat elevation from the ossim metadata */ double GetSatElevation() const ITK_OVERRIDE; /** Get the sat azimuth from the ossim metadata */ double GetSatAzimuth() const ITK_OVERRIDE; /** Get the first wavelength for the spectral band definition */ VariableLengthVectorType GetFirstWavelengths() const ITK_OVERRIDE; /** Get the last wavelength for the spectral band definition */ VariableLengthVectorType GetLastWavelengths() const ITK_OVERRIDE; bool CanRead() const ITK_OVERRIDE; /** Get the 3 spectral band numbers corresponding to the default display for visualization, * in the order R, G, B */ std::vector GetDefaultDisplay() const ITK_OVERRIDE; /** Vector that contains the filter function value in 6S format (step of 0.0025 micro m). * There values a computed by 6S. */ WavelengthSpectralBandVectorType GetSpectralSensitivity() const ITK_OVERRIDE; /** Get the enhanced band names from band names collected by ossim */ std::vector GetEnhancedBandNames() const ITK_OVERRIDE; protected: WorldView2ImageMetadataInterface(); ~WorldView2ImageMetadataInterface() ITK_OVERRIDE {} private: WorldView2ImageMetadataInterface(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/include/otbWorldView2ImageMetadataInterfaceFactory.h000066400000000000000000000044011301006202600315170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWorldView2ImageMetadataInterfaceFactory_h #define otbWorldView2ImageMetadataInterfaceFactory_h #include "itkObjectFactoryBase.h" #include "OTBMetadataExport.h" namespace otb { /** \class WorldView2ImageMetadataInterfaceFactory * \brief Creating an instance of a ImageMetadataInterface object using object factory. * * \ingroup OTBMetadata */ class OTBMetadata_EXPORT WorldView2ImageMetadataInterfaceFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef WorldView2ImageMetadataInterfaceFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(WorldView2ImageMetadataInterfaceFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { WorldView2ImageMetadataInterfaceFactory::Pointer worldView2IMIFactory = WorldView2ImageMetadataInterfaceFactory::New(); itk::ObjectFactoryBase::RegisterFactory(worldView2IMIFactory); } protected: WorldView2ImageMetadataInterfaceFactory(); ~WorldView2ImageMetadataInterfaceFactory() ITK_OVERRIDE; private: WorldView2ImageMetadataInterfaceFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Metadata/otb-module.cmake000066400000000000000000000007341301006202600225130ustar00rootroot00000000000000set(DOCUMENTATION "This module contains a set of classes that allow parsing metadata files from different types of sensor (both optical and radar sensor types are supported. for instance: Pleiades, SPOT6, TerraSar, and so on).") otb_module(OTBMetadata ENABLE_SHARED DEPENDS OTBObjectList OTBBoostAdapters OTBITK OTBOSSIMAdapters OTBCommon TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/Metadata/src/000077500000000000000000000000001301006202600202255ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Metadata/src/CMakeLists.txt000066400000000000000000000027401301006202600227700ustar00rootroot00000000000000set(OTBMetadata_SRC otbWorldView2ImageMetadataInterfaceFactory.cxx otbWorldView2ImageMetadataInterface.cxx otbQuickBirdImageMetadataInterfaceFactory.cxx otbQuickBirdImageMetadataInterface.cxx otbImageMetadataInterfaceFactory.cxx otbImageMetadataInterfaceBase.cxx otbSpotImageMetadataInterfaceFactory.cxx otbSpotImageMetadataInterface.cxx otbDefaultImageMetadataInterfaceFactory.cxx otbSarDefaultImageMetadataInterfaceFactory.cxx otbOpticalDefaultImageMetadataInterfaceFactory.cxx otbFormosatImageMetadataInterfaceFactory.cxx otbFormosatImageMetadataInterface.cxx otbOpticalImageMetadataInterfaceFactory.cxx otbOpticalImageMetadataInterface.cxx otbSpot6ImageMetadataInterfaceFactory.cxx otbSpot6ImageMetadataInterface.cxx otbIkonosImageMetadataInterfaceFactory.cxx otbIkonosImageMetadataInterface.cxx otbPleiadesImageMetadataInterfaceFactory.cxx otbPleiadesImageMetadataInterface.cxx otbSarImageMetadataInterfaceFactory.cxx otbSarImageMetadataInterface.cxx otbTerraSarImageMetadataInterfaceFactory.cxx otbTerraSarImageMetadataInterface.cxx otbSentinel1ImageMetadataInterfaceFactory.cxx otbSentinel1ImageMetadataInterface.cxx otbRadarsat2ImageMetadataInterfaceFactory.cxx otbRadarsat2ImageMetadataInterface.cxx otbNoDataHelper.cxx ) add_library(OTBMetadata ${OTBMetadata_SRC}) target_link_libraries(OTBMetadata ${OTBBoost_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ) otb_module_target(OTBMetadata) OTB-release-5.8/Modules/Core/Metadata/src/otbDefaultImageMetadataInterfaceFactory.cxx000066400000000000000000000030041301006202600306140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbDefaultImageMetadataInterfaceFactory.h" #include "otbDefaultImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { DefaultImageMetadataInterfaceFactory ::DefaultImageMetadataInterfaceFactory() { this->RegisterOverride("ImageMetadataInterfaceBase", "otbDefaultImageMetadataInterface", "Default Metadata Interface", 1, itk::CreateObjectFunction::New()); } DefaultImageMetadataInterfaceFactory ::~DefaultImageMetadataInterfaceFactory() { } const char* DefaultImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* DefaultImageMetadataInterfaceFactory::GetDescription() const { return "Default Metadata Interface Factory, handle Default metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbFormosatImageMetadataInterface.cxx000066400000000000000000001073101301006202600274770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFormosatImageMetadataInterface.h" #include "otbMacro.h" #include "otbMath.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" #include "otbStringUtils.h" namespace otb { FormosatImageMetadataInterface ::FormosatImageMetadataInterface() { } bool FormosatImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("Formosat") != std::string::npos) return true; else return false; } std::string FormosatImageMetadataInterface::GetInstrument() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument"); return valueString; } return ""; } unsigned int FormosatImageMetadataInterface::GetInstrumentIndex() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument_index")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument_index"); unsigned int value = atoi(valueString.c_str()); return value; } return -1; // Invalid value } FormosatImageMetadataInterface::VariableLengthVectorType FormosatImageMetadataInterface::GetSolarIrradiance() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.solar_irradiance")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.solar_irradiance"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); //In the case of SPOT, the bands are in a different order: // XS3, XS2. XS1, SWIR in the tif file. if (outputValues.size() == 1) { //this is a PAN image outputValuesVariableLengthVector[0] = outputValues[0]; } else if (outputValues.size() == 4) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; outputValuesVariableLengthVector[3] = outputValues[3]; } else { itkExceptionMacro("Invalid Solar Irradiance"); } return outputValuesVariableLengthVector; } int FormosatImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int FormosatImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int FormosatImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } int FormosatImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() < 4) itkExceptionMacro(<< "Invalid Hour"); int value = atoi(outputValues[3].c_str()); return value; } int FormosatImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() < 5) itkExceptionMacro(<< "Invalid Minute"); int value = atoi(outputValues[4].c_str()); return value; } int FormosatImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int FormosatImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int FormosatImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } FormosatImageMetadataInterface::VariableLengthVectorType FormosatImageMetadataInterface ::GetPhysicalBias() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.physical_bias")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.physical_bias"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); //In the case of FORMOSAT-2, the bands are in a different order: // XS3, XS2. XS1, SWIR in the tif file. if (outputValues.size() == 1) { //this is a PAN image outputValuesVariableLengthVector[0] = outputValues[0]; } else if (outputValues.size() == 4) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; outputValuesVariableLengthVector[3] = outputValues[3]; } else { itkExceptionMacro("Invalid Physical Bias"); } return outputValuesVariableLengthVector; } FormosatImageMetadataInterface::VariableLengthVectorType FormosatImageMetadataInterface ::GetPhysicalGain() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.physical_gain")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.physical_gain"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); //In the case of SPOT, the bands are in a different order: // XS3, XS2. XS1, SWIR in the tif file. if (outputValues.size() == 1) { //this is a PAN image outputValuesVariableLengthVector[0] = outputValues[0]; } else if (outputValues.size() == 4) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; outputValuesVariableLengthVector[3] = outputValues[3]; } else { itkExceptionMacro("Invalid Physical Gain"); } return outputValuesVariableLengthVector; } double FormosatImageMetadataInterface::GetSatElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.incident_angle")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.incident_angle"); double value = 90 - atof(valueString.c_str()); return value; } double FormosatImageMetadataInterface::GetSatAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.incident_angle")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.sat_azimuth_angle"); double satAz = atof(valueString.c_str()); // In some software version, a bug exists. // We have to check the version t correct the satellite azimuth angle contained in the metadata std::string softVersion = imageKeywordlist.GetMetadataByKey("support_data.software_version"); if( (softVersion == "R2P_02.03.P1") || (softVersion == "R2P_02.02") || (softVersion == "R2P_02.03") ) { if (!imageKeywordlist.HasKey("support_data.viewing_angle_across_track")) { return 0; } if (!imageKeywordlist.HasKey("support_data.viewing_angle_along_track")) { return 0; } if (!imageKeywordlist.HasKey("support_data.scene_orientation")) { return 0; } valueString = imageKeywordlist.GetMetadataByKey("support_data.viewing_angle_across_track"); double viewingAngleAcrossTrack( atof(valueString.c_str()) ); valueString = imageKeywordlist.GetMetadataByKey("support_data.viewing_angle_along_track"); double viewingAngleAlongTrack( atof(valueString.c_str()) ); valueString = imageKeywordlist.GetMetadataByKey("support_data.scene_orientation"); double sceneOrientation( atof(valueString.c_str()) ); double alpha = vcl_atan( vcl_tan( viewingAngleAcrossTrack * CONST_PI_180 ) / vcl_tan( viewingAngleAlongTrack * CONST_PI_180 ) ) * CONST_180_PI; if( viewingAngleAlongTrack < 0 ) { if (alpha >0) { alpha = alpha - 180; } else { alpha = alpha + 180; } } alpha -= sceneOrientation; if (alpha >0) { satAz += 180; } else { satAz = 180 - satAz; } } return satAz; } FormosatImageMetadataInterface::VariableLengthVectorType FormosatImageMetadataInterface ::GetFirstWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid metadata, no Formosat2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); // FIXME that's definitely NOT correct in a formosat file!!! if (sensorId == "SPOT4") wavel.Fill(0.610); else if (sensorId == "SPOT5") wavel.Fill(0.480); else itkExceptionMacro(<< "Invalid Formosat2 Sensor ID"); } else if (nbBands > 1 && nbBands < 5) { wavel.SetSize(4); //FIXME is that supposed to correspond to the bands in the files? wavel[0] = 0.500; wavel[1] = 0.610; wavel[2] = 0.780; wavel[3] = 1.580; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } FormosatImageMetadataInterface::VariableLengthVectorType FormosatImageMetadataInterface ::GetLastWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid metadata, no Formosat2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); if (sensorId == "SPOT4") wavel.Fill(0.680); else if (sensorId == "SPOT5") wavel.Fill(0.710); else itkExceptionMacro(<< "Invalid Formosat2 Sensor ID"); } else if (nbBands > 1 && nbBands < 5) { //FIXME is that supposed to correspond to the bands in the files? wavel.SetSize(4); wavel[0] = 0.590; wavel[1] = 0.680; wavel[2] = 0.890; wavel[3] = 1.750; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } unsigned int FormosatImageMetadataInterface ::BandIndexToWavelengthPosition(unsigned int i) const { otbMsgDevMacro(<< "Formosat2 detected: band 0 and 2 inverted"); if (i == 0) return 2; if (i == 2) return 0; return i; } std::vector FormosatImageMetadataInterface::GetDefaultDisplay() const { std::vector rgb(3); rgb[0] = 0; rgb[1] = 1; rgb[2] = 2; return rgb; } FormosatImageMetadataInterface::WavelengthSpectralBandVectorType FormosatImageMetadataInterface ::GetSpectralSensitivity() const { WavelengthSpectralBandVectorType wavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); std::list > tmpSpectralBandList; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Formosat Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { const float b0[281] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000219376f, 0.000219425f, 0.000231534f, 0.000284519f, 0.000550079f, 0.001f, 0.003f, 0.006f, 0.012f, 0.0235f, 0.035f, 0.043f, 0.0503893f, 0.0525f, 0.055f, 0.0565f, 0.058f, 0.059f, 0.059f, 0.0608594f, 0.061f, 0.0615f, 0.062f, 0.063f, 0.063f, 0.064f, 0.063f, 0.064f, 0.065f, 0.066f, 0.066f, 0.066f, 0.066f, 0.0675f, 0.069f, 0.0708104f, 0.0709615f, 0.0709001f, 0.071f, 0.0715f, 0.073f, 0.074f, 0.074f, 0.073f, 0.073f, 0.0735f, 0.075f, 0.0765f, 0.078f, 0.078f, 0.078f, 0.0785f, 0.0800145f, 0.0815f, 0.083f, 0.083f, 0.083f, 0.083f, 0.083f, 0.0835f, 0.085f, 0.0865f, 0.087f, 0.088f, 0.087f, 0.087f, 0.088f, 0.0885f, 0.0907023f, 0.0915f, 0.092f, 0.092f, 0.092f, 0.092f, 0.093f, 0.094f, 0.095f, 0.096f, 0.096f, 0.096f, 0.095f, 0.095f, 0.095f, 0.095f, 0.096f, 0.0975f, 0.098f, 0.099f, 0.099f, 0.098f, 0.098f, 0.0965f, 0.096f, 0.0965f, 0.098f, 0.0985f, 0.099f, 0.0995f, 0.099f, 0.0975f, 0.097f, 0.0955f, 0.095f, 0.095f, 0.095f, 0.0965f, 0.097f, 0.098f, 0.098f, 0.0975f, 0.097f, 0.096f, 0.095f, 0.095f, 0.094f, 0.094f, 0.095f, 0.0955f, 0.096f, 0.097f, 0.097f, 0.097f, 0.097f, 0.097f, 0.097f, 0.096f, 0.097f, 0.097f, 0.097f, 0.098f, 0.098f, 0.096f, 0.095f, 0.094f, 0.093f, 0.092f, 0.091f, 0.0905658f, 0.089f, 0.089f, 0.089f, 0.088f, 0.088f, 0.0875f, 0.087f, 0.086f, 0.085f, 0.084f, 0.083f, 0.0825f, 0.082f, 0.081f, 0.081f, 0.0804051f, 0.079f, 0.078f, 0.077f, 0.077f, 0.076f, 0.075f, 0.074f, 0.0735f, 0.073f, 0.0725f, 0.072f, 0.071f, 0.071f, 0.0704136f, 0.069f, 0.0685f, 0.068f, 0.067f, 0.066f, 0.0645f, 0.063f, 0.062f, 0.0607892f, 0.059f, 0.058f, 0.057f, 0.056f, 0.0545f, 0.052f, 0.0455f, 0.038f, 0.0286994f, 0.0202138f, 0.0125f, 0.007f, 0.004f, 0.002f, 0.001f, 0.000909856f, 0.000512159f, 0.000357051f, 0.00029112f, 0.000215752f, 0.000187213f, 0.000171918f, 0.000169724f, 0.000166392f, 0.000163058f, 0.000159726f, 0.000156393f, 0.000153061f, 0.000149728f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; //add panchromatic band to the temporary list const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); tmpSpectralBandList.push_back(vb0); } else if (nbBands > 1 && nbBands < 5) { const float b1[281] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000354959f, 0.000354603f, 0.000376745f, 0.000478212f, 0.0009718f, 0.002f, 0.005f, 0.0124297f, 0.024f, 0.0415f, 0.057f, 0.0685f, 0.074f, 0.074f, 0.076f, 0.0795695f, 0.082f, 0.084f, 0.083f, 0.0825f, 0.086f, 0.0910953f, 0.094f, 0.096f, 0.096f, 0.094f, 0.094f, 0.096f, 0.099f, 0.0995f, 0.099f, 0.098f, 0.095f, 0.092f, 0.095f, 0.0985f, 0.092f, 0.0695f, 0.037f, 0.025f, 0.009f, 0.0025f, 0.001f, 0.000847053f, 0.000588401f, 0.00051966f, 0.00050602f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 }; const float b2[281] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000324677f, 0.000326475f, 0.000331943f, 0.000386303f, 0.000447683f, 0.001f, 0.003f, 0.0045f, 0.012f, 0.0205f, 0.036f, 0.0615f, 0.075f, 0.081f, 0.082f, 0.0845f, 0.087f, 0.0885f, 0.088f, 0.087f, 0.086f, 0.0875f, 0.0908484f, 0.0925f, 0.094f, 0.094f, 0.093f, 0.0925f, 0.093f, 0.0955f, 0.097f, 0.098f, 0.099f, 0.099f, 0.099f, 0.099f, 0.099f, 0.099f, 0.095f, 0.0815f, 0.057f, 0.032f, 0.018f, 0.0112534f, 0.005f, 0.0015f, 0.000758484f, 0.000604297f, 0.000512471f, 0.000475316f, 0.000453283f, 0.00044559f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 }; const float b3[281] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000461752f, 0.001f, 0.001f, 0.003f, 0.006f, 0.013f, 0.0335f, 0.063f, 0.089f, 0.098f, 0.099f, 0.099f, 0.099f, 0.099f, 0.0985f, 0.097f, 0.0945f, 0.092f, 0.0906796f, 0.089f, 0.0907659f, 0.093f, 0.0965f, 0.1f, 0.097f, 0.091f, 0.0865f, 0.086f, 0.0910438f, 0.094f, 0.092f, 0.093f, 0.088f, 0.064f, 0.034f, 0.015f, 0.0075f, 0.006f, 0.0045f, 0.003f, 0.001f, 0.000607601f, 0.000202927f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 }; const float b4[281] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000481456f, 0.00071923f, 0.00098303f, 0.001f, 0.000947915f, 0.00090899f, 0.000887367f, 0.000576847f, 0.000470858f, 0.00052246f, 0.000713811f, 0.001f, 0.0015f, 0.003f, 0.005f, 0.008f, 0.0145f, 0.022f, 0.035f, 0.049f, 0.0595f, 0.075f, 0.0905f, 0.098f, 0.0995f, 0.097f, 0.093f, 0.091f, 0.0925f, 0.094f, 0.096f, 0.096f, 0.0955f, 0.094f, 0.092f, 0.0907811f, 0.089f, 0.088f, 0.088f, 0.088f, 0.088f, 0.088f, 0.0875f, 0.087f, 0.086f, 0.085f, 0.084f, 0.083f, 0.083f, 0.082f, 0.081f, 0.0806396f, 0.079f, 0.078f, 0.077f, 0.076f, 0.075f, 0.074f, 0.073f, 0.072f, 0.071f, 0.0700369f, 0.0685f, 0.067f, 0.0655f, 0.064f, 0.063f, 0.063f, 0.062f, 0.059f, 0.054f, 0.043f, 0.034f, 0.025f, 0.016f, 0.009f, 0.0055f, 0.003f, 0.0015f, 0.001f, 0.000691333f, 0.000432126f, 0.000356974f, 0.000265441f, 0.000219773f, 0.000195346f, 0.000192716f, 0.000188932f, 0.000185148f, 0.000181364f, 0.00017758f, 0.000173796f, 0.000170011f, 0.000166227f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 }; //Add multispectral bands to the temporary list const std::vector vb1 (b1, b1 + sizeof(b1) / sizeof(float) ); tmpSpectralBandList.push_back(vb1); const std::vector vb2 (b2, b2 + sizeof(b2) / sizeof(float) ); tmpSpectralBandList.push_back(vb2); const std::vector vb3 (b3, b3 + sizeof(b3) / sizeof(float) ); tmpSpectralBandList.push_back(vb3); const std::vector vb4 (b4, b4 + sizeof(b4) / sizeof(float) ); tmpSpectralBandList.push_back(vb4); unsigned int j = 0; for (std::list >::const_iterator it = tmpSpectralBandList.begin(); it != tmpSpectralBandList.end(); ++it) { wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); wavelengthSpectralBand->GetNthElement(j)->SetFilterFunctionValues(*it); wavelengthSpectralBand->GetNthElement(j)->SetMinSpectralValue(0.300); wavelengthSpectralBand->GetNthElement(j)->SetMaxSpectralValue(1.0); wavelengthSpectralBand->GetNthElement(j)->SetUserStep(0.0025); ++j; } } return wavelengthSpectralBand; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbFormosatImageMetadataInterfaceFactory.cxx000066400000000000000000000027531301006202600310340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFormosatImageMetadataInterfaceFactory.h" #include "otbFormosatImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { FormosatImageMetadataInterfaceFactory ::FormosatImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbFormosatImageMetadataInterface", "Formosat Metadata Interface", 1, itk::CreateObjectFunction::New()); } FormosatImageMetadataInterfaceFactory ::~FormosatImageMetadataInterfaceFactory() { } const char* FormosatImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* FormosatImageMetadataInterfaceFactory::GetDescription() const { return "Formosat Metadata Interface Factory, handle Formosat metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbIkonosImageMetadataInterface.cxx000066400000000000000000001131041301006202600271450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbIkonosImageMetadataInterface.h" #include "otbStringUtils.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" namespace otb { IkonosImageMetadataInterface ::IkonosImageMetadataInterface() { } bool IkonosImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("IKONOS-2") != std::string::npos) return true; else return false; } IkonosImageMetadataInterface::VariableLengthVectorType IkonosImageMetadataInterface::GetSolarIrradiance() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(1); if (!imageKeywordlist.HasKey("support_data.band_name")) { outputValuesVariableLengthVector[0] = -1; return outputValuesVariableLengthVector; } std::string keywordString = imageKeywordlist.GetMetadataByKey("support_data.band_name"); // values from geoeye // TODO are these the correct values ???? if (keywordString == "Pan") { outputValuesVariableLengthVector[0] = 1375.8; } else if (keywordString == "Blue") { outputValuesVariableLengthVector[0] = 1930.9; } else if (keywordString == "Green") { outputValuesVariableLengthVector[0] = 1854.8; } else if (keywordString == "Red") { outputValuesVariableLengthVector[0] = 1556.5; } else if (keywordString == "NIR") { outputValuesVariableLengthVector[0] = 1156.9; } return outputValuesVariableLengthVector; } int IkonosImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.acquisition_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.acquisition_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int IkonosImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.acquisition_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.acquisition_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int IkonosImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.acquisition_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.acquisition_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } int IkonosImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.acquisition_time")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.acquisition_time"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() < 2) itkExceptionMacro(<< "Invalid Hour"); int value = atoi(outputValues[0].c_str()); return value; } int IkonosImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.acquisition_time")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.acquisition_time"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() < 2) itkExceptionMacro(<< "Invalid Minute"); int value = atoi(outputValues[1].c_str()); return value; } int IkonosImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-/")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); // MM/DD/YY int value = atoi(outputValues[1].c_str()); return value; } int IkonosImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-/")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); // MM/DD/YY int value = atoi(outputValues[0].c_str()); return value; } int IkonosImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-/")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); // MM/DD/YY int year = atoi(outputValues[2].c_str()); if (year == 99) year += 1900; else year += 2000; return year; } IkonosImageMetadataInterface::VariableLengthVectorType IkonosImageMetadataInterface ::GetPhysicalBias() const { if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(GetNumberOfBands()); outputValuesVariableLengthVector.Fill(0.0); return outputValuesVariableLengthVector; } IkonosImageMetadataInterface::VariableLengthVectorType IkonosImageMetadataInterface ::GetPhysicalGain() const { if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } int productionYear = this->GetProductionYear(); int productionMonth = this->GetProductionMonth(); int productionDay = this->GetProductionDay(); bool isPost20010122 = false; if ((productionDay + 100 * productionMonth + 10000 * productionYear) >= 20010122) { isPost20010122 = true; } //Value computed from // http://www.geoeye.com/CorpSite/assets/docs/technical-papers/2009/IKONOS_Esun_Calculations.pdf // to get the equivalent of the SPOT alpha VariableLengthVectorType gain; gain.SetSize(5); if (isPost20010122) { gain[0] = 6.48830; //Pan gain[1] = 5.19064; //Blue gain[2] = 6.44122; //Green gain[3] = 6.24442; //Red gain[4] = 8.04222; //NIR } else { gain[0] = 6.48830; //Pan gain[1] = 4.51329; //Blue gain[2] = 5.75014; //Green gain[3] = 5.52720; //Red gain[4] = 7.11684; //NIR } std::vector bandName = GetBandName(); VariableLengthVectorType outputValuesVariableLengthVector; unsigned int numBands = GetNumberOfBands(); /** Tests if the number of bands in metadata are the same as bandName size*/ if (numBands != bandName.size()) { itkExceptionMacro(<< "Invalid number of bands..."); } outputValuesVariableLengthVector.SetSize(numBands); for (unsigned int i = 0; i < numBands; ++i) { if (bandName[i].find("Pan") != std::string::npos) outputValuesVariableLengthVector[i] = gain[0]; if (bandName[i].find("Blue") != std::string::npos) outputValuesVariableLengthVector[i] = gain[1]; if (bandName[i].find("Green") != std::string::npos) outputValuesVariableLengthVector[i] = gain[2]; if (bandName[i].find("Red") != std::string::npos) outputValuesVariableLengthVector[i] = gain[3]; if (bandName[i].find("NIR") != std::string::npos) outputValuesVariableLengthVector[i] = gain[4]; } return outputValuesVariableLengthVector; } double IkonosImageMetadataInterface::GetSatElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.nominal_collection_elevation_angle")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.nominal_collection_elevation_angle"); double value = atof(valueString.c_str()); return value; } double IkonosImageMetadataInterface::GetSatAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.nominal_collection_azimuth_angle")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.nominal_collection_azimuth_angle"); double value = atof(valueString.c_str()); return value; } IkonosImageMetadataInterface::VariableLengthVectorType IkonosImageMetadataInterface ::GetFirstWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); wavel.Fill(0.526); } else if (nbBands == 4) { wavel.SetSize(4); wavel[0] = 0.445; wavel[1] = 0.506; wavel[2] = 0.632; wavel[3] = 0.757; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } IkonosImageMetadataInterface::VariableLengthVectorType IkonosImageMetadataInterface ::GetLastWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Ikonos Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); wavel.Fill(0.929); } else if (nbBands == 4) { wavel.SetSize(4); wavel[0] = 0.516; wavel[1] = 0.595; wavel[2] = 0.698; wavel[3] = 0.853; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } std::vector IkonosImageMetadataInterface::GetDefaultDisplay() const { std::vector rgb(3); rgb[0] = 2; rgb[1] = 1; rgb[2] = 0; return rgb; } std::vector IkonosImageMetadataInterface ::GetEnhancedBandNames() const { // Already done for the current file return this->Superclass::GetBandName(); } IkonosImageMetadataInterface::WavelengthSpectralBandVectorType IkonosImageMetadataInterface ::GetSpectralSensitivity() const { //TODO tabulate spectral responses WavelengthSpectralBandVectorType wavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); std::vector bandName = GetBandName(); unsigned int numBands = GetNumberOfBands(); /** Tests if the number of bands in metadata are the same as bandName size*/ if (numBands != bandName.size()) { itkExceptionMacro(<< "Invalid number of bands..."); } for (unsigned int i = 0; i < numBands; ++i) { float b0[275]; if (bandName[i].find("Pan") != std::string::npos) { const float tmp[275] = { 0.000777411f, 0.000698442f, 0.000619473f, 0.000490086f, 0.000360699f, 0.000302118f, 0.000243538f, 0.000339101f, 0.000434664f, 0.000674356f, 0.000914047f, 0.00165711f, 0.00240018f, 0.00382524f, 0.00525031f, 0.00774772f, 0.0102451f, 0.0136149f, 0.0169847f, 0.0216852f, 0.0263858f, 0.0322139f, 0.0380419f, 0.0451535f, 0.052265f, 0.059372f, 0.066479f, 0.0749836f, 0.0834881f, 0.0922321f, 0.100976f, 0.11238f, 0.123783f, 0.135806f, 0.147828f, 0.158671f, 0.169515f, 0.181498f, 0.193481f, 0.199257f, 0.205034f, 0.224842f, 0.24465f, 0.252955f, 0.26126f, 0.271512f, 0.281764f, 0.291251f, 0.300738f, 0.30953f, 0.318322f, 0.321402f, 0.324481f, 0.329386f, 0.33429f, 0.338595f, 0.342899f, 0.346889f, 0.350879f, 0.354954f, 0.359028f, 0.366986f, 0.374944f, 0.383555f, 0.392166f, 0.407887f, 0.423609f, 0.439638f, 0.455668f, 0.472286f, 0.488904f, 0.509193f, 0.529483f, 0.549106f, 0.56873f, 0.592408f, 0.616086f, 0.639134f, 0.662182f, 0.680563f, 0.698943f, 0.720886f, 0.742829f, 0.764357f, 0.785886f, 0.805496f, 0.825106f, 0.843924f, 0.862743f, 0.882061f, 0.901379f, 0.923168f, 0.944958f, 0.948979f, 0.952999f, 0.960789f, 0.968579f, 0.973284f, 0.977989f, 0.972502f, 0.967015f, 0.980472f, 0.993929f, 0.993271f, 0.992614f, 0.988076f, 0.983538f, 0.991769f, 1.0f, 0.996457f, 0.992914f, 0.996456f, 0.999998f, 0.993659f, 0.98732f, 0.980205f, 0.973089f, 0.957487f, 0.941886f, 0.939394f, 0.936901f, 0.920086f, 0.90327f, 0.895178f, 0.887086f, 0.878162f, 0.869238f, 0.876515f, 0.883791f, 0.883182f, 0.882573f, 0.883526f, 0.884479f, 0.889877f, 0.895275f, 0.895902f, 0.89653f, 0.911267f, 0.926004f, 0.924618f, 0.923232f, 0.91542f, 0.907607f, 0.904518f, 0.90143f, 0.903022f, 0.904613f, 0.902261f, 0.899908f, 0.893658f, 0.887407f, 0.890136f, 0.892866f, 0.889693f, 0.88652f, 0.892279f, 0.898039f, 0.904587f, 0.911135f, 0.927581f, 0.944026f, 0.951458f, 0.95889f, 0.947059f, 0.935229f, 0.946541f, 0.957854f, 0.965818f, 0.973781f, 0.973879f, 0.973978f, 0.971217f, 0.968457f, 0.96373f, 0.959003f, 0.95437f, 0.949736f, 0.932402f, 0.915067f, 0.906743f, 0.898418f, 0.90573f, 0.913042f, 0.923885f, 0.934728f, 0.931538f, 0.928349f, 0.934038f, 0.939728f, 0.923287f, 0.906846f, 0.914615f, 0.922384f, 0.929317f, 0.93625f, 0.943838f, 0.951427f, 0.948289f, 0.945151f, 0.949082f, 0.953013f, 0.938094f, 0.923176f, 0.921154f, 0.919132f, 0.890009f, 0.860885f, 0.867236f, 0.873588f, 0.850292f, 0.826995f, 0.817882f, 0.808768f, 0.800406f, 0.792044f, 0.777065f, 0.762087f, 0.755304f, 0.748521f, 0.727815f, 0.707108f, 0.696978f, 0.686848f, 0.68378f, 0.680711f, 0.675044f, 0.669377f, 0.641688f, 0.613999f, 0.596144f, 0.578289f, 0.567037f, 0.555785f, 0.536112f, 0.516439f, 0.498523f, 0.480606f, 0.475695f, 0.470783f, 0.452628f, 0.434473f, 0.415006f, 0.395538f, 0.373581f, 0.351624f, 0.344258f, 0.336893f, 0.323178f, 0.309463f, 0.296963f, 0.284464f, 0.277545f, 0.270627f, 0.259838f, 0.249049f, 0.242783f, 0.236516f, 0.226031f, 0.215545f, 0.205517f, 0.195489f, 0.187778f, 0.180066f, 0.172017f, 0.163968f, 0.156649f, 0.14933f, 0.142851f, 0.136372f, 0.127527f, 0.118682f, 0.111158f, 0.103634f, 0.0963653f, 0.0f }; for (unsigned int j = 0; j < 275; ++j) { b0[j] = tmp[j]; } } else if (bandName[i].find("Blue") != std::string::npos) { const float tmp[275] = { 0.000773147f, 0.00111792f, 0.00146269f, 0.00116425f, 0.000865817f, 0.000798356f, 0.000730896f, 0.000724069f, 0.000717243f, 0.000983961f, 0.00125068f, 0.00147711f, 0.00170354f, 0.00181267f, 0.0019218f, 0.00235592f, 0.00279004f, 0.00398685f, 0.00518366f, 0.00642842f, 0.00767318f, 0.00823188f, 0.00879058f, 0.0103296f, 0.0118686f, 0.0146603f, 0.017452f, 0.0262281f, 0.0350041f, 0.0602011f, 0.085398f, 0.139163f, 0.192928f, 0.261737f, 0.330546f, 0.375015f, 0.419484f, 0.463835f, 0.508186f, 0.560708f, 0.613231f, 0.643718f, 0.674206f, 0.697319f, 0.720432f, 0.740631f, 0.760831f, 0.760468f, 0.760104f, 0.77422f, 0.788336f, 0.822457f, 0.856578f, 0.872968f, 0.889358f, 0.916497f, 0.943636f, 0.971818f, 1.0f, 0.993393f, 0.986786f, 0.956164f, 0.925542f, 0.843438f, 0.761333f, 0.651888f, 0.542443f, 0.428187f, 0.31393f, 0.259011f, 0.204092f, 0.178009f, 0.151925f, 0.118774f, 0.0856216f, 0.0643982f, 0.0431748f, 0.0370744f, 0.030974f, 0.0288085f, 0.0266429f, 0.0243978f, 0.0221527f, 0.0221454f, 0.0221381f, 0.0241802f, 0.0262224f, 0.027894f, 0.0295655f, 0.0282719f, 0.0269782f, 0.0247994f, 0.0226207f, 0.0240241f, 0.0254275f, 0.0279644f, 0.0305013f, 0.0289285f, 0.0273557f, 0.0243127f, 0.0212697f, 0.021495f, 0.0217203f, 0.0256572f, 0.0295941f, 0.0319082f, 0.0342224f, 0.0306457f, 0.027069f, 0.0232825f, 0.019496f, 0.0194953f, 0.0194945f, 0.019262f, 0.0190295f, 0.0165004f, 0.0139713f, 0.0106605f, 0.00734963f, 0.00665076f, 0.00595189f, 0.00555088f, 0.00514986f, 0.00651302f, 0.00787617f, 0.0101045f, 0.0123327f, 0.0161468f, 0.0199609f, 0.0210092f, 0.0220576f, 0.021422f, 0.0207864f, 0.0198958f, 0.0190052f, 0.0172422f, 0.0154792f, 0.012607f, 0.00973489f, 0.00827171f, 0.00680854f, 0.00586579f, 0.00492304f, 0.00515291f, 0.00538278f, 0.00845239f, 0.011522f, 0.0168842f, 0.0222464f, 0.0231172f, 0.023988f, 0.0180264f, 0.0120648f, 0.0080432f, 0.00402165f, 0.00311771f, 0.00221378f, 0.00238421f, 0.00255463f, 0.00240824f, 0.00226184f, 0.00286143f, 0.00346102f, 0.00296337f, 0.00246571f, 0.00239388f, 0.00232204f, 0.00315372f, 0.0039854f, 0.0037969f, 0.00360839f, 0.00315481f, 0.00270124f, 0.00254147f, 0.0023817f, 0.00250869f, 0.00263568f, 0.00244201f, 0.00224833f, 0.00192361f, 0.00159888f, 0.00157883f, 0.00155879f, 0.00177376f, 0.00198873f, 0.00199198f, 0.00199522f, 0.00225955f, 0.00252388f, 0.00306228f, 0.00360067f, 0.00461183f, 0.00562299f, 0.00610986f, 0.00659673f, 0.00707311f, 0.00754949f, 0.00775649f, 0.00796349f, 0.00871715f, 0.00947081f, 0.00887752f, 0.00828423f, 0.00852913f, 0.00877403f, 0.00901617f, 0.00925831f, 0.00995926f, 0.0106602f, 0.0115813f, 0.0125024f, 0.0128068f, 0.0131113f, 0.0130847f, 0.0130581f, 0.0124604f, 0.0118627f, 0.0111828f, 0.0105029f, 0.00998883f, 0.00947476f, 0.00913233f, 0.00878991f, 0.00859062f, 0.00839133f, 0.00830986f, 0.0082284f, 0.00812489f, 0.00802138f, 0.00818694f, 0.0083525f, 0.00823223f, 0.00811195f, 0.00805303f, 0.00799411f, 0.00800437f, 0.00801463f, 0.00743377f, 0.00685291f, 0.00615093f, 0.00544896f, 0.00512429f, 0.00479963f, 0.00463363f, 0.00446762f, 0.00428193f, 0.00409623f, 0.00384906f, 0.00360189f, 0.00353085f, 0.00345981f, 0.00336041f, 0.00326101f, 0.00300593f, 0.00275086f, 0.00278287f, 0.00281488f, 0.00259549f, 0.00237609f, 0.00236111f, 0.00234613f, 0.00248306f, 0.00261998f, 0.00263357f, 0.00264716f, 0.0026242f, 0.00260124f, 0.00210138f, 0.00160152f, 0.00177352f, 0.00194551f, 0.00218138f, 0.00241724f, 0.00185843f, 0.0f }; for (unsigned int j = 0; j < 275; ++j) { b0[j] = tmp[j]; } } else if (bandName[i].find("Green") != std::string::npos) { const float tmp[275] = { 0.000643373f, 0.000721567f, 0.000799761f, 0.000764593f, 0.000729425f, 0.000767756f, 0.000806087f, 0.000691702f, 0.000577317f, 0.000709642f, 0.000841967f, 0.000741458f, 0.000640949f, 0.000754853f, 0.000868757f, 0.000732192f, 0.000595627f, 0.000952731f, 0.00130983f, 0.00125601f, 0.00120219f, 0.00194445f, 0.00268671f, 0.00183813f, 0.000989541f, 0.00113105f, 0.00127256f, 0.00160875f, 0.00194493f, 0.00229841f, 0.00265189f, 0.00301361f, 0.00337532f, 0.00370611f, 0.00403689f, 0.00486952f, 0.00570216f, 0.00738653f, 0.0090709f, 0.010205f, 0.011339f, 0.0113175f, 0.011296f, 0.0121669f, 0.0130378f, 0.0151163f, 0.0171948f, 0.0208267f, 0.0244586f, 0.0305813f, 0.036704f, 0.0434839f, 0.0502638f, 0.0565094f, 0.0627551f, 0.0860566f, 0.109358f, 0.151232f, 0.193107f, 0.242087f, 0.291067f, 0.365317f, 0.439568f, 0.545145f, 0.650723f, 0.728637f, 0.806551f, 0.839149f, 0.871746f, 0.88005f, 0.888355f, 0.889065f, 0.889775f, 0.882352f, 0.874928f, 0.863518f, 0.852108f, 0.872214f, 0.89232f, 0.944994f, 0.997669f, 0.981902f, 0.966134f, 0.936936f, 0.907737f, 0.900477f, 0.893218f, 0.919539f, 0.94586f, 0.971546f, 0.997232f, 0.978528f, 0.959823f, 0.918631f, 0.877439f, 0.813588f, 0.749737f, 0.625854f, 0.50197f, 0.392566f, 0.283162f, 0.22152f, 0.159878f, 0.133355f, 0.106831f, 0.0946597f, 0.0824881f, 0.0732495f, 0.0640108f, 0.0556904f, 0.0473701f, 0.039668f, 0.031966f, 0.0273263f, 0.0226867f, 0.0196283f, 0.0165699f, 0.0155271f, 0.0144843f, 0.0146602f, 0.0148362f, 0.0155289f, 0.0162216f, 0.0174317f, 0.0186418f, 0.0192574f, 0.019873f, 0.0193336f, 0.0187943f, 0.0169768f, 0.0151594f, 0.0138395f, 0.0125197f, 0.0122022f, 0.0118846f, 0.0113754f, 0.0108661f, 0.0122059f, 0.0135457f, 0.0150274f, 0.0165092f, 0.0174059f, 0.0183026f, 0.0170915f, 0.0158804f, 0.0135402f, 0.0112001f, 0.00877389f, 0.00634772f, 0.00592819f, 0.00550866f, 0.00444963f, 0.0033906f, 0.00363493f, 0.00387926f, 0.00369547f, 0.00351167f, 0.00323999f, 0.0029683f, 0.00304107f, 0.00311383f, 0.00269225f, 0.00227067f, 0.00285765f, 0.00344463f, 0.0035057f, 0.00356676f, 0.00444226f, 0.00531776f, 0.00591164f, 0.00650553f, 0.00683137f, 0.00715721f, 0.00801677f, 0.00887633f, 0.00920412f, 0.0095319f, 0.00876825f, 0.00800459f, 0.00751842f, 0.00703224f, 0.00673578f, 0.00643931f, 0.00627542f, 0.00611152f, 0.00586377f, 0.00561602f, 0.00543874f, 0.00526147f, 0.0057041f, 0.00614673f, 0.00676773f, 0.00738874f, 0.00702707f, 0.00666541f, 0.0066904f, 0.0067154f, 0.00807246f, 0.00942952f, 0.0111187f, 0.0128079f, 0.0135393f, 0.0142706f, 0.015097f, 0.0159234f, 0.0165052f, 0.017087f, 0.0171597f, 0.0172324f, 0.0167555f, 0.0162786f, 0.0157604f, 0.0152423f, 0.0143205f, 0.0133987f, 0.0126828f, 0.0119669f, 0.0112674f, 0.0105679f, 0.0102702f, 0.00997248f, 0.00958224f, 0.009192f, 0.00947248f, 0.00975296f, 0.00932626f, 0.00889956f, 0.00866396f, 0.00842837f, 0.0081121f, 0.00779583f, 0.00765918f, 0.00752253f, 0.00724579f, 0.00696906f, 0.0064155f, 0.00586195f, 0.00563761f, 0.00541328f, 0.00499098f, 0.00456868f, 0.00425882f, 0.00394895f, 0.00377609f, 0.00360322f, 0.00343181f, 0.00326041f, 0.00310311f, 0.00294581f, 0.00285307f, 0.00276034f, 0.00277242f, 0.0027845f, 0.00250953f, 0.00223456f, 0.00235165f, 0.00246875f, 0.00235075f, 0.00223275f, 0.00238435f, 0.00253594f, 0.00230124f, 0.00206653f, 0.00190024f, 0.00173395f, 0.00191697f, 0.00209999f, 0.00206986f, 0.00203973f, 0.002129f, 0.00221828f, 0.00179734f, 0.00137641f, 0.00148945f, 0.0f }; for (unsigned int j = 0; j < 275; ++j) { b0[j] = tmp[j]; } } else if (bandName[i].find("Red") != std::string::npos) { const float tmp[275] = { 0.0f, 0.000251974f, 0.000503948f, 0.000447294f, 0.000390639f, 0.000493587f, 0.000596534f, 0.000462484f, 0.000328434f, 0.000587581f, 0.000846728f, 0.000748537f, 0.000650345f, 0.000516444f, 0.000382543f, 0.000939994f, 0.00149745f, 0.00175874f, 0.00202003f, 0.00252033f, 0.00302063f, 0.00326826f, 0.00351589f, 0.00376182f, 0.00400775f, 0.00406784f, 0.00412793f, 0.00595608f, 0.00778423f, 0.0080879f, 0.00839158f, 0.00829197f, 0.00819236f, 0.00662469f, 0.00505701f, 0.00383289f, 0.00260876f, 0.00345153f, 0.00429429f, 0.00487448f, 0.00545468f, 0.00545833f, 0.00546199f, 0.00418794f, 0.00291388f, 0.00230581f, 0.00169773f, 0.00162001f, 0.0015423f, 0.00259185f, 0.00364139f, 0.00396142f, 0.00428144f, 0.00339831f, 0.00251517f, 0.00227348f, 0.00203179f, 0.00167973f, 0.00132766f, 0.00141316f, 0.00149866f, 0.00150402f, 0.00150938f, 0.0018186f, 0.00212782f, 0.00224531f, 0.0023628f, 0.0025393f, 0.0027158f, 0.00304882f, 0.00338183f, 0.00312524f, 0.00286866f, 0.00286392f, 0.00285919f, 0.00345904f, 0.0040589f, 0.00503972f, 0.00602055f, 0.00659323f, 0.00716591f, 0.00825183f, 0.00933776f, 0.00929585f, 0.00925395f, 0.00899875f, 0.00874355f, 0.00912988f, 0.0095162f, 0.00993024f, 0.0103443f, 0.0118352f, 0.0133262f, 0.0168796f, 0.020433f, 0.0244432f, 0.0284535f, 0.0315921f, 0.0347306f, 0.0387702f, 0.0428098f, 0.0501643f, 0.0575189f, 0.0714861f, 0.0854534f, 0.105156f, 0.124858f, 0.150634f, 0.17641f, 0.217427f, 0.258444f, 0.338645f, 0.418847f, 0.528481f, 0.638116f, 0.721314f, 0.804512f, 0.841436f, 0.87836f, 0.898975f, 0.91959f, 0.936413f, 0.953235f, 0.954545f, 0.955856f, 0.942354f, 0.928852f, 0.933873f, 0.938894f, 0.962762f, 0.98663f, 0.991712f, 0.996794f, 0.952358f, 0.907922f, 0.838837f, 0.769753f, 0.68084f, 0.591927f, 0.506722f, 0.421517f, 0.363416f, 0.305314f, 0.265769f, 0.226224f, 0.192279f, 0.158334f, 0.131456f, 0.104578f, 0.0859652f, 0.067352f, 0.0560433f, 0.0447347f, 0.0373336f, 0.0299325f, 0.0269409f, 0.0239493f, 0.0229628f, 0.0219762f, 0.0201699f, 0.0183636f, 0.0171332f, 0.0159029f, 0.0160653f, 0.0162278f, 0.0159488f, 0.0156697f, 0.0160819f, 0.0164941f, 0.0168042f, 0.0171144f, 0.0167051f, 0.0162959f, 0.0141966f, 0.0120973f, 0.0105832f, 0.00906906f, 0.00792008f, 0.0067711f, 0.00649551f, 0.00621991f, 0.00588748f, 0.00555504f, 0.00486398f, 0.00417292f, 0.00419873f, 0.00422454f, 0.00461445f, 0.00500436f, 0.00449582f, 0.00398727f, 0.00397629f, 0.00396531f, 0.00332414f, 0.00268297f, 0.00284406f, 0.00300515f, 0.00277493f, 0.00254471f, 0.00290075f, 0.00325678f, 0.00290726f, 0.00255773f, 0.00259229f, 0.00262684f, 0.00269255f, 0.00275825f, 0.00271562f, 0.00267299f, 0.00275871f, 0.00284443f, 0.00269768f, 0.00255094f, 0.00257098f, 0.00259103f, 0.00253264f, 0.00247425f, 0.00242522f, 0.00237619f, 0.00235338f, 0.00233057f, 0.00261103f, 0.00289149f, 0.0028024f, 0.00271332f, 0.00290319f, 0.00309306f, 0.00350249f, 0.00391192f, 0.00395984f, 0.00400776f, 0.00401089f, 0.00401403f, 0.0037349f, 0.00345576f, 0.00305136f, 0.00264696f, 0.00241812f, 0.00218929f, 0.00191393f, 0.00163858f, 0.00153304f, 0.00142751f, 0.00137032f, 0.00131312f, 0.00134518f, 0.00137723f, 0.0012429f, 0.00110858f, 0.00114136f, 0.00117415f, 0.00116687f, 0.00115959f, 0.00108165f, 0.00100371f, 0.00131319f, 0.00162267f, 0.00130164f, 0.000980609f, 0.00115412f, 0.00132762f, 0.0013807f, 0.00143378f, 0.00218704f, 0.00294031f, 0.00234605f, 0.00175179f, 0.0020462f, 0.0023406f, 0.00180012f, 0.00125963f, 0.00107872f, 0.000897814f, 0.000448907f, 0.0f }; for (unsigned int j = 0; j < 275; ++j) { b0[j] = tmp[j]; } } else if (bandName[i].find("NIR") != std::string::npos) { const float tmp[275] = { 0.000894394f, 0.000713315f, 0.000532235f, 0.000603058f, 0.000673881f, 0.000760361f, 0.00084684f, 0.000787802f, 0.000728763f, 0.000817305f, 0.000905846f, 0.000904774f, 0.000903701f, 0.00160409f, 0.00230447f, 0.00221407f, 0.00212367f, 0.00314219f, 0.00416071f, 0.00470014f, 0.00523956f, 0.00641267f, 0.00758578f, 0.0090575f, 0.0105292f, 0.0156041f, 0.0206791f, 0.027643f, 0.0346069f, 0.0395911f, 0.0445753f, 0.0408266f, 0.0370779f, 0.0276002f, 0.0181225f, 0.017135f, 0.0161476f, 0.0168906f, 0.0176337f, 0.0172355f, 0.0168373f, 0.0168014f, 0.0167656f, 0.0178122f, 0.0188588f, 0.0165949f, 0.0143311f, 0.0120729f, 0.0098147f, 0.0125599f, 0.0153051f, 0.0187014f, 0.0220978f, 0.0244686f, 0.0268393f, 0.0270579f, 0.0272765f, 0.0223541f, 0.0174318f, 0.0124528f, 0.00747381f, 0.00633578f, 0.00519774f, 0.00546479f, 0.00573183f, 0.00496663f, 0.00420143f, 0.00375248f, 0.00330354f, 0.00289353f, 0.00248353f, 0.00252329f, 0.00256304f, 0.00431351f, 0.00606397f, 0.00864978f, 0.0112356f, 0.0122617f, 0.0132878f, 0.0113116f, 0.00933533f, 0.00834238f, 0.00734942f, 0.00698854f, 0.00662766f, 0.00662135f, 0.00661504f, 0.00802641f, 0.00943779f, 0.0113662f, 0.0132947f, 0.0126595f, 0.0120243f, 0.00943568f, 0.0068471f, 0.00523536f, 0.00362362f, 0.00341318f, 0.00320274f, 0.00318157f, 0.00316041f, 0.00303014f, 0.00289988f, 0.00349364f, 0.0040874f, 0.00427183f, 0.00445627f, 0.00425418f, 0.0040521f, 0.00432398f, 0.00459586f, 0.00500329f, 0.00541072f, 0.0052616f, 0.00511248f, 0.00619044f, 0.0072684f, 0.007209f, 0.0071496f, 0.00780861f, 0.00846762f, 0.0103595f, 0.0122514f, 0.014548f, 0.0168445f, 0.0180774f, 0.0193103f, 0.0203458f, 0.0213814f, 0.021739f, 0.0220966f, 0.0227061f, 0.0233155f, 0.0241796f, 0.0250438f, 0.0249493f, 0.0248548f, 0.0257403f, 0.0266259f, 0.0274829f, 0.0283399f, 0.0315445f, 0.034749f, 0.0392491f, 0.0437491f, 0.0488567f, 0.0539644f, 0.0651598f, 0.0763552f, 0.0905082f, 0.104661f, 0.125801f, 0.146941f, 0.17194f, 0.196939f, 0.22805f, 0.25916f, 0.283963f, 0.308767f, 0.332943f, 0.357119f, 0.400422f, 0.443726f, 0.504385f, 0.565045f, 0.633202f, 0.701359f, 0.76896f, 0.83656f, 0.889646f, 0.942732f, 0.971366f, 1.0f, 0.997999f, 0.995998f, 0.963345f, 0.930691f, 0.881401f, 0.832111f, 0.811504f, 0.790896f, 0.782153f, 0.773411f, 0.768032f, 0.762653f, 0.735848f, 0.709043f, 0.707354f, 0.705666f, 0.697871f, 0.690076f, 0.672979f, 0.655882f, 0.638978f, 0.622073f, 0.601538f, 0.581002f, 0.557459f, 0.533915f, 0.524241f, 0.514567f, 0.501153f, 0.487739f, 0.452918f, 0.418097f, 0.370059f, 0.32202f, 0.285355f, 0.248689f, 0.209974f, 0.171259f, 0.142537f, 0.113816f, 0.092517f, 0.0712178f, 0.0646218f, 0.0580258f, 0.050796f, 0.0435662f, 0.0353664f, 0.0271667f, 0.0232974f, 0.0194282f, 0.0176517f, 0.0158752f, 0.0144977f, 0.0131202f, 0.0118952f, 0.0106703f, 0.0101536f, 0.00963684f, 0.00921561f, 0.00879438f, 0.00794162f, 0.00708886f, 0.00654941f, 0.00600996f, 0.00563429f, 0.00525862f, 0.00510421f, 0.00494981f, 0.00454041f, 0.00413101f, 0.00410078f, 0.00407056f, 0.00396389f, 0.00385722f, 0.00364911f, 0.00344101f, 0.00333006f, 0.00321911f, 0.00300415f, 0.00278918f, 0.00317632f, 0.00356346f, 0.00312642f, 0.00268937f, 0.00260112f, 0.00251287f, 0.00263123f, 0.00274958f, 0.00362147f, 0.00449336f, 0.00413978f, 0.0037862f, 0.0028968f, 0.0020074f, 0.00190022f, 0.00179303f, 0.00227357f, 0.0027541f, 0.00137705f, 0.0f, 0.0f, 0.0f }; for (unsigned int j = 0; j < 275; ++j) { b0[j] = tmp[j]; } } else { itkExceptionMacro(<< "Invalid band name..."); } //create wavelength band vector const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); wavelengthSpectralBand->GetNthElement(i)->SetFilterFunctionValues(vb0); wavelengthSpectralBand->GetNthElement(i)->SetMinSpectralValue(0.350); wavelengthSpectralBand->GetNthElement(i)->SetMaxSpectralValue(1.035); wavelengthSpectralBand->GetNthElement(i)->SetUserStep(0.0025); } return wavelengthSpectralBand; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbIkonosImageMetadataInterfaceFactory.cxx000066400000000000000000000032231301006202600304750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbIkonosImageMetadataInterfaceFactory.h" #include "otbIkonosImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { /************************************************* ******* IkonosImageMetadataInterfaceFactory ****** **************************************************/ IkonosImageMetadataInterfaceFactory ::IkonosImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbIkonosImageMetadataInterface", "Ikonos Metadata Interface", 1, itk::CreateObjectFunction::New()); } IkonosImageMetadataInterfaceFactory ::~IkonosImageMetadataInterfaceFactory() { } const char* IkonosImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* IkonosImageMetadataInterfaceFactory::GetDescription() const { return "Ikonos Metadata Interface Factory, handle Ikonos metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbImageMetadataInterfaceBase.cxx000066400000000000000000000425521301006202600265650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageMetadataInterfaceBase.h" #include "otbNoDataHelper.h" #include "itkMetaDataObject.h" #include "itksys/SystemTools.hxx" namespace otb { ImageMetadataInterfaceBase ::ImageMetadataInterfaceBase() { } std::string ImageMetadataInterfaceBase::GetProjectionRef() const { std::string metadata; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::ProjectionRefKey)) { itk::ExposeMetaData(dict, static_cast(MetaDataKey::ProjectionRefKey), metadata); return (metadata); } else return (""); } std::string ImageMetadataInterfaceBase::GetGCPProjection() const { std::string metadata; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::GCPProjectionKey)) { itk::ExposeMetaData(dict, static_cast(MetaDataKey::GCPProjectionKey), metadata); return (metadata); } else return (""); } unsigned int ImageMetadataInterfaceBase::GetGCPCount() const { unsigned int GCPCount = 0; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::GCPCountKey)) { itk::ExposeMetaData(dict, MetaDataKey::GCPCountKey, GCPCount); } return (GCPCount); } OTB_GCP& ImageMetadataInterfaceBase::GetGCPs(unsigned int GCPnum) { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { itk::ExposeMetaData(dict, key, m_GCP); } return (m_GCP); } std::string ImageMetadataInterfaceBase::GetGCPId(unsigned int GCPnum) const { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); return (gcp.m_Id); } else return (""); } std::string ImageMetadataInterfaceBase::GetGCPInfo(unsigned int GCPnum) const { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); return (gcp.m_Info); } else return (""); } double ImageMetadataInterfaceBase::GetGCPRow(unsigned int GCPnum) const { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); return (gcp.m_GCPRow); } else return (0); } double ImageMetadataInterfaceBase::GetGCPCol(unsigned int GCPnum) const { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); return (gcp.m_GCPCol); } else return (0); } double ImageMetadataInterfaceBase::GetGCPX(unsigned int GCPnum) const { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); return (gcp.m_GCPX); } else return (0); } double ImageMetadataInterfaceBase::GetGCPY(unsigned int GCPnum) const { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); return (gcp.m_GCPY); } else return (0); } double ImageMetadataInterfaceBase::GetGCPZ(unsigned int GCPnum) const { std::string key; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << GCPnum; key = lStream.str(); if (dict.HasKey(key)) { OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); return (gcp.m_GCPZ); } else return (0); } bool ImageMetadataInterfaceBase::GetNoDataFlags(std::vector & flags, std::vector & values) const { return ReadNoDataFlags(this->GetMetaDataDictionary(),flags,values); } ImageMetadataInterfaceBase::VectorType ImageMetadataInterfaceBase::GetGeoTransform() const { VectorType adfGeoTransform; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::GeoTransformKey)) { itk::ExposeMetaData(dict, MetaDataKey::GeoTransformKey, adfGeoTransform); } return (adfGeoTransform); } ImageMetadataInterfaceBase::VectorType ImageMetadataInterfaceBase::GetUpperLeftCorner() const { VectorType UpperLeftCorner; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::UpperLeftCornerKey)) { itk::ExposeMetaData(dict, MetaDataKey::UpperLeftCornerKey, UpperLeftCorner); } return (UpperLeftCorner); } ImageMetadataInterfaceBase::VectorType ImageMetadataInterfaceBase::GetUpperRightCorner() const { VectorType UpperRightCorner; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::UpperRightCornerKey)) { itk::ExposeMetaData(dict, MetaDataKey::UpperRightCornerKey, UpperRightCorner); } return (UpperRightCorner); } ImageMetadataInterfaceBase::VectorType ImageMetadataInterfaceBase::GetLowerLeftCorner() const { VectorType LowerLeftCorner; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::LowerLeftCornerKey)) { itk::ExposeMetaData(dict, MetaDataKey::LowerLeftCornerKey, LowerLeftCorner); } return (LowerLeftCorner); } ImageMetadataInterfaceBase::VectorType ImageMetadataInterfaceBase::GetLowerRightCorner() const { VectorType LowerRightCorner; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::LowerRightCornerKey)) { itk::ExposeMetaData(dict, MetaDataKey::LowerRightCornerKey, LowerRightCorner); } return (LowerRightCorner); } ImageMetadataInterfaceBase::ImageKeywordlistType ImageMetadataInterfaceBase::GetImageKeywordlist() { ImageKeywordlistType imageKeywordlist; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } return (imageKeywordlist); } const ImageMetadataInterfaceBase::ImageKeywordlistType ImageMetadataInterfaceBase::GetImageKeywordlist() const { ImageKeywordlistType imageKeywordlist; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } return (imageKeywordlist); } std::string const ImageMetadataInterfaceBase::GetSensorID() const { std::string s; GetSensorID( s ); return s; } bool ImageMetadataInterfaceBase::GetSensorID(std::string & sensorId) const { ImageKeywordlistType imageKeywordlist; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if ( dict.HasKey(MetaDataKey::OSSIMKeywordlistKey) ) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if ( !imageKeywordlist.HasKey("sensor") ) { return false; } sensorId = imageKeywordlist.GetMetadataByKey("sensor"); return true; } unsigned int ImageMetadataInterfaceBase::GetNumberOfBands() const { ImageKeywordlistType imageKeywordlist; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.number_bands")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.number_bands"); unsigned int value = atoi(valueString.c_str()); return value; } std::vector ImageMetadataInterfaceBase::GetBandName() const { ImageKeywordlistType imageKeywordlist; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } /* band_name attribut is only used by OSSIM metadata reader otherwise it is band_name_list */ std::vector outputValues; if (!imageKeywordlist.HasKey("support_data.band_name")) { if (imageKeywordlist.HasKey("support_data.band_name_list")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.band_name_list"); itksys::SystemTools::Split(valueString.c_str(), outputValues, ' '); } else return outputValues; } else { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.band_name"); itksys::SystemTools::Split(valueString.c_str(), outputValues, '/'); } return outputValues; } double ImageMetadataInterfaceBase::GetXPixelSpacing() const { ImageKeywordlistType imageKeywordlist; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("meters_per_pixel_x")) { std::string valueString = imageKeywordlist.GetMetadataByKey("meters_per_pixel_x"); double value = atof(valueString.c_str()); return value; } if (imageKeywordlist.HasKey("pixel_spacing")) { std::string valueString = imageKeywordlist.GetMetadataByKey("pixel_spacing"); double value = atof(valueString.c_str()); return value; } return 0; } double ImageMetadataInterfaceBase::GetYPixelSpacing() const { ImageKeywordlistType imageKeywordlist; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("meters_per_pixel_y")) { std::string valueString = imageKeywordlist.GetMetadataByKey("meters_per_pixel_y"); double value = atof(valueString.c_str()); return value; } if (imageKeywordlist.HasKey("pixel_spacing")) { std::string valueString = imageKeywordlist.GetMetadataByKey("pixel_spacing"); double value = atof(valueString.c_str()); return value; } return 0; } void ImageMetadataInterfaceBase::PrintMetadata(std::ostream& os, itk::Indent indent, const MetaDataDictionaryType& dict) { std::vector keys = dict.GetKeys(); // an extra dependency just for printing is a bad idea. // VectorDataKeywordlist vectorDataKeywordlistValue; unsigned int i(0); // Copy of the const metadata dictionary in a metadata dictionary to be used // by the ExposeMetaData method MetaDataDictionaryType dict2 = dict; for (unsigned int itkey = 0; itkey < keys.size(); ++itkey) { switch (MetaDataKey::GetKeyType(keys[itkey])) { case MetaDataKey::TSTRING: { std::string svalue; itk::ExposeMetaData(dict2, keys[itkey], svalue); os << indent << "---> " << keys[itkey] << " = " << svalue << std::endl; break; } case MetaDataKey::TENTIER: { unsigned int ivalue(0); itk::ExposeMetaData(dict2, keys[itkey], ivalue); os << indent << "---> " << keys[itkey] << " = " << ivalue << std::endl; break; } case MetaDataKey::TVECTOR: { VectorType vvalue; itk::ExposeMetaData(dict2, keys[itkey], vvalue); for (i = 0; i < vvalue.size(); ++i) { os << indent << "---> " << keys[itkey] << "[" << i << "] = " << vvalue[i] << std::endl; } vvalue.clear(); break; } case MetaDataKey::TDOUBLE: { double dvalue(0.0); itk::ExposeMetaData(dict2, keys[itkey], dvalue); os << indent << "---> " << keys[itkey] << " = " << dvalue << std::endl; break; } case MetaDataKey::TOTB_GCP: { OTB_GCP gcpvalue; itk::ExposeMetaData(dict2, keys[itkey], gcpvalue); os << indent << "---> " << keys[itkey] << std::endl; gcpvalue.Print(os); break; } case MetaDataKey::TOSSIMKEYWORDLIST: { ImageKeywordlist kwl; itk::ExposeMetaData(dict2, keys[itkey], kwl); os << indent << "---> " << keys[itkey] << std::endl; kwl.Print(os); break; } // case MetaDataKey::TVECTORDATAKEYWORDLIST: // itk::ExposeMetaData(dict2, keys[itkey], vectorDataKeywordlistValue); // // os << indent << "---> " << keys[itkey] << std::endl; // vectorDataKeywordlistValue.Print(os); // break; default: break; } } } void ImageMetadataInterfaceBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); bool canRead = this->CanRead(); os << indent << "Initialized: " << (canRead ? true : false) << std::endl; if (canRead) { std::vector defaultDisplay = this->GetDefaultDisplay(); os << indent << "Default RGB Display: [" << defaultDisplay[0] << ", " << defaultDisplay[1] << ", " << defaultDisplay[2] << "]" << std::endl; os << indent << "ProjectionRef: " << this->GetProjectionRef() << std::endl; os << indent << "GCPProjection: " << this->GetGCPProjection( ) << std::endl; os << indent << "GCPCount: " << this->GetGCPCount( ) << std::endl; for(unsigned int gcpIdx = 0; gcpIdx < this->GetGCPCount(); ++ gcpIdx) { //os << indent << "GCPs: " << this->GetGCPs(gcpIdx) << std::endl; os << indent << "GCPId: " << this->GetGCPId(gcpIdx) << std::endl; os << indent << "GCPInfo: " << this->GetGCPInfo(gcpIdx) << std::endl; } //os << indent << "GeoTransform: " << this->GetGeoTransform( ) << std::endl; //os << indent << "UpperLeftCorner: " << this->GetUpperLeftCorner( ) << std::endl; //os << indent << "UpperRightCorner:" << this->GetUpperRightCorner( ) << std::endl; //os << indent << "LowerLeftCorner: " << this->GetLowerLeftCorner( ) << std::endl; //os << indent << "LowerRightCorner:" << this->GetLowerRightCorner( ) << std::endl; //os << indent << "ImageKeywordlist:" << this->GetImageKeywordlist( ) << std::endl; std::string sensorId; this->GetSensorID( sensorId ); os << indent << "SensorID: " << sensorId << std::endl; os << indent << "NumberOfBands: " << this->GetNumberOfBands( ) << std::endl; std::vector bandNameList = this->GetBandName(); if (bandNameList.size() == 1) { os << indent << "BandName: " << bandNameList[0] << std::endl; } else if (bandNameList.size() > 1) { os << indent << "BandNameList: "; for (std::vector::iterator it = bandNameList.begin(); it != bandNameList.end(); ++it) { os << *it << ", "; } os << std::endl; } os << indent << "XPixelSpacing: " << this->GetXPixelSpacing( ) << std::endl; os << indent << "YPixelSpacing: " << this->GetYPixelSpacing( ) << std::endl; os << indent << "Day: " << this->GetDay( ) << std::endl; os << indent << "Month: " << this->GetMonth( ) << std::endl; os << indent << "Year: " << this->GetYear( ) << std::endl; os << indent << "Hour: " << this->GetHour( ) << std::endl; os << indent << "Minute: " << this->GetMinute( ) << std::endl; os << indent << "ProductionDay: " << this->GetProductionDay( ) << std::endl; os << indent << "ProductionMonth: " << this->GetProductionMonth( ) << std::endl; os << indent << "ProductionYear: " << this->GetProductionYear( ) << std::endl; } } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbImageMetadataInterfaceFactory.cxx000066400000000000000000000105561301006202600273210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageMetadataInterfaceFactory.h" #include "otbDefaultImageMetadataInterface.h" // Optical sensors #include "otbIkonosImageMetadataInterfaceFactory.h" #include "otbSpotImageMetadataInterfaceFactory.h" #include "otbPleiadesImageMetadataInterfaceFactory.h" #include "otbSpot6ImageMetadataInterfaceFactory.h" #include "otbFormosatImageMetadataInterfaceFactory.h" #include "otbQuickBirdImageMetadataInterfaceFactory.h" #include "otbWorldView2ImageMetadataInterfaceFactory.h" // SAR Sensors #include "otbTerraSarImageMetadataInterfaceFactory.h" #include "otbSentinel1ImageMetadataInterfaceFactory.h" #include "otbRadarsat2ImageMetadataInterfaceFactory.h" #include "itkMutexLock.h" #include "itkMutexLockHolder.h" #include #include #include namespace otb { ImageMetadataInterfaceFactory::ImageMetadataInterfaceBasePointerType ImageMetadataInterfaceFactory ::CreateIMI(const MetaDataDictionaryType& dict) { RegisterBuiltInFactories(); std::list possibleIMI; std::list allOpticalObjects = itk::ObjectFactoryBase::CreateAllInstance("OpticalImageMetadataInterface"); std::list allSarObjects = itk::ObjectFactoryBase::CreateAllInstance("SarImageMetadataInterface"); std::list allObjects; std::copy(allOpticalObjects.begin(), allOpticalObjects.end(), std::back_inserter(allObjects) ); std::copy(allSarObjects.begin(), allSarObjects.end(), std::back_inserter(allObjects) ); for (std::list::iterator i = allObjects.begin(); i != allObjects.end(); ++i) { ImageMetadataInterfaceBase * io = dynamic_cast(i->GetPointer()); if (io) { possibleIMI.push_back(io); } else { itkGenericExceptionMacro(<< "Error ImageMetadataInterface factory did not return an ImageMetadataInterfaceBase: " << (*i)->GetNameOfClass()); } } for (std::list::iterator k = possibleIMI.begin(); k != possibleIMI.end(); ++k) { (*k)->SetMetaDataDictionary(dict); if ((*k)->CanRead()) { return *k; } } DefaultImageMetadataInterface::Pointer defaultIMI = DefaultImageMetadataInterface::New(); defaultIMI->SetMetaDataDictionary(dict); return dynamic_cast(static_cast(defaultIMI)); } void ImageMetadataInterfaceFactory ::RegisterBuiltInFactories() { static bool firstTime = true; static itk::SimpleMutexLock mutex; { // This helper class makes sure the Mutex is unlocked // in the event an exception is thrown. itk::MutexLockHolder mutexHolder(mutex); if (firstTime) { itk::ObjectFactoryBase::RegisterFactory(IkonosImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(SpotImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(PleiadesImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(Spot6ImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(FormosatImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(QuickBirdImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(WorldView2ImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(TerraSarImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(Sentinel1ImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(Radarsat2ImageMetadataInterfaceFactory::New()); firstTime = false; } } } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbNoDataHelper.cxx000066400000000000000000000025421301006202600237670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbNoDataHelper.h" #include "itkMetaDataDictionary.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" namespace otb { bool ReadNoDataFlags(const itk::MetaDataDictionary& dict, std::vector & flags, std::vector & values) { bool ret = itk::ExposeMetaData >(dict,MetaDataKey::NoDataValueAvailable,flags); if (ret) ret = itk::ExposeMetaData >(dict,MetaDataKey::NoDataValue,values); return ret; } void WriteNoDataFlags(const std::vector & flags, const std::vector & values, itk::MetaDataDictionary& dict) { itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,flags); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,values); } } // End namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbOpticalDefaultImageMetadataInterfaceFactory.cxx000066400000000000000000000030651301006202600321370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOpticalDefaultImageMetadataInterfaceFactory.h" #include "otbOpticalDefaultImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { OpticalDefaultImageMetadataInterfaceFactory ::OpticalDefaultImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbOpticalDefaultImageMetadataInterface", "Default Metadata Interface", 1, itk::CreateObjectFunction::New()); } OpticalDefaultImageMetadataInterfaceFactory ::~OpticalDefaultImageMetadataInterfaceFactory() { } const char* OpticalDefaultImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* OpticalDefaultImageMetadataInterfaceFactory::GetDescription() const { return "Optical Default Metadata Interface Factory, handle Default Optical metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbOpticalImageMetadataInterface.cxx000066400000000000000000000057421301006202600273060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOpticalImageMetadataInterface.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" namespace otb { OpticalImageMetadataInterface ::OpticalImageMetadataInterface() { } double OpticalImageMetadataInterface::GetSunElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.elevation_angle")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.elevation_angle"); double value = atof(valueString.c_str()); return value; } return 0; } double OpticalImageMetadataInterface::GetSunAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.azimuth_angle")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.azimuth_angle"); double value = atof(valueString.c_str()); return value; } return 0; } unsigned int OpticalImageMetadataInterface::BandIndexToWavelengthPosition(unsigned int i) const { return i; } void OpticalImageMetadataInterface ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); if (this->CanRead()) { os << indent << "GetSunElevation: " << this->GetSunElevation() << std::endl; os << indent << "GetSunAzimuth: " << this->GetSunAzimuth() << std::endl; os << indent << "GetSatElevation: " << this->GetSatElevation() << std::endl; os << indent << "GetSatAzimuth: " << this->GetSatAzimuth() << std::endl; os << indent << "GetPhysicalBias: " << this->GetPhysicalBias() << std::endl; os << indent << "GetPhysicalGain: " << this->GetPhysicalGain() << std::endl; os << indent << "GetSolarIrradiance: " << this->GetSolarIrradiance() << std::endl; os << indent << "GetFirstWavelengths: " << this->GetFirstWavelengths() << std::endl; os << indent << "GetLastWavelengths: " << this->GetLastWavelengths() << std::endl; } } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbOpticalImageMetadataInterfaceFactory.cxx000066400000000000000000000067701301006202600306400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOpticalImageMetadataInterfaceFactory.h" #include "otbOpticalDefaultImageMetadataInterface.h" // Optical sensors #include "otbIkonosImageMetadataInterfaceFactory.h" #include "otbSpotImageMetadataInterfaceFactory.h" #include "otbFormosatImageMetadataInterfaceFactory.h" #include "otbQuickBirdImageMetadataInterfaceFactory.h" #include "otbWorldView2ImageMetadataInterfaceFactory.h" #include "otbPleiadesImageMetadataInterfaceFactory.h" #include "otbSpot6ImageMetadataInterfaceFactory.h" #include "itkMutexLock.h" #include "itkMutexLockHolder.h" namespace otb { OpticalImageMetadataInterfaceFactory::OpticalImageMetadataInterfacePointerType OpticalImageMetadataInterfaceFactory ::CreateIMI(const MetaDataDictionaryType& dict) { RegisterBuiltInFactories(); std::list possibleIMI; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("OpticalImageMetadataInterface"); for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { OpticalImageMetadataInterface * io = dynamic_cast(i->GetPointer()); if (io) { possibleIMI.push_back(io); } else { itkGenericExceptionMacro(<< "Error OpticalImageMetadataInterface factory did not return an OpticalImageMetadataInterface: " << (*i)->GetNameOfClass()); } } for (std::list::iterator k = possibleIMI.begin(); k != possibleIMI.end(); ++k) { (*k)->SetMetaDataDictionary(dict); if ((*k)->CanRead()) { return *k; } } OpticalDefaultImageMetadataInterface::Pointer defaultIMI = OpticalDefaultImageMetadataInterface::New(); return dynamic_cast(static_cast(defaultIMI)); } void OpticalImageMetadataInterfaceFactory ::RegisterBuiltInFactories() { static bool firstTime = true; static itk::SimpleMutexLock mutex; { // This helper class makes sure the Mutex is unlocked // in the event an exception is thrown. itk::MutexLockHolder mutexHolder(mutex); if (firstTime) { itk::ObjectFactoryBase::RegisterFactory(IkonosImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(SpotImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(FormosatImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(QuickBirdImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(WorldView2ImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(PleiadesImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(Spot6ImageMetadataInterfaceFactory::New()); firstTime = false; } } } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbPleiadesImageMetadataInterface.cxx000066400000000000000000002113771301006202600274440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPleiadesImageMetadataInterface.h" #include "otbMacro.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" #include "otbStringUtils.h" //useful constants #include namespace otb { using boost::lexical_cast; using boost::bad_lexical_cast; PleiadesImageMetadataInterface ::PleiadesImageMetadataInterface() { } bool PleiadesImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("PHR") != std::string::npos) return true; else return false; } std::string PleiadesImageMetadataInterface::GetInstrument() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument"); return valueString; } return ""; } std::string PleiadesImageMetadataInterface::GetInstrumentIndex() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument_index")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument_index"); return valueString; } return ""; // Invalid value } PleiadesImageMetadataInterface::VariableLengthVectorType PleiadesImageMetadataInterface::GetSolarIrradiance() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.solar_irradiance")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.solar_irradiance"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); // Check that values read from metadata is not too far from the standard realistic values // '999' are likely to be dummy values (see Mantis #601) // This values were provided by the French Space Agency double defaultRadianceMS[4]; double defaultRadianceP; const std::string sensorId = this->GetSensorID(); if (sensorId == "PHR 1A") { // MS, ordered as B0, B1, B2, B3 defaultRadianceMS[0] = 1915.01; defaultRadianceMS[1] = 1830.57; defaultRadianceMS[2] = 1594.06; defaultRadianceMS[3] = 1060.01; defaultRadianceP = 1548.71; } else if (sensorId == "PHR 1B") { // MS, ordered as B0, B1, B2, B3 defaultRadianceMS[0] = 1926.51688; defaultRadianceMS[1] = 1805.91412; defaultRadianceMS[2] = 1533.60973; defaultRadianceMS[3] = 1019.23037; defaultRadianceP = 1529.00384; } else { itkExceptionMacro(<< "Invalid sensor ID."); } // tolerance threshold double tolerance = 0.05; if (outputValues.size() == 1) { // Pan if (vcl_abs(outputValues[0] - defaultRadianceP) > (tolerance * defaultRadianceP)) { outputValuesVariableLengthVector[0] = defaultRadianceP; } else { outputValuesVariableLengthVector[0] = outputValues[0]; } } else { // MS for (unsigned int i = 0; i < outputValues.size(); ++i) { int wavelenghPos = this->BandIndexToWavelengthPosition(i); if (vcl_abs(outputValues[wavelenghPos] - defaultRadianceMS[wavelenghPos]) > (tolerance * defaultRadianceMS[wavelenghPos])) { outputValuesVariableLengthVector[i] = defaultRadianceMS[wavelenghPos]; } else { outputValuesVariableLengthVector[i] = outputValues[wavelenghPos]; } } } return outputValuesVariableLengthVector; } int PleiadesImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[2]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Day"); } return value; } int PleiadesImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[1]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Month"); } return value; } int PleiadesImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[0]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Year"); } return value; } int PleiadesImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[3]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Hour"); } return value; } int PleiadesImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[4]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Minute"); } return value; } int PleiadesImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); int value; try { value = lexical_cast (outputValues[2]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Day"); } return value; } int PleiadesImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); int value; try { value = lexical_cast (outputValues[1]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Month"); } return value; } int PleiadesImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value; try { value = lexical_cast (outputValues[0]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Year"); } return value; } PleiadesImageMetadataInterface::VariableLengthVectorType PleiadesImageMetadataInterface ::GetPhysicalBias() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.physical_bias")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.physical_bias"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); // Use BandIndexToWavelengthPosition because values in keywordlist are sorted by wavelength for (unsigned int i = 0; i < outputValues.size(); ++i) { outputValuesVariableLengthVector[i] = outputValues[this->BandIndexToWavelengthPosition(i)]; } return outputValuesVariableLengthVector; } PleiadesImageMetadataInterface::VariableLengthVectorType PleiadesImageMetadataInterface ::GetPhysicalGain() const { //We use here tabulate in flight values for physical gain of PHR. Those values evolve //with time and are much more accurate. Values provided by CNES calibration //team. Diference between metadata values and in flight gain can lead to //difference of 10%. //Values: // Ak values for PHR1A are given in the following table : // Dates PA NTDI=13 B0 B1 B2 B3 // From 17/12/2011 to 01/08/2012 11.75 9.52 9.62 10.55 15.73 // From 01/08/2012 to 01/03/2013 11.73 9.45 9.48 10.51 15.71 // From 01/03/2013 11.70 9.38 9.34 10.46 15.69 // For PHR1B in the following table : // Dates PA NTDI=13 B0 B1 B2 B3 // From 01/12/2012 12.04 10.46 10.47 11.32 17.21 std::vector outputValues; const std::string sensorId = this->GetSensorID(); const int nbBands = this->GetNumberOfBands(); if (sensorId == "PHR 1A") { //PHR 1A if ( (this->GetYear() < 2012) || (this->GetYear() == 2012 && this->GetMonth() <8 ) ) { if (nbBands == 1) { outputValues.push_back(11.75); } else { outputValues.push_back(9.52); outputValues.push_back(9.62); outputValues.push_back(10.55); outputValues.push_back(15.73); } } else if ( (this->GetYear() == 2012 && this->GetMonth() >=8) || (this->GetYear() == 2013 && this->GetMonth() <3) ) { if (nbBands == 1) { outputValues.push_back(11.73); } else { outputValues.push_back(9.45); outputValues.push_back(9.48); outputValues.push_back(10.51); outputValues.push_back(15.71); } } else if ( (this->GetYear() == 2013 && this->GetMonth() >= 3) || this->GetYear() > 2013 ) { if (nbBands == 1) { outputValues.push_back(11.7); } else { outputValues.push_back(9.38); outputValues.push_back(9.34); outputValues.push_back(10.46); outputValues.push_back(15.69); } } else { itkExceptionMacro(<< "Invalid metadata, wrong acquisition date"); } } else if (sensorId == "PHR 1B") { //PHR 1B if ( this->GetYear() >= 2012 ) { if (nbBands == 1) { outputValues.push_back(12.04); } else { outputValues.push_back(10.46); outputValues.push_back(10.47); outputValues.push_back(11.32); outputValues.push_back(17.21); } } else { itkExceptionMacro(<< "Invalid metadata, wrong acquisition date"); } } else { itkExceptionMacro(<< "Invalid metadata, bad sensor id"); } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); // Use BandIndexToWavelengthPosition because values are tabulated and sorted by wavelength for (unsigned int i = 0; i < outputValues.size(); ++i) { outputValuesVariableLengthVector[i] = outputValues[this->BandIndexToWavelengthPosition(i)]; } otbMsgDevMacro( << "physical gain " << outputValuesVariableLengthVector); return outputValuesVariableLengthVector; } double PleiadesImageMetadataInterface::GetSatElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.incident_angle")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.incident_angle"); std::istringstream is(valueString); std::vector vecValues = std::vector(std::istream_iterator(is), std::istream_iterator()); //Take the second value (Center value) double value = vecValues[1]; //Convention use in input of atmospheric correction parameters computation is //"90 - satOrientation". Pleiades does not seem to follow this convention so //inverse the formula here to be able to take the angle read in the metadata //as input for 6S value = 90. - value; return value; } double PleiadesImageMetadataInterface::GetSatAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.scene_orientation")) { return 0; } else if (!imageKeywordlist.HasKey("support_data.along_track_incidence_angle") || !imageKeywordlist.HasKey("support_data.across_track_incidence_angle")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.scene_orientation"); std::istringstream is(valueString); std::vector vecCap = std::vector(std::istream_iterator(is), std::istream_iterator()); //Take the second value (Center value) double cap = vecCap[1]; //return only orientation if across/along track incidence are not available return cap; } else { //Got orientation and incidences angle which allow computing satellite // azimuthal angle // MSD: for the moment take only topCenter value std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.scene_orientation"); std::istringstream is(valueString); std::vector vecCap = std::vector(std::istream_iterator(is), std::istream_iterator()); //Take the second value (Center value) double cap = vecCap[1]; valueString = imageKeywordlist.GetMetadataByKey("support_data.along_track_incidence_angle"); std::istringstream isAlong(valueString); std::vector vecAlong = std::vector(std::istream_iterator(isAlong), std::istream_iterator()); //Take the second value (Center value) double along = vecAlong[1]; valueString = imageKeywordlist.GetMetadataByKey("support_data.across_track_incidence_angle"); std::istringstream isAcross(valueString); std::vector vecAcross = std::vector(std::istream_iterator(isAcross), std::istream_iterator()); //Take the second value (Center value) double ortho = vecAcross[1]; //Compute Satellite azimuthal angle using the azimuthal angle and the along //and across track incidence angle double satAz = (cap - vcl_atan2(vcl_tan(ortho * CONST_PI_180),vcl_tan(along * CONST_PI_180)) * CONST_180_PI); satAz = fmod(satAz,360); return satAz; } } PleiadesImageMetadataInterface::VariableLengthVectorType PleiadesImageMetadataInterface ::GetFirstWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); wavel.Fill(0.430); } else if (nbBands > 1 && nbBands < 5) { wavel.SetSize(4); wavel[0] = 0.430; wavel[1] = 0.430; wavel[2] = 0.430; wavel[3] = 0.430; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } PleiadesImageMetadataInterface::VariableLengthVectorType PleiadesImageMetadataInterface ::GetLastWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); wavel.Fill(0.95); } else if (nbBands > 1 && nbBands < 5) { wavel.SetSize(4); wavel[0] = 0.95; wavel[1] = 0.95; wavel[2] = 0.95; wavel[3] = 0.95; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } // TODO MSD need to update this function // Comment this part as relative response // FIXME check if this is coherent with other sensor unsigned int PleiadesImageMetadataInterface ::BandIndexToWavelengthPosition(unsigned int i) const { int nbBands = this->GetNumberOfBands(); //Panchromatic case if (nbBands == 1) { return 0; } else { otbMsgDevMacro(<< "Pleiades detected: first file component is red band and third component is blue one"); if (i == 0) return 2; if (i == 2) return 0; } return i; } std::vector PleiadesImageMetadataInterface ::GetEnhancedBandNames() const { std::vector enhBandNames; std::vector rawBandNames = this->Superclass::GetBandName(); if(rawBandNames.size()) { for (std::vector::iterator it = rawBandNames.begin(); it != rawBandNames.end(); ++it) { // Manage Panchro case if ( (rawBandNames.size() == 1) && !(*it).compare("P") ) { enhBandNames.push_back("PAN"); break; } else if ((rawBandNames.size() != 1) && !(*it).compare("P")) { /* Launch exception situation not valid*/ itkExceptionMacro(<< "Invalid Metadata, we cannot provide an consistent name to the band"); } // Manage MS case if ( !(*it).compare("B0") ) { enhBandNames.push_back("Blue"); } else if ( !(*it).compare("B1") ) { enhBandNames.push_back("Green"); } else if ( !(*it).compare("B2") ) { enhBandNames.push_back("Red"); } else if ( !(*it).compare("B3") ) { enhBandNames.push_back("NIR"); } else { enhBandNames.push_back("Unknown"); } } } return enhBandNames; } std::vector PleiadesImageMetadataInterface ::GetDefaultDisplay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector rgb(3); rgb[0] = 0; rgb[1] = 1; rgb[2] = 2; return rgb; } PleiadesImageMetadataInterface::WavelengthSpectralBandVectorType PleiadesImageMetadataInterface ::GetSpectralSensitivity() const { //TODO tabulate spectral responses WavelengthSpectralBandVectorType wavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); std::list > tmpSpectralBandList; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Pleiades Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } const int nbBands = this->GetNumberOfBands(); const std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { //if (sensorId.find("PHR") != std::string::npos) if (sensorId == "PHR 1A") { const float pan[209] = { 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0004358f, 0.0008051f, 0.0030464f, 0.0060688f, 0.0130170f, 0.0240166f, 0.0421673f, 0.0718226f, 0.1151660f, 0.1738520f, 0.2442960f, 0.3204090f, 0.3940400f, 0.4552560f, 0.5015220f, 0.5324310f, 0.5537040f, 0.5683830f, 0.5824280f, 0.5967100f, 0.6107110f, 0.6232080f, 0.6335930f, 0.6421600f, 0.6501020f, 0.6570500f, 0.6640260f, 0.6707420f, 0.6765340f, 0.6808170f, 0.6829760f, 0.6834310f, 0.6831800f, 0.6831390f, 0.6846760f, 0.6892820f, 0.6964400f, 0.7073100f, 0.7193370f, 0.7323050f, 0.7449550f, 0.7554270f, 0.7638770f, 0.7715940f, 0.7776340f, 0.7826480f, 0.7871060f, 0.7913600f, 0.7949010f, 0.7974290f, 0.7996850f, 0.8007000f, 0.8003370f, 0.8002560f, 0.8000160f, 0.8012780f, 0.8035920f, 0.8077100f, 0.8136680f, 0.8209800f, 0.8302930f, 0.8390660f, 0.8482460f, 0.8564130f, 0.8634600f, 0.8689680f, 0.8738000f, 0.8767770f, 0.8799960f, 0.8825630f, 0.8849870f, 0.8894330f, 0.8939110f, 0.8994160f, 0.9056300f, 0.9123790f, 0.9188800f, 0.9244770f, 0.9289540f, 0.9338010f, 0.9374110f, 0.9414880f, 0.9449190f, 0.9480210f, 0.9509810f, 0.9532570f, 0.9560420f, 0.9581430f, 0.9600910f, 0.9609580f, 0.9631350f, 0.9649320f, 0.9674470f, 0.9728920f, 0.9774240f, 0.9827830f, 0.9874630f, 0.9926650f, 0.9966400f, 0.9993680f, 0.9999140f, 0.9942900f, 0.9882640f, 0.9810720f, 0.9751580f, 0.9699990f, 0.9659940f, 0.9632210f, 0.9624050f, 0.9621500f, 0.9633410f, 0.9654310f, 0.9671030f, 0.9672570f, 0.9677370f, 0.9653110f, 0.9633140f, 0.9579490f, 0.9533250f, 0.9486410f, 0.9423590f, 0.9358410f, 0.9299340f, 0.9243940f, 0.9190090f, 0.9141220f, 0.9087800f, 0.9039750f, 0.8980690f, 0.8927220f, 0.8870500f, 0.8828150f, 0.8771870f, 0.8734510f, 0.8694140f, 0.8664310f, 0.8660560f, 0.8588170f, 0.8477750f, 0.8331070f, 0.8135860f, 0.7865930f, 0.7489860f, 0.6981680f, 0.6306270f, 0.5506620f, 0.4616840f, 0.3695890f, 0.2823490f, 0.2074510f, 0.1465300f, 0.1010100f, 0.0686868f, 0.0471034f, 0.0324221f, 0.0246752f, 0.0174143f, 0.0126697f, 0.0116629f, 0.0086694f, 0.0081772f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f }; //add panchromatic band to the temporary list const std::vector vpan (pan, pan + sizeof(pan) / sizeof(float) ); tmpSpectralBandList.push_back(vpan); } else if (sensorId == "PHR 1B") { const float pan[209] = { 8.4949016432e-06f,1.27423524648e-05f,2.54847049296e-05f,4.10586912755e-05f,5.94643115024e-05f,7.64541147888e-05f, 0.0001047705f,0.0001628184f,0.0004077553f,0.0007560434f,0.0027948226f,0.0055783471f, 0.0119863062f,0.022134882f,0.0389179761f,0.0664188043f,0.1067016279f,0.1614272001f, 0.2272018077f,0.2986552571f,0.367815083f,0.4258041132f,0.4697397445f,0.4991660838f, 0.5193159905f,0.5332504608f,0.5467262065f,0.5603038909f,0.5736437182f,0.5855337488f, 0.5956625032f,0.6041036038f,0.6120151889f,0.618774299f,0.625564557f,0.6319045853f, 0.6377943837f,0.6421862479f,0.6443949223f,0.6448819633f,0.644884795f,0.6451141573f, 0.6468357907f,0.6513182672f,0.6590911022f,0.6691405708f,0.6811806781f,0.6937021631f, 0.7056091836f,0.7157690859f,0.7250568451f,0.7323511339f,0.7384193253f,0.7438758838f, 0.7492531566f,0.7536450207f,0.7580793594f,0.7610893862f,0.7639125252f,0.7652348982f, 0.766172169f,0.7665969141f,0.767494542f,0.7687546191f,0.7723026564f,0.7771079391f, 0.7833828397f,0.7917191699f,0.8015449394f,0.8109516272f,0.8200326771f,0.8290684208f, 0.8364646485f,0.8426517685f,0.8481876127f,0.8519168746f,0.8555045547f,0.8583361886f, 0.8620173126f,0.8666838452f,0.8715797402f,0.8780188757f,0.8847071949f,0.8913473763f, 0.898890849f,0.9045824331f,0.9105090428f,0.9154615705f,0.9207935371f,0.9253156564f, 0.9289882855f,0.9328931087f,0.9369565033f,0.9400797954f,0.9441601799f,0.9469295178f, 0.9503472999f,0.9521085762f,0.9542804394f,0.9574405428f,0.9607705442f,0.9663148834f, 0.9720999114f,0.9788278735f,0.9845959117f,0.991221935f,0.9956874216f,0.9990882139f, 1.0f,0.9963273709f,0.9914682871f,0.9869688209f,0.9817019819f,0.9771458829f, 0.9745974125f,0.9729012638f,0.9739319785f,0.9741924888f,0.9768712145f,0.9798246086f, 0.9827723395f,0.9845732586f,0.9850772894f,0.9837266001f,0.9825967782f,0.9790232562f, 0.9745945808f,0.9697411603f,0.9648141174f,0.9598389367f,0.9533346736f,0.9483566613f, 0.9445481137f,0.93968903f,0.9344561706f,0.9297160154f,0.9248342786f,0.9183356789f, 0.9111942982f,0.9061001889f,0.9006181457f,0.8953456434f,0.8908093659f,0.8894954878f, 0.8885412272f,0.8809779331f,0.8707840511f,0.8566683562f,0.8369346997f,0.8102408871f, 0.7728519933f,0.718954674f,0.6528501811f,0.5710810895f,0.4795853355f,0.3846491464f, 0.294773087f,0.2166449103f,0.1531319287f,0.1057054591f,0.0716799801f,0.0491432892f, 0.0337757289f,0.0256986066f,0.0181762579f,0.0131968863f,0.0121562043f,0.0090201414f, 0.0084156159f,0.0042799863f,0.0033130116f,0.0026688064f,0.0022115061f,0.0018292327f, 0.0015290823f,0.0013634289f,0.0012147709f,0.0011015056f,0.0009939035f,0.0009188652f, 0.0008523218f,0.0008225925f,0.0006965819f,0.0007220666f,0.0006682656f,0.0006470283f, 0.0006144646f,0.000603138f,0.0006116329f,0.0005578319f,0.0005295155f,0.0005295155f, 0.0005210206f,0.0005054466f,0.0004473982f,0.0004473953f,0.0004077553f,0.0004558931f, 0.0004077553f,0.0004346558f,0.0003766073f,0.0003851022f,0.0003879338f,0.0003723599f, 0.0003341328f,0.0003723599f,0.0003313012f,0.0003341328f,0.0003143114f }; //add panchromatic band to the temporary list const std::vector vpan (pan, pan + sizeof(pan) / sizeof(float) ); tmpSpectralBandList.push_back(vpan); } else { itkExceptionMacro(<< "Invalid Pleiades Sensor ID"); } } else if (nbBands > 1 && nbBands < 5) { if (sensorId == "PHR 1A") { //band B0 (blue band) const float b0[209] = { 0.0098681f, 0.0293268f, 0.0877320f, 0.1287040f, 0.1341240f, 0.2457050f, 0.4345520f, 0.5133040f, 0.4710970f, 0.5125880f, 0.6530370f, 0.7707870f, 0.7879420f, 0.7648330f, 0.7718380f, 0.8013290f, 0.8240790f, 0.8352890f, 0.8326150f, 0.8249150f, 0.8168160f, 0.8163380f, 0.8285420f, 0.8623820f, 0.9075060f, 0.9379000f, 0.9505710f, 0.9572260f, 0.9650570f, 0.9632790f, 0.9587260f, 0.9567320f, 0.9646760f, 0.9804620f, 0.9900240f, 0.9838940f, 0.9719110f, 0.9715280f, 0.9574890f, 0.8770130f, 0.7103910f, 0.4943810f, 0.3021990f, 0.1722720f, 0.0943537f, 0.0543895f, 0.0345732f, 0.0261018f, 0.0230010f, 0.0223203f, 0.0210136f, 0.0173172f, 0.0119112f, 0.0072895f, 0.0046311f, 0.0033297f, 0.0025865f, 0.0020232f, 0.0015030f, 0.0010527f, 0.0007044f, 0.0005199f, 0.0004117f, 0.0004097f, 0.0005317f, 0.0009532f, 0.0013521f, 0.0014273f, 0.0009182f, 0.0003440f, 0.0001323f, 0.0000783f, 0.0000626f, 0.0000511f, 0.0000538f, 0.0000533f, 0.0000454f, 0.0000404f, 0.0000315f, 0.0000327f, 0.0000262f, 0.0000303f, 0.0000206f, 0.0000241f, 0.0000241f, 0.0000273f, 0.0000258f, 0.0000208f, 0.0000341f, 0.0000379f, 0.0000393f, 0.0000429f, 0.0000281f, 0.0000277f, 0.0000187f, 0.0000272f, 0.0000245f, 0.0000209f, 0.0000137f, 0.0000171f, 0.0000257f, 0.0000300f, 0.0000330f, 0.0000446f, 0.0000397f, 0.0000399f, 0.0000384f, 0.0000336f, 0.0000307f, 0.0000300f, 0.0000242f, 0.0000224f, 0.0000210f, 0.0000325f, 0.0000690f, 0.0002195f, 0.0005063f, 0.0008373f, 0.0009464f, 0.0007099f, 0.0004910f, 0.0004433f, 0.0006064f, 0.0012019f, 0.0016241f, 0.0016779f, 0.0009733f, 0.0003606f, 0.0001659f, 0.0000864f, 0.0000564f, 0.0000562f, 0.0000590f, 0.0000458f, 0.0000382f, 0.0000586f, 0.0000685f, 0.0000474f, 0.0000872f, 0.0000628f, 0.0000948f, 0.0001015f, 0.0001564f, 0.0002379f, 0.0003493f, 0.0005409f, 0.0007229f, 0.0007896f, 0.0007188f, 0.0005204f, 0.0003939f, 0.0003128f, 0.0002699f, 0.0002605f, 0.0002378f, 0.0002286f, 0.0002406f, 0.0002741f, 0.0003203f, 0.0003812f, 0.0004904f, 0.0006077f, 0.0008210f, 0.0011791f, 0.0018150f, 0.0030817f, 0.0055589f, 0.0103652f, 0.0166309f, 0.0211503f, 0.0216246f, 0.0176910f, 0.0136927f, 0.0107136f, 0.0089555f, 0.0079790f, 0.0079189f, 0.0080456f, 0.0088920f, 0.0102062f, 0.0126157f, 0.0162251f, 0.0221306f, 0.0308295f, 0.0411980f, 0.0498232f, 0.0531265f, 0.0484487f, 0.0391122f, 0.0291405f, 0.0212633f, 0.0162146f, 0.0128925f, 0.0108169f, 0.0094115f, 0.0084386f, 0.0077249f, 0.0074231f, 0.0072603f, 0.0073459f, 0.0074214f, 0.0076433f, 0.0077788f, 0.0078151f, 0.0077003f, 0.0072256f, 0.0065903f, 0.0057120f, 0.0048136f }; //B1 green band const float b1[209] = { 0.0000144f, 0.0000143f, 0.0000259f, 0.0000189f, 0.0000132f, 0.0000179f, 0.0000224f, 0.0000179f, 0.0000124f, 0.0000202f, 0.0000276f, 0.0000292f, 0.0000420f, 0.0000366f, 0.0000261f, 0.0000247f, 0.0000445f, 0.0000902f, 0.0001144f, 0.0000823f, 0.0000778f, 0.0001923f, 0.0003401f, 0.0004085f, 0.0004936f, 0.0007849f, 0.0045979f, 0.0085122f, 0.0143014f, 0.0243310f, 0.0480572f, 0.1097360f, 0.2353890f, 0.4328370f, 0.6491340f, 0.8095770f, 0.8847680f, 0.9066640f, 0.9131150f, 0.9186700f, 0.9273270f, 0.9405210f, 0.9512930f, 0.9587500f, 0.9667360f, 0.9709750f, 0.9728630f, 0.9769560f, 0.9850710f, 0.9892500f, 0.9865960f, 0.9743300f, 0.9575190f, 0.9435550f, 0.9439310f, 0.9571350f, 0.9712530f, 0.9761580f, 0.9619590f, 0.9244890f, 0.8734580f, 0.8349840f, 0.8166740f, 0.8015960f, 0.7435910f, 0.6160350f, 0.4321320f, 0.2544540f, 0.1360870f, 0.0769553f, 0.0479321f, 0.0342014f, 0.0266703f, 0.0212632f, 0.0160541f, 0.0106967f, 0.0060543f, 0.0030797f, 0.0015416f, 0.0008333f, 0.0004706f, 0.0002918f, 0.0001917f, 0.0001472f, 0.0001063f, 0.0000912f, 0.0000589f, 0.0000552f, 0.0000752f, 0.0000884f, 0.0000985f, 0.0001125f, 0.0001368f, 0.0001947f, 0.0002284f, 0.0002088f, 0.0001498f, 0.0000637f, 0.0000307f, 0.0000283f, 0.0000311f, 0.0000331f, 0.0000215f, 0.0000236f, 0.0000205f, 0.0000186f, 0.0000233f, 0.0000233f, 0.0000198f, 0.0000195f, 0.0000161f, 0.0000308f, 0.0000464f, 0.0000290f, 0.0000264f, 0.0000233f, 0.0000395f, 0.0001113f, 0.0001903f, 0.0002290f, 0.0002229f, 0.0001322f, 0.0000548f, 0.0000608f, 0.0000414f, 0.0000382f, 0.0000381f, 0.0000269f, 0.0000233f, 0.0000198f, 0.0000208f, 0.0000302f, 0.0000419f, 0.0000305f, 0.0000340f, 0.0000334f, 0.0000362f, 0.0000282f, 0.0000337f, 0.0000330f, 0.0000424f, 0.0000420f, 0.0000470f, 0.0000417f, 0.0000233f, 0.0000439f, 0.0000503f, 0.0000446f, 0.0000428f, 0.0000597f, 0.0000671f, 0.0001142f, 0.0001780f, 0.0003546f, 0.0009610f, 0.0041260f, 0.0066679f, 0.0078563f, 0.0068645f, 0.0029441f, 0.0011320f, 0.0007028f, 0.0005471f, 0.0004967f, 0.0004929f, 0.0005351f, 0.0006223f, 0.0007957f, 0.0010708f, 0.0016699f, 0.0030334f, 0.0054959f, 0.0091390f, 0.0125045f, 0.0144212f, 0.0141099f, 0.0117418f, 0.0089824f, 0.0067916f, 0.0056849f, 0.0051998f, 0.0053640f, 0.0060350f, 0.0067668f, 0.0083174f, 0.0106521f, 0.0139110f, 0.0183736f, 0.0231289f, 0.0272661f, 0.0298126f, 0.0300318f, 0.0286507f, 0.0266172f, 0.0247529f, 0.0236974f, 0.0232734f, 0.0236733f, 0.0245808f, 0.0257173f, 0.0267721f, 0.0267455f, 0.0254447f, 0.0227056f, 0.0188513f, 0.0147988f, 0.0109864f, 0.0079795f, 0.0057516f }; //B2 red band const float b2[209] = { 0.0097386f, 0.0035306f, 0.0035374f, 0.0114418f, 0.0266686f, 0.0373494f, 0.0904431f, 0.0907580f, 0.0399312f, 0.0208748f, 0.0080694f, 0.0027002f, 0.0011241f, 0.0006460f, 0.0005029f, 0.0006051f, 0.0009979f, 0.0019446f, 0.0014554f, 0.0006090f, 0.0003230f, 0.0002503f, 0.0002538f, 0.0003360f, 0.0005377f, 0.0007773f, 0.0004895f, 0.0002045f, 0.0000875f, 0.0000594f, 0.0000217f, 0.0000290f, 0.0000297f, 0.0000408f, 0.0000456f, 0.0000447f, 0.0000322f, 0.0000222f, 0.0000147f, 0.0000095f, 0.0000072f, 0.0000113f, 0.0000313f, 0.0000123f, 0.0000122f, 0.0000280f, 0.0000180f, 0.0000261f, 0.0000138f, 0.0000392f, 0.0000517f, 0.0000695f, 0.0000797f, 0.0000785f, 0.0001004f, 0.0001170f, 0.0001483f, 0.0001837f, 0.0002110f, 0.0002973f, 0.0004162f, 0.0006371f, 0.0010012f, 0.0032888f, 0.0100109f, 0.0181837f, 0.0330510f, 0.0624784f, 0.1183670f, 0.2218740f, 0.3756820f, 0.5574830f, 0.7342220f, 0.8636840f, 0.9319920f, 0.9527010f, 0.9620090f, 0.9527340f, 0.9437220f, 0.9456300f, 0.9562330f, 0.9693120f, 0.9839640f, 0.9949160f, 0.9992700f, 0.9993300f, 0.9963430f, 0.9944130f, 0.9883050f, 0.9857580f, 0.9807560f, 0.9683790f, 0.9544700f, 0.9371750f, 0.9170350f, 0.8922820f, 0.8662710f, 0.8442750f, 0.8220420f, 0.7888070f, 0.7372920f, 0.6625080f, 0.5662120f, 0.4493120f, 0.3260000f, 0.2194040f, 0.1416500f, 0.0925669f, 0.0619437f, 0.0456444f, 0.0355683f, 0.0310879f, 0.0295168f, 0.0233351f, 0.0189628f, 0.0158627f, 0.0132266f, 0.0107473f, 0.0083969f, 0.0063847f, 0.0046601f, 0.0033814f, 0.0024167f, 0.0017478f, 0.0012949f, 0.0009939f, 0.0007442f, 0.0006312f, 0.0005142f, 0.0004354f, 0.0003549f, 0.0003156f, 0.0003079f, 0.0002906f, 0.0002867f, 0.0002751f, 0.0003048f, 0.0003010f, 0.0003342f, 0.0004310f, 0.0004955f, 0.0005488f, 0.0005838f, 0.0006687f, 0.0006968f, 0.0006650f, 0.0005866f, 0.0004688f, 0.0004086f, 0.0003611f, 0.0002404f, 0.0002609f, 0.0002476f, 0.0002133f, 0.0002098f, 0.0001916f, 0.0001642f, 0.0001799f, 0.0002180f, 0.0002003f, 0.0002030f, 0.0002348f, 0.0002735f, 0.0002652f, 0.0002944f, 0.0004666f, 0.0004882f, 0.0006642f, 0.0007798f, 0.0010588f, 0.0014008f, 0.0019011f, 0.0024917f, 0.0034379f, 0.0042182f, 0.0053618f, 0.0062814f, 0.0068774f, 0.0071141f, 0.0070399f, 0.0065876f, 0.0067873f, 0.0066877f, 0.0068572f, 0.0070486f, 0.0073911f, 0.0081201f, 0.0087391f, 0.0096581f, 0.0106625f, 0.0120129f, 0.0137222f, 0.0159817f, 0.0180896f, 0.0206562f, 0.0236408f, 0.0269627f, 0.0310497f, 0.0353146f, 0.0398729f, 0.0438795f, 0.0462377f, 0.0454916f, 0.0408754f, 0.0333175f, 0.0251186f, 0.0179089f, 0.0125129f, 0.0086117f }; //B3 nir band const float b3[209] = { 0.0024163f, 0.0017305f, 0.0020803f, 0.0020499f, 0.0012660f, 0.0007361f, 0.0006198f, 0.0006344f, 0.0007721f, 0.0011837f, 0.0020819f, 0.0023991f, 0.0013377f, 0.0006328f, 0.0003544f, 0.0002890f, 0.0002498f, 0.0002541f, 0.0003346f, 0.0005048f, 0.0008684f, 0.0009871f, 0.0006587f, 0.0003833f, 0.0002606f, 0.0002356f, 0.0002364f, 0.0002791f, 0.0003613f, 0.0005575f, 0.0007414f, 0.0007413f, 0.0005768f, 0.0004230f, 0.0003206f, 0.0003044f, 0.0003019f, 0.0003201f, 0.0003813f, 0.0004630f, 0.0005930f, 0.0007080f, 0.0008577f, 0.0009017f, 0.0008813f, 0.0007801f, 0.0006583f, 0.0005863f, 0.0005224f, 0.0005506f, 0.0006403f, 0.0008293f, 0.0013444f, 0.0023942f, 0.0027274f, 0.0014330f, 0.0006388f, 0.0003596f, 0.0002416f, 0.0001718f, 0.0001566f, 0.0001642f, 0.0001892f, 0.0002351f, 0.0003227f, 0.0006734f, 0.0014311f, 0.0013325f, 0.0005796f, 0.0002424f, 0.0001263f, 0.0001022f, 0.0000446f, 0.0000652f, 0.0000544f, 0.0000573f, 0.0000518f, 0.0000504f, 0.0000649f, 0.0000723f, 0.0000833f, 0.0000739f, 0.0000691f, 0.0001382f, 0.0001692f, 0.0002240f, 0.0002296f, 0.0001553f, 0.0001492f, 0.0001121f, 0.0001058f, 0.0001068f, 0.0001012f, 0.0000864f, 0.0000533f, 0.0000354f, 0.0000440f, 0.0000371f, 0.0000691f, 0.0000769f, 0.0000791f, 0.0001333f, 0.0001244f, 0.0002048f, 0.0002455f, 0.0002721f, 0.0003812f, 0.0004568f, 0.0006255f, 0.0008185f, 0.0009733f, 0.0012281f, 0.0013528f, 0.0015758f, 0.0017458f, 0.0019104f, 0.0020863f, 0.0023053f, 0.0025241f, 0.0037234f, 0.0044186f, 0.0053574f, 0.0066118f, 0.0083509f, 0.0107509f, 0.0150393f, 0.0212756f, 0.0292566f, 0.0414246f, 0.0586633f, 0.0834879f, 0.1190380f, 0.1671850f, 0.2326370f, 0.3124060f, 0.4070470f, 0.5091930f, 0.6148270f, 0.7140870f, 0.8017550f, 0.8714840f, 0.9241260f, 0.9587210f, 0.9782990f, 0.9882040f, 0.9922940f, 0.9902030f, 0.9854020f, 0.9777560f, 0.9660200f, 0.9532070f, 0.9421250f, 0.9303560f, 0.9241490f, 0.9212220f, 0.9203820f, 0.9217020f, 0.9227420f, 0.9230000f, 0.9237670f, 0.9243070f, 0.9206520f, 0.9154840f, 0.9090910f, 0.9003380f, 0.8905620f, 0.8776420f, 0.8668600f, 0.8537290f, 0.8428590f, 0.8305310f, 0.8195740f, 0.8069090f, 0.7921080f, 0.7791670f, 0.7660510f, 0.7521190f, 0.7375270f, 0.7217320f, 0.7043220f, 0.6853170f, 0.6642500f, 0.6413850f, 0.6173030f, 0.5919540f, 0.5672310f, 0.5430130f, 0.5184560f, 0.4957540f, 0.4734340f, 0.4528220f, 0.4332270f, 0.4131920f, 0.3919120f, 0.3659660f, 0.3325420f, 0.2917680f, 0.2453910f, 0.1962540f, 0.1486850f, 0.1068860f, 0.0738260f, 0.0491777f, 0.0327991f, 0.0215831f, 0.0145386f, 0.0103219f, 0.0076144f, 0.0061346f }; //Add multispectral bands to the temporary list const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); const std::vector vb1 (b1, b1 + sizeof(b1) / sizeof(float) ); const std::vector vb2 (b2, b2 + sizeof(b2) / sizeof(float) ); const std::vector vb3 (b3, b3 + sizeof(b3) / sizeof(float) ); //For Pleiades MS image the order of band in 1A product is: B2 B1 B0 B3 //(BandIndexToWavelength method could be used here) tmpSpectralBandList.push_back(vb2); tmpSpectralBandList.push_back(vb1); tmpSpectralBandList.push_back(vb0); tmpSpectralBandList.push_back(vb3); } else if (sensorId == "PHR 1B") { //B0 blue band const float b0[209] = {0.0016025229f,0.0013381709f,0.0043437933f,0.0110724631f,0.0176270388f,0.0233671533f, 0.057403285f,0.1345548468f,0.2237631463f,0.3085427458f,0.4615565735f,0.650820526f, 0.755369094f,0.7477203647f,0.7168186424f,0.7185381794f,0.7566962056f,0.8101088802f, 0.842166474f,0.8234370764f,0.775247228f,0.7527006008f,0.7802203291f,0.8199266521f, 0.8516631705f,0.8602751259f,0.858684019f,0.8658261626f,0.8828217532f,0.9040412689f, 0.9196954778f,0.9325955734f,0.9502333148f,0.9757980507f,0.9949769539f,1.0f, 0.995062574f,0.9806284516f,0.9417497895f,0.8436220158f,0.6711424576f,0.4633403256f, 0.2888651055f,0.1670783567f,0.0901800876f,0.0505194286f,0.0314882201f,0.0238137335f, 0.0213108438f,0.0206298072f,0.0195599127f,0.0167943833f,0.0113582202f,0.0066519685f, 0.004144013f,0.0030298814f,0.0024159139f,0.0019903178f,0.0015682749f,0.0011355438f, 0.0012529075f,0.0008355166f,0.0005508227f,0.000419896f,0.0003617449f,0.000377798f, 0.0005322716f,0.0011091514f,0.0019870999f,0.0012200722f,0.0003753015f,0.0001469798f, 7.49175906503e-05f,5.2799e-05f,5.56530673402e-05f,5.74373902992e-05f,5.63665682035e-05f,3.78155457568e-05f, 3.49615423035e-05f,2.06915250367e-05f,1.35565164034e-05f,1.99783095738e-05f,4.281e-06f,1.10591920316e-05f, 1.21295146767e-05f,1.14159424633e-05f,9.27551122337e-06f,1.1773e-05f,1.92645233101e-05f,8.919e-06f, 1.1416e-05f,1.71237353197e-05f,4.99450604335e-06f,8.56172495969e-06f,2.4259e-05f,3.85286898697e-05f, 1.2843e-05f,2.35456711903e-05f,9.989e-06f,1.14162992137e-05f,2.06915250367e-05f,1.39132668351e-05f, 5.708e-06f,2.854e-06f,8.562e-06f,1.24862651084e-05f,8.562e-06f,9.27565392354e-06f, 6.42150777002e-06f,1.1773e-05f,5.708e-06f,1.35566591036e-05f,1.7124e-05f,7.13522268362e-06f, 9.989e-06f,2.71133895572e-05f,6.35015768369e-05f,0.0002194051f,0.0007613054f,0.0011194829f, 0.0007541704f,0.0004084771f,0.0003546099f,0.0004063402f,0.0006792528f,0.0016292935f, 0.0024002169f,0.0010317222f,0.0003481884f,0.000165889f,8.2766100147e-05f,9.70361174137e-05f, 4.63775561168e-05f,2.63994605933e-05f,3.21075388501e-05f,4.1026442342e-05f,1.5697e-05f,8.9192602423e-06f, 4.70910569802e-05f,7.88411318978e-05f,2.21185267634e-05f,5.35134923013e-05f,8.2766100147e-05f,0.0001052421f, 0.0001833697f,0.00026043f,0.000441657f,0.000710293f,0.000864763f,0.0007370464f, 0.0005515362f,0.000394566f,0.0002811193f,0.0002340283f,0.0002247528f,0.0001922885f, 0.0002197583f,0.0002340276f,0.0002454443f,0.0002454436f,0.0002782653f,0.000350685f, 0.000431668f,0.0005326263f,0.0006885283f,0.0010277909f,0.0015625669f,0.0026085734f, 0.0045749675f,0.0090618891f,0.0171625498f,0.0237927565f,0.021523467f,0.0159138519f, 0.011956134f,0.0094824265f,0.007869201f,0.0072241962f,0.0072420338f,0.0075677469f, 0.0083793541f,0.0098637927f,0.0122586583f,0.0162673916f,0.0226015668f,0.0320271273f, 0.0444304123f,0.0546690783f,0.0564243618f,0.048004124f,0.0357991923f,0.0258336544f, 0.0188870814f,0.0144386889f,0.0116792956f,0.0099112405f,0.008646917f,0.0078099805f, 0.0072270502f,0.006995876f,0.0069230989f,0.0069141801f,0.0070208485f,0.0072527363f, 0.0073726044f,0.0075049588f,0.007470354f,0.0070672332f,0.0063679952f }; //B1 green band const float b1[209] = {3.2793605247e-06f,3.2793605247e-06f,4.919e-06f,6.5587210494e-06f,6.5587210494e-06f,2.86944045911e-06f, 6.5587210494e-06f,5.73885632302e-06f,4.09920065587e-06f,2.86943226071e-06f,1.47571223611e-05f,2.29553597049e-05f, 1.06579217053e-05f,1.27075220332e-05f,2.21356835417e-05f,1.8856323017e-05f,9.01824144292e-05f,0.0001151875f, 0.0001123181f,0.0001893831f,0.000323017f,0.0004849346f,0.0006238983f,0.0008153327f, 0.0015208034f,0.0041299447f,0.009953679f,0.0196421398f,0.0325476532f,0.0567927854f, 0.1237909408f,0.2859094077f,0.5289756098f,0.7716253331f,0.8838040582f,0.9079565485f, 0.9131461365f,0.913728223f,0.9224841156f,0.9367083419f,0.9497601968f,0.9544988727f, 0.9585816766f,0.9642057799f,0.9705267473f,0.9722648084f,0.967517934f,0.9589096126f, 0.9524492724f,0.9524656692f,0.9560483706f,0.95517934f,0.948989547f,0.9471449067f, 0.9544496823f,0.9710596434f,0.9898175856f,1.0f,0.9953597049f,0.9698216848f, 0.9253043656f,0.8633244517f,0.7948284485f,0.7238967001f,0.6453265013f,0.5438524288f, 0.4170280795f,0.2766706292f,0.1575273622f,0.0856068867f,0.049225661f,0.0327237549f, 0.0237934003f,0.0181966796f,0.0140618979f,0.0099658947f,0.0058454601f,0.0030383275f, 0.0015355606f,0.0008386965f,0.0004878049f,0.0003115409f,0.0002074196f,0.0001381439f, 9.26419348227e-05f,7.00964131994e-05f,6.39475302316e-05f,5.41093666735e-05f,4.0992e-05f,7.00968231195e-05f, 4.75507276081e-05f,4.71408895265e-05f,6.23078499693e-05f,6.72277925804e-05f,0.0001483911f,0.0002512826f, 0.0002992416f,0.0002303743f,0.0001270752f,6.72265628203e-05f,3.11539249846e-05f,3.15638450502e-05f, 1.72166427547e-05f,6.5587210494e-06f,5.73888091822e-06f,1.76265628203e-05f,1.06579217053e-05f,1.72168067227e-05f, 1.14777618364e-05f,2.86946505431e-06f,3.2793605247e-06f,2.86941586391e-06f,1.393728223e-05f,1.27072760812e-05f, 1.72166427547e-05f,9.83840951015e-06f,7.37856118057e-06f,2.41853658537e-05f,3.2793605247e-05f,0.0001295372f, 0.000277106f,0.0001893831f,0.0001237959f,2.4185e-05f,7.37856118057e-06f,7.37870875179e-06f, 4.09920065587e-06f,1.0248e-05f,9.83808157409e-06f,3.2793605247e-06f,1.5577e-05f,2.29556056569e-05f, 7.37856118057e-06f,1.02477556876e-05f,9.01824144292e-06f,6.96851813896e-06f,1.72166427547e-05f,2.29553597049e-05f, 2.45952039352e-06f,2.1315e-05f,9.83808157409e-06f,1.1887763886e-05f,3.44332855093e-05f,9.01856937897e-06f, 1.80364828858e-05f,1.72165607706e-05f,1.8856323017e-05f,1.8037e-05f,2.86944045911e-05f,2.86944865751e-05f, 2.0496e-05f,4.34515269522e-05f,2.95142447223e-05f,5.28796884608e-05f,9.34617749539e-05f,0.0001336339f, 0.000277106f,0.0007050527f,0.0031850789f,0.0141905308f,0.0083394138f,0.0022443452f, 0.0009182209f,0.000571841f,0.0004369748f,0.0004029514f,0.0004181185f,0.000445174f, 0.0005173191f,0.0006021734f,0.0007575323f,0.0011108916f,0.0019381021f,0.0036905349f, 0.0063570404f,0.0102714491f,0.013107604f,0.0132605042f,0.0111153925f,0.0083664685f, 0.0065644599f,0.0056847797f,0.0053797909f,0.0056228653f,0.0062004509f,0.007239172f, 0.0089198606f,0.0115101455f,0.0149415864f,0.0192686206f,0.0234785817f,0.0264402542f, 0.0270489854f,0.0255453986f,0.0233974175f,0.0213945481f,0.0199442509f,0.0192531256f, 0.0190744005f,0.0196892806f,0.0206935848f,0.0220106579f,0.0232301701f,0.0237573273f, 0.0229858578f,0.0206595614f,0.0172248412f,0.01329215f,0.0097815126f }; //B2 red band const float b2[209] = {0.0004536879f,0.0008531472f,0.000520901f,0.0011945588f,0.0051417966f,0.0080033148f, 0.0066930427f,0.0108594102f,0.0246908583f,0.0653593224f,0.1225423328f,0.0570092494f, 0.0213752702f,0.0127972076f,0.006277544f,0.0023536016f,0.0009409824f,0.0005174639f, 0.0003742544f,0.0003818922f,0.0005155545f,0.0008462731f,0.0010127781f,0.0006431042f, 0.0003513408f,0.0002512851f,0.000223025f,0.000251667f,0.0003551597f,0.0004998969f, 0.0005262475f,0.0003864772f,0.0002528126f,0.0001626868f,0.0001069298f,8.78352058781e-05f, 7.02681647025e-05f,5.84297356542e-05f,5.49924767237e-05f,4.81185698901e-05f,3.66616511491e-05f,3.20791738908e-05f, 1.90946099735e-05f,1.79493916457e-05f,3.74254355481e-05f,2.40590558097e-05f,3.43702979523e-05f,1.48934902656e-05f, 6.87405959046e-06f,7.256e-06f,3.8189219947e-06f,2.29135319682e-06f,9.16541278728e-06f,2.94056993592e-05f, 2.36773163671e-05f,2.90238071597e-05f,3.8953e-05f,4.5063e-05f,6.95043803035e-05f,8.13422747027e-05f, 0.0001038747f,0.0001229693f,0.0001351898f,0.0001535207f,0.0001833083f,0.0002214967f, 0.0007454536f,0.0012442124f,0.0021416515f,0.0038193268f,0.0068045552f,0.0123329031f, 0.0221780076f,0.0413324983f,0.0780709861f,0.151934284f,0.277674582f,0.4510376011f, 0.6291322645f,0.7625485958f,0.8329450763f,0.8579055504f,0.8658870974f,0.8692630244f, 0.8752205427f,0.8857760431f,0.9005934605f,0.9174883714f,0.9348797421f,0.947810612f, 0.9569531113f,0.9623301534f,0.9647666257f,0.9624294454f,0.9613066823f,0.9620246397f, 0.9699145325f,0.9811574389f,0.9933932649f,1.0f,0.9809512171f,0.9522634751f, 0.9131729895f,0.8694005056f,0.8252079403f,0.7830470415f,0.7361270021f,0.6734890435f, 0.5877527172f,0.4804914189f,0.3630068664f,0.2523031919f,0.1626028245f,0.102221085f, 0.0641273381f,0.0419155713f,0.0284639532f,0.0204548336f,0.0153696335f,0.0121174395f, 0.0098810788f,0.0083168483f,0.0071016673f,0.0060949919f,0.0051723479f,0.0043142285f, 0.0034950774f,0.0027713917f,0.0035890229f,0.0030310784f,0.0023173219f,0.001784208f, 0.0013312762f,0.0010207978f,0.0007897531f,0.0006385253f,0.0005079166f,0.0004120624f, 0.0003788371f,0.0003593606f,0.0002978759f,0.0002787813f,0.0002810727f,0.0002623607f, 0.0002856554f,0.0002948208f,0.0002757262f,0.0003158256f,0.0003750181f,0.0004296295f, 0.0005186096f,0.0005747478f,0.0006194291f,0.0006503624f,0.0006515081f,0.0006041535f, 0.0005369404f,0.0004643817f,0.0003765457f,0.0003215532f,0.0002841278f,0.0002539583f, 0.000226844f,0.0002226432f,0.0001672688f,0.0001978194f,0.0002207337f,0.000208895f, 0.0002329542f,0.0002054572f,0.0001871272f,0.0002505213f,0.0002932932f,0.0002635079f, 0.0002589229f,0.000449106f,0.0005361766f,0.000566728f,0.0008210682f,0.0009856638f, 0.0013075989f,0.0017612792f,0.0024028657f,0.0032682258f,0.0043635003f,0.0056615366f, 0.0068900991f,0.0078222979f,0.0083298327f,0.0084363806f,0.0081854774f,0.0081381228f, 0.0080006416f,0.0077676873f,0.0077844906f,0.0079983502f,0.0081518709f,0.008505885f, 0.008792686f,0.0093120594f,0.009752763f,0.0101358009f,0.0103874678f,0.0104061805f, 0.0101713168f,0.009522482f,0.008608614f,0.0073373101f,0.0059842508f }; //B3 nir band const float b3[209] = {0.0001962709f,0.0007612586f,0.0003823311f,0.0005128001f,0.0016870217f,0.0026649725f, 0.0012252747f,0.0007391367f,0.0007408374f,0.0007538843f,0.0007760073f,0.0009904326f, 0.0015486111f,0.0021799679f,0.0019876678f,0.001044887f,0.0004923789f,0.0002830611f, 0.0002144231f,0.0001957036f,0.0002132886f,0.0002819266f,0.000417501f,0.0006069659f, 0.0006410002f,0.000437355f,0.0002654762f,0.0001905983f,0.0001622354f,0.0001707443f, 0.0001849257f,0.0002461883f,0.0003834656f,0.0005627165f,0.0006784391f,0.0006143403f, 0.0004844373f,0.0003880048f,0.0003596408f,0.000353401f,0.0003970798f,0.0004623154f, 0.0005513736f,0.0006410013f,0.0007306268f,0.0007572878f,0.0007669312f,0.0007192805f, 0.0006364621f,0.0005706603f,0.0005286833f,0.0004878409f,0.0004764957f,0.0005519409f, 0.0007181471f,0.0012241402f,0.0022656237f,0.0028788283f,0.00204099f,0.0008389819f, 0.0003789275f,0.0002252021f,0.0001395452f,0.0001242292f,9.98371972976e-05f,9.70007998321e-05f, 0.0001043753f,0.0001242292f,0.0001724461f,0.000286467f,0.0005275488f,0.0008208217f, 0.0006602869f,0.0003221996f,0.000167908f,0.0001032404f,6.80708163393e-05f,5.72929370855e-05f, 4.76495714375e-05f,3.23336377612e-05f,3.63044353809e-05f,4.14097466064e-05f,4.4246e-05f,3.91404924924e-05f, 5.78601938884e-05f,6.35326484653e-05f,6.2398248311e-05f,9.01938316495e-05f,0.0001009717f,0.0001525921f, 0.0001917328f,0.0001968381f,0.0001860602f,0.0001429487f,0.0001361416f,9.47317726208e-05f, 8.96265748467e-05f,8.79249178896e-05f,7.9416e-05f,7.54452682274e-05f,7.60124115788e-05f,8.50885204241e-05f, 9.41646292693e-05f,8.22522364099e-05f,8.1685e-05f,0.0001066443f,0.000121393f,0.0001350071f, 0.0001690425f,0.0002036441f,0.0002507275f,0.0003187972f,0.0003970798f,0.000508261f, 0.0006330586f,0.000795859f,0.0009688746f,0.0011538003f,0.0013523402f,0.0015542836f, 0.0017562271f,0.0019888024f,0.002250875f,0.0025345034f,0.0029032203f,0.0052357916f, 0.0064009258f,0.0080125023f,0.0101470897f,0.0131093047f,0.017134559f,0.0229045817f, 0.030977894f,0.0426621362f,0.0591898438f,0.0835072354f,0.1178884433f,0.1663775548f, 0.2311140356f,0.3159359454f,0.417216244f,0.528495011f,0.6409593447f,0.7472394448f, 0.8385519068f,0.9088123344f,0.9593662607f,0.988113701f,1.0f,0.9992058405f, 0.9896418908f,0.9676958596f,0.9514360106f,0.9374939729f,0.9254715322f,0.9152234708f, 0.9087828371f,0.9026076795f,0.8966832495f,0.8924832801f,0.8854912728f,0.8776551873f, 0.8676385667f,0.8568958573f,0.8474408209f,0.8360480353f,0.8236977202f,0.8130435029f, 0.8016268925f,0.7921616455f,0.7827951012f,0.7769353384f,0.7714647138f,0.7631453255f, 0.7543403654f,0.7452370283f,0.734920896f,0.7255123747f,0.714614237f,0.7030887133f, 0.6919477897f,0.6816475407f,0.6705202312f,0.6595358705f,0.6475962493f,0.6291853625f, 0.611093274f,0.5934323007f,0.5760594939f,0.5599936467f,0.5448751184f,0.5306142824f, 0.5154832744f,0.4976759489f,0.4734098374f,0.4387697334f,0.3934220901f,0.3367690187f, 0.2742732022f,0.2114336281f,0.1535541475f,0.1063407965f,0.0704419498f,0.0459120639f, 0.0295347927f,0.0192753862f,0.0126804586f,0.0084623824f,0.0057690017f }; //Add multispectral bands to the temporary list const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); const std::vector vb1 (b1, b1 + sizeof(b1) / sizeof(float) ); const std::vector vb2 (b2, b2 + sizeof(b2) / sizeof(float) ); const std::vector vb3 (b3, b3 + sizeof(b3) / sizeof(float) ); //For Pleiades MS image the order of band in 1A product is: B2 B1 B0 B3 //(BandIndexToWavelength method could be used here) tmpSpectralBandList.push_back(vb2); tmpSpectralBandList.push_back(vb1); tmpSpectralBandList.push_back(vb0); tmpSpectralBandList.push_back(vb3); } else { itkExceptionMacro(<< "Invalid Pleiades Sensor ID"); } } else { itkExceptionMacro(<< "Invalid number of bands..."); } unsigned int j = 0; for (std::list >::const_iterator it = tmpSpectralBandList.begin(); it != tmpSpectralBandList.end(); ++it) { wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); wavelengthSpectralBand->GetNthElement(j)->SetFilterFunctionValues(*it); wavelengthSpectralBand->GetNthElement(j)->SetMinSpectralValue(0.430); wavelengthSpectralBand->GetNthElement(j)->SetMaxSpectralValue(0.950); wavelengthSpectralBand->GetNthElement(j)->SetUserStep(0.0025); ++j; } return wavelengthSpectralBand; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbPleiadesImageMetadataInterfaceFactory.cxx000066400000000000000000000030231301006202600307570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbPleiadesImageMetadataInterfaceFactory.h" #include "otbPleiadesImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { PleiadesImageMetadataInterfaceFactory ::PleiadesImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbPleiadesImageMetadataInterface", "Pleiades Metadata Interface", 1, itk::CreateObjectFunction::New()); } PleiadesImageMetadataInterfaceFactory ::~PleiadesImageMetadataInterfaceFactory() { } const char* PleiadesImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* PleiadesImageMetadataInterfaceFactory::GetDescription() const { return "Pleiades Metadata Interface Factory, handle Pleiades metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbQuickBirdImageMetadataInterface.cxx000066400000000000000000001300021301006202600275540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbQuickBirdImageMetadataInterface.h" #include "otbStringUtils.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" namespace otb { QuickBirdImageMetadataInterface ::QuickBirdImageMetadataInterface() { } bool QuickBirdImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("QB02") != std::string::npos) return true; else return false; } QuickBirdImageMetadataInterface::VariableLengthVectorType QuickBirdImageMetadataInterface::GetSolarIrradiance() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType outputValuesVariableLengthVector; std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); if (keywordStringBId == panchro) { outputValuesVariableLengthVector.SetSize(1); outputValuesVariableLengthVector.Fill(1381.79); } else if (keywordStringBId == multi) { outputValuesVariableLengthVector.SetSize(4); outputValuesVariableLengthVector[0] = 1924.59; outputValuesVariableLengthVector[1] = 1843.08; outputValuesVariableLengthVector[2] = 1574.77; outputValuesVariableLengthVector[3] = 1113.71; } else { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } return outputValuesVariableLengthVector; } int QuickBirdImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int QuickBirdImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int QuickBirdImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } int QuickBirdImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Hour"); int value = atoi(outputValues[3].c_str()); return value; } int QuickBirdImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Minute"); int value = atoi(outputValues[4].c_str()); return value; } int QuickBirdImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.generation_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int QuickBirdImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.generation_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int QuickBirdImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.generation_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } QuickBirdImageMetadataInterface::VariableLengthVectorType QuickBirdImageMetadataInterface ::GetPhysicalBias() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType outputValuesVariableLengthVector; std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); if (keywordStringBId == panchro) { outputValuesVariableLengthVector.SetSize(1); outputValuesVariableLengthVector.Fill(0.0); } else if (keywordStringBId == multi) { outputValuesVariableLengthVector.SetSize(4); outputValuesVariableLengthVector.Fill(0.0); } else { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } return outputValuesVariableLengthVector; } QuickBirdImageMetadataInterface::VariableLengthVectorType QuickBirdImageMetadataInterface ::GetPhysicalGain() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } int productionYear = this->GetProductionYear(); //keywordStrings[0].toInt(); int productionMonth = this->GetProductionMonth(); //keywordStrings[1].toInt(); int productionDay = this->GetProductionDay(); //keywordStrings[2].toInt(); bool isPost20030606 = false; if (productionYear > 2003) isPost20030606 = true; else { if (productionYear == 2003) { if (productionMonth > 6) isPost20030606 = true; else if (productionDay >= 6) isPost20030606 = true; } } //Value computed from // Radiance Conversion of QuickBird Data - Technical Note. std::string keywordStringBitsPerPixel = imageKeywordlist.GetMetadataByKey("support_data.bits_per_pixel"); int bitsPerPixel = atoi(keywordStringBitsPerPixel.c_str()); if (bitsPerPixel != 16 && bitsPerPixel != 8) { itkExceptionMacro(<< "Invalid bitsPerPixel " << bitsPerPixel); } std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); if (keywordStringBId != panchro && keywordStringBId != multi) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } std::string keywordStringTDILevel = imageKeywordlist.GetMetadataByKey("support_data.TDI_level"); int TDILevel = atoi(keywordStringTDILevel.c_str()); if (keywordStringBId == panchro && TDILevel != 10 && TDILevel != 13 && TDILevel != 18 && TDILevel != 24 && TDILevel != 32) { itkExceptionMacro(<< "Invalid TDILevel " << TDILevel); } VariableLengthVectorType outputValuesVariableLengthVector; if (keywordStringBId == panchro) outputValuesVariableLengthVector.SetSize(1); else outputValuesVariableLengthVector.SetSize(4); outputValuesVariableLengthVector.Fill(1.); if (!isPost20030606) { if (bitsPerPixel == 16) { if (keywordStringBId == panchro) { if (TDILevel != 10) outputValuesVariableLengthVector[0] = 0.08381880; else if (TDILevel != 13) outputValuesVariableLengthVector[0] = 0.06447600; else if (TDILevel != 18) outputValuesVariableLengthVector[0] = 0.04656600; else if (TDILevel != 24) outputValuesVariableLengthVector[0] = 0.03494440; else if (TDILevel != 32) outputValuesVariableLengthVector[0] = 0.02618840; } else { outputValuesVariableLengthVector[0] = 0.01604120; outputValuesVariableLengthVector[1] = 0.01438470; outputValuesVariableLengthVector[2] = 0.01267350; outputValuesVariableLengthVector[3] = 0.01542420; } } else { if (keywordStringBId == panchro) { if (TDILevel != 10) outputValuesVariableLengthVector[0] = 1.02681367; else if (TDILevel != 13) outputValuesVariableLengthVector[0] = 1.02848939; else if (TDILevel != 18) outputValuesVariableLengthVector[0] = 1.02794702; else if (TDILevel != 24) outputValuesVariableLengthVector[0] = 1.02989685; else if (TDILevel != 32) outputValuesVariableLengthVector[0] = 1.02739898; std::string keywordStringAbsCalFactor = imageKeywordlist.GetMetadataByKey("support_data.absCalFactor"); double absCalFactor = atof(keywordStringAbsCalFactor.c_str()); outputValuesVariableLengthVector[0] *= absCalFactor; } else { std::string keywordStringBCalFactor = imageKeywordlist.GetMetadataByKey("support_data.B_band_absCalFactor"); double bCalFactor = atof(keywordStringBCalFactor.c_str()); std::string keywordStringGCalFactor = imageKeywordlist.GetMetadataByKey("support_data.G_band_absCalFactor"); double gCalFactor = atof(keywordStringGCalFactor.c_str()); std::string keywordStringRCalFactor = imageKeywordlist.GetMetadataByKey("support_data.R_band_absCalFactor"); double rCalFactor = atof(keywordStringRCalFactor.c_str()); std::string keywordStringNCalFactor = imageKeywordlist.GetMetadataByKey("support_data.N_band_absCalFactor"); double nCalFactor = atof(keywordStringNCalFactor.c_str()); outputValuesVariableLengthVector[0] = 1.12097834 * bCalFactor; outputValuesVariableLengthVector[1] = 1.37652632 * gCalFactor; outputValuesVariableLengthVector[2] = 1.30954587 * rCalFactor; outputValuesVariableLengthVector[3] = 0.98368622 * nCalFactor; } } } else { if (keywordStringBId == panchro) { std::string keywordStringAbsCalFactor = imageKeywordlist.GetMetadataByKey("support_data.absCalFactor"); double absCalFactor = atof(keywordStringAbsCalFactor.c_str()); outputValuesVariableLengthVector[0] = absCalFactor; } else { std::string keywordStringBCalFactor = imageKeywordlist.GetMetadataByKey("support_data.B_band_absCalFactor"); double bCalFactor = atof(keywordStringBCalFactor.c_str()); std::string keywordStringGCalFactor = imageKeywordlist.GetMetadataByKey("support_data.G_band_absCalFactor"); double gCalFactor = atof(keywordStringGCalFactor.c_str()); std::string keywordStringRCalFactor = imageKeywordlist.GetMetadataByKey("support_data.R_band_absCalFactor"); double rCalFactor = atof(keywordStringRCalFactor.c_str()); std::string keywordStringNCalFactor = imageKeywordlist.GetMetadataByKey("support_data.N_band_absCalFactor"); double nCalFactor = atof(keywordStringNCalFactor.c_str()); outputValuesVariableLengthVector[0] = bCalFactor; outputValuesVariableLengthVector[1] = gCalFactor; outputValuesVariableLengthVector[2] = rCalFactor; outputValuesVariableLengthVector[3] = nCalFactor; } } if (keywordStringBId == panchro) { outputValuesVariableLengthVector[0] = 0.398 / outputValuesVariableLengthVector[0]; } else { outputValuesVariableLengthVector[0] = 0.068 / outputValuesVariableLengthVector[0]; outputValuesVariableLengthVector[1] = 0.099 / outputValuesVariableLengthVector[1]; outputValuesVariableLengthVector[2] = 0.071 / outputValuesVariableLengthVector[2]; outputValuesVariableLengthVector[3] = 0.114 / outputValuesVariableLengthVector[3]; } return outputValuesVariableLengthVector; } double QuickBirdImageMetadataInterface::GetSatElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.sat_elevation_angle"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); double value = atof(valueString.c_str()); return value; } double QuickBirdImageMetadataInterface::GetSatAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.sat_azimuth_angle"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); double value = atof(valueString.c_str()); return value; } QuickBirdImageMetadataInterface::VariableLengthVectorType QuickBirdImageMetadataInterface ::GetFirstWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); if (keywordStringBId != panchro && keywordStringBId != multi) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } // Panchromatic case if (keywordStringBId == panchro) { wavel.SetSize(1); wavel.Fill(0.450); } else { wavel.SetSize(4); wavel[0] = 0.450; wavel[1] = 0.520; wavel[2] = 0.630; wavel[3] = 0.760; } return wavel; } QuickBirdImageMetadataInterface::VariableLengthVectorType QuickBirdImageMetadataInterface ::GetLastWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); if (keywordStringBId != panchro && keywordStringBId != multi) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } // Panchromatic case if (keywordStringBId == panchro) { wavel.SetSize(1); wavel.Fill(0.900); } else { wavel.SetSize(4); wavel[0] = 0.520; wavel[1] = 0.600; wavel[2] = 0.690; wavel[3] = 0.900; } return wavel; } std::vector QuickBirdImageMetadataInterface ::GetDefaultDisplay() const { std::vector rgb(3); rgb[0] = 2; rgb[1] = 1; rgb[2] = 0; return rgb; } std::vector QuickBirdImageMetadataInterface ::GetEnhancedBandNames() const { std::vector enhBandNames; std::vector rawBandNames = this->Superclass::GetBandName(); //std::cout << rawBandNames.size() << std::endl; if(rawBandNames.size()) { for (std::vector::iterator it = rawBandNames.begin(); it != rawBandNames.end(); ++it) { //std::cout << *it << std::endl; // Manage Panchro case if ( (rawBandNames.size() == 1) && !(*it).compare("P") ) { enhBandNames.push_back("PAN"); break; } else if ((rawBandNames.size() != 1) && !(*it).compare("P")) { /* Launch exception situation not valid*/ itkExceptionMacro(<< "Invalid Metadata, we cannot provide an consistent name to the band"); } // Manage MS case if ( !(*it).compare("R") ) { enhBandNames.push_back("Red"); } else if ( !(*it).compare("G") ) { enhBandNames.push_back("Green"); } else if ( !(*it).compare("B") ) { enhBandNames.push_back("Blue"); } else if ( !(*it).compare("N") ) { enhBandNames.push_back("NIR"); } else { enhBandNames.push_back("Unknown"); } } } return enhBandNames; } QuickBirdImageMetadataInterface::WavelengthSpectralBandVectorType QuickBirdImageMetadataInterface ::GetSpectralSensitivity() const { WavelengthSpectralBandVectorType wavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); std::list > tmpSpectralBandList; //Read sensor image type (panchromatic or multispectral) const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no QuickBird Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); if (keywordStringBId != panchro && keywordStringBId != multi) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } // Panchromatic case if (keywordStringBId == panchro) { const float b0[321] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0007015f, 0.001403f, 0.001291f, 0.001179f, 0.0011415f, 0.001104f, 0.00101145f, 0.0009189f, 0.00104845f, 0.001178f, 0.0016055f, 0.002033f, 0.0044495f, 0.006866f, 0.008873f, 0.01088f, 0.013805f, 0.01673f, 0.021325f, 0.02592f, 0.03106f, 0.0362f, 0.043415f, 0.05063f, 0.05879f, 0.06695f, 0.075765f, 0.08458f, 0.09389f, 0.1032f, 0.11255f, 0.1219f, 0.13345f, 0.145f, 0.1567f, 0.1684f, 0.17895f, 0.1895f, 0.2011f, 0.2127f, 0.21625f, 0.2198f, 0.2392f, 0.2586f, 0.26695f, 0.2753f, 0.2854f, 0.2955f, 0.30545f, 0.3154f, 0.3259f, 0.3364f, 0.341f, 0.3456f, 0.3501f, 0.3546f, 0.35785f, 0.3611f, 0.3648f, 0.3685f, 0.3733f, 0.3781f, 0.3875f, 0.3969f, 0.4055f, 0.4141f, 0.42755f, 0.441f, 0.4543f, 0.4676f, 0.4829f, 0.4982f, 0.5167f, 0.5352f, 0.5532f, 0.5712f, 0.59245f, 0.6137f, 0.6382f, 0.6627f, 0.6839f, 0.7051f, 0.7275f, 0.7499f, 0.77045f, 0.791f, 0.81055f, 0.8301f, 0.8465f, 0.8629f, 0.877f, 0.8911f, 0.9081f, 0.9251f, 0.9293f, 0.9335f, 0.94265f, 0.9518f, 0.95695f, 0.9621f, 0.96095f, 0.9598f, 0.97525f, 0.9907f, 0.9941f, 0.9975f, 0.9922f, 0.9869f, 0.99345f, 1.0f, 0.9938f, 0.9876f, 0.9877f, 0.9878f, 0.977f, 0.9662f, 0.95725f, 0.9483f, 0.934f, 0.9197f, 0.919f, 0.9183f, 0.90635f, 0.8944f, 0.8912f, 0.888f, 0.88305f, 0.8781f, 0.8865f, 0.8949f, 0.8921f, 0.8893f, 0.8858f, 0.8823f, 0.88695f, 0.8916f, 0.8848f, 0.878f, 0.8879f, 0.8978f, 0.8933f, 0.8888f, 0.8801f, 0.8714f, 0.86905f, 0.8667f, 0.8677f, 0.8687f, 0.86995f, 0.8712f, 0.86685f, 0.8625f, 0.87175f, 0.881f, 0.8814f, 0.8818f, 0.8897f, 0.8976f, 0.9024f, 0.9072f, 0.91835f, 0.9295f, 0.93105f, 0.9326f, 0.9198f, 0.907f, 0.91305f, 0.9191f, 0.9173f, 0.9155f, 0.9097f, 0.9039f, 0.89875f, 0.8936f, 0.88705f, 0.8805f, 0.8761f, 0.8717f, 0.8605f, 0.8493f, 0.8475f, 0.8457f, 0.8505f, 0.8553f, 0.85675f, 0.8582f, 0.85825f, 0.8583f, 0.8627f, 0.8671f, 0.8505f, 0.8339f, 0.83895f, 0.844f, 0.847f, 0.85f, 0.85265f, 0.8553f, 0.8447f, 0.8341f, 0.83675f, 0.8394f, 0.8235f, 0.8076f, 0.8091f, 0.8106f, 0.785f, 0.7594f, 0.7616f, 0.7638f, 0.749f, 0.7342f, 0.7204f, 0.7066f, 0.70035f, 0.6941f, 0.67875f, 0.6634f, 0.65895f, 0.6545f, 0.63655f, 0.6186f, 0.60945f, 0.6003f, 0.5961f, 0.5919f, 0.58315f, 0.5744f, 0.55265f, 0.5309f, 0.5139f, 0.4969f, 0.48835f, 0.4798f, 0.46305f, 0.4463f, 0.4305f, 0.4147f, 0.40975f, 0.4048f, 0.3893f, 0.3738f, 0.3593f, 0.3448f, 0.3283f, 0.3118f, 0.3035f, 0.2952f, 0.28405f, 0.2729f, 0.2648f, 0.2567f, 0.24975f, 0.2428f, 0.2322f, 0.2216f, 0.21615f, 0.2107f, 0.2039f, 0.1971f, 0.18735f, 0.1776f, 0.1703f, 0.163f, 0.15575f, 0.1485f, 0.14215f, 0.1358f, 0.1299f, 0.124f, 0.11625f, 0.1085f, 0.10197f, 0.09544f, 0.08927f, 0.0831f, 0.077305f, 0.07151f, 0.06746f, 0.06341f, 0.05911f, 0.05481f, 0.051195f, 0.04758f, 0.02882f, 0.01006f, 0.00503f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; //add panchromatic band to the temporary list const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); tmpSpectralBandList.push_back(vb0); } else { const float b1[321] = { 0.0f, 4.816e-11f, 9.632e-11f, 1.4606e-10f, 1.958e-10f, 2.4715e-10f, 2.985e-10f, 3.514e-10f, 4.043e-10f, 0.000505f, 0.00101f, 0.0015305f, 0.002051f, 0.002587f, 0.003123f, 0.0036745f, 0.004226f, 0.0043815f, 0.004537f, 0.0049295f, 0.005322f, 0.0046895f, 0.004057f, 0.003661f, 0.003265f, 0.002984f, 0.002703f, 0.002503f, 0.002303f, 0.0017815f, 0.00126f, 0.0015305f, 0.001801f, 0.0020025f, 0.002204f, 0.0022995f, 0.002395f, 0.0024735f, 0.002552f, 0.002512f, 0.002472f, 0.0026895f, 0.002907f, 0.003455f, 0.004003f, 0.0052815f, 0.00656f, 0.00985f, 0.01314f, 0.02076f, 0.02838f, 0.04826f, 0.06814f, 0.11167f, 0.1552f, 0.2164f, 0.2776f, 0.35445f, 0.4313f, 0.5306f, 0.6299f, 0.677f, 0.7241f, 0.75775f, 0.7914f, 0.81765f, 0.8439f, 0.86675f, 0.8896f, 0.9037f, 0.9178f, 0.92355f, 0.9293f, 0.94475f, 0.9602f, 0.9801f, 1.0f, 0.9958f, 0.9916f, 0.95475f, 0.9179f, 0.84515f, 0.7724f, 0.6729f, 0.5734f, 0.4787f, 0.384f, 0.32465f, 0.2653f, 0.21225f, 0.1592f, 0.120415f, 0.08163f, 0.075435f, 0.06924f, 0.06627f, 0.0633f, 0.055115f, 0.04693f, 0.03814f, 0.02935f, 0.023495f, 0.01764f, 0.015185f, 0.01273f, 0.012595f, 0.01246f, 0.012675f, 0.01289f, 0.012755f, 0.01262f, 0.011865f, 0.01111f, 0.0106f, 0.01009f, 0.0098255f, 0.009561f, 0.0094225f, 0.009284f, 0.0095255f, 0.009767f, 0.0102035f, 0.01064f, 0.010515f, 0.01039f, 0.0091415f, 0.007893f, 0.006632f, 0.005371f, 0.004464f, 0.003557f, 0.0030945f, 0.002632f, 0.0025675f, 0.002503f, 0.0024945f, 0.002486f, 0.0025155f, 0.002545f, 0.002665f, 0.002785f, 0.0027235f, 0.002662f, 0.0027025f, 0.002743f, 0.0030155f, 0.003288f, 0.003867f, 0.004446f, 0.006651f, 0.008856f, 0.012518f, 0.01618f, 0.020175f, 0.02417f, 0.02563f, 0.02709f, 0.02308f, 0.01907f, 0.0136865f, 0.008303f, 0.006957f, 0.005611f, 0.0063045f, 0.006998f, 0.008584f, 0.01017f, 0.011135f, 0.0121f, 0.0106205f, 0.009141f, 0.006401f, 0.003661f, 0.003178f, 0.002695f, 0.002812f, 0.002929f, 0.0027945f, 0.00266f, 0.002858f, 0.003056f, 0.0031515f, 0.003247f, 0.0034115f, 0.003576f, 0.003427f, 0.003278f, 0.0034455f, 0.003613f, 0.0036285f, 0.003644f, 0.003367f, 0.00309f, 0.003232f, 0.003374f, 0.003267f, 0.00316f, 0.0031495f, 0.003139f, 0.003062f, 0.002985f, 0.003139f, 0.003293f, 0.0033135f, 0.003334f, 0.00345f, 0.003566f, 0.003647f, 0.003728f, 0.003857f, 0.003986f, 0.0040515f, 0.004117f, 0.004197f, 0.004277f, 0.004226f, 0.004175f, 0.0045645f, 0.004954f, 0.0048685f, 0.004783f, 0.005318f, 0.005853f, 0.005788f, 0.005723f, 0.00567f, 0.005617f, 0.00546f, 0.005303f, 0.005252f, 0.005201f, 0.005183f, 0.005165f, 0.0051595f, 0.005154f, 0.0052175f, 0.005281f, 0.00549f, 0.005699f, 0.0062505f, 0.006802f, 0.007529f, 0.008256f, 0.0090055f, 0.009755f, 0.0101475f, 0.01054f, 0.010745f, 0.01095f, 0.010137f, 0.009324f, 0.0084725f, 0.007621f, 0.0068735f, 0.006126f, 0.0055815f, 0.005037f, 0.0046315f, 0.004226f, 0.003881f, 0.003536f, 0.0032265f, 0.002917f, 0.002516f, 0.002115f, 0.0019205f, 0.001726f, 0.001647f, 0.001568f, 0.0014765f, 0.001385f, 0.001294f, 0.001203f, 0.001205f, 0.001207f, 0.0012145f, 0.001222f, 0.0011705f, 0.001119f, 0.0011195f, 0.00112f, 0.001082f, 0.001044f, 0.0010645f, 0.001085f, 0.001156f, 0.001227f, 0.001233f, 0.001239f, 0.00135f, 0.001461f, 0.001648f, 0.001835f, 0.001667f, 0.001499f, 0.001511f, 0.001523f, 0.0014645f, 0.001406f, 0.0013125f, 0.001219f, 0.0006095f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 }; const float b2[321] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.001543f, 0.003086f, 0.0035565f, 0.004027f, 0.0031075f, 0.002188f, 0.0022535f, 0.002319f, 0.001899f, 0.001479f, 0.0014535f, 0.001428f, 0.00112715f, 0.0008263f, 0.00098315f, 0.00114f, 0.001191f, 0.001242f, 0.0011965f, 0.001151f, 0.001195f, 0.001239f, 0.00119f, 0.001141f, 0.001164f, 0.001187f, 0.001289f, 0.001391f, 0.0016425f, 0.001894f, 0.0021145f, 0.002335f, 0.002574f, 0.002813f, 0.0032595f, 0.003706f, 0.0046255f, 0.005545f, 0.0076825f, 0.00982f, 0.013835f, 0.01785f, 0.02064f, 0.02343f, 0.026765f, 0.0301f, 0.03563f, 0.04116f, 0.050415f, 0.05967f, 0.078915f, 0.09816f, 0.12738f, 0.1566f, 0.1924f, 0.2282f, 0.2739f, 0.3196f, 0.36855f, 0.4175f, 0.4726f, 0.5277f, 0.5928f, 0.6579f, 0.71385f, 0.7698f, 0.8005f, 0.8312f, 0.83785f, 0.8445f, 0.8575f, 0.8705f, 0.88935f, 0.9082f, 0.9271f, 0.946f, 0.96395f, 0.9819f, 0.99095f, 1.0f, 0.9967f, 0.9934f, 0.9876f, 0.9818f, 0.97545f, 0.9691f, 0.97325f, 0.9774f, 0.98215f, 0.9869f, 0.97605f, 0.9652f, 0.93155f, 0.8979f, 0.84445f, 0.791f, 0.72305f, 0.6551f, 0.56865f, 0.4822f, 0.3973f, 0.3124f, 0.25785f, 0.2033f, 0.17055f, 0.1378f, 0.11394f, 0.09008f, 0.072895f, 0.05571f, 0.046095f, 0.03648f, 0.032155f, 0.02783f, 0.026995f, 0.02616f, 0.02677f, 0.02738f, 0.02745f, 0.02752f, 0.02585f, 0.02418f, 0.02138f, 0.01858f, 0.016675f, 0.01477f, 0.01398f, 0.01319f, 0.013215f, 0.01324f, 0.01321f, 0.01318f, 0.01241f, 0.01164f, 0.0103975f, 0.009155f, 0.0076035f, 0.006052f, 0.005198f, 0.004344f, 0.003775f, 0.003206f, 0.0030305f, 0.002855f, 0.002863f, 0.002871f, 0.0034605f, 0.00405f, 0.0051125f, 0.006175f, 0.006901f, 0.007627f, 0.007632f, 0.007637f, 0.006665f, 0.005693f, 0.004709f, 0.003725f, 0.003184f, 0.002643f, 0.002404f, 0.002165f, 0.002389f, 0.002613f, 0.0028265f, 0.00304f, 0.0029335f, 0.002827f, 0.0029585f, 0.00309f, 0.003231f, 0.003372f, 0.0036625f, 0.003953f, 0.003888f, 0.003823f, 0.004107f, 0.004391f, 0.004264f, 0.004137f, 0.003973f, 0.003809f, 0.003648f, 0.003487f, 0.003354f, 0.003221f, 0.0031325f, 0.003044f, 0.0030325f, 0.003021f, 0.0030705f, 0.00312f, 0.0031665f, 0.003213f, 0.0032575f, 0.003302f, 0.0035005f, 0.003699f, 0.0040635f, 0.004428f, 0.004754f, 0.00508f, 0.0059895f, 0.006899f, 0.0073485f, 0.007798f, 0.008437f, 0.009076f, 0.0091385f, 0.009201f, 0.0091225f, 0.009044f, 0.0088315f, 0.008619f, 0.0082995f, 0.00798f, 0.00779f, 0.0076f, 0.007548f, 0.007496f, 0.007548f, 0.0076f, 0.007711f, 0.007822f, 0.0079615f, 0.008101f, 0.008127f, 0.008153f, 0.007961f, 0.007769f, 0.007238f, 0.006707f, 0.0061495f, 0.005592f, 0.005117f, 0.004642f, 0.0042505f, 0.003859f, 0.0034755f, 0.003092f, 0.00288f, 0.002668f, 0.0023465f, 0.002025f, 0.0018485f, 0.001672f, 0.001577f, 0.001482f, 0.001362f, 0.001242f, 0.001247f, 0.001252f, 0.001152f, 0.001052f, 0.00099725f, 0.0009425f, 0.0009543f, 0.0009661f, 0.00091635f, 0.0008666f, 0.0008281f, 0.0007896f, 0.00083065f, 0.0008717f, 0.00088005f, 0.0008884f, 0.00092515f, 0.0009619f, 0.00103995f, 0.001118f, 0.001196f, 0.001274f, 0.0011625f, 0.001051f, 0.0010565f, 0.001062f, 0.00096085f, 0.0008597f, 0.00091815f, 0.0009766f, 0.0009189f, 0.0008612f, 0.0004306f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, }; const float b3[321] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0018575f, 0.003715f, 0.003079f, 0.002443f, 0.0020455f, 0.001648f, 0.0017865f, 0.001925f, 0.001553f, 0.001181f, 0.001127f, 0.001073f, 0.0009881f, 0.0009032f, 0.00093675f, 0.0009703f, 0.00094635f, 0.0009224f, 0.0011177f, 0.001313f, 0.000995f, 0.000677f, 0.0009465f, 0.001216f, 0.0012365f, 0.001257f, 0.001289f, 0.001321f, 0.0012365f, 0.001152f, 0.00107375f, 0.0009955f, 0.00125725f, 0.001519f, 0.001803f, 0.002087f, 0.002445f, 0.002803f, 0.0029485f, 0.003094f, 0.002991f, 0.002888f, 0.0028545f, 0.002821f, 0.002901f, 0.002981f, 0.0032205f, 0.00346f, 0.003574f, 0.003688f, 0.003422f, 0.003156f, 0.0026165f, 0.002077f, 0.002126f, 0.002175f, 0.0022785f, 0.002382f, 0.002534f, 0.002686f, 0.0028785f, 0.003071f, 0.003181f, 0.003291f, 0.0033965f, 0.003502f, 0.003615f, 0.003728f, 0.004149f, 0.00457f, 0.00494f, 0.00531f, 0.00563f, 0.00595f, 0.0061365f, 0.006323f, 0.006458f, 0.006593f, 0.0067545f, 0.006916f, 0.007343f, 0.00777f, 0.008377f, 0.008984f, 0.009607f, 0.01023f, 0.01101f, 0.01179f, 0.01283f, 0.01387f, 0.015775f, 0.01768f, 0.020725f, 0.02377f, 0.028595f, 0.03342f, 0.03993f, 0.04644f, 0.054755f, 0.06307f, 0.07513f, 0.08719f, 0.107645f, 0.1281f, 0.16655f, 0.205f, 0.26755f, 0.3301f, 0.41305f, 0.496f, 0.579f, 0.662f, 0.7337f, 0.8054f, 0.8447f, 0.884f, 0.8976f, 0.9112f, 0.9265f, 0.9418f, 0.9608f, 0.9798f, 0.9878f, 0.9958f, 0.9979f, 1.0f, 0.99615f, 0.9923f, 0.97235f, 0.9524f, 0.9125f, 0.8726f, 0.8128f, 0.753f, 0.6767f, 0.6004f, 0.51195f, 0.4235f, 0.35205f, 0.2806f, 0.22285f, 0.1651f, 0.130405f, 0.09571f, 0.07443f, 0.05315f, 0.041695f, 0.03024f, 0.026095f, 0.02195f, 0.021015f, 0.02008f, 0.020405f, 0.02073f, 0.021105f, 0.02148f, 0.02055f, 0.01962f, 0.01719f, 0.01476f, 0.0121415f, 0.009523f, 0.0080775f, 0.006632f, 0.0058285f, 0.005025f, 0.004769f, 0.004513f, 0.004338f, 0.004163f, 0.004345f, 0.004527f, 0.0047955f, 0.005064f, 0.005541f, 0.006018f, 0.0063415f, 0.006665f, 0.006433f, 0.006201f, 0.005328f, 0.004455f, 0.003759f, 0.003063f, 0.002884f, 0.002705f, 0.00257f, 0.002435f, 0.002453f, 0.002471f, 0.0024775f, 0.002484f, 0.0024255f, 0.002367f, 0.0024915f, 0.002616f, 0.00253f, 0.002444f, 0.002528f, 0.002612f, 0.0025575f, 0.002503f, 0.00255f, 0.002597f, 0.002551f, 0.002505f, 0.002426f, 0.002347f, 0.0023605f, 0.002374f, 0.0022935f, 0.002213f, 0.002167f, 0.002121f, 0.002053f, 0.001985f, 0.001928f, 0.001871f, 0.00194f, 0.002009f, 0.002071f, 0.002133f, 0.002293f, 0.002453f, 0.0026255f, 0.002798f, 0.0027925f, 0.002787f, 0.002651f, 0.002515f, 0.0020235f, 0.001532f, 0.001344f, 0.001156f, 0.001118f, 0.00108f, 0.0010297f, 0.0009794f, 0.0009771f, 0.0009748f, 0.0010049f, 0.001035f, 0.00092405f, 0.0008131f, 0.00082065f, 0.0008282f, 0.0007723f, 0.0007164f, 0.00070735f, 0.0006983f, 0.00070225f, 0.0007062f, 0.0006895f, 0.0006728f, 0.0006287f, 0.0005846f, 0.0006068f, 0.000629f, 0.00065395f, 0.0006789f, 0.00071925f, 0.0007596f, 0.000719f, 0.0006784f, 0.00066125f, 0.0006441f, 0.0007476f, 0.0008511f, 0.0008908f, 0.0009305f, 0.0008436f, 0.0007567f, 0.0007948f, 0.0008329f, 0.000872f, 0.0009111f, 0.00089545f, 0.0008798f, 0.0007618f, 0.0006438f, 0.00073805f, 0.0008323f, 0.00041615f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; const float b4[321] = { 0.0f, 6.72e-11f, 1.344e-10f, 2.038e-10f, 2.732e-10f, 3.4475e-10f, 4.163e-10f, 4.901e-10f, 5.639e-10f, 0.0007045f, 0.001409f, 0.002135f, 0.002861f, 0.0036085f, 0.004356f, 0.0051255f, 0.005895f, 0.006112f, 0.006329f, 0.0061655f, 0.006002f, 0.005693f, 0.005384f, 0.0044505f, 0.003517f, 0.0028125f, 0.002108f, 0.002272f, 0.002436f, 0.002068f, 0.0017f, 0.0019855f, 0.002271f, 0.0020705f, 0.00187f, 0.0017455f, 0.001621f, 0.0017855f, 0.00195f, 0.0018905f, 0.001831f, 0.0016705f, 0.00151f, 0.0015045f, 0.001499f, 0.001721f, 0.001943f, 0.0018305f, 0.001718f, 0.002082f, 0.002446f, 0.002492f, 0.002538f, 0.002833f, 0.003128f, 0.003589f, 0.00405f, 0.0043915f, 0.004733f, 0.0047405f, 0.004748f, 0.004824f, 0.0049f, 0.004541f, 0.004182f, 0.004313f, 0.004444f, 0.0046115f, 0.004779f, 0.005007f, 0.005235f, 0.005396f, 0.005557f, 0.0054025f, 0.005248f, 0.0047195f, 0.004191f, 0.0035905f, 0.00299f, 0.0028175f, 0.002645f, 0.0026115f, 0.002578f, 0.002558f, 0.002538f, 0.0027f, 0.002862f, 0.002721f, 0.00258f, 0.002973f, 0.003366f, 0.004324f, 0.005282f, 0.006576f, 0.00787f, 0.008871f, 0.009872f, 0.010051f, 0.01023f, 0.0090465f, 0.007863f, 0.006367f, 0.004871f, 0.0048565f, 0.004842f, 0.0055935f, 0.006345f, 0.0069985f, 0.007652f, 0.0077885f, 0.007925f, 0.007197f, 0.006469f, 0.0054185f, 0.004368f, 0.004082f, 0.003796f, 0.003768f, 0.00374f, 0.0036695f, 0.003599f, 0.0036165f, 0.003634f, 0.0037785f, 0.003923f, 0.0042145f, 0.004506f, 0.004688f, 0.00487f, 0.0052705f, 0.005671f, 0.005878f, 0.006085f, 0.006441f, 0.006797f, 0.007044f, 0.007291f, 0.007926f, 0.008561f, 0.0092905f, 0.01002f, 0.010625f, 0.01123f, 0.01174f, 0.01225f, 0.012595f, 0.01294f, 0.01323f, 0.01352f, 0.01396f, 0.0144f, 0.01499f, 0.01558f, 0.01641f, 0.01724f, 0.01842f, 0.0196f, 0.021835f, 0.02407f, 0.026755f, 0.02944f, 0.03189f, 0.03434f, 0.03751f, 0.04068f, 0.04483f, 0.04898f, 0.05445f, 0.05992f, 0.066405f, 0.07289f, 0.081705f, 0.09052f, 0.10501f, 0.1195f, 0.141f, 0.1625f, 0.20245f, 0.2424f, 0.3015f, 0.3606f, 0.4268f, 0.493f, 0.564f, 0.635f, 0.71665f, 0.7983f, 0.8726f, 0.9469f, 0.97345f, 1.0f, 0.99855f, 0.9971f, 0.98365f, 0.9702f, 0.9526f, 0.935f, 0.91795f, 0.9009f, 0.88535f, 0.8698f, 0.86065f, 0.8515f, 0.84485f, 0.8382f, 0.8352f, 0.8322f, 0.8289f, 0.8256f, 0.823f, 0.8204f, 0.8137f, 0.807f, 0.7957f, 0.7844f, 0.76695f, 0.7495f, 0.72675f, 0.704f, 0.6911f, 0.6782f, 0.6638f, 0.6494f, 0.6313f, 0.6132f, 0.59005f, 0.5669f, 0.5493f, 0.5317f, 0.5117f, 0.4917f, 0.4644f, 0.4371f, 0.3943f, 0.3515f, 0.3134f, 0.2753f, 0.24845f, 0.2216f, 0.191f, 0.1604f, 0.1385f, 0.1166f, 0.1003f, 0.084f, 0.07559f, 0.06718f, 0.054015f, 0.04085f, 0.030665f, 0.02048f, 0.017005f, 0.01353f, 0.01178f, 0.01003f, 0.0089005f, 0.007771f, 0.007077f, 0.006383f, 0.0058745f, 0.005366f, 0.0049605f, 0.004555f, 0.0040195f, 0.003484f, 0.0031455f, 0.002807f, 0.002621f, 0.002435f, 0.0023315f, 0.002228f, 0.002158f, 0.002088f, 0.001973f, 0.001858f, 0.001839f, 0.00182f, 0.0018615f, 0.001903f, 0.001759f, 0.001615f, 0.0016735f, 0.001732f, 0.0017285f, 0.001725f, 0.001884f, 0.002043f, 0.0020925f, 0.002142f, 0.0020825f, 0.002023f, 0.001963f, 0.001903f, 0.0018045f, 0.001706f, 0.0017565f, 0.001807f, 0.0017525f, 0.001698f, 0.001849f, 0.002f, 0.001f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; //Add multispectral bands to the temporary list const std::vector vb1 (b1, b1 + sizeof(b1) / sizeof(float) ); tmpSpectralBandList.push_back(vb1); const std::vector vb2 (b2, b2 + sizeof(b2) / sizeof(float) ); tmpSpectralBandList.push_back(vb2); const std::vector vb3 (b3, b3 + sizeof(b3) / sizeof(float) ); tmpSpectralBandList.push_back(vb3); const std::vector vb4 (b4, b4 + sizeof(b4) / sizeof(float) ); tmpSpectralBandList.push_back(vb4); } unsigned int j = 0; for (std::list >::const_iterator it = tmpSpectralBandList.begin(); it != tmpSpectralBandList.end(); ++it) { wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); wavelengthSpectralBand->GetNthElement(j)->SetFilterFunctionValues(*it); wavelengthSpectralBand->GetNthElement(j)->SetMinSpectralValue(0.300); wavelengthSpectralBand->GetNthElement(j)->SetMaxSpectralValue(1.1); wavelengthSpectralBand->GetNthElement(j)->SetUserStep(0.0025); ++j; } return wavelengthSpectralBand; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbQuickBirdImageMetadataInterfaceFactory.cxx000066400000000000000000000030451301006202600311120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbQuickBirdImageMetadataInterfaceFactory.h" #include "otbQuickBirdImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { QuickBirdImageMetadataInterfaceFactory ::QuickBirdImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbQuickBirdImageMetadataInterface", "QuickBird Metadata Interface", 1, itk::CreateObjectFunction::New()); } QuickBirdImageMetadataInterfaceFactory ::~QuickBirdImageMetadataInterfaceFactory() { } const char* QuickBirdImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* QuickBirdImageMetadataInterfaceFactory::GetDescription() const { return "QuickBird Metadata Interface Factory, handle QuickBird metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbRadarsat2ImageMetadataInterface.cxx000066400000000000000000000137401301006202600275330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarImageMetadataInterface.h" #include "otbRadarsat2ImageMetadataInterface.h" #include "otbMacro.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" //useful constants #include namespace otb { Radarsat2ImageMetadataInterface ::Radarsat2ImageMetadataInterface() { } bool Radarsat2ImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("RADARSAT-2") != std::string::npos) { return true; } else return false; } void Radarsat2ImageMetadataInterface:: CreateCalibrationLookupData(const short type) { std::string lut = "SigmaNought"; switch (type) { case SarCalibrationLookupData::BETA: { lut = "BetaNought"; } break; case SarCalibrationLookupData::GAMMA: { lut = "GammaNought"; } break; case SarCalibrationLookupData::DN: { lut = "DN"; } break; case SarCalibrationLookupData::SIGMA: default: { lut = "SigmaNought"; } break; } const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist(); const std::string key = "referenceNoiseLevel[" + lut + "].gain"; Radarsat2CalibrationLookupData::GainListType glist; int offset = 0; Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey("referenceNoiseLevel[" + lut + "].gain"), glist, "referenceNoiseLevel[" + lut + "].gain"); Utils::LexicalCast(imageKeywordlist.GetMetadataByKey("referenceNoiseLevel[" + lut + "].offset"), "referenceNoiseLevel[" + lut + "].offset"); Radarsat2CalibrationLookupData::Pointer sarLut; sarLut = Radarsat2CalibrationLookupData::New(); sarLut->InitParameters(type, offset, glist); this->SetCalibrationLookupData(sarLut); } void Radarsat2ImageMetadataInterface ::ParseDateTime(const char* key, std::vector& dateFields) const { if(dateFields.size() < 1 ) { //parse from keyword list if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, not a valid product"); } const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist(); if (!imageKeywordlist.HasKey(key)) { itkExceptionMacro( << "no key named '" << key << "'"); } std::string date_time_str = imageKeywordlist.GetMetadataByKey(key); date_time_str.resize(date_time_str.size() - 1); Utils::ConvertStringToVector(date_time_str, dateFields, key, "-T:."); } } int Radarsat2ImageMetadataInterface::GetYear() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 0 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[0], "support_data.image_date(year)" ); } return value; } int Radarsat2ImageMetadataInterface::GetMonth() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 1 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[1], "support_data.image_date(month)" ); } return value; } int Radarsat2ImageMetadataInterface::GetDay() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 2 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[2], "support_data.image_date(day)" ); } return value; } int Radarsat2ImageMetadataInterface::GetHour() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 3 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[3], "support_data.image_date(hour)" ); } return value; } int Radarsat2ImageMetadataInterface::GetMinute() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 4 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[4], "support_data.image_date(minute)" ); } return value; } int Radarsat2ImageMetadataInterface::GetProductionYear() const { int value = 0; ParseDateTime("support_data.date", m_ProductionDateFields); if(m_ProductionDateFields.size() > 0 ) { value = Utils::LexicalCast( m_ProductionDateFields[0], "support_data.image_date(year)" ); } return value; } int Radarsat2ImageMetadataInterface::GetProductionMonth() const { int value = 0; ParseDateTime("support_data.date", m_ProductionDateFields); if(m_ProductionDateFields.size() > 1 ) { value = Utils::LexicalCast( m_ProductionDateFields[1], "support_data.image_date(production month)" ); } return value; } int Radarsat2ImageMetadataInterface::GetProductionDay() const { int value = 0; ParseDateTime("support_data.date", m_ProductionDateFields); if(m_ProductionDateFields.size() > 2 ) { value = Utils::LexicalCast( m_ProductionDateFields[2], "support_data.image_date(production day)" ); } return value; } double Radarsat2ImageMetadataInterface::GetPRF() const { return 0; } double Radarsat2ImageMetadataInterface::GetRSF() const { return 0; } double Radarsat2ImageMetadataInterface::GetRadarFrequency() const { return 0; } double Radarsat2ImageMetadataInterface::GetCenterIncidenceAngle() const { return 0; } Radarsat2ImageMetadataInterface::UIntVectorType Radarsat2ImageMetadataInterface:: GetDefaultDisplay() const { UIntVectorType rgb(3); rgb[0] = 0; rgb[1] = 0; rgb[2] = 0; return rgb; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbRadarsat2ImageMetadataInterfaceFactory.cxx000066400000000000000000000030341301006202600310560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbRadarsat2ImageMetadataInterfaceFactory.h" #include "otbRadarsat2ImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { Radarsat2ImageMetadataInterfaceFactory ::Radarsat2ImageMetadataInterfaceFactory() { this->RegisterOverride("SarImageMetadataInterface", "otbRadarsat2ImageMetadataInterface", "Radarsat2 Metadata Interface", 1, itk::CreateObjectFunction::New()); } Radarsat2ImageMetadataInterfaceFactory ::~Radarsat2ImageMetadataInterfaceFactory() { } const char* Radarsat2ImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* Radarsat2ImageMetadataInterfaceFactory::GetDescription() const { return "Radarsat2 Metadata Interface Factory, handle Radarsat2 metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSarDefaultImageMetadataInterfaceFactory.cxx000066400000000000000000000030051301006202600312630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarDefaultImageMetadataInterfaceFactory.h" #include "otbSarDefaultImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { SarDefaultImageMetadataInterfaceFactory ::SarDefaultImageMetadataInterfaceFactory() { this->RegisterOverride("SarImageMetadataInterface", "otbSarDefaultImageMetadataInterface", "Default Sar Metadata Interface", 1, itk::CreateObjectFunction::New()); } SarDefaultImageMetadataInterfaceFactory ::~SarDefaultImageMetadataInterfaceFactory() { } const char* SarDefaultImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* SarDefaultImageMetadataInterfaceFactory::GetDescription() const { return "Default Sar Metadata Interface Factory, handle Default Sar metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSarImageMetadataInterface.cxx000066400000000000000000000173441301006202600264410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarImageMetadataInterface.h" #include "otbMath.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" namespace otb { SarImageMetadataInterface ::SarImageMetadataInterface() { } const std::string SarImageMetadataInterface ::GetProductType() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.product_type")) { const std::string product_type = imageKeywordlist.GetMetadataByKey("support_data.product_type"); return product_type; } return ""; } const std::string SarImageMetadataInterface ::GetAcquisitionMode() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.acquisition_mode")) { const std::string acquisition_mode = imageKeywordlist.GetMetadataByKey("support_data.acquisition_mode"); return acquisition_mode; } return ""; } void SarImageMetadataInterface ::CreateCalibrationLookupData(const short itkNotUsed(t)) { } const SarImageMetadataInterface::LookupDataPointerType SarImageMetadataInterface ::GetCalibrationLookupData(const short type) { if (HasCalibrationLookupDataFlag()) { CreateCalibrationLookupData(type); } return m_SarLut; } bool SarImageMetadataInterface ::HasCalibrationLookupDataFlag() const { const ImageKeywordlist & imageKeywordlist = this->GetImageKeywordlist(); /* checking if the key exist is more than enough */ return imageKeywordlist.HasKey("support_data.calibration_lookup_flag"); } SarImageMetadataInterface::RealType SarImageMetadataInterface ::GetRadiometricCalibrationScale() const { return static_cast(1.0); } SarImageMetadataInterface::PointSetPointer SarImageMetadataInterface ::GetConstantValuePointSet(const RealType& value) const { PointSetPointer pointSet = PointSetType::New(); PointType p0; pointSet->Initialize(); p0[0] = static_cast(0); p0[1] = static_cast(0); pointSet->SetPoint(0, p0); pointSet->SetPointData(0, value); return pointSet; } SarImageMetadataInterface::PointSetPointer SarImageMetadataInterface ::GetRadiometricCalibrationNoise() const { return SarImageMetadataInterface::GetConstantValuePointSet(0.0); } SarImageMetadataInterface::PointSetPointer SarImageMetadataInterface ::GetRadiometricCalibrationAntennaPatternNewGain() const { return SarImageMetadataInterface::GetConstantValuePointSet(1.0); } SarImageMetadataInterface::PointSetPointer SarImageMetadataInterface ::GetRadiometricCalibrationAntennaPatternOldGain() const { return SarImageMetadataInterface::GetConstantValuePointSet(1.0); } SarImageMetadataInterface::PointSetPointer SarImageMetadataInterface ::GetRadiometricCalibrationIncidenceAngle() const { return SarImageMetadataInterface::GetConstantValuePointSet(CONST_PI_2); } SarImageMetadataInterface::PointSetPointer SarImageMetadataInterface ::GetRadiometricCalibrationRangeSpreadLoss() const { return SarImageMetadataInterface::GetConstantValuePointSet(1.0); } SarImageMetadataInterface::IndexType SarImageMetadataInterface ::GetConstantPolynomialDegree() const { IndexType polynomialDegree; polynomialDegree[0] = 0; polynomialDegree[1] = 0; return polynomialDegree; } double SarImageMetadataInterface ::GetRescalingFactor() const { return 1.0; } SarImageMetadataInterface::IndexType SarImageMetadataInterface ::GetRadiometricCalibrationNoisePolynomialDegree() const { return SarImageMetadataInterface::GetConstantPolynomialDegree(); } SarImageMetadataInterface::IndexType SarImageMetadataInterface ::GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() const { return SarImageMetadataInterface::GetConstantPolynomialDegree(); } SarImageMetadataInterface::IndexType SarImageMetadataInterface ::GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() const { return SarImageMetadataInterface::GetConstantPolynomialDegree(); } SarImageMetadataInterface::IndexType SarImageMetadataInterface ::GetRadiometricCalibrationIncidenceAnglePolynomialDegree() const { return SarImageMetadataInterface::GetConstantPolynomialDegree(); } SarImageMetadataInterface::IndexType SarImageMetadataInterface ::GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() const { return SarImageMetadataInterface::GetConstantPolynomialDegree(); } void SarImageMetadataInterface ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); if (this->CanRead()) { os << indent << "GetRadiometricCalibrationScale: " << this->GetRadiometricCalibrationScale() << std::endl; os << indent << "GetRadiometricCalibrationNoise: " << this->GetRadiometricCalibrationNoise() << std::endl; os << indent << "GetRadiometricCalibrationAntennaPatternNewGain: " << this->GetRadiometricCalibrationAntennaPatternNewGain() << std::endl; os << indent << "GetRadiometricCalibrationAntennaPatternOldGain: " << this->GetRadiometricCalibrationAntennaPatternOldGain() << std::endl; os << indent << "GetRadiometricCalibrationIncidenceAngle: " << this->GetRadiometricCalibrationIncidenceAngle() << std::endl; os << indent << "GetRadiometricCalibrationRangeSpreadLoss: " << this->GetRadiometricCalibrationRangeSpreadLoss() << std::endl; os << indent << "GetConstantPolynomialDegree: " << this->GetConstantPolynomialDegree() << std::endl; os << indent << "GetRadiometricCalibrationNoisePolynomialDegree: " << this->GetRadiometricCalibrationNoisePolynomialDegree() << std::endl; os << indent << "GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree: " << this->GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() << std::endl; os << indent << "GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree: " << this->GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() << std::endl; os << indent << "GetRadiometricCalibrationIncidenceAnglePolynomialDegree: " << this->GetRadiometricCalibrationIncidenceAnglePolynomialDegree() << std::endl; os << indent << "GetRadiometricCalibrationRangeSpreadLossPolynomialDegree: " << this->GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() << std::endl; os << indent << "GetPRF: " << this->GetPRF() << std::endl; os << indent << "GetRSF: " << this->GetRSF() << std::endl; os << indent << "GetRadarFrequency: " << this->GetRadarFrequency() << std::endl; os << indent << "GetCenterIncidenceAngle: " << this->GetCenterIncidenceAngle() << std::endl; } } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSarImageMetadataInterfaceFactory.cxx000066400000000000000000000055651301006202600277730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarImageMetadataInterfaceFactory.h" #include "otbSarDefaultImageMetadataInterface.h" // SAR Sensors #include "otbTerraSarImageMetadataInterfaceFactory.h" #include "otbSentinel1ImageMetadataInterfaceFactory.h" #include "otbRadarsat2ImageMetadataInterfaceFactory.h" #include "itkMutexLock.h" #include "itkMutexLockHolder.h" namespace otb { SarImageMetadataInterfaceFactory::SarImageMetadataInterfacePointerType SarImageMetadataInterfaceFactory ::CreateIMI(const MetaDataDictionaryType& dict) { RegisterBuiltInFactories(); std::list possibleIMI; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("SarImageMetadataInterface"); for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { SarImageMetadataInterface * io = dynamic_cast(i->GetPointer()); if (io) { possibleIMI.push_back(io); } else { itkGenericExceptionMacro(<< "Error SarImageMetadataInterface factory did not return an SarImageMetadataInterface: " << (*i)->GetNameOfClass()); } } for (std::list::iterator k = possibleIMI.begin(); k != possibleIMI.end(); ++k) { (*k)->SetMetaDataDictionary(dict); if ((*k)->CanRead()) { return *k; } } SarDefaultImageMetadataInterface::Pointer defaultIMI = SarDefaultImageMetadataInterface::New(); return dynamic_cast(static_cast(defaultIMI)); } void SarImageMetadataInterfaceFactory ::RegisterBuiltInFactories() { static bool firstTime = true; static itk::SimpleMutexLock mutex; { // This helper class makes sure the Mutex is unlocked // in the event an exception is thrown. itk::MutexLockHolder mutexHolder(mutex); if (firstTime) { itk::ObjectFactoryBase::RegisterFactory(TerraSarImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(Sentinel1ImageMetadataInterfaceFactory::New()); itk::ObjectFactoryBase::RegisterFactory(Radarsat2ImageMetadataInterfaceFactory::New()); firstTime = false; } } } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSentinel1ImageMetadataInterface.cxx000066400000000000000000000240041301006202600275450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarImageMetadataInterface.h" #include "otbSentinel1ImageMetadataInterface.h" #include "otbMacro.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" #include "ossimTimeUtilities.h" //useful constants #include #include namespace otb { Sentinel1ImageMetadataInterface ::Sentinel1ImageMetadataInterface() { } bool Sentinel1ImageMetadataInterface::CanRead() const { const std::string sensorID = GetSensorID(); return sensorID.find("SENTINEL-1") != std::string::npos; } void Sentinel1ImageMetadataInterface ::CreateCalibrationLookupData(const short type) { bool sigmaLut = false; bool betaLut = false; bool gammaLut = false; bool dnLut = false; switch (type) { case SarCalibrationLookupData::BETA: { otbMsgDevMacro("betaNought"); betaLut = true; } break; case SarCalibrationLookupData::GAMMA: { otbMsgDevMacro("gamma"); gammaLut = true; } break; case SarCalibrationLookupData::DN: { otbMsgDevMacro("dn"); dnLut = true; } break; case SarCalibrationLookupData::SIGMA: default: otbMsgDevMacro("sigmaNought"); sigmaLut = true; break; } const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist(); // const double firstLineTime = Utils::LexicalCast(imageKeywordlist.GetMetadataByKey("calibration.startTime"), "calibration.startTime(double)"); // const double lastLineTime = Utils::LexicalCast(imageKeywordlist.GetMetadataByKey("calibration.stopTime"), "calibration.stopTime(double)"); using namespace ossimplugins::time; const ModifiedJulianDate firstLineTime = toModifiedJulianDate(imageKeywordlist.GetMetadataByKey("calibration.startTime")); const ModifiedJulianDate lastLineTime = toModifiedJulianDate(imageKeywordlist.GetMetadataByKey("calibration.stopTime")); otbMsgDevMacro(<<"calibration.startTime: "<(imageKeywordlist.GetMetadataByKey(supportDataPrefix + "number_lines"), supportDataPrefix + "number_lines(int)"); otbMsgDevMacro(<<"numOfLines : " << numOfLines); const int count = Utils::LexicalCast(imageKeywordlist.GetMetadataByKey("calibration.count"), "calibration.count"); std::vector calibrationVectorList(count); double lastMJD = 0; for(int i = 0; i < count; i++) { Sentinel1CalibrationStruct calibrationVector; std::stringstream prefix; prefix << "calibration.calibrationVector[" << i << "]."; const std::string sPrefix = prefix.str(); calibrationVector.line = Utils::LexicalCast(imageKeywordlist.GetMetadataByKey(sPrefix + "line"), sPrefix + "line"); // TODO: don't manipulate doubles, but ModifiedJulianDate for a better type // safety const std::string sAzimuth = imageKeywordlist.GetMetadataByKey(sPrefix + "azimuthTime"); calibrationVector.timeMJD = toModifiedJulianDate(sAzimuth).as_day_frac(); calibrationVector.deltaMJD = calibrationVector.timeMJD - lastMJD; lastMJD = calibrationVector.timeMJD; otbMsgDevMacro(<InitParameters(type, firstLineTime.as_day_frac(), lastLineTime.as_day_frac(), numOfLines, count, calibrationVectorList); this->SetCalibrationLookupData(sarLut); } void Sentinel1ImageMetadataInterface ::ParseDateTime(const char* key, std::vector& dateFields) const { if(dateFields.size() < 1 ) { //parse from keyword list if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, not a valid product"); } const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist(); if (!imageKeywordlist.HasKey(key)) { itkExceptionMacro( << "no key named " << key ); } const std::string date_time_str = imageKeywordlist.GetMetadataByKey(key); Utils::ConvertStringToVector(date_time_str, dateFields, key, "T:-."); } } int Sentinel1ImageMetadataInterface::GetYear() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 0 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[0], "support_data.image_date:year(int)" ); } else { itkExceptionMacro( << "Invalid year" ); } return value; } int Sentinel1ImageMetadataInterface::GetMonth() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 1 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[1], "support_data.image_date:month(int)" ); } else { itkExceptionMacro( << "Invalid month" ); } return value; } int Sentinel1ImageMetadataInterface::GetDay() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 2 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[2], "support_data.image_date:day(int)"); } else { itkExceptionMacro( << "Invalid day" ); } return value; } int Sentinel1ImageMetadataInterface::GetHour() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 3 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[3], "support_data.image_date:hour(int)"); } else { itkExceptionMacro( << "Invalid hour" ); } return value; } int Sentinel1ImageMetadataInterface::GetMinute() const { int value = 0; ParseDateTime("support_data.image_date", m_AcquisitionDateFields); if(m_AcquisitionDateFields.size() > 4 ) { value = Utils::LexicalCast( m_AcquisitionDateFields[4], "support_data.image_date:minute(int)"); } else { itkExceptionMacro( << "Invalid minute" ); } return value; } int Sentinel1ImageMetadataInterface::GetProductionYear() const { int value = 0; ParseDateTime("support_data.date", m_ProductionDateFields); if(m_ProductionDateFields.size() > 0 ) { value = Utils::LexicalCast( m_ProductionDateFields[0], "support_data.date:year(int)" ); } else { itkExceptionMacro( << "Invalid production year" ); } return value; } int Sentinel1ImageMetadataInterface::GetProductionMonth() const { int value = 0; ParseDateTime("support_data.date", m_ProductionDateFields); if(m_ProductionDateFields.size() > 1 ) { value = Utils::LexicalCast( m_ProductionDateFields[1], "support_data.date:month(int)" ); } else { itkExceptionMacro( << "Invalid production month" ); } return value; } int Sentinel1ImageMetadataInterface::GetProductionDay() const { int value = 0; ParseDateTime("support_data.date", m_ProductionDateFields); if(m_ProductionDateFields.size() > 2 ) { value = Utils::LexicalCast( m_ProductionDateFields[2], "support_data.date:day(int)" ); } else { itkExceptionMacro( << "Invalid production day" ); } return value; } double Sentinel1ImageMetadataInterface::GetPRF() const { double value = 0; const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist(); if (!imageKeywordlist.HasKey("support_data.pulse_repetition_frequency")) { return value; } value = Utils::LexicalCast( imageKeywordlist.GetMetadataByKey("support_data.pulse_repetition_frequency"), "support_data.pulse_repetition_frequency(double)" ); return value; } Sentinel1ImageMetadataInterface::UIntVectorType Sentinel1ImageMetadataInterface::GetDefaultDisplay() const { UIntVectorType rgb(3); rgb[0] = 0; rgb[1] = 0; rgb[2] = 0; return rgb; } double Sentinel1ImageMetadataInterface::GetRSF() const { return 0; } double Sentinel1ImageMetadataInterface::GetRadarFrequency() const { return 0; } double Sentinel1ImageMetadataInterface::GetCenterIncidenceAngle() const { return 0; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSentinel1ImageMetadataInterfaceFactory.cxx000066400000000000000000000030341301006202600310750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbSentinel1ImageMetadataInterfaceFactory.h" #include "otbSentinel1ImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { Sentinel1ImageMetadataInterfaceFactory ::Sentinel1ImageMetadataInterfaceFactory() { this->RegisterOverride("SarImageMetadataInterface", "otbSentinel1ImageMetadataInterface", "Sentinel1 Metadata Interface", 1, itk::CreateObjectFunction::New()); } Sentinel1ImageMetadataInterfaceFactory ::~Sentinel1ImageMetadataInterfaceFactory() { } const char* Sentinel1ImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* Sentinel1ImageMetadataInterfaceFactory::GetDescription() const { return "Sentinel1 Metadata Interface Factory, handle Sentinel1 metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSpot6ImageMetadataInterface.cxx000066400000000000000000003020561301006202600267240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSpot6ImageMetadataInterface.h" #include "otbMacro.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" #include "otbStringUtils.h" namespace otb { using boost::lexical_cast; using boost::bad_lexical_cast; Spot6ImageMetadataInterface ::Spot6ImageMetadataInterface() { } bool Spot6ImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("SPOT 6") != std::string::npos || sensorID.find("SPOT 7") != std::string::npos) return true; else return false; } std::string Spot6ImageMetadataInterface::GetInstrument() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument"); return valueString; } return ""; } std::string Spot6ImageMetadataInterface::GetInstrumentIndex() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument_index")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument_index"); return valueString; } return ""; // Invalid value } Spot6ImageMetadataInterface::VariableLengthVectorType Spot6ImageMetadataInterface::GetSolarIrradiance() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.solar_irradiance")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.solar_irradiance"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); if (outputValues.size() > 0) { for (unsigned int i = 0; i < outputValues.size(); ++i) outputValuesVariableLengthVector[i] = outputValues[this->BandIndexToWavelengthPosition(i)]; } else { itkExceptionMacro("Invalid Physical Irradiance"); } return outputValuesVariableLengthVector; } int Spot6ImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[2]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Day"); } return value; } int Spot6ImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[1]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Month"); } return value; } int Spot6ImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[0]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Year"); } return value; } int Spot6ImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[3]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Hour"); } return value; } int Spot6ImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-.")); int value; try { value = lexical_cast (outputValues[4]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Minute"); } return value; } int Spot6ImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); int value; try { value = lexical_cast (outputValues[2]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Day"); } return value; } int Spot6ImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); int value; try { value = lexical_cast (outputValues[1]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Month"); } return value; } int Spot6ImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value; try { value = lexical_cast (outputValues[0]); } catch (bad_lexical_cast &) { itkExceptionMacro(<< "Invalid Year"); } return value; } Spot6ImageMetadataInterface::VariableLengthVectorType Spot6ImageMetadataInterface ::GetPhysicalBias() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.physical_bias")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.physical_bias"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); if (outputValues.size() > 0) { for (unsigned int i = 0; i < outputValues.size(); ++i) outputValuesVariableLengthVector[i] = outputValues[this->BandIndexToWavelengthPosition(i)]; } else { itkExceptionMacro("Invalid Physical Bias"); } return outputValuesVariableLengthVector; } Spot6ImageMetadataInterface::VariableLengthVectorType Spot6ImageMetadataInterface ::GetPhysicalGain() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.physical_gain")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.physical_gain"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); if (outputValues.size() > 0) { for (unsigned int i = 0; i < outputValues.size(); ++i) outputValuesVariableLengthVector[i] = outputValues[this->BandIndexToWavelengthPosition(i)]; } else { itkExceptionMacro("Invalid Physical Bias"); } return outputValuesVariableLengthVector; } double Spot6ImageMetadataInterface::GetSatElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.incident_angle")) { return 0; } // MSD: for the moment take only topCenter value std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.incident_angle"); double value = atof(valueString.c_str()); // Elevation is measured from ground, incidence from zenith // Elevation angle = 90° - Incidence angle value = 90. - value; return value; } double Spot6ImageMetadataInterface::GetSatAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.scene_orientation")) { return 0; } // MSD: for the moment take only topCenter value std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.scene_orientation"); double satAz = atof(valueString.c_str()); return satAz; } Spot6ImageMetadataInterface::VariableLengthVectorType Spot6ImageMetadataInterface ::GetFirstWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); } else if (nbBands > 1 && nbBands < 5) { wavel.SetSize(4); } else itkExceptionMacro(<< "Invalid number of bands..."); wavel.Fill(0.4); return wavel; } Spot6ImageMetadataInterface::VariableLengthVectorType Spot6ImageMetadataInterface ::GetLastWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); } else if (nbBands > 1 && nbBands < 5) { wavel.SetSize(4); } else itkExceptionMacro(<< "Invalid number of bands..."); wavel.Fill(1.0); return wavel; } // TODO MSD need to update this function // Comment this part as relative response // FIXME check if this is coherent with other sensor unsigned int Spot6ImageMetadataInterface ::BandIndexToWavelengthPosition(unsigned int i) const // todo { int nbBands = this->GetNumberOfBands(); //Panchromatic case if (nbBands == 1) { return 0; } else { otbMsgDevMacro(<< "Spot6 detected: first file component is red band and third component is blue one"); if (i == 0) return 2; if (i == 2) return 0; } return i; } std::vector Spot6ImageMetadataInterface ::GetEnhancedBandNames() const // todo { std::vector enhBandNames; std::vector rawBandNames = this->Superclass::GetBandName(); if(rawBandNames.size()) { for (std::vector::iterator it = rawBandNames.begin(); it != rawBandNames.end(); ++it) { // Manage Panchro case if ( (rawBandNames.size() == 1) && !(*it).compare("P") ) { enhBandNames.push_back("PAN"); break; } else if ((rawBandNames.size() != 1) && !(*it).compare("P")) { /* Launch exception situation not valid*/ itkExceptionMacro(<< "Invalid Metadata, we cannot provide an consistent name to the band"); } // Manage MS case if ( !(*it).compare("B0") ) { enhBandNames.push_back("Blue"); } else if ( !(*it).compare("B1") ) { enhBandNames.push_back("Green"); } else if ( !(*it).compare("B2") ) { enhBandNames.push_back("Red"); } else if ( !(*it).compare("B3") ) { enhBandNames.push_back("NIR"); } else { enhBandNames.push_back("Unknown"); } } } return enhBandNames; } std::vector Spot6ImageMetadataInterface ::GetDefaultDisplay() const // todo { std::vector rgb(3); rgb[0] = 0; rgb[1] = 1; rgb[2] = 2; return rgb; } Spot6ImageMetadataInterface::WavelengthSpectralBandVectorType Spot6ImageMetadataInterface ::GetSpectralSensitivity() const // todo { //TODO tabulate spectral responses WavelengthSpectralBandVectorType wavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); std::list > tmpSpectralBandList; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot6 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } const int nbBands = this->GetNumberOfBands(); const std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { //if (sensorId.find("PHR") != std::string::npos) if (sensorId == "SPOT 6") // todo: updated values for Spot7 { const float pan[601] = { 0.00007493f, 0.00008750f, 0.00009848f, 0.00010843f, 0.00011646f, 0.00012259f, 0.00012552f, 0.00012814f, 0.00013531f, 0.00015014f, 0.00017236f, 0.00019564f, 0.00021235f, 0.00022348f, 0.00022676f, 0.00022299f, 0.00021213f, 0.00020083f, 0.00019926f, 0.00021359f, 0.00025083f, 0.00030983f, 0.00038670f, 0.00047229f, 0.00056950f, 0.00067560f, 0.00078669f, 0.00090069f, 0.00103421f, 0.00131540f, 0.00169029f, 0.00228198f, 0.00312648f, 0.00417071f, 0.00533582f, 0.00661006f, 0.00802817f, 0.00960467f, 0.01132980f, 0.01334611f, 0.01609231f, 0.02038299f, 0.02732543f, 0.03802347f, 0.05294767f, 0.07167096f, 0.09348728f, 0.11872659f, 0.14830802f, 0.18269957f, 0.22269040f, 0.26906796f, 0.32263521f, 0.38325366f, 0.44824011f, 0.51559417f, 0.58258589f, 0.64645021f, 0.70236661f, 0.74583583f, 0.77585237f, 0.79433792f, 0.80499388f, 0.81090952f, 0.81371638f, 0.81431418f, 0.81316313f, 0.81141755f, 0.81097193f, 0.81322836f, 0.81878063f, 0.82800769f, 0.83916423f, 0.85084085f, 0.86161004f, 0.87040692f, 0.87637562f, 0.87967534f, 0.88047879f, 0.88112137f, 0.88175192f, 0.88365397f, 0.88759508f, 0.89291809f, 0.89912245f, 0.90543957f, 0.91146456f, 0.91547923f, 0.91843965f, 0.91963891f, 0.91975983f, 0.91963913f, 0.91947516f, 0.92025788f, 0.92260193f, 0.92575482f, 0.93070662f, 0.93550391f, 0.94001389f, 0.94383039f, 0.94609629f, 0.94688618f, 0.94624211f, 0.94455744f, 0.94265988f, 0.94120799f, 0.94079078f, 0.94176327f, 0.94473408f, 0.94915584f, 0.95419339f, 0.95954236f, 0.96459688f, 0.96902841f, 0.97179112f, 0.97317857f, 0.97320070f, 0.97218736f, 0.97091309f, 0.97035732f, 0.96996616f, 0.97140258f, 0.97376942f, 0.97636229f, 0.97957895f, 0.98311659f, 0.98550114f, 0.98688700f, 0.98705275f, 0.98569258f, 0.98301588f, 0.97915984f, 0.97493690f, 0.97129138f, 0.96813872f, 0.96649466f, 0.96685400f, 0.96849224f, 0.97201807f, 0.97702694f, 0.98197923f, 0.98753229f, 0.99230951f, 0.99540351f, 0.99740084f, 0.99730413f, 0.99558763f, 0.99262103f, 0.98803927f, 0.98368879f, 0.97966358f, 0.97601679f, 0.97409076f, 0.97356455f, 0.97460306f, 0.97733165f, 0.98142794f, 0.98607299f, 0.99104944f, 0.99556304f, 0.99892911f, 1.00128281f, 1.00206838f, 1.00124192f, 0.99879621f, 0.99466280f, 0.99032401f, 0.98568114f, 0.98102690f, 0.97756954f, 0.97495949f, 0.97366152f, 0.97436348f, 0.97596613f, 0.97930722f, 0.98307748f, 0.98726114f, 0.99154671f, 0.99533904f, 0.99803299f, 0.99950550f, 1.00000000f, 0.99848218f, 0.99593416f, 0.99288307f, 0.98834389f, 0.98366197f, 0.97971238f, 0.97601117f, 0.97307044f, 0.97155305f, 0.97102663f, 0.97152475f, 0.97341779f, 0.97585074f, 0.97896590f, 0.98255796f, 0.98543794f, 0.98789503f, 0.98994151f, 0.99059899f, 0.99029895f, 0.98922305f, 0.98676544f, 0.98389430f, 0.98067297f, 0.97675508f, 0.97324400f, 0.97055473f, 0.96803100f, 0.96629732f, 0.96561899f, 0.96564173f, 0.96639591f, 0.96771777f, 0.96934976f, 0.97124886f, 0.97291816f, 0.97432735f, 0.97530655f, 0.97542227f, 0.97463623f, 0.97308990f, 0.97065297f, 0.96750332f, 0.96379792f, 0.95963369f, 0.95522586f, 0.95099476f, 0.94711647f, 0.94373897f, 0.94086191f, 0.93909609f, 0.93751312f, 0.93716161f, 0.93749275f, 0.93844552f, 0.93992284f, 0.94157292f, 0.94327292f, 0.94494878f, 0.94621266f, 0.94689150f, 0.94695971f, 0.94601526f, 0.94485162f, 0.94216490f, 0.93936780f, 0.93516770f, 0.93117984f, 0.92600825f, 0.92184558f, 0.91679022f, 0.91281220f, 0.90873714f, 0.90559995f, 0.90280144f, 0.90151379f, 0.90018969f, 0.90026306f, 0.90055224f, 0.90169504f, 0.90303974f, 0.90479165f, 0.90660298f, 0.90788333f, 0.90928294f, 0.90961910f, 0.91044105f, 0.90941307f, 0.90884628f, 0.90648792f, 0.90426184f, 0.90090015f, 0.89728707f, 0.89360311f, 0.88921759f, 0.88536863f, 0.88109823f, 0.87784434f, 0.87367129f, 0.87100044f, 0.86849439f, 0.86645265f, 0.86555715f, 0.86486409f, 0.86444275f, 0.86462554f, 0.86421244f, 0.86509991f, 0.86504142f, 0.86574075f, 0.86547448f, 0.86537728f, 0.86481040f, 0.86329140f, 0.86242059f, 0.85986818f, 0.85807444f, 0.85502168f, 0.85224705f, 0.84852762f, 0.84517422f, 0.84157685f, 0.83807810f, 0.83443274f, 0.83120263f, 0.82819085f, 0.82520041f, 0.82259510f, 0.82050631f, 0.81863236f, 0.81673157f, 0.81518962f, 0.81376687f, 0.81276571f, 0.81111987f, 0.81039972f, 0.80884166f, 0.80742716f, 0.80605476f, 0.80328088f, 0.80094601f, 0.79797843f, 0.79448406f, 0.79079478f, 0.78664955f, 0.78403080f, 0.77837404f, 0.77671056f, 0.77071265f, 0.76860809f, 0.76568459f, 0.76096821f, 0.75943556f, 0.75440145f, 0.74853854f, 0.73756232f, 0.72050194f, 0.69619742f, 0.66466129f, 0.62570237f, 0.58042003f, 0.52946690f, 0.47429123f, 0.41572304f, 0.35577781f, 0.29694274f, 0.24182875f, 0.19245049f, 0.15026362f, 0.11482153f, 0.08854978f, 0.06698482f, 0.05109390f, 0.03916000f, 0.03018623f, 0.02342899f, 0.01832614f, 0.01444326f, 0.01147024f, 0.00918513f, 0.00740254f, 0.00609562f, 0.00491959f, 0.00435297f, 0.00335678f, 0.00291823f, 0.00234224f, 0.00205113f, 0.00167084f, 0.00145104f, 0.00124552f, 0.00104170f, 0.00108470f, 0.00077931f, 0.00084497f, 0.00059188f, 0.00063835f, 0.00045747f, 0.00040248f, 0.00043271f, 0.00031792f, 0.00033871f, 0.00025452f, 0.00026931f, 0.00020572f, 0.00018559f, 0.00019577f, 0.00015320f, 0.00016086f, 0.00012704f, 0.00011590f, 0.00012165f, 0.00009829f, 0.00010178f, 0.00008372f, 0.00007722f, 0.00008098f, 0.00007448f, 0.00006262f, 0.00006513f, 0.00005514f, 0.00005663f, 0.00004857f, 0.00004996f, 0.00004369f, 0.00004402f, 0.00003879f, 0.00003626f, 0.00003796f, 0.00003303f, 0.00003435f, 0.00003053f, 0.00003118f, 0.00002826f, 0.00002628f, 0.00002754f, 0.00002484f, 0.00002559f, 0.00002406f, 0.00002348f, 0.00002237f, 0.00002233f, 0.00002269f, 0.00002170f, 0.00001996f, 0.00002062f, 0.00001880f, 0.00002003f, 0.00001893f, 0.00001935f, 0.00001823f, 0.00001794f, 0.00001879f, 0.00001726f, 0.00001797f, 0.00001774f, 0.00001520f, 0.00001784f, 0.00001500f, 0.00001790f, 0.00001464f, 0.00001317f, 0.00001633f, 0.00001127f, 0.00001471f, 0.00001314f, 0.00001114f, 0.00000968f, 0.00001262f, 0.00001126f, 0.00002112f, 0.00001135f, 0.00001674f, 0.00001146f, 0.00001572f, 0.00002157f, 0.00001166f, 0.00002111f, 0.00001206f, 0.00002362f, 0.00002815f, 0.00001740f, 0.00001816f, 0.00002519f, 0.00001627f, 0.00002405f, 0.00002027f, 0.00002469f, 0.00002124f, 0.00001758f, 0.00002971f, 0.00002051f, 0.00002437f, 0.00002119f, 0.00001926f, 0.00001850f, 0.00001774f, 0.00002056f, 0.00002202f, 0.00001602f, 0.00001436f, 0.00001710f, 0.00001369f, 0.00001827f, 0.00001218f, 0.00001567f, 0.00001596f, 0.00001348f, 0.00001857f, 0.00001662f, 0.00001805f, 0.00002361f, 0.00001927f, 0.00003019f, 0.00003036f, 0.00003602f, 0.00003469f, 0.00004530f, 0.00004918f, 0.00005892f, 0.00005708f, 0.00006488f, 0.00006319f, 0.00007284f, 0.00006971f, 0.00007822f, 0.00007143f, 0.00007223f, 0.00007024f, 0.00007097f, 0.00007120f, 0.00006619f, 0.00006294f, 0.00005778f, 0.00005333f, 0.00005405f, 0.00004915f, 0.00004779f, 0.00004379f, 0.00004087f, 0.00003311f, 0.00003608f, 0.00003592f, 0.00002213f, 0.00002159f, 0.00002350f, 0.00001705f, 0.00002055f, 0.00001764f, 0.00001453f, 0.00001636f, 0.00001197f, 0.00001123f, 0.00001127f, 0.00001042f, 0.00001021f, 0.00001099f, 0.00001171f, 0.00001030f, 0.00001236f, 0.00001192f, 0.00000823f, 0.00000820f, 0.00000893f, 0.00001115f, 0.00001001f, 0.00000802f, 0.00000976f, 0.00000966f, 0.00000957f, 0.00000726f, 0.00000967f, 0.00001001f, 0.00000803f, 0.00000726f, 0.00000739f, 0.00000845f, 0.00000698f, 0.00000568f, 0.00000472f, 0.00000650f, 0.00000706f, 0.00000546f, 0.00000433f, 0.00000607f, 0.00000408f, 0.00000788f, 0.00000464f, 0.00000958f, 0.00000689f, 0.00000976f, 0.00000672f, 0.00000574f, 0.00000980f, 0.00000503f, 0.00000796f, 0.00000325f, 0.00000636f, 0.00000334f, 0.00000562f, 0.00000413f, 0.00000400f, 0.00000610f, 0.00000240f, 0.00000486f, 0.00000262f, 0.00000333f, 0.00000152f, 0.00000236f, 0.00000152f, 0.00000228f, 0.00000070f, 0.00000185f, 0.00000162f, 0.00000093f, 0.00000188f, 0.00000116f, 0.00000041f, 0.00000126f }; //add panchromatic band to the temporary list const std::vector vpan (pan, pan + sizeof(pan) / sizeof(float) ); tmpSpectralBandList.push_back(vpan); } else if (sensorId == "SPOT 7") { const float pan[241] = { 0.00006389f, 0.00006904f, 0.00007915f, 0.00009378f, 0.00010719f, 0.00010807f, 0.00005190f, 0.00007085f, 0.00008762f, 0.00011574f, 0.00012782f, 0.00020258f, 0.00028301f, 0.00041885f, 0.00079339f, 0.00231845f, 0.00809283f, 0.02627796f, 0.07986263f, 0.21857411f, 0.41950208f, 0.58629708f, 0.66050686f, 0.68010722f, 0.69547035f, 0.73200613f, 0.76244784f, 0.77631573f, 0.77685838f, 0.77827649f, 0.79088274f, 0.82399853f, 0.85580091f, 0.86901807f, 0.87815311f, 0.88386190f, 0.88817207f, 0.88840904f, 0.88986216f, 0.89780237f, 0.90741552f, 0.92203907f, 0.93653131f, 0.94317059f, 0.94634032f, 0.94826607f, 0.95033833f, 0.95413215f, 0.95048104f, 0.94044263f, 0.92879443f, 0.91596982f, 0.91697468f, 0.93980602f, 0.95870660f, 0.95318054f, 0.94231596f, 0.94431035f, 0.95901822f, 0.97746502f, 0.98759663f, 0.98550275f, 0.97993122f, 0.97745334f, 0.97810352f, 0.98221381f, 0.98793014f, 0.98964682f, 0.98759323f, 0.98932633f, 0.99590692f, 1.00000000f, 0.99684166f, 0.98739921f, 0.97751640f, 0.97333810f, 0.97745644f, 0.98380626f, 0.98261193f, 0.97292962f, 0.96647185f, 0.97034470f, 0.97825408f, 0.98127712f, 0.97970816f, 0.97805235f, 0.97616447f, 0.97247933f, 0.97166543f, 0.97283831f, 0.97422681f, 0.97153287f, 0.96550092f, 0.96119938f, 0.96103140f, 0.96128770f, 0.96042574f, 0.95959210f, 0.95853335f, 0.95403997f, 0.94406246f, 0.93246052f, 0.92672319f, 0.92977305f, 0.93586632f, 0.93897168f, 0.93690555f, 0.93160952f, 0.92690621f, 0.92296771f, 0.91842779f, 0.91408514f, 0.90917712f, 0.90063878f, 0.88604421f, 0.86698768f, 0.85188054f, 0.84835188f, 0.85624365f, 0.86584046f, 0.87078346f, 0.86760443f, 0.86093980f, 0.85542417f, 0.85190690f, 0.84736153f, 0.83999199f, 0.83265310f, 0.82574365f, 0.81691630f, 0.79906275f, 0.76297024f, 0.70997037f, 0.65661413f, 0.62490673f, 0.61368617f, 0.59949630f, 0.55020515f, 0.43968017f, 0.29408377f, 0.17078748f, 0.09678961f, 0.05559319f, 0.03167753f, 0.01645302f, 0.00834098f, 0.00415879f, 0.00246672f, 0.00161203f, 0.00125129f, 0.00104229f, 0.00092455f, 0.00089227f, 0.00079671f, 0.00081363f, 0.00092827f, 0.00069700f, 0.00111498f, 0.00114280f, 0.00100619f, 0.00078417f, 0.00082583f, 0.00081178f, 0.00088529f, 0.00079650f, 0.00086426f, 0.00073552f, 0.00082226f, 0.00078531f, 0.00083777f, 0.00101103f, 0.00107977f, 0.00122308f, 0.00080949f, 0.00071004f, 0.00086922f, 0.00109600f, 0.00070790f, 0.00070521f, 0.00062633f, 0.00057800f, 0.00055688f, 0.00036005f, 0.00043799f, 0.00082241f, 0.00048577f, 0.00065545f, 0.00048744f, 0.00073230f, 0.00058760f, 0.00049000f, 0.00037912f, 0.00023879f, 0.00041582f, 0.00049542f, 0.00037382f, 0.00035989f, 0.00036581f, 0.00036198f, 0.00037810f, 0.00041012f, 0.00036016f, 0.00040840f, 0.00034388f, 0.00031513f, 0.00031990f, 0.00027999f, 0.00030759f, 0.00022414f, 0.00030194f, 0.00023586f, 0.00036102f, 0.00028178f, 0.00025961f, 0.00017557f, 0.00028227f, 0.00039256f, 0.00032632f, 0.00025898f, 0.00025288f, 0.00035918f, 0.00021611f, 0.00015573f, 0.00019060f, 0.00020197f, 0.00017782f, 0.00011551f, 0.00017122f, 0.00008967f, 0.00017285f, 0.00026179f, 0.00016810f, 0.00008392f, 0.00012216f, 0.00015827f, 0.00008757f, 0.00003617f, 0.00006631f, 0.00006748f, 0.00005452f, 0.00004778f }; //add panchromatic band to the temporary list const std::vector vpan (pan, pan + sizeof(pan) / sizeof(float) ); tmpSpectralBandList.push_back(vpan); } else { itkExceptionMacro(<< "Invalid Spot6 Sensor ID"); } } else if (nbBands > 1 && nbBands < 5) { if (sensorId == "SPOT 6") // todo: updated values for Spot7 { //band B0 (blue band) const float b0[601] = { 0.00006627f, 0.00006114f, 0.00005964f, 0.00006755f, 0.00007354f, 0.00007335f, 0.00007303f, 0.00006988f, 0.00006669f, 0.00006467f, 0.00008891f, 0.00010731f, 0.00006420f, 0.00008781f, 0.00008978f, 0.00008292f, 0.00008193f, 0.00005499f, 0.00008203f, 0.00011262f, 0.00009092f, 0.00010575f, 0.00013926f, 0.00016613f, 0.00019666f, 0.00019375f, 0.00021841f, 0.00033008f, 0.00059283f, 0.00096710f, 0.00120426f, 0.00143132f, 0.00190776f, 0.00246548f, 0.00314995f, 0.00393858f, 0.00502501f, 0.00693758f, 0.00995331f, 0.01395395f, 0.01816332f, 0.02248784f, 0.02806060f, 0.03582005f, 0.04774668f, 0.06795621f, 0.09842750f, 0.13108997f, 0.16221496f, 0.20486488f, 0.26488470f, 0.33784410f, 0.41558626f, 0.48567541f, 0.54882896f, 0.61466150f, 0.68475833f, 0.75228611f, 0.80736646f, 0.84246227f, 0.85754473f, 0.85841741f, 0.85407547f, 0.85129313f, 0.85144931f, 0.85321674f, 0.85405128f, 0.85387063f, 0.85555834f, 0.86252514f, 0.87558536f, 0.89251130f, 0.90900546f, 0.92154349f, 0.92918777f, 0.93306769f, 0.93515923f, 0.93666027f, 0.93739349f, 0.93661481f, 0.93379608f, 0.92929650f, 0.92442581f, 0.92058032f, 0.91895381f, 0.92090421f, 0.92631122f, 0.93455782f, 0.94463030f, 0.95473194f, 0.96364502f, 0.97043568f, 0.97436437f, 0.97495098f, 0.97200508f, 0.96636029f, 0.95962307f, 0.95371958f, 0.95061152f, 0.95192705f, 0.95818895f, 0.96856416f, 0.98070274f, 0.99142860f, 0.99788650f, 1.00000000f, 0.99910819f, 0.99808156f, 0.99650360f, 0.99314712f, 0.98404465f, 0.96550845f, 0.93867401f, 0.90804427f, 0.87480177f, 0.83387151f, 0.77606904f, 0.69859059f, 0.60871934f, 0.51759429f, 0.43125686f, 0.34977809f, 0.27392459f, 0.20473488f, 0.14738691f, 0.10459452f, 0.07555179f, 0.05654570f, 0.04380857f, 0.03477386f, 0.02793581f, 0.02225302f, 0.01751704f, 0.01359022f, 0.01046026f, 0.00814691f, 0.00649078f, 0.00530930f, 0.00446096f, 0.00383097f, 0.00333164f, 0.00292664f, 0.00257637f, 0.00225949f, 0.00198202f, 0.00172287f, 0.00150439f, 0.00130359f, 0.00113903f, 0.00099076f, 0.00086925f, 0.00076142f, 0.00067853f, 0.00060841f, 0.00055953f, 0.00051880f, 0.00049699f, 0.00047445f, 0.00045863f, 0.00044229f, 0.00042470f, 0.00040647f, 0.00038780f, 0.00035963f, 0.00033330f, 0.00029660f, 0.00027179f, 0.00024451f, 0.00022875f, 0.00021524f, 0.00021255f, 0.00021004f, 0.00021079f, 0.00021138f, 0.00021521f, 0.00021336f, 0.00021459f, 0.00020993f, 0.00020747f, 0.00019888f, 0.00019065f, 0.00018249f, 0.00017164f, 0.00016473f, 0.00015826f, 0.00015437f, 0.00015378f, 0.00015002f, 0.00015089f, 0.00015050f, 0.00015245f, 0.00015136f, 0.00015264f, 0.00015147f, 0.00015009f, 0.00014792f, 0.00014493f, 0.00014083f, 0.00013665f, 0.00013056f, 0.00012700f, 0.00012212f, 0.00011620f, 0.00011384f, 0.00010918f, 0.00010782f, 0.00010377f, 0.00010231f, 0.00010126f, 0.00010021f, 0.00009925f, 0.00009923f, 0.00009906f, 0.00009850f, 0.00009892f, 0.00009742f, 0.00009802f, 0.00009809f, 0.00009662f, 0.00009692f, 0.00009575f, 0.00009546f, 0.00009575f, 0.00009469f, 0.00009485f, 0.00009453f, 0.00009384f, 0.00009463f, 0.00009451f, 0.00009458f, 0.00009520f, 0.00009478f, 0.00009588f, 0.00009579f, 0.00009545f, 0.00009560f, 0.00009549f, 0.00009549f, 0.00009551f, 0.00009535f, 0.00009579f, 0.00009570f, 0.00009544f, 0.00009552f, 0.00009622f, 0.00009645f, 0.00009648f, 0.00009799f, 0.00009797f, 0.00009864f, 0.00009916f, 0.00010183f, 0.00010153f, 0.00010358f, 0.00010461f, 0.00010712f, 0.00010718f, 0.00011085f, 0.00011321f, 0.00011173f, 0.00011398f, 0.00011982f, 0.00011831f, 0.00012135f, 0.00012902f, 0.00012720f, 0.00013658f, 0.00013538f, 0.00014397f, 0.00014356f, 0.00015119f, 0.00015202f, 0.00015693f, 0.00015686f, 0.00015130f, 0.00015184f, 0.00013690f, 0.00013092f, 0.00013335f, 0.00011361f, 0.00010715f, 0.00010823f, 0.00009932f, 0.00009856f, 0.00009765f, 0.00009914f, 0.00010008f, 0.00010777f, 0.00010686f, 0.00011218f, 0.00012769f, 0.00012456f, 0.00014074f, 0.00014680f, 0.00014400f, 0.00015360f, 0.00015552f, 0.00015166f, 0.00015221f, 0.00014625f, 0.00014561f, 0.00013613f, 0.00013172f, 0.00013242f, 0.00012141f, 0.00012300f, 0.00011836f, 0.00010821f, 0.00010974f, 0.00010309f, 0.00010302f, 0.00010127f, 0.00009629f, 0.00009854f, 0.00009280f, 0.00009475f, 0.00009054f, 0.00009196f, 0.00008822f, 0.00008866f, 0.00008744f, 0.00008550f, 0.00008673f, 0.00008483f, 0.00008628f, 0.00008449f, 0.00009254f, 0.00008532f, 0.00009594f, 0.00008917f, 0.00009084f, 0.00010183f, 0.00009128f, 0.00010000f, 0.00008800f, 0.00009430f, 0.00008055f, 0.00008475f, 0.00007796f, 0.00007850f, 0.00007713f, 0.00007770f, 0.00007623f, 0.00007664f, 0.00007474f, 0.00007405f, 0.00007519f, 0.00007318f, 0.00007349f, 0.00007204f, 0.00007375f, 0.00007369f, 0.00007149f, 0.00007148f, 0.00007312f, 0.00007167f, 0.00007255f, 0.00007120f, 0.00007186f, 0.00007087f, 0.00007145f, 0.00007024f, 0.00007096f, 0.00007041f, 0.00007088f, 0.00006995f, 0.00007149f, 0.00006924f, 0.00007103f, 0.00006949f, 0.00007093f, 0.00006951f, 0.00007194f, 0.00007193f, 0.00006859f, 0.00006781f, 0.00007056f, 0.00006741f, 0.00006870f, 0.00006628f, 0.00006687f, 0.00006601f, 0.00006595f, 0.00006670f, 0.00006450f, 0.00006595f, 0.00006433f, 0.00006569f, 0.00006431f, 0.00006573f, 0.00006406f, 0.00006507f, 0.00006298f, 0.00006428f, 0.00006201f, 0.00006357f, 0.00006101f, 0.00006096f, 0.00006309f, 0.00006103f, 0.00006314f, 0.00006382f, 0.00006164f, 0.00006245f, 0.00006061f, 0.00005973f, 0.00006261f, 0.00005982f, 0.00006197f, 0.00005956f, 0.00006099f, 0.00005881f, 0.00005972f, 0.00006005f, 0.00005691f, 0.00005647f, 0.00005823f, 0.00005603f, 0.00005759f, 0.00005605f, 0.00005558f, 0.00005646f, 0.00005480f, 0.00005543f, 0.00005551f, 0.00005357f, 0.00005295f, 0.00005549f, 0.00005286f, 0.00005495f, 0.00005278f, 0.00005414f, 0.00005475f, 0.00005169f, 0.00005307f, 0.00005117f, 0.00005068f, 0.00005036f, 0.00005270f, 0.00004991f, 0.00005177f, 0.00005900f, 0.00004889f, 0.00006116f, 0.00005285f, 0.00006427f, 0.00005589f, 0.00006943f, 0.00006195f, 0.00007219f, 0.00007275f, 0.00006694f, 0.00007232f, 0.00006712f, 0.00007044f, 0.00006607f, 0.00007040f, 0.00007120f, 0.00006047f, 0.00006863f, 0.00006547f, 0.00005919f, 0.00006852f, 0.00005996f, 0.00006589f, 0.00006938f, 0.00006013f, 0.00007365f, 0.00006702f, 0.00007595f, 0.00008089f, 0.00006987f, 0.00008784f, 0.00007751f, 0.00009504f, 0.00010978f, 0.00008984f, 0.00012777f, 0.00010534f, 0.00014784f, 0.00012341f, 0.00017455f, 0.00018601f, 0.00015342f, 0.00020484f, 0.00017984f, 0.00018931f, 0.00022557f, 0.00022780f, 0.00021393f, 0.00022939f, 0.00023016f, 0.00021920f, 0.00021508f, 0.00022046f, 0.00020159f, 0.00021016f, 0.00018988f, 0.00019842f, 0.00017117f, 0.00018205f, 0.00015240f, 0.00014443f, 0.00015946f, 0.00014629f, 0.00012207f, 0.00013127f, 0.00010545f, 0.00011422f, 0.00009446f, 0.00009843f, 0.00008316f, 0.00008914f, 0.00008435f, 0.00006511f, 0.00007269f, 0.00006160f, 0.00006279f, 0.00005814f, 0.00005882f, 0.00005406f, 0.00005351f, 0.00005183f, 0.00005084f, 0.00004786f, 0.00004877f, 0.00004859f, 0.00004583f, 0.00004279f, 0.00004263f, 0.00004130f, 0.00004093f, 0.00004059f, 0.00004012f, 0.00004037f, 0.00004396f, 0.00004304f, 0.00004054f, 0.00004200f, 0.00004073f, 0.00004199f, 0.00004077f, 0.00004125f, 0.00003820f, 0.00003723f, 0.00003610f, 0.00003503f, 0.00003232f, 0.00003214f, 0.00003263f, 0.00003065f, 0.00003127f, 0.00002955f, 0.00002956f, 0.00002840f, 0.00002896f, 0.00002780f, 0.00002805f, 0.00002680f, 0.00002585f, 0.00002704f, 0.00002540f, 0.00002576f, 0.00002438f, 0.00002409f, 0.00002110f, 0.00002288f, 0.00001930f, 0.00002147f, 0.00001830f, 0.00001907f, 0.00001917f, 0.00001634f, 0.00001778f, 0.00001705f, 0.00001506f, 0.00001555f, 0.00001544f, 0.00001376f, 0.00001432f, 0.00001256f, 0.00001321f, 0.00001143f, 0.00001207f, 0.00001040f, 0.00001079f, 0.00001077f, 0.00000938f, 0.00000992f, 0.00000926f, 0.00000875f, 0.00000915f, 0.00000791f, 0.00000858f, 0.00000757f, 0.00000885f, 0.00000740f, 0.00000859f, 0.00000871f, 0.00000732f, 0.00000711f }; //B1 green band const float b1[601] = { 0.00001010f, 0.00001389f, 0.00001902f, 0.00001356f, 0.00001327f, 0.00002873f, 0.00003122f, 0.00002184f, 0.00002860f, 0.00002274f, 0.00006723f, 0.00008343f, 0.00001226f, 0.00006171f, 0.00005563f, 0.00004426f, 0.00004539f, 0.00000677f, 0.00002035f, 0.00001522f, 0.00000528f, 0.00001865f, 0.00001834f, 0.00002028f, 0.00001608f, 0.00000017f, 0.00000057f, 0.00001313f, 0.00001658f, 0.00000224f, 0.00001983f, 0.00001885f, 0.00001859f, 0.00001975f, 0.00000023f, 0.00000139f, 0.00001634f, 0.00001789f, 0.00000616f, 0.00002267f, 0.00001903f, 0.00001956f, 0.00001844f, 0.00000342f, 0.00001448f, 0.00001340f, 0.00000774f, 0.00001880f, 0.00001632f, 0.00001912f, 0.00001915f, 0.00000950f, 0.00000865f, 0.00000927f, 0.00001089f, 0.00001236f, 0.00001349f, 0.00001273f, 0.00001062f, 0.00000958f, 0.00000938f, 0.00000973f, 0.00000998f, 0.00001014f, 0.00001042f, 0.00001060f, 0.00001115f, 0.00001174f, 0.00001254f, 0.00001338f, 0.00001400f, 0.00001431f, 0.00001481f, 0.00001528f, 0.00001646f, 0.00001812f, 0.00001991f, 0.00002232f, 0.00002548f, 0.00002855f, 0.00003235f, 0.00003705f, 0.00004200f, 0.00004766f, 0.00005414f, 0.00006070f, 0.00006821f, 0.00007648f, 0.00008464f, 0.00009410f, 0.00010524f, 0.00011803f, 0.00013402f, 0.00015319f, 0.00017614f, 0.00020243f, 0.00023094f, 0.00026260f, 0.00029673f, 0.00033499f, 0.00038048f, 0.00043594f, 0.00050952f, 0.00061362f, 0.00076395f, 0.00097908f, 0.00126923f, 0.00163382f, 0.00207590f, 0.00261314f, 0.00327921f, 0.00413303f, 0.00526369f, 0.00684627f, 0.00915649f, 0.01267648f, 0.01800685f, 0.02585007f, 0.03667779f, 0.05118064f, 0.07035894f, 0.09617429f, 0.13094754f, 0.17727190f, 0.23641290f, 0.30751157f, 0.38790047f, 0.47436827f, 0.56468213f, 0.65643377f, 0.74674718f, 0.82841738f, 0.89713046f, 0.94858047f, 0.98476388f, 1.00572477f, 1.01799762f, 1.02241761f, 1.02351216f, 1.02270186f, 1.02115905f, 1.01965328f, 1.01731773f, 1.01540955f, 1.01129946f, 1.00955329f, 1.00573235f, 1.00407549f, 1.00164097f, 1.00130077f, 0.99962912f, 1.00130006f, 1.00140898f, 1.00384853f, 1.00599723f, 1.00910590f, 1.01051975f, 1.01099594f, 1.00890543f, 1.00483865f, 0.99901144f, 0.99220799f, 0.98468953f, 0.97823873f, 0.97314859f, 0.97022501f, 0.96868569f, 0.97004107f, 0.97166154f, 0.97626613f, 0.98067188f, 0.98683373f, 0.99219054f, 0.99666299f, 1.00000000f, 0.99912543f, 0.99696320f, 0.99036225f, 0.98384547f, 0.97519907f, 0.96391617f, 0.94573906f, 0.91096960f, 0.85904551f, 0.79290657f, 0.72361833f, 0.65257621f, 0.57623116f, 0.48870213f, 0.39405229f, 0.29840580f, 0.21347365f, 0.14739732f, 0.10143634f, 0.07106678f, 0.05101665f, 0.03753145f, 0.02803887f, 0.02107987f, 0.01582745f, 0.01178705f, 0.00868732f, 0.00634606f, 0.00461992f, 0.00337907f, 0.00250694f, 0.00189987f, 0.00147499f, 0.00117574f, 0.00096470f, 0.00080813f, 0.00069267f, 0.00060187f, 0.00053101f, 0.00046977f, 0.00041864f, 0.00037515f, 0.00033197f, 0.00029595f, 0.00026098f, 0.00022974f, 0.00020299f, 0.00017878f, 0.00015870f, 0.00014470f, 0.00012912f, 0.00012281f, 0.00011148f, 0.00010580f, 0.00010508f, 0.00009942f, 0.00009982f, 0.00009664f, 0.00009667f, 0.00009589f, 0.00009628f, 0.00009600f, 0.00009459f, 0.00009484f, 0.00009162f, 0.00009246f, 0.00008883f, 0.00008616f, 0.00008688f, 0.00008318f, 0.00008295f, 0.00008153f, 0.00008262f, 0.00008265f, 0.00008855f, 0.00009224f, 0.00008974f, 0.00010120f, 0.00010537f, 0.00010299f, 0.00011271f, 0.00011213f, 0.00011810f, 0.00011639f, 0.00011824f, 0.00011152f, 0.00011302f, 0.00010361f, 0.00010441f, 0.00009482f, 0.00009519f, 0.00008675f, 0.00008735f, 0.00008078f, 0.00008067f, 0.00007509f, 0.00007486f, 0.00006895f, 0.00006944f, 0.00006375f, 0.00006358f, 0.00005878f, 0.00005896f, 0.00005523f, 0.00005501f, 0.00005343f, 0.00005281f, 0.00005140f, 0.00005170f, 0.00005134f, 0.00005138f, 0.00005107f, 0.00005085f, 0.00005096f, 0.00005018f, 0.00005046f, 0.00004904f, 0.00004833f, 0.00004769f, 0.00004781f, 0.00004694f, 0.00004600f, 0.00004584f, 0.00004562f, 0.00004584f, 0.00004525f, 0.00004562f, 0.00004612f, 0.00004747f, 0.00004854f, 0.00004734f, 0.00004932f, 0.00004894f, 0.00005047f, 0.00004972f, 0.00005030f, 0.00005129f, 0.00004999f, 0.00005048f, 0.00004864f, 0.00004901f, 0.00004923f, 0.00004719f, 0.00004950f, 0.00004776f, 0.00005348f, 0.00005702f, 0.00005214f, 0.00006320f, 0.00005556f, 0.00007144f, 0.00005903f, 0.00005649f, 0.00007807f, 0.00004800f, 0.00004042f, 0.00005618f, 0.00002571f, 0.00003251f, 0.00002175f, 0.00000592f, 0.00001077f, 0.00000286f, 0.00000380f, 0.00000323f, 0.00000149f, 0.00000247f, 0.00000112f, 0.00000145f, 0.00000111f, 0.00000139f, 0.00000105f, 0.00000141f, 0.00000097f, 0.00000085f, 0.00000123f, 0.00000158f, 0.00000089f, 0.00000137f, 0.00000086f, 0.00000158f, 0.00000202f, 0.00000091f, 0.00000174f, 0.00000102f, 0.00000200f, 0.00000128f, 0.00000479f, 0.00000149f, 0.00000719f, 0.00000417f, 0.00000502f, 0.00000963f, 0.00000561f, 0.00000984f, 0.00000949f, 0.00000318f, 0.00000643f, 0.00000153f, 0.00000184f, 0.00000116f, 0.00000173f, 0.00000086f, 0.00000185f, 0.00000089f, 0.00000193f, 0.00000096f, 0.00000196f, 0.00000116f, 0.00000200f, 0.00000115f, 0.00000195f, 0.00000131f, 0.00000197f, 0.00000125f, 0.00000187f, 0.00000099f, 0.00000070f, 0.00000049f, 0.00000119f, 0.00000051f, 0.00000135f, 0.00000086f, 0.00000153f, 0.00000104f, 0.00000186f, 0.00000156f, 0.00000205f, 0.00000293f, 0.00000170f, 0.00000296f, 0.00000182f, 0.00000266f, 0.00000171f, 0.00000236f, 0.00000240f, 0.00000093f, 0.00000174f, 0.00000183f, 0.00000096f, 0.00000144f, 0.00000177f, 0.00000076f, 0.00000198f, 0.00000079f, 0.00000160f, 0.00000058f, 0.00000154f, 0.00000070f, 0.00000161f, 0.00000076f, 0.00000068f, 0.00000245f, 0.00000079f, 0.00000299f, 0.00000128f, 0.00000285f, 0.00000154f, 0.00000296f, 0.00000178f, 0.00000333f, 0.00000130f, 0.00000347f, 0.00000220f, 0.00000159f, 0.00000449f, 0.00000188f, 0.00000635f, 0.00000903f, 0.00000344f, 0.00001051f, 0.00000601f, 0.00000991f, 0.00001299f, 0.00000632f, 0.00001514f, 0.00000941f, 0.00001426f, 0.00000749f, 0.00001524f, 0.00000887f, 0.00000743f, 0.00001404f, 0.00000558f, 0.00001092f, 0.00001135f, 0.00000460f, 0.00001024f, 0.00000547f, 0.00001036f, 0.00000503f, 0.00001140f, 0.00000557f, 0.00001124f, 0.00000612f, 0.00001120f, 0.00000642f, 0.00001093f, 0.00000638f, 0.00001191f, 0.00000531f, 0.00000907f, 0.00000487f, 0.00000794f, 0.00000998f, 0.00000316f, 0.00000322f, 0.00001260f, 0.00000365f, 0.00000446f, 0.00001209f, 0.00000567f, 0.00001173f, 0.00000705f, 0.00001006f, 0.00000466f, 0.00000325f, 0.00000921f, 0.00000755f, 0.00000493f, 0.00000922f, 0.00000673f, 0.00001643f, 0.00001135f, 0.00001160f, 0.00002335f, 0.00001573f, 0.00002364f, 0.00001931f, 0.00002613f, 0.00002318f, 0.00001698f, 0.00001954f, 0.00001127f, 0.00001395f, 0.00001618f, 0.00000862f, 0.00001383f, 0.00000962f, 0.00000696f, 0.00000696f, 0.00000561f, 0.00000807f, 0.00000905f, 0.00000632f, 0.00000850f, 0.00000820f, 0.00001222f, 0.00000921f, 0.00001027f, 0.00001204f, 0.00001323f, 0.00001373f, 0.00001579f, 0.00001521f, 0.00002156f, 0.00001894f, 0.00002375f, 0.00002243f, 0.00002409f, 0.00002019f, 0.00002182f, 0.00001452f, 0.00001755f, 0.00001475f, 0.00000805f, 0.00001071f, 0.00000537f, 0.00000682f, 0.00000663f, 0.00000526f, 0.00000418f, 0.00000477f, 0.00000426f, 0.00000405f, 0.00000367f, 0.00000399f, 0.00000340f, 0.00000339f, 0.00000169f, 0.00000178f, 0.00000242f, 0.00000171f, 0.00000172f, 0.00000233f, 0.00000182f, 0.00000230f, 0.00000204f, 0.00000245f, 0.00000243f, 0.00000136f, 0.00000259f, 0.00000105f, 0.00000239f, 0.00000090f, 0.00000213f, 0.00000104f, 0.00000226f, 0.00000088f, 0.00000229f, 0.00000065f, 0.00000246f, 0.00000063f, 0.00000238f, 0.00000072f, 0.00000210f, 0.00000091f, 0.00000122f, 0.00000184f, 0.00000177f, 0.00000066f, 0.00000153f, 0.00000065f, 0.00000147f, 0.00000054f, 0.00000145f, 0.00000023f, 0.00000134f, 0.00000029f, 0.00000141f, 0.00000045f, 0.00000127f, 0.00000146f, 0.00000040f, 0.00000142f, 0.00000038f }; //B2 red band const float b2[601] = { 0.00001168f, 0.00001419f, 0.00001348f, 0.00000996f, 0.00001009f, 0.00001366f, 0.00003289f, 0.00001748f, 0.00002207f, 0.00002377f, 0.00002383f, 0.00002470f, 0.00001811f, 0.00001353f, 0.00001155f, 0.00001303f, 0.00001374f, 0.00001126f, 0.00000712f, 0.00000464f, 0.00000438f, 0.00000381f, 0.00000312f, 0.00000581f, 0.00000319f, 0.00000473f, 0.00000585f, 0.00000644f, 0.00000967f, 0.00000918f, 0.00000742f, 0.00001090f, 0.00001649f, 0.00002016f, 0.00001631f, 0.00001673f, 0.00001578f, 0.00001766f, 0.00002209f, 0.00003114f, 0.00003091f, 0.00001848f, 0.00003451f, 0.00003492f, 0.00004332f, 0.00004770f, 0.00004658f, 0.00004547f, 0.00004239f, 0.00005155f, 0.00005834f, 0.00006365f, 0.00005824f, 0.00004581f, 0.00003799f, 0.00003584f, 0.00003689f, 0.00003817f, 0.00003951f, 0.00004017f, 0.00003987f, 0.00003754f, 0.00003651f, 0.00003781f, 0.00003645f, 0.00003408f, 0.00003160f, 0.00003251f, 0.00003509f, 0.00003935f, 0.00004494f, 0.00005115f, 0.00005707f, 0.00006145f, 0.00006038f, 0.00005716f, 0.00005354f, 0.00004978f, 0.00004759f, 0.00004735f, 0.00005985f, 0.00006501f, 0.00005803f, 0.00006474f, 0.00006650f, 0.00006908f, 0.00006585f, 0.00005102f, 0.00003616f, 0.00002648f, 0.00002034f, 0.00001645f, 0.00001363f, 0.00001142f, 0.00000950f, 0.00000755f, 0.00000648f, 0.00000560f, 0.00000476f, 0.00000466f, 0.00000444f, 0.00000389f, 0.00000408f, 0.00000399f, 0.00000392f, 0.00000436f, 0.00000413f, 0.00000397f, 0.00000424f, 0.00000400f, 0.00000389f, 0.00000385f, 0.00000390f, 0.00000379f, 0.00000357f, 0.00000383f, 0.00000386f, 0.00000378f, 0.00000439f, 0.00000377f, 0.00000416f, 0.00000494f, 0.00000455f, 0.00000553f, 0.00000605f, 0.00000613f, 0.00000672f, 0.00000696f, 0.00000744f, 0.00000760f, 0.00000766f, 0.00000770f, 0.00000725f, 0.00000682f, 0.00000716f, 0.00000758f, 0.00000759f, 0.00000722f, 0.00000805f, 0.00000826f, 0.00000816f, 0.00000835f, 0.00000798f, 0.00000798f, 0.00000796f, 0.00000817f, 0.00000856f, 0.00000897f, 0.00000920f, 0.00000935f, 0.00000980f, 0.00001003f, 0.00000998f, 0.00001038f, 0.00001044f, 0.00001035f, 0.00001090f, 0.00001143f, 0.00001155f, 0.00001240f, 0.00001322f, 0.00001374f, 0.00001466f, 0.00001507f, 0.00001561f, 0.00001799f, 0.00001806f, 0.00001990f, 0.00002207f, 0.00002400f, 0.00002768f, 0.00003153f, 0.00003519f, 0.00003855f, 0.00004048f, 0.00004339f, 0.00004685f, 0.00004712f, 0.00004885f, 0.00005031f, 0.00005058f, 0.00005380f, 0.00006109f, 0.00006875f, 0.00008360f, 0.00010367f, 0.00013385f, 0.00017220f, 0.00021349f, 0.00025613f, 0.00029745f, 0.00033957f, 0.00038077f, 0.00042014f, 0.00045664f, 0.00049082f, 0.00052462f, 0.00057202f, 0.00064046f, 0.00073788f, 0.00088389f, 0.00109195f, 0.00138377f, 0.00179072f, 0.00234897f, 0.00310035f, 0.00409611f, 0.00539886f, 0.00764596f, 0.00982485f, 0.01250677f, 0.01576553f, 0.01971871f, 0.02460136f, 0.03076162f, 0.03870973f, 0.04932564f, 0.06405112f, 0.08527458f, 0.11683854f, 0.16336997f, 0.22811553f, 0.30778033f, 0.39105868f, 0.46939880f, 0.54633346f, 0.62987089f, 0.71765372f, 0.80227884f, 0.87400338f, 0.92669327f, 0.95728386f, 0.97246242f, 0.98093913f, 0.98815314f, 0.99512479f, 1.00000000f, 1.00071278f, 0.99509151f, 0.98322813f, 0.96618038f, 0.94726377f, 0.92911907f, 0.91427200f, 0.90407257f, 0.89868685f, 0.89729260f, 0.90048309f, 0.90619876f, 0.91486402f, 0.92548194f, 0.93716217f, 0.95109280f, 0.96341044f, 0.97756310f, 0.98873468f, 1.00002059f, 1.00784176f, 1.01361246f, 1.01518655f, 1.01365106f, 1.00889905f, 1.00094470f, 0.99098939f, 0.97907661f, 0.96736515f, 0.95491923f, 0.94403019f, 0.93408742f, 0.92588661f, 0.91979557f, 0.91551236f, 0.91345541f, 0.91406966f, 0.91586446f, 0.92112352f, 0.92637606f, 0.93343259f, 0.93977000f, 0.94511856f, 0.94655018f, 0.94482431f, 0.93695460f, 0.92470622f, 0.90515848f, 0.87651239f, 0.84722733f, 0.81626058f, 0.77926628f, 0.74095072f, 0.69853161f, 0.65530863f, 0.60957078f, 0.56408506f, 0.51760530f, 0.47150814f, 0.42482252f, 0.37706746f, 0.32909071f, 0.28093192f, 0.23513938f, 0.19289082f, 0.15584587f, 0.12438828f, 0.09857760f, 0.07759031f, 0.06074302f, 0.04708451f, 0.03618668f, 0.02749464f, 0.02064713f, 0.01533676f, 0.01131374f, 0.00832392f, 0.00613477f, 0.00454626f, 0.00340798f, 0.00258536f, 0.00199356f, 0.00156305f, 0.00125005f, 0.00101327f, 0.00085049f, 0.00071368f, 0.00062520f, 0.00054959f, 0.00049985f, 0.00047162f, 0.00043891f, 0.00042848f, 0.00040347f, 0.00038227f, 0.00035692f, 0.00033769f, 0.00030789f, 0.00029814f, 0.00024879f, 0.00021170f, 0.00018471f, 0.00013393f, 0.00012509f, 0.00007240f, 0.00006419f, 0.00003891f, 0.00003294f, 0.00002353f, 0.00002711f, 0.00001690f, 0.00001474f, 0.00001598f, 0.00001292f, 0.00001366f, 0.00001329f, 0.00001411f, 0.00002354f, 0.00009563f, 0.00012882f, 0.00011528f, 0.00001687f, 0.00015343f, 0.00012777f, 0.00015354f, 0.00024298f, 0.00015520f, 0.00024274f, 0.00012696f, 0.00014910f, 0.00000979f, 0.00000629f, 0.00000738f, 0.00000483f, 0.00000489f, 0.00000536f, 0.00000458f, 0.00000528f, 0.00000438f, 0.00000475f, 0.00000446f, 0.00000488f, 0.00000456f, 0.00000547f, 0.00000448f, 0.00000478f, 0.00000435f, 0.00000470f, 0.00000425f, 0.00000458f, 0.00000435f, 0.00000380f, 0.00000373f, 0.00000298f, 0.00000390f, 0.00000278f, 0.00000290f, 0.00000277f, 0.00000307f, 0.00000247f, 0.00000231f, 0.00000301f, 0.00000293f, 0.00000319f, 0.00000351f, 0.00000323f, 0.00000339f, 0.00000318f, 0.00000318f, 0.00000396f, 0.00000313f, 0.00000364f, 0.00000310f, 0.00000419f, 0.00000349f, 0.00000396f, 0.00000341f, 0.00000365f, 0.00000362f, 0.00000290f, 0.00000345f, 0.00000289f, 0.00000288f, 0.00000429f, 0.00000323f, 0.00000329f, 0.00000329f, 0.00000455f, 0.00000497f, 0.00000353f, 0.00000556f, 0.00000383f, 0.00000507f, 0.00000482f, 0.00000484f, 0.00000546f, 0.00000374f, 0.00000601f, 0.00000422f, 0.00000512f, 0.00000509f, 0.00000286f, 0.00000637f, 0.00000539f, 0.00000579f, 0.00000462f, 0.00000647f, 0.00000604f, 0.00000432f, 0.00000662f, 0.00000521f, 0.00000680f, 0.00001180f, 0.00000638f, 0.00000805f, 0.00000389f, 0.00001200f, 0.00001134f, 0.00000562f, 0.00001181f, 0.00000868f, 0.00001541f, 0.00001086f, 0.00001222f, 0.00000823f, 0.00000960f, 0.00000871f, 0.00001051f, 0.00001235f, 0.00000864f, 0.00001357f, 0.00001158f, 0.00001522f, 0.00001091f, 0.00001237f, 0.00000928f, 0.00000973f, 0.00000865f, 0.00001333f, 0.00000847f, 0.00001329f, 0.00000740f, 0.00000974f, 0.00001229f, 0.00001128f, 0.00000704f, 0.00001244f, 0.00000915f, 0.00001448f, 0.00001164f, 0.00000861f, 0.00001441f, 0.00000700f, 0.00001461f, 0.00001401f, 0.00001007f, 0.00001695f, 0.00002042f, 0.00002108f, 0.00003064f, 0.00003171f, 0.00004339f, 0.00004171f, 0.00005692f, 0.00007019f, 0.00007121f, 0.00007122f, 0.00008504f, 0.00007450f, 0.00008010f, 0.00008936f, 0.00008826f, 0.00008831f, 0.00009721f, 0.00009019f, 0.00008741f, 0.00008467f, 0.00007373f, 0.00006748f, 0.00006984f, 0.00005307f, 0.00004844f, 0.00005417f, 0.00004482f, 0.00004483f, 0.00003814f, 0.00003524f, 0.00002726f, 0.00002455f, 0.00002566f, 0.00002043f, 0.00001759f, 0.00001473f, 0.00001512f, 0.00001132f, 0.00000862f, 0.00001262f, 0.00000857f, 0.00000918f, 0.00000689f, 0.00000671f, 0.00000434f, 0.00000648f, 0.00000513f, 0.00000748f, 0.00000691f, 0.00000789f, 0.00000754f, 0.00000715f, 0.00000806f, 0.00000701f, 0.00000449f, 0.00000640f, 0.00000595f, 0.00000877f, 0.00000724f, 0.00000837f, 0.00000733f, 0.00000815f, 0.00000621f, 0.00000755f, 0.00000444f, 0.00000580f, 0.00000524f, 0.00000343f, 0.00000356f, 0.00000340f, 0.00000361f, 0.00000245f, 0.00000146f, 0.00000232f, 0.00000165f, 0.00000168f, 0.00000491f, 0.00000168f, 0.00000411f, 0.00000122f, 0.00000367f, 0.00000244f, 0.00000179f, 0.00000395f, 0.00000177f, 0.00000108f, 0.00000330f, 0.00000166f, 0.00000258f, 0.00000204f, 0.00000054f, 0.00000259f, 0.00000133f, 0.00000205f, 0.00000101f, 0.00000210f, 0.00000084f, 0.00000090f, 0.00000176f, 0.00000079f, 0.00000165f, 0.00000071f, 0.00000173f, 0.00000070f, 0.00000043f, 0.00000056f, 0.00000159f }; //B3 nir band const float b3[601] = { 0.00000184f, 0.00000202f, 0.00000371f, 0.00000470f, 0.00000487f, 0.00000512f, 0.00000521f, 0.00000490f, 0.00000308f, 0.00000160f, 0.00000126f, 0.00000131f, 0.00000119f, 0.00000105f, 0.00000082f, 0.00000078f, 0.00000076f, 0.00000059f, 0.00000058f, 0.00000052f, 0.00000064f, 0.00000070f, 0.00000068f, 0.00000068f, 0.00000079f, 0.00000093f, 0.00000124f, 0.00000092f, 0.00000124f, 0.00000117f, 0.00000125f, 0.00000129f, 0.00000121f, 0.00000153f, 0.00000149f, 0.00000148f, 0.00000139f, 0.00000166f, 0.00000211f, 0.00000193f, 0.00000241f, 0.00000211f, 0.00000228f, 0.00000294f, 0.00000406f, 0.00000507f, 0.00001753f, 0.00062612f, 0.00099041f, 0.00038281f, 0.00084800f, 0.00090343f, 0.00098820f, 0.00100027f, 0.00030612f, 0.00003473f, 0.00002650f, 0.00002396f, 0.00002429f, 0.00002735f, 0.00003712f, 0.00005612f, 0.00007768f, 0.00008914f, 0.00009611f, 0.00010759f, 0.00011246f, 0.00011011f, 0.00009290f, 0.00006854f, 0.00005014f, 0.00003890f, 0.00003142f, 0.00002673f, 0.00002266f, 0.00002061f, 0.00002008f, 0.00002029f, 0.00002207f, 0.00002564f, 0.00003063f, 0.00003885f, 0.00004812f, 0.00005996f, 0.00007077f, 0.00007965f, 0.00008609f, 0.00008841f, 0.00008691f, 0.00008090f, 0.00007026f, 0.00005867f, 0.00004706f, 0.00003684f, 0.00002888f, 0.00002252f, 0.00001864f, 0.00001631f, 0.00001512f, 0.00001579f, 0.00001740f, 0.00002076f, 0.00002500f, 0.00002970f, 0.00003324f, 0.00003568f, 0.00003719f, 0.00003637f, 0.00003522f, 0.00003204f, 0.00002806f, 0.00002554f, 0.00002401f, 0.00002509f, 0.00002676f, 0.00003097f, 0.00003703f, 0.00004613f, 0.00006025f, 0.00007876f, 0.00010325f, 0.00012473f, 0.00014349f, 0.00015902f, 0.00017128f, 0.00017677f, 0.00017814f, 0.00017111f, 0.00016498f, 0.00016271f, 0.00016590f, 0.00017244f, 0.00018189f, 0.00018854f, 0.00019224f, 0.00019405f, 0.00019354f, 0.00018898f, 0.00018087f, 0.00017218f, 0.00016359f, 0.00015899f, 0.00015586f, 0.00015606f, 0.00015819f, 0.00016068f, 0.00016530f, 0.00016816f, 0.00017049f, 0.00017164f, 0.00017169f, 0.00017074f, 0.00017054f, 0.00016913f, 0.00016744f, 0.00016766f, 0.00016951f, 0.00017426f, 0.00018167f, 0.00019232f, 0.00020428f, 0.00021790f, 0.00023244f, 0.00024402f, 0.00025416f, 0.00026158f, 0.00026375f, 0.00026297f, 0.00026655f, 0.00026988f, 0.00027504f, 0.00028070f, 0.00028807f, 0.00030046f, 0.00031707f, 0.00033920f, 0.00036610f, 0.00039570f, 0.00043575f, 0.00048703f, 0.00053825f, 0.00057909f, 0.00060314f, 0.00061674f, 0.00061491f, 0.00059039f, 0.00054258f, 0.00047833f, 0.00039787f, 0.00031987f, 0.00025214f, 0.00019590f, 0.00015376f, 0.00012305f, 0.00010304f, 0.00008730f, 0.00007548f, 0.00006686f, 0.00006139f, 0.00005448f, 0.00005006f, 0.00004759f, 0.00004287f, 0.00003904f, 0.00003667f, 0.00003331f, 0.00003138f, 0.00002877f, 0.00002657f, 0.00002417f, 0.00002328f, 0.00002129f, 0.00002036f, 0.00001896f, 0.00001779f, 0.00001738f, 0.00001579f, 0.00001598f, 0.00001498f, 0.00001430f, 0.00001381f, 0.00001310f, 0.00001315f, 0.00001249f, 0.00001236f, 0.00001250f, 0.00001178f, 0.00001194f, 0.00001165f, 0.00001136f, 0.00001177f, 0.00001162f, 0.00001149f, 0.00001162f, 0.00001162f, 0.00001183f, 0.00001163f, 0.00001211f, 0.00001182f, 0.00001142f, 0.00001146f, 0.00001129f, 0.00001064f, 0.00001038f, 0.00001123f, 0.00001061f, 0.00001039f, 0.00001007f, 0.00001068f, 0.00001053f, 0.00001131f, 0.00001150f, 0.00001210f, 0.00001199f, 0.00001228f, 0.00001244f, 0.00001267f, 0.00001226f, 0.00001236f, 0.00001242f, 0.00001236f, 0.00001227f, 0.00001222f, 0.00001218f, 0.00001214f, 0.00001206f, 0.00001202f, 0.00001242f, 0.00001231f, 0.00001283f, 0.00001325f, 0.00001395f, 0.00001410f, 0.00001399f, 0.00001534f, 0.00001580f, 0.00001690f, 0.00001748f, 0.00001885f, 0.00001898f, 0.00001988f, 0.00002137f, 0.00002320f, 0.00002504f, 0.00002641f, 0.00002837f, 0.00003079f, 0.00003251f, 0.00003533f, 0.00003740f, 0.00004081f, 0.00004361f, 0.00004639f, 0.00004986f, 0.00005346f, 0.00005805f, 0.00006226f, 0.00006694f, 0.00007188f, 0.00007800f, 0.00008485f, 0.00009055f, 0.00010008f, 0.00010713f, 0.00011933f, 0.00012975f, 0.00014324f, 0.00015785f, 0.00017539f, 0.00019507f, 0.00021689f, 0.00024318f, 0.00027135f, 0.00030518f, 0.00034281f, 0.00039712f, 0.00044651f, 0.00050188f, 0.00056707f, 0.00063984f, 0.00072378f, 0.00081879f, 0.00092782f, 0.00105511f, 0.00120160f, 0.00137088f, 0.00156792f, 0.00180276f, 0.00207920f, 0.00240799f, 0.00280298f, 0.00327494f, 0.00384821f, 0.00454832f, 0.00540493f, 0.00645469f, 0.00774941f, 0.00936399f, 0.01137832f, 0.01388118f, 0.01700597f, 0.02092752f, 0.02586928f, 0.03206911f, 0.03985523f, 0.04956652f, 0.06173849f, 0.07680296f, 0.09550239f, 0.11837088f, 0.14615821f, 0.19110224f, 0.23178705f, 0.27801636f, 0.33031673f, 0.38771033f, 0.44914649f, 0.51370254f, 0.57939644f, 0.64484781f, 0.70835304f, 0.76788190f, 0.82252523f, 0.87063314f, 0.91086251f, 0.94360264f, 0.96734308f, 0.98447500f, 0.99402844f, 0.99904759f, 1.00000000f, 0.99829749f, 0.99534944f, 0.99113813f, 0.98712837f, 0.98344438f, 0.97955733f, 0.97683333f, 0.97381307f, 0.97171326f, 0.96937935f, 0.96682308f, 0.96494693f, 0.96155704f, 0.95914861f, 0.95524656f, 0.95141098f, 0.94725240f, 0.94238136f, 0.93805030f, 0.93299243f, 0.92787669f, 0.92261726f, 0.91765026f, 0.91344782f, 0.90866986f, 0.90481152f, 0.90031693f, 0.89720732f, 0.89342505f, 0.89040645f, 0.88745245f, 0.88446834f, 0.88140255f, 0.87825555f, 0.87487903f, 0.87077850f, 0.86665463f, 0.86193864f, 0.85704385f, 0.85203260f, 0.84608531f, 0.84067874f, 0.83464870f, 0.82847182f, 0.82237664f, 0.81646034f, 0.81067178f, 0.80547624f, 0.79996761f, 0.79538371f, 0.79048464f, 0.78593335f, 0.78246221f, 0.77854086f, 0.77505353f, 0.77183963f, 0.76834628f, 0.76559075f, 0.76238953f, 0.75915219f, 0.75631414f, 0.75288758f, 0.74984835f, 0.74648701f, 0.74311251f, 0.73936992f, 0.73559705f, 0.73163277f, 0.72765295f, 0.72334537f, 0.71892768f, 0.71424776f, 0.70932732f, 0.70417024f, 0.69865547f, 0.69314542f, 0.68706957f, 0.68120878f, 0.67553032f, 0.66989091f, 0.66440763f, 0.65922988f, 0.65415969f, 0.64965635f, 0.64537477f, 0.64153052f, 0.63820324f, 0.63506916f, 0.63264959f, 0.62992135f, 0.62726732f, 0.62445640f, 0.62156999f, 0.61847181f, 0.61501909f, 0.61133939f, 0.60744762f, 0.60314205f, 0.59883705f, 0.59425662f, 0.58928886f, 0.58381508f, 0.57719033f, 0.56857851f, 0.55699311f, 0.54163099f, 0.52202898f, 0.49847084f, 0.47191641f, 0.44270534f, 0.41155122f, 0.37843868f, 0.34304355f, 0.30590964f, 0.26730226f, 0.22805403f, 0.18974714f, 0.15369596f, 0.12145605f, 0.09413162f, 0.07189929f, 0.05457376f, 0.04144546f, 0.03158417f, 0.02425525f, 0.01879617f, 0.01470317f, 0.01163795f, 0.00930858f, 0.00744330f, 0.00607348f, 0.00501379f, 0.00413379f, 0.00347084f, 0.00293573f, 0.00250919f, 0.00215786f, 0.00186591f, 0.00163284f, 0.00142997f, 0.00127599f, 0.00112918f, 0.00102171f, 0.00091069f, 0.00083541f, 0.00075489f, 0.00069931f, 0.00063879f, 0.00059080f, 0.00055023f, 0.00050660f, 0.00047777f, 0.00044789f, 0.00041317f, 0.00039493f, 0.00035947f, 0.00033744f, 0.00031989f, 0.00028719f, 0.00027707f, 0.00025430f, 0.00023132f, 0.00022543f, 0.00019537f, 0.00018380f, 0.00016713f, 0.00014542f, 0.00013876f, 0.00011616f, 0.00011019f, 0.00009086f, 0.00009183f, 0.00006774f, 0.00006181f, 0.00006360f, 0.00004633f, 0.00005224f, 0.00003735f, 0.00003902f, 0.00002393f, 0.00003180f, 0.00001716f, 0.00001762f, 0.00002033f, 0.00001262f, 0.00001259f, 0.00001118f, 0.00001421f, 0.00000830f, 0.00001294f, 0.00000699f, 0.00000782f, 0.00000718f, 0.00000642f, 0.00000548f, 0.00000427f, 0.00000417f, 0.00000440f, 0.00000377f, 0.00000253f, 0.00000456f, 0.00000202f, 0.00000373f, 0.00000325f, 0.00000341f, 0.00000232f, 0.00000301f, 0.00000117f, 0.00000319f, 0.00000169f, 0.00000286f, 0.00000184f, 0.00000260f, 0.00000212f, 0.00000293f, 0.00000175f, 0.00000229f, 0.00000126f, 0.00000232f, 0.00000099f, 0.00000250f, 0.00000135f, 0.00000090f, 0.00000289f, 0.00000070f, 0.00000210f, 0.00000118f, 0.00000072f, 0.00000182f, 0.00000111f }; //Add multispectral bands to the temporary list const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); const std::vector vb1 (b1, b1 + sizeof(b1) / sizeof(float) ); const std::vector vb2 (b2, b2 + sizeof(b2) / sizeof(float) ); const std::vector vb3 (b3, b3 + sizeof(b3) / sizeof(float) ); //For Spot6 MS image the order of band is: B2 B1 B0 B3 //(BandIndexToWavelength method could be used here) tmpSpectralBandList.push_back(vb2); tmpSpectralBandList.push_back(vb1); tmpSpectralBandList.push_back(vb0); tmpSpectralBandList.push_back(vb3); } else if (sensorId == "SPOT 7") { //band B0 (blue band) const float b0[241] = { 0.00006223f, 0.00009415f, 0.00012429f, 0.00013639f, 0.00013753f, 0.00012891f, 0.00010218f, 0.00009278f, 0.00008783f, 0.00009141f, 0.00009723f, 0.00010706f, 0.00010524f, 0.00020698f, 0.00039717f, 0.00075474f, 0.00127926f, 0.00311549f, 0.01205305f, 0.06233600f, 0.18105752f, 0.38256698f, 0.59043414f, 0.70848867f, 0.77207521f, 0.79575312f, 0.80384998f, 0.81939978f, 0.84908020f, 0.87380894f, 0.88619128f, 0.89387948f, 0.90177013f, 0.90729110f, 0.91984833f, 0.93185189f, 0.95079208f, 0.95735099f, 0.94209245f, 0.92804056f, 0.94022333f, 0.95422481f, 0.96305217f, 0.96145513f, 0.96493862f, 0.98962585f, 1.00000000f, 0.95819838f, 0.84154929f, 0.65895898f, 0.39954244f, 0.18259058f, 0.07126465f, 0.02385368f, 0.00665853f, 0.00371385f, 0.00301785f, 0.00199155f, 0.00060530f, 0.00028358f, 0.00016827f, 0.00020355f, 0.00021207f, 0.00025503f, 0.00031159f, 0.00030672f, 0.00028100f, 0.00027885f, 0.00027786f, 0.00029299f, 0.00028906f, 0.00032038f, 0.00032455f, 0.00031566f, 0.00031624f, 0.00034902f, 0.00034040f, 0.00030293f, 0.00027660f, 0.00028711f, 0.00028857f, 0.00026469f, 0.00024329f, 0.00027568f, 0.00028253f, 0.00027954f, 0.00022052f, 0.00021894f, 0.00022427f, 0.00022480f, 0.00027263f, 0.00027193f, 0.00028123f, 0.00029369f, 0.00032476f, 0.00027348f, 0.00019338f, 0.00019522f, 0.00022102f, 0.00026397f, 0.00032200f, 0.00030746f, 0.00028825f, 0.00056141f, 0.00098123f, 0.00115372f, 0.00083003f, 0.00034274f, 0.00030276f, 0.00136481f, 0.00174203f, 0.00528887f, 0.00363463f, 0.00263354f, 0.00023767f, 0.00085373f, 0.00308313f, 0.00383517f, 0.00350842f, 0.00187129f, 0.00114591f, 0.00039397f, 0.00036147f, 0.00047659f, 0.00028036f, 0.00032295f, 0.00022860f, 0.00021316f, 0.00024186f, 0.00015903f, 0.00019401f, 0.00016204f, 0.00022580f, 0.00014776f, 0.00016706f, 0.00014137f, 0.00018257f, 0.00013750f, 0.00020102f, 0.00016524f, 0.00022404f, 0.00013058f, 0.00017588f, 0.00021843f, 0.00033274f, 0.00040937f, 0.00022751f, 0.00026991f, 0.00011570f, 0.00018936f, 0.00007716f, 0.00009678f, 0.00005590f, 0.00014024f, 0.00006012f, 0.00008625f, 0.00005988f, 0.00007702f, 0.00004836f, 0.00005283f, 0.00001724f, 0.00008368f, 0.00015662f, 0.00018147f, 0.00014258f, 0.00019128f, 0.00017554f, 0.00015024f, 0.00009702f, 0.00011595f, 0.00009845f, 0.00010465f, 0.00007963f, 0.00010628f, 0.00011597f, 0.00009482f, 0.00008396f, 0.00014762f, 0.00016181f, 0.00021927f, 0.00024570f, 0.00031710f, 0.00034636f, 0.00041754f, 0.00047979f, 0.00047446f, 0.00046590f, 0.00045465f, 0.00046585f, 0.00048115f, 0.00050182f, 0.00046597f, 0.00044784f, 0.00040927f, 0.00037423f, 0.00045082f, 0.00060266f, 0.00068456f, 0.00095082f, 0.00158306f, 0.00213891f, 0.00203578f, 0.00209486f, 0.00179064f, 0.00170038f, 0.00133240f, 0.00127140f, 0.00103228f, 0.00083963f, 0.00080970f, 0.00080732f, 0.00071204f, 0.00076914f, 0.00090316f, 0.00113432f, 0.00122795f, 0.00121075f, 0.00226176f, 0.00213613f, 0.00268812f, 0.00258953f, 0.00201580f, 0.00199608f, 0.00087274f, 0.00076959f, 0.00026605f, 0.00023035f, 0.00008012f, 0.00002169f, 0.00002845f, 0.00002870f, 0.00001083f, 0.00000787f, 0.00000498f, 0.00000366f, 0.00000709f, 0.00001239f, 0.00000419f, 0.00000676f, 0.00000507f, 0.00000356f }; //band B1 (green band) const float b1[241] = { 0.00000000f, 0.00000000f, 0.00000386f, 0.00000566f, 0.00000404f, 0.00000759f, 0.00001803f, 0.00002936f, 0.00003640f, 0.00003122f, 0.00001728f, 0.00001678f, 0.00000855f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00001174f, 0.00003061f, 0.00001542f, 0.00000002f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00001264f, 0.00003533f, 0.00001653f, 0.00000938f, 0.00003380f, 0.00001204f, 0.00002568f, 0.00006421f, 0.00011657f, 0.00019268f, 0.00034781f, 0.00065634f, 0.00158903f, 0.00438411f, 0.01335476f, 0.06107908f, 0.18681701f, 0.40314601f, 0.65792919f, 0.80353053f, 0.82833979f, 0.80070713f, 0.81789228f, 0.86938944f, 0.91191222f, 0.93590656f, 0.94933428f, 0.95315901f, 0.95612825f, 0.96015344f, 0.96488804f, 0.97405185f, 0.98775038f, 0.99694634f, 0.99953635f, 0.99920681f, 0.99995509f, 1.00000000f, 0.98413416f, 0.92515351f, 0.85770369f, 0.75506786f, 0.65784685f, 0.53623586f, 0.31657708f, 0.12855983f, 0.04354890f, 0.01832512f, 0.00806139f, 0.00339129f, 0.00133028f, 0.00066241f, 0.00033912f, 0.00014269f, 0.00005860f, 0.00002161f, 0.00004310f, 0.00005128f, 0.00005092f, 0.00002347f, 0.00000002f, 0.00000650f, 0.00002838f, 0.00003072f, 0.00001848f, 0.00002796f, 0.00001389f, 0.00000612f, 0.00000025f, 0.00003069f, 0.00003600f, 0.00001337f, 0.00002671f, 0.00002978f, 0.00003422f, 0.00001379f, 0.00002347f, 0.00004055f, 0.00002227f, 0.00001294f, 0.00003483f, 0.00001712f, 0.00000002f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00001081f, 0.00000769f, 0.00002469f, 0.00003172f, 0.00001765f, 0.00001146f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f, 0.00001915f, 0.00010077f, 0.00009227f, 0.00036170f, 0.00041903f, 0.00028285f, 0.00011955f, 0.00013258f, 0.00013216f, 0.00016185f, 0.00023636f, 0.00022910f, 0.00016182f, 0.00003655f, 0.00000822f, 0.00000813f, 0.00002457f, 0.00005473f, 0.00014214f, 0.00013627f, 0.00019327f, 0.00023474f, 0.00020969f, 0.00028852f, 0.00027134f, 0.00022611f, 0.00017862f, 0.00011338f, 0.00010355f, 0.00010164f, 0.00006384f, 0.00006032f, 0.00005830f, 0.00004039f, 0.00003523f, 0.00004225f, 0.00005370f, 0.00006190f, 0.00004503f, 0.00007030f, 0.00007374f, 0.00007399f, 0.00009285f, 0.00007544f, 0.00008048f, 0.00007956f, 0.00014808f, 0.00028476f, 0.00033229f, 0.00059065f, 0.00081565f, 0.00091910f, 0.00084857f, 0.00064772f, 0.00049455f, 0.00030383f, 0.00028348f, 0.00026936f, 0.00027984f, 0.00026084f, 0.00027212f, 0.00018413f, 0.00012211f, 0.00012484f, 0.00011296f, 0.00019231f, 0.00027856f, 0.00040423f, 0.00056768f, 0.00054620f, 0.00053311f, 0.00061131f, 0.00042033f, 0.00034603f, 0.00022132f, 0.00021608f, 0.00020483f, 0.00012462f, 0.00008773f, 0.00008066f, 0.00008884f, 0.00008933f, 0.00006750f, 0.00007617f, 0.00007908f, 0.00006165f, 0.00004525f, 0.00004836f, 0.00003234f, 0.00003518f, 0.00003174f, 0.00001670f, 0.00001955f, 0.00000830f, 0.00001164f, 0.00000610f, 0.00000576f, 0.00000441f, 0.00000591f, 0.00000682f, 0.00000867f }; //band B2 (red band) const float b2[241] = { 0.00006712f, 0.00010372f, 0.00014401f, 0.00016823f, 0.00018607f, 0.00020871f, 0.00050585f, 0.00279268f, 0.00632703f, 0.00707717f, 0.00330878f, 0.00074050f, 0.00128845f, 0.00173704f, 0.00116168f, 0.00082131f, 0.00110044f, 0.00126307f, 0.00132016f, 0.00114549f, 0.00107557f, 0.00144593f, 0.00153967f, 0.00088105f, 0.00082143f, 0.00114470f, 0.00127469f, 0.00133542f, 0.00115328f, 0.00079149f, 0.00077299f, 0.00090499f, 0.00105427f, 0.00090991f, 0.00083955f, 0.00066794f, 0.00067541f, 0.00066792f, 0.00068078f, 0.00080775f, 0.00085164f, 0.00085421f, 0.00082583f, 0.00080782f, 0.00079826f, 0.00092916f, 0.00091108f, 0.00094218f, 0.00089515f, 0.00076910f, 0.00082056f, 0.00081487f, 0.00081175f, 0.00089594f, 0.00104200f, 0.00111628f, 0.00108311f, 0.00092050f, 0.00082103f, 0.00076961f, 0.00073415f, 0.00075688f, 0.00079026f, 0.00092809f, 0.00112965f, 0.00129699f, 0.00116185f, 0.00100703f, 0.00077365f, 0.00076033f, 0.00080477f, 0.00080677f, 0.00083078f, 0.00088649f, 0.00133616f, 0.00228180f, 0.00311165f, 0.00337426f, 0.00247413f, 0.00177023f, 0.00173937f, 0.00256226f, 0.00416833f, 0.00730146f, 0.01307862f, 0.02642362f, 0.06885090f, 0.15790517f, 0.26507651f, 0.35581948f, 0.36234721f, 0.34595470f, 0.38409276f, 0.46785520f, 0.55768332f, 0.66561640f, 0.79823243f, 0.91459526f, 0.96232534f, 0.96952002f, 0.98582495f, 1.00000000f, 0.99443971f, 0.98397125f, 0.98187568f, 0.98041741f, 0.96491138f, 0.93163418f, 0.89816790f, 0.88514299f, 0.89755385f, 0.92254931f, 0.93973289f, 0.93678803f, 0.91972131f, 0.90149737f, 0.89571277f, 0.89773936f, 0.87641072f, 0.80610845f, 0.68062720f, 0.52091655f, 0.35563494f, 0.21526112f, 0.12155259f, 0.07558788f, 0.05580549f, 0.04684205f, 0.04082636f, 0.03321721f, 0.02271154f, 0.01282745f, 0.00644798f, 0.00375586f, 0.00268764f, 0.00244160f, 0.00251460f, 0.00274482f, 0.00284903f, 0.00283393f, 0.00229636f, 0.00179541f, 0.00141479f, 0.00155409f, 0.00176736f, 0.00186357f, 0.00211627f, 0.00176027f, 0.00116946f, 0.00085689f, 0.00080209f, 0.00079516f, 0.00085574f, 0.00079376f, 0.00084450f, 0.00093073f, 0.00069627f, 0.00111129f, 0.00096584f, 0.00137960f, 0.00142059f, 0.00168015f, 0.00164225f, 0.00153220f, 0.00138690f, 0.00114578f, 0.00107348f, 0.00089340f, 0.00089331f, 0.00082670f, 0.00069853f, 0.00070151f, 0.00041916f, 0.00060178f, 0.00039900f, 0.00047821f, 0.00073072f, 0.00054756f, 0.00046307f, 0.00038372f, 0.00040120f, 0.00094566f, 0.00144115f, 0.00174783f, 0.00160637f, 0.00207648f, 0.00184054f, 0.00120344f, 0.00136012f, 0.00065528f, 0.00021298f, 0.00029801f, 0.00023598f, 0.00043383f, 0.00039109f, 0.00036737f, 0.00034646f, 0.00038008f, 0.00062999f, 0.00069556f, 0.00086262f, 0.00106473f, 0.00139535f, 0.00143002f, 0.00159045f, 0.00149705f, 0.00143753f, 0.00108801f, 0.00100188f, 0.00143027f, 0.00216615f, 0.00284243f, 0.00233023f, 0.00366138f, 0.00515819f, 0.00414161f, 0.00255302f, 0.00219772f, 0.00093040f, 0.00092687f, 0.00062159f, 0.00057901f, 0.00041318f, 0.00042130f, 0.00028280f, 0.00033035f, 0.00030452f, 0.00024442f, 0.00025135f, 0.00018402f, 0.00021192f, 0.00016193f, 0.00016590f, 0.00011075f, 0.00013043f, 0.00007256f, 0.00006166f, 0.00005303f, 0.00005455f, 0.00004600f, 0.00004757f }; //band B3 (NIR band) const float b3[241] = { 0.00001292f, 0.00002171f, 0.00004807f, 0.00011182f, 0.00025418f, 0.00039857f, 0.00046443f, 0.00047839f, 0.00044713f, 0.00037654f, 0.00035148f, 0.00034462f, 0.00033637f, 0.00051395f, 0.00079863f, 0.00092629f, 0.00091280f, 0.00081377f, 0.00060282f, 0.00061723f, 0.00092913f, 0.00135949f, 0.00180283f, 0.00217378f, 0.00232524f, 0.00179411f, 0.00127217f, 0.00106374f, 0.00082233f, 0.00044924f, 0.00037015f, 0.00032951f, 0.00019803f, 0.00014290f, 0.00014584f, 0.00011731f, 0.00014607f, 0.00015945f, 0.00016082f, 0.00016211f, 0.00016332f, 0.00017511f, 0.00023669f, 0.00032355f, 0.00033368f, 0.00023295f, 0.00015066f, 0.00032285f, 0.00066048f, 0.00112654f, 0.00108799f, 0.00054363f, 0.00026323f, 0.00041415f, 0.00077743f, 0.00113221f, 0.00111148f, 0.00081011f, 0.00059036f, 0.00065976f, 0.00101972f, 0.00135998f, 0.00140171f, 0.00102011f, 0.00059021f, 0.00033876f, 0.00021227f, 0.00019790f, 0.00021420f, 0.00026787f, 0.00026668f, 0.00028505f, 0.00027375f, 0.00020546f, 0.00021823f, 0.00030911f, 0.00047168f, 0.00065687f, 0.00084531f, 0.00102653f, 0.00104974f, 0.00067340f, 0.00034568f, 0.00020268f, 0.00015007f, 0.00015894f, 0.00014163f, 0.00013650f, 0.00016949f, 0.00013145f, 0.00014790f, 0.00014450f, 0.00016482f, 0.00013165f, 0.00014328f, 0.00015615f, 0.00016551f, 0.00012613f, 0.00014439f, 0.00016190f, 0.00016368f, 0.00016309f, 0.00016247f, 0.00016185f, 0.00016121f, 0.00016054f, 0.00015987f, 0.00014932f, 0.00015809f, 0.00011786f, 0.00013893f, 0.00015448f, 0.00015548f, 0.00015471f, 0.00015391f, 0.00015308f, 0.00015226f, 0.00015141f, 0.00015056f, 0.00014968f, 0.00014878f, 0.00014787f, 0.00014695f, 0.00017325f, 0.00016332f, 0.00020224f, 0.00023233f, 0.00026294f, 0.00031470f, 0.00036507f, 0.00044863f, 0.00054533f, 0.00070811f, 0.00098155f, 0.00144124f, 0.00224364f, 0.00359220f, 0.00600863f, 0.01034187f, 0.01844116f, 0.03239372f, 0.05644336f, 0.09596693f, 0.16642227f, 0.29891104f, 0.46664393f, 0.65196155f, 0.82462228f, 0.93492473f, 0.96391539f, 0.95443216f, 0.94614531f, 0.94775818f, 0.95521775f, 0.96787170f, 0.98075567f, 0.99990788f, 1.00000000f, 0.99361003f, 0.97888468f, 0.96699472f, 0.95409755f, 0.94033720f, 0.92803915f, 0.91619283f, 0.90622111f, 0.89602226f, 0.88630428f, 0.87500909f, 0.86095237f, 0.84370968f, 0.82545572f, 0.80461400f, 0.78501260f, 0.76772428f, 0.75486365f, 0.74647323f, 0.73951238f, 0.73121168f, 0.72267447f, 0.70863907f, 0.69074451f, 0.66813774f, 0.64157628f, 0.61222073f, 0.58351079f, 0.55338601f, 0.52370658f, 0.49552374f, 0.46688500f, 0.43837106f, 0.40924006f, 0.37555859f, 0.33386557f, 0.28478902f, 0.22725968f, 0.16595809f, 0.10930651f, 0.06488794f, 0.03605219f, 0.01953905f, 0.01126891f, 0.00690848f, 0.00468269f, 0.00344177f, 0.00292199f, 0.00233016f, 0.00218781f, 0.00181206f, 0.00165803f, 0.00144119f, 0.00123269f, 0.00109776f, 0.00075502f, 0.00044380f, 0.00037750f, 0.00032479f, 0.00017482f, 0.00008358f, 0.00008118f, 0.00004817f, 0.00004175f, 0.00004611f, 0.00003185f, 0.00000389f, 0.00002899f, 0.00003629f, 0.00001965f, 0.00000707f, 0.00001519f, 0.00000235f, 0.00001547f, 0.00001885f, 0.00000892f, 0.00000652f, 0.00000763f, 0.00000967f, 0.00000820f, 0.00000825f, 0.00000750f, 0.00000634f }; //Add multispectral bands to the temporary list const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); const std::vector vb1 (b1, b1 + sizeof(b1) / sizeof(float) ); const std::vector vb2 (b2, b2 + sizeof(b2) / sizeof(float) ); const std::vector vb3 (b3, b3 + sizeof(b3) / sizeof(float) ); //For Spot6 MS image the order of band is: B2 B1 B0 B3 //(BandIndexToWavelength method could be used here) tmpSpectralBandList.push_back(vb2); tmpSpectralBandList.push_back(vb1); tmpSpectralBandList.push_back(vb0); tmpSpectralBandList.push_back(vb3); } else { itkExceptionMacro(<< "Invalid Spot6 Sensor ID"); } } else { itkExceptionMacro(<< "Invalid number of bands..."); } unsigned int j = 0; for (std::list >::const_iterator it = tmpSpectralBandList.begin(); it != tmpSpectralBandList.end(); ++it) { wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); wavelengthSpectralBand->GetNthElement(j)->SetFilterFunctionValues(*it); wavelengthSpectralBand->GetNthElement(j)->SetMinSpectralValue(0.4); wavelengthSpectralBand->GetNthElement(j)->SetMaxSpectralValue(1.0); if (sensorId == "SPOT 6") { wavelengthSpectralBand->GetNthElement(j)->SetUserStep(0.001); } else if (sensorId == "SPOT 7") { wavelengthSpectralBand->GetNthElement(j)->SetUserStep(0.0025); } else { itkExceptionMacro(<< "Invalid Spot6 Sensor ID"); } ++j; } return wavelengthSpectralBand; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSpot6ImageMetadataInterfaceFactory.cxx000066400000000000000000000027541301006202600302560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbSpot6ImageMetadataInterfaceFactory.h" #include "otbSpot6ImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { Spot6ImageMetadataInterfaceFactory ::Spot6ImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbSpot6ImageMetadataInterface", "Spot6 Metadata Interface", 1, itk::CreateObjectFunction::New()); } Spot6ImageMetadataInterfaceFactory ::~Spot6ImageMetadataInterfaceFactory() { } const char* Spot6ImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* Spot6ImageMetadataInterfaceFactory::GetDescription() const { return "Spot6 Metadata Interface Factory, handle Spot6 metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSpotImageMetadataInterface.cxx000066400000000000000000001126301301006202600266330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSpotImageMetadataInterface.h" #include "otbStringUtils.h" #include "otbMacro.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" namespace otb { SpotImageMetadataInterface ::SpotImageMetadataInterface() { } bool SpotImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("Spot") != std::string::npos) return true; else return false; } std::string SpotImageMetadataInterface::GetInstrument() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument"); return valueString; } return ""; } unsigned int SpotImageMetadataInterface::GetInstrumentIndex() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (imageKeywordlist.HasKey("support_data.instrument_index")) { std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.instrument_index"); unsigned int value = atoi(valueString.c_str()); return value; } return -1; // Invalid value } SpotImageMetadataInterface::VariableLengthVectorType SpotImageMetadataInterface::GetSolarIrradiance() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.solar_irradiance")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.solar_irradiance"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); //In the case of SPOT, the bands are in a different order: // XS3, XS2. XS1, SWIR in the tif file. if (outputValues.size() == 1) { //this is a PAN image outputValuesVariableLengthVector[0] = outputValues[0]; } else if (outputValues.size() == 4) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; outputValuesVariableLengthVector[3] = outputValues[3]; } else if (outputValues.size() == 3) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; } else { itkExceptionMacro("Invalid Physical Irradiance"); } return outputValuesVariableLengthVector; } int SpotImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int SpotImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int SpotImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } int SpotImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() < 4) itkExceptionMacro(<< "Invalid Hour"); int value = atoi(outputValues[3].c_str()); return value; } int SpotImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.image_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.image_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() < 5) itkExceptionMacro(<< "Invalid Minute"); int value = atoi(outputValues[4].c_str()); return value; } int SpotImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int SpotImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int SpotImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.production_date")) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.production_date"); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } SpotImageMetadataInterface::VariableLengthVectorType SpotImageMetadataInterface ::GetPhysicalBias() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.physical_bias")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.physical_bias"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); //In the case of SPOT, the bands are in a different order: // XS3, XS2. XS1, SWIR in the tif file. if (outputValues.size() == 1) { //this is a PAN image outputValuesVariableLengthVector[0] = outputValues[0]; } else if (outputValues.size() == 4) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; outputValuesVariableLengthVector[3] = outputValues[3]; } else if (outputValues.size() == 3) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; } else { itkExceptionMacro("Invalid Physical Gain"); } return outputValuesVariableLengthVector; } SpotImageMetadataInterface::VariableLengthVectorType SpotImageMetadataInterface ::GetPhysicalGain() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::vector outputValues; if (imageKeywordlist.HasKey("support_data.physical_gain")) { std::vector outputValuesString; std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.physical_gain"); boost::trim(valueString); boost::split(outputValuesString, valueString, boost::is_any_of(" ")); for (unsigned int i = 0; i < outputValuesString.size(); ++i) { outputValues.push_back(atof(outputValuesString[i].c_str())); } } VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(outputValues.size()); outputValuesVariableLengthVector.Fill(0); //In the case of SPOT, the bands are in a different order: // XS3, XS2. XS1, SWIR in the tif file. if (outputValues.size() == 1) { //this is a PAN image outputValuesVariableLengthVector[0] = outputValues[0]; } else if (outputValues.size() == 4) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; outputValuesVariableLengthVector[3] = outputValues[3]; } else if (outputValues.size() == 3) { outputValuesVariableLengthVector[0] = outputValues[2]; outputValuesVariableLengthVector[1] = outputValues[1]; outputValuesVariableLengthVector[2] = outputValues[0]; } else { itkExceptionMacro("Invalid Physical Gain"); } return outputValuesVariableLengthVector; } double SpotImageMetadataInterface::GetSatElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.incident_angle")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.incident_angle"); double value = 90 - atof(valueString.c_str()); return value; } double SpotImageMetadataInterface::GetSatAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } if (!imageKeywordlist.HasKey("support_data.step_count") || !imageKeywordlist.HasKey("support_data.scene_orientation")) { return 0; } std::string valueString = imageKeywordlist.GetMetadataByKey("support_data.step_count"); int step = atoi(valueString.c_str()); valueString = imageKeywordlist.GetMetadataByKey("support_data.scene_orientation"); double satAz = atof(valueString.c_str()); if ((step - 48) < 0) { satAz += 90.; } else satAz = satAz - 90.; return satAz; } SpotImageMetadataInterface::VariableLengthVectorType SpotImageMetadataInterface ::GetFirstWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); if (sensorId == "Spot 4") wavel.Fill(0.610); else if (sensorId == "Spot 5") wavel.Fill(0.475); else wavel.Fill(0.500); // assume SPOT 123 //else itkExceptionMacro(<< "Invalid Spot Sensor ID"); } else if (nbBands == 4) { wavel.SetSize(4); //FIXME is that supposed to correspond to the bands in the files? wavel[0] = 0.500; wavel[1] = 0.610; wavel[2] = 0.780; wavel[3] = 1.580; } else if (nbBands == 3) { wavel.SetSize(3); //FIXME is that supposed to correspond to the bands in the files? wavel[0] = 0.500; wavel[1] = 0.610; wavel[2] = 0.780; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } SpotImageMetadataInterface::VariableLengthVectorType SpotImageMetadataInterface ::GetLastWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { wavel.SetSize(1); if (sensorId == "Spot 4") wavel.Fill(0.680); else if (sensorId == "Spot 5") wavel.Fill(0.710); else wavel.Fill(0.730); // assume SPOT 123 // else itkExceptionMacro(<< "Invalid Spot Sensor ID"); } else if (nbBands == 4) { //FIXME is that supposed to correspond to the bands in the files? wavel.SetSize(4); wavel[0] = 0.590; wavel[1] = 0.680; wavel[2] = 0.890; wavel[3] = 1.750; } else if (nbBands == 3) { wavel.SetSize(3); wavel[0] = 0.590; wavel[1] = 0.680; wavel[2] = 0.890; } else itkExceptionMacro(<< "Invalid number of bands..."); return wavel; } unsigned int SpotImageMetadataInterface ::BandIndexToWavelengthPosition(unsigned int i) const { otbMsgDevMacro(<< "SPOT detected: band 0 and 2 inverted"); if (i == 0) return 2; if (i == 2) return 0; return i; } std::vector SpotImageMetadataInterface ::GetDefaultDisplay() const { std::vector rgb(3); rgb[0] = 0; rgb[1] = 1; rgb[2] = 2; return rgb; } SpotImageMetadataInterface::WavelengthSpectralBandVectorType SpotImageMetadataInterface ::GetSpectralSensitivity() const { //TODO tabulate spectral responses WavelengthSpectralBandVectorType wavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); std::list > tmpSpectralBandList; const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no Spot Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } int nbBands = this->GetNumberOfBands(); std::string sensorId = this->GetSensorID(); // Panchromatic case if (nbBands == 1) { if (sensorId == "Spot 4") { } else if (sensorId == "Spot 5") { } else { itkExceptionMacro(<< "Invalid Spot Sensor ID"); } } else if (nbBands == 4) { //FIXME add other instrument relative spectral response (not only HRG1) const float green[541] = { 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0022771144f, 0.0045542287f,0.021714223f,0.038874217f,0.088104725f,0.13733523f,0.21823871f, 0.29914218f,0.38027802f,0.46141386f,0.52832052f,0.59522718f,0.64936955f, 0.70351192f,0.74529693f,0.78708195f,0.82499008f,0.86289822f,0.891466f, 0.92003378f,0.94254762f,0.96506146f,0.9776788f,0.99029614f,0.99514807f, 1.0f,0.99612511f,0.99225022f,0.9804036f,0.96855699f,0.94715939f, 0.9257618f,0.90154813f,0.87733446f,0.84871261f,0.82009075f,0.78645969f, 0.75282863f,0.71875799f,0.68468734f,0.64818039f,0.61167343f,0.57338572f, 0.53509801f,0.49156491f,0.44803182f,0.39732491f,0.346618f,0.29724838f, 0.24787875f,0.20190886f,0.15593897f,0.12403284f,0.09212672f,0.070920769f, 0.049714818f,0.03798244f,0.026250061f,0.019816831f,0.013383602f,0.010152718f, 0.006921834f,0.0054235249f,0.0039252158f,0.0033455489f,0.002765882f,0.001382941f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f}; const float red[541] = { 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0007673711f, 0.0015347422f,0.010419638f,0.019304534f,0.061542786f,0.10378104f,0.20079599f, 0.29781095f,0.41207816f,0.52634536f,0.62039262f,0.71443988f,0.78093055f, 0.84742121f,0.88691213f,0.92640305f,0.95094047f,0.9754779f,0.98546823f, 0.99545857f,0.99772928f,1.0f,0.99374775f,0.98749549f,0.97497667f, 0.96245784f,0.94318133f,0.92390482f,0.89924371f,0.8745826f,0.84464903f, 0.81471546f,0.76863444f,0.72255341f,0.65866954f,0.59478567f,0.5169305f, 0.43907532f,0.36620824f,0.29334116f,0.23579319f,0.17824522f,0.14140026f, 0.1045553f,0.082135956f,0.059716612f,0.047238187f,0.034759762f,0.027242624f, 0.019725486f,0.015547759f,0.011370033f,0.0090187963f,0.0066675595f,0.0050977127f, 0.0035278658f,0.0028316045f,0.0021353432f,0.0010676716f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f }; const float nir[541] = { 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.00046485267f, 0.00092970533f,0.0022703511f,0.0036109969f,0.0072833599f,0.010955723f,0.020381246f, 0.029806769f,0.050425041f,0.071043314f,0.10698612f,0.14292892f,0.19323862f, 0.24354832f,0.30664343f,0.36973854f,0.43590247f,0.5020664f,0.56601537f, 0.62996434f,0.68195348f,0.73394262f,0.77728387f,0.82062512f,0.85237025f, 0.88411539f,0.91130117f,0.93848695f,0.95316338f,0.96783982f,0.9764626f, 0.98508538f,0.99215522f,0.99922506f,0.99961253f,1.0f,0.99705423f, 0.99410845f,0.98330518f,0.97250191f,0.95825152f,0.94400112f,0.93075194f, 0.91750276f,0.90228886f,0.88707495f,0.87152458f,0.8559742f,0.82966368f, 0.80335316f,0.7684215f,0.73348985f,0.68197206f,0.63045427f,0.56244955f, 0.49444484f,0.43235415f,0.37026347f,0.30941829f,0.24857311f,0.20286212f, 0.15715112f,0.13022816f,0.1033052f,0.084892217f,0.06647923f,0.053553967f, 0.040628703f,0.03389025f,0.027151797f,0.022906605f,0.018661412f,0.015551925f, 0.012442438f,0.010396472f,0.0083505073f,0.0070520644f,0.0057536215f,0.0049600816f, 0.0041665416f,0.0035720051f,0.0029774686f,0.0029639347f,0.0029504007f,0.0029368668f, 0.0029233328f,0.0029097989f,0.0028962649f,0.002882731f,0.0028691971f,0.0028556631f, 0.0028421292f,0.0028285952f,0.0028150613f,0.0028015273f,0.0027879934f,0.0027744594f, 0.0027609255f,0.0027473915f,0.0027338576f,0.0027203236f,0.0027067897f,0.0026932557f, 0.0026797218f,0.0026661878f,0.0026526539f,0.0026391199f,0.002625586f,0.002612052f, 0.0025985181f,0.0025849841f,0.0025714502f,0.0025579162f,0.0025443823f,0.0025308483f, 0.0025173144f,0.0025037804f,0.0024902465f,0.0024767125f,0.0024631786f,0.0024496447f, 0.0024361107f,0.0024225768f,0.0024090428f,0.0023955089f,0.0023819749f,0.002368441f, 0.002354907f,0.0023413731f,0.0023278391f,0.0023143052f,0.0023007712f,0.0022872373f, 0.0022737033f,0.0022601694f,0.0022466354f,0.0022331015f,0.0022195675f,0.0022060336f, 0.0021924996f,0.0021789657f,0.0021654317f,0.0021518978f,0.0021383638f,0.0021248299f, 0.0021112959f,0.002097762f,0.002084228f,0.0020706941f,0.0020571601f,0.0020436262f, 0.0020300923f,0.0020165583f,0.0020030244f,0.0019894904f,0.0019759565f,0.0019624225f, 0.0019488886f,0.0019353546f,0.0019218207f,0.0019082867f,0.0018947528f,0.0018812188f, 0.0018676849f,0.0018541509f,0.001840617f,0.001827083f,0.0018135491f,0.0018000151f, 0.0017864812f,0.0017729472f,0.0017594133f,0.0017458793f,0.0017323454f,0.0017188114f, 0.0017052775f,0.0016917435f,0.0016782096f,0.0016646756f,0.0016511417f,0.0016376078f, 0.0016240738f,0.0016105399f,0.0015970059f,0.001583472f,0.001569938f,0.0015564041f, 0.0015428701f,0.0015293362f,0.0015158022f,0.0015022683f,0.0014887343f,0.0014752004f, 0.0014616664f,0.0014481325f,0.0014345985f,0.0014210646f,0.0014075306f,0.0013939967f, 0.0013804627f,0.0013669288f,0.0013533948f,0.0013398609f,0.0013263269f,0.001312793f, 0.001299259f,0.0012857251f,0.0012721911f,0.0012586572f,0.0012451232f,0.0012315893f, 0.0012180554f,0.0012045214f,0.0011909875f,0.0011774535f,0.0011639196f,0.0011503856f, 0.0011368517f,0.0011233177f,0.0011097838f,0.0010962498f,0.0010827159f,0.0010691819f, 0.001055648f,0.001042114f,0.0010285801f,0.0010150461f,0.0010015122f,0.00098797823f, 0.00097444428f,0.00096091033f,0.00094737638f,0.00093384244f,0.00092030849f,0.00090677454f, 0.00089324059f,0.00087970664f,0.00086617269f,0.00085263875f,0.0008391048f,0.00082557085f, 0.0008120369f,0.00079850295f,0.000784969f,0.00077143506f,0.00075790111f,0.00074436716f, 0.00073083321f,0.00071729926f,0.00070376531f,0.00069023137f,0.00067669742f,0.00066316347f, 0.00064962952f,0.00063609557f,0.00062256162f,0.00060902768f,0.00059549373f,0.00058195978f, 0.00056842583f,0.00055489188f,0.00054135793f,0.00052782399f,0.00051429004f,0.00050075609f, 0.00048722214f,0.00047368819f,0.00046015424f,0.0004466203f,0.00043308635f,0.0004195524f, 0.00040601845f,0.0003924845f,0.00037895055f,0.00036541661f,0.00035188266f,0.00033834871f, 0.00032481476f,0.00031128081f,0.00029774686f,0.00028421292f,0.00027067897f,0.00025714502f, 0.00024361107f,0.00023007712f,0.00021654317f,0.00020300923f,0.00018947528f,0.00017594133f, 0.00016240738f,0.00014887343f,0.00013533948f,0.00012180554f,0.00010827159f,9.4737638e-05f, 8.120369e-05f,6.7669742e-05f,5.4135793e-05f,4.0601845e-05f,2.7067897e-05f,1.3533948e-05f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f }; const float mir[541] = { 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f,0.0f,0.0f, 0.0f,0.0088105211f,0.017621042f,0.020528086f,0.02343513f,0.026392526f, 0.029349921f,0.033664215f,0.037978508f,0.042245031f,0.046511554f,0.055648902f, 0.064786249f,0.07395196f,0.08311767f,0.10386151f,0.12460535f,0.14594447f, 0.16728359f,0.20442288f,0.24156217f,0.27841272f,0.31526328f,0.35919335f, 0.40312341f,0.44621342f,0.48930344f,0.53207715f,0.57485086f,0.61905294f, 0.66325502f,0.7114532f,0.75965137f,0.8076253f,0.85559924f,0.89376042f, 0.93192161f,0.9659608f,1.0f,0.99696894f,0.99393787f,0.99224825f, 0.99055862f,0.96192825f,0.93329788f,0.90629723f,0.87929659f,0.87156435f, 0.8638321f,0.85303543f,0.84223875f,0.85502674f,0.86781473f,0.88056734f, 0.89331995f,0.89301593f,0.89271191f,0.86628263f,0.83985335f,0.80572933f, 0.77160531f,0.73099612f,0.69038694f,0.64866608f,0.60694523f,0.56782227f, 0.52869932f,0.48719362f,0.44568791f,0.40599882f,0.36630972f,0.32807542f, 0.28984112f,0.25834284f,0.22684456f,0.19656397f,0.16628339f,0.14643708f, 0.12659078f,0.106444f,0.086297227f,0.076081433f,0.065865639f,0.055683249f, 0.045500859f,0.040629869f,0.03575888f,0.031127116f,0.026495353f,0.024316707f, 0.022138061f,0.019934653f,0.017731245f,0.01619062f,0.014649995f,0.013104617f, 0.011559239f,0.01030835f,0.0090574603f,0.0078583703f,0.0066592804f,0.0059099939f, 0.0051607074f,0.0044159179f,0.0036711284f,0.0033605972f,0.0030500659f,0.0027368724f, 0.0024236788f,0.0021708901f,0.0019181013f,0.0016732152f,0.001428329f,0.001428329f, 0.001428329f }; //Add multispectral bands to the temporary list const std::vector vgreen (green, green + sizeof(green) / sizeof(float) ); const std::vector vred (red, red + sizeof(red) / sizeof(float) ); const std::vector vnir (nir, nir + sizeof(nir) / sizeof(float) ); const std::vector vmir (mir, mir + sizeof(mir) / sizeof(float) ); tmpSpectralBandList.push_back(vgreen); tmpSpectralBandList.push_back(vred); tmpSpectralBandList.push_back(vnir); tmpSpectralBandList.push_back(vmir); unsigned int j = 0; for (std::list >::const_iterator it = tmpSpectralBandList.begin(); it != tmpSpectralBandList.end(); ++it) { wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); wavelengthSpectralBand->GetNthElement(j)->SetFilterFunctionValues(*it); wavelengthSpectralBand->GetNthElement(j)->SetMinSpectralValue(0.45); wavelengthSpectralBand->GetNthElement(j)->SetMaxSpectralValue(1.8); wavelengthSpectralBand->GetNthElement(j)->SetUserStep(0.0025); ++j; } } else { itkExceptionMacro(<< "Invalid number of bands..."); } return wavelengthSpectralBand; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbSpotImageMetadataInterfaceFactory.cxx000066400000000000000000000027371301006202600301710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbSpotImageMetadataInterfaceFactory.h" #include "otbSpotImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { SpotImageMetadataInterfaceFactory ::SpotImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbSpotImageMetadataInterface", "Spot Metadata Interface", 1, itk::CreateObjectFunction::New()); } SpotImageMetadataInterfaceFactory ::~SpotImageMetadataInterfaceFactory() { } const char* SpotImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* SpotImageMetadataInterfaceFactory::GetDescription() const { return "Spot Metadata Interface Factory, handle Spot metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbTerraSarImageMetadataInterface.cxx000066400000000000000000001023401301006202600274260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTerraSarImageMetadataInterface.h" #include "otbStringUtils.h" #include "otbMath.h" #include "itkIndex.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" namespace otb { TerraSarImageMetadataInterface ::TerraSarImageMetadataInterface() { } bool TerraSarImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("TSX") != std::string::npos) return true; else return false; } int TerraSarImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("azimuth_start_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int TerraSarImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("azimuth_start_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int TerraSarImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("azimuth_start_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } int TerraSarImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("azimuth_start_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 4) itkExceptionMacro(<< "Invalid Hour"); int value = atoi(outputValues[3].c_str()); return value; } int TerraSarImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("azimuth_start_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 4) itkExceptionMacro(<< "Invalid Minute"); int value = atoi(outputValues[4].c_str()); return value; } int TerraSarImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("generation_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Production Day"); int value = atoi(outputValues[2].c_str()); return value; } int TerraSarImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("generation_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Production Month"); int value = atoi(outputValues[1].c_str()); return value; } int TerraSarImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("generation_time"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Production Year"); int value = atoi(outputValues[0].c_str()); return value; } double TerraSarImageMetadataInterface::GetCalibrationFactor() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("calibration.calibrationConstant.calFactor"); if (imageKeywordlist.HasKey(key)) { std::string valueString = imageKeywordlist.GetMetadataByKey(key); double value = atof(valueString.c_str()); return value; } return std::numeric_limits::quiet_NaN(); // Invalid value } unsigned int TerraSarImageMetadataInterface::GetNumberOfNoiseRecords() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("noise.numberOfNoiseRecords"); if (imageKeywordlist.HasKey(key)) { std::string valueString = imageKeywordlist.GetMetadataByKey(key); unsigned int value = atoi(valueString.c_str()); return value; } return std::numeric_limits::quiet_NaN(); // Invalid value } unsigned int TerraSarImageMetadataInterface::GetNoisePolynomialDegrees(unsigned int noiseRecord) const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::ostringstream oss; oss.str(""); oss << "noise[" << noiseRecord << "]imageNoise.noiseEstimate.polynomialDegree"; std::string key = oss.str(); if (imageKeywordlist.HasKey(key)) { std::string valueString = imageKeywordlist.GetMetadataByKey(key); unsigned int value = atoi(valueString.c_str()); return value; } return std::numeric_limits::quiet_NaN(); // Invalid value } TerraSarImageMetadataInterface::UIntVectorType TerraSarImageMetadataInterface::GetNoisePolynomialDegrees() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } UIntVectorType polDeg; std::ostringstream oss; unsigned int nbRec = this->GetNumberOfNoiseRecords(); for (unsigned int i = 0; i < nbRec; ++i) { oss.str(""); oss << "noise[" << i << "]imageNoise.noiseEstimate.polynomialDegree"; std::string key = oss.str(); std::string valueString = imageKeywordlist.GetMetadataByKey(key); unsigned int value = atoi(valueString.c_str()); polDeg.push_back(value); } return polDeg; } TerraSarImageMetadataInterface::DoubleVectorType TerraSarImageMetadataInterface ::GetNoisePolynomialCoefficients(unsigned int noiseRecord) const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } unsigned int polDegs = this->GetNoisePolynomialDegrees(noiseRecord); DoubleVectorType polCoef; std::ostringstream oss; polCoef.clear(); // set <= condition because degree N means N+1 coeff for (unsigned int j = 0; j <= polDegs; ++j) { oss.str(""); oss << "noise[" << noiseRecord << "]imageNoise.noiseEstimate.coefficient[" << j << "]"; std::string key = oss.str(); std::string valueString = imageKeywordlist.GetMetadataByKey(key); double value = atof(valueString.c_str()); polCoef.push_back(value); } return polCoef; } TerraSarImageMetadataInterface::DoubleVectorVectorType TerraSarImageMetadataInterface::GetNoisePolynomialCoefficientsList() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } unsigned int nbRec = this->GetNumberOfNoiseRecords(); UIntVectorType polDegs = this->GetNoisePolynomialDegrees(); DoubleVectorVectorType polCoefList; DoubleVectorType polCoef; std::ostringstream oss; for (unsigned int i = 0; i < nbRec; ++i) { polCoef.clear(); // set <= condition because degree N means N+1 coeff for (unsigned int j = 0; j <= polDegs.size(); ++j) { oss.str(""); oss << "noise[" << i << "]imageNoise.noiseEstimate.coefficient[" << j << "]"; std::string key = oss.str(); std::string valueString = imageKeywordlist.GetMetadataByKey(key); double value = atof(valueString.c_str()); polCoef.push_back(value); } polCoefList.push_back(polCoef); } return polCoefList; } double TerraSarImageMetadataInterface ::GetNoiseTimeUTC(unsigned int noiseRecord) const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } DoubleVectorType timeList; std::ostringstream oss; oss.str(""); oss << "noise[" << noiseRecord << "]imageNoise.timeUTC"; std::string key = oss.str(); if (imageKeywordlist.HasKey(key)) { std::string valueString = imageKeywordlist.GetMetadataByKey(key); double julianDay = ConvertStringTimeUTCToJulianDay(valueString); return julianDay; } return std::numeric_limits::quiet_NaN(); // Invalid value } double TerraSarImageMetadataInterface ::ConvertStringTimeUTCToJulianDay(const std::string& value) const { std::vector splitDate; boost::split(splitDate, value, boost::is_any_of("-T:Z")); int year = atoi(splitDate[0].c_str()); int month = atoi(splitDate[1].c_str()); int day = atoi(splitDate[2].c_str()); int hour = atoi(splitDate[3].c_str()); int minu = atoi(splitDate[4].c_str()); double sec = atof(splitDate[5].c_str()); // Conversion to julian day // according to http://en.wikipedia.org/wiki/Julian_day // division are integer divisions: int a = (14 - month) / 12; int y = year + 4800 - a; int m = month + 12*a - 3; double julianDay = day + (153*m+2)/5 + 365*y + y/4 -y/100 + y/400 - 32045; // now, the division are NOT integer julianDay += hour/24. + minu/1440. + sec/86400.; return julianDay; } TerraSarImageMetadataInterface::DoubleVectorType TerraSarImageMetadataInterface::GetNoiseTimeUTCList() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } DoubleVectorType timeList; std::ostringstream oss; unsigned int nbRec = this->GetNumberOfNoiseRecords(); for (unsigned int i = 0; i < nbRec; ++i) { oss.str(""); oss << "noise[" << i << "]imageNoise.timeUTC"; std::string key = oss.str(); std::string valueString = imageKeywordlist.GetMetadataByKey(key); double julianDay = ConvertStringTimeUTCToJulianDay(valueString); timeList.push_back(julianDay); } return timeList; } TerraSarImageMetadataInterface::DoubleVectorType TerraSarImageMetadataInterface::GetNoiseValidityRangeMaxList() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } DoubleVectorType maxList; std::ostringstream oss; unsigned int nbRec = this->GetNumberOfNoiseRecords(); for (unsigned int i = 0; i < nbRec; ++i) { oss.str(""); oss << "noise[" << i << "]imageNoise.noiseEstimate.validityRangeMax"; std::string valueString = imageKeywordlist.GetMetadataByKey(oss.str()); maxList.push_back(atof(valueString.c_str())); } return maxList; } TerraSarImageMetadataInterface::DoubleVectorType TerraSarImageMetadataInterface::GetNoiseValidityRangeMinList() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } DoubleVectorType minList; std::ostringstream oss; unsigned int nbRec = this->GetNumberOfNoiseRecords(); for (unsigned int i = 0; i < nbRec; ++i) { oss.str(""); oss << "noise[" << i << "]imageNoise.noiseEstimate.validityRangeMin"; std::string valueString = imageKeywordlist.GetMetadataByKey(oss.str()); minList.push_back(atof(valueString.c_str())); } return minList; } double TerraSarImageMetadataInterface ::GetNoiseReferencePoint(unsigned int noiseRecord) const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } double refPoint; std::ostringstream oss; oss.str(""); oss << "noise[" << noiseRecord << "]imageNoise.noiseEstimate.referencePoint"; std::string valueString = imageKeywordlist.GetMetadataByKey(oss.str()); refPoint = atof(valueString.c_str()); return refPoint; } TerraSarImageMetadataInterface::DoubleVectorType TerraSarImageMetadataInterface::GetNoiseReferencePointList() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } DoubleVectorType refPointList; std::ostringstream oss; unsigned int nbRec = this->GetNumberOfNoiseRecords(); for (unsigned int i = 0; i < nbRec; ++i) { oss.str(""); oss << "noise[" << i << "]imageNoise.noiseEstimate.referencePoint"; std::string valueString = imageKeywordlist.GetMetadataByKey(oss.str()); refPointList.push_back(atof(valueString.c_str())); } return refPointList; } double TerraSarImageMetadataInterface::GetRadarFrequency() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("radarFrequency"); double freq = atof(valueString.c_str()); return freq; } double TerraSarImageMetadataInterface::GetPRF() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("sensor_params.prf"); double freq = atof(valueString.c_str()); return freq; } double TerraSarImageMetadataInterface::GetRSF() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("sensor_params.sampling_frequency"); double freq = atof(valueString.c_str()); return freq; } unsigned int TerraSarImageMetadataInterface::GetNumberOfCornerIncidenceAngles() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("sceneCoord.numberOfSceneCornerCoord"); int value = atoi(valueString.c_str()); return value; } double TerraSarImageMetadataInterface::GetMeanIncidenceAngles() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); ImageKeywordlistType imageKeywordlist; double sum = 0.; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("sceneCoord.sceneCenterCoord.incidenceAngle"); double value = atof(valueString.c_str()); sum += value; unsigned int nbAngles = this->GetNumberOfCornerIncidenceAngles(); std::ostringstream oss; for (unsigned int i = 0; i < nbAngles; ++i) { oss.str(""); oss << "sceneCoord.sceneCornerCoord[" << i << "].incidenceAngle"; valueString = imageKeywordlist.GetMetadataByKey(oss.str()); value = atof(valueString.c_str()); sum += value; } return (sum / (nbAngles + 1)); } double TerraSarImageMetadataInterface::GetCenterIncidenceAngle() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("sceneCoord.sceneCenterCoord.incidenceAngle"); double value = atof(valueString.c_str()); return value; } TerraSarImageMetadataInterface::IndexType TerraSarImageMetadataInterface::GetCenterIncidenceAngleIndex() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); TerraSarImageMetadataInterface::IndexType it; ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("sceneCoord.sceneCenterCoord.refRow"); it[1] = atoi(valueString.c_str()); valueString = imageKeywordlist.GetMetadataByKey("sceneCoord.sceneCenterCoord.refColumn"); it[0] = atoi(valueString.c_str()); return it; } TerraSarImageMetadataInterface::DoubleVectorType TerraSarImageMetadataInterface::GetCornersIncidenceAngles() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); ImageKeywordlistType imageKeywordlist; TerraSarImageMetadataInterface::DoubleVectorType dv; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::ostringstream oss; unsigned int nbAngles = this->GetNumberOfCornerIncidenceAngles(); for (unsigned int i = 0; i < nbAngles; ++i) { oss.str(""); oss << "sceneCoord.sceneCornerCoord[" << i << "].incidenceAngle"; std::string valueString = imageKeywordlist.GetMetadataByKey(oss.str()); dv.push_back(atof(valueString.c_str())); } return dv; } TerraSarImageMetadataInterface::IndexVectorType TerraSarImageMetadataInterface::GetCornersIncidenceAnglesIndex() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); ImageKeywordlistType imageKeywordlist; TerraSarImageMetadataInterface::IndexVectorType iv; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::ostringstream oss; std::ostringstream oss2; unsigned int nbAngles = this->GetNumberOfCornerIncidenceAngles(); for (unsigned int i = 0; i < nbAngles; ++i) { TerraSarImageMetadataInterface::IndexType it; oss.str(""); oss << "sceneCoord.sceneCornerCoord[" << i << "].refRow"; std::string valueString = imageKeywordlist.GetMetadataByKey(oss.str()); it[1] = atoi(valueString.c_str()); oss2.str(""); oss2 << "sceneCoord.sceneCornerCoord[" << i << "].refColumn"; valueString = imageKeywordlist.GetMetadataByKey(oss2.str()); it[0] = atoi(valueString.c_str()); iv.push_back(it); } return iv; } double TerraSarImageMetadataInterface ::Horner(std::vector& coefficients, const double tauMinusTauRef) const { std::vector::reverse_iterator coefIt = coefficients.rbegin(); double res = *(coefIt); ++coefIt; while (coefIt < coefficients.rend()) { // Cumulate polynomial res = res * tauMinusTauRef + (*coefIt); ++coefIt; } return res; } TerraSarImageMetadataInterface::PointSetPointer TerraSarImageMetadataInterface ::GetRadiometricCalibrationNoise() const { PointSetPointer points = PointSetType::New(); IndexVectorType cornerIndex = this->GetCornersIncidenceAnglesIndex(); unsigned int numberOfRows = 0; unsigned int numberOfCols = 0; for (unsigned int i = 0; i < cornerIndex.size(); ++i) { IndexType index; index = cornerIndex[i]; unsigned int noRow = index[0]; unsigned int noCol = index[1]; if (noRow > numberOfRows) { numberOfRows = noRow; } if (noCol > numberOfCols) { numberOfCols = noCol; } } double startTime = this->GetStartTimeUTC(); double stopTime = this->GetStopTimeUTC(); RealType firstRangeTime = this->GetRangeTimeFirstPixel(); RealType lastRangeTime = this->GetRangeTimeLastPixel(); points->Initialize(); unsigned int noPoint = 0; PointType p0; unsigned int numberOfNoiseRecords = this->GetNumberOfNoiseRecords(); for (unsigned int noiseRecord = 0; noiseRecord < numberOfNoiseRecords; ++noiseRecord) { double currentNoiseTime = this->GetNoiseTimeUTC(noiseRecord); RealType AzimutAcquisition = (currentNoiseTime - startTime) * numberOfRows / (stopTime - startTime); RealType referencePointTime = this->GetNoiseReferencePoint(noiseRecord); std::vector polynomialCoefficient; polynomialCoefficient = this->GetNoisePolynomialCoefficients(noiseRecord); p0[0] = AzimutAcquisition; for (unsigned int col = 0; col < numberOfCols; ++col) { RealType rangeTime = col * (lastRangeTime - firstRangeTime) / (numberOfCols) + firstRangeTime; RealType tauMinusTauRef = rangeTime - referencePointTime; RealType value = this->Horner(polynomialCoefficient, tauMinusTauRef); p0[1] = col; points->SetPoint(noPoint, p0); points->SetPointData(noPoint, value); ++noPoint; } } return points; } TerraSarImageMetadataInterface::IndexType TerraSarImageMetadataInterface ::GetRadiometricCalibrationNoisePolynomialDegree() const { IndexType polynomSize; polynomSize[0] = 2; polynomSize[1] = 2; return polynomSize; } double TerraSarImageMetadataInterface ::GetStartTimeUTC() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string referenceUTC = imageKeywordlist.GetMetadataByKey("azimuth_start_time"); double julianDay = ConvertStringTimeUTCToJulianDay(referenceUTC); return julianDay; } double TerraSarImageMetadataInterface ::GetStopTimeUTC() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string referenceUTC = imageKeywordlist.GetMetadataByKey("azimuth_stop_time"); double julianDay = ConvertStringTimeUTCToJulianDay(referenceUTC); return julianDay; } TerraSarImageMetadataInterface::RealType TerraSarImageMetadataInterface ::GetRangeTimeFirstPixel() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("range_first_time"); double value = atof(valueString.c_str()); return value; } TerraSarImageMetadataInterface::RealType TerraSarImageMetadataInterface ::GetRangeTimeLastPixel() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("range_last_time"); double value = atof(valueString.c_str()); return value; } TerraSarImageMetadataInterface::RealType TerraSarImageMetadataInterface ::GetRadiometricCalibrationScale() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no TerraSar Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string valueString = imageKeywordlist.GetMetadataByKey("calibration.calibrationConstant.calFactor"); double value = atof(valueString.c_str()); return value; } TerraSarImageMetadataInterface::PointSetPointer TerraSarImageMetadataInterface ::GetRadiometricCalibrationIncidenceAngle() const { PointSetPointer points = PointSetType::New(); PointType p0; double centerIncidenceAngleValue = this->GetCenterIncidenceAngle(); IndexType centerIncidenceAngleIndex = this->GetCenterIncidenceAngleIndex(); DoubleVectorType cornerIncidenceAngleValue = this->GetCornersIncidenceAngles(); IndexVectorType cornerIncidenceAngleIndex = this->GetCornersIncidenceAnglesIndex(); points->Initialize(); unsigned int noPoint = 0; p0[0] = centerIncidenceAngleIndex[0]; p0[1] = centerIncidenceAngleIndex[1]; points->SetPoint(noPoint, p0); points->SetPointData(noPoint, centerIncidenceAngleValue * CONST_PI_180); ++noPoint; for (unsigned int i = 0; i < cornerIncidenceAngleIndex.size(); ++i) { p0[0] = cornerIncidenceAngleIndex.at(i)[0]; p0[1] = cornerIncidenceAngleIndex.at(i)[1]; points->SetPoint(noPoint, p0); points->SetPointData(noPoint, cornerIncidenceAngleValue[i] * CONST_PI_180); ++noPoint; } return points; } TerraSarImageMetadataInterface::IndexType TerraSarImageMetadataInterface ::GetRadiometricCalibrationIncidenceAnglePolynomialDegree() const { IndexType polynomSize; polynomSize[0] = 2; polynomSize[1] = 1; return polynomSize; } /** Get the R, G, B channel */ std::vector TerraSarImageMetadataInterface ::GetDefaultDisplay() const { std::vector rgb(3); rgb[0] = 0; rgb[1] = 0; rgb[2] = 0; return rgb; } void TerraSarImageMetadataInterface ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbTerraSarImageMetadataInterfaceFactory.cxx000066400000000000000000000027501301006202600307620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTerraSarImageMetadataInterfaceFactory.h" #include "otbTerraSarImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { TerraSarImageMetadataInterfaceFactory ::TerraSarImageMetadataInterfaceFactory() { this->RegisterOverride("SarImageMetadataInterface", "otbTerraSarImageMetadataInterface", "TerraSar Metadata Interface", 1, itk::CreateObjectFunction::New()); } TerraSarImageMetadataInterfaceFactory ::~TerraSarImageMetadataInterfaceFactory() { } const char* TerraSarImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* TerraSarImageMetadataInterfaceFactory::GetDescription() const { return "TerraSar Metadata Interface Factory, handle TerraSar metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbWorldView2ImageMetadataInterface.cxx000066400000000000000000002134251301006202600277160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWorldView2ImageMetadataInterface.h" #include "otbStringUtils.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" namespace otb { WorldView2ImageMetadataInterface ::WorldView2ImageMetadataInterface() { } bool WorldView2ImageMetadataInterface::CanRead() const { std::string sensorID = GetSensorID(); if (sensorID.find("WV02") != std::string::npos) return true; else return false; } WorldView2ImageMetadataInterface::VariableLengthVectorType WorldView2ImageMetadataInterface::GetSolarIrradiance() const { // Used the solari irradiance provided by DigitalGlobe here: // http://www.digitalglobe.com/downloads/Radiometric_Use_of_WorldView-2_Imagery.pdf const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType outputValuesVariableLengthVector; std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); std::string ms1("MS1"); if (keywordStringBId == panchro) { outputValuesVariableLengthVector.SetSize(1); outputValuesVariableLengthVector.Fill(1580.8140); } else { std::string keywordStringBandNameList = imageKeywordlist.GetMetadataByKey("support_data.band_name_list"); std::vector bandNameList; boost::trim(keywordStringBandNameList); boost::split(bandNameList, keywordStringBandNameList, boost::is_any_of(" ")); outputValuesVariableLengthVector.SetSize(bandNameList.size()); for(unsigned int i = 0; i < bandNameList.size(); ++i) { double SolarIrradianceValue = 0.0; if(bandNameList[i] == "C") { SolarIrradianceValue = 1758.2229; } else if(bandNameList[i] == "B") { SolarIrradianceValue = 1974.2416; } else if(bandNameList[i] == "G") { SolarIrradianceValue = 1856.4104; } else if(bandNameList[i] == "Y") { SolarIrradianceValue = 1738.4791; } else if(bandNameList[i] == "R") { SolarIrradianceValue = 1559.4555; } else if(bandNameList[i] == "RE") { SolarIrradianceValue = 1342.0695; } else if(bandNameList[i] == "N") { SolarIrradianceValue = 1069.7302; } else if(bandNameList[i] == "N2") { SolarIrradianceValue = 861.2866; } outputValuesVariableLengthVector[i] = SolarIrradianceValue; } } return outputValuesVariableLengthVector; } int WorldView2ImageMetadataInterface::GetDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int WorldView2ImageMetadataInterface::GetMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int WorldView2ImageMetadataInterface::GetYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } int WorldView2ImageMetadataInterface::GetHour() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Hour"); int value = atoi(outputValues[3].c_str()); return value; } int WorldView2ImageMetadataInterface::GetMinute() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.tlc_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Minute"); int value = atoi(outputValues[4].c_str()); return value; } int WorldView2ImageMetadataInterface::GetProductionDay() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.generation_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Day"); int value = atoi(outputValues[2].c_str()); return value; } int WorldView2ImageMetadataInterface::GetProductionMonth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.generation_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Month"); int value = atoi(outputValues[1].c_str()); return value; } int WorldView2ImageMetadataInterface::GetProductionYear() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.generation_date"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); std::vector outputValues; boost::split(outputValues, valueString, boost::is_any_of(" T:-")); if (outputValues.size() <= 2) itkExceptionMacro(<< "Invalid Year"); int value = atoi(outputValues[0].c_str()); return value; } WorldView2ImageMetadataInterface::VariableLengthVectorType WorldView2ImageMetadataInterface ::GetPhysicalBias() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType outputValuesVariableLengthVector; std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); std::string ms1("MS1"); if (keywordStringBId == panchro) { outputValuesVariableLengthVector.SetSize(1); outputValuesVariableLengthVector.Fill(0.0); } else if (keywordStringBId == multi || keywordStringBId == ms1) { std::string keywordStringBandNameList = imageKeywordlist.GetMetadataByKey("support_data.band_name_list"); std::vector bandNameList; boost::trim(keywordStringBandNameList); boost::split(bandNameList, keywordStringBandNameList, boost::is_any_of(" ")); outputValuesVariableLengthVector.SetSize(bandNameList.size()); outputValuesVariableLengthVector.Fill(0.0); } else { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } return outputValuesVariableLengthVector; } WorldView2ImageMetadataInterface::VariableLengthVectorType WorldView2ImageMetadataInterface ::GetPhysicalGain() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string keywordStringBitsPerPixel = imageKeywordlist.GetMetadataByKey("support_data.bits_per_pixel"); int bitsPerPixel = atoi(keywordStringBitsPerPixel.c_str()); if (bitsPerPixel != 16) { itkExceptionMacro(<< "Invalid bitsPerPixel " << bitsPerPixel); } std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); std::string ms1("MS1"); if (keywordStringBId != panchro && keywordStringBId != multi && keywordStringBId != ms1) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } std::string keywordStringTDILevel = imageKeywordlist.GetMetadataByKey("support_data.TDI_level"); int TDILevel = atoi(keywordStringTDILevel.c_str()); if ( (keywordStringBId == panchro && TDILevel > 64) || (keywordStringBId == panchro && TDILevel < 8) ) { itkExceptionMacro(<< "Invalid TDILevel " << TDILevel); } std::string keywordStringBandNameList = imageKeywordlist.GetMetadataByKey("support_data.band_name_list"); std::vector bandNameList; boost::trim(keywordStringBandNameList); boost::split(bandNameList, keywordStringBandNameList, boost::is_any_of(" ")); VariableLengthVectorType outputValuesVariableLengthVector; outputValuesVariableLengthVector.SetSize(bandNameList.size()); if (keywordStringBId == panchro) { std::string keywordStringAbsCalFactor = imageKeywordlist.GetMetadataByKey("support_data.absCalFactor"); double absCalFactor = atof(keywordStringAbsCalFactor.c_str()); outputValuesVariableLengthVector[0] = absCalFactor; } else { for(unsigned int i = 0; i < bandNameList.size(); ++i) { std::string key = "support_data." + bandNameList[i] + "_band_absCalFactor"; std::string keywordStringCalFactor = imageKeywordlist.GetMetadataByKey(key); double calFactor = atof(keywordStringCalFactor.c_str()); outputValuesVariableLengthVector[i] = calFactor; } } if (keywordStringBId == panchro) { // In the case of WorldView-2, we need to divide the absolute calibration // factor by the effective bandwidth see for details: // http://www.digitalglobe.com/downloads/Radiometric_Use_of_WorldView-2_Imagery.pdf // These values are not retrieved by the ossimQuickBirdMetadata class as // there are specific to WV2 We did not retrieve those values in the ossim // class and consider them as constant values // FIXME: add the effectivebandwidth in the ossim keywordlist const double effectiveBandWidthPan = 2.846000e-01; outputValuesVariableLengthVector[0] = effectiveBandWidthPan / outputValuesVariableLengthVector[0]; } else { // Also need to divide by the effective bandwidth available // We consider the 2 cases with 4 or 8 bands in WV2 multispectral product VariableLengthVectorType effectiveBandwidthVariableLengthVector; effectiveBandwidthVariableLengthVector.SetSize(bandNameList.size()); effectiveBandwidthVariableLengthVector.Fill(1.); if (bandNameList.size() == 8) { effectiveBandwidthVariableLengthVector[0] = 4.730000e-02; effectiveBandwidthVariableLengthVector[1] = 5.430000e-02; effectiveBandwidthVariableLengthVector[2] = 6.300000e-02; effectiveBandwidthVariableLengthVector[3] = 3.740000e-02; effectiveBandwidthVariableLengthVector[4] = 5.740000e-02; effectiveBandwidthVariableLengthVector[5] = 3.930000e-02; effectiveBandwidthVariableLengthVector[6] = 9.890000e-02; effectiveBandwidthVariableLengthVector[7] = 9.960000e-02; } else if (bandNameList.size() == 4) { effectiveBandwidthVariableLengthVector[0] = 5.430000e-02; effectiveBandwidthVariableLengthVector[1] = 6.300000e-02; effectiveBandwidthVariableLengthVector[2] = 5.740000e-02; effectiveBandwidthVariableLengthVector[3] = 9.890000e-02; } for(unsigned int i = 0; i < bandNameList.size(); ++i) { outputValuesVariableLengthVector[i] = effectiveBandwidthVariableLengthVector[i] / outputValuesVariableLengthVector[i]; } } return outputValuesVariableLengthVector; } double WorldView2ImageMetadataInterface::GetSatElevation() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.sat_elevation_angle"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); double value = atof(valueString.c_str()); return value; } double WorldView2ImageMetadataInterface::GetSatAzimuth() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key("support_data.sat_azimuth_angle"); if (!imageKeywordlist.HasKey(key)) { return -1; } std::string valueString = imageKeywordlist.GetMetadataByKey(key); double value = atof(valueString.c_str()); return value; } WorldView2ImageMetadataInterface::VariableLengthVectorType WorldView2ImageMetadataInterface ::GetFirstWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); std::string ms1("MS1"); if (keywordStringBId != panchro && keywordStringBId != multi && keywordStringBId != ms1) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } // Panchromatic case if (keywordStringBId == panchro) { wavel.SetSize(1); wavel.Fill(0.464); } else { std::string keywordStringBandNameList = imageKeywordlist.GetMetadataByKey("support_data.band_name_list"); std::vector bandNameList; boost::trim(keywordStringBandNameList); boost::split(bandNameList, keywordStringBandNameList, boost::is_any_of(" ")); wavel.SetSize(bandNameList.size()); for(unsigned int i = 0; i < bandNameList.size(); ++i) { double waveValue = 0.0; if(bandNameList[i] == "C") { waveValue = 0.401; } else if(bandNameList[i] == "B") { waveValue = 0.447; } else if(bandNameList[i] == "G") { waveValue = 0.511; } else if(bandNameList[i] == "Y") { waveValue = 0.588; } else if(bandNameList[i] == "R") { waveValue = 0.629; } else if(bandNameList[i] == "RE") { waveValue = 0.704; } else if(bandNameList[i] == "N") { waveValue = 0.772; } else if(bandNameList[i] == "N2") { waveValue = 0.862; } wavel[i] = waveValue; } } return wavel; } WorldView2ImageMetadataInterface::VariableLengthVectorType WorldView2ImageMetadataInterface ::GetLastWavelengths() const { const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } VariableLengthVectorType wavel(1); wavel.Fill(0.); std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); std::string ms1("MS1"); if (keywordStringBId != panchro && keywordStringBId != multi && keywordStringBId != ms1) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } // Panchromatic case if (keywordStringBId == panchro) { wavel.SetSize(1); wavel.Fill(0.801); } else { std::string keywordStringBandNameList = imageKeywordlist.GetMetadataByKey("support_data.band_name_list"); std::vector bandNameList; boost::trim(keywordStringBandNameList); boost::split(bandNameList, keywordStringBandNameList, boost::is_any_of(" ")); wavel.SetSize(bandNameList.size()); for(unsigned int i = 0; i < bandNameList.size(); ++i) { double waveValue = 0.0; if(bandNameList[i] == "C") { waveValue = 0.453; } else if(bandNameList[i] == "B") { waveValue = 0.581; } else if(bandNameList[i] == "G") { waveValue = 0.581; } else if(bandNameList[i] == "Y") { waveValue = 0.627; } else if(bandNameList[i] == "R") { waveValue = 0.689; } else if(bandNameList[i] == "RE") { waveValue = 0.744; } else if(bandNameList[i] == "N") { waveValue = 0.890; } else if(bandNameList[i] == "N2") { waveValue = 0.954; } wavel[i] = waveValue; } } return wavel; } std::vector WorldView2ImageMetadataInterface::GetDefaultDisplay() const { // Handle both 4 bands and 8 bands wv2 products const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, not a WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string key = "support_data.band_name_list"; std::vector rgb(3); if (imageKeywordlist.HasKey(key)) { std::string keywordStringBandNameList = imageKeywordlist.GetMetadataByKey(key); std::vector bandNameList; boost::trim(keywordStringBandNameList); boost::split(bandNameList, keywordStringBandNameList, boost::is_any_of(" ")); if (bandNameList.size() > 4) { rgb[0] = 4; rgb[1] = 2; rgb[2] = 1; } else { rgb[0] = 2; rgb[1] = 1; rgb[2] = 0; } } else { rgb[0] = 2; rgb[1] = 1; rgb[2] = 0; } return rgb; } std::vector WorldView2ImageMetadataInterface ::GetEnhancedBandNames() const { std::vector enhBandNames; std::vector rawBandNames = this->Superclass::GetBandName(); if(rawBandNames.size()) { for (std::vector::iterator it = rawBandNames.begin(); it != rawBandNames.end(); ++it) { // Manage Panchro case if ( (rawBandNames.size() == 1) && !(*it).compare("P") ) { enhBandNames.push_back("PAN"); break; } else if ((rawBandNames.size() != 1) && !(*it).compare("P")) { /* Launch exception situation not valid*/ itkExceptionMacro(<< "Invalid Metadata, we cannot provide an consistent name to the band"); } // Manage MS case if ( !(*it).compare("C") ) { enhBandNames.push_back("Coastal"); } else if ( !(*it).compare("B") ) { enhBandNames.push_back("Blue"); } else if ( !(*it).compare("G") ) { enhBandNames.push_back("Green"); } else if ( !(*it).compare("Y") ) { enhBandNames.push_back("Yellow"); } else if ( !(*it).compare("R") ) { enhBandNames.push_back("Red"); } else if ( !(*it).compare("RE") ) { enhBandNames.push_back("RedEdge"); } else if ( !(*it).compare("N") ) { enhBandNames.push_back("NIR1"); } else if ( !(*it).compare("N2") ) { enhBandNames.push_back("NIR2"); } else { enhBandNames.push_back("Unknown"); } } } return enhBandNames; } WorldView2ImageMetadataInterface::WavelengthSpectralBandVectorType WorldView2ImageMetadataInterface ::GetSpectralSensitivity() const { WavelengthSpectralBandVectorType wavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); std::list > tmpSpectralBandList; //Read sensor image type (panchromatic or multispectral) const MetaDataDictionaryType& dict = this->GetMetaDataDictionary(); if (!this->CanRead()) { itkExceptionMacro(<< "Invalid Metadata, no WorldView2 Image"); } ImageKeywordlistType imageKeywordlist; if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); } std::string keywordStringBId = imageKeywordlist.GetMetadataByKey("support_data.band_id"); std::string panchro("P"); std::string multi("Multi"); std::string ms1("MS1"); if (keywordStringBId != panchro && keywordStringBId != multi && keywordStringBId != ms1) { itkExceptionMacro(<< "Invalid bandID " << keywordStringBId); } // Panchromatic case if (keywordStringBId == panchro) { const float b0[301] = { 5.53407e-06f, 6.18974e-06f, 6.77586e-06f, 4.47741e-06f, 2.18462e-06f, 2.35814e-06f, 2.74394e-06f, 3.35619e-06f, 4.12548e-06f, 3.76678e-06f, 2.97253e-06f, 3.87911e-06f, 4.9452e-06f, 4.23503e-06f, 3.35741e-06f, 3.66642e-06f, 4.01401e-06f, 5.01097e-06f, 6.02754e-06f, 5.03579e-06f, 3.95097e-06f, 3.61214e-06f, 3.26677e-06f, 3.72693e-06f, 4.18733e-06f, 5.20028e-06f, 6.2917e-06f, 4.84978e-06f, 3.39534e-06f, 6.07837e-06f, 8.8389e-06f, 1.04941e-05f, 1.21421e-05f, 4.98988e-05f, 8.81089e-05f, 0.000272275f, 0.000459932f, 0.00169883f, 0.00295147f, 0.0559008f, 0.109766f, 0.271344f, 0.436163f, 0.461822f, 0.487533f, 0.494856f, 0.504992f, 0.515215f, 0.525596f, 0.529589f, 0.535583f, 0.529756f, 0.522233f, 0.527207f, 0.53366f, 0.528602f, 0.523089f, 0.541112f, 0.55728f, 0.55817f, 0.558232f, 0.580899f, 0.605533f, 0.616208f, 0.626792f, 0.612118f, 0.595414f, 0.612008f, 0.630712f, 0.649153f, 0.671541f, 0.663704f, 0.654733f, 0.672532f, 0.693098f, 0.691335f, 0.688237f, 0.67829f, 0.664973f, 0.683323f, 0.70156f, 0.705992f, 0.713576f, 0.709848f, 0.709786f, 0.738422f, 0.765752f, 0.762756f, 0.757827f, 0.759162f, 0.759818f, 0.779983f, 0.794085f, 0.797935f, 0.800715f, 0.811351f, 0.81929f, 0.820814f, 0.82303f, 0.829794f, 0.838869f, 0.848913f, 0.860802f, 0.858037f, 0.858462f, 0.865197f, 0.870285f, 0.877932f, 0.889278f, 0.896475f, 0.909253f, 0.91308f, 0.917885f, 0.914221f, 0.910762f, 0.916979f, 0.92489f, 0.93683f, 0.950791f, 0.943998f, 0.936911f, 0.932311f, 0.929417f, 0.938274f, 0.951232f, 0.960012f, 0.962781f, 0.957501f, 0.953865f, 0.954752f, 0.957376f, 0.968155f, 0.977735f, 0.961332f, 0.949217f, 0.946955f, 0.953334f, 0.946656f, 0.952193f, 0.96247f, 0.969595f, 0.983968f, 1.0f, 0.99432f, 0.994003f, 0.980974f, 0.969563f, 0.968253f, 0.968397f, 0.973674f, 0.978855f, 0.966847f, 0.963741f, 0.952252f, 0.946654f, 0.94592f, 0.952938f, 0.954759f, 0.962583f, 0.962142f, 0.956637f, 0.950381f, 0.940962f, 0.936224f, 0.924596f, 0.923379f, 0.921684f, 0.933568f, 0.940831f, 0.957977f, 0.963832f, 0.958143f, 0.941297f, 0.92426f, 0.903f, 0.895878f, 0.887152f, 0.910523f, 0.929402f, 0.744019f, 0.553867f, 0.320246f, 0.0858164f, 0.0514292f, 0.0172983f, 0.0120102f, 0.00659981f, 0.00436796f, 0.00213134f, 0.00153565f, 0.000922227f, 0.000721841f, 0.000528696f, 0.000489722f, 0.000449662f, 0.000431783f, 0.000409049f, 0.000407132f, 0.000396445f, 0.000420259f, 0.000446526f, 0.000403311f, 0.000361257f, 0.00033034f, 0.000298026f, 0.000301128f, 0.000308537f, 0.000286243f, 0.000261497f, 0.000253604f, 0.000242266f, 0.000274627f, 0.000307033f, 0.000295007f, 0.000283703f, 0.000261529f, 0.000237475f, 0.00024833f, 0.000258997f, 0.00027011f, 0.000282485f, 0.000261654f, 0.000240819f, 0.000248561f, 0.00025802f, 0.000273541f, 0.000287576f, 0.000282785f, 0.000276218f, 0.000275306f, 0.000273131f, 0.000256767f, 0.000242183f, 0.000239187f, 0.000234252f, 0.000223355f, 0.000213509f, 0.00021573f, 0.000218602f, 0.000204845f, 0.000191131f, 0.000179884f, 0.000169031f, 0.000177057f, 0.000183172f, 0.00016757f, 0.0001513f, 0.000138821f, 0.000125806f, 0.000129696f, 0.000133722f, 0.000122536f, 0.000111436f, 0.000102899f, 9.41714e-05f, 0.000104721f, 0.000115227f, 9.94755e-05f, 8.3857e-05f, 8.4497e-05f, 8.52612e-05f, 7.76124e-05f, 7.00705e-05f, 7.06672e-05f, 7.1081e-05f, 6.5671e-05f, 6.00304e-05f, 6.21262e-05f, 6.42018e-05f, 5.57459e-05f, 4.73181e-05f, 4.33172e-05f, 3.91675e-05f, 3.60807e-05f, 3.29177e-05f, 3.41277e-05f, 3.52334e-05f, 3.14413e-05f, 2.76314e-05f, 2.55335e-05f, 2.34256e-05f, 2.1133e-05f, 1.88297e-05f, 1.80004e-05f, 1.71146e-05f, 1.51355e-05f, 1.31473e-05f, 1.21372e-05f, 1.11225e-05f, 9.97857e-06f, 8.84718e-06f, 8.76091e-06f, 8.67416e-06f, 7.95176e-06f, 7.22607e-06f, 7.06298e-06f, 6.8991e-06f, 6.66214e-06f, 6.42406e-06f, 6.36617e-06f, 6.32615e-06f }; //add panchromatic band to the temporary list const std::vector vb0 (b0, b0 + sizeof(b0) / sizeof(float) ); tmpSpectralBandList.push_back(vb0); } else { const float b1[301] = { 1.93924e-06f, 3.33156e-06f, 3.2732e-06f, 2.78199e-06f, 1.7488e-06f, 3.34801e-06f, 3.55785e-06f, 4.38919e-06f, 2.94112e-06f, 6.21317e-06f, 5.37163e-06f, 5.00497e-06f, 7.41645e-06f, 1.35004e-05f, 4.53797e-05f, 0.000173069f, 0.000634651f, 0.00341498f, 0.0274284f, 0.132903f, 0.355988f, 0.59258f, 0.700719f, 0.739625f, 0.765307f, 0.787842f, 0.817088f, 0.838687f, 0.86178f, 0.883513f, 0.905055f, 0.917072f, 0.927208f, 0.947658f, 0.965088f, 0.979304f, 0.985921f, 0.989094f, 0.997236f, 0.974613f, 0.85394f, 0.588032f, 0.281577f, 0.0805215f, 0.00894615f, 0.00133307f, 0.0003609f, 0.000145392f, 7.12168e-05f, 3.80253e-05f, 1.15412e-05f, 9.59192e-06f, 5.14417e-06f, 1.11808e-05f, 1.09998e-05f, 1.07851e-05f, 9.08862e-06f, 1.0105e-05f, 1.17289e-05f, 6.3851e-06f, 1.30646e-06f, 1.3751e-06f, 8.62503e-07f, 6.19172e-07f, 7.02247e-07f, 8.87865e-07f, 9.3924e-07f, 1.11657e-06f, 9.84522e-07f, 7.45006e-07f, 8.99363e-07f, 1.24448e-06f, 3.62747e-06f, 1.27768e-06f, 4.00518e-07f, 5.21386e-07f, 2.69075e-07f, 4.85233e-07f, 3.69503e-07f, 1.25632e-05f, 0.00014168f, 2.39565e-06f, 3.06503e-07f, 2.7473e-07f, 5.19969e-07f, 4.87974e-07f, 2.69412e-07f, 3.10803e-07f, 6.51482e-08f, 1.769e-10f, 2.06764e-07f, 1.56239e-06f, 1.71434e-06f, 3.76485e-07f, 9.78272e-08f, 1.07281e-07f, 5.25843e-07f, 2.86289e-06f, 4.49334e-06f, 2.7912e-06f, 9.77366e-07f, 1.65592e-06f, 1.25872e-06f, 1.35006e-06f, 2.26827e-06f, 3.08804e-06f, 6.08055e-06f, 1.15782e-05f, 1.00862e-05f, 5.55949e-06f, 3.85934e-06f, 3.17286e-06f, 2.67182e-06f, 3.11772e-06f, 2.48961e-06f, 2.56662e-06f, 2.69687e-06f, 2.66657e-06f, 2.49631e-06f, 2.07413e-06f, 2.21763e-06f, 1.82216e-06f, 1.73999e-06f, 1.79846e-06f, 1.78097e-06f, 2.08078e-06f, 2.41026e-06f, 2.95564e-06f, 4.37817e-06f, 9.26286e-06f, 1.71525e-05f, 1.63404e-05f, 7.76378e-06f, 4.20687e-06f, 4.36152e-06f, 4.1979e-06f, 3.60385e-06f, 4.21227e-06f, 6.61165e-06f, 1.85337e-05f, 2.63714e-05f, 1.23596e-05f, 8.08582e-06f, 7.62016e-06f, 8.54114e-06f, 9.63216e-06f, 1.21937e-05f, 2.92224e-05f, 9.75796e-05f, 9.35745e-05f, 3.33406e-05f, 2.37882e-05f, 2.9829e-05f, 4.42465e-05f, 6.68887e-05f, 0.000152608f, 0.000422651f, 0.000256325f, 6.52584e-05f, 4.13991e-05f, 5.7842e-05f, 0.000264601f, 0.000711195f, 0.000441052f, 8.93762e-05f, 3.04976e-05f, 1.31372e-05f, 8.13006e-06f, 5.95634e-06f, 5.94402e-06f, 6.95574e-06f, 1.12493e-05f, 1.93408e-05f, 3.30614e-05f, 5.526e-05f, 0.000106194f, 0.000246237f, 0.000245793f, 0.000116183f, 6.90781e-05f, 0.000121558f, 0.00012478f, 0.000160506f, 0.000195856f, 0.000163724f, 0.000116846f, 9.27976e-05f, 7.97493e-05f, 7.30327e-05f, 6.2535e-05f, 7.15964e-05f, 6.92402e-05f, 6.98667e-05f, 7.20625e-05f, 5.92742e-05f, 4.73751e-05f, 5.11686e-05f, 3.8765e-05f, 2.87346e-05f, 2.82287e-05f, 4.23112e-05f, 2.84265e-05f, 2.76262e-05f, 3.13753e-05f, 3.20692e-05f, 2.54603e-05f, 1.55049e-05f, 1.67992e-05f, 1.51677e-05f, 1.72863e-05f, 1.82755e-05f, 1.62912e-05f, 1.63329e-05f, 2.11384e-05f, 1.68083e-05f, 1.32225e-05f, 9.90909e-06f, 9.57385e-06f, 9.22475e-06f, 1.59785e-05f, 1.89273e-05f, 1.94756e-05f, 1.68079e-05f, 1.52813e-05f, 1.45048e-05f, 1.12089e-05f, 9.50048e-06f, 7.40732e-06f, 6.16214e-06f, 4.66982e-06f, 4.04122e-06f, 3.96966e-06f, 3.02326e-06f, 3.30965e-06f, 2.53001e-06f, 3.00426e-06f, 3.01337e-06f, 3.36385e-06f, 3.56402e-06f, 4.18688e-06f, 4.12602e-06f, 5.01737e-06f, 5.44329e-06f, 5.985e-06f, 5.40637e-06f, 6.44899e-06f, 5.42357e-06f, 4.91412e-06f, 4.3504e-06f, 3.89253e-06f, 3.67736e-06f, 4.08168e-06f, 3.85234e-06f, 3.99802e-06f, 4.60479e-06f, 5.29422e-06f, 4.87849e-06f, 4.55674e-06f, 4.24992e-06f, 3.52154e-06f, 3.22953e-06f, 2.58855e-06f, 2.42857e-06f, 2.34923e-06f, 2.36014e-06f, 2.33549e-06f, 2.55772e-06f, 3.03473e-06f, 3.14355e-06f, 3.65574e-06f, 3.70734e-06f, 3.68159e-06f, 3.81222e-06f, 3.35656e-06f, 3.062e-06f, 2.69374e-06f, 2.45185e-06f, 2.09096e-06f, 1.87615e-06f, 1.59947e-06f, 1.51572e-06f, 1.47543e-06f, 1.5459e-06f, 1.6819e-06f, 1.89924e-06f, 2.46062e-06f, 2.89706e-06f, 3.43049e-06f, 4.07493e-06f, 4.31785e-06f, 4.56185e-06f, 4.84605e-06f, 4.70059e-06f, 5.04519e-06f, 5.03717e-06f, 5.58133e-06f, 5.772e-06f, 6.2806e-06f, 6.83109e-06f, 7.80214e-06f, 8.13898e-06f }; const float b2[301] = { 7.50196e-07f, 3.64689e-07f, 3.0422e-07f, 2.19926e-07f, 2.95025e-07f, 1.36813e-07f, 2.46454e-07f, 3.07665e-07f, 4.35207e-07f, 4.54783e-07f, 4.09999e-07f, 4.6799e-07f, 4.30817e-07f, 3.21329e-07f, 5.14891e-07f, 5.88871e-07f, 7.24472e-07f, 5.19291e-07f, 5.83071e-07f, 7.385e-07f, 2.80484e-06f, 2.40132e-06f, 1.65424e-06f, 1.01535e-06f, 2.56678e-06f, 6.15462e-06f, 1.34813e-05f, 2.75384e-05f, 4.11764e-05f, 5.15236e-05f, 7.01286e-05f, 0.000133268f, 0.000337419f, 0.000957927f, 0.00227712f, 0.00543291f, 0.0197821f, 0.0818229f, 0.2452f, 0.503309f, 0.70097f, 0.757605f, 0.778255f, 0.788626f, 0.8f, 0.801737f, 0.809859f, 0.82107f, 0.826045f, 0.830925f, 0.842262f, 0.862706f, 0.878482f, 0.876943f, 0.878267f, 0.887613f, 0.907576f, 0.930559f, 0.950192f, 0.976801f, 1.0f, 0.97894f, 0.855779f, 0.593873f, 0.297629f, 0.125661f, 0.0503684f, 0.018199f, 0.00573411f, 0.00297352f, 0.00165595f, 0.000980273f, 0.000604892f, 0.000391497f, 0.000259234f, 0.000168111f, 0.00010894f, 7.63081e-05f, 5.14226e-05f, 5.2013e-05f, 6.6689e-05f, 6.23362e-05f, 6.06577e-05f, 5.93819e-05f, 6.25513e-05f, 5.48608e-05f, 5.86835e-05f, 4.88126e-05f, 4.93644e-05f, 4.14711e-05f, 3.10164e-05f, 2.97216e-05f, 1.74405e-05f, 1.74672e-05f, 1.43447e-05f, 1.09051e-05f, 1.27791e-05f, 9.19063e-06f, 8.62276e-06f, 9.16788e-06f, 8.06522e-06f, 8.53885e-06f, 8.9662e-06f, 7.58053e-06f, 8.12959e-06f, 9.11945e-06f, 7.37798e-06f, 7.16219e-06f, 7.98185e-06f, 6.06857e-06f, 5.53839e-06f, 6.14124e-06f, 4.19494e-06f, 3.49052e-06f, 4.14312e-06f, 3.83884e-06f, 2.7725e-06f, 3.75738e-06f, 3.84359e-06f, 3.23508e-06f, 4.16085e-06f, 5.43268e-06f, 5.65941e-06f, 5.66555e-06f, 1.00131e-05f, 1.62239e-05f, 1.75445e-05f, 2.14947e-05f, 3.58956e-05f, 4.56586e-05f, 3.43405e-05f, 2.38686e-05f, 2.4332e-05f, 2.54789e-05f, 1.95079e-05f, 1.33965e-05f, 1.25793e-05f, 1.40937e-05f, 1.1979e-05f, 8.63893e-06f, 7.58208e-06f, 8.83774e-06f, 1.00948e-05f, 9.00984e-06f, 7.04681e-06f, 8.09797e-06f, 1.08886e-05f, 1.33532e-05f, 1.23902e-05f, 1.19507e-05f, 1.48562e-05f, 2.23955e-05f, 3.10266e-05f, 3.26266e-05f, 3.10397e-05f, 3.39779e-05f, 4.5376e-05f, 6.10958e-05f, 6.5279e-05f, 5.23129e-05f, 4.14838e-05f, 4.19558e-05f, 5.09964e-05f, 6.37575e-05f, 6.45187e-05f, 4.91907e-05f, 3.53937e-05f, 3.00032e-05f, 3.20417e-05f, 4.00312e-05f, 4.4359e-05f, 3.93208e-05f, 2.98789e-05f, 2.47787e-05f, 2.45129e-05f, 2.9428e-05f, 4.04968e-05f, 5.068e-05f, 5.14977e-05f, 4.47032e-05f, 5.94662e-05f, 5.43218e-05f, 6.09036e-05f, 7.73321e-05f, 8.48403e-05f, 9.27208e-05f, 9.49843e-05f, 8.04592e-05f, 5.70392e-05f, 5.08953e-05f, 5.09718e-05f, 4.29127e-05f, 5.66121e-05f, 6.40647e-05f, 6.35005e-05f, 6.45065e-05f, 6.8561e-05f, 6.61624e-05f, 7.80311e-05f, 7.84671e-05f, 7.47972e-05f, 5.56929e-05f, 4.48557e-05f, 3.82956e-05f, 3.24203e-05f, 2.64364e-05f, 2.01874e-05f, 2.18951e-05f, 2.14424e-05f, 2.35802e-05f, 2.69757e-05f, 3.50803e-05f, 3.50877e-05f, 3.08309e-05f, 2.96703e-05f, 2.80215e-05f, 2.15038e-05f, 2.20744e-05f, 1.92407e-05f, 1.75484e-05f, 1.8481e-05f, 1.73708e-05f, 1.80909e-05f, 1.87169e-05f, 1.78419e-05f, 1.86544e-05f, 1.83542e-05f, 1.71676e-05f, 1.57509e-05f, 1.42299e-05f, 1.48274e-05f, 1.35095e-05f, 1.29937e-05f, 1.31147e-05f, 1.17814e-05f, 1.09442e-05f, 1.06259e-05f, 9.91455e-06f, 8.8098e-06f, 7.903e-06f, 7.02151e-06f, 6.14267e-06f, 6.40226e-06f, 6.90937e-06f, 7.40346e-06f, 9.0376e-06f, 1.04649e-05f, 1.20358e-05f, 1.35923e-05f, 1.45542e-05f, 1.52353e-05f, 1.4587e-05f, 1.27967e-05f, 1.1387e-05f, 9.40921e-06f, 7.79714e-06f, 6.31225e-06f, 5.63816e-06f, 5.29451e-06f, 5.25947e-06f, 5.15346e-06f, 5.42692e-06f, 5.31811e-06f, 4.77555e-06f, 3.83623e-06f, 3.20429e-06f, 2.71831e-06f, 2.16288e-06f, 1.99789e-06f, 2.14329e-06f, 2.24263e-06f, 2.42711e-06f, 2.89596e-06f, 2.86037e-06f, 2.81914e-06f, 2.48083e-06f, 2.0678e-06f, 1.92076e-06f, 1.53978e-06f, 1.43754e-06f, 1.37064e-06f, 1.76234e-06f, 2.22508e-06f, 2.69147e-06f, 3.00682e-06f, 3.16738e-06f, 2.99304e-06f, 2.70142e-06f, 2.48436e-06f, 2.08026e-06f, 1.84657e-06f, 2.06456e-06f, 2.72316e-06f, 3.75312e-06f, 4.7306e-06f, 5.55564e-06f, 6.32699e-06f, 5.91106e-06f, 5.11932e-06f, 4.25178e-06f, 3.32253e-06f }; const float b3[301] = { 4.15708e-07f, 2.60143e-07f, 1.32494e-07f, 1.5403e-07f, 1.64746e-07f, 9.97031e-08f, 1.50249e-07f, 2.02269e-07f, 2.84962e-07f, 2.57269e-07f, 2.49117e-07f, 3.36282e-07f, 3.75568e-07f, 2.16954e-07f, 4.25352e-07f, 4.61622e-07f, 4.19126e-07f, 3.82693e-07f, 3.69658e-07f, 5.02627e-07f, 4.42599e-07f, 4.84876e-07f, 4.95357e-07f, 4.94213e-07f, 5.20767e-07f, 3.90137e-07f, 3.59035e-07f, 5.27747e-07f, 3.37674e-07f, 4.88789e-07f, 3.74123e-07f, 3.69271e-07f, 3.20795e-07f, 4.14981e-07f, 4.61504e-07f, 2.95452e-07f, 1.74563e-07f, 3.27091e-07f, 5.33897e-07f, 3.57089e-07f, 5.66046e-07f, 6.04714e-07f, 4.58234e-07f, 5.14316e-07f, 2.30656e-06f, 4.42627e-06f, 8.51169e-06f, 1.27751e-05f, 1.41306e-05f, 1.59342e-05f, 1.97713e-05f, 2.12166e-05f, 2.25515e-05f, 2.66048e-05f, 3.56016e-05f, 4.35119e-05f, 6.64286e-05f, 0.000143846f, 0.000396291f, 0.00113574f, 0.00309186f, 0.0111042f, 0.0405198f, 0.133788f, 0.35151f, 0.606039f, 0.723007f, 0.760026f, 0.779389f, 0.788811f, 0.80685f, 0.828035f, 0.840756f, 0.842039f, 0.844305f, 0.846857f, 0.850335f, 0.859723f, 0.863516f, 0.869143f, 0.882571f, 0.90072f, 0.924469f, 0.942168f, 0.962285f, 0.976601f, 0.985726f, 0.994764f, 1.0f, 0.993053f, 0.979121f, 0.907745f, 0.66404f, 0.301436f, 0.0929241f, 0.0252385f, 0.00556269f, 0.0024767f, 0.0011294f, 0.00050847f, 0.000222899f, 0.00010723f, 5.39405e-05f, 2.56897e-05f, 6.85006e-06f, 3.52589e-06f, 1.71169e-06f, 2.75668e-07f, 1.82902e-06f, 1.67961e-06f, 6.19122e-06f, 8.59549e-06f, 1.52263e-05f, 1.60512e-05f, 2.56929e-05f, 3.25443e-05f, 2.91571e-05f, 2.70292e-05f, 2.41446e-05f, 1.40807e-05f, 2.13973e-07f, 1.02058e-07f, 1.9749e-07f, 1.75362e-07f, 2.57315e-07f, 4.77614e-07f, 6.77741e-07f, 7.65801e-07f, 9.90214e-07f, 7.51558e-07f, 6.2059e-07f, 9.81957e-07f, 1.09702e-06f, 6.25215e-07f, 9.27757e-07f, 1.11919e-06f, 1.17872e-06f, 1.14779e-06f, 8.93355e-07f, 8.36189e-07f, 1.05053e-06f, 1.08276e-06f, 1.04181e-06f, 9.27774e-07f, 1.07702e-06f, 9.37779e-07f, 9.88439e-07f, 1.13665e-06f, 1.09476e-06f, 1.05959e-06f, 1.04925e-06f, 1.29595e-06f, 9.34329e-07f, 1.13077e-06f, 8.30981e-07f, 8.0781e-07f, 1.02709e-06f, 1.16311e-06f, 8.47734e-07f, 9.97851e-07f, 1.11274e-06f, 1.33262e-06f, 1.05514e-06f, 9.58995e-07f, 1.08595e-06f, 1.15264e-06f, 1.41038e-06f, 1.22922e-06f, 1.70163e-06f, 3.4679e-06f, 3.95449e-06f, 2.72695e-06f, 1.36732e-06f, 9.90143e-07f, 7.54806e-07f, 6.55742e-07f, 2.85239e-07f, 6.86364e-07f, 7.71553e-07f, 1.12635e-06f, 9.62279e-07f, 2.59255e-06f, 9.30699e-07f, 1.62071e-07f, 1.00889e-10f, 1.00081e-10f, 0.0f, 0.0f, 0.0f, 3.23471e-08f, 3.49174e-08f, 6.19205e-07f, 5.116e-06f, 4.16041e-06f, 1.78258e-06f, 5.02328e-07f, 2.68142e-07f, 3.8522e-07f, 7.72031e-07f, 2.61664e-07f, 1.37503e-07f, 2.31254e-06f, 8.6085e-06f, 4.70061e-06f, 1.69519e-06f, 1.83093e-07f, 1.14424e-07f, 1.73792e-06f, 1.25833e-06f, 1.66069e-06f, 9.83103e-07f, 1.83029e-07f, 1.17095e-05f, 9.47984e-06f, 1.12401e-05f, 9.14076e-06f, 9.03094e-06f, 8.49106e-06f, 7.68749e-06f, 6.74929e-06f, 7.6733e-06f, 6.95369e-06f, 6.01684e-06f, 5.47181e-06f, 6.12431e-06f, 6.94762e-06f, 6.21639e-06f, 6.62084e-06f, 6.59998e-06f, 5.76706e-06f, 6.04266e-06f, 5.40722e-06f, 5.40383e-06f, 4.91854e-06f, 4.02118e-06f, 3.62242e-06f, 3.52044e-06f, 3.49028e-06f, 2.9236e-06f, 2.56893e-06f, 2.28989e-06f, 2.09968e-06f, 2.91966e-06f, 2.44435e-06f, 2.21268e-06f, 2.22573e-06f, 2.02219e-06f, 1.75423e-06f, 1.83833e-06f, 1.72076e-06f, 1.51802e-06f, 1.53759e-06f, 1.24302e-06f, 1.44829e-06f, 1.35566e-06f, 1.31717e-06f, 1.18067e-06f, 1.12871e-06f, 1.2687e-06f, 1.33911e-06f, 1.09356e-06f, 1.31515e-06f, 1.44675e-06f, 1.55647e-06f, 1.63886e-06f, 1.97263e-06f, 1.86758e-06f, 1.76664e-06f, 1.90731e-06f, 1.8888e-06f, 1.74551e-06f, 1.59134e-06f, 1.71152e-06f, 1.35904e-06f, 1.32272e-06f, 1.27499e-06f, 1.1585e-06f, 1.26847e-06f, 1.33096e-06f, 1.48891e-06f, 1.66013e-06f, 1.92885e-06f, 2.33777e-06f, 2.98726e-06f, 3.83011e-06f, 5.24983e-06f, 7.20736e-06f, 9.73918e-06f, 1.32221e-05f, 1.70002e-05f, 2.10955e-05f, 2.549e-05f, 2.99685e-05f, 3.51168e-05f, 4.07206e-05f, 4.74368e-05f, 5.50521e-05f, 6.53211e-05f, 8.10989e-05f, 0.000105497f, 0.000140101f }; const float b4[301] = { 3.12145e-07f, 8.28534e-08f, 9.83184e-08f, 8.55079e-08f, 4.71887e-08f, 3.85598e-08f, 6.13263e-08f, 1.09691e-07f, 8.19229e-08f, 8.18698e-08f, 8.44374e-08f, 8.18784e-08f, 7.47651e-08f, 6.01096e-08f, 7.12291e-08f, 2.8315e-07f, 6.00765e-07f, 2.10864e-05f, 2.73104e-05f, 4.50671e-07f, 1.06402e-08f, 6.94993e-08f, 3.13328e-08f, 1.09588e-07f, 1.74842e-07f, 1.9277e-07f, 1.34675e-07f, 1.92847e-07f, 2.02477e-07f, 2.6112e-07f, 3.33295e-07f, 2.31552e-07f, 2.58338e-07f, 3.82314e-07f, 4.29747e-07f, 4.01449e-07f, 1.02894e-06f, 5.00318e-06f, 3.23438e-06f, 1.18679e-06f, 5.38393e-07f, 3.44446e-07f, 3.9298e-07f, 3.47571e-07f, 7.25503e-07f, 6.40036e-07f, 5.09299e-07f, 4.9699e-07f, 4.32861e-07f, 6.78173e-07f, 7.05903e-07f, 6.95095e-07f, 7.07479e-07f, 6.7639e-07f, 6.97946e-07f, 6.43371e-07f, 7.30317e-07f, 5.63357e-07f, 3.36905e-07f, 4.48422e-07f, 1.74648e-07f, 3.13465e-07f, 2.23411e-07f, 2.26471e-07f, 1.67155e-07f, 1.6068e-07f, 1.35935e-07f, 2.80495e-07f, 1.38627e-07f, 2.43633e-07f, 3.57075e-07f, 3.20907e-07f, 5.0935e-07f, 2.31732e-07f, 2.02004e-07f, 1.99908e-07f, 1.24175e-07f, 3.61372e-07f, 3.62811e-07f, 3.75752e-06f, 7.00146e-06f, 6.23552e-06f, 4.3711e-06f, 4.90926e-06f, 3.82553e-06f, 1.1127e-05f, 2.66906e-05f, 5.75092e-05f, 0.00012712f, 0.000344491f, 0.000895024f, 0.0022247f, 0.0058789f, 0.0265572f, 0.134652f, 0.38922f, 0.66355f, 0.848198f, 0.899806f, 0.920023f, 0.932634f, 0.940181f, 0.947026f, 0.952441f, 0.966412f, 0.981469f, 0.989723f, 0.992706f, 1.0f, 0.969368f, 0.759433f, 0.436651f, 0.134322f, 0.0308525f, 0.00738524f, 0.00223674f, 0.0006906f, 0.000285122f, 0.000157594f, 9.63247e-05f, 4.43162e-05f, 2.30954e-05f, 1.28847e-05f, 7.45056e-06f, 4.97739e-06f, 3.29911e-06f, 2.15753e-06f, 1.42561e-06f, 8.30459e-07f, 9.51382e-07f, 8.18661e-07f, 7.03925e-07f, 9.15122e-07f, 5.41677e-07f, 8.31395e-07f, 8.59648e-07f, 6.23981e-07f, 8.59012e-07f, 5.17849e-07f, 6.53052e-07f, 9.60845e-07f, 5.49969e-07f, 8.65149e-07f, 8.47562e-07f, 7.28829e-07f, 1.14307e-06f, 9.13936e-07f, 8.44814e-07f, 1.18804e-06f, 1.11252e-06f, 1.50364e-06f, 1.29736e-06f, 1.19152e-06f, 1.05178e-06f, 1.28277e-06f, 1.31103e-06f, 1.03605e-06f, 9.37231e-07f, 1.12941e-06f, 1.07726e-06f, 1.01085e-06f, 8.19055e-07f, 8.60927e-07f, 8.22335e-07f, 7.66233e-07f, 8.69038e-07f, 7.82916e-07f, 7.56701e-07f, 6.00481e-07f, 4.7558e-07f, 5.374e-07f, 6.07694e-07f, 6.55254e-07f, 2.03489e-07f, 3.94378e-07f, 5.87726e-07f, 3.09931e-07f, 4.14639e-07f, 5.61119e-07f, 6.43642e-07f, 2.33671e-05f, 1.59193e-05f, 1.89268e-05f, 2.13128e-05f, 1.12554e-05f, 1.39639e-05f, 1.88608e-05f, 1.99851e-05f, 1.94386e-05f, 9.88685e-06f, 1.82516e-05f, 1.15331e-05f, 9.26691e-06f, 1.352e-05f, 1.06333e-05f, 1.13419e-05f, 1.19485e-05f, 7.6223e-06f, 1.19821e-05f, 1.2663e-05f, 1.70876e-05f, 1.1388e-05f, 6.7115e-06f, 8.61733e-06f, 8.92584e-06f, 6.81989e-06f, 4.43969e-06f, 6.43896e-06f, 4.89677e-06f, 5.81233e-06f, 6.00927e-06f, 4.89342e-06f, 1.92265e-06f, 3.92241e-06f, 3.60834e-06f, 2.9064e-06f, 3.27708e-06f, 2.99611e-06f, 3.11394e-06f, 4.66012e-06f, 3.91458e-06f, 4.29283e-06f, 3.86838e-06f, 3.83149e-06f, 3.27398e-06f, 2.83986e-06f, 2.47138e-06f, 2.0826e-06f, 2.02905e-06f, 1.68586e-06f, 1.78242e-06f, 1.83929e-06f, 1.04638e-06f, 1.38024e-06f, 1.31731e-06f, 1.31521e-06f, 6.52398e-07f, 7.78377e-07f, 9.25714e-07f, 8.67073e-07f, 8.22355e-07f, 7.92099e-07f, 8.62113e-07f, 8.90454e-07f, 6.33338e-07f, 9.92124e-07f, 8.63085e-07f, 7.34335e-07f, 9.03921e-07f, 7.04451e-07f, 7.04449e-07f, 7.89631e-07f, 8.61175e-07f, 8.20682e-07f, 1.00168e-06f, 1.43427e-06f, 1.54572e-06f, 1.60886e-06f, 1.78755e-06f, 1.77994e-06f, 1.53679e-06f, 1.41e-06f, 1.19628e-06f, 9.79616e-07f, 5.21729e-07f, 4.42824e-07f, 4.64902e-07f, 4.29654e-07f, 4.08101e-07f, 4.66717e-07f, 4.10742e-07f, 3.40666e-07f, 3.24714e-07f, 4.197e-07f, 3.64468e-07f, 3.65553e-07f, 3.44671e-07f, 3.67198e-07f, 3.12263e-07f, 3.30082e-07f, 1.99664e-07f, 1.72882e-07f, 1.60492e-07f, 1.2065e-07f, 7.23715e-08f, 1.43254e-07f, 1.12445e-07f, 8.94112e-08f, 9.22383e-08f, 8.79915e-08f, 1.07076e-07f, 1.084e-07f, 1.27328e-07f, 1.69284e-07f, 2.04354e-07f, 2.73764e-07f, 3.37554e-07f, 4.28357e-07f, 4.83865e-07f, 5.33671e-07f, 5.77712e-07f }; const float b5[301] = { 3.12286e-07f, 1.21265e-07f, 6.94181e-08f, 3.9853e-08f, 8.0826e-08f, 4.04409e-08f, 9.26526e-08f, 1.12003e-07f, 2.00442e-07f, 1.25411e-07f, 1.38037e-07f, 1.68875e-07f, 1.62312e-07f, 9.81447e-08f, 2.36616e-07f, 2.99972e-07f, 3.57437e-07f, 1.73237e-07f, 2.51165e-07f, 3.80091e-07f, 2.95126e-07f, 3.00839e-07f, 2.8738e-07f, 3.69689e-07f, 4.13567e-07f, 3.59864e-07f, 6.22912e-07f, 5.73343e-07f, 2.85253e-07f, 3.05785e-07f, 2.84932e-07f, 2.7333e-07f, 3.14806e-07f, 3.26106e-07f, 1.62258e-07f, 1.93473e-07f, 2.7907e-07f, 1.95591e-07f, 3.78068e-07f, 2.19725e-07f, 3.13698e-07f, 2.73155e-07f, 3.05173e-07f, 2.00063e-07f, 1.86757e-06f, 3.44125e-06f, 7.95772e-07f, 6.25956e-07f, 1.17606e-06f, 2.40044e-06f, 9.54706e-07f, 9.25815e-07f, 5.61706e-07f, 1.3451e-06f, 1.28024e-06f, 1.36027e-06f, 2.94643e-06f, 1.86431e-06f, 2.88379e-06f, 2.16267e-06f, 1.53977e-06f, 2.27062e-06f, 8.29005e-07f, 2.30761e-07f, 3.01119e-07f, 2.36372e-07f, 2.45071e-07f, 2.32871e-07f, 1.90817e-07f, 2.06172e-07f, 1.14463e-07f, 3.52299e-08f, 2.27043e-07f, 3.45896e-08f, 2.42045e-08f, 1.21876e-08f, 6.62187e-08f, 6.09625e-08f, 1.41816e-07f, 8.79884e-08f, 1.19441e-07f, 3.73189e-08f, 7.59332e-08f, 2.40439e-07f, 1.17802e-07f, 6.55622e-08f, 8.63856e-08f, 6.44464e-08f, 2.23776e-07f, 1.03047e-07f, 1.32551e-07f, 2.79429e-07f, 2.07195e-07f, 3.67864e-07f, 5.11545e-07f, 5.89037e-07f, 8.2924e-07f, 8.56781e-07f, 1.3186e-06f, 9.10331e-06f, 1.26163e-05f, 2.68254e-05f, 4.09503e-05f, 7.03781e-05f, 0.000122912f, 0.000268666f, 0.000628092f, 0.00164922f, 0.00486736f, 0.0227608f, 0.0955659f, 0.294353f, 0.596071f, 0.822289f, 0.872776f, 0.885335f, 0.927928f, 0.955695f, 0.965042f, 0.967095f, 0.965588f, 0.957776f, 0.9555f, 0.952831f, 0.955801f, 0.965253f, 0.970358f, 0.976493f, 0.987526f, 0.996575f, 0.999085f, 0.992107f, 0.983694f, 0.978311f, 0.88528f, 0.632595f, 0.291823f, 0.0832547f, 0.0204412f, 0.00563548f, 0.00191373f, 0.000843246f, 0.000403589f, 0.000203731f, 0.000101781f, 5.6897e-05f, 2.7195e-05f, 1.61825e-05f, 1.4231e-05f, 1.68343e-05f, 1.3334e-05f, 1.44383e-05f, 1.32012e-05f, 1.24899e-05f, 1.05706e-05f, 6.08328e-06f, 3.05093e-06f, 3.42552e-06f, 1.54743e-06f, 1.36525e-06f, 1.23105e-06f, 4.3642e-07f, 5.81041e-07f, 1.18259e-06f, 3.00501e-06f, 4.97549e-06f, 9.51182e-06f, 7.32646e-06f, 6.71037e-06f, 8.93449e-06f, 6.85023e-06f, 4.8556e-06f, 5.46221e-06f, 2.19395e-06f, 1.5006e-06f, 4.9089e-07f, 2.22462e-06f, 6.60787e-07f, 6.09816e-07f, 9.03731e-07f, 1.37929e-05f, 1.40411e-05f, 1.3406e-05f, 1.63301e-05f, 1.06067e-05f, 1.24196e-05f, 1.08121e-05f, 7.69758e-06f, 8.8836e-06f, 9.03241e-06f, 7.87554e-06f, 4.2784e-06f, 1.07825e-05f, 4.51337e-06f, 6.97831e-06f, 6.53672e-06f, 6.20341e-06f, 6.41495e-06f, 8.42444e-06f, 6.85528e-06f, 2.70354e-06f, 6.50522e-06f, 6.34091e-06f, 6.54655e-06f, 5.05613e-06f, 7.09478e-06f, 9.15616e-06f, 1.08124e-05f, 6.65697e-06f, 7.89558e-06f, 4.14291e-06f, 4.32081e-06f, 8.59893e-06f, 6.22021e-06f, 7.2363e-06f, 6.14019e-06f, 3.87893e-06f, 5.4737e-06f, 4.80289e-06f, 5.01621e-06f, 5.71604e-06f, 5.0985e-06f, 4.24175e-06f, 4.44819e-06f, 3.97763e-06f, 3.48069e-06f, 3.4912e-06f, 4.00016e-06f, 2.68235e-06f, 3.0765e-06f, 3.20229e-06f, 2.41872e-06f, 3.06521e-06f, 2.72094e-06f, 2.13903e-06f, 1.70534e-06f, 1.72736e-06f, 1.5771e-06f, 1.31904e-06f, 1.10782e-06f, 1.20611e-06f, 9.60313e-07f, 1.25562e-06f, 9.96851e-07f, 1.08323e-06f, 9.27816e-07f, 7.70516e-07f, 6.93097e-07f, 7.47027e-07f, 7.07703e-07f, 8.10806e-07f, 7.26741e-07f, 6.80176e-07f, 6.20037e-07f, 6.39881e-07f, 5.95663e-07f, 4.7329e-07f, 5.43599e-07f, 5.47303e-07f, 6.05122e-07f, 5.1772e-07f, 5.88033e-07f, 5.45848e-07f, 5.08645e-07f, 2.36035e-07f, 5.84744e-07f, 5.20728e-07f, 4.18312e-07f, 3.71858e-07f, 4.39561e-07f, 3.37007e-07f, 2.56984e-07f, 3.79198e-07f, 4.64178e-07f, 5.27954e-07f, 6.02129e-07f, 6.16109e-07f, 8.1714e-07f, 7.41506e-07f, 6.23132e-07f, 4.93815e-07f, 3.36936e-07f, 2.6114e-07f, 1.50937e-07f, 1.37661e-07f, 1.5674e-07f, 1.21087e-07f, 1.3344e-07f, 1.58735e-07f, 1.86711e-07f, 1.80942e-07f, 2.25817e-07f, 2.17427e-07f, 2.35791e-07f, 2.14853e-07f, 1.85285e-07f, 1.48392e-07f, 1.1159e-07f, 8.25772e-08f, 7.09923e-08f, 5.57264e-08f }; const float b6[301] = { 1.31873e-07f, 1.87926e-07f, 2.81592e-07f, 2.17374e-07f, 1.70877e-07f, 1.0562e-07f, 1.12979e-07f, 2.00636e-07f, 1.89536e-07f, 2.42299e-07f, 1.75878e-07f, 1.93174e-07f, 2.64698e-07f, 2.57301e-07f, 3.40167e-07f, 3.55343e-07f, 7.60476e-07f, 2.25433e-06f, 1.29749e-06f, 1.29558e-06f, 2.01722e-06f, 1.13819e-06f, 1.64078e-06f, 9.96598e-07f, 9.78403e-07f, 1.06118e-06f, 8.77215e-07f, 1.97241e-06f, 1.14645e-06f, 8.83069e-07f, 7.40957e-07f, 1.02664e-06f, 9.67904e-06f, 5.091e-05f, 2.50784e-06f, 3.48606e-07f, 8.32043e-07f, 2.39095e-05f, 2.58811e-06f, 2.33621e-07f, 1.98094e-07f, 2.85714e-07f, 1.27594e-07f, 1.7327e-07f, 1.82199e-07f, 1.5321e-07f, 1.63299e-07f, 1.01052e-07f, 1.49075e-07f, 5.47801e-07f, 7.84427e-07f, 1.65041e-06f, 8.51018e-07f, 5.77883e-06f, 1.38337e-05f, 7.9076e-06f, 3.87846e-06f, 5.69445e-06f, 1.53368e-05f, 9.94259e-06f, 1.2e-06f, 1.54553e-06f, 4.22091e-06f, 1.43071e-06f, 2.00613e-07f, 1.81045e-07f, 1.2783e-07f, 1.03067e-07f, 1.82997e-07f, 1.10773e-07f, 1.1226e-07f, 1.16695e-07f, 2.16241e-07f, 1.05663e-07f, 1.614e-07f, 1.6817e-07f, 1.16441e-07f, 1.15124e-07f, 6.99069e-08f, 1.53185e-08f, 2.72037e-08f, 1.23476e-07f, 1.55133e-07f, 1.49846e-07f, 3.58885e-07f, 2.02413e-06f, 2.0841e-06f, 8.13696e-07f, 9.02676e-07f, 2.00266e-06f, 3.1147e-06f, 3.09139e-06f, 4.4865e-06f, 6.70102e-06f, 6.05048e-06f, 5.02704e-06f, 7.09114e-06f, 1.13053e-05f, 1.37502e-05f, 1.60627e-05f, 2.40093e-05f, 3.44167e-05f, 3.74905e-05f, 3.98343e-05f, 5.38148e-05f, 7.94317e-05f, 8.83804e-05f, 7.59032e-05f, 9.03911e-05f, 0.000174361f, 0.000184766f, 5.17257e-05f, 8.78977e-06f, 4.47753e-06f, 2.69144e-06f, 1.45718e-06f, 1.07089e-06f, 6.55321e-07f, 1.38442e-06f, 2.79808e-06f, 5.03238e-06f, 6.41933e-06f, 8.09994e-06f, 1.05514e-05f, 1.15504e-05f, 1.14512e-05f, 1.17762e-05f, 1.04862e-05f, 1.12589e-05f, 8.43843e-06f, 8.21063e-06f, 8.85197e-06f, 9.70519e-06f, 1.53186e-05f, 3.28e-05f, 7.87273e-05f, 0.000207342f, 0.000759089f, 0.00312753f, 0.0188368f, 0.0996101f, 0.346835f, 0.622908f, 0.853785f, 0.952792f, 0.978422f, 0.987634f, 0.989026f, 0.993901f, 0.999858f, 0.99928f, 0.989417f, 0.986813f, 0.980962f, 0.977116f, 0.944191f, 0.846399f, 0.615837f, 0.359763f, 0.138813f, 0.0305442f, 0.00709174f, 0.00215848f, 0.000729986f, 0.000269875f, 0.000118803f, 5.53309e-05f, 2.39914e-05f, 9.56683e-06f, 6.93469e-06f, 5.29459e-06f, 3.2974e-06f, 4.31265e-06f, 4.03836e-06f, 5.07602e-06f, 7.67396e-06f, 8.34915e-06f, 9.4325e-06f, 6.44795e-06f, 5.01789e-06f, 6.71178e-08f, 3.03948e-07f, 3.1684e-07f, 2.65135e-07f, 2.09765e-07f, 3.00101e-07f, 1.67201e-07f, 1.60492e-07f, 2.13433e-07f, 1.29106e-07f, 9.71011e-08f, 2.9819e-07f, 1.86975e-07f, 2.30772e-07f, 1.64834e-07f, 6.97091e-08f, 3.40321e-07f, 2.85903e-07f, 2.06352e-07f, 3.65446e-07f, 4.38643e-07f, 1.65414e-07f, 8.01729e-07f, 7.59196e-07f, 1.87131e-06f, 3.94486e-06f, 8.7793e-06f, 1.12049e-05f, 1.14224e-05f, 7.65019e-06f, 4.71997e-06f, 4.25463e-06f, 1.04158e-05f, 8.44869e-06f, 7.60545e-06f, 7.43366e-06f, 8.91167e-06f, 1.17538e-05f, 1.53146e-05f, 1.90496e-05f, 1.73994e-05f, 1.71082e-05f, 1.83056e-05f, 1.86976e-05f, 1.80158e-05f, 1.89996e-05f, 1.5662e-05f, 1.44995e-05f, 1.26694e-05f, 1.02432e-05f, 8.13754e-06f, 6.21556e-06f, 4.54308e-06f, 3.91257e-06f, 3.1588e-06f, 2.52225e-06f, 2.01583e-06f, 1.62728e-06f, 1.47903e-06f, 1.09533e-06f, 1.03503e-06f, 9.97997e-07f, 7.70181e-07f, 7.25907e-07f, 8.38991e-07f, 5.98253e-07f, 7.1384e-07f, 4.89317e-07f, 6.07583e-07f, 5.97359e-07f, 7.18152e-07f, 5.91987e-07f, 6.80961e-07f, 3.87465e-07f, 4.28846e-07f, 6.08958e-07f, 3.8379e-07f, 5.16479e-07f, 5.35559e-07f, 4.5999e-07f, 4.5037e-07f, 4.34943e-07f, 3.90623e-07f, 3.55287e-07f, 3.677e-07f, 4.21178e-07f, 3.62045e-07f, 3.55015e-07f, 2.54848e-07f, 2.60974e-07f, 2.42997e-07f, 1.96909e-07f, 2.38909e-07f, 1.73543e-07f, 2.20613e-07f, 1.73692e-07f, 1.66732e-07f, 1.40222e-07f, 1.22858e-07f, 1.39263e-07f, 1.49344e-07f, 1.63372e-07f, 1.54912e-07f, 1.45368e-07f, 1.58958e-07f, 1.93923e-07f, 1.65487e-07f, 1.60786e-07f, 1.52013e-07f, 1.35784e-07f, 9.24469e-08f, 9.92189e-08f, 7.60063e-08f, 9.85175e-08f, 7.22548e-08f, 4.57741e-08f, 6.97201e-08f, 8.69437e-08f, 1.13252e-07f, 2.58077e-07f, 4.68462e-07f }; const float b7[301] = { 3.42494e-07f, 5.7563e-09f, 2.4306e-08f, 6.23161e-08f, 8.60169e-08f, 6.54447e-09f, 4.9819e-08f, 9.30485e-08f, 5.51852e-08f, 1.75292e-08f, 2.87474e-08f, 2.73409e-08f, 2.83316e-08f, 3.82621e-09f, 3.07146e-08f, 4.55383e-08f, 1.04778e-07f, 1.23884e-09f, 8.25112e-09f, 5.0621e-08f, 1.79225e-07f, 2.74552e-08f, 1.04373e-07f, 9.7114e-08f, 9.62771e-08f, 1.75398e-07f, 8.63102e-08f, 6.84208e-08f, 9.40778e-08f, 5.15181e-08f, 1.02132e-07f, 1.42588e-07f, 8.08711e-08f, 2.16959e-07f, 1.03608e-07f, 9.2287e-08f, 1.59861e-06f, 6.11993e-06f, 3.68931e-07f, 9.24078e-08f, 3.81349e-07f, 2.64627e-07f, 3.27124e-07f, 2.55578e-07f, 2.87094e-07f, 3.84e-07f, 5.21921e-07f, 6.14658e-07f, 3.75539e-07f, 3.80046e-07f, 7.36489e-07f, 1.37786e-06f, 6.07935e-07f, 9.45777e-07f, 1.59554e-06f, 5.68797e-07f, 4.72783e-07f, 5.63447e-07f, 3.35752e-07f, 1.70326e-07f, 3.17931e-07f, 1.41325e-07f, 2.49863e-07f, 3.96423e-07f, 2.16004e-07f, 3.37582e-07f, 2.90124e-07f, 3.80183e-07f, 3.11457e-07f, 3.98668e-07f, 1.79901e-07f, 1.22001e-07f, 1.13002e-07f, 2.85022e-08f, 4.67327e-08f, 1.90183e-08f, 0.0f, 2.99103e-08f, 1.06093e-07f, 1.18422e-07f, 1.07083e-08f, 7.91334e-08f, 9.95149e-08f, 1.54428e-07f, 9.12854e-08f, 2.15373e-08f, 7.48973e-08f, 7.40942e-08f, 0.0f, 3.73909e-08f, 7.49644e-08f, 0.0f, 0.0f, 1.92802e-08f, 2.95975e-08f, 7.04334e-08f, 6.50404e-08f, 0.0f, 0.0f, 0.0f, 2.0755e-07f, 1.04836e-10f, 7.80821e-09f, 1.57983e-07f, 1.0595e-10f, 1.13403e-07f, 3.312e-10f, 1.14176e-07f, 1.03109e-10f, 3.76115e-09f, 7.45634e-09f, 1.19272e-07f, 1.07481e-10f, 1.10155e-10f, 1.1276e-10f, 1.40161e-07f, 1.16185e-10f, 7.139e-08f, 9.90442e-08f, 3.74204e-07f, 5.05087e-07f, 4.6352e-07f, 5.97207e-07f, 5.4384e-07f, 6.81312e-07f, 6.90591e-07f, 1.00825e-06f, 8.18553e-07f, 1.07975e-06f, 8.27673e-07f, 9.35167e-07f, 9.64121e-07f, 1.00596e-06f, 8.68247e-07f, 8.97409e-07f, 1.19586e-06f, 1.28982e-06f, 9.86575e-07f, 9.25037e-07f, 2.05008e-06f, 1.71977e-06f, 3.51855e-06f, 4.80754e-06f, 6.35905e-06f, 5.22507e-06f, 4.29703e-06f, 3.92372e-06f, 4.42103e-06f, 4.97574e-06f, 5.96695e-06f, 6.60085e-06f, 1.11374e-05f, 1.62372e-05f, 2.84438e-05f, 4.4002e-05f, 7.0506e-05f, 0.000106141f, 0.000165311f, 0.000256229f, 0.000412257f, 0.000713036f, 0.00139941f, 0.00288571f, 0.00595325f, 0.0126868f, 0.0276938f, 0.0588599f, 0.123117f, 0.260204f, 0.506774f, 0.759967f, 0.94058f, 0.995805f, 0.997622f, 0.988907f, 0.983091f, 0.972934f, 0.958312f, 0.941139f, 0.931907f, 0.919382f, 0.90908f, 0.8976f, 0.88212f, 0.871191f, 0.863054f, 0.844284f, 0.836496f, 0.838036f, 0.841189f, 0.835657f, 0.833819f, 0.842548f, 0.830777f, 0.818604f, 0.816837f, 0.806711f, 0.81076f, 0.794161f, 0.779884f, 0.767313f, 0.749602f, 0.739271f, 0.738714f, 0.734145f, 0.711833f, 0.697141f, 0.680462f, 0.658635f, 0.649781f, 0.632471f, 0.619908f, 0.60912f, 0.598992f, 0.590914f, 0.566107f, 0.507112f, 0.402799f, 0.275174f, 0.157667f, 0.0738047f, 0.032787f, 0.0138147f, 0.00539084f, 0.00262463f, 0.00180863f, 0.00130633f, 0.00103281f, 0.000917177f, 0.000891162f, 0.000798344f, 0.000745739f, 0.000727178f, 0.000783273f, 0.000701058f, 0.000655311f, 0.00060278f, 0.000557875f, 0.000281186f, 0.000274231f, 4.37496e-06f, 3.22571e-06f, 2.88909e-06f, 2.24195e-06f, 1.98867e-06f, 1.47066e-06f, 1.12615e-06f, 1.04739e-06f, 1.1344e-06f, 8.90363e-07f, 8.71592e-07f, 7.40614e-07f, 7.19518e-07f, 6.91579e-07f, 7.01778e-07f, 6.72029e-07f, 4.36737e-07f, 6.31103e-07f, 6.64941e-07f, 6.02511e-07f, 3.22655e-07f, 5.32912e-07f, 4.71662e-07f, 4.99519e-07f, 3.35434e-07f, 4.46158e-07f, 4.48065e-07f, 3.19015e-07f, 2.39899e-07f, 4.55294e-07f, 2.89741e-07f, 2.5021e-07f, 2.57359e-07f, 3.5683e-07f, 2.96983e-07f, 2.97873e-07f, 1.88219e-07f, 2.40558e-07f, 2.15601e-07f, 2.13278e-07f, 1.40431e-07f, 1.60961e-07f, 1.70122e-07f, 1.10615e-07f, 1.0436e-07f, 1.222e-07f, 1.25283e-07f, 9.88137e-08f, 8.59799e-08f, 9.19016e-08f, 7.99614e-08f, 8.73603e-08f, 7.68151e-08f, 6.51417e-08f, 7.38325e-08f, 6.48494e-08f, 5.64187e-08f, 6.5542e-08f, 5.90555e-08f, 4.77664e-08f, 5.59409e-08f }; const float b8[301] = { 2.75157e-07f, 6.96359e-06f, 1.9874e-05f, 8.73924e-05f, 7.4835e-05f, 5.16098e-06f, 4.81496e-07f, 6.24369e-07f, 2.89158e-07f, 1.33848e-07f, 1.61046e-07f, 2.69148e-07f, 1.41051e-07f, 1.93786e-07f, 2.0957e-07f, 2.34628e-07f, 2.36518e-07f, 2.47669e-07f, 2.25346e-07f, 2.01273e-07f, 2.14493e-07f, 1.42204e-07f, 1.7784e-07f, 2.29739e-07f, 4.0488e-07f, 2.15782e-07f, 1.58074e-07f, 1.50063e-07f, 7.18437e-08f, 1.88801e-07f, 2.3008e-07f, 1.64135e-07f, 1.27638e-07f, 1.9751e-07f, 1.13678e-07f, 7.76496e-07f, 1.1877e-06f, 1.47692e-07f, 2.12794e-07f, 1.89394e-06f, 1.22e-06f, 8.28353e-07f, 5.66846e-07f, 1.55612e-07f, 3.89524e-08f, 6.08863e-08f, 4.13505e-07f, 1.57781e-07f, 8.45778e-09f, 9.45575e-07f, 3.68309e-06f, 1.1502e-06f, 2.14722e-07f, 1.01022e-07f, 6.8025e-07f, 8.6337e-07f, 3.19639e-08f, 2.56285e-07f, 1.35378e-07f, 3.34694e-08f, 7.36246e-07f, 8.36204e-07f, 2.65609e-08f, 8.10432e-08f, 2.05826e-07f, 3.69154e-07f, 8.02175e-07f, 8.89483e-07f, 4.4826e-07f, 2.42823e-07f, 2.17011e-07f, 2.65704e-06f, 8.78188e-06f, 7.05779e-07f, 3.82597e-07f, 4.04534e-06f, 4.67549e-06f, 9.19411e-08f, 2.98568e-07f, 2.08203e-06f, 1.03067e-06f, 9.72367e-08f, 1.50024e-07f, 1.2413e-07f, 1.4876e-07f, 2.35395e-08f, 1.65976e-10f, 1.65631e-10f, 8.45577e-09f, 1.59829e-10f, 1.56488e-10f, 1.35137e-07f, 1.26482e-06f, 9.54683e-08f, 2.93604e-07f, 1.59714e-07f, 2.23112e-07f, 5.34018e-07f, 6.1337e-07f, 1.72864e-07f, 5.77747e-07f, 4.80195e-07f, 5.14193e-07f, 5.97282e-07f, 1.16949e-06f, 5.3439e-07f, 2.8602e-07f, 2.20078e-07f, 5.34755e-07f, 5.51942e-07f, 6.32398e-07f, 1.13151e-06f, 1.09476e-06f, 3.24873e-07f, 3.6263e-07f, 5.49154e-07f, 8.32561e-08f, 6.24779e-07f, 6.90714e-07f, 8.366e-07f, 1.2346e-06f, 1.93899e-06f, 2.35572e-06f, 9.86481e-07f, 5.4618e-07f, 1.53631e-06f, 4.98064e-07f, 4.68967e-08f, 2.82103e-07f, 1.79437e-07f, 2.82801e-07f, 5.47962e-07f, 7.69025e-07f, 1.62521e-07f, 2.32749e-07f, 5.04263e-07f, 8.32099e-07f, 2.27261e-07f, 4.08301e-07f, 3.43738e-07f, 1.2715e-07f, 2.36481e-07f, 8.74008e-08f, 3.913e-07f, 4.88832e-07f, 6.9057e-07f, 7.13913e-07f, 8.95172e-07f, 8.96901e-07f, 5.53029e-07f, 1.04012e-06f, 9.12699e-07f, 7.19448e-07f, 7.20192e-07f, 8.80887e-07f, 1.14393e-06f, 5.57443e-07f, 9.4312e-07f, 1.04838e-06f, 9.98724e-07f, 1.23283e-06f, 8.72156e-07f, 8.03599e-07f, 5.35655e-07f, 8.46701e-07f, 6.91104e-07f, 8.55943e-07f, 6.31436e-07f, 4.51508e-07f, 1.11291e-06f, 1.03136e-06f, 4.73296e-07f, 6.08156e-07f, 8.62452e-07f, 9.2854e-07f, 7.79087e-07f, 1.22534e-06f, 0.000114086f, 0.000453417f, 0.000504746f, 0.000779556f, 0.0010461f, 0.000976304f, 0.00111328f, 0.0010687f, 0.00109088f, 0.00109552f, 0.00113106f, 0.00109447f, 0.00108912f, 0.00104157f, 0.0011403f, 0.001127f, 0.00117057f, 0.00115094f, 0.00120607f, 0.00135466f, 0.00130018f, 0.00149181f, 0.002231f, 0.00432839f, 0.0105836f, 0.0305957f, 0.107853f, 0.313746f, 0.571884f, 0.789269f, 0.951541f, 0.987144f, 0.991677f, 0.993363f, 0.999691f, 0.996691f, 0.983327f, 0.970856f, 0.95236f, 0.93302f, 0.922376f, 0.910922f, 0.899767f, 0.892112f, 0.878565f, 0.864645f, 0.850525f, 0.841298f, 0.827257f, 0.80818f, 0.794005f, 0.774377f, 0.760282f, 0.746906f, 0.725848f, 0.708967f, 0.689184f, 0.66172f, 0.64063f, 0.620929f, 0.596457f, 0.574685f, 0.551871f, 0.530905f, 0.51163f, 0.493667f, 0.474118f, 0.454311f, 0.437766f, 0.421449f, 0.406047f, 0.389741f, 0.376622f, 0.363517f, 0.349855f, 0.336697f, 0.326962f, 0.31708f, 0.305806f, 0.29492f, 0.282203f, 0.271439f, 0.260807f, 0.250912f, 0.243373f, 0.235734f, 0.227658f, 0.217559f, 0.208722f, 0.198576f, 0.188152f, 0.178705f, 0.168441f, 0.159032f, 0.148125f, 0.13777f, 0.124557f, 0.109612f, 0.0917406f, 0.0715068f, 0.0503125f, 0.0328064f, 0.0198817f, 0.00979572f, 0.00470763f, 0.00218491f, 0.00102923f, 0.000523709f, 0.000298469f, 0.000200007f, 0.000145961f, 0.000114257f, 0.000102038f, 8.00865e-05f, 7.65951e-05f, 8.01237e-05f, 6.45166e-05f, 7.00539e-05f, 6.46441e-05f, 5.37976e-05f, 2.97925e-05f, 2.99793e-05f, 2.77311e-05f, 6.76079e-07f }; //Add multispectral bands to the temporary list const std::vector vb1 (b1, b1 + sizeof(b1) / sizeof(float) ); tmpSpectralBandList.push_back(vb1); const std::vector vb2 (b2, b2 + sizeof(b2) / sizeof(float) ); tmpSpectralBandList.push_back(vb2); const std::vector vb3 (b3, b3 + sizeof(b3) / sizeof(float) ); tmpSpectralBandList.push_back(vb3); const std::vector vb4 (b4, b4 + sizeof(b4) / sizeof(float) ); tmpSpectralBandList.push_back(vb4); const std::vector vb5 (b5, b5 + sizeof(b5) / sizeof(float) ); tmpSpectralBandList.push_back(vb5); const std::vector vb6 (b6, b6 + sizeof(b6) / sizeof(float) ); tmpSpectralBandList.push_back(vb6); const std::vector vb7 (b7, b7 + sizeof(b7) / sizeof(float) ); tmpSpectralBandList.push_back(vb7); const std::vector vb8 (b8, b8 + sizeof(b8) / sizeof(float) ); tmpSpectralBandList.push_back(vb8); } unsigned int j = 0; for (std::list >::const_iterator it = tmpSpectralBandList.begin(); it != tmpSpectralBandList.end(); ++it) { wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); wavelengthSpectralBand->GetNthElement(j)->SetFilterFunctionValues(*it); wavelengthSpectralBand->GetNthElement(j)->SetMinSpectralValue(0.350); wavelengthSpectralBand->GetNthElement(j)->SetMaxSpectralValue(1.1); wavelengthSpectralBand->GetNthElement(j)->SetUserStep(0.0025); ++j; } return wavelengthSpectralBand; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/src/otbWorldView2ImageMetadataInterfaceFactory.cxx000066400000000000000000000030561301006202600312430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbWorldView2ImageMetadataInterfaceFactory.h" #include "otbWorldView2ImageMetadataInterface.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" namespace otb { WorldView2ImageMetadataInterfaceFactory ::WorldView2ImageMetadataInterfaceFactory() { this->RegisterOverride("OpticalImageMetadataInterface", "otbWorldView2ImageMetadataInterface", "WorldView2 Metadata Interface", 1, itk::CreateObjectFunction::New()); } WorldView2ImageMetadataInterfaceFactory ::~WorldView2ImageMetadataInterfaceFactory() { } const char* WorldView2ImageMetadataInterfaceFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* WorldView2ImageMetadataInterfaceFactory::GetDescription() const { return "WorldView2 Metadata Interface Factory, handle WorldView2 metadata in OTB"; } } // end namespace otb OTB-release-5.8/Modules/Core/Metadata/test/000077500000000000000000000000001301006202600204155ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Metadata/test/CMakeLists.txt000066400000000000000000000463471301006202600231730ustar00rootroot00000000000000otb_module_test() set(OTBMetadataTests otbMetadataTestDriver.cxx otbOpticalDefaultImageMetadataInterfaceNew.cxx otbSarImageMetadataInterfaceTest.cxx otbDefaultImageMetadataInterfaceFactoryNew.cxx otbOpticalDefaultImageMetadataInterfaceFactoryNew.cxx otbPleiadesImageMetadataInterfaceNew.cxx otbImageMetadataInterfaceBaseTest.cxx otbSarDefaultImageMetadataInterface.cxx otbSarDefaultImageMetadataInterfaceNew.cxx otbOpticalImageMetadataInterfaceTest.cxx otbSarDefaultImageMetadataInterfaceFactoryNew.cxx otbFormosatImageMetadataInterfaceNew.cxx otbOpticalDefaultImageMetadataInterface.cxx otbSpot6ImageMetadataInterfaceNew.cxx otbSpotImageMetadataInterfaceNew.cxx otbQuickBirdImageMetadataInterfaceNew.cxx otbIkonosImageMetadataInterfaceNew.cxx otbTerraSarImageMetadataInterfaceNew.cxx otbSentinel1ImageMetadataInterfaceNew.cxx otbWorldView2ImageMetadataInterfaceNew.cxx otbDefaultImageMetadataInterface.cxx otbImageMetadataInterfaceTest2.cxx otbNoDataHelperTest.cxx otbSarCalibrationLookupDataTest.cxx otbRadarsat2ImageMetadataInterfaceNew.cxx ) add_executable(otbMetadataTestDriver ${OTBMetadataTests}) target_link_libraries(otbMetadataTestDriver ${OTBMetadata-Test_LIBRARIES}) otb_module_target_label(otbMetadataTestDriver) # Tests Declaration otb_add_test(NAME ioTuOpticalDefaultImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbOpticalDefaultImageMetadataInterfaceNew ) #otb_add_test(NAME ioTvSarImageMetadataInterfaceTest_TSX1dims COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvSarImageMetadataInterface_TSX1dims.txt #${TEMP}/ioTvSarImageMetadataInterface_TSX1dims.txt #otbSarImageMetadataInterfaceTest #LARGEINPUT{TERRASARX/dims/TSX-1.SAR.L1B/TSX1_SAR__SSC/IMAGEDATA/IMAGE_HH_SRA_strip_011.cos} #${TEMP}/ioTvSarImageMetadataInterface_TSX1dims.txt #) #otb_add_test(NAME ioTvSarImageMetadataInterfaceTest_TSX1PANGKALANBUUNUsingVVCosFile COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvSarImageMetadataInterface_TSX1PANGKALANBUUNUsingVVCosFile.txt #${TEMP}/ioTvSarImageMetadataInterface_TSX1PANGKALANBUUNUsingVVCosFile.txt #otbSarImageMetadataInterfaceTest #LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_VV_SRA_stripFar_008.cos} #${TEMP}/ioTvSarImageMetadataInterface_TSX1PANGKALANBUUNUsingVVCosFile.txt #) #otb_add_test(NAME ioTvSarImageMetadataInterfaceTest_TSX1TORONTO COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvSarImageMetadataInterface_TSX1TORONTO.txt #${TEMP}/ioTvSarImageMetadataInterface_TSX1TORONTO.txt #otbSarImageMetadataInterfaceTest #LARGEINPUT{TERRASARX/TORONTO/TSX1_SAR__SSC/IMAGEDATA/IMAGE_HH_SRA_spot_074.cos} #${TEMP}/ioTvSarImageMetadataInterface_TSX1TORONTO.txt #) #otb_add_test(NAME ioTvSarImageMetadataInterfaceTest_TSX1PANGKALANBUUNUsingXmlFile COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvSarImageMetadataInterface_TSX1PangkalanbuunuUsingXmlFile.txt #${TEMP}/ioTvSarImageMetadataInterface_TSX1PangkalanbuunuUsingXmlFile.txt #otbSarImageMetadataInterfaceTest #LARGEINPUT{TERRASARX/PANGKALANBUUN/TSX1_SAR__SSC______SM_D_SRA_20080313T221955_20080313T222003.xml} #${TEMP}/ioTvSarImageMetadataInterface_TSX1PangkalanbuunuUsingXmlFile.txt #) #otb_add_test(NAME ioTvSarImageMetadataInterfaceTest_TSX1PANGKALANBUUNUsingHHCosFile COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvSarImageMetadataInterface_TSX1PANGKALANBUUNUsingHHCosFile.txt #${TEMP}/ioTvSarImageMetadataInterface_TSX1PANGKALANBUUNUsingHHCosFile.txt #otbSarImageMetadataInterfaceTest #LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} #${TEMP}/ioTvSarImageMetadataInterface_TSX1PANGKALANBUUNUsingHHCosFile.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_SENTINEL1 COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_SENTINEL1.txt #${TEMP}/ioTvImageMetadataInterfaceBase_SENTINEL1.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{SENTINEL1/S1A_S6_SLC__1SSV_20150619T195043/measurement/s1a-s6-slc-vv-20150619t195043-20150619t195101-006447-00887d-001.tiff} #${TEMP}/ioTvImageMetadataInterfaceBase_SENTINEL1.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_RADARSAT2 COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_RADARSAT2.txt #${TEMP}/ioTvImageMetadataInterfaceBase_RADARSAT2.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{RADARSAT2/ALTONA/Fine_Quad-Pol_Dataset/PK6621_DK406_FQ9_20080405_124900_HH_VV_HV_VH_SLC_Altona/imagery_HV.tif} #${TEMP}/ioTvImageMetadataInterfaceBase_RADARSAT2.txt #) otb_add_test(NAME ioTuSentinel1ImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbSentinel1ImageMetadataInterfaceNew ) otb_add_test(NAME ioTuRadarsat2ImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbRadarsat2ImageMetadataInterfaceNew ) otb_add_test(NAME ioTuDefaultImageMetadataInterfaceFactoryNew COMMAND otbMetadataTestDriver otbDefaultImageMetadataInterfaceFactoryNew ) otb_add_test(NAME ioTuOpticalDefaultImageMetadataInterfaceFactoryNew COMMAND otbMetadataTestDriver otbOpticalDefaultImageMetadataInterfaceFactoryNew ) otb_add_test(NAME ioTuPleiadesImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbPleiadesImageMetadataInterfaceNew ) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_SPOT COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_SPOT.txt #${TEMP}/ioTvImageMetadataInterfaceBase_SPOT.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} #${TEMP}/ioTvImageMetadataInterfaceBase_SPOT.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_TSX1PANGKALANBUUNUsingVVCosFile COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_TSX1PANGKALANBUUNUsingVVCosFile.txt #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1PANGKALANBUUNUsingVVCosFile.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_VV_SRA_stripFar_008.cos} #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1PANGKALANBUUNUsingVVCosFile.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_TSX1PANGKALANBUUNUsingHHCosFile COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_TSX1PANGKALANBUUNUsingHHCosFile.txt #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1PANGKALANBUUNUsingHHCosFile.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1PANGKALANBUUNUsingHHCosFile.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_FORMOSAT2 COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_FORMOSAT2.txt #${TEMP}/ioTvImageMetadataInterfaceBase_FORMOSAT2.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} #${TEMP}/ioTvImageMetadataInterfaceBase_FORMOSAT2.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_TSX1dims COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_TSX1dims.txt #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1dims.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{TERRASARX/dims/TSX-1.SAR.L1B/TSX1_SAR__SSC/IMAGEDATA/IMAGE_HH_SRA_strip_011.cos} #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1dims.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_QBMUL COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_QBMUL.txt #${TEMP}/ioTvImageMetadataInterfaceBase_QBMUL.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} #${TEMP}/ioTvImageMetadataInterfaceBase_QBMUL.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_WV2Mul COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_WV2RomeMul.txt #${TEMP}/ioTvImageMetadataInterfaceBase_WV2RomeMul.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL/09DEC10103019-M2AS-052298844010_01_P001.TIF} #${TEMP}/ioTvImageMetadataInterfaceBase_WV2RomeMul.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_QB COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_QB.txt #${TEMP}/ioTvImageMetadataInterfaceBase_QB.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} #${TEMP}/ioTvImageMetadataInterfaceBase_QB.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_WV2Pan COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_WV2RomePan.txt #${TEMP}/ioTvImageMetadataInterfaceBase_WV2RomePan.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} #${TEMP}/ioTvImageMetadataInterfaceBase_WV2RomePan.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_IKONOS COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_IKONOS.txt #${TEMP}/ioTvImageMetadataInterfaceBase_IKONOS.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_blu_0000000.tif} #${TEMP}/ioTvImageMetadataInterfaceBase_IKONOS.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_TSX1PANGKALANBUUNUsingXmlFile COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_TSX1PangkalanbuunuUsingXmlFile.txt #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1PangkalanbuunuUsingXmlFile.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{TERRASARX/PANGKALANBUUN/TSX1_SAR__SSC______SM_D_SRA_20080313T221955_20080313T222003.xml} #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1PangkalanbuunuUsingXmlFile.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_QBCevennes COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_QBCevennes.txt #${TEMP}/ioTvImageMetadataInterfaceBase_QBCevennes.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{QUICKBIRD/CEVENNES/06FEB12104912-P1BS-005533998070_01_P001.TIF} #${TEMP}/ioTvImageMetadataInterfaceBase_QBCevennes.txt #) #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_TSX1TORONTO COMMAND otbMetadataTestDriver #--compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_TSX1TORONTO.txt #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1TORONTO.txt #otbImageMetadataInterfaceBaseTest #LARGEINPUT{TERRASARX/TORONTO/TSX1_SAR__SSC/IMAGEDATA/IMAGE_HH_SRA_spot_074.cos} #${TEMP}/ioTvImageMetadataInterfaceBase_TSX1TORONTO.txt #) otb_add_test(NAME ioTuSarDefaultImageMetadataInterface COMMAND otbMetadataTestDriver otbSarDefaultImageMetadataInterface ) otb_add_test(NAME ioTuSarDefaultImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbSarDefaultImageMetadataInterfaceNew ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_QBCevennes COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_QBCevennes.txt ${TEMP}/ioTvOpticalImageMetadataInterface_QBCevennes.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{QUICKBIRD/CEVENNES/06FEB12104912-P1BS-005533998070_01_P001.TIF} ${TEMP}/ioTvOpticalImageMetadataInterface_QBCevennes.txt ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_WV2Pan COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_WV2RomePan.txt ${TEMP}/ioTvOpticalImageMetadataInterface_WV2RomePan.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} ${TEMP}/ioTvOpticalImageMetadataInterface_WV2RomePan.txt ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_QBMUL COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_QBMUL.txt ${TEMP}/ioTvOpticalImageMetadataInterface_QBMUL.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TEMP}/ioTvOpticalImageMetadataInterface_QBMUL.txt ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_WV2Mul COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_WV2RomeMul.txt ${TEMP}/ioTvOpticalImageMetadataInterface_WV2RomeMul.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL/09DEC10103019-M2AS-052298844010_01_P001.TIF} ${TEMP}/ioTvOpticalImageMetadataInterface_WV2RomeMul.txt ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_SPOT COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_SPOT.txt ${TEMP}/ioTvOpticalImageMetadataInterface_SPOT.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} ${TEMP}/ioTvOpticalImageMetadataInterface_SPOT.txt ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_QB COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_QB.txt ${TEMP}/ioTvOpticalImageMetadataInterface_QB.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/ioTvOpticalImageMetadataInterface_QB.txt ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_IKONOS COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_IKONOS.txt ${TEMP}/ioTvOpticalImageMetadataInterface_IKONOS.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_blu_0000000.tif} ${TEMP}/ioTvOpticalImageMetadataInterface_IKONOS.txt ) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_FORMOSAT2 COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_FORMOSAT2.txt ${TEMP}/ioTvOpticalImageMetadataInterface_FORMOSAT2.txt otbOpticalImageMetadataInterfaceTest LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} ${TEMP}/ioTvOpticalImageMetadataInterface_FORMOSAT2.txt ) otb_add_test(NAME ioTuSarDefaultImageMetadataInterfaceFactoryNew COMMAND otbMetadataTestDriver otbSarDefaultImageMetadataInterfaceFactoryNew ) otb_add_test(NAME ioTuFormosatImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbFormosatImageMetadataInterfaceNew ) otb_add_test(NAME ioTuOpticalDefaultImageMetadataInterface COMMAND otbMetadataTestDriver otbOpticalDefaultImageMetadataInterface ) otb_add_test(NAME ioTuSpot6ImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbSpot6ImageMetadataInterfaceNew ) otb_add_test(NAME ioTuSpotImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbSpotImageMetadataInterfaceNew ) otb_add_test(NAME ioTuQuickBirdImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbQuickBirdImageMetadataInterfaceNew ) otb_add_test(NAME ioTuIkonosImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbIkonosImageMetadataInterfaceNew ) otb_add_test(NAME ioTuTerraSarImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbTerraSarImageMetadataInterfaceNew ) otb_add_test(NAME ioTuWorldView2ImageMetadataInterfaceNew COMMAND otbMetadataTestDriver otbWorldView2ImageMetadataInterfaceNew ) otb_add_test(NAME ioTuDefaultImageMetadataInterface COMMAND otbMetadataTestDriver otbDefaultImageMetadataInterface ) otb_add_test(NAME ioTvImageMetadataInterfaceTest COMMAND otbMetadataTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvImageMetadataInterface.txt ${TEMP}/ioTvImageMetadataInterface.txt otbImageMetadataInterfaceTest2 ${EXAMPLEDATA}/qb_RoadExtract.tif ${TEMP}/ioTvImageMetadataInterface.txt ) set( GenericTestPHR_TESTNB 0) foreach( current_file ${GenericTestPHR_DATA_INPUTS} ) list(GET GenericTestPHR_DATA_TYPES ${GenericTestPHR_TESTNB} current_type ) math(EXPR GenericTestPHR_TESTNB "${GenericTestPHR_TESTNB} + 1") #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_${current_type} COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} #${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_${current_type}.txt #${TEMP}/ioTvImageMetadataInterfaceBase_${current_type}_OUT.txt #otbImageMetadataInterfaceBaseTest #${current_file} #${TEMP}/ioTvImageMetadataInterfaceBase_${current_type}_OUT.txt #) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_${current_type} COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_${current_type}.txt ${TEMP}/ioTvOpticalImageMetadataInterface_${current_type}_OUT.txt otbOpticalImageMetadataInterfaceTest ${current_file} ${TEMP}/ioTvOpticalImageMetadataInterface_${current_type}_OUT.txt ) endforeach() # SPOT 6 set( GenericTestSPOT6_TESTNB 0) foreach( current_file ${GenericTestSPOT6_DATA_INPUTS} ) list(GET GenericTestSPOT6_DATA_TYPES ${GenericTestSPOT6_TESTNB} current_type ) math(EXPR GenericTestSPOT6_TESTNB "${GenericTestSPOT6_TESTNB} + 1") #otb_add_test(NAME ioTvImageMetadataInterfaceBaseTest_${current_type} COMMAND otbMetadataTestDriver #--compare-ascii ${NOTOL} #${BASELINE_FILES}/ioTvImageMetadataInterfaceBase_${current_type}.txt #${TEMP}/ioTvImageMetadataInterfaceBase_${current_type}_OUT.txt #otbImageMetadataInterfaceBaseTest #${current_file} #${TEMP}/ioTvImageMetadataInterfaceBase_${current_type}_OUT.txt #) otb_add_test(NAME ioTvOpticalImageMetadataInterfaceTest_${current_type} COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvOpticalImageMetadataInterface_${current_type}.txt ${TEMP}/ioTvOpticalImageMetadataInterface_${current_type}_OUT.txt otbOpticalImageMetadataInterfaceTest ${current_file} ${TEMP}/ioTvOpticalImageMetadataInterface_${current_type}_OUT.txt ) endforeach() otb_add_test(NAME coreMetaDataNoDataHelperTest COMMAND otbMetadataTestDriver otbNoDataHelperTest) otb_add_test(NAME ioTvSarCalibrationLookupDataTest_SENTINEL1 COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvSarCalibrationLookupDataTest_SENTINEL1.txt ${TEMP}/ioTvSarCalibrationLookupDataTest_SENTINEL1.txt otbSarCalibrationLookupDataTest ${INPUTDATA}/SENTINEL1_SLC_S6_1S_extract_300_300.tif?&geom=${INPUTDATA}/SENTINEL1_SLC_S6_1S_extract_300_300.geom ${TEMP}/ioTvSarCalibrationLookupDataTest_SENTINEL1.txt ) otb_add_test(NAME ioTvSarCalibrationLookupDataTest_RADARSAT2 COMMAND otbMetadataTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvSarCalibrationLookupDataTest_RADARSAT2.txt ${TEMP}/ioTvSarCalibrationLookupDataTest_RADARSAT2.txt otbSarCalibrationLookupDataTest ${INPUTDATA}/RADARSAT2_ALTONA_300_300_VV.tif?&geom=${INPUTDATA}/RADARSAT2_ALTONA_300_300_VV.geom ${TEMP}/ioTvSarCalibrationLookupDataTest_RADARSAT2.txt ) OTB-release-5.8/Modules/Core/Metadata/test/otbDefaultImageMetadataInterface.cxx000066400000000000000000000177011301006202600274650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDefaultImageMetadataInterface.h" int otbDefaultImageMetadataInterface(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::DefaultImageMetadataInterface ObjectType; ObjectType::Pointer obj = ObjectType::New(); bool hasRaisedException; hasRaisedException = false; try { std::cout << obj->GetPhysicalBias() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetPhysicalBias() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetPhysicalGain() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetPhysicalGain() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetSolarIrradiance() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSolarIrradiance() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetDay() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetDay() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetMonth() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetMonth() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetYear() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetYear() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetHour() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetHour() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetMinute() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetMinute() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetProductionDay() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetProductionDay() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetProductionMonth() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetProductionMonth() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetProductionYear() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetProductionYear() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetSatElevation() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSatElevation() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetSatAzimuth() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSatAzimuth() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetFirstWavelengths() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetFirstWavelengths() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::cout << obj->GetLastWavelengths() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetLastWavelengths() !" << std::endl; std::cout << err << std::endl; hasRaisedException =true; } if(!hasRaisedException) { std::cerr << " Should has raise an exception !"<< std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { if( obj->CanRead() != true) { std::cout << "wrong value for CanRead() method!" << std::endl; return EXIT_FAILURE; } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for CanRead() !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } hasRaisedException = false; try { std::vector rgb(3); rgb = obj->GetDefaultDisplay(); if (obj->GetNumberOfBands() != 0 && rgb[0] != 0 && rgb[1] != 1 && rgb[2] != 2) { std::cout << "wrong value for GetDefaultDisplay() method!" << std::endl; return EXIT_FAILURE; } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetDefaultDisplay() !" << std::endl; std::cout << err << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbDefaultImageMetadataInterfaceFactoryNew.cxx000066400000000000000000000016221301006202600314620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDefaultImageMetadataInterfaceFactory.h" int otbDefaultImageMetadataInterfaceFactoryNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::DefaultImageMetadataInterfaceFactory ObjectType; ObjectType::Pointer object = ObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbFormosatImageMetadataInterfaceNew.cxx000066400000000000000000000016151301006202600303420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbFormosatImageMetadataInterface.h" int otbFormosatImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::FormosatImageMetadataInterface::Pointer object = otb::FormosatImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbIkonosImageMetadataInterfaceNew.cxx000066400000000000000000000016041301006202600300100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbIkonosImageMetadataInterface.h" int otbIkonosImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::IkonosImageMetadataInterface::Pointer object = otb::IkonosImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbImageMetadataInterfaceBaseTest.cxx000066400000000000000000000100671301006202600276110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageMetadataInterfaceFactory.h" int otbImageMetadataInterfaceBaseTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer reader = ImageReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); otb::ImageMetadataInterfaceBase::Pointer lImageMetadata = otb::ImageMetadataInterfaceFactory::CreateIMI( reader->GetOutput()->GetMetaDataDictionary()); std::ofstream file; file.open(outputFilename); std::vector defaultDisplay = lImageMetadata->GetDefaultDisplay(); file << "Default RGB Display: [" << defaultDisplay[0] << ", " << defaultDisplay[1] << ", " << defaultDisplay[2] << "]" << std::endl; file << "ProjectionRef: " << lImageMetadata->GetProjectionRef() << std::endl; file << "GCPProjection: " << lImageMetadata->GetGCPProjection( ) << std::endl; file << "GCPCount: " << lImageMetadata->GetGCPCount( ) << std::endl; for(unsigned int gcpIdx = 0; gcpIdx < lImageMetadata->GetGCPCount(); ++ gcpIdx) { file << "GCPId: " << lImageMetadata->GetGCPId(gcpIdx) << std::endl; file << "GCPInfo: " << lImageMetadata->GetGCPInfo(gcpIdx) << std::endl; } std::string sensorId; lImageMetadata->GetSensorID( sensorId ); file << "SensorID: " << sensorId << std::endl; file << "NumberOfBands: " << lImageMetadata->GetNumberOfBands( ) << std::endl; file << "XPixelSpacing: " << lImageMetadata->GetXPixelSpacing( ) << std::endl; file << "YPixelSpacing: " << lImageMetadata->GetYPixelSpacing( ) << std::endl; file << "Day: " << lImageMetadata->GetDay( ) << std::endl; file << "Month: " << lImageMetadata->GetMonth( ) << std::endl; file << "Year: " << lImageMetadata->GetYear( ) << std::endl; file << "Hour: " << lImageMetadata->GetHour( ) << std::endl; file << "Minute: " << lImageMetadata->GetMinute( ) << std::endl; file << "ProductionDay: " << lImageMetadata->GetProductionDay( ) << std::endl; file << "ProductionMonth: " << lImageMetadata->GetProductionMonth( ) << std::endl; file << "ProductionYear: " << lImageMetadata->GetProductionYear( ) << std::endl; std::vector bandNameList = lImageMetadata->GetBandName(); if (bandNameList.size() == 1) { file << "BandName: " << bandNameList[0] << std::endl; } else if (bandNameList.size() > 1) { file << "BandNameList: "; for (std::vector::iterator it = bandNameList.begin(); it != bandNameList.end(); ++it) file << *it << ", "; file << std::endl; } std::vector bandNameList2 = lImageMetadata->GetEnhancedBandNames(); if (bandNameList2.size() == 1) { file << "ENH BandName: " << bandNameList2[0] << std::endl; } else if (bandNameList2.size() > 1) { file << "ENH BandNameList: "; for (std::vector::iterator it = bandNameList2.begin(); it != bandNameList2.end(); ++it) file << *it << ", "; file << std::endl; } file.close(); std::cout << lImageMetadata << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbImageMetadataInterfaceTest2.cxx000066400000000000000000000030701301006202600270740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageMetadataInterfaceFactory.h" int otbImageMetadataInterfaceTest2(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef otb::Image InputImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer reader = ImageReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); otb::ImageMetadataInterfaceBase::Pointer lImageMetadata = otb::ImageMetadataInterfaceFactory::CreateIMI( reader->GetOutput()->GetMetaDataDictionary()); std::ofstream file; file.open(outputFilename); //Test the image interface lImageMetadata->SetImage(reader->GetOutput()); file << lImageMetadata->GetProjectionRef() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbMetadataTestDriver.cxx000066400000000000000000000025251301006202600254060ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbOpticalDefaultImageMetadataInterfaceNew); REGISTER_TEST(otbSarImageMetadataInterfaceTest); REGISTER_TEST(otbDefaultImageMetadataInterfaceFactoryNew); REGISTER_TEST(otbOpticalDefaultImageMetadataInterfaceFactoryNew); REGISTER_TEST(otbPleiadesImageMetadataInterfaceNew); REGISTER_TEST(otbImageMetadataInterfaceBaseTest); REGISTER_TEST(otbSarDefaultImageMetadataInterface); REGISTER_TEST(otbSarDefaultImageMetadataInterfaceNew); REGISTER_TEST(otbOpticalImageMetadataInterfaceTest); REGISTER_TEST(otbSarDefaultImageMetadataInterfaceFactoryNew); REGISTER_TEST(otbFormosatImageMetadataInterfaceNew); REGISTER_TEST(otbOpticalDefaultImageMetadataInterface); REGISTER_TEST(otbSpot6ImageMetadataInterfaceNew); REGISTER_TEST(otbSpotImageMetadataInterfaceNew); REGISTER_TEST(otbQuickBirdImageMetadataInterfaceNew); REGISTER_TEST(otbIkonosImageMetadataInterfaceNew); REGISTER_TEST(otbTerraSarImageMetadataInterfaceNew); REGISTER_TEST(otbSentinel1ImageMetadataInterfaceNew); REGISTER_TEST(otbWorldView2ImageMetadataInterfaceNew); REGISTER_TEST(otbDefaultImageMetadataInterface); REGISTER_TEST(otbImageMetadataInterfaceTest2); REGISTER_TEST(otbNoDataHelperTest); REGISTER_TEST(otbSarCalibrationLookupDataTest); REGISTER_TEST(otbRadarsat2ImageMetadataInterfaceNew); } OTB-release-5.8/Modules/Core/Metadata/test/otbNoDataHelperTest.cxx000066400000000000000000000033361301006202600250210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbNoDataHelper.h" #include "itkMetaDataDictionary.h" #include "otbMacro.h" int otbNoDataHelperTest(int itkNotUsed(argc),char * itkNotUsed(argv) []) { std::vector b1(1,true); std::vector v1(1,0); itk::MetaDataDictionary dict; otb::WriteNoDataFlags(b1,v1,dict); otb::ReadNoDataFlags(dict,b1,v1); otbControlConditionTestMacro(otb::IsNoData(10,b1,v1)," wrong output of IsNoData function"); otbControlConditionTestMacro(!otb::IsNoData(0,b1,v1)," wrong output of IsNoData function"); b1[0]=false; otbControlConditionTestMacro(otb::IsNoData(10,b1,v1)," wrong output of IsNoData function"); otbControlConditionTestMacro(otb::IsNoData(0,b1,v1)," wrong output of IsNoData function"); std::vector b2(4,true); std::vector v2(4,1); itk::VariableLengthVector v(4); v.Fill(10); otbControlConditionTestMacro(otb::IsNoData(v,b2,v2)," wrong output of IsNoData function"); v[1]=1; otbControlConditionTestMacro(!otb::IsNoData(v,b2,v2)," wrong output of IsNoData function"); b2[1]=false; otbControlConditionTestMacro(otb::IsNoData(v,b2,v2)," wrong output of IsNoData function"); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbOpticalDefaultImageMetadataInterface.cxx000066400000000000000000000074051301006202600310010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbOpticalDefaultImageMetadataInterface.h" int otbOpticalDefaultImageMetadataInterface(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::OpticalDefaultImageMetadataInterface ObjectType; ObjectType::Pointer obj = ObjectType::New(); try { std::cout << obj->GetSunElevation() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSunElevation() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetSunAzimuth() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSunAzimuth() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetSatElevation() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSatElevation() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetSatAzimuth() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSatAzimuth() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetPhysicalBias() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetPhysicalBias() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetPhysicalGain() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetPhysicalGain() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetSolarIrradiance() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSolarIrradiance() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetFirstWavelengths() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetFirstWavelengths() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetLastWavelengths() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetLastWavelengths() !" << std::endl; std::cout << err << std::endl; } try { if(obj->CanRead() != false) { itkGenericExceptionMacro( << "CanRead() must be false "); } std::vector displayValue = obj->GetDefaultDisplay(); if(displayValue[0] != 0 || displayValue[1] != 1 || displayValue[2] != 2) { itkGenericExceptionMacro( << "GetDefaultDisplay() wrong value "); } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } try { std::cout << obj->GetSpectralSensitivity() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetSpectralSensitivity() !" << std::endl; std::cout << err << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbOpticalDefaultImageMetadataInterfaceFactoryNew.cxx000066400000000000000000000016471301006202600330050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbOpticalDefaultImageMetadataInterfaceFactory.h" int otbOpticalDefaultImageMetadataInterfaceFactoryNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::OpticalDefaultImageMetadataInterfaceFactory ObjectType; ObjectType::Pointer object = ObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbOpticalDefaultImageMetadataInterfaceNew.cxx000066400000000000000000000016221301006202600314460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbOpticalDefaultImageMetadataInterface.h" int otbOpticalDefaultImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::OpticalDefaultImageMetadataInterface ObjectType; ObjectType::Pointer object = ObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbOpticalImageMetadataInterfaceTest.cxx000066400000000000000000000045331301006202600303330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbOpticalImageMetadataInterfaceFactory.h" int otbOpticalImageMetadataInterfaceTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer reader = ImageReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); otb::OpticalImageMetadataInterface::Pointer lImageMetadata = otb::OpticalImageMetadataInterfaceFactory::CreateIMI( reader->GetOutput()->GetMetaDataDictionary()); std::ofstream file; file.open(outputFilename); file << "GetSunElevation: " << lImageMetadata->GetSunElevation() << std::endl; file << "GetSunAzimuth: " << lImageMetadata->GetSunAzimuth() << std::endl; file << "GetSatElevation: " << lImageMetadata->GetSatElevation() << std::endl; file << "GetSatAzimuth: " << lImageMetadata->GetSatAzimuth() << std::endl; file << "GetPhysicalBias: " << lImageMetadata->GetPhysicalBias() << std::endl; file << "GetPhysicalGain: " << lImageMetadata->GetPhysicalGain() << std::endl; file << "GetSolarIrradiance: " << lImageMetadata->GetSolarIrradiance() << std::endl; file << "GetFirstWavelengths: " << lImageMetadata->GetFirstWavelengths() << std::endl; file << "GetLastWavelengths: " << lImageMetadata->GetLastWavelengths() << std::endl; file << "GetSpectralSensitivity: " << lImageMetadata->GetSpectralSensitivity() << std::endl; file.close(); std::cout << lImageMetadata << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbPleiadesImageMetadataInterfaceNew.cxx000066400000000000000000000016141301006202600302750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbPleiadesImageMetadataInterface.h" int otbPleiadesImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::PleiadesImageMetadataInterface::Pointer object = otb::PleiadesImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbQuickBirdImageMetadataInterfaceNew.cxx000066400000000000000000000016201301006202600304210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbQuickBirdImageMetadataInterface.h" int otbQuickBirdImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::QuickBirdImageMetadataInterface::Pointer object = otb::QuickBirdImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbRadarsat2ImageMetadataInterfaceNew.cxx000066400000000000000000000016271301006202600303760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbRadarsat2ImageMetadataInterface.h" int otbRadarsat2ImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::Radarsat2ImageMetadataInterface::Pointer object = otb::Radarsat2ImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSarCalibrationLookupDataTest.cxx000066400000000000000000000045421301006202600273740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbSarImageMetadataInterfaceFactory.h" int otbSarCalibrationLookupDataTest(int argc, char* argv[]) { typedef double RealType; typedef otb::SarImageMetadataInterface ImageMetadataInterfaceType; typedef otb::SarCalibrationLookupData LookupDataType; typedef otb::Image InputImageType; typedef otb::ImageFileReader ImageReaderType; if (argc < 3 ) { std::cerr << "Usage: otbSarCalibationLookupDataTest /path/to/input/file /path/to/output/file !"<< std::endl; return EXIT_FAILURE; } ImageReaderType::Pointer reader = ImageReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); const char * outFileName = argv[2]; std::ofstream outfile; outfile.open(outFileName); ImageMetadataInterfaceType::Pointer imageMetadataInterface = otb::SarImageMetadataInterfaceFactory::CreateIMI( reader->GetOutput()->GetMetaDataDictionary() ); if (!imageMetadataInterface.IsNotNull()) { std::cerr << "cannot create a otb::SarImageMetadataInterface for input image." << std::endl; return EXIT_FAILURE; } const std::string sensorId = imageMetadataInterface->GetSensorID(); outfile << sensorId << std::endl; LookupDataType::Pointer lookupDataObj = imageMetadataInterface->GetCalibrationLookupData(0); if (!lookupDataObj.IsNotNull()) { std::cerr << "lookupDataObj is Null"<< std::endl; return EXIT_FAILURE; } RealType lutVal = static_cast(lookupDataObj->GetValue(10,19)); outfile << imageMetadataInterface->HasCalibrationLookupDataFlag() << std::endl; outfile << lutVal << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSarDefaultImageMetadataInterface.cxx000066400000000000000000000146441301006202600301360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSarDefaultImageMetadataInterface.h" int otbSarDefaultImageMetadataInterface(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::SarDefaultImageMetadataInterface ObjectType; ObjectType::Pointer obj = ObjectType::New(); try { std::cout << obj->GetRadiometricCalibrationScale() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationScale() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationAntennaPatternNewGain() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationAntennaPatternNewGain() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationAntennaPatternOldGain() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationAntennaPatternOldGain() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationIncidenceAngle() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationIncidenceAngle() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationRangeSpreadLoss() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationRangeSpreadLoss() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationNoise() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationNoise() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationIncidenceAnglePolynomialDegree() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationIncidenceAnglePolynomialDegree() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetRadiometricCalibrationNoisePolynomialDegree() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetRadiometricCalibrationNoisePolynomialDegree() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetDay() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetDay() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetMonth() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetMonth() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetYear() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetYear() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetHour() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetHour() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetMinute() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetMinute() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetProductionDay() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetProductionDay() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetProductionMonth() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetProductionMonth() !" << std::endl; std::cout << err << std::endl; } try { std::cout << obj->GetProductionYear() << std::endl; } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught for GetProductionYear() !" << std::endl; std::cout << err << std::endl; } try { if(obj->CanRead() != false) { itkGenericExceptionMacro( << "CanRead() must be false "); } std::vector displayValue = obj->GetDefaultDisplay(); if(displayValue[0] != 0 || displayValue[1] != 0 || displayValue[2] != 0) { itkGenericExceptionMacro( << "GetDefaultDisplay() wrong value "); } } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSarDefaultImageMetadataInterfaceFactoryNew.cxx000066400000000000000000000016331301006202600321320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSarDefaultImageMetadataInterfaceFactory.h" int otbSarDefaultImageMetadataInterfaceFactoryNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::SarDefaultImageMetadataInterfaceFactory ObjectType; ObjectType::Pointer object = ObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSarDefaultImageMetadataInterfaceNew.cxx000066400000000000000000000016061301006202600306020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSarDefaultImageMetadataInterface.h" int otbSarDefaultImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::SarDefaultImageMetadataInterface ObjectType; ObjectType::Pointer object = ObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSarImageMetadataInterfaceTest.cxx000066400000000000000000000067761301006202600275000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbSarImageMetadataInterfaceFactory.h" void printPointSet(otb::SarImageMetadataInterface::PointSetPointer pointSet, std::ostream& stream ) { stream << pointSet << std::endl; if (pointSet->GetNumberOfPoints() < 20) { stream << "PointSet values :" << std::endl; otb::SarImageMetadataInterface::PointSetType::PointType point; otb::SarImageMetadataInterface::PointSetType::PixelType pointValue; for (unsigned int i = 0; i < pointSet->GetNumberOfPoints(); ++i) { pointSet->GetPoint(i, &point); pointSet->GetPointData(i, &pointValue); stream << point << " : " << pointValue << std::endl; } } } int otbSarImageMetadataInterfaceTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer reader = ImageReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); otb::SarImageMetadataInterface::Pointer lImageMetadata = otb::SarImageMetadataInterfaceFactory::CreateIMI(reader->GetOutput()->GetMetaDataDictionary()); std::ofstream file; file.open(outputFilename); file << "GetRadiometricCalibrationScale : " << lImageMetadata->GetRadiometricCalibrationScale() << std::endl; file << "CalibrationNoise : " << std::endl; file << "Polynomial degree : " << lImageMetadata->GetRadiometricCalibrationNoisePolynomialDegree() << std::endl; printPointSet(lImageMetadata->GetRadiometricCalibrationNoise(), file); file << "CalibrationAntennaPatternNewGain : " << std::endl; file << "Polynomial degree : " << lImageMetadata->GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree() << std::endl; printPointSet(lImageMetadata->GetRadiometricCalibrationAntennaPatternNewGain(), file); file << "CalibrationAntennaPatternOldGain : " << std::endl; file << "Polynomial degree : " << lImageMetadata->GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree() << std::endl; printPointSet(lImageMetadata->GetRadiometricCalibrationAntennaPatternOldGain(), file); file << "CalibrationIncidenceAngle : " << std::endl; file << "Polynomial degree : " << lImageMetadata->GetRadiometricCalibrationIncidenceAnglePolynomialDegree() << std::endl; printPointSet(lImageMetadata->GetRadiometricCalibrationIncidenceAngle(), file); file << "CalibrationRangeSpreadLoss : " << std::endl; file << "Polynomial degree : " << lImageMetadata->GetRadiometricCalibrationRangeSpreadLossPolynomialDegree() << std::endl; printPointSet(lImageMetadata->GetRadiometricCalibrationRangeSpreadLoss(), file); file.close(); std::cout << lImageMetadata << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSentinel1ImageMetadataInterfaceNew.cxx000066400000000000000000000016271301006202600304150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbSentinel1ImageMetadataInterface.h" int otbSentinel1ImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::Sentinel1ImageMetadataInterface::Pointer object = otb::Sentinel1ImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSpot6ImageMetadataInterfaceNew.cxx000066400000000000000000000016001301006202600275550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbSpot6ImageMetadataInterface.h" int otbSpot6ImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::Spot6ImageMetadataInterface::Pointer object = otb::Spot6ImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbSpotImageMetadataInterfaceNew.cxx000066400000000000000000000015741301006202600275010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbSpotImageMetadataInterface.h" int otbSpotImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::SpotImageMetadataInterface::Pointer object = otb::SpotImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbTerraSarImageMetadataInterfaceNew.cxx000066400000000000000000000017431301006202600302750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbTerraSarImageMetadataInterface.h" int otbTerraSarImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::TerraSarImageMetadataInterface::Pointer object = otb::TerraSarImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Metadata/test/otbWorldView2ImageMetadataInterfaceNew.cxx000066400000000000000000000016241301006202600305540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbWorldView2ImageMetadataInterface.h" int otbWorldView2ImageMetadataInterfaceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::WorldView2ImageMetadataInterface::Pointer object = otb::WorldView2ImageMetadataInterface::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/000077500000000000000000000000001301006202600177605ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ObjectList/CMakeLists.txt000066400000000000000000000000511301006202600225140ustar00rootroot00000000000000project(OTBObjectList) otb_module_impl() OTB-release-5.8/Modules/Core/ObjectList/include/000077500000000000000000000000001301006202600214035ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ObjectList/include/otbImageList.h000066400000000000000000000047561301006202600241530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageList_h #define otbImageList_h #include "otbObjectList.h" namespace otb { /** \class ImageList * \brief This class represent a list of images. * * It is derived from the otbObjectList class, which allows manipulating an ITK/OTB * object list with the appropriate formalism (iterators, accessors). * \sa ObjectList * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageList : public ObjectList { public: /** Standard typedefs */ typedef ImageList Self; typedef ObjectList Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(ImageList, ObjectList); /** Creation through object factory macro */ itkNewMacro(Self); /** Template parameter typedefs */ typedef TImage ImageType; typedef typename Superclass::ObjectPointerType ImagePointerType; typedef typename Superclass::Iterator Iterator; typedef typename Superclass::ConstIterator ConstIterator; typedef typename Superclass::ReverseIterator ReverseIterator; typedef typename Superclass::ReverseConstIterator ReverseConstIterator; /** * Update images in the list. */ void UpdateOutputInformation(void) ITK_OVERRIDE; void PropagateRequestedRegion(void) throw (itk::InvalidRequestedRegionError) ITK_OVERRIDE; void UpdateOutputData(void) ITK_OVERRIDE; protected: /** Constructor */ ImageList() {}; /** Destructor */ ~ImageList() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: ImageList(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageList.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageList.txx000066400000000000000000000045201301006202600245340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageList_txx #define otbImageList_txx #include "otbImageList.h" #include "otbMacro.h" namespace otb { template void ImageList ::UpdateOutputData() { Superclass::UpdateOutputData(); for (ConstIterator it = this->Begin(); it != this->End(); ++it) { if (it.Get()->GetUpdateMTime() < it.Get()->GetPipelineMTime() || it.Get()->GetDataReleased() || it.Get()->RequestedRegionIsOutsideOfTheBufferedRegion()) { if (it.Get()->GetSource()) { it.Get()->GetSource()->PropagateRequestedRegion(it.Get()); // Check that the requested region lies within the largest possible region if (!it.Get()->VerifyRequestedRegion()) { // invalid requested region, throw an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDataObject(it.Get()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); throw e; } it.Get()->GetSource()->UpdateOutputData(it.Get()); } } } } template void ImageList ::PropagateRequestedRegion() throw (itk::InvalidRequestedRegionError) { Superclass::PropagateRequestedRegion(); } template void ImageList ::UpdateOutputInformation() { // otbMsgDebugMacro(<<"ImageList: Call to UpdateOutputInformation()"); Superclass::UpdateOutputInformation(); if (this->GetSource()) { this->GetSource()->UpdateOutputInformation(); } for (ConstIterator it = this->Begin(); it != this->End(); ++it) { if (it.Get()->GetSource()) { it.Get()->GetSource()->UpdateOutputInformation(); } } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListSource.h000066400000000000000000000045651301006202600253320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListSource_h #define otbImageListSource_h #include "itkProcessObject.h" #include "otbImageList.h" namespace otb { /** \class ImageListSource * * \brief Base class for all the filters producing an otbImageList * * \ingroup DataSources * \ingroup Images * \ingroup Lists * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageListSource : public itk::ProcessObject { public: /** Standard typedefs */ typedef ImageListSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageListSource, itk::ProcessObject); /** Data object pointer type */ typedef itk::DataObject::Pointer DataObjectPointer; /** Template parameter typedef*/ typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef ImageList OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::ConstPointer OutputImageListConstPointerType; /** Overriding of the GetOutput() method */ virtual OutputImageListType * GetOutput(void); protected: /** Constructor */ ImageListSource(); /** Destructor */ ~ImageListSource() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageListSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageListSource.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListSource.txx000066400000000000000000000027471301006202600257260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListSource_txx #define otbImageListSource_txx #include "otbImageListSource.h" namespace otb { /** * Constructor */ template ImageListSource ::ImageListSource() { this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, ImageList::New().GetPointer()); } /** * Get the output image list * \return The image list produced. */ template typename ImageListSource::OutputImageListType * ImageListSource ::GetOutput(void) { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } /** * PrintSelf Method */ template void ImageListSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToImageFilter.h000066400000000000000000000056561301006202600265670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToImageFilter_h #define otbImageListToImageFilter_h #include "itkImageSource.h" #include "otbImageList.h" namespace otb { /** \class ImageListToImageFilter * * \brief Base class for all the filters taking an images list as input to * produce an image. * * \ingroup Images * \ingroup Lists * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageListToImageFilter : public itk::ImageSource { public: /** Standard typedefs */ typedef ImageListToImageFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageListToImageFilter, ImageSource); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef ImageList InputImageListType; typedef typename InputImageListType::ConstPointer InputImageListConstPointerType; /** Derived typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; /** InputImage dimension constant */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Overriding the SetInput() and GetInput() methods */ using Superclass::SetInput; virtual void SetInput(const InputImageListType * image); InputImageListType * GetInput(void); protected: /** Constructor */ ImageListToImageFilter(); /** Destructor */ ~ImageListToImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageListToImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageListToImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToImageFilter.txx000066400000000000000000000036651301006202600271610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToImageFilter_txx #define otbImageListToImageFilter_txx #include "otbImageListToImageFilter.h" namespace otb { /** * Constructor */ template ImageListToImageFilter ::ImageListToImageFilter() { this->SetNumberOfRequiredInputs(1); } /** * Input Connection * \param image The input image. */ template void ImageListToImageFilter ::SetInput(const InputImageListType *image) { // A single input image this->itk::ProcessObject::SetNthInput(0, const_cast(image)); } /** * Input image retrieval * \return The input image. */ template typename ImageListToImageFilter::InputImageListType * ImageListToImageFilter ::GetInput(void) { // If there is no input if (this->GetNumberOfInputs() < 1) { // exit return ITK_NULLPTR; } // else return the first input return static_cast (this->itk::ProcessObject::GetInput(0)); } /** * PrintSelf Method */ template void ImageListToImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToImageListApplyFilter.h000066400000000000000000000074621301006202600304260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToImageListApplyFilter_h #define otbImageListToImageListApplyFilter_h #include "otbImageListToImageListFilter.h" namespace otb { /** \class ImageListToImageListApplyFilter * \brief This filter applies the filter given as template to the input image list. * * It produces one output image in the output list for one input image in the output list. * * It uses the given filter methods to generate output information and input requested region. * * The filter can be set up via the GetFilter() accessor. * * It also support streaming when the templated filter support it. * * No type checking is done : it is up to the user to check the adequation between the input images, * output images and filter IO types. * * \ingroup Streamed * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageListToImageListApplyFilter : public ImageListToImageListFilter { public: /** Standard typedefs */ typedef ImageListToImageListApplyFilter Self; typedef ImageListToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageListToImageListApplyFilter, ImageListToImageListFilter); /** Template parameters typedefs */ typedef TInputImageList InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::ImageType InputImageType; typedef TOutputImageList OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::ImageType OutputImageType; typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; /** Accessors */ itkSetObjectMacro(Filter, FilterType); itkGetObjectMacro(Filter, FilterType); itkGetMacro(OutputIndex, unsigned int); itkSetMacro(OutputIndex, unsigned int); /** Generate output information for the ImageList and for each image in the list. */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Generate input requested region for each image in the list. */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; protected: /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** Constructor */ ImageListToImageListApplyFilter(); /** Destructor */ ~ImageListToImageListApplyFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageListToImageListApplyFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The processing filter */ FilterPointerType m_Filter; /** The index of the output of the filter to use */ unsigned int m_OutputIndex; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageListToImageListApplyFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToImageListApplyFilter.txx000066400000000000000000000114451301006202600310160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToImageListApplyFilter_txx #define otbImageListToImageListApplyFilter_txx #include "otbImageListToImageListApplyFilter.h" namespace otb { /** * Constructor */ template ImageListToImageListApplyFilter ::ImageListToImageListApplyFilter() { m_Filter = FilterType::New(); m_OutputIndex = 0; } /** Generate output information for the ImageList and for each image in the List. */ template void ImageListToImageListApplyFilter ::GenerateOutputInformation() { // Retrieving input/output pointers InputImageListPointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); if (outputPtr) { if (outputPtr->Size() != inputPtr->Size()) { // in this case, clear the list outputPtr->Clear(); typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); while (inputListIt != inputPtr->End()) { outputPtr->PushBack(OutputImageType::New()); ++inputListIt; } } // For each input image typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); while (inputListIt != inputPtr->End() && outputListIt != outputPtr->End()) { // Create the output image and set its information m_Filter->SetInput(inputListIt.Get()); m_Filter->UpdateOutputInformation(); outputListIt.Get()->CopyInformation(m_Filter->GetOutput(m_OutputIndex)); outputListIt.Get()->SetLargestPossibleRegion(m_Filter->GetOutput(m_OutputIndex)->GetLargestPossibleRegion()); ++inputListIt; ++outputListIt; } } } /** Generate input requested region for each image in the List. */ template void ImageListToImageListApplyFilter ::GenerateInputRequestedRegion() { // Retrieving input/output pointers InputImageListPointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); // For each input image and corresponding output image typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); // Use the filter to generate input requested region while (inputListIt != inputPtr->End() && outputListIt != outputPtr->End()) { m_Filter->SetInput(inputListIt.Get()); m_Filter->GetOutput(m_OutputIndex)->SetRequestedRegion(outputListIt.Get()->GetRequestedRegion()); m_Filter->PropagateRequestedRegion(outputListIt.Get()); ++inputListIt; ++outputListIt; } } /** Main computation method */ template void ImageListToImageListApplyFilter ::GenerateData() { // Retrieving input/output pointers InputImageListPointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); // For each input image and corresponding output image typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); unsigned int counter = 0; while (inputListIt != inputPtr->End() && outputListIt != outputPtr->End()) { m_Filter->SetInput(inputListIt.Get()); m_Filter->GetOutput(m_OutputIndex)->SetRequestedRegion(outputListIt.Get()->GetRequestedRegion()); m_Filter->Update(); outputPtr->SetNthElement(counter, static_cast(m_Filter->GetOutput(m_OutputIndex))); outputListIt.Get()->DisconnectPipeline(); ++inputListIt; ++outputListIt; ++counter; } } /** * PrintSelf Method */ template void ImageListToImageListApplyFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToImageListFilter.h000066400000000000000000000063051301006202600274130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToImageListFilter_h #define otbImageListToImageListFilter_h #include "otbImageListSource.h" namespace otb { /** \class ImageListToImageListFilter * \brief Base class for all the filters taking an image list as input * to produce an image list. * \ingroup Images * \ingroup Lists * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageListToImageListFilter : public ImageListSource { public: /** Standard typedefs */ typedef ImageListToImageListFilter Self; typedef ImageListSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageListToImageListFilter, ImageListSource); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef ImageList InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::ConstPointer InputImageListConstPointer; /** Derived typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImageListPointerType OutputImageListPointerType; typedef typename Superclass::OutputImagePointerType OutputImagePointer; /** InputImage dimension constant */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Overriding the SetInput() and GetInput() methods */ using Superclass::SetInput; virtual void SetInput(const InputImageListType * imageList); virtual InputImageListType * GetInput(void); protected: /** Constructor */ ImageListToImageListFilter(); /** Destructor */ ~ImageListToImageListFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageListToImageListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageListToImageListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToImageListFilter.txx000066400000000000000000000037521301006202600300120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToImageListFilter_txx #define otbImageListToImageListFilter_txx #include "otbImageListToImageListFilter.h" namespace otb { /** * Constructor */ template ImageListToImageListFilter ::ImageListToImageListFilter() { this->SetNumberOfRequiredInputs(1); } /** * Input Connection * \param imageList The input image list. */ template void ImageListToImageListFilter ::SetInput(const InputImageListType *imageList) { // A single input image this->itk::ProcessObject::SetNthInput(0, const_cast(imageList)); } /** * Input image retrieval * \return The input image. */ template typename ImageListToImageListFilter::InputImageListType * ImageListToImageListFilter ::GetInput(void) { // If there is no input if (this->GetNumberOfInputs() < 1) { // exit return ITK_NULLPTR; } // else return the first input return static_cast (this->itk::ProcessObject::GetInput(0)); } /** * PrintSelf Method */ template void ImageListToImageListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToSingleImageFilter.h000066400000000000000000000057351301006202600277270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToSingleImageFilter_h #define otbImageListToSingleImageFilter_h #include "otbImageListToImageFilter.h" namespace otb { /** \class ImageListToSingleImageFilter * \brief This class aims at converting a image list to one (scalar or vector) image. * * This class takes a image list image represented as an otb::ImageList and produces a * output which contains of scalar/vector images corresponding to the element selected. * This filter avoid to break the pipeline after the use of an filter which derive * from ImageToImagelistFilter class. * * * \ingroup Streamed * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageListToSingleImageFilter : public ImageListToImageFilter { public: /** Standard typedefs */ typedef ImageListToSingleImageFilter Self; typedef ImageListToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImageType InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef ImageList InputImageListType; typedef TInputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageListToSingleImageFilter, ImageListToImageFilter); /** Set/Get the position of the extracted image from the image list */ itkGetMacro(ExtractedImagePosition, unsigned int); itkSetMacro(ExtractedImagePosition, unsigned int); InputImagePointerType GetOutput(void); protected: /** Constructor */ ImageListToSingleImageFilter(); /** Destructor */ ~ImageListToSingleImageFilter() ITK_OVERRIDE {} /** Main computation method */ void GenerateData() ITK_OVERRIDE; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageListToSingleImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_ExtractedImagePosition; }; // end of class } // end of namespace #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageListToSingleImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToSingleImageFilter.txx000066400000000000000000000054351301006202600303200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToSingleImageFilter_txx #define otbImageListToSingleImageFilter_txx #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkProgressReporter.h" #include "otbImageListToSingleImageFilter.h" namespace otb { /** * Constructor */ template ImageListToSingleImageFilter ::ImageListToSingleImageFilter() :m_ExtractedImagePosition(0) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); } template typename ImageListToSingleImageFilter::OutputImagePointerType ImageListToSingleImageFilter ::GetOutput() { // If there is no input if (this->GetNumberOfInputs() != 1) { // exit return ITK_NULLPTR; } // else return the first input return static_cast( this->GetInput()->GetNthElement(m_ExtractedImagePosition)); } /** * Main computation method */ template void ImageListToSingleImageFilter ::GenerateData(void) { OutputImagePointerType outputPtr = this->GetOutput(); InputImagePointerType inputPtr = this->GetInput()->GetNthElement(m_ExtractedImagePosition); typedef itk::ImageRegionConstIteratorWithIndex InputIteratorType; typedef itk::ImageRegionIteratorWithIndex OutputIteratorType; outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); itk::ProgressReporter progress(this, 0, outputPtr->GetRequestedRegion().GetNumberOfPixels()); OutputIteratorType outputIt(outputPtr, outputPtr->GetRequestedRegion()); outputIt.GoToBegin(); InputIteratorType inputIt(inputPtr, outputPtr->GetRequestedRegion()); inputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { if ( !(outputIt).IsAtEnd()) { outputIt.Set(inputIt.Get()); ++outputIt; } else { itkGenericExceptionMacro("End of image at index " << outputIt.GetIndex() << " !"); } ++inputIt; } } /** * PrintSelf Method */ template void ImageListToSingleImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToVectorImageFilter.h000066400000000000000000000061011301006202600277340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToVectorImageFilter_h #define otbImageListToVectorImageFilter_h #include "otbImageListToImageFilter.h" namespace otb { /** \class ImageListToVectorImageFilter * \brief Converts an ImageList to a VectorImage. * * The output VectorImage has n band, where n is the number of images in the image list. * * This filter assumes that the images in the input ImageList have all the same size. * * Casting is done through standard cast operation. * * \ingroup Streamed * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageListToVectorImageFilter : public ImageListToImageFilter { public: /** Standard typedefs */ typedef ImageListToVectorImageFilter Self; typedef ImageListToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageListToVectorImageFilter, ImageToImageListFilter); /** Template parameters typedefs */ typedef TVectorImage OutputVectorImageType; typedef typename OutputVectorImageType::Pointer OutputVectorImagePointerType; typedef TImageList InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::ImageType InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; protected: /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** GenerateOutputInformation * Set the number of bands of the output. * Copy information from the first image of the list if existing. **/ void GenerateOutputInformation(void) ITK_OVERRIDE; /** * GenerateInputRequestedRegion * Set the requested region of each image in the list. */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Constructor */ ImageListToVectorImageFilter() {}; /** Destructor */ ~ImageListToVectorImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageListToVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageListToVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageListToVectorImageFilter.txx000066400000000000000000000102111301006202600303250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToVectorImageFilter_txx #define otbImageListToVectorImageFilter_txx #include "otbImageListToVectorImageFilter.h" #include "itkImageRegionIterator.h" #include #include "otbMacro.h" #include "itkProgressReporter.h" namespace otb { /** * GenerateOutputInformation */ template void ImageListToVectorImageFilter ::GenerateOutputInformation(void) { if (this->GetOutput()) { if (this->GetInput()->Size() > 0) { this->GetOutput()->CopyInformation(this->GetInput()->GetNthElement(0)); this->GetOutput()->SetNumberOfComponentsPerPixel(this->GetInput()->Size()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetNthElement(0)->GetLargestPossibleRegion()); } } } /** * GenerateInputRequestedRegion */ template void ImageListToVectorImageFilter ::GenerateInputRequestedRegion(void) { InputImageListPointerType inputPtr = this->GetInput(); typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); while (inputListIt != inputPtr->End()) { inputListIt.Get()->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); ++inputListIt; } } /** * Main computation method */ template void ImageListToVectorImageFilter ::GenerateData(void) { InputImageListPointerType inputPtr = this->GetInput(); OutputVectorImagePointerType outputPtr = this->GetOutput(); itk::ProgressReporter progress(this, 0, outputPtr->GetRequestedRegion().GetNumberOfPixels()); // Output image initializations typename OutputVectorImageType::PixelType black; black.SetSize(inputPtr->Size()); black.Fill(0); outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); outputPtr->FillBuffer(black); // defines input and output iterators typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); // defines a vector of input iterators typedef std::vector InputIteratorListType; InputIteratorListType inputIteratorList; // fills the vector of input iterators for (; inputListIt != inputPtr->End(); ++inputListIt) { inputIteratorList.push_back(InputIteratorType(inputListIt.Get(), outputPtr->GetRequestedRegion())); inputIteratorList.back().GoToBegin(); } // walk through the output image OutputIteratorType outputIt(outputPtr, outputPtr->GetRequestedRegion()); outputIt.GoToBegin(); while (!outputIt.IsAtEnd()) { typename OutputVectorImageType::PixelType pixel = outputIt.Get(); unsigned int counter = 0; // for each input iterator, fill the right component for (typename InputIteratorListType::iterator it = inputIteratorList.begin(); it != inputIteratorList.end(); ++it) { if (!it->IsAtEnd()) { pixel[counter] = static_cast(it->Get()); ++(*it); ++counter; } } outputIt.Set(pixel); progress.CompletedPixel(); ++outputIt; } } /** * PrintSelf Method */ template void ImageListToVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageToImageListFilter.h000066400000000000000000000054561301006202600265650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToImageListFilter_h #define otbImageToImageListFilter_h #include "otbImageListSource.h" namespace otb { /** \class ImageToImageListFilter * * \brief Base class for all the filters taking an image input to * produce an image list. * * \ingroup Images * \ingroup Lists * * \ingroup OTBObjectList */ template class ITK_EXPORT ImageToImageListFilter : public ImageListSource { public: /** Standard typedefs */ typedef ImageToImageListFilter Self; typedef ImageListSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageToImageListFilter, ImageListSource); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; /** Derived typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; /** InputImage dimension constant */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Overriding the SetInput() and GetInput() methods */ using Superclass::SetInput; virtual void SetInput(const InputImageType * image); InputImageType * GetInput(void); protected: /** Constructor */ ImageToImageListFilter(); /** Destructor */ ~ImageToImageListFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageToImageListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToImageListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbImageToImageListFilter.txx000066400000000000000000000036421301006202600271540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToImageListFilter_txx #define otbImageToImageListFilter_txx #include "otbImageToImageListFilter.h" namespace otb { /** * Constructor */ template ImageToImageListFilter ::ImageToImageListFilter() { this->SetNumberOfRequiredInputs(1); } /** * Input Connection * \param image The input image. */ template void ImageToImageListFilter ::SetInput(const InputImageType *image) { // A single input image this->itk::ProcessObject::SetNthInput(0, const_cast(image)); } /** * Input image retrieval * \return The input image. */ template typename ImageToImageListFilter::InputImageType * ImageToImageListFilter ::GetInput(void) { // If there is no input if (this->GetNumberOfInputs() < 1) { // exit return ITK_NULLPTR; } // else return the first input return static_cast (this->itk::ProcessObject::GetInput(0)); } /** * PrintSelf Method */ template void ImageToImageListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbObjectList.h000066400000000000000000000341101301006202600243220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectList_h #define otbObjectList_h #include #include "itkDataObject.h" #include "itkObjectFactory.h" namespace otb { /** \class ObjectList * \brief This class is a generic all-purpose wrapping around an std::vector >. * * ObjectList stores SmartPointer to ObjectType in a std::vector data structure. It provides the same * methods and iterators interfaces. * * \ingroup OTBObjectList */ template class ITK_EXPORT ObjectList : public itk::DataObject { public: /** Standard typedefs */ typedef ObjectList Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(ObjectList, DataObject); /** Creation through object factory macro */ itkNewMacro(Self); /** Template parameter typedefs */ typedef TObject ObjectType; typedef itk::SmartPointer ObjectPointerType; typedef std::vector InternalContainerType; typedef typename InternalContainerType::size_type InternalContainerSizeType; /** * Set the minimum capacity of the vector. * \param size Size of the vector to reserve. */ void Reserve(InternalContainerSizeType size); /** * Get the capacity of the vector. * \return The capacity of the vector. */ InternalContainerSizeType Capacity(void) const; /** * Get the number of elements in the vector. * \return The number of elements in the vector. */ InternalContainerSizeType Size(void) const; /** * Resize the maximal list capacity. * \param size The new maximal size of the list. */ void Resize(InternalContainerSizeType size); /** * Append an element to the list. * \param element Pointer to the element to append. */ void PushBack(ObjectType* element); /** * Delete the last element to the list. */ void PopBack(void); /** * Set the nth element of the list. * \param index The index where to put the element. * \param element Pointer to the element to set. */ void SetNthElement(unsigned int index, ObjectPointerType element); void SetNthElement(unsigned int index, const ObjectType * element); /** * Get the nth element of the list. * \param index The index of the object to get. * \return The pointer to the nth element of the list. */ ObjectPointerType GetNthElement(unsigned int index) const; /** * Return the first element of the list. * \return The first element of the list. */ ObjectPointerType Front(void); /** * Return the last element of the list. * \return The last element of the list. */ ObjectPointerType Back(void); /** * Erase the nth element of the list. * \param index The index of the element to erase. */ void Erase(unsigned int index); /** * Clear the object list. */ void Clear(void); class ConstIterator; class ReverseIterator; class ReverseConstIterator; class Iterator; friend class Iterator; friend class ConstIterator; friend class ReverseIterator; friend class ReverseConstIterator; /** * Insert an element at a given position * \param position A random access iterator * \return An iterator that points to the newly insereted element. */ Iterator Insert(Iterator position, ObjectPointerType element); /** * Insert an element at a given position * \param position A reverse iterator * \return A reverse iterator that points to the newly insereted element. */ ReverseIterator Insert(ReverseIterator position, ObjectPointerType element); /** \class Iterator * \brief Iterator of the object list. * * \ingroup OTBObjectList */ class ITK_EXPORT Iterator { public: friend class ObjectList; friend class ConstIterator; /** typedef of the internal iterator */ typedef typename InternalContainerType::iterator InternalIteratorType; /** Constructor */ Iterator() {}; /** Constructor with iternal iterator parameter */ Iterator(InternalIteratorType iter) { m_Iter = iter; }; /** * Get the current object. * \return The current object pointed by the iterator. */ ObjectPointerType Get(void) { return (*m_Iter); } /** * Set the current object */ void Set(ObjectPointerType element) { (*m_Iter) = element; this->Modified(); } /** * Increment. */ Iterator & operator ++() { ++m_Iter; return *this; } /** * Decrement. */ Iterator & operator --() { --m_Iter; return *this; } /** * Add */ Iterator operator +(int i) { Iterator lIter(m_Iter + i); return lIter; } /** * Remove */ Iterator operator -(int i) { Iterator lIter(m_Iter - i); return lIter; } /** * Difference comparison operator. */ bool operator !=(const Iterator& it) { return (m_Iter != it.m_Iter); } /** * Equality comparison operator. */ bool operator ==(const Iterator& it) { return (m_Iter == it.m_Iter); } /** * Instantiation operator. */ Iterator & operator =(const Iterator& it) { m_Iter = it.m_Iter; return *this; } /** * Copy operator. */ Iterator(const Iterator &it) { m_Iter = it.m_Iter; }; /** * Get the current internal iterator */ InternalIteratorType& GetIter(void) { return (m_Iter); } private: // Internal iterator. InternalIteratorType m_Iter; }; /** \class ConstIterator * \brief ConstIterator of the object list. * * \ingroup OTBObjectList */ class ITK_EXPORT ConstIterator { public: friend class ObjectList; friend class Iterator; /** typedef of the internal iterator */ typedef typename InternalContainerType::const_iterator InternalConstIteratorType; /** Constructor */ ConstIterator() {}; /** Constructor with iternal iterator parameter */ ConstIterator(InternalConstIteratorType iter) { m_Iter = iter; }; /** * Get the current object. * \return The current object pointed by the iterator. */ ObjectPointerType Get(void) { return (*m_Iter); } /** * Increment. */ ConstIterator & operator ++() { ++m_Iter; return *this; } /** * Decrement. */ ConstIterator & operator --() { --m_Iter; return *this; } /** * Difference comparison operator. */ bool operator !=(const ConstIterator& it) { return (m_Iter != it.m_Iter); } /** * Equality comparison operator. */ bool operator ==(const ConstIterator& it) { return (m_Iter == it.m_Iter); } /** * Instantiation operator. */ ConstIterator & operator =(const ConstIterator& it) { m_Iter = it.m_Iter; return *this; } /** * Instantiation operator. */ ConstIterator & operator =(const Iterator& it) { m_Iter = it.m_Iter; return *this; } /** * Copy operator. */ ConstIterator(const ConstIterator &it) { m_Iter = it.m_Iter; }; /** * Copy operator. */ ConstIterator(const Iterator &it) { m_Iter = it.m_Iter; }; private: // Internal iterator. InternalConstIteratorType m_Iter; }; /** \class ReverseIterator * \brief ReverseIterator of the object list. * * \ingroup OTBObjectList */ class ITK_EXPORT ReverseIterator { public: friend class ObjectList; friend class Iterator; friend class ReverseConstIterator; /** typedef of the internal iterator */ typedef typename InternalContainerType::reverse_iterator InternalReverseIteratorType; /** Constructor */ ReverseIterator() {}; /** Constructor with iternal iterator parameter */ ReverseIterator(InternalReverseIteratorType iter) { m_Iter = iter; }; /** * Get the current object. * \return The current object pointed by the iterator. */ ObjectPointerType Get(void) { return (*m_Iter); } /** * Set the current object */ void Set(ObjectPointerType element) { (*m_Iter) = element; } /** * Increment. */ ReverseIterator & operator ++() { ++m_Iter; return *this; } /** * Decrement. */ ReverseIterator & operator --() { --m_Iter; return *this; } /** * Difference comparison operator. */ bool operator !=(const ReverseIterator& it) { return (m_Iter != it.m_Iter); } /** * Equality comparison operator. */ bool operator ==(const ReverseIterator& it) { return (m_Iter == it.m_Iter); } /** * Instantiation operator. */ ReverseIterator & operator =(const ReverseIterator& it) { m_Iter = it.m_Iter; return *this; } /** * Copy operator. */ ReverseIterator(const ReverseIterator &it) { m_Iter = it.m_Iter; }; /** * Get the current internal iterator */ InternalReverseIteratorType& GetIter(void) { return (m_Iter); } private: // Internal iterator. InternalReverseIteratorType m_Iter; }; /** \class ReverseConstIterator * \brief ReverseConstIterator of the object list. * * \ingroup OTBObjectList */ class ITK_EXPORT ReverseConstIterator { public: friend class ObjectList; friend class Iterator; friend class ConstIterator; friend class ReverseIterator; /** typedef of the internal iterator */ typedef typename InternalContainerType::reverse_iterator InternalReverseConstIteratorType; /** Constructor */ ReverseConstIterator() {}; /** Constructor with iternal iterator parameter */ ReverseConstIterator(InternalReverseConstIteratorType iter) { m_Iter = iter; }; /** * Get the current object. * \return The current object pointed by the iterator. */ ObjectPointerType Get(void) { return (*m_Iter); } /** * Increment. */ ReverseConstIterator & operator ++() { ++m_Iter; return *this; } /** * Decrement. */ ReverseConstIterator & operator --() { --m_Iter; return *this; } /** * Difference comparison operator. */ bool operator !=(const ReverseConstIterator& it) { return (m_Iter != it.m_Iter); } /** * Equality comparison operator. */ bool operator ==(const ReverseConstIterator& it) { return (m_Iter == it.m_Iter); } /** * Instantiation operator. */ ReverseConstIterator & operator =(const ReverseConstIterator& it) { m_Iter = it.m_Iter; return *this; } /** * Instantiation operator. */ ReverseConstIterator & operator =(const ReverseIterator& it) { m_Iter = it.m_Iter; return *this; } /** * Copy operator. */ ReverseConstIterator(const ReverseConstIterator &it) { m_Iter = it.m_Iter; }; /** * Copy operator. */ ReverseConstIterator(const ReverseIterator &it) { m_Iter = it.m_Iter; }; private: // Internal iterator. InternalReverseConstIteratorType m_Iter; }; /** * Get an Iterator that points to the beginning of the container. * \return The iterator. */ Iterator Begin(void); /** * Get a ConstIterator that points to the beginning of the container. * \return The iterator. */ ConstIterator Begin(void) const; /** * Get a ReverseIterator that points to the reverse beginning of the container. * \return The iterator. */ ReverseIterator ReverseBegin(void); /** * Get a ReverseConstIterator that points to the reverse beginning of the container. * \return The iterator. */ ReverseConstIterator ReverseBegin(void) const; /** * Get an Iterator that points past-the-end of the container. * \return The iterator. */ Iterator End(void); /** * Get a ConstIterator that points past-the-end of the container. * \return The iterator. */ ConstIterator End(void) const; /** * Get a ReverseIterator that points to the reverse past-the-end of the container. * \return The iterator. */ ReverseIterator ReverseEnd(void); /** * Get a ReverseConstIterator that points to the reverse past-the-end of the container. * \return The iterator. */ ReverseConstIterator ReverseEnd(void) const; /** * Erase elements from begin to last. * \param begin Iterator pointing on first object to erase. * \param end Iterator pointing past the last object to erase. */ void Erase(Iterator begin, Iterator end); /** * Erase loc element. * \param loc Iterator pointing on object to erase. */ void Erase(Iterator loc); protected: /** Constructor */ ObjectList(); /** Destructor */ ~ObjectList() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ObjectList(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The internal std::vector object container */ InternalContainerType m_InternalContainer; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbObjectList.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbObjectList.txx000066400000000000000000000220011301006202600247120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectList_txx #define otbObjectList_txx #include "otbObjectList.h" #include "itkMacro.h" namespace otb { /** * Constructor */ template ObjectList ::ObjectList() {} /** * Set the minimum capacity of the vector. * \param size Size of the vector to reserve. */ template void ObjectList ::Reserve(InternalContainerSizeType size) { m_InternalContainer.reserve(size); } /** * Get the capacity of the vector. * \return The capacity of the vector. */ template typename ObjectList::InternalContainerSizeType ObjectList ::Capacity(void) const { return m_InternalContainer.capacity(); } /** * Get the number of elements in the vector. * \return The number of elements in the vector. */ template typename ObjectList::InternalContainerSizeType ObjectList ::Size(void) const { return m_InternalContainer.size(); } /** * Resize the maximal list capacity. * \param size The new maximal size of the list. */ template void ObjectList ::Resize(InternalContainerSizeType size) { m_InternalContainer.resize(size); } /** * Append an element to the list. * \param element Pointer to the element to append. */ template void ObjectList ::PushBack(ObjectType* element) { m_InternalContainer.push_back(element); this->Modified(); } /** * Delete the last element to the list. */ template void ObjectList ::PopBack(void) { if (m_InternalContainer.size() > 0) { m_InternalContainer.pop_back(); this->Modified(); } } /** * Set the nth element of the list. * \param index The index where to put the element. * \param element Pointer to the element to set. */ template void ObjectList ::SetNthElement(unsigned int index, ObjectPointerType element) { if (index >= m_InternalContainer.size()) { itkExceptionMacro( << "Impossible to SetNthElement with the index element " << index << "; this element don't exist, the size of the list is " << m_InternalContainer.size() << "."); } m_InternalContainer[index] = element; this->Modified(); } /** * Set the nth element of the list. * \param index The index where to put the element. * \param element Pointer to the element to set. */ template void ObjectList ::SetNthElement(unsigned int index, const ObjectType * element) { if (index >= m_InternalContainer.size()) { itkExceptionMacro( << "Impossible to SetNthElement with the index element " << index << "; this element don't exist, the size of the list is " << m_InternalContainer.size() << "."); } m_InternalContainer[index] = const_cast(element); this->Modified(); } /** * Get the nth element of the list. * \param index The index of the object to get. * \return The pointer to the nth element of the list. */ template typename ObjectList::ObjectPointerType ObjectList ::GetNthElement(unsigned int index) const { if (index >= m_InternalContainer.size()) { itkExceptionMacro( << "Impossible to GetNthElement with the index element " << index << "; this element don't exist, the size of the list is " << m_InternalContainer.size() << "."); } return m_InternalContainer[index]; } /** * Return the first element of the list. * \return The first element of the list. */ template typename ObjectList::ObjectPointerType ObjectList ::Front(void) { return m_InternalContainer.front(); } /** * Return the last element of the list. * \return The last element of the list. */ template typename ObjectList::ObjectPointerType ObjectList ::Back(void) { return m_InternalContainer.back(); } /** * Erase the nth element in the list. * \param index The index of the element to erase. */ template void ObjectList ::Erase(unsigned int index) { if (index >= m_InternalContainer.size()) { itkExceptionMacro( << "Impossible to erase the index element " << index << "; the size of the list is " << m_InternalContainer.size() << "."); } m_InternalContainer.erase(m_InternalContainer.begin() + index); this->Modified(); } /** * Clear the object list. */ template void ObjectList ::Clear(void) { m_InternalContainer.clear(); this->Modified(); } /** * Insert an element */ template typename ObjectList::Iterator ObjectList ::Insert(Iterator position, ObjectPointerType element) { Iterator iter(m_InternalContainer.insert(position.GetIter(), element)); this->Modified(); return iter; } /** * Insert an element */ template typename ObjectList::ReverseIterator ObjectList ::Insert(ReverseIterator position, ObjectPointerType element) { ReverseIterator iter(m_InternalContainer.insert(position.GetIter(), element)); this->Modified(); return iter; } /** * Get an Iterator that points to the beginning of the container. * \return The iterator. */ template typename ObjectList::Iterator ObjectList ::Begin(void) { Iterator iter(m_InternalContainer.begin()); return iter; } /** * Get a ConstIterator that points to the beginning of the container. * \return The iterator. */ template typename ObjectList::ConstIterator ObjectList ::Begin(void) const { ConstIterator iter(m_InternalContainer.begin()); return iter; } /** * Get a ReverseIterator that points to the reverse beginning of the container. * \return The iterator. */ template typename ObjectList::ReverseIterator ObjectList ::ReverseBegin(void) { ReverseIterator iter(m_InternalContainer.rbegin()); return iter; } /** * Get a ReverseConstIterator that points to the reverse beginning of the container. * \return The iterator. */ template typename ObjectList::ReverseConstIterator ObjectList ::ReverseBegin(void) const { ReverseConstIterator iter(m_InternalContainer.rbegin()); return iter; } /** * Get an Iterator that points past-the-end of the container. * \return The iterator. */ template typename ObjectList::Iterator ObjectList ::End(void) { Iterator iter(m_InternalContainer.end()); return iter; } /** * Get a ConstIterator that points past-the-end of the container. * \return The iterator. */ template typename ObjectList::ConstIterator ObjectList ::End(void) const { ConstIterator iter(m_InternalContainer.end()); return iter; } /** * Get a ReverseIterator that points to the reverse past-the-end of the container. * \return The iterator. */ template typename ObjectList::ReverseIterator ObjectList ::ReverseEnd(void) { ReverseIterator iter(m_InternalContainer.rend()); return iter; } /** * Get a ReverseConstIterator that points to the reverse past-the-end of the container. * \return The iterator. */ template typename ObjectList::ReverseConstIterator ObjectList ::ReverseEnd(void) const { ReverseConstIterator iter(m_InternalContainer.rend()); return iter; } /** * Erase elements from begin to last. * \param begin Iterator pointing on first object to erase. * \param end Iterator pointing past the last object to erase. */ template void ObjectList ::Erase(Iterator begin, Iterator end) { m_InternalContainer.erase(begin.GetIter(), end.GetIter()); this->Modified(); } /** * Erase loc element. * \param loc Iterator pointing on object to erase. */ template void ObjectList ::Erase(Iterator loc) { m_InternalContainer.erase(loc.GetIter()); this->Modified(); } /**PrintSelf method */ template void ObjectList ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Size: " << m_InternalContainer.size() << std::endl; os << indent << "List contains : " << std::endl; ConstIterator iter = this->Begin(); while (iter != this->End()) { os << indent.GetNextIndent() << iter.Get().GetPointer() << std::endl; os << indent.GetNextIndent() << iter.Get() << std::endl; // iter.Get()->PrintSelf(os, indent.GetNextIndent()); // iter.Get()->Print(os, indent.GetNextIndent()); ++iter; } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbObjectListSource.h000066400000000000000000000176721301006202600255210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectListSource_h #define otbObjectListSource_h #include "itkProcessObject.h" #include "otbObjectList.h" namespace otb { /** \class ObjectListSource * \brief Base class for all process objects that output ObjectList data. * * * ObjectListSource is the base class for all process objects that output ObjectList data. * Specifically, this class defines the GetOutput() method that returns a pointer to the * output ObjectList. * * Be aware that this class is templated over the list type, not the object type. It will * be typically something like otb::ObjectList. This is to enable the use of * class derived from ObjectList or other implementations. * * \ingroup ObjectListFilter * * \ingroup OTBObjectList */ template class ITK_EXPORT ObjectListSource : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef ObjectListSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ObjectListSource, ProcessObject); /** Some typedefs. */ typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef TOutputList OutputListType; typedef typename TOutputList::Pointer OutputListPointer; typedef itk::DataObject::Pointer DataObjectPointer; /** Make a DataObject of the correct type to used as the specified * output. Every ProcessObject subclass must be able to create a * DataObject that can be used as a specified output. This method * is automatically called when DataObject::DisconnectPipeline() is * called. DataObject::DisconnectPipeline, disconnects a data object * from being an output of its current source. When the data object * is disconnected, the ProcessObject needs to construct a replacement * output data object so that the ProcessObject is in a valid state. * So DataObject::DisconnectPipeline eventually calls * ProcessObject::MakeOutput. Note that MakeOutput always returns a * SmartPointer to a DataObject. If a subclass of ImageSource has * multiple outputs of different types, then that class must provide * an implementation of MakeOutput(). */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Graft the specified DataObject onto this ProcessObject's output. * This method grabs a handle to the specified DataObject's path * data to use as its output's own path data. It also copies the * region ivars (RequestedRegion, BufferedRegion, * LargestPossibleRegion) and meta-data (Spacing, Origin) from the * specified data object into this filter's output data object. Most * importantly, however, it leaves the Source ivar untouched so the * original pipeline routing is intact. This method is used when a * process object is implemented using a mini-pipeline which is * defined in its GenerateData() method. The usage is: * * \code * // setup the mini-pipeline to process the input to this filter * firstFilterInMiniPipeline->SetInput( this->GetInput() ); * * // setup the mini-pipeline to calculate the correct regions * // and write to the appropriate bulk data block * lastFilterInMiniPipeline->GraftOutput( this->GetOutput() ); * * // execute the mini-pipeline * lastFilterInMiniPipeline->Update(); * * // graft the mini-pipeline output back onto this filter's output. * // this is needed to get the appropriate regions passed back. * this->GraftOutput( lastFilterInMiniPipeline->GetOutput() ); * \endcode * * For proper pipeline execution, a filter using a mini-pipeline * must implement the GeneratseInputRequestedRegion(), * GenerateOutputRequestedRegion(), GenerateOutputInformation() and * EnlargeOutputRequestedRegion() methods as necessary to reflect * how the mini-pipeline will execute (in other words, the outer * filter's pipeline mechanism must be consistent with what the * mini-pipeline will do). */ void GraftOutput(itk::DataObject *graft); /** Graft the specified data object onto this ProcessObject's idx'th * output. This is the similar to GraftOutput method except is * allows you specify which output is affected. The specified index * must be a valid output number (less than * ProcessObject::GetNumberOfOutputs()). See the GraftOutput for * general usage information. */ void GraftNthOutput(DataObjectPointerArraySizeType idx, itk::DataObject *graft); /** Get the output data of this process object. The output of this * function is not valid until an appropriate Update() method has * been called, either explicitly or implicitly. Both the filter * itself and the data object have Update() methods, and both * methods update the data. Here are three ways to use * GetOutput() and make sure the data is valid. In these * examples, \a image is a pointer to some Image object, and the * particular ProcessObjects involved are filters. The same * examples apply to non-image (e.g. Mesh) data as well. * * \code * anotherFilter->SetInput( someFilter->GetOutput() ); * anotherFilter->Update(); * \endcode * * In this situation, \a someFilter and \a anotherFilter are said * to constitute a \b pipeline. * * \code * image = someFilter->GetOutput(); * image->Update(); * \endcode * * \code * someFilter->Update(); * image = someFilter->GetOutput(); * \endcode * (In the above example, the two lines of code can be in * either order.) * * Note that Update() is not called automatically except within a * pipeline as in the first example. When \b streaming (using a * StreamingImageFilter) is activated, it may be more efficient to * use a pipeline than to call Update() once for each filter in * turn. * * For an image, the data generated is for the requested * Region, which can be set using ImageBase::SetRequestedRegion(). * By default, the largest possible region is requested. */ OutputListType * GetOutput(void); OutputListType * GetOutput(DataObjectPointerArraySizeType idx); protected: /** Constructor */ ObjectListSource(); /** Destructor */ ~ObjectListSource() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Ensure that the output lists are cleared before processing */ virtual void AllocateOutputs(); /** ObjectListSource can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void GenerateData(void) ITK_OVERRIDE; private: ObjectListSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbObjectListSource.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbObjectListSource.txx000066400000000000000000000067411301006202600261100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectListSource_txx #define otbObjectListSource_txx #include "otbObjectListSource.h" #include "itkProgressReporter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template ObjectListSource ::ObjectListSource() { // Create the output. We use static_cast<> here because we know the default // output must be of type TOutputImage typename TOutputList::Pointer output = static_cast(this->MakeOutput(0).GetPointer()); this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, output.GetPointer()); } /** * */ template typename ObjectListSource::DataObjectPointer ObjectListSource ::MakeOutput(DataObjectPointerArraySizeType) { return static_cast(TOutputList::New().GetPointer()); } /** * */ template typename ObjectListSource::OutputListType * ObjectListSource ::GetOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->Superclass::GetOutput(0)); } /** * */ template typename ObjectListSource::OutputListType * ObjectListSource ::GetOutput(DataObjectPointerArraySizeType idx) { return static_cast (this->Superclass::GetOutput(idx)); } /** * */ template void ObjectListSource ::GraftOutput(itk::DataObject *graft) { this->GraftNthOutput(0, graft); } /** * */ template void ObjectListSource ::GraftNthOutput(DataObjectPointerArraySizeType idx, itk::DataObject *graft) { if (idx >= this->GetNumberOfOutputs()) { itkExceptionMacro(<< "Requested to graft output " << idx << " but this filter only has " << this->GetNumberOfOutputs() << " Outputs."); } if (!graft) { itkExceptionMacro(<< "Requested to graft output that is a NULL pointer"); } itk::DataObject * output = this->GetOutput(idx); // Call GraftImage to copy meta-information, regions, and the pixel container output->Graft(graft); } //---------------------------------------------------------------------------- template void ObjectListSource ::AllocateOutputs() { OutputListPointer outputPtr; // Allocate the output memory for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { outputPtr = this->GetOutput(i); outputPtr->Clear(); } } /** * GenerateData */ template void ObjectListSource ::GenerateData(void) { itkExceptionMacro("subclass should ITK_OVERRIDE this method!!!"); } /** * PrintSelf Method */ template void ObjectListSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbObjectListToObjectListFilter.h000066400000000000000000000103521301006202600277600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectListToObjectListFilter_h #define otbObjectListToObjectListFilter_h #include "otbObjectListSource.h" namespace otb { /** \class ObjectListToObjectListFilter * \brief Base class for filters that take an ObjectList as input and produce an ObjectList as output. * * ObjectListToObjectListFilter is the base class for all process objects that output * ObjectList data and require ObjectList data as input. Specifically, this class * defines the SetInput() method for defining the input to a filter. * * Be aware that this class is templated over the list type, not the object type. It will * be typically something like otb::ObjectList. This is to enable the use of * class derived from ObjectList or other implementations. * * * \ingroup ObjectListFilter * * \ingroup OTBObjectList */ template class ITK_EXPORT ObjectListToObjectListFilter : public otb::ObjectListSource { public: /** Standard class typedefs. */ typedef ObjectListToObjectListFilter Self; typedef otb::ObjectListSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ObjectListToObjectListFilter, ObjectListSource); /** Some typedefs. */ typedef TInputList InputListType; typedef TOutputList OutputListType; typedef typename TInputList::ConstPointer InputListPointer; typedef typename TOutputList::Pointer OutputListPointer; typedef typename TInputList::ConstIterator InputListIterator; typedef typename InputListType::ObjectType InputObjectType; typedef typename OutputListType::ObjectType OutputObjectType; typedef itk::DataObject::Pointer DataObjectPointer; using Superclass::SetInput; virtual void SetInput(const InputListType *input); const InputListType * GetInput(void); protected: /** Constructor */ ObjectListToObjectListFilter(); /** Destructor */ ~ObjectListToObjectListFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; /** Multi-threading implementation */ typedef std::vector OutputListForThreadType; virtual void BeforeThreadedGenerateData(); virtual void AfterThreadedGenerateData() {} virtual int SplitRequestedRegion(itk::ThreadIdType threadId, int threadCount, unsigned int requestedElements, unsigned int& startIndex, unsigned int& stopIndex); /** startIndex and stopIndex represent the indices of the Objects * to examine in thread threadId */ virtual void ThreadedGenerateData(unsigned int startIndex, unsigned int stopIndex, itk::ThreadIdType threadId); /** Static function used as a "callback" by the MultiThreader. The threading * library will call this routine for each thread, which will delegate the * control to ThreadedGenerateData(). */ static ITK_THREAD_RETURN_TYPE ThreaderCallback(void *arg); /** Internal structure used for passing image data into the threading library */ struct ThreadStruct { Pointer Filter; }; OutputListForThreadType m_ObjectListPerThread; /** End Multi-threading implementation */ private: ObjectListToObjectListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbObjectListToObjectListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbObjectListToObjectListFilter.txx000066400000000000000000000141471301006202600303620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectListToObjectListFilter_txx #define otbObjectListToObjectListFilter_txx #include "otbObjectListToObjectListFilter.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template ObjectListToObjectListFilter ::ObjectListToObjectListFilter() { this->SetNumberOfRequiredInputs(1); } template void ObjectListToObjectListFilter ::SetInput(const InputListType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template const typename ObjectListToObjectListFilter::InputListType * ObjectListToObjectListFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template int ObjectListToObjectListFilter ::SplitRequestedRegion(itk::ThreadIdType threadId, int threadCount, unsigned int requestedElements, unsigned int& startIndex, unsigned int& stopIndex) { startIndex = static_cast(vcl_floor( requestedElements * static_cast(threadId) / static_cast(threadCount) + 0.5 )); stopIndex = static_cast(vcl_floor( requestedElements * static_cast(threadId + 1) / static_cast(threadCount) + 0.5 )); if (stopIndex > requestedElements) stopIndex = requestedElements; //Note: check the itkImageSource.txx for the compuration done there. // for now, there is no requested region for ObjectListFilter, so we don't // compute anything here. return threadCount; } /** * GenerateData */ template void ObjectListToObjectListFilter ::GenerateData(void) { // Call a method that can be overridden by a subclass to perform // some calculations prior to splitting the main computations into // separate threads this->BeforeThreadedGenerateData(); // Set up the multithreaded processing ThreadStruct str; str.Filter = this; // Initializing object per thread OutputListPointer defaultList; this->m_ObjectListPerThread = OutputListForThreadType(this->GetNumberOfThreads(), defaultList); // Setting up multithreader this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads()); this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str); // multithread the execution this->GetMultiThreader()->SingleMethodExecute(); // Call a method that can be overridden by a subclass to perform // some calculations after all the threads have completed this->AfterThreadedGenerateData(); } template void ObjectListToObjectListFilter ::BeforeThreadedGenerateData(void) { this->AllocateOutputs(); } template void ObjectListToObjectListFilter ::ThreadedGenerateData(unsigned int /*startIndex*/, unsigned int /*stopIndex*/, itk::ThreadIdType /*threadId*/) { // The following code is equivalent to: // itkExceptionMacro("subclass should ITK_OVERRIDE this method!!!"); // The ExceptionMacro is not used because gcc warns that a // 'noreturn' function does return std::ostringstream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "Subclass should ITK_OVERRIDE this method!!!"; itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); throw e_; } template ITK_THREAD_RETURN_TYPE ObjectListToObjectListFilter ::ThreaderCallback(void *arg) { ThreadStruct *str; itk::ThreadIdType threadId, threadCount; unsigned int total, start, stop; unsigned int requestedElements; threadId = ((itk::MultiThreader::ThreadInfoStruct *) (arg))->ThreadID; threadCount = ((itk::MultiThreader::ThreadInfoStruct *) (arg))->NumberOfThreads; str = (ThreadStruct *) (((itk::MultiThreader::ThreadInfoStruct *) (arg))->UserData); requestedElements = str->Filter->GetInput()->Size(); total = str->Filter->SplitRequestedRegion(threadId, threadCount, requestedElements, start, stop); if (threadId < static_cast(total)) { // For very small list it might occur that start = stop. In this // case the vertex at that index will be processed in the next strip. if (start != stop) { str->Filter->ThreadedGenerateData(start, stop, threadId); } } // else // { // otherwise don't use this thread. Sometimes the threads don't // break up very well and it is just as efficient to leave a // few threads idle. // } return ITK_THREAD_RETURN_VALUE; } /** * PrintSelf Method */ template void ObjectListToObjectListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbUnaryFunctorObjectListBooleanFilter.h000066400000000000000000000100121301006202600313430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorObjectListBooleanFilter_h #define otbUnaryFunctorObjectListBooleanFilter_h #include "otbObjectListToObjectListFilter.h" namespace otb { /** \class UnaryFunctorObjectListBooleanFilter * \brief Filter an ObjectList and keep elements according to the functor value * * Only elements of the list for which the functor evaluate as true are kept in the * output list. This is similar to the python filter() function. * * * \ingroup ObjectListFilter * * \ingroup OTBObjectList */ template class ITK_EXPORT UnaryFunctorObjectListBooleanFilter : public otb::ObjectListToObjectListFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorObjectListBooleanFilter Self; typedef otb::ObjectListToObjectListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorObjectListBooleanFilter, ObjectListToObjectListFilter); /** Some typedefs. */ typedef TFunction FunctorType; typedef TInputList InputListType; typedef TOutputList OutputListType; typedef typename TInputList::ConstPointer InputListPointer; typedef typename TOutputList::Pointer OutputListPointer; typedef typename TInputList::ConstIterator InputListIterator; typedef typename TOutputList::ConstIterator OutputListIterator; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { if (m_Functor != functor) { m_Functor = functor; this->Modified(); } } protected: UnaryFunctorObjectListBooleanFilter(); ~UnaryFunctorObjectListBooleanFilter() ITK_OVERRIDE {} /** Multi-threading implementation */ void AfterThreadedGenerateData() ITK_OVERRIDE; /** startIndex and stopIndex represent the indices of the Objects to examine in thread threadId */ void ThreadedGenerateData(unsigned int startIndex, unsigned int stopIndex, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Internal structure used for passing image data into the threading library */ struct ThreadStruct { Pointer Filter; }; /** End Multi-threading implementation */ private: UnaryFunctorObjectListBooleanFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorObjectListBooleanFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbUnaryFunctorObjectListBooleanFilter.txx000066400000000000000000000046771301006202600317630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorObjectListBooleanFilter_txx #define otbUnaryFunctorObjectListBooleanFilter_txx #include "otbUnaryFunctorObjectListBooleanFilter.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template UnaryFunctorObjectListBooleanFilter ::UnaryFunctorObjectListBooleanFilter() { } template void UnaryFunctorObjectListBooleanFilter ::ThreadedGenerateData(unsigned int startIndex, unsigned int stopIndex, itk::ThreadIdType threadId) { InputListPointer inputPtr = this->GetInput(); this->m_ObjectListPerThread[threadId] = OutputListType::New(); itk::ProgressReporter progress(this, threadId, stopIndex - startIndex); // Define the iterators InputListIterator it = inputPtr->Begin(); unsigned int count = 0; while ((count < startIndex) && (it != inputPtr->End())) { ++it; ++count; } while ((count < stopIndex) && (it != inputPtr->End())) { if (m_Functor(it.Get())) { this->m_ObjectListPerThread[threadId]->PushBack(it.Get()); } progress.CompletedPixel(); ++it; ++count; } } template void UnaryFunctorObjectListBooleanFilter ::AfterThreadedGenerateData() { // copy the lists to the output OutputListPointer outputPtr = this->GetOutput(); for (unsigned int i = 0; i < this->m_ObjectListPerThread.size(); ++i) { if (this->m_ObjectListPerThread[i].IsNotNull()) { for (OutputListIterator it = this->m_ObjectListPerThread[i]->Begin(); it != this->m_ObjectListPerThread[i]->End(); ++it) { outputPtr->PushBack(it.Get()); } } } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbUnaryFunctorObjectListFilter.h000066400000000000000000000074301301006202600300550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorObjectListFilter_h #define otbUnaryFunctorObjectListFilter_h #include "otbObjectListToObjectListFilter.h" namespace otb { /** \class UnaryFunctorObjectListFilter * \brief Process each element in the ObjectList with the functor * * Each element of the ObjectList is processed by the functor. * This is similar to the python map() function. * * * \ingroup ObjectListFilter * * \ingroup OTBObjectList */ template class ITK_EXPORT UnaryFunctorObjectListFilter : public otb::ObjectListToObjectListFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorObjectListFilter Self; typedef otb::ObjectListToObjectListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorObjectListFilter, ObjectListToObjectListFilter); /** Some typedefs. */ typedef TFunction FunctorType; typedef TInputList InputListType; typedef TOutputList OutputListType; typedef typename TInputList::ConstPointer InputListPointer; typedef typename TOutputList::Pointer OutputListPointer; typedef typename TInputList::ConstIterator InputListIterator; typedef typename TOutputList::ConstIterator OutputListIterator; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { if (m_Functor != functor) { m_Functor = functor; this->Modified(); } } protected: UnaryFunctorObjectListFilter(); ~UnaryFunctorObjectListFilter() ITK_OVERRIDE {} /** Multi-threading implementation */ void AfterThreadedGenerateData() ITK_OVERRIDE; /** startIndex and stopIndex represent the indices of the Objects to examine in thread threadId */ void ThreadedGenerateData(unsigned int startIndex, unsigned int stopIndex, itk::ThreadIdType threadId) ITK_OVERRIDE; /** End Multi-threading implementation */ private: UnaryFunctorObjectListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorObjectListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbUnaryFunctorObjectListFilter.txx000066400000000000000000000045771301006202600304620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorObjectListFilter_txx #define otbUnaryFunctorObjectListFilter_txx #include "otbUnaryFunctorObjectListFilter.h" #include "itkProgressReporter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template UnaryFunctorObjectListFilter ::UnaryFunctorObjectListFilter() { } template void UnaryFunctorObjectListFilter ::ThreadedGenerateData(unsigned int startIndex, unsigned int stopIndex, itk::ThreadIdType threadId) { InputListPointer inputPtr = this->GetInput(); this->m_ObjectListPerThread[threadId] = OutputListType::New(); itk::ProgressReporter progress(this, threadId, stopIndex - startIndex); // Define the iterators InputListIterator it = inputPtr->Begin(); unsigned int count = 0; while ((count < startIndex) && (it != inputPtr->End())) { ++it; ++count; } while ((count < stopIndex) && (it != inputPtr->End())) { this->m_ObjectListPerThread[threadId]->PushBack(m_Functor(it.Get())); progress.CompletedPixel(); ++it; ++count; } } template void UnaryFunctorObjectListFilter ::AfterThreadedGenerateData() { // copy the lists to the output OutputListPointer outputPtr = this->GetOutput(); for (unsigned int i = 0; i < this->m_ObjectListPerThread.size(); ++i) { if (this->m_ObjectListPerThread[i].IsNotNull()) { for (OutputListIterator it = this->m_ObjectListPerThread[i]->Begin(); it != this->m_ObjectListPerThread[i]->End(); ++it) { outputPtr->PushBack(it.Get()); } } } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbVectorImageToImageListFilter.h000066400000000000000000000061721301006202600277440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToImageListFilter_h #define otbVectorImageToImageListFilter_h #include "otbImageToImageListFilter.h" namespace otb { /** \class VectorImageToImageListFilter * \brief This class aims at converting a multi-band image to a list of scalar images. * * This class takes a multi-band image represented as an otb::VectorImage and produces a list * of scalar images corresponding to each band of the input image. * * Casting is done through standard cast operation. * * The output of this filter didn't support the use of iterator on it, use a selector filter * to avoid break the output * * \ingroup Streamed * * \ingroup OTBObjectList */ template class ITK_EXPORT VectorImageToImageListFilter : public ImageToImageListFilter { public: /** Standard typedefs */ typedef VectorImageToImageListFilter Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(VectorImageToImageListFilter, ImageToImageListFilter); /** Template parameters typedefs */ typedef TVectorImageType InputVectorImageType; typedef typename InputVectorImageType::Pointer InputVectorImagePointerType; typedef TImageList OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::ImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; /** Generate the input requested region from the first element in the list. */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Generate the output information by building the output list. */ void GenerateOutputInformation(void) ITK_OVERRIDE; protected: /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** Constructor */ VectorImageToImageListFilter() {}; /** Destructor */ ~VectorImageToImageListFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: VectorImageToImageListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorImageToImageListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/ObjectList/include/otbVectorImageToImageListFilter.txx000066400000000000000000000110351301006202600303320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToImageListFilter_txx #define otbVectorImageToImageListFilter_txx #include "otbVectorImageToImageListFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include #include "otbMacro.h" #include "itkProgressReporter.h" namespace otb { /** Generate the input requested region from the first element in the list. */ template void VectorImageToImageListFilter ::GenerateOutputInformation(void) { OutputImageListPointerType outputPtr = this->GetOutput(); InputVectorImagePointerType inputPtr = this->GetInput(); if (inputPtr) { if (outputPtr->Size() != inputPtr->GetNumberOfComponentsPerPixel()) { // if the number of components does not match, clear the list outputPtr->Clear(); for (unsigned int i = 0; i < inputPtr->GetNumberOfComponentsPerPixel(); ++i) { typename OutputImageType::Pointer tmpImagePtr = OutputImageType::New(); this->AddOutput(tmpImagePtr); outputPtr->PushBack(tmpImagePtr); } } for (unsigned int i = 0; i < inputPtr->GetNumberOfComponentsPerPixel(); ++i) { typename OutputImageType::Pointer tmpImagePtr = outputPtr->GetNthElement(i); tmpImagePtr->CopyInformation(inputPtr); tmpImagePtr->SetLargestPossibleRegion(inputPtr->GetLargestPossibleRegion()); tmpImagePtr->SetRequestedRegion(inputPtr->GetLargestPossibleRegion()); } } } /** Generate the output information by building the output list. */ template void VectorImageToImageListFilter ::GenerateInputRequestedRegion(void) { OutputImageListPointerType outputPtr = this->GetOutput(); InputVectorImagePointerType inputPtr = this->GetInput(); if (inputPtr) { if (outputPtr->Size() > 0) { inputPtr->SetRequestedRegion(outputPtr->GetNthElement(0)->GetRequestedRegion()); } } } /** * Main computation method */ template void VectorImageToImageListFilter ::GenerateData(void) { OutputImageListPointerType outputPtr = this->GetOutput(); InputVectorImagePointerType inputPtr = this->GetInput(); typedef itk::ImageRegionConstIteratorWithIndex InputIteratorType; typedef itk::ImageRegionIteratorWithIndex OutputIteratorType; std::vector outputIteratorList; typename OutputImageListType::ConstIterator outputListIt = outputPtr->Begin(); for (; outputListIt != outputPtr->End(); ++outputListIt) { outputListIt.Get()->SetBufferedRegion(outputListIt.Get()->GetRequestedRegion()); outputListIt.Get()->Allocate(); OutputIteratorType tmpIt = OutputIteratorType(outputListIt.Get(), outputListIt.Get()->GetRequestedRegion()); tmpIt.GoToBegin(); outputIteratorList.push_back(tmpIt); } InputIteratorType inputIt(inputPtr, outputPtr->GetNthElement(0)->GetRequestedRegion()); itk::ProgressReporter progress(this, 0, outputPtr->GetNthElement(0)->GetRequestedRegion().GetNumberOfPixels()); inputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { unsigned int counter = 0; for (typename std::vector::iterator it = outputIteratorList.begin(); it != outputIteratorList.end(); ++it) { if (!(*it).IsAtEnd()) { (*it).Set(static_cast(inputIt.Get()[counter])); ++(*it); ++counter; } else { itkGenericExceptionMacro("End of image for band " << counter << " at index " << (*it).GetIndex() << " !"); } } progress.CompletedPixel(); ++inputIt; } } /** * PrintSelf Method */ template void VectorImageToImageListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/ObjectList/otb-module.cmake000066400000000000000000000007631301006202600230370ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes that allow manipulating an ITK/OTB object list with the appropriate formalism. For instance, it is possible to apply a given scalar image filter to a list of images. or to produce an output corresponding to the elements selected from an image list. and so on.") otb_module(OTBObjectList DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel OTBVectorDataBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/ObjectList/test/000077500000000000000000000000001301006202600207375ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/ObjectList/test/CMakeLists.txt000066400000000000000000000127351301006202600235070ustar00rootroot00000000000000otb_module_test() set(OTBObjectListTests otbObjectList.cxx otbObjectListNew.cxx otbImageList.cxx otbImageListNew.cxx otbImageListSourceNew.cxx otbImageListToImageFilterNew.cxx otbImageListToImageListApplyFilter.cxx otbImageListToImageListApplyFilterNew.cxx otbImageListToImageListFilterNew.cxx otbImageListToVectorImageFilter2.cxx otbImageListToVectorImageFilter.cxx otbImageListToVectorImageFilterNew.cxx otbObjectList2.cxx otbObjectListToObjectListFilterNew.cxx otbImageToImageListFilterNew.cxx otbVectorImageToImageListFilter.cxx otbVectorImageToImageListFilterNew.cxx otbObjectListTestDriver.cxx ) add_executable(otbObjectListTestDriver ${OTBObjectListTests}) target_link_libraries(otbObjectListTestDriver ${OTBObjectList-Test_LIBRARIES}) otb_module_target_label(otbObjectListTestDriver) otb_add_test(NAME coTvObjectList COMMAND otbObjectListTestDriver otbObjectList ${INPUTDATA}/couleurs.jpg ${INPUTDATA}/poupees.png ${INPUTDATA}/couleurs_extrait.png ) otb_add_test(NAME coTuObjectListNew COMMAND otbObjectListTestDriver otbObjectListNew) otb_add_test(NAME coTvImageList COMMAND otbObjectListTestDriver --compare-image ${NOTOL} ${INPUTDATA}/amst.png ${TEMP}/amst.png otbImageList ${INPUTDATA}/amst.png ${TEMP}/amst.png ) otb_add_test(NAME coTuImageListNew COMMAND otbObjectListTestDriver otbImageListNew) otb_add_test(NAME coTuImageListSourceNew COMMAND otbObjectListTestDriver otbImageListSourceNew) otb_add_test(NAME coTuImageListToImageFilterNew COMMAND otbObjectListTestDriver otbImageListToImageFilterNew) otb_add_test(NAME bfTvImageListToImageListApplyFilter COMMAND otbObjectListTestDriver --compare-n-images ${EPSILON_7} 3 ${BASELINE}/bfTvImageListToImageListApplyFilterBand1.png ${TEMP}/bfTvImageListToImageListApplyFilterBand1.png ${BASELINE}/bfTvImageListToImageListApplyFilterBand2.png ${TEMP}/bfTvImageListToImageListApplyFilterBand2.png ${BASELINE}/bfTvImageListToImageListApplyFilterBand3.png ${TEMP}/bfTvImageListToImageListApplyFilterBand3.png otbImageListToImageListApplyFilter ${INPUTDATA}/poupees_c1.hdr ${INPUTDATA}/poupees_c2.hdr ${INPUTDATA}/poupees_c3.hdr ${TEMP}/bfTvImageListToImageListApplyFilterBand1.png ${TEMP}/bfTvImageListToImageListApplyFilterBand2.png ${TEMP}/bfTvImageListToImageListApplyFilterBand3.png ) otb_add_test(NAME bfTuImageListToImageListApplyFilterNew COMMAND otbObjectListTestDriver otbImageListToImageListApplyFilterNew) otb_add_test(NAME coTvImageListToImageListFilterNew COMMAND otbObjectListTestDriver otbImageListToImageListFilterNew) otb_add_test(NAME coTvImageListToVectorImageFilter2 COMMAND otbObjectListTestDriver otbImageListToVectorImageFilter2 ${INPUTDATA}/poupees_c1.hdr ${INPUTDATA}/poupees_c2.hdr ${INPUTDATA}/poupees_c3.hdr ) otb_add_test(NAME coTvImageListToVectorImageFilter COMMAND otbObjectListTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvImageListToVectorImageFilter.png ${TEMP}/coTvImageListToVectorImageFilter.png otbImageListToVectorImageFilter ${INPUTDATA}/poupees_c1.hdr ${INPUTDATA}/poupees_c2.hdr ${INPUTDATA}/poupees_c3.hdr ${TEMP}/coTvImageListToVectorImageFilter.png ) otb_add_test(NAME coTuImageListToVectorImageFilterNew COMMAND otbObjectListTestDriver otbImageListToVectorImageFilterNew) otb_add_test(NAME coTvObjectListTestNotValid COMMAND otbObjectListTestDriver otbObjectList2 ) otb_add_test(NAME coTuObjectListToObjectListFilterNew COMMAND otbObjectListTestDriver otbObjectListToObjectListFilterNew) otb_add_test(NAME coTuImageToImageListFilterNew COMMAND otbObjectListTestDriver otbImageToImageListFilterNew) otb_add_test(NAME bfTvVectorImageToImageListFilter COMMAND otbObjectListTestDriver --compare-n-images ${EPSILON_7} 3 ${BASELINE}/bfTvVectorImageToImageListFilterBand1.png ${TEMP}/bfTvVectorImageToImageListFilterBand1.png ${BASELINE}/bfTvVectorImageToImageListFilterBand2.png ${TEMP}/bfTvVectorImageToImageListFilterBand2.png ${BASELINE}/bfTvVectorImageToImageListFilterBand3.png ${TEMP}/bfTvVectorImageToImageListFilterBand3.png otbVectorImageToImageListFilter ${INPUTDATA}/poupees.png ${TEMP}/bfTvVectorImageToImageListFilterBand1.png ${TEMP}/bfTvVectorImageToImageListFilterBand2.png ${TEMP}/bfTvVectorImageToImageListFilterBand3.png ) otb_add_test(NAME bfTvVectorImageToImageListFilterIt COMMAND otbObjectListTestDriver --compare-n-images ${EPSILON_7} 3 ${BASELINE}/bfTvVectorImageToImageListFilterBand1.png ${TEMP}/bfTvVectorImageToImageListFilterItBand1.png ${BASELINE}/bfTvVectorImageToImageListFilterBand2.png ${TEMP}/bfTvVectorImageToImageListFilterItBand2.png ${BASELINE}/bfTvVectorImageToImageListFilterBand3.png ${TEMP}/bfTvVectorImageToImageListFilterItBand3.png otbVectorImageToImageListFilterIterator ${INPUTDATA}/poupees.png ${TEMP}/bfTvVectorImageToImageListFilterIt png ) otb_add_test(NAME bfTvVectorImageToImageListFilterIt2 COMMAND otbObjectListTestDriver --compare-n-images ${EPSILON_7} 3 ${BASELINE}/bfTvVectorImageToImageListFilterBand1.png ${TEMP}/bfTvVectorImageToImageListFilterIt2Band1.tif ${BASELINE}/bfTvVectorImageToImageListFilterBand2.png ${TEMP}/bfTvVectorImageToImageListFilterIt2Band2.tif ${BASELINE}/bfTvVectorImageToImageListFilterBand3.png ${TEMP}/bfTvVectorImageToImageListFilterIt2Band3.tif otbVectorImageToImageListFilterIterator ${INPUTDATA}/poupees.png ${TEMP}/bfTvVectorImageToImageListFilterIt2 tif ) otb_add_test(NAME bfTuVectorImageToImageListFilterNew COMMAND otbObjectListTestDriver otbVectorImageToImageListFilterNew) OTB-release-5.8/Modules/Core/ObjectList/test/otbImageList.cxx000066400000000000000000000033031301006202600240450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageList.h" #include "otbImage.h" int otbImageList(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageList ImageListType; // Reading image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->Update(); // Instantiating ImageList object ImageListType::Pointer imageList = ImageListType::New(); // Appending one image to the list imageList->PushBack(reader->GetOutput()); // Getting the image from the list and writing it to file WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(imageList->Back()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListNew.cxx000066400000000000000000000021031301006202600245140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageList.h" #include "otbImage.h" int otbImageListNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef otb::Image InputImageType; typedef otb::ImageList ImageListType; // Instantiating ImageList object ImageListType::Pointer imageList = ImageListType::New(); std::cout << imageList << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListSourceNew.cxx000066400000000000000000000021461301006202600257040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListSource.h" #include "otbImage.h" int otbImageListSourceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef otb::Image InputImageType; typedef otb::ImageListSource ImageListSourceType; // Instantiating ImageListSource object ImageListSourceType::Pointer imageList = ImageListSourceType::New(); std::cout << imageList << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListToImageFilterNew.cxx000066400000000000000000000025761301006202600271460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListToImageFilter.h" #include "otbImage.h" int otbImageListToImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageListToImageFilter ImageListToImageFilterType; // Instantiating ImageListSource object ImageListToImageFilterType::Pointer imageList = ImageListToImageFilterType::New(); std::cout << imageList << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListToImageListApplyFilter.cxx000066400000000000000000000054031301006202600303260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListToImageListApplyFilter.h" #include "otbImageList.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkMeanImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageListToImageListApplyFilter(int itkNotUsed(argc), char * argv[]) { char * infname1 = argv[1]; char * infname2 = argv[2]; char * infname3 = argv[3]; char * outfname1 = argv[4]; char * outfname2 = argv[5]; char * outfname3 = argv[6]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageList ImageListType; typedef itk::MeanImageFilter MeanFilterType; // IO typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageListToImageListApplyFilter ImageListToImageListApplyFilterType; // Instantiating object ImageListToImageListApplyFilterType::Pointer filter = ImageListToImageListApplyFilterType::New(); ReaderType::Pointer reader1, reader2, reader3; reader1 = ReaderType::New(); reader1->SetFileName(infname1); reader2 = ReaderType::New(); reader2->SetFileName(infname2); reader3 = ReaderType::New(); reader3->SetFileName(infname3); ImageListType::Pointer imageList = ImageListType::New(); imageList->PushBack(reader1->GetOutput()); imageList->PushBack(reader2->GetOutput()); imageList->PushBack(reader3->GetOutput()); MeanFilterType::Pointer meanFilter = MeanFilterType::New(); filter->SetInput(imageList); filter->SetFilter(meanFilter); filter->Update(); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname1); writer->SetInput(filter->GetOutput()->GetNthElement(0)); writer->Update(); writer = WriterType::New(); writer->SetFileName(outfname2); writer->SetInput(filter->GetOutput()->GetNthElement(0)); writer->Update(); writer = WriterType::New(); writer->SetFileName(outfname3); writer->SetInput(filter->GetOutput()->GetNthElement(0)); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListToImageListApplyFilterNew.cxx000066400000000000000000000026731301006202600310060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListToImageListApplyFilter.h" #include "otbImageList.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkMeanImageFilter.h" int otbImageListToImageListApplyFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageList ImageListType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::ImageListToImageListApplyFilter ImageListToImageListApplyFilterType; // Instantiating object ImageListToImageListApplyFilterType::Pointer filter = ImageListToImageListApplyFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListToImageListFilterNew.cxx000066400000000000000000000026321301006202600277730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListToImageListFilter.h" #include "otbImage.h" int otbImageListToImageListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageListToImageListFilter ImageToImageListFilterType; // Instantiating ImageListSource object ImageToImageListFilterType::Pointer imageList = ImageToImageListFilterType::New(); std::cout << imageList << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListToVectorImageFilter.cxx000066400000000000000000000043151301006202600276500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListToVectorImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageList.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageListToVectorImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; char * infname1 = argv[1]; char * infname2 = argv[2]; char * infname3 = argv[3]; char * outfname = argv[4]; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; // IO typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; // Instantiating object ImageListToVectorImageFilterType::Pointer filter = ImageListToVectorImageFilterType::New(); // Building image list ReaderType::Pointer reader1, reader2, reader3; reader1 = ReaderType::New(); reader1->SetFileName(infname1); reader2 = ReaderType::New(); reader2->SetFileName(infname2); reader3 = ReaderType::New(); reader3->SetFileName(infname3); ImageListType::Pointer imageList = ImageListType::New(); imageList->PushBack(reader1->GetOutput()); imageList->PushBack(reader2->GetOutput()); imageList->PushBack(reader3->GetOutput()); filter->SetInput(imageList); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListToVectorImageFilter2.cxx000066400000000000000000000051621301006202600277330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListToVectorImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageList.h" #include "otbImageFileReader.h" int otbImageListToVectorImageFilter2(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; char * infname1 = argv[1]; char * infname2 = argv[2]; char * infname3 = argv[3]; // char * outfname = argv[4]; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; // typedef VectorImageType::Pointer VectorImagePointerType; typedef otb::ImageList ImageListType; // IO typedef otb::ImageFileReader ReaderType; // typedef otb::ImageFileWriter WriterType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; // Instantiating object ImageListToVectorImageFilterType::Pointer filter = ImageListToVectorImageFilterType::New(); // Building image list ReaderType::Pointer reader1, reader2, reader3; reader1 = ReaderType::New(); reader1->SetFileName(infname1); reader2 = ReaderType::New(); reader2->SetFileName(infname2); reader3 = ReaderType::New(); reader3->SetFileName(infname3); ImageListType::Pointer imageList = ImageListType::New(); imageList->PushBack(reader1->GetOutput()); imageList->PushBack(reader2->GetOutput()); imageList->PushBack(reader3->GetOutput()); filter->SetInput(imageList); VectorImageType::Pointer m_OutputImage = VectorImageType::New(); m_OutputImage = filter->GetOutput(); m_OutputImage->UpdateOutputInformation(); unsigned int nbComp1 = m_OutputImage->GetNumberOfComponentsPerPixel(); imageList->PopBack(); m_OutputImage->UpdateOutputInformation(); unsigned int nbComp2 = m_OutputImage->GetNumberOfComponentsPerPixel (); std::cout << "component 1: " << nbComp1 << std::endl; std::cout << "component 2: " << nbComp2 << std::endl; if (nbComp2 != nbComp1 - 1) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageListToVectorImageFilterNew.cxx000066400000000000000000000025061301006202600303220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageListToVectorImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageList.h" int otbImageListToVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; // Instantiating object ImageListToVectorImageFilterType::Pointer filter = ImageListToVectorImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbImageToImageListFilterNew.cxx000066400000000000000000000025761301006202600271460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToImageListFilter.h" #include "otbImage.h" int otbImageToImageListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageToImageListFilter ImageToImageListFilterType; // Instantiating ImageListSource object ImageToImageListFilterType::Pointer imageList = ImageToImageListFilterType::New(); std::cout << imageList << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbObjectList.cxx000066400000000000000000000152461301006202600242420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbObjectList.h" #include "otbImage.h" #include "otbMacro.h" int otbObjectList(int itkNotUsed(argc), char * argv[]) { const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * inputFilename3 = argv[3]; const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ObjectList ImageListType; // Reading image 1 ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(inputFilename1); reader1->Update(); // Reading image 2 ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(inputFilename2); reader2->Update(); // Reading image 3 ReaderType::Pointer reader3 = ReaderType::New(); reader3->SetFileName(inputFilename3); reader3->Update(); // Instantiating the tested object ImageListType::Pointer imageList = ImageListType::New(); // Testing reserve/capacity imageList->Reserve(2); otbControlConditionTestMacro((imageList->Capacity() != 2), "Reserve/Capacity()"); // Testing Size/Element accessor imageList->PushBack(reader1->GetOutput()); imageList->PushBack(reader2->GetOutput()); otbControlConditionTestMacro(imageList->Size() != 2, "PushBack/Size()"); otbControlConditionTestMacro(imageList->GetNthElement(0) != reader1->GetOutput(), "PushBack/GetNthElement(0)"); otbControlConditionTestMacro(imageList->GetNthElement(1) != reader2->GetOutput(), "PushBack/GetNthElement(1)"); otbControlConditionTestMacro(imageList->Front() != reader1->GetOutput(), "PushBack/Front()"); otbControlConditionTestMacro(imageList->Back() != reader2->GetOutput(), "PushBack/Back()"); // Testing resizing and related method imageList->Resize(3); otbControlConditionTestMacro(imageList->Size() != 3, "Resize/Size()"); // Testing explicit setter imageList->SetNthElement(2, reader3->GetOutput()); otbControlConditionTestMacro(imageList->Size() != 3, "SetNthElement/Size()"); otbControlConditionTestMacro(imageList->GetNthElement(2) != reader3->GetOutput(), "SetNthElement/GetNthElement(2)"); // Testing erase operation imageList->Erase(2); otbControlConditionTestMacro((imageList->Size() != 2) || (imageList->GetNthElement(0) != reader1->GetOutput()) || (imageList->GetNthElement(1) != reader2->GetOutput()), "Erase(3)"); // Testing iterator ImageListType::Iterator iter = imageList->Begin(); otbControlConditionTestMacro(!(iter != imageList->End()), "Iterator/Begin()!=Iterator/End()"); unsigned int index = 0; while (iter != imageList->End()) { otbControlConditionTestMacro((index == 0) && (reader1->GetOutput() != iter.Get()), "Iterator/1/iter.Get()"); otbControlConditionTestMacro((index == 1) && (reader2->GetOutput() != iter.Get()), "Iterator/2/iter.Get()"); otbControlConditionTestMacro(index > 1, "Iterator/OutOfBound/iter.Get()"); ++index; ++iter; } // Testing operator+ iter = imageList->Begin(); index = 0; otbControlConditionTestMacro(imageList->GetNthElement(0) != iter.Get(), "Iterator != GetNthElement(0)"); otbControlConditionTestMacro(imageList->GetNthElement(1) != (iter + 1).Get(), "Iterator+1 != GetNthElement(1)"); ++iter; otbControlConditionTestMacro(imageList->GetNthElement(1) != iter.Get(), "Iterator != GetNthElement(1)"); otbControlConditionTestMacro(imageList->GetNthElement(0) != (iter - 1).Get(), "Iterator-1 != GetNthElement(0)"); // Testing const iterator ImageListType::ConstIterator constIter = imageList->Begin(); index = 0; while (constIter != imageList->End()) { otbControlConditionTestMacro( (index == 0) && (reader1->GetOutput() != constIter.Get()), "ConstIterator/1/iter.Get()"); otbControlConditionTestMacro( (index == 1) && (reader2->GetOutput() != constIter.Get()), "ConstIterator/2/iter.Get()"); otbControlConditionTestMacro(index > 1, "ConstIterator/OutOfBound/iter.Get()"); ++index; ++constIter; } //Testing reverse iterator ImageListType::ReverseIterator revIter = imageList->ReverseBegin(); otbControlConditionTestMacro( !(revIter != imageList->ReverseEnd()), "ReverseIterator/ReverseBegin()!=ReverseIterator/ReverseEnd()"); index = 0; while (revIter != imageList->ReverseEnd()) { otbControlConditionTestMacro( (index == 0) && (reader2->GetOutput() != revIter.Get()), "ReverseIterator/1/iter.Get()"); otbControlConditionTestMacro( (index == 1) && (reader1->GetOutput() != revIter.Get()), "ReverseIterator/2/iter.Get()"); otbControlConditionTestMacro(index > 1, "ReverseIterator/OutOfBound/iter.Get()"); ++index; ++revIter; } //Testing const reverse iterator ImageListType::ReverseConstIterator revConstIter = imageList->ReverseBegin(); index = 0; while (revConstIter != imageList->ReverseEnd()) { otbControlConditionTestMacro( (index == 0) && (reader2->GetOutput() != revConstIter.Get()), "ReverseConstIterator/1/iter.Get()"); otbControlConditionTestMacro( (index == 1) && (reader1->GetOutput() != revConstIter.Get()), "ReverseConstIterator/2/iter.Get()"); otbControlConditionTestMacro(index > 1, "ReverseConstIterator/OutOfBound/iter.Get()"); ++index; ++revConstIter; } // Testing clear imageList->Clear(); otbControlConditionTestMacro(imageList->Size() != 0, "Clear()"); // Testing erase with iterators imageList->PushBack(reader1->GetOutput()); imageList->PushBack(reader2->GetOutput()); imageList->PushBack(reader3->GetOutput()); ImageListType::Iterator begin = imageList->Begin() + 1; ImageListType::Iterator end = imageList->End(); imageList->Erase(begin, end); otbControlConditionTestMacro(imageList->Size() != 1, "Erase(Iterator, Iterator)/Size()"); otbControlConditionTestMacro(imageList->Back() != reader1->GetOutput(), "Erase(Iterator, Iterator)/Back()"); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbObjectList2.cxx000066400000000000000000000040431301006202600243150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbObjectList.h" #include "otbPolygon.h" #include "otbMacro.h" #include int otbObjectList2(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon PolygonType; typedef otb::ObjectList PolygonListType; PolygonType::Pointer polygon = PolygonType::New(); PolygonListType::Pointer listPolygon = PolygonListType::New(); otbTestingCheckNotValidCommand(listPolygon->Erase(1)); otbTestingCheckValidCommand(listPolygon->Clear()); otbTestingCheckNotValidCommand(listPolygon->SetNthElement(0, polygon)); otbTestingCheckNotValidCommand(listPolygon->SetNthElement(2, polygon)); otbTestingCheckNotValidCommand(listPolygon->GetNthElement(2)); std::vector tab; tab.reserve(3); otbControlConditionTestMacro(tab.capacity() != 3, "Check std::vector Capacity"); otbControlConditionTestMacro(tab.size() != 0, "Check std::vector Size"); tab.resize(2); otbControlConditionTestMacro(tab.capacity() != 3, "Check std::vector Capacity"); otbControlConditionTestMacro(tab.size() != 2, "Check std::vector Size"); listPolygon->Reserve(3); otbControlConditionTestMacro(listPolygon->Capacity() != 3, "Check Reserve and Capacity coherence"); listPolygon->Resize(2); otbControlConditionTestMacro(listPolygon->Size() != 2, "Check Resize and Size coherence"); otbTestingCheckValidCommand(listPolygon->SetNthElement(0, polygon)); otbTestingCheckNotValidCommand(listPolygon->SetNthElement(2, polygon)); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbObjectListNew.cxx000066400000000000000000000020171301006202600247040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbObjectList.h" #include "otbImage.h" int otbObjectListNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ObjectList ImageListType; ImageListType::Pointer imageList = ImageListType::New(); std::cout << imageList << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbObjectListTestDriver.cxx000066400000000000000000000015551301006202600262540ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbObjectList); REGISTER_TEST(otbObjectListNew); REGISTER_TEST(otbImageList); REGISTER_TEST(otbImageListNew); REGISTER_TEST(otbImageListSourceNew); REGISTER_TEST(otbImageListToImageFilterNew); REGISTER_TEST(otbImageListToImageListApplyFilter); REGISTER_TEST(otbImageListToImageListApplyFilterNew); REGISTER_TEST(otbImageListToImageListFilterNew); REGISTER_TEST(otbImageListToVectorImageFilter2); REGISTER_TEST(otbImageListToVectorImageFilter); REGISTER_TEST(otbImageListToVectorImageFilterNew); REGISTER_TEST(otbObjectList2); REGISTER_TEST(otbObjectListToObjectListFilterNew); REGISTER_TEST(otbImageToImageListFilterNew); REGISTER_TEST(otbVectorImageToImageListFilter); REGISTER_TEST(otbVectorImageToImageListFilterNew); REGISTER_TEST(otbVectorImageToImageListFilterIterator); } OTB-release-5.8/Modules/Core/ObjectList/test/otbObjectListToObjectListFilterNew.cxx000066400000000000000000000024601301006202600303420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbObjectListToObjectListFilter.h" #include "otbObjectList.h" #include #include "otbPolygon.h" int otbObjectListToObjectListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::PolyLineParametricPathWithValue, 2> InputObjectType; typedef otb::Polygon OutputObjectType; typedef otb::ObjectList InputListType; typedef otb::ObjectList OutputListType; typedef otb::ObjectListToObjectListFilter ObjectListFilterType; ObjectListFilterType::Pointer objectList = ObjectListFilterType::New(); std::cout << objectList << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbVectorImageToImageListFilter.cxx000066400000000000000000000104461301006202600276520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImageToImageListFilter.h" #include "otbVectorImage.h" #include "otbImageList.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbVectorImageToImageListFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; char * infname = argv[1]; char * outfname1 = argv[2]; char * outfname2 = argv[3]; char * outfname3 = argv[4]; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; // IO typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorImageToImageListFilter VectorImageToImageListFilterType; // Instantiating object VectorImageToImageListFilterType::Pointer filter = VectorImageToImageListFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->Update(); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname1); writer->SetInput(filter->GetOutput()->GetNthElement(0)); writer->Update(); writer = WriterType::New(); writer->SetFileName(outfname2); writer->SetInput(filter->GetOutput()->GetNthElement(1)); writer->Update(); writer = WriterType::New(); writer->SetFileName(outfname3); writer->SetInput(filter->GetOutput()->GetNthElement(2)); writer->Update(); return EXIT_SUCCESS; } int otbVectorImageToImageListFilterIterator(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const char * infname = argv[1]; const char * outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; // IO typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorImageToImageListFilter VectorImageToImageListFilterType; typedef VectorImageToImageListFilterType::OutputImageListType::Iterator ImageListIterator; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); VectorImageToImageListFilterType::Pointer filter = VectorImageToImageListFilterType::New(); filter->SetInput(reader->GetOutput()); // We need to do that to fill the Imagelist before update and use it as input of other filter filter->UpdateOutputInformation(); ImageListIterator itOutput = filter->GetOutput()->Begin(); WriterType::Pointer writer = WriterType::New(); int i = 1; while ((itOutput != filter->GetOutput()->End()) ) { std::stringstream oss; oss << outputFilenamePrefix << "Band" << i << "." << outputFilenameSuffix; writer->SetInput(itOutput.Get()); writer->SetFileName(oss.str().c_str()); writer->SetNumberOfDivisionsTiledStreaming(8); writer->Update(); ++itOutput; ++i; } /* while ((itOutput != filter->GetOutput()->End()) ) { std::stringstream oss; WriterType::Pointer writer = WriterType::New(); oss << outputFilenamePrefix << "Band" << i << "." << outputFilenameSuffix; writer->SetInput(itOutput.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); ++itOutput; ++i; } */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/ObjectList/test/otbVectorImageToImageListFilterNew.cxx000066400000000000000000000025371301006202600303260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImageToImageListFilter.h" #include "otbVectorImage.h" #include "otbImageList.h" #include "otbImage.h" int otbVectorImageToImageListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorImageToImageListFilterType; // Instantiating object VectorImageToImageListFilterType::Pointer filter = VectorImageToImageListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/000077500000000000000000000000001301006202600174635ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/PointSet/CMakeLists.txt000066400000000000000000000000471301006202600222240ustar00rootroot00000000000000project(OTBPointSet) otb_module_impl() OTB-release-5.8/Modules/Core/PointSet/include/000077500000000000000000000000001301006202600211065ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/PointSet/include/otbImageToPointSetFilter.h000066400000000000000000000114731301006202600261530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPointSetFilter_h #define otbImageToPointSetFilter_h #include "otbPointSetSource.h" #include "otbRAMDrivenAdaptativeStreamingManager.h" // TODO: This class needs a refactoring to become a persistent filter namespace otb { /** \class ImageToPointSetFilter * \brief Base class to output PointSet data with image data as input * * ImageToPointSetFilter is the base class for all process objects that output * Point Set data and require image data as input. Specifically, this class * defines the SetInput() method for defining the input to a filter. * * \ingroup ImageFilters * * \ingroup OTBPointSet */ template class ITK_EXPORT ImageToPointSetFilter : public PointSetSource { public: /** Standard class typedefs. */ typedef ImageToPointSetFilter Self; typedef PointSetSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ImageToPointSetFilter, PointSetSource); /** Some Image related typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Some PointSet related typedefs. */ typedef typename Superclass::OutputPointSetType OutputPointSetType; typedef typename Superclass::OutputPointSetPointer OutputPointSetPointer; typedef typename Superclass::PointsContainerType PointsContainerType; typedef typename Superclass::PointDataContainerType PointDataContainerType; typedef itk::ProcessObject ProcessObjectType; /** Set the input image of this process object. */ using Superclass::SetInput; void SetInput(unsigned int idx, const InputImageType *input); void SetInput(const InputImageType *input); /** Get the input image of this process object. */ const InputImageType * GetInput(unsigned int idx); const InputImageType * GetInput(); /** Prepare the output */ void GenerateOutputInformation(void) ITK_OVERRIDE; protected: ImageToPointSetFilter(); ~ImageToPointSetFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; /** Multi-threading implementation */ typedef std::vector OutputPointsContainerForThreadType; typedef std::vector OutputPointDataContainerForThreadType; virtual void BeforeThreadedGenerateData(); virtual void AfterThreadedGenerateData(); virtual int SplitRequestedRegion(int i, int num, InputImageRegionType& splitRegion); virtual void ThreadedGenerateData(const InputImageRegionType& inputRegionForThread, itk::ThreadIdType threadId); /** Static function used as a "callback" by the MultiThreader. The threading * library will call this routine for each thread, which will delegate the * control to ThreadedGenerateData(). */ static ITK_THREAD_RETURN_TYPE ThreaderCallback(void *arg); /** Internal structure used for passing image data into the threading library */ struct ThreadStruct { Pointer Filter; }; OutputPointsContainerForThreadType m_PointsContainerPerThread; OutputPointDataContainerForThreadType m_PointDataContainerPerThread; /** End Multi-threading implementation */ /** Setup for streaming */ typedef RAMDrivenAdaptativeStreamingManager StreamingManagerType; typedef typename StreamingManagerType::Pointer StreamingManagerPointer; StreamingManagerPointer m_StreamingManager; private: ImageToPointSetFilter(const ImageToPointSetFilter &); //purposely not implemented void operator =(const ImageToPointSetFilter&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbImageToPointSetFilter.txx000066400000000000000000000264511301006202600265510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPointSetFilter_txx #define otbImageToPointSetFilter_txx #include "otbImageToPointSetFilter.h" namespace otb { /** * */ template ImageToPointSetFilter ::ImageToPointSetFilter() { this->ProcessObjectType::SetNumberOfRequiredInputs(1); OutputPointSetPointer output = dynamic_cast(this->MakeOutput(0).GetPointer()); ProcessObjectType::SetNumberOfRequiredOutputs(1); ProcessObjectType::SetNthOutput(0, output.GetPointer()); m_PointsContainerPerThread.clear(); m_PointDataContainerPerThread.clear(); // create default region splitter m_StreamingManager = StreamingManagerType::New(); } /** * */ template void ImageToPointSetFilter ::SetInput(unsigned int idx, const InputImageType *input) { // process object is not const-correct, the const_cast // is required here. this->ProcessObjectType::SetNthInput(idx, const_cast(input)); } /** * */ template void ImageToPointSetFilter ::SetInput(const InputImageType *input) { // process object is not const-correct, the const_cast // is required here. this->ProcessObjectType::SetNthInput(0, const_cast(input)); } /** * */ template const typename ImageToPointSetFilter::InputImageType * ImageToPointSetFilter ::GetInput(unsigned int idx) { return dynamic_cast (this->ProcessObjectType::GetInput(idx)); } /** * */ template const typename ImageToPointSetFilter::InputImageType * ImageToPointSetFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) return ITK_NULLPTR; return dynamic_cast (this->ProcessObjectType::GetInput(0)); } /** * */ template void ImageToPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } /** * copy information from first input to all outputs * This is a void implementation to prevent the * ProcessObject version to be called */ template void ImageToPointSetFilter ::GenerateOutputInformation() { } /** * GenerateData */ template void ImageToPointSetFilter ::GenerateData(void) { PointsContainerType * outputPointsContainer = this->GetOutput()->GetPoints(); outputPointsContainer->Initialize(); PointDataContainerType * outputPointDataContainer = this->GetOutput()->GetPointData(); outputPointDataContainer->Initialize(); typename TInputImage::RegionType inputRegion = this->GetInput()->GetLargestPossibleRegion(); // Input is an image, cast away the constness so we can set // the requested region. InputImagePointer input = const_cast (this->GetInput()); m_StreamingManager->PrepareStreaming(input,inputRegion); unsigned long numDivisions = m_StreamingManager->GetNumberOfSplits(); /** * Loop over the number of pieces, execute the upstream pipeline on each * piece, and copy the results into the output image. */ unsigned int piece; InputImageRegionType streamRegion; for (piece = 0; piece < numDivisions && !this->GetAbortGenerateData(); piece++) { streamRegion = m_StreamingManager->GetSplit(piece); typedef itk::ImageToImageFilterDetail::ImageRegionCopier OutputToInputRegionCopierType; OutputToInputRegionCopierType regionCopier; InputImageRegionType inputRegion2; regionCopier(inputRegion2, streamRegion); input->SetRequestedRegion(inputRegion2); // Call a method that can be overridden by a subclass to perform // some calculations prior to splitting the main computations into // separate threads this->BeforeThreadedGenerateData(); // Set up the multithreaded processing ThreadStruct str; str.Filter = this; // Initializing object per thread typename PointsContainerType::Pointer defaultPointsContainer = PointsContainerType::New(); this->m_PointsContainerPerThread = OutputPointsContainerForThreadType(this->GetNumberOfThreads(), defaultPointsContainer); typename PointDataContainerType::Pointer defaultPointDataContainer = PointDataContainerType::New(); this->m_PointDataContainerPerThread = OutputPointDataContainerForThreadType(this->GetNumberOfThreads(), defaultPointDataContainer); // Setting up multithreader this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads()); this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str); // multithread the execution this->GetMultiThreader()->SingleMethodExecute(); // Call a method that can be overridden by a subclass to perform // some calculations after all the threads have completed this->AfterThreadedGenerateData(); } } template void ImageToPointSetFilter ::BeforeThreadedGenerateData(void) { } template void ImageToPointSetFilter ::AfterThreadedGenerateData(void) { // copy the lists to the output PointsContainerType * outputPointsContainer = this->GetOutput()->GetPoints(); unsigned long currentIndex = outputPointsContainer->Size(); typedef typename PointsContainerType::ConstIterator OutputPointsContainerIterator; for (unsigned int i = 0; i < this->m_PointsContainerPerThread.size(); ++i) { if (this->m_PointsContainerPerThread[i].IsNotNull()) { for (OutputPointsContainerIterator it = this->m_PointsContainerPerThread[i]->Begin(); it != this->m_PointsContainerPerThread[i]->End(); ++it) { outputPointsContainer->InsertElement(currentIndex,it.Value()); ++currentIndex; } } } PointDataContainerType * outputPointDataContainer = this->GetOutput()->GetPointData(); currentIndex = outputPointDataContainer->Size(); typedef typename PointDataContainerType::ConstIterator OutputPointDataContainerIterator; for (unsigned int i = 0; i < this->m_PointDataContainerPerThread.size(); ++i) { if (this->m_PointDataContainerPerThread[i].IsNotNull()) { for (OutputPointDataContainerIterator it = this->m_PointDataContainerPerThread[i]->Begin(); it != this->m_PointDataContainerPerThread[i]->End(); ++it) { outputPointDataContainer->InsertElement(currentIndex,it.Value()); ++currentIndex; } } } } template void ImageToPointSetFilter ::ThreadedGenerateData(const InputImageRegionType&, itk::ThreadIdType) { // The following code is equivalent to: // itkExceptionMacro("subclass should ITK_OVERRIDE this method!!!"); // The ExceptionMacro is not used because gcc warns that a // 'noreturn' function does return std::ostringstream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "Subclass should ITK_OVERRIDE this method!!!"; itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); throw e_; } template ITK_THREAD_RETURN_TYPE ImageToPointSetFilter ::ThreaderCallback(void *arg) { ThreadStruct *str; unsigned int total, threadCount; itk::ThreadIdType threadId; threadId = ((itk::MultiThreader::ThreadInfoStruct *) (arg))->ThreadID; threadCount = ((itk::MultiThreader::ThreadInfoStruct *) (arg))->NumberOfThreads; str = (ThreadStruct *) (((itk::MultiThreader::ThreadInfoStruct *) (arg))->UserData); // execute the actual method with appropriate output region // first find out how many pieces extent can be split into. typename TInputImage::RegionType splitRegion; total = str->Filter->SplitRequestedRegion(threadId, threadCount, splitRegion); if (threadId < total) { str->Filter->ThreadedGenerateData(splitRegion, threadId); } // else // { // otherwise don't use this thread. Sometimes the threads don't // break up very well and it is just as efficient to leave a // few threads idle. // } return ITK_THREAD_RETURN_VALUE; } template int ImageToPointSetFilter ::SplitRequestedRegion(int i, int num, InputImageRegionType& splitRegion) { // Get the output pointer typename InputImageType::ConstPointer inputPtr = this->GetInput(); const typename TInputImage::SizeType& requestedRegionSize = inputPtr->GetRequestedRegion().GetSize(); int splitAxis; typename TInputImage::IndexType splitIndex; typename TInputImage::SizeType splitSize; // Initialize the splitRegion to the output requested region splitRegion = inputPtr->GetRequestedRegion(); splitIndex = splitRegion.GetIndex(); splitSize = splitRegion.GetSize(); // split on the outermost dimension available splitAxis = inputPtr->GetImageDimension() - 1; while (requestedRegionSize[splitAxis] == 1) { --splitAxis; if (splitAxis < 0) { // cannot split itkDebugMacro(" Cannot Split"); return 1; } } // determine the actual number of pieces that will be generated typename TInputImage::SizeType::SizeValueType range = requestedRegionSize[splitAxis]; int valuesPerThread = (int) ::vcl_ceil(range / (double) num); int maxThreadIdUsed = (int) ::vcl_ceil(range / (double) valuesPerThread) - 1; // Split the region if (i < maxThreadIdUsed) { splitIndex[splitAxis] += i * valuesPerThread; splitSize[splitAxis] = valuesPerThread; } if (i == maxThreadIdUsed) { splitIndex[splitAxis] += i * valuesPerThread; // last thread needs to process the "rest" dimension being split splitSize[splitAxis] = splitSize[splitAxis] - i * valuesPerThread; } // set the split region ivars splitRegion.SetIndex(splitIndex); splitRegion.SetSize(splitSize); itkDebugMacro(" Split Piece: " << splitRegion); return maxThreadIdUsed + 1; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetAndValuesFunction.h000066400000000000000000000072311301006202600270450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetAndValuesFunction_h #define otbPointSetAndValuesFunction_h #include "itkFunctionBase.h" #include "itkContinuousIndex.h" #include "itkVectorContainer.h" #include "itkPointSet.h" namespace otb { /** \class PointSetAndValuesFunction * \brief Base class for function needing a point set and a set of associated value to compute the output. * * \ingroup OTBPointSet */ template class ITK_EXPORT PointSetAndValuesFunction : public itk::FunctionBase, TValue> { public: /** Standard typedefs */ typedef PointSetAndValuesFunction Self; typedef itk::FunctionBase< itk::Point, TValue > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkTypeMacro(PointSetAndValuesFunction, itk::FunctionBase); typedef TPointSet PointSetType; typedef typename PointSetType::ConstPointer PointSetConstPointerType; typedef TValue ValueType; typedef TCoordRep CoordRepType; typedef typename PointSetType::PointType PointType; typedef itk::Index IndexType; typedef itk::ContinuousIndex ContinuousIndexType; typedef itk::VectorContainer ValueVectorType; typedef typename ValueVectorType::ConstPointer ValueVectorPointerType; itkSetObjectMacro(ValueVector, ValueVectorType); itkGetObjectMacro(ValueVector, ValueVectorType); /** * Set the point set. * \param the point set */ virtual void SetPointSet(const PointSetType * ptr); /** * Get the point set. * \return the point set */ const PointSetType * GetPointSet() const { return m_PointSet.GetPointer(); } /** Evaluate the function at specified Point position. * Subclasses must provide this method. */ virtual TValue Evaluate(const PointType& point) const = 0; /** Evaluate the function at specified Index position. * Subclasses must provide this method. */ virtual TValue EvaluateAtIndex(const IndexType& index) const = 0; /** Evaluate the function at specified ContinuousIndex position. * Subclasses must provide this method. */ virtual TValue EvaluateAtContinuousIndex(const ContinuousIndexType& index) const = 0; protected: /** Constructor */ PointSetAndValuesFunction() { m_PointSet = PointSetType::New(); m_ValueVector = ValueVectorType::New(); } /** Destructor */ virtual ~PointSetAndValuesFunction() {} /**PrintSelf method */ virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; private: PointSetAndValuesFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** PointSet */ PointSetConstPointerType m_PointSet; /** value vector */ ValueVectorPointerType m_ValueVector; }; } // End namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetExtractROI.h000066400000000000000000000062121301006202600254370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetExtractROI_h #define otbPointSetExtractROI_h #include "otbPointSetToPointSetFilter.h" #include "itkTransform.h" namespace otb { /** \class PointSetExtractROI * \brief Extract a part of the points specified by a region * * PointSetExtractROI extract all the points of a PointSet that are * in a given region. * * The additional content of the PointSet is passed untouched. * * * \ingroup PointSetFilters * * \ingroup OTBPointSet */ template class ITK_EXPORT PointSetExtractROI : public PointSetToPointSetFilter { public: /** Standard class typedefs. */ typedef PointSetExtractROI Self; typedef PointSetToPointSetFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputPointSet InputPointSetType; typedef TOutputPointSet OutputPointSetType; typedef typename InputPointSetType::Pointer InputPointSetPointer; typedef typename OutputPointSetType::Pointer OutputPointSetPointer; /** Type for representing coordinates. */ typedef typename TInputPointSet::CoordRepType CoordRepType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PointSetExtractROI, PointSetToPointSetFilter); /** Set/Get Start methods */ itkGetMacro(StartX, unsigned long); itkGetMacro(StartY, unsigned long); itkSetMacro(StartX, unsigned long); itkSetMacro(StartY, unsigned long); /** Set/Get Size methods */ itkGetMacro(SizeX, unsigned long); itkGetMacro(SizeY, unsigned long); itkSetMacro(SizeX, unsigned long); itkSetMacro(SizeY, unsigned long); protected: PointSetExtractROI(); ~PointSetExtractROI() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Generate Requested Data */ void GenerateData(void) ITK_OVERRIDE; private: PointSetExtractROI(const PointSetExtractROI &); //purposely not implemented void operator =(const PointSetExtractROI&); //purposely not implemented /** X/Y coordinates of the first point of the region to extract. */ unsigned long m_StartX; unsigned long m_StartY; /** Size in X/Y of the region to extract. */ unsigned long m_SizeX; unsigned long m_SizeY; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetExtractROI.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetExtractROI.txx000066400000000000000000000070121301006202600260320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetExtractROI_txx #define otbPointSetExtractROI_txx #include "otbPointSetExtractROI.h" #include "itkMacro.h" namespace otb { /** * */ template PointSetExtractROI ::PointSetExtractROI() { } /** * */ template void PointSetExtractROI ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } /** * This method causes the filter to generate its output. */ template void PointSetExtractROI ::GenerateData(void) { typedef typename TInputPointSet::PointsContainer InputPointsContainer; typedef typename TInputPointSet::PointsContainerPointer InputPointsContainerPointer; typedef typename TOutputPointSet::PointsContainerPointer OutputPointsContainerPointer; typedef typename TInputPointSet::PointDataContainerPointer InputPointDataContainerPointer; typedef typename TOutputPointSet::PointDataContainerPointer OutputPointDataContainerPointer; InputPointSetPointer inputPointSet = this->GetInput(); OutputPointSetPointer outputPointSet = this->GetOutput(); if (!inputPointSet) { itkExceptionMacro(<< "Missing Input PointSet"); } if (!outputPointSet) { itkExceptionMacro(<< "Missing Output PointSet"); } outputPointSet->SetBufferedRegion(outputPointSet->GetRequestedRegion()); //TODO update outputRegion InputPointsContainerPointer inPoints = inputPointSet->GetPoints(); InputPointDataContainerPointer inData = inputPointSet->GetPointData(); OutputPointsContainerPointer outPoints = outputPointSet->GetPoints(); OutputPointDataContainerPointer outData = outputPointSet->GetPointData(); typename InputPointsContainer::ConstIterator inputPoint = inPoints->Begin(); // Commented cause using iterator on the pointSetData crash // Use a direct access to pointSet Data instead to avoid segfault //typename InputPointDataContainer::ConstIterator inputData = inData->Begin(); //if (inData.IsNotNull()) // { // inputData = inData->Begin(); // } while (inputPoint != inPoints->End()) { typename InputPointsContainer::Element point = inputPoint.Value(); if ((((point[0] >= m_StartX) && (point[0] < m_StartX + m_SizeX)) || ((point[0] <= m_StartX) && (point[0] > m_StartX + m_SizeX))) //cover the case when size<0 && (((point[1] >= m_StartY) && (point[1] < m_StartY + m_SizeY)) || ((point[1] <= m_StartY) && (point[1] > m_StartY + m_SizeY)))) { // Add the point outPoints->push_back(point); // Get & Add the data typename InputPointSetType::PixelType data; inputPointSet->GetPointData(inputPoint.Index(), &data); outData->push_back(data/*inputData.Value()*/); } ++inputPoint; //++inputData; } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetFunction.h000066400000000000000000000045771301006202600252540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetFunction_h #define otbPointSetFunction_h #include "itkSpatialFunction.h" #include "itkProcessObject.h" namespace otb { /** * \class PointSetFunction * \brief Calculate the density in the neighborhood of a pixel * * \ingroup SpatialFunctions * * \ingroup OTBPointSet */ template class ITK_EXPORT PointSetFunction : public itk::SpatialFunction { public: /** Standard class typedefs. */ typedef PointSetFunction Self; typedef itk::SpatialFunction Superclass; /** Run-time type information (and related methods). */ itkTypeMacro(PointSetFunction, itk::SpatialFunction); /** PointSet Type typedef Support*/ typedef TPointSet PointSetType; typedef typename PointSetType::ConstPointer PointSetPointerType; /** TOutput typedef suppoty*/ typedef TOutput OutputType; /** Set the input image (reimplemented since we need to set the detector input) */ itkGetConstObjectMacro(PointSet, PointSetType); void SetPointSet(PointSetType * PointSet) { m_PointSet = PointSet; } /** SetPointSet() to maintain the const correctness of the pointset*/ void SetPointSet(PointSetPointerType PointSet) { m_PointSet = PointSet; } protected: PointSetFunction(); ~PointSetFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PointSetFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented PointSetPointerType m_PointSet; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetFunction.txx000066400000000000000000000031531301006202600256350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetFunction_txx #define otbPointSetFunction_txx #include "otbPointSetFunction.h" #include "itkNumericTraits.h" #include "itkConstNeighborhoodIterator.h" namespace otb { /** * Constructor */ template PointSetFunction ::PointSetFunction() { m_PointSet = PointSetType::New(); } /** * */ template void PointSetFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } // /** // * SetDetector method // */ // template // void // PointSetFunction< TPointSet, TOutput> // ::SetPointSet(PointSetType* PointSet) const // { // m_PointSet = PointSet; // } // /** // * GetDetector method // */ // template // const // typename PointSetFunction< TPointSet, TOutput> // ::PointSetType * // PointSetFunction< TPointSet, TOutput> // ::GetPointSet() const // { // return m_PointSet; // } } // end namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetSource.h000066400000000000000000000144311301006202600247150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetSource_h #define otbPointSetSource_h #include "itkProcessObject.h" namespace otb { /** \class PointSetSource * \brief Base class for all process objects that output point set data. * * PointSetSource is the base class for all process objects that output * point set data. Specifically, this class defines the GetOutput() method * that returns a pointer to the output point set. The class also defines * some internal private data members that are used to manage streaming * of data. * * \ingroup DataSources * * \ingroup OTBPointSet */ template class ITK_EXPORT PointSetSource : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef PointSetSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PointSetSource, itk::ProcessObject); /** Some convenient typedefs. */ typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef itk::DataObject::Pointer DataObjectPointer; typedef TOutputPointSet OutputPointSetType; typedef typename OutputPointSetType::Pointer OutputPointSetPointer; typedef typename OutputPointSetType::PointsContainer PointsContainerType; typedef typename OutputPointSetType::PointDataContainer PointDataContainerType; /** Get the point set output of this process object. */ OutputPointSetType * GetOutput(void); OutputPointSetType * GetOutput(DataObjectPointerArraySizeType idx); /** Set the point set output of this process object. This call is slated * to be removed from ITK. You should GraftOutput() and possible * DataObject::DisconnectPipeline() to properly change the output. */ void SetOutput(OutputPointSetType *output); using Superclass::SetOutput; /** Graft the specified DataObject onto this ProcessObject's output. * This method grabs a handle to the specified DataObject's bulk * data to used as its output's own bulk data. It also copies the * region ivars (RequestedRegion, BufferedRegion, * LargestPossibleRegion) and meta-data (Spacing, Origin) from the * specified data object into this filter's output data object. Most * importantly, however, it leaves the Source ivar untouched so the * original pipeline routing is intact. This method is used when a * process object is implemented using a mini-pipeline which is * defined in its GenerateData() method. The usage is: * * \code * // setup the mini-pipeline to process the input to this filter * firstFilterInMiniPipeline->SetInput( this->GetInput() ); * * // setup the mini-pipeline to calculate the correct regions * // and write to the appropriate bulk data block * lastFilterInMiniPipeline->GraftOutput( this->GetOutput() ); * * // execute the mini-pipeline * lastFilterInMiniPipeline->Update(); * * // graft the mini-pipeline output back onto this filter's output. * // this is needed to get the appropriate regions passed back. * this->GraftOutput( lastFilterInMiniPipeline->GetOutput() ); * \endcode * * For proper pipeline execution, a filter using a mini-pipeline * must implement the GenerateInputRequestedRegion(), * GenerateOutputRequestedRegion(), GenerateOutputInformation() and * EnlargeOutputRequestedRegion() methods as necessary to reflect * how the mini-pipeline will execute (in other words, the outer * filter's pipeline mechanism must be consistent with what the * mini-pipeline will do). */ virtual void GraftOutput(itk::DataObject *output); virtual void GraftNthOutput(DataObjectPointerArraySizeType idx, itk::DataObject *output); /** Make a DataObject of the correct type to used as the specified * output. Every ProcessObject subclass must be able to create a * DataObject that can be used as a specified output. This method * is automatically called when DataObject::DisconnectPipeline() is * called. DataObject::DisconnectPipeline, disconnects a data object * from being an output of its current source. When the data object * is disconnected, the ProcessObject needs to construct a replacement * output data object so that the ProcessObject is in a valid state. * So DataObject::DisconnectPipeline eventually calls * ProcessObject::MakeOutput. Note that MakeOutput always returns a * SmartPointer to a DataObject. If a subclass of MeshSource has * multiple outputs of different types, then that class must provide * an implementation of MakeOutput(). */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; protected: PointSetSource(); ~PointSetSource() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Requested region of Point Set is specified as i of N unstructured regions. * Since all DataObjects should be able to set the requested region in * unstructured form, just copy output->RequestedRegion all inputs. */ void GenerateInputRequestedRegion() ITK_OVERRIDE; private: PointSetSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Used by streaming: The requested region of the output being processed * by the execute method. Set in the GenerateInputRequestedRegion method. */ int m_GenerateDataRegion; int m_GenerateDataNumberOfRegions; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetSource.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetSource.txx000066400000000000000000000067611301006202600253200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetSource_txx #define otbPointSetSource_txx #include "otbPointSetSource.h" namespace otb { /** * */ template PointSetSource ::PointSetSource() { // Create the output. We use static_cast<> here because we know the default // output must be of type TOutputPointSet OutputPointSetPointer output = static_cast(this->MakeOutput(0).GetPointer()); this->ProcessObject::SetNumberOfRequiredOutputs(1); this->ProcessObject::SetNthOutput(0, output.GetPointer()); m_GenerateDataRegion = 0; m_GenerateDataNumberOfRegions = 0; } /** * */ template typename PointSetSource::DataObjectPointer PointSetSource ::MakeOutput(DataObjectPointerArraySizeType) { return static_cast(TOutputPointSet::New().GetPointer()); } /** * */ template typename PointSetSource::OutputPointSetType * PointSetSource ::GetOutput(void) { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } /** * */ template typename PointSetSource::OutputPointSetType * PointSetSource ::GetOutput(DataObjectPointerArraySizeType idx) { return static_cast (this->ProcessObject::GetOutput(idx)); } /** * */ template void PointSetSource ::SetOutput(OutputPointSetType *output) { itkWarningMacro( << "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead."); this->ProcessObject::SetNthOutput(0, output); } /** * */ template void PointSetSource ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); } /** * */ template void PointSetSource ::GraftOutput(itk::DataObject *graft) { this->GraftNthOutput(0, graft); } /** * */ template void PointSetSource ::GraftNthOutput(DataObjectPointerArraySizeType idx, itk::DataObject *graft) { if (idx >= this->GetNumberOfOutputs()) { itkExceptionMacro(<< "Requested to graft output " << idx << " but this filter only has " << this->GetNumberOfOutputs() << " Outputs."); } if (!graft) { itkExceptionMacro(<< "Requested to graft output that is a NULL pointer"); } itk::DataObject * output = this->GetOutput(idx); // Call Graft on the PointSet in order to copy meta-information, and containers. output->Graft(graft); } /** * */ template void PointSetSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetToPointSetFilter.h000066400000000000000000000057131301006202600266760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetToPointSetFilter_h #define otbPointSetToPointSetFilter_h #include "otbPointSetSource.h" #include "otbStreamingTraits.h" namespace otb { /** \class PointSetToPointSetFilter * \brief Base class to process PointSet data * * PointSetToPointSetFilter is the base class for all process objects that output * PointSet data and require a PointSet as input. Specifically, this class * defines the SetInput() method for defining the input to a filter. * * \ingroup PointSetFilters * * \ingroup OTBPointSet */ template class ITK_EXPORT PointSetToPointSetFilter : public PointSetSource { public: /** Standard class typedefs. */ typedef PointSetToPointSetFilter Self; typedef PointSetSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(PointSetToPointSetFilter, PointSetSource); /** Some Image related typedefs. */ typedef TInputPointSet InputPointSetType; typedef typename InputPointSetType::Pointer InputPointSetPointer; typedef typename InputPointSetType::ConstPointer InputPointSetConstPointer; /** Some PointSet related typedefs. */ typedef typename Superclass::OutputPointSetType OutputPointSetType; typedef typename Superclass::OutputPointSetPointer OutputPointSetPointer; typedef typename Superclass::PointsContainerType PointsContainerType; typedef itk::ProcessObject ProcessObjectType; /** Set the input image of this process object. */ using Superclass::SetInput; void SetInput(unsigned int idx, const InputPointSetType *input); void SetInput(const InputPointSetType *input); /** Get the input image of this process object. */ InputPointSetType * GetInput(unsigned int idx); InputPointSetType * GetInput(); protected: PointSetToPointSetFilter(); ~PointSetToPointSetFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PointSetToPointSetFilter(const PointSetToPointSetFilter &); //purposely not implemented void operator =(const PointSetToPointSetFilter&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetToPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbPointSetToPointSetFilter.txx000066400000000000000000000052741301006202600272740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetToPointSetFilter_txx #define otbPointSetToPointSetFilter_txx #include "otbPointSetToPointSetFilter.h" namespace otb { /** * */ template PointSetToPointSetFilter ::PointSetToPointSetFilter() { this->SetNumberOfRequiredInputs(1); } /** * */ template void PointSetToPointSetFilter ::SetInput(unsigned int idx, const InputPointSetType *input) { // process object is not const-correct, the const_cast // is required here. this->ProcessObjectType::SetNthInput(idx, const_cast(input)); this->GetInput()->ReleaseDataFlagOff(); } /** * */ template void PointSetToPointSetFilter ::SetInput(const InputPointSetType *input) { // process object is not const-correct, the const_cast // is required here. this->ProcessObjectType::SetNthInput(0, const_cast(input)); this->GetInput()->ReleaseDataFlagOff(); } /** * */ template typename PointSetToPointSetFilter::InputPointSetType * PointSetToPointSetFilter ::GetInput(unsigned int idx) { return static_cast (this->ProcessObjectType::GetInput(idx)); } /** * */ template typename PointSetToPointSetFilter::InputPointSetType * PointSetToPointSetFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) return ITK_NULLPTR; return static_cast (this->ProcessObjectType::GetInput(0)); } /** * */ template void PointSetToPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbRandomPointSetSource.h000066400000000000000000000063721301006202600260630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRandomPointSetSource_h #define otbRandomPointSetSource_h #include "otbPointSetSource.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { /** \class RandomPointSetSource * \brief This class generate a random point set * * A point set with a specific number of points is generated as an output * of this filter. The point are N dimensional, depending on the specified template. * * The coordinate value of the point is uniformly distributed and the maximum and * minimum value for the range in each dimension is provided by the * \code SetMinPoint \endcode and \code SetMaxPoint \endcode methods. * * \ingroup DataSources * * \ingroup OTBPointSet */ template class ITK_EXPORT RandomPointSetSource : public PointSetSource { public: /** Standard class typedefs. */ typedef RandomPointSetSource Self; typedef PointSetSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self) /** Run-time type information (and related methods). */ itkTypeMacro(RandomPointSetSource, PointSetSource) /** Some convenient typedefs. */ typedef itk::DataObject::Pointer DataObjectPointer; typedef TOutputPointSet OutputPointSetType; typedef typename OutputPointSetType::Pointer OutputPointSetPointer; typedef typename OutputPointSetType::PointsContainer PointsContainerType; typedef typename PointsContainerType::Pointer PointsContainerPointer; typedef typename OutputPointSetType::PointType PointType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator GeneratorType; typedef GeneratorType::Pointer GeneratorPointerType; typedef GeneratorType::IntegerType SeedType; itkSetMacro(NumberOfPoints, unsigned int) itkGetMacro(NumberOfPoints, unsigned int) itkSetMacro(MinPoint, PointType) itkGetMacro(MinPoint, PointType) itkSetMacro(MaxPoint, PointType) itkGetMacro(MaxPoint, PointType) void SetSeed(SeedType seed) { m_Generator->SetSeed(seed); } protected: RandomPointSetSource(); ~RandomPointSetSource() ITK_OVERRIDE {} void GenerateData(void) ITK_OVERRIDE; private: RandomPointSetSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfPoints; GeneratorPointerType m_Generator; PointType m_MinPoint; PointType m_MaxPoint; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbRandomPointSetSource.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbRandomPointSetSource.txx000066400000000000000000000032161301006202600264510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRandomPointSetSource_txx #define otbRandomPointSetSource_txx #include "otbRandomPointSetSource.h" namespace otb { template RandomPointSetSource ::RandomPointSetSource() { m_NumberOfPoints = 1; m_Generator = GeneratorType::New(); m_Generator->Initialize(); m_MinPoint.Fill(0.0); m_MaxPoint.Fill(1.0); } //init seed template void RandomPointSetSource ::GenerateData(void) { OutputPointSetPointer outputPointSet = this->GetOutput(); outputPointSet->Initialize(); PointsContainerPointer outPoints = outputPointSet->GetPoints(); outPoints->Reserve(m_NumberOfPoints); typename PointsContainerType::Iterator outputPoint = outPoints->Begin(); while (outputPoint != outPoints->End()) { PointType point; for (unsigned int i = 0; i < OutputPointSetType::PointDimension; ++i) { double v = m_Generator->GetVariateWithClosedRange(1.0); point[i] = (1.0 - v) * m_MinPoint[i] + v * m_MaxPoint[i]; } outputPoint.Value() = point; ++outputPoint; } } } #endif OTB-release-5.8/Modules/Core/PointSet/include/otbSimplePointCountStrategy.h000066400000000000000000000036441301006202600267720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimplePointCountStrategy_h #define otbSimplePointCountStrategy_h #include "otbMath.h" namespace otb { /** \class Count * \brief Compute the density of a neighboorhood centerred in a pixel * * This filter is templated over the pixel type of the input image * and the pixel type of the output image. * * The filter will walk over all the pixels in the input image, and for * each one of them it will do the following: * * \ingroup OTBPointSet */ template class Count { public: Count() {} ~Count() {} inline float operator ()(const TPointSet * pointSet, const TRadiusType& size, const TIndexType& index) { int accu = 0; double surface = CONST_PI * size * size; if (pointSet->GetNumberOfPoints() != 0) { typedef typename TPointSet::PointsContainer::ConstIterator iteratorType; iteratorType it = pointSet->GetPoints()->Begin(); while (it != pointSet->GetPoints()->End()) { float distX2 = (index[0] - it.Value()[0]) * (index[0] - it.Value()[0]); float distY2 = (index[1] - it.Value()[1]) * (index[1] - it.Value()[1]); float dist = vcl_sqrt(distX2 + distY2); if (dist <= size) accu++; ++it; } } else return 0.; return static_cast(accu / surface); } }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbThresholdImageToPointSetFilter.h000066400000000000000000000071151301006202600300260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbThresholdImageToPointSetFilter_h #define otbThresholdImageToPointSetFilter_h #include "otbImageToPointSetFilter.h" #include "itkPointSet.h" #include "itkConceptChecking.h" namespace otb { /** \class ThresholdImageToPointSetFilter * \brief Produce a PointSet according to filtering conditions * * * \ingroup OTBPointSet */ template > class ITK_EXPORT ThresholdImageToPointSetFilter : public ImageToPointSetFilter { public: itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); typedef TInputImage InputImageType; typedef ThresholdImageToPointSetFilter Self; typedef ImageToPointSetFilter Superclass; typedef typename Superclass::OutputPointSetType OutputPointSetType; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(ThresholdImageToPointSetFilter, ImageToPointSetFilter); typedef typename Superclass::InputImagePixelType InputPixelType; typedef typename Superclass::InputImagePointer InputImagePointer; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename Superclass::InputImageConstPointer InputImageConstPointer; typedef typename Superclass::InputImageType::SizeType SizeType; typedef typename Superclass::InputImageType::IndexType IndexType; typedef typename Superclass::OutputPointSetPointer OutputPointSetPointer; typedef typename Superclass::OutputPointSetType::PixelType OutputPointSetPixelType; typedef typename Superclass::PointsContainerType PointsContainerType; typedef typename Superclass::PointDataContainerType PointDataContainerType; #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(PixelConvertibleToPointSetDataType, (itk::Concept::Convertible)); #endif itkSetMacro(LowerThreshold, InputPixelType); itkGetConstReferenceMacro(LowerThreshold, InputPixelType); itkSetMacro(UpperThreshold, InputPixelType); itkGetConstReferenceMacro(UpperThreshold, InputPixelType); protected: ThresholdImageToPointSetFilter(); ~ThresholdImageToPointSetFilter() ITK_OVERRIDE {} void ThreadedGenerateData(const InputImageRegionType& inputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ThresholdImageToPointSetFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InputPixelType m_LowerThreshold; InputPixelType m_UpperThreshold; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbThresholdImageToPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbThresholdImageToPointSetFilter.txx000066400000000000000000000056211301006202600304220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbThresholdImageToPointSetFilter_txx #define otbThresholdImageToPointSetFilter_txx #include "otbThresholdImageToPointSetFilter.h" #include "itkImageRegionConstIterator.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template ThresholdImageToPointSetFilter ::ThresholdImageToPointSetFilter() { m_LowerThreshold = itk::NumericTraits::NonpositiveMin(); m_UpperThreshold = itk::NumericTraits::max(); } template void ThresholdImageToPointSetFilter ::ThreadedGenerateData(const InputImageRegionType& inputRegionForThread, itk::ThreadIdType threadId) { this->m_PointsContainerPerThread[threadId] = PointsContainerType::New(); this->m_PointDataContainerPerThread[threadId] = PointDataContainerType::New(); InputImageConstPointer inputPtr = this->GetInput(); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, inputRegionForThread); itk::ProgressReporter progress(this, threadId, inputRegionForThread.GetNumberOfPixels()); typename OutputPointSetType::PointType position; inputIt.GoToBegin(); unsigned long currentIndex = 0; while (!inputIt.IsAtEnd()) { const InputPixelType value = inputIt.Get(); if ((value >= m_LowerThreshold) && (value <= m_UpperThreshold)) { //FIXME: non valid for image with dim > 2 const IndexType index = inputIt.GetIndex(); position[0] = index[0]; position[1] = index[1]; this->m_PointsContainerPerThread[threadId]->InsertElement(currentIndex,position); this->m_PointDataContainerPerThread[threadId]->InsertElement(currentIndex,static_cast(value)); ++currentIndex; } ++inputIt; progress.CompletedPixel(); // potential exception thrown here } } /** * Standard "PrintSelf" method */ template void ThresholdImageToPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "LowerThreshold : " << m_LowerThreshold << std::endl; os << indent << "UpperThreshold : " << m_UpperThreshold << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/PointSet/include/otbTransformPointSetFilter.h000066400000000000000000000057761301006202600266120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTransformPointSetFilter_h #define otbTransformPointSetFilter_h #include "otbPointSetToPointSetFilter.h" namespace otb { /** \class TransformPointSetFilter * \brief TransformPointSetFilter applies a transform to all the * points of a PointSet. * * The additional content of the PointSet is left untouched. * * PointSets that have added information like normal vector on the points, will * have to take care of transforming this data by other means. * * \ingroup PointSetFilters * * \ingroup OTBPointSet */ template class ITK_EXPORT TransformPointSetFilter : public PointSetToPointSetFilter { public: /** Standard class typedefs. */ typedef TransformPointSetFilter Self; typedef PointSetToPointSetFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputPointSet InputPointSetType; typedef TOutputPointSet OutputPointSetType; typedef typename InputPointSetType::Pointer InputPointSetPointer; typedef typename OutputPointSetType::Pointer OutputPointSetPointer; /** Type for representing coordinates. */ typedef typename TInputPointSet::CoordRepType CoordRepType; /** Type of the transform. */ typedef TTransform TransformType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TransformPointSetFilter, PointSetToPointSetFilter); /** Set transform. */ itkSetObjectMacro(Transform, TransformType); /** Get transform. */ itkGetObjectMacro(Transform, TransformType); protected: TransformPointSetFilter(); ~TransformPointSetFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Generate Requested Data */ void GenerateData(void) ITK_OVERRIDE; /** Transform to apply to all the PointSet points. */ typename TransformType::Pointer m_Transform; private: TransformPointSetFilter(const TransformPointSetFilter &); //purposely not implemented void operator =(const TransformPointSetFilter&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTransformPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/PointSet/include/otbTransformPointSetFilter.txx000066400000000000000000000060521301006202600271720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTransformPointSetFilter_txx #define otbTransformPointSetFilter_txx #include "otbTransformPointSetFilter.h" #include "itkMacro.h" namespace otb { /** * */ template TransformPointSetFilter ::TransformPointSetFilter() { m_Transform = TransformType::New(); } /** * */ template void TransformPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); if (m_Transform) { os << indent << "Transform: " << m_Transform << std::endl; } } /** * This method causes the filter to generate its output. */ template void TransformPointSetFilter ::GenerateData(void) { typedef typename TInputPointSet::PointsContainer InputPointsContainer; typedef typename TOutputPointSet::PointsContainer OutputPointsContainer; typedef typename TInputPointSet::PointsContainerPointer InputPointsContainerPointer; typedef typename TOutputPointSet::PointsContainerPointer OutputPointsContainerPointer; InputPointSetPointer inputPointSet = this->GetInput(); OutputPointSetPointer outputPointSet = this->GetOutput(); if (!inputPointSet) { itkExceptionMacro(<< "Missing Input PointSet"); } if (!outputPointSet) { itkExceptionMacro(<< "Missing Output PointSet"); } outputPointSet->SetBufferedRegion(outputPointSet->GetRequestedRegion()); InputPointsContainerPointer inPoints = inputPointSet->GetPoints(); OutputPointsContainerPointer outPoints = outputPointSet->GetPoints(); outPoints->Reserve(inputPointSet->GetNumberOfPoints()); outPoints->Squeeze(); // in case the previous PointSet had // allocated a larger memory typename InputPointsContainer::ConstIterator inputPoint = inPoints->Begin(); typename OutputPointsContainer::Iterator outputPoint = outPoints->Begin(); while (inputPoint != inPoints->End()) { outputPoint.Value() = m_Transform->TransformPoint(inputPoint.Value()); ++inputPoint; ++outputPoint; } // Create duplicate references to the rest of data on the PointSet outputPointSet->SetPointData(inputPointSet->GetPointData()); //TODO validate that we are copying everything } } // end namespace itk #endif OTB-release-5.8/Modules/Core/PointSet/otb-module.cmake000066400000000000000000000012741301006202600225400ustar00rootroot00000000000000set(DOCUMENTATION "This module is related to the handling of point sets. For instance, it contains the base class 'otb::ImageToPointSetFilter' from which inherit detectors such as Harris (note that contrary to the 'corner' module, here the harris detector outputs a point set instead of an image.). With this module, users will be able to apply a transform to all the points of a PointSet, extract all the points of a PointSet that are in a given region, generate a random point set, and so on.") otb_module(OTBPointSet DEPENDS OTBStreaming OTBInterpolation OTBITK OTBCommon TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/PointSet/test/000077500000000000000000000000001301006202600204425ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/PointSet/test/CMakeLists.txt000066400000000000000000000053341301006202600232070ustar00rootroot00000000000000otb_module_test() set(OTBPointSetTests otbPointSetTestDriver.cxx otbPointSetSourceTest.cxx otbPointSetExtractROITest.cxx otbSimplePointCountStrategyTest.cxx otbThresholdImageToPointSetFilterNew.cxx otbRandomPointSetSourceTest.cxx otbImageToPointSetFilterTest.cxx otbTransformPointSetFilterTest.cxx otbThresholdImageToPointSetTest.cxx ) add_executable(otbPointSetTestDriver ${OTBPointSetTests}) target_link_libraries(otbPointSetTestDriver ${OTBPointSet-Test_LIBRARIES}) otb_module_target_label(otbPointSetTestDriver) # Tests Declaration otb_add_test(NAME coTuPointSetSource COMMAND otbPointSetTestDriver otbPointSetSourceTest) otb_add_test(NAME bfTvPointSetExtractROI COMMAND otbPointSetTestDriver otbPointSetExtractROITest) otb_add_test(NAME feTvSimplePointCountStrategyTest COMMAND otbPointSetTestDriver otbSimplePointCountStrategyTest) otb_add_test(NAME feTuThresholdImageToPointSetFilterNew COMMAND otbPointSetTestDriver otbThresholdImageToPointSetFilterNew ) otb_add_test(NAME bfTvRandomPointSetSource COMMAND otbPointSetTestDriver otbRandomPointSetSourceTest) otb_add_test(NAME bfTuImageToPointSetFilterTest COMMAND otbPointSetTestDriver otbImageToPointSetFilterTest) otb_add_test(NAME bfTvTransformPointSetFilter COMMAND otbPointSetTestDriver otbTransformPointSetFilterTest) otb_add_test(NAME feTvThresholdImageToPointSet1 COMMAND otbPointSetTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feThresholdImageToPointSet_Threshold_0To255.txt ${TEMP}/feThresholdImageToPointSet_Threshold_0To255.txt otbThresholdImageToPointSetTest ${INPUTDATA}/small_points.hdr ${TEMP}/feThresholdImageToPointSet_Threshold_0To255.txt 0 255 ) otb_add_test(NAME feTvThresholdImageToPointSet2 COMMAND otbPointSetTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feThresholdImageToPointSet_Threshold_0To0.txt ${TEMP}/feThresholdImageToPointSet_Threshold_0To0.txt otbThresholdImageToPointSetTest ${INPUTDATA}/small_points.hdr ${TEMP}/feThresholdImageToPointSet_Threshold_0To0.txt 0 0 ) otb_add_test(NAME feTvThresholdImageToPointSet3 COMMAND otbPointSetTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feThresholdImageToPointSet_Threshold_255To255.txt ${TEMP}/feThresholdImageToPointSet_Threshold_255To255.txt otbThresholdImageToPointSetTest ${INPUTDATA}/small_points.hdr ${TEMP}/feThresholdImageToPointSet_Threshold_255To255.txt 255 255 ) otb_add_test(NAME feTvThresholdImageToPointSet4 COMMAND otbPointSetTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feThresholdImageToPointSet_Threshold_1To200.txt ${TEMP}/feThresholdImageToPointSet_Threshold_1To200.txt otbThresholdImageToPointSetTest ${INPUTDATA}/small_points.hdr ${TEMP}/feThresholdImageToPointSet_Threshold_1To200.txt 1 200 ) OTB-release-5.8/Modules/Core/PointSet/test/otbImageToPointSetFilterTest.cxx000066400000000000000000000020231301006202600267110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToPointSetFilter.h" #include "otbImage.h" #include "itkPointSet.h" int otbImageToPointSetFilterTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { /* const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PointSet PointSetType; //FunctionType::Pointer function = FunctionType::New(); */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/test/otbPointSetExtractROITest.cxx000066400000000000000000000054421301006202600262120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPointSetExtractROI.h" #include "itkPointSet.h" #include "otbRandomPointSetSource.h" int otbPointSetExtractROITest(int, char*[]) { typedef float PixelType; typedef itk::PointSet PointSetType; typedef PointSetType::PointsContainer PointsContainerType; typedef PointSetType::PointType PointType; typedef otb::RandomPointSetSource PointSetSource; PointSetSource::Pointer pointSetSource = PointSetSource::New(); pointSetSource->SetNumberOfPoints(1000); PointSetType::PointType maxPoint; maxPoint[0] = 1000; maxPoint[1] = 1000; pointSetSource->SetMaxPoint(maxPoint); pointSetSource->SetSeed(152002); pointSetSource->Update(); std::cout << "Input PointSet has " << pointSetSource->GetOutput()->GetNumberOfPoints(); std::cout << " points " << std::endl; typedef otb::PointSetExtractROI FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput(pointSetSource->GetOutput()); filter->SetStartX(450); filter->SetStartY(450); filter->SetSizeX(100); filter->SetSizeY(100); filter->Update(); std::cout << "Keeping points from " << filter->GetStartX() << ", " << filter->GetStartY() << std::endl; std::cout << "with a region size of " << filter->GetSizeX() << ", " << filter->GetSizeY() << std::endl; //Output the result // Get the Smart Pointer to the Filter Output PointSetType::Pointer outputPointSet = filter->GetOutput(); std::cout << "Output PointSet has " << outputPointSet->GetNumberOfPoints(); std::cout << " points " << std::endl; // Get the the point container PointSetType::PointsContainerPointer extractedPoints = outputPointSet->GetPoints(); PointsContainerType::ConstIterator it = extractedPoints->Begin(); while (it != extractedPoints->End()) { PointType p = it.Value(); std::cout.width(5); std::cout << p[0] << ", "; std::cout.width(5); std::cout << p[1] << std::endl; ++it; } // All objects should be automatically destroyed at this point if (outputPointSet->GetNumberOfPoints() != 6) { std::cout << "Wrong number of point in the output" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/test/otbPointSetSourceTest.cxx000066400000000000000000000044161301006202600254660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkPointSet.h" #include "otbPointSetSource.h" #include "itkMacro.h" int otbPointSetSourceTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Declare the PointSet pixel type. // Those are the values associated // with each PointSet point. (not used on this filter test) typedef int PixelType; // Declare the types of the PointSet typedef itk::PointSet PointSetType; // Declare the type for PointsContainer typedef PointSetType::PointsContainer PointsContainerType; // Declare the type for PointsContainerPointer typedef PointSetType::PointsContainerPointer PointsContainerPointer; // Declare the type for Points typedef PointSetType::PointType PointType; // Create an input Point Set PointSetType::Pointer inputPointSet = PointSetType::New(); // Insert data on the PointSet PointsContainerPointer points = inputPointSet->GetPoints(); // Fill a square with points , just to get some data int n = 1; // let's start with a few of them PointsContainerType::ElementIdentifier count = 0; // count them for (int x = -n; x <= n; x++) { for (int y = -n; y <= n; y++) { PointType p; p[0] = x; p[1] = y; std::cout << "Inserting point # "; std::cout.width(3); std::cout << count << " = "; std::cout.width(4); std::cout << p[0] << ", "; std::cout.width(4); std::cout << p[1] << std::endl; points->InsertElement(count, p); count++; } } std::cout << "Input PointSet has " << inputPointSet->GetNumberOfPoints(); std::cout << " points " << std::endl; // All objects should be automatically destroyed at this point return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/test/otbPointSetTestDriver.cxx000066400000000000000000000006571301006202600254640ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbPointSetSourceTest); REGISTER_TEST(otbPointSetExtractROITest); REGISTER_TEST(otbSimplePointCountStrategyTest); REGISTER_TEST(otbThresholdImageToPointSetFilterNew); REGISTER_TEST(otbRandomPointSetSourceTest); REGISTER_TEST(otbImageToPointSetFilterTest); REGISTER_TEST(otbTransformPointSetFilterTest); REGISTER_TEST(otbThresholdImageToPointSetTest); } OTB-release-5.8/Modules/Core/PointSet/test/otbRandomPointSetSourceTest.cxx000066400000000000000000000034251301006202600266260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRandomPointSetSource.h" #include "itkPointSet.h" int otbRandomPointSetSourceTest(int, char*[]) { typedef double PixelType; typedef itk::PointSet PointSetType; typedef otb::RandomPointSetSource PointSetSourceType; typedef PointSetType::PointsContainer PointsContainerType; PointSetSourceType::Pointer pointSet = PointSetSourceType::New(); pointSet->SetNumberOfPoints(10); PointSetType::PointType minPoint, maxPoint; minPoint[0] = 10; minPoint[1] = 20; pointSet->SetMinPoint(minPoint); maxPoint[0] = 100; maxPoint[1] = 50; pointSet->SetMaxPoint(maxPoint); //To get deterministic results pointSet->SetSeed(100); pointSet->Update(); // Get the the point container PointSetSourceType::PointsContainerPointer points = pointSet->GetOutput()->GetPoints(); PointsContainerType::ConstIterator it = points->Begin(); while (it != points->End()) { PointSetType::PointType p = it.Value(); std::cout.width(5); std::cout << p[0] << ", "; std::cout.width(5); std::cout << p[1] << std::endl; ++it; } // All objects should be automatically destroyed at this point return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/test/otbSimplePointCountStrategyTest.cxx000066400000000000000000000035011301006202600275310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSimplePointCountStrategy.h" #include "itkPointSet.h" #include "otbImage.h" #include "itkVariableLengthVector.h" int otbSimplePointCountStrategyTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float RealType; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef PointSetType::PointsContainer PointsContainerType; typedef ImageType::IndexType IndexType; typedef otb::Count counterType; /*pointSet de test*/ PointSetType::Pointer pointset = PointSetType::New(); PointsContainerType::ElementIdentifier count = 0; PointSetType::PointType Point; Point[0] = 12.14; Point[1] = 14.14; for (int i = 0; i < 10; ++i) { pointset->SetPoint(count, Point); count++; } /** Fin creation pointset de test */ /*Test du filtre*/ IndexType index; index[0] = 12; index[1] = 14; unsigned int rad = 2; counterType comptemoica; std::cout << "Le resultat retourne est " << comptemoica(pointset, rad, index) << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/test/otbThresholdImageToPointSetFilterNew.cxx000066400000000000000000000022621301006202600304050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbThresholdImageToPointSetFilter.h" #include "otbImage.h" #include int otbThresholdImageToPointSetFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PointSet PointSetType; typedef otb::ThresholdImageToPointSetFilter FilterThresholdType; FilterThresholdType::Pointer filter = FilterThresholdType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/test/otbThresholdImageToPointSetTest.cxx000066400000000000000000000047661301006202600274400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbThresholdImageToPointSetFilter.h" int otbThresholdImageToPointSetTest(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ThresholdImageToPointSetFilter FunctionType; typedef PointSetType::PointType PointType; typedef FunctionType::InputPixelType InputPixelType; typedef FunctionType::OutputPointSetType OutputPointSetType; InputPixelType LowerThreshold((InputPixelType) ::atoi(argv[3])); InputPixelType UpperThreshold((InputPixelType) ::atoi(argv[4])); ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer function = FunctionType::New(); reader->SetFileName(inputFilename); function->SetInput(0, reader->GetOutput()); function->SetLowerThreshold(LowerThreshold); function->SetUpperThreshold(UpperThreshold); function->Update(); OutputPointSetType * pointList = function->GetOutput(); std::ofstream file; file.open(outputFilename); unsigned long NbPoints = pointList->GetNumberOfPoints(); file << "NbPoints : " << NbPoints << std::endl; PointType CoordPoint; //Initialization CoordPoint.Fill(0); for (unsigned long i = 0; i < NbPoints; ++i) { pointList->GetPoint(i, &CoordPoint); file << i + 1 << "/" << NbPoints << " : " << CoordPoint[0] << " , " << CoordPoint[1] << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/PointSet/test/otbTransformPointSetFilterTest.cxx000066400000000000000000000077701301006202600273550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTransformPointSetFilter.h" #include "itkPointSet.h" #include "itkAffineTransform.h" int otbTransformPointSetFilterTest(int, char*[]) { // Declare the PointSet pixel type. // Those are the values associated // with each PointSet point. (not used on this filter test) typedef int PixelType; // Declare the types of the PointSet // By default it is a 3D PointSet using itk::Point // on the vertices, and an itk::VectorContainter // as containter for points typedef itk::PointSet PointSetType; // Declare the type for PointsContainer typedef PointSetType::PointsContainer PointsContainerType; // Declare the type for PointsContainerPointer typedef PointSetType::PointsContainerPointer PointsContainerPointer; // Declare the type for Points typedef PointSetType::PointType PointType; // Create an input PointSet PointSetType::Pointer inputPointSet = PointSetType::New(); // Insert data on the PointSet PointsContainerPointer points = inputPointSet->GetPoints(); // Fill a cube with points , just to get some data int n = 1; // let's start with a few of them PointsContainerType::ElementIdentifier count = 0; // count them for (int x = -n; x <= n; x++) { for (int y = -n; y <= n; y++) { for (int z = -n; z <= n; z++) { PointType p; p[0] = x; p[1] = y; p[2] = z; std::cout << "Inserting point # "; std::cout.width(3); std::cout << count << " = "; std::cout.width(4); std::cout << p[0] << ", "; std::cout.width(4); std::cout << p[1] << ", "; std::cout.width(4); std::cout << p[2] << std::endl; points->InsertElement(count, p); count++; } } } std::cout << "Input PointSet has " << inputPointSet->GetNumberOfPoints(); std::cout << " points " << std::endl; // Declare the transform type typedef itk::AffineTransform TransformType; // Declare the type for the filter typedef otb::TransformPointSetFilter< PointSetType, PointSetType, TransformType> FilterType; // Create a Filter FilterType::Pointer filter = FilterType::New(); // Create an Transform // (it doesn't use smart pointers) TransformType::Pointer affineTransform = TransformType::New(); affineTransform->Scale(3.5); TransformType::OffsetType::ValueType tInit[3] = {100, 200, 300}; TransformType::OffsetType translation = tInit; affineTransform->Translate(translation); // Connect the inputs filter->SetInput(inputPointSet); filter->SetTransform(affineTransform); // Execute the filter filter->Update(); std::cout << "Filter: " << filter; // Get the Smart Pointer to the Filter Output PointSetType::Pointer outputPointSet = filter->GetOutput(); std::cout << "Output PointSet has " << outputPointSet->GetNumberOfPoints(); std::cout << " points " << std::endl; // Get the the point container PointSetType::PointsContainerPointer transformedPoints = outputPointSet->GetPoints(); PointsContainerType::ConstIterator it = transformedPoints->Begin(); while (it != transformedPoints->End()) { PointType p = it.Value(); std::cout.width(5); std::cout << p[0] << ", "; std::cout.width(5); std::cout << p[1] << ", "; std::cout.width(5); std::cout << p[2] << std::endl; ++it; } // All objects should be automatically destroyed at this point return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/000077500000000000000000000000001301006202600206255ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/SpatialObjects/CMakeLists.txt000066400000000000000000000000561301006202600233660ustar00rootroot00000000000000project(OTBSpatialObjects) otb_module_impl() OTB-release-5.8/Modules/Core/SpatialObjects/include/000077500000000000000000000000001301006202600222505ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/SpatialObjects/include/otbDrawLineSpatialObjectFilter.h000066400000000000000000000102001301006202600304370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawLineSpatialObjectFilter_h #define otbDrawLineSpatialObjectFilter_h #include "itkSpatialObjectToImageFilter.h" #include "otbDrawLineSpatialObjectListFilter.h" //#include namespace otb { /** \class DrawLineSpatialObjectFilter * \brief Application of a filter which draw line in a binary image. * * This class implements a filter that draws line in a binary image. * Inputs are a LineSpatialObject and an input image that is used to * allocate the output image. This filter copies the input image in * the output image. * * * \ingroup OTBSpatialObjects */ template class ITK_EXPORT DrawLineSpatialObjectFilter : //public itk::SpatialObjectToImageFilter< itk::LineSpatialObject<2>, TOutputImage > public itk::ImageToImageFilter { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef for the classes standards. */ typedef DrawLineSpatialObjectFilter Self; //typedef itk::ImageTo< itk::LineSpatialObject<2>, TOutputImage > Superclass; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the "object factory". */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(DrawLineSpatialObjectFilter, /*SpatialObjectToImageFilter*/ itk::ImageToImageFilter); /** typedef Support for input & output image*/ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType OutputPixelType; /** Support typedef for input & Output*/ typedef itk::LineSpatialObject<2> InputLineType; typedef itk::ProcessObject ProcessObjectType; /** Typedef Support for lineList Type*/ typedef LineSpatialObjectList LineSpatialObjectListType; typedef typename LineSpatialObjectListType::Pointer LineSpatialObjectListPointer; /** Typedef Support for drawLineSpatialObjectListFilter*/ typedef otb::DrawLineSpatialObjectListFilter DrawLineSpatialObjectListFilterType; typedef typename DrawLineSpatialObjectListFilterType::Pointer DrawLineSpatialObjectListFilterPointerType; /** Set/Get the image input of this process object. */ /* virtual void SetInputImage(const InputImageType *image); */ /* const InputImageType * GetInputImage(void); */ /** Get the input LineSpatialObjet (not const) */ virtual void SetInputLine(const InputLineType *line); InputLineType * GetInputLine(void); /** Set/Get pixel value */ itkSetMacro(Value, OutputPixelType); itkGetConstReferenceMacro(Value, OutputPixelType); protected: DrawLineSpatialObjectFilter(); ~DrawLineSpatialObjectFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: DrawLineSpatialObjectFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputPixelType m_Value; DrawLineSpatialObjectListFilterPointerType m_DrawLineListFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDrawLineSpatialObjectFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbDrawLineSpatialObjectFilter.txx000066400000000000000000000055301301006202600310450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawLineSpatialObjectFilter_txx #define otbDrawLineSpatialObjectFilter_txx #include "otbDrawLineSpatialObjectFilter.h" #include "itkDataObject.h" #include "itkMacro.h" #include "itkImageRegionIterator.h" #include "itkImageIteratorWithIndex.h" namespace otb { /** * */ template DrawLineSpatialObjectFilter::DrawLineSpatialObjectFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); m_Value = static_cast(255.0); m_DrawLineListFilter = DrawLineSpatialObjectListFilterType::New(); } template void DrawLineSpatialObjectFilter ::SetInputLine(const InputLineType *line) { this->ProcessObjectType::SetNthInput(1, const_cast(line)); } template typename DrawLineSpatialObjectFilter::InputLineType * DrawLineSpatialObjectFilter ::GetInputLine(void) { return static_cast (this->ProcessObjectType::GetInput(1)); } template void DrawLineSpatialObjectFilter ::GenerateData(void) { typename InputImageType::ConstPointer input = this->GetInput(); InputLineType * line = this->GetInputLine(); typename OutputImageType::Pointer output = this->GetOutput(); /** Create a new list line with one line*/ LineSpatialObjectListPointer lineList = LineSpatialObjectListType::New(); lineList->push_back(line); /** Invoke the DrawLineSpatialObjectListFilter to draw the line */ m_DrawLineListFilter->SetInput(input); m_DrawLineListFilter->SetInputLineSpatialObjectList(lineList); m_DrawLineListFilter->GraftOutput(this->GetOutput()); m_DrawLineListFilter->Update(); this->GraftOutput(m_DrawLineListFilter->GetOutput()); } /** * Standard "PrintSelf" method */ template void DrawLineSpatialObjectFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Path Value: " << m_Value << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbDrawLineSpatialObjectListFilter.h000066400000000000000000000115611301006202600313060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawLineSpatialObjectListFilter_h #define otbDrawLineSpatialObjectListFilter_h #include "itkImageToImageFilter.h" #include "otbLineSpatialObjectList.h" namespace otb { /** \class DrawLineSpatialObjectListFilter * \brief Composite filter which draw lines in an image. * * This class implements a composite filter that draws a list of lines in * an input Image. This class * * * * * \ingroup OTBSpatialObjects */ template class ITK_EXPORT DrawLineSpatialObjectListFilter : public itk::ImageToImageFilter { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedefs support for inputs & outputs*/ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** typedef for the classes standards. */ typedef DrawLineSpatialObjectListFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef LineSpatialObjectList LinesListType; typedef LinesListType::LineType LineType; typedef LineType::PointListType PointListType; typedef typename LinesListType::const_iterator LineListIterator; typedef itk::ProcessObject ProcessObjectType; /** Method for management of the "object factory". */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(DrawLineSpatialObjectListFilter, ImageToImageFilter); /** Definition of the input and output images */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputIndexType::IndexValueType OutputIndexValueType; /** Set/Get the image input of this process object. */ virtual void SetInputLineSpatialObjectList(const LinesListType * list); LinesListType * GetInputLineSpatialObjectList(void); /** Get/Set m_Value*/ itkGetMacro(Value, OutputPixelType); itkSetMacro(Value, OutputPixelType); protected: DrawLineSpatialObjectListFilter(); ~DrawLineSpatialObjectListFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * compute the intersection of the segment to draw with the region */ virtual void CropSegment(OutputIndexType *indexToCrop, OutputIndexType *otherIndex, const OutputImageRegionType *outputRegionForThread) const; virtual void CropRightSegment(OutputIndexType *indexToCrop, OutputIndexType *otherIndex, const OutputImageRegionType *outputRegionForThread) const; virtual bool IsUpsideTheRegion(OutputIndexType *indexToCrop, const OutputImageRegionType *outputRegionForThread) const; virtual bool IsDownsideTheRegion(OutputIndexType *indexToCrop, const OutputImageRegionType *outputRegionForThread) const; virtual bool IsDownsideTheImage(OutputIndexType *indexToCrop) const; virtual bool IsColumnOutsideOfTheRegion(OutputIndexType *indexToCheck, OutputIndexType *otherToCheck, const OutputImageRegionType *outputRegionForThread) const; private: DrawLineSpatialObjectListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputPixelType m_Value; int m_Length; int m_Width; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDrawLineSpatialObjectListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbDrawLineSpatialObjectListFilter.txx000066400000000000000000000275011301006202600317030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawLineSpatialObjectListFilter_txx #define otbDrawLineSpatialObjectListFilter_txx #include "otbDrawLineSpatialObjectListFilter.h" #include "itkLineIterator.h" #include "itkDataObject.h" #include "itkImageRegionIterator.h" namespace otb { /** * */ template DrawLineSpatialObjectListFilter ::DrawLineSpatialObjectListFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); m_Value = static_cast(255.); } template void DrawLineSpatialObjectListFilter ::SetInputLineSpatialObjectList(const LinesListType * list) { this->ProcessObjectType::SetNthInput(1, const_cast(list)); } template typename DrawLineSpatialObjectListFilter::LinesListType * DrawLineSpatialObjectListFilter ::GetInputLineSpatialObjectList(void) { //ROMAIN return static_cast (this->ProcessObjectType::GetInput(1)); } template void DrawLineSpatialObjectListFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { typename InputImageType::ConstPointer input = this->GetInput(); typename OutputImageType::Pointer output = this->GetOutput(); typename LinesListType::Pointer list = const_cast(this->GetInputLineSpatialObjectList()); /** Copy the input requested region in the output requested region*/ typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionConstIterator InputIteratorType; OutputIteratorType outputIt(output, outputRegionForThread); InputIteratorType inputIt(input, outputRegionForThread); outputIt.GoToBegin(); inputIt.GoToBegin(); for (outputIt.GoToBegin(); !outputIt.IsAtEnd(); ++outputIt, ++inputIt) outputIt.Set(static_cast(inputIt.Get())); /** Draw the lines in the output image using lineIterator*/ typedef itk::LineIterator LineIteratorFilter; OutputIndexType indexBeginLine, indexEndLine; LineListIterator itList = list->begin(); typename InputImageType::SizeType size = input->GetLargestPossibleRegion().GetSize(); m_Length = size[1]; m_Width = size[0]; while (itList != list->end()) { PointListType& pointsList = (*itList)->GetPoints(); typename PointListType::const_iterator itPoints = pointsList.begin(); indexBeginLine[0] = static_cast((*itPoints).GetPosition()[0]); indexBeginLine[1] = static_cast((*itPoints).GetPosition()[1]); ++itPoints; //Get the second extremity of the segment indexEndLine[0] = static_cast((*itPoints).GetPosition()[0]); indexEndLine[1] = static_cast((*itPoints).GetPosition()[1]); /** Crop the segment if it is outside the region in the left*/ if (!(this->IsColumnOutsideOfTheRegion(&indexBeginLine, &indexEndLine, &outputRegionForThread) && this->IsColumnOutsideOfTheRegion(&indexEndLine, &indexBeginLine, &outputRegionForThread))) { if (indexEndLine[0] >= static_cast(size[0])) this->CropRightSegment(&indexEndLine, &indexBeginLine, &outputRegionForThread); if (indexBeginLine[0] >= static_cast(size[0])) this->CropRightSegment( &indexBeginLine, &indexEndLine, & outputRegionForThread); } /** * If an extremity is under the region * Technically, the X component of the index is inside the image */ if (this->IsDownsideTheImage(&indexBeginLine) && input->GetLargestPossibleRegion().IsInside(indexEndLine)) this->CropSegment(&indexBeginLine, &indexEndLine, &outputRegionForThread); if (this->IsDownsideTheImage(&indexEndLine) && input->GetLargestPossibleRegion().IsInside(indexBeginLine)) this->CropSegment(&indexEndLine, &indexBeginLine, &outputRegionForThread); /** If the segments are not in the region (upside or downside the region)*/ if (!(this->IsUpsideTheRegion(&indexBeginLine, &outputRegionForThread) && this->IsUpsideTheRegion(&indexEndLine, &outputRegionForThread)) && !(this->IsDownsideTheRegion(&indexBeginLine, &outputRegionForThread) && this->IsDownsideTheRegion(&indexEndLine, &outputRegionForThread)) && !(this->IsColumnOutsideOfTheRegion(&indexBeginLine, &indexEndLine, &outputRegionForThread) && this->IsColumnOutsideOfTheRegion(&indexEndLine, &indexBeginLine, &outputRegionForThread)) ) { /** Instantiation of the line iterator with begin and ending index*/ LineIteratorFilter itLine(output, indexBeginLine, indexEndLine); /** Iteration over the line and writing white lines */ while (!itLine.IsAtEnd()) { if (outputRegionForThread.IsInside(itLine.GetIndex())) itLine.Set(m_Value); ++itLine; } } ++itList; } } /** * Compute the intersection between the segment to draw and the region belonging to the current thread * It is used if the segment abcisse is greater than the width of the image * */ template void DrawLineSpatialObjectListFilter ::CropRightSegment(OutputIndexType *indexToCrop, OutputIndexType *otherIndex, const OutputImageRegionType *outputRegionForThread) const { /** Dimensions of the buffered region*/ typename OutputImageRegionType::SizeType size = outputRegionForThread->GetSize(); //typename OutputImageRegionType::IndexType start = outputRegionForThread->GetIndex(); /** Equation of the line (Begin, End)*/ double lengthSegment = -(*otherIndex)[1] + (*indexToCrop)[1]; double slope = lengthSegment / ((*indexToCrop)[0] - (*otherIndex)[0]); double origin = (*otherIndex)[1] - (slope * (*otherIndex)[0]); (*indexToCrop)[0] = static_cast(size[0] - 1); (*indexToCrop)[1] = static_cast(slope * (*indexToCrop)[0] + origin + 0.5); } /** * Define if the point is upside the region or not * */ template bool DrawLineSpatialObjectListFilter ::IsUpsideTheRegion(OutputIndexType *indexToCrop, const OutputImageRegionType *outputRegionForThread) const { /** Dimensions of the buffered region*/ //typename OutputImageRegionType::SizeType size = outputRegionForThread->GetSize(); typename OutputImageRegionType::IndexType start = outputRegionForThread->GetIndex(); return (*indexToCrop)[1] < static_cast(start[1]); } /** * Define if the point is upside the region or not * */ template bool DrawLineSpatialObjectListFilter ::IsDownsideTheRegion(OutputIndexType *indexToCrop, const OutputImageRegionType *outputRegionForThread) const { /** Dimensions of the buffered region*/ typename OutputImageRegionType::SizeType size = outputRegionForThread->GetSize(); typename OutputImageRegionType::IndexType start = outputRegionForThread->GetIndex(); return (*indexToCrop)[1] >= static_cast(start[1] + size[1]); //The down limit of the region in the Y direction } /** * Define if the point is outside the hole image * */ template bool DrawLineSpatialObjectListFilter ::IsDownsideTheImage(OutputIndexType *indexToCrop) const { return (*indexToCrop)[1] >= static_cast(m_Length); //The down limit of the Image in the Y direction } /** * * */ template bool DrawLineSpatialObjectListFilter ::IsColumnOutsideOfTheRegion(OutputIndexType *indexToCheck, OutputIndexType *otherToCheck, const OutputImageRegionType *outputRegionForThread) const { /** Dimensions of the buffered region*/ typename OutputImageRegionType::SizeType size = outputRegionForThread->GetSize(); bool res = false, res1 = false, res2 = false; if (((*indexToCheck)[0] >= static_cast(size[0])) && ((*otherToCheck)[0] >= static_cast(size[0]))) res = true; if ((*indexToCheck)[0] >= static_cast(size[0]) && this->IsUpsideTheRegion(otherToCheck, outputRegionForThread)) res1 = true; if ((*indexToCheck)[0] >= static_cast(size[0]) && this->IsDownsideTheRegion(otherToCheck, outputRegionForThread)) res2 = true; return res || res1 || res2; } /** * Compute the intersection between the segment to draw and the region belonging to the current thread * */ template void DrawLineSpatialObjectListFilter ::CropSegment(OutputIndexType *indexToCrop, OutputIndexType *otherIndex, const OutputImageRegionType *itkNotUsed(outputRegionForThread)) const { OutputIndexType tempIndex; tempIndex = *indexToCrop; /** Dimensions of the buffered region*/ //typename OutputImageRegionType::SizeType size = outputRegionForThread->GetSize(); //typename OutputImageRegionType::IndexType start = outputRegionForThread->GetIndex(); /** Equation of the line (Begin, End)*/ double slope = 0.; double lengthSegment = 0.; double origin = 0.; double tempOtherIndexX = 0.; /** Equation of the first Line*/ if (vcl_abs((*otherIndex)[0] - (*indexToCrop)[0]) < 1e-4) tempOtherIndexX = 0.000001; else tempOtherIndexX = static_cast((*otherIndex)[0]); if ((*indexToCrop)[0] < (*otherIndex)[0]) lengthSegment = (*otherIndex)[1] - (*indexToCrop)[1]; else lengthSegment = (*indexToCrop)[1] - (*otherIndex)[1]; slope = lengthSegment / (tempOtherIndexX - static_cast((*indexToCrop)[0])); origin = (*indexToCrop)[1] - (slope * static_cast((*indexToCrop)[0])); if ((*indexToCrop)[1] < 0) { unsigned int Y = 0; tempIndex[1] = Y; tempIndex[0] = static_cast((Y - origin) / slope); // X = (Y-B)/A } if (this->IsDownsideTheImage(indexToCrop)) { double Y = static_cast(m_Length - 1) /*tstart[1]+size[1]-1*/; tempIndex[1] = static_cast(Y); tempIndex[0] = static_cast((Y - origin) / slope); // X = (Y-B)/A } (*indexToCrop)[0] = tempIndex[0]; (*indexToCrop)[1] = tempIndex[1]; } /** * Standard "PrintSelf" method */ template void DrawLineSpatialObjectListFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbImageToLineSpatialObjectListFilter.h000066400000000000000000000060051301006202600317330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToLineSpatialObjectListFilter_h #define otbImageToLineSpatialObjectListFilter_h #include "itkProcessObject.h" #include "otbLineSpatialObjectList.h" namespace otb { /** \class ImageToLineSpatialObjectListFilter * \brief Base class for all process objects that output LineSpatialObjectList. * * ImageToLineSpatialObjectListFilter is the base class for all process objects * that output list of LineSpatialObject. * * * \ingroup OTBSpatialObjects */ template class ITK_EXPORT ImageToLineSpatialObjectListFilter : public itk::ProcessObject { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); typedef TInputImage InputImageType; /** Standard class typedefs. */ typedef ImageToLineSpatialObjectListFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageToLineSpatialObjectListFilter, itk::ProcessObject); /** Some convenient typedefs. */ typedef LineSpatialObjectList LinesListType; typedef typename LinesListType::LineType LineType; /** Definition of the input and output images */ typedef typename InputImageType::PixelType InputPixelType; /** Definition of the size of the images. */ typedef typename InputImageType::SizeType SizeType; typedef itk::ProcessObject ProcessObjectType; /** Set/Get the input image */ using Superclass::SetInput; void SetInput(const InputImageType *image); const InputImageType * GetInput(void); /** Set/Get the list of LineSpatialObject of this process object. */ using Superclass::SetOutput; void SetOutput(const LinesListType *list); LinesListType * GetOutput(void); protected: ImageToLineSpatialObjectListFilter(); ~ImageToLineSpatialObjectListFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageToLineSpatialObjectListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToLineSpatialObjectListFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbImageToLineSpatialObjectListFilter.txx000066400000000000000000000043601301006202600323310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToLineSpatialObjectListFilter_txx #define otbImageToLineSpatialObjectListFilter_txx #include "otbImageToLineSpatialObjectListFilter.h" namespace otb { /** * */ template ImageToLineSpatialObjectListFilter::ImageToLineSpatialObjectListFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); typename LinesListType::Pointer list = LinesListType::New(); this->SetOutput(list); } template void ImageToLineSpatialObjectListFilter ::SetInput(const InputImageType *image) { this->itk::ProcessObject::SetNthInput(0, const_cast(image)); } template const typename ImageToLineSpatialObjectListFilter::InputImageType * ImageToLineSpatialObjectListFilter ::GetInput(void) { return static_cast (this->itk::ProcessObject::GetInput(0)); } template void ImageToLineSpatialObjectListFilter ::SetOutput(const LinesListType *list) { this->ProcessObjectType::SetNthOutput(0, const_cast(list)); } template typename ImageToLineSpatialObjectListFilter::LinesListType * ImageToLineSpatialObjectListFilter ::GetOutput(void) { return static_cast (this->ProcessObjectType::GetOutput(0)); } /** * */ template void ImageToLineSpatialObjectListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbLineSpatialObject.h000066400000000000000000000106161301006202600264660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSpatialObject_h #define otbLineSpatialObject_h #include "itkPointBasedSpatialObject.h" #include "itkLineSpatialObjectPoint.h" namespace otb { /** \class LineSpatialObject * \brief Representation of a Line based on the spatial object classes. * * The Line is basically defined by a set of points. * * \sa LineSpatialObjectPoint * * \ingroup OTBSpatialObjects */ template class ITK_EXPORT LineSpatialObject : public itk::PointBasedSpatialObject { public: /** Standard typedefs */ typedef LineSpatialObject Self; typedef itk::PointBasedSpatialObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Method for creation through the object factory. */ itkTypeMacro(LineSpatialObject, PointBasedSpatialObject); /** Superclass typedefs */ typedef typename Superclass::SpatialObjectPointType SpatialObjectPointType; typedef typename Superclass::PointType PointType; typedef typename Superclass::TransformType TransformType; typedef typename Superclass::BoundingBoxType BoundingBoxType; /** Additional typedefs */ typedef double ScalarType; typedef itk::LineSpatialObjectPoint LinePointType; typedef std::vector PointListType; typedef itk::VectorContainer PointContainerType; typedef itk::SmartPointer PointContainerPointer; /** Returns a reference to the list of the Line points.*/ PointListType& GetPoints(void); /** Set the list of line points. */ void SetPoints(PointListType& newPoints); /** Return a point in the list given the index */ const SpatialObjectPointType* GetPoint(unsigned long id) const ITK_OVERRIDE { return &(m_Points[id]); } /** Return a point in the list given the index */ SpatialObjectPointType* GetPoint(unsigned long id) ITK_OVERRIDE { return &(m_Points[id]); } /** Return the number of points in the list */ itk::SizeValueType GetNumberOfPoints(void) const ITK_OVERRIDE { return m_Points.size(); } /** Returns true if the line is evaluable at the requested point, * false otherwise. */ bool IsEvaluableAt(const PointType& point, unsigned int depth = 0, char * name = ITK_NULLPTR) const ITK_OVERRIDE; /** Returns the value of the line at that point. * Currently this function returns a binary value, * but it might want to return a degree of membership * in case of fuzzy Lines. */ bool ValueAt(const PointType& point, double& value, unsigned int depth = 0, char * name = ITK_NULLPTR) const ITK_OVERRIDE; /** Returns true if the point is inside the line, false otherwise. */ bool IsInside(const PointType& point, unsigned int depth, char * name) const ITK_OVERRIDE; /** Test whether a point is inside or outside the object * For computational speed purposes, it is faster if the method does not * check the name of the class and the current depth */ virtual bool IsInside(const PointType& point) const; /** Compute the boundaries of the line.*/ bool ComputeLocalBoundingBox() const ITK_OVERRIDE; protected: /** Constructor */ LineSpatialObject(); /** Destructor */ ~LineSpatialObject() ITK_OVERRIDE; /** Method to print the object. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LineSpatialObject(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Point list */ PointListType m_Points; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineSpatialObject.txx" #endif #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbLineSpatialObject.txx000066400000000000000000000202141301006202600270550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSpatialObject_txx #define otbLineSpatialObject_txx #include "otbLineSpatialObject.h" #include "otbMacro.h" namespace otb { /** Constructor */ template LineSpatialObject ::LineSpatialObject() { this->SetDimension(VDimension); this->SetTypeName("LineSpatialObject"); this->GetProperty()->SetRed(1); this->GetProperty()->SetGreen(0); this->GetProperty()->SetBlue(0); this->GetProperty()->SetAlpha(1); this->ComputeBoundingBox(); } /** Destructor */ template LineSpatialObject ::~LineSpatialObject() {} /** Returns a reference to the list of the Line points.*/ template typename LineSpatialObject::PointListType& LineSpatialObject ::GetPoints() { // otbMsgDevMacro( "Getting LinePoint list" ); return m_Points; } /** Set the list of Line points. */ template void LineSpatialObject ::SetPoints(PointListType& points) { // in this function, passing a null pointer as argument will // just clear the list... m_Points.clear(); typename PointListType::iterator it, end; it = points.begin(); end = points.end(); while (it != end) { m_Points.push_back(*it); ++it; } this->ComputeBoundingBox(); this->Modified(); } /** Print the object. */ template void LineSpatialObject ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "LineSpatialObject(" << this << ")" << std::endl; os << indent << "ID: " << this->GetId() << std::endl; os << indent << "nb of points: " << static_cast(m_Points.size()) << std::endl; Superclass::PrintSelf(os, indent); } /** Compute the boundaries of the line.*/ template bool LineSpatialObject ::ComputeLocalBoundingBox() const { // tbMsgDevMacro( "Computing tube bounding box" ); if (this->GetBoundingBoxChildrenName().empty() || strstr(typeid(Self).name(), this->GetBoundingBoxChildrenName().c_str())) { typename PointListType::const_iterator it = m_Points.begin(); typename PointListType::const_iterator end = m_Points.end(); if (it == end) { return false; } else { PointType pt = this->GetIndexToWorldTransform()->TransformPoint((*it).GetPosition()); PointType ptmin; PointType ptmax; ptmin[0] = pt[0] - 1; ptmin[1] = pt[1] - 1; ptmax[0] = pt[0] + 1; ptmax[1] = pt[1] + 1; const_cast(this->GetBounds())->SetMinimum(ptmin); const_cast(this->GetBounds())->SetMaximum(ptmax); ++it; while (it != end) { PointType pt2 = this->GetIndexToWorldTransform()->TransformPoint((*it).GetPosition()); const_cast(this->GetBounds())->ConsiderPoint(pt2); ++it; } } } return true; } /** Test whether a point is inside or outside the object * For computational speed purposes, it is faster if the method does not * check the name of the class and the current depth */ template bool LineSpatialObject ::IsInside(const PointType& point) const { typename PointListType::const_iterator it1 = m_Points.begin(); typename PointListType::const_iterator end = m_Points.end(); typename PointListType::const_iterator it2 = it1 + 1; if (!this->GetIndexToWorldTransform()->GetInverse(const_cast(this->GetInternalInverseTransform()))) { return false; } PointType transformedPoint = this->GetInternalInverseTransform()->TransformPoint(point); if (this->GetBounds()->IsInside(transformedPoint)) { while (it2 != end) { if ((*it1).GetPosition()[0] < (*it2).GetPosition()[0]) { if (transformedPoint[1] == (int) ((*it1).GetPosition()[1] + (((*it2).GetPosition()[1] - (*it1).GetPosition()[1]) / ((*it2).GetPosition()[0] - (*it1).GetPosition()[0])) * (transformedPoint[0] - (*it1).GetPosition()[0])) && transformedPoint[0] >= (*it1).GetPosition()[0] && transformedPoint[0] <= (*it2).GetPosition()[0]) { return true; } } else { if (transformedPoint[1] == (int) ((((*it2).GetPosition()[1] - (*it1).GetPosition()[1]) / ((*it1).GetPosition()[0] - (*it2).GetPosition()[0])) * ((*it1).GetPosition()[0] - transformedPoint[0]) + (*it1).GetPosition()[1]) && transformedPoint[0] >= (*it2).GetPosition()[0] && transformedPoint[0] <= (*it1).GetPosition()[0]) { return true; } } if ((*it1).GetPosition()[1] < (*it2).GetPosition()[1]) { if (transformedPoint[0] == (int) ((((*it2).GetPosition()[0] - (*it1).GetPosition()[0]) / ((*it2).GetPosition()[1] - (*it1).GetPosition()[1])) * (transformedPoint[1] - (*it1).GetPosition()[1]) + (*it1).GetPosition()[0]) && transformedPoint[1] >= (*it1).GetPosition()[1] && transformedPoint[1] <= (*it2).GetPosition()[1]) { return true; } } else { if (transformedPoint[0] == (int) ((((*it2).GetPosition()[0] - (*it1).GetPosition()[0]) / ((*it1).GetPosition()[1] - (*it2).GetPosition()[1])) * ((*it1).GetPosition()[1] - transformedPoint[1]) + (*it1).GetPosition()[0]) && transformedPoint[1] >= (*it2).GetPosition()[1] && transformedPoint[1] <= (*it1).GetPosition()[1]) { return true; } } it1++; ++it2; } } return false; } /** Check if a given point is inside a line * return True only if the point is in the point list */ template bool LineSpatialObject ::IsInside(const PointType& point, unsigned int depth, char * name) const { // otbMsgDevMacro( "Checking the point [" << point << "] is on the Line" ); if (name == ITK_NULLPTR) { if (IsInside(point)) { return true; } } else if (strstr(typeid(Self).name(), name)) { if (IsInside(point)) { return true; } } return Superclass::IsInside(point, depth, name); } /** Returns true if the line is evaluable at the requested point, * false otherwise. */ template bool LineSpatialObject ::IsEvaluableAt(const PointType& point, unsigned int depth, char * name) const { // otbMsgDevMacro( "Checking if the tube is evaluable at " << point ); return IsInside(point, depth, name); } /** Returns the value of the line at that point. * Currently this function returns a binary value, * but it might want to return a degree of membership * in case of fuzzy Lines. */ template bool LineSpatialObject ::ValueAt(const PointType& point, double& value, unsigned int depth, char * name) const { // otbMsgDevMacro( "Getting the value of the tube at " << point ); if (IsInside(point, 0, name)) { value = this->GetDefaultInsideValue(); return true; } else { if (Superclass::IsEvaluableAt(point, depth, name)) { Superclass::ValueAt(point, value, depth, name); return true; } else { value = this->GetDefaultOutsideValue(); return false; } } return false; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbLineSpatialObjectList.h000066400000000000000000000032571301006202600273250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSpatialObjectList_h #define otbLineSpatialObjectList_h #include "itkDataObject.h" #include "itkLineSpatialObject.h" #include namespace otb { /** \class LineSpatialObjectList * \brief TODO * * \ingroup OTBSpatialObjects */ class ITK_EXPORT LineSpatialObjectList : public std::list::Pointer>, public itk::DataObject { public: /** Standard class typedefs. */ typedef LineSpatialObjectList Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LineSpatialObjectList, itk::DataObject); /** Some convenient typedefs. */ typedef itk::LineSpatialObject<2> LineType; protected: LineSpatialObjectList() {}; ~LineSpatialObjectList() ITK_OVERRIDE {} private: LineSpatialObjectList(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbLineSpatialObjectListToPointSetFilter.h000066400000000000000000000052031301006202600324550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSpatialObjectListToPointSetFilter_h #define otbLineSpatialObjectListToPointSetFilter_h #include "itkProcessObject.h" #include "otbLineSpatialObjectList.h" namespace otb { /** \class LineSpatialObjectListToPointSetFilter * \brief Base class for all process objects that output PointSets And use LineSpatialObjectList * as input. * * * * \ingroup OTBSpatialObjects */ template class ITK_EXPORT LineSpatialObjectListToPointSetFilter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef LineSpatialObjectListToPointSetFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LineSpatialObjectListToPointSetFilter, itk::ProcessObject); /** Some convenient typedefs. */ typedef TLinesList LinesListType; typedef typename LinesListType::LineType LineType; /** typedef support for output*/ typedef TPointSet PointSetType; typedef itk::ProcessObject ProcessObjectType; /** Set/Get the input image */ using Superclass::SetInput; virtual void SetInput(const LinesListType *list); virtual const LinesListType* GetInput(void); /** Set/Get the list of LineSpatialObject of this process object. */ using Superclass::SetOutput; virtual void SetOutput(const PointSetType *pointSet); virtual PointSetType* GetOutput(void); protected: LineSpatialObjectListToPointSetFilter(); ~LineSpatialObjectListToPointSetFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LineSpatialObjectListToPointSetFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineSpatialObjectListToPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbLineSpatialObjectListToPointSetFilter.txx000066400000000000000000000046241301006202600330570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSpatialObjectListToPointSetFilter_txx #define otbLineSpatialObjectListToPointSetFilter_txx #include "otbLineSpatialObjectListToPointSetFilter.h" namespace otb { /** * */ template LineSpatialObjectListToPointSetFilter::LineSpatialObjectListToPointSetFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, PointSetType::New()); } template void LineSpatialObjectListToPointSetFilter ::SetInput(const LinesListType *list) { this->itk::ProcessObject::SetNthInput(0, const_cast(list)); } template const typename LineSpatialObjectListToPointSetFilter::LinesListType* LineSpatialObjectListToPointSetFilter ::GetInput(void) { return static_cast (this->itk::ProcessObject::GetInput(0)); } template void LineSpatialObjectListToPointSetFilter ::SetOutput(const PointSetType *pointSet) { this->ProcessObjectType::SetNthOutput(0, const_cast(pointSet)); } template typename LineSpatialObjectListToPointSetFilter::PointSetType* LineSpatialObjectListToPointSetFilter ::GetOutput(void) { return static_cast (this->ProcessObjectType::GetOutput(0)); } /** * */ template void LineSpatialObjectListToPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbSpatialObjectSource.h000066400000000000000000000042571301006202600270430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpatialObjectSource_h #define otbSpatialObjectSource_h #include "otbMacro.h" #include "itkProcessObject.h" namespace otb { /** * \class SpatialObjectSource * \brief Base class for filters producing a SpatialObject as output. * \ingroup DataSources * * \ingroup OTBSpatialObjects */ template class ITK_EXPORT SpatialObjectSource : public itk::ProcessObject { public: /** Standard typedefs */ typedef SpatialObjectSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** Runtime information */ itkTypeMacro(SpatialObjectSource, itk::ProcessObject); /** Template parameters typedefs */ typedef TSpatialObject SpatialObjectType; typedef typename SpatialObjectType::Pointer SpatialObjectPointerType; /** Data object pointer */ typedef itk::DataObject::Pointer DataObjectPointer; /** * Get the output spatial object. * \return The output spatial object. */ virtual SpatialObjectType * GetOutput(void); protected: /** Constructor */ SpatialObjectSource(); /** Destructor */ ~SpatialObjectSource() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SpatialObjectSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSpatialObjectSource.txx" #endif #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbSpatialObjectSource.txx000066400000000000000000000030071301006202600274270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpatialObjectSource_txx #define otbSpatialObjectSource_txx #include "otbSpatialObjectSource.h" namespace otb { /** * Constructor. */ template SpatialObjectSource ::SpatialObjectSource() { this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, TSpatialObject::New().GetPointer()); } /** * Get the output image list * \return The image list produced. */ template typename SpatialObjectSource::SpatialObjectType * SpatialObjectSource ::GetOutput(void) { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } /** * PrintSelf Method */ template void SpatialObjectSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbSpatialObjectToImageDrawingFilter.h000066400000000000000000000146511301006202600316110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpatialObjectToImageDrawingFilter_h #define otbSpatialObjectToImageDrawingFilter_h #include "itkImageSource.h" #include "itkConceptChecking.h" #include "itkSpatialObject.h" namespace otb { /** \class SpatialObjectToImageDrawingFilter * \brief Base class for filters that take a SpatialObject * as input and produce an image as output. * By default, if the user does not specify the size of the output image, * the maximum size of the object's bounding box is used. * The spacing of the image is given by the spacing of the input * Spatial object. * * \ingroup OTBSpatialObjects */ template class ITK_EXPORT SpatialObjectToImageDrawingFilter : public itk::ImageSource { public: /** Standard class typedefs. */ typedef SpatialObjectToImageDrawingFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename TOutputImage::SizeType SizeType; typedef typename TOutputImage::PointType PointType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ValueType ValueType; typedef typename OutputImageType::SpacingType SpacingType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SpatialObjectToImageDrawingFilter, itk::ImageSource); /** Superclass typedefs. */ typedef typename Superclass::OutputImageRegionType OutputImageRegionType; /** Some convenient typedefs. */ typedef TInputSpatialObject InputSpatialObjectType; typedef typename InputSpatialObjectType::Pointer InputSpatialObjectPointer; typedef typename InputSpatialObjectType::ConstPointer InputSpatialObjectConstPointer; typedef typename TInputSpatialObject::ChildrenListType ChildrenListType; /** ImageDimension constants */ itkStaticConstMacro(ObjectDimension, unsigned int, InputSpatialObjectType::ObjectDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Set/Get the image input of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputSpatialObjectType *object); virtual void SetInput(unsigned int, const InputSpatialObjectType * object); const InputSpatialObjectType * GetInput(void); const InputSpatialObjectType * GetInput(unsigned int idx); /** Spacing (size of a pixel) of the output image. The * spacing is the geometric distance between image samples. * It is stored internally as double, but may be set from * float. \sa GetSpacing() */ virtual void SetSpacing(const SpacingType& spacing); virtual void SetSpacing(const double* spacing); virtual void SetSpacing(const float* spacing); virtual const double* GetSpacing() const; /** Set/Get the value for pixels inside the spatial object. * By default, this filter will return an image * that contains values from the spatial object specified as input. * If this "inside" value is changed to a non-null value, * the output produced by this filter will be a mask with inside/outside values * specified by the user. */ itkSetMacro(InsideValue, ValueType); itkGetMacro(InsideValue, ValueType); /** Set/Get the value for pixels outside the spatial object. * By default, this filter will return an image * that contains values from the spatial object specified as input. * If this "outside" value is changed to a non-null value, * the output produced by this filter will be a mask with inside/outside values * specified by the user. */ itkSetMacro(OutsideValue, ValueType); itkGetMacro(OutsideValue, ValueType); /** The origin of the output image. The origin is the geometric * coordinates of the index (0, 0, ..., 0). It is stored internally * as double but may be set from float. * \sa GetOrigin() */ virtual void SetOrigin(const PointType& origin); virtual void SetOrigin(const double* origin); virtual void SetOrigin(const float* origin); virtual const double * GetOrigin() const; /** The spatial object being transformed can be part of a hierarchy. * How deep in the hierarchy should we descend in generating the * image? A ChildrenDepth of 0 means to only include the object * itself. */ itkSetMacro(ChildrenDepth, unsigned int); itkGetMacro(ChildrenDepth, unsigned int); /** Set/Get Size */ itkSetMacro(Size, SizeType); itkGetMacro(Size, SizeType); /** If UseObjectValue is set to true, then the filter uses * the ValueAt() function instead of IsInside() */ itkSetMacro(UseObjectValue, bool); itkGetMacro(UseObjectValue, bool); typedef itk::SpatialObject SpatialObjectType; typedef typename SpatialObjectType::ChildrenListType* ChildrenType; typedef typename SpatialObjectType::ChildrenListType::iterator IteratorType; protected: SpatialObjectToImageDrawingFilter(); ~SpatialObjectToImageDrawingFilter() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; // do nothing void GenerateData() ITK_OVERRIDE; SizeType m_Size; double m_Spacing[OutputImageDimension]; double m_Origin[OutputImageDimension]; unsigned int m_ChildrenDepth; ValueType m_InsideValue; ValueType m_OutsideValue; bool m_UseObjectValue; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SpatialObjectToImageDrawingFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSpatialObjectToImageDrawingFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/SpatialObjects/include/otbSpatialObjectToImageDrawingFilter.txx000066400000000000000000000305341301006202600322030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpatialObjectToImageDrawingFilter_txx #define otbSpatialObjectToImageDrawingFilter_txx #include "otbSpatialObjectToImageDrawingFilter.h" #include "itkImageRegionIteratorWithIndex.h" namespace otb { /** Constructor */ template SpatialObjectToImageDrawingFilter ::SpatialObjectToImageDrawingFilter() { this->SetNumberOfRequiredInputs(1); m_ChildrenDepth = 1; m_Size.Fill(0); for (unsigned int i = 0; i < OutputImageDimension; ++i) { m_Spacing[i] = 1.0; m_Origin[i] = 0.; } m_InsideValue = 0; m_OutsideValue = 0; m_UseObjectValue = false; } /** Destructor */ template SpatialObjectToImageDrawingFilter ::~SpatialObjectToImageDrawingFilter() { } /** Set the Input SpatialObject */ template void SpatialObjectToImageDrawingFilter ::SetInput(const InputSpatialObjectType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } /** Connect one of the operands */ template void SpatialObjectToImageDrawingFilter ::SetInput(unsigned int index, const TInputSpatialObject * object) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(index, const_cast(object)); } /** Get the input Spatial Object */ template const typename SpatialObjectToImageDrawingFilter::InputSpatialObjectType * SpatialObjectToImageDrawingFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } /** Get the input Spatial Object */ template const typename SpatialObjectToImageDrawingFilter::InputSpatialObjectType * SpatialObjectToImageDrawingFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } //---------------------------------------------------------------------------- template void SpatialObjectToImageDrawingFilter ::SetSpacing(const SpacingType& spacing) { unsigned int i; for (i = 0; i < TOutputImage::ImageDimension; ++i) { if ((double) spacing[i] != m_Spacing[i]) { break; } } if (i < TOutputImage::ImageDimension) { for (i = 0; i < TOutputImage::ImageDimension; ++i) { m_Spacing[i] = spacing[i]; } this->Modified(); } } //---------------------------------------------------------------------------- template void SpatialObjectToImageDrawingFilter ::SetSpacing(const double* spacing) { unsigned int i; for (i = 0; i < OutputImageDimension; ++i) { if (spacing[i] != m_Spacing[i]) { break; } } if (i < OutputImageDimension) { for (i = 0; i < OutputImageDimension; ++i) { m_Spacing[i] = spacing[i]; } } } template void SpatialObjectToImageDrawingFilter ::SetSpacing(const float* spacing) { unsigned int i; for (i = 0; i < OutputImageDimension; ++i) { if ((double) spacing[i] != m_Spacing[i]) { break; } } if (i < OutputImageDimension) { for (i = 0; i < OutputImageDimension; ++i) { m_Spacing[i] = spacing[i]; } } } template const double * SpatialObjectToImageDrawingFilter ::GetSpacing() const { return m_Spacing; } //---------------------------------------------------------------------------- template void SpatialObjectToImageDrawingFilter ::SetOrigin(const PointType& origin) { unsigned int i; for (i = 0; i < TOutputImage::ImageDimension; ++i) { if ((double) origin[i] != m_Origin[i]) { break; } } if (i < TOutputImage::ImageDimension) { for (i = 0; i < TOutputImage::ImageDimension; ++i) { m_Origin[i] = origin[i]; } this->Modified(); } } //---------------------------------------------------------------------------- template void SpatialObjectToImageDrawingFilter ::SetOrigin(const double* origin) { unsigned int i; for (i = 0; i < OutputImageDimension; ++i) { if (origin[i] != m_Origin[i]) { break; } } if (i < OutputImageDimension) { for (i = 0; i < OutputImageDimension; ++i) { m_Origin[i] = origin[i]; } this->Modified(); } } template void SpatialObjectToImageDrawingFilter ::SetOrigin(const float* origin) { unsigned int i; for (i = 0; i < OutputImageDimension; ++i) { if ((double) origin[i] != m_Origin[i]) { break; } } if (i < OutputImageDimension) { for (i = 0; i < OutputImageDimension; ++i) { m_Origin[i] = origin[i]; } this->Modified(); } } template const double * SpatialObjectToImageDrawingFilter ::GetOrigin() const { return m_Origin; } template void SpatialObjectToImageDrawingFilter ::GenerateOutputInformation() { const InputSpatialObjectType * InputObject = this->GetInput(); OutputImagePointer OutputImage = this->GetOutput(); unsigned int i; // Generate the image SizeType size; double origine[ObjectDimension]; InputObject->ComputeBoundingBox(); bool originspecified = false; if (!strcmp(InputObject->GetNameOfClass(), "GroupSpatialObject")) { ChildrenType children; children = InputObject->GetChildren(0); IteratorType iter = children->begin(); IteratorType end = children->end(); double minimum[ObjectDimension]; (*iter)->ComputeBoundingBox(); for (i = 0; i < ObjectDimension; ++i) { minimum[i] = (*iter)->GetBoundingBox()->GetMinimum()[i]; } while (iter != end) { (*iter)->ComputeBoundingBox(); for (i = 0; i < ObjectDimension; ++i) { if ((*iter)->GetBoundingBox()->GetMinimum()[i] < minimum[i]) { minimum[i] = (*iter)->GetBoundingBox()->GetMinimum()[i]; } } ++iter; } for (i = 0; i < ObjectDimension; ++i) { size[i] = (long unsigned int) (InputObject->GetBoundingBox()->GetMaximum()[i] - minimum[i]) + 1; origine[i] = (long int) minimum[i]; originspecified = true; } itkDebugMacro( << "minx= " << minimum[0] << ", miny= " << minimum[0] << ", maxx= " << InputObject->GetBoundingBox()->GetMaximum()[0] << ", maxy= " << InputObject->GetBoundingBox()->GetMaximum()[1]); } else { for (i = 0; i < ObjectDimension; ++i) { size[i] = (long int) (InputObject->GetBoundingBox()->GetMaximum()[i] - InputObject->GetBoundingBox()->GetMinimum()[i]); } } typename OutputImageType::IndexType index; index.Fill(0); typename OutputImageType::RegionType region; // If the size of the output has been explicitly specified, the filter // will set the output size to the explicit size, otherwise the size from the spatial // object's bounding box will be used as default. bool specified = false; for (i = 0; i < OutputImageDimension; ++i) { if (m_Size[i] != 0) { specified = true; break; } } if (specified) { region.SetSize(m_Size); } else { region.SetSize (size); m_Size = size; } region.SetIndex(index); OutputImage->SetLargestPossibleRegion(region); specified = false; for (i = 0; i < OutputImageDimension; ++i) { if (m_Spacing[i] != 0) { specified = true; break; } } if (specified) { OutputImage->SetSpacing(this->m_Spacing); // set spacing } else { OutputImage->SetSpacing(InputObject->GetIndexToObjectTransform()->GetScaleComponent()); // set spacing m_Spacing[0] = InputObject->GetIndexToObjectTransform()->GetScaleComponent()[0]; m_Spacing[1] = InputObject->GetIndexToObjectTransform()->GetScaleComponent()[1]; } if (originspecified) { origine[0] += 0.5 * m_Spacing[0]; origine[1] += 0.5 * m_Spacing[1]; OutputImage->SetOrigin(origine); // and origin m_Origin[0] = OutputImage->GetOrigin()[0]; m_Origin[1] = OutputImage->GetOrigin()[1]; } else OutputImage->SetOrigin(m_Origin); } //---------------------------------------------------------------------------- /** Update */ template void SpatialObjectToImageDrawingFilter ::GenerateData(void) { itkDebugMacro(<< "SpatialObjectToImageDrawingFilter::Update() called"); // Get the input and output pointers const InputSpatialObjectType * InputObject = this->GetInput(); OutputImagePointer OutputImage = this->GetOutput(); typename OutputImageType::RegionType region = OutputImage->GetLargestPossibleRegion(); OutputImage->SetBufferedRegion(region); // set the region OutputImage->SetRequestedRegion(region); // OutputImage->Allocate(); // allocate the image typedef itk::ImageRegionIteratorWithIndex myIteratorType; myIteratorType it(OutputImage, region); itk::Point point; while (!it.IsAtEnd()) { // ValueAt requires the point to be in physical coordinate i.e for (unsigned int i = 0; i < ObjectDimension; ++i) { point[i] = (int) (it.GetIndex()[i] * m_Spacing[i]) + m_Origin[i]; } double val = 0; InputObject->ValueAt(point, val, 99999); if (m_InsideValue != 0 || m_OutsideValue != 0) { if (val) { if (m_UseObjectValue) { it.Set(static_cast(val)); } else { it.Set(m_InsideValue); } } else { it.Set(m_OutsideValue); } } else { it.Set(static_cast(val)); } ++it; } itkDebugMacro(<< "SpatialObjectToImageDrawingFilter::Update() finished"); } // end update function template void SpatialObjectToImageDrawingFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Size : " << m_Size << std::endl; os << indent << "Children depth : " << m_ChildrenDepth << std::endl; os << indent << "Inside Value : " << m_InsideValue << std::endl; os << indent << "Outside Value : " << m_OutsideValue << std::endl; if (m_UseObjectValue) { os << indent << "Using Object Value : ON" << std::endl; } else { os << indent << "Using Object Value : OFF" << std::endl; } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/SpatialObjects/otb-module.cmake000066400000000000000000000015111301006202600236740ustar00rootroot00000000000000set(DOCUMENTATION "Geometric shapes are represented in OTB using the ITK spatial object hierarchy. These classes are intended to support modelling of anatomical structures in ITK. OTB uses them in order to model cartographic elements. Using a common basic interface, the spatial objects are capable of representing regions of space in a variety of different ways. For example: mesh structures, image masks, and implicit equations may be used as the underlying representation scheme. Spatial objects are a natural data structure for communicating the results of segmentation methods and for introducing geometrical priors in both segmentation and registration methods.") otb_module(OTBSpatialObjects DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/SpatialObjects/test/000077500000000000000000000000001301006202600216045ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/SpatialObjects/test/CMakeLists.txt000066400000000000000000000045601301006202600243510ustar00rootroot00000000000000otb_module_test() set(OTBSpatialObjectsTests otbSpatialObjectsTestDriver.cxx otbLineSpatialObjectListToPointSetFilterNew.cxx otbSpatialObjectToImageDrawingFilter.cxx otbDrawLineSpatialObject.cxx otbSpatialObjectToImageDrawingFilterNew.cxx otbLineSpatialObjectList.cxx otbLineSpatialObjectNew.cxx otbDrawLineSpatialObjectListNew.cxx otbDrawLineSpatialObjectList.cxx otbSpatialObjectSourceNew.cxx otbImageToLineSpatialObjectListNew.cxx otbDrawLineSpatialObjectNew.cxx ) add_executable(otbSpatialObjectsTestDriver ${OTBSpatialObjectsTests}) target_link_libraries(otbSpatialObjectsTestDriver ${OTBSpatialObjects-Test_LIBRARIES}) otb_module_target_label(otbSpatialObjectsTestDriver) # Tests Declaration otb_add_test(NAME coTuLineSpatialObjectListToPointSetFilter COMMAND otbSpatialObjectsTestDriver otbLineSpatialObjectListToPointSetFilterNew) otb_add_test(NAME bfTvSpatialObjectToImageDrawingFilterWithoutInputImage COMMAND otbSpatialObjectsTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvSpatialObjectDrawingNoInput.png ${TEMP}/bfTvSpatialObjectDrawingNoInput.png otbSpatialObjectToImageDrawingFilter ${TEMP}/bfTvSpatialObjectDrawingNoInput.png 100 50 ) otb_add_test(NAME coTuDrawLineSpatialObject COMMAND otbSpatialObjectsTestDriver otbDrawLineSpatialObject ${INPUTDATA}/ImageLineDir.bsq ${TEMP}/coFiltreDrawLine_ImageLineDir.png 10. 22. 38. 42.) otb_add_test(NAME bfTuSpatialObjectToImageDrawingFilterNew COMMAND otbSpatialObjectsTestDriver otbSpatialObjectToImageDrawingFilterNew) otb_add_test(NAME coTuLineSpatialObjectList COMMAND otbSpatialObjectsTestDriver otbLineSpatialObjectList ) otb_add_test(NAME coTuLineSpatialObjectNew COMMAND otbSpatialObjectsTestDriver otbLineSpatialObjectNew) otb_add_test(NAME coTuDrawLineSpatialObjectListNew COMMAND otbSpatialObjectsTestDriver otbDrawLineSpatialObjectListNew) otb_add_test(NAME coTuDrawLineSpatialObjectList COMMAND otbSpatialObjectsTestDriver otbDrawLineSpatialObjectList ${INPUTDATA}/ImageLineDir.bsq ${TEMP}/coFiltreDrawLineList_ImageLineDir.png ) otb_add_test(NAME coTuSpatialObjectSourceNew COMMAND otbSpatialObjectsTestDriver otbSpatialObjectSourceNew) otb_add_test(NAME coTuImageToLineSpatialObjectListNew COMMAND otbSpatialObjectsTestDriver otbImageToLineSpatialObjectListNew) otb_add_test(NAME coTuDrawLineSpatialObjectNew COMMAND otbSpatialObjectsTestDriver otbDrawLineSpatialObjectNew) OTB-release-5.8/Modules/Core/SpatialObjects/test/otbDrawLineSpatialObject.cxx000066400000000000000000000045101301006202600272070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbDrawLineSpatialObjectFilter.h" int otbDrawLineSpatialObject(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // two points to represent a straight line double Ux((double) ::atof(argv[3])); double Uy((double) ::atof(argv[4])); double Vx((double) ::atof(argv[5])); double Vy((double) ::atof(argv[6])); typedef double InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::DrawLineSpatialObjectFilter FilterType; FilterType::Pointer filter = FilterType::New(); typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Definition of the line typedef itk::LineSpatialObject<2> LineType; LineType::PointListType list; LineType::LinePointType point; point.SetPosition(Ux, Uy); list.push_back(point); point.SetPosition(Vx, Vy); list.push_back(point); LineType::Pointer line = LineType::New(); line->SetId(0); line->SetPoints(list); line->ComputeBoundingBox(); filter->SetValue(static_cast(245)); filter->SetInputLine(line); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbDrawLineSpatialObjectList.cxx000066400000000000000000000063571301006202600300560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbDrawLineSpatialObjectListFilter.h" int otbDrawLineSpatialObjectList(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::DrawLineSpatialObjectListFilter FilterType; FilterType::Pointer filter = FilterType::New(); typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); typedef otb::LineSpatialObjectList LinesListType; typedef LinesListType::LineType LineType; LinesListType::Pointer list = LinesListType::New(); LineType::PointListType pointList; LineType::LinePointType point; // Definition of the first line double Ux, Uy, Vx, Vy; Ux = 10.; Uy = 12.; Vx = 35.; Vy = 29.; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line = LineType::New(); line->SetId(0); line->SetPoints(pointList); line->ComputeBoundingBox(); list->push_back(line); pointList.clear(); // Definition of a second line Ux = 8.; Uy = 7.; Vx = 8.; Vy = 46.; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line2 = LineType::New(); line2->SetId(0); line2->SetPoints(pointList); line2->ComputeBoundingBox(); list->push_back(line2); pointList.clear(); // Definition of a third line Ux = 52.; Uy = 15.; Vx = 22.; Vy = 38.; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line3 = LineType::New(); line3->SetId(0); line3->SetPoints(pointList); line3->ComputeBoundingBox(); list->push_back(line3); /* LinesListType::const_iterator it; std::cout<SetInputLineSpatialObjectList(list); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbDrawLineSpatialObjectListNew.cxx000066400000000000000000000023021301006202600305120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbDrawLineSpatialObjectListFilter.h" int otbDrawLineSpatialObjectListNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::DrawLineSpatialObjectListFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbDrawLineSpatialObjectNew.cxx000066400000000000000000000022501301006202600276600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbDrawLineSpatialObjectFilter.h" int otbDrawLineSpatialObjectNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::DrawLineSpatialObjectFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbImageToLineSpatialObjectListNew.cxx000066400000000000000000000021171301006202600311460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageToLineSpatialObjectListFilter.h" int otbImageToLineSpatialObjectListNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageToLineSpatialObjectListFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbLineSpatialObjectList.cxx000066400000000000000000000030421301006202600272240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLineSpatialObjectList.h" #include int otbLineSpatialObjectList(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::LineSpatialObjectList LineSpatialObjectListType; typedef LineSpatialObjectListType::LineType LineSpatialObjecType; typedef LineSpatialObjectListType::LineType::PointListType PointListType; typedef LineSpatialObjectListType::const_iterator LineSpatialObjectListConstIterator; LineSpatialObjectListType::Pointer listLines = LineSpatialObjectListType::New(); for (int i = 0; i < 10; ++i) { LineSpatialObjecType::Pointer lLine = LineSpatialObjecType::New(); listLines->push_back(lLine); } LineSpatialObjectListConstIterator lIter; lIter = listLines->begin(); while (lIter != listLines->end()) { LineSpatialObjecType::Pointer lLine = (*lIter); PointListType lPoints = lLine->GetPoints(); lIter++; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbLineSpatialObjectListToPointSetFilterNew.cxx000066400000000000000000000021671301006202600330440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkPointSet.h" #include #include "otbLineSpatialObjectListToPointSetFilter.h" int otbLineSpatialObjectListToPointSetFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float InputPixelType; typedef otb::LineSpatialObjectList LinesListType; typedef itk::PointSet PointSetType; typedef otb::LineSpatialObjectListToPointSetFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbLineSpatialObjectNew.cxx000066400000000000000000000016241301006202600270460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLineSpatialObject.h" int otbLineSpatialObjectNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::LineSpatialObject<2> LineSpatialObjectType; // Instantiating object LineSpatialObjectType::Pointer object = LineSpatialObjectType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbSpatialObjectSourceNew.cxx000066400000000000000000000020711301006202600274140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSpatialObjectSource.h" #include "itkGroupSpatialObject.h" int otbSpatialObjectSourceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::GroupSpatialObject SpatialObjectType; typedef otb::SpatialObjectSource SpatialObjectSourceType; // Instantiation SpatialObjectSourceType::Pointer source = SpatialObjectSourceType::New(); std::cout << source << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbSpatialObjectToImageDrawingFilter.cxx000066400000000000000000000042051301006202600315120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSpatialObjectToImageDrawingFilter.h" #include "itkEllipseSpatialObject.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbSpatialObjectToImageDrawingFilter(int itkNotUsed(argc), char * argv[]) { const char * outputFilename = argv[1]; const double radiusx = atof(argv[2]); const double radiusy = atof(argv[3]); const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileWriter WriterType; typedef itk::EllipseSpatialObject SpatialObjectType; typedef otb::SpatialObjectToImageDrawingFilter SpatialObjectToImageDrawingFilterType; // Instantiating object SpatialObjectToImageDrawingFilterType::Pointer filter = SpatialObjectToImageDrawingFilterType::New(); WriterType::Pointer writer = WriterType::New(); SpatialObjectType::Pointer ellipse = SpatialObjectType::New(); SpatialObjectType::ArrayType radius; radius[0] = radiusx; radius[1] = radiusy; ellipse->SetRadius(radius); ImageType::PointType origin; origin[0] = -radiusx; origin[1] = -radiusy; filter->SetInput(ellipse); filter->SetOrigin(origin); filter->SetInsideValue(255); filter->SetOutsideValue(0); writer->SetInput(filter->GetOutput()); writer->SetFileName(outputFilename); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbSpatialObjectToImageDrawingFilterNew.cxx000066400000000000000000000026011301006202600321620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSpatialObjectToImageDrawingFilter.h" #include "itkGroupSpatialObject.h" #include "otbImage.h" int otbSpatialObjectToImageDrawingFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::GroupSpatialObject SpatialObjectType; typedef otb::SpatialObjectToImageDrawingFilter SpatialObjectToImageDrawingFilterType; // Instantiating object SpatialObjectToImageDrawingFilterType::Pointer filter = SpatialObjectToImageDrawingFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/SpatialObjects/test/otbSpatialObjectsTestDriver.cxx000066400000000000000000000011211301006202600277530ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbLineSpatialObjectListToPointSetFilterNew); REGISTER_TEST(otbSpatialObjectToImageDrawingFilter); REGISTER_TEST(otbDrawLineSpatialObject); REGISTER_TEST(otbSpatialObjectToImageDrawingFilterNew); REGISTER_TEST(otbLineSpatialObjectList); REGISTER_TEST(otbLineSpatialObjectNew); REGISTER_TEST(otbDrawLineSpatialObjectListNew); REGISTER_TEST(otbDrawLineSpatialObjectList); REGISTER_TEST(otbSpatialObjectSourceNew); REGISTER_TEST(otbImageToLineSpatialObjectListNew); REGISTER_TEST(otbDrawLineSpatialObjectNew); } OTB-release-5.8/Modules/Core/Streaming/000077500000000000000000000000001301006202600176475ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Streaming/CMakeLists.txt000066400000000000000000000001221301006202600224020ustar00rootroot00000000000000project(OTBStreaming) set(OTBStreaming_LIBRARIES OTBStreaming) otb_module_impl() OTB-release-5.8/Modules/Core/Streaming/include/000077500000000000000000000000001301006202600212725ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Streaming/include/otbNumberOfDivisionsStrippedStreamingManager.h000066400000000000000000000061231301006202600324370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNumberOfDivisionsStrippedStreamingManager_h #define otbNumberOfDivisionsStrippedStreamingManager_h #include "otbStreamingManager.h" #include "itkImageRegionSplitterSlowDimension.h" namespace otb { /** \class NumberOfDivisionsStrippedStreamingManager * \brief This class computes the divisions needed to stream an image by strips, * driven by a user-defined number of divisions in which to divide the images. * * You can use SetNumberOfDivisions to ask for a specific number of divisions. * The number of strips will be computed to fit this requirements as close as possible. * * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT NumberOfDivisionsStrippedStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef NumberOfDivisionsStrippedStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename Superclass::RegionType RegionType; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(NumberOfDivisionsStrippedStreamingManager, itk::LightObject); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** The number of lines per strip desired */ itkSetMacro(NumberOfDivisions, unsigned int); /** The number of lines per strip desired */ itkGetMacro(NumberOfDivisions, unsigned int); /** Actually computes the stream divisions given a DataObject and its region to write */ void PrepareStreaming(itk::DataObject * /*input*/, const RegionType ®ion) ITK_OVERRIDE; protected: NumberOfDivisionsStrippedStreamingManager(); ~NumberOfDivisionsStrippedStreamingManager() ITK_OVERRIDE; /** The splitter type used to generate the different strips */ typedef itk::ImageRegionSplitterSlowDimension SplitterType; /** The number of lines per strip desired by the user. * This may be different than the one computed by the Splitter */ unsigned int m_NumberOfDivisions; private: NumberOfDivisionsStrippedStreamingManager(const NumberOfDivisionsStrippedStreamingManager &); void operator =(const NumberOfDivisionsStrippedStreamingManager&); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNumberOfDivisionsStrippedStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbNumberOfDivisionsStrippedStreamingManager.txx000066400000000000000000000034371301006202600330400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNumberOfDivisionsStrippedStreamingManager_txx #define otbNumberOfDivisionsStrippedStreamingManager_txx #include "otbNumberOfDivisionsStrippedStreamingManager.h" #include "otbMacro.h" namespace otb { template NumberOfDivisionsStrippedStreamingManager::NumberOfDivisionsStrippedStreamingManager() : m_NumberOfDivisions(0) { } template NumberOfDivisionsStrippedStreamingManager::~NumberOfDivisionsStrippedStreamingManager() { } template void NumberOfDivisionsStrippedStreamingManager::PrepareStreaming( itk::DataObject * /*input*/, const RegionType ®ion ) { otbMsgDevMacro(<< "Activating NumberOfDivisionsStrippedStreamingManager streaming mode") if (m_NumberOfDivisions < 1) { itkWarningMacro(<< "NumberOfDivisions set to 0 : streaming disabled") m_NumberOfDivisions = 1; } this->m_Splitter = itk::ImageRegionSplitterSlowDimension::New(); this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, m_NumberOfDivisions); otbMsgDevMacro(<< "Computed number of split : " << this->m_ComputedNumberOfSplits) // Save the region to generate the splits later this->m_Region = region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbNumberOfDivisionsTiledStreamingManager.h000066400000000000000000000055721301006202600317150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNumberOfDivisionsTiledStreamingManager_h #define otbNumberOfDivisionsTiledStreamingManager_h #include "otbStreamingManager.h" namespace otb { /** \class NumberOfDivisionsTiledStreamingManager * \brief This class computes the divisions needed to stream an image by strips, * driven by a user-defined number of divisions in which to divide the images. * * You can use SetNumberOfDivisions to ask for a specific number of divisions. * The number of strips will be computed to fit this requirements as close as possible. * * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT NumberOfDivisionsTiledStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef NumberOfDivisionsTiledStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename Superclass::RegionType RegionType; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(NumberOfDivisionsTiledStreamingManager, itk::LightObject); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** The number of lines per strip desired */ itkSetMacro(NumberOfDivisions, unsigned int); /** The number of lines per strip desired */ itkGetMacro(NumberOfDivisions, unsigned int); /** Actually computes the stream divisions given a DataObject and its region to write */ void PrepareStreaming(itk::DataObject * input, const RegionType ®ion) ITK_OVERRIDE; protected: NumberOfDivisionsTiledStreamingManager(); ~NumberOfDivisionsTiledStreamingManager() ITK_OVERRIDE; /** The number of lines per strip desired by the user. * This may be different than the one computed by the Splitter */ unsigned int m_NumberOfDivisions; private: NumberOfDivisionsTiledStreamingManager(const NumberOfDivisionsTiledStreamingManager &); void operator =(const NumberOfDivisionsTiledStreamingManager&); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNumberOfDivisionsTiledStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbNumberOfDivisionsTiledStreamingManager.txx000066400000000000000000000035301301006202600323010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNumberOfDivisionsTiledStreamingManager_txx #define otbNumberOfDivisionsTiledStreamingManager_txx #include "otbNumberOfDivisionsTiledStreamingManager.h" #include "otbMacro.h" #include "otbImageRegionSquareTileSplitter.h" namespace otb { template NumberOfDivisionsTiledStreamingManager::NumberOfDivisionsTiledStreamingManager() : m_NumberOfDivisions(0) { } template NumberOfDivisionsTiledStreamingManager::~NumberOfDivisionsTiledStreamingManager() { } template void NumberOfDivisionsTiledStreamingManager::PrepareStreaming( itk::DataObject * /*input*/, const RegionType ®ion ) { otbMsgDevMacro(<< "Activating NumberOfDivisionsTiledStreamingManager streaming mode") if (m_NumberOfDivisions < 1) { itkWarningMacro(<< "NumberOfDivisions set to 0 : streaming disabled") m_NumberOfDivisions = 1; } this->m_Splitter = otb::ImageRegionSquareTileSplitter::New(); this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, m_NumberOfDivisions); otbMsgDevMacro(<< "Computed number of split : " << this->m_ComputedNumberOfSplits) // Save the region to generate the splits later this->m_Region = region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbNumberOfLinesStrippedStreamingManager.h000066400000000000000000000062021301006202600315400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNumberOfLinesStrippedStreamingManager_h #define otbNumberOfLinesStrippedStreamingManager_h #include "otbStreamingManager.h" #include "itkImageRegionSplitter.h" namespace otb { /** \class NumberOfLinesStrippedStreamingManager * \brief This class computes the divisions needed to stream an image by strips, * driven by a user-defined desired number of lines per strips. * * You can use SetNumberOfLinesPerStrip to ask for a specific number of lines per strip. * The number of strips will be computed to fit this requirements as close as possible. * * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT NumberOfLinesStrippedStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef NumberOfLinesStrippedStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename Superclass::RegionType RegionType; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(NumberOfLinesStrippedStreamingManager, itk::LightObject); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** The number of lines per strip desired */ itkSetMacro(NumberOfLinesPerStrip, unsigned int); /** The number of lines per strip desired */ itkGetMacro(NumberOfLinesPerStrip, unsigned int); /** Actually computes the stream divisions, according to the specified streaming mode, * eventually using the input parameter to estimate memory consumption */ void PrepareStreaming(itk::DataObject * /*input*/, const RegionType ®ion) ITK_OVERRIDE; protected: NumberOfLinesStrippedStreamingManager(); ~NumberOfLinesStrippedStreamingManager() ITK_OVERRIDE; /** The splitter type used to generate the different strips */ typedef itk::ImageRegionSplitter SplitterType; /** The number of lines per strip desired by the user. * This may be different than the one computed by the Splitter */ unsigned int m_NumberOfLinesPerStrip; private: NumberOfLinesStrippedStreamingManager(const NumberOfLinesStrippedStreamingManager &); void operator =(const NumberOfLinesStrippedStreamingManager&); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNumberOfLinesStrippedStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbNumberOfLinesStrippedStreamingManager.txx000066400000000000000000000043111301006202600321330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNumberOfLinesStrippedStreamingManager_txx #define otbNumberOfLinesStrippedStreamingManager_txx #include "otbNumberOfLinesStrippedStreamingManager.h" #include "otbMacro.h" namespace otb { template NumberOfLinesStrippedStreamingManager::NumberOfLinesStrippedStreamingManager() : m_NumberOfLinesPerStrip(0) { } template NumberOfLinesStrippedStreamingManager::~NumberOfLinesStrippedStreamingManager() { } template void NumberOfLinesStrippedStreamingManager::PrepareStreaming( itk::DataObject * /*input*/, const RegionType ®ion ) { otbMsgDevMacro(<< "Activating STRIPPED_SET_NUMBEROFLINES streaming mode") if (m_NumberOfLinesPerStrip < 1) { itkWarningMacro(<< "DesiredNumberOfLines set to 0 : streaming disabled") } // Calculate number of splits unsigned long numberLinesOfRegion = region.GetSize()[1]; // Y dimension unsigned long nbSplit; if (numberLinesOfRegion > m_NumberOfLinesPerStrip && m_NumberOfLinesPerStrip > 0) { nbSplit = static_cast(vcl_ceil(static_cast(numberLinesOfRegion) / static_cast(m_NumberOfLinesPerStrip) ) ); } else { // Don't stream nbSplit = 1; } this->m_Splitter = itk::ImageRegionSplitter::New(); this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, nbSplit); otbMsgDevMacro(<< "Computed number of split : " << this->m_ComputedNumberOfSplits) // Save the region to generate the splits later this->m_Region = region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbPersistentFilterStreamingDecorator.h000066400000000000000000000066341301006202600312040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentFilterStreamingDecorator_h #define otbPersistentFilterStreamingDecorator_h #include "otbStreamingImageVirtualWriter.h" #include "itkProcessObject.h" namespace otb { /** \class PersistentFilterStreamingDecorator * \brief This filter link a persistent filter with a StreamingImageVirtualWriter. * * The StreamingVirtualWriter will break the input image into pieces and stream each * piece through the persistent filter. That way, the persistent filter will computes * its data on the whole image, but never loads the whole of it, and eventually processes * each piece with multiple threads. Before the streaming of the whole image is triggered, * the Reset() method of the persistent filter is called to clear the temporary data it might * contain. After the streaming, the Synthetize() method is called to synthetize the * temporary data. One can access the persistent filter via the GetFilter() method, and * StreamingVirtualWriter via the GetStreamer() method. * * \sa StreamingStatisticsImageFilter * \sa StreamingStatisticsVectorImageFilter * * \ingroup OTBStreaming */ template class ITK_EXPORT PersistentFilterStreamingDecorator : public itk::ProcessObject { public: /** Standard typedefs */ typedef PersistentFilterStreamingDecorator Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(PersistentFilterStreamingDecorator, ProcessObject); /** Template parameters typedefs */ typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; typedef typename FilterType::InputImageType ImageType; typedef StreamingImageVirtualWriter StreamerType; typedef typename StreamerType::Pointer StreamerPointerType; itkSetObjectMacro(Filter, FilterType); itkGetObjectMacro(Filter, FilterType); itkGetConstObjectMacro(Filter, FilterType); itkGetObjectMacro(Streamer, StreamerType); void Update(void) ITK_OVERRIDE; protected: /** Constructor */ PersistentFilterStreamingDecorator(); /** Destructor */ ~PersistentFilterStreamingDecorator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; /// Object responsible for streaming StreamerPointerType m_Streamer; /// Object responsible for computation FilterPointerType m_Filter; private: PersistentFilterStreamingDecorator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPersistentFilterStreamingDecorator.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbPersistentFilterStreamingDecorator.txx000066400000000000000000000034611301006202600315730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentFilterStreamingDecorator_txx #define otbPersistentFilterStreamingDecorator_txx #include "otbPersistentFilterStreamingDecorator.h" namespace otb { /** * Constructor */ template PersistentFilterStreamingDecorator ::PersistentFilterStreamingDecorator() { m_Filter = FilterType::New(); m_Streamer = StreamerType::New(); } template void PersistentFilterStreamingDecorator ::GenerateData(void) { // Reset the filter before the generation. this->GetFilter()->Reset(); /* for (unsigned int idx = 0; idx < this->GetFilter()->GetNumberOfOutputs(); ++idx) { this->GetStreamer()->SetNthInput(idx, this->GetFilter()->GetOutput(idx)); } */ this->GetStreamer()->SetInput(this->GetFilter()->GetOutput()); this->GetStreamer()->Update(); // Synthetize data after the streaming of the whole image. this->GetFilter()->Synthetize(); } template void PersistentFilterStreamingDecorator ::Update(void) { this->GenerateData(); } /** * PrintSelf Method */ template void PersistentFilterStreamingDecorator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbPersistentImageFilter.h000066400000000000000000000055731301006202600264330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentImageFilter_h #define otbPersistentImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class PersistentImageFilter * \brief This filter is the base class for all filter persisting data through multiple * update. * For instance, a filter computing global statistics on an image with streaming * capabilities will have to keep the temporary results for each streamed piece of the * image in order to synthesize the global statistics at the end. This filter is an * itk::ImageToImageFilter, providing two additional methods. The first one, Synthetize(), * allows the user to synthesize temporary data produced by the multiple updates on different * pieces of the image to the global result. The second one, Reset(), allows the user to * reset the temporary data for a new input image for instance. * * \note This class contains pure virtual method, and can not be instantiated. * * \sa StatisticsImageFilter * \sa StatisticsVectorImageFilter * * \ingroup OTBStreaming */ template class ITK_EXPORT PersistentImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef PersistentImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkTypeMacro(PersistentImageFilter, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** * Reset the persistent data of the filter. */ virtual void Reset(void) = 0; /** * Synthesize the persistent data of the filter. */ virtual void Synthetize(void) = 0; protected: /** Constructor */ PersistentImageFilter() {} /** Destructor */ ~PersistentImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: PersistentImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbPipelineMemoryPrintCalculator.h000066400000000000000000000130221301006202600301330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPipelineMemoryPrintCalculator_h #define otbPipelineMemoryPrintCalculator_h #include "itkProcessObject.h" #if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 8) #include "itksys/FundamentalType.h" #else #include "itk_kwiml.h" #endif #include #include "OTBStreamingExport.h" namespace otb { /** \class PipelineMemoryPrintCalculator * \brief Estimate pipeline memory usage and optimal stream divisions * * This class allows estimating the memory usage of a given pipeline * by tracing back pipeline from a given data (in general, this * data should be set to the data to write) and * examining each filter to determine its memory footprint. To do so, * it performs a dry run of the requested region pipeline * negotiation. * * The SetDataToWrite() method allows setting the data candidate for * writing, and for which memory usage estimation should be * performed. * * Additionally, this class allows computing the optimal number of * stream division to write the data. To do so, the available memory * can be set via the SetAvailableMemory() method, and an optional * bias correction factor can be applied to weight the estimate * memory usage in case a bias occurs between estimated and real * memory usage. The optimal number of stream divisions can be * retrieved using the GetOptimalNumberOfStreamDivisions(). * * Please note that for now this calculator suffers from the * following limitations: * - DataObject taken into account for memory usage estimation are * only Image, VectorImage and ImageList instantiation, * - The estimator is non-intrusive regarding the pipeline high-level * class, but it is not able to estimate memory usage of minipipeline * within composite filter (because there is no way to trace back to * these internal filters). Therefore, memory usage can be highly * biased depending on the filters in the upstream pipeline. The bias * correction factor parameters allows compensating this bias to the first * order. * * \ingroup OTBStreaming */ class OTBStreaming_EXPORT PipelineMemoryPrintCalculator : public itk::Object { public: /** Standard class typedefs */ typedef PipelineMemoryPrintCalculator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Useful typedefs */ typedef itk::ProcessObject ProcessObjectType; typedef ProcessObjectType::Pointer ProcessObjectPointerType; typedef itk::DataObject DataObjectType; typedef DataObjectType::Pointer DataObjectPointerType; #if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 8) typedef ::itksysFundamentalType_UInt64 MemoryPrintType; #else typedef KWIML_INT_uint64_t MemoryPrintType; #endif typedef std::set ProcessObjectPointerSetType; /** Run-time type information (and related methods). */ itkTypeMacro(PipelineMemoryPrintCalculator, itk::Object); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Get the total memory print (in bytes) */ itkGetMacro(MemoryPrint, MemoryPrintType); /** Set/Get the bias correction factor which will weight the * estimated memory print (allows compensating bias between * estimated and real memory print, default is 1., i.e. no correction) */ itkSetMacro(BiasCorrectionFactor, double); itkGetMacro(BiasCorrectionFactor, double); /** Get the optimal number of stream division */ static unsigned long EstimateOptimalNumberOfStreamDivisions( MemoryPrintType memoryPrint, MemoryPrintType availableMemory); /** Set last pipeline filter */ itkSetObjectMacro(DataToWrite, DataObjectType); /** Compute pipeline memory print */ void Compute(); /** Const conversion factor */ static const double ByteToMegabyte; static const double MegabyteToByte; /** Evaluate the print (in bytes) of a single data object */ MemoryPrintType EvaluateDataObjectPrint(DataObjectType * data) const; protected: /** Constructor */ PipelineMemoryPrintCalculator(); /** Destructor */ ~PipelineMemoryPrintCalculator() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Recursive method to evaluate memory print in bytes */ MemoryPrintType EvaluateProcessObjectPrintRecursive(ProcessObjectType * process); private: PipelineMemoryPrintCalculator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The total memory print of the pipeline */ MemoryPrintType m_MemoryPrint; /** Pointer to the last pipeline filter */ DataObjectPointerType m_DataToWrite; /** Bias correction factor */ double m_BiasCorrectionFactor; /** Visited ProcessObject set */ ProcessObjectPointerSetType m_VisitedProcessObjects; }; } // end of namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbRAMDrivenAdaptativeStreamingManager.h000066400000000000000000000065521301006202600311170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAMDrivenAdaptativeStreamingManager_h #define otbRAMDrivenAdaptativeStreamingManager_h #include "otbStreamingManager.h" namespace otb { /** \class RAMDrivenAdaptativeStreamingManager * \brief This class computes the divisions needed to stream an image * according to the input image tiling scheme and a user-defined * available RAM. * * This streaming manager uses the TileHint from the * MetaDataDictionary to find out the tiling sheme of the input file * if available. * * You can use SetAvailableRAMInMB to set the available RAM. An * estimation of the pipeline memory print will be done, and the * number of divisions will then be computed to fit the available RAM. * * \sa ImageRegionAdaptativeSplitter * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT RAMDrivenAdaptativeStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef RAMDrivenAdaptativeStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename Superclass::RegionType RegionType; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(RAMDrivenAdaptativeStreamingManager, itk::LightObject); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** The number of Megabytes available (if 0, the configuration option is used)*/ itkSetMacro(AvailableRAMInMB, unsigned int); /** The number of Megabytes available (if 0, the configuration option is used)*/ itkGetConstMacro(AvailableRAMInMB, unsigned int); /** The multiplier to apply to the memory print estimation */ itkSetMacro(Bias, double); /** The multiplier to apply to the memory print estimation */ itkGetConstMacro(Bias, double); /** Actually computes the stream divisions, according to the specified streaming mode, * eventually using the input parameter to estimate memory consumption */ void PrepareStreaming(itk::DataObject * input, const RegionType ®ion) ITK_OVERRIDE; protected: RAMDrivenAdaptativeStreamingManager(); ~RAMDrivenAdaptativeStreamingManager() ITK_OVERRIDE; /** The number of MegaBytes of RAM available */ unsigned int m_AvailableRAMInMB; /** The multiplier to apply to the memory print estimation */ double m_Bias; private: RAMDrivenAdaptativeStreamingManager(const RAMDrivenAdaptativeStreamingManager &); void operator =(const RAMDrivenAdaptativeStreamingManager&); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRAMDrivenAdaptativeStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbRAMDrivenAdaptativeStreamingManager.txx000066400000000000000000000046341301006202600315120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAMDrivenAdaptativeStreamingManager_txx #define otbRAMDrivenAdaptativeStreamingManager_txx #include "otbRAMDrivenAdaptativeStreamingManager.h" #include "otbMacro.h" #include "otbImageRegionAdaptativeSplitter.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" namespace otb { template RAMDrivenAdaptativeStreamingManager::RAMDrivenAdaptativeStreamingManager() : m_AvailableRAMInMB(0), m_Bias(1.0) { } template RAMDrivenAdaptativeStreamingManager::~RAMDrivenAdaptativeStreamingManager() { } template void RAMDrivenAdaptativeStreamingManager::PrepareStreaming( itk::DataObject * input, const RegionType ®ion ) { unsigned long nbDivisions = this->EstimateOptimalNumberOfDivisions(input, region, m_AvailableRAMInMB, m_Bias); typename otb::ImageRegionAdaptativeSplitter::SizeType tileHint; unsigned int tileHintX(0), tileHintY(0); itk::ExposeMetaData(input->GetMetaDataDictionary(), MetaDataKey::TileHintX, tileHintX); itk::ExposeMetaData(input->GetMetaDataDictionary(), MetaDataKey::TileHintY, tileHintY); tileHint[0] = tileHintX; tileHint[1] = tileHintY; typename otb::ImageRegionAdaptativeSplitter::Pointer splitter = otb::ImageRegionAdaptativeSplitter::New(); splitter->SetTileHint(tileHint); this->m_Splitter = splitter; this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, nbDivisions); otbMsgDevMacro(<< "Number of split : " << this->m_ComputedNumberOfSplits) this->m_Region = region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbRAMDrivenStrippedStreamingManager.h000066400000000000000000000065121301006202600306230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAMDrivenStrippedStreamingManager_h #define otbRAMDrivenStrippedStreamingManager_h #include "itkImageRegionSplitter.h" #include "otbStreamingManager.h" namespace otb { /** \class RAMDrivenStrippedStreamingManager * \brief This class computes the divisions needed to stream an image by strips, * according to a user-defined available RAM * * You can use SetAvailableRAMInMB to set the available RAM. An estimation of the pipeline * memory print will be done, and the number of divisions will then be computed to fit * the available RAM * * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT RAMDrivenStrippedStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef RAMDrivenStrippedStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename Superclass::RegionType RegionType; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(RAMDrivenStrippedStreamingManager, itk::LightObject); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** The number of Megabytes available (if 0, the configuration option is used)*/ itkSetMacro(AvailableRAMInMB, unsigned int); /** The number of Megabytes available (if 0, the configuration option is used)*/ itkGetConstMacro(AvailableRAMInMB, unsigned int); /** The multiplier to apply to the memory print estimation */ itkSetMacro(Bias, double); /** The multiplier to apply to the memory print estimation */ itkGetConstMacro(Bias, double); /** Actually computes the stream divisions, according to the specified streaming mode, * eventually using the input parameter to estimate memory consumption */ void PrepareStreaming(itk::DataObject * input, const RegionType ®ion) ITK_OVERRIDE; protected: RAMDrivenStrippedStreamingManager(); ~RAMDrivenStrippedStreamingManager() ITK_OVERRIDE; /** The splitter type used to generate the different strips */ typedef itk::ImageRegionSplitter SplitterType; /** The number of MegaBytes of RAM available */ unsigned int m_AvailableRAMInMB; /** The multiplier to apply to the memory print estimation */ double m_Bias; private: RAMDrivenStrippedStreamingManager(const RAMDrivenStrippedStreamingManager &); void operator =(const RAMDrivenStrippedStreamingManager&); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRAMDrivenStrippedStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbRAMDrivenStrippedStreamingManager.txx000066400000000000000000000027701301006202600312210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAMDrivenStrippedStreamingManager_txx #define otbRAMDrivenStrippedStreamingManager_txx #include "otbRAMDrivenStrippedStreamingManager.h" #include "otbMacro.h" namespace otb { template RAMDrivenStrippedStreamingManager::RAMDrivenStrippedStreamingManager() : m_AvailableRAMInMB(0), m_Bias(1.0) { } template RAMDrivenStrippedStreamingManager::~RAMDrivenStrippedStreamingManager() { } template void RAMDrivenStrippedStreamingManager::PrepareStreaming( itk::DataObject * input, const RegionType ®ion ) { unsigned long nbDivisions = this->EstimateOptimalNumberOfDivisions(input, region, m_AvailableRAMInMB, m_Bias); this->m_Splitter = itk::ImageRegionSplitter::New(); this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, nbDivisions); this->m_Region = region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbRAMDrivenTiledStreamingManager.h000066400000000000000000000061441301006202600300730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAMDrivenTiledStreamingManager_h #define otbRAMDrivenTiledStreamingManager_h #include "otbStreamingManager.h" namespace otb { /** \class RAMDrivenTiledStreamingManager * \brief This class computes the divisions needed to stream an image in square tiles, * according to a user-defined available RAM * * You can use SetAvailableRAMInMB to set the available RAM. An estimation of the pipeline * memory print will be done, and the number of divisions will then be computed to fit * the available RAM * * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT RAMDrivenTiledStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef RAMDrivenTiledStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename Superclass::RegionType RegionType; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(RAMDrivenTiledStreamingManager, itk::LightObject); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** The number of Megabytes available (if 0, the configuration option is used)*/ itkSetMacro(AvailableRAMInMB, unsigned int); /** The number of Megabytes available (if 0, the configuration option is used)*/ itkGetConstMacro(AvailableRAMInMB, unsigned int); /** The multiplier to apply to the memory print estimation */ itkSetMacro(Bias, double); /** The multiplier to apply to the memory print estimation */ itkGetConstMacro(Bias, double); /** Actually computes the stream divisions, according to the specified streaming mode, * eventually using the input parameter to estimate memory consumption */ void PrepareStreaming(itk::DataObject * input, const RegionType ®ion) ITK_OVERRIDE; protected: RAMDrivenTiledStreamingManager(); ~RAMDrivenTiledStreamingManager() ITK_OVERRIDE; /** The number of MegaBytes of RAM available */ unsigned int m_AvailableRAMInMB; /** The multiplier to apply to the memory print estimation */ double m_Bias; private: RAMDrivenTiledStreamingManager(const RAMDrivenTiledStreamingManager &); void operator =(const RAMDrivenTiledStreamingManager&); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRAMDrivenTiledStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbRAMDrivenTiledStreamingManager.txx000066400000000000000000000031551301006202600304660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAMDrivenTiledStreamingManager_txx #define otbRAMDrivenTiledStreamingManager_txx #include "otbRAMDrivenTiledStreamingManager.h" #include "otbMacro.h" #include "otbImageRegionSquareTileSplitter.h" namespace otb { template RAMDrivenTiledStreamingManager::RAMDrivenTiledStreamingManager() : m_AvailableRAMInMB(0), m_Bias(1.0) { } template RAMDrivenTiledStreamingManager::~RAMDrivenTiledStreamingManager() { } template void RAMDrivenTiledStreamingManager::PrepareStreaming( itk::DataObject * input, const RegionType ®ion ) { unsigned long nbDivisions = this->EstimateOptimalNumberOfDivisions(input, region, m_AvailableRAMInMB, m_Bias); this->m_Splitter = otb::ImageRegionSquareTileSplitter::New(); this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, nbDivisions); otbMsgDevMacro(<< "Number of split : " << this->m_ComputedNumberOfSplits) this->m_Region = region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbStreamingImageVirtualWriter.h000066400000000000000000000164401301006202600276150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingImageVirtualWriter_h #define otbStreamingImageVirtualWriter_h #include "itkMacro.h" #include "itkImageToImageFilter.h" #include "otbStreamingManager.h" namespace otb { /** \class StreamingImageVirtualWriter * \brief This class acts like a StreamingImageFileWriter, but without actually * writing data to the disk. * * This allows streaming the whole image through persistent filters such as * PersitentStatisticsImageFilter in order to get the global statistics of an image. * * This filter is not intended to be used with classic ImageToImageFilter, though it * will not generate any error. * * The computation of divisions can be done following different strategies * by setting the StreamingManager attributes with SetStreamingManager. * A set of behaviors are available with the following methods : * - SetNumberOfLinesStrippedStreaming : divide by strips, according to a number of lines * - SetAutomaticStrippedStreaming : divide by strips, according to available RAM * - SetTileDimensionTiledStreaming : divide by tiles, according to a desired tile dimension * - SetAutomaticTiledStreaming : divide by tiles, according to available RAM * * It is used in the PersistentFilterStreamingDecorator helper class to propose an easy * way to stream an image through a persistent filter. * * \sa PersistentImageFilter * \sa PersistentStatisticsImageFilter * \sa PersistentImageStreamingDecorator. * * \ingroup OTBStreaming */ template class ITK_EXPORT StreamingImageVirtualWriter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef StreamingImageVirtualWriter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(StreamingImageVirtualWriter, itk::ImageToImageFilter); /** Some typedefs for the input and output. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; /** Streaming manager base class pointer */ typedef StreamingManager StreamingManagerType; typedef typename StreamingManagerType::Pointer StreamingManagerPointerType; /** Dimension of input image. */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); /** Return the StreamingManager object responsible for dividing * the region to write */ StreamingManagerType* GetStreamingManager(void) { return m_StreamingManager; } /** Set a user-specific implementation of StreamingManager * used to divide the largest possible region in several divisions */ void SetStreamingManager(StreamingManagerType* streamingManager) { m_StreamingManager = streamingManager; } /** Set the streaming mode to 'stripped' and configure the number of strips * which will be used to stream the image */ void SetNumberOfDivisionsStrippedStreaming(unsigned int nbDivisions); /** Set the streaming mode to 'tiled' and configure the number of tiles * which will be used to stream the image */ void SetNumberOfDivisionsTiledStreaming(unsigned int nbDivisions); /** Set the streaming mode to 'stripped' and configure the number of strips * which will be used to stream the image */ void SetNumberOfLinesStrippedStreaming(unsigned int nbLinesPerStrip); /** Set the streaming mode to 'stripped' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option */ void SetAutomaticStrippedStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the streaming mode to 'tiled' and configure the dimension of the tiles * in pixels for each dimension (square tiles will be generated) */ void SetTileDimensionTiledStreaming(unsigned int tileDimension); /** Set the streaming mode to 'tiled' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Tiles will be square. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option */ void SetAutomaticTiledStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the streaming mode to 'adaptative' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Tiles will try to match the input file tile scheme. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option */ void SetAutomaticAdaptativeStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Override Update() from ProcessObject * This filter does not produce an output */ void Update() ITK_OVERRIDE; protected: StreamingImageVirtualWriter(); ~StreamingImageVirtualWriter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; void GenerateInputRequestedRegion(void) ITK_OVERRIDE; private: StreamingImageVirtualWriter(const StreamingImageVirtualWriter &); //purposely not implemented void operator =(const StreamingImageVirtualWriter&); //purposely not implemented void ObserveSourceFilterProgress(itk::Object* object, const itk::EventObject & event ) { if (typeid(event) != typeid(itk::ProgressEvent)) { return; } itk::ProcessObject* processObject = dynamic_cast(object); if (processObject) { m_DivisionProgress = processObject->GetProgress(); } this->UpdateFilterProgress(); } void UpdateFilterProgress() { this->UpdateProgress( (m_DivisionProgress + m_CurrentDivision) / m_NumberOfDivisions ); } unsigned int m_NumberOfDivisions; unsigned int m_CurrentDivision; float m_DivisionProgress; StreamingManagerPointerType m_StreamingManager; bool m_IsObserving; unsigned long m_ObserverID; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingImageVirtualWriter.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbStreamingImageVirtualWriter.txx000066400000000000000000000216601301006202600302110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingImageVirtualWriter_txx #define otbStreamingImageVirtualWriter_txx #include "otbStreamingImageVirtualWriter.h" #include "otbMacro.h" #include "itkCommand.h" #include "otbNumberOfDivisionsStrippedStreamingManager.h" #include "otbNumberOfDivisionsTiledStreamingManager.h" #include "otbNumberOfLinesStrippedStreamingManager.h" #include "otbRAMDrivenStrippedStreamingManager.h" #include "otbTileDimensionTiledStreamingManager.h" #include "otbRAMDrivenTiledStreamingManager.h" #include "otbRAMDrivenAdaptativeStreamingManager.h" namespace otb { template StreamingImageVirtualWriter ::StreamingImageVirtualWriter() : m_NumberOfDivisions(0), m_CurrentDivision(0), m_DivisionProgress(0.0), m_IsObserving(true), m_ObserverID(0) { // By default, we use tiled streaming, with automatic tile size // We don't set any parameter, so the memory size is retrieved from the OTB configuration options this->SetAutomaticAdaptativeStreaming(); } template StreamingImageVirtualWriter ::~StreamingImageVirtualWriter() { } template void StreamingImageVirtualWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void StreamingImageVirtualWriter ::SetNumberOfDivisionsStrippedStreaming(unsigned int nbDivisions) { typedef NumberOfDivisionsStrippedStreamingManager NumberOfDivisionsStrippedStreamingManagerType; typename NumberOfDivisionsStrippedStreamingManagerType::Pointer streamingManager = NumberOfDivisionsStrippedStreamingManagerType::New(); streamingManager->SetNumberOfDivisions(nbDivisions); m_StreamingManager = streamingManager; } template void StreamingImageVirtualWriter ::SetNumberOfDivisionsTiledStreaming(unsigned int nbDivisions) { typedef NumberOfDivisionsTiledStreamingManager NumberOfDivisionsTiledStreamingManagerType; typename NumberOfDivisionsTiledStreamingManagerType::Pointer streamingManager = NumberOfDivisionsTiledStreamingManagerType::New(); streamingManager->SetNumberOfDivisions(nbDivisions); m_StreamingManager = streamingManager; } template void StreamingImageVirtualWriter ::SetNumberOfLinesStrippedStreaming(unsigned int nbLinesPerStrip) { typedef NumberOfLinesStrippedStreamingManager NumberOfLinesStrippedStreamingManagerType; typename NumberOfLinesStrippedStreamingManagerType::Pointer streamingManager = NumberOfLinesStrippedStreamingManagerType::New(); streamingManager->SetNumberOfLinesPerStrip(nbLinesPerStrip); m_StreamingManager = streamingManager; } template void StreamingImageVirtualWriter ::SetAutomaticStrippedStreaming(unsigned int availableRAM, double bias) { typedef RAMDrivenStrippedStreamingManager RAMDrivenStrippedStreamingManagerType; typename RAMDrivenStrippedStreamingManagerType::Pointer streamingManager = RAMDrivenStrippedStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } template void StreamingImageVirtualWriter ::SetTileDimensionTiledStreaming(unsigned int tileDimension) { typedef TileDimensionTiledStreamingManager TileDimensionTiledStreamingManagerType; typename TileDimensionTiledStreamingManagerType::Pointer streamingManager = TileDimensionTiledStreamingManagerType::New(); streamingManager->SetTileDimension(tileDimension); m_StreamingManager = streamingManager; } template void StreamingImageVirtualWriter ::SetAutomaticTiledStreaming(unsigned int availableRAM, double bias) { typedef RAMDrivenTiledStreamingManager RAMDrivenTiledStreamingManagerType; typename RAMDrivenTiledStreamingManagerType::Pointer streamingManager = RAMDrivenTiledStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } template void StreamingImageVirtualWriter ::SetAutomaticAdaptativeStreaming(unsigned int availableRAM, double bias) { typedef RAMDrivenAdaptativeStreamingManager RAMDrivenAdaptativeStreamingManagerType; typename RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } template void StreamingImageVirtualWriter ::Update() { InputImagePointer inputPtr = const_cast(this->GetInput(0)); inputPtr->UpdateOutputInformation(); this->GenerateData(); } template void StreamingImageVirtualWriter ::GenerateInputRequestedRegion(void) { InputImagePointer inputPtr = const_cast(this->GetInput(0)); InputImageRegionType region; typename InputImageRegionType::SizeType size; typename InputImageRegionType::IndexType index; index.Fill(0); size.Fill(0); region.SetSize(size); region.SetIndex(index); inputPtr->SetRequestedRegion(region); } template void StreamingImageVirtualWriter ::GenerateData(void) { /** * Prepare all the outputs. This may deallocate previous bulk data. */ this->PrepareOutputs(); this->SetAbortGenerateData(0); this->SetProgress(0.0); this->m_Updating = true; /** * Tell all Observers that the filter is starting */ this->InvokeEvent(itk::StartEvent()); /** * Grab the input */ InputImagePointer inputPtr = const_cast(this->GetInput(0)); InputImageRegionType outputRegion = inputPtr->GetLargestPossibleRegion(); /** * Determine of number of pieces to divide the input. This will be the * minimum of what the user specified via SetNumberOfDivisionsStrippedStreaming() * and what the Splitter thinks is a reasonable value. */ m_StreamingManager->PrepareStreaming(inputPtr, outputRegion); m_NumberOfDivisions = m_StreamingManager->GetNumberOfSplits(); /** * Register to the ProgressEvent of the source filter */ // Get the source process object itk::ProcessObject* source = inputPtr->GetSource(); m_IsObserving = false; m_ObserverID = 0; // Check if source exists if(source) { typedef itk::MemberCommand CommandType; typedef typename CommandType::Pointer CommandPointerType; CommandPointerType command = CommandType::New(); command->SetCallbackFunction(this, &Self::ObserveSourceFilterProgress); m_ObserverID = source->AddObserver(itk::ProgressEvent(), command); m_IsObserving = true; } else { itkWarningMacro(<< "Could not get the source process object. Progress report might be buggy"); } /** * Loop over the number of pieces, execute the upstream pipeline on each * piece, and copy the results into the output image. */ InputImageRegionType streamRegion; for (m_CurrentDivision = 0; m_CurrentDivision < m_NumberOfDivisions && !this->GetAbortGenerateData(); m_CurrentDivision++, m_DivisionProgress = 0, this->UpdateFilterProgress()) { streamRegion = m_StreamingManager->GetSplit(m_CurrentDivision); otbMsgDevMacro(<< "Processing region : " << streamRegion ) //inputPtr->ReleaseData(); //inputPtr->SetRequestedRegion(streamRegion); //inputPtr->Update(); inputPtr->SetRequestedRegion(streamRegion); inputPtr->PropagateRequestedRegion(); inputPtr->UpdateOutputData(); } /** * If we ended due to aborting, push the progress up to 1.0 (since * it probably didn't end there) */ if (!this->GetAbortGenerateData()) { this->UpdateProgress(1.0); } // Notify end event observers this->InvokeEvent(itk::EndEvent()); if (m_IsObserving) { m_IsObserving = false; source->RemoveObserver(m_ObserverID); } /** * Now we have to mark the data as up to data. */ for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx) { if (this->GetOutput(idx)) { this->GetOutput(idx)->DataHasBeenGenerated(); } } /** * Release any inputs if marked for release */ this->ReleaseInputs(); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbStreamingManager.h000066400000000000000000000107331301006202600254000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingManager_h #define otbStreamingManager_h #include "otbMacro.h" #include "itkDataObject.h" #include "itkImageRegionSplitterBase.h" #include "otbPipelineMemoryPrintCalculator.h" namespace otb { /** \class StreamingManager * \brief This class handles the streaming process used in the writers implementation * * The streaming mode can be chosen with either SetStrippedRAMStreamingMode, SetStrippedNumberOfLinesStreamingMode, * SetTiledRAMStreamingMode, or SetTiledTileDimensionStreamingMode. * * Then, PrepareStreaming must be called so that the stream type and dimensions are computed * This involves passing the actual DataObject who will be written, since it will be used * during memory estimation for some specific streaming modes. * * After PrepareStreaming has been called, the actual number of splits and streaming mode which will be used * can be retrieved with GetStreamingMode and GetNumberOfSplits. * The different splits can be retrieved with GetSplit * * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT StreamingManager : public itk::Object { public: /** Standard class typedefs. */ typedef StreamingManager Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::RegionType RegionType; typedef typename RegionType::IndexType IndexType; typedef typename RegionType::SizeType SizeType; typedef typename ImageType::InternalPixelType PixelType; typedef otb::PipelineMemoryPrintCalculator::MemoryPrintType MemoryPrintType; /** Type macro */ itkTypeMacro(StreamingManager, itk::LightObject); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** Actually computes the stream divisions, according to the specified streaming mode, * eventually using the input parameter to estimate memory consumption */ virtual void PrepareStreaming(itk::DataObject * input, const RegionType ®ion) = 0; /** Returns the actual number of pieces that will be used to process the image. * PrepareStreaming() must have been called before. * This can be different than the requested number */ virtual unsigned int GetNumberOfSplits(); /** Get a region definition that represents the ith piece a specified region. * The "numberOfPieces" must be equal to what * GetNumberOfSplits() returns. */ virtual RegionType GetSplit(unsigned int i); protected: StreamingManager(); ~StreamingManager() ITK_OVERRIDE; virtual unsigned int EstimateOptimalNumberOfDivisions(itk::DataObject * input, const RegionType ®ion, MemoryPrintType availableRAMInMB, double bias = 1.0); /** The number of splits generated by the splitter */ unsigned int m_ComputedNumberOfSplits; /** The region to stream */ RegionType m_Region; /** The splitter used to compute the different strips */ typedef itk::ImageRegionSplitterBase AbstractSplitterType; typedef typename AbstractSplitterType::Pointer AbstractSplitterPointerType; AbstractSplitterPointerType m_Splitter; private: StreamingManager(const StreamingManager &); //purposely not implemented void operator =(const StreamingManager&); //purposely not implemented /* Compute the available RAM from configuration settings if the input parameter is 0, * otherwise, simply returns the input parameter */ MemoryPrintType GetActualAvailableRAMInBytes(MemoryPrintType availableRAMInMB); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbStreamingManager.txx000066400000000000000000000130061301006202600257700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingManager_txx #define otbStreamingManager_txx #include "otbStreamingManager.h" #include "otbConfigurationManager.h" #include "itkExtractImageFilter.h" namespace otb { template StreamingManager::StreamingManager() : m_ComputedNumberOfSplits(0) { } template StreamingManager::~StreamingManager() { } template typename StreamingManager::MemoryPrintType StreamingManager::GetActualAvailableRAMInBytes(MemoryPrintType availableRAMInMB) { MemoryPrintType availableRAMInBytes = availableRAMInMB * 1024 * 1024; if (availableRAMInBytes == 0) { otbMsgDevMacro(<< "Retrieving available RAM size from configuration"); // Retrieve it from the configuration availableRAMInBytes = 1024*1024*ConfigurationManager::GetMaxRAMHint(); } otbMsgDevMacro("RAM used to estimate memory footprint : " << availableRAMInBytes / 1024 / 1024 << " MB") return availableRAMInBytes; } template unsigned int StreamingManager::EstimateOptimalNumberOfDivisions(itk::DataObject * input, const RegionType ®ion, MemoryPrintType availableRAM, double bias) { otbMsgDevMacro(<< "availableRAM " << availableRAM) MemoryPrintType availableRAMInBytes = GetActualAvailableRAMInBytes(availableRAM); otb::PipelineMemoryPrintCalculator::Pointer memoryPrintCalculator; memoryPrintCalculator = otb::PipelineMemoryPrintCalculator::New(); // Trick to avoid having the resampler compute the whole // displacement field double regionTrickFactor = 1; ImageType* inputImage = dynamic_cast(input); MemoryPrintType pipelineMemoryPrint; if (inputImage) { typedef itk::ExtractImageFilter ExtractFilterType; typename ExtractFilterType::Pointer extractFilter = ExtractFilterType::New(); extractFilter->SetInput(inputImage); // Define a small region to run the memory footprint estimation, // around the image center, 100 pixels wide in each dimension SizeType smallSize; smallSize.Fill(100); IndexType index; index[0] = region.GetIndex()[0] + region.GetSize()[0]/2 - 50; index[1] = region.GetIndex()[1] + region.GetSize()[1]/2 - 50; RegionType smallRegion; smallRegion.SetSize(smallSize); smallRegion.SetIndex(index); // In case the image is smaller than 100 pixels in a direction smallRegion.Crop(region); extractFilter->SetExtractionRegion(smallRegion); bool smallRegionSuccess = smallRegion.Crop(region); if (smallRegionSuccess) { otbMsgDevMacro("Using an extract to estimate memory : " << smallRegion) // the region is well behaved, inside the largest possible region memoryPrintCalculator->SetDataToWrite(extractFilter->GetOutput() ); regionTrickFactor = static_cast( region.GetNumberOfPixels() ) / static_cast(smallRegion.GetNumberOfPixels() ); memoryPrintCalculator->SetBiasCorrectionFactor(regionTrickFactor * bias); } else { otbMsgDevMacro("Using the input region to estimate memory : " << region) // the region is not well behaved // use the full region memoryPrintCalculator->SetDataToWrite(input); memoryPrintCalculator->SetBiasCorrectionFactor(bias); } memoryPrintCalculator->Compute(); pipelineMemoryPrint = memoryPrintCalculator->GetMemoryPrint(); if (smallRegionSuccess) { // remove the contribution of the ExtractImageFilter MemoryPrintType extractContrib = memoryPrintCalculator->EvaluateDataObjectPrint(extractFilter->GetOutput()); pipelineMemoryPrint -= extractContrib; } } else { // Use the original object to estimate memory footprint memoryPrintCalculator->SetDataToWrite(input); memoryPrintCalculator->SetBiasCorrectionFactor(1.0); memoryPrintCalculator->Compute(); pipelineMemoryPrint = memoryPrintCalculator->GetMemoryPrint(); } unsigned int optimalNumberOfDivisions = otb::PipelineMemoryPrintCalculator::EstimateOptimalNumberOfStreamDivisions(pipelineMemoryPrint, availableRAMInBytes); otbMsgDevMacro( "Estimated Memory print for the full image : " << static_cast(pipelineMemoryPrint * otb::PipelineMemoryPrintCalculator::ByteToMegabyte ) << std::endl) otbMsgDevMacro( "Optimal number of stream divisions: " << optimalNumberOfDivisions << std::endl) return optimalNumberOfDivisions; } template unsigned int StreamingManager::GetNumberOfSplits() { return m_ComputedNumberOfSplits; } template typename StreamingManager::RegionType StreamingManager::GetSplit(unsigned int i) { typename StreamingManager::RegionType region( m_Region ); m_Splitter->GetSplit(i, m_ComputedNumberOfSplits, region); return region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/include/otbTileDimensionTiledStreamingManager.h000066400000000000000000000057041301006202600310500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileDimensionTiledStreamingManager_h #define otbTileDimensionTiledStreamingManager_h #include "otbStreamingManager.h" namespace otb { /** \class TileDimensionTiledStreamingManager * \brief This class computes the divisions needed to stream an image in square tiles, * driven by a user-defined tile dimension * * You can use SetTileDimension to ask for a specific tile size (number of pixels * for each dimension of the tile) * * The number of tiles will be computed to fit this requirement as close as possible. * * The tile dimension is always aligned on a multiple of 16 (as in TIFF spec) * * \sa ImageFileWriter * \sa StreamingImageVirtualFileWriter * * \ingroup OTBStreaming */ template class ITK_EXPORT TileDimensionTiledStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef TileDimensionTiledStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TImage ImageType; typedef typename Superclass::RegionType RegionType; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(TileDimensionTiledStreamingManager, StreamingManager); /** Dimension of input image. */ itkStaticConstMacro(ImageDimension, unsigned int, ImageType::ImageDimension); /** The desired tile dimension */ itkSetMacro(TileDimension, unsigned int); /** The desired tile dimension */ itkGetMacro(TileDimension, unsigned int); /** Actually computes the stream divisions, according to the specified streaming mode, * eventually using the input parameter to estimate memory consumption */ void PrepareStreaming(itk::DataObject * input, const RegionType ®ion) ITK_OVERRIDE; protected: TileDimensionTiledStreamingManager(); ~TileDimensionTiledStreamingManager() ITK_OVERRIDE; /** The number of lines per strip desired by the user. * This may be different than the one computed by the Splitter */ unsigned int m_TileDimension; private: TileDimensionTiledStreamingManager(const TileDimensionTiledStreamingManager &); void operator =(const TileDimensionTiledStreamingManager&); }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTileDimensionTiledStreamingManager.txx" #endif #endif OTB-release-5.8/Modules/Core/Streaming/include/otbTileDimensionTiledStreamingManager.txx000066400000000000000000000034021301006202600314350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileDimensionTiledStreamingManager_txx #define otbTileDimensionTiledStreamingManager_txx #include "otbTileDimensionTiledStreamingManager.h" #include "otbMacro.h" #include "otbImageRegionSquareTileSplitter.h" namespace otb { template TileDimensionTiledStreamingManager::TileDimensionTiledStreamingManager() : m_TileDimension(0) { } template TileDimensionTiledStreamingManager::~TileDimensionTiledStreamingManager() { } template void TileDimensionTiledStreamingManager::PrepareStreaming( itk::DataObject * /*input*/, const RegionType ®ion ) { if (m_TileDimension < 16) { itkWarningMacro(<< "TileDimension inferior to 16 : using 16 as tile dimension") m_TileDimension = 16; } // Calculate number of split this->m_Splitter = otb::ImageRegionSquareTileSplitter::New(); unsigned int nbDesiredTiles = itk::Math::Ceil( double(region.GetNumberOfPixels() ) / (m_TileDimension * m_TileDimension) ); this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, nbDesiredTiles); this->m_Region = region; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Streaming/otb-module.cmake000066400000000000000000000010101301006202600227100ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes related to streaming functionalities: only the data of a particular requested region are produced. This is useful when big images must be processed: processing is done piecewise, which prevents the system from running out of memory.") otb_module(OTBStreaming ENABLE_SHARED DEPENDS OTBCommon OTBITK OTBImageBase OTBOSSIMAdapters OTBObjectList TEST_DEPENDS OTBImageIO OTBStatistics OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/Streaming/src/000077500000000000000000000000001301006202600204365ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Streaming/src/CMakeLists.txt000066400000000000000000000004161301006202600231770ustar00rootroot00000000000000set(OTBStreaming_SRC otbPipelineMemoryPrintCalculator.cxx ) add_library(OTBStreaming ${OTBStreaming_SRC}) target_link_libraries(OTBStreaming ${OTBImageBase_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBStreaming) OTB-release-5.8/Modules/Core/Streaming/src/otbPipelineMemoryPrintCalculator.cxx000066400000000000000000000200361301006202600276550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPipelineMemoryPrintCalculator.h" #include "otbMacro.h" #include "otbMath.h" #include "otbImage.h" #include "otbVectorImage.h" #include "itkFixedArray.h" #include "otbImageList.h" namespace otb { const double PipelineMemoryPrintCalculator::ByteToMegabyte = 1./vcl_pow(2.0, 20); const double PipelineMemoryPrintCalculator::MegabyteToByte = vcl_pow(2.0, 20); PipelineMemoryPrintCalculator ::PipelineMemoryPrintCalculator() : m_MemoryPrint(0), m_DataToWrite(ITK_NULLPTR), m_BiasCorrectionFactor(1.), m_VisitedProcessObjects() {} PipelineMemoryPrintCalculator ::~PipelineMemoryPrintCalculator() {} // [static] unsigned long PipelineMemoryPrintCalculator ::EstimateOptimalNumberOfStreamDivisions(MemoryPrintType memoryPrint, MemoryPrintType availableMemory) { unsigned long divisions; divisions = vcl_ceil(static_cast(memoryPrint) / availableMemory); return divisions; } void PipelineMemoryPrintCalculator ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); // Display parameters os<UpdateOutputInformation(); m_DataToWrite->SetRequestedRegionToLargestPossibleRegion(); m_DataToWrite->PropagateRequestedRegion(); // Get the source process object ProcessObjectType * source = m_DataToWrite->GetSource(); // Check if source exists if(source) { // Call the recursive memory print evaluation m_MemoryPrint = EvaluateProcessObjectPrintRecursive(source); } else { // Get memory print for this data only m_MemoryPrint = EvaluateDataObjectPrint(m_DataToWrite); } // Apply bias correction factor m_MemoryPrint *= m_BiasCorrectionFactor; } PipelineMemoryPrintCalculator::MemoryPrintType PipelineMemoryPrintCalculator ::EvaluateProcessObjectPrintRecursive(ProcessObjectType * process) { otbMsgDevMacro(<< "EvaluateMemoryPrint for " << process->GetNameOfClass() << " (" << process << ")") // This variable will store the final print MemoryPrintType print = 0; // Check if this process object has already been visited if(m_VisitedProcessObjects.count(process)) { return print; } // Else register it as a visited process object else { m_VisitedProcessObjects.insert(process); } // Retrieve the array of inputs ProcessObjectType::DataObjectPointerArray inputs = process->GetInputs(); // First, recurse on each input source for(unsigned int i = 0; i < process->GetNumberOfInputs(); ++i) { // Retrieve the data object DataObjectType * input = inputs[i]; if( input ) { // Retrieve possible source ProcessObjectType * source = input->GetSource(); // If data object has a source if(source) { print += this->EvaluateProcessObjectPrintRecursive(source); } else { MemoryPrintType localPrint = this->EvaluateDataObjectPrint(input); print += localPrint; } } } // Retrieve the output array ProcessObjectType::DataObjectPointerArray outputs = process->GetOutputs(); // Now, evaluate the current object print for(unsigned int i = 0; i < process->GetNumberOfOutputs(); ++i) { MemoryPrintType localPrint = this->EvaluateDataObjectPrint(outputs[i]); print += localPrint; } // Finally, return the total print return print; } PipelineMemoryPrintCalculator::MemoryPrintType PipelineMemoryPrintCalculator ::EvaluateDataObjectPrint(DataObjectType * data) const { otbMsgDevMacro(<< "EvaluateMemoryPrint for " << data->GetNameOfClass() << " (" << data << ")") #define OTB_IMAGE_SIZE_BLOCK(type) \ if(dynamic_cast *>(data) != NULL) \ { \ itk::Image * image = dynamic_cast *>(data); \ return image->GetRequestedRegion().GetNumberOfPixels() \ * image->GetNumberOfComponentsPerPixel() * sizeof(type); \ } \ if(dynamic_cast * >(data) != NULL) \ { \ itk::VectorImage * image = dynamic_cast *>(data); \ return image->GetRequestedRegion().GetNumberOfPixels() \ * image->GetNumberOfComponentsPerPixel() * sizeof(type); \ } \ if(dynamic_cast > *>(data) != NULL) \ { \ ImageList > * imageList = dynamic_cast > *>(data); \ MemoryPrintType print(0); \ for(ImageList >::ConstIterator it = imageList->Begin(); \ it != imageList->End(); ++it) \ { \ print += it.Get()->GetRequestedRegion().GetNumberOfPixels() \ * it.Get()->GetNumberOfComponentsPerPixel() * sizeof(type); \ } \ return print; \ } \ if(dynamic_cast > *>(data) != NULL) \ { \ ImageList > * imageList = dynamic_cast > *>(data); \ MemoryPrintType print(0); \ for(ImageList >::ConstIterator it = imageList->Begin(); \ it != imageList->End(); ++it) \ { \ print += it.Get()->GetRequestedRegion().GetNumberOfPixels() \ * it.Get()->GetNumberOfComponentsPerPixel() * sizeof(type); \ } \ return print; \ } \ // Call the macro for each pixel type OTB_IMAGE_SIZE_BLOCK(unsigned char) OTB_IMAGE_SIZE_BLOCK(char) OTB_IMAGE_SIZE_BLOCK(unsigned short) OTB_IMAGE_SIZE_BLOCK(short) OTB_IMAGE_SIZE_BLOCK(unsigned int) OTB_IMAGE_SIZE_BLOCK(int) OTB_IMAGE_SIZE_BLOCK(unsigned long) OTB_IMAGE_SIZE_BLOCK(long) OTB_IMAGE_SIZE_BLOCK(float) OTB_IMAGE_SIZE_BLOCK(double) OTB_IMAGE_SIZE_BLOCK(std::complex) OTB_IMAGE_SIZE_BLOCK(std::complex) typedef itk::FixedArray FloatFixedArray2Type; typedef itk::FixedArray DoubleFixedArray2Type; OTB_IMAGE_SIZE_BLOCK(FloatFixedArray2Type) OTB_IMAGE_SIZE_BLOCK(DoubleFixedArray2Type) // If we are still here, none of the macro call succeed return 0; } } // End namespace otb OTB-release-5.8/Modules/Core/Streaming/test/000077500000000000000000000000001301006202600206265ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Streaming/test/CMakeLists.txt000066400000000000000000000050151301006202600233670ustar00rootroot00000000000000otb_module_test() set(OTBStreamingTests otbStreamingTestDriver.cxx otbStreamingManager.cxx otbPipelineMemoryPrintCalculatorTest.cxx ) add_executable(otbStreamingTestDriver ${OTBStreamingTests}) target_link_libraries(otbStreamingTestDriver ${OTBStreaming-Test_LIBRARIES}) otb_module_target_label(otbStreamingTestDriver) # Tests Declaration otb_add_test(NAME coTvRAMDrivenAdaptativeStreamingManager COMMAND otbStreamingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvRAMDrivenAdaptativeStreamingManager.txt ${TEMP}/coTvRAMDrivenAdaptativeStreamingManager.txt otbRAMDrivenAdaptativeStreamingManager ${TEMP}/coTvRAMDrivenAdaptativeStreamingManager.txt ) otb_add_test(NAME coTvRAMDrivenStrippedStreamingManager COMMAND otbStreamingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvRAMDrivenStrippedStreamingManager.txt ${TEMP}/coTvRAMDrivenStrippedStreamingManager.txt otbRAMDrivenStrippedStreamingManager ${TEMP}/coTvRAMDrivenStrippedStreamingManager.txt ) otb_add_test(NAME coTvNumberOfLinesStrippedStreamingManager COMMAND otbStreamingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvNumberOfLinesStrippedStreamingManager.txt ${TEMP}/coTvNumberOfLinesStrippedStreamingManager.txt otbNumberOfLinesStrippedStreamingManager ${TEMP}/coTvNumberOfLinesStrippedStreamingManager.txt ) otb_add_test(NAME coTvRAMDrivenTiledStreamingManager COMMAND otbStreamingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvRAMDrivenTiledStreamingManager.txt ${TEMP}/coTvRAMDrivenTiledStreamingManager.txt otbRAMDrivenTiledStreamingManager ${TEMP}/coTvRAMDrivenTiledStreamingManager.txt ) otb_add_test(NAME coTuStreamingManagerNew COMMAND otbStreamingTestDriver otbStreamingManagerNew ) otb_add_test(NAME coTvTileDimensionTiledStreamingManager COMMAND otbStreamingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvTileDimensionTiledStreamingManager.txt ${TEMP}/coTvTileDimensionTiledStreamingManager.txt otbTileDimensionTiledStreamingManager ${TEMP}/coTvTileDimensionTiledStreamingManager.txt ) otb_add_test(NAME coTvPipelineMemoryPrintCalculator COMMAND otbStreamingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvPipelineMemoryPrintCalculatorOutput.txt ${TEMP}/coTvPipelineMemoryPrintCalculatorOutput.txt otbPipelineMemoryPrintCalculatorTest ${INPUTDATA}/qb_RoadExtract.img ${TEMP}/coTvPipelineMemoryPrintCalculatorOutput.txt ) otb_add_test(NAME coTuPipelineMemoryPrintCalculatorNew COMMAND otbStreamingTestDriver otbPipelineMemoryPrintCalculatorNew ) OTB-release-5.8/Modules/Core/Streaming/test/otbPipelineMemoryPrintCalculatorTest.cxx000066400000000000000000000050661301006202600307130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPipelineMemoryPrintCalculator.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbVectorImageToIntensityImageFilter.h" int otbPipelineMemoryPrintCalculatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::PipelineMemoryPrintCalculator::Pointer calculator = otb::PipelineMemoryPrintCalculator::New(); return EXIT_SUCCESS; } int otbPipelineMemoryPrintCalculatorTest(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorImageToIntensityImageFilter IntensityImageFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); IntensityImageFilterType::Pointer intensity = IntensityImageFilterType::New(); intensity->SetInput(reader->GetOutput()); otb::PipelineMemoryPrintCalculator::Pointer calculator = otb::PipelineMemoryPrintCalculator::New(); calculator->SetDataToWrite(intensity->GetOutput()); calculator->Compute(); otb::PipelineMemoryPrintCalculator::MemoryPrintType availableMemoryInBytes = 104858; otb::PipelineMemoryPrintCalculator::MemoryPrintType memoryPrint = calculator->GetMemoryPrint(); unsigned int optimalNbDiv = otb::PipelineMemoryPrintCalculator::EstimateOptimalNumberOfStreamDivisions(memoryPrint, availableMemoryInBytes); std::ofstream ofs(argv[2]); ofs<<"Memory print of whole pipeline: "<GetMemoryPrint() * otb::PipelineMemoryPrintCalculator::ByteToMegabyte << " Mb"<GetBiasCorrectionFactor()< const int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::NumberOfLinesStrippedStreamingManager NbLinesStrippedStreamingManagerType; typedef otb::RAMDrivenStrippedStreamingManager RAMDrivenStrippedStreamingManagerType; typedef otb::TileDimensionTiledStreamingManager TileDimensionTiledStreamingManagerType; typedef otb::RAMDrivenTiledStreamingManager RAMDrivenTiledStreamingManagerType; typedef otb::RAMDrivenAdaptativeStreamingManager RAMDrivenAdaptativeStreamingManagerType; ImageType::Pointer makeImage(ImageType::RegionType region) { ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(10); itk::MetaDataDictionary& dict = image->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, otb::MetaDataKey::TileHintX, 64); itk::EncapsulateMetaData(dict, otb::MetaDataKey::TileHintY, 64); return image; } int otbStreamingManagerNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { NbLinesStrippedStreamingManagerType::Pointer streamingManager1 = NbLinesStrippedStreamingManagerType::New(); std::cout << streamingManager1 << std::endl; RAMDrivenStrippedStreamingManagerType::Pointer streamingManager2 = RAMDrivenStrippedStreamingManagerType::New(); std::cout << streamingManager2 << std::endl; TileDimensionTiledStreamingManagerType::Pointer streamingManager3 = TileDimensionTiledStreamingManagerType::New(); std::cout << streamingManager3 << std::endl; RAMDrivenTiledStreamingManagerType::Pointer streamingManager4 = RAMDrivenTiledStreamingManagerType::New(); std::cout << streamingManager4 << std::endl; RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager5 = RAMDrivenAdaptativeStreamingManagerType::New(); std::cout<SetNumberOfLinesPerStrip(10); streamingManager->PrepareStreaming( makeImage(region), region ); unsigned int nbSplits = streamingManager->GetNumberOfSplits(); ImageType::RegionType split; split = streamingManager->GetSplit(0); outfile << split << std::endl; split = streamingManager->GetSplit(1); outfile << split << std::endl; split = streamingManager->GetSplit(nbSplits - 1); outfile << split << std::endl; return EXIT_SUCCESS; } int otbRAMDrivenStrippedStreamingManager(int itkNotUsed(argc), char * argv[]) { std::ofstream outfile(argv[1]); RAMDrivenStrippedStreamingManagerType::Pointer streamingManager = RAMDrivenStrippedStreamingManagerType::New(); ImageType::RegionType region; region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, 10013); region.SetSize(1, 5727); streamingManager->SetAvailableRAMInMB(1); streamingManager->PrepareStreaming( makeImage(region), region ); unsigned int nbSplits = streamingManager->GetNumberOfSplits(); ImageType::RegionType split; split = streamingManager->GetSplit(0); outfile << split << std::endl; split = streamingManager->GetSplit(1); outfile << split << std::endl; split = streamingManager->GetSplit(nbSplits - 1); outfile << split << std::endl; return EXIT_SUCCESS; } int otbTileDimensionTiledStreamingManager(int itkNotUsed(argc), char * argv[]) { std::ofstream outfile(argv[1]); TileDimensionTiledStreamingManagerType::Pointer streamingManager = TileDimensionTiledStreamingManagerType::New(); ImageType::RegionType region; region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, 10013); region.SetSize(1, 5727); streamingManager->SetTileDimension(100); streamingManager->PrepareStreaming( makeImage(region), region ); unsigned int nbSplits = streamingManager->GetNumberOfSplits(); ImageType::RegionType split; split = streamingManager->GetSplit(0); outfile << split << std::endl; split = streamingManager->GetSplit(1); outfile << split << std::endl; split = streamingManager->GetSplit(nbSplits - 1); outfile << split << std::endl; return EXIT_SUCCESS; } int otbRAMDrivenTiledStreamingManager(int itkNotUsed(argc), char * argv[]) { std::ofstream outfile(argv[1]); RAMDrivenTiledStreamingManagerType::Pointer streamingManager = RAMDrivenTiledStreamingManagerType::New(); ImageType::RegionType region; region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, 10013); region.SetSize(1, 5727); streamingManager->SetAvailableRAMInMB(1); streamingManager->PrepareStreaming( makeImage(region), region ); unsigned int nbSplits = streamingManager->GetNumberOfSplits(); ImageType::RegionType split; split = streamingManager->GetSplit(0); outfile << split << std::endl; split = streamingManager->GetSplit(1); outfile << split << std::endl; split = streamingManager->GetSplit(nbSplits - 1); outfile << split << std::endl; return EXIT_SUCCESS; } int otbRAMDrivenAdaptativeStreamingManager(int itkNotUsed(argc), char * argv[]) { std::ofstream outfile(argv[1]); RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); ImageType::RegionType region; region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, 10013); region.SetSize(1, 5727); streamingManager->SetAvailableRAMInMB(1); streamingManager->PrepareStreaming( makeImage(region), region ); unsigned int nbSplits = streamingManager->GetNumberOfSplits(); ImageType::RegionType split; split = streamingManager->GetSplit(0); outfile << split << std::endl; split = streamingManager->GetSplit(1); outfile << split << std::endl; split = streamingManager->GetSplit(nbSplits - 1); outfile << split << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Streaming/test/otbStreamingTestDriver.cxx000066400000000000000000000007371301006202600260330ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbStreamingManagerNew); REGISTER_TEST(otbNumberOfLinesStrippedStreamingManager); REGISTER_TEST(otbRAMDrivenStrippedStreamingManager); REGISTER_TEST(otbTileDimensionTiledStreamingManager); REGISTER_TEST(otbRAMDrivenTiledStreamingManager); REGISTER_TEST(otbRAMDrivenAdaptativeStreamingManager); REGISTER_TEST(otbPipelineMemoryPrintCalculatorTest); REGISTER_TEST(otbPipelineMemoryPrintCalculatorNew); } OTB-release-5.8/Modules/Core/Transform/000077500000000000000000000000001301006202600176715ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Transform/CMakeLists.txt000066400000000000000000000001221301006202600224240ustar00rootroot00000000000000project(OTBTransform) set(OTBTransform_LIBRARIES OTBTransform) otb_module_impl() OTB-release-5.8/Modules/Core/Transform/include/000077500000000000000000000000001301006202600213145ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Transform/include/otbCompositeTransform.h000066400000000000000000000124541301006202600260360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCompositeTransform_h #define otbCompositeTransform_h #include #include #include #include "otbTransform.h" #include "itkMacro.h" namespace otb { /** \class CompositeTransform * \brief Class which compose two itk::Transform to obtain one itk::Transform * T1 T2 T3 * (x, y) -> (x', y') -> (x'', y'') => (x, y) -> (x'', y'') * * * \ingroup Transform * * \ingroup OTBTransform */ //typedef enum //{ // PROJDEFAULT=0, // PROJIDENTITY=1, // PROJMAPFORWARD=2, // PROJMAPINVERSE=3, // PROJSENSORFORWARD=4, // PROJSENSORINVERSE=5 //} ProjectionTypeEnum; template class ITK_EXPORT CompositeTransform : public Transform // Number of dimensions in the output space { public: /** Standard class typedefs */ typedef Transform Superclass; typedef CompositeTransform Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TFirstTransform FirstTransformType; typedef typename TFirstTransform::Pointer FirstTransformPointerType; typedef TSecondTransform SecondTransformType; typedef typename TSecondTransform::Pointer SecondTransformPointerType; /** Standard vector type for this class. */ // typedef typename TFirstTransform::InputVectorType FirstTransformInputVectorType; // typedef typename TFirstTransform::OutputVectorType FirstTransformOutputVectorType; /** Standard covariant vector type for this class */ // typedef typename TFirstTransform::InputCovariantVectorType FirstTransformInputCovariantVectorType; // typedef typename TFirstTransform::OutputCovariantVectorType FirstTransformOutputCovariantVectorType; /** Standard vnl_vector type for this class. */ // typedef typename TFirstTransform::InputVnlVectorType FirstTransformInputVnlVectorType; // typedef typename TFirstTransform::OutputVnlVectorType FirstTransformOutputVnlVectorType; /** Standard coordinate point type for this class */ typedef typename Superclass::InputPointType FirstTransformInputPointType; typedef typename TFirstTransform::OutputPointType FirstTransformOutputPointType; /** TSecondTransform::InputPointType is purposely not defined * It contrains user to choose First Transform Output compatible * with Second Transform Input */ typedef typename Superclass::OutputPointType SecondTransformOutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(CompositeTransform, Transform); itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); itkStaticConstMacro(SpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(ParametersDimension, unsigned int, NInputDimensions * (NInputDimensions + 1)); /** Set first transformation */ itkSetObjectMacro(FirstTransform, FirstTransformType); /** Set second transformation */ itkSetObjectMacro(SecondTransform, SecondTransformType); /** Get First and second transform*/ itkGetConstReferenceMacro(FirstTransform, FirstTransformPointerType); itkGetConstReferenceMacro(SecondTransform, SecondTransformPointerType); /** Method to transform a point. */ SecondTransformOutputPointType TransformPoint(const FirstTransformInputPointType&) const ITK_OVERRIDE; /** Method to transform a vector. */ // virtual OutputVectorType TransformVector(const InputVectorType &) const; /** Method to transform a vnl_vector. */ // virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const; /** Method to transform a CovariantVector. */ // virtual OutputCovariantVectorType TransformCovariantVector(const InputCovariantVectorType &) const; protected: CompositeTransform(); ~CompositeTransform() ITK_OVERRIDE; FirstTransformPointerType m_FirstTransform; SecondTransformPointerType m_SecondTransform; private: CompositeTransform(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbCompositeTransform.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbCompositeTransform.txx000066400000000000000000000106271301006202600264320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCompositeTransform_txx #define otbCompositeTransform_txx #include "otbCompositeTransform.h" #include "otbGenericMapProjection.h" #include "otbForwardSensorModel.h" #include "otbInverseSensorModel.h" #include "itkIdentityTransform.h" namespace otb { template CompositeTransform ::CompositeTransform() : Superclass(ParametersDimension) { m_FirstTransform = ITK_NULLPTR; m_SecondTransform = ITK_NULLPTR; } template CompositeTransform ::~CompositeTransform() { } template typename CompositeTransform::SecondTransformOutputPointType CompositeTransform ::TransformPoint(const FirstTransformInputPointType& point1) const { FirstTransformOutputPointType geoPoint; geoPoint = m_FirstTransform->TransformPoint(point1); SecondTransformOutputPointType outputPoint; outputPoint = m_SecondTransform->TransformPoint(geoPoint); // otbMsgDevMacro(<< std::setprecision(15) << "Converting: " << point1 << " -> " << geoPoint<< " -> " << outputPoint); return outputPoint; } /*template typename CompositeTransform::OutputVectorType CompositeTransform ::TransformVector(const InputVectorType &vector1) const { InputVectorType vectorTmp; OutputVectorType vector2; vectorTmp=m_FirstTransform->TransformVector(vector1); vector2=m_SecondTransform->TransformVector(vectorTmp); return vector2; } template typename CompositeTransform::OutputVnlVectorType CompositeTransform ::TransformVector(const InputVnlVectorType &vnlVector1) const { InputVnlVectorType vnlVectorTmp; OutputVnlVectorType vnlVector2; vnlVectorTmp=m_FirstTransform->TransformVector(vnlVector1); vnlVector2=m_SecondTransform->TransformVector(vnlVectorTmp); return vnlVector2; } template typename CompositeTransform::OutputCovariantVectorType CompositeTransform ::TransformCovariantVector(const InputCovariantVectorType &covariantVector1) const { InputCovariantVectorType covariantVectorTmp; OutputCovariantVectorType covariantVector2; covariantVectorTmp=m_FirstTransform->TransformCovariantVector(covariantVector1); covariantVector2=m_SecondTransform->TransformCovariantVector(covariantVectorTmp); return covariantVector2; }*/ } // namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbForwardSensorModel.h000066400000000000000000000051151301006202600257530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbForwardSensorModel_h #define otbForwardSensorModel_h #include "otbSensorModelBase.h" #include "itkMacro.h" #include "itkObject.h" namespace otb { /** \class ForwardSensorModel * \brief Class for direct sensor models * * Based on ossimProjectionFactoryRegistry and ossimProjection methods. * It takes as input an index and computes the world coordinates. * (i, j, h) -> (lon, lat). * Notice that the elevation h is optional. * * \ingroup Transform * \ingroup Projection * * \ingroup OTBTransform */ template class ITK_EXPORT ForwardSensorModel : public SensorModelBase { public: /** Standard class typedefs. */ typedef ForwardSensorModel Self; typedef SensorModelBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputPointType InputPointType; typedef typename Superclass::OutputPointType OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ForwardSensorModel, SensorModelBase); itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); /** Compute the world coordinates. */ OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; protected: ForwardSensorModel(); ~ForwardSensorModel() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ForwardSensorModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbForwardSensorModel.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbForwardSensorModel.txx000066400000000000000000000041711301006202600263500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbForwardSensorModel_txx #define otbForwardSensorModel_txx #include "otbForwardSensorModel.h" #include "otbMacro.h" namespace otb { template ForwardSensorModel ::ForwardSensorModel() {} template ForwardSensorModel ::~ForwardSensorModel() {} template typename ForwardSensorModel::OutputPointType ForwardSensorModel ::TransformPoint(const InputPointType& point) const { double x = point[0]; double y = point[1]; double lon, lat, h; if (InputPointType::PointDimension == 3) { double z = point[2]; this->m_Model->ForwardTransformPoint(x, y, z, lon, lat, h); } else { this->m_Model->ForwardTransformPoint(x, y, lon, lat, h); } OutputPointType outputPoint; outputPoint[0] = lon; outputPoint[1] = lat; if (OutputPointType::PointDimension == 3) { outputPoint[2] = h; } return outputPoint; } template void ForwardSensorModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbGenericMapProjection.h000066400000000000000000000104641301006202600262460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericMapProjection_h #define otbGenericMapProjection_h #include #include #include "otbTransform.h" #include "itkMacro.h" #include "otbMapProjectionAdapter.h" namespace otb { namespace TransformDirection { enum TransformationDirection { FORWARD = 0, INVERSE = 1 }; } /** \class GenericMapProjection * \brief This is the base class for generic map projection transformation * * The forward transformation will transform the coordinate for the geographic to the * cartographic. The inverse model will transform from the cartographic to the geographic. * * All derived class assume that the latitude and longitude are given according to the * WGS84 ellipsoid model. * * \ingroup Projection * * * \ingroup OTBTransform **/ template class ITK_EXPORT GenericMapProjection : public Transform // Number of dimensions in the output space { public: /** Standard class typedefs. */ typedef Transform Superclass; typedef GenericMapProjection Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef MapProjectionAdapter MapProjectionType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GenericMapProjection, Transform); static const TransformDirection::TransformationDirection DirectionOfMapping = TDirectionOfMapping; itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); itkStaticConstMacro(SpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(ParametersDimension, unsigned int, NInputDimensions * (NInputDimensions + 1)); /** Return the Wkt representation of the projection*/ virtual std::string GetWkt(); /** Instantiate the projection according to the Wkt specification*/ virtual void SetWkt(const std::string& projectionRefWkt); virtual void PrintMap() const; OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; virtual bool InstantiateProjection(); /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ virtual bool InstanciateProjection() { otbWarningMacro( << "InstanciateProjection has been deprecated. Please use InstantiateProjection() instead"); return this->InstantiateProjection(); } const MapProjectionAdapter* GetMapProjection() const; virtual bool IsProjectionDefined() const; void SetParameter(const std::string& key, const std::string& value); std::string GetParameter(const std::string& key) const; protected: GenericMapProjection(); ~GenericMapProjection() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; MapProjectionAdapter::Pointer m_MapProjection; private: GenericMapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGenericMapProjection.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbGenericMapProjection.txx000066400000000000000000000132511301006202600266370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericMapProjection_txx #define otbGenericMapProjection_txx #include "otbGenericMapProjection.h" #include "otbMacro.h" namespace otb { template GenericMapProjection ::GenericMapProjection() : Superclass(ParametersDimension) { m_MapProjection = MapProjectionAdapter::New(); } template GenericMapProjection ::~GenericMapProjection() { } template const MapProjectionAdapter* GenericMapProjection ::GetMapProjection() const { return m_MapProjection; } template std::string GenericMapProjection ::GetWkt() { return m_MapProjection->GetWkt(); } template void GenericMapProjection ::SetWkt(const std::string& projectionRefWkt) { m_MapProjection->SetWkt(projectionRefWkt); this->Modified(); } template bool GenericMapProjection ::InstantiateProjection() { return m_MapProjection->InstantiateProjection(); } template typename GenericMapProjection::OutputPointType GenericMapProjection ::TransformPoint(const InputPointType& point) const { OutputPointType outputPoint; if (DirectionOfMapping == TransformDirection::INVERSE) { double lon, lat, h; double z = 0.0; if (InputPointType::PointDimension == 3) z = point[2]; m_MapProjection->InverseTransform(point[0], point[1], z, lon, lat, h); outputPoint[0] = lon; outputPoint[1] = lat; if (OutputPointType::PointDimension == 3) outputPoint[2] = h; } if (DirectionOfMapping == TransformDirection::FORWARD) { double x, y, z; double h = 0.0; if (InputPointType::PointDimension == 3) h = point[2]; m_MapProjection->ForwardTransform(point[0], point[1], h, x, y, z); outputPoint[0] = x; outputPoint[1] = y; if (OutputPointType::PointDimension == 3) outputPoint[2] = z; } return outputPoint; } template void GenericMapProjection ::PrintMap() const { m_MapProjection->PrintMap(); } template bool GenericMapProjection ::IsProjectionDefined() const { return (m_MapProjection->GetMapProjection() != ITK_NULLPTR); } template void GenericMapProjection ::SetParameter(const std::string& key, const std::string& value) { m_MapProjection->SetParameter(key, value); } template std::string GenericMapProjection ::GetParameter(const std::string& key) const { return m_MapProjection->GetParameter(key); } template void GenericMapProjection ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "ProjectionRefWkt: " << m_MapProjection->GetWkt() << std::endl; } } // namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbGenericRSTransform.h000066400000000000000000000164251301006202600257170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericRSTransform_h #define otbGenericRSTransform_h #include "otbCompositeTransform.h" namespace otb { namespace Projection { enum TransformAccuracy {UNKNOWN, ESTIMATE, PRECISE}; } /** \class GenericRSTransform * \brief This is the class to handle generic remote sensing transform * * The transformation will transform the coordinate from any map projection or sensor * model to any map projection or sensor model. * * If one of the projection (output or input) is a map projection, it can be * specified using the WKT or the EPSG code. * * \ingroup Projection * * * \ingroup OTBTransform **/ template class ITK_EXPORT GenericRSTransform : public otb::Transform // Number of dimensions in the output space { public: /**\name Standard ITK typedefs */ //@{ typedef otb::Transform Superclass; typedef GenericRSTransform Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //@} typedef typename Superclass::ScalarType ScalarType; typedef typename Superclass::JacobianType JacobianType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; typedef itk::Vector SpacingType; typedef itk::Point OriginType; typedef itk::Transform GenericTransformType; typedef typename GenericTransformType::Pointer GenericTransformPointerType; typedef otb::CompositeTransform TransformType; typedef typename TransformType::Pointer TransformPointerType; typedef typename Superclass::InverseTransformBasePointer InverseTransformBasePointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GenericRSTransform, Transform); typedef TransformDirection::TransformationDirection DirectionOfMappingEnumType; itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); itkStaticConstMacro(SpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(ParametersDimension, unsigned int, NInputDimensions * (NInputDimensions + 1)); /** Set/Get for input and output projections. */ itkSetStringMacro(InputProjectionRef); itkGetStringMacro(InputProjectionRef); itkSetStringMacro(OutputProjectionRef); itkGetStringMacro(OutputProjectionRef); /** Set/Get Dictionary*/ const itk::MetaDataDictionary& GetInputDictionary() const { return m_InputDictionary; } void SetInputDictionary(const itk::MetaDataDictionary& dictionary) { m_InputDictionary = dictionary; this->Modified(); } const itk::MetaDataDictionary& GetOutputDictionary() const { return m_OutputDictionary; } void SetOutputDictionary(const itk::MetaDataDictionary& dictionary) { m_OutputDictionary = dictionary; this->Modified(); } /** Set/Get Keywordlist*/ itkGetMacro(InputKeywordList, ImageKeywordlist); void SetInputKeywordList(const ImageKeywordlist& kwl) { this->m_InputKeywordList = kwl; this->Modified(); } itkGetMacro(OutputKeywordList, ImageKeywordlist); void SetOutputKeywordList(const ImageKeywordlist& kwl) { this->m_OutputKeywordList = kwl; this->Modified(); } /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(InputOrigin, OriginType); itkGetConstReferenceMacro(InputOrigin, OriginType); /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ itkSetMacro(InputSpacing, SpacingType); itkGetConstReferenceMacro(InputSpacing, SpacingType); /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(OutputOrigin, OriginType); itkGetConstReferenceMacro(OutputOrigin, OriginType); /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ itkSetMacro(OutputSpacing, SpacingType); itkGetConstReferenceMacro(OutputSpacing, SpacingType); /** Check if the transform is up to date */ virtual bool IsUpToDate() { return m_TransformUpToDate; } /** Get Transform accuracy */ itkGetMacro(TransformAccuracy, Projection::TransformAccuracy); /** Methods prototypes */ virtual const TransformType * GetTransform() const; OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; virtual void InstantiateTransform(); /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ void InstanciateTransform() { otbWarningMacro(<< "InstanciateTransform has been deprecated. Please use InstantiateTransform instead"); this->InstantiateTransform(); } // Get inverse methods bool GetInverse(Self * inverseTransform) const; InverseTransformBasePointer GetInverseTransform() const ITK_OVERRIDE; // Dummy set parameter method void SetParameters(const typename Superclass::ParametersType &) ITK_OVERRIDE {} // Dummy ComputeJacobianWithRespectToParameters method void ComputeJacobianWithRespectToParameters(const InputPointType &, JacobianType& ) const ITK_OVERRIDE {} protected: GenericRSTransform(); ~GenericRSTransform() ITK_OVERRIDE {} void Modified() const ITK_OVERRIDE { this->Superclass::Modified(); m_TransformUpToDate = false; } void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GenericRSTransform(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ImageKeywordlist m_InputKeywordList; ImageKeywordlist m_OutputKeywordList; itk::MetaDataDictionary m_InputDictionary; itk::MetaDataDictionary m_OutputDictionary; std::string m_InputProjectionRef; std::string m_OutputProjectionRef; SpacingType m_InputSpacing; OriginType m_InputOrigin; SpacingType m_OutputSpacing; OriginType m_OutputOrigin; TransformPointerType m_Transform; GenericTransformPointerType m_InputTransform; GenericTransformPointerType m_OutputTransform; mutable bool m_TransformUpToDate; Projection::TransformAccuracy m_TransformAccuracy; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGenericRSTransform.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbGenericRSTransform.txx000066400000000000000000000310361301006202600263060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericRSTransform_txx #define otbGenericRSTransform_txx #include "otbGenericRSTransform.h" #include "otbMacro.h" #include "otbMetaDataKey.h" #include "itkMetaDataObject.h" #include "otbGeoInformationConversion.h" #include "ogr_spatialref.h" namespace otb { template GenericRSTransform ::GenericRSTransform() : Superclass(0) { m_InputProjectionRef.clear(); m_OutputProjectionRef.clear(); m_InputKeywordList.Clear(); m_OutputKeywordList.Clear(); m_InputSpacing.Fill(1); m_InputOrigin.Fill(0); m_OutputSpacing.Fill(1); m_OutputOrigin.Fill(0); m_Transform = ITK_NULLPTR; m_InputTransform = ITK_NULLPTR; m_OutputTransform = ITK_NULLPTR; m_TransformUpToDate = false; m_TransformAccuracy = Projection::UNKNOWN; } template const typename GenericRSTransform::TransformType* GenericRSTransform ::GetTransform() const { itkDebugMacro("returning MapProjection address " << this->m_Transform); if ((!m_TransformUpToDate) || (m_Transform.IsNull())) { itkExceptionMacro(<< "m_Transform not up-to-date, call InstantiateTransform() first"); } return this->m_Transform; } /** * Instantiate the transformation according to information */ template void GenericRSTransform ::InstantiateTransform(void) { m_Transform = TransformType::New(); if (m_InputKeywordList.GetSize() == 0) { itk::ExposeMetaData(m_InputDictionary, MetaDataKey::OSSIMKeywordlistKey, m_InputKeywordList); } if (m_InputProjectionRef.empty()) { itk::ExposeMetaData(m_InputDictionary, MetaDataKey::ProjectionRefKey, m_InputProjectionRef); } otbMsgDevMacro(<< "Information to instantiate transform: "); otbMsgDevMacro(<< " * Input Origin: " << m_InputOrigin); otbMsgDevMacro(<< " * Input Spacing: " << m_InputSpacing); otbMsgDevMacro(<< " * Input keyword list: " << ((m_InputKeywordList.GetSize() == 0) ? "Empty" : "Full")); otbMsgDevMacro(<< " * Input projection: " << m_InputProjectionRef); otbMsgDevMacro(<< " * Output keyword list: " << ((m_OutputKeywordList.GetSize() == 0) ? "Empty" : "Full")); otbMsgDevMacro(<< " * Output projection: " << m_OutputProjectionRef); otbMsgDevMacro(<< " * Output Origin: " << m_OutputOrigin); otbMsgDevMacro(<< " * Output Spacing: " << m_OutputSpacing); //Make sure that the state is clean: m_InputTransform = ITK_NULLPTR; m_OutputTransform = ITK_NULLPTR; bool firstTransformGiveGeo = true; bool inputTransformIsSensor = false; bool inputTransformIsMap = false; bool outputTransformIsSensor = false; bool outputTransformIsMap = false; // Prepare the projection ref (eventually convert the EPSG code into full WKT) // // Note that we do that at the GenericRSTransform level and not in the member // class for several reasons: // - at the GenericMapProjection and MapProjectionAdapter the method are // called SetWkt and thus should not take a SRID. // - we do not want to mix the GeoInformationConversion (which uses gdal) in // the MapProjectionAdapter to keep ossim and gdal dependencies as separated // as possible. m_InputProjectionRef = GeoInformationConversion::ToWKT(m_InputProjectionRef); m_OutputProjectionRef = GeoInformationConversion::ToWKT(m_OutputProjectionRef); //***************************** //Set the input transformation //***************************** // First, try to make a geo transform if (!m_InputProjectionRef.empty()) //map projection { typedef otb::GenericMapProjection InverseMapProjectionType; typename InverseMapProjectionType::Pointer mapTransform = InverseMapProjectionType::New(); mapTransform->SetWkt(m_InputProjectionRef); if (mapTransform->IsProjectionDefined()) { m_InputTransform = mapTransform.GetPointer(); inputTransformIsMap = true; otbMsgDevMacro(<< "Input projection set to map transform: " << m_InputTransform); } } // If not, try to make a sensor model if ((m_InputTransform.IsNull()) && (m_InputKeywordList.GetSize() > 0)) { typedef otb::ForwardSensorModel ForwardSensorModelType; typename ForwardSensorModelType::Pointer sensorModel = ForwardSensorModelType::New(); sensorModel->SetImageGeometry(m_InputKeywordList); if (sensorModel->IsValidSensorModel()) { m_InputTransform = sensorModel.GetPointer(); inputTransformIsSensor = true; otbMsgDevMacro(<< "Input projection set to sensor model."); } } if (m_InputTransform.IsNull()) //default if we didn't manage to instantiate it before { m_InputTransform = itk::IdentityTransform::New(); // firstTransformGiveGeo = false; OGRSpatialReferenceH hSRS = ITK_NULLPTR; hSRS = OSRNewSpatialReference(ITK_NULLPTR); const char * wktString = m_InputProjectionRef.c_str(); if (OSRImportFromWkt(hSRS, (char **) &wktString) != OGRERR_NONE) { firstTransformGiveGeo = false; otbMsgDevMacro(<< "- Considering that the first transform does not give geo (WKT)") } else if ( OSRIsGeographic(hSRS) ) { firstTransformGiveGeo = true; otbMsgDevMacro(<< "- Considering that the first transform gives geo") } else { firstTransformGiveGeo = false; otbMsgDevMacro(<< "- Considering that the first transform does not give geo (fallback)") } OSRRelease(hSRS); otbMsgDevMacro(<< "Input projection set to identity") } //***************************** //Set the output transformation //***************************** if (!m_OutputProjectionRef.empty()) //map projection { typedef otb::GenericMapProjection ForwardMapProjectionType; typename ForwardMapProjectionType::Pointer mapTransform = ForwardMapProjectionType::New(); mapTransform->SetWkt(m_OutputProjectionRef); if (mapTransform->IsProjectionDefined()) { m_OutputTransform = mapTransform.GetPointer(); outputTransformIsMap = true; otbMsgDevMacro(<< "Output projection set to map transform: " << m_OutputTransform); } } // If not, try to make a sensor model if ((m_OutputTransform.IsNull()) && (m_OutputKeywordList.GetSize() > 0)) { typedef otb::InverseSensorModel InverseSensorModelType; typename InverseSensorModelType::Pointer sensorModel = InverseSensorModelType::New(); sensorModel->SetImageGeometry(m_OutputKeywordList); if (sensorModel->IsValidSensorModel()) { m_OutputTransform = sensorModel.GetPointer(); outputTransformIsSensor = true; otbMsgDevMacro(<< "Output projection set to sensor model"); } } if (m_OutputTransform.IsNull()) //default if we didn't manage to instantiate it before { m_OutputTransform = itk::IdentityTransform::New(); if (firstTransformGiveGeo) { m_OutputProjectionRef = "GEOGCS[\"GCS_WGS_1984\", DATUM[\"D_WGS_1984\", SPHEROID[\"WGS_1984\", 6378137, 298.257223563]], PRIMEM[\"Greenwich\", 0], UNIT[\"Degree\", 0.017453292519943295]]"; } otbMsgDevMacro(<< "Output projection set to identity"); } m_Transform->SetFirstTransform(m_InputTransform); m_Transform->SetSecondTransform(m_OutputTransform); m_TransformUpToDate = true; //The accuracy information is a simplistic model for now and should be refined if ((inputTransformIsSensor || outputTransformIsSensor)) { //Sensor model m_TransformAccuracy = Projection::ESTIMATE; } else if (firstTransformGiveGeo && !outputTransformIsSensor && !outputTransformIsMap) { //The original image was in lon/lat and we did not change anything m_TransformAccuracy = Projection::PRECISE; } else if (!inputTransformIsSensor && !outputTransformIsSensor && !inputTransformIsMap && !outputTransformIsMap) { //no transform m_TransformAccuracy = Projection::UNKNOWN; } else { m_TransformAccuracy = Projection::PRECISE; } } template typename GenericRSTransform::OutputPointType GenericRSTransform ::TransformPoint(const InputPointType& point) const { InputPointType inputPoint = point; // Apply input origin/spacing inputPoint[0] = inputPoint[0] * m_InputSpacing[0] + m_InputOrigin[0]; inputPoint[1] = inputPoint[1] * m_InputSpacing[1] + m_InputOrigin[1]; // Transform point OutputPointType outputPoint; outputPoint = this->GetTransform()->TransformPoint(inputPoint); // Apply output origin/spacing outputPoint[0] = (outputPoint[0] - m_OutputOrigin[0]) / m_OutputSpacing[0]; outputPoint[1] = (outputPoint[1] - m_OutputOrigin[1]) / m_OutputSpacing[1]; // otbMsgDevMacro("GenericRSTransform: " << point << " -> " << outputPoint); return outputPoint; } template bool GenericRSTransform ::GetInverse(Self * inverseTransform) const { // Test the inverseTransform pointer if (inverseTransform == ITK_NULLPTR) { return false; } // Swich projection refs inverseTransform->SetInputProjectionRef(m_OutputProjectionRef); inverseTransform->SetOutputProjectionRef(m_InputProjectionRef); // Switch keywordlists inverseTransform->SetInputKeywordList(m_OutputKeywordList); inverseTransform->SetOutputKeywordList(m_InputKeywordList); // Switch dictionnaries inverseTransform->SetInputDictionary(m_OutputDictionary); inverseTransform->SetOutputDictionary(m_InputDictionary); // Switch spacings inverseTransform->SetInputSpacing(m_OutputSpacing); inverseTransform->SetOutputSpacing(m_InputSpacing); // Switch origins inverseTransform->SetInputOrigin(m_OutputOrigin); inverseTransform->SetOutputOrigin(m_InputOrigin); // Instantiate transform inverseTransform->InstantiateTransform(); return true; } template typename GenericRSTransform ::InverseTransformBasePointer GenericRSTransform ::GetInverseTransform() const { Self * inverseTransform = Self::New(); bool success = this->GetInverse(inverseTransform); if (!success) { itkExceptionMacro(<< "Failed to create inverse transform"); } return inverseTransform; } template void GenericRSTransform ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Up to date: " << m_TransformUpToDate << std::endl; if (m_TransformUpToDate) { os << indent << "Input transform: "<< std::endl; m_InputTransform->Print(os, indent.GetNextIndent()); os << indent << "Output transform: " << std::endl; m_OutputTransform->Print(os, indent.GetNextIndent()); } else { os << indent << "Input transform: NULL" << std::endl; os << indent << "Output transform: NULL" << std::endl; } os << indent << "Accuracy: " << (m_TransformAccuracy == Projection::PRECISE ? "PRECISE" : (m_TransformAccuracy == Projection::ESTIMATE ? "ESTIMATE" : "UNKNOWN")) << std::endl; } } // namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbGeoInformationConversion.h000066400000000000000000000025431301006202600271640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeoInformationConversion_h #define otbGeoInformationConversion_h #include #include "OTBTransformExport.h" namespace otb { /** * \namespace GeoInformationConversion * \brief Helper functions to do the geo information conversions used frequently. * * This namespace provides helpers functions to build a WKT from a valid EPSG number using * the method ToWKT(int srid). */ namespace GeoInformationConversion { /** method used to create a wkt from an epsg number */ OTBTransform_EXPORT std::string ToWKT(int srid); OTBTransform_EXPORT std::string ToWKT(const std::string& candidateSrid); /** this method try to morph a wkt to ESRI WKT format and returns the error code**/ OTBTransform_EXPORT bool IsESRIValidWKT(const std::string &Wkt); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbGeocentricTransform.h000066400000000000000000000056541301006202600261620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeocentricTransform_h #define otbGeocentricTransform_h #include "otbGenericMapProjection.h" #include "otbEllipsoidAdapter.h" namespace otb { /** \class GeocentricTransform * * \brief Convert coordinates from geocentric (X, Y, Z) to geographic (lon, lat, h) * * * \ingroup OTBTransform */ template class ITK_EXPORT GeocentricTransform : public Transform // Number of dimensions in the output space { public: /** Standard class typedefs. */ typedef GeocentricTransform Self; typedef Transform Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GeocentricTransform, Transform); static const TransformDirection::TransformationDirection DirectionOfMapping = TDirectionOfMapping; itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); itkStaticConstMacro(SpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(ParametersDimension, unsigned int, NInputDimensions * (NInputDimensions + 1)); OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; protected: GeocentricTransform(); ~GeocentricTransform() ITK_OVERRIDE; EllipsoidAdapter::Pointer m_Ellipsoid; private: GeocentricTransform(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGeocentricTransform.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbGeocentricTransform.txx000066400000000000000000000044331301006202600265500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeocentricTransform_txx #define otbGeocentricTransform_txx #include "otbGeocentricTransform.h" namespace otb { template GeocentricTransform ::GeocentricTransform() : Superclass(ParametersDimension) { m_Ellipsoid = EllipsoidAdapter::New(); } template GeocentricTransform ::~GeocentricTransform() {} template typename GeocentricTransform::OutputPointType GeocentricTransform ::TransformPoint(const InputPointType& point) const { OutputPointType outputPoint; if (DirectionOfMapping == TransformDirection::INVERSE) { m_Ellipsoid->XYZToLonLatHeight(point[0], point[1], point[2], outputPoint[0], outputPoint[1], outputPoint[2]); } if (DirectionOfMapping == TransformDirection::FORWARD) { m_Ellipsoid->LonLatHeightToXYZ(point[0], point[1], point[2], outputPoint[0], outputPoint[1], outputPoint[2]); } //To be completed return outputPoint; } } // namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbImageToGenericRSOutputParameters.h000066400000000000000000000134111301006202600305260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToGenericRSOutputParameters_h #define otbImageToGenericRSOutputParameters_h #include "itkObject.h" #include "otbGenericRSTransform.h" namespace otb { /** \class ImageToGenericRSOutputParameters * \brief This class is a helper class to estimate the output * parameters of an image after projection in a target SRS (defined * here using its projectionRef). * * This class allow the computation of the output Origin|Spacing|Size * when projecting an image in a target SRS. The user can set the * target projectionRef via SetOutputProjectionRef(std::string). * * This class allows forcing use of a desired spacing. For * instance, if one need to compute the output Size of an * image in the UTM srs with a spacing of 5 m, it can be set via the * method ForceSpacingTo(spacing). * * In the same way, one can force the image to have a final size using * ForceSizeTo(size). The spacing is then computed to get all the * pixels of the image in the output image. * * \sa GenericRSTransform * \ingroup Projection * * \ingroup OTBTransform **/ template class ImageToGenericRSOutputParameters : public itk::Object { public: /** Standard class typedefs */ typedef ImageToGenericRSOutputParameters Self; typedef itk::Object Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ImageToGenericRSOutputParameters, itk::Object); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImage typedefs */ typedef TImage ImageType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::SpacingType SpacingType; typedef typename ImageType::PointType PointType; /** GenericRSTransform typedef */ typedef GenericRSTransform<> GenericRSTransformType; typedef typename GenericRSTransformType::Pointer GenericRSTransformPointerType; /** Struct to store the extent of the output image when using the * methods SetOutputParameters. */ struct OutputImageExtentType{ double minX; double maxX; double minY; double maxY; }; /** Method to Set/Get the input */ itkSetConstObjectMacro(Input, ImageType); itkGetConstObjectMacro(Input, ImageType); /** Output Origin */ itkSetMacro(OutputOrigin, PointType); itkGetMacro(OutputOrigin, PointType); /** Output Spacing */ itkSetMacro(OutputSpacing, SpacingType); itkGetMacro(OutputSpacing, SpacingType); /** Output Size */ itkSetMacro(OutputSize, SizeType); itkGetMacro(OutputSize, SizeType); /** Isotropic spacing flag */ itkSetMacro(EstimateIsotropicSpacing, bool); itkGetMacro(EstimateIsotropicSpacing, bool); itkBooleanMacro(EstimateIsotropicSpacing); /** * Method to Force the use of the spacing selected by the user * The output size is computed using this spacing */ void ForceSpacingTo(const SpacingType& spacing) { m_ForceSpacing = true; this->SetOutputSpacing(spacing); } /** * Method to Force the use of the size selected by the user, the * output spacing is computed using this one */ void ForceSizeTo(const SizeType& size) { m_ForceSize = true; this->SetOutputSize(size); } /** * Method to Set/Get the output projectionRef * We cannot use the macro otbGetObjectMemberConstMacro cause the * SetOutputProjectionRef calls actually the method * SetInputProjectionRef of the GenericRSTransform class. */ void SetOutputProjectionRef(const std::string& ref) { m_Transform->SetInputProjectionRef(ref); this->Modified(); } std::string GetInputProjectionRef() const { return m_Transform->GetOutputProjectionRef(); } /** Set/Get Input Keywordlist*/ void SetInputKeywordList(const ImageKeywordlist& kwl) { m_Transform->SetOutputKeywordList(kwl); this->Modified(); } const ImageKeywordlist GetInputKeywordList() { return m_Transform->GetOutputKeywordList(); } /** Method to trigger the output parameters */ void Compute(); protected: ImageToGenericRSOutputParameters(); ~ImageToGenericRSOutputParameters() ITK_OVERRIDE {} private: ImageToGenericRSOutputParameters(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented void UpdateTransform(); void EstimateOutputImageExtent(); void EstimateOutputSpacing(); void EstimateOutputSize(); void EstimateOutputOrigin(); typename ImageType::ConstPointer m_Input; PointType m_OutputOrigin; SpacingType m_OutputSpacing; SizeType m_OutputSize; OutputImageExtentType m_OutputExtent; GenericRSTransformPointerType m_Transform; bool m_ForceSpacing; bool m_ForceSize; bool m_EstimateIsotropicSpacing; }; // end of class ImageToGenericRSOutputParameters } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToGenericRSOutputParameters.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbImageToGenericRSOutputParameters.txx000066400000000000000000000171331301006202600311270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToGenericRSOutputParameters_txx #define otbImageToGenericRSOutputParameters_txx #include "otbImageToGenericRSOutputParameters.h" #include "itkMacro.h" #include "itkContinuousIndex.h" namespace otb { template ImageToGenericRSOutputParameters ::ImageToGenericRSOutputParameters() { m_Transform = GenericRSTransformType::New(); m_ForceSpacing = false; m_ForceSize = false; m_EstimateIsotropicSpacing = false; } /** * Trigger the output image information computation */ template void ImageToGenericRSOutputParameters ::Compute() { // Do some checks : exceptions if Null or empty projectionRef and empty keywordlist if(m_Input.IsNull()) itkExceptionMacro(<<"The input is null , please set a non null input image"); if(m_Input->GetProjectionRef().empty() && m_Input->GetImageKeywordlist().GetSize() == 0) itkExceptionMacro(<<"No information in the metadata, please set an image with non empty metadata"); // First Call to UpdateTransform : Initialize with the input image // information this->UpdateTransform(); // Estimate the Output image Extent this->EstimateOutputImageExtent(); // Estimate the Output Spacing if(!m_ForceSpacing) this->EstimateOutputSpacing(); // Finally Estimate the Output Size this->EstimateOutputSize(); // Estimate the Output Origin this->EstimateOutputOrigin(); } template void ImageToGenericRSOutputParameters ::UpdateTransform() { m_Transform->SetOutputDictionary(this->GetInput()->GetMetaDataDictionary()); m_Transform->SetOutputProjectionRef(this->GetInput()->GetProjectionRef()); m_Transform->SetOutputKeywordList(this->GetInput()->GetImageKeywordlist()); m_Transform->InstantiateTransform(); } /** * The extent is the projection of the 4 image corner in the final * projection system. */ template void ImageToGenericRSOutputParameters ::EstimateOutputImageExtent() { // Get the inverse transform again : used later GenericRSTransformPointerType invTransform = GenericRSTransformType::New(); m_Transform->GetInverse(invTransform); // Compute the 4 corners in the cartographic coordinate system std::vector< itk::ContinuousIndex > vindex; std::vector voutput; itk::ContinuousIndex index1(m_Input->GetLargestPossibleRegion().GetIndex()); index1[0] += -0.5; index1[1] += -0.5; itk::ContinuousIndex index2(index1); itk::ContinuousIndex index3(index1); itk::ContinuousIndex index4(index1); // Image size SizeType size = m_Input->GetLargestPossibleRegion().GetSize(); // project the 4 corners index2[0] += size[0]; index3[0] += size[0]; index3[1] += size[1]; index4[1] += size[1]; vindex.push_back(index1); vindex.push_back(index2); vindex.push_back(index3); vindex.push_back(index4); for (unsigned int i = 0; i < vindex.size(); ++i) { PointType physicalPoint; m_Input->TransformContinuousIndexToPhysicalPoint(vindex[i], physicalPoint); voutput.push_back(invTransform->TransformPoint(physicalPoint)); } // Compute the boundaries double minX = voutput[0][0]; double maxX = voutput[0][0]; double minY = voutput[0][1]; double maxY = voutput[0][1]; for (unsigned int i = 0; i < voutput.size(); ++i) { // Origins if (minX > voutput[i][0]) minX = voutput[i][0]; if (minY > voutput[i][1]) minY = voutput[i][1]; // Sizes if (maxX < voutput[i][0]) maxX = voutput[i][0]; if (maxY < voutput[i][1]) maxY = voutput[i][1]; } // Edit the output image extent type m_OutputExtent.maxX = maxX; m_OutputExtent.minX = minX; m_OutputExtent.maxY = maxY; m_OutputExtent.minY = minY; } /** * Method used to estimate the Origin using the extent of the image * */ template void ImageToGenericRSOutputParameters ::EstimateOutputOrigin() { // Set the output origin in carto // projection PointType origin; origin[0] = m_OutputExtent.minX + 0.5 * this->GetOutputSpacing()[0]; origin[1] = m_OutputExtent.maxY + 0.5 * this->GetOutputSpacing()[1]; this->SetOutputOrigin(origin); } /** * Method used to estimate the spacing using the extent of the image * */ template void ImageToGenericRSOutputParameters ::EstimateOutputSpacing() { // Compute the output size double sizeCartoX = vcl_abs(m_OutputExtent.maxX - m_OutputExtent.minX); double sizeCartoY = vcl_abs(m_OutputExtent.minY - m_OutputExtent.maxY); PointType o, oX, oY; o[0] = m_OutputExtent.minX; o[1] = m_OutputExtent.maxY; oX = o; oY = o; oX[0] += sizeCartoX; oY[1] -= sizeCartoY; // Transform back into the input image PointType io = m_Transform->TransformPoint(o); PointType ioX = m_Transform->TransformPoint(oX); PointType ioY = m_Transform->TransformPoint(oY); // Transform to indices IndexType ioIndex, ioXIndex, ioYIndex; m_Input->TransformPhysicalPointToIndex(io, ioIndex); m_Input->TransformPhysicalPointToIndex(ioX, ioXIndex); m_Input->TransformPhysicalPointToIndex(ioY, ioYIndex); // Evaluate Ox and Oy length in number of pixels double OxLength, OyLength; OxLength = vcl_sqrt(vcl_pow((double) ioIndex[0] - (double) ioXIndex[0], 2) + vcl_pow((double) ioIndex[1] - (double) ioXIndex[1], 2)); OyLength = vcl_sqrt(vcl_pow((double) ioIndex[0] - (double) ioYIndex[0], 2) + vcl_pow((double) ioIndex[1] - (double) ioYIndex[1], 2)); // Evaluate spacing SpacingType outputSpacing; if(m_EstimateIsotropicSpacing) { double isotropicSpacing = std::min(sizeCartoX / OxLength, sizeCartoY / OyLength); outputSpacing[0] = isotropicSpacing; outputSpacing[1] = -isotropicSpacing; } else { outputSpacing[0] = sizeCartoX / OxLength; outputSpacing[1] = -sizeCartoY / OyLength; } this->SetOutputSpacing(outputSpacing); } /** * Method used to estimate the size using the output size of the image * */ template void ImageToGenericRSOutputParameters ::EstimateOutputSize() { // Compute the output size double sizeCartoX = vcl_abs(m_OutputExtent.maxX - m_OutputExtent.minX); double sizeCartoY = vcl_abs(m_OutputExtent.minY - m_OutputExtent.maxY); // Evaluate output size SizeType outputSize; outputSize[0] = static_cast(vcl_floor(vcl_abs(sizeCartoX / this->GetOutputSpacing()[0]))); outputSize[1] = static_cast(vcl_floor(vcl_abs(sizeCartoY / this->GetOutputSpacing()[1]))); // if ForceSizeTo used don't update the output size with the value // computed : the value is computed to update the spacing knowing // the forced size and the computed one. if(!m_ForceSize) this->SetOutputSize(outputSize); else { // Compute the spacing knowing the size SpacingType outputSpacing; outputSpacing[0] = this->GetOutputSpacing()[0] * outputSize[0]/this->GetOutputSize()[0]; outputSpacing[1] = this->GetOutputSpacing()[1] * outputSize[1]/this->GetOutputSize()[1]; this->SetOutputSpacing(outputSpacing); } this->UpdateTransform(); } } #endif OTB-release-5.8/Modules/Core/Transform/include/otbInverseLogPolarTransform.h000066400000000000000000000114151301006202600271430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbInverseLogPolarTransform_h #define otbInverseLogPolarTransform_h #include "otbTransform.h" namespace otb { /** \class InverseLogPolarTransform * \brief This transform is the back transform of the LogPolarTransform. * * Given (x, y) the coordinates of a point in cartesian system, the corresponding * log-polar coordinates are : * \f$ \rho = 1/2*log((x-xc)^2+(y+yc)^2) \f$ * \f$ \theta = asin(y-yc)/(\sqrt{(x-xc)^2+(y+yc)^2}) \f$ * * In this implemenatation, theta is expressed in degree, and the result of the asin function * is clamped to the [0, 360] range. Please note that since the transform of the center has no meaning * it is rejected to the point [400, 0], which does not belong to this range. This is done to provide * a coordinate not likely to belong to a log-polar image buffer. * * \sa LogPolarTransform * \ingroup Transform * * \ingroup OTBTransform */ template class ITK_EXPORT InverseLogPolarTransform : public Transform { public: /** Standard typedef */ typedef InverseLogPolarTransform Self; typedef Transform Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory */ itkNewMacro(Self); /** Runtime information */ itkTypeMacro(InverseLogPolarTransform, Transform); /** Template related typedefs */ typedef TScalarType ScalarType; /** Superclass related typedefs */ typedef typename Superclass::InputPointType InputPointType; typedef typename Superclass::OutputPointType OutputPointType; typedef typename Superclass::InputVectorType InputVectorType; typedef typename Superclass::OutputVectorType OutputVectorType; typedef typename Superclass::InputVnlVectorType InputVnlVectorType; typedef typename Superclass::OutputVnlVectorType OutputVnlVectorType; typedef typename Superclass::ParametersType ParametersType; typedef itk::FixedArray ScaleType; /** Set/Get the origin */ itkSetMacro(Center, InputPointType); itkGetConstReferenceMacro(Center, InputPointType); /** Set/Get the scales */ itkSetMacro(Scale, ScaleType); itkGetConstReferenceMacro(Scale, ScaleType); /** * Set the transform parameters through the standard interface. * \param parameters The parameters of the transform. */ void SetParameters(const ParametersType& parameters) ITK_OVERRIDE; /** * Get the transform parameters through the standard interface. * \return The parameters of the transform. */ ParametersType& GetParameters(void) const ITK_OVERRIDE; /** * Set the Fixed Parameters * \param param The fixed parameters of the transform. */ void SetFixedParameters( const ParametersType & param) ITK_OVERRIDE { this->m_FixedParameters = param; } /** * Get the Fixed Parameters * \return The Fixed parameters of the transform. */ const ParametersType& GetFixedParameters(void) const ITK_OVERRIDE{return this->m_FixedParameters; } /** * Transform a point. * \param point The point to transform. * \return The transformed point. */ using Superclass::TransformVector; OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; /** * Transform a vector representing a point. * \param vector The point to transform. * \return The transformed point. */ OutputVectorType TransformVector(const InputVectorType& vector) const ITK_OVERRIDE; /** * Transform a vnl vector representing a point. * \param vector The point to transform. * \return The transformed point. */ OutputVnlVectorType TransformVector(const InputVnlVectorType& vector) const ITK_OVERRIDE; protected: /** Constructor */ InverseLogPolarTransform(); /** Destructor */ ~InverseLogPolarTransform() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: InverseLogPolarTransform(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented InputPointType m_Center; ScaleType m_Scale; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbInverseLogPolarTransform.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbInverseLogPolarTransform.txx000066400000000000000000000136561301006202600275500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbInverseLogPolarTransform_txx #define otbInverseLogPolarTransform_txx #include "otbInverseLogPolarTransform.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { /** * Constructor. */ template InverseLogPolarTransform ::InverseLogPolarTransform() : Superclass(4) { m_Center[0] = 0.0; m_Center[1] = 0.0; m_Scale[0] = 1.0; m_Scale[1] = 1.0; } /** * Destructor. */ template InverseLogPolarTransform ::~InverseLogPolarTransform() {} /** * Set the transform parameters through the standard interface. * \param parameters The parameters of the transform. */ template void InverseLogPolarTransform ::SetParameters(const ParametersType& parameters) { m_Center[0] = parameters[0]; m_Center[1] = parameters[1]; m_Scale[0] = parameters[2]; m_Scale[1] = parameters[3]; otbMsgDebugMacro(<< "Call To SetParameters: Center=" << m_Center << ", Scale=" << m_Scale); this->m_Parameters = parameters; this->Modified(); } /** * Get the transform parameters through the standard interface. * \return The parameters of the transform. */ template typename InverseLogPolarTransform ::ParametersType& InverseLogPolarTransform ::GetParameters(void) const { // Filling parameters vector this->m_Parameters[0] = m_Center[0]; this->m_Parameters[1] = m_Center[1]; this->m_Parameters[2] = m_Scale[0]; this->m_Parameters[3] = m_Scale[1]; return this->m_Parameters; } /** * Transform a point. * \param point The point to transform. * \return The transformed point. */ template typename InverseLogPolarTransform ::OutputPointType InverseLogPolarTransform ::TransformPoint(const InputPointType& point) const { OutputPointType result; double rho = vcl_sqrt(vcl_pow(point[0] - m_Center[0], 2) + vcl_pow(point[1] - m_Center[1], 2)); if (rho > 0) { result[0] = (1. / m_Scale[0]) * vcl_asin((point[1] - m_Center[1]) / rho); // degree conversion result[0] = result[0] * (180. / CONST_PI); // Deplacing the range to [0, 90], [270, 360] result[0] = result[0] > 0. ? result[0] : result[0] + 360.; // Avoiding asin indetermination if ((point[0] - m_Center[0]) >= 0) { result[0] = result[0] < 90. ? result[0] + 90. : result[0] - 90.; } result[1] = (1. / m_Scale[1]) * vcl_log(rho); // otbMsgDebugMacro(< typename InverseLogPolarTransform ::OutputVectorType InverseLogPolarTransform ::TransformVector(const InputVectorType& vector) const { OutputVectorType result; double rho = vcl_sqrt(vcl_pow(vector[0] - m_Center[0], 2) + vcl_pow(vector[1] - m_Center[1], 2)); if (rho > 0) { result[0] = (1 / m_Scale[0]) * vcl_asin((vector[1] - m_Center[1]) / rho); // degree conversion result[0] = result[0] * (180 / CONST_PI); // Deplacing the range to [0, 90], [270, 360] result[0] = result[0] > 0 ? result[0] : result[0] + 360; // Avoiding asin indetermination if ((vector[0] - m_Center[0]) >= 0) { result[0] = result[0] < 90 ? result[0] + 90 : result[0] - 90; } result[1] = (1 / m_Scale[1]) * vcl_log(rho); // otbMsgDebugMacro(< typename InverseLogPolarTransform ::OutputVnlVectorType InverseLogPolarTransform ::TransformVector(const InputVnlVectorType& vector) const { OutputVnlVectorType result; double rho = vcl_sqrt(vcl_pow(vector[0], 2) + vcl_pow(vector[1], 2)); if (rho > 0) { result[0] = (1 / m_Scale[0]) * vcl_asin((vector[1] - m_Center[1]) / rho); // degree conversion result[0] = result[0] * (180 / CONST_PI); // Deplacing the range to [0, 90], [270, 360] result[0] = result[0] > 0 ? result[0] : result[0] + 360; // Avoiding vcl_asin indetermination if ((vector[0] - m_Center[0]) >= 0) { result[0] = result[0] < 90 ? result[0] + 90 : result[0] - 90; } result[1] = (1 / m_Scale[1]) * vcl_log(rho); // otbMsgDebugMacro(< void InverseLogPolarTransform ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Center: " << m_Center << std::endl; os << indent << "Scale: " << m_Scale << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbInverseSensorModel.h000066400000000000000000000054771301006202600257750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbInverseSensorModel_h #define otbInverseSensorModel_h #include "otbSensorModelBase.h" #include "itkMacro.h" #include "itkObject.h" namespace otb { /** \class InverseSensorModel * * \brief Class for inverse sensor models * * Based on ossimProjectionFactoryRegistry and ossimProjection methods. * It takes as input a world point and computes the index position of the * corresponding point in the input image. * (lon, lat, h) -> (i, j). * Notice that the elevation h is optional. * * \ingroup Transform * \ingroup Projection * * \ingroup OTBTransform */ template class ITK_EXPORT InverseSensorModel : public SensorModelBase { public: /** Standard class typedefs. */ typedef InverseSensorModel Self; typedef SensorModelBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputPointType InputPointType; typedef typename Superclass::OutputPointType OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(InverseSensorModel, SensorModelBase); itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); // Transform of geographic point in image sensor index OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; // Transform of geographic point in image sensor index -- Backward Compatibility // OutputPointType TransformPoint(const InputPointType &point, double height) const; protected: InverseSensorModel(); ~InverseSensorModel() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: InverseSensorModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbInverseSensorModel.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbInverseSensorModel.txx000066400000000000000000000041711301006202600263570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbInverseSensorModel_txx #define otbInverseSensorModel_txx #include "otbInverseSensorModel.h" #include "otbMacro.h" namespace otb { template InverseSensorModel ::InverseSensorModel() { } template InverseSensorModel ::~InverseSensorModel() { } template typename InverseSensorModel::OutputPointType InverseSensorModel ::TransformPoint(const InputPointType& point) const { double lon = point[0]; double lat = point[1]; double x, y, z; if (InputPointType::PointDimension == 3) { double h = point[2]; this->m_Model->InverseTransformPoint(lon, lat, h, x, y, z); } else { this->m_Model->InverseTransformPoint(lon, lat, x, y, z); } OutputPointType outputPoint; outputPoint[0] = x; outputPoint[1] = y; if (OutputPointType::PointDimension == 3) { outputPoint[2] = z; } return outputPoint; } template void InverseSensorModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbLogPolarTransform.h000066400000000000000000000111061301006202600256040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLogPolarTransform_h #define otbLogPolarTransform_h #include "otbTransform.h" namespace otb { /** \class LogPolarTransform * \brief Implement the log-polar coordinate transform. * * The log-polar coordinate system is a polar system where the * radial coordinate has a logarithmic scale. * * Given \f$(\rho,\theta)\f$ the coordinate in the log-polar system, the * corresponding cartesian coordinates are * * \f$ x-xc=exp(\rho)*cos(\theta) \f$ * \f$ y-yc=exp(\rho)*sin(\theta) \f$ * * Where (xc, yc) is the center of the log-polar transform in the cartesian space. * Please note that this center can NOT be represented in log-polar. * * \sa InverseLogPolarTransform * \ingroup Transform * * \ingroup OTBTransform */ template class ITK_EXPORT LogPolarTransform : public Transform { public: /** Standard typedef */ typedef LogPolarTransform Self; typedef Transform Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory */ itkNewMacro(Self); /** Runtime information */ itkTypeMacro(LogPolarTransform, Transform); /** Template related typedefs */ typedef TScalarType ScalarType; /** Superclass related typedefs */ typedef typename Superclass::InputPointType InputPointType; typedef typename Superclass::OutputPointType OutputPointType; typedef typename Superclass::InputVectorType InputVectorType; typedef typename Superclass::OutputVectorType OutputVectorType; typedef typename Superclass::InputVnlVectorType InputVnlVectorType; typedef typename Superclass::OutputVnlVectorType OutputVnlVectorType; typedef typename Superclass::ParametersType ParametersType; typedef itk::FixedArray ScaleType; /** Set/Get the origin */ itkSetMacro(Center, InputPointType); itkGetConstReferenceMacro(Center, InputPointType); /** Set/Get the scales */ itkSetMacro(Scale, ScaleType); itkGetConstReferenceMacro(Scale, ScaleType); /** * Set the transform parameters through the standard interface. * \param parameters The parameters of the transform. */ void SetParameters(const ParametersType& parameters) ITK_OVERRIDE; /** * Get the transform parameters through the standard interface. * \return The parameters of the transform. */ ParametersType& GetParameters(void) const ITK_OVERRIDE; /** * Set the Fixed Parameters * \param param The fixed parameters of the transform. */ void SetFixedParameters( const ParametersType & param) ITK_OVERRIDE { this->m_FixedParameters = param; } /** * Get the Fixed Parameters * \return The Fixed parameters of the transform. */ const ParametersType& GetFixedParameters(void) const ITK_OVERRIDE{return this->m_FixedParameters; } /** * Transform a point. * \param point The point to transform. * \return The transformed point. */ OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; /** * Transform a vector representing a point. * \param vector The point to transform. * \return The transformed point. */ using Superclass::TransformVector; OutputVectorType TransformVector(const InputVectorType& vector) const ITK_OVERRIDE; /** * Transform a vnl vector representing a point. * \param vector The point to transform. * \return The transformed point. */ OutputVnlVectorType TransformVector(const InputVnlVectorType& vector) const ITK_OVERRIDE; protected: /** Constructor */ LogPolarTransform(); /** Destructor */ ~LogPolarTransform() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LogPolarTransform(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented InputPointType m_Center; ScaleType m_Scale; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLogPolarTransform.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbLogPolarTransform.txx000066400000000000000000000101361301006202600262020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLogPolarTransform_txx #define otbLogPolarTransform_txx #include "otbLogPolarTransform.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { /** * Constructor. */ template LogPolarTransform ::LogPolarTransform() : Superclass(4) { m_Center[0] = 0.0; m_Center[1] = 0.0; m_Scale[0] = 1.0; m_Scale[1] = 1.0; } /** * Destructor. */ template LogPolarTransform ::~LogPolarTransform() {} /** * Set the transform parameters through the standard interface. * \param parameters The parameters of the transform. */ template void LogPolarTransform ::SetParameters(const ParametersType& parameters) { m_Center[0] = parameters[0]; m_Center[1] = parameters[1]; m_Scale[0] = parameters[2]; m_Scale[1] = parameters[3]; otbMsgDebugMacro(<< "Call To SetParameters: Center=" << m_Center << ", Scale=" << m_Scale); this->m_Parameters = parameters; this->Modified(); } /** * Get the transform parameters through the standard interface. * \return The parameters of the transform. */ template typename LogPolarTransform ::ParametersType& LogPolarTransform ::GetParameters(void) const { // Filling parameters vector this->m_Parameters[0] = m_Center[0]; this->m_Parameters[1] = m_Center[1]; this->m_Parameters[2] = m_Scale[0]; this->m_Parameters[3] = m_Scale[1]; return this->m_Parameters; } /** * Transform a point. * \param point The point to transform. * \return The transformed point. */ template typename LogPolarTransform ::OutputPointType LogPolarTransform ::TransformPoint(const InputPointType& point) const { OutputPointType result; double theta = point[0] * m_Scale[0] * CONST_PI_180; double logRho = point[1] * m_Scale[1]; result[0] = m_Center[0]; result[1] = m_Center[1]; result[0] += vcl_exp(logRho) * vcl_cos(theta); result[1] += vcl_exp(logRho) * vcl_sin(theta); return result; } /** * Transform a vector representing a point. * \param vector The point to transform. * \return The transformed point. */ template typename LogPolarTransform ::OutputVectorType LogPolarTransform ::TransformVector(const InputVectorType& vector) const { OutputVectorType result; double theta = vector[0] * m_Scale[0] * CONST_PI_180; double logRho = vector[1] * m_Scale[1]; result[0] = 0.; result[1] = 0.; result[0] += vcl_exp(logRho) * vcl_cos(theta); result[1] += vcl_exp(logRho) * vcl_sin(theta); return result; } /** * Transform a vnl vector representing a point. * \param vector The point to transform. * \return The transformed point. */ template typename LogPolarTransform ::OutputVnlVectorType LogPolarTransform ::TransformVector(const InputVnlVectorType& vector) const { OutputVnlVectorType result; double theta = vector[0] * m_Scale[0] * CONST_PI_180; double logRho = vector[1] * m_Scale[1]; result[0] = 0.; result[1] = 0.; result[0] += vcl_exp(logRho) * vcl_cos(theta); result[1] += vcl_exp(logRho) * vcl_sin(theta); return result; } /** * PrintSelf method. */ template void LogPolarTransform ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Center: " << m_Center << std::endl; os << indent << "Scale: " << m_Scale << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbSensorModelBase.h000066400000000000000000000062271301006202600252260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSensorModelBase_h #define otbSensorModelBase_h #include #include "otbMacro.h" #include "otbImageKeywordlist.h" #include "otbSensorModelAdapter.h" #include "otbTransform.h" #include "itkSmartPointer.h" namespace otb { /** \class SensorModelBase * \brief Base class for the sensor model projection classes. * * This class allows transforming a geographic point in (lat, long) to a point * in the sensor geometry. (lat, lon) -> (i, j) ou (lat, lon, h) -> (i, j) * * \ingroup Projection * * * \ingroup OTBTransform */ template class ITK_EXPORT SensorModelBase : public Transform { public: /** Standard class typedefs. */ typedef SensorModelBase Self; typedef Transform Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; typedef TScalarType PixelType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SensorModelBase, Transform); itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); /* Get the ImageKeywordlist */ ImageKeywordlist GetImageGeometryKeywordlist(void) const; /* * Set the Imagekeywordlist and affect the ossim projection ( m_Model) * Return false if not model found. */ virtual void SetImageGeometry(const ImageKeywordlist& image_kwl); /** Is sensor model valid method. return false if the sensor model is null */ bool IsValidSensorModel() { return m_Model->IsValidSensorModel(); } protected: SensorModelBase(); ~SensorModelBase() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ImageKeywordlist */ ImageKeywordlist m_ImageKeywordlist; /** Pointer on an ossim projection (created with the keywordlist) */ SensorModelAdapter::Pointer m_Model; private: SensorModelBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSensorModelBase.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbSensorModelBase.txx000066400000000000000000000043051301006202600256150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSensorModelBase_txx #define otbSensorModelBase_txx #include "otbSensorModelBase.h" namespace otb { template SensorModelBase ::SensorModelBase() : Superclass(0) { m_Model = SensorModelAdapter::New(); } template SensorModelBase ::~SensorModelBase() {} /// Get the Geometry Keyword list template ImageKeywordlist SensorModelBase ::GetImageGeometryKeywordlist(void) const { return m_ImageKeywordlist; } /** Set the Imagekeywordlist and affect the ossim projection ( m_Model) */ template void SensorModelBase ::SetImageGeometry(const ImageKeywordlist& image_kwl) { m_ImageKeywordlist = image_kwl; m_Model->CreateProjection(m_ImageKeywordlist); } /** * PrintSelf method */ template void SensorModelBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Model: " << m_Model << std::endl; os << indent << "Keywordlist: " << m_ImageKeywordlist << std::endl; } } // namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbStreamingWarpImageFilter.h000066400000000000000000000110461301006202600270700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingWarpImageFilter_h #define otbStreamingWarpImageFilter_h #include "otbWarpImageFilter.h" #include "otbStreamingTraits.h" namespace otb { /** \class StreamingWarpImageFilter * \brief This class acts like the otb::WarpImageFilter, but it does not request the largest possible region of the image to warp. * * Instead, the user should assess the maximum displacement in the displacement field and set it via the SetMaximumDisplacement() method. * * The filter will then compute an appropriate security margin according to the image spacing, the maximum displacement and the interpolator * radius in otb::StreamingTraits. * * This security margin is used to stream the input image, making this filter an entirely streamable one. * * If the maximum displacement is wrong, this filter is likely to request data outside of the input image buffered region. In this case, pixels * outside the region will be set to Zero according to itk::NumericTraits. * * \sa itk::WarpImageFilter * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBTransform */ template class ITK_EXPORT StreamingWarpImageFilter : public otb::WarpImageFilter { public: /** Standard class typedefs. */ typedef StreamingWarpImageFilter Self; typedef otb::WarpImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(StreamingWarpImageFilter, itk::WarpImageFilter); /** template parameters typedef */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PointType PointType; typedef typename OutputImageType::IndexType IndexType; typedef typename OutputImageType::PixelType PixelType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef TDisplacementField DisplacementFieldType; typedef typename DisplacementFieldType::PixelType DisplacementValueType; typedef typename DisplacementFieldType::Pointer DisplacementFieldPointerType; typedef typename DisplacementFieldType::RegionType DisplacementFieldRegionType; /** Accessors */ itkSetMacro(MaximumDisplacement, DisplacementValueType); itkGetConstReferenceMacro(MaximumDisplacement, DisplacementValueType); protected: /** Constructor */ StreamingWarpImageFilter(); /** Destructor */ ~StreamingWarpImageFilter() ITK_OVERRIDE {} /** PrintSelf */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * This filters requires only a part of the input and of the displacement field to * produce its output. As such, we need to overload the GenerateInputRequestedRegion() method. */ void GenerateInputRequestedRegion() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; /** * Re-implement the method ThreadedGenerateData to mask area outside the deformation grid */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE; private: StreamingWarpImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Assesment of the maximum displacement for streaming DisplacementValueType m_MaximumDisplacement; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingWarpImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Core/Transform/include/otbStreamingWarpImageFilter.txx000066400000000000000000000262611301006202600274710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingWarpImageFilter_txx #define otbStreamingWarpImageFilter_txx #include "otbStreamingWarpImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkDefaultConvertPixelTraits.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" namespace otb { template StreamingWarpImageFilter ::StreamingWarpImageFilter() { // Fill the default maximum displacement m_MaximumDisplacement.Fill(1); } template void StreamingWarpImageFilter ::GenerateInputRequestedRegion() { // Get the input and displacement field pointers InputImageType * inputPtr = const_cast(this->GetInput()); DisplacementFieldType * displacementPtr = const_cast(this->GetDisplacementField()); OutputImageType * outputPtr = this->GetOutput(); // Check if the input and the displacement field exist if (!inputPtr || !displacementPtr || !outputPtr) { return; } // Here we are breaking traditional pipeline steps because we need to access the displacement field data // so as to compute the input image requested region // 1) First, evaluate the displacement field requested region corresponding to the output requested region // (Here we suppose that the displacement field and the output image are in the same geometry/map projection) typename OutputImageType::RegionType outputRequestedRegion = outputPtr->GetRequestedRegion(); typename OutputImageType::IndexType outIndexStart = outputRequestedRegion.GetIndex(); typename OutputImageType::IndexType outIndexEnd; for(unsigned int dim = 0; dimTransformIndexToPhysicalPoint(outIndexStart, outPointStart); outputPtr->TransformIndexToPhysicalPoint(outIndexEnd, outPointEnd); typename DisplacementFieldType::IndexType defIndexStart, defIndexEnd; displacementPtr->TransformPhysicalPointToIndex(outPointStart, defIndexStart); displacementPtr->TransformPhysicalPointToIndex(outPointEnd, defIndexEnd); typename DisplacementFieldType::SizeType defRequestedSize; typename DisplacementFieldType::IndexType defRequestedIndex; for(unsigned int dim = 0; dimGetLargestPossibleRegion())) { displacementPtr->SetRequestedRegion(displacementRequestedRegion); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) displacementPtr->SetRequestedRegion(displacementRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region of the displacement field."); e.SetDataObject(inputPtr); throw e; } // 2) If we are still there, we have a correct displacement field requested region. // This next step breaks pipeline rule but we need to do it to compute the input requested region, // since it depends on displacement value. // Trigger pipeline update on the displacement field displacementPtr->PropagateRequestedRegion(); displacementPtr->UpdateOutputData(); // Walk the loaded displacement field to derive maximum and minimum itk::ImageRegionIteratorWithIndex defIt(displacementPtr, displacementRequestedRegion); defIt.GoToBegin(); typename InputImageType::PointType currentPoint; typename InputImageType::PointType inputStartPoint, inputEndPoint; // Initialise start and end points displacementPtr->TransformIndexToPhysicalPoint(defIt.GetIndex(), currentPoint); for(unsigned int dim = 0; dimTransformIndexToPhysicalPoint(defIt.GetIndex(), currentPoint); for(unsigned int dim = 0; dim currentPoint[dim]) inputStartPoint[dim] = currentPoint[dim]; if(inputEndPoint[dim] < currentPoint[dim]) inputEndPoint[dim] = currentPoint[dim]; } ++defIt; } // Convert physical bounding box to requested region typename InputImageType::IndexType inputStartIndex, inputEndIndex; inputPtr->TransformPhysicalPointToIndex(inputStartPoint, inputStartIndex); inputPtr->TransformPhysicalPointToIndex(inputEndPoint, inputEndIndex); typename InputImageType::SizeType inputFinalSize; typename InputImageType::IndexType inputFinalIndex; for(unsigned int dim = 0; dim::CalculateNeededRadiusForInterpolator(this->GetInterpolator()); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(interpolatorRadius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); } else { inputFinalSize.Fill(0); inputRequestedRegion.SetSize(inputFinalSize); inputFinalIndex.Fill(0); inputRequestedRegion.SetIndex(inputFinalIndex); // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // // build an exception // itk::InvalidRequestedRegionError e(__FILE__, __LINE__); // e.SetLocation(ITK_LOCATION); // e.SetDescription("Requested region is (at least partially) outside the largest possible region."); // e.SetDataObject(inputPtr); // throw e; } } template void StreamingWarpImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // Set the NoData flag to the edge padding value itk::MetaDataDictionary& dict = this->GetOutput()->GetMetaDataDictionary(); std::vector noDataValueAvailable; bool ret = itk::ExposeMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); if (!ret) { noDataValueAvailable.resize(this->GetOutput()->GetNumberOfComponentsPerPixel(),false); } std::vector noDataValue; ret = itk::ExposeMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); if (!ret) { noDataValue.resize(this->GetOutput()->GetNumberOfComponentsPerPixel(),0.0); } PixelType edgePadding = this->GetEdgePaddingValue(); for (unsigned int i=0; i::GetNthComponent(i,edgePadding); } } itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); } template void StreamingWarpImageFilter ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { // the superclass itk::WarpImageFilter is doing the actual warping Superclass::ThreadedGenerateData(outputRegionForThread,threadId); // second pass on the thread region to mask pixels outside the displacement grid const PixelType paddingValue = this->GetEdgePaddingValue(); OutputImagePointerType outputPtr = this->GetOutput(); DisplacementFieldPointerType fieldPtr = this->GetDisplacementField(); DisplacementFieldRegionType defRegion = fieldPtr->GetLargestPossibleRegion(); itk::ImageRegionIteratorWithIndex outputIt( outputPtr, outputRegionForThread ); IndexType currentIndex; PointType currentPoint; itk::ContinuousIndex contiIndex; while(!outputIt.IsAtEnd()) { // get the output image index currentIndex = outputIt.GetIndex(); outputPtr->TransformIndexToPhysicalPoint(currentIndex,currentPoint); fieldPtr->TransformPhysicalPointToContinuousIndex(currentPoint,contiIndex); for (unsigned int dim = 0; dim(defRegion.GetIndex(dim)) || contiIndex[dim] > static_cast(defRegion.GetIndex(dim)+defRegion.GetSize(dim)-1)) { outputIt.Set(paddingValue); break; } } ++outputIt; } } template void StreamingWarpImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Maximum displacement: " << m_MaximumDisplacement << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/Transform/include/otbTransform.h000066400000000000000000000207621301006202600241540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTransform_h #define otbTransform_h #include "itkTransform.h" #include "vnl/vnl_vector_fixed.h" namespace otb { /** \class Transform * \brief Class to overload method passed to virtual pure in ITK V4. * * * * \ingroup OTBTransform */ template< class TScalarType, unsigned int NInputDimensions = 3, unsigned int NOutputDimensions = 3 > class ITK_EXPORT Transform : public itk::Transform // Number of dimensions in the output space { public: /** Standard class typedefs. */ typedef Transform Self; typedef itk::Transform Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer< const Self > ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(Transform, itk::Transform); /** Dimension of the domain space. */ itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); /** Get the size of the input space */ unsigned int GetInputSpaceDimension(void) const ITK_OVERRIDE { return NInputDimensions; } /** Get the size of the output space */ unsigned int GetOutputSpaceDimension(void) const ITK_OVERRIDE { return NOutputDimensions; } /** Type of the scalar representing coordinate and vector elements. */ typedef TScalarType ScalarType; /** Type of the input parameters. */ typedef typename Superclass::ParametersType ParametersType; typedef typename Superclass::ParametersValueType ParametersValueType; typedef typename Superclass::NumberOfParametersType NumberOfParametersType; /** Type of the Jacobian matrix. */ typedef itk::Array2D< double > JacobianType; /** Standard vector type for this class. */ typedef itk::Vector< TScalarType, NInputDimensions > InputVectorType; typedef itk::Vector< TScalarType, NOutputDimensions > OutputVectorType; /** Standard covariant vector type for this class */ typedef itk::CovariantVector< TScalarType, NInputDimensions > InputCovariantVectorType; typedef itk::CovariantVector< TScalarType, NOutputDimensions > OutputCovariantVectorType; /** Standard vnl_vector type for this class. */ typedef vnl_vector_fixed< TScalarType, NInputDimensions > InputVnlVectorType; typedef vnl_vector_fixed< TScalarType, NOutputDimensions > OutputVnlVectorType; /** Standard coordinate point type for this class */ typedef itk::Point< TScalarType, NInputDimensions > InputPointType; typedef itk::Point< TScalarType, NOutputDimensions > OutputPointType; /** Base inverse transform type. This type should not be changed to the * concrete inverse transform type or inheritance would be lost. */ typedef typename Superclass::InverseTransformBaseType InverseTransformBaseType; typedef typename Superclass::InverseTransformBasePointer InverseTransformBasePointer; /** Method to transform a point. */ OutputPointType TransformPoint(const InputPointType & ) const ITK_OVERRIDE { return OutputPointType(); } using Superclass::TransformVector; /** Method to transform a vector. */ OutputVectorType TransformVector(const InputVectorType &) const ITK_OVERRIDE { return OutputVectorType(); } /** Method to transform a vnl_vector. */ virtual OutputVnlVectorType TransforVector(const InputVnlVectorType &) const { return OutputVnlVectorType(); } using Superclass::TransformCovariantVector; /** Method to transform a CovariantVector. */ OutputCovariantVectorType TransformCovariantVector( const InputCovariantVectorType &) const ITK_OVERRIDE { return OutputCovariantVectorType(); } /** Set the transformation parameters and update internal transformation. * SetParameters gives the transform the option to set it's * parameters by keeping a reference to the parameters, or by * copying. To force the transform to copy it's parameters call * SetParametersByValue. * \sa SetParametersByValue */ void SetParameters( const ParametersType & ) ITK_OVERRIDE { itkExceptionMacro( << "Subclasses should ITK_OVERRIDE this method (SetParameters)" ) } void ComputeJacobianWithRespectToParameters(const InputPointType &, JacobianType& ) const ITK_OVERRIDE { itkExceptionMacro(<< "Subclasses should ITK_OVERRIDE this method (ComputeJacobianWithRespectToParameters)" ); } /** Set the transformation parameters and update internal transformation. * This method forces the transform to copy the parameters. The * default implementation is to call SetParameters. This call must * be overridden if the transform normally implements SetParameters * by keeping a reference to the parameters. * \sa SetParameters */ void SetParametersByValue(const ParametersType & p) ITK_OVERRIDE { this->SetParameters (p); } /** Get the Transformation Parameters. */ const ParametersType & GetParameters(void) const ITK_OVERRIDE { return m_Parameters; } /** Set the fixed parameters and update internal transformation. */ void SetFixedParameters( const ParametersType & ) ITK_OVERRIDE { itkExceptionMacro( << "Subclasses should ITK_OVERRIDE this method (SetFixedParameters)" ) } /** Get the Fixed Parameters. */ const ParametersType& GetFixedParameters(void) const ITK_OVERRIDE { itkExceptionMacro( << "Subclasses should ITK_OVERRIDE this method (GetFixedParameters)" ); // Next line is needed to avoid errors due to: // "function must return a value". return this->m_FixedParameters; } /** Compute the Jacobian of the transformation * * This method computes the Jacobian matrix of the transformation * at a given input point. The rank of the Jacobian will also indicate * if the transform is invertible at this point. * * The Jacobian is be expressed as a matrix of partial derivatives of the * output point components with respect to the parameters that defined * the transform: * * \f[ * J=\left[ \begin{array}{cccc} \frac{\partial x_{1}}{\partial p_{1}} & \frac{\partial x_{1}}{\partial p_{2}} & \cdots & \frac{\partial x_{1}}{\partial p_{m}}\\ \frac{\partial x_{2}}{\partial p_{1}} & \frac{\partial x_{2}}{\partial p_{2}} & \cdots & \frac{\partial x_{2}}{\partial p_{m}}\\ \vdots & \vdots & \ddots & \vdots \\ \frac{\partial x_{n}}{\partial p_{1}} & \frac{\partial x_{n}}{\partial p_{2}} & \cdots & \frac{\partial x_{n}}{\partial p_{m}} \end{array}\right] * * \f] * */ virtual const JacobianType & GetJacobian(const InputPointType &) const { itkExceptionMacro( << "Subclass should ITK_OVERRIDE this method (GetJacobian)" ); // Next line is needed to avoid errors due to: // "function must return a value" . return this->m_Jacobian; } /** Return the number of parameters that completely define the Transfom */ NumberOfParametersType GetNumberOfParameters(void) const ITK_OVERRIDE { return this->m_Parameters.Size(); } protected: Transform(): Superclass::Transform() {} Transform(NumberOfParametersType numberOfParameters) : Superclass::Transform(numberOfParameters) {} ~Transform() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); #if 0 os << indent << "Parameters : " << m_Parameters << std::endl; os << indent << "FixedParameters : " << m_FixedParameters << std::endl; os << indent << "Jacobian : " << m_Jacobian << std::endl; #endif } mutable ParametersType m_Parameters; mutable ParametersType m_FixedParameters; mutable JacobianType m_Jacobian; private: Transform(const Self &); //purposely not implemented void operator=(const Self &); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/Transform/otb-module.cmake000066400000000000000000000011361301006202600227430ustar00rootroot00000000000000set(DOCUMENTATION "This module contains additional geometric transformations that are more suitable to remote sensing (compared to the ones already available in itk -see itk::Transform-). this mainly concerns transformations of coordinates from any map projection or sensor model to any map projection or sensor model.") otb_module(OTBTransform ENABLE_SHARED DEPENDS OTBBoost OTBCommon OTBGDAL OTBITK OTBInterpolation OTBOSSIMAdapters TEST_DEPENDS OTBImageBase OTBImageIO OTBImageManipulation OTBOssim OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/Transform/src/000077500000000000000000000000001301006202600204605ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Transform/src/CMakeLists.txt000066400000000000000000000004341301006202600232210ustar00rootroot00000000000000set(OTBTransform_SRC otbGeoInformationConversion.cxx ) add_library(OTBTransform ${OTBTransform_SRC}) target_link_libraries(OTBTransform ${OTBCommon_LIBRARIES} ${OTBGDAL_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ) otb_module_target(OTBTransform) OTB-release-5.8/Modules/Core/Transform/src/otbGeoInformationConversion.cxx000066400000000000000000000032651301006202600267050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeoInformationConversion.h" #include "ogr_spatialref.h" #include "ogr_core.h" #include "cpl_conv.h" #include "boost/lexical_cast.hpp" #include "itkMacro.h" namespace otb { std::string GeoInformationConversion::ToWKT(int srid) { char * wkt = ITK_NULLPTR; std::string ret; // Build the srs from the epsg number OGRSpatialReferenceH hSRS = ITK_NULLPTR; hSRS = OSRNewSpatialReference(ITK_NULLPTR); if (OSRImportFromEPSG(hSRS, srid ) == OGRERR_NONE) { // Get the wkt if ( OSRExportToWkt(hSRS, &wkt) == OGRERR_NONE) { ret = wkt; CPLFree(wkt); } } OSRRelease(hSRS); return ret; } std::string GeoInformationConversion::ToWKT(const std::string& candidateSrid) { std::string wkt(candidateSrid); try { int srid = boost::lexical_cast(candidateSrid); return GeoInformationConversion::ToWKT(srid); } catch(boost::bad_lexical_cast &) { return wkt; } } bool GeoInformationConversion::IsESRIValidWKT(const std::string &wkt) { OGRSpatialReference SRS(wkt.c_str()); SRS.morphToESRI(); return SRS.Validate()==OGRERR_NONE; } } // End namespace otb OTB-release-5.8/Modules/Core/Transform/test/000077500000000000000000000000001301006202600206505ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/Transform/test/CMakeLists.txt000066400000000000000000000170011301006202600234070ustar00rootroot00000000000000otb_module_test() set(OTBTransformTests otbTransformTestDriver.cxx otbGenericRSTransformWithSRID.cxx otbCreateInverseForwardSensorModel.cxx otbGenericRSTransform.cxx otbCreateProjectionWithOSSIM.cxx otbLogPolarTransformResample.cxx otbStreamingWarpImageFilterNew.cxx otbLogPolarTransform.cxx otbGenericRSTransformNew.cxx otbLogPolarTransformNew.cxx otbGeocentricTransform.cxx otbCreateProjectionWithOTB.cxx otbGeocentricTransformNew.cxx otbGenericMapProjection.cxx otbStreamingWarpImageFilter.cxx otbSensorModelsNew.cxx otbGenericMapProjectionNew.cxx otbInverseLogPolarTransform.cxx otbInverseLogPolarTransformNew.cxx otbInverseLogPolarTransformResample.cxx otbStreamingResampleImageFilterWithAffineTransform.cxx ) add_executable(otbTransformTestDriver ${OTBTransformTests}) target_link_libraries(otbTransformTestDriver ${OTBTransform-Test_LIBRARIES}) otb_module_target_label(otbTransformTestDriver) # Tests Declaration otb_add_test(NAME prTvGenericMapProjection COMMAND otbTransformTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvGenericMapProjection.txt ${TEMP}/prTvGenericMapProjection.txt otbGenericMapProjection ${TEMP}/prTvGenericMapProjection.txt ) otb_add_test(NAME prTvGenericRSTransformWithSRID COMMAND otbTransformTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvGenericRSTransform.txt ${TEMP}/prTvGenericRSTransform_WithSRID.txt otbGenericRSTransformWithSRID 1.35617289802566 43.4876035537 ${TEMP}/prTvGenericRSTransform_WithSRID.txt ) otb_add_test(NAME prTvTestCreateInverseForwardSensorModel_Cevennes COMMAND otbTransformTestDriver otbCreateInverseForwardSensorModel LARGEINPUT{QUICKBIRD/CEVENNES/06FEB12104912-P1BS-005533998070_01_P001.TIF} ) otb_add_test(NAME prTvTestCreateInverseForwardSensorModel_Toulouse COMMAND otbTransformTestDriver otbCreateInverseForwardSensorModel LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ) otb_add_test(NAME prTvGenericRSTransform COMMAND otbTransformTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvGenericRSTransform.txt ${TEMP}/prTvGenericRSTransform.txt otbGenericRSTransform 1.35617289802566 43.4876035537 ${TEMP}/prTvGenericRSTransform.txt ) otb_add_test(NAME prTvTestCreateProjectionWithOSSIM_Cevennes COMMAND otbTransformTestDriver otbCreateProjectionWithOSSIM LARGEINPUT{QUICKBIRD/CEVENNES/06FEB12104912-P1BS-005533998070_01_P001.TIF} ) otb_add_test(NAME prTvTestCreateProjectionWithOSSIM_Toulouse COMMAND otbTransformTestDriver otbCreateProjectionWithOSSIM LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ) otb_add_test(NAME bfTvLogPolarTransformResample COMMAND otbTransformTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfLogPolarTransformResampleOutput.hdr ${TEMP}/bfLogPolarTransformResampleOutput.hdr otbLogPolarTransformResample ${INPUTDATA}/circle.hdr ${TEMP}/bfLogPolarTransformResampleOutput.hdr ) otb_add_test(NAME dmTuStreamingWarpImageFilterNew COMMAND otbTransformTestDriver otbStreamingWarpImageFilterNew) otb_add_test(NAME bfTvLogPolarTransform COMMAND otbTransformTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfLogPolarTransformResults.txt ${TEMP}/bfLogPolarTransformResults.txt otbLogPolarTransform 1 1 ${TEMP}/bfLogPolarTransformResults.txt 5 0 0 0 10 45 0 3.14 3.14 18 1 ) otb_add_test(NAME prTuGenericRSTransformNew COMMAND otbTransformTestDriver otbGenericRSTransformNew ) otb_add_test(NAME bfTuLogPolarTransformNew COMMAND otbTransformTestDriver otbLogPolarTransformNew) otb_add_test(NAME prTvGeocentricTransform COMMAND otbTransformTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvGeocentricTransform.txt ${TEMP}/prTvGeocentricTransform.txt otbGeocentricTransform ${TEMP}/prTvGeocentricTransform.txt ) otb_add_test(NAME prTvTestCreateProjectionWithOTB_Toulouse COMMAND otbTransformTestDriver otbCreateProjectionWithOTB LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ) otb_add_test(NAME prTvTestCreateProjectionWithOTB_Cevennes COMMAND otbTransformTestDriver otbCreateProjectionWithOTB LARGEINPUT{QUICKBIRD/CEVENNES/06FEB12104912-P1BS-005533998070_01_P001.TIF} ) otb_add_test(NAME prTuGeocentricTransformNew COMMAND otbTransformTestDriver otbGeocentricTransformNew ) otb_add_test(NAME dmTvStreamingWarpImageFilter COMMAND otbTransformTestDriver --compare-image ${EPSILON_10} ${BASELINE}/dmStreamingWarpImageFilterOutput.tif ${TEMP}/dmStreamingWarpImageFilterOutput.tif otbStreamingWarpImageFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub_deformation_field.tif ${TEMP}/dmStreamingWarpImageFilterOutput.tif 5 ) otb_add_test(NAME prTuSensorModelsNew COMMAND otbTransformTestDriver otbSensorModelsNew ) otb_add_test(NAME prTuGenericMapProjectionNew COMMAND otbTransformTestDriver otbGenericMapProjectionNew ) # Forward / Backward projection consistency checking set(FWDBWDChecking_INPUTS LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} #LARGEINPUT{SPOT4/RIO_DE_JANEIRO/IMAG_01.DAT} LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} LARGEINPUT{RADARSAT1/GOMA2/SCENE01/DAT_01.001} LARGEINPUT{RADARSAT2/ALTONA/Fine_Quad-Pol_Dataset/PK6621_DK406_FQ9_20080405_124900_HH_VV_HV_VH_SLC_Altona/imagery_HH.tif} LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} #LARGEINPUT{GEOEYE/LES_ROCHES/po_350134_bgrn_0000000.tif} #LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_pan_0000000.tif} #LARGEINPUT{PALSAR/ALOS-H1_1__A-ORBIT__ALPSRP037120700.tif} #LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} LARGEINPUT{TERRASARX/2008-03-10_GrandCanyon_SSC/TSX1_SAR__SSC______SM_S_SRA_20080310T133220_20080310T133228/IMAGEDATA/IMAGE_HH_SRA_strip_011.cos} LARGEINPUT{ENVISAT_ASAR_SCENE01/ASA_APS_1PNDPA20030821_7713.N1} #LARGEINPUT{COSMOSKYMED/Toulouse_spotlight/CSKS3_GTC_B_S2_08_HH_RD_SF_20110418180325_20110418180332.h5} #LARGEINPUT{MODIS/MOD13Q1/MOD13Q1.A2010001.h17v05.005.2010028003734.hdf} #LARGEINPUT{ONERA/spa3_0215_rad.dat} #LARGEINPUT{RAPIDEYE/level3A/2008-12-25T005918_RE3_3A-NAC_752656_40091.tif} ) otb_add_test(NAME bfTvInverseLogPolarTransform COMMAND otbTransformTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfInverseLogPolarTransformResults.txt ${TEMP}/bfInverseLogPolarTransformResults.txt otbInverseLogPolarTransform 1. 1. ${TEMP}/bfInverseLogPolarTransformResults.txt 6 0 0 10 20 45 60 3.14 3.14 1 0 0 1 ) otb_add_test(NAME bfTuInverseLogPolarTransformNew COMMAND otbTransformTestDriver otbInverseLogPolarTransformNew) otb_add_test(NAME bfTvInverseLogPolarTransformResample COMMAND otbTransformTestDriver --compare-image ${NOTOL} ${BASELINE}/bfInverseLogPolarTransformResampleOutput.hdr ${TEMP}/bfInverseLogPolarTransformResampleOutput.hdr otbInverseLogPolarTransformResample ${BASELINE}/bfLogPolarTransformResampleOutput.hdr ${TEMP}/bfInverseLogPolarTransformResampleOutput.hdr ) otb_add_test(NAME bfTvStreamingResampleImageFilterWithAffineTransform COMMAND otbTransformTestDriver otbStreamingResampleImageFilterWithAffineTransform LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} 500 ${TEMP}/bfTvotbStreamingResampledImageWithAffineTransform.tif ) otb_add_test(NAME bfTuStreamingResampleImageFilterWithAffineTransformNew COMMAND otbTransformTestDriver otbStreamingResampleImageFilterWithAffineTransform ) OTB-release-5.8/Modules/Core/Transform/test/SensorModelBorder.cxx000066400000000000000000000200601301006202600247620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbForwardSensorModel.h" #include "otbInverseSensorModel.h" // Exercise the Spot5 sensor model on the image border int main(int argc, char* argv[]) { if (argc != 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } char * filename = argv[1]; char* outFilename = argv[2]; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(16.19688987731934); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(filename); reader->UpdateOutputInformation(); ImageType::Pointer image = reader->GetOutput(); ImageType::RegionType region = image->GetLargestPossibleRegion(); typedef otb::ForwardSensorModel ForwardSensorModelType; ForwardSensorModelType::Pointer forwardSensorModel = ForwardSensorModelType::New(); forwardSensorModel->SetImageGeometry(reader->GetOutput()->GetImageKeywordlist()); if (forwardSensorModel->IsValidSensorModel() == false) { std::cout << "Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!" << std::endl; return EXIT_FAILURE; } typedef otb::InverseSensorModel InverseSensorModelType; InverseSensorModelType::Pointer inverseSensorModel = InverseSensorModelType::New(); inverseSensorModel->SetImageGeometry(reader->GetOutput()->GetImageKeywordlist()); if (inverseSensorModel->IsValidSensorModel() == false) { std::cout << "Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!" << std::endl; return EXIT_FAILURE; } const int radius = 10; const double gridstep = 0.1; itk::Point imagePoint; // Test upper left corner std::cout << " --- upper left corner ---" << std::endl; for (imagePoint[0] = region.GetIndex(0) - radius; imagePoint[0] < region.GetIndex(0) + radius; imagePoint[0] += gridstep) { for (imagePoint[1] = region.GetIndex(1) - radius; imagePoint[1] < region.GetIndex(1) + radius; imagePoint[1] += gridstep) { itk::Point geoPoint; geoPoint = forwardSensorModel->TransformPoint(imagePoint); std::cout << "Image to geo: " << imagePoint << " -> " << geoPoint << "\n"; if (vnl_math_isnan(geoPoint[0]) || vnl_math_isnan(geoPoint[1])) { return EXIT_FAILURE; } itk::Point reversedImagePoint; reversedImagePoint = inverseSensorModel->TransformPoint(geoPoint); std::cout << "Geo to image: " << geoPoint << " -> " << reversedImagePoint << "\n"; if (vnl_math_isnan(reversedImagePoint[0]) || vnl_math_isnan(reversedImagePoint[1])) { return EXIT_FAILURE; } } } // Test lower left corner std::cout << " --- lower left corner ---" << std::endl; for (imagePoint[0] = region.GetIndex(0) - radius; imagePoint[0] < region.GetIndex(0) + radius; imagePoint[0] += gridstep) { for (imagePoint[1] = region.GetIndex(1) + region.GetSize(1) - radius; imagePoint[1] < region.GetIndex(1) + region.GetSize(1) + radius; imagePoint[1] += gridstep) { itk::Point geoPoint; geoPoint = forwardSensorModel->TransformPoint(imagePoint); std::cout << "Image to geo: " << imagePoint << " -> " << geoPoint << "\n"; if (vnl_math_isnan(geoPoint[0]) || vnl_math_isnan(geoPoint[1])) { return EXIT_FAILURE; } itk::Point reversedImagePoint; reversedImagePoint = inverseSensorModel->TransformPoint(geoPoint); std::cout << "Geo to image: " << geoPoint << " -> " << reversedImagePoint << "\n"; if (vnl_math_isnan(reversedImagePoint[0]) || vnl_math_isnan(reversedImagePoint[1])) { return EXIT_FAILURE; } } } // Test lower right corner std::cout << " --- lower right corner ---" << std::endl; for (imagePoint[0] = region.GetIndex(0) + region.GetSize(0) - radius; imagePoint[0] < region.GetIndex(0) + region.GetSize(0) + radius; imagePoint[0] += gridstep) { for (imagePoint[1] = region.GetIndex(1) + region.GetSize(1) - radius; imagePoint[1] < region.GetIndex(1) + region.GetSize(1) + radius; imagePoint[1] += gridstep) { itk::Point geoPoint; geoPoint = forwardSensorModel->TransformPoint(imagePoint); std::cout << "Image to geo: " << imagePoint << " -> " << geoPoint << "\n"; if (vnl_math_isnan(geoPoint[0]) || vnl_math_isnan(geoPoint[1])) { return EXIT_FAILURE; } itk::Point reversedImagePoint; reversedImagePoint = inverseSensorModel->TransformPoint(geoPoint); std::cout << "Geo to image: " << geoPoint << " -> " << reversedImagePoint << "\n"; if (vnl_math_isnan(reversedImagePoint[0]) || vnl_math_isnan(reversedImagePoint[1])) { return EXIT_FAILURE; } } } // Test upper right corner std::cout << " --- upper right corner ---" << std::endl; for (imagePoint[0] = region.GetIndex(0) + region.GetSize(0) - radius; imagePoint[0] < region.GetIndex(0) + region.GetSize(0) + radius; imagePoint[0] += gridstep) { for (imagePoint[1] = region.GetIndex(1) - radius; imagePoint[1] < region.GetIndex(1) + radius; imagePoint[1] += gridstep) { itk::Point geoPoint; geoPoint = forwardSensorModel->TransformPoint(imagePoint); std::cout << "Image to geo: " << imagePoint << " -> " << geoPoint << "\n"; if (vnl_math_isnan(geoPoint[0]) || vnl_math_isnan(geoPoint[1])) { return EXIT_FAILURE; } itk::Point reversedImagePoint; reversedImagePoint = inverseSensorModel->TransformPoint(geoPoint); std::cout << "Geo to image: " << geoPoint << " -> " << reversedImagePoint << "\n"; if (vnl_math_isnan(reversedImagePoint[0]) || vnl_math_isnan(reversedImagePoint[1])) { return EXIT_FAILURE; } } } // generat the output value along a segment crossing the lower image border // at the center position itk::Point imagePoint1; imagePoint1[0] = region.GetIndex(0) + region.GetSize(0)/2; imagePoint1[1] = region.GetIndex(1) + region.GetSize(1) - radius; itk::Point imagePoint2; imagePoint2[0] = region.GetIndex(0) + region.GetSize(0)/2; imagePoint2[1] = region.GetIndex(1) + region.GetSize(1) + radius; itk::Point geoPoint1, geoPoint2; geoPoint1 = forwardSensorModel->TransformPoint(imagePoint1); geoPoint2 = forwardSensorModel->TransformPoint(imagePoint2); itk::Vector geoDir; geoDir[0] = geoPoint2[0] - geoPoint1[0]; geoDir[1] = geoPoint2[1] - geoPoint1[1]; const int nbStep = 50; itk::Vector geoStep = geoDir / nbStep; std::ofstream file; file.open(outFilename); file << "# image_x image_y geo_x geo_y reversed_image_x reversed_image_y" << std::endl; file << std::setprecision(15); for (int i = 0; i < nbStep; ++i) { itk::Point geoPoint; geoPoint[0] = geoPoint1[0] + geoStep[0] * i; geoPoint[1] = geoPoint1[1] + geoStep[1] * i; itk::Point reversedImagePoint; reversedImagePoint = inverseSensorModel->TransformPoint(geoPoint); file << geoPoint[0] << "\t" << geoPoint[1] << "\t" << reversedImagePoint[0] << "\t" << reversedImagePoint[1] << std::endl; if (vnl_math_isnan(geoPoint[0]) || vnl_math_isnan(geoPoint[1])) { return EXIT_FAILURE; } } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbCreateInverseForwardSensorModel.cxx000066400000000000000000000046541301006202600303510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*! * * PURPOSE: * * Application to rproject an image region into gepgraphical coordinates * usinf un Interpolator+regionextractor and an Iterator. * */ // iostream is used for general output #include #include #include #include "otbMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbInverseSensorModel.h" #include "otbForwardSensorModel.h" int otbCreateInverseForwardSensorModel(int argc, char* argv[]) { if (argc != 2) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::InverseSensorModel InverseModelType; typedef otb::ForwardSensorModel ForwardModelType; //Allocate pointer InverseModelType::Pointer inverse_model = InverseModelType::New(); ForwardModelType::Pointer forward_model = ForwardModelType::New(); ReaderType::Pointer reader = ReaderType::New(); // Set parameters ... reader->SetFileName(argv[1]); // Read meta data (ossimKeywordlist) reader->GenerateOutputInformation(); ImageType::Pointer inputImage = reader->GetOutput(); otbGenericMsgDebugMacro(<< "Inverse model creation..."); inverse_model->SetImageGeometry(inputImage->GetImageKeywordlist()); if( inverse_model->IsValidSensorModel() == false ) { std::cout<<"Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!"<SetImageGeometry(inputImage->GetImageKeywordlist()); if( forward_model->IsValidSensorModel() == false ) { std::cout<<"Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!"< #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkExtractImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkLinearInterpolateImageFunction.h" #include "otbInverseSensorModel.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/imaging/ossimImageHandler.h" #include "ossim/base/ossimKeywordlist.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #include "ossim/projection/ossimProjectionFactoryRegistry.h" #pragma GCC diagnostic pop #else #include "ossim/imaging/ossimImageHandler.h" #include "ossim/base/ossimKeywordlist.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #include "ossim/projection/ossimProjectionFactoryRegistry.h" #endif int otbCreateProjectionWithOSSIM(int argc, char* argv[]) { if (argc != 2) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } otbGenericMsgDebugMacro(<< "Creating handler..."); ossimImageHandler *handler = ossimImageHandlerRegistry::instance()->open(ossimFilename(argv[1])); if (!handler) { itkGenericExceptionMacro(<< "Unable to open input image " << argv[1]); } ossimKeywordlist geom; otbGenericMsgDebugMacro(<< "Read ossim Keywordlist..."); handler->getImageGeometry()->getProjection()->saveState(geom); ossimGpt ossimGPoint(0, 0); ossimDpt ossimDPoint; otbGenericMsgDebugMacro(<< "Creating projection..."); ossimProjection * model = ITK_NULLPTR; model = ossimProjectionFactoryRegistry::instance()->createProjection(geom); if (model == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Invalid Model * == NULL !"); } otbGenericMsgDebugMacro(<< "Creating RefPtr of projection..."); ossimRefPtr ptrmodel = model; if (ptrmodel.valid() == false) { itkGenericExceptionMacro(<< "Invalid Model pointer .valid() == false !"); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbCreateProjectionWithOTB.cxx000066400000000000000000000061631301006202600265500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*! * * PURPOSE: * * Application to rproject an image region into gepgraphical coordinates * usinf un Interpolator+regionextractor and an Iterator. * */ // iostream is used for general output #include #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkExtractImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkLinearInterpolateImageFunction.h" #include "otbInverseSensorModel.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include "ossim/base/ossimKeywordlist.h" #include "ossim/base/ossimGpt.h" #include "ossim/projection/ossimProjectionFactoryRegistry.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #pragma GCC diagnostic pop #else #include "ossim/base/ossimKeywordlist.h" #include "ossim/base/ossimGpt.h" #include "ossim/projection/ossimProjectionFactoryRegistry.h" #include "ossim/imaging/ossimImageHandlerRegistry.h" #endif int otbCreateProjectionWithOTB(int argc, char* argv[]) { if (argc != 2) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); //Read meta data (ossimKeywordlist) reader->GenerateOutputInformation(); otbGenericMsgDebugMacro(<< "Read ossim Keywordlist..."); otb::ImageKeywordlist otb_image_keywordlist = reader->GetOutput()->GetImageKeywordlist(); ossimKeywordlist geom; otb_image_keywordlist.convertToOSSIMKeywordlist(geom); otbGenericMsgDebugMacro(<< "ossim Keywordlist:" << geom); ossimGpt ossimGPoint(0, 0); ossimDpt ossimDPoint; ossimProjection * model = ITK_NULLPTR; otbGenericMsgDebugMacro(<< "Creating projection..."); model = ossimProjectionFactoryRegistry::instance()->createProjection(geom); if (model == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Invalid Model * == NULL !"); } otbGenericMsgDebugMacro(<< "Creating RefPtr of projection..."); ossimRefPtr ptrmodel = model; if (ptrmodel.valid() == false) { itkGenericExceptionMacro(<< "Invalid Model pointer .valid() == false !"); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbGenericMapProjection.cxx000066400000000000000000000052501301006202600261520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbGenericMapProjection.h" int otbGenericMapProjection(int itkNotUsed(argc), char* argv[]) { const char * outFileName = argv[1]; std::ofstream file; file.open(outFileName); file << std::setprecision(15); /** Test the ability to instantiate a projection from a string*/ std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; typedef otb::GenericMapProjection GenericMapProjection; GenericMapProjection::Pointer genericMapProjection = GenericMapProjection::New(); genericMapProjection->SetWkt(projectionRefWkt); file << genericMapProjection->GetWkt() << std::endl << std::endl; itk::Point point; point[0] = 1.44; point[1] = 43.6050; file << "Forward projection: " << std::endl; file << point << " -> "; file << genericMapProjection->TransformPoint(point); file << std::endl << std::endl; typedef otb::GenericMapProjection GenericMapProjectionInverse; GenericMapProjectionInverse::Pointer genericMapProjectionInverse = GenericMapProjectionInverse::New(); genericMapProjectionInverse->SetWkt(projectionRefWkt); file << genericMapProjectionInverse->GetWkt() << std::endl << std::endl; point[0] = 374100.8; point[1] = 4829184.8; file << "Inverse projection: " << std::endl; file << point << " -> "; file << genericMapProjectionInverse->TransformPoint(point); file << std::endl << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbGenericMapProjectionNew.cxx000066400000000000000000000016001301006202600266170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbGenericMapProjection.h" int otbGenericMapProjectionNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::GenericMapProjection MapProjectionType; MapProjectionType::Pointer mapProjection = MapProjectionType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbGenericRSTransform.cxx000066400000000000000000000161641301006202600256260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbGenericRSTransform.h" #include int otbGenericRSTransform(int itkNotUsed(argc), char* argv[]) { OGRSpatialReference oSRS; typedef otb::GenericRSTransform<> TransformType; typedef TransformType::InputPointType PointType; PointType geoPoint; geoPoint[0] = atof(argv[1]); geoPoint[1] = atof(argv[2]); const char * outfname = argv[3]; // Build wgs ref oSRS.SetWellKnownGeogCS("WGS84"); char * wgsRef = ITK_NULLPTR; oSRS.exportToWkt(&wgsRef); // Build UTM ref oSRS.SetProjCS("UTM"); oSRS.SetUTM(31, true); char * utmRef = ITK_NULLPTR; oSRS.exportToWkt(&utmRef); // Build Lambert II ref double stdParallel1 = 45.89891944; double stdParallel2 = 47.69601389; double originLatL2 = 46.8; double originLongL2 = 2.33722778; double falseEastingL2 = 600000; double falseNorthingL2 = 2200000; oSRS.SetProjCS("Lambert II "); oSRS.SetLCC(stdParallel1, stdParallel2, originLatL2, originLongL2, falseEastingL2, falseNorthingL2); char * lambertRef = ITK_NULLPTR; oSRS.exportToWkt(&lambertRef); // Build the Transmercator ref double originLatTmt = 49.83; double originLongTmt = 6.16; oSRS.SetProjCS("Transmercator "); oSRS.SetWellKnownGeogCS("WGS84"); oSRS.SetTM(originLatTmt, originLongTmt, 1, 0, 0); char * tmtRef = ITK_NULLPTR; oSRS.exportToWkt(&tmtRef); TransformType::Pointer wgs2utm = TransformType::New(); wgs2utm->SetInputProjectionRef(wgsRef); wgs2utm->SetOutputProjectionRef(utmRef); wgs2utm->InstantiateTransform(); TransformType::Pointer utm2wgs = TransformType::New(); wgs2utm->GetInverse(utm2wgs); TransformType::Pointer wgs2lambert = TransformType::New(); wgs2lambert->SetInputProjectionRef(wgsRef); wgs2lambert->SetOutputProjectionRef(lambertRef); wgs2lambert->InstantiateTransform(); TransformType::Pointer lambert2wgs = TransformType::New(); wgs2lambert->GetInverse(lambert2wgs); TransformType::Pointer wgs2tmt = TransformType::New(); wgs2tmt->SetInputProjectionRef(wgsRef); wgs2tmt->SetOutputProjectionRef(tmtRef); wgs2tmt->InstantiateTransform(); TransformType::Pointer tmt2wgs = TransformType::New(); wgs2tmt->GetInverse(tmt2wgs); TransformType::Pointer wgs2wgs = TransformType::New(); wgs2wgs->SetInputProjectionRef(wgsRef); wgs2wgs->SetOutputProjectionRef(wgsRef); wgs2wgs->InstantiateTransform(); TransformType::Pointer utm2utm = TransformType::New(); utm2utm->SetInputProjectionRef(utmRef); utm2utm->SetOutputProjectionRef(utmRef); utm2utm->InstantiateTransform(); TransformType::Pointer lambert2lambert = TransformType::New(); lambert2lambert->SetInputProjectionRef(lambertRef); lambert2lambert->SetOutputProjectionRef(lambertRef); lambert2lambert->InstantiateTransform(); TransformType::Pointer tmt2tmt = TransformType::New(); tmt2tmt->SetInputProjectionRef(tmtRef); tmt2tmt->SetOutputProjectionRef(tmtRef); tmt2tmt->InstantiateTransform(); TransformType::Pointer utm2lambert = TransformType::New(); utm2lambert->SetInputProjectionRef(utmRef); utm2lambert->SetOutputProjectionRef(lambertRef); utm2lambert->InstantiateTransform(); TransformType::Pointer lambert2utm = TransformType::New(); utm2lambert->GetInverse(lambert2utm); TransformType::Pointer utm2tmt = TransformType::New(); utm2tmt->SetInputProjectionRef(utmRef); utm2tmt->SetOutputProjectionRef(tmtRef); utm2tmt->InstantiateTransform(); TransformType::Pointer tmt2utm = TransformType::New(); utm2tmt->GetInverse(tmt2utm); TransformType::Pointer lambert2tmt = TransformType::New(); lambert2tmt->SetInputProjectionRef(lambertRef); lambert2tmt->SetOutputProjectionRef(tmtRef); lambert2tmt->InstantiateTransform(); TransformType::Pointer tmt2lambert = TransformType::New(); lambert2tmt->GetInverse(tmt2lambert); std::ofstream ofs; ofs.open(outfname); // Set floatfield to format writing properly ofs.setf(std::ios::fixed, std::ios::floatfield); ofs.precision(10); ofs << "Testing geopoint: " << geoPoint << std::endl << std::endl; ofs << "Testing wgs84 to wgs84: " << geoPoint << " -> " << wgs2wgs->TransformPoint(geoPoint) << std::endl; PointType utmPoint, lambertPoint, tmtPoint; utmPoint = wgs2utm->TransformPoint(geoPoint); lambertPoint = wgs2lambert->TransformPoint(geoPoint); tmtPoint = wgs2tmt->TransformPoint(geoPoint); ofs.precision(3); ofs << "Testing utm 31 north to utm 31 north: " << utmPoint << " -> " << utm2utm->TransformPoint(utmPoint) << std::endl; ofs << "Testing lambert 2 to lambert 2: " << lambertPoint << " -> " << lambert2lambert->TransformPoint(lambertPoint) << std::endl; ofs << "Testing transmercator 31 north to transmercator: " << tmtPoint << " -> " << tmt2tmt->TransformPoint(tmtPoint) << std::endl; ofs << std::endl << "Testing geo 2 carto ..." << std::endl << std::endl; ofs.precision(10); ofs << "Testing wgs84 to utm 31 north: " << geoPoint; ofs.precision(3); ofs << " -> " << utmPoint << std::endl; ofs << "Testing utm 31 north to wgs84: " << utmPoint; ofs.precision(10); ofs << " -> " << utm2wgs->TransformPoint(utmPoint) << std::endl; ofs << "Testing wgs84 to lambert 2: " << geoPoint; ofs.precision(3); ofs << " -> " << lambertPoint << std::endl; ofs << "Testing lambert 2 to wgs84: " << lambertPoint; ofs.precision(10); ofs << " -> " << lambert2wgs->TransformPoint(lambertPoint) << std::endl; ofs << "Testing wgs84 to transmeractor: " << geoPoint; ofs.precision(3); ofs << " -> " << tmtPoint << std::endl; ofs << "Testing transmercator to wgs84: " << tmtPoint; ofs.precision(10); ofs << " -> " << tmt2wgs->TransformPoint(tmtPoint) << std::endl; ofs << std::endl << "Testing cross geo ..." << std::endl << std::endl; ofs.precision(3); ofs << "Testing lambert 2 to utm 31 north: " << lambertPoint << " -> " << lambert2utm->TransformPoint(lambertPoint) << std::endl; ofs << "Testing utm 31 north to lambert 2: " << utmPoint << " -> " << utm2lambert->TransformPoint(utmPoint) << std::endl; ofs << "Testing lambert 2 to transmercator: " << lambertPoint << " -> " << lambert2tmt->TransformPoint(lambertPoint) << std::endl; ofs << "Testing transmercator to lambert 2: " << tmtPoint << " -> " << tmt2lambert->TransformPoint(tmtPoint) << std::endl; ofs << "Testing transmercator to utm 31 north: " << tmtPoint << " -> " << tmt2utm->TransformPoint(tmtPoint) << std::endl; ofs << "Testing utm 31 north to transmercator: " << utmPoint << " -> " << utm2tmt->TransformPoint(utmPoint) << std::endl; ofs.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbGenericRSTransformNew.cxx000066400000000000000000000015621301006202600262740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbGenericRSTransform.h" int otbGenericRSTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::GenericRSTransform<> TransformType; TransformType::Pointer transform = TransformType::New(); std::cout << transform << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbGenericRSTransformWithSRID.cxx000066400000000000000000000161501301006202600271370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbGenericRSTransform.h" #include /** * This test is the same than the otbGenericRSTransform * except using the SRID to build the wkt. */ int otbGenericRSTransformWithSRID(int itkNotUsed(argc), char* argv[]) { OGRSpatialReference oSRS; typedef otb::GenericRSTransform<> TransformType; typedef TransformType::InputPointType PointType; PointType geoPoint; geoPoint[0] = atof(argv[1]); geoPoint[1] = atof(argv[2]); const char * outfname = argv[3]; // Build Lambert II ref double stdParallel1 = 45.89891944; double stdParallel2 = 47.69601389; double originLatL2 = 46.8; double originLongL2 = 2.33722778; double falseEastingL2 = 600000; double falseNorthingL2 = 2200000; oSRS.SetProjCS("Lambert II "); oSRS.SetLCC(stdParallel1, stdParallel2, originLatL2, originLongL2, falseEastingL2, falseNorthingL2); char * lambertRef = ITK_NULLPTR; oSRS.exportToWkt(&lambertRef); // Build the Transmercator ref double originLatTmt = 49.83; double originLongTmt = 6.16; oSRS.SetProjCS("Transmercator "); oSRS.SetWellKnownGeogCS("WGS84"); oSRS.SetTM(originLatTmt, originLongTmt, 1, 0, 0); char * tmtRef = ITK_NULLPTR; oSRS.exportToWkt(&tmtRef); TransformType::Pointer wgs2utm = TransformType::New(); wgs2utm->SetInputProjectionRef("4326"); // WGS 84 wgs2utm->SetOutputProjectionRef("32631"); // UTM 31 N wgs2utm->InstantiateTransform(); TransformType::Pointer utm2wgs = TransformType::New(); wgs2utm->GetInverse(utm2wgs); TransformType::Pointer wgs2lambert = TransformType::New(); wgs2lambert->SetInputProjectionRef("4326"); // WGS 84 wgs2lambert->SetOutputProjectionRef(lambertRef); wgs2lambert->InstantiateTransform(); TransformType::Pointer lambert2wgs = TransformType::New(); wgs2lambert->GetInverse(lambert2wgs); TransformType::Pointer wgs2tmt = TransformType::New(); wgs2tmt->SetInputProjectionRef("4326"); // WGS 84 wgs2tmt->SetOutputProjectionRef(tmtRef); wgs2tmt->InstantiateTransform(); TransformType::Pointer tmt2wgs = TransformType::New(); wgs2tmt->GetInverse(tmt2wgs); TransformType::Pointer wgs2wgs = TransformType::New(); wgs2wgs->SetInputProjectionRef("4326"); // WGS 84 wgs2wgs->SetOutputProjectionRef("4326"); // WGS 84 wgs2wgs->InstantiateTransform(); TransformType::Pointer utm2utm = TransformType::New(); utm2utm->SetInputProjectionRef("32631"); // UTM 31 N utm2utm->SetOutputProjectionRef("32631"); // UTM 31 N utm2utm->InstantiateTransform(); TransformType::Pointer lambert2lambert = TransformType::New(); lambert2lambert->SetInputProjectionRef(lambertRef); lambert2lambert->SetOutputProjectionRef(lambertRef); lambert2lambert->InstantiateTransform(); TransformType::Pointer tmt2tmt = TransformType::New(); tmt2tmt->SetInputProjectionRef(tmtRef); tmt2tmt->SetOutputProjectionRef(tmtRef); tmt2tmt->InstantiateTransform(); TransformType::Pointer utm2lambert = TransformType::New(); utm2lambert->SetInputProjectionRef("32631"); // UTM utm2lambert->SetOutputProjectionRef(lambertRef); utm2lambert->InstantiateTransform(); TransformType::Pointer lambert2utm = TransformType::New(); utm2lambert->GetInverse(lambert2utm); TransformType::Pointer utm2tmt = TransformType::New(); utm2tmt->SetInputProjectionRef("32631"); utm2tmt->SetOutputProjectionRef(tmtRef); utm2tmt->InstantiateTransform(); TransformType::Pointer tmt2utm = TransformType::New(); utm2tmt->GetInverse(tmt2utm); TransformType::Pointer lambert2tmt = TransformType::New(); lambert2tmt->SetInputProjectionRef(lambertRef); lambert2tmt->SetOutputProjectionRef(tmtRef); lambert2tmt->InstantiateTransform(); TransformType::Pointer tmt2lambert = TransformType::New(); lambert2tmt->GetInverse(tmt2lambert); std::ofstream ofs; ofs.open(outfname); // Set floatfield to format writing properly ofs.setf(std::ios::fixed, std::ios::floatfield); ofs.precision(10); ofs << "Testing geopoint: " << geoPoint << std::endl << std::endl; ofs << "Testing wgs84 to wgs84: " << geoPoint << " -> " << wgs2wgs->TransformPoint(geoPoint) << std::endl; PointType utmPoint, lambertPoint, tmtPoint; utmPoint = wgs2utm->TransformPoint(geoPoint); lambertPoint = wgs2lambert->TransformPoint(geoPoint); tmtPoint = wgs2tmt->TransformPoint(geoPoint); ofs.precision(3); ofs << "Testing utm 31 north to utm 31 north: " << utmPoint << " -> " << utm2utm->TransformPoint(utmPoint) << std::endl; ofs << "Testing lambert 2 to lambert 2: " << lambertPoint << " -> " << lambert2lambert->TransformPoint(lambertPoint) << std::endl; ofs << "Testing transmercator 31 north to transmercator: " << tmtPoint << " -> " << tmt2tmt->TransformPoint(tmtPoint) << std::endl; ofs << std::endl << "Testing geo 2 carto ..." << std::endl << std::endl; ofs.precision(10); ofs << "Testing wgs84 to utm 31 north: " << geoPoint; ofs.precision(3); ofs << " -> " << utmPoint << std::endl; ofs << "Testing utm 31 north to wgs84: " << utmPoint; ofs.precision(10); ofs << " -> " << utm2wgs->TransformPoint(utmPoint) << std::endl; ofs << "Testing wgs84 to lambert 2: " << geoPoint; ofs.precision(3); ofs << " -> " << lambertPoint << std::endl; ofs << "Testing lambert 2 to wgs84: " << lambertPoint; ofs.precision(10); ofs << " -> " << lambert2wgs->TransformPoint(lambertPoint) << std::endl; ofs << "Testing wgs84 to transmeractor: " << geoPoint; ofs.precision(3); ofs << " -> " << tmtPoint << std::endl; ofs << "Testing transmercator to wgs84: " << tmtPoint; ofs.precision(10); ofs << " -> " << tmt2wgs->TransformPoint(tmtPoint) << std::endl; ofs << std::endl << "Testing cross geo ..." << std::endl << std::endl; ofs.precision(3); ofs << "Testing lambert 2 to utm 31 north: " << lambertPoint << " -> " << lambert2utm->TransformPoint(lambertPoint) << std::endl; ofs << "Testing utm 31 north to lambert 2: " << utmPoint << " -> " << utm2lambert->TransformPoint(utmPoint) << std::endl; ofs << "Testing lambert 2 to transmercator: " << lambertPoint << " -> " << lambert2tmt->TransformPoint(lambertPoint) << std::endl; ofs << "Testing transmercator to lambert 2: " << tmtPoint << " -> " << tmt2lambert->TransformPoint(tmtPoint) << std::endl; ofs << "Testing transmercator to utm 31 north: " << tmtPoint << " -> " << tmt2utm->TransformPoint(tmtPoint) << std::endl; ofs << "Testing utm 31 north to transmercator: " << utmPoint << " -> " << utm2tmt->TransformPoint(utmPoint) << std::endl; ofs.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbGeocentricTransform.cxx000066400000000000000000000037001301006202600260570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" #include "otbImage.h" #include "otbGeocentricTransform.h" int otbGeocentricTransform(int itkNotUsed(argc), char* argv[]) { const char * outFileName = argv[1]; std::ofstream file; file.open(outFileName); typedef otb::GeocentricTransform ProjectionType; ProjectionType::Pointer projection = ProjectionType::New(); file << std::setprecision(15); file << "Forward projection: " << std::endl; itk::Point point; point[0] = 0; //lon point[1] = 0; //lat point[2] = 0; //elev file << point << " -> "; file << projection->TransformPoint(point); file << std::endl << std::endl; // itk::Point point; point[0] = 1.4835345f; //lon point[1] = 43.559682611111107f; //lat point[2] = 192.15; //elev file << point << " -> "; file << projection->TransformPoint(point); file << std::endl << std::endl; typedef otb::GeocentricTransform InverseProjectionType; InverseProjectionType::Pointer inverseProjection = InverseProjectionType::New(); file << "Inverse projection: " << std::endl; point[0] = 3771793.97; //X point[1] = 140253.34; //Y point[2] = 5124421.30; //Z file << point << " -> "; file << inverseProjection->TransformPoint(point); file << std::endl << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbGeocentricTransformNew.cxx000066400000000000000000000016611301006202600265350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbImage.h" #include "otbGeocentricTransform.h" int otbGeocentricTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::GeocentricTransform ProjectionType; ProjectionType::Pointer projection = ProjectionType::New(); std::cout << projection << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbInverseLogPolarTransform.cxx000066400000000000000000000055101301006202600270510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbInverseLogPolarTransform.h" #include "otbMacro.h" #include #include #include "otbMath.h" int otbInverseLogPolarTransform(int itkNotUsed(argc), char* argv[]) { double radialStep = atof(argv[1]); double angularStep = atof(argv[2]); const char * outputFilename(argv[3]); unsigned int nbPoints = atoi(argv[4]); typedef double PrecisionType; typedef otb::InverseLogPolarTransform InverseLogPolarTransformType; typedef itk::Point PointType; typedef std::vector PointsVectorType; std::ofstream file; file.open(outputFilename); file << "input points retrieval : " << std::endl; // input points retrieval PointsVectorType vect; for (unsigned int i = 0; i < nbPoints; ++i) { PointType p; p[0] = atof(argv[5 + 2 * i]); p[1] = atof(argv[6 + 2 * i]); file << "Adding point " << p << "." << std::endl; vect.push_back(p); } // Instantiation InverseLogPolarTransformType::Pointer transform = InverseLogPolarTransformType::New(); InverseLogPolarTransformType::ParametersType params(4); params[0] = 0.; params[1] = 0.; params[2] = radialStep; params[3] = angularStep; transform->SetParameters(params); file << "Transform calculation ... :" << std::endl; for (PointsVectorType::iterator it = vect.begin(); it != vect.end(); ++it) { PointType p = transform->TransformPoint(*it); PointType pprime; double rho = vcl_sqrt((*it)[0] * (*it)[0] + (*it)[1] * (*it)[1]); if (rho > 0) { pprime[0] = (1. / angularStep) * vcl_asin((*it)[1] / rho); pprime[0] = pprime[0] * (180. / otb::CONST_PI); // Deplacing the range to [0, 90], [270, 360] pprime[0] = pprime[0] > 0. ? pprime[0] : pprime[0] + 360.; // Avoiding asin indetermination if (p[0] >= 0) { pprime[0] = pprime[0] < 90. ? pprime[0] + 90. : pprime[0] - 90.; } pprime[1] = (1. / radialStep) * vcl_log(rho); } else { pprime[0] = 400.; pprime[1] = 0.; } file << "Original Point: " << (*it) << ", Reference point: " << pprime << ", Transformed point: " << p << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbInverseLogPolarTransformNew.cxx000066400000000000000000000020131301006202600275160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbInverseLogPolarTransform.h" #include int otbInverseLogPolarTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PrecisionType; typedef otb::InverseLogPolarTransform InverseLogPolarTransformType; // Instantiation InverseLogPolarTransformType::Pointer transform = InverseLogPolarTransformType::New(); std::cout << transform << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbInverseLogPolarTransformResample.cxx000066400000000000000000000064501301006202600305460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbInverseLogPolarTransform.h" #include "otbImage.h" #include "itkResampleImageFilter.h" #include "itkPoint.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbInverseLogPolarTransformResample(int itkNotUsed(argc), char* argv[]) { char * inputFileName = argv[1]; char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PrecisionType; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::InverseLogPolarTransform InverseLogPolarTransformType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::ResampleImageFilter ResampleFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); reader->UpdateOutputInformation(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); interpolator->SetInputImage(reader->GetOutput()); std::cout << interpolator << std::endl; InverseLogPolarTransformType::Pointer transform = InverseLogPolarTransformType::New(); ImageType::SizeType size; size[0] = 720; size[1] = 540; InverseLogPolarTransformType::ParametersType params(4); // Center the transform params[0] = 0.5 * static_cast(size[0]); params[1] = 0.5 * static_cast(size[1]); params[2] = 360. / reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]; params[3] = vcl_log(vcl_sqrt(vcl_pow(static_cast(size[0]), 2.) + vcl_pow(static_cast(size[1]), 2.)) / 2) / reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]; transform->SetParameters(params); // ImageType::SpacingType spacing; // spacing.Fill(1.0); ResampleFilterType::Pointer resampler = ResampleFilterType::New(); resampler->SetInput(reader->GetOutput()); resampler->SetTransform(transform); resampler->SetInterpolator(interpolator); resampler->SetDefaultPixelValue(0); resampler->SetSize(size); ImageType::PointType origin; origin[0] = 0.5; origin[1] = 0.5; resampler->SetOutputOrigin(origin); ImageType::SpacingType spacing; spacing[0] = 1.0; spacing[1] = 1.0; resampler->SetOutputSpacing(spacing); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(resampler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbLogPolarTransform.cxx000066400000000000000000000047321301006202600255220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLogPolarTransform.h" #include "itkPoint.h" #include "otbMacro.h" #include "otbMath.h" #include #include int otbLogPolarTransform(int itkNotUsed(argc), char* argv[]) { double radialStep = atof(argv[1]); double angularStep = atof(argv[2]); const char * outputFilename(argv[3]); unsigned int nbPoints = atoi(argv[4]); typedef double PrecisionType; typedef otb::LogPolarTransform LogPolarTransformType; typedef itk::Point PointType; typedef std::vector PointsVectorType; std::ofstream file; file.open(outputFilename); file << "input points retrieval : " << std::endl; // input points retrieval PointsVectorType vect; for (unsigned int i = 0; i < nbPoints; ++i) { PointType p; p[0] = atof(argv[5 + 2 * i]); p[1] = atof(argv[6 + 2 * i]); file << "Adding point " << p << "." << std::endl; vect.push_back(p); } // Instantiation LogPolarTransformType::Pointer transform = LogPolarTransformType::New(); LogPolarTransformType::ParametersType params(4); params[0] = 0.; params[1] = 0.; params[2] = radialStep; params[3] = angularStep; transform->SetParameters(params); file << "Transform calculation ... :" << std::endl; for (PointsVectorType::iterator it = vect.begin(); it != vect.end(); ++it) { PointType p = transform->TransformPoint(*it); PointType pprime; double theta = (*it)[0] * angularStep * otb::CONST_PI / 180.0; double logRho = (*it)[1] * radialStep; file << "Rho: " << logRho << ", Theta: " << theta << std::endl; pprime[0] = vcl_exp(logRho) * vcl_cos(theta); pprime[1] = vcl_exp(logRho) * vcl_sin(theta); file << "Original Point: " << (*it) << ", Reference point: " << pprime << ", Transformed point: " << p << std::endl << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbLogPolarTransformNew.cxx000066400000000000000000000017321301006202600261710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLogPolarTransform.h" #include int otbLogPolarTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PrecisionType; typedef otb::LogPolarTransform LogPolarTransformType; // Instantiation LogPolarTransformType::Pointer transform = LogPolarTransformType::New(); std::cout << transform << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbLogPolarTransformResample.cxx000066400000000000000000000064731301006202600272170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLogPolarTransform.h" #include "otbImage.h" #include "itkResampleImageFilter.h" #include "itkPoint.h" #include "otbMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbLogPolarTransformResample(int itkNotUsed(argc), char* argv[]) { char * inputFileName = argv[1]; char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PrecisionType; typedef double PixelType; typedef otb::Image ImageType; typedef otb::LogPolarTransform LogPolarTransformType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::ResampleImageFilter ResampleFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); reader->UpdateOutputInformation(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); interpolator->SetInputImage(reader->GetOutput()); std::cout << interpolator << std::endl; LogPolarTransformType::Pointer transform = LogPolarTransformType::New(); LogPolarTransformType::ParametersType params(4); // Center the transform params[0] = 0.5 * static_cast(reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]); params[1] = 0.5 * static_cast(reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]); params[2] = 360. / 1024; params[3] = vcl_log(vcl_sqrt(vcl_pow(static_cast(reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]), 2) + vcl_pow(static_cast(reader->GetOutput()->GetLargestPossibleRegion().GetSize()[ 1]), 2)) / 2) / 512; transform->SetParameters(params); ImageType::SizeType size; size[0] = 1024; size[1] = 512; ResampleFilterType::Pointer resampler = ResampleFilterType::New(); resampler->SetInput(reader->GetOutput()); resampler->SetTransform(transform); resampler->SetInterpolator(interpolator); resampler->SetDefaultPixelValue(0); resampler->SetSize(size); ImageType::PointType origin; origin[0] = 0.5; origin[1] = 0.5; resampler->SetOutputOrigin(origin); ImageType::SpacingType spacing; spacing[0] = 1.0; spacing[1] = 1.0; resampler->SetOutputSpacing(spacing); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(resampler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbSensorModelsNew.cxx000066400000000000000000000025111301006202600251670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbForwardSensorModel.h" #include "otbInverseSensorModel.h" int otbSensorModelsNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::SensorModelBase SensorModelBaseType; SensorModelBaseType::Pointer lSensorModelBase = SensorModelBaseType::New(); std::cout << lSensorModelBase << std::endl; typedef otb::InverseSensorModel InverseSensorModelType; InverseSensorModelType::Pointer lInverseSensorModel = InverseSensorModelType::New(); std::cout << lInverseSensorModel << std::endl; typedef otb::ForwardSensorModel ForwardSensorModelType; ForwardSensorModelType::Pointer lForwardSensorModel = ForwardSensorModelType::New(); std::cout << lForwardSensorModel << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbStreamingResampleImageFilterWithAffineTransform.cxx000066400000000000000000000066501301006202600335040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingResampleImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" // Transform #include "itkTransform.h" #include "itkAffineTransform.h" int otbStreamingResampleImageFilterWithAffineTransform(int argc, char* argv[]) { // Images definition const unsigned int Dimension = 2; typedef double InternalPixelType; typedef otb::VectorImage ImageType; typedef otb::StreamingResampleImageFilter ImageResamplerType; // Instantiate a Resampler ImageResamplerType::Pointer resampler = ImageResamplerType::New(); if (argc== 4) { const char * infname = argv[1]; const char * outfname = argv[3]; unsigned int isize = atoi(argv[2]); typedef itk::AffineTransform< InternalPixelType, Dimension> AffineTransformType; typedef otb::ImageFileReader ReaderType; // Instantiate an affine transformation Pointer AffineTransformType::Pointer affineTransform = AffineTransformType::New(); // Instantiate reader ReaderType::Pointer reader = ReaderType::New(); // Get the image file reader->SetFileName(infname); reader->UpdateOutputInformation(); /** Set the options. */ ImageResamplerType::OriginType centerOfRotation; centerOfRotation[ 0 ] = -3.0; centerOfRotation[ 1 ] = -3.0; affineTransform->SetCenter( centerOfRotation ); /** Create and set parameters. */ AffineTransformType::ParametersType parameters( affineTransform->GetNumberOfParameters() ); parameters[ 0 ] = 1.1; parameters[ 1 ] = 0.1; parameters[ 2 ] = -0.2; parameters[ 3 ] = 0.9; parameters[ 4 ] = 10.3; parameters[ 5 ] = -33.8; affineTransform->SetParameters( parameters ); // Get the size specified by the user ImageType::SizeType size; size.Fill(isize); // Default value builder ImageType::PixelType defaultValue; itk::NumericTraits::SetLength(defaultValue, reader->GetOutput()->GetNumberOfComponentsPerPixel()); /** Set the OptResampler Parameters*/ resampler->SetInput(reader->GetOutput()); resampler->SetOutputParametersFromImage(reader->GetOutput()); resampler->SetTransform(affineTransform); resampler->SetDisplacementFieldSpacing(5.); resampler->SetOutputSize(size); resampler->SetEdgePaddingValue(defaultValue); // Write the resampled image typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer= WriterType::New(); writer->SetNumberOfDivisionsTiledStreaming(4); writer->SetFileName(outfname); writer->SetInput(resampler->GetOutput()); writer->Update(); } else { std::cout <<" Unit Test"<< std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbStreamingWarpImageFilter.cxx000066400000000000000000000047651301006202600270110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkVector.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStreamingWarpImageFilter.h" int otbStreamingWarpImageFilter(int argc, char* argv[]) { if (argc != 5) { std::cout << "usage: " << argv[0] << "infname deffname outfname radius" << std::endl; return EXIT_SUCCESS; } // Input parameters const char * infname = argv[1]; const char * deffname = argv[2]; const char * outfname = argv[3]; const double maxdef = atoi(argv[4]); // Images definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef itk::Vector DisplacementValueType; typedef otb::Image DisplacementFieldType; // Warper typedef otb::StreamingWarpImageFilter ImageWarperType; // Reader/Writer typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader DisplacementReaderType; typedef otb::ImageFileWriter WriterType; // Objects creation DisplacementReaderType::Pointer displacementReader = DisplacementReaderType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ImageWarperType::Pointer warper = ImageWarperType::New(); // Reading reader->SetFileName(infname); displacementReader->SetFileName(deffname); // Warping DisplacementValueType maxDisplacement; maxDisplacement.Fill(maxdef); warper->SetMaximumDisplacement(maxDisplacement); warper->SetInput(reader->GetOutput()); warper->SetDisplacementField(displacementReader->GetOutput()); // Writing writer->SetInput(warper->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbStreamingWarpImageFilterNew.cxx000066400000000000000000000024301301006202600274460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkVector.h" #include "otbStreamingWarpImageFilter.h" int otbStreamingWarpImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Images definition const unsigned int Dimension = 2; typedef double PixelType; typedef itk::Vector DisplacementValueType; typedef otb::Image ImageType; typedef otb::Image DisplacementFieldType; // Warper typedef otb::StreamingWarpImageFilter ImageWarperType; // Objects creation ImageWarperType::Pointer warper = ImageWarperType::New(); std::cout << warper << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/Transform/test/otbTransformTestDriver.cxx000066400000000000000000000017201301006202600260700ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbGenericRSTransformWithSRID); REGISTER_TEST(otbCreateInverseForwardSensorModel); REGISTER_TEST(otbGenericRSTransform); REGISTER_TEST(otbCreateProjectionWithOSSIM); REGISTER_TEST(otbLogPolarTransformResample); REGISTER_TEST(otbStreamingWarpImageFilterNew); REGISTER_TEST(otbLogPolarTransform); REGISTER_TEST(otbGenericRSTransformNew); REGISTER_TEST(otbLogPolarTransformNew); REGISTER_TEST(otbGeocentricTransform); REGISTER_TEST(otbCreateProjectionWithOTB); REGISTER_TEST(otbGeocentricTransformNew); REGISTER_TEST(otbGenericMapProjection); REGISTER_TEST(otbStreamingWarpImageFilter); REGISTER_TEST(otbSensorModelsNew); REGISTER_TEST(otbGenericMapProjectionNew); REGISTER_TEST(otbInverseLogPolarTransform); REGISTER_TEST(otbInverseLogPolarTransformNew); REGISTER_TEST(otbInverseLogPolarTransformResample); REGISTER_TEST(otbStreamingResampleImageFilterWithAffineTransform); } OTB-release-5.8/Modules/Core/VectorDataBase/000077500000000000000000000000001301006202600205455ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/VectorDataBase/CMakeLists.txt000066400000000000000000000001411301006202600233010ustar00rootroot00000000000000project(OTBVectorDataBase) set(OTBVectorDataBase_LIBRARIES OTBVectorDataBase) otb_module_impl() OTB-release-5.8/Modules/Core/VectorDataBase/include/000077500000000000000000000000001301006202600221705ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/VectorDataBase/include/otbDataNode.h000066400000000000000000000230671301006202600245350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataNode_h #define otbDataNode_h #include "itkPoint.h" #include "otbPolygon.h" #include "otbObjectList.h" #include "otbVectorDataKeywordlist.h" #include #include "ogrsf_frmts.h" namespace otb { /** * This enumeration describes the type of nodes used to represent a tree of vector data in the Orfeo ToolBox. */ typedef enum { ROOT = 0, DOCUMENT = 1, FOLDER = 2, FEATURE_POINT = 3, FEATURE_LINE = 4, FEATURE_POLYGON = 5, FEATURE_MULTIPOINT = 6, FEATURE_MULTILINE = 7, FEATURE_MULTIPOLYGON = 8, FEATURE_COLLECTION = 9 } NodeType; /** \class DataNode * \brief This class represents a node of data in a vector data hierarchy. * * A DataNode has a type represented by the NodeType enumeration. Depending on * its type, it can have associated data such as Point, Line or Polygon. * * A flag indicates if the data are valid or not. * * A DataNode has also a dictionary of fields which can be used to store associated data. * Depending on the writing vector data file format, fields will be used by the writing driver. * * The three templates indicate * - the precision of the point coordinates (default double) * - the number of dimensions of the space (default 2) * - the precision of the value associated with objects such as lines or polygons (default double) * * \sa VectorData * * \ingroup OTBVectorDataBase */ template class DataNode : public itk::Object { public: /** Standard class typedef */ typedef DataNode Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(DataNode, Object); /** Template parameters typedefs */ typedef TPrecision PrecisionType; typedef TValuePrecision ValuePrecisionType; itkStaticConstMacro(Dimension, unsigned int, VDimension); /** Internal data typedef */ typedef itk::Point PointType; typedef otb::PolyLineParametricPathWithValue LineType; typedef typename LineType::Pointer LinePointerType; typedef typename LineType::ConstPointer LineConstPointerType; typedef Polygon PolygonType; typedef typename PolygonType::VertexListType VertexListType; typedef typename VertexListType::ConstPointer VertexListConstPointerType; typedef typename PolygonType::Pointer PolygonPointerType; typedef typename PolygonType::ConstPointer PolygonConstPointerType; typedef ObjectList PolygonListType; typedef typename PolygonListType::Pointer PolygonListPointerType; typedef typename PolygonListType::ConstPointer PolygonListConstPointerType; /** Fields typedef */ // typedef std::map FieldMapType; // typedef std::pair FieldType; /** Accessors */ itkGetConstMacro(NodeType, NodeType); itkGetStringMacro(NodeId); itkSetStringMacro(NodeId); /** * Set the node type. * \param type node type. */ void SetNodeType(NodeType type); /** * \return the node type as a printable string. */ std::string GetNodeTypeAsString() const; /** * Get the point data, when valid. * \return The point. */ PointType GetPoint() const; /** * Get the line data, when valid. * \return The line. */ LinePointerType GetLine() const; /** * Get the polygon exterior ring data, when valid. * \return The polygon exterior ring. */ PolygonPointerType GetPolygonExteriorRing() const; /** * Get the polygon interior rings data, when valid. * \return The polygon interior rings list. */ PolygonListPointerType GetPolygonInteriorRings() const; /** * Set the point data. Node type is automatically set to FEATURE_POINT. * \param point the point. */ void SetPoint(PointType point); /** * Set the line data. Node type is automatically set to FEATURE_LINE. * \param line The line. */ void SetLine(LineType* line); /** * Set the polygon exterior ring. Node type is automatically set to FEATURE_POLYGON. * \param polygon The polygon exterior ring. */ void SetPolygonExteriorRing(PolygonType* polygon); /** * Set the polygon interior rings. Node type is automatically set to FEATURE_POLYGON. * \param polygonList The polygon interior rings list. */ void SetPolygonInteriorRings(PolygonListType* polygonList); /** * \return True if node type is DOCUMENT. */ bool IsDocument() const; /** * \return True if node type is ROOT. */ bool IsRoot() const; /** * \return True if node type is FOLDER. */ bool IsFolder() const; /** * \return True if node type is FEATURE_POINT. */ bool IsPointFeature() const; /** * \return True if node type is FEATURE_LINE. */ bool IsLineFeature() const; /** * \return True if node type is FEATURE_POLYGON. */ bool IsPolygonFeature() const; /** * \return True if node type is FEATURE_MULTIPOINT. */ bool IsMultiPointFeature() const; /** * \return True if node type is FEATURE_MULTILINE. */ bool IsMultiLineFeature() const; /** * \return True if node type is FEATURE_MULTIPOLYGON. */ bool IsMultiPolygonFeature() const; /** * \return True if node type is FEATURE_COLLECTION. */ bool IsCollectionFeature() const; /** * Add a field to the node. * \param key The name of the field. * \param value The value of the field. */ void SetFieldAsString(const std::string& key, const std::string& value); /** * Returns the value associated with a field name. * \param key The name of the field. * \return The value of the field. A default value is returned if the key was not found. */ std::string GetFieldAsString(const std::string& key) const; /** * Add a field to the node. * \param key The name of the field. * \param value The value of the field. */ void SetFieldAsInt(const std::string& key, int value); /** * Returns the value associated with a field name. * \param key The name of the field. * \return The value of the field. A default value is returned if the key was not found. */ int GetFieldAsInt(const std::string& key) const; /** * Add a field to the node. * \param key The name of the field. * \param value The value of the field. */ void SetFieldAsDouble(const std::string& key, double value); /** * Returns the value associated with a field name. * \param key The name of the field. * \return The value of the field. A default value is returned if the key was not found. */ double GetFieldAsDouble(const std::string& key) const; // /** // * Remove the field associated with the given key, if possible. // * \param key The name of the field. // */ // void RemoveField(const std::string& key); /** * \return True if the node contains the field named after the given key. * \param key The name of the field. */ bool HasField(const std::string& key) const; /** * Copy the field list from a DataNode * \param dataNode datanode where to get the keywordlist to copy. */ void CopyFieldList(const DataNode * dataNode); /** * \return the field list in the node. */ std::vector GetFieldList() const; /** \return the distance to a point */ double EuclideanDistanceMetric(const DataNode* node); double EuclideanDistanceMetric(const PointType point); /** * \return true if the two datanodes intersects */ bool Intersects(const DataNode* node); /** * \return true if the two datanodes intersects */ bool Within(const DataNode* node); /** * Clear all fields. */ // void ClearFields(); protected: /** Constructor */ DataNode(); /** Destructor */ ~DataNode() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; OGRGeometry* ConvertDataNodeToOGRGeometry(const DataNode* dataNode); private: DataNode(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** typedef of the data associated with the node */ typedef struct { bool valid; PointType point; LinePointerType line; PolygonPointerType exteriorRing; PolygonListPointerType interiorRings; } DataType; /** The node type */ NodeType m_NodeType; /** The node id */ std::string m_NodeId; /** The data associated with the node */ DataType m_Data; /** The fields map */ // FieldMapType m_FieldMap; }; } // end namespace #ifndef OTB_MANUAL_INSTANTIATION #include "otbDataNode.txx" #endif #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbDataNode.txx000066400000000000000000000462061301006202600251310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataNode_txx #define otbDataNode_txx #include "otbDataNode.h" #include "otbMetaDataKey.h" namespace otb { template DataNode ::DataNode() { m_NodeType = ROOT; m_NodeId = ""; m_Data.valid = false; } template void DataNode ::SetNodeType(NodeType type) { m_NodeType = type; m_Data.valid = false; } template void DataNode ::SetPoint(PointType point) { m_NodeType = FEATURE_POINT; m_Data.point = point; m_Data.valid = true; } template void DataNode ::SetLine(LineType* line) { m_NodeType = FEATURE_LINE; m_Data.line = line; m_Data.valid = true; } template void DataNode ::SetPolygonExteriorRing(PolygonType* polygon) { m_NodeType = FEATURE_POLYGON; m_Data.exteriorRing = polygon; if (!m_Data.interiorRings) { m_Data.interiorRings = PolygonListType::New(); } m_Data.valid = true; } template void DataNode ::SetPolygonInteriorRings(PolygonListType* polygonList) { m_NodeType = FEATURE_POLYGON; m_Data.interiorRings = polygonList; if (!m_Data.exteriorRing) { m_Data.exteriorRing = PolygonType::New(); } m_Data.valid = true; } template typename DataNode ::PointType DataNode ::GetPoint() const { if (!IsPointFeature()) { itkGenericExceptionMacro(<< "Node " << m_NodeId << " is not a point."); } if (!m_Data.valid) { itkGenericExceptionMacro(<< "Invalid point node."); } return m_Data.point; } template typename DataNode ::LinePointerType DataNode ::GetLine() const { if (!IsLineFeature()) { itkGenericExceptionMacro(<< "Node " << m_NodeId << " is not a line."); } if (!m_Data.valid) { itkGenericExceptionMacro(<< "Invalid line node."); } return m_Data.line; } template typename DataNode ::PolygonPointerType DataNode ::GetPolygonExteriorRing() const { if (!IsPolygonFeature()) { itkGenericExceptionMacro(<< "Node " << m_NodeId << " is not a polygon."); } if (!m_Data.valid || !m_Data.exteriorRing) { itkGenericExceptionMacro(<< "Invalid polygon node."); } return m_Data.exteriorRing; } template typename DataNode ::PolygonListPointerType DataNode ::GetPolygonInteriorRings() const { if (!IsPolygonFeature()) { itkGenericExceptionMacro(<< "Node " << m_NodeId << " is not a polygon."); } if (!m_Data.valid || !m_Data.interiorRings) { itkGenericExceptionMacro(<< "Invalid polygon node."); } return m_Data.interiorRings; } template void DataNode ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << this->GetNodeTypeAsString(); } template std::string DataNode ::GetNodeTypeAsString() const { std::ostringstream oss; switch (m_NodeType) { case ROOT: { oss << "Root (" << m_NodeId << ")"; break; } case DOCUMENT: { oss << "Document (" << m_NodeId << ")"; break; } case FOLDER: { oss << "Folder (" << m_NodeId << ")"; break; } case FEATURE_POINT: { oss << "Point (" << m_NodeId << ") " << m_Data.point; break; } case FEATURE_LINE: { oss << "Line (" << m_NodeId << ") " << m_Data.line->GetVertexList()->Size() << " points"; break; } case FEATURE_POLYGON: { oss << "Polygon (" << m_NodeId << ") " << this->GetPolygonExteriorRing()->GetVertexList()->Size() << " points, " << this->GetPolygonInteriorRings()->Size() << " interior rings"; break; } case FEATURE_MULTIPOINT: { oss << "MultiPoint (" << m_NodeId << ")"; break; } case FEATURE_MULTILINE: { oss << "MultiLine (" << m_NodeId << ")"; break; } case FEATURE_MULTIPOLYGON: { oss << "MultiPolygon (" << m_NodeId << ")"; break; } case FEATURE_COLLECTION: { oss << "Collection (" << m_NodeId << ")"; break; } } if (GetMetaDataDictionary().HasKey(MetaDataKey::VectorDataKeywordlistKey)) { VectorDataKeywordlist kwl; itk::ExposeMetaData(GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); oss << "\n -> Metadata: " << kwl; } return oss.str(); } /* template void DataNode ::SetField(const std::string& key, const std::string& value) { m_FieldMap[key] = value; } */ template void DataNode ::SetFieldAsString(const std::string& key, const std::string& value) { otb::VectorDataKeywordlist kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); kwl.SetFieldAsString(key, value); itk::EncapsulateMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); } template void DataNode ::SetFieldAsInt(const std::string& key, int value) { otb::VectorDataKeywordlist kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); kwl.SetFieldAsInt(key, value); itk::EncapsulateMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); } template void DataNode ::SetFieldAsDouble(const std::string& key, double value) { otb::VectorDataKeywordlist kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); kwl.SetFieldAsDouble(key, value); itk::EncapsulateMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); } template double DataNode ::GetFieldAsDouble(const std::string& key) const { VectorDataKeywordlist keywordlist; if (HasField(key)) { itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, keywordlist); return keywordlist.GetFieldAsDouble(key); } return 0; } /* template std::string DataNode ::GetField(const std::string& key) const { if (HasField(key)) { return (*m_FieldMap.find(key)).second; } else { return "Unknown Key"; } }*/ template std::string DataNode ::GetFieldAsString(const std::string& key) const { VectorDataKeywordlist keywordlist; if (HasField(key)) { itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, keywordlist); return keywordlist.GetFieldAsString(key); } return ""; } template int DataNode ::GetFieldAsInt(const std::string& key) const { VectorDataKeywordlist keywordlist; if (HasField(key)) { itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, keywordlist); return keywordlist.GetFieldAsInt(key); } return 0; } /* template void DataNode ::RemoveField(const std::string& key) { m_FieldMap.erase(key); } template bool DataNode ::HasField(const std::string& key) const { return (m_FieldMap.find(key)!=m_FieldMap.end()); } */ template bool DataNode ::HasField(const std::string& key) const { VectorDataKeywordlist keywordlist; if (this->GetMetaDataDictionary().HasKey(MetaDataKey::VectorDataKeywordlistKey)) { itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, keywordlist); return keywordlist.HasField(key); } return false; } /* template typename DataNode ::FieldType DataNode ::GetNthField(unsigned int index) const { if (index unsigned int DataNode ::GetNumberOfFields() const { return m_FieldMap.size(); } */ template void DataNode ::CopyFieldList(const DataNode * dataNode) { // The source keywordlist where to get the feature list to copy otb::VectorDataKeywordlist srcKwl; itk::ExposeMetaData(dataNode->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, srcKwl); otb::VectorDataKeywordlist kwl; itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); kwl.CopyFieldList(srcKwl); itk::EncapsulateMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); } template std::vector DataNode ::GetFieldList() const { VectorDataKeywordlist keywordlist; if (this->GetMetaDataDictionary().HasKey(MetaDataKey::VectorDataKeywordlistKey)) { itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, keywordlist); return keywordlist.GetFieldList(); } std::vector empty; return empty; } /* template void DataNode ::ClearFields() { m_FieldMap.clear(); }*/ template bool DataNode ::IsDocument() const { return m_NodeType == DOCUMENT; } template bool DataNode ::IsRoot() const { return m_NodeType == ROOT; } template bool DataNode ::IsFolder() const { return m_NodeType == FOLDER; } template bool DataNode ::IsPointFeature() const { return m_NodeType == FEATURE_POINT; } template bool DataNode ::IsLineFeature() const { return m_NodeType == FEATURE_LINE; } template bool DataNode ::IsPolygonFeature() const { return m_NodeType == FEATURE_POLYGON; } template bool DataNode ::IsMultiPointFeature() const { return m_NodeType == FEATURE_MULTIPOINT; } template bool DataNode ::IsMultiLineFeature() const { return m_NodeType == FEATURE_MULTILINE; } template bool DataNode ::IsMultiPolygonFeature() const { return m_NodeType == FEATURE_MULTIPOLYGON; } template bool DataNode ::IsCollectionFeature() const { return m_NodeType == FEATURE_COLLECTION; } template OGRGeometry * DataNode ::ConvertDataNodeToOGRGeometry(const DataNode* dataNode) { switch(dataNode->GetNodeType()) { case FEATURE_POINT: { OGRPoint *ogrPoint = (OGRPoint *) OGRGeometryFactory::createGeometry(wkbPoint); ogrPoint->setX(dataNode->GetPoint()[0]); ogrPoint->setY(dataNode->GetPoint()[1]); return ogrPoint; } break; case FEATURE_LINE: { //Build the ogrObject OGRLineString * ogrLine = (OGRLineString *) OGRGeometryFactory::createGeometry(wkbLineString); VertexListConstPointerType vertexList = dataNode->GetLine()->GetVertexList(); typename VertexListType::ConstIterator vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if (Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrLine->addPoint(&ogrPoint); ++vIt; } return ogrLine; } break; case FEATURE_POLYGON: { OGRPolygon * polygon = (OGRPolygon *) OGRGeometryFactory::createGeometry(wkbPolygon); OGRLinearRing * ogrExternalRing = (OGRLinearRing *) OGRGeometryFactory::createGeometry(wkbLinearRing); VertexListConstPointerType vertexList = dataNode->GetPolygonExteriorRing()->GetVertexList(); typename VertexListType::ConstIterator vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if ( Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrExternalRing->addPoint(&ogrPoint); ++vIt; } polygon->addRing(ogrExternalRing); // Close the polygon polygon->closeRings(); OGRGeometryFactory::destroyGeometry(ogrExternalRing); return polygon; } break; default: break; } return ITK_NULLPTR; } template double DataNode ::EuclideanDistanceMetric(const DataNode* node) { // Convert the nodes to OGRGeometries OGRGeometry * dstGeomtery = this->ConvertDataNodeToOGRGeometry(node); OGRGeometry * currentGeometry = this->ConvertDataNodeToOGRGeometry(this); // Compute the distance return currentGeometry->Distance(dstGeomtery); } template double DataNode ::EuclideanDistanceMetric(const PointType point) { // Convert Point to point to ogrPoint OGRPoint ogrPointSrc; ogrPointSrc.setX(point[0]); ogrPointSrc.setY(point[1]); // Convert the current datanode to an OGRGeometry OGRGeometry * currentGeometry = this->ConvertDataNodeToOGRGeometry(this); // return the distance return currentGeometry->Distance(&ogrPointSrc); } template bool DataNode ::Intersects(const DataNode* node) { // Convert the nodes to OGRGeometries OGRGeometry * dstGeomtery = this->ConvertDataNodeToOGRGeometry(node); OGRGeometry * currentGeometry = this->ConvertDataNodeToOGRGeometry(this); // return currentGeometry->Intersects(dstGeomtery); } template bool DataNode ::Within(const DataNode* node) { // Convert the nodes to OGRGeometries OGRGeometry * dstGeomtery = this->ConvertDataNodeToOGRGeometry(node); OGRGeometry * currentGeometry = this->ConvertDataNodeToOGRGeometry(this); // return currentGeometry->Within(dstGeomtery); } } // end namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbDataNodeFunctionBase.h000066400000000000000000000043171301006202600270330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataNodeFunctionBase_h #define otbDataNodeFunctionBase_h #include "itkFunctionBase.h" namespace otb { /** \class DataNodeFunctionBase * \brief Base class for DataNode functions. * * DataNodeFunctionBase is the base class for DataNode function objects. Specifically, * the abstract method Evaluate() maps a DataNode from the input space to a element * in the output space. * * Subclasses must ITK_OVERRIDE Evaluate(). * * This class is template over the input DataNode type and * the output (range) type. * * * \ingroup Functions * \sa DataNodeImageFunction * \sa DataNodeVectorDataFunction * * \ingroup OTBVectorDataBase */ template class ITK_EXPORT DataNodeFunctionBase : public itk::FunctionBase { public: /** Standard class typedefs. */ typedef DataNodeFunctionBase Self; typedef itk::FunctionBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(otb::DataNodeFunctionBase, itk::FunctionBase); /** Input type */ typedef TDataNode DataNodeType; /** Output type */ typedef TOutput OutputType; /** Evaluate at the specified input position */ OutputType Evaluate( const DataNodeType& node ) const ITK_OVERRIDE = 0; protected: DataNodeFunctionBase(){}; ~DataNodeFunctionBase() ITK_OVERRIDE{}; private: DataNodeFunctionBase(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbDataNodeImageFunction.h000066400000000000000000000147141301006202600272050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataNodeImageFunction_h #define otbDataNodeImageFunction_h #include "otbDataNodeFunctionBase.h" #include "otbDataNode.h" #include "itkContinuousIndex.h" #include "itkImageBase.h" namespace otb { /** \class DataNodeImageFunction * \brief TODO * * * * \ingroup Functions * \sa NDVIDataNodeFeatureFunction * * \ingroup OTBVectorDataBase */ template < class TImage, class TOutput, class TCoordRep = double, class TPrecision = double > class ITK_EXPORT DataNodeImageFunction : public DataNodeFunctionBase, TOutput> { public: /** Dimension underlying input image. */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Standard class typedefs. */ typedef DataNodeImageFunction Self; typedef DataNodeFunctionBase, TOutput> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(DataNodeImageFunction, DataNodeFunctionBase); /** Some typedefs. */ typedef TImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef TOutput OutputType; /** CoordRepType typedef support. */ typedef TCoordRep CoordRepType; /** PrecisionType typedef support. */ typedef TPrecision PrecisionType; /** Index Type. */ typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::IndexValueType IndexValueType; /** ContinuousIndex Type. */ typedef itk::ContinuousIndex ContinuousIndexType; /** DataNode Type */ typedef typename Superclass::DataNodeType DataNodeType; /** Point Type */ typedef typename DataNodeType::PointType PointType; /** Set the input image. * \warning this method caches BufferedRegion information. * If the BufferedRegion has changed, user must call * SetInputImage again to update cached values. */ virtual void SetInputImage( const InputImageType * ptr ); /** Get the input image. */ const InputImageType * GetInputImage() const { return m_Image.GetPointer(); } /** Evaluate the function at specified DataNode position. * Subclasses must provide this method. */ TOutput Evaluate( const DataNodeType& node ) const ITK_OVERRIDE = 0; /** Check if an index is inside the image buffer. * we take into account the fact that each voxel has its * center at the integer coordinate and extends half way * to the next integer coordinate. * \warning For efficiency, no validity checking of * the input image is done. */ virtual bool IsInsideBuffer( const IndexType & index ) const { for( unsigned int j = 0; j < ImageDimension; ++j ) { if( index[j] < m_StartIndex[j] ) { return false; } if( index[j] > m_EndIndex[j] ) { return false; } } return true; } /** Check if a continuous index is inside the image buffer. * \warning For efficiency, no validity checking of * the input image is done. */ virtual bool IsInsideBuffer( const ContinuousIndexType & index ) const { for( unsigned int j = 0; j < ImageDimension; ++j ) { if( index[j] < m_StartContinuousIndex[j] ) { return false; } if( index[j] >= m_EndContinuousIndex[j] ) //Comment this instruction after itkv4 migration (correct //usage of centered-pixel coordinates) //if( index[j] > m_EndContinuousIndex[j] ) { return false; } } return true; } /** Check if a point is inside the image buffer. * \warning For efficiency, no validity checking of * the input image pointer is done. */ virtual bool IsInsideBuffer( const PointType & point ) const { ContinuousIndexType index; m_Image->TransformPhysicalPointToContinuousIndex( point, index ); return this->IsInsideBuffer( index ); } /** Convert point to continuous index */ void ConvertPointToContinuousIndex( const PointType & point, ContinuousIndexType & cindex ) const { m_Image->TransformPhysicalPointToContinuousIndex( point, cindex ); } /** Convert continuous index to nearest index. */ inline void ConvertContinuousIndexToNearestIndex( const ContinuousIndexType & cindex, IndexType & index ) const { index.CopyWithRound( cindex ); } /** Set/Get methods */ itkGetConstReferenceMacro(StartIndex, IndexType); itkGetConstReferenceMacro(EndIndex, IndexType); itkGetConstReferenceMacro(StartContinuousIndex, ContinuousIndexType); itkGetConstReferenceMacro(EndContinuousIndex, ContinuousIndexType); protected: DataNodeImageFunction(); ~DataNodeImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Const pointer to the input image. */ InputImageConstPointer m_Image; /** Cache some values for testing if indices are inside buffered region. */ IndexType m_StartIndex; IndexType m_EndIndex; ContinuousIndexType m_StartContinuousIndex; ContinuousIndexType m_EndContinuousIndex; private: DataNodeImageFunction(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbDataNodeImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbDataNodeImageFunction.txx000066400000000000000000000054271301006202600276020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataNodeImageFunction_txx #define otbDataNodeImageFunction_txx #include "otbDataNodeImageFunction.h" namespace otb { /** * Constructor */ template DataNodeImageFunction ::DataNodeImageFunction() { m_Image = ITK_NULLPTR; m_StartIndex.Fill(0); m_EndIndex.Fill(0); m_StartContinuousIndex.Fill(0.0f); m_EndContinuousIndex.Fill(0.0f); } /** * Standard "PrintSelf" method */ template void DataNodeImageFunction ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf( os, indent ); os << indent << "InputImage: " << m_Image.GetPointer() << std::endl; os << indent << "StartIndex: " << m_StartIndex << std::endl; os << indent << "EndIndex: " << m_EndIndex << std::endl; os << indent << "StartContinuousIndex: " << m_StartContinuousIndex << std::endl; os << indent << "EndContinuousIndex: " << m_EndContinuousIndex << std::endl; } /** * Initialize by setting the input image */ template void DataNodeImageFunction ::SetInputImage( const InputImageType * ptr ) { // set the input image m_Image = ptr; if ( ptr ) { typename InputImageType::SizeType size = ptr->GetBufferedRegion().GetSize(); m_StartIndex = ptr->GetBufferedRegion().GetIndex(); for ( unsigned int j = 0; j < ImageDimension; ++j ) { m_EndIndex[j] = m_StartIndex[j] + static_cast( size[j] ) - 1; m_StartContinuousIndex[j] = static_cast( m_StartIndex[j] - 0.5 ); m_EndContinuousIndex[j] = static_cast( m_EndIndex[j] + 0.5 ); //Comment these instructions after migration to ITKv4 where there is a correct //usage of centered-pixel coordinates //(ITK_USE_CENTERED_PIXEL_COORDINATES_CONSISTENTLY always ON) //m_StartContinuousIndex[j] = static_cast( m_StartIndex[j] ); //m_EndContinuousIndex[j] = static_cast( m_EndIndex[j] ); } } } } // end namespace itk #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbDataNodeVectorDataFunction.h000066400000000000000000000062131301006202600302120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataNodeVectorDataFunction_h #define otbDataNodeVectorDataFunction_h #include "otbDataNodeFunctionBase.h" #include "otbVectorDataProperties.h" namespace otb { /** \class DataNodeVectorDataFunction * \brief TODO * * * * \ingroup Functions * \sa * * \ingroup OTBVectorDataBase */ template < class TOutput, class TCoordRep = double, class TPrecision = double > class ITK_EXPORT DataNodeVectorDataFunction : public DataNodeFunctionBase, TOutput> { public: /** Standard class typedefs. */ typedef DataNodeVectorDataFunction Self; typedef DataNodeFunctionBase, TOutput> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(DataNodeVetorDataFunction, DataNodeFunctionBase); /** Some typedefs. */ typedef VectorData VectorDataType; typedef typename VectorDataType::ConstPointer VectorDataConstPointerType; typedef TOutput OutputType; /** CoordRepType typedef support. */ typedef TCoordRep CoordRepType; /** PrecisionType typedef support. */ typedef TPrecision PrecisionType; /** DataNode Type */ typedef typename Superclass::DataNodeType DataNodeType; /** Point Type */ typedef typename DataNodeType::PointType PointType; /** Set the input VetorData. */ virtual void SetInputVectorData( const VectorDataType * ptr ); /** Get the input VectorData. */ const VectorDataType * GetInputVectorData() const { return m_VectorData.GetPointer(); } /** Evaluate the function at specified DataNode position. * Subclasses must provide this method. */ TOutput Evaluate( const DataNodeType& node ) const ITK_OVERRIDE = 0; protected: DataNodeVectorDataFunction(); ~DataNodeVectorDataFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Const pointer to the input VectorData. */ VectorDataConstPointerType m_VectorData; private: DataNodeVectorDataFunction(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbDataNodeVectorDataFunction.txx" #endif #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbDataNodeVectorDataFunction.txx000066400000000000000000000030601301006202600306030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataNodeVectorDataFunction_txx #define otbDataNodeVectorDataFunction_txx #include "otbDataNodeVectorDataFunction.h" namespace otb { /** * Constructor */ template DataNodeVectorDataFunction ::DataNodeVectorDataFunction() { m_VectorData = ITK_NULLPTR; } /** * Standard "PrintSelf" method */ template void DataNodeVectorDataFunction ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf( os, indent ); os << indent << "VetorData: " << m_VectorData.GetPointer() << std::endl; } /** * Initialize by setting the input VectorData */ template void DataNodeVectorDataFunction ::SetInputVectorData( const VectorDataType * ptr ) { // set the input VectorData m_VectorData = ptr; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbGISConnectionImplementation.h000066400000000000000000000045151301006202600304230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGISConnectionImplementation_h #define otbGISConnectionImplementation_h #include "itkDataObject.h" #include "itkObjectFactory.h" namespace otb { /** \class GISConnectionImplementation * \brief Base class for GIS DB connection implementations * * * * \ingroup OTBVectorDataBase */ template class ITK_EXPORT GISConnectionImplementation : public itk::DataObject { public: /** Standard class typedefs */ typedef GISConnectionImplementation Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkNewMacro(Self); itkTypeMacro(GISConnectionImplementation, itk::DataObject); /** Acessors */ itkGetMacro(Host, std::string); itkSetMacro(Host, std::string); itkGetMacro(DBName, std::string); itkSetMacro(DBName, std::string); itkGetMacro(User, std::string); itkSetMacro(User, std::string); itkGetMacro(Password, std::string); itkSetMacro(Password, std::string); itkGetMacro(Port, std::string); itkSetMacro(Port, std::string); itkGetMacro(Options, std::string); itkSetMacro(Options, std::string); /** Using the connection */ virtual void ConnectToDB(){} virtual void PerformTransaction(const TransactorType& itkNotUsed(theTransaction)) const {} protected: /** Constructor */ GISConnectionImplementation(){}; /** Destructor */ virtual ~GISConnectionImplementation(){}; private: GISConnectionImplementation(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string m_Host; std::string m_DBName; std::string m_User; std::string m_Password; std::string m_Port; std::string m_Options; }; } // end namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbPolyLineParametricPathWithValue.h000066400000000000000000000101631301006202600312600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolyLineParametricPathWithValue_h #define otbPolyLineParametricPathWithValue_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include "itkPolyLineParametricPath.h" #pragma GCC diagnostic pop #else #include "itkPolyLineParametricPath.h" #endif #include "itkMetaDataObject.h" #include "otbRemoteSensingRegion.h" #include "otbMacro.h" namespace otb { /** \class PolyLineParametricPathWithValue * \brief This class implement a PolyLineParametricPath for which a value can be set. * The value is stored in the itk::MetaDataDictionary. * The precision of the value can be set. * * \sa itk::PolyLineParametricPath. * * \ingroup OTBVectorDataBase */ template class ITK_EXPORT PolyLineParametricPathWithValue : public itk::PolyLineParametricPath { public: /** Standard typedefs */ typedef PolyLineParametricPathWithValue Self; typedef itk::PolyLineParametricPath Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(PolyLineParametricPath, MySuperclass); /** Template parameters typedefs */ typedef TValue ValueType; /** Derived typedefs */ typedef typename Superclass::VertexType VertexType; typedef typename Superclass::VertexListType VertexListType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename VertexListType::ConstIterator VertexListConstIteratorType; // typedef itk::ImageRegion<2> RegionType; typedef otb::RemoteSensingRegion RegionType; typedef typename RegionType::SizeType SizeType; typedef typename RegionType::IndexType IndexType; itkGetMacro(Key, std::string); void SetValue(ValueType value) { itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, m_Key, value); } ValueType GetValue(void) const { ValueType resp(0); const itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); if (dict.HasKey(m_Key)) { itk::ExposeMetaData(dict, m_Key, resp); } else { itkGenericExceptionMacro(<< "Key " << m_Key << " not found in metadata dictionary !"); } return resp; } /** * Return the path length (perimeter). * \return The length. */ virtual double GetLength() const; virtual void AddVertex(const ContinuousIndexType& vertex); /** * Compute the path bounding region. * \return The region. */ virtual RegionType GetBoundingRegion(void) const; protected: /** Constructor */ PolyLineParametricPathWithValue(); /** Destructor */ ~PolyLineParametricPathWithValue() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; virtual void ComputeLength() const; virtual void ComputeBoundingRegion() const; void Modified() const ITK_OVERRIDE; private: PolyLineParametricPathWithValue(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string m_Key; mutable double m_Length; mutable bool m_LengthIsValid; mutable RegionType m_BoundingRegion; mutable bool m_BoundingRegionIsValid; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPolyLineParametricPathWithValue.txx" #endif #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbPolyLineParametricPathWithValue.txx000066400000000000000000000111741301006202600316570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolyLineParametricPathWithValue_txx #define otbPolyLineParametricPathWithValue_txx #include "otbPolyLineParametricPathWithValue.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template PolyLineParametricPathWithValue ::PolyLineParametricPathWithValue() : m_Key("Value"), m_Length(-1.0), m_LengthIsValid(false), m_BoundingRegion(), m_BoundingRegionIsValid(false) { itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); ValueType v; itk::EncapsulateMetaData(dict, m_Key, itk::NumericTraits::ZeroValue(v)); } template void PolyLineParametricPathWithValue ::AddVertex(const ContinuousIndexType& vertex) { Superclass::AddVertex(vertex); this->Modified(); } template double PolyLineParametricPathWithValue ::GetLength() const { if (!m_LengthIsValid) { ComputeLength(); } return m_Length; } template void PolyLineParametricPathWithValue ::ComputeLength() const { double length = 0.0; VertexListConstIteratorType it = this->GetVertexList()->Begin(); if (this->GetVertexList()->Size() > 1) { VertexType pt1 = it.Value(); //just init, won't be used like that VertexType pt2 = it.Value(); ++it; while (it != this->GetVertexList()->End()) { pt1 = pt2; pt2 = it.Value(); double accum = 0.0; for (unsigned int i = 0; i < VDimension; ++i) { accum += (pt1[i] - pt2[i]) * (pt1[i] - pt2[i]); } length += vcl_sqrt(accum); ++it; } } else //if there is strictly less than 2 points, length is 0 { length = 0.0; } m_Length = length; m_LengthIsValid = true; } /** * PrintSelf Method */ template void PolyLineParametricPathWithValue ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); VertexListConstIteratorType it = this->GetVertexList()->Begin(); while (it != this->GetVertexList()->End()) { os << it.Value() << " - "; ++it; } os << std::endl; } template typename PolyLineParametricPathWithValue ::RegionType PolyLineParametricPathWithValue ::GetBoundingRegion() const { if (!m_BoundingRegionIsValid) { ComputeBoundingRegion(); } return m_BoundingRegion; } /** * Bounding Box computation */ template void PolyLineParametricPathWithValue ::ComputeBoundingRegion() const { SizeType size; IndexType index; size.Fill(0); index.Fill(0); IndexType maxId; maxId.Fill(0); VertexListConstIteratorType it = this->GetVertexList()->Begin(); double x = 0.0; double y = 0.0; if (this->GetVertexList()->Size() > 0) { x = static_cast(it.Value()[0]); y = static_cast(it.Value()[1]); index[0] = x; index[1] = y; maxId[0] = x; maxId[1] = y; ++it; while (it != this->GetVertexList()->End()) { x = static_cast(it.Value()[0]); y = static_cast(it.Value()[1]); // Index search if (x < index[0]) { index[0] = x; } if (y < index[1]) { index[1] = y; } // Max Id search for size computation if (x > maxId[0]) { maxId[0] = x; } if (y > maxId[1]) { maxId[1] = y; } ++it; } size[0] = maxId[0] - index[0]; size[1] = maxId[1] - index[1]; } m_BoundingRegion.SetSize(size); m_BoundingRegion.SetOrigin(index); m_BoundingRegionIsValid = true; } template void PolyLineParametricPathWithValue ::Modified() const { m_LengthIsValid = false; m_BoundingRegionIsValid = false; } } // end namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbPolygon.h000066400000000000000000000122321301006202600244750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolygon_h #define otbPolygon_h #include "otbPolyLineParametricPathWithValue.h" namespace otb { /** \class Polygon * \brief This class represent a 2D polygon. * * It derives from otb::PolyLineParametricPathWithValue. The polygon is * considered to be the closed path represented by the * PolyLineParametricPathWithValue. * * It implements some useful methods to work with polygons, such as surface * computation, as well as method useful in the spatial reasoning context, such * as IsInside, IsOnEdge, IsTouching, IsCrossing. * * \sa otb::PolyLineParametricPathWithValue * * \ingroup OTBVectorDataBase */ template class ITK_EXPORT Polygon : public PolyLineParametricPathWithValue { public: /** Standard typedefs */ typedef Polygon Self; typedef PolyLineParametricPathWithValue Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TValue ValueType; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(Polygon, PolyLineParametricPathWithValue); /** Derived typedefs */ typedef typename Superclass::VertexType VertexType; typedef typename Superclass::VertexListType VertexListType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::VertexListConstIteratorType VertexListConstIteratorType; itkSetMacro(Epsilon, double); itkGetMacro(Epsilon, double); /** * Check whether point is strictly inside the polygon. * \param point The point to check. * \return True if the point is inside the polygon. */ bool IsInside(VertexType point) const; /** * Check whether point is strictly on the edge of the polygon. * \param point The point to check. * \return True if the point is on the edge of the polygon. */ bool IsOnEdge(VertexType point) const; /** * Returns the number of crossings of the polygon with a given segment. * \param a First point of the segment, * \param b Second point of the segment, * \return the number of strict crossings of segment [ab] with the polygon. */ unsigned int NbCrossing(VertexType a, VertexType b) const; /** * Returns the number of touchings without crossing of the polygon with a given segment. * \param a First point of the segment, * \param b Second point of the segment, * \return the number of touchings without crossing of segment [ab] with the polygon. */ unsigned int NbTouching(VertexType a, VertexType b) const; /** * Check whether two segments [a1a2] and [b1b2] are strictly crossing. * \param a1 First point of the first segment, * \param a1 Second point of the first segment, * \param a1 First point of the second segment, * \param a1 Second point of the second segment. * \return True if the two segments are strictly crossing. */ bool IsCrossing(VertexType a1, VertexType a2, VertexType b1, VertexType b2) const; /** * Check whether two segments[a1a2] and [b1b2] are touching without crossing. * \param a1 First point of the first segment, * \param a1 Second point of the first segment, * \param a1 First point of the second segment, * \param a1 Second point of the second segment. * \return True if the two segments are touching without crossing. */ bool IsTouching(VertexType a1, VertexType a2, VertexType b1, VertexType b2) const; /** * Return the polygon area. * \return The area. */ virtual double GetArea() const; /** * Return the polygon area. * \return The area. * \deprecated */ virtual double GetSurface() const { return this->GetArea(); } /** * Return the polygon length (perimeter). * \return The length. */ double GetLength() const ITK_OVERRIDE; void AddVertex(const ContinuousIndexType& vertex) ITK_OVERRIDE; protected: /** Constructor */ Polygon() { m_Epsilon = 0.000001; m_Area = -1.0; m_AreaIsValid = false; }; /** Destructor */ ~Polygon() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; virtual void ComputeArea() const; void Modified() const ITK_OVERRIDE; private: Polygon(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_Epsilon; mutable double m_Area; mutable bool m_AreaIsValid; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPolygon.txx" #endif #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbPolygon.txx000066400000000000000000000351651301006202600251030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolygon_txx #define otbPolygon_txx #include "otbPolygon.h" namespace otb { template void Polygon ::AddVertex(const ContinuousIndexType& vertex) { Superclass::AddVertex(vertex); m_AreaIsValid = false; } /** * Check whether point is strictly inside the polygon. * \param point The point to check. * \return True if the point is inside the polygon. */ template bool Polygon ::IsInside(VertexType point) const { double x = point[0]; double y = point[1]; unsigned int crossingCount = 0; VertexListConstIteratorType it = this->GetVertexList()->Begin(); double xa = it.Value()[0]; double ya = it.Value()[1]; ++it; while (it != this->GetVertexList()->End()) { double xb = it.Value()[0]; double yb = it.Value()[1]; if (vcl_abs(xb - xa) < m_Epsilon) { if (ya > yb && xa > x && y >= yb && y < ya) { ++crossingCount; } else if (ya < yb && xa > x && y >= ya && y < yb) { ++crossingCount; } } else if (vcl_abs(yb - ya) >= m_Epsilon) { double xcross = xa + (xb - xa) * (y - ya) / (yb - ya); if (ya > yb && xcross > x && y >= yb && y < ya) { ++crossingCount; } else if (ya < yb && xcross > x && y >= ya && y < yb) { ++crossingCount; } } xa = xb; ya = yb; ++it; } double xb = this->GetVertexList()->Begin().Value()[0]; double yb = this->GetVertexList()->Begin().Value()[1]; if (vcl_abs(xb - xa) < m_Epsilon) { if (ya > yb && xa > x && y >= yb && y < ya) { ++crossingCount; } else if (ya < yb && xa > x && y >= ya && y < yb) { ++crossingCount; } } else if (vcl_abs(yb - ya) >= m_Epsilon) { double xcross = xa + (xb - xa) * (y - ya) / (yb - ya); if (ya > yb && xcross > x && y >= yb && y < ya) { ++crossingCount; } else if (ya < yb && xcross > x && y >= ya && y < yb) { ++crossingCount; } } //std::cout<<"Crossing count: "< bool Polygon ::IsOnEdge(VertexType point) const { //std::cout<<"Checking point "<GetVertexList()->Begin(); double xa = it.Value()[0]; double ya = it.Value()[1]; double xbegin = xa; double ybegin = ya; ++it; while (!resp && it != this->GetVertexList()->End()) { xb = it.Value()[0]; yb = it.Value()[1]; if (vcl_abs(xb - xa) >= m_Epsilon) { double cd = (yb - ya) / (xb - xa); double oo = (ya - cd * xa); double xmin = std::min(xa, xb); double xmax = std::max(xa, xb); if ((vcl_abs(y - cd * x - oo) < m_Epsilon) && (x <= xmax) && (x >= xmin)) { //std::cout<<"Case 1: Point is on segment "< "<= ymin)) { resp = true; //std::cout<<"Case 2: Point is on segment "< "<= m_Epsilon) { double cd = (yb - ya) / (xb - xa); double oo = (ya - cd * xa); double xmin = std::min(xa, xb); double xmax = std::max(xa, xb); if ((vcl_abs(y - cd * x - oo) < m_Epsilon) && (x <= xmax) && (x >= xmin)) { resp = true; //std::cout<<"Case 1: Point is on segment "< "<= ymin)) { resp = true; //std::cout<<"Case 2: Point is on segment "< "< unsigned int Polygon ::NbCrossing(VertexType a, VertexType b) const { unsigned int resp = 0; VertexListConstIteratorType it = this->GetVertexList()->Begin(); VertexListConstIteratorType it_end = this->GetVertexList()->End(); VertexType current = it.Value(); VertexType first = current; ++it; while (it != it_end) { //std::cout<<"Testing Is crossing "< "< "< bool Polygon ::IsCrossing(VertexType a1, VertexType a2, VertexType b1, VertexType b2) const { bool resp = false; double xbmin = std::min(b1[0], b2[0]); double xbmax = std::max(b1[0], b2[0]); double ybmin = std::min(b1[1], b2[1]); double ybmax = std::max(b1[1], b2[1]); double xamin = std::min(a1[0], a2[0]); double xamax = std::max(a1[0], a2[0]); double yamin = std::min(a1[1], a2[1]); double yamax = std::max(a1[1], a2[1]); if (vcl_abs(a1[0] - a2[0]) < m_Epsilon && vcl_abs(b1[0] - b2[0]) < m_Epsilon) { resp = false; } else if (vcl_abs(a1[0] - a2[0]) < m_Epsilon) { double cd2 = (b2[1] - b1[1]) / (b2[0] - b1[0]); double oo2 = b1[1] - cd2 * b1[0]; double ycross = cd2 * a1[0] + oo2; resp = (xbmin a1[0] && yamin ycross); } else if (vcl_abs(b1[0] - b2[0]) < m_Epsilon) { double cd1 = (a2[1] - a1[1]) / (a2[0] - a1[0]); double oo1 = a1[1] - cd1 * a1[0]; double ycross = cd1 * b1[0] + oo1; resp = (xamin b1[0] && ybmin ycross); } else { double cd1 = (a2[1] - a1[1]) / (a2[0] - a1[0]); double oo1 = a1[1] - cd1 * a1[0]; double cd2 = (b2[1] - b1[1]) / (b2[0] - b1[0]); double oo2 = b1[1] - cd2 * b1[0]; if (cd1 != cd2) { double xcross = (oo2 - oo1) / (cd1 - cd2); resp = (xamin xcross && xbmax> xcross); } } return resp; } /** * Check whether two segments[a1a2] and [b1b2] are touching without crossing. * \param a1 First point of the first segment, * \param a1 Second point of the first segment, * \param a1 First point of the second segment, * \param a1 Second point of the second segment. * \return True if the two segments are touching without crossing. */ template bool Polygon ::IsTouching(VertexType a1, VertexType a2, VertexType b1, VertexType b2) const { bool resp = false; double xbmin = std::min(b1[0], b2[0]); double xbmax = std::max(b1[0], b2[0]); double ybmin = std::min(b1[1], b2[1]); double ybmax = std::max(b1[1], b2[1]); double xamin = std::min(a1[0], a2[0]); double xamax = std::max(a1[0], a2[0]); double yamin = std::min(a1[1], a2[1]); double yamax = std::max(a1[1], a2[1]); if (vcl_abs(a1[0] - a2[0]) < m_Epsilon && vcl_abs(b1[0] - b2[0]) < m_Epsilon) { resp = (vcl_abs(a1[0] - b1[0]) < m_Epsilon) && ((a1[1] <= ybmax && a1[1] >= ybmin) || (a2[1] <= ybmax && a2[1] >= ybmin) || (b1[1] <= yamax && b1[1] >= yamin) || (b2[1] <= yamax && b2[1] >= yamin)); } else if (vcl_abs(a1[0] - a2[0]) < m_Epsilon) { double cd2 = (b2[1] - b1[1]) / (b2[0] - b1[0]); double oo2 = b1[1] - cd2 * b1[0]; if (vcl_abs(a1[1] - cd2 * a1[0] - oo2) < m_Epsilon) { resp = (a1[0] >= xbmin && a1[0] <= xbmax); } else if (vcl_abs(a2[1] - cd2 * a2[0] - oo2) < m_Epsilon) { resp = (a2[0] >= xbmin && a2[0] <= xbmax); } } else if (vcl_abs(b1[0] - b2[0]) < m_Epsilon) { double cd1 = (a2[1] - a1[1]) / (a2[0] - a1[0]); double oo1 = a1[1] - cd1 * a1[0]; if (vcl_abs(b1[1] - cd1 * b1[0] - oo1) < m_Epsilon) { resp = (b1[0] >= xamin && b1[0] <= xamax); } else if (vcl_abs(b2[1] - cd1 * b2[0] - oo1) < m_Epsilon) { resp = (b2[0] >= xamin && b2[0] <= xamax); } } else { double cd1 = (a2[1] - a1[1]) / (a2[0] - a1[0]); double oo1 = a1[1] - cd1 * a1[0]; double cd2 = (b2[1] - b1[1]) / (b2[0] - b1[0]); double oo2 = b1[1] - cd2 * b1[0]; if (vcl_abs(cd1 - cd2) < m_Epsilon && vcl_abs(oo1 - oo2) < m_Epsilon) { resp = ((xamin <= xbmax && xamin >= xbmin) || (xamax <= xbmax && xamax >= xbmin) || (xbmin <= xamax && xbmin >= xamin) || (xbmax <= xamax && xbmax >= xamin)); } else { if (vcl_abs(a1[1] - cd2 * a1[0] - oo2) < m_Epsilon) { resp = (a1[0] >= xbmin && a1[0] <= xbmax); } else if (vcl_abs(a2[1] - cd2 * a2[0] - oo2) < m_Epsilon) { resp = (a2[0] >= xbmin && a2[0] <= xbmax); } if (vcl_abs(b1[1] - cd1 * b1[0] - oo1) < m_Epsilon) { resp = (b1[0] >= xamin && b1[0] <= xamax); } else if (vcl_abs(b2[1] - cd1 * b2[0] - oo1) < m_Epsilon) { resp = (b2[0] >= xamin && b2[0] <= xamax); } } } return resp; } /** * Area computation (for non convex polygons as well) */ template void Polygon ::ComputeArea() const { VertexListConstIteratorType it = this->GetVertexList()->Begin(); if (this->GetVertexList()->Size() > 2) { double area = 0.0; VertexType origin = it.Value(); ++it; VertexType pt1 = it.Value(); VertexType pt2 = it.Value(); while (it != this->GetVertexList()->End()) { pt1 = pt2; pt2 = it.Value(); double vector1x = pt1[0] - origin[0]; double vector1y = pt1[1] - origin[1]; double vector2x = pt2[0] - origin[0]; double vector2y = pt2[1] - origin[1]; double crossProdduct = vector1x * vector2y - vector2x * vector1y; area += crossProdduct; ++it; } m_Area = fabs(area / 2.0); } else //if there is strictly less than 3 points, surface is 0 { m_Area = 0.0; } m_AreaIsValid = true; } /** * Get surface */ template double Polygon ::GetArea() const { if (!m_AreaIsValid) { ComputeArea(); } return m_Area; } /** * Length computation (difference with path is in the last addition) */ template double Polygon ::GetLength() const { double length = 0.0; VertexListConstIteratorType it = this->GetVertexList()->Begin(); VertexType origin = it.Value(); if (this->GetVertexList()->Size() > 1) { VertexType pt1 = it.Value(); //just init, won't be used like that VertexType pt2 = it.Value(); ++it; while (it != this->GetVertexList()->End()) { pt1 = pt2; pt2 = it.Value(); double accum = 0.0; for (int i = 0; i < 2; ++i) { accum += (pt1[i] - pt2[i]) * (pt1[i] - pt2[i]); } length += vcl_sqrt(accum); ++it; } //Adding the last segment (between first and last point) double accum = 0.0; for (int i = 0; i < 2; ++i) { accum += (origin[i] - pt2[i]) * (origin[i] - pt2[i]); } length += vcl_sqrt(accum); } else //if there is strictly less than 2 points, length is 0 { length = 0.0; } return length; } template void Polygon ::Modified() const { Superclass::Modified(); m_AreaIsValid = false; } /** * PrintSelf Method */ template void Polygon ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorData.h000066400000000000000000000122231301006202600251020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorData_h #define otbVectorData_h #include "itkTreeContainer.h" #include "itkDataObject.h" #include "otbDataNode.h" namespace otb { /** \class VectorData * \brief This class represents a hierarchy of vector data. * * This class contains an itk::TreeContainer templated with otb::DataNode. * It represents a tree structure of vector data. These data can be read from * shapefiles or kml files for instance. * * The internal tree can be walked with itk::TreeIteratorBase subclasses. * * The three templates indicate * - the precision of the points coordinates (by default: double) * - the number of dimensions of the space (by default: 2) * - the precision of the value associated with objects such as line or * polygons (by default: double) * * The elements in the VectorData have their coordinates in the projection * specified by the WKT string. This class also offer the possibility to store * the coordinates directly into an image coordinate system, using the origin and * spacing in a similar way as the corresponding image. * * \sa DataNode * \sa VectorDataFileReader * \sa VectorDataFileWriter * * * \ingroup OTBVectorDataBase */ template class VectorData : public itk::DataObject { public: /** Standard class typedefs */ typedef VectorData Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkNewMacro(Self); itkTypeMacro(VectorData, DataObject); itkStaticConstMacro(Dimension, unsigned int, VDimension); /** Template parameters typedef */ typedef TPrecision PrecisionType; typedef TValuePrecision ValuePrecisionType; //define VDimension Dimension; typedef otb::DataNode DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef itk::TreeContainer DataTreeType; typedef typename DataTreeType::Pointer DataTreePointerType; typedef typename DataNodeType::PointType PointType; typedef typename DataNodeType::LineType LineType; typedef typename DataNodeType::PolygonType PolygonType; typedef itk::Vector SpacingType; typedef itk::Point OriginType; itkGetObjectMacro(DataTree, DataTreeType); itkGetConstObjectMacro(DataTree, DataTreeType); virtual void SetProjectionRef(const std::string& projectionRef); virtual std::string GetProjectionRef() const; /** Set the origin of the vector data to put it in the corresponding * image coordinates * \sa GetOrigin() */ itkSetMacro(Origin, OriginType); virtual void SetOrigin(const double origin[2]); virtual void SetOrigin(const float origin[2]); itkGetConstReferenceMacro(Origin, OriginType); /** Set the spacing of the vector data to put it in the corresponding * image coordinates * \sa GetSpacing() */ virtual void SetSpacing(const SpacingType& spacing); virtual void SetSpacing(const double spacing[2]); virtual void SetSpacing(const float spacing[2]); itkGetConstReferenceMacro(Spacing, SpacingType); /** Clear the vector data */ virtual bool Clear(); /** Return the number of element in the tree */ virtual int Size() const; void TransformPointToPhysicalPoint(const PointType& point, PointType& physicalPoint) const { physicalPoint[0] = point[0] * m_Spacing[0] + m_Origin[0]; physicalPoint[1] = point[1] * m_Spacing[1] + m_Origin[1]; } /** Graft the data and information from one VectorData to another. This * is a convenience method to setup a second VectorData with all the meta * information of another VectorData and use the same DataTree * Note that this method is different than just using two * SmartPointers to the same VectorData since separate DataObjects are * still maintained. This method is similar to * VectorDataSource::GraftOutput(). */ void Graft(const itk::DataObject *data) ITK_OVERRIDE; protected: /** Constructor */ VectorData(); /** Destructor */ ~VectorData() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: VectorData(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Data tree */ DataTreePointerType m_DataTree; SpacingType m_Spacing; OriginType m_Origin; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorData.txx" #endif #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorData.txx000066400000000000000000000121651301006202600255030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorData_txx #define otbVectorData_txx #include "otbVectorData.h" #include "itkPreOrderTreeIterator.h" #include "otbMetaDataKey.h" namespace otb { template VectorData ::VectorData() { m_DataTree = DataTreeType::New(); DataNodePointerType root = DataNodeType::New(); root->SetNodeId("Root"); m_DataTree->SetRoot(root); m_Origin.Fill(0); m_Spacing.Fill(1); } template void VectorData ::SetProjectionRef(const std::string& projectionRef) { itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, projectionRef); this->Modified(); } template std::string VectorData ::GetProjectionRef() const { const itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); std::string projectionRef; itk::ExposeMetaData(dict, MetaDataKey::ProjectionRefKey, projectionRef); return projectionRef; } template void VectorData ::SetSpacing(const SpacingType& spacing) { itkDebugMacro("setting Spacing to " << spacing); if (this->m_Spacing != spacing) { this->m_Spacing = spacing; this->Modified(); } } template void VectorData ::SetSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetSpacing(s); } template void VectorData ::SetSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetSpacing(s); } template void VectorData ::SetOrigin(const double origin[2]) { OriginType p(origin); this->SetOrigin(p); } template void VectorData ::SetOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetOrigin(p); } template bool VectorData ::Clear() { return m_DataTree->Clear(); } template int VectorData ::Size() const { return m_DataTree->Count(); } template void VectorData ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << std::endl; itk::PreOrderTreeIterator it(m_DataTree); it.GoToBegin(); while (!it.IsAtEnd()) { itk::PreOrderTreeIterator itParent = it; bool goesOn = true; while (itParent.HasParent() && goesOn) { os << indent; goesOn = itParent.GoToParent(); } os << "+" << it.Get()->GetNodeTypeAsString() << std::endl; ++it; } } template void VectorData ::Graft(const itk::DataObject *data) { // call the superclass' implementation Superclass::Graft( data ); if ( data ) { // Attempt to cast data to an Image const Self * vdData; try { vdData = dynamic_cast( data ); } catch( ... ) { return; } if ( vdData ) { // Copy all the needed data : DataTree, spacing, origin and // Projection Ref m_DataTree = const_cast (vdData->GetDataTree()); this->SetSpacing(vdData->GetSpacing()); this->SetOrigin(vdData->GetOrigin()); this->SetProjectionRef(vdData->GetProjectionRef()); } else { // pointer could not be cast back down itkExceptionMacro( << "otb::VectorData::Graft() cannot cast " << typeid(data).name() << " to " << typeid(const Self *).name() ); } } } } // end namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorDataIOBase.h000066400000000000000000000136651301006202600261400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataIOBase_h #define otbVectorDataIOBase_h #include #include "itkLightProcessObject.h" #include "itkIndent.h" #include "itkPoint.h" #include "itkDataObject.h" #include "OTBVectorDataBaseExport.h" namespace otb { /** \class VectorDataIOBase * \brief Abstract superclass defines VectorData IO interface. * * VectorDataIOBase is a class that reads and/or writes VectorData data * of a particular format (such as shapefile or kml). The * VectorDataIOBase encapsulates both the reading and writing of data. The * VectorDataIOBase is used by the VectorDataFileReader class (to read data) * and the VectorDataFileWriter (to write data) into a single file. * Normally the user does not directly * manipulate this class other than to instantiate it, set the FileName, * and assign it to a VectorDataFileReader/VectorDataFileWriter. * * A Pluggable factory pattern is used this allows different kinds of readers * to be registered (even at run time) without having to modify the * code in this class. * * \sa VectorDataFileWriter * \sa VectorDataFileReader * * \ingroup IOFilters * * * \ingroup OTBVectorDataBase */ class OTBVectorDataBase_EXPORT VectorDataIOBase : public itk::LightProcessObject { public: /** Standard class typedefs. */ typedef VectorDataIOBase Self; typedef itk::LightProcessObject Superclass; typedef itk::SmartPointer Pointer; /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataIOBase, Superclass); itkStaticConstMacro(VDimension, unsigned int, 3); typedef itk::Vector SpacingType; typedef itk::Point PointType; /** Set/Get the name of the file to be read. */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); /** Enums used to specify byte order; whether Big Endian or Little Endian. * Some subclasses use this, some ignore it. */ typedef enum {BigEndian, LittleEndian, OrderNotApplicable} ByteOrder; /** These methods indicate the byte ordering of the file you are * trying to read in. These methods will then either swap or not * swap the bytes depending on the byte ordering of the machine it * is being run on. For example, reading in a BigEndian file on a * BigEndian machine will result in no swapping. Trying to read the * same file on a LittleEndian machine will result in swapping. * Note: most UNIX machines are BigEndian while PC's and VAX's are * LittleEndian. So if the file you are reading in was generated on * a VAX or PC, SetByteOrderToLittleEndian() otherwise * SetByteOrderToBigEndian(). Some ImageIOBase subclasses * ignore these methods. */ itkSetEnumMacro(ByteOrder, ByteOrder); itkGetEnumMacro(ByteOrder, ByteOrder); void SetByteOrderToBigEndian() { this->SetByteOrder(BigEndian); } void SetByteOrderToLittleEndian() { this->SetByteOrder(LittleEndian); } /** Convenience method returns the ByteOrder as a string. This can be * used for writing output files. */ std::string GetByteOrderAsString(ByteOrder) const; /** Type for representing size of bytes, and or positions along a file */ typedef std::streamoff SizeType; /*-------- This part of the interfaces deals with reading data ----- */ /** Determine the file type. Returns true if this VectorDataIO can read the * file specified. */ virtual bool CanReadFile(const char*) const = 0; /** Determine if the VectorDataIO can stream reading from this file. Default is false. */ virtual bool CanStreamRead() const { return false; } /* /\** Read the spacing and dimensions of the VectorData. */ /* * Assumes SetFileName has been called with a valid file name. *\/ */ /* virtual void ReadVectorDataInformation() = 0; */ /** Reads the data from disk into the memory buffer provided. */ virtual void Read(itk::DataObject* data) = 0; /*-------- This part of the interfaces deals with writing data ----- */ /** Determine the file type. Returns true if this VectorDataIO can read the * file specified. */ virtual bool CanWriteFile(const char*) const = 0; /** Determine if the ImageIO can stream writing to this file. Default is false. */ virtual bool CanStreamWrite() const { return false; } /* /\** Writes the spacing and dimensions of the VectorData. */ /* * Assumes SetFileName has been called with a valid file name. *\/ */ /* virtual void WriteVectorDataInformation() = 0; */ /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegions has been set properly. The buffer is cast to a * pointer to the beginning of the image data. */ virtual void Write(const itk::DataObject* data, char ** papszOptions = ITK_NULLPTR) = 0; protected: VectorDataIOBase(); ~VectorDataIOBase() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Big or Little Endian, and the type of the file. (May be ignored.) */ ByteOrder m_ByteOrder; /** Does the VectorDataIOBase object have enough info to be of use? */ bool m_Initialized; /** Filename to read */ std::string m_FileName; /** Return the object to an initialized state, ready to be used */ virtual void Reset(const bool freeDynamic = true); private: VectorDataIOBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif // otbVectorDataIOBase_h OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorDataKeywordlist.h000066400000000000000000000111511301006202600273420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataKeywordlist_h #define otbVectorDataKeywordlist_h #include "itkLightObject.h" #include "itkObjectFactory.h" #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "ogr_feature.h" #pragma GCC diagnostic pop #else #include "ogr_feature.h" #endif namespace otb { /** \class VectorDataKeywordlist * \brief this class handle the metadata of vector data. * * This class is used internaly to handle the information associated with * a vector object. This information is retrieved from the input file (a * shapefile for example) and propagated along the pipeline with the object. * * This is the equivalent of the otbImageKeywordlist class but for OGR information. * * \todo add the accessor to enable modifying/updating the data. * * * \ingroup OTBVectorDataBase */ #include "OTBVectorDataBaseExport.h" class OTBVectorDataBase_EXPORT VectorDataKeywordlist { public: /** Smart pointer typedef support. */ typedef VectorDataKeywordlist Self; typedef std::pair FieldType; typedef std::vector FieldListType; virtual const char *GetNameOfClass() const {return "VectorDataKeywordlist"; } void AddField(OGRFieldDefn* fieldDefn, OGRField* field); /** * \param key The name of the field. * \param value The value of the field. */ void AddField(const std::string& key, const std::string& value); /** * Returns the value associated with a field name. * \param key The name of the field. * \return The value of the field. A default value is returned if the key was not found. */ std::string GetFieldAsString(const std::string& key) const; /** * \return True if the node contains the field named after the given key. * \param key The name of the field. */ bool HasField(const std::string& key) const; /** * \param key The name of the field. * \param value The value of the field. */ void SetFieldAsString(const std::string& key, const std::string& value); /** * Returns the value associated with a field name. * \param key The name of the field. * \return The value of the field. A default value is returned if the key was not found. */ double GetFieldAsDouble(const std::string& key) const; /** * \param key The name of the field. * \param value The value of the field. */ void SetFieldAsDouble(const std::string& key, double value); /** * Set the field as an integer * \param key The name of the field. * \param value The value of the field. */ void SetFieldAsInt(const std::string& key, int value); /** * Returns the value associated with a field name. * \param key The name of the field. * \return The value of the field. A default value is returned if the key was not found. */ int GetFieldAsInt(const std::string& key) const; /** * \return the nth field of the node as a std::pair of (key, value). * \param index the index of the field to return. */ FieldType GetNthField(unsigned int index) const; /** * \return the number of fields in the node. */ unsigned int GetNumberOfFields() const; /** * \return the name of fields in the node. */ std::vector GetFieldList() const; /** * Copy all the fields from another kwl */ void CopyFieldList(const Self& kwl); /** * Print the keyword list */ virtual void Print(std::ostream& os, itk::Indent indent = 0) const; /** Constructor */ VectorDataKeywordlist(); /** Destructor */ ~VectorDataKeywordlist(); /** Constructor by copy (deep copy)*/ VectorDataKeywordlist(const Self& other); /** Deep copy operator*/ void operator =(const Self&); protected: virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; private: std::string PrintField(FieldType field) const; FieldType CopyOgrField(FieldType field); FieldListType m_FieldList; }; OTBVectorDataBase_EXPORT extern std::ostream & operator <<(std::ostream& os, const VectorDataKeywordlist& kwl); } #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorDataProperties.h000066400000000000000000000067471301006202600271750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataProperties_h #define otbVectorDataProperties_h #include "itkObjectFactory.h" // #include "itkNumericTraits.h" #include "otbVectorData.h" namespace otb { /** \class VectorDataProperties * \brief Compute public properties of the vectordata * * \sa VectorData * * \ingroup OTBVectorDataBase */ template class ITK_EXPORT VectorDataProperties : public itk::DataObject { public: /** Standard class typedefs. */ typedef VectorDataProperties Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Convenient typedefs */ typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef typename VectorDataType::ConstPointer InputVectorDataConstPointer; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename VectorDataType::DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename InternalTreeNodeType::ChildrenListType ChildrenListType; typedef typename PolygonType::RegionType RegionType; typedef typename RegionType::Pointer RegionPointerType; typedef typename RegionType::IndexType IndexType; typedef typename RegionType::SizeType SizeType; typedef typename RegionType::Type Type; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataProperties, LightObject); /** Number of dimensions. */ itkStaticConstMacro(VectorDataDimension, unsigned int, TVectorData::Dimension); /** Get/Set the VectorData. */ // itkGetObjectMacro(VectorDataObject, VectorDataType); void SetVectorDataObject(const VectorDataType * v) {m_VectorDataObject = const_cast (v); } // RegionType GetBoundingRegion() {return m_BoundingRegion; } void SetBoundingRegion(RegionType& region) {m_BoundingRegion = region; } void AddRegion(const RegionType& region); void ComputeBoundingRegion(); protected: /** Constructor */ VectorDataProperties() : m_VectorDataObject(ITK_NULLPTR) {}; /** Destructor */ ~VectorDataProperties() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void ProcessNode(InternalTreeNodeType * source); bool IsBoundingRegionNull(); private: VectorDataProperties(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented //Pointer to the VectorData VectorDataType * m_VectorDataObject; RegionType m_BoundingRegion; }; // end class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataProperties.txx" #endif #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorDataProperties.txx000066400000000000000000000120601301006202600275520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataProperties_txx #define otbVectorDataProperties_txx #include "otbVectorDataProperties.h" #include namespace otb { template bool VectorDataProperties ::IsBoundingRegionNull() { for (unsigned int i = 0; i < VectorDataDimension; ++i) { if ((m_BoundingRegion.GetOrigin(i) != itk::NumericTraits::ZeroValue()) || (m_BoundingRegion.GetSize(i) != itk::NumericTraits::ZeroValue())) return false; } return true; } /** * Add a region */ template void VectorDataProperties ::AddRegion(const RegionType& region) { // std::cout << "add region: " << region << std::endl; if (this->IsBoundingRegionNull()) { m_BoundingRegion = region; } else { Type index; for (unsigned int i = 0; i < VectorDataDimension; ++i) { index = std::min (m_BoundingRegion.GetOrigin(i), region.GetOrigin(i)); m_BoundingRegion.SetSize(i, std::max (m_BoundingRegion.GetOrigin(i) + m_BoundingRegion.GetSize(i), region.GetOrigin(i) + region.GetSize( i)) - index); m_BoundingRegion.SetOrigin(i, index); } } } /** * Compute the complete bounding box of the dataset */ template void VectorDataProperties ::ComputeBoundingRegion() { /** Initialize the bounding region to null*/ IndexType index; SizeType size; index.Fill(itk::NumericTraits::ZeroValue()); size.Fill(itk::NumericTraits::ZeroValue()); m_BoundingRegion.SetIndex(index); m_BoundingRegion.SetSize(size); /** Compute the bounding region*/ InternalTreeNodeType * inputRoot = const_cast(m_VectorDataObject->GetDataTree()->GetRoot()); ProcessNode(inputRoot); } template void VectorDataProperties ::ProcessNode(InternalTreeNodeType * source) { // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // For each child for (typename ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { // Copy input DataNode info DataNodePointerType dataNode = (*it)->Get(); switch (dataNode->GetNodeType()) { case otb::ROOT: { ProcessNode((*it)); break; } case otb::DOCUMENT: { ProcessNode((*it)); break; } case otb::FOLDER: { ProcessNode((*it)); break; } case FEATURE_POINT: { // otbGenericMsgDebugMacro(<<"Insert Point from vectorData"); IndexType start; for (unsigned int i = 0; i < VectorDataDimension; ++i) { start[i] = dataNode->GetPoint()[i]; } SizeType size; size.Fill(itk::NumericTraits::ZeroValue()); RegionType region; region.SetSize(size); region.SetIndex(start); this->AddRegion(region); break; } case otb::FEATURE_LINE: { this->AddRegion(dataNode->GetLine()->GetBoundingRegion()); break; } case FEATURE_POLYGON: { //otbGenericMsgDebugMacro(<<"Insert polygons from vectorData"); this->AddRegion(dataNode->GetPolygonExteriorRing()->GetBoundingRegion()); break; } case FEATURE_MULTIPOINT: { itkExceptionMacro( << "This type (FEATURE_MULTIPOINT) is not handle (yet), please request for it"); break; } case FEATURE_MULTILINE: { itkExceptionMacro( << "This type (FEATURE_MULTILINE) is not handle (yet), please request for it"); break; } case FEATURE_MULTIPOLYGON: { itkExceptionMacro( << "This type (FEATURE_MULTIPOLYGON) is not handle (yet), please request for it"); break; } case FEATURE_COLLECTION: { itkExceptionMacro( << "This type (FEATURE_COLLECTION) is not handle (yet), please request for it"); break; } } } } template void VectorDataProperties ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Properties VectorData: " << m_VectorDataObject << std::endl; os << indent << "Properties Bounding Region: " << m_BoundingRegion << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorDataSource.h000066400000000000000000000063151301006202600262700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataSource_h #define otbVectorDataSource_h #include "OTBVectorDataBaseExport.h" #include "itkProcessObject.h" #include "itkMacro.h" namespace otb { /** \class VectorDataSource * \brief Filter hierarchy for generating VectorData * * * \ingroup IO * * * \ingroup OTBVectorDataBase */ template class ITK_ABI_EXPORT VectorDataSource : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef VectorDataSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataSource, itk::ProcessObject); typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef TOutputVectorData OutputVectorDataType; typedef typename TOutputVectorData::Pointer OutputVectorDataPointer; /** Graft the specified DataObject onto this ProcessObject's output. * This method grabs a handle to the specified DataObject's bulk * data to used as its output's own bulk data. * Most importantly, however, it leaves the Source ivar untouched so * the original pipeline routing is intact. This method is used when * a process object is implemented using a mini-pipeline which is * defined in its GenerateData() method. * */ virtual void GraftOutput(itk::DataObject *output); /** Graft the specified data object onto this ProcessObject's idx'th * output. This is similar to the GraftOutput method except it * allows you to specify which output is affected. The specified index * must be a valid output number (less than * ProcessObject::GetNumberOfOutputs()). See the GraftOutput for * general usage information. */ virtual void GraftNthOutput(unsigned int idx, itk::DataObject *output); /** Overriding GetOutput() method */ virtual OutputVectorDataType* GetOutput(void); virtual OutputVectorDataType* GetOutput(DataObjectPointerArraySizeType idx); protected: VectorDataSource(); ~VectorDataSource() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Ensure that the output vector data are cleared before processing */ virtual void AllocateOutputs(); private: VectorDataSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataSource.txx" #endif #endif // otbVectorDataSource_h OTB-release-5.8/Modules/Core/VectorDataBase/include/otbVectorDataSource.txx000066400000000000000000000061061301006202600266620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataSource_txx #define otbVectorDataSource_txx #include "otbVectorDataSource.h" namespace otb { /** * Constructor */ template VectorDataSource ::VectorDataSource() { this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, OutputVectorDataType::New().GetPointer()); } template VectorDataSource ::~VectorDataSource() { } /** * */ template void VectorDataSource ::GraftOutput(itk::DataObject *graft) { this->GraftNthOutput(0, graft); } /** * */ template void VectorDataSource ::GraftNthOutput(unsigned int idx, itk::DataObject *graft) { if ( idx >= this->GetNumberOfOutputs() ) { itkExceptionMacro(<<"Requested to graft output " << idx << " but this filter only has " << this->GetNumberOfOutputs() << " Outputs."); } if ( !graft ) { itkExceptionMacro(<<"Requested to graft output that is a NULL pointer" ); } // we use the process object method since all out output may not be // of the same type itk::DataObject * output = this->ProcessObject::GetOutput(idx); // Call GraftImage to copy meta-information, regions, and the pixel container output->Graft( graft ); } template void VectorDataSource ::AllocateOutputs() { OutputVectorDataPointer outputPtr; // Allocate the output memory for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { outputPtr = this->GetOutput(i); outputPtr->Clear(); } } /** * Get the output vector data * \return The vector data produced. */ template typename VectorDataSource::OutputVectorDataType * VectorDataSource ::GetOutput(void) { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } template typename VectorDataSource::OutputVectorDataType * VectorDataSource ::GetOutput(DataObjectPointerArraySizeType idx) { return static_cast (this->Superclass::GetOutput(idx)); } /** * PrintSelf Method */ template void VectorDataSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Core/VectorDataBase/otb-module.cmake000066400000000000000000000006011301006202600236130ustar00rootroot00000000000000set(DOCUMENTATION "This module contains base classes for representing vector data (see also VectorDataIO and VectorDataManipulation modules).") otb_module(OTBVectorDataBase ENABLE_SHARED DEPENDS OTBCommon OTBGDAL OTBITK OTBImageBase OTBOSSIMAdapters OTBObjectList TEST_DEPENDS OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Core/VectorDataBase/src/000077500000000000000000000000001301006202600213345ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/VectorDataBase/src/CMakeLists.txt000066400000000000000000000006011301006202600240710ustar00rootroot00000000000000set(OTBVectorDataBase_SRC otbVectorDataIOBase.cxx otbVectorDataKeywordlist.cxx ) add_library(OTBVectorDataBase ${OTBVectorDataBase_SRC}) target_link_libraries(OTBVectorDataBase ${OTBCommon_LIBRARIES} ${OTBGDAL_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_module_target(OTBVectorDataBase) OTB-release-5.8/Modules/Core/VectorDataBase/src/otbVectorDataIOBase.cxx000066400000000000000000000026451301006202600256530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataIOBase.h" namespace otb { VectorDataIOBase ::VectorDataIOBase() : m_ByteOrder(OrderNotApplicable) { this->Reset(false); } void VectorDataIOBase ::Reset(const bool) { m_Initialized = false; m_FileName = ""; } VectorDataIOBase ::~VectorDataIOBase() {} std::string VectorDataIOBase ::GetByteOrderAsString(ByteOrder t) const { std::string s; switch (t) { case BigEndian: return s = "BigEndian"; case LittleEndian: return s = "LittleEndian"; case OrderNotApplicable: default: return s = "OrderNotApplicable"; } } void VectorDataIOBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "FileName: " << m_FileName << std::endl; os << indent << "ByteOrder: " << this->GetByteOrderAsString(m_ByteOrder) << std::endl; } } //namespace otb OTB-release-5.8/Modules/Core/VectorDataBase/src/otbVectorDataKeywordlist.cxx000066400000000000000000000336661301006202600271000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVectorDataKeywordlist.h" #include "otbConfigure.h" #include "itkNumericTraits.h" namespace otb { VectorDataKeywordlist ::VectorDataKeywordlist() { //Nothing to do here } VectorDataKeywordlist ::VectorDataKeywordlist(const Self& other) { *this = other; } VectorDataKeywordlist ::~VectorDataKeywordlist() { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (m_FieldList[i].first->GetType() == OFTString) { VSIFree(m_FieldList[i].second.String); } delete (m_FieldList[i].first); } } void VectorDataKeywordlist ::AddField(OGRFieldDefn* fieldDefn, OGRField* field) { FieldType newField; newField.first = fieldDefn; newField.second = *field; //TODO: evaluate performance impact of fieldDefn copy // the object itself could be handled at the VectorData level // keeping only pointer here. (but it does not seem // necessary so far...) m_FieldList.push_back(CopyOgrField(newField)); } void VectorDataKeywordlist ::AddField(const std::string& key, const std::string& value) { FieldType newField; OGRFieldDefn* fieldDefn = new OGRFieldDefn(key.c_str(), OFTString); OGRField field; char * cstr = (char*)VSIMalloc( (value.length() + 1) * sizeof(char) ); strcpy(cstr, value.c_str()); field.String = cstr; newField.first = fieldDefn; newField.second = field; m_FieldList.push_back(newField); } std::string VectorDataKeywordlist ::GetFieldAsString(const std::string& key) const { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (key.compare(m_FieldList[i].first->GetNameRef()) == 0) { switch(m_FieldList[i].first->GetType()) { case OFTString: { return m_FieldList[i].second.String; } case OFTInteger: { std::ostringstream ss; ss << std::setprecision(15) << m_FieldList[i].second.Integer; return ss.str(); } #ifdef OTB_USE_GDAL_20 case OFTInteger64: { std::ostringstream ss; ss << std::setprecision(15) << m_FieldList[i].second.Integer64; return ss.str(); } #endif case OFTReal: { std::ostringstream ss; ss << std::setprecision(15) << m_FieldList[i].second.Real; return ss.str(); } default: { itkExceptionMacro( << "Type of field " << m_FieldList[i].first->GetNameRef() << " (" << m_FieldList[i].first->GetType() << ") is not handled (yet) by GetFieldAsString(), please request for it"); } } } } return ""; } double VectorDataKeywordlist ::GetFieldAsDouble(const std::string& key) const { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (key.compare(m_FieldList[i].first->GetNameRef()) == 0) { switch (m_FieldList[i].first->GetType()) { case OFTInteger: { return (double)(m_FieldList[i].second.Integer); } case OFTReal: { return (double)(m_FieldList[i].second.Real); } case OFTString: { std::istringstream is(m_FieldList[i].second.String); double value; is >> value; return value; } default: { itkExceptionMacro( << "Type of field " << m_FieldList[i].first->GetNameRef() << " (" << m_FieldList[i].first->GetType() << ") is not handled (yet) by GetFieldAsDouble(), please request for it"); } } } } return 0.; } int VectorDataKeywordlist ::GetFieldAsInt(const std::string& key) const { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (key.compare(m_FieldList[i].first->GetNameRef()) == 0) { switch(m_FieldList[i].first->GetType()) { case OFTInteger: { return (int)(m_FieldList[i].second.Integer); } #ifdef OTB_USE_GDAL_20 // Some fields that were OFTInteger with gdal 1.x are now // exposed as OFTInteger64. So as to make the old code still // work with the same data, here we downcast to Integer (if // and only if no overflow occur). case OFTInteger64: { if(m_FieldList[i].second.Integer64 > itk::NumericTraits::max()) { itkExceptionMacro(<<"value "<GetNameRef()<<" can not be safely casted to 32 bits integer"); } return static_cast(m_FieldList[i].second.Integer64); } #endif case OFTReal: { return (int)(m_FieldList[i].second.Real); } case OFTString: { std::istringstream is(m_FieldList[i].second.String); int value; is >> value; return value; } default: { itkExceptionMacro( << "Type of field " << m_FieldList[i].first->GetNameRef() << " (" << m_FieldList[i].first->GetType() << ") is not handled (yet) by GetFieldAsInt(), please request for it"); } } } } return 0.; } void VectorDataKeywordlist ::SetFieldAsDouble(const std::string& key, double value) { if (HasField(key)) { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (key.compare(m_FieldList[i].first->GetNameRef()) == 0) { if (m_FieldList[i].first->GetType() == OFTReal) { OGRField field; field.Real = value; m_FieldList[i].second = field; } else { itkExceptionMacro(<< "This type is not of double type, can't add the element in it"); } } } } else { FieldType newField; OGRFieldDefn* fieldDefn = new OGRFieldDefn(key.c_str(), OFTReal); OGRField field; field.Real = value; newField.first = fieldDefn; newField.second = field; m_FieldList.push_back(newField); } } void VectorDataKeywordlist ::SetFieldAsInt(const std::string& key, int value) { if (HasField(key)) { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (key.compare(m_FieldList[i].first->GetNameRef()) == 0) { if (m_FieldList[i].first->GetType() == OFTInteger) { OGRField field; field.Integer = value; m_FieldList[i].second = field; } else if (m_FieldList[i].first->GetType() == OFTReal) { OGRField field; field.Real = static_cast(value); m_FieldList[i].second = field; } else { itkExceptionMacro(<< "This type is not of integer type, can't add the element in it"); } } } } else { FieldType newField; OGRFieldDefn* fieldDefn = new OGRFieldDefn(key.c_str(), OFTInteger); OGRField field; field.Integer = value; newField.first = fieldDefn; newField.second = field; m_FieldList.push_back(newField); } } bool VectorDataKeywordlist ::HasField(const std::string& key) const { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (key.compare(m_FieldList[i].first->GetNameRef()) == 0) { return true; } } return false; } void VectorDataKeywordlist ::SetFieldAsString(const std::string& key, const std::string& value) { if (HasField(key)) { for (unsigned int i = 0; i < m_FieldList.size(); ++i) { if (key.compare(m_FieldList[i].first->GetNameRef()) == 0) { if (m_FieldList[i].first->GetType() == OFTString) { OGRField field; char * cstr = (char*)VSIMalloc( (value.length() + 1) * sizeof(char) ); strcpy(cstr, value.c_str()); field.String = cstr; m_FieldList[i].second = field; } else { itkExceptionMacro(<< "This type is not of string type, can't add the element in it"); } } } } else { AddField(key, value); } } VectorDataKeywordlist::FieldType VectorDataKeywordlist ::GetNthField(unsigned int index) const { if (index > m_FieldList.size()) { itkExceptionMacro(<< " Accessing out-of-range metadata "); } return m_FieldList[index]; } unsigned int VectorDataKeywordlist ::GetNumberOfFields() const { return m_FieldList.size(); } std::vector VectorDataKeywordlist ::GetFieldList() const { std::vector res; for (unsigned int i = 0; i < m_FieldList.size(); ++i) { res.push_back((m_FieldList[i].first)->GetNameRef()); } return res; } void VectorDataKeywordlist ::operator =(const Self& p) { for (unsigned int i = 0; i < p.m_FieldList.size(); ++i) { m_FieldList.push_back(CopyOgrField(p.m_FieldList[i])); } } void VectorDataKeywordlist ::Print(std::ostream& os, itk::Indent indent) const { this->PrintSelf(os, indent.GetNextIndent()); } void VectorDataKeywordlist ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << " VectorData Keyword list: "; os << indent << " - Size: " << m_FieldList.size() << std::endl; for (unsigned int i = 0; i < m_FieldList.size(); ++i) { os << indent << " " << PrintField(m_FieldList[i]); } } void VectorDataKeywordlist::CopyFieldList(const Self& kwl) { for (unsigned int idx = 0; idx < kwl.GetNumberOfFields(); ++idx) { switch(kwl.GetNthField(idx).first->GetType()) { case OFTString : { this->SetFieldAsString(kwl.GetNthField(idx).first->GetNameRef(), kwl.GetNthField(idx).second.String); break; } case OFTInteger : { this->SetFieldAsInt(kwl.GetNthField(idx).first->GetNameRef(), kwl.GetNthField(idx).second.Integer); break; } case OFTReal : { this->SetFieldAsDouble(kwl.GetNthField(idx).first->GetNameRef(), kwl.GetNthField(idx).second.Real); break; } default: { std::cerr << "Type not handled for Integer conversion"<GetNameRef() << " ("; output << field.first->GetFieldTypeName(field.first->GetType()) << "): "; switch (field.first->GetType()) { case OFTInteger: { output << field.second.Integer; break; } case OFTReal: { output << field.second.Real; break; } case OFTString: { if (field.second.String != ITK_NULLPTR) { output << field.second.String; } break; } case OFTDate: { output << field.second.Date.Year << field.second.Date.Month << field.second.Date.Day; break; } case OFTTime: { output << field.second.Date.Hour << field.second.Date.Minute << field.second.Date.Second; break; } case OFTDateTime: { output << field.second.Date.Year << field.second.Date.Month << field.second.Date.Day << "-" << field.second.Date.Hour << field.second.Date.Minute << field.second.Date.Second; break; } #ifdef OTB_USE_GDAL_20 case OFTInteger64: { output << std::setprecision(15)<GetType()) { case OFTInteger: { outField.second.Integer = field.second.Integer; break; } #ifdef OTB_USE_GDAL_20 case OFTInteger64: { outField.second.Integer64 = field.second.Integer64; break; } #endif case OFTReal: { outField.second.Real = field.second.Real; break; } case OFTString: { if (field.second.String != ITK_NULLPTR) { CPLFree(outField.second.String); outField.second.String = CPLStrdup(field.second.String); } break; } case OFTDate: { outField.second.Date.Year = field.second.Date.Year; outField.second.Date.Month = field.second.Date.Month; outField.second.Date.Day = field.second.Date.Day; break; } case OFTTime: { outField.second.Date.Hour = field.second.Date.Hour; outField.second.Date.Minute = field.second.Date.Minute; outField.second.Date.Second = field.second.Date.Second; break; } case OFTDateTime: { outField.second.Date.Year = field.second.Date.Year; outField.second.Date.Month = field.second.Date.Month; outField.second.Date.Day = field.second.Date.Day; outField.second.Date.Hour = field.second.Date.Hour; outField.second.Date.Minute = field.second.Date.Minute; outField.second.Date.Second = field.second.Date.Second; break; } default: { std::cerr << "OGR type not handled" << std::endl; break; } } return outField; } std::ostream & operator <<(std::ostream& os, const VectorDataKeywordlist& kwl) { kwl.Print(os); return os; } } OTB-release-5.8/Modules/Core/VectorDataBase/test/000077500000000000000000000000001301006202600215245ustar00rootroot00000000000000OTB-release-5.8/Modules/Core/VectorDataBase/test/CMakeLists.txt000066400000000000000000000044761301006202600242770ustar00rootroot00000000000000otb_module_test() set(OTBVectorDataBaseTests otbVectorDataBaseTestDriver.cxx otbVectorData.cxx otbVectorDataKeywordlistTest.cxx otbPolygon.cxx otbVectorDataSourceNew.cxx otbDataNodeTest.cxx otbRemoteSensingRegion.cxx otbPolygonNew.cxx otbPolyLineParametricPathWithValueNew.cxx otbRemoteSensingRegionNew.cxx otbVectorDataNew.cxx ) add_executable(otbVectorDataBaseTestDriver ${OTBVectorDataBaseTests}) target_link_libraries(otbVectorDataBaseTestDriver ${OTBVectorDataBase-Test_LIBRARIES}) otb_module_target_label(otbVectorDataBaseTestDriver) # Tests Declaration otb_add_test(NAME coTvVectorData COMMAND otbVectorDataBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/coTvVectorData.txt ${TEMP}/coTvVectorData.txt --ignore-lines-with 1 RTTI otbVectorData ${TEMP}/coTvVectorData.txt ) otb_add_test(NAME ioTuVectorDataKeywordlistNew COMMAND otbVectorDataBaseTestDriver otbVectorDataKeywordlistNew ) otb_add_test(NAME ioTvVectorDataKeywordlist COMMAND otbVectorDataBaseTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTuVectorDataKeywordlist.txt ${TEMP}/ioTuVectorDataKeywordlist.txt otbVectorDataKeywordlist ${INPUTDATA}/waterways.shp ${TEMP}/ioTuVectorDataKeywordlist.txt ) otb_add_test(NAME coTvPolygon COMMAND otbVectorDataBaseTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/otbPolygonTest.txt ${TEMP}/otbPolygonTest.txt otbPolygon ${TEMP}/otbPolygonTest.txt 2 10 7 10 7 9 5 9 5 8 7 8 7 6 9 6 9 5 7 5 7 3 2 3 next 6 10 11 10 11 2 4 2 3 4 8 4 8 7 6 7 ) otb_add_test(NAME coTuVectorDataSource COMMAND otbVectorDataBaseTestDriver otbVectorDataSourceNew ) otb_add_test(NAME coTvDataNode COMMAND otbVectorDataBaseTestDriver otbDataNodeTest ) otb_add_test(NAME coTvRemoteSensingRegion COMMAND otbVectorDataBaseTestDriver otbRemoteSensingRegion 1.21 2.33 58.47 59.49 #size et index of the region 0. 0. # Point to check ) otb_add_test(NAME coTuPolygonNew COMMAND otbVectorDataBaseTestDriver otbPolygonNew) otb_add_test(NAME coTuPolyLineParametricPathWithValueNew COMMAND otbVectorDataBaseTestDriver otbPolyLineParametricPathWithValueNew) otb_add_test(NAME coTuRemoteSensingRegionNew COMMAND otbVectorDataBaseTestDriver otbRemoteSensingRegionNew ) otb_add_test(NAME coTuVectorData COMMAND otbVectorDataBaseTestDriver otbVectorDataNew ) OTB-release-5.8/Modules/Core/VectorDataBase/test/otbDataNodeTest.cxx000066400000000000000000000067651301006202600253120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include #include "otbDataNode.h" int otbDataNodeTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::DataNode DataNodeType; typedef DataNodeType::PointType PointType; typedef DataNodeType::LineType LineType; typedef DataNodeType::PolygonType PolygonType; DataNodeType::Pointer root = DataNodeType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder = DataNodeType::New(); DataNodeType::Pointer point = DataNodeType::New(); DataNodeType::Pointer line = DataNodeType::New(); DataNodeType::Pointer polygon = DataNodeType::New(); root->SetNodeType(otb::ROOT); document->SetNodeType(otb::DOCUMENT); folder->SetNodeType(otb::FOLDER); point->SetNodeType(otb::FEATURE_POINT); line->SetNodeType(otb::FEATURE_LINE); polygon->SetNodeType(otb::FEATURE_POLYGON); root->SetNodeId("ROOT"); document->SetNodeId("DOCUMENT"); folder->SetNodeId("FOLDER"); point->SetNodeId("FEATURE_POINT"); line->SetNodeId("FEATURE_LINE"); polygon->SetNodeId("FEATURE_POLYGON"); PointType p; p.Fill(5); point->SetPoint(p); LineType::Pointer l = LineType::New(); line->SetLine(l); PolygonType::Pointer pol = PolygonType::New(); polygon->SetPolygonExteriorRing(pol); otbControlConditionTestMacro(!root->IsRoot(), "Wrong IsRoot() method return."); otbControlConditionTestMacro(root->IsDocument(), "Wrong IsDocument() method return."); otbControlConditionTestMacro(root->IsFolder(), "Wrong IsFolder() method return."); otbControlConditionTestMacro(root->IsPointFeature(), "Wrong IsPointFeature() method return."); otbControlConditionTestMacro(root->IsLineFeature(), "Wrong IsLineFeature() method return."); otbControlConditionTestMacro(root->IsPolygonFeature(), "Wrong IsPolygonFeature() method return."); otbControlConditionTestMacro(document->IsRoot(), "Wrong IsRoot() method return."); otbControlConditionTestMacro(!document->IsDocument(), "Wrong IsDocument() method return."); otbControlConditionTestMacro(document->IsFolder(), "Wrong IsFolder() method return."); otbControlConditionTestMacro(document->IsPointFeature(), "Wrong IsPointFeature() method return."); otbControlConditionTestMacro(document->IsLineFeature(), "Wrong IsLineFeature() method return."); otbControlConditionTestMacro(document->IsPolygonFeature(), "Wrong IsPolygonFeature() method return."); otbControlConditionTestMacro(folder->IsRoot(), "Wrong IsRoot() method return."); otbControlConditionTestMacro(folder->IsDocument(), "Wrong IsDocument() method return."); otbControlConditionTestMacro(!folder->IsFolder(), "Wrong IsFolder() method return."); otbControlConditionTestMacro(folder->IsPointFeature(), "Wrong IsPointFeature() method return."); otbControlConditionTestMacro(folder->IsLineFeature(), "Wrong IsLineFeature() method return."); otbControlConditionTestMacro(folder->IsPolygonFeature(), "Wrong IsPolygonFeature() method return."); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbPolyLineParametricPathWithValueNew.cxx000066400000000000000000000022311301006202600316360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbPolyLineParametricPathWithValue.h" int otbPolyLineParametricPathWithValueNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double ValueType; typedef otb::PolyLineParametricPathWithValue PolyLineParametricPathWithValueType; // Instantiating object PolyLineParametricPathWithValueType::Pointer object = PolyLineParametricPathWithValueType::New(); object->SetValue(0); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbPolygon.cxx000066400000000000000000000177251301006202600244200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbPolygon.h" int otbPolygon(int itkNotUsed(argc), char * argv[]) { typedef otb::Polygon<> PolygonType; typedef PolygonType::ContinuousIndexType ContinuousIndexType; typedef PolygonType::VertexListType VertexListType; typedef VertexListType::ConstIterator IteratorType; // Instantiating object PolygonType::Pointer polygon1 = PolygonType::New(); PolygonType::Pointer polygon2 = PolygonType::New(); const char * outfile = argv[1]; // Reading vertices from command line int cpt = 2; bool first = true; while (argv[cpt] != ITK_NULLPTR && argv[cpt + 1] != ITK_NULLPTR) { if (argv[cpt][0] == 'n') { first = false; ++cpt; } else { ContinuousIndexType newVertex; newVertex[0] = atof(argv[cpt]); newVertex[1] = atof(argv[cpt + 1]); if (first) polygon1->AddVertex(newVertex); else polygon2->AddVertex(newVertex); ++cpt; ++cpt; } } IteratorType begin1 = polygon1->GetVertexList()->Begin(); IteratorType end1 = polygon1->GetVertexList()->End(); IteratorType begin2 = polygon2->GetVertexList()->Begin(); IteratorType end2 = polygon2->GetVertexList()->End(); IteratorType it; ContinuousIndexType current, firstVertex; std::ofstream file; file.open(outfile); for (it = begin1; it != end1; ++it) { file << "polygon1->IsInside(" << it.Value() << ") = " << polygon1->IsInside(it.Value()) << std::endl; file << "polygon1->IsOnEdge(" << it.Value() << ") = " << polygon1->IsOnEdge(it.Value()) << std::endl; file << "polygon2->IsInside(" << it.Value() << ") = " << polygon2->IsInside(it.Value()) << std::endl; file << "polygon2->IsOnEdge(" << it.Value() << ") = " << polygon2->IsOnEdge(it.Value()) << std::endl; } file << std::endl << std::endl; for (it = begin2; it != end2; ++it) { file << "polygon1->IsInside(" << it.Value() << ") = " << polygon1->IsInside(it.Value()) << std::endl; file << "polygon1->IsOnEdge(" << it.Value() << ") = " << polygon1->IsOnEdge(it.Value()) << std::endl; file << "polygon2->IsInside(" << it.Value() << ") = " << polygon2->IsInside(it.Value()) << std::endl; file << "polygon2->IsOnEdge(" << it.Value() << ") = " << polygon2->IsOnEdge(it.Value()) << std::endl; } file << std::endl << std::endl; current = begin1.Value(); firstVertex = current; ++begin1; for (it = begin1; it != end1; ++it) { file << "polygon1->NbCrossing(" << current << ", " << it.Value() << ") = " << polygon1->NbCrossing(current, it.Value()) << std::endl; file << "polygon1->NbTouching(" << current << ", " << it.Value() << ") = " << polygon1->NbTouching(current, it.Value()) << std::endl; file << "polygon2->NbCrossing(" << current << ", " << it.Value() << ") = " << polygon2->NbCrossing(current, it.Value()) << std::endl; file << "polygon2->NbTouching(" << current << ", " << it.Value() << ") = " << polygon2->NbTouching(current, it.Value()) << std::endl; current = it.Value(); } file << "polygon1->NbCrossing(" << current << ", " << firstVertex << ") = " << polygon1->NbCrossing(current, firstVertex) << std::endl; file << "polygon1->NbTouching(" << current << ", " << firstVertex << ") = " << polygon1->NbTouching(current, firstVertex) << std::endl; file << "polygon2->NbCrossing(" << current << ", " << firstVertex << ") = " << polygon2->NbCrossing(current, firstVertex) << std::endl; file << "polygon2->NbTouching(" << current << ", " << firstVertex << ") = " << polygon2->NbTouching(current, firstVertex) << std::endl; file << std::endl << std::endl; current = begin2.Value(); firstVertex = current; ++begin2; for (it = begin2; it != end2; ++it) { file << "polygon1->NbCrossing(" << current << ", " << it.Value() << ") = " << polygon1->NbCrossing(current, it.Value()) << std::endl; file << "polygon1->NbTouching(" << current << ", " << it.Value() << ") = " << polygon1->NbTouching(current, it.Value()) << std::endl; file << "polygon2->NbCrossing(" << current << ", " << it.Value() << ") = " << polygon2->NbCrossing(current, it.Value()) << std::endl; file << "polygon2->NbTouching(" << current << ", " << it.Value() << ") = " << polygon2->NbTouching(current, it.Value()) << std::endl; current = it.Value(); } file << "polygon1->NbCrossing(" << current << ", " << firstVertex << ") = " << polygon1->NbCrossing(current, firstVertex) << std::endl; file << "polygon1->NbTouching(" << current << ", " << firstVertex << ") = " << polygon1->NbTouching(current, firstVertex) << std::endl; file << "polygon2->NbCrossing(" << current << ", " << firstVertex << ") = " << polygon2->NbCrossing(current, firstVertex) << std::endl; file << "polygon2->NbTouching(" << current << ", " << firstVertex << ") = " << polygon2->NbTouching(current, firstVertex) << std::endl; file << std::endl << std::endl; file << "Bounding Boxs computation : " << std::endl; PolygonType::RegionType r1 = polygon1->GetBoundingRegion(); file << "Bounding Box 1" << std::endl; file << "Index : " << r1.GetIndex() << " , Size : " << r1.GetSize() << std::endl; PolygonType::RegionType r2 = polygon2->GetBoundingRegion(); file << "Bounding Box 2" << std::endl; file << "Index : " << r2.GetIndex() << " , Size : " << r2.GetSize() << std::endl; file << std::endl << std::endl; file << "Surface computation : " << std::endl; file << "Surface 1 :" << (double) polygon1->GetArea() << std::endl; file << "Surface 2 :" << polygon2->GetArea() << std::endl; file << std::endl << std::endl; file << "Length computation : " << std::endl; file << "Length 1 :" << (double) polygon1->GetLength() << std::endl; file << "Length 2 :" << polygon2->GetLength() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbPolygonNew.cxx000066400000000000000000000015541301006202600250630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbPolygon.h" int otbPolygonNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PolygonType; // Instantiating object PolygonType::Pointer polygon = PolygonType::New(); std::cout << polygon << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbRemoteSensingRegion.cxx000066400000000000000000000045611301006202600267110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRemoteSensingRegion.h" int otbRemoteSensingRegion(int itkNotUsed(argc), char * argv[]) { typedef double Type; const Type startX = atof(argv[1]); const Type startY = atof(argv[2]); const Type sizeX = atof(argv[3]); const Type sizeY = atof(argv[4]); const Type pointX = atof(argv[5]); const Type pointY = atof(argv[6]); typedef otb::RemoteSensingRegion TypedRegion; TypedRegion region; /** */ TypedRegion::SizeType size; TypedRegion::IndexType index, indexPt; size[0] = sizeX; size[1] = sizeY; index[0] = startX; index[1] = startY; region.SetSize(size); region.SetOrigin(index); /** Check if the segment is inside the region*/ indexPt[0] = pointX; indexPt[1] = pointY; if (region.IsInside(indexPt)) std::cout << "Le point " << indexPt[0] << "," << indexPt[1] << " is inside the region " << std::endl; else std::cout << "Le point is OUTSIDE the region " << std::endl; /*Set the projection */ std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; region.SetRegionProjection(projectionRefWkt); std::cout << "The projection set is " << region.GetRegionProjection() << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbRemoteSensingRegionNew.cxx000066400000000000000000000015701301006202600273600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRemoteSensingRegion.h" int otbRemoteSensingRegionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double Type; typedef otb::RemoteSensingRegion TypedRegion; TypedRegion Cartoregion; std::cout << Cartoregion << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbVectorData.cxx000066400000000000000000000045441301006202600250200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include #include "otbVectorData.h" int otbVectorData(int argc, char * argv[]) { typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::PointType PointType; typedef DataNodeType::LineType LineType; typedef DataNodeType::PolygonType PolygonType; //Instantiation VectorDataType::Pointer data = VectorDataType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder = DataNodeType::New(); DataNodeType::Pointer point = DataNodeType::New(); DataNodeType::Pointer line = DataNodeType::New(); DataNodeType::Pointer polygon = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder->SetNodeType(otb::FOLDER); point->SetNodeType(otb::FEATURE_POINT); line->SetNodeType(otb::FEATURE_LINE); polygon->SetNodeType(otb::FEATURE_POLYGON); document->SetNodeId("DOCUMENT"); folder->SetNodeId("FOLDER"); point->SetNodeId("FEATURE_POINT"); line->SetNodeId("FEATURE_LINE"); polygon->SetNodeId("FEATURE_POLYGON"); PointType p; p.Fill(5); point->SetPoint(p); LineType::Pointer l = LineType::New(); line->SetLine(l); PolygonType::Pointer pol = PolygonType::New(); polygon->SetPolygonExteriorRing(pol); DataNodeType::Pointer root = data->GetDataTree()->GetRoot()->Get(); data->GetDataTree()->Add(document, root); data->GetDataTree()->Add(folder, document); data->GetDataTree()->Add(point, folder); data->GetDataTree()->Add(line, folder); data->GetDataTree()->Add(polygon, folder); if (argc < 2) { std::cout << data << std::endl; } else { const char * outfile = argv[1]; std::ofstream file; file.open(outfile); file << data << std::endl; file.close(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbVectorDataBaseTestDriver.cxx000066400000000000000000000007431301006202600276240ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbVectorData); REGISTER_TEST(otbVectorDataKeywordlistNew); REGISTER_TEST(otbVectorDataKeywordlist); REGISTER_TEST(otbPolygon); REGISTER_TEST(otbVectorDataSourceNew); REGISTER_TEST(otbDataNodeTest); REGISTER_TEST(otbRemoteSensingRegion); REGISTER_TEST(otbPolygonNew); REGISTER_TEST(otbPolyLineParametricPathWithValueNew); REGISTER_TEST(otbRemoteSensingRegionNew); REGISTER_TEST(otbVectorDataNew); } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbVectorDataKeywordlistTest.cxx000066400000000000000000000053601301006202600301160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbVectorDataKeywordlist.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbMetaDataKey.h" int otbVectorDataKeywordlistNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::VectorDataKeywordlist kwl; std::cout << kwl << std::endl; return EXIT_SUCCESS; } int otbVectorDataKeywordlist(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); typedef otb::DataNode DataNodeType; typedef DataNodeType::Pointer DataNodePointerType; typedef itk::TreeContainer DataTreeType; itk::Indent indent; reader->SetFileName(argv[1]); reader->Update(); VectorDataType::Pointer data = reader->GetOutput(); DataTreeType::Pointer dataTree = DataTreeType::New(); dataTree = data->GetDataTree(); std::ofstream fout (argv[2]); itk::PreOrderTreeIterator it(dataTree); it.GoToBegin(); while (!it.IsAtEnd()) { itk::PreOrderTreeIterator itParent = it; bool goesOn = true; while (itParent.HasParent() && goesOn) { fout << indent; goesOn = itParent.GoToParent(); } if (it.Get()->GetMetaDataDictionary().HasKey(otb::MetaDataKey::VectorDataKeywordlistKey)) { otb::VectorDataKeywordlist kwl; kwl.GetNameOfClass(); itk::ExposeMetaData(it.Get()->GetMetaDataDictionary(), otb::MetaDataKey::VectorDataKeywordlistKey, kwl); fout << "New node: " << kwl.GetNumberOfFields() << " fields" << std::endl; fout << "- HasField(\"name\"): " << kwl.HasField("name") << std::endl; if (kwl.HasField("name")) { fout << "- name: " << kwl.GetFieldAsString("name") << std::endl; } fout << std::endl; } ++it; } /*added PrintSelf*/ fout.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbVectorDataNew.cxx000066400000000000000000000015501301006202600254640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbVectorData.h" int otbVectorDataNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorData VectorDataType; //Instantiation VectorDataType::Pointer data = VectorDataType::New(); std::cout << data << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Core/VectorDataBase/test/otbVectorDataSourceNew.cxx000066400000000000000000000022071301006202600266450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorDataSource.h" #include "otbVectorData.h" int otbVectorDataSourceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::VectorData InputVectorDataType; typedef otb::VectorDataSource VectorDataSourceType; // Instantiating VectorDataSource object VectorDataSourceType::Pointer vectorData = VectorDataSourceType::New(); std::cout << vectorData << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/000077500000000000000000000000001301006202600167445ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/CloudDetection/000077500000000000000000000000001301006202600216515ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/CloudDetection/CMakeLists.txt000066400000000000000000000000551301006202600244110ustar00rootroot00000000000000project(OTBCloudDetection) otb_module_impl() OTB-release-5.8/Modules/Detection/CloudDetection/include/000077500000000000000000000000001301006202600232745ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/CloudDetection/include/otbCloudDetectionFilter.h000066400000000000000000000055111301006202600302270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCloudDetectionFilter_h #define otbCloudDetectionFilter_h #include "otbCloudDetectionFunctor.h" #include "itkUnaryFunctorImageFilter.h" namespace otb { /** \class CloudDetectionFilter * \brief Applies cloud detection functor to an image. * * \ingroup OTBCloudDetection */ template > class ITK_EXPORT CloudDetectionFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef CloudDetectionFilter Self; typedef typename itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(CloudDetectionFilter, UnaryFunctorImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; /** Getters/Setters */ void SetReferencePixel(InputPixelType ref); void SetVariance(double var); void SetMinThreshold(double threshold); void SetMaxThreshold(double threshold); InputPixelType GetReferencePixel(); double GetMinThreshold(); double GetMaxThreshold(); double GetVariance(); protected: CloudDetectionFilter(); ~CloudDetectionFilter() ITK_OVERRIDE {} void BeforeThreadedGenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: CloudDetectionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbCloudDetectionFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/CloudDetection/include/otbCloudDetectionFilter.txx000066400000000000000000000071071301006202600306260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCloudDetectionFilter_txx #define otbCloudDetectionFilter_txx #include "otbCloudDetectionFilter.h" namespace otb { /** * Constructor */ template CloudDetectionFilter ::CloudDetectionFilter() { } /** * Printself */ template void CloudDetectionFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } /** * BeforeThreadedGenerateData */ template void CloudDetectionFilter ::BeforeThreadedGenerateData() { unsigned int ReferencePixelNumberOfBands = 0; ReferencePixelNumberOfBands = this->GetReferencePixel().GetSize(); if (ReferencePixelNumberOfBands != this->GetInput()->GetNumberOfComponentsPerPixel()) { itkExceptionMacro( "The number of bands of the reference pixel is different from the number of bands of the input image. "); } } /** * SetVariance */ template void CloudDetectionFilter ::SetVariance(double var) { this->GetFunctor().SetVariance(var); } /** * GetVariance */ template double CloudDetectionFilter ::GetVariance() { return this->GetFunctor().GetVariance(); } /** * SetReferencePixel */ template void CloudDetectionFilter ::SetReferencePixel(InputPixelType ref) { this->GetFunctor().SetReferencePixel(ref); } /** * GetReferencePixel */ template typename CloudDetectionFilter::InputPixelType CloudDetectionFilter ::GetReferencePixel() { return this->GetFunctor().GetReferencePixel(); } /** * SetMinThreshold */ template void CloudDetectionFilter ::SetMinThreshold(double threshold) { this->GetFunctor().SetMinThreshold(threshold); } /** * SetMaxThreshold */ template void CloudDetectionFilter ::SetMaxThreshold(double threshold) { this->GetFunctor().SetMaxThreshold(threshold); } /** * GetMinThreshold */ template double CloudDetectionFilter ::GetMinThreshold() { return this->GetFunctor().GetMinThreshold(); } /** * GetMaxThreshold */ template double CloudDetectionFilter ::GetMaxThreshold() { return this->GetFunctor().GetMaxThreshold(); } } #endif OTB-release-5.8/Modules/Detection/CloudDetection/include/otbCloudDetectionFunctor.h000066400000000000000000000044001301006202600304160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCloudDetectionFunctor_h #define otbCloudDetectionFunctor_h #include "otbCloudEstimatorFunctor.h" namespace otb { /** \class CloudDetectionFunctor * \brief This functor first uses CloudEstimatorFunctor * \brief And then binarise the image with two thresholds * * \ingroup OTBCloudDetection */ namespace Functor { template class CloudDetectionFunctor { public: typedef CloudEstimatorFunctor CloudEstimatorFunctorType; CloudDetectionFunctor() { m_MinThreshold = 0.0; m_MaxThreshold = 1.0; } virtual ~CloudDetectionFunctor() {} inline TOutputValue operator ()(const TInput& inPix) { if ((m_CloudEstimatorFunctor(inPix) > m_MinThreshold) && (m_CloudEstimatorFunctor(inPix) <= m_MaxThreshold)) { return 1; } else { return 0; } } void SetReferencePixel(TInput ref) { m_CloudEstimatorFunctor.SetReferencePixel(ref); } void SetVariance(double variance) { m_CloudEstimatorFunctor.SetVariance(variance); } void SetMinThreshold(double threshold) { m_MinThreshold = threshold; } void SetMaxThreshold(double threshold) { m_MaxThreshold = threshold; } double GetMinThreshold() { return m_MinThreshold; } double GetMaxThreshold() { return m_MaxThreshold; } double GetVariance() { return m_CloudEstimatorFunctor.GetVariance(); } TInput GetReferencePixel() { return m_CloudEstimatorFunctor.GetReferencePixel(); } protected: CloudEstimatorFunctorType m_CloudEstimatorFunctor; double m_MinThreshold; double m_MaxThreshold; }; } // end namespace functor } // end namespace otb #endif OTB-release-5.8/Modules/Detection/CloudDetection/include/otbCloudEstimatorFilter.h000066400000000000000000000055651301006202600302710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCloudEstimatorFilter_h #define otbCloudEstimatorFilter_h #include "otbSpectralAngleFunctor.h" #include "itkUnaryFunctorImageFilter.h" namespace otb { /** \class CloudEstimatorFilter * \brief Filter to help with the cloud detection * * Applies spectral angle functor to an image. * Multiplies by a Gaussian coefficient * Applies a color reversal. * * \example FeatureExtraction/CloudDetectionExample.cxx * * \ingroup OTBCloudDetection */ template > class ITK_EXPORT CloudEstimatorFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef CloudEstimatorFilter Self; typedef typename itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(CloudEstimatorFilter, UnaryFunctorImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; /** Getters/Setters */ void SetReferencePixel(InputPixelType ref); InputPixelType GetReferencePixel() const; void SetVariance(double var); double GetVariance() const; protected: CloudEstimatorFilter(); ~CloudEstimatorFilter() ITK_OVERRIDE {} void BeforeThreadedGenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: CloudEstimatorFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbCloudEstimatorFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/CloudDetection/include/otbCloudEstimatorFilter.txx000066400000000000000000000052771301006202600306650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCloudEstimatorFilter_txx #define otbCloudEstimatorFilter_txx #include "otbCloudEstimatorFilter.h" namespace otb { /** * Constructor */ template CloudEstimatorFilter ::CloudEstimatorFilter() { } /** * Printself */ template void CloudEstimatorFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } /** * BeforeThreadedGenerateData */ template void CloudEstimatorFilter ::BeforeThreadedGenerateData() { unsigned int ReferencePixelNumberOfBands = 0; ReferencePixelNumberOfBands = this->GetReferencePixel().GetSize(); if (ReferencePixelNumberOfBands != this->GetInput()->GetNumberOfComponentsPerPixel()) { itkExceptionMacro( "The number of bands of the reference pixel is different from the number of bands of the input image. "); } } /** * SetVariance */ template void CloudEstimatorFilter ::SetVariance(double var) { this->GetFunctor().SetVariance(var); this->Modified(); } /** * GetVariance */ template double CloudEstimatorFilter ::GetVariance() const { return this->GetFunctor().GetVariance(); } /** * SetReferencePixel */ template void CloudEstimatorFilter ::SetReferencePixel(InputPixelType ref) { this->GetFunctor().SetReferencePixel(ref); this->Modified(); } /** * GetReferencePixel */ template typename CloudEstimatorFilter::InputPixelType CloudEstimatorFilter ::GetReferencePixel() const { return this->GetFunctor().GetReferencePixel(); } } #endif OTB-release-5.8/Modules/Detection/CloudDetection/include/otbCloudEstimatorFunctor.h000066400000000000000000000056561301006202600304650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCloudEstimatorFunctor_h #define otbCloudEstimatorFunctor_h #include "otbSpectralAngleFunctor.h" namespace otb { namespace Functor { /** \class CloudEstimatorFunctor * \brief Functor to help with the cloud detection * * This functor first computes the spectral angle according to a reference pixel. * Then multiplies the result by a Gaussian coefficient * And reverse the pixel values. * * \ingroup OTBCloudDetection */ template class CloudEstimatorFunctor { public: typedef SpectralAngleFunctor SpectralAngleFunctorType; CloudEstimatorFunctor() { m_ReferencePixel.SetSize(4); m_ReferencePixel.Fill(1); m_RefNorm = 2.0; m_Variance = 1.0; m_Denom = 1.0; } virtual ~CloudEstimatorFunctor() {} inline TOutputValue operator ()(const TInput& inPix) const { TOutputValue lOut; double lRes = 0.0; double lCurPixNorm = 0.0; double lGaussianCoef = 1.0; // Compute the Gaussian Coef for (unsigned int i = 0; i < std::min(inPix.Size(), m_ReferencePixel.Size()); ++i) { lCurPixNorm += inPix[i] * inPix[i]; } lCurPixNorm = vcl_sqrt(static_cast(lCurPixNorm)); lGaussianCoef = vcl_exp(-vcl_pow((lCurPixNorm - m_RefNorm), 2) / m_Denom); // Reverse the SpectralAngle values and set them between [0; 1] lRes = lGaussianCoef * ((CONST_PI - m_SpectralAngleFunctor(inPix)) / CONST_PI); lOut = static_cast(lRes); return lOut; } void SetReferencePixel(TInput ref) { m_ReferencePixel = ref; m_SpectralAngleFunctor.SetReferencePixel(ref); m_RefNorm = 0.0; for (unsigned int i = 0; i < ref.Size(); ++i) { m_RefNorm += ref[i] * ref[i]; } m_RefNorm = vcl_sqrt(static_cast(m_RefNorm)); SetVariance(m_Variance); } void SetVariance(double variance) { m_Variance = variance; m_Denom = 2 * variance * variance * m_RefNorm * m_RefNorm; } TInput GetReferencePixel() const { return m_ReferencePixel; } double GetVariance() const { return m_Variance; } protected: SpectralAngleFunctorType m_SpectralAngleFunctor; TInput m_ReferencePixel; double m_RefNorm; double m_Variance; double m_Denom; }; } // end namespace functor } // end namespace otb #endif OTB-release-5.8/Modules/Detection/CloudDetection/otb-module.cmake000066400000000000000000000006401301006202600247220ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes to estimate and detect clouds. The implemented filters rely on the spectral angle principle to measure the radiometric gap between a reference pixel and the other pixels of the image.") otb_module(OTBCloudDetection DEPENDS OTBITK OTBImageManipulation TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Detection/CloudDetection/test/000077500000000000000000000000001301006202600226305ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/CloudDetection/test/CMakeLists.txt000066400000000000000000000033361301006202600253750ustar00rootroot00000000000000otb_module_test() set(OTBCloudDetectionTests otbCloudDetectionTestDriver.cxx otbCloudEstimatorDefaultFilter.cxx otbCloudDetectionFilter.cxx otbCloudEstimatorFilter.cxx otbCloudEstimatorFilterNew.cxx otbCloudDetectionFilterNew.cxx ) add_executable(otbCloudDetectionTestDriver ${OTBCloudDetectionTests}) target_link_libraries(otbCloudDetectionTestDriver ${OTBCloudDetection-Test_LIBRARIES}) otb_module_target_label(otbCloudDetectionTestDriver) # Tests Declaration otb_add_test(NAME feTvCloudEstimatorDefaultFilter COMMAND otbCloudDetectionTestDriver --compare-image ${EPSILON_3} ${BASELINE}/feTvSpectralAngleOutput.tif ${TEMP}/feTvSpectralAngleOutput.tif otbCloudEstimatorDefaultFilter ${INPUTDATA}/ExtrZoneNuageuse.tif ${TEMP}/feTvSpectralAngleOutput.tif 500 731 500 632 ) otb_add_test(NAME feTvCloudDetectionFilter COMMAND otbCloudDetectionTestDriver --compare-image ${EPSILON_3} ${BASELINE}/feTvCloudDetectionOutput.tif ${TEMP}/feTvCloudDetectionOutput.tif otbCloudDetectionFilter ${INPUTDATA}/ExtrZoneNuageuse.tif ${TEMP}/feTvCloudDetectionOutput.tif 500 731 500 632 0.25 # variance 0.95 # minthreshold 1.0 # maxthreshold ) otb_add_test(NAME feTvCloudEstimatorFilter COMMAND otbCloudDetectionTestDriver --compare-image ${EPSILON_3} ${BASELINE}/feTvCloudEstimatorOutput.tif ${TEMP}/feTvCloudEstimatorOutput.tif otbCloudEstimatorFilter ${INPUTDATA}/ExtrZoneNuageuse.tif ${TEMP}/feTvCloudEstimatorOutput.tif 500 731 500 632 0.25 # variance ) otb_add_test(NAME feTuCloudEstimatorFilterNew COMMAND otbCloudDetectionTestDriver otbCloudEstimatorFilterNew) otb_add_test(NAME feTuCloudDetectionFilterNew COMMAND otbCloudDetectionTestDriver otbCloudDetectionFilterNew) OTB-release-5.8/Modules/Detection/CloudDetection/test/otbCloudDetectionFilter.cxx000066400000000000000000000053501301006202600301370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbCloudDetectionFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbCloudDetectionFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef VectorImageType::PixelType VectorPixelType; typedef otb::Functor::CloudDetectionFunctor FunctorType; typedef otb::CloudDetectionFilter CloudDetectionFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; //Parameters const char * inputFileName(argv[1]); const char * outputFileName(argv[2]); VectorPixelType referencePixel; referencePixel.SetSize(4); referencePixel.Fill(0.); referencePixel[0] = (atof(argv[3])); referencePixel[1] = (atof(argv[4])); referencePixel[2] = (atof(argv[5])); referencePixel[3] = (atof(argv[6])); const double variance = (atof(argv[7])); const double minThreshold = (atof(argv[8])); const double maxThreshold = (atof(argv[9])); // Instantiating object ReaderType::Pointer reader = ReaderType::New(); CloudDetectionFilterType::Pointer cloudDetection = CloudDetectionFilterType::New(); WriterType::Pointer writer = WriterType::New(); //Initialization parameters reader->SetFileName(inputFileName); cloudDetection->SetInput(reader->GetOutput()); cloudDetection->SetReferencePixel(referencePixel); cloudDetection->SetMinThreshold(minThreshold); cloudDetection->SetMaxThreshold(maxThreshold); cloudDetection->SetVariance(variance); writer->SetFileName(outputFileName); writer->SetInput(cloudDetection->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/CloudDetection/test/otbCloudDetectionFilterNew.cxx000066400000000000000000000024061301006202600306100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbCloudDetectionFilter.h" int otbCloudDetectionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::CloudDetectionFilter CloudDetectionFilterType; // Instantiating object CloudDetectionFilterType::Pointer filter = CloudDetectionFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/CloudDetection/test/otbCloudDetectionTestDriver.cxx000066400000000000000000000004211301006202600307770ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbCloudEstimatorDefaultFilter); REGISTER_TEST(otbCloudDetectionFilter); REGISTER_TEST(otbCloudEstimatorFilter); REGISTER_TEST(otbCloudEstimatorFilterNew); REGISTER_TEST(otbCloudDetectionFilterNew); } OTB-release-5.8/Modules/Detection/CloudDetection/test/otbCloudEstimatorDefaultFilter.cxx000066400000000000000000000045161301006202600315000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbCloudEstimatorFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbCloudEstimatorDefaultFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef VectorImageType::PixelType VectorPixelType; typedef otb::CloudEstimatorFilter CloudEstimatorFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; //Parameters const char * inputFileName(argv[1]); const char * outputFileName(argv[2]); VectorPixelType referencePixel; referencePixel.SetSize(4); referencePixel.Fill(0.); referencePixel[0] = (atof(argv[3])); referencePixel[1] = (atof(argv[4])); referencePixel[2] = (atof(argv[5])); referencePixel[3] = (atof(argv[6])); // Instantiating object ReaderType::Pointer reader = ReaderType::New(); // Using SpectralAngle Filter, the default functor CloudEstimatorFilterType::Pointer cloudEstimator = CloudEstimatorFilterType::New(); WriterType::Pointer writer = WriterType::New(); //Initialization parameters reader->SetFileName(inputFileName); cloudEstimator->SetInput(reader->GetOutput()); cloudEstimator->SetReferencePixel(referencePixel); writer->SetFileName(outputFileName); writer->SetInput(cloudEstimator->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/CloudDetection/test/otbCloudEstimatorFilter.cxx000066400000000000000000000051161301006202600301700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbCloudEstimatorFunctor.h" #include "otbCloudEstimatorFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbCloudEstimatorFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef VectorImageType::PixelType VectorPixelType; typedef otb::Functor::CloudEstimatorFunctor FunctorType; typedef otb::CloudEstimatorFilter CloudEstimatorFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; //Parameters const char * inputFileName(argv[1]); const char * outputFileName(argv[2]); VectorPixelType referencePixel; referencePixel.SetSize(4); referencePixel.Fill(0.); referencePixel[0] = (atof(argv[3])); referencePixel[1] = (atof(argv[4])); referencePixel[2] = (atof(argv[5])); referencePixel[3] = (atof(argv[6])); const double variance = (atof(argv[7])); // Instantiating object ReaderType::Pointer reader = ReaderType::New(); CloudEstimatorFilterType::Pointer cloudEstimator = CloudEstimatorFilterType::New(); WriterType::Pointer writer = WriterType::New(); //Initialization parameters reader->SetFileName(inputFileName); cloudEstimator->SetInput(reader->GetOutput()); cloudEstimator->SetReferencePixel(referencePixel); cloudEstimator->SetVariance(variance); writer->SetFileName(outputFileName); writer->SetInput(cloudEstimator->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/CloudDetection/test/otbCloudEstimatorFilterNew.cxx000066400000000000000000000024061301006202600306410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbCloudEstimatorFilter.h" int otbCloudEstimatorFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::CloudEstimatorFilter CloudEstimatorFilterType; // Instantiating object CloudEstimatorFilterType::Pointer filter = CloudEstimatorFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/ObjectDetection/000077500000000000000000000000001301006202600220115ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/ObjectDetection/CMakeLists.txt000066400000000000000000000000561301006202600245520ustar00rootroot00000000000000project(OTBObjectDetection) otb_module_impl() OTB-release-5.8/Modules/Detection/ObjectDetection/include/000077500000000000000000000000001301006202600234345ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbDescriptorsListSampleGenerator.h000066400000000000000000000353671301006202600324760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDescriptorsListSampleGenerator_h #define otbDescriptorsListSampleGenerator_h #include #include "itkVariableLengthVector.h" #include "itkImageRegion.h" #include "itkFunctionBase.h" #include "itkListSample.h" #include "itkSimpleDataObjectDecorator.h" #include "otbListSampleSource.h" #include "otbVectorData.h" #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" namespace otb { template class DefaultDescriptorsType { public: typedef itk::VariableLengthVector Type; }; /** \class PersistentDescriptorsListSampleGenerator * \brief [internal] Helper class for the implementation of DescriptorsListSampleGenerator * * This class inherits PersistentImageFilter and provides the Reset/Synthesize functions, * plus the ThreadedGenerateData function implementing the image function evaluation * * \ingroup OTBObjectDetection */ template class ITK_EXPORT PersistentDescriptorsListSampleGenerator : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentDescriptorsListSampleGenerator Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentDescriptorsListSampleGenerator, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage InputImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Smart Pointer type to a DataObject. */ typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef typename itk::DataObject::Pointer DataObjectPointer; /** Input VectorData */ typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef typename VectorDataType::DataNodeType VectorDataNodeType; typedef typename VectorDataType::DataNodePointerType VectorDataNodePointerType; typedef typename VectorDataType::DataTreeType VectorDataTreeType; typedef typename VectorDataType::DataTreePointerType VectorDataTreePointerType; typedef typename VectorDataNodeType::PointType VectorDataPointType; typedef typename VectorDataNodeType::LineType VectorDataLineType; typedef typename VectorDataNodeType::PolygonType VectorDataPolygonType; typedef itk::PreOrderTreeIterator VectorDataTreeIteratorType; /** Function type for descriptors extraction */ typedef TFunctionType DescriptorsFunctionType; typedef typename DescriptorsFunctionType::Pointer DescriptorsFunctionPointerType; typedef typename DescriptorsFunctionType::InputType DescriptorsFunctionPointType; typedef itk::ContinuousIndex ContinuousIndexType; /** ListSample output */ typedef TListSample ListSampleType; typedef typename ListSampleType::Pointer ListSamplePointerType; typedef typename ListSampleType::MeasurementVectorType SampleMeasurementVectorType; typedef typename ListSampleType::MeasurementType SampleMeasurementType; /** LabelListSample output */ typedef TLabel LabelType; typedef itk::FixedArray LabelSampleType; typedef itk::Statistics::ListSample LabelListSampleType; typedef typename LabelListSampleType::Pointer LabelListSamplePointerType; typedef typename LabelListSampleType::MeasurementVectorType LabelMeasurementVectorType; typedef typename LabelListSampleType::MeasurementType LabelMeasurementType; /** ListSamplePositions output */ typedef std::vector SamplesPositionType; typedef itk::SimpleDataObjectDecorator SamplesPositionObjectType; typedef typename SamplesPositionObjectType::Pointer SamplesPositionObjectPointerType; void SetSamplesLocations(VectorDataType * input); VectorDataType * GetSamplesLocations(void); /** The function to evaluate */ itkSetObjectMacro(DescriptorsFunction, DescriptorsFunctionType); itkGetObjectMacro(DescriptorsFunction, DescriptorsFunctionType); itkGetConstObjectMacro(DescriptorsFunction, DescriptorsFunctionType); /** Output sample list */ ListSampleType* GetListSample(); /** Output label list */ LabelListSampleType* GetLabelListSample(); /** Output sample position list */ SamplesPositionType& GetSamplesPositions(); SamplesPositionObjectType* GetSamplesPositionsObject(); itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); /** Make a DataObject of the correct type to be used as the specified * output. */ itk::DataObject::Pointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void AddInput(itk::DataObject * dataObject) ITK_OVERRIDE { Superclass::AddInput(dataObject); } protected: PersistentDescriptorsListSampleGenerator(); ~PersistentDescriptorsListSampleGenerator() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentDescriptorsListSampleGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented bool IsInsideWithNeighborhoodRadius(const RegionType& region, const ContinuousIndexType &index) const { typedef typename RegionType::IndexType IndexType; typedef typename IndexType::IndexValueType IndexValueType; typedef typename ContinuousIndexType::ValueType ContinuousIndexValueType; for(unsigned int i=0; i(index[i]) < static_cast( region.GetIndex(i) ) + static_cast(m_NeighborhoodRadius) ) //Comment this instruction after itkv4 migration (correct //usage of centered-pixel coordinates) //if( index[i] < static_cast( region.GetIndex(i) ) + m_NeighborhoodRadius ) { return false; } // bound is the last valid pixel location const ContinuousIndexValueType bound = static_cast( region.GetIndex(i) + region.GetSize(i) - 0.5); //Comment this instruction after itkv4 migration (correct //usage of centered-pixel coordinates) //const ContinuousIndexValueType bound = static_cast( // region.GetIndex(i) + static_cast(region.GetSize(i)) - 1); if( index[i] > bound - m_NeighborhoodRadius ) { return false; } } return true; } typedef std::vector ListSampleArray; typedef std::vector LabelListSampleArray; typedef std::vector SamplesPositionArray; ListSampleArray m_ThreadListSample; LabelListSampleArray m_ThreadLabelListSample; SamplesPositionArray m_ThreadSamplesPosition; DescriptorsFunctionPointerType m_DescriptorsFunction; unsigned int m_NeighborhoodRadius; }; /** \class DescriptorsListSampleGenerator * \brief This class generates a ListSample by computing local descriptors * on an image at specified positions. * * Given an image (by SetInputImage()) and a vector data containing points (by SetSamplesLocations()), * this class evaluates an ImageFunction (set by SetDescriptorsFunction()) at each point of the vector data * over the image. * It generates a ListSample containing the descriptors values for each sample, * along with a label ListSample containing the label associated with each sample. * The label is read from the vector data using the data field "Class", read as an int * * This class is streaming capable and multithreaded * * \ingroup OTBObjectDetection */ template class ITK_EXPORT DescriptorsListSampleGenerator : public PersistentFilterStreamingDecorator< PersistentDescriptorsListSampleGenerator< TInputImage, TVectorData, itk::FunctionBase< itk::Point, typename DefaultDescriptorsType::Type >, TListSample, TLabel > > { public: /** Standard Self typedef */ typedef DescriptorsListSampleGenerator Self; typedef PersistentFilterStreamingDecorator < PersistentDescriptorsListSampleGenerator , typename DefaultDescriptorsType::Type >, TListSample, TLabel> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(DescriptorsListSampleGenerator, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef TVectorData InputVectorDataType; typedef TListSample ListSampleType; typedef TCoordRep CoordRepType; typedef TOutputPrecision OutputPrecision; /** The coordinates used when evaluating function */ typedef itk::Point PointType; /** The return value of the function */ typedef typename DefaultDescriptorsType::Type DescriptorType; /** The function evaluated on the input image at locations specified by the vector data */ typedef itk::FunctionBase DescriptorsFunctionType; typedef typename DescriptorsFunctionType::Pointer DescriptorsFunctionPointerType; typedef typename Superclass::FilterType PersistentFilterType; typedef typename PersistentFilterType::LabelListSampleType LabelListSampleType; typedef typename PersistentFilterType::SamplesPositionObjectType SamplesPositionObjectType; typedef typename PersistentFilterType::SamplesPositionType SamplesPositionType; /** Input image to extract feature */ void SetInputImage(InputImageType * input) { this->GetFilter()->SetInput(input); } /** Input image to extract feature */ InputImageType * GetInputImage() { return this->GetFilter()->GetInput(); } void AddInput(itk::DataObject * dataObject) ITK_OVERRIDE { this->GetFilter()->AddInput(dataObject); } /** Sample locations as a VectorData of points. The label is in the ClassKey feature */ void SetSamplesLocations(InputVectorDataType * input) { this->GetFilter()->SetSamplesLocations(input); } /** Sample locations as a VectorData of points. The label is in the ClassKey feature */ InputImageType * GetSamplesLocations() { return this->GetFilter()->GetSamplesLocations(); } /** The function to evaluate */ void SetDescriptorsFunction(DescriptorsFunctionType * input) { this->GetFilter()->SetDescriptorsFunction(input); } /** The function to evaluate */ DescriptorsFunctionType * GetDescriptorsFunction() { return this->GetFilter()->GetDescriptorsFunction(); } /** Final sample list */ ListSampleType* GetListSample() { return this->GetFilter()->GetListSample(); } /** Final label list */ LabelListSampleType* GetLabelListSample() { return this->GetFilter()->GetLabelListSample(); } /** Final label list */ SamplesPositionType& GetSamplesPositions() { return this->GetFilter()->GetSamplesPositions(); } SamplesPositionObjectType* GetSamplesPositionsObject() { return this->GetFilter()->GetSamplesPositionsObject(); } otbSetObjectMemberMacro(Filter, NeighborhoodRadius, unsigned int); otbGetObjectMemberMacro(Filter, NeighborhoodRadius, unsigned int); protected: /** Constructor */ DescriptorsListSampleGenerator(); /** Destructor */ ~DescriptorsListSampleGenerator() ITK_OVERRIDE; private: DescriptorsListSampleGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDescriptorsListSampleGenerator.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbDescriptorsListSampleGenerator.txx000066400000000000000000000346671301006202600330740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDescriptorsListSampleGenerator_txx #define otbDescriptorsListSampleGenerator_txx #include "otbDescriptorsListSampleGenerator.h" #include "itkContinuousIndex.h" namespace otb { template PersistentDescriptorsListSampleGenerator ::PersistentDescriptorsListSampleGenerator() : m_NeighborhoodRadius(0) { // Need 2 inputs : a vector image and a vectordata this->SetNumberOfRequiredInputs(2); // Have 4 outputs : the image created by Superclass, // the sample list, the label sample list, the positions of the samples this->SetNumberOfRequiredOutputs(3); this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(2, this->MakeOutput(2).GetPointer()); this->itk::ProcessObject::SetNthOutput(3, this->MakeOutput(3).GetPointer()); } template PersistentDescriptorsListSampleGenerator ::~PersistentDescriptorsListSampleGenerator() { } template void PersistentDescriptorsListSampleGenerator ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentDescriptorsListSampleGenerator ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentDescriptorsListSampleGenerator ::SetSamplesLocations(VectorDataType* location) { this->SetNthInput(1, location); } template typename PersistentDescriptorsListSampleGenerator::VectorDataType* PersistentDescriptorsListSampleGenerator ::GetSamplesLocations() { return static_cast(this->itk::ProcessObject::GetInput(1)); } template typename PersistentDescriptorsListSampleGenerator::ListSampleType* PersistentDescriptorsListSampleGenerator ::GetListSample() { return dynamic_cast(this->itk::ProcessObject::GetOutput(1)); } template typename PersistentDescriptorsListSampleGenerator::LabelListSampleType* PersistentDescriptorsListSampleGenerator ::GetLabelListSample() { return dynamic_cast( this->itk::ProcessObject::GetOutput(2) ); } template typename PersistentDescriptorsListSampleGenerator::SamplesPositionType& PersistentDescriptorsListSampleGenerator ::GetSamplesPositions() { return this->GetSamplesPositionsObject()->Get(); } template typename PersistentDescriptorsListSampleGenerator::SamplesPositionObjectType* PersistentDescriptorsListSampleGenerator ::GetSamplesPositionsObject() { return dynamic_cast(this->itk::ProcessObject::GetOutput(3)); } template itk::DataObject::Pointer PersistentDescriptorsListSampleGenerator ::MakeOutput(DataObjectPointerArraySizeType idx) { itk::DataObject::Pointer output; switch (idx) { case 0: output = static_cast(InputImageType::New().GetPointer()); break; case 1: { ListSamplePointerType listSample = ListSampleType::New(); output = static_cast(listSample.GetPointer()); break; } case 2: { LabelListSamplePointerType labelListSample = LabelListSampleType::New(); output = static_cast(labelListSample.GetPointer()); break; } case 3: { SamplesPositionObjectPointerType samplesPositions = SamplesPositionObjectType::New(); output = static_cast(samplesPositions.GetPointer()); break; } default: output = static_cast(InputImageType::New().GetPointer()); break; } return output; } template void PersistentDescriptorsListSampleGenerator ::Reset() { m_ThreadListSample = ListSampleArray(this->GetNumberOfThreads()); for (unsigned int i = 0; i < this->GetNumberOfThreads(); ++i) { m_ThreadListSample[i] = ListSampleType::New(); } m_ThreadLabelListSample = LabelListSampleArray(this->GetNumberOfThreads()); for (unsigned int i = 0; i < this->GetNumberOfThreads(); ++i) { m_ThreadLabelListSample[i] = LabelListSampleType::New(); } m_ThreadSamplesPosition = SamplesPositionArray(this->GetNumberOfThreads()); this->GetListSample()->Clear(); this->GetLabelListSample()->Clear(); this->GetSamplesPositions().clear(); } template void PersistentDescriptorsListSampleGenerator ::Synthetize() { // Merge the ListSample from all the threads ListSampleType* listSample = this->GetListSample(); LabelListSampleType* labelListSample = this->GetLabelListSample(); SamplesPositionType& samplesPosition = this->GetSamplesPositions(); VectorDataPointType ref; // Get the output list measurement vector sample sizes once listSample->SetMeasurementVectorSize(m_ThreadListSample[0]->GetMeasurementVectorSize()); labelListSample->SetMeasurementVectorSize(m_ThreadLabelListSample[0]->GetMeasurementVectorSize()); // Copy the first thread elements into lists if( this->GetNumberOfThreads() > 1 ) { ListSampleType* threadListSample = m_ThreadListSample[0]; LabelListSampleType* threadLabelListSample = m_ThreadLabelListSample[0]; SamplesPositionType& threadSamplesPosition = m_ThreadSamplesPosition[0]; for (unsigned int i = 0; i < threadListSample->Size(); ++i) { listSample->PushBack( threadListSample->GetMeasurementVector(i) ); labelListSample->PushBack( threadLabelListSample->GetMeasurementVector(i) ); samplesPosition.push_back( threadSamplesPosition[i] ); } } // Add the other thread element checking if the point dosn't already exist for (itk::ThreadIdType threadId = 1; threadId < this->GetNumberOfThreads(); ++threadId ) { ListSampleType* threadListSample = m_ThreadListSample[threadId]; LabelListSampleType* threadLabelListSample = m_ThreadLabelListSample[threadId]; SamplesPositionType& threadSamplesPosition = m_ThreadSamplesPosition[threadId]; for (unsigned int i = 0; i < threadListSample->Size(); ++i) { const DescriptorsFunctionPointType & curSamplesPosition = threadSamplesPosition[i]; if( std::find(samplesPosition.begin(), samplesPosition.end(), curSamplesPosition) == samplesPosition.end() ) { listSample->PushBack( threadListSample->GetMeasurementVector(i) ); labelListSample->PushBack( threadLabelListSample->GetMeasurementVector(i) ); samplesPosition.push_back( curSamplesPosition ); } } } } template void PersistentDescriptorsListSampleGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void PersistentDescriptorsListSampleGenerator ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast< TInputImage * >( this->GetInput() ); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if ( !inputPtr || !outputPtr ) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius( m_NeighborhoodRadius + 5 ); // crop the input requested region at the input's largest possible region if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) ) { inputPtr->SetRequestedRegion( inputRequestedRegion ); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion( inputRequestedRegion ); } } template void PersistentDescriptorsListSampleGenerator ::BeforeThreadedGenerateData() {} template void PersistentDescriptorsListSampleGenerator ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { ListSampleType* listSample = m_ThreadListSample[threadId]; LabelListSampleType* labelListSample = m_ThreadLabelListSample[threadId]; SamplesPositionType& samplesPosition = m_ThreadSamplesPosition[threadId]; VectorDataTreeIteratorType vectorDataIt(this->GetSamplesLocations()->GetDataTree()); bool isInitialized = false; for (vectorDataIt.GoToBegin(); !vectorDataIt.IsAtEnd(); ++vectorDataIt) { if (vectorDataIt.Get()->IsPointFeature()) { VectorDataPointType point = vectorDataIt.Get()->GetPoint(); ContinuousIndexType cidx; this->GetInput()->TransformPhysicalPointToContinuousIndex(point, cidx); RegionType paddedRegion = outputRegionForThread; paddedRegion.PadByRadius(m_NeighborhoodRadius); if (this->IsInsideWithNeighborhoodRadius(paddedRegion, cidx)) { // Set the Measurement Vector Size of the samplelists, once if(!isInitialized) { // output list sample listSample->SetMeasurementVectorSize(m_DescriptorsFunction->Evaluate(point).Size()); labelListSample->SetMeasurementVectorSize(LabelMeasurementVectorType::Length); isInitialized = true; } SampleMeasurementVectorType sample(m_DescriptorsFunction->Evaluate(point)); listSample->PushBack( sample ); LabelMeasurementVectorType label; label[0] = static_cast(vectorDataIt.Get()->GetFieldAsInt("Class")); labelListSample->PushBack( label ); samplesPosition.push_back(point); } } } } template DescriptorsListSampleGenerator ::DescriptorsListSampleGenerator() { } template DescriptorsListSampleGenerator ::~DescriptorsListSampleGenerator() { } } // end namespace otb #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbFlusserMomentsIFFactory.h000066400000000000000000000060541301006202600310540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlusserMomentsIFFactory_h #define otbFlusserMomentsIFFactory_h #include "itkLightObject.h" #include "otbMetaImageFunction.h" #include "itkDataObject.h" #include "otbImage.h" #include "otbImageFunctionAdaptor.h" #include "otbFlusserMomentsImageFunction.h" namespace otb { /** \class FlusserMomentsFFactory * \brief add a FlusserMoments image function to a * MetaImageFunction * * This class aims at adding an adapted * FlusserMomentsImageFunction to an existing * MetaImageFunction through the method Create. * * * \ingroup OTBObjectDetection */ template class ITK_EXPORT FlusserMomentsIFFactory : public itk::LightObject { public: /** Standard class typedefs. */ typedef FlusserMomentsIFFactory Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // New macro itkNewMacro(Self); // RTTI typeinfo itkTypeMacro(FlusserMomentsIFFactory, itk::LightObject); // Input and output typedef typedef TImageType InputImageType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; // Other typedef typedef typename MetaImageFunction::Pointer MetaImageFunctionPointerType; typedef typename std::vector DataObjectContainerType; typedef typename std::vector ParamContainerType; typedef FlusserMomentsImageFunction FlusserMomentsIF; typedef ImageFunctionAdaptor AdaptedFlusserMomentsIF; void Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container); protected: FlusserMomentsIFFactory(){} ~FlusserMomentsIFFactory() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: FlusserMomentsIFFactory(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFlusserMomentsIFFactory.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbFlusserMomentsIFFactory.txx000066400000000000000000000027401301006202600314460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlusserMomentsIFFactory_txx #define otbFlusserMomentsIFFactory_txx #include "otbFlusserMomentsIFFactory.h" namespace otb { template void FlusserMomentsIFFactory ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void FlusserMomentsIFFactory ::Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container) { typename AdaptedFlusserMomentsIF::Pointer function = AdaptedFlusserMomentsIF::New(); function->SetInputImage(image); function->GetInternalImageFunction()->SetNeighborhoodRadius(param[0]); metaIF->AddFunction(function); container->push_back(image); } }//end namespace #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbFourierMellinDescriptorsIFFactory.h000066400000000000000000000062661301006202600330710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFourierMellinDescriptorsIFFactory_h #define otbFourierMellinDescriptorsIFFactory_h #include "itkLightObject.h" #include "otbMetaImageFunction.h" #include "itkDataObject.h" #include "otbImageFunctionAdaptor.h" #include "otbFourierMellinDescriptorsImageFunction.h" namespace otb { /** \class FourierMellinDescriptorsFFactory * \brief add a FourierMellinDescriptors image function to a * MetaImageFunction * * This class aims at adding an adapted * FourierMellinDescriptorsImageFunction to an existing * MetaImageFunction through the method Create. * * * \ingroup OTBObjectDetection */ template class ITK_EXPORT FourierMellinDescriptorsIFFactory : public itk::LightObject { public: /** Standard class typedefs. */ typedef FourierMellinDescriptorsIFFactory Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // New macro itkNewMacro(Self); // RTTI typeinfo itkTypeMacro(FourierMellinDescriptorsIFFactory, itk::LightObject); // Input and output typedef typedef TImageType InputImageType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; // Other typedef typedef typename MetaImageFunction::Pointer MetaImageFunctionPointerType; typedef typename std::vector DataObjectContainerType; typedef typename std::vector ParamContainerType; typedef FourierMellinDescriptorsImageFunction FourierMellinDescriptorsIF; typedef ImageFunctionAdaptor AdaptedFourierMellinDescriptorsIF; void Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container); protected: FourierMellinDescriptorsIFFactory(){} ~FourierMellinDescriptorsIFFactory() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: FourierMellinDescriptorsIFFactory(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFourierMellinDescriptorsIFFactory.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbFourierMellinDescriptorsIFFactory.txx000066400000000000000000000032341301006202600334550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFourierMellinDescriptorsIFFactory_txx #define otbFourierMellinDescriptorsIFFactory_txx #include "otbFourierMellinDescriptorsIFFactory.h" namespace otb { template void FourierMellinDescriptorsIFFactory ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void FourierMellinDescriptorsIFFactory ::Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container) { typename AdaptedFourierMellinDescriptorsIF::Pointer function = AdaptedFourierMellinDescriptorsIF::New(); function->SetInputImage(image); function->GetInternalImageFunction()->SetNeighborhoodRadius(param[0]); function->GetInternalImageFunction()->SetPmax(param[1]); function->GetInternalImageFunction()->SetQmax(param[2]); metaIF->AddFunction(function); container->push_back(image); } }//end namespace #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbHaralickTexturesIFFactory.h000066400000000000000000000062421301006202600313470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHaralickTexturesIFFactory_h #define otbHaralickTexturesIFFactory_h #include "itkLightObject.h" #include "otbMetaImageFunction.h" #include "itkDataObject.h" #include "otbImage.h" #include "otbImageFunctionAdaptor.h" #include "otbHaralickTexturesImageFunction.h" namespace otb { /** \class HaralickTexturesFFactory * \brief add a HaralickTextures image function to a * MetaImageFunction * * This class aims at adding an adapted * HaralickTexturesImageFunction to an existing * MetaImageFunction through the method Create. * * * \ingroup OTBObjectDetection */ template class ITK_EXPORT HaralickTexturesIFFactory : public itk::LightObject { public: /** Standard class typedefs. */ typedef HaralickTexturesIFFactory Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // New macro itkNewMacro(Self); // RTTI typeinfo itkTypeMacro(haralickTexturesIFFactory, itk::LightObject); // Input and output typedef typedef TImageType InputImageType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; // Other typedef typedef typename MetaImageFunction::Pointer MetaImageFunctionPointerType; typedef typename std::vector DataObjectContainerType; typedef typename std::vector ParamContainerType; typedef HaralickTexturesImageFunction HaralickTexturesIF; typedef typename HaralickTexturesIF::OffsetType OffsetType; typedef ImageFunctionAdaptor AdaptedHaralickTexturesIF; void Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container); protected: HaralickTexturesIFFactory(){} ~HaralickTexturesIFFactory() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: HaralickTexturesIFFactory(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHaralickTexturesIFFactory.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbHaralickTexturesIFFactory.txx000066400000000000000000000033361301006202600317440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHaralickTexturesIFFactory_txx #define otbHaralickTexturesIFFactory_txx #include "otbHaralickTexturesIFFactory.h" namespace otb { template void HaralickTexturesIFFactory ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void HaralickTexturesIFFactory ::Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container) { typename AdaptedHaralickTexturesIF::Pointer function = AdaptedHaralickTexturesIF::New(); function->SetInputImage(image); function->GetInternalImageFunction()->SetNeighborhoodRadius(param[0]); function->SetInputImageMinimum(param[1]); function->SetInputImageMaximum(param[2]); function->SetNumberOfBinsPerAxis(param[3]); OffsetType offset; offset.Fill(param[4]); function->GetInternalImageFunction()->SetOffset(offset); metaIF->AddFunction(function); container->push_back(image); } }//end namespace #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbLabeledSampleLocalizationGenerator.h000066400000000000000000000130771301006202600332340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabeledSampleLocalizationGenerator_h #define otbLabeledSampleLocalizationGenerator_h #include "otbVectorDataSource.h" #include "otbVectorData.h" #include "itkPreOrderTreeIterator.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "itkEuclideanDistanceMetric.h" namespace otb { /** \class LabeledSampleLocalizationGenerator * \brief Produces a VectorData from potentialy multiple VectorData * * This generator produces a unique vector data containing labeled positions * extracted from inputs. * * Input points are transmitted to the output. In addition, 'no class' * points are randomly picked inside input polygons making sure * they are at least at a given distance (InhibitionRadius) of every * known points. * * Classes are specified by the VectorData with a metadata field identified by * a specific key. This key can be provided by the SetClassKey() method * (using "Class" as a default key). * The field is retrieved by GetFieldAsInt(), thus must be int-compatible * * * \ingroup OTBObjectDetection */ template class ITK_EXPORT LabeledSampleLocalizationGenerator : public VectorDataSource { public: /** Standard class typedefs */ typedef LabeledSampleLocalizationGenerator Self; typedef VectorDataSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(LabeledSampleLocalizationGenerator, VectorDataSource); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::PolygonType::RegionType RegionType; typedef typename DataNodeType::PointType PointType; typedef typename DataNodeType::PolygonType::VertexType VertexType; typedef typename std::vector PointVectorType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; typedef itk::Statistics::EuclideanDistanceMetric EuclideanDistanceMetricType; /** Connects the VectorDatas from which the localizations are going to be extracted. */ using Superclass::PushBackInput; void PushBackInput(const VectorDataType *); const VectorDataType * GetInput(unsigned int idx) const; /** Field name containing the class identifier */ itkGetConstMacro(ClassKey, std::string); itkSetMacro(ClassKey, std::string); /** Identifier for the negative samples class */ itkGetConstMacro(NoClassIdentifier, int); itkSetMacro(NoClassIdentifier, int); /** The density of auto-generated negative samples inside the polygons */ itkGetConstMacro(RandomLocalizationDensity, double); itkSetMacro(RandomLocalizationDensity, double); /** The minimum distance between a generated negative sample and positive samples */ itkGetConstMacro(InhibitionRadius, double); itkSetMacro(InhibitionRadius, double); /** The maximum iteration number during negative sample positions */ itkGetConstMacro(NbMaxIteration, unsigned long int); itkSetMacro(NbMaxIteration, unsigned long int); /** Set the number of samples position to generate inside the inhibition radius window around a positive point */ itkGetConstMacro(NumberOfPositiveSamplesPerPoint, unsigned int); itkSetMacro(NumberOfPositiveSamplesPerPoint, unsigned int); /** Set the seed for random number generator */ void SetSeed(unsigned int seed) { m_RandomGenerator->SetSeed(seed); } protected: LabeledSampleLocalizationGenerator(); ~LabeledSampleLocalizationGenerator() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Triggers the Computation of the sample list */ void GenerateData(void) ITK_OVERRIDE; PointVectorType RandomPointsGenerator(DataNodeType * node); PointVectorType PointDensification(DataNodeType * node); private: LabeledSampleLocalizationGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string GetNextID() { std::ostringstream oss; oss << m_CurrentID++; return oss.str(); } RandomGeneratorType::Pointer m_RandomGenerator; std::string m_ClassKey; int m_NoClassIdentifier; double m_RandomLocalizationDensity; double m_InhibitionRadius; unsigned long int m_NbMaxIteration; unsigned int m_NumberOfPositiveSamplesPerPoint; unsigned int m_CurrentID; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabeledSampleLocalizationGenerator.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbLabeledSampleLocalizationGenerator.txx000066400000000000000000000231131301006202600336200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabeledSampleLocalizationGenerator_txx #define otbLabeledSampleLocalizationGenerator_txx #include "otbLabeledSampleLocalizationGenerator.h" #include "otbMath.h" namespace otb { template LabeledSampleLocalizationGenerator ::LabeledSampleLocalizationGenerator() : m_ClassKey("Class"), m_NoClassIdentifier(0), m_RandomLocalizationDensity(.005), m_InhibitionRadius(5.0), m_NbMaxIteration(10000), m_NumberOfPositiveSamplesPerPoint(50), m_CurrentID(0) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_RandomGenerator = RandomGeneratorType::GetInstance(); } template void LabeledSampleLocalizationGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "Class Key: " << m_ClassKey << std::endl; os << indent << "Negative Class Identifier: " << m_NoClassIdentifier << std::endl; os << indent << "Sampling Density: " << m_RandomLocalizationDensity << std::endl; os << indent << "Inhibition Radius: " << m_InhibitionRadius << std::endl; } template void LabeledSampleLocalizationGenerator ::PushBackInput(const VectorDataType * vectorData) { this->Superclass::SetNthInput(this->GetNumberOfIndexedInputs(), const_cast(vectorData)); } template const TVectorData * LabeledSampleLocalizationGenerator ::GetInput(unsigned int idx) const { if (this->GetNumberOfInputs() < idx) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(idx)); } template typename LabeledSampleLocalizationGenerator ::PointVectorType LabeledSampleLocalizationGenerator ::PointDensification(DataNodeType * node) { PointVectorType pPoint; PointType centerPoint = node->GetPoint(); for(unsigned int i = 0; i < m_NumberOfPositiveSamplesPerPoint; ++i) { PointType point; for(unsigned int dim = 0; dim < 2; ++dim) { point[dim] = centerPoint[dim]+this->m_RandomGenerator->GetUniformVariate(-m_InhibitionRadius, m_InhibitionRadius); } pPoint.push_back(point); } return pPoint; } template typename LabeledSampleLocalizationGenerator ::PointVectorType LabeledSampleLocalizationGenerator ::RandomPointsGenerator(DataNodeType * node) { // Output PointVectorType vPoint; // Euclidean distance typename EuclideanDistanceMetricType::Pointer euclideanDistanceMetric = EuclideanDistanceMetricType::New(); // Gathering Information RegionType generatorRegion = node->GetPolygonExteriorRing()->GetBoundingRegion(); typename RegionType::SizeType generatorRegionSize = generatorRegion.GetSize(); typename RegionType::IndexType generatorRegionIndex = generatorRegion.GetIndex(); //typename RegionType::IndexType generatorRegionOrigin = generatorRegion.GetOrigin(); // Identify inside known points std::vector insiders; typename VectorDataType::ConstPointer vectorData = static_cast(this->GetOutput(0)); TreeIteratorType itVector(vectorData->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPointFeature() && itVector.Get()->GetFieldAsInt(m_ClassKey) != m_NoClassIdentifier) { VertexType vertex; vertex[0] = itVector.Get()->GetPoint()[0]; vertex[1] = itVector.Get()->GetPoint()[1]; if(node->GetPolygonExteriorRing()->IsInside(vertex)) { insiders.push_back(itVector.Get()->GetPoint()); } } ++itVector; } // Generation unsigned int nbMaxPosition = (unsigned int)(node->GetPolygonExteriorRing()->GetArea() * this->GetRandomLocalizationDensity()); unsigned long int nbIter = this->GetNbMaxIteration(); unsigned int nbPosition = nbMaxPosition; PointType rangeMin, rangeMax; for(unsigned int dim = 0; dim < 2; ++dim) { rangeMin[dim] = generatorRegionIndex[dim]; rangeMax[dim] = generatorRegionIndex[dim] + generatorRegionSize[dim]; } while(nbIter > 0 && nbPosition > 0) { VertexType candidate; for(unsigned int dim = 0; dim < 2; ++dim) { candidate[dim] = this->m_RandomGenerator->GetUniformVariate(rangeMin[dim], rangeMax[dim]); } if(node->GetPolygonExteriorRing()->IsInside(candidate)) { typename PointVectorType::const_iterator pit = insiders.begin(); bool valid = true; while(valid && pit!=insiders.end()) { valid = (euclideanDistanceMetric->Evaluate(candidate, *pit) > this->GetInhibitionRadius()); ++pit; } PointType point; point[0] = candidate[0]; point[1] = candidate[1]; if(valid) { vPoint.push_back(point); } nbPosition --; } nbIter --; } return vPoint; } template void LabeledSampleLocalizationGenerator ::GenerateData() { unsigned int nbInputs = this->GetNumberOfInputs(); this->GetOutput(0)->SetMetaDataDictionary(this->GetInput(0)->GetMetaDataDictionary()); // Retrieving root node typename DataNodeType::Pointer root = this->GetOutput(0)->GetDataTree()->GetRoot()->Get(); // Create the document node typename DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(document, root); std::string positiveClassIdentifier; bool firstFeature = true; // Copy all point feature in output VectorData for (unsigned int i=0; i(this->GetInput(i)); TreeIteratorType itVector(vectorData->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPointFeature()) { //Get the value of the positive value of if (firstFeature) { positiveClassIdentifier = itVector.Get()->GetFieldAsString(m_ClassKey); firstFeature = false; } // Duplicate input feature typename DataNodeType::Pointer currentGeometry = DataNodeType::New(); currentGeometry->SetNodeId(this->GetNextID()); currentGeometry->SetNodeType(otb::FEATURE_POINT); currentGeometry->SetPoint(itVector.Get()->GetPoint()); std::vector fields = itVector.Get()->GetFieldList(); for (std::vector::const_iterator it = fields.begin(); it != fields.end(); ++it) { currentGeometry->SetFieldAsString( *it, itVector.Get()->GetFieldAsString(*it) ); // The PositiveClass identifier must be an attribute of the class } this->GetOutput(0)->GetDataTree()->Add(currentGeometry, document); } ++itVector; } } // Iterates through the polygon features and generates random point inside the polygon with // the "NoClass" identifier for (unsigned int i=0; i(this->GetInput(i)); TreeIteratorType itVector(vectorData->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPolygonFeature()) { PointVectorType vPoints = RandomPointsGenerator(itVector.Get()); for (typename PointVectorType::const_iterator it = vPoints.begin(); it != vPoints.end(); ++it) { typename DataNodeType::Pointer currentGeometry = DataNodeType::New(); currentGeometry->SetNodeId(this->GetNextID()); currentGeometry->SetNodeType(otb::FEATURE_POINT); currentGeometry->SetPoint(*it); currentGeometry->SetFieldAsInt(this->GetClassKey(), this->GetNoClassIdentifier()); this->GetOutput(0)->GetDataTree()->Add(currentGeometry, document); } } ++itVector; } } // Densify positive points for (unsigned int i=0; i(this->GetInput(i)); TreeIteratorType itVector(vectorData->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPointFeature()) { PointVectorType pPoints = PointDensification(itVector.Get()); for (typename PointVectorType::const_iterator it = pPoints.begin(); it != pPoints.end(); ++it) { typename DataNodeType::Pointer currentGeometry = DataNodeType::New(); currentGeometry->SetNodeId(this->GetNextID()); currentGeometry->SetNodeType(otb::FEATURE_POINT); currentGeometry->SetPoint(*it); currentGeometry->SetFieldAsInt(this->GetClassKey(), atoi(positiveClassIdentifier.c_str()) ); this->GetOutput(0)->GetDataTree()->Add(currentGeometry, document); } } ++itVector; } } } } // end namespace otb #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbLocalHistogramIFFactory.h000066400000000000000000000060621301006202600307750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalHistogramIFFactory_h #define otbLocalHistogramIFFactory_h #include "itkLightObject.h" #include "otbMetaImageFunction.h" #include "itkDataObject.h" #include "otbImage.h" #include "otbImageFunctionAdaptor.h" #include "otbLocalHistogramImageFunction.h" namespace otb { /** \class LocalHistogramIFFactory * \brief add a LocalHistogram image function to a * MetaImageFunction * * This class aims at adding an adapted * LocalHistogramImageFunction to an existing MetaImageFunction * through the method Create. * * * \ingroup OTBObjectDetection */ template class ITK_EXPORT LocalHistogramIFFactory : public itk::LightObject { public: /** Standard class typedefs. */ typedef LocalHistogramIFFactory Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // New macro itkNewMacro(Self); // RTTI typeinfo itkTypeMacro(LocalHistogramIFFactory, itk::LightObject); // Input and output typedef typedef TImageType InputImageType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; // Other typedef typedef typename MetaImageFunction::Pointer MetaImageFunctionPointerType; typedef typename std::vector DataObjectContainerType; typedef typename std::vector ParamContainerType; typedef LocalHistogramImageFunction LocalHistogramIF; typedef ImageFunctionAdaptor AdaptedLocalHistogramIF; void Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container); protected: LocalHistogramIFFactory(){} ~LocalHistogramIFFactory() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LocalHistogramIFFactory(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLocalHistogramIFFactory.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbLocalHistogramIFFactory.txx000066400000000000000000000032621301006202600313700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalHistogramIFFactory_txx #define otbLocalHistogramIFFactory_txx #include "otbLocalHistogramIFFactory.h" namespace otb { template void LocalHistogramIFFactory ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void LocalHistogramIFFactory ::Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container) { typename AdaptedLocalHistogramIF::Pointer function = AdaptedLocalHistogramIF::New(); function->SetInputImage(image); function->GetInternalImageFunction()->SetNeighborhoodRadius(param[0]); function->GetInternalImageFunction()->SetNumberOfHistogramBins(param[1]); function->GetInternalImageFunction()->SetHistogramMin(param[2]); function->GetInternalImageFunction()->SetHistogramMax(param[3]); metaIF->AddFunction(function); container->push_back(image); } }//end namespace #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbMultiChannelIFFactory.h000066400000000000000000000104531301006202600304470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelIFFactory_h #define otbMultiChannelIFFactory_h #include "otbVectorImageToImageListFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageList.h" #include "itkDataObject.h" #include "otbMetaImageFunction.h" namespace otb { /** \class MultiChannelIFFactory * \brief Yhis class handle the image type before the use of an * image function factory * * According to the image type, the Create method of this class can * call an ImageFunctionFactory for each band of the input image or * once if the image type is otb::Image. * * * \ingroup OTBObjectDetection */ template class MultiChannelIFFactory { public: typedef TIFFactory IFFactoryType; typedef TInputImage InputImageType; typedef typename IFFactoryType::Pointer IFFactoryPointerType; typedef typename IFFactoryType::InputImageType ImageType; typedef typename IFFactoryType::CoordRepType CoordRepType; typedef typename IFFactoryType::PrecisionType PrecisionType; typedef typename std::vector ParameterContainerType; typedef typename std::vector ImageContainer; typedef typename MetaImageFunction::Pointer MetaIFPointerType; typedef ImageList ImageListType; typedef VectorImageToImageListFilter VIToILFilterType; void Create(InputImageType * image, ParameterContainerType param, MetaIFPointerType metaIF, ImageContainer * container) { m_Factory->Create(image, param, metaIF, container); } MultiChannelIFFactory() { m_Factory = IFFactoryType::New(); } virtual ~MultiChannelIFFactory(){}; private: IFFactoryPointerType m_Factory; }; template class MultiChannelIFFactory > { public: typedef TIFFactory IFFactoryType; typedef typename IFFactoryType::Pointer IFFactoryPointerType; typedef typename IFFactoryType::InputImageType ImageType; typedef typename IFFactoryType::CoordRepType CoordRepType; typedef typename IFFactoryType::PrecisionType PrecisionType; typedef VectorImage InputImageType; typedef typename std::vector ParameterContainerType; typedef typename std::vector ImageContainer; typedef typename MetaImageFunction::Pointer MetaIFPointerType; typedef ImageList ImageListType; typedef VectorImageToImageListFilter VIToILFilterType; void Create(InputImageType * image, ParameterContainerType param, MetaIFPointerType metaIF, ImageContainer * container) { unsigned int nbBand; typename VIToILFilterType::Pointer filter = VIToILFilterType::New(); filter->SetInput(image); filter->UpdateOutputInformation(); nbBand = filter->GetOutput()->Size(); for (unsigned int i=0; iGetOutput()->GetNthElement(i)->UpdateOutputInformation(); m_Factory->Create(filter->GetOutput()->GetNthElement(i), param, metaIF, container); } } MultiChannelIFFactory() { m_Factory = IFFactoryType::New(); } virtual ~MultiChannelIFFactory(){}; private: IFFactoryPointerType m_Factory; }; } //end namespace #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbRadiometricMomentsIFFactory.h000066400000000000000000000061731301006202600316750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometricMomentsIFFactory_h #define otbRadiometricMomentsIFFactory_h #include "itkLightObject.h" #include "otbMetaImageFunction.h" #include "itkDataObject.h" #include "otbImage.h" #include "otbImageFunctionAdaptor.h" #include "otbRadiometricMomentsImageFunction.h" namespace otb { /** \class RadiometricMomentsIFFactory * \brief add a RadiometricMoments image function to a * MetaImageFunction * * This class aims at adding an adapted * RadiometricMomentsImageFunction to an existing MetaImageFunction * through the method Create. * * * \ingroup OTBObjectDetection */ template class ITK_EXPORT RadiometricMomentsIFFactory : public itk::LightObject { public: /** Standard class typedefs. */ typedef RadiometricMomentsIFFactory Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // New macro itkNewMacro(Self); // RTTI typeinfo itkTypeMacro(RadiometricMomentsIFFactory, itk::LightObject); // Input and output typedef typedef TImageType InputImageType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; // Other typedef typedef typename MetaImageFunction::Pointer MetaImageFunctionPointerType; typedef typename std::vector DataObjectContainerType; typedef typename std::vector ParamContainerType; typedef RadiometricMomentsImageFunction RadiometricMomentsIF; typedef ImageFunctionAdaptor AdaptedRadiometricMomentsIF; void Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container); protected: RadiometricMomentsIFFactory(){} ~RadiometricMomentsIFFactory() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RadiometricMomentsIFFactory(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRadiometricMomentsIFFactory.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbRadiometricMomentsIFFactory.txx000066400000000000000000000027741301006202600322740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometricMomentsIFFactory_txx #define otbRadiometricMomentsIFFactory_txx #include "otbRadiometricMomentsIFFactory.h" namespace otb { template void RadiometricMomentsIFFactory ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void RadiometricMomentsIFFactory ::Create(InputImageType * image, ParamContainerType param, MetaImageFunctionPointerType metaIF, DataObjectContainerType * container) { typename AdaptedRadiometricMomentsIF::Pointer function = AdaptedRadiometricMomentsIF::New(); function->SetInputImage(image); function->GetInternalImageFunction()->SetNeighborhoodRadius(param[0]); metaIF->AddFunction(function); container->push_back(image); } }//end namespace #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbStandardMetaImageFunctionBuilder.h000066400000000000000000000201751301006202600326460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStandardMetaImageFunctionBuilder_h #define otbStandardMetaImageFunctionBuilder_h #include "itkVariableLengthVector.h" #include "otbMultiChannelIFFactory.h" #include "otbLocalHistogramIFFactory.h" #include "otbFlusserMomentsIFFactory.h" #include "otbRadiometricMomentsIFFactory.h" #include "otbFourierMellinDescriptorsIFFactory.h" #include "otbHaralickTexturesIFFactory.h" namespace otb { /** \class StandardMetaImageFunctionBuilder * \brief Build a Standard MetaImageFunction * * The StandardMetaImageFunctionBuilder class allows calling multiple * ImageFunctions: * - otbRadiometricMomentsImageFunction * - otbFlusserMomentsImageFunction * - otbFourierMellinDescriptorsImageFunction * - otbLocalHistogramImageFunction * On Multiple Images (and VectorImages Processed as ImageList). * * Each ImageFunction can be parametrized. The only thing to do to * complete the MetaImageFunction is to AddImages. * * * * * \ingroup OTBObjectDetection */ template class ITK_EXPORT StandardMetaImageFunctionBuilder : public itk::LightObject { public: /** Standard class typedefs. */ typedef StandardMetaImageFunctionBuilder Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // New macro itkNewMacro(Self); // RTTI typeinfo itkTypeMacro(StandardMetaImageFunctionBuilder, itk::LightObject); // Input and output typedef typedef TPrecision ValueType; typedef TCoordRep CoordRepType; // Other typedef typedef MetaImageFunction MetaImageFunctionType; typedef typename MetaImageFunctionType::Pointer MetaImageFunctionPointerType; typedef typename std::vector DataObjectContainerType; typedef typename std::vector ParamContainerType; //Accessors unsigned int GetNeighborhoodRadius(); void SetNeighborhoodRadius(unsigned int radius); ParamContainerType GetFlusserMomentsIFParameters(); void SetFlusserMomentsIFParameters(ParamContainerType Param); ParamContainerType GetLocalHistogramIFParameters(); void SetLocalHistogramIFParameters(ParamContainerType Param); ParamContainerType GetRadiometricMomentsIFParameters(); void SetRadiometricMomentsIFParameters(ParamContainerType Param); ParamContainerType GetFourierMellinDescriptorsIFParameters(); void SetFourierMellinDescriptorsIFParameters(ParamContainerType Param); ParamContainerType GetHaralickTexturesIFParameters(); void SetHaralickTexturesIFParameters(ParamContainerType Param); MetaImageFunctionPointerType GetMetaImageFunction(); DataObjectContainerType GetDataObjectContainer(); // Adding Image template void AddImage(TInputImage * image) { typedef TInputImage InputImageType; typedef typename InputImageType::InternalPixelType InternalPixelType; typedef Image ImageType; //Mono-Channel Factories typedef LocalHistogramIFFactory LocalHistogramIFFactoryType; typedef FlusserMomentsIFFactory FlusserMomentsIFFactoryType; typedef RadiometricMomentsIFFactory RadiometricMomentsIFFactoryType; typedef FourierMellinDescriptorsIFFactory FourierMellinDescriptorsIFFactoryType; typedef HaralickTexturesIFFactory HaralickTexturesIFFactoryType; //Multi-Channel Factories typedef MultiChannelIFFactory MCLocalHistogramIFFactoryType; typedef MultiChannelIFFactory MCFlusserMomentsIFFactoryType; typedef MultiChannelIFFactory MCRadiometricMomentsIFFactoryType; typedef MultiChannelIFFactory MCFourierMellinDescriptorsIFFactoryType; typedef MultiChannelIFFactory MCHaralickTexturesIFFactoryType; MCLocalHistogramIFFactoryType MCLocalHistogramIFFactory; MCFlusserMomentsIFFactoryType MCFlusserMomentsIFFactory; MCRadiometricMomentsIFFactoryType MCRadiometricMomentsIFFactory; MCFourierMellinDescriptorsIFFactoryType MCFourierMellinDescriptorsIFFactory; MCHaralickTexturesIFFactoryType MCHaralickTexturesIFFactory; MCRadiometricMomentsIFFactory.Create(image, this->GetRadiometricMomentsIFParameters(), m_MetaImageFunction, &m_DataObjectContainer); MCFlusserMomentsIFFactory.Create(image, this->GetFlusserMomentsIFParameters(), m_MetaImageFunction, &m_DataObjectContainer); MCFourierMellinDescriptorsIFFactory.Create(image, this->GetFourierMellinDescriptorsIFParameters(), m_MetaImageFunction, &m_DataObjectContainer); //MCLocalHistogramIFFactory.Create(image, // m_LocalHistogramParam, // m_MetaImageFunction, // &m_DataObjectContainer); //MCHaralickTexturesIFFactory.Create(image, // m_HaralickTexturesParam, // m_MetaImageFunction, // &m_DataObjectContainer); } protected: StandardMetaImageFunctionBuilder(); ~StandardMetaImageFunctionBuilder() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: StandardMetaImageFunctionBuilder(const Self& ); //purposely not implemented void operator=(const Self& ); //purposely not implemented MetaImageFunctionPointerType m_MetaImageFunction; DataObjectContainerType m_DataObjectContainer; unsigned int m_NeighborhoodRadius; ParamContainerType m_FlusserMomentsParam; //[NeighborhoodRadius] ParamContainerType m_RadiometricMomentsParam; //[NeighborhoodRadius] ParamContainerType m_LocalHistogramParam; //[NeighborhoodRadius; nbBins; minHistogram; maxHistogram] ParamContainerType m_FourierMellinDescriptorsParam; //[NeighborhoodRadius; PMax; QMax] ParamContainerType m_HaralickTexturesParam; //[NeighborhoodRadius; ImageMin; ImageMax; NbBinPerAxis; Offset] }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStandardMetaImageFunctionBuilder.txx" #endif #endif OTB-release-5.8/Modules/Detection/ObjectDetection/include/otbStandardMetaImageFunctionBuilder.txx000066400000000000000000000144301301006202600332370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStandardMetaImageFunctionBuilder_txx #define otbStandardMetaImageFunctionBuilder_txx #include "otbStandardMetaImageFunctionBuilder.h" namespace otb { template StandardMetaImageFunctionBuilder ::StandardMetaImageFunctionBuilder() { m_NeighborhoodRadius = 4; m_MetaImageFunction = MetaImageFunctionType::New(); m_FlusserMomentsParam.push_back(static_cast(this->GetNeighborhoodRadius())); m_RadiometricMomentsParam.push_back(static_cast(this->GetNeighborhoodRadius())); m_LocalHistogramParam.push_back(static_cast(this->GetNeighborhoodRadius())); m_LocalHistogramParam.push_back(16); m_LocalHistogramParam.push_back(0); m_LocalHistogramParam.push_back(4096); m_FourierMellinDescriptorsParam.push_back(static_cast(this->GetNeighborhoodRadius())); m_FourierMellinDescriptorsParam.push_back(3); m_FourierMellinDescriptorsParam.push_back(3); m_HaralickTexturesParam.push_back(static_cast(this->GetNeighborhoodRadius())); m_HaralickTexturesParam.push_back(0); m_HaralickTexturesParam.push_back(4096); m_HaralickTexturesParam.push_back(30); m_HaralickTexturesParam.push_back(2); } template StandardMetaImageFunctionBuilder ::~StandardMetaImageFunctionBuilder() { } template void StandardMetaImageFunctionBuilder ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template unsigned int StandardMetaImageFunctionBuilder ::GetNeighborhoodRadius() { return m_NeighborhoodRadius; } template void StandardMetaImageFunctionBuilder ::SetNeighborhoodRadius(unsigned int radius) { if (radius>0) { m_NeighborhoodRadius = radius; m_FlusserMomentsParam[0] = static_cast(radius); m_RadiometricMomentsParam[0] = static_cast(radius); m_LocalHistogramParam[0] = static_cast(radius); m_FourierMellinDescriptorsParam[0] = static_cast(radius); m_HaralickTexturesParam[0] = static_cast(radius); } } template typename StandardMetaImageFunctionBuilder::ParamContainerType StandardMetaImageFunctionBuilder ::GetFlusserMomentsIFParameters() { return m_FlusserMomentsParam; } template void StandardMetaImageFunctionBuilder ::SetFlusserMomentsIFParameters(ParamContainerType Param) { if (Param.size()==1) { m_FlusserMomentsParam[0] = Param[0]; } } template typename StandardMetaImageFunctionBuilder::ParamContainerType StandardMetaImageFunctionBuilder ::GetLocalHistogramIFParameters() { return m_LocalHistogramParam; } template void StandardMetaImageFunctionBuilder ::SetLocalHistogramIFParameters(ParamContainerType Param) { if (Param.size()==4) { m_LocalHistogramParam[0] = Param[0]; m_LocalHistogramParam[1] = Param[1]; m_LocalHistogramParam[2] = Param[2]; m_LocalHistogramParam[3] = Param[3]; } } template typename StandardMetaImageFunctionBuilder::ParamContainerType StandardMetaImageFunctionBuilder ::GetRadiometricMomentsIFParameters() { return m_RadiometricMomentsParam; } template void StandardMetaImageFunctionBuilder ::SetRadiometricMomentsIFParameters(ParamContainerType Param) { if (Param.size()==1) { m_RadiometricMomentsParam[0] = Param[0]; } } template typename StandardMetaImageFunctionBuilder::ParamContainerType StandardMetaImageFunctionBuilder ::GetFourierMellinDescriptorsIFParameters() { return m_FourierMellinDescriptorsParam; } template void StandardMetaImageFunctionBuilder ::SetFourierMellinDescriptorsIFParameters(ParamContainerType Param) { if (Param.size()==3) { m_FourierMellinDescriptorsParam[0] = Param[0]; m_FourierMellinDescriptorsParam[1] = Param[1]; m_FourierMellinDescriptorsParam[2] = Param[2]; } } template typename StandardMetaImageFunctionBuilder::ParamContainerType StandardMetaImageFunctionBuilder ::GetHaralickTexturesIFParameters() { return m_HaralickTexturesParam; } template void StandardMetaImageFunctionBuilder ::SetHaralickTexturesIFParameters(ParamContainerType Param) { if (Param.size()==5) { m_HaralickTexturesParam[0] = Param[0]; m_HaralickTexturesParam[1] = Param[1]; m_HaralickTexturesParam[2] = Param[2]; m_HaralickTexturesParam[3] = Param[3]; m_HaralickTexturesParam[4] = Param[4]; } } template typename StandardMetaImageFunctionBuilder::MetaImageFunctionPointerType StandardMetaImageFunctionBuilder ::GetMetaImageFunction() { return m_MetaImageFunction; } template typename StandardMetaImageFunctionBuilder::DataObjectContainerType StandardMetaImageFunctionBuilder ::GetDataObjectContainer() { return m_DataObjectContainer; } }//end namespace #endif OTB-release-5.8/Modules/Detection/ObjectDetection/otb-module.cmake000066400000000000000000000006541301006202600250670ustar00rootroot00000000000000set(DOCUMENTATION "This module contains useful classes for object detection.") otb_module(OTBObjectDetection DEPENDS OTBCommon OTBDescriptors OTBITK OTBImageBase OTBMoments OTBObjectList OTBStatistics OTBStreaming OTBTextures OTBVectorDataBase TEST_DEPENDS OTBIOXML OTBImageIO OTBSVMLearning OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Detection/ObjectDetection/test/000077500000000000000000000000001301006202600227705ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/ObjectDetection/test/CMakeLists.txt000066400000000000000000000061221301006202600255310ustar00rootroot00000000000000otb_module_test() set(OTBObjectDetectionTests otbObjectDetectionTestDriver.cxx otbLabeledSampleLocalizationGenerator.cxx otbStandardMetaImageFunctionBuilder.cxx otbDescriptorsListSampleGenerator.cxx ) add_executable(otbObjectDetectionTestDriver ${OTBObjectDetectionTests}) target_link_libraries(otbObjectDetectionTestDriver ${OTBObjectDetection-Test_LIBRARIES}) otb_module_target_label(otbObjectDetectionTestDriver) # Tests Declaration otb_add_test(NAME odTuLabeledSampleLocalizationGeneratorNew COMMAND otbObjectDetectionTestDriver otbLabeledSampleLocalizationGeneratorNew ) otb_add_test(NAME odTvLabeledSampleLocalizationGenerator COMMAND otbObjectDetectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/TvLabeledSampleLocalizationGeneratorOutput.shp ${TEMP}/TvLabeledSampleLocalizationGeneratorOutput.shp otbLabeledSampleLocalizationGenerator ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01LabeledPoints.shp ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01Polygons.shp ${TEMP}/TvLabeledSampleLocalizationGeneratorOutput.shp ) otb_add_test(NAME odTuStandardMetaImageFunctionBuilderNew COMMAND otbObjectDetectionTestDriver otbStandardMetaImageFunctionBuilderNew ) otb_add_test(NAME odTvStandardMetaImageFunctionBuilder COMMAND otbObjectDetectionTestDriver otbStandardMetaImageFunctionBuilder ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01.tif ) otb_add_test(NAME odTvDescriptorsListSampleGeneratorStreaming COMMAND otbObjectDetectionTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt ${TEMP}/TvDescriptorsListSampleGeneratorStreamingOutput.txt otbDescriptorsListSampleGenerator ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01_amplitude.tif ${BASELINE_FILES}/TvLabeledSampleLocalizationGeneratorOutput.shp ${TEMP}/TvDescriptorsListSampleGeneratorStreamingOutput.txt 50 # streaming 5 # neighborhood radius ) #otb_add_test(NAME odTvDescriptorsSVMModelCreation COMMAND otbObjectDetectionTestDriver #--compare-ascii ${NOTOL} #${BASELINE_FILES}/TvDescriptorsSVMModelCreation.svm #${TEMP}/TvDescriptorsSVMModelCreation.svm #otbDescriptorsSVMModelCreation #${INPUTDATA}/ObjectReco/Boats/maur_B010202_01_amplitude.tif #${BASELINE_FILES}/TvLabeledSampleLocalizationGeneratorOutput.shp #${INPUTDATA}/ObjectReco/Boats/FeatureStats_RadiometricMoments_amplitude.xml #${TEMP}/TvDescriptorsSVMModelCreation.svm #0 # streaming #5 # neighborhood radius #) otb_add_test(NAME odTvDescriptorsListSampleGeneratorNoStreaming COMMAND otbObjectDetectionTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt ${TEMP}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt otbDescriptorsListSampleGenerator ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01_amplitude.tif ${BASELINE_FILES}/TvLabeledSampleLocalizationGeneratorOutput.shp ${TEMP}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt 0 # streaming 5 # neighborhood radius ) otb_add_test(NAME odTuDescriptorsListSampleGeneratorNew COMMAND otbObjectDetectionTestDriver otbDescriptorsListSampleGeneratorNew ) OTB-release-5.8/Modules/Detection/ObjectDetection/test/otbDescriptorsListSampleGenerator.cxx000066400000000000000000000214421301006202600323720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbRadiometricMomentsImageFunction.h" #include "otbDescriptorsListSampleGenerator.h" #include "otbImageFileReader.h" #include "otbVectorDataFileReader.h" #include "otbImageFunctionAdaptor.h" #include "otbStatisticsXMLFileReader.h" #include "otbShiftScaleSampleListFilter.h" #include "otbSVMSampleListModelEstimator.h" const unsigned int Dimension = 2; typedef int LabelType; typedef double PixelType; typedef double FunctionPrecisionType; typedef double CoordRepType; typedef otb::Image ImageType; typedef otb::VectorData<> VectorDataType; typedef otb::RadiometricMomentsImageFunction FunctionType; typedef otb::ImageFunctionAdaptor AdaptedFunctionType; typedef itk::VariableLengthVector SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::FixedArray LabelSampleType; typedef itk::Statistics::ListSample LabelListSampleType; typedef otb::DescriptorsListSampleGenerator < ImageType, VectorDataType, ListSampleType, LabelType, FunctionPrecisionType, CoordRepType > DescriptorsListSampleGeneratorType; typedef otb::ImageFileReader ImageReaderType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::Functor::VariableLengthVectorToMeasurementVectorFunctor MeasurementVectorFunctorType; typedef otb::StatisticsXMLFileReader StatisticsReader; typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleListSampleFilterType; typedef otb::SVMSampleListModelEstimator< ListSampleType, LabelListSampleType, MeasurementVectorFunctorType> SVMEstimatorType; typedef FunctionType::PointType PointType; typedef DescriptorsListSampleGeneratorType::SamplesPositionType SamplesPositionType; struct SampleEntry { PointType position; LabelType label; SampleType measurement; }; struct CompareSampleEntry { bool operator () (SampleEntry p, SampleEntry q) { // order with the y axis position if (p.position[1] < q.position[1]) return true; if (p.position[1] > q.position[1]) return false; // If one the same line, // order with the x axis position if (p.position[0] < q.position[0]) return true; return false; } }; std::ostream &operator<<(std::ostream &stream, SampleEntry entry) { stream << "---" << std::endl << "Label : " << entry.label << std::endl << "Position : " << entry.position << std::endl << "Measurements : " << entry.measurement; return stream; } int otbDescriptorsListSampleGeneratorNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { // instantiation DescriptorsListSampleGeneratorType::Pointer generator = DescriptorsListSampleGeneratorType::New(); std::cout << generator << std::endl; return EXIT_SUCCESS; } int otbDescriptorsListSampleGenerator(int argc, char* argv[]) { if (argc != 6) { std::cerr << "Wrong number of arguments" << std::endl; return EXIT_FAILURE; } const char* inputImageFileName = argv[1]; const char* inputSamplesLocation = argv[2]; const char* outputFileName = argv[3]; int streaming = atoi(argv[4]); int neighborhood = atoi(argv[5]); ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(inputImageFileName); VectorDataReaderType::Pointer vectorDataReader = VectorDataReaderType::New(); vectorDataReader->SetFileName(inputSamplesLocation); //imageReader->Update(); //vectorDataReader->Update(); AdaptedFunctionType::Pointer descriptorsFunction = AdaptedFunctionType::New(); descriptorsFunction->SetInputImage(imageReader->GetOutput()); descriptorsFunction->GetInternalImageFunction()->SetNeighborhoodRadius(5); DescriptorsListSampleGeneratorType::Pointer descriptorsGenerator = DescriptorsListSampleGeneratorType::New(); descriptorsGenerator->SetInputImage(imageReader->GetOutput()); descriptorsGenerator->SetSamplesLocations(vectorDataReader->GetOutput()); descriptorsGenerator->SetDescriptorsFunction(descriptorsFunction.GetPointer()); descriptorsGenerator->SetNeighborhoodRadius(neighborhood); descriptorsGenerator->GetStreamer()->SetNumberOfLinesStrippedStreaming( streaming ); descriptorsGenerator->Update(); ListSampleType::Pointer samples = descriptorsGenerator->GetListSample(); LabelListSampleType::Pointer labels = descriptorsGenerator->GetLabelListSample(); SamplesPositionType& positions = descriptorsGenerator->GetSamplesPositions(); ListSampleType::Iterator sampleIt = samples->Begin(); LabelListSampleType::Iterator labelIt = labels->Begin(); SamplesPositionType::const_iterator posIt = positions.begin(); ListSampleType::Iterator sampleEnd = samples->End(); LabelListSampleType::Iterator labelEnd = labels->End(); SamplesPositionType::const_iterator posEnd = positions.end(); std::vector entries; while (sampleIt != sampleEnd && labelIt != labelEnd && posIt != posEnd) { SampleEntry entry; entry.position = *posIt; entry.label = labelIt.GetMeasurementVector()[0]; entry.measurement = sampleIt.GetMeasurementVector(); entries.push_back(entry); ++sampleIt; ++labelIt; ++posIt; } std::sort(entries.begin(), entries.end(), CompareSampleEntry()); std::ofstream file(outputFileName); std::copy(entries.begin(), entries.end(), std::ostream_iterator(file, "\n")); file.close(); return EXIT_SUCCESS; } int otbDescriptorsSVMModelCreation(int argc, char* argv[]) { if (argc != 7) { std::cerr << "Wrong number of arguments" << std::endl; return EXIT_FAILURE; } const char* inputImageFileName = argv[1]; const char* inputSamplesLocation = argv[2]; const char* featureStatisticsFileName = argv[3]; const char* outputFileName = argv[4]; int streaming = atoi(argv[5]); int neighborhood = atoi(argv[6]); ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(inputImageFileName); VectorDataReaderType::Pointer vectorDataReader = VectorDataReaderType::New(); vectorDataReader->SetFileName(inputSamplesLocation); //imageReader->Update(); //vectorDataReader->Update(); AdaptedFunctionType::Pointer descriptorsFunction = AdaptedFunctionType::New(); descriptorsFunction->SetInputImage(imageReader->GetOutput()); descriptorsFunction->GetInternalImageFunction()->SetNeighborhoodRadius(neighborhood); DescriptorsListSampleGeneratorType::Pointer descriptorsGenerator = DescriptorsListSampleGeneratorType::New(); descriptorsGenerator->SetInputImage(imageReader->GetOutput()); descriptorsGenerator->SetSamplesLocations(vectorDataReader->GetOutput()); descriptorsGenerator->SetDescriptorsFunction(descriptorsFunction.GetPointer()); descriptorsGenerator->SetNeighborhoodRadius(5); descriptorsGenerator->GetStreamer()->SetNumberOfLinesStrippedStreaming( streaming ); descriptorsGenerator->Update(); // Normalize the samples // Read the mean and variance form the XML file StatisticsReader::Pointer statisticsReader = StatisticsReader::New(); statisticsReader->SetFileName(featureStatisticsFileName); SampleType meanMeasurentVector = statisticsReader->GetStatisticVectorByName("mean"); SampleType varianceMeasurentVector = statisticsReader->GetStatisticVectorByName("stddev"); // Shift scale the samples ShiftScaleListSampleFilterType::Pointer shiftscaleFilter = ShiftScaleListSampleFilterType::New(); shiftscaleFilter->SetInput(descriptorsGenerator->GetListSample()); shiftscaleFilter->SetShifts(meanMeasurentVector); shiftscaleFilter->SetScales(varianceMeasurentVector); shiftscaleFilter->Update(); SVMEstimatorType::Pointer svmEstimator = SVMEstimatorType::New(); svmEstimator->SetInputSampleList(shiftscaleFilter->GetOutput()); svmEstimator->SetTrainingSampleList(descriptorsGenerator->GetLabelListSample()); svmEstimator->Update(); svmEstimator->GetModel()->SaveModel(outputFileName); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/ObjectDetection/test/otbLabeledSampleLocalizationGenerator.cxx000066400000000000000000000051011301006202600331300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbLabeledSampleLocalizationGenerator.h" int otbLabeledSampleLocalizationGeneratorNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef otb::VectorData<> VectorDataType; typedef otb::LabeledSampleLocalizationGenerator GeneratorType; // instantiation GeneratorType::Pointer generator = GeneratorType::New(); std::cout << generator << std::endl; return EXIT_SUCCESS; } int otbLabeledSampleLocalizationGenerator(int itkNotUsed(argc), char* argv[]) { const char * inputVD1 = argv[1]; const char * inputVD2 = argv[2]; const char * outputVD = argv[3]; typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef otb::LabeledSampleLocalizationGenerator GeneratorType; // instantiation VectorDataReaderType::Pointer reader1 = VectorDataReaderType::New(); VectorDataReaderType::Pointer reader2 = VectorDataReaderType::New(); VectorDataWriterType::Pointer writer = VectorDataWriterType::New(); GeneratorType::Pointer generator = GeneratorType::New(); reader1->SetFileName(inputVD1); //reader1->Update(); reader2->SetFileName(inputVD2); //reader2->Update(); generator->PushBackInput(reader1->GetOutput()); generator->PushBackInput(reader2->GetOutput()); generator->SetSeed(0); // enable reproducible random number sequence generator->SetClassKey("Class"); generator->SetNoClassIdentifier(0); generator->SetInhibitionRadius(5); generator->SetRandomLocalizationDensity(0.004); generator->SetNbMaxIteration(1000); generator->SetNumberOfPositiveSamplesPerPoint(2); //generator->Update(); writer->SetFileName(outputVD); writer->SetInput(generator->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/ObjectDetection/test/otbObjectDetectionTestDriver.cxx000066400000000000000000000006601301006202600313040ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbLabeledSampleLocalizationGeneratorNew); REGISTER_TEST(otbLabeledSampleLocalizationGenerator); REGISTER_TEST(otbStandardMetaImageFunctionBuilderNew); REGISTER_TEST(otbStandardMetaImageFunctionBuilder); REGISTER_TEST(otbDescriptorsListSampleGeneratorNew); REGISTER_TEST(otbDescriptorsListSampleGenerator); REGISTER_TEST(otbDescriptorsSVMModelCreation); } OTB-release-5.8/Modules/Detection/ObjectDetection/test/otbStandardMetaImageFunctionBuilder.cxx000066400000000000000000000125721301006202600325570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStandardMetaImageFunctionBuilder.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFunctionAdaptor.h" #include "otbFlusserMomentsImageFunction.h" #include "otbRadiometricMomentsImageFunction.h" #include "otbFourierMellinDescriptorsImageFunction.h" #include "otbLocalHistogramImageFunction.h" #include "otbHaralickTexturesImageFunction.h" int otbStandardMetaImageFunctionBuilderNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef double PrecisionType; typedef otb::StandardMetaImageFunctionBuilder BuilderType; // instantiation BuilderType::Pointer builder = BuilderType::New(); std::cout << builder << std::endl; return EXIT_SUCCESS; } int otbStandardMetaImageFunctionBuilder(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; std::vector p1, p2, p3, p4, p5; typedef double PrecisionType; typedef double CoordRepType; typedef otb::StandardMetaImageFunctionBuilder BuilderType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileReader VectorImageReaderType; typedef BuilderType::MetaImageFunctionType MetaImageFunctionType; typedef BuilderType::DataObjectContainerType DataObjectContainerType; typedef otb::FlusserMomentsImageFunction FlusserMomentsIF; typedef otb::ImageFunctionAdaptor AdaptedFlusserMomentsIF; typedef otb::RadiometricMomentsImageFunction RadiometricMomentsIF; typedef otb::ImageFunctionAdaptor AdaptedRadiometricMomentsIF; typedef otb::FourierMellinDescriptorsImageFunction FourierMellinDescriptorsIF; typedef otb::ImageFunctionAdaptor AdaptedFourierMellinDescriptorsIF; p1.push_back(7); p1.push_back(128); p1.push_back(0); p1.push_back(1500); p2.push_back(6); p3.push_back(5); p4.push_back(9); p4.push_back(5); p4.push_back(5); p5.push_back(10); p5.push_back(1); p5.push_back(1500); p5.push_back(16); p5.push_back(4); // instantiation ImageReaderType::Pointer Ireader = ImageReaderType::New(); VectorImageReaderType::Pointer VIreader = VectorImageReaderType::New(); BuilderType::Pointer builder = BuilderType::New(); Ireader->SetFileName(inputFilename); VIreader->SetFileName(inputFilename); builder->AddImage(Ireader->GetOutput()); builder->SetNeighborhoodRadius(8); builder->SetLocalHistogramIFParameters(p1); builder->SetFlusserMomentsIFParameters(p2); builder->SetRadiometricMomentsIFParameters(p3); builder->SetFourierMellinDescriptorsIFParameters(p4); builder->SetHaralickTexturesIFParameters(p5); builder->AddImage(VIreader->GetOutput()); MetaImageFunctionType::Pointer MIF = builder->GetMetaImageFunction(); std::cout << MIF << std::endl; DataObjectContainerType DOC = builder->GetDataObjectContainer(); std::cout << "DataObjectContainer.size(): " << DOC.size() << std::endl; std::cout << static_cast(MIF->GetNthFunction(0))->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(3))->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(1))->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(7))->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(2))->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(11))->GetInternalImageFunction() << std::endl; /* std::cout << static_cast(MIF->GetNthFunction())->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(5))->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(4))->GetInternalImageFunction() << std::endl; std::cout << static_cast(MIF->GetNthFunction(21))->GetInternalImageFunction() << std::endl; */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/000077500000000000000000000000001301006202600216725ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/RoadExtraction/CMakeLists.txt000066400000000000000000000000551301006202600244320ustar00rootroot00000000000000project(OTBRoadExtraction) otb_module_impl() OTB-release-5.8/Modules/Detection/RoadExtraction/include/000077500000000000000000000000001301006202600233155ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbBreakAngularPathListFilter.h000066400000000000000000000052671301006202600313620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBreakAngularPathListFilter_h #define otbBreakAngularPathListFilter_h #include "otbPathListToPathListFilter.h" #include "otbMacro.h" namespace otb { /** \class BreakAngularPathListFilter * \brief CBase class for breaking angulars the input PathList, returning a PathList. * * \example FeatureExtraction/ExtractRoadByStepsExample.cxx * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT BreakAngularPathListFilter : public PathListToPathListFilter { public: /** Standard typedefs */ typedef BreakAngularPathListFilter Self; typedef PathListToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(BreakAngularPathListFilter, PathListToPathListFilter); /** Template parameters typedefs */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathListType PathListType; typedef typename Superclass::PathPointerType PathPointerType; typedef typename PathListType::Pointer PathListPointerType; typedef double MaxAngleType; /** Set/Get the max angle */ itkSetMacro(MaxAngle, MaxAngleType); itkGetConstMacro(MaxAngle, MaxAngleType); protected: /** Constructor */ BreakAngularPathListFilter(); /** Destructor */ ~BreakAngularPathListFilter() ITK_OVERRIDE {} /** GenerateData method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BreakAngularPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Calculate break angular for a path */ void BreakAngularPath(const MaxAngleType maxAngle, const PathPointerType inputPath, PathListPointerType outputPathList); /** Max angle value */ MaxAngleType m_MaxAngle; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBreakAngularPathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbBreakAngularPathListFilter.txx000066400000000000000000000064151301006202600317520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBreakAngularPathListFilter_txx #define otbBreakAngularPathListFilter_txx #include "otbBreakAngularPathListFilter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template BreakAngularPathListFilter ::BreakAngularPathListFilter() { } template void BreakAngularPathListFilter ::BreakAngularPath(const MaxAngleType maxAngle, const PathPointerType inputPath, PathListPointerType outputPathList) { typename PathType::VertexListType::ConstPointer vertexList = inputPath->GetVertexList(); typename PathType::VertexListType::ConstIterator pathIt = vertexList->Begin(); typename PathType::VertexType pixel1, pixel2, pixel3; // Initialization PathPointerType newPath = PathType::New(); newPath->Initialize(); double alpha1(0.), alpha2(0.); while (pathIt != vertexList->End()) { // Add Pixel 1 newPath->AddVertex(pathIt.Value()); pixel1 = pathIt.Value(); ++pathIt; if (pathIt != vertexList->End()) { pixel2 = pathIt.Value(); ++pathIt; if (pathIt != vertexList->End()) { pixel3 = pathIt.Value(); alpha1 = vcl_atan2((pixel1[1] - pixel2[1]), (pixel1[0] - pixel2[0])); alpha2 = vcl_atan2((pixel2[1] - pixel3[1]), (pixel2[0] - pixel3[0])); alpha1 = (alpha1 >= 0) ? alpha1 : (alpha1 + CONST_2PI); alpha2 = (alpha2 >= 0) ? alpha2 : (alpha2 + CONST_2PI); if (vcl_abs(alpha1 - alpha2) > static_cast(maxAngle)) { // Add Pixel 2 newPath->AddVertex(pixel2); //Create new PathType in the out path list outputPathList->PushBack(newPath); // Reinit newPath = PathType::New(); } --pathIt; // Return previous pixel } else { // Add last Pixel (Pixel 2) newPath->AddVertex(pixel2); } } } //Create new PathType in the out list outputPathList->PushBack(newPath); } template void BreakAngularPathListFilter ::GenerateData() { const PathListType * inputPathList = this->GetInput(); PathListType * outputPathList = this->GetOutput(); typename PathListType::ConstIterator listIt = inputPathList->Begin(); outputPathList->Clear(); PathListPointerType newTempPathList = PathListType::New(); while (listIt != inputPathList->End()) { (void) BreakAngularPath(m_MaxAngle, listIt.Get(), outputPathList); ++listIt; } } /** * PrintSelf Method */ template void BreakAngularPathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Angular max value : " << m_MaxAngle << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbGenericRoadExtractionFilter.h000066400000000000000000000252051301006202600315700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericRoadExtractionFilter_h #define otbGenericRoadExtractionFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkGradientRecursiveGaussianImageFilter.h" #include "otbVectorImage.h" #include "otbImageToPathListFilter.h" #include "itkSqrtImageFilter.h" #include "otbNeighborhoodScalarProductFilter.h" #include "otbNonMaxRemovalByDirectionFilter.h" #include "otbVectorizationPathListFilter.h" #include "otbSimplifyPathListFilter.h" #include "otbBreakAngularPathListFilter.h" #include "otbRemoveTortuousPathListFilter.h" #include "otbLinkPathListFilter.h" #include "otbRemoveIsolatedByDirectionFilter.h" #include "otbRemoveWrongDirectionFilter.h" #include "otbLikelihoodPathListFilter.h" namespace otb { /** * \class GenericRoadExtractionFilter * \brief This class performs the extraction of roads from an image. * * This composite filter implements a fast and robust road extraction * for high resolution satellite images. The line * detection is done using a Gaussian gradient with a scalar product to find * the road directions. Finally, extracted roads are vectorized and * processed to improve the results removing some occultations and false * detections. * * The full method is detailed in E. Christophe and J. Inglada, "Robust Road * Extraction for High Resolution Satellite Images," in IEEE International * Conference on Image Processing, ICIP'07, 2007. * * This filter is fast, as the detection typically takes 3 seconds for a * 1000 \f$ \times \f$ 1000 images with four spectral bands. Results can be * used as an initialization for more complex algorithms. * * \sa itk::SqrtImageFilter * \sa itk::GradientRecursiveGaussianImageFilter * \sa NeighborhoodScalarProductFilter * \sa RemoveIsolatedByDirectionFilter * \sa RemoveWrongDirectionFilter * \sa NonMaxRemovalByDirectionFilter * \sa VectorizationPathListFilter * \sa SimplifyPathListFilter * \sa BreakAngularPathListFilter * \sa RemoveTortuousPathListFilter * \sa LinkPathListFilter * \sa LikelihoodPathListFilter * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT GenericRoadExtractionFilter : public ImageToPathListFilter { public: /** Standard typedefs */ typedef GenericRoadExtractionFilter Self; typedef ImageToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(GenericRoadExtractionFilter, ImageToPathListFilter); /** Template parameters typedefs */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputPathType OutputPathType; typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename InputImageType::PixelType InputPixelType; typedef double InternalPixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ModulusType; typedef otb::Image DirectionType; typedef itk::CovariantVector VectorPixelType; typedef otb::Image CovariantVectorImageType; typedef itk::SqrtImageFilter< InputImageType, InputImageType> SquareRootImageFilterType; typedef itk::GradientRecursiveGaussianImageFilter< InputImageType, CovariantVectorImageType> GradientFilterType; typedef NeighborhoodScalarProductFilter< CovariantVectorImageType, ModulusType, DirectionType> NeighborhoodScalarProductFilterType; typedef RemoveIsolatedByDirectionFilter< ModulusType, DirectionType, ModulusType> RemoveIsolatedByDirectionFilterType; typedef RemoveWrongDirectionFilter< ModulusType, DirectionType, ModulusType> RemoveWrongDirectionFilterType; typedef NonMaxRemovalByDirectionFilter< ModulusType, DirectionType, ModulusType> NonMaxRemovalByDirectionFilterType; typedef VectorizationPathListFilter< ModulusType, DirectionType, OutputPathType> VectorizationPathListFilterType; typedef SimplifyPathListFilter SimplifyPathListFilterType; typedef BreakAngularPathListFilter BreakAngularPathListFilterType; typedef RemoveTortuousPathListFilter RemoveTortuousPathListFilterType; typedef LinkPathListFilter LinkPathListFilterType; typedef LikelihoodPathListFilter LikelihoodPathListFilterType; /** Template parameters typedefs for internals filters */ typedef typename GradientFilterType::RealType SigmaType; typedef typename VectorizationPathListFilterType::InputPixelType AmplitudeThresholdType; // typedef typename SimplifyPathListFilterType::ToleranceType ToleranceType; typedef double ToleranceType; typedef typename BreakAngularPathListFilterType::MaxAngleType MaxAngleType; // typedef typename RemoveTortuousPathListFilterType::MeanDistanceThresholdType MeanDistanceThresholdType; typedef double MeanDistanceThresholdType; typedef typename LinkPathListFilterType::RealType LinkRealType; /** Get/Set the alpha value */ itkGetConstReferenceMacro(Alpha, double); itkSetMacro(Alpha, double); /** Get/Set the amplitude threshold to start following a path (use by the VectorizationPathListFilter)*/ itkSetMacro(AmplitudeThreshold, AmplitudeThresholdType); itkGetMacro(AmplitudeThreshold, AmplitudeThresholdType); /** Get/Set the tolerance for segment consistency (tolerance in terms of distance) (use by the SimplifyPathListFilter)*/ itkGetMacro(Tolerance, ToleranceType); itkSetMacro(Tolerance, ToleranceType); /** Get/Set the resolution */ itkGetMacro(Resolution, double); itkSetMacro(Resolution, double); /** Set/Get the max angle (use bye the BreakAngularPathListFilter)*/ itkSetMacro(MaxAngle, MaxAngleType); itkGetConstMacro(MaxAngle, MaxAngleType); /** Get/Set the tolerance for segment consistency (tolerance in terms of distance) (use by RemoveTortuousPathListFilter)*/ itkGetMacro(FirstMeanDistanceThreshold, MeanDistanceThresholdType); itkSetMacro(FirstMeanDistanceThreshold, MeanDistanceThresholdType); itkGetMacro(SecondMeanDistanceThreshold, MeanDistanceThresholdType); itkSetMacro(SecondMeanDistanceThreshold, MeanDistanceThresholdType); /** Get/Set the angular threshold (use by LinkPathFilter)*/ itkSetMacro(AngularThreshold, LinkRealType); itkGetMacro(AngularThreshold, LinkRealType); /** Get/Set the distance threshold (use by LinkPathFilter)*/ itkSetMacro(DistanceThreshold, LinkRealType); itkGetMacro(DistanceThreshold, LinkRealType); protected: /** Constructor */ GenericRoadExtractionFilter(); /** Destructor */ ~GenericRoadExtractionFilter() ITK_OVERRIDE {} /** Prepare main computation method * Note : this function isn't called */ void BeforeGenerateData(void); /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GenericRoadExtractionFilter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented typename SquareRootImageFilterType::Pointer m_SquareRootImageFilter; typename GradientFilterType::Pointer m_GradientFilter; typename NeighborhoodScalarProductFilterType::Pointer m_NeighborhoodScalarProductFilter; typename RemoveIsolatedByDirectionFilterType::Pointer m_RemoveIsolatedByDirectionFilter; typename RemoveWrongDirectionFilterType::Pointer m_RemoveWrongDirectionFilter; typename NonMaxRemovalByDirectionFilterType::Pointer m_NonMaxRemovalByDirectionFilter; typename VectorizationPathListFilterType::Pointer m_VectorizationPathListFilter; typename SimplifyPathListFilterType::Pointer m_FirstSimplifyPathListFilter; typename SimplifyPathListFilterType::Pointer m_SecondSimplifyPathListFilter; typename BreakAngularPathListFilterType::Pointer m_BreakAngularPathListFilter; typename RemoveTortuousPathListFilterType::Pointer m_FirstRemoveTortuousPathListFilter; typename RemoveTortuousPathListFilterType::Pointer m_SecondRemoveTortuousPathListFilter; typename LinkPathListFilterType::Pointer m_LinkPathListFilter; typename LikelihoodPathListFilterType::Pointer m_LikelihoodPathListFilter; /** Amplitude threshold to start following a path (use by the VectorizationPathListFilter)*/ AmplitudeThresholdType m_AmplitudeThreshold; /** Tolerance for segment consistency (tolerance in terms of distance) (use by the SimplifyPathListFilter)*/ ToleranceType m_Tolerance; /** Max angle (use bye the BreakAngularPathListFilter)*/ MaxAngleType m_MaxAngle; /** Tolerance for segment consistency (tolerance in terms of distance) (use by RemoveTortuousPathListFilter)*/ MeanDistanceThresholdType m_FirstMeanDistanceThreshold; MeanDistanceThresholdType m_SecondMeanDistanceThreshold; /** The angular threshold (use by LinkPathListFilter) */ LinkRealType m_AngularThreshold; /** The distance threshold (use by LinkPathListFilter) */ double m_DistanceThreshold; /** Alpha. Use to calculate the sigma value used by the GradientRecursiveGaussianImageFilter */ double m_Alpha; /** Resolution of the image. Use to calculate the sigma value used by the GradientRecursiveGaussianImageFilter and the m_DistanceThreshold value used by the LinkPathListFilter This value is set bye the image's spacing.*/ double m_Resolution; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGenericRoadExtractionFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbGenericRoadExtractionFilter.txx000066400000000000000000000177701301006202600321740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericRoadExtractionFilter_txx #define otbGenericRoadExtractionFilter_txx #include "otbGenericRoadExtractionFilter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template GenericRoadExtractionFilter ::GenericRoadExtractionFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_SquareRootImageFilter = SquareRootImageFilterType::New(); m_GradientFilter = GradientFilterType::New(); m_NeighborhoodScalarProductFilter = NeighborhoodScalarProductFilterType::New(); m_RemoveIsolatedByDirectionFilter = RemoveIsolatedByDirectionFilterType::New(); m_RemoveWrongDirectionFilter = RemoveWrongDirectionFilterType::New(); m_NonMaxRemovalByDirectionFilter = NonMaxRemovalByDirectionFilterType::New(); m_VectorizationPathListFilter = VectorizationPathListFilterType::New(); m_FirstSimplifyPathListFilter = SimplifyPathListFilterType::New(); m_SecondSimplifyPathListFilter = SimplifyPathListFilterType::New(); m_BreakAngularPathListFilter = BreakAngularPathListFilterType::New(); m_FirstRemoveTortuousPathListFilter = RemoveTortuousPathListFilterType::New(); m_SecondRemoveTortuousPathListFilter = RemoveTortuousPathListFilterType::New(); m_LinkPathListFilter = LinkPathListFilterType::New(); m_LikelihoodPathListFilter = LikelihoodPathListFilterType::New(); /** Amplitude threshold to start following a path (use by the VectorizationPathListFilter)*/ m_AmplitudeThreshold = static_cast(0.00005); /** Tolerance for segment consistency (tolerance in terms of distance) (use by the SimplifyPathFilter)*/ m_Tolerance = static_cast(1.); /** Max angle (use bye the BreakAngularPathListFilter)*/ m_MaxAngle = static_cast(CONST_PI_8); /** Tolerance for segment consistency (tolerance in terms of distance) (use by RemoveTortuousPathFilter)*/ m_FirstMeanDistanceThreshold = static_cast(1.); m_SecondMeanDistanceThreshold = static_cast(10.); /** The angular threshold (use by LinkPathFilter) */ m_AngularThreshold = static_cast(CONST_PI_8); /** The distance threshold (use by LinkPathFilter) */ m_DistanceThreshold = 25.; /** Alpha value */ /** Use to calculate the sigma value use by the GradientRecursiveGaussianImageFilter */ m_Alpha = 1.0; /** Resolution of the image */ m_Resolution = 1.; } /** * Prepare main computation method */ template void GenericRoadExtractionFilter ::BeforeGenerateData() { /** Calculation of resolution value */ typename InputImageType::SpacingType spacing = this->GetInput()->GetSpacing(); // Getting x Spacing for the resolution m_Resolution = static_cast(spacing[0]); if (m_Resolution == 0.) { itkWarningMacro(<< "The image spacing is zero. So the resolution used in the filter is forced to 1."); m_Resolution = 1.; } } /** * Main computation method */ template void GenericRoadExtractionFilter ::GenerateData() { // // Input images pointers typename InputImageType::ConstPointer inputImage = this->GetInput(); typename OutputPathListType::Pointer outputPathList = this->GetOutput(); /////////////////////////////////////// //// Algorithm for road extraction //// /////////////////////////////////////// // m_SquareRootImageFilter->SetInput(inputImage); m_GradientFilter->SetInput(m_SquareRootImageFilter->GetOutput()); /** Sigma calculated with the alpha and image resolution parameters */ m_GradientFilter->SetSigma(static_cast(m_Alpha * (1.2 / m_Resolution + 1.))); m_GradientFilter->SetUseImageDirection(false); m_NeighborhoodScalarProductFilter->SetInput(m_GradientFilter->GetOutput()); m_RemoveIsolatedByDirectionFilter->SetInput(m_NeighborhoodScalarProductFilter->GetOutput()); m_RemoveIsolatedByDirectionFilter->SetInputDirection(m_NeighborhoodScalarProductFilter->GetOutputDirection()); m_RemoveWrongDirectionFilter->SetInput(m_RemoveIsolatedByDirectionFilter->GetOutput()); m_RemoveWrongDirectionFilter->SetInputDirection(m_NeighborhoodScalarProductFilter->GetOutputDirection()); m_NonMaxRemovalByDirectionFilter->SetInput(m_RemoveWrongDirectionFilter->GetOutput()); m_NonMaxRemovalByDirectionFilter->SetInputDirection(m_NeighborhoodScalarProductFilter->GetOutputDirection()); m_VectorizationPathListFilter->SetInput(m_NonMaxRemovalByDirectionFilter->GetOutput()); m_VectorizationPathListFilter->SetInputDirection(m_NeighborhoodScalarProductFilter->GetOutputDirection()); m_VectorizationPathListFilter->SetAmplitudeThreshold(m_AmplitudeThreshold); m_FirstSimplifyPathListFilter->SetInput(m_VectorizationPathListFilter->GetOutput()); m_FirstSimplifyPathListFilter->GetFunctor().SetTolerance(m_Tolerance); m_BreakAngularPathListFilter->SetInput(m_FirstSimplifyPathListFilter->GetOutput()); m_BreakAngularPathListFilter->SetMaxAngle(m_MaxAngle); m_FirstRemoveTortuousPathListFilter->SetInput(m_BreakAngularPathListFilter->GetOutput()); m_FirstRemoveTortuousPathListFilter->GetFunctor().SetThreshold(m_FirstMeanDistanceThreshold); m_LinkPathListFilter->SetInput(m_FirstRemoveTortuousPathListFilter->GetOutput()); m_LinkPathListFilter->SetAngularThreshold(m_AngularThreshold); m_LinkPathListFilter->SetDistanceThreshold(static_cast(m_DistanceThreshold / m_Resolution)); m_SecondSimplifyPathListFilter->SetInput(m_LinkPathListFilter->GetOutput()); m_SecondSimplifyPathListFilter->GetFunctor().SetTolerance(m_Tolerance); m_SecondRemoveTortuousPathListFilter->SetInput(m_SecondSimplifyPathListFilter->GetOutput()); m_SecondRemoveTortuousPathListFilter->GetFunctor().SetThreshold(m_SecondMeanDistanceThreshold); m_LikelihoodPathListFilter->SetInput(m_SecondRemoveTortuousPathListFilter->GetOutput()); m_LikelihoodPathListFilter->SetInputImage(m_NonMaxRemovalByDirectionFilter->GetOutput()); // Graft output seems to be broken for PolylineParametricPath // So we use update, and copy the path to the output path list. // m_LikelihoodPathListFilter->GraftOutput(this->GetOutput()); m_LikelihoodPathListFilter->Update(); // outputPathList = m_LikelihoodPathListFilter->GetOutput(); for (typename LikelihoodPathListFilterType::PathListType::ConstIterator it = m_LikelihoodPathListFilter->GetOutput()->Begin(); it != m_LikelihoodPathListFilter->GetOutput()->End(); ++it) { outputPathList->PushBack(it.Get()); } } /** * PrintSelf method */ template void GenericRoadExtractionFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "m_Alpha:" << m_Alpha << std::endl; os << indent << "m_Resolution:" << m_Resolution << std::endl; os << indent << "m_AmplitudeThreshold: " << m_AmplitudeThreshold << std::endl; os << indent << "m_Tolerance: " << m_Tolerance << std::endl; os << indent << "m_MaxAngle: " << m_MaxAngle << std::endl; os << indent << "m_FirstMeanDistanceThreshold: " << m_FirstMeanDistanceThreshold << std::endl; os << indent << "m_SecondMeanDistanceThreshold: " << m_SecondMeanDistanceThreshold << std::endl; os << indent << "m_DistanceThreshold: " << m_DistanceThreshold << std::endl; os << indent << "m_AngularThreshold: " << m_AngularThreshold << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbImageToPathListAlignFilter.h000066400000000000000000000137051301006202600313200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPathListAlignFilter_h #define otbImageToPathListAlignFilter_h #include "itkImageSource.h" #include "itkConceptChecking.h" #include "otbImage.h" #include "otbImageToPathListFilter.h" #include namespace otb { /** \class ImageToPathListAlignFilter * \brief Base class used to implement filter to extract align points or group of points and give the coordinates. * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT ImageToPathListAlignFilter : public ImageToPathListFilter { public: /** Standard class typedefs. */ typedef ImageToPathListAlignFilter Self; typedef ImageToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageToPathListAlignFilter, ImageToPathListFilter); // itkTypeMacro(ImageToPathListAlignFilter, itk::ImageSource); /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Some convenient typedefs. */ typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename InputImageType::PixelType PixelType; typedef typename Superclass::OutputPathType OutputPathType; // typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename Superclass::OutputPathPointerType OutputPathPointerType; // typedef float RealType; //typedef typename itk::NumericTraits::RealType RealType; typedef double RealType; // typedef typename itk::Image RealImageType; typedef typename otb::Image RealImageType; typedef typename RealImageType::Pointer RealImageTypePointer; typedef typename RealImageType::IndexType RealImageTypeIndexType; /** Spacing (size of a pixel) of the output image. The * spacing is the geometric distance between image samples. * It is stored internally as double, but may be set from * float. \sa GetSpacing() */ virtual void SetSpacing(const double* spacing); virtual void SetSpacing(const float* spacing); virtual const double* GetSpacing() const; /** Set/Get the value for pixels on and off the path. * By default, this filter will return a "0" image with path pixels set to 1 */ itkSetMacro(PathValue, ValueType); itkGetMacro(PathValue, ValueType); itkSetMacro(BackgroundValue, ValueType); itkGetMacro(BackgroundValue, ValueType); /** The origin of the output image. The origin is the geometric * coordinates of the index (0, 0, ..., 0). It is stored internally * as double but may be set from float. * \sa GetOrigin() */ virtual void SetOrigin(const double* origin); virtual void SetOrigin(const float* origin); virtual const double * GetOrigin() const; /** Set/Get Size */ itkSetMacro(Size, SizeType); itkGetMacro(Size, SizeType); itkSetMacro(isMeaningfulSegment, bool); itkSetMacro(NbGradDirection, int); itkSetMacro(NbLineDirection, int); itkSetMacro(MinGradNorm, double); itkSetMacro(Eps, double); itkGetConstReferenceMacro(isMeaningfulSegment, bool); itkGetConstReferenceMacro(NbGradDirection, int); itkGetConstReferenceMacro(NbLineDirection, int); itkGetConstReferenceMacro(MinGradNorm, double); itkGetConstReferenceMacro(Eps, double); protected: ImageToPathListAlignFilter(); ~ImageToPathListAlignFilter() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE {} // do nothing void GenerateData() ITK_OVERRIDE; virtual std::vector tab(int n, double p, double m); virtual void AngleCalculate(const InputImageType* InputImageIn); SizeType m_Size; double m_Spacing[InputImageDimension]; double m_Origin[InputImageDimension]; ValueType m_PathValue; ValueType m_BackgroundValue; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageToPathListAlignFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented bool m_isMeaningfulSegment; /// to get all meaningful segments (maximal or not int m_NbGradDirection; /// Number of allowed gradient direction, default 16 int m_NbLineDirection; /// Number of line directions to scan, default 96) double m_MinGradNorm; /// Minimum gradient norm to define a direction, default 2. double m_Eps; /// -log10(max. number of false alarms), default 0 std::vector m_seglist; RealImageType * m_AngleImage; //Angle image use by GenerateData and AngleCalculate methods }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToPathListAlignFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbImageToPathListAlignFilter.txx000066400000000000000000000405051301006202600317120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPathListAlignFilter_txx #define otbImageToPathListAlignFilter_txx #include "otbImageToPathListAlignFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkPathIterator.h" #include "itkNumericTraits.h" #include "itkImageLinearIteratorWithIndex.h" #include "otbMath.h" namespace otb { struct one_segment { short start; /* starting position (distance from border) */ short end; /* ending position (hence, length is end-start+1) */ double nfa; /* number of false alarms */ char ok; }; /** Constructor */ template ImageToPathListAlignFilter ::ImageToPathListAlignFilter() { this->SetNumberOfRequiredInputs(1); m_Size.Fill(0); m_isMeaningfulSegment = false; m_NbGradDirection = 16; m_NbLineDirection = 96; m_MinGradNorm = 2.0; m_Eps = 0.0; for (unsigned int i = 0; i < InputImageDimension; ++i) { // Set an image spacing for the user m_Spacing[i] = 1.0; m_Origin[i] = 0; } m_PathValue = itk::NumericTraits::One; m_BackgroundValue = itk::NumericTraits::Zero; } /** Destructor */ template ImageToPathListAlignFilter ::~ImageToPathListAlignFilter() { } //---------------------------------------------------------------------------- template void ImageToPathListAlignFilter ::SetSpacing(const double* spacing) { unsigned int i; for (i = 0; i < InputImageDimension; ++i) { if (spacing[i] != m_Spacing[i]) { break; } } if (i < InputImageDimension) { for (i = 0; i < InputImageDimension; ++i) { m_Spacing[i] = spacing[i]; } this->Modified(); } } template void ImageToPathListAlignFilter ::SetSpacing(const float* spacing) { unsigned int i; for (i = 0; i < InputImageDimension; ++i) { if ((double) spacing[i] != m_Spacing[i]) { break; } } if (i < InputImageDimension) { for (i = 0; i < InputImageDimension; ++i) { m_Spacing[i] = spacing[i]; } this->Modified(); } } template const double * ImageToPathListAlignFilter ::GetSpacing() const { return m_Spacing; } //---------------------------------------------------------------------------- template void ImageToPathListAlignFilter ::SetOrigin(const double* origin) { unsigned int i; for (i = 0; i < InputImageDimension; ++i) { if (origin[i] != m_Origin[i]) { break; } } if (i < InputImageDimension) { for (i = 0; i < InputImageDimension; ++i) { m_Origin[i] = origin[i]; } } } template void ImageToPathListAlignFilter ::SetOrigin(const float* origin) { unsigned int i; for (i = 0; i < InputImageDimension; ++i) { if ((double) origin[i] != m_Origin[i]) { break; } } if (i < InputImageDimension) { for (i = 0; i < InputImageDimension; ++i) { m_Origin[i] = origin[i]; } } } template const double * ImageToPathListAlignFilter ::GetOrigin() const { return m_Origin; } //---------------------------------------------------------------------------- /* Algorithm */ template std::vector ImageToPathListAlignFilter ::tab(int n, double p, double m) { std::vector out; int adr1, adr2, x, y; // double lambda; double q; q = 1.0 - p; out.resize((n + 1) * (n + 1)); adr1 = 0; /*** compute proba (=x among y) ***/ out[0] = 1.0; for (y = 1, adr2 = 0; y <= n; ++y) { adr1 = adr2; adr2 += n + 1; out[adr2] = q * out[adr1]; for (x = 1; x <= y; ++x) out[adr2 + x] = p * out[adr1 + x - 1] + q * out[adr1 + x]; } /*** sum to obtain proba (>=k among y) ***/ for (y = 1, adr1 = n + 1; y <= n; ++y, adr1 += n + 1) for (x = y - 1; x >= 0; x--) out[adr1 + x] += out[adr1 + x + 1]; /*** multiply by m (number of segments) to obtain expectation***/ for (adr1 = (n + 1) * (n + 1); --adr1 >= 0; ) out[adr1] *= m; return out; } template void ImageToPathListAlignFilter ::AngleCalculate(const InputImageType* InputImage) { double threshold; int n, p, x, y; typename InputImageType::SizeType Taille; typename RealImageType::IndexType IndexOut; Taille = InputImage->GetLargestPossibleRegion().GetSize(); typename RealImageType::RegionType region; region.SetSize(InputImage->GetLargestPossibleRegion().GetSize()); IndexOut[0] = 0; IndexOut[1] = 0; // region.SetIndex(InputImage->GetLargestPossibleRegion().GetIndex()); region.SetIndex(IndexOut); m_AngleImage->SetRegions(region); m_AngleImage->SetOrigin(InputImage->GetOrigin()); m_AngleImage->SetSpacing(InputImage->GetSpacing()); m_AngleImage->Allocate(); n = Taille[0]; p = Taille[1]; threshold = m_MinGradNorm; threshold *= threshold; typename InputImageType::IndexType idx; for (x = 0; x < p; ++x) { idx[0] = (n - 1); idx[1] = x; // indice = (n-1)*p +x m_AngleImage->SetPixel(idx, static_cast(-1000.0)); } for (y = 0; y < n; ++y) { idx[0] = y; idx[1] = p - 1; // indice = p*y+p-1 m_AngleImage->SetPixel(idx, static_cast(-1000.0)); } typename InputImageType::IndexType adr; RealType PixelA, PixelB, PixelC, PixelD; RealType com1, com2, gx, gy, norm; for (x = 0; x < p - 1; ++x) for (y = 0; y < n - 1; ++y) { // indice = y*p+x adr[0] = y; adr[1] = x; idx[0] = adr[0] + 1; idx[1] = adr[1] + 1; PixelA = static_cast(InputImage->GetPixel(idx)); idx[0] = adr[0]; idx[1] = adr[1]; assert(idx[0] < n); assert(idx[1] < p); assert(idx[0] >= 0); assert(idx[1] >= 0); PixelB = static_cast(InputImage->GetPixel(idx)); idx[0] = adr[0] + 1; idx[1] = adr[1]; assert(idx[0] < n); assert(idx[1] < p); assert(idx[0] >= 0); assert(idx[1] >= 0); PixelC = static_cast(InputImage->GetPixel(idx)); idx[0] = adr[0]; idx[1] = adr[1] + 1; assert(idx[0] < n); assert(idx[1] < p); assert(idx[0] >= 0); assert(idx[1] >= 0); PixelD = static_cast(InputImage->GetPixel(idx)); com1 = PixelA - PixelB; com2 = PixelC - PixelD; gx = 0.5 * (com1 + com2); gy = 0.5 * (com1 - com2); norm = gx * gx + gy * gy; if (norm <= threshold) m_AngleImage->SetPixel(adr, static_cast(-1000.0)); else m_AngleImage->SetPixel(adr, static_cast(vcl_atan2(gx, -gy))); } } template void ImageToPathListAlignFilter ::GenerateData(void) { // SizeType size; // double origin[InputImageDimension]; typename InputImageType::SizeType Taille; RealImageTypeIndexType indexAngle; // Flist result; int iseglist, size_seglist; /* associated counter and dynamic size */ int iseg, size_seg; double nfa, max_nfa; std::vector test; std::vector count, startbloc, endbloc; std::vector seglist; /* list of recorded segments */ std::vector seg; int mx, my, ox, oy, nx, ny, n; int xx, yy, pos, posmax, nblocs, inbloc, max_nblocs; int cur, i, j, side, l, lphase; // int tmp; int itheta, ntheta; double theta, theta0, dtheta, dx, dy, prec; double error = 0.0; itkDebugMacro(<< "ImageToPathListAlignFilter::GenerateData() called"); // Get the input and output pointers const InputImageType * InputImage = this->GetInput(); OutputPathListType * OutputPath = this->GetOutput(); // Generate the image /* Filter algorithm */ Taille = InputImage->GetLargestPossibleRegion().GetSize(); nx = Taille[0]; ny = Taille[1]; max_nfa = vcl_pow(10.0, -(m_Eps)); // typename InputImageType::IndexType adr; /*** maximal length for a line */ n = (int) vcl_ceil(hypot((double) nx, (double) ny)) + 1; /*** compute angle map of u ***/ RealImageTypePointer lAngleImagePointer = RealImageType::New(); m_AngleImage = static_cast(lAngleImagePointer.GetPointer()); this->AngleCalculate(InputImage); /*** compute P(k, l) ***/ test = tab(n, 1.0 / (double) (m_NbGradDirection), (double) (nx * ny) * (double) (nx * ny)); /*** initialization ***/ prec = CONST_PI / (double) (m_NbGradDirection); ntheta = m_NbLineDirection / 2; /* i.e. # directions of NON-ORIENTED lines */ dtheta = CONST_PI / (double) ntheta; /******************** memory allocation ********************/ max_nblocs = n / 2 + 1; /* maximal number of blocs */ count.resize(max_nblocs); startbloc.resize(max_nblocs); endbloc.resize(max_nblocs); size_seg = 10000; /* initial allocation (may reallocate later) */ seg.resize(size_seg); size_seglist = 10000; /* initial allocation (may reallocate later) */ seglist.resize(5 * size_seglist); /* counter for recorded segments (seglist) */ iseglist = 0; /******************** first loop : the four sides ********************/ for (side = 0; side < 4; side++) { printf("side %d/4 ", side + 1); theta0 = CONST_PI_2 * (double) side; mx = ((side == 0 || side == 2) ? 1 : 0); my = ((side == 1 || side == 3) ? 1 : 0); ox = ((side == 1) ? nx - 1 : 0); oy = ((side == 2) ? ny - 1 : 0); posmax = nx * mx + ny * my; /*** second loop : angles ***/ for (itheta = 0; itheta < ntheta; itheta++) { printf("."); fflush(stdout); theta = theta0 + (double) (itheta) * dtheta; dx = (double) vcl_cos((double) theta); dy = (double) vcl_sin((double) theta); /*** third loop : start positions ***/ for (pos = 0; pos < posmax; ++pos) { /* clear segment array */ iseg = 0; /*** fourth loop : phase for two-spaced pixels ***/ for (lphase = 0; lphase < 2; lphase++) { /*** detect aligned points by blocs ***/ inbloc = nblocs = cur = l = count[0] = 0; xx = ox + pos * mx + (int) (dx * (double) (l * 2 + lphase)); yy = oy + pos * my + (int) (dy * (double) (l * 2 + lphase)); for (; xx >= 0 && xx < nx && yy >= 0 && yy < ny; ) { indexAngle[0] = xx; indexAngle[1] = yy; // indice = yy*nx+xx assert(indexAngle[0] < nx); assert(indexAngle[1] < ny); assert(indexAngle[0] >= 0); assert(indexAngle[1] >= 0); error = static_cast(m_AngleImage->GetPixel(indexAngle)); if (error > -100.0) { error -= theta; while (error <= -CONST_PI) error += CONST_2PI; while (error > CONST_PI) error -= CONST_2PI; if (error < 0.0) error = -error; if (error < prec) { ++cur; if (!inbloc) { startbloc[nblocs] = l; inbloc = 1; } } else { if (inbloc) { endbloc[nblocs] = l - 1; ++nblocs; count[nblocs] = cur; } inbloc = 0; } } /* compute next point */ ++l; xx = ox + pos * mx + (int) (dx * (double) (l * 2 + lphase)); yy = oy + pos * my + (int) (dy * (double) (l * 2 + lphase)); } /*** detect meaningful segments ***/ for (i = 0; i < nblocs; ++i) for (j = i; j < nblocs; ++j) if ((nfa = test[count[j + 1] - count[i] + (n + 1) * (1 + endbloc[j] - startbloc[i])]) < max_nfa) { seg[iseg].start = startbloc[i] * 2 + lphase; seg[iseg].end = endbloc[j] * 2 + lphase; seg[iseg].nfa = nfa; seg[iseg].ok = 1; iseg++; /* reallocate if necessary */ if (iseg == size_seg) { size_seg = (size_seg * 3) / 2; seg.resize(size_seg); // if (!seg) // mwerror(FATAL, 1,"Not enough memory."); } } } /*** end of phase loop ***/ /*** remove non-maximal segments ***/ if (!m_isMeaningfulSegment) for (i = 0; i < iseg; ++i) for (j = 0; j < iseg; ++j) if (i != j) /* seg[i] is included in seg[j] ? */ if (seg[i].start >= seg[j].start && seg[i].end <= seg[j].end) { /* remove the less meaningful of seg[i] and seg[j] */ if (seg[i].nfa < seg[j].nfa) seg[j].ok = 0; else seg[i].ok = 0; } /*** store detected segments ***/ for (i = 0; i < iseg; ++i) if (seg[i].ok) { seglist[iseglist * 5] = (double) (ox + pos * mx) + dx * (double) (seg[i].start); seglist[iseglist * 5 + 1] = (double) (oy + pos * my) + dy * (double) (seg[i].start); seglist[iseglist * 5 + 2] = (double) (ox + pos * mx) + dx * (double) (seg[i].end); seglist[iseglist * 5 + 3] = (double) (oy + pos * my) + dy * (double) (seg[i].end); seglist[iseglist * 5 + 4] = -(double) log10(seg[i].nfa); iseglist++; /* reallocate seglist if necessary */ if (iseglist == size_seglist) { size_seglist = (size_seglist * 3) / 2; seglist.resize(size_seglist); // if (!seglist) // mwerror(FATAL, 1,"Not enough memory."); } } } } /*** end of second loop ***/ printf(" nb de segments: %d\n", iseglist); } /******************** end of first loop ********************/ seg.clear(); endbloc.clear(); startbloc.clear(); count.clear(); test.clear(); /* build segments list */ seglist.resize(5 * iseglist); /* build segments list */ OutputPath->Clear(); // OutputPath->Resize(iseglist); typedef typename OutputPathType::ContinuousIndexType ContinuousIndexType; typename InputImageType::PointType point; ContinuousIndexType cindex; for (i = 0; i < iseglist; ++i) { OutputPathPointerType path = OutputPathType::New(); path->Initialize(); point[0] = seglist[i * 5]; point[1] = seglist[i * 5 + 1]; InputImage->TransformPhysicalPointToContinuousIndex(point, cindex); path->AddVertex(cindex); cindex[0] = seglist[i * 5 + 2]; cindex[1] = seglist[i * 5 + 3]; path->AddVertex(cindex); OutputPath->PushBack(path); } itkDebugMacro(<< "ImageToPathListAlignFilter::GenerateData() finished"); } // end update function template void ImageToPathListAlignFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); // os << indent << "Size : " << m_Size << std::endl; // os << indent << "Path Value : " << m_PathValue << std::endl; // os << indent << "Background Value : " << m_BackgroundValue << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbLikelihoodPathListFilter.h000066400000000000000000000063151301006202600311020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLikelihoodPathListFilter_h #define otbLikelihoodPathListFilter_h #include "otbPathListToPathListFilter.h" #include "otbMacro.h" namespace otb { /** \class LikelihoodPathListFilter * \brief Affect a value to each path of the list based on the image * * PathList and image are given as an input, the filter affect a value to each * path: this value is equal to the sum of the pixels crossed by the path * (using a PolyLineImageConstIterator) divided by the number of points in the * path * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT LikelihoodPathListFilter : public PathListToPathListFilter { public: /** Standard typedefs */ typedef LikelihoodPathListFilter Self; typedef PathListToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(LikelihoodPathListFilter, PathListToPathListFilter); /** Template parameters typedefs */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathListType PathListType; typedef typename Superclass::PathPointerType PathPointerType; typedef typename PathListType::Pointer PathListPointerType; typedef typename PathListType::ConstIterator IteratorType; typedef typename PathType::VertexType VertexType; typedef typename PathType::VertexListType VertexListType; typedef typename VertexListType::ConstIterator VertexIteratorType; typedef double RealType; typedef TImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::ConstPointer ImageConstPointerType; /** * Set the input Likelihood image. * \param image The Likelihood image. */ void SetInputImage(const ImageType * image); /** * Get the input Likelihood image. * \return The input Likelihood image. */ const ImageType * GetInputImage(void); protected: /** Constructor */ LikelihoodPathListFilter(); /** Destructor */ ~LikelihoodPathListFilter() ITK_OVERRIDE {} /** GenerateData method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LikelihoodPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string m_Key; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLikelihoodPathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbLikelihoodPathListFilter.txx000066400000000000000000000052271301006202600314770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLikelihoodPathListFilter_txx #define otbLikelihoodPathListFilter_txx #include "otbLikelihoodPathListFilter.h" #include "otbPolyLineImageConstIterator.h" #include "itkMetaDataObject.h" namespace otb { /** * Constructor */ template LikelihoodPathListFilter ::LikelihoodPathListFilter() { m_Key = "Value"; this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(2); } template void LikelihoodPathListFilter ::SetInputImage(const ImageType * image) { this->itk::ProcessObject::SetNthInput(1, const_cast(image)); } template const typename LikelihoodPathListFilter ::ImageType * LikelihoodPathListFilter ::GetInputImage(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void LikelihoodPathListFilter ::GenerateData() { // I/O wiring ImageConstPointerType inputImagePtr = this->GetInputImage(); const PathListType * inputPtr = this->GetInput(); PathListType * outputPtr = this->GetOutput(); typedef otb::PolyLineImageConstIterator ImageIteratorType; for (IteratorType it = inputPtr->Begin(); it != inputPtr->End(); ++it) { PathPointerType path = it.Get(); ImageIteratorType imageIt(inputImagePtr, path); double cumulatedValues = 0.0; double nbPoints = 0.0; for (imageIt.GoToBegin(); !imageIt.IsAtEnd(); ++imageIt, ++nbPoints) { cumulatedValues += static_cast(imageIt.Get()); } itk::MetaDataDictionary& dict = path->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, m_Key, cumulatedValues / nbPoints); outputPtr->PushBack(path); } } /** * PrintSelf Method */ template void LikelihoodPathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbLinkPathListFilter.h000066400000000000000000000103451301006202600277120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLinkPathListFilter_h #define otbLinkPathListFilter_h #include "otbPathListToPathListFilter.h" #include "otbMacro.h" namespace otb { /** \class LinkPathListFilter * \brief This filters link path from the input path list according to distance and angular criterions. * * This filter examines both ends of each path to link and is able to link several path into one single path. * The two criterions to link a path are : * - The two ends to link must be closer than the user defined threshold in terms of euclidean distance, * - The angle at the link must not be sharp (less than the user defined threshold). * * Please note that this filter may invert the order of the vertices in the newly created path. * * This filter is part of the road extraction framework. * * \sa ParallelLinePathListFilter * * \ingroup PathFilters * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT LinkPathListFilter : public PathListToPathListFilter { public: /** Standard typedefs */ typedef LinkPathListFilter Self; typedef PathListToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(LinkPathListFilter, PathListToPathListFilter); /** Template parameters typedefs */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathListType PathListType; typedef typename Superclass::PathPointerType PathPointerType; typedef typename PathListType::Pointer PathListPointerType; typedef typename PathListType::ConstIterator IteratorType; typedef typename PathType::VertexType VertexType; typedef typename PathType::VertexListType VertexListType; typedef typename VertexListType::ConstIterator VertexIteratorType; typedef double RealType; itkSetMacro(AngularThreshold, RealType); itkGetMacro(AngularThreshold, RealType); itkSetMacro(DistanceThreshold, RealType); itkGetMacro(DistanceThreshold, RealType); itkSetMacro(ModuloPI, bool); itkGetMacro(ModuloPI, bool); protected: /** Constructor */ LinkPathListFilter(); /** Destructor */ ~LinkPathListFilter() ITK_OVERRIDE {} /** GenerateData method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Verify the angular condition to link a path. * \param v1 First vertex (before first path ending), * \param v2 second vertex (first path ending), * \param v3 third vertex (second path beginning), * \param v4 fourth vertex (second path after beginning), * \return True or false whether the condition is verified or not. **/ bool VerifyAngularCondition(VertexType v1, VertexType v2, VertexType v3, VertexType v4); /** * Actually link the end of path p1 to the beginning of path p2. * \param p1 First path to link, * \param revert1 whether p1 need to be reverted or not, * \param p2 second path to link, * \param revert2 whether p2 need to be reverted or not, * \return the linked path. */ PathPointerType LinkPath(PathPointerType p1, bool revert1, PathPointerType p2, bool revert2); private: LinkPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented RealType m_AngularThreshold; RealType m_DistanceThreshold; /// Do not use the sign of the orientation of the lines bool m_ModuloPI; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLinkPathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbLinkPathListFilter.txx000066400000000000000000000241721301006202600303110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLinkPathListFilter_txx #define otbLinkPathListFilter_txx #include "otbLinkPathListFilter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template LinkPathListFilter ::LinkPathListFilter() { m_DistanceThreshold = 10.; m_AngularThreshold = 3.14; m_ModuloPI = false; } template void LinkPathListFilter ::GenerateData() { // IO const PathListType * inputPtr = this->GetInput(); PathListType * outputPtr = this->GetOutput(); // Input iterator IteratorType inputIt = inputPtr->Begin(); std::vector eraseFlagVector; // First we copy all input path to output while (inputIt != inputPtr->End()) { outputPtr->PushBack(inputIt.Get()); eraseFlagVector.push_back(false); ++inputIt; } IteratorType outputIt1 = outputPtr->Begin(); unsigned int index1 = 0; while (outputIt1 != outputPtr->End()) { if (!eraseFlagVector[index1]) { IteratorType outputIt2 = outputIt1; ++outputIt2; // indicate if a path was found and wath is its index unsigned int pathToLinkIndex = 0; double distance = -1.0; unsigned int index2 = index1 + 1; bool found = false; bool revert1 = false; bool revert2 = false; if (!eraseFlagVector[index1]) { while (outputIt2 != outputPtr->End()) { if (!eraseFlagVector[index2]) { //otbMsgDevMacro(<<"Examining links between path "<GetVertexList()->End(); VertexIteratorType vTargetIt = outputIt2.Get()->GetVertexList()->Begin(); --vSourceIt; VertexType v2 = vSourceIt.Value(); --vSourceIt; VertexType v1 = vSourceIt.Value(); VertexType v3 = vTargetIt.Value(); ++vTargetIt; VertexType v4 = vTargetIt.Value(); double tmpDistance = vcl_sqrt(vcl_pow(v2[0] - v3[0], 2) + vcl_pow(v2[1] - v3[1], 2)); if ((tmpDistance < static_cast(m_DistanceThreshold)) && ((!found) || (tmpDistance < distance))) { if (VerifyAngularCondition(v1, v2, v3, v4)) { // we found a better candidate //otbMsgDevMacro(<<"Link between end of path "<GetVertexList()->End(); --vTargetIt; v3 = vTargetIt.Value(); --vTargetIt; v4 = vTargetIt.Value(); tmpDistance = vcl_sqrt(vcl_pow(v2[0] - v3[0], 2) + vcl_pow(v2[1] - v3[1], 2)); if ((tmpDistance < static_cast(m_DistanceThreshold)) && ((!found) || (tmpDistance < distance))) { if (VerifyAngularCondition(v1, v2, v3, v4)) { // we found a better candidate //otbMsgDevMacro(<<"Link between end of path "<GetVertexList()->Begin(); v2 = vSourceIt.Value(); ++vSourceIt; v1 = vSourceIt.Value(); tmpDistance = vcl_sqrt(vcl_pow(v2[0] - v3[0], 2) + vcl_pow(v2[1] - v3[1], 2)); if ((tmpDistance < static_cast(m_DistanceThreshold)) && ((!found) || (tmpDistance < distance))) { if (VerifyAngularCondition(v1, v2, v3, v4)) { // we found a better candidate //otbMsgDevMacro(<<"Link between beginning of path "<GetVertexList()->Begin(); v3 = vTargetIt.Value(); ++vTargetIt; v4 = vTargetIt.Value(); tmpDistance = vcl_sqrt(vcl_pow(v2[0] - v3[0], 2) + vcl_pow(v2[1] - v3[1], 2)); if ((tmpDistance < static_cast(m_DistanceThreshold)) && ((!found) || (tmpDistance < distance))) { if (VerifyAngularCondition(v1, v2, v3, v4)) { // we found a better candidate //otbMsgDevMacro(<<"Link between beginning of path "<Begin() + pathToLinkIndex; PathPointerType newPath = this->LinkPath(outputIt1.Get(), revert1, outputIt2.Get(), revert2); outputPtr->PushBack(newPath); // add a non erased flag for the new path eraseFlagVector.push_back(false); // mark the old path as erased eraseFlagVector[index1] = true; eraseFlagVector[pathToLinkIndex] = true; } } } ++index1; // This replaces ++outputIt1 because the iterators is somehow invalidated by a pushback. outputIt1 = outputPtr->Begin() + index1; } // search ended, now removing the erased path typename std::vector::reverse_iterator it = eraseFlagVector.rbegin(); index1 = eraseFlagVector.size() - 1; while (it != eraseFlagVector.rend()) { if (eraseFlagVector[index1]) { outputPtr->Erase(index1); } --index1; ++it; } } /** * Verify the angular condition to link a path. * \param v1 First vertex (before first path ending), * \param v2 second vertex (first path ending), * \param v3 third vertex (second path beginning), * \param v4 fourth vertex (second path after beginning), * \return True or false whether the condition is verified or not. **/ template bool LinkPathListFilter ::VerifyAngularCondition(VertexType v1, VertexType v2, VertexType v3, VertexType v4) { double alpha1 = vcl_atan2((v2[1] - v1[1]), (v2[0] - v1[0])); double alpha2 = vcl_atan2((v4[1] - v3[1]), (v4[0] - v3[0])); double alpha3 = vcl_atan2((v3[1] - v2[1]), (v3[0] - v2[0])); if (m_ModuloPI) { alpha1 = (alpha1 >= 0) ? alpha1 : (alpha1 + CONST_PI); alpha2 = (alpha2 >= 0) ? alpha2 : (alpha2 + CONST_PI); alpha3 = (alpha3 >= 0) ? alpha3 : (alpha3 + CONST_PI); } else { alpha1 = (alpha1 >= 0) ? alpha1 : (alpha1 + CONST_2PI); alpha2 = (alpha2 >= 0) ? alpha2 : (alpha2 + CONST_2PI); alpha3 = (alpha3 >= 0) ? alpha3 : (alpha3 + CONST_2PI); } bool resp = (vcl_abs(alpha1 - alpha2) < static_cast(m_AngularThreshold)) && (vcl_abs(alpha1 - alpha3) < static_cast(m_AngularThreshold)) && (vcl_abs(alpha2 - alpha3) < static_cast(m_AngularThreshold)); return resp; } /** * Actually link the end of path p1 to the beginning of path p2. * \param p1 First path to link, * \param revert1 whether p1 need to be reverted or not, * \param p2 second path to link, * \param revert2 whether p2 need to be reverted or not, * \return the linked path. */ template typename LinkPathListFilter ::PathPointerType LinkPathListFilter ::LinkPath(PathPointerType p1, bool revert1, PathPointerType p2, bool revert2) { PathPointerType resp = PathType::New(); VertexIteratorType it; if (revert1) { for (it = (p1->GetVertexList()->End()); it != p1->GetVertexList()->Begin(); ) { --it; resp->AddVertex((it).Value()); } } else { for (it = p1->GetVertexList()->Begin(); it != p1->GetVertexList()->End(); ++it) { resp->AddVertex((it).Value()); } } if (revert2) { for (it = (p2->GetVertexList()->End()); it != p2->GetVertexList()->Begin(); ) { --it; resp->AddVertex((it).Value()); } } else { for (it = p2->GetVertexList()->Begin(); it != p2->GetVertexList()->End(); ++it) { resp->AddVertex(it.Value()); } } return resp; } /** * PrintSelf Method */ template void LinkPathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbModulusAndDirectionImageToImageFilter.h000066400000000000000000000061541301006202600334740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbModulusAndDirectionImageToImageFilter_h #define otbModulusAndDirectionImageToImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class ModulusAndDirectionImageToImageFilter * * \brief Base class for modulus and direction image filters. * * This is the base class for alls class' generate an image dulus and * by using an modulus and a direction images intputs. * SetInput() method set the modulus image input and * SetInputDirection() set the image direction input. * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT ModulusAndDirectionImageToImageFilter : public itk::ImageToImageFilter { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef for the classes standards. */ typedef ModulusAndDirectionImageToImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(ModulusAndDirectionImageToImageFilter, itk::ImageToImageFilter); typedef typename Superclass::InputImageType InputImageType; typedef TInputImageDirection InputImageDirectionType; typedef typename Superclass::OutputImageType OutputImageType; /** Set/Get the image input of this process object. */ using Superclass::SetInput; void SetInput(const InputImageType *input) ITK_OVERRIDE; virtual void SetInputDirection(const InputImageDirectionType *direction); const InputImageType * GetInput(void); const InputImageDirectionType * GetInputDirection(void); protected: ModulusAndDirectionImageToImageFilter(); ~ModulusAndDirectionImageToImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ModulusAndDirectionImageToImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbModulusAndDirectionImageToImageFilter.txx" #endif #endif otbModulusAndDirectionImageToImageFilter.txx000066400000000000000000000066011301006202600340060ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/RoadExtraction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbModulusAndDirectionImageToImageFilter_txx #define otbModulusAndDirectionImageToImageFilter_txx #include "otbModulusAndDirectionImageToImageFilter.h" #include "itkProcessObject.h" namespace otb { /** * */ template ModulusAndDirectionImageToImageFilter:: ModulusAndDirectionImageToImageFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageType::New()); } template void ModulusAndDirectionImageToImageFilter:: SetInput(const InputImageType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template void ModulusAndDirectionImageToImageFilter:: SetInputDirection(const InputImageDirectionType *direction) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast(direction)); } /** Return the input image modulus */ template const typename ModulusAndDirectionImageToImageFilter::InputImageType * ModulusAndDirectionImageToImageFilter:: GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } /** Return the intput image direction */ template const typename ModulusAndDirectionImageToImageFilter::InputImageDirectionType * ModulusAndDirectionImageToImageFilter:: GetInputDirection(void) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1)); } /** * Standard "PrintSelf" method */ template void ModulusAndDirectionImageToImageFilter:: PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbNeighborhoodScalarProductFilter.h000066400000000000000000000121261301006202600324410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeighborhoodScalarProductFilter_h #define otbNeighborhoodScalarProductFilter_h #include "otbImageToModulusAndDirectionImageFilter.h" namespace otb { /** \class NeighborhoodScalarProductFilter * \brief This filter is designed to be part of a pipeline aiming at linear feature extraction, such as roads. * * This filter takes as input a two-band image resulting from a gradient operator. The first channel contains * the gradient value in the first image direction, the second contains the gradient value in the second image direction. * * Assuming that the linear feature we want to detect is darker than its surrounding environnement, we can deduce that * the gradient direction will be opposite on each side of the road. Therefore, we compute for each pixel to compute the scalar * product of the gradient vector for each opposite pixels in the neighborhood of radius 1 of the pixel to compute. * * The lower negativ scalar product value along these four pairs of pixel gives us the direction in which there is most * likely a linear feature. * * This filters has two outputs : * - The first output (from the GetOutput() method) gives the modulus of the lower negativ scalar product value for this pixel. * - The second output (from the GetOutputDirection() method) gives the direction in radian of this linear feature. * * Please note that there are only 8 possible values for the direction image, corresponding to two directions for each pair of opposite * pixels. In our conventions, negatives angle values represent opposite gradient vectors, whereas positive angle values represent convergent * gradient vectors. * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT NeighborhoodScalarProductFilter : public ImageToModulusAndDirectionImageFilter { public: /** Standard typedefs */ typedef NeighborhoodScalarProductFilter Self; typedef ImageToModulusAndDirectionImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NeighborhoodScalarProductFilter, ImageToModulusAndDirectionImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputModulus OutputModulusType; typedef typename OutputModulusType::Pointer OutputModulusPointerType; typedef typename OutputModulusType::RegionType RegionType; typedef typename OutputModulusType::SizeType SizeType; typedef typename OutputModulusType::IndexType IndexType; typedef TOutputDirection OutputDirectionType; typedef typename OutputDirectionType::Pointer OutputDirectionPointerType; typedef typename OutputDirectionType::RegionType OutputImageRegionType; protected: /** Constructor */ NeighborhoodScalarProductFilter(); /** Destructor */ ~NeighborhoodScalarProductFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** NeighborhoodScalarProductImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: NeighborhoodScalarProductFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNeighborhoodScalarProductFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbNeighborhoodScalarProductFilter.txx000066400000000000000000000137141301006202600330410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeighborhoodScalarProductFilter_txx #define otbNeighborhoodScalarProductFilter_txx #include "otbNeighborhoodScalarProductFilter.h" #include "itkImageRegionIterator.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template NeighborhoodScalarProductFilter ::NeighborhoodScalarProductFilter() {} template void NeighborhoodScalarProductFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // some typedefs typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::RadiusType RadiusType; typedef typename NeighborhoodIteratorType::OffsetType OffsetType; typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionIterator OutputDirectionIteratorType; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator BoundaryFacesCalculatorType; typedef typename BoundaryFacesCalculatorType::FaceListType FaceListType; typedef typename FaceListType::iterator FaceListIteratorType; // Pointers on inputs/outputs InputImageType * inputPtr = const_cast(this->GetInput()); OutputModulusPointerType outputPtr = this->GetOutput(); OutputDirectionPointerType outputDirPtr = this->GetOutputDirection(); // Neighborhood radius RadiusType r; r.Fill(1); // Find the data-set boundary "faces" BoundaryFacesCalculatorType bC; FaceListType faceList = bC(inputPtr, outputRegionForThread, r); FaceListIteratorType fit; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { NeighborhoodIteratorType neighInputIt(r, inputPtr, *fit); OutputIteratorType outputIt(outputPtr, *fit); OutputDirectionIteratorType outputDirIt(outputDirPtr, *fit); neighInputIt.GoToBegin(); outputIt.GoToBegin(); outputDirIt.GoToBegin(); while ((!neighInputIt.IsAtEnd()) && (!outputIt.IsAtEnd()) && (!outputDirIt.IsAtEnd())) { // local variable initialization int neighborhoodNumberMax = 0; double scalarMaxValue = 0; //TODO for a more general algorithm this might be replaced by: //double scalarMaxValue = itk::NumericTraits::NonpositiveMin(); int flagPosNegDirection = 0; // walk through each case for (int neighborhoodNumber = 0; neighborhoodNumber < 4; ++neighborhoodNumber) { double scalarCurrentValue = 0.0; OffsetType offset1; OffsetType offset2; switch (neighborhoodNumber) { case 0: offset1[0] = 1; offset1[1] = -1; offset2[0] = -1; offset2[1] = 1; break; case 1: offset1[0] = 1; offset1[1] = 0; offset2[0] = -1; offset2[1] = 0; break; case 2: offset1[0] = 1; offset1[1] = 1; offset2[0] = -1; offset2[1] = -1; break; case 3: offset1[0] = 0; offset1[1] = 1; offset2[0] = 0; offset2[1] = -1; break; } // Get the gradient values InputPixelType pixel1 = neighInputIt.GetPixel(offset1); InputPixelType pixel2 = neighInputIt.GetPixel(offset2); // Compute the scalar product scalarCurrentValue = -(pixel1[0] * pixel2[0] + pixel1[1] * pixel2[1]); // If the value is higher than the current max value if (scalarCurrentValue > scalarMaxValue) { // keep this configuration scalarMaxValue = scalarCurrentValue; neighborhoodNumberMax = neighborhoodNumber; // Also keep the direction if (pixel1[0] < 0) { flagPosNegDirection = 1; } else { flagPosNegDirection = 0; } } } // Compute the direction double angle = static_cast((1 + neighborhoodNumberMax)) * static_cast(CONST_PI_4); if (flagPosNegDirection) { angle -= CONST_PI; } // Set the output values outputIt.Set(scalarMaxValue); outputDirIt.Set(angle); ++neighInputIt; ++outputIt; ++outputDirIt; progress.CompletedPixel(); } } } /** * PrintSelf Method */ template void NeighborhoodScalarProductFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbNonMaxRemovalByDirectionFilter.h000066400000000000000000000117671301006202600322370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNonMaxRemovalByDirectionFilter_h #define otbNonMaxRemovalByDirectionFilter_h #include "otbModulusAndDirectionImageToImageFilter.h" #include "otbBinaryFunctorNeighborhoodImageFilter.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class NonMaxRemovalByDirectionFunctor * \brief This functor is used by the NonMaxRemovalByDirectionFilter * \sa NonMaxRemovalByDirectionFilter * \ingroup Functor * * \ingroup OTBRoadExtraction */ template class NonMaxRemovalByDirectionFunctor { public: NonMaxRemovalByDirectionFunctor() {} virtual ~NonMaxRemovalByDirectionFunctor() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB) { TOutput resp = 0; if (itA.GetCenterPixel() != 0) { typename TInput1::OffsetType offset1, offset2; offset1.Fill(0); offset2.Fill(0); int neighborhoodNumber; if (itB.GetCenterPixel() > 0) { neighborhoodNumber = static_cast(itB.GetCenterPixel() / (CONST_PI_4) -1); } else { neighborhoodNumber = static_cast((itB.GetCenterPixel() + CONST_PI) / (CONST_PI_4) -1); } switch (neighborhoodNumber) { case 0: offset1[0] = 1; offset1[1] = -1; offset2[0] = -1; offset2[1] = 1; break; case 1: offset1[0] = 1; offset1[1] = 0; offset2[0] = -1; offset2[1] = 0; break; case 2: offset1[0] = 1; offset1[1] = 1; offset2[0] = -1; offset2[1] = -1; break; case 3: offset1[0] = 0; offset1[1] = 1; offset2[0] = 0; offset2[1] = -1; break; } if ((itA.GetCenterPixel() > itA.GetPixel(offset1)) && (itA.GetCenterPixel() > itA.GetPixel(offset2))) { resp = itA.GetCenterPixel(); } } return resp; } }; } /** \class NonMaxRemovalByDirectionFilter * \brief This filters removes (sets to null intensity) pixels which are not the maxima of the * scalar product modulus value in the given direction. * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT NonMaxRemovalByDirectionFilter : public ModulusAndDirectionImageToImageFilter { public: /** Standard typedefs */ typedef NonMaxRemovalByDirectionFilter Self; typedef ModulusAndDirectionImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NonMaxRemovalByDirectionFilter, ModulusAndDirectionImageToImageFilter); /** typedef of the computing filter (this allows us to derive from ModulusAndDirectionToImageFilter as well as using the BinaryFunctorNeighBorhoodImageFilter, which is appropriate here */ typedef Functor::NonMaxRemovalByDirectionFunctor< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> FunctorType; typedef otb::BinaryFunctorNeighborhoodImageFilter ComputingFilterType; protected: /** Constructor */ NonMaxRemovalByDirectionFilter() {}; /** Destructor */ ~NonMaxRemovalByDirectionFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } /** Main computation method */ void GenerateData(void) ITK_OVERRIDE { typename ComputingFilterType::Pointer filter = ComputingFilterType::New(); filter->SetInput1(this->GetInput()); filter->SetInput2(this->GetInputDirection()); filter->GraftOutput(this->GetOutput()); filter->Update(); this->GraftOutput(filter->GetOutput()); } private: NonMaxRemovalByDirectionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbParallelLinePathListFilter.h000066400000000000000000000136241301006202600313640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbParallelLinePathListFilter_h #define otbParallelLinePathListFilter_h #include "otbPathListToPathListFilter.h" #include "otbMacro.h" namespace otb { /** \class ParallelLinePathListFilter * \brief Detects parallel lines in imagery, the required input data are a PathList object. * * The class consists of three basic functions that determine the angle between two lines, * the distance between the lines and the common part of the lines. First, all input lines * are checked if there is a second line running in the same direction. Thereafter, all line * pairs that already fulfilled the angular criterion are checked whether they are close to * each other or not, i.e. the orthogonal distance between them is calculated. Finally, it * has to be verified if the two lines have a common part since lines may fulfill the two * first criteria but be located in different parts of the image. In order to adapt the * detection algorithm to the user's needs, the thresholds AngularThreshold, DistanceThreshold * and CommonDistanceThreshold can be set. * * A possible processing chain would be to extract lines with a line detector, to convert the * result to PathList object (an ObjectList of PolyLineParametricPath), to link short line * segments with the otbLinkPathListFilter to longer lines and to finally detect all parallel * long lines. * * \sa LinkPathListFilter * * \ingroup PathFilters * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT ParallelLinePathListFilter : public PathListToPathListFilter { public: /** Standard typedefs */ typedef ParallelLinePathListFilter Self; typedef PathListToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ParallelLinePathListFilter, PathListToPathListFilter); /** Template parameters typedefs */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathListType PathListType; typedef typename Superclass::PathPointerType PathPointerType; typedef typename PathListType::Pointer PathListPointerType; typedef typename PathListType::ConstIterator IteratorType; typedef typename PathType::VertexType VertexType; typedef typename PathType::VertexListType VertexListType; typedef typename VertexListType::ConstIterator VertexIteratorType; typedef double RealType; itkSetMacro(AngularThreshold, RealType); itkGetMacro(AngularThreshold, RealType); itkSetMacro(DistanceThreshold, RealType); itkGetMacro(DistanceThreshold, RealType); itkSetMacro(CommonDistanceThreshold, RealType); itkGetMacro(CommonDistanceThreshold, RealType); protected: /** Constructor */ ParallelLinePathListFilter(); /** Destructor */ ~ParallelLinePathListFilter() ITK_OVERRIDE {} /** GenerateData method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Verify the angular condition to find parallel lines. * This function verifies if two lines are parallel by * computing the angle in relation to the y-axis. * First line segment: v1 is the first vertex, v2 the second one * (not necessarily the path ending). * Second line segment: v3 is the first vertex, v4 the second one * (not necessarily the path ending). * Return true if the condition is verified. * * This is the first criteria to be fulfilled. **/ bool VerifyAngularCondition(VertexType v1, VertexType v2, VertexType v3, VertexType v4); /** * Verify the maximum distance condition to find parallel lines. * The orthogonal distance between two parallel lines is calculated. * First line segment: v1 is the first vertex, v2 the second one * (not necessarily the path ending). * Second line segment: v3 is the first vertex, v4 the second one * (not necessarily the path ending). * Return true if the condition is verified. * * This is the second criteria to be fulfilled. **/ bool VerifyMaxDistanceCondition(VertexType v1, VertexType v2, VertexType v3, VertexType v4); /** * Verify the common distance condition to find parallel lines. * The overlapping part of the parallel lines is computed. In case * no overlapping part exists or the value is below the specified * threshold, false is returned. * First line segment: v1 is the first vertex, v2 the second one * (not necessarily the path ending). * Second line segment: v3 is the first vertex, v4 the second one * (not necessarily the path ending). * Return true if the condition is verified. * * This is the third criteria to be fulfilled. **/ bool VerifyCommonDistanceCondition(VertexType v1, VertexType v2, VertexType v3, VertexType v4); /** * Write the first parallel path. * p1: First parallel path (line segment), */ PathPointerType WriteParallelPath(PathPointerType p1); private: ParallelLinePathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented RealType m_AngularThreshold; RealType m_DistanceThreshold; RealType m_CommonDistanceThreshold; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbParallelLinePathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbParallelLinePathListFilter.txx000066400000000000000000000405221301006202600317550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbParallelLinePathListFilter_txx #define otbParallelLinePathListFilter_txx #include "otbParallelLinePathListFilter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template ParallelLinePathListFilter ::ParallelLinePathListFilter() { m_DistanceThreshold = 100.; m_CommonDistanceThreshold = 10.; m_AngularThreshold = 3.14; } template void ParallelLinePathListFilter ::GenerateData() { // IO const PathListType * inputPtr = this->GetInput(); PathListType * outputPtr = this->GetOutput(); // Input iterator IteratorType inputIt = inputPtr->Begin(); std::vector eraseFlagVector1; std::vector parallelLineIndex; // First we copy all input path to output while (inputIt != inputPtr->End()) { // Write the next input path always to the // last element of the list. This last element is // newly created. outputPtr->PushBack(inputIt.Get()); // If a new element is copied to the output vector, // "false" is written to the corresponding index of // the vector eraseFlagVector. eraseFlagVector1.push_back(false); ++inputIt; } unsigned int VectorSize = static_cast(eraseFlagVector1.size()); //std::cout<<" Number of Lines: "<< VectorSize <Begin(); unsigned int index1 = 0; unsigned int firstLineCounter = 0, parallelLineCounter = 0; unsigned int commonDistCounter = 0, maxDistCounter = 0; // Iterate through all lines of the pathlist while (firstLineCounter < VectorSize) { if (!eraseFlagVector1[index1]) { IteratorType outputIt2 = outputIt1; ++outputIt2; unsigned int index2 = index1 + 1; // Check if any of the following lines are parallel while (outputIt2 != outputPtr->End()) { if (!eraseFlagVector1[index2]) { // Read the first and the last vertex of each line pair that is checked VertexIteratorType vSourceIt = outputIt1.Get()->GetVertexList()->Begin(); VertexType v1 = vSourceIt.Value(); vSourceIt = outputIt1.Get()->GetVertexList()->End(); --vSourceIt; VertexType v2 = vSourceIt.Value(); VertexIteratorType vTargetIt = outputIt2.Get()->GetVertexList()->Begin(); VertexType v3 = vTargetIt.Value(); vTargetIt = outputIt2.Get()->GetVertexList()->End(); --vTargetIt; VertexType v4 = vTargetIt.Value(); // Check for parallel lines if (VerifyAngularCondition(v1, v2, v3, v4)) { ++parallelLineCounter; if (VerifyMaxDistanceCondition(v1, v2, v3, v4)) { ++maxDistCounter; if (VerifyCommonDistanceCondition(v1, v2, v3, v4)) { ++commonDistCounter; // Write index of first parallel path parallelLineIndex.push_back(index1); // Write index of second parallel path parallelLineIndex.push_back(index2); } } } } ++index2; ++outputIt2; } } // mark the old path as erased eraseFlagVector1[index1] = true; ++firstLineCounter; ++index1; ++outputIt1; } // end of for loop otbMsgDevMacro( << "Number of line pairs that pass the angular condition: " << parallelLineCounter ); otbMsgDevMacro( << "Number of line pairs that pass the maximum distance condition: " << maxDistCounter ); otbMsgDevMacro( << "Number of line pairs that pass the common distance condition: " << commonDistCounter ); // Write all parallel lines and set the non-erase flagg. typename std::vector::iterator lineIt1 = parallelLineIndex.begin(); unsigned int sortLineIndex = 0; while (lineIt1 != parallelLineIndex.end()) { IteratorType outputIt3 = outputPtr->Begin() + parallelLineIndex[sortLineIndex]; PathPointerType newPath1 = this->WriteParallelPath(outputIt3.Get()); outputPtr->PushBack(newPath1); // add a non-erase flag for the new path eraseFlagVector1.push_back(false); ++sortLineIndex; otbMsgDevMacro( << "Number of lines written in the path list: " << sortLineIndex ); ++lineIt1; } // Search ended, now removing the erased path from the first line pointer typename std::vector::reverse_iterator it1 = eraseFlagVector1.rbegin(); index1 = eraseFlagVector1.size() - 1; while (it1 != eraseFlagVector1.rend()) { if (eraseFlagVector1[index1]) { outputPtr->Erase(index1); } --index1; ++it1; } } /** * Verify the angular condition to find parallel lines. * This function verifies if two lines are parallel by * computing the angle in relation to the y-axis. * First line segment: v1 is the first vertex, v2 the second one * (not necessarily the path ending). * Second line segment: v3 is the first vertex, v4 the second one * (not necessarily the path ending). * Return true if the condition is verified. * * This is the first criteria to be fulfilled. **/ template bool ParallelLinePathListFilter ::VerifyAngularCondition(VertexType v1, VertexType v2, VertexType v3, VertexType v4) { double alpha1 = vcl_atan2((v2[1] - v1[1]), (v2[0] - v1[0])); double alpha2 = vcl_atan2((v4[1] - v3[1]), (v4[0] - v3[0])); alpha1 = (alpha1 >= 0) ? alpha1 : (alpha1 + CONST_PI); alpha2 = (alpha2 >= 0) ? alpha2 : (alpha2 + CONST_PI); // Return true if the angle between the two lines is smaller than // the specified threshold. bool angle = (vcl_abs(alpha1 - alpha2) < static_cast(m_AngularThreshold)); return angle; } /** * Verify the maximum distance condition to find parallel lines. * The orthogonal distance between two parallel lines is calculated. * First line segment: v1 is the first vertex, v2 the second one * (not necessarily the path ending). * Second line segment: v3 is the first vertex, v4 the second one * (not necessarily the path ending). * Return true if the condition is verified. * * This is the second criteria to be fulfilled. **/ template bool ParallelLinePathListFilter ::VerifyMaxDistanceCondition(VertexType v1, VertexType v2, VertexType v3, VertexType itkNotUsed(v4)) { // Compute the direction vector of the first line VertexType vectorDir12; vectorDir12[0] = v2[0] - v1[0]; vectorDir12[1] = v2[1] - v1[1]; // Compute the orthogonal distance between the two parallel lines // with equation d = |(v3 - v1)X(v2 - v1)|/|v2 - v1| double distance = 0., denominator = 0., nominator = 0.; denominator = vcl_abs((v3[0] - v1[0]) * vectorDir12[1] - (v3[1] - v1[1]) * vectorDir12[0]); nominator = sqrt(pow(vectorDir12[0], 2) + pow(vectorDir12[1], 2)); distance = denominator / nominator; //std::cout<< "Distance between two parallel lines: " << distance <(m_DistanceThreshold)); return dist; } /** * Verify the common distance condition to find parallel lines. * The overlapping part of the parallel lines is computed. In case * no overlapping part exists or the value is below the specified * threshold, false is returned. * First line segment: v1 is the first vertex, v2 the second one * (not necessarily the path ending). * Second line segment: v3 is the first vertex, v4 the second one * (not necessarily the path ending). * Return true if the condition is verified. * * This is the third criteria to be fulfilled. **/ template bool ParallelLinePathListFilter ::VerifyCommonDistanceCondition(VertexType v1, VertexType v2, VertexType v3, VertexType v4) { // Compute the length of each line double length12 = 0.; // double length34 = 0.; length12 = sqrt(pow((v2[0] - v1[0]), 2) + pow((v2[1] - v1[1]), 2)); //length34 = sqrt(pow((v4[0] - v3[0]), 2) + pow((v4[1] - v3[1]), 2)); // Set v1[0] to zero and align the y-axis of // the new coordinate system with line one (v1 and v2). // Compute the coordinates of the first and of the // second line in the new coordinate system. VertexType tempv1, tempv2, tempv3, tempv4; //Initialization tempv1.Fill(0.); tempv2.Fill(0.); tempv3.Fill(0.); tempv4.Fill(0.); if (v1[1] == v2[1]) { if (v1[0] < v2[0]) { tempv1[0] = 0., tempv1[1] = 0.; tempv2[0] = 0., tempv2[1] = length12; tempv3[0] = v3[0] - v1[0], tempv3[1] = v3[1] - v1[1]; tempv4[0] = v4[0] - v1[0], tempv4[1] = v4[1] - v1[1]; } else { tempv2[0] = 0., tempv2[1] = 0.; tempv1[0] = 0., tempv1[1] = length12; tempv3[0] = v3[0] - v2[0], tempv3[1] = v3[1] - v2[1]; tempv4[0] = v4[0] - v2[0], tempv4[1] = v4[1] - v2[1]; } } // Check the direction of the line (vector). // The origin of the new coordinate system is // set to the smaller of the two vertices. // Then, a rotation and translation of the vertices // of the second line (v3 and v4) to the new coordinate // system is performed. VertexType temptransv3, temptransv4; if (v1[1] < v2[1]) { if (v1[0] == v2[0]) { tempv1[0] = 0., tempv1[1] = 0.; tempv2[0] = 0., tempv2[1] = length12; tempv3[0] = v3[0] - v1[0], tempv3[1] = v3[1] - v1[1]; tempv4[0] = v4[0] - v1[0], tempv4[1] = v4[1] - v1[1]; } else { // Coordinates of the first line in the new coordinate system tempv1[0] = 0.; tempv1[1] = 0.; tempv2[0] = 0.; tempv2[1] = length12; // Rotate the system clockwise double sinealpha; if (v2[0] > v1[0]) { sinealpha = (v2[0] - v1[0]) / length12; } else { sinealpha = (v1[0] - v2[0]) / length12; } double alpha1 = vcl_asin(sinealpha); // Translation temptransv3[0] = v3[0] - v1[0]; temptransv3[1] = v3[1] - v1[1]; temptransv4[0] = v4[0] - v1[0]; temptransv4[1] = v4[1] - v1[1]; // Rotation tempv3[0] = temptransv3[0] * cos(alpha1) + temptransv3[1] * sin(alpha1); tempv3[1] = temptransv3[1] * cos(alpha1) - temptransv3[0] * sin(alpha1); tempv4[0] = temptransv4[0] * cos(alpha1) + temptransv4[1] * sin(alpha1); tempv4[1] = temptransv4[1] * cos(alpha1) - temptransv4[0] * sin(alpha1); otbMsgDevMacro(<< "tempv1[0], tempv1[1], tempv2[0], tempv2[1]: " ); otbMsgDevMacro(<< tempv1[0] << ", " << tempv1[1] << ", " << tempv2[0] << ", " << tempv2[1] ); otbMsgDevMacro(<< "Alpha: " << alpha1 ); otbMsgDevMacro(<< "tempv3[0], tempv3[1], tempv4[0], tempv4[1]: " << tempv3[0] << ", " << tempv3[1] << ", " << tempv4[0] << ", " << tempv4[1] ); otbMsgDevMacro(<< "Calculated length of the second line: " << sqrt(pow((tempv4[0] - tempv3[0]), 2) + pow((tempv4[1] - tempv3[1]), 2)) ); otbMsgDevMacro(<< "Original length of line 1: " << length12 ); } } if (v2[1] < v1[1]) { if (v1[0] == v2[0]) { tempv2[0] = 0., tempv2[1] = 0.; tempv1[0] = 0., tempv1[1] = length12; tempv3[0] = v3[0] - v2[0], tempv3[1] = v3[1] - v2[1]; tempv4[0] = v4[0] - v2[0], tempv4[1] = v4[1] - v2[1]; } else { tempv1[0] = 0.; tempv1[1] = 0.; tempv2[0] = 0.; tempv2[1] = length12; // Rotate the system clockwise double sinealpha; if (v2[0] > v1[0]) { sinealpha = (v2[0] - v1[0]) / length12; } else { sinealpha = (v1[0] - v2[0]) / length12; } double alpha1 = vcl_asin(sinealpha); // Translation temptransv3[0] = v3[0] - v2[0]; temptransv3[1] = v3[1] - v2[1]; temptransv4[0] = v4[0] - v2[0]; temptransv4[1] = v4[1] - v2[1]; // Rotation tempv3[0] = temptransv3[0] * cos(alpha1) + temptransv3[1] * sin(alpha1); tempv3[1] = temptransv3[1] * cos(alpha1) - temptransv3[0] * sin(alpha1); tempv4[0] = temptransv4[0] * cos(alpha1) + temptransv4[1] * sin(alpha1); tempv4[1] = temptransv4[1] * cos(alpha1) - temptransv4[0] * sin(alpha1); otbMsgDevMacro( << "tempv1[0], tempv1[1], tempv2[0], tempv2[1]: " ); otbMsgDevMacro( << tempv1[0] << ", " << tempv1[1] << ", " << tempv2[0] << ", " << tempv2[1] ); otbMsgDevMacro( << "Alpha: " << alpha1 ); otbMsgDevMacro( << "tempv3[0], tempv3[1], tempv4[0], tempv4[1]: " << tempv3[0] << ", " << tempv3[1] << ", " << tempv4[0] << ", " << tempv4[1] ); otbMsgDevMacro( << "Calculated length of the second line: " << sqrt(pow((tempv4[0] - tempv3[0]), 2) + pow((tempv4[1] - tempv3[1]), 2)) ); otbMsgDevMacro( << "Original length of line 1: " << length12 ); } } // Compute the length of the overlapping part // of the two lines. This is done by simply // comparing the y-values of the lines (remember // that both lines are parallel and also parallel // to the new y-axis). double commonDist = 0.; if (tempv3[1] >= tempv4[1]) { if (tempv3[1] >= 0 && tempv3[1] <= tempv2[1]) { if (tempv4[1] >= 0) { commonDist = vcl_abs(tempv4[1] - tempv3[1]); } else if (tempv4[1] < 0) { commonDist = tempv3[1]; } } else if (tempv3[1] >= 0 && tempv3[1] >= tempv2[1]) { if (tempv4[1] >= 0) { commonDist = tempv2[1] - tempv4[1]; } else if (tempv4[1] < 0) { commonDist = tempv2[1]; } } else if (tempv4[1] >= tempv2[1]) { // No overlapping parts exist. The (negative) distance // between the two closest endpoints is calculated. commonDist = -vcl_abs(tempv4[1] - tempv2[1]); } else if (tempv3[1] < 0) { // No overlapping parts exist. The (negative) distance // between the two closest endpoints is calculated. commonDist = tempv3[1]; } } else { if (tempv4[1] >= 0 && tempv4[1] <= tempv2[1]) { if (tempv3[1] >= 0) { commonDist = vcl_abs(tempv3[1] - tempv4[1]); } else if (tempv3[1] < 0) { commonDist = tempv4[1]; } } else if (tempv4[1] >= 0 && tempv4[1] >= tempv2[1]) { if (tempv3[1] >= 0) { commonDist = tempv2[1] - tempv3[1]; } else if (tempv3[1] < 0) { commonDist = tempv2[1]; } } else if (tempv3[1] >= tempv2[1]) { // No overlapping parts exist. The (negative) distance // between the two closest endpoints is calculated. commonDist = -vcl_abs(tempv3[1] - tempv2[1]); } else if (tempv4[1] < 0) { // No overlapping parts exist. The (negative) distance // between the two closest endpoints is calculated. commonDist = tempv4[1]; } } // The common parallel parts of the two lines have to be greater than // the provided threshold. otbMsgDevMacro( << "Calculated common distance of the parallel lines: " << commonDist ); bool common = (commonDist >= static_cast(m_CommonDistanceThreshold)); return common; } /** * Write parallel line in a new path list. * p1: First parallel path (line segment) */ template typename ParallelLinePathListFilter ::PathPointerType ParallelLinePathListFilter ::WriteParallelPath(PathPointerType p1) { PathPointerType resp = PathType::New(); VertexIteratorType it; for (it = p1->GetVertexList()->Begin(); it != p1->GetVertexList()->End(); ++it) { resp->AddVertex((it).Value()); } return resp; } /** * PrintSelf Method */ template void ParallelLinePathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbRemoveIsolatedByDirectionFilter.h000066400000000000000000000113071301006202600324210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRemoveIsolatedByDirectionFilter_h #define otbRemoveIsolatedByDirectionFilter_h #include "otbModulusAndDirectionImageToImageFilter.h" #include "otbBinaryFunctorNeighborhoodImageFilter.h" namespace otb { namespace Functor { /** \class RemoveIsolatedByDirectionFunctor * \brief Binary neighborhood functor to remove isolated pixels by direction. * Used by the RemoveIsolatedByDirectionFilter. * \sa RemoveIsolatedByDirectionFilter * \ingroup Functor * * \ingroup OTBRoadExtraction */ template class RemoveIsolatedByDirectionFunctor { public: RemoveIsolatedByDirectionFunctor() {} virtual ~RemoveIsolatedByDirectionFunctor() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB) { double currentDirection = itB.GetCenterPixel(); int nEqualNeighbors = 0; for (int neighborhoodIndex = 0; neighborhoodIndex < 9; ++neighborhoodIndex) { if (itB.GetPixel(neighborhoodIndex) == currentDirection) { ++nEqualNeighbors; } } if (nEqualNeighbors <= 1) { //should never be 0 as it is at least equal to itself return 0; } else { return static_cast(itA.GetCenterPixel()); } } }; } /** \class RemoveIsolatedByDirectionFilter * \brief This filter removes (sets to null intensity) pixels isolated by direction. * * For a given pixel, the filter walk through its neighborhood in direction image, counting pixels having * the same direction as the center pixel. If there is no such a pixel, the center pixel is considered to be * isolated in direction, and thus will be removed (set to 0). If the pixel is not isolated in direction, the output * value is the value of the pixel in the modulus image. * Of course this filter requires the direction to be discrete, in order to be able to count the directions. * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT RemoveIsolatedByDirectionFilter : public ModulusAndDirectionImageToImageFilter { public: /** Standard typedefs */ typedef RemoveIsolatedByDirectionFilter Self; typedef ModulusAndDirectionImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(RemoveIsolatedByDirectionFilter, ModulusAndDirectionImageToImageFilter); /** typedef of the computing filter (this allows us to derive from ModulusAndDirectionToImageFilter as well as using the BinaryFunctorNeighBorhoodImageFilter, which is appropriate here */ typedef Functor::RemoveIsolatedByDirectionFunctor< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> FunctorType; typedef otb::BinaryFunctorNeighborhoodImageFilter ComputingFilterType; protected: /** Constructor */ RemoveIsolatedByDirectionFilter() {}; /** Destructor */ ~RemoveIsolatedByDirectionFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } /** Main computation method */ void GenerateData(void) ITK_OVERRIDE { typename ComputingFilterType::Pointer filter = ComputingFilterType::New(); filter->SetInput1(this->GetInput()); filter->SetInput2(this->GetInputDirection()); filter->GraftOutput(this->GetOutput()); filter->Update(); this->GraftOutput(filter->GetOutput()); } private: RemoveIsolatedByDirectionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbRemoveTortuousPathListFilter.h000066400000000000000000000036311301006202600320370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRemoveTortuousPathListFilter_h #define otbRemoveTortuousPathListFilter_h #include "otbUnaryFunctorObjectListBooleanFilter.h" #include "otbPathMeanDistanceFunctor.h" #include "otbObjectList.h" namespace otb { /** \class RemoveTortuousPathListFilter * \brief This filter remove path considered as tortuous. * * A path is considered to be tortuous if the mean distance between each consecutive vertices * is strictly lower than the user provided threshold. * * This class is just a shortcut to the UnaryFunctorObjectListBooleanFilter with * the PathMeanDistanceFunctor. * *Recent API changes: * Now part of the UnaryFunctorObjectListBooleanFilter hierarchy, replace call to SetMeanDistanceThreshold() * by GetFunctor().SetThreshold(). * * The inequality is now a strict one. * * \sa BreakAngularPathListFilter * \sa SimplifyPathFilter * \sa UnaryFunctorObjectListBooleanFilter * \sa PathMeanDistanceFunctor * * \example FeatureExtraction/ExtractRoadByStepsExample.cxx * * * \ingroup OTBRoadExtraction */ // template template class ITK_EXPORT RemoveTortuousPathListFilter : public UnaryFunctorObjectListBooleanFilter< ObjectList, ObjectList, PathMeanDistanceFunctor > {}; } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbRemoveWrongDirectionFilter.h000066400000000000000000000101521301006202600314530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRemoveWrongDirectionFilter_h #define otbRemoveWrongDirectionFilter_h #include "otbModulusAndDirectionImageToImageFilter.h" #include "itkBinaryFunctorImageFilter.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class RemoveWrongDirectionFunctor * \brief This functor is used by the RemoveWrongDirectionFilter * * \sa RemoveWrongDirectionFilter * \ingroup Functor * * \example FeatureExtraction/ExtractRoadByStepsExample.cxx * * * \ingroup OTBRoadExtraction */ template class RemoveWrongDirectionFunctor { public: RemoveWrongDirectionFunctor() {} virtual ~RemoveWrongDirectionFunctor() {} inline TOutput operator ()(const TInput1& A, const TInput2& B) { if (B < CONST_PI_8) { return 0; } else { return A; } } }; } /** \class RemoveWrongDirectionFilter * \brief This filter removes (sets to null intensity) pixels with wrong direction. * * This filter is part of the road extraction framework. By using the Spectral Angle filter, * we can assume that the direction of a road on our scalar product image is positive (greater * than \f$ \pi/8 \f$). * Therefore in the input modulus and direction images, pixels whose direction is lower than * this threshold are suppressed * (in fact, their intensity is set to 0). * * \sa NeighborhoodScalarProductFilter * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT RemoveWrongDirectionFilter : public ModulusAndDirectionImageToImageFilter { public: /** Standard typedefs */ typedef RemoveWrongDirectionFilter Self; typedef ModulusAndDirectionImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(RemoveWrongDirectionFilter, ModulusAndDirectionImageToImageFilter); /** typedef of the computing filter (this allows us to derive from ModulusAndDirectionToImageFilter as well as using the BinaryFunctorImageFilter, which is appropriate here */ typedef Functor::RemoveWrongDirectionFunctor< typename TInputModulus::PixelType, typename TInputDirection::PixelType, typename TOutputImage::PixelType> FunctorType; typedef itk::BinaryFunctorImageFilter ComputingFilterType; protected: /** Constructor */ RemoveWrongDirectionFilter() {}; /** Destructor */ ~RemoveWrongDirectionFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } /** Main computation method */ void GenerateData(void) ITK_OVERRIDE { typename ComputingFilterType::Pointer filter = ComputingFilterType::New(); filter->SetInput1(this->GetInput()); filter->SetInput2(this->GetInputDirection()); filter->GraftOutput(this->GetOutput()); filter->Update(); this->GraftOutput(filter->GetOutput()); } private: RemoveWrongDirectionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbRoadExtractionFilter.h000066400000000000000000000172001301006202600302670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRoadExtractionFilter_h #define otbRoadExtractionFilter_h #include "otbSpectralAngleDistanceImageFilter.h" #include "otbGenericRoadExtractionFilter.h" namespace otb { /** * \class RoadExtractionFilter * \brief This class performs the extraction of roads from an image. * * This composite filter implements a fast and robust road extraction * for high resolution satellite images. This is a composite filter using the * SpectralAngleDistanceImageFilter and the GenericRoadExtractionFilter and is * intended to be used with optical high resolution data. The full method is * described in E. Christophe and J. Inglada, "Robust Road Extraction for High * Resolution Satellite Images," in IEEE International Conference on * Image Processing, ICIP 2007. * * The algorithm uses all spectral * bands based on the spectral angle with a reference pixel. Then, the line * detection is done using a Gaussian gradient with a scalar product to find * the road directions. Finally, extracted roads are vectorized and * processed to improve the results removing some occultations and false * detections. * * This filter is fast, as the detection typically takes 3 seconds for a * 1000 \f$ \times \f$ 1000 images with four spectral bands. Results can be * used as an initialization for more complex algorithms. * * \sa SpectralAngleDistanceImageFilter * \sa GenericRoadExtractionFilter * * \example FeatureExtraction/ExtractRoadExample.cxx * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT RoadExtractionFilter : public ImageToPathListFilter { public: /** Standard typedefs */ typedef RoadExtractionFilter Self; typedef ImageToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(RoadExtractionFilter, ImageToPathListFilter); /** Template parameters typedefs */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputPathType OutputPathType; typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename InputImageType::PixelType InputPixelType; typedef double InternalPixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image SpectralAngleType; typedef otb::Image ModulusType; typedef otb::Image DirectionType; typedef itk::CovariantVector VectorPixelType; typedef otb::Image CovariantVectorImageType; /* Template parameters typedefs for composites filters */ typedef SpectralAngleDistanceImageFilter< InputImageType, SpectralAngleType> SpectralAngleDistanceImageFilterType; typedef GenericRoadExtractionFilter GenericRoadExtractionFilterType; /** Template parameters typedefs for internals filters */ typedef typename GenericRoadExtractionFilterType::SigmaType SigmaType; typedef typename GenericRoadExtractionFilterType::AmplitudeThresholdType AmplitudeThresholdType; typedef typename GenericRoadExtractionFilterType::ToleranceType ToleranceType; typedef typename GenericRoadExtractionFilterType::MaxAngleType MaxAngleType; typedef typename GenericRoadExtractionFilterType::MeanDistanceThresholdType MeanDistanceThresholdType; typedef typename GenericRoadExtractionFilterType::LinkRealType LinkRealType; /** Get/Set the reference pixel (use by the SpectralAngleDistanceImageFilter)*/ otbGetObjectMemberConstReferenceMacro(SpectralAngleDistanceImageFilter, ReferencePixel, InputPixelType); otbSetObjectMemberMacro(SpectralAngleDistanceImageFilter, ReferencePixel, InputPixelType); /** Get/Set the alpha value */ otbGetObjectMemberConstReferenceMacro(GenericRoadExtractionFilter, Alpha, double); otbSetObjectMemberMacro(GenericRoadExtractionFilter, Alpha, double); /** Get/Set the amplitude threshold to start following a path (use by the VectorizationPathListFilter)*/ otbSetObjectMemberMacro(GenericRoadExtractionFilter, AmplitudeThreshold, AmplitudeThresholdType); otbGetObjectMemberMacro(GenericRoadExtractionFilter, AmplitudeThreshold, AmplitudeThresholdType); /** Get/Set the tolerance for segment consistency (tolerance in terms of distance) (use by the SimplifyPathListFilter)*/ otbGetObjectMemberMacro(GenericRoadExtractionFilter, Tolerance, ToleranceType); otbSetObjectMemberMacro(GenericRoadExtractionFilter, Tolerance, ToleranceType); /** Set/Get the max angle (use bye the BreakAngularPathListFilter)*/ otbSetObjectMemberMacro(GenericRoadExtractionFilter, MaxAngle, MaxAngleType); otbGetObjectMemberConstMacro(GenericRoadExtractionFilter, MaxAngle, MaxAngleType); /** Get/Set the tolerance for segment consistency (tolerance in terms of distance) (use by RemoveTortuousPathListFilter)*/ otbGetObjectMemberMacro(GenericRoadExtractionFilter, FirstMeanDistanceThreshold, MeanDistanceThresholdType); otbSetObjectMemberMacro(GenericRoadExtractionFilter, FirstMeanDistanceThreshold, MeanDistanceThresholdType); otbGetObjectMemberMacro(GenericRoadExtractionFilter, SecondMeanDistanceThreshold, MeanDistanceThresholdType); otbSetObjectMemberMacro(GenericRoadExtractionFilter, SecondMeanDistanceThreshold, MeanDistanceThresholdType); /** Get/Set the angular threshold (use by LinkPathFilter)*/ otbSetObjectMemberMacro(GenericRoadExtractionFilter, AngularThreshold, LinkRealType); otbGetObjectMemberMacro(GenericRoadExtractionFilter, AngularThreshold, LinkRealType); /** Get/Set the distance threshold (use by LinkPathFilter)*/ otbSetObjectMemberMacro(GenericRoadExtractionFilter, DistanceThreshold, LinkRealType); otbGetObjectMemberMacro(GenericRoadExtractionFilter, DistanceThreshold, LinkRealType); protected: /** Constructor */ RoadExtractionFilter(); /** Destructor */ ~RoadExtractionFilter() ITK_OVERRIDE {} /** Prepare main computation method */ void BeforeGenerateData(void); /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RoadExtractionFilter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** SpectralAngleDistanceImageFilter use by the composite filter */ typename SpectralAngleDistanceImageFilterType::Pointer m_SpectralAngleDistanceImageFilter; typename GenericRoadExtractionFilterType::Pointer m_GenericRoadExtractionFilter; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRoadExtractionFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbRoadExtractionFilter.txx000066400000000000000000000043471301006202600306730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRoadExtractionFilter_txx #define otbRoadExtractionFilter_txx #include "otbRoadExtractionFilter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template RoadExtractionFilter ::RoadExtractionFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_SpectralAngleDistanceImageFilter = SpectralAngleDistanceImageFilterType::New(); m_GenericRoadExtractionFilter = GenericRoadExtractionFilterType::New(); } /** * Main computation method */ template void RoadExtractionFilter ::GenerateData() { // Input images pointers typename InputImageType::ConstPointer inputImage = this->GetInput(); typename OutputPathListType::Pointer outputPathList = this->GetOutput(); m_SpectralAngleDistanceImageFilter->SetInput(inputImage); m_GenericRoadExtractionFilter->SetInput(m_SpectralAngleDistanceImageFilter->GetOutput()); m_GenericRoadExtractionFilter->Update(); for (typename GenericRoadExtractionFilterType::OutputPathListType::ConstIterator it = m_GenericRoadExtractionFilter->GetOutput()->Begin(); it != m_GenericRoadExtractionFilter->GetOutput()->End(); ++it) { outputPathList->PushBack(it.Get()); } } /** * PrintSelf method */ template void RoadExtractionFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "m_ReferencePixel: " << m_SpectralAngleDistanceImageFilter->GetReferencePixel() << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbSimplifyPathListFilter.h000066400000000000000000000051171301006202600306120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimplifyPathListFilter_h #define otbSimplifyPathListFilter_h #include "otbUnaryFunctorObjectListFilter.h" #include "otbSimplifyPathFunctor.h" #include "otbObjectList.h" namespace otb { /** \class SimplifyPathListFilter * \brief This filter performs a simplification of the path in the input list. * * It reduces the number of vertices in each path, according to a tolerance criterion. It aims at * removing aligned vertices while keeping sharp angular points. * * In order to ensure the unicity of its output, each path is considered first from begin to end, then * from begin to the first vertex before the end. At each step, the consistency of the path is checked : * the equation of the line passing by the first and last vertices is computed. Then, for each * vertices between them, the euclidean distance to this line is computed. If for one vertex, this distance * is upper than the tolerance threshold, the path is considered to be inconsistent and no vertices can be removed. * * If the path is considered consistent (which will occur at least with a 2 vertices path), * only the beginning and ending * vertices are kept and a new search iteration begin at its end. * * This filter is part of the road extraction framework. * * This class is just a shortcut to the UnaryFunctorObjectListFilter with * the SimplifyPathFunctor. * * Recent API changes: * Now part of the UnaryFunctorObjectListFilter hierarchy, replace call to SetTolerance() * by GetFunctor().SetTolerance(). * * * \sa BreakAngularPathListFilter * \sa RemoveTortuousPathFilter. * \sa UnaryFunctorObjectListFilter * \sa SimplifyPathFunctor * * \example FeatureExtraction/ExtractRoadByStepsExample.cxx * * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT SimplifyPathListFilter : public UnaryFunctorObjectListFilter< ObjectList, ObjectList, SimplifyPathFunctor > {}; } // End namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbVectorDataToRoadDescriptionFilter.h000066400000000000000000000126011301006202600327120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToRoadDescriptionFilter_h #define otbVectorDataToRoadDescriptionFilter_h #include "otbVectorDataToSpecificDescriptionFilterBase.h" #include "otbVectorData.h" //#include "otbNDVIDataNodeFeatureFunction.h" //#include "otbSpectralAngleDataNodeFeatureFunction.h" #include "otbParserConditionDataNodeFeatureFunction.h" #include "otbDBOverlapDataNodeFeatureFunction.h" namespace otb { /** \class VectorDataToRoadDescriptionFilter * \brief VectorDataToRoadDescriptionFilter associates a score to each * adapted input VectorData DataNode. * * VectorDataToRoadDescriptionFilter is dedicated to road description. * Input and output are both VectorDatas in index coordinate. * Each DataNode of the output VectorData contains its scores * regarding to the associated descriptors. * The support is an Optical Image and the descriptor are: * - (NDVI >= threshold) per cent along the tested lines * - mean Spectral Angle regarding a reference pixel along the tested lines * - DB Overlap compute the number of building crossed by the data node in percent * regarding all the buildings within a data node neighborhood * * \ingroup VectorDataFilter * \sa VectorDataToSpecificDescriptionFilterBase * \sa VectorDataToBuildingDescriptionFilter * * \ingroup OTBRoadExtraction */ template class ITK_EXPORT VectorDataToRoadDescriptionFilter : public otb::VectorDataToSpecificDescriptionFilterBase { public: /** Standard class typedefs. */ typedef VectorDataToRoadDescriptionFilter Self; typedef otb::VectorDataToSpecificDescriptionFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToRoadDescriptionFilter, VectorDataToSpecificDescriptionFilterBase); /** Some typedefs. */ typedef TVectorData VectorDataType; typedef typename TVectorData::Pointer VectorDataPointer; typedef typename VectorDataType::DataNodeType DataNodeType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef typename DataNodeType::ValuePrecisionType PrecisionType; typedef typename DataNodeType::PrecisionType CoordRepType; typedef TOpticalImage OpticalImageType; typedef typename TOpticalImage::Pointer OpticalImageTypePointer; typedef std::vector DescriptorsListType; /* typedef otb::NDVIDataNodeFeatureFunction NDVIFeatureFunctionType; typedef otb::SpectralAngleDataNodeFeatureFunction SpectralAngleFeatureFunctionType; */ typedef otb::ParserConditionDataNodeFeatureFunction ParserConditionFeatureFunctionType; typedef otb::DBOverlapDataNodeFeatureFunction DBOverlapFeatureFunctionType; typedef itk::DataObject::Pointer DataObjectPointer; typedef itk::DataObject DataObject; virtual void AddOpticalImage(const OpticalImageType * support); const OpticalImageType * GetOpticalImage(); virtual void AddBuildingsDB(const VectorDataType * support); const VectorDataType * GetBuildingsDB(); const DescriptorsListType& GetDescriptorsList() const { return m_DescriptorsList; } protected: /** Constructor */ VectorDataToRoadDescriptionFilter(); /** Destructor */ ~VectorDataToRoadDescriptionFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Triggers the Computation of the Descriptors */ void GenerateData(void) ITK_OVERRIDE; private: VectorDataToRoadDescriptionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename ParserConditionFeatureFunctionType::Pointer m_NDVIFeatureFunction; typename ParserConditionFeatureFunctionType::Pointer m_SpectralAngleFeatureFunction; typename DBOverlapFeatureFunctionType::Pointer m_DBOverlapFeatureFunction; DescriptorsListType m_DescriptorsList; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToRoadDescriptionFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/RoadExtraction/include/otbVectorDataToRoadDescriptionFilter.txx000066400000000000000000000114521301006202600333110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToRoadDescriptionFilter_txx #define otbVectorDataToRoadDescriptionFilter_txx #include "otbVectorDataToRoadDescriptionFilter.h" namespace otb { // Constructor template VectorDataToRoadDescriptionFilter ::VectorDataToRoadDescriptionFilter() { this->SetNumberOfRequiredInputs(3); m_NDVIFeatureFunction = ParserConditionFeatureFunctionType::New(); m_NDVIFeatureFunction->SetExpression("ndvi(b3, b4) > 0.4"); m_SpectralAngleFeatureFunction = ParserConditionFeatureFunctionType::New(); m_SpectralAngleFeatureFunction->SetExpression("spectralAngle > 0.25"); //Example for QuickBird images (on a specific image) typename ParserConditionFeatureFunctionType::PixelType refPixel; refPixel.SetSize(4); refPixel[0] = 252; refPixel[1] = 357; refPixel[2] = 232; refPixel[3] = 261; m_SpectralAngleFeatureFunction->SetSpectralAngleReferencePixel(refPixel); m_DBOverlapFeatureFunction = DBOverlapFeatureFunctionType::New(); m_DescriptorsList.push_back("NONDVI"); m_DescriptorsList.push_back("ROADSA"); m_DescriptorsList.push_back("NOBUIL"); } template void VectorDataToRoadDescriptionFilter ::AddOpticalImage(const OpticalImageType * support) { this->AddSupport(const_cast(support), 0); } template const typename VectorDataToRoadDescriptionFilter ::OpticalImageType * VectorDataToRoadDescriptionFilter ::GetOpticalImage() { return static_cast (this->GetSupport(0)); } template void VectorDataToRoadDescriptionFilter ::AddBuildingsDB(const VectorDataType * support) { this->AddSupport(const_cast(support), 1); } template const typename VectorDataToRoadDescriptionFilter ::VectorDataType * VectorDataToRoadDescriptionFilter ::GetBuildingsDB() { return static_cast (this->GetSupport(1)); } template void VectorDataToRoadDescriptionFilter ::GenerateData() { m_NDVIFeatureFunction->SetInputImage(const_cast(this->GetOpticalImage())); m_SpectralAngleFeatureFunction->SetInputImage(const_cast(this->GetOpticalImage())); m_DBOverlapFeatureFunction->SetInputVectorData(const_cast(this->GetBuildingsDB())); // Retrieving root node typename DataNodeType::Pointer root = this->GetOutput(0)->GetDataTree()->GetRoot()->Get(); // Create the document node typename DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(document, root); // Create the folder node typename DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(folder, document); TreeIteratorType itVector(this->GetInput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (!itVector.Get()->IsRoot() && !itVector.Get()->IsDocument() && !itVector.Get()->IsFolder()) { typename DataNodeType::Pointer currentGeometry = itVector.Get(); currentGeometry->SetFieldAsDouble("NONDVI", (double)(m_NDVIFeatureFunction->Evaluate(*(currentGeometry.GetPointer()))[0])); currentGeometry->SetFieldAsDouble("ROADSA", (double)(m_SpectralAngleFeatureFunction->Evaluate(*(currentGeometry.GetPointer()))[0])); currentGeometry->SetFieldAsDouble("NOBUIL", (double)(m_DBOverlapFeatureFunction->Evaluate(*(currentGeometry.GetPointer()))[0])); this->GetOutput(0)->GetDataTree()->Add(currentGeometry, folder); } ++itVector; } } // PrintSelf Method template void VectorDataToRoadDescriptionFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Detection/RoadExtraction/otb-module.cmake000066400000000000000000000006131301006202600247430ustar00rootroot00000000000000set(DOCUMENTATION "Everything users need to extract roads.") otb_module(OTBRoadExtraction DEPENDS OTBVectorDataBase OTBITK OTBImageBase OTBVectorDataManipulation OTBImageManipulation OTBMathParser OTBPath OTBObjectList OTBCommon TEST_DEPENDS OTBTestKernel OTBImageIO OTBProjection OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Detection/RoadExtraction/test/000077500000000000000000000000001301006202600226515ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/RoadExtraction/test/AlignementsQB.cxx000066400000000000000000000070371301006202600260750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkPolyLineParametricPath.h" #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbExtractROI.h" #include "otbImageToPathListAlignFilter.h" #include "otbDrawPathFilter.h" //#include "otbColorImageViewer.h" #include int main(int argc, char ** argv) { if (argc != 3) { std::cout << "Usage : " << argv[0] << " inputImage outputImage" << std::endl; return 1; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); reader->Update(); std::cout << "Lecture terminee" << std::endl; typedef otb::ExtractROI ROIFilterType; ROIFilterType::Pointer roiFilter = ROIFilterType::New(); roiFilter->SetInput(reader->GetOutput()); roiFilter->SetStartX(10); roiFilter->SetStartY(0); roiFilter->SetSizeX(256); roiFilter->SetSizeY(256); roiFilter->Update(); std::cout << "Extraction ROI" << std::endl; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageToPathListAlignFilter ListAlignFilterType; ListAlignFilterType::Pointer alignFilter = ListAlignFilterType::New(); alignFilter->SetInput(roiFilter->GetOutput()); alignFilter->Update(); std::cout << "Alignements termines" << std::endl; typedef ROIFilterType::OutputImageType BackgroundImageType; typedef otb::DrawPathFilter DrawPathFilterType; DrawPathFilterType::Pointer drawPathFilter = DrawPathFilterType::New(); typedef ListAlignFilterType::OutputPathListType ListType; ListType* listePaths = alignFilter->GetOutput(); ListType::Iterator listIt = listePaths->Begin(); BackgroundImageType::Pointer backgroundImage = roiFilter->GetOutput(); roiFilter->Update(); unsigned int color = 0; while (listIt != listePaths->End()) { drawPathFilter->SetImageInput(backgroundImage); drawPathFilter->SetInputPath(listIt.Get()); //drawPathFilter->SetPathValue( color ); drawPathFilter->Update(); backgroundImage = drawPathFilter->GetOutput(); ++listIt; ++color; } writer->SetInput(drawPathFilter->GetOutput()); writer->Update(); /* typedef otb::ColorImageViewer ViewerType; ViewerType viewer; viewer.SetLabel( "Input Image" ); viewer.SetImage( drawPathFilter->GetOutput() ); viewer.Show(); Fl::run(); */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/CMakeLists.txt000066400000000000000000000217061301006202600254170ustar00rootroot00000000000000otb_module_test() set(OTBRoadExtractionTests otbRoadExtractionTestDriver.cxx otbLikelihoodPathListFilter.cxx otbParallelLinePathListFilterNew.cxx otbRemoveWrongDirectionFilter.cxx otbSimplifyPathListFilter.cxx otbRoadExtractionFilterNew.cxx otbRemoveIsolatedByDirectionFilterNew.cxx otbAlignImageToPath.cxx otbNonMaxRemovalByDirectionFilterNew.cxx otbNeighborhoodScalarProductFilterNew.cxx otbRemoveTortuousPathListFilterNew.cxx otbNonMaxRemovalByDirectionFilter.cxx otbRemoveWrongDirectionFilterNew.cxx otbRoadExtractionFilter.cxx otbLinkPathListFilter.cxx otbModulusAndDirectionImageFiltersNew.cxx otbSimplifyPathListFilterNew.cxx otbRemoveTortuousPathListFilter.cxx otbLinkPathListFilterNew.cxx otbLikelihoodPathListFilterNew.cxx otbParallelLinePathListFilter.cxx otbRemoveIsolatedByDirectionFilter.cxx otbVectorDataToRoadDescriptionFilter.cxx otbSimplifyManyPathListFilter.cxx otbNeighborhoodScalarProductFilter.cxx otbDrawPathAlign.cxx otbBreakAngularPathListFilter.cxx otbBreakAngularPathListFilterNew.cxx ) add_executable(otbRoadExtractionTestDriver ${OTBRoadExtractionTests}) target_link_libraries(otbRoadExtractionTestDriver ${OTBRoadExtraction-Test_LIBRARIES}) otb_module_target_label(otbRoadExtractionTestDriver) # Tests Declaration otb_add_test(NAME feTvLikelihoodPathListFilter COMMAND otbRoadExtractionTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvLikelihoodPathOutput.txt ${TEMP}/feTvLikelihoodPathOutput.txt otbLikelihoodPathListFilter ${INPUTDATA}/InputForRoadDetection_NonMaxRem.hdr ${TEMP}/feTvLikelihoodPathOutput.txt 157 335 204 376 | 21 305 35 308 77 354 85 358 | 73 160 126 173 ) otb_add_test(NAME feTuParallelLinePathListFilterNew COMMAND otbRoadExtractionTestDriver otbParallelLinePathListFilterNew) otb_add_test(NAME feTvRemoveWrongDirectionFilter COMMAND otbRoadExtractionTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvRemoveWrongDirectionOutput.hdr ${TEMP}/feTvRemoveWrongDirectionOutput.hdr otbRemoveWrongDirectionFilter ${INPUTDATA}/InputForRoadDetection_IsolatedRem.hdr ${INPUTDATA}/InputForRoadDetectionScalarProductDir.hdr ${TEMP}/feTvRemoveWrongDirectionOutput.hdr ) otb_add_test(NAME feTvSimplifyPathListFilter COMMAND otbRoadExtractionTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvSimplifyPathOutput.txt ${TEMP}/feTvSimplifyPathOutput.txt otbSimplifyPathListFilter ${TEMP}/feTvSimplifyPathOutput.txt 1.0 1 1 5 1 7 1 11 1 21 1 31 1 | 1 1 5 1 7 1 11 1 21 11 31 11 | 1 1 5 5 7 7 11 11 21 21 31 31 41 41 | 1 1 5 1 7 1 11 1 21 11 31 11 41 11 58 11 70 11 ) otb_add_test(NAME feTuRoadExtractionFilterNew COMMAND otbRoadExtractionTestDriver otbRoadExtractionFilterNew) otb_add_test(NAME feTuRemoveIsolatedByDirectionFilterNew COMMAND otbRoadExtractionTestDriver otbRemoveIsolatedByDirectionFilterNew) otb_add_test(NAME feTvAlignMV2ITK COMMAND otbRoadExtractionTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feAlign.txt ${TEMP}/feAlign.txt otbAlignImageToPath ${INPUTDATA}/poupees.hdr ${TEMP}/feAlign.txt) otb_add_test(NAME feTuNonMaxRemovalByDirectionFilterNew COMMAND otbRoadExtractionTestDriver otbNonMaxRemovalByDirectionFilterNew) otb_add_test(NAME feTuNeighborhoodScalarProductFilterNew COMMAND otbRoadExtractionTestDriver otbNeighborhoodScalarProductFilterNew) otb_add_test(NAME feTuRemoveTortuousPathListFilterNew COMMAND otbRoadExtractionTestDriver otbRemoveTortuousPathListFilterNew) otb_add_test(NAME feTvNonMaxRemovalByDirectionFilter COMMAND otbRoadExtractionTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvNonMaxRemovalByDirectionOutput.hdr ${TEMP}/feTvNonMaxRemovalByDirectionOutput.hdr otbNonMaxRemovalByDirectionFilter ${INPUTDATA}/InputForRoadDetection_WrongRem.hdr ${INPUTDATA}/InputForRoadDetectionScalarProductDir.hdr ${TEMP}/feTvNonMaxRemovalByDirectionOutput.hdr ) otb_add_test(NAME feTuRemoveWrongDirectionFilterNew COMMAND otbRoadExtractionTestDriver otbRemoveWrongDirectionFilterNew) otb_add_test(NAME feTvRoadExtractionFilter COMMAND otbRoadExtractionTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvOutputRoadDetection.hdr ${TEMP}/feTvOutputRoadDetection.hdr otbRoadExtractionFilter ${INPUTDATA}/qb_RoadExtract.img.hdr ${TEMP}/feTvOutputRoadDetection.hdr 337 557 432 859 # ReferencePixel 1.0 # Alpha 0.00005 # AmplitudeThreshold 1.0 # Tolerance 22.5 # (degre) MaxAngle (3.14159265358979323846/8.) 1.0 # FirstMeanDistanceThreshold 10.0 # SecondMeanDistanceThreshold 25. # DistanceThreshold for LinkPathFiler 22.5 # AngularThreshold for LinkPathFiler ) otb_add_test(NAME feTvLinkPathListFilter COMMAND otbRoadExtractionTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvLinkPathOutput.txt ${TEMP}/feTvLinkPathOutput.txt otbLinkPathListFilter ${TEMP}/feTvLinkPathOutput.txt 30 40 1 1 51 1 | 61 1 91 1 | 111 11 211 11 | 1 51 51 51 | 71 71 71 91 | 71 131 71 201 | 141 111 101 111 | 151 111 191 111 | 111 71 141 71 | 181 71 151 71 | 11 131 11 101 | 11 171 11 141 ) otb_add_test(NAME feTuModulusAndDirectionImageFiltersNew COMMAND otbRoadExtractionTestDriver otbModulusAndDirectionImageFiltersNew) otb_add_test(NAME feTuSimplifyPathListFilterNew COMMAND otbRoadExtractionTestDriver otbSimplifyPathListFilterNew) otb_add_test(NAME feTvRemoveTortuousPathListFilter COMMAND otbRoadExtractionTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvRemoveTortuousPathOutput.txt ${TEMP}/feTvRemoveTortuousPathOutput.txt otbRemoveTortuousPathListFilter ${TEMP}/feTvRemoveTortuousPathOutput.txt 10.0 1 1 1 11 | 1 1 5 1 7 1 11 1 | 1 1 7 7 21 21 31 31 41 41 | 1 1 5 1 7 1 11 1 21 11 31 11 41 11 58 11 70 11 ) otb_add_test(NAME feTuLinkPathListFilterNew COMMAND otbRoadExtractionTestDriver otbLinkPathListFilterNew) otb_add_test(NAME feTuLikelihoodPathListFilterNew COMMAND otbRoadExtractionTestDriver otbLikelihoodPathListFilterNew) otb_add_test(NAME feTvParallelLinePathListFilter COMMAND otbRoadExtractionTestDriver otbParallelLinePathListFilter) otb_add_test(NAME feTvRemoveIsolatedByDirectionFilter COMMAND otbRoadExtractionTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvRemoveIsolatedByDirectionOutput.hdr ${TEMP}/feTvRemoveIsolatedByDirectionOutput.hdr otbRemoveIsolatedByDirectionFilter ${INPUTDATA}/InputForRoadDetectionScalarProductMod.hdr ${INPUTDATA}/InputForRoadDetectionScalarProductDir.hdr ${TEMP}/feTvRemoveIsolatedByDirectionOutput.hdr ) otb_add_test(NAME fzTuVectorDataToRoadDescriptionFilterNew COMMAND otbRoadExtractionTestDriver otbVectorDataToRoadDescriptionFilterNew) otb_add_test(NAME fzTvVectorDataToRoadDescriptionFilter COMMAND otbRoadExtractionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/fzTvVectorDataToRoadDescriptionFilterOutput.shp ${TEMP}/fzTvVectorDataToRoadDescriptionFilterOutput.shp otbVectorDataToRoadDescriptionFilter ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_ROADS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_BUILDINGS.shp ${TEMP}/fzTvVectorDataToRoadDescriptionFilterOutput.shp ${INPUTDATA}/DEM/srtm_directory 0 ) otb_add_test(NAME feTpSimplifyManyPathListFilter COMMAND otbRoadExtractionTestDriver otbSimplifyManyPathListFilter ${TEMP}/feTvSimplifyManyPathOutput.txt 1.0 ) otb_add_test(NAME feTvNeighborhoodScalarProductFilter COMMAND otbRoadExtractionTestDriver --compare-n-images ${EPSILON_6} 2 ${BASELINE}/feTvNeighborhoodScalarProductModulusOutput.hdr ${TEMP}/feTvNeighborhoodScalarProductModulusOutput.hdr ${BASELINE}/feTvNeighborhoodScalarProductDirectionOutput.hdr ${TEMP}/feTvNeighborhoodScalarProductDirectionOutput.hdr otbNeighborhoodScalarProductFilter ${INPUTDATA}/InputForRoadDetection_SpectralAngle.hdr ${TEMP}/feTvNeighborhoodScalarProductModulusOutput.hdr ${TEMP}/feTvNeighborhoodScalarProductDirectionOutput.hdr 1.0 ) otb_add_test(NAME feTvDrawPathTestAlign COMMAND otbRoadExtractionTestDriver --compare-image ${NOTOL} ${BASELINE}/feDrawPathAlignDeuxTraits.png ${TEMP}/feDrawPathAlignDeuxTraits.png otbDrawPathAlign ${INPUTDATA}/DeuxTraits.png ${TEMP}/feDrawPathAlignDeuxTraits.png) otb_add_test(NAME feTuBreakAngularPathListFilterNew COMMAND otbRoadExtractionTestDriver otbBreakAngularPathListFilterNew) otb_add_test(NAME feTvBreakAngularPathListFilter COMMAND otbRoadExtractionTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feBreakAngularPathListOutput.txt ${TEMP}/feBreakAngularPathListOutput.txt otbBreakAngularPathListFilter ${TEMP}/feBreakAngularPathListOutput.txt 10 20 30 50 90 140 180 | 1 1 5 1 7 1 11 1 21 1 31 1 | 1 1 5 1 7 1 11 1 21 11 31 11 | 1 1 5 1 7 1 11 1 21 11 31 11 41 11 | 1 1 5 1 7 1 11 1 21 11 31 11 41 11 58 11 70 11 | 1 11 5 11 7 11 11 11 21 1 31 1 41 1 | 1 1 5 1 7 1 11 1 21 11 31 21 41 31 | 1 1 5 1 5 11 5 21 | 1 1 31 1 41 1 ) OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbAlignImageToPath.cxx000066400000000000000000000101651301006202600272220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkPolyLineParametricPath.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageToPathListAlignFilter.h" #include "itkPathSource.h" #include int otbAlignImageToPath(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef itk::PolyLineParametricPath PathType; PathType::Pointer ltoto = PathType::New(); typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageToPathListAlignFilter ListAlignFilterType; typedef ListAlignFilterType::ValueType ValueType; typedef ListAlignFilterType::SizeType SizeType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); InputImageType::Pointer ImageIn = InputImageType::New(); ListAlignFilterType::Pointer testList = ListAlignFilterType::New(); reader->SetFileName(inputFilename); //OTB-FA-00010-CS testList->SetInput(reader->GetOutput()); typedef ListAlignFilterType::OutputPathListType ListAlignFilterOutputPathListType; otbGenericMsgDebugMacro(<< "Before update"); testList->Update(); otbGenericMsgDebugMacro(<< "After update"); ValueType pathValue; pathValue = testList->GetPathValue(); testList->SetPathValue(pathValue); ValueType backgroundValue; backgroundValue = testList->GetBackgroundValue(); testList->SetBackgroundValue(backgroundValue); SizeType size; size = testList->GetSize(); testList->SetSize(size); bool isMeaningfulSegment; isMeaningfulSegment = testList->GetisMeaningfulSegment(); testList->SetisMeaningfulSegment(isMeaningfulSegment); int NbGradDirection; NbGradDirection = testList->GetNbGradDirection(); testList->SetNbGradDirection(NbGradDirection); int NbLineDirection; NbLineDirection = testList->GetNbLineDirection(); testList->SetNbLineDirection(NbLineDirection); double MinGradNorm; MinGradNorm = testList->GetMinGradNorm(); testList->SetMinGradNorm(MinGradNorm); double Eps; Eps = testList->GetEps(); testList->SetEps(Eps); ListAlignFilterOutputPathListType * sortiePath = testList->GetOutput(); otbGenericMsgDebugMacro(<< "Writing :"); FILE *file = fopen(outputFilename, "w"); if (file == ITK_NULLPTR) { fprintf(stderr, "Error, can't open file"); exit(-1); } typedef itk::ContinuousIndex VertexType; typedef itk::VectorContainer VertexListType; typedef VertexListType::ConstPointer VertexListTypePointer; VertexListTypePointer vertexList; VertexType cindex; double x1, y1; //double x2, y2; int nbPath = sortiePath->Size(); otbGenericMsgDebugMacro(<< "NbSegment: " << nbPath); fprintf(file, "Nb Segment: %d\n", nbPath); for (int i = 0; i < nbPath; ++i) { vertexList = sortiePath->GetNthElement(i)->GetVertexList(); cindex = vertexList->GetElement(0); x1 = cindex[0]; y1 = cindex[1]; cindex = vertexList->GetElement(1); //x2 = cindex[0]; //y2 = cindex[1]; fprintf(file, "%8.3f %8.3f\n", x1, y1); } fclose(file); // writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbBreakAngularPathListFilter.cxx000066400000000000000000000113621301006202600312620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbBreakAngularPathListFilter.h" #include "itkPolyLineParametricPath.h" #include #include #include "otbMath.h" #include int otbBreakAngularPathListFilter(int itkNotUsed(argc), char * argv[]) { const char * outfname = argv[1]; typedef std::vector PointsVectorType; typedef std::vector PointsMatrixType; PointsMatrixType MatricePoints; PointsVectorType ListPoints; PointsVectorType ListMaxAngle; int cpt = 2; ListMaxAngle.clear(); while (argv[cpt][0] != '|') { ListMaxAngle.push_back(static_cast(::atof(argv[cpt]))); ++cpt; } ++cpt; ListPoints.clear(); while (argv[cpt] != ITK_NULLPTR) { if (argv[cpt][0] == '|') { if ((ListPoints.size() % 2) != 0) { itkGenericExceptionMacro(<< "Missing point in parameters !"); } MatricePoints.push_back(ListPoints); ListPoints.clear(); } else { ListPoints.push_back(static_cast(::atof(argv[cpt]))); } ++cpt; } MatricePoints.push_back(ListPoints); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::BreakAngularPathListFilter BreakAngularPathListFilterType; typedef BreakAngularPathListFilterType::PathListType PathListType; PathType::ContinuousIndexType cindex; PathListType::Pointer InputPathList = PathListType::New(); //Generate PathList for (PointsMatrixType::iterator listpos = MatricePoints.begin(); listpos != MatricePoints.end(); ++listpos) { PathType::Pointer path = PathType::New(); //Generate PathList std::cout << "List " << std::endl; for (PointsVectorType::iterator it = (*listpos).begin(); it != (*listpos).end(); ++it) { cindex[0] = *it; ++it; cindex[1] = *it; std::cout << "Point Index :" << cindex[0] << ";" << cindex[1] << std::endl; path->AddVertex(cindex); } InputPathList->PushBack(path); } // Instantiating object BreakAngularPathListFilterType::Pointer breakAngularFilter = BreakAngularPathListFilterType::New(); breakAngularFilter->SetInput(InputPathList); std::ofstream file; file.open(outfname); for (PointsVectorType::iterator itAngle = ListMaxAngle.begin(); itAngle != ListMaxAngle.end(); ++itAngle) { breakAngularFilter->SetMaxAngle((*itAngle) * otb::CONST_PI / 180.); breakAngularFilter->Update(); PathListType::Pointer OutputPathList = breakAngularFilter->GetOutput(); typedef PathListType::ConstIterator PathListIteratorType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstIterator VertexIteratorType; unsigned int counter = 1; PathListIteratorType pathListIt = InputPathList->Begin(); file << "--------------------------------------------------------------------------" << std::endl; file << "MAX ANGULAR :" << breakAngularFilter->GetMaxAngle() << "(" << (*itAngle) << " deg.)" << std::endl; file << "INPUT list of Path " << ": " << std::endl; while (pathListIt != InputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } counter = 1; pathListIt = OutputPathList->Begin(); file << "OUTPUT list of Path " << ": " << std::endl; while (pathListIt != OutputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } } //Enf for angle file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbBreakAngularPathListFilterNew.cxx000066400000000000000000000021541301006202600317330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbBreakAngularPathListFilter.h" #include "itkPolyLineParametricPath.h" #include int otbBreakAngularPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::BreakAngularPathListFilter BreakAngularPathListFilterType; // Instantiating object BreakAngularPathListFilterType::Pointer filter = BreakAngularPathListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbDrawPathAlign.cxx000066400000000000000000000050411301006202600265670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPolyLineParametricPath.h" #include "otbImageFileReader.h" #include "otbPathListSource.h" #include "otbImageToPathListAlignFilter.h" #include "otbDrawPathListFilter.h" #include "otbImageFileWriter.h" int otbDrawPathAlign(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageToPathListAlignFilter PathListType; typedef PathListType::OutputPathListType OutputPathListType; typedef otb::DrawPathListFilter DrawPathFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); DrawPathFilterType::Pointer DrawPath = DrawPathFilterType::New(); PathType::Pointer VertexList = PathType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); typedef otb::ImageToPathListAlignFilter PathListAlignType; PathListAlignType::Pointer testList = PathListAlignType::New(); //OTB-FA-00010-CS testList->SetInput(reader->GetOutput()); testList->Update(); OutputPathListType * sortiePath = testList->GetOutput(); int nbPath = sortiePath->Size(); std::cout << "NbPath: " << nbPath << std::endl; InputImageType::ConstPointer imageIn = reader->GetOutput(); DrawPath->SetInput(imageIn); DrawPath->SetInputPath(sortiePath); writer->SetInput(DrawPath->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbLikelihoodPathListFilter.cxx000066400000000000000000000111271301006202600310060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLikelihoodPathListFilter.h" #include "otbPolyLineParametricPathWithValue.h" #include "otbImage.h" #include "otbImageFileReader.h" #include int otbLikelihoodPathListFilter(int itkNotUsed(argc), char * argv[]) { std::cout << std::endl; const char * infname = argv[1]; const char * outfname = argv[2]; typedef std::vector PointsVectorType; typedef std::vector PointsMatrixType; PointsMatrixType MatricePoints; PointsVectorType ListPoints; int cpt = 3; ListPoints.clear(); while (argv[cpt] != ITK_NULLPTR) { if (argv[cpt][0] == '|') { if ((ListPoints.size() % 2) != 0) { itkGenericExceptionMacro(<< "Missing point in parameters !"); } MatricePoints.push_back(ListPoints); ListPoints.clear(); } else { ListPoints.push_back(static_cast(::atof(argv[cpt]))); } ++cpt; } MatricePoints.push_back(ListPoints); const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::PolyLineParametricPathWithValue PathType; typedef otb::LikelihoodPathListFilter LikelihoodPathListFilterType; typedef LikelihoodPathListFilterType::PathListType PathListType; PathType::ContinuousIndexType cindex; PathListType::Pointer InputPathList = PathListType::New(); //Generate PathList for (PointsMatrixType::iterator listpos = MatricePoints.begin(); listpos != MatricePoints.end(); ++listpos) { PathType::Pointer path = PathType::New(); //Generate PathList std::cout << "List " << std::endl; for (PointsVectorType::iterator it = (*listpos).begin(); it != (*listpos).end(); ++it) { cindex[0] = *it; ++it; cindex[1] = *it; std::cout << "Point Index :" << cindex[0] << ";" << cindex[1] << std::endl; path->AddVertex(cindex); } InputPathList->PushBack(path); } //Instantiating object LikelihoodPathListFilterType::Pointer filter = LikelihoodPathListFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); filter->SetInput(InputPathList); filter->SetInputImage(reader->GetOutput()); filter->Update(); std::cout << "Filter execution ended" << std::endl; PathListType::Pointer OutputPathList = filter->GetOutput(); typedef PathListType::ConstIterator PathListIteratorType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstIterator VertexIteratorType; std::ofstream file; file.open(outfname); unsigned int counter = 1; PathListIteratorType pathListIt = InputPathList->Begin(); file << "INPUT list of Path " << ": " << std::endl; while (pathListIt != InputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } counter = 1; pathListIt = OutputPathList->Begin(); file << "OUTPUT list of Path " << ": " << std::endl; while (pathListIt != OutputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << " Value: " << pathListIt.Get()->GetValue(); file << std::endl; ++pathListIt; ++counter; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbLikelihoodPathListFilterNew.cxx000066400000000000000000000024231301006202600314570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLikelihoodPathListFilter.h" #include "otbPolyLineParametricPathWithValue.h" #include "otbImage.h" int otbLikelihoodPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::PolyLineParametricPathWithValue PathType; typedef otb::LikelihoodPathListFilter LinkPathListFilterType; // Instantiating object LinkPathListFilterType::Pointer filter = LinkPathListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbLinkPathListFilter.cxx000066400000000000000000000106671301006202600276300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLinkPathListFilter.h" #include "itkPolyLineParametricPath.h" #include "otbMath.h" #include #include int otbLinkPathListFilter(int itkNotUsed(argc), char * argv[]) { std::cout << std::endl; const char * outfname = argv[1]; const double distance = atof(argv[2]); const double angle = ::atof(argv[3]) * otb::CONST_PI / 180.; typedef std::vector PointsVectorType; typedef std::vector PointsMatrixType; PointsMatrixType MatricePoints; PointsVectorType ListPoints; int cpt = 4; ListPoints.clear(); while (argv[cpt] != ITK_NULLPTR) { if (argv[cpt][0] == '|') { if ((ListPoints.size() % 2) != 0) { itkGenericExceptionMacro(<< "Missing point in parameters !"); } MatricePoints.push_back(ListPoints); ListPoints.clear(); } else { ListPoints.push_back(static_cast(::atof(argv[cpt]))); } ++cpt; } MatricePoints.push_back(ListPoints); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::LinkPathListFilter LinkPathListFilterType; typedef LinkPathListFilterType::PathListType PathListType; PathType::ContinuousIndexType cindex; PathListType::Pointer InputPathList = PathListType::New(); //Generate PathList for (PointsMatrixType::iterator listpos = MatricePoints.begin(); listpos != MatricePoints.end(); ++listpos) { PathType::Pointer path = PathType::New(); //Generate PathList std::cout << "List " << std::endl; for (PointsVectorType::iterator it = (*listpos).begin(); it != (*listpos).end(); ++it) { cindex[0] = *it; ++it; cindex[1] = *it; std::cout << "Point Index :" << cindex[0] << ";" << cindex[1] << std::endl; path->AddVertex(cindex); } InputPathList->PushBack(path); } //Instantiating object LinkPathListFilterType::Pointer filter = LinkPathListFilterType::New(); filter->SetInput(InputPathList); filter->SetDistanceThreshold(distance); filter->SetAngularThreshold(angle); filter->Update(); std::cout << "Filter execution ended" << std::endl; PathListType::Pointer OutputPathList = filter->GetOutput(); typedef PathListType::ConstIterator PathListIteratorType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstIterator VertexIteratorType; std::ofstream file; file.open(outfname); unsigned int counter = 1; PathListIteratorType pathListIt = InputPathList->Begin(); file << "Maximum distance threshold: " << filter->GetDistanceThreshold() << " (" << distance << ")" << std::endl; file << "Maximum angle threshold: " << filter->GetAngularThreshold() << " (" << angle * 180 / otb::CONST_PI << ")" << std::endl; file << "INPUT list of Path " << ": " << std::endl; while (pathListIt != InputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } counter = 1; pathListIt = OutputPathList->Begin(); file << "OUTPUT list of Path " << ": " << std::endl; while (pathListIt != OutputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbLinkPathListFilterNew.cxx000066400000000000000000000020761301006202600302750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLinkPathListFilter.h" #include "itkPolyLineParametricPath.h" #include int otbLinkPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::LinkPathListFilter LinkPathListFilterType; // Instantiating object LinkPathListFilterType::Pointer filter = LinkPathListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbModulusAndDirectionImageFiltersNew.cxx000066400000000000000000000034361301006202600327720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbImageToModulusAndDirectionImageFilter.h" #include "otbModulusAndDirectionImageToImageFilter.h" int otbModulusAndDirectionImageFiltersNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image InputImageDirectionType; typedef otb::Image OutputImageType; typedef otb::Image OutputImageDirectionType; typedef otb::ImageToModulusAndDirectionImageFilter FilterType; typedef otb::ImageToModulusAndDirectionImageFilter Filter2Type; FilterType::Pointer filter = FilterType::New(); Filter2Type::Pointer filter2 = Filter2Type::New(); typedef otb::ModulusAndDirectionImageToImageFilter Filter3Type; Filter3Type::Pointer filter3 = Filter3Type::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbNeighborhoodScalarProductFilter.cxx000066400000000000000000000047431301006202600323560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbNeighborhoodScalarProductFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkGradientRecursiveGaussianImageFilter.h" int otbNeighborhoodScalarProductFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const char * diroutfname = argv[3]; const double sigma = atof(argv[4]); const unsigned int Dimension = 2; typedef double PixelType; typedef itk::CovariantVector VectorPixelType; typedef otb::Image VectorImageType; typedef otb::Image ImageType; typedef otb::NeighborhoodScalarProductFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::GradientRecursiveGaussianImageFilter GradientFilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); GradientFilterType::Pointer gradient = GradientFilterType::New(); reader->SetFileName(infname); reader->Update(); gradient->SetInput(reader->GetOutput()); gradient->SetSigma(sigma); filter->SetInput(gradient->GetOutput()); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); writer = WriterType::New(); writer->SetFileName(diroutfname); writer->SetInput(filter->GetOutputDirection()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbNeighborhoodScalarProductFilterNew.cxx000066400000000000000000000027071301006202600330260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbNeighborhoodScalarProductFilter.h" #include "otbImage.h" int otbNeighborhoodScalarProductFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef itk::CovariantVector VectorPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::NeighborhoodScalarProductFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbNonMaxRemovalByDirectionFilter.cxx000066400000000000000000000035161301006202600321370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbNonMaxRemovalByDirectionFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbNonMaxRemovalByDirectionFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::NonMaxRemovalByDirectionFilter NonMaxRemovalByDirectionFilterType; // Instantiating object ReaderType::Pointer modReader = ReaderType::New(); ReaderType::Pointer dirReader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); modReader->SetFileName(argv[1]); dirReader->SetFileName(argv[2]); writer->SetFileName(argv[3]); NonMaxRemovalByDirectionFilterType::Pointer filter = NonMaxRemovalByDirectionFilterType::New(); filter->SetInput(modReader->GetOutput()); filter->SetInputDirection(dirReader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbNonMaxRemovalByDirectionFilterNew.cxx000066400000000000000000000023561301006202600326120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbNonMaxRemovalByDirectionFilter.h" #include "otbImage.h" int otbNonMaxRemovalByDirectionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::NonMaxRemovalByDirectionFilter NonMaxRemovalByDirectionFilterType; // Instantiating object NonMaxRemovalByDirectionFilterType::Pointer filter = NonMaxRemovalByDirectionFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbParallelLinePathListFilter.cxx000066400000000000000000000065631301006202600312770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbParallelLinePathListFilter.h" #include "itkPolyLineParametricPath.h" #include int otbParallelLinePathListFilter(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // We create some lines const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::ObjectList PathListType; PathListType::Pointer lineList = PathListType::New(); PathListType::Pointer parallelList = PathListType::New(); typedef PathType::ContinuousIndexType ContinuousIndexType; ContinuousIndexType cindex; /*-----*/ PathType::Pointer aLine = PathType::New(); aLine->Initialize(); cindex[0] = 1; cindex[1] = 1; aLine->AddVertex(cindex); cindex[0] = 1; cindex[1] = 100; aLine->AddVertex(cindex); lineList->PushBack(aLine); parallelList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 10; cindex[1] = 1; aLine->AddVertex(cindex); cindex[0] = 10; cindex[1] = 100; aLine->AddVertex(cindex); parallelList->PushBack(aLine); lineList->PushBack(aLine); /*-----*/ aLine = PathType::New(); aLine->Initialize(); cindex[0] = 174; cindex[1] = 99; aLine->AddVertex(cindex); cindex[0] = 281; cindex[1] = 1; aLine->AddVertex(cindex); lineList->PushBack(aLine); // Parallel lines are detected. typedef otb::ParallelLinePathListFilter ParallelLinePathType; ParallelLinePathType::Pointer parallelLinePathListFilter = ParallelLinePathType::New(); parallelLinePathListFilter->SetDistanceThreshold(10); parallelLinePathListFilter->SetAngularThreshold(10); parallelLinePathListFilter->SetCommonDistanceThreshold(10); parallelLinePathListFilter->SetInput(lineList); parallelLinePathListFilter->Update(); PathListType::Pointer pathList = parallelLinePathListFilter->GetOutput(); PathListType::Iterator listIt = pathList->Begin(); PathListType::Iterator parListIt = parallelList->Begin(); // A path is a line segment in this case. while (listIt != pathList->End() && parListIt != parallelList->End()) { PathType::VertexListType::ConstPointer vertexList = (listIt.Get())->GetVertexList(); PathType::VertexListType::ConstPointer parVertexList = (parListIt.Get())->GetVertexList(); PathType::VertexListType::ConstIterator pathIt = vertexList->Begin(); PathType::VertexListType::ConstIterator parPathIt = parVertexList->Begin(); // Loop over all the vertices in one path while (pathIt != vertexList->End() && parPathIt != parVertexList->End()) { if (pathIt.Value() != parPathIt.Value()) { std::cout << pathIt.Index() << pathIt.Value() << std::endl; return EXIT_FAILURE; } ++pathIt; ++parPathIt; } ++listIt; ++parListIt; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbParallelLinePathListFilterNew.cxx000066400000000000000000000021151301006202600317360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbParallelLinePathListFilter.h" #include "itkPolyLineParametricPath.h" #include int otbParallelLinePathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::ParallelLinePathListFilter ParallelLinePathType; // Instantiating object ParallelLinePathType::Pointer filter = ParallelLinePathType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRemoveIsolatedByDirectionFilter.cxx000066400000000000000000000035301301006202600323270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRemoveIsolatedByDirectionFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbRemoveIsolatedByDirectionFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::RemoveIsolatedByDirectionFilter RemoveIsolatedByDirectionFilterType; // Instantiating object ReaderType::Pointer modReader = ReaderType::New(); ReaderType::Pointer dirReader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); modReader->SetFileName(argv[1]); dirReader->SetFileName(argv[2]); writer->SetFileName(argv[3]); RemoveIsolatedByDirectionFilterType::Pointer filter = RemoveIsolatedByDirectionFilterType::New(); filter->SetInput(modReader->GetOutput()); filter->SetInputDirection(dirReader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRemoveIsolatedByDirectionFilterNew.cxx000066400000000000000000000023661301006202600330070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRemoveIsolatedByDirectionFilter.h" #include "otbImage.h" int otbRemoveIsolatedByDirectionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::RemoveIsolatedByDirectionFilter RemoveIsolatedByDirectionFilterType; // Instantiating object RemoveIsolatedByDirectionFilterType::Pointer filter = RemoveIsolatedByDirectionFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRemoveTortuousPathListFilter.cxx000066400000000000000000000102731301006202600317460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRemoveTortuousPathListFilter.h" #include "itkPolyLineParametricPath.h" #include #include int otbRemoveTortuousPathListFilter(int itkNotUsed(argc), char * argv[]) { const char * outfname = argv[1]; const double threshold = atof(argv[2]); typedef std::vector PointsVectorType; typedef std::vector PointsMatrixType; PointsMatrixType MatricePoints; PointsVectorType ListPoints; int cpt = 3; ListPoints.clear(); while (argv[cpt] != ITK_NULLPTR) { if (argv[cpt][0] == '|') { if ((ListPoints.size() % 2) != 0) { itkGenericExceptionMacro(<< "Missing point in parameters !"); } MatricePoints.push_back(ListPoints); ListPoints.clear(); } else { ListPoints.push_back(static_cast(::atof(argv[cpt]))); } ++cpt; } MatricePoints.push_back(ListPoints); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::RemoveTortuousPathListFilter RemoveTortuousPathListFilterType; typedef RemoveTortuousPathListFilterType::InputListType PathListType; PathType::ContinuousIndexType cindex; PathListType::Pointer InputPathList = PathListType::New(); //Generate PathList for (PointsMatrixType::iterator listpos = MatricePoints.begin(); listpos != MatricePoints.end(); ++listpos) { PathType::Pointer path = PathType::New(); //Generate PathList std::cout << "List " << std::endl; for (PointsVectorType::iterator it = (*listpos).begin(); it != (*listpos).end(); ++it) { cindex[0] = *it; ++it; cindex[1] = *it; std::cout << "Point Index :" << cindex[0] << ";" << cindex[1] << std::endl; path->AddVertex(cindex); } InputPathList->PushBack(path); } // Instantiating object RemoveTortuousPathListFilterType::Pointer filter = RemoveTortuousPathListFilterType::New(); filter->SetInput(InputPathList); filter->GetFunctor().SetThreshold(threshold); filter->Update(); PathListType::Pointer OutputPathList = filter->GetOutput(); typedef PathListType::ConstIterator PathListIteratorType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstIterator VertexIteratorType; std::ofstream file; file.open(outfname); unsigned int counter = 1; PathListIteratorType pathListIt = InputPathList->Begin(); file << "Minimum Mean Distance: " << filter->GetFunctor().GetThreshold() << " (" << threshold << ")" << std::endl; file << "INPUT list of Path " << ": " << std::endl; while (pathListIt != InputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } counter = 1; pathListIt = OutputPathList->Begin(); file << "OUTPUT list of Path " << ": " << std::endl; while (pathListIt != OutputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRemoveTortuousPathListFilterNew.cxx000066400000000000000000000021731301006202600324200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRemoveTortuousPathListFilter.h" #include "itkPolyLineParametricPath.h" #include int otbRemoveTortuousPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::RemoveTortuousPathListFilter RemoveTortuousPathListFilterType; // Instantiating object RemoveTortuousPathListFilterType::Pointer filter = RemoveTortuousPathListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRemoveWrongDirectionFilter.cxx000066400000000000000000000034461301006202600313720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRemoveWrongDirectionFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbRemoveWrongDirectionFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::RemoveWrongDirectionFilter RemoveWrongDirectionFilterType; // Instantiating object ReaderType::Pointer modReader = ReaderType::New(); ReaderType::Pointer dirReader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); modReader->SetFileName(argv[1]); dirReader->SetFileName(argv[2]); writer->SetFileName(argv[3]); RemoveWrongDirectionFilterType::Pointer filter = RemoveWrongDirectionFilterType::New(); filter->SetInput(modReader->GetOutput()); filter->SetInputDirection(dirReader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRemoveWrongDirectionFilterNew.cxx000066400000000000000000000023161301006202600320370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRemoveWrongDirectionFilter.h" #include "otbImage.h" int otbRemoveWrongDirectionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::RemoveWrongDirectionFilter RemoveWrongDirectionFilterType; // Instantiating object RemoveWrongDirectionFilterType::Pointer filter = RemoveWrongDirectionFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRoadExtractionFilter.cxx000066400000000000000000000075171301006202600302100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbRoadExtractionFilter.h" #include "otbDrawPathListFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPolyLineParametricPathWithValue.h" #include "otbMath.h" int otbRoadExtractionFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::PolyLineParametricPathWithValue PathType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::RoadExtractionFilter RoadExtractionFilterType; typedef RoadExtractionFilterType::InputPixelType InputPixelType; typedef otb::DrawPathListFilter DrawPathFilterType; //Parameters const char * inputFileName(argv[1]); const char * outputFileName(argv[2]); InputPixelType ReferencePixel; ReferencePixel.Reserve(4); ReferencePixel.SetElement(0, ::atof(argv[3])); ReferencePixel.SetElement(1, ::atof(argv[4])); ReferencePixel.SetElement(2, ::atof(argv[5])); ReferencePixel.SetElement(3, ::atof(argv[6])); const double Alpha = ::atof(argv[7]); const double AmplitudeThreshold = ::atof(argv[8]); const double Tolerance = ::atof(argv[9]); const double MaxAngle = ((otb::CONST_PI * ::atof(argv[10])) / 180.); const double FirstMeanDistanceThreshold = ::atof(argv[11]); const double SecondMeanDistanceThreshold = ::atof(argv[12]); const double LinkAngularThreshold = ((otb::CONST_PI * ::atof(argv[13])) / 180.); const double LinkDistanceThreshold = ::atof(argv[14]); // Instantiating object ReaderType::Pointer reader = ReaderType::New(); RoadExtractionFilterType::Pointer roadExtraction = RoadExtractionFilterType::New(); DrawPathFilterType::Pointer draw = DrawPathFilterType::New(); WriterType::Pointer writer = WriterType::New(); //Initialization parameters reader->SetFileName(inputFileName); roadExtraction->SetInput(reader->GetOutput()); roadExtraction->SetReferencePixel(ReferencePixel); roadExtraction->SetAlpha(Alpha); roadExtraction->SetAmplitudeThreshold(AmplitudeThreshold); roadExtraction->SetTolerance(Tolerance); roadExtraction->SetMaxAngle(MaxAngle); roadExtraction->SetFirstMeanDistanceThreshold(FirstMeanDistanceThreshold); roadExtraction->SetSecondMeanDistanceThreshold(SecondMeanDistanceThreshold); roadExtraction->SetAngularThreshold(LinkAngularThreshold); roadExtraction->SetDistanceThreshold(LinkDistanceThreshold); reader->GenerateOutputInformation(); OutputImageType::Pointer image = OutputImageType::New(); image->CopyInformation(reader->GetOutput()); image->SetRegions(image->GetLargestPossibleRegion()); image->Allocate(); image->FillBuffer(0); draw->SetInput(image); //Use internal value of path draw->UseInternalPathValueOn(); draw->SetInputPath(roadExtraction->GetOutput()); writer->SetFileName(outputFileName); writer->SetInput(draw->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRoadExtractionFilterNew.cxx000066400000000000000000000022051301006202600306470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPolyLineParametricPath.h" #include "otbRoadExtractionFilter.h" int otbRoadExtractionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::RoadExtractionFilter RoadExtractionFilterType; // Instantiating object RoadExtractionFilterType::Pointer filter = RoadExtractionFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbRoadExtractionTestDriver.cxx000066400000000000000000000026151301006202600310500ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbLikelihoodPathListFilter); REGISTER_TEST(otbParallelLinePathListFilterNew); REGISTER_TEST(otbRemoveWrongDirectionFilter); REGISTER_TEST(otbSimplifyPathListFilter); REGISTER_TEST(otbRoadExtractionFilterNew); REGISTER_TEST(otbRemoveIsolatedByDirectionFilterNew); REGISTER_TEST(otbAlignImageToPath); REGISTER_TEST(otbNonMaxRemovalByDirectionFilterNew); REGISTER_TEST(otbNeighborhoodScalarProductFilterNew); REGISTER_TEST(otbRemoveTortuousPathListFilterNew); REGISTER_TEST(otbNonMaxRemovalByDirectionFilter); REGISTER_TEST(otbRemoveWrongDirectionFilterNew); REGISTER_TEST(otbRoadExtractionFilter); REGISTER_TEST(otbLinkPathListFilter); REGISTER_TEST(otbModulusAndDirectionImageFiltersNew); REGISTER_TEST(otbSimplifyPathListFilterNew); REGISTER_TEST(otbRemoveTortuousPathListFilter); REGISTER_TEST(otbLinkPathListFilterNew); REGISTER_TEST(otbLikelihoodPathListFilterNew); REGISTER_TEST(otbParallelLinePathListFilter); REGISTER_TEST(otbRemoveIsolatedByDirectionFilter); REGISTER_TEST(otbVectorDataToRoadDescriptionFilterNew); REGISTER_TEST(otbVectorDataToRoadDescriptionFilter); REGISTER_TEST(otbSimplifyManyPathListFilter); REGISTER_TEST(otbNeighborhoodScalarProductFilter); REGISTER_TEST(otbDrawPathAlign); REGISTER_TEST(otbBreakAngularPathListFilter); REGISTER_TEST(otbBreakAngularPathListFilterNew); } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbSimplifyManyPathListFilter.cxx000066400000000000000000000070141301006202600313440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSimplifyPathListFilter.h" #include "itkPolyLineParametricPath.h" #include #include /** * This filter is intended to test the multithreading capabilities * of the otb::UnaryFunctorObjectListFilter */ int otbSimplifyManyPathListFilter(int itkNotUsed(argc), char * argv[]) { const char * outfname = argv[1]; const double tolerance = atof(argv[2]); // typedef std::vector PointsVectorType; // typedef std::vector< PointsVectorType > PointsMatrixType; // PointsMatrixType MatricePoints; // PointsVectorType ListPoints; const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::SimplifyPathListFilter SimplifyPathListFilterType; typedef SimplifyPathListFilterType::InputListType PathListType; PathType::ContinuousIndexType cindex; PathListType::Pointer InputPathList = PathListType::New(); //Generate PathList unsigned long int numberOfPaths = 10000; srand(123456); for (unsigned long int i = 0; i < numberOfPaths; ++i) { PathType::Pointer path = PathType::New(); //Generate PathList unsigned int numberOfPoints = static_cast((rand() / (RAND_MAX + 1.0)) * 90) + 10; // std::cout << "List :" << numberOfPoints << " points" << std::endl; cindex[0] = 0; cindex[1] = 0; for (unsigned int j = 0; j < numberOfPoints; ++j) { cindex[0] += (rand() / (RAND_MAX + 1.0)) * 100 - 50; cindex[1] += (rand() / (RAND_MAX + 1.0)) * 100 - 50; // std::cout << "Point Index :"<AddVertex(cindex); } InputPathList->PushBack(path); } // Instantiating object SimplifyPathListFilterType::Pointer simplifyFilter = SimplifyPathListFilterType::New(); simplifyFilter->SetInput(InputPathList); simplifyFilter->GetFunctor().SetTolerance(tolerance); simplifyFilter->Update(); PathListType::Pointer OutputPathList = simplifyFilter->GetOutput(); typedef PathListType::ConstIterator PathListIteratorType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstIterator VertexIteratorType; std::ofstream file; file.open(outfname); unsigned int counter = 1; PathListIteratorType pathListIt = InputPathList->Begin(); file << "TOLERANCE: " << simplifyFilter->GetFunctor().GetTolerance() << "(" << tolerance << ")" << std::endl; pathListIt = OutputPathList->Begin(); file << "OUTPUT list of Path " << ": " << std::endl; while (pathListIt != OutputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbSimplifyPathListFilter.cxx000066400000000000000000000102561301006202600305210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSimplifyPathListFilter.h" #include "itkPolyLineParametricPath.h" #include #include int otbSimplifyPathListFilter(int itkNotUsed(argc), char * argv[]) { const char * outfname = argv[1]; const double tolerance = atof(argv[2]); typedef std::vector PointsVectorType; typedef std::vector PointsMatrixType; PointsMatrixType MatricePoints; PointsVectorType ListPoints; int cpt = 3; ListPoints.clear(); while (argv[cpt] != ITK_NULLPTR) { if (argv[cpt][0] == '|') { if ((ListPoints.size() % 2) != 0) { itkGenericExceptionMacro(<< "Missing point in parameters !"); } MatricePoints.push_back(ListPoints); ListPoints.clear(); } else { ListPoints.push_back(static_cast(::atof(argv[cpt]))); } ++cpt; } MatricePoints.push_back(ListPoints); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::SimplifyPathListFilter SimplifyPathListFilterType; typedef SimplifyPathListFilterType::InputListType PathListType; PathType::ContinuousIndexType cindex; PathListType::Pointer InputPathList = PathListType::New(); //Generate PathList for (PointsMatrixType::iterator listpos = MatricePoints.begin(); listpos != MatricePoints.end(); ++listpos) { PathType::Pointer path = PathType::New(); //Generate PathList std::cout << "List " << std::endl; for (PointsVectorType::iterator it = (*listpos).begin(); it != (*listpos).end(); ++it) { cindex[0] = *it; ++it; cindex[1] = *it; std::cout << "Point Index :" << cindex[0] << ";" << cindex[1] << std::endl; path->AddVertex(cindex); } InputPathList->PushBack(path); } // Instantiating object SimplifyPathListFilterType::Pointer simplifyFilter = SimplifyPathListFilterType::New(); simplifyFilter->SetInput(InputPathList); simplifyFilter->GetFunctor().SetTolerance(tolerance); simplifyFilter->Update(); PathListType::Pointer OutputPathList = simplifyFilter->GetOutput(); typedef PathListType::ConstIterator PathListIteratorType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstIterator VertexIteratorType; std::ofstream file; file.open(outfname); unsigned int counter = 1; PathListIteratorType pathListIt = InputPathList->Begin(); file << "TOLERANCE: " << simplifyFilter->GetFunctor().GetTolerance() << "(" << tolerance << ")" << std::endl; file << "INPUT list of Path " << ": " << std::endl; while (pathListIt != InputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } counter = 1; pathListIt = OutputPathList->Begin(); file << "OUTPUT list of Path " << ": " << std::endl; while (pathListIt != OutputPathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbSimplifyPathListFilterNew.cxx000066400000000000000000000021231301006202600311650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSimplifyPathListFilter.h" #include "itkPolyLineParametricPath.h" #include int otbSimplifyPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::SimplifyPathListFilter SimplifyPathListFilterType; // Instantiating object SimplifyPathListFilterType::Pointer filter = SimplifyPathListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/RoadExtraction/test/otbVectorDataToRoadDescriptionFilter.cxx000066400000000000000000000073501301006202600326260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataToRoadDescriptionFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbVectorDataProperties.h" #include "otbRemoteSensingRegion.h" #include "otbVectorDataIntoImageProjectionFilter.h" int otbVectorDataToRoadDescriptionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PrecisionType; typedef otb::VectorData VectorDataType; typedef otb::VectorImage ImageType; typedef otb::VectorDataToRoadDescriptionFilter VectorDataToRoadDescriptionFilterType; VectorDataToRoadDescriptionFilterType::Pointer filter = VectorDataToRoadDescriptionFilterType::New(); std::cout< VectorDataType; typedef otb::VectorImage ImageType; typedef otb::VectorDataToRoadDescriptionFilter VectorDataToRoadDescriptionFilterType; typedef otb::ImageFileReader ImageReaderType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef otb::VectorDataIntoImageProjectionFilter VectorDataReProjFilter; VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); VectorDataReaderType::Pointer DBReader = VectorDataReaderType::New(); ImageReaderType::Pointer reader = ImageReaderType::New(); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); VectorDataReProjFilter::Pointer vdReProjFilter = VectorDataReProjFilter::New(); VectorDataToRoadDescriptionFilterType::Pointer filter = VectorDataToRoadDescriptionFilterType::New(); if (!DisplayWarnings) { reader->SetGlobalWarningDisplay(0); } otb::DEMHandler::Instance()->OpenDEMDirectory(DEMDirectory); reader->SetFileName(inputImg); reader->UpdateOutputInformation(); DBReader->SetFileName(inputDB); DBReader->Update(); vdReader->SetFileName(inputVD); vdReader->Update(); vdReProjFilter->SetInputImage(reader->GetOutput()); vdReProjFilter->SetInputVectorData(vdReader->GetOutput()); vdReProjFilter->SetUseOutputSpacingAndOriginFromImage(true); vdReProjFilter->Update(); filter->SetInput(vdReProjFilter->GetOutput()); filter->AddOpticalImage(reader->GetOutput()); filter->AddBuildingsDB(DBReader->GetOutput()); vdWriter->SetFileName(outputVD); vdWriter->SetInput(filter->GetOutput()); vdWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/UrbanArea/000077500000000000000000000000001301006202600206045ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/UrbanArea/CMakeLists.txt000066400000000000000000000000501301006202600233370ustar00rootroot00000000000000project(OTBUrbanArea) otb_module_impl() OTB-release-5.8/Modules/Detection/UrbanArea/include/000077500000000000000000000000001301006202600222275ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/UrbanArea/include/otbUrbanAreaDetectionImageFilter.h000066400000000000000000000235631301006202600307260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUrbanAreaDetectionImageFilter_h #define otbUrbanAreaDetectionImageFilter_h #include "otbImage.h" #include "otbWaterIndicesFunctor.h" #include "otbMultiChannelRAndGAndNIRIndexImageFilter.h" #include "itkBinaryErodeImageFilter.h" #include "itkBinaryDilateImageFilter.h" #include "itkBinaryBallStructuringElement.h" #include "itkSobelEdgeDetectionImageFilter.h" #include "otbEdgeDetectorImageFilter.h" #include "otbEdgeDensityImageFilter.h" #include "otbBinaryImageDensityFunction.h" #include "otbVectorImageToIntensityImageFilter.h" namespace otb { namespace Functor { /** \class RadiometricNonWaterNonVegetationIndexFunctor * \brief This functor computes ndwi and ndvi of an image * \brief in order to find urban areas and generate a grayscale image * * \ingroup OTBUrbanArea */ template class RadiometricNonWaterNonVegetationIndexFunctor { public: typedef Functor::NDVI VegetationFunctorType; typedef Functor::NDWI2 WaterFunctorType; typedef TOutput ValueType; VegetationFunctorType GetVegetationFunctor(){ return m_VegetationFunctor; } WaterFunctorType GetWaterFunctor(){ return m_WaterFunctor; } void SetRedIndex(int id){ m_VegetationFunctor.SetRedIndex(id); } void SetGreenIndex(int id){ m_WaterFunctor.SetGIndex(id); } void SetNIRIndex(int id) { m_VegetationFunctor.SetNIRIndex(id); m_WaterFunctor.SetNIRIndex(id); } RadiometricNonWaterNonVegetationIndexFunctor(){} virtual ~RadiometricNonWaterNonVegetationIndexFunctor(){} inline TOutput operator ()(const TInput& pInPix) { TOutput lVIval, lWIval, lOutPix; TInput zero = pInPix; zero.Fill(0); if (pInPix != zero) { lVIval = static_cast(std::max(0., m_VegetationFunctor(pInPix))); lWIval = static_cast(std::max(0., m_WaterFunctor(pInPix))); lOutPix = vcl_sqrt(vcl_abs((1 - lVIval) * (1 - lWIval))); } else lOutPix = 0; return lOutPix; } protected: VegetationFunctorType m_VegetationFunctor; WaterFunctorType m_WaterFunctor; }; /** \class RadiometricNonWaterNonVegetationDetectionFunctor * \brief This functor uses computes RadiometricNonWaterNonVegetationIndexFunctor * \brief and appli a threshold to produce a binary image * * \ingroup OTBUrbanArea */ template class RadiometricNonWaterNonVegetationDetectionFunctor { public: typedef RadiometricNonWaterNonVegetationIndexFunctor RadiometricNonWaterNonVegetationIndexFunctorType; RadiometricNonWaterNonVegetationDetectionFunctor() { m_LowerThreshold = 0.0; m_UpperThreshold = 1.0; } virtual ~RadiometricNonWaterNonVegetationDetectionFunctor() {} inline TOutput operator ()(const TInput& inPix) { // The vegetation and water areas are put to 0. double indexesVal = static_cast(m_RadiometricNonWaterNonVegetationIndexFunctor(inPix)); if ((indexesVal > m_LowerThreshold) && (indexesVal <= m_UpperThreshold)) { return static_cast(1); } else { return static_cast(0); } } void SetLowerThreshold(double threshold){ m_LowerThreshold = threshold; } void SetUpperThreshold(double threshold){ m_UpperThreshold = threshold; } double GetLowerThreshold(){ return m_LowerThreshold; } double GetUpperThreshold(){ return m_UpperThreshold; } void SetRedIndex(int id){ m_RadiometricNonWaterNonVegetationIndexFunctor.SetRedIndex(id); } void SetGreenIndex(int id){ m_RadiometricNonWaterNonVegetationIndexFunctor.SetGreenIndex(id); } void SetNIRIndex(int id){ m_RadiometricNonWaterNonVegetationIndexFunctor.SetNIRIndex(id); } protected: RadiometricNonWaterNonVegetationIndexFunctorType m_RadiometricNonWaterNonVegetationIndexFunctor; double m_LowerThreshold; double m_UpperThreshold; }; } //end namespace functor /** \class UrbanAreaDetectionImageFilter * \brief This filter uses associated functors to produce a binary or grayscale image * \brief where the white areas represents the urban areas. * * \ingroup OTBUrbanArea */ template > class ITK_EXPORT UrbanAreaDetectionImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef UrbanAreaDetectionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UrbanAreaDetectionImageFilter, itk::ImageToImageFilter); /** Images typedefs */ typedef TInputImage VectorImageType; typedef TOutputImage OutputImageType; typedef double SingleImagePixelType; typedef Image SingleImageType; typedef SingleImageType::SizeType SizeType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename VectorImageType::PixelType VectorImagePixelType; /** Filters typedefs */ // NonVegetationNonWaterIndexFilter typedef Functor::RadiometricNonWaterNonVegetationDetectionFunctor FunctorType; typedef MultiChannelRAndGAndNIRIndexImageFilter UrbanAreaExtractionFilterType; typedef typename UrbanAreaExtractionFilterType::Pointer UrbanAreaExtrationFilterPointerType; // Erode/Dilate Filters typedef typename itk::BinaryBallStructuringElement StructuringElementType; typedef typename itk::BinaryErodeImageFilter ErodeFilterType; typedef typename itk::BinaryDilateImageFilter DilateFilterType; // Intensity typedef VectorImageToIntensityImageFilter IntensityFilterType; typedef typename IntensityFilterType::Pointer IntensityFilterPointerType; // EdgeDensityFilter typedef BinaryImageDensityFunction CountFunctionType; typedef itk::SobelEdgeDetectionImageFilter SobelType; typedef EdgeDetectorImageFilter SobelDetectorType; typedef EdgeDensityImageFilter EdgeDensityFilterType; typedef typename EdgeDensityFilterType::Pointer EdgeDensityFilterPointerType; // Threshold typedef itk::BinaryThresholdImageFilter ThresholdFilterType; typedef typename ThresholdFilterType::Pointer ThresholdFilterPointerType; // Multiply typedef itk::MultiplyImageFilter MultiplyImageFilterType; typedef typename MultiplyImageFilterType::Pointer MultiplyImageFilterPointerType; /** Get/Set indices */ void SetRedIndex(int id){ m_UrbanAreaExtractionFilter->SetRedIndex(id); } void SetGreenIndex(int id){ m_UrbanAreaExtractionFilter->SetGreenIndex(id); } void SetNIRIndex(int id){ m_UrbanAreaExtractionFilter->SetNIRIndex(id); } unsigned int GetRedIndex(){ return m_UrbanAreaExtractionFilter->GetRedIndex(); } unsigned int GetGreenIndex(){ return m_UrbanAreaExtractionFilter->GetGreenIndex(); } unsigned int GetNIRIndex(){ return m_UrbanAreaExtractionFilter->GetNIRIndex(); } /** Get/Set threshold values */ itkGetMacro(ThresholdValue, double); itkSetMacro(ThresholdValue, double); itkGetMacro(ThresholdDensity, double); itkSetMacro(ThresholdDensity, double); itkGetMacro(SobelLowerThreshold, double); itkSetMacro(SobelLowerThreshold, double); itkGetMacro(SobelUpperThreshold, double); itkSetMacro(SobelUpperThreshold, double); /** Methods */ void GenerateData() ITK_OVERRIDE; protected: UrbanAreaDetectionImageFilter(); ~UrbanAreaDetectionImageFilter() ITK_OVERRIDE{} private: UrbanAreaDetectionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Filters */ IntensityFilterPointerType m_IntensityFilter; EdgeDensityFilterType::Pointer m_EdgeDensityFilter; SobelDetectorType::Pointer m_SobelFilter; ThresholdFilterPointerType m_Thresholder; UrbanAreaExtrationFilterPointerType m_UrbanAreaExtractionFilter; MultiplyImageFilterPointerType m_MultiplyFilter; /** Thresholds */ double m_ThresholdValue; double m_ThresholdDensity; double m_SobelLowerThreshold; double m_SobelUpperThreshold; }; // end class RadiometricNonWaterNonVegetationDetectionImageFilter } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUrbanAreaDetectionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Detection/UrbanArea/include/otbUrbanAreaDetectionImageFilter.txx000066400000000000000000000062251301006202600313160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUrbanAreaDetectionImageFilter_txx #define otbUrbanAreaDetectionImageFilter_txx #include "otbUrbanAreaDetectionImageFilter.h" #include "itkProgressAccumulator.h" namespace otb { /** * Constructor */ template UrbanAreaDetectionImageFilter ::UrbanAreaDetectionImageFilter() { m_IntensityFilter = IntensityFilterType::New(); m_EdgeDensityFilter = EdgeDensityFilterType::New(); m_SobelFilter = SobelDetectorType::New(); m_Thresholder = ThresholdFilterType::New(); m_UrbanAreaExtractionFilter = UrbanAreaExtractionFilterType::New(); m_MultiplyFilter = MultiplyImageFilterType::New(); /** Init the Pipeline */ // EdgeDensity m_EdgeDensityFilter->SetInput(m_IntensityFilter->GetOutput()); m_EdgeDensityFilter->SetDetector(m_SobelFilter); // Threshold m_Thresholder->SetInput(m_EdgeDensityFilter->GetOutput()); // Mask Image m_MultiplyFilter->SetInput2(m_Thresholder->GetOutput()); // NonVegetationNonWaterIndex m_UrbanAreaExtractionFilter->SetInput(m_MultiplyFilter->GetOutput()); m_ThresholdValue = 0.5; m_ThresholdDensity = 0.1; m_SobelLowerThreshold = -100.0; m_SobelUpperThreshold = 200.0; } /** * Parameters the filters of the pipeline */ template void UrbanAreaDetectionImageFilter ::GenerateData() { // Intensity m_IntensityFilter->SetInput(this->GetInput()); // Edge Density m_SobelFilter->SetLowerThreshold(m_SobelLowerThreshold); m_SobelFilter->SetUpperThreshold(m_SobelUpperThreshold); SizeType lSize; lSize[0] = static_cast(10); lSize[1] = static_cast(10); m_EdgeDensityFilter->SetNeighborhoodRadius(lSize); // Threshold m_Thresholder->SetInsideValue(0); m_Thresholder->SetOutsideValue(1); m_Thresholder->SetLowerThreshold(-10.); m_Thresholder->SetUpperThreshold(m_ThresholdDensity); // Apply the mask on the input image m_MultiplyFilter->SetInput1(this->GetInput()); // Give a threshold to urbanAreaFilter m_UrbanAreaExtractionFilter->GetFunctor().SetLowerThreshold(m_ThresholdValue); // Progress accumulator itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); progress->RegisterInternalFilter(m_UrbanAreaExtractionFilter, 0.5f); /** GraftOutput */ m_UrbanAreaExtractionFilter->GraftOutput(this->GetOutput()); m_UrbanAreaExtractionFilter->Update(); this->GraftOutput(m_UrbanAreaExtractionFilter->GetOutput()); } } // end namespace otb #endif OTB-release-5.8/Modules/Detection/UrbanArea/otb-module.cmake000066400000000000000000000004561301006202600236620ustar00rootroot00000000000000set(DOCUMENTATION "This module is concerned with the detection of urban area.") otb_module(OTBUrbanArea DEPENDS OTBStatistics OTBITK OTBImageBase OTBEdge OTBImageManipulation OTBIndices TEST_DEPENDS OTBTestKernel OTBImageIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Detection/UrbanArea/test/000077500000000000000000000000001301006202600215635ustar00rootroot00000000000000OTB-release-5.8/Modules/Detection/UrbanArea/test/CMakeLists.txt000066400000000000000000000016041301006202600243240ustar00rootroot00000000000000otb_module_test() set(OTBUrbanAreaTests otbUrbanAreaTestDriver.cxx otbUrbanAreaDetectionImageFilterNew.cxx otbUrbanAreaDetectionImageFilter.cxx ) add_executable(otbUrbanAreaTestDriver ${OTBUrbanAreaTests}) target_link_libraries(otbUrbanAreaTestDriver ${OTBUrbanArea-Test_LIBRARIES}) otb_module_target_label(otbUrbanAreaTestDriver) # Tests Declaration otb_add_test(NAME raTuUrbanAreaDetectionImageFilterNew COMMAND otbUrbanAreaTestDriver otbUrbanAreaDetectionImageFilterNew ) otb_add_test(NAME raTvUrbanAreaDetectionImageFilter COMMAND otbUrbanAreaTestDriver --compare-image ${EPSILON_8} ${BASELINE}/raTvUrbanAreaDetection.png ${TEMP}/raTvUrbanAreaDetection.png otbUrbanAreaDetectionImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raTvUrbanAreaDetection.png 3 # red 2 # green 4 # nir 0.8 # threshold NDVI+NDWI 0.005 # threshold EdgeDensity ) OTB-release-5.8/Modules/Detection/UrbanArea/test/otbUrbanAreaDetectionImageFilter.cxx000066400000000000000000000037721301006202600306350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbUrbanAreaDetectionImageFilter.h" int otbUrbanAreaDetectionImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputVectorImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::UrbanAreaDetectionImageFilter UrbanAreaDetectionFilterType; // Instantiating objects UrbanAreaDetectionFilterType::Pointer filter = UrbanAreaDetectionFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); filter->SetRedIndex(::atoi(argv[3])); filter->SetGreenIndex(::atoi(argv[4])); filter->SetNIRIndex(::atoi(argv[5])); filter->SetThresholdValue(::atof(argv[6])); filter->SetThresholdDensity(::atof(argv[7])); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/UrbanArea/test/otbUrbanAreaDetectionImageFilterNew.cxx000066400000000000000000000024101301006202600312730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbUrbanAreaDetectionImageFilter.h" int otbUrbanAreaDetectionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputVectorImageType; typedef otb::Image OutputImageType; typedef otb::UrbanAreaDetectionImageFilter UrbanAreaDetectionFilterType; // Instantiating objects UrbanAreaDetectionFilterType::Pointer filter = UrbanAreaDetectionFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Detection/UrbanArea/test/otbUrbanAreaTestDriver.cxx000066400000000000000000000002331301006202600266660ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbUrbanAreaDetectionImageFilterNew); REGISTER_TEST(otbUrbanAreaDetectionImageFilter); } OTB-release-5.8/Modules/Feature/000077500000000000000000000000001301006202600164215ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Corner/000077500000000000000000000000001301006202600176515ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Corner/CMakeLists.txt000066400000000000000000000000451301006202600224100ustar00rootroot00000000000000project(OTBCorner) otb_module_impl() OTB-release-5.8/Modules/Feature/Corner/include/000077500000000000000000000000001301006202600212745ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Corner/include/otbHarrisImageFilter.h000066400000000000000000000106151301006202600255160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHarrisImageFilter_h #define otbHarrisImageFilter_h #include "itkImageToImageFilter.h" #include "itkHessianRecursiveGaussianImageFilter.h" #include "otbHessianToScalarImageFilter.h" #include "otbMultiplyByScalarImageFilter.h" #include "otbMath.h" namespace otb { /** \class HarrisImageFilter \brief This filter performs the computation of the Harris measure as followed. The derivative computation is performed by a convolution with the derivative of a Gaussian kernel of variance \f$\sigma_D\f$ (derivation scale) and the smoothing of the image is performed by convolving with a Gaussian kernel of variance \f$\sigma_I\f$ (integration scale). This allows the computation of the following matrix: \f[ \mu(\mathbf{x},\sigma_I,\sigma_D) = \sigma_D^2 g(\sigma_I)\star \left[\begin{array}{cc} L_x^2(\mathbf{x},\sigma_D) & L_xL_y^2(\mathbf{x},\sigma_D)\\ L_xL_y^2(\mathbf{x},\sigma_D)& L_y^2(\mathbf{x},\sigma_D) \end{array}\right] \f] The output of the detector is \f$[det(\mu) - \alpha trace^2(\mu)\f$. The interest points can then be extracted with a thresholding filter. * * * \ingroup OTBCorner */ template class HarrisImageFilter : public itk::ImageToImageFilter { public: itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef HarrisImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(HarrisImageFilter, ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::SizeType SizeType; typedef typename OutputImageType::PixelType OutputPixelType; // typedef typename InputImageType::SizeType SizeType; typedef itk::Image::RealType, InputImageDimension>, InputImageDimension> TensorType; typedef itk::HessianRecursiveGaussianImageFilter HessianFilterType; typedef itk::RecursiveGaussianImageFilter GaussianFilterType; typedef otb::HessianToScalarImageFilter HessianToScalarFilterType; typedef otb::MultiplyByScalarImageFilter MultiplyScalarFilterType; itkSetMacro(SigmaD, double); itkGetConstReferenceMacro(SigmaD, double); itkSetMacro(SigmaI, double); itkGetConstReferenceMacro(SigmaI, double); itkSetMacro(Alpha, double); itkGetConstReferenceMacro(Alpha, double); protected: HarrisImageFilter(); ~HarrisImageFilter() ITK_OVERRIDE {} void GenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: HarrisImageFilter(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_SigmaD; double m_SigmaI; double m_Alpha; typename HessianFilterType::Pointer m_HessianFilter; typename GaussianFilterType::Pointer m_GaussianFilter0; typename GaussianFilterType::Pointer m_GaussianFilter1; typename HessianToScalarFilterType::Pointer m_HessianToScalarFilter; typename MultiplyScalarFilterType::Pointer m_MultiplyScalarFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHarrisImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Corner/include/otbHarrisImageFilter.txx000066400000000000000000000053161301006202600261140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHarrisImageFilter_txx #define otbHarrisImageFilter_txx #include "otbHarrisImageFilter.h" namespace otb { /** * */ template HarrisImageFilter ::HarrisImageFilter() { m_SigmaD = 1.0; m_SigmaI = 1.0; m_Alpha = 1.0; m_HessianFilter = HessianFilterType::New(); m_GaussianFilter0 = GaussianFilterType::New(); m_GaussianFilter1 = GaussianFilterType::New(); m_HessianToScalarFilter = HessianToScalarFilterType::New(); m_MultiplyScalarFilter = MultiplyScalarFilterType::New(); } template void HarrisImageFilter ::GenerateData() { m_HessianFilter->SetInput(this->GetInput()); m_HessianFilter->SetSigma(this->m_SigmaD); m_HessianFilter->SetNormalizeAcrossScale(false); m_GaussianFilter0->SetInput(m_HessianFilter->GetOutput()); m_GaussianFilter0->SetSigma(this->m_SigmaI); m_GaussianFilter0->SetOrder(GaussianFilterType::ZeroOrder); m_GaussianFilter0->SetNormalizeAcrossScale(false); m_GaussianFilter1->SetInput(m_GaussianFilter0->GetOutput()); m_GaussianFilter1->SetSigma(this->m_SigmaI); m_GaussianFilter1->SetOrder(GaussianFilterType::ZeroOrder); m_GaussianFilter1->SetNormalizeAcrossScale(false); m_GaussianFilter1->SetDirection(1); m_HessianToScalarFilter->SetInput(m_GaussianFilter1->GetOutput()); m_HessianToScalarFilter->SetAlpha(this->m_Alpha); m_MultiplyScalarFilter->SetInput(m_HessianToScalarFilter->GetOutput()); m_MultiplyScalarFilter->SetCoef(vcl_pow(m_SigmaD, 4.0)); m_MultiplyScalarFilter->GraftOutput(this->GetOutput()); m_MultiplyScalarFilter->Update(); this->GraftOutput(m_MultiplyScalarFilter->GetOutput()); } /** * Standard "PrintSelf" method */ template void HarrisImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Sigma_D : " << this->m_SigmaD << std::endl; os << indent << "Sigma_I : " << this->m_SigmaI << std::endl; os << indent << "Alpha : " << this->m_Alpha << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Corner/include/otbHarrisImageToPointSetFilter.h000066400000000000000000000063351301006202600275130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHarrisImageToPointSetFilter_h #define otbHarrisImageToPointSetFilter_h #include "otbThresholdImageToPointSetFilter.h" #include "otbHarrisImageFilter.h" namespace otb { /** \class HarrisImageToPointSetFilter * \brief TODO * * \ingroup OTBCorner */ template > class ITK_EXPORT HarrisImageToPointSetFilter : public ImageToPointSetFilter { public: itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputPointSet OutputPointSetType; typedef HarrisImageToPointSetFilter Self; typedef ImageToPointSetFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(HarrisImageToPointSetFilter, ImageToPointSetFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::SizeType SizeType; typedef typename otb::HarrisImageFilter HarrisImageFilterType; typedef typename otb::ThresholdImageToPointSetFilter ThresholdImageToPointSetType; typedef typename OutputPointSetType::PixelType OutputPixelType; itkSetMacro(SigmaD, double); itkGetConstReferenceMacro(SigmaD, double); itkSetMacro(SigmaI, double); itkGetConstReferenceMacro(SigmaI, double); itkSetMacro(Alpha, double); itkGetConstReferenceMacro(Alpha, double); itkSetMacro(LowerThreshold, InputPixelType); itkGetConstReferenceMacro(LowerThreshold, InputPixelType); itkSetMacro(UpperThreshold, InputPixelType); itkGetConstReferenceMacro(UpperThreshold, InputPixelType); protected: HarrisImageToPointSetFilter(); ~HarrisImageToPointSetFilter() ITK_OVERRIDE {} void GenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: HarrisImageToPointSetFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InputPixelType m_LowerThreshold; InputPixelType m_UpperThreshold; double m_SigmaD; double m_SigmaI; double m_Alpha; typename HarrisImageFilterType::Pointer m_HarrisFilter; typename ThresholdImageToPointSetType::Pointer m_ThresholdFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHarrisImageToPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Corner/include/otbHarrisImageToPointSetFilter.txx000066400000000000000000000046331301006202600301060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHarrisImageToPointSetFilter_txx #define otbHarrisImageToPointSetFilter_txx #include "otbHarrisImageToPointSetFilter.h" namespace otb { /** * */ template HarrisImageToPointSetFilter ::HarrisImageToPointSetFilter() { m_SigmaD = 1.0; m_SigmaI = 1.0; m_Alpha = 1.0; m_LowerThreshold = itk::NumericTraits::NonpositiveMin(); m_UpperThreshold = itk::NumericTraits::max(); m_HarrisFilter = HarrisImageFilterType::New(); m_ThresholdFilter = ThresholdImageToPointSetType::New(); } template void HarrisImageToPointSetFilter ::GenerateData() { typename OutputPointSetType::Pointer pointList = this->GetOutput(); m_HarrisFilter->SetInput(0, this->GetInput(0)); m_HarrisFilter->SetSigmaD(m_SigmaD); m_HarrisFilter->SetSigmaI(m_SigmaI); m_HarrisFilter->SetAlpha(m_Alpha); m_ThresholdFilter->SetInput(0, m_HarrisFilter->GetOutput()); m_ThresholdFilter->SetLowerThreshold(m_LowerThreshold); m_ThresholdFilter->SetUpperThreshold(m_UpperThreshold); m_ThresholdFilter->SetOutput(pointList); m_ThresholdFilter->Update(); } /** * Standard "PrintSelf" method */ template void HarrisImageToPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Sigma_D : " << this->m_SigmaD << std::endl; os << indent << "Sigma_I : " << this->m_SigmaI << std::endl; os << indent << "Alpha : " << this->m_Alpha << std::endl; os << indent << "LowerThreshold : " << this->m_LowerThreshold << std::endl; os << indent << "UpperThreshold : " << this->m_UpperThreshold << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Corner/include/otbLineSpatialObjectListToRightAnglePointSetFilter.h000066400000000000000000000122561301006202600334540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSpatialObjectListToRightAnglePointSetFilter_h #define otbLineSpatialObjectListToRightAnglePointSetFilter_h #include "itkPointSet.h" #include "otbLineSpatialObjectListToPointSetFilter.h" #include "otbMath.h" #include "itkVariableSizeMatrix.h" namespace otb { /** \class LineSpatialObjectListToRightAnglePointSetFilter * \brief TODO * * \ingroup OTBCorner */ template class ITK_EXPORT LineSpatialObjectListToRightAnglePointSetFilter : public otb::LineSpatialObjectListToPointSetFilter { public: /** Standard class typedefs. */ typedef LineSpatialObjectListToRightAnglePointSetFilter Self; typedef LineSpatialObjectListToPointSetFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LineSpatialObjectListToRightAnglePointSetFilter, LineSpatialObjectListToPointSetFilter); /** Typedef support for ProcessObject*/ typedef itk::ProcessObject ProcessObjectType; /** Template parameters typedefs*/ typedef TLinesList InputLinesListType; typedef typename InputLinesListType::LineType LineType; typedef std::vector VectorLineType; //typedef typename LineType::PointListType InputPointListType; typedef typename InputLinesListType::const_iterator InputLinesListTypeIterator; /** Typdedef for The input image : * (ONLY USED FOR THE LINE ITERATOR -> To check if the index is inside the region) */ typedef TImage InputImageType; typedef typename InputImageType::IndexType InputIndexType; /** Typedef support for output PointSet*/ typedef TPointSet OutputPointSetType; typedef typename OutputPointSetType::PointType PointType; typedef typename OutputPointSetType::Pointer OutputPointSetPointerType; /** Typedef Support for Checking couple of segments used*/ typedef itk::VariableSizeMatrix checkMatrixType; /** * Public Methods : * Get the Input Image & Get The input Image */ virtual InputImageType* GetInputImage(); virtual void SetInputImage(InputImageType *); /** Set/Get the thresholds*/ itkGetMacro(ThresholdDistance, double); itkSetMacro(ThresholdDistance, double); itkGetMacro(ThresholdAngle, double); itkSetMacro(ThresholdAngle, double); protected: /** * Without the GenerateOutputInformation below it does not work * Because the ProcessObject class do a static_cast to allow memory and copy * the output (here a pointset). It works fine with images but with pointsets * no size is specified ... * the aim of the GenerateOutputInformation below is to avoid the guilty static_cast * */ void GenerateOutputInformation() ITK_OVERRIDE{} /** * Constructor. */ LineSpatialObjectListToRightAnglePointSetFilter(); /** * Destructor. */ ~LineSpatialObjectListToRightAnglePointSetFilter() ITK_OVERRIDE{} /** * Standard PrintSelf method. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Main computation method. */ void GenerateData() ITK_OVERRIDE; /** * Angle computation */ virtual double ComputeAngleFormedBySegments(LineType * lineDst, LineType * lineSrc); /** * When we find a right angle, one compute the coordinate of the segments intersection */ virtual PointType ComputeAngleRightCoordinate(LineType * lineDst, LineType * lineSrc); /** * AddRightAngleToPointSet */ virtual void AddRightAngleToPointSet(PointType rAngle, LineType * LineDst, LineType* LineCur); /** * Compute the orienation of a segment */ virtual double ComputeOrientation(LineType* line); /** * Distance From a point rAngle to a segment line */ virtual double ComputeDistanceFromPointToSegment(PointType rAngle, LineType * line); private: LineSpatialObjectListToRightAnglePointSetFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Smart pointer on the output PointSet*/ OutputPointSetPointerType m_OutputPointSet; double m_ThresholdDistance; double m_ThresholdAngle; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineSpatialObjectListToRightAnglePointSetFilter.txx" #endif #endif otbLineSpatialObjectListToRightAnglePointSetFilter.txx000066400000000000000000000246141301006202600337720ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Corner/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSpatialObjectListToRightAnglePointSetFilter_txx #define otbLineSpatialObjectListToRightAnglePointSetFilter_txx #include "otbLineSpatialObjectListToRightAnglePointSetFilter.h" #include "itkLineIterator.h" #include "itkMatrix.h" #include "vnl/vnl_math.h" namespace otb { /** * */ template LineSpatialObjectListToRightAnglePointSetFilter ::LineSpatialObjectListToRightAnglePointSetFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); m_ThresholdDistance = 20.; m_ThresholdAngle = CONST_PI / 30.; //36 cause we want 6 degrees threshold } /** * Method : Set The Input Image */ template void LineSpatialObjectListToRightAnglePointSetFilter ::SetInputImage(InputImageType * inputImage) { this->itk::ProcessObject::SetNthInput(1, const_cast(inputImage)); } /** * Method : Get The Input Image */ template typename LineSpatialObjectListToRightAnglePointSetFilter ::InputImageType * LineSpatialObjectListToRightAnglePointSetFilter ::GetInputImage() { return static_cast (this->ProcessObjectType::GetInput(1)); } /** * Method : GenerateData() */ template void LineSpatialObjectListToRightAnglePointSetFilter ::GenerateData() { unsigned int counterTest = 0, counterCur = 0; /** Output*/ m_OutputPointSet = this->GetOutput(); /** Get The input Lines*/ typename InputLinesListType::Pointer inputLinesList = const_cast(this->GetInput()); /** Instancition of Checking availability Matrix*/ unsigned int numberOfLines = inputLinesList->size(); checkMatrixType segmentsUsedMatrix(numberOfLines, numberOfLines); segmentsUsedMatrix.Fill(0); /** Loop to get all the lines in the listLine */ InputLinesListTypeIterator itLinesListTest = inputLinesList->begin(); /** Current tested Line */ while (itLinesListTest != inputLinesList->end()) { counterCur = 0; InputLinesListTypeIterator itLinesListCur = inputLinesList->begin(); /** Line tested with with current Line*/ InputLinesListTypeIterator itLinesListCurEnd = inputLinesList->end(); while (itLinesListCur != itLinesListCurEnd) { /** Check If segments are already computed */ if (segmentsUsedMatrix[counterTest][counterCur] == 0 && segmentsUsedMatrix[counterCur][counterTest] == 0) { /** Set the segments to USED (== 1)*/ segmentsUsedMatrix[counterTest][counterCur] = 1; segmentsUsedMatrix[counterCur][counterTest] = 1; /** Compute the angle formed by the two segments */ double Angle = this->ComputeAngleFormedBySegments(*itLinesListTest, *itLinesListCur); /** Check if the angle is a right one */ if (vcl_abs(Angle - CONST_PI_2) <= m_ThresholdAngle) { /** Right angle coordinate*/ PointType RightAngleCoordinate; RightAngleCoordinate = this->ComputeAngleRightCoordinate(*itLinesListTest, *itLinesListCur); /** Compute the distance between the two segments and the right angle formed by this segments*/ double dist1 = this->ComputeDistanceFromPointToSegment(RightAngleCoordinate, *itLinesListTest); double dist2 = this->ComputeDistanceFromPointToSegment(RightAngleCoordinate, *itLinesListCur); /** Use Pythagore to compute the distance between the two segments*/ double SegmentDistance = vcl_sqrt(dist1 * dist1 + dist2 * dist2); // if(this->ComputeDistanceFromPointToSegment(RightAngleCoordinate, *itLinesListTest) ComputeDistanceFromPointToSegment(RightAngleCoordinate, *itLinesListCur) AddRightAngleToPointSet(RightAngleCoordinate, *itLinesListTest, *itLinesListCur); } } } ++counterCur; ++itLinesListCur; } ++counterTest; ++itLinesListTest; } } /** * Method : Compute Distance between a point and a segment * */ template double LineSpatialObjectListToRightAnglePointSetFilter ::ComputeDistanceFromPointToSegment(PointType rAngle, LineType * line) { /** Extract Indexes from the Dst line to instantiate the line iterator*/ typename LineType::PointListType& pointsListDst = line->GetPoints(); typename LineType::PointListType::const_iterator itPointsDst = pointsListDst.begin(); double X1 = (*itPointsDst).GetPosition()[0]; //xq1 double Y1 = (*itPointsDst).GetPosition()[1]; //yq1 ++itPointsDst; double X2 = (*itPointsDst).GetPosition()[0]; //xq2 double Y2 = (*itPointsDst).GetPosition()[1]; //yq2 double dist1 = vcl_sqrt((X1 - rAngle[0]) * (X1 - rAngle[0]) + (Y1 - rAngle[1]) * (Y1 - rAngle[1])); double dist2 = vcl_sqrt((X2 - rAngle[0]) * (X2 - rAngle[0]) + (Y2 - rAngle[1]) * (Y2 - rAngle[1])); return std::min(dist1, dist2); } /** * Method : Compute Angle formed by the two segments * */ template double LineSpatialObjectListToRightAnglePointSetFilter ::ComputeAngleFormedBySegments(LineType * lineDst, LineType * lineSrc) { double oriDst = this->ComputeOrientation(lineDst); double oriSrc = this->ComputeOrientation(lineSrc); return vcl_abs(oriDst - oriSrc); } /** * Method : ComputeDistanceBetweenSegments */ template double LineSpatialObjectListToRightAnglePointSetFilter ::ComputeOrientation(LineType * line) { typename LineType::PointListType& pointsList = line->GetPoints(); typename LineType::PointListType::const_iterator itPoints = pointsList.begin(); double Xp1 = (*itPoints).GetPosition()[0]; double Yp1 = (*itPoints).GetPosition()[1]; ++itPoints; double Xp2 = (*itPoints).GetPosition()[0]; double Yp2 = (*itPoints).GetPosition()[1]; //Compute the orientation double dx = Xp1 - Xp2; double dy = Yp1 - Yp2; double orientation = vcl_atan2(dy, dx); if (orientation < 0) orientation += CONST_PI; return orientation; } /** * Method : ComputeDistanceBetweenSegments */ template typename LineSpatialObjectListToRightAnglePointSetFilter ::PointType LineSpatialObjectListToRightAnglePointSetFilter ::ComputeAngleRightCoordinate(LineType * lineDst, LineType * lineSrc) { PointType P; /** ----- */ typename LineType::PointListType& pointsList = lineSrc->GetPoints(); typename LineType::PointListType::const_iterator itPoints = pointsList.begin(); double Xp1 = (*itPoints).GetPosition()[0]; double Yp1 = (*itPoints).GetPosition()[1]; ++itPoints; double Xp2 = (*itPoints).GetPosition()[0]; double Yp2 = (*itPoints).GetPosition()[1]; /** Extract Indexes from the Dst line to instantiate the line iterator*/ typename LineType::PointListType& pointsListDst = lineDst->GetPoints(); typename LineType::PointListType::const_iterator itPointsDst = pointsListDst.begin(); double Xq1 = (*itPointsDst).GetPosition()[0]; //xq1 double Yq1 = (*itPointsDst).GetPosition()[1]; //yq1 ++itPointsDst; double Xq2 = (*itPointsDst).GetPosition()[0]; //xq2 double Yq2 = (*itPointsDst).GetPosition()[1]; //yq2 /** Compute the equation of the lines A and B which are support of the segments Src & Dst*/ // - Line 1 : slope and origin double originA = 0., slopeA = 0.; double originB = 0., slopeB = 0.; double LengthSegmentAy = 0., lengthSegmentBy = 0.; /** Equation of the first Line*/ if (vcl_abs(Xp2 - Xp1) < 1e-10) Xp2 = 0.0001; if (Xp1 < Xp2) LengthSegmentAy = Yp2 - Yp1; else LengthSegmentAy = Yp1 - Yp2; slopeA = LengthSegmentAy / (Xp2 - Xp1); originA = Yp1 - (slopeA * Xp1); /** Equation of the second Line*/ if (vcl_abs(Xq2 - Xq1) < 1e-10) Xq2 = 0.0001; if (Xq1 < Xq2) lengthSegmentBy = Yq2 - Yq1; else lengthSegmentBy = Yq1 - Yq2; slopeB = lengthSegmentBy / (Xq2 - Xq1); originB = Yq1 - (slopeB * Xq1); /** Avoid the case of parallel lines*/ double denum = 0.; if (vcl_abs(slopeA - slopeB) < 1e-5) denum = 0.001; else denum = slopeA - slopeB; /** Compute the coordinate of the intersection point Y =AX+B*/ P[0] = (originB - originA) / denum; P[1] = slopeA * static_cast(P[0]) + originA; return P; } /** * AddRightAngleToPointSet */ template void LineSpatialObjectListToRightAnglePointSetFilter ::AddRightAngleToPointSet(PointType rAngle, LineType * LineDst, LineType* LineCur) { unsigned int CurrentPos = m_OutputPointSet->GetNumberOfPoints(); m_OutputPointSet->SetPoint(CurrentPos, rAngle); VectorLineType vectorLine; vectorLine.push_back(LineDst); vectorLine.push_back(LineCur); m_OutputPointSet->SetPointData(CurrentPos, vectorLine); } /** * Standard "PrintSelf" method */ template void LineSpatialObjectListToRightAnglePointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Corner/include/otbVectorDataToRightAngleVectorDataFilter.h000066400000000000000000000076131301006202600316100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToRightAngleVectorDataFilter_h #define otbVectorDataToRightAngleVectorDataFilter_h #include "otbVectorDataToVectorDataFilter.h" #include "itkPreOrderTreeIterator.h" #include "otbMath.h" namespace otb { /** \class VectorDataToRightAngleVectorDataFilter * \brief Right angle detector * * This filter aims at detecting right angle formed by the segments * included in the input VectorData. It outputs a vector data * containing right angle localizations symbolized by points. * * The entire input vector data will be processed considering the two * firsts vertex of each line features as a segment. * * * * \ingroup OTBCorner */ template class ITK_EXPORT VectorDataToRightAngleVectorDataFilter : public otb::VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataToRightAngleVectorDataFilter Self; typedef VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToRightAngleVectorDataFilter, VectorDataToVectorDataFilter); /** Typedef support for ProcessObject*/ typedef itk::ProcessObject ProcessObjectType; /** Typdedef support for the VectroData*/ typedef TVectorData VectorDataType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename VectorDataType::LineType LineType; typedef typename VectorDataType::PointType PointType; typedef typename LineType::VertexType VertexType; typedef typename LineType::VertexListType VertexListType; typedef itk::PreOrderTreeIterator TreeIteratorType; /** Set/Get the thresholds*/ itkGetMacro(DistanceThreshold, double); itkSetMacro(DistanceThreshold, double); itkGetMacro(AngleThreshold, double); itkSetMacro(AngleThreshold, double); protected: /** Constructor.*/ VectorDataToRightAngleVectorDataFilter(); /**Destructor.*/ ~VectorDataToRightAngleVectorDataFilter() ITK_OVERRIDE{} /** Standard PrintSelf method.*/ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /**Main computation method.*/ void GenerateData() ITK_OVERRIDE; /**Angle computation.*/ virtual double ComputeAngleFormedBySegments(LineType * lineDst, LineType * lineSrc); /** When we find a right angle, one compute the coordinate of the segments intersection.*/ virtual PointType ComputeRightAngleCoordinate(LineType * lineDst, LineType * lineSrc); /**Compute the orientation of a segment*/ virtual double ComputeOrientation(LineType * line); /**Distance From a point rAngle to a segment line.*/ virtual double ComputeDistanceFromPointToSegment(PointType rAngle, LineType * line); private: VectorDataToRightAngleVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_DistanceThreshold; double m_AngleThreshold; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToRightAngleVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Corner/include/otbVectorDataToRightAngleVectorDataFilter.txx000066400000000000000000000161521301006202600322020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToRightAngleVectorDataFilter_txx #define otbVectorDataToRightAngleVectorDataFilter_txx #include "otbVectorDataToRightAngleVectorDataFilter.h" #include "otbVectorData.h" namespace otb { template VectorDataToRightAngleVectorDataFilter ::VectorDataToRightAngleVectorDataFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_DistanceThreshold = 20.; m_AngleThreshold = CONST_PI / 30.; //we want a threshold at 6 degrees } template void VectorDataToRightAngleVectorDataFilter ::GenerateData() { // Get the input segments typename VectorDataType::Pointer vData = const_cast(this->GetInput()); // Output this->GetOutput(0)->SetMetaDataDictionary(vData->GetMetaDataDictionary()); // Retrieving root node typename DataNodeType::Pointer root = this->GetOutput(0)->GetDataTree()->GetRoot()->Get(); // Create the document node typename DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(document, root); // Create the folder node typename DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); this->GetOutput(0)->GetDataTree()->Add(folder, document); this->GetOutput(0)->SetProjectionRef(vData->GetProjectionRef()); // Itterate on the vector data TreeIteratorType itVectorRef(vData->GetDataTree()); // Reference itVectorRef.GoToBegin(); while (!itVectorRef.IsAtEnd()) { if (!itVectorRef.Get()->IsLineFeature()) { ++itVectorRef; continue; // do not process if it's not a line } TreeIteratorType itVectorCur = itVectorRef; // Current while (!itVectorCur.IsAtEnd()) { if (!itVectorCur.Get()->IsLineFeature()) { ++itVectorCur; continue; // do not process if it's not a line } // Compute the angle formed by the two segments double Angle = this->ComputeAngleFormedBySegments(itVectorRef.Get()->GetLine(), itVectorCur.Get()->GetLine()); // Check if the angle is a right one if (vcl_abs(Angle - CONST_PI_2) <= m_AngleThreshold) { // Right angle coordinate PointType RightAngleCoordinate; RightAngleCoordinate = this->ComputeRightAngleCoordinate(itVectorRef.Get()->GetLine(), itVectorCur.Get()->GetLine()); // Compute the distance between the two segments and the right angle formed by this segments double dist1_2 = this->ComputeDistanceFromPointToSegment(RightAngleCoordinate, itVectorRef.Get()->GetLine()); double dist2_2 = this->ComputeDistanceFromPointToSegment(RightAngleCoordinate, itVectorCur.Get()->GetLine()); double threshold_2 = m_DistanceThreshold * m_DistanceThreshold; if (dist1_2 < threshold_2 && dist2_2 < threshold_2) { // If Right Angle & not so far from segments: Add to the output typename DataNodeType::Pointer CurrentGeometry = DataNodeType::New(); CurrentGeometry->SetNodeId("FEATURE_POINT"); CurrentGeometry->SetNodeType(otb::FEATURE_POINT); CurrentGeometry->SetPoint(RightAngleCoordinate); this->GetOutput(0)->GetDataTree()->Add(CurrentGeometry, folder); } } ++itVectorCur; } ++itVectorRef; } } template double VectorDataToRightAngleVectorDataFilter ::ComputeDistanceFromPointToSegment(PointType rAngle, LineType * line) { VertexListType * vertexList = const_cast(line->GetVertexList()); VertexType v0 = vertexList->GetElement(0); VertexType v1 = vertexList->GetElement(1); // Case the extremities of the segment are the same double l2 = v0.SquaredEuclideanDistanceTo(v1); // Is the projection of rAngle on the segment inside (0 1e-10 ) u = 1.; double x = v0[0] + u *(v1[0] - v0[0] ); double y = v0[1] + u *(v1[1] - v0[1] ); double dx = x - rAngle[0]; double dy = y - rAngle[1]; return dx*dx + dy*dy; } template double VectorDataToRightAngleVectorDataFilter ::ComputeAngleFormedBySegments(LineType * lineDst, LineType * lineSrc) { double oriDst = this->ComputeOrientation(lineDst); double oriSrc = this->ComputeOrientation(lineSrc); return vcl_abs(oriDst - oriSrc); } template double VectorDataToRightAngleVectorDataFilter ::ComputeOrientation(LineType * line) { VertexListType * vertexList = const_cast(line->GetVertexList()); double Xp1 = vertexList->GetElement(0)[0]; double Yp1 = vertexList->GetElement(0)[1]; double Xp2 = vertexList->GetElement(1)[0]; double Yp2 = vertexList->GetElement(1)[1]; //Compute the orientation double dx = Xp1 - Xp2; double dy = Yp1 - Yp2; double orientation = vcl_atan2(dy, dx); if (orientation < 0) orientation += CONST_PI; return orientation; } template typename VectorDataToRightAngleVectorDataFilter ::PointType VectorDataToRightAngleVectorDataFilter ::ComputeRightAngleCoordinate(LineType * lineDst, LineType * lineSrc) { PointType P; VertexListType * vertexListSrc = const_cast(lineSrc->GetVertexList()); double Xp1 = vertexListSrc->GetElement(0)[0]; double Yp1 = vertexListSrc->GetElement(0)[1]; double Xp2 = vertexListSrc->GetElement(1)[0]; double Yp2 = vertexListSrc->GetElement(1)[1]; VertexListType * vertexListDst = const_cast(lineDst->GetVertexList()); double Xq1 = vertexListDst->GetElement(0)[0]; double Yq1 = vertexListDst->GetElement(0)[1]; double Xq2 = vertexListDst->GetElement(1)[0]; double Yq2 = vertexListDst->GetElement(1)[1]; double numU = (Xq2 - Xq1)*(Yp1-Yq1) - (Yq2-Yq1)*(Xp1-Xq1); double denumU = (Yq2-Yq1)*(Xp2-Xp1)-(Xq2-Xq1)*(Yp2-Yp1); double u = numU/ denumU; P[0] = Xp1 + u*(Xp2-Xp1); P[1] = Yp1 + u * (Yp2-Yp1); return P; } template void VectorDataToRightAngleVectorDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Corner/otb-module.cmake000066400000000000000000000010421301006202600227170ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes that implement classical corner detection algorithms (Harris for instance). It also contains classes to detect right angle by exploiting the output of a line detection algorithm.") otb_module(OTBCorner DEPENDS OTBVectorDataBase OTBITK OTBDescriptors OTBSpatialObjects OTBVectorDataManipulation OTBPointSet OTBImageManipulation OTBCommon TEST_DEPENDS OTBVectorDataIO OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Feature/Corner/test/000077500000000000000000000000001301006202600206305ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Corner/test/CMakeLists.txt000066400000000000000000000101541301006202600233710ustar00rootroot00000000000000otb_module_test() set(OTBCornerTests otbCornerTestDriver.cxx otbLineSpatialObjectListToRightAnglePointSetFilter.cxx otbVectorDataToRightAngleVectorDataFilter.cxx otbLineSpatialObjectListToRightAnglePointSetFilterByStepsOutputAscii.cxx otbLineSpatialObjectListToRightAnglePointSetFilterNew.cxx otbHarrisImage.cxx otbHarrisToPointSet.cxx ) add_executable(otbCornerTestDriver ${OTBCornerTests}) target_link_libraries(otbCornerTestDriver ${OTBCorner-Test_LIBRARIES}) otb_module_target_label(otbCornerTestDriver) # Tests Declaration otb_add_test(NAME feTvLineSpatialObjectListToRightAnglePointSetFilter COMMAND otbCornerTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvLineSpatialObjectListToRightAnglePointSetFilterOutputAscii.txt ${TEMP}/feTvLineSpatialObjectListToRightAnglePointSetFilterOutputAscii.txt otbLineSpatialObjectListToRightAnglePointSetFilter ${INPUTDATA}/carre.png ${TEMP}/feTvLineSpatialObjectListToRightAnglePointSetFilterOutputAscii.txt ) otb_add_test(NAME feTvVectorDataToRightAngleVectorDataFilter COMMAND otbCornerTestDriver --compare-ogr ${EPSILON_8} ${BASELINE_FILES}/feTvVectorDataToRightAngleVectorDataFilterOutput.shp ${TEMP}/feTvVectorDataToRightAngleVectorDataFilterOutput.shp otbVectorDataToRightAngleVectorDataFilter ${BASELINE_FILES}/feTvLineSegmentDetectorOutput.shp #input vectordata ${TEMP}/feTvVectorDataToRightAngleVectorDataFilterOutput.shp #output text file ) otb_add_test(NAME feTuVectorDataToRightAngleVectorDataFilterNew COMMAND otbCornerTestDriver otbVectorDataToRightAngleVectorDataFilterNew) otb_add_test(NAME feTvLineSpatialObjectListToRightAnglePointSetFilterBySteps COMMAND otbCornerTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvLineSpatialObjectListToRightAnglePointSetFilterOutputAscii.txt ${TEMP}/feTvLineSpatialObjectListToRightAnglePointSetFilterByStepsOutputAscii.txt otbLineSpatialObjectListToRightAnglePointSetFilterByStepsOutputAscii ${INPUTDATA}/carre.png ${TEMP}/feTvLineSpatialObjectListToRightAnglePointSetFilterByStepsOutputAscii.txt ) otb_add_test(NAME feTuLineSpatialObjectListToRightAnglePointSetFilterNew COMMAND otbCornerTestDriver otbLineSpatialObjectListToRightAnglePointSetFilterNew) otb_add_test(NAME feTvHarrisImage COMMAND otbCornerTestDriver --compare-image ${NOTOL} ${BASELINE}/feHarrisImage.png ${TEMP}/feHarrisImage.png otbHarrisImage ${INPUTDATA}/TeteAToto.png ${TEMP}/feHarrisImage.png 1.0 2.0 0.0) otb_add_test(NAME feTvHarrisPoupee COMMAND otbCornerTestDriver --compare-image ${NOTOL} ${BASELINE}/feHarris_poupees.png ${TEMP}/feHarris_poupees.png otbHarrisImage ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/feHarris_poupees.png 1.0 1.0 1.0) otb_add_test(NAME feTvHarrisProduceImageToValidHarrisToPointSet COMMAND otbCornerTestDriver otbHarrisImage ${INPUTDATA}/small_points.hdr ${TEMP}/small_points_harris.hdr 1.0 1.0 1.0) otb_add_test(NAME feTvHarrisImageQB COMMAND otbCornerTestDriver --compare-image ${NOTOL} ${BASELINE}/feHarrisImage_QB.png ${TEMP}/feHarrisImage_QB.png otbHarrisImage ${INPUTDATA}/QB_Suburb.png ${TEMP}/feHarrisImage_QB.png 1.0 1.0 1.0) otb_add_test(NAME feTvHarrisToPointSet2 COMMAND otbCornerTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feHarrisToPointSet_Threshold_20To90.txt ${TEMP}/feHarrisToPointSet_Threshold_20To90.txt otbHarrisToPointSet ${INPUTDATA}/small_points.hdr ${TEMP}/feHarrisToPointSet_Threshold_20To90.txt 1.0 1.0 1.0 20 90) otb_add_test(NAME feTvHarrisToPointSet3 COMMAND otbCornerTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feHarrisToPointSet_Threshold_100To160.txt ${TEMP}/feHarrisToPointSet_Threshold_100To160.txt otbHarrisToPointSet ${INPUTDATA}/small_points.hdr ${TEMP}/feHarrisToPointSet_Threshold_100To160.txt 1.0 1.0 1.0 100 160) otb_add_test(NAME feTvHarrisToPointSet1 COMMAND otbCornerTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feHarrisToPointSet_Threshold_2To255.txt ${TEMP}/feHarrisToPointSet_Threshold_2To255.txt otbHarrisToPointSet ${INPUTDATA}/small_points.hdr ${TEMP}/feHarrisToPointSet_Threshold_2To255.txt 1.0 1.0 1.0 2.0 255.0) OTB-release-5.8/Modules/Feature/Corner/test/otbCornerTestDriver.cxx000066400000000000000000000007301301006202600253250ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbLineSpatialObjectListToRightAnglePointSetFilter); REGISTER_TEST(otbVectorDataToRightAngleVectorDataFilterNew); REGISTER_TEST(otbVectorDataToRightAngleVectorDataFilter); REGISTER_TEST(otbLineSpatialObjectListToRightAnglePointSetFilterByStepsOutputAscii); REGISTER_TEST(otbLineSpatialObjectListToRightAnglePointSetFilterNew); REGISTER_TEST(otbHarrisImage); REGISTER_TEST(otbHarrisToPointSet); } OTB-release-5.8/Modules/Feature/Corner/test/otbHarrisImage.cxx000066400000000000000000000036351301006202600242630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbHarrisImageFilter.h" int otbHarrisImage(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; double SigmaD((double) ::atof(argv[3])); double SigmaI((double) ::atof(argv[4])); double Alpha((double) ::atof(argv[5])); typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::HarrisImageFilter FunctionType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FunctionType::Pointer harris = FunctionType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); harris->SetInput(reader->GetOutput()); harris->SetSigmaD(SigmaD); harris->SetSigmaI(SigmaI); harris->SetAlpha(Alpha); writer->SetInput(harris->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Corner/test/otbHarrisToPointSet.cxx000066400000000000000000000051011301006202600252770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbHarrisImageToPointSetFilter.h" #include int otbHarrisToPointSet(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; double SigmaD((double) ::atof(argv[3])); double SigmaI((double) ::atof(argv[4])); double AlphaValue((double) ::atof(argv[5])); typedef unsigned char PixelType; const unsigned int Dimension = 2; PixelType LowerThreshold((PixelType) ::atoi(argv[6])); PixelType UpperThreshold((PixelType) ::atoi(argv[7])); typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::HarrisImageToPointSetFilter FunctionType; typedef FunctionType::OutputPointSetType OutputPointSetType; typedef OutputPointSetType::PointType OutputPointType; ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer harris = FunctionType::New(); OutputPointType CoordPoint; //Initialization CoordPoint.Fill(0); reader->SetFileName(inputFilename); harris->SetInput(0, reader->GetOutput()); harris->SetSigmaD(SigmaD); harris->SetSigmaI(SigmaI); harris->SetAlpha(AlphaValue); harris->SetLowerThreshold(LowerThreshold); harris->SetUpperThreshold(UpperThreshold); OutputPointSetType * pointList = harris->GetOutput(); harris->Update(); std::cout << "Threshold Lower/Upper : " << harris->GetLowerThreshold() << "/" << harris->GetUpperThreshold() << std::endl; std::ofstream file; file.open(outputFilename); unsigned long NbPoints = pointList->GetNumberOfPoints(); file << "NbPoints : " << NbPoints << std::endl; for (unsigned long i = 0; i < NbPoints; ++i) { pointList->GetPoint(i, &CoordPoint); file << i + 1 << " / " << NbPoints << " : "; file << CoordPoint[0] << " , " << CoordPoint[1] << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Corner/test/otbLineSpatialObjectListToRightAnglePointSetFilter.cxx000066400000000000000000000073361301006202600333660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbLineSpatialObjectListToRightAnglePointSetFilter.h" #include "otbLineSpatialObjectList.h" #include "otbImageFileReader.h" #include #include int otbLineSpatialObjectListToRightAnglePointSetFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; /** Typedefs */ typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::LineSpatialObjectList LinesListType; typedef LinesListType::LineType LineType; typedef std::vector VectorLines; typedef itk::PointSet PointSetType; typedef otb::LineSpatialObjectListToRightAnglePointSetFilter RightAngleFilterType; /** Creatop, of an instance of the filters */ RightAngleFilterType::Pointer rightAngleFilter = RightAngleFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); PointSetType::Pointer segmentOrtho = PointSetType::New(); /** Creation of lines */ LinesListType::Pointer list = LinesListType::New(); LineType::PointListType pointList; LineType::LinePointType point; // Definition of the first line float Ux, Uy, Vx, Vy; Ux = 31.7; Uy = 11.1; Vx = 31.7; Vy = 25.1; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line = LineType::New(); line->SetId(0); line->SetPoints(pointList); line->ComputeBoundingBox(); list->push_back(line); pointList.clear(); // Definition of a second line Ux = 10.1; Uy = 10.7; Vx = 30.1; Vy = 10.6; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line2 = LineType::New(); line2->SetId(0); line2->SetPoints(pointList); line2->ComputeBoundingBox(); list->push_back(line2); pointList.clear(); // Definition of a third line Ux = 20.1; Uy = 7.1; Vx = 40.5; Vy = 17.1; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line3 = LineType::New(); line3->SetId(0); line3->SetPoints(pointList); line3->ComputeBoundingBox(); list->push_back(line3); // Begin the process reader->SetFileName(infname); rightAngleFilter->SetInputImage(reader->GetOutput()); rightAngleFilter->SetInput(list); rightAngleFilter->Update(); /** Writing The result in the outfile*/ std::ofstream outfile(outfname); outfile << "Number of right angles detected " << rightAngleFilter->GetOutput()->GetNumberOfPoints() << std::endl; /** Draw the orthogonal segments */ segmentOrtho = rightAngleFilter->GetOutput(); PointSetType::PointType pRight; for (unsigned int i = 0; i < segmentOrtho->GetNumberOfPoints(); ++i) { segmentOrtho->GetPoint(i, &pRight); outfile << " Right Angle found in point : " << pRight << std::endl; } outfile.close(); return EXIT_SUCCESS; } otbLineSpatialObjectListToRightAnglePointSetFilterByStepsOutputAscii.cxx000066400000000000000000000103641301006202600370060ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Corner/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbLineSpatialObjectListToRightAnglePointSetFilter.h" #include "otbDrawLineSpatialObjectListFilter.h" #include "otbImageFileReader.h" #include #include int otbLineSpatialObjectListToRightAnglePointSetFilterByStepsOutputAscii(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; /** Typedefs */ typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::LineSpatialObjectList LinesListType; typedef LinesListType::LineType LineType; typedef std::vector VectorLines; typedef itk::PointSet PointSetType; typedef otb::LineSpatialObjectListToRightAnglePointSetFilter RightAngleFilterType; /** Creatop, of an instance of the filters */ RightAngleFilterType::Pointer rightAngleFilter = RightAngleFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); PointSetType::Pointer segmentOrtho = PointSetType::New(); /** Creation of lines */ LinesListType::Pointer list = LinesListType::New(); LineType::PointListType pointList; LineType::LinePointType point; // Definition of the first line float Ux, Uy, Vx, Vy; Ux = 31.7; Uy = 11.1; Vx = 31.7; Vy = 25.1; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line = LineType::New(); line->SetId(0); line->SetPoints(pointList); line->ComputeBoundingBox(); list->push_back(line); pointList.clear(); // Definition of a second line Ux = 10.1; Uy = 10.7; Vx = 30.1; Vy = 10.6; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line2 = LineType::New(); line2->SetId(0); line2->SetPoints(pointList); line2->ComputeBoundingBox(); list->push_back(line2); pointList.clear(); // Definition of a third line Ux = 20.1; Uy = 7.1; Vx = 40.5; Vy = 17.1; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line3 = LineType::New(); line3->SetId(0); line3->SetPoints(pointList); line3->ComputeBoundingBox(); list->push_back(line3); // Begin the process reader->SetFileName(infname); rightAngleFilter->SetInputImage(reader->GetOutput()); rightAngleFilter->SetInput(list); rightAngleFilter->Update(); std::cout << "Number of right angles detected " << rightAngleFilter->GetOutput()->GetNumberOfPoints() << std::endl; /** Print the right angles coordinate in the output file*/ segmentOrtho = rightAngleFilter->GetOutput(); PointSetType::PointType pRight; VectorLines outputVectorLines; LinesListType::Pointer outputLinesList = LinesListType::New(); std::ofstream outfile(outfname); outfile << "Number of right angles detected " << rightAngleFilter->GetOutput()->GetNumberOfPoints() << std::endl; for (unsigned int i = 0; i < segmentOrtho->GetNumberOfPoints(); ++i) { segmentOrtho->GetPoint(i, &pRight); outfile << " Right Angle found in point : " << pRight << std::endl; /** Example To extract The coordinate of the segment (Just for example)*/ segmentOrtho->GetPointData(i, &outputVectorLines); outputLinesList->push_back(outputVectorLines[0]); outputLinesList->push_back(outputVectorLines[1]); } outfile.close(); return EXIT_SUCCESS; } otbLineSpatialObjectListToRightAnglePointSetFilterNew.cxx000066400000000000000000000026471301006202600337610ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Corner/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLineSpatialObjectListToRightAnglePointSetFilter.h" #include "otbImage.h" #include "otbLineSpatialObjectList.h" int otbLineSpatialObjectListToRightAnglePointSetFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float PixelType; /** Typedefs */ typedef otb::Image ImageType; typedef otb::LineSpatialObjectList LinesListType; typedef LinesListType::LineType LineType; typedef std::vector VectorLines; typedef itk::PointSet PointSetType; typedef otb::LineSpatialObjectListToRightAnglePointSetFilter RightAngleFilterType; RightAngleFilterType::Pointer filter = RightAngleFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Corner/test/otbVectorDataToRightAngleVectorDataFilter.cxx000066400000000000000000000045211301006202600315120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataToRightAngleVectorDataFilter.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImage.h" #include "otbImageFileWriter.h" int otbVectorDataToRightAngleVectorDataFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { /** Typedefs */ typedef otb::VectorData< > VectorDataType; typedef otb::VectorDataToRightAngleVectorDataFilter RightAngleFilterType; RightAngleFilterType::Pointer filter = RightAngleFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbVectorDataToRightAngleVectorDataFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; /** Typedefs */ typedef otb::VectorData< > VectorDataType; typedef otb::VectorDataToRightAngleVectorDataFilter RightAngleFilterType; typedef otb::VectorDataFileReader vDataReaderType; typedef otb::VectorDataFileWriter vDataWriterType; // Create instances vDataReaderType::Pointer vDataReader = vDataReaderType::New(); RightAngleFilterType::Pointer rightAngleFilter = RightAngleFilterType::New(); vDataWriterType::Pointer vDataWriter = vDataWriterType::New(); // Begin the process vDataReader->SetFileName(infname); rightAngleFilter->SetInput(vDataReader->GetOutput()); rightAngleFilter->SetDistanceThreshold(10.0); rightAngleFilter->SetAngleThreshold(3.141592/18.0); vDataWriter->SetFileName(outfname); vDataWriter->SetInput(rightAngleFilter->GetOutput()); vDataWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/000077500000000000000000000000001301006202600200405ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Density/CMakeLists.txt000066400000000000000000000000461301006202600226000ustar00rootroot00000000000000project(OTBDensity) otb_module_impl() OTB-release-5.8/Modules/Feature/Density/include/000077500000000000000000000000001301006202600214635ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Density/include/otbKeyPointDensityImageFilter.h000066400000000000000000000102261301006202600275550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKeyPointDensityImageFilter_h #define otbKeyPointDensityImageFilter_h #include "itkImageToImageFilter.h" #include "otbPointSetToDensityImageFilter.h" #include "itkNumericTraits.h" namespace otb { /** \class KeyPointDensityImageFilter * \brief This class computes the density of the characteristic * points detected in the image. * * The density computed is a ratio of the number of keypoints over * the total number of pixels within a region. * It uses the class PointSetToDensityImageFilter to do so. * * This class use the key point detector specified in the 3rd argument * template to detect the keypoints. Then for every pixel, the density of the key points * within its neighborhood is computed. * * The output is a map of key points density. * * \ingroup OTBDensity */ template class ITK_EXPORT KeyPointDensityImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef KeyPointDensityImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(KeyPointDensityImageFilter, itk::ImageToImageFilter); /** Template parameters typedefs*/ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; /** OutputImageType typedef support*/ typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; /** Detector typedef Support*/ typedef TDetector DetectorType; typedef typename DetectorType::OutputPointSetType PointSetType; typedef typename DetectorType::Pointer DetectorPointerType; /** PointSetToDensityImageFilter support*/ typedef otb::PointSetToDensityImageFilter PointSetToDensityImageType; typedef typename PointSetToDensityImageType::Pointer PointSetToDensityImagePointerType; /** Get/Set the radius of the neighborhood over which the statistics are evaluated */ itkSetMacro(NeighborhoodRadius, unsigned int); itkGetConstReferenceMacro(NeighborhoodRadius, unsigned int); /**Set/Get Descriptor from the otbCountmageFunction*/ virtual void SetDetector(DetectorType* detector); virtual DetectorType* GetDetector(); protected: /** * Constructor. */ KeyPointDensityImageFilter(); /** * Destructor. */ ~KeyPointDensityImageFilter() ITK_OVERRIDE; /** * Standard PrintSelf method. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Main computation method. */ //virtual void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ); void GenerateData() ITK_OVERRIDE; private: KeyPointDensityImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented DetectorPointerType m_Detector; PointSetToDensityImagePointerType m_PointSetToDensityImageFilter; unsigned int m_NeighborhoodRadius; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbKeyPointDensityImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Density/include/otbKeyPointDensityImageFilter.txx000066400000000000000000000072711301006202600301570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKeyPointDensityImageFilter_txx #define otbKeyPointDensityImageFilter_txx #include "otbKeyPointDensityImageFilter.h" #include "itkImageRegionIterator.h" namespace otb { /**--------------------------------------------------------- * Constructor ----------------------------------------------------------*/ template KeyPointDensityImageFilter ::KeyPointDensityImageFilter() { this->SetNumberOfRequiredInputs(1); m_NeighborhoodRadius = 1; m_Detector = DetectorType::New(); m_PointSetToDensityImageFilter = PointSetToDensityImageType::New(); } /*--------------------------------------------------------- * Destructor.c ----------------------------------------------------------*/ template KeyPointDensityImageFilter ::~KeyPointDensityImageFilter() {} /** * threaded Generate Data */ /** * GenerateData Performs the pixel-wise addition */ template void KeyPointDensityImageFilter ::GenerateData() //::GenerateData( const OutputImageRegionType &outputRegionForThread, itk::ThreadIdType threadId ) { typename Superclass::OutputImagePointer outputImage = this->GetOutput(); InputImagePointerType ptr = const_cast(this->GetInput()); if (!ptr) return; /** Detector*/ m_Detector->SetInput(ptr); /** Applying the pointsetTodensityImageFilter*/ m_PointSetToDensityImageFilter->SetInput(m_Detector->GetOutput()); m_PointSetToDensityImageFilter->SetRadius(m_NeighborhoodRadius); m_PointSetToDensityImageFilter->SetSpacing(ptr->GetSpacing()); m_PointSetToDensityImageFilter->SetSize(ptr->GetLargestPossibleRegion().GetSize()); m_PointSetToDensityImageFilter->SetOrigin(ptr->GetOrigin()); m_PointSetToDensityImageFilter->Update(); /** updating the output*/ this->GraftOutput(m_PointSetToDensityImageFilter->GetOutput()); } /** * Set Detector */ template void KeyPointDensityImageFilter ::SetDetector(DetectorType* detector) { m_Detector = detector; } /** * Get Detector */ template typename KeyPointDensityImageFilter ::DetectorType * KeyPointDensityImageFilter ::GetDetector() { return m_Detector; } /*---------------------------------------------------------------- PrintSelf -----------------------------------------------------------------*/ template void KeyPointDensityImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Neighborhood Radius " << m_NeighborhoodRadius << std::endl; } } /** end namesapce otb*/ #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetDensityEpanechnikovFunction.h000066400000000000000000000050011301006202600315030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetDensityEpanechnikovFunction_h #define otbPointSetDensityEpanechnikovFunction_h #include "otbPointSetFunction.h" #include "itkPoint.h" namespace otb { /** * \class PointSetDensityEpanechnikovFunction * \brief Calculate the density in the neighborhood of a pixel using an Epanechnikov function * * * \ingroup PointSetFunctions * * \ingroup OTBDensity */ template class ITK_EXPORT PointSetDensityEpanechnikovFunction : public PointSetFunction { public: /** Standard class typedefs. */ typedef PointSetDensityEpanechnikovFunction Self; typedef PointSetFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(PointSetDensityEpanechnikovFunction, PointSetFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** PointSet Type typedef Support*/ typedef TPointSet PointSetType; typedef typename Superclass::InputType InputType; typedef typename PointSetType::Pointer PointSetPointerType; /** TOutput typedef support*/ typedef TOutput OutputType; /** Set/Get the number of scales*/ itkSetMacro(Radius, unsigned int); itkGetMacro(Radius, unsigned int); /** Evaluate Method */ OutputType Evaluate(const InputType& input) const ITK_OVERRIDE; protected: PointSetDensityEpanechnikovFunction() : m_Radius(1) {}; ~PointSetDensityEpanechnikovFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PointSetDensityEpanechnikovFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Radius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetDensityEpanechnikovFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetDensityEpanechnikovFunction.txx000066400000000000000000000035271301006202600321120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetDensityEpanechnikovFunction_txx #define otbPointSetDensityEpanechnikovFunction_txx #include "otbPointSetDensityEpanechnikovFunction.h" #include "otbMath.h" namespace otb { /** * Evaluate */ template typename PointSetDensityEpanechnikovFunction ::OutputType PointSetDensityEpanechnikovFunction ::Evaluate(const InputType& input) const { double accu = 0; double radiussq = m_Radius * m_Radius; if (this->GetPointSet()->GetNumberOfPoints() != 0) { typedef typename TPointSet::PointsContainer::ConstIterator iteratorType; iteratorType it = this->GetPointSet()->GetPoints()->Begin(); while (it != this->GetPointSet()->GetPoints()->End()) { float distX = input[0] - it.Value()[0]; float distY = input[1] - it.Value()[1]; float distsq = distX * distX + distY * distY; if (distsq < radiussq) { accu += 0.75 * (1 - distsq / radiussq); } ++it; } } return accu; } /** * PrintSelf */ template void PointSetDensityEpanechnikovFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetDensityFunction.h000066400000000000000000000045761301006202600271700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetDensityFunction_h #define otbPointSetDensityFunction_h #include "otbPointSetFunction.h" namespace otb { /** * \class PointSetDensityFunction * \brief Calculate the density in the neighborhood of a pixel using a simple cut off method * * * \ingroup PointSetFunctions * * \ingroup OTBDensity */ template class ITK_EXPORT PointSetDensityFunction : public PointSetFunction { public: /** Standard class typedefs. */ typedef PointSetDensityFunction Self; typedef PointSetFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(PointSetDensityFunction, PointSetFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** PointSet Type typedef Support*/ typedef TPointSet PointSetType; typedef typename Superclass::InputType InputType; typedef typename PointSetType::Pointer PointSetPointerType; /** TOutput typedef support*/ typedef TOutput OutputType; /** Set/Get the number of scales*/ itkSetMacro(Radius, unsigned int); itkGetMacro(Radius, unsigned int); /** Evaluate Method */ OutputType Evaluate(const InputType& input) const ITK_OVERRIDE; protected: PointSetDensityFunction() : m_Radius(1) {}; ~PointSetDensityFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PointSetDensityFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Radius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetDensityFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetDensityFunction.txx000066400000000000000000000034441301006202600275550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetDensityFunction_txx #define otbPointSetDensityFunction_txx #include "otbPointSetDensityFunction.h" #include "otbMath.h" namespace otb { /** * Evaluate */ template typename PointSetDensityFunction ::OutputType PointSetDensityFunction ::Evaluate(const InputType& input) const { int accu = 0; double surface = CONST_PI * m_Radius * m_Radius; if (this->GetPointSet()->GetNumberOfPoints() != 0) { typedef typename TPointSet::PointsContainer::ConstIterator iteratorType; iteratorType it = this->GetPointSet()->GetPoints()->Begin(); while (it != this->GetPointSet()->GetPoints()->End()) { float distX = input[0] - it.Value()[0]; float distY = input[1] - it.Value()[1]; float distsq = distX * distX + distY * distY; if (distsq <= m_Radius * m_Radius) { accu++; } ++it; } } return static_cast(accu / surface); } /** * PrintSelf */ template void PointSetDensityFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetDensityGaussianFunction.h000066400000000000000000000047301301006202600306530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetDensityGaussianFunction_h #define otbPointSetDensityGaussianFunction_h #include "otbPointSetFunction.h" #include "itkPoint.h" namespace otb { /** * \class PointSetDensityGaussianFunction * \brief Calculate the density in the neighborhood of a pixel using a gaussian function * * * \ingroup PointSetFunctions * * \ingroup OTBDensity */ template class ITK_EXPORT PointSetDensityGaussianFunction : public PointSetFunction { public: /** Standard class typedefs. */ typedef PointSetDensityGaussianFunction Self; typedef PointSetFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(PointSetDensityGaussianFunction, PointSetFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** PointSet Type typedef Support*/ typedef TPointSet PointSetType; typedef typename Superclass::InputType InputType; typedef typename PointSetType::Pointer PointSetPointerType; /** TOutput typedef support*/ typedef TOutput OutputType; /** Set/Get the number of scales*/ itkSetMacro(Radius, unsigned int); itkGetMacro(Radius, unsigned int); /** Evaluate Method */ OutputType Evaluate(const InputType& input) const ITK_OVERRIDE; protected: PointSetDensityGaussianFunction() : m_Radius(1) {}; ~PointSetDensityGaussianFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PointSetDensityGaussianFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Radius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetDensityGaussianFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetDensityGaussianFunction.txx000066400000000000000000000034751301006202600312540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetDensityGaussianFunction_txx #define otbPointSetDensityGaussianFunction_txx #include "otbPointSetDensityGaussianFunction.h" #include "otbMath.h" namespace otb { /** * Evaluate */ template typename PointSetDensityGaussianFunction ::OutputType PointSetDensityGaussianFunction ::Evaluate(const InputType& input) const { double accu = 0; double radiussq = m_Radius * m_Radius; if (this->GetPointSet()->GetNumberOfPoints() != 0) { typedef typename TPointSet::PointsContainer::ConstIterator iteratorType; iteratorType it = this->GetPointSet()->GetPoints()->Begin(); while (it != this->GetPointSet()->GetPoints()->End()) { float distX = input[0] - it.Value()[0]; float distY = input[1] - it.Value()[1]; float distsq = distX * distX + distY * distY; accu += vcl_exp(-distsq / radiussq / 2); ++it; } accu /= vcl_sqrt(2 * CONST_PI * radiussq); } return accu; } /** * PrintSelf */ template void PointSetDensityGaussianFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetToDensityImageFilter.h000066400000000000000000000067361301006202600300760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetToDensityImageFilter_h #define otbPointSetToDensityImageFilter_h #include "itkProcessObject.h" #include "itkPointSet.h" #include "itkPointSetToImageFilter.h" #include "otbPointSetDensityFunction.h" #include "itkPoint.h" namespace otb { /** \class PointSetToDensityImageFilter * \brief Draw the density of a point set on an image * * \ingroup OTBDensity */ template > class ITK_EXPORT PointSetToDensityImageFilter : public itk::PointSetToImageFilter { public: /** Standard class typedefs. */ typedef PointSetToDensityImageFilter Self; typedef itk::PointSetToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PointSetToDensityImageFilter, itk::PointSetToImageFilter); /** typedefs parameters support */ typedef TInputPointSet PointSetType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType PixelType; typedef typename OutputImageType::IndexType IndexType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** typedef filter support*/ typedef TDensityFunction PointSetDensityFunctionType; typedef typename PointSetDensityFunctionType::InputType InputType; typedef typename PointSetDensityFunctionType::Pointer PointSetDensityFunctionPointerType; /** Set/Get Radius*/ itkGetMacro(Radius, unsigned int); itkSetMacro(Radius, unsigned int); protected: /** * Constructor. */ PointSetToDensityImageFilter(); /** * Destructor. */ ~PointSetToDensityImageFilter() ITK_OVERRIDE {} /** * Standard PrintSelf method. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Call the ImageSource::GenerateData which handle multithreading */ void GenerateData() ITK_OVERRIDE; /** * Main computation method. */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Main computation method. */ void GenerateOutputInformation() ITK_OVERRIDE; private: PointSetToDensityImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Radius; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetToDensityImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Density/include/otbPointSetToDensityImageFilter.txx000066400000000000000000000102441301006202600304570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetToDensityImageFilter_txx #define otbPointSetToDensityImageFilter_txx #include "otbPointSetToDensityImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /**--------------------------------------------------------- * Constructor ----------------------------------------------------------*/ template PointSetToDensityImageFilter ::PointSetToDensityImageFilter() { m_Radius = 1; } /*------------------------------------------------------- * GenerateData --------------------------------------------------------*/ template void PointSetToDensityImageFilter ::GenerateData(void) { //Call the GenerateData() from itk::ImageSource which allow threading Superclass::Superclass::GenerateData(); } /*------------------------------------------------------- * ThreadedGenerateData --------------------------------------------------------*/ template void PointSetToDensityImageFilter ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // sleep(threadId); // std::cerr << threadId << " -> " << outputRegionForThread.GetIndex() << std::endl; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); typename OutputImageType::Pointer outPtr = this->GetOutput(); PointSetDensityFunctionPointerType densityComputeFunction = PointSetDensityFunctionType::New(); densityComputeFunction->SetPointSet(this->GetInput()); densityComputeFunction->SetRadius(m_Radius); /** Point*/ InputType pCenter; IndexType index; itk::ImageRegionIterator itOut(outPtr, outputRegionForThread); itOut.GoToBegin(); while (!itOut.IsAtEnd()) { index = itOut.GetIndex(); outPtr->TransformIndexToPhysicalPoint(index, pCenter); itOut.Set(densityComputeFunction->Evaluate(pCenter)); ++itOut; progress.CompletedPixel(); } } /*---------------------------------------------------------------- GenerateOutputInformation -----------------------------------------------------------------*/ template void PointSetToDensityImageFilter ::GenerateOutputInformation(void) { //Superclass::GenerateOutputInformation(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!outputPtr) { return; } typename OutputImageType::RegionType region; IndexType start; start.Fill(0); region.SetSize(this->GetSize()); region.SetIndex(start); outputPtr->SetOrigin(this->GetOrigin()); outputPtr->SetSpacing(this->GetSpacing()); outputPtr->SetRegions(region); } /*---------------------------------------------------------------- PrintSelf -----------------------------------------------------------------*/ template void PointSetToDensityImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/Feature/Density/otb-module.cmake000066400000000000000000000011201301006202600231030ustar00rootroot00000000000000set(DOCUMENTATION "This module contains tools to computes a local density of keypoints (SIFT or SURF, for instance). Many estimators are implemented (Epanechnikov / simple cut off / gaussian function, ratio of the number of keypoints over the total number of pixels within a region). Note that the estimated density can be represented as an image or quiered at particular points (function).") otb_module(OTBDensity DEPENDS OTBPointSet OTBCommon OTBITK TEST_DEPENDS OTBDescriptors OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Feature/Density/test/000077500000000000000000000000001301006202600210175ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Density/test/CMakeLists.txt000066400000000000000000000057751301006202600235750ustar00rootroot00000000000000otb_module_test() set(OTBDensityTests otbDensityTestDriver.cxx otbPointSetDensityFunctionNew.cxx otbPointSetDensityGaussianFunctionNew.cxx otbPointSetToDensityImageFilterNew.cxx otbPointSetDensityGaussianFunctionTest.cxx otbPointSetDensityEpanechnikovFunctionNew.cxx otbPointSetDensityEpanechnikovFunctionTest.cxx otbKeyPointDensityImageFilterTest.cxx otbKeyPointDensityImageFilterNew.cxx otbPointSetToDensityImageFilterTest.cxx otbPointSetDensityFunctionTest.cxx ) add_executable(otbDensityTestDriver ${OTBDensityTests}) target_link_libraries(otbDensityTestDriver ${OTBDensity-Test_LIBRARIES}) otb_module_target_label(otbDensityTestDriver) # Tests Declaration otb_add_test(NAME bfTuPointSetDensityFunctionNew COMMAND otbDensityTestDriver otbPointSetDensityFunctionNew ) otb_add_test(NAME bfTuPointSetDensityGaussianFunctionNew COMMAND otbDensityTestDriver otbPointSetDensityGaussianFunctionNew ) otb_add_test(NAME bfTuPointSetToDensityImageFilterNew COMMAND otbDensityTestDriver otbPointSetToDensityImageFilterNew) otb_add_test(NAME bfTvPointSetDensityGaussianFunctionTest COMMAND otbDensityTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvPointSetDensityGaussianFunctionOutputAscii.txt ${TEMP}/bfTvPointSetDensityGaussianFunctionOutputAscii.txt otbPointSetDensityGaussianFunctionTest ${TEMP}/bfTvPointSetDensityGaussianFunctionOutputAscii.txt ) otb_add_test(NAME bfTuPointSetDensityEpanechnikovFunctionNew COMMAND otbDensityTestDriver otbPointSetDensityEpanechnikovFunctionNew ) otb_add_test(NAME bfTvPointSetDensityEpanechnikovFunctionTest COMMAND otbDensityTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvPointSetDensityEpanechnikovFunctionOutputAscii.txt ${TEMP}/bfTvPointSetDensityEpanechnikovFunctionOutputAscii.txt otbPointSetDensityEpanechnikovFunctionTest ${TEMP}/bfTvPointSetDensityEpanechnikovFunctionOutputAscii.txt ) otb_add_test(NAME bfTvKeyPointDensityImageFilterOutputImage COMMAND otbDensityTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvKeyPointDensityImageFilterOutputImage.tif ${TEMP}/bfTvKeyPointDensityImageFilterOutputImage.tif otbKeyPointDensityImageFilterTest ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvKeyPointDensityImageFilterOutputImage.tif 3 5 10 ) otb_add_test(NAME bfTuKeyPointDensityImageFilterNew COMMAND otbDensityTestDriver otbKeyPointDensityImageFilterNew ) otb_add_test(NAME bfTvPointSetToDensityImageFilterTest COMMAND otbDensityTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvPointSetToDensityImageFilterOutputImage.tif ${TEMP}/bfTvPointSetToDensityImageFilterOutputImage.tif otbPointSetToDensityImageFilterTest ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvPointSetToDensityImageFilterOutputImage.tif 3 5 10 ) otb_add_test(NAME bfTvPointSetDensityFunctionTest COMMAND otbDensityTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvPointSetDensityFunctionOutputAscii.txt ${TEMP}/bfTvPointSetDensityFunctionOutputAscii.txt otbPointSetDensityFunctionTest ${TEMP}/bfTvPointSetDensityFunctionOutputAscii.txt ) OTB-release-5.8/Modules/Feature/Density/test/otbDensityTestDriver.cxx000066400000000000000000000011171301006202600257030ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbPointSetDensityFunctionNew); REGISTER_TEST(otbPointSetDensityGaussianFunctionNew); REGISTER_TEST(otbPointSetToDensityImageFilterNew); REGISTER_TEST(otbPointSetDensityGaussianFunctionTest); REGISTER_TEST(otbPointSetDensityEpanechnikovFunctionNew); REGISTER_TEST(otbPointSetDensityEpanechnikovFunctionTest); REGISTER_TEST(otbKeyPointDensityImageFilterTest); REGISTER_TEST(otbKeyPointDensityImageFilterNew); REGISTER_TEST(otbPointSetToDensityImageFilterTest); REGISTER_TEST(otbPointSetDensityFunctionTest); } OTB-release-5.8/Modules/Feature/Density/test/otbKeyPointDensityImageFilterNew.cxx000066400000000000000000000026541301006202600301440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbKeyPointDensityImageFilter.h" #include "otbImageToSIFTKeyPointSetFilter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "otbImage.h" int otbKeyPointDensityImageFilterNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter DetectorType; typedef otb::KeyPointDensityImageFilter FilterType; /**Instantiation of an object*/ FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbKeyPointDensityImageFilterTest.cxx000066400000000000000000000046471301006202600303360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbKeyPointDensityImageFilter.h" #include "otbImageToSIFTKeyPointSetFilter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbKeyPointDensityImageFilterTest(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int scales = atoi(argv[3]); const unsigned int octaves = atoi(argv[4]); const unsigned int radius = atoi(argv[5]); const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter DetectorType; typedef otb::KeyPointDensityImageFilter FilterType; /**Instantiation of an object*/ FilterType::Pointer filter = FilterType::New(); DetectorType::Pointer detector = DetectorType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); filter->SetInput(reader->GetOutput()); detector = filter->GetDetector(); detector->SetOctavesNumber(octaves); detector->SetScalesNumber(scales); filter->SetDetector(detector); filter->SetNeighborhoodRadius(radius); /** Writing the densty Image*/ WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetDensityEpanechnikovFunctionNew.cxx000066400000000000000000000023561301006202600320760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbPointSetDensityEpanechnikovFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" int otbPointSetDensityEpanechnikovFunctionNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::PointSetDensityEpanechnikovFunction FunctionType; /**Instantiation of a Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetDensityEpanechnikovFunctionTest.cxx000066400000000000000000000041461301006202600322630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbPointSetDensityEpanechnikovFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include int otbPointSetDensityEpanechnikovFunctionTest(int itkNotUsed(argc), char* argv[]) { const char * outfname = argv[1]; const unsigned int Dimension = 2; typedef float PixelType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::PointSetDensityEpanechnikovFunction FunctionType; /**Instantiation of a Smart Pointer*/ PointSetType::Pointer pointSet = PointSetType::New(); FunctionType::Pointer filter = FunctionType::New(); std::ofstream outfile(outfname); /** Construction of the pointSet */ PointSetType::PointIdentifier count = 0; PointSetType::PointType pDst, pSrc; pDst[0] = 12.78; pDst[1] = 18.76; pointSet->SetPoint(count++, pDst); pDst[0] = 15.78; pDst[1] = 23.76; pointSet->SetPoint(count++, pDst); pDst[0] = 9.78; pDst[1] = 5.76; pointSet->SetPoint(count++, pDst); filter->SetPointSet(pointSet); filter->SetRadius(2); /**Point we search around*/ pDst[0] = 14.9; pDst[1] = 24; outfile << "Density computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; pDst[0] = 9; pDst[1] = 5; outfile << "Density computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetDensityFunctionNew.cxx000066400000000000000000000022621301006202600275370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbPointSetDensityFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" int otbPointSetDensityFunctionNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::PointSetDensityFunction FunctionType; /**Instantiation of a Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetDensityFunctionTest.cxx000066400000000000000000000040521301006202600277240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbPointSetDensityFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include int otbPointSetDensityFunctionTest(int itkNotUsed(argc), char* argv[]) { const char * outfname = argv[1]; const unsigned int Dimension = 2; typedef float PixelType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::PointSetDensityFunction FunctionType; /**Instantiation of a Smart Pointer*/ PointSetType::Pointer pointSet = PointSetType::New(); FunctionType::Pointer filter = FunctionType::New(); std::ofstream outfile(outfname); /** Construction of the pointSet */ PointSetType::PointIdentifier count = 0; PointSetType::PointType pDst, pSrc; pDst[0] = 12.78; pDst[1] = 18.76; pointSet->SetPoint(count++, pDst); pDst[0] = 15.78; pDst[1] = 23.76; pointSet->SetPoint(count++, pDst); pDst[0] = 9.78; pDst[1] = 5.76; pointSet->SetPoint(count++, pDst); filter->SetPointSet(pointSet); filter->SetRadius(2); /**Point we search around*/ pDst[0] = 14.9; pDst[1] = 24; outfile << "Density computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; pDst[0] = 9; pDst[1] = 5; outfile << "Density computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetDensityGaussianFunctionNew.cxx000066400000000000000000000023321301006202600312300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbPointSetDensityGaussianFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" int otbPointSetDensityGaussianFunctionNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::PointSetDensityGaussianFunction FunctionType; /**Instantiation of a Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetDensityGaussianFunctionTest.cxx000066400000000000000000000041221301006202600314150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbPointSetDensityGaussianFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include int otbPointSetDensityGaussianFunctionTest(int itkNotUsed(argc), char* argv[]) { const char * outfname = argv[1]; const unsigned int Dimension = 2; typedef float PixelType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::PointSetDensityGaussianFunction FunctionType; /**Instantiation of a Smart Pointer*/ PointSetType::Pointer pointSet = PointSetType::New(); FunctionType::Pointer filter = FunctionType::New(); std::ofstream outfile(outfname); /** Construction of the pointSet */ PointSetType::PointIdentifier count = 0; PointSetType::PointType pDst, pSrc; pDst[0] = 12.78; pDst[1] = 18.76; pointSet->SetPoint(count++, pDst); pDst[0] = 15.78; pDst[1] = 23.76; pointSet->SetPoint(count++, pDst); pDst[0] = 9.78; pDst[1] = 5.76; pointSet->SetPoint(count++, pDst); filter->SetPointSet(pointSet); filter->SetRadius(2); /**Point we search around*/ pDst[0] = 14.9; pDst[1] = 24; outfile << "Density computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; pDst[0] = 9; pDst[1] = 5; outfile << "Density computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetToDensityImageFilterNew.cxx000066400000000000000000000024231301006202600304440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbPointSetToDensityImageFilter.h" #include "itkVariableLengthVector.h" int otbPointSetToDensityImageFilterNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::PointSetToDensityImageFilter FunctionType; /**Instantiation of an object*/ FunctionType::Pointer filter = FunctionType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Density/test/otbPointSetToDensityImageFilterTest.cxx000066400000000000000000000051161301006202600306340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbPointSetToDensityImageFilter.h" #include "itkVariableLengthVector.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageToSIFTKeyPointSetFilter.h" int otbPointSetToDensityImageFilterTest(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int scales = atoi(argv[3]); const unsigned int octaves = atoi(argv[4]); const unsigned int radius = atoi(argv[5]); const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter DetectorType; typedef otb::PointSetToDensityImageFilter FunctionType; /**Instantiation of an object*/ FunctionType::Pointer filter = FunctionType::New(); DetectorType::Pointer detector = DetectorType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); detector->SetInput(reader->GetOutput()); detector->SetOctavesNumber(octaves); detector->SetScalesNumber(scales); /** PointSetImageToDensity ImageFilter*/ filter->SetInput(detector->GetOutput()); filter->SetRadius(radius); filter->SetSpacing(reader->GetOutput()->GetSpacing()); filter->SetSize(reader->GetOutput()->GetLargestPossibleRegion().GetSize()); filter->SetOrigin(reader->GetOutput()->GetOrigin()); /** Writing the densty Image*/ WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/000077500000000000000000000000001301006202600207225ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/CMakeLists.txt000066400000000000000000000000521301006202600234570ustar00rootroot00000000000000project(OTBDescriptors) otb_module_impl() OTB-release-5.8/Modules/Feature/Descriptors/include/000077500000000000000000000000001301006202600223455ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/include/otbForwardFourierMellinTransformImageFilter.h000066400000000000000000000144051301006202600333350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbForwardFourierMellinTransformImageFilter_h #define otbForwardFourierMellinTransformImageFilter_h #include "otbImage.h" #include "itkForwardFFTImageFilter.h" #include "otbLogPolarTransform.h" #include "itkResampleImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" namespace otb { /** * \class ForwardFourierMellinTransformImageFilter * \brief Calculate the Fourier-Mellin transform over an image. * * This class implements a composite filter. It combines two filters : * - otb::LogPolarResampleImageFilter : converting the input image in a log-polar system coordinate * - itk::ForwardFFTImageFilter : applying the Forward Fourier transform of the log-polar image. * * \note the Fourier transform image is coded from 0.0 to 1.0 * * \ingroup ImageFunctions * * \ingroup OTBDescriptors */ template class ITK_EXPORT ForwardFourierMellinTransformImageFilter : public itk::ImageToImageFilter, itk::Image, Dimension> > { public: //typedef TPixel PixelType; typedef Image InputImageType; /* typedef otb::Image< std::complex< TPixel > , Dimension > OutputImageType; */ typedef typename itk::ForwardFFTImageFilter FourierImageFilterType; typedef typename FourierImageFilterType::OutputImageType OutputImageType; /** Standard class typedefs. */ typedef ForwardFourierMellinTransformImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ForwardFourierMellinTransformImageFilter, itk::ImageToImageFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::Pointer ImagePointer; typedef typename InputImageType::ConstPointer ImageConstPointer; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::SpacingType SpacingType; /** InputImageType typedef support. */ typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType ComplexType; /** Typedefs to describe and access Interpolator */ typedef TInterpol InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointerType; typedef typename InterpolatorType::ConstPointer InterpolatorConstPointerType; typedef typename InterpolatorType::CoordRepType CoordRepType; typedef typename InterpolatorType::PointType PointType; typedef LogPolarTransform LogPolarTransformType; typedef typename LogPolarTransformType::Pointer LogPolarTransformPointerType; typedef itk::ResampleImageFilter ResampleFilterType; typedef typename ResampleFilterType::Pointer ResampleFilterPointerType; typedef itk::ImageRegionIteratorWithIndex IteratorType; typedef typename FourierImageFilterType::Pointer FourierImageFilterPointer; typedef typename FourierImageFilterType::ConstPointer FourierImageFilterConstPointer; /** Set/Get the output size of the transform (should be powers of two in both directions */ itkSetMacro(OutputSize, OutputSizeType); itkGetMacro(OutputSize, OutputSizeType); /** Set/Get the Sigma value for the Log-polar resampler */ itkSetMacro(Sigma, double); itkGetMacro(Sigma, double); /** Set/Get the Default pixel value for the Log-polar resampler */ itkSetMacro(DefaultPixelValue, PixelType); itkGetMacro(DefaultPixelValue, PixelType); /** Set/Get the Interpolator pointer for the Log-polar resampler */ itkSetObjectMacro(Interpolator, InterpolatorType); itkGetObjectMacro(Interpolator, InterpolatorType); protected: ForwardFourierMellinTransformImageFilter(); ~ForwardFourierMellinTransformImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Main Computation Method */ void GenerateData() ITK_OVERRIDE; private: ForwardFourierMellinTransformImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Sigma for normalization */ double m_Sigma; /** Output size */ OutputSizeType m_OutputSize; /** Output pixel default value */ PixelType m_DefaultPixelValue; /** Interpolator */ InterpolatorPointerType m_Interpolator; /** Transform */ LogPolarTransformPointerType m_Transform; /** Resampler */ ResampleFilterPointerType m_ResampleFilter; /** FFT Filter */ FourierImageFilterPointer m_FFTFilter; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbForwardFourierMellinTransformImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbForwardFourierMellinTransformImageFilter.txx000066400000000000000000000130241301006202600337250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbForwardFourierMellinTransformImageFilter_txx #define otbForwardFourierMellinTransformImageFilter_txx #include "otbForwardFourierMellinTransformImageFilter.h" #include "itkImageDuplicator.h" namespace otb { template ForwardFourierMellinTransformImageFilter ::ForwardFourierMellinTransformImageFilter() { m_Sigma = 1.0; m_OutputSize.Fill(512); m_FFTFilter = FourierImageFilterType::New(); m_Interpolator = InterpolatorType::New(); m_Transform = LogPolarTransformType::New(); m_ResampleFilter = ResampleFilterType::New(); m_ResampleFilter->SetInterpolator(m_Interpolator); m_ResampleFilter->SetTransform(m_Transform); m_DefaultPixelValue = 0; } template void ForwardFourierMellinTransformImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); OutputImagePointer outputPtr = this->GetOutput(); if (!outputPtr) { return; } typename OutputImageType::RegionType largestPossibleRegion; typename OutputImageType::IndexType index; index.Fill(0); largestPossibleRegion.SetIndex(index); largestPossibleRegion.SetSize(m_OutputSize); outputPtr->SetLargestPossibleRegion(largestPossibleRegion); } template void ForwardFourierMellinTransformImageFilter ::GenerateInputRequestedRegion(void) { ImagePointer input = const_cast(this->GetInput()); input->SetRequestedRegion(input->GetLargestPossibleRegion()); } template void ForwardFourierMellinTransformImageFilter ::GenerateData() { typename LogPolarTransformType::ParametersType params(4); // Compute centre of the transform SizeType inputSize = this->GetInput()->GetLargestPossibleRegion().GetSize(); SpacingType inputSpacing = this->GetInput()->GetSpacing(); itk::ContinuousIndex centre; centre[0] = -0.5 + 0.5 * static_cast(inputSize[0]); centre[1] = -0.5 + 0.5 * static_cast(inputSize[1]); PointType centrePt; this->GetInput()->TransformContinuousIndexToPhysicalPoint(centre,centrePt); // Compute physical radius in the input image double radius = vcl_log(vcl_sqrt( vcl_pow(static_cast(inputSize[0])*inputSpacing[0],2.0) + vcl_pow(static_cast(inputSize[1])*inputSpacing[1],2.0)) / 2.0); params[0] = centrePt[0]; params[1] = centrePt[1]; params[2] = 360. / m_OutputSize[0]; params[3] = radius / m_OutputSize[1]; m_Transform->SetParameters(params); // Compute rho scaling parameter in index space double rhoScaleIndex = vcl_log(vcl_sqrt( vcl_pow(static_cast(inputSize[0]),2.0) + vcl_pow(static_cast(inputSize[1]),2.0)) / 2.0) / m_OutputSize[1]; // log polar resampling m_ResampleFilter->SetInput(this->GetInput()); m_ResampleFilter->SetDefaultPixelValue(m_DefaultPixelValue); m_ResampleFilter->SetSize(m_OutputSize); PointType outOrigin; outOrigin.Fill(0.5); m_ResampleFilter->SetOutputOrigin(outOrigin); SpacingType outSpacing; outSpacing.Fill(1.0); m_ResampleFilter->SetOutputSpacing(outSpacing); m_ResampleFilter->Update(); typename InputImageType::Pointer tempImage = m_ResampleFilter->GetOutput(); IteratorType iter(tempImage, tempImage->GetRequestedRegion()); // Min/max values of the output pixel type AND these values // represented as the output type of the interpolator const PixelType minOutputValue = itk::NumericTraits::NonpositiveMin(); const PixelType maxOutputValue = itk::NumericTraits::max(); // Normalization is specific to FourierMellin convergence conditions, and // thus should be implemented here instead of in the resample filter. for (iter.GoToBegin(); !iter.IsAtEnd(); ++iter) { // 0.5 shift in order to follow output image physical space double Rho = (0.5 + static_cast(iter.GetIndex()[1])) * rhoScaleIndex; PixelType pixval; double valueTemp = static_cast(iter.Get()); valueTemp *= vcl_exp(m_Sigma * Rho); valueTemp *= rhoScaleIndex; PixelType value = static_cast(valueTemp); if (value < minOutputValue) { pixval = minOutputValue; } else if (value > maxOutputValue) { pixval = maxOutputValue; } else { pixval = static_cast(value); } iter.Set(pixval); } m_FFTFilter->SetInput(tempImage); m_FFTFilter->GraftOutput(this->GetOutput()); m_FFTFilter->Update(); this->GraftOutput(m_FFTFilter->GetOutput()); } /** * Standard "PrintSelf" method */ template void ForwardFourierMellinTransformImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbFourierMellinDescriptorsImageFunction.h000066400000000000000000000120441301006202600326730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFourierMellinDescriptorsImageFunction_h #define otbFourierMellinDescriptorsImageFunction_h #include "itkImageFunction.h" #include "otbImage.h" #include "otbMath.h" #include namespace otb { /** * \class FourierMellinDescriptorsImageFunction * \brief Calculate the Fourier-Mellin descriptors in the specified * neighborhood. * * Calculate the Fourier-Mellin descriptors over a specified neighborhood. * The implemented equation is: * * D_{p, q}=|M_{p, q}| * * With: * * \f[ M_{p, q}=\frac{1}{2\pi} \int_{-\infty}^{\infty} \int_{-\infty}^{\infty} (x+iy)^{p} \cdot (x^{2}+y^{2})^{\frac{p-2+\sigma-iq}{2}} \cdot f(x, y) \cdot dx \cdot dy \f] * * And: * - \f$(x, y)\f$ pixel localization; * - \f$ f(x, y)\f$ the pixel value over the \f$(x, y)\f$ coordinate. * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double). * * \ingroup ImageFunctions * * \ingroup OTBDescriptors */ template class ITK_EXPORT FourierMellinDescriptorsImageFunction : public itk::ImageFunction ::RealType > >, TCoordRep> { public: /** Standard class typedefs. */ typedef FourierMellinDescriptorsImageFunction Self; typedef itk::ImageFunction::RealType > >, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(FourierMellinDescriptorsImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef double ScalarRealType; typedef typename std::complex ScalarComplexType; typedef typename std::vector< std::vector< ScalarComplexType > > ComplexType; typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); itkSetMacro(Pmax, unsigned int); itkGetConstReferenceMacro(Pmax, unsigned int); itkSetMacro(Qmax, unsigned int); itkGetConstReferenceMacro(Qmax, unsigned int); protected: FourierMellinDescriptorsImageFunction(); ~FourierMellinDescriptorsImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: FourierMellinDescriptorsImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Pmax; unsigned int m_Qmax; unsigned int m_NeighborhoodRadius; double m_Sigma; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFourierMellinDescriptorsImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbFourierMellinDescriptorsImageFunction.txx000066400000000000000000000102201301006202600332610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFourierMellinDescriptorsImageFunction_txx #define otbFourierMellinDescriptorsImageFunction_txx #include "otbFourierMellinDescriptorsImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template FourierMellinDescriptorsImageFunction ::FourierMellinDescriptorsImageFunction() { m_NeighborhoodRadius = 1; m_Pmax = 3; m_Qmax = 3; m_Sigma = 0.5; } template void FourierMellinDescriptorsImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " p indice maximum value : " << m_Pmax << std::endl; os << indent << " q indice maximum value : " << m_Qmax << std::endl; os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; } template typename FourierMellinDescriptorsImageFunction::OutputType FourierMellinDescriptorsImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build Fourier-Mellin Harmonics Matrix ComplexType coefs; coefs.resize(m_Pmax+1); OutputType descriptors; descriptors.resize(m_Pmax+1); // Initialize moments for (unsigned int p = 0; p <= m_Pmax; p++) { coefs.at(p).resize(m_Qmax+1); descriptors.at(p).resize(m_Qmax+1); for (unsigned int q = 0; q <= m_Qmax; q++) { coefs.at(p).at(q) = itk::NumericTraits::Zero; descriptors.at(p).at(q) = itk::NumericTraits::Zero; } } // Check for input image if( !this->GetInputImage() ) { return descriptors; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return descriptors; } // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Walk the neighborhood const unsigned int size = it.Size(); for (unsigned int i = 0; i < size; ++i) { // Retrieve value, and centered-reduced position ScalarRealType value = static_cast(it.GetPixel(i)); ScalarRealType x = static_cast(it.GetOffset(i)[0])/(2*m_NeighborhoodRadius+1); ScalarRealType y = static_cast(it.GetOffset(i)[1])/(2*m_NeighborhoodRadius+1); // Build complex value ScalarComplexType xplusiy(x, y), x2plusy2(x*x+y*y, 0.0); // Update cumulants for (unsigned int p = 0; p <= m_Pmax; p++) { for (unsigned int q= 0; q <= m_Qmax; q++) { ScalarComplexType power(double(p-2.0+m_Sigma)/2.0, -double(q)/2.0); if(x!=0 || y !=0) // vcl_pow limitation { coefs.at(p).at(q) += vcl_pow(xplusiy, -static_cast(p)) * vcl_pow(x2plusy2, power) * value; } } } } // Normalisation for (int p = m_Pmax; p >= 0; p--) { for (int q = m_Qmax; q >= 0; q--) { coefs.at(p).at(q) /= 2*CONST_PI * coefs.at(0).at(0); descriptors.at(p).at(q) = vcl_sqrt((coefs.at(p).at(q).real() * coefs.at(p).at(q).real() + coefs.at(p).at(q).imag() * coefs.at(p).at(q).imag())); } } // Return result return descriptors; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbHessianToScalarImageFilter.h000066400000000000000000000052361301006202600303650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHessianToScalarImageFilter_h #define otbHessianToScalarImageFilter_h #include "itkUnaryFunctorImageFilter.h" namespace otb { /** \class HessianToScalarImageFilter * \brief TODO * * \ingroup OTBDescriptors */ namespace Functor { template class HessianToScalar { public: HessianToScalar() { m_Alpha = 1.0; } virtual ~HessianToScalar() {} inline TOutput operator ()(const TInput& Hessian) { TOutput det; TOutput trace; TOutput result; det = static_cast(Hessian(0, 0) * Hessian(1, 1) - Hessian(0, 1) * Hessian(1, 0)); trace = static_cast(Hessian(0, 0) + Hessian(1, 1)); result = det - (static_cast(m_Alpha) * trace * trace); return result; } void SetAlpha(double Alpha) { m_Alpha = Alpha; } double GetAlpha(void) const { return (m_Alpha); } private: double m_Alpha; }; } template class ITK_EXPORT HessianToScalarImageFilter : public itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, Functor::HessianToScalar< typename TInputImage::PixelType, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef HessianToScalarImageFilter Self; typedef typename itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, Functor::HessianToScalar< typename TInputImage::PixelType, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); void SetAlpha(double Alpha) { this->GetFunctor().SetAlpha(Alpha); this->Modified(); } double GetAlpha(void) const { return (this->GetFunctor().GetAlpha()); } protected: HessianToScalarImageFilter() {} ~HessianToScalarImageFilter() ITK_OVERRIDE {} private: HessianToScalarImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif otbHistogramOfOrientedGradientCovariantImageFunction.h000066400000000000000000000133601301006202600350610ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHistogramOfOrientedGradientCovariantImageFunction_h #define otbHistogramOfOrientedGradientCovariantImageFunction_h #include "itkImageFunction.h" #include "itkFixedArray.h" namespace otb { /** * \class HistogramOfOrientedGradientCovariantImageFunction * \brief Calculate the centered HOG features * * This filter implements the centered histogram of gradient * feature. It expects a gradient covariant image as input, such as * the output of the itk::GradientImageFilter. Steps of the algorithm * are as follows. * * In order to make the C-HOG descriptor rotation-invariant, a * principal gradient orientation is first looked for. Within the * m_NeighborhoodRadius ($r$), an histogram of the local orientation is * computed with m_NumberOfOrientationBins bins. Values cumulated in * this histogram are the gradient magnitude weighted by a gaussian * kernel of $\sigma = 0.5 * r$. * * From this orientation histogram, the principal orientation is * computed by looking for the maximum valued bin. * * Once principal orientation is computed, * gradient magnitude values weighted by the gaussian kernel are * cumulated in five different histograms corresponding to five * distinct spatial areas : the center area (radius of the center area * is computed using $r_{c}=log_{2}(r)$), and the upper-left, * upper-right, lower-left and lower-right radial areas. Orientation * of these radial areas is shifted to match the principal * orientation, and gradient orientations to determine histogram bins * are also compensated with the principal orientation. Last, each * histogram is normalized by its $L_2$ norm, ensuring that they * all lie in the range $[0, 1]$. * * This class is templated over the input image type, the output * precision (e.g. float ou double) and the * coordinate representation type (e.g. float or double). * \ingroup ImageFunctions * * \ingroup OTBDescriptors */ template class ITK_EXPORT HistogramOfOrientedGradientCovariantImageFunction : public itk::ImageFunction< TInputImage, std::vector< std::vector< TOutputPrecision > >, TCoordRep > { public: /** Standard class typedefs. */ typedef HistogramOfOrientedGradientCovariantImageFunction Self; typedef itk::ImageFunction< TInputImage, std::vector >, TCoordRep > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(HistogramOfOrientedGradientCovariantImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef TOutputPrecision OutputPrecisionType; typedef typename Superclass::OutputType OutputType; typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); /** Get/Set the number of bins of the orientation histograms */ itkSetMacro( NumberOfOrientationBins, unsigned int ); itkGetConstReferenceMacro( NumberOfOrientationBins, unsigned int ); protected: HistogramOfOrientedGradientCovariantImageFunction(); ~HistogramOfOrientedGradientCovariantImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: HistogramOfOrientedGradientCovariantImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Radius over which the principal orientation will be computed unsigned int m_NeighborhoodRadius; // Number of bins in the orientation unsigned int m_NumberOfOrientationBins; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHistogramOfOrientedGradientCovariantImageFunction.txx" #endif #endif otbHistogramOfOrientedGradientCovariantImageFunction.txx000066400000000000000000000232621301006202600354570ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHistogramOfOrientedGradientCovariantImageFunction_txx #define otbHistogramOfOrientedGradientCovariantImageFunction_txx #include "otbHistogramOfOrientedGradientCovariantImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" #include "otbMath.h" namespace otb { /** * Constructor */ template HistogramOfOrientedGradientCovariantImageFunction ::HistogramOfOrientedGradientCovariantImageFunction() : m_NeighborhoodRadius(8), m_NumberOfOrientationBins(18) {} template void HistogramOfOrientedGradientCovariantImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; } template typename HistogramOfOrientedGradientCovariantImageFunction::OutputType HistogramOfOrientedGradientCovariantImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build output vector OutputType hog; // Check for input image if( !this->GetInputImage() ) { return hog; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return hog; } // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Offset to be used in the loops typename InputImageType::OffsetType offset; // Compute the center bin radius double centerBinRadius = static_cast(m_NeighborhoodRadius)/2; // Define a gaussian kernel around the center location double squaredRadius = m_NeighborhoodRadius * m_NeighborhoodRadius; double squaredCenterBinRadius = centerBinRadius * centerBinRadius; double squaredSigma = 0.25 * squaredRadius; // Build a global orientation histogram std::vector globalOrientationHistogram(m_NumberOfOrientationBins, 0.); // Compute the orientation bin width double orientationBinWidth = otb::CONST_2PI / m_NumberOfOrientationBins; // Build the global orientation histogram for(int i = -(int)m_NeighborhoodRadius; i< (int)m_NeighborhoodRadius; ++i) { for(int j = -(int)m_NeighborhoodRadius; j< (int)m_NeighborhoodRadius; ++j) { // Check if the current pixel lies within a disc of radius m_NeighborhoodRadius double currentSquaredRadius = i*i+j*j; if(currentSquaredRadius < squaredRadius) { // If so, compute the gaussian weighting (this could be // computed once for all for the sake of optimisation) double gWeight = (1/vcl_sqrt(otb::CONST_2PI*squaredSigma)) * vcl_exp(- currentSquaredRadius/(2*squaredSigma)); // Compute pixel location offset[0]=i; offset[1]=j; // Get the current gradient covariant value InputPixelType gradient = it.GetPixel(offset); // Then, compute the gradient orientation double angle = vcl_atan2(gradient[1], gradient[0]); // Also compute its magnitude TOutputPrecision magnitude = vcl_sqrt(gradient[0]*gradient[0]+gradient[1]*gradient[1]); // Determine the bin index (shift of otb::CONST_PI since atan2 values // lies in [-pi, pi] unsigned int binIndex = vcl_floor((otb::CONST_PI + angle)/orientationBinWidth); // Handle special case where angle = pi, and binIndex is out-of-bound if(binIndex == m_NumberOfOrientationBins) binIndex=m_NumberOfOrientationBins-1; // Cumulate values globalOrientationHistogram[binIndex]+= magnitude * gWeight; } } } // Compute principal orientation // TODO: Replace this with a stl algorithm double maxOrientationHistogramValue = globalOrientationHistogram[0]; unsigned int maxOrientationHistogramBin = 0; for(unsigned int i = 1; i < m_NumberOfOrientationBins; ++i) { // Retrieve current value double currentValue = globalOrientationHistogram[i]; // Look for new maximum if(maxOrientationHistogramValue centerHistogram(m_NumberOfOrientationBins, 0.); std::vector upperLeftHistogram(m_NumberOfOrientationBins, 0.); std::vector upperRightHistogram(m_NumberOfOrientationBins, 0.); std::vector lowerLeftHistogram(m_NumberOfOrientationBins, 0.); std::vector lowerRightHistogram(m_NumberOfOrientationBins, 0.); // Walk the image once more to fill the spatial bins for(int i = -(int)m_NeighborhoodRadius; i< (int)m_NeighborhoodRadius; ++i) { for(int j = -(int)m_NeighborhoodRadius; j< (int)m_NeighborhoodRadius; ++j) { // Check if the current pixel lies within a disc of radius m_NeighborhoodRadius double currentSquaredRadius = i*i+j*j; if(currentSquaredRadius < squaredRadius) { // If so, compute the gaussian weighting (this could be // computed once for all for the sake of optimisation) double gWeight = (1/vcl_sqrt(otb::CONST_2PI * squaredSigma)) * vcl_exp(- currentSquaredRadius/(2*squaredSigma)); // Compute pixel location offset[0]=i; offset[1]=j; // Get the current gradient covariant value InputPixelType gradient = it.GetPixel(offset); // Then, compute the compensated gradient orientation double angle = vcl_atan2(gradient[1], gradient[0]) - principalOrientation; // Angle is supposed to lie with [-pi, pi], so we ensure that // compenstation did not introduce out-of-range values if(angle > otb::CONST_PI) { angle -= otb::CONST_2PI; } else if(angle < -otb::CONST_PI) { angle += otb::CONST_2PI; } // Also compute its magnitude TOutputPrecision magnitude = vcl_sqrt(gradient[0]*gradient[0]+gradient[1]*gradient[1]); // Determine the bin index (shift of otb::CONST_PI since atan2 values // lies in [-pi, pi] unsigned int binIndex = vcl_floor((otb::CONST_PI + angle)/orientationBinWidth); if(binIndex == m_NumberOfOrientationBins) binIndex=m_NumberOfOrientationBins-1; // Compute the angular position double angularPosition = vcl_atan2((double)j, (double)i) - principalOrientation; // Angle is supposed to lie within [-pi, pi], so we ensure that // the compensation did not introduce out-of-range values if(angularPosition > otb::CONST_PI) { angularPosition -= otb::CONST_2PI; } else if(angularPosition < -otb::CONST_PI) { angularPosition += otb::CONST_2PI; } // Check if we lie in center bin if(currentSquaredRadius < squaredCenterBinRadius) { centerHistogram[binIndex]+= magnitude * gWeight; } else if(angularPosition > 0) { if(angularPosition < otb::CONST_PI_2) { upperRightHistogram[binIndex]+= magnitude * gWeight; } else { upperLeftHistogram[binIndex]+= magnitude * gWeight; } } else { if(angularPosition > -otb::CONST_PI_2) { lowerRightHistogram[binIndex]+= magnitude * gWeight; } else { lowerLeftHistogram[binIndex]+= magnitude * gWeight; } } // Cumulate values globalOrientationHistogram[binIndex]+= magnitude * gWeight; } } } // Build the final output hog.push_back(centerHistogram); hog.push_back(upperLeftHistogram); hog.push_back(upperRightHistogram); hog.push_back(lowerRightHistogram); hog.push_back(lowerLeftHistogram); // Normalize each histogram for(typename OutputType::iterator oIt = hog.begin(); oIt!=hog.end(); ++oIt) { // Compute L2 norm double squaredCumul = 1e-10; for(typename std::vector::const_iterator vIt = oIt->begin(); vIt!=oIt->end(); ++vIt) { squaredCumul += (*vIt)*(*vIt); } double scale = 1/vcl_sqrt(squaredCumul); // Apply normalisation factor for(typename std::vector::iterator vIt = oIt->begin(); vIt!=oIt->end(); ++vIt) { (*vIt)*=scale; } } // Return result return hog; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbImageToHessianDeterminantImageFilter.h000066400000000000000000000116431301006202600323740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToHessianDeterminantImageFilter_h #define otbImageToHessianDeterminantImageFilter_h #include "itkProcessObject.h" #include "itkImageToImageFilter.h" #include "itkHessianRecursiveGaussianImageFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "otbImage.h" #include "itkFixedArray.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class HessianDeterminant * \brief This functor computes the determinant of symmetric 2*2 matrix . * * A Hessian matrix is symmetric, we compute only the 3 first parameters * The First component is : Dxx * The Second component is : Dyy * The Third component is : Dxy * * \ingroup OTBDescriptors */ template class HessianDeterminant { public: HessianDeterminant() {} virtual ~HessianDeterminant() {} /* * * \param input : A symmetric Hessian Matrix * \return Determinant of the Hessian Matrix */ inline TOutput operator ()(const TInput& input) { return static_cast(input[0] * input[1] - input[2] * input[2]); } bool operator !=(const HessianDeterminant) const { return false; } bool operator ==(const HessianDeterminant& other) const { return !(*this != other); } }; } /** \class ImageToHessianDeterminantImageFilter * \brief This class compute the Hessian determinant of each pixel of an input image * * For an input image, the Hessian matrix of each pixel is computed an then the determinant * of each pixel's matrix is computed. * * \sa itk::HessianRecursiveGaussianImageFilter * * \ingroup OTBDescriptors */ template class ITK_EXPORT ImageToHessianDeterminantImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef ImageToHessianDeterminantImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Set/Get the number of iterations */ itkSetMacro(Sigma, double); itkGetMacro(Sigma, double); /** Run-time type information (and related methods). */ itkTypeMacro(ImageToHessianDeterminantImageFilter, ImageToImageFilter); /* Initialization of Input & Output Images*/ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::PixelType OutputPixelType; typedef itk::FixedArray VectorType; typedef otb::Image VectorImageType; typedef typename VectorImageType::Pointer VectorImagePointerType; /** Internal filters typedefs */ typedef itk::HessianRecursiveGaussianImageFilter ImageToHessianImageFilterType; typedef typename ImageToHessianImageFilterType::Pointer ImageToHessianImageFilterPointerType; typedef Functor::HessianDeterminant DeterminantFunctorType; typedef itk::UnaryFunctorImageFilter DeterminantFilterType; typedef typename DeterminantFilterType::Pointer DeterminantFilterPointerType; protected: /** * Constructor. */ ImageToHessianDeterminantImageFilter(); /** * Destructor. */ ~ImageToHessianDeterminantImageFilter() ITK_OVERRIDE; /** * Standard PrintSelf method. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Main computation method. */ void GenerateData() ITK_OVERRIDE; private: /** Hessian filter */ ImageToHessianImageFilterPointerType m_HessianFilter; /** Hessian Determinant Computation filter */ DeterminantFilterPointerType m_DeterminantFilter; /** Width of the Gaussian used in the HessianRecursiveGaussianImageFilter */ double m_Sigma; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToHessianDeterminantImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbImageToHessianDeterminantImageFilter.txx000066400000000000000000000043001301006202600327600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToHessianDeterminantImageFilter_txx #define otbImageToHessianDeterminantImageFilter_txx #include "otbImageToHessianDeterminantImageFilter.h" namespace otb { template ImageToHessianDeterminantImageFilter ::ImageToHessianDeterminantImageFilter() { // Filter initialization m_HessianFilter = ImageToHessianImageFilterType::New(); m_DeterminantFilter = DeterminantFilterType::New(); // pipeline wiring m_DeterminantFilter->SetInput(m_HessianFilter->GetOutput()); // default parameter value m_Sigma = 1.0; } template ImageToHessianDeterminantImageFilter ::~ImageToHessianDeterminantImageFilter() {} template void ImageToHessianDeterminantImageFilter ::GenerateData(void) { // Execute minipipeline m_HessianFilter->SetInput(this->GetInput()); m_HessianFilter->SetSigma(m_Sigma); m_DeterminantFilter->GraftOutput(this->GetOutput()); m_DeterminantFilter->Update(); this->GraftOutput(m_DeterminantFilter->GetOutput()); } /*PrintSelf*/ template void ImageToHessianDeterminantImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Sigma: " << m_Sigma << std::endl; } } #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbImageToSIFTKeyPointSetFilter.h000066400000000000000000000320071301006202600305450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToSIFTKeyPointSetFilter_h #define otbImageToSIFTKeyPointSetFilter_h #include #include "itkExpandImageFilter.h" #include "itkDiscreteGaussianImageFilter.h" #include "itkRecursiveGaussianImageFilter.h" #include "itkSubtractImageFilter.h" #include "itkShrinkImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionConstIterator.h" #include "itkVector.h" #include "itkMinimumMaximumImageCalculator.h" #include "itkUnaryFunctorImageFilter.h" #include "itkGradientImageFilter.h" #include "otbImageToPointSetFilter.h" #include "otbImageList.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class MagnitudeFunctor * \brief This functor computes the magnitude of a covariant vector. * * \ingroup OTBDescriptors */ template class MagnitudeFunctor { public: inline TOutputPixel operator ()(const TInputPixel& input) { return vcl_sqrt(input[0] * input[0] + input[1] * input[1]); } }; /** \class OrientationFunctor * \brief This functor computes the orientation of a cavariant vector
* Orientation values lies between 0 and 2*Pi. * * \ingroup OTBDescriptors */ template class OrientationFunctor { public: inline TOutputPixel operator ()(const TInputPixel& input) { TOutputPixel resp = vcl_atan2(input[1], input[0]); if (resp < 0) { resp += CONST_2PI; } return resp; } }; } // end namespace Functor /** \class ImageToSIFTKeyPointSetFilter * \brief This class extracts key points from an input image, trough a pyramidal decomposition. * * This class implements the SIFT key point detector proposed by David G. Lowe in proceedings of International * Conference on Computer Vision, Corfu, september 1999. * * \li Input image is downsample by factor 2 * \li Pyramid of gaussians is obtained by filtering input image with * variable length sigma, each separated by a constant k = 2^(1/S) * where S is the number of scales * \li Difference of gaussian are compute with the difference of two * adjacent gaussian image results * \li Detector is laucnched on each difference of gaussian to find key point * \li A key point is a local minimum or a local maximum on 3*3 neighborhood * \li An interpolated location of the maximum key point is compute with fitting * a 3D quadratic function * \li DoG low constrast are discarded (DoG < 3%) * \li High edge responses key point are discarded * * Selected key points are stored in a itk::PointSet structure. * Data points contains a list of (magnitude, main orientation) for each level * of the pyramidal decomposition. * * Orientation is expressed in degree in the range [0, 360] with a precision of 10 degrees. * * \example Patented/SIFTExample.cxx * * * \ingroup OTBDescriptors */ template class ITK_EXPORT ImageToSIFTKeyPointSetFilter : public ImageToPointSetFilter { public: /** Standard typedefs */ typedef ImageToSIFTKeyPointSetFilter Self; typedef ImageToPointSetFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(ImageToSIFTKeyPointSetFilter, ImageToPointSetFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename TInputImage::Pointer InputImagePointerType; typedef typename TInputImage::PixelType PixelType; typedef TOutputPointSet OutputPointSetType; typedef typename TOutputPointSet::Pointer OutputPointSetPointerType; typedef typename TOutputPointSet::PixelType OutputPixelType; typedef typename TOutputPointSet::PointType OutputPointType; typedef typename TOutputPointSet::PointIdentifier OutputPointIdentifierType; typedef itk::Vector VectorPointType; /** Set/Get the number of octaves */ itkSetMacro(OctavesNumber, unsigned int); itkGetMacro(OctavesNumber, unsigned int); /** Set/Get the number of scales */ itkSetMacro(ScalesNumber, unsigned int); itkGetMacro(ScalesNumber, unsigned int); /** Set/Get the expand factors */ itkSetMacro(ExpandFactors, unsigned int); itkGetMacro(ExpandFactors, unsigned int); /** Set/Get the shrink factors */ itkSetMacro(ShrinkFactors, unsigned int); itkGetMacro(ShrinkFactors, unsigned int); /** Set/Get the sigma 0 */ itkSetMacro(Sigma0, double); itkGetMacro(Sigma0, double); /** Set/Get the Difference of gaussian threshold * eliminating low contrast key point */ itkSetMacro(DoGThreshold, double); itkGetMacro(DoGThreshold, double); /** Set/Get Edgethreshold * Eliminating edge responses */ itkSetMacro(EdgeThreshold, double); itkGetMacro(EdgeThreshold, double); /** Set/Get Gauss sigma factor orientation */ itkSetMacro(SigmaFactorOrientation, double); itkGetMacro(SigmaFactorOrientation, double); /** Set/Get Gauss sigma factor descriptor */ itkSetMacro(SigmaFactorDescriptor, double); itkGetMacro(SigmaFactorDescriptor, double); /** Internal typedefs */ typedef itk::ExpandImageFilter ExpandFilterType; typedef typename ExpandFilterType::Pointer ExpandFilterPointerType; typedef itk::ShrinkImageFilter ShrinkFilterType; typedef typename ShrinkFilterType::Pointer ShrinkFilterPointerType; typedef itk::RecursiveGaussianImageFilter GaussianFilterType; typedef typename GaussianFilterType::Pointer GaussianFilterPointerType; typedef otb::ImageList ImageListType; typedef typename ImageListType::Pointer ImageListPointerType; typedef itk::SubtractImageFilter SubtractFilterType; typedef typename SubtractFilterType::Pointer SubtractFilterPointerType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::NeighborhoodType NeighborhoodType; typedef typename NeighborhoodType::OffsetType OffsetType; typedef itk::ImageRegionConstIterator RegionIteratorType; typedef itk::MinimumMaximumImageCalculator MinimumMaximumCalculatorType; typedef typename MinimumMaximumCalculatorType::Pointer MinimumMaximumCalculatorPointerType; typedef itk::GradientImageFilter GradientFilterType; typedef typename GradientFilterType::Pointer GradientFilterPointerType; typedef typename GradientFilterType::OutputImageType GradientOutputImageType; typedef itk::UnaryFunctorImageFilter > MagnitudeFilterType; typedef typename MagnitudeFilterType::Pointer MagnitudeFilterPointerType; typedef itk::UnaryFunctorImageFilter > OrientationFilterType; typedef typename OrientationFilterType::Pointer OrientationFilterPointerType; protected: /** Actually process the input */ void GenerateData() ITK_OVERRIDE; /** Constructor */ ImageToSIFTKeyPointSetFilter(); /** Destructor */ ~ImageToSIFTKeyPointSetFilter() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Initialize input image */ void InitializeInputImage(); /** Compute differenec of gaussian * * \param input current input in process */ void ComputeDifferenceOfGaussian(InputImagePointerType input); /** Localize key point */ void DetectKeyPoint(const unsigned int octave); /** Check local extremum for 26 neighbors (current and adjacents scales) * * \param currentScale * \param previousScale * \param nextScale * * \return true if the pixel is extremum */ bool IsLocalExtremum(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale, const NeighborhoodIteratorType& nextScale) const; /** Refine location key point * * \li Discard keypoints with low contrats DoG < DoGThreshold * \li Discard keypoints that have a ratio between the principles * curvature greater than EdgeTrhesold (=10) * * \param currentScale iterator * \param previousScale iterator * \param nextScale iterator * \param solution * * \return true if key point is accepted, false otherwise */ bool RefineLocationKeyPoint(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale, const NeighborhoodIteratorType& nextScale, VectorPointType& solution); /** Assign key point orientation * * \param currentScale neighborhood iterator * \param scale current scale * \param translation refine offset pixel location * * \return orientation key point orientation */ std::vector ComputeKeyPointOrientations(const NeighborhoodIteratorType& currentScale, const unsigned int scale, const PixelType translation); /** Compute local image descriptor * * \param currentScale neighborhood iterator * \param scale * \param orientation * * \return histogram descriptor */ std::vector ComputeKeyPointDescriptor(const NeighborhoodIteratorType& currentScale, const unsigned int scale, const PixelType& orientation); private: ImageToSIFTKeyPointSetFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Number of octaves */ unsigned int m_OctavesNumber; /** Number of scale for each octave */ unsigned int m_ScalesNumber; /** Expand factors */ unsigned int m_ExpandFactors; /** Shrink factors */ unsigned int m_ShrinkFactors; /** Threshold DoG */ double m_DoGThreshold; /** Edge Threshold */ double m_EdgeThreshold; /** Ratio threshold compute */ double m_RatioEdgeThreshold; /** Histogram sift keys descriptors gradient magnitude threshold */ PixelType m_GradientMagnitudeThreshold; /** Sigma 0 */ typename GaussianFilterType::ScalarRealType m_Sigma0; /** Sigma k */ double m_Sigmak; /** Gauss factor length for key point orientation */ double m_SigmaFactorOrientation; /** Descriptor size */ double m_SigmaFactorDescriptor; /** Expand filter */ ExpandFilterPointerType m_ExpandFilter; /** Shrink filter */ ShrinkFilterPointerType m_ShrinkFilter; /** Gaussian filter */ GaussianFilterPointerType m_XGaussianFilter; GaussianFilterPointerType m_YGaussianFilter; /** Gaussian image pointer */ InputImagePointerType m_LastGaussian; /** Difference of gaussian list */ ImageListPointerType m_DoGList; /** Magnitude image list */ ImageListPointerType m_MagnitudeList; /** Orientation image list */ ImageListPointerType m_OrientationList; /** Subtract filter */ SubtractFilterPointerType m_SubtractFilter; /** Gradient filter */ GradientFilterPointerType m_GradientFilter; /** Magnitude filter */ MagnitudeFilterPointerType m_MagnitudeFilter; /** Orientation filter */ OrientationFilterPointerType m_OrientationFilter; /** Number of key points */ OutputPointIdentifierType m_ValidatedKeyPoints; /** Number of key point which offset is larger than 0.5 per octave*/ unsigned int m_DifferentSamplePoints; /** Number of discarded key points */ unsigned int m_DiscardedKeyPoints; /** Number of change sample max */ unsigned int m_ChangeSamplePointsMax; /** Gaussian sigma for histogram smoothing */ std::vector m_HistogramGaussianWeights; /** Offsets vector, conveniance datas */ OffsetType m_Offsets[8]; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToSIFTKeyPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbImageToSIFTKeyPointSetFilter.txx000066400000000000000000000770311301006202600311470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToSIFTKeyPointSetFilter_txx #define otbImageToSIFTKeyPointSetFilter_txx #include "otbImageToSIFTKeyPointSetFilter.h" #include "itkMatrix.h" #include "itkProcessObject.h" namespace otb { /** * Constructor */ template ImageToSIFTKeyPointSetFilter ::ImageToSIFTKeyPointSetFilter() { m_OctavesNumber = 1; m_ScalesNumber = 3; m_ExpandFactors = 2; m_ShrinkFactors = 2; m_Sigma0 = 1.6; m_Sigmak = 0; m_DoGThreshold = 0.03; m_EdgeThreshold = 10; m_RatioEdgeThreshold = 0; m_ValidatedKeyPoints = 0; m_DifferentSamplePoints = 0; m_DiscardedKeyPoints = 0; m_ChangeSamplePointsMax = 2; m_SigmaFactorOrientation = 3; m_SigmaFactorDescriptor = 1.5; m_GradientMagnitudeThreshold = 0.2; m_ExpandFilter = ExpandFilterType::New(); const double HistogramGaussianWeights[73] = { 2.3771112282795414e-07, 3.8860734758633732e-07, 6.2655544995978937e-07, 9.9631120821413786e-07, 1.5624909838697011e-06, 2.4167238265599128e-06, 3.6865788528530121e-06, 5.5463469229192623e-06, 8.2295774080263437e-06, 1.2043009749602365e-05, 1.738119136656513e-05, 2.4740646513897326e-05, 3.4731980398846277e-05, 4.808781565748272e-05, 6.5664032975164266e-05, 8.8431512984476723e-05, 0.00011745555408931643, 0.00015386047198026335, 0.00019877765486783745, 0.00025327659834301937, 0.00031828015928190065, 0.00039446735551235698, 0.00048216931692246382, 0.00058126620279441276, 0.00069109471776775144, 0.00081037694122312908, 0.00093718121775182789, 0.0010689246133776746, 0.0012024238404411182, 0.0013339976954896103, 0.0014596192424447215, 0.0015751106965100009, 0.0016763688464699555, 0.0017596045720966803, 0.0018215772013714365, 0.0018598035923515156, 0.0018727231637146351, 0.0018598035923515156, 0.0018215772013714365, 0.0017596045720966803, 0.0016763688464699555, 0.0015751106965100009, 0.0014596192424447215, 0.0013339976954896103, 0.0012024238404411182, 0.0010689246133776746, 0.00093718121775182789, 0.00081037694122312908, 0.00069109471776775144, 0.00058126620279441276, 0.00048216931692246382, 0.00039446735551235698, 0.00031828015928190065, 0.00025327659834301937, 0.00019877765486783745, 0.00015386047198026335, 0.00011745555408931643, 8.8431512984476723e-05, 6.5664032975164266e-05, 4.808781565748272e-05, 3.4731980398846277e-05, 2.4740646513897326e-05, 1.738119136656513e-05, 1.2043009749602365e-05, 8.2295774080263437e-06, 5.5463469229192623e-06, 3.6865788528530121e-06, 2.4167238265599128e-06, 1.5624909838697011e-06, 9.9631120821413786e-07, 6.2655544995978937e-07, 3.8860734758633732e-07, 2.3771112282795414e-07 }; m_HistogramGaussianWeights = std::vector(HistogramGaussianWeights,HistogramGaussianWeights+73); m_Offsets[0][0]=-1; m_Offsets[0][1]=-1; m_Offsets[1][0]=-1; m_Offsets[1][1]= 0; m_Offsets[2][0]=-1; m_Offsets[2][1]= 1; m_Offsets[3][0]= 0; m_Offsets[3][1]=-1; m_Offsets[4][0]= 0; m_Offsets[4][1]= 1; m_Offsets[5][0]= 1; m_Offsets[5][1]=-1; m_Offsets[6][0]= 1; m_Offsets[6][1]= 0; m_Offsets[7][0]= 1; m_Offsets[7][1]= 1; } template void ImageToSIFTKeyPointSetFilter ::GenerateData() { // First, subsample the input image InitializeInputImage(); InputImagePointerType input = m_ExpandFilter->GetOutput(); typename InputImageType::PointType point; typename InputImageType::IndexType index; index[0] = 0; index[1] = 0; m_ExpandFilter->GetOutput()->TransformIndexToPhysicalPoint(index, point); // for each octave, compute the difference of gaussian unsigned int lOctave = 0; m_Sigmak = vcl_pow(2, static_cast(1 / (double) (m_ScalesNumber + 1))); m_RatioEdgeThreshold = (m_EdgeThreshold + 1) * (m_EdgeThreshold + 1) / m_EdgeThreshold; for (lOctave = 0; lOctave != m_OctavesNumber; lOctave++) { m_DifferentSamplePoints = 0; m_DiscardedKeyPoints = 0; typename InputImageType::PointType origin0 = input->GetOrigin(); ComputeDifferenceOfGaussian(input); DetectKeyPoint(lOctave); // Get the last gaussian for subsample and // repeat the process m_ShrinkFilter = ShrinkFilterType::New(); m_ShrinkFilter->SetInput(m_LastGaussian); m_ShrinkFilter->SetShrinkFactors(m_ShrinkFactors); m_ShrinkFilter->Update(); input = m_ShrinkFilter->GetOutput(); typename InputImageType::PointType origin1; typename InputImageType::SpacingType spacing = input->GetSpacing(); origin1[0] = origin0[0] + spacing[0] * 0.25; origin1[1] = origin0[1] + spacing[1] * 0.25; input->SetOrigin(origin1); otbGenericMsgDebugMacro(<< "ImageToSIFTKeyPointSetFilter:: Number total key points : " \ << m_ValidatedKeyPoints); otbGenericMsgDebugMacro(<< "ImageToSIFTKeyPointSetFilter:: Number different sample key points per octave : " \ << m_DifferentSamplePoints); otbGenericMsgDebugMacro(<< "ImageToSIFTKeyPointSetFilter:: Number discarded key points per octave : " \ << m_DiscardedKeyPoints); otbGenericMsgDebugMacro(<< "ImageToSIFTKeyPointSetFilter:: Resample image factor : " \ << m_ShrinkFactors); } otbGenericMsgDebugMacro(<< "ImageToSIFTKeyPointSetFilter:: Total number key points : " \ << this->GetOutput()->GetNumberOfPoints()); } /** * Initialize the input image */ template void ImageToSIFTKeyPointSetFilter ::InitializeInputImage() { m_ExpandFilter->SetInput(this->GetInput()); m_ExpandFilter->SetExpandFactors(m_ExpandFactors); m_ExpandFilter->Update(); typename InputImageType::PointType origin0 = this->GetInput()->GetOrigin(); typename InputImageType::PointType origin1; typename InputImageType::SpacingType spacing = m_ExpandFilter->GetOutput()->GetSpacing(); origin1[0] = origin0[0] - spacing[0] * 0.5; origin1[1] = origin0[1] - spacing[1] * 0.5; m_ExpandFilter->GetOutput()->SetOrigin(origin1); } /** * Compute the difference of gaussian */ template void ImageToSIFTKeyPointSetFilter ::ComputeDifferenceOfGaussian(InputImagePointerType input) { unsigned int lScale = 0; InputImagePointerType previousGaussian; m_DoGList = ImageListType::New(); m_MagnitudeList = ImageListType::New(); m_OrientationList = ImageListType::New(); // m_GaussianWeightOrientationList = ImageListType::New(); // m_GaussianWeightDescriptorList = ImageListType::New(); // itkRecursiveGaussian use spacing to compute // length sigma gaussian (in mm) // sigma = sigma/spacing // // with multiply by spacing before filtering, length sigma gaussian // is compute in pixel double xsigman = vcl_abs(input->GetSpacing()[0]) * m_Sigma0; double ysigman = vcl_abs(input->GetSpacing()[1]) * m_Sigma0; for (lScale = 0; lScale != m_ScalesNumber + 2; lScale++) { m_XGaussianFilter = GaussianFilterType::New(); m_YGaussianFilter = GaussianFilterType::New(); m_XGaussianFilter->SetSigma(xsigman); m_XGaussianFilter->SetDirection(0); m_XGaussianFilter->SetInput(input); m_YGaussianFilter->SetSigma(ysigman); m_YGaussianFilter->SetDirection(1); m_YGaussianFilter->SetInput(m_XGaussianFilter->GetOutput()); m_YGaussianFilter->Update(); m_GradientFilter = GradientFilterType::New(); m_MagnitudeFilter = MagnitudeFilterType::New(); m_OrientationFilter = OrientationFilterType::New(); m_GradientFilter->SetInput(m_YGaussianFilter->GetOutput()); m_MagnitudeFilter->SetInput(m_GradientFilter->GetOutput()); m_OrientationFilter->SetInput(m_GradientFilter->GetOutput()); m_MagnitudeFilter->Update(); m_OrientationFilter->Update(); m_MagnitudeList->PushBack(m_MagnitudeFilter->GetOutput()); m_OrientationList->PushBack(m_OrientationFilter->GetOutput()); if (lScale > 0) { m_SubtractFilter = SubtractFilterType::New(); m_SubtractFilter->SetInput1(m_YGaussianFilter->GetOutput()); m_SubtractFilter->SetInput2(previousGaussian); m_SubtractFilter->Update(); m_DoGList->PushBack(m_SubtractFilter->GetOutput()); } previousGaussian = m_YGaussianFilter->GetOutput(); xsigman = xsigman * m_Sigmak; ysigman = ysigman * m_Sigmak; } m_LastGaussian = previousGaussian; otbGenericMsgDebugMacro(<< "ImageToSIFTKeyPointSetFilter:: Number of DoG " << m_DoGList->Size()); } /** * Localize key point */ template void ImageToSIFTKeyPointSetFilter ::DetectKeyPoint(const unsigned int octave) { // need at least 3 DoG, ie 2 scales if (m_ScalesNumber > 1) { typename ImageListType::Iterator lIterDoG = m_DoGList->Begin() + 1; unsigned int lScale = 1; OutputPointSetPointerType outputPointSet = this->GetOutput(); typename InputImageType::SpacingType spacing = lIterDoG.Get()->GetSpacing(); while ((lIterDoG + 1) != m_DoGList->End()) { otbGenericMsgDebugMacro(<< "ImageToSIFTKeyPointSetFilter:: octave: " << octave << " scale: " << lScale); otbUnusedMacro(octave); // Compute max of DoG MinimumMaximumCalculatorPointerType lMaximumCalculator = MinimumMaximumCalculatorType::New(); lMaximumCalculator->SetImage(lIterDoG.Get()); lMaximumCalculator->Compute(); typename InputImageType::SizeType lRadius; lRadius.Fill(1); typename ImageListType::Iterator lIterNext = lIterDoG + 1; typename ImageListType::Iterator lIterPrev = lIterDoG - 1; NeighborhoodIteratorType lIterCurrent(lRadius, lIterDoG.Get(), lIterDoG.Get()->GetLargestPossibleRegion()); NeighborhoodIteratorType lIterLowerAdjacent(lRadius, lIterPrev.Get(), lIterPrev.Get()->GetLargestPossibleRegion()); NeighborhoodIteratorType lIterUpperAdjacent(lRadius, lIterNext.Get(), lIterNext.Get()->GetLargestPossibleRegion()); while (!lIterCurrent.IsAtEnd() && !lIterLowerAdjacent.IsAtEnd() && !lIterUpperAdjacent.IsAtEnd()) { // check local min/max if (IsLocalExtremum(lIterCurrent, lIterLowerAdjacent, lIterUpperAdjacent)) { VectorPointType lTranslation(PixelType(0)); OffsetType lOffsetZero = {{0, 0}}; unsigned int lChangeSamplePoints = 0; NeighborhoodIteratorType neighborCurrentScale(lIterCurrent); NeighborhoodIteratorType neighborPreviousScale(lIterLowerAdjacent); NeighborhoodIteratorType neighborNextScale(lIterUpperAdjacent); bool accepted = false; bool changed = true; while (lChangeSamplePoints < m_ChangeSamplePointsMax && changed) { accepted = RefineLocationKeyPoint(neighborCurrentScale, neighborPreviousScale, neighborNextScale, lTranslation); OffsetType lTranslateOffset = {{0, 0}}; lTranslateOffset[0] += static_cast(lTranslation[0] > 0.5); lTranslateOffset[0] += -static_cast(lTranslation[0] < -0.5); lTranslateOffset[1] += static_cast(lTranslation[1] > 0.5); lTranslateOffset[1] += -static_cast(lTranslation[1] < -0.5); NeighborhoodIteratorType moveIterator = neighborCurrentScale + lTranslateOffset; if (moveIterator.InBounds()) { changed = lTranslateOffset != lOffsetZero; // move iterator neighborCurrentScale += lTranslateOffset; neighborPreviousScale += lTranslateOffset; neighborNextScale += lTranslateOffset; } else { changed = false; } ++lChangeSamplePoints; } if (changed) { ++m_DifferentSamplePoints; } // add key point if (accepted) { std::vector lOrientations = ComputeKeyPointOrientations(neighborCurrentScale, lScale, lTranslation[2]); // for each main orientation for (typename std::vector::iterator orientationIt = lOrientations.begin(); orientationIt != lOrientations.end(); ++orientationIt) { std::vector lDescriptors = ComputeKeyPointDescriptor(neighborCurrentScale, lScale, *orientationIt); OutputPointType keyPoint; lIterDoG.Get()->TransformIndexToPhysicalPoint(neighborCurrentScale.GetIndex(), keyPoint); keyPoint[0] += spacing[0] * lTranslation[0]; keyPoint[1] += spacing[1] * lTranslation[1]; outputPointSet->SetPoint(m_ValidatedKeyPoints, keyPoint); OutputPixelType data; data.SetSize(128); // check this, compute scale // real scale = octave*scale typename std::vector::const_iterator lIterDescriptor = lDescriptors.begin(); unsigned int lIndDesc = 0; while (lIterDescriptor != lDescriptors.end()) { data.SetElement(lIndDesc, *lIterDescriptor); ++lIndDesc; ++lIterDescriptor; } outputPointSet->SetPointData(m_ValidatedKeyPoints, data); ++m_ValidatedKeyPoints; } } } ++lIterCurrent; ++lIterLowerAdjacent; ++lIterUpperAdjacent; } ++lIterDoG; ++lScale; } } } /** * Check local extremum for 26 neighbors */ template bool ImageToSIFTKeyPointSetFilter ::IsLocalExtremum(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale, const NeighborhoodIteratorType& nextScale) const { bool isMin = currentScale.GetCenterPixel() < currentScale.GetPixel(m_Offsets[0]); bool isMax = currentScale.GetCenterPixel() > currentScale.GetPixel(m_Offsets[0]); bool isExtremum = isMin || isMax; unsigned int lIterOffset = 0; while (isExtremum && lIterOffset != 8) { OffsetType off = m_Offsets[lIterOffset]; if (isMin) { isExtremum = currentScale.GetCenterPixel() < currentScale.GetPixel(off) && currentScale.GetCenterPixel() < previousScale.GetPixel(off) && currentScale.GetCenterPixel() < nextScale.GetPixel(off); } else if (isMax) { isExtremum = currentScale.GetCenterPixel() > currentScale.GetPixel(off) && currentScale.GetCenterPixel() > previousScale.GetPixel(off) && currentScale.GetCenterPixel() > nextScale.GetPixel(off); } lIterOffset++; } if (isExtremum && isMin) { isExtremum = currentScale.GetCenterPixel() < previousScale.GetCenterPixel() && currentScale.GetCenterPixel() < nextScale.GetCenterPixel(); } else if (isExtremum && isMax) { isExtremum = currentScale.GetCenterPixel() > previousScale.GetCenterPixel() && currentScale.GetCenterPixel() > nextScale.GetCenterPixel(); } return isExtremum; } /** * Refine location key point */ template bool ImageToSIFTKeyPointSetFilter ::RefineLocationKeyPoint(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale, const NeighborhoodIteratorType& nextScale, VectorPointType& solution) { bool accepted = true; solution = VectorPointType(PixelType(0)); PixelType dx = 0.5 * (currentScale.GetPixel(m_Offsets[6]) - currentScale.GetPixel(m_Offsets[1])); PixelType dy = 0.5 * (currentScale.GetPixel(m_Offsets[4]) - currentScale.GetPixel(m_Offsets[3])); PixelType ds = 0.5 * (nextScale.GetCenterPixel() - previousScale.GetCenterPixel()); PixelType dxx = currentScale.GetPixel(m_Offsets[6]) - 2 * currentScale.GetCenterPixel() + currentScale.GetPixel(m_Offsets[1]); PixelType dyy = currentScale.GetPixel(m_Offsets[3]) - 2 * currentScale.GetCenterPixel() + currentScale.GetPixel(m_Offsets[4]); PixelType dss = previousScale.GetCenterPixel() - 2 * currentScale.GetCenterPixel() + nextScale.GetCenterPixel(); PixelType dxy = 0.25 * (currentScale.GetPixel(m_Offsets[7]) + currentScale.GetPixel(m_Offsets[0]) - currentScale.GetPixel(m_Offsets[2]) - currentScale.GetPixel(m_Offsets[5])); PixelType dxs = 0.25 * (nextScale.GetPixel(m_Offsets[6]) + previousScale.GetPixel(m_Offsets[1]) - nextScale.GetPixel(m_Offsets[1]) - previousScale.GetPixel(m_Offsets[6])); PixelType dys = 0.25 * (nextScale.GetPixel(m_Offsets[4]) + previousScale.GetPixel(m_Offsets[3]) - nextScale.GetPixel(m_Offsets[3]) - previousScale.GetPixel(m_Offsets[4])); // Compute matrice determinant double det = dxx * (dyy * dss - dys * dys) - dxy * (dxy * dss - dxs * dys) + dxs * (dxy * dys - dxs * dyy); // Solve system, compute key point offset solution[0] = -dx * (dyy * dss - dys * dys) - dy * (dxs * dys - dxy * dss) - ds * (dxy * dys - dyy * dxs); solution[1] = -dx * (dys * dxs - dss * dxy) - dy * (dxx * dss - dxs * dxs) - ds * (dxs * dxy - dxx * dys); solution[2] = -dx * (dxy * dys - dxs * dyy) - dy * (dxy * dxs - dxx * dys) - ds * (dxx * dyy - dxy * dxy); // Compute interpolated value DoG for lSolution (determinant factor) PixelType lDoGInterpolated = det * currentScale.GetCenterPixel() + 0.5 * (dx * solution[0] + dy * solution[1] + ds * solution[2]); PixelType lHessianTrace2 = (dxx + dyy) * (dxx + dyy); PixelType lHessianDet = dxx * dyy - dxy * dxy; // DoG threshold accepted = fabs(lDoGInterpolated) >= fabs(det * m_DoGThreshold); // Eliminating edge response accepted = accepted && fabs(lHessianTrace2) < fabs(m_RatioEdgeThreshold * lHessianDet); if (!accepted) { ++m_DiscardedKeyPoints; } if (det < 1e-10f) { solution.Fill(0); } else { // normalize offset with determinant of derivative matrix solution /= det; } return accepted; } /** * Compute key point orientation */ template std::vector::PixelType> ImageToSIFTKeyPointSetFilter ::ComputeKeyPointOrientations(const NeighborhoodIteratorType& currentScale, const unsigned int scale, const PixelType itkNotUsed(translation)) { // radius of the neighborhood unsigned int radius = 4; double lSigma = scale * 3; unsigned int nbBins = 36; double binWidth = 360. / nbBins; // initialize the histogram std::vector lHistogram(nbBins, 0.), lSmoothedHistogram(nbBins, 0.); // Build the region to examine typename InputImageType::RegionType region; typename InputImageType::RegionType::SizeType regionSize; typename InputImageType::RegionType::IndexType regionIndex; regionSize.Fill(2 * radius + 2); region.SetSize(regionSize); regionIndex[0] = currentScale.GetIndex()[0] - regionSize[0] / 2; regionIndex[1] = currentScale.GetIndex()[1] - regionSize[1] / 2; region.SetIndex(regionIndex); if (!region.Crop(m_OrientationList->GetNthElement(scale)->GetLargestPossibleRegion())) { itkExceptionMacro(<< "Region " << region << " is strictly outside the largest possible region!"); } // iterators on the orientation and the magnitude RegionIteratorType lIterOrientation(m_OrientationList->GetNthElement(scale), region); RegionIteratorType lIterMagn(m_MagnitudeList->GetNthElement(scale), region); lIterOrientation.GoToBegin(); lIterMagn.GoToBegin(); // For each pixel while (!lIterOrientation.IsAtEnd() && !lIterMagn.IsAtEnd()) { // check if pixel is inside the circle of radius float dx = lIterMagn.GetIndex()[0] - currentScale.GetIndex()[0]; float dy = lIterMagn.GetIndex()[1] - currentScale.GetIndex()[1]; float dist = vcl_sqrt(dx * dx + dy * dy); // If we are in the circle if (dist < radius) { //Get the values PixelType lOrientation = lIterOrientation.Get(); PixelType lMagnitude = lIterMagn.Get(); // Compute the gaussian weight double lWeightMagnitude = vcl_exp(-dist * dist / (2 * lSigma * lSigma)); // Compute the histogram bin index unsigned int lHistoIndex = static_cast(vcl_floor(nbBins * lOrientation / (CONST_2PI))); // Update the histogram value lHistogram[lHistoIndex] += lMagnitude * lWeightMagnitude; } ++lIterOrientation; ++lIterMagn; } // Computing smoothed histogram and looking for the maximum and a second maximum within 80% of the first double max = 0; double secondMax = 0; double sum = 0; int maxIndex = 0; //int secondMaxIndex = -1; int j = 0; int i = 0; // Smoothing histogram for (i = 0; i < static_cast(nbBins); ++i) { sum = 0; for (j = i - nbBins; j < i; ++j) { sum += lHistogram[i - j - 1] * m_HistogramGaussianWeights[j + nbBins]; } lSmoothedHistogram[i] = sum; } // looking for maximums for (i = 0; i < static_cast(nbBins); ++i) { if (lSmoothedHistogram[i] > max) { secondMax = max; //secondMaxIndex = maxIndex; max = lSmoothedHistogram[i]; maxIndex = i; } else if (sum > secondMax) { secondMax = lSmoothedHistogram[i]; //secondMaxIndex = i; } } // This structure will hold the located maximums std::vector orientations; //interpolate orientation maximum double x1, x2, x3, y1, y2, y3, a, b, num, denom, orientation; x1 = (maxIndex - 1) * binWidth + binWidth / 2; y1 = lSmoothedHistogram[(maxIndex - 1) < 0 ? maxIndex - 1 + nbBins : maxIndex - 1]; x2 = (maxIndex) * binWidth + binWidth / 2; y2 = lSmoothedHistogram[maxIndex]; x3 = (maxIndex + 1) * binWidth + binWidth / 2; y3 = lSmoothedHistogram[maxIndex + 1 > static_cast < int > (nbBins) - 1 ? maxIndex + 1 - nbBins : maxIndex + 1]; denom = x1 * x1 * x2 + x2 * x2 * x3 + x3 * x3 * x1 - x1 * x1 * x3 - x2 * x2 * x1 - x3 * x3 * x2; num = y1 * x2 + y2 * x3 + y3 * x1 - y1 * x3 - y2 * x1 - y3 * x2; if (denom == 0 || num == 0) { // no main orientation, return an empty orientation vector return orientations; } a = num / denom; b = ((y1 - y2) - a * (x1 * x1 - x2 * x2)) / (x1 - x2); orientation = -b / (2 * a); if (orientation < 0) { orientation += 360; } else if (orientation >= 360) { orientation -= 360; } // orientations.push_back( static_cast(maxIndex*binWidth + binWidth/2)); orientations.push_back(static_cast(orientation)); // Second peak is disabled, since it seems to confuse the matching procedure. // if(secondMaxIndex>=0 && secondMax > 0.8 * max) // { // x1 = (secondMaxIndex-1)*binWidth+binWidth/2; // y1 = lSmoothedHistogram[(secondMaxIndex-1)<0 ? secondMaxIndex-1+nbBins : secondMaxIndex-1]; // x2 = (secondMaxIndex)*binWidth+binWidth/2; // y2 = lSmoothedHistogram[secondMaxIndex]; // x3 = (secondMaxIndex+1)*binWidth+binWidth/2; // y3 = lSmoothedHistogram[secondMaxIndex+1>static_cast(nbBins)-1 ? secondMaxIndex+1-nbBins : secondMaxIndex+1]; // denom = x1*x1*x2 + x2*x2*x3 + x3*x3*x1 - x1*x1*x3 - x2*x2*x1 - x3*x3*x2; // num = y1*x2 + y2 * x3 + y3*x1 - y1*x3 - y2*x1 - y3*x2; // if(denom == 0 || num == 0) // { // // no main orientation, return an empty orientation vector // return orientations; // } // a = num/denom; // b = ((y1-y2)-a*(x1*x1-x2*x2))/(x1-x2); // orientation = -b/(2*a); // if(orientation<0) // { // orientation+=360; // } // else if(orientation>=360) // { // orientation-=360; // } // // orientations.push_back( static_cast(secondMaxIndex*binWidth+binWidth/2)); // orientations.push_back(static_cast(orientation)); // } return orientations; } /** * Compute key point descriptor */ template std::vector::PixelType> ImageToSIFTKeyPointSetFilter ::ComputeKeyPointDescriptor(const NeighborhoodIteratorType& currentScale, const unsigned int scale, const PixelType& orientation) { std::vector lHistogram(128, 0.); typename InputImageType::RegionType region; typename InputImageType::RegionType::SizeType regionSize; typename InputImageType::RegionType::IndexType regionIndex; unsigned int nbHistograms = 4; unsigned int nbPixelsPerHistogram = 4; unsigned int nbBinsPerHistogram = 8; float radius = static_cast(nbHistograms / 2 * nbPixelsPerHistogram); // std::cout<<"Radius: "<GetNthElement(scale)->GetLargestPossibleRegion())) { itkExceptionMacro(<< "Region " << region << " is outside of the largest possible region!"); } RegionIteratorType lIterMagnitude(m_MagnitudeList->GetNthElement(scale), region); RegionIteratorType lIterOrientation(m_OrientationList->GetNthElement(scale), region); lIterMagnitude.GoToBegin(); lIterOrientation.GoToBegin(); // For each pixel in the region while (!lIterMagnitude.IsAtEnd() && !lIterOrientation.IsAtEnd()) { // check if pixel is inside the circle of radius float dx = lIterMagnitude.GetIndex()[0] - currentScale.GetIndex()[0]; float dy = lIterMagnitude.GetIndex()[1] - currentScale.GetIndex()[1]; float dist = vcl_sqrt(dx * dx + dy * dy); // If we are in the circle if (dist < radius) { // rotate the pixel location to compensate sift orientation float angle = orientation * CONST_PI_180; float cosangle = vcl_cos(-angle); float sinangle = vcl_sin(-angle); float rdx = dx * cosangle - dy * sinangle; float rdy = dx * sinangle + dy * cosangle; // decide to which histogram the pixel contributes unsigned int xHistogramIndex = static_cast(vcl_floor((rdx + radius) / static_cast(nbPixelsPerHistogram))); unsigned int yHistogramIndex = static_cast(vcl_floor((rdy + radius) / static_cast(nbPixelsPerHistogram))); // decide to which bin of the histogram the pixel contributes float compensatedOrientation = lIterOrientation.Get() - angle; if (compensatedOrientation < 0) { compensatedOrientation += CONST_2PI; } if (compensatedOrientation >= CONST_2PI) { compensatedOrientation -= CONST_2PI; } unsigned int histogramBin = static_cast(vcl_floor(compensatedOrientation * nbBinsPerHistogram / (CONST_2PI))); // Compute the wheight of the pixel in the histogram double lWeightMagnitude = vcl_exp(-(dist * dist) / (2 * lSigma * lSigma)); // Compute the global descriptor index unsigned int descriptorIndex = yHistogramIndex * nbBinsPerHistogram * nbHistograms + xHistogramIndex * nbBinsPerHistogram + histogramBin; lHistogram[descriptorIndex] += lIterMagnitude.Get() * lWeightMagnitude; } ++lIterOrientation; ++lIterMagnitude; } // normalize histogram to unit length typename std::vector::iterator lIterHisto = lHistogram.begin(); float lNorm = 0.0; while (lIterHisto != lHistogram.end()) { lNorm = lNorm + (*lIterHisto) * (*lIterHisto); ++lIterHisto; } lNorm = vcl_sqrt(lNorm); lIterHisto = lHistogram.begin(); while (lIterHisto != lHistogram.end()) { if (lNorm > 0) { *lIterHisto = (*lIterHisto) / lNorm; } else { *lIterHisto = m_GradientMagnitudeThreshold; } // threshold gradient magnitude if (*lIterHisto > m_GradientMagnitudeThreshold) { *lIterHisto = m_GradientMagnitudeThreshold; } ++lIterHisto; } // renormalize histogram to unit length lIterHisto = lHistogram.begin(); lNorm = 0.0; while (lIterHisto != lHistogram.end()) { lNorm = lNorm + (*lIterHisto) * (*lIterHisto); ++lIterHisto; } lNorm = vcl_sqrt(lNorm); lIterHisto = lHistogram.begin(); while (lIterHisto != lHistogram.end()) { *lIterHisto = (*lIterHisto) / lNorm; ++lIterHisto; } return lHistogram; } /** * PrintSelf Method */ template void ImageToSIFTKeyPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { typedef itk::ProcessObject ProcessObjectType; const OutputPointSetType* output = dynamic_cast(this->ProcessObjectType::GetOutput(0)); Superclass::PrintSelf(os, indent); os << indent << "Number of octaves: " << m_OctavesNumber << std::endl; os << indent << "Number of scales: " << m_ScalesNumber << std::endl; os << indent << "Number of SIFT key points: " << output->GetNumberOfPoints() << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbImageToSURFKeyPointSetFilter.h000066400000000000000000000206761301006202600305700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToSURFKeyPointSetFilter_h #define otbImageToSURFKeyPointSetFilter_h #include "itkConstNeighborhoodIterator.h" #include "otbImageToHessianDeterminantImageFilter.h" #include "itkPointSet.h" #include #include #include "itkResampleImageFilter.h" #include "otbImageToPointSetFilter.h" #include "itkVector.h" #include namespace otb { /** \class ImageToSURFKeyPointSetFilter * \brief This class extracts key points from an image through a pyramidal gaussian based decomposition * * This class implements the SURF Key point detector proposed by Tuytelaars and Vangool from the university * of Leuven, 2005 * * \li Gaussian Second order derivative Hessian images are computed in each * level and each octave for the input image. * \li For each octave, an extremum search is launched on each 3 adjacent scales. * \li The Key points detected are the ones extremum in the current , previous and * next scale of reserach. 3 scales are needed for the computation (NumberOfScales >=3). * \li Orientation and descriptors are computed for each key point detected. * * Selected Key Points are stored in an itk::PointSet structure. * Points contains the coordinate of the detected point. * DataPoints contain the values of the 64 element descriptor for each key point * detected through the pyramidal analysis. * * Orientation is expressed in degree in the range of [0, 360] * * \sa otb::ImageToDeterminantHessianImage * * \ingroup OTBDescriptors */ template class ITK_EXPORT ImageToSURFKeyPointSetFilter : public ImageToPointSetFilter { public: /** Standard class typedefs. */ typedef ImageToSURFKeyPointSetFilter Self; typedef ImageToPointSetFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageToSURFKeyPointSetFilter, ImageToPointSetFilter); /** Template parameters typedefs*/ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::IndexType PixelIndex; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::PixelType PixelValue; typedef typename InputImageType::SpacingType SpacingType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::PointType PointImageType; typedef TOutputPointSet OutputPointSetType; typedef typename TOutputPointSet::Pointer OutputPointSetPointerType; typedef typename TOutputPointSet::PixelType OutputPixelType; typedef typename TOutputPointSet::PointType OutputPointType; typedef typename TOutputPointSet::PointIdentifier OutputPointIdentifierType; /** Set/Get the number of Octaves */ itkSetMacro(OctavesNumber, int); itkGetMacro(OctavesNumber, int); /** Set/Get the number of scales*/ itkSetMacro(ScalesNumber, int); itkGetMacro(ScalesNumber, int); /** Get the number of KeyPoints detected*/ itkGetMacro(NumberOfPoints, int); /** Internal filters typedefs */ typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::NeighborhoodType NeighborhoodType; typedef typename NeighborhoodType::OffsetType OffsetType; typedef otb::ImageToHessianDeterminantImageFilter ImageToDetHessianImageType; typedef typename ImageToDetHessianImageType::Pointer DetHessianPointerFilter; /** Filter for resampling images for the multi-scale analysis */ typedef itk::ResampleImageFilter ResampleFilterType; typedef typename ResampleFilterType::Pointer ResampleFilterPointerType; /** ImageList to store the Hessian determinant image at each scale (sigma width)*/ typedef otb::ImageList ImageListType; typedef typename ImageListType::Pointer ImageListTypePointer; /** 3D vector to store the keypoints translations */ typedef std::vector VectorType; typedef itk::Vector VectorPointType; protected: /** * Constructor. */ ImageToSURFKeyPointSetFilter(); /** * Destructor. */ ~ImageToSURFKeyPointSetFilter() ITK_OVERRIDE; /** * Standard PrintSelf method. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Main computation method. */ void GenerateData() ITK_OVERRIDE; /** Check local extremum for 8 neighbors (current) * * \param neigh Current scale neighborhood * * \return true if the Central pixel is extremum */ virtual bool IsLocalExtremum(const NeighborhoodType& neigh); /** Check local extremum for 8 neighbors (Previous or Scale) * * \param neigh Neighborhood at previous or next scale * \param CenterValue value at current scale center * * \return true if the Central pixel is extremum */ virtual bool IsLocalExtremumAround(const NeighborhoodType& neigh, double CenterValue); /** Refine location key point * * \li Discard keypoints with low contrats DoH < DoHThreshold * \li Discard keypoints that lie outside the centre cubic pixel * * \param currentScale iterator * \param previousScale iterator * \param nextScale iterator * \param solution refined keypoint location * * \return true if key point is accepted, false otherwise */ bool RefineLocationKeyPoint(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale, const NeighborhoodIteratorType& nextScale, VectorPointType& solution); /** AssignOrientation * * \param neigh current scale neighborhood * \param S scale affected to the keypoint * * \return key point orientation */ virtual double AssignOrientation(const NeighborhoodType& neigh, double S); /** ComputeDescriptor * * \param neigh current scale neighboorhood * \param O orientation assigned to the key point * \param S scale * * \return hsitogram descriptor */ virtual VectorType ComputeDescriptor(const NeighborhoodType& neigh, double O, double S); /** * Compute min a b c */ virtual int GetMin(int a, int b, int c); private: ImageToSURFKeyPointSetFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Number of octaves */ int m_OctavesNumber; /** Number of scale for each octave */ int m_ScalesNumber; /** Number of key points detected */ int m_NumberOfPoints; /** Minimum threshold for determinant of Hessian **/ double m_DoHThreshold; /** Those images */ InputImagePointerType m_determinantImage; InputImagePointerType m_ImageCurrent; InputImagePointerType m_ImageMovedPrev; InputImagePointerType m_ImageMovedNext; /** ImageToDeterminantHessianFilter filter */ DetHessianPointerFilter m_DetHessianFilter; /*Resample Filter*/ ResampleFilterPointerType m_ResampleFilter; /** ImageList*/ ImageListTypePointer m_ImageList; /** Number of shifted keypoints*/ unsigned int m_DifferentSamplePoints; /** Offsets vector, conveniance datas */ OffsetType m_Offsets[8]; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToSURFKeyPointSetFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbImageToSURFKeyPointSetFilter.txx000066400000000000000000000602431301006202600311560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToSURFKeyPointSetFilter_txx #define otbImageToSURFKeyPointSetFilter_txx #include "otbImageToSURFKeyPointSetFilter.h" #include "itkCenteredRigid2DTransform.h" namespace otb { /**--------------------------------------------------------- * Constructor ----------------------------------------------------------*/ template ImageToSURFKeyPointSetFilter ::ImageToSURFKeyPointSetFilter() { m_Offsets[0][0]=-1; m_Offsets[0][1]=-1; m_Offsets[1][0]=-1; m_Offsets[1][1]= 0; m_Offsets[2][0]=-1; m_Offsets[2][1]= 1; m_Offsets[3][0]= 0; m_Offsets[3][1]=-1; m_Offsets[4][0]= 0; m_Offsets[4][1]= 1; m_Offsets[5][0]= 1; m_Offsets[5][1]=-1; m_Offsets[6][0]= 1; m_Offsets[6][1]= 0; m_Offsets[7][0]= 1; m_Offsets[7][1]= 1; m_OctavesNumber = 1; m_ScalesNumber = 3; m_NumberOfPoints = 0; m_DifferentSamplePoints = 0; m_DoHThreshold = 0.03; m_DetHessianFilter = ImageToDetHessianImageType::New(); } /*--------------------------------------------------------- * Destructor.c ----------------------------------------------------------*/ template ImageToSURFKeyPointSetFilter ::~ImageToSURFKeyPointSetFilter() {} /*------------------------------------------------------- * Generate Data --------------------------------------------------------*/ template void ImageToSURFKeyPointSetFilter ::GenerateData(void) { double k; double sigma_in = 2.; SizeType radius; SpacingType spacing; /*Output*/ OutputPointSetPointerType outputPointSet = this->GetOutput(); /** Computing the multiplicative factor for scales iteration * scalar used for the wifth of the gaussian */ if (m_ScalesNumber > 1) k = (double) std::pow(2.0, (double) (1 / (double) (m_ScalesNumber - 1))); else k = 3; /* Computation loop over octaves*/ for (int i = 0; i < m_OctavesNumber; ++i) { sigma_in = 2.; m_ImageList = ImageListType::New(); spacing = this->GetInput()->GetSpacing(); /*-------------------------------------------------------- Octave per octave --------------------------------------------------------*/ if (i > 0) { m_ResampleFilter = ResampleFilterType::New(); m_ResampleFilter->SetInput(this->GetInput()); SizeType size = this->GetInput()->GetLargestPossibleRegion().GetSize(); for (int l = 0; l < 2; ++l) size[l] = (unsigned int) floor(size[l] / std::pow(2.0, i)); m_ResampleFilter->SetSize(size); for (int l = 0; l < 2; ++l) spacing[l] = (spacing[l] * std::pow(2.0, i)); m_ResampleFilter->SetOutputSpacing(spacing); /* necessary to handle images where the origin is not (0, 0) */ m_ResampleFilter->SetOutputOrigin(this->GetInput()->GetOrigin()); m_ResampleFilter->SetDefaultPixelValue(0); m_ResampleFilter->Update(); m_determinantImage = m_ResampleFilter->GetOutput(); otbGenericMsgDebugMacro(<< "ImageToSURFKeyPointSetFilter:: Size of the image at the octave : " \ << i << " is " \ << m_determinantImage->GetLargestPossibleRegion().GetSize()); } for (int j = 0; j < m_ScalesNumber; ++j) { /** Incrementation of the gaussian width * the width of the gaussian have to be doubled for * each iteration over octaves */ if ((i != 0 && j != 0) || (i == 0 && (i + j != 0)) || (m_ScalesNumber == 1 && i != 0)) sigma_in *= k; /** * For each octave, we search for the key points */ /** Hessian Determinant Image */ m_DetHessianFilter = ImageToDetHessianImageType::New(); if (i == 0) m_DetHessianFilter->SetInput(this->GetInput()); else m_DetHessianFilter->SetInput(m_determinantImage); m_DetHessianFilter->SetSigma(sigma_in); m_DetHessianFilter->Update(); m_determinantImage = m_DetHessianFilter->GetOutput(); if (i + j == 0) { otbGenericMsgDebugMacro(<< "ImageToSURFKeyPointSetFilter:: Size of the image at the octave : " << i << " is " << m_determinantImage->GetLargestPossibleRegion().GetSize()); } /** For each octave, we fill the imageList for the extremum search*/ m_ImageList->PushBack(m_determinantImage); } /*----------------------------------------------------*/ /* extremum Search over octave's scales */ /*----------------------------------------------------*/ for (int jj = 1; jj < (int) (m_ImageList->Size() - 1); jj++) { m_ImageCurrent = m_ImageList->GetNthElement(jj); m_ImageMovedPrev = m_ImageList->GetNthElement(jj - 1); m_ImageMovedNext = m_ImageList->GetNthElement(jj + 1); /** NeighboorhoodIterator parameters*/ radius.Fill(1); NeighborhoodIteratorType it(radius, m_ImageCurrent, m_ImageCurrent->GetLargestPossibleRegion()); it.GoToBegin(); /* NeighboorhoodIterator Adjacents parameters*/ NeighborhoodIteratorType itNeighPrev(radius, m_ImageMovedPrev, m_ImageMovedPrev->GetLargestPossibleRegion()); itNeighPrev.GoToBegin(); NeighborhoodIteratorType itNeighNext(radius, m_ImageMovedNext, m_ImageMovedNext->GetLargestPossibleRegion()); itNeighNext.GoToBegin(); while (!it.IsAtEnd()) { /** * The extremum condition is weak over scales, it allows the cases : * maxPrev & minCurr & maxNext, minPrev & maxCurr maxNext , ... */ if (IsLocalExtremum(it.GetNeighborhood()) && IsLocalExtremumAround(itNeighPrev.GetNeighborhood(), m_ImageCurrent->GetPixel(it.GetIndex())) && IsLocalExtremumAround(itNeighNext.GetNeighborhood(), m_ImageCurrent->GetPixel(it.GetIndex()))) { OutputPointType keyPoint; itNeighPrev.SetLocation(it.GetIndex()); itNeighNext.SetLocation(it.GetIndex()); VectorPointType lTranslation(PixelValue(0)); /* Approximation de la position */ NeighborhoodIteratorType neighborCurrentScale(it); NeighborhoodIteratorType neighborPreviousScale(itNeighPrev); NeighborhoodIteratorType neighborNextScale(itNeighNext); bool accepted = false; accepted = RefineLocationKeyPoint(neighborCurrentScale, neighborPreviousScale, neighborNextScale, lTranslation); OffsetType lTranslateOffset = {{0, 0}}; lTranslateOffset[0] += static_cast(lTranslation[0] > 0.5); lTranslateOffset[0] += -static_cast(lTranslation[0] < -0.5); lTranslateOffset[1] += static_cast(lTranslation[1] > 0.5); lTranslateOffset[1] += -static_cast(lTranslation[1] < -0.5); NeighborhoodIteratorType moveIterator = neighborCurrentScale + lTranslateOffset; if (moveIterator.InBounds()) { // move iterator neighborCurrentScale += lTranslateOffset; neighborPreviousScale += lTranslateOffset; neighborNextScale += lTranslateOffset; lTranslation[0] -= lTranslateOffset[0]; lTranslation[1] -= lTranslateOffset[1]; } else { lTranslation[0] = 0.0; lTranslation[1] = 0.0; } if (accepted == false) { ++it; ++itNeighPrev; ++itNeighNext; continue; } typename InputImageType::IndexType indexKeyPoint; indexKeyPoint[0] = neighborCurrentScale.GetIndex()[0]; indexKeyPoint[1] = neighborCurrentScale.GetIndex()[1]; double sigmaDetected = sigma_in / pow(k, (double) jj) * pow(2., (double) i); radius.Fill(GetMin((int) (this->GetInput()->GetLargestPossibleRegion().GetSize()[0] - indexKeyPoint[0]), (int) (this->GetInput()->GetLargestPossibleRegion().GetSize()[1] - indexKeyPoint[1]), (int) (6 * sigmaDetected))); /* Computing the orientation of the key point detected */ NeighborhoodIteratorType itNeighOrientation(radius, this->GetInput(), this->GetInput()->GetLargestPossibleRegion()); itNeighOrientation.SetLocation(neighborCurrentScale.GetIndex()); double orientationDetected = AssignOrientation(itNeighOrientation.GetNeighborhood(), sigmaDetected); /*Filling the Point pointSet Part*/ typename InputImageType::PointType physicalKeyPoint; m_ImageCurrent->TransformIndexToPhysicalPoint(neighborCurrentScale.GetIndex(), keyPoint); physicalKeyPoint[0] = keyPoint[0] + spacing[0] * lTranslation[0]; physicalKeyPoint[1] = keyPoint[1] + spacing[1] * lTranslation[1]; outputPointSet->SetPoint(m_NumberOfPoints, physicalKeyPoint); /*----------------------------------------*/ /* Descriptor Computation */ /*----------------------------------------*/ radius.Fill(GetMin((int) (this->GetInput()->GetLargestPossibleRegion().GetSize()[0] - indexKeyPoint[0]), (int) (this->GetInput()->GetLargestPossibleRegion().GetSize()[1] - indexKeyPoint[1]), (int) (10 * sigmaDetected))); // TODO a changer sigmaDetected par Keypoint[2] NeighborhoodIteratorType itNeighDescriptor(radius, this->GetInput(), this->GetInput()->GetLargestPossibleRegion()); //itNeighDescriptor.SetLocation(it.GetIndex()); itNeighDescriptor.SetLocation(neighborCurrentScale.GetIndex()); VectorType descriptor; descriptor.resize(64); //descriptor = ComputeDescriptor(itNeighDescriptor.GetNeighborhood(), keyPoint[3], keyPoint[2]); descriptor = ComputeDescriptor(itNeighDescriptor.GetNeighborhood(), orientationDetected, sigmaDetected); /*Updating the pointset data with values of the descriptor*/ OutputPixelType data; data.SetSize(64); unsigned int IndDescriptor = 0; typename std::vector::const_iterator itDescriptor = descriptor.begin(); while (itDescriptor != descriptor.end()) { data.SetElement(IndDescriptor, *itDescriptor); IndDescriptor++; itDescriptor++; } outputPointSet->SetPointData(m_NumberOfPoints, data); m_NumberOfPoints++; } ++it; ++itNeighPrev; ++itNeighNext; } /*End while for extremum search*/ } /*End Iteration over scales */ m_ImageList->Clear(); } /* End Key Points search*/ otbGenericMsgDebugMacro(<< "ImageToSURFKeyPointSetFilter:: Total Number of Key points " \ << m_NumberOfPoints); } /** End of GenerateData()*/ template int ImageToSURFKeyPointSetFilter ::GetMin(int a, int b, int c) { return std::min(a, std::min(b, c)); } /*----------------------------------------------------------- * Find Local Extremum -----------------------------------------------------------*/ template bool ImageToSURFKeyPointSetFilter ::IsLocalExtremum(const NeighborhoodType& neigh) { int centerIndex = neigh.GetCenterNeighborhoodIndex(), i = 0; double centerValue = neigh[centerIndex]; bool max = false, min = false; int flag_min = 0, flag_max = 0; while (i != (int) neigh.Size()) { if (i != centerIndex) { if (centerValue > neigh[i] && flag_max == 0) max = true; else { max = false; flag_max = 1; } if (centerValue < neigh[i] && flag_min == 0 && centerValue < 0) min = true; else { min = false; flag_min = 1; } } ++i; } return max || min; } /*----------------------------------------------------------- *Find Local Extremum Around -----------------------------------------------------------*/ template bool ImageToSURFKeyPointSetFilter ::IsLocalExtremumAround(const NeighborhoodType& neigh, double CenterValue) { int i = 0; bool max = false, min = false; int flag_min = 0, flag_max = 0; while (i != (int) neigh.Size()) { if (CenterValue > neigh[i] && flag_max == 0) max = true; else { max = false; flag_max = 1; } if (CenterValue < neigh[i] && flag_min == 0) min = true; else { min = false; flag_min = 1; } ++i; } return max || min; } /**---------------------------------------------------- * Refine location key point * TODO : adapt the interpolation to the type of extrema -----------------------------------------------------*/ template bool ImageToSURFKeyPointSetFilter ::RefineLocationKeyPoint(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale, const NeighborhoodIteratorType& nextScale, VectorPointType& solution) { bool accepted = true; solution = VectorPointType(PixelValue(0)); PixelValue dx = 0.5 * (currentScale.GetPixel(m_Offsets[6]) - currentScale.GetPixel(m_Offsets[1])); PixelValue dy = 0.5 * (currentScale.GetPixel(m_Offsets[4]) - currentScale.GetPixel(m_Offsets[3])); PixelValue ds = 0.5 * (nextScale.GetCenterPixel() - previousScale.GetCenterPixel()); PixelValue dxx = currentScale.GetPixel(m_Offsets[6]) - 2 * currentScale.GetCenterPixel() + currentScale.GetPixel(m_Offsets[1]); PixelValue dyy = currentScale.GetPixel(m_Offsets[3]) - 2 * currentScale.GetCenterPixel() + currentScale.GetPixel(m_Offsets[4]); PixelValue dss = previousScale.GetCenterPixel() - 2 * currentScale.GetCenterPixel() + nextScale.GetCenterPixel(); PixelValue dxy = 0.25 * (currentScale.GetPixel(m_Offsets[7]) + currentScale.GetPixel(m_Offsets[0]) - currentScale.GetPixel(m_Offsets[2]) - currentScale.GetPixel(m_Offsets[5])); PixelValue dxs = 0.25 * (nextScale.GetPixel(m_Offsets[6]) + previousScale.GetPixel(m_Offsets[1]) - nextScale.GetPixel(m_Offsets[1]) - previousScale.GetPixel(m_Offsets[6])); PixelValue dys = 0.25 * (nextScale.GetPixel(m_Offsets[4]) + previousScale.GetPixel(m_Offsets[3]) - nextScale.GetPixel(m_Offsets[3]) - previousScale.GetPixel(m_Offsets[4])); // We look for the "false" extrema : min-?-max and max-?-min // Those are not compatible with the 3D quadric interpolation PixelValue curr = currentScale.GetCenterPixel(); PixelValue prev = previousScale.GetCenterPixel(); PixelValue next = nextScale.GetCenterPixel(); if ((prev < curr && curr < next) || (next < curr && curr < prev)) { // So we use only 2D interpolation in the current scale dss = 1.0; dxs = 0.0; dys = 0.0; ds = 0.0; } // Compute matrice determinant double det = dxx * (dyy * dss - dys * dys) - dxy * (dxy * dss - dxs * dys) + dxs * (dxy * dys - dxs * dyy); // Solve system, compute key point offset solution[0] = -dx * (dyy * dss - dys * dys) - dy * (dxs * dys - dxy * dss) - ds * (dxy * dys - dyy * dxs); solution[1] = -dx * (dys * dxs - dss * dxy) - dy * (dxx * dss - dxs * dxs) - ds * (dxs * dxy - dxx * dys); solution[2] = -dx * (dxy * dys - dxs * dyy) - dy * (dxy * dxs - dxx * dys) - ds * (dxx * dyy - dxy * dxy); // Compute interpolated value Hessian Determinant for lSolution (determinant factor) PixelValue lDoHInterpolated = det * currentScale.GetCenterPixel() + 0.5 * (dx * solution[0] + dy * solution[1] + ds * solution[2]); // DoG threshold : ignore detected extrema if is not sufficiently noticeable accepted = vcl_abs(lDoHInterpolated) > vcl_abs(det * m_DoHThreshold); if (!accepted) { //++m_DiscardedKeyPoints; /* not used at the moment */ } if (det < 1.0E-10) // this test cancels the shift for every "weak" extrema { solution.Fill(0); } else { // normalize offset with determinant of derivative matrix solution /= det; } /* check that the translation found is inside a cubic pixel */ if (vcl_abs(static_cast(solution[0])) > 1.0 || vcl_abs(static_cast(solution[1])) > 1.0 || vcl_abs(static_cast(solution[2])) > 1.0) { accepted = false; //solution.Fill(0); } return accepted; } /*----------------------------------------------------------- * Compute the orientation of The KeyPoint -----------------------------------------------------------*/ template double ImageToSURFKeyPointSetFilter ::AssignOrientation(const NeighborhoodType& neigh, double S) { int i = 0; int pas = ((i + S) - (int) (i + S) > 0.5) ? ((int) S + 1) : (int) S; int Largeur = 2 * neigh.GetRadius()[0] + 1; // Width & length of a neighborhood int rayon = neigh.GetRadius()[0]; // radius of the neigh int col, raw; double dist; double w; // weight of the circular gaussian OutputPointType pt; // Gradient orientation histogram double angle; int bin = 0; int Pi = 180; int LengthBin = 60; int NbBins = (2 * Pi / LengthBin); std::vector tab(NbBins*2, 0.); while (i < (int) neigh.Size()) { col = i % Largeur - rayon; raw = i / Largeur - rayon; dist = vcl_sqrt(static_cast(col * col + raw * raw)); col += rayon; raw += rayon; // Backup to the image coordinate axes if (dist < 6 * S) { // Haar Wavelets responses accumulated in an histogram with Pi/3 precision if ((col > pas && col < Largeur - pas) && (raw > pas && raw < Largeur - pas)) { w = vcl_exp(-((col - rayon) * (col - rayon) + (raw - rayon) * (raw - rayon)) / (2 * 2.5 * 2.5 * S * S)); pt[0] = (neigh[(col + pas) + raw * Largeur] - neigh[(col - pas) + raw * Largeur]) * w; pt[1] = (neigh[col + (raw + pas) * Largeur] - neigh[col + (raw - pas) * Largeur]) * w; if (pt[0] + pt[1] != 0) { angle = atan(pt[0] / pt[1]) * (Pi / otb::CONST_PI); if (angle < 0) angle += 2 * Pi; bin = (int) (angle / LengthBin); if (bin <= NbBins - 1 || bin >= 0) { tab[2 * bin] += pt[0]; tab[2 * bin + 1] += pt[1]; } } } } i += pas; } //Find Orientation double indice = 0; double max = 0; double length = 0; // Detecting current point orientation for (int ii = 0; ii < NbBins * 2; ii = ii + 2) { length = vcl_sqrt(tab[ii] * tab[ii] + tab[ii + 1] * tab[ii + 1]); if (length > max) { max = length; indice = ii / 2; } } return (indice + 0.5) * LengthBin; } /*----------------------------------------------------------- * Compute the descriptor of The KeyPoint -----------------------------------------------------------*/ template typename ImageToSURFKeyPointSetFilter ::VectorType ImageToSURFKeyPointSetFilter ::ComputeDescriptor(const NeighborhoodType& neigh, double O, double S) { typedef itk::CenteredRigid2DTransform TransformType; TransformType::Pointer eulerTransform = TransformType::New(); TransformType::ParametersType ParamVec(5); PointImageType pSrc, pDst; double angle = O * otb::CONST_PI / 180; int i = 0, col, raw, Nbin, pas = 1; double xx = 0, yy = 0; double dx, dy, w; int Largeur = 2 * neigh.GetRadius()[0] + 1; double rayon = static_cast(Largeur) / 4.; double r = neigh.GetRadius()[0]; double dist = 0; double x0 = neigh.GetCenterNeighborhoodIndex() % Largeur; double y0 = neigh.GetCenterNeighborhoodIndex() / Largeur; //std::cout << " x0 " << x0 << " y0 " << y0 << angle << std::endl; VectorType descriptorVector; descriptorVector.resize(64); /** Parameters of the transformation*/ ParamVec[0] = angle; ParamVec[1] = x0; ParamVec[2] = y0; ParamVec[3] = 0; ParamVec[4] = 0; eulerTransform->SetParameters(ParamVec); while (i < (int) neigh.Size()) { col = i % Largeur; raw = i / Largeur; if ((col > pas && col < Largeur - pas) && (raw > pas && raw < Largeur - pas)) { double distanceX = (raw - r); double distanceY = (col - r); dist = vcl_sqrt(distanceX * distanceX + distanceY * distanceY); if (dist <= r) { /* Transform point to compensate the rotation the orientation */ pDst[0] = col; pDst[1] = raw; pSrc = eulerTransform->TransformPoint(pDst); /** New Coordinates (rotated) */ col = static_cast(vcl_floor(pSrc[0])); raw = static_cast(vcl_floor(pSrc[1])); if (raw == 0) raw = +1; if (col == 0) col += 1; xx = static_cast (pSrc[1] / rayon); yy = static_cast (pSrc[0] / rayon); Nbin = static_cast (xx + 4 * yy); if (Nbin < 16) //because 64 descriptor length { double distanceXcompensee_2 = (pSrc[0] - r) * (pSrc[0] - r); double distanceYcompensee_2 = (pSrc[1] - r) * (pSrc[1] - r); w = vcl_exp(-(distanceXcompensee_2 + distanceYcompensee_2) / (2 * 3.3 * 3.3 * S * S)); dx = 0.5 * (neigh[(col + pas) + raw * Largeur] - neigh[(col - pas) + raw * Largeur]) * w; dy = 0.5 * (neigh[col + (raw + pas) * Largeur] - neigh[col + (raw - pas) * Largeur]) * w; descriptorVector[4 * Nbin] += dx; descriptorVector[4 * Nbin + 1] += dy; descriptorVector[4 * Nbin + 2] += vcl_abs(dx); descriptorVector[4 * Nbin + 3] += vcl_abs(dy); } } } ++i; } double accu = 0; for (int ii = 0; ii < 64; ++ii) accu += descriptorVector[ii] * descriptorVector[ii]; for (int jj = 0; jj < 64; ++jj) descriptorVector[jj] /= vcl_sqrt(accu); return descriptorVector; } /*---------------------------------------------------------------- PrintSelf -----------------------------------------------------------------*/ template void ImageToSURFKeyPointSetFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Number of Key Points " << m_NumberOfPoints << std::endl; } } #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbKeyPointSetsMatchingFilter.h000066400000000000000000000121101301006202600304400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKeyPointSetsMatchingFilter_h #define otbKeyPointSetsMatchingFilter_h #include "otbObjectListSource.h" #include "otbLandmark.h" #include "itkEuclideanDistanceMetric.h" namespace otb { /** \class KeyPointSetsMatchingFilter * \brief This class matches two point sets according to their associated data. * * The matching criteria is that the ratio between the distance to the first nearest neighbor and the * second nearest neighbor is lower than the distance threshold. The distance used can be set via the TDistance * template parameters. It has to implement the Evaluate() method (see EuclideanDistanceMetric for more details). * * By default, the algorithm tries to match points from pointset 1 to points from pointset 2. If back matching is activated, * it will also try to match points from pointset 2 to points from pointset 2, and discard matches that do not appear both in * forward and backward matching. * * Matches are stored in a landmark object containing both matched points and point data. The landmark data will hold the distance value * between the data. * * \sa Landmark * \sa PointSet * \sa EuclideanDistanceMetric * * \ingroup OTBDescriptors */ template > class ITK_EXPORT KeyPointSetsMatchingFilter : public ObjectListSource > > { public: /// standard class typedefs typedef KeyPointSetsMatchingFilter Self; typedef ObjectListSource > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /// template typedefs typedef TPointSet PointSetType; typedef typename PointSetType::Pointer PointSetPointerType; typedef typename PointSetType::PointType PointType; typedef typename PointSetType::PixelType PointDataType; typedef typename PointSetType::PointsContainer PointsContainerType; typedef typename PointsContainerType::ConstIterator PointsIteratorType; typedef typename PointSetType::PointDataContainer PointDataContainerType; typedef typename PointDataContainerType::ConstIterator PointDataIteratorType; typedef TDistance DistanceType; typedef typename DistanceType::Pointer DistancePointerType; typedef Landmark LandmarkType; typedef typename LandmarkType::Pointer LandmarkPointerType; typedef ObjectList LandmarkListType; typedef typename LandmarkListType::Pointer LandmarkListPointerType; typedef std::pair NeighborSearchResultType; /// standard macros itkNewMacro(Self); itkTypeMacro(KeyPointSetsMatchingFilter, ObjectListSource); /// Accessors itkBooleanMacro(UseBackMatching); itkSetMacro(UseBackMatching, bool); itkGetMacro(UseBackMatching, bool); itkSetMacro(DistanceThreshold, double); itkGetMacro(DistanceThreshold, double); /// Set the first pointset void SetInput1(const PointSetType * pointset); /// Get the first pointset const PointSetType * GetInput1(); /// Set the second pointset void SetInput2(const PointSetType * pointset); /// Get the second pointset const PointSetType * GetInput2(); protected: /// Constructor KeyPointSetsMatchingFilter(); /// Destructor ~KeyPointSetsMatchingFilter() ITK_OVERRIDE {} /// PrintSelf method void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /// Generate Data void GenerateData() ITK_OVERRIDE; /** * Find the nearest neighbor of data1 in pointset. * \return a pair of (index, distance). */ NeighborSearchResultType NearestNeighbor(const PointDataType& data1, const PointSetType * pointset); private: KeyPointSetsMatchingFilter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented // Find back matches from 2 to 1 to validate them bool m_UseBackMatching; // Distance threshold to decide matching double m_DistanceThreshold; // Distance calculator DistancePointerType m_DistanceCalculator; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKeyPointSetsMatchingFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbKeyPointSetsMatchingFilter.txx000066400000000000000000000147511301006202600310510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKeyPointSetsMatchingFilter_txx #define otbKeyPointSetsMatchingFilter_txx #include "otbKeyPointSetsMatchingFilter.h" namespace otb { template KeyPointSetsMatchingFilter ::KeyPointSetsMatchingFilter() { this->SetNumberOfRequiredInputs(2); m_UseBackMatching = false; m_DistanceThreshold = 0.6; // Object used to measure distance m_DistanceCalculator = DistanceType::New(); } template const typename KeyPointSetsMatchingFilter ::PointSetType * KeyPointSetsMatchingFilter ::GetInput1() { return static_cast(this->itk::ProcessObject::GetInput(0)); } template void KeyPointSetsMatchingFilter ::SetInput1(const PointSetType * pointset) { this->itk::ProcessObject::SetNthInput(0, const_cast(pointset)); } template const typename KeyPointSetsMatchingFilter ::PointSetType * KeyPointSetsMatchingFilter ::GetInput2() { return static_cast(this->itk::ProcessObject::GetInput(1)); } template void KeyPointSetsMatchingFilter ::SetInput2(const PointSetType * pointset) { this->itk::ProcessObject::SetNthInput(1, const_cast(pointset)); } template void KeyPointSetsMatchingFilter ::GenerateData() { // std::cout<<"GenerateData()"<GetInput1(); const PointSetType * ps2 = this->GetInput2(); // Check if one of the pointsets is empty if (ps1->GetNumberOfPoints() == 0 || ps2->GetNumberOfPoints() == 0) { itkExceptionMacro(<< "Empty input pointset !"); } // Get the output pointer LandmarkListPointerType landmarks = this->GetOutput(); // Define iterators on points and point data. PointsIteratorType pIt = ps1->GetPoints()->Begin(); PointDataIteratorType pdIt = ps1->GetPointData()->Begin(); // iterate on pointset 1 while (pdIt != ps1->GetPointData()->End() && pIt != ps1->GetPoints()->End()) { // Get point and point data at current location bool matchFound = false; unsigned int currentIndex = pIt.Index(); PointDataType data = pdIt.Value(); PointType point = pIt.Value(); // These variables will hold the matched point and point data PointDataType dataMatch; PointType pointMatch; // call to the matching routine NeighborSearchResultType searchResult1 = NearestNeighbor(data, ps2); // Check if the neighbor distance is lower than the threshold if (searchResult1.second < m_DistanceThreshold) { // Get the matched point and point data dataMatch = ps2->GetPointData()->GetElement(searchResult1.first); pointMatch = ps2->GetPoints()->GetElement(searchResult1.first); // If the back matching option is on if (m_UseBackMatching) { // Peform the back search NeighborSearchResultType searchResult2 = NearestNeighbor(dataMatch, ps1); // Test if back search finds the same match if (currentIndex == searchResult2.first) { matchFound = true; } } else // else back matching { matchFound = true; } } // If we found a match, add the proper landmark if (matchFound) { LandmarkPointerType landmark = LandmarkType::New(); landmark->SetPoint1(point); landmark->SetPointData1(data); landmark->SetPoint2(pointMatch); landmark->SetPointData2(dataMatch); landmark->SetLandmarkData(searchResult1.second); // Add the new landmark to the landmark list landmarks->PushBack(landmark); } ++pdIt; ++pIt; } } template typename KeyPointSetsMatchingFilter::NeighborSearchResultType KeyPointSetsMatchingFilter ::NearestNeighbor(const PointDataType& data1, const PointSetType * pointset) { // std::cout<<"Call to NearestNeighbor()"<GetPointData()->Begin(); // local variables unsigned int nearestIndex = 0; double d1 = m_DistanceCalculator->Evaluate(data1, pdIt.Value()); ++pdIt; double d2 = m_DistanceCalculator->Evaluate(data1, pdIt.Value()); ++pdIt; if (d1 > d2) { nearestIndex = 1; } // Initialize distances double nearestDistance = std::min(d1, d2); double secondNearestDistance = std::max(d1, d2); double distanceValue; // iterate on the pointset while (pdIt != pointset->GetPointData()->End()) { // Evaluate the distance distanceValue = m_DistanceCalculator->Evaluate(data1, pdIt.Value()); // std::cout< void KeyPointSetsMatchingFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbLandmark.h000066400000000000000000000054271301006202600247640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLandmark_h #define otbLandmark_h #include "itkDataObject.h" #include "otbMacro.h" #include "itkObjectFactory.h" namespace otb { /** \class Landmark * \brief This class represent point and point data binary matching. * * It is used to represent match between keypoint like SIFT keypoint for instance. * * The class TLandmarkData can be used to store any information on the matching. * * \ingroup OTBDescriptors */ template class ITK_EXPORT Landmark : public itk::DataObject { public: /// standard class typedefs typedef Landmark Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /// Standard macros itkNewMacro(Self); itkTypeMacro(Landmark, DataObject); /// template typedefs typedef TPoint PointType; typedef TPointData PointDataType; typedef TLandmarkData LandmarkDataType; /// Accessors itkSetMacro(Point1, PointType); itkGetConstReferenceMacro(Point1, PointType); itkSetMacro(PointData1, PointDataType); itkGetConstReferenceMacro(PointData1, PointDataType); itkSetMacro(Point2, PointType); itkGetConstReferenceMacro(Point2, PointType); itkSetMacro(PointData2, PointDataType); itkGetConstReferenceMacro(PointData2, PointDataType); itkSetMacro(LandmarkData, LandmarkDataType); itkGetConstReferenceMacro(LandmarkData, LandmarkDataType); protected: /// Constructor Landmark() {} /// Destructor ~Landmark() ITK_OVERRIDE {} /// PrintSelf method void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << indent << "Landmark: P1= " << m_Point1 << " P2= " << m_Point2 << std::endl; } private: Landmark(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /// First landmark point PointType m_Point1; /// Second landmark point PointType m_Point2; /// First landmark point data PointDataType m_PointData1; /// Second landmark point data PointDataType m_PointData2; /// Landmark data LandmarkDataType m_LandmarkData; }; } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbSiftFastImageFilter.h000066400000000000000000000070721301006202600270650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSiftFastImageFilter_h #define otbSiftFastImageFilter_h #include "otbImageToPointSetFilter.h" #include "otbImage.h" namespace otb { /** \class SiftFastImageFilter * \brief This class extracts key points from an input image through a pyramidal decomposition * * This class implements the SIFT key point detector proposed by David G. Lowe in proceedings of International * Conference on Computer Vision, Corfu, september 1999. The * implementation used is provided by the external library libsiftfast * (http://sourceforge.net/projects/libsift/), * using the 1.2 release. * * The code has been slightly modified in order to allow the user to * tune the number of scales used in pyramidal decomposition. * * Please note that OTB provides also a home-brewed version of the * SIFT (ImageToSIFTKeyPointSetFilter). * * \sa ImageToSIFTKeyPointSetFilter * * \example Patented/SIFTFastExample.cxx * * \ingroup OTBDescriptors */ template class ITK_EXPORT SiftFastImageFilter : public ImageToPointSetFilter { public: /** Standard typedefs */ typedef SiftFastImageFilter Self; typedef ImageToPointSetFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(SiftFastImageFilter, ImageToPointSetFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename TInputImage::Pointer InputImagePointerType; typedef typename TInputImage::PixelType PixelType; typedef TOutputPointSet OutputPointSetType; typedef typename TOutputPointSet::Pointer OutputPointSetPointerType; typedef typename TOutputPointSet::PixelType OutputPixelType; typedef typename TOutputPointSet::PointType OutputPointType; typedef typename TOutputPointSet::PointIdentifier OutputPointIdentifierType; typedef otb::Image FloatImageType; typedef std::vector > OrientationVectorType; itkSetMacro(ScalesNumber, unsigned int); itkGetMacro(ScalesNumber, unsigned int); //Set/Get the Orientation of all KeyPoints OrientationVectorType GetOrientationVector() { return m_OrientationVector; } protected: /** Actually process the input */ void GenerateData() ITK_OVERRIDE; /** Constructor */ SiftFastImageFilter(); /** Destructor */ ~SiftFastImageFilter() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** The number of scales */ unsigned int m_ScalesNumber; OrientationVectorType m_OrientationVector; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSiftFastImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Descriptors/include/otbSiftFastImageFilter.txx000066400000000000000000000056661301006202600274700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSiftFastImageFilter_txx #define otbSiftFastImageFilter_txx #include "otbSiftFastImageFilter.h" #include "siftfast.h" #include "itkContinuousIndex.h" #include "itkImageRegionConstIterator.h" namespace otb { /** * Constructor */ template SiftFastImageFilter ::SiftFastImageFilter() : m_ScalesNumber(1) {} template void SiftFastImageFilter ::GenerateData() { // Get the input image pointer const InputImageType * inputPtr = this->GetInput(); OutputPointSetPointerType outputPointSet = this->GetOutput(); typename InputImageType::SizeType size = inputPtr->GetLargestPossibleRegion().GetSize(); SiftFastImage siftInputImage = CreateImage(size[1], size[0]); itk::ImageRegionConstIterator inIt(inputPtr, inputPtr->GetBufferedRegion()); unsigned int index = 0; for (inIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt) { siftInputImage->pixels[index] = static_cast(inIt.Get()); ++index; } Keypoint keypts = GetKeypoints(siftInputImage, m_ScalesNumber); Keypoint key = keypts; unsigned int numkeys = 0; while (key) { // Get the key location itk::ContinuousIndex keyContIndex; keyContIndex[0] = key->col; keyContIndex[1] = key->row; OutputPointType point; inputPtr->TransformContinuousIndexToPhysicalPoint(keyContIndex, point); // Get the key descriptor OutputPixelType data; data.SetSize(128); for (int i = 0; i < 128; ++i) { data[i] = key->descrip[i]; } outputPointSet->SetPoint(numkeys, point); outputPointSet->SetPointData(numkeys, data); //Fill the current point and its orientation std::pair pair; pair.first = point; pair.second = key->ori; m_OrientationVector.push_back(pair); //std::cout << " In SiftFastimageFilter : point " << point << " have orientation " << key->ori<< std::endl; // go to next key ++numkeys; key = key->next; } FreeKeypoints(keypts); DestroyAllResources(); } /* * PrintSelf Method */ template void SiftFastImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Feature/Descriptors/otb-module.cmake000066400000000000000000000011661301006202600237770ustar00rootroot00000000000000set(DOCUMENTATION "The output of a descriptor algorithm is usually a short vector of numbers which is invariant to common image transformations. Descriptors are then compared according to some criterion in order to be matched. This module contains different descriptors such as Fourrier-Mellin, SIFT, SURF, HOG, and so on.") otb_module(OTBDescriptors DEPENDS OTBCommon OTBITK OTBImageBase OTBObjectList OTBPointSet OTBTransform OPTIONAL_DEPENDS OTBSiftFast TEST_DEPENDS OTBImageIO OTBImageManipulation OTBInterpolation OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Feature/Descriptors/test/000077500000000000000000000000001301006202600217015ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/CMakeLists.txt000066400000000000000000000273131301006202600244470ustar00rootroot00000000000000otb_module_test() set(OTBDescriptorsTests otbDescriptorsTestDriver.cxx otbImageToSURFKeyPointSetFilterOutputDescriptorAscii.cxx otbKeyPointSetsMatchingFilterNew.cxx otbImageToSIFTKeyPointSetFilterOutputInterestPointAscii.cxx otbHistogramOfOrientedGradientCovariantImageFunction.cxx otbImageToSURFKeyPointSetFilterOutputInterestPointAscii.cxx otbImageToSURFKeyPointSetFilterNew.cxx otbLandmarkNew.cxx otbImageToSIFTKeyPointSetFilterNew.cxx otbKeyPointSetsMatchingFilter.cxx otbImageToSIFTKeyPointSetFilterOutputDescriptorAscii.cxx otbImageToSIFTKeyPointSetFilterOutputAscii.cxx otbFourierMellinImageFilter.cxx otbImageToHessianDeterminantImageFilter.cxx otbImageToSIFTKeyPointSetFilterOutputImage.cxx otbFourierMellinDescriptors.cxx otbImageToSIFTKeyPointSetFilterDistanceMap.cxx otbImageToHessianDeterminantImageFilterNew.cxx otbFourierMellinImageFilterNew.cxx ) if(OTB_USE_SIFTFAST) list(APPEND OTBDescriptorsTests otbImageToFastSIFTKeyPointSetFilterNew.cxx otbImageToFastSIFTKeyPointSetFilterOutputInterestPointAscii.cxx otbImageToFastSIFTKeyPointSetFilterOutputDescriptorAscii.cxx ) endif() add_executable(otbDescriptorsTestDriver ${OTBDescriptorsTests}) target_link_libraries(otbDescriptorsTestDriver ${OTBDescriptors-Test_LIBRARIES}) otb_module_target_label(otbDescriptorsTestDriver) # Tests Declaration otb_add_test(NAME feTvImageToSURFKeyPointSetFilterSceneOutputDescriptorAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSURFKeyPointSetFilterSceneKeysOutputDescriptor.txt ${TEMP}/feTvImageToSURFKeyPointSetFilterSceneKeysOutputDescriptor.txt otbImageToSURFKeyPointSetFilterOutputDescriptorAscii ${INPUTDATA}/scene.png ${TEMP}/feTvImageToSURFKeyPointSetFilterSceneKeysOutputDescriptor.txt 3 3 ) otb_add_test(NAME feTuKeyPointSetsMatchingFilterNew COMMAND otbDescriptorsTestDriver otbKeyPointSetsMatchingFilterNew) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterSceneOutputInterestPointAscii COMMAND otbDescriptorsTestDriver --ignore-order --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterSceneKeysOutputInterestPoint.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterSceneKeysOutputInterestPoint.txt otbImageToSIFTKeyPointSetFilterOutputInterestPointAscii ${INPUTDATA}/scene.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSceneKeysOutputInterestPoint.txt 6 3 0.08 10.0 ) otb_add_test(NAME feTuHistogramOfOrientedGradientCovariantImageFunction COMMAND otbDescriptorsTestDriver otbHistogramOfOrientedGradientCovariantImageFunctionNew) otb_add_test(NAME feTvHistogramOfOrientedGradientCovariantImageFunction COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_8} ${BASELINE_FILES}/feTvHistogramOfOrientedGradientCovariantImageFunction.txt ${TEMP}/feTvHistogramOfOrientedGradientCovariantImageFunction.txt otbHistogramOfOrientedGradientCovariantImageFunction ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/feTvHistogramOfOrientedGradientCovariantImageFunction.txt 5 273 64 ) otb_add_test(NAME feTvImageToSURFKeyPointSetFilterSceneOutputInterestPointAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSURFKeyPointSetFilterSceneKeysOutputInterestPoint.txt ${TEMP}/feTvImageToSURFKeyPointSetFilterSceneKeysOutputInterestPoint.txt otbImageToSURFKeyPointSetFilterOutputInterestPointAscii ${INPUTDATA}/scene.png ${TEMP}/feTvImageToSURFKeyPointSetFilterSceneKeysOutputInterestPoint.txt 3 3 ) otb_add_test(NAME feTuImageToSURFKeyPointSetFilterNew COMMAND otbDescriptorsTestDriver otbImageToSURFKeyPointSetFilterNew) otb_add_test(NAME feTuLandmarkNew COMMAND otbDescriptorsTestDriver otbLandmarkNew) otb_add_test(NAME feTuImageToSIFTKeyPointSetFilterNew COMMAND otbDescriptorsTestDriver otbImageToSIFTKeyPointSetFilterNew) otb_add_test(NAME feTvKeyPointSetsMatchingFilter COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvKeyPointSetsMatchingFilterOutputAscii.txt ${TEMP}/feTvKeyPointSetsMatchingFilterOutputAscii.txt otbKeyPointSetsMatchingFilter ${TEMP}/feTvKeyPointSetsMatchingFilterOutputAscii.txt 0.6 0 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterSceneDescriptorAscii COMMAND otbDescriptorsTestDriver --ignore-order --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterSceneKeysOutputDescriptor.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterSceneKeysOutputDescriptor.txt otbImageToSIFTKeyPointSetFilterOutputDescriptorAscii ${INPUTDATA}/scene.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSceneKeysOutputDescriptor.txt 6 3 0.08 10.0 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterGridOutputAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterGridKeysOutput.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterGridKeysOutput.txt otbImageToSIFTKeyPointSetFilterOutputAscii ${INPUTDATA}/damier.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterGridKeysOutput.txt 7 3 0.01 10.0 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterSquareRotatedOutputAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterSquareRotatedKeysOutput.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareRotatedKeysOutput.txt otbImageToSIFTKeyPointSetFilterOutputAscii ${INPUTDATA}/carre_ori.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareRotatedKeysOutput.txt 7 3 0.01 10.0 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterSquare2OutputAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterSquareKeysOutput2.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareKeysOutput2.txt otbImageToSIFTKeyPointSetFilterOutputAscii ${INPUTDATA}/carre.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareKeysOutput2.txt 1 3 0.2 0.9 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterSquareRotated2OutputAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterSquareRotatedKeysOutput2.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareRotatedKeysOutput2.txt otbImageToSIFTKeyPointSetFilterOutputAscii ${INPUTDATA}/carre_ori.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareRotatedKeysOutput2.txt 1 3 0.215 10.0 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterSquareOutputAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterSquareKeysOutput.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareKeysOutput.txt otbImageToSIFTKeyPointSetFilterOutputAscii ${INPUTDATA}/carre.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareKeysOutput.txt 7 3 0.01 10.0 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterQB_SuburbOutputAscii COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterQB_SuburbOutputAscii.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterQB_SuburbOutputAscii.txt otbImageToSIFTKeyPointSetFilterOutputAscii ${INPUTDATA}/QB_Suburb.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterQB_SuburbOutputAscii.txt 2 3 5.0 0.0 ) otb_add_test(NAME feTvForwardFourierMellinImageFilter COMMAND otbDescriptorsTestDriver --compare-n-images ${EPSILON_6} 2 ${BASELINE}/feForwardFourierMellinImageFilterReal.hdr ${TEMP}/feForwardFourierMellinImageFilterReal.hdr ${BASELINE}/feForwardFourierMellinImageFilterImag.hdr ${TEMP}/feForwardFourierMellinImageFilterImag.hdr otbFourierMellinImageFilter ${INPUTDATA}/circle.hdr ${TEMP}/feForwardFourierMellinImageFilterReal.hdr ${TEMP}/feForwardFourierMellinImageFilterImag.hdr) otb_add_test(NAME feTvImageToHessianDeterminantImageFilter COMMAND otbDescriptorsTestDriver --compare-image ${EPSILON_3} ${BASELINE}/feTvImageToHessianDeterminantImageFilterOutput.tif ${TEMP}/feTvImageToHessianDeterminantImageFilterOutput.tif otbImageToHessianDeterminantImageFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub.tif ${TEMP}/feTvImageToHessianDeterminantImageFilterOutput.tif 1.5 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterSquareOutputImage COMMAND otbDescriptorsTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvImageToSIFTKeyPointSetFilterSquareImageOutput.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareImageOutput.png otbImageToSIFTKeyPointSetFilterOutputImage ${INPUTDATA}/carre.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterSquareImageOutput.png 7 3 0.01 10.0 ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterGridOutputImage COMMAND otbDescriptorsTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvImageToSIFTKeyPointSetFilterGridImageOutput.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterGridImageOutput.png otbImageToSIFTKeyPointSetFilterOutputImage ${INPUTDATA}/damier.png ${TEMP}/feTvImageToSIFTKeyPointSetFilterGridImageOutput.png 7 3 0.01 10.0 ) otb_add_test(NAME feTvFourierMellinDescriptorsRotationInvariant COMMAND otbDescriptorsTestDriver otbFourierMellinDescriptorsRotationInvariant ${INPUTDATA}/poupees.png 4 4 90 ) otb_add_test(NAME feTuFourierMellinDescriptorsNew COMMAND otbDescriptorsTestDriver otbFourierMellinDescriptorsNew ) otb_add_test(NAME feTvFourierMellinDescriptorsScaleInvariant COMMAND otbDescriptorsTestDriver otbFourierMellinDescriptorsScaleInvariant ${INPUTDATA}/poupees.png 4 4 ) otb_add_test(NAME feTvFourierMellinDescriptors COMMAND otbDescriptorsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feTvFourierMellinDescriptors.txt ${TEMP}/feTvFourierMellinDescriptors.txt otbFourierMellinDescriptors ${INPUTDATA}/poupees.png 4 4 ${TEMP}/feTvFourierMellinDescriptors.txt ) otb_add_test(NAME feTvImageToSIFTKeyPointSetFilterDistanceMap COMMAND otbDescriptorsTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToSIFTKeyPointSetFilterDistanceMap.txt ${TEMP}/feTvImageToSIFTKeyPointSetFilterDistanceMap.txt otbImageToSIFTKeyPointSetFilterDistanceMap ${INPUTDATA}/scene.png 6 3 0.08 10.0 15.0 # rotation 1.2 # zoom factor 10 255 ${TEMP}/feTvImageToSIFTKeyPointSetFilterDistanceMap.txt ) otb_add_test(NAME feTuImageToHessianDeterminantImageFilterNew COMMAND otbDescriptorsTestDriver otbImageToHessianDeterminantImageFilterNew) otb_add_test(NAME feTuForwardFourierMellinImageFilterNew COMMAND otbDescriptorsTestDriver otbFourierMellinImageFilterNew) if(OTB_USE_SIFTFAST) otb_add_test(NAME feTuImageToFastSIFTKeyPointSetFilterNew COMMAND otbDescriptorsTestDriver otbImageToFastSIFTKeyPointSetFilterNew) otb_add_test(NAME feTvImageToFastSIFTKeyPointSetFilterSceneOutputInterestPointAscii COMMAND otbDescriptorsTestDriver --ignore-order --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvImageToFastSIFTKeyPointSetFilterSceneKeysOutputInterestPoint.txt ${TEMP}/feTvImageToFastSIFTKeyPointSetFilterSceneKeysOutputInterestPoint.txt otbImageToFastSIFTKeyPointSetFilterOutputInterestPointAscii ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub.tif ${TEMP}/feTvImageToFastSIFTKeyPointSetFilterSceneKeysOutputInterestPoint.txt 6 ) # RK: 06/2016. the root cause of this test having different output on platforms comes from libsiftfast (3rd party code) # Until there is a fix, that failure cannot be attributed to OTB or dashboard results # --ignore-order --epsilon-boundary 0.01 --compare-ascii ${EPSILON_2} # ${BASELINE_FILES}/feTvImageToFastSIFTKeyPointSetFilterSceneKeysOutputDescriptor.txt # ${TEMP}/feTvImageToFastSIFTKeyPointSetFilterSceneKeysOutputDescriptor.txt otb_add_test(NAME feTvImageToFastSIFTKeyPointSetFilterSceneOutputDescriptorAscii COMMAND otbDescriptorsTestDriver otbImageToFastSIFTKeyPointSetFilterOutputDescriptorAscii ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub.tif ${TEMP}/feTvImageToFastSIFTKeyPointSetFilterSceneKeysOutputDescriptor.txt 6 ) endif() OTB-release-5.8/Modules/Feature/Descriptors/test/otbDescriptorsTestDriver.cxx000066400000000000000000000030531301006202600274500ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbImageToSURFKeyPointSetFilterOutputDescriptorAscii); REGISTER_TEST(otbKeyPointSetsMatchingFilterNew); REGISTER_TEST(otbImageToSIFTKeyPointSetFilterOutputInterestPointAscii); REGISTER_TEST(otbHistogramOfOrientedGradientCovariantImageFunctionNew); REGISTER_TEST(otbHistogramOfOrientedGradientCovariantImageFunction); REGISTER_TEST(otbImageToSURFKeyPointSetFilterOutputInterestPointAscii); REGISTER_TEST(otbImageToSURFKeyPointSetFilterNew); REGISTER_TEST(otbLandmarkNew); REGISTER_TEST(otbImageToSIFTKeyPointSetFilterNew); REGISTER_TEST(otbKeyPointSetsMatchingFilter); REGISTER_TEST(otbImageToSIFTKeyPointSetFilterOutputDescriptorAscii); REGISTER_TEST(otbImageToSIFTKeyPointSetFilterOutputAscii); REGISTER_TEST(otbFourierMellinImageFilter); REGISTER_TEST(otbImageToHessianDeterminantImageFilter); REGISTER_TEST(otbImageToSIFTKeyPointSetFilterOutputImage); REGISTER_TEST(otbFourierMellinDescriptorsNew); REGISTER_TEST(otbFourierMellinDescriptors); REGISTER_TEST(otbFourierMellinDescriptorsScaleInvariant); REGISTER_TEST(otbFourierMellinDescriptorsRotationInvariant); REGISTER_TEST(otbImageToSIFTKeyPointSetFilterDistanceMap); REGISTER_TEST(otbImageToHessianDeterminantImageFilterNew); REGISTER_TEST(otbFourierMellinImageFilterNew); #ifdef OTB_USE_SIFTFAST REGISTER_TEST(otbImageToFastSIFTKeyPointSetFilterNew); REGISTER_TEST(otbImageToFastSIFTKeyPointSetFilterOutputInterestPointAscii); REGISTER_TEST(otbImageToFastSIFTKeyPointSetFilterOutputDescriptorAscii); #endif } OTB-release-5.8/Modules/Feature/Descriptors/test/otbFourierMellinDescriptors.cxx000066400000000000000000000235051301006202600301350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkMacro.h" #include "otbFourierMellinDescriptorsImageFunction.h" #include "otbImageFileReader.h" #include "otbBCOInterpolateImageFunction.h" #include "otbStreamingResampleImageFilter.h" #include "itkResampleImageFilter.h" #include "itkAffineTransform.h" int otbFourierMellinDescriptorsNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::Image ImageType; typedef otb::FourierMellinDescriptorsImageFunction FunctionType; // Instantiating object FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } int otbFourierMellinDescriptors(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; unsigned int p((unsigned int) ::atoi(argv[2])); unsigned int q((unsigned int) ::atoi(argv[3])); const char * outputFilename = argv[4]; typedef double PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::FourierMellinDescriptorsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer function = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); function->SetInputImage(reader->GetOutput()); function->SetQmax(q); function->SetPmax(p); ImageType::IndexType index; index[0] = 256; index[1] = 256; function->SetNeighborhoodRadius(3); OutputType Result = function->EvaluateAtIndex(index); std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10); for (unsigned int k=0; k<=p; ++k) { for (unsigned int l=0; l<=q; ++l) { outputStream << "FMDescriptor |M(" << k << l << ")| : " << Result.at(k).at(l) << std::endl; } } outputStream.close(); return EXIT_SUCCESS; } int otbFourierMellinDescriptorsScaleInvariant(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; unsigned int p((unsigned int) ::atoi(argv[2])); unsigned int q((unsigned int) ::atoi(argv[3])); typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::FourierMellinDescriptorsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(2); interpolator->SetAlpha(-0.5); resampler->SetInput(reader->GetOutput()); resampler->SetInterpolator(interpolator); StreamingResampleImageFilterType::SizeType size; size[0] = 1024; size[1] = 1024; resampler->SetOutputSize(size); resampler->SetOutputSpacing(0.5); resampler->Update(); function1->SetInputImage(reader->GetOutput()); function1->SetQmax(q); function1->SetPmax(p); InputImageType::IndexType index1; index1[0] = 148; index1[1] = 248; function1->SetNeighborhoodRadius(3); OutputType Result1 = function1->EvaluateAtIndex(index1); function2->SetInputImage(resampler->GetOutput()); function2->SetQmax(q); function2->SetPmax(p); InputImageType::IndexType index2; index2[0] = 296; index2[1] = 496; function2->SetNeighborhoodRadius(6); OutputType Result2 = function2->EvaluateAtIndex(index2); double error = 0.0; for (unsigned int k=0; k<=p; ++k) { for (unsigned int l=0; l<=q; ++l) { error += vcl_pow(vcl_abs( Result1.at(k).at(l) - Result2.at(k).at(l) ), 2); std::cout << "Original - D" << k << l << " : " << Result1.at(k).at(l) << " / Scaled - D" << k << l << " : " << Result2.at(k).at(l) << std::endl; } } error = vcl_sqrt(error)/(q+p); std::cout << "Error : " << error << std::endl << std::endl; if (error > 1E-2) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-2 -> TEST FAILLED" << std::endl ); } return EXIT_SUCCESS; } int otbFourierMellinDescriptorsRotationInvariant(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; unsigned int p((unsigned int) ::atoi(argv[2])); unsigned int q((unsigned int) ::atoi(argv[3])); const double angleInDegrees = atoi(argv[4]); typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ResampleImageFilter< InputImageType, InputImageType > FilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::FourierMellinDescriptorsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; typedef itk::AffineTransform< InputPixelType, Dimension > TransformType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); TransformType::Pointer transform = TransformType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(2); interpolator->SetAlpha(-0.5); filter->SetInterpolator(interpolator); filter->SetDefaultPixelValue( 100 ); const InputImageType::SpacingType & spacing = reader->GetOutput()->GetSpacing(); const InputImageType::PointType & origin = reader->GetOutput()->GetOrigin(); InputImageType::SizeType size = reader->GetOutput()->GetLargestPossibleRegion().GetSize(); filter->SetOutputOrigin( origin ); filter->SetOutputSpacing( spacing ); filter->SetOutputDirection( reader->GetOutput()->GetDirection() ); filter->SetSize( size ); filter->SetInput(reader->GetOutput()); TransformType::OutputVectorType translation1; const double imageCenterX = origin[0] + spacing[0] * size[0] / 2.0; const double imageCenterY = origin[1] + spacing[1] * size[1] / 2.0; translation1[0] = -imageCenterX; translation1[1] = -imageCenterY; transform->Translate( translation1 ); const double degreesToRadians = vcl_atan(1.0) / 45.0; const double angle = angleInDegrees * degreesToRadians; transform->Rotate2D( -angle, false ); TransformType::OutputVectorType translation2; translation2[0] = imageCenterX; translation2[1] = imageCenterY; transform->Translate( translation2, false ); filter->SetTransform( transform ); filter->Update(); function1->SetInputImage(reader->GetOutput()); InputImageType::IndexType index1; index1[0] = 256; index1[1] = 256; function1->SetNeighborhoodRadius(4); function1->SetQmax(q); function1->SetPmax(p); OutputType Result1 = function1->EvaluateAtIndex(index1); function2->SetInputImage(filter->GetOutput()); InputImageType::IndexType index2; index2[0] = 256; index2[1] = 256; function2->SetNeighborhoodRadius(4); function2->SetQmax(q); function2->SetPmax(p); OutputType Result2 = function2->EvaluateAtIndex(index2); double error = 0.0; for (unsigned int k=0; k<=p; ++k) { for (unsigned int l=0; l<=q; ++l) { error += vcl_pow(vcl_abs( Result1.at(k).at(l) - Result2.at(k).at(l) ), 2); std::cout << "Original - D" << k << l << " : " << Result1.at(k).at(l) << " / Rotated - D" << k << l << " : " << Result2.at(k).at(l) << std::endl; } } error = vcl_sqrt(error)/(q+p); std::cout << "Error : " << error << std::endl << std::endl; if (error > 1E-3) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-3 -> TEST FAILLED" << std::endl ); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbFourierMellinImageFilter.cxx000066400000000000000000000067111301006202600300240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbForwardFourierMellinTransformImageFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkLinearInterpolateImageFunction.h" #include "itkComplexToImaginaryImageFilter.h" #include "itkComplexToRealImageFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" #include "itkRescaleIntensityImageFilter.h" int otbFourierMellinImageFilter(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputRealFilename = argv[2]; const char * outputImaginaryFilename = argv[3]; typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::ForwardFourierMellinTransformImageFilter FourierMellinTransformType; typedef FourierMellinTransformType::OutputImageType OutputImageType; typedef itk::ComplexToRealImageFilter RealFilterType; typedef itk::ComplexToImaginaryImageFilter ImaginaryFilterType; typedef itk::RescaleIntensityImageFilter RescalerType; FourierMellinTransformType::Pointer FourierMellinTransform = FourierMellinTransformType::New(); RealFilterType::Pointer real = RealFilterType::New(); ImaginaryFilterType::Pointer imaginary = ImaginaryFilterType::New(); RescalerType::Pointer realRescaler = RescalerType::New(); RescalerType::Pointer imaginaryRescaler = RescalerType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer realWriter = WriterType::New(); WriterType::Pointer imaginaryWriter = WriterType::New(); reader->SetFileName(inputFilename); realWriter->SetFileName(outputRealFilename); imaginaryWriter->SetFileName(outputImaginaryFilename); OutputImageType::SizeType size; size[0] = 512; size[1] = 256; FourierMellinTransform->SetInput(reader->GetOutput()); FourierMellinTransform->SetOutputSize(size); real->SetInput(FourierMellinTransform->GetOutput()); realRescaler->SetInput(real->GetOutput()); realRescaler->SetOutputMinimum(-1); realRescaler->SetOutputMaximum(1); realWriter->SetInput(realRescaler->GetOutput()); realWriter->Update(); imaginary->SetInput(FourierMellinTransform->GetOutput()); imaginaryRescaler->SetInput(imaginary->GetOutput()); imaginaryRescaler->SetOutputMinimum(-1); imaginaryRescaler->SetOutputMaximum(1); imaginaryWriter->SetInput(imaginaryRescaler->GetOutput()); imaginaryWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbFourierMellinImageFilterNew.cxx000066400000000000000000000022601301006202600304710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbForwardFourierMellinTransformImageFilter.h" int otbFourierMellinImageFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::ForwardFourierMellinTransformImageFilter FourierMellinTransformType; FourierMellinTransformType::Pointer filter = FourierMellinTransformType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbHistogramOfOrientedGradientCovariantImageFunction.cxx000066400000000000000000000050771301006202600347760ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "itkGradientImageFilter.h" #include "otbHistogramOfOrientedGradientCovariantImageFunction.h" typedef unsigned short ShortPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef itk::GradientImageFilter GradientFilterType; typedef GradientFilterType::OutputImageType CovariantImageType; typedef otb::HistogramOfOrientedGradientCovariantImageFunction FunctionType; int otbHistogramOfOrientedGradientCovariantImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiating object FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } int otbHistogramOfOrientedGradientCovariantImageFunction(int itkNotUsed(argc), char * argv[]) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); GradientFilterType::Pointer gradient = GradientFilterType::New(); gradient->SetInput(reader->GetOutput()); gradient->SetUseImageSpacing(false); gradient->Update(); // Instantiating object FunctionType::Pointer function = FunctionType::New(); function->SetInputImage(gradient->GetOutput()); InputImageType::IndexType index; unsigned int radius = atoi(argv[3]); index[0] = atoi(argv[4]); index[1] = atoi(argv[5]); function->SetNeighborhoodRadius(radius); FunctionType::OutputType value = function->EvaluateAtIndex(index); std::ofstream ofs(argv[2]); for(unsigned i = 0; i < 5; ++i) { for(unsigned j = 0; jGetNumberOfOrientationBins(); ++j) { ofs< ImageType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::SiftFastImageFilter ImageToFastSIFTKeyPointSetFilterType; // Instantiating object ImageToFastSIFTKeyPointSetFilterType::Pointer filter = ImageToFastSIFTKeyPointSetFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbImageToFastSIFTKeyPointSetFilterOutputDescriptorAscii.cxx000066400000000000000000000102411301006202600354400ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include #include "otbSiftFastImageFilter.h" #include "otbImageFileReader.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" bool CMPData(std::vector a, std::vector b) { return lexicographical_compare(a.begin(), a.begin() + 2, b.begin(), b.begin() + 2); } int otbImageToFastSIFTKeyPointSetFilterOutputDescriptorAscii(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int scales = atoi(argv[3]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::SiftFastImageFilter ImageToFastSIFTKeyPointSetFilterType; // Iterator types typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; typedef PointSetType::PointDataContainer PointDataContainerType; typedef PointDataContainerType::Iterator PointDataIteratorType; typedef std::vector siftDataVector; typedef std::vector ImageDataType; //Kind of PointSet with vectors // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToFastSIFTKeyPointSetFilterType::Pointer filter = ImageToFastSIFTKeyPointSetFilterType::New(); //Instantiation of std::vector for lexicographiacal sorting ImageDataType imageData; reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetScalesNumber(scales); filter->Update(); PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); PointDataIteratorType pDataIt = filter->GetOutput()->GetPointData()->Begin(); std::ofstream outfile(outfname); outfile << "Number of scales: " << scales << std::endl; outfile << "Number of SIFT key points: " << filter->GetOutput()->GetNumberOfPoints() << std::endl; if (filter->GetOutput()->GetPointData()->Size() != filter->GetOutput()->GetPoints()->Size()) return EXIT_FAILURE; if (filter->GetOutput()->GetPointData()->Size() == 0) return EXIT_FAILURE; // Copy the PointSet to std::vector< std::vector > while (pIt != filter->GetOutput()->GetPoints()->End() && pDataIt != filter->GetOutput()->GetPointData()->End()) { siftDataVector siftData; siftData.push_back(pIt.Value()[0]); siftData.push_back(pIt.Value()[1]); unsigned int lIterDesc = 0; while (lIterDesc < pDataIt.Value().Size()) { siftData.push_back(pDataIt.Value()[lIterDesc]); lIterDesc++; } imageData.push_back(siftData); ++pIt; ++pDataIt; } //Sorting the vectors ImageDataType::iterator itData; sort(imageData.begin(), imageData.end(), CMPData); itData = imageData.begin(); unsigned int stopVal = static_cast(filter->GetOutput()->GetPointData()->Begin().Value().Size()); while (itData != imageData.end()) { unsigned int itDescriptor = 0; outfile << "[ "; while (itDescriptor < stopVal) //while (itDescriptor < static_cast((*itData).size()-2) ) { outfile << std::fixed << std::setprecision(4) << (*itData)[itDescriptor + 2] << " "; itDescriptor++; } outfile << "]" << std::endl; ++itData; } outfile.close(); return EXIT_SUCCESS; } otbImageToFastSIFTKeyPointSetFilterOutputInterestPointAscii.cxx000066400000000000000000000072071301006202600361410ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include #include "otbSiftFastImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" bool CMP(std::vector a, std::vector b) { return lexicographical_compare(a.begin(), a.begin() + 2, b.begin(), b.begin() + 2); } int otbImageToFastSIFTKeyPointSetFilterOutputInterestPointAscii(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int scales = atoi(argv[3]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::SiftFastImageFilter ImageToFastSIFTKeyPointSetFilterType; // PointSet iterator types typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; typedef PointSetType::PointDataContainer PointDataContainerType; typedef PointDataContainerType::Iterator PointDataIteratorType; typedef std::vector siftDataVector; typedef std::vector ImageDataType; //Kind of PointSet with vectors // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToFastSIFTKeyPointSetFilterType::Pointer filter = ImageToFastSIFTKeyPointSetFilterType::New(); //Instantiation of std::vector for lexicographiacal sorting ImageDataType imageData; reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetScalesNumber(scales); filter->Update(); PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); PointDataIteratorType pDataIt = filter->GetOutput()->GetPointData()->Begin(); std::ofstream outfile(outfname); outfile << "Number of scales: " << scales << std::endl; outfile << "Number of SIFT key points: " << filter->GetOutput()->GetNumberOfPoints() << std::endl; // Copy the PointSet to std::vector< std::vector > while (pIt != filter->GetOutput()->GetPoints()->End()) { siftDataVector siftData; siftData.push_back(pIt.Value()[0]); siftData.push_back(pIt.Value()[1]); unsigned int lIterDesc = 0; while (lIterDesc < pDataIt.Value().Size()) { siftData.push_back(pDataIt.Value()[lIterDesc]); lIterDesc++; } imageData.push_back(siftData); ++pIt; ++pDataIt; } //Sorting the vectors ImageDataType::iterator itData; sort(imageData.begin(), imageData.end(), CMP); itData = imageData.begin(); while (itData != imageData.end()) { outfile << "[" << std::fixed << std::setprecision(1) << (*itData)[0] << ", " << std::setprecision(1) << (*itData)[1] << "]" << std::endl; ++itData; } outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbImageToHessianDeterminantImageFilter.cxx000066400000000000000000000033701301006202600323010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToHessianDeterminantImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageToHessianDeterminantImageFilter(int itkNotUsed(argc), char * argv[]) { const char * ifname = argv[1]; const char * outfname = argv[2]; const double sigma = atof(argv[3]); const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageToHessianDeterminantImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(ifname); filter->SetInput(reader->GetOutput()); filter->SetSigma(sigma); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbImageToHessianDeterminantImageFilterNew.cxx000066400000000000000000000022151301006202600327500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToHessianDeterminantImageFilter.h" int otbImageToHessianDeterminantImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageToHessianDeterminantImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbImageToSIFTKeyPointSetFilterDistanceMap.cxx000066400000000000000000000307211301006202600325660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itkUnaryFunctorImageFilter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkResampleImageFilter.h" #include "itkDanielssonDistanceMapImageFilter.h" #include "itkPointSetToImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageToSIFTKeyPointSetFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkAffineTransform.h" typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::Image ImageType; typedef otb::Image OutputImageType; // PointSet iterator types typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; typedef PointSetType::PointDataContainer PointDataContainerType; typedef PointDataContainerType::Iterator PointDataIteratorType; // Filter typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter WriterInputType; OutputImageType::Pointer sift(ImageType::Pointer input, const unsigned int octaves, const unsigned int scales, const float threshold, const float ratio, const char* siftFileName) { typedef otb::ImageToSIFTKeyPointSetFilter SiftFilterType; typedef itk::PointSetToImageFilter PointSetFilterType; SiftFilterType::Pointer sift = SiftFilterType::New(); PointSetFilterType::Pointer pointSetFilter = PointSetFilterType::New(); sift->SetInput(input); sift->SetOctavesNumber(octaves); sift->SetScalesNumber(scales); sift->SetDoGThreshold(threshold); sift->SetEdgeThreshold(ratio); pointSetFilter->SetInput(sift->GetOutput()); pointSetFilter->SetOutsideValue(0); pointSetFilter->SetInsideValue(255); pointSetFilter->SetSize(input->GetLargestPossibleRegion().GetSize()); pointSetFilter->SetSpacing(input->GetSpacing()); pointSetFilter->SetOrigin(input->GetOrigin()); pointSetFilter->Update(); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(siftFileName); writer->SetInput(pointSetFilter->GetOutput()); //writer->Update(); return pointSetFilter->GetOutput(); } OutputImageType::Pointer ddm(OutputImageType::Pointer input, const char* ddmFileName) { typedef itk::DanielssonDistanceMapImageFilter DDMFilterType; DDMFilterType::Pointer ddmFilter = DDMFilterType::New(); ddmFilter->SetInput(input); ddmFilter->InputIsBinaryOn(); ddmFilter->Update(); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(ddmFileName); writer->SetInput(ddmFilter->GetOutput()); //writer->Update(); return ddmFilter->GetOutput(); } ImageType::Pointer rotate(ImageType::Pointer input, const unsigned int rotation) { typedef itk::AffineTransform TransformType; typedef itk::ResampleImageFilter ResampleFilterType; ResampleFilterType::Pointer resampler = ResampleFilterType::New(); TransformType::Pointer transform = TransformType::New(); TransformType::OutputVectorType translation1; TransformType::OutputVectorType translation2; const ImageType::SpacingType& spacing = input->GetSpacing(); const ImageType::PointType& origin = input->GetOrigin(); ImageType::SizeType size = input->GetLargestPossibleRegion().GetSize(); const double imageCenterX = origin[0] + spacing[0] * size[0] / 2.0; const double imageCenterY = origin[1] + spacing[1] * size[1] / 2.0; const double degreesToRadians = atan(1.0) / 45.0; const double angle = rotation * degreesToRadians; translation1[0] = -imageCenterX; translation1[1] = -imageCenterY; translation2[0] = imageCenterX; translation2[1] = imageCenterY; transform->Translate(translation1); transform->Rotate2D(-angle, false); transform->Translate(translation2); resampler->SetOutputOrigin(origin); resampler->SetOutputSpacing(spacing); resampler->SetSize(size); resampler->SetTransform(transform); resampler->SetInput(input); resampler->Update(); return resampler->GetOutput(); } OutputImageType::Pointer invRotate(OutputImageType::Pointer input, const unsigned int rotation) { typedef itk::AffineTransform TransformType; typedef itk::ResampleImageFilter ResampleFilterType; ResampleFilterType::Pointer resampler = ResampleFilterType::New(); TransformType::Pointer transform = TransformType::New(); TransformType::OutputVectorType translation1; TransformType::OutputVectorType translation2; const ImageType::SpacingType& spacing = input->GetSpacing(); const ImageType::PointType& origin = input->GetOrigin(); ImageType::SizeType size = input->GetLargestPossibleRegion().GetSize(); const double imageCenterX = origin[0] + spacing[0] * size[0] / 2.0; const double imageCenterY = origin[1] + spacing[1] * size[1] / 2.0; const double degreesToRadians = atan(1.0) / 45.0; const double angle = rotation * degreesToRadians; translation1[0] = -imageCenterX; translation1[1] = -imageCenterY; translation2[0] = imageCenterX; translation2[1] = imageCenterY; transform->Translate(translation1); transform->Rotate2D(angle, false); transform->Translate(translation2); resampler->SetOutputOrigin(origin); resampler->SetOutputSpacing(spacing); resampler->SetSize(size); resampler->SetTransform(transform); resampler->SetInput(input); resampler->Update(); return resampler->GetOutput(); } ImageType::Pointer zoom(ImageType::Pointer input, const unsigned int zoomFactor) { typedef itk::ShrinkImageFilter ShrinkFilterType; ShrinkFilterType::Pointer shrink = ShrinkFilterType::New(); shrink->SetInput(input); shrink->SetShrinkFactors(zoomFactor); shrink->Update(); return shrink->GetOutput(); } OutputImageType::Pointer invZoom(OutputImageType::Pointer input, const unsigned int zoomFactor) { typedef itk::ExpandImageFilter ExpandFilterType; ExpandFilterType::Pointer expand = ExpandFilterType::New(); expand->SetInput(input); expand->SetExpandFactors(zoomFactor); expand->Update(); return expand->GetOutput(); } ImageType::Pointer contrast(ImageType::Pointer input, const unsigned int contrastMin, const unsigned int contrastMax) { typedef itk::RescaleIntensityImageFilter RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetInput(input); rescaler->SetOutputMinimum(static_cast(contrastMin)); rescaler->SetOutputMaximum(static_cast(contrastMax)); rescaler->Update(); return rescaler->GetOutput(); } OutputImageType::Pointer invContrast(OutputImageType::Pointer input, const unsigned int itkNotUsed(contrastMin), const unsigned int itkNotUsed(contrastMax)) { return input; } void subtract(OutputImageType::Pointer image1, OutputImageType::Pointer image2, const char* subtractFileName) { typedef itk::SubtractImageFilter SubtractFilterType; typedef itk::MinimumMaximumImageCalculator MaximumCalculatorType; typedef itk::RescaleIntensityImageFilter OutputRescaleFilterType; SubtractFilterType::Pointer subtract = SubtractFilterType::New(); MaximumCalculatorType::Pointer maximumCalculator = MaximumCalculatorType::New(); subtract->SetInput1(image1); subtract->SetInput2(image2); subtract->Update(); OutputRescaleFilterType::Pointer rescaler = OutputRescaleFilterType::New(); rescaler->SetInput(subtract->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(subtractFileName); writer->SetInput(rescaler->GetOutput()); //writer->Update(); maximumCalculator->SetImage(subtract->GetOutput()); maximumCalculator->Compute(); std::cout << "Mix(sub)= " << maximumCalculator->GetMinimum() << " "; std::cout << "Max(sub)= " << maximumCalculator->GetMaximum() << std::endl; } int otbImageToSIFTKeyPointSetFilterDistanceMap(int argc, char * argv[]) { if (argc < 10) { std::cout << "Missing arguments " << std::endl; return EXIT_FAILURE; } // Input Image file name const char * infname = argv[1]; const char * outfname = argv[10]; const unsigned int octaves = atoi(argv[2]); const unsigned int scales = atoi(argv[3]); const float threshold = atof(argv[4]); const float ratio = atof(argv[5]); // Rotation angle [0, 360[ const unsigned int rotation = atoi(argv[6]); // Zoom factor const unsigned int zoomFactor = atoi(argv[7]); // contrast factor const unsigned int contrastMin = atoi(argv[8]); const unsigned int contrastMax = atoi(argv[9]); //redirect cout to a file std::ofstream file(outfname); std::streambuf* strm_buffer = std::cout.rdbuf(); //save the cout to put it //back later std::cout.rdbuf(file.rdbuf()); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->Update(); ImageType::Pointer _rotated = rotate(reader->GetOutput(), rotation); ImageType::Pointer _zoomed = zoom(reader->GetOutput(), zoomFactor); ImageType::Pointer _contrasted = contrast(reader->GetOutput(), contrastMin, contrastMax); ImageType::Pointer _combined1 = zoom(_rotated, zoomFactor); ImageType::Pointer _combined2 = contrast(_combined1, contrastMin, contrastMax); OutputImageType::Pointer sift_base = sift(reader->GetOutput(), octaves, scales, threshold, ratio, "sift_base.png"); OutputImageType::Pointer _sift_rotated = sift(_rotated, octaves, scales, threshold, ratio, "sift_rotated.png"); OutputImageType::Pointer _sift_zoomed = sift(_zoomed, octaves, scales, threshold, ratio, "sift_zoomed.png"); OutputImageType::Pointer _sift_contrasted = sift(_contrasted, octaves, scales, threshold, ratio, "sift_contrasted.png"); OutputImageType::Pointer _sift_combined = sift(_combined2, octaves, scales, threshold, ratio, "sift_combined.png"); OutputImageType::Pointer sift_rotated = invRotate(_sift_rotated, rotation); OutputImageType::Pointer sift_zoomed = invZoom(_sift_zoomed, zoomFactor); OutputImageType::Pointer sift_contrasted = invContrast(_sift_contrasted, contrastMin, contrastMax); OutputImageType::Pointer _sift_combined1 = invContrast(_sift_combined, contrastMin, contrastMax); OutputImageType::Pointer _sift_combined2 = invRotate(_sift_combined1, rotation); OutputImageType::Pointer sift_combined = invZoom(_sift_combined2, zoomFactor); OutputImageType::Pointer ddm_base = ddm(sift_base, "ddm_base.png"); OutputImageType::Pointer ddm_rotated = ddm(sift_rotated, "ddm_rotated.png"); OutputImageType::Pointer ddm_contrasted = ddm(sift_contrasted, "ddm_contrasted.png"); OutputImageType::Pointer ddm_zoomed = ddm(sift_zoomed, "ddm_zoomed.png"); OutputImageType::Pointer ddm_combined = ddm(sift_combined, "ddm_combined.png"); subtract(ddm_base, ddm_rotated, "subtract_rotated.png"); subtract(ddm_base, ddm_zoomed, "subtract_zoomed.png"); subtract(ddm_base, ddm_contrasted, "subtract_contrasted.png"); subtract(ddm_base, ddm_combined, "subtract_combined.png"); std::cout.rdbuf(strm_buffer); file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbImageToSIFTKeyPointSetFilterNew.cxx000066400000000000000000000025511301006202600311270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToSIFTKeyPointSetFilter.h" #include "otbImage.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" int otbImageToSIFTKeyPointSetFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter ImageToSIFTKeyPointSetFilterType; // Instantiating object ImageToSIFTKeyPointSetFilterType::Pointer filter = ImageToSIFTKeyPointSetFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbImageToSIFTKeyPointSetFilterOutputAscii.cxx000066400000000000000000000067731301006202600326610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbImageToSIFTKeyPointSetFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" int otbImageToSIFTKeyPointSetFilterOutputAscii(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int octaves = atoi(argv[3]); const unsigned int scales = atoi(argv[4]); const float threshold = atof(argv[5]); const float ratio = atof(argv[6]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter ImageToSIFTKeyPointSetFilterType; // PointSet iterator type typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; typedef PointSetType::PointDataContainer PointDataContainerType; typedef PointDataContainerType::Iterator PointDataIteratorType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToSIFTKeyPointSetFilterType::Pointer filter = ImageToSIFTKeyPointSetFilterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->SetDoGThreshold(threshold); filter->SetEdgeThreshold(ratio); filter->Update(); PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); if (filter->GetOutput()->GetPointData() == ITK_NULLPTR) { std::cerr << "No sift point found!" << std::endl; return EXIT_FAILURE; //Avoid the subsequent segfault, but need to check if that what the test want to do } PointDataIteratorType pDataIt = filter->GetOutput()->GetPointData()->Begin(); std::ofstream outfile(outfname); outfile << "Number of octaves: " << octaves << std::endl; outfile << "Number of scales: " << scales << std::endl; outfile << "Number of SIFT key points: " << filter->GetOutput()->GetNumberOfPoints() << std::endl; while (pIt != filter->GetOutput()->GetPoints()->End()) { outfile << "[" << std::fixed << std::setprecision(2) << pIt.Value()[0] << ", " << std::setprecision(2) << pIt.Value()[1] << "]["; unsigned int lIterDesc = 0; while (lIterDesc < pDataIt.Value().Size()) { outfile << std::setprecision(3) << pDataIt.Value()[lIterDesc] << " "; lIterDesc++; } outfile << "]" << std::endl; ++pIt; ++pDataIt; } outfile.close(); return EXIT_SUCCESS; } otbImageToSIFTKeyPointSetFilterOutputDescriptorAscii.cxx000066400000000000000000000062471301006202600346350ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbImageToSIFTKeyPointSetFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" int otbImageToSIFTKeyPointSetFilterOutputDescriptorAscii(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int octaves = atoi(argv[3]); const unsigned int scales = atoi(argv[4]); const float threshold = atof(argv[5]); const float ratio = atof(argv[6]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter ImageToSIFTKeyPointSetFilterType; // PointSet terator type typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; typedef PointSetType::PointDataContainer PointDataContainerType; typedef PointDataContainerType::Iterator PointDataIteratorType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToSIFTKeyPointSetFilterType::Pointer filter = ImageToSIFTKeyPointSetFilterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->SetDoGThreshold(threshold); filter->SetEdgeThreshold(ratio); filter->Update(); PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); PointDataIteratorType pDataIt = filter->GetOutput()->GetPointData()->Begin(); std::ofstream outfile(outfname); outfile << "Number of octaves: " << octaves << std::endl; outfile << "Number of scales: " << scales << std::endl; outfile << "Number of SIFT key points: " << filter->GetOutput()->GetNumberOfPoints() << std::endl; while (pIt != filter->GetOutput()->GetPoints()->End()) { outfile << "["; unsigned int lIterDesc = 0; while (lIterDesc < pDataIt.Value().Size()) { outfile << std::setprecision(3) << pDataIt.Value()[lIterDesc] << " "; lIterDesc++; } outfile << "]" << std::endl; ++pIt; ++pDataIt; } outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbImageToSIFTKeyPointSetFilterOutputImage.cxx000066400000000000000000000131631301006202600326420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToSIFTKeyPointSetFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" #include #include int otbImageToSIFTKeyPointSetFilterOutputImage(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outputImageFilename = argv[2]; const unsigned int octaves = atoi(argv[3]); const unsigned int scales = atoi(argv[4]); float threshold = atof(argv[5]); float ratio = atof(argv[6]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter ImageToSIFTKeyPointSetFilterType; typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToSIFTKeyPointSetFilterType::Pointer filter = ImageToSIFTKeyPointSetFilterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->SetDoGThreshold(threshold); filter->SetEdgeThreshold(ratio); filter->Update(); ImageType::OffsetType t = {{ 0, 1}}; ImageType::OffsetType b = {{ 0, -1}}; ImageType::OffsetType l = {{ 1, 0}}; ImageType::OffsetType r = {{-1, 0}}; typedef unsigned char PixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; OutputImageType::Pointer outputImage = OutputImageType::New(); OutputImageType::RegionType region; OutputImageType::SizeType outputSize; outputSize[0] = reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]; outputSize[1] = reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]; region.SetSize(outputSize); OutputImageType::IndexType indexStart; indexStart[0] = 0; indexStart[1] = 0; region.SetIndex(indexStart); outputImage->SetRegions(region); outputImage->Allocate(); itk::ImageRegionIterator iterOutput(outputImage, outputImage->GetLargestPossibleRegion()); itk::ImageRegionIterator iterInput(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); for (iterOutput.GoToBegin(), iterInput.GoToBegin(); !iterOutput.IsAtEnd(); ++iterOutput, ++iterInput) { OutputImageType::PixelType rgbPixel; rgbPixel.SetRed(static_cast(iterInput.Get())); rgbPixel.SetGreen(static_cast(iterInput.Get())); rgbPixel.SetBlue(static_cast(iterInput.Get())); iterOutput.Set(rgbPixel); } WriterType::Pointer writerTmp = WriterType::New(); writerTmp->SetFileName(outputImageFilename); writerTmp->SetInput(outputImage); writerTmp->Update(); std::cout << "Copy Input image in Output image" << std::endl; PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); ImageType::SpacingType spacing = reader->GetOutput()->GetSpacing(); ImageType::PointType origin = reader->GetOutput()->GetOrigin(); //OutputImageType::SizeType size = outputImage->GetLargestPossibleRegion().GetSize(); while (pIt != filter->GetOutput()->GetPoints()->End()) { ImageType::IndexType index; index[0] = (unsigned int) (vcl_floor ((double) ((pIt.Value()[0] - origin[0]) / spacing[0] + 0.5))); index[1] = (unsigned int) (vcl_floor ((double) ((pIt.Value()[1] - origin[1]) / spacing[1] + 0.5))); OutputImageType::PixelType keyPixel; keyPixel.SetRed(0); keyPixel.SetGreen(255); keyPixel.SetBlue(0); if (outputImage->GetLargestPossibleRegion().IsInside(index)) { outputImage->SetPixel(index, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + t)) outputImage->SetPixel(index + t, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + b)) outputImage->SetPixel(index + b, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + l)) outputImage->SetPixel(index + l, keyPixel); if (outputImage->GetLargestPossibleRegion().IsInside(index + r)) outputImage->SetPixel(index + r, keyPixel); } ++pIt; } std::cout << "Copy sift key" << std::endl; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageFilename); writer->SetInput(outputImage); writer->Update(); std::cout << "Write image" << std::endl; return EXIT_SUCCESS; } otbImageToSIFTKeyPointSetFilterOutputInterestPointAscii.cxx000066400000000000000000000055141301006202600353220ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbImageToSIFTKeyPointSetFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" int otbImageToSIFTKeyPointSetFilterOutputInterestPointAscii(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int octaves = atoi(argv[3]); const unsigned int scales = atoi(argv[4]); const float threshold = atof(argv[5]); const float ratio = atof(argv[6]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ImageToSIFTKeyPointSetFilter ImageToSIFTKeyPointSetFilterType; typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToSIFTKeyPointSetFilterType::Pointer filter = ImageToSIFTKeyPointSetFilterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->SetDoGThreshold(threshold); filter->SetEdgeThreshold(ratio); filter->Update(); PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); std::ofstream outfile(outfname); outfile << "Number of octaves: " << octaves << std::endl; outfile << "Number of scales: " << scales << std::endl; outfile << "Number of SIFT key points: " << filter->GetOutput()->GetNumberOfPoints() << std::endl; while (pIt != filter->GetOutput()->GetPoints()->End()) { outfile << "[" << std::fixed << std::setprecision(2) << pIt.Value()[0] << ", " << std::setprecision(2) << pIt.Value()[1] << "]" << std::endl; ++pIt; } outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbImageToSURFKeyPointSetFilterNew.cxx000066400000000000000000000025521301006202600311420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToSURFKeyPointSetFilter.h" #include "otbImage.h" #include "itkVariableLengthVector.h" int otbImageToSURFKeyPointSetFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::ImageToSURFKeyPointSetFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbImageToSURFKeyPointSetFilterOutputDescriptorAscii.cxx000066400000000000000000000062621301006202600346440ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbImageToSURFKeyPointSetFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" int otbImageToSURFKeyPointSetFilterOutputDescriptorAscii(int argc, char * argv[]) { if (argc < 5) { std::cout << " Usage : otbSURFTest imageName FileOutName Octave[int] Level[int]" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int octaves = atoi(argv[3]); const unsigned int scales = atoi(argv[4]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ImageToSURFKeyPointSetFilter ImageToSURFKeyPointSetFilterType; typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; typedef PointSetType::PointDataContainer PointDataContainerType; typedef PointDataContainerType::Iterator PointDataIteratorType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToSURFKeyPointSetFilterType::Pointer filter = ImageToSURFKeyPointSetFilterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->Update(); PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); PointDataIteratorType pDataIt = filter->GetOutput()->GetPointData()->Begin(); std::ofstream outfile(outfname); outfile << "Number of octaves: " << octaves << std::endl; outfile << "Number of scales: " << scales << std::endl; outfile << "Number of SURF key points: " << filter->GetNumberOfPoints() << std::endl; while (pIt != filter->GetOutput()->GetPoints()->End()) { outfile << "["; unsigned int lIterDesc = 0; while (lIterDesc < pDataIt.Value().Size()) { outfile << std::setprecision(3) << pDataIt.Value()[lIterDesc] << " "; lIterDesc++; } outfile << "]" << std::endl; ++pIt; ++pDataIt; } outfile.close(); return EXIT_SUCCESS; } otbImageToSURFKeyPointSetFilterOutputInterestPointAscii.cxx000066400000000000000000000056451301006202600353410ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Descriptors/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbImageToSURFKeyPointSetFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkImageRegionIterator.h" int otbImageToSURFKeyPointSetFilterOutputInterestPointAscii(int argc, char * argv[]) { if (argc < 5) { std::cout << " Usage : otbSURFTest imageName FileOutName Octave[int] Level[int]" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int octaves = atoi(argv[3]); const unsigned int scales = atoi(argv[4]); typedef float RealType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef itk::VariableLengthVector RealVectorType; typedef otb::ImageFileReader ReaderType; typedef itk::PointSet PointSetType; typedef otb::ImageToSURFKeyPointSetFilter ImageToSURFKeyPointSetFilterType; typedef PointSetType::PointsContainer PointsContainerType; typedef PointsContainerType::Iterator PointsIteratorType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); ImageToSURFKeyPointSetFilterType::Pointer filter = ImageToSURFKeyPointSetFilterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetOctavesNumber(octaves); filter->SetScalesNumber(scales); filter->Update(); PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); filter->GetOutput()->GetPointData()->Begin(); std::ofstream outfile(outfname); outfile << "Number of octaves: " << octaves << std::endl; outfile << "Number of scales: " << scales << std::endl; outfile << "Number of SURF key points: " << filter->GetNumberOfPoints() << std::endl; while (pIt != filter->GetOutput()->GetPoints()->End()) { outfile << "[" << std::fixed << std::setprecision(2) << pIt.Value()[0] << ", " << std::setprecision(2) << pIt.Value()[1] << "]" << std::endl; ++pIt; } outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbKeyPointSetsMatchingFilter.cxx000066400000000000000000000052251301006202600303600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKeyPointSetsMatchingFilter.h" #include "itkVariableLengthVector.h" #include "itkPointSet.h" #include #include int otbKeyPointSetsMatchingFilter(int itkNotUsed(argc), char* argv[]) { const char * outfname = argv[1]; const double thresh = atof(argv[2]); const bool useBackMatching = atoi(argv[3]); typedef itk::VariableLengthVector PointDataType; typedef itk::PointSet PointSetType; typedef PointSetType::PointType PointType; typedef otb::KeyPointSetsMatchingFilter MatchingFilterType; typedef MatchingFilterType::LandmarkListType LandmarkListType; // instantiation MatchingFilterType::Pointer filter = MatchingFilterType::New(); filter->SetUseBackMatching(useBackMatching); filter->SetDistanceThreshold(thresh); // Building two pointsets PointSetType::Pointer ps1 = PointSetType::New(); PointSetType::Pointer ps2 = PointSetType::New(); PointType p1, p2, p3; p1.Fill(1); p2.Fill(2); p3.Fill(3); PointDataType d1(3), d2(3), d3(3), d1b(3), d2b(3), d3b(3); d1.Fill(1); d1b.Fill(1); d2.Fill(0); d2[0] = 10; d2b.Fill(0); d2b[1] = 10; d3.Fill(2); d3b.Fill(10); ps1->SetPoint(0, p1); ps1->SetPoint(1, p2); ps1->SetPoint(2, p3); ps2->SetPoint(0, p1); ps2->SetPoint(1, p2); ps2->SetPoint(2, p3); ps1->SetPointData(0, d1); ps1->SetPointData(1, d2); ps1->SetPointData(2, d3); ps2->SetPointData(0, d1b); ps2->SetPointData(1, d2b); ps2->SetPointData(2, d3b); filter->SetInput1(ps1); filter->SetInput2(ps2); filter->Update(); LandmarkListType * matching = filter->GetOutput(); std::ofstream outfile(outfname); outfile << "Matches: " << std::endl; for (LandmarkListType::Iterator it = matching->Begin(); it != matching->End(); ++it) { outfile << "Matching: " << it.Get()->GetPoint1() << " " << it.Get()->GetPointData1() << " <- " << it.Get()->GetLandmarkData() << " -> " << it.Get()->GetPoint2() << " " << it.Get()->GetPointData2() << std::endl; } outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbKeyPointSetsMatchingFilterNew.cxx000066400000000000000000000023631301006202600310320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "otbKeyPointSetsMatchingFilter.h" int otbKeyPointSetsMatchingFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float RealType; const unsigned int Dimension = 2; typedef itk::VariableLengthVector RealVectorType; typedef itk::PointSet PointSetType; typedef otb::KeyPointSetsMatchingFilter EuclideanDistanceMetricMatchingFilterType; // Instantiating object EuclideanDistanceMetricMatchingFilterType::Pointer filter = EuclideanDistanceMetricMatchingFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Descriptors/test/otbLandmarkNew.cxx000066400000000000000000000020571301006202600253410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLandmark.h" #include "itkVariableLengthVector.h" #include "itkPoint.h" int otbLandmarkNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef itk::Point PointType; typedef itk::VariableLengthVector PointDataType; typedef otb::Landmark LandmarkType; // instantiation LandmarkType::Pointer landmark = LandmarkType::New(); std::cout << landmark << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/000077500000000000000000000000001301006202600172655ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Edge/CMakeLists.txt000066400000000000000000000001041301006202600220200ustar00rootroot00000000000000project(OTBEdge) set(OTBEdge_LIBRARIES OTBEdge) otb_module_impl() OTB-release-5.8/Modules/Feature/Edge/include/000077500000000000000000000000001301006202600207105ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Edge/include/otbAssociativeSymmetricalSumImageFilter.h000066400000000000000000000056651301006202600310640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAssociativeSymmetricalSumImageFilter_h #define otbAssociativeSymmetricalSumImageFilter_h #include "itkBinaryFunctorImageFilter.h" namespace otb { /** \class AssociativeSymmetricalSumImageFilter * \brief Implements an asymmetric fusion of line detector image filter. * * This class implements a fusion of the output images of * otb::LineRatioDetector and otb::LineCorrelationDetector * * The associative symmetrical sum \f$ \sigma(x, y) \f$ is used to merge information from the * two detectors: \f[ \sigma(x, y)=\frac{xy}{1-x-y+2xy} \f] with \f$ x, y \in [0, 1] \f$. * * * * \ingroup OTBEdge */ namespace Functor { /** \class AssociativeSymmetricalSum * \brief Functor used with the AssociativeSymmetricalSumImageFilter. * * \ingroup OTBEdge */ template class ITK_EXPORT AssociativeSymmetricalSum { public: AssociativeSymmetricalSum() {}; virtual ~AssociativeSymmetricalSum() {} inline TOutput operator ()(const TInput1 X, const TInput2 Y) { TOutput SumXY = 0.; SumXY += static_cast((X * Y) / (1. - X - Y + (2 * X * Y))); return (SumXY); } }; } template class ITK_EXPORT AssociativeSymmetricalSumImageFilter : public itk::BinaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef AssociativeSymmetricalSumImageFilter Self; typedef itk::BinaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); protected: AssociativeSymmetricalSumImageFilter() {} ~AssociativeSymmetricalSumImageFilter() ITK_OVERRIDE {} private: AssociativeSymmetricalSumImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbAssymmetricFusionOfLineDetectorImageFilter.h000066400000000000000000000100351301006202600321510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAssymmetricFusionOfLineDetectorImageFilter_h #define otbAssymmetricFusionOfLineDetectorImageFilter_h #include "itkImageToImageFilter.h" #include "otbLineRatioDetectorImageFilter.h" #include "otbLineCorrelationDetectorImageFilter.h" #include "otbAssociativeSymmetricalSumImageFilter.h" #include "vcl_deprecated_header.h" namespace otb { /** \class AssymmetricFusionOfLineDetectorImageFilter * * This class implements a composite filter that combines three filters: * two filters of line detector ( a line detector by ratio and a line * detector by croos-correlation) and a filter that produces a fusion of * those two line detector filters. * * * \ingroup OTBEdge */ template > class ITK_EXPORT AssymmetricFusionOfLineDetectorImageFilter : public LineDetectorImageFilterBase { public: itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef AssymmetricFusionOfLineDetectorImageFilter Self; typedef LineDetectorImageFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(AssymmetricFusionOfLineDetectorImageFilter, LineDetectorImageFilterBase); typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageDirectionType OutputImageDirectionType; typedef typename Superclass::InterpolatorType InterpolatorType; typedef OutputImageType InputImageType1; typedef OutputImageType InputImageType2; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::SizeType SizeType; typedef typename OutputImageType::PixelType OutputPixelType; protected: AssymmetricFusionOfLineDetectorImageFilter(); ~AssymmetricFusionOfLineDetectorImageFilter() ITK_OVERRIDE {} typedef otb::LineRatioDetectorImageFilter LineRatioType; typedef otb::LineCorrelationDetectorImageFilter LineCorrelationType; typedef otb::AssociativeSymmetricalSumImageFilter AssSymSumType; void GenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: AssymmetricFusionOfLineDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename LineRatioType::Pointer m_LineRatio; typename LineCorrelationType::Pointer m_LineCorrelation; typename AssSymSumType::Pointer m_AssSymSum; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAssymmetricFusionOfLineDetectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbAssymmetricFusionOfLineDetectorImageFilter.txx000066400000000000000000000050331301006202600325470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAssymmetricFusionOfLineDetectorImageFilter_txx #define otbAssymmetricFusionOfLineDetectorImageFilter_txx #include "otbAssymmetricFusionOfLineDetectorImageFilter.h" namespace otb { /** * */ template AssymmetricFusionOfLineDetectorImageFilter ::AssymmetricFusionOfLineDetectorImageFilter() { this->m_Radius.Fill(1); this->m_LengthLine = 1; this->m_WidthLine = 0; this->m_NumberOfDirections = 8; m_LineRatio = LineRatioType::New(); m_LineCorrelation = LineCorrelationType::New(); m_AssSymSum = AssSymSumType::New(); } template void AssymmetricFusionOfLineDetectorImageFilter ::GenerateData() { m_LineRatio->SetInput( this->GetInput() ); m_LineRatio->SetLengthLine( this->m_LengthLine ); m_LineRatio->SetWidthLine( this->m_WidthLine ); m_LineRatio->SetNumberOfDirections( this->m_NumberOfDirections ); m_LineCorrelation->SetInput( this->GetInput() ); m_LineCorrelation->SetLengthLine( this->m_LengthLine ); m_LineCorrelation->SetWidthLine( this->m_WidthLine ); m_LineCorrelation->SetNumberOfDirections( this->m_NumberOfDirections ); m_AssSymSum->SetInput1( m_LineRatio->GetOutput() ); m_AssSymSum->SetInput2( m_LineCorrelation->GetOutput() ); m_AssSymSum->GraftOutput(this->GetOutput() ); m_AssSymSum->Update(); this->GraftOutput(m_AssSymSum->GetOutput() ); } /** * Standard "PrintSelf" method */ template void AssymmetricFusionOfLineDetectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } //namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbAsymmetricFusionOfLineDetectorImageFilter.h000066400000000000000000000077571301006202600320070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAsymmetricFusionOfLineDetectorImageFilter_h #define otbAsymmetricFusionOfLineDetectorImageFilter_h #include "itkImageToImageFilter.h" #include "otbLineRatioDetectorImageFilter.h" #include "otbLineCorrelationDetectorImageFilter.h" #include "otbAssociativeSymmetricalSumImageFilter.h" namespace otb { /** \class AsymmetricFusionOfLineDetectorImageFilter * * This class implements a composite filter that combines three filters: * two filters of line detector ( a line detector by ratio and a line * detector by croos-correlation) and a filter that produces a fusion of * those two line detector filters. * * * \ingroup OTBEdge */ template > class ITK_EXPORT AsymmetricFusionOfLineDetectorImageFilter : public LineDetectorImageFilterBase { public: itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef AsymmetricFusionOfLineDetectorImageFilter Self; typedef LineDetectorImageFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(AsymmetricFusionOfLineDetectorImageFilter, LineDetectorImageFilterBase); typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageDirectionType OutputImageDirectionType; typedef typename Superclass::InterpolatorType InterpolatorType; typedef OutputImageType InputImageType1; typedef OutputImageType InputImageType2; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::SizeType SizeType; typedef typename OutputImageType::PixelType OutputPixelType; protected: AsymmetricFusionOfLineDetectorImageFilter(); ~AsymmetricFusionOfLineDetectorImageFilter() ITK_OVERRIDE {} typedef otb::LineRatioDetectorImageFilter LineRatioType; typedef otb::LineCorrelationDetectorImageFilter LineCorrelationType; typedef otb::AssociativeSymmetricalSumImageFilter AssSymSumType; void GenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: AsymmetricFusionOfLineDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename LineRatioType::Pointer m_LineRatio; typename LineCorrelationType::Pointer m_LineCorrelation; typename AssSymSumType::Pointer m_AssSymSum; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAsymmetricFusionOfLineDetectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbAsymmetricFusionOfLineDetectorImageFilter.txx000066400000000000000000000050241301006202600323640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAsymmetricFusionOfLineDetectorImageFilter_txx #define otbAsymmetricFusionOfLineDetectorImageFilter_txx #include "otbAsymmetricFusionOfLineDetectorImageFilter.h" namespace otb { /** * */ template AsymmetricFusionOfLineDetectorImageFilter ::AsymmetricFusionOfLineDetectorImageFilter() { this->m_Radius.Fill(1); this->m_LengthLine = 1; this->m_WidthLine = 0; this->m_NumberOfDirections = 8; m_LineRatio = LineRatioType::New(); m_LineCorrelation = LineCorrelationType::New(); m_AssSymSum = AssSymSumType::New(); } template void AsymmetricFusionOfLineDetectorImageFilter ::GenerateData() { m_LineRatio->SetInput( this->GetInput() ); m_LineRatio->SetLengthLine( this->m_LengthLine ); m_LineRatio->SetWidthLine( this->m_WidthLine ); m_LineRatio->SetNumberOfDirections( this->m_NumberOfDirections ); m_LineCorrelation->SetInput( this->GetInput() ); m_LineCorrelation->SetLengthLine( this->m_LengthLine ); m_LineCorrelation->SetWidthLine( this->m_WidthLine ); m_LineCorrelation->SetNumberOfDirections( this->m_NumberOfDirections ); m_AssSymSum->SetInput1( m_LineRatio->GetOutput() ); m_AssSymSum->SetInput2( m_LineCorrelation->GetOutput() ); m_AssSymSum->GraftOutput(this->GetOutput() ); m_AssSymSum->Update(); this->GraftOutput(m_AssSymSum->GetOutput() ); } /** * Standard "PrintSelf" method */ template void AsymmetricFusionOfLineDetectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } //namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbEdgeDensityImageFilter.h000066400000000000000000000076101301006202600261070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEdgeDensityImageFilter_h #define otbEdgeDensityImageFilter_h #include "otbBinaryImageToDensityImageFilter.h" #include "itkProcessObject.h" namespace otb { /** \class EdgeDensityImageFilter * \brief This composite filter computes the density of the edges around a pixel. * * * * \ingroup OTBEdge */ template class ITK_EXPORT EdgeDensityImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef EdgeDensityImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(EdgeDensityImageFilter, itk::ImageToImageFilter); /** Template parameters typedefs*/ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; /** OutputImageType typedef support*/ typedef TOutputImage OutputImageType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::Pointer OutputImagePointerType; /** Edge Detector typedef Support*/ typedef TEdgeDetector DetectorType; typedef typename DetectorType::Pointer DetectorPointerType; /** Count Density Function typedef support*/ typedef TDensityCount DensityCountFunctionType; /** PointSetToDensityImageFilter support*/ typedef otb::BinaryImageToDensityImageFilter DensityImageType; typedef typename DensityImageType::Pointer DensityImagePointerType; /** Get/Set the radius of the neighborhood over which the statistics are evaluated */ itkSetMacro(NeighborhoodRadius, InputImageSizeType); itkGetConstReferenceMacro(NeighborhoodRadius, InputImageSizeType); void SetNeighborhoodRadius(unsigned int rad) { m_NeighborhoodRadius.Fill(rad); this->Modified(); } /**Set/Get detector */ itkSetObjectMacro(Detector, DetectorType); itkGetObjectMacro(Detector, DetectorType); itkGetObjectMacro(DensityImageFilter, DensityImageType); protected: /** * Constructor. */ EdgeDensityImageFilter(); /** * Destructor. */ ~EdgeDensityImageFilter() ITK_OVERRIDE; /** * Standard PrintSelf method. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Main computation method. */ void GenerateData() ITK_OVERRIDE; private: EdgeDensityImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented DetectorPointerType m_Detector; DensityImagePointerType m_DensityImageFilter; InputImageSizeType m_NeighborhoodRadius; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbEdgeDensityImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbEdgeDensityImageFilter.txx000066400000000000000000000052451301006202600265050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEdgeDensityImageFilter_txx #define otbEdgeDensityImageFilter_txx #include "otbEdgeDensityImageFilter.h" namespace otb { /**--------------------------------------------------------- * Constructor ----------------------------------------------------------*/ template EdgeDensityImageFilter ::EdgeDensityImageFilter() { this->SetNumberOfRequiredInputs(1); m_NeighborhoodRadius.Fill(1); m_Detector = DetectorType::New(); m_DensityImageFilter = DensityImageType::New(); } /*--------------------------------------------------------- * Destructor.c ----------------------------------------------------------*/ template EdgeDensityImageFilter ::~EdgeDensityImageFilter() {} /** * threaded Generate Data */ template void EdgeDensityImageFilter ::GenerateData() { m_Detector->SetInput(this->GetInput()); m_DensityImageFilter->SetNeighborhoodRadius(m_NeighborhoodRadius); m_DensityImageFilter->SetInput(m_Detector->GetOutput()); m_DensityImageFilter->GraftOutput(this->GetOutput()); m_DensityImageFilter->Update(); this->GraftOutput(m_DensityImageFilter->GetOutput()); } /*---------------------------------------------------------------- PrintSelf -----------------------------------------------------------------*/ template void EdgeDensityImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Neighborhood Radius " << m_NeighborhoodRadius << std::endl; } } /** end namesapce otb*/ #endif OTB-release-5.8/Modules/Feature/Edge/include/otbEdgeDetectorImageFilter.h000066400000000000000000000102631301006202600262370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEdgeDetectorImageFilter_h #define otbEdgeDetectorImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkImageToImageFilter.h" #include "itkBinaryThresholdImageFilter.h" namespace otb { /** \class EdgeDetectorImageFilter * \brief This composite filter binaries a edge detection image output. * The used edge detection filter is given as template of the class. * The class only supports Image. * * * \ingroup OTBEdge */ template class ITK_EXPORT EdgeDetectorImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef EdgeDetectorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(EdgeDetectorImageFilter, itk::ImageToImageFilter); /** Template parameters typedefs*/ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::PixelType OutputImagePixelType; /** Edge Detection */ typedef TEdgeDetection DetectionType; typedef typename DetectionType::Pointer DetectionPointerType; /** Thresholder filter : Otsu */ typedef itk::BinaryThresholdImageFilter BinaryFilterType; typedef typename BinaryFilterType::Pointer BinaryFilterPointerType; /**Set/Get detector */ itkSetObjectMacro(Detector, DetectionType); itkGetObjectMacro(Detector, DetectionType); itkGetConstObjectMacro(Detector, DetectionType); /**Set/Get binary filter */ itkSetObjectMacro(BinaryFilter, BinaryFilterType); itkGetObjectMacro(BinaryFilter, BinaryFilterType); //itkGetObjectMacro(DetectorImageFilter, DetectorImageType); /** Set lower threshold value. */ void SetLowerThreshold(InputImagePixelType val) { m_BinaryFilter->SetLowerThreshold(val); this->Modified(); } /** Set upper threshold value. */ void SetUpperThreshold(InputImagePixelType val) { m_BinaryFilter->SetUpperThreshold(val); this->Modified(); } /** Set Inside value. */ void SetInsideValue(InputImagePixelType val) { m_BinaryFilter->SetInsideValue(val); this->Modified(); } /** Set Outside value. */ void SetOutsideValue(InputImagePixelType val) { m_BinaryFilter->SetOutsideValue(val); this->Modified(); } protected: EdgeDetectorImageFilter(); ~EdgeDetectorImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: EdgeDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented DetectionPointerType m_Detector; BinaryFilterPointerType m_BinaryFilter; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbEdgeDetectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbEdgeDetectorImageFilter.txx000066400000000000000000000052231301006202600266330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEdgeDetectorImageFilter_txx #define otbEdgeDetectorImageFilter_txx #include "otbEdgeDetectorImageFilter.h" namespace otb { /**--------------------------------------------------------- * Constructor ----------------------------------------------------------*/ template EdgeDetectorImageFilter ::EdgeDetectorImageFilter() { this->SetNumberOfRequiredInputs(1); m_Detector = DetectionType::New(); m_BinaryFilter = BinaryFilterType::New(); m_BinaryFilter->SetInsideValue(static_cast(0.)); m_BinaryFilter->SetOutsideValue(static_cast(1.)); m_BinaryFilter->SetUpperThreshold(static_cast(255)); m_BinaryFilter->SetLowerThreshold(static_cast(0)); } /*--------------------------------------------------------- * Destructor.c ----------------------------------------------------------*/ template EdgeDetectorImageFilter ::~EdgeDetectorImageFilter() {} /** * threaded Generate Data */ template void EdgeDetectorImageFilter ::GenerateData() { m_Detector->SetInput(this->GetInput()); m_Detector->Update(); m_BinaryFilter->SetInput(m_Detector->GetOutput()); m_BinaryFilter->GraftOutput(this->GetOutput()); m_BinaryFilter->Update(); this->GraftOutput(m_BinaryFilter->GetOutput()); } /*---------------------------------------------------------------- PrintSelf -----------------------------------------------------------------*/ template void EdgeDetectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } /** end namesapce otb*/ #endif OTB-release-5.8/Modules/Feature/Edge/include/otbExtractSegmentsImageFilter.h000066400000000000000000000127661301006202600270330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtractSegmentsImageFilter_h #define otbExtractSegmentsImageFilter_h #include "otbPixelSuppressionByDirectionImageFilter.h" #include "otbLocalHoughFilter.h" #include "otbFillGapsFilter.h" #include "otbDrawLineSpatialObjectListFilter.h" #include "itkRescaleIntensityImageFilter.h" namespace otb { /** \class ExtractSegmentsImageFilter * * This class implements a composite filter that generate an image of segments * primitives. It combines four filters : * - otb::PixelSuppressionByDirectionImageFilter * - otb::LocalHoughFilter * - otb::FillGapsFilter * - otb::DrawLineSpatialObjectListFilter * * * \ingroup OTBEdge */ template class ITK_EXPORT ExtractSegmentsImageFilter : public itk::ImageToImageFilter { public: itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TInputImage PSOutputImageType; typedef ExtractSegmentsImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(ExtractSegmentsImageFilter, itk::ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::SizeType SizeType; typedef typename OutputImageType::PixelType OutputPixelType; /** Definition of the list of lines. */ typedef LineSpatialObjectList LinesListType; /** Set/Get the radius of the region of the pixel suppression by direction image filter. */ void SetPixelSuppressionRadius(SizeType Radius); const SizeType GetPixelSuppressionRadius(); /** Set/Get Angular Accuracy on the direction of the central pixel for the pixel suppression by direction image filter. */ void SetPixelSuppressionAngularBeam(float AngularBeam); float GetPixelSuppressionAngularBeam(); /** Set/Get the radius used to define the region of local hough filter. */ void SetLocalHoughRadius(SizeType Radius); const SizeType GetLocalHoughRadius(); /** Set/Get the number of lines we are looking for in the local hough filter. */ void SetLocalHoughNumberOfLines(unsigned int Radius); unsigned int GetLocalHoughNumberOfLines(); /** Set/Get the radius of the disc to remove from the accumulator * for each line found */ void SetLocalHoughDiscRadius(float DiscRadius); float GetLocalHoughDiscRadius(); /** Set/Get the variance of the gaussian bluring for the accumulator */ void SetLocalHoughVariance(float Variance); float GetLocalHoughVariance(); /** Set/Get the radius between two segments in the fill gaps filter. */ void SetFillGapsRadius(float Radius); float GetFillGapsRadius(); /** Set/Get Angular Beam between two segments in the fill gaps filter. */ void SetFillGapsAngularBeam(float AngularBeam); float GetFillGapsAngularBeam(); /** Set/Get the image input of this filter. */ void SetInputImage(const InputImageType *image); const InputImageType * GetInputImage(); /** Set/Get the image direction of this filter. */ void SetInputImageDirection(const InputImageType *image); const InputImageType * GetInputImageDirection(); /** Set/Get the value of the drawed line*/ itkGetMacro(LineValue, typename OutputImageType::PixelType); itkSetMacro(LineValue, typename OutputImageType::PixelType); protected: ExtractSegmentsImageFilter(); ~ExtractSegmentsImageFilter() ITK_OVERRIDE {} typedef PixelSuppressionByDirectionImageFilter PixelSuppressionType; typedef LocalHoughFilter LocalHoughType; typedef FillGapsFilter FillGapsType; typedef DrawLineSpatialObjectListFilter DrawLineListType; typedef itk::RescaleIntensityImageFilter RescaleType; void GenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ExtractSegmentsImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename OutputImageType::PixelType m_LineValue; typename PixelSuppressionType::Pointer m_PixelSuppression; typename LocalHoughType::Pointer m_LocalHough; typename FillGapsType::Pointer m_FillGaps; typename DrawLineListType::Pointer m_DrawLineList; typename RescaleType::Pointer m_Rescaler; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbExtractSegmentsImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbExtractSegmentsImageFilter.txx000066400000000000000000000152141301006202600274160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtractSegmentsImageFilter_txx #define otbExtractSegmentsImageFilter_txx #include "otbExtractSegmentsImageFilter.h" namespace otb { /** * */ template ExtractSegmentsImageFilter ::ExtractSegmentsImageFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); m_PixelSuppression = PixelSuppressionType::New(); m_LocalHough = LocalHoughType::New(); m_FillGaps = FillGapsType::New(); m_DrawLineList = DrawLineListType::New(); m_Rescaler = RescaleType::New(); m_LineValue = static_cast(255.); } /** * Set/Get image input */ template void ExtractSegmentsImageFilter ::SetInputImage(const InputImageType *image) { this->SetInput(0, image); } template const typename ExtractSegmentsImageFilter::InputImageType * ExtractSegmentsImageFilter ::GetInputImage() { return static_cast (this->GetInput(0)); } /** * Set/Get image direction input */ template void ExtractSegmentsImageFilter ::SetInputImageDirection(const InputImageType *image) { this->SetInput(1, image); } template const typename ExtractSegmentsImageFilter::InputImageType * ExtractSegmentsImageFilter ::GetInputImageDirection() { return static_cast (this->GetInput(1)); } /** * Set/Get PixelSuppressionyDirectionImageFilter parameters */ template void ExtractSegmentsImageFilter ::SetPixelSuppressionRadius(SizeType Radius) { m_PixelSuppression->SetRadius(Radius); } template const typename ExtractSegmentsImageFilter::SizeType ExtractSegmentsImageFilter ::GetPixelSuppressionRadius() { return (m_PixelSuppression->GetRadius()); } template void ExtractSegmentsImageFilter ::SetPixelSuppressionAngularBeam(float AngularBeam) { m_PixelSuppression->SetAngularBeam(AngularBeam); } template float ExtractSegmentsImageFilter ::GetPixelSuppressionAngularBeam() { return (m_PixelSuppression->GetAngularBeam()); } /** * Set/Get LocalHoughFilter parameters */ template void ExtractSegmentsImageFilter ::SetLocalHoughRadius(SizeType Radius) { m_LocalHough->SetRadius(Radius); } template const typename ExtractSegmentsImageFilter::SizeType ExtractSegmentsImageFilter ::GetLocalHoughRadius() { return (m_LocalHough->GetRadius()); } template void ExtractSegmentsImageFilter ::SetLocalHoughNumberOfLines(unsigned int NumberOfLines) { m_LocalHough->SetNumberOfLines(NumberOfLines); } template unsigned int ExtractSegmentsImageFilter ::GetLocalHoughNumberOfLines() { return (m_LocalHough->GetNumberOfLines()); } template void ExtractSegmentsImageFilter ::SetLocalHoughDiscRadius(float DiscRadius) { m_LocalHough->SetDiscRadius(DiscRadius); } template float ExtractSegmentsImageFilter ::GetLocalHoughDiscRadius() { return (m_LocalHough->GetDiscRadius()); } template void ExtractSegmentsImageFilter ::SetLocalHoughVariance(float Variance) { m_LocalHough->SetVariance(Variance); } template float ExtractSegmentsImageFilter ::GetLocalHoughVariance() { return (m_LocalHough->GetVariance()); } /** * Set/Get FillGapsFilter parameters */ template void ExtractSegmentsImageFilter ::SetFillGapsRadius(float Radius) { m_FillGaps->SetRadius(Radius); } template float ExtractSegmentsImageFilter ::GetFillGapsRadius() { return (m_FillGaps->GetRadius()); } template void ExtractSegmentsImageFilter ::SetFillGapsAngularBeam(float AngularBeam) { m_FillGaps->SetAngularBeam(AngularBeam); } template float ExtractSegmentsImageFilter ::GetFillGapsAngularBeam() { return (m_FillGaps->GetAngularBeam()); } template void ExtractSegmentsImageFilter ::GenerateData() { m_PixelSuppression->SetInputImage(this->GetInputImage()); m_PixelSuppression->SetInputImageDirection(this->GetInputImageDirection()); m_Rescaler->SetInput(m_PixelSuppression->GetOutput()); m_LocalHough->SetInput(m_Rescaler->GetOutput()); m_FillGaps->SetInput (m_LocalHough->GetOutput()); m_DrawLineList->SetInput(this->GetInputImage()); m_DrawLineList->SetInputLineSpatialObjectList(m_FillGaps->GetOutput()); m_DrawLineList->SetValue(m_LineValue); m_DrawLineList->GraftOutput(this->GetOutput()); m_DrawLineList->Update(); this->GraftOutput(m_DrawLineList->GetOutput()); } /** * Standard "PrintSelf" method */ template void ExtractSegmentsImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); /* os << indent << "Length: " << m_LengthLine << std::endl; os << indent << "Width: " << m_WidthLine << std::endl; */ } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbFillGapsFilter.h000066400000000000000000000046171301006202600244450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFillGapsFilter_h #define otbFillGapsFilter_h #include "itkProcessObject.h" #include "otbLineSpatialObjectList.h" namespace otb { /** \class FillGapsFilter * \brief To be documented * * \ingroup OTBEdge */ class ITK_EXPORT FillGapsFilter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef FillGapsFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(FillGapsFilter, itk::ProcessObject); /** Some convenient typedefs. */ typedef LineSpatialObjectList LineSpatialObjectListType; typedef LineSpatialObjectListType::Pointer LineSpatialObjectListPointer; typedef LineSpatialObjectListType::LineType LineSpatialObjectType; typedef LineSpatialObjectType::PointListType PointListType; typedef LineSpatialObjectType::LinePointType PointType; typedef itk::ProcessObject ProcessObjectType; using Superclass::SetInput; void SetInput(const LineSpatialObjectListType * input); const LineSpatialObjectListType * GetInput(); LineSpatialObjectListType * GetOutput(); itkSetMacro(AngularBeam, double); itkGetConstReferenceMacro(AngularBeam, double); itkSetMacro(Radius, double); itkGetConstReferenceMacro(Radius, double); protected: FillGapsFilter(); ~FillGapsFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: FillGapsFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_AngularBeam; double m_Radius; }; } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbHorizontalSobelVectorImageFilter.h000066400000000000000000000061241301006202600302030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHorizontalSobelVectorImageFilter_h #define otbHorizontalSobelVectorImageFilter_h #include "otbUnaryFunctorNeighborhoodVectorImageFilter.h" namespace otb { namespace Functor { /** \class HorizontalSobelOperator * \brief Performs the calculation of horizontal Sobel derivation * * \ingroup OTBEdge */ template < class TInput, class TOutput > class HorizontalSobelOperator { public: HorizontalSobelOperator() { } virtual ~HorizontalSobelOperator() { } TOutput operator() ( const TInput & input ) { unsigned int length = input.GetPixel(0).Size(); TOutput output ( length ); for ( unsigned int i = 0; i < length; ++i ) { output[i] = static_cast( ( input.GetPixel(0)[i] - input.GetPixel(2)[i] ) + 2 * ( input.GetPixel(3)[i] - input.GetPixel(5)[i] ) + ( input.GetPixel(6)[i] - input.GetPixel(8)[i] ) ); } return output; } }; // end of functor class } // end of namespace Functor /** \class HorizontalSobelVectorImageFilter * \brief Implements the Horizontal Sobel Gradient to be processed on a vector image * * \ingroup OTBEdge */ template < class TInputImage, class TOutputImage > class ITK_EXPORT HorizontalSobelVectorImageFilter : public UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::HorizontalSobelOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > { public: /** Standard class typedefs */ typedef HorizontalSobelVectorImageFilter Self; typedef UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::HorizontalSobelOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(HorizontalSobelVectorImageFilter, ImageToImageFilter); protected: HorizontalSobelVectorImageFilter() { typename Superclass::RadiusType radius = {{1, 1}}; this->SetRadius( radius ); } ~HorizontalSobelVectorImageFilter() ITK_OVERRIDE { } private: HorizontalSobelVectorImageFilter( const Self & ); // Not implemented void operator=( const Self & ); // Not implemented }; // end of class } // end of namespace otb #endif // otbHorizontalSobelVectorImageFilter_h OTB-release-5.8/Modules/Feature/Edge/include/otbHoughTransform2DLinesImageFilter.h000066400000000000000000000205051301006202600300300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHoughTransform2DLinesImageFilter_h #define otbHoughTransform2DLinesImageFilter_h #include "itkImageToImageFilter.h" #include "otbImage.h" #include "itkLineSpatialObject.h" namespace otb { /** * \class HoughTransform2DLinesImageFilter * \brief Performs the Hough Transform to find 2D straight lines * in a 2D image. * * This filter derives from ImageToImageFilter * The input is an image, and all pixels above some threshold are those * to be extracted. The output is the image of the accumulator. * GetLines() returns a list of LinesSpatialObjects * * Lines are parameterized in the form: R = x*vcl_cos(Teta)+y*vcl_sin(Teta) * where R is the perpendicular distance from the origin and Teta * the angle with the normal. * * The output is the accumulator array: * -The first dimension (X) represents the distance R from the origin * to the line. This is the distance axis. Its size depends on the size * of the diagonal of the input image. * * -The second dimension (Y) represents the angle between the X axis * and the normal to the line. This is the angle axis. Its size depends * on the AngleAxisSize parameter (500 by default) and its bounds can be * set with the AngleAxisMinimum and AngleAxisMaximum parameters * (-PI and +PI by default). * * \ingroup ImageFeatureExtraction * \sa LineSpatialObject * * * \ingroup OTBEdge * */ template class ITK_EXPORT HoughTransform2DLinesImageFilter : public itk::ImageToImageFilter< Image, Image > { public: /** Standard "Self" typedef. */ typedef HoughTransform2DLinesImageFilter Self; /** Input Image typedef */ typedef otb::Image InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; /** Output Image typedef */ typedef otb::Image OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; /** Smart pointer typedef support. */ typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Line typedef */ typedef itk::LineSpatialObject<2> LineType; typedef typename LineType::Pointer LinePointer; typedef std::list LinesListType; typedef LineType::LinePointType LinePointType; /** Standard "Superclass" typedef. */ typedef itk::ImageToImageFilter Superclass; /** Image index typedef */ typedef typename InputImageType::IndexType IndexType; /** Image pixel value typedef */ typedef typename InputImageType::PixelType PixelType; /** Typedef to describe the output image region type. */ typedef typename InputImageType::RegionType OutputImageRegionType; /** Run-time type information (and related methods). */ itkTypeMacro(HoughTransform2DLinesImageFilter, ImageToImageFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Method for evaluating the implicit function over the image. */ void GenerateData() ITK_OVERRIDE; /** Accessors for the threshold above which the filter should consider the point as a valid point */ itkSetMacro(Threshold, float); itkGetMacro(Threshold, float); /** Accessors for the parameters of the angle axis. The Hough space describes (in the angle direction) [AngleAxisMinimum, AngleAxisMaximum[ with AngleAxisSize values */ /** Accessors for the size of the angle axis */ itkSetMacro(AngleAxisSize, unsigned int); itkGetMacro(AngleAxisSize, unsigned int); /** Accessors for the minimum of the angle axis */ itkSetMacro(AngleAxisMinimum, double); itkGetMacro(AngleAxisMinimum, double); /** Accessors for the maximum of the angle axis */ itkSetMacro(AngleAxisMaximum, double); itkGetMacro(AngleAxisMaximum, double); /** Accessors for the parameters of the distance axis. The Hough space describes (in the distance direction) [DistanceAxisMinimum, DistanceAxisMaximum[ with DistanceAxisSize values */ /** Accessors for the actual size of the Distance axis */ itkSetMacro(DistanceAxisSize, unsigned int); itkGetMacro(DistanceAxisSize, unsigned int); /** Accessors for the maximum size of the Distance axis */ itkGetMacro(DistanceAxisMaximumSize, unsigned int); /** Accessors for the minimum of the Distance axis */ itkSetMacro(DistanceAxisMinimum, double); itkGetMacro(DistanceAxisMinimum, double); /** Accessors for the maximum of the Distance axis */ itkSetMacro(DistanceAxisMaximum, double); itkGetMacro(DistanceAxisMaximum, double); /** Set/Get the number of lines to extract */ itkSetMacro(NumberOfLines, unsigned int); itkGetMacro(NumberOfLines, unsigned int); /** Set/Get the radius of the disc to remove from the accumulator * for each line found */ itkSetMacro(DiscRadius, float); itkGetMacro(DiscRadius, float); /** Set/Get the variance of the gaussian bluring for the accumulator */ itkSetMacro(Variance, float); itkGetMacro(Variance, float); /** Simplify the accumulator */ void Simplify(void); /** Get the Simplified accumulator */ itkGetObjectMacro(SimplifyAccumulator, OutputImageType); /** Get the list of lines. This recomputes the lines */ LinesListType& GetLines(unsigned int n = 0); #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(IntConvertibleToOutputCheck, (itk::Concept::Convertible)); itkConceptMacro(InputGreaterThanFloatCheck, (itk::Concept::GreaterThanComparable)); itkConceptMacro(OutputPlusIntCheck, (itk::Concept::AdditiveOperators)); /** End concept checking */ #endif protected: HoughTransform2DLinesImageFilter(); ~HoughTransform2DLinesImageFilter() ITK_OVERRIDE {} HoughTransform2DLinesImageFilter(const Self &) {} void operator =(const Self&) {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** HoughTransform2DLinesImageFilter needs the entire input. Therefore * it must provide an implementation GenerateInputRequestedRegion(). * \sa ProcessObject::GenerateInputRequestedRegion(). */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** HoughTransform2DLinesImageFilter's output is the accumulator * array. The size of the output is a function of the size of the * input and of the angle and distance axis sizes. Since this output * has a different size than the input, it must provide an implementation * of GenerateOutputInformation. * \sa ProcessObject::GenerateOutputRequestedRegion() */ void GenerateOutputInformation() ITK_OVERRIDE; /** HoughTransform2DLinesImageFilter must produce the entire output */ void EnlargeOutputRequestedRegion(itk::DataObject *output) ITK_OVERRIDE; int GetAngleIndex(double); double GetAngleValue(int); int GetDistanceIndex(double); double GetDistanceValue(int); private: unsigned int m_AngleAxisSize; double m_AngleAxisMinimum; double m_AngleAxisMaximum; double m_AngleAxisIncrement; unsigned int m_DistanceAxisSize; unsigned int m_DistanceAxisMaximumSize; double m_DistanceAxisMinimum; double m_DistanceAxisMaximum; double m_DistanceAxisIncrement; float m_Threshold; OutputImagePointer m_SimplifyAccumulator; LinesListType m_LinesList; unsigned int m_NumberOfLines; float m_DiscRadius; float m_Variance; unsigned long m_OldModifiedTime; unsigned long m_OldNumberOfLines; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHoughTransform2DLinesImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbHoughTransform2DLinesImageFilter.txx000066400000000000000000000351231301006202600304260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHoughTransform2DLinesImageFilter_txx #define otbHoughTransform2DLinesImageFilter_txx #include "otbHoughTransform2DLinesImageFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkDiscreteGaussianImageFilter.h" #include "itkMinimumMaximumImageCalculator.h" #include "itkCastImageFilter.h" namespace otb { /** Constructor */ template HoughTransform2DLinesImageFilter ::HoughTransform2DLinesImageFilter() { const double nPI = 4.0 * vcl_atan(1.0); m_Threshold = 0; // by default m_AngleAxisSize = 500; m_AngleAxisMinimum = -nPI; m_AngleAxisMaximum = nPI; m_DistanceAxisSize = -1; m_DistanceAxisMinimum = -100; m_DistanceAxisMaximum = 100; m_NumberOfLines = 1; m_DiscRadius = 10; m_Variance = 5; m_OldModifiedTime = 0; m_OldNumberOfLines = 0; m_SimplifyAccumulator = ITK_NULLPTR; } template void HoughTransform2DLinesImageFilter ::EnlargeOutputRequestedRegion(itk::DataObject *output) { // call the superclass' implementation of this method Superclass::EnlargeOutputRequestedRegion(output); output->SetRequestedRegionToLargestPossibleRegion(); } template void HoughTransform2DLinesImageFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointers to the input and output InputImageConstPointer input = this->GetInput(); OutputImagePointer output = this->GetOutput(); if (!input || !output) { return; } // Compute the size of the output image if (m_DistanceAxisSize + 1 == 0) { double inputSize0 = input->GetLargestPossibleRegion().GetSize()[0]; double inputSize1 = input->GetLargestPossibleRegion().GetSize()[1]; double inputDiagonalSize = sqrt(inputSize0 * inputSize0 + inputSize1 * inputSize1); m_DistanceAxisSize = (long unsigned int) inputDiagonalSize; } itk::Size<2> size; size[0] = (long unsigned int) m_DistanceAxisSize; size[1] = (long unsigned int) m_AngleAxisSize; typename InputImageType::RegionType region; region.SetSize(size); region.SetIndex(input->GetLargestPossibleRegion().GetIndex()); output->SetLargestPossibleRegion(region); } template void HoughTransform2DLinesImageFilter ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); if (this->GetInput()) { InputImagePointer image = const_cast(this->GetInput()); image->SetRequestedRegionToLargestPossibleRegion(); } } /** Generate the accumulator image */ template void HoughTransform2DLinesImageFilter ::GenerateData() { itkDebugMacro(<< "HoughTransform2DLinesImageFilter called"); m_AngleAxisIncrement = (m_AngleAxisMaximum - m_AngleAxisMinimum) / m_AngleAxisSize; m_DistanceAxisIncrement = (m_DistanceAxisMaximum - m_DistanceAxisMinimum) / m_DistanceAxisSize; // Get the input and output pointers InputImageConstPointer inputImage = this->GetInput(0); OutputImagePointer outputImage = this->GetOutput(0); // Allocate the output this->AllocateOutputs(); outputImage->FillBuffer(0); itk::ImageRegionConstIteratorWithIndex image_it(inputImage, inputImage->GetRequestedRegion()); image_it.GoToBegin(); itk::Index<2> index; // Pre-computation of trigonometric lines unsigned int nbAngles = static_cast(m_AngleAxisSize); std::vector cosAngle(nbAngles, 0.); std::vector sinAngle(nbAngles, 0.); //const double nPI = 4.0 * vcl_atan( 1.0 ); Unused in this method for (unsigned int indexAngle = 0; indexAngle < nbAngles; indexAngle++) { double angle = this->GetAngleValue(indexAngle); cosAngle[indexAngle] = vcl_cos(angle); sinAngle[indexAngle] = vcl_sin(angle); } while (!image_it.IsAtEnd()) { if (image_it.Get() > m_Threshold) { for (unsigned int indexAngle = 0; indexAngle < nbAngles; indexAngle++) { double r = image_it.GetIndex()[0] * cosAngle[indexAngle] + image_it.GetIndex()[1] * sinAngle[indexAngle]; unsigned int indexR = this->GetDistanceIndex(r); index[0] = indexR; // m_R index[1] = indexAngle; // m_Theta if (outputImage->GetBufferedRegion().IsInside(index)) { outputImage->SetPixel(index, outputImage->GetPixel(index) + image_it.Get()); } } } ++image_it; } } /** Simplify the accumulator * Do the same iteration process as the Update() method but find the maximum * along the curve and then remove the curve */ template void HoughTransform2DLinesImageFilter ::Simplify(void) { // Get the input and output pointers InputImageConstPointer inputImage = this->GetInput(0); OutputImagePointer outputImage = this->GetOutput(0); if (!inputImage || !outputImage) { itkExceptionMacro("Update() must be called before Simplify()."); } /** Allocate the simplify accumulator */ m_SimplifyAccumulator = OutputImageType::New(); m_SimplifyAccumulator->SetRegions(outputImage->GetLargestPossibleRegion()); m_SimplifyAccumulator->SetOrigin(inputImage->GetOrigin()); m_SimplifyAccumulator->SetSpacing(inputImage->GetSpacing()); m_SimplifyAccumulator->Allocate(); m_SimplifyAccumulator->FillBuffer(0); itk::Index<2> index; itk::Index<2> maxIndex; typename OutputImageType::PixelType value; typename OutputImageType::PixelType valuemax; itk::ImageRegionConstIteratorWithIndex image_it(inputImage, inputImage->GetRequestedRegion()); image_it.GoToBegin(); while (!image_it.IsAtEnd()) { if (image_it.Get() > m_Threshold) { // Look for maximum along the curve and remove the curve at the same time valuemax = -1; maxIndex[0] = 0; maxIndex[1] = 0; for (double angle = m_AngleAxisMinimum; angle < m_AngleAxisMaximum; angle += m_AngleAxisIncrement) { index[0] = (long int) (image_it.GetIndex()[0] * vcl_cos(angle) + image_it.GetIndex()[1] * vcl_sin(angle)); // m_R index[1] = (long int) (this->GetAngleIndex(angle)); // m_Theta if (outputImage->GetBufferedRegion().IsInside(index)) { value = outputImage->GetPixel(index); if (value > valuemax) { valuemax = value; maxIndex = index; } } } m_SimplifyAccumulator->SetPixel(maxIndex, m_SimplifyAccumulator->GetPixel(maxIndex) + 1); } ++image_it; } itk::ImageRegionConstIteratorWithIndex accusimple_it(m_SimplifyAccumulator, m_SimplifyAccumulator->GetRequestedRegion()); itk::ImageRegionIteratorWithIndex accu_it(outputImage, outputImage->GetRequestedRegion()); accusimple_it.GoToBegin(); accu_it.GoToBegin(); while (!accusimple_it.IsAtEnd()) { accu_it.Set(accusimple_it.Get()); ++accu_it; ++accusimple_it; } } /** Get the list of lines. This recomputes the lines */ template typename HoughTransform2DLinesImageFilter::LinesListType& HoughTransform2DLinesImageFilter ::GetLines(unsigned int n) { if ((this->GetMTime() == m_OldModifiedTime) && (n == m_OldNumberOfLines)) // if the filter has not been updated { return m_LinesList; } m_LinesList.clear(); /** Blur the accumulator in order to find the maximum */ typedef float InternalImagePixelType; typedef itk::Image InternalImageType; OutputImagePointer outputImage = this->GetOutput(0); if (!outputImage) { itkExceptionMacro("Update() must be called before GetLines()."); } /** Convert the accumulator output image type to internal image type*/ typedef itk::CastImageFilter CastImageFilterType; typename CastImageFilterType::Pointer castImageFilter = CastImageFilterType::New(); castImageFilter->SetInput(outputImage); typedef itk::DiscreteGaussianImageFilter GaussianFilterType; typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); gaussianFilter->SetInput(castImageFilter->GetOutput()); // the output is the accumulator image double variance[2]; variance[0] = m_Variance; variance[1] = m_Variance; gaussianFilter->SetVariance(variance); gaussianFilter->Update(); InternalImageType::Pointer postProcessImage = gaussianFilter->GetOutput(); typedef itk::MinimumMaximumImageCalculator MinMaxCalculatorType; typename MinMaxCalculatorType::Pointer minMaxCalculator = MinMaxCalculatorType::New(); itk::ImageRegionIterator it_input(postProcessImage, postProcessImage->GetLargestPossibleRegion()); const double nPI = 4.0 * vcl_atan(1.0); itk::Index<2> index; unsigned int lines = 0; bool found; // Find maxima do { minMaxCalculator->SetImage(postProcessImage); minMaxCalculator->ComputeMaximum(); InternalImageType::PixelType max = minMaxCalculator->GetMaximum(); found = false; for (it_input.GoToBegin(); !it_input.IsAtEnd(); ++it_input) { if (it_input.Get() == max) { // Create the line LineType::PointListType list; // insert two points per line double radius = this->GetDistanceValue(it_input.GetIndex()[0]); double teta = this->GetAngleValue(it_input.GetIndex()[1]); double Vx = radius * vcl_cos(teta); double Vy = radius * vcl_sin(teta); double norm = vcl_sqrt(Vx * Vx + Vy * Vy); double VxNorm = Vx / norm; double VyNorm = Vy / norm; if ((teta <= 0) || (teta >= nPI / 2)) { if (teta >= nPI / 2) { VyNorm = -VyNorm; VxNorm = -VxNorm; } LinePointType p; p.SetPosition(Vx, Vy); list.push_back(p); p.SetPosition(Vx - VyNorm * 5, Vy + VxNorm * 5); list.push_back(p); } else // if teta>0 { LinePointType p; p.SetPosition(Vx, Vy); list.push_back(p); p.SetPosition(Vx - VyNorm * 5, Vy + VxNorm * 5); list.push_back(p); } // end if(teta>0) // Create a Line Spatial Object LinePointer Line = LineType::New(); Line->SetId(lines); Line->SetPoints(list); Line->ComputeBoundingBox(); m_LinesList.push_back(Line); // Remove a black disc from the hough space domain for (double angle = m_AngleAxisMinimum; angle <= m_AngleAxisMaximum; angle += m_AngleAxisIncrement) { for (double length = 0; length < m_DiscRadius; length += 1) { index[0] = (long int) (it_input.GetIndex()[0] + length * vcl_cos(angle)); index[1] = (long int) (it_input.GetIndex()[1] + length * vcl_sin(angle)); if (postProcessImage->GetBufferedRegion().IsInside(index)) { postProcessImage->SetPixel(index, 0); } } } minMaxCalculator->SetImage(postProcessImage); minMaxCalculator->ComputeMaximum(); max = minMaxCalculator->GetMaximum(); ++lines; found = true; if (lines == m_NumberOfLines) break; } } } while ((lines < m_NumberOfLines) && (found)); m_OldModifiedTime = this->GetMTime(); m_OldNumberOfLines = m_LinesList.size(); return m_LinesList; } /** Print Self information */ template void HoughTransform2DLinesImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << "Threshold: " << m_Threshold << std::endl; os << "Angle axis size: " << m_AngleAxisSize << std::endl; os << "Angle axis minimum: " << m_AngleAxisMinimum << std::endl; os << "Angle axis maximum: " << m_AngleAxisMaximum << std::endl; os << "Number Of Lines: " << m_NumberOfLines << std::endl; os << "Disc Radius: " << m_DiscRadius << std::endl; os << "Accumulator blur variance: " << m_Variance << std::endl; os << "Simplify Accumulator" << m_SimplifyAccumulator << std::endl; } /** Computes angle index from angle value */ template int HoughTransform2DLinesImageFilter ::GetAngleIndex(double angle) { int indexAngle = static_cast((angle - m_AngleAxisMinimum) / m_AngleAxisIncrement); return indexAngle; } /** Computes angle value from angle index */ template double HoughTransform2DLinesImageFilter ::GetAngleValue(int indexAngle) { double angle = m_AngleAxisMinimum + indexAngle * m_AngleAxisIncrement; return angle; } /** Computes distance index from distance value */ template int HoughTransform2DLinesImageFilter ::GetDistanceIndex(double distance) { int indexDistance = static_cast((distance - m_DistanceAxisMinimum) / m_DistanceAxisIncrement); return indexDistance; } /** Computes distance value from distance index */ template double HoughTransform2DLinesImageFilter ::GetDistanceValue(int indexDistance) { double distance = m_DistanceAxisMinimum + indexDistance * m_DistanceAxisIncrement; return distance; } } // end namespace #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineCorrelationDetectorImageFilter.h000066400000000000000000000073121301006202600304650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineCorrelationDetectorImageFilter_h #define otbLineCorrelationDetectorImageFilter_h #include "otbLineDetectorImageFilterBase.h" namespace otb { /** *\class LineCorrelationDetectorImageFilter * \brief To be documented * * * \ingroup OTBEdge */ template > class ITK_EXPORT LineCorrelationDetectorImageFilter : public LineDetectorImageFilterBase { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef for the classes standards. */ typedef LineCorrelationDetectorImageFilter Self; typedef LineDetectorImageFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the "object factory". */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(LineCorrelationDetectorImageFilter, LineDetectorImageFilterBase); typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageDirectionType OutputImageDirectionType; typedef typename Superclass::InterpolatorType InterpolatorType; /** Typedefs to describe and access Interpolator */ typedef typename InterpolatorType::Pointer InterpolatorPointer; typedef typename InterpolatorType::CoordRepType CoordRepType; typedef typename InputImageType::PointType TPoint; /** Definition of the input and output images */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Definition of the size of the images. */ typedef typename InputImageType::SizeType SizeType; protected: LineCorrelationDetectorImageFilter(); ~LineCorrelationDetectorImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Compute the measure */ double ComputeMeasure(std::vector* m1, std::vector* m2, std::vector* m3) ITK_OVERRIDE; private: LineCorrelationDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineCorrelationDetectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineCorrelationDetectorImageFilter.txx000066400000000000000000000101231301006202600310530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineCorrelationDetectorImageFilter_txx #define otbLineCorrelationDetectorImageFilter_txx #include "otbLineCorrelationDetectorImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "otbMath.h" namespace otb { /** * */ template LineCorrelationDetectorImageFilter ::LineCorrelationDetectorImageFilter() { this->m_Radius.Fill(1); this->m_LengthLine = 1; this->m_WidthLine = 0; this->m_FaceList.Fill(0); } template double LineCorrelationDetectorImageFilter ::ComputeMeasure(std::vector* m1, std::vector* m2, std::vector* m3) { double M1 = 0.0; double M2 = 0.0; double M3 = 0.0; std::vector::iterator m1It = m1->begin(); std::vector::iterator m1End = m1->end(); std::vector::iterator m2It = m2->begin(); std::vector::iterator m2End = m2->end(); std::vector::iterator m3It = m3->begin(); std::vector::iterator m3End = m3->end(); while (m1It != m1End && m2It != m2End && m3It != m3End) { M1 += (*m1It); ++m1It; M2 += (*m2It); ++m2It; M3 += (*m3It); ++m3It; } M1 /= m1->size(); M2 /= m2->size(); M3 /= m3->size(); double sigma1 = 0.0; double sigma2 = 0.0; double sigma3 = 0.0; m1It = m1->begin(); m2It = m2->begin(); m3It = m3->begin(); while (m1It != m1End && m2It != m2End && m3It != m3End) { sigma1 += vcl_pow((*m1It) - M1, 2); ++m1It; sigma2 += vcl_pow((*m2It) - M2, 2); ++m2It; sigma3 += vcl_pow((*m3It) - M3, 2); ++m3It; } sigma1 /= m1->size(); sigma2 /= m2->size(); sigma3 /= m3->size(); // Actually, we use the variance /* sigma1 = vcl_sqrt(sigma1); sigma2 = vcl_sqrt(sigma2); sigma3 = vcl_sqrt(sigma3); */ // Calculation of the cross correlation coefficient double d1 = 0.; double d2 = 0.; double d3 = 0.; double rho12 = 0.; double rho13 = 0.; // rho12 if (M2 != 0.) { d1 = sigma1 / vcl_pow(M2, 2) * m1->size(); d2 = sigma2 / vcl_pow(M2, 2) * m2->size(); d3 = vcl_pow(((M1 / M2) - 1.), 2) * (m1->size() * m2->size()); if ((d3 != 0.)) rho12 = static_cast(1. / (1. + ((m1->size() + m2->size()) * (d1 + d2) / d3))); else rho12 = 0.; } if (M3 != 0.) { d1 = sigma1 / vcl_pow(M3, 2) * m1->size(); d2 = sigma3 / vcl_pow(M3, 2) * m2->size(); d3 = vcl_pow(((M1 / M3) - 1.), 2) * (m1->size() * m2->size()); if ((d3 != 0.)) rho13 = static_cast(1. / (1. + ((m1->size() + m2->size()) * (d1 + d2) / d3))); else rho13 = 0.; } rho12 = vcl_sqrt(rho12); rho13 = vcl_sqrt(rho13); // Determination of the minimum intensity of detection between R12 et R13 return static_cast(std::min(rho12, rho13)); } /** * Standard "PrintSelf" method */ template void LineCorrelationDetectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineDetectorImageFilterBase.h000066400000000000000000000150451301006202600270600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineDetectorImageFilterBase_h #define otbLineDetectorImageFilterBase_h #include "itkNearestNeighborInterpolateImageFunction.h" #include "itkLinearInterpolateImageFunction.h" #include "otbImageToModulusAndDirectionImageFilter.h" #include "otbImage.h" #include "itkNumericTraits.h" namespace otb { /** \class LineDetectorImageFilterBase * * \brief Base class for line detector filters. * * This is the base class for the hierarchy of line detector * filters. Line detectors work by detecting 2 parallel edges for * a given set of directions. This class implements the * ThreadedGenerateData"()" method which, for every pixel and for * every direction, builds three sets of pixels (left, center and * right with respect to the reference direction). The * ThreadedGenerateData"()" method calls the virtual * ComputeMeasure"()" method which implements the detection. This * method should be overloaded by each specific line detector. * * The output is an image of intensity of detection and an image of * direction of the line fo each pixel. * * * \ingroup OTBEdge */ template > class ITK_EXPORT LineDetectorImageFilterBase : public ImageToModulusAndDirectionImageFilter { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef for the classes standards. */ typedef LineDetectorImageFilterBase Self; typedef ImageToModulusAndDirectionImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(LineDetectorImageFilterBase, ImageToModulusAndDirectionImageFilter); typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageDirectionType OutputImageDirectionType; typedef TInterpolator InterpolatorType; /** Typedefs to describe and access Interpolator */ typedef typename InterpolatorType::Pointer InterpolatorPointer; typedef typename InterpolatorType::CoordRepType CoordRepType; typedef typename InputImageType::PointType TPoint; /** Definition of the input and output images */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Definition of the size of the images. */ typedef typename InputImageType::SizeType SizeType; /** Set the length of the linear feature. */ itkSetMacro(LengthLine, unsigned int); /** Get the length of the linear feature. */ itkGetConstReferenceMacro(LengthLine, unsigned int); /** Set the width of the linear feature. */ itkSetMacro(WidthLine, unsigned int); /** Get the length of the linear feature. */ itkGetConstReferenceMacro(WidthLine, unsigned int); /** Set the radius of one zone. */ itkSetMacro(Radius, SizeType); /** Get the radius of one zone. */ itkGetConstReferenceMacro(Radius, SizeType); /** Set the radius of one zone. */ itkSetMacro(Threshold, OutputPixelType); /** Get the radius of one zone. */ itkGetConstReferenceMacro(Threshold, OutputPixelType); /** Set the numbero of drections for line detection. */ itkSetMacro(NumberOfDirections, unsigned int); /** Get the numbero of drections for line detection. */ itkGetConstReferenceMacro(NumberOfDirections, unsigned int); void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; protected: LineDetectorImageFilterBase(); ~LineDetectorImageFilterBase() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** LineDetectorImageFilterBase can be implemented for a treatment of filter multithreaded. * Thus, the ThreadedGenerateData() method is called for each thread process. * The data image are allocated automatically by the mother class by calling the * ThreadedGenerateData() method. ThreadedGenerateData can only write the portion * of the image specified by the parameter outputRegionForThread * * \sa ImageToImageFilter::ThreadedGenerateData() * \sa ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; virtual double ComputeMeasure(std::vector* m1, std::vector* m2, std::vector* m3); /** Length of the linear feature = 2*m_LengthLine+1 */ unsigned int m_LengthLine; /** Width of the linear feature = 2*m_WidthLine+1 */ unsigned int m_WidthLine; /** Radius of the region*/ SizeType m_Radius; /** Size of the facelist*/ SizeType m_FaceList; OutputPixelType m_Threshold; unsigned int m_NumberOfDirections; private: LineDetectorImageFilterBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineDetectorImageFilterBase.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineDetectorImageFilterBase.txx000066400000000000000000000337531301006202600274620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineDetectorImageFilterBase_txx #define otbLineDetectorImageFilterBase_txx #include "otbLineDetectorImageFilterBase.h" #include "itkDataObject.h" #include "itkConstantPadImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { /** * */ template LineDetectorImageFilterBase ::LineDetectorImageFilterBase() { this->SetNumberOfRequiredOutputs(2); this->SetNumberOfRequiredOutputs(1); m_Radius.Fill(1); m_LengthLine = 1; m_WidthLine = 0; m_Threshold = 0; m_NumberOfDirections = 4; m_FaceList.Fill(0); // THOMAS : donc contructeur de base // this->SetNthOutput(0, OutputImageType::New()); // this->SetNthOutput(1, OutputImageType::New()); } template void LineDetectorImageFilterBase ::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // Define the size of the region by the radius m_Radius[1] = static_cast(3 * (2 * m_WidthLine + 1) + 2); m_Radius[0] = 2 * m_LengthLine + 1; // Define the size of the facelist by taking into account the rotation of the region m_FaceList[0] = static_cast(vcl_sqrt(static_cast( (m_Radius[0] * m_Radius[0]) + (m_Radius[1] * m_Radius[1]))) + 1); m_FaceList[1] = m_FaceList[0]; otbMsgDevMacro(<< "Radius : " << m_Radius[0] << " " << m_Radius[1]); otbMsgDevMacro(<< "-> FaceList : " << m_FaceList[0] << " " << m_FaceList[1]); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_FaceList); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /* * Set up state of filter before multi-threading. * InterpolatorType::SetInputImage is not thread-safe and hence * has to be set up before ThreadedGenerateData */ template void LineDetectorImageFilterBase ::BeforeThreadedGenerateData() { typename OutputImageType::Pointer output = this->GetOutput(); output->FillBuffer(0); typename OutputImageType::Pointer outputDirection = this->GetOutputDirection(); outputDirection->FillBuffer(0); } template void LineDetectorImageFilterBase ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { typename InputImageType::ConstPointer input = this->GetInput(); InterpolatorPointer interpolator2 = InterpolatorType::New(); interpolator2->SetInputImage(input); itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ConstNeighborhoodIterator bit, cit; typename itk::ConstNeighborhoodIterator::OffsetType off; itk::ImageRegionIterator it; itk::ImageRegionIterator itdir; // Allocate output typename OutputImageType::Pointer output = this->GetOutput(); typename OutputImageType::Pointer outputDir = this->GetOutputDirection(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(input, outputRegionForThread, m_FaceList); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); typename TInputImage::IndexType bitIndex; typename InterpolatorType::ContinuousIndexType Index; // -------------------------------------------------------------------------- // Number of direction const unsigned int NB_DIR = this->GetNumberOfDirections(); // Number of zone const int NB_ZONE = 3; // Definition of the 4 directions //double Theta[NB_DIR]; //ROMAIN double* Theta = new double[NB_DIR]; // La rotation nulle correspond a un contour horizontal -> 0 !! for (unsigned int i = 0; i < NB_DIR; ++i) { Theta[i] = (CONST_PI * (i / double(NB_DIR))); /* if(Theta[i]>CONST_PI) Theta[i] = Theta[i]-CONST_PI; if((i/double(NB_DIR))==0.5) Theta[i]=0.; */ } // Number of the zone unsigned int zone; // Intensity of the linear feature double R; // Direction of detection double Direction = 0.; // Pixel location in the input image int X, Y; // Pixel location after rotation in the system axis of the region double xout, yout; // location of the central pixel in the input image int Xc, Yc; // location of the central pixel between zone 1 and 2 and between zone 1 and 3 int Yc12, Yc13; //--------------------------------------------------------------------------- otbMsgDevMacro(<< "Theta : " << Theta[0] << " " << Theta[1] << " " << Theta[2] << " " << Theta[3]); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. //bool interiorFace = true; for (fit = faceList.begin(); fit != faceList.end(); ++fit) { bit = itk::ConstNeighborhoodIterator(m_Radius, input, *fit); cit = itk::ConstNeighborhoodIterator(m_FaceList, input, *fit); it = itk::ImageRegionIterator(output, *fit); itdir = itk::ImageRegionIterator(outputDir, *fit); bit.OverrideBoundaryCondition(&nbc); bit.GoToBegin(); cit.OverrideBoundaryCondition(&nbc); cit.GoToBegin(); otbMsgDevMacro(<< " ------------------- FaceList --------------------------"); while ((!bit.IsAtEnd()) && (!cit.IsAtEnd())) { InterpolatorPointer interpolator = InterpolatorType::New(); // Location of the central pixel of the region off.Fill(0); bitIndex = bit.GetIndex(off); Xc = bitIndex[0]; Yc = bitIndex[1]; // JULIEN : If the processed region is the center face // the input image can be used for the interpolation //if (interiorFace) // { // interpolator->SetInputImage(input); // } // else we must feed the interpolator with a partial image corresponding // to the boundary conditions //else // { typename InputImageType::RegionType tempRegion; typename InputImageType::SizeType tempSize; tempSize[0] = 2 * m_FaceList[0] + 1; tempSize[1] = 2 * m_FaceList[1] + 1; tempRegion.SetSize(tempSize); typename itk::ConstNeighborhoodIterator::OffsetType tempIndex; tempIndex[0] = off[0] - m_FaceList[0]; tempIndex[1] = off[1] - m_FaceList[1]; tempRegion.SetIndex(cit.GetIndex(tempIndex)); typename InputImageType::Pointer tempImage = InputImageType::New(); tempImage->SetRegions(tempRegion); tempImage->Allocate(); for (unsigned int p = 0; p <= 2 * m_FaceList[0]; ++p) { for (unsigned int q = 0; q <= 2 * m_FaceList[1]; q++) { typename itk::ConstNeighborhoodIterator::OffsetType index; index[0] = p - m_FaceList[0]; index[1] = q - m_FaceList[1]; tempImage->SetPixel(cit.GetIndex(index), cit.GetPixel(index)); } } interpolator->SetInputImage(tempImage); // } // Location of the central pixel between zone 1 and zone 2 Yc12 = Yc - m_WidthLine - 1; // Location of the central pixel between zone 1 and zone 3 Yc13 = Yc + m_WidthLine + 1; // Contains for the 4 directions the the pixels belonging to each zone //std::vector PixelValues[NB_DIR][NB_ZONE]; // ROMAIN std::vector** PixelValues = ITK_NULLPTR; PixelValues = new std::vector*[NB_DIR]; for (unsigned int i = 0; i < NB_DIR; ++i) { PixelValues[i] = ITK_NULLPTR; PixelValues[i] = new std::vector[NB_ZONE]; } //otbMsgDevMacro( << "\tCentre Xc/Yc="< Yc13) zone = 2; else continue; //otbMsgDevMacro( << "\t\tPoint traite (i, j)=("< X, Y="<= this->GetThreshold()) { // Assignment of this value to the output pixel it.Set(static_cast(R)); // Assignment of this value to the "outputdir" pixel itdir.Set(static_cast(Direction)); } else { it.Set(itk::NumericTraits::Zero); itdir.Set(static_cast(0)); } ++bit; ++cit; ++it; ++itdir; //interiorFace = false; progress.CompletedPixel(); // ROMAIN for (unsigned int i = 0; i < NB_DIR; ++i) { delete[] PixelValues[i]; PixelValues[i] = ITK_NULLPTR; } delete[] PixelValues; PixelValues = ITK_NULLPTR; } } delete[] Theta; } template double LineDetectorImageFilterBase ::ComputeMeasure(std::vector* itkNotUsed(m1), std::vector* itkNotUsed(m2), std::vector* itkNotUsed(m3)) { return 0; } /** * Standard "PrintSelf" method */ template void LineDetectorImageFilterBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Length: " << m_LengthLine << std::endl; os << indent << "Width: " << m_WidthLine << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineRatioDetectorImageFilter.h000066400000000000000000000121511301006202600272570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineRatioDetectorImageFilter_h #define otbLineRatioDetectorImageFilter_h #include "otbLineDetectorImageFilterBase.h" namespace otb { /** \class LineRatioDetectorImageFilter * \brief Application of detection of linear features based on the * ratio of local means. * * This class implements the Tupin's detector D1 used to detect * two parallel lines. This detector is derived from the coupling of two * ratio edge detectors (Touzi detector) on both side of a region. * * The region is divided in three zones to delimite two parallel lines. * The size of one zone is defined by the product of the width * of the linear feature by its length. * * For each vertical line, we calculate the intensity of detection * \f$ R_{12}(\theta_{0}) \f$ between zones 1 and 2 and \f$ R_{13}(\theta_{0})\f$ between * zones 1 and 3 according to the principle of the Touzi's filter. * * The response of the edge detector between two zones i and j is: * \f[R_{ij}=1-\min (\frac{\mu_{i}}{\mu_{j}};\frac{\mu_{j}}{\mu_{i}}) \f] * * The intensity of detection in the three other directions \f$ R(\theta_{i}) \f$ * is determined by rotation of the pixels of each zone around the * central pixel of the region considered. By default, the pixel location after * rotation is determined by the Spline interpolator. * * Finally, the intensity of detection formed by the two parallel lines * is determined by the minimum response of a ration edge detector on both sides * of the linear structure: * \f[ R = \min (R_{12}; R_{13}) \f] * where \f$ R_{12} \f$ and \f$ R_{13}\f$ are the maximum response of the ratio edge * detector of \f$ R(\theta_{i}) \f$. The intensity of detection lies in * the interval \f$ [0, 1] \f$. * * * * \ingroup OTBEdge */ template > class ITK_EXPORT LineRatioDetectorImageFilter : public LineDetectorImageFilterBase { public: /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef for the classes standards. */ typedef LineRatioDetectorImageFilter Self; typedef LineDetectorImageFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the "object factory". */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(LineRatioDetectorImageFilter, LineDetectorImageFilterBase); typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageDirectionType OutputImageDirectionType; typedef typename Superclass::InterpolatorType InterpolatorType; /** Typedefs to describe and access Interpolator */ typedef typename InterpolatorType::Pointer InterpolatorPointer; typedef typename InterpolatorType::CoordRepType CoordRepType; typedef typename InputImageType::PointType TPoint; /** Definition of the input and output images */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Definition of the size of the images. */ typedef typename InputImageType::SizeType SizeType; protected: LineRatioDetectorImageFilter(); ~LineRatioDetectorImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; double ComputeMeasure(std::vector* m1, std::vector* m2, std::vector* m3) ITK_OVERRIDE; private: LineRatioDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineRatioDetectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineRatioDetectorImageFilter.txx000066400000000000000000000062211301006202600276540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineRatioDetectorImageFilter_txx #define otbLineRatioDetectorImageFilter_txx #include "otbLineRatioDetectorImageFilter.h" #include "otbMacro.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "otbMath.h" namespace otb { /** * */ template LineRatioDetectorImageFilter ::LineRatioDetectorImageFilter() { this->m_Radius.Fill(1); this->m_LengthLine = 1; this->m_WidthLine = 0; this->m_FaceList.Fill(0); } template double LineRatioDetectorImageFilter ::ComputeMeasure(std::vector* m1, std::vector* m2, std::vector* m3) { double M1 = 0.0; double M2 = 0.0; double M3 = 0.0; std::vector::iterator m1It = m1->begin(); std::vector::iterator m1End = m1->end(); std::vector::iterator m2It = m2->begin(); std::vector::iterator m2End = m2->end(); std::vector::iterator m3It = m3->begin(); std::vector::iterator m3End = m3->end(); while (m1It != m1End && m2It != m2End && m3It != m3End) { M1 += (*m1It); ++m1It; M2 += (*m2It); ++m2It; M3 += (*m3It); ++m3It; } M1 /= m1->size(); M2 /= m2->size(); M3 /= m3->size(); double R12 = 0.0; double R13 = 0.0; double epsilon = 0.0000000001; if ((vcl_abs(M1) > epsilon) && (vcl_abs(M2) > epsilon)) R12 = static_cast(1 - std::min((M1 / M2), (M2 / M1))); else if ((vcl_abs(M1) > epsilon) || (vcl_abs(M2) > epsilon)) R12 = 1.0; else R12 = 0.; if ((vcl_abs(M1) > epsilon) && (vcl_abs(M3) > epsilon)) R13 = static_cast(1 - std::min((M1 / M3), (M3 / M1))); else if ((vcl_abs(M1) > epsilon) || (vcl_abs(M3) > epsilon)) R13 = 1.0; else R13 = 0.; // Determination of the minimum intensity of detection between R12 et R13 return static_cast(std::min(R12, R13)); } /** * Standard "PrintSelf" method */ template void LineRatioDetectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineSegmentDetector.h000066400000000000000000000243261301006202600255010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSegmentDetector_h #define otbLineSegmentDetector_h #include "otbImage.h" #include "otbVectorDataSource.h" #include "otbVectorData.h" #include "itkUnaryFunctorImageFilter.h" #include "itkGradientRecursiveGaussianImageFilter.h" #include "itkGradientImageFilter.h" namespace otb { namespace Functor { /** \class MagnitudeFunctor * \brief This functor computes the magnitude of a covariant vector. * * \ingroup OTBEdge */ template class MagnitudeFunctor { public: inline TOutputPixel operator ()(const TInputPixel& input) { return static_cast(2 * vcl_sqrt(input[0] * input[0] + input[1] * input[1])); } }; /** \class OrientationFunctor * \brief This functor computes the orientation of a covariant vector
* Orientation values lies between -Pi and Pi. * * \ingroup OTBEdge */ template class OrientationFunctor { public: inline TOutputPixel operator ()(const TInputPixel& input) { return static_cast(vcl_atan2(input[0], -input[1])); } }; } // end namespace Functor /** \class LineSegmentDetector * \brief this class implement a fast line detector with false detection control using * the a contrario method * * The implementation is based on the online version of the lsd * documentation and code lsd 1.5. The OTB version use a 3x3 filter * to compute the gradient(vs. 2x2 in the original implementation) * and implements the density control, the NOTINIT status and the * incremental rectangle optimisation. * * \sa StreamingLineSegmentDetector (streamed version) * \ingroup FeatureExtraction * * See Publication : * " LSD: A line segment detector ", R. Grompone, J.Jackubowicz, J-M.Morel, G.Randall * And Website : * http://www.ipol.im/pub/algo/gjmr_line_segment_detector/ * * * \ingroup OTBEdge */ template class ITK_EXPORT LineSegmentDetector : public VectorDataSource< otb::VectorData > { public: /** typedef for the classes standards. */ typedef LineSegmentDetector Self; typedef VectorDataSource< VectorData > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(LineSegmentDetector, VectorDataSource); /** Definition of the input image */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SpacingType SpacingType; typedef typename InputImageType::PointType OriginType; /** Definition of the output vector data. */ typedef VectorData VectorDataType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename VectorDataType::LineType LineType; typedef typename VectorDataType::PointType PointType; typedef typename LineType::VertexType VertexType; /** Definition of temporary image ised to store LABELS*/ typedef Image OutputImageType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::SizeType OutputSizeType; /** Histogram to store the coordinate of ordered pixels*/ typedef std::vector IndexVectorType; typedef typename IndexVectorType::iterator IndexVectorIteratorType; typedef std::vector CoordinateHistogramType; typedef typename CoordinateHistogramType::iterator CoordinateHistogramIteratorType; /** typedef structure to store REGION*/ typedef std::vector VectorOfIndexVectorType; typedef std::vector DirectionVectorType; typedef typename DirectionVectorType::iterator DirectionVectorIteratorType; /** */ typedef itk::GradientRecursiveGaussianImageFilter GradientFilterType; typedef typename GradientFilterType::Pointer GradientFilterPointerType; typedef typename GradientFilterType::OutputImageType GradientOutputImageType; typedef itk::UnaryFunctorImageFilter > MagnitudeFilterType; typedef typename MagnitudeFilterType::Pointer MagnitudeFilterPointerType; typedef typename MagnitudeFilterType::OutputImageType::PixelType MagnitudePixelType; typedef typename MagnitudeFilterType::OutputImageType MagnitudeImageType; typedef typename MagnitudeImageType::Pointer MagnitudeImagePointerType; typedef itk::UnaryFunctorImageFilter > OrientationFilterType; typedef typename OrientationFilterType::Pointer OrientationFilterPointerType; typedef typename OrientationFilterType::OutputImageType OutputImageDirType; typedef typename OutputImageDirType::RegionType OutputImageDirRegionType; /** Create an image to store the label USED(255), NOTINI(127) or NOTUSED (0)*/ typedef otb::Image LabelImageType; typedef typename LabelImageType::Pointer LabelImagePointerType; /** Vector to store the rectangle characteization center, width, orientation , ( begin , end ) of the central line*/ typedef std::vector RectangleType; typedef typename RectangleType::iterator RectangleIteratorType; typedef std::vector RectangleListType; typedef typename RectangleListType::iterator RectangleListTypeIterator; /** Set/Get the input image of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputImageType *input); virtual const InputImageType * GetInput(void); /** Custom Get methods to access intermediate data*/ LabelImagePointerType GetMap() { return m_UsedPointImage; } MagnitudeImagePointerType GetGradMod() { return m_MagnitudeFilter->GetOutput(); } typename OutputImageDirType::Pointer GetGradOri() { return m_OrientationFilter->GetOutput(); } protected: LineSegmentDetector(); ~LineSegmentDetector() ITK_OVERRIDE {} void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Generate Data method*/ void GenerateData() ITK_OVERRIDE; /** Sort the image and store the coordinates in a histogram * this method is used to determine the seeds where to begin the search segments * Points with large gradient modulus are more able to belong to a segment */ virtual CoordinateHistogramType SortImageByModulusValue(MagnitudeImagePointerType modulusImage); /** */ virtual void LineSegmentDetection(CoordinateHistogramType& CoordinateHistogram); /** Return true if the pixel status is NOTUSED*/ virtual bool IsNotUsed(InputIndexType& index) const; /** Return true if the pixel status is USED*/ virtual bool IsUsed(InputIndexType& index) const; /** Return true if the pixel status is NOTINI*/ virtual bool IsNotIni(InputIndexType& index) const; /** Set Pixel flag to USED*/ virtual void SetPixelToUsed(InputIndexType index); /** Set Pixel flag to NOTINI*/ virtual void SetPixelToNotIni(InputIndexType index); /** Set Pixels flag to NOTINI*/ virtual void SetRegionToNotIni(IndexVectorType region); /** search for a segment which begins from a seed "index "*/ virtual bool GrowRegion(InputIndexType index, IndexVectorType ®ion, double ®ionAngle); /** Define if two are aligned */ virtual bool IsAligned(double Angle, double regionAngle, double prec) const; /** For each region of the region List it builds a rectangle */ virtual int ComputeRectangles(); /** */ virtual RectangleType Region2Rectangle(IndexVectorType region, double regionAngle); /** */ virtual double ComputeRegionOrientation(IndexVectorType region, double x, double y, double angleRegion) const; /** */ virtual double angle_diff(double a, double b) const; /** Compute the Number Of False Alarm for a rectangle*/ virtual double ComputeRectNFA(const RectangleType& rec) const; /** */ virtual double ImproveRectangle(RectangleType& rectangle) const; /** NFA For a rectangle*/ virtual double NFA(int n, int k, double p, double logNT) const; /** Create a copy of a rectangle*/ virtual void CopyRectangle(RectangleType& rDst, RectangleType& rSrc) const; /** Printself method*/ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LineSegmentDetector(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented VectorOfIndexVectorType m_RegionList; DirectionVectorType m_DirectionVector; LabelImagePointerType m_UsedPointImage; RectangleListType m_RectangleList; double m_Threshold; double m_Prec; double m_DirectionsAllowed; unsigned int m_MinimumRegionSize; /** Gradient filter */ GradientFilterPointerType m_GradientFilter; /** Magnitude filter */ MagnitudeFilterPointerType m_MagnitudeFilter; /** Orientation filter */ OrientationFilterPointerType m_OrientationFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineSegmentDetector.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLineSegmentDetector.txx000066400000000000000000001007271301006202600260750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineSegmentDetector_txx #define otbLineSegmentDetector_txx #include "otbLineSegmentDetector.h" #include "itkImageRegionIterator.h" #include "itkMinimumMaximumImageCalculator.h" #include "itkImageConstIterator.h" #include "itkNeighborhoodIterator.h" #include "otbPolygon.h" #include "itkCastImageFilter.h" #include "otbRectangle.h" #include "otbRemoteSensingRegion.h" #include "otbMath.h" #include "itkMatrix.h" #include "itkSymmetricEigenAnalysis.h" extern "C" double dlngam_(double *x); extern "C" double dbetai_(double *x, double *a, double *b); namespace otb { template LineSegmentDetector ::LineSegmentDetector() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_DirectionsAllowed = 1. / 8.; m_Prec = CONST_PI * m_DirectionsAllowed; m_Threshold = 5.2; /** Compute the modulus and the orientation gradient images */ m_GradientFilter = GradientFilterType::New(); m_MagnitudeFilter = MagnitudeFilterType::New(); m_OrientationFilter = OrientationFilterType::New(); /** Image to store the pixels used 0:NOTUSED 127:NOTINIT 255:USED*/ m_UsedPointImage = LabelImageType::New(); } template void LineSegmentDetector ::SetInput(const InputImageType *input) { this->Superclass::SetNthInput(0, const_cast(input)); } template const typename LineSegmentDetector ::InputImageType * LineSegmentDetector ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(0)); } template void LineSegmentDetector ::GenerateInputRequestedRegion(void) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the inputs typename InputImageType::Pointer input = const_cast (this->GetInput()); if ( !input ) { return; } // The input is necessarily the largest possible region. // For a streamed implementation, use the StreamingLineSegmentDetector filter input->SetRequestedRegionToLargestPossibleRegion(); } template void LineSegmentDetector ::GenerateData() { if (this->GetInput()->GetRequestedRegion() != this->GetInput()->GetLargestPossibleRegion()) { itkExceptionMacro(<< "Not streamed filter. ERROR : requested region is not the largest possible region."); } /** Allocate memory for the temporary label Image*/ m_UsedPointImage->SetRegions(this->GetInput()->GetLargestPossibleRegion()); m_UsedPointImage->Allocate(); m_UsedPointImage->FillBuffer(0); /** Cast the MagnitudeOutput Image in */ typedef itk::CastImageFilter castFilerType; typename castFilerType::Pointer castFilter = castFilerType::New(); castFilter->SetInput(this->GetInput()); /** Compute the modulus and the orientation gradient image */ m_GradientFilter->SetInput(castFilter->GetOutput()); m_GradientFilter->SetSigma(0.6); m_MagnitudeFilter->SetInput(m_GradientFilter->GetOutput()); m_OrientationFilter->SetInput(m_GradientFilter->GetOutput()); m_MagnitudeFilter->Update(); m_OrientationFilter->Update(); /** Compute the seed histogram to begin the search*/ CoordinateHistogramType CoordinateHistogram; CoordinateHistogram = this->SortImageByModulusValue(m_MagnitudeFilter->GetOutput()); /** Search the segments on the image by growing a region from a seed */ this->LineSegmentDetection(CoordinateHistogram); /** Transfert the detected segment to the output vector data */ this->ComputeRectangles(); } template typename LineSegmentDetector ::CoordinateHistogramType LineSegmentDetector ::SortImageByModulusValue(MagnitudeImagePointerType modulusImage) { RegionType largestRegion = this->GetInput()->GetLargestPossibleRegion(); // Compute the minimum region size double logNT = 5. * vcl_log10( static_cast(largestRegion.GetNumberOfPixels()) ) / 2.; double log1_p = vcl_log10(m_DirectionsAllowed); double rapport = logNT / log1_p; m_MinimumRegionSize = static_cast(-rapport); // Computing the min & max of the image typedef itk::MinimumMaximumImageCalculator MinMaxCalculatorFilter; typename MinMaxCalculatorFilter::Pointer minmaxCalculator = MinMaxCalculatorFilter::New(); minmaxCalculator->SetImage(modulusImage); minmaxCalculator->ComputeMinimum(); OutputPixelType min = minmaxCalculator->GetMinimum(); minmaxCalculator->ComputeMaximum(); OutputPixelType max = minmaxCalculator->GetMaximum(); /** Compute the threshold on the gradient*/ m_Threshold = m_Threshold * ((max - min) / 255.); // threshold normalized with min & max of the values /** Computing the length of the bins*/ unsigned int NbBin = 1024; double lengthBin = static_cast((max - min)) / static_cast(NbBin-1); CoordinateHistogramType tempHisto(NbBin); /** Initializing the histogram */ // New region : without boundaries RegionType region; SizeType size = modulusImage->GetRequestedRegion().GetSize(); InputIndexType id = modulusImage->GetRequestedRegion().GetIndex(); // Don't take in carre the boundary of the image. // Special cases for streamed call if (modulusImage->GetRequestedRegion().GetIndex()[0] == 0) { id[0]++; size[0]--; if (modulusImage->GetRequestedRegion().GetSize()[0] + modulusImage->GetRequestedRegion().GetIndex()[0] == largestRegion.GetSize(0)) size[0]--; } else if (modulusImage->GetRequestedRegion().GetSize()[0] + modulusImage->GetRequestedRegion().GetIndex()[0] == largestRegion.GetSize(0)) { size[0]--; } if (modulusImage->GetRequestedRegion().GetIndex()[1] == 0) { id[1]++; size[1]--; if (modulusImage->GetRequestedRegion().GetSize()[1] + modulusImage->GetRequestedRegion().GetIndex()[1] == largestRegion.GetSize(1)) size[1]--; } else if (modulusImage->GetRequestedRegion().GetSize()[1] + modulusImage->GetRequestedRegion().GetIndex()[1] == largestRegion.GetSize(1)) { size[1]--; } region.SetIndex(id); region.SetSize(size); itk::ImageRegionIterator it(modulusImage, region); it.GoToBegin(); while (!it.IsAtEnd()) { unsigned int bin = static_cast (static_cast(it.Value()-min) / lengthBin); // Highlights bug 498 assert(bin 1e-10) tempHisto[NbBin - bin - 1].push_back(it.GetIndex()); else SetPixelToUsed(it.GetIndex()); ++it; } return tempHisto; } /**************************************************************************************************************/ /** * Method used to search the segments */ template void LineSegmentDetector ::LineSegmentDetection(CoordinateHistogramType& CoordinateHistogram) { /** Begin the search of the segments*/ CoordinateHistogramIteratorType ItCoordinateList = CoordinateHistogram.begin(); while (ItCoordinateList != CoordinateHistogram.end()) { typename IndexVectorType::iterator ItIndexVector = (*ItCoordinateList).begin(); while (ItIndexVector != (*ItCoordinateList).end()) { InputIndexType index = *(ItIndexVector); /** If the point is not yet computed */ if (this->IsNotUsed(index)) { IndexVectorType region; double regionAngle = 0.; bool fail = GrowRegion(index, region, regionAngle); if (!fail) { //region -> rectangle RectangleType rectangle = Region2Rectangle(region, regionAngle); //ImprovRectangle(&rectangle) double nfa = ImproveRectangle(rectangle); double density = (double)region.size() / ( vcl_sqrt((rectangle[2]-rectangle[0])*(rectangle[2]-rectangle[0]) +(rectangle[3]-rectangle[1])*(rectangle[3]-rectangle[1])) * rectangle[4] ); if (density < 0.7) { nfa = -1; //std::cout << "Density = " << density << std::endl; } //if NFA(ImprovRect(rec)) > 0. if (nfa > 0.) { m_RectangleList.push_back(rectangle); } else { SetRegionToNotIni(region); } } } ++ItIndexVector; } ++ItCoordinateList; } } /**************************************************************************************************************/ /** * Method used to compute rectangles from region * Here you can access the NFA for each region */ template int LineSegmentDetector ::ComputeRectangles() { // Output this->GetOutput(0)->SetMetaDataDictionary(this->GetInput()->GetMetaDataDictionary()); // Retrieving root node typename DataNodeType::Pointer root = this->GetOutput(0)->GetDataTree()->GetRoot()->Get(); // Create the document node typename DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(document, root); // Create the folder node typename DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(folder, document); this->GetOutput(0)->SetProjectionRef(this->GetInput()->GetProjectionRef()); SpacingType spacing = this->GetInput()->GetSpacing(); OriginType origin = this->GetInput()->GetOrigin(); /** store the lines*/ RectangleListTypeIterator itRec = m_RectangleList.begin(); while (itRec != m_RectangleList.end()) { VertexType start, end; start[0] = origin[0] + static_cast((*itRec)[0]) * spacing[0]; start[1] = origin[1] + static_cast((*itRec)[1]) * spacing[1]; end[0] = origin[0] + static_cast((*itRec)[2]) * spacing[0]; end[1] = origin[1] + static_cast((*itRec)[3]) * spacing[1]; typename DataNodeType::Pointer CurrentGeometry = DataNodeType::New(); CurrentGeometry->SetNodeId("FEATURE_LINE"); CurrentGeometry->SetNodeType(otb::FEATURE_LINE); typename LineType::Pointer line = LineType::New(); CurrentGeometry->SetLine(line); this->GetOutput(0)->GetDataTree()->Add(CurrentGeometry, folder); CurrentGeometry->GetLine()->AddVertex(start); CurrentGeometry->GetLine()->AddVertex(end); ++itRec; } return EXIT_SUCCESS; } /**************************************************************************************************************/ /** * Copy a rectangle rSrc in a rectangle rDst */ template void LineSegmentDetector ::CopyRectangle(RectangleType& rDst, RectangleType& rSrc) const { RectangleIteratorType itSrc = rSrc.begin(); while (itSrc != rSrc.end()) { rDst.push_back(*(itSrc)); ++itSrc; } } /**************************************************************************************************************/ /** * Method used to compute improve the NFA of The rectangle by changing * the components of the rectangle */ template double LineSegmentDetector ::ImproveRectangle(RectangleType &rec) const { int n = 0; double nfa_new; double delta = 0.5; double delta_2 = delta / 2.0; RectangleType r; double nfa_rect = this->ComputeRectNFA(rec); if (nfa_rect > 0.) return nfa_rect; /*Try to improve the precision of the oriented */ CopyRectangle(r, rec); for (n = 0; n < 5; ++n) { r[7] /= 2.0; r[6] = CONST_PI * r[7]; // prec = rec[6] nfa_new = this->ComputeRectNFA(r); if (nfa_new > nfa_rect) { nfa_rect = nfa_new; CopyRectangle(rec, r); } } if (nfa_rect > 0.) return nfa_rect; /*Try to improve the width of the rectangle*/ CopyRectangle(r, rec); for (n = 0; n < 5; ++n) { r[4] -= delta; //r[4] is stored as the width nfa_new = this->ComputeRectNFA(r); if (nfa_new > nfa_rect) { nfa_rect = nfa_new; CopyRectangle(rec, r); } } if (nfa_rect > 0.) return nfa_rect; /*Try to improve the extremity of the segments*/ CopyRectangle(r, rec); for (n = 0; n < 5; ++n) { if ((r[4] - delta) >= 0.5) { r[0] += -vcl_sin(r[5]) * delta_2; r[1] += vcl_cos(r[5]) * delta_2; r[2] += -vcl_sin(r[5]) * delta_2; r[3] += vcl_cos(r[5]) * delta_2; r[4] -= delta; nfa_new = this->ComputeRectNFA(r); if (nfa_new > nfa_rect) { nfa_rect = nfa_new; CopyRectangle(rec, r); } } } if (nfa_rect > 0.) return nfa_rect; CopyRectangle(r, rec); for (n = 0; n < 5; ++n) { if ((r[4] - delta) >= 0.5) { r[0] -= -vcl_sin(r[5]) * delta_2; r[1] -= vcl_cos(r[5]) * delta_2; r[2] -= -vcl_sin(r[5]) * delta_2; r[3] -= vcl_cos(r[5]) * delta_2; r[4] -= delta; nfa_new = this->ComputeRectNFA(r); if (nfa_new > nfa_rect) { nfa_rect = nfa_new; CopyRectangle(rec, r); } } } if (nfa_rect > 0.) return nfa_rect; /*Try to improve the precision again */ CopyRectangle(r, rec); for (n = 0; n < 5; ++n) { r[7] /= 2.0; r[6] = CONST_PI * r[7]; // prec = rec[] nfa_new = this->ComputeRectNFA(r); if (nfa_new > nfa_rect) { nfa_rect = nfa_new; CopyRectangle(rec, r); } } return nfa_rect; } /**************************************************************************************************************/ /** * Method IsNotUsed : Determine if a point was NOTUSED or not. search in the m_LabelImage */ template bool LineSegmentDetector ::IsNotUsed(InputIndexType& index) const { bool isNotUsed = false; typedef itk::ImageConstIterator ImageIteratorType; RegionType region = m_UsedPointImage->GetLargestPossibleRegion(); InputIndexType indexRef = region.GetIndex(); ImageIteratorType itLabel(m_UsedPointImage, region); itLabel.GoToBegin(); if (m_UsedPointImage->GetLargestPossibleRegion().IsInside(index)) { itLabel.SetIndex(index); if (itLabel.Get() == 0) isNotUsed = true; } else { itkExceptionMacro(<< "Can't access to index " << index << ", outside the image largest region (" << indexRef << ", " << region.GetSize() << ")"); } return isNotUsed; } /**************************************************************************************************************/ /** * Method IsUsed : Determine if a point was USED or not. search in the m_LabelImage */ template bool LineSegmentDetector ::IsUsed(InputIndexType& index) const { bool isUsed = false; typedef itk::ImageConstIterator ImageIteratorType; RegionType region = m_UsedPointImage->GetLargestPossibleRegion(); InputIndexType indexRef = region.GetIndex(); ImageIteratorType itLabel(m_UsedPointImage, region); itLabel.GoToBegin(); if (m_UsedPointImage->GetLargestPossibleRegion().IsInside(index)) { itLabel.SetIndex(index); if (itLabel.Get() == 255) isUsed = true; } else { itkExceptionMacro(<< "Can't access to index " << index << ", outside the image largest region (" < bool LineSegmentDetector ::IsNotIni(InputIndexType& index) const { bool isNotIni = false; typedef itk::ImageConstIterator ImageIteratorType; RegionType region = m_UsedPointImage->GetLargestPossibleRegion(); InputIndexType indexRef = region.GetIndex(); ImageIteratorType itLabel(m_UsedPointImage, region); itLabel.GoToBegin(); if (m_UsedPointImage->GetLargestPossibleRegion().IsInside(index)) { itLabel.SetIndex(index); if (itLabel.Get() == 127) isNotIni = true; } else { itkExceptionMacro(<< "Can't access to index " << index << ", outside the image largest region (" << indexRef << ", " << region.GetSize() << ")"); } return isNotIni; } /**************************************************************************************************************/ /** * Method SetPixelToUsed : Set a pixel to USED */ template void LineSegmentDetector ::SetPixelToUsed(InputIndexType index) { typedef itk::NeighborhoodIterator NeighborhoodLabelIteratorType; typename NeighborhoodLabelIteratorType::SizeType radiusLabel; radiusLabel.Fill(0); NeighborhoodLabelIteratorType itLabel(radiusLabel, m_UsedPointImage, m_UsedPointImage->GetRequestedRegion()); itLabel.SetLocation(index); itLabel.SetCenterPixel(255); // 255 : Set the point status to : Used Point } /**************************************************************************************************************/ /** * Method SetPixelToNotIni : Set a pixel to NOTINI */ template void LineSegmentDetector ::SetPixelToNotIni(InputIndexType index) { typedef itk::NeighborhoodIterator NeighborhoodLabelIteratorType; typename NeighborhoodLabelIteratorType::SizeType radiusLabel; radiusLabel.Fill(0); NeighborhoodLabelIteratorType itLabel(radiusLabel, m_UsedPointImage, m_UsedPointImage->GetRequestedRegion()); itLabel.SetLocation(index); itLabel.SetCenterPixel(127); // 127 : Set the point status to : Not Ini Point } /**************************************************************************************************************/ /** * Method SetRegionToNotIni : Set a region pixels to NOTINI */ template void LineSegmentDetector ::SetRegionToNotIni(IndexVectorType region) { IndexVectorIteratorType it = region.begin(); while (it != region.end()) { this->SetPixelToNotIni(*it); it ++; } } /**************************************************************************************************************/ /** * Method GrowRegion : From a seed grow the region to find a connected region with the same orientation * within a precision (m_Prec) */ template bool LineSegmentDetector ::GrowRegion(InputIndexType index, IndexVectorType& region, double& regionAngle) { /** Add the point to the used list point*/ this->SetPixelToUsed(index); /** Neighborhooding */ typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typename NeighborhoodIteratorType::SizeType radius; radius.Fill(1); NeighborhoodIteratorType itNeigh(radius, m_MagnitudeFilter->GetOutput(), m_MagnitudeFilter->GetOutput()->GetRequestedRegion()); NeighborhoodIteratorType itNeighDir(radius, m_OrientationFilter->GetOutput(), m_OrientationFilter->GetOutput()-> GetRequestedRegion()); /** Vector where to store the point belonging to the current region*/ unsigned int neighSize = itNeigh.GetSize()[0] * itNeigh.GetSize()[1]; /** Add the first point to the region */ region.push_back(index); double sumX = 0.; double sumY = 0.; /** * Loop for searching regions */ for (unsigned int cpt = 0; cpt < region.size(); ++cpt) { itNeigh.SetLocation(region[cpt]); itNeighDir.SetLocation(region[cpt]); sumX += vcl_cos(*(itNeighDir.GetCenterValue())); sumY += vcl_sin(*(itNeighDir.GetCenterValue())); regionAngle = vcl_atan2(sumY, sumX); unsigned int s = 0; while (s < neighSize) { InputIndexType NeighIndex = itNeigh.GetIndex(s); double angleComp = itNeighDir.GetPixel(s); if (this->GetInput()->GetLargestPossibleRegion().IsInside(NeighIndex)) /** Check if the index is inside the image*/ { if ((this->IsNotUsed(NeighIndex) || this->IsNotIni(NeighIndex)) && this->IsAligned(angleComp, regionAngle, m_Prec)) { this->SetPixelToUsed(NeighIndex); region.push_back(NeighIndex); } } ++s; } } /** End Searching loop*/ unsigned int nbPixels = this->GetInput()->GetLargestPossibleRegion().GetNumberOfPixels(); if (region.size() > m_MinimumRegionSize && region.size() < nbPixels / 4) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } } /**************************************************************************************************************/ /** * The method atan2 gives values of angles modulo PI, put the angle in a rang [0, Pi] */ template bool LineSegmentDetector ::IsAligned(double Angle, double regionAngle, double prec) const { double diff = Angle - regionAngle; if (diff < 0.0) diff = -diff; if (diff > 1.5 * CONST_PI) { diff -= CONST_2PI; if (diff < 0.0) diff = -diff; } return diff < prec; } /**************************************************************************************************************/ /** * compute the best rectangle possible that */ template typename LineSegmentDetector ::RectangleType LineSegmentDetector ::Region2Rectangle(IndexVectorType region, double regionAngle) { /** Local Variables*/ double weight = 0., sumWeight = 0.; double x = 0., y = 0.; double l_min = 0., l_max = 0., l = 0., w = 0., w_min = 0., w_max = 0.; /** Neighborhooding again*/ typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typename NeighborhoodIteratorType::SizeType radius; radius.Fill(0); NeighborhoodIteratorType itNeigh(radius, m_MagnitudeFilter->GetOutput(), m_MagnitudeFilter->GetOutput()->GetRequestedRegion()); /** Computing the center of the rectangle*/ IndexVectorIteratorType it = region.begin(); while (it != region.end()) { itNeigh.SetLocation(*it); weight = *itNeigh.GetCenterValue(); x += static_cast((*it)[0]) * weight; y += static_cast((*it)[1]) * weight; sumWeight += weight; ++it; } if (sumWeight < 1e-10) { x = 0.; y = 0.; } else { x /= sumWeight; y /= sumWeight; } /** Compute the orientation of the region*/ double theta = this->ComputeRegionOrientation(region, x, y, regionAngle); /* Length & Width of the rectangle **/ typedef std::vector MagnitudeVector; RegionType largestRegion = this->GetInput()->GetLargestPossibleRegion(); unsigned int Diagonal = static_cast(vnl_math_hypot(static_cast(largestRegion.GetSize(1)), static_cast( largestRegion.GetSize(0))) + 2); MagnitudeVector sum_l(2*Diagonal, itk::NumericTraits::Zero); MagnitudeVector sum_w(2*Diagonal, itk::NumericTraits::Zero); double dx = vcl_cos(theta); double dy = vcl_sin(theta); it = region.begin(); while (it != region.end()) { itNeigh.SetLocation(*it); weight = *itNeigh.GetCenterValue(); l = (static_cast((*it)[0]) - x) * dx + (static_cast((*it)[1]) - y) * dy; w = -(static_cast((*it)[0]) - x) * dy + (static_cast((*it)[1]) - y) * dx; if (l < l_min) l_min = l; if (l > l_max) l_max = l; if (w < w_min) w_min = w; if (w > w_max) w_max = w; sum_l[static_cast < int > (vcl_floor(l) + 0.5) + Diagonal] += static_cast(weight); sum_w[static_cast < int > (vcl_floor(w) + 0.5) + Diagonal] += static_cast(weight); ++it; } /** Thresholdinq the width and the length*/ double sum_th = 0.01 * sumWeight; /* weight threshold for selecting region */ double s = 0.; int i = 0; for (s = 0.0, i = static_cast(l_min); s < sum_th && i <= static_cast(l_max); ++i) s += sum_l[Diagonal + i]; double lb = (static_cast(i - 1) - 0.5); for (s = 0.0, i = static_cast(l_max); s < sum_th && i >= static_cast(l_min); i--) s += sum_l[Diagonal + i]; double lf = (static_cast(i + 1) + 0.5); for (s = 0.0, i = static_cast(w_min); s < sum_th && i <= static_cast(w_max); ++i) s += sum_w[Diagonal + i]; double wr = (static_cast(i - 1) - 0.5); for (s = 0.0, i = static_cast(w_max); s < sum_th && i >= static_cast(w_min); i--) s += sum_w[Diagonal + i]; double wl = (static_cast(i + 1) + 0.5); /** Finally store the rectangle in vector this way : * vec[0] = x1 * vec[1] = y1 * vec[2] = x2 * vec[3] = y2 * vec[4] = width * vec[5] = theta * vec[6] = prec = Pi/8 * vec[7] = p = 1/8 */ RectangleType rec(8, 0.); // Definition of a // rectangle : 8 components if (vcl_abs(wl - wr) - vcl_sqrt( static_cast (largestRegion.GetSize(0) * largestRegion.GetSize(0) + largestRegion.GetSize(1) * largestRegion.GetSize(1))) < 1e-10 ) { rec[0] = (x + lb * dx > 0) ? x + lb * dx : 0.; rec[1] = (y + lb * dy > 0) ? y + lb * dy : 0.; rec[2] = (x + lf * dx > 0) ? x + lf * dx : 0.; rec[3] = (y + lf * dy > 0) ? y + lf * dy : 0; rec[4] = wl - wr; rec[5] = theta; rec[6] = m_Prec; rec[7] = m_DirectionsAllowed; if (rec[4] - 1. < 1e-10) rec[4] = 1.; } return rec; } /**************************************************************************************************************/ /** * Compute the orientation of a region , using an eigen Value analysis. */ template double LineSegmentDetector ::ComputeRegionOrientation(IndexVectorType region, double x, double y, double angleRegion) const { double Ixx = 0.0; double Iyy = 0.0; double Ixy = 0.0; double theta = 0.; double weight = 0., sum = 0.; /** Neighborhooding again*/ typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typename NeighborhoodIteratorType::SizeType radius; radius.Fill(0); NeighborhoodIteratorType itNeigh(radius, m_MagnitudeFilter->GetOutput(), m_MagnitudeFilter->GetOutput()->GetRequestedRegion()); /** Computing the center of the rectangle*/ IndexVectorIteratorType it = region.begin(); while (it != region.end()) { itNeigh.SetLocation(*it); weight = *itNeigh.GetCenterValue(); double Iyy2 = static_cast((*it)[0]) - x; double Ixx2 = static_cast((*it)[1]) - y; Ixx += Ixx2 * Ixx2 * weight; Iyy += Iyy2 * Iyy2 * weight; Ixy -= Ixx2 * Iyy2 * weight; sum += weight; ++it; } /** using te itk Eigen analysis*/ typedef itk::Matrix MatrixType; typedef std::vector MatrixEigenType; MatrixType Inertie, eigenVector; MatrixEigenType eigenMatrix(2, 0.); Inertie[1][1] = Ixx; Inertie[0][0] = Iyy; Inertie[0][1] = Ixy; Inertie[1][0] = Ixy; typedef itk::SymmetricEigenAnalysis EigenAnalysisType; EigenAnalysisType eigenFilter(2); eigenFilter.ComputeEigenValuesAndVectors(Inertie, eigenMatrix, eigenVector); theta = vcl_atan2(eigenVector[1][1], -eigenVector[1][0]); /* the previous procedure don't cares orientations, so it could be wrong by 180 degrees. here is corrected if necessary */ if (this->angle_diff(theta, angleRegion) > m_Prec) theta += CONST_PI; return theta; } /**************************************************************************************************************/ /** * Compute the difference betwenn 2 angles modulo 2_PI */ template double LineSegmentDetector ::angle_diff(double a, double b) const { a -= b; while (a <= -CONST_PI) a += CONST_2PI; while (a > CONST_PI) a -= CONST_2PI; if (a < 0.0) a = -a; return a; } /**************************************************************************************************************/ /** * compute the number of false alarm of the rectangle */ template double LineSegmentDetector ::ComputeRectNFA(const RectangleType& rec) const { int NbAligned = 0; double nfa_val = 0.; /** Compute the NFA of the rectangle * We Need : The number of : Points in the rec (Area of the rectangle) * Aligned points with theta in the rectangle */ /** Compute the number of points aligned */ typedef otb::Rectangle RectangleType; RectangleType::Pointer rectangle = RectangleType::New(); /** Fill the rectangle with the points*/ for (int i = 0; i < 2; ++i) { typename RectangleType::VertexType vertex; vertex[0] = rec[2 * i]; vertex[1] = rec[2 * i + 1]; rectangle->AddVertex(vertex); } rectangle->SetWidth(rec[4]); rectangle->SetOrientation(rec[5]); /** Get The Bounding Region*/ OutputImageDirRegionType region = m_OrientationFilter->GetOutput()->GetLargestPossibleRegion(); region.Crop(rectangle->GetBoundingRegion()); itk::ImageRegionIterator it(m_OrientationFilter->GetOutput(), region); it.GoToBegin(); int pts = 0; while (!it.IsAtEnd()) { if (rectangle->IsInside(it.GetIndex()) && m_OrientationFilter->GetOutput()->GetBufferedRegion().IsInside(it.GetIndex())) { ++pts; if (this->IsAligned(it.Get(), rec[5] /*theta*/, rec[6] /*Prec*/)) NbAligned++; } ++it; } /** Compute the NFA from the rectangle computed below*/ RegionType largestRegion = const_cast(this)->GetInput()->GetLargestPossibleRegion(); double logNT = 5. * vcl_log10( static_cast(largestRegion.GetNumberOfPixels()) ) / 2.; nfa_val = NFA(pts, NbAligned, m_DirectionsAllowed, logNT); return nfa_val; } /**************************************************************************************************************/ /* compute logarithm of binomial NFA NFA = NT.b(n, k, p) log10 NFA = log10( NFA ) n, k, p - binomial parameters. logNT - logarithm of Number of Tests */ template double LineSegmentDetector ::NFA(int n, int k, double p, double logNT) const { double val; double n_d = static_cast(n); double k_d = static_cast(k); if (k == 0) return -logNT; // double x = p; double a = k_d; double b = n_d - k_d + 1.0; val = -logNT - log10( dbetai_(&p, &a, &b) ); if (vnl_math_isinf(val)) /* approximate by the first term of the tail */ { double x1 = n_d + 1.0; double x2 = k_d + 1.0; double x3 = n_d - k_d + 1.0; val = -logNT - (dlngam_(&x1) - dlngam_(&x2) - dlngam_(&x3)) / CONST_LN10 - k_d * log10(p) - (n_d - k_d) * log10(1.0 - p); } return val; } /** * Standard "PrintSelf" method */ template void LineSegmentDetector ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLocalHoughFilter.h000066400000000000000000000131361301006202600247650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalHoughFilter_h #define otbLocalHoughFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkHoughTransform2DLinesImageFilter.h" #include "otbImageToLineSpatialObjectListFilter.h" #include "otbExtractROI.h" namespace otb { /** \class LocalHoughFilter * \brief Application of Hough filter on a nxm pixel tiling of the image. * * This class implements a filter that applies the hough transform on nxm * pixel tiling of the image. The Hough filter is used to find straight * lines in a 2-dimensional image. It detects the best line in each tile * and suppresses dubious line detection due to small local structures. * * Input parameters are : the tile radius, the number of lines we are * looking for, the variance of the accumulator blurring (default = 5) and * the radius of the disc to remove from the accumulator (default = 10). * * * \ingroup OTBEdge */ template class ITK_EXPORT LocalHoughFilter : public ImageToLineSpatialObjectListFilter { public: /** Standard class typedefs. */ typedef LocalHoughFilter Self; typedef ImageToLineSpatialObjectListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the "object factory". */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(LocalHoughFilter, ImageToLineSpatialObjectListFilter); /** Definition of the list of lines. */ typedef typename Superclass::LinesListType LinesListType; typedef typename LinesListType::const_iterator LineIterator; typedef typename LinesListType::LineType LineType; typedef typename LineType::Pointer LinePointer; typedef typename LineType::PointListType PointListType; typedef typename LineType::LinePointType LinePointType; /** Extract dimensions as well of the images of entry of exit. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); typedef TInputImage InputImageType; //------------------------------------------------------------ typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; //----------------------------------------------- /** Definition of the pixel type of the input and output images */ typedef typename InputImageType::PixelType InputPixelType; typedef float AccumulatorPixelType; typedef typename InputImageType::RegionType InputImageRegionType; /** Definition of the size of the images. */ typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::RegionType::IndexType IndexType; /** Typedefs to define the extract ROI filter. */ typedef ExtractROI ROIFilterType; /** Set the radius of the local region where to apply the Hough filter. */ itkSetMacro(Radius, SizeType); /** Get the radius of the local region. */ itkGetConstReferenceMacro(Radius, SizeType); /** Set the radius of the overlap of the local region where to apply the Hough filter. */ itkSetMacro(Overlap, SizeType); /** Get the radius of the overlap. */ itkGetConstReferenceMacro(Overlap, SizeType); /** Set the number of lines we are looking for. */ itkSetMacro(NumberOfLines, unsigned int); /** Get the number of lines we are looking for. */ itkGetConstReferenceMacro(NumberOfLines, unsigned int); /** Set/Get the radius of the disc to remove from the accumulator * for each line found */ itkSetMacro(DiscRadius, float); itkGetMacro(DiscRadius, float); /** Set/Get the variance of the gaussian bluring for the accumulator */ itkSetMacro(Variance, float); itkGetMacro(Variance, float); itkSetMacro(Threshold, float); itkGetMacro(Threshold, float); protected: LocalHoughFilter(); ~LocalHoughFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Definition of the Hough Filter. */ typedef itk::HoughTransform2DLinesImageFilter HoughFilterType; void GenerateData() ITK_OVERRIDE; private: LocalHoughFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius used to define the local region. */ SizeType m_Radius; /** Radius used to define the overlap of local regions. */ SizeType m_Overlap; /** Parameter of the Hough filter : number of lines we are looking for. */ unsigned int m_NumberOfLines; /** Variance of the accumulator blurring (default = 5). */ float m_Variance; /** Radius of the disc to remove from the accumulator (default = 10). */ float m_DiscRadius; /** Threshold abouve which a pixel is consedered as valid */ float m_Threshold; LinePointer LinePointResearch(LineIterator itLines, InputImageType *localImage, IndexType origin); }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLocalHoughFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbLocalHoughFilter.txx000066400000000000000000000172651301006202600253700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalHoughFilter_txx #define otbLocalHoughFilter_txx #include "otbLocalHoughFilter.h" #include "otbImage.h" namespace otb { /** * */ template LocalHoughFilter::LocalHoughFilter() : ImageToLineSpatialObjectListFilter(), m_NumberOfLines(1), m_Variance(5), m_DiscRadius(10), m_Threshold(0) { m_Radius.Fill(20); m_Overlap.Fill(0); } template typename LocalHoughFilter::LinePointer LocalHoughFilter:: LinePointResearch(LineIterator itLines, InputImageType *image, IndexType origin) { // Get the list of points which consists of two points to represent a // straight line PointListType& pointsList = (*itLines)->GetPoints(); typename PointListType::const_iterator itPoints = pointsList.begin(); double u[2]; u[0] = (*itPoints).GetPosition()[0]; u[1] = (*itPoints).GetPosition()[1]; ++itPoints; double v[2]; v[0] = u[0] - (*itPoints).GetPosition()[0]; v[1] = u[1] - (*itPoints).GetPosition()[1]; double norm = vcl_sqrt(v[0] * v[0] + v[1] * v[1]); v[0] /= norm; v[1] /= norm; typename InputImageType::RegionType region = image->GetLargestPossibleRegion(); PointListType ptList; LinePointType point; typename InputImageType::IndexType localIndex; typename InputImageType::IndexType previousIndex; typename InputImageType::IndexType nextIndex; // The diagonal is the largest distance between two edges of image itk::Size<2> size = region.GetSize(); float diag = vcl_sqrt((float) (size[0] * size[0] + size[1] * size[1])); // Loop on the largest distance to be sure to cover all the image // whatever the position of the origin u for (int i = static_cast(-diag); i < static_cast(diag); ++i) { previousIndex[0] = static_cast(u[0] + (i - 1) * v[0]); previousIndex[1] = static_cast(u[1] + (i - 1) * v[1]); localIndex[0] = static_cast(u[0] + i * v[0]); localIndex[1] = static_cast(u[1] + i * v[1]); nextIndex[0] = static_cast(u[0] + (i + 1) * v[0]); nextIndex[1] = static_cast(u[1] + (i + 1) * v[1]); // Check if the local index is inside the image and the previous // index is outside or if the local index is inside the image and // the next index is outside if (((region.IsInside(localIndex)) && (!region.IsInside(previousIndex))) || ((region.IsInside(localIndex)) && (!region.IsInside(nextIndex)))) { point.SetPosition(localIndex[0] + origin[0], localIndex[1] + origin[1]); ptList.push_back(point); } } // Check if the line is well defined by two points LinePointer line = LineType::New(); if (ptList.size() == 2) { line->SetId(0); line->SetPoints(ptList); line->ComputeBoundingBox(); } ptList.clear(); return (line); } template void LocalHoughFilter ::GenerateData() { typename InputImageType::ConstPointer input = this->GetInput(); typename LinesListType::Pointer list; list = this->GetOutput(); typename ROIFilterType::Pointer ROIfilter = ROIFilterType::New(); typename HoughFilterType::LinesListType lines; typename HoughFilterType::Pointer houghFilter = HoughFilterType::New(); // Get image size itk::Size<2> size = input->GetLargestPossibleRegion().GetSize(); // Loop on the input image // Direction X // x and y must be < size in order to avoid 0-sized regions for (unsigned long x = 0; x < size[0] - 1; x += (m_Radius[0] - m_Overlap[0])) { // Initialize the extract ROI filter in the direction X ROIfilter->SetStartX(x); // Number of pixels of the local region if ((x + m_Radius[0]) < size[0]) ROIfilter->SetSizeX(m_Radius[0]); else ROIfilter->SetSizeX(size[0] - x - 1); // Direction Y for (unsigned long y = 0; y < size[1] - 1; y += (m_Radius[1] - m_Overlap[1])) { // Initialize the extract ROI filter in the direction Y ROIfilter->SetStartY(y); if ((y + m_Radius[1]) < size[1]) ROIfilter->SetSizeY(m_Radius[1]); else ROIfilter->SetSizeY(size[1] - y - 1); // Extract the local region of the input image ROIfilter->SetInput(this->GetInput()); // ---------------------------------------------------- // Create a copy of the extract ROI filter output image // ---------------------------------------------------- typename InputImageType::Pointer localImage = InputImageType::New(); typename InputImageType::Pointer filterImage = InputImageType::New(); ROIfilter->UpdateLargestPossibleRegion(); ROIfilter->Update(); filterImage = ROIfilter->GetOutput(); // Create a new image from the extracted region. The starting // index is the corner of the newly generated image (0, 0) typename InputImageType::RegionType region; IndexType index; index[0] = 0; index[1] = 0; region.SetSize(filterImage->GetLargestPossibleRegion().GetSize()); region.SetIndex(index); localImage->SetRegions(region); localImage->SetOrigin(filterImage->GetOrigin()); localImage->SetSpacing(filterImage->GetSpacing()); localImage->Allocate(); typedef itk::ImageRegionIteratorWithIndex LocalIteratorType; typedef itk::ImageRegionConstIteratorWithIndex FilterIteratorType; LocalIteratorType localIt(localImage, localImage->GetRequestedRegion()); FilterIteratorType filterIt(filterImage, filterImage->GetRequestedRegion()); localIt.GoToBegin(); filterIt.GoToBegin(); // Copy the filter image in the new local image for (localIt.GoToBegin(); !localIt.IsAtEnd(); ++localIt, ++filterIt) localIt.Set(static_cast(filterIt.Get())); // ------------------------------- // Application of Hough filter // ------------------------------- houghFilter->SetInput(localImage); houghFilter->SetNumberOfLines(m_NumberOfLines); houghFilter->SetVariance(m_Variance); houghFilter->SetDiscRadius(m_DiscRadius); houghFilter->SetThreshold(m_Threshold); houghFilter->Modified(); houghFilter->Update(); // --------------------------------------- // Get the list of LineSpatialObject lines // --------------------------------------- lines = houghFilter->GetLines(m_NumberOfLines); LineIterator itLines = lines.begin(); // Loop on the lines of hough filter list while (itLines != lines.end()) { LinePointer line = LineType::New(); IndexType origin; origin[0] = x; origin[1] = y; // Call the private method that researchs the two points // used to define a line line = LinePointResearch(itLines, localImage, origin); if (line->GetNumberOfPoints() != 0) list->push_back(line); ++itLines; } lines.clear(); } // end of loop in y direction } // end of loop in x direction } template void LocalHoughFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbPersistentVectorizationImageFilter.h000066400000000000000000000076051301006202600306300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentVectorizationImageFilter_h #define otbPersistentVectorizationImageFilter_h #include "otbPersistentImageFilter.h" #include "otbObjectList.h" #include "otbImageToEdgePathFilter.h" #include "itkMinimumMaximumImageFilter.h" namespace otb { /** \class PersistentVectorizationImageFilter * \brief Perform vectorization in a persistent way. * * This filter allows vectorizing input labeled image while it is streamed * through it. The GetPathList() method allows getting the vectorized boundaries, * while the GetOutput() method allows getting the input image itself. * * The Reset() method allows clearing the result path list. * * \sa PersistentImageFilter * * * \ingroup OTBEdge */ template class ITK_EXPORT PersistentVectorizationImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentVectorizationImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentVectorizationImageFilter, PersistentImageFilter); /** Image related typedefs. */ // First Input typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; typedef typename TInputImage::InternalPixelType InternalPixelType; // Output path type typedef TOutputPath PathType; typedef otb::ObjectList PathListType; typedef typename PathListType::Pointer PathListPointerType; typedef typename PathType::Pointer PathPointerType; typedef itk::MinimumMaximumImageFilter MinMaxFilterType; typedef typename MinMaxFilterType::Pointer MinMaxFilterPointerType; typedef otb::ImageToEdgePathFilter ImageToEdgePathFilterType; typedef typename ImageToEdgePathFilterType::Pointer ImageToEdgePathFilterPointerType; void Reset(void) ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; itkGetObjectMacro(PathList, PathListType); protected: PersistentVectorizationImageFilter(); ~PersistentVectorizationImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: PersistentVectorizationImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Min max filter (the mini-pipeline) MinMaxFilterPointerType m_MinMaxFilter; // Where to store the vectorized objects PathListPointerType m_PathList; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPersistentVectorizationImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbPersistentVectorizationImageFilter.txx000066400000000000000000000044551301006202600312240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentVectorizationImageFilter_txx #define otbPersistentVectorizationImageFilter_txx #include "otbPersistentVectorizationImageFilter.h" #include "itkProgressReporter.h" namespace otb { template PersistentVectorizationImageFilter ::PersistentVectorizationImageFilter() { m_MinMaxFilter = MinMaxFilterType::New(); m_PathList = PathListType::New(); } template void PersistentVectorizationImageFilter ::Reset() { m_PathList->Clear(); } template void PersistentVectorizationImageFilter ::Synthetize() {} template void PersistentVectorizationImageFilter ::GenerateData() { // Compute the min max and handle mini-pipeline m_MinMaxFilter->SetInput(this->GetInput()); m_MinMaxFilter->GraftOutput(this->GetOutput()); m_MinMaxFilter->Update(); this->GraftOutput(m_MinMaxFilter->GetOutput()); for (PixelType label = m_MinMaxFilter->GetMinimum() + 1; label <= m_MinMaxFilter->GetMaximum(); ++label) { ImageToEdgePathFilterPointerType edgeFilter = ImageToEdgePathFilterType::New(); edgeFilter->SetInput(m_MinMaxFilter->GetOutput()); edgeFilter->SetForegroundValue(label); edgeFilter->Update(); m_PathList->PushBack(edgeFilter->GetOutput()); } } template void PersistentVectorizationImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbPixelSuppressionByDirectionImageFilter.h000066400000000000000000000110151301006202600313650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPixelSuppressionByDirectionImageFilter_h #define otbPixelSuppressionByDirectionImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" namespace otb { /** \class PixelSuppressionByDirectionImageFilter * \brief Application of a filter of suppression of isolated pixels, * not belonging to a line, strating from the directions of pixels. * * This class implements an image filter which detects isolated pixels * that have little chance of belonging to a raod and performs a pixel * suppression. For each pixel kept with direction \f$ \theta_{i} \f$, we look * for other pixels with a direction close to \f$ \theta_i \f$ in an angular * beam around it. If none is found, the pixel is suppressed. * * This filter is the first step to generate an image of segments * primitives. It starts from the two output images of the line detector * image filters which are the image of intensity of detection and * the image of direction. * * * \ingroup OTBEdge */ template class ITK_EXPORT PixelSuppressionByDirectionImageFilter : public itk::ImageToImageFilter { public: /** Extract input and output image dimensions */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** typedef for the classes standards. */ typedef PixelSuppressionByDirectionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the "object factory". */ itkNewMacro(Self); /** Return the nale of the class. */ itkTypeMacro(PixelSuppressionByDirectionImageFilter, ImageToImageFilter); /** Definition of the input and output images */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType SizeType; /** Set the radius of one zone. */ itkSetMacro(Radius, SizeType); /** Get the radius of one zone. */ itkGetConstReferenceMacro(Radius, SizeType); /** Set the angular beam. */ itkSetMacro(AngularBeam, InputRealType); /** Get the angular beam. */ itkGetConstReferenceMacro(AngularBeam, InputRealType); /** Set/Get the image input of this process object. */ void SetInputImage(const InputImageType *image); const InputImageType * GetInputImage(void); void SetInputImageDirection(const InputImageType *image); const InputImageType * GetInputImageDirection(void); void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; protected: PixelSuppressionByDirectionImageFilter(); ~PixelSuppressionByDirectionImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PixelSuppressionByDirectionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Radius of the region SizeType m_Radius; // Angular Accuracy on the direction of the central pixel InputRealType m_AngularBeam; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPixelSuppressionByDirectionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbPixelSuppressionByDirectionImageFilter.txx000066400000000000000000000216771301006202600320000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPixelSuppressionByDirectionImageFilter_txx #define otbPixelSuppressionByDirectionImageFilter_txx #include "otbPixelSuppressionByDirectionImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkConstantBoundaryCondition.h" #include "itkOffset.h" #include "itkProgressReporter.h" #include "otbMath.h" namespace otb { /** * */ template PixelSuppressionByDirectionImageFilter::PixelSuppressionByDirectionImageFilter() { m_Radius.Fill(1); m_AngularBeam = static_cast(0.); } template void PixelSuppressionByDirectionImageFilter ::SetInputImage(const InputImageType *input) { this->SetInput(0, input); } template void PixelSuppressionByDirectionImageFilter ::SetInputImageDirection(const InputImageType *input) { this->SetInput(1, input); } template const typename PixelSuppressionByDirectionImageFilter::InputImageType * PixelSuppressionByDirectionImageFilter ::GetInputImage(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->GetInput(0)); } template const typename PixelSuppressionByDirectionImageFilter::InputImageType * PixelSuppressionByDirectionImageFilter ::GetInputImageDirection(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->GetInput(1)); } template void PixelSuppressionByDirectionImageFilter::GenerateInputRequestedRegion() throw ( itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInputImageDirection()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void PixelSuppressionByDirectionImageFilter::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { itk::ConstantBoundaryCondition cbc; const InputPixelType cvalue = 255; cbc.SetConstant(cvalue); itk::ConstNeighborhoodIterator bit; itk::ImageRegionConstIterator itin; itk::ImageRegionIterator itout; // Allocate output typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInputImage(); typename InputImageType::ConstPointer inputDirection = this->GetInputImageDirection(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(inputDirection, outputRegionForThread, m_Radius); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); //typename TInputImage::IndexType bitIndex; //--------------------------------------------------------------------------- InputPixelType PixelValue; // Location of the central pixel in the input image // int Xc, Yc; // Pixel location in the system axis of the region int x, y; // Pixel location in the system axis of the region after rotation of theta // where theta is the direction of the cantral pixel // Pixel Direction double ThetaXcYc, Thetaxtyt; //--------------------------------------------------------------------------- // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { bit = itk::ConstNeighborhoodIterator(m_Radius, inputDirection, *fit); itin = itk::ImageRegionConstIterator(input, *fit); itout = itk::ImageRegionIterator(output, *fit); bit.OverrideBoundaryCondition(&cbc); bit.GoToBegin(); while (!bit.IsAtEnd()) { /*// Location of the central pixel of the region in the input image bitIndex = bit.GetIndex(); Xc = bitIndex[0]; Yc = bitIndex[1]; */ // Get Pixel Direction from the image of directions ThetaXcYc = static_cast(bit.GetCenterPixel()); // Pixel intensity in the input image PixelValue = itin.Get(); bool IsLine = false; typename itk::ConstNeighborhoodIterator::OffsetType off; // Loop on the region for (unsigned int i = 0; i < 2 * m_Radius[0] + 1; ++i) for (unsigned int j = 0; j < 2 * m_Radius[1] + 1; ++j) { off[0] = i - m_Radius[0]; off[1] = j - m_Radius[1]; x = off[0]; y = off[1]; // No calculation on the central pixel if ((x == 0) && (y == 0)) continue; Thetaxtyt = vcl_atan2(static_cast(y), static_cast(x)); //result is [-PI, PI] while (Thetaxtyt < 0) Thetaxtyt = CONST_PI + Thetaxtyt; // Theta is now [0, PI] as is // the result of detectors while (Thetaxtyt > CONST_PI_2) Thetaxtyt = Thetaxtyt - CONST_PI; // Theta is now [-PI/2, PI/2] if ((vcl_abs(vcl_cos(Thetaxtyt - ThetaXcYc)) >= vcl_cos(m_AngularBeam)) // this // pixel // is // in // the // angular beam && (vcl_abs(vcl_cos(bit.GetPixel(off) - ThetaXcYc)) >= vcl_cos(m_AngularBeam))) //and //its //direction //is //also //in //the beam { IsLine = true; continue; } } // end of the loop on the pixels of the region // Assignment of this value to the output pixel if (IsLine == true) { itout.Set(static_cast(PixelValue)); } else { itout.Set(static_cast(0.)); } ++bit; ++itin; ++itout; progress.CompletedPixel(); } } } /** * Standard "PrintSelf" method */ template void PixelSuppressionByDirectionImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbSobelVectorImageFilter.h000066400000000000000000000064341301006202600261350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSobelVectorImageFilter_h #define otbSobelVectorImageFilter_h #include "otbUnaryFunctorNeighborhoodVectorImageFilter.h" #include namespace otb { namespace Functor { /** \class SobelOperator * \brief Performs the calculation of Sobel derivation * * \ingroup OTBEdge */ template < class TInput, class TOutput > class SobelOperator { public: SobelOperator() { } virtual ~SobelOperator() { } TOutput operator() ( const TInput & input ) { unsigned int length = input.GetPixel(0).Size(); TOutput output ( length ); for ( unsigned int i = 0; i < length; ++i ) { double hori = static_cast( ( input.GetPixel(0)[i] - input.GetPixel(2)[i] ) + 2 * ( input.GetPixel(3)[i] - input.GetPixel(5)[i] ) + ( input.GetPixel(6)[i] - input.GetPixel(8)[i] ) ); double vert = static_cast( ( input.GetPixel(0)[i] - input.GetPixel(6)[i] ) + 2 * ( input.GetPixel(1)[i] - input.GetPixel(7)[i] ) + ( input.GetPixel(2)[i] - input.GetPixel(8)[i] ) ); output[i] = static_cast( vcl_sqrt( vcl_pow( hori, 2. ) + vcl_pow( vert, 2. ) ) ); } return output; } }; // end of functor class } // end of namespace Functor /** \class SobelVectorImageFilter * \brief Implements the Sobel Gradient to be processed on a vector image * * \ingroup OTBEdge */ template < class TInputImage, class TOutputImage > class ITK_EXPORT SobelVectorImageFilter : public UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::SobelOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > { public: /** Standard class typedefs */ typedef SobelVectorImageFilter Self; typedef UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::SobelOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SobelVectorImageFilter, ImageToImageFilter); protected: SobelVectorImageFilter() { typename Superclass::RadiusType radius = {{1, 1}}; this->SetRadius( radius ); } ~SobelVectorImageFilter() ITK_OVERRIDE { } private: SobelVectorImageFilter( const Self & ); // Not implemented void operator=( const Self & ); // Not implemented }; // end of class } // end of namespace otb #endif // otbSobelVectorImageFilter_h OTB-release-5.8/Modules/Feature/Edge/include/otbStreamingLineSegmentDetector.h000066400000000000000000000072031301006202600273460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingLineSegmentDetector_h #define otbStreamingLineSegmentDetector_h #include #include "itkImageRegion.h" #include "itkPreOrderTreeIterator.h" #include "itkDataObjectDecorator.h" #include "itkSimpleDataObjectDecorator.h" #include "otbLineSegmentDetector.h" #include "otbPersistentFilterStreamingDecorator.h" #include "otbPersistentImageToVectorDataFilter.h" namespace otb { /** \class PersistentStreamingLineSegmentDetector * \brief Perform Line segment detector in a persistent way. * * This filter is a generic PersistentImageFilter, which encapsulate * the Line Segment detector filter. * * \sa PersistentImageToVectorDataFilter * * * \ingroup OTBEdge */ template class PersistentStreamingLineSegmentDetector : public otb::PersistentImageToVectorDataFilter::VectorDataType > { public: /** Standard Self typedef */ typedef PersistentStreamingLineSegmentDetector Self; typedef PersistentImageToVectorDataFilter::VectorDataType > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::LineSegmentDetector LSDType; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointerType; typedef typename Superclass::OutputVectorDataType OutputVectorDataType; typedef typename Superclass::OutputVectorDataPointerType OutputVectorDataPointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentStreamingLineSegmentDetector, PersistentImageToVectorDataFilter); protected: PersistentStreamingLineSegmentDetector(); ~PersistentStreamingLineSegmentDetector() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; private: PersistentStreamingLineSegmentDetector(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputVectorDataPointerType ProcessTile() ITK_OVERRIDE; }; template class StreamingLineSegmentDetector { public: // define the PersistentStreamingLineSegmentDetector template typedef PersistentStreamingLineSegmentDetector PersistentStreamingLineSegmentDetectorType; typedef typename PersistentStreamingLineSegmentDetectorType::InputImageType InputImageType; typedef typename PersistentStreamingLineSegmentDetectorType::OutputVectorDataType OutputVectorDataType; // typedef for streaming capable filter typedef PersistentFilterStreamingDecorator FilterType; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingLineSegmentDetector.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbStreamingLineSegmentDetector.txx000066400000000000000000000052401301006202600277410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingLineSegmentDetector_txx #define otbStreamingLineSegmentDetector_txx #include "otbStreamingLineSegmentDetector.h" #include "otbVectorDataTransformFilter.h" #include "itkAffineTransform.h" namespace otb { template PersistentStreamingLineSegmentDetector ::PersistentStreamingLineSegmentDetector() { } template PersistentStreamingLineSegmentDetector ::~PersistentStreamingLineSegmentDetector() { } template void PersistentStreamingLineSegmentDetector ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); if (this->GetInput()) { InputImagePointerType input = const_cast (this->GetInput()); typename InputImageType::RegionType region = this->GetOutput()->GetRequestedRegion(); region.PadByRadius(1); region.Crop(input->GetLargestPossibleRegion()); input->SetRequestedRegion(region); } } template typename PersistentStreamingLineSegmentDetector::OutputVectorDataPointerType PersistentStreamingLineSegmentDetector ::ProcessTile() { // Apply an ExtractImageFilter to avoid problems with filters asking for the LargestPossibleRegion typedef itk::ExtractImageFilter ExtractImageFilterType; typename ExtractImageFilterType::Pointer extract = ExtractImageFilterType::New(); extract->SetInput( this->GetInput() ); extract->SetExtractionRegion( this->GetInput()->GetBufferedRegion() ); extract->Update(); // WARNING: itk::ExtractImageFilter does not copy the MetadataDictionary // but LSD filter need the projection ref if available extract->GetOutput()->SetMetaDataDictionary(this->GetInput()->GetMetaDataDictionary()); typename LSDType::Pointer lsd = LSDType::New(); lsd->SetInput(extract->GetOutput()); lsd->UpdateOutputInformation(); lsd->Update(); // return the LSD VectorData in image physical coordinates return lsd->GetOutput(); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbTouziEdgeDetectorImageFilter.h000066400000000000000000000124401301006202600272710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTouziEdgeDetectorImageFilter_h #define otbTouziEdgeDetectorImageFilter_h #include "otbImageToModulusAndDirectionImageFilter.h" #include "otbImage.h" #include "itkNumericTraits.h" namespace otb { /** \class TouziEdgeDetectorImageFilter * \brief Application of a filter of detection of contours. * * This class implements the Touzi's ratio edge detector used to detect * contours. * * We define a square region of size 2n+1 that we divided in two regions. * * The response of the edge detector between two regions 1 and 2 in * one direction \f$ \theta_{i} \f$ is: * \f[R(\theta_{i}) = 1 - \min (\frac{\mu_{1}}{\mu_{2}};\frac{\mu_{2}}{\mu_{1}}) \f] * where \f$ \mu_{1} \f$ and \f$ \mu_{2} \f$ are the mean of regions 1 and 2. * * The intensity of contour is calculated in four directions * vertical , diagonal 1, horizontal and diagonal 2. * * The output is an image of intensity of the detection of contour R, the * maximum response of the ratio edge detector of \f$ R(\theta_{i}) \f$ : * \f[R = \max ( R(\theta_{i}) ) \f] * * An image of the direction of contours can also be determined by this filter: * \f[D = \frac{\sum_{i=1}^{4} s_{i}\theta_{i}R(\theta_{i})}{\sum_{i=1}^{4} R(\theta_{i}} \f] * where if \f[ \mu_{1}>\mu_{2} s_{i}=+1 \f] * else if \f[ \mu_{1}<\mu_{2} s_{i}=-1 \f] * * * \ingroup OTBEdge */ template class ITK_EXPORT TouziEdgeDetectorImageFilter : public ImageToModulusAndDirectionImageFilter { public: /** Extract input and output images sizes. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef for the classes standards. */ typedef TouziEdgeDetectorImageFilter Self; typedef ImageToModulusAndDirectionImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(TouziEdgeDetectorImageFilter, ImageToModulusAndDirectionImageFilter); /** typedef to simplify variables definition and declaration. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageDirectionType OutputImageDirectionType; typedef typename InputImageType::SizeType SizeType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageDirectionType::PixelType OutputPixelDirectionType; /** Set/Get radius methods */ itkSetMacro(Radius, SizeType); itkGetConstReferenceMacro(Radius, SizeType); /** To be allowed to use the pipeline method TouziEdgeDetectorImageFilter needs * a treatment input area larger than the output one. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; protected: TouziEdgeDetectorImageFilter(); ~TouziEdgeDetectorImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** TouziEdgeDetectorImageFilter can be implemented for a multithreaded filter treatment. * Thus, this implementation give the ThreadedGenerateData() method. * that is called for each process thread. Image datas are automatically allocated * through the parent class calling the ThreadedGenerateData() method. * ThreadedGenerateData() can only write the area of the image specified by the parameter "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: TouziEdgeDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius declaration */ SizeType m_Radius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTouziEdgeDetectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Edge/include/otbTouziEdgeDetectorImageFilter.txx000066400000000000000000000233351301006202600276720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTouziEdgeDetectorImageFilter_txx #define otbTouziEdgeDetectorImageFilter_txx #include "otbTouziEdgeDetectorImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { /** * */ template TouziEdgeDetectorImageFilter::TouziEdgeDetectorImageFilter() { m_Radius.Fill(1); } template void TouziEdgeDetectorImageFilter::GenerateInputRequestedRegion() throw ( itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /** * Set up state of filter before multi-threading. * InterpolatorType::SetInputImage is not thread-safe and hence * has to be set up before ThreadedGenerateData */ template void TouziEdgeDetectorImageFilter ::BeforeThreadedGenerateData() { typename OutputImageDirectionType::RegionType region; typename OutputImageType::Pointer output = this->GetOutput(); OutputImageDirectionType * direction = this->GetOutputDirection(); region.SetSize(output->GetRequestedRegion().GetSize()); region.SetIndex(output->GetRequestedRegion().GetIndex()); direction->SetRegions(region); direction->SetOrigin(output->GetOrigin()); direction->SetSpacing(output->GetSpacing()); direction->Allocate(); } template void TouziEdgeDetectorImageFilter ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { unsigned int i; itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ConstNeighborhoodIterator bit; itk::ImageRegionIterator it; itk::ImageRegionIterator it_dir; // Allocate output typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); typename OutputImageDirectionType::Pointer outputDir = this->GetOutputDirection(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(input, outputRegionForThread, m_Radius); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); typename TInputImage::IndexType bitIndex; // Initializations // --------------- // Number of direction const int NB_DIR = 4; // Number of region of the filter const int NB_REGION = 2; // Definition of the 4 directions double Theta[NB_DIR]; Theta[0] = 0.; Theta[1] = CONST_PI_4; Theta[2] = CONST_PI_2; Theta[3] = 3 * CONST_PI / 4.; // contains for the 4 directions the sum of the pixels belonging to each region double Sum[NB_DIR][NB_REGION]; // Mean of region 1 double M1; // Mean of region 2 double M2; // Result of the filter for each direction double R_theta[NB_DIR]; double Sum_R_theta = 0.; // Intensity of the contour double R_contour; // Direction of the contour double Dir_contour = 0.; // sign of the contour int sign; // Pixel location in the input image int x; int y; // Location of the central pixel in the input image int xc; int yc; int cpt = 0; // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { cpt += 1; bit = itk::ConstNeighborhoodIterator(m_Radius, input, *fit); unsigned int neighborhoodSize = bit.Size(); it = itk::ImageRegionIterator(output, *fit); it_dir = itk::ImageRegionIterator(outputDir, *fit); bit.OverrideBoundaryCondition(&nbc); bit.GoToBegin(); while (!bit.IsAtEnd()) { // Location of the pixel central bitIndex = bit.GetIndex(); xc = bitIndex[0]; yc = bitIndex[1]; // Initializations for (int dir = 0; dir < NB_DIR; ++dir) { for (int m = 0; m < NB_REGION; m++) Sum[dir][m] = 0.; } R_contour = -1; Dir_contour = 0.; Sum_R_theta = 0.; // Loop on pixels of the filter for (i = 0; i < neighborhoodSize; ++i) { bitIndex = bit.GetIndex(i); x = bitIndex[0]; y = bitIndex[1]; // We determine for each direction with which region the pixel belongs. // Horizontal direction if (y < yc) Sum[0][0] += static_cast(bit.GetPixel(i)); else if (y > yc) Sum[0][1] += static_cast(bit.GetPixel(i)); // Diagonal direction 1 if ((y - yc) < (x - xc)) Sum[1][0] += static_cast(bit.GetPixel(i)); else if ((y - yc) > (x - xc)) Sum[1][1] += static_cast(bit.GetPixel(i)); // Vertical direction if (x > xc) Sum[2][0] += static_cast(bit.GetPixel(i)); else if (x < xc) Sum[2][1] += static_cast(bit.GetPixel(i)); // Diagonal direction 2 if ((y - yc) > -(x - xc)) Sum[3][0] += static_cast(bit.GetPixel(i)); else if ((y - yc) < -(x - xc)) Sum[3][1] += static_cast(bit.GetPixel(i)); } // end of the loop on pixels of the filter // Loop on the 4 directions for (int dir = 0; dir < NB_DIR; ++dir) { // Calculation of the mean of the 2 regions M1 = Sum[dir][0] / static_cast(m_Radius[0] * (2 * m_Radius[0] + 1)); M2 = Sum[dir][1] / static_cast(m_Radius[0] * (2 * m_Radius[0] + 1)); // Calculation of the intensity of the contour if ((M1 != 0) && (M2 != 0)) R_theta[dir] = static_cast(1 - std::min((M1 / M2), (M2 / M1))); else R_theta[dir] = 0.; // Determination of the maximum intensity of the contour R_contour = static_cast(std::max(R_contour, R_theta[dir])); // Determination of the sign of contour if (M2 > M1) sign = +1; else sign = -1; Dir_contour += sign * Theta[dir] * R_theta[dir]; Sum_R_theta += R_theta[dir]; } // end of the loop on the directions // Assignment of this value to the output pixel it.Set(static_cast(R_contour)); // Determination of the direction of the contour if (Sum_R_theta != 0.) Dir_contour = Dir_contour / Sum_R_theta; // Assignment of this value to the "outputdir" pixel it_dir.Set(static_cast(Dir_contour)); ++bit; ++it; ++it_dir; progress.CompletedPixel(); } } } /** * Standard "PrintSelf" method */ template void TouziEdgeDetectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Edge/include/otbVerticalSobelVectorImageFilter.h000066400000000000000000000060601301006202600276220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVerticalSobelVectorImageFilter_h #define otbVerticalSobelVectorImageFilter_h #include "otbUnaryFunctorNeighborhoodVectorImageFilter.h" namespace otb { namespace Functor { /** \class VerticalSobelOperator * \brief Performs the calculation of vertical Sobel derivation * * \ingroup OTBEdge */ template < class TInput, class TOutput > class VerticalSobelOperator { public: VerticalSobelOperator() { } virtual ~VerticalSobelOperator() { } TOutput operator() ( const TInput & input ) { unsigned int length = input.GetPixel(0).Size(); TOutput output ( length ); for ( unsigned int i = 0; i < length; ++i ) { output[i] = static_cast( ( input.GetPixel(0)[i] - input.GetPixel(6)[i] ) + 2 * ( input.GetPixel(1)[i] - input.GetPixel(7)[i] ) + ( input.GetPixel(2)[i] - input.GetPixel(8)[i] ) ); } return output; } }; // end of functor class } // end of namespace Functor /** \class VerticalSobelVectorImageFilter * \brief Implements the Vertical Sobel Gradient to be processed on a vector image * * \ingroup OTBEdge */ template < class TInputImage, class TOutputImage > class ITK_EXPORT VerticalSobelVectorImageFilter : public UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::VerticalSobelOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > { public: /** Standard class typedefs */ typedef VerticalSobelVectorImageFilter Self; typedef UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::VerticalSobelOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(VerticalSobelVectorImageFilter, ImageToImageFilter); protected: VerticalSobelVectorImageFilter() { typename Superclass::RadiusType radius = {{1, 1}}; this->SetRadius( radius ); } ~VerticalSobelVectorImageFilter() ITK_OVERRIDE { } private: VerticalSobelVectorImageFilter( const Self & ); // Not implemented void operator=( const Self & ); // Not implemented }; // end of class } // end of namespace otb #endif // otbVerticalSobelVectorImageFilter_h OTB-release-5.8/Modules/Feature/Edge/otb-module.cmake000066400000000000000000000011041301006202600223320ustar00rootroot00000000000000set(DOCUMENTATION "This module contains tools related to edge / line extraction. users can find classes that implement tools such as Sobel Detector, Touzi or Line Ratio Detector (SAR images), Hough Transform, and so on.") otb_module(OTBEdge DEPENDS OTBCommon OTBConversion OTBITK OTBImageBase OTBImageManipulation OTBObjectList OTBPath OTBProjection OTBSpatialObjects OTBStreaming OTBVectorDataBase TEST_DEPENDS OTBCommandLineParser OTBImageIO OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Feature/Edge/src/000077500000000000000000000000001301006202600200545ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Edge/src/CMakeLists.txt000066400000000000000000000007541301006202600226220ustar00rootroot00000000000000set(OTBEdge_SRC otbFillGapsFilter.cxx ) add_library(OTBEdge ${OTBEdge_SRC}) target_link_libraries(OTBEdge ${OTBCommon_LIBRARIES} ${OTBConversion_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBITKPendingPatches_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBObjectList_LIBRARIES} ${OTBPath_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBSpatialObjects_LIBRARIES} ${OTBStreaming_LIBRARIES} ${OTBVectorDataBase_LIBRARIES} ) otb_module_target(OTBEdge) OTB-release-5.8/Modules/Feature/Edge/src/otbFillGapsFilter.cxx000066400000000000000000000156401301006202600241620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFillGapsFilter.h" namespace otb { /** * Constructor */ FillGapsFilter::FillGapsFilter() { this->ProcessObjectType::SetNumberOfRequiredInputs(1); this->ProcessObjectType::SetNumberOfRequiredOutputs(1); LineSpatialObjectListPointer output = LineSpatialObjectListType::New(); this->ProcessObjectType::SetNthOutput(0, output); m_Radius = 4.0; m_AngularBeam = 1.0; } void FillGapsFilter ::SetInput(const LineSpatialObjectListType * input) { this->ProcessObjectType::SetNthInput(0, const_cast(input)); } const FillGapsFilter::LineSpatialObjectListType * FillGapsFilter ::GetInput(void) { return static_cast (this->ProcessObjectType::GetInput(0)); } FillGapsFilter::LineSpatialObjectListType * FillGapsFilter ::GetOutput(void) { return static_cast (this->ProcessObjectType::GetOutput(0)); } /** * */ void FillGapsFilter ::GenerateData() { // Get the LineSpatialObject const LineSpatialObjectList * inputLine = this->GetInput(); LineSpatialObjectList * outputLine = this->GetOutput(); // Get the list of points which consists of two points to represent a // straight line LineSpatialObjectListType::const_iterator itLineListA = inputLine->begin(); LineSpatialObjectListType::const_iterator itLineListAEnd = inputLine->end(); LineSpatialObjectListType::const_iterator itLineListB; LineSpatialObjectListType::const_iterator itLineListBEnd = inputLine->end(); double x1(0.), y1(0.), x2(0.), y2(0.), x3(0.), y3(0.), x4(0.), y4(0.); double xTemp(0.), yTemp(0.); double R13(0.), R14(0.), R23(0.), R24(0.); double CosTheta(0.); PointListType::const_iterator itPoints; CosTheta = vcl_cos(m_AngularBeam); --itLineListAEnd; while (itLineListA != itLineListAEnd) { itLineListB = itLineListA; ++itLineListB; PointListType& pointsList = (*itLineListA)->GetPoints(); itPoints = pointsList.begin(); x1 = (*itPoints).GetPosition()[0]; y1 = (*itPoints).GetPosition()[1]; ++itPoints; x2 = (*itPoints).GetPosition()[0]; y2 = (*itPoints).GetPosition()[1]; PointType point; PointListType pointList; point.SetPosition(x1, y1); pointList.push_back(point); point.SetPosition(x2, y2); pointList.push_back(point); LineSpatialObjectType::Pointer line = LineSpatialObjectType::New(); line->SetId(0); line->SetPoints(pointList); line->ComputeBoundingBox(); outputLine->push_back(line); while (itLineListB != itLineListBEnd) { pointsList = (*itLineListB)->GetPoints(); itPoints = pointsList.begin(); x3 = (*itPoints).GetPosition()[0]; y3 = (*itPoints).GetPosition()[1]; ++itPoints; x4 = (*itPoints).GetPosition()[0]; y4 = (*itPoints).GetPosition()[1]; // Calculate the radius for each point of each line R13 = vcl_sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3)); R14 = vcl_sqrt((x1 - x4) * (x1 - x4) + (y1 - y4) * (y1 - y4)); R23 = vcl_sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3)); R24 = vcl_sqrt((x2 - x4) * (x2 - x4) + (y2 - y4) * (y2 - y4)); double Rmin = m_Radius; // Test the lower Radius if (R13 < Rmin) Rmin = R13; if (R14 < Rmin) Rmin = R14; if (R23 < Rmin) Rmin = R23; if (R24 < Rmin) Rmin = R24; if (Rmin < m_Radius) { // Sort Points such as the radius of P2 and P3 is the smallest one. if (Rmin == R24) { xTemp = x3; yTemp = y3; x3 = x4; y3 = y4; x4 = xTemp; y4 = yTemp; } if (Rmin == R13) { xTemp = x1; yTemp = y1; x1 = x2; y1 = y2; x2 = xTemp; y2 = yTemp; } if (Rmin == R14) { xTemp = x3; yTemp = y3; x3 = x4; y3 = y4; x4 = xTemp; y4 = yTemp; xTemp = x1; yTemp = y1; x1 = x2; y1 = y2; x2 = xTemp; y2 = yTemp; } //Estimate the norm each line /* double Norm12, Norm23, Norm34; Norm12 = vcl_sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) ); Norm23 = vcl_sqrt( (x2-x3)*(x2-x3) + (y2-y3)*(y2-y3) ); Norm34 = vcl_sqrt( (x3-x4)*(x3-x4) + (y3-y4)*(y3-y4) ); */ double Angle12_23, Angle12_34, Angle23_34; //Estimate the angle between lines 12-23 and lines 12-34 /*Angle12_23 = (x2-x1)*(x3-x2) + (y2-y1)*(y3-y2); Angle12_23 = Angle12_23 / Norm12 / Norm23; Angle12_34 = (x2-x1)*(x4-x3) + (y2-y1)*(y4-y3); Angle12_34 = Angle12_34 / Norm12 / Norm34; */ Angle12_23 = vcl_cos(vcl_atan2((y2 - y1), (x2 - x1)) - vcl_atan2((y3 - y2), (x3 - x2))); Angle12_34 = vcl_cos(vcl_atan2((y2 - y1), (x2 - x1)) - vcl_atan2((y4 - y3), (x4 - x3))); Angle23_34 = vcl_cos(vcl_atan2((y3 - y2), (x3 - x2)) - vcl_atan2((y4 - y3), (x4 - x3))); if ((Angle12_23 > CosTheta) && (Angle12_34 > CosTheta) && (Angle23_34 > CosTheta)) { // Store 23-segment PointType ppoint; PointListType ppointList; ppoint.SetPosition(x2, y2); ppointList.push_back(ppoint); ppoint.SetPosition(x3, y3); ppointList.push_back(ppoint); LineSpatialObjectType::Pointer lline = LineSpatialObjectType::New(); lline->SetId(0); lline->SetPoints(ppointList); lline->ComputeBoundingBox(); outputLine->push_back(lline); ppointList.clear(); } } // if(Rmin < m_Radius) ++itLineListB; } // while(itLineListB != itLineListBEnd) ++itLineListA; } // Insert the last element PointType point; PointListType pointList; point.SetPosition(x3, y3); pointList.push_back(point); point.SetPosition(x4, y4); pointList.push_back(point); LineSpatialObjectType::Pointer line = LineSpatialObjectType::New(); line->SetId(0); line->SetPoints(pointList); line->ComputeBoundingBox(); outputLine->push_back(line); pointList.clear(); } /** * */ void FillGapsFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb OTB-release-5.8/Modules/Feature/Edge/test/000077500000000000000000000000001301006202600202445ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Edge/test/0000094-PolygonsVectorization.cxx000066400000000000000000000251471301006202600262060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbCommandLineArgumentParser.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbPolygon.h" #include "otbPersistentVectorizationImageFilter.h" #include "itkRelabelComponentImageFilter.h" #include "itkConnectedComponentImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "otbStandardWriterWatcher.h" #include "otbStandardFilterWatcher.h" int main(int argc, char * argv[]) { typedef unsigned long LabelPixelType; typedef unsigned char PixelTypeOutput; typedef otb::Image LabeledImageType; typedef otb::Image OutputImageType; typedef itk::ImageRegionIterator IteratorType; typedef otb::Polygon PolygonType; typedef otb::ObjectList PolygonListType; typedef PolygonListType::Pointer PolygonListPointerType; typedef itk::ImageRegion<2> ImageRegionType; typedef otb::PersistentVectorizationImageFilter PersistentVectorizationFilterType; typedef itk::ConnectedComponentImageFilter ConnectedFilterType; typedef itk::RescaleIntensityImageFilter RescalerType; /* typedef itk::BinaryBallStructuringElement< LabelPixelType, 2 > StructuringElementType; typedef itk::BinaryErodeImageFilter ErodeFilterType; typedef itk::BinaryDilateImageFilter DilateFilterType; typedef itk::MedianImageFilter MedianFilterType; typedef otb::RemoveObjectPreprocessingImageFilter PreprocessingFilterType; */ typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; //----------------------------------------------------------------- //Command Line Argument Parser try { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->SetProgramDescription("This program remove small objects"); parser->AddInputImage(); parser->AddOutputImage(); parser->AddOption("--surface", "objects surface limit. Default is 100", "-s", 1, false); parser->AddOption("--outputText", "output text file name", "-ot", 1, false); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); } catch (itk::ExceptionObject& err) { std::string descriptionException = err.GetDescription(); if (descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos) { return EXIT_SUCCESS; } if (descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos) { return EXIT_SUCCESS; } return EXIT_FAILURE; } //object under this value will be removed double surfaceLimit; if (parseResult->IsOptionPresent("--surface")) surfaceLimit = parseResult->GetParameterDouble("--surface"); else surfaceLimit = 100; //----------------------------------------------------------------- //read image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(parseResult->GetInputImage().c_str()); reader->UpdateOutputInformation(); /////////////////////////////////////////////////////////////////// // Object Processing /////////////////////////////////////////////////////////////////// //----------------------------------------------------------------- //Label the objects in a binary image ConnectedFilterType::Pointer connectedFilter = ConnectedFilterType::New(); connectedFilter->SetInput(reader->GetOutput()); //----------------------------------------------------------------- //Perform vectorization in a persistent way PersistentVectorizationFilterType::Pointer persistentVectorization = PersistentVectorizationFilterType::New(); persistentVectorization->Reset(); persistentVectorization->SetInput(connectedFilter->GetOutput()); try { persistentVectorization->Update(); } catch (itk::ExceptionObject& err) { std::cout << "\nExceptionObject caught !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } PolygonListPointerType OutputPolyList = persistentVectorization->GetPathList(); //Display results std::cout << "nb objects found = " << OutputPolyList->Size() << std::endl; //------------------- //DEBUG //------------------- unsigned int polygon = 0; std::ofstream file; if (parseResult->IsOptionPresent("--outputText")) { file.open(parseResult->GetParameterString("--outputText").c_str()); } double minSize = -1; //Initializing the minSize if (OutputPolyList->Size() > 0) { minSize = OutputPolyList->GetNthElement(0)->GetArea(); } while (polygon < OutputPolyList->Size()) { ImageRegionType polygonRegion = OutputPolyList->GetNthElement(polygon)->GetBoundingRegion().GetImageRegion(); if (OutputPolyList->GetNthElement(polygon)->GetArea() < minSize) { minSize = OutputPolyList->GetNthElement(polygon)->GetArea(); } if (parseResult->IsOptionPresent("--outputText")) { file << "polygon " << polygon << "\tnPoints=" << OutputPolyList->GetNthElement(polygon)->GetVertexList()->Size() << "\tsurface=" << OutputPolyList->GetNthElement(polygon)->GetArea() << "\tlength=" << OutputPolyList->GetNthElement(polygon)->GetLength() << "\tregion size=" << polygonRegion.GetSize() << "\tregion nb pixel=" << polygonRegion.GetNumberOfPixels() << std::endl; // file << OutputPolyList->GetNthElement(polygon)<< std::endl << std::endl; } else { std::cout << "polygon " << polygon << "\tnPoints=" << OutputPolyList->GetNthElement(polygon)->GetVertexList()->Size() << "\tsurface=" << OutputPolyList->GetNthElement(polygon)->GetArea() << "\tlength=" << OutputPolyList->GetNthElement(polygon)->GetLength() << "\tregion size=" << polygonRegion.GetSize() << "\tregion nb pixel=" << polygonRegion.GetNumberOfPixels() << std::endl; // std::cout << OutputPolyList->GetNthElement(polygon)<< std::endl << std::endl; } polygon++; } if (parseResult->IsOptionPresent("--outputText")) { file.close(); } //------------------- // END DEBUG //------------------- //----------------------------------------------------------------- //erase object unsigned int i = 0; std::cout << "erase ..." << std::endl; while (i < OutputPolyList->Size()) { if ((OutputPolyList->GetNthElement(i)->GetArea() > surfaceLimit) //delete big polygon || (OutputPolyList->GetNthElement(i)->GetArea() == 0)) //delete invalid polygon OutputPolyList->Erase(i); else ++i; } //Display results after erasure std::cout << "nb objects found = " << OutputPolyList->Size() << std::endl; std::cout << "------------------------------------------------" << std::endl; /////////////////////////////////////////////////////////////////// // Output Image Writing /////////////////////////////////////////////////////////////////// //----------------------------------------------------------------- //allocate the memory for the output file LabeledImageType::Pointer outputImage = LabeledImageType::New(); outputImage->SetRegions(reader->GetOutput()->GetRequestedRegion()); outputImage->CopyInformation(reader->GetOutput()); outputImage->Allocate(); // copy input IteratorType iit(reader->GetOutput(), reader->GetOutput()->GetRequestedRegion()); IteratorType oit(outputImage, outputImage->GetRequestedRegion()); for (iit.GoToBegin(), oit.GoToBegin(); !iit.IsAtEnd(); ++iit, ++oit) oit.Set(iit.Get()); // erase small polygon for (unsigned int i = 0; i < OutputPolyList->Size(); ++i) { std::cout << "polygon " << i << std::endl; ImageRegionType polygonRegion = OutputPolyList->GetNthElement(i)->GetBoundingRegion().GetImageRegion(); IteratorType outputIt(outputImage, polygonRegion); outputIt.GoToBegin(); while (!outputIt.IsAtEnd()) { outputIt.Set(0); ++outputIt; } } //----------------------------------------------------------------- //rescale image RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(outputImage); rescaler->Update(); //----------------------------------------------------------------- //write image WriterType::Pointer writer = WriterType::New(); writer->SetFileName(parseResult->GetOutputImage().c_str()); writer->SetInput(rescaler->GetOutput()); try { otb::StandardWriterWatcher watcher(writer, "Remove small object"); writer->Update(); } catch (itk::ExceptionObject& err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } if (minSize == 0) { return EXIT_FAILURE; } } //end block try global catch (itk::ExceptionObject& err) { std::cout << "Following otbException catch :" << std::endl; std::cout << err << std::endl; return EXIT_FAILURE; } catch (std::bad_alloc& err) { std::cout << "Exception bad_alloc : " << (char*) err.what() << std::endl; return EXIT_FAILURE; } catch (...) { std::cout << "Unknown Exception found !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/0000433-LineSegmentDetector_8b_16b_compare.cxx000066400000000000000000000061361301006202600302600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLineSegmentDetector.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImageFileWriter.h" // Code showing difference between LSD with 8 and 16 bits images. // http://bugs.orfeo-toolbox.org/view.php?id=433 int main(int argc, char *argv[]) { if (argc != 6) { std::cout << "Usage : " << std::endl; return EXIT_FAILURE; } const char * infname8 = argv[2]; const char * infname16 = argv[3]; const char * outfname8 = argv[4]; const char * outfname16 = argv[5]; /** Typedefs */ typedef unsigned char PixelType8; typedef otb::Image ImageType8; typedef otb::ImageFileReader ReaderType8; typedef otb::LineSegmentDetector LSDFilterType8; typedef unsigned short PixelType16; typedef otb::Image ImageType16; typedef otb::ImageFileReader ReaderType16; typedef otb::LineSegmentDetector LSDFilterType16; typedef LSDFilterType8::VectorDataType VectorDataType; typedef otb::VectorDataFileWriter VectorDataWriterType; /** 8bits */ //Instantiation of smart pointer ReaderType8::Pointer reader8 = ReaderType8::New(); LSDFilterType8::Pointer lsdFilter8 = LSDFilterType8::New(); //Reade the input image reader8->SetFileName(infname8); reader8->GenerateOutputInformation(); //LSD Detection lsdFilter8->SetInput(reader8->GetOutput()); VectorDataWriterType::Pointer vdWriter8 = VectorDataWriterType::New(); vdWriter8->SetFileName(outfname8); vdWriter8->SetInput(lsdFilter8->GetOutput()); vdWriter8->Update(); /** 16bits */ //Instantiation of smart pointer ReaderType16::Pointer reader16 = ReaderType16::New(); LSDFilterType16::Pointer lsdFilter16 = LSDFilterType16::New(); //Reade the input image reader16->SetFileName(infname16); reader16->GenerateOutputInformation(); //LSD Detection lsdFilter16->SetInput(reader16->GetOutput()); VectorDataWriterType::Pointer vdWriter16 = VectorDataWriterType::New(); vdWriter16->SetFileName(outfname16); vdWriter16->SetInput(lsdFilter16->GetOutput()); vdWriter16->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/CMakeLists.txt000066400000000000000000000276061301006202600230170ustar00rootroot00000000000000otb_module_test() set(OTBEdgeTests otbEdgeTestDriver.cxx otbPixelSuppressionByDirectionNew.cxx otbEdgeDetectorImageFilter.cxx otbHorizontalSobelVectorImageFilter.cxx otbAsymmetricFusionOfLineDetector.cxx otbLocalHoughDraw.cxx otbAssociativeSymmetricalSum.cxx otbPersistentVectorizationFilterNew.cxx otbLineCorrelationDetectorNew.cxx otbPersistentVectorizationFilter.cxx otbEdgeDensityImageFilter.cxx otbLineCorrelationDetector.cxx otbSobelVectorImageFilter.cxx otbAssociativeSymmetricalSumNew.cxx otbHoughTransform2DLinesImageTest.cxx otbPixelSuppressionByDirection.cxx otbLocalHoughNew.cxx otbEdgeDetectorImageFilterNew.cxx otbEdgeDensityImageFilterNew.cxx otbLocalHough.cxx otbExtractSegments.cxx otbExtractSegmentsNew.cxx otbAsymmetricFusionOfLineDetectorNew.cxx otbLineRatioDetector.cxx otbTouziEdgeDetectorDirection.cxx otbTouziEdgeDetectorNew.cxx otbVerticalSobelVectorImageFilter.cxx otbStreamingLineSegmentDetector.cxx otbLineRatioDetectorNew.cxx otbTouziEdgeDetector.cxx otbLineRatioDetectorLinear.cxx otbLineSegmentDetector.cxx otbLineCorrelationDetectorLinear.cxx otbLineDetectorBaseNew.cxx otbFillGapsFilter.cxx otbFillGapsFilterNew.cxx ) add_executable(otbEdgeTestDriver ${OTBEdgeTests}) target_link_libraries(otbEdgeTestDriver ${OTBEdge-Test_LIBRARIES}) otb_module_target_label(otbEdgeTestDriver) # Tests Declaration otb_add_test(NAME feTuPixelSuppressionByDirectionNew COMMAND otbEdgeTestDriver otbPixelSuppressionByDirectionNew) otb_add_test(NAME bfTvEdgeDetectorImageFilter COMMAND otbEdgeTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvEdgeDetectorImageFilter.tif ${TEMP}/bfTvEdgeDetectorImageFilter.tif otbEdgeDetectorImageFilter ${INPUTDATA}/poupees_sub_c1.png ${TEMP}/bfTvEdgeDetectorImageFilter.tif 0 # lower threshold 255 # upper threshold ) otb_add_test(NAME bfTvHorizontalSobelVectorImageFilter COMMAND otbEdgeTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvHorizontalSobelVectorImageFilter.tif ${TEMP}/bfTvHorizontalSobelVectorImageFilter.tif otbHorizontalSobelVectorImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvHorizontalSobelVectorImageFilter.tif) otb_add_test(NAME bfTuHorizontalSobelVectorImageFilterNew COMMAND otbEdgeTestDriver otbHorizontalSobelVectorImageFilterNewTest) otb_add_test(NAME feTvAsymmetricFusionOfLineDetector COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreAsymmetricFusion_amst_2_3.hdr ${TEMP}/feFiltreAsymmetricFusion_amst_2_3.hdr otbAsymmetricFusionOfLineDetector ${INPUTDATA}/amst.png ${TEMP}/feFiltreAsymmetricFusion_amst_2_3.hdr 2 3) otb_add_test(NAME feTvLocalHoughDrawBis COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreLocalHoughDraw_Line_20_10_2.png ${TEMP}/feFiltreLocalHoughDraw_Line_20_10_2.png otbLocalHoughDraw ${INPUTDATA}/Line.png ${TEMP}/feFiltreLocalHoughDraw_Line_20_10_2.png 20 10 2) otb_add_test(NAME feTvLocalHoughDraw2 COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFilterLocalHoughDraw_amst_20_20_1.png ${TEMP}/feFilterLocalHoughDraw_amst_20_20_1.png otbLocalHoughDraw ${INPUTDATA}/amst.png ${TEMP}/feFilterLocalHoughDraw_amst_20_20_1.png 20 20 1) otb_add_test(NAME feTvLocalHoughDraw COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreLocalHoughDraw_ImageLine_20_20_2.hdr ${TEMP}/feFiltreLocalHoughDraw_ImageLine_20_20_2.hdr otbLocalHoughDraw ${INPUTDATA}/ImageLine.bsq.hdr ${TEMP}/feFiltreLocalHoughDraw_ImageLine_20_20_2.hdr 20 20 1) otb_add_test(NAME feTvAssociativeSymmetricalSum COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreASS_amst_2_3.hdr ${TEMP}/feFiltreASS_amst_2_3.hdr otbAssociativeSymmetricalSum ${BASELINE}/feFiltreLineRatioLinear_amst_2_3.hdr ${BASELINE}/feFiltreLineCorrelationLinear_amst_2_3.hdr ${TEMP}/feFiltreASS_amst_2_3.hdr) otb_add_test(NAME bfTuPersistentVectorizationImageFilterNew COMMAND otbEdgeTestDriver otbPersistentVectorizationFilterNew ) otb_add_test(NAME feTuLineCorrelationNew COMMAND otbEdgeTestDriver otbLineCorrelationDetectorNew) otb_add_test(NAME bfTvPersistentVectorizationImageFilter COMMAND otbEdgeTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvPersistentVectorizationImageFilterOutput.txt ${TEMP}/bfTvPersistentVectorizationImageFilterOutput.txt otbPersistentVectorizationFilter ${INPUTDATA}/Seg1InputForRCC8Graph.tif ${TEMP}/bfTvPersistentVectorizationImageFilterOutput.txt ) otb_add_test(NAME bfTvEdgeDensityImageFilter COMMAND otbEdgeTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvEdgeDensityImageFilterOutputImage.tif ${TEMP}/bfTvEdgeDensityImageFilterOutputImage.tif otbEdgeDensityImageFilter ${INPUTDATA}/scene.png ${TEMP}/bfTvEdgeDensityImageFilterOutputImage.tif 1 # radius 15 3 1. 0.01 #Canny Parameters ) otb_add_test(NAME feTvLineCorrelation COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreLineCorrelation_amst_2_3.hdr ${TEMP}/feFiltreLineCorrelation_amst_2_3.hdr otbLineCorrelationDetector ${INPUTDATA}/amst.png ${TEMP}/feFiltreLineCorrelation_amst_2_3.hdr 2 3) otb_add_test(NAME bfTuSobelVectorImageFilterNew COMMAND otbEdgeTestDriver otbSobelVectorImageFilterNewTest) otb_add_test(NAME bfTvSobelVectorImageFilter COMMAND otbEdgeTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvSobelVectorImageFilter.tif ${TEMP}/bfTvSobelVectorImageFilter.tif otbSobelVectorImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvSobelVectorImageFilter.tif) otb_add_test(NAME feTuAssociativeSymmetricalSumNew COMMAND otbEdgeTestDriver otbAssociativeSymmetricalSumNew) otb_add_test(NAME feTvHoughTransform2DLinesImage COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFilterHoughTransformDraw.tif ${TEMP}/feFilterHoughTransformDraw.tif otbHoughTransform2DLinesImageTest ${TEMP}/feFilterHoughTransformDraw.tif ) otb_add_test(NAME feTvPixelSuppressionByDirection COMMAND otbEdgeTestDriver --compare-image ${NOTOL} ${BASELINE}/feFiltrePixelSuppr_ImageLine_2_0_3.hdr ${TEMP}/feFiltrePixelSuppr_ImageLine_2_0_3.hdr otbPixelSuppressionByDirection ${INPUTDATA}/ImageLine_hd.bsq.hdr ${INPUTDATA}/ImageLineDir.bsq.hdr ${TEMP}/feFiltrePixelSuppr_ImageLine_2_0_3.hdr 2 0.3) otb_add_test(NAME feTuLocalHoughNew COMMAND otbEdgeTestDriver otbLocalHoughNew) otb_add_test(NAME bfTuEdgeDetectorImageFilterNew COMMAND otbEdgeTestDriver otbEdgeDetectorImageFilterNew ) otb_add_test(NAME bfTuEdgeDensityImageFilterNew COMMAND otbEdgeTestDriver otbEdgeDensityImageFilterNew ) otb_add_test(NAME feTvLocalHough COMMAND otbEdgeTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvLocaLHoughLinesDetected.txt ${TEMP}/feTvLocaLHoughLinesDetected.txt otbLocalHough ${INPUTDATA}/ImageLine.bsq.hdr ${TEMP}/feTvLocaLHoughLinesDetected.txt 20 20 1) otb_add_test(NAME feTvExtractSegments COMMAND otbEdgeTestDriver --compare-image ${NOTOL} ${BASELINE}/feFiltreExtractSegments_ImageLine.hdr ${TEMP}/feFiltreExtractSegments_ImageLine.hdr otbExtractSegments ${INPUTDATA}/ImageLine_hd.bsq.hdr ${INPUTDATA}/ImageLineDir.bsq.hdr ${TEMP}/feFiltreExtractSegments_ImageLine.hdr 10 0.3 10 10 3 10 0.5) otb_add_test(NAME feTuExtractSegmentsNew COMMAND otbEdgeTestDriver otbExtractSegmentsNew) otb_add_test(NAME feTuAsymmetricFusionOfLineDetectorNew COMMAND otbEdgeTestDriver otbAsymmetricFusionOfLineDetectorNew) otb_add_test(NAME feTvLineRatio COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreLineRatio_amst_2_3.hdr ${TEMP}/feFiltreLineRatio_amst_2_3.hdr otbLineRatioDetector ${INPUTDATA}/amst.png ${TEMP}/feFiltreLineRatio_amst_2_3.hdr 2 3) otb_add_test(NAME feTvTouziDir COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreTouzi_amst_dir_3.hdr ${TEMP}/feFiltreTouzi_amst_dir_3.hdr otbTouziEdgeDetectorDirection ${INPUTDATA}/amst.png ${TEMP}/feFiltreTouzi_amst_dir_3.hdr 3) otb_add_test(NAME feTuTouziNew COMMAND otbEdgeTestDriver otbTouziEdgeDetectorNew) otb_add_test(NAME bfTvVerticalSobelVectorImageFilter COMMAND otbEdgeTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvVerticalSobelVectorImageFilter.tif ${TEMP}/bfTvVerticalSobelVectorImageFilter.tif otbVerticalSobelVectorImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvVerticalSobelVectorImageFilter.tif) otb_add_test(NAME bfTuVerticalSobelVectorImageFilterNew COMMAND otbEdgeTestDriver otbVerticalSobelVectorImageFilterNewTest) otb_add_test(NAME feTuStreamingLineSegmentDetectorNew COMMAND otbEdgeTestDriver otbStreamingLineSegmentDetectorNew) otb_add_test(NAME feTvStreamingLineSegmentDetector10 COMMAND otbEdgeTestDriver --compare-ogr ${EPSILON_8} ${BASELINE_FILES}/feTvStreamingLineSegmentDetectorOutput10.shp ${TEMP}/feTvStreamingLineSegmentDetectorOutput10.shp otbStreamingLineSegmentDetector ${INPUTDATA}/scene.png ${TEMP}/feTvStreamingLineSegmentDetectorOutput10.shp 10 ) otb_add_test(NAME feTvStreamingLineSegmentDetector1000 COMMAND otbEdgeTestDriver --compare-ogr ${EPSILON_8} ${BASELINE_FILES}/feTvStreamingLineSegmentDetectorOutput1000.shp ${TEMP}/feTvStreamingLineSegmentDetectorOutput1000.shp otbStreamingLineSegmentDetector ${INPUTDATA}/scene.png ${TEMP}/feTvStreamingLineSegmentDetectorOutput1000.shp 1000 ) otb_add_test(NAME feTuLineRatioNew COMMAND otbEdgeTestDriver otbLineRatioDetectorNew) otb_add_test(NAME feTvTouzi COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feFiltreTouzi_amst_3.hdr ${TEMP}/feFiltreTouzi_amst_3.hdr otbTouziEdgeDetector ${INPUTDATA}/amst.png ${TEMP}/feFiltreTouzi_amst_3.hdr 3) otb_add_test(NAME feTvLineRatioLinearAmsters1 COMMAND otbEdgeTestDriver --compare-n-images ${EPSILON_8} 2 ${BASELINE}/feFiltreLineRatioLinear_amst_ers1_ima_extrait.hdr ${TEMP}/feFiltreLineRatioLinear_amst_ers1_ima_extrait.hdr ${BASELINE}/feFiltreLineRatioLinear_amst_dir_ers1_ima_extrait.hdr ${TEMP}/feFiltreLineRatioLinear_amst_dir_ers1_ima_extrait.hdr otbLineRatioDetectorLinear ${INPUTDATA}/amst_ers1.ima.extrait.419_187_70_66.hdr ${TEMP}/feFiltreLineRatioLinear_amst_ers1_ima_extrait.hdr ${TEMP}/feFiltreLineRatioLinear_amst_dir_ers1_ima_extrait.hdr 1 2) otb_add_test(NAME feTvLineRatioLinear COMMAND otbEdgeTestDriver --compare-n-images ${EPSILON_8} 2 ${BASELINE}/feFiltreLineRatioLinear_amst_2_3.hdr ${TEMP}/feFiltreLineRatioLinear_amst_2_3.hdr ${BASELINE}/feFiltreLineRatioLinear_amst_dir_2_3.hdr ${TEMP}/feFiltreLineRatioLinear_amst_dir_2_3.hdr otbLineRatioDetectorLinear ${INPUTDATA}/amst.png ${TEMP}/feFiltreLineRatioLinear_amst_2_3.hdr ${TEMP}/feFiltreLineRatioLinear_amst_dir_2_3.hdr 2 3) otb_add_test(NAME feTuLineSegmentDetectorNew COMMAND otbEdgeTestDriver otbLineSegmentDetectorNew) otb_add_test(NAME feTvLineSegmentDetector COMMAND otbEdgeTestDriver --compare-ogr ${EPSILON_8} ${BASELINE_FILES}/feTvLineSegmentDetectorOutput.shp ${TEMP}/feTvLineSegmentDetectorOutput.shp otbLineSegmentDetector ${INPUTDATA}/scene.png ${TEMP}/feTvLineSegmentDetectorOutput.shp ) otb_add_test(NAME feTvLineCorrelationLinear COMMAND otbEdgeTestDriver --compare-n-images ${EPSILON_8} 2 ${BASELINE}/feFiltreLineCorrelationLinear_amst_2_3.hdr ${TEMP}/feFiltreLineCorrelationLinear_amst_2_3.hdr ${BASELINE}/feFiltreLineCorrelationLinear_amst_dir_2_3.hdr ${TEMP}/feFiltreLineCorrelationLinear_amst_dir_2_3.hdr otbLineCorrelationDetectorLinear ${INPUTDATA}/amst.png ${TEMP}/feFiltreLineCorrelationLinear_amst_2_3.hdr ${TEMP}/feFiltreLineCorrelationLinear_amst_dir_2_3.hdr 2 3) otb_add_test(NAME feTuLineDetectorBaseNew COMMAND otbEdgeTestDriver otbLineDetectorBaseNew) otb_add_test(NAME feTvFillGapsFilter COMMAND otbEdgeTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvFillGapfilter.png ${TEMP}/feTvFillGapfilter.png otbFillGapsFilter ${INPUTDATA}/ImageLine.bsq.hdr ${TEMP}/feTvFillGapfilter.png) otb_add_test(NAME feTuFillGapsFilterNew COMMAND otbEdgeTestDriver otbFillGapsFilterNew) OTB-release-5.8/Modules/Feature/Edge/test/otbAssociativeSymmetricalSum.cxx000066400000000000000000000037751301006202600266620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbAssociativeSymmetricalSumImageFilter.h" int otbAssociativeSymmetricalSum(int itkNotUsed(argc), char* argv[]) { const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[3]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef otb::AssociativeSymmetricalSumImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbAssociativeSymmetricalSumNew.cxx000066400000000000000000000024231301006202600273210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbAssociativeSymmetricalSumImageFilter.h" int otbAssociativeSymmetricalSumNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image OutputImageType; typedef otb::AssociativeSymmetricalSumImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbAsymmetricFusionOfLineDetector.cxx000066400000000000000000000043631301006202600275730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbAsymmetricFusionOfLineDetectorImageFilter.h" int otbAsymmetricFusionOfLineDetector(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Width of the linear feature = 2*WidthLine+1 unsigned int WidthLine((unsigned int) ::atoi(argv[3])); // Length of the linear feature = 2*LengthLine+1 unsigned int LengthLine((unsigned int) ::atoi(argv[4])); typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image OutputImageDirectionType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::AsymmetricFusionOfLineDetectorImageFilter FilterType; FilterType::Pointer FilterAssSymSum = FilterType::New(); FilterAssSymSum->SetWidthLine(WidthLine); FilterAssSymSum->SetLengthLine(LengthLine); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); FilterAssSymSum->SetInput(reader->GetOutput()); writer->SetInput(FilterAssSymSum->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbAsymmetricFusionOfLineDetectorNew.cxx000066400000000000000000000027631301006202600302470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbAsymmetricFusionOfLineDetectorImageFilter.h" int otbAsymmetricFusionOfLineDetectorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image OutputImageDirectionType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::AsymmetricFusionOfLineDetectorImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbEdgeDensityImageFilter.cxx000066400000000000000000000052341301006202600260160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbEdgeDensityImageFilter.h" #include "otbBinaryImageDensityFunction.h" #include "itkCannyEdgeDetectionImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbEdgeDensityImageFilter(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int radius = atoi(argv[3]); /** Variables for the canny detector*/ const double upperThreshold = atof(argv[4]); const double lowerThreshold = atof(argv[5]); const double variance = atof(argv[6]); const double maximumError = atof(argv[7]); /*--*/ const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::BinaryImageDensityFunction CountFunctionType; typedef itk::CannyEdgeDetectionImageFilter CannyDetectorType; typedef otb::EdgeDensityImageFilter EdgeDensityFilterType; /**Instantiation of an object*/ EdgeDensityFilterType::Pointer filter = EdgeDensityFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); CannyDetectorType::Pointer CannyFilter = CannyDetectorType::New(); /** Set The input*/ reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); /** Update the Canny Filter Information*/ CannyFilter->SetUpperThreshold(static_cast(upperThreshold)); /** 30*/ CannyFilter->SetLowerThreshold(static_cast(lowerThreshold)); /** 10*/ CannyFilter->SetVariance(variance); //1. CannyFilter->SetMaximumError(maximumError); ///0.01f filter->SetDetector(CannyFilter); filter->SetNeighborhoodRadius(radius); /** Write the output*/ WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbEdgeDensityImageFilterNew.cxx000066400000000000000000000025121301006202600264640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbEdgeDensityImageFilter.h" #include "otbBinaryImageDensityFunction.h" #include "itkCannyEdgeDetectionImageFilter.h" int otbEdgeDensityImageFilterNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::BinaryImageDensityFunction CountFunctionType; typedef itk::CannyEdgeDetectionImageFilter CannyDetectorType; typedef otb::EdgeDensityImageFilter EdgeDensityFilterType; /**Instantiation of an object*/ EdgeDensityFilterType::Pointer filter = EdgeDensityFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbEdgeDetectorImageFilter.cxx000066400000000000000000000034771301006202600261570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbEdgeDetectorImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkSobelEdgeDetectionImageFilter.h" int otbEdgeDetectorImageFilter(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::SobelEdgeDetectionImageFilter SobelDetectionType; typedef otb::EdgeDetectorImageFilter DetectorType; /**Instantiation of an object*/ ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); DetectorType::Pointer detector = DetectorType::New(); SobelDetectionType::Pointer sobelFilter = SobelDetectionType::New(); reader->SetFileName(argv[1]); detector->SetInput(reader->GetOutput()); detector->SetLowerThreshold(static_cast(atof(argv[3]))); detector->SetUpperThreshold(static_cast(atof(argv[4]))); writer->SetFileName(argv[2]); writer->SetInput(detector->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbEdgeDetectorImageFilterNew.cxx000066400000000000000000000022001301006202600266100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbEdgeDetectorImageFilter.h" #include "itkSobelEdgeDetectionImageFilter.h" int otbEdgeDetectorImageFilterNew(int, char*[]) { typedef double PixelType; typedef otb::Image ImageType; typedef itk::SobelEdgeDetectionImageFilter SobelType; typedef otb::EdgeDetectorImageFilter FilterType; /**Instantiation of an object*/ FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbEdgeTestDriver.cxx000066400000000000000000000036601301006202600243620ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbPixelSuppressionByDirectionNew); REGISTER_TEST(otbEdgeDetectorImageFilter); REGISTER_TEST(otbHorizontalSobelVectorImageFilterNewTest); REGISTER_TEST(otbHorizontalSobelVectorImageFilterTest); REGISTER_TEST(otbAsymmetricFusionOfLineDetector); REGISTER_TEST(otbLocalHoughDraw); REGISTER_TEST(otbAssociativeSymmetricalSum); REGISTER_TEST(otbPersistentVectorizationFilterNew); REGISTER_TEST(otbLineCorrelationDetectorNew); REGISTER_TEST(otbPersistentVectorizationFilter); REGISTER_TEST(otbEdgeDensityImageFilter); REGISTER_TEST(otbLineCorrelationDetector); REGISTER_TEST(otbSobelVectorImageFilterNewTest); REGISTER_TEST(otbSobelVectorImageFilterTest); REGISTER_TEST(otbAssociativeSymmetricalSumNew); REGISTER_TEST(otbHoughTransform2DLinesImageTest); REGISTER_TEST(otbPixelSuppressionByDirection); REGISTER_TEST(otbLocalHoughNew); REGISTER_TEST(otbEdgeDetectorImageFilterNew); REGISTER_TEST(otbEdgeDensityImageFilterNew); REGISTER_TEST(otbLocalHough); REGISTER_TEST(otbExtractSegments); REGISTER_TEST(otbExtractSegmentsNew); REGISTER_TEST(otbAsymmetricFusionOfLineDetectorNew); REGISTER_TEST(otbLineRatioDetector); REGISTER_TEST(otbTouziEdgeDetectorDirection); REGISTER_TEST(otbTouziEdgeDetectorNew); REGISTER_TEST(otbVerticalSobelVectorImageFilterNewTest); REGISTER_TEST(otbVerticalSobelVectorImageFilterTest); REGISTER_TEST(otbStreamingLineSegmentDetectorNew); REGISTER_TEST(otbStreamingLineSegmentDetector); REGISTER_TEST(otbLineRatioDetectorNew); REGISTER_TEST(otbTouziEdgeDetector); REGISTER_TEST(otbLineRatioDetectorLinear); REGISTER_TEST(otbLineSegmentDetectorNew); REGISTER_TEST(otbLineSegmentDetector); REGISTER_TEST(otbLineSegmentDetector_8b_16b_compare); REGISTER_TEST(otbLineCorrelationDetectorLinear); REGISTER_TEST(otbLineDetectorBaseNew); REGISTER_TEST(otbFillGapsFilter); REGISTER_TEST(otbFillGapsFilterNew); } OTB-release-5.8/Modules/Feature/Edge/test/otbExtractSegments.cxx000066400000000000000000000066061301006202600246250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractSegmentsImageFilter.h" int otbExtractSegments(int itkNotUsed(argc), char * argv[]) { const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[3]; unsigned int PixelSuppressionRadiusX((unsigned int) ::atoi(argv[4])); float PixelSuppressionAngularBeam((float) ::atof(argv[5])); unsigned int LocalHoughRadiusX((unsigned int) ::atoi(argv[6])); unsigned int LocalHoughRadiusY((unsigned int) ::atoi(argv[7])); unsigned int LocalHoughNumberOfLines((unsigned int) ::atoi(argv[8])); float FillGapsRadius((float) ::atof(argv[9])); float FillGapsAngularBeam((float) ::atof(argv[10])); typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::ExtractSegmentsImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); // filter parameters FilterType::SizeType PixelSuppressionRadius; PixelSuppressionRadius[0] = PixelSuppressionRadiusX; PixelSuppressionRadius[1] = PixelSuppressionRadiusX; filter->SetPixelSuppressionRadius(PixelSuppressionRadius); filter->SetPixelSuppressionAngularBeam(PixelSuppressionAngularBeam); FilterType::SizeType LocalHoughRadius; LocalHoughRadius[0] = LocalHoughRadiusX; LocalHoughRadius[1] = LocalHoughRadiusY; filter->SetLocalHoughRadius(LocalHoughRadius); filter->SetLocalHoughNumberOfLines(LocalHoughNumberOfLines); filter->SetFillGapsRadius(FillGapsRadius); filter->SetFillGapsAngularBeam(FillGapsAngularBeam); // Reader / Writer ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); filter->SetInputImage(reader1->GetOutput()); filter->SetInputImageDirection(reader2->GetOutput()); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbExtractSegmentsNew.cxx000066400000000000000000000023561301006202600252750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractSegmentsImageFilter.h" int otbExtractSegmentsNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ExtractSegmentsImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbFillGapsFilter.cxx000066400000000000000000000070731301006202600243530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbFillGapsFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbDrawLineSpatialObjectListFilter.h" int otbFillGapsFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::DrawLineSpatialObjectListFilter FilterType; typedef otb::FillGapsFilter FillGapsFilterType; typedef otb::LineSpatialObjectList LinesListType; typedef LinesListType::LineType LineType; FilterType::Pointer filter = FilterType::New(); typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); FillGapsFilterType::Pointer fillgaps = FillGapsFilterType::New(); LinesListType::Pointer linesListBeforeFillGaps = LinesListType::New(); const LinesListType * linesListAfterFillGaps; LineType::PointListType pointList; LineType::LinePointType point; // Definition of the first line double Ux, Uy, Vx, Vy; Ux = 10.; Uy = 10.; Vx = 10.; Vy = 20.; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line = LineType::New(); line->SetId(0); line->SetPoints(pointList); line->ComputeBoundingBox(); linesListBeforeFillGaps->push_back(line); pointList.clear(); // Definition of a second line Ux = 10.; Uy = 30.; Vx = 10.; Vy = 50.; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line2 = LineType::New(); line2->SetId(0); line2->SetPoints(pointList); line2->ComputeBoundingBox(); linesListBeforeFillGaps->push_back(line2); pointList.clear(); // Definition of a third line Ux = 20.; Uy = 50.; Vx = 50.; Vy = 50.; point.SetPosition(Ux, Uy); pointList.push_back(point); point.SetPosition(Vx, Vy); pointList.push_back(point); LineType::Pointer line3 = LineType::New(); line3->SetId(0); line3->SetPoints(pointList); line3->ComputeBoundingBox(); linesListBeforeFillGaps->push_back(line3); pointList.clear(); // FillGapsFilter parameters fillgaps->SetRadius(15.); fillgaps->SetAngularBeam(1.0); // Angle in Radian fillgaps->SetInput(linesListBeforeFillGaps); linesListAfterFillGaps = fillgaps->GetOutput(); fillgaps->Update(); filter->SetInputLineSpatialObjectList(linesListAfterFillGaps); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbFillGapsFilterNew.cxx000066400000000000000000000015461301006202600250240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbFillGapsFilter.h" int otbFillGapsFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::FillGapsFilter FillGapsFilterType; FillGapsFilterType::Pointer filter = FillGapsFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbHorizontalSobelVectorImageFilter.cxx000066400000000000000000000063561301006202600301210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbHorizontalSobelVectorImageFilter.h" int otbHorizontalSobelVectorImageFilterNewTest ( int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::HorizontalSobelVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbHorizontalSobelVectorImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs horizonal sobel on a vector image\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::HorizontalSobelVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbHoughTransform2DLinesImageTest.cxx000066400000000000000000000215761301006202600274420ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: otbHoughTransform2DLinesImageTest.cxx, v $ Language: C++ Date: $Date: 2007-03-07 14:05:39 $ Version: $Revision: 1.10 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbHoughTransform2DLinesImageFilter.h" #include "itkImageRegionIterator.h" #include "itkThresholdImageFilter.h" #include "itkMinimumMaximumImageCalculator.h" #include #include #include #include #include "otbImageFileWriter.h" /** * This program looks for straight lines whithin an image * It uses the ITK HoughTransform2DLinesImageFilter. * - Read the image. * - Apply a gradient and thresholding functions. * - Compute the accumulator by running the filter. * - Blur the accumulator. * - Find maxima in the accumulator. * - Display the results */ /** Hough Point structure */ struct houghPoint { double radius; double angle; }; /** Main program */ int otbHoughTransform2DLinesImageTest(int itkNotUsed(argc), char* argv[]) { const char * outputFilename = argv[1]; /** Typedefs */ typedef unsigned char PixelType; typedef double HoughSpacePixelType; typedef otb::Image HoughImageType; typedef otb::Image ImageType; typedef otb::ImageFileWriter WriterType; itk::Index<2> m_Index; /** Create a line image with one line */ std::cout << "Creating simulated image" << std::endl; ImageType::Pointer m_Image = ImageType::New(); ImageType::RegionType region; ImageType::SizeType size; size.Fill(100); ImageType::IndexType index; index.Fill(0); region.SetSize(size); region.SetIndex(index); m_Image->SetRegions(region); m_Image->Allocate(); m_Image->FillBuffer(0); /** Create a line */ float teta = 0.20; // radians float radius = 50; double Vx = radius * cos(teta); double Vy = radius * sin(teta); double norm = sqrt(Vx * Vx + Vy * Vy); double VxNorm = Vx / norm; double VyNorm = Vy / norm; unsigned int maxval = size[0] * size[1]; const double nPI = 4.0 * vcl_atan(1.0); for (unsigned int i = 0; i < maxval; i += 1) { m_Index[0] = (long int) (Vx - VyNorm * i); m_Index[1] = (long int) (Vy + VxNorm * i); if (((m_Index[0] < (long) size[0]) && (m_Index[0] >= 0)) && ((m_Index[1] < (long) size[1]) && (m_Index[1] >= 0)) ) { m_Image->SetPixel(m_Index, 255); } } /** Allocate Hough Space image (accumulator) */ std::cout << "Allocating Hough Space Image" << std::endl; HoughImageType::Pointer m_HoughSpaceImage = HoughImageType::New(); m_HoughSpaceImage->SetRegions(region); m_HoughSpaceImage->Allocate(); /** Apply gradient filter to the input image */ typedef itk::CastImageFilter< ImageType, HoughImageType> CastingFilterType; CastingFilterType::Pointer caster = CastingFilterType::New(); caster->SetInput(m_Image); std::cout << "Applying gradient magnitude filter" << std::endl; typedef itk::GradientMagnitudeImageFilter GradientFilterType; GradientFilterType::Pointer gradFilter = GradientFilterType::New(); gradFilter->SetInput(caster->GetOutput()); gradFilter->Update(); /** Apply a threshold to the Grad(InputImage) */ std::cout << "Thresholding" << std::endl; typedef itk::ThresholdImageFilter ThresholdFilterType; ThresholdFilterType::Pointer threshFilter = ThresholdFilterType::New(); threshFilter->SetInput(gradFilter->GetOutput()); threshFilter->SetOutsideValue(0); unsigned char thresh_below = 10; unsigned char thresh_above = 200; threshFilter->ThresholdOutside(thresh_below, thresh_above); threshFilter->Update(); /** Define the HoughTransform filter */ typedef otb::HoughTransform2DLinesImageFilter HoughTransformFilterType; HoughTransformFilterType::Pointer houghFilter = HoughTransformFilterType::New(); houghFilter->SetInput(threshFilter->GetOutput()); houghFilter->SetThreshold(0.0f); if (houghFilter->GetThreshold() != 0.0f) { std::cout << "Failure" << std::endl; return EXIT_FAILURE; } //houghFilter->SetAngleResolution(500.0f); houghFilter->SetDiscRadius(10.0f); if (houghFilter->GetDiscRadius() != 10.0f) { std::cout << "Failure" << std::endl; return EXIT_FAILURE; } houghFilter->SetVariance(10.0f); if (houghFilter->GetVariance() != 10.0f) { std::cout << "Failure" << std::endl; return EXIT_FAILURE; } houghFilter->Update(); houghFilter->Simplify(); HoughImageType::Pointer m_SimplifyAccumulator = houghFilter->GetSimplifyAccumulator(); HoughImageType::Pointer m_Accumulator = houghFilter->GetOutput(); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(m_Accumulator); writer->Update(); /** Blur the accumulator in order to find the maximum */ HoughImageType::Pointer m_PostProcessImage = HoughImageType::New(); typedef itk::DiscreteGaussianImageFilter GaussianFilterType; GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); gaussianFilter->SetInput(m_Accumulator); double variance[2]; variance[0] = 10; variance[1] = 10; gaussianFilter->SetVariance(variance); gaussianFilter->SetMaximumError(.01f); gaussianFilter->Update(); m_PostProcessImage = gaussianFilter->GetOutput(); typedef itk::MinimumMaximumImageCalculator MinMaxCalculatorType; MinMaxCalculatorType::Pointer minMaxCalculator = MinMaxCalculatorType::New(); itk::ImageRegionIterator it_output(m_HoughSpaceImage, m_HoughSpaceImage->GetLargestPossibleRegion()); itk::ImageRegionIterator it_input(m_PostProcessImage, m_PostProcessImage->GetLargestPossibleRegion()); /** Set the number of lines we are looking for. */ unsigned int m_NumberOfLines = 1; /** Each time we find a maximum we remove it by drawing a black disc this define the size of this disc */ unsigned int m_HoughDiscRadius = 10; unsigned int lines = 0; std::list m_LinesList; /** Find maxima */ do { minMaxCalculator->SetImage(m_PostProcessImage); minMaxCalculator->ComputeMaximum(); HoughImageType::PixelType max = minMaxCalculator->GetMaximum(); for (it_input.GoToBegin(); !it_input.IsAtEnd(); ++it_input) { if (it_input.Get() == max) { houghPoint m_HoughPoint; m_HoughPoint.radius = it_input.GetIndex()[0]; m_HoughPoint.angle = ((it_input.GetIndex()[1]) * 2 * nPI / houghFilter->GetAngleAxisSize()) - nPI; m_LinesList.push_back(m_HoughPoint); // Remove a black disc from the hough space domain for (double angle = 0; angle <= 2 * nPI; angle += nPI / 1000) { for (double length = 0; length < m_HoughDiscRadius; length += 1) { m_Index[0] = (long int) (it_input.GetIndex()[0] + length * cos(angle)); m_Index[1] = (long int) (it_input.GetIndex()[1] + length * sin(angle)); if (((m_Index[0] <= sqrt((double) 400 * 400 + 400 * 400)) && (m_Index[0] >= 0)) && ((m_Index[1] <= 500) && (m_Index[1] >= 0)) ) { m_Accumulator->SetPixel(m_Index, 0); } } } minMaxCalculator->SetImage(m_Accumulator); minMaxCalculator->ComputeMaximum(); max = minMaxCalculator->GetMaximum(); lines++; if (lines == m_NumberOfLines) break; } } } while (lines < m_NumberOfLines); std::list::iterator it_list = m_LinesList.begin(); while (it_list != m_LinesList.end()) { std::cout << "Angle = " << it_list->angle << " (expected " << teta << ")" << std::endl; std::cout << "Radius = " << it_list->radius << " (expected " << radius << ")" << std::endl; if (fabs(it_list->angle - teta) > 0.1) { std::cout << "Failure" << std::endl; //return EXIT_FAILURE; } if (fabs(it_list->radius - radius) > 1.0) { std::cout << "Failure" << std::endl; //return EXIT_FAILURE; } it_list++; } std::cout << "Printing Hough Fiter information:" << std::endl; std::cout << houghFilter << std::endl; std::cout << "Hough Transform Successful" << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineCorrelationDetector.cxx000066400000000000000000000037471301006202600262730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbLineCorrelationDetectorImageFilter.h" int otbLineCorrelationDetector(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Parameters of the line to detect unsigned int WidthLine((unsigned int) ::atoi(argv[3])); unsigned int LengthLine((unsigned int) ::atoi(argv[4])); typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::LineCorrelationDetectorImageFilter FilterType; FilterType::Pointer FilterLineCorrelation = FilterType::New(); FilterLineCorrelation->SetWidthLine(WidthLine); FilterLineCorrelation->SetLengthLine(LengthLine); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); FilterLineCorrelation->SetInput(reader->GetOutput()); writer->SetInput(FilterLineCorrelation->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineCorrelationDetectorLinear.cxx000066400000000000000000000046721301006202600274240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbLineCorrelationDetectorImageFilter.h" int otbLineCorrelationDetectorLinear(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputFilename1 = argv[2]; const char * outputFilename2 = argv[3]; // Parameters of the line to detect unsigned int WidthLine((unsigned int) ::atoi(argv[4])); unsigned int LengthLine((unsigned int) ::atoi(argv[5])); typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image OutputImageDirectionType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::LineCorrelationDetectorImageFilter FilterType; FilterType::Pointer FilterLineCorrelation = FilterType::New(); FilterLineCorrelation->SetWidthLine(WidthLine); FilterLineCorrelation->SetLengthLine(LengthLine); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer1 = WriterType::New(); WriterType::Pointer writer2 = WriterType::New(); reader->SetFileName(inputFilename); writer1->SetFileName(outputFilename1); writer2->SetFileName(outputFilename2); FilterLineCorrelation->SetInput(reader->GetOutput()); writer1->SetInput(FilterLineCorrelation->GetOutput()); writer2->SetInput(FilterLineCorrelation->GetOutputDirection()); writer1->Update(); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineCorrelationDetectorNew.cxx000066400000000000000000000023051301006202600267320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbLineCorrelationDetectorImageFilter.h" int otbLineCorrelationDetectorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LineCorrelationDetectorImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineDetectorBaseNew.cxx000066400000000000000000000022321301006202600253220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbLineDetectorImageFilterBase.h" int otbLineDetectorBaseNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LineDetectorImageFilterBase FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineRatioDetector.cxx000066400000000000000000000037731301006202600250670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbLineRatioDetectorImageFilter.h" int otbLineRatioDetector(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; // Largeur de la ligne a detecter = 2*WidthLine+1 unsigned int WidthLine((unsigned int) ::atoi(argv[3])); // Longueur de la ligne a detecter = 2*LengthLine+1 unsigned int LengthLine((unsigned int) ::atoi(argv[4])); typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::LineRatioDetectorImageFilter FilterType; FilterType::Pointer FilterLineRatio = FilterType::New(); FilterLineRatio->SetWidthLine(WidthLine); FilterLineRatio->SetLengthLine(LengthLine); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); FilterLineRatio->SetInput(reader->GetOutput()); writer->SetInput(FilterLineRatio->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineRatioDetectorLinear.cxx000066400000000000000000000046751301006202600262240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbLineRatioDetectorImageFilter.h" int otbLineRatioDetectorLinear(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputFilename1 = argv[2]; const char * outputFilename2 = argv[3]; // Width of the linear feature = 2*WidthLine+1 unsigned int WidthLine((unsigned int) ::atoi(argv[4])); // Length of the linear feature = 2*LengthLine+1 unsigned int LengthLine((unsigned int) ::atoi(argv[5])); typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image OutputImageDirectionType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef otb::LineRatioDetectorImageFilter FilterType; FilterType::Pointer FilterLineRatio = FilterType::New(); FilterLineRatio->SetWidthLine(WidthLine); FilterLineRatio->SetLengthLine(LengthLine); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer1 = WriterType::New(); WriterType::Pointer writer2 = WriterType::New(); reader->SetFileName(inputFilename); writer1->SetFileName(outputFilename1); writer2->SetFileName(outputFilename2); FilterLineRatio->SetInput(reader->GetOutput()); writer1->SetInput(FilterLineRatio->GetOutput()); writer2->SetInput(FilterLineRatio->GetOutputDirection()); writer1->Update(); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineRatioDetectorNew.cxx000066400000000000000000000022641301006202600255330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbLineRatioDetectorImageFilter.h" int otbLineRatioDetectorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LineRatioDetectorImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLineSegmentDetector.cxx000066400000000000000000000126131301006202600254040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLineSegmentDetector.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImageFileWriter.h" int otbLineSegmentDetectorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float InputPixelType; const unsigned int Dimension = 2; /** Typedefs */ typedef otb::Image InputImageType; typedef otb::LineSegmentDetector lsdFilterType; lsdFilterType::Pointer filter = lsdFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbLineSegmentDetector(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; /** Typedefs */ typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::LineSegmentDetector LSDFilterType; typedef LSDFilterType::VectorDataType VectorDataType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef otb::ImageFileWriter WriterType; /** Instantiation of smart pointer*/ ReaderType::Pointer reader = ReaderType::New(); LSDFilterType::Pointer lsdFilter = LSDFilterType::New(); //Reade the input image reader->SetFileName(infname); reader->GenerateOutputInformation(); //LSD Detection lsdFilter->SetInput(reader->GetOutput()); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); vdWriter->SetFileName(outfname); vdWriter->SetInput(lsdFilter->GetOutput()); vdWriter->Update(); if (argc > 3) { //Write the status map const char * regfname = argv[3]; WriterType::Pointer writer0 = WriterType::New(); writer0->SetFileName(regfname); writer0->SetInput(lsdFilter->GetMap()); writer0->Update(); //Write the gradient modulus image typedef otb::ImageFileWriter< otb::Image > WriterDoubleType; const char * gradModfname = argv[4]; WriterDoubleType::Pointer writer1 = WriterDoubleType::New(); writer1->SetFileName(gradModfname); writer1->SetInput(lsdFilter->GetGradMod()); writer1->Update(); //Write the gradient orientation image const char * gradOrifname = argv[5]; WriterDoubleType::Pointer writer2 = WriterDoubleType::New(); writer1->SetFileName(gradOrifname); writer1->SetInput(lsdFilter->GetGradOri()); writer1->Update(); } return EXIT_SUCCESS; } int otbLineSegmentDetector_8b_16b_compare(int itkNotUsed(argc), char * argv[]) { const char * infname8 = argv[1]; const char * infname16 = argv[2]; const char * outfname8 = argv[3]; const char * outfname16 = argv[4]; /** Typedefs */ typedef unsigned char PixelType8; typedef otb::Image ImageType8; typedef otb::ImageFileReader ReaderType8; typedef otb::LineSegmentDetector LSDFilterType8; typedef unsigned short PixelType16; typedef otb::Image ImageType16; typedef otb::ImageFileReader ReaderType16; typedef otb::LineSegmentDetector LSDFilterType16; typedef LSDFilterType8::VectorDataType VectorDataType; typedef otb::VectorDataFileWriter VectorDataWriterType; /** 8bits */ //Instantiation of smart pointer ReaderType8::Pointer reader8 = ReaderType8::New(); LSDFilterType8::Pointer lsdFilter8 = LSDFilterType8::New(); //Reade the input image reader8->SetFileName(infname8); reader8->GenerateOutputInformation(); //LSD Detection lsdFilter8->SetInput(reader8->GetOutput()); VectorDataWriterType::Pointer vdWriter8 = VectorDataWriterType::New(); vdWriter8->SetFileName(outfname8); vdWriter8->SetInput(lsdFilter8->GetOutput()); vdWriter8->Update(); /** 16bits */ //Instantiation of smart pointer ReaderType16::Pointer reader16 = ReaderType16::New(); LSDFilterType16::Pointer lsdFilter16 = LSDFilterType16::New(); //Reade the input image reader16->SetFileName(infname16); reader16->GenerateOutputInformation(); //LSD Detection lsdFilter16->SetInput(reader16->GetOutput()); VectorDataWriterType::Pointer vdWriter16 = VectorDataWriterType::New(); vdWriter16->SetFileName(outfname16); vdWriter16->SetInput(lsdFilter16->GetOutput()); vdWriter16->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLocalHough.cxx000066400000000000000000000042021301006202600235200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbLocalHoughFilter.h" #include #include int otbLocalHough(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outfname = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); unsigned int RadiusY((unsigned int) ::atoi(argv[4])); unsigned int NumberOfLines((unsigned int) ::atoi(argv[5])); typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::LocalHoughFilter FilterType; FilterType::Pointer filter = FilterType::New(); typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->Update(); FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusY; typedef otb::LineSpatialObjectList LinesListType; LinesListType::Pointer list = LinesListType::New(); filter->SetRadius(Radius); filter->SetNumberOfLines(NumberOfLines); filter->SetInput(reader->GetOutput()); filter->Update(); list = filter->GetOutput(); LinesListType::const_iterator itList; std::ofstream outfile(outfname); outfile << "size of the Line list " << list->size() << std::endl; for (itList = list->begin(); itList != list->end(); itList++) outfile << (*itList)->GetPoints()[0].GetPosition() << " \t" << (*itList)->GetPoints()[1].GetPosition() << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLocalHoughDraw.cxx000066400000000000000000000051761301006202600243510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbLocalHoughFilter.h" #include "otbDrawLineSpatialObjectListFilter.h" #include "itkRescaleIntensityImageFilter.h" int otbLocalHoughDraw(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); unsigned int RadiusY((unsigned int) ::atoi(argv[4])); unsigned int NumberOfLines((unsigned int) ::atoi(argv[5])); typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LocalHoughFilter FilterType; //typedef otb::ImageToLineSpatialObjectListFilter< InputImageType > FilterType; FilterType::Pointer filter = FilterType::New(); typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); reader->SetFileName(inputFilename); reader->Update(); writer->SetFileName(outputFilename); FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusY; filter->SetRadius(Radius); filter->SetNumberOfLines(NumberOfLines); rescaler->SetInput(reader->GetOutput()); filter->SetInput(rescaler->GetOutput()); filter->Update(); typedef otb::DrawLineSpatialObjectListFilter DrawFilterType; DrawFilterType::Pointer drawfilter = DrawFilterType::New(); drawfilter->SetInputLineSpatialObjectList(filter->GetOutput()); drawfilter->SetInput(reader->GetOutput()); writer->SetInput(drawfilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbLocalHoughNew.cxx000066400000000000000000000020321301006202600241710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbLocalHoughFilter.h" int otbLocalHoughNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::LocalHoughFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbPersistentVectorizationFilter.cxx000066400000000000000000000037341301006202600275730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbPolygon.h" #include "otbPersistentVectorizationImageFilter.h" #include "otbImageFileReader.h" #include int otbPersistentVectorizationFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int ImageDimension = 2; typedef unsigned short LabelType; typedef otb::Image ImageType; typedef otb::Polygon PolygonType; typedef otb::PersistentVectorizationImageFilter FilterType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); filter->Update(); typedef FilterType::PathListType PathListType; std::ofstream f; f.open(outfname); for (PathListType::Iterator it = filter->GetPathList()->Begin(); it != filter->GetPathList()->End(); ++it) { for (unsigned int i = 0; i < it.Get()->GetVertexList()->Size(); ++i) { f << "[ " << it.Get()->GetVertexList()->GetElement(i)[0] << ", " << it.Get()->GetVertexList()->GetElement(i)[1] << "] "; } f << std::endl; } f.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbPersistentVectorizationFilterNew.cxx000066400000000000000000000023041301006202600302350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbPolygon.h" #include "otbPersistentVectorizationImageFilter.h" int otbPersistentVectorizationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int ImageDimension = 2; typedef unsigned short LabelType; typedef otb::Image ImageType; typedef otb::Polygon PolygonType; typedef otb::PersistentVectorizationImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbPixelSuppressionByDirection.cxx000066400000000000000000000043001301006202600271620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPixelSuppressionByDirectionImageFilter.h" int otbPixelSuppressionByDirection(int itkNotUsed(argc), char* argv[]) { const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[3]; unsigned int RadiusX((unsigned int) ::atoi(argv[4])); float AngularBeam((float) ::atof(argv[5])); typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef otb::PixelSuppressionByDirectionImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusX; filter->SetRadius(Radius); filter->SetAngularBeam(AngularBeam); ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); filter->SetInputImage(reader1->GetOutput()); filter->SetInputImageDirection(reader2->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbPixelSuppressionByDirectionNew.cxx000066400000000000000000000024041301006202600276370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbPixelSuppressionByDirectionImageFilter.h" int otbPixelSuppressionByDirectionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::PixelSuppressionByDirectionImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbSobelVectorImageFilter.cxx000066400000000000000000000062061301006202600260410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbSobelVectorImageFilter.h" int otbSobelVectorImageFilterNewTest ( int itkNotUsed(argc), char * itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::SobelVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbSobelVectorImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs sobel on a vector image\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::SobelVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbStreamingLineSegmentDetector.cxx000066400000000000000000000044701301006202600272600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbStreamingLineSegmentDetector.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" int otbStreamingLineSegmentDetectorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float InputPixelType; const unsigned int Dimension = 2; /** Typedefs */ typedef otb::Image ImageType; typedef otb::StreamingLineSegmentDetector::FilterType StreamingLSDFilterType; StreamingLSDFilterType::Pointer lsdFilter = StreamingLSDFilterType::New(); std::cout << lsdFilter << std::endl; return EXIT_SUCCESS; } int otbStreamingLineSegmentDetector(int itkNotUsed(argc), char * argv[]) { typedef float InputPixelType; const unsigned int Dimension = 2; // Typedefs typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingLineSegmentDetector::FilterType StreamingLineSegmentDetectorType; typedef StreamingLineSegmentDetectorType::FilterType::OutputVectorDataType OutputVectorDataType; typedef otb::VectorDataFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); StreamingLineSegmentDetectorType::Pointer lsdFilter = StreamingLineSegmentDetectorType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); reader->GenerateOutputInformation(); lsdFilter->GetFilter()->SetInput(reader->GetOutput()); lsdFilter->GetStreamer()->SetNumberOfLinesStrippedStreaming(atoi(argv[3])); lsdFilter->Update(); writer->SetFileName(argv[2]); writer->SetInput(lsdFilter->GetFilter()->GetOutputVectorData()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbTouziEdgeDetector.cxx000066400000000000000000000035101301006202600250650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbTouziEdgeDetectorImageFilter.h" int otbTouziEdgeDetector(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::TouziEdgeDetectorImageFilter FilterType; FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusX; FilterType::Pointer filterTouzi = FilterType::New(); filterTouzi->SetRadius(Radius); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filterTouzi->SetInput(reader->GetOutput()); writer->SetInput(filterTouzi->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbTouziEdgeDetectorDirection.cxx000066400000000000000000000035321301006202600267320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbTouziEdgeDetectorImageFilter.h" int otbTouziEdgeDetectorDirection(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::TouziEdgeDetectorImageFilter FilterType; FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusX; FilterType::Pointer filterTouzi = FilterType::New(); filterTouzi->SetRadius(Radius); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filterTouzi->SetInput(reader->GetOutput()); writer->SetInput(filterTouzi->GetOutputDirection()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbTouziEdgeDetectorNew.cxx000066400000000000000000000022361301006202600255430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbTouziEdgeDetectorImageFilter.h" int otbTouziEdgeDetectorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::TouziEdgeDetectorImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Edge/test/otbVerticalSobelVectorImageFilter.cxx000066400000000000000000000062771301006202600275430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbVerticalSobelVectorImageFilter.h" int otbVerticalSobelVectorImageFilterNewTest ( int itkNotUsed(argc), char * itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::VerticalSobelVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbVerticalSobelVectorImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs vertical sobel on a vector image\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::VerticalSobelVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/000077500000000000000000000000001301006202600200435ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Moments/CMakeLists.txt000066400000000000000000000000461301006202600226030ustar00rootroot00000000000000project(OTBMoments) otb_module_impl() OTB-release-5.8/Modules/Feature/Moments/include/000077500000000000000000000000001301006202600214665ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Moments/include/otbComplexMomentPathFunction.h000066400000000000000000000071141301006202600274610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbComplexMomentPathFunction_h #define otbComplexMomentPathFunction_h #include "otbGeometricMomentPathFunction.h" #include "itkVectorContainer.h" namespace otb { /** * \class ComplexMomentPathFunction * \brief Calculate the complex moment value over a path. * * The implemented equation is: * * \f[ c_{p, q}=\int\int_{D} (x+iy)^{p} \cdot (x-iy)^{q} \cdot dx \cdot dy \f] * * With: * * - \f$ (x, y) \f$ pixel localization; * - \f$ D \f$ the contour domain. * * This class is templated over : * - the input image type * - the path type * - and the coordinate representation type (e.g. float or double). * * \ingroup ImageFunctions * * \ingroup OTBMoments */ template , class TPrecision = double> class ITK_EXPORT ComplexMomentPathFunction : public GeometricMomentPathFunction { public: /** Standard class typedefs. */ typedef ComplexMomentPathFunction Self; typedef GeometricMomentPathFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ComplexMomentPathFunction, GeometricMomentPathFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputPathType typedef support. */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathConstPointer PathConstPointer; typedef typename PathType::ContinuousIndexType VertexType; typedef itk::VectorContainer VertexListType; typedef typename VertexListType::ConstPointer VertexListPointer; /** Complex Type */ typedef typename Superclass::OutputType ComplexType; typedef typename Superclass::OutputType OutputType; typedef double RealType; /** Type for calculation precision */ typedef typename Superclass::PrecisionType PrecisionType; /** ComplexType for calculation precision */ typedef std::complex ComplexPrecisionType; /** Evalulate the function */ OutputType Evaluate(const PathType& path) const ITK_OVERRIDE; virtual OutputType Evaluate() const; itkSetMacro(P, unsigned int); itkGetConstReferenceMacro(P, unsigned int); itkSetMacro(Q, unsigned int); itkGetConstReferenceMacro(Q, unsigned int); protected: ComplexMomentPathFunction(); ~ComplexMomentPathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ComplexMomentPathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ComplexPrecisionType EvaluateComplexMomentAtIndex(VertexType index) const; unsigned int m_P; unsigned int m_Q; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbComplexMomentPathFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbComplexMomentPathFunction.txx000066400000000000000000000121501301006202600300510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbComplexMomentPathFunction_txx #define otbComplexMomentPathFunction_txx #include "otbComplexMomentPathFunction.h" #include "itkImageRegionIterator.h" #include "itkConstNeighborhoodIterator.h" #include "otbMacro.h" #include namespace otb { /** * Constructor */ template ComplexMomentPathFunction ::ComplexMomentPathFunction() { m_P = 0; m_Q = 0; } /** * */ template void ComplexMomentPathFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " p indice value : " << m_P << std::endl; os << indent << " q indice value : " << m_Q << std::endl; } template typename ComplexMomentPathFunction::ComplexPrecisionType ComplexMomentPathFunction ::EvaluateComplexMomentAtIndex(VertexType index) const { ComplexPrecisionType ValP; ComplexPrecisionType ValQ; ComplexPrecisionType Result; PrecisionType PixelValue(1.0); ValP = ComplexPrecisionType(1.0, 0.0); ValQ = ComplexPrecisionType(1.0, 0.0); unsigned int p = m_P; while (p > 0) { ValP *= ComplexPrecisionType(index[0], index[1]); --p; } unsigned int q = m_Q; while (q > 0) { ValQ *= ComplexPrecisionType(index[0], -index[1]); --q; } Result = ValP * ValQ * ComplexPrecisionType(static_cast(PixelValue), 0.0); return Result; } template typename ComplexMomentPathFunction::OutputType ComplexMomentPathFunction ::Evaluate(const PathType& path) const { // Retrieve the vertex list VertexListPointer vertexList = path.GetVertexList(); // Get the number of vertices in the path unsigned int pathSize = vertexList->Size(); // value will store the result ComplexPrecisionType value = static_cast(0.0); // Check if we there are enough vertices in the path to actually // compute something if (pathSize < 2) { return static_cast(value); } // First, we compute the centroid of the path so as to center the moment typename VertexListType::ConstIterator it = vertexList->Begin(); VertexType centroid = it.Value(); ++it; // Cumulate points while (it != vertexList->End()) { centroid[0] += it.Value()[0]; centroid[1] += it.Value()[1]; ++it; } // Normalize centroid[0] /= static_cast(pathSize); centroid[1] /= static_cast(pathSize); // Second, we integrate along the edge it = vertexList->Begin(); VertexType source = it.Value(); source[0] -= centroid[0]; source[1] -= centroid[1]; ++it; PrecisionType ds; VertexType dest; // This variable will be used to normalize the moment PrecisionType norm = 0.; while (it != vertexList->End()) { dest = it.Value(); // Get source and destination coordinates dest[0] -= centroid[0]; dest[1] -= centroid[1]; // Don't forget the ds part of the integration process ds = vcl_sqrt(vcl_pow(dest[0] - source[0], 2.) + vcl_pow(dest[1] - source[1], 2.)); norm += ds; value += ds * EvaluateComplexMomentAtIndex(source); source = dest; ++it; } // Close the loop dest = vertexList->Begin().Value(); dest[0] -= centroid[0]; dest[1] -= centroid[1]; ds = vcl_sqrt(vcl_pow(dest[0] - source[0], 2.) + vcl_pow(dest[1] - source[1], 2.)); norm += ds; value += EvaluateComplexMomentAtIndex(source) * ds; norm = vcl_pow(norm, ((PrecisionType) m_P + (PrecisionType) m_Q) / 2.); // Normalize with edge perimeter value /= norm; return static_cast(value); } template typename ComplexMomentPathFunction::OutputType ComplexMomentPathFunction ::Evaluate() const { if (!this->GetInputPath()) { otbMsgDevMacro(<< "Pb with GetInputPath"); return static_cast(ComplexPrecisionType(itk::NumericTraits::Zero, itk::NumericTraits::Zero)); } OutputType Result = Evaluate(*(this->GetInputPath())); return Result; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbComplexMomentsImageFunction.h000066400000000000000000000110121301006202600277620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbComplexMomentsImageFunction_h #define otbComplexMomentsImageFunction_h #include "itkImageFunction.h" #include namespace otb { /** * \class ComplexMomentsImageFunction * \brief Calculate the complex moment values in the specified * neighborhood. * * Calculate the complex moment values over a specified neighborhood. * The implemented equation is: * * \f[ c_{p, q}=\int_{-\infty}^{\infty} \int_{-\infty}^{\infty} (x+iy)^{p} \cdot (x-iy)^{q} \cdot f(x, y) \cdot dx \cdot dy \f] * * With: * * - \f$ (x, y) \f$ pixel localization; * - \f$ f(x, y) \f$ the pixel value over the \f$(x, y) \f$ coordinate. * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double). * * \ingroup ImageFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT ComplexMomentsImageFunction : public itk::ImageFunction > >, TCoordRep> { public: /** Standard class typedefs. */ typedef ComplexMomentsImageFunction Self; typedef itk::ImageFunction > >, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ComplexMomentsImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef double ScalarRealType; typedef typename std::complex ScalarComplexType; typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); itkSetMacro(Pmax, unsigned int); itkGetConstReferenceMacro(Pmax, unsigned int); itkSetMacro(Qmax, unsigned int); itkGetConstReferenceMacro(Qmax, unsigned int); protected: ComplexMomentsImageFunction(); ~ComplexMomentsImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ComplexMomentsImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Pmax; unsigned int m_Qmax; unsigned int m_NeighborhoodRadius; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbComplexMomentsImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbComplexMomentsImageFunction.txx000066400000000000000000000072571301006202600303760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbComplexMomentsImageFunction_txx #define otbComplexMomentsImageFunction_txx #include "otbComplexMomentsImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template ComplexMomentsImageFunction ::ComplexMomentsImageFunction() { m_NeighborhoodRadius = 1; m_Pmax = 4; m_Qmax = 4; } template void ComplexMomentsImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " p indice maximum value : " << m_Pmax << std::endl; os << indent << " q indice maximum value : " << m_Qmax << std::endl; os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; } template typename ComplexMomentsImageFunction::OutputType ComplexMomentsImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build moments vector OutputType moments; moments.resize(m_Pmax+1); // Initialize moments for (unsigned int p = 0; p <= m_Pmax; p++) { moments[p].resize(m_Qmax+1); for (unsigned int q = 0; q <= m_Qmax; q++) { moments[p][q] = ScalarComplexType(0.0, 0.0); } } // Check for input image if( !this->GetInputImage() ) { return moments; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return moments; } // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Walk the neighborhood const unsigned int size = it.Size(); for (unsigned int i = 0; i < size; ++i) { // Retrieve value, and centered-reduced position ScalarRealType value = static_cast(it.GetPixel(i)); ScalarRealType x = static_cast(it.GetOffset(i)[0])/(2*m_NeighborhoodRadius+1); ScalarRealType y = static_cast(it.GetOffset(i)[1])/(2*m_NeighborhoodRadius+1); // Build complex value ScalarComplexType xpy(x, y), xqy(x, -y); // Update cumulants for (unsigned int p = 0; p <= m_Pmax; p++) { for (unsigned int q= 0; q <= m_Qmax; q++) { ScalarComplexType pow1(1,0); ScalarComplexType pow2(1,0); if(p!=0 || x!=0 || y != 0) { pow1 = std::pow(xpy, static_cast(p) ); } if(q!=0 || x!=0 || y != 0) { pow2 = std::pow(xqy, static_cast(q) ); } moments[p][q] += pow1 * pow2 * value; } } } // Normalisation for (int p = m_Pmax; p >= 0; p--) { for (int q= m_Qmax; q >= 0; q--) { moments[p][q] /= moments[0][0]; } } // Return result return moments; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbFlusserMomentsImageFunction.h000066400000000000000000000114661301006202600300130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlusserMomentsImageFunction_h #define otbFlusserMomentsImageFunction_h #include "itkImageFunction.h" #include "itkFixedArray.h" namespace otb { /** * \class FlusserMomentsImageFunction * \brief Calculate the Flusser's invariant parameters. * * Calculate the Flusser's invariants over a specified neighborhood * defined as : * * - \f$ \psi_{1} = c_{11} \f$ * - \f$ \psi_{2} = c_{21} c_{12} \f$ * - \f$ \psi_{3} = Re (c_{20} c_{12}^{2} )\f$ * - \f$ \psi_{4} = Im (c_{20} c_{12}^{2} )\f$ * - \f$ \psi_{5} = Re (c_{30} c_{12}^{3} )\f$ * - \f$ \psi_{6} = Im (c_{30} c_{12}^{3} )\f$ * - \f$ \psi_{7} = c_{22} \f$ * - \f$ \psi_{8} = Re (c_{31} c_{12}^{2} )\f$ * - \f$ \psi_{9} = Im (c_{31} c_{12}^{2} )\f$ * - \f$ \psi_{10} = Re (c_{40} c_{12}^{4} )\f$ * - \f$ \psi_{11} = Im (c_{40} c_{12}^{4} )\f$ * * With : * * \f[ c_{p, q}=\int_{-\infty}^{\infty} \int_{-\infty}^{\infty} (x+iy)^{p} \cdot (x-iy)^{q} \cdot f(x, y) \cdot dx \cdot dy \f] * * And: * - \f$(x, y)\f$ pixel localization; * - \f$ f(x, y)\f$ the pixel value over the \f$(x, y)\f$ coordinate. * * Note that the output is defined as: * \f$ \psi_{i} = output[i-1] \f$ * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double). * * \ingroup ImageFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT FlusserMomentsImageFunction : public itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits::RealType, 11 >, TCoordRep > { public: /** Standard class typedefs. */ typedef FlusserMomentsImageFunction Self; typedef itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits< typename TInputImage::PixelType>::RealType, 11 >, TCoordRep > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(FlusserMomentsImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef typename OutputType::ValueType ScalarRealType; typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); protected: FlusserMomentsImageFunction(); ~FlusserMomentsImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: FlusserMomentsImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NeighborhoodRadius; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFlusserMomentsImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbFlusserMomentsImageFunction.txx000066400000000000000000000110111301006202600303710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlusserMomentsImageFunction_txx #define otbFlusserMomentsImageFunction_txx #include "otbFlusserMomentsImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" #include namespace otb { /** * Constructor */ template FlusserMomentsImageFunction ::FlusserMomentsImageFunction() { m_NeighborhoodRadius = 1; } template void FlusserMomentsImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; } template typename FlusserMomentsImageFunction::OutputType FlusserMomentsImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build moments vector OutputType moments; // Initialize moments moments.Fill( itk::NumericTraits< ScalarRealType >::Zero ); // Check for input image if( !this->GetInputImage() ) { return moments; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return moments; } // Define complex type typedef std::complex ComplexType; // Define and initialize cumulants for complex moments ComplexType c11, c12, c21, c20, c30, c22, c31, c40; c11 = itk::NumericTraits::Zero; c12 = itk::NumericTraits::Zero; c21 = itk::NumericTraits::Zero; c20 = itk::NumericTraits::Zero; c30 = itk::NumericTraits::Zero; c22 = itk::NumericTraits::Zero; c31 = itk::NumericTraits::Zero; c40 = itk::NumericTraits::Zero; ScalarRealType c00 = itk::NumericTraits::Zero; // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Walk the neighborhood const unsigned int size = it.Size(); for (unsigned int i = 0; i < size; ++i) { // Retrieve value, and centered-reduced position ScalarRealType value = static_cast(it.GetPixel(i)); ScalarRealType x = static_cast(it.GetOffset(i)[0])/(2*m_NeighborhoodRadius+1); ScalarRealType y = static_cast(it.GetOffset(i)[1])/(2*m_NeighborhoodRadius+1); // Build complex value ComplexType xpy(x, y), xqy(x, -y); // Update cumulants c00 += value; c11 += xpy*xqy*value; c12 += xpy*xqy*xqy*value; c21 += xpy*xpy*xqy*value; c20 += xpy*xpy*value; c30 += xpy*xpy*xpy*value; c22 += xpy*xpy*xqy*xqy*value; c31 += xpy*xpy*xpy*xqy*value; c40 += xpy*xpy*xpy*xpy*value; } // Nomalisation c11 /= c00; c12 /= c00; c21 /= c00; c20 /= c00; c30 /= c00; c22 /= c00; c31 /= c00; c40 /= c00; // Compute moments combinations moments[0] = static_cast(c11.real()); moments[1] = static_cast((c21*c12).real()); moments[2] = static_cast((c20*c12*c12).real()); moments[3] = static_cast((c20*c12*c12).imag()); moments[4] = static_cast((c30*c12*c12*c12).real()); moments[5] = static_cast((c30*c12*c12*c12).imag()); moments[6] = static_cast(c22.real()); moments[7] = static_cast((c31*c12*c12).real()); moments[8] = static_cast((c31*c12*c12).imag()); moments[9] = static_cast((c40*c12*c12*c12*c12).real()); moments[10] = static_cast((c40*c12*c12*c12*c12).imag()); // Return result return moments; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbFlusserPathFunction.h000066400000000000000000000073051301006202600263170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlusserPathFunction_h #define otbFlusserPathFunction_h #include "otbRealMomentPathFunction.h" namespace otb { /** * \class FlusserPathFunction * \brief Calculate the Flusser's invariant parameters. * * Calculate the Flusser's invariant over a path and defined as: * * - \f$ \psi_{1} = c_{11} \f$ * - \f$ \psi_{2} = c_{21} c_{12} \f$ * - \f$ \psi_{3} = Re (c_{20} c_{12}^{2} )\f$ * - \f$ \psi_{4} = Im (c_{20} c_{12}^{2} )\f$ * - \f$ \psi_{5} = Re (c_{30} c_{12}^{3} )\f$ * - \f$ \psi_{6} = Im (c_{30} c_{12}^{3} )\f$ * - \f$ \psi_{7} = c_{22} \f$ * - \f$ \psi_{8} = Re (c_{31} c_{12}^{2} )\f$ * - \f$ \psi_{9} = Im (c_{31} c_{12}^{2} )\f$ * - \f$ \psi_{10} = Re (c_{40} c_{12}^{4} )\f$ * - \f$ \psi_{11} = Im (c_{40} c_{12}^{4} )\f$ * * With : * * \f[ c_{p, q}=\int \int (x+iy)^{p} \cdot (x-iy)^{q} \cdot f(x, y) \cdot dx \cdot dy \f] * * And: * - \f$(x, y)\f$ pixel localization; * - \f$ f(x, y)\f$ the pixel value over the \f$(x, y)\f$ coordinate. * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double). * * \ingroup PathFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT FlusserPathFunction : public RealMomentPathFunction { public: /** Standard class typedefs. */ typedef FlusserPathFunction Self; typedef RealMomentPathFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(FlusserPathFunction, RealMomentPathFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputPathType typedef support. */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathConstPointer PathConstPointer; typedef typename PathType::ContinuousIndexType VertexType; typedef itk::VectorContainer VertexListType; typedef typename VertexListType::ConstPointer VertexListPointer; typedef typename Superclass::RealType RealType; /** Type for calculation precision */ typedef typename Superclass::PrecisionType PrecisionType; /** Evaluate the function at non-integer positions */ RealType Evaluate(const PathType& path) const ITK_OVERRIDE; virtual RealType Evaluate() const; /** Get/Set the radius of the neighborhood over which the statistics are evaluated */ itkSetMacro(MomentNumber, short); itkGetConstReferenceMacro(MomentNumber, short); protected: FlusserPathFunction(); ~FlusserPathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: FlusserPathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented short m_MomentNumber; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFlusserPathFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbFlusserPathFunction.txx000066400000000000000000000135101301006202600267060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlusserPathFunction_txx #define otbFlusserPathFunction_txx #include "otbFlusserPathFunction.h" #include "otbComplexMomentPathFunction.h" #include "itkNumericTraits.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template FlusserPathFunction ::FlusserPathFunction() { m_MomentNumber = -1; } /** * */ template void FlusserPathFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " m_MomentNumber : " << m_MomentNumber << std::endl; } template typename FlusserPathFunction::RealType FlusserPathFunction ::Evaluate(const PathType& itkNotUsed(path)) const { typedef ComplexMomentPathFunction FunctionType; typedef typename FunctionType::ComplexType ComplexType; RealType FlusserValue(itk::NumericTraits::Zero); ComplexType FlusserValueComplex(itk::NumericTraits::Zero); typename FunctionType::Pointer function = FunctionType::New(); function->SetInputPath(this->GetInputPath()); switch (m_MomentNumber) { case 1: { ComplexType C11; function->SetP(1); function->SetQ(1); C11 = function->Evaluate(); FlusserValue = C11.real(); } break; case 2: { ComplexType C21, C12; function->SetP(2); function->SetQ(1); C21 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValue = vcl_abs(C21 * C12); } break; case 3: { ComplexType C20, C12; function->SetP(2); function->SetQ(0); C20 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C20 * vcl_pow(C12, 2); FlusserValue = FlusserValueComplex.real(); } break; case 4: { ComplexType C20, C12; function->SetP(2); function->SetQ(0); C20 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C20 * vcl_pow(C12, 2); FlusserValue = FlusserValueComplex.imag(); } break; case 5: { ComplexType C30, C12; function->SetP(3); function->SetQ(0); C30 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C30 * vcl_pow(C12, 3); FlusserValue = FlusserValueComplex.real(); } break; case 6: { ComplexType C30, C12; function->SetP(3); function->SetQ(0); C30 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C30 * vcl_pow(C12, 3); FlusserValue = FlusserValueComplex.imag(); } break; case 7: { ComplexType C22; function->SetP(2); function->SetQ(2); C22 = function->Evaluate(); FlusserValue = C22.real(); } break; case 8: { ComplexType C31, C12; function->SetP(3); function->SetQ(1); C31 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C31 * vcl_pow(C12, 2); FlusserValue = FlusserValueComplex.real(); } break; case 9: { ComplexType C31, C12; function->SetP(3); function->SetQ(1); C31 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C31 * vcl_pow(C12, 2); FlusserValue = FlusserValueComplex.imag(); } break; case 10: { ComplexType C40, C12; function->SetP(4); function->SetQ(0); C40 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C40 * vcl_pow(C12, 4); FlusserValue = FlusserValueComplex.real(); } break; case 11: { ComplexType C40, C12; function->SetP(4); function->SetQ(0); C40 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); FlusserValueComplex = C40 * vcl_pow(C12, 4); FlusserValue = FlusserValueComplex.imag(); } break; default: itkWarningMacro("Flusser's invariant parameters are between 1 and 11"); } return (static_cast(FlusserValue)); } template typename FlusserPathFunction::RealType FlusserPathFunction ::Evaluate() const { if (!this->GetInputPath()) { otbMsgDevMacro(<< "Pb with GetInputPath"); return static_cast(itk::NumericTraits::max()); } RealType Result = Evaluate(*(this->GetInputPath())); return Result; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbGeometricMomentPathFunction.h000066400000000000000000000041741301006202600277730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeometricMomentPathFunction_h #define otbGeometricMomentPathFunction_h #include "otbPathFunction.h" namespace otb { /** * \class GeometricMomentPathFunction * \brief Virtual class for the Geometric moments for an path function * * \ingroup PathFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT GeometricMomentPathFunction : public PathFunction { public: /** Standard class typedefs. */ typedef GeometricMomentPathFunction Self; typedef PathFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(GeometricMomentPathFunction, PathFunction); /** InputPathType typedef support. */ typedef typename Superclass::InputPathType PathType; typedef typename Superclass::InputPathConstPointer PathConstPointer; /** OutputPathType typedef support. */ typedef typename Superclass::OutputType OutputType; /** Type for calculation precision */ typedef TPrecision PrecisionType; protected: GeometricMomentPathFunction() {}; ~GeometricMomentPathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: GeometricMomentPathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbHuMomentsImageFunction.h000066400000000000000000000110711301006202600267340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHuMomentsImageFunction_h #define otbHuMomentsImageFunction_h #include "itkImageFunction.h" #include "itkFixedArray.h" namespace otb { /** * \class HuMomentsImageFunction * \brief Calculate the Hu's invariant parameters. * * Calculate the Hu's invariants over a specified neighbohood defined * as : * * - \f$ \phi_{1} = c_{11} \f$ * - \f$ \phi_{2} = c_{20} c_{02} \f$ * - \f$ \phi_{3} = c_{30} c_{03} \f$ * - \f$ \phi_{4} = c_{21} c_{12} \f$ * - \f$ \phi_{5} = Re (c_{30} c_{12}^{3}) \f$ * - \f$ \phi_{6} = Re (c_{20} c_{12}^{2}) \f$ * - \f$ \phi_{7} = Im (c_{30} c_{12}^{3}) \f$ * * With : * * \f[ c_{p, q}=\int_{-\infty}^{\infty} \int_{-\infty}^{\infty} (x+iy)^{p} \cdot (x-iy)^{q} \cdot f(x, y) \cdot dx \cdot dy \f] * * And: * - \f$(x, y)\f$ pixel localization; * - \f$ f(x, y)\f$ the pixel value over the \f$(x, y)\f$ coordinate. * * Note that the output is defined as: * \f$ \phi_{i} = output[i-1] \f$ * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double). * * \ingroup ImageFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT HuMomentsImageFunction : public itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits::RealType, 7 >, TCoordRep > { public: /** Standard class typedefs. */ typedef HuMomentsImageFunction Self; typedef itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits< typename TInputImage::PixelType>::RealType, 7 >, TCoordRep > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(HuMomentsImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef typename OutputType::ValueType ScalarRealType; typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); protected: HuMomentsImageFunction(); ~HuMomentsImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: HuMomentsImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NeighborhoodRadius; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHuMomentsImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbHuMomentsImageFunction.txx000066400000000000000000000101321301006202600273250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHuMomentsImageFunction_txx #define otbHuMomentsImageFunction_txx #include "otbHuMomentsImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" #include namespace otb { /** * Constructor */ template HuMomentsImageFunction ::HuMomentsImageFunction() { m_NeighborhoodRadius = 1; } template void HuMomentsImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; } template typename HuMomentsImageFunction::OutputType HuMomentsImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build moments vector OutputType moments; // Initialize moments moments.Fill( itk::NumericTraits< ScalarRealType >::Zero ); // Check for input image if( !this->GetInputImage() ) { return moments; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return moments; } // Define complex type typedef std::complex ComplexType; // Define and initialize cumulants for complex moments ComplexType c11, c20, c02, c30, c03, c21, c12; c11 = itk::NumericTraits::Zero; c20 = itk::NumericTraits::Zero; c02 = itk::NumericTraits::Zero; c30 = itk::NumericTraits::Zero; c03 = itk::NumericTraits::Zero; c21 = itk::NumericTraits::Zero; c12 = itk::NumericTraits::Zero; ScalarRealType c00 = itk::NumericTraits::Zero; // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Walk the neighborhood const unsigned int size = it.Size(); for (unsigned int i = 0; i < size; ++i) { // Retrieve value, and centered-reduced position ScalarRealType value = static_cast(it.GetPixel(i)); ScalarRealType x = static_cast(it.GetOffset(i)[0])/(2*m_NeighborhoodRadius+1); ScalarRealType y = static_cast(it.GetOffset(i)[1])/(2*m_NeighborhoodRadius+1); // Build complex value ComplexType xpy(x, y), xqy(x, -y); // Update cumulants c00 += value; c11 += xpy*xqy*value; c20 += xpy*xpy*value; c02 += xqy*xqy*value; c30 += xpy*xpy*xpy*value; c03 += xqy*xqy*xqy*value; c21 += xpy*xpy*xqy*value; c12 += xpy*xqy*xqy*value; } // Nomalisation c11 /= c00; c20 /= c00; c02 /= c00; c30 /= c00; c03 /= c00; c21 /= c00; c12 /= c00; // Compute moments combinations moments[0] = static_cast(c11.real()); moments[1] = static_cast((c20*c02).real()); moments[2] = static_cast((c30*c03).real()); moments[3] = static_cast((c21*c12).real()); moments[4] = static_cast((c30*c12*c12*c12).real()); moments[5] = static_cast((c20*c12*c12).real()); moments[6] = static_cast((c30*c12*c12*c12).imag()); // Return result return moments; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbHuPathFunction.h000066400000000000000000000067311301006202600252520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHuPathFunction_h #define otbHuPathFunction_h #include "otbRealMomentPathFunction.h" namespace otb { /** * \class HuPathFunction * \brief Calculate the Hu's invariant parameter. * * Calculate the Hu's invariant defined as: * * - \f$ \phi_{1} = c_{11} \f$ * - \f$ \phi_{2} = c_{20} c_{02} \f$ * - \f$ \phi_{3} = c_{30} c_{03} \f$ * - \f$ \phi_{4} = c_{21} c_{12} \f$ * - \f$ \phi_{5} = Re (c_{30} c_{12}^{3}) \f$ * - \f$ \phi_{6} = Re (c_{20} c_{12}^{2}) \f$ * - \f$ \phi_{7} = Im (c_{30} c_{12}^{3}) \f$ * * With : * * \f[ c_{p, q}=\int \int (x+iy)^{p} \cdot (x-iy)^{q} \cdot f(x, y) \cdot dx \cdot dy \f] * * And: * - \f$(x, y)\f$ pixel localization; * - \f$ f(x, y)\f$ the pixel value over the \f$(x, y)\f$ coordinate. * * This class is templated over the input image type and the * path type (e.g. PolyLineParametricPath<2> ). * * \ingroup FunctionFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT HuPathFunction : public RealMomentPathFunction { public: /** Standard class typedefs. */ typedef HuPathFunction Self; typedef RealMomentPathFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(HuPathFunction, RealMomentPathFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputPathType typedef support. */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathConstPointer PathConstPointer; typedef typename PathType::ContinuousIndexType VertexType; typedef itk::VectorContainer VertexListType; typedef typename VertexListType::ConstPointer VertexListPointer; /** OutputType typedef support. */ typedef typename Superclass::RealType RealType; /** Type for calculation precision */ typedef typename Superclass::PrecisionType PrecisionType; /** Evaluate the function at non-integer positions */ RealType Evaluate(const PathType& path) const ITK_OVERRIDE; virtual RealType Evaluate() const; /** Get/Set the radius of the neighborhood over which the statistics are evaluated */ itkSetMacro(MomentNumber, short); itkGetConstReferenceMacro(MomentNumber, short); protected: HuPathFunction(); ~HuPathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: HuPathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented short m_MomentNumber; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHuPathFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbHuPathFunction.txx000066400000000000000000000104621301006202600256420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHuPathFunction_txx #define otbHuPathFunction_txx #include "otbHuPathFunction.h" #include "otbComplexMomentPathFunction.h" #include "itkNumericTraits.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template HuPathFunction ::HuPathFunction() { m_MomentNumber = -1; } /** * */ template void HuPathFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " m_MomentNumber : " << m_MomentNumber << std::endl; } template typename HuPathFunction::RealType HuPathFunction ::Evaluate(const PathType& itkNotUsed(path)) const { typedef ComplexMomentPathFunction FunctionType; typedef typename FunctionType::ComplexType ComplexType; RealType HuValue = 0.; ComplexType HuValueComplex; typename FunctionType::Pointer function = FunctionType::New(); function->SetInputPath(this->GetInputPath()); switch (m_MomentNumber) { case 1: { ComplexType C11; function->SetP(1); function->SetQ(1); C11 = function->Evaluate(); HuValue = C11.real(); } break; case 2: { ComplexType C20, C02; function->SetP(2); function->SetQ(0); C20 = function->Evaluate(); function->SetP(0); function->SetQ(2); C02 = function->Evaluate(); HuValue = vcl_abs(C20 * C02); } break; case 3: { ComplexType C30, C03; function->SetP(3); function->SetQ(0); C30 = function->Evaluate(); function->SetP(0); function->SetQ(3); C03 = function->Evaluate(); HuValue = vcl_abs(C30 * C03); } break; case 4: { ComplexType C21, C12; function->SetP(2); function->SetQ(1); C21 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); HuValue = vcl_abs(C21 * C12); } break; case 5: { ComplexType C30, C12; function->SetP(3); function->SetQ(0); C30 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); HuValueComplex = C30 * vcl_pow(C12, 3); HuValue = HuValueComplex.real(); } break; case 6: { ComplexType C20, C12; function->SetP(2); function->SetQ(0); C20 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); HuValueComplex = C20 * vcl_pow(C12, 2); HuValue = HuValueComplex.real(); } break; case 7: { ComplexType C30, C12; function->SetP(3); function->SetQ(0); C30 = function->Evaluate(); function->SetP(1); function->SetQ(2); C12 = function->Evaluate(); HuValueComplex = C30 * vcl_pow(C12, 3); HuValue = HuValueComplex.imag(); } break; default: itkWarningMacro("Hu's invariant parameters are between 1 and 7"); } return (static_cast(HuValue)); } template typename HuPathFunction::RealType HuPathFunction ::Evaluate() const { if (!this->GetInputPath()) { otbMsgDevMacro(<< "Pb with GetInputPath"); return static_cast(itk::NumericTraits::max()); } RealType Result = Evaluate(*(this->GetInputPath())); return Result; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRadiometricMomentsFunctor.h000066400000000000000000000054271301006202600275220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometricMomentsFunctor_h #define otbRadiometricMomentsFunctor_h #include "itkVariableLengthVector.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class RadiometricMomentsFunctor * \brief * * \ingroup Functor * * \ingroup OTBMoments */ template class RadiometricMomentsFunctor { public: typedef RadiometricMomentsFunctor Self; typedef TNeighIter IteratorType; typedef typename IteratorType::PixelType PixelType; typedef TPrecision ScalarRealType; typedef itk::VariableLengthVector< ScalarRealType > OutputType; RadiometricMomentsFunctor() {} ~RadiometricMomentsFunctor() {} inline OutputType operator ()(TNeighIter& it) const { OutputType moments; moments.SetSize(4); moments.Fill( itk::NumericTraits< ScalarRealType >::Zero ); ScalarRealType sum1, sum2, sum3, sum4; sum1 = itk::NumericTraits< ScalarRealType >::Zero; sum2 = itk::NumericTraits< ScalarRealType >::Zero; sum3 = itk::NumericTraits< ScalarRealType >::Zero; sum4 = itk::NumericTraits< ScalarRealType >::Zero; //it.GoToBegin(); const unsigned int size = it.Size(); for (unsigned int i = 0; i < size; ++i) { ScalarRealType value = static_cast(it.GetPixel(i)); ScalarRealType value2 = value * value; // Update cumulants sum1 += value; sum2 += value2; sum3 += value * value2; sum4 += value2 * value2; } // final computations // Mean moments[0] = sum1 / size; // Variance moments[1] = (sum2 - (sum1 * moments[0])) / (size - 1); ScalarRealType sigma = vcl_sqrt(moments[1]); ScalarRealType mean2 = moments[0] * moments[0]; const double epsilon = 1E-10; if (vcl_abs(moments[1]) > epsilon) { // Skewness moments[2] = ((sum3 - 3.0 * moments[0] * sum2) / size + 2.0 * moments[0] * mean2) / (moments[1] * sigma); // Kurtosis moments[3] = ((sum4 - 4.0 * moments[0] * sum3 + 6.0 * mean2 * sum2) / size - 3.0 * mean2 * mean2) / (moments[1] * moments[1]) - 3.0; } return moments; } }; } } #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRadiometricMomentsImageFilter.h000066400000000000000000000075761301006202600303010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometricMomentsImageFilter_h #define otbRadiometricMomentsImageFilter_h #include "itkImageToImageFilter.h" #include "otbRadiometricMomentsFunctor.h" #include "itkConstNeighborhoodIterator.h" namespace otb { /** * \class RadiometricMomentsImageFilter * \brief Calculate the radiometric moments. * * Calculate the radiometric moments over a specified neighborhood * * This class is templated over the input image and the output image. * * \ingroup ImageFilters * * \ingroup OTBMoments */ template class ITK_EXPORT RadiometricMomentsImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef RadiometricMomentsImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RadiometricMomentsImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef typename Superclass::InputImageType InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::InternalPixelType ScalarType; typedef Functor::RadiometricMomentsFunctor< itk::ConstNeighborhoodIterator, ScalarType> FunctorType; typedef itk::ProcessObject ProcessObjectType; /**Set/Get the radius of neighborhood.*/ itkSetMacro(Radius, InputImageSizeType); itkGetMacro(Radius, InputImageSizeType); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::RadiusType RadiusType; typedef unsigned char RadiusSizeType; protected: RadiometricMomentsImageFilter(); ~RadiometricMomentsImageFilter() ITK_OVERRIDE {} void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void GenerateInputRequestedRegion(void) ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; private: RadiometricMomentsImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InputImageSizeType m_Radius; FunctorType m_Functor; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRadiometricMomentsImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRadiometricMomentsImageFilter.txx000066400000000000000000000120341301006202600306560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometricMomentsImageFilter_txx #define otbRadiometricMomentsImageFilter_txx #include "otbRadiometricMomentsImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "itkZeroFluxNeumannBoundaryCondition.h" #include "itkNeighborhoodAlgorithm.h" namespace otb { /** * Constructor */ template RadiometricMomentsImageFilter ::RadiometricMomentsImageFilter() { this->SetNumberOfRequiredInputs(1); m_Radius.Fill(1); } template void RadiometricMomentsImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /** * Generate the output information */ template void RadiometricMomentsImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel(4); } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void RadiometricMomentsImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itk::ZeroFluxNeumannBoundaryCondition nbc; // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImage so it cannot be used for the second input. InputImagePointer inputPtr = dynamic_cast(ProcessObjectType::GetInput(0)); OutputImagePointer outputPtr = this->GetOutput(0); RadiusType r; r[0] = m_Radius[0]; r[1] = m_Radius[1]; NeighborhoodIteratorType neighInputIt; itk::ImageRegionIterator outputIt; // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(inputPtr, outputRegionForThread, r); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { neighInputIt = itk::ConstNeighborhoodIterator(r, inputPtr, *fit); outputIt = itk::ImageRegionIterator(outputPtr, *fit); neighInputIt.OverrideBoundaryCondition(&nbc); neighInputIt.GoToBegin(); while (!outputIt.IsAtEnd()) { outputIt.Set(m_Functor(neighInputIt)); ++neighInputIt; ++outputIt; progress.CompletedPixel(); } } } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRadiometricMomentsImageFunction.h000066400000000000000000000104371301006202600306270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometricMomentsImageFunction_h #define otbRadiometricMomentsImageFunction_h #include "itkImageFunction.h" #include "otbRadiometricMomentsFunctor.h" #include "itkConstNeighborhoodIterator.h" #include "itkFixedArray.h" namespace otb { /** * \class RadiometricMomentsImageFunction * \brief Calculate the radiometric moments. * * Calculate the radiometric moments over a specified neighborhood * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double). * * \ingroup ImageFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT RadiometricMomentsImageFunction : public itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits::RealType, 4 >, TCoordRep > { public: /** Standard class typedefs. */ typedef RadiometricMomentsImageFunction Self; typedef itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits< typename TInputImage::PixelType>::RealType, 4 >, TCoordRep > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(RadiometricMomentsImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef typename OutputType::ValueType ScalarRealType; typedef TCoordRep CoordRepType; typedef Functor::RadiometricMomentsFunctor< itk::ConstNeighborhoodIterator, ScalarRealType> FunctorType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); protected: RadiometricMomentsImageFunction(); ~RadiometricMomentsImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RadiometricMomentsImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NeighborhoodRadius; FunctorType m_Functor; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRadiometricMomentsImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRadiometricMomentsImageFunction.txx000066400000000000000000000047451301006202600312300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometricMomentsImageFunction_txx #define otbRadiometricMomentsImageFunction_txx #include "otbRadiometricMomentsImageFunction.h" #include "itkMacro.h" #include "itkVariableLengthVector.h" #include namespace otb { /** * Constructor */ template RadiometricMomentsImageFunction ::RadiometricMomentsImageFunction() { m_NeighborhoodRadius = 1; } template void RadiometricMomentsImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; } template typename RadiometricMomentsImageFunction::OutputType RadiometricMomentsImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build moments vector OutputType moments; // Initialize moments moments.Fill( itk::NumericTraits< ScalarRealType >::Zero ); // Check for input image if( !this->GetInputImage() ) { return moments; } // Check for out of buffer //Self* _this = const_cast(this); //_this->SetInputImage( this->GetInputImage() ); if ( !this->IsInsideBuffer( index ) ) { return moments; } // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); itk::VariableLengthVector tmp(m_Functor(it)); for (unsigned int i=0; i<4; i++) { moments[i] = tmp[i]; } // Return result return moments; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRealMomentPathFunction.h000066400000000000000000000047711301006202600267430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRealMomentPathFunction_h #define otbRealMomentPathFunction_h #include "otbGeometricMomentPathFunction.h" #include "itkVectorContainer.h" namespace otb { /** * \class RealMomentPathFunction * \brief Virtual class for the Real moments for a path * * \ingroup PathFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT RealMomentPathFunction : public GeometricMomentPathFunction { public: /** Standard class typedefs. */ typedef RealMomentPathFunction Self; typedef GeometricMomentPathFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(RealMomentPathFunction, GeometricMomentPathFunction); /** InputPathType typedef support. */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathConstPointer PathConstPointer; typedef typename PathType::ContinuousIndexType VertexType; typedef itk::VectorContainer VertexListType; typedef typename VertexListType::ConstPointer VertexListPointer; /** Type for calculation precision */ typedef typename Superclass::PrecisionType PrecisionType; /** OutputType typedef support. */ typedef typename Superclass::OutputType RealType; protected: RealMomentPathFunction() {} ~RealMomentPathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: RealMomentPathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRealMomentsImageFunction.h000066400000000000000000000102771301006202600272520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRealMomentsImageFunction_h #define otbRealMomentsImageFunction_h #include "itkImageFunction.h" namespace otb { /** * \class RealMomentsImageFunction * \brief Calculate the moment values in the specified * neighborhood. * * Calculate the real moment values over a specified neighborhood. * * \ingroup ImageFunctions * * \ingroup OTBMoments */ template class ITK_EXPORT RealMomentsImageFunction : public itk::ImageFunction::RealType > >, TCoordRep> { public: /** Standard class typedefs. */ typedef RealMomentsImageFunction Self; typedef itk::ImageFunction::RealType > >, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(RealMomentsImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef float ScalarRealType; typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); itkSetMacro(Pmax, unsigned int); itkGetConstReferenceMacro(Pmax, unsigned int); itkSetMacro(Qmax, unsigned int); itkGetConstReferenceMacro(Qmax, unsigned int); protected: RealMomentsImageFunction(); ~RealMomentsImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RealMomentsImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Pmax; unsigned int m_Qmax; unsigned int m_NeighborhoodRadius; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRealMomentsImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Moments/include/otbRealMomentsImageFunction.txx000066400000000000000000000074201301006202600276420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRealMomentsImageFunction_txx #define otbRealMomentsImageFunction_txx #include "otbRealMomentsImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template RealMomentsImageFunction ::RealMomentsImageFunction() { m_NeighborhoodRadius = 1; m_Pmax = 4; m_Qmax = 4; } template void RealMomentsImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " p indice maximum value : " << m_Pmax << std::endl; os << indent << " q indice maximum value : " << m_Qmax << std::endl; os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; } template typename RealMomentsImageFunction::OutputType RealMomentsImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build moments vector OutputType moments; moments.resize(m_Pmax+1); std::vector valXpY, valXqY; valXpY.resize(m_Pmax+1); valXqY.resize(m_Qmax+1); // Initialize moments for (unsigned int p = 0; p <= m_Pmax; p++) { moments.at(p).resize(m_Qmax+1); valXpY.at(p) = 1.0; for (unsigned int q = 0; q <= m_Qmax; q++) { moments.at(p).at(q) = 0.0; valXqY.at(q) = 1.0; } } // Check for input image if( !this->GetInputImage() ) { return moments; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return moments; } // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Walk the neighborhood const unsigned int size = it.Size(); for (unsigned int i = 0; i < size; ++i) { // Retrieve value, and centered-reduced position ScalarRealType value = static_cast(it.GetPixel(i)); ScalarRealType x = static_cast(it.GetOffset(i)[0])/(2*m_NeighborhoodRadius+1); ScalarRealType y = static_cast(it.GetOffset(i)[1])/(2*m_NeighborhoodRadius+1); unsigned int pTmp = 1; unsigned int qTmp = 1; while (pTmp <= m_Pmax) { valXpY.at(pTmp) = valXpY.at(pTmp-1) * x; pTmp ++; } while (qTmp <= m_Qmax) { valXqY.at(qTmp) = valXqY.at(qTmp-1) * y; qTmp ++; } // Update cumulants for (unsigned int p = 0; p <= m_Pmax; p++) { for (unsigned int q= 0; q <= m_Qmax; q++) { moments.at(p).at(q) += valXpY.at(p) * valXqY.at(q) * value; } } } // Normalisation for (int p = m_Pmax; p >= 0; p--) { for (int q= m_Qmax; q >= 0; q--) { moments.at(p).at(q) /= moments.at(0).at(0); } } // Return result return moments; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Moments/otb-module.cmake000066400000000000000000000007371301006202600231230ustar00rootroot00000000000000set(DOCUMENTATION "Geometric moments are widely used in image processing and pattern recognition. This module contains classes that implement many moments: Hu, Flusser, and so on. Note that some of them can be evaluated along a path, instead of an image.") otb_module(OTBMoments DEPENDS OTBCommon OTBITK OTBPath TEST_DEPENDS OTBImageBase OTBImageIO OTBImageManipulation OTBInterpolation OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Feature/Moments/test/000077500000000000000000000000001301006202600210225ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Moments/test/CMakeLists.txt000066400000000000000000000123501301006202600235630ustar00rootroot00000000000000otb_module_test() set(OTBMomentsTests otbMomentsTestDriver.cxx otbComplexMomentPathFloat.cxx otbRadiometricMomentsImageFunction.cxx otbComplexMomentPathNew.cxx otbHuMomentsImageFunction.cxx otbRealMomentsImageFunction.cxx otbComplexMomentsImageFunction.cxx otbHuPathNew.cxx otbFlusserPathNew.cxx otbFlusserMomentsImageFunction.cxx otbHuPath.cxx otbFlusserPath.cxx otbComplexMomentPath.cxx otbRadiometricMomentsImageFilter.cxx ) add_executable(otbMomentsTestDriver ${OTBMomentsTests}) target_link_libraries(otbMomentsTestDriver ${OTBMoments-Test_LIBRARIES}) otb_module_target_label(otbMomentsTestDriver) # Tests Declaration otb_add_test(NAME feTvComplexMomentPathFloat COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feComplexMomentPathFloat.txt ${TEMP}/feComplexMomentPathFloat.txt otbComplexMomentPathFloat 1 1 ${TEMP}/feComplexMomentPathFloat.txt) otb_add_test(NAME feTuRadiometricMomentsImageFunctionNew COMMAND otbMomentsTestDriver otbRadiometricMomentsImageFunctionNew ) otb_add_test(NAME feTvRadiometricMomentsImageFunction COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feTvRadiometricMomentsImageFunction.txt ${TEMP}/feTvRadiometricMomentsImageFunction.txt otbRadiometricMomentsImageFunction ${INPUTDATA}/poupees.png ${TEMP}/feTvRadiometricMomentsImageFunction.txt) otb_add_test(NAME feTuComplexMomentPathNew COMMAND otbMomentsTestDriver otbComplexMomentPathNew) otb_add_test(NAME feTvHuMomentsImageFunction COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feTvHuMomentsImageFunction.txt ${TEMP}/feTvHuMomentsImageFunction.txt otbHuMomentsImageFunction ${INPUTDATA}/poupees.png ${TEMP}/feTvHuMomentsImageFunction.txt ) otb_add_test(NAME feTvHuMomentsImageFunctionScaleInvariant COMMAND otbMomentsTestDriver otbHuMomentsImageFunctionScaleInvariant ${INPUTDATA}/poupees.png ) otb_add_test(NAME feTuHuMomentsImageFunctionNew COMMAND otbMomentsTestDriver otbHuMomentsImageFunctionNew ) otb_add_test(NAME feTvHuMomentsImageFunctionRotationInvariant COMMAND otbMomentsTestDriver otbHuMomentsImageFunctionRotationInvariant ${INPUTDATA}/poupees.png 90 ) otb_add_test(NAME feTuRealMomentsImageFunctionNew COMMAND otbMomentsTestDriver otbRealMomentsImageFunctionNew ) otb_add_test(NAME feTvRealMomentsImageFunction COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feTvRealMomentsImageFunction.txt ${TEMP}/feTvRealMomentsImageFunction.txt otbRealMomentsImageFunction ${INPUTDATA}/poupees.png 4 4 ${TEMP}/feTvRealMomentsImageFunction.txt) otb_add_test(NAME feTvComplexMomentsImageFunction COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feTvComplexMomentsImageFunction.txt ${TEMP}/feTvComplexMomentsImageFunction.txt otbComplexMomentsImageFunction ${INPUTDATA}/poupees.png 4 4 ${TEMP}/feTvComplexMomentsImageFunction.txt ) otb_add_test(NAME feTuComplexMomentsImageFunctionNew COMMAND otbMomentsTestDriver otbComplexMomentsImageFunctionNew ) otb_add_test(NAME feTvComplexMomentsImageFunctionScaleInvariant COMMAND otbMomentsTestDriver otbComplexMomentsImageFunctionScaleInvariant ${INPUTDATA}/poupees.png 4 4 ) otb_add_test(NAME feTuHuPathNew COMMAND otbMomentsTestDriver otbHuPathNew) otb_add_test(NAME feTuFlusserPathNew COMMAND otbMomentsTestDriver otbFlusserPathNew) otb_add_test(NAME feTuFlusserMomentsImageFunctionNew COMMAND otbMomentsTestDriver otbFlusserMomentsImageFunctionNew ) otb_add_test(NAME feTvFlusserMomentsImageFunctionScaleInvariant COMMAND otbMomentsTestDriver otbFlusserMomentsImageFunctionScaleInvariant ${INPUTDATA}/poupees.png ) otb_add_test(NAME feTvFlusserMomentsImageFunction COMMAND otbMomentsTestDriver --compare-ascii ${EPSILON_8} ${BASELINE_FILES}/feTvFlusserMomentsImageFunction.txt ${TEMP}/feTvFlusserMomentsImageFunction.txt otbFlusserMomentsImageFunction ${INPUTDATA}/poupees.png ${TEMP}/feTvFlusserMomentsImageFunction.txt) otb_add_test(NAME feTvFlusserMomentsImageFunctionRotationInvariant COMMAND otbMomentsTestDriver otbFlusserMomentsImageFunctionRotationInvariant ${INPUTDATA}/poupees.png 90 ) otb_add_test(NAME feTvHuPath COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feHuPath.txt ${TEMP}/feHuPath.txt otbHuPath ${TEMP}/feHuPath.txt) otb_add_test(NAME feTvFlusserPath COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feFlusserPath.txt ${TEMP}/feFlusserPath.txt otbFlusserPath ${TEMP}/feFlusserPath.txt) otb_add_test(NAME feTvComplexMomentPath COMMAND otbMomentsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/feComplexMomentPath.txt ${TEMP}/feComplexMomentPath.txt otbComplexMomentPath 1 1 ${TEMP}/feComplexMomentPath.txt) otb_add_test(NAME feTuRadiometricMomentsImageFilterNew COMMAND otbMomentsTestDriver otbRadiometricMomentsImageFilterNew) otb_add_test(NAME feTvRadiometricMomentsImageFilter COMMAND otbMomentsTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvRadiometricMomentsImageFilter.tif ${TEMP}/feTvRadiometricMomentsImageFilter.tif otbRadiometricMomentsImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/feTvRadiometricMomentsImageFilter.tif 3 #radius ) OTB-release-5.8/Modules/Feature/Moments/test/otbComplexMomentPath.cxx000066400000000000000000000036241301006202600256640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbImageFileReader.h" #include "otbComplexMomentPathFunction.h" #include "itkMacro.h" #include "itkPolyLineParametricPath.h" int otbComplexMomentPath(int itkNotUsed(argc), char * argv[]) { unsigned int p((unsigned int) ::atoi(argv[1])); unsigned int q((unsigned int) ::atoi(argv[2])); const char * outputFilename = argv[3]; const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::ComplexMomentPathFunction CMType; typedef CMType::ComplexType ComplexType; // Draw a square PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); pathElt->Initialize(); cindex[0] = 30; cindex[1] = 30; pathElt->AddVertex(cindex); cindex[0] = 30; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 30; pathElt->AddVertex(cindex); CMType::Pointer function = CMType::New(); function->SetQ(q); function->SetP(p); ComplexType Result; std::ofstream outputStream(outputFilename); Result = function->Evaluate(*pathElt); outputStream << std::setprecision(10) << "function->Evaluate(Path)" << Result << std::endl; outputStream.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbComplexMomentPathFloat.cxx000066400000000000000000000037001301006202600266450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbImageFileReader.h" #include "otbComplexMomentPathFunction.h" #include "itkMacro.h" #include "itkPolyLineParametricPath.h" int otbComplexMomentPathFloat(int itkNotUsed(argc), char * argv[]) { unsigned int p((unsigned int) ::atoi(argv[1])); unsigned int q((unsigned int) ::atoi(argv[2])); const char * outputFilename = argv[3]; const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef std::complex ComplexType; typedef otb::ComplexMomentPathFunction CMType; // Draw a square PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); pathElt->Initialize(); cindex[0] = 30; cindex[1] = 30; pathElt->AddVertex(cindex); cindex[0] = 30; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 30; pathElt->AddVertex(cindex); CMType::Pointer function = CMType::New(); function->SetQ(q); function->SetP(p); ComplexType Result; std::ofstream outputStream(outputFilename); Result = function->Evaluate(*pathElt); outputStream << std::setprecision(10) << "function->Evaluate(Path)" << Result << std::endl; outputStream.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbComplexMomentPathNew.cxx000066400000000000000000000017631301006202600263400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbComplexMomentPathFunction.h" #include "itkPolyLineParametricPath.h" int otbComplexMomentPathNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::ComplexMomentPathFunction CMType; CMType::Pointer function = CMType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbComplexMomentsImageFunction.cxx000066400000000000000000000132221301006202600276760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbComplexMomentsImageFunction.h" #include "otbBCOInterpolateImageFunction.h" #include "otbStreamingResampleImageFilter.h" int otbComplexMomentsImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::Image ImageType; typedef otb::ComplexMomentsImageFunction FunctionType; // Instantiating object FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } int otbComplexMomentsImageFunction(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; unsigned int p((unsigned int) ::atoi(argv[2])); unsigned int q((unsigned int) ::atoi(argv[3])); const char * outputFilename = argv[4]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ComplexMomentsImageFunction CMType; typedef CMType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); CMType::Pointer function = CMType::New(); reader->SetFileName(inputFilename); reader->Update(); function->SetInputImage(reader->GetOutput()); function->SetQmax(q); function->SetPmax(p); InputImageType::IndexType index; index[0] = 100; index[1] = 100; OutputType Result; std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10); function->SetNeighborhoodRadius(3); Result = function->EvaluateAtIndex(index); for (unsigned int k=0; k<=p; ++k) { for (unsigned int l=0; l<=q; ++l) { outputStream << "ComplexMoment c(" << k << l << ") : " << Result.at(k).at(l) << std::endl; } } outputStream.close(); return EXIT_SUCCESS; } int otbComplexMomentsImageFunctionScaleInvariant(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; unsigned int p((unsigned int) ::atoi(argv[2])); unsigned int q((unsigned int) ::atoi(argv[3])); typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::ComplexMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(2); interpolator->SetAlpha(-0.5); resampler->SetInput(reader->GetOutput()); resampler->SetInterpolator(interpolator); StreamingResampleImageFilterType::SizeType size; size[0] = 1024; size[1] = 1024; resampler->SetOutputSize(size); resampler->SetOutputSpacing(0.5); resampler->Update(); function1->SetInputImage(reader->GetOutput()); function1->SetQmax(q); function1->SetPmax(p); InputImageType::IndexType index1; index1[0] = 256; index1[1] = 256; function1->SetNeighborhoodRadius(4); OutputType Result1 = function1->EvaluateAtIndex(index1); function2->SetInputImage(resampler->GetOutput()); function2->SetQmax(q); function2->SetPmax(p); InputImageType::IndexType index2; index2[0] = 512; index2[1] = 512; function2->SetNeighborhoodRadius(8); OutputType Result2 = function2->EvaluateAtIndex(index2); double error; error = 0.0; for (unsigned int k=0; k<=p; ++k) { for (unsigned int l=0; l<=q; ++l) { error += vcl_pow(vcl_abs( Result1.at(k).at(l) - Result2.at(k).at(l) ), 2); std::cout << "Original - C" << k << l << " : " << Result1.at(k).at(l) << " / Scaled - C" << k << l << " : " << Result2.at(k).at(l) << std::endl; } } error = vcl_sqrt(error)/(q+p); std::cout << "Error : " << error << std::endl << std::endl; if (error > 1E-3) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-3 -> TEST FAILLED" << std::endl ); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbFlusserMomentsImageFunction.cxx000066400000000000000000000222021301006202600277100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbFlusserMomentsImageFunction.h" #include "otbBCOInterpolateImageFunction.h" #include "otbStreamingResampleImageFilter.h" #include "itkResampleImageFilter.h" #include "itkAffineTransform.h" int otbFlusserMomentsImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::FlusserMomentsImageFunction FunctionType; // Instantiating object FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } int otbFlusserMomentsImageFunction(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::FlusserMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer function = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); function->SetInputImage(reader->GetOutput()); InputImageType::IndexType index; index[0] = 100; index[1] = 100; function->SetNeighborhoodRadius(3); OutputType Result; Result = function->EvaluateAtIndex(index); std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10) << "Flusser Image moments: [10]" << std::endl; for (unsigned int j = 1; j < 12; ++j) { outputStream << "Flusser(" << j << ") = " << Result[j-1] << std::endl; } outputStream.close(); return EXIT_SUCCESS; } int otbFlusserMomentsImageFunctionScaleInvariant(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::FlusserMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(2); interpolator->SetAlpha(-0.5); resampler->SetInput(reader->GetOutput()); resampler->SetInterpolator(interpolator); StreamingResampleImageFilterType::SizeType size; size[0] = 1024; size[1] = 1024; resampler->SetOutputSize(size); resampler->SetOutputSpacing(0.5); resampler->Update(); function1->SetInputImage(reader->GetOutput()); InputImageType::IndexType index1; index1[0] = 256; index1[1] = 256; function1->SetNeighborhoodRadius(3); OutputType Result1 = function1->EvaluateAtIndex(index1); function2->SetInputImage(resampler->GetOutput()); InputImageType::IndexType index2; index2[0] = 512; index2[1] = 512; function2->SetNeighborhoodRadius(6); OutputType Result2 = function2->EvaluateAtIndex(index2); double error = 0.0; for (unsigned int j = 1; j < 12; ++j) { error += vcl_pow(vcl_abs( Result1[j-1] - Result2[j-1]), 2); std::cout << "Original -F" << j << " : " << Result1[j-1] << " / Scaled - F" << j << " : " << Result2[j-1] << std::endl; } error = vcl_sqrt(error)/11.0; std::cout << "Error : " << error << std::endl << std::endl; if (error > 1E-3) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-3 -> TEST FAILLED" << std::endl ); } return EXIT_SUCCESS; } int otbFlusserMomentsImageFunctionRotationInvariant(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const double angleInDegrees = atoi(argv[2]); typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ResampleImageFilter< InputImageType, InputImageType > FilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::FlusserMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; typedef itk::AffineTransform< double, Dimension > TransformType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); TransformType::Pointer transform = TransformType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(2); interpolator->SetAlpha(-0.5); filter->SetInterpolator(interpolator); filter->SetDefaultPixelValue( 100 ); const InputImageType::SpacingType & spacing = reader->GetOutput()->GetSpacing(); const InputImageType::PointType & origin = reader->GetOutput()->GetOrigin(); InputImageType::SizeType size = reader->GetOutput()->GetLargestPossibleRegion().GetSize(); filter->SetOutputOrigin( origin ); filter->SetOutputSpacing( spacing ); filter->SetOutputDirection( reader->GetOutput()->GetDirection() ); filter->SetSize( size ); filter->SetInput(reader->GetOutput()); TransformType::OutputVectorType translation1; const double imageCenterX = origin[0] + spacing[0] * size[0] / 2.0; const double imageCenterY = origin[1] + spacing[1] * size[1] / 2.0; translation1[0] = -imageCenterX; translation1[1] = -imageCenterY; transform->Translate( translation1 ); const double degreesToRadians = vcl_atan(1.0) / 45.0; const double angle = angleInDegrees * degreesToRadians; transform->Rotate2D( -angle, false ); TransformType::OutputVectorType translation2; translation2[0] = imageCenterX; translation2[1] = imageCenterY; transform->Translate( translation2, false ); filter->SetTransform( transform ); filter->Update(); function1->SetInputImage(reader->GetOutput()); InputImageType::IndexType index1; index1[0] = 256; index1[1] = 256; function1->SetNeighborhoodRadius(4); OutputType Result1 = function1->EvaluateAtIndex(index1); function2->SetInputImage(filter->GetOutput()); InputImageType::IndexType index2; index2[0] = 256; index2[1] = 256; function2->SetNeighborhoodRadius(4); OutputType Result2 = function2->EvaluateAtIndex(index2); double error = 0.0; for (unsigned int j = 1; j < 12; ++j) { error += vcl_pow(vcl_abs( Result1[j-1] - Result2[j-1]), 2); std::cout << "Original -F" << j << " : " << Result1[j-1] << " / Rotated - F" << j << " : " << Result2[j-1] << std::endl; } error = vcl_sqrt(error)/11.0; std::cout << "Error : " << error << std::endl << std::endl; if (error > 1E-3) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-3 -> TEST FAILLED" << std::endl ); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbFlusserPath.cxx000066400000000000000000000037511301006202600245210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbFlusserPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" int otbFlusserPath(int itkNotUsed(argc), char * argv[]) { unsigned int Number; const unsigned int Dimension = 2; const char * outputFilename = argv[1]; typedef itk::PolyLineParametricPath PathType; typedef otb::FlusserPathFunction FunctionType; typedef FunctionType::RealType RealType; // Draw a square PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); pathElt->Initialize(); cindex[0] = 30; cindex[1] = 30; pathElt->AddVertex(cindex); cindex[0] = 30; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 30; pathElt->AddVertex(cindex); FunctionType::Pointer function = FunctionType::New(); //OTB-FA-00022-CS function->SetInputPath(pathElt); std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10) << "Flusser Path moments: [12]" << std::endl; RealType Result; for (Number = 1; Number < 12; Number++) { //OTB-FA-00024-CS function->SetMomentNumber(Number); Result = function->Evaluate(); outputStream << "Flusser(" << Number << ") = " << Result << std::endl; } outputStream.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbFlusserPathNew.cxx000066400000000000000000000017641301006202600251750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFlusserPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" int otbFlusserPathNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::FlusserPathFunction FunctionType; FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbHuMomentsImageFunction.cxx000066400000000000000000000220631301006202600266460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbHuMomentsImageFunction.h" #include "otbBCOInterpolateImageFunction.h" #include "otbStreamingResampleImageFilter.h" #include "itkResampleImageFilter.h" #include "itkAffineTransform.h" int otbHuMomentsImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::HuMomentsImageFunction FunctionType; // Instantiating object FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } int otbHuMomentsImageFunction(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::HuMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer function = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); function->SetInputImage(reader->GetOutput()); InputImageType::IndexType index; index[0] = 100; index[1] = 100; function->SetNeighborhoodRadius(3); OutputType Result; Result = function->EvaluateAtIndex(index); std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10) << "Hu Image moments: [10]" << std::endl; for (unsigned int j = 1; j < 8; ++j) { outputStream << "Hu(" << j << ") = " << Result[j-1] << std::endl; } outputStream.close(); return EXIT_SUCCESS; } int otbHuMomentsImageFunctionScaleInvariant(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::HuMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(2); interpolator->SetAlpha(-0.5); resampler->SetInput(reader->GetOutput()); resampler->SetInterpolator(interpolator); StreamingResampleImageFilterType::SizeType size; size[0] = 1024; size[1] = 1024; resampler->SetOutputSize(size); resampler->SetOutputSpacing(0.5); resampler->Update(); function1->SetInputImage(reader->GetOutput()); InputImageType::IndexType index1; index1[0] = 100; index1[1] = 100; function1->SetNeighborhoodRadius(2); OutputType Result1 = function1->EvaluateAtIndex(index1); function2->SetInputImage(resampler->GetOutput()); InputImageType::IndexType index2; index2[0] = 200; index2[1] = 200; function2->SetNeighborhoodRadius(4); OutputType Result2 = function2->EvaluateAtIndex(index2); double error = 0.0; for (unsigned int j = 1; j < 8; ++j) { error += vcl_pow(vcl_abs( Result1[j-1] - Result2[j-1]), 2); std::cout << "Original -H" << j << " : " << Result1[j-1] << " / Scaled - H" << j << " : " << Result2[j-1] << std::endl; } error = vcl_sqrt(error)/7.0; std::cout << "Error : " << error << std::endl << std::endl; if (error > 1E-3) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-3 -> TEST FAILLED" << std::endl ); } return EXIT_SUCCESS; } int otbHuMomentsImageFunctionRotationInvariant(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const double angleInDegrees = atoi(argv[2]); typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ResampleImageFilter< InputImageType, InputImageType > FilterType; typedef otb::BCOInterpolateImageFunction InterpolatorType; typedef otb::HuMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; typedef itk::AffineTransform< double, Dimension > TransformType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); TransformType::Pointer transform = TransformType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); FunctionType::Pointer function1 = FunctionType::New(); FunctionType::Pointer function2 = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); interpolator->SetInputImage(reader->GetOutput()); interpolator->SetRadius(2); interpolator->SetAlpha(-0.5); filter->SetInterpolator(interpolator); filter->SetDefaultPixelValue( 100 ); const InputImageType::SpacingType & spacing = reader->GetOutput()->GetSpacing(); const InputImageType::PointType & origin = reader->GetOutput()->GetOrigin(); InputImageType::SizeType size = reader->GetOutput()->GetLargestPossibleRegion().GetSize(); filter->SetOutputOrigin( origin ); filter->SetOutputSpacing( spacing ); filter->SetOutputDirection( reader->GetOutput()->GetDirection() ); filter->SetSize( size ); filter->SetInput(reader->GetOutput()); TransformType::OutputVectorType translation1; const double imageCenterX = origin[0] + spacing[0] * size[0] / 2.0; const double imageCenterY = origin[1] + spacing[1] * size[1] / 2.0; translation1[0] = -imageCenterX; translation1[1] = -imageCenterY; transform->Translate( translation1 ); const double degreesToRadians = vcl_atan(1.0) / 45.0; const double angle = angleInDegrees * degreesToRadians; transform->Rotate2D( -angle, false ); TransformType::OutputVectorType translation2; translation2[0] = imageCenterX; translation2[1] = imageCenterY; transform->Translate( translation2, false ); filter->SetTransform( transform ); filter->Update(); function1->SetInputImage(reader->GetOutput()); InputImageType::IndexType index1; index1[0] = 256; index1[1] = 256; function1->SetNeighborhoodRadius(4); OutputType Result1 = function1->EvaluateAtIndex(index1); function2->SetInputImage(filter->GetOutput()); InputImageType::IndexType index2; index2[0] = 256; index2[1] = 256; function2->SetNeighborhoodRadius(4); OutputType Result2 = function2->EvaluateAtIndex(index2); double error = 0.0; for (unsigned int j = 1; j < 8; ++j) { error += vcl_pow(vcl_abs( Result1[j-1] - Result2[j-1]), 2); std::cout << "Original -H" << j << " : " << Result1[j-1] << " / Rotated - H" << j << " : " << Result2[j-1] << std::endl; } error = vcl_sqrt(error)/7.0; std::cout << "Error : " << error << std::endl << std::endl; if (error > 1E-3) { itkGenericExceptionMacro( << "Error = " << error << " > 1E-3 -> TEST FAILLED" << std::endl ); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbHuPath.cxx000066400000000000000000000037031301006202600234470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbHuPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" int otbHuPath(int itkNotUsed(argc), char * argv[]) { unsigned int Number; const unsigned int Dimension = 2; const char * outputFilename = argv[1]; typedef itk::PolyLineParametricPath PathType; typedef otb::HuPathFunction FunctionType; typedef FunctionType::RealType RealType; // Dessiner un carre: PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); pathElt->Initialize(); cindex[0] = 30; cindex[1] = 30; pathElt->AddVertex(cindex); cindex[0] = 30; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 130; pathElt->AddVertex(cindex); cindex[0] = 130; cindex[1] = 30; pathElt->AddVertex(cindex); FunctionType::Pointer function = FunctionType::New(); RealType Result; function->SetInputPath(pathElt); std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10) << "Hu Path moments: [8]" << std::endl; for (Number = 1; Number < 8; Number++) { //OTB-FA-00024-CS function->SetMomentNumber(Number); Result = function->Evaluate(); outputStream << "Hu(" << Number << ") = " << Result << std::endl; } outputStream.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbHuPathNew.cxx000066400000000000000000000017521301006202600241230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbHuPathFunction.h" #include "itkPolyLineParametricPath.h" int otbHuPathNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::HuPathFunction FunctionType; FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbMomentsTestDriver.cxx000066400000000000000000000023001301006202600257040ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbComplexMomentPathFloat); REGISTER_TEST(otbRadiometricMomentsImageFunctionNew); REGISTER_TEST(otbRadiometricMomentsImageFunction); REGISTER_TEST(otbComplexMomentPathNew); REGISTER_TEST(otbHuMomentsImageFunctionNew); REGISTER_TEST(otbHuMomentsImageFunction); REGISTER_TEST(otbHuMomentsImageFunctionScaleInvariant); REGISTER_TEST(otbHuMomentsImageFunctionRotationInvariant); REGISTER_TEST(otbRealMomentsImageFunctionNew); REGISTER_TEST(otbRealMomentsImageFunction); REGISTER_TEST(otbComplexMomentsImageFunction); REGISTER_TEST(otbComplexMomentsImageFunctionScaleInvariant); REGISTER_TEST(otbHuPathNew); REGISTER_TEST(otbFlusserPathNew); REGISTER_TEST(otbFlusserMomentsImageFunctionNew); REGISTER_TEST(otbFlusserMomentsImageFunction); REGISTER_TEST(otbFlusserMomentsImageFunctionScaleInvariant); REGISTER_TEST(otbFlusserMomentsImageFunctionRotationInvariant); REGISTER_TEST(otbHuPath); REGISTER_TEST(otbFlusserPath); REGISTER_TEST(otbComplexMomentPath); REGISTER_TEST(otbRadiometricMomentsImageFilterNew); REGISTER_TEST(otbRadiometricMomentsImageFilter); REGISTER_TEST(otbComplexMomentsImageFunctionNew); } OTB-release-5.8/Modules/Feature/Moments/test/otbRadiometricMomentsImageFilter.cxx000066400000000000000000000042361301006202600301760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbRadiometricMomentsImageFilter.h" int otbRadiometricMomentsImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float InputPixelType; const unsigned int Dimension = 2; /** Typedefs */ typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::RadiometricMomentsImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbRadiometricMomentsImageFilter(int itkNotUsed(argc), char * argv[]) { typedef float InputPixelType; const unsigned int Dimension = 2; // Typedefs typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileWriter WriterType; typedef otb::RadiometricMomentsImageFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); reader->GenerateOutputInformation(); filter->SetInput(reader->GetOutput()); filter->SetRadius(atoi(argv[3])); filter->SetNumberOfThreads(1); writer->SetFileName(argv[2]); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbRadiometricMomentsImageFunction.cxx000066400000000000000000000047261301006202600305420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbRadiometricMomentsImageFunction.h" int otbRadiometricMomentsImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::RadiometricMomentsImageFunction FunctionType; // Instantiating object FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } int otbRadiometricMomentsImageFunction(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::RadiometricMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer function = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); function->SetInputImage(reader->GetOutput()); InputImageType::IndexType index; index[0] = 100; index[1] = 100; function->SetNeighborhoodRadius(3); OutputType Result; Result = function->EvaluateAtIndex(index); std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10) << "Radiometric moments: [10]" << std::endl; for (unsigned int j = 1; j < 5; ++j) { outputStream << "Radiometric Moment(" << j << ") = " << Result[j-1] << std::endl; } outputStream.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Moments/test/otbRealMomentsImageFunction.cxx000066400000000000000000000051241301006202600271540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbRealMomentsImageFunction.h" int otbRealMomentsImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::RealMomentsImageFunction FunctionType; // Instantiating object FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } int otbRealMomentsImageFunction(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; unsigned int p((unsigned int) ::atoi(argv[2])); unsigned int q((unsigned int) ::atoi(argv[3])); const char * outputFilename = argv[4]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::RealMomentsImageFunction FunctionType; typedef FunctionType::OutputType OutputType; ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer function = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); function->SetInputImage(reader->GetOutput()); function->SetQmax(q); function->SetPmax(p); InputImageType::IndexType index; index[0] = 100; index[1] = 100; OutputType Result; std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10) << "Central Image moments: [10]" << std::endl; function->SetNeighborhoodRadius(3); Result = function->EvaluateAtIndex(index); for (unsigned int k=0; k<=p; ++k) { for (unsigned int l=0; l<=q; ++l) { outputStream << "RealMoment c(" << k << l << ") : " << Result.at(k).at(l) << std::endl; } } outputStream.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/SeamCarving/000077500000000000000000000000001301006202600206205ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/SeamCarving/CMakeLists.txt000066400000000000000000000000521301006202600233550ustar00rootroot00000000000000project(OTBSeamCarving) otb_module_impl() OTB-release-5.8/Modules/Feature/SeamCarving/include/000077500000000000000000000000001301006202600222435ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/SeamCarving/include/otbAddCarvingPathFilter.h000066400000000000000000000123311301006202600271060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAddCarvingPathFilter_h #define otbAddCarvingPathFilter_h #include "itkImageAndPathToImageFilter.h" #include "itkImageSliceIteratorWithIndex.h" namespace otb { /** \class AddCarvingPathFilter * \brief This class add pixels given in one path * * This filter add pixels found by the otb::ImageToCarvingPathFilter * thus increasing the image size. * the image (if Direction is set to 0) or from left to right * (if direction is set to 1). Pixel value is computed as the average * between the neighborhood pixels. * * This is one component necessary to apply the seam carving algorithm * published by Shai Avidan, Ariel Shamir, * Seam Carving for Content-Aware Image Resizing, * ACM Transactions on Graphics, Volume 26, Number 3, * SIGGRAPH 2007 * * \par INPUTS * The first input is an image, usually, the same one provided to the * otb::ImageToCarvingPathFilter * The second input is a path, typically the output of otb::ImageToCarvingPathFilter. * * \par OUTPUTS * The output is an image with a bigger size than the input image. There is one more * column if direction is 0 and one more line if direction is 1. * * \sa ImageToCarvingPathFilter * * * \ingroup PathFilters * \ingroup ImageFilters * * \ingroup OTBSeamCarving */ template class ITK_EXPORT AddCarvingPathFilter : public itk::ImageAndPathToImageFilter { public: /** Standard class typedefs. */ typedef AddCarvingPathFilter Self; typedef itk::ImageAndPathToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(AddCarvingPathFilter, itk::ImageAndPathToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TInputPath InputPathType; typedef typename InputPathType::Pointer InputPathPointer; typedef typename InputPathType::ConstPointer InputPathConstPointer; typedef typename InputPathType::InputType InputPathInputType; typedef typename InputPathType::OutputType InputPathOutputType; typedef typename InputPathType::IndexType InputPathIndexType; typedef typename InputPathType::OffsetType InputPathOffsetType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::ValueType OutputImageValueType; // typedef typename itk::ImageRegionConstIterator InputIteratorType; // typedef typename itk::ImageRegionIterator OutputIteratorType; typedef typename itk::ImageSliceConstIteratorWithIndex InputIteratorType; typedef typename itk::ImageSliceIteratorWithIndex OutputIteratorType; /** Set/Get the path input of this process object. Note: these methods are adding to get the proper name */ void SetInputPath(const TInputPath * path); const TInputPath * GetInputPath(void); itkSetMacro(Value, OutputImagePixelType); itkGetConstReferenceMacro(Value, OutputImagePixelType); /** Set and Get direction value */ itkSetMacro(Direction, unsigned int); itkGetConstMacro(Direction, unsigned int); void GenerateOutputInformation() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; protected: AddCarvingPathFilter(); ~AddCarvingPathFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: AddCarvingPathFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputImagePixelType m_Value; unsigned int m_Direction; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAddCarvingPathFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/SeamCarving/include/otbAddCarvingPathFilter.txx000066400000000000000000000176541301006202600275170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAddCarvingPathFilter_txx #define otbAddCarvingPathFilter_txx #include "otbAddCarvingPathFilter.h" #include "itkMacro.h" namespace otb { /** * Constructor */ template AddCarvingPathFilter ::AddCarvingPathFilter() { m_Value = static_cast(255.0); m_Direction = 0; } /** * Main computation method. */ template inline void AddCarvingPathFilter ::SetInputPath(const TInputPath * path) { this->SetPathInput(path); } template const TInputPath * AddCarvingPathFilter ::GetInputPath(void) { return this->GetPathInput(); } template void AddCarvingPathFilter ::GenerateData(void) { const InputImageType * inputImage = this->GetImageInput(); const InputPathType * inputPath = this->GetPathInput(); OutputImageType * outputImage = this->GetOutput(); outputImage->SetBufferedRegion(outputImage->GetRequestedRegion()); outputImage->Allocate(); InputIteratorType inputIterator(inputImage, inputImage->GetLargestPossibleRegion()); OutputIteratorType outputIterator(outputImage, outputImage->GetLargestPossibleRegion()); unsigned int dir0; unsigned int dir1; if (m_Direction == 0) { dir0 = 0; dir1 = 1; } else { dir0 = 1; dir1 = 0; } inputIterator.SetFirstDirection(dir0); inputIterator.SetSecondDirection(dir1); inputIterator.GoToBegin(); outputIterator.SetFirstDirection(dir0); outputIterator.SetSecondDirection(dir1); outputIterator.GoToBegin(); int line = -1; typename InputImageType::IndexType index; typename InputPathType::VertexListType::ConstPointer vertexList = inputPath->GetVertexList(); typename InputPathType::VertexListType::ConstIterator pathIterator; typename InputImageType::IndexType indexToAdd; typedef typename InputImageType::IndexType::IndexValueType IndexValueType; typename InputImageType::SizeType inputSize; inputSize = inputImage->GetLargestPossibleRegion().GetSize(); //go to the end of the path pathIterator = vertexList->Begin(); while (pathIterator != vertexList->End()) { ++pathIterator; } --pathIterator; while (!outputIterator.IsAtEnd()) { while (!outputIterator.IsAtEndOfSlice()) { bool flag = false; while (!outputIterator.IsAtEndOfLine()) { index = outputIterator.GetIndex(); if (index[dir1] != line) { line = index[dir1]; typename InputImageType::PointType tmpIndex; inputImage->TransformContinuousIndexToPhysicalPoint(pathIterator.Value(), tmpIndex); inputImage->TransformPhysicalPointToIndex(tmpIndex, indexToAdd); if (pathIterator != vertexList->Begin()) { --pathIterator; } if (index[dir1] != indexToAdd[dir1]) { itkExceptionMacro(<< "Error : " << index[dir1] << " , " << indexToAdd[dir1]); } } if ((flag == true) || ((index[dir0] != indexToAdd[dir0]) && (index[dir0] < static_cast(inputSize[dir0])))) { outputIterator.Set(inputIterator.Get()); ++inputIterator; } else { flag = true; OutputImagePixelType newValue = itk::NumericTraits::Zero; int n = 0; InputIteratorType tmpIterator = inputIterator; --tmpIterator; if (!tmpIterator.IsAtReverseEndOfLine()) { newValue = tmpIterator.Get(); ++n; } tmpIterator = inputIterator; ++tmpIterator; if (!tmpIterator.IsAtEndOfLine()) { newValue += tmpIterator.Get(); ++n; } assert(n != 0); newValue /= n; outputIterator.Set(newValue); } ++outputIterator; } if ((outputIterator.GetIndex())[dir0] != (inputIterator.GetIndex())[dir0] + 1) { itkExceptionMacro(<< "Error 2: " << (outputIterator.GetIndex())[dir0] << " , " << (inputIterator.GetIndex())[dir0]); } inputIterator.NextLine(); outputIterator.NextLine(); } inputIterator.NextSlice(); outputIterator.NextSlice(); } } /** * Printself Method */ template void AddCarvingPathFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Path Value: " << m_Value << std::endl; } template void AddCarvingPathFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointers to the input and output typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); unsigned int dir0; //unsigned int dir1; if (m_Direction == 0) { dir0 = 0; //dir1 = 1; } else { dir0 = 1; //dir1 = 0; } // we need to compute the output spacing, the output image size, and the // output image start index const typename TInputImage::SpacingType& inputSpacing = inputPtr->GetSpacing(); const typename TInputImage::SizeType& inputSize = inputPtr->GetLargestPossibleRegion().GetSize(); const typename TInputImage::IndexType& inputStartIndex = inputPtr->GetLargestPossibleRegion().GetIndex(); typename TOutputImage::SpacingType outputSpacing; typename TOutputImage::SizeType outputSize; typename TOutputImage::IndexType outputStartIndex; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { outputSpacing[i] = inputSpacing[i]; outputSize[i] = (unsigned int) (inputSize[i]); outputStartIndex[i] = inputStartIndex[i]; } // we remove one column of the image outputSize[dir0] = inputSize[dir0] + 1; outputPtr->SetSpacing(outputSpacing); typename TOutputImage::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(outputSize); outputLargestPossibleRegion.SetIndex(outputStartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); } template void AddCarvingPathFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output InputImagePointer inputPtr = const_cast(this->GetInput()); if (!inputPtr) { itkExceptionMacro(<< "Input has not been set."); } inputPtr->SetRequestedRegion(inputPtr->GetLargestPossibleRegion()); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/SeamCarving/include/otbImageToCarvingPathFilter.h000066400000000000000000000067141301006202600277530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToCarvingPathFilter_h #define otbImageToCarvingPathFilter_h #include "otbImageToPathFilter.h" #include "itkImageSliceConstIteratorWithIndex.h" namespace otb { /** * \class ImageToCarvingPathFilter * \brief This filter find the minimum energy path of an image. * * This filter find the minimum energy path from top to bottom of * the image (if Direction is set to 0) or from left to right * (if direction is set to 1). * * This is one component necessary to apply the seam carving algorithm * published by Shai Avidan, Ariel Shamir, * Seam Carving for Content-Aware Image Resizing, * ACM Transactions on Graphics, Volume 26, Number 3, * SIGGRAPH 2007 * * \par INPUTS * The input is an image, typically the output of a gradient filter. * * \par OUTPUTS * The output is * a polyline parametric path comprising one and only one pixel per line * (resp. column) if direction is 0 (resp. 1). * * \sa RemoveCarvingPathFilter * * \ingroup PathFilters * \ingroup ImageFilters * * \ingroup OTBSeamCarving */ template class ITK_EXPORT ImageToCarvingPathFilter : public ImageToPathFilter { public: /** standards typedefs */ typedef ImageToCarvingPathFilter Self; typedef ImageToPathFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /// Creation through the object factory itkNewMacro(Self); /// Runtime information itkTypeMacro(ImageToCarvingPathFilter, ImageToPathFilter); /// Template parameters typedef typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointerType InputImagePointerType; typedef typename Superclass::OutputPathType OutputPathType; typedef typename Superclass::OutputPathPointerType OutputPathPointerType; typedef typename InputImageType::PixelType PixelType; /** Set and Get foreground value */ itkSetMacro(ForegroundValue, PixelType); itkGetConstMacro(ForegroundValue, PixelType); /** Set and Get direction value */ itkSetMacro(Direction, unsigned int); itkGetConstMacro(Direction, unsigned int); /** Get EnergyPerPix value */ itkGetConstMacro(EnergyPerPix, double); protected: ImageToCarvingPathFilter(); ~ImageToCarvingPathFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE {} //does nothing void GenerateData() ITK_OVERRIDE; private: ImageToCarvingPathFilter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented PixelType m_ForegroundValue; unsigned int m_Direction; double m_EnergyPerPix; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToCarvingPathFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/SeamCarving/include/otbImageToCarvingPathFilter.txx000066400000000000000000000151151301006202600303420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToCarvingPathFilter_txx #define otbImageToCarvingPathFilter_txx #include "otbImageToCarvingPathFilter.h" #include "otbMacro.h" #include "itkConstantPadImageFilter.h" #include "itkConstShapedNeighborhoodIterator.h" #include "itkImageRegionConstIterator.h" #include "itkNumericTraits.h" #include "itkImageLinearConstIteratorWithIndex.h" namespace otb { /* * Constructor. */ template ImageToCarvingPathFilter ::ImageToCarvingPathFilter() { m_ForegroundValue = PixelType(255); m_Direction = 0; m_EnergyPerPix = 0.0; } /** * Main computation method. */ template void ImageToCarvingPathFilter ::GenerateData(void) { const InputImageType * inputImage = this->GetInput(); OutputPathType * outputPath = this->GetOutput(); typedef itk::ImageSliceConstIteratorWithIndex IteratorType; typedef itk::NeighborhoodIterator NeighborhoodIteratorType; IteratorType it(inputImage, inputImage->GetLargestPossibleRegion()); it.GoToBegin(); PixelType maxValue = itk::NumericTraits::max(); typename InputImageType::Pointer energyImage = InputImageType::New(); energyImage->SetRegions(inputImage->GetLargestPossibleRegion()); energyImage->Allocate(); typename NeighborhoodIteratorType::RadiusType radius; radius.Fill(1); NeighborhoodIteratorType neighIt(radius, energyImage, energyImage->GetLargestPossibleRegion()); neighIt.GoToBegin(); unsigned int dir0; unsigned int dir1; typename IteratorType::OffsetType UP0; typename IteratorType::OffsetType UP1; typename IteratorType::OffsetType UP2; typename IteratorType::OffsetType NEXT; const typename IteratorType::OffsetType LEFT = {{-1, 0}}; const typename IteratorType::OffsetType RIGHT = {{1, 0}}; const typename IteratorType::OffsetType UP = {{0, -1}}; const typename IteratorType::OffsetType DOWN = {{0, 1}}; const typename IteratorType::OffsetType LEFTUP = {{-1, -1}}; // const typename IteratorType::OffsetType RIGHTDOWN ={{1, 1}}; const typename IteratorType::OffsetType RIGHTUP = {{1, -1}}; const typename IteratorType::OffsetType LEFTDOWN = {{-1, 1}}; // const typename IteratorType::OffsetType CENTER ={{0, 0}}; if (m_Direction == 0) { dir0 = 0; dir1 = 1; UP0 = LEFTUP; UP1 = UP; UP2 = RIGHTUP; NEXT = DOWN; } else { dir0 = 1; dir1 = 0; UP0 = LEFTUP; UP1 = LEFT; UP2 = LEFTDOWN; NEXT = RIGHT; } /** Compute the energy image top-down or left-right * with cumulative energy (dynamic programming first step) */ it.SetFirstDirection(dir0); it.SetSecondDirection(dir1); it.GoToBegin(); neighIt.GoToBegin(); while (!it.IsAtEnd()) { while (!it.IsAtEndOfSlice()) { while (!it.IsAtEndOfLine()) { neighIt.SetLocation(it.GetIndex()); //TODO bad for performances... find a better option // this is really about 20% of total processing time !!! PixelType min = maxValue; bool isInside = false; bool flag = false; if (neighIt.GetPixel(UP0, isInside) < min) { if (isInside) { min = neighIt.GetPixel(UP0); flag = true; } } if (neighIt.GetPixel(UP1, isInside) < min) { if (isInside) { min = neighIt.GetPixel(UP1); flag = true; } } if (neighIt.GetPixel(UP2, isInside) < min) { if (isInside) { min = neighIt.GetPixel(UP2); flag = true; } } if (!flag) //no previous value { min = 0; } PixelType newValue = it.Get() + min; neighIt.SetCenterPixel(newValue); ++it; } it.NextLine(); } it.NextSlice(); } /** Follow the minima bottom-up or right-left * (dynamic programming second step) */ //find the starting point to follow on the last line typedef itk::ImageLinearConstIteratorWithIndex LinearIteratorType; LinearIteratorType LinIt(energyImage, energyImage->GetLargestPossibleRegion()); LinIt.SetDirection(dir0); LinIt.GoToReverseBegin(); typedef typename InputImageType::IndexType IndexType; PixelType min = maxValue; IndexType indexToAdd; while (!LinIt.IsAtReverseEndOfLine()) { if (LinIt.Get() < min) { min = LinIt.Get(); indexToAdd = LinIt.GetIndex(); } --LinIt; } outputPath->AddVertex(indexToAdd); m_EnergyPerPix = ((double) min) / (inputImage->GetLargestPossibleRegion().GetSize())[dir1]; //follow the min neighIt.SetLocation(indexToAdd); bool flag = true; while (flag) { flag = false; PixelType minValue = maxValue; IndexType indexToAdd2; bool isInside = false; if (neighIt.GetPixel(UP0, isInside) < min) { if (isInside) { minValue = neighIt.GetPixel(UP0); indexToAdd2 = neighIt.GetIndex(UP0); flag = true; } } if (neighIt.GetPixel(UP1, isInside) < minValue) { if (isInside) { minValue = neighIt.GetPixel(UP1); indexToAdd2 = neighIt.GetIndex(UP1); flag = true; } } if (neighIt.GetPixel(UP2, isInside) < minValue) { if (isInside) { minValue = neighIt.GetPixel(UP2); indexToAdd2 = neighIt.GetIndex(UP2); flag = true; } } if (flag) { outputPath->AddVertex(indexToAdd2); neighIt.SetLocation(indexToAdd2); } } } template void ImageToCarvingPathFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << "Foreground value : " << m_ForegroundValue << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/SeamCarving/include/otbRemoveCarvingPathFilter.h000066400000000000000000000122041301006202600276520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRemoveCarvingPathFilter_h #define otbRemoveCarvingPathFilter_h #include "itkImageAndPathToImageFilter.h" #include "itkImageSliceIteratorWithIndex.h" namespace otb { /** \class RemoveCarvingPathFilter * \brief This class remove pixels given in one path * * * * This filter remove pixels found by the otb::ImageToCarvingPathFilter * thus decreasing the image size. * the image (if Direction is set to 0) or from left to right * (if direction is set to 1). * * This is one component necessary to apply the seam carving algorithm * published by Shai Avidan, Ariel Shamir, * Seam Carving for Content-Aware Image Resizing, * ACM Transactions on Graphics, Volume 26, Number 3, * SIGGRAPH 2007 * * \par INPUTS * The first input is an image, usually, the same one provided to the * otb::ImageToCarvingPathFilter * The second input is a path, typically the output of otb::ImageToCarvingPathFilter. * * \par OUTPUTS * The output is an image with a smaller size than the input image. There is one less * column if direction is 0 and one less line if direction is 1. * * \sa ImageToCarvingPathFilter * * * \ingroup PathFilters * \ingroup ImageFilters * * \ingroup OTBSeamCarving */ template class ITK_EXPORT RemoveCarvingPathFilter : public itk::ImageAndPathToImageFilter { public: /** Standard class typedefs. */ typedef RemoveCarvingPathFilter Self; typedef itk::ImageAndPathToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RemoveCarvingPathFilter, itk::ImageAndPathToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TInputPath InputPathType; typedef typename InputPathType::Pointer InputPathPointer; typedef typename InputPathType::ConstPointer InputPathConstPointer; typedef typename InputPathType::InputType InputPathInputType; typedef typename InputPathType::OutputType InputPathOutputType; typedef typename InputPathType::IndexType InputPathIndexType; typedef typename InputPathType::OffsetType InputPathOffsetType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::ValueType OutputImageValueType; // typedef typename itk::ImageRegionConstIterator InputIteratorType; // typedef typename itk::ImageRegionIterator OutputIteratorType; typedef typename itk::ImageSliceConstIteratorWithIndex InputIteratorType; typedef typename itk::ImageSliceIteratorWithIndex OutputIteratorType; /** Set/Get the path input of this process object. Note: these methods are adding to get the proper name */ void SetInputPath(const TInputPath * path); const TInputPath * GetInputPath(void); itkSetMacro(Value, OutputImagePixelType); itkGetConstReferenceMacro(Value, OutputImagePixelType); /** Set and Get direction value */ itkSetMacro(Direction, unsigned int); itkGetConstMacro(Direction, unsigned int); void GenerateOutputInformation() ITK_OVERRIDE; protected: RemoveCarvingPathFilter(); ~RemoveCarvingPathFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: RemoveCarvingPathFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputImagePixelType m_Value; unsigned int m_Direction; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRemoveCarvingPathFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/SeamCarving/include/otbRemoveCarvingPathFilter.txx000066400000000000000000000141741301006202600302560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRemoveCarvingPathFilter_txx #define otbRemoveCarvingPathFilter_txx #include "otbRemoveCarvingPathFilter.h" #include "itkMacro.h" namespace otb { /** * Constructor */ template RemoveCarvingPathFilter ::RemoveCarvingPathFilter() { m_Value = static_cast(255.0); m_Direction = 0; } template inline void RemoveCarvingPathFilter ::SetInputPath(const TInputPath * path) { this->SetPathInput(path); } template const TInputPath * RemoveCarvingPathFilter ::GetInputPath(void) { return this->GetPathInput(); } /** * Main computation method. */ template void RemoveCarvingPathFilter ::GenerateData(void) { const InputImageType * inputImage = this->GetImageInput(); const InputPathType * inputPath = this->GetPathInput(); OutputImageType * outputImage = this->GetOutput(); outputImage->SetBufferedRegion(outputImage->GetRequestedRegion()); outputImage->Allocate(); InputIteratorType inputIterator(inputImage, inputImage->GetLargestPossibleRegion()); OutputIteratorType outputIterator(outputImage, outputImage->GetLargestPossibleRegion()); unsigned int dir0; unsigned int dir1; if (m_Direction == 0) { dir0 = 0; dir1 = 1; } else { dir0 = 1; dir1 = 0; } inputIterator.SetFirstDirection(dir0); inputIterator.SetSecondDirection(dir1); inputIterator.GoToBegin(); outputIterator.SetFirstDirection(dir0); outputIterator.SetSecondDirection(dir1); outputIterator.GoToBegin(); int line = -1; typename InputImageType::IndexType index; typename InputPathType::VertexListType::ConstPointer vertexList = inputPath->GetVertexList(); typename InputPathType::VertexListType::ConstIterator pathIterator; typename InputImageType::IndexType indexToRemove; //go to the end of the path pathIterator = vertexList->Begin(); while (pathIterator != vertexList->End()) { ++pathIterator; } --pathIterator; while (!inputIterator.IsAtEnd()) { while (!inputIterator.IsAtEndOfSlice()) { while (!inputIterator.IsAtEndOfLine()) { index = inputIterator.GetIndex(); if (index[dir1] != line) { line = index[dir1]; typename InputImageType::PointType tmpIndex; inputImage->TransformContinuousIndexToPhysicalPoint(pathIterator.Value(), tmpIndex); inputImage->TransformPhysicalPointToIndex(tmpIndex, indexToRemove); if (pathIterator != vertexList->Begin()) { --pathIterator; } if (index[dir1] != indexToRemove[dir1]) { itkExceptionMacro(<< "Error!!!"); } } if (index[dir0] != indexToRemove[dir0]) { outputIterator.Set(inputIterator.Get()); ++outputIterator; } ++inputIterator; } inputIterator.NextLine(); outputIterator.NextLine(); } inputIterator.NextSlice(); outputIterator.NextSlice(); } } /** * Printself Method */ template void RemoveCarvingPathFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Path Value: " << m_Value << std::endl; } template void RemoveCarvingPathFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointers to the input and output typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); unsigned int dir0; //unsigned int dir1; if (m_Direction == 0) { dir0 = 0; //dir1 = 1; } else { dir0 = 1; //dir1 = 0; } // we need to compute the output spacing, the output image size, and the // output image start index const typename TInputImage::SpacingType& inputSpacing = inputPtr->GetSpacing(); const typename TInputImage::SizeType& inputSize = inputPtr->GetLargestPossibleRegion().GetSize(); const typename TInputImage::IndexType& inputStartIndex = inputPtr->GetLargestPossibleRegion().GetIndex(); typename TOutputImage::SpacingType outputSpacing; typename TOutputImage::SizeType outputSize; typename TOutputImage::IndexType outputStartIndex; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { outputSpacing[i] = inputSpacing[i]; outputSize[i] = (unsigned int) (inputSize[i]); outputStartIndex[i] = inputStartIndex[i]; } // we remove one column of the image outputSize[dir0] = inputSize[dir0] - 1; outputPtr->SetSpacing(outputSpacing); typename TOutputImage::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(outputSize); outputLargestPossibleRegion.SetIndex(outputStartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/SeamCarving/otb-module.cmake000066400000000000000000000006341301006202600236740ustar00rootroot00000000000000set(DOCUMENTATION "This module contains necessary components to apply the seam carving algorithm published by Shai Avidan, Ariel Shamir, Seam Carving for Content-Aware Resizing, ACM Transactions on Graphics, Volume 26, Number 3, SIGGRAPH 2007.") otb_module(OTBSeamCarving DEPENDS OTBPath OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Feature/SeamCarving/test/000077500000000000000000000000001301006202600215775ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/SeamCarving/test/CMakeLists.txt000066400000000000000000000013371301006202600243430ustar00rootroot00000000000000otb_module_test() set(OTBSeamCarvingTests otbSeamCarvingTestDriver.cxx otbRemoveCarvingPathFilterNew.cxx otbImageToCarvingPathFilterNew.cxx otbAddCarvingPathFilterNew.cxx ) add_executable(otbSeamCarvingTestDriver ${OTBSeamCarvingTests}) target_link_libraries(otbSeamCarvingTestDriver ${OTBSeamCarving-Test_LIBRARIES}) otb_module_target_label(otbSeamCarvingTestDriver) # Tests Declaration otb_add_test(NAME feTuRemoveCarvingPathFilterNew COMMAND otbSeamCarvingTestDriver otbRemoveCarvingPathFilterNew) otb_add_test(NAME feTuImageToCarvingPathFilterNew COMMAND otbSeamCarvingTestDriver otbImageToCarvingPathFilterNew) otb_add_test(NAME feTuAddCarvingPathFilterNew COMMAND otbSeamCarvingTestDriver otbAddCarvingPathFilterNew) OTB-release-5.8/Modules/Feature/SeamCarving/test/otbAddCarvingPathFilterNew.cxx000066400000000000000000000023451301006202600274730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbAddCarvingPathFilter.h" #include "itkPolyLineParametricPath.h" int otbAddCarvingPathFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::AddCarvingPathFilter AddCarvingPathFilterType; AddCarvingPathFilterType::Pointer filter = AddCarvingPathFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/SeamCarving/test/otbImageToCarvingPathFilterNew.cxx000066400000000000000000000022431301006202600303250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageToCarvingPathFilter.h" #include "itkPolyLineParametricPath.h" int otbImageToCarvingPathFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageToCarvingPathFilter ImageToCarvingPathFilterType; ImageToCarvingPathFilterType::Pointer filter = ImageToCarvingPathFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/SeamCarving/test/otbRemoveCarvingPathFilterNew.cxx000066400000000000000000000023671301006202600302440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbRemoveCarvingPathFilter.h" #include "itkPolyLineParametricPath.h" int otbRemoveCarvingPathFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::RemoveCarvingPathFilter RemoveCarvingPathFilterType; RemoveCarvingPathFilterType::Pointer filter = RemoveCarvingPathFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/SeamCarving/test/otbSeamCarvingTestDriver.cxx000066400000000000000000000003001301006202600272340ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbRemoveCarvingPathFilterNew); REGISTER_TEST(otbImageToCarvingPathFilterNew); REGISTER_TEST(otbAddCarvingPathFilterNew); } OTB-release-5.8/Modules/Feature/Textures/000077500000000000000000000000001301006202600202445ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Textures/CMakeLists.txt000066400000000000000000000000471301006202600230050ustar00rootroot00000000000000project(OTBTextures) otb_module_impl() OTB-release-5.8/Modules/Feature/Textures/include/000077500000000000000000000000001301006202600216675ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Textures/include/otbGreyLevelCooccurrenceIndexedList.h000066400000000000000000000162511301006202600311400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGreyLevelCooccurrenceIndexedList_h #define otbGreyLevelCooccurrenceIndexedList_h #include "itkNumericTraits.h" #include "itkObjectFactory.h" #include "itkLightObject.h" #include "itkArray.h" #include "itkIndex.h" #include "itkSize.h" #include #include namespace otb { /** \class GreyLevelCooccurrenceIndexedList * \brief This class holds a VectorType of CooccurrencePairType with each pair is * a combination of pixel index and frequency. * * GreyLevelCooccurrenceIndexedList instance is created for every neighborhood * iteration over the given input image. This class keep an internal itk::Array * as a lookup array with size as [nbbins x nbbins]. The lookup array stores * position CooccurrencePairType in the VectorType. It ensures us that all elements * in Vector are unqiue in terms of the index value in the pair. For any given * pixel index, -1 value indicates zero existence of the index in the * VectorType. This avoid searching all elements in VectorType for each pixel * index added during neighborhood iterator. It is also used to decide wheather * to update the frequency of pair or to insert a new element in the vector. * * Print references: * David A. Clausi and Yongping Zhao. 2002. Rapid extraction of image texture by * co-occurrence using a hybrid data structure. Comput. Geosci. 28, 6 (July * 2002), 763-774. DOI=10.1016/S0098-3004(01)00108-X * http://dx.doi.org/10.1016/S0098-3004(01)00108-X * * de O.Bastos, L.; Liatsis, P.; Conci, A., Automatic texture segmentation based * on k-means clustering and efficient calculation of co-occurrence * features. Systems, Signals and Image Processing, 2008. IWSSIP 2008. 15th * International Conference on , vol., no., pp.141,144, 25-28 June 2008 * doi: 10.1109/IWSSIP.2008.4604387 * * \ingroup OTBTextures */ template class ITK_EXPORT GreyLevelCooccurrenceIndexedList : public itk::LightObject { public: /** Standard typedefs */ typedef GreyLevelCooccurrenceIndexedList Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(GreyLevelCooccurrenceIndexedList, itk::LightObject); typedef TPixel PixelType; itkStaticConstMacro(PixelPairSize, unsigned int, 2); typedef itk::Index IndexType; typedef itk::Size SizeType; typedef typename itk::IndexValueType IndexValueType; typedef typename itk::IdentifierType InstanceIdentifier; typedef InstanceIdentifier FrequencyType; typedef typename itk::NumericTraits< FrequencyType >::RealType RelativeFrequencyType; typedef typename itk::NumericTraits< FrequencyType >::AccumulateType TotalFrequencyType; typedef typename itk::NumericTraits< PixelType >::RealType PixelValueType; typedef itk::FixedArray PixelPairType; // lower bound of each bin std::vector< std::vector< PixelValueType > > m_Min; // upper bound of each bin std::vector< std::vector< PixelValueType > > m_Max; /* std::pair to hold pixel pair and its frequency count */ typedef std::pair CooccurrencePairType; /** Lookup array used to store the index of the given pixel pair. Size of * LookupAray is equal to the nbins * nbins. Values in the array represents 1D * index of the IndexType*/ typedef itk::Array LookupArrayType; /** std::vector to hold CooccurrencePairType. Index of the array where the * cooccurrence is stored is saved in the LookupArrayType.*/ typedef std::vector VectorType; /** Get the total frequency of Co-occurrence pairs. */ itkGetMacro(TotalFrequency, TotalFrequencyType); /** Get the total frequency of Co-occurrence pairs. */ itkGetMacro(Symmetry, bool); /** Get std::vector containing non-zero co-occurrence pairs */ VectorType GetVector(); /** Initialize the lowerbound and upper bound vecotor, Fill m_LookupArray with * -1 and set m_TotalFrequency to zero */ void Initialize(const unsigned int nbins, const PixelValueType min, const PixelValueType max, const bool symmetry = true); //check if both pixel values fall between m_InputImageMinimum and //m_InputImageMaximum. If so add to m_Vector via AddPairToVector method */ void AddPixelPair(const PixelValueType& pixelvalue1, const PixelValueType& pixelvalue2); /* Get the frequency value from Vector with index =[j,i] */ RelativeFrequencyType GetFrequency(IndexValueType i, IndexValueType j); /* Get the frequency value from Vector with index =[j,i] from given * vector. This is used if we have a copy of m_Vector normalized. */ RelativeFrequencyType GetFrequency(IndexValueType i, IndexValueType j, const VectorType& vect) const; protected: GreyLevelCooccurrenceIndexedList(); ~GreyLevelCooccurrenceIndexedList() ITK_OVERRIDE { } /** create a cooccurrence pair with given index and frequency = 1 * value. Next occurrence of same index is checked via m_LookupArray and the * corresponding frequency value is incremented. If m_Symmetry is true the * co-occurrence pair is added again with index values swapped */ void AddPairToVector(IndexType index); void SetBinMin(const unsigned int dimension, const InstanceIdentifier nbin, PixelValueType min); void SetBinMax(const unsigned int dimension, const InstanceIdentifier nbin, PixelValueType max); /** Get index of the pixelPair combination and save the result in index **/ bool GetIndex(const PixelPairType & pixelPair, IndexType & index) const; void PrintSelf(std::ostream & os, itk::Indent indent) const ITK_OVERRIDE; private: GreyLevelCooccurrenceIndexedList(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** LookupArray instance */ LookupArrayType m_LookupArray; /* std::vector holding actual co-occurrence pairs */ VectorType m_Vector; /* Size instance */ SizeType m_Size; /** booleab to check if co-occurrene list is a symmtrical. true by default */ bool m_Symmetry; /* Store the total frequency of co-occurrence pairs in GreyLevelCooccureneIndexedList class */ TotalFrequencyType m_TotalFrequency; /** boolean to check pixel values fall under m_InputImageMinimum and * m_InputImageMaximum. Used in GetIndex method. false by default */ bool m_ClipBinsAtEnds; /** Input image minimum */ PixelValueType m_InputImageMinimum; /** Input image maximum */ PixelValueType m_InputImageMaximum; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGreyLevelCooccurrenceIndexedList.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbGreyLevelCooccurrenceIndexedList.txx000066400000000000000000000212361301006202600315330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGreyLevelCooccurrenceIndexedList_txx #define otbGreyLevelCooccurrenceIndexedList_txx #include "otbGreyLevelCooccurrenceIndexedList.h" namespace otb { template GreyLevelCooccurrenceIndexedList:: GreyLevelCooccurrenceIndexedList(): m_Size(), m_Symmetry(true), m_TotalFrequency(0), m_ClipBinsAtEnds(true), m_InputImageMinimum(0), m_InputImageMaximum(255) { } template void GreyLevelCooccurrenceIndexedList:: Initialize(const unsigned int nbins, const PixelValueType min, const PixelValueType max, const bool symmetry) { PixelPairType lowerBound; PixelPairType upperBound; m_Size.Fill(nbins); m_InputImageMinimum = min; m_InputImageMaximum = max; lowerBound.Fill(min); upperBound.Fill(max+1); m_Symmetry = symmetry; m_LookupArray = LookupArrayType(m_Size[0] * m_Size[1]); m_LookupArray.Fill(-1); m_TotalFrequency = 0; // adjust the sizes of min max value containers unsigned int dim; m_Min.resize( PixelPairSize ); for ( dim = 0; dim < PixelPairSize; dim++ ) { m_Min[dim].resize(m_Size[dim]); } m_Max.resize( PixelPairSize ); for ( dim = 0; dim < PixelPairSize; dim++ ) { m_Max[dim].resize(m_Size[dim]); } float interval; for ( unsigned int i = 0; i < PixelPairSize; i++ ) { if ( m_Size[i] > 0 ) { interval = static_cast( upperBound[i] - lowerBound[i] ) / static_cast< PixelValueType >( m_Size[i] ); // Set the min vector and max vector for ( unsigned int j = 0; j < static_cast< unsigned int >( m_Size[i] - 1 ); j++ ) { this->SetBinMin( i, j, (PixelValueType)( lowerBound[i] + ( (float)j * interval ) ) ); this->SetBinMax( i, j, (PixelValueType)( lowerBound[i] + ( ( (float)j + 1 ) * interval ) ) ); } this->SetBinMin( i, m_Size[i] - 1, (PixelValueType)( lowerBound[i] + ( ( (float)m_Size[i] - 1 ) * interval ) ) ); this->SetBinMax( i, m_Size[i] - 1, (PixelValueType)( upperBound[i] ) ); } } } template void GreyLevelCooccurrenceIndexedList:: SetBinMin(const unsigned int dimension, const InstanceIdentifier nbin, PixelValueType min) { m_Min[dimension][nbin] = min; } template void GreyLevelCooccurrenceIndexedList:: SetBinMax(const unsigned int dimension, const InstanceIdentifier nbin, PixelValueType max) { m_Max[dimension][nbin] = max; } template bool GreyLevelCooccurrenceIndexedList:: GetIndex(const PixelPairType & pixelPair, IndexType & index) const { // now using something similar to binary search to find // index. unsigned int dim; int begin; int mid; int end; PixelValueType median; PixelValueType tempPixelValue; for ( dim = 0; dim < PixelPairSize; dim++ ) { tempPixelValue = pixelPair[dim]; begin = 0; if ( tempPixelValue < m_Min[dim][begin] ) { // one of measurement is below the minimum // its ok if we extend the bins to infinity.. not ok if we don't if ( !m_ClipBinsAtEnds ) { index[dim] = (IndexValueType)0; continue; } else { // set an illegal value and return 0 index[dim] = (IndexValueType)m_Size[dim]; return false; } } end = m_Min[dim].size() - 1; if ( tempPixelValue >= m_Max[dim][end] ) { // one of measurement is above the maximum // its ok if we extend the bins to infinity.. not ok if we don't // Need to include the last endpoint in the last bin. if ( !m_ClipBinsAtEnds || tempPixelValue == m_Max[dim][end]) { index[dim] = (IndexValueType)m_Size[dim] - 1; continue; } else { // set an illegal value and return 0 index[dim] = (IndexValueType)m_Size[dim]; return false; } } // Binary search for the bin where this measurement could be mid = ( end + 1 ) / 2; median = m_Min[dim][mid]; while ( true ) { if ( tempPixelValue < median ) { end = mid - 1; } else if ( tempPixelValue > median ) { // test whether it is inside the current bin by comparing to the max of // this bin. if ( tempPixelValue < m_Max[dim][mid] && tempPixelValue >= m_Min[dim][mid] ) { index[dim] = mid; break; } // otherwise, continue binary search begin = mid + 1; } else { index[dim] = mid; break; } mid = begin + ( end - begin ) / 2; median = m_Min[dim][mid]; } // end of while } // end of for() return true; } template void GreyLevelCooccurrenceIndexedList:: AddPixelPair(const PixelValueType& pixelvalue1, const PixelValueType& pixelvalue2) { if ( pixelvalue1 < m_InputImageMinimum || pixelvalue1 > m_InputImageMaximum ) { return; // don't put a pixel in the co-occurrence list if pixelvalue1 // is out-of-bounds. } if ( pixelvalue2 < m_InputImageMinimum || pixelvalue2 > m_InputImageMaximum ) { return; // don't put a pixel in the co-occurrence list if the pixelvalue2 // is out-of-bounds. } IndexType index; PixelPairType ppair( PixelPairSize); ppair[0] = pixelvalue1; ppair[1] = pixelvalue2; //Get Index of the given pixel pair; this->GetIndex(ppair, index); //Add the index and set/update the frequency of the pixel pair. if m_Symmetry //is true the index is swapped and added to vector again. this->AddPairToVector(index); if(m_Symmetry) { IndexValueType temp; temp = index[0]; index[0] = index[1]; index[1] = temp; this->AddPairToVector(index); } } template typename GreyLevelCooccurrenceIndexedList::RelativeFrequencyType GreyLevelCooccurrenceIndexedList:: GetFrequency(IndexValueType i, IndexValueType j) { double frequency = 0; InstanceIdentifier instanceId = i * m_Size[0] + j; if (instanceId < m_LookupArray.size()) { int findex = m_LookupArray[instanceId]; if(findex > -1 ) frequency = m_Vector[findex].second / m_TotalFrequency; } return frequency; } template typename GreyLevelCooccurrenceIndexedList::RelativeFrequencyType GreyLevelCooccurrenceIndexedList:: GetFrequency(IndexValueType i, IndexValueType j, const VectorType& vect) const { double frequency = 0; InstanceIdentifier instanceId = i * m_Size[0] + j; if (instanceId < m_LookupArray.size()) { int findex = m_LookupArray[instanceId]; if(findex > -1 ) frequency = vect[findex].second; } return frequency; } template typename GreyLevelCooccurrenceIndexedList::VectorType GreyLevelCooccurrenceIndexedList ::GetVector() { return m_Vector; } template void GreyLevelCooccurrenceIndexedList ::AddPairToVector(IndexType index) { InstanceIdentifier instanceId = 0; instanceId = index[1] * m_Size[0] + index[0]; int vindex = m_LookupArray[instanceId]; if( vindex < 0) { m_LookupArray[instanceId] = m_Vector.size(); CooccurrencePairType cooccur; cooccur = std::make_pair(index,1); m_Vector.push_back(cooccur); } else { m_Vector[vindex].second++; } m_TotalFrequency = m_TotalFrequency + 1; } template void GreyLevelCooccurrenceIndexedList ::PrintSelf(std::ostream & os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Symmetry: " << this->m_Symmetry << std::endl; os << indent << "TotalFrequency: " << this->m_TotalFrequency << std::endl; os << indent << "Size: " << m_Size; os << indent << "CooccurrenceIndexedList: " << std::endl; typename VectorType::const_iterator it; for (it = m_Vector.begin(); it != m_Vector.end(); ++it) { std::cerr << "index=" << (*it).first << ", frequency=" << (*it).second << std::endl; } std::cerr << std::endl; } } //end namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbHaralickTexturesImageFunction.h000066400000000000000000000216601301006202600305050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHaralickTexturesImageFunction_h #define otbHaralickTexturesImageFunction_h #include "otbGreyLevelCooccurrenceIndexedList.h" #include "itkImageToImageFilter.h" #include "itkImageFunction.h" #include "itkFixedArray.h" namespace otb { /** * \class HaralickTexturesImageFunction * \brief Compute the 8 Haralick texture indices on the neighborhood of the point * * To improve the speed of computation, a variant of Grey Level Co-occurrence * Matrix(GLCM) called Grey Level Co-occurrence Indexed List (GLCIL) is * used. Given below is the mathematical explanation on the computation of each * textures. Here $ g(i, j) $ is the frequency of element in the GLCIL whose * index is i, j. GLCIL stores a pair of frequency of two pixels from the given * offset and the cell index (i, j) of the pixel in the neighborhood * window. :(where each element in GLCIL is a pair of pixel index and it's * frequency, $ g(i, j) $ is the frequency value of the pair having index is i, j). * * "Energy" \f$ = f_1 = \sum_{i, j}g(i, j)^2 \f$ * * "Entropy" \f$ = f_2 = -\sum_{i, j}g(i, j) \log_2 g(i, j)\f$, or 0 if \f$g(i, j) = 0\f$ * * "Correlation" \f$ = f_3 = \sum_{i, j}\frac{(i - \mu)(j - \mu)g(i, j)}{\sigma^2} \f$ * * "Difference Moment" \f$= f_4 = \sum_{i, j}\frac{1}{1 + (i - j)^2}g(i, j) \f$ * * "Inertia" \f$ = f_5 = \sum_{i, j}(i - j)^2g(i, j) \f$ (sometimes called "contrast") * * "Cluster Shade" \f$ = f_6 = \sum_{i, j}((i - \mu) + (j - \mu))^3 g(i, j) \f$ * * "Cluster Prominence" \f$ = f_7 = \sum_{i, j}((i - \mu) + (j - \mu))^4 g(i, j) \f$ * * "Haralick's Correlation" \f$ = f_8 = \frac{\sum_{i, j}(i, j) g(i, j) -\mu_t^2}{\sigma_t^2} \f$ * where \f$\mu_t\f$ and \f$\sigma_t\f$ are the mean and standard deviation of the row * (or column, due to symmetry) sums. * * Above, \f$ \mu = \f$ (weighted pixel average) \f$ = \sum_{i, j}i \cdot g(i, j) = * \sum_{i, j}j \cdot g(i, j) \f$ (due to matrix summetry), and * * \f$ \sigma = \f$ (weighted pixel variance) \f$ = \sum_{i, j}(i - \mu)^2 \cdot g(i, j) = * \sum_{i, j}(j - \mu)^2 \cdot g(i, j) \f$ (due to matrix summetry) * * Print references: * * Haralick, R.M., K. Shanmugam and I. Dinstein. 1973. Textural Features for * Image Classification. IEEE Transactions on Systems, Man and Cybernetics. * SMC-3(6):610-620. * * David A. Clausi and Yongping Zhao. 2002. Rapid extraction of image texture by * co-occurrence using a hybrid data structure. Comput. Geosci. 28, 6 (July * 2002), 763-774. DOI=10.1016/S0098-3004(01)00108-X * http://dx.doi.org/10.1016/S0098-3004(01)00108-X * * de O.Bastos, L.; Liatsis, P.; Conci, A., Automatic texture segmentation based * on k-means clustering and efficient calculation of co-occurrence * features. Systems, Signals and Image Processing, 2008. IWSSIP 2008. 15th * International Conference on , vol., no., pp.141,144, 25-28 June 2008 * doi: 10.1109/IWSSIP.2008.4604387 * * \sa otb::GreyLevelCo-occurrenceIndexedList * * \ingroup ImageFunctions * * \ingroup OTBTextures */ template class ITK_EXPORT HaralickTexturesImageFunction : public itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits::RealType, 8 >, TCoordRep > { public: /** Standard class typedefs. */ typedef HaralickTexturesImageFunction Self; typedef itk::ImageFunction< TInputImage, itk::FixedArray< typename itk::NumericTraits< typename TInputImage::PixelType>::RealType, 8 >, TCoordRep > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(HaralickTexturesImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::RegionType InputRegionType; typedef typename InputImageType::OffsetType OffsetType; typedef typename InputRegionType::SizeType SizeType; // Output typedef support typedef typename Superclass::OutputType OutputType; typedef typename OutputType::ValueType ScalarRealType; // Textures tools typedef GreyLevelCooccurrenceIndexedList< InputPixelType > CooccurrenceIndexedListType; typedef typename CooccurrenceIndexedListType::Pointer CooccurrenceIndexedListPointerType; typedef typename CooccurrenceIndexedListType::ConstPointer CooccurrenceIndexedListConstPointerType; typedef typename CooccurrenceIndexedListType::IndexType CooccurrenceIndexType; typedef typename CooccurrenceIndexedListType::PixelValueType PixelValueType; typedef typename CooccurrenceIndexedListType::RelativeFrequencyType RelativeFrequencyType; typedef typename CooccurrenceIndexedListType::VectorType VectorType; typedef typename VectorType::iterator VectorIteratorType; typedef typename VectorType::const_iterator VectorConstIteratorType; // Coord rep typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** * Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); /** * Get the radius of the neighborhood over which the * statistics are evaluated */ itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); /** Set the offset for co-occurence computation */ itkSetMacro(Offset, OffsetType); /** Get the offset for co-occurence computation */ itkGetMacro(Offset, OffsetType); /** Set the number of bin per axis */ itkSetMacro(NumberOfBinsPerAxis, unsigned int); /** Get the number of bin per axis */ itkGetMacro(NumberOfBinsPerAxis, unsigned int); /** Set the input image minimum */ itkSetMacro(InputImageMinimum, InputPixelType); /** Get the input image minimum */ itkGetMacro(InputImageMinimum, InputPixelType); /** Set the input image maximum */ itkSetMacro(InputImageMaximum, InputPixelType); /** Get the input image maximum */ itkGetMacro(InputImageMaximum, InputPixelType); protected: HaralickTexturesImageFunction(); ~HaralickTexturesImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: HaralickTexturesImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the neighborhood over which to compute the textures */ unsigned int m_NeighborhoodRadius; /** Offset for co-occurences generation */ OffsetType m_Offset; /** Number of bins per axis */ unsigned int m_NumberOfBinsPerAxis; /** Input image minimum */ InputPixelType m_InputImageMinimum; /** Input image maximum */ InputPixelType m_InputImageMaximum; //TODO: should we use constexpr? only c++11 and problem for msvc inline double GetPixelValueTolerance() const {return 0.0001; } }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHaralickTexturesImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbHaralickTexturesImageFunction.txx000066400000000000000000000175261301006202600311070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHaralickTexturesImageFunction_txx #define otbHaralickTexturesImageFunction_txx #include "otbHaralickTexturesImageFunction.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" #include #include namespace otb { /** * Constructor */ template HaralickTexturesImageFunction ::HaralickTexturesImageFunction() : m_NeighborhoodRadius(10), m_Offset(), m_NumberOfBinsPerAxis(8), m_InputImageMinimum(0), m_InputImageMaximum(255) {} template void HaralickTexturesImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " Neighborhood radius value : " << m_NeighborhoodRadius << std::endl; os << indent << " Input image minimum value : " << m_InputImageMinimum << std::endl; os << indent << " Input Image maximum value : " << m_InputImageMaximum << std::endl; os << indent << " Number of bins per axis : " << m_NumberOfBinsPerAxis << std::endl; os << indent << " Offset : " << m_Offset << std::endl; } template typename HaralickTexturesImageFunction::OutputType HaralickTexturesImageFunction ::EvaluateAtIndex(const IndexType& index) const { // Build textures vector OutputType textures; // Initialize textures textures.Fill( itk::NumericTraits< ScalarRealType >::Zero ); // Check for input image if( !this->GetInputImage() ) { return textures; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return textures; } const double log2 = vcl_log(2.0); // Retrieve the input pointer InputImagePointerType inputPtr = const_cast (this->GetInputImage()); // Compute the region on which co-occurence will be estimated typename InputRegionType::IndexType inputIndex; typename InputRegionType::SizeType inputSize; for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputIndex[dim] = index[dim] - m_NeighborhoodRadius; inputSize[dim] = 2 * m_NeighborhoodRadius + 1; } // Build the input region InputRegionType inputRegion; inputRegion.SetIndex(inputIndex); inputRegion.SetSize(inputSize); inputRegion.Crop(inputPtr->GetRequestedRegion()); CooccurrenceIndexedListPointerType GLCIList = CooccurrenceIndexedListType::New(); GLCIList->Initialize(m_NumberOfBinsPerAxis, m_InputImageMinimum, m_InputImageMaximum); // Next, find the minimum radius that encloses all the offsets. unsigned int minRadius = 0; for ( unsigned int i = 0; i < m_Offset.GetOffsetDimension(); i++ ) { unsigned int distance = vcl_abs(m_Offset[i]); if ( distance > minRadius ) { minRadius = distance; } } SizeType radius; radius.Fill(minRadius); typedef itk::ConstNeighborhoodIterator< InputImageType > NeighborhoodIteratorType; NeighborhoodIteratorType neighborIt; neighborIt = NeighborhoodIteratorType(radius, inputPtr, inputRegion); for ( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt ) { const InputPixelType centerPixelIntensity = neighborIt.GetCenterPixel(); bool pixelInBounds; const InputPixelType pixelIntensity = neighborIt.GetPixel(m_Offset, pixelInBounds); if ( !pixelInBounds ) { continue; // don't put a pixel in the value if it's out-of-bounds. } GLCIList->AddPixelPair(centerPixelIntensity, pixelIntensity); } double pixelMean = 0.; double marginalMean; double marginalDevSquared = 0.; double pixelVariance = 0.; //Create and Initialize marginalSums std::vector marginalSums(m_NumberOfBinsPerAxis, 0); //get co-occurrence vector and totalfrequency VectorType glcVector = GLCIList->GetVector(); double totalFrequency = static_cast (GLCIList->GetTotalFrequency()); //Normalize the co-occurrence indexed list and compute mean, marginalSum typename VectorType::iterator it = glcVector.begin(); while( it != glcVector.end()) { double frequency = (*it).second / totalFrequency; CooccurrenceIndexType index2 = (*it).first; pixelMean += index2[0] * frequency; marginalSums[index2[0]] += frequency; ++it; } /* Now get the mean and deviaton of the marginal sums. Compute incremental mean and SD, a la Knuth, "The Art of Computer Programming, Volume 2: Seminumerical Algorithms", section 4.2.2. Compute mean and standard deviation using the recurrence relation: M(1) = x(1), M(k) = M(k-1) + (x(k) - M(k-1) ) / k S(1) = 0, S(k) = S(k-1) + (x(k) - M(k-1)) * (x(k) - M(k)) for 2 <= k <= n, then sigma = vcl_sqrt(S(n) / n) (or divide by n-1 for sample SD instead of population SD). */ std::vector::const_iterator msIt = marginalSums.begin(); marginalMean = *msIt; //Increment iterator to start with index 1 ++msIt; for(int k= 2; msIt != marginalSums.end(); ++k, ++msIt) { double M_k_minus_1 = marginalMean; double S_k_minus_1 = marginalDevSquared; double x_k = *msIt; double M_k = M_k_minus_1 + ( x_k - M_k_minus_1 ) / k; double S_k = S_k_minus_1 + ( x_k - M_k_minus_1 ) * ( x_k - M_k ); marginalMean = M_k; marginalDevSquared = S_k; } marginalDevSquared = marginalDevSquared / m_NumberOfBinsPerAxis; VectorConstIteratorType constVectorIt; constVectorIt = glcVector.begin(); while( constVectorIt != glcVector.end()) { RelativeFrequencyType frequency = (*constVectorIt).second / totalFrequency; CooccurrenceIndexType index2 = (*constVectorIt).first; pixelVariance += ( index2[0] - pixelMean ) * ( index2[0] - pixelMean ) * frequency; ++constVectorIt; } double pixelVarianceSquared = pixelVariance * pixelVariance; // Variance is only used in correlation. If variance is 0, then (index[0] - pixelMean) * (index[1] - pixelMean) // should be zero as well. In this case, set the variance to 1. in order to // avoid NaN correlation. if(pixelVarianceSquared < GetPixelValueTolerance()) { pixelVarianceSquared = 1.; } //Compute textures constVectorIt = glcVector.begin(); while( constVectorIt != glcVector.end()) { CooccurrenceIndexType index2 = (*constVectorIt).first; RelativeFrequencyType frequency = (*constVectorIt).second / totalFrequency; textures[0] += frequency * frequency; textures[1] -= ( frequency > GetPixelValueTolerance() ) ? frequency *vcl_log(frequency) / log2:0; textures[2] += ( ( index2[0] - pixelMean ) * ( index2[1] - pixelMean ) * frequency ) / pixelVarianceSquared; textures[3] += frequency / ( 1.0 + ( index2[0] - index2[1] ) * ( index2[0] - index2[1] ) ); textures[4] += ( index2[0] - index2[1] ) * ( index2[0] - index2[1] ) * frequency; textures[5] += vcl_pow( ( index2[0] - pixelMean ) + ( index2[1] - pixelMean ), 3 ) * frequency; textures[6] += vcl_pow( ( index2[0] - pixelMean ) + ( index2[1] - pixelMean ), 4 ) * frequency; textures[7] += index2[0] * index2[1] * frequency; ++constVectorIt; } textures[7] = (fabs(marginalDevSquared) > 1E-8) ? ( textures[7] - marginalMean * marginalMean ) / marginalDevSquared : 0; // Return result return textures; } } // namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbSFSTexturesFunctor.h000066400000000000000000000320751301006202600263140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSFSTexturesFunctor_h #define otbSFSTexturesFunctor_h #include "otbMath.h" #include "itkNumericTraits.h" #include #include namespace otb { /** \class SFSTexturesFunctor * \brief This functor computes textures based on line direction analysis through the central pixel. * * Directions are computed using NumberOfDirection, used to compute a constant step angle. * A direction is defined as : \f$ \mathit{d_{i} = \sqrt{(m^{e1}-m{e2})^{2}+(n^{e1}-n{e2})^{2}}} \f$ * From \f$ \mathit{d_{i}} \f$, histograms are defined : * \f$ \mathit{H(c) : \{c \in I \mid \lbrack d_{1}(c), \ldots , d_{i}(c), \ldots , d_{D}(c)\rbrack \}} \f$ * Thus, 6 textures are defined : * \f$ \mathit{length = \max_{i \in \lbrack1; D\rbrack}(d_{i}(c)} \f$ * \f$ \mathit{width = \min_{i \in \lbrack1; D\rbrack}(d_{i}(c)} \f$ * \f$ \mathit{PSI = \frac{1}{D}\sum_{1=1}^{D}d_{i}(c)} \f$ * \f$ \mathit{\omega-mean = \frac{1}{D}\sum_{1=1}^{D}\frac{\alpha.(k_{i}-1)}{st_{i}}d_{i}(c)} \f$ * \f$ \mathit{ratio = \arctan{\frac{\sum_{j=1}^{n}{sort_{min}^{j}(H(c))}}{\sum_{j=1}^{n}{sort_{max}^{j}(H(c))}}}} \f$ * \f$ \mathit{SD = \frac{1}{D-1}\sqrt{\sum_{1=1}^{D}(d_{i}(c)-PSI)^{2}}} \f$ * * For more details, please refer to refer to Xin Huang, Liangpei Zhang and Pingxiang Li publication, * Classification and Extraction of Spatial Features in Urban Areas * Using High-Resolution Multispectral Imagery. * IEEE Geoscience and Remote Sensing Letters, * vol. 4, n. 2, 2007, pp 260-264 * * \ingroup Textures * * \ingroup OTBTextures */ namespace Functor { template class SFSTexturesFunctor { public: SFSTexturesFunctor() { m_SpatialThreshold = 100; m_SpectralThreshold = 50; m_RatioMaxConsiderationNumber = 5; m_Alpha = 1; this->SetNumberOfDirections(20); // set the step too m_SelectedTextures = std::vector(6, 1); } virtual ~SFSTexturesFunctor() {} typedef typename TIter::InternalPixelType InternalPixelType; typedef typename TIter::SizeType SizeType; typedef typename TIter::IndexType IndexType; typedef typename TIter::OffsetType OffsetType; typedef TOutputValue OutputValueType; typedef std::vector OutputType; void SetSpatialThreshold(unsigned int thresh){ m_SpatialThreshold = thresh; } void SetSpectralThreshold(InternalPixelType thresh){ m_SpectralThreshold = thresh; } void SetRatioMaxConsiderationNumber(unsigned int value){ m_RatioMaxConsiderationNumber = value; } void SetAlpha(double alpha){ m_Alpha = alpha; } void SetNumberOfDirections(unsigned int D) { m_NumberOfDirections = D; m_DirectionStep = CONST_PI / static_cast(D); } void SetDirectionStep(double step){ m_DirectionStep = step; } void SetSelectedTextures(std::vector vect) { m_SelectedTextures.clear(); m_SelectedTextures = vect; } void SetTextureStatus(unsigned int id, bool isSelected){ m_SelectedTextures[id] = isSelected; } unsigned int GetSpatialThreshold(){ return m_SpatialThreshold; } InternalPixelType GetSpectralThreshold(){ return m_SpectralThreshold; } unsigned int GetRatioMaxConsiderationNumber(){ return m_RatioMaxConsiderationNumber; } double GetAlpha(){ return m_Alpha; } unsigned int GetNumberOfDirections(){ return m_NumberOfDirections(); } std::vector GetTexturesStatus(){ return m_SelectedTextures; } inline OutputType operator ()(const TIter& it) { double length = itk::NumericTraits::NonpositiveMin(); double width = itk::NumericTraits::max(); double SpatialThresholdDouble = static_cast(m_SpatialThreshold); double NumberOfDirectionsDouble = static_cast(m_NumberOfDirections); double dist = 0.; double angle = 0.; double sdiVal = 0.; double sumWMean = 0.; double sum = 0.; std::vector di(m_NumberOfDirections, 0.); std::vector minSorted(m_RatioMaxConsiderationNumber, width); std::vector maxSorted(m_RatioMaxConsiderationNumber, length); std::vector sti(m_NumberOfDirections, 0.); std::vector lengthLine(m_NumberOfDirections, 0); std::vector::iterator itVector; OutputType out(6, 0); OffsetType off; off.Fill(0); for (unsigned int d = 0; d < m_NumberOfDirections; d++) { // Current angle direction angle = m_DirectionStep * static_cast(d); // last offset in the direction respecting spatial threshold off[0] = static_cast(vcl_floor(SpatialThresholdDouble * vcl_cos(angle) + 0.5)); off[1] = static_cast(vcl_floor(SpatialThresholdDouble * vcl_sin(angle) + 0.5)); // last indices in the direction respecting spectral threshold OffsetType offEnd = this->FindLastOffset(it, off); // Check the opposite side off[0] *= -1.0; off[1] *= -1.0; OffsetType offStart = this->FindLastOffset(it, off); // computes distance = dist between the 2 segment point. dist = vcl_sqrt(vcl_pow(static_cast(offEnd[0]-offStart[0]), 2) + vcl_pow(static_cast(offEnd[1]-offStart[1]), 2)); // for length computation if (m_SelectedTextures[0] == true) if (dist > length) length = dist; // for width computation if (m_SelectedTextures[1] == true) if (dist < width) width = dist; // for PSI computation if (m_SelectedTextures[2] == true || m_SelectedTextures[5] == true) sum += dist; // for w-mean computation if (m_SelectedTextures[3] == true) sdiVal = this->ComputeSDi(it, offEnd); // for Ratio computation if (m_SelectedTextures[4] == true) { bool doo = false; itVector = maxSorted.begin(); while (itVector != maxSorted.end() && doo == false) { if (dist > (*itVector)) { itVector = maxSorted.insert(itVector, dist); maxSorted.pop_back(); doo = true; } ++itVector; } doo = false; itVector = minSorted.begin(); while (itVector != minSorted.end() && doo == false) { if (dist < (*itVector)) { itVector = minSorted.insert(itVector, dist); minSorted.pop_back(); doo = true; } ++itVector; } } di[d] = dist; if (m_SelectedTextures[3] == true) { lengthLine[d] = static_cast(dist); //static_cast( vcl_sqrt(vcl_pow(static_cast(offEnd[0]), 2) + vcl_pow(static_cast(offEnd[1]), 2)) ); sti[d] = sdiVal; if (sdiVal != 0.) sumWMean += (m_Alpha * (dist - 1) * dist /*lengthLine[n]*di[n]*/) / sdiVal; } } /////// FILL OUTPUT // length if (m_SelectedTextures[0] == true) out[0] = static_cast(length); // width if (m_SelectedTextures[1] == true) out[1] = static_cast(width); // PSI if (m_SelectedTextures[2] == true) out[2] = static_cast(sum / NumberOfDirectionsDouble); // w-mean if (m_SelectedTextures[3] == true) out[3] = static_cast(sumWMean / NumberOfDirectionsDouble); // ratio if (m_SelectedTextures[4] == true) { double sumMin = 0; double sumMax = 0; for (unsigned int t = 0; t < m_RatioMaxConsiderationNumber; t++) { sumMin += minSorted[t]; sumMax += maxSorted[t]; } if (sumMax != 0.) out[4] = static_cast(vcl_atan(sumMin / sumMax)); else if (sumMax == 0. && sumMin == 0.) out[4] = static_cast(1.); } // SD if (m_SelectedTextures[5] == true) { double sumPSI = 0; for (unsigned int n = 0; n < di.size(); ++n) sumPSI += vcl_pow(di[n] - sumWMean / NumberOfDirectionsDouble, 2); out[5] = static_cast(vcl_sqrt(sumPSI) / (NumberOfDirectionsDouble - 1.)); } return out; } /** Checks spectral threshold condition * the last point in the directiuon is the first that doesn't * respect the spectral condition. */ OffsetType FindLastOffset(const TIter& it, const OffsetType& stopOffset) { bool res = true; int signX = this->ComputeStep(stopOffset[0]); int signY = this->ComputeStep(stopOffset[1]); OffsetType currentOff; currentOff.Fill(0); currentOff[0] = signX; double slop = 0.; if (stopOffset[0] != 0) slop = static_cast(stopOffset[1] / static_cast(stopOffset[0])); bool isInside = true; while (isInside == true && res == true) { this->ComputePointLine(currentOff, slop, signY, stopOffset[0]); if (vcl_abs(it.GetPixel(currentOff) - it.GetCenterPixel()) > m_SpectralThreshold) { res = false; } else currentOff[0] += signX; isInside = this->CheckIsInside(signX, signY, currentOff, stopOffset); } return currentOff; } /** Computes SD in the ith direction */ double ComputeSDi(const TIter& it, const OffsetType& stopOffset) { bool canGo = true; unsigned int nbElt = 0; double SDi = 0.; double mean = 0.; double slop = 0.; if (stopOffset[0] != 0) slop = static_cast(stopOffset[1] / static_cast(stopOffset[0])); int signX = this->ComputeStep(stopOffset[0]); int signY = this->ComputeStep(stopOffset[1]); OffsetType currentOff; currentOff.Fill(0); currentOff[0] = signX; bool isInside = true; // First compute mean while (isInside == true && canGo == true) { this->ComputePointLine(currentOff, slop, signY, stopOffset[0]); mean += static_cast(it.GetPixel(currentOff)); nbElt++; if (vcl_abs(it.GetPixel(currentOff) - it.GetCenterPixel()) >= m_SpectralThreshold) canGo = false; else currentOff[0] += signX; isInside = this->CheckIsInside(signX, signY, currentOff, stopOffset); } mean /= static_cast(nbElt); currentOff[0] = signX; currentOff[1] = 0; isInside = true; while (isInside == true && canGo == true) { this->ComputePointLine(currentOff, slop, signY, stopOffset[0]); SDi += vcl_pow((static_cast(it.GetPixel(currentOff)) - mean), 2); if (vcl_abs(it.GetPixel(currentOff) - it.GetCenterPixel()) >= m_SpectralThreshold) canGo = false; else currentOff[0] += signX; isInside = this->CheckIsInside(signX, signY, currentOff, stopOffset); } return vcl_sqrt(SDi); } /** Check if the current offset is inside the stop one. */ bool CheckIsInside(const int& signX, const int& signY, const OffsetType& currentOff, const OffsetType& stopOffset) { bool isInside = true; if (signX * currentOff[0] >= signX * stopOffset[0] && stopOffset[0] != 0) isInside = false; else if (signY * currentOff[1] >= signY * stopOffset[1] && stopOffset[1] != 0) isInside = false; return isInside; } /** Compute the y coordinate according to a given x coordinate. * Use the Bresenham algo if the line is not horizontal (stopOffsetX==0). * Otherwise, it increments of 1 Y. */ void ComputePointLine(OffsetType& currentOff, const double& slop, const int& signY, const int& stopOffsetX) { if (stopOffsetX != 0) currentOff[1] = static_cast(vcl_floor(slop * static_cast(currentOff[0]) + 0.5)); else currentOff[1] += signY; } /** Compute the to give at x for line computation. * according to the signof stopOffset. */ int ComputeStep(const int& stopOffset) { int sign = 1; if (stopOffset < 0) sign = -1; return sign; } protected: /** spectral threshold conditon*/ InternalPixelType m_SpectralThreshold; /** spatial threshold condition */ unsigned int m_SpatialThreshold; /** Max nulber of min and considered for Ration computation */ unsigned int m_RatioMaxConsiderationNumber; /** constant to adjust w-mean values */ double m_Alpha; /** Number of direction considered */ unsigned int m_NumberOfDirections; /** Angular step between 2 directions (between and 2*pi). */ double m_DirectionStep; /** List of wanted textures : * 0: length * 1: width * 2: PSI * 3: w-mean * 4: ratio * 5: SD * Set to 1 means the texture will be computed. **/ std::vector m_SelectedTextures; }; } // end namespace functor } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbSFSTexturesImageFilter.h000066400000000000000000000176501301006202600270660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSFSTexturesImageFilter_h #define otbSFSTexturesImageFilter_h #include "otbSFSTexturesFunctor.h" #include "itkImageToImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" namespace otb { /** \class SFSTexturesImageFilter * \brief This functor computes the texture describes in the following publication * It is based on line direction estimation. * * Please refer to Xin Huang, Liangpei Zhang and Pingxiang Li publication, * Classification and Extraction of Spatial Features in Urban Areas * Using High-Resolution Multispectral Imagery. * IEEE Geoscience and Remote Sensing Letters, * vol. 4, n. 2, 2007, pp 260-264 * * The texture is computated for each pixel using its neighborhood. * User can set the spatial threshold that is the max line length, the spectral threshold * that is the max difference authorized between a pixel of the line and the center pixel * of the current neighborhood. Alpha and RatioMaxConsideration are used to compute * the \f$ \omega \f$ - mean value. Finally, The number of direction can be precised with * NumberOfDirections. * You can choose the computed textures using SetTextureStatus method (1:length, 2:width, * 3:PSI, 4:w-mean, 5:ratio, 6:SD). * * \sa SFSTexturesFunctor * \ingroup Textures * * \ingroup OTBTextures */ template class ITK_EXPORT SFSTexturesImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef SFSTexturesImageFilter Self; typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorNeighborhoodImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef typename InputImageType::ConstPointer InputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::RadiusType RadiusType; typedef Functor::SFSTexturesFunctor FunctorType; typedef typename FunctorType::OutputType FunctorOutputType; typedef itk::ProcessObject ProcessObjectType; /**Set/Get the radius of neighborhood.*/ itkGetMacro(Radius, unsigned int); /** Functor accessors */ FunctorType& GetFunctor() { return m_Functor; } const FunctorType& GetFunctor() const { return m_Functor; } void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } /** Spatial Threshold accessor */ void SetSpatialThreshold(unsigned int thresh) { this->GetFunctor().SetSpatialThreshold(thresh); m_Radius = thresh; this->Modified(); } unsigned int GetSpatialThreshold() { return this->GetFunctor().GetSpatialThreshold(); } /** Spectral Threshold accessor */ void SetSpectralThreshold(InputImagePixelType thresh) { this->GetFunctor().SetSpectralThreshold(thresh); } InputImagePixelType GetSpectralThreshold() { return this->GetFunctor().GetSpectralThreshold(); } /** RatioMaxConsiderationNumber accessor */ void SetRatioMaxConsiderationNumber(unsigned int value) { this->GetFunctor().SetRatioMaxConsiderationNumber(value); } unsigned int GetRatioMaxConsiderationNumber() { return this->GetFunctor().GetRatioMaxConsiderationNumber(); } /** Alpha accessor */ void SetAlpha(double alpha) { this->GetFunctor().SetAlpha(alpha); } double GetAlpha() { return this->GetFunctor().GetAlpha(); } /** Number Of Directions */ void SetNumberOfDirections(unsigned int D) { this->GetFunctor().SetNumberOfDirections(D); double step = CONST_PI / static_cast(D); this->GetFunctor().SetDirectionStep(step); } unsigned int GetNumberOfDirections() { return this->GetFunctor().GetNumberOfDirections(); } /** Texture selection accessors * 1: LENGTH * 2: WIDTH * 3: PSI * 4: WMEAN * 5: RATIO * 6: SD * Set to 1 means the texture will be computed. **/ typedef enum {LENGTH = 1, WIDTH, PSI, WMEAN, RATIO, SD} FeatureType; void SetFeatureStatus(FeatureType id, bool isSelected) { if (static_cast(id) > this->GetTexturesStatus().size() || id == 0) { itkExceptionMacro( << "Invalid texture index " << id << ", must be in [1;" << this->GetTexturesStatus().size() << "]"); } else { this->GetFunctor().SetTextureStatus(id - 1, isSelected); } } std::vector GetTexturesStatus() { return this->GetFunctor().GetTexturesStatus(); } void InitFeatureStatus(bool status); /** Return output length image */ const OutputImageType * GetLengthOutput() const; OutputImageType * GetLengthOutput(); /** Return output width image */ const OutputImageType * GetWidthOutput() const; OutputImageType * GetWidthOutput(); /** Return output PSI image */ const OutputImageType * GetPSIOutput() const; OutputImageType * GetPSIOutput(); /** Return output WMean image */ const OutputImageType * GetWMeanOutput() const; OutputImageType * GetWMeanOutput(); /** Return output ratio image */ const OutputImageType * GetRatioOutput() const; OutputImageType * GetRatioOutput(); /** Return output SD image */ const OutputImageType * GetSDOutput() const; OutputImageType * GetSDOutput(); void GenerateOutputInformation() ITK_OVERRIDE; std::vector m_FunctorList; protected: SFSTexturesImageFilter(); ~SFSTexturesImageFilter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Pad the input requested region by radius */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; private: SFSTexturesImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_Radius; FunctorType m_Functor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSFSTexturesImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbSFSTexturesImageFilter.txx000066400000000000000000000363251301006202600274620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSFSTexturesImageFilter_txx #define otbSFSTexturesImageFilter_txx #include "otbSFSTexturesImageFilter.h" #include "itkProgressReporter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "otbMath.h" namespace otb { template SFSTexturesImageFilter ::SFSTexturesImageFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(6); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageType::New()); this->SetNthOutput(2, OutputImageType::New()); this->SetNthOutput(3, OutputImageType::New()); this->SetNthOutput(4, OutputImageType::New()); this->SetNthOutput(5, OutputImageType::New()); m_Radius = this->GetSpatialThreshold(); m_FunctorList.clear(); } /************************************************************ * * OUTPUTS MANIPULATION * ************************************************************/ // Return output length image template const typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetLengthOutput() const { if (this->GetNumberOfOutputs() < 1) { return 0; } if (this->GetTexturesStatus()[0] == false) { itkExceptionMacro(<< "Impossible to create length image : texture not selected"); } return static_cast (this->itk::ProcessObject::GetOutput(0)); } template typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetLengthOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } if (this->GetTexturesStatus()[0] == false) { itkExceptionMacro(<< "Impossible to create length image : texture not selected"); } return static_cast(this->itk::ProcessObject::GetOutput(0)); } // Return output width image template const typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetWidthOutput() const { if (this->GetNumberOfOutputs() < 2) { return 0; } if (this->GetTexturesStatus()[1] == false) { itkExceptionMacro(<< "Impossible to create width image : texture not selected"); } return static_cast (this->itk::ProcessObject::GetOutput(1)); } template typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetWidthOutput() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } if (this->GetTexturesStatus()[1] == false) { itkExceptionMacro(<< "Impossible to create width image : texture not selected"); } return static_cast(this->itk::ProcessObject::GetOutput(1)); } //Return output PSI image template const typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetPSIOutput() const { if (this->GetNumberOfOutputs() < 3) { return 0; } if (this->GetTexturesStatus()[2] == false) { itkExceptionMacro(<< "Impossible to create PSI image : texture not selected"); } return static_cast (this->itk::ProcessObject::GetOutput(2)); } template typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetPSIOutput() { if (this->GetNumberOfOutputs() < 3) { return ITK_NULLPTR; } if (this->GetTexturesStatus()[2] == false) { itkExceptionMacro(<< "Impossible to create PSI image : texture not selected"); } return static_cast(this->itk::ProcessObject::GetOutput(2)); } // Return output WMean image template const typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetWMeanOutput() const { if (this->GetNumberOfOutputs() < 4) { return 0; } if (this->GetTexturesStatus()[3] == false) { itkExceptionMacro(<< "Impossible to create W-Mean image : texture not selected"); } return static_cast (this->itk::ProcessObject::GetOutput(3)); } template typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetWMeanOutput() { if (this->GetNumberOfOutputs() < 4) { return ITK_NULLPTR; } if (this->GetTexturesStatus()[3] == false) { itkExceptionMacro(<< "Impossible to create W-Mean image : texture not selected"); } return static_cast(this->itk::ProcessObject::GetOutput(3)); } // Return output ratio image template const typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetRatioOutput() const { if (this->GetNumberOfOutputs() < 5) { return 0; } if (this->GetTexturesStatus()[4] == false) { itkExceptionMacro(<< "Impossible to create Ratio image : texture not selected"); } return static_cast (this->itk::ProcessObject::GetOutput(4)); } template typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetRatioOutput() { if (this->GetNumberOfOutputs() < 5) { return ITK_NULLPTR; } if (this->GetTexturesStatus()[4] == false) { itkExceptionMacro(<< "Impossible to create Ratio image : texture not selected"); } return static_cast(this->itk::ProcessObject::GetOutput(4)); } // Return output SD image template const typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetSDOutput() const { if (this->GetNumberOfOutputs() < 6) { return 0; } if (this->GetTexturesStatus()[5] == false) { itkExceptionMacro(<< "Impossible to create SD image : texture not selected"); } return static_cast (this->itk::ProcessObject::GetOutput(5)); } template typename SFSTexturesImageFilter::OutputImageType * SFSTexturesImageFilter ::GetSDOutput() { if (this->GetNumberOfOutputs() < 6) { return ITK_NULLPTR; } if (this->GetTexturesStatus()[5] == false) { itkExceptionMacro(<< "Impossible to create SD image : texture not selected"); } return static_cast(this->itk::ProcessObject::GetOutput(5)); } template void SFSTexturesImageFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); if (this->GetSpatialThreshold() < this->GetRatioMaxConsiderationNumber()) { itkExceptionMacro(<< "Spatial Threshold (" << this->GetSpatialThreshold() << ") is lower than Ration Max Consideration Number (" << this->GetRatioMaxConsiderationNumber() << ") what is not allowed."); } for (unsigned int i = 0; i < this->GetNumberOfThreads(); ++i) { m_FunctorList.push_back(m_Functor); } this->InitFeatureStatus(true); } template void SFSTexturesImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr1 = this->GetOutput(0); //this->GetLengthOutput(); typename Superclass::OutputImagePointer outputPtr2 = this->GetOutput(1); //this->GetWidthOutput(); typename Superclass::OutputImagePointer outputPtr3 = this->GetOutput(2); //this->GetPSIOutput(); typename Superclass::OutputImagePointer outputPtr4 = this->GetOutput(3); //this->GetWMeanOutput(); typename Superclass::OutputImagePointer outputPtr5 = this->GetOutput(4); //this->GetRatioOutput(); typename Superclass::OutputImagePointer outputPtr6 = this->GetOutput(5); //this->GetSDOutput(); if (!inputPtr || !outputPtr1 || !outputPtr2 || !outputPtr3 || !outputPtr4 || !outputPtr5 || !outputPtr6) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius InputImageSizeType rad; rad[0] = m_Radius; rad[1] = m_Radius; inputRequestedRegion.PadByRadius(rad); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void SFSTexturesImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); //this->GetOutput()->SetNumberOfComponentsPerPixel(6); } template void SFSTexturesImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itk::ZeroFluxNeumannBoundaryCondition nbc; // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImage so it cannot be used for the second input. InputImagePointerType inputPtr = dynamic_cast(ProcessObjectType::GetInput(0)); OutputImagePointerType outputPtr1 = this->GetOutput(0); OutputImagePointerType outputPtr2 = this->GetOutput(1); OutputImagePointerType outputPtr3 = this->GetOutput(2); OutputImagePointerType outputPtr4 = this->GetOutput(3); OutputImagePointerType outputPtr5 = this->GetOutput(4); OutputImagePointerType outputPtr6 = this->GetOutput(5); RadiusType r; r.Fill(this->GetRadius()); NeighborhoodIteratorType neighInputIt; itk::ImageRegionIterator outputIt1, outputIt2, outputIt3, outputIt4, outputIt5, outputIt6; FunctorOutputType outputFunctor; // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(inputPtr, outputRegionForThread, r); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. std::vector textStatus = this->GetTexturesStatus(); for (fit = faceList.begin(); fit != faceList.end(); ++fit) { neighInputIt = itk::ConstNeighborhoodIterator(r, inputPtr, *fit); outputIt1 = itk::ImageRegionIterator(outputPtr1, *fit); outputIt2 = itk::ImageRegionIterator(outputPtr2, *fit); outputIt3 = itk::ImageRegionIterator(outputPtr3, *fit); outputIt4 = itk::ImageRegionIterator(outputPtr4, *fit); outputIt5 = itk::ImageRegionIterator(outputPtr5, *fit); outputIt6 = itk::ImageRegionIterator(outputPtr6, *fit); std::vector *> outItList; outItList.push_back(&outputIt1); outItList.push_back(&outputIt2); outItList.push_back(&outputIt3); outItList.push_back(&outputIt4); outItList.push_back(&outputIt5); outItList.push_back(&outputIt6); neighInputIt.OverrideBoundaryCondition(&nbc); neighInputIt.GoToBegin(); for (unsigned int i = 0; i < outItList.size(); ++i) { (*outItList[i]).GoToBegin(); } while (!outputIt1.IsAtEnd()) { outputFunctor = m_FunctorList[threadId](neighInputIt); for (unsigned int i = 0; i < outItList.size(); ++i) { if (textStatus[i] == true) (*outItList[i]).Set(outputFunctor[i]); } ++neighInputIt; for (unsigned int i = 0; i < outItList.size(); ++i) { ++(*outItList[i]); } progress.CompletedPixel(); } } } template void SFSTexturesImageFilter ::InitFeatureStatus(bool status) { for (FeatureType id = LENGTH; id <= SD; id = static_cast(id + 1)) { this->SetFeatureStatus(static_cast(id), status); } } /** * Standard "PrintSelf" method */ template void SFSTexturesImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); //os << indent << "Spatial Threshold : " << this->GetSpatialThreshold() << std::endl; //os << indent << "Spectral Threshold : " << this->GetSpectralThreshold() << std::endl; //os << indent << "Ratio Max Consideration Number: " << this->GetRatioMaxConsiderationNumber() << std::endl; //os << indent << "Alpha : " << this->GetAlpha() << std::endl; //os << indent << "Number Of Directions : " << this->GetNumberOfDirections() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToAdvancedTexturesFilter.h000066400000000000000000000220651301006202600315650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToAdvancedTexturesFilter_h #define otbScalarImageToAdvancedTexturesFilter_h #include "otbGreyLevelCooccurrenceIndexedList.h" #include "itkImageToImageFilter.h" namespace otb { /** * \class ScalarImageToAdvancedTexturesFilter * \brief In this case, 10 advanced texture features will be processed. The 10 * output image channels are: Mean, Variance, Dissimilarity, Sum Average, Sum * Variance, Sum Entropy, Difference of Entropies, Difference of Variances, IC1 * and IC2. They are provided in this exact order in the output image. The * textures are computed over a sliding window with user defined radius. * * To improve the speed of computation, a variant of Grey Level Co-occurrence * Matrix(GLCM) called Grey Level Co-occurrence Indexed List (GLCIL) is * used. Given below is the mathematical explanation on the computation of each * textures. Here $ g(i, j) $ is the frequency of element in the GLCIL whose * index is i, j. GLCIL stores a pair of frequency of two pixels from the given * offset and the cell index (i, j) of the pixel in the neighborhood * window. :(where each element in GLCIL is a pair of pixel index and it's * frequency, $ g(i, j) $ is the frequency value of the pair having index is i, j). * * "Mean" \f$ = \sum_{i, j}i g(i, j) \f$ * * "Sum of squares: Variance" \f$ = f_4 = \sum_{i, j}(i - \mu)^2 g(i, j) \f$ * * "Dissimilarity" \f$ = f_5 = \sum_{i, j}(i - j) g(i, j)^2 \f$ * * "Sum average" \f$ = f_6 = -\sum_{i}i g_{x+y}(i) \f$ * * "Sum Variance" \f$ = f_7 = \sum_{i}(i - f_8)^2 g_{x+y}(i) \f$ * * "Sum Entropy" \f$= f_8 = -\sum_{i}g_{x+y}(i) log (g_{x+y}(i)) \f$ * * "Difference variance" \f$ = f_10 = variance of g_{x-y}(i) \f$ * * "Difference entropy" \f$ = f_11 = -\sum_{i}g_{x-y}(i) log (g_{x-y}(i)) \f$ * * "Information Measures of Correlation IC1" \f$ = f_12 = \frac{f_9 - HXY1}{H} \f$ * * "Information Measures of Correlation IC2" \f$ = f_13 = \sqrt{1 - \exp{-2}|HXY2 - f_9|} \f$ * * Above, \f$ \mu = \f$ (weighted pixel average) \f$ = \sum_{i, j}i \cdot g(i, j) = * \sum_{i, j}j \cdot g(i, j) \f$ (due to matrix summetry), and * * \f$ \g_{x+y}(k) = \sum_{i}\sum_{j}g(i)\f$ where \f$ i+j=k \f$ and \f$ k = 2, 3, .., 2N_[g} \f$ and * * \f$ \g_{x-y}(k) = \sum_{i}\sum_{j}g(i)\f$ where \f$ i-j=k \f$ and \f$ k = 0, 1, .., N_[g}-1 \f$ * * Print references: * * Haralick, R.M., K. Shanmugam and I. Dinstein. 1973. Textural Features for * Image Classification. IEEE Transactions on Systems, Man and Cybernetics. * SMC-3(6):610-620. * * David A. Clausi and Yongping Zhao. 2002. Rapid extraction of image texture by * co-occurrence using a hybrid data structure. Comput. Geosci. 28, 6 (July * 2002), 763-774. DOI=10.1016/S0098-3004(01)00108-X * http://dx.doi.org/10.1016/S0098-3004(01)00108-X * * de O.Bastos, L.; Liatsis, P.; Conci, A., Automatic texture segmentation based * on k-means clustering and efficient calculation of co-occurrence * features. Systems, Signals and Image Processing, 2008. IWSSIP 2008. 15th * International Conference on , vol., no., pp.141,144, 25-28 June 2008 * doi: 10.1109/IWSSIP.2008.4604387 * * Neighborhood size can be set using the SetRadius() method. Offset for co-occurence estimation * is set using the SetOffset() method. * * \sa otb::ScalarImageToCooccurrenceIndexedList * \sa otb::ScalarImageToTexturesFiler * \sa otb::ScalarImageToHigherOrderTexturesFilter * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBTextures */ template class ScalarImageToAdvancedTexturesFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs */ typedef ScalarImageToAdvancedTexturesFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(ScalarImageToAdvancedTexturesFilter, ImageToImageFilter); /** Template class typedefs */ typedef TInpuImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::RegionType InputRegionType; typedef typename InputImageType::OffsetType OffsetType; typedef typename InputRegionType::SizeType SizeType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputRegionType; typedef GreyLevelCooccurrenceIndexedList< InputPixelType > CooccurrenceIndexedListType; typedef typename CooccurrenceIndexedListType::Pointer CooccurrenceIndexedListPointerType; typedef typename CooccurrenceIndexedListType::ConstPointer CooccurrenceIndexedListConstPointerType; typedef typename CooccurrenceIndexedListType::IndexType CooccurrenceIndexType; typedef typename CooccurrenceIndexedListType::PixelValueType PixelValueType; typedef typename CooccurrenceIndexedListType::RelativeFrequencyType RelativeFrequencyType; typedef typename CooccurrenceIndexedListType::VectorType VectorType; typedef typename VectorType::iterator VectorIteratorType; typedef typename VectorType::const_iterator VectorConstIteratorType; /** Set the radius of the window on which textures will be computed */ itkSetMacro(Radius, SizeType); /** Get the radius of the window on which textures will be computed */ itkGetMacro(Radius, SizeType); /** Set the offset for co-occurence computation */ itkSetMacro(Offset, OffsetType); /** Get the offset for co-occurence computation */ itkGetMacro(Offset, OffsetType); /** Set the number of bin per axis */ itkSetMacro(NumberOfBinsPerAxis, unsigned int); /** Get the number of bin per axis*/ itkGetMacro(NumberOfBinsPerAxis, unsigned int); /** Set the input image minimum */ itkSetMacro(InputImageMinimum, InputPixelType); /** Get the input image minimum */ itkGetMacro(InputImageMinimum, InputPixelType); /** Set the input image maximum */ itkSetMacro(InputImageMaximum, InputPixelType); /** Get the input image maximum */ itkGetMacro(InputImageMaximum, InputPixelType); /** Get the mean output image */ OutputImageType * GetMeanOutput(); /** Get the variance output image */ OutputImageType * GetVarianceOutput(); /** Get the dissimilarity output image */ OutputImageType * GetDissimilarityOutput(); /** Get the sum average output image */ OutputImageType * GetSumAverageOutput(); /** Get the sum of variances output image */ OutputImageType * GetSumVarianceOutput(); /** Get the sum of entropies output image */ OutputImageType * GetSumEntropyOutput(); /** Get the difference of entropies output image */ OutputImageType * GetDifferenceEntropyOutput(); /** Get the difference of variance output image */ OutputImageType * GetDifferenceVarianceOutput(); /** Get the IC1 image */ OutputImageType * GetIC1Output(); /** Get the IC2 output image */ OutputImageType * GetIC2Output(); protected: /** Constructor */ ScalarImageToAdvancedTexturesFilter(); /** Destructor */ ~ScalarImageToAdvancedTexturesFilter() ITK_OVERRIDE; /** Generate the input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Before Parallel textures extraction */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Parallel textures extraction */ void ThreadedGenerateData(const OutputRegionType& outputRegion, itk::ThreadIdType threadId) ITK_OVERRIDE; private: ScalarImageToAdvancedTexturesFilter(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Convenient method to compute union of 2 regions */ static OutputRegionType RegionUnion(const OutputRegionType& region1, const OutputRegionType& region2); /** Radius of the window on which to compute textures */ SizeType m_Radius; /** Offset for co-occurence */ OffsetType m_Offset; /** Radius of the neighborhood iterator which is minimum of m_Radius */ SizeType m_NeighborhoodRadius; /** Number of bins per axis */ unsigned int m_NumberOfBinsPerAxis; /** Input image minimum */ InputPixelType m_InputImageMinimum; /** Input image maximum */ InputPixelType m_InputImageMaximum; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbScalarImageToAdvancedTexturesFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToAdvancedTexturesFilter.txx000066400000000000000000000444751301006202600321720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToAdvancedTexturesFilter_txx #define otbScalarImageToAdvancedTexturesFilter_txx #include "otbScalarImageToAdvancedTexturesFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkNumericTraits.h" #include namespace otb { template ScalarImageToAdvancedTexturesFilter ::ScalarImageToAdvancedTexturesFilter() : m_Radius() , m_Offset() , m_NeighborhoodRadius() , m_NumberOfBinsPerAxis(8) , m_InputImageMinimum(0) , m_InputImageMaximum(255) { // There are 10 outputs corresponding to the 9 textures indices this->SetNumberOfRequiredOutputs(10); // Create the 10 outputs this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageType::New()); this->SetNthOutput(2, OutputImageType::New()); this->SetNthOutput(3, OutputImageType::New()); this->SetNthOutput(4, OutputImageType::New()); this->SetNthOutput(5, OutputImageType::New()); this->SetNthOutput(6, OutputImageType::New()); this->SetNthOutput(7, OutputImageType::New()); this->SetNthOutput(8, OutputImageType::New()); this->SetNthOutput(9, OutputImageType::New()); } template ScalarImageToAdvancedTexturesFilter ::~ScalarImageToAdvancedTexturesFilter() {} template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetMeanOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->GetOutput(0)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetVarianceOutput() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast(this->GetOutput(1)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetDissimilarityOutput() { if (this->GetNumberOfOutputs() < 3) { return ITK_NULLPTR; } return static_cast(this->GetOutput(2)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetSumAverageOutput() { if (this->GetNumberOfOutputs() < 4) { return ITK_NULLPTR; } return static_cast(this->GetOutput(3)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetSumVarianceOutput() { if (this->GetNumberOfOutputs() < 5) { return ITK_NULLPTR; } return static_cast(this->GetOutput(4)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetSumEntropyOutput() { if (this->GetNumberOfOutputs() < 6) { return ITK_NULLPTR; } return static_cast(this->GetOutput(5)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetDifferenceEntropyOutput() { if (this->GetNumberOfOutputs() < 7) { return ITK_NULLPTR; } return static_cast(this->GetOutput(6)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetDifferenceVarianceOutput() { if (this->GetNumberOfOutputs() < 8) { return ITK_NULLPTR; } return static_cast(this->GetOutput(7)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetIC1Output() { if (this->GetNumberOfOutputs() < 9) { return ITK_NULLPTR; } return static_cast(this->GetOutput(8)); } template typename ScalarImageToAdvancedTexturesFilter ::OutputImageType * ScalarImageToAdvancedTexturesFilter ::GetIC2Output() { if (this->GetNumberOfOutputs() < 10) { return ITK_NULLPTR; } return static_cast(this->GetOutput(9)); } template void ScalarImageToAdvancedTexturesFilter ::GenerateInputRequestedRegion() { // First, call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast(this->GetInput()); OutputImagePointerType outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // Retrieve the output requested region // We use only the first output since requested regions for all outputs are enforced to be equal // by the default GenerateOutputRequestedRegiont() implementation OutputRegionType outputRequestedRegion = outputPtr->GetRequestedRegion(); typename OutputRegionType::IndexType outputIndex = outputRequestedRegion.GetIndex(); typename OutputRegionType::SizeType outputSize = outputRequestedRegion.GetSize(); typename InputRegionType::IndexType inputIndex; typename InputRegionType::SizeType inputSize; // First, apply offset for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputIndex[dim] = std::min(outputIndex[dim], outputIndex[dim] + m_Offset[dim]); inputSize[dim] = std::max(outputIndex[dim] + outputSize[dim], outputIndex[dim] + outputSize[dim] + m_Offset[dim]) - inputIndex[dim]; } // Build the input requested region InputRegionType inputRequestedRegion; inputRequestedRegion.SetIndex(inputIndex); inputRequestedRegion.SetSize(inputSize); // Apply the radius inputRequestedRegion.PadByRadius(m_Radius); // Try to apply the requested region to the input image if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); } else { // Build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void ScalarImageToAdvancedTexturesFilter ::BeforeThreadedGenerateData() { unsigned int minRadius = 0; for ( unsigned int i = 0; i < m_Offset.GetOffsetDimension(); i++ ) { unsigned int distance = vcl_abs(m_Offset[i]); if ( distance > minRadius ) { minRadius = distance; } } m_NeighborhoodRadius.Fill(minRadius); } template void ScalarImageToAdvancedTexturesFilter ::ThreadedGenerateData(const OutputRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast(this->GetInput()); OutputImagePointerType meanPtr = this->GetMeanOutput(); OutputImagePointerType variancePtr = this->GetVarianceOutput(); OutputImagePointerType dissimilarityPtr = this->GetDissimilarityOutput(); OutputImagePointerType sumAveragePtr = this->GetSumAverageOutput(); OutputImagePointerType sumVariancePtr = this->GetSumVarianceOutput(); OutputImagePointerType sumEntropytPtr = this->GetSumEntropyOutput(); OutputImagePointerType differenceEntropyPtr = this->GetDifferenceEntropyOutput(); OutputImagePointerType differenceVariancePtr = this->GetDifferenceVarianceOutput(); OutputImagePointerType ic1Ptr = this->GetIC1Output(); OutputImagePointerType ic2Ptr = this->GetIC2Output(); // Build output iterators itk::ImageRegionIteratorWithIndex varianceIt(variancePtr, outputRegionForThread); itk::ImageRegionIterator meanIt(meanPtr, outputRegionForThread); itk::ImageRegionIterator dissimilarityIt(dissimilarityPtr, outputRegionForThread); itk::ImageRegionIterator sumAverageIt(sumAveragePtr, outputRegionForThread); itk::ImageRegionIterator sumVarianceIt(sumVariancePtr, outputRegionForThread); itk::ImageRegionIterator sumEntropytIt(sumEntropytPtr, outputRegionForThread); itk::ImageRegionIterator differenceEntropyIt(differenceEntropyPtr, outputRegionForThread); itk::ImageRegionIterator differenceVarianceIt(differenceVariancePtr, outputRegionForThread); itk::ImageRegionIterator ic1It(ic1Ptr, outputRegionForThread); itk::ImageRegionIterator ic2It(ic2Ptr, outputRegionForThread); // Go to begin varianceIt.GoToBegin(); meanIt.GoToBegin(); dissimilarityIt.GoToBegin(); sumAverageIt.GoToBegin(); sumVarianceIt.GoToBegin(); sumEntropytIt.GoToBegin(); differenceEntropyIt.GoToBegin(); differenceVarianceIt.GoToBegin(); ic1It.GoToBegin(); ic2It.GoToBegin(); const double log2 = vcl_log(2.0); const unsigned int histSize = m_NumberOfBinsPerAxis; const long unsigned int twiceHistSize = 2 * m_NumberOfBinsPerAxis; // Set-up progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Iterate on outputs to compute textures while (!varianceIt.IsAtEnd() && !meanIt.IsAtEnd() && !dissimilarityIt.IsAtEnd() && !sumAverageIt.IsAtEnd() && !sumVarianceIt.IsAtEnd() && !sumEntropytIt.IsAtEnd() && !differenceEntropyIt.IsAtEnd() && !differenceVarianceIt.IsAtEnd() && !ic1It.IsAtEnd() && !ic2It.IsAtEnd()) { // Compute the region on which co-occurence will be estimated typename InputRegionType::IndexType inputIndex; typename InputRegionType::SizeType inputSize; // First, create an window for neighborhood iterator based on m_Radius // For example, if xradius and yradius is 2. window size is 5x5 (2 * radius + 1). for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputIndex[dim] = varianceIt.GetIndex()[dim] - m_Radius[dim]; inputSize[dim] = 2 * m_Radius[dim] + 1; } // Build the input region InputRegionType inputRegion; inputRegion.SetIndex(inputIndex); inputRegion.SetSize(inputSize); inputRegion.Crop(inputPtr->GetRequestedRegion()); CooccurrenceIndexedListPointerType GLCIList = CooccurrenceIndexedListType::New(); GLCIList->Initialize(m_NumberOfBinsPerAxis, m_InputImageMinimum, m_InputImageMaximum); typedef itk::ConstNeighborhoodIterator< InputImageType > NeighborhoodIteratorType; NeighborhoodIteratorType neighborIt; neighborIt = NeighborhoodIteratorType(m_NeighborhoodRadius, inputPtr, inputRegion); for ( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt ) { const InputPixelType centerPixelIntensity = neighborIt.GetCenterPixel(); bool pixelInBounds; const InputPixelType pixelIntensity = neighborIt.GetPixel(m_Offset, pixelInBounds); if ( !pixelInBounds ) { continue; // don't put a pixel in the co-occurrence list if the value is // out of bounds } GLCIList->AddPixelPair(centerPixelIntensity, pixelIntensity); } PixelValueType m_Mean = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_Variance = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_Dissimilarity = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_SumAverage = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_SumEntropy = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_SumVariance = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_DifferenceEntropy = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_DifferenceVariance = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_IC1 = itk::NumericTraits< PixelValueType >::Zero; PixelValueType m_IC2 = itk::NumericTraits< PixelValueType >::Zero; double Entropy = 0; typedef itk::Array DoubleArrayType; DoubleArrayType hx(histSize); DoubleArrayType hy(histSize); DoubleArrayType pdxy(twiceHistSize); for(long unsigned int i = 0; i < histSize; i++) { hx[i] = 0.0; hy[i] = 0.0; pdxy[i] = 0.0; } for(long unsigned int i = histSize; i < twiceHistSize; i++) { pdxy[i] = 0.0; } /* hx.Fill(0.0); hy.Fill(0.0); pdxy.Fill(0.0); */ double hxy1 = 0; //get co-occurrence vector and totalfrequency VectorType glcVector = GLCIList->GetVector(); double totalFrequency = static_cast (GLCIList->GetTotalFrequency()); VectorConstIteratorType constVectorIt; //Normalize the GreyLevelCooccurrenceListType //Compute Mean, Entropy (f12), hx, hy, pdxy constVectorIt = glcVector.begin(); while( constVectorIt != glcVector.end()) { CooccurrenceIndexType index = (*constVectorIt).first; double frequency = (*constVectorIt).second / totalFrequency; m_Mean += static_cast(index[0]) * frequency; Entropy -= (frequency > 0.0001) ? frequency * vcl_log(frequency) / log2 : 0.; unsigned int i = index[1]; unsigned int j = index[0]; hx[j] += frequency; hy[i] += frequency; if( i+j > histSize-1) { pdxy[i+j] += frequency; } if( i <= j ) { pdxy[j-i] += frequency; } ++constVectorIt; } //second pass over normalized co-occurrence list to find variance and pipj. //pipj is needed to calculate f11 constVectorIt = glcVector.begin(); while( constVectorIt != glcVector.end()) { double frequency = (*constVectorIt).second / totalFrequency; CooccurrenceIndexType index = (*constVectorIt).first; unsigned int i = index[1]; unsigned int j = index[0]; double index0 = static_cast(index[0]); m_Variance += ((index0 - m_Mean) * (index0 - m_Mean)) * frequency; double pipj = hx[j] * hy[i]; hxy1 -= (pipj > 0.0001) ? frequency * vcl_log(pipj) : 0.; ++constVectorIt; } //iterate histSize to compute sumEntropy double PSSquareCumul = 0; for(long unsigned int k = histSize; k < twiceHistSize; k++) { m_SumAverage += k * pdxy[k]; m_SumEntropy -= (pdxy[k] > 0.0001) ? pdxy[k] * vcl_log(pdxy[k]) / log2 : 0; PSSquareCumul += k * k * pdxy[k]; } m_SumVariance = PSSquareCumul - m_SumAverage * m_SumAverage; double PDSquareCumul = 0; double PDCumul = 0; double hxCumul = 0; double hyCumul = 0; for (long unsigned int i = 0; i < histSize; ++i) { double pdTmp = pdxy[i]; PDCumul += i * pdTmp; m_DifferenceEntropy -= (pdTmp > 0.0001) ? pdTmp * vcl_log(pdTmp) / log2 : 0; PDSquareCumul += i * i * pdTmp; //comput hxCumul and hyCumul double marginalfreq = hx[i]; hxCumul += (marginalfreq > 0.0001) ? vcl_log (marginalfreq) * marginalfreq : 0; marginalfreq = hy[i]; hyCumul += (marginalfreq > 0.0001) ? vcl_log (marginalfreq) * marginalfreq : 0; } m_DifferenceVariance = PDSquareCumul - PDCumul * PDCumul; /* pipj computed below is totally different from earlier one which was used * to compute hxy1. */ double hxy2 = 0; for(unsigned int i = 0; i < histSize; ++i) { for(unsigned int j = 0; j < histSize; ++j) { double pipj = hx[j] * hy[i]; hxy2 -= (pipj > 0.0001) ? pipj * vcl_log(pipj) : 0.; double frequency = GLCIList->GetFrequency(i,j, glcVector) / totalFrequency; m_Dissimilarity+= ( static_cast(j) - static_cast(i) ) * (frequency * frequency); } } //Information measures of correlation 1 & 2 m_IC1 = (vcl_abs(std::max (hxCumul, hyCumul)) > 0.0001) ? (Entropy - hxy1) / (std::max (hxCumul, hyCumul)) : 0; m_IC2 = 1 - vcl_exp (-2. * vcl_abs (hxy2 - Entropy)); m_IC2 = (m_IC2 >= 0) ? vcl_sqrt (m_IC2) : 0; // Fill outputs meanIt.Set(m_Mean); varianceIt.Set(m_Variance); dissimilarityIt.Set(m_Dissimilarity); sumAverageIt.Set(m_SumAverage); sumVarianceIt.Set(m_SumVariance); sumEntropytIt.Set(m_SumEntropy); differenceEntropyIt.Set(m_DifferenceEntropy); differenceVarianceIt.Set(m_DifferenceVariance); ic1It.Set(m_IC1); ic2It.Set(m_IC2); // Update progress progress.CompletedPixel(); // Increment iterators ++varianceIt; ++meanIt; ++dissimilarityIt; ++sumAverageIt; ++sumVarianceIt; ++sumEntropytIt; ++differenceEntropyIt; ++differenceVarianceIt; ++ic1It; ++ic2It; } } } // End namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToHigherOrderTexturesFilter.h000066400000000000000000000212031301006202600322530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToHigherOrderTexturesFilter_h #define otbScalarImageToHigherOrderTexturesFilter_h #include "itkImageToImageFilter.h" #include "itkScalarImageToRunLengthFeaturesFilter.h" namespace otb { /** \class ScalarImageToHigherOrderTexturesFilter * \brief This class compute 11 local higher order statistics textures coefficients * based on the grey level run-length matrix * * This filter computes the following Haralick textures over a sliding window with * user defined radius: * (where \f$ p(i, j) \f$ is the element in * cell i, j of a normalized Run Length Matrix, * \f$n_r\f$ is the total number of runs * and \f$n_p\f$ is the total number of pixels ): * * "Short Run Emphasis" \f$ = SRE = \frac{1}{n_r} \sum_{i, j}\frac{p(i, j)}{j^2} \f$ * * "Long Run Emphasis" \f$ = LRE = \frac{1}{n_r} \sum_{i, j}p(i, j) * j^2 \f$ * * "Grey-Level Nonuniformity" \f$ = GLN = \frac{1}{n_r} \sum_{i} \left( \sum_{j}{p(i, j)} \right)^2 \f$ * * "Run Length Nonuniformity" \f$ = RLN = \frac{1}{n_r} \sum_{j} \left( \sum_{i}{p(i, j)} \right)^2 \f$ * * "Low Grey-Level Run Emphasis" \f$ = LGRE = \frac{1}{n_r} \sum_{i, j}\frac{p(i, j)}{i^2} \f$ * * "High Grey-Level Run Emphasis" \f$ = HGRE = \frac{1}{n_r} \sum_{i, j}p(i, j) * i^2 \f$ * * "Short Run Low Grey-Level Emphasis" \f$ = SRLGE = \frac{1}{n_r} \sum_{i, j}\frac{p(i, j)}{i^2 j^2} \f$ * * "Short Run High Grey-Level Emphasis" \f$ = SRHGE = \frac{1}{n_r} \sum_{i, j}\frac{p(i, j) * i^2}{j^2} \f$ * * "Long Run Low Grey-Level Emphasis" \f$ = LRLGE = \frac{1}{n_r} \sum_{i, j}\frac{p(i, j) * j^2}{i^2} \f$ * * "Long Run High Grey-Level Emphasis" \f$ = LRHGE = \frac{1}{n_r} \sum_{i, j} p(i, j) i^2 j^2 \f$ * * Neighborhood size can be set using the SetRadius() method. Offset for co-occurence estimation * is set using the SetOffset() method. * * \sa otb::MaskedScalarImageToGreyLevelRunLengthMatrixGenerator * \sa itk::GreyLevelRunLengthMatrixTextureCoefficientsCalculator * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBTextures */ template class ScalarImageToHigherOrderTexturesFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs */ typedef ScalarImageToHigherOrderTexturesFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(ScalarImageToHigherOrderTexturesFilter, ImageToImageFilter); /** Template class typedefs */ typedef TInpuImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::RegionType InputRegionType; typedef typename InputRegionType::SizeType SizeType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputRegionType; /** Co-occurence matrix and textures calculator */ /* typedef otb::MaskedScalarImageToGreyLevelRunLengthMatrixGenerator RunLengthMatrixGeneratorType; typedef typename RunLengthMatrixGeneratorType::Pointer RunLengthMatrixGeneratorPointerType; typedef typename RunLengthMatrixGeneratorType::OffsetType OffsetType; typedef typename RunLengthMatrixGeneratorType::HistogramType HistogramType; typedef itk::Statistics::GreyLevelRunLengthMatrixTextureCoefficientsCalculator TextureCoefficientsCalculatorType; typedef typename TextureCoefficientsCalculatorType::Pointer TextureCoefficientsCalculatorPointerType; */ typedef itk::Statistics::ScalarImageToRunLengthFeaturesFilter ScalarImageToRunLengthFeaturesFilterType; //typedef typename ImageType::PixelType PixelType; typedef typename InputImageType::OffsetType OffsetType; typedef itk::VectorContainer< unsigned char, OffsetType > OffsetVector; typedef typename OffsetVector::Pointer OffsetVectorPointer; typedef typename OffsetVector::ConstPointer OffsetVectorConstPointer; /** Set the radius of the window on which textures will be computed */ itkSetMacro(Radius, SizeType); /** Get the radius of the window on which textures will be computed */ itkGetMacro(Radius, SizeType); /** Get/Set the offset or offsets over which the co-occurrence pairs will be computed. Calling either of these methods clears the previous offsets. */ itkSetConstObjectMacro(Offsets, OffsetVector); itkGetConstObjectMacro(Offsets, OffsetVector); void SetOffset(const OffsetType offset); /** Set the number of bin per axis for histogram generation */ itkSetMacro(NumberOfBinsPerAxis, unsigned int); /** Get the number of bin per axis for histogram generation */ itkGetMacro(NumberOfBinsPerAxis, unsigned int); /** Set the input image minimum */ itkSetMacro(InputImageMinimum, InputPixelType); /** Get the input image minimum */ itkGetMacro(InputImageMinimum, InputPixelType); /** Set the input image maximum */ itkSetMacro(InputImageMaximum, InputPixelType); /** Get the input image maximum */ itkGetMacro(InputImageMaximum, InputPixelType); /* Enable/Disable fast calculation */ itkGetConstMacro(FastCalculations, bool); itkSetMacro(FastCalculations, bool); itkBooleanMacro(FastCalculations); /** Get the Short Run Emphasis output image */ OutputImageType * GetShortRunEmphasisOutput(); /** Get the Long Run Emphasis output image */ OutputImageType * GetLongRunEmphasisOutput(); /** Get the Grey-Level Nonuniformity output image */ OutputImageType * GetGreyLevelNonuniformityOutput(); /** Get the Run Length Nonuniformity output image */ OutputImageType * GetRunLengthNonuniformityOutput(); /** Get the Run Percentage output image */ OutputImageType * GetRunPercentageOutput(); /** Get the Low Grey-Level Run Emphasis output image */ OutputImageType * GetLowGreyLevelRunEmphasisOutput(); /** Get the High Grey-Level Run Emphasis output image */ OutputImageType * GetHighGreyLevelRunEmphasisOutput(); /** Get the Short Run Low Grey-Level Emphasis output image */ OutputImageType * GetShortRunLowGreyLevelEmphasisOutput(); /** Get the Short Run High Grey-Level Emphasis output image */ OutputImageType * GetShortRunHighGreyLevelEmphasisOutput(); /** Get the Long Run Low Grey-Level Emphasis output image */ OutputImageType * GetLongRunLowGreyLevelEmphasisOutput(); /** Get the Long Run High Grey-Level Emphasis output image */ OutputImageType * GetLongRunHighGreyLevelEmphasisOutput(); protected: /** Constructor */ ScalarImageToHigherOrderTexturesFilter(); /** Destructor */ ~ScalarImageToHigherOrderTexturesFilter() ITK_OVERRIDE; /** Generate the input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Parallel textures extraction */ void ThreadedGenerateData(const OutputRegionType& outputRegion, itk::ThreadIdType threadId) ITK_OVERRIDE; private: ScalarImageToHigherOrderTexturesFilter(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Convenient method to compute union of 2 regions */ static OutputRegionType RegionUnion(const OutputRegionType& region1, const OutputRegionType& region2); /** Radius of the window on which to compute textures */ SizeType m_Radius; /** Offset for co-occurence */ OffsetVectorConstPointer m_Offsets; /** Number of bins per axis for histogram generation */ unsigned int m_NumberOfBinsPerAxis; /** Input image minimum */ InputPixelType m_InputImageMinimum; /** Input image maximum */ InputPixelType m_InputImageMaximum; /** Fast calculation */ bool m_FastCalculations; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbScalarImageToHigherOrderTexturesFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToHigherOrderTexturesFilter.txx000066400000000000000000000307731301006202600326630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToHigherOrderTexturesFilter_txx #define otbScalarImageToHigherOrderTexturesFilter_txx #include "otbScalarImageToHigherOrderTexturesFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template ScalarImageToHigherOrderTexturesFilter ::ScalarImageToHigherOrderTexturesFilter() : m_Radius(), m_NumberOfBinsPerAxis(8), m_InputImageMinimum(0), m_InputImageMaximum(255), m_FastCalculations(false) { // There are 11 outputs corresponding to the 8 textures indices this->SetNumberOfRequiredOutputs(10); // Create the 11 outputs this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageType::New()); this->SetNthOutput(2, OutputImageType::New()); this->SetNthOutput(3, OutputImageType::New()); this->SetNthOutput(4, OutputImageType::New()); this->SetNthOutput(5, OutputImageType::New()); this->SetNthOutput(6, OutputImageType::New()); this->SetNthOutput(7, OutputImageType::New()); this->SetNthOutput(8, OutputImageType::New()); this->SetNthOutput(9, OutputImageType::New()); this->SetNthOutput(10, OutputImageType::New()); m_Radius.Fill(10); // Set the offset directions to their defaults: half of all the possible // directions 1 pixel away. (The other half is included by symmetry.) // We use a neighborhood iterator to calculate the appropriate offsets. typedef itk::Neighborhood NeighborhoodType; NeighborhoodType hood; hood.SetRadius( 1 ); // select all "previous" neighbors that are face+edge+vertex // connected to the current pixel. do not include the center pixel. unsigned int centerIndex = hood.GetCenterNeighborhoodIndex(); OffsetVectorPointer offsets = OffsetVector::New(); for( unsigned int d = 0; d < centerIndex; d++ ) { OffsetType offset = hood.GetOffset( d ); offsets->push_back( offset ); } this->SetOffsets( offsets ); } template ScalarImageToHigherOrderTexturesFilter ::~ScalarImageToHigherOrderTexturesFilter() {} template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetShortRunEmphasisOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->GetOutput(0)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetLongRunEmphasisOutput() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast(this->GetOutput(1)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetGreyLevelNonuniformityOutput() { if (this->GetNumberOfOutputs() < 3) { return ITK_NULLPTR; } return static_cast(this->GetOutput(2)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetRunLengthNonuniformityOutput() { if (this->GetNumberOfOutputs() < 4) { return ITK_NULLPTR; } return static_cast(this->GetOutput(3)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetRunPercentageOutput() { if (this->GetNumberOfOutputs() < 5) { return ITK_NULLPTR; } return static_cast(this->GetOutput(4)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetLowGreyLevelRunEmphasisOutput() { if (this->GetNumberOfOutputs() < 6) { return ITK_NULLPTR; } return static_cast(this->GetOutput(5)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetHighGreyLevelRunEmphasisOutput() { if (this->GetNumberOfOutputs() < 7) { return ITK_NULLPTR; } return static_cast(this->GetOutput(6)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetShortRunLowGreyLevelEmphasisOutput() { if (this->GetNumberOfOutputs() < 8) { return ITK_NULLPTR; } return static_cast(this->GetOutput(7)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetShortRunHighGreyLevelEmphasisOutput() { if (this->GetNumberOfOutputs() < 9) { return ITK_NULLPTR; } return static_cast(this->GetOutput(8)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetLongRunLowGreyLevelEmphasisOutput() { if (this->GetNumberOfOutputs() < 10) { return ITK_NULLPTR; } return static_cast(this->GetOutput(9)); } template typename ScalarImageToHigherOrderTexturesFilter ::OutputImageType * ScalarImageToHigherOrderTexturesFilter ::GetLongRunHighGreyLevelEmphasisOutput() { if (this->GetNumberOfOutputs() < 11) { return ITK_NULLPTR; } return static_cast(this->GetOutput(10)); } template void ScalarImageToHigherOrderTexturesFilter ::SetOffset( const OffsetType offset ) { OffsetVectorPointer offsetVector = OffsetVector::New(); offsetVector->push_back( offset ); this->SetOffsets( offsetVector ); } template void ScalarImageToHigherOrderTexturesFilter ::GenerateInputRequestedRegion() { // First, call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast(this->GetInput()); OutputImagePointerType outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // Retrieve the output requested region // We use only the first output since requested regions for all outputs are enforced to be equal // by the default GenerateOutputRequestedRegiont() implementation OutputRegionType outputRequestedRegion = outputPtr->GetRequestedRegion(); InputRegionType inputRequestedRegion = outputRequestedRegion; // Apply the radius inputRequestedRegion.PadByRadius(m_Radius); // Try to apply the requested region to the input image if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); } else { // Build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void ScalarImageToHigherOrderTexturesFilter ::ThreadedGenerateData(const OutputRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast(this->GetInput()); typedef typename itk::ImageRegionIterator IteratorType; std::vector outputImagesIterators; for (unsigned int i = 0; i < 10; ++i) { outputImagesIterators.push_back( IteratorType(this->GetOutput(i), outputRegionForThread) ); outputImagesIterators[i].GoToBegin(); } // Compute the max possible run length (in physical unit) typename InputImageType::PointType topLeftPoint; typename InputImageType::PointType bottomRightPoint; inputPtr->TransformIndexToPhysicalPoint( outputImagesIterators[0].GetIndex() - m_Radius, topLeftPoint ); inputPtr->TransformIndexToPhysicalPoint( outputImagesIterators[0].GetIndex() + m_Radius, bottomRightPoint ); double maxDistance = topLeftPoint.EuclideanDistanceTo(bottomRightPoint); // Set-up progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Iterate on outputs to compute textures while ( !outputImagesIterators[0].IsAtEnd() ) { // Compute the region on which run-length matrix will be estimated typename InputRegionType::IndexType inputIndex = outputImagesIterators[0].GetIndex() - m_Radius; typename InputRegionType::SizeType inputSize; // First, apply offset for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputSize[dim] = 2 * m_Radius[dim] + 1; } // Build the input region InputRegionType inputRegion; inputRegion.SetIndex(inputIndex); inputRegion.SetSize(inputSize); inputRegion.Crop(inputPtr->GetBufferedRegion()); // Create a local image corresponding to the input region InputImagePointerType localInputImage = InputImageType::New(); localInputImage->SetRegions(inputRegion); localInputImage->Allocate(); typedef itk::ImageRegionIteratorWithIndex ImageRegionIteratorType; ImageRegionIteratorType itInputPtr(inputPtr, inputRegion); ImageRegionIteratorType itLocalInputImage(localInputImage, inputRegion); for (itInputPtr.GoToBegin(), itLocalInputImage.GoToBegin(); !itInputPtr.IsAtEnd(); ++itInputPtr, ++itLocalInputImage) { itLocalInputImage.Set(itInputPtr.Get()); } typename ScalarImageToRunLengthFeaturesFilterType::Pointer runLengthFeatureCalculator = ScalarImageToRunLengthFeaturesFilterType::New(); runLengthFeatureCalculator->SetInput(localInputImage); runLengthFeatureCalculator->SetOffsets(m_Offsets); runLengthFeatureCalculator->SetNumberOfBinsPerAxis(m_NumberOfBinsPerAxis); runLengthFeatureCalculator->SetPixelValueMinMax(m_InputImageMinimum, m_InputImageMaximum); runLengthFeatureCalculator->SetDistanceValueMinMax(0, maxDistance); runLengthFeatureCalculator->Update(); typename ScalarImageToRunLengthFeaturesFilterType::FeatureValueVector& featuresMeans = *(runLengthFeatureCalculator->GetFeatureMeans().GetPointer()); // Fill outputs outputImagesIterators[0].Set(featuresMeans[0]); outputImagesIterators[1].Set(featuresMeans[1]); outputImagesIterators[2].Set(featuresMeans[2]); outputImagesIterators[3].Set(featuresMeans[3]); outputImagesIterators[4].Set(featuresMeans[4]); outputImagesIterators[5].Set(featuresMeans[5]); outputImagesIterators[6].Set(featuresMeans[6]); outputImagesIterators[7].Set(featuresMeans[7]); outputImagesIterators[8].Set(featuresMeans[8]); outputImagesIterators[9].Set(featuresMeans[9]); // Update progress progress.CompletedPixel(); // Increment iterators for (unsigned int i = 0; i < 10; ++i) { ++outputImagesIterators[i]; } } } } // End namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToPanTexTextureFilter.h000066400000000000000000000126311301006202600310720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToPanTexTextureFilter_h #define otbScalarImageToPanTexTextureFilter_h #include "otbGreyLevelCooccurrenceIndexedList.h" #include "itkImageToImageFilter.h" namespace otb { /** \class ScalarImageToPanTexTextureFilter * \brief This class computes a texture derived built-up precense index (PanTex) * * This class computes a texture-derived built-up presence index (PanTex) from textural * characteristics of scalar images.It is the min value of the contrast in 8 directions. * * Print references: * * Pesari, M., A. Gerhardinger, F. Kayitakire. 2008. A robust built-up area precense * index by anisotropic rotation-invariant textural measure. * IEEE Journal of selected topics in applied earth observations and remote sensing. * Vol1, NO3. * * * \sa otb::GreyLevelCooccurrenceIndexedList * * * \ingroup OTBTextures */ template class ScalarImageToPanTexTextureFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs */ typedef ScalarImageToPanTexTextureFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(ScalarImageToPanTexTextureFilter, ImageToImageFilter); /** Template class typedefs */ typedef TInpuImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::RegionType InputRegionType; typedef typename InputRegionType::SizeType SizeType; typedef typename InputImageType::OffsetType OffsetType; typedef typename std::vector< OffsetType> OffsetListType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputRegionType; typedef GreyLevelCooccurrenceIndexedList< InputPixelType > CooccurrenceIndexedListType; typedef typename CooccurrenceIndexedListType::Pointer CooccurrenceIndexedListPointerType; typedef typename CooccurrenceIndexedListType::ConstPointer CooccurrenceIndexedListConstPointerType; typedef typename CooccurrenceIndexedListType::IndexType CooccurrenceIndexType; typedef typename CooccurrenceIndexedListType::PixelValueType PixelValueType; typedef typename CooccurrenceIndexedListType::RelativeFrequencyType RelativeFrequencyType; typedef typename CooccurrenceIndexedListType::VectorType VectorType; typedef typename VectorType::iterator VectorIteratorType; typedef typename VectorType::const_iterator VectorConstIteratorType; /** Set the radius of the window on which textures will be computed */ itkSetMacro(Radius, SizeType); /** Get the radius of the window on which textures will be computed */ itkGetMacro(Radius, SizeType); /** Set the number of bin per axis for histogram generation */ itkSetMacro(NumberOfBinsPerAxis, unsigned int); /** Get the number of bin per axis for histogram generation */ itkGetMacro(NumberOfBinsPerAxis, unsigned int); /** Set the input image minimum */ itkSetMacro(InputImageMinimum, InputPixelType); /** Get the input image minimum */ itkGetMacro(InputImageMinimum, InputPixelType); /** Set the input image maximum */ itkSetMacro(InputImageMaximum, InputPixelType); /** Get the input image maximum */ itkGetMacro(InputImageMaximum, InputPixelType); protected: /** Constructor */ ScalarImageToPanTexTextureFilter(); /** Destructor */ ~ScalarImageToPanTexTextureFilter() ITK_OVERRIDE; /** Generate the input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Parallel textures extraction */ void ThreadedGenerateData(const OutputRegionType& outputRegion, itk::ThreadIdType threadId) ITK_OVERRIDE; private: ScalarImageToPanTexTextureFilter(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Convenient method to compute union of 2 regions */ static OutputRegionType RegionUnion(const OutputRegionType& region1, const OutputRegionType& region2); /** Radius of the window on which to compute textures */ SizeType m_Radius; /** List of Offsets for co-occurence */ OffsetListType m_OffsetList; /** Number of bins per axis for histogram generation */ unsigned int m_NumberOfBinsPerAxis; /** Input image minimum */ InputPixelType m_InputImageMinimum; /** Input image maximum */ InputPixelType m_InputImageMaximum; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbScalarImageToPanTexTextureFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToPanTexTextureFilter.txx000066400000000000000000000165621301006202600314750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToPanTexTextureFilter_txx #define otbScalarImageToPanTexTextureFilter_txx #include "otbScalarImageToPanTexTextureFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkNumericTraits.h" namespace otb { template ScalarImageToPanTexTextureFilter ::ScalarImageToPanTexTextureFilter() : m_Radius(), m_NumberOfBinsPerAxis(8), m_InputImageMinimum(0), m_InputImageMaximum(255) { // There are 1 output corresponding to the Pan Tex texture indice this->SetNumberOfRequiredOutputs(1); //Fill the offset list for contrast computation OffsetType off; off[0] = 0; off[1] = 1; m_OffsetList.push_back(off); //(0, 1) off[1] = 2; m_OffsetList.push_back(off); //(0, 2) off[0] = 1; off[1] = -2; m_OffsetList.push_back(off); //(1, -2) off[1] = -1; m_OffsetList.push_back(off); //(1, -1) off[1] = 0; m_OffsetList.push_back(off); //(1, 0) off[1] = 1; m_OffsetList.push_back(off); //(1, 1) off[1] = 2; m_OffsetList.push_back(off); //(1, 2) off[0] = 2; off[1] = -1; m_OffsetList.push_back(off); //(2, -1) off[1] = 0; m_OffsetList.push_back(off); //(2, 0) off[1] = 1; m_OffsetList.push_back(off); //(2, 1) } template ScalarImageToPanTexTextureFilter ::~ScalarImageToPanTexTextureFilter() {} template void ScalarImageToPanTexTextureFilter ::GenerateInputRequestedRegion() { // First, call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast(this->GetInput()); OutputImagePointerType outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // Retrieve the output requested region // We use only the first output since requested regions for all outputs are enforced to be equal // by the default GenerateOutputRequestedRegiont() implementation OutputRegionType outputRequestedRegion = outputPtr->GetRequestedRegion(); // Build the input requested region InputRegionType inputRequestedRegion = outputRequestedRegion; // Apply the radius SizeType maxOffsetSize; maxOffsetSize[0] = 2; maxOffsetSize[1] = 2; inputRequestedRegion.PadByRadius(m_Radius + maxOffsetSize); // Try to apply the requested region to the input image if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); } else { // Build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void ScalarImageToPanTexTextureFilter ::ThreadedGenerateData(const OutputRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast (this->GetInput()); OutputImagePointerType outputPtr = this->GetOutput(); itk::ImageRegionIteratorWithIndex outputIt(outputPtr, outputRegionForThread); // Go to begin outputIt.GoToBegin(); // Set-up progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Iterate on outputs to compute textures while (!outputIt.IsAtEnd()) { // Initialise output value double out = itk::NumericTraits::max(); // For each offset typename OffsetListType::const_iterator offIt; for (offIt = m_OffsetList.begin(); offIt != m_OffsetList.end(); ++offIt) { OffsetType currentOffset = *offIt; // Compute the region on which co-occurence will be estimated typename InputRegionType::IndexType inputIndex; typename InputRegionType::SizeType inputSize; // First, create an window for neighborhood iterator based on m_Radius // For example, if xradius and yradius is 2. window size is 5x5 (2 * // radius + 1). for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputIndex[dim] = outputIt.GetIndex()[dim] - m_Radius[dim]; inputSize[dim] = 2 * m_Radius[dim] + 1; } // Build the input region InputRegionType inputRegion; inputRegion.SetIndex(inputIndex); inputRegion.SetSize(inputSize); inputRegion.Crop(inputPtr->GetRequestedRegion()); SizeType neighborhoodRadius; /** calculate minimum offset and set it as neighborhood radius **/ unsigned int minRadius = 0; for ( unsigned int i = 0; i < currentOffset.GetOffsetDimension(); i++ ) { unsigned int distance = vcl_abs(currentOffset[i]); if ( distance > minRadius ) { minRadius = distance; } } neighborhoodRadius.Fill(minRadius); CooccurrenceIndexedListPointerType GLCIList = CooccurrenceIndexedListType::New(); GLCIList->Initialize(m_NumberOfBinsPerAxis, m_InputImageMinimum, m_InputImageMaximum); typedef itk::ConstNeighborhoodIterator< InputImageType > NeighborhoodIteratorType; NeighborhoodIteratorType neighborIt; neighborIt = NeighborhoodIteratorType(neighborhoodRadius, inputPtr, inputRegion); for ( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt ) { const InputPixelType centerPixelIntensity = neighborIt.GetCenterPixel(); bool pixelInBounds; const InputPixelType pixelIntensity = neighborIt.GetPixel(currentOffset, pixelInBounds); if ( !pixelInBounds ) { continue; // don't put a pixel in the histogram if it's out-of-bounds. } GLCIList->AddPixelPair(centerPixelIntensity, pixelIntensity); } VectorConstIteratorType constVectorIt; VectorType glcVector = GLCIList->GetVector(); double totalFrequency = static_cast (GLCIList->GetTotalFrequency()); //Compute inertia aka contrast double inertia = 0; constVectorIt = glcVector.begin(); while( constVectorIt != glcVector.end()) { CooccurrenceIndexType index = (*constVectorIt).first; RelativeFrequencyType frequency = (*constVectorIt).second / totalFrequency; inertia += ( index[0] - index[1] ) * ( index[0] - index[1] ) * frequency; ++constVectorIt; } if (inertia < out) { out = inertia; } } outputIt.Set(out); ++outputIt; progress.CompletedPixel(); } } } // End namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToTexturesFilter.h000066400000000000000000000220511301006202600301320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToTexturesFilter_h #define otbScalarImageToTexturesFilter_h #include "otbGreyLevelCooccurrenceIndexedList.h" #include "itkImageToImageFilter.h" namespace otb { /** * \class ScalarImageToTexturesFilter * \brief This class compute 8 local Haralick textures features. The 8 output * image channels are: Energy, Entropy, Correlation, Inverse Difference Moment, * Inertia, Cluster Shade, Cluster Prominence and Haralick Correlation. They * are provided in this exact order in the output image. Thus, this application * computes the following Haralick textures over a neighborhood with user * defined radius. * * To improve the speed of computation, a variant of Grey Level Co-occurrence * Matrix(GLCM) called Grey Level Co-occurrence Indexed List (GLCIL) is * used. Given below is the mathematical explanation on the computation of each * textures. Here $ g(i, j) $ is the frequency of element in the GLCIL whose * index is i, j. GLCIL stores a pair of frequency of two pixels from the given * offset and the cell index (i, j) of the pixel in the neighborhood * window. :(where each element in GLCIL is a pair of pixel index and it's * frequency, $ g(i, j) $ is the frequency value of the pair having index is i, j). * * "Energy" \f$ = f_1 = \sum_{i, j}g(i, j)^2 \f$ * * "Entropy" \f$ = f_2 = -\sum_{i, j}g(i, j) \log_2 g(i, j)\f$, or 0 if \f$g(i, j) = 0\f$ * * "Correlation" \f$ = f_3 = \sum_{i, j}\frac{(i - \mu)(j - \mu)g(i, j)}{\sigma^2} \f$ * * "Difference Moment" \f$= f_4 = \sum_{i, j}\frac{1}{1 + (i - j)^2}g(i, j) \f$ * * "Inertia" \f$ = f_5 = \sum_{i, j}(i - j)^2g(i, j) \f$ (sometimes called "contrast") * * "Cluster Shade" \f$ = f_6 = \sum_{i, j}((i - \mu) + (j - \mu))^3 g(i, j) \f$ * * "Cluster Prominence" \f$ = f_7 = \sum_{i, j}((i - \mu) + (j - \mu))^4 g(i, j) \f$ * * "Haralick's Correlation" \f$ = f_8 = \frac{\sum_{i, j}(i, j) g(i, j) -\mu_t^2}{\sigma_t^2} \f$ * where \f$\mu_t\f$ and \f$\sigma_t\f$ are the mean and standard deviation of the row * (or column, due to symmetry) sums. * * Above, \f$ \mu = \f$ (weighted pixel average) \f$ = \sum_{i, j}i \cdot g(i, j) = * \sum_{i, j}j \cdot g(i, j) \f$ (due to matrix summetry), and * * \f$ \sigma = \f$ (weighted pixel variance) \f$ = \sum_{i, j}(i - \mu)^2 \cdot g(i, j) = * \sum_{i, j}(j - \mu)^2 \cdot g(i, j) \f$ (due to matrix summetry) * * Print references: * * Haralick, R.M., K. Shanmugam and I. Dinstein. 1973. Textural Features for * Image Classification. IEEE Transactions on Systems, Man and Cybernetics. * SMC-3(6):610-620. * * David A. Clausi and Yongping Zhao. 2002. Rapid extraction of image texture by * co-occurrence using a hybrid data structure. Comput. Geosci. 28, 6 (July * 2002), 763-774. DOI=10.1016/S0098-3004(01)00108-X * http://dx.doi.org/10.1016/S0098-3004(01)00108-X * * de O.Bastos, L.; Liatsis, P.; Conci, A., Automatic texture segmentation based * on k-means clustering and efficient calculation of co-occurrence * features. Systems, Signals and Image Processing, 2008. IWSSIP 2008. 15th * International Conference on , vol., no., pp.141,144, 25-28 June 2008 * doi: 10.1109/IWSSIP.2008.4604387 * * Neighborhood size can be set using the SetRadius() method. Offset for co-occurence estimation * is set using the SetOffset() method. * * \sa otb::GreyLevelCooccurrenceIndexedList * \sa otb::ScalarImageToAdvancedTexturesFiler * \sa otb::ScalarImageToHigherOrderTexturesFilter * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBTextures */ template class ScalarImageToTexturesFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs */ typedef ScalarImageToTexturesFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** RTTI */ itkTypeMacro(ScalarImageToTexturesFilter, ImageToImageFilter); /** Template class typedefs */ typedef TInpuImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::RegionType InputRegionType; typedef typename InputRegionType::SizeType SizeType; typedef typename InputImageType::OffsetType OffsetType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputRegionType; typedef GreyLevelCooccurrenceIndexedList< InputPixelType > CooccurrenceIndexedListType; typedef typename CooccurrenceIndexedListType::Pointer CooccurrenceIndexedListPointerType; typedef typename CooccurrenceIndexedListType::ConstPointer CooccurrenceIndexedListConstPointerType; typedef typename CooccurrenceIndexedListType::IndexType CooccurrenceIndexType; typedef typename CooccurrenceIndexedListType::PixelValueType PixelValueType; typedef typename CooccurrenceIndexedListType::RelativeFrequencyType RelativeFrequencyType; typedef typename CooccurrenceIndexedListType::VectorType VectorType; typedef typename VectorType::iterator VectorIteratorType; typedef typename VectorType::const_iterator VectorConstIteratorType; /** Set the radius of the window on which textures will be computed */ itkSetMacro(Radius, SizeType); /** Get the radius of the window on which textures will be computed */ itkGetMacro(Radius, SizeType); /** Set the offset for co-occurence computation */ itkSetMacro(Offset, OffsetType); /** Get the offset for co-occurence computation */ itkGetMacro(Offset, OffsetType); /** Set the number of bin per axis */ itkSetMacro(NumberOfBinsPerAxis, unsigned int); /** Get the number of bin per axis */ itkGetMacro(NumberOfBinsPerAxis, unsigned int); /** Set the input image minimum */ itkSetMacro(InputImageMinimum, InputPixelType); /** Get the input image minimum */ itkGetMacro(InputImageMinimum, InputPixelType); /** Set the input image maximum */ itkSetMacro(InputImageMaximum, InputPixelType); /** Get the input image maximum */ itkGetMacro(InputImageMaximum, InputPixelType); /** Get the energy output image */ OutputImageType * GetEnergyOutput(); /** Get the entropy output image */ OutputImageType * GetEntropyOutput(); /** Get the correlation output image */ OutputImageType * GetCorrelationOutput(); /** Get the inverse difference moment output image */ OutputImageType * GetInverseDifferenceMomentOutput(); /** Get the inertia output image */ OutputImageType * GetInertiaOutput(); /** Get the cluster shade output image */ OutputImageType * GetClusterShadeOutput(); /** Get the cluster prominence image */ OutputImageType * GetClusterProminenceOutput(); /** Get the Haralick correlation output image */ OutputImageType * GetHaralickCorrelationOutput(); protected: /** Constructor */ ScalarImageToTexturesFilter(); /** Destructor */ ~ScalarImageToTexturesFilter() ITK_OVERRIDE; /** Generate the input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Before Parallel textures extraction */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Parallel textures extraction */ void ThreadedGenerateData(const OutputRegionType& outputRegion, itk::ThreadIdType threadId) ITK_OVERRIDE; private: ScalarImageToTexturesFilter(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Convenient method to compute union of 2 regions */ static OutputRegionType RegionUnion(const OutputRegionType& region1, const OutputRegionType& region2); /** Radius of the window on which to compute textures */ SizeType m_Radius; /** Offset for co-occurence */ OffsetType m_Offset; /** Radius of the neighborhood iterator which is minimum of m_Radius */ SizeType m_NeighborhoodRadius; /** Number of bins per axis */ unsigned int m_NumberOfBinsPerAxis; /** Input image minimum */ InputPixelType m_InputImageMinimum; /** Input image maximum */ InputPixelType m_InputImageMaximum; //TODO: should we use constexpr? only c++11 and problem for msvc inline double GetPixelValueTolerance() const {return 0.0001; } }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbScalarImageToTexturesFilter.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbScalarImageToTexturesFilter.txx000066400000000000000000000404661301006202600305400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarImageToTexturesFilter_txx #define otbScalarImageToTexturesFilter_txx #include "otbScalarImageToTexturesFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkNumericTraits.h" #include #include namespace otb { template ScalarImageToTexturesFilter ::ScalarImageToTexturesFilter() : m_Radius() , m_Offset() , m_NeighborhoodRadius() , m_NumberOfBinsPerAxis(8) , m_InputImageMinimum(0) , m_InputImageMaximum(255) { // There are 8 outputs corresponding to the 8 textures indices this->SetNumberOfRequiredOutputs(8); // Create the 8 outputs this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageType::New()); this->SetNthOutput(2, OutputImageType::New()); this->SetNthOutput(3, OutputImageType::New()); this->SetNthOutput(4, OutputImageType::New()); this->SetNthOutput(5, OutputImageType::New()); this->SetNthOutput(6, OutputImageType::New()); this->SetNthOutput(7, OutputImageType::New()); } template ScalarImageToTexturesFilter ::~ScalarImageToTexturesFilter() {} template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetEnergyOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->GetOutput(0)); } template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetEntropyOutput() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast(this->GetOutput(1)); } template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetCorrelationOutput() { if (this->GetNumberOfOutputs() < 3) { return ITK_NULLPTR; } return static_cast(this->GetOutput(2)); } template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetInverseDifferenceMomentOutput() { if (this->GetNumberOfOutputs() < 4) { return ITK_NULLPTR; } return static_cast(this->GetOutput(3)); } template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetInertiaOutput() { if (this->GetNumberOfOutputs() < 5) { return ITK_NULLPTR; } return static_cast(this->GetOutput(4)); } template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetClusterShadeOutput() { if (this->GetNumberOfOutputs() < 6) { return ITK_NULLPTR; } return static_cast(this->GetOutput(5)); } template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetClusterProminenceOutput() { if (this->GetNumberOfOutputs() < 7) { return ITK_NULLPTR; } return static_cast(this->GetOutput(6)); } template typename ScalarImageToTexturesFilter ::OutputImageType * ScalarImageToTexturesFilter ::GetHaralickCorrelationOutput() { if (this->GetNumberOfOutputs() < 8) { return ITK_NULLPTR; } return static_cast(this->GetOutput(7)); } template void ScalarImageToTexturesFilter ::GenerateInputRequestedRegion() { // First, call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast(this->GetInput()); OutputImagePointerType outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // Retrieve the output requested region // We use only the first output since requested regions for all outputs are enforced to be equal // by the default GenerateOutputRequestedRegiont() implementation OutputRegionType outputRequestedRegion = outputPtr->GetRequestedRegion(); typename OutputRegionType::IndexType outputIndex = outputRequestedRegion.GetIndex(); typename OutputRegionType::SizeType outputSize = outputRequestedRegion.GetSize(); typename InputRegionType::IndexType inputIndex; typename InputRegionType::SizeType inputSize; // First, apply offset for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputIndex[dim] = std::min(outputIndex[dim], outputIndex[dim] + m_Offset[dim]); inputSize[dim] = std::max(outputIndex[dim] + outputSize[dim], outputIndex[dim] + outputSize[dim] + m_Offset[dim]) - inputIndex[dim]; } // Build the input requested region InputRegionType inputRequestedRegion; inputRequestedRegion.SetIndex(inputIndex); inputRequestedRegion.SetSize(inputSize); // Apply the radius inputRequestedRegion.PadByRadius(m_Radius); // Try to apply the requested region to the input image if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); } else { // Build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void ScalarImageToTexturesFilter ::BeforeThreadedGenerateData() { unsigned int minRadius = 0; for ( unsigned int i = 0; i < m_Offset.GetOffsetDimension(); i++ ) { unsigned int distance = vcl_abs(m_Offset[i]); if ( distance > minRadius ) { minRadius = distance; } } m_NeighborhoodRadius.Fill(minRadius); } template void ScalarImageToTexturesFilter ::ThreadedGenerateData(const OutputRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve the input and output pointers InputImagePointerType inputPtr = const_cast(this->GetInput()); OutputImagePointerType energyPtr = this->GetEnergyOutput(); OutputImagePointerType entropyPtr = this->GetEntropyOutput(); OutputImagePointerType correlationPtr = this->GetCorrelationOutput(); OutputImagePointerType invDiffMomentPtr = this->GetInverseDifferenceMomentOutput(); OutputImagePointerType inertiaPtr = this->GetInertiaOutput(); OutputImagePointerType clusterShadePtr = this->GetClusterShadeOutput(); OutputImagePointerType clusterProminencePtr = this->GetClusterProminenceOutput(); OutputImagePointerType haralickCorPtr = this->GetHaralickCorrelationOutput(); // Build output iterators itk::ImageRegionIteratorWithIndex energyIt(energyPtr, outputRegionForThread); itk::ImageRegionIterator entropyIt(entropyPtr, outputRegionForThread); itk::ImageRegionIterator correlationIt(correlationPtr, outputRegionForThread); itk::ImageRegionIterator invDiffMomentIt(invDiffMomentPtr, outputRegionForThread); itk::ImageRegionIterator inertiaIt(inertiaPtr, outputRegionForThread); itk::ImageRegionIterator clusterShadeIt(clusterShadePtr, outputRegionForThread); itk::ImageRegionIterator clusterProminenceIt(clusterProminencePtr, outputRegionForThread); itk::ImageRegionIterator haralickCorIt(haralickCorPtr, outputRegionForThread); // Go to begin energyIt.GoToBegin(); entropyIt.GoToBegin(); correlationIt.GoToBegin(); invDiffMomentIt.GoToBegin(); inertiaIt.GoToBegin(); clusterShadeIt.GoToBegin(); clusterProminenceIt.GoToBegin(); haralickCorIt.GoToBegin(); const double log2 = vcl_log(2.0); // Set-up progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Iterate on outputs to compute textures while (!energyIt.IsAtEnd() && !entropyIt.IsAtEnd() && !correlationIt.IsAtEnd() && !invDiffMomentIt.IsAtEnd() && !inertiaIt.IsAtEnd() && !clusterShadeIt.IsAtEnd() && !clusterProminenceIt.IsAtEnd() && !haralickCorIt.IsAtEnd()) { // Compute the region on which co-occurence will be estimated typename InputRegionType::IndexType inputIndex; typename InputRegionType::SizeType inputSize; // First, create an window for neighborhood iterator based on m_Radius // For example, if xradius and yradius is 2. window size is 5x5 (2 * radius + 1). for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputIndex[dim] = energyIt.GetIndex()[dim] - m_Radius[dim]; inputSize[dim] = 2 * m_Radius[dim] + 1; } // Build the input region InputRegionType inputRegion; inputRegion.SetIndex(inputIndex); inputRegion.SetSize(inputSize); inputRegion.Crop(inputPtr->GetRequestedRegion()); CooccurrenceIndexedListPointerType GLCIList = CooccurrenceIndexedListType::New(); GLCIList->Initialize(m_NumberOfBinsPerAxis, m_InputImageMinimum, m_InputImageMaximum); typedef itk::ConstNeighborhoodIterator< InputImageType > NeighborhoodIteratorType; NeighborhoodIteratorType neighborIt; neighborIt = NeighborhoodIteratorType(m_NeighborhoodRadius, inputPtr, inputRegion); for ( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt ) { const InputPixelType centerPixelIntensity = neighborIt.GetCenterPixel(); bool pixelInBounds; const InputPixelType pixelIntensity = neighborIt.GetPixel(m_Offset, pixelInBounds); if ( !pixelInBounds ) { continue; // don't put a pixel in the co-occurrence list if the value is // out of bounds } GLCIList->AddPixelPair(centerPixelIntensity, pixelIntensity); } double pixelMean = 0.; double marginalMean; double marginalDevSquared = 0.; double pixelVariance = 0.; //Create and Initialize marginalSums std::vector marginalSums(m_NumberOfBinsPerAxis, 0); //get co-occurrence vector and totalfrequency VectorType glcVector = GLCIList->GetVector(); double totalFrequency = static_cast (GLCIList->GetTotalFrequency()); //Normalize the co-occurrence indexed list and compute mean, marginalSum typename VectorType::iterator it = glcVector.begin(); while( it != glcVector.end()) { double frequency = (*it).second / totalFrequency; CooccurrenceIndexType index = (*it).first; pixelMean += index[0] * frequency; marginalSums[index[0]] += frequency; ++it; } /* Now get the mean and deviaton of the marginal sums. Compute incremental mean and SD, a la Knuth, "The Art of Computer Programming, Volume 2: Seminumerical Algorithms", section 4.2.2. Compute mean and standard deviation using the recurrence relation: M(1) = x(1), M(k) = M(k-1) + (x(k) - M(k-1) ) / k S(1) = 0, S(k) = S(k-1) + (x(k) - M(k-1)) * (x(k) - M(k)) for 2 <= k <= n, then sigma = vcl_sqrt(S(n) / n) (or divide by n-1 for sample SD instead of population SD). */ std::vector::const_iterator msIt = marginalSums.begin(); marginalMean = *msIt; //Increment iterator to start with index 1 ++msIt; for(int k= 2; msIt != marginalSums.end(); ++k, ++msIt) { double M_k_minus_1 = marginalMean; double S_k_minus_1 = marginalDevSquared; double x_k = *msIt; double M_k = M_k_minus_1 + ( x_k - M_k_minus_1 ) / k; double S_k = S_k_minus_1 + ( x_k - M_k_minus_1 ) * ( x_k - M_k ); marginalMean = M_k; marginalDevSquared = S_k; } marginalDevSquared = marginalDevSquared / m_NumberOfBinsPerAxis; VectorConstIteratorType constVectorIt; constVectorIt = glcVector.begin(); while( constVectorIt != glcVector.end()) { RelativeFrequencyType frequency = (*constVectorIt).second / totalFrequency; CooccurrenceIndexType index = (*constVectorIt).first; pixelVariance += ( index[0] - pixelMean ) * ( index[0] - pixelMean ) * frequency; ++constVectorIt; } double pixelVarianceSquared = pixelVariance * pixelVariance; // Variance is only used in correlation. If variance is 0, then (index[0] - pixelMean) * (index[1] - pixelMean) // should be zero as well. In this case, set the variance to 1. in order to // avoid NaN correlation. if(pixelVarianceSquared < GetPixelValueTolerance()) { pixelVarianceSquared = 1.; } //Initialize texture variables; PixelValueType energy = itk::NumericTraits< PixelValueType >::Zero; PixelValueType entropy = itk::NumericTraits< PixelValueType >::Zero; PixelValueType correlation = itk::NumericTraits< PixelValueType >::Zero; PixelValueType inverseDifferenceMoment = itk::NumericTraits< PixelValueType >::Zero; PixelValueType inertia = itk::NumericTraits< PixelValueType >::Zero; PixelValueType clusterShade = itk::NumericTraits< PixelValueType >::Zero; PixelValueType clusterProminence = itk::NumericTraits< PixelValueType >::Zero; PixelValueType haralickCorrelation = itk::NumericTraits< PixelValueType >::Zero; //Compute textures constVectorIt = glcVector.begin(); while( constVectorIt != glcVector.end()) { CooccurrenceIndexType index = (*constVectorIt).first; RelativeFrequencyType frequency = (*constVectorIt).second / totalFrequency; energy += frequency * frequency; entropy -= ( frequency > GetPixelValueTolerance() ) ? frequency *vcl_log(frequency) / log2 : 0; correlation += ( ( index[0] - pixelMean ) * ( index[1] - pixelMean ) * frequency ) / pixelVarianceSquared; inverseDifferenceMoment += frequency / ( 1.0 + ( index[0] - index[1] ) * ( index[0] - index[1] ) ); inertia += ( index[0] - index[1] ) * ( index[0] - index[1] ) * frequency; clusterShade += vcl_pow( ( index[0] - pixelMean ) + ( index[1] - pixelMean ), 3 ) * frequency; clusterProminence += vcl_pow( ( index[0] - pixelMean ) + ( index[1] - pixelMean ), 4 ) * frequency; haralickCorrelation += index[0] * index[1] * frequency; ++constVectorIt; } haralickCorrelation = (fabs(marginalDevSquared) > 1E-8) ? ( haralickCorrelation - marginalMean * marginalMean ) / marginalDevSquared : 0; // Fill outputs energyIt.Set(energy); entropyIt.Set(entropy); correlationIt.Set(correlation); invDiffMomentIt.Set(inverseDifferenceMoment); inertiaIt.Set(inertia); clusterShadeIt.Set(clusterShade); clusterProminenceIt.Set(clusterProminence); haralickCorIt.Set(haralickCorrelation); // Update progress progress.CompletedPixel(); // Increment iterators ++energyIt; ++entropyIt; ++correlationIt; ++invDiffMomentIt; ++inertiaIt; ++clusterShadeIt; ++clusterProminenceIt; ++haralickCorIt; } } } // End namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/include/otbTextureImageFunction.h000066400000000000000000000110121301006202600266510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTextureImageFunction_h #define otbTextureImageFunction_h #include "itkImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkVariableLengthVector.h" namespace otb { /** * \class TextureImageFunction * \brief Calculate a texture over an image. * * This class is templated with the input image and the Functor * that will compute the texture. * * \ingroup ImageFunctions * \ingroup Textures * * \ingroup OTBTextures */ template class ITK_EXPORT TextureImageFunction : public itk::ImageFunction::RealType, TCoordRep> { public: /** Standard class typedefs. */ typedef TextureImageFunction Self; typedef itk::ImageFunction::RealType, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(TextureImageFunction, itk::ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** typedef support. */ typedef TInputImage InputImageType; typedef TFunctor FunctorType; typedef typename InputImageType::OffsetType OffsetType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::PixelType PixelType; typedef typename Superclass::OutputType OutputType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef itk::ConstNeighborhoodIterator IteratorType; typedef typename IteratorType::NeighborhoodType NeighborhoodType; typedef typename itk::NumericTraits::RealType RealType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ RealType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ RealType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } RealType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the statistics are evaluated */ void SetRadius(SizeType& rad) { m_Radius = rad; this->Modified(); } void SetOffset(OffsetType& off) { m_Offset = off; this->Modified(); } itkGetMacro(Radius, SizeType); itkGetMacro(Offset, OffsetType); /** Return the texture name */ virtual std::string GetName() const { FunctorType funct; return funct.GetName(); } protected: TextureImageFunction(); ~TextureImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: TextureImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented SizeType m_Radius; OffsetType m_Offset; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbTextureImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Feature/Textures/include/otbTextureImageFunction.txx000066400000000000000000000040631301006202600272550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTextureImageFunction_txx #define otbTextureImageFunction_txx #include "otbTextureImageFunction.h" namespace otb { /** * Constructor */ template TextureImageFunction ::TextureImageFunction() { m_Radius.Fill(0); m_Offset.Fill(0); } /** * */ template void TextureImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; os << indent << "Offset: " << m_Offset << std::endl; } /** * */ template typename TextureImageFunction ::RealType TextureImageFunction ::EvaluateAtIndex(const IndexType& index) const { if (!this->GetInputImage()) { return (itk::NumericTraits::max()); } if (!this->IsInsideBuffer(index)) { return (itk::NumericTraits::max()); } SizeType radiusOff; radiusOff[0] = (m_Radius[0]) + vcl_abs(m_Offset[0]); radiusOff[1] = (m_Radius[1]) + vcl_abs(m_Offset[1]); IteratorType itOff(radiusOff, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); itOff.SetLocation(index); FunctorType funct; funct.SetOffset(m_Offset); return static_cast(funct(itOff.GetNeighborhood())); } } // end namespace otb #endif OTB-release-5.8/Modules/Feature/Textures/otb-module.cmake000066400000000000000000000004731301006202600233210ustar00rootroot00000000000000set(DOCUMENTATION "This module is concerned with texture analysis. Co-occurrence matrix, Haralick are examples of what can be found in this module.") otb_module(OTBTextures DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Feature/Textures/test/000077500000000000000000000000001301006202600212235ustar00rootroot00000000000000OTB-release-5.8/Modules/Feature/Textures/test/CMakeLists.txt000066400000000000000000000152111301006202600237630ustar00rootroot00000000000000otb_module_test() set(OTBTexturesTests otbTexturesTestDriver.cxx otbScalarImageToHigherOrderTexturesFilter.cxx otbHaralickTexturesImageFunction.cxx otbGreyLevelCooccurrenceIndexedList.cxx otbScalarImageToTexturesFilter.cxx otbScalarImageToTexturesFilterNew.cxx otbSFSTexturesImageFilterTest.cxx otbSFSTexturesImageFilterNew.cxx otbScalarImageToPanTexTextureFilterNew.cxx otbScalarImageToAdvancedTexturesFilterNew.cxx otbGreyLevelCooccurrenceIndexedListNew.cxx otbScalarImageToAdvancedTexturesFilter.cxx otbScalarImageToPanTexTextureFilter.cxx ) add_executable(otbTexturesTestDriver ${OTBTexturesTests}) target_link_libraries(otbTexturesTestDriver ${OTBTextures-Test_LIBRARIES}) otb_module_target_label(otbTexturesTestDriver) otb_add_test(NAME feTuScalarImageToHigherOrderTexturesFilterNew COMMAND otbTexturesTestDriver otbScalarImageToHigherOrderTexturesFilterNew ) otb_add_test(NAME feTvScalarImageToHigherOrderTexturesFilter COMMAND otbTexturesTestDriver otbScalarImageToHigherOrderTexturesFilter ${INPUTDATA}/Mire_Cosinus.png) otb_add_test(NAME feTuHaralickTexturesImageFunctionNew COMMAND otbTexturesTestDriver otbHaralickTexturesImageFunctionNew ) otb_add_test(NAME feTvHaralickTexturesImageFunction COMMAND otbTexturesTestDriver --compare-ascii ${EPSILON_8} ${BASELINE_FILES}/feTvHaralickTexturesImageFunction.txt ${TEMP}/feTvHaralickTexturesImageFunction.txt otbHaralickTexturesImageFunction ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/feTvHaralickTexturesImageFunction.txt 451846.014047961 5412466.57452216 ) otb_add_test(NAME feTvGreyLevelCooccurrenceIndexedList COMMAND otbTexturesTestDriver otbGreyLevelCooccurrenceIndexedList ) otb_add_test(NAME feTvScalarImageToTexturesFilter COMMAND otbTexturesTestDriver --compare-n-images ${EPSILON_10} 8 ${BASELINE}/feTvScalarImageToTexturesFilterOutputEnergy.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputEnergy.tif ${BASELINE}/feTvScalarImageToTexturesFilterOutputEntropy.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputEntropy.tif ${BASELINE}/feTvScalarImageToTexturesFilterOutputCorrelation.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputCorrelation.tif ${BASELINE}/feTvScalarImageToTexturesFilterOutputInverseDifferenceMoment.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputInverseDifferenceMoment.tif ${BASELINE}/feTvScalarImageToTexturesFilterOutputInertia.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputInertia.tif ${BASELINE}/feTvScalarImageToTexturesFilterOutputClusterShade.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputClusterShade.tif ${BASELINE}/feTvScalarImageToTexturesFilterOutputClusterProminence.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputClusterProminence.tif ${BASELINE}/feTvScalarImageToTexturesFilterOutputHaralickCorrelation.tif ${TEMP}/feTvScalarImageToTexturesFilterOutputHaralickCorrelation.tif otbScalarImageToTexturesFilter ${INPUTDATA}/Mire_Cosinus.png ${TEMP}/feTvScalarImageToTexturesFilterOutput 8 3 2 2) otb_add_test(NAME feTuScalarImageToTexturesFilterNew COMMAND otbTexturesTestDriver otbScalarImageToTexturesFilterNew ) otb_add_test(NAME feTvSFSTexturesImageFilterTest COMMAND otbTexturesTestDriver --compare-n-images ${EPSILON_8} 5 ${BASELINE}/feTvSFSTexturesLengthImageFilterTest.tif ${TEMP}/feTvSFSTexturesLengthImageFilterTest.tif ${BASELINE}/feTvSFSTexturesWidthImageFilterTest.tif ${TEMP}/feTvSFSTexturesWidthImageFilterTest.tif ${BASELINE}/feTvSFSTexturesWMeanImageFilterTest.tif ${TEMP}/feTvSFSTexturesWMeanImageFilterTest.tif ${BASELINE}/feTvSFSTexturesRatioImageFilterTest.tif ${TEMP}/feTvSFSTexturesRatioImageFilterTest.tif ${BASELINE}/feTvSFSTexturesSDImageFilterTest.tif ${TEMP}/feTvSFSTexturesSDImageFilterTest.tif otbSFSTexturesImageFilterTest ${INPUTDATA}/poupees_sub_c1.png ${TEMP}/feTvSFSTexturesLengthImageFilterTest.tif ${TEMP}/feTvSFSTexturesWidthImageFilterTest.tif ${TEMP}/feTvSFSTexturesWMeanImageFilterTest.tif ${TEMP}/feTvSFSTexturesRatioImageFilterTest.tif ${TEMP}/feTvSFSTexturesSDImageFilterTest.tif 50 # spectral threshold 20 # spatial threshold 15 # direction 4 # max min/max number takes in care for ratio 0.6 # alpha value ) otb_add_test(NAME feTuSFSTexturesImageFilterNew COMMAND otbTexturesTestDriver otbSFSTexturesImageFilterNew) otb_add_test(NAME feTuScalarImageToPanTexTextureFilterNew COMMAND otbTexturesTestDriver otbScalarImageToPanTexTextureFilterNew ) otb_add_test(NAME feTuScalarImageToAdvancedTexturesFilterNew COMMAND otbTexturesTestDriver otbScalarImageToAdvancedTexturesFilterNew ) otb_add_test(NAME feTuGreyLevelCooccurrenceIndexedListNew COMMAND otbTexturesTestDriver otbGreyLevelCooccurrenceIndexedListNew ) otb_add_test(NAME feTvScalarImageToAdvancedTexturesFilter COMMAND otbTexturesTestDriver --compare-n-images ${NOTOL} 10 ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputVariance.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputVariance.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputMean.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputMean.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputDissimilarity.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputDissimilarity.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputSumAverage.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputSumAverage.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputSumVariance.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputSumVariance.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputSumEntropy.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputSumEntropy.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputDifferenceEntropy.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputDifferenceEntropy.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputDifferenceVariance.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputDifferenceVariance.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputIC1.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputIC1.tif ${BASELINE}/feTvScalarImageToAdvancedTexturesFilterOutputIC2.tif ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutputIC2.tif otbScalarImageToAdvancedTexturesFilter ${INPUTDATA}/Mire_Cosinus.png ${TEMP}/feTvScalarImageToAdvancedTexturesFilterOutput 8 5 1 1) otb_add_test(NAME feTvScalarImageToPanTexTextureFilter COMMAND otbTexturesTestDriver --compare-image ${NOTOL} ${BASELINE}/feTvScalarImageToPanTexTextureFilterOutputPanTex.tif ${TEMP}/feTvScalarImageToPanTexTextureFilterOutputPanTex.tif otbScalarImageToPanTexTextureFilter ${INPUTDATA}/Mire_Cosinus.png ${TEMP}/feTvScalarImageToPanTexTextureFilterOutput 8 5) OTB-release-5.8/Modules/Feature/Textures/test/otbGreyLevelCooccurrenceIndexedList.cxx000066400000000000000000000203751301006202600310510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGreyLevelCooccurrenceIndexedList.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" int otbGreyLevelCooccurrenceIndexedList(int, char* [] ) { //Data definitions const unsigned int IMGWIDTH = 4; const unsigned int IMGHEIGHT = 4; const unsigned int NDIMENSION = 2; //------------------------------------------------------ //Create a simple test images //------------------------------------------------------ typedef unsigned char InputPixelType; typedef itk::Image InputImageType; typedef itk::ImageRegionIterator< InputImageType > InputImageIterator; typedef InputImageType::RegionType InputRegionType; InputImageType::Pointer image = InputImageType::New(); InputImageType::SizeType inputImageSize = {{ IMGWIDTH, IMGHEIGHT }}; InputImageType::IndexType index; index.Fill(0); InputRegionType region; region.SetSize( inputImageSize ); region.SetIndex( index ); image->SetRegions( region ); image->Allocate(); //-------------------------------------------------------------------------- // Set up the image first. It looks like: // 1 2 1 2 1 // 1 2 1 2 1 // 1 2 1 2 1 // 1 2 1 2 1 // 1 2 1 2 1 //-------------------------------------------------------------------------- // setup the iterator InputImageIterator imageIt( image, image->GetBufferedRegion() ); imageIt.GoToBegin(); for(unsigned int i = 0; i < IMGWIDTH; i++) { for(unsigned int j = 0; j < IMGHEIGHT; j++, ++imageIt) { imageIt.Set(j % 2 + 1); } } typedef otb::GreyLevelCooccurrenceIndexedList< InputPixelType > CooccurrenceIndexedListType; typedef CooccurrenceIndexedListType::FrequencyType FrequencyType; typedef CooccurrenceIndexedListType::TotalFrequencyType TotalFrequencyType; CooccurrenceIndexedListType::Pointer cooccurrenceObj1 = CooccurrenceIndexedListType::New(); std::cout << "Class name = "; std::cout << cooccurrenceObj1->GetNameOfClass() << std::endl; bool passed = true; try { // Check Initialize method. cooccurrenceObj1->Initialize(4, 0, 8); bool symmetry = cooccurrenceObj1->GetSymmetry(); float totalFrequency = cooccurrenceObj1->GetTotalFrequency(); if( !symmetry || totalFrequency != 0) { std::cerr << "Error" << std::endl; std::cerr << "Expected symmetry = 1, totalFrequency = 0, got symmetry = " << symmetry << " totalFrequency = " << totalFrequency << std::endl; passed = false; } } catch( itk::ExceptionObject & err ) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; std::cerr << "Test failed" << std::endl; return EXIT_FAILURE; } static const FrequencyType out1[] = {12,6,12,12,12,12,12,6,12,6,12,12,12,12,12,6,12,6,12,12,12,12,12,6,8,4,8,8,8,8,8,4}; std::vector avector (out1, out1 + sizeof(out1) / sizeof(out1[0]) ); static const FrequencyType out2[] = {18,24,24,18,18,24,24,18,18,24,24,18,12,16,16,12}; std::vector< TotalFrequencyType> tavector(out2, out2 + sizeof(out2) / sizeof(out2[0]) ); ; InputImageType::OffsetType offset = {{0, 1}}; //vector to save results std::vector< FrequencyType> fvector; std::vector< TotalFrequencyType> tfvector; InputImageType::SizeType neighborhoodRadius; unsigned int minRadius = 0; for ( unsigned int i = 0; i < offset.GetOffsetDimension(); i++ ) { unsigned int distance = vcl_abs(offset[i]); if ( distance > minRadius ) { minRadius = distance; } } neighborhoodRadius.Fill(minRadius); InputImageType::SizeType radius = {{ 2, 2 }}; // Iterate over input image and create co-occurrence list itk::ImageRegionIteratorWithIndex imageItWithIndex(image, region); imageItWithIndex.GoToBegin(); while (!imageItWithIndex.IsAtEnd()) { InputRegionType::IndexType inputIndex; InputRegionType::SizeType inputSize; for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { inputIndex[dim] = imageItWithIndex.GetIndex()[dim] - radius[dim]; inputSize[dim] = 2 * radius[dim] + 1; } // Build the input region InputRegionType inputRegion; inputRegion.SetIndex(inputIndex); inputRegion.SetSize(inputSize); inputRegion.Crop(image->GetRequestedRegion()); CooccurrenceIndexedListType::Pointer cooccurrenceObj2 = CooccurrenceIndexedListType::New(); cooccurrenceObj2->Initialize(8, 0, 3); typedef itk::ConstNeighborhoodIterator< InputImageType > NeighborhoodIteratorType; NeighborhoodIteratorType neighborIt; neighborIt = NeighborhoodIteratorType(neighborhoodRadius, image, inputRegion); for ( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt ) { const InputPixelType centerPixelIntensity = neighborIt.GetCenterPixel(); bool pixelInBounds; const InputPixelType pixelIntensity = neighborIt.GetPixel(offset, pixelInBounds); if ( !pixelInBounds ) { continue; // don't put a pixel in the co-occurrence list if it's out-of-bounds. } cooccurrenceObj2->AddPixelPair(centerPixelIntensity, pixelIntensity); } typedef CooccurrenceIndexedListType::VectorType VectorType; VectorType vector; //get indexed list and total frequency vector = cooccurrenceObj2->GetVector(); //save total frequency tfvector.push_back(cooccurrenceObj2->GetTotalFrequency()); //save each vector to fvector so as to compare results later VectorType::const_iterator it; for (it = vector.begin(); it != vector.end(); ++it) { fvector.push_back( (*it).second ); } ++imageItWithIndex; } //Check size of fvector against the actual results if( fvector.size() != avector.size()) { std::cerr << "Size of computed co-occurrence indexed list for entire image is: " << fvector.size() << " expected size is: " << avector.size() << std::endl; passed = false; } else { //check contents individually std::vector::const_iterator fit, ait; ait = avector.begin(); fit = fvector.begin(); while(ait != avector.end()) { if ((*fit) != (*ait)) { std::cerr << "Expected value: " << (*ait) << " got :" << (*fit) << std::endl; passed = false; break; } ++ait; ++fit; } std::cerr << "Co-occurrence list frequencies are correct" << std::endl; } //Check size of tfvector against the tavector if( tfvector.size() != tavector.size()) { std::cerr << "Size of computed co-occurrence indexed list for entire image is: " << tfvector.size() << " expected size is: " << tavector.size() << std::endl; passed = false; } else { //check contents individually std::vector::const_iterator fit, ait; ait = tavector.begin(); fit = tfvector.begin(); while(ait != tavector.end()) { if ((*fit) != (*ait)) { std::cerr << "Expected value: " << (*ait) << " got :" << (*fit) << std::endl; passed = false; break; } ++ait; ++fit; } std::cerr << "Co-occurrence list total frequencies are correct" << std::endl; } if (!passed) { std::cerr << "Test failed" << std::endl; return EXIT_FAILURE; } else { std::cerr << "Test succeeded" << std::endl; return EXIT_SUCCESS; } } OTB-release-5.8/Modules/Feature/Textures/test/otbGreyLevelCooccurrenceIndexedListNew.cxx000066400000000000000000000021021301006202600315070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbGreyLevelCooccurrenceIndexedList.h" int otbGreyLevelCooccurrenceIndexedListNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float PixelType; typedef otb::GreyLevelCooccurrenceIndexedList< PixelType > CooccurrenceIndexedListType; CooccurrenceIndexedListType::Pointer lightObj = CooccurrenceIndexedListType::New(); std::cout << "Printing otb::GreyLevelCooccurrenceIndexedList: " << std::endl; lightObj->Print( std::cout ); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbHaralickTexturesImageFunction.cxx000066400000000000000000000043471301006202600304170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbHaralickTexturesImageFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" typedef unsigned short InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::HaralickTexturesImageFunction< InputImageType, double> HaralickTexturesImageFunctionType; typedef HaralickTexturesImageFunctionType::PointType PointType; typedef HaralickTexturesImageFunctionType::OutputType OutputType; int otbHaralickTexturesImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { HaralickTexturesImageFunctionType::Pointer function = HaralickTexturesImageFunctionType::New(); return EXIT_SUCCESS; } int otbHaralickTexturesImageFunction(int itkNotUsed(argc), char * argv[]) { // Read the input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->Update(); std::ofstream outputStream(argv[2]); HaralickTexturesImageFunctionType::Pointer haralick = HaralickTexturesImageFunctionType::New(); haralick->SetInputImage(reader->GetOutput()); haralick->SetNeighborhoodRadius(10); HaralickTexturesImageFunctionType::OffsetType offset; offset.Fill(1); haralick->SetOffset(offset); PointType p; p[0] = atof(argv[3]); p[1] = atof(argv[4]); OutputType output = haralick->Evaluate(p); outputStream<<"Evaluate("< ImageType; typedef otb::SFSTexturesImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbSFSTexturesImageFilterTest.cxx000066400000000000000000000057701301006202600276350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSFSTexturesImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbSFSTexturesImageFilterTest(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; const unsigned int Dimension = 2; std::string inName = argv[1]; std::string outNameLength = argv[2]; std::string outNameWidth = argv[3]; std::string outNameWMean = argv[4]; std::string outNameRatio = argv[5]; std::string outNameSD = argv[6]; PixelType spectThresh = atof(argv[7]); unsigned int spatialThresh = atoi(argv[8]); unsigned int dirNb = atoi(argv[9]); unsigned int maxConsideration = atoi(argv[10]); double alpha = atof(argv[11]); typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SFSTexturesImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writerLength = WriterType::New(); WriterType::Pointer writerWidth = WriterType::New(); WriterType::Pointer writerWMean = WriterType::New(); WriterType::Pointer writerRatio = WriterType::New(); WriterType::Pointer writerSD = WriterType::New(); reader->SetFileName(inName); reader->GenerateOutputInformation(); filter->SetSpectralThreshold(spectThresh); filter->SetSpatialThreshold(spatialThresh); filter->SetNumberOfDirections(dirNb); filter->SetRatioMaxConsiderationNumber(maxConsideration); filter->SetAlpha(alpha); // disable PSI texture filter->SetFeatureStatus(FilterType::PSI, false); filter->SetInput(reader->GetOutput()); writerLength->SetFileName(outNameLength); writerLength->SetInput(filter->GetLengthOutput()); writerLength->Update(); writerWidth->SetFileName(outNameWidth); writerWidth->SetInput(filter->GetWidthOutput()); writerWidth->Update(); writerWMean->SetFileName(outNameWMean); writerWMean->SetInput(filter->GetWMeanOutput()); writerWMean->Update(); writerRatio->SetFileName(outNameRatio); writerRatio->SetInput(filter->GetRatioOutput()); writerRatio->Update(); writerSD->SetFileName(outNameSD); writerSD->SetInput(filter->GetSDOutput()); writerSD->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbScalarImageToAdvancedTexturesFilter.cxx000066400000000000000000000077571301006202600315070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbScalarImageToAdvancedTexturesFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStandardFilterWatcher.h" int otbScalarImageToAdvancedTexturesFilter(int argc, char * argv[]) { if (argc != 7) { std::cerr << "Usage: " << argv[0] << " infname outprefix nbBins radius offsetx offsety" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outprefix = argv[2]; const unsigned int nbBins = atoi(argv[3]); const unsigned int radius = atoi(argv[4]); const int offsetx = atoi(argv[5]); const int offsety = atoi(argv[6]); const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::ScalarImageToAdvancedTexturesFilter TexturesFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); TexturesFilterType::Pointer filter = TexturesFilterType::New(); WriterType::Pointer writer = WriterType::New(); // Read image reader->SetFileName(infname); // Build radius TexturesFilterType::SizeType sradius; sradius.Fill(radius); // Build offset TexturesFilterType::OffsetType offset; offset[0] = offsetx; offset[1] = offsety; filter->SetInput(reader->GetOutput()); filter->SetRadius(sradius); filter->SetOffset(offset); otb::StandardFilterWatcher watcher(filter, "Textures filter"); filter->SetNumberOfBinsPerAxis(nbBins); filter->SetInputImageMinimum(0); filter->SetInputImageMaximum(255); // Write outputs std::ostringstream oss; writer->SetNumberOfDivisionsStrippedStreaming(2); oss.str(""); oss << outprefix << "Variance.tif"; writer->SetInput(filter->GetVarianceOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "Mean.tif"; writer->SetInput(filter->GetMeanOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "Dissimilarity.tif"; writer->SetInput(filter->GetDissimilarityOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "SumAverage.tif"; writer->SetInput(filter->GetSumAverageOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "SumVariance.tif"; writer->SetInput(filter->GetSumVarianceOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "SumEntropy.tif"; writer->SetInput(filter->GetSumEntropyOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "DifferenceEntropy.tif"; writer->SetInput(filter->GetDifferenceEntropyOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "DifferenceVariance.tif"; writer->SetInput(filter->GetDifferenceVarianceOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "IC1.tif"; writer->SetInput(filter->GetIC1Output()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "IC2.tif"; writer->SetInput(filter->GetIC2Output()); writer->SetFileName(oss.str()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbScalarImageToAdvancedTexturesFilterNew.cxx000066400000000000000000000022041301006202600321370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbScalarImageToAdvancedTexturesFilter.h" #include "otbImage.h" int otbScalarImageToAdvancedTexturesFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ScalarImageToAdvancedTexturesFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbScalarImageToHigherOrderTexturesFilter.cxx000066400000000000000000000212521301006202600321660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbScalarImageToHigherOrderTexturesFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "itkExtractImageFilter.h" const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::ScalarImageToHigherOrderTexturesFilter TexturesFilterType; typedef otb::ImageFileReader ReaderType; typedef ImageType::IndexType IndexType; typedef ImageType::IndexValueType IndexValueType; typedef itk::Statistics::ScalarImageToRunLengthFeaturesFilter RunLengthFeaturesFilterType; typedef itk::ExtractImageFilter ExtractImageFilterType; typedef RunLengthFeaturesFilterType::OffsetType OffsetType; typedef RunLengthFeaturesFilterType::OffsetVector OffsetVector; typedef RunLengthFeaturesFilterType::OffsetVectorPointer OffsetVectorPointer; int otbScalarImageToHigherOrderTexturesFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { TexturesFilterType::Pointer filter = TexturesFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } ImageType::Pointer ReadInputImage(const char * filename) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(filename); reader->Update(); ImageType::Pointer image = reader->GetOutput(); image->DisconnectPipeline(); return image; } std::vector Compute( ImageType* inputImage, unsigned int nbBins, unsigned int radius, OffsetVector* offsetVector ) { TexturesFilterType::Pointer textureFilter = TexturesFilterType::New(); TexturesFilterType::SizeType sradius; sradius.Fill(radius); textureFilter->SetInput(inputImage); textureFilter->SetNumberOfBinsPerAxis(nbBins); textureFilter->SetRadius(sradius); if ( offsetVector ) { textureFilter->SetOffsets(offsetVector); } textureFilter->SetInputImageMinimum(0); textureFilter->SetInputImageMaximum(256); textureFilter->Update(); std::vector outputs; for (int i = 0; i < 10; ++i) { ImageType::Pointer output = textureFilter->GetOutput(i); output->DisconnectPipeline(); outputs.push_back(output); } return outputs; } int ValidateAt( ImageType* inputImage, std::vector computeResults, unsigned int nbBins, unsigned int radius, OffsetVector* offsetVector, IndexValueType x, IndexValueType y ) { ExtractImageFilterType::Pointer extract = ExtractImageFilterType::New(); ImageType::RegionType region; region.SetIndex(0,x - radius); region.SetIndex(1,y - radius); region.SetSize(0,2 * radius + 1); region.SetSize(1,2 * radius + 1); region.Crop(inputImage->GetLargestPossibleRegion()); extract->SetExtractionRegion(region); extract->SetInput(inputImage); RunLengthFeaturesFilterType::Pointer itkFilter = RunLengthFeaturesFilterType::New(); itkFilter->SetInput(extract->GetOutput()); itkFilter->SetNumberOfBinsPerAxis(nbBins); if ( offsetVector ) { itkFilter->SetOffsets(offsetVector); } itkFilter->SetPixelValueMinMax(0, 256); ImageType::PointType topLeftPoint; ImageType::PointType bottomRightPoint; ImageType::IndexType topLeftIndex = region.GetIndex(); ImageType::IndexType bottomRightIndex = region.GetIndex(); bottomRightIndex[0] += 2 * radius; bottomRightIndex[1] += 2 * radius; inputImage->TransformIndexToPhysicalPoint(topLeftIndex, topLeftPoint ); inputImage->TransformIndexToPhysicalPoint(bottomRightIndex, bottomRightPoint ); double maxDistance = topLeftPoint.EuclideanDistanceTo(bottomRightPoint); itkFilter->SetDistanceValueMinMax(0, maxDistance ); itkFilter->Update(); RunLengthFeaturesFilterType::FeatureValueVector& featuresMeans = *(itkFilter->GetFeatureMeans().GetPointer()); for (int i = 0; i < 10; ++i) { ImageType::IndexType idx; idx[0] = x; idx[1] = y; PixelType output = computeResults[i]->GetPixel(idx); PixelType reference = featuresMeans[i]; std::cout << "index : " << idx << std::endl; std::cout << "compute : " << output << std::endl; std::cout << "ref : " << reference << std::endl; if (reference != output) { std::cerr << "Error at index " << idx << ", feature #" << i << ", got " << output << " and ref is " << reference << std::endl; return EXIT_FAILURE; } } return EXIT_SUCCESS; } int otbScalarImageToHigherOrderTexturesFilter(int argc, char * argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " infname" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const unsigned int nbBins = 8; unsigned int radius; OffsetVectorPointer offsetVector; // radius = 5, offset = [1,1] { radius = 5; OffsetType offset; offset[0] = 1; offset[1] = 1; offsetVector = OffsetVector::New(); offsetVector->push_back(offset); std::cout << "Testing radius = " << radius << " and offset = " << offset << std::endl; ImageType::Pointer inputImage = ReadInputImage(infname); std::vector results = Compute(inputImage, nbBins, radius, offsetVector); if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 5, 5) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 7, 11) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 10, 5) == EXIT_FAILURE ) return EXIT_FAILURE; } // radius = 7, offset = [1,2] { radius = 7; OffsetType offset; offset[0] = 1; offset[1] = 2; offsetVector = OffsetVector::New(); offsetVector->push_back(offset); std::cout << "Testing radius = " << radius << " and offset = " << offset << std::endl; ImageType::Pointer inputImage = ReadInputImage(infname); std::vector results = Compute(inputImage, nbBins, radius, offsetVector); if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 7, 11) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 5, 5) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 7, 11) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 10, 5) == EXIT_FAILURE ) return EXIT_FAILURE; } // radius = 3, offset = defaults (average of all directions) { radius = 3; std::cout << "Testing radius = " << radius << " and default offsets" << std::endl; ImageType::Pointer inputImage = ReadInputImage(infname); std::vector results = Compute(inputImage, nbBins, radius, ITK_NULLPTR); if ( ValidateAt(inputImage, results, nbBins, radius, ITK_NULLPTR, 7, 11) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, ITK_NULLPTR, 5, 5) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, ITK_NULLPTR, 7, 11) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, ITK_NULLPTR, 10, 5) == EXIT_FAILURE ) return EXIT_FAILURE; } // radius = 7, offset = [0,-1] { radius = 7; OffsetType offset; offset[0] = 1; offset[1] = -1; offsetVector = OffsetVector::New(); offsetVector->push_back(offset); std::cout << "Testing radius = " << radius << " and offset = " << offset << std::endl; ImageType::Pointer inputImage = ReadInputImage(infname); std::vector results = Compute(inputImage, nbBins, radius, offsetVector); if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 7, 11) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 5, 5) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 7, 11) == EXIT_FAILURE ) return EXIT_FAILURE; if ( ValidateAt(inputImage, results, nbBins, radius, offsetVector, 10, 5) == EXIT_FAILURE ) return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbScalarImageToPanTexTextureFilter.cxx000066400000000000000000000045171301006202600310050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbScalarImageToPanTexTextureFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStandardFilterWatcher.h" int otbScalarImageToPanTexTextureFilter(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " infname outprefix nbBins radius" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outprefix = argv[2]; const unsigned int nbBins = atoi(argv[3]); const unsigned int radius = atoi(argv[4]); const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::ScalarImageToPanTexTextureFilter PanTexTextureFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); PanTexTextureFilterType::Pointer filter = PanTexTextureFilterType::New(); WriterType::Pointer writer = WriterType::New(); // Read image reader->SetFileName(infname); // Build radius PanTexTextureFilterType::SizeType sradius; sradius.Fill(radius); filter->SetInput(reader->GetOutput()); filter->SetRadius(sradius); otb::StandardFilterWatcher watcher(filter, "Textures filter"); filter->SetNumberOfBinsPerAxis(nbBins); filter->SetInputImageMinimum(0); filter->SetInputImageMaximum(255); // Write outputs std::ostringstream oss; oss.str(""); oss << outprefix << "PanTex.tif"; writer->SetInput(filter->GetOutput()); writer->SetFileName(oss.str()); writer->SetNumberOfDivisionsStrippedStreaming(2); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbScalarImageToPanTexTextureFilterNew.cxx000066400000000000000000000021651301006202600314540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbScalarImageToPanTexTextureFilter.h" #include "otbImage.h" int otbScalarImageToPanTexTextureFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ScalarImageToPanTexTextureFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbScalarImageToTexturesFilter.cxx000066400000000000000000000073151301006202600300470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbScalarImageToTexturesFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStandardFilterWatcher.h" int otbScalarImageToTexturesFilter(int argc, char * argv[]) { if (argc != 7) { std::cerr << "Usage: " << argv[0] << " infname outprefix nbBins radius offsetx offsety" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outprefix = argv[2]; const unsigned int nbBins = atoi(argv[3]); const unsigned int radius = atoi(argv[4]); const int offsetx = atoi(argv[5]); const int offsety = atoi(argv[6]); const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::ScalarImageToTexturesFilter TexturesFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); TexturesFilterType::Pointer filter = TexturesFilterType::New(); WriterType::Pointer writer = WriterType::New(); // Read image reader->SetFileName(infname); // Build radius TexturesFilterType::SizeType sradius; sradius.Fill(radius); // Build offset TexturesFilterType::OffsetType offset; offset[0] = offsetx; offset[1] = offsety; filter->SetInput(reader->GetOutput()); filter->SetRadius(sradius); filter->SetOffset(offset); otb::StandardFilterWatcher watcher(filter, "Textures filter"); filter->SetNumberOfBinsPerAxis(nbBins); filter->SetInputImageMinimum(0); filter->SetInputImageMaximum(255); // Write outputs std::ostringstream oss; writer->SetNumberOfDivisionsStrippedStreaming(2); oss.str(""); oss << outprefix << "Energy.tif"; writer->SetInput(filter->GetEnergyOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "Entropy.tif"; writer->SetInput(filter->GetEntropyOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "Correlation.tif"; writer->SetInput(filter->GetCorrelationOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "InverseDifferenceMoment.tif"; writer->SetInput(filter->GetInverseDifferenceMomentOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "Inertia.tif"; writer->SetInput(filter->GetInertiaOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "ClusterShade.tif"; writer->SetInput(filter->GetClusterShadeOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "ClusterProminence.tif"; writer->SetInput(filter->GetClusterProminenceOutput()); writer->SetFileName(oss.str()); writer->Update(); oss.str(""); oss << outprefix << "HaralickCorrelation.tif"; writer->SetInput(filter->GetHaralickCorrelationOutput()); writer->SetFileName(oss.str()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbScalarImageToTexturesFilterNew.cxx000066400000000000000000000021341301006202600305130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbScalarImageToTexturesFilter.h" #include "otbImage.h" int otbScalarImageToTexturesFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ScalarImageToTexturesFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Feature/Textures/test/otbTexturesTestDriver.cxx000066400000000000000000000014551301006202600263200ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbScalarImageToHigherOrderTexturesFilterNew); REGISTER_TEST(otbScalarImageToHigherOrderTexturesFilter); REGISTER_TEST(otbHaralickTexturesImageFunctionNew); REGISTER_TEST(otbHaralickTexturesImageFunction); REGISTER_TEST(otbGreyLevelCooccurrenceIndexedList); REGISTER_TEST(otbScalarImageToTexturesFilter); REGISTER_TEST(otbScalarImageToTexturesFilterNew); REGISTER_TEST(otbSFSTexturesImageFilterTest); REGISTER_TEST(otbSFSTexturesImageFilterNew); REGISTER_TEST(otbScalarImageToPanTexTextureFilterNew); REGISTER_TEST(otbScalarImageToAdvancedTexturesFilterNew); REGISTER_TEST(otbGreyLevelCooccurrenceIndexedListNew); REGISTER_TEST(otbScalarImageToAdvancedTexturesFilter); REGISTER_TEST(otbScalarImageToPanTexTextureFilter); } OTB-release-5.8/Modules/Filtering/000077500000000000000000000000001301006202600167515ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/000077500000000000000000000000001301006202600217755ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/CMakeLists.txt000066400000000000000000000000561301006202600245360ustar00rootroot00000000000000project(OTBChangeDetection) otb_module_impl() OTB-release-5.8/Modules/Filtering/ChangeDetection/include/000077500000000000000000000000001301006202600234205ustar00rootroot00000000000000otbBinaryFunctorNeighborhoodJoinHistogramImageFilter.h000066400000000000000000000167661301006202600361630ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryFunctorNeighborhoodJoinHistogramImageFilter_h #define otbBinaryFunctorNeighborhoodJoinHistogramImageFilter_h #include "itkBinaryFunctorImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkHistogram.h" namespace otb { /** \class BinaryFunctorNeighborhoodJoinHistogramImageFilter * \brief Implements neighborhood-wise generic operation of two images. * * This class is parameterized over the types of the two input images * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT BinaryFunctorNeighborhoodJoinHistogramImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef BinaryFunctorNeighborhoodJoinHistogramImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BinaryFunctorNeighborhoodJoinHistogramImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef TInputImage1 Input1ImageType; typedef typename Input1ImageType::Pointer Input1ImagePointer; typedef typename Input1ImageType::ConstPointer Input1ImageConstPointer; typedef typename Input1ImageType::RegionType Input1ImageRegionType; typedef typename Input1ImageType::PixelType Input1ImagePixelType; typedef TInputImage2 Input2ImageType; typedef typename Input2ImageType::Pointer Input2ImagePointer; typedef typename Input2ImageType::ConstPointer Input2ImageConstPointer; typedef typename Input2ImageType::RegionType Input2ImageRegionType; typedef typename Input2ImageType::PixelType Input2ImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType1; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType2; typedef typename NeighborhoodIteratorType1::RadiusType RadiusType1; typedef typename NeighborhoodIteratorType2::RadiusType RadiusType2; typedef unsigned char RadiusSizeType; /** Typedefs for histogram. This should have been defined as Histogram but a bug in VC++7 produced an internal compiler error with such declaration. */ typedef typename itk::Statistics::Histogram HistogramType; typedef typename HistogramType::MeasurementVectorType MeasurementVectorType; typedef typename HistogramType::SizeType HistogramSizeType; /** Connect one of the operands for pixel-wise addition */ void SetInput1(const TInputImage1 * image1); /** Connect one of the operands for pixel-wise addition */ void SetInput2(const TInputImage2 * image2); /** Get the inputs */ const TInputImage1 * GetInput1(); const TInputImage2 * GetInput2(); /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } /** Neighborhood radius */ itkSetMacro(Radius, RadiusSizeType); /** Factor to increase the upper bound for the samples in the histogram. Default value is 0.001 */ itkSetMacro(UpperBoundIncreaseFactor, double); itkGetMacro(UpperBoundIncreaseFactor, double); /** The padding value. */ itkSetMacro(PaddingValue, Input1ImagePixelType); /** Returns the padding value. */ itkGetConstReferenceMacro(PaddingValue, Input1ImagePixelType); /** Set whether the padding value should be used to determine which pixels should be ignored when calculating the similarity measure. Those pixels in the fixed image which have the padding value will be ignored. */ itkSetMacro(UsePaddingValue, bool); itkGetMacro(UsePaddingValue, bool); protected: BinaryFunctorNeighborhoodJoinHistogramImageFilter(); ~BinaryFunctorNeighborhoodJoinHistogramImageFilter() ITK_OVERRIDE {} void BeforeThreadedGenerateData() ITK_OVERRIDE; /** BinaryFunctorNeighborhoodJoinHistogramImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Pad the inputs requested regions by radius */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; RadiusSizeType m_Radius; HistogramType::Pointer m_Histogram; private: BinaryFunctorNeighborhoodJoinHistogramImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void ComputeHistogram(); FunctorType m_Functor; /** The padding value. */ Input1ImagePixelType m_PaddingValue; /** True if those pixels in the fixed image with the same value as the padding value should be ignored when calculating the similarity measure. */ bool m_UsePaddingValue; /** The increase in the upper bound. */ double m_UpperBoundIncreaseFactor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBinaryFunctorNeighborhoodJoinHistogramImageFilter.txx" #endif #endif otbBinaryFunctorNeighborhoodJoinHistogramImageFilter.txx000066400000000000000000000302541301006202600365430ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryFunctorNeighborhoodJoinHistogramImageFilter_txx #define otbBinaryFunctorNeighborhoodJoinHistogramImageFilter_txx #include "otbBinaryFunctorNeighborhoodJoinHistogramImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template BinaryFunctorNeighborhoodJoinHistogramImageFilter ::BinaryFunctorNeighborhoodJoinHistogramImageFilter() { this->SetNumberOfRequiredInputs(2); m_Radius = 3; m_UsePaddingValue = false; m_UpperBoundIncreaseFactor = 0.001; } /** * Connect one of the operands for neighborhood-wise operation */ template void BinaryFunctorNeighborhoodJoinHistogramImageFilter ::SetInput1(const TInputImage1 * image1) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast(image1)); } /** * Connect one of the operands for neighborhood-wise operation */ template void BinaryFunctorNeighborhoodJoinHistogramImageFilter ::SetInput2(const TInputImage2 * image2) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast(image2)); } template const TInputImage1 * BinaryFunctorNeighborhoodJoinHistogramImageFilter ::GetInput1() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TInputImage2 * BinaryFunctorNeighborhoodJoinHistogramImageFilter ::GetInput2() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void BinaryFunctorNeighborhoodJoinHistogramImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output Input1ImagePointer inputPtr1 = const_cast(this->GetInput1()); Input2ImagePointer inputPtr2 = const_cast(this->GetInput2()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr1 || !inputPtr2 || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage1::RegionType inputRequestedRegion1, inputRequestedRegion2; inputRequestedRegion1 = inputPtr1->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion1.PadByRadius(m_Radius); inputRequestedRegion2 = inputRequestedRegion1; // crop the input requested region at the input's largest possible region if (inputRequestedRegion1.Crop(inputPtr1->GetLargestPossibleRegion())) { inputPtr1->SetRequestedRegion(inputRequestedRegion1); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr1->SetRequestedRegion(inputRequestedRegion1); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(inputPtr1); throw e; } if (inputRequestedRegion2.Crop(inputPtr2->GetLargestPossibleRegion())) { inputPtr2->SetRequestedRegion(inputRequestedRegion2); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr2->SetRequestedRegion(inputRequestedRegion2); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(inputPtr2); throw e; } return; } template void BinaryFunctorNeighborhoodJoinHistogramImageFilter ::BeforeThreadedGenerateData() { this->ComputeHistogram(); } /** * Initialize the histogram */ template void BinaryFunctorNeighborhoodJoinHistogramImageFilter ::ComputeHistogram() { // Calculate min and max image values in input1 image. Input1ImageConstPointer pInput1Image = dynamic_cast(ProcessObjectType::GetInput(0)); Input1ImagePixelType minInput1, maxInput1; itk::ImageRegionConstIterator fiIt(pInput1Image, pInput1Image->GetBufferedRegion()); fiIt.GoToBegin(); minInput1 = fiIt.Value(); maxInput1 = fiIt.Value(); ++fiIt; while (!fiIt.IsAtEnd()) { Input1ImagePixelType value = fiIt.Value(); if (value < minInput1) { minInput1 = value; } else if (value > maxInput1) { maxInput1 = value; } ++fiIt; } // Calculate min and max image values in input2 image. Input2ImageConstPointer pInput2Image = dynamic_cast(ProcessObjectType::GetInput(1)); Input2ImagePixelType minInput2, maxInput2; itk::ImageRegionConstIterator miIt(pInput2Image, pInput2Image->GetBufferedRegion()); miIt.GoToBegin(); minInput2 = miIt.Value(); maxInput2 = miIt.Value(); ++miIt; while (!miIt.IsAtEnd()) { Input2ImagePixelType value = miIt.Value(); if (value < minInput2) { minInput2 = value; } else if (value > maxInput2) { maxInput2 = value; } ++miIt; } // Set the size of the upper and lower bounds of the histogram: MeasurementVectorType lowerBound, upperBound; lowerBound.SetSize(2); upperBound.SetSize(2); // Initialize the upper and lower bounds of the histogram. lowerBound[0] = minInput1; lowerBound[1] = minInput2; upperBound[0] = maxInput1 + (maxInput1 - minInput1) * m_UpperBoundIncreaseFactor; upperBound[1] = maxInput2 + (maxInput2 - minInput2) * m_UpperBoundIncreaseFactor; typedef itk::ImageRegionConstIteratorWithIndex Input1IteratorType; typedef itk::ImageRegionConstIteratorWithIndex Input2IteratorType; typename Input1ImageType::RegionType input1Region; typename Input1ImageType::RegionType input2Region; input1Region = pInput1Image->GetRequestedRegion(); Input1IteratorType ti1(pInput1Image, input1Region); input2Region = pInput2Image->GetRequestedRegion(); Input2IteratorType ti2(pInput2Image, input2Region); typename HistogramType::Pointer histogram = HistogramType::New(); HistogramSizeType histogramSize(2); histogramSize.Fill(256); histogram->SetMeasurementVectorSize(2); histogram->Initialize(histogramSize, lowerBound, upperBound); ti1.GoToBegin(); ti2.GoToBegin(); while (!ti1.IsAtEnd() && !ti2.IsAtEnd()) { typename HistogramType::IndexType sample(2); sample[0] = ti1.Get(); sample[1] = ti2.Get(); if (sample[0] != itk::NumericTraits::Zero && sample[1] != itk::NumericTraits::Zero) histogram->IncreaseFrequencyOfIndex(sample, 1); ++ti1; ++ti2; } m_Histogram = histogram; } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void BinaryFunctorNeighborhoodJoinHistogramImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itk::ZeroFluxNeumannBoundaryCondition nbc1; itk::ZeroFluxNeumannBoundaryCondition nbc2; // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToJoinHistogramImageFilter::GetInput(int) always returns a pointer to a // TInputImage1 so it cannot be used for the second input. Input1ImageConstPointer inputPtr1 = dynamic_cast(ProcessObjectType::GetInput(0)); Input2ImageConstPointer inputPtr2 = dynamic_cast(ProcessObjectType::GetInput(1)); OutputImagePointer outputPtr = this->GetOutput(0); RadiusType1 r1; r1.Fill(m_Radius); NeighborhoodIteratorType1 neighInputIt1; RadiusType2 r2; r2.Fill(m_Radius); NeighborhoodIteratorType2 neighInputIt2; itk::ImageRegionIterator outputIt; // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList1; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC1; faceList1 = bC1(inputPtr1, outputRegionForThread, r1); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList2; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC2; faceList2 = bC2(inputPtr2, outputRegionForThread, r2); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit1; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit2; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit1 = faceList1.begin(), fit2 = faceList2.begin(); fit1 != faceList1.end() && fit2 != faceList2.end(); ++fit1, ++fit2) { neighInputIt1 = itk::ConstNeighborhoodIterator(r1, inputPtr1, *fit1); neighInputIt2 = itk::ConstNeighborhoodIterator(r1, inputPtr2, *fit2); outputIt = itk::ImageRegionIterator(outputPtr, outputRegionForThread); outputIt = itk::ImageRegionIterator(outputPtr, *fit1); neighInputIt1.OverrideBoundaryCondition(&nbc1); neighInputIt1.GoToBegin(); neighInputIt2.OverrideBoundaryCondition(&nbc2); neighInputIt2.GoToBegin(); while (!outputIt.IsAtEnd()) { outputIt.Set(m_Functor(neighInputIt1, neighInputIt2, m_Histogram)); ++neighInputIt1; ++neighInputIt2; ++outputIt; progress.CompletedPixel(); } } } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbCBAMI.h000066400000000000000000000137751301006202600251260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCBAMI_h #define otbCBAMI_h #include #include "itkMath.h" namespace otb { namespace Functor { template class CBAMI { public: typedef typename std::vector VectorType; typedef typename VectorType::iterator IteratorType; typedef typename std::vector VectorOfVectorType; typedef typename VectorOfVectorType::iterator VecOfVecIteratorType; CBAMI() {} virtual ~CBAMI() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB) const { double epsilon = 0.01; VectorType vecA; VectorType vecB; for (unsigned long pos = 0; pos < itA.Size(); ++pos) { vecA.push_back(static_cast(itA.GetPixel(pos))); vecB.push_back(static_cast(itB.GetPixel(pos))); } normalizeInPlace(vecA); normalizeInPlace(vecB); return static_cast(-vcl_log(static_cast(PhiMI(vecA, vecB) + epsilon))); } protected: inline void normalizeInPlace(VectorType vx) const { TOutput Ex = 0.0; IteratorType itx; for (itx = vx.begin(); itx < vx.end(); ++itx) { Ex += static_cast(*itx); } Ex /= (vx.size()); TOutput Vx = 0.0; for (itx = vx.begin(); itx < vx.end(); ++itx) { Vx += static_cast(vcl_pow(static_cast((*itx) - Ex), 2)); } Vx /= (vx.size()); for (itx = vx.begin(); itx < vx.end(); ++itx) { (*itx) = ((*itx) - Ex) / static_cast(vcl_sqrt(static_cast(Vx))); } } inline TOutput Exyc(VectorType vx, VectorType vy) const { TOutput Exy = 0.0; TOutput Ex = 0.0; TOutput Ey = 0.0; IteratorType itx; IteratorType ity; for (itx = vx.begin(), ity = vy.begin(); itx < vx.end(); ++itx, ++ity) { //Ex += (*itx); //Ey += (*ity); Exy += (*itx) * (*ity); } //Ex /= (vx.size()); //Ey /= (vy.size()); Exy /= (vx.size()); return Exy - Ex * Ey; } inline TOutput Exyztc(VectorType vx, VectorType vy, VectorType vz, VectorType vt) const { TOutput Exyzt = 0.0; TOutput Exyz = 0.0; TOutput Exyt = 0.0; TOutput Exzt = 0.0; TOutput Eyzt = 0.0; TOutput Exy = 0.0; TOutput Exz = 0.0; TOutput Ext = 0.0; TOutput Eyz = 0.0; TOutput Eyt = 0.0; TOutput Ezt = 0.0; TOutput Ex = 0.0; TOutput Ey = 0.0; TOutput Ez = 0.0; TOutput Et = 0.0; IteratorType itx; IteratorType ity; IteratorType itz; IteratorType itt; for (itx = vx.begin(), ity = vy.begin(), itz = vz.begin(), itt = vt.begin(); itx < vx.end(); ++itx, ++ity, itz++, itt++) { //Ex += (*itx); //Ey += (*ity); //Ez += (*itz); //Et += (*itt); Exy += (*itx) * (*ity); Exz += (*itx) * (*itz); Ext += (*itx) * (*itt); Eyz += (*ity) * (*itz); Eyt += (*ity) * (*itt); Ezt += (*itz) * (*itt); Exyz += (*itx) * (*ity) * (*itz); Exyt += (*itx) * (*ity) * (*itt); Exzt += (*itx) * (*itz) * (*itt); Eyzt += (*ity) * (*itz) * (*itt); Exyzt += (*itx) * (*ity) * (*itz) * (*itt); } /*Ex /= (vx.size()); Ey /= (vx.size()); Ez /= (vx.size()); Et /= (vx.size()); */ Exy /= (vx.size()); Exz /= (vx.size()); Ext /= (vx.size()); Eyz /= (vx.size()); Eyt /= (vx.size()); Ezt /= (vx.size()); Exyz /= (vx.size()); Exyt /= (vx.size()); Exzt /= (vx.size()); Eyzt /= (vx.size()); TOutput result = Exyzt - Exyz * Et - Exyt * Ez - Exzt * Ey - Eyzt * Ex + Exy * Ez * Et + Exz * Et * Ey + Ext * Ey * Ez + Eyz * Et * Ex + Eyt * Ex * Ez + Ezt * Ex * Ey - 3 * Ex * Ey * Ez * Et; return result; } inline TOutput Rxy(VectorType va, VectorType vb) const { return Exyc(va, vb); } inline TOutput Qxijkl(VectorType va, VectorType vb, VectorType vc, VectorType vd) const { // IteratorType ita; // IteratorType itb; // IteratorType itc; // IteratorType itd; TOutput Eabcd_c = Exyztc(va, vb, vc, vd); TOutput Eab_c = Exyc(va, vb); TOutput Eac_c = Exyc(va, vc); TOutput Ead_c = Exyc(va, vd); TOutput Ecd_c = Exyc(vc, vd); TOutput Ebd_c = Exyc(vb, vd); TOutput Ebc_c = Exyc(vb, vc); return Eabcd_c - Eab_c * Ecd_c - Eac_c * Ebd_c - Ead_c * Ebc_c; } inline TOutput PhiMI(VectorType v1, VectorType v2) const { VectorOfVectorType donnees; donnees.push_back(v1); donnees.push_back(v2); VecOfVecIteratorType iti; VecOfVecIteratorType itj; VecOfVecIteratorType itk; VecOfVecIteratorType itl; TOutput termeR = 0.0; TOutput termeQ = 0.0; for (iti = donnees.begin(); iti < donnees.end(); ++iti) for (itj = donnees.begin(); itj < donnees.end(); ++itj) { if (iti != itj) termeR += static_cast(vcl_pow(static_cast(Rxy((*iti), (*itj))), 2)); for (itk = donnees.begin(); itk < donnees.end(); ++itk) for (itl = donnees.begin(); itl < donnees.end(); itl++) { if ((iti != itj) || (iti != itk) || (iti != itl)) termeQ += static_cast(vcl_pow(static_cast(Qxijkl((*iti), (*itj), (*itk), (*itl))), 2)); } } return 1.0 / 4.0 * termeR + 1.0 / 48.0 * termeQ; } }; } } #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbCBAMIChangeDetector.h000066400000000000000000000056601301006202600277200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCBAMIChangeDetector_h #define otbCBAMIChangeDetector_h #include "otbBinaryFunctorNeighborhoodImageFilter.h" #include "otbCBAMI.h" namespace otb { /** \class CBAMIChangeDetector * \brief Implements neighborhood-wise the computation of the * cumulant-based approximation to mutual information. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input images, and for * each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the difference of the two pixel values * - compute the value of the CBAMI * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension * (e.g. all 2D, or all 3D, or all ND) * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT CBAMIChangeDetector : public BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::CBAMI< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef CBAMIChangeDetector Self; typedef BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::CBAMI< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(CBAMIChangeDetector, SuperClass); protected: CBAMIChangeDetector() {} ~CBAMIChangeDetector() ITK_OVERRIDE {} private: CBAMIChangeDetector(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbCorrelationChangeDetector.h000066400000000000000000000057521301006202600313700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCorrelationChangeDetector_h #define otbCorrelationChangeDetector_h #include "otbBinaryFunctorNeighborhoodImageFilter.h" #include "otbCrossCorrelation.h" namespace otb { /** \class CorrelationChangeDetector * \brief Implements neighborhood-wise the computation of crosscorrelation. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input images, and for * each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the difference of the two pixel values * - compute the value of the cross-correlation * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension * (e.g. all 2D, or all 3D, or all ND) * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT CorrelationChangeDetector : public BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::CrossCorrelation< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef CorrelationChangeDetector Self; typedef BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::CrossCorrelation< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(CorrelationChangeDetector, SuperClass); protected: CorrelationChangeDetector() {} ~CorrelationChangeDetector() ITK_OVERRIDE {} private: CorrelationChangeDetector(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbCrossCorrelation.h000066400000000000000000000060331301006202600275730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCrossCorrelation_h #define otbCrossCorrelation_h #include "itkMath.h" namespace otb { namespace Functor { /** \class CrossCorrelation * \brief Functor to compute the cross correlation * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the difference of the two pixel values * - compute the value of the cross-correlation * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * * \ingroup OTBChangeDetection */ template class CrossCorrelation { public: CrossCorrelation() {} virtual ~CrossCorrelation() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB) { TOutput meanA = itk::NumericTraits::Zero; TOutput meanB = itk::NumericTraits::Zero; for (unsigned long pos = 0; pos < itA.Size(); ++pos) { meanA += static_cast(itA.GetPixel(pos)); meanB += static_cast(itB.GetPixel(pos)); } meanA /= itA.Size(); meanB /= itB.Size(); TOutput varA = itk::NumericTraits::Zero; TOutput varB = itk::NumericTraits::Zero; for (unsigned long pos = 0; pos < itA.Size(); ++pos) { varA += static_cast(vcl_pow(static_cast(itA.GetPixel(pos)) - static_cast(meanA), static_cast(2.0))); varB += static_cast(vcl_pow(static_cast(itB.GetPixel(pos)) - static_cast(meanB), static_cast(2.0))); } varA /= itA.Size(); varB /= itB.Size(); TOutput crossCorrel = itk::NumericTraits::Zero; if (varA != itk::NumericTraits::Zero && varB != itk::NumericTraits::Zero) { for (unsigned long pos = 0; pos < itA.Size(); ++pos) { crossCorrel += (static_cast(itA.GetPixel(pos)) - meanA) * (static_cast(itB.GetPixel(pos)) - meanB) / (itA.Size() * vcl_sqrt(static_cast(varA * varB))); } } else if (varA == itk::NumericTraits::Zero && varB == itk::NumericTraits::Zero) { crossCorrel = itk::NumericTraits::One; } return static_cast(itk::NumericTraits::One - crossCorrel); } }; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbJoinHistogramMI.h000066400000000000000000000040651301006202600273060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbJoinHistogramMI_h #define otbJoinHistogramMI_h #include "itkHistogram.h" namespace otb { namespace Functor { template class JoinHistogramMI { public: typedef double HistogramFrequencyType; typedef typename itk::Statistics::Histogram HistogramType; JoinHistogramMI() {} virtual ~JoinHistogramMI() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB, const HistogramType* histogram) { TOutput jointEntropy = itk::NumericTraits::Zero; HistogramFrequencyType totalFreq = histogram->GetTotalFrequency(); typename HistogramType::MeasurementVectorType sample(2); for (unsigned long pos = 0; pos < itA.Size(); ++pos) { double valueA = static_cast(itA.GetPixel(pos)); double valueB = static_cast(itB.GetPixel(pos)); sample[0] = valueA; sample[1] = valueB; typename HistogramType::IndexType index; histogram->GetIndex(sample, index); HistogramFrequencyType freq = histogram->GetFrequency(index); if (freq > 0) { jointEntropy += freq * vcl_log(freq); } } jointEntropy = -jointEntropy / static_cast(totalFreq) + vcl_log(totalFreq); return jointEntropy; } }; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbJoinHistogramMIImageFilter.h000066400000000000000000000060641301006202600314200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbJoinHistogramMIImageFilter_h #define otbJoinHistogramMIImageFilter_h #include "otbBinaryFunctorNeighborhoodJoinHistogramImageFilter.h" #include "otbJoinHistogramMI.h" namespace otb { /** \class JoinHistogramMIImageFilter * \brief Implements neighborhood-wise the computation of mutual * information using a join histogram. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input images, and for * each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the difference of the two pixel values * - compute the value of the mutual information * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension * (e.g. all 2D, or all 3D, or all ND) * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT JoinHistogramMIImageFilter : public BinaryFunctorNeighborhoodJoinHistogramImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::JoinHistogramMI< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef JoinHistogramMIImageFilter Self; typedef BinaryFunctorNeighborhoodJoinHistogramImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::JoinHistogramMI< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(JoinHistogramMIImageFilter, SuperClass); protected: JoinHistogramMIImageFilter() {} ~JoinHistogramMIImageFilter() ITK_OVERRIDE {} private: JoinHistogramMIImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbKullbackLeiblerDistanceImageFilter.h000066400000000000000000000133151301006202600331140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKullbackLeiblerDistanceImageFilter_h #define otbKullbackLeiblerDistanceImageFilter_h #include "itkVariableLengthVector.h" #include "otbBinaryFunctorNeighborhoodImageFilter.h" namespace otb { /** \class CumulantsForEdgeworth * \brief Helper class for KullbackLeiblerDistanceImageFilter. Please refer to KullbackLeiblerDistanceImageFilter. * * * \ingroup OTBChangeDetection */ template class CumulantsForEdgeworth { public: CumulantsForEdgeworth (const TInput& input); CumulantsForEdgeworth (const itk::Image * input); virtual ~CumulantsForEdgeworth () {} /** KL Divergence calculation */ template double Divergence(const CumulantsForEdgeworth& cumulants); inline double GetMean() const { return this->fMean; } inline double GetVariance() const { return this->fVariance; } inline double GetSkewness() const { return this->fSkewness; } inline double GetKurtosis() const { return this->fKurtosis; } inline bool IsDataAvailable() const { return this->fDataAvailable; } protected: /** Moment estimation from initial neighborhood */ void MakeSumAndMoments(const TInput& input); /** Moment estimation from raw data */ void MakeSumAndMoments(const itk::Image * input); /** transformation moment -> cumulants (for Edgeworth) */ void MakeCumulants(); double fSum0, fSum1, fSum2, fSum3, fSum4; double fMu1, fMu2, fMu3, fMu4; double fMean, fVariance, fSkewness, fKurtosis; bool fDataAvailable; }; namespace Functor { /** \class KullbackLeiblerDistance * \brief Functor for KullbackLeiblerDistanceImageFilter. Please refer to KullbackLeiblerDistanceImageFilter. * * * \ingroup OTBChangeDetection */ template class KullbackLeiblerDistance { public: KullbackLeiblerDistance () {} virtual ~KullbackLeiblerDistance () {} TOutput operator ()(const TInput1& it1, const TInput2& it2) { CumulantsForEdgeworth cum1 (it1); if (!cum1.IsDataAvailable()) return static_cast(0.); CumulantsForEdgeworth cum2 (it2); if (!cum2.IsDataAvailable()) return static_cast(0.); return static_cast (cum1.Divergence(cum2) + cum2.Divergence(cum1)); } }; } // Functor /** \class KullbackLeiblerDistanceImageFilter * \brief Implements neighborhood-wise the computation of KullbackLeibler distance over Edgeworth approximation. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input images, and for * each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the first four cumulants of the two pixel values * - compute the value of the Edgeorth approximation of the KL distance * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension * (e.g. all 2D, or all 3D, or all ND) * * See article of Lin Saito et Levine * "Edgeworth Approximation of the Kullback-Leibler Distance Towards Problems in Image Analysis" * and * "Edgeworth Expansions of the Kullback-Leibler Information" (submitted to JASA, nov 25, 1999) * http://www.math.ucdavis.edu/~saito/publications * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT KullbackLeiblerDistanceImageFilter : public otb::BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::KullbackLeiblerDistance< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef KullbackLeiblerDistanceImageFilter Self; typedef otb::BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::KullbackLeiblerDistance< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); protected: KullbackLeiblerDistanceImageFilter() {} ~KullbackLeiblerDistanceImageFilter() ITK_OVERRIDE {} private: KullbackLeiblerDistanceImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKullbackLeiblerDistanceImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbKullbackLeiblerDistanceImageFilter.txx000066400000000000000000000155621301006202600335160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKullbackLeiblerDistanceImageFilter_txx #define otbKullbackLeiblerDistanceImageFilter_txx #include "otbKullbackLeiblerDistanceImageFilter.h" #include #include "itkImageRegionConstIterator.h" #include "otbMacro.h" namespace otb { /* ******************************************************************* * CumulantsForEdgeworth ********************************************************************* */ template CumulantsForEdgeworth ::CumulantsForEdgeworth (const TInput& input) { MakeSumAndMoments(input); MakeCumulants(); } template CumulantsForEdgeworth ::CumulantsForEdgeworth (const itk::Image * input) { MakeSumAndMoments(input); MakeCumulants(); } /* ========================== Divergence de KL ======================= */ template template double CumulantsForEdgeworth ::Divergence(const CumulantsForEdgeworth& cumulants) { double cum1 = GetMean(); double cum2 = GetVariance(); double cum3 = GetSkewness(); double sqrt_cum2 = sqrt(cum2); double cum2_3 = cum2 * cum2 * cum2; double cum3_2 = cum3 * cum3; double tilde_cum1 = cumulants.GetMean(); double tilde_cum2 = cumulants.GetVariance(); double tilde_cum3 = cumulants.GetSkewness(); double tilde_cum4 = cumulants.GetKurtosis(); double tilde_cum2_2 = cum2 * cum2; double tilde_cum2_3 = cum2 * tilde_cum2_2; double tilde_cum2_6 = tilde_cum2_3 * tilde_cum2_3; double tilde_cum3_2 = tilde_cum3 * tilde_cum3; double beta = sqrt_cum2 / tilde_cum2; double alpha = (cum1 - tilde_cum1) / tilde_cum2; double alpha_2 = alpha * alpha; double alpha_4 = alpha_2 * alpha_2; double alpha_6 = alpha_2 * alpha_4; double beta_2 = beta * beta; double beta_4 = beta_2 * beta_2; double beta_6 = beta_2 * beta_4; double c2 = alpha_2 + beta_2; double c3 = alpha * (alpha_2 + 3.0 * beta_2); double c4 = alpha_4 + 6.0 * alpha_2 * beta_2 + 3.0 * beta_4; double c6 = alpha_6 + 15.0 * alpha_4 * beta_2 + 45.0 * alpha_2 * beta_4 + 15.0 * beta_6; double a1 = c3 - 3.0 * alpha / tilde_cum2; double a2 = c4 - 6.0 * c2 / tilde_cum2 + 3.0 / tilde_cum2_2; // Watch for tilde_cum2_2 mistake in the article! double a3 = c6 - 15.0 * c4 / tilde_cum2 + 45.0 * c2 / tilde_cum2_2 - 15.0 / tilde_cum2_3; double tmp = cum1 - tilde_cum1 + sqrt_cum2; double resu = cum3_2 / (12.0 * cum2_3) + (log(tilde_cum2 / cum2) - 1.0 + tmp * tmp / tilde_cum2) / 2.0 - (tilde_cum3 * a1 / 6.0 + tilde_cum4 * a2 / 24.0 + tilde_cum3_2 * a3 / 72.0) - tilde_cum3_2 * (c6 - 6.0 * c4 / cum2 + 9.0 * c2 / tilde_cum2_2) / 72.0 - 10.0 * cum3 * tilde_cum3 * (cum1 - tilde_cum1) * (cum2 - tilde_cum2) / tilde_cum2_6; return resu < 0.0 ? 0.0 : resu; } /* ========== Moment estimation from initial neighborhood ============ */ template void CumulantsForEdgeworth ::MakeSumAndMoments(const TInput& input) { fSum0 = fSum1 = fSum2 = fSum3 = fSum4 = 0.0; double pixel, pixel_2; for (unsigned long i = 0; i < input.Size(); ++i) { pixel = static_cast (input.GetPixel(i)); pixel_2 = pixel * pixel; fSum0 += 1.0; fSum1 += pixel; fSum2 += pixel_2; fSum3 += pixel_2 * pixel; fSum4 += pixel_2 * pixel_2; } fMu1 = fSum1 / fSum0; fMu2 = fSum2 / fSum0 - fMu1 * fMu1; if (fMu2 <= 0.0) { //otbGenericMsgDebugMacro( << "Potential NAN detected in function MakeSumAndMoments."); fMu3 = 0.0; fMu4 = 4.0; fDataAvailable = false; return; } double sigma = sqrt(fMu2); itk::VariableLengthVector tab(input.Size()); double * x = const_cast (tab.GetDataPointer()); for (unsigned long i = 0; i < input.Size(); ++i) *x++ = (static_cast (input.GetPixel(i)) - fMu1) / sigma; fMu3 = fMu4 = 0.0; x = const_cast (tab.GetDataPointer()); for (unsigned long i = 0; i < input.Size(); ++i) { pixel = *x++; pixel_2 = pixel * pixel; fMu3 += pixel * pixel_2; fMu4 += pixel_2 * pixel_2; } fMu3 /= fSum0; fMu4 /= fSum0; fDataAvailable = true; } /* ================= Moment estimation from raw data ================= */ template void CumulantsForEdgeworth ::MakeSumAndMoments(const itk::Image * input) { fSum0 = fSum1 = fSum2 = fSum3 = fSum4 = 0.0; double pixel, pixel_2; typedef itk::Image LocalImageType; typedef itk::ImageRegionConstIterator ImageRegionConstIteratorType; ImageRegionConstIteratorType inputIter(input, input->GetRequestedRegion()); inputIter.GoToBegin(); unsigned int inputSize = 0; while (!inputIter.IsAtEnd()) { pixel = static_cast (inputIter.Get()); pixel_2 = pixel * pixel; fSum0 += 1.0; fSum1 += pixel; fSum2 += pixel_2; fSum3 += pixel_2 * pixel; fSum4 += pixel_2 * pixel_2; ++inputIter; ++inputSize; } fMu1 = fSum1 / fSum0; fMu2 = fSum2 / fSum0 - fMu1 * fMu1; if (fMu2 <= 0.0) { //otbGenericMsgDebugMacro( << "Potential NAN detected in function MakeSumAndMoments."); fMu3 = 0.0; fMu4 = 4.0; fDataAvailable = false; return; } double sigma = sqrt(fMu2); std::vector tab(inputSize); std::vector::iterator iterTab = tab.begin(); inputIter.GoToBegin(); while (!inputIter.IsAtEnd()) { *iterTab = (static_cast (inputIter.Get()) - fMu1) / sigma; ++inputIter; ++iterTab; } fMu3 = fMu4 = 0.0; for (unsigned int i = 0; i < inputSize; ++i) { pixel = tab[i]; pixel_2 = pixel * pixel; fMu3 += pixel * pixel_2; fMu4 += pixel_2 * pixel_2; } fMu3 /= fSum0; fMu4 /= fSum0; otbGenericMsgDebugMacro(<< "Moments: " << fMu1 << ",\t" << fMu2 << ",\t" << fMu3 << ",\t" << fMu4); fDataAvailable = true; //return 0; } /* ================= moments -> cumulants transformation ============= */ template void CumulantsForEdgeworth ::MakeCumulants() { if (fDataAvailable) { fMean = fMu1; fVariance = fMu2; fSkewness = fMu3; fKurtosis = fMu4 - 3.0; } //return 0; } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbKullbackLeiblerProfileImageFilter.h000066400000000000000000000147211301006202600327640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKullbackLeiblerProfileImageFilter_h #define otbKullbackLeiblerProfileImageFilter_h #include #include "itkArray.h" #include "itkArray2D.h" #include "itkVariableLengthVector.h" #include "otbBinaryFunctorNeighborhoodVectorImageFilter.h" namespace otb { /** \class CumulantsForEdgeworthProfile * \brief Helper class for KullbackLeiblerProfileImageFilter. Please refer to KullbackLeibleProfileImageFilter. * * * \ingroup OTBChangeDetection */ template class CumulantsForEdgeworthProfile { public: typedef itk::Vector CumulantType; typedef std::vector CumulantSet; typedef CumulantSet::iterator Iterator; CumulantsForEdgeworthProfile (const TInput& input, std::vector >& mask); virtual ~CumulantsForEdgeworthProfile () {} // Kullback-Leibler Profile template itk::VariableLengthVector KL_profile(CumulantsForEdgeworthProfile& cumulants); // Kullback-Leibler divergence at a given scale double KL_profile(const CumulantType& cumulants1, const CumulantType& cumulants2); // Access to data inline CumulantType& GetCumulantAtScale(int i) { return this->fCum[i]; } // Check data availability inline bool IsDataAvailable() const { return this->fDataAvailable; } // debug int m_debug; protected: // Momentum Estimation from encapsulated neighborhood int MakeSumAndMoments(const TInput& input, std::vector >& mask); // momentum estimation from the smaller window int InitSumAndMoments(const TInput& input, itk::Array2D& mask); // int ReInitSumAndMoments(const TInput& input, itk::Array2D& mask, int level); // transformation moment -> cumulants (for Edgeworth) int MakeCumulants(); // Internal variables double fSum0, fSum1, fSum2, fSum3, fSum4; CumulantSet fMu; CumulantSet fCum; bool fDataAvailable; private: CumulantsForEdgeworthProfile (); // Not implemented CumulantsForEdgeworthProfile (const TInput& input); // Not implemented }; namespace Functor { /** \class KullbackLeiblerProfile * \brief Functor for KullbackLeiblerProfileImageFilter. Please refer to KullbackLeiblerProfileImageFilter. * * * \ingroup OTBChangeDetection */ template class KullbackLeiblerProfile { public: KullbackLeiblerProfile (); virtual ~KullbackLeiblerProfile () {} // Gives the radius min and max of neighborhood void SetRadius(const unsigned char& min, const unsigned char& max); unsigned char GetRadiusMin(void); unsigned char GetRadiusMax(void); // Gives the size of the profile int GetNumberOfComponentsPerPixel() const { return m_mask.size(); } // functor TOutput operator ()(const TInput1& it1, const TInput2& it2); protected: // Make the set of masks to play the increase in window size void MakeMultiscaleProfile(); // Internal attributes unsigned char m_RadiusMin; unsigned char m_RadiusMax; std::vector > m_mask; }; } // Functor /** \class KullbackLeiblerProfileImageFilter * \brief Implements neighborhood-wise the computation of KullbackLeibler profile over Edgeworth approximation. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input images, and for * each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the first four cumulants of the two pixel values * - compute the value of the Edgeorth approximation of the KL distance * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension (all 2D) * * See article of Lin Saito et Levine * "Edgeworth Approximation of the Kullback-Leibler Distance Towards Problems in Image Analysis" * and * "Edgeworth Expansions of the Kullback-Leibler Information" (submitted to JASA, nov 25, 1999) * http://www.math.ucdavis.edu/~saito/publications * * TOutput is expected to be a itk::VariableLengthVector< TPixel > and comes from an otbVectorImage< TPixel, 2 > * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT KullbackLeiblerProfileImageFilter : public BinaryFunctorNeighborhoodVectorImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::KullbackLeiblerProfile< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef KullbackLeiblerProfileImageFilter Self; typedef /*typename*/ BinaryFunctorNeighborhoodVectorImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::KullbackLeiblerProfile< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); protected: KullbackLeiblerProfileImageFilter() {} ~KullbackLeiblerProfileImageFilter() ITK_OVERRIDE {} private: KullbackLeiblerProfileImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKullbackLeiblerProfileImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbKullbackLeiblerProfileImageFilter.txx000066400000000000000000000267061301006202600333660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKullbackLeiblerProfileImageFilter_txx #define otbKullbackLeiblerProfileImageFilter_txx #include #include "otbKullbackLeiblerProfileImageFilter.h" #include "otbMath.h" namespace otb { /* ******************************************************************* * Classe CumulantsForEdgeworthProfile * ******************************************************************** */ template CumulantsForEdgeworthProfile ::CumulantsForEdgeworthProfile (const TInput& input, std::vector >& mask) { m_debug = MakeSumAndMoments(input, mask); MakeCumulants(); } /* ===================== Kullback-Leibler Profile ==================== */ template template itk::VariableLengthVector CumulantsForEdgeworthProfile ::KL_profile(CumulantsForEdgeworthProfile& cumulants) { itk::VariableLengthVector resu(fCum.size()); Iterator iter1 = fCum.begin(); Iterator iter2 = cumulants.fCum.begin(); for (unsigned int level = 0; level < resu.GetSize(); level++) resu[level] = KL_profile((*iter1++), (*iter2++)); return resu; } /* =========== Kullback-Leibler divergence at a given scale ========== */ template double CumulantsForEdgeworthProfile ::KL_profile (const CumulantType& cumulants1, const CumulantType& cumulants2) { double cum1 = cumulants1[0]; double cum2 = cumulants1[1]; double cum3 = cumulants1[2]; // double cum4 = cumulants1[3]; // unused double sqrt_cum2 = sqrt(cum2); double cum2_3 = cum2 * cum2 * cum2; double cum3_2 = cum3 * cum3; double tilde_cum1 = cumulants2[0]; double tilde_cum2 = cumulants2[1]; double tilde_cum3 = cumulants2[2]; double tilde_cum4 = cumulants2[3]; double tilde_cum2_2 = cum2 * cum2; double tilde_cum2_3 = cum2 * tilde_cum2_2; double tilde_cum2_6 = tilde_cum2_3 * tilde_cum2_3; double tilde_cum3_2 = tilde_cum3 * tilde_cum3; double beta = sqrt_cum2 / tilde_cum2; double alpha = (cum1 - tilde_cum1) / tilde_cum2; double alpha_2 = alpha * alpha; double alpha_4 = alpha_2 * alpha_2; double alpha_6 = alpha_2 * alpha_4; double beta_2 = beta * beta; double beta_4 = beta_2 * beta_2; double beta_6 = beta_2 * beta_4; double c2 = alpha_2 + beta_2; double c3 = alpha * (alpha_2 + 3.0 * beta_2); double c4 = alpha_4 + 6.0 * alpha_2 * beta_2 + 3.0 * beta_4; double c6 = alpha_6 + 15.0 * alpha_4 * beta_2 + 45.0 * alpha_2 * beta_4 + 15.0 * beta_6; double a1 = c3 - 3.0 * alpha / tilde_cum2; double a2 = c4 - 6.0 * c2 / tilde_cum2 + 3.0 / tilde_cum2_2; // Watch for tilde_cum2_2 mistake in the article! double a3 = c6 - 15.0 * c4 / tilde_cum2 + 45.0 * c2 / tilde_cum2_2 - 15.0 / tilde_cum2_3; double tmp = cum1 - tilde_cum1 + sqrt_cum2; double resu = cum3_2 / (12.0 * cum2_3) + (log(tilde_cum2 / cum2) - 1.0 + tmp * tmp / tilde_cum2) / 2.0 - (tilde_cum3 * a1 / 6.0 + tilde_cum4 * a2 / 24.0 + tilde_cum3_2 * a3 / 72.0) - tilde_cum3_2 * (c6 - 6.0 * c4 / cum2 + 9.0 * c2 / tilde_cum2_2) / 72.0 - 10.0 * cum3 * tilde_cum3 * (cum1 - tilde_cum1) * (cum2 - tilde_cum2) / tilde_cum2_6; if (vnl_math_isnan(resu) || resu > 1e3) resu = 1e3; return resu < 0.0 ? 0.0 : resu; } /* ====== Moments estimation from nested neighborhoods ==== */ template int CumulantsForEdgeworthProfile ::MakeSumAndMoments (const TInput& input, std::vector >& mask) { fMu.resize(mask.size()); std::vector >::iterator iter = mask.begin(); if (InitSumAndMoments (input, (*iter++))) return 1; for (unsigned int level = 1; level < mask.size(); level++) if (ReInitSumAndMoments(input, (*iter++), level)) return 1; return 0; } /* ===================== Moments estimation ====================== */ /* =============== from the small window size =========== */ template int CumulantsForEdgeworthProfile ::InitSumAndMoments (const TInput& input, itk::Array2D& mask) { fSum0 = fSum1 = fSum2 = fSum3 = fSum4 = 0.0; fMu[0].Fill(0.0); unsigned int i, j; unsigned long k = 0; double pixel, pixel_2; // for ( unsigned long i = 0; i < input.Size(); ++i ) for (i = 0; i < mask.rows(); ++i) { for (j = 0; j < mask.cols(); ++j) { // std::cerr << "(" << i << "," << j << ") k=" << k << " "; if (mask.get(i, j) == 1) { pixel = static_cast (input.GetPixel(k)); pixel_2 = pixel * pixel; fSum0 += 1.0; fSum1 += pixel; fSum2 += pixel_2; fSum3 += pixel_2 * pixel; fSum4 += pixel_2 * pixel_2; // std::cerr << "*\n"; } ++k; } } if (fSum0 == 0.0) { fDataAvailable = false; return 1; } double mu1, mu2; mu1 = fSum1 / fSum0; mu2 = fSum2 / fSum0 - mu1 * mu1; if (mu2 == 0.0) { fDataAvailable = false; return 1; } double sigma = sqrt(mu2); itk::VariableLengthVector tab(input.Size()); double * x = const_cast (tab.GetDataPointer()); for (unsigned long cp = 0; cp < input.Size(); ++cp) *x++ = (static_cast (input.GetPixel(cp)) - mu1) / sigma; double mu3 = 0.0; double mu4 = 0.0; x = const_cast (tab.GetDataPointer()); // for ( unsigned long i = 0; i < input.Size(); ++i ) for (i = 0; i < mask.rows(); ++i) { for (j = 0; j < mask.cols(); ++j) { if (mask.get(i, j) == 1) { pixel = *x++; pixel_2 = pixel * pixel; mu3 += pixel * pixel_2; mu4 += pixel_2 * pixel_2; } else ++x; } } mu3 /= fSum0; mu4 /= fSum0; if (vnl_math_isnan(mu3) || vnl_math_isnan(mu4)) { fDataAvailable = false; return 1; } fMu[0][0] = mu1; fMu[0][1] = mu2; fMu[0][2] = mu3; fMu[0][3] = mu4; fDataAvailable = true; return 0; } /* ================ Window size growth ============ */ template int CumulantsForEdgeworthProfile ::ReInitSumAndMoments (const TInput& input, itk::Array2D& mask, int level) { fMu[level].Fill(0.0); // mise a jour du comptage... double sum0 = 0.0, sum1 = 0.0, sum2 = 0.0, sum3 = 0.0, sum4 = 0.0; double pixel, pixel_2; unsigned int i, j; unsigned long k = 0L; // for ( unsigned long i = 0; i < input.Size(); ++i ) for (i = 0; i < mask.rows(); ++i) { for (j = 0; j < mask.cols(); ++j) { if (mask.get(i, j) == 1) { pixel = static_cast (input.GetPixel(k)); pixel_2 = pixel * pixel; sum0 += 1.0; sum1 += pixel; sum2 += pixel_2; sum3 += pixel * pixel_2; sum4 += pixel_2 * pixel_2; } ++k; } } fSum0 += sum0; fSum1 += sum1; fSum2 += sum2; fSum3 += sum3; fSum4 += sum4; double mu = fSum1 / fSum0; double mu_2 = mu * mu; double mu_3 = mu_2 * mu; double mu_4 = mu_2 * mu_2; fMu[level][0] = mu; fMu[level][1] = fSum2 / fSum0 - mu_2; double sigma = sqrt(fSum2); double sigma_2 = fSum2; double sigma_3 = sigma * sigma_2; double sigma_4 = sigma_2 * sigma_2; fMu[level][2] = (fSum3 - 3.0 * mu * fSum2 + 3.0 * mu_2 * fSum1 - fSum0 * mu_3) / (sigma_3 * fSum0); fMu[level][3] = (fSum4 - 4.0 * mu * fSum3 + 6.0 * mu_2 * fSum2 - 4.0 * mu_3 * fSum1 + fSum0 * mu_4) / (sigma_4 * fSum0); return 0; } /* =========== transformation moment -> cumulants ==================== */ template int CumulantsForEdgeworthProfile ::MakeCumulants() { if (!IsDataAvailable()) return 1; fCum.resize(fMu.size()); fCum = fMu; for (unsigned int i = 0; i < fCum.size(); ++i) fCum[i][3] -= 3.0; return 0; } /* ******************************************************************* * * Functor * * ******************************************************************** */ namespace Functor { template KullbackLeiblerProfile ::KullbackLeiblerProfile () { m_RadiusMin = 1; m_RadiusMax = 3; } /* =========== Gives the radius min and max of neighborhood ========== */ template void KullbackLeiblerProfile ::SetRadius(const unsigned char& min, const unsigned char& max) { m_RadiusMin = min < max ? min : max; m_RadiusMax = max > min ? max : min; MakeMultiscaleProfile(); } template unsigned char KullbackLeiblerProfile ::GetRadiusMin(void) { return m_RadiusMin; } template unsigned char KullbackLeiblerProfile ::GetRadiusMax(void) { return m_RadiusMax; } /* ====== Make the set of masks to play the increase in window size == */ template void KullbackLeiblerProfile ::MakeMultiscaleProfile() { m_mask.resize(m_RadiusMax - m_RadiusMin + 1); int lenMax = 2 * m_RadiusMax + 1; int i, j, middle = m_RadiusMax; // let's begin by the smaller neighborhood std::vector >::iterator outer_iter = m_mask.begin(); (*outer_iter).SetSize(lenMax, lenMax); (*outer_iter).fill(0); for (i = middle - m_RadiusMin; i <= middle + m_RadiusMin; ++i) for (j = middle - m_RadiusMin; j <= middle + m_RadiusMin; ++j) (*outer_iter).put(i, j, 1); // std::cerr << "outerIter = " << (*outer_iter) << std::endl; // let's continue with increasing neighborhoods ++outer_iter; for (int radius = m_RadiusMin + 1; radius <= m_RadiusMax; ++radius) { (*outer_iter).SetSize(lenMax, lenMax); (*outer_iter).fill(0); for (i = middle - radius; i <= middle + radius; ++i) { (*outer_iter).put(i, middle - radius, 1); (*outer_iter).put(i, middle + radius, 1); (*outer_iter).put(middle - radius, i, 1); (*outer_iter).put(middle + radius, i, 1); } // std::cerr << "outerIter = " << (*outer_iter) << std::endl; ++outer_iter; } } /* ========================== Functor ================================ */ template TOutput KullbackLeiblerProfile ::operator() (const TInput1 &it1, const TInput2 &it2) { CumulantsForEdgeworthProfile cum1(it1, m_mask); if (cum1.m_debug) { itk::VariableLengthVector resu(m_RadiusMax - m_RadiusMin + 1); resu.Fill(1e3); return static_cast (resu); } CumulantsForEdgeworthProfile cum2(it2, m_mask); if (cum2.m_debug) { itk::VariableLengthVector resu(m_RadiusMax - m_RadiusMin + 1); resu.Fill(1e3); return static_cast (resu); } return static_cast (cum1.KL_profile(cum2) + cum2.KL_profile(cum1)); } } // Functor } // namespace otb #endif otbKullbackLeiblerSupervizedDistanceImageFilter.h000066400000000000000000000133211301006202600351130ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKullbackLeiblerSupervizedDistanceImageFilter_h #define otbKullbackLeiblerSupervizedDistanceImageFilter_h #include "otbKullbackLeiblerDistanceImageFilter.h" #include "otbROIdataConversion.h" namespace otb { /** \class KullbackLeiblerSupervizedDistanceImageFilter * \brief Implements KullbackLeibler distance over Edgeworth approximation, * between a Neighborhood and a predefined Region of Interest. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input * images, and for each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - compute the first four cumulants of the ROI * - cast the input 2 pixel value to \c double * - compute the first four cumulants of the pixel values * - compute the value of the Edgeorth approximation of the KL distance * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension * (e.g. all 2D, or all 3D, or all ND) * * See article of Lin Saito et Levine * "Edgeworth Approximation of the Kullback-Leibler Distance Towards Problems in Image Analysis" * and * "Edgeworth Expansions of the Kullback-Leibler Information" (submitted to JASA, nov 25, 1999) * http://www.math.ucdavis.edu/~saito/publications * * \sa CumulantsForEdgeworth * * \ingroup OTBChangeDetection */ namespace Functor { /** \class KullbackLeiblerSupervizedDistance * \brief Functor for KullbackLeiblerSupervizedDistanceImageFilter. Please refer to KullbackLeiblerSupervizedDistanceImageFilter. * * * \ingroup OTBChangeDetection */ template class KullbackLeiblerSupervizedDistance { public: KullbackLeiblerSupervizedDistance (); virtual ~KullbackLeiblerSupervizedDistance (); /** performs the preprocess calculation on the training area */ void Evaluate(const typename TInput1::ImageType * img1, const typename TInput2::ImageType * img2, const TInputROIImage * imgROI); /** The functor by itself */ TOutput operator ()(const TInput1& it1, const TInput2& it2); protected: typedef ROIdataConversion< typename TInput1::ImageType, TInputROIImage> ROIConversionType1; typedef itk::ConstNeighborhoodIterator< typename ROIConversionType1::OutputImageType> ROIInputType1; typedef ROIdataConversion< typename TInput2::ImageType, TInputROIImage> ROIConversionType2; typedef itk::ConstNeighborhoodIterator< typename ROIConversionType2::OutputImageType> ROIInputType2; CumulantsForEdgeworth * m_CumROI1; CumulantsForEdgeworth * m_CumROI2; private: KullbackLeiblerSupervizedDistance (const KullbackLeiblerSupervizedDistance&); }; } // Functor template class ITK_EXPORT KullbackLeiblerSupervizedDistanceImageFilter : public otb::BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::KullbackLeiblerSupervizedDistance< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, TInputROIImage, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef KullbackLeiblerSupervizedDistanceImageFilter Self; typedef typename otb::BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::KullbackLeiblerSupervizedDistance< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, TInputROIImage, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Vectors that hold the training area */ typedef typename TInputImage1::PixelType MeasurementType1; typedef typename TInputImage2::PixelType MeasurementType2; typedef std::vector TrainingMeasureType1; typedef std::vector TrainingMeasureType2; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Method for creation of the training area and the computation * of some reference cumulants */ void SetTrainingArea(const TInputROIImage * trainingImage); protected: void BeforeThreadedGenerateData(void) ITK_OVERRIDE; KullbackLeiblerSupervizedDistanceImageFilter() { this->SetNumberOfRequiredInputs(3); } ~KullbackLeiblerSupervizedDistanceImageFilter() ITK_OVERRIDE {} private: KullbackLeiblerSupervizedDistanceImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKullbackLeiblerSupervizedDistanceImageFilter.txx" #endif #endif otbKullbackLeiblerSupervizedDistanceImageFilter.txx000066400000000000000000000121161301006202600355100ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKullbackLeiblerSupervizedDistanceImageFilter_txx #define otbKullbackLeiblerSupervizedDistanceImageFilter_txx #include "otbKullbackLeiblerSupervizedDistanceImageFilter.h" namespace otb { namespace Functor { template KullbackLeiblerSupervizedDistance ::KullbackLeiblerSupervizedDistance () { m_CumROI1 = ITK_NULLPTR; m_CumROI2 = ITK_NULLPTR; } template KullbackLeiblerSupervizedDistance ::~KullbackLeiblerSupervizedDistance () { delete m_CumROI1; m_CumROI1 = ITK_NULLPTR; delete m_CumROI2; m_CumROI2 = ITK_NULLPTR; } template void KullbackLeiblerSupervizedDistance ::Evaluate(const typename TInput1::ImageType * img1, const typename TInput2::ImageType * img2, const TInputROIImage * imgROI) { typedef ROIdataConversion ROIConversionType1; typedef itk::ConstNeighborhoodIterator< typename ROIConversionType1::OutputImageType> ROIInputType1; typename ROIConversionType1::Pointer conversion1 = ROIConversionType1::New(); conversion1->SetInputImage(img1); conversion1->SetROIImage(imgROI); conversion1->Update(); if (m_CumROI1 != ITK_NULLPTR) delete m_CumROI1; m_CumROI1 = new CumulantsForEdgeworth (conversion1->GetOutput()); if (!m_CumROI1->IsDataAvailable()) { throw itk::ExceptionObject(__FILE__, __LINE__, "Cumulants estimated from ROI in image 1 are not usable", ITK_LOCATION); } typedef ROIdataConversion ROIConversionType2; typedef itk::ConstNeighborhoodIterator< typename ROIConversionType2::OutputImageType> ROIInputType2; typename ROIConversionType2::Pointer conversion2 = ROIConversionType2::New(); conversion2->SetInputImage(img2); conversion2->SetROIImage(imgROI); conversion2->Update(); if (m_CumROI2 != ITK_NULLPTR) delete m_CumROI2; m_CumROI2 = new CumulantsForEdgeworth (conversion2->GetOutput()); if (!m_CumROI2->IsDataAvailable()) { throw itk::ExceptionObject(__FILE__, __LINE__, "Cumulants estimated from ROI in image 2 are not usable", ITK_LOCATION); } } template TOutput KullbackLeiblerSupervizedDistance ::operator() (const TInput1 &it1, const TInput2 &it2) { CumulantsForEdgeworth cum1(it1); if (!cum1.IsDataAvailable()) { return static_cast (0.); } CumulantsForEdgeworth cum2(it2); if (!cum2.IsDataAvailable()) { return static_cast (0.); } return static_cast (m_CumROI1->Divergence(cum1) + m_CumROI2->Divergence(cum2)); } } // end of namespace Functor /** * Connect the training area to build the reference pdfs, * with parameters to be hold by * Functor::KullbackLeiblerSupervizedDistance. * * Images 1 & 2 are supposed to be already connected. */ template void KullbackLeiblerSupervizedDistanceImageFilter ::SetTrainingArea(const TInputROIImage * trainingImage) { this->itk::ProcessObject::SetNthInput(2, const_cast(trainingImage)); } template void KullbackLeiblerSupervizedDistanceImageFilter ::BeforeThreadedGenerateData(void) { typename TInputImage1::ConstPointer inputPtr1 = dynamic_cast(this->GetInput(0)); typename TInputImage2::ConstPointer inputPtr2 = dynamic_cast(this->GetInput(1)); typename TInputROIImage::ConstPointer trainingImage = static_cast(this->itk::ProcessObject::GetInput(2)); this->GetFunctor().Evaluate(inputPtr1, inputPtr2, trainingImage); } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbLHMI.h000066400000000000000000000120151301006202600250260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLHMI_h #define otbLHMI_h #include #include "itkHistogram.h" namespace otb { namespace Functor { /** \class LHMI * \brief TODO * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the difference of the two pixel values * - compute the value of the LHMI * - cast the \c double value resulting to the pixel type of the output image * * * \ingroup OTBChangeDetection */ template class LHMI { public: typedef typename std::vector VectorType; typedef typename VectorType::iterator IteratorType; typedef typename std::vector VectorOfVectorType; typedef typename VectorOfVectorType::iterator VecOfVecIteratorType; typedef double HistogramFrequencyType; typedef typename itk::Statistics::Histogram HistogramType; typedef typename HistogramType::MeasurementVectorType MeasurementVectorType; typedef typename HistogramType::SizeType HistogramSizeType; typedef typename HistogramType::Iterator HistogramIteratorType; LHMI() {} virtual ~LHMI() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB) { HistogramType::Pointer histogram; /** The histogram size. */ HistogramSizeType histogramSize(2); /** The lower bound for samples in the histogram. */ MeasurementVectorType lowerBound(2); /** The upper bound for samples in the histogram. */ MeasurementVectorType upperBound(2); double upperBoundIncreaseFactor = 0.001; histogramSize.Fill(256); TOutput maxA = itA.GetPixel(0); TOutput minA = itA.GetPixel(0); TOutput maxB = itB.GetPixel(0); TOutput minB = itB.GetPixel(0); for (unsigned long pos = 0; pos < itA.Size(); ++pos) { TOutput value = static_cast(itA.GetPixel(pos)); if (value > maxA) maxA = value; else if (value < minA) minA = value; value = static_cast(itB.GetPixel(pos)); if (value > maxB) maxB = value; else if (value < minB) minB = value; } // Initialize the upper and lower bounds of the histogram. lowerBound[0] = minA; lowerBound[1] = minB; upperBound[0] = maxA + (maxA - minA) * upperBoundIncreaseFactor; upperBound[1] = maxB + (maxB - minB) * upperBoundIncreaseFactor; histogram = HistogramType::New(); histogram->SetMeasurementVectorSize(2); histogram->Initialize(histogramSize, lowerBound, upperBound); for (unsigned long pos = 0; pos < itA.Size(); ++pos) { typename HistogramType::IndexType sample(2); sample[0] = itA.GetPixel(pos); sample[1] = itB.GetPixel(pos); /*if(sample[0]!=NumericTraits::Zero && sample[1]!=NumericTraits::Zero)*/ histogram->IncreaseFrequencyOfIndex(sample, 1); } TOutput entropyX = itk::NumericTraits::Zero; TOutput entropyY = itk::NumericTraits::Zero; TOutput jointEntropy = itk::NumericTraits::Zero; HistogramFrequencyType totalFreq = histogram->GetTotalFrequency(); for (unsigned int i = 0; i < histogram->GetSize()[0]; ++i) { HistogramFrequencyType freq = histogram->GetFrequency(i, 0); if (freq > 0) { entropyX += freq * vcl_log(freq); } } entropyX = -entropyX / static_cast(totalFreq) + vcl_log(totalFreq); for (unsigned int i = 0; i < histogram->GetSize()[1]; ++i) { HistogramFrequencyType freq = histogram->GetFrequency(i, 1); if (freq > 0) { entropyY += freq * vcl_log(freq); } } entropyY = -entropyY / static_cast(totalFreq) + vcl_log(totalFreq); HistogramIteratorType it = histogram->Begin(); HistogramIteratorType end = histogram->End(); while (it != end) { HistogramFrequencyType freq = it.GetFrequency(); if (freq > 0) { jointEntropy += freq * vcl_log(freq); } ++it; } jointEntropy = -jointEntropy / static_cast(totalFreq) + vcl_log(totalFreq); return static_cast(jointEntropy / (entropyX + entropyY)); } }; } } #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbLHMIChangeDetector.h000066400000000000000000000056431301006202600276370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLHMIChangeDetector_h #define otbLHMIChangeDetector_h #include "otbBinaryFunctorNeighborhoodImageFilter.h" #include "otbLHMI.h" namespace otb { /** \class LHMIChangeDetector * \brief Implements neighborhood-wise the computation of the * cumulant-based approximation to mutual information. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input images, and for * each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the difference of the two pixel values * - compute the value of the LHMI * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension * (e.g. all 2D, or all 3D, or all ND) * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT LHMIChangeDetector : public BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::LHMI< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef LHMIChangeDetector Self; typedef BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::LHMI< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(LHMIChangeDetector, SuperClass); protected: LHMIChangeDetector() {} ~LHMIChangeDetector() ITK_OVERRIDE {} private: LHMIChangeDetector(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbMeanDifference.h000066400000000000000000000023061301006202600271320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanDifference_h #define otbMeanDifference_h namespace otb { namespace Functor { template class MeanDifference { public: MeanDifference() {} virtual ~MeanDifference() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB) { TOutput meanA = 0.0; TOutput meanB = 0.0; for (unsigned long pos = 0; pos < itA.Size(); ++pos) { meanA += static_cast(itA.GetPixel(pos)); meanB += static_cast(itB.GetPixel(pos)); } return static_cast((meanA - meanB) / itA.Size()); } }; } } #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbMeanDifferenceImageFilter.h000066400000000000000000000057441301006202600312540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanDifferenceImageFilter_h #define otbMeanDifferenceImageFilter_h #include "otbBinaryFunctorNeighborhoodImageFilter.h" #include "otbMeanDifference.h" namespace otb { /** \class MeanDifferenceImageFilter * \brief Implements neighborhood-wise the computation of mean difference. * * This filter is parametrized over the types of the two * input images and the type of the output image. * * Numeric conversions (castings) are done by the C++ defaults. * * The filter will walk over all the pixels in the two input images, and for * each one of them it will do the following: * * - cast the input 1 pixel value to \c double * - cast the input 2 pixel value to \c double * - compute the difference of the two pixel values * - compute the value of the difference of means * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * The filter expect all images to have the same dimension * (e.g. all 2D, or all 3D, or all ND) * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT MeanDifferenceImageFilter : public BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::MeanDifference< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef MeanDifferenceImageFilter Self; typedef BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::MeanDifference< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(MeanDifferenceImageFilter, SuperClass); protected: MeanDifferenceImageFilter() {} ~MeanDifferenceImageFilter() ITK_OVERRIDE {} private: MeanDifferenceImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ChangeDetection/include/otbMeanRatio.h000066400000000000000000000035021301006202600261550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanRatio_h #define otbMeanRatio_h #include "otbBinaryFunctorNeighborhoodImageFilter.h" namespace otb { /** \class Functor::MeanRatio * * - compute the ratio of the two pixel values * - compute the value of the ratio of means * - cast the \c double value resulting to the pixel type of the output image * - store the casted value into the output image. * * \ingroup Functor * * \ingroup OTBChangeDetection */ namespace Functor { template class MeanRatio { public: MeanRatio() {} virtual ~MeanRatio() {} inline TOutput operator ()(const TInput1& itA, const TInput2& itB) { TOutput meanA = 0.0; TOutput meanB = 0.0; for (unsigned long pos = 0; pos < itA.Size(); ++pos) { meanA += static_cast(itA.GetPixel(pos)); meanB += static_cast(itB.GetPixel(pos)); } meanA /= itA.Size(); meanB /= itB.Size(); //std::cout<<"meanA= "< class ITK_EXPORT MeanRatioImageFilter : public BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::MeanRatio< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef MeanRatioImageFilter Self; typedef BinaryFunctorNeighborhoodImageFilter< TInputImage1, TInputImage2, TOutputImage, Functor::MeanRatio< typename itk::ConstNeighborhoodIterator, typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(MeanRatioImageFilter, SuperClass); protected: MeanRatioImageFilter() {} ~MeanRatioImageFilter() ITK_OVERRIDE {} private: MeanRatioImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif otbMultivariateAlterationDetectorImageFilter.h000066400000000000000000000160321301006202600345150ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultivariateAlterationDetectorImageFilter_h #define otbMultivariateAlterationDetectorImageFilter_h #include "otbStreamingStatisticsVectorImageFilter.h" #include "otbConcatenateVectorImageFilter.h" #include "vnl/vnl_vector.h" #include "vnl/vnl_matrix.h" namespace otb { /** \class MultivariateAlterationDetectorImageFilter * \brief This filter implements the Multivariate Alteration Detector * * This filter implements the Multivariate Alteration Detector, based * on the following work: * * A. A. Nielsen and K. Conradsen, "Multivariate alteration detection * (mad) in multispectral, bi-temporal image data: a new approach to * change detection studies," Remote Sens. Environ., vol. 64, * pp. 1-19, (1998) * * Multivariate Alteration Detector takes two images as inputs and * produce a set of N change maps as a VectorImage (where N is the * maximum of number of bands in first and second image) with the * following properties: * * - Change maps are differences of a pair of linear combinations of * bands from image 1 and bands from image 2 chosen to maximize the * correlation. * - Each change map is orthogonal to the others. * * This is a statistical method which can handle different modalities * and even different bands and number of bands between images. * * If numbers of bands in image 1 and 2 are equal, then change maps * are sorted by increasing correlation. If number of bands is * different, the change maps are sorted by decreasing correlation. * * The GetV1() and GetV2() methods allow retrieving the linear * combinations used to generate the Mad change maps as a vnl_matrix of * double, and the GetRho() method allows retrieving the correlation * associated to each Mad change maps as a vnl_vector. * * This filter has been implemented from the Matlab code kindly made * available by the authors here: * http://www2.imm.dtu.dk/~aa/software.html * * Both cases (same and different number of bands) have been validated * by comparing the output image to the output produced by the Matlab * code, and the reference images for testing have been generated from * the Matlab code using Octave. * * \ingroup Streamed, Multithreaded * * \ingroup OTBChangeDetection */ template class ITK_EXPORT MultivariateAlterationDetectorImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef MultivariateAlterationDetectorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultivariateAlterationDetectorImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; /** Internal filters types */ typedef StreamingStatisticsVectorImageFilter CovarianceEstimatorType; typedef typename CovarianceEstimatorType::Pointer CovarianceEstimatorPointer; typedef otb::ConcatenateVectorImageFilter ConcatenateImageFilterType; typedef typename ConcatenateImageFilterType::Pointer ConcatenateImageFilterPointer; typedef typename CovarianceEstimatorType::MatrixObjectType MatrixObjectType; typedef typename MatrixObjectType::ComponentType MatrixType; typedef typename MatrixType::InternalMatrixType InternalMatrixType; typedef typename CovarianceEstimatorType::RealPixelType VectorType; typedef typename VectorType::ValueType RealType; typedef vnl_vector VnlVectorType; typedef vnl_matrix VnlMatrixType; /** Get the mean of bands from image 1 */ itkGetMacro(Mean1,VnlVectorType); /** Get the mean of bands from image 2 */ itkGetMacro(Mean2,VnlVectorType); /** Get the linear combinations of bands of image 1 associated to * multivariate alteration detector. This is a square matrix of * size nbBand of image 1. */ itkGetMacro(V1, VnlMatrixType); /** Get the linear combinations of bands of image 2 associated to * multivariate alteration detector. This is a square matrix of * size nbBand of image 2. */ itkGetMacro(V2, VnlMatrixType); /** Get the correlation coefficient associated with each mad.*/ itkGetMacro(Rho, VnlVectorType); /** Get the covariance estimator (for progress reporting purposes) */ itkGetObjectMacro(CovarianceEstimator, CovarianceEstimatorType); /** Connect one of the operands for pixel-wise addition */ void SetInput1(const TInputImage * image1); /** Connect one of the operands for pixel-wise addition */ void SetInput2(const TInputImage * image2); /** Get the inputs */ const TInputImage * GetInput1(); const TInputImage * GetInput2(); protected: MultivariateAlterationDetectorImageFilter(); ~MultivariateAlterationDetectorImageFilter() ITK_OVERRIDE {} void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; private: MultivariateAlterationDetectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CovarianceEstimatorPointer m_CovarianceEstimator; MatrixType m_CovarianceMatrix; VectorType m_MeanValues; VnlMatrixType m_V1; VnlMatrixType m_V2; VnlVectorType m_Mean1; VnlVectorType m_Mean2; VnlVectorType m_Rho; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMultivariateAlterationDetectorImageFilter.txx" #endif #endif otbMultivariateAlterationDetectorImageFilter.txx000066400000000000000000000246201301006202600351130ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultivariateAlterationDetectorImageFilter_txx #define otbMultivariateAlterationDetectorImageFilter_txx #include "otbMultivariateAlterationDetectorImageFilter.h" #include "otbMath.h" #include "vnl/algo/vnl_matrix_inverse.h" #include "vnl/algo/vnl_generalized_eigensystem.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template MultivariateAlterationDetectorImageFilter ::MultivariateAlterationDetectorImageFilter() { this->SetNumberOfRequiredInputs(2); m_CovarianceEstimator = CovarianceEstimatorType::New(); } template void MultivariateAlterationDetectorImageFilter ::SetInput1(const TInputImage * image1) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast(image1)); } template const typename MultivariateAlterationDetectorImageFilter ::InputImageType * MultivariateAlterationDetectorImageFilter ::GetInput1() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template void MultivariateAlterationDetectorImageFilter ::SetInput2(const TInputImage * image2) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast(image2)); } template const typename MultivariateAlterationDetectorImageFilter ::InputImageType * MultivariateAlterationDetectorImageFilter ::GetInput2() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void MultivariateAlterationDetectorImageFilter ::GenerateOutputInformation() { // Call superclass implementation Superclass::GenerateOutputInformation(); // Retrieve input images pointers const TInputImage * input1Ptr = this->GetInput1(); const TInputImage * input2Ptr = this->GetInput2(); TOutputImage * outputPtr = const_cast(this->GetOutput()); // Get the number of components for each image unsigned int nbComp1 = input1Ptr->GetNumberOfComponentsPerPixel(); unsigned int nbComp2 = input2Ptr->GetNumberOfComponentsPerPixel(); unsigned int outNbComp = std::max(nbComp1, nbComp2); outputPtr->SetNumberOfComponentsPerPixel(outNbComp); if(input1Ptr->GetLargestPossibleRegion() != input2Ptr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Input images does not have the same size!"); } // First concatenate both images ConcatenateImageFilterPointer concatenateFilter = ConcatenateImageFilterType::New(); concatenateFilter->SetInput1(input1Ptr); concatenateFilter->SetInput2(input2Ptr); // The compute covariance matrix // TODO: implement switch off of this computation m_CovarianceEstimator->SetInput(concatenateFilter->GetOutput()); m_CovarianceEstimator->Update(); m_CovarianceMatrix = m_CovarianceEstimator->GetCovariance(); m_MeanValues = m_CovarianceEstimator->GetMean(); // Extract sub-matrices of the covariance matrix VnlMatrixType s11 = m_CovarianceMatrix.GetVnlMatrix().extract(nbComp1, nbComp1); VnlMatrixType s22 = m_CovarianceMatrix.GetVnlMatrix().extract(nbComp2, nbComp2, nbComp1, nbComp1); VnlMatrixType s12 = m_CovarianceMatrix.GetVnlMatrix().extract(nbComp1, nbComp2, 0, nbComp1); VnlMatrixType s21 = s12.transpose(); // Extract means m_Mean1 = VnlVectorType(nbComp1, 0); m_Mean2 = VnlVectorType(nbComp2, 0); for(unsigned int i = 0; i(s22); // Build the generalized eigensystem VnlMatrixType s12s22is21 = s12 * invs22 *s21; vnl_generalized_eigensystem ges(s12s22is21, s11); m_V1 = ges.V; // Compute canonical correlation matrix m_Rho = ges.D.get_diagonal(); m_Rho = m_Rho.apply(&vcl_sqrt); // We do not need to scale v1 since the // vnl_generalized_eigensystem already gives unit variance VnlMatrixType invstderr1 = s11.apply(&vcl_sqrt); invstderr1 = invstderr1.apply(&InverseValue); VnlVectorType diag1 = invstderr1.get_diagonal(); invstderr1.fill(0); invstderr1.set_diagonal(diag1); VnlMatrixType sign1 = VnlMatrixType(nbComp1, nbComp1, 0); VnlMatrixType aux4 = invstderr1 * s11 * m_V1; VnlVectorType aux5 = VnlVectorType(nbComp1, 0); for(unsigned int i = 0; i < nbComp1; ++i) { aux5=aux5 + aux4.get_row(i); } sign1.set_diagonal(aux5); sign1 = sign1.apply(&SignOfValue); m_V1 = m_V1 * sign1; m_V2 = invs22*s21*m_V1; // Scale v2 for unit variance VnlMatrixType aux1 = m_V2.transpose() * (s22 * m_V2); VnlVectorType aux2 = aux1.get_diagonal(); aux2 = aux2.apply(&vcl_sqrt); aux2 = aux2.apply(&InverseValue); VnlMatrixType aux3 = VnlMatrixType(aux2.size(), aux2.size(), 0); aux3.fill(0); aux3.set_diagonal(aux2); m_V2 = m_V2 * aux3; } else { VnlMatrixType sl(nbComp1+nbComp2, nbComp1+nbComp2, 0); VnlMatrixType sr(nbComp1+nbComp2, nbComp1+nbComp2, 0); sl.update(s12, 0, nbComp1); sl.update(s21, nbComp1, 0); sr.update(s11, 0, 0); sr.update(s22, nbComp1, nbComp1); vnl_generalized_eigensystem ges(sl, sr); VnlMatrixType V = ges.V; V.fliplr(); m_V1 = V.extract(nbComp1, nbComp1); m_V2 = V.extract(nbComp2, nbComp2, nbComp1, 0); m_Rho = ges.D.get_diagonal().flip().extract(std::max(nbComp1, nbComp2), 0); //Scale v1 to get a unit variance VnlMatrixType aux1 = m_V1.transpose() * (s11 * m_V1); VnlVectorType aux2 = aux1.get_diagonal(); aux2 = aux2.apply(&vcl_sqrt); aux2 = aux2.apply(&InverseValue); VnlMatrixType aux3 = VnlMatrixType(aux2.size(), aux2.size(), 0); aux3.set_diagonal(aux2); m_V1 = m_V1 * aux3; VnlMatrixType invstderr1 = s11.apply(&vcl_sqrt); invstderr1 = invstderr1.apply(&InverseValue); VnlVectorType diag1 = invstderr1.get_diagonal(); invstderr1.fill(0); invstderr1.set_diagonal(diag1); VnlMatrixType sign1 = VnlMatrixType(nbComp1, nbComp1, 0); VnlMatrixType aux4 = invstderr1 * s11 * m_V1; VnlVectorType aux5 = VnlVectorType(nbComp1, 0); for(unsigned int i = 0; i < nbComp1; ++i) { aux5=aux5 + aux4.get_row(i); } sign1.set_diagonal(aux5); sign1 = sign1.apply(&SignOfValue); m_V1 = m_V1 * sign1; // Scale v2 for unit variance aux1 = m_V2.transpose() * (s22 * m_V2); aux2 = aux1.get_diagonal(); aux2 = aux2.apply(&vcl_sqrt); aux2 = aux2.apply(&InverseValue); aux3 = VnlMatrixType(aux2.size(), aux2.size(), 0); aux3.fill(0); aux3.set_diagonal(aux2); m_V2 = m_V2 * aux3; VnlMatrixType sign2 = VnlMatrixType(nbComp2, nbComp2, 0); aux5 = (m_V1.transpose() * s12 * m_V2).transpose().get_diagonal(); sign2.set_diagonal(aux5); sign2 = sign2.apply(&SignOfValue); m_V2 = m_V2 * sign2; } } template void MultivariateAlterationDetectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve input images pointers const TInputImage * input1Ptr = this->GetInput1(); const TInputImage * input2Ptr = this->GetInput2(); TOutputImage * outputPtr = this->GetOutput(); typedef itk::ImageRegionConstIterator ConstIteratorType; typedef itk::ImageRegionIterator IteratorType; IteratorType outIt(outputPtr, outputRegionForThread); ConstIteratorType inIt1(input1Ptr, outputRegionForThread); ConstIteratorType inIt2(input2Ptr, outputRegionForThread); inIt1.GoToBegin(); inIt2.GoToBegin(); outIt.GoToBegin(); // Get the number of components for each image unsigned int nbComp1 = input1Ptr->GetNumberOfComponentsPerPixel(); unsigned int nbComp2 = input2Ptr->GetNumberOfComponentsPerPixel(); unsigned int outNbComp = outputPtr->GetNumberOfComponentsPerPixel(); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); while(!inIt1.IsAtEnd() && !inIt2.IsAtEnd() && !outIt.IsAtEnd()) { VnlVectorType x1(nbComp1, 0); VnlVectorType x1bis(outNbComp, 0); VnlVectorType x2(nbComp2, 0); VnlVectorType x2bis(outNbComp, 0); VnlVectorType mad(outNbComp, 0); for(unsigned int i = 0; i < nbComp1; ++i) { x1[i] = inIt1.Get()[i]; } for(unsigned int i = 0; i < nbComp2; ++i) { x2[i] = inIt2.Get()[i]; } VnlVectorType first = (x1-m_Mean1)*m_V1; VnlVectorType second = (x2-m_Mean2)*m_V2; for(unsigned int i = 0; i < nbComp1; ++i) { x1bis[i] = first[i]; } for(unsigned int i = 0; i < nbComp2; ++i) { x2bis[i] = second[i]; } mad = x1bis - x2bis; typename OutputImageType::PixelType outPixel(outNbComp); if(nbComp1 == nbComp2) { for(unsigned int i = 0; i InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; // Declare the type for the filter typedef otb::CBAMIChangeDetector< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbChangeDetectionTestDriver.cxx000066400000000000000000000014701301006202600312470ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbJHMIChangeDetectionTest); REGISTER_TEST(otbMeanDiffChangeDetectionTest); REGISTER_TEST(otbMultivariateAlterationDetectorImageFilterNew); REGISTER_TEST(otbMultivariateAlterationDetectorImageFilter); REGISTER_TEST(otbCBAMIChangeDetectionTest); REGISTER_TEST(otbKullbackLeiblerSupervizedDistanceImageFilter); REGISTER_TEST(otbCorrelChangeDetectionTest); REGISTER_TEST(otbKullbackLeiblerProfileImageFilter); REGISTER_TEST(otbKullbackLeiblerSupervizedDistanceImageFilterNew); REGISTER_TEST(otbKullbackLeiblerProfileImageFilterNew); REGISTER_TEST(otbKullbackLeiblerDistanceImageFilter); REGISTER_TEST(otbMeanRatioChangeDetectionTest); REGISTER_TEST(otbKullbackLeiblerDistanceImageFilterNew); REGISTER_TEST(otbLHMIChangeDetectionTest); } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbCorrelChangeDetectionTest.cxx000066400000000000000000000060601301006202600312420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" #include "otbCorrelationChangeDetector.h" #include "otbCommandProgressUpdate.h" int otbCorrelChangeDetectionTest(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Declare the types of the images typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; // Declare the type for the filter typedef otb::CorrelationChangeDetector< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbJHMIChangeDetectionTest.cxx000066400000000000000000000060611301006202600305440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" #include "otbJoinHistogramMIImageFilter.h" #include "otbCommandProgressUpdate.h" int otbJHMIChangeDetectionTest(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Declare the types of the images typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; // Declare the type for the filter typedef otb::JoinHistogramMIImageFilter< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbKullbackLeiblerDistanceImageFilter.cxx000066400000000000000000000041011301006202600330140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbKullbackLeiblerDistanceImageFilter.h" int otbKullbackLeiblerDistanceImageFilter(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Detection de changements par mesure de Kullback-Leibler, optimisee par un development de Edgeworth\n"; std::cerr << argv[0] << " imgAv imgAp imgResu winSize\n"; return 1; } char * fileName1 = argv[1]; char * fileName2 = argv[2]; char * fileNameOut = argv[3]; int winSize = atoi(argv[4]); const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::KullbackLeiblerDistanceImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(fileName1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(fileName2); FilterType::Pointer filter = FilterType::New(); filter->SetRadius((winSize - 1) / 2); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(fileNameOut); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbKullbackLeiblerDistanceImageFilterNew.cxx000066400000000000000000000021351301006202600334730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbKullbackLeiblerDistanceImageFilter.h" int otbKullbackLeiblerDistanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::KullbackLeiblerDistanceImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbKullbackLeiblerProfileImageFilter.cxx000066400000000000000000000044471301006202600326770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbKullbackLeiblerProfileImageFilter.h" int otbKullbackLeiblerProfileImageFilter(int argc, char * argv[]) { if (argc != 6) { std::cerr << "Detection de changements par mesure de Kullback-Leibler, optimisee par un development de Edgeworth\n"; std::cerr << argv[0] << " imgAv imgAp imgResu winSizeMin winSizeMax\n"; return 1; } char * fileName1 = argv[1]; char * fileName2 = argv[2]; char * fileNameOut = argv[3]; int winSizeMin = atoi(argv[4]); int winSizeMax = atoi(argv[5]); const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::KullbackLeiblerProfileImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(fileName1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(fileName2); FilterType::Pointer filter = FilterType::New(); filter->SetRadius((winSizeMin - 1) / 2, (winSizeMax - 1) / 2); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(fileNameOut); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbKullbackLeiblerProfileImageFilterNew.cxx000066400000000000000000000023521301006202600333420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbKullbackLeiblerProfileImageFilter.h" int otbKullbackLeiblerProfileImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::KullbackLeiblerProfileImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbKullbackLeiblerSupervizedDistanceImageFilter.cxx000066400000000000000000000070111301006202600350210ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbKullbackLeiblerSupervizedDistanceImageFilter.h" #include "otbCommandProgressUpdate.h" int otbKullbackLeiblerSupervizedDistanceImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned char TrainingPixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::Image TrainingImageType; typedef otb::ImageFileReader TrainingReaderType; if (argc != 6) { std::cout << "Invalid number of arguiments !!" << std::endl; return EXIT_FAILURE; } const char * inputImageFileName1 = argv[1]; const char * inputImageFileName2 = argv[2]; const char * inputTrainingImageFileName = argv[3]; const int winSize(atoi(argv[4])); const char * outputImageFileName = argv[5]; ImageType::Pointer img1 = ImageType::New(); ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(inputImageFileName1); //reader1->Update(); img1 = reader1->GetOutput(); ImageType::Pointer img2 = ImageType::New(); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(inputImageFileName2); //reader2->Update(); img2 = reader2->GetOutput(); TrainingImageType::Pointer imgRoi = TrainingImageType::New(); TrainingReaderType::Pointer readerRoi = TrainingReaderType::New(); readerRoi->SetFileName(inputTrainingImageFileName); //readerRoi->Update(); imgRoi = readerRoi->GetOutput(); typedef otb::KullbackLeiblerSupervizedDistanceImageFilter< ImageType, ImageType, TrainingImageType, ImageType> FilterType; FilterType::Pointer changeDetector = FilterType::New(); changeDetector->SetRadius((winSize - 1) / 2); changeDetector->SetInput1(img1); changeDetector->SetInput2(img2); // Once img1 and img2 are connected, it is time to connect imgRoi // to perform the parameters estimation of the non-changed area. changeDetector->SetTrainingArea(imgRoi); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); changeDetector->AddObserver(itk::ProgressEvent(), observer); typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(changeDetector->GetOutput()); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageFileName); writer->SetInput(rescaler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbKullbackLeiblerSupervizedDistanceImageFilterNew.cxx000066400000000000000000000024761301006202600355050ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbKullbackLeiblerSupervizedDistanceImageFilter.h" int otbKullbackLeiblerSupervizedDistanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned char TrainingPixelType; typedef otb::Image ImageType; typedef otb::Image TrainingImageType; typedef otb::KullbackLeiblerSupervizedDistanceImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbLHMIChangeDetectionTest.cxx000066400000000000000000000060401301006202600305430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" #include "otbLHMIChangeDetector.h" #include "otbCommandProgressUpdate.h" int otbLHMIChangeDetectionTest(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Declare the types of the images typedef double InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; // Declare the type for the filter typedef otb::LHMIChangeDetector< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbMeanDiffChangeDetectionTest.cxx000066400000000000000000000057421301006202600314730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" #include "otbMeanDifferenceImageFilter.h" #include "otbCommandProgressUpdate.h" int otbMeanDiffChangeDetectionTest(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Declare the types of the images typedef double InternalPixelType; typedef double OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; // Declare the type for the filter typedef otb::MeanDifferenceImageFilter< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(-1); rescaler->SetOutputMaximum(1); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ChangeDetection/test/otbMeanRatioChangeDetectionTest.cxx000066400000000000000000000060521301006202600316740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImage.h" #include "otbMeanRatioImageFilter.h" #include "otbCommandProgressUpdate.h" int otbMeanRatioChangeDetectionTest(int argc, char* argv[]) { if (argc < 5) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile1 inputImageFile2 radius outputImageFile " << std::endl; return -1; } // Define the dimension of the images const unsigned int Dimension = 2; // Declare the types of the images typedef float InternalPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType1; typedef otb::Image InputImageType2; typedef otb::Image ChangeImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; // Declare the type for the filter typedef otb::MeanRatioImageFilter< InputImageType1, InputImageType2, ChangeImageType> FilterType; ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * outputFilename = argv[4]; reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); writer->SetFileName(outputFilename); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); filter->SetRadius(atoi(argv[3])); rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); typedef otb::CommandProgressUpdate CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); writer->Update(); return EXIT_SUCCESS; } otbMultivariateAlterationDetectorImageFilter.cxx000066400000000000000000000041251301006202600344240ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ChangeDetection/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultivariateAlterationDetectorImageFilter.h" typedef otb::VectorImage ImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultivariateAlterationDetectorImageFilter MADFilterType; int otbMultivariateAlterationDetectorImageFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { MADFilterType::Pointer madFilter = MADFilterType::New(); return EXIT_SUCCESS; } int otbMultivariateAlterationDetectorImageFilter(int itkNotUsed(argc), char* argv[]) { char * infname1 = argv[1]; char * infname2 = argv[2]; char * outfname = argv[3]; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(infname1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(infname2); MADFilterType::Pointer madFilter = MADFilterType::New(); madFilter->SetInput1(reader1->GetOutput()); madFilter->SetInput2(reader2->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(madFilter->GetOutput()); writer->SetFileName(outfname); writer->Update(); std::cout<<"V1: "<GetV1()<GetV2()<GetRho()< class ITK_EXPORT ReliefColormapFunctor : public itk::Function::ColormapFunction { public: typedef ReliefColormapFunctor Self; typedef itk::Function::ColormapFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); typedef typename Superclass::RGBPixelType RGBPixelType; typedef typename Superclass::ScalarType ScalarType; typedef typename Superclass::RealType RealType; RGBPixelType operator ()(const TScalar&) const ITK_OVERRIDE; protected: ReliefColormapFunctor(){}; ~ReliefColormapFunctor() ITK_OVERRIDE {} private: ReliefColormapFunctor(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace functor } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbReliefColormapFunctor.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ColorMap/include/otbReliefColormapFunctor.txx000066400000000000000000000043361301006202600276340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReliefColormapFunctor_txx #define otbReliefColormapFunctor_txx #include "otbReliefColormapFunctor.h" namespace otb { namespace Functor { template typename ReliefColormapFunctor::RGBPixelType ReliefColormapFunctor ::operator() (const TScalar &v) const { float m_Borders[] = {0.0f, 0.00001f, 0.2f, 0.43f, 0.71f, 1.0f}; float m_RedValues[] = {0.75f, 0.64f, 0.47f, 0.89f, 0.58f, 1.0f}; float m_GreenValues[] = {0.91f, 0.84f, 0.76f, 0.90f, 0.32f, 1.0f}; float m_BlueValues[] = {0.96f, 0.59f, 0.40f, 0.57f, 0.00f, 1.0f}; // Map the input scalar between [0, 1]. RealType value = this->RescaleInputValue(v); int i = 1; while (value > m_Borders[i]) ++i; float factor = (value - m_Borders[i - 1]) / (m_Borders[i] - m_Borders[i - 1]); // Apply the color mapping. RealType red = m_RedValues[i - 1] + factor * (m_RedValues[i] - m_RedValues[i - 1]); RealType green = m_GreenValues[i - 1] + factor * (m_GreenValues[i] - m_GreenValues[i - 1]); RealType blue = m_BlueValues[i - 1] + factor * (m_BlueValues[i] - m_BlueValues[i - 1]); // Normalize the values red = vnl_math_max(0.0, red); red = vnl_math_min(1.0, red); green = vnl_math_max(0.0, green); green = vnl_math_min(1.0, green); blue = vnl_math_max(0.0, blue); blue = vnl_math_min(1.0, blue); // Set the rgb components after rescaling the values. RGBPixelType pixel; pixel[0] = this->RescaleRGBComponentValue(red); pixel[1] = this->RescaleRGBComponentValue(green); pixel[2] = this->RescaleRGBComponentValue(blue); return pixel; } } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ColorMap/include/otbScalarToRainbowRGBPixelFunctor.h000066400000000000000000000114031301006202600307150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarToRainbowRGBPixelFunctor_h #define otbScalarToRainbowRGBPixelFunctor_h #include "itkColormapFunction.h" namespace otb { namespace Functor { /** * \class HSVToRGBFunctor * \brief Function object to convert HSV value to RGB. * * * \sa ScalarToRainbowRGBPixelFunctor * * * \ingroup OTBColorMap */ template class ITK_EXPORT HSVToRGBFunctor { public: HSVToRGBFunctor(){}; ~HSVToRGBFunctor(){} inline TRGBPixel operator ()(double h, double s, double v) const { const double onethird = 1.0 / 3.0; const double onesixth = 1.0 / 6.0; const double twothird = 2.0 / 3.0; const double fivesixth = 5.0 / 6.0; double r, g, b; // compute RGB from HSV if (h > onesixth && h <= onethird) // green/red { g = 1.0; r = (onethird - h) / onesixth; b = 0.0; } else if (h > onethird && h <= 0.5) // green/blue { g = 1.0; b = (h - onethird) / onesixth; r = 0.0; } else if (h > 0.5 && h <= twothird) // blue/green { b = 1.0; g = (twothird - h) / onesixth; r = 0.0; } else if (h > twothird && h <= fivesixth) // blue/red { b = 1.0; r = (h - twothird) / onesixth; g = 0.0; } else if (h > fivesixth && h <= 1.0) // red/blue { r = 1.0; b = (1.0 - h) / onesixth; g = 0.0; } else // red/green { r = 1.0; g = h / onesixth; b = 0.0; } // add Saturation to the equation. r = (s * r + (1.0 - s)); g = (s * g + (1.0 - s)); b = (s * b + (1.0 - s)); r *= v; g *= v; b *= v; // std::cout << h << ", " << s << ", " << v << " -> " << r << ", " << g << ", " << b << std::endl; TRGBPixel ans; typedef typename TRGBPixel::ComponentType RGBComponentType; ans[0] = static_cast(r); ans[1] = static_cast(g); ans[2] = static_cast(b); return ans; } }; } namespace Functor { /** * \class ScalarToRainbowRGBPixelFunctor * \brief Function object which maps a scalar value into a rainbow RGB pixel value. * * Grayscale image is mapped to a color image where blue represents * small values and red represents big values. * * This function is compatible with the colormap hierarchy presented in * http://hdl.handle.net/1926/1452 * * \example BasicFilters/DEMToRainbowExample.cxx * * * \ingroup OTBColorMap */ template > class ITK_EXPORT ScalarToRainbowRGBPixelFunctor : public itk::Function::ColormapFunction // public itk::Functor::ScalarToRGBPixelFunctor { public: ScalarToRainbowRGBPixelFunctor(); ~ScalarToRainbowRGBPixelFunctor() ITK_OVERRIDE {} typedef ScalarToRainbowRGBPixelFunctor Self; typedef itk::Function::ColormapFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TRGBPixel RGBPixelType; typedef typename RGBPixelType::ComponentType RGBComponentType; typedef TScalar ScalarType; typedef HSVToRGBFunctor HSVToRGBFunctorType; RGBPixelType operator ()(const TScalar&) const ITK_OVERRIDE; /** Set the input maximum to be mapped to red * \deprecated use SetMaximumInputValue() */ void SetMaximum(ScalarType max) { this->SetMaximumInputValue(max); } /** Set the input minimum to be mapped to blue * \deprecated use SetMinimumInputValue() */ void SetMinimum(ScalarType min) { this->SetMinimumInputValue(min); } protected: RGBPixelType HSVToRGB(double h, double s, double v) const; private: ScalarToRainbowRGBPixelFunctor(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented HSVToRGBFunctorType m_HSVToRGBFunctor; }; } // end namespace functor } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbScalarToRainbowRGBPixelFunctor.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ColorMap/include/otbScalarToRainbowRGBPixelFunctor.txx000066400000000000000000000032521301006202600313140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarToRainbowRGBPixelFunctor_txx #define otbScalarToRainbowRGBPixelFunctor_txx #include "otbScalarToRainbowRGBPixelFunctor.h" namespace otb { namespace Functor { template ScalarToRainbowRGBPixelFunctor ::ScalarToRainbowRGBPixelFunctor() { // m_Minimum = 0; // m_Maximum = itk::NumericTraits::max(); } template typename ScalarToRainbowRGBPixelFunctor::RGBPixelType ScalarToRainbowRGBPixelFunctor ::operator() (const TScalar &v) const { double hinc, sinc, vinc; hinc = 0.6 / (this->GetMaximumInputValue() - this->GetMinimumInputValue()); sinc = 0.0; vinc = 0.0; double hue, sat, val; hue = 0.6 - (v - this->GetMinimumInputValue()) * hinc; if (v < this->GetMinimumInputValue()) { hue = 0.6; } if (v > this->GetMaximumInputValue()) { hue = 0.0; } sat = 0.99 + v * sinc; val = itk::NumericTraits::max() + v * vinc; return m_HSVToRGBFunctor(hue, sat, val); } } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ColorMap/otb-module.cmake000066400000000000000000000010651301006202600235400ustar00rootroot00000000000000set(DOCUMENTATION "In some situation, it is desirable to represent a gray level image in color for easier interpretation. This is particularly the case if pixel values in the image are used to represent some data such as elevation, deformation map, interferogram. In this case, it is important to ensure that similar values will get similar colors. This module contains classes that can meet these requirements.") otb_module(OTBColorMap DEPENDS OTBITK TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/ColorMap/test/000077500000000000000000000000001301006202600214445ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ColorMap/test/CMakeLists.txt000066400000000000000000000014561301006202600242120ustar00rootroot00000000000000otb_module_test() set(OTBColorMapTests otbColorMapTestDriver.cxx otbScalarToRainbowRGBPixelFunctor.cxx otbScalarToRainbowRGBPixelFunctorNew.cxx ) add_executable(otbColorMapTestDriver ${OTBColorMapTests}) target_link_libraries(otbColorMapTestDriver ${OTBColorMap-Test_LIBRARIES}) otb_module_target_label(otbColorMapTestDriver) # Tests Declaration otb_add_test(NAME bfTvScalarToRainbowRGBPixelFunctor COMMAND otbColorMapTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvScalarToRainbowRGBPixelFunctor.png ${TEMP}/bfTvScalarToRainbowRGBPixelFunctor.png otbScalarToRainbowRGBPixelFunctor ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvScalarToRainbowRGBPixelFunctor.png ) otb_add_test(NAME bfTuScalarToRainbowRGBPixelFunctorNew COMMAND otbColorMapTestDriver otbScalarToRainbowRGBPixelFunctorNew) OTB-release-5.8/Modules/Filtering/ColorMap/test/otbColorMapTestDriver.cxx000066400000000000000000000002351301006202600264250ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbScalarToRainbowRGBPixelFunctor); REGISTER_TEST(otbScalarToRainbowRGBPixelFunctorNew); } OTB-release-5.8/Modules/Filtering/ColorMap/test/otbScalarToRainbowRGBPixelFunctor.cxx000066400000000000000000000035371301006202600306350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "otbScalarToRainbowRGBPixelFunctor.h" int otbScalarToRainbowRGBPixelFunctor(int itkNotUsed(argc), char * argv[]) { typedef unsigned char PixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; typedef otb::Image RGBImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); typedef otb::Functor::ScalarToRainbowRGBPixelFunctor ColorMapFunctorType; typedef itk::UnaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->GetFunctor().SetMaximumInputValue(150); colormapper->GetFunctor().SetMinimumInputValue(70); colormapper->SetInput(reader->GetOutput()); writer->SetInput(colormapper->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ColorMap/test/otbScalarToRainbowRGBPixelFunctorNew.cxx000066400000000000000000000025641301006202600313060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "otbScalarToRainbowRGBPixelFunctor.h" int otbScalarToRainbowRGBPixelFunctorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char PixelType; typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; typedef otb::Image RGBImageType; typedef otb::Functor::ScalarToRainbowRGBPixelFunctor ColorMapFunctorType; typedef itk::UnaryFunctorImageFilter ColorMapFilterType; ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->GetFunctor().SetMaximum(150); colormapper->GetFunctor().SetMinimum(70); std::cout << colormapper << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Convolution/000077500000000000000000000000001301006202600212705ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Convolution/CMakeLists.txt000066400000000000000000000000521301006202600240250ustar00rootroot00000000000000project(OTBConvolution) otb_module_impl() OTB-release-5.8/Modules/Filtering/Convolution/include/000077500000000000000000000000001301006202600227135ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Convolution/include/otbConvolutionImageFilter.h000066400000000000000000000161751301006202600302330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConvolutionImageFilter_h #define otbConvolutionImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" #include "itkArray.h" #include "itkZeroFluxNeumannBoundaryCondition.h" namespace otb { /** \class ConvolutionImageFilter * \brief Applies a convolution filter to a mono channel image * * Computes an image which is the convolution of the input image * with a filter. * * The radius of the input filter is provided by the \code SetInput() \endcode * method and the filters coefficients are given by an itk::Array passed to the * \code SetFilter() \endcode method. * * By default, the input filter is not normalized but it can be using the * NormalizeFilterOn() method. * * This filter allows the user to choose the boundary condtions in the template parameters. Default boundary conditions are zero flux Neumann boundary conditions. * * An optimized version of this filter using FFTW is available in the Orfeo ToolBox and * will significantly improves performances especially for large kernels * (see OverlapSaveConvolutionImageFilter). * * \sa Image * \sa Neighborhood * \sa NeighborhoodOperator * \sa NeighborhoodIterator * \sa ImageBoundaryCondition * \sa ZeroFluxNeumannBoundaryCondition * \sa OverlapSaveConvolutionImageFilter * * \ingroup IntensityImageFilters * \ingroup Streamed * \ingroup MultiThreaded * * \ingroup OTBConvolution */ template , class TFilterPrecision = typename itk::NumericTraits::RealType> class ITK_EXPORT ConvolutionImageFilter : public itk::ImageToImageFilter { public: /** Extract dimension from input and output image. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Convenient typedefs for simplifying declarations. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Standard class typedefs. */ typedef ConvolutionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ConvolutionImageFilter, ImageToImageFilter); /** Image typedef support. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; typedef TFilterPrecision FilterPrecisionType; typedef typename itk::Array ArrayType; typedef TBoundaryCondition BoundaryConditionType; /** Set the radius of the neighborhood of the filter */ virtual void SetRadius(const InputSizeType rad) { itkDebugMacro("setting radius to " << rad); if (this->m_Radius != rad) { this->m_Radius = rad; unsigned int arraySize = 1; for (unsigned int i = 0; i < m_Radius.GetSizeDimension(); ++i) { arraySize *= 2 * this->m_Radius[i] + 1; } this->m_Filter.SetSize(arraySize); this->m_Filter.Fill(1); this->Modified(); } } /** Get the radius of the neighborhood of the filter*/ itkGetConstReferenceMacro(Radius, InputSizeType); /** Set the input filter */ virtual void SetFilter(ArrayType filter) { if (filter.Size() != m_Filter.Size()) { itkExceptionMacro( "Error in SetFilter, invalid filter size:" << filter.Size() << " instead of (2*m_Radius[0]+1)*(2*m_Radius[1]+1): " << m_Filter.Size()); } else { m_Filter = filter; } this->Modified(); } itkGetConstReferenceMacro(Filter, ArrayType); /** * Set/Get methods for the normalization of the filter */ itkSetMacro(NormalizeFilter, bool); itkGetMacro(NormalizeFilter, bool); itkBooleanMacro(NormalizeFilter); #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(InputHasNumericTraitsCheck, (itk::Concept::HasNumericTraits)); /** End concept checking */ #endif protected: ConvolutionImageFilter(); ~ConvolutionImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ConvolutionImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() * routine which is called for each processing thread. The output * image data is allocated automatically by the superclass prior to * calling ThreadedGenerateData(). ThreadedGenerateData can only * write to the portion of the output image specified by the * parameter "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** ConvolutionImageFilter needs a larger input requested region than * the output requested region. As such, ConvolutionImageFilter needs * to provide an implementation for GenerateInputRequestedRegion() * in order to inform the pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; private: ConvolutionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the filter */ InputSizeType m_Radius; /** Array containing the filter values */ ArrayType m_Filter; /** Flag for filter coefficients normalization */ bool m_NormalizeFilter; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbConvolutionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Convolution/include/otbConvolutionImageFilter.txx000066400000000000000000000126151301006202600306220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConvolutionImageFilter_txx #define otbConvolutionImageFilter_txx #include "otbConvolutionImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" #include "itkConstantBoundaryCondition.h" #include "otbMacro.h" namespace otb { template ConvolutionImageFilter ::ConvolutionImageFilter() { m_Radius.Fill(1); m_Filter.SetSize(3 * 3); m_Filter.Fill(1); m_NormalizeFilter = false; } template void ConvolutionImageFilter ::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); otbMsgDevMacro(<< "Padding by " << m_Radius); otbMsgDevMacro(<< "Region is now " << inputRequestedRegion.GetIndex() << ", " << inputRequestedRegion.GetSize()); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void ConvolutionImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { unsigned int i; // Allocate output typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); InputRealType sum = itk::NumericTraits::Zero; InputRealType norm = itk::NumericTraits::Zero; InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); itk::ConstNeighborhoodIterator inputIt(m_Radius, input, inputRegionForThread); itk::ImageRegionIterator outputIt(output, outputRegionForThread); inputIt.GoToBegin(); unsigned int neighborhoodSize = inputIt.Size(); // Compute the norm of the filter if (m_NormalizeFilter) { norm = itk::NumericTraits::Zero; for (i = 0; i < neighborhoodSize; ++i) { norm += static_cast(vcl_abs(m_Filter(i))); } } while (!inputIt.IsAtEnd()) { sum = itk::NumericTraits::Zero; for (i = 0; i < neighborhoodSize; ++i) { sum += static_cast(inputIt.GetPixel(i) * m_Filter(i)); } // get the mean value if (m_NormalizeFilter) { outputIt.Set(static_cast(sum / double(norm))); } else { outputIt.Set(static_cast(sum)); } ++inputIt; ++outputIt; progress.CompletedPixel(); } } /** * Standard "PrintSelf" method */ template void ConvolutionImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Convolution/include/otbGaborFilterGenerator.h000066400000000000000000000111431301006202600276400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGaborFilterGenerator_h #define otbGaborFilterGenerator_h #include "itkObject.h" #include "itkObjectFactory.h" #include "itkArray.h" #include "itkSize.h" namespace otb { /** \class GaborFilterGenerator * This class allows generating a gabor filter convolution mask. The mask is stored * in a linear buffer of type itk::Array returned by the GetFilter() method. * * When calling the GetFilter() method, if the filter has to be regenerated, it will be * done seamlessly. * * Gabor filters are commonly used in image processing for textures description for instance * The complex Gabor function is the product in spatial domain of a complex sinusoidal, also * known as the carrier, and a gaussian-shaped function, also knwown as the envelop. * * Please note that this helper class generates a filter whose coefficients are the real part * of a complex Gabor function. * * The formula used to compute these coefficients is as follows: * * \f$ g(x, y) = \exp\Big(-\pi((a x_\theta)^{2} +(b y_\theta)^{2})\Big) * \cos\big(2\pi(u_0*x + v_0*y)+\phi\big) \f$ * * with: * * \f$ x_\theta = x \cos(\theta)+y \sin(\theta) \f$ * and * \f$ y_\theta = y \cos(\theta)-x \sin(\theta) \f$ * * Where: * * - Radius : Radius of the generated filter (GetRadius()/SetRadius()) * - \f$ a \f$ : Scale the x axis of the gaussian envelop. (GetA()/SetA()) * - \f$ b \f$ : Scale the y axis of the gaussian envelop (GetB()/SetB()) * - \f$ \theta \f$ : Rotation angle of the gaussian envelop (in degree) (GetTheta()/SetTheta()) * - \f$ u_0 \f$ : x spatial frenquency of the sinusoidal carrier (GetU0()/SetU0()) * - \f$ v_0 \f$ : y spatial frenquency of the sinusoidal carrier (GetV0()/SetV0()) * - \f$ \phi \f$ : Phase of the sinusoidal carrier (GetPhi()/SetPhi()) * * * \ingroup OTBConvolution */ template class GaborFilterGenerator : public itk::Object { public: // Standard class typedefs typedef GaborFilterGenerator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // Standard new and type macro itkNewMacro(Self); itkTypeMacro(GaborFilterGenerator, Object); // useful typedefs typedef TPrecision PrecisionType; typedef itk::Array ArrayType; typedef itk::Size<2> RadiusType; /** Setters/Getters */ itkSetMacro(A, PrecisionType); itkGetMacro(A, PrecisionType); itkSetMacro(B, PrecisionType); itkGetMacro(B, PrecisionType); itkSetMacro(Theta, PrecisionType); itkGetMacro(Theta, PrecisionType); itkSetMacro(Phi, PrecisionType); itkGetMacro(Phi, PrecisionType); itkSetMacro(U0, PrecisionType); itkGetMacro(U0, PrecisionType); itkSetMacro(V0, PrecisionType); itkGetMacro(V0, PrecisionType); itkSetMacro(Radius, RadiusType); itkGetConstReferenceMacro(Radius, RadiusType); /** Get The generated filter */ const ArrayType& GetFilter(); protected: /** constructor */ GaborFilterGenerator(); /** destructor */ ~GaborFilterGenerator() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Generate the filter coefficients */ void GenerateFilter(); /** Reimplement the Modified() method *to set the NeedToGenerateFilter to true */ void Modified() const ITK_OVERRIDE; private: GaborFilterGenerator(const Self&); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the filter */ RadiusType m_Radius; /** Gabor parameters */ PrecisionType m_A; PrecisionType m_B; PrecisionType m_Theta; PrecisionType m_U0; PrecisionType m_V0; PrecisionType m_Phi; /** Output filter coefficient array */ ArrayType m_Filter; /** Whether we need to regenerate the filter */ mutable bool m_NeedToRegenerateFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGaborFilterGenerator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Convolution/include/otbGaborFilterGenerator.txx000066400000000000000000000055241301006202600302420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGaborFilterGenerator_txx #define otbGaborFilterGenerator_txx #include "otbGaborFilterGenerator.h" #include "otbMath.h" namespace otb { template GaborFilterGenerator ::GaborFilterGenerator() { m_Radius.Fill(2); m_A = 0; m_B = 0; m_U0 = 0; m_V0 = 0; m_Theta = 0; m_Phi = 0; m_NeedToRegenerateFilter = true; } template const typename GaborFilterGenerator ::ArrayType& GaborFilterGenerator ::GetFilter() { if (m_NeedToRegenerateFilter) { this->GenerateFilter(); } return m_Filter; } template void GaborFilterGenerator ::GenerateFilter() { m_Filter.SetSize((2 * m_Radius[0] + 1) * (2 * m_Radius[1] + 1)); m_Filter.Fill(0); PrecisionType coef, xr, yr, costheta, sintheta; unsigned int k = 0; costheta = vcl_cos(m_Theta * CONST_PI_180); sintheta = vcl_sin(m_Theta * CONST_PI_180); for (PrecisionType y = -static_cast(m_Radius[1]); y <= static_cast(m_Radius[1]); y += 1) { for (PrecisionType x = -static_cast(m_Radius[0]); x <= static_cast(m_Radius[0]); x += 1) { xr = x * costheta + y * sintheta; yr = y * costheta - x * sintheta; coef = vcl_exp(-CONST_PI * (vcl_pow(m_A * xr, 2) + vcl_pow(m_B * yr, 2))) * cos( CONST_2PI * (m_U0 * x + m_V0 * y) + m_Phi); m_Filter.SetElement(k, coef); ++k; } } } template void GaborFilterGenerator ::Modified() const { this->Superclass::Modified(); m_NeedToRegenerateFilter = true; } template void GaborFilterGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; os << indent << "A: " << m_A << std::endl; os << indent << "B: " << m_B << std::endl; os << indent << "Theta: " << m_Theta << std::endl; os << indent << "U0: " << m_U0 << std::endl; os << indent << "V0: " << m_V0 << std::endl; os << indent << "Phi: " << m_Phi << std::endl; os << "Need to regenerate filter: " << m_NeedToRegenerateFilter << std::endl; } } #endif OTB-release-5.8/Modules/Filtering/Convolution/include/otbOverlapSaveConvolutionImageFilter.h000066400000000000000000000150031301006202600323700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOverlapSaveConvolutionImageFilter_h #define otbOverlapSaveConvolutionImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" #include "itkArray.h" #include "itkZeroFluxNeumannBoundaryCondition.h" namespace otb { /** \class OverlapSaveConvolutionImageFilter * * This filter implements the convolution operation between a kernel and an * image using the overlap save algorithm (http://wikipedia.org/wiki/Overlap-save_method). * * This method takes advantages of the FFTW implementation of Fast Fourrier Transform to * exchange an intensive convolution product in the space domain for a simple term by term * product in the Fourrier domain. This result in tremendous speed gain when using large kernel * with exactly the same result as the classical convolution filter. * * \note This filter could be threaded but requires additional design due to limited thread-safety * of the FFTW library. * * \note For the moment only constant zero boundary conditions are used in this filter. This could produce * very different results from the classical convolution filter with zero flux neumann boundary condition, * especially with large kernels. * * \note ITK must be set to use FFTW (double implementation) for this filter to work properly. If not, exception * will be raised at filter creation. * Install fftw and set the cmake variable ITK_USE_FFTWD to ON. * * \sa ConvolutionImageFilter * * \ingroup ShouldBeThreaded * \ingroup Streamed * \ingroup IntensityImageFilters * * \ingroup OTBConvolution */ template > class ITK_EXPORT OverlapSaveConvolutionImageFilter : public itk::ImageToImageFilter { public: /** Extract dimension from input and output image. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Convenient typedefs for simplifying declarations. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Standard class typedefs. */ typedef OverlapSaveConvolutionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(OverlapSaveConvolutionImageFilter, ImageToImageFilter); /** Image typedef support. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; typedef typename itk::Array ArrayType; typedef TBoundaryCondition BoundaryConditionType; /** Set the radius of the neighborhood used to compute the mean. */ virtual void SetRadius(const InputSizeType rad) { itkDebugMacro("setting radius to " << rad); if (this->m_Radius != rad) { this->m_Radius = rad; unsigned int arraySize = 1; for (unsigned int i = 0; i < m_Radius.GetSizeDimension(); ++i) { arraySize *= 2 * this->m_Radius[i] + 1; } this->m_Filter.SetSize(arraySize); this->m_Filter.Fill(1); this->Modified(); } } /** Get the radius of the neighborhood used to compute the mean */ itkGetConstReferenceMacro(Radius, InputSizeType); /** Set the input filter */ void SetFilter(ArrayType filter) { if ((filter.Size() != m_Filter.Size())) { itkExceptionMacro( "Error in SetFilter, invalid filter size:" << filter.Size() << " instead of 2*(m_Radius[0]+1)*(2*m_Radius[1]+1): " << m_Filter.Size()); } else { m_Filter = filter; } this->Modified(); } /** Get the filter */ itkGetConstReferenceMacro(Filter, ArrayType); /** Set/Get methods for the normalization of the filter */ itkSetMacro(NormalizeFilter, bool); itkGetMacro(NormalizeFilter, bool); itkBooleanMacro(NormalizeFilter); /** Since this filter implements a neighborhood operation, it requests a largest input * region than the output region. */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(InputHasNumericTraitsCheck, (itk::Concept::HasNumericTraits)); /** End concept checking */ #endif protected: /** Constructor */ OverlapSaveConvolutionImageFilter(); /** destructor */ ~OverlapSaveConvolutionImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /* TODO For the moment this class provide only a GenerateData(), * due to limited thread-safety of FFTW plan creation. */ void GenerateData() ITK_OVERRIDE; // void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId); private: OverlapSaveConvolutionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the filter */ InputSizeType m_Radius; /** Filter array */ ArrayType m_Filter; /** Flag for filter normalization */ bool m_NormalizeFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOverlapSaveConvolutionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Convolution/include/otbOverlapSaveConvolutionImageFilter.txx000066400000000000000000000262361301006202600327760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOverlapSaveConvolutionImageFilter_txx #define otbOverlapSaveConvolutionImageFilter_txx #include "itkConfigure.h" #include "otbOverlapSaveConvolutionImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" //debug #include "itkImageRegionIterator.h" #include "otbMath.h" #ifdef ITK_USE_FFTWD #include "itkFFTWCommon.h" #endif namespace otb { template OverlapSaveConvolutionImageFilter ::OverlapSaveConvolutionImageFilter() { m_Radius.Fill(1); m_Filter.SetSize(3 * 3); m_Filter.Fill(1); m_NormalizeFilter = false; } template void OverlapSaveConvolutionImageFilter ::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { #if defined ITK_USE_FFTWD // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // Pad by filter radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } #else itkGenericExceptionMacro( << "The OverlapSaveConvolutionImageFilter can not operate without the FFTW library (double implementation). Please build ITK with USE_FFTD set to ON, and rebuild OTB."); #endif } template void OverlapSaveConvolutionImageFilter /* TODO commented out since multi-threading is not supported for the moment * ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) */ ::GenerateData() { #if defined ITK_USE_FFTWD // Input/Output pointers typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); /* TODO: This is a patch to switch from GenerateData() to ThreadedGenerateData(). Remove these two lines once multi-threading problem is solved */ this->AllocateOutputs(); OutputImageRegionType outputRegionForThread = output->GetRequestedRegion(); // Size of the filter typename InputImageType::SizeType sizeOfFilter; sizeOfFilter[0] = 2 * m_Radius[0] + 1; sizeOfFilter[1] = 2 * m_Radius[1] + 1; // Filter normalization InputRealType norm; // Compute the input region for the given thread OutputImageRegionType inputRegionForThread = outputRegionForThread; inputRegionForThread.PadByRadius(m_Radius); // Compute the piece region for the input thread. Piece region is different // from input region on boundaries typename InputImageType::RegionType pieceRegion = inputRegionForThread; typename InputImageType::SizeType pieceSize = pieceRegion.GetSize(); typename InputImageType::IndexType pieceIndex = pieceRegion.GetIndex(); // Compute the size of the FFT and the size of the piece unsigned int pieceNbOfPixel = pieceRegion.GetNumberOfPixels(); unsigned int sizeFFT = (pieceSize[0] / 2 + 1) * pieceSize[1]; // Achieve the computation of the inputRegionForThread inputRegionForThread.Crop(input->GetLargestPossibleRegion()); typename InputImageType::IndexType inputIndex = inputRegionForThread.GetIndex(); typename InputImageType::SizeType inputSize = inputRegionForThread.GetSize(); //Iterator of input image itk::ConstNeighborhoodIterator inputIt(m_Radius, input, inputRegionForThread); inputIt.GoToBegin(); //Iterator of output image itk::ImageRegionIteratorWithIndex outputIt; outputIt = itk::ImageRegionIteratorWithIndex(output, outputRegionForThread); //variables for loops unsigned int i, j, k, l; // ITK proxy to the fftw library typedef typename itk::fftw::Proxy FFTWProxyType; //memory allocation InputPixelType* resampledFilterPiece; resampledFilterPiece = static_cast(fftw_malloc(pieceNbOfPixel * sizeof(InputPixelType))); FFTWProxyType::ComplexType* filterPieceFFT; filterPieceFFT = static_cast(fftw_malloc(sizeFFT * sizeof(FFTWProxyType::ComplexType))); InputPixelType *inputPiece; inputPiece = static_cast(fftw_malloc(pieceNbOfPixel * sizeof(InputPixelType))); FFTWProxyType::ComplexType* inputPieceFFT; inputPieceFFT = static_cast(fftw_malloc(sizeFFT * sizeof(FFTWProxyType::ComplexType))); // Image piece FFT FFTWProxyType::PlanType inputPlan = FFTWProxyType::Plan_dft_r2c_2d(pieceSize[1], pieceSize[0], inputPiece, inputPieceFFT, FFTW_MEASURE); // left zero padding unsigned int leftskip = static_cast(std::max(0L, inputIndex[0] - pieceIndex[0])); unsigned int topskip = pieceSize[0] * static_cast(std::max(0L, inputIndex[1] - pieceIndex[1])); // Filling the buffer with image values for (l = 0; l < inputSize[1]; ++l) { for (k = 0; k < inputSize[0]; ++k) { inputPiece[topskip + pieceSize[0] * l + k + leftskip] = inputIt.GetCenterPixel(); ++inputIt; } } FFTWProxyType::Execute(inputPlan); // Resampled filter FFT FFTWProxyType::PlanType filterPlan = FFTWProxyType::Plan_dft_r2c_2d(pieceSize[1], pieceSize[0], resampledFilterPiece, filterPieceFFT, FFTW_MEASURE); k = 0; // Filling the buffer with filter values for (j = 0; j < sizeOfFilter[1]; ++j) { for (i = 0; i < sizeOfFilter[0]; ++i) { resampledFilterPiece[i + j * pieceSize[0]] = m_Filter.GetElement(k); //Copy values ++k; } } FFTWProxyType::Execute(filterPlan); // memory allocation for inverse FFT FFTWProxyType::ComplexType* multipliedFFTarray; multipliedFFTarray = static_cast(fftw_malloc(sizeFFT * sizeof(FFTWProxyType::ComplexType))); FFTWProxyType::PixelType* inverseFFTpiece; inverseFFTpiece = static_cast(fftw_malloc(pieceNbOfPixel * sizeof(FFTWProxyType::PixelType))); // Inverse FFT of the product of FFT (actually do filtering here) FFTWProxyType::PlanType outputPlan = FFTWProxyType::Plan_dft_c2r_2d(pieceSize[1], pieceSize[0], multipliedFFTarray, inverseFFTpiece, FFTW_MEASURE); // Filling the buffer with complex product values for (k = 0; k < sizeFFT; ++k) { //complex mutiplication multipliedFFTarray[k][0] = inputPieceFFT[k][0] * filterPieceFFT[k][0] - inputPieceFFT[k][1] * filterPieceFFT[k][1]; multipliedFFTarray[k][1] = inputPieceFFT[k][0] * filterPieceFFT[k][1] + inputPieceFFT[k][1] * filterPieceFFT[k][0]; } FFTWProxyType::Execute(outputPlan); // Computing the filter normalization if (m_NormalizeFilter) { norm = itk::NumericTraits::Zero; for (i = 0; i < sizeOfFilter[0] * sizeOfFilter[1]; ++i) { norm += static_cast(m_Filter(i)); } if (norm == 0.0) { norm = 1.0; } else { norm = 1 / norm; } } else { norm = 1.0; } // Fill the output image outputIt.GoToBegin(); while (!outputIt.IsAtEnd()) { typename InputImageType::IndexType index = outputIt.GetIndex(); unsigned int linearIndex = (index[1] + sizeOfFilter[1] - 1 - outputRegionForThread.GetIndex()[1]) * pieceSize[0] - 1 + index[0] + sizeOfFilter[0] - outputRegionForThread.GetIndex()[0]; outputIt.Set(static_cast((inverseFFTpiece[linearIndex] / pieceNbOfPixel) * static_cast(norm))); ++outputIt; } // destroy the FFT plans FFTWProxyType::DestroyPlan(inputPlan); FFTWProxyType::DestroyPlan(filterPlan); FFTWProxyType::DestroyPlan(outputPlan); //frees memory fftw_free(resampledFilterPiece); fftw_free(inputPiece); fftw_free(filterPieceFFT); fftw_free(inputPieceFFT); fftw_free(multipliedFFTarray); fftw_free(inverseFFTpiece); #else itkGenericExceptionMacro( << "The OverlapSaveConvolutionImageFilter can not operate without the FFTW library (double implementation). Please build ITK with USE_FFTD set to ON, and rebuild OTB."); #endif } /** Standard "PrintSelf" method */ template void OverlapSaveConvolutionImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; os << indent << "Normalize filter: " << m_NormalizeFilter << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Convolution/otb-module.cmake000066400000000000000000000006321301006202600243420ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes to compute an image which is the convolution of the input image with a given kernel. Note that two methods are used: classical convolution and convolution based on the Overlap-save algorithm.") otb_module(OTBConvolution DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/Convolution/test/000077500000000000000000000000001301006202600222475ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Convolution/test/CMakeLists.txt000066400000000000000000000046061301006202600250150ustar00rootroot00000000000000otb_module_test() set(OTBConvolutionTests otbConvolutionTestDriver.cxx otbConvolutionImageFilter.cxx otbConvolutionImageFilterNew.cxx otbOverlapSaveConvolutionImageFilterNew.cxx otbOverlapSaveConvolutionImageFilter.cxx otbCompareOverlapSaveAndClassicalConvolutionWithGaborFilter.cxx otbGaborFilterGenerator.cxx otbGaborFilterGeneratorNew.cxx ) add_executable(otbConvolutionTestDriver ${OTBConvolutionTests}) target_link_libraries(otbConvolutionTestDriver ${OTBConvolution-Test_LIBRARIES}) otb_module_target_label(otbConvolutionTestDriver) # Tests Declaration otb_add_test(NAME bfTvConvolutionImageFilter COMMAND otbConvolutionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvConvolutionImageFilter.tif ${TEMP}/bfTvConvolutionImageFilter.tif otbConvolutionImageFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvConvolutionImageFilter.tif ) otb_add_test(NAME bfTuConvolutionImageFilterNew COMMAND otbConvolutionTestDriver otbConvolutionImageFilterNew) otb_add_test(NAME bfTuOverlapSaveConvolutionImageFilterNew COMMAND otbConvolutionTestDriver otbOverlapSaveConvolutionImageFilterNew) if(ITK_USE_FFTWD) otb_add_test(NAME bfTvOverlapSaveConvolutionImageFilter COMMAND otbConvolutionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvConvolutionImageFilter.tif ${TEMP}/bfTvOverlapSaveConvolutionImageFilter.tif otbOverlapSaveConvolutionImageFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvOverlapSaveConvolutionImageFilter.tif ) otb_add_test(NAME bfTvCompareOverlapSaveAndClassicalConvolutionWithGaborFilter COMMAND otbConvolutionTestDriver --compare-image ${EPSILON_7} ${TEMP}/bfTvCompareConvolutionOutput.tif ${TEMP}/bfTvCompareOSConvolutionoutput.tif otbCompareOverlapSaveAndClassicalConvolutionWithGaborFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles_sub.tif ${TEMP}/bfTvCompareConvolutionOutput.tif ${TEMP}/bfTvCompareOSConvolutionoutput.tif 64 64 #Radius 0.02 0.025 # a b -45 # theta 0.0125 0.0125 #u0 v0 0 ) endif() otb_add_test(NAME bfTvGaborFilterGenerator COMMAND otbConvolutionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfGaborFilterGeneratorTest.tif ${TEMP}/bfGaborFilterGeneratorTest.tif otbGaborFilterGenerator ${TEMP}/bfGaborFilterGeneratorTest.tif 64 64 #Radius 0.02 0.025 # a b -45 # theta 0.0125 0.0125 #u0 v0 0 ) otb_add_test(NAME bfTuGaborFilterGeneratorNew COMMAND otbConvolutionTestDriver otbGaborFilterGeneratorNew ) otbCompareOverlapSaveAndClassicalConvolutionWithGaborFilter.cxx000066400000000000000000000077141301006202600366470ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Convolution/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbConvolutionImageFilter.h" #include "otbOverlapSaveConvolutionImageFilter.h" #include "otbGaborFilterGenerator.h" #include "itkConstantBoundaryCondition.h" #include "itkTimeProbe.h" int otbCompareOverlapSaveAndClassicalConvolutionWithGaborFilter(int argc, char *argv[]) { if (argc != 12) { std::cerr << "Usage: " << argv[0] << " infname outfname1 outfname2 xradius yradius a b theta u0 v0 phi" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname1 = argv[2]; const char * outfname2 = argv[3]; const unsigned int xradius = atoi(argv[4]); const unsigned int yradius = atoi(argv[5]); const double a = atof(argv[6]); const double b = atof(argv[7]); const double theta = atof(argv[8]); const double u0 = atof(argv[9]); const double v0 = atof(argv[10]); const double phi = atof(argv[11]); typedef double PrecisionType; typedef otb::GaborFilterGenerator GaborGeneratorType; typedef GaborGeneratorType::RadiusType RadiusType; typedef GaborGeneratorType::ArrayType ArrayType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::OverlapSaveConvolutionImageFilter OSConvolutionFilterType; // Setting the same boundary conditions than the one used in the overlap save convolution filter typedef itk::ConstantBoundaryCondition BoundaryConditionType; typedef otb::ConvolutionImageFilter ConvolutionFilterType; // Gabor filter generation GaborGeneratorType::Pointer gabor = GaborGeneratorType::New(); RadiusType radius; radius[0] = xradius; radius[1] = yradius; gabor->SetRadius(radius); gabor->SetA(a); gabor->SetB(b); gabor->SetTheta(theta); gabor->SetU0(u0); gabor->SetV0(v0); gabor->SetPhi(phi); ArrayType filter = gabor->GetFilter(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); itk::TimeProbe probe1, probe2; ConvolutionFilterType::Pointer convolution = ConvolutionFilterType::New(); convolution->SetRadius(radius); convolution->SetFilter(filter); convolution->SetInput(reader->GetOutput()); WriterType::Pointer writer1 = WriterType::New(); writer1->SetInput(convolution->GetOutput()); writer1->SetFileName(outfname1); probe1.Start(); writer1->Update(); probe1.Stop(); std::cout << "Classical convolution algorithm took " << probe1.GetMean() << " seconds." << std::endl; OSConvolutionFilterType::Pointer osconvolution = OSConvolutionFilterType::New(); osconvolution->SetRadius(radius); osconvolution->SetFilter(filter); osconvolution->SetInput(reader->GetOutput()); WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(osconvolution->GetOutput()); writer2->SetFileName(outfname2); probe2.Start(); writer2->Update(); probe2.Stop(); std::cout << "Overlap-save convolution algorithm took " << probe2.GetMean() << " seconds." << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Convolution/test/otbConvolutionImageFilter.cxx000066400000000000000000000044141301006202600301330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbConvolutionImageFilter.h" #include "itkConstantBoundaryCondition.h" int otbConvolutionImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image PanchroImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Overriding boundary condition to compare with the overlap save convolution results. typedef itk::ConstantBoundaryCondition BoundaryConditionType; typedef otb::ConvolutionImageFilter ConvFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ConvFilterType::Pointer convFilter = ConvFilterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); ConvFilterType::InputSizeType radius; radius[0] = 3; radius[1] = 3; //itk::Array< double > filterCoeffs; ConvFilterType::ArrayType filterCoeffs; filterCoeffs.SetSize((2 * radius[0] + 1) * (2 * radius[1] + 1)); filterCoeffs.Fill(1); convFilter->SetRadius(radius); convFilter->SetFilter(filterCoeffs); convFilter->NormalizeFilterOn(); convFilter->SetInput(reader->GetOutput()); writer->SetInput(convFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Convolution/test/otbConvolutionImageFilterNew.cxx000066400000000000000000000022431301006202600306030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbConvolutionImageFilter.h" int otbConvolutionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ConvolutionImageFilter FilterType; FilterType::Pointer conv = FilterType::New(); std::cout << conv << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Convolution/test/otbConvolutionTestDriver.cxx000066400000000000000000000007051301006202600300350ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbConvolutionImageFilter); REGISTER_TEST(otbConvolutionImageFilterNew); REGISTER_TEST(otbOverlapSaveConvolutionImageFilterNew); #if defined(ITK_USE_FFTWD) REGISTER_TEST(otbOverlapSaveConvolutionImageFilter); REGISTER_TEST(otbCompareOverlapSaveAndClassicalConvolutionWithGaborFilter); #endif REGISTER_TEST(otbGaborFilterGenerator); REGISTER_TEST(otbGaborFilterGeneratorNew); } OTB-release-5.8/Modules/Filtering/Convolution/test/otbGaborFilterGenerator.cxx000066400000000000000000000053101301006202600275460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGaborFilterGenerator.h" #include "otbImage.h" #include "otbImageFileWriter.h" #include "itkImageRegionIterator.h" int otbGaborFilterGenerator(int argc, char * argv[]) { if (argc != 10) { std::cerr << "Usage: " << argv[0] << "outfname xradius yradius a b theta u0 v0 phi" << std::endl; return EXIT_FAILURE; } const char * outfname = argv[1]; const unsigned int xradius = atoi(argv[2]); const unsigned int yradius = atoi(argv[3]); const double a = atof(argv[4]); const double b = atof(argv[5]); const double theta = atof(argv[6]); const double u0 = atof(argv[7]); const double v0 = atof(argv[8]); const double phi = atof(argv[9]); typedef double PrecisionType; typedef otb::GaborFilterGenerator GaborGeneratorType; typedef GaborGeneratorType::RadiusType RadiusType; typedef GaborGeneratorType::ArrayType ArrayType; typedef otb::Image ImageType; typedef otb::ImageFileWriter WriterType; // Gabor filter generation GaborGeneratorType::Pointer gabor = GaborGeneratorType::New(); RadiusType radius; radius[0] = xradius; radius[1] = yradius; gabor->SetRadius(radius); gabor->SetA(a); gabor->SetB(b); gabor->SetTheta(theta); gabor->SetU0(u0); gabor->SetV0(v0); gabor->SetPhi(phi); ArrayType filter = gabor->GetFilter(); // Writing filter mask to an image ImageType::Pointer image = ImageType::New(); ImageType::RegionType region; ImageType::SizeType size; size[0] = 2 * radius[0] + 1; size[1] = 2 * radius[1] + 1; ImageType::IndexType index; index.Fill(0); region.SetIndex(index); region.SetSize(size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); itk::ImageRegionIterator it(image, region); unsigned int k = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it, ++k) { it.Set(filter[k]); } WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Convolution/test/otbGaborFilterGeneratorNew.cxx000066400000000000000000000017231301006202600302240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGaborFilterGenerator.h" int otbGaborFilterGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PrecisionType; typedef otb::GaborFilterGenerator GaborGeneratorType; // Instantiating object GaborGeneratorType::Pointer gabor = GaborGeneratorType::New(); std::cout << gabor << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Convolution/test/otbOverlapSaveConvolutionImageFilter.cxx000066400000000000000000000042011301006202600322750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbOverlapSaveConvolutionImageFilter.h" int otbOverlapSaveConvolutionImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image PanchroImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::OverlapSaveConvolutionImageFilter ConvFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ConvFilterType::Pointer convFilter = ConvFilterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); ConvFilterType::InputSizeType radius; radius[0] = 3; radius[1] = 3; ConvFilterType::ArrayType filterCoeffs; filterCoeffs.SetSize((2 * radius[0] + 1) * (2 * radius[1] + 1)); filterCoeffs.Fill(1); convFilter->SetRadius(radius); convFilter->SetFilter(filterCoeffs); convFilter->NormalizeFilterOn(); convFilter->SetInput(reader->GetOutput()); writer->SetInput(convFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Convolution/test/otbOverlapSaveConvolutionImageFilterNew.cxx000066400000000000000000000023321301006202600327520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbOverlapSaveConvolutionImageFilter.h" int otbOverlapSaveConvolutionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::OverlapSaveConvolutionImageFilter FilterType; FilterType::Pointer conv = FilterType::New(); std::cout << conv << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DEM/000077500000000000000000000000001301006202600173565ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DEM/CMakeLists.txt000066400000000000000000000000431301006202600221130ustar00rootroot00000000000000project(OTBDEM) otb_module_impl() OTB-release-5.8/Modules/Filtering/DEM/include/000077500000000000000000000000001301006202600210015ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DEM/include/otbDEMCaracteristicsExtractor.h000066400000000000000000000143121301006202600270450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDEMCaracteristicsExtractor_h #define otbDEMCaracteristicsExtractor_h #include "otbImage.h" #include "otbVectorImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkGradientMagnitudeImageFilter.h" #include "itkGradientRecursiveGaussianImageFilter.h" #include "itkAtan2ImageFilter.h" #include "itkAtanImageFilter.h" #include "otbMultiplyByScalarImageFilter.h" #include "itkMultiplyImageFilter.h" #include "itkAcosImageFilter.h" #include "itkCosImageFilter.h" #include "itkSinImageFilter.h" #include "itkShiftScaleImageFilter.h" #include "itkAddImageFilter.h" #include "itkGradientImageFilter.h" namespace otb { /** \class DEMCaracteristicsExtractor * \brief Calculates the slope, the orientation incidence and exitance radius values for each pixel. * * To note that azimuth value are projection over North-South direction and angles have to be given in degres. * * \ingroup DEMHanler * \ingroup DEMToImageGenerator * \ingroup Radiometry * * \ingroup OTBDEM */ template class ITK_EXPORT DEMCaracteristicsExtractor : public itk::ImageToImageFilter { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** "typedef" for standard classes. */ typedef DEMCaracteristicsExtractor Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(DEMCaracteristicsExtractor, ImageToImageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef itk::CovariantVector VectorPixelType; typedef Image VectorGradientImageType; /** Filter definition */ typedef itk::GradientMagnitudeImageFilter GradientMagnitudeFilterType; typedef itk::GradientImageFilter GradientRecursiveGaussianImageFilterType; typedef typename GradientRecursiveGaussianImageFilterType::OutputImageType tutuType; typedef itk::NthElementImageAdaptor AdaptorType; typedef itk::Atan2ImageFilter Atan2FilterType; typedef itk::AtanImageFilter AtanFilterType; /** Operation Filters*/ typedef MultiplyByScalarImageFilter MultiplyByScalarImageFilterType; typedef itk::MultiplyImageFilter MultiplyImageFilterType; typedef itk::AcosImageFilter AcosImageFilterType; typedef itk::CosImageFilter CosImageFilterType; typedef itk::SinImageFilter SinImageFilterType; typedef itk::ShiftScaleImageFilter ShiftScaleImageFilterType; typedef itk::AddImageFilter AddImageFilterType; /** Get the slop output image */ OutputImageType* GetSlopOutput() { return static_cast(this->itk::ProcessObject::GetOutput(0)); } /** Get the aspect output image */ OutputImageType* GetAspectOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } /** Get the incidence output image */ OutputImageType* GetIncidenceOutput() { return static_cast(this->itk::ProcessObject::GetOutput(2)); } /** Get the exitance output image */ OutputImageType* GetExitanceOutput() { return static_cast(this->itk::ProcessObject::GetOutput(3)); } /** Angle parameters*/ /** Set/Get Solar Angle */ itkSetMacro(SolarAngle, double); itkGetConstMacro(SolarAngle, double); /** Set/Get Solar Solar */ itkSetMacro(SolarAzimut, double); itkGetConstMacro(SolarAzimut, double); /** Set/Get View Angle */ itkSetMacro(ViewAngle, double); itkGetConstMacro(ViewAngle, double); /** Set/Get View Solar */ itkSetMacro(ViewAzimut, double); itkGetConstMacro(ViewAzimut, double); protected: DEMCaracteristicsExtractor(); ~DEMCaracteristicsExtractor() ITK_OVERRIDE; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: /** Angle parameters*/ /** Solar Angle */ double m_SolarAngle; /** Solar Solar */ double m_SolarAzimut; /** View Angle */ double m_ViewAngle; /** View Solar */ double m_ViewAzimut; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDEMCaracteristicsExtractor.txx" #endif #endif OTB-release-5.8/Modules/Filtering/DEM/include/otbDEMCaracteristicsExtractor.txx000066400000000000000000000222671301006202600274510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDEMCaracteristicsExtractor_txx #define otbDEMCaracteristicsExtractor_txx #include "otbDEMCaracteristicsExtractor.h" #include "itkImageRegionIterator.h" #include "otbMath.h" namespace otb { template DEMCaracteristicsExtractor ::DEMCaracteristicsExtractor() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(3); this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageType::New()); this->SetNthOutput(2, OutputImageType::New()); this->SetNthOutput(3, OutputImageType::New()); m_SolarAngle = 0; m_SolarAzimut = 0; m_ViewAngle = 0; m_ViewAzimut = 0; } template DEMCaracteristicsExtractor ::~DEMCaracteristicsExtractor() { } /** * ThreadedGenerateData Performs the pixel-wise addition */ template void DEMCaracteristicsExtractor ::GenerateData() { // Input and output pointer definition typename InputImageType::Pointer inputPtr = const_cast(this->GetInput()); typename OutputImageType::Pointer SlopOutputPtr = this->GetSlopOutput(); typename OutputImageType::Pointer AspectOutputPtr = this->GetAspectOutput(); typename OutputImageType::Pointer IncidenceOutputPtr = this->GetIncidenceOutput(); typename OutputImageType::Pointer ExitanceOutputPtr = this->GetExitanceOutput(); // Gradient Magnitude Image Filter used to compute the slope. typename GradientMagnitudeFilterType::Pointer GradientMagnitudeFilter = GradientMagnitudeFilterType::New(); // Gradient Recursive Gaussian Image Filter used to compute the aspect. typename GradientRecursiveGaussianImageFilterType::Pointer GradientRecursiveGaussianFilter = GradientRecursiveGaussianImageFilterType::New(); // Atan used to compute the slop typename AtanFilterType::Pointer AtanFilter = AtanFilterType::New(); // Atan2 Image Filter used to compute the aspect. typename Atan2FilterType::Pointer AspectFilter = Atan2FilterType::New(); // Inverse cosinus Image filter used to compute the incidence image typename AcosImageFilterType::Pointer IncidenceFilter = AcosImageFilterType::New(); // Inverse cosinus Image filter used to compute the exitance image typename AcosImageFilterType::Pointer ExitanceFilter = AcosImageFilterType::New(); // Degrees To Radian _-> Radian To Degree coefficient double rad2degCoef; rad2degCoef = 180 / CONST_PI; // Slop calculation GradientMagnitudeFilter->SetInput(inputPtr); AtanFilter->SetInput(GradientMagnitudeFilter->GetOutput()); // Transform values from radian to degrees. typename MultiplyByScalarImageFilterType::Pointer rad2DegFilter = MultiplyByScalarImageFilterType::New(); //rad2DegFilter->SetInput( GradientMagnitudeFilter->GetOutput() ); rad2DegFilter->SetInput(AtanFilter->GetOutput()); rad2DegFilter->SetCoef(rad2degCoef); rad2DegFilter->GraftOutput(SlopOutputPtr); rad2DegFilter->Update(); this->GraftNthOutput(0, rad2DegFilter->GetOutput()); // Aspect calcultation GradientRecursiveGaussianFilter->SetInput(inputPtr); GradientRecursiveGaussianFilter->Update(); // // Extract the X and the Y gradient typename AdaptorType::Pointer XAdaptator = AdaptorType::New(); typename AdaptorType::Pointer YAdaptator = AdaptorType::New(); XAdaptator->SetImage(GradientRecursiveGaussianFilter->GetOutput()); YAdaptator->SetImage(GradientRecursiveGaussianFilter->GetOutput()); XAdaptator->SelectNthElement(0); YAdaptator->SelectNthElement(1); // // Compute Arctan AspectFilter->SetInput1(XAdaptator); AspectFilter->SetInput2(YAdaptator); // // Transform values from radian to degres. typename MultiplyByScalarImageFilterType::Pointer rad2DegFilter1 = MultiplyByScalarImageFilterType::New(); rad2DegFilter1->SetInput(AspectFilter->GetOutput()); rad2DegFilter1->SetCoef(rad2degCoef); rad2DegFilter1->GraftOutput(AspectOutputPtr); rad2DegFilter1->Update(); this->GraftNthOutput(1, rad2DegFilter1->GetOutput()); // Angle calculation : // sin(slop) typename SinImageFilterType::Pointer sinS = SinImageFilterType::New(); sinS->SetInput(GradientMagnitudeFilter->GetOutput()); // cos (slop) typename CosImageFilterType::Pointer cosS = CosImageFilterType::New(); cosS->SetInput(GradientMagnitudeFilter->GetOutput()); // -aspect typename MultiplyByScalarImageFilterType::Pointer oppositeFilter = MultiplyByScalarImageFilterType::New(); oppositeFilter->SetInput(AspectFilter->GetOutput()); oppositeFilter->SetCoef(-1); // Incidence calculation typename ShiftScaleImageFilterType::Pointer addAzimut = ShiftScaleImageFilterType::New(); addAzimut->SetScale(1.); addAzimut->SetShift(m_SolarAzimut / rad2degCoef); addAzimut->SetInput(oppositeFilter->GetOutput()); typename CosImageFilterType::Pointer cosAAzimut = CosImageFilterType::New(); cosAAzimut->SetInput(addAzimut->GetOutput()); typename MultiplyByScalarImageFilterType::Pointer sinSsinSolarAngleFilter = MultiplyByScalarImageFilterType::New(); sinSsinSolarAngleFilter->SetCoef(vcl_sin(m_SolarAngle / rad2degCoef)); sinSsinSolarAngleFilter->SetInput(sinS->GetOutput()); typename MultiplyImageFilterType::Pointer cosAAzimuthsinSsinAngle = MultiplyImageFilterType::New(); cosAAzimuthsinSsinAngle->SetInput1(sinSsinSolarAngleFilter->GetOutput()); cosAAzimuthsinSsinAngle->SetInput2(cosAAzimut->GetOutput()); typename MultiplyByScalarImageFilterType::Pointer cosScosSolarAngleFilter = MultiplyByScalarImageFilterType::New(); cosScosSolarAngleFilter->SetCoef(vcl_cos(m_SolarAngle / rad2degCoef)); cosScosSolarAngleFilter->SetInput(cosS->GetOutput()); typename AddImageFilterType::Pointer cosIncidence = AddImageFilterType::New(); cosIncidence->SetInput1(cosAAzimuthsinSsinAngle->GetOutput()); cosIncidence->SetInput2(cosScosSolarAngleFilter->GetOutput()); IncidenceFilter->SetInput(cosIncidence->GetOutput()); // // Change radians in degres typename MultiplyByScalarImageFilterType::Pointer rad2DegFilter2 = MultiplyByScalarImageFilterType::New(); rad2DegFilter2->SetInput(IncidenceFilter->GetOutput()); rad2DegFilter2->SetCoef(rad2degCoef); // // Link to the output rad2DegFilter2->GraftOutput(IncidenceOutputPtr); rad2DegFilter2->Update(); this->GraftNthOutput(2, rad2DegFilter2->GetOutput()); // Exitance calculation typename ShiftScaleImageFilterType::Pointer addAzimut2 = ShiftScaleImageFilterType::New(); addAzimut2->SetScale(1.); addAzimut2->SetShift(m_ViewAzimut / rad2degCoef); addAzimut2->SetInput(oppositeFilter->GetOutput()); typename CosImageFilterType::Pointer cosAAzimut2 = CosImageFilterType::New(); cosAAzimut2->SetInput(addAzimut2->GetOutput()); typename MultiplyByScalarImageFilterType::Pointer sinSsinSolarAngleFilter2 = MultiplyByScalarImageFilterType::New(); sinSsinSolarAngleFilter2->SetCoef(vcl_sin(m_ViewAngle / rad2degCoef)); sinSsinSolarAngleFilter2->SetInput(sinS->GetOutput()); typename MultiplyImageFilterType::Pointer cosAAzimuthsinSsinAngle2 = MultiplyImageFilterType::New(); cosAAzimuthsinSsinAngle2->SetInput1(sinSsinSolarAngleFilter2->GetOutput()); cosAAzimuthsinSsinAngle2->SetInput2(cosAAzimut2->GetOutput()); typename MultiplyByScalarImageFilterType::Pointer cosScosSolarAngleFilter2 = MultiplyByScalarImageFilterType::New(); cosScosSolarAngleFilter2->SetCoef(vcl_cos(m_ViewAngle / rad2degCoef)); cosScosSolarAngleFilter2->SetInput(cosS->GetOutput()); typename AddImageFilterType::Pointer cosIncidence2 = AddImageFilterType::New(); cosIncidence2->SetInput1(cosAAzimuthsinSsinAngle2->GetOutput()); cosIncidence2->SetInput2(cosScosSolarAngleFilter2->GetOutput()); ExitanceFilter->SetInput(cosIncidence2->GetOutput()); // // Change radians in degres typename MultiplyByScalarImageFilterType::Pointer rad2DegFilter3 = MultiplyByScalarImageFilterType::New(); rad2DegFilter3->SetInput(ExitanceFilter->GetOutput()); rad2DegFilter3->SetCoef(rad2degCoef); // // Link to the output rad2DegFilter3->GraftOutput(ExitanceOutputPtr); rad2DegFilter3->Update(); this->GraftNthOutput(3, rad2DegFilter3->GetOutput()); } /**PrintSelf method */ template void DEMCaracteristicsExtractor ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Solar Angle: " << m_SolarAngle << std::endl; os << indent << "Solar Azimut: " << m_SolarAzimut << std::endl; os << indent << "View Angle: " << m_ViewAngle << std::endl; os << indent << "View Azimut: " << m_ViewAzimut << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/DEM/include/otbDEMToImageGenerator.h000066400000000000000000000146101301006202600254030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDEMToImageGenerator_h #define otbDEMToImageGenerator_h #include #include #include "itkImageSource.h" #include "otbImage.h" #include "otbDEMHandler.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbGenericRSTransform.h" namespace otb { /** \class DEMToImageGenerator * * \brief Class to generate an image from DEM data * * This class is based on DEMHandler. It takes in input the upper left longitude * and latitude, the spacing and the output image size. * Handle DTED and SRTM formats. * * \ingroup Images * * \example IO/DEMToImageGenerator.cxx * * * \ingroup OTBDEM */ template class ITK_EXPORT DEMToImageGenerator : public itk::ImageSource { public: /** Standard class typedefs. */ typedef TDEMImage DEMImageType; typedef typename DEMImageType::Pointer DEMImagePointerType; typedef typename DEMImageType::PixelType PixelType; typedef DEMToImageGenerator Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef DEMImageType OutputImageType; typedef typename Superclass::Pointer OutputImagePointer; typedef typename OutputImageType::SpacingType SpacingType; typedef typename OutputImageType::SizeType SizeType; typedef typename OutputImageType::PointType PointType; typedef typename OutputImageType::IndexType IndexType; typedef typename Superclass::OutputImageRegionType OutputImageRegionType; typedef itk::ImageRegionIteratorWithIndex ImageIteratorType; typedef otb::DEMHandler DEMHandlerType; /** Specialisation of OptResampleFilter with a remote * sensing transform */ typedef GenericRSTransform<> GenericRSTransformType; typedef typename GenericRSTransformType::Pointer GenericRSTransformPointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DEMToImageGenerator, ImageSource); /** Set/Get the Output Origin coordinates. */ itkSetMacro(OutputOrigin, PointType); itkGetConstReferenceMacro(OutputOrigin, PointType); /** Set/Get the Output Size. */ itkSetMacro(OutputSize, SizeType); itkGetConstReferenceMacro(OutputSize, SizeType); /** Set/Get the Output Spacing. */ itkSetMacro(OutputSpacing, SpacingType); itkGetConstReferenceMacro(OutputSpacing, SpacingType); /** Set/Get the Default Unknown Value. */ itkSetObjectMacro(Transform, GenericRSTransformType); itkGetConstObjectMacro(Transform, GenericRSTransformType); /** Set/Get the above ellipsoid flag. If false, height is given above MSL */ itkSetMacro(AboveEllipsoid,bool); itkGetMacro(AboveEllipsoid,bool); itkBooleanMacro(AboveEllipsoid); void InstantiateTransform(); /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ void InstanciateTransform() { otbWarningMacro( << "InstanciateTransform has been deprecated. Please use InstanciateTransform() instead"); this->InstantiateTransform(); } /** * Set/Get input & output projections. * Set/Get input & output keywordlist * The macro are not used here cause the input and the output are * inversed. */ void SetInputProjectionRef(const std::string& ref) { m_Transform->SetOutputProjectionRef(ref); this->Modified(); } std::string GetInputProjectionRef() const { return m_Transform->GetOutputProjectionRef(); } void SetOutputProjectionRef(const std::string& ref) { m_Transform->SetInputProjectionRef(ref); this->Modified(); } std::string GetOutputProjectionRef() const { return m_Transform->GetInputProjectionRef(); } /** Set/Get Input Keywordlist*/ void SetInputKeywordList(const ImageKeywordlist& kwl) { m_Transform->SetOutputKeywordList(kwl); this->Modified(); } const ImageKeywordlist GetInputKeywordList() { return m_Transform->GetOutputKeywordList(); } /** Set/Get output Keywordlist*/ void SetOutputKeywordList(const ImageKeywordlist& kwl) { m_Transform->SetInputKeywordList(kwl); this->Modified(); } const ImageKeywordlist GetOutputKeywordList() { return m_Transform->GetInputKeywordList(); } /** Useful to set the output parameters from an existing image*/ template void SetOutputParametersFromImage(const TImageType * image) { this->SetOutputOrigin ( image->GetOrigin() ); this->SetOutputSpacing ( image->GetSpacing() ); //this->SetOutputStartIndex ( image->GetLargestPossibleRegion().GetIndex() ); this->SetOutputSize ( image->GetLargestPossibleRegion().GetSize() ); this->SetOutputProjectionRef(image->GetProjectionRef()); this->SetOutputKeywordList(image->GetImageKeywordlist()); InstantiateTransform(); } protected: DEMToImageGenerator(); ~DEMToImageGenerator() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; DEMHandlerType::Pointer m_DEMHandler; PointType m_OutputOrigin; SpacingType m_OutputSpacing; SizeType m_OutputSize; PixelType m_DefaultUnknownValue; bool m_AboveEllipsoid; private: DEMToImageGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented GenericRSTransformPointerType m_Transform; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDEMToImageGenerator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/DEM/include/otbDEMToImageGenerator.txx000066400000000000000000000132731301006202600260030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDEMToImageGenerator_txx #define otbDEMToImageGenerator_txx #include "otbDEMToImageGenerator.h" #include "otbMacro.h" #include "itkProgressReporter.h" namespace otb { template DEMToImageGenerator ::DEMToImageGenerator() { m_DEMHandler = DEMHandlerType::Instance(); m_OutputSpacing[0] = 0.0001; m_OutputSpacing[1] = -0.0001; m_OutputSize[0] = 1; m_OutputSize[1] = 1; m_OutputOrigin[0] = 0; m_OutputOrigin[1] = 0; m_DefaultUnknownValue = itk::NumericTraits::ZeroValue(); m_AboveEllipsoid = false; m_Transform = GenericRSTransformType::New(); } // GenerateOutputInformation method template void DEMToImageGenerator ::GenerateOutputInformation() { DEMImageType *output; output = this->GetOutput(0); IndexType start; start[0] = 0; start[1] = 0; // Specify region parameters OutputImageRegionType largestPossibleRegion; largestPossibleRegion.SetSize(m_OutputSize); largestPossibleRegion.SetIndex(start); output->SetLargestPossibleRegion(largestPossibleRegion); output->SetSpacing(m_OutputSpacing); output->SetOrigin(m_OutputOrigin); // Get the Output MetaData Dictionary itk::MetaDataDictionary& dict = output->GetMetaDataDictionary(); // Encapsulate the metadata set by the user itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, m_Transform->GetInputProjectionRef()); if (this->GetOutputKeywordList().GetSize() > 0) { itk::EncapsulateMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, m_Transform->GetInputKeywordList()); } } // InstantiateTransform method template void DEMToImageGenerator ::InstantiateTransform() { m_Transform->InstantiateTransform(); } template void DEMToImageGenerator ::BeforeThreadedGenerateData() { InstantiateTransform(); DEMImagePointerType DEMImage = this->GetOutput(); // allocate the output buffer DEMImage->SetBufferedRegion(DEMImage->GetRequestedRegion()); DEMImage->Allocate(); DEMImage->FillBuffer(0); } template void DEMToImageGenerator ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { DEMImagePointerType DEMImage = this->GetOutput(); // Create an iterator that will walk the output region ImageIteratorType outIt = ImageIteratorType(DEMImage, outputRegionForThread); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Walk the output image, evaluating the height at each pixel IndexType currentindex; PointType phyPoint; double height; PointType geoPoint; for (outIt.GoToBegin(); !outIt.IsAtEnd(); ++outIt) { currentindex = outIt.GetIndex(); DEMImage->TransformIndexToPhysicalPoint(currentindex, phyPoint); if(m_Transform.IsNotNull()) { geoPoint = m_Transform->TransformPoint(phyPoint); if(m_AboveEllipsoid) { height = m_DEMHandler->GetHeightAboveEllipsoid(geoPoint); // Altitude // calculation } else { height = m_DEMHandler->GetHeightAboveMSL(geoPoint); // Altitude // calculation } } else { if(m_AboveEllipsoid) { height = m_DEMHandler->GetHeightAboveEllipsoid(phyPoint); // Altitude // calculation } else { height = m_DEMHandler->GetHeightAboveMSL(phyPoint); // Altitude // calculation } } /* otbMsgDevMacro(<< "Index : (" << currentindex[0]<< "," << currentindex[1] << ") -> PhyPoint : (" << phyPoint[0] << "," << phyPoint[1] << ") -> GeoPoint: (" << geoPoint[0] << "," << geoPoint[1] << ") -> height" << height); */ // otbMsgDevMacro(<< "height" << height); // DEM sets a default value (-32768) at point where it doesn't have altitude information. // OSSIM has chosen to change this default value in OSSIM_DBL_NAN (-4.5036e15). if (!vnl_math_isnan(height)) { // Fill the image DEMImage->SetPixel(currentindex, static_cast(height)); } else { // Back to the MNT default value DEMImage->SetPixel(currentindex, m_DefaultUnknownValue); } progress.CompletedPixel(); } } template void DEMToImageGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Output Spacing:" << m_OutputSpacing[0] << "," << m_OutputSpacing[1] << std::endl; os << indent << "Output Origin:" << m_OutputOrigin[0] << "," << m_OutputOrigin[1] << std::endl; os << indent << "Output Size:" << m_OutputSize[0] << "," << m_OutputSize[1] << std::endl; } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/DEM/otb-module.cmake000066400000000000000000000003711301006202600224300ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBDEM DEPENDS OTBCommon OTBITK OTBImageBase OTBImageManipulation OTBOSSIMAdapters OTBTransform TEST_DEPENDS OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/DEM/test/000077500000000000000000000000001301006202600203355ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DEM/test/CMakeLists.txt000066400000000000000000000100711301006202600230740ustar00rootroot00000000000000otb_module_test() set(OTBDEMTests otbDEMToImageGeneratorFromImageTest.cxx otbDEMToImageGeneratorNew.cxx otbDEMToImageGeneratorTest.cxx otbDEMCaracteristicsExtractor.cxx otbDEMCaracteristicsExtractorNew.cxx otbDEMTestDriver.cxx ) add_executable(otbDEMTestDriver ${OTBDEMTests}) target_link_libraries(otbDEMTestDriver ${OTBDEM-Test_LIBRARIES}) otb_module_target_label(otbDEMTestDriver) otb_add_test(NAME ioTvDEMToImageGeneratorFromImageTest_SensorModel COMMAND otbDEMTestDriver --compare-n-images ${EPSILON_5} 2 ${BASELINE}/ioTvDEMToImageGeneratorFromImageTest_SM.tif ${TEMP}/ioTvDEMToImageGeneratorFromImage_Extract_DEM.tif ${BASELINE}/ioTvDEMToImageGeneratorFromImageTest_SM.tif ${TEMP}/ioTvDEMToImageGeneratorFromImage_DEM_Extract.tif otbDEMToImageGeneratorFromImageTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${INPUTDATA}/DEM/srtm_directory ${TEMP}/ioTvDEMToImageGeneratorFromImage_Extract_DEM.tif ${TEMP}/ioTvDEMToImageGeneratorFromImage_DEM_Extract.tif 2600 4300 512 128 ) otb_add_test(NAME ioTvDEMToImageGeneratorFromImageTest COMMAND otbDEMTestDriver --compare-image ${EPSILON_5} ${BASELINE}/ioTvDEMToImageGeneratorFromImageTest.tif ${TEMP}/ioTvDEMToImageGeneratorFromImage.tif otbDEMToImageGeneratorFromImageTest ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${INPUTDATA}/DEM/srtm_directory ${TEMP}/ioTvDEMToImageGeneratorFromImage.tif ) otb_add_test(NAME ioTvDEMToImageGeneratorFromImageTest2 COMMAND otbDEMTestDriver --compare-n-images ${EPSILON_5} 2 ${BASELINE}/ioTvDEMToImageGeneratorFromImageTest_Ortho.tif ${TEMP}/ioTvDEMToImageGeneratorFromImage_Extract_DEM2.tif ${BASELINE}/ioTvDEMToImageGeneratorFromImageTest_Ortho.tif ${TEMP}/ioTvDEMToImageGeneratorFromImage_DEM_Extract2.tif otbDEMToImageGeneratorFromImageTest ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${INPUTDATA}/DEM/srtm_directory ${TEMP}/ioTvDEMToImageGeneratorFromImage_Extract_DEM2.tif ${TEMP}/ioTvDEMToImageGeneratorFromImage_DEM_Extract2.tif 10 15 16 64 ) otb_add_test(NAME ioTuDEMToImageGeneratorNew COMMAND otbDEMTestDriver otbDEMToImageGeneratorNew ) otb_add_test(NAME ioTvDEMToImageGeneratorTest2 COMMAND otbDEMTestDriver --compare-image ${EPSILON_5} ${BASELINE}/ioTvDEMToImageGenerator2.tif ${TEMP}/ioTvDEMToImageGenerator2.tif otbDEMToImageGeneratorTest ${INPUTDATA}/DEM/srtm_directory ${TEMP}/ioTvDEMToImageGenerator2.tif -1.8 52 232 422 0.02 -0.018 ) otb_add_test(NAME ioTvDEMToImageGeneratorTest1 COMMAND otbDEMTestDriver --compare-image ${EPSILON_5} ${BASELINE}/ioTvDEMToImageGenerator1.tif ${TEMP}/ioTvDEMToImageGenerator1.tif otbDEMToImageGeneratorTest ${INPUTDATA}/DEM/srtm_directory ${TEMP}/ioTvDEMToImageGenerator1.tif 1.437371 43.559045 512 128 0.000032 -0.000024 ) otb_add_test(NAME ioTvDEMToImageGeneratorTest COMMAND otbDEMTestDriver --compare-image ${EPSILON_5} ${BASELINE}/ioTvDEMToImageGenerator.tif ${TEMP}/ioTvDEMToImageGenerator.tif otbDEMToImageGeneratorTest ${INPUTDATA}/DEM/srtm_directory ${TEMP}/ioTvDEMToImageGenerator.tif 6.5 45.5 500 500 0.002 -0.002 ) otb_add_test(NAME raTvDEMCaracteristicsExtractor COMMAND otbDEMTestDriver --compare-n-images ${EPSILON_12} 4 ${BASELINE}/raTvDEMCaracteristicsExtractorSlop.tif ${TEMP}/raTvDEMCaracteristicsExtractorSlop.tif ${BASELINE}/raTvDEMCaracteristicsExtractorAspect.tif ${TEMP}/raTvDEMCaracteristicsExtractorAspect.tif ${BASELINE}/raTvDEMCaracteristicsExtractorIncidence.tif ${TEMP}/raTvDEMCaracteristicsExtractorIncidence.tif ${BASELINE}/raTvDEMCaracteristicsExtractorExitance.tif ${TEMP}/raTvDEMCaracteristicsExtractorExitance.tif otbDEMCaracteristicsExtractor ${INPUTDATA}/pyramide.tif 20 # view azimut 40 # view angle 10 # solar azimut 30 # solar angle ${TEMP}/raTvDEMCaracteristicsExtractorSlop.tif ${TEMP}/raTvDEMCaracteristicsExtractorAspect.tif ${TEMP}/raTvDEMCaracteristicsExtractorIncidence.tif ${TEMP}/raTvDEMCaracteristicsExtractorExitance.tif ) otb_add_test(NAME raTuDEMCaracteristicsExtractorNew COMMAND otbDEMTestDriver otbDEMCaracteristicsExtractorNew ) OTB-release-5.8/Modules/Filtering/DEM/test/otbDEMCaracteristicsExtractor.cxx000066400000000000000000000057021301006202600267570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDEMCaracteristicsExtractor.h" #include "otbImageFileWriter.h" #include "otbImageFileReader.h" int otbDEMCaracteristicsExtractor(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputSlotFileName = argv[6]; const char * outputAspectFileName = argv[7]; const char * outputIncidenceFileName = argv[8]; const char * outputExitanceFileName = argv[9]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputImageType; typedef otb::DEMCaracteristicsExtractor DEMCaracteristicsExtractorType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer input = ReaderType::New(); WriterType::Pointer slotWriter = WriterType::New(); WriterType::Pointer aspectWriter = WriterType::New(); WriterType::Pointer incidenceWriter = WriterType::New(); WriterType::Pointer exitanceWriter = WriterType::New(); DEMCaracteristicsExtractorType::Pointer filter = DEMCaracteristicsExtractorType::New(); slotWriter->SetNumberOfDivisionsStrippedStreaming(1); aspectWriter->SetNumberOfDivisionsStrippedStreaming(1); incidenceWriter->SetNumberOfDivisionsStrippedStreaming(1); exitanceWriter->SetNumberOfDivisionsStrippedStreaming(1); input->SetFileName(inputFileName); slotWriter->SetFileName(outputSlotFileName); aspectWriter->SetFileName(outputAspectFileName); incidenceWriter->SetFileName(outputIncidenceFileName); exitanceWriter->SetFileName(outputExitanceFileName); filter->SetInput(input->GetOutput()); filter->SetViewAzimut(static_cast(atof(argv[2]))); filter->SetViewAngle(static_cast(atof(argv[3]))); filter->SetSolarAzimut(static_cast(atof(argv[4]))); filter->SetSolarAngle(static_cast(atof(argv[5]))); slotWriter->SetInput(filter->GetSlopOutput()); aspectWriter->SetInput(filter->GetAspectOutput()); incidenceWriter->SetInput(filter->GetIncidenceOutput()); exitanceWriter->SetInput(filter->GetExitanceOutput()); slotWriter->Update(); aspectWriter->Update(); incidenceWriter->Update(); exitanceWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DEM/test/otbDEMCaracteristicsExtractorNew.cxx000066400000000000000000000022501301006202600274240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDEMCaracteristicsExtractor.h" int otbDEMCaracteristicsExtractorNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputImageType; typedef otb::DEMCaracteristicsExtractor DEMCaracteristicsExtractorType; DEMCaracteristicsExtractorType::Pointer filter = DEMCaracteristicsExtractorType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DEM/test/otbDEMTestDriver.cxx000066400000000000000000000004441301006202600242110ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbDEMToImageGeneratorFromImageTest); REGISTER_TEST(otbDEMToImageGeneratorNew); REGISTER_TEST(otbDEMToImageGeneratorTest); REGISTER_TEST(otbDEMCaracteristicsExtractor); REGISTER_TEST(otbDEMCaracteristicsExtractorNew); } OTB-release-5.8/Modules/Filtering/DEM/test/otbDEMToImageGeneratorFromImageTest.cxx000066400000000000000000000073411301006202600277440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbDEMToImageGenerator.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbExtractROI.h" int otbDEMToImageGeneratorFromImageTest(int argc, char * argv[]) { std::cout << argc << std::endl; if ( (argc != 9) && (argc != 4) ) { std::cout << argv[0] << " input filename, folder path, output filename 1, " " (option) output filename 2," " (option) X Output Origin, (option) Y Output Origin," " (option) X Output Size, (option) Y Output Size." << std::endl; return EXIT_FAILURE; } bool useExtractFilter = false; if (argc == 9) { useExtractFilter = true; } char * inputName = argv[1]; char * folderPath = argv[2]; char * outputName1 = argv[3]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VImageType; typedef otb::Image ImageType; typedef otb::DEMToImageGenerator DEMToImageGeneratorType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiToMonoChannelExtractROI ExtractVFilterType; typedef otb::ExtractROI ExtractFilterType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); DEMToImageGeneratorType::Pointer generatorFilter1 = DEMToImageGeneratorType::New(); DEMToImageGeneratorType::Pointer generatorFilter2 = DEMToImageGeneratorType::New(); ExtractVFilterType::Pointer extract1 = ExtractVFilterType::New(); ExtractFilterType::Pointer extract2 = ExtractFilterType::New(); WriterType::Pointer writer1 = WriterType::New(); WriterType::Pointer writer2 = WriterType::New(); otb::DEMHandler::Instance()->OpenDEMDirectory(folderPath); // Read input image reader->SetFileName(inputName); reader->GenerateOutputInformation(); // First pipeline: if (useExtractFilter) { extract1->SetInput(reader->GetOutput()); extract1->SetSizeX(atoi(argv[7])); extract1->SetSizeY(atoi(argv[8])); extract1->SetStartX(atoi(argv[5])); extract1->SetStartY(atoi(argv[6])); extract1->SetChannel(1); extract1->UpdateOutputInformation(); } if (useExtractFilter) { generatorFilter1->SetOutputParametersFromImage(extract1->GetOutput()); } else { generatorFilter1->SetOutputParametersFromImage(reader->GetOutput()); } writer1->SetFileName(outputName1); writer1->SetInput(generatorFilter1->GetOutput()); writer1->Update(); // Second pipeline: if (useExtractFilter) { char * outputName2 = argv[4]; generatorFilter2->SetOutputParametersFromImage(reader->GetOutput()); generatorFilter2->InstantiateTransform(); extract2->SetInput(generatorFilter2->GetOutput()); extract2->SetSizeX(atoi(argv[7])); extract2->SetSizeY(atoi(argv[8])); extract2->SetStartX(atoi(argv[5])); extract2->SetStartY(atoi(argv[6])); writer2->SetFileName(outputName2); writer2->SetInput(extract2->GetOutput()); writer2->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DEM/test/otbDEMToImageGeneratorNew.cxx000066400000000000000000000020071301006202600257610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDEMToImageGenerator.h" int otbDEMToImageGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::DEMToImageGenerator DEMToImageGeneratorType; // Instantiating object DEMToImageGeneratorType::Pointer object = DEMToImageGeneratorType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DEM/test/otbDEMToImageGeneratorTest.cxx000066400000000000000000000043741301006202600261600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDEMToImageGenerator.h" #include "otbImageFileWriter.h" #include "otbStandardFilterWatcher.h" int otbDEMToImageGeneratorTest(int argc, char * argv[]) { if (argc < 9) { std::cout << argv[0] << " folder path , output filename , Longitude Output Orign point , Latitude Output Origin point , X Output Size, Y Output size , X Spacing , Y Spacing" << std::endl; return EXIT_FAILURE; } char * folderPath = argv[1]; char * outputName = argv[2]; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::DEMToImageGenerator DEMToImageGeneratorType; typedef DEMToImageGeneratorType::PointType PointType; typedef DEMToImageGeneratorType::SizeType SizeType; typedef DEMToImageGeneratorType::SpacingType SpacingType; typedef otb::ImageFileWriter WriterType; // Instantiating object DEMToImageGeneratorType::Pointer object = DEMToImageGeneratorType::New(); WriterType::Pointer writer = WriterType::New(); PointType origin; origin[0] = ::atof(argv[3]); origin[1] = ::atof(argv[4]); SizeType size; size[0] = ::atoi(argv[5]); size[1] = ::atoi(argv[6]); SpacingType spacing; spacing[0] = ::atof(argv[7]); spacing[1] = ::atof(argv[8]); otb::DEMHandler::Instance()->OpenDEMDirectory(folderPath); object->SetOutputOrigin(origin); object->SetOutputSize(size); object->SetOutputSpacing(spacing); std::cout << object << std::endl; otb::StandardFilterWatcher watcher(object, "DEM to image generator"); writer->SetFileName(outputName); writer->SetInput(object->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/000077500000000000000000000000001301006202600236165ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/CMakeLists.txt000066400000000000000000000000661301006202600263600ustar00rootroot00000000000000project(OTBDimensionalityReduction) otb_module_impl() OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/000077500000000000000000000000001301006202600252415ustar00rootroot00000000000000otbAngularProjectionBinaryImageFilter.h000066400000000000000000000071671301006202600347570ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAngularProjectionBinaryImageFilter_h #define otbAngularProjectionBinaryImageFilter_h #include #include "itkImageToImageFilter.h" namespace otb { /** \class AngularProjectionBinaryImageFilter * \brief Performs \f$ y_i = \cos \theta_i x_1 + \sin \theta_i x_2\f$ * * This class performs the projections of the 2 input images to a set of N * output images according to N angular values * * * \ingroup OTBDimensionalityReduction */ template < class TInputImage, class TOutputImage, class TPrecision > class ITK_EXPORT AngularProjectionBinaryImageFilter : public itk::ImageToImageFilter< TInputImage, TOutputImage > { public: /** Standard typedefs */ typedef AngularProjectionBinaryImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(AngularProjectionBinaryImageFilter, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::PixelType OutputPixelType; typedef TPrecision PrecisionType; /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Set/Get Angle set */ std::vector GetAngleSet() const { return m_AngleSet; } void SetAngleSet ( std::vector & angle ); void SetInput1 ( const InputImageType * ); const InputImageType * GetInput1 () const; void SetInput2 ( const InputImageType * ); const InputImageType * GetInput2 () const; protected: AngularProjectionBinaryImageFilter(); ~AngularProjectionBinaryImageFilter() ITK_OVERRIDE { } void GenerateOutputInformation() ITK_OVERRIDE; void ThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadID ) ITK_OVERRIDE; private: AngularProjectionBinaryImageFilter(const Self&); // not implemented void operator=(const Self&); // not implemented std::vector m_AngleSet; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAngularProjectionBinaryImageFilter.txx" #endif #endif otbAngularProjectionBinaryImageFilter.txx000066400000000000000000000107221301006202600353420ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAngularProjectionBinaryImageFilter_txx #define otbAngularProjectionBinaryImageFilter_txx #include "otbAngularProjectionBinaryImageFilter.h" #include #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template < class TInputImage, class TOutputImage, class TPrecision > AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::AngularProjectionBinaryImageFilter () { this->SetNumberOfRequiredInputs(2); } template < class TInputImage, class TOutputImage, class TPrecision > void AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::SetInput1 ( const InputImageType * inputPtr ) { this->SetNthInput(0, const_cast( inputPtr )); } template < class TInputImage, class TOutputImage, class TPrecision > void AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::SetInput2 ( const InputImageType * inputPtr ) { this->SetNthInput(1, const_cast( inputPtr )); } template < class TInputImage, class TOutputImage, class TPrecision > const TInputImage * AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::GetInput1() const { if ( this->GetNumberOfInputs() < 1 ) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } template < class TInputImage, class TOutputImage, class TPrecision > const TInputImage * AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::GetInput2() const { if ( this->GetNumberOfInputs() < 2 ) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1)); } template < class TInputImage, class TOutputImage, class TPrecision > void AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::SetAngleSet ( std::vector & angle ) { m_AngleSet = angle; this->SetNumberOfRequiredOutputs( angle.size() ); for ( unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i ) { this->SetNthOutput(i, OutputImageType::New()); } this->Modified(); } template < class TInputImage, class TOutputImage, class TPrecision > void AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { this->GetOutput(i)->SetRegions( this->GetInput()->GetRequestedRegion()); } } template < class TInputImage, class TOutputImage, class TPrecision > void AngularProjectionBinaryImageFilter< TInputImage, TOutputImage, TPrecision > ::ThreadedGenerateData ( const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId ) { itk::ProgressReporter reporter(this, threadId, outputRegionForThread.GetNumberOfPixels() ); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion( inputRegionForThread, outputRegionForThread ); itk::ImageRegionConstIterator iter1 ( this->GetInput1(), inputRegionForThread ); iter1.GoToBegin(); itk::ImageRegionConstIterator iter2 ( this->GetInput2(), inputRegionForThread ); iter2.GoToBegin(); std::vector< itk::ImageRegionIterator > outIter ( this->GetNumberOfOutputs() ); for ( unsigned int i = 0; i < outIter.size(); ++i ) { outIter[i] = itk::ImageRegionIterator ( this->GetOutput(i), outputRegionForThread ); outIter[i].GoToBegin(); } while ( !iter1.IsAtEnd() && !iter2.IsAtEnd() ) { for ( unsigned int i = 0; i < outIter.size(); ++i ) { outIter[i].Set( vcl_cos( m_AngleSet[i] ) * iter1.Get() + vcl_sin( m_AngleSet[i] ) * iter2.Get() ); ++outIter[i]; } ++iter1; ++iter2; reporter.CompletedPixel(); } } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbAngularProjectionImageFilter.h000066400000000000000000000076161301006202600336700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAngularProjectionImageFilter_h #define otbAngularProjectionImageFilter_h #include "itkImageRegionConstIterator.h" #include "itkProgressReporter.h" #include "itkImageToImageFilter.h" namespace otb { /** \class AngularProjectionImageFilter * \brief Performs spherical transformation in ND space * * This class performs the projections of the N input images according * to angular value through the generalized spherical projection. * * The angle value are considered to come from a itk::FixedArray... * * \ingroup Threaded * * \ingroup OTBDimensionalityReduction */ template < class TInputImage, class TOutputImage, class TAngleArray, class TPrecision > class ITK_EXPORT AngularProjectionImageFilter : public itk::ImageToImageFilter< TInputImage, TOutputImage > { public: /** Standard typedefs */ typedef AngularProjectionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(AngularProjectionImageFilter, ImageToImageFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); //itkStaticConstMacro(NumberOfInputImages, unsigned int, TAngleArray::Dimension+1); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef TPrecision PrecisionType; typedef TAngleArray AngleArrayType; typedef typename AngleArrayType::ValueType AngleValueType; typedef itk::ImageRegionConstIterator ImageRegionConstIteratorType; typedef std::vector< ImageRegionConstIteratorType > ImageRegionConstIteratorVectorType; /** Set/Get Angle set */ itkGetMacro(AngleArray, AngleArrayType); itkSetMacro(AngleArray, AngleArrayType); void SetInput ( unsigned int i, const InputImageType * ) ITK_OVERRIDE; using Superclass::SetInput; const InputImageType * GetInput( unsigned int i ) const; protected: AngularProjectionImageFilter(); ~AngularProjectionImageFilter() ITK_OVERRIDE { } void ThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadID ) ITK_OVERRIDE; virtual OutputImagePixelType InternalGenerateData ( const ImageRegionConstIteratorVectorType & ) const; private: AngularProjectionImageFilter(const Self&); // not implemented void operator=(const Self&); // not implemented AngleArrayType m_AngleArray; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAngularProjectionImageFilter.txx" #endif #endif otbAngularProjectionImageFilter.txx000066400000000000000000000112251301006202600341740ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAngularProjectionImageFilter_txx #define otbAngularProjectionImageFilter_txx #include "otbAngularProjectionImageFilter.h" #include #include #include namespace otb { template < class TInputImage, class TOutputImage, class TAngleArray, class TPrecision > AngularProjectionImageFilter< TInputImage, TOutputImage, TAngleArray, TPrecision > ::AngularProjectionImageFilter () { //this->SetNumberOfRequiredInputs(NumberOfInputImages); this->SetNumberOfRequiredOutputs(1); } template < class TInputImage, class TOutputImage, class TAngleArray, class TPrecision > void AngularProjectionImageFilter< TInputImage, TOutputImage, TAngleArray, TPrecision > ::SetInput ( unsigned int i, const InputImageType * img ) { this->itk::ProcessObject::SetNthInput(i, const_cast< InputImageType * >( img ) ); } template < class TInputImage, class TOutputImage, class TAngleArray, class TPrecision > const TInputImage * AngularProjectionImageFilter< TInputImage, TOutputImage, TAngleArray, TPrecision > ::GetInput ( unsigned int i ) const { if ( i >= this->GetNumberOfInputs() ) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(i) ); } template < class TInputImage, class TOutputImage, class TAngleArray, class TPrecision > void AngularProjectionImageFilter< TInputImage, TOutputImage, TAngleArray, TPrecision > ::ThreadedGenerateData ( const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId ) { itk::ProgressReporter reporter(this, threadId, outputRegionForThread.GetNumberOfPixels() ); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion( inputRegionForThread, outputRegionForThread ); bool iteratorsAtEnd = false; ImageRegionConstIteratorVectorType it ( this->GetNumberOfInputs() ); for ( unsigned int i = 0; i < this->GetNumberOfInputs(); ++i ) { it[i] = ImageRegionConstIteratorType( this->GetInput(i), inputRegionForThread ); it[i].GoToBegin(); if ( it[i].IsAtEnd() ) iteratorsAtEnd = true; } itk::ImageRegionIterator outIter ( this->GetOutput(), outputRegionForThread ); outIter.GoToBegin(); while ( !iteratorsAtEnd && !outIter.IsAtEnd() ) { outIter.Set( InternalGenerateData( it ) ); ++outIter; for ( unsigned int i = 0; i < this->GetNumberOfInputs(); ++i ) { ++(it[i]); if ( it[i].IsAtEnd() ) iteratorsAtEnd = true; } reporter.CompletedPixel(); } } template < class TInputImage, class TOutputImage, class TAngleArray, class TPrecision > typename AngularProjectionImageFilter< TInputImage, TOutputImage, TAngleArray, TPrecision > ::OutputImagePixelType AngularProjectionImageFilter< TInputImage, TOutputImage, TAngleArray, TPrecision > ::InternalGenerateData ( const ImageRegionConstIteratorVectorType & it ) const { PrecisionType output = 0; if ( this->GetNumberOfInputs() == 2 ) { PrecisionType alpha = static_cast( m_AngleArray[0] ); output = static_cast( it[0].Get() ) * vcl_cos( alpha ) - static_cast( it[1].Get() ) * vcl_sin( alpha ); } else if ( this->GetNumberOfInputs() == 3 ) { PrecisionType alpha = static_cast( m_AngleArray[0] ); PrecisionType beta = static_cast( m_AngleArray[1] ); output = static_cast( it[0].Get() ) * vcl_cos( alpha ) - static_cast( it[1].Get() ) * vcl_sin( alpha ) * vcl_cos ( beta ) + static_cast( it[2].Get() ) * vcl_sin( alpha ) * vcl_sin ( beta ); } else { unsigned int i = this->GetNumberOfInputs()-1; output = static_cast( it[i--].Get() ); do { PrecisionType alpha = static_cast( m_AngleArray[i] ); output = static_cast( it[i].Get() ) * vcl_cos( alpha ) - output * vcl_sin( alpha ); } while ( i-- == 0 ); } return static_cast( output ); } } // end of namespace otb #endif otbAngularProjectionSetImageFilter.h000066400000000000000000000125471301006202600342640ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAngularProjectionSetImageFilter_h #define otbAngularProjectionSetImageFilter_h #include "otbAngularProjectionImageFilter.h" #include "otbImageToImageListFilter.h" #include "otbObjectList.h" namespace otb { /** \class AngularProjectionSetImageFilter * \brief Performs spherical transformation in ND space from a set of angle values * * This class performs the projections of the set input images to a set of N * output images according to N angular values. * * The list of angular values is given in template. It is supposed to be a list of FixedArray * of dimension N-1 (since in speherical coordinate system, there are N-1 angle value in a * ND space). * * Each projection is performed by the AngularProjectionImageFilter class and the * output is becoming a ImageList. * * \sa AngularProjectionImageListFilter * * * \ingroup OTBDimensionalityReduction */ template < class TInputImage, class TOutputImage, class TAngleList, class TPrecision > class ITK_EXPORT AngularProjectionSetImageFilter : public ImageToImageListFilter< TInputImage, TOutputImage > { public: /** Standard typedefs */ typedef AngularProjectionSetImageFilter Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(AngularProjectionSetImageFilter, ImageToImageListFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); //itkStaticConstMacro(NumberOfInputImages, unsigned int, TAngleList::MeasurementVectorType::Dimension+1); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::Iterator OutputImageIterator; typedef TPrecision PrecisionType; typedef TAngleList AngleListType; typedef typename AngleListType::Pointer AngleListPointerType; typedef typename AngleListType::MeasurementVectorType MeasurementVectorType; typedef typename AngleListType::MeasurementType MeasurementType; typedef MeasurementVectorType AngleArrayType; typedef MeasurementType AngleValueType; typedef AngularProjectionImageFilter< InputImageType, OutputImageType, AngleArrayType, PrecisionType > FilterType; typedef typename FilterType::Pointer FilterPointerType; typedef ObjectList FilterListType; typedef typename FilterListType::Pointer FilterListPointerType; typedef typename FilterListType::Iterator FilterListIterator; itkGetObjectMacro(FilterList, FilterListType); FilterType * GetNthFilter(unsigned int idx) const { if (idx >= m_FilterList->Size()) { itkExceptionMacro(<< "Impossible to GetNthFilter with the index element " << idx << "; this element don't exist, the size of the filter list is " << m_FilterList->Size() << "."); } return static_cast(m_FilterList->GetNthElement(idx)); } /** Set/Get Angle List */ AngleListType * GetAngleList () const { return static_cast( this->m_AngleList ); } void SetAngleList ( const AngleListType * angles ) { this->m_AngleList = const_cast( angles ); this->Modified(); } void SetInput ( unsigned int i, const InputImageType * ); using Superclass::SetInput; const InputImageType * GetInput( unsigned int i ) const; protected: AngularProjectionSetImageFilter(); ~AngularProjectionSetImageFilter() ITK_OVERRIDE { } void GenerateData() ITK_OVERRIDE; private: AngularProjectionSetImageFilter(const Self&); // not implemented void operator=(const Self&); // not implemented AngleListPointerType m_AngleList; FilterListPointerType m_FilterList; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAngularProjectionSetImageFilter.txx" #endif #endif otbAngularProjectionSetImageFilter.txx000066400000000000000000000060031301006202600346460ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAngularProjectionSetImageFilter_txx #define otbAngularProjectionSetImageFilter_txx #include "otbAngularProjectionSetImageFilter.h" #include #include namespace otb { template < class TInputImage, class TOutputImage, class TAngleList, class TPrecision > AngularProjectionSetImageFilter< TInputImage, TOutputImage, TAngleList, TPrecision > ::AngularProjectionSetImageFilter () { //this->SetNumberOfRequiredInputs( NumberOfInputImages ); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageListType::New()); m_FilterList = FilterListType::New(); m_AngleList = AngleListType::New(); } template < class TInputImage, class TOutputImage, class TAngleList, class TPrecision > void AngularProjectionSetImageFilter< TInputImage, TOutputImage, TAngleList, TPrecision > ::SetInput ( unsigned int i, const InputImageType * img ) { this->itk::ProcessObject::SetNthInput(i, const_cast< InputImageType * >( img ) ); } template < class TInputImage, class TOutputImage, class TAngleList, class TPrecision > const TInputImage * AngularProjectionSetImageFilter< TInputImage, TOutputImage, TAngleList, TPrecision > ::GetInput ( unsigned int i ) const { if ( i >= this->GetNumberOfInputs() ) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(i) ); } template < class TInputImage, class TOutputImage, class TAngleList, class TPrecision > void AngularProjectionSetImageFilter< TInputImage, TOutputImage, TAngleList, TPrecision > ::GenerateData () { itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); std::cerr << "Using " << GetAngleList()->Size() << " outputs...\n"; GetFilterList()->Resize( GetAngleList()->Size() ); this->GetOutput()->Resize( GetAngleList()->Size() ); for ( unsigned int idx = 0; idx < GetFilterList()->Size(); ++idx ) { GetFilterList()->SetNthElement(0, FilterType::New()); FilterPointerType filter = GetFilterList()->GetNthElement(0); for ( unsigned int i = 0; i < this->GetNumberOfInputs(); ++i ) filter->SetInput( i, this->GetInput(i) ); filter->SetAngleArray( GetAngleList()->GetMeasurementVector(idx) ); progress->RegisterInternalFilter(filter, 1.f/static_cast( GetAngleList()->Size() ) ); filter->Update(); this->GetOutput()->SetNthElement( idx, filter->GetOutput() ); } } } // end of namespace otb #endif otbEstimateInnerProductPCAImageFilter.h000066400000000000000000000110071301006202600346040ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEstimateInnerProductPCAImageFilter_h #define otbEstimateInnerProductPCAImageFilter_h #include "itkImageToImageFilter.h" #include "otbStreamingInnerProductVectorImageFilter.h" namespace otb { /** \class EstimateInnerProductPCAImageFilter * \brief Applies the Inner product to an vector image. * Implement the itk::ImagePCAShapeModelEstimator algorithms in streaming capabilities * Use by the InnerProductPCAImageFilter composite filter * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT EstimateInnerProductPCAImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef EstimateInnerProductPCAImageFilter Self; typedef typename itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(EstimateInnerProductPCAImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef StreamingInnerProductVectorImageFilter StreamingInnerProductType; typedef typename StreamingInnerProductType::Pointer StreamingInnerProductPointer; typedef typename StreamingInnerProductType::MatrixType MatrixType; typedef typename StreamingInnerProductType::MatrixObjectType MatrixObjectType; /** Set/Get the number of required largest principal components. The filter produces the required number of principal components plus one outputs. Output index 0 represents the mean image and the remaining outputs the requested principal components.*/ itkSetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkGetMacro(NumberOfPrincipalComponentsRequired, unsigned int); /** Enable/Disable center data */ itkSetMacro(CenterData, bool); itkGetMacro(CenterData, bool); itkBooleanMacro(CenterData); protected: EstimateInnerProductPCAImageFilter(); ~EstimateInnerProductPCAImageFilter() ITK_OVERRIDE {} /** GenerateOutputInformation * Set the number of bands of the output. * Copy information from the first image of the list if existing. **/ void GenerateOutputInformation(void) ITK_OVERRIDE; /** * BeforeThreadedGenerateData **/ void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: EstimateInnerProductPCAImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The number of output Principal Components */ unsigned int m_NumberOfPrincipalComponentsRequired; /** Enable/Disable center data */ bool m_CenterData; /** Inner Product Matrix pre computed */ MatrixType m_InnerProduct; /** Contains Eigen Vectors Of Inner Product Matrix computed */ MatrixType m_EigenVectorsOfInnerProductMatrix; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbEstimateInnerProductPCAImageFilter.txx" #endif #endif otbEstimateInnerProductPCAImageFilter.txx000066400000000000000000000112141301006202600352000ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEstimateInnerProductPCAImageFilter_txx #define otbEstimateInnerProductPCAImageFilter_txx #include "otbEstimateInnerProductPCAImageFilter.h" #include #include namespace otb { /** * Constructor */ template EstimateInnerProductPCAImageFilter ::EstimateInnerProductPCAImageFilter() { m_NumberOfPrincipalComponentsRequired = 1; } /** * Printself */ template void EstimateInnerProductPCAImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } /** * GenerateOutputInformation */ template void EstimateInnerProductPCAImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel(m_NumberOfPrincipalComponentsRequired); } /** * BeforeThreadedGenerateData */ template void EstimateInnerProductPCAImageFilter ::BeforeThreadedGenerateData() { // Instantiation object StreamingInnerProductPointer streamingInnerProduct = StreamingInnerProductType::New(); streamingInnerProduct->SetInput(const_cast(this->GetInput())); streamingInnerProduct->SetCenterData(m_CenterData); streamingInnerProduct->Update(); m_InnerProduct = streamingInnerProduct->GetInnerProduct(); MatrixType identityMatrix(m_InnerProduct.rows(), m_InnerProduct.columns()); identityMatrix.set_identity(); vnl_generalized_eigensystem eigenVectors_eigenValues(m_InnerProduct, identityMatrix); m_EigenVectorsOfInnerProductMatrix = eigenVectors_eigenValues.V; } template void EstimateInnerProductPCAImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { typename InputImageType::ConstPointer inputPtr = this->GetInput(); typename OutputImageType::Pointer outputPtr = this->GetOutput(); // Define the portion of the input to walk for this thread, using // the CallCopyOutputRegionToInputRegion method allows for the input // and output images to be different dimensions unsigned int numberOfTrainingImages = inputPtr->GetNumberOfComponentsPerPixel(); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, inputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { InputPixelType inputPixel = inputIt.Get(); OutputPixelType outputPixel; outputPixel.SetSize(m_NumberOfPrincipalComponentsRequired); outputPixel.Fill(0); for (unsigned int img_number = 0; img_number < numberOfTrainingImages; ++img_number) { unsigned int indexNumberOfTrainingImages = numberOfTrainingImages - 1; for (unsigned int vec_number = 0; vec_number < m_NumberOfPrincipalComponentsRequired; ++vec_number, indexNumberOfTrainingImages--) { outputPixel[vec_number] += static_cast(static_cast( inputPixel[img_number]) * static_cast( m_EigenVectorsOfInnerProductMatrix[img_number ][indexNumberOfTrainingImages])); } } outputIt.Set(outputPixel); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } } #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbFastICAImageFilter.h000066400000000000000000000150311301006202600314420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFastICAImageFilter_h #define otbFastICAImageFilter_h #include "itkImageToImageFilter.h" #include "otbPCAImageFilter.h" #include "otbFastICAInternalOptimizerVectorImageFilter.h" namespace otb { /** \class FastICAImageFilter * \brief Performs a Independent Component Analysis * * The internal structure of this filter is a filter-to-filter like structure. * The estimation of the covariance matrix has persistent capabilities... * * \sa PCAImageFilter * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT FastICAImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef FastICAImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(FastICAImageFilter, ImageToImageFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef Transform::TransformDirection TransformDirectionEnumType; itkStaticConstMacro(DirectionOfTransformation, TransformDirectionEnumType, TDirectionOfTransformation); /** typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef PCAImageFilter< InputImageType, OutputImageType, TDirectionOfTransformation > PCAFilterType; typedef typename PCAFilterType::Pointer PCAFilterPointerType; typedef typename PCAFilterType::RealType RealType; typedef typename PCAFilterType::VectorType VectorType; typedef typename PCAFilterType::MatrixType MatrixType; typedef typename MatrixType::InternalMatrixType InternalMatrixType; typedef typename InternalMatrixType::element_type MatrixElementType; typedef MatrixImageFilter< TInputImage, TOutputImage > TransformFilterType; typedef typename TransformFilterType::Pointer TransformFilterPointerType; typedef FastICAInternalOptimizerVectorImageFilter< InputImageType, InputImageType > InternalOptimizerType; typedef typename InternalOptimizerType::Pointer InternalOptimizerPointerType; typedef StreamingStatisticsVectorImageFilter< InputImageType > MeanEstimatorFilterType; typedef typename MeanEstimatorFilterType::Pointer MeanEstimatorFilterPointerType; typedef double (*ContrastFunctionType) ( double ); /** * Set/Get the number of required largest principal components. */ itkGetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkSetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkGetConstMacro(PCAFilter, PCAFilterType *); itkGetMacro(PCAFilter, PCAFilterType *); itkGetConstMacro(TransformFilter, TransformFilterType *); itkGetMacro(TransformFilter, TransformFilterType *); VectorType GetMeanValues () const { return this->GetPCAFilter()->GetMeanValues(); } void SetMeanValues ( const VectorType & vec ) { m_PCAFilter->SetMeanValues(vec); } VectorType GetStdDevValues ( ) const { return this->GetPCAFilter()->GetStdDevValues(); } void SetStdDevValues ( const VectorType & vec ) { m_PCAFilter->SetStdDevValues(vec); } MatrixType GetPCATransformationMatrix () const { return this->GetPCAFilter()->GetTransformationMatrix(); } void SetPCATransformationMatrix ( const MatrixType & mat, bool isForward = true ) { m_PCAFilter->SetTransformationMatrix(mat, isForward); } itkGetConstMacro(TransformationMatrix, MatrixType); itkGetMacro(TransformationMatrix, MatrixType); void SetTransformationMatrix ( const MatrixType & mat, bool isForward = true ) { m_IsTransformationForward = isForward; m_GivenTransformationMatrix = true; m_TransformationMatrix = mat; this->Modified(); } itkGetMacro(NumberOfIterations, unsigned int); itkSetMacro(NumberOfIterations, unsigned int); itkGetMacro(ConvergenceThreshold, double); itkSetMacro(ConvergenceThreshold, double); itkGetMacro(ContrastFunction, ContrastFunctionType); itkGetMacro(Mu, double); itkSetMacro(Mu, double); protected: FastICAImageFilter (); ~FastICAImageFilter() ITK_OVERRIDE { } /** GenerateOutputInformation * Propagate vector length info and modify if needed * NumberOfPrincipalComponentsRequired * * In REVERSE mode, the covariance matrix or the transformation matrix * (which may not be square) has to be given, * otherwize, GenerateOutputInformation throws an itk::ExceptionObject */ void GenerateOutputInformation() ITK_OVERRIDE; /** GenerateData * Through a filter of filter structure */ void GenerateData () ITK_OVERRIDE; /** Internal methods */ void ForwardGenerateOutputInformation(); void ReverseGenerateOutputInformation(); virtual void ForwardGenerateData(); virtual void ReverseGenerateData(); /** this is the specific part of FastICA */ virtual void GenerateTransformationMatrix(); unsigned int m_NumberOfPrincipalComponentsRequired; /** Transformation matrix refers to the ICA step (not PCA) */ bool m_GivenTransformationMatrix; bool m_IsTransformationForward; MatrixType m_TransformationMatrix; /** FastICA parameters */ unsigned int m_NumberOfIterations; // def is 50 double m_ConvergenceThreshold; // def is 1e-4 ContrastFunctionType m_ContrastFunction; // see g() function in the biblio. Def is tanh double m_Mu; // def is 1. in [0, 1] PCAFilterPointerType m_PCAFilter; TransformFilterPointerType m_TransformFilter; private: FastICAImageFilter( const Self & ); //purposely not implemented void operator =( const Self & ); //purposely not implemented }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFastICAImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbFastICAImageFilter.txx000066400000000000000000000243001301006202600320350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFastICAImageFilter_txx #define otbFastICAImageFilter_txx #include "otbFastICAImageFilter.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include #include #include namespace otb { template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::FastICAImageFilter () { this->SetNumberOfRequiredInputs(1); m_NumberOfPrincipalComponentsRequired = 0; m_GivenTransformationMatrix = false; m_IsTransformationForward = true; m_NumberOfIterations = 50; m_ConvergenceThreshold = 1E-4; m_ContrastFunction = &vcl_tanh; m_Mu = 1.; m_PCAFilter = PCAFilterType::New(); m_PCAFilter->SetUseNormalization(true); m_TransformFilter = TransformFilterType::New(); } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::GenerateOutputInformation() // throw itk::ExceptionObject { Superclass::GenerateOutputInformation(); switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): { if ( m_NumberOfPrincipalComponentsRequired == 0 || m_NumberOfPrincipalComponentsRequired > this->GetInput()->GetNumberOfComponentsPerPixel() ) { m_NumberOfPrincipalComponentsRequired = this->GetInput()->GetNumberOfComponentsPerPixel(); } this->GetOutput()->SetNumberOfComponentsPerPixel( m_NumberOfPrincipalComponentsRequired ); break; } case static_cast(Transform::INVERSE): { unsigned int theOutputDimension = 0; if ( m_GivenTransformationMatrix ) { theOutputDimension = m_TransformationMatrix.Rows() >= m_TransformationMatrix.Cols() ? m_TransformationMatrix.Rows() : m_TransformationMatrix.Cols(); } else { throw itk::ExceptionObject(__FILE__, __LINE__, "Mixture matrix is required to know the output size", ITK_LOCATION); } this->GetOutput()->SetNumberOfComponentsPerPixel( theOutputDimension ); break; } default: throw itk::ExceptionObject(__FILE__, __LINE__, "Class should be templeted with FORWARD or INVERSE only...", ITK_LOCATION ); } switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): { ForwardGenerateOutputInformation(); break; } case static_cast(Transform::INVERSE): { ReverseGenerateOutputInformation(); break; } } } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ForwardGenerateOutputInformation() { typename InputImageType::Pointer inputImgPtr = const_cast( this->GetInput() ); m_PCAFilter->SetInput( inputImgPtr ); m_PCAFilter->GetOutput()->UpdateOutputInformation(); if ( !m_GivenTransformationMatrix ) { GenerateTransformationMatrix(); } else if ( !m_IsTransformationForward ) { // prevent from multiple inversion in the pipelines m_IsTransformationForward = true; vnl_svd< MatrixElementType > invertor ( m_TransformationMatrix.GetVnlMatrix() ); m_TransformationMatrix = invertor.pinverse(); } if ( m_TransformationMatrix.GetVnlMatrix().empty() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Empty transformation matrix", ITK_LOCATION); } m_TransformFilter->SetInput( m_PCAFilter->GetOutput() ); m_TransformFilter->SetMatrix( m_TransformationMatrix.GetVnlMatrix() ); } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ReverseGenerateOutputInformation() { if ( !m_GivenTransformationMatrix ) { throw itk::ExceptionObject( __FILE__, __LINE__, "No Transformation matrix given", ITK_LOCATION ); } if ( m_TransformationMatrix.GetVnlMatrix().empty() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Empty transformation matrix", ITK_LOCATION); } if ( m_IsTransformationForward ) { // prevent from multiple inversion in the pipelines m_IsTransformationForward = false; vnl_svd< MatrixElementType > invertor ( m_TransformationMatrix.GetVnlMatrix() ); m_TransformationMatrix = invertor.pinverse(); } m_TransformFilter->SetInput( this->GetInput() ); m_TransformFilter->SetMatrix( m_TransformationMatrix.GetVnlMatrix() ); /* * PCA filter may throw exception if * the mean, stdDev and transformation matrix * have not been given at this point */ m_PCAFilter->SetInput( m_TransformFilter->GetOutput() ); } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::GenerateData () { switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): return ForwardGenerateData(); case static_cast(Transform::INVERSE): return ReverseGenerateData(); default: throw itk::ExceptionObject(__FILE__, __LINE__, "Class should be templated with FORWARD or INVERSE only...", ITK_LOCATION ); } } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ForwardGenerateData () { m_TransformFilter->GraftOutput( this->GetOutput() ); m_TransformFilter->Update(); this->GraftOutput( m_TransformFilter->GetOutput() ); } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ReverseGenerateData () { m_PCAFilter->GraftOutput( this->GetOutput() ); m_PCAFilter->Update(); this->GraftOutput( m_PCAFilter->GetOutput() ); } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void FastICAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::GenerateTransformationMatrix () { itk::ProgressReporter reporter ( this, 0, GetNumberOfIterations(), GetNumberOfIterations() ); double convergence = itk::NumericTraits::max(); unsigned int iteration = 0; const unsigned int size = this->GetInput()->GetNumberOfComponentsPerPixel(); // transformation matrix InternalMatrixType W ( size, size, vnl_matrix_identity ); while ( iteration++ < GetNumberOfIterations() && convergence > GetConvergenceThreshold() ) { InternalMatrixType W_old ( W ); typename InputImageType::Pointer img = const_cast( this->GetInput() ); TransformFilterPointerType transformer = TransformFilterType::New(); if ( !W.is_identity() ) { transformer->SetInput( GetPCAFilter()->GetOutput() ); transformer->SetMatrix( W ); transformer->Update(); img = const_cast( transformer->GetOutput() ); } for ( unsigned int band = 0; band < size; band++ ) { otbMsgDebugMacro( << "Iteration " << iteration << ", bande " << band << ", convergence " << convergence ); InternalOptimizerPointerType optimizer = InternalOptimizerType::New(); optimizer->SetInput( 0, m_PCAFilter->GetOutput() ); optimizer->SetInput( 1, img ); optimizer->SetW( W ); optimizer->SetContrastFunction( this->GetContrastFunction() ); optimizer->SetCurrentBandForLoop( band ); MeanEstimatorFilterPointerType estimator = MeanEstimatorFilterType::New(); estimator->SetInput( optimizer->GetOutput() ); estimator->Update(); double norm = 0.; for ( unsigned int bd = 0; bd < size; bd++ ) { W(band, bd) -= m_Mu * ( estimator->GetMean()[bd] - optimizer->GetBeta() * W(band, bd) / optimizer->GetDen() ); norm += vcl_pow( W(band, bd), 2. ); } for ( unsigned int bd = 0; bd < size; bd++ ) W(band, bd) /= vcl_sqrt( norm ); } // Decorrelation of the W vectors InternalMatrixType W_tmp = W * W.transpose(); vnl_svd< MatrixElementType > solver ( W_tmp ); InternalMatrixType valP = solver.W(); for ( unsigned int i = 0; i < valP.rows(); ++i ) valP(i, i) = 1. / vcl_sqrt( static_cast( valP(i, i) ) ); // Watch for 0 or neg InternalMatrixType transf = solver.U(); W_tmp = transf * valP * transf.transpose(); W = W_tmp * W; // Convergence evaluation convergence = 0.; for ( unsigned int i = 0; i < W.rows(); ++i ) for ( unsigned int j = 0; j < W.cols(); ++j ) convergence += vcl_abs( W(i, j) - W_old(i, j) ); reporter.CompletedPixel(); } // end of while loop if ( size != this->GetNumberOfPrincipalComponentsRequired() ) { this->m_TransformationMatrix = W.get_n_columns( 0, this->GetNumberOfPrincipalComponentsRequired() ); } else { this->m_TransformationMatrix = W; } otbMsgDebugMacro( << "Final convergence " << convergence << " after " << iteration << " iterations" ); } } // end of namespace otb #endif otbFastICAInternalOptimizerVectorImageFilter.h000066400000000000000000000105211301006202600361450ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFastICAInternalOptimizerVectorImageFilter_h #define otbFastICAInternalOptimizerVectorImageFilter_h #include "otbMacro.h" #include "otbMatrixImageFilter.h" #include "otbStreamingStatisticsVectorImageFilter.h" namespace otb { /** \class FastICAInternalOptimizerVectorImageFilter * \brief Internal optimisation of the FastICA unmixing filter * * This class implements the internal search for the unmixing matrix W * in the FastICA technique. * * The class takes 2 inputs (initial image and its projection with the W matrix). * * \ingroup Multithreaded * \sa FastICAImageFilter * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT FastICAInternalOptimizerVectorImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef FastICAInternalOptimizerVectorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(FastICAInternalOptimizerVectorImageFilter, ImageToImageFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::RegionType InputRegionType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::RegionType OutputRegionType; /** Filter types and related */ typedef StreamingStatisticsVectorImageFilter< InputImageType > CovarianceEstimatorFilterType; typedef typename CovarianceEstimatorFilterType::Pointer CovarianceEstimatorFilterPointerType; typedef typename CovarianceEstimatorFilterType::RealType RealType; typedef typename CovarianceEstimatorFilterType::RealPixelType VectorType; typedef typename CovarianceEstimatorFilterType::MatrixObjectType MatrixObjectType; typedef typename MatrixObjectType::ComponentType MatrixType; typedef typename MatrixType::InternalMatrixType InternalMatrixType; typedef typename InternalMatrixType::element_type MatrixElementType; typedef MatrixImageFilter< TInputImage, TOutputImage > TransformFilterType; typedef typename TransformFilterType::Pointer TransformFilterPointerType; typedef double (*ContrastFunctionType) ( double ); itkSetMacro(CurrentBandForLoop, unsigned int); itkGetMacro(CurrentBandForLoop, unsigned int); itkGetMacro(W, InternalMatrixType); itkSetMacro(W, InternalMatrixType); itkSetMacro(ContrastFunction, ContrastFunctionType); itkGetMacro(Beta, double); itkGetMacro(Den, double); protected: FastICAInternalOptimizerVectorImageFilter(); ~FastICAInternalOptimizerVectorImageFilter() ITK_OVERRIDE { } void GenerateOutputInformation() ITK_OVERRIDE; void BeforeThreadedGenerateData () ITK_OVERRIDE; void ThreadedGenerateData ( const OutputRegionType &, itk::ThreadIdType ) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; unsigned int m_CurrentBandForLoop; std::vector m_BetaVector; std::vector m_DenVector; std::vector m_NbSamples; double m_Beta; double m_Den; InternalMatrixType m_W; ContrastFunctionType m_ContrastFunction; TransformFilterPointerType m_TransformFilter; private: FastICAInternalOptimizerVectorImageFilter( const Self & ); // not implemented void operator= ( const Self & ); // not implemented }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFastICAInternalOptimizerVectorImageFilter.txx" #endif #endif otbFastICAInternalOptimizerVectorImageFilter.txx000066400000000000000000000076551301006202600365570ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFastICAInternalOptimizerVectorImageFilter_txx #define otbFastICAInternalOptimizerVectorImageFilter_txx #include "otbFastICAInternalOptimizerVectorImageFilter.h" #include #include #include #include namespace otb { template FastICAInternalOptimizerVectorImageFilter< TInputImage, TOutputImage > ::FastICAInternalOptimizerVectorImageFilter() { this->SetNumberOfRequiredInputs(2); m_CurrentBandForLoop = 0; m_Beta = 0.; m_Den = 0.; m_ContrastFunction = &vcl_tanh; m_TransformFilter = TransformFilterType::New(); } template void FastICAInternalOptimizerVectorImageFilter< TInputImage, TOutputImage > ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput(0)->GetNumberOfComponentsPerPixel() ); } template void FastICAInternalOptimizerVectorImageFilter< TInputImage, TOutputImage > ::BeforeThreadedGenerateData () { if ( m_W.empty() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Give the initial W matrix", ITK_LOCATION ); } m_BetaVector.resize( this->GetNumberOfThreads() ); m_DenVector.resize( this->GetNumberOfThreads() ); m_NbSamples.resize( this->GetNumberOfThreads() ); } template void FastICAInternalOptimizerVectorImageFilter< TInputImage, TOutputImage > ::ThreadedGenerateData ( const OutputRegionType & outputRegionForThread, itk::ThreadIdType threadId ) { InputRegionType inputRegion; this->CallCopyOutputRegionToInputRegion( inputRegion, outputRegionForThread ); itk::ImageRegionConstIterator< InputImageType > input0It ( this->GetInput(0), inputRegion ); itk::ImageRegionConstIterator< InputImageType > input1It ( this->GetInput(1), inputRegion ); itk::ImageRegionIterator< OutputImageType > outputIt ( this->GetOutput(), outputRegionForThread ); unsigned int nbBands = this->GetInput(0)->GetNumberOfComponentsPerPixel(); input0It.GoToBegin(); input1It.GoToBegin(); outputIt.GoToBegin(); double beta = 0.; double den = 0.; double nbSample = 0.; while ( !input0It.IsAtEnd() && !input1It.IsAtEnd() && !outputIt.IsAtEnd() ) { double x = static_cast( input1It.Get()[GetCurrentBandForLoop()] ); double g_x = (*m_ContrastFunction)(x); double x_g_x = x * g_x; beta += x_g_x; double gp = 1. - vcl_pow( g_x, 2. ); den += gp; nbSample += 1.; typename OutputImageType::PixelType z ( nbBands ); for ( unsigned int bd = 0; bd < nbBands; bd++ ) z[bd] = g_x * input0It.Get()[bd]; outputIt.Set(z); ++input0It; ++input1It; ++outputIt; } // end while loop m_BetaVector[threadId] = beta; m_DenVector[threadId] = den; m_NbSamples[threadId] = nbSample; } template void FastICAInternalOptimizerVectorImageFilter< TInputImage, TOutputImage > ::AfterThreadedGenerateData () { double beta = 0; double den = 0.; double nbSample = 0; for ( itk::ThreadIdType i = 0; i < this->GetNumberOfThreads(); ++i ) { beta += m_BetaVector[i]; den += m_DenVector[i]; nbSample += m_NbSamples[i]; } m_Beta = beta / nbSample; m_Den = den / nbSample - m_Beta; } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbInnerProductPCAImageFilter.h000066400000000000000000000161651301006202600332010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbInnerProductPCAImageFilter_h #define otbInnerProductPCAImageFilter_h #include "otbImage.h" #include "otbMacro.h" #include "otbEstimateInnerProductPCAImageFilter.h" #include "otbNormalizeInnerProductPCAImageFilter.h" #include "otbMeanFunctor.h" #include "otbImageToVectorImageCastFilter.h" #include "otbConcatenateVectorImageFilter.h" #include "otbImageToVectorImageCastFilter.h" namespace otb { /** \class InnerProductPCAImageFilter * \brief Performs a PCA with streaming capabilities * * InnerProductPCAImageFilter performs a principal component analysis (as * itk::ImagePCAShapeModelEstimator) (PCA) on a vector image in streaming capabilities. * Alls channels of the input vector image are used for training images * and also the number of desired largest principal components needed. * The number of channels of the output image are the user specified number of desired * largest principal components. * * The algorithm uses the VNL library to perform the eigen analysis. To speed * the computation of the instead of performing the eigen analysis of the * covariance vector A*A' where A is a matrix with p x t, p = number of * pixels or voxels in each images and t = number of training images, we * calculate the eigen vectors of the inner product matrix A'*A. The resulting * eigen vectors (E) are then multiplied with the the matrix A to get the * principal compoenets. The covariance matrix has a dimension of p x p. Since * number of pixels in any image being typically very high the eigen * decomposition becomes computationally expensive. The inner product on the * other hand has the dimension of t x t, where t is typically much smaller * that p. Hence the eigen decomposition (most compute intensive part) is an * orders of magnitude faster. * * The Update() function enables the calculation of the various models, creates * the membership function objects and populates them. * * \sa itk::ImagePCAShapeModelEstimator * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT InnerProductPCAImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef InnerProductPCAImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(InnerProductPCAImageFilter, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef EstimateInnerProductPCAImageFilter EstimatePCAFilterType; typedef typename EstimatePCAFilterType::Pointer EstimatePCAFilterPointer; typedef NormalizeInnerProductPCAImageFilter NormalizePCAFilterType; typedef typename NormalizePCAFilterType::Pointer NormalizePCAFilterPointer; /** Template parameters typedefs for mean component generation */ typedef Image InternalImageType; typedef Functor::MeanFunctor MeanFunctorType; typedef itk::UnaryFunctorImageFilter MeanFilterType; typedef typename MeanFilterType::Pointer MeanFilterPointer; typedef ImageToVectorImageCastFilter CastFilterType; typedef typename CastFilterType::Pointer CastFilterPointer; typedef ConcatenateVectorImageFilter ConcatenateFilterType; typedef typename ConcatenateFilterType::Pointer ConcatenateFilterPointer; /** Set/Get the number of required largest principal components. The filter produces the required number of principal components plus one outputs. Output index 0 represents the mean image and the remaining outputs the requested principal components.*/ itkSetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkGetMacro(NumberOfPrincipalComponentsRequired, unsigned int); /** Enable/Disable the generation of the mean component output */ itkSetMacro(GenerateMeanComponent, bool); itkGetMacro(GenerateMeanComponent, bool); itkBooleanMacro(GenerateMeanComponent); /** Enable/Disable center data */ itkSetMacro(CenterData, bool); itkGetMacro(CenterData, bool); itkBooleanMacro(CenterData); /** Get the NormalizeInnerProductPCAImage filter */ otbSetObjectMemberMacro(NormalizePCAFilter, UseUnbiasedEstimator, bool); otbGetObjectMemberMacro(NormalizePCAFilter, UseUnbiasedEstimator, bool); protected: /** GenerateData */ void GenerateData(void) ITK_OVERRIDE; /** Constructor */ InnerProductPCAImageFilter(); /** Destructor */ ~InnerProductPCAImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** NormalizeInnerProductPCAImageFilter can produce an image which is a different * resolution than its input image. As such, NormalizeInnerProductPCAImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; private: InnerProductPCAImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The number of largest principal components */ unsigned int m_NumberOfPrincipalComponentsRequired; /** Radius of the structuring element */ EstimatePCAFilterPointer m_EstimatePCAFilter; /** Opening filter */ NormalizePCAFilterPointer m_NormalizePCAFilter; /** Enable/Disable center data */ bool m_CenterData; /** Flag to specify the generation or not of the mean component output */ bool m_GenerateMeanComponent; /** Internals filters use to generate mean component output */ MeanFilterPointer m_MeanFilter; CastFilterPointer m_CastFilter; ConcatenateFilterPointer m_ConcatenateFilter; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbInnerProductPCAImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbInnerProductPCAImageFilter.txx000066400000000000000000000060351301006202600335700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbInnerProductPCAImageFilter_txx #define otbInnerProductPCAImageFilter_txx #include "otbInnerProductPCAImageFilter.h" namespace otb { /** * Constructor */ template InnerProductPCAImageFilter ::InnerProductPCAImageFilter() { this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageType::New()); m_EstimatePCAFilter = EstimatePCAFilterType::New(); m_NormalizePCAFilter = NormalizePCAFilterType::New(); m_CenterData = true; m_GenerateMeanComponent = false; m_MeanFilter = MeanFilterType::New(); m_CastFilter = CastFilterType::New(); m_ConcatenateFilter = ConcatenateFilterType::New(); } /** * GenerateOutputInformation */ template void InnerProductPCAImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); if (m_GenerateMeanComponent == false) this->GetOutput()->SetNumberOfComponentsPerPixel( m_NumberOfPrincipalComponentsRequired); else this->GetOutput()->SetNumberOfComponentsPerPixel(m_NumberOfPrincipalComponentsRequired + 1); } /** * Main computation method */ template void InnerProductPCAImageFilter ::GenerateData() { m_EstimatePCAFilter->SetInput(this->GetInput()); m_EstimatePCAFilter->SetNumberOfPrincipalComponentsRequired(m_NumberOfPrincipalComponentsRequired); m_EstimatePCAFilter->SetCenterData(m_CenterData); m_NormalizePCAFilter->SetInput(m_EstimatePCAFilter->GetOutput()); if ((m_CenterData == false) || ((m_CenterData == true) && (m_GenerateMeanComponent == false))) { m_NormalizePCAFilter->GraftOutput(this->GetOutput()); m_NormalizePCAFilter->Update(); this->GraftOutput(m_NormalizePCAFilter->GetOutput()); } else { m_MeanFilter->SetInput(this->GetInput()); m_CastFilter->SetInput(m_MeanFilter->GetOutput()); m_ConcatenateFilter->SetInput1(m_NormalizePCAFilter->GetOutput()); m_ConcatenateFilter->SetInput2(m_CastFilter->GetOutput()); m_ConcatenateFilter->GraftOutput(this->GetOutput()); m_ConcatenateFilter->Update(); this->GraftOutput(m_ConcatenateFilter->GetOutput()); } } /** * PrintSelf Method */ template void InnerProductPCAImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbLocalActivityVectorImageFilter.h000066400000000000000000000066671301006202600341220ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalActivityVectorImageFilter_h #define otbLocalActivityVectorImageFilter_h #include "otbUnaryFunctorNeighborhoodVectorImageFilter.h" #include namespace otb { namespace Functor { /** \class LocalActivityOperator * \brief Performs the calculation of LocalActivity derivation * * \ingroup OTBDimensionalityReduction */ template < class TInput, class TOutput > class LocalActivityOperator { public: LocalActivityOperator() { } virtual ~LocalActivityOperator() { } TOutput operator() ( const TInput & input ) { /* * it is assumed that input and output have the same size */ typename TInput::PixelType centerPixel = input.GetCenterPixel(); unsigned int neighborSize = input.Size(); unsigned int vectorSize = centerPixel.Size(); if ( neighborSize == 1 ) return centerPixel; TOutput output ( vectorSize ); for ( unsigned int i = 0; i < vectorSize; ++i ) { typename TOutput::ValueType out = itk::NumericTraits< typename TOutput::ValueType >::Zero; for ( unsigned int j = 0; j < neighborSize/2; ++j ) { out += input.GetPixel(j)[i]; } for ( unsigned int j = neighborSize/2+1; j < neighborSize; ++j ) { out += input.GetPixel(j)[i]; } output[i] = centerPixel[i] - out / static_cast( neighborSize-1 ); } return output; } }; // end of functor class } // end of namespace Functor /** \class LocalActivityVectorImageFilter * \brief Implements the LocalActivity Gradient to be processed on a vector image * * \ingroup OTBDimensionalityReduction */ template < class TInputImage, class TOutputImage > class ITK_EXPORT LocalActivityVectorImageFilter : public UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::LocalActivityOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > { public: /** Standard class typedefs */ typedef LocalActivityVectorImageFilter Self; typedef UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::LocalActivityOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(LocalActivityVectorImageFilter, ImageToImageFilter); protected: LocalActivityVectorImageFilter() { } ~LocalActivityVectorImageFilter() ITK_OVERRIDE { } private: LocalActivityVectorImageFilter( const Self & ); // Not implemented void operator=( const Self & ); // Not implemented }; // end of class } // end of namespace otb #endif // otbLocalActivityVectorImageFilter_h OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbMNFImageFilter.h000066400000000000000000000160131301006202600306510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMNFImageFilter_h #define otbMNFImageFilter_h #include "otbPCAImageFilter.h" namespace otb { /** \class MNFImageFilter * \brief Performs a Maximum Noise Fraction analysis of a vector image. * * The internal structure of this filter is a filter-to-filter like structure. * The estimation of the covariance matrix is streamed * * The high pass filter which has to be used for the noise estimation is templated * for a better scalability. * * TODO? Utiliser une 2e entree pour donner directement une image de bruit ? * * \sa otbStreamingStatisticsVectorImageFilter * \sa PCAImageFiler * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT MNFImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef MNFImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(MNFImageFilter, ImageToImageFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef Transform::TransformDirection TransformDirectionEnumType; itkStaticConstMacro(DirectionOfTransformation, TransformDirectionEnumType, TDirectionOfTransformation); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Filter types and related */ typedef StreamingStatisticsVectorImageFilter< InputImageType > CovarianceEstimatorFilterType; typedef typename CovarianceEstimatorFilterType::Pointer CovarianceEstimatorFilterPointerType; typedef typename CovarianceEstimatorFilterType::RealType RealType; typedef typename CovarianceEstimatorFilterType::RealPixelType VectorType; typedef typename CovarianceEstimatorFilterType::MatrixObjectType MatrixObjectType; typedef typename MatrixObjectType::ComponentType MatrixType; typedef typename MatrixType::InternalMatrixType InternalMatrixType; typedef typename InternalMatrixType::element_type MatrixElementType; typedef MatrixImageFilter< InputImageType, OutputImageType > TransformFilterType; typedef typename TransformFilterType::Pointer TransformFilterPointerType; typedef TNoiseImageFilter NoiseImageFilterType; typedef typename NoiseImageFilterType::Pointer NoiseImageFilterPointerType; typedef NormalizeVectorImageFilter< InputImageType, OutputImageType > NormalizeFilterType; typedef typename NormalizeFilterType::Pointer NormalizeFilterPointerType; /** * Set/Get the number of required largest principal components. */ itkGetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkSetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkGetConstMacro(Normalizer, NormalizeFilterType*); itkGetMacro(Normalizer, NormalizeFilterType*); itkGetMacro(NoiseCovarianceEstimator, CovarianceEstimatorFilterType *); itkGetMacro(Transformer, TransformFilterType *); itkGetMacro(NoiseImageFilter, NoiseImageFilterType *); /** Normalization only impact the use of variance. The data is always centered */ itkGetMacro(UseNormalization, bool); itkSetMacro(UseNormalization, bool); itkGetConstMacro(MeanValues, VectorType); void SetMeanValues ( const VectorType & vec ) { m_MeanValues = vec; m_GivenMeanValues = true; } itkGetConstMacro(StdDevValues, VectorType); void SetStdDevValues ( const VectorType & vec ) { m_StdDevValues = vec; m_UseNormalization = true; m_GivenStdDevValues = true; } itkGetConstMacro(CovarianceMatrix, MatrixType); void SetCovarianceMatrix ( const MatrixType & cov ) { m_CovarianceMatrix = cov; m_GivenCovarianceMatrix = true; } itkGetConstMacro(NoiseCovarianceMatrix, MatrixType); void SetNoiseCovarianceMatrix ( const MatrixType & mat ) { m_NoiseCovarianceMatrix = mat; m_GivenNoiseCovarianceMatrix = true; } itkGetConstMacro(TransformationMatrix, MatrixType); void SetTransformationMatrix( const MatrixType & transf, bool isForward = true ) { m_TransformationMatrix = transf; m_GivenTransformationMatrix = true; m_IsTransformationMatrixForward = isForward; } itkGetConstMacro(EigenValues, VectorType); protected: MNFImageFilter(); ~MNFImageFilter() ITK_OVERRIDE { } /** GenerateOutputInformation * Propagate vector length info and modify if needed * NumberOfPrincipalComponentsRequired * * In REVERSE mode, the covariance matrix or the transformation matrix * (which may not be square) has to be given, * otherwize, GenerateOutputInformation throws an itk::ExceptionObject */ void GenerateOutputInformation() ITK_OVERRIDE; /** GenerateData * Through a filter of filter structure */ void GenerateData () ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Internal methods */ void ForwardGenerateOutputInformation(); void ReverseGenerateOutputInformation(); virtual void ForwardGenerateData(); virtual void ReverseGenerateData(); /** Specific functionality of MNF */ virtual void GenerateTransformationMatrix(); /** Internal attributes */ unsigned int m_NumberOfPrincipalComponentsRequired; bool m_UseNormalization; bool m_GivenMeanValues; bool m_GivenStdDevValues; bool m_GivenCovarianceMatrix; bool m_GivenNoiseCovarianceMatrix; bool m_GivenTransformationMatrix; bool m_IsTransformationMatrixForward; VectorType m_MeanValues; VectorType m_StdDevValues; MatrixType m_CovarianceMatrix; MatrixType m_NoiseCovarianceMatrix; MatrixType m_TransformationMatrix; VectorType m_EigenValues; NormalizeFilterPointerType m_Normalizer; NoiseImageFilterPointerType m_NoiseImageFilter; CovarianceEstimatorFilterPointerType m_CovarianceEstimator; CovarianceEstimatorFilterPointerType m_NoiseCovarianceEstimator; TransformFilterPointerType m_Transformer; private: MNFImageFilter( const Self & ); // not implemented void operator=( const Self & ); // not implemented }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMNFImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbMNFImageFilter.txx000066400000000000000000000363141301006202600312530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMNFImageFilter_txx #define otbMNFImageFilter_txx #include "otbMNFImageFilter.h" #include "itkMacro.h" #include #include #include #include #include namespace otb { template MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::MNFImageFilter () { this->SetNumberOfRequiredInputs(1); m_NumberOfPrincipalComponentsRequired = 0; m_UseNormalization = false; m_GivenMeanValues = false; m_GivenStdDevValues = false; m_GivenCovarianceMatrix = false; m_GivenNoiseCovarianceMatrix = false; m_GivenTransformationMatrix = false; m_IsTransformationMatrixForward = true; m_Normalizer = NormalizeFilterType::New(); m_NoiseImageFilter = NoiseImageFilterType::New(); m_CovarianceEstimator = CovarianceEstimatorFilterType::New(); m_NoiseCovarianceEstimator = CovarianceEstimatorFilterType::New(); m_Transformer = TransformFilterType::New(); m_Transformer->MatrixByVectorOn(); } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::GenerateOutputInformation() // throw itk::ExceptionObject { Superclass::GenerateOutputInformation(); switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): { if ( m_NumberOfPrincipalComponentsRequired == 0 || m_NumberOfPrincipalComponentsRequired > this->GetInput()->GetNumberOfComponentsPerPixel() ) { m_NumberOfPrincipalComponentsRequired = this->GetInput()->GetNumberOfComponentsPerPixel(); } this->GetOutput()->SetNumberOfComponentsPerPixel( m_NumberOfPrincipalComponentsRequired ); break; } case static_cast(Transform::INVERSE): { unsigned int theOutputDimension = 0; if ( m_GivenTransformationMatrix ) { theOutputDimension = m_TransformationMatrix.Rows() >= m_TransformationMatrix.Cols() ? m_TransformationMatrix.Rows() : m_TransformationMatrix.Cols(); } else if ( m_GivenCovarianceMatrix ) { theOutputDimension = m_CovarianceMatrix.Rows() >= m_CovarianceMatrix.Cols() ? m_CovarianceMatrix.Rows() : m_CovarianceMatrix.Cols(); } else { throw itk::ExceptionObject(__FILE__, __LINE__, "Covariance or transformation matrix required to know the output size", ITK_LOCATION); } m_NumberOfPrincipalComponentsRequired = 0; this->GetOutput()->SetNumberOfComponentsPerPixel( theOutputDimension ); break; } default: // should not go so far... throw itk::ExceptionObject(__FILE__, __LINE__, "Class should be templeted with FORWARD or INVERSE only...", ITK_LOCATION ); } switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): { ForwardGenerateOutputInformation(); break; } case static_cast(Transform::INVERSE): { ReverseGenerateOutputInformation(); break; } } } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::ForwardGenerateOutputInformation() { typename InputImageType::Pointer inputImgPtr = const_cast( this->GetInput() ); if ( m_GivenMeanValues ) m_Normalizer->SetMean( this->GetMeanValues() ); if ( m_UseNormalization ) { m_Normalizer->SetUseStdDev( true ); if ( m_GivenStdDevValues ) m_Normalizer->SetStdDev( this->GetStdDevValues() ); } else m_Normalizer->SetUseStdDev( false ); m_Normalizer->SetInput( inputImgPtr ); m_Normalizer->GetOutput()->UpdateOutputInformation(); if ( !m_GivenMeanValues ) m_MeanValues = m_Normalizer->GetCovarianceEstimator()->GetMean(); if ( m_UseNormalization ) { if ( !m_GivenStdDevValues ) m_StdDevValues = m_Normalizer->GetFunctor().GetStdDev(); } if ( !m_GivenTransformationMatrix ) { if ( !m_GivenNoiseCovarianceMatrix ) { m_NoiseImageFilter->SetInput( m_Normalizer->GetOutput() ); m_NoiseCovarianceEstimator->SetInput( m_NoiseImageFilter->GetOutput() ); m_NoiseCovarianceEstimator->Update(); m_NoiseCovarianceMatrix = m_NoiseCovarianceEstimator->GetCovariance(); } if ( !m_GivenCovarianceMatrix ) { m_CovarianceEstimator->SetInput( m_Normalizer->GetOutput() ); m_CovarianceEstimator->Update(); m_CovarianceMatrix = m_CovarianceEstimator->GetCovariance(); } GenerateTransformationMatrix(); } else if ( !m_IsTransformationMatrixForward ) { // Prevents from multiple transpose in pipeline m_IsTransformationMatrixForward = true; if ( m_TransformationMatrix.Rows() == m_TransformationMatrix.Cols() ) { m_TransformationMatrix = m_TransformationMatrix.GetInverse(); } else { vnl_svd< MatrixElementType > invertor ( m_TransformationMatrix.GetVnlMatrix() ); m_TransformationMatrix = invertor.pinverse(); } } if ( m_TransformationMatrix.GetVnlMatrix().empty() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Empty transformation matrix", ITK_LOCATION); } m_Transformer->SetInput( m_Normalizer->GetOutput() ); m_Transformer->SetMatrix( m_TransformationMatrix.GetVnlMatrix() ); } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::ReverseGenerateOutputInformation() { if ( !m_GivenTransformationMatrix ) { if ( !m_GivenCovarianceMatrix ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Inverse Transformation or at least Covariance matrix is required to invert MNF", ITK_LOCATION ); } if ( !m_GivenNoiseCovarianceMatrix ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Inverse Transformation or at least Noise Covariance matrix is required to invert MNF", ITK_LOCATION ); } GenerateTransformationMatrix(); m_IsTransformationMatrixForward = false; if ( m_TransformationMatrix.Rows() == m_TransformationMatrix.Cols() ) m_TransformationMatrix = vnl_matrix_inverse< MatrixElementType > ( m_TransformationMatrix.GetVnlMatrix() ); else { vnl_svd< MatrixElementType > invertor ( m_TransformationMatrix.GetVnlMatrix() ); m_TransformationMatrix = invertor.inverse(); } } else if ( m_IsTransformationMatrixForward ) { // Prevent from multiple transpose in pipeline m_IsTransformationMatrixForward = false; if ( m_TransformationMatrix.Rows() == m_TransformationMatrix.Cols() ) { m_TransformationMatrix = vnl_matrix_inverse< MatrixElementType > ( m_TransformationMatrix.GetVnlMatrix() ); } else { vnl_svd< MatrixElementType > invertor ( m_TransformationMatrix.GetVnlMatrix() ); m_TransformationMatrix = invertor.pinverse(); } } if ( m_TransformationMatrix.GetVnlMatrix().empty() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Empty transformation matrix", ITK_LOCATION); } m_Transformer->SetInput( this->GetInput() ); m_Transformer->SetMatrix( m_TransformationMatrix.GetVnlMatrix() ); if ( !m_GivenMeanValues ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Initial means required for correct data centering", ITK_LOCATION ); } if ( m_UseNormalization ) { if ( !m_GivenStdDevValues ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Initial StdDevs required for de-normalization", ITK_LOCATION ); } VectorType revStdDev ( m_StdDevValues.Size() ); for ( unsigned int i = 0; i < m_StdDevValues.Size(); ++i ) revStdDev[i] = 1. / m_StdDevValues[i]; m_Normalizer->SetStdDev( revStdDev ); VectorType revMean ( m_MeanValues.Size() ); for ( unsigned int i = 0; i < m_MeanValues.Size(); ++i ) revMean[i] = - m_MeanValues[i] / m_StdDevValues[i]; m_Normalizer->SetMean( revMean ); } else { VectorType revMean ( m_MeanValues.Size() ); for ( unsigned int i = 0; i < m_MeanValues.Size(); ++i ) revMean[i] = - m_MeanValues[i]; m_Normalizer->SetMean( revMean ); m_Normalizer->SetUseStdDev( false ); } m_Normalizer->SetInput( m_Transformer->GetOutput() ); } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::GenerateData () { switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): return ForwardGenerateData(); case static_cast(Transform::INVERSE): return ReverseGenerateData(); default: // should not go so far throw itk::ExceptionObject(__FILE__, __LINE__, "Class should be templated with FORWARD or INVERSE only...", ITK_LOCATION ); } } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::ForwardGenerateData () { m_Transformer->GraftOutput( this->GetOutput() ); m_Transformer->Update(); this->GraftOutput( m_Transformer->GetOutput() ); } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::ReverseGenerateData () { m_Normalizer->GraftOutput( this->GetOutput() ); m_Normalizer->Update(); this->GraftOutput( m_Normalizer->GetOutput() ); } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::GenerateTransformationMatrix () { vnl_cholesky choleskySolver ( m_NoiseCovarianceMatrix.GetVnlMatrix(), vnl_cholesky::estimate_condition ); InternalMatrixType Rn = choleskySolver.lower_triangle(); InternalMatrixType Rn_inv = vnl_matrix_inverse< MatrixElementType > ( Rn.transpose() ); InternalMatrixType C = Rn_inv.transpose() * m_CovarianceMatrix.GetVnlMatrix() * Rn_inv; vnl_svd< MatrixElementType > solver ( C ); InternalMatrixType U = solver.U(); InternalMatrixType valP = solver.W(); InternalMatrixType transf = Rn_inv * U; #if 0 InternalMatrixType Ax = m_CovarianceMatrix.GetVnlMatrix(); InternalMatrixType Ax_inv = vnl_matrix_inverse< MatrixElementType > ( Ax ); InternalMatrixType An = m_NoiseCovarianceMatrix.GetVnlMatrix(); InternalMatrixType W = An * Ax_inv; #endif #if 0 InternalMatrixType transf; vnl_vector< MatrixElementType > vectValP; vnl_symmetric_eigensystem_compute( W, transf, vectValP ); InternalMatrixType valP ( vectValP.size(), vectValP.size(), vnl_matrix_null ); for ( unsigned int i = 0; i < vectValP.size(); ++i ) valP(i, i) = vectValP[i]; #endif #if 0 vnl_svd< MatrixElementType > solver ( W ); InternalMatrixType transf = solver.U(); InternalMatrixType valP = solver.W(); #endif #if 0 MatrixType Id ( m_CovarianceMatrix ); Id.SetIdentity(); vnl_generalized_eigensystem solver ( W, Id.GetVnlMatrix() ); InternalMatrixType transf = solver.V; transf.fliplr(); InternalMatrixType valP = solver.D; valP.fliplr(); valP.flipud(); #endif /* InternalMatrixType normMat = transf.transpose() * Ax * transf; for ( unsigned int i = 0; i < transf.rows(); ++i ) { double norm = 1. / vcl_sqrt( normMat.get(i, i) ); for ( unsigned int j = 0; j < transf.cols(); ++j ) transf.put( j, i, transf.get(j, i) * norm ); } */ transf.inplace_transpose(); if ( m_NumberOfPrincipalComponentsRequired != this->GetInput()->GetNumberOfComponentsPerPixel() ) m_TransformationMatrix = transf.get_n_rows( 0, m_NumberOfPrincipalComponentsRequired ); else m_TransformationMatrix = transf; m_EigenValues.SetSize( m_NumberOfPrincipalComponentsRequired ); for ( unsigned int i = 0; i < m_NumberOfPrincipalComponentsRequired; ++i ) m_EigenValues[i] = static_cast< RealType >( valP(i, i) ); } template void MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::PrintSelf ( std::ostream& os, itk::Indent indent ) const { Superclass::PrintSelf( os, indent ); if ( m_UseNormalization ) { os << indent << "Normalisation with :\n" << indent << "Mean: "; for ( unsigned int i = 0; i < m_MeanValues.Size(); ++i ) os << m_MeanValues[i] << " "; os << "\n" << indent << "StdDev: "; for ( unsigned int i = 0; i < m_StdDevValues.Size(); ++i ) os << m_StdDevValues[i] << " "; os << "\n"; } else os << indent << "No normalisation\n"; if ( !m_NoiseCovarianceMatrix.GetVnlMatrix().empty() ) { os << indent << "Noise Covariance matrix"; if ( m_GivenNoiseCovarianceMatrix ) os << " (given)"; os << "\n"; m_NoiseCovarianceMatrix.GetVnlMatrix().print(os); } if ( !m_CovarianceMatrix.GetVnlMatrix().empty() ) { os << indent << "Covariance matrix"; if ( m_GivenCovarianceMatrix ) os << " (given)"; os << "\n"; m_CovarianceMatrix.GetVnlMatrix().print(os); } if ( !m_TransformationMatrix.GetVnlMatrix().empty() ) { os << indent << "Transformation matrix"; if ( m_GivenTransformationMatrix ) os << " (given)"; os << "\n"; m_TransformationMatrix.GetVnlMatrix().print(os); } if ( m_EigenValues.Size() > 0 ) { os << indent << "RMS value :"; for ( unsigned int i = 0; i < m_EigenValues.Size(); ++i ) os << " " << m_EigenValues[i]; os << "\n"; } } } // end of namespace otb #endif // otbMNFImageFilter_txx otbMaximumAutocorrelationFactorImageFilter.h000066400000000000000000000155571301006202600360350ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaximumAutocorrelationFactorImageFilter_h #define otbMaximumAutocorrelationFactorImageFilter_h #include "otbStreamingStatisticsVectorImageFilter.h" #include "otbConcatenateVectorImageFilter.h" #include "itkNumericTraits.h" #include "vnl/vnl_vector.h" #include "vnl/vnl_matrix.h" namespace otb { /** \class MaximumAutocorrelationFactorImageFilter * \brief This filter implements the Maximum Autocorrelation Factor * * This filter implements the Maximum Autocorrelation Factor, based * on the following work: * * A. A. Nielsen, "Kernel maximum autocorrelation factor and minimum * noise fraction transformations," IEEE Transactions on Image * Processing, vol. 20, no. 3, pp. 612-624, (2011) * * Maximum Autocorrelation Factor can be considered as a spatial * extension of the PCA, in which new variates try to maximize * auto-correlation between neighboring pixels instead of * variance. Though the inverse transform can be computed, this filter * only provides the forward transform for now. * * The GetV() method allows retrieving the linear combinations used * to generate new variates, and the GetAutoCorrelation() method * allows retrieving the auto-correlation associated to each variate. * * This filter has been implemented from the Matlab code kindly made * available by the authors here: * http://www2.imm.dtu.dk/~aa/software.html * * this filter have been validated by comparing the output image to * the output produced by the Matlab code, and the reference image * for testing has been generated from the Matlab code using Octave. * \ingroup Multithreaded, Streamed * \sa otbPCAImageFilter * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT MaximumAutocorrelationFactorImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef MaximumAutocorrelationFactorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MaximumAutocorrelationFactorImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageRegionType::SizeType InputImageSizeType; typedef typename InputImageRegionType::IndexType InputImageIndexType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::ValueType InputImageValueType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename itk::NumericTraits::RealType InternalPixelType; typedef VectorImage InternalImageType; /** Internal filters types */ typedef StreamingStatisticsVectorImageFilter CovarianceEstimatorType; typedef typename CovarianceEstimatorType::Pointer CovarianceEstimatorPointer; typedef typename CovarianceEstimatorType::MatrixObjectType MatrixObjectType; typedef typename MatrixObjectType::ComponentType MatrixType; typedef typename MatrixType::InternalMatrixType InternalMatrixType; typedef typename CovarianceEstimatorType::RealPixelType VectorType; typedef typename VectorType::ValueType RealType; typedef vnl_vector VnlVectorType; typedef vnl_matrix VnlMatrixType; /** Get the linear combination used to compute Maf */ itkGetMacro(V, VnlMatrixType); /** Get the auto-correlation associated with each Maf */ itkGetMacro(AutoCorrelation, VnlVectorType); /** Get the covariance estimator for image (use for progress * reporting purposes) */ itkGetObjectMacro(CovarianceEstimator, CovarianceEstimatorType); /** Get the covariance estimator for horizontal autocorrelation (use * for progress reporting purposes) */ itkGetObjectMacro(CovarianceEstimatorH, CovarianceEstimatorType); /** Get the covariance estimator for vertical autocorrelation (use * for progress reporting purposes) */ itkGetObjectMacro(CovarianceEstimatorV, CovarianceEstimatorType); protected: MaximumAutocorrelationFactorImageFilter(); ~MaximumAutocorrelationFactorImageFilter() ITK_OVERRIDE {} void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; private: MaximumAutocorrelationFactorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The covariance estimator for the image */ CovarianceEstimatorPointer m_CovarianceEstimator; /** The covariance estimator for auto-correlation in horizontal * direction */ CovarianceEstimatorPointer m_CovarianceEstimatorH; /** The covariance estimator for auto-correlation in vertical * direction */ CovarianceEstimatorPointer m_CovarianceEstimatorV; /** The linear combination for Maf */ VnlMatrixType m_V; /** The mean used to center data before computing Maf */ VnlVectorType m_Mean; /** The auto-correlation associated with each Maf */ VnlVectorType m_AutoCorrelation; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMaximumAutocorrelationFactorImageFilter.txx" #endif #endif otbMaximumAutocorrelationFactorImageFilter.txx000066400000000000000000000167601301006202600364260ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaximumAutocorrelationFactorImageFilter_txx #define otbMaximumAutocorrelationFactorImageFilter_txx #include "otbMaximumAutocorrelationFactorImageFilter.h" #include "otbMultiChannelExtractROI.h" #include "otbMath.h" #include "itkSubtractImageFilter.h" #include "vnl/algo/vnl_matrix_inverse.h" #include "vnl/algo/vnl_generalized_eigensystem.h" #include "itkChangeInformationImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template MaximumAutocorrelationFactorImageFilter ::MaximumAutocorrelationFactorImageFilter() { m_CovarianceEstimator = CovarianceEstimatorType::New(); m_CovarianceEstimatorH = CovarianceEstimatorType::New(); m_CovarianceEstimatorV = CovarianceEstimatorType::New(); } template void MaximumAutocorrelationFactorImageFilter ::GenerateOutputInformation() { // Call superclass implementation Superclass::GenerateOutputInformation(); // Retrieve input images pointers TInputImage * inputPtr = const_cast(this->GetInput()); //TOutputImage * outputPtr = this->GetOutput(); // TODO: set the number of output components unsigned int nbComp = inputPtr->GetNumberOfComponentsPerPixel(); // Compute Dh and Dv typedef otb::MultiChannelExtractROI ExtractFilterType; typedef itk::SubtractImageFilter DifferenceFilterType; typedef itk::ChangeInformationImageFilter ChangeInformationImageFilter; InputImageRegionType largestInputRegion = inputPtr->GetLargestPossibleRegion(); InputImageRegionType referenceRegion; InputImageSizeType size = largestInputRegion.GetSize(); size[0] -= 1; size[1] -= 1; referenceRegion.SetSize(size); InputImageIndexType index = largestInputRegion.GetIndex(); referenceRegion.SetIndex(index); InputImageRegionType dhRegion; InputImageRegionType dvRegion; index[0] += 1; dhRegion.SetSize(size); dhRegion.SetIndex(index); index[0] -= 1; index[1] += 1; dvRegion.SetSize(size); dvRegion.SetIndex(index); typename ExtractFilterType::Pointer referenceExtract = ExtractFilterType::New(); referenceExtract->SetInput(inputPtr); referenceExtract->SetExtractionRegion(referenceRegion); typename ExtractFilterType::Pointer dhExtract = ExtractFilterType::New(); dhExtract->SetInput(inputPtr); dhExtract->SetExtractionRegion(dhRegion); typename ChangeInformationImageFilter::Pointer dhExtractShift = ChangeInformationImageFilter::New(); dhExtractShift->SetInput(dhExtract->GetOutput()); dhExtractShift->SetReferenceImage(referenceExtract->GetOutput()); dhExtractShift->SetUseReferenceImage(true); dhExtractShift->SetChangeOrigin(true); typename ExtractFilterType::Pointer dvExtract = ExtractFilterType::New(); dvExtract->SetInput(inputPtr); dvExtract->SetExtractionRegion(dvRegion); typename ChangeInformationImageFilter::Pointer dvExtractShift = ChangeInformationImageFilter::New(); dvExtractShift->SetInput(dvExtract->GetOutput()); dvExtractShift->SetReferenceImage(referenceExtract->GetOutput()); dvExtractShift->SetUseReferenceImage(true); dvExtractShift->SetChangeOrigin(true); typename DifferenceFilterType::Pointer diffh = DifferenceFilterType::New(); diffh->SetInput1(referenceExtract->GetOutput()); diffh->SetInput2(dhExtractShift->GetOutput()); typename DifferenceFilterType::Pointer diffv = DifferenceFilterType::New(); diffv->SetInput1(referenceExtract->GetOutput()); diffv->SetInput2(dvExtractShift->GetOutput()); //Compute pooled sigma (using sigmadh and sigmadv) m_CovarianceEstimatorH->SetInput(diffh->GetOutput()); m_CovarianceEstimatorH->Update(); VnlMatrixType sigmadh = m_CovarianceEstimatorH->GetCovariance().GetVnlMatrix(); m_CovarianceEstimatorV->SetInput(diffv->GetOutput()); m_CovarianceEstimatorV->Update(); VnlMatrixType sigmadv = m_CovarianceEstimatorV->GetCovariance().GetVnlMatrix(); // Simple pool VnlMatrixType sigmad = 0.5*(sigmadh+sigmadv); // Compute the original image covariance referenceExtract->SetExtractionRegion(inputPtr->GetLargestPossibleRegion()); m_CovarianceEstimator->SetInput(referenceExtract->GetOutput()); m_CovarianceEstimator->Update(); VnlMatrixType sigma = m_CovarianceEstimator->GetCovariance().GetVnlMatrix(); m_Mean = VnlVectorType(nbComp, 0); for(unsigned int i = 0; iGetMean()[i]; } vnl_generalized_eigensystem ges(sigmad, sigma); VnlMatrixType d = ges.D; m_V = ges.V; m_AutoCorrelation = VnlVectorType(nbComp, 1.); m_AutoCorrelation -= 0.5 *d.get_diagonal(); VnlMatrixType invstderr = VnlMatrixType(nbComp, nbComp, 0); invstderr.set_diagonal(sigma.get_diagonal()); invstderr = invstderr.apply(&vcl_sqrt); invstderr = invstderr.apply(&InverseValue); VnlMatrixType invstderrmaf = VnlMatrixType(nbComp, nbComp, 0); invstderrmaf.set_diagonal((m_V.transpose() * sigma * m_V).get_diagonal()); invstderrmaf = invstderrmaf.apply(&vcl_sqrt); invstderrmaf = invstderrmaf.apply(&InverseValue); VnlMatrixType aux1 = invstderr * sigma * m_V * invstderrmaf; VnlMatrixType sign = VnlMatrixType(nbComp, nbComp, 0); VnlVectorType aux2 = VnlVectorType(nbComp, 0); for(unsigned int i = 0; i < nbComp; ++i) { aux2=aux2 + aux1.get_row(i); } sign.set_diagonal(aux2); sign = sign.apply(&SignOfValue); // There is no need for scaling since vnl_generalized_eigensystem // already gives unit variance m_V = m_V * sign; } template void MaximumAutocorrelationFactorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve input images pointers const TInputImage * inputPtr = this->GetInput(); TOutputImage * outputPtr = this->GetOutput(); typedef itk::ImageRegionConstIterator ConstIteratorType; typedef itk::ImageRegionIterator IteratorType; IteratorType outIt(outputPtr, outputRegionForThread); ConstIteratorType inIt(inputPtr, outputRegionForThread); inIt.GoToBegin(); outIt.GoToBegin(); // Get the number of components for each image unsigned int outNbComp = outputPtr->GetNumberOfComponentsPerPixel(); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); while(!inIt.IsAtEnd() && !outIt.IsAtEnd()) { VnlVectorType x(outNbComp, 0); VnlVectorType maf(outNbComp, 0); for(unsigned int i = 0; i < outNbComp; ++i) { x[i] = inIt.Get()[i]; } maf = (x-m_Mean)*m_V; typename OutputImageType::PixelType outPixel(outNbComp); for(unsigned int i = 0; i class ITK_EXPORT NAPCAImageFilter : public MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > { public: typedef NAPCAImageFilter Self; typedef MNFImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NAPCAImageFilter, MNFImageFilter); /** Template parameters typedefs */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::CovarianceEstimatorFilterType CovarianceEstimatorFilterType; typedef typename Superclass::CovarianceEstimatorFilterPointerType CovarianceEstimatorFilterPointerType; typedef typename Superclass::RealType RealType; typedef typename Superclass::VectorType VectorType; typedef typename Superclass::MatrixObjectType MatrixObjectType; typedef typename Superclass::MatrixType MatrixType; typedef typename Superclass::InternalMatrixType InternalMatrixType; typedef typename Superclass::MatrixElementType MatrixElementType; typedef typename Superclass::TransformFilterType TransformFilterType; typedef typename Superclass::TransformFilterPointerType TransformFilterPointerType; typedef typename Superclass::NoiseImageFilterType NoiseImageFilterType; typedef typename Superclass::NoiseImageFilterPointerType NoiseImageFilterPointerType; typedef typename Superclass::NormalizeFilterType NormalizeFilterType; typedef typename Superclass::NormalizeFilterPointerType NormalizeFilterPointerType; protected: NAPCAImageFilter() { } ~NAPCAImageFilter () ITK_OVERRIDE { } /** Specific functionality of NAPCA */ void GenerateTransformationMatrix() ITK_OVERRIDE; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNAPCAImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbNAPCAImageFilter.txx000066400000000000000000000056071301006202600314560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNAPCAImageFilter_txx #define otbNAPCAImageFilter_txx #include "otbNAPCAImageFilter.h" #include "itkMacro.h" #include #include #include #include namespace otb { template void NAPCAImageFilter< TInputImage, TOutputImage, TNoiseImageFilter, TDirectionOfTransformation > ::GenerateTransformationMatrix () { InternalMatrixType An = this->GetNoiseCovarianceMatrix().GetVnlMatrix(); InternalMatrixType Fn; vnl_vector vectValPn; vnl_symmetric_eigensystem_compute( An, Fn, vectValPn ); /* We used normalized PCA */ InternalMatrixType valPn ( vectValPn.size(), vectValPn.size(), vnl_matrix_null ); for ( unsigned int i = 0; i < valPn.rows(); ++i ) { if ( vectValPn[i] > 0. ) { valPn(i, i) = 1. / vcl_sqrt( vectValPn[i] ); } else if ( vectValPn[i] < 0. ) { otbMsgDebugMacro( << "ValPn(" << i << ") neg : " << vectValPn[i] << " taking abs value" ); valPn(i, i) = 1. / vcl_sqrt( vcl_abs( vectValPn[i] ) ); } else { throw itk::ExceptionObject( __FILE__, __LINE__, "Null Eigen value !!", ITK_LOCATION ); } } Fn = Fn * valPn; InternalMatrixType Ax = vnl_matrix_inverse< MatrixElementType > ( this->GetCovarianceMatrix().GetVnlMatrix() ); InternalMatrixType Aadj = Fn.transpose() * Ax * Fn; InternalMatrixType Fadj; vnl_vector vectValPadj; vnl_symmetric_eigensystem_compute( Aadj, Fadj, vectValPadj ); InternalMatrixType transf = Fn * Fadj; transf.inplace_transpose(); if ( this->GetNumberOfPrincipalComponentsRequired() != this->GetInput()->GetNumberOfComponentsPerPixel() ) this->m_TransformationMatrix = transf.get_n_rows( 0, this->GetNumberOfPrincipalComponentsRequired() ); else this->m_TransformationMatrix = transf; this->m_EigenValues.SetSize( this->GetNumberOfPrincipalComponentsRequired() ); for ( unsigned int i = 0; i < this->GetNumberOfPrincipalComponentsRequired(); ++i ) this->m_EigenValues[this->GetNumberOfPrincipalComponentsRequired()-1-i] = static_cast< RealType >( vectValPadj[i] ); } } // end of namespace otb #endif otbNormalizeInnerProductPCAImageFilter.h000066400000000000000000000117721301006202600350020ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalizeInnerProductPCAImageFilter_h #define otbNormalizeInnerProductPCAImageFilter_h #include "itkInPlaceImageFilter.h" #include "otbStreamingStatisticsVectorImageFilter.h" namespace otb { /** \class NormalizeInnerProductPCAImageFilter * \brief The aim of the class is to normalise vector images using a vector coefficient values. * * \ingroup VectorImage * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT NormalizeInnerProductPCAImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef NormalizeInnerProductPCAImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(NormalizeInnerProductPCAImageFilter, itk::InPlaceImageFilter); /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; /** Typedef for statistic computing. */ typedef StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef typename StreamingStatisticsVectorImageFilterType::Pointer StreamingStatisticsVectorImageFilterPointer; typedef typename StreamingStatisticsVectorImageFilterType::RealType RealType; typedef typename StreamingStatisticsVectorImageFilterType::RealPixelType RealPixelType; typedef typename StreamingStatisticsVectorImageFilterType::MatrixType MatrixType; itkSetMacro(UseUnbiasedEstimator, bool); itkGetMacro(UseUnbiasedEstimator, bool); protected: NormalizeInnerProductPCAImageFilter(); ~NormalizeInnerProductPCAImageFilter() ITK_OVERRIDE {} /** NormalizeInnerProductPCAImageFilter can produce an image which is a different * resolution than its input image. As such, NormalizeInnerProductPCAImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; /** NormalizeInnerProductPCAImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** BeforeThreadedGenerateData method */ void BeforeThreadedGenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** Contains normalization coefficient input image */ RealPixelType m_CoefNorm; /* use an unbiased estimator to compute the covariance */ bool m_UseUnbiasedEstimator; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNormalizeInnerProductPCAImageFilter.txx" #endif #endif otbNormalizeInnerProductPCAImageFilter.txx000066400000000000000000000106561301006202600353760ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalizeInnerProductPCAImageFilter_txx #define otbNormalizeInnerProductPCAImageFilter_txx #include "otbNormalizeInnerProductPCAImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template NormalizeInnerProductPCAImageFilter ::NormalizeInnerProductPCAImageFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->InPlaceOff(); m_UseUnbiasedEstimator = true; } /** * GenerateOutputInformation */ template void NormalizeInnerProductPCAImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); } /** * BeforeThreadedGenerateData Performs the pixel-wise addition */ template void NormalizeInnerProductPCAImageFilter ::BeforeThreadedGenerateData() { StreamingStatisticsVectorImageFilterPointer stats = StreamingStatisticsVectorImageFilterType::New(); stats->SetInput(const_cast(this->GetInput())); //set the normalization method to compute covariance to the StreamingStatisticsVectorImage filter stats->SetUseUnbiasedEstimator(m_UseUnbiasedEstimator); stats->Update(); RealPixelType means = stats->GetMean(); MatrixType cov = stats->GetCovariance(); double NbPixels = static_cast( this->GetInput()->GetLargestPossibleRegion().GetSize()[0] * this->GetInput()->GetLargestPossibleRegion().GetSize()[1]); if ((cov.Rows() != means.Size()) || (cov.Cols() != means.Size())) { itkExceptionMacro(<< "Covariance matrix with size (" << cov.Rows() << "," << cov.Cols() << ") is incompatible with mean vector with size" << means.Size()); } m_CoefNorm.SetSize(means.Size()); for (unsigned int i = 0; i < m_CoefNorm.Size(); ++i) { m_CoefNorm[i] = (1. / vcl_sqrt(NbPixels * (cov[i][i] + means[i] * means[i]))); } } /** * ThreadedGenerateData Performs the pixel-wise addition */ template void NormalizeInnerProductPCAImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); // Null pixel construction InputPixelType nullPixel; nullPixel.SetSize(inputPtr->GetNumberOfComponentsPerPixel()); nullPixel.Fill(itk::NumericTraits::Zero); while (!inputIt.IsAtEnd()) { InputPixelType inPixel = inputIt.Get(); OutputPixelType outPixel; outPixel.SetSize(inputPtr->GetNumberOfComponentsPerPixel()); outPixel.Fill(itk::NumericTraits::Zero); //outPixel = m_Means * inPixel; for (unsigned int j = 0; j < inputPtr->GetNumberOfComponentsPerPixel(); ++j) { outPixel[j] = static_cast(m_CoefNorm[j] * static_cast(inPixel[j])); } outputIt.Set(outPixel); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } template void NormalizeInnerProductPCAImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbPCAImageFilter.h000066400000000000000000000161771301006202600306470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPCAImageFilter_h #define otbPCAImageFilter_h #include "otbMacro.h" #include "otbMatrixImageFilter.h" #include "otbNormalizeVectorImageFilter.h" namespace otb { namespace Transform { enum TransformDirection {FORWARD = 0, INVERSE = 1}; } /** \class PCAImageFilter * \brief Performs a Principal Component Analysis * * The internal structure of this filter is a filter-to-filter like structure. * The estimation of the covariance matrix has persistent capabilities... * * \sa otbStreamingStatisticsVectorImageFilter * \sa MatrixMultiplyImageFilter * * \ingroup OTBDimensionalityReduction */ template class ITK_EXPORT PCAImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef PCAImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(PCAImageFilter, ImageToImageFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef Transform::TransformDirection TransformDirectionEnumType; itkStaticConstMacro(DirectionOfTransformation, TransformDirectionEnumType, TDirectionOfTransformation); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Filter types and related */ typedef StreamingStatisticsVectorImageFilter< InputImageType > CovarianceEstimatorFilterType; typedef typename CovarianceEstimatorFilterType::Pointer CovarianceEstimatorFilterPointerType; typedef typename CovarianceEstimatorFilterType::RealType RealType; typedef typename CovarianceEstimatorFilterType::RealPixelType VectorType; typedef typename CovarianceEstimatorFilterType::MatrixObjectType MatrixObjectType; typedef typename MatrixObjectType::ComponentType MatrixType; typedef typename MatrixType::InternalMatrixType InternalMatrixType; typedef typename InternalMatrixType::element_type MatrixElementType; typedef MatrixImageFilter< TInputImage, TOutputImage > TransformFilterType; typedef typename TransformFilterType::Pointer TransformFilterPointerType; typedef NormalizeVectorImageFilter< TInputImage, TOutputImage > NormalizeFilterType; typedef typename NormalizeFilterType::Pointer NormalizeFilterPointerType; /** * Set/Get the number of required largest principal components. * The filter produces the required number of principal components plus one outputs. * Output index 0 represents the mean image and the remaining outputs the requested principal components. */ itkSetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkGetMacro(NumberOfPrincipalComponentsRequired, unsigned int); itkGetMacro(CovarianceEstimator, CovarianceEstimatorFilterType *); itkGetMacro(Transformer, TransformFilterType *); itkGetMacro(GivenCovarianceMatrix, bool); MatrixType GetCovarianceMatrix () const { if ( m_GivenCovarianceMatrix ) return m_CovarianceMatrix; else return this->GetCovarianceEstimator()->GetCovariance(); } void SetCovarianceMatrix ( const MatrixType & cov ) { m_CovarianceMatrix = cov; m_GivenCovarianceMatrix = true; this->Modified(); } itkGetMacro(TransformationMatrix, MatrixType); itkGetMacro(GivenTransformationMatrix, bool); void SetTransformationMatrix( const MatrixType & transf, bool isForward = true ) { m_TransformationMatrix = transf; m_GivenTransformationMatrix = true; m_IsTransformationMatrixForward = isForward; this->Modified(); } itkGetConstMacro(EigenValues, VectorType); itkGetMacro(UseNormalization, bool); void SetUseNormalization ( bool norm ) { m_UseNormalization = norm; m_UseVarianceForNormalization = norm; this->Modified(); } itkGetConstMacro(MeanValues, VectorType); void SetMeanValues ( const VectorType & data ) { m_UseNormalization = true; m_GivenMeanValues = true; m_MeanValues = data; this->Modified(); } itkGetConstMacro(UseVarianceForNormalization, bool); itkSetMacro(UseVarianceForNormalization, bool); itkGetConstMacro(StdDevValues, VectorType); void SetStdDevValues ( const VectorType & vec ) { m_UseNormalization = true; m_UseVarianceForNormalization = true; m_GivenStdDevValues = true; m_StdDevValues = vec; this->Modified(); } protected: PCAImageFilter(); ~PCAImageFilter() ITK_OVERRIDE { } /** GenerateOutputInformation * Propagate vector length info and modify if needed * NumberOfPrincipalComponentsRequired * * In REVERSE mode, the covariance matrix or the transformation matrix * (which may not be square) has to be given, * otherwize, GenerateOutputInformation throws an itk::ExceptionObject */ void GenerateOutputInformation() ITK_OVERRIDE; /** GenerateData * Through a filter of filter structure */ void GenerateData () ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Internal methods */ virtual void ForwardGenerateOutputInformation(); virtual void ReverseGenerateOutputInformation(); virtual void ForwardGenerateData(); virtual void ReverseGenerateData(); void GenerateTransformationMatrix(); /** Internal attributes */ unsigned int m_NumberOfPrincipalComponentsRequired; bool m_UseNormalization; bool m_UseVarianceForNormalization; bool m_GivenMeanValues; bool m_GivenStdDevValues; bool m_GivenCovarianceMatrix; bool m_GivenTransformationMatrix; bool m_IsTransformationMatrixForward; VectorType m_MeanValues; VectorType m_StdDevValues; MatrixType m_CovarianceMatrix; VectorType m_EigenValues; MatrixType m_TransformationMatrix; CovarianceEstimatorFilterPointerType m_CovarianceEstimator; TransformFilterPointerType m_Transformer; NormalizeFilterPointerType m_Normalizer; private: PCAImageFilter( const Self & ); // not implemented void operator= ( const Self & ); // not implemented }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPCAImageFilter.txx" #endif #endif // otbPCAImageFilter_h OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/otbPCAImageFilter.txx000066400000000000000000000340011301006202600312250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPCAImageFilter_txx #define otbPCAImageFilter_txx #include "otbPCAImageFilter.h" #include "itkMacro.h" #include #include #include namespace otb { template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::PCAImageFilter () { this->SetNumberOfRequiredInputs(1); m_NumberOfPrincipalComponentsRequired = 0; m_UseNormalization = false; m_UseVarianceForNormalization = false; m_GivenMeanValues = false; m_GivenStdDevValues = false; m_GivenCovarianceMatrix = false; m_GivenTransformationMatrix = false; m_IsTransformationMatrixForward = true; m_CovarianceEstimator = CovarianceEstimatorFilterType::New(); m_Transformer = TransformFilterType::New(); m_Transformer->MatrixByVectorOn(); m_Normalizer = NormalizeFilterType::New(); } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): { if ( m_NumberOfPrincipalComponentsRequired == 0 || m_NumberOfPrincipalComponentsRequired > this->GetInput()->GetNumberOfComponentsPerPixel() ) { m_NumberOfPrincipalComponentsRequired = this->GetInput()->GetNumberOfComponentsPerPixel(); } this->GetOutput()->SetNumberOfComponentsPerPixel( m_NumberOfPrincipalComponentsRequired ); break; } case static_cast(Transform::INVERSE): { unsigned int theOutputDimension = 0; if ( m_GivenTransformationMatrix ) { theOutputDimension = m_TransformationMatrix.Rows() >= m_TransformationMatrix.Cols() ? m_TransformationMatrix.Rows() : m_TransformationMatrix.Cols(); } else if ( m_GivenCovarianceMatrix ) { theOutputDimension = m_CovarianceMatrix.Rows() >= m_CovarianceMatrix.Cols() ? m_CovarianceMatrix.Rows() : m_CovarianceMatrix.Cols(); } else { throw itk::ExceptionObject(__FILE__, __LINE__, "Covariance or transformation matrix required to know the output size", ITK_LOCATION); } this->GetOutput()->SetNumberOfComponentsPerPixel( theOutputDimension ); break; } default: throw itk::ExceptionObject(__FILE__, __LINE__, "Class should be templeted with FORWARD or INVERSE only...", ITK_LOCATION ); } switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): { ForwardGenerateOutputInformation(); break; } case static_cast(Transform::INVERSE): { ReverseGenerateOutputInformation(); break; } } } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ForwardGenerateOutputInformation() { typename InputImageType::Pointer inputImgPtr = const_cast( this->GetInput() ); if ( !m_GivenTransformationMatrix ) { if ( !m_GivenCovarianceMatrix ) { if ( m_UseNormalization ) { m_Normalizer->SetInput( inputImgPtr ); m_Normalizer->SetUseStdDev( m_UseVarianceForNormalization ); if ( m_GivenMeanValues ) m_Normalizer->SetMean( m_MeanValues ); if ( m_GivenStdDevValues ) m_Normalizer->SetStdDev( m_StdDevValues ); m_Normalizer->GetOutput()->UpdateOutputInformation(); if ( !m_GivenMeanValues ) { m_MeanValues = m_Normalizer->GetCovarianceEstimator()->GetMean(); if ( !m_GivenStdDevValues ) m_StdDevValues = m_Normalizer->GetFunctor().GetStdDev(); if ( m_UseVarianceForNormalization ) m_CovarianceMatrix = m_Normalizer->GetCovarianceEstimator()->GetCorrelation(); else m_CovarianceMatrix = m_Normalizer->GetCovarianceEstimator()->GetCovariance(); } else { m_CovarianceEstimator->SetInput( m_Normalizer->GetOutput() ); m_CovarianceEstimator->UpdateOutputInformation(); m_CovarianceMatrix = m_CovarianceEstimator->GetCovariance(); } m_Transformer->SetInput( m_Normalizer->GetOutput() ); } else { m_CovarianceEstimator->SetInput( inputImgPtr ); m_CovarianceEstimator->Update(); m_CovarianceMatrix = m_CovarianceEstimator->GetCovariance(); m_Transformer->SetInput( inputImgPtr ); } } else { m_Transformer->SetInput( inputImgPtr ); } GenerateTransformationMatrix(); } else if ( !m_IsTransformationMatrixForward ) { //m_TransformationMatrix = m_TransformationMatrix.GetTranspose(); m_TransformationMatrix = m_TransformationMatrix.GetInverse(); m_Transformer->SetInput( inputImgPtr ); } if ( m_TransformationMatrix.GetVnlMatrix().empty() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Empty transformation matrix", ITK_LOCATION); } } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ReverseGenerateOutputInformation() { if ( !m_GivenTransformationMatrix ) { if ( !m_GivenCovarianceMatrix ) { throw itk::ExceptionObject( __FILE__, __LINE__, "No Covariance nor Transformation matrix given", ITK_LOCATION ); } GenerateTransformationMatrix(); //m_TransformationMatrix = m_TransformationMatrix.GetTranspose(); m_TransformationMatrix = m_TransformationMatrix.GetInverse(); } else if ( m_IsTransformationMatrixForward ) { // prevents from multiple transpositions... m_IsTransformationMatrixForward = false; //m_TransformationMatrix = m_TransformationMatrix.GetTranspose(); m_TransformationMatrix = m_TransformationMatrix.GetInverse(); } if ( m_TransformationMatrix.GetVnlMatrix().empty() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "Empty transformation matrix", ITK_LOCATION); } m_Transformer->SetInput( this->GetInput() ); m_Transformer->SetMatrix( m_TransformationMatrix.GetVnlMatrix() ); m_Normalizer->SetInput( m_Transformer->GetOutput() ); if ( m_GivenStdDevValues || m_GivenMeanValues ) { if ( m_GivenStdDevValues ) { VectorType revStdDev ( m_StdDevValues.Size() ); for ( unsigned int i = 0; i < m_StdDevValues.Size(); ++i ) revStdDev[i] = 1. / m_StdDevValues[i]; m_Normalizer->SetStdDev( revStdDev ); } if ( m_GivenMeanValues ) { VectorType revMean ( m_MeanValues.Size() ); if ( m_GivenStdDevValues ) { for ( unsigned int i = 0; i < m_MeanValues.Size(); ++i ) revMean[i] = - m_MeanValues[i] / m_StdDevValues[i]; m_Normalizer->SetUseStdDev( true ); } else { for ( unsigned int i = 0; i < m_MeanValues.Size(); ++i ) revMean[i] = -m_MeanValues[i]; m_Normalizer->SetUseStdDev( false ); } m_Normalizer->SetMean( revMean ); } } else { m_Normalizer->SetUseMean(false); m_Normalizer->SetUseStdDev(false); } } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::GenerateData () { switch ( static_cast(DirectionOfTransformation) ) { case static_cast(Transform::FORWARD): return ForwardGenerateData(); case static_cast(Transform::INVERSE): return ReverseGenerateData(); default: throw itk::ExceptionObject(__FILE__, __LINE__, "Class should be templated with FORWARD or INVERSE only...", ITK_LOCATION ); } } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ForwardGenerateData () { m_Transformer->SetMatrix( m_TransformationMatrix.GetVnlMatrix() ); m_Transformer->GraftOutput( this->GetOutput() ); m_Transformer->Update(); this->GraftOutput( m_Transformer->GetOutput() ); } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::ReverseGenerateData () { if ( m_GivenStdDevValues || m_GivenMeanValues ) { m_Normalizer->GraftOutput(this->GetOutput()); m_Normalizer->Update(); this->GraftOutput(m_Normalizer->GetOutput()); } else { m_Transformer->GraftOutput( this->GetOutput() ); m_Transformer->Update(); this->GraftOutput( m_Transformer->GetOutput() ); } } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::GenerateTransformationMatrix () { #if 0 /* * Old stuff but did work ! */ MatrixType Id ( m_CovarianceMatrix ); Id.SetIdentity(); typename MatrixType::InternalMatrixType A = m_CovarianceMatrix.GetVnlMatrix(); typename MatrixType::InternalMatrixType I = Id.GetVnlMatrix(); vnl_generalized_eigensystem solver ( A, I ); typename MatrixType::InternalMatrixType transf = solver.V; transf.fliplr(); transf.inplace_transpose(); vnl_vector< double > valP = solver.D.diagonal(); valP.flip(); /* * We used normalized PCA */ for ( unsigned int i = 0; i < valP.size(); ++i ) { if ( valP[i] != 0. ) valP[i] = 1. / vcl_sqrt( vcl_abs( valP[i] ) ); else throw itk::ExceptionObject( __FILE__, __LINE__, "Null Eigen value !!", ITK_LOCATION ); } valP.post_multiply( transf ); if ( m_NumberOfPrincipalComponentsRequired != this->GetInput()->GetNumberOfComponentsPerPixel() ) m_TransformationMatrix = transf.get_n_rows( 0, m_NumberOfPrincipalComponentsRequired ); else m_TransformationMatrix = transf; m_EigenValues.SetSize( m_NumberOfPrincipalComponentsRequired ); for ( unsigned int i = 0; i < m_NumberOfPrincipalComponentsRequired; ++i ) m_EigenValues[i] = static_cast< RealType >( valP[i] ); #else InternalMatrixType transf; vnl_vector vectValP; vnl_symmetric_eigensystem_compute( m_CovarianceMatrix.GetVnlMatrix(), transf, vectValP ); InternalMatrixType valP ( vectValP.size(), vectValP.size(), vnl_matrix_null ); for ( unsigned int i = 0; i < vectValP.size(); ++i ) valP(i, i) = vectValP[i]; /* We used normalized PCA */ for ( unsigned int i = 0; i < valP.rows(); ++i ) { if ( valP(i, i) > 0. ) { valP(i, i) = 1. / vcl_sqrt( valP(i, i) ); } else if ( valP(i, i) < 0. ) { otbMsgDebugMacro( << "ValP(" << i << ") neg : " << valP(i, i) << " taking abs value" ); valP(i, i) = 1. / vcl_sqrt( vcl_abs( valP(i, i) ) ); } else { throw itk::ExceptionObject( __FILE__, __LINE__, "Null Eigen value !!", ITK_LOCATION ); } } transf = valP * transf.transpose(); transf.flipud(); if ( m_NumberOfPrincipalComponentsRequired != this->GetInput()->GetNumberOfComponentsPerPixel() ) m_TransformationMatrix = transf.get_n_rows( 0, m_NumberOfPrincipalComponentsRequired ); else m_TransformationMatrix = transf; m_EigenValues.SetSize( m_NumberOfPrincipalComponentsRequired ); for ( unsigned int i = 0; i < m_NumberOfPrincipalComponentsRequired; ++i ) m_EigenValues[i] = static_cast< RealType >( valP(i, i) ); #endif } template < class TInputImage, class TOutputImage, Transform::TransformDirection TDirectionOfTransformation > void PCAImageFilter< TInputImage, TOutputImage, TDirectionOfTransformation > ::PrintSelf ( std::ostream& os, itk::Indent indent ) const { Superclass::PrintSelf( os, indent ); os << indent << "m_UseNormalization = "; if ( m_UseNormalization ) os << "true\n"; else os << "false\n"; if ( m_GivenMeanValues ) os << indent << "Given Mean : " << m_MeanValues << "\n"; if ( m_GivenStdDevValues ) os << indent << "Given StdDev : " << m_StdDevValues << "\n"; if ( !m_CovarianceMatrix.GetVnlMatrix().empty() ) { os << indent << "Covariance matrix"; if ( m_GivenCovarianceMatrix ) os << " (given)"; os << "\n"; m_CovarianceMatrix.GetVnlMatrix().print(os); if ( m_GivenCovarianceMatrix ) m_CovarianceEstimator->Print( os, indent.GetNextIndent() ); } if ( !m_TransformationMatrix.GetVnlMatrix().empty() ) { os << indent; if ( !m_IsTransformationMatrixForward ) os << "Invert "; os << "Transformation matrix"; if ( m_GivenTransformationMatrix ) os << " (given)"; os << "\n"; m_TransformationMatrix.GetVnlMatrix().print(os); } if ( m_EigenValues.Size() > 0 ) { os << indent << "Eigen value :"; for ( unsigned int i = 0; i < m_NumberOfPrincipalComponentsRequired; ++i ) os << " " << m_EigenValues[i]; os << "\n"; } } } // end of namespace otb #endif // otbPCAImageFilter_txx otbSparseWvltToAngleMapperListFilter.h000066400000000000000000000122721301006202600345770ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSparseWvltToAngleMapperListFilter_h #define otbSparseWvltToAngleMapperListFilter_h #include "otbMath.h" #include "otbImageList.h" #include "itkProcessObject.h" #include "itkDataObjectDecorator.h" #include "itkImageRegionConstIterator.h" namespace otb { /** \class SparseWvltToAngleMapperListFilter * \brief This class select N-uple join-wvlt coeff for sparse unmixing * * This class performs a kind of scatter plot of wavelet coeff of N images and yields * the angle values (through a generalized spherical coordinate representation)) of * the most significant coeff (up to a threshold). * * \ingroup Threaded * * \ingroup OTBDimensionalityReduction */ template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > class SparseWvltToAngleMapperListFilter : public ITK_EXPORT itk::ProcessObject { public: /** Standard typedefs. */ typedef SparseWvltToAngleMapperListFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SparseWvltToAngleMapperListFilter, ProcessObject); /** Number of input images */ itkStaticConstMacro(NumberOfInputImages, unsigned int, VNbInputImages); /** InputList typedefs */ typedef TInputImageList InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::ConstIterator InputImageListConstIteratorType; typedef typename InputImageListType::ImageType InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; /** OutputSampleList typedefs */ typedef TOutputSampleList OutputSampleListType; typedef typename OutputSampleListType::Pointer OutputSampleListPointer; typedef typename OutputSampleListType::ConstPointer OutputSampleListConstPointer; typedef typename OutputSampleListType::MeasurementVectorType OutputMeasurementVectorType; typedef typename OutputMeasurementVectorType::ValueType OutputValueType; /** Iterator */ typedef itk::ImageRegionConstIterator< InputImageType > ImageConstIteratorType; typedef std::vector< ImageConstIteratorType > ImageConstIteratorVectorType; typedef std::vector< InputImageListConstIteratorType > InputImageListConstIteratorVectorType; void SetInput ( unsigned int i, const InputImageListType * ); using Superclass::SetInput; const InputImageListType * GetInput( unsigned int i ) const; /** ListSample is not a DataObject, we need to decorate it to push it down * a ProcessObject's pipeline */ typedef itk::DataObject::Pointer DataObjectPointer; typedef itk::DataObjectDecorator< OutputSampleListType > OutputSampleListObjectType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Returns the output sample list */ OutputSampleListType * GetOutputSampleList(); /** Returns the output sample list as a data object */ OutputSampleListObjectType * GetOutput(); /** Get/Set the threshold value */ itkGetMacro(ThresholdValue, ValueType); itkSetMacro(ThresholdValue, ValueType); protected: SparseWvltToAngleMapperListFilter(); ~SparseWvltToAngleMapperListFilter() ITK_OVERRIDE { } /** Standard itk::ProcessObject subclass method. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** This method causes the filter to generate its output. */ void GenerateData() ITK_OVERRIDE; /* Internal functions */ virtual bool IsToGenerate ( const ImageConstIteratorVectorType & ) const; virtual OutputMeasurementVectorType GenerateData ( const ImageConstIteratorVectorType & ) const; virtual OutputMeasurementVectorType FromEuclideanToSphericalSpace ( const ImageConstIteratorVectorType & ) const; private: SparseWvltToAngleMapperListFilter(const Self &); // not implemented void operator=(const Self &); ValueType m_ThresholdValue; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSparseWvltToAngleMapperListFilter.txx" #endif #endif otbSparseWvltToAngleMapperListFilter.txx000066400000000000000000000200501301006202600351640ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSparseWvltToAngleMapperListFilter_txx #define otbSparseWvltToAngleMapperListFilter_txx #include "otbSparseWvltToAngleMapperListFilter.h" #include #include "itkProgressReporter.h" namespace otb { template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::SparseWvltToAngleMapperListFilter () { this->SetNumberOfRequiredInputs(NumberOfInputImages); // Generate the output sample list typename OutputSampleListObjectType::Pointer outputPtr = static_cast< OutputSampleListObjectType * >(this->MakeOutput(0).GetPointer()); this->ProcessObject::SetNthOutput(0, outputPtr.GetPointer()); m_ThresholdValue = static_cast( 10. ); } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > void SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::SetInput ( unsigned int i, const InputImageListType * img ) { this->itk::ProcessObject::SetNthInput(i, const_cast< InputImageListType * >( img ) ); } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > const TInputImageList * SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::GetInput ( unsigned int i ) const { if ( i >= this->GetNumberOfInputs() ) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(i) ); } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > typename SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::DataObjectPointer SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::MakeOutput(DataObjectPointerArraySizeType itkNotUsed(idx)) { typename OutputSampleListObjectType::Pointer outputPtr = OutputSampleListObjectType::New(); OutputSampleListPointer outputSampleList = OutputSampleListType::New(); outputPtr->Set(outputSampleList); return static_cast(outputPtr); } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > typename SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::OutputSampleListType * SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::GetOutputSampleList() { typename OutputSampleListObjectType::Pointer dataObjectPointer = static_cast (this->ProcessObject::GetOutput(0) ); return const_cast(dataObjectPointer->Get()); } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > typename SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::OutputSampleListObjectType * SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::GetOutput() { return static_cast (this->ProcessObject::GetOutput(0) ); } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > void SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Threshold : " << m_ThresholdValue << "\n"; } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > void SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::GenerateData () { InputImageListConstIteratorVectorType it ( NumberOfInputImages ); for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) it[i] = this->GetInput(i)->Begin(); OutputSampleListType * outputList = this->GetOutputSampleList(); // Set-up progress reporting itk::ProgressReporter progress(this, 0, this->GetInput(0)->Size()); bool iteratorsNotAtEnd = true; while ( iteratorsNotAtEnd ) { ImageConstIteratorVectorType imgIt ( NumberOfInputImages ); for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { imgIt[i] = ImageConstIteratorType( it[i].Get(), it[i].Get()->GetLargestPossibleRegion() ); imgIt[i].GoToBegin(); } bool localIteratorsNotAtEnd = true; while ( localIteratorsNotAtEnd ) { if ( IsToGenerate( imgIt ) ) { outputList->PushBack( GenerateData( imgIt ) ); } for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { ++(imgIt[i]); if ( imgIt[i].IsAtEnd() ) localIteratorsNotAtEnd = false; } } for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { ++(it[i]); if ( it[i] != this->GetInput(i)->End() ) iteratorsNotAtEnd = false; } progress.CompletedPixel(); } } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > bool SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::IsToGenerate ( const ImageConstIteratorVectorType & it ) const { for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { if ( it[i].Get() < m_ThresholdValue ) return false; } return true; } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > typename SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::OutputMeasurementVectorType SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::GenerateData ( const ImageConstIteratorVectorType & it ) const { return FromEuclideanToSphericalSpace( it ); } template < class TInputImageList, class TOutputSampleList, unsigned int VNbInputImages > typename SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::OutputMeasurementVectorType SparseWvltToAngleMapperListFilter< TInputImageList, TOutputSampleList, VNbInputImages > ::FromEuclideanToSphericalSpace ( const ImageConstIteratorVectorType & it ) const { // First, get the modulus of the vector double modulus = 0; for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { modulus += vcl_pow( static_cast( it[i].Get() ), 2. ); } // The modulus cannot be nul since it is over the threshold... modulus = vcl_sqrt( modulus ); // FIXME test if NaN nor infinite OutputMeasurementVectorType angle; angle.Fill( static_cast< OutputValueType >( 0. ) ); if ( NumberOfInputImages == 2 ) { if ( it[1].Get() < 0 ) { angle[0] = vcl_acos( it[0].Get() / modulus ); } else { angle[0] = - vcl_acos( it[0].Get() / modulus ); } } else { for ( unsigned int k = 0; k < angle.Size()-1; ++k ) { double phase = vcl_acos( it[k].Get() / modulus ); angle[k] = phase; modulus *= vcl_sin( phase ); // FIXME test also if not finite if ( modulus < 1e-5 ) { while ( ++k < angle.Size() ) angle[k] = 0.; return angle; } } /* * With this sign modification, we can put the same * images for all the components and recover the good direction */ double sign = NumberOfInputImages == 3 ? -1. : 1.; if ( it[ NumberOfInputImages-1 ].Get() < 0 ) { angle[ angle.Size()-1 ] = sign * vcl_acos( it[ NumberOfInputImages-2 ].Get() / modulus ); } else { angle[ angle.Size()-1 ] = - sign * vcl_acos( it[ NumberOfInputImages-2 ].Get() / modulus ); } } return angle; } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/DimensionalityReduction/otb-module.cmake000066400000000000000000000013141301006202600266660ustar00rootroot00000000000000set(DOCUMENTATION "Dimension reduction is a statistical process, which concentrates the amount of information in multivariate data into a fewer number of variables (or dimensions). This module implements methods such as Principal Component Analysis (PCA), Noise-Adjusted Principal Components Analysis (NAPCA), Maximum Noise Fraction (MNF), Fast Independent Component Analysis (FICA), Maximum Autocorrelation Factor (MAF), and so on.") otb_module(OTBDimensionalityReduction DEPENDS OTBCommon OTBITK OTBImageBase OTBImageManipulation OTBObjectList OTBStatistics TEST_DEPENDS OTBCommandLineParser OTBImageIO OTBTestKernel OTBWavelet DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/000077500000000000000000000000001301006202600245755ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/CMakeLists.txt000066400000000000000000000363751301006202600273530ustar00rootroot00000000000000otb_module_test() set(OTBDimensionalityReductionTests otbDimensionalityReductionTestDriver.cxx otbNormalizeInnerProductPCAImageFilterNew.cxx otbFastICAImageFilter.cxx otbNormalizeInnerProductPCAImageFilter.cxx otbMaximumAutocorrelationFactorImageFilter.cxx otbMNFImageFilter.cxx otbInnerProductPCAImageFilter.cxx otbEstimateInnerProductPCAImageFilterNew.cxx otbEstimateInnerProductPCAImageFilter.cxx otbPCAImageFilter.cxx otbAngularProjectionSetImageFilter.cxx otbAngularProjectionSetImageFilterNew.cxx otbNAPCAImageFilter.cxx otbInnerProductPCAImageFilterNew.cxx otbSparseWvltToAngleMapperListFilterNew.cxx otbAngularProjectionImageFilterNew.cxx otbAngularProjectionImageFilter.cxx otbAngularProjectionBinaryImageFilter.cxx otbSparseWvltToAngleMapperListFilter.cxx otbLocalActivityVectorImageFilter.cxx ) add_executable(otbDimensionalityReductionTestDriver ${OTBDimensionalityReductionTests}) target_link_libraries(otbDimensionalityReductionTestDriver ${OTBDimensionalityReduction-Test_LIBRARIES}) otb_module_target_label(otbDimensionalityReductionTestDriver) # Tests Declaration otb_add_test(NAME bfTuNormalizeInnerProductPCAImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbNormalizeInnerProductPCAImageFilterNew ) otb_add_test(NAME bfTuFastICAImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbFastICAImageFilterNewTest) #otb_add_test(NAME bfTvFastICAImageFilter COMMAND otbDimensionalityReductionTestDriver #--compare-n-images ${EPSILON_7} 2 #${BASELINE}/hyTvFastICAImageFilter.tif #${TEMP}/hyTvFastICAImageFilter.tif #${BASELINE}/hyTvFastICAImageFilterInv.tif #${TEMP}/hyTvFastICAImageFilterInv.tif #otbFastICAImageFilterTest #-in ${INPUTDATA}/cupriteSubHsi.tif #-inv ${TEMP}/hyTvFastICAImageFilterInv.tif #-out ${TEMP}/hyTvFastICAImageFilter.tif) otb_add_test(NAME bfTuFastICAInternalOptimizerVectorImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbFastICAInternalOptimizerVectorImageFilterNewTest) otb_add_test(NAME bfTvNormalizeInnerProductPCAImageFilter COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_12} ${BASELINE}/bfNormalizeInnerProductPCAImageFilter.tif ${TEMP}/bfNormalizeInnerProductPCAImageFilter.tif otbNormalizeInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfNormalizeInnerProductPCAImageFilter.tif ) otb_add_test(NAME bfTvMaximumAutocorrelationFactorImageFilter COMMAND otbDimensionalityReductionTestDriver --compare-image 0.0001 ${BASELINE}/bfTvMaximumAutocorrelationFactorImageFilterOutput.tif ${TEMP}/bfTvMaximumAutocorrelationFactorImageFilterOutput.tif otbMaximumAutocorrelationFactorImageFilter ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/bfTvMaximumAutocorrelationFactorImageFilterOutput.tif ) otb_add_test(NAME bfTuMaximumAutocorrelationFactorImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbMaximumAutocorrelationFactorImageFilterNew ) otb_add_test(NAME bfTvMNFImageFilter3 COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvMNFImageFilter3.tif ${TEMP}/bfTvMNFImageFilter3.tif ${BASELINE}/bfTvMNFImageFilter3Inv.tif ${TEMP}/bfTvMNFImageFilter3Inv.tif otbMNFImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvMNFImageFilter3.tif -inv ${TEMP}/bfTvMNFImageFilter3Inv.tif -norm) otb_add_test(NAME bfTvMNFImageFilter2 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/bfTvMNFImageFilter2Inv.tif otbMNFImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvMNFImageFilter2.tif -inv ${TEMP}/bfTvMNFImageFilter2Inv.tif -norm) otb_add_test(NAME bfTvMNFImageFilter1 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/bfTvMNFImageFilter1Inv.tif otbMNFImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvMNFImageFilter1.tif -inv ${TEMP}/bfTvMNFImageFilter1Inv.tif) otb_add_test(NAME bfTvMNFImageFilter4 COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvMNFImageFilter4.tif ${TEMP}/bfTvMNFImageFilter4.tif ${BASELINE}/bfTvMNFImageFilter4Inv.tif ${TEMP}/bfTvMNFImageFilter4Inv.tif otbMNFImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvMNFImageFilter4.tif -inv ${TEMP}/bfTvMNFImageFilter4Inv.tif -norm -n 4) otb_add_test(NAME bfTvInnerProductPCAImageFilter_PC12 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfInnerProductPCAImageFilter_PC12.tif ${TEMP}/bfInnerProductPCAImageFilter_PC12.tif otbInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfInnerProductPCAImageFilter_PC12.tif 0 # Flag generate Mean component ? 1 #center data 2 # Nb Of Principal Components 1 # use unbiased estimator ${TEMP}/bfInnerProductPCAImageFilter_PC12_1.tif ${TEMP}/bfInnerProductPCAImageFilter_PC12_2.tif ) otb_add_test(NAME bfTvInnerProductPCAImageFilter_PC1 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfInnerProductPCAImageFilter_PC1.tif ${TEMP}/bfInnerProductPCAImageFilter_PC1.tif otbInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfInnerProductPCAImageFilter_PC1.tif 0 # Flag generate Mean component ? 1 #center data 1 # Nb Of Principal Components 1 # use unbiased estimator ${TEMP}/bfInnerProductPCAImageFilter_PC1_1.tif ) otb_add_test(NAME bfTvInnerProductPCAImageFilterDisableCenterData COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfInnerProductPCAImageFilterDisableCenterData.tif ${TEMP}/bfInnerProductPCAImageFilterDisableCenterData.tif otbInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfInnerProductPCAImageFilterDisableCenterData.tif 0 # Flag generate Mean component ? 0 #center data 3 # Nb Of Principal Components 1 # use unbiased estimator ${TEMP}/bfInnerProductPCAImageFilterDisableCenterData_pc1.tif ${TEMP}/bfInnerProductPCAImageFilterDisableCenterData_pc2.tif ${TEMP}/bfInnerProductPCAImageFilterDisableCenterData_pc3.tif ) otb_add_test(NAME bfTvInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfInnerProductPCAImageFilterAllsOutputs.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator.tif otbInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator.tif 1 # Flag generate Mean component ? 1 #center data 3 # Nb Of Principal Components 0 # do not use unbiased estimator (use in bfTvItkImagePCAShapeModelEstimatorTest to compare results with ITK PCA filter) ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_pc1.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_pc2.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_pc3.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputsWithoutUnbiasedEstimator_MEAN.tif ) otb_add_test(NAME bfTvInnerProductPCAImageFilterAllsOutputs COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfInnerProductPCAImageFilterAllsOutputs.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputs.tif otbInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfInnerProductPCAImageFilterAllsOutputs.tif 1 # Flag generate Mean component ? 1 #center data 3 # Nb Of Principal Components 1 # use unbiased estimator (default mode) ${TEMP}/bfInnerProductPCAImageFilterAllsOutputs_pc1.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputs_pc2.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputs_pc3.tif ${TEMP}/bfInnerProductPCAImageFilterAllsOutputs_MEAN.tif ) otb_add_test(NAME bfTvInnerProductPCAImageFilter COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfInnerProductPCAImageFilter.tif ${TEMP}/bfInnerProductPCAImageFilter.tif otbInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfInnerProductPCAImageFilter.tif 0 # Flag generate Mean component ? 1 #center data 3 # Nb Of Principal Components 1 # use unbiased estimator ${TEMP}/bfInnerProductPCAImageFilter_pc1.tif ${TEMP}/bfInnerProductPCAImageFilter_pc2.tif ${TEMP}/bfInnerProductPCAImageFilter_pc3.tif ) otb_add_test(NAME bfTuEstimateInnerProductPCAImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbEstimateInnerProductPCAImageFilterNew ) otb_add_test(NAME bfTvEstimateInnerProductPCAImageFilterDisableCenterData COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfEstimateInnerProductPCAImageFilterDisableCenterData.tif ${TEMP}/bfEstimateInnerProductPCAImageFilterDisableCenterData.tif otbEstimateInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfEstimateInnerProductPCAImageFilterDisableCenterData.tif 3 0 #center data ) otb_add_test(NAME bfTvEstimateInnerProductPCAImageFilterCP1 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfEstimateInnerProductPCAImageFilter_CP1.tif ${TEMP}/bfEstimateInnerProductPCAImageFilter_CP1.tif otbEstimateInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfEstimateInnerProductPCAImageFilter_CP1.tif 1 1 #center data ) otb_add_test(NAME bfTvEstimateInnerProductPCAImageFilterCP12 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfEstimateInnerProductPCAImageFilter_CP12.tif ${TEMP}/bfEstimateInnerProductPCAImageFilter_CP12.tif otbEstimateInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfEstimateInnerProductPCAImageFilter_CP12.tif 2 1 #center data ) otb_add_test(NAME bfTvEstimateInnerProductPCAImageFilter COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfEstimateInnerProductPCAImageFilter.tif ${TEMP}/bfEstimateInnerProductPCAImageFilter.tif otbEstimateInnerProductPCAImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfEstimateInnerProductPCAImageFilter.tif 3 1 #center data ) otb_add_test(NAME bfTuPCAImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbPCAImageFilterNewTest) otb_add_test(NAME bfTvPCAImageFilter2 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/bfTvPCAImageFilter2Inv.tif otbPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvPCAImageFilter2.tif -inv ${TEMP}/bfTvPCAImageFilter2Inv.tif -norm) otb_add_test(NAME bfTvPCAImageFilter4 COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvPCAImageFilter4.tif ${TEMP}/bfTvPCAImageFilter4.tif ${BASELINE}/bfTvPCAImageFilter4Inv.tif ${TEMP}/bfTvPCAImageFilter4Inv.tif otbPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvPCAImageFilter4.tif -inv ${TEMP}/bfTvPCAImageFilter4Inv.tif -n 4) otb_add_test(NAME bfTvPCAImageFilter4Norm COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvPCAImageFilter4Norm.tif ${TEMP}/bfTvPCAImageFilter4Norm.tif ${BASELINE}/bfTvPCAImageFilter4InvNorm.tif ${TEMP}/bfTvPCAImageFilter4InvNorm.tif otbPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvPCAImageFilter4Norm.tif -inv ${TEMP}/bfTvPCAImageFilter4InvNorm.tif -norm -n 4) otb_add_test(NAME bfTvPCAImageFilter3 COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvPCAImageFilter3.tif ${TEMP}/bfTvPCAImageFilter3.tif ${BASELINE}/bfTvPCAImageFilter3Inv.tif ${TEMP}/bfTvPCAImageFilter3Inv.tif otbPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvPCAImageFilter3.tif -inv ${TEMP}/bfTvPCAImageFilter3Inv.tif ) otb_add_test(NAME bfTvPCAImageFilter1 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/bfTvPCAImageFilter1Inv.tif otbPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvPCAImageFilter1.tif -inv ${TEMP}/bfTvPCAImageFilter1Inv.tif) otb_add_test(NAME bfTvPCAImageFilter3Norm COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvPCAImageFilter3Norm.tif ${TEMP}/bfTvPCAImageFilter3Norm.tif ${BASELINE}/bfTvPCAImageFilter3InvNorm.tif ${TEMP}/bfTvPCAImageFilter3InvNorm.tif otbPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvPCAImageFilter3Norm.tif -inv ${TEMP}/bfTvPCAImageFilter3InvNorm.tif -norm) otb_add_test(NAME bfTuAngularProjectionSetImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbAngularProjectionSetImageFilterNew) otb_add_test(NAME bfTuNAPCAImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbNAPCAImageFilterNewTest) otb_add_test(NAME bfTvNAPCAImageFilter1 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/bfTvNAPCAImageFilter1Inv.tif otbNAPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvNAPCAImageFilter1.tif -inv ${TEMP}/bfTvNAPCAImageFilter1Inv.tif) otb_add_test(NAME bfTvNAPCAImageFilter3 COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvNAPCAImageFilter3.tif ${TEMP}/bfTvNAPCAImageFilter3.tif ${BASELINE}/bfTvNAPCAImageFilter3Inv.tif ${TEMP}/bfTvNAPCAImageFilter3Inv.tif otbNAPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvNAPCAImageFilter3.tif -inv ${TEMP}/bfTvNAPCAImageFilter3Inv.tif -norm) otb_add_test(NAME bfTvNAPCAImageFilter2 COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/bfTvNAPCAImageFilter2Inv.tif otbNAPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvNAPCAImageFilter2.tif -inv ${TEMP}/bfTvNAPCAImageFilter2Inv.tif -norm) otb_add_test(NAME bfTvNAPCAImageFilter4 COMMAND otbDimensionalityReductionTestDriver --compare-n-images ${EPSILON_7} 2 ${BASELINE}/bfTvNAPCAImageFilter4.tif ${TEMP}/bfTvNAPCAImageFilter4.tif ${BASELINE}/bfTvNAPCAImageFilter4Inv.tif ${TEMP}/bfTvNAPCAImageFilter4Inv.tif otbNAPCAImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvNAPCAImageFilter4.tif -inv ${TEMP}/bfTvNAPCAImageFilter4Inv.tif -norm -n 4) otb_add_test(NAME bfTuInnerProductPCAImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbInnerProductPCAImageFilterNew ) otb_add_test(NAME bfTuSparseWvltToAngleMapperListFilterNew COMMAND otbDimensionalityReductionTestDriver otbSparseWvltToAngleMapperListFilterNew) otb_add_test(NAME bfTuAngularProjectionImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbAngularProjectionImageFilterNew) otb_add_test(NAME bfTuLocalActivityVectorImageFilterNew COMMAND otbDimensionalityReductionTestDriver otbLocalActivityVectorImageFilterNewTest) otb_add_test(NAME bfTvLocalActivityVectorImageFilter COMMAND otbDimensionalityReductionTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvLocalActivityVectorImageFilter.tif ${TEMP}/bfTvLocalActivityVectorImageFilter.tif otbLocalActivityVectorImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvLocalActivityVectorImageFilter.tif) otbAngularProjectionBinaryImageFilter.cxx000066400000000000000000000100571301006202600346560ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMath.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbAngularProjectionBinaryImageFilter.h" int otbAngularProjectionBinaryImageFilterNewTest ( int itkNotUsed(argc), char * itkNotUsed(argv)[] ) { const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image< PixelType, Dimension > ImageType; typedef double PrecisionType; typedef otb::AngularProjectionBinaryImageFilter< ImageType, ImageType, PrecisionType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbAngularProjectionBinaryImageFilterTest ( int argc, char * argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption( "--InputImages", "Input Images", "-in", 2, true ); parser->AddOption( "--OutputImages", "Generic name for output Images (_#.hdr will be added)", "-out", 1, true ); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs angular projection on 2 images\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName1(parseResult->GetParameterString("--InputImages", 0)); std::string inputImageName2(parseResult->GetParameterString("--InputImages", 1)); std::string outputImageName(parseResult->GetParameterString("--OutputImages")); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(inputImageName1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(inputImageName2); // Image filtering typedef otb::AngularProjectionBinaryImageFilter< ImageType, ImageType, PixelType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput1( reader1->GetOutput() ); filter->SetInput2( reader2->GetOutput() ); std::vector< PixelType > angle; angle.push_back( otb::CONST_PI_2 ); angle.push_back( 0. ); filter->SetAngleSet( angle ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); filter->Update(); typedef otb::ImageFileWriter< ImageType > WriterType; std::vector< WriterType::Pointer > writers; writers.resize( filter->GetNumberOfOutputs() ); for ( unsigned int i = 0; i < filter->GetNumberOfOutputs(); ++i ) { std::stringstream title; title << outputImageName << "_" << i << ".hdr"; writers[i] = WriterType::New(); writers[i]->SetFileName( title.str().c_str() ); writers[i]->SetInput( filter->GetOutput(i) ); writers[i]->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/otbAngularProjectionImageFilter.cxx000066400000000000000000000060611301006202600335700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbMath.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandLineArgumentParser.h" #include "otbAngularProjectionImageFilter.h" int otbAngularProjectionImageFilterTest ( int argc, char * argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption( "--InputImages", "Input Images", "-in", 2, true ); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs otbAngularProjectionImageFilterTest\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName1 = parseResult->GetParameterString("--InputImages", 0); std::string inputImageName2 = parseResult->GetParameterString("--InputImages", 1); std::string outputImageName = parseResult->GetOutputImage(); // Main type definition const unsigned int Dimension = 2; typedef float PixelType; typedef double PrecisionType; typedef itk::FixedArray< PrecisionType, 1 > AngleType; typedef otb::Image< PixelType, Dimension > ImageType; // Reading images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(inputImageName1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(inputImageName2); // Parameter (to be changed if necessary) AngleType angle; angle[0] = otb::CONST_PI_2; // Filtering typedef otb::AngularProjectionImageFilter< ImageType, ImageType, AngleType, PrecisionType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( 0, reader1->GetOutput() ); filter->SetInput( 1, reader2->GetOutput() ); filter->SetAngleArray( angle ); // Saving typedef otb::ImageFileWriter< ImageType > WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } otbAngularProjectionImageFilterNew.cxx000066400000000000000000000024021301006202600341560ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbMath.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandLineArgumentParser.h" #include "otbAngularProjectionImageFilter.h" int otbAngularProjectionImageFilterNew ( int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float PixelType; typedef double PrecisionType; typedef itk::FixedArray< PrecisionType, 1 > AngleType; typedef otb::Image< PixelType, Dimension > ImageType; typedef otb::AngularProjectionImageFilter< ImageType, ImageType, AngleType, PrecisionType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } otbAngularProjectionSetImageFilter.cxx000066400000000000000000000104001301006202600341550ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "otbMath.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandLineArgumentParser.h" #include "otbAngularProjectionSetImageFilter.h" int otbAngularProjectionSetImageFilterTest ( int argc, char * argv[] ) { const unsigned int Dimension = 2; const unsigned int SpaceDimension = 3; const unsigned int nbInputImages = SpaceDimension+1; typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption( "--InputImages", "Input Images", "-in", nbInputImages, true ); parser->AddOption( "--OutputImages", "Generic name for output Images (_#.hdr will be added)", "-out", 1, true ); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs otbAngularProjectionSetImageFilterTest with " << nbInputImages << " images\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName [ nbInputImages ]; for ( unsigned int i = 0; i < nbInputImages; i++ ) inputImageName[i] = parseResult->GetParameterString("--InputImages", i); std::string outputImageName = parseResult->GetParameterString("--OutputImages"); // Main type definition typedef float PixelType; typedef double PrecisionType; typedef itk::FixedArray< PrecisionType, SpaceDimension > AngleType; typedef itk::Statistics::ListSample< AngleType > AngleListType; typedef otb::Image< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; typedef otb::ObjectList< ReaderType > ReaderListType; ReaderListType::Pointer reader = ReaderListType::New(); reader->Resize( nbInputImages ); for ( unsigned int i = 0; i < nbInputImages; i++ ) { reader->SetNthElement(i, ReaderType::New()); reader->GetNthElement(i)->SetFileName( inputImageName[i].c_str() ); reader->GetNthElement(i)->Update(); } // Parameter (to be changed if necessary) // Here, we will have one output only AngleListType::Pointer angleList = AngleListType::New(); AngleType angle; for ( unsigned int i = 0; i < SpaceDimension; i++ ) { angle[i] = otb::CONST_PI / static_cast( SpaceDimension ); } angleList->PushBack( angle ); // Filter typedef otb::AngularProjectionSetImageFilter< ImageType, ImageType, AngleListType, PrecisionType > FilterType; FilterType::Pointer filter = FilterType::New(); for ( unsigned int i = 0; i < nbInputImages; i++ ) { filter->SetInput( i, reader->GetNthElement(i)->GetOutput() ); } filter->SetAngleList( angleList ); // Saving typedef otb::ImageFileWriter< ImageType > WriterType; typedef otb::ObjectList< WriterType > WriterListType; WriterListType::Pointer writers = WriterListType::New(); writers->Resize( filter->GetOutput()->Size() ); for ( unsigned int i = 0; i < writers->Size(); i++ ) { std::ostringstream title; title << outputImageName << "_" << i << ".hdr"; writers->SetNthElement(i, WriterType::New()); WriterType::Pointer writer = writers->GetNthElement(i); writer->SetFileName( title.str().c_str() ); writer->SetInput( filter->GetOutput()->GetNthElement(i) ); writer->Update(); } return EXIT_SUCCESS; } otbAngularProjectionSetImageFilterNew.cxx000066400000000000000000000026341301006202600346410ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "otbMath.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandLineArgumentParser.h" #include "otbAngularProjectionSetImageFilter.h" int otbAngularProjectionSetImageFilterNew ( int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; const unsigned int SpaceDimension = 3; typedef float PixelType; typedef double PrecisionType; typedef itk::FixedArray< PrecisionType, SpaceDimension > AngleType; typedef itk::Statistics::ListSample< AngleType > AngleListType; typedef otb::Image< PixelType, Dimension > ImageType; typedef otb::AngularProjectionSetImageFilter< ImageType, ImageType, AngleListType, PrecisionType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } otbDimensionalityReductionTestDriver.cxx000066400000000000000000000027321301006202600346340ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbNormalizeInnerProductPCAImageFilterNew); REGISTER_TEST(otbFastICAInternalOptimizerVectorImageFilterNewTest); REGISTER_TEST(otbFastICAImageFilterNewTest); REGISTER_TEST(otbFastICAImageFilterTest); REGISTER_TEST(otbNormalizeInnerProductPCAImageFilter); REGISTER_TEST(otbMaximumAutocorrelationFactorImageFilterNew); REGISTER_TEST(otbMaximumAutocorrelationFactorImageFilter); REGISTER_TEST(otbMNFImageFilterNewTest); REGISTER_TEST(otbMNFImageFilterTest); REGISTER_TEST(otbInnerProductPCAImageFilter); REGISTER_TEST(otbEstimateInnerProductPCAImageFilterNew); REGISTER_TEST(otbEstimateInnerProductPCAImageFilter); REGISTER_TEST(otbPCAImageFilterNewTest); REGISTER_TEST(otbPCAImageFilterTest); REGISTER_TEST(otbAngularProjectionSetImageFilterTest); REGISTER_TEST(otbAngularProjectionSetImageFilterNew); REGISTER_TEST(otbNAPCAImageFilterNewTest); REGISTER_TEST(otbNAPCAImageFilterTest); REGISTER_TEST(otbInnerProductPCAImageFilterNew); REGISTER_TEST(otbSparseWvltToAngleMapperListFilterNew); REGISTER_TEST(otbAngularProjectionImageFilterNew); REGISTER_TEST(otbAngularProjectionImageFilterTest); REGISTER_TEST(otbSparseWvltToAngleMapperListFilterNewTest); REGISTER_TEST(otbLocalActivityVectorImageFilterNewTest); REGISTER_TEST(otbLocalActivityVectorImageFilterTest); REGISTER_TEST(otbAngularProjectionBinaryImageFilterNewTest); REGISTER_TEST(otbAngularProjectionBinaryImageFilterTest); } otbEstimateInnerProductPCAImageFilter.cxx000066400000000000000000000036621301006202600345230ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbEstimateInnerProductPCAImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" int otbEstimateInnerProductPCAImageFilter(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; const char * inputFileName = argv[1]; const char * outputFilename = argv[2]; const unsigned int numberOfPrincipalComponentsRequired(atoi(argv[3])); const bool centerdata = atoi(argv[4]); typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::EstimateInnerProductPCAImageFilter PCAFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); PCAFilterType::Pointer pcafilter = PCAFilterType::New(); // Compute Inner Product raw pcafilter->SetNumberOfPrincipalComponentsRequired(numberOfPrincipalComponentsRequired); pcafilter->SetCenterData(centerdata); pcafilter->SetInput(reader->GetOutput()); pcafilter->Update(); writer->SetInput(pcafilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbEstimateInnerProductPCAImageFilterNew.cxx000066400000000000000000000021371301006202600351710ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbEstimateInnerProductPCAImageFilter.h" #include "otbVectorImage.h" int otbEstimateInnerProductPCAImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; // Typedef typedef otb::VectorImage ImageType; typedef otb::EstimateInnerProductPCAImageFilter FilterType; // Instantiation object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/otbFastICAImageFilter.cxx000066400000000000000000000126771301006202600313660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbFastICAImageFilter.h" int otbFastICAInternalOptimizerVectorImageFilterNewTest ( int itkNotUsed(argc), char* itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::FastICAInternalOptimizerVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbFastICAImageFilterNewTest ( int itkNotUsed(argc), char* itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::FastICAImageFilter< ImageType, ImageType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbFastICAImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOption( "--NumComponents", "Number of components to keep for output", "-n", 1, false ); parser->AddOption( "--Inverse", "Performs also the inverse transformation (give the output name)", "-inv", 1, false ); parser->AddOption( "--NumIterations", "number of iterations (def.20)", "-iter", 1, false ); parser->AddOption( "--Mu", "Give the increment weight of W in [0, 1] (def. 1)", "-mu", 1, false ); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " applies FastICA transformations\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); const unsigned int nbComponents = parseResult->IsOptionPresent("--NumComponents") ? parseResult->GetParameterUInt("--NumComponents") : 0; const unsigned int nbIterations = parseResult->IsOptionPresent("--NumIterations") ? parseResult->GetParameterUInt("--NumIterations") : 20; const double mu = parseResult->IsOptionPresent("--Mu" ) ? parseResult->GetParameterDouble("--Mu") : 1.; // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::FastICAImageFilter< ImageType, ImageType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); filter->SetNumberOfPrincipalComponentsRequired( nbComponents ); filter->SetNumberOfIterations( nbIterations ); filter->SetMu( mu ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); std::cerr << "Decomposition\n"; // Writing typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); // std::cerr << filter << "\n"; if ( parseResult->IsOptionPresent("--Inverse") ) { typedef otb::FastICAImageFilter< ImageType, ImageType, otb::Transform::INVERSE > InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); invFilter->SetInput( filter->GetOutput() ); invFilter->SetMeanValues( filter->GetMeanValues() ); invFilter->SetStdDevValues( filter->GetStdDevValues() ); invFilter->SetPCATransformationMatrix( filter->GetPCATransformationMatrix() ); invFilter->SetTransformationMatrix( filter->GetTransformationMatrix() ); typedef otb::CommandProgressUpdate< InvFilterType > CommandType2; CommandType2::Pointer invObserver = CommandType2::New(); invFilter->AddObserver( itk::ProgressEvent(), invObserver ); std::cerr << "Reconstruction\n"; ImageWriterType::Pointer invWriter = ImageWriterType::New(); invWriter->SetFileName( parseResult->GetParameterString("--Inverse") ); invWriter->SetInput( invFilter->GetOutput() ); invWriter->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/otbInnerProductPCAImageFilter.cxx000066400000000000000000000055371301006202600331110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbInnerProductPCAImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" int otbInnerProductPCAImageFilter(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; const char * inputFileName = argv[1]; const char * outputFilename = argv[2]; const bool generateMeanComponent(atoi(argv[3])); const bool centerdata = atoi(argv[4]); const unsigned int numberOfPrincipalComponentsRequired(atoi(argv[5])); const bool useUnbiasedEstimator = atoi(argv[6]); typedef otb::Image MonoImageType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter WriterType2; typedef otb::InnerProductPCAImageFilter PCAFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); PCAFilterType::Pointer pcafilter = PCAFilterType::New(); pcafilter->SetNumberOfPrincipalComponentsRequired(numberOfPrincipalComponentsRequired); pcafilter->SetGenerateMeanComponent(generateMeanComponent); pcafilter->SetCenterData(centerdata); pcafilter->SetInput(reader->GetOutput()); pcafilter->SetUseUnbiasedEstimator(useUnbiasedEstimator); writer->SetInput(pcafilter->GetOutput()); writer->Update(); typedef otb::MultiToMonoChannelExtractROI ExtractROIFilterType; unsigned int nbComponents = numberOfPrincipalComponentsRequired; if (generateMeanComponent == true) nbComponents += 1; for (unsigned int cpt = 0; cpt < nbComponents; ++cpt) { ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); WriterType2::Pointer writer2 = WriterType2::New(); extractROIFilter->SetInput(pcafilter->GetOutput()); extractROIFilter->SetChannel(cpt + 1); writer2->SetInput(extractROIFilter->GetOutput()); writer2->SetFileName(argv[cpt + 7]); writer2->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/otbInnerProductPCAImageFilterNew.cxx000066400000000000000000000020771301006202600335570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbInnerProductPCAImageFilter.h" #include "otbVectorImage.h" int otbInnerProductPCAImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; // Typedef typedef otb::VectorImage ImageType; typedef otb::InnerProductPCAImageFilter FilterType; // Instantiation object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/otbLocalActivityVectorImageFilter.cxx000066400000000000000000000073301301006202600340740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbLocalActivityVectorImageFilter.h" int otbLocalActivityVectorImageFilterNewTest ( int itkNotUsed(argc), char* itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::LocalActivityVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbLocalActivityVectorImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOption( "--Radius", "Set the radius of the sliding window (def.1)", "-r", 2, false ); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs the local activity estimation on a vector image\n"; std::cerr << "Local activity is defined here a the difference between pixel and mean of surrounding\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); unsigned int radiusX = 1; unsigned int radiusY = 1; if ( parseResult->IsOptionPresent("--Radius") ) { radiusX = parseResult->GetParameterUInt("--Radius", 0); radiusY = parseResult->GetParameterUInt("--Radius", 1); } // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::LocalActivityVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); FilterType::RadiusType radius = {{ radiusX, radiusY }}; filter->SetRadius( radius ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/otbMNFImageFilter.cxx000066400000000000000000000127461301006202600305710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbMNFImageFilter.h" #include "otbLocalActivityVectorImageFilter.h" int otbMNFImageFilterNewTest ( int itkNotUsed(argc), char* itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::LocalActivityVectorImageFilter< ImageType, ImageType > NoiseFilterType; typedef otb::MNFImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); typedef otb::MNFImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE > InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); return EXIT_SUCCESS; } int otbMNFImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOption( "--NumComponents", "Number of components to keep for output", "-n", 1, false ); parser->AddOption( "--Inverse", "Performs also the inverse transformation (give the output name)", "-inv", 1, false ); parser->AddOption( "--Radius", "Set the radius of the sliding window (def.1)", "-r", 2, false ); parser->AddOption( "--Normalize", "center and reduce data before MNF", "-norm", 0, false ); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " applies MNF transformations\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); const unsigned int nbComponents = parseResult->IsOptionPresent("--NumComponents") ? parseResult->GetParameterUInt("--NumComponents") : 0; unsigned int radiusX = 1; unsigned int radiusY = 1; if ( parseResult->IsOptionPresent("--Radius") ) { radiusX = parseResult->GetParameterUInt("--Radius", 0); radiusY = parseResult->GetParameterUInt("--Radius", 1); } const bool normalization = parseResult->IsOptionPresent("--Normalize"); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Noise filtering typedef otb::LocalActivityVectorImageFilter< ImageType, ImageType > NoiseFilterType; NoiseFilterType::RadiusType radius = {{ radiusX, radiusY }}; // Image filtering typedef otb::MNFImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); filter->SetNumberOfPrincipalComponentsRequired( nbComponents ); filter->SetUseNormalization( normalization ); filter->GetNoiseImageFilter()->SetRadius( radius ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); // Writing typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); if ( parseResult->IsOptionPresent("--Inverse") ) { typedef otb::MNFImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE > InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); invFilter->SetInput( filter->GetOutput() ); invFilter->SetMeanValues( filter->GetMeanValues() ); if ( normalization ) invFilter->SetStdDevValues( filter->GetStdDevValues() ); invFilter->SetTransformationMatrix( filter->GetTransformationMatrix() ); typedef otb::CommandProgressUpdate< InvFilterType > CommandType2; CommandType2::Pointer invObserver = CommandType2::New(); invFilter->AddObserver( itk::ProgressEvent(), invObserver ); ImageWriterType::Pointer invWriter = ImageWriterType::New(); invWriter->SetFileName( parseResult->GetParameterString("--Inverse") ); invWriter->SetInput( invFilter->GetOutput() ); invWriter->Update(); } return EXIT_SUCCESS; } otbMaximumAutocorrelationFactorImageFilter.cxx000066400000000000000000000035711301006202600357350ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMaximumAutocorrelationFactorImageFilter.h" typedef otb::VectorImage ImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MaximumAutocorrelationFactorImageFilter MADFilterType; int otbMaximumAutocorrelationFactorImageFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { MADFilterType::Pointer madFilter = MADFilterType::New(); return EXIT_SUCCESS; } int otbMaximumAutocorrelationFactorImageFilter(int itkNotUsed(argc), char* argv[]) { char * infname = argv[1]; char * outfname = argv[2]; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); MADFilterType::Pointer madFilter = MADFilterType::New(); madFilter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(madFilter->GetOutput()); writer->SetFileName(outfname); writer->Update(); std::cout<<"V: "<GetV()<GetAutoCorrelation()< ImageType; typedef otb::LocalActivityVectorImageFilter< ImageType, ImageType > NoiseFilterType; typedef otb::NAPCAImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); typedef otb::NAPCAImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE > InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); return EXIT_SUCCESS; } int otbNAPCAImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOption( "--NumComponents", "Number of components to keep for output", "-n", 1, false ); parser->AddOption( "--Inverse", "Performs also the inverse transformation (give the output name)", "-inv", 1, false ); parser->AddOption( "--Radius", "Set the radius of the sliding window (def.1)", "-r", 2, false ); parser->AddOption( "--Normalize", "center and reduce data before NAPCA", "-norm", 0, false ); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " applies NAPCA transformations\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); const unsigned int nbComponents = parseResult->IsOptionPresent("--NumComponents") ? parseResult->GetParameterUInt("--NumComponents") : 0; unsigned int radiusX = 1; unsigned int radiusY = 1; if ( parseResult->IsOptionPresent("--Radius") ) { radiusX = parseResult->GetParameterUInt("--Radius", 0); radiusY = parseResult->GetParameterUInt("--Radius", 1); } const bool normalization = parseResult->IsOptionPresent("--Normalize"); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Noise filtering typedef otb::LocalActivityVectorImageFilter< ImageType, ImageType > NoiseFilterType; NoiseFilterType::RadiusType radius = {{ radiusX, radiusY }}; // Image filtering typedef otb::NAPCAImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); filter->SetNumberOfPrincipalComponentsRequired( nbComponents ); filter->SetUseNormalization( normalization ); filter->GetNoiseImageFilter()->SetRadius( radius ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); // Writing typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); if ( parseResult->IsOptionPresent("--Inverse") ) { typedef otb::NAPCAImageFilter< ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE > InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); invFilter->SetInput( filter->GetOutput() ); invFilter->SetMeanValues( filter->GetMeanValues() ); if ( normalization ) invFilter->SetStdDevValues( filter->GetStdDevValues() ); invFilter->SetTransformationMatrix( filter->GetTransformationMatrix() ); typedef otb::CommandProgressUpdate< InvFilterType > CommandType2; CommandType2::Pointer invObserver = CommandType2::New(); invFilter->AddObserver( itk::ProgressEvent(), invObserver ); ImageWriterType::Pointer invWriter = ImageWriterType::New(); invWriter->SetFileName( parseResult->GetParameterString("--Inverse") ); invWriter->SetInput( invFilter->GetOutput() ); invWriter->Update(); } return EXIT_SUCCESS; } otbNormalizeInnerProductPCAImageFilter.cxx000066400000000000000000000032601301006202600347020ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbNormalizeInnerProductPCAImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" int otbNormalizeInnerProductPCAImageFilter(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; const char * inputFileName = argv[1]; const char * outputFilename = argv[2]; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::NormalizeInnerProductPCAImageFilter NormalizePCAFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); NormalizePCAFilterType::Pointer normalizepcafilter = NormalizePCAFilterType::New(); normalizepcafilter->SetInput(reader->GetOutput()); writer->SetInput(normalizepcafilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbNormalizeInnerProductPCAImageFilterNew.cxx000066400000000000000000000021431301006202600353530ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbNormalizeInnerProductPCAImageFilter.h" #include "otbVectorImage.h" int otbNormalizeInnerProductPCAImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; // Typedef typedef otb::VectorImage ImageType; typedef otb::NormalizeInnerProductPCAImageFilter FilterType; // Instantiation object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/otbPCAImageFilter.cxx000066400000000000000000000113431301006202600305440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbPCAImageFilter.h" int otbPCAImageFilterNewTest ( int itkNotUsed(argc), char* itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::PCAImageFilter< ImageType, ImageType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); typedef otb::PCAImageFilter< ImageType, ImageType, otb::Transform::INVERSE > InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); return EXIT_SUCCESS; } int otbPCAImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOption( "--NumComponents", "Number of components to keep for output", "-n", 1, false ); parser->AddOption( "--Inverse", "Performs also the inverse transformation (give the output name)", "-inv", 1, false ); parser->AddOption( "--Normalize", "center AND reduce data before PCA", "-norm", 0, false ); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " applies PCA transformations\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); const unsigned int nbComponents = parseResult->IsOptionPresent("--NumComponents") ? parseResult->GetParameterUInt("--NumComponents") : 0; const bool normalization = parseResult->IsOptionPresent("--Normalize"); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::PCAImageFilter< ImageType, ImageType, otb::Transform::FORWARD > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); filter->SetNumberOfPrincipalComponentsRequired( nbComponents ); filter->SetUseNormalization( normalization ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); // Writing typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); if ( parseResult->IsOptionPresent("--Inverse") ) { typedef otb::PCAImageFilter< ImageType, ImageType, otb::Transform::INVERSE > InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); invFilter->SetInput( filter->GetOutput() ); if ( normalization ) { invFilter->SetMeanValues( filter->GetMeanValues() ); invFilter->SetStdDevValues( filter->GetStdDevValues() ); } invFilter->SetTransformationMatrix( filter->GetTransformationMatrix() ); typedef otb::CommandProgressUpdate< InvFilterType > CommandType2; CommandType2::Pointer invObserver = CommandType2::New(); invFilter->AddObserver( itk::ProgressEvent(), invObserver ); ImageWriterType::Pointer invWriter = ImageWriterType::New(); invWriter->SetFileName( parseResult->GetParameterString("--Inverse") ); invWriter->SetInput( invFilter->GetOutput() ); invWriter->Update(); } return EXIT_SUCCESS; } otbSparseWvltToAngleMapperListFilter.cxx000066400000000000000000000105521301006202600345050ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletTransform.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandLineArgumentParser.h" #include "itkListSample.h" #include "otbSparseWvltToAngleMapperListFilter.h" int otbSparseWvltToAngleMapperListFilterNewTest ( int argc, char * argv[] ) { // number of images to consider const unsigned int Dimension = 2; const unsigned int nbInputImages = 2; typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption( "--InputImages", "Input Images", "-in", nbInputImages, true ); //parser->AddOption( "--OutputImages", "Generic name for output Images (_#.hdr will be added)", "-out", 1, true ); parser->AddOption( "--Threshold", "Lower threshold for accounting the waBinaryFunctorImageListToSampleListFiltervelet coeffs (def. 10)", "-th", 1, false ); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs otbSparseWvltToAngleMapperListFilterNewTest on " << nbInputImages << " images\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName [ nbInputImages ]; for ( unsigned int i = 0; i < nbInputImages; i++ ) inputImageName[i] = parseResult->GetParameterString("--InputImages", i); //const char * outputImageName = parseResult->GetParameterString("--OutputImages").c_str(); // Parameter (to be changed if necessary) const double threshold = parseResult->IsOptionPresent("--Threshold") ? parseResult->GetParameterDouble("--Threshold") : 10.; // Main type definition typedef float PixelType; typedef double PrecisionType; typedef itk::FixedArray< PrecisionType, nbInputImages-1 > AngleType; typedef itk::Statistics::ListSample< AngleType > AngleListType; typedef otb::Image< PixelType, Dimension > ImageType; typedef otb::ImageList< ImageType > ImageListType; // Reading input images typedef otb::ImageFileReader ReaderType; typedef otb::ObjectList< ReaderType > ReaderListType; ReaderListType::Pointer reader = ReaderListType::New(); reader->Resize( nbInputImages ); typedef otb::ObjectList< ImageListType > ListOfImageListType; ListOfImageListType::Pointer listOfInputImages = ListOfImageListType::New(); listOfInputImages->Resize( nbInputImages ); for ( unsigned int i = 0; i < nbInputImages; i++ ) { reader->SetNthElement(i, ReaderType::New()); reader->GetNthElement(i)->SetFileName( inputImageName[i].c_str() ); reader->GetNthElement(i)->Update(); // Here, we will have 'nbInputImages' image lists of one image each only listOfInputImages->SetNthElement(i, ImageListType::New() ); listOfInputImages->GetNthElement(i)->PushBack( reader->GetNthElement(i)->GetOutput() ); } // Filter typedef otb::SparseWvltToAngleMapperListFilter< ImageListType, AngleListType, nbInputImages > AngleListFilterType; AngleListFilterType::Pointer filter = AngleListFilterType::New(); for ( unsigned int i = 0; i < nbInputImages; i++ ) { filter->SetInput( i, listOfInputImages->GetNthElement(i) ); } filter->SetThresholdValue( threshold ); filter->Update(); std::cerr << "Number of sample found over " << threshold << " : " << filter->GetOutputSampleList()->Size() << "\n"; return EXIT_SUCCESS; } otbSparseWvltToAngleMapperListFilterNew.cxx000066400000000000000000000030711301006202600351550ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/DimensionalityReduction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletTransform.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandLineArgumentParser.h" #include "itkListSample.h" #include "otbSparseWvltToAngleMapperListFilter.h" int otbSparseWvltToAngleMapperListFilterNew ( int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; const unsigned int SpaceDimension = 3; typedef float PixelType; typedef double PrecisionType; typedef itk::FixedArray< PrecisionType, SpaceDimension > AngleType; typedef itk::Statistics::ListSample< AngleType > AngleListType; typedef otb::Image< PixelType, Dimension > ImageType; typedef otb::ImageList< ImageType > ImageListType; typedef otb::SparseWvltToAngleMapperListFilter< ImageListType, AngleListType, SpaceDimension+1 > AngleListFilterType; AngleListFilterType::Pointer filter = AngleListFilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/000077500000000000000000000000001301006202600223545ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/CMakeLists.txt000066400000000000000000000001521301006202600251120ustar00rootroot00000000000000project(OTBImageManipulation) set(OTBImageManipulation_LIBRARIES OTBImageManipulation) otb_module_impl() OTB-release-5.8/Modules/Filtering/ImageManipulation/include/000077500000000000000000000000001301006202600237775ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbAffineFunctor.h000066400000000000000000000036511301006202600274130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAffineFunctor_h #define otbAffineFunctor_h namespace otb { namespace Functor { /** \class AffineFunctor * \brief This functor performs a linear transform of its input. * * \f[ output = a*input + b \f] * * Coefficient a is a scalar, its type is templated (default is double). * Coefficient b has the same type as output type. Standard casting is applied * between input and output type. * * TInput and TOutput type are supposed to be scalar types. * * \ingroup OTBImageManipulation */ template class AffineFunctor { public: /// Constructor AffineFunctor() :m_A(0.), m_B(0.) {} /// Constructor virtual ~AffineFunctor() {} /// Accessors void SetA(TScale value) { m_A = value; } TScale GetA() { return m_A; } void SetB(TOutput value) { m_B = value; } TOutput GetB() { return m_B; } bool operator !=(const AffineFunctor& other) const { return ((m_A != other.GetA()) || (m_B != other.GetB())); } bool operator==(const AffineFunctor& other) const { return ((m_A == other.GetA()) && (m_B == other.GetB())); } // main computation method inline TOutput operator()(const TInput & x) const { return (m_B + static_cast(m_A*x)); } private: TScale m_A; TOutput m_B; }; } // End namespace Functor } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbAlphaBlendingFunctor.h000066400000000000000000000117611301006202600307140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAlphaBlendingFunctor_h #define otbAlphaBlendingFunctor_h #include "itkRGBAPixel.h" namespace otb { namespace Functor { /** * \class AlphaBlendingFunctor * \brief Implements simple blending * * For each channel the blending function is as follows: * \f[ P_{o} = (1 - \alpha) P_{i1} + \alpha P_{i2} \f] * with * \f[ \alpha = \alpha_{pix} * \alpha_{glo} \f] * \f$ \alpha_{pix} \f$ is retrieved from the second pixel RGBA * \f$ \alpha_{glo} \f$ is provided by the SetAlpha() method (1.0 by default) * * * \ingroup OTBImageManipulation */ template class ITK_EXPORT AlphaBlendingFunctorBase { public: AlphaBlendingFunctorBase(): m_Alpha(1.0) {} ~AlphaBlendingFunctorBase(){} typedef TInputPixel1 InputPixel1Type; typedef TInputPixel2 InputPixel2Type; typedef TOutputPixel OutputPixelType; virtual void SetAlpha(double a) { //Keep alpha between 0 and 1 m_Alpha = a<0.0?0.0:(a>1.0?1.0:a); } virtual double GetAlpha() const { return m_Alpha; } virtual inline OutputPixelType operator ()(InputPixel1Type input1, InputPixel2Type input2) const = 0; protected: double m_Alpha; }; template class ITK_EXPORT AlphaBlendingFunctor :public AlphaBlendingFunctorBase< TInputPixel1, TInputPixel2, TOutputPixel > { public: AlphaBlendingFunctor(){} ~AlphaBlendingFunctor(){} typedef TInputPixel1 InputPixel1Type; typedef TInputPixel2 InputPixel2Type; typedef TOutputPixel OutputPixelType; inline OutputPixelType operator ()(InputPixel1Type input1, InputPixel2Type input2) const { OutputPixelType resp; double alpha = this->GetAlpha(); resp = static_cast(vcl_floor(0.5 + (1.0 - alpha) * static_cast(input1) + alpha * static_cast(input2))); return resp; } protected: double m_Alpha; }; template class ITK_EXPORT AlphaBlendingFunctor< itk::RGBAPixel, itk::RGBAPixel, itk::RGBAPixel > : public AlphaBlendingFunctorBase, itk::RGBAPixel, itk::RGBAPixel > { public: AlphaBlendingFunctor(){} ~AlphaBlendingFunctor(){} typedef TInputInternalPixel1 InternalInputPixel1Type; typedef itk::RGBAPixel InputPixel1Type; typedef TInputInternalPixel2 InternalInputPixel2Type; typedef itk::RGBAPixel InputPixel2Type; typedef TOutputInternalPixel InternalOutputPixelType; typedef itk::RGBAPixel OutputPixelType; inline OutputPixelType operator ()(InputPixel1Type input1, InputPixel2Type input2) const { OutputPixelType resp; resp.Fill(itk::NumericTraits::max()); double alpha = static_cast(input2.GetAlpha()) / 255.0 * this->GetAlpha(); resp.SetRed(static_cast(vcl_floor(0.5 + (1.0 - alpha) * static_cast(input1.GetRed()) + alpha * static_cast(input2.GetRed()) ))); resp.SetGreen(static_cast(vcl_floor(0.5 + (1.0 - alpha) * static_cast(input1.GetGreen()) + alpha * static_cast(input2.GetGreen()) ))); resp.SetBlue(static_cast(vcl_floor(0.5 + (1.0 - alpha) * static_cast(input1.GetBlue()) + alpha * static_cast(input2.GetBlue()) ))); return resp; } protected: double m_Alpha; }; } } #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbAmplitudeFunctor.h000066400000000000000000000073421301006202600301500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAmplitudeFunctor_h #define otbAmplitudeFunctor_h #include "otbChannelSelectorFunctor.h" namespace otb { namespace Function { /** \class AmplitudeFunctor * \brief Compute the module from the selected channel in the input * * \ingroup Visualization * * \sa PhaseFunctor ChannelSelectorFunctor * * \ingroup OTBImageManipulation */ template class AmplitudeFunctor : public ChannelSelectorFunctor { public: /** Standard class typedefs */ typedef AmplitudeFunctor Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory */ itkNewMacro(Self); /** Runtime information */ itkTypeMacro(AmplitudeFunctor, itk::Object); typedef TInputPixel PixelType; typedef typename itk::NumericTraits::ValueType ScalarType; typedef itk::VariableLengthVector VectorPixelType; typedef itk::RGBPixel RGBPixelType; typedef itk::RGBAPixel RGBAPixelType; typedef VectorPixelType OutputPixelType; /** Constructor */ AmplitudeFunctor() { std::vector channels; channels.push_back(0); channels.push_back(1); this->SetChannelList(channels); } /** Destructor */ ~AmplitudeFunctor() ITK_OVERRIDE {} const char *GetDescription() const {return "Amplitude"; } unsigned int GetOutputSize() const ITK_OVERRIDE { return 1; } OutputPixelType operator ()(const VectorPixelType& inPixel) const ITK_OVERRIDE { OutputPixelType outPixel; outPixel.SetSize(1); assert((this->GetChannelList()).size() == 2); assert((this->GetChannelList())[0] < inPixel.Size()); assert((this->GetChannelList())[1] < inPixel.Size()); outPixel[0] = ComputeAmplitude(inPixel[(this->GetChannelList())[0]], inPixel[(this->GetChannelList())[1]]); return outPixel; } OutputPixelType operator ()(ScalarType) const ITK_OVERRIDE { //FIXME we don't handle the std::complex<> yet itkExceptionMacro(<< "Can't compute amplitude from a scalar value"); } OutputPixelType operator ()(const RGBPixelType& inPixel) const ITK_OVERRIDE { OutputPixelType outPixel; outPixel.SetSize(1); assert((this->GetChannelList()).size() == 2); assert((this->GetChannelList())[0] < 3); assert((this->GetChannelList())[1] < 3); outPixel[0] = ComputeAmplitude(inPixel[(this->GetChannelList())[0]], inPixel[(this->GetChannelList())[1]]); return outPixel; } OutputPixelType operator ()(const RGBAPixelType& inPixel) const ITK_OVERRIDE { OutputPixelType outPixel; outPixel.SetSize(1); assert((this->GetChannelList()).size() == 2); assert((this->GetChannelList())[0] < 4); assert((this->GetChannelList())[1] < 4); outPixel[0] = ComputeAmplitude(inPixel[(this->GetChannelList())[0]], inPixel[(this->GetChannelList())[1]]); return outPixel; } private: inline ScalarType ComputeAmplitude(ScalarType a, ScalarType b) const { return vcl_sqrt(a * a + b * b); } }; } } #endif otbBinaryFunctorNeighborhoodImageFilter.h000066400000000000000000000137311301006202600340310ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryFunctorNeighborhoodImageFilter_h #define otbBinaryFunctorNeighborhoodImageFilter_h #include "itkImageToImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkSize.h" namespace otb { /** \class BinaryFunctorNeighborhoodImageFilter * \brief Implements neighborhood-wise generic operation of two images. * * This class is parameterized over the types of the two input images * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \example ChangeDetection/ChangeDetectionFrameworkExample.cxx * * * \ingroup OTBImageManipulation */ template class ITK_EXPORT BinaryFunctorNeighborhoodImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef BinaryFunctorNeighborhoodImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BinaryFunctorNeighborhoodImageFilter, BinaryFunctorImageFilter); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef TInputImage1 Input1ImageType; typedef typename Input1ImageType::ConstPointer Input1ImageConstPointer; typedef typename Input1ImageType::Pointer Input1ImagePointer; typedef typename Input1ImageType::RegionType Input1ImageRegionType; typedef typename Input1ImageType::PixelType Input1ImagePixelType; typedef TInputImage2 Input2ImageType; typedef typename Input2ImageType::ConstPointer Input2ImageConstPointer; typedef typename Input2ImageType::Pointer Input2ImagePointer; typedef typename Input2ImageType::RegionType Input2ImageRegionType; typedef typename Input2ImageType::PixelType Input2ImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /** Connect one of the operands for pixel-wise addition */ void SetInput1(const TInputImage1 * image1); /** Connect one of the operands for pixel-wise addition */ void SetInput2(const TInputImage2 * image2); /** Get the inputs */ const TInputImage1 * GetInput1(); const TInputImage2 * GetInput2(); /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType1; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType2; typedef typename NeighborhoodIteratorType1::RadiusType RadiusType1; typedef typename NeighborhoodIteratorType2::RadiusType RadiusType2; typedef typename itk::Size RadiusSizeType; itkSetMacro(Radius, RadiusSizeType); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } protected: BinaryFunctorNeighborhoodImageFilter(); ~BinaryFunctorNeighborhoodImageFilter() ITK_OVERRIDE {} /** BinaryFunctorNeighborhoodImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Pad the inputs requested regions by radius */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; RadiusSizeType m_Radius; private: BinaryFunctorNeighborhoodImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBinaryFunctorNeighborhoodImageFilter.txx" #endif #endif otbBinaryFunctorNeighborhoodImageFilter.txx000066400000000000000000000210451301006202600344220ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryFunctorNeighborhoodImageFilter_txx #define otbBinaryFunctorNeighborhoodImageFilter_txx #include "otbBinaryFunctorNeighborhoodImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template BinaryFunctorNeighborhoodImageFilter ::BinaryFunctorNeighborhoodImageFilter() { this->SetNumberOfRequiredInputs(2); m_Radius.Fill(3); } /** * Connect one of the operands for neighborhood-wise operation */ template void BinaryFunctorNeighborhoodImageFilter ::SetInput1(const TInputImage1 * image1) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast(image1)); } /** * Connect one of the operands for neighborhood-wise operation */ template void BinaryFunctorNeighborhoodImageFilter ::SetInput2(const TInputImage2 * image2) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast(image2)); } template const TInputImage1 * BinaryFunctorNeighborhoodImageFilter ::GetInput1() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TInputImage2 * BinaryFunctorNeighborhoodImageFilter ::GetInput2() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void BinaryFunctorNeighborhoodImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output Input1ImagePointer inputPtr1 = const_cast(this->GetInput1()); Input2ImagePointer inputPtr2 = const_cast(this->GetInput2()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr1 || !inputPtr2 || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage1::RegionType inputRequestedRegion1, inputRequestedRegion2; inputRequestedRegion1 = inputPtr1->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion1.PadByRadius(m_Radius); inputRequestedRegion2 = inputRequestedRegion1; // crop the input requested region at the input's largest possible region if (inputRequestedRegion1.Crop(inputPtr1->GetLargestPossibleRegion())) { inputPtr1->SetRequestedRegion(inputRequestedRegion1); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr1->SetRequestedRegion(inputRequestedRegion1); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(inputPtr1); throw e; } if (inputRequestedRegion2.Crop(inputPtr2->GetLargestPossibleRegion())) { inputPtr2->SetRequestedRegion(inputRequestedRegion2); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr2->SetRequestedRegion(inputRequestedRegion2); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(inputPtr2); throw e; } return; } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void BinaryFunctorNeighborhoodImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { //unsigned int i; itk::ZeroFluxNeumannBoundaryCondition nbc1; itk::ZeroFluxNeumannBoundaryCondition nbc2; // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImage1 so it cannot be used for the second input. Input1ImageConstPointer inputPtr1 = dynamic_cast(ProcessObjectType::GetInput(0)); Input2ImageConstPointer inputPtr2 = dynamic_cast(ProcessObjectType::GetInput(1)); OutputImagePointer outputPtr = this->GetOutput(0); RadiusType1 r1; r1[0] = m_Radius[0]; r1[1] = m_Radius[1]; NeighborhoodIteratorType1 neighInputIt1; RadiusType2 r2; r2[0] = m_Radius[0]; r2[1] = m_Radius[1]; NeighborhoodIteratorType2 neighInputIt2; itk::ImageRegionIterator outputIt; // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList1; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC1; faceList1 = bC1(inputPtr1, outputRegionForThread, r1); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList2; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC2; faceList2 = bC2(inputPtr2, outputRegionForThread, r2); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit1; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit2; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit1 = faceList1.begin(), fit2 = faceList2.begin(); fit1 != faceList1.end() && fit2 != faceList2.end(); ++fit1, ++fit2) { neighInputIt1 = itk::ConstNeighborhoodIterator(r1, inputPtr1, *fit1); neighInputIt2 = itk::ConstNeighborhoodIterator(r2, inputPtr2, *fit2); // outputIt = itk::ImageRegionIterator(outputPtr, outputRegionForThread); outputIt = itk::ImageRegionIterator(outputPtr, *fit1); neighInputIt1.OverrideBoundaryCondition(&nbc1); neighInputIt1.GoToBegin(); neighInputIt2.OverrideBoundaryCondition(&nbc2); neighInputIt2.GoToBegin(); while (!outputIt.IsAtEnd()) { outputIt.Set(m_Functor(neighInputIt1, neighInputIt2)); ++neighInputIt1; ++neighInputIt2; ++outputIt; progress.CompletedPixel(); } } } } // end namespace otb #endif otbBinaryFunctorNeighborhoodVectorImageFilter.h000066400000000000000000000136521301006202600352160ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryFunctorNeighborhoodVectorImageFilter_h #define otbBinaryFunctorNeighborhoodVectorImageFilter_h #include "itkInPlaceImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" namespace otb { /** \class BinaryFunctorNeighborhoodVectorImageFilter * \brief Implements neighborhood-wise generic operation of two images being vector images. * * This class is parameterized over the types of the two input images * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT BinaryFunctorNeighborhoodVectorImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef BinaryFunctorNeighborhoodVectorImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BinaryFunctorNeighborhoodVectorImageFilter, InPlaceImageFilter); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef TInputImage1 Input1ImageType; typedef typename Input1ImageType::ConstPointer Input1ImagePointer; typedef typename Input1ImageType::RegionType Input1ImageRegionType; typedef typename Input1ImageType::PixelType Input1ImagePixelType; typedef TInputImage2 Input2ImageType; typedef typename Input2ImageType::ConstPointer Input2ImagePointer; typedef typename Input2ImageType::RegionType Input2ImageRegionType; typedef typename Input2ImageType::PixelType Input2ImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /** Connect one of the operands for pixel-wise addition */ void SetInput1(const TInputImage1 * image1); /** Connect one of the operands for pixel-wise addition */ void SetInput2(const TInputImage2 * image2); /** Connect the set of radius. In fact, Self keeps the larger size * only to define neighborhood parameters, and gives the min and max * radius to the functor. */ void SetRadius(const unsigned char& min, const unsigned char& max); /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType1; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType2; typedef typename NeighborhoodIteratorType1::RadiusType RadiusType1; typedef typename NeighborhoodIteratorType2::RadiusType RadiusType2; typedef unsigned char RadiusSizeType; itkSetMacro(Radius, RadiusSizeType); protected: BinaryFunctorNeighborhoodVectorImageFilter(); ~BinaryFunctorNeighborhoodVectorImageFilter() ITK_OVERRIDE {} /** BinaryFunctorNeighborhoodVectorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Since the number of components per pixel depends on the radius range, one must reimplement * this method to set the proper number of component on the filter output. */ void GenerateOutputInformation(void) ITK_OVERRIDE; RadiusSizeType m_Radius; private: BinaryFunctorNeighborhoodVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBinaryFunctorNeighborhoodVectorImageFilter.txx" #endif #endif otbBinaryFunctorNeighborhoodVectorImageFilter.txx000066400000000000000000000136361301006202600356140ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryFunctorNeighborhoodVectorImageFilter_txx #define otbBinaryFunctorNeighborhoodVectorImageFilter_txx #include "otbBinaryFunctorNeighborhoodVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template BinaryFunctorNeighborhoodVectorImageFilter ::BinaryFunctorNeighborhoodVectorImageFilter() { this->SetNumberOfRequiredInputs(2); this->InPlaceOff(); m_Radius = 3; } /** * Connect one of the operands for neighborhood-wise operation */ template void BinaryFunctorNeighborhoodVectorImageFilter ::SetInput1(const TInputImage1 * image1) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast(image1)); } /** * Connect one of the operands for neighborhood-wise operation */ template void BinaryFunctorNeighborhoodVectorImageFilter ::SetInput2(const TInputImage2 * image2) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast(image2)); } /** * Connect the interval of radius */ template void BinaryFunctorNeighborhoodVectorImageFilter ::SetRadius(const unsigned char& min, const unsigned char& max) { this->SetRadius(max); GetFunctor().SetRadius(min, max); } /** * Generate the output information */ template void BinaryFunctorNeighborhoodVectorImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); int nbComponents = static_cast(m_Functor.GetRadiusMax()) + 1 - static_cast(m_Functor.GetRadiusMin()); this->GetOutput()->SetNumberOfComponentsPerPixel(nbComponents); } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void BinaryFunctorNeighborhoodVectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itk::ZeroFluxNeumannBoundaryCondition nbc1; itk::ZeroFluxNeumannBoundaryCondition nbc2; Input1ImagePointer inputPtr1 = dynamic_cast(ProcessObjectType::GetInput(0)); Input2ImagePointer inputPtr2 = dynamic_cast(ProcessObjectType::GetInput(1)); RadiusType1 r1; r1.Fill(m_Radius); NeighborhoodIteratorType1 neighInputIt1; RadiusType2 r2; r2.Fill(m_Radius); NeighborhoodIteratorType2 neighInputIt2; // This is the main difference from BinaryFunctorNeighborhoodImageFilter::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, itk::ThreadIdType threadId) OutputImagePointer outputPtr = this->GetOutput(); outputPtr->SetNumberOfComponentsPerPixel(m_Functor.GetNumberOfComponentsPerPixel()); outputPtr->Allocate(); itk::ImageRegionIterator outputIt; // Find the data-set boundary "faces" typedef typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator TypeFace1; typename TypeFace1::FaceListType::iterator fit1; typename TypeFace1::FaceListType faceList1; TypeFace1 bC1; faceList1 = bC1(inputPtr1, outputRegionForThread, r1); typedef typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator TypeFace2; typename TypeFace2::FaceListType::iterator fit2; typename TypeFace2::FaceListType faceList2; TypeFace2 bC2; faceList2 = bC2(inputPtr2, outputRegionForThread, r2); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. // Center first and then left, right, up, down borders for (fit1 = faceList1.begin(), fit2 = faceList2.begin(); fit1 != faceList1.end() && fit2 != faceList2.end(); ++fit1, ++fit2) { neighInputIt1 = itk::ConstNeighborhoodIterator (r1, inputPtr1, *fit1); neighInputIt1.OverrideBoundaryCondition(&nbc1); neighInputIt1.GoToBegin(); neighInputIt2 = itk::ConstNeighborhoodIterator (r2, inputPtr2, *fit2); neighInputIt2.OverrideBoundaryCondition(&nbc2); neighInputIt2.GoToBegin(); outputIt = itk::ImageRegionIterator (outputPtr, *fit1); outputIt.GoToBegin(); while (!outputIt.IsAtEnd()) { outputIt.Set(m_Functor(neighInputIt1, neighInputIt2)); ++neighInputIt1; ++neighInputIt2; ++outputIt; progress.CompletedPixel(); } } } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbBinaryImageDensityFunction.h000066400000000000000000000102101301006202600321040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryImageDensityFunction_h #define otbBinaryImageDensityFunction_h #include "itkImageFunction.h" #include "itkNumericTraits.h" namespace otb { /** * \class BinaryImageDensityFunction * \brief Calculate the density pixel of in the neighborhood of a pixel * * Calculate the variance pixel value over the standard 8, 26, etc. connected * neighborhood. This calculation uses a ZeroFluxNeumannBoundaryCondition. * * If called with a ContinuousIndex or Point, the calculation is performed * at the nearest neighbor. * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double ). * * \ingroup ImageFunctions * * \ingroup OTBImageManipulation */ template class ITK_EXPORT BinaryImageDensityFunction : public itk::ImageFunction::RealType, TCoordRep> { public: /** Standard class typedefs. */ typedef BinaryImageDensityFunction Self; typedef itk::ImageFunction::RealType, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(BinaryImageDensityFunction, itk::ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename InputImageType::SizeType RadiusType; typedef typename Superclass::OutputType OutputType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Datatype used for the density */ typedef typename itk::NumericTraits::RealType RealType; /** Evalulate the function at specified index */ RealType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ RealType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } RealType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the statistics are evaluated */ itkSetMacro(NeighborhoodRadius, RadiusType); itkGetConstReferenceMacro(NeighborhoodRadius, RadiusType); void SetNeighborhoodRadius(unsigned int rad) { m_NeighborhoodRadius.Fill(rad); this->Modified(); } protected: BinaryImageDensityFunction(); ~BinaryImageDensityFunction() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BinaryImageDensityFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented RadiusType m_NeighborhoodRadius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbBinaryImageDensityFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbBinaryImageDensityFunction.txx000066400000000000000000000047301301006202600325120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryImageDensityFunction_txx #define otbBinaryImageDensityFunction_txx #include "otbBinaryImageDensityFunction.h" #include "itkConstNeighborhoodIterator.h" namespace otb { /** * Constructor */ template BinaryImageDensityFunction ::BinaryImageDensityFunction() { m_NeighborhoodRadius.Fill(1); } /** * */ template void BinaryImageDensityFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "NeighborhoodRadius: " << m_NeighborhoodRadius << std::endl; } /** * */ template typename BinaryImageDensityFunction ::RealType BinaryImageDensityFunction ::EvaluateAtIndex(const IndexType& index) const { RealType sum; RealType var; sum = itk::NumericTraits::Zero; if (!this->GetInputImage()) { return (itk::NumericTraits::max()); } if (!this->IsInsideBuffer(index)) { return (itk::NumericTraits::max()); } // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize = m_NeighborhoodRadius; itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Walk the neighborhood const unsigned int size = it.Size(); for (unsigned int i = 0; i < size; ++i) { const RealType value = static_cast(it.GetPixel(i)); sum += value; } const RealType num = static_cast(size); var = sum / num; return var; } } // end namespace otb #endif otbBinaryImageMinimalBoundingRegionCalculator.h000066400000000000000000000061621301006202600351450ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryImageMinimalBoundingRegionCalculator_h #define otbBinaryImageMinimalBoundingRegionCalculator_h #include "itkImageToImageFilter.h" #include "itkObjectFactory.h" namespace otb { /** * \class BinaryImageMinimalBoundingRegionCalculator * \brief This class compute the smallest region of the image * containing every pixel with the foreground value. * * This class is used for instance in the RCC8 calculator filter, * where the input region used for computation has to be the smallest possible * for costs reasons. The Pad arg allows the user to get a region of pad pixel larger * at each bound in case a security margin has to be kept. * * \sa ImageToImageRCC8Calculator * * \ingroup OTBImageManipulation */ template class ITK_EXPORT BinaryImageMinimalBoundingRegionCalculator : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef BinaryImageMinimalBoundingRegionCalculator Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(BinaryImageMinimalBoundingRegionCalculator, ImageToImageFilter); typedef TInputImage InputImageType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::Pointer InputImagePointerType; /** Toogle the pad option */ itkGetMacro(Region, RegionType); itkSetMacro(InsideValue, PixelType); itkGetMacro(InsideValue, PixelType); itkSetMacro(Pad, unsigned int); itkGetMacro(Pad, unsigned int); protected: /** Constructor */ BinaryImageMinimalBoundingRegionCalculator(); /** Destructor */ ~BinaryImageMinimalBoundingRegionCalculator() ITK_OVERRIDE {} /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BinaryImageMinimalBoundingRegionCalculator(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** The computed region */ RegionType m_Region; /** Toogle if pad wanted */ unsigned int m_Pad; /** Inside value */ PixelType m_InsideValue; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBinaryImageMinimalBoundingRegionCalculator.txx" #endif #endif otbBinaryImageMinimalBoundingRegionCalculator.txx000066400000000000000000000100161301006202600355320ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryImageMinimalBoundingRegionCalculator_txx #define otbBinaryImageMinimalBoundingRegionCalculator_txx #include "otbBinaryImageMinimalBoundingRegionCalculator.h" #include "itkImageSliceConstIteratorWithIndex.h" #include "otbMacro.h" namespace otb { /* * Constructor */ template BinaryImageMinimalBoundingRegionCalculator ::BinaryImageMinimalBoundingRegionCalculator() { // The pad option is desactivated by default m_Pad = 0; // Set the default region typename InputImageType::SizeType size; typename InputImageType::IndexType index; size[0] = 0; size[1] = 0; index[0] = 0; index[1] = 0; m_Region.SetSize(size); m_Region.SetIndex(index); m_InsideValue = static_cast(255); } /** * Main computation method */ template void BinaryImageMinimalBoundingRegionCalculator ::GenerateData(void) { // Input images pointers const InputImageType* image = this->GetInput(); // Iterator definition typedef itk::ImageSliceConstIteratorWithIndex SliceIteratorType; // Indexes containing upper-left and lower-right corner typename InputImageType::IndexType min; typename InputImageType::IndexType max; min[0] = 0; min[1] = 0; max[1] = 0; max[1] = 0; for (unsigned int axis = 0; axis < InputImageType::ImageDimension; ++axis) { // Create the forward iterator to find lower bound SliceIteratorType fit(image, image->GetLargestPossibleRegion()); fit.SetFirstDirection(!axis); fit.SetSecondDirection(axis); fit.GoToBegin(); // Walk through the two images line by line while (!fit.IsAtEnd()) { while (!fit.IsAtEndOfSlice()) { while (!fit.IsAtEndOfLine()) { // If a common intersection is found if (fit.Get() == m_InsideValue) { // then the lower bound is found min[axis] = fit.GetIndex()[axis]; fit.GoToReverseBegin(); // skip to the end break; } ++fit; } fit.NextLine(); } fit.NextSlice(); } // Create the reverse iterator to find upper bound SliceIteratorType rit(image, image->GetLargestPossibleRegion()); rit.SetFirstDirection(!axis); rit.SetSecondDirection(axis); rit.GoToReverseBegin(); // Walk through the two images line by line while (!rit.IsAtReverseEnd()) { while (!rit.IsAtReverseEndOfSlice()) { while (!rit.IsAtReverseEndOfLine()) { // If a common intersection is found if (rit.Get() == m_InsideValue) { max[axis] = rit.GetIndex()[axis]; rit.GoToBegin(); //Skip to reverse end break; } --rit; } rit.PreviousLine(); } rit.PreviousSlice(); } } typename InputImageType::SizeType size; typename InputImageType::IndexType index; for (unsigned int i = 0; i < InputImageType::ImageDimension; ++i) { size[i] = max[i] - min[i] + 1; index[i] = min[i]; } m_Region.SetIndex(index); m_Region.SetSize(size); if (m_Pad) { m_Region.PadByRadius(m_Pad); } m_Region.Crop(image->GetLargestPossibleRegion()); } /** * PrintSelf method */ template void BinaryImageMinimalBoundingRegionCalculator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbBinaryImageToDensityImageFilter.h000066400000000000000000000066141301006202600330270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryImageToDensityImageFilter_h #define otbBinaryImageToDensityImageFilter_h #include "itkImageToImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" namespace otb { /** \class BinaryImageToDensityImageFilter * \brief This class performs a streaming isotropic shrinking operation without smoothing. * * * \ingroup OTBImageManipulation */ template class ITK_EXPORT BinaryImageToDensityImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef BinaryImageToDensityImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(BinaryImageToDensityImageFilter, itk::ImageToImageFilter); /** Template parameter typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::SizeType InputImageSizeType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef TCountFunction CountFunctionType; typedef typename CountFunctionType::Pointer CountFunctionPointerType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::RadiusType RadiusType; /** Shrink factor accessor */ itkSetMacro(NeighborhoodRadius, RadiusType); itkGetMacro(NeighborhoodRadius, RadiusType); void SetNeighborhoodRadius(unsigned int rad) { m_NeighborhoodRadius.Fill(rad); this->Modified(); } /** Main computation method */ void ThreadedGenerateData(const InputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; protected: /** Constructor */ BinaryImageToDensityImageFilter(); /** Destructor */ ~BinaryImageToDensityImageFilter() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BinaryImageToDensityImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CountFunctionPointerType m_CountFunction; /** The shrink factor */ RadiusType m_NeighborhoodRadius; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBinaryImageToDensityImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbBinaryImageToDensityImageFilter.txx000066400000000000000000000131051301006202600334140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinaryImageToDensityImageFilter_txx #define otbBinaryImageToDensityImageFilter_txx #include "otbBinaryImageToDensityImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkZeroFluxNeumannBoundaryCondition.h" #include "itkNeighborhoodAlgorithm.h" #include "otbMacro.h" namespace otb { /** Constructor */ template BinaryImageToDensityImageFilter ::BinaryImageToDensityImageFilter() { m_NeighborhoodRadius.Fill(1); m_CountFunction = CountFunctionType::New(); } /** Destructor */ template BinaryImageToDensityImageFilter ::~BinaryImageToDensityImageFilter() {} template void BinaryImageToDensityImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output InputImagePointerType inputPtr = const_cast(this->GetInput()); OutputImagePointerType outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) InputImageRegionType inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_NeighborhoodRadius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void BinaryImageToDensityImageFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); m_CountFunction->SetInputImage(this->GetInput()); m_CountFunction->SetNeighborhoodRadius(m_NeighborhoodRadius); } /** Main computation method */ template void BinaryImageToDensityImageFilter ::ThreadedGenerateData(const InputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImagePointerType inputPtr = const_cast (this->GetInput()); OutputImagePointerType outputPtr = this->GetOutput(); itk::ZeroFluxNeumannBoundaryCondition nbc; RadiusType r; r[0] = m_NeighborhoodRadius[0]; r[1] = m_NeighborhoodRadius[1]; NeighborhoodIteratorType it; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(inputPtr, outputRegionForThread, r); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::ImageRegionIterator itOut(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); typename InputImageType::IndexType index; for (fit = faceList.begin(); fit != faceList.end(); ++fit) { it = itk::ConstNeighborhoodIterator(r, inputPtr, *fit); itOut = itk::ImageRegionIterator(outputPtr, *fit); it.OverrideBoundaryCondition(&nbc); it.GoToBegin(); while (!itOut.IsAtEnd()) { index = it.GetIndex(); if (outputRegionForThread.IsInside(index)) { itOut.Set(m_CountFunction->EvaluateAtIndex(index)); } ++itOut; ++it; progress.CompletedPixel(); // potential exception thrown here } } } /** PrintSelf method */ template void BinaryImageToDensityImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Neighborhood Radius : " << m_NeighborhoodRadius << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbBinarySpectralAngleFunctor.h000066400000000000000000000036451301006202600321170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBinarySpectralAngleFunctor_h #define otbBinarySpectralAngleFunctor_h #include #include "otbMath.h" namespace otb { /** \class BinarySpectralAngleFunctor * \brief This functor computes the spectral angle between two pixels. * * It can be used as a functor in a BinaryFunctorImageFilter to * compute the pixel-by-pixel spectral angles. * * \ingroup OTBImageManipulation */ namespace Functor { template class BinarySpectralAngleFunctor { public: BinarySpectralAngleFunctor() { } virtual ~BinarySpectralAngleFunctor() {} // Binary operator inline TOutputValue operator ()(const TInput1& a, const TInput2& b) const { const double Epsilon = 1E-10; double dist = 0.0; double scalarProd = 0.0; double norma = 0.0; double normb = 0.0; double sqrtNormProd = 0.0; for (unsigned int i = 0; i < std::min(a.Size(), b.Size()); ++i) { scalarProd += a[i] * b[i]; norma += a[i] * a[i]; normb += b[i] * b[i]; } sqrtNormProd = vcl_sqrt(norma * normb); if ( vcl_abs(sqrtNormProd) < Epsilon || scalarProd / sqrtNormProd > 1 ) { dist = 0.0; } else { dist = vcl_acos(scalarProd / sqrtNormProd); } return static_cast(dist); } }; } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbBoxAndWhiskerImageFilter.h000066400000000000000000000106131301006202600314770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoxAndWhiskerImageFilter_h #define otbBoxAndWhiskerImageFilter_h #include "itkMacro.h" #include "itkUnaryFunctorImageFilter.h" namespace otb { /** \class BoxAndWhiskerImageFilter * \brief This class performs the detection of outlier with the Box and Whisker technique * * This is appropriated to perform simple outlier detection over vector data. * The input image has to contain vector pixel through a VectorImage type. * When an outlier is detected, it is treated to as an missing value through the function * \code otb::EuclideanDistanceMetricWithMissingValue::SetToMissingValue() \endcode. * * A component is considered to as a missing value when * \f$ \| x_i - \beta \left( x_{3/4} - x_{1/4} \right) \| > \| x_{1/2} \| \f$ * where \f$ x_{1/4}, x_{1/2}, x_{3/4} \f$ stand for the first, second (median) and * third quantile values. * * \ingroup Streamed * \sa EuclideanDistanceMetricWithMissingValue * * \ingroup OTBImageManipulation */ template class ITK_EXPORT BoxAndWhiskerImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef BoxAndWhiskerImageFilter Self; typedef typename itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BoxAndWhiskerImageFilter, InPlaceImageFilter); /** Template parameters typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointer OutputImagePointer; typedef typename Superclass::OutputImageRegionType OutputImageRegionType; typedef typename Superclass::OutputImagePixelType OutputImagePixelType; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointer; typedef typename Superclass::InputImageConstPointer InputImageConstPointer; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename Superclass::InputImagePixelType InputImagePixelType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType ValueType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::RegionType RegionType; /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension); /** Get the Radius (all to 1) */ itkSetMacro(Radius, SizeType); itkGetConstReferenceMacro(Radius, SizeType); /** Fix the whisker */ itkGetConstMacro(Beta, double); itkSetMacro(Beta, double); itkGetConstMacro(NumberFound, unsigned int); protected: BoxAndWhiskerImageFilter (); ~BoxAndWhiskerImageFilter () ITK_OVERRIDE {} /** Main computation method implemented as a multithreaded filter */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void AllocateOutputs() ITK_OVERRIDE; /** Perform the outlier detection */ PixelType PerformBoxAndWhiskerDetection(const PixelType& pixel); private: BoxAndWhiskerImageFilter (const Self &); void operator =(const Self&); // not implemented SizeType m_Radius; double m_Beta; long int m_NumberFound; }; // end of class BoxAndWhiskerImageFilter } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBoxAndWhiskerImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbBoxAndWhiskerImageFilter.txx000066400000000000000000000114521301006202600320750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoxAndWhiskerImageFilter_txx #define otbBoxAndWhiskerImageFilter_txx #include #include #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "otbBoxAndWhiskerImageFilter.h" #include "otbEuclideanDistanceMetricWithMissingValue.h" namespace otb { template BoxAndWhiskerImageFilter ::BoxAndWhiskerImageFilter () { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->InPlaceOn(); m_Beta = 1.5; m_Radius.Fill(1); m_NumberFound = 0L; } template void BoxAndWhiskerImageFilter ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { const TInputImage * inputPtr = this->GetInput(); OutputImageType * outputPtr = this->GetOutput(); // data-set boundary faces typedef typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator ImageBoundaryFacesCalculatorType; typename ImageBoundaryFacesCalculatorType::FaceListType faceList; ImageBoundaryFacesCalculatorType boundaryCalculator; faceList = boundaryCalculator(inputPtr, outputRegionForThread, this->GetRadius()); // face iterator typename ImageBoundaryFacesCalculatorType::FaceListType::iterator faceIterator; // local iterators itk::ImageRegionConstIterator inputIter; itk::ImageRegionIterator outputIter; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); /** * Process each of the boundary faces. * These are N-d regions which border the edge of the buffer. */ for (faceIterator = faceList.begin(); faceIterator != faceList.end(); ++faceIterator) { inputIter = itk::ImageRegionConstIterator (inputPtr, *faceIterator); inputIter.GoToBegin(); outputIter = itk::ImageRegionIterator (outputPtr, *faceIterator); outputIter.GoToBegin(); while (!outputIter.IsAtEnd()) { outputIter.Set(this->PerformBoxAndWhiskerDetection(inputIter.Get())); ++inputIter; ++outputIter; progress.CompletedPixel(); } } } template typename BoxAndWhiskerImageFilter ::PixelType BoxAndWhiskerImageFilter ::PerformBoxAndWhiskerDetection(const PixelType& pixel) { typedef std::vector VectorType; typedef otb::Statistics::EuclideanDistanceMetricWithMissingValue OutlierType; unsigned int i; const unsigned int vectorSize = pixel.Size(); const unsigned int medianPosition = vectorSize / 2; const unsigned int firstQuartilePosition = vectorSize / 4; const unsigned int thirdQuartilePosition = (3 * vectorSize) / 4; VectorType data(vectorSize); for (i = 0; i < vectorSize; ++i) data[i] = pixel[i]; std::sort(data.begin(), data.end()); double box = m_Beta * static_cast(data[thirdQuartilePosition] - data[firstQuartilePosition]); double median = ::fabs(static_cast(data[medianPosition])); PixelType outputPixel(pixel); for (i = 0; i < vectorSize; ++i) { if (::fabs(static_cast(outputPixel[i]) - box) > median) { OutlierType::SetToMissingValue(outputPixel[i]); m_NumberFound++; } } return outputPixel; } template void BoxAndWhiskerImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel()); this->GetOutput()->CopyInformation(this->GetInput()); } template void BoxAndWhiskerImageFilter ::AllocateOutputs() { OutputImageType * output = this->GetOutput(); output->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel()); output->SetBufferedRegion(output->GetRequestedRegion()); output->Allocate(); } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbChangeInformationImageFilter.h000066400000000000000000000056731301006202600323740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbChangeInformationImageFilter_h #define otbChangeInformationImageFilter_h #include "itkChangeInformationImageFilter.h" #include "otbMetaDataKey.h" namespace otb { /** * \class ChangeInformationImageFilter * \brief Filter to modify image metadata * * The base class is itk::ChangeInformationImageFilter that allows * modifying origin, spacing, direction and buffered region. This deriving * filter adds the support of MetaDataDictionary. * * \ingroup OTBImageManipulation */ template< typename TInputImage > class ChangeInformationImageFilter: public itk::ChangeInformationImageFilter< TInputImage > { public: /** Standard class typedefs. */ typedef ChangeInformationImageFilter Self; typedef itk::ChangeInformationImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ChangeInformationImageFilter, itk::ChangeInformationImageFilter); /** Set key names to change */ void SetChangeMetaData(const char *keyname, bool flag); /** Ask if a metadata will be changed */ bool GetChangeMetaData(const char *keyname); /** Set output values for metadata, passing a NULL value will remove the * metadata from output. If not set for a key name in the change list, * the metadata will also be set. */ template void SetOutputMetaData(const char *keyname, const T * value); protected: ChangeInformationImageFilter() {} ~ChangeInformationImageFilter() ITK_OVERRIDE {} /** Apply changes to the output image metadata. */ void GenerateOutputInformation() ITK_OVERRIDE; private: ChangeInformationImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Removes a field from a metadata dictionary * After ITK 4.6, an Erase() method has been added to * itk::MetaDataDictionary, so this function could be tagged as deprecated */ bool RemoveKeyFromDictionary(itk::MetaDataDictionary & dict, const std::string & key); /** List of metadata keys to change */ std::set m_ChangedKeys; }; } // End of namespace OTB #ifndef OTB_MANUAL_INSTANTIATION #include "otbChangeInformationImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbChangeInformationImageFilter.txx000066400000000000000000000070301301006202600327550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbChangeInformationImageFilter_txx #define otbChangeInformationImageFilter_txx #include "otbChangeInformationImageFilter.h" #include "itkMetaDataObject.h" namespace otb { template< typename TInputImage > void ChangeInformationImageFilter ::SetChangeMetaData(const char *keyname, bool flag) { std::string key(keyname); if (! key.empty()) { if (flag) { m_ChangedKeys.insert(key); } else { std::set::iterator pos = m_ChangedKeys.find(key); if (pos != m_ChangedKeys.end()) { m_ChangedKeys.erase(pos); } } } } template< typename TInputImage > bool ChangeInformationImageFilter ::GetChangeMetaData(const char *keyname) { std::string key(keyname); if (! key.empty()) { if (m_ChangedKeys.find(key) != m_ChangedKeys.end()) { return true; } } return false; } template< typename TInputImage > template void ChangeInformationImageFilter ::SetOutputMetaData(const char *keyname, const T * value) { std::string key(keyname); if (! key.empty()) { // enable this key for metadata change m_ChangedKeys.insert(key); itk::MetaDataDictionary &dict = this->GetMetaDataDictionary(); if (value == ITK_NULLPTR) { // Remove meta-data from dictionary this->RemoveKeyFromDictionary(dict,key); } else { // Set metadata in dictionary const T &valueRef = (*value); itk::EncapsulateMetaData(dict,key,valueRef); } } } template< typename TInputImage > void ChangeInformationImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // Process the metadatas to be changed itk::MetaDataDictionary &dict = this->GetMetaDataDictionary(); itk::MetaDataDictionary &outputDict = this->GetOutput()->GetMetaDataDictionary(); std::set::iterator it = m_ChangedKeys.begin(); for ( ; it != m_ChangedKeys.end() ; ++it) { if (dict.HasKey(*it)) { // Replace metadata in output dictionary outputDict[*it] = dict[*it]; } else { // Remove metadata from output dictionary this->RemoveKeyFromDictionary(outputDict,*it); } } } template< typename TInputImage > bool ChangeInformationImageFilter ::RemoveKeyFromDictionary(itk::MetaDataDictionary & dict, const std::string & key) { std::vector keyList = dict.GetKeys(); std::vector::iterator pos = keyList.begin(); while (pos != keyList.end()) { if (key.compare(*pos) == 0) { break; } ++pos; } if (pos != keyList.end()) { itk::MetaDataDictionary copyDict; keyList.erase(pos); pos = keyList.begin(); for ( ; pos != keyList.end();++pos) { copyDict.Set(*pos, const_cast(dict.Get(*pos))); } dict = copyDict; return true; } return false; } } // End of namespace OTB #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbChangeLabelImageFilter.h000066400000000000000000000112361301006202600311160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbChangeLabelImageFilter_h #define otbChangeLabelImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkConceptChecking.h" #include "itkSimpleDataObjectDecorator.h" #include namespace otb { /** \class ChangeLabelImageFilter * * \brief Change Sets of Labels * * Adapt the itkChangeLabelImageFilter for multichannel images. * * * \ingroup OTBImageManipulation */ namespace Functor { template class VectorChangeLabel { public: typedef typename TOutput::ValueType ValueType; VectorChangeLabel() {} virtual ~VectorChangeLabel() {} typedef std::map ChangeMapType; void SetNumberOfComponentsPerPixel(unsigned int nb) { m_NumberOfComponentsPerPixel = nb; } unsigned int GetNumberOfComponentsPerPixel() { return m_NumberOfComponentsPerPixel; } bool operator !=(const VectorChangeLabel& other) const { if (m_ChangeMap != other.m_ChangeMap) { return true; } return false; } bool operator ==(const VectorChangeLabel& other) const { return !(*this != other); } TOutput GetChange(const TInput& original) { return m_ChangeMap[original]; } void SetChange(const TInput& original, const TOutput& result) { m_ChangeMap[original] = result; } void SetChangeMap(const ChangeMapType& changeMap) { m_ChangeMap = changeMap; } void ClearChangeMap() { m_ChangeMap.clear(); } inline TOutput operator ()(const TInput& A) { TOutput out; out.SetSize(m_NumberOfComponentsPerPixel); if (m_ChangeMap.find(A) != m_ChangeMap.end()) { out = m_ChangeMap[A]; } else { out.Fill(static_cast(A)); } return out; } private: ChangeMapType m_ChangeMap; unsigned int m_NumberOfComponentsPerPixel; }; } template class ITK_EXPORT ChangeLabelImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ChangeLabelImageFilter Self; typedef itk::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ChangeLabelImageFilter, itk::UnaryFunctorImageFilter); /** Pixel types. */ typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; /** Type of the change map to use for change requests */ typedef std::map ChangeMapType; /** Set up a change of a single label */ void SetChange(const InputPixelType& original, const OutputPixelType& result); /** Set the entire change map */ void SetChangeMap(const ChangeMapType& changeMap); /** Clears the entire change map */ void ClearChangeMap(); /** Set/Get the number of components per pixel */ void SetNumberOfComponentsPerPixel(unsigned int nb) { m_NumberOfComponentsPerPixel = nb; this->GetFunctor().SetNumberOfComponentsPerPixel(m_NumberOfComponentsPerPixel); this->Modified(); } itkGetMacro(NumberOfComponentsPerPixel, unsigned int); protected: ChangeLabelImageFilter(); ~ChangeLabelImageFilter() ITK_OVERRIDE {} /** Generate the output information missing */ void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ChangeLabelImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /// Number of components per pixel unsigned int m_NumberOfComponentsPerPixel; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbChangeLabelImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbChangeLabelImageFilter.txx000066400000000000000000000046061301006202600315150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbChangeLabelImageFilter_txx #define otbChangeLabelImageFilter_txx #include "otbChangeLabelImageFilter.h" namespace otb { /** * */ template ChangeLabelImageFilter ::ChangeLabelImageFilter() : m_NumberOfComponentsPerPixel(0) { } /** * */ template void ChangeLabelImageFilter ::SetChange(const InputPixelType& original, const OutputPixelType& result) { OutputPixelType current = this->GetFunctor().GetChange(original); if (current != result) { this->GetFunctor().SetChange(original, result); this->Modified(); } } /** * */ template void ChangeLabelImageFilter ::SetChangeMap(const ChangeMapType& changeMap) { //If the whole map is being set then we assume that a real change is made this->GetFunctor().SetChangeMap(changeMap); this->Modified(); } /** * */ template void ChangeLabelImageFilter ::ClearChangeMap() { //If the whole map is being set then we assume that a real change is made this->GetFunctor().ClearChangeMap(); this->Modified(); } /** * */ template void ChangeLabelImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel(m_NumberOfComponentsPerPixel); } /** * */ template void ChangeLabelImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Number of components per pixel: " << m_NumberOfComponentsPerPixel; } } // end namespace #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbChangeNoDataValueFilter.h000066400000000000000000000125501301006202600312770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbChangeNoDataValueFilter_h #define otbChangeNoDataValueFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "otbNoDataHelper.h" namespace otb { namespace Functor { /** \class ChangeNoDataFunctor * \brief Functor used by ChangeNoDataValueFilter * * See ChangeNoDataValueFilter for complete documentation. * \ingroup OTBImageManipulation */ template class ChangeNoDataFunctor { public: ChangeNoDataFunctor(): m_Flags(), m_Values(), m_NewValues(), m_NaNIsNoData(false) {} virtual ~ChangeNoDataFunctor(){} inline TOutputPixel operator()(const TInputPixel& in) const { return otb::ChangeNoData(in,m_Flags,m_Values,m_NewValues,m_NaNIsNoData); } std::vector m_Flags; std::vector m_Values; std::vector m_NewValues; bool m_NaNIsNoData; }; } // End namespace Functor /** \class ChangeNoDataValueFilter * \brief Change no-data flags and values and replace them in image * * This filter reads the no-data flags (a boolean vector indicating * for each band if a no-data value exists) and values (the actual * value to be used as no-data for each band) from * MetaDataDictionary, and allows changing this value. * * The algorithm is the following: for each pixel, for each channel * in the pixel, if there is a no-data value for this channel * (according to no-data flags) and the current channel value equals * to the no-data value set for this channel, then the value is * changed for the new no-data value specified by the * users. Otherwise, value remains untouched. * * If NaNIsNoData is true: * - NaN values will be considered as no data and replaced as well * - Output image will have no-data flags and values for all bands * * If NaNIsNoData is false: * - Band for which input no-data flags is false will remain * untouched * - Output image will have no-data flags and values only for bands * for which input no-data flag is true. * * \ingroup Streamed * \ingroup MultiThreaded * \ingroup OTBImageManipulation */ template class ChangeNoDataValueFilter : public itk::UnaryFunctorImageFilter > { public: typedef Functor::ChangeNoDataFunctor FunctorType; typedef ChangeNoDataValueFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ChangeNoDataValueFilter, itk::ImageToImageFilter); /** * Set the new no-data values * \param newValues The vector of new no-data values (size should be * >= to number of bands) */ void SetNewNoDataValues(std::vector & newValues) { this->GetFunctor().m_NewValues = newValues; } /** * Set the NaN is no data flags * \param nanIsNoData If true, NaN values will be considered as * no-data as well (default is false) */ void SetNaNIsNoData(bool nanIsNoData) { this->GetFunctor().m_NaNIsNoData = nanIsNoData; } protected: ChangeNoDataValueFilter() {} ~ChangeNoDataValueFilter() ITK_OVERRIDE {} void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation(); std::vector noDataValueAvailable; std::vector noDataValues; bool ret = ReadNoDataFlags(this->GetInput()->GetMetaDataDictionary(),noDataValueAvailable,noDataValues); if(!ret) { noDataValueAvailable.resize(this->GetInput()->GetNumberOfComponentsPerPixel(),false); noDataValues.resize(this->GetInput()->GetNumberOfComponentsPerPixel(),0); } this->GetFunctor().m_Flags = noDataValueAvailable; this->GetFunctor().m_Values = noDataValues; std::vector flags = noDataValueAvailable; if(this->GetFunctor().m_NaNIsNoData) { flags = std::vector(flags.size(),true); } WriteNoDataFlags(flags,this->GetFunctor().m_NewValues,this->GetOutput()->GetMetaDataDictionary()); } private: ChangeNoDataValueFilter(const Self&); // purposely not implemented void operator =(const Self&); // purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.h000066400000000000000000000115001301006202600300170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbClampImageFilter_h #define otbClampImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class ClampImageFilter * \brief Set image values to a user-specified value if they are below, * above, or between simple threshold values. * * ClampImageFilter clamp image values to be between an upper * and lower value. Values lower than m_Lower values are set to lower, * and values greater than upper threshold are set to upper threshold * value. * * By default lower and upper thresholds are set to the maximum and * minimum bounds of the image pixel type. * * The pixels must support the operators >= and <=. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ClampImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef ClampImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ClampImageFilter, itk::ImageToImageFilter); /** Some additional typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; /** Some additional typedefs. */ typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; /** The values greater than or equal to the value are set to OutsideValue. */ void ClampAbove(const OutputImagePixelType &thresh); /** The values less than or equal to the value are set to OutsideValue. */ void ClampBelow(const OutputImagePixelType &thresh); /** The values outside the range are set to OutsideValue. */ void ClampOutside(const OutputImagePixelType &lower, const OutputImagePixelType &upper); /** Set/Get methods to set the lower threshold */ void SetLower(OutputImagePixelType val) { m_Lower = val; m_DLower = static_cast(val); this->Modified(); } itkGetConstMacro(Lower, OutputImagePixelType); /** Set/Get methods to set the upper threshold */ void SetUpper(OutputImagePixelType val) { m_Upper = val; m_DUpper = static_cast(val); this->Modified(); } itkGetConstMacro(Upper, OutputImagePixelType); protected: ClampImageFilter(); ~ClampImageFilter() ITK_OVERRIDE {}; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ClampImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() ); } private: ClampImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented double m_DLower; double m_DUpper; OutputImagePixelType m_Lower; OutputImagePixelType m_Upper; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbClampImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.txx000066400000000000000000000115231301006202600304200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbClampImageFilter_txx #define otbClampImageFilter_txx #include "otbClampImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" #include "itkObjectFactory.h" #include "itkProgressReporter.h" namespace otb { /** * */ template ClampImageFilter ::ClampImageFilter() { m_Lower = itk::NumericTraits::NonpositiveMin(); m_Upper = itk::NumericTraits::max(); m_DLower = static_cast(m_Lower); m_DUpper = static_cast(m_Upper); } /** * */ template void ClampImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Lower: " << static_cast::PrintType>(m_Lower) << std::endl; os << indent << "Upper: " << static_cast::PrintType>(m_Upper) << std::endl; } /** * The values greater than or equal to the value are set to UpperValue */ template void ClampImageFilter ::ClampAbove(const OutputImagePixelType &thresh) { if (m_Upper != thresh || m_Lower > itk::NumericTraits::NonpositiveMin()) { m_Lower = itk::NumericTraits::NonpositiveMin(); m_Upper = thresh; m_DUpper = static_cast(m_Upper); this->Modified(); } } /** * The values less than or equal to the value are set to OutsideValue */ template void ClampImageFilter ::ClampBelow(const OutputImagePixelType &thresh) { if (m_Lower != thresh || m_Upper < itk::NumericTraits::max()) { m_Lower = thresh; m_DLower = m_Lower; m_Upper = itk::NumericTraits::max(); this->Modified(); } } /** * The values outside the range are set to OutsideValue */ template void ClampImageFilter ::ClampOutside(const OutputImagePixelType &lower, const OutputImagePixelType &upper) { if (lower > upper) { itkExceptionMacro(<<"Lower threshold cannot be greater than upper threshold."); return; } if (m_Lower != lower || m_Upper != upper) { m_Lower = lower; m_Upper = upper; m_DLower = m_Lower; m_DUpper = m_Upper; this->Modified(); } } /** * */ template void ClampImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itkDebugMacro(<<"Actually executing"); // Get the input and output pointers InputImagePointer inputPtr = this->GetInput(); OutputImagePointer outputPtr = this->GetOutput(0); // Define/declare an iterator that will walk the output region for this // thread. typedef itk::ImageRegionConstIterator InputIterator; typedef itk::ImageRegionIterator OutputIterator; InputIterator inIt(inputPtr, outputRegionForThread); OutputIterator outIt(outputPtr, outputRegionForThread); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // walk the regions, threshold each pixel while( !outIt.IsAtEnd() && !inIt.IsAtEnd() ) { // Cast the value of the pixel to double in order to compare // with the double version of the upper and the lower bounds of // output image const double value = static_cast(inIt.Get()); OutputImagePixelType outPix = m_Lower; if ( m_DLower <= value && value <= m_DUpper) { // pixel passes to output unchanged outPix = static_cast(value); } /* Already outPix is initialized with m_Lower even for preventing Warning. * else if ( value < m_DLower ) { outPix = m_Lower; } */ else if ( value > m_DUpper) { outPix = m_Upper; } outIt.Set( outPix ); ++inIt; ++outIt; progress.CompletedPixel(); } } } // end namespace itk #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbClampVectorImageFilter.h000066400000000000000000000121231301006202600312040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbClampVectorImageFilter_h #define otbClampVectorImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class ClampVectorImageFilter * \brief Set image values to a user-specified value if they are below, * above, or between simple threshold values. * * ClampVectorImageFilter clamp image values to be between an upper * and lower value. Values lower than m_Lower values are set to lower, * and values greater than upper threshold are set to upper threshold * value. * * By default lower and upper thresholds are set to the maximum and * minimum bounds of the image pixel type. * * The pixels must support the operators >= and <=. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ClampVectorImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef ClampVectorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ClampVectorImageFilter, itk::ImageToImageFilter); /** Some additional typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::InternalPixelType InputImageInternalPixelType; /** Some additional typedefs. */ typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::InternalPixelType OutputImageInternalPixelType; /** The values greater than or equal to the value are set to OutsideValue. */ void ClampAbove(const OutputImageInternalPixelType &thresh); /** The values less than or equal to the value are set to OutsideValue. */ void ClampBelow(const OutputImageInternalPixelType &thresh); /** The values outside the range are set to OutsideValue. */ void ClampOutside(const OutputImageInternalPixelType &lower, const OutputImageInternalPixelType &upper); /** Set/Get methods to set the lower threshold */ void SetLower(OutputImageInternalPixelType val) { m_Lower = val; m_DLower = static_cast(val); this->Modified(); } itkGetConstMacro(Lower, OutputImageInternalPixelType); /** Set/Get methods to set the upper threshold */ void SetUpper(OutputImageInternalPixelType val) { m_Upper = val; m_DUpper = static_cast(val); this->Modified(); } itkGetConstMacro(Upper, OutputImageInternalPixelType); protected: ClampVectorImageFilter(); ~ClampVectorImageFilter() ITK_OVERRIDE {}; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ClampVectorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() ); } private: ClampVectorImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented double m_DLower; double m_DUpper; OutputImageInternalPixelType m_Lower; OutputImageInternalPixelType m_Upper; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbClampVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbClampVectorImageFilter.txx000066400000000000000000000122561301006202600316070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbClampVectorImageFilter_txx #define otbClampVectorImageFilter_txx #include "otbClampVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" #include "itkObjectFactory.h" #include "itkProgressReporter.h" namespace otb { /** * */ template ClampVectorImageFilter ::ClampVectorImageFilter() { m_Lower = itk::NumericTraits::NonpositiveMin(); m_Upper = itk::NumericTraits::max(); m_DLower = static_cast(m_Lower); m_DUpper = static_cast(m_Upper); } /** * */ template void ClampVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Lower: " << static_cast::PrintType>(m_Lower) << std::endl; os << indent << "Upper: " << static_cast::PrintType>(m_Upper) << std::endl; } /** * The values greater than or equal to the value are set to UpperValue */ template void ClampVectorImageFilter ::ClampAbove(const OutputImageInternalPixelType &thresh) { if (m_Upper != thresh || m_Lower > itk::NumericTraits::NonpositiveMin()) { m_Lower = itk::NumericTraits::NonpositiveMin(); m_Upper = thresh; m_DUpper = static_cast(m_Upper); this->Modified(); } } /** * The values less than or equal to the value are set to OutsideValue */ template void ClampVectorImageFilter ::ClampBelow(const OutputImageInternalPixelType &thresh) { if (m_Lower != thresh || m_Upper < itk::NumericTraits::max()) { m_Lower = thresh; m_DLower = m_Lower; m_Upper = itk::NumericTraits::max(); this->Modified(); } } /** * The values outside the range are set to OutsideValue */ template void ClampVectorImageFilter ::ClampOutside(const OutputImageInternalPixelType &lower, const OutputImageInternalPixelType &upper) { if (lower > upper) { itkExceptionMacro(<<"Lower threshold cannot be greater than upper threshold."); return; } if (m_Lower != lower || m_Upper != upper) { m_Lower = lower; m_Upper = upper; m_DLower = m_Lower; m_DUpper = m_Upper; this->Modified(); } } /** * */ template void ClampVectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itkDebugMacro(<<"Actually executing"); // Get the input and output pointers InputImagePointer inputPtr = this->GetInput(); OutputImagePointer outputPtr = this->GetOutput(0); // Define/declare an iterator that will walk the output region for this // thread. typedef itk::ImageRegionConstIterator InputIterator; typedef itk::ImageRegionIterator OutputIterator; InputIterator inIt(inputPtr, outputRegionForThread); OutputIterator outIt(outputPtr, outputRegionForThread); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // walk the regions, threshold each pixel while( !outIt.IsAtEnd() && !inIt.IsAtEnd() ) { const InputImagePixelType inPix = inIt.Get(); unsigned int l_size = inPix.Size(); OutputImagePixelType outPix; outPix.SetSize(l_size); for(unsigned int i=0; i(inPix[i]); if ( m_DLower <= value && value <= m_DUpper ) { // pixel passes to output unchanged and is replaced by m_OutsideValue in // the inverse output image outPix[i] = static_cast(value); } else if ( value < m_DLower ) { outPix[i] = m_Lower; } else if ( value > m_DUpper ) { outPix[i] = m_Upper; } } outIt.Set( outPix ); ++inIt; ++outIt; progress.CompletedPixel(); } } } // end namespace itk #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbConcatenateScalarValueImageFilter.h000066400000000000000000000100041301006202600333300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateScalarValueImageFilter_h #define otbConcatenateScalarValueImageFilter_h #include "itkMacro.h" #include "itkUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class ConcatenateScalarValueFunctor * * \brief TODO * * * \ingroup OTBImageManipulation */ template class ConcatenateScalarValueFunctor { public: typedef TInput InputType; typedef TOutput OutputType; typedef typename InputType::ComponentType ComponentType; ConcatenateScalarValueFunctor() : m_ScalarValue(0) {} virtual ~ConcatenateScalarValueFunctor() {} const ComponentType& GetScalarValue() { return m_ScalarValue; } void SetScalarValue(const ComponentType& p) { m_ScalarValue = p; } bool operator !=(const ConcatenateScalarValueFunctor& itkNotUsed(other)) const { return false; } bool operator ==(const ConcatenateScalarValueFunctor& other) const { return !(*this != other); } OutputType operator ()(const InputType& in) { OutputType out(in.Size() + 1); for (unsigned int j = 0; j < in.Size(); ++j) { out[j] = in[j]; } out[in.Size()] = m_ScalarValue; return out; } private: ComponentType m_ScalarValue; }; } /** \class ConcatenateScalarValueImageFilter * * \brief Applies a projective projection to each pixel of an image * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ConcatenateScalarValueImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ConcatenateScalarValueImageFilter Self; typedef itk::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Functor::ConcatenateScalarValueFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctorType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ConcatenateScalarValueImageFilter, otb::UnaryFunctorImageFilter); /** Pixel types. */ typedef typename TInputImage::PixelType InputPixelType; typedef typename InputPixelType::ComponentType InputComponentType; typedef typename TOutputImage::PixelType OutputPixelType; const InputComponentType& GetScalarValue() { return this->GetFunctor().GetScalarValue(); } void SetScalarValue(const InputComponentType& p) { this->GetFunctor().SetScalarValue(p); this->Modified(); } protected: ConcatenateScalarValueImageFilter(); ~ConcatenateScalarValueImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; private: ConcatenateScalarValueImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConcatenateScalarValueImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbConcatenateScalarValueImageFilter.txx000066400000000000000000000026351301006202600337370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateScalarValueImageFilter_txx #define otbConcatenateScalarValueImageFilter_txx #include "otbConcatenateScalarValueImageFilter.h" namespace otb { template ConcatenateScalarValueImageFilter ::ConcatenateScalarValueImageFilter() { } template void ConcatenateScalarValueImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() + 1 ); } template void ConcatenateScalarValueImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbConcatenateVectorImageFilter.h000066400000000000000000000075411301006202600324040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateVectorImageFilter_h #define otbConcatenateVectorImageFilter_h #include "itkImageToImageFilter.h" #include "otbVectorImage.h" namespace otb { /** \class ConcatenateVectorImageFilter * \brief This filter concatenates the vector pixel of the first * image with the vector pixel of the second image. * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ConcatenateVectorImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef ConcatenateVectorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorImageToImagePixelAccessor, ImageToImageFilter); /** Template related typedefs */ typedef TInputImage1 InputImage1Type; typedef TInputImage2 InputImage2Type; typedef TOutputImage OutputImageType; typedef typename InputImage1Type::Pointer InputImage1PointerType; typedef typename InputImage2Type::Pointer InputImage2PointerType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename InputImage1Type::PixelType InputPixel1Type; typedef typename InputImage2Type::PixelType InputPixel2Type; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** * Set The first input image. * \param image The first input image. */ void SetInput1(const TInputImage1 * image); /** * Get the first input image. * \return The first input image. */ InputImage1Type * GetInput1(void); /** * Set The second input image. * \param image The second input image. */ void SetInput2(const TInputImage2 * image); /** * Get the second input image. * \return The second input image. */ InputImage2Type * GetInput2(void); /** ImageDimension constant */ itkStaticConstMacro(InputImage1Dimension, unsigned int, TInputImage1::ImageDimension); itkStaticConstMacro(InputImage2Dimension, unsigned int, TInputImage2::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); protected: /** Constructor. */ ConcatenateVectorImageFilter(); /** Destructor. */ ~ConcatenateVectorImageFilter() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Main computation method. */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ConcatenateVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConcatenateVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbConcatenateVectorImageFilter.txx000066400000000000000000000155321301006202600327770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateVectorImageFilter_txx #define otbConcatenateVectorImageFilter_txx #include "otbConcatenateVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor. */ template ConcatenateVectorImageFilter ::ConcatenateVectorImageFilter() { this->SetNumberOfRequiredInputs(2); } /** * Destructor. */ template ConcatenateVectorImageFilter ::~ConcatenateVectorImageFilter() {} /** * Set The first input image. * \param image The first input image. */ template void ConcatenateVectorImageFilter ::SetInput1(const TInputImage1 * image) { this->SetNthInput(0, const_cast(image)); } /** * Set The second input image. * \param image The second input image. */ template void ConcatenateVectorImageFilter ::SetInput2(const TInputImage2 * image) { this->SetNthInput(1, const_cast(image)); } /** * Get the first input image. * \return The first input image. */ template typename ConcatenateVectorImageFilter ::InputImage1Type * ConcatenateVectorImageFilter ::GetInput1(void) { return const_cast(this->GetInput(0)); } /** * Get the second input image. * \return The second input image. */ template typename ConcatenateVectorImageFilter ::InputImage2Type * ConcatenateVectorImageFilter ::GetInput2(void) { return const_cast(this->GetInput(1)); } template void ConcatenateVectorImageFilter ::GenerateOutputInformation() { // Call to the superclass implementation Superclass::GenerateOutputInformation(); typename Superclass::InputImageConstPointer inputPtr1 = this->GetInput1(); typename Superclass::InputImageConstPointer inputPtr2 = this->GetInput2(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); unsigned int nbComponentsPerPixel = inputPtr1->GetNumberOfComponentsPerPixel() + inputPtr2->GetNumberOfComponentsPerPixel(); // initialize the number of channels of the output image outputPtr->SetNumberOfComponentsPerPixel(nbComponentsPerPixel); } template void ConcatenateVectorImageFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); typename Superclass::InputImageConstPointer inputPtr1 = this->GetInput1(); typename Superclass::InputImageConstPointer inputPtr2 = this->GetInput2(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (inputPtr1->GetLargestPossibleRegion() != inputPtr2->GetLargestPossibleRegion()) { itkExceptionMacro(<< "InputImage1 and InputImage2 have different requested regions."); } } /** * Main computation method. */ template void ConcatenateVectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // retrieves inputs and output pointer InputImage1PointerType input1 = this->GetInput1(); InputImage2PointerType input2 = this->GetInput2(); OutputImagePointerType output = this->GetOutput(); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define the portion of the input to walk for this thread typename InputImage1Type::RegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Iterators typedefs typedef itk::ImageRegionIterator Input1IteratorType; typedef itk::ImageRegionIterator Input2IteratorType; typedef itk::ImageRegionIterator OutputIteratorType; // Iterators declaration Input1IteratorType input1It(input1, inputRegionForThread); Input2IteratorType input2It(input2, inputRegionForThread); OutputIteratorType outputIt(output, outputRegionForThread); input1It.GoToBegin(); input2It.GoToBegin(); outputIt.GoToBegin(); typename OutputImageType::PixelType outputPix(outputIt.Get().GetSize()); // Retrieve the size of each input pixel const unsigned int l1 = input1It.Get().GetSize(); const unsigned int l2 = input2It.Get().GetSize(); // Iterate through the pixel while (!outputIt.IsAtEnd()) { // Check the size of each input pixel assert(l1 == input1It.Get().GetSize()); assert(l2 == input2It.Get().GetSize()); // Check the size of the output pixel assert(l1 + l2 == outputPix.GetSize()); // References to the input pixels InputPixel1Type const& pix1 = input1It.Get(); InputPixel2Type const& pix2 = input2It.Get(); // Loop through each band of the first image for (unsigned int i = 0; i < l1; ++i) { // Fill the output pixel outputPix[i] = static_cast(pix1[i]); } // Loop though each band of the second image for (unsigned int i = 0; i < l2; ++i) { // Fill the output pixel outputPix[i + l1] = static_cast(pix2[i]); } // Set the output pixel outputIt.Set(outputPix); // Increment the iterator ++input1It; ++input2It; ++outputIt; } } /** * PrintSelf method. */ template void ConcatenateVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif otbEuclideanDistanceMetricWithMissingValue.h000066400000000000000000000064351301006202600345010ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEuclideanDistanceMetricWithMissingValue_h #define otbEuclideanDistanceMetricWithMissingValue_h #include "otbEuclideanDistanceMetricWithMissingValuePow2.h" namespace otb { namespace Statistics { /** \class EuclideanDistanceMetricWithMissingValue * \brief Euclidean distance function facing missing value. * * This class is derived from EuclideanDistanceMetricWithMissingValuePow2 class that handle the missing value * functonnalities. Here, the square root is included in the evaluation... * * The class can be templated over any container that holds data elements, as * for template of EuclideanDistanceMetric. * * The only restriction is that elements have to support NaN values. * * \sa EuclideanDistanceMetric * \sa EuclideanDistanceMetricWithMissingValuePow2 * * \ingroup OTBImageManipulation */ template class ITK_EXPORT EuclideanDistanceMetricWithMissingValue : public otb::Statistics::EuclideanDistanceMetricWithMissingValuePow2 { public: /** Standard "Self" typedef. */ typedef EuclideanDistanceMetricWithMissingValue Self; typedef otb::Statistics::EuclideanDistanceMetricWithMissingValuePow2 Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::MeasurementVectorSizeType MeasurementVectorSizeType; /** Run-time type information (and related methods). */ itkTypeMacro(EuclideanDistanceMetricWithMissingValue, EuclideanDistanceMetricWithMissingValuePow2); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Type of the component of a vector */ typedef typename TVector::ValueType ValueType; /** Gets the distance between the origin and x */ double Evaluate(const TVector& x) const ITK_OVERRIDE { return ::vcl_sqrt(Superclass::Evaluate(x)); } /** Gets the distance between x1 and x2 */ double Evaluate(const TVector& x1, const TVector& x2) const ITK_OVERRIDE { return ::vcl_sqrt(Superclass::Evaluate(x1, x2)); } /** Gets the cooridnate distance between a and b. NOTE: a and b * should be type of component */ double Evaluate(const ValueType& a, const ValueType& b) const { return ::vcl_sqrt(Superclass::Evaluate(a, b)); } /** Returns true if the distance between x and the origin is less * than radius */ bool IsWithinRange(const TVector& x, const double radius) const { return Superclass::IsWithinRange(x, radius); } protected: EuclideanDistanceMetricWithMissingValue() {} ~EuclideanDistanceMetricWithMissingValue() ITK_OVERRIDE {} }; // end of class } // end namespace statistics } // end namespace otb #endif otbEuclideanDistanceMetricWithMissingValuePow2.h000066400000000000000000000070701301006202600352450ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEuclideanDistanceMetricWithMissingValuePow2_h #define otbEuclideanDistanceMetricWithMissingValuePow2_h #include "itkEuclideanDistanceMetric.h" namespace otb { namespace Statistics { /** \class EuclideanDistanceMetricWithMissingValuePow2 * \brief Euclidean comparison distance function facing missing value. The square root is not performed in this class. * * This class is derived from EuclideanDistanceMetric class. In addition * to the initial Evaluate method, the class does not perform calculation * when a component does not contain any data. The 'no data' case is perform through the \code SetToMissingValue() \endcode * which performs a \code Nan \endcode affectation. * * The class can be templated over any container that holds data elements, as * for template of EuclideanDistanceMetric. * * The only restriction is that elements have to support NaN values. * * \sa EuclideanDistanceMetric * \sa EuclideanDistanceMetricWithMissingValue * * \ingroup OTBImageManipulation */ template class ITK_EXPORT EuclideanDistanceMetricWithMissingValuePow2 : public itk::Statistics::EuclideanDistanceMetric { public: /** Standard "Self" typedef. */ typedef EuclideanDistanceMetricWithMissingValuePow2 Self; typedef itk::Statistics::EuclideanDistanceMetric Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::MeasurementVectorSizeType MeasurementVectorSizeType; /** Run-time type information (and related methods). */ itkTypeMacro(EuclideanDistanceMetricWithMissingValuePow2, EuclideanDistanceMetric); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Type of the component of a vector */ typedef typename TVector::ValueType ValueType; /** Gets the distance between the origin and x */ double Evaluate(const TVector& x) const ITK_OVERRIDE; /** Gets the distance between x1 and x2 */ double Evaluate(const TVector& x1, const TVector& x2) const ITK_OVERRIDE; /** Gets the cooridnate distance between a and b. NOTE: a and b * should be type of component */ double Evaluate(const ValueType& a, const ValueType& b) const; /** Returns true if the distance between x and the origin is less * than radius */ bool IsWithinRange(const TVector& x, const double radius) const { return Superclass::IsWithinRange(x, radius); } /** Check if a value is NaN or not */ static bool IsMissingValue(const ValueType& v); /** Set a value to Nan */ static void SetToMissingValue(ValueType& v); protected: EuclideanDistanceMetricWithMissingValuePow2() {} ~EuclideanDistanceMetricWithMissingValuePow2() ITK_OVERRIDE {} }; // end of class } // end namespace statistics } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbEuclideanDistanceMetricWithMissingValuePow2.txx" #endif #endif otbEuclideanDistanceMetricWithMissingValuePow2.txx000066400000000000000000000061031301006202600356350ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEuclideanDistanceMetricWithMissingValuePow2_txx #define otbEuclideanDistanceMetricWithMissingValuePow2_txx #include "otbEuclideanDistanceMetricWithMissingValuePow2.h" #include "itkMeasurementVectorTraits.h" namespace otb { namespace Statistics { template inline double EuclideanDistanceMetricWithMissingValuePow2 ::Evaluate(const TVector& x1, const TVector& x2) const { if (itk::NumericTraits::GetLength(x1) != itk::NumericTraits::GetLength(x2)) { itkExceptionMacro(<< "Vector lengths must be equal."); } double temp, distance = itk::NumericTraits::Zero; for (unsigned int i = 0; i < x1.Size(); ++i) { if (!IsMissingValue(x1[i]) && !IsMissingValue(x2[i])) { temp = x1[i] - x2[i]; distance += temp * temp; } } return distance; } template inline double EuclideanDistanceMetricWithMissingValuePow2 ::Evaluate(const TVector& x) const { MeasurementVectorSizeType measurementVectorSize = this->GetMeasurementVectorSize(); if (measurementVectorSize == 0) { itkExceptionMacro(<< "Please set the MeasurementVectorSize first"); } itk::Statistics::MeasurementVectorTraits::Assert(this->GetOrigin(), measurementVectorSize, "EuclideanDistanceMetric::Evaluate Origin and input vector have different lengths"); double temp, distance = itk::NumericTraits::Zero; for (unsigned int i = 0; i < measurementVectorSize; ++i) { if (!IsMissingValue(this->GetOrigin()[i]) && !IsMissingValue(x[i])) { temp = this->GetOrigin()[i] - x[i]; distance += temp * temp; } } return distance; } template inline double EuclideanDistanceMetricWithMissingValuePow2 ::Evaluate(const ValueType& a, const ValueType& b) const { // FIXME throw NaN exception ?? if (IsMissingValue(a) || IsMissingValue(b)) return 0.0; double temp = a - b; return temp * temp; } template /*static */ bool EuclideanDistanceMetricWithMissingValuePow2 ::IsMissingValue(const ValueType& v) { return static_cast(vnl_math_isnan(static_cast(v))); } template /* static */ void EuclideanDistanceMetricWithMissingValuePow2 ::SetToMissingValue(ValueType& v) { v = std::numeric_limits::signaling_NaN(); } } // end namespace statistics } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbFlexibleDistanceWithMissingValue.h000066400000000000000000000077161301006202600332600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlexibleDistanceWithMissingValue_h #define otbFlexibleDistanceWithMissingValue_h #include "otbEuclideanDistanceMetricWithMissingValuePow2.h" namespace otb { namespace Statistics { /** \class FlexibleDistanceWithMissingValue * \brief Non-Euclidean distance function facing missing value. * * This class is derived from EuclideanDistanceMetricWithMissingValuePow2 class to * deal with missing data. In addition, the initial Evaluate method performs * a flexible calculation of distance when a component does contain data. * * The general formulation is defined as: * \f$ d(x, y) = \sum_i | x_i^a - y_i^a |^b. \f$ * * The class can be templated over any container that holds data elements, as * for template of EuclideanDistanceMetric. * * The only restriction is that elements have to support \code NaN \endcode. * * \sa EuclideanDistanceMetricWithMissingValuePow2 * * \ingroup OTBImageManipulation */ template class ITK_EXPORT FlexibleDistanceWithMissingValue : public otb::Statistics::EuclideanDistanceMetricWithMissingValuePow2 { public: /** Standard "Self" typedef. */ typedef FlexibleDistanceWithMissingValue Self; typedef otb::Statistics::EuclideanDistanceMetricWithMissingValuePow2 Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::MeasurementVectorSizeType MeasurementVectorSizeType; /** Run-time type information (and related methods). */ itkTypeMacro(FlexibleDistanceWithMissingValue, EuclideanDistanceMetricWithMissingValuePow2); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Type of the component of a vector */ typedef typename TVector::ValueType ValueType; /** Gets the distance between the origin and x */ double Evaluate(const TVector& x) const ITK_OVERRIDE; /** Gets the distance between x1 and x2 */ double Evaluate(const TVector& x1, const TVector& x2) const ITK_OVERRIDE; /** Gets the cooridnate distance between a and b. NOTE: a and b * should be type of component */ double Evaluate(const ValueType& a, const ValueType& b) const; /** Returns true if the distance between x and the origin is less * than radius */ bool IsWithinRange(const TVector& x, const double radius) const { return Superclass::IsWithinRange(x, radius); } /** Set the value of the parameter a and b. * Those parameters are defined as static component in order to call it far * away from the instantiation of the class (through the SOM training for instance) */ static double Alpha; static double Beta; static void SetAlphaBeta(double a, double b); /** test if it is ordinary Euclidean distance */ static bool IsEuclidean(); protected: FlexibleDistanceWithMissingValue() {} ~FlexibleDistanceWithMissingValue() ITK_OVERRIDE {} }; // end of class /** Static variable instantiation */ template double FlexibleDistanceWithMissingValue::Alpha = 1.0; template double FlexibleDistanceWithMissingValue::Beta = 2.0; } // end namespace statistics } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFlexibleDistanceWithMissingValue.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbFlexibleDistanceWithMissingValue.txx000066400000000000000000000065531301006202600336520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFlexibleDistanceWithMissingValue_txx #define otbFlexibleDistanceWithMissingValue_txx #include "otbFlexibleDistanceWithMissingValue.h" #include "itkNumericTraits.h" namespace otb { namespace Statistics { template inline double FlexibleDistanceWithMissingValue ::Evaluate(const TVector& x1, const TVector& x2) const { if (IsEuclidean()) return Superclass::Evaluate(x1, x2); if (itk::NumericTraits::GetLength(x1) != itk::NumericTraits::GetLength(x2)) { itkExceptionMacro(<< "Vector lengths must be equal."); } double temp, distance = itk::NumericTraits::Zero; for (unsigned int i = 0; i < x1.Size(); ++i) { if (!this->IsMissingValue(x1[i]) && !this->IsMissingValue(x2[i])) { temp = vcl_pow(vcl_abs(vcl_pow(x1[i], this->Alpha) - vcl_pow(x2[i], this->Alpha)), this->Beta); distance += temp; } } return distance; } template inline double FlexibleDistanceWithMissingValue ::Evaluate(const TVector& x) const { if (IsEuclidean()) return Superclass::Evaluate(x); MeasurementVectorSizeType measurementVectorSize = this->GetMeasurementVectorSize(); if (measurementVectorSize == 0) { itkExceptionMacro(<< "Please set the MeasurementVectorSize first"); } itk::Statistics::MeasurementVectorTraits::Assert(this->GetOrigin(), measurementVectorSize, "EuclideanDistanceMetric::Evaluate Origin and input vector have different lengths"); double temp, distance = itk::NumericTraits::Zero; for (unsigned int i = 0; i < measurementVectorSize; ++i) { if (!this->IsMissingValue(this->GetOrigin()[i]) && !this->IsMissingValue(x[i])) { temp = vcl_pow(vcl_abs(vcl_pow(this->GetOrigin()[i], this->Alpha) - vcl_pow(x[i], this->Alpha)), this->Beta); distance += temp; } } return distance; } template inline double FlexibleDistanceWithMissingValue ::Evaluate(const ValueType& a, const ValueType& b) const { if (IsEuclidean()) return Superclass::Evaluate(a, b); // FIXME throw NaN exception instaed of returning 0. ?? if (this->IsMissingValue(a) || this->IsMissingValue(b)) return 0.0; double temp = vcl_pow(vcl_abs(vcl_pow(a, this->Alpha) - vcl_pow(b, this->Alpha)), this->Beta); return temp; } template void FlexibleDistanceWithMissingValue ::SetAlphaBeta(double a, double b) { Alpha = a; Beta = b; } template bool FlexibleDistanceWithMissingValue ::IsEuclidean() { if ((Alpha == 1.0) && (Beta == 2.0)) { return true; } else { return false; } } } // end namespace statistics } // end namespace otb #endif otbFunctionWithNeighborhoodToImageFilter.h000066400000000000000000000127351301006202600341730ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFunctionWithNeighborhoodToImageFilter_h #define otbFunctionWithNeighborhoodToImageFilter_h #include "otbFunctionToImageFilter.h" namespace otb { /** \class FunctionWithNeighborhoodToImageFilter * \brief Evaluates a ImageFunction onto a source image * * The class walks an input image and evaluates * the function at every pixel location. The output of the spatial function * and the pixel type of the output image must be compatible. * * Like its parent ImageToImageFilter, this class functions in the filtering * pipeline and produces a unique output image. * * The function has to inherit from itkImageFunction * * \sa SpatialFunctionImageEvaluatorFilter * \sa SpatialFunctionImageFilter * \sa ImageFunction * \ingroup ImageFilters * * \ingroup OTBImageManipulation */ template class ITK_EXPORT FunctionWithNeighborhoodToImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef FunctionWithNeighborhoodToImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(FunctionWithNeighborhoodToImageFilter, itk::InPlaceImageFilter); /** Some typedefs. */ /** Image size typedef. */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename InputImageType::OffsetType InputImageOffsetType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; /** Type of function. */ typedef TFunction FunctionType; typedef typename FunctionType::Pointer FunctionPointerType; typedef typename FunctionType::OutputType FunctionValueType; typedef typename FunctionType::InputType FunctionPositionType; // itkGetObjectMacro(Function, FunctionType); /** Set the internal spatial function. */ void SetFunction(FunctionPointerType function) { m_Function = function; this->Modified(); } FunctionPointerType GetFunction() { return m_Function; } /** Image dimensions */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Accessors */ itkGetMacro(Radius, InputImageSizeType); void SetRadius(InputImageSizeType& rad) { m_Radius = rad; m_Function->SetRadius(rad); this->Modified(); } itkGetMacro(Offset, InputImageOffsetType); void SetOffset(InputImageOffsetType& offset) { m_Offset = offset; m_Function->SetOffset(offset); this->Modified(); } protected: FunctionWithNeighborhoodToImageFilter(); ~FunctionWithNeighborhoodToImageFilter() ITK_OVERRIDE{} void BeforeThreadedGenerateData() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; /** SpatialFunctionImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: FunctionWithNeighborhoodToImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented //FunctionPointerType m_Function; FunctionPointerType m_Function; std::vector m_FunctionList; InputImageSizeType m_Radius; InputImageOffsetType m_Offset; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFunctionWithNeighborhoodToImageFilter.txx" #endif #endif otbFunctionWithNeighborhoodToImageFilter.txx000066400000000000000000000114661301006202600345670ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFunctionWithNeighborhoodToImageFilter_txx #define otbFunctionWithNeighborhoodToImageFilter_txx #include "otbFunctionWithNeighborhoodToImageFilter.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template FunctionWithNeighborhoodToImageFilter ::FunctionWithNeighborhoodToImageFilter() { this->InPlaceOff(); this->SetNumberOfRequiredInputs(1); m_Radius.Fill(1); m_Offset.Fill(1); m_FunctionList.clear(); m_Function = FunctionType::New(); } template void FunctionWithNeighborhoodToImageFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); InputImageConstPointer inputPtr = dynamic_cast((itk::ProcessObject::GetInput(0))); if (inputPtr.IsNull()) { itkExceptionMacro(<< "At least one input is missing." << " Input is missing :" << inputPtr.GetPointer(); ) } m_Function->SetInputImage(inputPtr); for (unsigned int i = 0; i < static_cast(this->GetNumberOfThreads()); ++i) { FunctionPointerType func = m_Function; m_FunctionList.push_back(func); } } template void FunctionWithNeighborhoodToImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output InputImagePointer inputPtr = const_cast(this->GetInput()); OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) InputImageRegionType inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius InputImageSizeType maxRad; maxRad[0] = m_Radius[0] + vcl_abs(m_Offset[0]); maxRad[1] = m_Radius[0] + vcl_abs(m_Offset[1]); inputRequestedRegion.PadByRadius(maxRad); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /** * ThreadedGenerateData function. Performs the pixel-wise addition */ template void FunctionWithNeighborhoodToImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // We use dynamic_cast since inputs are stored as DataObjects. InputImageConstPointer inputPtr = dynamic_cast((itk::ProcessObject::GetInput(0))); OutputImagePointer outputPtr = this->GetOutput(0); itk::ImageRegionConstIterator inputIt(inputPtr, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { outputIt.Set(static_cast(m_FunctionList[threadId]->EvaluateAtIndex(inputIt.GetIndex()))); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbGridResampleImageFilter.h000066400000000000000000000213011301006202600313410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGridResampleImageFilter_h #define otbGridResampleImageFilter_h #include "itkImageToImageFilter.h" #include "itkLinearInterpolateImageFunction.h" #include "itkDefaultConvertPixelTraits.h" #include "otbMacro.h" namespace otb { /** \class GridResampleImageFilter * \brief Resample input image on a new origin/spacing/size grid * * This filter resample the input image on a new grid defined by * OutputOrigin, OutputSpacing and OutputSize, using the provided * interpolator. * * This is equivalent to a itk::ResampleImageFilter using an * itk::IdentityTransform, except that it is slightly more efficient * and that in this simplified case it is possible to explicitly * compute the input requested region. The GridResampleImageFilter * therefore supports streaming, contrary to the * itk::ResampleImageFilter. * * When grid position is outside of the input image domain, the * default EdgePaddingValue is used. * * If CheckOutputBounds flag is set to true (default value), the * interpolated value will be checked for output pixel type range * prior to casting. * * \ingroup OTBImageManipulation * \ingroup Streamed * \ingroup Threaded **/ template class ITK_EXPORT GridResampleImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef GridResampleImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GridResampleImageFilter, itk::ImageToImageFilter); /** Number of dimensions. */ itkStaticConstMacro(ImageDimension, unsigned int, TOutputImage::ImageDimension); itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Typedef parameters*/ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename TOutputImage::PixelType OutputPixelType; typedef itk::DefaultConvertPixelTraits OutputPixelConvertType; typedef typename OutputPixelConvertType::ComponentType OutputPixelComponentType; /** Interpolator type */ typedef itk::InterpolateImageFunction InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointerType; typedef itk::LinearInterpolateImageFunction DefaultInterpolatorType; typedef typename InterpolatorType::OutputType InterpolatorOutputType; typedef itk::DefaultConvertPixelTraits< InterpolatorOutputType > InterpolatorConvertType; typedef typename InterpolatorConvertType::ComponentType InterpolatorComponentType; /** Input pixel continuous index typdef */ typedef typename itk::ContinuousIndex ContinuousInputIndexType; /** ImageBase typedef */ typedef itk::ImageBase ImageBaseType; typedef typename ImageBaseType::SpacingType SpacingType; typedef typename ImageBaseType::SizeType SizeType; typedef typename ImageBaseType::PointType PointType; typedef typename ImageBaseType::IndexType IndexType; itkSetMacro(OutputStartIndex,IndexType); itkGetConstReferenceMacro(OutputStartIndex,IndexType); itkSetMacro(OutputSize,SizeType); itkGetConstReferenceMacro(OutputSize,SizeType); itkSetMacro(OutputOrigin,PointType); itkGetConstReferenceMacro(OutputOrigin,PointType); itkSetMacro(OutputSpacing,SpacingType); itkGetConstReferenceMacro(OutputSpacing,SpacingType); itkSetMacro(EdgePaddingValue,OutputPixelType); itkGetConstReferenceMacro(EdgePaddingValue,OutputPixelType); itkSetMacro(CheckOutputBounds,bool); itkGetMacro(CheckOutputBounds,bool); itkBooleanMacro(CheckOutputBounds); itkSetObjectMacro(Interpolator,InterpolatorType); itkGetObjectMacro(Interpolator,InterpolatorType); /** Import output parameters from a given image */ void SetOutputParametersFromImage(const ImageBaseType * image); /** Method Compute the Modified Time based on changed to the components. */ itk::ModifiedTimeType GetMTime(void) const ITK_OVERRIDE; protected: GridResampleImageFilter(); /** Destructor */ ~GridResampleImageFilter() ITK_OVERRIDE {}; void GenerateOutputInformation() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; inline void CastPixelWithBoundsChecking( const InterpolatorOutputType& value, const InterpolatorComponentType& minComponent, const InterpolatorComponentType& maxComponent, OutputPixelType& outputValue ) const { // Method imported from itk::ResampleImageFilter const unsigned int nComponents = InterpolatorConvertType::GetNumberOfComponents(value); itk::NumericTraits::SetLength( outputValue, nComponents ); for (unsigned int n=0; n( minComponent ) ); } else if ( m_CheckOutputBounds && component > maxComponent ) { OutputPixelConvertType::SetNthComponent( n, outputValue, static_cast( maxComponent ) ); } else { OutputPixelConvertType::SetNthComponent(n, outputValue, static_cast( component ) ); } } } void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GridResampleImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented IndexType m_OutputStartIndex; // output image start index SizeType m_OutputSize; // output image size PointType m_OutputOrigin; // output image origin SpacingType m_OutputSpacing; // output image spacing OutputPixelType m_EdgePaddingValue; // Default pixel value bool m_CheckOutputBounds; // Shall we check // output bounds when // casting? InterpolatorPointerType m_Interpolator; // Interpolator used // for resampling OutputImageRegionType m_ReachableOutputRegion; // Internal // variable for // speed-up. Computed // in BeforeThreadedGenerateData }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGridResampleImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbGridResampleImageFilter.txx000066400000000000000000000334451301006202600317510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGridResampleImageFilter_txx #define otbGridResampleImageFilter_txx #include "otbGridResampleImageFilter.h" #include "otbStreamingTraits.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "itkImageScanlineIterator.h" #include "itkContinuousIndex.h" namespace otb { template GridResampleImageFilter ::GridResampleImageFilter() : m_OutputStartIndex(), m_OutputSize(), m_OutputOrigin(), m_OutputSpacing(), m_EdgePaddingValue(), m_CheckOutputBounds(true), m_Interpolator(), m_ReachableOutputRegion() { // Set linear interpolator as default m_Interpolator = dynamic_cast(DefaultInterpolatorType::New().GetPointer()); // Initialize EdgePaddingValue m_EdgePaddingValue = itk::NumericTraits::ZeroValue(m_EdgePaddingValue); // Initialize origin and spacing m_OutputOrigin.Fill(0.); m_OutputSpacing.Fill(1.); m_OutputStartIndex.Fill(0); m_OutputSize.Fill(0); } /** Import output parameters from a given image */ template void GridResampleImageFilter ::SetOutputParametersFromImage(const ImageBaseType * image) { this->SetOutputOrigin ( image->GetOrigin() ); this->SetOutputSpacing ( image->GetSpacing() ); this->SetOutputStartIndex ( image->GetLargestPossibleRegion().GetIndex() ); this->SetOutputSize ( image->GetLargestPossibleRegion().GetSize() ); } template void GridResampleImageFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointers to the input and output OutputImageType *outputPtr = this->GetOutput(); if ( !outputPtr ) { return; } // Fill output image data typename TOutputImage::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(m_OutputSize); outputLargestPossibleRegion.SetIndex(m_OutputStartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); outputPtr->SetSpacing(m_OutputSpacing); outputPtr->SetOrigin(m_OutputOrigin); // TODO: Report no data value here } template void GridResampleImageFilter ::GenerateInputRequestedRegion() { // call the superclass's implementation of this method Superclass::GenerateInputRequestedRegion(); // Check for input if ( !this->GetInput() ) { return; } // get pointers to the input and output typename TInputImage::Pointer inputPtr = const_cast< TInputImage * >( this->GetInput() ); // check for output OutputImageType *outputPtr = this->GetOutput(); if ( !outputPtr ) { return; } typename TOutputImage::RegionType outputRequestedRegion = outputPtr->GetRequestedRegion(); IndexType outULIndex,outLRIndex; typedef itk::ContinuousIndex ContinuousIndexType; ContinuousIndexType inULCIndex,inLRCIndex; // Get output image requested region corners as Index outULIndex = outputRequestedRegion.GetIndex(); outLRIndex = outULIndex+outputRequestedRegion.GetSize(); outLRIndex[0]-=1; outLRIndex[1]-=1; // Transform to physiscal points PointType outULPoint,outLRPoint; outputPtr->TransformIndexToPhysicalPoint(outULIndex,outULPoint); outputPtr->TransformIndexToPhysicalPoint(outLRIndex,outLRPoint); // Transform to input image Index inputPtr->TransformPhysicalPointToContinuousIndex(outULPoint,inULCIndex); inputPtr->TransformPhysicalPointToContinuousIndex(outLRPoint,inLRCIndex); SizeType inSize; IndexType inULIndex,inLRIndex; // Reorder index properly and compute size for(unsigned int dim = 0; dim < ImageDimension;++dim) { if(inULCIndex[dim] > inLRCIndex[dim]) { // swap typename ContinuousIndexType::ValueType tmp(inULCIndex[dim]); inULCIndex[dim]=inLRCIndex[dim]; inLRCIndex[dim]=tmp; } // Ensure correct rounding of coordinates inULIndex[dim] = vcl_floor(inULCIndex[dim]); inLRIndex[dim] = vcl_ceil(inLRCIndex[dim]); inSize[dim] = static_cast(inLRIndex[dim]-inULIndex[dim])+1; } // Build the input requested region typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion.SetIndex(inULIndex); inputRequestedRegion.SetSize(inSize); // Compute the padding due to the interpolator unsigned int interpolatorRadius = StreamingTraits::CalculateNeededRadiusForInterpolator(this->GetInterpolator()); inputRequestedRegion.PadByRadius(interpolatorRadius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); } else { // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void GridResampleImageFilter ::BeforeThreadedGenerateData() { if ( !m_Interpolator ) { itkExceptionMacro(<< "Interpolator not set"); } // Connect input image to interpolator m_Interpolator->SetInputImage( this->GetInput() ); unsigned int nComponents = itk::DefaultConvertPixelTraits::GetNumberOfComponents( m_EdgePaddingValue ); if (nComponents == 0) { // Build a default value of the correct number of components OutputPixelComponentType zeroComponent = itk::NumericTraits::ZeroValue( zeroComponent ); nComponents = this->GetInput()->GetNumberOfComponentsPerPixel(); itk::NumericTraits::SetLength(m_EdgePaddingValue, nComponents ); for (unsigned int n=0; nGetInput()->GetBufferedRegion().GetIndex(); IndexType inLR = this->GetInput()->GetBufferedRegion().GetIndex() + this->GetInput()->GetBufferedRegion().GetSize(); inLR[0]-=1; inLR[1]-=1; // We should take interpolation radius into account here, but this // does not match the IsInsideBuffer method // unsigned int interpolatorRadius = // StreamingTraits::CalculateNeededRadiusForInterpolator(this->GetInterpolator()); // inUL[0]+=interpolatorRadius; // inUL[1]+=interpolatorRadius; // inLR[0]-=interpolatorRadius; // inLR[1]-=interpolatorRadius; PointType inULp, inLRp; this->GetInput()->TransformIndexToPhysicalPoint(inUL,inULp); this->GetInput()->TransformIndexToPhysicalPoint(inLR,inLRp); inULp-=0.5*this->GetInput()->GetSpacing(); inLRp+=0.5*this->GetInput()->GetSpacing(); ContinuousInputIndexType outUL; ContinuousInputIndexType outLR; this->GetOutput()->TransformPhysicalPointToContinuousIndex(inULp,outUL); this->GetOutput()->TransformPhysicalPointToContinuousIndex(inLRp,outLR); IndexType outputIndex; // This needs to take into account negative spacing outputIndex[0] = vcl_ceil(std::min(outUL[0],outLR[0])); outputIndex[1] = vcl_ceil(std::min(outUL[1],outLR[1])); SizeType outputSize; outputSize[0] = vcl_floor(std::max(outUL[0],outLR[0])) - outputIndex[0] + 1; outputSize[1] = vcl_floor(std::max(outUL[1],outLR[1])) - outputIndex[1] + 1; m_ReachableOutputRegion.SetIndex(outputIndex); m_ReachableOutputRegion.SetSize(outputSize); } template void GridResampleImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Get the output pointers OutputImageType *outputPtr = this->GetOutput(); // Get this input pointers const InputImageType *inputPtr = this->GetInput(); // Min/max values of the output pixel type AND these values // represented as the output type of the interpolator const OutputPixelComponentType minValue = itk::NumericTraits< OutputPixelComponentType >::NonpositiveMin(); const OutputPixelComponentType maxValue = itk::NumericTraits< OutputPixelComponentType >::max(); const InterpolatorComponentType minOutputValue = static_cast< InterpolatorComponentType >( minValue ); const InterpolatorComponentType maxOutputValue = static_cast< InterpolatorComponentType >( maxValue ); // Iterator on the output region for current thread OutputImageRegionType regionToCompute = outputRegionForThread; bool cropSucceed = regionToCompute.Crop(m_ReachableOutputRegion); // Fill thread buffer itk::ImageScanlineIterator outItFull(outputPtr,outputRegionForThread); outItFull.GoToBegin(); while(!outItFull.IsAtEnd()) { while(!outItFull.IsAtEndOfLine()) { outItFull.Set(m_EdgePaddingValue); ++outItFull; } outItFull.NextLine(); } if(!cropSucceed) return; itk::ImageScanlineIterator outIt(outputPtr, regionToCompute); // Support for progress methods/callbacks itk::ProgressReporter progress( this, threadId, regionToCompute.GetSize()[1]); // Temporary variables for loop PointType outPoint; ContinuousInputIndexType inCIndex; InterpolatorOutputType interpolatorValue; //(this->GetOutput()->GetNumberOfComponentsPerPixel()); OutputPixelType outputValue; //(this->GetOutput()->GetNumberOfComponentsPerPixel()); // TODO: assert outputPtr->GetSpacing() != 0 here assert(outputPtr->GetSpacing()[0]!=0&&"Null spacing will cause division by zero."); const double delta = outputPtr->GetSpacing()[0]/inputPtr->GetSpacing()[0]; // Iterate through the output region outIt.GoToBegin(); while(!outIt.IsAtEnd()) { // Map output index to input continuous index outputPtr->TransformIndexToPhysicalPoint(outIt.GetIndex(),outPoint); inputPtr->TransformPhysicalPointToContinuousIndex(outPoint,inCIndex); while(!outIt.IsAtEndOfLine()) { // Interpolate interpolatorValue = m_Interpolator->EvaluateAtContinuousIndex(inCIndex); // Cast and check bounds this->CastPixelWithBoundsChecking(interpolatorValue,minOutputValue,maxOutputValue,outputValue); // Set output value outIt.Set(outputValue); // move one pixel forward ++outIt; // Update input position inCIndex[0]+=delta; } // Report progress progress.CompletedPixel(); // Move to next line outIt.NextLine(); } } template void GridResampleImageFilter ::AfterThreadedGenerateData() { // Disconnect input image from the interpolator m_Interpolator->SetInputImage(ITK_NULLPTR); } template itk::ModifiedTimeType GridResampleImageFilter< TInputImage, TOutputImage, TInterpolatorPrecision > ::GetMTime(void) const { itk::ModifiedTimeType latestTime = itk::Object::GetMTime(); if ( m_Interpolator ) { if ( latestTime < m_Interpolator->GetMTime() ) { latestTime = m_Interpolator->GetMTime(); } } return latestTime; } template void GridResampleImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "EdgePaddingValue: " << static_cast< typename itk::NumericTraits< OutputPixelType >::PrintType > ( m_EdgePaddingValue ) << std::endl; os << indent << "OutputStartIndex: " << m_OutputStartIndex << std::endl; os << indent << "OutputSize: " << m_OutputSize << std::endl; os << indent << "OutputOrigin: " << m_OutputOrigin << std::endl; os << indent << "OutputSpacing: " << m_OutputSpacing << std::endl; os << indent << "Interpolator: " << m_Interpolator.GetPointer() << std::endl; os << indent << "CheckOutputBounds: " << ( m_CheckOutputBounds ? "On" : "Off" ) << std::endl; } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbHillShadingFilter.h000066400000000000000000000046351301006202600302210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHillShadingFilter_h #define otbHillShadingFilter_h #include "otbUnaryFunctorNeighborhoodImageFilter.h" #include "otbHillShadingFunctor.h" namespace otb { /** \class HillShadingFilter * \brief Filter to compute the lambertian of a surface given as an image * * The light source is assumed to be at a given elevation and azimuth * (by default \f$ \pi/4 \f$ and \f$ \pi/6 \f$ respectively). This is used * to generate hill shading representation of relief. The output is * a value between 0 and 1. * * \example BasicFilters/HillShadingExample.cxx * * \ingroup OTBImageManipulation */ template class ITK_EXPORT HillShadingFilter : public UnaryFunctorNeighborhoodImageFilter, TInputImage, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef HillShadingFilter Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(HillShadingFilter, UnaryFunctorNeighborhoodImageFilter); double GetAzimuthLight() const { return this->GetFunctor().GetAzimuthLight(); } void SetAzimuthLight(double az) { this->GetFunctor().SetAzimuthLight(az); } double GetElevationLight() const { return this->GetFunctor().GetElevationLight(); } void SetElevationLight(double el) { this->GetFunctor().SetElevationLight(el); } protected: HillShadingFilter() {} ~HillShadingFilter() ITK_OVERRIDE {} private: HillShadingFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbHillShadingFunctor.h000066400000000000000000000132541301006202600304110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHillShadingFunctor_h #define otbHillShadingFunctor_h #include "itkNumericTraits.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class HillShadeModulationFunctor * \brief Modulate an image with hill shading * * Take an image (RGB) as input and the result of the hillshading * (another image with the value between 0 and 1) and modulate * the first image by the value of the hill shading. * * \ingroup Functor * \example BasicFilters/HillShadingExample.cxx * * \ingroup OTBImageManipulation */ template class HillShadeModulationFunctor { public: HillShadeModulationFunctor() {} ~HillShadeModulationFunctor() {} inline TOutput operator ()(const TInput1& A, const TInput2& B) const { TOutput out; out.SetRed( static_cast(static_cast(A.GetRed()) * static_cast(B)) ); out.SetGreen( static_cast(static_cast(A.GetGreen()) * static_cast(B)) ); out.SetBlue(static_cast(static_cast(A.GetBlue()) * static_cast(B))); return out; } }; /** \class HillShadingFunctor * \brief Unary neighborhood functor to compute the lambertian of a surface * * The light source is assumed to be at a given elevation and azimuth * (by default \f$ \pi/4 \f$ and \f$ \pi/6 \f$ respectively). This is used to generate hill shading * representation of relief. The output is a value between 0 and 1. * * \ingroup Functor * \example BasicFilters/HillShadingExample.cxx * * \ingroup OTBImageManipulation */ template class HillShadingFunctor { public: typedef HillShadingFunctor Self; typedef TNeighIter IteratorType; typedef typename IteratorType::PixelType PixelType; HillShadingFunctor() : m_AzimuthLight(30.0 * CONST_PI_180), m_ElevationLight(45.0 *CONST_PI_180), m_XRes(100.0), m_YRes(100.0), m_Scale(0.1) { m_SinElev = vcl_sin(m_ElevationLight); m_CosElev = vcl_cos(m_ElevationLight); m_SinAz = vcl_sin(m_AzimuthLight); m_CosAz = vcl_cos(m_AzimuthLight); } ~HillShadingFunctor() {} double GetXRes() const { return m_XRes; } double GetYRes() const { return m_YRes; } void SetXRes(double res) { m_XRes = vcl_abs(res); } void SetYRes(double res) { m_YRes = vcl_abs(res); } double GetScale() const { return m_Scale; } void SetScale(double scale) { m_Scale = scale; } double GetAzimuthLight() const { return m_AzimuthLight; } void SetAzimuthLight(double az) { m_AzimuthLight = az; m_SinAz = vcl_sin(m_AzimuthLight); m_CosAz = vcl_cos(m_AzimuthLight); } double GetElevationLight() const { return m_ElevationLight; } void SetElevationLight(double el) { m_ElevationLight = el; m_SinElev = vcl_sin(m_ElevationLight); m_CosElev = vcl_cos(m_ElevationLight); } inline TOutput operator ()(const TNeighIter& it) const { const typename IteratorType::OffsetType LEFT = {{-1, 0}}; const typename IteratorType::OffsetType RIGHT = {{1, 0}}; const typename IteratorType::OffsetType UP = {{0, -1}}; const typename IteratorType::OffsetType DOWN = {{0, 1}}; const typename IteratorType::OffsetType LEFTUP = {{-1, -1}}; const typename IteratorType::OffsetType RIGHTDOWN = {{1, 1}}; const typename IteratorType::OffsetType RIGHTUP = {{1, -1}}; const typename IteratorType::OffsetType LEFTDOWN = {{-1, 1}}; // const typename IteratorType::OffsetType CENTER ={{0, 0}}; float xSlope = ((makeValid(it.GetPixel(LEFTUP)) + 2 * makeValid(it.GetPixel(LEFT)) + makeValid(it.GetPixel(LEFTDOWN))) - (makeValid(it.GetPixel(RIGHTUP)) + 2 * makeValid(it.GetPixel(RIGHT)) + makeValid(it.GetPixel(RIGHTDOWN)))) / (m_XRes * m_Scale); // - as the azimuth is given compared to y axis pointing up float ySlope = -((makeValid(it.GetPixel(LEFTUP)) + 2 * makeValid(it.GetPixel(UP)) + makeValid(it.GetPixel(RIGHTUP))) - (makeValid(it.GetPixel(LEFTDOWN)) + 2 * makeValid(it.GetPixel(DOWN)) + makeValid(it.GetPixel(RIGHTDOWN))) ) / (m_YRes * m_Scale); // permutation between x and y as the azimuth angle is given compared to the north-south axis float lambertian = ((m_CosElev * m_CosAz * ySlope) + (m_CosElev * m_SinAz * xSlope) + m_SinElev) / vcl_sqrt(xSlope * xSlope + ySlope * ySlope + 1); return (lambertian + 1) / 2; //normalize between 0 and 1 } private: inline PixelType makeValid(PixelType v) const { return v < itk::NumericTraits::Zero ? itk::NumericTraits::Zero : v; } double m_AzimuthLight; // in radian double m_ElevationLight; // in radian double m_XRes; // assumed to be positive provided in m double m_YRes; // assumed to be positive provided in m double m_Scale; // precomputed parameters to avoid the sin() cos() call for each pixel double m_SinElev; double m_CosElev; double m_SinAz; double m_CosAz; }; } } #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbImageToNoDataMaskFilter.h000066400000000000000000000115711301006202600312600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToNoDataMaskFilter_h #define otbImageToNoDataMaskFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "otbNoDataHelper.h" namespace otb { namespace Functor { /** \class NoDataFunctor * \brief Functor used by ImageToNoDataMaskFilter * * See ImageToNoDataMaskFilter for complete documentation. * \ingroup OTBImageManipulation */ template class NoDataFunctor { public: NoDataFunctor(): m_Flags(), m_Values(), m_OutsideValue(0), m_InsideValue(1), m_NaNIsNoData(false) {} virtual ~NoDataFunctor(){} inline TOutputPixel operator()(const TInputPixel& in) const { return otb::IsNoData(in,m_Flags,m_Values,m_NaNIsNoData)?m_OutsideValue:m_InsideValue; } std::vector m_Flags; std::vector m_Values; TOutputPixel m_OutsideValue; TOutputPixel m_InsideValue; bool m_NaNIsNoData; }; } // End namespace Functor /** \class ImageToNoDataMaskFilter * \brief Builds a no-data mask image from no-data flags and values * * This filter reads the no-data flags (a boolean vector indicating * for each band if a no-data value exists) and values (the actual * value to be used as no-data for each band) from * MetaDataDictionary, and builds a binary mask indicating presence * or absence of no-data for each pixel. * * If NaNIsNoData is true, NaN pixels will also be considered as * no-data pixels. * * \ingroup Streamed * \ingroup MultiThreaded * \ingroup OTBImageManipulation */ template class ImageToNoDataMaskFilter : public itk::UnaryFunctorImageFilter > { public: typedef Functor::NoDataFunctor FunctorType; typedef ImageToNoDataMaskFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SpectralAngleDistanceImageFilter, itk::ImageToImageFilter); /** * Set inside value of output mask. This value will be used to * indicate absence of no-data for the pixel in the output mask */ void SetInsideValue(const typename TOutputImage::PixelType & value) { this->GetFunctor().m_InsideValue = value; } /** * Set outside value of output mask. This value will be used to * indicate presence of no-data for the pixel in the output mask */ void SetOutsideValue(const typename TOutputImage::PixelType & value) { this->GetFunctor().m_OutsideValue = value; } /** * Set the NaN is no data flags * \param nanIsNoData If true, NaN values will be considered as * no-data as well (default is false) */ void SetNaNIsNoData(bool nanIsNoData) { this->GetFunctor().m_NaNIsNoData=nanIsNoData; } protected: ImageToNoDataMaskFilter() {} ~ImageToNoDataMaskFilter() ITK_OVERRIDE {} void BeforeThreadedGenerateData() ITK_OVERRIDE { std::vector noDataValueAvailable; std::vector noDataValues; ReadNoDataFlags(this->GetInput()->GetMetaDataDictionary(),noDataValueAvailable,noDataValues); // don't pass empty containers to the functor if (noDataValueAvailable.empty() || noDataValues.empty()) { const TInputImage* input = this->GetInput(); noDataValueAvailable.assign(input->GetNumberOfComponentsPerPixel(),false); noDataValues.assign(input->GetNumberOfComponentsPerPixel(),0.0); } this->GetFunctor().m_Flags = noDataValueAvailable; this->GetFunctor().m_Values = noDataValues; } private: ImageToNoDataMaskFilter(const Self&); // purposely not implemented void operator =(const Self&); // purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbImageToVectorImageCastFilter.h000066400000000000000000000067271301006202600323250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToVectorImageCastFilter_h #define otbImageToVectorImageCastFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkVariableLengthVector.h" namespace otb { namespace Functor { /** * \class VectorCast * \brief This functor can be used to convert scalar value to VariableLengthVector with another precision * a size of 1. * \ingroup Functor * * * \ingroup OTBImageManipulation */ template class VectorCast { public: typedef typename TOutput::ValueType OutputValueType; VectorCast() {} virtual ~VectorCast() {} bool operator !=(const VectorCast&) const { return false; } bool operator ==(const VectorCast& other) const { return (*this != other); } inline TOutput operator ()(const TInput& A) { TOutput output; output.SetSize(1); output[0] = static_cast(A); return output; } }; } // End namespace Functor /** * \class ImageToVectorImageCastFilter * \brief This is a helper class that convert an otb::Image into a single-channel otb::VectorImage. * \ingroup Singlethreaded * * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ImageToVectorImageCastFilter : public itk::UnaryFunctorImageFilter > { public: /// Standard class typedefs typedef ImageToVectorImageCastFilter Self; typedef itk::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /// Method for creation through the object factory itkNewMacro(Self); /// Runtime information itkTypeMacro(ImageToVectorImageCastFilter, itk::UnaryFunctorImageFilter); protected: /// Constructor ImageToVectorImageCastFilter() {} /// Detructor ~ImageToVectorImageCastFilter() ITK_OVERRIDE {} /// Additional output information for allocation void GenerateOutputInformation(void) ITK_OVERRIDE { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel(1); } /// Copy output requested region to input requested region void GenerateInputRequestedRegion(void) ITK_OVERRIDE { if (this->GetInput()) { typename TInputImage::Pointer input = const_cast(this->GetInput()); typename TInputImage::RegionType inputRegion; this->CallCopyOutputRegionToInputRegion(inputRegion, this->GetOutput()->GetRequestedRegion()); input->SetRequestedRegion(inputRegion); } } private: ImageToVectorImageCastFilter(const Self &); //purposely not implemented void operator =(const Self&); // purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbLocalGradientVectorImageFilter.h000066400000000000000000000061531301006202600326660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalGradientVectorImageFilter_h #define otbLocalGradientVectorImageFilter_h #include "otbUnaryFunctorNeighborhoodVectorImageFilter.h" #include namespace otb { namespace Functor { /** \class LocalGradientOperator * \brief Performs the calculation of LocalGradient derivation * * \ingroup OTBImageManipulation */ template < class TInput, class TOutput > class LocalGradientOperator { public: LocalGradientOperator() { } virtual ~LocalGradientOperator() { } TOutput operator() ( const TInput & input ) { /* * it is assumed that input and output have the same size */ unsigned int length = input.GetPixel(0).Size(); TOutput output ( length ); for ( unsigned int i = 0; i < length; ++i ) { output[i] = static_cast( input.GetCenterPixel()[i] - input.GetPixel(5)[i] / 2. - input.GetPixel(7)[i] / 2. ); } return output; } }; // end of functor class } // end of namespace Functor /** \class LocalGradientVectorImageFilter * \brief Implements the 3x3 Local Gradient to be processed on a vector image * * \ingroup OTBImageManipulation */ template < class TInputImage, class TOutputImage > class ITK_EXPORT LocalGradientVectorImageFilter : public UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::LocalGradientOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > { public: /** Standard class typedefs */ typedef LocalGradientVectorImageFilter Self; typedef UnaryFunctorNeighborhoodVectorImageFilter< TInputImage, TOutputImage, Functor::LocalGradientOperator< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(LocalGradientVectorImageFilter, ImageToImageFilter); protected: LocalGradientVectorImageFilter() { typename Superclass::RadiusType radius = {{1, 1}}; this->SetRadius( radius ); } ~LocalGradientVectorImageFilter() ITK_OVERRIDE { } private: LocalGradientVectorImageFilter( const Self & ); // Not implemented void operator=( const Self & ); // Not implemented }; // end of class } // end of namespace otb #endif // otbLocalGradientVectorImageFilter_h OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbLog10ThresholdedImageFilter.h000066400000000000000000000061221301006202600320370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLog10ThresholdedImageFilter_h #define otbLog10ThresholdedImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "vnl/vnl_math.h" namespace otb { /** \class Log10ThresholdedImageFilter * \brief Computes the 10 * vcl_log10(x) pixel-wise with a threshold for the lowest values * * \ingroup OTBImageManipulation */ namespace Functor { template class Log10Thresholded { public: Log10Thresholded() { m_ThresholdValue = 0.001; // -> -30dB } ~Log10Thresholded() { } bool operator!=(const Log10Thresholded &) const { return false; } bool operator==(const Log10Thresholded & other) const { return !(*this != other); } inline TOutput operator()(const TInput & A) const { if ((static_cast (A) >= m_ThresholdValue) && (A == A)) { return static_cast (10.0 * vcl_log10(static_cast (A))); } else // If (A != A) then A is a NaN { return static_cast (10.0 * vcl_log10(m_ThresholdValue)); } } /** Set ThresholdValue method */ void SetThresholdValue(const double value) { if (value > 0.0) { m_ThresholdValue = value; } } private: double m_ThresholdValue; }; } // End namespace Functor template class ITK_EXPORT Log10ThresholdedImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef Log10ThresholdedImageFilter Self; typedef Functor::Log10Thresholded< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctorType; typedef itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, FunctorType> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(Log10ThresholdedImageFilter, itk::UnaryFunctorImageFilter); void SetThresholdedValue(double val) { this->GetFunctor().SetThresholdValue(val); } protected: Log10ThresholdedImageFilter() {} ~Log10ThresholdedImageFilter() ITK_OVERRIDE {} private: Log10ThresholdedImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbMaskedIteratorDecorator.h000066400000000000000000000077271301006202600314530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaskedIteratorDecorator_h #define otbMaskedIteratorDecorator_h #include "itkMacro.h" namespace otb { /** \class MaskedIteratorDecorator * \brief Decorate an iterator to ignore masked pixels * * An iterator that dispatches its operations on both an image and a mask using * two iterators of the same type. It skips over pixels where the value of the * mask is zero. There is a limitation that the image and the mask must both be * of the same type. * * \ingroup OTBImageManipulation */ template class MaskedIteratorDecorator { public: typedef MaskedIteratorDecorator Self; typedef typename TMaskIteratorType::ImageType MaskType; typedef typename TIteratorType::ImageType ImageType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::PixelType PixelType; typedef typename MaskType::PixelType MaskPixelType; // Run-time type information itkTypeMacroNoParent(MaskedIteratorDecorator); /** Constructors forward arguments to both iterators * Beware that the iterator is in a undefinite state after construction * GoToBegin() or GoToEnd() should be called */ MaskedIteratorDecorator(MaskType* mask, ImageType* image, const RegionType& region); /** Current iterator index. Wraps the underlying iterator GetIndex() */ IndexType GetIndex() const; /** Move to the first valid iteration position. Note that this is different * from the underlying iterators GoToBegin because their first pixels might be * masked */ void GoToBegin(); /** Move one pixel past the last valid iteration index */ void GoToEnd(); /** True if the iterator is at the beginning */ bool IsAtBegin() const; /** True if the iterator is at the end */ bool IsAtEnd() const; /** Advance to the next valid iteration position. That is the next non masked * position of the image iterator */ Self& operator++(); /** Move to the previous valid iteration position. That is the previous non * masked position of the image iterator */ Self & operator--(); /** Set the image pixel value */ //void Set(const PixelType& value) const; /** Get the image pixel value */ const PixelType& Value(void) const; // Can't wrap all methods because iterator interface is open ended // So provide access to inner iterators: /** Underlying mask iterator accessor */ TMaskIteratorType& GetMaskIterator(); /** Underlying mask iterator const accessor */ const TMaskIteratorType& GetMaskIterator() const; /** Underlying image iterator accessor */ TIteratorType& GetImageIterator(); /** Underlying image iterator const accessor */ const TIteratorType& GetImageIterator() const; const bool& HasMask() const; private: /** Private method to compute the begin iterator position taking into account the mask. Called by the constructor. */ void ComputeMaskedBegin(); private: // Inner iterators on the image and mask TMaskIteratorType m_ItMask; TIteratorType m_ItImage; // flag to check if mask is present bool m_UseMask; // Unmasked bounds TMaskIteratorType m_StartMask; TIteratorType m_StartImage; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbMaskedIteratorDecorator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbMaskedIteratorDecorator.txx000066400000000000000000000133471301006202600320420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaskedIteratorDecorator_hxx #define otbMaskedIteratorDecorator_hxx #include "otbMaskedIteratorDecorator.h" #include "itkMacro.h" namespace otb { template MaskedIteratorDecorator ::MaskedIteratorDecorator( MaskType* mask, ImageType* image, const RegionType& region) { m_ItImage = TIteratorType(image,region); if (mask == ITK_NULLPTR) { m_UseMask = false; } else { if (image->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) { itkGenericExceptionMacro("Input image and mask have different largest regions : mask is discarded!"); } else { m_UseMask = true; m_ItMask = TMaskIteratorType(mask,region); m_StartMask = TMaskIteratorType(mask,region); m_StartImage = TIteratorType(image,region); } } } template typename MaskedIteratorDecorator::IndexType MaskedIteratorDecorator ::GetIndex() const { return m_ItImage.GetIndex(); } template void MaskedIteratorDecorator ::GoToBegin() { if (m_UseMask) { this->ComputeMaskedBegin(); } else { m_ItImage.GoToBegin(); } } template void MaskedIteratorDecorator ::GoToEnd() { if (m_UseMask) { // make sure masked begin is computed as next calls might be operator--() // and IsAtBegin() (for a reverse iteration) this->ComputeMaskedBegin(); m_ItMask.GoToEnd(); } m_ItImage.GoToEnd(); } template bool MaskedIteratorDecorator ::IsAtBegin() const { if (m_UseMask) { return m_ItMask == m_StartMask || m_ItImage == m_StartImage; } return m_ItImage.IsAtBegin(); } template bool MaskedIteratorDecorator ::IsAtEnd() const { if (m_UseMask) { return m_ItMask.IsAtEnd() || m_ItImage.IsAtEnd(); } return m_ItImage.IsAtEnd(); } // Wrap the underlying iterators to skip masked pixels template MaskedIteratorDecorator& MaskedIteratorDecorator ::operator++() { if (m_UseMask) { do { ++m_ItMask; ++m_ItImage; } while (m_ItMask.Value() == 0 && !this->IsAtEnd()); } else { ++m_ItImage; } return *this; } // Wrap the underlying iterators to skip masked pixels template MaskedIteratorDecorator& MaskedIteratorDecorator ::operator--() { if (m_UseMask) { do { --m_ItMask; --m_ItImage; } while (m_ItMask.Value() == 0 && !this->IsAtBegin()); } else { --m_ItImage; } return *this; } /* template void MaskedIteratorDecorator::Set(const PixelType& value) const { m_ItImage.Set(value); } */ template const typename MaskedIteratorDecorator::PixelType& MaskedIteratorDecorator ::Value(void) const { return m_ItImage.Value(); } template TMaskIteratorType& MaskedIteratorDecorator ::GetMaskIterator() { return m_ItMask; } template const TMaskIteratorType& MaskedIteratorDecorator ::GetMaskIterator() const { return m_ItMask; } template TIteratorType& MaskedIteratorDecorator ::GetImageIterator() { return m_ItImage; } template const TIteratorType& MaskedIteratorDecorator ::GetImageIterator() const { return m_ItImage; } template const bool& MaskedIteratorDecorator ::HasMask() const { return m_UseMask; } // Compute begin iterator position taking into account the mask template void MaskedIteratorDecorator ::ComputeMaskedBegin() { // We must search for the first index where the image is not masked // Start searching at the beginning m_ItMask.GoToBegin(); m_ItImage.GoToBegin(); // Advance to the first non-masked position, or the end while (m_ItMask.Value() == 0 && !m_ItMask.IsAtEnd() && !m_ItImage.IsAtEnd()) { ++m_ItMask; ++m_ItImage; } m_StartMask.SetIndex(m_ItMask.GetIndex()); m_StartImage.SetIndex(m_ItImage.GetIndex()); } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbMatrixImageFilter.h000066400000000000000000000125021301006202600302320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMatrixImageFilter_h #define otbMatrixImageFilter_h #include "itkImageToImageFilter.h" #include "otbMath.h" namespace otb { /** \class MatrixImageFilter * \brief Apply a matrix multiplication over the channels of an image. * * The templates are the input and output image type. * The transition matrix is given using the SetTransitionMatrix() method. * The awaited type must be compatible with vnl_matrix * * The multiplication can be done as \f$ p . M \f$ or \f$ M . p \f$ where \f$ p \f$ is the pixel and \f$ M \f$ is the vector. * The behavior can be chosen with * * The number of rows of the matrix must be the input image number of channels, the number of columns is the number of channels of the output image. * * For example, if the image has 2 bands, the matrix is \f$ \begin{pmatrix} \alpha & \beta \\ \gama & \delta \end{pmatrix} \f$ * The pixel \f$ [a, b] \f$ will give the output pixel \f$ [\alpha.a + \beta.b, \gamma.a + \delta.b ]. \f$ * * * \ingroup OTBImageManipulation */ template ::RealType> > class ITK_EXPORT MatrixImageFilter : public itk::ImageToImageFilter { public: /** Extract input and output images sizes. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef to simplify variables definition and declaration. */ typedef TInputImage InputImageType; /** typedef to simplify variables definition and declaration. */ typedef TOutputImage OutputImageType; /** typedef for standard classes. */ typedef MatrixImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** "object factory" management method. */ itkNewMacro(Self); /** Return the class name. */ itkTypeMacro(MatrixImageFilter, ImageToImageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; /** MatrixType definition */ // To support complexe... typedef typename itk::NumericTraits::RealType InputRealType; typedef TMatrix MatrixType; typedef vnl_vector VectorType; /** "typedef" to define a real. */ typedef typename OutputImageType::RegionType OutputImageRegionType; /** "typedef" to define an image size. */ typedef typename InputImageType::SizeType SizeType; /** Transition matrix accessors. */ void SetMatrix( MatrixType mat) { m_Matrix = mat; this->Modified(); } MatrixType GetMatrix() { return m_Matrix; } itkGetConstMacro( MatrixByVector, bool ); itkSetMacro( MatrixByVector, bool ); itkBooleanMacro( MatrixByVector ); protected: MatrixImageFilter(); ~MatrixImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Before threaded generate data method. */ void GenerateOutputInformation() ITK_OVERRIDE; /** MatrixImageFilter can be implemented for a multithreaded filter treatment. * Thus, this implementation give the ThreadedGenerateData() method. * that is called for each process thread. Image datas are automatically allocated * through the parent class calling the ThreadedGenerateData() method. * ThreadedGenerateData() can only write the area of the image specified by the parameter "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: MatrixImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Matrix declaration */ MatrixType m_Matrix; /** If set to true, the applied operation is \f$ M . p \f$ where p is the pixel represented as a column vector. Otherwise the applied operation is \f$ p . M \f$ where p is the pixel represented as a row vector. */ bool m_MatrixByVector; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMatrixImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbMatrixImageFilter.txx000066400000000000000000000100321301006202600306220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMatrixImageFilter_txx #define otbMatrixImageFilter_txx #include "otbMatrixImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * */ template MatrixImageFilter::MatrixImageFilter() : m_MatrixByVector(false) { } template void MatrixImageFilter::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); if ( m_MatrixByVector ) { if( this->GetInput()->GetNumberOfComponentsPerPixel() != m_Matrix.cols() ) { itkExceptionMacro("Invalid Matrix size. Number of columns must be the same as the image number of channels."); } if( m_Matrix.rows() == 0 ) { itkExceptionMacro("Invalid Matrix size. Number of rows can't be null."); } this->GetOutput()->SetNumberOfComponentsPerPixel( m_Matrix.rows() ); } if ( !m_MatrixByVector ) { if( this->GetInput()->GetNumberOfComponentsPerPixel() != m_Matrix.rows() ) { itkExceptionMacro("Invalid Matrix size. Number of rows must be the same as the image number of channels."); } if( m_Matrix.cols() == 0 ) { itkExceptionMacro("Invalid Matrix size. Number of columns can't be null."); } this->GetOutput()->SetNumberOfComponentsPerPixel( m_Matrix.cols() ); } } template void MatrixImageFilter::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { // images pointer typename OutputImageType::Pointer outputPtr = this->GetOutput(); typename InputImageType::ConstPointer inputPtr = this->GetInput(); typename itk::ImageRegionConstIterator inIt( inputPtr, outputRegionForThread); itk::ImageRegionIterator outIt( outputPtr, outputRegionForThread); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inIt.GoToBegin(); outIt.GoToBegin(); const unsigned int inSize = m_MatrixByVector ? m_Matrix.cols() : m_Matrix.rows(); const unsigned int outSize = m_MatrixByVector ? m_Matrix.rows() : m_Matrix.cols(); VectorType inVect(inSize, InputRealType(0.)); VectorType outVect(outSize, InputRealType(0.)); while (!outIt.IsAtEnd()) { const InputPixelType & inPix = inIt.Get(); OutputPixelType outPix; outPix.SetSize(outSize); for(unsigned int i=0; i(inPix[i]); } outVect = m_MatrixByVector ? m_Matrix*inVect : inVect*m_Matrix; for(unsigned int i=0; i(outVect[i]); } outIt.Set(outPix); ++inIt; ++outIt; progress.CompletedPixel(); } } /** * Standard "PrintSelf" method */ template void MatrixImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Matrix: " << m_Matrix << std::endl; os << indent << "MatrixByVector: " << m_MatrixByVector << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbMeanFunctor.h000066400000000000000000000025361301006202600271040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanFunctor_h #define otbMeanFunctor_h namespace otb { namespace Functor { /** \class MeanFunctor * \brief This functor generate the mean value of a component pixels * * \ingroup OTBImageManipulation */ template class MeanFunctor { public: typedef MeanFunctor MeanFunctorType; MeanFunctor() { } ~MeanFunctor() {} inline TOutputValue operator ()(const TInput& inPix) { double value(0.); if (inPix.Size() <= 0) return static_cast (0.); for (unsigned int i = 0; i < inPix.Size(); ++i) { value += static_cast(inPix[i]); } return static_cast (value / static_cast(inPix.Size())); } }; } // end namespace functor } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbMultiplyByScalarImageFilter.h000066400000000000000000000047101301006202600322300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiplyByScalarImageFilter_h #define otbMultiplyByScalarImageFilter_h #include "itkUnaryFunctorImageFilter.h" namespace otb { /** \class MultiplyByScalarImageFilter * \brief TODO * * \ingroup OTBImageManipulation */ namespace Functor { template class MultiplyByScalar { public: MultiplyByScalar() { m_Coef = 1.0; } virtual ~MultiplyByScalar() {} inline TOutput operator ()(const TInput& value) { TOutput result; result = static_cast(m_Coef * value); return result; } void SetCoef(double Coef) { m_Coef = Coef; } double GetCoef(void) const { return (m_Coef); } private: double m_Coef; }; } template class ITK_EXPORT MultiplyByScalarImageFilter : public itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, Functor::MultiplyByScalar< typename TInputImage::PixelType, typename TOutputImage::PixelType> > { public: /** Standard class typedefs. */ typedef MultiplyByScalarImageFilter Self; typedef typename itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, Functor::MultiplyByScalar< typename TInputImage::PixelType, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); void SetCoef(double Coef) { this->GetFunctor().SetCoef(Coef); this->Modified(); } double GetCoef(void) const { return (this->GetFunctor().GetCoef()); } protected: MultiplyByScalarImageFilter() {} ~MultiplyByScalarImageFilter() ITK_OVERRIDE {} private: MultiplyByScalarImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif otbNRIBandImagesToOneNComplexBandsImage.h000066400000000000000000000060541301006202600334740ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNRIBandImagesToOneNComplexBandsImage_h #define otbNRIBandImagesToOneNComplexBandsImage_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" /* * Inputs : N images made of two real bands * Output : one single image made of N complex bands * * */ namespace otb { template class ITK_EXPORT NRIBandImagesToOneNComplexBandsImage : public itk::ImageToImageFilter { public: /** Extract input and output image dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** standard class typedefs */ typedef NRIBandImagesToOneNComplexBandsImage Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Object factory management */ itkNewMacro(Self); /** typemacro */ itkTypeMacro(NRIBandImagesToOneNComplexBandsImage, ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; protected: NRIBandImagesToOneNComplexBandsImage(); ~NRIBandImagesToOneNComplexBandsImage() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; void BeforeThreadedGenerateData(void) ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: NRIBandImagesToOneNComplexBandsImage(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNRIBandImagesToOneNComplexBandsImage.txx" #endif #endif otbNRIBandImagesToOneNComplexBandsImage.txx000066400000000000000000000072051301006202600340670ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNRIBandImagesToOneNComplexBandsImage_txx #define otbNRIBandImagesToOneNComplexBandsImage_txx #include "otbNRIBandImagesToOneNComplexBandsImage.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIterator.h" #include "itkProgressReporter.h" #include "itkVariableLengthVector.h" namespace otb { /** * */ template NRIBandImagesToOneNComplexBandsImage::NRIBandImagesToOneNComplexBandsImage() { //this->SetNumberOfThreads(1); } /** * GenerateOutputInformation */ template void NRIBandImagesToOneNComplexBandsImage ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); unsigned int nbInputs = this->GetNumberOfInputs(); this->GetOutput()->SetNumberOfComponentsPerPixel(nbInputs); } /** * BeforeThreadedGenerateData */ template void NRIBandImagesToOneNComplexBandsImage ::BeforeThreadedGenerateData(void) { unsigned int nbInputs = this->GetNumberOfInputs(); for (unsigned int i=0; iGetInput(i)->GetNumberOfComponentsPerPixel() != 2 ) itkExceptionMacro("Input images must be made of two bands and only two (see input #" << i << ")."); } /** * ThreadedGenerateData */ template void NRIBandImagesToOneNComplexBandsImage::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); unsigned int nbInputs = this->GetNumberOfInputs(); itk::VariableLengthVector< std::complex< typename InputPixelType::ValueType > > vlv(nbInputs); std::vector< typename itk::ImageRegionConstIterator > vInIt; for (unsigned int i=0; i(this->GetInput(i), outputRegionForThread) ); itk::ImageRegionIterator outIt; outIt = itk::ImageRegionIterator(this->GetOutput(), outputRegionForThread); for (unsigned int i=0; i(vInIt[i].Get()[0],vInIt[i].Get()[1]); //std::cout << "i = " << i << " " << vInIt[i].Get()[0] << " " << vInIt[i].Get()[1] << std::endl; } outIt.Set(vlv); //std::cout << "outIt.Get() = " << outIt.Get() << std::endl; for (unsigned int i=0; i void NRIBandImagesToOneNComplexBandsImage::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbOneRIBandImageToOneComplexBandImage.h000066400000000000000000000057511301006202600334160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOneRIBandImageToOneComplexBandImage_h #define otbOneRIBandImageToOneComplexBandImage_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" /* * Inputs : one image made of two real bands * Output : one image made of one complex band * * */ namespace otb { template class ITK_EXPORT OneRIBandImageToOneComplexBandImage : public itk::ImageToImageFilter { public: /** Extract input and output image dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** standard class typedefs */ typedef OneRIBandImageToOneComplexBandImage Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Object factory management */ itkNewMacro(Self); /** typemacro */ itkTypeMacro(OneRIBandImageToOneComplexBandImage, ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; protected: OneRIBandImageToOneComplexBandImage(); ~OneRIBandImageToOneComplexBandImage() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData(void) ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: OneRIBandImageToOneComplexBandImage(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOneRIBandImageToOneComplexBandImage.txx" #endif #endif otbOneRIBandImageToOneComplexBandImage.txx000066400000000000000000000052671301006202600337350ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOneRIBandImageToOneComplexBandImage_txx #define otbOneRIBandImageToOneComplexBandImage_txx #include "otbOneRIBandImageToOneComplexBandImage.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIterator.h" #include "itkProgressReporter.h" namespace otb { /** * */ template OneRIBandImageToOneComplexBandImage::OneRIBandImageToOneComplexBandImage() { //this->SetNumberOfThreads(1); } /** * BeforeThreadedGenerateData */ template void OneRIBandImageToOneComplexBandImage ::BeforeThreadedGenerateData(void) { if (this->GetInput()->GetNumberOfComponentsPerPixel() != 2 ) itkExceptionMacro("Input image must be made of two bands and only two."); } /** * ThreadedGenerateData */ template void OneRIBandImageToOneComplexBandImage::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); itk::ImageRegionIterator it; itk::ImageRegionConstIterator itIn; itIn = itk::ImageRegionConstIterator(input, outputRegionForThread); it = itk::ImageRegionIterator(output, outputRegionForThread); it.GoToBegin(); itIn.GoToBegin(); while (!it.IsAtEnd()) { it.Set(static_cast( std::complex< typename InputPixelType::ValueType >(itIn.Get()[0],itIn.Get()[1]) )); ++it; ++itIn; progress.CompletedPixel(); } } /** * Standard "PrintSelf" method */ template void OneRIBandImageToOneComplexBandImage::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbPerBandVectorImageFilter.h000066400000000000000000000113021301006202600314610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPerBandVectorImageFilter_h #define otbPerBandVectorImageFilter_h #include "otbVectorImageToImageListFilter.h" #include "otbImageListToImageListApplyFilter.h" #include "otbImageListToVectorImageFilter.h" #include "otbImageList.h" #include "otbImage.h" #include "itkImageToImageFilter.h" namespace otb { /** \class PerBandVectorImageFilter * \brief This filter is a helper class to apply per band a standard itk::ImageToImageFilter to a VectorImage. * * This filter is a composite filter composed of the following filters : * - VectorImageToImageListFilter * - ImageListToImageListApplyFilter * - ImageListToVectorImageFilter * * \sa VectorImageToImageListFilter * \sa ImageListToImageListApplyFilter * \sa ImageListToVectorImageFilter * \ingroup Streamed * * \ingroup OTBImageManipulation */ template class ITK_EXPORT PerBandVectorImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef PerBandVectorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(PerBandVectorImageFilter, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputVectorImageType; typedef typename InputVectorImageType::Pointer InputVectorImagePointerType; typedef typename InputVectorImageType::InternalPixelType InputPixelType; typedef Image InputImageType; typedef ImageList InputImageListType; typedef TOutputImage OutputVectorImageType; typedef typename OutputVectorImageType::Pointer OutputVectorImagePointerType; typedef typename OutputVectorImageType::InternalPixelType OutputPixelType; typedef Image OutputImageType; typedef ImageList OutputImageListType; typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; // Internal filters definition typedef VectorImageToImageListFilter DecompositionFilterType; typedef typename DecompositionFilterType::Pointer DecompositionFilterPointerType; typedef ImageListToImageListApplyFilter ProcessingFilterType; typedef typename ProcessingFilterType::Pointer ProcessingFilterPointerType; typedef ImageListToVectorImageFilter RecompositionFilterType; typedef typename RecompositionFilterType::Pointer RecompositionFilterPointerType; /// Accessors itkSetObjectMacro(Filter, FilterType); itkGetObjectMacro(Filter, FilterType); itkSetMacro(OutputIndex, unsigned int); itkGetMacro(OutputIndex, unsigned int); void GenerateInputRequestedRegion(void) ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; protected: /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** Constructor */ PerBandVectorImageFilter(); /** Destructor */ ~PerBandVectorImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PerBandVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /// The processing filter FilterPointerType m_Filter; /// The index of the output of the filter to gather unsigned m_OutputIndex; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPerBandVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbPerBandVectorImageFilter.txx000066400000000000000000000071261301006202600320660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPerBandVectorImageFilter_txx #define otbPerBandVectorImageFilter_txx #include "otbPerBandVectorImageFilter.h" namespace otb { /** * Constructor */ template PerBandVectorImageFilter ::PerBandVectorImageFilter() { m_Filter = FilterType::New(); m_OutputIndex = 0; } template void PerBandVectorImageFilter ::GenerateOutputInformation() { if (this->GetInput()) { // Create a false monoband image typename InputImageType::Pointer dummyInputImage = InputImageType::New(); dummyInputImage->CopyInformation(this->GetInput()); dummyInputImage->SetNumberOfComponentsPerPixel(1); m_Filter->SetInput(dummyInputImage); m_Filter->UpdateOutputInformation(); this->GetOutput()->CopyInformation(m_Filter->GetOutput(m_OutputIndex)); this->GetOutput()->SetNumberOfComponentsPerPixel(this->GetInput()->GetNumberOfComponentsPerPixel()); } } template void PerBandVectorImageFilter ::GenerateInputRequestedRegion() { InputVectorImageType * inputPtr = const_cast(this->GetInput()); typename InputImageType::Pointer dummyInputImage = InputImageType::New(); dummyInputImage->CopyInformation(this->GetInput()); dummyInputImage->SetNumberOfComponentsPerPixel(1); m_Filter->SetInput(dummyInputImage); m_Filter->GetOutput(m_OutputIndex)->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); m_Filter->PropagateRequestedRegion(this->GetOutput()); inputPtr->SetRequestedRegion(m_Filter->GetInput()->GetRequestedRegion()); } /** * Main computation method */ template void PerBandVectorImageFilter ::GenerateData() { InputVectorImageType * inputPtr = const_cast(this->GetInput()); OutputVectorImagePointerType outputPtr = this->GetOutput(); DecompositionFilterPointerType decomposer = DecompositionFilterType::New(); ProcessingFilterPointerType processor = ProcessingFilterType::New(); RecompositionFilterPointerType recomposer = RecompositionFilterType::New(); inputPtr->UpdateOutputData(); decomposer->SetInput(this->GetInput()); processor->SetInput(decomposer->GetOutput()); processor->SetFilter(m_Filter); processor->SetOutputIndex(m_OutputIndex); recomposer->SetInput(processor->GetOutput()); recomposer->GetOutput()->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); recomposer->GraftOutput(this->GetOutput()); recomposer->Update(); this->GraftOutput(recomposer->GetOutput()); } /** * PrintSelf Method */ template void PerBandVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbPhaseFunctor.h000066400000000000000000000071261301006202600272640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPhaseFunctor_h #define otbPhaseFunctor_h #include "otbChannelSelectorFunctor.h" namespace otb { namespace Function { /** \class PhaseFunctor * \brief Compute the module from the selected channel in the input * * \ingroup Visualization * * \sa AmplitudeFunctor ChannelSelectorFunctor * * \ingroup OTBImageManipulation */ template class PhaseFunctor : public ChannelSelectorFunctor { public: /** Standard class typedefs */ typedef PhaseFunctor Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory */ itkNewMacro(Self); /** Runtime information */ itkTypeMacro(PhaseFunctor, itk::Object); typedef TInputPixel PixelType; typedef typename itk::NumericTraits::ValueType ScalarType; typedef itk::VariableLengthVector VectorPixelType; typedef itk::RGBPixel RGBPixelType; typedef itk::RGBAPixel RGBAPixelType; typedef VectorPixelType OutputPixelType; /** Constructor */ PhaseFunctor() { std::vector channels; channels.push_back(0); channels.push_back(1); this->SetChannelList(channels); } /** Destructor */ ~PhaseFunctor() ITK_OVERRIDE {} const char *GetDescription() const {return "Phase"; } unsigned int GetOutputSize() const ITK_OVERRIDE { return 1; } OutputPixelType operator ()(const VectorPixelType& inPixel) const ITK_OVERRIDE { OutputPixelType outPixel; outPixel.SetSize(1); assert((this->GetChannelList()).size() == 2); assert((this->GetChannelList())[0] < inPixel.Size()); assert((this->GetChannelList())[1] < inPixel.Size()); outPixel[0] = ComputePhase(inPixel[(this->GetChannelList())[0]], inPixel[(this->GetChannelList())[1]]); return outPixel; } OutputPixelType operator ()(ScalarType /*inPixel*/) const ITK_OVERRIDE { //FIXME we don't handle the std::complex<> yet itkExceptionMacro(<< "Can't compute amplitude from a scalar value"); } OutputPixelType operator ()(const RGBPixelType& inPixel) const ITK_OVERRIDE { OutputPixelType outPixel; outPixel.SetSize(1); assert((this->GetChannelList())[0] < 3); assert((this->GetChannelList())[1] < 3); outPixel[0] = ComputePhase(inPixel[(this->GetChannelList())[0]], inPixel[(this->GetChannelList())[1]]); return outPixel; } OutputPixelType operator ()(const RGBAPixelType& inPixel) const ITK_OVERRIDE { OutputPixelType outPixel; outPixel.SetSize(1); assert((this->GetChannelList())[0] < 4); assert((this->GetChannelList())[1] < 4); outPixel[0] = ComputePhase(inPixel[(this->GetChannelList())[0]], inPixel[(this->GetChannelList())[1]]); return outPixel; } private: inline ScalarType ComputePhase(ScalarType a, ScalarType b) const { return vcl_atan2(b, a); } }; } } #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbPrintableImageFilter.h000066400000000000000000000202051301006202600307050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPrintableImageFilter_h #define otbPrintableImageFilter_h #include "otbImage.h" #include "itkImageToImageFilter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbMultiChannelExtractROI.h" #include "itkBinaryFunctorImageFilter.h" namespace otb { namespace Functor { /** * \class MaskFunctor * \brief Output is a InputPixel if MaskPixel is m_Background and a * defined other value (m_ObjectColor) otherwise. * * \ingroup OTBImageManipulation */ template class ITK_EXPORT MaskFunctor { public: MaskFunctor() { m_BackgroundValue = 0; m_ObjectColor.SetSize(3); m_ObjectColor.Fill(255); }; ~MaskFunctor(){} typedef TInputPixel InputPixelType; typedef TMaskPixel MaskPixelType; typedef TOutputPixel OutputPixelType; typedef typename OutputPixelType::ValueType OutputInternalPixelType; MaskPixelType GetBackgroundValue() { return m_BackgroundValue; } void SetBackgroundValue(MaskPixelType val) { m_BackgroundValue = val; } OutputPixelType GetObjectColor() { return m_ObjectColor; } void SetObjectColor(OutputPixelType val) { m_ObjectColor = val; } inline OutputPixelType operator ()(InputPixelType inPix, MaskPixelType maskPix) const { OutputPixelType outPix; if (maskPix == m_BackgroundValue) { outPix.SetSize(inPix.Size()); for (unsigned int i = 0; i < outPix.Size(); ++i) { outPix[i] = static_cast(inPix[i]); } } else { outPix = m_ObjectColor; } return outPix; } protected: MaskPixelType m_BackgroundValue; OutputPixelType m_ObjectColor; }; } /** * \class PrintableImageFilter * \brief This class is a helper class to turn a vector image to a generic 8 bytes RGB image. * A mask can be used to highlight some objects represented by the same value. * The mask is a binary image. Background MaskValue is used to precise which * value of the mask are objects (default 0). * Output object color can be set using m_ObjectColor (default white). * The output is a 3 channel image, each channel is a channel of the input image. * They can be selected using m_ChannelList or SetChannel(int ch ) method. * * It is useful for publications for instance. * * \sa itkImageToImageFilter * * \ingroup OTBImageManipulation **/ template > class ITK_EXPORT PrintableImageFilter : public itk::ImageToImageFilter > { public: typedef PrintableImageFilter Self; typedef itk::ImageToImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; // typedef typename itk::NumericTraits::ValueType InputInternalPixelType; typedef unsigned char OutputInternalPixelType; typedef VectorImage OutputImageType; typedef OutputImageType::PixelType OutputPixelType; typedef TMaskImage MaskImageType; typedef typename MaskImageType::Pointer MaskImagePointerType; typedef typename MaskImageType::PixelType MaskPixelType; typedef otb::MultiChannelExtractROI ChannelExtractorType; typedef typename ChannelExtractorType::ChannelsType ChannelsType; typedef VectorRescaleIntensityImageFilter VectorRescalerType; typedef Functor::MaskFunctor FunctorType; typedef itk::BinaryFunctorImageFilter FunctorFilterType; typedef typename FunctorFilterType::Pointer FunctorFilterPointerType; /** Method for creation through object factory */ itkNewMacro(Self); /** Run-time type information */ itkTypeMacro(PrintableImageFilter, itk::ImageToImageFilter); /** Display */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void SetChannel(unsigned int channel); const ChannelsType GetChannels(void) const; otbSetObjectMemberMacro(Rescaler, AutomaticInputMinMaxComputation, bool); otbGetObjectMemberMacro(Rescaler, AutomaticInputMinMaxComputation, bool); otbSetObjectMemberMacro(Rescaler, InputMinimum, InputPixelType); otbGetObjectMemberMacro(Rescaler, InputMinimum, InputPixelType); otbSetObjectMemberMacro(Rescaler, InputMaximum, InputPixelType); otbGetObjectMemberMacro(Rescaler, InputMaximum, InputPixelType); /** * If set, only pixels within the mask will be classified. * \param mask The input mask. */ void SetInputMask(const MaskImageType * mask); /** * Get the input mask. * \return The mask. */ MaskImageType * GetInputMask(void); itkSetMacro(UseMask, bool); itkGetMacro(UseMask, bool); ChannelsType const GetChannelList() { return m_ChannelList; } /* Set the selected channel index (order is important) */ void SetChannelList(ChannelsType chList) { if (chList.size() != 3) { itkExceptionMacro(<< "Invalid channel list, size is " << chList.size() << " instead of 3"); } m_ChannelList = chList; this->Modified(); } /** Output Mask Object color. */ void SetObjectColor(OutputPixelType val) { if (val.GetSize() != 3) { itkExceptionMacro(<< "Invalid object color, size is " << val.Size() << " instead of 3"); } m_ObjectColor = val; m_MaskFilter->GetFunctor().SetObjectColor(val); this->Modified(); } itkGetMacro(ObjectColor, OutputPixelType); void SetBackgroundMaskValue(MaskPixelType val) { m_BackgroundMaskValue = val; m_MaskFilter->GetFunctor().SetBackgroundValue(val); this->Modified(); } itkGetMacro(BackgroundMaskValue, MaskPixelType); /** PrintableImageFilter can produce an image which is a different * resolution than its input image. As such, PrintableImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; protected: PrintableImageFilter(); void BeforeGenerateData(); void GenerateData() ITK_OVERRIDE; private: PrintableImageFilter(Self &); // intentionally not implemented void operator =(const Self&); // intentionally not implemented typename VectorRescalerType::Pointer m_Rescaler; typename ChannelExtractorType::Pointer m_Extractor; // Foreground mask value FunctorFilterPointerType m_MaskFilter; // Objects (of the mask) will be displayer with the chosen color. OutputPixelType m_ObjectColor; // Use mask bool m_UseMask; // Used channel for output Image ChannelsType m_ChannelList; // Foreground mask value //MaskPixelType m_ForegroundMaskValue; // Background mask value MaskPixelType m_BackgroundMaskValue; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPrintableImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbPrintableImageFilter.txx000066400000000000000000000125151301006202600313060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPrintableImageFilter_txx #define otbPrintableImageFilter_txx #include "otbPrintableImageFilter.h" namespace otb { template PrintableImageFilter ::PrintableImageFilter() { m_Rescaler = VectorRescalerType::New(); m_Extractor = ChannelExtractorType::New(); m_Rescaler->SetInput(m_Extractor->GetOutput()); m_MaskFilter = FunctorFilterType::New(); m_ChannelList = ChannelsType(3, 2); m_ChannelList[1] = 3; m_ChannelList[2] = 4; m_ObjectColor.SetSize(3); m_ObjectColor.Fill(255); m_UseMask = false; m_BackgroundMaskValue = 0; } template void PrintableImageFilter ::SetChannel(unsigned int channel) { m_ChannelList.push_back(channel); m_Extractor->SetChannel(channel); this->Modified(); } template const typename PrintableImageFilter::ChannelsType PrintableImageFilter ::GetChannels() const { return m_ChannelList; } template void PrintableImageFilter ::SetInputMask(const MaskImageType * mask) { this->itk::ProcessObject::SetNthInput(1, const_cast(mask)); m_UseMask = true; } template typename PrintableImageFilter::MaskImageType * PrintableImageFilter ::GetInputMask() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void PrintableImageFilter ::GenerateOutputInformation() { // Call to the superclass implementation Superclass::GenerateOutputInformation(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); outputPtr->SetNumberOfComponentsPerPixel(3); } template void PrintableImageFilter ::BeforeGenerateData() { if (m_Extractor->GetNbChannels() == 0 && m_ChannelList.size() > 3) { itkExceptionMacro(<< "Invalid channel list (must be three channels instead of " << m_ChannelList.size()); } if (m_Extractor->GetNbChannels() == 0 && m_Extractor->GetNbChannels() > 3) { itkExceptionMacro(<< "Invalid channel list (must be three channels instead of " << m_Extractor->GetNbChannels()); } if (m_ObjectColor.GetSize() != 3) { itkExceptionMacro(<< "Invalid m_ObjectColor pixel size"); } if (m_UseMask == true) { MaskImagePointerType inputMaskPtr = this->GetInputMask(); typename InputImageType::ConstPointer inputPtr = this->GetInput(); if (!inputMaskPtr) { itkExceptionMacro(<< "No mask detected"); } if (inputMaskPtr->GetLargestPossibleRegion().GetSize() != inputPtr->GetLargestPossibleRegion().GetSize()) { itkExceptionMacro( << "Input size (" << inputPtr->GetLargestPossibleRegion().GetSize() << ") and Mask size (" << inputMaskPtr->GetLargestPossibleRegion().GetSize() << ") must be the same"); } } } /* * If no mask used, just rescale the input between 0 and 255. * Else, sur M%askFunctor. */ template void PrintableImageFilter ::GenerateData() { this->BeforeGenerateData(); // let this loop to be compliant with previous version of the class where m_ChannelList didn't exist... if (m_Extractor->GetNbChannels() == 0) { for (unsigned int i = 0; i < m_ChannelList.size(); ++i) m_Extractor->SetChannel(m_ChannelList[i]); } m_Extractor->SetInput(this->GetInput()); m_Extractor->UpdateOutputInformation(); typename TInputImage::PixelType minimum, maximum; minimum.SetSize(m_Extractor->GetNbChannels()); maximum.SetSize(m_Extractor->GetNbChannels()); minimum.Fill(0); maximum.Fill(255); m_Rescaler->SetOutputMinimum(minimum); m_Rescaler->SetOutputMaximum(maximum); m_Rescaler->SetClampThreshold(0.01); if (m_UseMask == false) { m_Rescaler->GraftOutput(this->GetOutput()); m_Rescaler->Update(); this->GraftOutput(m_Rescaler->GetOutput()); } else { m_MaskFilter->SetInput1(m_Rescaler->GetOutput()); m_MaskFilter->SetInput2(this->GetInputMask()); m_MaskFilter->GraftOutput(this->GetOutput()); m_MaskFilter->Update(); this->GraftOutput(m_MaskFilter->GetOutput()); } } template void PrintableImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif otbRealAndImaginaryImageToComplexImageFilter.h000066400000000000000000000105011301006202600346510ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRealAndImaginaryImageToComplexImageFilter_h #define otbRealAndImaginaryImageToComplexImageFilter_h #include "itkBinaryFunctorImageFilter.h" #include "vnl/vnl_math.h" namespace otb { /** \class RealAndImaginaryImageToComplexImageFilter * \brief Computes pixel-wise the complex image of a real and imaginary image. * * \sa RealAndImaginaryImageToComplexImageFilter * \ingroup Multithreaded * * \ingroup OTBImageManipulation */ namespace Function { template< class TInputImageRealPart, class TInputImageImaginaryPart, class TOutput> class RealAndImaginaryToComplex { public: typedef typename TOutput::value_type OutputValueType; RealAndImaginaryToComplex() {} ~RealAndImaginaryToComplex() {} bool operator!=( const RealAndImaginaryToComplex & ) const { return false; } bool operator==( const RealAndImaginaryToComplex & other ) const { return !(*this != other); } inline TOutput operator()( const TInputImageRealPart & real, const TInputImageImaginaryPart & imaginary ) const { return TOutput(static_cast(real), static_cast(imaginary)); } }; } template class ITK_EXPORT RealAndImaginaryImageToComplexImageFilter : public itk::BinaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef RealAndImaginaryImageToComplexImageFilter Self; typedef itk::BinaryFunctorImageFilter< TInputImageRealPart, TInputImageImaginaryPart, TOutputImage, Function::RealAndImaginaryToComplex< typename TInputImageRealPart::PixelType, typename TInputImageImaginaryPart::PixelType, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(RealAndImaginaryImageToComplexImageFilter, BinaryFunctorImageFilter); typedef typename TInputImageRealPart::PixelType InputRealPartPixelType; typedef typename TInputImageImaginaryPart::PixelType InputImaginaryPartPixelType; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename itk::NumericTraits< OutputPixelType >::ValueType OutputPixelValueType; //#ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ // itkConceptMacro(InputConvertibleToOutputCheck, // (Concept::Convertible)); // itkConceptMacro(InputConvertibleToOutputCheck, // (Concept::Convertible)); /** End concept checking */ //#endif void SetInputRealPart(const TInputImageRealPart * imageRealPart ) { this->SetInput1( imageRealPart ); } void SetInputImaginaryPart(const TInputImageImaginaryPart * imageImaginaryPart ) { this->SetInput2( imageImaginaryPart ); } protected: RealAndImaginaryImageToComplexImageFilter() {} ~RealAndImaginaryImageToComplexImageFilter() ITK_OVERRIDE {} private: RealAndImaginaryImageToComplexImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbRealImageToComplexImageFilter.h000066400000000000000000000060411301006202600324500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRealImageToComplexImageFilter_h #define otbRealImageToComplexImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "vnl/vnl_math.h" namespace otb { /** \class RealImageToComplexImageFilter * \brief Computes pixel-wise the complex image of a real image. * * \sa RealImageToComplexImageFilter * \ingroup Multithreaded * * \ingroup OTBImageManipulation */ namespace Function { template< class TInputImageRealPart, class TOutput> class RealToComplex { public: typedef typename TOutput::value_type OutputValueType; RealToComplex() {} ~RealToComplex() {} bool operator!=( const RealToComplex & ) const { return false; } bool operator==( const RealToComplex & other ) const { return !(*this != other); } inline TOutput operator()( const TInputImageRealPart & real) const { return TOutput(static_cast(real), static_cast(0.0)); } }; } template class ITK_EXPORT RealImageToComplexImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef RealImageToComplexImageFilter Self; typedef itk::UnaryFunctorImageFilter< TInputImageRealPart, TOutputImage, Function::RealToComplex< typename TInputImageRealPart::PixelType, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(RealImageToComplexImageFilter, UnaryFunctorImageFilter); typedef typename TInputImageRealPart::PixelType InputRealPartPixelType; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename itk::NumericTraits< OutputPixelType >::ValueType OutputPixelValueType; protected: RealImageToComplexImageFilter() {} ~RealImageToComplexImageFilter() ITK_OVERRIDE {} private: RealImageToComplexImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbShiftScaleImageAdaptor.h000066400000000000000000000115461301006202600311670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbShiftScaleImageAdaptor_h #define otbShiftScaleImageAdaptor_h #include "vnl/vnl_math.h" #include "itkImageAdaptor.h" namespace otb { namespace Accessor { /** \class ShiftScalePixelAccessor * \brief Apply a shift scale operation to the value * * ShiftScalePixelAccessor shifts the input pixel by Shift * and then scales the pixel by Scale. All computations * are performed in the precision of the input pixel's RealType * * ShiftScalePixelAccessor is templated over an internal type and an * external type representation. This class cast the input * applies the function to it and cast the result according * to the types defined as template parameters * * \ingroup ImageAdaptors * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ShiftScalePixelAccessor { public: /** External typedef. It defines the external aspect * that this class will exhibit. */ typedef TExternalType ExternalType; /** Internal typedef. It defines the internal real * representation of data. */ typedef typename itk::NumericTraits::RealType InternalType; InternalType GetShift() const { return m_Shift; } void SetShift(InternalType value) { m_Shift = value; } InternalType GetScale() const { return m_Scale; } void SetScale(InternalType value) { m_Scale = value; } inline void Set(InternalType& output, const ExternalType& input) { output = static_cast(m_Scale * (static_cast(input) + m_Shift)); } inline const ExternalType Get(const InternalType& input) const { return static_cast(m_Scale * (static_cast(input) + m_Shift)); } private: InternalType m_Shift; InternalType m_Scale; }; } // end namespace Accessor /** \class ShiftScaleImageAdaptor * \brief Presents an image as being composed of the shift scale operation of its pixels * * Additional casting is performed according to the input and output image * types following C++ default casting rules. * * \ingroup ImageAdaptors * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ShiftScaleImageAdaptor : public itk::ImageAdaptor > { public: /** Standard class typedefs. */ typedef ShiftScaleImageAdaptor Self; typedef itk::ImageAdaptor< TImage, Accessor::ShiftScalePixelAccessor > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename TImage::PixelType InternalType; typedef typename Superclass::IndexType IndexType; typedef typename Accessor::ShiftScalePixelAccessor< typename TImage::PixelType, TOutputPixelType> AccessorType; typedef typename AccessorType::ExternalType PixelType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ShiftScaleImageAdaptor, ImageAdaptor); typename TImage::PixelType GetShift() const { itkDebugMacro("returning " << " m_Shift of " << this->GetPixelAccessor().GetShift()); return this->GetPixelAccessor().GetShift(); } virtual void SetShift(typename TImage::PixelType value) { itkDebugMacro("setting m_Shift to " << value); if (this->GetPixelAccessor().GetShift() != value) { this->GetPixelAccessor().SetShift(value); this->Modified(); } } typename TImage::PixelType GetScale() const { itkDebugMacro("returning " << " m_Scale of " << this->GetPixelAccessor().GetScale()); return this->GetPixelAccessor().GetScale(); } virtual void SetScale(typename TImage::PixelType value) { itkDebugMacro("setting m_Scale to " << value); if (this->GetPixelAccessor().GetScale() != value) { this->GetPixelAccessor().SetScale(value); this->Modified(); } } protected: ShiftScaleImageAdaptor() {} ~ShiftScaleImageAdaptor() ITK_OVERRIDE {} private: ShiftScaleImageAdaptor(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbShiftScaleVectorImageFilter.h000066400000000000000000000146441301006202600322070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbShiftScaleImageFilter_h #define otbShiftScaleImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkVariableLengthVector.h" namespace otb { namespace Functor { /** \class VectorShiftScale * \brief This functor performs a per band linear transform of its input. * * For each band, the following formula is applied : * * \f[ output = \frac{input - shift}{scale} \f] * * Standard casting is applied between input and output type. * * Shifts and scales can be set via the SetShiftValues() and SetScaleValues() methods. * * TInput and TOutput type are supposed to be of type itk::VariableLengthVector. * * * \ingroup OTBImageManipulation */ template class VectorShiftScale { public: public: /// Real type typedef typedef typename itk::NumericTraits::RealType RealType; /// Constructor VectorShiftScale() {} /// Constructor virtual ~VectorShiftScale() {} /// Accessors void SetShiftValues(TInput value) { m_Shift = value; } void SetScaleValues(TInput value) { m_Scale = value; } TInput GetShiftValues() { return m_Shift; } TInput GetScaleValues() { return m_Scale; } bool operator !=(const VectorShiftScale& other) const { if (m_Shift.Size() == other.GetShiftValues().Size()) { for (unsigned int i = 0; i < m_Shift.Size(); ++i) { if (m_Shift[i] != other.GetShiftValues()[i]) { return true; } } } if (m_Scale.Size() == other.GetScaleValues().Size()) { for (unsigned int i = 0; i < m_Scale.Size(); ++i) { if (m_Scale[i] != other.GetScaleValues()[i]) { return true; } } } return false; } bool operator==(const VectorShiftScale & other) const { return !(*this != other); } // main computation method inline TOutput operator()(const TInput & x) const { // output instantiation TOutput result; result.SetSize(x.GetSize()); // consistency checking if (result.GetSize() != m_Scale.GetSize() || result.GetSize() != m_Shift.GetSize()) { itkGenericExceptionMacro(<< "Pixel size different from scale or shift size !"); } // transformation for (unsigned int i = 0; i < x.GetSize(); ++i) { if ( m_Scale[i] > 1e-10) { const RealType invertedScale = 1 / m_Scale[i]; result[i] = static_cast (invertedScale * (x[i] - m_Shift[i]) ); } else { result[i] = static_cast (x[i] - m_Shift[i]); } } return result; } private: TInput m_Shift; TOutput m_Scale; }; } // End namespace Functor /** \class ShiftScaleVectorImageFilter * \brief This filter performs a shift and scaling of a vector image on a per band basis. * * For each band, the following formula is applied : * * \f[ output = \frac{input - shift}{scale} \f] * * Beware that the behaviour differs from itk::ShiftScaleImageFilter * (which add shift instead of subtracting it). * * \sa VectorShiftScale * \ingroup IntensityImageFilters * \ingroup MultiThreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ShiftScaleVectorImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ShiftScaleVectorImageFilter Self; typedef Functor::VectorShiftScale< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctorType; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename TInputImage::PixelType InputPixelType; typedef typename InputPixelType::ValueType InputValueType; typedef typename OutputPixelType::ValueType OutputValueType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename itk::NumericTraits::RealType OutputRealType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ShiftScaleImageFilter, itk::UnaryFunctorImageFilter); itkGetMacro(Scale, InputPixelType); itkSetMacro(Scale, InputPixelType); itkGetMacro(Shift, InputPixelType); itkSetMacro(Shift, InputPixelType); protected: ShiftScaleVectorImageFilter() {} ~ShiftScaleVectorImageFilter() ITK_OVERRIDE {} /** Process to execute before entering the multithreaded section */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; private: ShiftScaleVectorImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented InputPixelType m_Scale; InputPixelType m_Shift; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbShiftScaleVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbShiftScaleVectorImageFilter.txx000066400000000000000000000040541301006202600325750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbShiftScaleVectorImageFilter_txx #define otbShiftScaleVectorImageFilter_txx #include "otbShiftScaleVectorImageFilter.h" namespace otb { /** * Generate output information. */ template void ShiftScaleVectorImageFilter ::GenerateOutputInformation(void) { this->Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() ); } /** * Generate input requested region. */ template void ShiftScaleVectorImageFilter ::GenerateInputRequestedRegion(void) { if (this->GetInput()) { typename TInputImage::Pointer input = const_cast(this->GetInput()); typename TInputImage::RegionType inputRegion; this->CallCopyOutputRegionToInputRegion(inputRegion, this->GetOutput()->GetRequestedRegion()); input->SetRequestedRegion(inputRegion); } } /** * Process to execute before entering the multithreaded section. */ template void ShiftScaleVectorImageFilter ::BeforeThreadedGenerateData() { // set up the functor values this->GetFunctor().SetScaleValues(m_Scale); this->GetFunctor().SetShiftValues(m_Shift); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbSpectralAngleDistanceImageFilter.h000066400000000000000000000105251301006202600331700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralAngleDistanceImageFilter_h #define otbSpectralAngleDistanceImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class SpectralAngleDistanceImageFilter * \brief This filter implements the computation of the spectral angle * distance with respect to a reference pixel. * * Spectral angle distance is an efficient way to convert spectral information to * scalar data with respect to a reference pixel. The spectral angle distance * is defined as: * * \f[SA = cos^{-1}\Big(\frac{{\sum_{b=1}^{n_{b}}}r(b)\cdot p(b)}{\sqrt{{\sum_{b=1}^{n_{b}}}r(b)^{2}{\sum_{b=1}^{n_{b}}p(b)^{2}}}}\Big) \f] * with \f$b\f$ being the spectral band, \f$r\f$ the reference pixel and \f$p\f$ * the current pixel. * * Since the spectral angle deals with multi-bands image, the InputImage pixels are supposed to * support the [] operator, and the input image to support the GetNumberOfComponentsPerPixel() method. * * \sa VectorImage * * This filter is implemented as a multithreaded filter. * * \ingroup IntensityImageFilters * \ingroup Threading * \ingroup Streamed * * \ingroup OTBImageManipulation */ template class ITK_EXPORT SpectralAngleDistanceImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef SpectralAngleDistanceImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SpectralAngleDistanceImageFilter, itk::ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; /** Get/Set the reference pixel */ itkGetConstReferenceMacro(ReferencePixel, InputPixelType); itkSetMacro(ReferencePixel, InputPixelType); protected: /** Constructor */ SpectralAngleDistanceImageFilter(); /** Destructor */ ~SpectralAngleDistanceImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** SpectralAngleDistanceImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; private: SpectralAngleDistanceImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The reference pixel */ InputPixelType m_ReferencePixel; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSpectralAngleDistanceImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbSpectralAngleDistanceImageFilter.txx000066400000000000000000000102121301006202600335550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralAngleDistanceImageFilter_txx #define otbSpectralAngleDistanceImageFilter_txx #include "otbSpectralAngleDistanceImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { /** * Constructor */ template SpectralAngleDistanceImageFilter ::SpectralAngleDistanceImageFilter() { m_ReferencePixel = 0; } template void SpectralAngleDistanceImageFilter ::BeforeThreadedGenerateData() { if (this->GetInput()->GetNumberOfComponentsPerPixel() == 1) { itkExceptionMacro(<< "Not valid input image : mono channel image gives a nul output image."); } } template void SpectralAngleDistanceImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { if (m_ReferencePixel.Size() == 0) { itkExceptionMacro(<< "Reference pixel is not set!"); } InputImageConstPointerType inputPtr = this->GetInput(); OutputImagePointerType outputPtr = this->GetOutput(); //inputPtr->UpdateOutputInformation(); // Check if the reference pixel size matches the input image number of components. if (m_ReferencePixel.GetSize() != inputPtr->GetNumberOfComponentsPerPixel()) { itkExceptionMacro(<< "Reference pixel size (" << m_ReferencePixel.GetSize() << " and input image pixel size (" << inputPtr->GetNumberOfComponentsPerPixel() << ") don't match!"); } // Define the portion of the input to walk for this thread, using // the CallCopyOutputRegionToInputRegion method allows for the input // and output images to be different dimensions InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, inputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd() && !outputIt.IsAtEnd()) { double dist = 0.0; double scalarProd = 0.0; double normProd = 0.0; double normProd1 = 0.0; double normProd2 = 0.0; InputPixelType pixel = inputIt.Get(); for (unsigned int i = 0; i < pixel.Size(); ++i) { scalarProd += pixel[i] * m_ReferencePixel[i]; normProd1 += pixel[i] * pixel[i]; normProd2 += m_ReferencePixel[i] * m_ReferencePixel[i]; } normProd = normProd1 * normProd2; if (normProd == 0.0) { dist = 0.0; } else { dist = vcl_acos(scalarProd / vcl_sqrt(normProd)); } //------ This part was suppressed since the filter must perform only the spectral angle computation --- // Spectral angle normalization // dist = dist/(CONST_PI_2); //square ponderation // dist = vcl_sqrt(dist); outputIt.Set(static_cast(dist)); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } /** * PrintSelf Method */ template void SpectralAngleDistanceImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbSpectralAngleFunctor.h000066400000000000000000000047011301006202600307440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralAngleFunctor_h #define otbSpectralAngleFunctor_h #include "otbMath.h" #include namespace otb { /** \class SpectralAngleFunctor * \brief This functor computes the spectral angle according to a reference pixel. * * \ingroup OTBImageManipulation */ namespace Functor { template class SpectralAngleFunctor { public: SpectralAngleFunctor() { m_ReferencePixel.SetSize(4); m_ReferencePixel.Fill(1); } virtual ~SpectralAngleFunctor() {} // Binary operator inline TOutputValue operator ()(const TInput& inPix) const { return this->Evaluate(inPix); } void SetReferencePixel(TInput ref) { m_ReferencePixel = ref; m_RefNorm = 0.0; for (unsigned int i = 0; i < ref.Size(); ++i) { m_RefNorm += ref[i] * ref[i]; } m_RefNorm = vcl_sqrt(static_cast(m_RefNorm)); } TInput GetReferencePixel() const { return m_ReferencePixel; } protected: // This method can be reimplemented in subclasses to actually // compute the index value virtual TOutputValue Evaluate(const TInput& inPix) const { TOutputValue out; double dist = 0.0; double scalarProd = 0.0; double normProd = 0.0; double normProd1 = 0.0; double sqrtNormProd = 0.0; for (unsigned int i = 0; i < std::min(inPix.Size(), m_ReferencePixel.Size()); ++i) { scalarProd += inPix[i] * m_ReferencePixel[i]; normProd1 += inPix[i] * inPix[i]; } normProd = normProd1 * m_RefNorm * m_RefNorm; sqrtNormProd = vcl_sqrt(normProd); if ((sqrtNormProd == 0.0) || (scalarProd / sqrtNormProd > 1)) { dist = 0.0; } else { dist = vcl_acos(scalarProd / sqrtNormProd); } out = static_cast(dist); return out; } TInput m_ReferencePixel; double m_RefNorm; }; } // end namespace functor } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbSqrtSpectralAngleFunctor.h000066400000000000000000000030521301006202600316140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSqrtSpectralAngleFunctor_h #define otbSqrtSpectralAngleFunctor_h #include "otbSpectralAngleFunctor.h" #include "itkMacro.h" namespace otb { namespace Functor { /** \class SqrtSpectralAngleFunctor * \brief This functor computes the square root of a spectral angle according to a reference pixel. * * \ingroup OTBImageManipulation */ template class SqrtSpectralAngleFunctor : public SpectralAngleFunctor { public: typedef SqrtSpectralAngleFunctor Self; typedef SpectralAngleFunctor Superclass; SqrtSpectralAngleFunctor() {} ~SqrtSpectralAngleFunctor() ITK_OVERRIDE {} protected: TOutputPixel Evaluate(const TInputVectorPixel& inPix) const ITK_OVERRIDE { return static_cast(vcl_sqrt(Superclass::Evaluate(inPix))); } }; } // end namespace Functor } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #endif #endif otbStreamingInnerProductVectorImageFilter.h000066400000000000000000000173331301006202600343670ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingInnerProductVectorImageFilter_h #define otbStreamingInnerProductVectorImageFilter_h #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "itkSimpleDataObjectDecorator.h" #include "itkImageRegionSplitter.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" #include "vnl/vnl_matrix.h" namespace otb { /** \class PersistentInnerProductVectorImageFilter * \brief Compute the inner product of a large image using streaming * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output statistics will be the statitics of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the statistics once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * * \ingroup OTBImageManipulation */ template class ITK_EXPORT PersistentInnerProductVectorImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentInnerProductVectorImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentInnerProductVectorImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::PixelType PixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Type definition for a double matrix. */ typedef vnl_matrix MatrixType; typedef typename std::vector ArrayMatrixType; /** Type of DataObjects used for scalar outputs */ typedef itk::SimpleDataObjectDecorator MatrixObjectType; /** Return the computed inner product matrix. */ MatrixType GetInnerProduct() const { return this->GetInnerProductOutput()->Get(); } MatrixObjectType* GetInnerProductOutput(); const MatrixObjectType* GetInnerProductOutput() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; /** Enable/Disable center data */ itkSetMacro(CenterData, bool); itkGetMacro(CenterData, bool); itkBooleanMacro(CenterData); protected: PersistentInnerProductVectorImageFilter(); ~PersistentInnerProductVectorImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentInnerProductVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ArrayMatrixType m_ThreadInnerProduct; /** Enable/Disable center data */ bool m_CenterData; }; // end of class PersistentStatisticsVectorImageFilter /**===========================================================================*/ /** \class StreamingInnerProductVectorImageFilter * \brief This class streams the whole input image through the PersistentStatisticsImageFilter. * * This way, it allows computing the inner product of this image. It calls the * Reset() method of the PersistentStatisticsImageFilter before streaming the image and the * Synthetize() method of the PersistentStatisticsImageFilter after having streamed the image * to compute the statistics. The accessor on the results are wrapping the accessors of the * internal PersistentStatisticsImageFilter. * * \sa PersistentStatisticsVectorImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBImageManipulation */ template class ITK_EXPORT StreamingInnerProductVectorImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingInnerProductVectorImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingInnerProductVectorImageFilter, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef typename Superclass::FilterType StatFilterType; typedef typename StatFilterType::MatrixType MatrixType; /** Type of DataObjects used for scalar outputs */ typedef typename StatFilterType::MatrixObjectType MatrixObjectType; using Superclass::SetInput; void SetInput(TInputImage * input) { this->GetFilter()->SetInput(input); } TInputImage * GetInput() { return this->GetFilter()->GetInput(); } /** Return the computed inner product. */ MatrixType GetInnerProduct() const { return this->GetFilter()->GetInnerProductOutput()->Get(); } MatrixObjectType* GetInnerProductOutput() { return this->GetFilter()->GetInnerProductOutput(); } const MatrixObjectType* GetInnerProductOutput() const { return this->GetFilter()->GetInnerProductOutput(); } /** Enable/Disable center data */ void SetCenterData(bool centerdata) { this->GetFilter()->SetCenterData(centerdata); } protected: /** Constructor */ StreamingInnerProductVectorImageFilter() {}; /** Destructor */ ~StreamingInnerProductVectorImageFilter() ITK_OVERRIDE {} private: StreamingInnerProductVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingInnerProductVectorImageFilter.txx" #endif #endif otbStreamingInnerProductVectorImageFilter.txx000066400000000000000000000210031301006202600347500ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingInnerProductVectorImageFilter_txx #define otbStreamingInnerProductVectorImageFilter_txx #include "otbStreamingInnerProductVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentInnerProductVectorImageFilter ::PersistentInnerProductVectorImageFilter() { // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around pixel types // allocate the data objects for the outputs which are // just decorators around matrix types typename ImageType::Pointer output1 = static_cast(this->MakeOutput(0).GetPointer()); this->itk::ProcessObject::SetNthOutput(0, output1.GetPointer()); typename MatrixObjectType::Pointer output2 = static_cast(this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, output2.GetPointer()); m_CenterData = true; } template itk::DataObject::Pointer PersistentInnerProductVectorImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { switch (output) { case 0: return static_cast(TInputImage::New().GetPointer()); break; case 1: return static_cast(MatrixObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputImage::New().GetPointer()); break; } } template typename PersistentInnerProductVectorImageFilter::MatrixObjectType* PersistentInnerProductVectorImageFilter ::GetInnerProductOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentInnerProductVectorImageFilter::MatrixObjectType* PersistentInnerProductVectorImageFilter ::GetInnerProductOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void PersistentInnerProductVectorImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentInnerProductVectorImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentInnerProductVectorImageFilter ::Reset() { TInputImage * inputPtr = const_cast(this->GetInput()); inputPtr->UpdateOutputInformation(); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } unsigned int numberOfThreads = this->GetNumberOfThreads(); unsigned int numberOfTrainingImages = inputPtr->GetNumberOfComponentsPerPixel(); // Set the number of training image MatrixType tempMatrix; tempMatrix.set_size(numberOfTrainingImages, numberOfTrainingImages); tempMatrix.fill(0); m_ThreadInnerProduct = ArrayMatrixType(numberOfThreads, tempMatrix); MatrixType initMatrix; initMatrix.set_size(numberOfTrainingImages, numberOfTrainingImages); initMatrix.fill(0); this->GetInnerProductOutput()->Set(initMatrix); } template void PersistentInnerProductVectorImageFilter ::Synthetize() { // Compute Inner product Matrix TInputImage * inputPtr = const_cast(this->GetInput()); unsigned int numberOfTrainingImages = inputPtr->GetNumberOfComponentsPerPixel(); unsigned int numberOfThreads = this->GetNumberOfThreads(); MatrixType innerProduct; innerProduct.set_size(numberOfTrainingImages, numberOfTrainingImages); innerProduct.fill(0); // Concatenate threaded matrix for (unsigned int thread = 0; thread < numberOfThreads; thread++) { innerProduct += m_ThreadInnerProduct[thread]; } //--------------------------------------------------------------------- // Fill the rest of the inner product matrix and make it symmetric //--------------------------------------------------------------------- for (unsigned int band_x = 0; band_x < (numberOfTrainingImages - 1); ++band_x) { for (unsigned int band_y = band_x + 1; band_y < numberOfTrainingImages; ++band_y) { innerProduct[band_x][band_y] = innerProduct[band_y][band_x]; } // end band_y loop } // end band_x loop if ((numberOfTrainingImages - 1) != 0) { innerProduct /= (numberOfTrainingImages - 1); } else { innerProduct.fill(0); } // Set the output this->GetInnerProductOutput()->Set(innerProduct); } template void PersistentInnerProductVectorImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { /** * Grab the input */ InputImagePointer inputPtr = const_cast(this->GetInput()); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); unsigned int numberOfTrainingImages = inputPtr->GetNumberOfComponentsPerPixel(); itk::ImageRegionConstIterator it(inputPtr, outputRegionForThread); if (m_CenterData == true) { it.GoToBegin(); // do the work while (!it.IsAtEnd()) { PixelType vectorValue = it.Get(); double mean(0.); for (unsigned int i = 0; i < vectorValue.GetSize(); ++i) { mean += static_cast(vectorValue[i]); } mean /= static_cast(vectorValue.GetSize()); // Matrix iteration for (unsigned int band_x = 0; band_x < numberOfTrainingImages; ++band_x) { for (unsigned int band_y = 0; band_y <= band_x; ++band_y) { m_ThreadInnerProduct[threadId][band_x][band_y] += (static_cast(vectorValue[band_x]) - mean) * (static_cast(vectorValue[band_y]) - mean); } // end: band_y loop } // end: band_x loop ++it; progress.CompletedPixel(); } // end: looping through the image } else { it.GoToBegin(); // do the work while (!it.IsAtEnd()) { PixelType vectorValue = it.Get(); // Matrix iteration for (unsigned int band_x = 0; band_x < numberOfTrainingImages; ++band_x) { for (unsigned int band_y = 0; band_y <= band_x; ++band_y) { m_ThreadInnerProduct[threadId][band_x][band_y] += (static_cast(vectorValue[band_x])) * (static_cast(vectorValue[band_y])); } // end: band_y loop } // end: band_x loop ++it; progress.CompletedPixel(); } // end: looping through the image } } template void PersistentInnerProductVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "m_CenterData: " << m_CenterData << std::endl; os << indent << "InnerProduct: " << this->GetInnerProductOutput()->Get() << std::endl; } } // end namespace otb #endif otbStreamingMatrixTransposeMatrixImageFilter.h000066400000000000000000000242221301006202600351130ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingMatrixTransposeMatrixImageFilter_h #define otbStreamingMatrixTransposeMatrixImageFilter_h #include "otbPersistentImageFilter.h" #include "itkSimpleDataObjectDecorator.h" #include "otbStreamingTraits.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" #include "otbPersistentFilterStreamingDecorator.h" namespace otb { /** \class PersistentMatrixTransposeMatrixImageFilter * \brief Compute \f[X^T.Y \f]. Allow a padding of ones. * * \f[X\f] and \f[Y\f] are the input images. * The padding has the effect of adding a component filled with ones to the image * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output statistics will be the result for the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the statistics once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa StreamingTraits * \sa StatisticsImageFilter * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBImageManipulation */ template class ITK_EXPORT PersistentMatrixTransposeMatrixImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentMatrixTransposeMatrixImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentMatrixTransposeMatrixImageFilter, PersistentImageFilter); /** Image related typedefs. */ // First Input typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; typedef typename TInputImage::InternalPixelType InternalPixelType; typedef typename TInputImage2::IndexType IndexType2; typedef typename TInputImage2::PixelType PixelType2; typedef typename TInputImage2::InternalPixelType InternalPixelType2; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkSetMacro(UsePadFirstInput, bool); itkGetMacro(UsePadFirstInput, bool); itkSetMacro(UsePadSecondInput, bool); itkGetMacro(UsePadSecondInput, bool); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Type to use for computations. */ // First Input typedef double RealType; typedef itk::VariableLengthVector RealPixelType; /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Type of DataObjects used for scalar outputs */ typedef typename itk::Array ArrayLongPixelType; typedef typename itk::VariableSizeMatrix MatrixType; typedef typename std::vector ArrayMatrixType; typedef typename std::vector ArrayRealPixelType; typedef typename std::vector ArrayPixelType; typedef itk::SimpleDataObjectDecorator RealPixelObjectType; typedef itk::SimpleDataObjectDecorator PixelObjectType; typedef itk::SimpleDataObjectDecorator MatrixObjectType; /** Return the computed transpose(Image1)*Image2. */ MatrixType GetResult() const { return this->GetResultOutput()->Get(); } MatrixObjectType* GetResultOutput(); const MatrixObjectType* GetResultOutput() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; // Override since the filter needs all the data for the algorithm void GenerateInputRequestedRegion() ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; /** Input wrapper */ void SetFirstInput(const TInputImage *input1) { this->SetInput(0, input1); } void SetSecondInput(const TInputImage2 *input2) { this->SetInput(1, input2); } const TInputImage* GetFirstInput() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } else return (static_cast(this->itk::ProcessObject::GetInput(0))); } const TInputImage2* GetSecondInput() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } else return (static_cast(this->itk::ProcessObject::GetInput(1))); } protected: PersistentMatrixTransposeMatrixImageFilter(); ~PersistentMatrixTransposeMatrixImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentMatrixTransposeMatrixImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ArrayMatrixType m_ThreadSum; bool m_UsePadFirstInput; bool m_UsePadSecondInput; /** Nulber Of Component per Pixel. Change for padding */ unsigned int m_NumberOfComponents1; unsigned int m_NumberOfComponents2; }; // end of class /**===========================================================================*/ /** \class StreamingMatrixTransposeMatrixImageFilter * \brief This class streams the whole input image through the PersistentMatrixTransposeMatrixImageFilter. * * This way, it allows computing \f[X^T.Y \f] where \f[X\f] and \f[Y\f] are the input images. * first order global statistics of this image. It calls the Reset() method of the * PersistentMatrixTransposeMatrixImageFilter before streaming the image and the * Synthetize() method of the PersistentMatrixTransposeMatrixImageFilter after having streamed the image * to compute the statistics. The accessor on the results are wrapping the accessors of the * internal PersistentStatisticsImageFilter. The accessor on the pad options are also provided. * * \sa PersistentMatrixTransposeMatrixImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBImageManipulation */ template class ITK_EXPORT StreamingMatrixTransposeMatrixImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingMatrixTransposeMatrixImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingMatrixTransposeMatrixImageFilter, PersistentFilterStreamingDecorator); typedef typename Superclass::FilterType MatrixToTransposeMatrixFilterType; typedef typename MatrixToTransposeMatrixFilterType::MatrixType MatrixType; typedef itk::SimpleDataObjectDecorator MatrixObjectType; typedef TInputImage1 InputImage1Type; typedef TInputImage2 InputImage2Type; /** Interfaces to the embedded filter */ void SetFirstInput(InputImage1Type * input1) { this->GetFilter()->SetFirstInput(input1); } void SetSecondInput(InputImage2Type * input2) { this->GetFilter()->SetSecondInput(input2); } void SetUsePadFirstInput(bool pad) { this->GetFilter()->SetUsePadFirstInput(pad); } void SetUsePadSecondInput(bool pad) { this->GetFilter()->SetUsePadSecondInput(pad); } bool GetUsePadFirstInput(void) { return this->GetFilter()->GetUsePadFirstInput(); } bool GetUsePadSecondInput(void) { return this->GetFilter()->GetUsePadSecondInput(); } /** Return the computed transpose(Image1)*Image2. */ MatrixType GetResult(void) const { return this->GetResultOutput()->Get(); } MatrixObjectType* GetResultOutput(void) { return this->GetFilter()->GetResultOutput(); } const MatrixObjectType* GetResultOutput() const { return this->GetFilter()->GetResultOutput(); } protected: /** Constructor */ StreamingMatrixTransposeMatrixImageFilter() {}; /** Destructor */ ~StreamingMatrixTransposeMatrixImageFilter() ITK_OVERRIDE {} private: StreamingMatrixTransposeMatrixImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingMatrixTransposeMatrixImageFilter.txx" #endif #endif otbStreamingMatrixTransposeMatrixImageFilter.txx000066400000000000000000000231171301006202600355110ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingMatrixTransposeMatrixImageFilter_txx #define otbStreamingMatrixTransposeMatrixImageFilter_txx #include "otbStreamingMatrixTransposeMatrixImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" namespace otb { template PersistentMatrixTransposeMatrixImageFilter ::PersistentMatrixTransposeMatrixImageFilter() { this->SetNumberOfRequiredInputs(2); // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around pixel types typename ImageType::Pointer output1 = static_cast(this->MakeOutput(0).GetPointer()); this->itk::ProcessObject::SetNthOutput(0, output1.GetPointer()); typename MatrixObjectType::Pointer output2 = static_cast(this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, output2.GetPointer()); // false means no pad added m_UsePadFirstInput = false; m_UsePadSecondInput = false; // Number of component initialization m_NumberOfComponents1 = 0; m_NumberOfComponents2 = 0; } template itk::DataObject::Pointer PersistentMatrixTransposeMatrixImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { switch (output) { case 0: return static_cast(TInputImage::New().GetPointer()); break; case 1: return static_cast(MatrixObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputImage::New().GetPointer()); break; } } template typename PersistentMatrixTransposeMatrixImageFilter::MatrixObjectType* PersistentMatrixTransposeMatrixImageFilter ::GetResultOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentMatrixTransposeMatrixImageFilter::MatrixObjectType* PersistentMatrixTransposeMatrixImageFilter ::GetResultOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void PersistentMatrixTransposeMatrixImageFilter ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); if (this->GetFirstInput() && this->GetSecondInput()) { InputImagePointer image = const_cast(this->GetFirstInput()); InputImagePointer image2 = const_cast(this->GetSecondInput()); image->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); image2->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); } } template void PersistentMatrixTransposeMatrixImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetFirstInput()) { this->GetOutput()->CopyInformation(this->GetFirstInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetFirstInput()->GetLargestPossibleRegion()); } if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } template void PersistentMatrixTransposeMatrixImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentMatrixTransposeMatrixImageFilter ::Reset() { TInputImage * inputPtr1 = const_cast(this->GetFirstInput()); inputPtr1->UpdateOutputInformation(); TInputImage2 * inputPtr2 = const_cast(this->GetSecondInput()); inputPtr2->UpdateOutputInformation(); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } if (inputPtr1->GetLargestPossibleRegion().GetSize() != inputPtr2->GetLargestPossibleRegion().GetSize()) { itkExceptionMacro(<< " Can't multiply the transposed matrix of a " << inputPtr1->GetLargestPossibleRegion().GetSize() << " and a " << inputPtr2->GetLargestPossibleRegion().GetSize() << " matrix "); } m_NumberOfComponents1 = inputPtr1->GetNumberOfComponentsPerPixel(); m_NumberOfComponents2 = inputPtr2->GetNumberOfComponentsPerPixel(); unsigned int numberOfThreads = this->GetNumberOfThreads(); if (m_UsePadFirstInput == true) { m_NumberOfComponents1++; } if (m_UsePadSecondInput == true) { m_NumberOfComponents2++; } MatrixType tempMatrix, initMatrix; tempMatrix.SetSize(m_NumberOfComponents1, m_NumberOfComponents2); tempMatrix.Fill(itk::NumericTraits::Zero); m_ThreadSum = ArrayMatrixType(numberOfThreads, tempMatrix); initMatrix.SetSize(m_NumberOfComponents2, m_NumberOfComponents2); initMatrix.Fill(itk::NumericTraits::Zero); this->GetResultOutput()->Set(initMatrix); } template void PersistentMatrixTransposeMatrixImageFilter ::Synthetize() { unsigned int numberOfThreads = this->GetNumberOfThreads(); MatrixType resultMatrix; resultMatrix.SetSize(m_NumberOfComponents1, m_NumberOfComponents2); resultMatrix.Fill(itk::NumericTraits::Zero); for (unsigned int thread = 0; thread < numberOfThreads; thread++) { /** TODO * To modify using + method operator. If we use it now -> exceptionmacro (no GetClassName...) * resultMatrix += m_ThreadSum[thread]; **/ for (unsigned int i = 0; i < resultMatrix.Rows(); ++i) { for (unsigned int j = 0; j < resultMatrix.Cols(); ++j) { resultMatrix(i, j) += m_ThreadSum[thread](i, j); } } /********END TODO ******/ } this->GetResultOutput()->Set(resultMatrix); } template void PersistentMatrixTransposeMatrixImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { /** * Grab the input */ InputImagePointer input1Ptr = const_cast(this->GetFirstInput()); InputImagePointer input2Ptr = const_cast(this->GetSecondInput()); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); itk::ImageRegionConstIterator it1(input1Ptr, outputRegionForThread); itk::ImageRegionConstIterator it2(input2Ptr, outputRegionForThread); it1.GoToBegin(); it2.GoToBegin(); // loop the second image and get one pixel a time while (!it1.IsAtEnd()) { PixelType vectorValue1 = it1.Get(); PixelType2 vectorValue2 = it2.Get(); // Add a first component to vectorValue2 and vectorValue1 filled with ones. if (m_UsePadFirstInput == true) { PixelType vectortemp1(vectorValue1.Size() + 1); vectortemp1[0] = 1; for (unsigned int n = 0; n < vectorValue1.Size(); ++n) { vectortemp1[n + 1] = vectorValue1[n]; } vectorValue1.SetSize(vectortemp1.Size()); vectorValue1 = vectortemp1; } if (m_UsePadSecondInput == true) { PixelType2 vectortemp2(vectorValue2.Size() + 1); vectortemp2[0] = 1; for (unsigned int m = 0; m < vectorValue2.Size(); m++) { vectortemp2[m + 1] = vectorValue2[m]; } vectorValue2.SetSize(vectortemp2.Size()); vectorValue2 = vectortemp2; } for (unsigned int i = 0; i < vectorValue1.Size(); ++i) { for (unsigned int j = 0; j < vectorValue2.Size(); ++j) { m_ThreadSum[threadId](i, j) += static_cast(vectorValue1[i]) * static_cast(vectorValue2[j]); } } ++it1; ++it2; progress.CompletedPixel(); } } template void PersistentMatrixTransposeMatrixImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Result: " << this->GetResultOutput()->Get() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbStreamingResampleImageFilter.h000066400000000000000000000166171301006202600324230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingResampleImageFilter_h #define otbStreamingResampleImageFilter_h #include "itkImageToImageFilter.h" #include "otbStreamingWarpImageFilter.h" #include "itkTransformToDisplacementFieldSource.h" #include "itkLinearInterpolateImageFunction.h" #include "otbImage.h" #include "itkVector.h" #include "otbMacro.h" namespace otb { /** \class StreamingResampleImageFilter * \brief This class is a composite filter resampling an input image * by setting a transform. The filter computes a displacement * grid using the transform set and used it to warp the input. * * The otb::StreamingResampleImageFilter allows resampling a * otb::VectorImage using a transformation set with SetTransform() * method. First, a displacement grid, with a spacing m_DisplacementGridSpacing * and a size relative to this spacing, is built. Then, the image is * wraped using this displacement grid. The size (SetOutputSize()), the * spacing (SetOutputSpacing()), the start index (SetOutputIndex()) and * the interpolator (SetInterpolator()) and the origin (SetOrigin()) * can be set using the method between brackets. * * * * \ingroup Projection * * * \ingroup OTBImageManipulation **/ template class ITK_EXPORT StreamingResampleImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef StreamingResampleImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(StreamingResampleImageFilter, itk::ImageToImageFilter); /** Typedef parameters*/ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Displacement field used to warp the image*/ typedef itk::Vector DisplacementType; typedef otb::Image DisplacementFieldType; /** filter warping input image using displacement field */ typedef StreamingWarpImageFilter WarpImageFilterType; /** Internal filters typedefs*/ typedef itk::TransformToDisplacementFieldSource DisplacementFieldGeneratorType; typedef typename DisplacementFieldGeneratorType::TransformType TransformType; typedef typename DisplacementFieldGeneratorType::SizeType SizeType; typedef typename DisplacementFieldGeneratorType::SpacingType SpacingType; typedef typename DisplacementFieldGeneratorType::OriginType OriginType; typedef typename DisplacementFieldGeneratorType::IndexType IndexType; typedef typename DisplacementFieldGeneratorType::RegionType RegionType; /** Interpolator type */ typedef itk::InterpolateImageFunction InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointerType; typedef itk::LinearInterpolateImageFunction DefaultInterpolatorType; /** ImageBase typedef */ typedef itk::ImageBase ImageBaseType; /** Accessors to internal filters parameters */ void SetTransform(TransformType * transform) { m_DisplacementFilter->SetTransform(transform); this->Modified(); } otbGetObjectMemberConstMacro(DisplacementFilter, Transform, const TransformType*); /** The Displacement field spacing & size */ void SetDisplacementFieldSpacing(const SpacingType & spacing) { m_DisplacementFilter->SetOutputSpacing(spacing); this->Modified(); } const SpacingType & GetDisplacementFieldSpacing() const { return m_DisplacementFilter->GetOutputSpacing(); } /** The resampled image parameters */ // Output Origin void SetOutputOrigin(const OriginType & origin) { m_DisplacementFilter->SetOutputOrigin(origin); m_WarpFilter->SetOutputOrigin(origin); this->Modified(); } otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputOrigin, OriginType); // Output Start index otbSetObjectMemberMacro(WarpFilter, OutputStartIndex, IndexType); otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputStartIndex, IndexType); // Output Size otbSetObjectMemberMacro(WarpFilter, OutputSize, SizeType); otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputSize, SizeType); // Output Spacing otbSetObjectMemberMacro(WarpFilter, OutputSpacing, SpacingType); otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputSpacing, SpacingType); /** Methods to Set/Get the interpolator */ void SetInterpolator(InterpolatorType * interpolator) { m_WarpFilter->SetInterpolator(interpolator); this->Modified(); } otbGetObjectMemberConstMacro(WarpFilter, Interpolator, const InterpolatorType *); /** Default Edgepadding value */ otbSetObjectMemberMacro(WarpFilter, EdgePaddingValue, typename OutputImageType::PixelType); otbGetObjectMemberMacro(WarpFilter, EdgePaddingValue, typename OutputImageType::PixelType); /** Import output parameters from a given image */ void SetOutputParametersFromImage(const ImageBaseType * image); /* Set number of threads for Deformation field generator*/ void SetDisplacementFilterNumberOfThreads(unsigned int nbThread) { m_DisplacementFilter->SetNumberOfThreads(nbThread); } /** Override itk::ProcessObject method to let the internal filter do the propagation */ void PropagateRequestedRegion(itk::DataObject *output) ITK_OVERRIDE; protected: StreamingResampleImageFilter(); /** Destructor */ ~StreamingResampleImageFilter() ITK_OVERRIDE {}; void GenerateData() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: StreamingResampleImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename DisplacementFieldGeneratorType::Pointer m_DisplacementFilter; typename WarpImageFilterType::Pointer m_WarpFilter; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingResampleImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbStreamingResampleImageFilter.txx000066400000000000000000000116331301006202600330100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingResampleImageFilter_txx #define otbStreamingResampleImageFilter_txx #include "otbStreamingResampleImageFilter.h" #include "itkProgressAccumulator.h" namespace otb { template StreamingResampleImageFilter ::StreamingResampleImageFilter() { // internal filters instantiation m_DisplacementFilter = DisplacementFieldGeneratorType::New(); m_WarpFilter = WarpImageFilterType::New(); // Initialize the displacement field spacing to zero : inconsistent // value this->SetDisplacementFieldSpacing(itk::NumericTraits::ZeroValue()); // Wire minipipeline m_WarpFilter->SetDisplacementField(m_DisplacementFilter->GetOutput()); } template void StreamingResampleImageFilter ::GenerateData() { // Set up progress reporting typename itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); progress->RegisterInternalFilter(m_WarpFilter, 1.f); m_WarpFilter->GraftOutput(this->GetOutput()); m_WarpFilter->UpdateOutputData(m_WarpFilter->GetOutput()); this->GraftOutput(m_WarpFilter->GetOutput()); } /** * */ template void StreamingResampleImageFilter ::GenerateOutputInformation() { // check the output spacing of the displacement field if(this->GetDisplacementFieldSpacing()== itk::NumericTraits::ZeroValue()) { this->SetDisplacementFieldSpacing(2.*this->GetOutputSpacing()); } // Retrieve output largest region SizeType largestSize = this->GetOutputSize(); // Set up displacement field filter SizeType displacementFieldLargestSize; for(unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim) { // vcl_ceil to avoid numerical problems due to division of // spacings // + 1 : We need to enlarge the displacement field size cause // itk::WarpImageFilter::EvaluateDisplacementAtPhysicalPoint needs // 4 neighbors and in the edges we can need 1 neighbor pixel // outside the field displacementFieldLargestSize[dim] = static_cast( vcl_ceil( largestSize[dim]* vcl_abs(this->GetOutputSpacing()[dim] / this->GetDisplacementFieldSpacing()[dim]))) + 1; } m_DisplacementFilter->SetOutputSize(displacementFieldLargestSize); m_DisplacementFilter->SetOutputIndex(this->GetOutputStartIndex()); m_WarpFilter->SetInput(this->GetInput()); m_WarpFilter->GraftOutput(this->GetOutput()); m_WarpFilter->UpdateOutputInformation(); this->GraftOutput(m_WarpFilter->GetOutput()); } template void StreamingResampleImageFilter ::PropagateRequestedRegion(itk::DataObject *output) { if (this->m_Updating) return; m_WarpFilter->GetOutput()->SetRequestedRegion(output); m_WarpFilter->GetOutput()->PropagateRequestedRegion(); } /** * Method used to copy the parameters of the input image * */ template void StreamingResampleImageFilter ::SetOutputParametersFromImage(const ImageBaseType * image) { this->SetOutputOrigin ( image->GetOrigin() ); this->SetOutputSpacing ( image->GetSpacing() ); this->SetOutputStartIndex ( image->GetLargestPossibleRegion().GetIndex() ); this->SetOutputSize ( image->GetLargestPossibleRegion().GetSize() ); } template void StreamingResampleImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "OutputOrigin: " << this->GetOutputOrigin() << std::endl; os << indent << "OutputSpacing: " << this->GetOutputSpacing() << std::endl; os << indent << "OutputStartIndex: " << this->GetOutputStartIndex() << std::endl; os << indent << "OutputSize: " << this->GetOutputSize() << std::endl; } } #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbStreamingShrinkImageFilter.h000066400000000000000000000260531301006202600321040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingShrinkImageFilter_h #define otbStreamingShrinkImageFilter_h #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "otbStreamingManager.h" #include "otbMacro.h" namespace otb { class ITK_EXPORT StreamingShrinkImageRegionSplitter : public itk::ImageRegionSplitter<2> { public: /** Standard class typedefs. */ typedef StreamingShrinkImageRegionSplitter Self; typedef itk::ImageRegionSplitter<2> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(StreamingShrinkImageRegionSplitter, itk::Object); /** Dimension of the image available at compile time. */ itkStaticConstMacro(ImageDimension, unsigned int, 2); /** Dimension of the image available at run time. */ static unsigned int GetImageDimension() { return ImageDimension; } /** Index typedef support. An index is used to access pixel values. */ typedef itk::Index IndexType; typedef IndexType::IndexValueType IndexValueType; /** Size typedef support. A size is used to define region bounds. */ typedef itk::Size SizeType; typedef SizeType::SizeValueType SizeValueType; /** Region typedef support. */ typedef itk::ImageRegion RegionType; /** How many pieces can the specified region be split? A given region * cannot always be divided into the requested number of pieces. For * instance, if the numberOfPieces exceeds the number of pixels along * a certain dimensions, then some splits will not be possible. */ unsigned int GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) ITK_OVERRIDE; /** Get a region definition that represents the ith piece a specified region. * The "numberOfPieces" specified should be less than or equal to what * GetNumberOfSplits() returns. */ RegionType GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region) ITK_OVERRIDE; itkGetMacro(TileSizeAlignment, unsigned int); itkSetMacro(TileSizeAlignment, unsigned int); itkGetMacro(TileDimension, unsigned int); itkSetMacro(ShrinkFactor, unsigned int); itkGetMacro(ShrinkFactor, unsigned int); protected: StreamingShrinkImageRegionSplitter() : m_SplitsPerDimension(0U), m_TileDimension(0), m_TileSizeAlignment(0), m_ShrinkFactor(10) {} ~StreamingShrinkImageRegionSplitter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: StreamingShrinkImageRegionSplitter(const StreamingShrinkImageRegionSplitter &); //purposely not implemented void operator =(const StreamingShrinkImageRegionSplitter&); //purposely not implemented itk::FixedArray m_SplitsPerDimension; unsigned int m_TileDimension; unsigned int m_TileSizeAlignment; unsigned int m_ShrinkFactor; }; template class ITK_EXPORT StreamingShrinkStreamingManager : public StreamingManager { public: /** Standard class typedefs. */ typedef StreamingShrinkStreamingManager Self; typedef StreamingManager Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(StreamingShrinkStreamingManager, StreamingManager); typedef TInputImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::RegionType RegionType; typedef typename RegionType::IndexType IndexType; typedef typename RegionType::SizeType SizeType; typedef typename ImageType::InternalPixelType PixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Actually computes the stream divisions, according to the specified streaming mode, * eventually using the input parameter to estimate memory consumption */ void PrepareStreaming(itk::DataObject * input, const RegionType ®ion) ITK_OVERRIDE; void SetShrinkFactor(unsigned int val) { m_ShrinkFactor = val; } unsigned int GetShrinkFactor() const { return m_ShrinkFactor; } protected: StreamingShrinkStreamingManager(); ~StreamingShrinkStreamingManager() ITK_OVERRIDE; private: StreamingShrinkStreamingManager(const StreamingShrinkStreamingManager &); //purposely not implemented void operator =(const StreamingShrinkStreamingManager&); //purposely not implemented unsigned int m_ShrinkFactor; }; /** \class PersistentShrinkImageFilter * \brief * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * * * \ingroup OTBImageManipulation */ template class ITK_EXPORT PersistentShrinkImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentShrinkImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentShrinkImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage InputImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; /** Image related typedefs. */ typedef TOutputImage OutputImageType; typedef typename TOutputImage::Pointer OutputImagePointer; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; OutputImageType * GetShrunkOutput() { return m_ShrunkOutput; } /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ OutputImageType * GetShrinkedOutput() { otbWarningMacro(<< "GetShrinkedOutput has been deprecated. Please use GetShrunkOutput instead"); return GetShrunkOutput(); } void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; itkSetMacro(ShrinkFactor, unsigned int); itkGetMacro(ShrinkFactor, unsigned int); protected: PersistentShrinkImageFilter(); ~PersistentShrinkImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; private: PersistentShrinkImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /* the output shrunk image */ OutputImagePointer m_ShrunkOutput; /** The shrink factor */ unsigned int m_ShrinkFactor; }; // end of class PersistentStatisticsVectorImageFilter /** \class StreamingShrinkImageFilter * \brief Generates a quicklook of the input image * * This filter computes a subsampled version of the input image with streaming capabilities * * The subsampling ration is set with SetShrinkFactor * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * * * \ingroup OTBImageManipulation */ template class ITK_EXPORT StreamingShrinkImageFilter : public PersistentFilterStreamingDecorator< PersistentShrinkImageFilter > { public: /** Standard Self typedef */ typedef StreamingShrinkImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingShrinkImageFilter, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Superclass::FilterType PersistentFilterType; typedef StreamingShrinkStreamingManager StreamingShrinkStreamingManagerType; typedef typename StreamingShrinkStreamingManagerType::Pointer StreamingShrinkStreamingManagerPointerType; using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } OutputImageType * GetOutput() { return this->GetFilter()->GetShrunkOutput(); } otbSetObjectMemberMacro(Filter, ShrinkFactor, unsigned int); otbGetObjectMemberMacro(Filter, ShrinkFactor, unsigned int); void Update(void) ITK_OVERRIDE { m_StreamingManager->SetShrinkFactor( this->GetFilter()->GetShrinkFactor() ); Superclass::Update(); } protected: /** Constructor */ StreamingShrinkImageFilter() { // Use a specific StreamingManager implementation m_StreamingManager = StreamingShrinkStreamingManagerType::New(); this->GetStreamer()->SetStreamingManager( m_StreamingManager ); } /** Destructor */ ~StreamingShrinkImageFilter() ITK_OVERRIDE {} private: StreamingShrinkImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented StreamingShrinkStreamingManagerPointerType m_StreamingManager; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingShrinkImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbStreamingShrinkImageFilter.txx000066400000000000000000000154411301006202600324770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingShrinkImageFilter_txx #define otbStreamingShrinkImageFilter_txx #include "otbStreamingShrinkImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbMacro.h" #include "itkProgressReporter.h" namespace otb { template StreamingShrinkStreamingManager::StreamingShrinkStreamingManager() : m_ShrinkFactor(10) { } template StreamingShrinkStreamingManager::~StreamingShrinkStreamingManager() { } template void StreamingShrinkStreamingManager::PrepareStreaming( itk::DataObject * input, const RegionType ®ion ) { typedef otb::StreamingShrinkImageRegionSplitter TileSplitterType; TileSplitterType::Pointer splitter = TileSplitterType::New(); splitter->SetTileSizeAlignment(m_ShrinkFactor); this->m_Splitter = splitter; unsigned long nbDivisions = this->EstimateOptimalNumberOfDivisions(input, region, 0); this->m_ComputedNumberOfSplits = this->m_Splitter->GetNumberOfSplits(region, nbDivisions); otbMsgDevMacro(<< "Number of split : " << this->m_ComputedNumberOfSplits) // Save the region to generate the splits later this->m_Region = region; } /** Constructor */ template PersistentShrinkImageFilter ::PersistentShrinkImageFilter() : m_ShrinkFactor(10) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); } /** Destructor */ template PersistentShrinkImageFilter ::~PersistentShrinkImageFilter() { } template void PersistentShrinkImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); const InputImageType* input = this->GetInput(); OutputImageType* output = this->GetOutput(); if (input) { output->CopyInformation(input); output->SetLargestPossibleRegion(input->GetLargestPossibleRegion()); if (output->GetRequestedRegion().GetNumberOfPixels() == 0) { output->SetRequestedRegion(output->GetLargestPossibleRegion()); } } } template void PersistentShrinkImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentShrinkImageFilter ::Reset() { // Get pointers to the input and output InputImageType* inputPtr = const_cast(this->GetInput()); inputPtr->UpdateOutputInformation(); m_ShrunkOutput = OutputImageType::New(); m_ShrunkOutput->CopyInformation(inputPtr); const typename InputImageType::SpacingType& inputSpacing = inputPtr->GetSpacing(); const typename InputImageType::SizeType& inputSize = inputPtr->GetLargestPossibleRegion().GetSize(); typename OutputImageType::SpacingType shrunkOutputSpacing; typename OutputImageType::RegionType shrunkOutputLargestPossibleRegion; typename OutputImageType::SizeType shrunkOutputSize; typename OutputImageType::IndexType shrunkOutputStartIndex; typename OutputImageType::PointType shrunkOutputOrigin; for (unsigned int i = 0; i < OutputImageType::ImageDimension; ++i) { shrunkOutputSpacing[i] = inputSpacing[i] * static_cast(m_ShrinkFactor); shrunkOutputSize[i] = inputSize[i] > m_ShrinkFactor ? inputSize[i] / m_ShrinkFactor : 1; shrunkOutputOrigin[i] = inputPtr->GetOrigin()[i] + inputSpacing[i] * (static_cast(inputPtr->GetLargestPossibleRegion().GetIndex(i)) - 0.5) + shrunkOutputSpacing[i] * 0.5; // we choose to output a region with a start index [0,0] // the origin is set accordingly shrunkOutputStartIndex[i] = 0; } m_ShrunkOutput->SetSpacing(shrunkOutputSpacing); m_ShrunkOutput->SetOrigin(shrunkOutputOrigin); shrunkOutputLargestPossibleRegion.SetSize(shrunkOutputSize); shrunkOutputLargestPossibleRegion.SetIndex(shrunkOutputStartIndex); m_ShrunkOutput->SetRegions(shrunkOutputLargestPossibleRegion); m_ShrunkOutput->Allocate(); } template void PersistentShrinkImageFilter ::Synthetize() { } template void PersistentShrinkImageFilter ::BeforeThreadedGenerateData() { } template void PersistentShrinkImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { //std::cout << "outputRegionForThread " << threadId << " " << outputRegionForThread << std::endl; itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); const InputImageType* inputPtr = this->GetInput(); itk::ImageRegionConstIteratorWithIndex inIt(inputPtr, outputRegionForThread); for(inIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt, progress.CompletedPixel()) { const IndexType& inIndex = inIt.GetIndex(); // TODO the pixel value should be taken near the centre of the cell, not at the corners if (inIndex[0] % m_ShrinkFactor == 0 && inIndex[1] % m_ShrinkFactor == 0 ) { IndexType shrunkIndex; shrunkIndex[0] = inIndex[0] / m_ShrinkFactor; shrunkIndex[1] = inIndex[1] / m_ShrinkFactor; if (m_ShrunkOutput->GetLargestPossibleRegion().IsInside(shrunkIndex)) m_ShrunkOutput->SetPixel(shrunkIndex, inIt.Get()); } } } template void PersistentShrinkImageFilter ::AfterThreadedGenerateData() { } template void PersistentShrinkImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Shrink factor: " << m_ShrinkFactor << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbThresholdVectorImageFilter.h000066400000000000000000000122601301006202600321060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbThresholdVectorImageFilter_h #define otbThresholdVectorImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class ThresholdVectorImageFilter * \brief Set image values to a user-specified value if they are below, * above, or between simple threshold values. * * ThresholdVectorImageFilter sets image values to a user-specified "outside" * value (by default, "black") if the image values are below, above, or * between simple threshold values. * * The pixels must support the operators >= and <=. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT ThresholdVectorImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef ThresholdVectorImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ThresholdVectorImageFilter, itk::ImageToImageFilter); /** Some additional typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::InternalPixelType InputImageInternalPixelType; /** Some additional typedefs. */ typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::InternalPixelType OutputImageInternalPixelType; /** Set the "outside" pixel value. The default value * NumericTraits::Zero. */ itkSetMacro(OutsideValue, OutputImageInternalPixelType); /** Get the "outside" pixel value. */ itkGetConstMacro(OutsideValue, OutputImageInternalPixelType); /** The values greater than or equal to the value are set to OutsideValue. */ void ThresholdAbove(const InputImageInternalPixelType &thresh); /** The values less than or equal to the value are set to OutsideValue. */ void ThresholdBelow(const InputImageInternalPixelType &thresh); /** The values outside the range are set to OutsideValue. */ void ThresholdOutside(const InputImageInternalPixelType &lower, const InputImageInternalPixelType &upper); /** Set/Get methods to set the lower threshold */ itkSetMacro(Lower, InputImageInternalPixelType); itkGetConstMacro(Lower, InputImageInternalPixelType); /** Set/Get methods to set the upper threshold */ itkSetMacro(Upper, InputImageInternalPixelType); itkGetConstMacro(Upper, InputImageInternalPixelType); protected: ThresholdVectorImageFilter(); ~ThresholdVectorImageFilter() ITK_OVERRIDE {}; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** ThresholdVectorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType ThrethreadId ) ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() ); } private: ThresholdVectorImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented OutputImageInternalPixelType m_OutsideValue; InputImageInternalPixelType m_Lower; InputImageInternalPixelType m_Upper; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbThresholdVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbThresholdVectorImageFilter.txx000066400000000000000000000121761301006202600325100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbThresholdVectorImageFilter_txx #define otbThresholdVectorImageFilter_txx #include "otbThresholdVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" #include "itkObjectFactory.h" #include "itkProgressReporter.h" namespace otb { /** * */ template ThresholdVectorImageFilter ::ThresholdVectorImageFilter() { m_OutsideValue = itk::NumericTraits::Zero; m_Lower = itk::NumericTraits::NonpositiveMin(); m_Upper = itk::NumericTraits::max(); } /** * */ template void ThresholdVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "OutsideValue: " << static_cast::PrintType>(m_OutsideValue) << std::endl; os << indent << "Lower: " << static_cast::PrintType>(m_Lower) << std::endl; os << indent << "Upper: " << static_cast::PrintType>(m_Upper) << std::endl; } /** * The values greater than or equal to the value are set to OutsideValue */ template void ThresholdVectorImageFilter ::ThresholdAbove(const InputImageInternalPixelType &thresh) { if (m_Upper != thresh || m_Lower > itk::NumericTraits::NonpositiveMin()) { m_Lower = itk::NumericTraits::NonpositiveMin(); m_Upper = thresh; this->Modified(); } } /** * The values less than or equal to the value are set to OutsideValue */ template void ThresholdVectorImageFilter ::ThresholdBelow(const InputImageInternalPixelType &thresh) { if (m_Lower != thresh || m_Upper < itk::NumericTraits::max()) { m_Lower = thresh; m_Upper = itk::NumericTraits::max(); this->Modified(); } } /** * The values outside the range are set to OutsideValue */ template void ThresholdVectorImageFilter ::ThresholdOutside(const InputImageInternalPixelType &lower, const InputImageInternalPixelType &upper) { if (lower > upper) { itkExceptionMacro(<<"Lower threshold cannot be greater than upper threshold."); return; } if (m_Lower != lower || m_Upper != upper) { m_Lower = lower; m_Upper = upper; this->Modified(); } } /** * */ template void ThresholdVectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itkDebugMacro(<<"Actually executing"); // Get the input and output pointers InputImagePointer inputPtr = this->GetInput(); OutputImagePointer outputPtr = this->GetOutput(0); // Define/declare an iterator that will walk the output region for this // thread. typedef itk::ImageRegionConstIterator InputIterator; typedef itk::ImageRegionIterator OutputIterator; InputIterator inIt(inputPtr, outputRegionForThread); OutputIterator outIt(outputPtr, outputRegionForThread); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // walk the regions, threshold each pixel while( !outIt.IsAtEnd() && !inIt.IsAtEnd() ) { const InputImagePixelType inPix = inIt.Get(); unsigned int l_size = inPix.Size(); OutputImagePixelType outPix; outPix.SetSize(l_size); for(unsigned int i=0; i(value); } else { outPix[i] = static_cast(m_OutsideValue); } } outIt.Set( outPix ); ++inIt; ++outIt; progress.CompletedPixel(); } } } // end namespace itk #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbTileImageFilter.h000066400000000000000000000100521301006202600276610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileImageFilter_h #define otbTileImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class TileImageFilter * \brief This filter allows making a spatial mosaic from a set of images * * This filter produces a spatial mosaic from a set of images. It * supports both otb::Image and otb::VectorImage. The layout * parameter allows setting up of the images will be patched together: * it is a 2D array containing the number of images in the horizontal * direction and vertical direction respectively. * * Images can be set using the PushBackInput() or SetInput(unsigned * int, Image *) methods. Please note that input images are supposed * to be set in the lexicographical order. * * This filter does not support missing images: the number of input * images must match exactly layout[0]*layout[1]. Additional * consistency checks are that the number of components and spacing * must be consistent for all images, and the size of the images must * match with each others. * * \ingroup Streamed * \ingroup MultiThreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT TileImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef TileImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Helper typedefs */ typedef TImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::RegionType RegionType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TileImageFilter, ImageToImageFilter); itkSetMacro(Layout,SizeType); itkGetConstReferenceMacro(Layout,SizeType); protected: /** Constructor */ TileImageFilter(); /** Destructor */ ~TileImageFilter() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Generate input requested region method */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Generate input requested region method */ void GenerateOutputInformation() ITK_OVERRIDE; /** Override VerifyInputInformation() since this filter's inputs do * not need to occupy the same physical space. * * \sa ProcessObject::VerifyInputInformation */ void VerifyInputInformation() ITK_OVERRIDE {} private: TileImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Compute the overlapping region between the output requested // region and the nth input tile largest region RegionType OutputRegionToInputRegion(unsigned int tileIndex, const RegionType & requestedRegion); RegionType InputRegionToOutputRegion(unsigned int tileIndex, const RegionType & requestedRegion); // Layout of the images SizeType m_Layout; // Columns sizes std::vector m_ColumnsSizes; // Row sizes std::vector m_RowsSizes; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbTileImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbTileImageFilter.txx000066400000000000000000000166651301006202600302750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileImageFilter_txx #define otbTileImageFilter_txx #include "otbTileImageFilter.h" #include "itkImageRegionIterator.h" namespace otb { template TileImageFilter ::TileImageFilter() {} template TileImageFilter ::~TileImageFilter() {} template void TileImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os,indent); os< void TileImageFilter ::GenerateOutputInformation() { // First, call superclass implementation Superclass::GenerateOutputInformation(); // Get the number of images unsigned int numberOfImages = m_Layout[0] * m_Layout[1]; // Check we have enough inputs if(numberOfImages != this->GetNumberOfInputs()) { itkExceptionMacro(<<"Layout has "<GetNumberOfInputs()<<" inputs are found."); } typename ImageType::SpacingType spacing = this->GetInput()->GetSpacing(); unsigned int nbComp = this->GetInput()->GetNumberOfComponentsPerPixel(); m_ColumnsSizes.clear(); m_RowsSizes.clear(); // Loop on the layout for(unsigned int col = 0; col < m_Layout[0]; ++col) { for(unsigned int row = 0; row < m_Layout[1]; ++row) { // First, get current tile const ImageType * currentTile = this->GetInput(col + row * m_Layout[0]); typename ImageType::SizeType currentSize = currentTile->GetLargestPossibleRegion().GetSize(); // Retrieve row and column sizes if(col == 0) { m_RowsSizes.push_back(currentSize[1]); } if(row == 0) { m_ColumnsSizes.push_back(currentSize[0]); } // Check for consistent layout if(currentSize[1] != m_RowsSizes[row] || currentSize[0] != m_ColumnsSizes[col]) { itkExceptionMacro(<<"Inconsistent sizes in layout detected!"); } if(spacing != currentTile->GetSpacing()) { itkExceptionMacro(<<"Inconsistent spacings in layout detected!"); } if(nbComp != currentTile->GetNumberOfComponentsPerPixel()) { itkExceptionMacro(<<"Inconsistent number of components in layout detected!"); } } } // Compute total size typename ImageType::SizeType totalSize; totalSize.Fill(0); for(unsigned int i = 0; i < m_Layout[0]; ++i) { totalSize[0]+=m_ColumnsSizes[i]; } for(unsigned int i = 0; i < m_Layout[1]; ++i) { totalSize[1]+=m_RowsSizes[i]; } // Fill out output image settings typename ImageType::RegionType outRegion; outRegion.SetSize(totalSize); //std::cout<<"Output largest region: "<GetOutput(); // Copy information from first tile outputPtr->CopyInformation(this->GetInput()); // Set region outputPtr->SetLargestPossibleRegion(outRegion); } template void TileImageFilter ::GenerateInputRequestedRegion() { // Get output requested region RegionType outRegion = this->GetOutput()->GetRequestedRegion(); // Loop on al input images unsigned int numberOfImages = m_Layout[0] * m_Layout[1]; //std::cout<<"Number of input images: "<GetNumberOfInputs()<(this->GetInput(i)); RegionType inRegion = OutputRegionToInputRegion(i,outRegion); //std::cout<<"In region: "<SetRequestedRegion(inRegion); } } template void TileImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { // Retrieve output image pointer ImageType * outputPtr = this->GetOutput(); // Loop on all input tiles unsigned int numberOfImages = m_Layout[0] * m_Layout[1]; for(unsigned int i = 0; i < numberOfImages; ++i) { const ImageType * inputTile = this->GetInput(i); RegionType inRegion = OutputRegionToInputRegion(i,outputRegionForThread); RegionType outRegion = InputRegionToOutputRegion(i,inRegion); //std::cout<<"[thread] outRegion: "< 0) { //std::cout<<"[thread] "<GetBufferedRegion()< inIt(inputTile,inRegion); itk::ImageRegionIterator outIt(outputPtr,outRegion); inIt.GoToBegin(); outIt.GoToBegin(); while(!inIt.IsAtEnd() && !outIt.IsAtEnd()) { outIt.Set(inIt.Get()); ++inIt; ++outIt; } } } } template typename TileImageFilter ::RegionType TileImageFilter ::OutputRegionToInputRegion(unsigned int tileIndex, const RegionType & requestedRegion) { // Retrieve the nth tile pointer const ImageType * tile = this->GetInput(tileIndex); unsigned int tileYIndex = tileIndex / m_Layout[0]; unsigned int tileXIndex = tileIndex % m_Layout[0]; RegionType out2inRegion = requestedRegion; typename RegionType::IndexType regionIndex = out2inRegion.GetIndex(); // Compute tile offsets for(unsigned int i = 0; i < tileXIndex; ++i) { regionIndex[0]-=m_ColumnsSizes.at(i); } for(unsigned int i = 0; i < tileYIndex; ++i) { regionIndex[1]-=m_RowsSizes.at(i); } out2inRegion.SetIndex(regionIndex); // Crop input region if(!out2inRegion.Crop(tile->GetLargestPossibleRegion())) { typename RegionType::IndexType nullIndex; nullIndex.Fill(0); out2inRegion.SetIndex(nullIndex); SizeType nullSize; nullSize.Fill(0); out2inRegion.SetSize(nullSize); } return out2inRegion; } template typename TileImageFilter ::RegionType TileImageFilter ::InputRegionToOutputRegion(unsigned int tileIndex, const RegionType & requestedRegion) { // Retrieve the nth tile pointer // const ImageType * tile = this->GetInput(tileIndex); unsigned int tileYIndex = tileIndex / m_Layout[0]; unsigned int tileXIndex = tileIndex % m_Layout[0]; RegionType out2inRegion = requestedRegion; typename RegionType::IndexType regionIndex = out2inRegion.GetIndex(); // Compute tile offsets for(unsigned int i = 0; i < tileXIndex; ++i) { regionIndex[0]+=m_ColumnsSizes.at(i); } for(unsigned int i = 0; i < tileYIndex; ++i) { regionIndex[1]+=m_RowsSizes.at(i); } out2inRegion.SetIndex(regionIndex); // Crop input region if(!out2inRegion.Crop(this->GetOutput()->GetLargestPossibleRegion())) { SizeType nullSize; nullSize.Fill(0); out2inRegion.SetSize(nullSize); } return out2inRegion; } } // end namepsace otb #endif otbTwoNRIBandsImageToNComplexBandsImage.h000066400000000000000000000060631301006202600335240ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTwoNRIBandsImageToNComplexBandsImage_h #define otbTwoNRIBandsImageToNComplexBandsImage_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" /* * Inputs : one single image made of 2N real bands * Output : one single image made of N complex bands * * */ namespace otb { template class ITK_EXPORT TwoNRIBandsImageToNComplexBandsImage : public itk::ImageToImageFilter { public: /** Extract input and output image dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** standard class typedefs */ typedef TwoNRIBandsImageToNComplexBandsImage Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Object factory management */ itkNewMacro(Self); /** typemacro */ itkTypeMacro(TwoNRIBandsImageToNComplexBandsImage, ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; protected: TwoNRIBandsImageToNComplexBandsImage(); ~TwoNRIBandsImageToNComplexBandsImage() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; void BeforeThreadedGenerateData(void) ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: TwoNRIBandsImageToNComplexBandsImage(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTwoNRIBandsImageToNComplexBandsImage.txx" #endif #endif otbTwoNRIBandsImageToNComplexBandsImage.txx000066400000000000000000000070501301006202600341150ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTwoNRIBandsImageToNComplexBandsImage_txx #define otbTwoNRIBandsImageToNComplexBandsImage_txx #include "otbTwoNRIBandsImageToNComplexBandsImage.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIterator.h" #include "itkProgressReporter.h" #include "itkVariableLengthVector.h" namespace otb { /** * */ template TwoNRIBandsImageToNComplexBandsImage::TwoNRIBandsImageToNComplexBandsImage() { //this->SetNumberOfThreads(1); } /** * GenerateOutputInformation */ template void TwoNRIBandsImageToNComplexBandsImage ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); unsigned int nbCompo = this->GetInput()->GetNumberOfComponentsPerPixel(); if ( (nbCompo % 2) != 0 ) { itkExceptionMacro("Number of bands of the input images must be an even number"); } else this->GetOutput()->SetNumberOfComponentsPerPixel(nbCompo/2); std::cout << "GenerateOutputInformation : " << this->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; } /** * BeforeThreadedGenerateData */ template void TwoNRIBandsImageToNComplexBandsImage ::BeforeThreadedGenerateData(void) { unsigned int nbCompo = this->GetInput()->GetNumberOfComponentsPerPixel(); if ( (nbCompo % 2) != 0 ) itkExceptionMacro("Number of bands of the input images must be an even number"); } /** * ThreadedGenerateData */ template void TwoNRIBandsImageToNComplexBandsImage::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { unsigned int nbCompo = this->GetInput()->GetNumberOfComponentsPerPixel(); itk::VariableLengthVector< std::complex< typename InputPixelType::ValueType > > vlv(nbCompo/2); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); itk::ImageRegionConstIterator inIt; inIt = itk::ImageRegionConstIterator(this->GetInput(), outputRegionForThread); itk::ImageRegionIterator outIt; outIt = itk::ImageRegionIterator(this->GetOutput(), outputRegionForThread); inIt.GoToBegin(); outIt.GoToBegin(); while (!outIt.IsAtEnd()) { unsigned int k=0; for (unsigned int i=0; i(inIt.Get()[i],inIt.Get()[i+1]); k++; } outIt.Set(vlv); ++inIt; ++outIt; progress.CompletedPixel(); } } /** * Standard "PrintSelf" method */ template void TwoNRIBandsImageToNComplexBandsImage::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbUnaryFunctorNeighborhoodImageFilter.h000066400000000000000000000126761301006202600337710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorNeighborhoodImageFilter_h #define otbUnaryFunctorNeighborhoodImageFilter_h #include "itkImageToImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkProcessObject.h" namespace otb { /** \class UnaryFunctorNeighborhoodImageFilter * \brief Implements neighborhood-wise generic operation on image * * This class is parameterized over the input image type * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT UnaryFunctorNeighborhoodImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorNeighborhoodImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorNeighborhoodImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef typename Superclass::InputImageType InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /**Set/Get the radius of neighborhood.*/ itkSetMacro(Radius, InputImageSizeType); itkGetMacro(Radius, InputImageSizeType); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { this->Modified(); return m_Functor; } /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::RadiusType RadiusType; typedef unsigned char RadiusSizeType; protected: /** * Constructor */ UnaryFunctorNeighborhoodImageFilter(); /** * Destructor */ ~UnaryFunctorNeighborhoodImageFilter() ITK_OVERRIDE {} /** UnaryFunctorNeighborhoodImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Pad the input requested region by radius */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; private: UnaryFunctorNeighborhoodImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InputImageSizeType m_Radius; FunctorType m_Functor; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorNeighborhoodImageFilter.txx" #endif #endif otbUnaryFunctorNeighborhoodImageFilter.txx000066400000000000000000000115701301006202600342760ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorNeighborhoodImageFilter_txx #define otbUnaryFunctorNeighborhoodImageFilter_txx #include "otbUnaryFunctorNeighborhoodImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "itkZeroFluxNeumannBoundaryCondition.h" #include "itkNeighborhoodAlgorithm.h" namespace otb { /** * Constructor */ template UnaryFunctorNeighborhoodImageFilter ::UnaryFunctorNeighborhoodImageFilter() { this->SetNumberOfRequiredInputs(1); m_Radius.Fill(1); } template void UnaryFunctorNeighborhoodImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void UnaryFunctorNeighborhoodImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itk::ZeroFluxNeumannBoundaryCondition nbc; // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImage so it cannot be used for the second input. InputImagePointer inputPtr = dynamic_cast(ProcessObjectType::GetInput(0)); OutputImagePointer outputPtr = this->GetOutput(0); RadiusType r; r[0] = m_Radius[0]; r[1] = m_Radius[1]; NeighborhoodIteratorType neighInputIt; itk::ImageRegionIterator outputIt; // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(inputPtr, outputRegionForThread, r); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { neighInputIt = itk::ConstNeighborhoodIterator(r, inputPtr, *fit); outputIt = itk::ImageRegionIterator(outputPtr, *fit); neighInputIt.OverrideBoundaryCondition(&nbc); neighInputIt.GoToBegin(); while (!outputIt.IsAtEnd()) { outputIt.Set(m_Functor(neighInputIt)); ++neighInputIt; ++outputIt; progress.CompletedPixel(); } } } } // end namespace otb #endif otbUnaryFunctorNeighborhoodWithOffsetImageFilter.h000066400000000000000000000136671301006202600357160ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorNeighborhoodWithOffsetImageFilter_h #define otbUnaryFunctorNeighborhoodWithOffsetImageFilter_h #include "itkImageToImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkProcessObject.h" namespace otb { /** \class UnaryFunctorNeighborhoodWithOffsetImageFilter * \brief Implements neighborhood-wise generic operation on image * * This class is parameterized over the input image type * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT UnaryFunctorNeighborhoodWithOffsetImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorNeighborhoodWithOffsetImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorNeighborhoodWithOffsetImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef typename Superclass::InputImageType InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename InputImageType::OffsetType InputImageOffsetType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /**Set/Get the radius of neighborhood.*/ itkSetMacro(Radius, InputImageSizeType); itkGetMacro(Radius, InputImageSizeType); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } /** Set/Get the offset */ virtual void SetOffset(InputImageOffsetType off) { m_Offset = off; this->GetFunctor().SetOffset(off); this->Modified(); } itkGetMacro(Offset, InputImageOffsetType); /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { this->Modified(); return m_Functor; } /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef typename NeighborhoodIteratorType::RadiusType RadiusType; typedef unsigned char RadiusSizeType; protected: /** * Constructor */ UnaryFunctorNeighborhoodWithOffsetImageFilter(); /** * Destructor */ ~UnaryFunctorNeighborhoodWithOffsetImageFilter() ITK_OVERRIDE {} void BeforeThreadedGenerateData() ITK_OVERRIDE; /** UnaryFunctorNeighborhoodWithOffsetImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Pad the input requested region by radius */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; std::vector m_FunctorList; private: UnaryFunctorNeighborhoodWithOffsetImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InputImageSizeType m_Radius; FunctorType m_Functor; InputImageOffsetType m_Offset; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorNeighborhoodWithOffsetImageFilter.txx" #endif #endif otbUnaryFunctorNeighborhoodWithOffsetImageFilter.txx000066400000000000000000000133601301006202600363000ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorNeighborhoodWithOffsetImageFilter_txx #define otbUnaryFunctorNeighborhoodWithOffsetImageFilter_txx #include "otbUnaryFunctorNeighborhoodWithOffsetImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "itkZeroFluxNeumannBoundaryCondition.h" #include "itkNeighborhoodAlgorithm.h" namespace otb { /** * Constructor */ template UnaryFunctorNeighborhoodWithOffsetImageFilter ::UnaryFunctorNeighborhoodWithOffsetImageFilter() { this->SetNumberOfRequiredInputs(1); m_Radius.Fill(1); m_Offset.Fill(1); m_FunctorList.clear(); } template void UnaryFunctorNeighborhoodWithOffsetImageFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); for (itk::ThreadIdType i = 0; i < this->GetNumberOfThreads(); ++i) { m_FunctorList.push_back(m_Functor); } } template void UnaryFunctorNeighborhoodWithOffsetImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius InputImageSizeType maxRad; maxRad[0] = m_Radius[0] + vcl_abs(m_Offset[0]); maxRad[1] = m_Radius[1] + vcl_abs(m_Offset[1]); inputRequestedRegion.PadByRadius(maxRad); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void UnaryFunctorNeighborhoodWithOffsetImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ZeroFluxNeumannBoundaryCondition nbcOff; // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImage so it cannot be used for the second input. InputImagePointer inputPtr = dynamic_cast(ProcessObjectType::GetInput(0)); OutputImagePointer outputPtr = this->GetOutput(0); itk::ImageRegionIterator outputIt; // Neighborhood+offset iterator RadiusType rOff; rOff[0] = m_Radius[0] + vcl_abs(m_Offset[0]); rOff[1] = m_Radius[1] + vcl_abs(m_Offset[1]); NeighborhoodIteratorType neighInputOffIt; // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceListOff; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bCOff; faceListOff = bCOff(inputPtr, outputRegionForThread, rOff); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fitOff; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. fitOff = faceListOff.begin(); while (fitOff != faceListOff.end()) { // Neighborhood+offset iterator neighInputOffIt = itk::ConstNeighborhoodIterator(rOff, inputPtr, *fitOff); neighInputOffIt.OverrideBoundaryCondition(&nbcOff); neighInputOffIt.GoToBegin(); outputIt = itk::ImageRegionIterator(outputPtr, *fitOff); while (!outputIt.IsAtEnd()) { outputIt.Set(m_FunctorList[threadId](neighInputOffIt.GetNeighborhood())); ++neighInputOffIt; ++outputIt; progress.CompletedPixel(); } ++fitOff; } } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbUnaryFunctorWithIndexImageFilter.h000066400000000000000000000120331301006202600332500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorWithIndexImageFilter_h #define otbUnaryFunctorWithIndexImageFilter_h #include "itkImageToImageFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkProcessObject.h" namespace otb { /** \class UnaryFunctorWithIndexImageFilter * \brief Implements neighborhood-wise generic operation on image * * This class is parameterized over the input image type * and the type of the output image. It is also parameterized by the * operation to be applied. A Functor style is used. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT UnaryFunctorWithIndexImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef UnaryFunctorWithIndexImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorWithIndexImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TFunction FunctorType; typedef typename Superclass::InputImageType InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef itk::ProcessObject ProcessObjectType; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { this->Modified(); return m_Functor; } /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; this->Modified(); } typedef itk::ImageRegionConstIteratorWithIndex IteratorType; protected: /** * Constructor */ UnaryFunctorWithIndexImageFilter(); /** * Destructor */ ~UnaryFunctorWithIndexImageFilter() ITK_OVERRIDE {} /** UnaryFunctorWithIndexImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Pad the input requested region by radius */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; private: UnaryFunctorWithIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorType m_Functor; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryFunctorWithIndexImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbUnaryFunctorWithIndexImageFilter.txx000066400000000000000000000073771301006202600336630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryFunctorWithIndexImageFilter_txx #define otbUnaryFunctorWithIndexImageFilter_txx #include "otbUnaryFunctorWithIndexImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template UnaryFunctorWithIndexImageFilter ::UnaryFunctorWithIndexImageFilter() { this->SetNumberOfRequiredInputs(1); } template void UnaryFunctorWithIndexImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } /** * ThreadedGenerateData Performs the neighborhood-wise operation */ template void UnaryFunctorWithIndexImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImagePointer inputPtr = dynamic_cast(ProcessObjectType::GetInput(0)); OutputImagePointer outputPtr = this->GetOutput(0); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators IteratorType inputIt = IteratorType(inputPtr, inputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd()) { outputIt.Set(m_Functor(inputIt.Get(), inputIt.GetIndex())); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } } // end namespace otb #endif otbUnaryImageFunctorWithVectorImageFilter.h000066400000000000000000000112531301006202600343320ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryImageFunctorWithVectorImageFilter_h #define otbUnaryImageFunctorWithVectorImageFilter_h #include "otbVectorImage.h" #include "itkVariableLengthVector.h" #include "itkUnaryFunctorImageFilter.h" namespace otb { /** \class UnaryImageFunctorWithVectorImageFilter * \brief Applies a functor to a VectorImage * * The aim of the class is to work with vector images but with a functor * that uses as input a component of the pixel. * * For N components pixel, an array of functor is defined and each is applied to * the corresponding component of the output pixel. * * \ingroup Functor * \ingroup VectorImage * * \ingroup OTBImageManipulation */ template class ITK_EXPORT UnaryImageFunctorWithVectorImageFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef UnaryImageFunctorWithVectorImageFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TFunction FunctorType; /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; typedef std::vector FunctorVectorType; /** return class name. */ itkTypeMacro(UnaryImageFunctorWithVectorImageFilter, itk::InPlaceImageFilter); /** Get the functor list */ FunctorVectorType& GetFunctorVector(void) { return m_FunctorVector; } protected: UnaryImageFunctorWithVectorImageFilter(); ~UnaryImageFunctorWithVectorImageFilter() ITK_OVERRIDE {} /** UnaryImageFunctorWithVectorImageFilter can produce an image which is a different * resolution than its input image. As such, UnaryImageFunctorWithVectorImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; /** UnaryImageFunctorWithVectorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** Ponderation declaration*/ FunctorVectorType m_FunctorVector; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnaryImageFunctorWithVectorImageFilter.txx" #endif #endif otbUnaryImageFunctorWithVectorImageFilter.txx000066400000000000000000000103131301006202600347220ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnaryImageFunctorWithVectorImageFilter_txx #define otbUnaryImageFunctorWithVectorImageFilter_txx #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template UnaryImageFunctorWithVectorImageFilter ::UnaryImageFunctorWithVectorImageFilter() { this->SetNumberOfRequiredInputs(1); this->InPlaceOff(); } /** * UnaryImageFunctorWithVectorImageFilter can produce an image which is a different resolution * than its input image. As such, UnaryImageFunctorWithVectorImageFilter needs to provide an * implementation for GenerateOutputInformation() in order to inform * the pipeline execution model. The original documentation of this * method is below. * * \sa ProcessObject::GenerateOutputInformation() */ template void UnaryImageFunctorWithVectorImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // get pointers to the input and output typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); if (!outputPtr || !inputPtr) { return; } outputPtr->SetNumberOfComponentsPerPixel( // propagate vector length info inputPtr->GetNumberOfComponentsPerPixel()); // TODO: Check this // The Functor vector is not initialised ! for (unsigned int i = 0; i < inputPtr->GetNumberOfComponentsPerPixel(); ++i) { FunctorType functor; m_FunctorVector.push_back(functor); } } /** * ThreadedGenerateData Performs the pixel-wise addition */ template void UnaryImageFunctorWithVectorImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); // Null pixel construction InputPixelType nullPixel; nullPixel.SetSize(inputPtr->GetNumberOfComponentsPerPixel()); nullPixel.Fill(itk::NumericTraits::Zero); while (!inputIt.IsAtEnd()) { InputPixelType inPixel = inputIt.Get(); OutputPixelType outPixel; outPixel.SetSize(inputPtr->GetNumberOfComponentsPerPixel()); outPixel.Fill(itk::NumericTraits::Zero); // if the input pixel in null, the output is considered as null ( no sensor information ) if (inPixel != nullPixel) { for (unsigned int j = 0; j < inputPtr->GetNumberOfComponentsPerPixel(); ++j) { outPixel[j] = m_FunctorVector[j](inPixel[j]); } } outputIt.Set(outPixel); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } template void UnaryImageFunctorWithVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbVectorImageTo3DScalarImageFilter.h000066400000000000000000000070351301006202600330200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageTo3DScalarImageFilter_h #define otbVectorImageTo3DScalarImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class VectorImageTo3DScalarImageFilter * \brief This filter convert a 2 Dimension VectorImage to a 3 Dimension scalar image. * * The third dimension of the output image is the index of the band in the vector image. * * No Dimension checking is done by the filter so it is up to the user to template the input * and output image dimension correctly. * * Casting is done through standard casting operators. * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT VectorImageTo3DScalarImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef VectorImageTo3DScalarImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(VectorImageTo3DScalarImageFilter, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::IndexType OutputImageIndexType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename OutputImageType::PixelType OutputPixelType; protected: /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Threaded Generate data */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Constructor */ VectorImageTo3DScalarImageFilter(); /** Destructor */ ~VectorImageTo3DScalarImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: VectorImageTo3DScalarImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorImageTo3DScalarImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbVectorImageTo3DScalarImageFilter.txx000066400000000000000000000105151301006202600334110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageTo3DScalarImageFilter_txx #define otbVectorImageTo3DScalarImageFilter_txx #include "otbVectorImageTo3DScalarImageFilter.h" #include "itkImageRegionConstIterator.h" #include "itkImageSliceIteratorWithIndex.h" namespace otb { /** * Constructor */ template VectorImageTo3DScalarImageFilter ::VectorImageTo3DScalarImageFilter() {} /** Generate output information */ template void VectorImageTo3DScalarImageFilter ::GenerateOutputInformation() { const InputImageType* inputPtr = this->GetInput(); OutputImageType* outputPtr = this->GetOutput(); InputImageRegionType inputLargestRegion = this->GetInput()->GetLargestPossibleRegion(); OutputImageSizeType size; OutputImageIndexType index; for (unsigned int i = 0; i < InputImageType::ImageDimension; ++i) { size[i] = inputLargestRegion.GetSize()[i]; index[i] = inputLargestRegion.GetIndex()[i]; } size[OutputImageType::ImageDimension - 1] = inputPtr->GetNumberOfComponentsPerPixel(); index[OutputImageType::ImageDimension - 1] = 0; OutputImageRegionType outputRegion; outputRegion.SetSize(size); outputRegion.SetIndex(index); outputPtr->SetLargestPossibleRegion(outputRegion); } /** Generate input requested region */ template void VectorImageTo3DScalarImageFilter ::GenerateInputRequestedRegion() { InputImageType* inputPtr = const_cast(this->GetInput()); OutputImageType* outputPtr = this->GetOutput(); OutputImageRegionType requestedRegion = outputPtr->GetRequestedRegion(); InputImageRegionType inputRequestedRegion; InputImageSizeType size; InputImageIndexType index; for (unsigned int i = 0; i < InputImageType::ImageDimension; ++i) { size[i] = requestedRegion.GetSize()[i]; index[i] = requestedRegion.GetIndex()[i]; } inputRequestedRegion.SetSize(size); inputRequestedRegion.SetIndex(index); inputPtr->SetRequestedRegion(inputRequestedRegion); } template void VectorImageTo3DScalarImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { const InputImageType* inputPtr = this->GetInput(); OutputImageType* outputPtr = this->GetOutput(); typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageSliceIteratorWithIndex OutputIteratorType; InputImageRegionType inputRegion; InputImageSizeType size; InputImageIndexType index; for (unsigned int i = 0; i < InputImageType::ImageDimension; ++i) { size[i] = outputRegionForThread.GetSize()[i]; index[i] = outputRegionForThread.GetIndex()[i]; } inputRegion.SetSize(size); inputRegion.SetIndex(index); InputIteratorType inIt(inputPtr, inputRegion); OutputIteratorType outIt(outputPtr, outputRegionForThread); outIt.SetFirstDirection(0); outIt.SetSecondDirection(1); outIt.GoToBegin(); inIt.GoToBegin(); while (!outIt.IsAtEnd()) { outIt.Set(static_cast(inIt.Get()[outIt.GetIndex()[InputImageType::ImageDimension]])); ++inIt; if (inIt.IsAtEnd()) { inIt.GoToBegin(); } ++outIt; if (outIt.IsAtEndOfLine()) { outIt.NextLine(); } if (outIt.IsAtEndOfSlice()) { outIt.NextSlice(); } } } /** * PrintSelf Method */ template void VectorImageTo3DScalarImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbVectorImageToAmplitudeImageFilter.h000066400000000000000000000052641301006202600333520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToAmplitudeImageFilter_h #define otbVectorImageToAmplitudeImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "otbMath.h" #include "itkConceptChecking.h" namespace otb { namespace Functor { template class VectorToAmplitudeFunctor { public: VectorToAmplitudeFunctor() {} virtual ~VectorToAmplitudeFunctor() {} inline TOutput operator ()(const TInput& A) { return static_cast(A.GetNorm()); } itkConceptMacro(OutputShouldNotBeVectorImageCheck, (itk::Concept::Convertible)); }; // end namespace Functor } /** \class VectorImageToAmplitudeImageFilter * \brief This filter returns the the amplitude of the pixel vector. * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT VectorImageToAmplitudeImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard typedefs */ typedef VectorImageToAmplitudeImageFilter Self; typedef itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, Functor::VectorToAmplitudeFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(VectorImageToAmplitudeImageFilter, UnaryFunctorImageFilter); protected: /** Constructor */ VectorImageToAmplitudeImageFilter() {}; /** Destructor */ ~VectorImageToAmplitudeImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: VectorImageToAmplitudeImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbVectorRescaleIntensityImageFilter.h000066400000000000000000000210231301006202600334340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorRescaleIntensityImageFilter_h #define otbVectorRescaleIntensityImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkVariableLengthVector.h" namespace otb { namespace Functor { /** \class VectorAffineTransform * \brief This functor performs a per band linear transform of its input. * * Values upper than InputMaximum or lower than InputMinimum are clamped to OutputMaximum * respectively OutputMinimum values. * * TInput and TOutput type are supposed to be of type itk::VariableLengthVector. * * * \ingroup OTBImageManipulation */ template class VectorAffineTransform { public: /// Real type typedef typedef typename itk::NumericTraits::RealType RealType; /// Constructor VectorAffineTransform(): m_OutputMaximum(), m_OutputMinimum(), m_InputMinimum(), m_InputMaximum(), m_Gamma(1.){} /// Desctructor virtual ~VectorAffineTransform() {} /// Accessors void SetOutputMaximum(TOutput a) { m_OutputMaximum = a; } void SetOutputMinimum(TOutput a) { m_OutputMinimum = a; } void SetInputMinimum(TInput a) { m_InputMinimum = a; } void SetInputMaximum(TInput a) { m_InputMaximum = a; } void SetGamma(const double& gamma) { m_Gamma = gamma; } TOutput GetOutputMaximum() { return m_OutputMaximum; } TOutput GetOutputMinimum() { return m_OutputMinimum; } TInput GetInputMinimum() { return m_InputMinimum; } TInput GetInputMaximum() { return m_InputMaximum; } double GetGamma() { return m_Gamma; } bool operator !=(const VectorAffineTransform& other) const { if (m_OutputMinimum.Size() == other.GetOutputMinimum().Size()) { for (unsigned int i = 0; i < m_OutputMinimum.Size(); ++i) { if (m_OutputMinimum[i] != other.GetOutputMinimum()[i]) { return true; } } } if (m_OutputMaximum.Size() == other.GetOutputMaximum().Size()) { for (unsigned int i = 0; i < m_OutputMaximum.Size(); ++i) { if (m_OutputMaximum[i] != other.GetOutputMaximum()[i]) { return true; } } } if (m_InputMinimum.Size() == other.GetInputMinimum().Size()) { for (unsigned int i = 0; i < m_InputMinimum.Size(); ++i) { if (m_InputMinimum[i] != other.GetInputMinimum()[i]) { return true; } } } if (m_InputMaximum.Size() == other.GetInputMaximum().Size()) { for (unsigned int i = 0; i < m_InputMaximum.Size(); ++i) { if (m_InputMaximum[i] != other.GetInputMaximum()[i]) { return true; } } } return false; } bool operator ==(const VectorAffineTransform& other) const { return !(*this != other); } // main computation method inline TOutput operator ()(const TInput& x) { // output instantiation TOutput result; result.SetSize(x.GetSize()); // consistency checking if (result.GetSize() != m_OutputMinimum.GetSize() || result.GetSize() != m_OutputMaximum.GetSize() || result.GetSize() != m_InputMinimum.GetSize() || result.GetSize() != m_InputMaximum.GetSize()) { itkGenericExceptionMacro(<< "Pixel size different from scale or shift size !"); } // transformation for (unsigned int i = 0; i < x.GetSize(); ++i) { if (x[i] < m_InputMinimum[i]) { result[i] = m_OutputMinimum[i]; } else if (x[i] > m_InputMaximum[i]) { result[i] = m_OutputMaximum[i]; } else if (m_InputMaximum[i] == m_InputMinimum[i]) { result[i] = m_OutputMinimum[i]; } else { RealType scaledComponent = static_cast(x[i] - m_InputMinimum[i])/ static_cast (m_InputMaximum[i] - m_InputMinimum[i]); scaledComponent = vcl_pow(scaledComponent,1./m_Gamma); scaledComponent *= static_cast (m_OutputMaximum[i] - m_OutputMinimum[i]); result[i] = static_cast(scaledComponent + m_OutputMinimum[i]); } } return result; } private: TOutput m_OutputMaximum; TOutput m_OutputMinimum; TInput m_InputMinimum; TInput m_InputMaximum; double m_Gamma; }; } // end namespace functor /** \class VectorRescaleIntensityImageFilter * \brief This filter performs a rescaling of a vector image on a per band basis. * * This filter rescales each band to match the [OutputMinimum, OutputMaximum] range. * In order to avoid odd values to alter the intensity extent, one can set a clamp percentage. * * Values lower than the first quantile of this percentage are set to the OutputMinimum. * Values upper than the last quantile of this percentage are set to the OutputMaximum. * * \ingroup IntensityImageFilters * \ingroup MultiThreaded * * \ingroup OTBImageManipulation */ template class ITK_EXPORT VectorRescaleIntensityImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef VectorRescaleIntensityImageFilter Self; typedef itk::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename TInputImage::PixelType InputPixelType; typedef typename InputPixelType::ValueType InputValueType; typedef typename OutputPixelType::ValueType OutputValueType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename itk::NumericTraits::RealType OutputRealType; /** Method for creation through the object factory. */ itkNewMacro(Self); itkSetMacro(OutputMaximum, OutputPixelType); itkGetConstReferenceMacro(OutputMaximum, OutputPixelType); itkSetMacro(OutputMinimum, OutputPixelType); itkGetConstReferenceMacro(OutputMinimum, OutputPixelType); itkSetMacro(AutomaticInputMinMaxComputation, bool); itkGetMacro(AutomaticInputMinMaxComputation, bool); itkBooleanMacro(AutomaticInputMinMaxComputation); itkGetMacro(ClampThreshold, double); itkSetMacro(ClampThreshold, double); itkGetMacro(InputMinimum, InputPixelType); itkSetMacro(InputMinimum, InputPixelType); itkGetMacro(InputMaximum, InputPixelType); itkSetMacro(InputMaximum, InputPixelType); itkSetMacro(Gamma,double); itkGetConstReferenceMacro(Gamma,double); /** Process to execute before entering the multithreaded section */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Print internal ivars */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; protected: VectorRescaleIntensityImageFilter(); ~VectorRescaleIntensityImageFilter() ITK_OVERRIDE {} private: VectorRescaleIntensityImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputPixelType m_OutputMinimum; OutputPixelType m_OutputMaximum; InputPixelType m_InputMinimum; InputPixelType m_InputMaximum; double m_ClampThreshold; bool m_AutomaticInputMinMaxComputation; double m_Gamma; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorRescaleIntensityImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/include/otbVectorRescaleIntensityImageFilter.txx000066400000000000000000000134411301006202600340350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorRescaleIntensityImageFilter_txx #define otbVectorRescaleIntensityImageFilter_txx #include "otbVectorRescaleIntensityImageFilter.h" #include "itkSampleToHistogramFilter.h" #include "itkHistogram.h" #include "itkListSample.h" #include "otbObjectList.h" #include "otbMacro.h" #include "itkImageRegionConstIterator.h" namespace otb { /** * Constructor */ template VectorRescaleIntensityImageFilter ::VectorRescaleIntensityImageFilter() { m_ClampThreshold = 0.01; m_Gamma = 1.0; m_AutomaticInputMinMaxComputation = true; } /** * Generate output information. */ template void VectorRescaleIntensityImageFilter ::GenerateOutputInformation(void) { this->Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel()); } /** * Generate input requested region. */ template void VectorRescaleIntensityImageFilter ::GenerateInputRequestedRegion(void) { if (this->GetInput()) { typename TInputImage::Pointer input = const_cast(this->GetInput()); typename TInputImage::RegionType inputRegion; this->CallCopyOutputRegionToInputRegion(inputRegion, this->GetOutput()->GetRequestedRegion()); input->SetRequestedRegion(inputRegion); } } /** * Process to execute before entering the multithreaded section. */ template void VectorRescaleIntensityImageFilter ::BeforeThreadedGenerateData() { if (m_ClampThreshold < 0.) { itkExceptionMacro(<< "Invalid Clamp Threshold must be greater than 0.0"); } if (m_AutomaticInputMinMaxComputation) { typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointer; // Get the input InputImagePointer inputImage = this->GetInput(); typedef itk::ImageRegionConstIterator InputIterator; typedef itk::Vector MeasurementVectorType; typedef itk::Statistics::ListSample ListSampleType; typedef float HistogramMeasurementType; typedef itk::Statistics::Histogram< HistogramMeasurementType, itk::Statistics::DenseFrequencyContainer2 > HistogramType; typedef itk::Statistics::SampleToHistogramFilter HistogramGeneratorType; typedef ObjectList ListSampleListType; m_InputMinimum.SetSize(inputImage->GetNumberOfComponentsPerPixel()); m_InputMaximum.SetSize(inputImage->GetNumberOfComponentsPerPixel()); typename ListSampleListType::Pointer sl = ListSampleListType::New(); sl->Reserve(inputImage->GetNumberOfComponentsPerPixel()); for (unsigned int i = 0; i < m_InputMaximum.GetSize(); ++i) { sl->PushBack(ListSampleType::New()); } InputIterator it(inputImage, inputImage->GetBufferedRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { InputPixelType pixel = it.Get(); for (unsigned int i = 0; i < m_InputMaximum.GetSize(); ++i) { sl->GetNthElement(i)->PushBack(pixel[i]); } ++it; } for (unsigned int i = 0; i < m_InputMaximum.GetSize(); ++i) { typename HistogramGeneratorType::Pointer generator = HistogramGeneratorType::New(); generator->SetInput(sl->GetNthElement(i)); typename HistogramGeneratorType::HistogramType::SizeType size; // Initialize the size of the SizeType size size.SetSize(sl->GetNthElement(i)->GetMeasurementVectorSize()); if (m_ClampThreshold > 0.) size.Fill(static_cast(vcl_ceil(1 / m_ClampThreshold) * 10)); else size.Fill(256); generator->SetHistogramSize(size); generator->Update(); m_InputMinimum[i] = static_cast(generator->GetOutput()->Quantile(0, m_ClampThreshold)); m_InputMaximum[i] = static_cast(generator->GetOutput()->Quantile(0, 1 - m_ClampThreshold)); } } // set up the functor values this->GetFunctor().SetInputMinimum(m_InputMinimum); this->GetFunctor().SetInputMaximum(m_InputMaximum); this->GetFunctor().SetOutputMaximum(m_OutputMaximum); this->GetFunctor().SetOutputMinimum(m_OutputMinimum); this->GetFunctor().SetGamma(m_Gamma); } /** * Printself method */ template void VectorRescaleIntensityImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Automatic min/max computation: " << m_AutomaticInputMinMaxComputation << std::endl; os << indent << "Clamp threshold: " << m_ClampThreshold << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageManipulation/otb-module.cmake000066400000000000000000000013551301006202600254310ustar00rootroot00000000000000set(DOCUMENTATION "This module contains everything users may need handle images : clamping, shifting, scaling, rescaling intensities, concatenating of images into one vector image, splitting a vector image into many images, and so on. Among nice other features, let's mention: applying a standard (or a functor) per band, evaluating a ImageFunction onto a source image, generating an image from DEM data.") otb_module(OTBImageManipulation DEPENDS OTBBoostAdapters OTBCommon OTBITK OTBImageBase OTBMetadata OTBInterpolation OTBObjectList OTBStreaming OTBTransform TEST_DEPENDS OTBCommandLineParser OTBDensity OTBImageIO OTBTestKernel OTBTextures DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/ImageManipulation/src/000077500000000000000000000000001301006202600231435ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/src/CMakeLists.txt000066400000000000000000000007001301006202600257000ustar00rootroot00000000000000set(OTBImageManipulation_SRC otbStreamingShrinkImageFilter.cxx ) add_library(OTBImageManipulation ${OTBImageManipulation_SRC}) target_link_libraries(OTBImageManipulation ${OTBCommon_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBITKPendingPatches_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBInterpolation_LIBRARIES} ${OTBObjectList_LIBRARIES} ${OTBStreaming_LIBRARIES} ${OTBTransform_LIBRARIES} ) otb_module_target(OTBImageManipulation) OTB-release-5.8/Modules/Filtering/ImageManipulation/src/otbStreamingShrinkImageFilter.cxx000066400000000000000000000070151301006202600316200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingShrinkImageFilter.h" namespace otb { unsigned int StreamingShrinkImageRegionSplitter ::GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber) { unsigned int theoricalNbPixelPerTile = region.GetNumberOfPixels() / requestedNumber; unsigned int theoricalTileDimension = static_cast (vcl_sqrt(static_cast(theoricalNbPixelPerTile)) ); // Take the previous multiple of m_TileSizeAlignment (eventually generate more splits than requested) m_TileDimension = theoricalTileDimension / m_TileSizeAlignment * m_TileSizeAlignment; // Minimal tile size is m_TileSizeAlignment * m_TileSizeAlignment if (m_TileDimension < m_TileSizeAlignment) { otbMsgDevMacro(<< "Using the minimal tile size : " << m_TileSizeAlignment << " * " << m_TileSizeAlignment); m_TileDimension = m_TileSizeAlignment; } // Use the computed tile size, and generate (m_TileDimension * 1) tiles const SizeType& regionSize = region.GetSize(); m_SplitsPerDimension[0] = (regionSize[0] + m_TileDimension - 1) / m_TileDimension; m_SplitsPerDimension[1] = regionSize[1] / m_TileSizeAlignment; if (m_SplitsPerDimension[1] == 0) m_SplitsPerDimension[1] = 1; unsigned int numPieces = 1; for (unsigned int j = 0; j < ImageDimension; ++j) { numPieces *= m_SplitsPerDimension[j]; } otbMsgDevMacro(<< "Tile dimension : " << m_TileDimension) otbMsgDevMacro(<< "Number of splits per dimension : " << m_SplitsPerDimension[0] << " " << m_SplitsPerDimension[1]) return numPieces; } StreamingShrinkImageRegionSplitter::RegionType StreamingShrinkImageRegionSplitter ::GetSplit(unsigned int i, unsigned int itkNotUsed(numberOfPieces), const RegionType& region) { RegionType splitRegion; IndexType splitIndex; // Compute the actual number of splits unsigned int numPieces = 1; for (unsigned int j = 0; j < ImageDimension; ++j) { numPieces *= m_SplitsPerDimension[j]; } if (i >= numPieces) { itkExceptionMacro("Requested split number " << i << " but region contains only " << numPieces << " splits"); } // Compute the split index in the streaming grid splitIndex[1] = i / m_SplitsPerDimension[0]; splitIndex[0] = i % m_SplitsPerDimension[0]; // Transform the split index to the actual coordinates splitRegion.SetIndex(0, region.GetIndex(0) + m_TileDimension * splitIndex[0]); splitRegion.SetIndex(1, region.GetIndex(1) + m_TileSizeAlignment * splitIndex[1]); splitRegion.SetSize(0, m_TileDimension); splitRegion.SetSize(1, 1); // Handle the borders splitRegion.Crop(region); return splitRegion; } void StreamingShrinkImageRegionSplitter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "SplitsPerDimension : " << m_SplitsPerDimension << std::endl; os << indent << "TileDimension : " << m_TileDimension << std::endl; os << indent << "TileSizeAlignment : " << m_TileSizeAlignment << std::endl; } } // End namespace otb OTB-release-5.8/Modules/Filtering/ImageManipulation/test/000077500000000000000000000000001301006202600233335ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/CMakeLists.txt000066400000000000000000000645221301006202600261040ustar00rootroot00000000000000otb_module_test() set(OTBImageManipulationTests otbImageManipulationTestDriver.cxx otbBinaryImageDensityFunctionNew.cxx otbPrintableImageFilter.cxx otbConcatenateScalarValueImageFilterTest.cxx otbShiftScaleImageAdaptor.cxx otbImageToVectorImageCastFilter.cxx otbFunctionWithNeighborhoodToImageFilter.cxx otbSqrtSpectralAngleImageFilter.cxx otbUnaryFunctorNeighborhoodImageFilterNew.cxx otbStreamingShrinkImageFilter.cxx otbUnaryFunctorWithIndexImageFilterNew.cxx otbUnaryFunctorImageFilterNew.cxx otbUnaryImageFunctorWithVectorImageFilter.cxx otbImageToVectorImageCastFilterNew.cxx otbPrintableImageFilterWithMask.cxx otbStreamingResampleImageFilter.cxx otbUnaryFunctorNeighborhoodWithOffsetImageFilterNew.cxx otbBoxAndWhiskerImageFilterNew.cxx otbVectorImageToAmplitudeImageFilter.cxx otbUnaryFunctorNeighborhoodWithOffsetImageFilter.cxx otbStreamingResampleImageFilterCompareWithITK.cxx otbRegionProjectionResampler.cxx otbVectorImageTo3DScalarImageFilterNew.cxx otbUnaryFunctorWithIndexImageFilter.cxx otbMeanFunctorImageTest.cxx otbBinaryImageToDensityImageFilterNew.cxx otbVectorImageTo3DScalarImageFilter.cxx otbTileImageFilter.cxx otbMatrixImageFilterTest.cxx otbMatrixTransposeMatrixImageFilter.cxx otbPerBandVectorImageFilterNew.cxx otbUnaryFunctorNeighborhoodImageFilter.cxx otbStreamingResampleImageFilterNew.cxx otbStreamingInnerProductVectorImageFilter.cxx otbPhaseFunctorTest.cxx otbShiftScaleVectorImageFilterNew.cxx otbChangeLabelImageFilter.cxx otbClampVectorImageFilter.cxx otbPrintableImageFilterNew.cxx otbShiftScaleImageAdaptorNew.cxx otbStreamingInnerProductVectorImageFilterNew.cxx otbBoxAndWhiskerImageFilter.cxx otbStreamingShrinkImageFilterNew.cxx otbVectorRescaleIntensityImageFilter.cxx otbLog10ThresholdedImageFilterTest.cxx otbChangeLabelImageFilterNew.cxx otbMatrixTransposeMatrixImageFilterNew.cxx otbExtractROIResample.cxx otbLocalGradientVectorImageFilter.cxx otbBinaryImageMinimalBoundingRegionCalculator.cxx otbPerBandVectorImageFilterWithSobelFilter.cxx otbBinaryImageDensityFunction.cxx otbVectorImageToAmplitudeImageFilterNew.cxx otbThresholdVectorImageFilter.cxx otbPerBandVectorImageFilterWithMeanFilter.cxx otbConcatenateVectorImageFilterNew.cxx otbAmplitudeFunctorTest.cxx otbMultiplyByScalarImageTest.cxx otbClampImageFilter.cxx otbConcatenateVectorImageFilter.cxx otbBinaryImageMinimalBoundingRegionCalculatorNew.cxx otbVectorRescaleIntensityImageFilterNew.cxx otbSpectralAngleDistanceImageFilterNew.cxx otbUnaryImageFunctorWithVectorImageFilterNew.cxx otbBinaryImageToDensityImageFilter.cxx otbSpectralAngleDistanceImageFilter.cxx otbFunctionWithNeighborhoodToImageFilterNew.cxx otbEuclideanDistanceMetricWithMissingValue.cxx otbEuclideanDistanceMetricWithMissingValueNew.cxx otbNRIBandImagesToOneNComplexBandsImage.cxx otbOneRIBandImageToOneComplexBandImage.cxx otbTwoNRIBandsImageToNComplexBandsImage.cxx otbChangeNoDataValueFilter.cxx otbImageToNoDataMaskFilter.cxx otbChangeInformationImageFilter.cxx otbGridResampleImageFilter.cxx otbMaskedIteratorDecorator.cxx ) add_executable(otbImageManipulationTestDriver ${OTBImageManipulationTests}) target_link_libraries(otbImageManipulationTestDriver ${OTBImageManipulation-Test_LIBRARIES}) otb_module_target_label(otbImageManipulationTestDriver) # Tests Declaration otb_add_test(NAME bfTuBinaryImageDensityFunctionNew COMMAND otbImageManipulationTestDriver otbBinaryImageDensityFunctionNew ) otb_add_test(NAME bfTvPrintableImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvPrintableImageFilter.png ${TEMP}/bfTvPrintableImageFilter.png otbPrintableImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif ${TEMP}/bfTvPrintableImageFilter.png ) otb_add_test(NAME bfTvConcatenateScalarValueImageFilterTest COMMAND otbImageManipulationTestDriver otbConcatenateScalarValueImageFilterTest ) otb_add_test(NAME bfTuConcatenateScalarValueImageFilterNew COMMAND otbImageManipulationTestDriver otbConcatenateScalarValueImageFilterNew ) otb_add_test(NAME coTvImageToVectorImageCastFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/coImageToVectorImageCastFilterOutput.tif ${TEMP}/coImageToVectorImageCastFilterOutput.tif otbImageToVectorImageCastFilter ${INPUTDATA}/poupees.hdr ${TEMP}/coImageToVectorImageCastFilterOutput.tif ) otb_add_test(NAME bfTvFunctionWithNeighborhoodToImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvFunctionWithNeighborhoodToImageFilterTest.tif ${TEMP}/bfTvFunctionWithNeighborhoodToImageFilterTest.tif otbFunctionWithNeighborhoodToImageFilter ${INPUTDATA}/poupees_1canal.hd ${TEMP}/bfTvFunctionWithNeighborhoodToImageFilterTest.tif 2 # radius ) otb_add_test(NAME feTvSqrtSpectralAngleImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feSqrtSpectralAngle.tif ${TEMP}/feSqrtSpectralAngle.tif otbSqrtSpectralAngleImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/feSqrtSpectralAngle.tif 185 270 150 619 #reference pixel ) otb_add_test(NAME coTuUnaryFunctorNeighborhoodImageFilterNew COMMAND otbImageManipulationTestDriver otbUnaryFunctorNeighborhoodImageFilterNew ) otb_add_test(NAME bfTvStreamingShrinkImageFilterQBPAN COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvStreamingShrinkImageFilterQBPANOutput.hdr ${TEMP}/bfTvStreamingShrinkImageFilterQBPANOutput.hdr otbStreamingShrinkImageFilter LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/bfTvStreamingShrinkImageFilterQBPANOutput.hdr 50 ) otb_add_test(NAME bfTvStreamingShrinkImageFilterQBMUL COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvStreamingShrinkImageFilterQBMULOutput.hdr ${TEMP}/bfTvStreamingShrinkImageFilterQBMULOutput.hdr otbStreamingShrinkImageFilter LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TEMP}/bfTvStreamingShrinkImageFilterQBMULOutput.hdr 20 ) otb_add_test(NAME coTuUnaryFunctorWithIndexImageFilterNew COMMAND otbImageManipulationTestDriver otbUnaryFunctorWithIndexImageFilterNew ) otb_add_test(NAME bfTuUnaryFunctorImageFilterNew COMMAND otbImageManipulationTestDriver otbUnaryFunctorImageFilterNew) otb_add_test(NAME bfTvUnaryImageFunctorWithVectorImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvUnaryImageFunctorWithVectorImageFilter.tif ${TEMP}/bfTvUnaryImageFunctorWithVectorImageFilter.tif otbUnaryImageFunctorWithVectorImageFilter ${INPUTDATA}/poupees_sub.png ${TEMP}/bfTvUnaryImageFunctorWithVectorImageFilter.tif ) otb_add_test(NAME coTuImageToVectorImageCastFilter COMMAND otbImageManipulationTestDriver otbImageToVectorImageCastFilterNew) otb_add_test(NAME bfTvPrintableImageFilterWithMask COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvPrintableImageFilterWithMask.png ${TEMP}/bfTvPrintableImageFilterWithMask.png otbPrintableImageFilterWithMask ${INPUTDATA}/poupees.tif ${INPUTDATA}/carre.png ${TEMP}/bfTvPrintableImageFilterWithMask.png 0 # background ) otb_add_test(NAME bfTvStreamingResampleImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvStreamingResamplePoupeesTest.tif ${TEMP}/bfTvStreamingResamplePoupeesTest.tif otbStreamingResampleImageFilter ${INPUTDATA}/poupees.tif ${TEMP}/bfTvStreamingResamplePoupeesTest.tif ) otb_add_test(NAME coTuUnaryFunctorNeighborhoodWithOffsetImageFilterNew COMMAND otbImageManipulationTestDriver otbUnaryFunctorNeighborhoodWithOffsetImageFilterNew ) otb_add_test(NAME bfTuBoxAndWhiskerImageFilterNew COMMAND otbImageManipulationTestDriver otbBoxAndWhiskerImageFilterNew ) otb_add_test(NAME bfTvVectorImageToAmplitudeImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvVectorImageToAmplitudeImageFilterOutput.tif ${TEMP}/bfTvVectorImageToAmplitudeImageFilterOutput.tif otbVectorImageToAmplitudeImageFilter ${INPUTDATA}/poupees.tif ${TEMP}/bfTvVectorImageToAmplitudeImageFilterOutput.tif ) otb_add_test(NAME coTvUnaryFunctorNeighborhoodWithOffsetImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${INPUTDATA}/poupees.tif ${TEMP}/coTvUnaryFunctorNeighborhoodWithOffsetImageFilter.tif otbUnaryFunctorNeighborhoodWithOffsetImageFilter ${INPUTDATA}/poupees.tif ${TEMP}/coTvUnaryFunctorNeighborhoodWithOffsetImageFilter.tif 2 # radius 2 # offset[0] 2 #offset[1] ) otb_add_test(NAME bfTvStreamingResampleImageFilterCompareWithITK COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${TEMP}/bfTvStreamingResamplePoupeesTestITK.tif ${TEMP}/bfTvStreamingResamplePoupeesTestOTB.tif otbStreamingResampleImageFilterCompareWithITK ${INPUTDATA}/poupees.tif 3000 3000 ${TEMP}/bfTvStreamingResamplePoupeesTestITK.tif ${TEMP}/bfTvStreamingResamplePoupeesTestOTB.tif ) otb_add_test(NAME prTvRegionProjectionResamplerToulouse COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_4} ${BASELINE}/prTvRegionProjectionResamplerToulouse.tif ${TEMP}/prTvRegionProjectionResamplerToulouse.tif otbRegionProjectionResampler LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/prTvRegionProjectionResamplerToulouse.tif 1.44 43.6050 # Long/Lat of Toulouse, Capitole 500 500 100 0.00001 -0.00001 ) otb_add_test(NAME prTvRegionProjectionResamplerCevennes COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_4} ${BASELINE}/prTvRegionProjectionResamplerCevennes.tif ${TEMP}/prTvRegionProjectionResamplerCevennes.tif otbRegionProjectionResampler LARGEINPUT{QUICKBIRD/CEVENNES/06FEB12104912-P1BS-005533998070_01_P001.TIF} ${TEMP}/prTvRegionProjectionResamplerCevennes.tif 3.7 44.08 500 500 10 0.00001 -0.00001 ) otb_add_test(NAME bfTuVectorImageTo3DScalarImageFilterNew COMMAND otbImageManipulationTestDriver otbVectorImageTo3DScalarImageFilterNew) otb_add_test(NAME coTvUnaryFunctorWithIndexImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${INPUTDATA}/poupees.tif ${TEMP}/coTvUnaryFunctorWithIndexImageFilter.tif otbUnaryFunctorWithIndexImageFilter ${INPUTDATA}/poupees.tif ${TEMP}/coTvUnaryFunctorWithIndexImageFilter.tif ) otb_add_test(NAME bfTvMeanFunctorImageTest COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfMeanFunctorImage.tif ${TEMP}/bfMeanFunctorImage.tif otbMeanFunctorImageTest ${INPUTDATA}/couleurs_extrait.png ${TEMP}/bfMeanFunctorImage.tif ) otb_add_test(NAME bfTuBinaryImageToImageDensityFilterNew COMMAND otbImageManipulationTestDriver otbBinaryImageToDensityImageFilterNew ) otb_add_test(NAME bfTvVectorImageTo3DScalarImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvVectorImageTo3DScalarImageFilterOutput.png ${TEMP}/bfTvVectorImageTo3DScalarImageFilterOutput.png otbVectorImageTo3DScalarImageFilter ${INPUTDATA}/poupees.png ${TEMP}/bfTvVectorImageTo3DScalarImageFilterOutput.png ) otb_add_test(NAME bfTvTileImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvTileImageFilterOutput.tif ${TEMP}/bfTvTileImageFilterOutput.tif otbTileImageFilter 2 2 ${TEMP}/bfTvTileImageFilterOutput.tif ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4.tif ) otb_add_test(NAME bfTuTileImageFilterNew COMMAND otbImageManipulationTestDriver otbTileImageFilterNew ) otb_add_test(NAME bfTuMatrixImageFilterNew COMMAND otbImageManipulationTestDriver otbMatrixImageFilterNew ) otb_add_test(NAME bfTvMatrixImageFilterTest_1 COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvMatrixImageFilterTest_1.tif ${TEMP}/bfTvMatrixImageFilterTest_1.tif otbMatrixImageFilterTest ${INPUTDATA}/poupees.tif ${TEMP}/bfTvMatrixImageFilterTest_1.tif 1 ) otb_add_test(NAME bfTvMatrixImageFilterTest_2 COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvMatrixImageFilterTest_2.tif ${TEMP}/bfTvMatrixImageFilterTest_2.tif otbMatrixImageFilterTest ${INPUTDATA}/poupees.tif ${TEMP}/bfTvMatrixImageFilterTest_2.tif 2 ) otb_add_test(NAME bfTvMatrixImageFilterTest_3 COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvMatrixImageFilterTest_3.tif ${TEMP}/bfTvMatrixImageFilterTest_3.tif otbMatrixImageFilterTest ${INPUTDATA}/poupees.tif ${TEMP}/bfTvMatrixImageFilterTest_3.tif 3 ) otb_add_test(NAME bfTvMatrixTransposeMatrixImageFilter COMMAND otbImageManipulationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvMatrixTransposeMatrixImageFilterResults.txt ${TEMP}/bfTvMatrixTransposeMatrixImageFilterResults.txt otbMatrixTransposeMatrixImageFilter ${INPUTDATA}/multiSpect.tif ${INPUTDATA}/multiSpectInterp.tif ${TEMP}/bfTvMatrixTransposeMatrixImageFilterResults.txt ) otb_add_test(NAME bfTuPerBandVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbPerBandVectorImageFilterNew) otb_add_test(NAME coTvUnaryFunctorNeighborhoodImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvUnaryFunctorNeighborhoodImageFilter.png ${TEMP}/coTvUnaryFunctorNeighborhoodImageFilter.png otbUnaryFunctorNeighborhoodImageFilter ${INPUTDATA}/amst.png ${TEMP}/coTvUnaryFunctorNeighborhoodImageFilter.png 3 ) otb_add_test(NAME bfTuStreamingResampleImageFilterNew COMMAND otbImageManipulationTestDriver otbStreamingResampleImageFilterNew) otb_add_test(NAME bfTvStreamingInnerProductVectorImageFilterDisableCenterData COMMAND otbImageManipulationTestDriver --compare-ascii 0.000001 ${BASELINE_FILES}/bfStreamingInnerProductVectorImageFilterResultsDisableCenterData.txt ${TEMP}/bfStreamingInnerProductVectorImageFilterResultsDisableCenterData.txt otbStreamingInnerProductVectorImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfStreamingInnerProductVectorImageFilterResultsDisableCenterData.txt 0 #center data ) otb_add_test(NAME bfTvStreamingInnerProductVectorImageFilter COMMAND otbImageManipulationTestDriver --compare-ascii 0.000001 ${BASELINE_FILES}/bfStreamingInnerProductVectorImageFilterResults.txt ${TEMP}/bfStreamingInnerProductVectorImageFilterResults.txt otbStreamingInnerProductVectorImageFilter ${INPUTDATA}/poupees_sub_3c.png ${TEMP}/bfStreamingInnerProductVectorImageFilterResults.txt 1 #center data ) otb_add_test(NAME bfTvPhaseFunctorTest COMMAND otbImageManipulationTestDriver otbPhaseFunctorTest ) otb_add_test(NAME bfTuShiftScaleVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbShiftScaleVectorImageFilterNew) otb_add_test(NAME bfTvChangeLabelImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfChangeLabelImageFilter.tif ${TEMP}/bfChangeLabelImageFilter.tif otbChangeLabelImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/bfChangeLabelImageFilter.tif 150 # lower threshold 255 # upper threshold ) otb_add_test(NAME bfTvClampVectorImageFilterTest COMMAND otbImageManipulationTestDriver --compare-image 0.0001 ${BASELINE}/bfTvClampVectorImageFilterTest_Output.tif ${TEMP}/bfTvClampVectorImageFilterTest_Output.tif otbClampVectorImageFilterTest ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif ${TEMP}/bfTvClampVectorImageFilterTest_Output.tif ) otb_add_test(NAME bfTuClampVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbClampVectorImageFilterNew ) otb_add_test(NAME bfTuPrintableImageFilterNew COMMAND otbImageManipulationTestDriver otbPrintableImageFilterNew) otb_add_test(NAME coTuShiftScaleImageAdaptorNew COMMAND otbImageManipulationTestDriver otbShiftScaleImageAdaptorNew ) otb_add_test(NAME coTvShiftScaleImageAdaptor COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_9} ${BASELINE}/coTvShiftScaleImageAdaptor.tif # copie the input image ${TEMP}/coTvShiftScaleImageAdaptor.tif otbShiftScaleImageAdaptor ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/coTvShiftScaleImageAdaptor.tif ) otb_add_test(NAME bfTuStreamingInnerProductVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbStreamingInnerProductVectorImageFilterNew ) otb_add_test(NAME bfTvBoxAndWhiskerImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfBoxAndWhiskerImageFilter_05_05.tif ${TEMP}/bfBoxAndWhiskerImageFilter_05_05.tif otbBoxAndWhiskerImageFilter ${INPUTDATA}/poupees.tif ${TEMP}/bfBoxAndWhiskerImageFilter_05_05.tif 05 05) otb_add_test(NAME bfTuStreamingShrinkImageFilterNew COMMAND otbImageManipulationTestDriver otbStreamingShrinkImageFilterNew) otb_add_test(NAME bfTvVectorRescaleIntensityImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvVectorRescaleIntensityOutput.png ${TEMP}/bfTvVectorRescaleIntensityOutput.png otbVectorRescaleIntensityImageFilter ${INPUTDATA}/qb_RoadExtract.img.hdr ${TEMP}/bfTvVectorRescaleIntensityOutput.png 0 255 ) otb_add_test(NAME bfTvotbLog10ThresholdedImageFilterTest COMMAND otbImageManipulationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvLog10ThresholdedImageFilter.txt ${TEMP}/bfTvLog10ThresholdedImageFilterTest.txt otbLog10ThresholdedImageFilterTest ${TEMP}/bfTvLog10ThresholdedImageFilterTest.txt ) otb_add_test(NAME bfTuChangeLabelImageFilterNew COMMAND otbImageManipulationTestDriver otbChangeLabelImageFilterNew ) otb_add_test(NAME bfTuMatrixTransposeMatrixImageFilterNew COMMAND otbImageManipulationTestDriver otbMatrixTransposeMatrixImageFilterNew) otb_add_test(NAME bfTvExtractROIResample2 COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvExtractROIResample2.tif ${TEMP}/bfTvExtractROIResample2.tif otbExtractROIResample ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/bfTvExtractROIResample2.tif 1 ) otb_add_test(NAME bfTvExtractROIResample COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvExtractROIResample.tif ${TEMP}/bfTvExtractROIResample.tif otbExtractROIResample ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/bfTvExtractROIResample.tif 0 ) otb_add_test(NAME bfTvLocalGradientVectorImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvLocalGradientVectorImageFilter.tif ${TEMP}/bfTvLocalGradientVectorImageFilter.tif otbLocalGradientVectorImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvLocalGradientVectorImageFilter.tif) otb_add_test(NAME bfTuLocalGradientVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbLocalGradientVectorImageFilterNewTest) otb_add_test(NAME bfTvBoundingRegionCalculator COMMAND otbImageManipulationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfBoundingRegionCalculatorOutput.txt ${TEMP}/bfBoundingRegionCalculatorOutput.txt otbBinaryImageMinimalBoundingRegionCalculator 4 ${TEMP}/bfBoundingRegionCalculatorOutput.txt ${INPUTDATA}/rcc8_mire1.png ${INPUTDATA}/rcc8_mire2.png ${INPUTDATA}/rcc8_mire3.png ${INPUTDATA}/rcc8_mire4.png ) otb_add_test(NAME bfTvPerBandVectorImageFilterWithSobelFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvPerBandVectorImageFilterWithSobelFilterOutput.hdr ${TEMP}/bfTvPerBandVectorImageFilterWithSobelFilterOutput.hdr otbPerBandVectorImageFilterWithSobelFilter ${INPUTDATA}/poupees.png ${TEMP}/bfTvPerBandVectorImageFilterWithSobelFilterOutput.hdr ) otb_add_test(NAME bfTvBinaryImageDensityFunction COMMAND otbImageManipulationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvBinaryImageDensityFunctionOutputAscii.txt ${TEMP}/bfTvBinaryImageDensityFunctionOutputAscii.txt otbBinaryImageDensityFunction ${INPUTDATA}/scene.png ${TEMP}/bfTvBinaryImageDensityFunctionOutputAscii.txt ) otb_add_test(NAME bfTuVectorImageToAmplitudeImageFilterNew COMMAND otbImageManipulationTestDriver otbVectorImageToAmplitudeImageFilterNew) otb_add_test(NAME bfTvThresholdVectorImageFilterTest COMMAND otbImageManipulationTestDriver --compare-image 0.0001 ${BASELINE}/bfTvThresholdVectorImageFilterTest_Output.tif ${TEMP}/bfTvThresholdVectorImageFilterTest_Output.tif otbThresholdVectorImageFilterTest ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif ${TEMP}/bfTvThresholdVectorImageFilterTest_Output.tif ) otb_add_test(NAME bfTuThresholdVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbThresholdVectorImageFilterNew ) otb_add_test(NAME bfTvPerBandVectorImageFilterWithMeanFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvPerBandVectorImageFilterWithMeanFilterOutput.hdr ${TEMP}/bfTvPerBandVectorImageFilterWithMeanFilterOutput.hdr otbPerBandVectorImageFilterWithMeanFilter ${INPUTDATA}/poupees.png ${TEMP}/bfTvPerBandVectorImageFilterWithMeanFilterOutput.hdr ) otb_add_test(NAME coTuConcatenateVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbConcatenateVectorImageFilterNew) otb_add_test(NAME bfTvAmplitudeFunctorTest COMMAND otbImageManipulationTestDriver otbAmplitudeFunctorTest ) otb_add_test(NAME feTvMultiplyByScalarImage COMMAND otbImageManipulationTestDriver otbMultiplyByScalarImageFilterTest) otb_add_test(NAME bfTuClampImageFilterNew COMMAND otbImageManipulationTestDriver otbClampImageFilterNew ) otb_add_test(NAME bfTvClampImageFilterTest COMMAND otbImageManipulationTestDriver --compare-image 0.0001 ${BASELINE}/bfTvClampImageFilterTest_Output.tif ${TEMP}/bfTvClampImageFilterTest_Output.tif otbClampImageFilterTest ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/bfTvClampImageFilterTest_Output.tif ) otb_add_test(NAME coTvConcatenateVectorImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${NOTOL} ${BASELINE}/coConcatenateVectorImageFilterOutput1.hdr ${TEMP}/coConcatenateVectorImageFilterOutput1.hdr otbConcatenateVectorImageFilter ${INPUTDATA}/poupees.png ${INPUTDATA}/poupees.png ${TEMP}/coConcatenateVectorImageFilterOutput1.hdr ) otb_add_test(NAME bfTuBoundingRegionCalculatorNew COMMAND otbImageManipulationTestDriver otbBinaryImageMinimalBoundingRegionCalculatorNew) otb_add_test(NAME bfTuVectorRescaleIntensityImageFilterNew COMMAND otbImageManipulationTestDriver otbVectorRescaleIntensityImageFilterNew) otb_add_test(NAME bfTuSpectralAngleDistanceImageFilterNew COMMAND otbImageManipulationTestDriver otbSpectralAngleDistanceImageFilterNew) otb_add_test(NAME bfTuUnaryImageFunctorWithVectorImageFilterNew COMMAND otbImageManipulationTestDriver otbUnaryImageFunctorWithVectorImageFilterNew) otb_add_test(NAME bfTvBinaryImageToDensityImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvBinaryImageToDensityImageFilterOutputImage.tif ${TEMP}/bfTvBinaryImageToDensityImageFilterOutputImage.tif otbBinaryImageToDensityImageFilter ${INPUTDATA}/scene.png ${TEMP}/bfTvBinaryImageToDensityImageFilterOutputImage.tif 2 # radius ) otb_add_test(NAME bfTvSpectralAngleDistanceImageFilter COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvSpectralAngleDistanceOutput.hdr ${TEMP}/bfTvSpectralAngleDistanceOutput.hdr otbSpectralAngleDistanceImageFilter ${INPUTDATA}/qb_RoadExtract.img.hdr ${TEMP}/bfTvSpectralAngleDistanceOutput.hdr 337 557 432 859 ) otb_add_test(NAME bfTvSpectralAngleDistanceImageFilterOneChannel COMMAND otbImageManipulationTestDriver otbSpectralAngleDistanceImageFilter ${INPUTDATA}/DeuxCercles.hdr ${TEMP}/bfTvSpectralAngleDistanceOneChannelOutput.hdr 100 ) set_property(TEST bfTvSpectralAngleDistanceImageFilterOneChannel PROPERTY WILL_FAIL true) otb_add_test(NAME bfTvFunctionWithNeighborhoodToImageFilterNew COMMAND otbImageManipulationTestDriver otbFunctionWithNeighborhoodToImageFilterNew ) otb_add_test(NAME bfTvEuclideanDistanceMetricWithMissingValue COMMAND otbImageManipulationTestDriver otbEuclideanDistanceMetricWithMissingValue) otb_add_test(NAME bfTuEuclideanDistanceMetricWithMissingValueNew COMMAND otbImageManipulationTestDriver otbEuclideanDistanceMetricWithMissingValueNew) otb_add_test(NAME bfTvTwoNRIBandsImageToNComplexBandsImage COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvNRIBandImagesToOneNComplexBandsImage.tif ${TEMP}/bfTvTwoNRIBandsImageToNComplexBandsImage.tif otbTwoNRIBandsImageToNComplexBandsImage ${INPUTDATA}/RSAT_imagery_HH_HV_VV.tif ${TEMP}/bfTvTwoNRIBandsImageToNComplexBandsImage.tif ) otb_add_test(NAME bfTvNRIBandImagesToOneNComplexBandsImage COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvNRIBandImagesToOneNComplexBandsImage.tif ${TEMP}/bfTvNRIBandImagesToOneNComplexBandsImage.tif otbNRIBandImagesToOneNComplexBandsImage ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/bfTvNRIBandImagesToOneNComplexBandsImage.tif ) otb_add_test(NAME bfTvOneRIBandImageToOneComplexBandImage COMMAND otbImageManipulationTestDriver --compare-image ${EPSILON_3} ${INPUTDATA}/RSAT_imageryC_HH.tif ${TEMP}/bfTvOneRIBandImageToOneComplexBandImage.tif otbOneRIBandImageToOneComplexBandImage ${INPUTDATA}/RSAT_imagery_HH.tif ${TEMP}/bfTvOneRIBandImageToOneComplexBandImage.tif ) otb_add_test(NAME filteringImageManipulationChangeNoDataValueFilter COMMAND otbImageManipulationTestDriver otbChangeNoDataValueFilter) otb_add_test(NAME filteringImageManipulationImageToNoDataMaskFilter COMMAND otbImageManipulationTestDriver otbImageToNoDataMaskFilter) otb_add_test(NAME bfTvChangeInformationImageFilter COMMAND otbImageManipulationTestDriver otbChangeInformationImageFilter ${INPUTDATA}/WV2_PAN_ROI_1000_100.tif ) otb_add_test(NAME otbGridResampleImageFilter COMMAND otbImageManipulationTestDriver otbGridResampleImageFilter) otb_add_test(NAME bfTuMaskedIteratorDecoratorNew COMMAND otbImageManipulationTestDriver otbMaskedIteratorDecoratorNew ) otb_add_test(NAME bfTvMaskedIteratorDecoratorNominal COMMAND otbImageManipulationTestDriver otbMaskedIteratorDecoratorNominal ) otb_add_test(NAME bfTvMaskedIteratorDecoratorDegenerate COMMAND otbImageManipulationTestDriver otbMaskedIteratorDecoratorDegenerate ) otb_add_test(NAME bfTvMaskedIteratorDecoratorExtended COMMAND otbImageManipulationTestDriver otbMaskedIteratorDecoratorExtended ) OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbAmplitudeFunctorTest.cxx000066400000000000000000000072051301006202600307150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbAmplitudeFunctor.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkRGBAPixel.h" #include "otbMath.h" int otbAmplitudeFunctorTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double ScalarType; typedef otb::Function::AmplitudeFunctor FunctorType; typedef itk::VariableLengthVector VectorPixelType; typedef itk::RGBPixel RGBPixelType; typedef itk::RGBAPixel RGBAPixelType; typedef VectorPixelType OutputPixelType; FunctorType funct; OutputPixelType output; std::vector channels; ScalarType result; VectorPixelType vectorPixel; vectorPixel.SetSize(3); vectorPixel.SetElement(0, 1.0); vectorPixel.SetElement(1, 2.0); vectorPixel.SetElement(2, 3.0); // Test VectorPixelType for(unsigned int i = 0; i < 3; ++i) { for(unsigned int j = 0; j < 3; ++j) { channels.clear(); channels.push_back(i); channels.push_back(j); funct.SetChannelList(channels); output = funct.operator ()(vectorPixel); result = vcl_sqrt(vectorPixel[i] * vectorPixel[i] + vectorPixel[j] * vectorPixel[j]); if( vcl_abs(static_cast(result)-static_cast(output[0])) > 0.0000001) { std::cout << "vectorPixelType Test VectorPixelType failed for channels " << i<< " and " << j << " !" << std::endl; return EXIT_FAILURE; } } } // Test RGBPixelType RGBPixelType rgbPixel; rgbPixel.SetRed(1.0); rgbPixel.SetGreen(2.0); rgbPixel.SetBlue(3.0); for(unsigned int i = 0; i < 3; ++i) { for(unsigned int j = 0; j < 3; ++j) { channels.clear(); channels.push_back(i); channels.push_back(j); funct.SetChannelList(channels); output = funct.operator ()(rgbPixel); result = vcl_sqrt(rgbPixel[i] * rgbPixel[i] + rgbPixel[j] * rgbPixel[j]); if( vcl_abs(static_cast(result)-static_cast(output[0])) > 0.0000001) { std::cout << "vectorPixelType Test RGBPixelType failed for channels " << i<< " and " << j << " !" << std::endl; return EXIT_FAILURE; } } } // Test RGBPAixelType RGBAPixelType rgbaPixel; rgbaPixel.SetRed(1.0); rgbaPixel.SetGreen(2.0); rgbaPixel.SetBlue(3.0); rgbaPixel.SetAlpha(4.0); for(unsigned int i = 0; i < 4; ++i) { for(unsigned int j = 0; j < 4; ++j) { channels.clear(); channels.push_back(i); channels.push_back(j); funct.SetChannelList(channels); output = funct.operator ()(rgbaPixel); result = vcl_sqrt(rgbaPixel[i] * rgbaPixel[i] + rgbaPixel[j] * rgbaPixel[j]); if( std::abs(static_cast(result)-static_cast(output[0])) > 0.0000001) { std::cout << "vectorPixelType Test RGBAPixelType failed for channels " << i<< " and " << j << " !" << std::endl; return EXIT_FAILURE; } } } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbBinaryImageDensityFunction.cxx000066400000000000000000000045541301006202600320310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbBinaryImageDensityFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" #include int otbBinaryImageDensityFunction(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef InputImageType::IndexType IndexType; typedef otb::ImageFileReader ReaderType; typedef otb::BinaryImageDensityFunction FunctionType; /**Instantiation ofa Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); ReaderType::Pointer reader = ReaderType::New(); std::ofstream outfile(outfname); /** Input Image*/ reader->SetFileName(infname); reader->Update(); /** Computing the density around a pixel */ filter->SetInputImage(reader->GetOutput()); filter->SetNeighborhoodRadius(2); /** Test on some indexes and some physical coordinates*/ InputImageType::SizeType size = reader->GetOutput()->GetRequestedRegion().GetSize(); FunctionType::PointType pDst; IndexType index; index[0] = 0; index[1] = 0; outfile << "Density computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; index[0] = static_cast(size[0] / 2.); index[1] = static_cast(size[1] / 4.); outfile << "Density computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; pDst[0] = static_cast(size[0] / 2.); pDst[1] = static_cast(size[1] / 4.); outfile << "Density computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbBinaryImageDensityFunctionNew.cxx000066400000000000000000000022461301006202600324770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbPointSetDensityFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "otbBinaryImageDensityFunction.h" #include "otbImage.h" int otbBinaryImageDensityFunctionNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef otb::BinaryImageDensityFunction FunctionType; /**Instantiation of a Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbBinaryImageMinimalBoundingRegionCalculator.cxx000066400000000000000000000051451301006202600350540ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbBinaryImageMinimalBoundingRegionCalculator.h" #include "otbImageFileReader.h" #include "otbImageList.h" int otbBinaryImageMinimalBoundingRegionCalculator(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; int nbImages = atoi(argv[1]); char * outfile = argv[2]; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::BinaryImageMinimalBoundingRegionCalculator BoundingRegionCalculatorType; typedef BoundingRegionCalculatorType::RegionType RegionType; typedef otb::ImageList ImageListType; typedef ImageListType::Iterator IteratorType; // reference image list ImageListType::Pointer images = ImageListType::New(); // Reading input images std::ofstream out; out.open(outfile, std::ios::out); out << "Test results from otbBinaryImageBoundingRegionCalculator test." << std::endl; for (int i = 1; i <= nbImages; ++i) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[2 + i]); reader->Update(); images->PushBack(reader->GetOutput()); } // Declaration BoundingRegionCalculatorType::Pointer brct; // Computing bounding region for each image for (IteratorType it = images->Begin(); it != images->End(); ++it) { brct = BoundingRegionCalculatorType::New(); brct->SetInput(it.Get()); brct->Update(); RegionType region = brct->GetRegion(); out << region.GetIndex() << "\t" << region.GetSize() << std::endl; } out << std::endl << "Testing the pad option" << std::endl << std::endl; for (IteratorType it = images->Begin(); it != images->End(); ++it) { brct = BoundingRegionCalculatorType::New(); brct->SetPad(1); brct->SetInput(it.Get()); brct->Update(); RegionType region = brct->GetRegion(); out << region.GetIndex() << "\t" << region.GetSize() << std::endl; } out.close(); return EXIT_SUCCESS; } otbBinaryImageMinimalBoundingRegionCalculatorNew.cxx000066400000000000000000000022301301006202600355160ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbBinaryImageMinimalBoundingRegionCalculator.h" int otbBinaryImageMinimalBoundingRegionCalculatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::BinaryImageMinimalBoundingRegionCalculator BoundingRegionCalculatorType; //Instantiation BoundingRegionCalculatorType::Pointer brct = BoundingRegionCalculatorType::New(); std::cout << brct << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbBinaryImageToDensityImageFilter.cxx000066400000000000000000000036001301006202600327260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBinaryImageDensityFunction.h" #include "otbBinaryImageToDensityImageFilter.h" int otbBinaryImageToDensityImageFilter(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int radius = atoi(argv[3]); const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::BinaryImageDensityFunction CountFunctionType; typedef otb::BinaryImageToDensityImageFilter FilterType; /** Instantiation of a Smart Pointer*/ FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); /** */ reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetNeighborhoodRadius(radius); /** */ writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbBinaryImageToDensityImageFilterNew.cxx000066400000000000000000000027371301006202600334120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbPointSetDensityFunction.h" #include "itkPointSet.h" #include "itkVariableLengthVector.h" #include "otbBinaryImageDensityFunction.h" #include "otbBinaryImageToDensityImageFilter.h" #include "otbImage.h" int otbBinaryImageToDensityImageFilterNew(int, char*[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef otb::BinaryImageDensityFunction CountFunctionType; typedef otb::BinaryImageToDensityImageFilter FilterType; /**Instantiation of a Smart Pointer*/ FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbBoxAndWhiskerImageFilter.cxx000066400000000000000000000061371301006202600314140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbBoxAndWhiskerImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbEuclideanDistanceMetricWithMissingValuePow2.h" #include "itkImageRegionIterator.h" int otbBoxAndWhiskerImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); unsigned int RadiusY((unsigned int) ::atoi(argv[4])); typedef double PixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::BoxAndWhiskerImageFilter FilterType; FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusY; FilterType::Pointer filter = FilterType::New(); filter->SetRadius(Radius); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); writer->SetFileName(outputFilename); typedef otb::Statistics::EuclideanDistanceMetricWithMissingValuePow2 OutlierType; filter->SetInput(reader->GetOutput()); filter->Update(); ImageType::Pointer binaryImage = ImageType::New(); binaryImage->SetRegions(filter->GetOutput()->GetLargestPossibleRegion()); binaryImage->SetNumberOfComponentsPerPixel(filter->GetOutput()->GetNumberOfComponentsPerPixel()); binaryImage->Allocate(); ImageType::PixelType p; p.SetSize(filter->GetOutput()->GetNumberOfComponentsPerPixel()); p.Fill(0.0); binaryImage->FillBuffer(p); typedef itk :: ImageRegionConstIterator ConstIteratorType; typedef itk :: ImageRegionIterator IteratorType; ConstIteratorType inputIt (filter->GetOutput(), filter->GetOutput()->GetRequestedRegion()); IteratorType outputIt (binaryImage , filter->GetOutput()->GetRequestedRegion()); for (inputIt .GoToBegin (), outputIt .GoToBegin (); ! inputIt.IsAtEnd (); ++inputIt , ++ outputIt ) { const FilterType::PixelType pixel = inputIt.Get(); ImageType::PixelType outputPixel = outputIt.Get(); const unsigned int vectorSize = pixel.Size(); for (unsigned i = 0; i < vectorSize; ++i) { if ( OutlierType::IsMissingValue(pixel[i]) ) { outputPixel[i] = 1.0; } } outputIt.Set(outputPixel); } writer->SetInput(binaryImage ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbBoxAndWhiskerImageFilterNew.cxx000066400000000000000000000022721301006202600320620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVectorImage.h" #include "otbBoxAndWhiskerImageFilter.h" int otbBoxAndWhiskerImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::BoxAndWhiskerImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbChangeInformationImageFilter.cxx000066400000000000000000000043641301006202600322770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbChangeInformationImageFilter.h" #include "otbImageFileReader.h" #include "otbImage.h" int otbChangeInformationImageFilter(int itkNotUsed(argc), char * argv[]) { const char *inputFilename(argv[1]); typedef otb::Image ImageType; typedef otb::ChangeInformationImageFilter FilterType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); // try to set a different ProjRef std::string newProj("Fake ProjRef"); filter->SetOutputMetaData(otb::MetaDataKey::ProjectionRefKey,&newProj); // erase that choice filter->SetOutputMetaData(otb::MetaDataKey::ProjectionRefKey,ITK_NULLPTR); // add a no data to the image std::vector flags; flags.push_back(true); std::vector nodata; nodata.push_back(0.0); filter->SetOutputMetaData >(otb::MetaDataKey::NoDataValueAvailable,&flags); filter->SetOutputMetaData >(otb::MetaDataKey::NoDataValue,&nodata); filter->UpdateOutputInformation(); ImageType::Pointer outImage = filter->GetOutput(); if (! outImage->GetProjectionRef().empty()) { std::cout << "Projection is supposed to be removed but is still present !" << std::endl; return EXIT_FAILURE; } itk::MetaDataDictionary &dict = outImage->GetMetaDataDictionary(); if (!dict.HasKey(otb::MetaDataKey::NoDataValueAvailable) || !dict.HasKey(otb::MetaDataKey::NoDataValue)) { std::cout << "Missing no data metadata !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbChangeLabelImageFilter.cxx000066400000000000000000000052071301006202600310260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbChangeLabelImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbImageFileWriter.h" #include "otbImageFileReader.h" int otbChangeLabelImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int ImageDimension = 2; const char * inputFilename(argv[1]); const char * outFilename(argv[2]); typedef unsigned short PixelType; typedef otb::Image InputImageType; typedef otb::VectorImage OutputImageType; typedef InputImageType::PixelType InputPixelType; typedef OutputImageType::PixelType OutputPixelType; typedef otb::ChangeLabelImageFilter FilterType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileReader ReaderType; FilterType::Pointer filter = FilterType::New(); InputImageType::Pointer vectImage = InputImageType::New(); WriterType::Pointer writer = WriterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outFilename); InputPixelType lower = static_cast(atoi(argv[3])); InputPixelType upper = static_cast(atoi(argv[4])); filter->SetNumberOfComponentsPerPixel(3); OutputPixelType background; background.SetSize(filter->GetNumberOfComponentsPerPixel()); background[0] = itk::NumericTraits::max(); background[1] = itk::NumericTraits::max(); background[2] = 0; OutputPixelType zero = itk::NumericTraits::ZeroValue(background); filter->SetChange(0, zero); for (InputPixelType i = lower; i <= upper; ++i) { filter->SetChange(i, background); } filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbChangeLabelImageFilterNew.cxx000066400000000000000000000022351301006202600314760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbChangeLabelImageFilter.h" #include "itkChangeLabelImageFilter.h" #include "otbImage.h" int otbChangeLabelImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int ImageDimension = 2; typedef otb::Image InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ChangeLabelImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbChangeNoDataValueFilter.cxx000066400000000000000000000051201301006202600312010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbChangeNoDataValueFilter.h" #include "itkImageRegionIterator.h" int otbChangeNoDataValueFilter(int itkNotUsed(argc),char * itkNotUsed(argv) []) { // Build an image typedef otb::Image ImageType; ImageType::Pointer img = ImageType::New(); ImageType::SizeType size; size.Fill(20); ImageType::RegionType region; region.SetSize(size); // Fill it with a default value img->SetRegions(region); img->Allocate(); img->FillBuffer(10); // Write no-data flags to it std::vector flags(1,true); std::vector values(1,-10.); otb::WriteNoDataFlags(flags,values,img->GetMetaDataDictionary()); // Fill half of the pixels with no-data values itk::ImageRegionIterator it(img,region); unsigned int count = 0; for(it.GoToBegin();!it.IsAtEnd();++it,++count) { if (count%2 == 0) it.Set(-10.); } // Instantiate filter typedef otb::ChangeNoDataValueFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::vector newValues(1,-20.); filter->SetInput(img); filter->SetNewNoDataValues(newValues); filter->Update(); // Check output it = itk::ImageRegionIterator(filter->GetOutput(),region); count = 0; bool failed = false; for(it.GoToBegin();!it.IsAtEnd();++it,++count) { if (count%2 == 0 && it.Get()!=-20.) { std::cerr<<"Pixel should have new no-data value"<GetOutput()->GetMetaDataDictionary(),flags,values); if(flags.empty() || !flags[0]) { std::cerr<<"Output no-data flag should be [1] "< InputImageType; typedef otb::Image OutputImageType; typedef otb::ClampImageFilter FilterType; int otbClampImageFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { /** instantiating the filter */ FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbClampImageFilterTest(int itkNotUsed(argc), char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; /** instantiating the filter */ FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName( argv[1] ); filter->SetInput( reader->GetOutput() ); filter->SetLower( 100 ); filter->SetUpper( 400 ); writer->SetInput( filter->GetOutput() ); writer->SetFileName( argv[2] ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbClampVectorImageFilter.cxx000066400000000000000000000040621301006202600311160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbClampVectorImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" /** Pixel typedefs */ typedef double InputPixelType; typedef unsigned int OutputPixelType; /** Image typedefs */ const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ClampVectorImageFilter FilterType; int otbClampVectorImageFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { /** instantiating the filter */ FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbClampVectorImageFilterTest(int itkNotUsed(argc), char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; /** instantiating the filter */ FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName( argv[1] ); filter->SetInput( reader->GetOutput() ); filter->SetLower( 100 ); filter->SetUpper( 400 ); writer->SetInput( filter->GetOutput() ); writer->SetFileName( argv[2] ); writer->Update(); return EXIT_SUCCESS; } otbConcatenateScalarValueImageFilterTest.cxx000066400000000000000000000062701301006202600340320ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbConcatenateScalarValueImageFilter.h" #include "otbImageFileReader.h" #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ConcatenateScalarValueImageFilter FilterType; int otbConcatenateScalarValueImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbConcatenateScalarValueImageFilterTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { ImageType::Pointer image = ImageType::New(); const PixelType ScalarValue = 42; const unsigned int Size = 10; const unsigned int NbComponentIn = 4; ImageType::RegionType region; region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, Size); region.SetSize(1, Size); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(NbComponentIn); image->Allocate(); itk::ImageRegionIteratorWithIndex it(image, image->GetLargestPossibleRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { ImageType::IndexType idx = it.GetIndex(); ImageType::PixelType value; value.SetSize(NbComponentIn); for (unsigned int k = 0; k < NbComponentIn; ++k) { value[k] = idx[0] + idx[1] * Size + k; } it.Set(value); } FilterType::Pointer filter = FilterType::New(); filter->SetInput(image); filter->SetScalarValue(ScalarValue); ImageType::Pointer outimage = filter->GetOutput(); filter->UpdateOutputInformation(); if (outimage->GetNumberOfComponentsPerPixel() != NbComponentIn + 1) { std::cerr << "Number of components should be " << NbComponentIn + 1 << std::endl; return EXIT_FAILURE; } filter->Update(); itk::ImageRegionIteratorWithIndex outIt(outimage, outimage->GetLargestPossibleRegion()); for (outIt.GoToBegin(); !outIt.IsAtEnd(); ++outIt) { ImageType::IndexType idx = outIt.GetIndex(); ImageType::PixelType value = outIt.Get(); for (unsigned int k = 0; k < NbComponentIn; ++k) { if (value[k] != idx[0] + idx[1] * Size + k) { std::cerr << "Error at index " << idx << " channel " << k << " : expected " << idx[0] + idx[1] * Size + k << " got " << value[k] << std::endl; return EXIT_FAILURE; } } if (value[NbComponentIn] != ScalarValue) { std::cerr << "Error at index " << idx << " channel " << NbComponentIn << " : expected " << ScalarValue << " got " << value[NbComponentIn] << std::endl; return EXIT_FAILURE; } } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbConcatenateVectorImageFilter.cxx000066400000000000000000000037031301006202600323070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbConcatenateVectorImageFilter.h" int otbConcatenateVectorImageFilter(int itkNotUsed(argc), char * argv[]) { const char * filename1 = argv[1]; const char * filename2 = argv[2]; const char * outputfilename = argv[3]; const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ConcatenateVectorImageFilter FilterType; ReaderType::Pointer reader1 = ReaderType::New(); ReaderType::Pointer reader2 = ReaderType::New(); reader1->SetFileName(filename1); reader2->SetFileName(filename2); // Instantiating filter object FilterType::Pointer filter = FilterType::New(); filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputfilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbConcatenateVectorImageFilterNew.cxx000066400000000000000000000022161301006202600327570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbConcatenateVectorImageFilter.h" int otbConcatenateVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::VectorImage ImageType; typedef otb::ConcatenateVectorImageFilter FilterType; // Instantiating adaptor object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbEuclideanDistanceMetricWithMissingValue.cxx000066400000000000000000000033421301006202600344020ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itkVariableLengthVector.h" #include "otbEuclideanDistanceMetricWithMissingValue.h" int otbEuclideanDistanceMetricWithMissingValue(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef itk::VariableLengthVector VectorType; typedef otb::Statistics::EuclideanDistanceMetricWithMissingValue DistanceType; DistanceType::Pointer dist = DistanceType::New(); if (dist->IsMissingValue(0.0)) return EXIT_FAILURE; if (dist->IsMissingValue(1.0)) return EXIT_FAILURE; if (dist->IsMissingValue(-1.0)) return EXIT_FAILURE; /* std::cerr << "Is O Nan ?? -> " << dist->IsMissingValue( 0.0 ) << "\n"; std::cerr << "Is 1 Nan ?? -> " << dist->IsMissingValue( 1.0 ) << "\n"; std::cerr << "Is -1 Nan ?? -> " << dist->IsMissingValue( -1.0 ) << "\n"; */ double x = 0.0; dist->SetToMissingValue(x); if (!dist->IsMissingValue(x)) return EXIT_FAILURE; // std::cerr << "Is x (=" << x << ") Nan ?? -> " << dist->IsMissingValue( x ) << "\n"; return EXIT_SUCCESS; } otbEuclideanDistanceMetricWithMissingValueNew.cxx000066400000000000000000000022641301006202600350560ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itkVariableLengthVector.h" #include "otbEuclideanDistanceMetricWithMissingValue.h" int otbEuclideanDistanceMetricWithMissingValueNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef itk::VariableLengthVector VectorType; typedef otb::Statistics::EuclideanDistanceMetricWithMissingValue DistanceType; DistanceType::Pointer dist = DistanceType::New(); std::cout << dist << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbExtractROIResample.cxx000066400000000000000000000053341301006202600302460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "itkIdentityTransform.h" #include "otbStreamingResampleImageFilter.h" // Pipeline reader -> Resampler (with Identity transform) -> ExtractROI // -> Writer // the resample is optionally removed with the command line parameter. // int otbExtractROIResample(int argc, char* argv[]) { if (argc < 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } bool useResample = true; if (atoi(argv[3]) == 0) { useResample = false; } unsigned int startX = 10; unsigned int startY = 10; unsigned int sizeX = 100; unsigned int sizeY = 100; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); typedef itk::IdentityTransform IdentityTransformType; IdentityTransformType::Pointer transform = IdentityTransformType::New(); typedef otb::StreamingResampleImageFilter ResampleType; ResampleType::Pointer filterResample = ResampleType::New(); filterResample->SetInput(reader->GetOutput()); filterResample->SetTransform(transform); filterResample->SetOutputSize(reader->GetOutput()->GetLargestPossibleRegion().GetSize()); typedef otb::ExtractROI ExtractROIType; ExtractROIType::Pointer filterResampleRoi = ExtractROIType::New(); filterResampleRoi->SetStartX(startX); filterResampleRoi->SetStartY(startY); filterResampleRoi->SetSizeX(sizeX); filterResampleRoi->SetSizeY(sizeY); if (useResample) { filterResampleRoi->SetInput(filterResample->GetOutput()); } else { filterResampleRoi->SetInput(reader->GetOutput()); } typedef otb::ImageFileWriter WriterType; WriterType::Pointer streamingWriter = WriterType::New(); streamingWriter->SetFileName(argv[2]); streamingWriter->SetInput(filterResampleRoi->GetOutput()); streamingWriter->Update(); return EXIT_SUCCESS; } otbFunctionWithNeighborhoodToImageFilter.cxx000066400000000000000000000042031301006202600340710ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbFunctionWithNeighborhoodToImageFilter.h" #include "itkVarianceImageFunction.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbFunctionWithNeighborhoodToImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::VarianceImageFunction FunctionType; typedef otb::FunctionWithNeighborhoodToImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); FunctionType::Pointer function = FunctionType::New(); function->SetNeighborhoodRadius(atoi(argv[3])); function->SetInputImage(reader->GetOutput()); filter->SetFunction(function); writer->SetInput(filter->GetOutput()); writer->SetNumberOfDivisionsStrippedStreaming(2); writer->Update(); return EXIT_SUCCESS; } otbFunctionWithNeighborhoodToImageFilterNew.cxx000066400000000000000000000043251301006202600345500ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkNeighborhood.h" #include "otbImage.h" //#include "itkVariableLengthVector.h" //#include "itkConstNeighborhoodIterator.h" #include "otbTextureImageFunction.h" #include "otbFunctionWithNeighborhoodToImageFilter.h" //#include "otbTextureFunctorBase.h" template //IterInput1, class TIterInput2, class TOutput> class TextureFunctorTest { public: /** Return the texture name */ virtual std::string GetName() const { return "TextureFunctorTest"; } TextureFunctorTest() { m_Offset.Fill(1); } virtual ~TextureFunctorTest() {} typedef itk::Offset<> OffsetType; typedef itk::Neighborhood NeighborhoodType; void SetOffset(OffsetType off){ m_Offset = off; } inline TOutputScalarType operator ()(const NeighborhoodType& neigh) { return static_cast(neigh.GetCenterValue()); } private: OffsetType m_Offset; }; int otbFunctionWithNeighborhoodToImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef TextureFunctorTest FunctorType; typedef otb::TextureImageFunction FunctionType; typedef otb::FunctionWithNeighborhoodToImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbGridResampleImageFilter.cxx000066400000000000000000000112651301006202600312600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbGridResampleImageFilter.h" #include "itkResampleImageFilter.h" #include "itkGaussianImageSource.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "itkIdentityTransform.h" #include "otbDifferenceImageFilter.h" #include "itkStreamingImageFilter.h" #include "otbImageFileWriter.h" int otbGridResampleImageFilter(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { // This test is only to check that filter builds with VectorImage // too typedef otb::VectorImage VectorImageType; typedef otb::GridResampleImageFilter VectorFilterType; VectorFilterType::Pointer vectorFilter = VectorFilterType::New(); typedef otb::Image ImageType; typedef otb::GridResampleImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); typedef itk::ResampleImageFilter RefFilterType; RefFilterType::Pointer refFilter = RefFilterType::New(); // We will resample a random image with GridResampleImageFilter and // ResampleImageFilter, and check that outputs are the same typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; RandomGeneratorType::Pointer randomGenerator = RandomGeneratorType::GetInstance(); ImageType::SizeType size; size.Fill(1000); ImageType::RegionType region; region.SetSize(size); ImageType::Pointer randomImage = ImageType::New(); randomImage->SetRegions(region); randomImage->Allocate(); typedef itk::ImageRegionIterator IteratorType; IteratorType iter(randomImage,region); for (iter.GoToBegin() ; !iter.IsAtEnd() ; ++iter) { iter.Set(randomGenerator->GetUniformVariate(0.0, 1.0) * 1000); } filter->SetInput(randomImage); refFilter->SetInput(randomImage); typedef itk::IdentityTransform IdentityTransformType; IdentityTransformType::Pointer idTransform = IdentityTransformType::New(); refFilter->SetTransform(idTransform); ImageType::SpacingType spacing; spacing[0]=0.12; spacing[1]=-0.19; ImageType::PointType origin; origin[0]=11; origin[1]=17; ImageType::SizeType outSize; outSize.Fill(103); filter->SetOutputSize(outSize); filter->SetOutputOrigin(origin); filter->SetOutputSpacing(spacing); refFilter->SetSize(outSize); refFilter->SetOutputOrigin(origin); refFilter->SetOutputSpacing(spacing); typedef otb::DifferenceImageFilter ComparisonFilterType; typedef itk::StreamingImageFilter StreamingFilterType; StreamingFilterType::Pointer streamingRef = StreamingFilterType::New(); streamingRef->SetInput(refFilter->GetOutput()); streamingRef->SetNumberOfStreamDivisions(10); StreamingFilterType::Pointer streaming = StreamingFilterType::New(); streaming->SetInput(filter->GetOutput()); streaming->SetNumberOfStreamDivisions(10); ComparisonFilterType::Pointer comparisonFilter = ComparisonFilterType::New(); comparisonFilter->SetValidInput(streamingRef->GetOutput()); comparisonFilter->SetTestInput(streaming->GetOutput()); comparisonFilter->SetDifferenceThreshold(1e-9); comparisonFilter->Update(); unsigned int nbPixelsWithDiff = comparisonFilter->GetNumberOfPixelsWithDifferences(); std::cout<<"Number of pixels with differences: "< WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(comparisonFilter->GetOutput()); writer->SetFileName("otbGridResampleImageFilterTestOutput.tif"); writer->Update(); writer = WriterType::New(); writer->SetInput(streamingRef->GetOutput()); writer->SetFileName("otbGridResampleImageFilterTestOutput1.tif"); writer->Update(); writer = WriterType::New(); writer->SetInput(streaming->GetOutput()); writer->SetFileName("otbGridResampleImageFilterTestOutput2.tif"); writer->Update(); return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbImageManipulationTestDriver.cxx000066400000000000000000000107271301006202600322120ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbBinaryImageDensityFunctionNew); REGISTER_TEST(otbPrintableImageFilter); REGISTER_TEST(otbConcatenateScalarValueImageFilterNew); REGISTER_TEST(otbConcatenateScalarValueImageFilterTest); REGISTER_TEST(otbShiftScaleImageAdaptor); REGISTER_TEST(otbImageToVectorImageCastFilter); REGISTER_TEST(otbFunctionWithNeighborhoodToImageFilter); REGISTER_TEST(otbSqrtSpectralAngleImageFilter); REGISTER_TEST(otbUnaryFunctorNeighborhoodImageFilterNew); REGISTER_TEST(otbStreamingShrinkImageFilter); REGISTER_TEST(otbUnaryFunctorWithIndexImageFilterNew); REGISTER_TEST(otbUnaryFunctorImageFilterNew); REGISTER_TEST(otbUnaryImageFunctorWithVectorImageFilter); REGISTER_TEST(otbImageToVectorImageCastFilterNew); REGISTER_TEST(otbPrintableImageFilterWithMask); REGISTER_TEST(otbStreamingResampleImageFilter); REGISTER_TEST(otbUnaryFunctorNeighborhoodWithOffsetImageFilterNew); REGISTER_TEST(otbBoxAndWhiskerImageFilterNew); REGISTER_TEST(otbVectorImageToAmplitudeImageFilter); REGISTER_TEST(otbUnaryFunctorNeighborhoodWithOffsetImageFilter); REGISTER_TEST(otbStreamingResampleImageFilterCompareWithITK); REGISTER_TEST(otbRegionProjectionResampler); REGISTER_TEST(otbVectorImageTo3DScalarImageFilterNew); REGISTER_TEST(otbUnaryFunctorWithIndexImageFilter); REGISTER_TEST(otbMeanFunctorImageTest); REGISTER_TEST(otbBinaryImageToDensityImageFilterNew); REGISTER_TEST(otbVectorImageTo3DScalarImageFilter); REGISTER_TEST(otbTileImageFilterNew); REGISTER_TEST(otbTileImageFilter); REGISTER_TEST(otbMatrixImageFilterNew); REGISTER_TEST(otbMatrixImageFilterTest); REGISTER_TEST(otbMatrixTransposeMatrixImageFilter); REGISTER_TEST(otbPerBandVectorImageFilterNew); REGISTER_TEST(otbUnaryFunctorNeighborhoodImageFilter); REGISTER_TEST(otbStreamingResampleImageFilterNew); REGISTER_TEST(otbStreamingInnerProductVectorImageFilter); REGISTER_TEST(otbPhaseFunctorTest); REGISTER_TEST(otbShiftScaleVectorImageFilterNew); REGISTER_TEST(otbChangeLabelImageFilter); REGISTER_TEST(otbClampVectorImageFilterNew); REGISTER_TEST(otbClampVectorImageFilterTest); REGISTER_TEST(otbPrintableImageFilterNew); REGISTER_TEST(otbShiftScaleImageAdaptorNew); REGISTER_TEST(otbStreamingInnerProductVectorImageFilterNew); REGISTER_TEST(otbBoxAndWhiskerImageFilter); REGISTER_TEST(otbStreamingShrinkImageFilterNew); REGISTER_TEST(otbVectorRescaleIntensityImageFilter); REGISTER_TEST(otbLog10ThresholdedImageFilterTest); REGISTER_TEST(otbChangeLabelImageFilterNew); REGISTER_TEST(otbMatrixTransposeMatrixImageFilterNew); REGISTER_TEST(otbExtractROIResample); REGISTER_TEST(otbLocalGradientVectorImageFilterNewTest); REGISTER_TEST(otbLocalGradientVectorImageFilterTest); REGISTER_TEST(otbBinaryImageMinimalBoundingRegionCalculator); REGISTER_TEST(otbPerBandVectorImageFilterWithSobelFilter); REGISTER_TEST(otbBinaryImageDensityFunction); REGISTER_TEST(otbVectorImageToAmplitudeImageFilterNew); REGISTER_TEST(otbThresholdVectorImageFilterNew); REGISTER_TEST(otbThresholdVectorImageFilterTest); REGISTER_TEST(otbPerBandVectorImageFilterWithMeanFilter); REGISTER_TEST(otbConcatenateVectorImageFilterNew); REGISTER_TEST(otbAmplitudeFunctorTest); REGISTER_TEST(otbMultiplyByScalarImageFilterTest); REGISTER_TEST(otbClampImageFilterNew); REGISTER_TEST(otbClampImageFilterTest); REGISTER_TEST(otbConcatenateVectorImageFilter); REGISTER_TEST(otbBinaryImageMinimalBoundingRegionCalculatorNew); REGISTER_TEST(otbVectorRescaleIntensityImageFilterNew); REGISTER_TEST(otbSpectralAngleDistanceImageFilterNew); REGISTER_TEST(otbUnaryImageFunctorWithVectorImageFilterNew); REGISTER_TEST(otbBinaryImageToDensityImageFilter); REGISTER_TEST(otbSpectralAngleDistanceImageFilter); REGISTER_TEST(otbFunctionWithNeighborhoodToImageFilterNew); REGISTER_TEST(otbEuclideanDistanceMetricWithMissingValue); REGISTER_TEST(otbEuclideanDistanceMetricWithMissingValueNew); REGISTER_TEST(otbNRIBandImagesToOneNComplexBandsImage); REGISTER_TEST(otbOneRIBandImageToOneComplexBandImage); REGISTER_TEST(otbTwoNRIBandsImageToNComplexBandsImage); REGISTER_TEST(otbChangeNoDataValueFilter); REGISTER_TEST(otbImageToNoDataMaskFilter); REGISTER_TEST(otbChangeInformationImageFilter); REGISTER_TEST(otbGridResampleImageFilter); REGISTER_TEST(otbMaskedIteratorDecoratorNew); REGISTER_TEST(otbMaskedIteratorDecoratorNominal); REGISTER_TEST(otbMaskedIteratorDecoratorDegenerate); REGISTER_TEST(otbMaskedIteratorDecoratorExtended); } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbImageToNoDataMaskFilter.cxx000066400000000000000000000043061301006202600311650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageToNoDataMaskFilter.h" #include "itkImageRegionIterator.h" int otbImageToNoDataMaskFilter(int itkNotUsed(argc),char * itkNotUsed(argv) []) { // Build an image typedef otb::Image ImageType; ImageType::Pointer img = ImageType::New(); ImageType::SizeType size; size.Fill(20); ImageType::RegionType region; region.SetSize(size); // Fill it with a default value img->SetRegions(region); img->Allocate(); img->FillBuffer(10); // Write no-data flags to it std::vector flags(1,true); std::vector values(1,-10.); otb::WriteNoDataFlags(flags,values,img->GetMetaDataDictionary()); // Fill half of the pixels with no-data values itk::ImageRegionIterator it(img,region); unsigned int count = 0; for(it.GoToBegin();!it.IsAtEnd();++it,++count) { if (count%2 == 0) it.Set(-10.); } // Instantiate filter typedef otb::ImageToNoDataMaskFilter FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput(img); filter->SetInsideValue(255); filter->SetOutsideValue(0); filter->Update(); // Check output it = itk::ImageRegionIterator(filter->GetOutput(),region); count = 0; bool failed = false; for(it.GoToBegin();!it.IsAtEnd();++it,++count) { if (count%2 == 0 && it.Get()!=0) { std::cerr<<"Pixel should be masked"< ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageToVectorImageCastFilter VectorImageCastFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infilename); VectorImageCastFilterType::Pointer cast = VectorImageCastFilterType::New(); cast->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfilename); writer->SetInput(cast->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbImageToVectorImageCastFilterNew.cxx000066400000000000000000000023041301006202600326710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToVectorImageCastFilter.h" #include "otbVectorImage.h" #include "otbImage.h" int otbImageToVectorImageCastFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageToVectorImageCastFilter VectorImageCastFilterType; // Instantiation VectorImageCastFilterType::Pointer caster = VectorImageCastFilterType::New(); std::cout << caster << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbLocalGradientVectorImageFilter.cxx000066400000000000000000000063451301006202600326000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbLocalGradientVectorImageFilter.h" int otbLocalGradientVectorImageFilterNewTest ( int itkNotUsed(argc), char * itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::LocalGradientVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbLocalGradientVectorImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs horizonal sobel on a vector image\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::LocalGradientVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbLog10ThresholdedImageFilterTest.cxx000066400000000000000000000051411301006202600326060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "itkImageRegionIterator.h" #include "otbLog10ThresholdedImageFilter.h" int otbLog10ThresholdedImageFilterTest(int argc, char* argv[]) { if (argc != 2) { std::cout << "Invalid arguments -> need only output filename" << std::endl; return EXIT_FAILURE; } // TYPEDEFS typedef double PixelType; typedef otb::Image ImageType; typedef ImageType::RegionType RegionType; typedef ImageType::SizeType SizeType; typedef ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::Log10ThresholdedImageFilter FilterType; // INSTANTIATIONS ImageType::Pointer image = ImageType::New(); ImageType::Pointer imageOut = ImageType::New(); FilterType::Pointer filter = FilterType::New(); std::ofstream file; file.open(argv[1]); RegionType region; SizeType size; size.Fill(5); IndexType orig; orig.Fill(0); region.SetSize(size); region.SetIndex(orig); image->SetRegions(region); image->Allocate(); image->FillBuffer(0.); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); double val = 0.; while (!it.IsAtEnd()) { val = 0.000001 * (double) pow((double) 10.0, (int) (it.GetIndex()[0] + it.GetIndex()[1])); if (it.GetIndex()[0] + it.GetIndex()[1] > 6) it.Set(itk::NumericTraits::quiet_NaN()); else it.Set(static_cast (val)); ++it; } filter->SetInput(image); filter->SetThresholdedValue(0.002); // -> -26.9897 dB filter->Update(); IteratorType itOut(filter->GetOutput(), image->GetLargestPossibleRegion()); itOut.GoToBegin(); it.GoToBegin(); while (!itOut.IsAtEnd() && !it.IsAtEnd()) { std::cout << "Input Value : " << it.Get() << ", "\ << "Output Value : " << itOut.Get() << " dB" \ << std::endl; file << "val[" << it.GetIndex() << "] = " << itOut.Get() << " dB" << std::endl; ++itOut; ++it; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbMaskedIteratorDecorator.cxx000066400000000000000000000306441301006202600313540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbVectorImage.h" #include "itkImageRegionIterator.h" #include "itkImageRegionReverseIterator.h" #include "itkImageRandomIteratorWithIndex.h" #include "itkImageScanlineIterator.h" #include "itkImageRandomNonRepeatingIteratorWithIndex.h" #include "otbSubsampledImageRegionIterator.h" #include "otbMaskedIteratorDecorator.h" // Generate a test image of specified size and value template typename ImageType::Pointer GetTestImage(itk::SizeValueType fillSize, const typename ImageType::PixelType& value, unsigned int nbBand=1) { typename ImageType::Pointer image = ImageType::New(); typename ImageType::SizeType size; size.Fill(fillSize); typename ImageType::RegionType region; region.SetSize(size); image->SetNumberOfComponentsPerPixel(nbBand); image->SetRegions(region); image->Allocate(); image->FillBuffer(value); return image; } // Fill half of the pixels with a value // Used for generating a test mask template void FillHalf(typename ImageType::Pointer image, const typename ImageType::RegionType& region, const typename ImageType::PixelType& value) { itk::ImageRegionIterator it(image, region); unsigned int count = 0; for(it.GoToBegin(); !it.IsAtEnd(); ++it, ++count) { if (count % 2 == 0) { it.Set(value); } } } // Test template instantiation int otbMaskedIteratorDecoratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; ImageType::Pointer image = GetTestImage(10, 10); ImageType::Pointer mask = GetTestImage(10, 0); ImageType::RegionType region(image->GetLargestPossibleRegion()); otb::MaskedIteratorDecorator > it(mask, image, region); return EXIT_SUCCESS; } // ---------------------- Initialization code ---------------------------------- template void InitializeIterator(IteratorType&, typename IteratorType::RegionType) { // by default : nothing to do } // specialization for otb::SubsampledImageRegionIterator > template <> void InitializeIterator< otb::SubsampledImageRegionIterator< otb::Image > >( otb::SubsampledImageRegionIterator< otb::Image >& it, otb::SubsampledImageRegionIterator >::RegionType) { it.SetSubsampleFactor(2); } // -------------------------- ForwardTest -------------------------------------- // Function to test the forward iteration interface template int ForwardTest(typename MaskIteratorType::ImageType::Pointer mask, typename IteratorType::ImageType::Pointer image, typename IteratorType::ImageType::RegionType region) { otb::MaskedIteratorDecorator it(mask, image, region); // specific initialization code InitializeIterator(it.GetImageIterator(),region); if (it.HasMask()) { InitializeIterator(it.GetMaskIterator(),region); } it.GoToBegin(); if (!it.IsAtBegin()) {return 1;} unsigned int loopCount = 0; for(; !it.IsAtEnd(); ++it) { if (loopCount != 0 && it.IsAtBegin()) {return 2;} if (it.IsAtEnd()) {return 3;} //it.Set(it.Value() * 0.42); loopCount += 1; } if(!it.IsAtEnd()) {return 4;} return 0; } // -------------------------- ReverseTest -------------------------------------- // Test reverse iteration interface template int ReverseTest(typename MaskIteratorType::ImageType::Pointer mask, typename IteratorType::ImageType::Pointer image, typename IteratorType::ImageType::RegionType region) { otb::MaskedIteratorDecorator it(mask, image, region); // specific initialization code InitializeIterator(it.GetImageIterator(),region); if (it.HasMask()) { InitializeIterator(it.GetMaskIterator(),region); } it.GoToEnd(); if (!it.IsAtEnd()) {return 1;} bool beginReached = false; while (!it.IsAtBegin()) { --it; if (it.IsAtEnd()) {return 2;} if (beginReached) { return 3; } if (it.IsAtBegin()) { beginReached = true; } } if(!it.IsAtBegin()) {return 4;} return 0; } // -------------------------- BijectiveTest -------------------------------------- // Check bijection between iterated and non masked // i.e all locations where mask value != 0 are in the iteration (injection) // and mask value != 0 at all iteration locations (surjection) // Templated to test decoration of different iterator types template int BijectiveTest(typename MaskIteratorType::ImageType::Pointer mask, typename IteratorType::ImageType::Pointer image, typename IteratorType::ImageType::RegionType region) { otb::MaskedIteratorDecorator itDecorated(mask, image, region); IteratorType it(image, region); // specific initialization code InitializeIterator(itDecorated.GetImageIterator(),region); InitializeIterator(it,region); if (itDecorated.HasMask()) { InitializeIterator(itDecorated.GetMaskIterator(),region); } it.GoToBegin(); itDecorated.GoToBegin(); // Find the non masked begin for the image iterator if (itDecorated.HasMask()) { while (mask->GetPixel(it.GetIndex()) == 0 && !it.IsAtEnd()) { ++it; } } // Begins are the same if (!(it.GetIndex() == itDecorated.GetIndex() && it.GetIndex() == itDecorated.GetImageIterator().GetIndex())) { return 1; } if (itDecorated.HasMask() && it.GetIndex() != itDecorated.GetMaskIterator().GetIndex()) { return 1; } // Advance both and check while (!it.IsAtEnd() && !itDecorated.IsAtEnd()) { // Iteration locations are the same if (!(it.GetIndex() == itDecorated.GetIndex() && it.GetIndex() == itDecorated.GetImageIterator().GetIndex())) { return 2; } if (itDecorated.HasMask() && it.GetIndex() != itDecorated.GetMaskIterator().GetIndex()) { return 2; } ++itDecorated; if (itDecorated.HasMask()) { do { ++it; } while (mask->GetPixel(it.GetIndex()) == 0 && !it.IsAtEnd()); } else { ++it; } } // Check IsAtEnd if (!(it.IsAtEnd() && itDecorated.IsAtEnd())) { return 3; } return 0; } // Multiplex to forward, reverse and bijection test template int TripleTest(typename IteratorType::ImageType::Pointer image,typename MaskIteratorType::ImageType::Pointer mask, typename IteratorType::ImageType::RegionType region) { int ret; int retGlobal = EXIT_SUCCESS; ret = ForwardTest(mask, image, region); if (ret>0) { std::cout << "Forward(FAILED:"<(mask, image, region); if (ret>0) { std::cout << "Reverse(FAILED:"<(mask, image, region); if (ret>0) { std::cout << "Bijective(FAILED:"< ImageType; ImageType::Pointer image = GetTestImage(10, 10); ImageType::Pointer mask = GetTestImage(10, 0); ImageType::RegionType region(image->GetLargestPossibleRegion()); FillHalf(mask, region, 1); int ret; int retGlobal = EXIT_SUCCESS; std::cout << std::endl << "itk::ImageRegionIterator : "; ret = TripleTest< itk::ImageRegionIterator, itk::ImageRegionIterator >(image, mask, region); retGlobal = (ret == EXIT_FAILURE ? EXIT_FAILURE : retGlobal); std::cout << std::endl << "itk::ImageRegionConstIterator : "; ret = TripleTest< itk::ImageRegionConstIterator, itk::ImageRegionConstIterator >(image, mask, region); retGlobal = (ret == EXIT_FAILURE ? EXIT_FAILURE : retGlobal); // std::cout << std::endl << "otb::SubsampledImageRegionIterator : "; // ret = TripleTest< otb::SubsampledImageRegionIterator, // otb::SubsampledImageRegionIterator >(image, mask, region); // retGlobal = (ret == EXIT_FAILURE ? EXIT_FAILURE : retGlobal); return retGlobal; } // ------------------------ Degenerate cases ----------------------------------- int otbMaskedIteratorDecoratorDegenerate(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Fully masked (0 everywhere) typedef otb::Image ImageType; ImageType::Pointer image = GetTestImage(10, 10); ImageType::Pointer mask = GetTestImage(10, 0); ImageType::RegionType region(image->GetLargestPossibleRegion()); return TripleTest, itk::ImageRegionIterator >(image, mask, region); } // --------------------------- Extended cases ---------------------------------- int otbMaskedIteratorDecoratorExtended(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorImage ImageType; typedef otb::Image MaskType; otb::VectorImage::PixelType pixel(3); pixel.Fill(12); ImageType::Pointer image = GetTestImage(10,pixel ,3); MaskType::Pointer mask = GetTestImage(10, 0); ImageType::RegionType region(image->GetLargestPossibleRegion()); FillHalf(mask, region, 1); int ret; int retGlobal = EXIT_SUCCESS; std::cout << std::endl << "itk::ImageRegionIterator : "; ret = TripleTest< itk::ImageRegionIterator, itk::ImageRegionIterator >(image, mask, region); retGlobal = (ret == EXIT_FAILURE ? EXIT_FAILURE : retGlobal); std::cout << std::endl << "itk::ImageRegionConstIterator : "; ret = TripleTest< itk::ImageRegionConstIterator, itk::ImageRegionConstIterator >(image, mask, region); retGlobal = (ret == EXIT_FAILURE ? EXIT_FAILURE : retGlobal); std::cout << std::endl << "itk::ImageRegionIterator without mask: "; ret = TripleTest< itk::ImageRegionIterator, itk::ImageRegionIterator >(image, ITK_NULLPTR, region); retGlobal = (ret == EXIT_FAILURE ? EXIT_FAILURE : retGlobal); std::cout << std::endl << "itk::ImageRegionConstIterator without mask: "; ret = TripleTest< itk::ImageRegionConstIterator, itk::ImageRegionConstIterator >(image, ITK_NULLPTR, region); retGlobal = (ret == EXIT_FAILURE ? EXIT_FAILURE : retGlobal); return retGlobal; } /* Other iterators potentially compatible: Different constructor arguments than (image, region) itk::PathIterator itk::LineIterator itk::SliceIterator itk::NeighborhoodIterator Needs initialization code: itk::ImageRandomConstIteratorWithIndex itk::ImageRandomIteratorWithIndex itk::ImageRandomNonRepeatingConstIteratorWithIndex itk::ImageRandomNonRepeatingIteratorWithIndex otb::SubsampledImageRegionIterator : GoToEnd is buggy ! Different iteration interface than normal iterators: itk::ImageScanlineIterator itk::ImageScanlineConstIterator GoToEnd is not implemented itk::ImageLinearIteratorWithIndex itk::ReflectiveImageRegionIterator itk::ImageRegionExclusionConstIteratorWithIndex itk::ImageRegionIteratorWithIndex Other problem: itk::ImageRegionReverseIterator>() // IsAtEnd not a const method otb::PolyLineImageIterator>() // header not found itk::ImageRandomConstIteratorWithOnlyIndex>() // no Value method */ OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbMatrixImageFilterTest.cxx000066400000000000000000000042061301006202600310030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMatrixImageFilter.h" #include "otbImageFileReader.h" #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include int otbMatrixImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::MatrixImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbMatrixImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int nbCol =atoi(argv[3]); typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MatrixImageFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); reader->SetFileName(inputFilename); reader->GenerateOutputInformation(); writer->SetFileName(outputFilename); FilterType::MatrixType mat(reader->GetOutput()->GetNumberOfComponentsPerPixel(), nbCol, 0.); double val = 0; for(unsigned int i=0; iSetInput(reader->GetOutput()); filter->SetMatrix(mat); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbMatrixTransposeMatrixImageFilter.cxx000066400000000000000000000042401301006202600332250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbStreamingMatrixTransposeMatrixImageFilter.h" int otbMatrixTransposeMatrixImageFilter(int itkNotUsed(argc), char * argv[]) { const char * infname1 = argv[1]; const char * infname2 = argv[2]; const char * outfname = argv[3]; const unsigned int Dimension = 2; //typedef double InputPixelType; //typedef double OutputPixelType; typedef unsigned char InputPixelType; typedef otb::VectorImage InputImage1Type; typedef otb::VectorImage InputImage2Type; typedef otb::StreamingMatrixTransposeMatrixImageFilter MatrixTransposeMatrixImageFilterType; typedef otb::ImageFileReader ReaderType1; typedef otb::ImageFileReader ReaderType2; // Instantiation MatrixTransposeMatrixImageFilterType::Pointer filter = MatrixTransposeMatrixImageFilterType::New(); ReaderType1::Pointer reader1 = ReaderType1::New(); ReaderType2::Pointer reader2 = ReaderType2::New(); reader1->SetFileName(infname1); reader2->SetFileName(infname2); filter->GetStreamer()->SetNumberOfLinesStrippedStreaming( 10 ); filter->SetFirstInput(reader1->GetOutput()); filter->SetSecondInput(reader2->GetOutput()); filter->SetUsePadFirstInput(true); filter->SetUsePadSecondInput(true); filter->Update(); std::ofstream file; file.open(outfname); file << "transpose : " << filter->GetResult() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbMatrixTransposeMatrixImageFilterNew.cxx000066400000000000000000000024531301006202600337030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbStreamingMatrixTransposeMatrixImageFilter.h" int otbMatrixTransposeMatrixImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef otb::VectorImage InputImage1Type; typedef otb::VectorImage InputImage2Type; typedef otb::StreamingMatrixTransposeMatrixImageFilter MatrixTransposeMatrixImageFilterType; // Instantiation MatrixTransposeMatrixImageFilterType::Pointer filter = MatrixTransposeMatrixImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbMeanFunctorImageTest.cxx000066400000000000000000000033671301006202600306210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "itkUnaryFunctorImageFilter.h" #include "otbMeanFunctor.h" int otbMeanFunctorImageTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::MeanFunctor MeanFunctorType; typedef itk::UnaryFunctorImageFilter MeanFilterType; MeanFilterType::Pointer filter = MeanFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbMultiplyByScalarImageTest.cxx000066400000000000000000000073771301006202600316450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbMultiplyByScalarImageFilter.h" int otbMultiplyByScalarImageFilterTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Define the dimension of the images const unsigned int ImageDimension = 2; // Declare the types of the images typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // Declare Iterator types apropriated for each image typedef itk::ImageRegionIteratorWithIndex< InputImageType> InputIteratorType; typedef itk::ImageRegionIteratorWithIndex< OutputImageType> OutputIteratorType; // Declare the type of the index to access images typedef itk::Index IndexType; // Declare the type of the size typedef itk::Size SizeType; // Declare the type of the Region typedef itk::ImageRegion RegionType; // Create two images InputImageType::Pointer inputImage = InputImageType::New(); // Define their size, and start index SizeType size; size[0] = 2; size[1] = 2; IndexType start; start[0] = 0; start[1] = 0; RegionType region; region.SetIndex(start); region.SetSize(size); // Initialize Image A inputImage->SetRegions(region); inputImage->Allocate(); // Create one iterator for the Input Image (this is a light object) InputIteratorType it(inputImage, inputImage->GetBufferedRegion()); // Initialize the content of Image A const double pi = vcl_atan(1.0) * 4.0; const double value = pi / 6.0; std::cout << "Content of the Input " << std::endl; it.GoToBegin(); while (!it.IsAtEnd()) { it.Set(value); std::cout << it.Get() << std::endl; ++it; } // Declare the type for the Acos filter typedef otb::MultiplyByScalarImageFilter FilterType; // Create a MultiplyScalarImage Filter FilterType::Pointer filter = FilterType::New(); // Connect the input images filter->SetInput(inputImage); // Get the Smart Pointer to the Filter Output OutputImageType::Pointer outputImage = filter->GetOutput(); // Execute the filter filter->SetCoef(10.); filter->Update(); // Create an iterator for going through the image output OutputIteratorType ot(outputImage, outputImage->GetRequestedRegion()); // Check the content of the result image std::cout << "Verification of the output " << std::endl; const OutputImageType::PixelType epsilon = 1e-6; ot.GoToBegin(); it.GoToBegin(); while (!ot.IsAtEnd()) { std::cout << ot.Get() << " = "; std::cout << 10.0 * (it.Get()) << std::endl; const InputImageType::PixelType input = it.Get(); const OutputImageType::PixelType output = ot.Get(); const OutputImageType::PixelType multiplyByScal = 10.0 * input; if (vcl_abs(multiplyByScal - output) > epsilon) { std::cerr << "Error in otbMultiplyScalarImageFilterTest " << std::endl; std::cerr << " 10.0 * " << input << ") = " << multiplyByScal << std::endl; std::cerr << " differs from " << output; std::cerr << " by more than " << epsilon << std::endl; return 1; } ++ot; ++it; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbNRIBandImagesToOneNComplexBandsImage.cxx000066400000000000000000000035151301006202600334610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbNRIBandImagesToOneNComplexBandsImage.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbNRIBandImagesToOneNComplexBandsImage(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage InputImageType; typedef std::complex OutputPixelType; typedef otb::VectorImage OutputImageType; typedef otb::NRIBandImagesToOneNComplexBandsImage FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer readerA = ReaderType::New(); ReaderType::Pointer readerB = ReaderType::New(); ReaderType::Pointer readerC = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); WriterType::Pointer writer = WriterType::New(); readerA->SetFileName(argv[1]); readerB->SetFileName(argv[2]); readerC->SetFileName(argv[3]); writer->SetFileName(argv[4]); filter->SetInput(0,readerA->GetOutput()); filter->SetInput(1,readerB->GetOutput()); filter->SetInput(2,readerC->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbOneRIBandImageToOneComplexBandImage.cxx000066400000000000000000000030771301006202600333240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbOneRIBandImageToOneComplexBandImage.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbOneRIBandImageToOneComplexBandImage(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage InputImageType; typedef std::complex OutputPixelType; typedef otb::Image OutputImageType; typedef otb::OneRIBandImageToOneComplexBandImage FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbPerBandVectorImageFilterNew.cxx000066400000000000000000000026031301006202600320460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPerBandVectorImageFilter.h" #include "otbVectorImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkMeanImageFilter.h" int otbPerBandVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::PerBandVectorImageFilter PerBandVectorImageFilterType; // Instantiating object PerBandVectorImageFilterType::Pointer filter = PerBandVectorImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbPerBandVectorImageFilterWithMeanFilter.cxx000066400000000000000000000035521301006202600341240ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPerBandVectorImageFilter.h" #include "otbVectorImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkMeanImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbPerBandVectorImageFilterWithMeanFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::PerBandVectorImageFilter PerBandVectorImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object PerBandVectorImageFilterType::Pointer filter = PerBandVectorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); writer->SetFileName(outfname); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbPerBandVectorImageFilterWithSobelFilter.cxx000066400000000000000000000036631301006202600343130ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPerBandVectorImageFilter.h" #include "otbVectorImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkSobelEdgeDetectionImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbPerBandVectorImageFilterWithSobelFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef itk::SobelEdgeDetectionImageFilter SobelFilterType; typedef otb::PerBandVectorImageFilter PerBandVectorImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object PerBandVectorImageFilterType::Pointer filter = PerBandVectorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); writer->SetFileName(outfname); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbPhaseFunctorTest.cxx000066400000000000000000000070351301006202600300320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPhaseFunctor.h" #include "itkVariableLengthVector.h" #include "itkRGBPixel.h" #include "itkRGBAPixel.h" #include "otbMath.h" int otbPhaseFunctorTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double ScalarType; typedef otb::Function::PhaseFunctor FunctorType; typedef itk::VariableLengthVector VectorPixelType; typedef itk::RGBPixel RGBPixelType; typedef itk::RGBAPixel RGBAPixelType; typedef VectorPixelType OutputPixelType; FunctorType funct; OutputPixelType output; std::vector channels; ScalarType result; VectorPixelType vectorPixel; vectorPixel.SetSize(3); vectorPixel.SetElement(0, 1.0); vectorPixel.SetElement(1, 2.0); vectorPixel.SetElement(2, 3.0); // Test VectorPixelType for(unsigned int i = 0; i < 3; ++i) { for(unsigned int j = 0; j < 3; ++j) { channels.clear(); channels.push_back(i); channels.push_back(j); funct.SetChannelList(channels); output = funct.operator ()(vectorPixel); result = vcl_atan2(vectorPixel[j],vectorPixel[i]); if( vcl_abs(static_cast(result)-static_cast(output[0])) > 0.0000001) { std::cout << "vectorPixelType Test VectorPixelType failed for channels " << i<< " and " << j << " !" << std::endl; return EXIT_FAILURE; } } } // Test RGBPixelType RGBPixelType rgbPixel; rgbPixel.SetRed(1.0); rgbPixel.SetGreen(2.0); rgbPixel.SetBlue(3.0); for(unsigned int i = 0; i < 3; ++i) { for(unsigned int j = 0; j < 3; ++j) { channels.clear(); channels.push_back(i); channels.push_back(j); funct.SetChannelList(channels); output = funct.operator ()(rgbPixel); result = vcl_atan2(rgbPixel[j],rgbPixel[i]); if( vcl_abs(static_cast(result)-static_cast(output[0])) > 0.0000001) { std::cout << "vectorPixelType Test RGBPixelType failed for channels " << i<< " and " << j << " !" << std::endl; return EXIT_FAILURE; } } } // Test RGBPAixelType RGBAPixelType rgbaPixel; rgbaPixel.SetRed(1.0); rgbaPixel.SetGreen(2.0); rgbaPixel.SetBlue(3.0); rgbaPixel.SetAlpha(4.0); for(unsigned int i = 0; i < 4; ++i) { for(unsigned int j = 0; j < 4; ++j) { channels.clear(); channels.push_back(i); channels.push_back(j); funct.SetChannelList(channels); output = funct.operator ()(rgbaPixel); result = vcl_atan2(rgbaPixel[j],rgbaPixel[i]); if( vcl_abs(static_cast(result)-static_cast(output[0])) > 0.0000001) { std::cout << "vectorPixelType Test RGBAPixelType failed for channels " << i<< " and " << j << " !" << std::endl; return EXIT_FAILURE; } } } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbPrintableImageFilter.cxx000066400000000000000000000034051301006202600306170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "itkMacro.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbPrintableImageFilter.h" int otbPrintableImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::PrintableImageFilter FilterType; typedef FilterType::OutputImageType OutputImageType; typedef otb::ImageFileWriter WriterType; FilterType::Pointer printableImageFilter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); printableImageFilter->SetInput(reader->GetOutput()); printableImageFilter->SetChannel(3); printableImageFilter->SetChannel(2); printableImageFilter->SetChannel(1); writer->SetInput(printableImageFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbPrintableImageFilterNew.cxx000066400000000000000000000020531301006202600312670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbPrintableImageFilter.h" int otbPrintableImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::PrintableImageFilter FilterType; FilterType::Pointer printableImage = FilterType::New(); std::cout << printableImage << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbPrintableImageFilterWithMask.cxx000066400000000000000000000052051301006202600322670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbPrintableImageFilter.h" int otbPrintableImageFilterWithMask(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * masktFilename = argv[2]; const char * outputFilename = argv[3]; typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::PrintableImageFilter FilterType; typedef FilterType::OutputImageType OutputImageType; typedef OutputImageType::PixelType OutputPixelType; typedef FilterType::MaskImageType MaskImageType; typedef FilterType::MaskPixelType MaskPixelType; typedef otb::ImageFileReader InputReaderType; typedef otb::ImageFileReader MaskReaderType; typedef otb::ImageFileWriter WriterType; FilterType::Pointer printableImageFilter = FilterType::New(); InputReaderType::Pointer inputReader = InputReaderType::New(); MaskReaderType::Pointer maskReader = MaskReaderType::New(); WriterType::Pointer writer = WriterType::New(); inputReader->SetFileName(inputFilename); maskReader->SetFileName(masktFilename); maskReader->GenerateOutputInformation(); writer->SetFileName(outputFilename); printableImageFilter->SetInput(inputReader->GetOutput()); printableImageFilter->SetInputMask(maskReader->GetOutput()); FilterType::ChannelsType chList; chList.push_back(3); chList.push_back(2); chList.push_back(1); printableImageFilter->SetChannelList(chList); OutputPixelType objectColor; objectColor.SetSize(3); objectColor[0] = 0; objectColor[1] = 255; objectColor[2] = 0; printableImageFilter->SetObjectColor(objectColor); printableImageFilter->SetBackgroundMaskValue(static_cast(atof(argv[4]))); writer->SetInput(printableImageFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbRegionProjectionResampler.cxx000066400000000000000000000103371301006202600317230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*! * * PURPOSE: * * Appliaction to project a geographic coordinated image region * using an Interpolator, a Regionextractor and an Iteratorregion. * */ // iostream is used for general output #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "otbStreamingResampleImageFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkExtractImageFilter.h" #include "itkResampleImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkTranslationTransform.h" #include "otbInverseSensorModel.h" #include "otbCompositeTransform.h" int otbRegionProjectionResampler(int argc, char* argv[]) { if (argc != 10) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::Image CharImageType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::InverseSensorModel ModelType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::StreamingResampleImageFilter ResamplerType; ImageType::IndexType start; ImageType::SizeType size; ImageType::SpacingType spacing; ImageType::PointType origin; ImageType::RegionType region; //Allocate pointer ModelType::Pointer model = ModelType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RescalerType::Pointer rescaler = RescalerType::New(); ResamplerType::Pointer resampler = ResamplerType::New(); // Set parameters ... reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); // Read meta data (ossimKeywordlist) reader->GenerateOutputInformation(); ImageType::ConstPointer inputImage = reader->GetOutput(); model->SetImageGeometry(reader->GetOutput()->GetImageKeywordlist()); if( model->IsValidSensorModel() == false ) { std::cout<<"Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!"<SetOutputSpacing(spacing); resampler->SetOutputOrigin(origin); resampler->SetOutputSize(region.GetSize()); resampler->SetOutputStartIndex(start); //Connect pipeline resampler->SetInput(reader->GetOutput()); resampler->SetTransform(model); resampler->SetInterpolator(interpolator); otbGenericMsgDebugMacro(<< "Sensor Model :" << model); writer->SetInput(resampler->GetOutput()); writer->SetNumberOfDivisionsTiledStreaming(10); otbGenericMsgDebugMacro(<< "Update writer ..."); writer->Update(); return EXIT_SUCCESS; } //Fin main() OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbShiftScaleImageAdaptor.cxx000066400000000000000000000042401301006202600310670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbShiftScaleImageAdaptor.h" int otbShiftScaleImageAdaptor(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double PixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ShiftScaleImageAdaptor FilterType; typedef itk::RescaleIntensityImageFilter RescalerType; FilterType::Pointer filter = FilterType::New(); RescalerType::Pointer rescaler = RescalerType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); filter->SetScale(3.); filter->SetShift(10.); reader->SetFileName(inputFilename); filter->SetImage(reader->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(filter); writer->SetFileName(outputFilename); writer->SetInput(rescaler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbShiftScaleImageAdaptorNew.cxx000066400000000000000000000020711301006202600315410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbShiftScaleImageAdaptor.h" int otbShiftScaleImageAdaptorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef otb::VectorImage ImageType; typedef otb::ShiftScaleImageAdaptor FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbShiftScaleVectorImageFilterNew.cxx000066400000000000000000000026571301006202600325710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbShiftScaleVectorImageFilter.h" #include "otbVectorImage.h" int otbShiftScaleVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef int OutputPixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ShiftScaleVectorImageFilter ShiftScaleVImageFilterType; // Instantiating object ShiftScaleVImageFilterType::Pointer filter = ShiftScaleVImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbSpectralAngleDistanceImageFilter.cxx000066400000000000000000000041651301006202600331020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSpectralAngleDistanceImageFilter.h" int otbSpectralAngleDistanceImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SpectralAngleDistanceImageFilter DistanceFilterType; // Instantiating object DistanceFilterType::Pointer filter = DistanceFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); InputImageType::PixelType refPixel; reader->UpdateOutputInformation(); refPixel.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); for (unsigned int i = 0; i < reader->GetOutput()->GetNumberOfComponentsPerPixel(); ++i) { refPixel[i] = atoi(argv[3 + i]); } filter->SetInput(reader->GetOutput()); filter->SetReferencePixel(refPixel); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbSpectralAngleDistanceImageFilterNew.cxx000066400000000000000000000025121301006202600335460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbSpectralAngleDistanceImageFilter.h" int otbSpectralAngleDistanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::SpectralAngleDistanceImageFilter DistanceFilterType; // Instantiating object DistanceFilterType::Pointer filter = DistanceFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbSqrtSpectralAngleImageFilter.cxx000066400000000000000000000045041301006202600322760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSqrtSpectralAngleFunctor.h" #include "itkUnaryFunctorImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbSqrtSpectralAngleImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::SqrtSpectralAngleFunctor FunctorType; typedef itk::UnaryFunctorImageFilter SqrtSpectralAngleImageFilterType; // Instantiating objects SqrtSpectralAngleImageFilterType::Pointer filter = SqrtSpectralAngleImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int blueValue(::atoi(argv[3])); unsigned int greenValue(::atoi(argv[4])); unsigned int redValue(::atoi(argv[5])); unsigned int nirValue(::atoi(argv[6])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); InputImageType::PixelType referencePixel; referencePixel.SetSize(4); referencePixel[0] = blueValue; referencePixel[1] = greenValue; referencePixel[2] = redValue; referencePixel[3] = nirValue; filter->GetFunctor().SetReferencePixel(referencePixel); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbStreamingInnerProductVectorImageFilter.cxx000066400000000000000000000034221301006202600342700ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingInnerProductVectorImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include int otbStreamingInnerProductVectorImageFilter(int itkNotUsed(argc), char* argv[]) { const char * inputFileName = argv[1]; const char * outfname = argv[2]; const bool centerdata = atoi(argv[3]); typedef double PixelType; const unsigned int Dimension = 2; // Typedef typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingInnerProductVectorImageFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Instantiation object FilterType::Pointer filter = FilterType::New(); filter->GetStreamer()->SetNumberOfLinesStrippedStreaming( 10 ); filter->SetCenterData(centerdata); filter->SetInput(reader->GetOutput()); filter->Update(); std::ofstream file; file.open(outfname); file.precision(10); file << std::fixed; file << "Inner Product: Dim [" << filter->GetInnerProduct().size() << "]:" << std::endl; file << filter->GetInnerProduct() << std::endl; file.close(); return EXIT_SUCCESS; } otbStreamingInnerProductVectorImageFilterNew.cxx000066400000000000000000000021311301006202600347360ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingInnerProductVectorImageFilter.h" #include "otbVectorImage.h" int otbStreamingInnerProductVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; // Typedef typedef otb::VectorImage ImageType; typedef otb::StreamingInnerProductVectorImageFilter FilterType; // Instantiation object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbStreamingResampleImageFilter.cxx000066400000000000000000000051751301006202600323270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingResampleImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkTranslationTransform.h" int otbStreamingResampleImageFilter(int itkNotUsed(argc), char * argv[]) { const char* inputFilename = argv[1]; const char* outputFilename = argv[2]; const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned char OutputPixelType; typedef double InterpolatorPrecisionType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::TranslationTransform TransformType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New(); TransformType::Pointer transform = TransformType::New(); // Input Image reader->SetFileName(inputFilename); // Resampler connected to input image resampler->SetInput(reader->GetOutput()); // Size of output resampler result StreamingResampleImageFilterType::SizeType size; size[0] = 600; size[1] = 600; resampler->SetOutputSize(size); // Transformation creation TransformType::OutputVectorType translation; translation[0] = 10; translation[1] = 20; transform->SetOffset(translation); // Resampler is updated with new transformation (default is identity) resampler->SetTransform(transform); // Result of resampler is written writer->SetInput(resampler->GetOutput()); writer->SetNumberOfDivisionsStrippedStreaming(1); writer->SetFileName(outputFilename); writer->Update(); return EXIT_SUCCESS; } otbStreamingResampleImageFilterCompareWithITK.cxx000066400000000000000000000102241301006202600347520ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingResampleImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "itkTranslationTransform.h" #include "otbStreamingTraits.h" #include "itkResampleImageFilter.h" int otbStreamingResampleImageFilterCompareWithITK(int itkNotUsed(argc), char * argv[]) { const char* inputFilename = argv[1]; unsigned int sizeXOutputImage = atoi(argv[2]); unsigned int sizeYOutputImage = atoi(argv[3]); const char* outputITKFilename = argv[4]; const char* outputOTBFilename = argv[5]; const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef double InterpolatorPrecisionType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; // typedef otb::VectorImage InputVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter StreamingWriterType; typedef itk::TranslationTransform TransformType; typedef itk::NearestNeighborInterpolateImageFunction NNInterpolatorType; typedef itk::ResampleImageFilter ITKResampleImageFilterType; typedef otb::StreamingResampleImageFilter OTBResampleImageFilterType; // Instantiating object ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writerITKFilter = WriterType::New(); StreamingWriterType::Pointer writerOTBFilter = StreamingWriterType::New(); ITKResampleImageFilterType::Pointer resamplerITK = ITKResampleImageFilterType::New(); OTBResampleImageFilterType::Pointer resamplerOTB = OTBResampleImageFilterType::New(); TransformType::Pointer transform = TransformType::New(); // Transformation creation TransformType::OutputVectorType translation; translation[0] = 30; translation[1] = 50; transform->SetOffset(translation); // Input Image reader->SetFileName(inputFilename); // Resamplers connected to input image resamplerITK->SetInput(reader->GetOutput()); resamplerOTB->SetInput(reader->GetOutput()); // Size of output resamplers result OTBResampleImageFilterType::SizeType size; size[0] = sizeXOutputImage; size[1] = sizeYOutputImage; resamplerITK->SetSize(size); resamplerOTB->SetOutputSize(size); // Set Interpolation NNInterpolatorType::Pointer interpolator = NNInterpolatorType::New(); // Resamplers are updated with new interpolation (default is linear interpolation) resamplerITK->SetInterpolator(interpolator); resamplerOTB->SetInterpolator(interpolator); // Resamplers are updated with new transformation (default is identity) resamplerITK->SetTransform(transform); resamplerOTB->SetTransform(transform); // Result of resamplers is written writerITKFilter->SetInput(resamplerITK->GetOutput()); writerITKFilter->SetFileName(outputITKFilename); writerITKFilter->Update(); writerOTBFilter->SetInput(resamplerOTB->GetOutput()); // writerOTBFilter->SetAutomaticTiledStreaming(); writerOTBFilter->SetFileName(outputOTBFilename); writerOTBFilter->SetNumberOfDivisionsStrippedStreaming(10); writerOTBFilter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbStreamingResampleImageFilterNew.cxx000066400000000000000000000026141301006202600327740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingResampleImageFilter.h" int otbStreamingResampleImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef double InterpolatorPrecisionType; typedef otb::StreamingResampleImageFilter StreamingResampleImageFilterType; // Instantiating object StreamingResampleImageFilterType::Pointer filter = StreamingResampleImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbStreamingShrinkImageFilter.cxx000066400000000000000000000033331301006202600320070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbStreamingShrinkImageFilter.h" int otbStreamingShrinkImageFilter(int itkNotUsed(argc), char * argv[]) { char * inputFilename = argv[1]; char * outputFilename = argv[2]; unsigned int shrinkFactor = atoi(argv[3]); const unsigned int Dimension = 2; typedef unsigned int PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::StreamingShrinkImageFilter ShrinkType; ReaderType::Pointer reader = ReaderType::New(); ShrinkType::Pointer shrink = ShrinkType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); shrink->SetShrinkFactor(shrinkFactor); shrink->SetInput(reader->GetOutput()); shrink->Update(); writer->SetInput(shrink->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbStreamingShrinkImageFilterNew.cxx000066400000000000000000000021201301006202600324520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbStreamingShrinkImageFilter.h" int otbStreamingShrinkImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::VectorImage ImageType; typedef otb::StreamingShrinkImageFilter ShrinkType; ShrinkType::Pointer filter = ShrinkType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbThresholdVectorImageFilter.cxx000066400000000000000000000041411301006202600320140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbThresholdVectorImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" /** Pixel typedefs */ typedef double InputPixelType; typedef unsigned int OutputPixelType; /** Image typedefs */ const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ThresholdVectorImageFilter FilterType; int otbThresholdVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { /** instantiating the filter */ FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbThresholdVectorImageFilterTest(int itkNotUsed(argc), char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; /** instantiating the filter */ FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName( argv[1] ); filter->SetInput( reader->GetOutput() ); filter->SetLower( 100 ); filter->SetUpper( 150 ); filter->SetOutsideValue(0); writer->SetInput( filter->GetOutput() ); writer->SetFileName( argv[2] ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbTileImageFilter.cxx000066400000000000000000000046201301006202600275740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbTileImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::TileImageFilter TileImageFilterType; typedef otb::TileImageFilter TileVectorImageFilterType; typedef otb::ImageFileReader VectorImageReaderType; typedef otb::ImageFileWriter VectorImageWriterType; int otbTileImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { TileImageFilterType::Pointer tileFilter = TileImageFilterType::New(); TileVectorImageFilterType::Pointer tileVectorFilter = TileVectorImageFilterType::New(); return EXIT_SUCCESS; } int otbTileImageFilter(int argc, char * argv[]) { TileVectorImageFilterType::SizeType layout; layout[0]=atoi(argv[1]); layout[1]=atoi(argv[2]); const char * outfname = argv[3]; unsigned int numberOfImages = layout[0] * layout[1]; std::vector readersVector; TileVectorImageFilterType::Pointer tileFilter = TileVectorImageFilterType::New(); tileFilter->SetLayout(layout); for(unsigned int i = 0; i (unsigned int)argc) { std::cerr<<"Not enough images to support layout!"<SetFileName(argv[i+4]); readersVector.push_back(reader); tileFilter->SetInput(i,reader->GetOutput()); } VectorImageWriterType::Pointer writer = VectorImageWriterType::New(); writer->SetFileName(outfname); writer->SetInput(tileFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbTwoNRIBandsImageToNComplexBandsImage.cxx000066400000000000000000000031121301006202600335020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbTwoNRIBandsImageToNComplexBandsImage.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbTwoNRIBandsImageToNComplexBandsImage(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage InputImageType; typedef std::complex OutputPixelType; typedef otb::VectorImage OutputImageType; typedef otb::TwoNRIBandsImageToNComplexBandsImage FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(0,reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbUnaryFunctorImageFilterNew.cxx000066400000000000000000000024201301006202600320040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbPhaseFunctor.h" #include "otbUnaryFunctorImageFilter.h" int otbUnaryFunctorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef InputImageType::InternalPixelType InternalPixelType; typedef otb::Function::PhaseFunctor FunctorType; typedef otb::UnaryFunctorImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbUnaryFunctorNeighborhoodImageFilter.cxx000066400000000000000000000045031301006202600336660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbUnaryFunctorNeighborhoodImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" namespace Functor { template class UnaryFunctorNeighborhoodImageFilterTest { public: UnaryFunctorNeighborhoodImageFilterTest() {} ~UnaryFunctorNeighborhoodImageFilterTest() {} inline TOutput operator ()(const TIter& it) { return (static_cast(it.GetCenterPixel())); } }; } int otbUnaryFunctorNeighborhoodImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; typedef unsigned char InputPixelType; const int Dimension = 2; typedef otb::Image ImageType; typedef ImageType::PixelType PixelType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::ConstNeighborhoodIterator IterType; typedef Functor::UnaryFunctorNeighborhoodImageFilterTest FunctorType; typedef otb::UnaryFunctorNeighborhoodImageFilter UnaryFunctorNeighborhoodImageFilterType; // Instantiating object UnaryFunctorNeighborhoodImageFilterType::Pointer object = UnaryFunctorNeighborhoodImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); object->SetInput(reader->GetOutput()); object->SetRadius(atoi(argv[3])); writer->SetInput(object->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbUnaryFunctorNeighborhoodImageFilterNew.cxx000066400000000000000000000035661301006202600342710ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbUnaryFunctorNeighborhoodImageFilter.h" #include "otbImage.h" namespace Functor { template class UnaryFunctorNeighborhoodImageFilterFunctorNewTest { public: UnaryFunctorNeighborhoodImageFilterFunctorNewTest() {} ~UnaryFunctorNeighborhoodImageFilterFunctorNewTest() {} inline TOutput operator ()(const TIter& it) { return (static_cast(it.GetCenterPixel())); } }; } int otbUnaryFunctorNeighborhoodImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; const int Dimension = 2; typedef otb::Image ImageType; typedef ImageType::PixelType PixelType; typedef itk::ConstNeighborhoodIterator IterType; typedef Functor::UnaryFunctorNeighborhoodImageFilterFunctorNewTest FunctorType; typedef otb::UnaryFunctorNeighborhoodImageFilter UnaryFunctorNeighborhoodImageFilterType; // Instantiating object UnaryFunctorNeighborhoodImageFilterType::Pointer object = UnaryFunctorNeighborhoodImageFilterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } otbUnaryFunctorNeighborhoodWithOffsetImageFilter.cxx000066400000000000000000000066511301006202600356200ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbUnaryFunctorNeighborhoodWithOffsetImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" namespace Functor { template class UnaryFunctorNeighborhoodWithOffseImageFilterTest { public: UnaryFunctorNeighborhoodWithOffseImageFilterTest() {} ~UnaryFunctorNeighborhoodWithOffseImageFilterTest() {} typedef TInput InputScalarType; typedef TOutput OutputScalarType; typedef itk::VariableLengthVector InputVectorType; typedef itk::VariableLengthVector OutputVectorType; typedef itk::Offset<> OffsetType; typedef itk::Neighborhood NeighborhoodType; typedef itk::Neighborhood NeighborhoodVectorType; void SetOffset(OffsetType off) { m_Offset = off; } OffsetType GetOffset() { return m_Offset; } inline OutputScalarType operator ()(const NeighborhoodType& neigh) { return (static_cast(neigh.GetCenterValue())); } inline OutputVectorType operator ()(const NeighborhoodVectorType& neigh) { return (static_cast(neigh.GetCenterValue())); } private: OffsetType m_Offset; }; } int otbUnaryFunctorNeighborhoodWithOffsetImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; typedef double InputPixelType; const int Dimension = 2; typedef otb::VectorImage ImageType; typedef ImageType::OffsetType OffsetType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef Functor::UnaryFunctorNeighborhoodWithOffseImageFilterTest FunctorType; typedef otb::UnaryFunctorNeighborhoodWithOffsetImageFilter UnaryFunctorNeighborhoodImageFilterType; // Instantiating object UnaryFunctorNeighborhoodImageFilterType::Pointer object = UnaryFunctorNeighborhoodImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); object->SetInput(reader->GetOutput()); object->SetRadius(atoi(argv[3])); OffsetType offset; offset[0] = atoi(argv[4]); offset[1] = atoi(argv[5]); //object->SetOffset(offset); writer->SetInput(object->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbUnaryFunctorNeighborhoodWithOffsetImageFilterNew.cxx000066400000000000000000000051421301006202600362640ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbUnaryFunctorNeighborhoodWithOffsetImageFilter.h" #include "otbVectorImage.h" #include "itkOffset.h" namespace Functor { template class UnaryFunctorNeighborhoodWithOffsetImageFilterFunctorNewTest { public: UnaryFunctorNeighborhoodWithOffsetImageFilterFunctorNewTest() {} ~UnaryFunctorNeighborhoodWithOffsetImageFilterFunctorNewTest() {} typedef TInput InputScalarType; typedef TOutput OutputScalarType; typedef itk::VariableLengthVector InputVectorType; typedef itk::VariableLengthVector OutputVectorType; typedef itk::Offset<> OffsetType; typedef itk::Neighborhood NeighborhoodType; typedef itk::Neighborhood NeighborhoodVectorType; void SetOffset(OffsetType off) { m_Offset = off; } OffsetType GetOffset() { return m_Offset; } inline OutputScalarType operator ()(const NeighborhoodType& neigh) { return (static_cast(neigh.GetCenterValue())); } inline OutputVectorType operator ()(const NeighborhoodVectorType& neigh) { return (static_cast(neigh.GetCenterValue())); } private: OffsetType m_Offset; }; } int otbUnaryFunctorNeighborhoodWithOffsetImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; const int Dimension = 2; typedef otb::VectorImage ImageType; typedef Functor::UnaryFunctorNeighborhoodWithOffsetImageFilterFunctorNewTest FunctorType; typedef otb::UnaryFunctorNeighborhoodWithOffsetImageFilter UnaryFunctorNeighborhoodWithOffsetImageFilterType; // Instantiating object UnaryFunctorNeighborhoodWithOffsetImageFilterType::Pointer filter = UnaryFunctorNeighborhoodWithOffsetImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbUnaryFunctorWithIndexImageFilter.cxx000066400000000000000000000043311301006202600331610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbUnaryFunctorWithIndexImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" namespace Functor { template class UnaryFunctorWithIndexImageFilterFunctorTest { public: UnaryFunctorWithIndexImageFilterFunctorTest() {} ~UnaryFunctorWithIndexImageFilterFunctorTest() {} typedef itk::Index<2> IndexType; inline TOutput operator ()(const TInput& inPix, IndexType itkNotUsed(index)) { return (static_cast(inPix)); } }; } int otbUnaryFunctorWithIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; typedef double InputPixelType; typedef otb::VectorImage ImageType; typedef ImageType::PixelType PixelType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef Functor::UnaryFunctorWithIndexImageFilterFunctorTest FunctorType; typedef otb::UnaryFunctorWithIndexImageFilter UnaryFunctorWithIndexImageFilterType; // Instantiating object UnaryFunctorWithIndexImageFilterType::Pointer object = UnaryFunctorWithIndexImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); object->SetInput(reader->GetOutput()); writer->SetInput(object->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbUnaryFunctorWithIndexImageFilterNew.cxx000066400000000000000000000034771301006202600336450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbUnaryFunctorWithIndexImageFilter.h" #include "otbImage.h" namespace Functor { template class UnaryFunctorWithIndexImageFilterFunctorNewTest { public: UnaryFunctorWithIndexImageFilterFunctorNewTest() {} ~UnaryFunctorWithIndexImageFilterFunctorNewTest() {} typedef itk::Index<2> IndexType; inline TOutput operator ()(const TInput& inPix, IndexType itkNotUsed(index)) { return (static_cast(inPix)); } }; } int otbUnaryFunctorWithIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef otb::Image ImageType; typedef ImageType::PixelType PixelType; typedef Functor::UnaryFunctorWithIndexImageFilterFunctorNewTest FunctorType; typedef otb::UnaryFunctorWithIndexImageFilter UnaryFunctorWithIndexImageFilterType; // Instantiating object UnaryFunctorWithIndexImageFilterType::Pointer filter = UnaryFunctorWithIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbUnaryImageFunctorWithVectorImageFilter.cxx000066400000000000000000000042251301006202600342420ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkCastImageFilter.h" int otbUnaryImageFunctorWithVectorImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef InputImageType::InternalPixelType InternalPixelType; typedef itk::Functor::Cast FunctorType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::UnaryImageFunctorWithVectorImageFilter UnaryImageFunctorWithVectorImageFilterType; // Instantiating object UnaryImageFunctorWithVectorImageFilterType::Pointer filter = UnaryImageFunctorWithVectorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbUnaryImageFunctorWithVectorImageFilterNew.cxx000066400000000000000000000027451301006202600347210ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbImage.h" #include "itkCosImageFilter.h" int otbUnaryImageFunctorWithVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef InputImageType::InternalPixelType InternalPixelType; typedef itk::Functor::Cos FunctorType; typedef otb::UnaryImageFunctorWithVectorImageFilter UnaryImageFunctorWithVectorImageFilterType; // Instantiating object UnaryImageFunctorWithVectorImageFilterType::Pointer filter = UnaryImageFunctorWithVectorImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbVectorImageTo3DScalarImageFilter.cxx000066400000000000000000000051451301006202600327270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkImageRegionIterator.h" #include "itkImageSliceConstIteratorWithIndex.h" #include "otbVectorImageTo3DScalarImageFilter.h" int otbVectorImageTo3DScalarImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int BiDimension = 2; const unsigned int TriDimension = 3; const char * infname = argv[1]; const char * outfname = argv[2]; typedef unsigned char PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::Image OutImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorImageTo3DScalarImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->Update(); // Build the first slice OutImageType::Pointer outImage = OutImageType::New(); outImage->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); outImage->Allocate(); outImage->FillBuffer(0); typedef itk::ImageRegionIterator OutIteratorType; typedef itk::ImageSliceConstIteratorWithIndex InIteratorType; OutIteratorType outIt(outImage, outImage->GetLargestPossibleRegion()); InIteratorType inIt(filter->GetOutput(), filter->GetOutput()->GetLargestPossibleRegion()); inIt.SetFirstDirection(0); inIt.SetSecondDirection(1); outIt.GoToBegin(); while (!outIt.IsAtEnd() && !inIt.IsAtEndOfSlice()) { outIt.Set(inIt.Get()); ++inIt; ++outIt; } WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(outImage); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbVectorImageTo3DScalarImageFilterNew.cxx000066400000000000000000000023321301006202600333740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbVectorImageTo3DScalarImageFilter.h" int otbVectorImageTo3DScalarImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int BiDimension = 2; const unsigned int TriDimension = 3; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::VectorImageTo3DScalarImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbVectorImageToAmplitudeImageFilter.cxx000066400000000000000000000033401301006202600332520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImageToAmplitudeImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbVectorImageToAmplitudeImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::VectorImageToAmplitudeImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); writer->SetFileName(outfname); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbVectorImageToAmplitudeImageFilterNew.cxx000066400000000000000000000023271301006202600337300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImageToAmplitudeImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" int otbVectorImageToAmplitudeImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::VectorImageToAmplitudeImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbVectorRescaleIntensityImageFilter.cxx000066400000000000000000000055321301006202600333520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorRescaleIntensityImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" int otbVectorRescaleIntensityImageFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned char min = atoi(argv[3]); const unsigned char max = atoi(argv[4]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned char OutputPixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::VectorRescaleIntensityImageFilter VectorRescaleIntensityImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelExtractROI SelectBandsFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); // Instantiating object VectorRescaleIntensityImageFilterType::Pointer filter = VectorRescaleIntensityImageFilterType::New(); filter->SetInput(reader->GetOutput()); OutputImageType::PixelType minPixel, maxPixel; minPixel.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); maxPixel.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); minPixel.Fill(min); maxPixel.Fill(max); filter->SetOutputMinimum(minPixel); filter->SetOutputMaximum(maxPixel); filter->SetClampThreshold(0.01); SelectBandsFilterType::Pointer selecter = SelectBandsFilterType::New(); selecter->SetInput(filter->GetOutput()); selecter->SetChannel(1); selecter->SetChannel(2); selecter->SetChannel(3); selecter->SetExtractionRegion(reader->GetOutput()->GetLargestPossibleRegion()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(selecter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageManipulation/test/otbVectorRescaleIntensityImageFilterNew.cxx000066400000000000000000000027341301006202600340250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbVectorImage.h" int otbVectorRescaleIntensityImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned char OutputPixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::VectorRescaleIntensityImageFilter VectorRescaleIntensityImageFilterType; // Instantiating object VectorRescaleIntensityImageFilterType::Pointer filter = VectorRescaleIntensityImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageNoise/000077500000000000000000000000001301006202600207715ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageNoise/CMakeLists.txt000066400000000000000000000000511301006202600235250ustar00rootroot00000000000000project(OTBImageNoise) otb_module_impl() OTB-release-5.8/Modules/Filtering/ImageNoise/include/000077500000000000000000000000001301006202600224145ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbFrostImageFilter.h000066400000000000000000000112321301006202600264770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFrostImageFilter_h #define otbFrostImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" namespace otb { /** \class FrostImageFilter * \brief Anti-speckle image filter * * Uses a negative exponential convolution kernel. * The kernel is defined as follows: * exp(-A*D), where * D is the distance from the current pixel to the center pixel * A = k*Ci*Ci with Ci = VAR[I]/ (E[I]*E[I]) * The final result is normalized by the sum of the kernel coefficients. * * (http://www.isprs.org/proceedings/XXXV/congress/comm2/papers/110.pdf) * * \ingroup OTBImageNoise */ template class ITK_EXPORT FrostImageFilter : public itk::ImageToImageFilter { public: /** Extract input and output images sizes. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** typedef to simplify variables definition and declaration. */ typedef TInputImage InputImageType; /** typedef to simplify variables definition and declaration. */ typedef TOutputImage OutputImageType; /** typedef for standard classes. */ typedef FrostImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** "object factory" management method. */ itkNewMacro(Self); /** Return the class name. */ itkTypeMacro(FrostImageFilter, ImageToImageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; /** "typedef" to define a real. */ typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** "typedef" to define an image size. */ typedef typename InputImageType::SizeType SizeType; /** Set the radius used to define the neighborhood for the filter calculation. */ itkSetMacro(Radius, SizeType); /** Get the radius used to define the neighborhood for the filter calculation. */ itkGetConstReferenceMacro(Radius, SizeType); /** Set the damping factor. */ itkSetMacro(Deramp, double); /** Get the damping factor. */ itkGetConstReferenceMacro(Deramp, double); /** To be allowed to use the pipeline method FrostImageFilter needs * an input processing area larger than the output one. * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; protected: FrostImageFilter(); ~FrostImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** FrostImageFilter can be implemented for a multithreaded filter treatment. * Thus, this implementation give the ThreadedGenerateData() method. * that is called for each process thread. Image datas are automatically allocated * through the parent class calling the ThreadedGenerateData() method. * ThreadedGenerateData() can only write the area of the image specified by the parameter "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: FrostImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius declaration */ SizeType m_Radius; /** Decrease factor declaration */ double m_Deramp; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFrostImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbFrostImageFilter.txx000066400000000000000000000147351301006202600271060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFrostImageFilter_txx #define otbFrostImageFilter_txx #include "otbFrostImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" namespace otb { /** * */ template FrostImageFilter::FrostImageFilter() { m_Radius.Fill(1); m_Deramp = 2; } template void FrostImageFilter::GenerateInputRequestedRegion() throw ( itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void FrostImageFilter::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { unsigned int i; itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ConstNeighborhoodIterator bit; typename itk::ConstNeighborhoodIterator::OffsetType off; itk::ImageRegionIterator it; // Allocate output typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(input, outputRegionForThread, m_Radius); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); InputRealType sum; InputRealType sum2; double Mean, Variance; double Alpha; double NormFilter; double FrostFilter; double CoefFilter; double dPixel; // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { bit = itk::ConstNeighborhoodIterator(m_Radius, input, *fit); unsigned int neighborhoodSize = bit.Size(); it = itk::ImageRegionIterator(output, *fit); bit.OverrideBoundaryCondition(&nbc); bit.GoToBegin(); it.GoToBegin(); while (!bit.IsAtEnd()) { sum = itk::NumericTraits::Zero; sum2 = itk::NumericTraits::Zero; for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum += dPixel; } Mean = sum / static_cast(neighborhoodSize); for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum2 += (dPixel-Mean) * (dPixel-Mean); } Variance = sum2 / double(neighborhoodSize-1); const double epsilon = 0.0000000001; if (vcl_abs(Mean) < epsilon) { dPixel = itk::NumericTraits::Zero; } else if (vcl_abs(Variance) < epsilon) { dPixel = Mean; } else { Alpha = m_Deramp * Variance / (Mean * Mean); NormFilter = 0.0; FrostFilter = 0.0; const int rad_x = m_Radius[0]; const int rad_y = m_Radius[1]; for (int x = -rad_x; x <= rad_x; ++x) { for (int y = -rad_y; y <= rad_y; ++y) { double Dist = vcl_sqrt(static_cast(x * x + y * y)); off[0] = x; off[1] = y; dPixel = static_cast(bit.GetPixel(off)); CoefFilter = vcl_exp(-Alpha * Dist); NormFilter += CoefFilter; FrostFilter += (CoefFilter * dPixel); } } dPixel = FrostFilter / NormFilter; } it.Set(static_cast(dPixel)); ++bit; ++it; progress.CompletedPixel(); } } } /** * Standard "PrintSelf" method */ template void FrostImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbGammaMAPImageFilter.h000066400000000000000000000077351301006202600267770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGammaMAPImageFilter_h #define otbGammaMAPImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" namespace otb { /** \class GammaMAPImageFilter * \brief Anti-speckle image filter * * This class implements Gamma MAP filter for despeckleing of SAR * images. * * (http://www.isprs.org/proceedings/XXXV/congress/comm2/papers/110.pdf) * * \ingroup OTBImageNoise */ template class ITK_EXPORT GammaMAPImageFilter : public itk::ImageToImageFilter { public: /** Extract input and output image dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** standard class typedefs */ typedef GammaMAPImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Object factory management */ itkNewMacro(Self); /** typemacro */ itkTypeMacro(GammaMAPImageFilter, ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType SizeType; /** Set the radius of the neighborhood used in this filter */ itkSetMacro(Radius, SizeType); /** Get the radius of the neighborhood used in this filter */ itkGetConstReferenceMacro(Radius, SizeType); /** Set the number of look used for computation */ itkSetMacro(NbLooks, double); /** Getthe number of look used for computation */ itkGetConstReferenceMacro(NbLooks, double); /** GammaMAPImageFilter needs a larger input requested region than * the output requested region. As such, GammaMAPImageFilter needs * to provide an implementation for GenerateInputRequestedRegion() * in order to inform the pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; protected: GammaMAPImageFilter(); ~GammaMAPImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** GammaMAPImageFilter can be multithreaded. */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: GammaMAPImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the filter */ SizeType m_Radius; /** Number of look of the filter */ double m_NbLooks; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGammaMAPImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbGammaMAPImageFilter.txx000066400000000000000000000146631301006202600273710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGammaMAPImageFilter_txx #define otbGammaMAPImageFilter_txx #include "otbGammaMAPImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" namespace otb { /** * */ template GammaMAPImageFilter::GammaMAPImageFilter() { m_Radius.Fill(1); SetNbLooks(1.0); } template void GammaMAPImageFilter::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void GammaMAPImageFilter::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { unsigned int i; itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ConstNeighborhoodIterator bit; itk::ImageRegionIterator it; typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(input, outputRegionForThread, m_Radius); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // InputRealType pixel; InputRealType sum; InputRealType sum2; double Ci, Ci2, Cu, Cu2, E_I, I, Var_I, dPixel, alpha, b, d, Cmax; //Compute the ratio using the number of looks Cu2 = 1.0/m_NbLooks; Cu = vcl_sqrt(Cu2); // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { bit = itk::ConstNeighborhoodIterator(m_Radius, input, *fit); const unsigned int neighborhoodSize = bit.Size(); it = itk::ImageRegionIterator(output, *fit); bit.OverrideBoundaryCondition(&nbc); bit.GoToBegin(); it.GoToBegin(); while (!bit.IsAtEnd()) { sum = itk::NumericTraits::Zero; sum2 = itk::NumericTraits::Zero; //Parcours du voisinage for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum += dPixel; } E_I = sum / static_cast(neighborhoodSize); for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum2 += (dPixel-E_I) * (dPixel-E_I); } Var_I = sum2 / static_cast(neighborhoodSize -1); I = static_cast(bit.GetCenterPixel()); Ci2 = Var_I / (E_I * E_I); Ci = vcl_sqrt(Ci2); const double epsilon = 0.0000000001; if (vcl_abs(E_I) < epsilon) { dPixel = itk::NumericTraits::Zero; } else if (vcl_abs(Var_I) < epsilon) { dPixel = E_I; } else if (Ci2 < Cu2) { dPixel = E_I; } else { Cmax = vcl_sqrt(2.0) * Cu; if (Ci < Cmax) { alpha = (1 + Cu2) / (Ci2 - Cu2); b = alpha - m_NbLooks - 1; d = E_I * E_I * b * b + 4 * alpha * m_NbLooks * E_I * I; dPixel = (b * E_I + vcl_sqrt(d)) / (2 * alpha); } else dPixel = I; } // set the weighted value it.Set(static_cast(dPixel)); ++bit; ++it; progress.CompletedPixel(); } } } /** * Standard "PrintSelf" method */ template void GammaMAPImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbKuanImageFilter.h000066400000000000000000000076441301006202600263140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKuanImageFilter_h #define otbKuanImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" namespace otb { /** \class KuanImageFilter * \brief Anti-speckle image filter * * This class implements Kuan filter for despeckleing of SAR * images. * * (http://www.isprs.org/proceedings/XXXV/congress/comm2/papers/110.pdf) * * \ingroup OTBImageNoise */ template class ITK_EXPORT KuanImageFilter : public itk::ImageToImageFilter { public: /** Extract input and output image dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** standard class typedefs */ typedef KuanImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Object factory management */ itkNewMacro(Self); /** typemacro */ itkTypeMacro(KuanImageFilter, ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType SizeType; /** Set the radius of the neighborhood used in this filter */ itkSetMacro(Radius, SizeType); /** Get the radius of the neighborhood used in this filter */ itkGetConstReferenceMacro(Radius, SizeType); /** Set the number of look used for computation */ itkSetMacro(NbLooks, double); /** Getthe number of look used for computation */ itkGetConstReferenceMacro(NbLooks, double); /** KuanImageFilter needs a larger input requested region than * the output requested region. As such, KuanImageFilter needs * to provide an implementation for GenerateInputRequestedRegion() * in order to inform the pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; protected: KuanImageFilter(); ~KuanImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** KuanImageFilter can be multithreaded. */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: KuanImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the filter */ SizeType m_Radius; /** Number of look of the filter */ double m_NbLooks; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKuanImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbKuanImageFilter.txx000066400000000000000000000140601301006202600266760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKuanImageFilter_txx #define otbKuanImageFilter_txx #include "otbKuanImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" namespace otb { /** * */ template KuanImageFilter::KuanImageFilter() { m_Radius.Fill(1); SetNbLooks(1.0); } template void KuanImageFilter::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void KuanImageFilter::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { unsigned int i; itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ConstNeighborhoodIterator bit; itk::ImageRegionIterator it; typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(input, outputRegionForThread, m_Radius); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // InputRealType pixel; InputRealType sum; InputRealType sum2; double Ci2, Cu2, w, E_I, I, Var_I, dPixel; //Compute the ratio using the number of looks Cu2 = 1.0/m_NbLooks; // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { bit = itk::ConstNeighborhoodIterator(m_Radius, input, *fit); const unsigned int neighborhoodSize = bit.Size(); it = itk::ImageRegionIterator(output, *fit); bit.OverrideBoundaryCondition(&nbc); bit.GoToBegin(); it.GoToBegin(); while (!bit.IsAtEnd()) { sum = itk::NumericTraits::Zero; sum2 = itk::NumericTraits::Zero; //Parcours du voisinage for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum += dPixel; } E_I = sum / static_cast(neighborhoodSize); for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum2 += (dPixel-E_I) * (dPixel-E_I); } Var_I = sum2 / static_cast(neighborhoodSize -1); I = static_cast(bit.GetCenterPixel()); Ci2 = Var_I / (E_I * E_I); const double epsilon = 0.0000000001; if (vcl_abs(E_I) < epsilon) { dPixel = itk::NumericTraits::Zero; } else if (vcl_abs(Var_I) < epsilon) { dPixel = E_I; } else if (Ci2 < Cu2) { dPixel = E_I; } else { w = (1 - Cu2 / Ci2) / (1+Cu2); dPixel = I*w + E_I*(1-w); } // set the weighted value it.Set(static_cast(dPixel)); ++bit; ++it; progress.CompletedPixel(); } } } /** * Standard "PrintSelf" method */ template void KuanImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbLeeImageFilter.h000066400000000000000000000107201301006202600261100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLeeImageFilter_h #define otbLeeImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" namespace otb { /** \class LeeImageFilter * \brief Anti-speckle image filter * * This class implements Lee's filter for despeckleing of SAR * images. The estimated reflectivity R is computed as follows: * * R=I*W+E[I]*(1-W), where * W=1-Cu*Cu/(Ci*Ci) * Cu = 1/sqrt(nb of look) * Ci = sqrt(VAR[I])/E[I] * * (http://www.isprs.org/proceedings/XXXV/congress/comm2/papers/110.pdf) * * * * \ingroup OTBImageNoise */ template class ITK_EXPORT LeeImageFilter : public itk::ImageToImageFilter { public: /** Extract input and output image dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** standard class typedefs */ typedef LeeImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Object factory management */ itkNewMacro(Self); /** typemacro */ itkTypeMacro(LeeImageFilter, ImageToImageFilter); typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType SizeType; /** Set the radius of the neighborhood used in this filter */ itkSetMacro(Radius, SizeType); /** Get the radius of the neighborhood used in this filter */ itkGetConstReferenceMacro(Radius, SizeType); /** Set the number of look used for computation */ itkSetMacro(NbLooks, double); /** Getthe number of look used for computation */ itkGetConstReferenceMacro(NbLooks, double); /** LeeImageFilter needs a larger input requested region than * the output requested region. As such, LeeImageFilter needs * to provide an implementation for GenerateInputRequestedRegion() * in order to inform the pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; protected: LeeImageFilter(); ~LeeImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** LeeImageFilter can be multithreaded. * As such, it provides a definition of ThreadedGenerateData() * * LEE filter: *\f$ R = E[I] + b(I-E[I])\f$ with \f$ b = C^2r / ( C^2r + C^2v )\f$ * \f$ Cv = 1 / \sqrt(L) \f$ with L the number of look. * \f$ Cr = \sqrt(Var(I)) / E[I] avec Var(I) = E[I^2] - E[I]^2 \f$ * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: LeeImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the filter */ SizeType m_Radius; /** Number of look of the filter */ double m_NbLooks; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLeeImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbLeeImageFilter.txx000066400000000000000000000140361301006202600265100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLeeImageFilter_txx #define otbLeeImageFilter_txx #include "otbLeeImageFilter.h" #include "itkDataObject.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" namespace otb { /** * */ template LeeImageFilter::LeeImageFilter() { m_Radius.Fill(1); SetNbLooks(1.0); } template void LeeImageFilter::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void LeeImageFilter::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { unsigned int i; itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ConstNeighborhoodIterator bit; itk::ImageRegionIterator it; typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(input, outputRegionForThread, m_Radius); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // InputRealType pixel; InputRealType sum; InputRealType sum2; double Ci2, Cu2, w, E_I, I, Var_I, dPixel; //Compute the ratio using the number of looks Cu2 = 1.0/m_NbLooks; // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { bit = itk::ConstNeighborhoodIterator(m_Radius, input, *fit); const unsigned int neighborhoodSize = bit.Size(); it = itk::ImageRegionIterator(output, *fit); bit.OverrideBoundaryCondition(&nbc); bit.GoToBegin(); it.GoToBegin(); while (!bit.IsAtEnd()) { sum = itk::NumericTraits::Zero; sum2 = itk::NumericTraits::Zero; //Parcours du voisinage for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum += dPixel; } E_I = sum / static_cast(neighborhoodSize); for (i = 0; i < neighborhoodSize; ++i) { dPixel = static_cast(bit.GetPixel(i)); sum2 += (dPixel-E_I) * (dPixel-E_I); } Var_I = sum2 / static_cast(neighborhoodSize -1); I = static_cast(bit.GetCenterPixel()); Ci2 = Var_I / (E_I * E_I); const double epsilon = 0.0000000001; if (vcl_abs(E_I) < epsilon) { dPixel = itk::NumericTraits::Zero; } else if (vcl_abs(Var_I) < epsilon) { dPixel = E_I; } else if (Ci2 < Cu2) { dPixel = E_I; } else { w = 1 - Cu2 / Ci2; dPixel = I*w + E_I*(1-w); } // set the weighted value it.Set(static_cast(dPixel)); ++bit; ++it; progress.CompletedPixel(); } } } /** * Standard "PrintSelf" method */ template void LeeImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/ImageNoise/include/otbNoiseEstimatorVectorImageFilter.h000066400000000000000000000000731301006202600315330ustar00rootroot00000000000000#include OTB-release-5.8/Modules/Filtering/ImageNoise/otb-module.cmake000066400000000000000000000004011301006202600240350ustar00rootroot00000000000000set(DOCUMENTATION "This module is related to noise estimation and reduction.") otb_module(OTBImageNoise DEPENDS OTBImageManipulation OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/ImageNoise/test/000077500000000000000000000000001301006202600217505ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/ImageNoise/test/CMakeLists.txt000066400000000000000000000036701301006202600245160ustar00rootroot00000000000000otb_module_test() set(OTBImageNoiseTests otbImageNoiseTestDriver.cxx otbFrostFilter.cxx otbLeeFilter.cxx otbGammaMAPFilter.cxx otbKuanFilter.cxx otbFrostFilterNew.cxx ) add_executable(otbImageNoiseTestDriver ${OTBImageNoiseTests}) target_link_libraries(otbImageNoiseTestDriver ${OTBImageNoise-Test_LIBRARIES}) otb_module_target_label(otbImageNoiseTestDriver) # Tests Declaration otb_add_test(NAME bfTvFrostFilter COMMAND otbImageNoiseTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreFrost_poupees_05_05_01.tif ${TEMP}/bfFiltreFrost_poupees_05_05_01.tif otbFrostFilter ${INPUTDATA}/GomaAvant.tif #poupees.hdr ${TEMP}/bfFiltreFrost_poupees_05_05_01.tif 05 05 0.1) otb_add_test(NAME bfTvFiltreLee1CanalPoupees COMMAND otbImageNoiseTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreLee_05_05_04.tif ${TEMP}/bfFiltreLee_05_05_04.tif otbLeeFilter ${INPUTDATA}/GomaAvant.tif #poupees_1canal.c1.hdr ${TEMP}/bfFiltreLee_05_05_04.tif 05 05 4.0) otb_add_test(NAME bfTvFiltreLee COMMAND otbImageNoiseTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreLee_05_05_12.tif ${TEMP}/bfFiltreLee_05_05_12.tif otbLeeFilter ${INPUTDATA}/GomaAvant.tif #poupees.hdr ${TEMP}/bfFiltreLee_05_05_12.tif 05 05 12.0) otb_add_test(NAME bfTvFiltreGammaMAP COMMAND otbImageNoiseTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreGammaMAP_05_05_12.tif ${TEMP}/bfFiltreGammaMAP_05_05_12.tif otbGammaMAPFilter ${INPUTDATA}/GomaAvant.tif #poupees.hdr ${TEMP}/bfFiltreGammaMAP_05_05_12.tif 05 05 12.0) otb_add_test(NAME bfTvFiltreKuan COMMAND otbImageNoiseTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfFiltreKuan_05_05_12.tif ${TEMP}/bfFiltreKuan_05_05_12.tif otbKuanFilter ${INPUTDATA}/GomaAvant.tif #poupees.hdr ${TEMP}/bfFiltreKuan_05_05_12.tif 05 05 12.0) otb_add_test(NAME bfTuFrostFilterNew COMMAND otbImageNoiseTestDriver otbFrostFilterNew) OTB-release-5.8/Modules/Filtering/ImageNoise/test/otbFrostFilter.cxx000066400000000000000000000036241301006202600254510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbFrostImageFilter.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbFrostFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); unsigned int RadiusY((unsigned int) ::atoi(argv[4])); double Deramp ((double) ::atof(argv[5])); typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::FrostImageFilter FilterType; FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusY; FilterType::Pointer filterFrost = FilterType::New(); filterFrost->SetRadius(Radius); filterFrost->SetDeramp(Deramp); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filterFrost->SetInput(reader->GetOutput()); writer->SetInput(filterFrost->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageNoise/test/otbFrostFilterNew.cxx000066400000000000000000000022101301006202600261110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbFrostImageFilter.h" #include "otbImage.h" int otbFrostFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::FrostImageFilter FilterType; FilterType::Pointer frost = FilterType::New(); std::cout << frost << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageNoise/test/otbGammaMAPFilter.cxx000066400000000000000000000037241301006202600257350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbGammaMAPImageFilter.h" int otbGammaMAPFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); unsigned int RadiusY((unsigned int) ::atoi(argv[4])); double NbLooks((double) ::atof(argv[5])); typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::GammaMAPImageFilter FilterType; FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusY; FilterType::Pointer filterLee = FilterType::New(); filterLee->SetRadius(Radius); // OTB-FA-00018-CS filterLee->SetNbLooks(NbLooks); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filterLee->SetInput(reader->GetOutput()); writer->SetInput(filterLee->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageNoise/test/otbImageNoiseTestDriver.cxx000066400000000000000000000003321301006202600272330ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbFrostFilter); REGISTER_TEST(otbLeeFilter); REGISTER_TEST(otbGammaMAPFilter); REGISTER_TEST(otbKuanFilter); REGISTER_TEST(otbFrostFilterNew); } OTB-release-5.8/Modules/Filtering/ImageNoise/test/otbKuanFilter.cxx000066400000000000000000000037101301006202600252460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbKuanImageFilter.h" int otbKuanFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); unsigned int RadiusY((unsigned int) ::atoi(argv[4])); double NbLooks((double) ::atof(argv[5])); typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::KuanImageFilter FilterType; FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusY; FilterType::Pointer filterLee = FilterType::New(); filterLee->SetRadius(Radius); // OTB-FA-00018-CS filterLee->SetNbLooks(NbLooks); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filterLee->SetInput(reader->GetOutput()); writer->SetInput(filterLee->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/ImageNoise/test/otbLeeFilter.cxx000066400000000000000000000037051301006202600250610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbLeeImageFilter.h" int otbLeeFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int RadiusX((unsigned int) ::atoi(argv[3])); unsigned int RadiusY((unsigned int) ::atoi(argv[4])); double NbLooks((double) ::atof(argv[5])); typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::LeeImageFilter FilterType; FilterType::SizeType Radius; Radius[0] = RadiusX; Radius[1] = RadiusY; FilterType::Pointer filterLee = FilterType::New(); filterLee->SetRadius(Radius); // OTB-FA-00018-CS filterLee->SetNbLooks(NbLooks); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filterLee->SetInput(reader->GetOutput()); writer->SetInput(filterLee->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParser/000077500000000000000000000000001301006202600210175ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParser/CMakeLists.txt000066400000000000000000000001251301006202600235550ustar00rootroot00000000000000project(OTBMathParser) set(OTBMathParser_LIBRARIES OTBMathParser) otb_module_impl() OTB-release-5.8/Modules/Filtering/MathParser/include/000077500000000000000000000000001301006202600224425ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParser/include/otbBandMathImageFilter.h000066400000000000000000000135461301006202600271200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBandMathImageFilter_h #define otbBandMathImageFilter_h #include "itkInPlaceImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkArray.h" #include "otbParser.h" namespace otb { /** \class BandMathImageFilter * \brief Performs a mathematical operation on the input images * according to the formula specified by the user. * * This filter is based on the mathematical parser library muParser. * The built in functions and operators list is available at: * http://muparser.sourceforge.net/mup_features.html#idDef2 * * OTB additional functions: * ndvi(r, niri) * * OTB additional constants: * e - log2e - log10e - ln2 - ln10 - pi - euler * * In order to use this filter, at least one input image is to be * set. An associated variable name can be specified or not by using * the corresponding SetNthInput method. For the nth input image, if * no associated variable name has been spefified, a default variable * name is given by concatenating the letter "b" (for band) and the * corresponding input index. * Next step is to set the expression according to the variable * names. For example, in the default case with three input images the * following expression is valid : * "ndvi(b1, b2)*b3" * * As an additional functionality, the filter also granted access to * indexes information under special virtual bands named idxX, idxY * for the images indexes and idxPhyX, idxPhyY for the physical * indexes. * It allows the user to perform, for example a spatial processing * aiming to suppress a determined area : * "if(sqrt((idxPhyX-105.3)*(idxPhyX-105.3)+ * (idxPhyY-207.1)*(idxPhyY-207.1))>100, b1, 0)" * This expression replace the physical zone around the point of * physical index (105.3; 207.1) by a black area * This functionality assumes that all the band involved have the same * spacing and origin. * * * \sa Parser * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBMathParser */ template< class TImage > class ITK_EXPORT BandMathImageFilter : public itk::InPlaceImageFilter< TImage > { public: /** Standard class typedefs. */ typedef BandMathImageFilter< TImage > Self; typedef itk::InPlaceImageFilter< TImage > Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer< const Self > ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BandMathImageFilter, InPlaceImageFilter); /** Some convenient typedefs. */ typedef TImage ImageType; typedef typename ImageType::ConstPointer ImagePointer; typedef typename ImageType::RegionType ImageRegionType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::PointType OrigineType; typedef typename ImageType::SpacingType SpacingType; typedef Parser ParserType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Set the nth filter input with or without a specified associated variable name */ using Superclass::SetNthInput; void SetNthInput( DataObjectPointerArraySizeType idx, const ImageType * image); void SetNthInput( DataObjectPointerArraySizeType idx, const ImageType * image, const std::string& varName); /** Change the nth filter input associated variable name */ void SetNthInputName(DataObjectPointerArraySizeType idx, const std::string& expression); /** Set the expression to be parsed */ void SetExpression(const std::string& expression); /** Return the expression to be parsed */ std::string GetExpression() const; /** Return the nth filter input associated variable name */ std::string GetNthInputName(DataObjectPointerArraySizeType idx) const; /** Return a pointer on the nth filter input */ ImageType * GetNthInput(DataObjectPointerArraySizeType idx); protected : BandMathImageFilter(); ~BandMathImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const ImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; private : BandMathImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented std::string m_Expression; std::vector m_VParser; std::vector< std::vector > m_AImage; std::vector< std::string > m_VVarName; unsigned int m_NbVar; SpacingType m_Spacing; OrigineType m_Origin; long m_UnderflowCount; long m_OverflowCount; itk::Array m_ThreadUnderflow; itk::Array m_ThreadOverflow; }; }//end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBandMathImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbBandMathImageFilter.txx000066400000000000000000000235231301006202600275100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBandMathImageFilter_txx #define otbBandMathImageFilter_txx #include "otbBandMathImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "otbMacro.h" #include #include namespace otb { /** Constructor */ template BandMathImageFilter ::BandMathImageFilter() { //This number will be incremented each time an image //is added over the one minimumrequired this->SetNumberOfRequiredInputs( 1 ); this->InPlaceOff(); m_UnderflowCount = 0; m_OverflowCount = 0; m_ThreadUnderflow.SetSize(1); m_ThreadOverflow.SetSize(1); } /** Destructor */ template BandMathImageFilter ::~BandMathImageFilter() { } template void BandMathImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Expression: " << m_Expression << std::endl; os << indent << "Computed values follow:" << std::endl; os << indent << "UnderflowCount: " << m_UnderflowCount << std::endl; os << indent << "OverflowCount: " << m_OverflowCount << std::endl; os << indent << "itk::NumericTraits::NonpositiveMin() : " << itk::NumericTraits::NonpositiveMin() << std::endl; os << indent << "itk::NumericTraits::max() : " << itk::NumericTraits::max() << std::endl; } template void BandMathImageFilter ::SetNthInput(DataObjectPointerArraySizeType idx, const ImageType * image) { this->SetInput(idx, const_cast( image )); DataObjectPointerArraySizeType nbInput = this->GetNumberOfInputs(); m_VVarName.resize(nbInput+4); std::ostringstream varName; varName << "b" << nbInput; m_VVarName[idx] = varName.str(); m_VVarName[idx+1] = "idxX"; m_VVarName[idx+2] = "idxY"; m_VVarName[idx+3] = "idxPhyX"; m_VVarName[idx+4] = "idxPhyY"; } template void BandMathImageFilter ::SetNthInput(DataObjectPointerArraySizeType idx, const ImageType * image, const std::string& varName) { this->SetInput(idx, const_cast( image )); m_VVarName.resize(this->GetNumberOfInputs()+4); m_VVarName[idx] = varName; m_VVarName[idx+1] = "idxX"; m_VVarName[idx+2] = "idxY"; m_VVarName[idx+3] = "idxPhyX"; m_VVarName[idx+4] = "idxPhyY"; } template void BandMathImageFilter ::SetNthInputName(DataObjectPointerArraySizeType idx, const std::string& varName) { m_VVarName[idx] = varName; } template TImage * BandMathImageFilter ::GetNthInput(DataObjectPointerArraySizeType idx) { return const_cast(this->GetInput(idx)); } template< typename TImage > void BandMathImageFilter ::SetExpression(const std::string& expression) { if (m_Expression != expression) m_Expression = expression; this->Modified(); } template< typename TImage > std::string BandMathImageFilter ::GetExpression() const { return m_Expression; } template< typename TImage > std::string BandMathImageFilter ::GetNthInputName(DataObjectPointerArraySizeType idx) const { return m_VVarName.at(idx); } template< typename TImage > void BandMathImageFilter ::BeforeThreadedGenerateData() { typename std::vector::iterator itParser; typename std::vector< std::vector >::iterator itVImage; unsigned int nbThreads = this->GetNumberOfThreads(); unsigned int nbInputImages = this->GetNumberOfInputs(); unsigned int nbAccessIndex = 4; //to give access to image and physical index unsigned int i, j; unsigned int inputSize[2]; std::vector< std::string > tmpIdxVarNames; tmpIdxVarNames.resize(nbAccessIndex); tmpIdxVarNames.resize(nbAccessIndex); tmpIdxVarNames[0] = "idxX"; tmpIdxVarNames[1] = "idxY"; tmpIdxVarNames[2] = "idxPhyX"; tmpIdxVarNames[3] = "idxPhyY"; // Check if input image dimensions matches inputSize[0] = this->GetNthInput(0)->GetLargestPossibleRegion().GetSize(0); inputSize[1] = this->GetNthInput(0)->GetLargestPossibleRegion().GetSize(1); for(unsigned int p = 1; p < nbInputImages; p++) { if((inputSize[0] != this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(0)) || (inputSize[1] != this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(1))) { itkExceptionMacro(<< "Input images must have the same dimensions." << std::endl << "band #1 is [" << inputSize[0] << ";" << inputSize[1] << "]" << std::endl << "band #" << p+1 << " is [" << this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(0) << ";" << this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(1) << "]"); } } // Store images specs m_Spacing = this->GetNthInput(0)->GetSpacing(); m_Origin = this->GetNthInput(0)->GetOrigin(); // Allocate and initialize the thread temporaries m_ThreadUnderflow.SetSize(nbThreads); m_ThreadUnderflow.Fill(0); m_ThreadOverflow.SetSize(nbThreads); m_ThreadOverflow.Fill(0); m_VParser.resize(nbThreads); m_AImage.resize(nbThreads); m_NbVar = nbInputImages+nbAccessIndex; m_VVarName.resize(m_NbVar); for(itParser = m_VParser.begin(); itParser < m_VParser.end(); itParser++) { *itParser = ParserType::New(); } for(i = 0; i < nbThreads; ++i) { m_AImage[i].resize(m_NbVar); m_VParser[i]->SetExpr(m_Expression); for(j=0; j < nbInputImages; ++j) { m_VParser[i]->DefineVar(m_VVarName[j], &(m_AImage[i][j])); } for(j=nbInputImages; j < nbInputImages+nbAccessIndex; ++j) { m_VVarName[j] = tmpIdxVarNames[j-nbInputImages]; m_VParser[i]->DefineVar(m_VVarName[j], &(m_AImage[i][j])); } } } template< typename TImage > void BandMathImageFilter ::AfterThreadedGenerateData() { unsigned int nbThreads = this->GetNumberOfThreads(); unsigned int i; m_UnderflowCount = 0; m_OverflowCount = 0; // Accumulate counts for each thread for(i = 0; i < nbThreads; ++i) { m_UnderflowCount += m_ThreadUnderflow[i]; m_OverflowCount += m_ThreadOverflow[i]; } if((m_UnderflowCount != 0) || (m_OverflowCount!=0)) otbWarningMacro(<< std::endl << "The Following Parsed Expression : " << this->GetExpression() << std::endl << "Generated " << m_UnderflowCount << " Underflow(s) " << "And " << m_OverflowCount << " Overflow(s) " << std::endl << "The Parsed Expression, The Inputs And The Output " << "Type May Be Incompatible !"); } template< typename TImage > void BandMathImageFilter ::ThreadedGenerateData(const ImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { double value; unsigned int j; unsigned int nbInputImages = this->GetNumberOfInputs(); typedef itk::ImageRegionConstIterator ImageRegionConstIteratorType; assert(nbInputImages); std::vector< ImageRegionConstIteratorType > Vit(nbInputImages); for(j=0; j < nbInputImages; ++j) { Vit[j] = ImageRegionConstIteratorType (this->GetNthInput(j), outputRegionForThread); } itk::ImageRegionIterator ot (this->GetOutput(), outputRegionForThread); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); std::vector & threadImage = m_AImage[threadId]; ParserType::Pointer const& threadParser = m_VParser[threadId]; long & threadUnderflow = m_ThreadUnderflow[threadId]; long & threadOverflow = m_ThreadOverflow[threadId]; ImageRegionConstIteratorType & firstImageRegion = Vit.front(); // alias for better perfs while(!firstImageRegion.IsAtEnd()) { for(j=0; j < nbInputImages; ++j) { threadImage[j] = static_cast(Vit[j].Get()); } // Image Indexes for(j=0; j < 2; ++j) { threadImage[nbInputImages+j] = static_cast(firstImageRegion.GetIndex()[j]); } for(j=0; j < 2; ++j) { threadImage[nbInputImages+2+j] = static_cast(m_Origin[j]) + static_cast(firstImageRegion.GetIndex()[j]) * static_cast(m_Spacing[j]); } try { value = threadParser->Eval(); } catch(itk::ExceptionObject& err) { itkExceptionMacro(<< err); } // Case value is equal to -inf or inferior to the minimum value // allowed by the pixelType cast if (value < double(itk::NumericTraits::NonpositiveMin())) { ot.Set(itk::NumericTraits::NonpositiveMin()); threadUnderflow++; } // Case value is equal to inf or superior to the maximum value // allowed by the pixelType cast else if (value > double(itk::NumericTraits::max())) { ot.Set(itk::NumericTraits::max()); threadOverflow++; } else { ot.Set(static_cast(value)); } for(j=0; j < nbInputImages; ++j) { ++Vit[j]; } ++ot; progress.CompletedPixel(); } } }// end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbMaskMuParserFilter.h000066400000000000000000000106611301006202600270440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaskMuParserFilter_h #define otbMaskMuParserFilter_h #include "itkProgressReporter.h" #include #include #include #include "itkArray.h" #include "otbMaskMuParserFunctor.h" #include "itkImageToImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" namespace otb { /** \class MaskMuParserImageFilter * \brief Performs a mathematical operation on the input images * according to the formula specified by the user. values different from 0 are set to 1 * * This filter is based on the mathematical parser library muParser. * The built in functions and operators list is available at: * http://muparser.sourceforge.net/mup_features.html#idDef2 * * OTB additional functions: * ndvi(r, niri) * * OTB additional constants: * e - log2e - log10e - ln2 - ln10 - pi - euler * * an input vector image and a Mu Parser compliant fomula is needed * each band of vector image is name bX, where X is the band index * for example b2 correspond to the second band of the input image. * Next step is to set the expression according to the variable * names. For example, in the default case with three input images the * following expression is valid : * "b1<140" * * * \sa Parser * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBMathParser */ template > class ITK_EXPORT MaskMuParserFilter: public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef MaskMuParserFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self) ; /** Run-time type information (and related methods). */ itkTypeMacro(MaskMuParserFilter, itk::ImageToImageFilter) ; /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef TOutputImage OutputImageType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef TFunction FunctorType; typedef typename FunctorType::Pointer FunctorPointer; typedef MaskMuParserFilter MaskMuParserFilterType; /** Set the expression to be parsed */ void SetExpression(const std::string expression); /**Check expression */ bool CheckExpression(); /** Return the expression to be parsed */ std::string GetExpression() const; std::vector GetVar(); Parser::FunctionMapType GetFunList(); protected: MaskMuParserFilter(); ~MaskMuParserFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType &outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; private: MaskMuParserFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented std::vector m_VFunctor; std::string m_Expression; long m_UnderflowCount; long m_OverflowCount; itk::Array m_ThreadUnderflow; itk::Array m_ThreadOverflow; }; }//end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMaskMuParserFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbMaskMuParserFilter.txx000066400000000000000000000141431301006202600274370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaskMuParserFilter_txx #define otbMaskMuParserFilter_txx #include "otbMaskMuParserFilter.h" #include #include #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" namespace otb { // constructor template MaskMuParserFilter::MaskMuParserFilter() { m_UnderflowCount = 0; m_OverflowCount = 0; m_ThreadUnderflow.SetSize(1); m_ThreadOverflow.SetSize(1); m_Expression=""; } // Destructor template MaskMuParserFilter::~MaskMuParserFilter() { } template void MaskMuParserFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Expression: " << m_Expression << std::endl; } template void MaskMuParserFilter::SetExpression(const std::string expression) { if (m_Expression != expression) m_Expression = expression; this->Modified(); } template std::string MaskMuParserFilter::GetExpression() const { return m_Expression; } template std::vector MaskMuParserFilter::GetVar() { std::vector varList; FunctorPointer tempFunctor = FunctorType::New(); tempFunctor->SetExpression(m_Expression); FunctorType& functor = *tempFunctor; try { functor(this->GetInput()->GetPixel(this->GetInput()->GetBufferedRegion().GetIndex())); } catch (itk::ExceptionObject& err) { itkDebugMacro(<< err); } const std::map& varMap = functor.GetVar(); std::map::const_iterator it; for (it = varMap.begin(); it != varMap.end(); ++it) { varList.push_back( it->first ); } return varList; } template Parser::FunctionMapType MaskMuParserFilter::GetFunList() { FunctorPointer tempFunctor = FunctorType::New(); tempFunctor->SetExpression(m_Expression); FunctorType& functor = *tempFunctor; try { functor(this->GetInput()->GetPixel(this->GetInput()->GetBufferedRegion().GetIndex())); } catch (itk::ExceptionObject& err) { itkDebugMacro(<< err); } return functor.GetFunList(); } template bool MaskMuParserFilter::CheckExpression() { FunctorPointer checkFunctor = FunctorType::New(); checkFunctor->SetExpression(m_Expression); FunctorType& functor = *checkFunctor; try { functor(this->GetInput()->GetPixel(this->GetInput()->GetBufferedRegion().GetIndex())); } catch (itk::ExceptionObject& err) { itkDebugMacro(<< err); return false; } return true; } /** * BeforeThreadedGenerateData */ template void MaskMuParserFilter::BeforeThreadedGenerateData() { typename std::vector::iterator itFunctor; unsigned int nbThreads = this->GetNumberOfThreads(); unsigned int thread_index; std::ostringstream varName; // Allocate and initialize the thread temporaries m_ThreadUnderflow.SetSize(nbThreads); m_ThreadUnderflow.Fill(0); m_ThreadOverflow.SetSize(nbThreads); m_ThreadOverflow.Fill(0); m_VFunctor.resize(nbThreads); for (itFunctor = m_VFunctor.begin(); itFunctor < m_VFunctor.end(); itFunctor++) *itFunctor = FunctorType::New(); for (thread_index = 0; thread_index < nbThreads; thread_index++) { m_VFunctor.at(thread_index)->SetExpression(m_Expression); } } template void MaskMuParserFilter::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, itk::ThreadIdType threadId) { InputImageConstPointer inputPtr = this->GetInput(); OutputImagePointer outputPtr = this->GetOutput(0); // Define the portion of the input to walk for this thread, using // the CallCopyOutputRegionToInputRegion method allows for the input // and output images to be different dimensions InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, inputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); FunctorPointer functorP = m_VFunctor.at(threadId); FunctorType& functor = *functorP; while (!inputIt.IsAtEnd()) { outputIt.Set(functor(inputIt.Get())); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } template void MaskMuParserFilter::AfterThreadedGenerateData() { } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbMaskMuParserFunctor.h000066400000000000000000000065421301006202600272420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaskMuParserFunctor_h #define otbMaskMuParserFunctor_h #include "otbParser.h" #include "otbMacro.h" #include "otbBinarySpectralAngleFunctor.h" namespace otb { /** \class MaskMuParserFunctor * \brief Functor used to create binary mask for input of connected component segmentation module. * * This functor is based on the mathematical parser library muParser. * The built in functions and operators list is available at: * http://muparser.sourceforge.net/mup_features.html#idDef2 * * OTB additional functions: * ndvi(r, niri) * * OTB additional constants: * e - log2e - log10e - ln2 - ln10 - pi - euler * * \sa Parser * * * \ingroup OTBMathParser */ /** \class MaskMuParserFunctor * \brief This functor use MuParser to evaluate and process mathematical expression * * \ingroup OTBMathParser */ namespace Functor { template class ITK_EXPORT MaskMuParserFunctor: public itk::LightObject { public: typedef MaskMuParserFunctor Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MaskMuParserFunctor, itk::LightObject); typedef TInputPixel PixelType; typedef Parser ParserType; typedef BinarySpectralAngleFunctor SpectralAngleFunctorType; bool operator()(const PixelType &p); const std::map& GetVar() const; Parser::FunctionMapType GetFunList() const; void SetExpression(const std::string& expression); /** Return the expression to be parsed */ std::string GetExpression() const; void SetNumberOfBands(unsigned int NbOfBands); /** Set the reference pixel used to compute the "spectralangle" parser variable */ void SetSpectralAngleReferencePixel(const PixelType& refPixel); /** Check the expression */ bool CheckExpression(); protected: MaskMuParserFunctor(); ~MaskMuParserFunctor() ITK_OVERRIDE; private: MaskMuParserFunctor(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented std::string m_Expression; ParserType::Pointer m_Parser; std::vector m_AImage; //std::vector m_VarName; unsigned int m_NbOfBands; //unsigned int m_NbVar; double m_ParserResult; //user defined variables double m_Intensity; double m_SpectralAngle; PixelType m_SpectralAngleReferencePixel; SpectralAngleFunctorType m_SpectralAngleFunctor; }; } // end of Functor namespace }//end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMaskMuParserFunctor.txx" #endif #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbMaskMuParserFunctor.txx000066400000000000000000000063751301006202600276420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMaskMuParserFunctor_txx #define otbMaskMuParserFunctor_txx #include "otbMaskMuParserFunctor.h" namespace otb { namespace Functor { // constructor template MaskMuParserFunctor::MaskMuParserFunctor() : m_Parser(ParserType::New()), m_NbOfBands(0), m_ParserResult(0), m_Intensity(0), m_SpectralAngle(0) { } // Destructor template MaskMuParserFunctor::~MaskMuParserFunctor() { } template bool MaskMuParserFunctor::operator()(const PixelType &p) { double value; if (p.Size() != m_NbOfBands) { this->SetNumberOfBands(p.GetSize()); } // we fill the buffer for (unsigned int i = 0; i < m_NbOfBands; ++i) { m_AImage[i] = static_cast (p[i]); } // user defined variables m_Intensity = 0.0; for (unsigned int i = 0; i < m_NbOfBands; ++i) { m_Intensity += p[i]; } m_Intensity = m_Intensity / (static_cast (m_NbOfBands)); m_SpectralAngle = m_SpectralAngleFunctor(p, m_SpectralAngleReferencePixel); value = m_Parser->Eval(); return static_cast (value); } template const std::map& MaskMuParserFunctor::GetVar() const { return this->m_Parser->GetVar(); } template Parser::FunctionMapType MaskMuParserFunctor::GetFunList() const { return this->m_Parser->GetFunList(); } template void MaskMuParserFunctor::SetExpression(const std::string& expression) { m_Expression = expression; m_Parser->SetExpr(m_Expression); } /** Return the expression to be parsed */ template std::string MaskMuParserFunctor::GetExpression() const { return m_Expression; } template void MaskMuParserFunctor::SetNumberOfBands(unsigned int NbOfBands) { m_NbOfBands = NbOfBands; std::ostringstream varName; m_AImage.resize(NbOfBands, 0.0); for (unsigned int i = 0; i < NbOfBands; ++i) { varName << "b" << i + 1; m_Parser->DefineVar(varName.str(), &(m_AImage[i])); varName.str(""); } // customized data m_Parser->DefineVar("intensity", &m_Intensity); m_Parser->DefineVar("spectralAngle", &m_SpectralAngle); } /** Set the reference pixel used to compute the "spectralangle" parser variable */ template void MaskMuParserFunctor::SetSpectralAngleReferencePixel(const PixelType& refPixel) { m_SpectralAngleReferencePixel = refPixel; } /** Check the expression */ template bool MaskMuParserFunctor::CheckExpression() { return m_Parser->CheckExpr(); } } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbOBIAMuParserFunctor.h000066400000000000000000000125611301006202600270570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOBIAMuParserFunctor_h #define otbOBIAMuParserFunctor_h #include "otbParser.h" #include "otbMacro.h" namespace otb { /** \class OBIAMuParserFunctor * \brief use MuParser criteria to accept/reject LabelObject given his shape and radiometrics statistics. * This functor is based on the mathematical parser library muParser. * The built in functions and operators list is available at: * http://muparser.sourceforge.net/mup_features.html#idDef2 * * OTB additional functions: * ndvi(r, niri) * * OTB additional constants: * e - log2e - log10e - ln2 - ln10 - pi - euler * * \sa Parser * * * \ingroup OTBMathParser */ /** \class OBIAMuParserFunctor * \brief This functor use MuParser to evaluate and process mathematical expression * * \ingroup OTBMathParser */ namespace Functor { template //class ITK_EXPORT OBIAMuParserFunctor : public itk::LightObject class ITK_EXPORT OBIAMuParserFunctor { public: typedef Parser ParserType; typedef OBIAMuParserFunctor Self; std::string GetNameOfClass() { return "OBIAMuParserFunctor"; } inline bool operator()(const TLabelObject &a) { double value; if (a.GetNumberOfAttributes() != m_AAttributes.size()) { this->SetAttributes(a); } for (unsigned int i = 0; i < m_AAttributes.size(); ++i) { std::string name = (m_AttributesName[i]); m_AAttributes[i] = a.GetAttribute(name.c_str()); } try { value = m_Parser->Eval(); } catch (itk::ExceptionObject& err) { itkExceptionMacro(<< err); } return static_cast (value); } void SetExpression(const std::string expression) { m_Expression = expression; m_Parser->SetExpr(m_Expression); } /** Return the expression to be parsed */ std::string GetExpression() const { return m_Expression; } void ParseAttributeName(std::string &attributeName) { for (unsigned int i = 0; i < attributeName.size(); ++i) { if (attributeName[i] == ':') { attributeName.erase(i, 1); attributeName[i] = '_'; } } // TODO JGU // replace "Band" by "b" for homogeneity with other functors } void SetAttributes(const TLabelObject &a) { unsigned int nbOfAttributes = a.GetNumberOfAttributes(); m_AAttributes.resize(nbOfAttributes, 0.0); m_AttributesName.resize(nbOfAttributes, ""); m_AttributesName = a.GetAvailableAttributes(); for (unsigned int i = 0; i < nbOfAttributes; ++i) { std::string attributeName = m_AttributesName.at(i); ParseAttributeName(attributeName); //eliminate '::' from string name m_Parser->DefineVar(attributeName, &(m_AAttributes[i])); } } void SetAttributes(std::vector shapeAttributes, std::vector statAttributes, unsigned int nbOfBands) { int index = 0; unsigned int nbOfAttributes = shapeAttributes.size() + statAttributes.size() * nbOfBands; m_AAttributes.resize(nbOfAttributes, 0.0); m_AttributesName.resize(nbOfAttributes, ""); std::ostringstream varName; for (unsigned int i = 0; i < shapeAttributes.size(); ++i) { varName << "SHAPE::" << shapeAttributes.at(i); m_AttributesName.at(index) = varName.str(); varName.str(""); varName << "SHAPE_" << shapeAttributes.at(i); m_Parser->DefineVar(varName.str(), &(m_AAttributes[index])); varName.str(""); index++; } for (unsigned int i = 0; i < statAttributes.size(); ++i) { for (unsigned int bandIndex = 1; bandIndex <= nbOfBands; bandIndex++) { varName << "STATS::Band" << bandIndex << "::" << statAttributes.at(i); m_AttributesName.at(index) = varName.str(); varName.str(""); varName << "STATS_Band" << bandIndex << "_" << statAttributes.at(i); m_Parser->DefineVar(varName.str(), &(m_AAttributes[index])); varName.str(""); index++; } } } /** Check the expression */ bool CheckExpression() { return m_Parser->CheckExpr(); } const std::map& GetVar() const { return this->m_Parser->GetVar(); } Parser::FunctionMapType GetFunList() const { return this->m_Parser->GetFunList(); } OBIAMuParserFunctor() { m_Parser = ParserType::New(); m_AAttributes.resize(0); } ; ~OBIAMuParserFunctor() { } ; protected: private: OBIAMuParserFunctor(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented std::string m_Expression; ParserType::Pointer m_Parser; std::vector m_AAttributes; std::vector m_AttributesName; double m_ParserResult; }; } // end of Functor namespace }//end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbParser.h000066400000000000000000000053531301006202600245620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbParser_h #define otbParser_h #include "itkLightObject.h" #include "itkObjectFactory.h" #include "otb_muparser.h" namespace otb { class ParserImpl; /** \class Parser * \brief Definition of the standard floating point parser. * Standard implementation of the mathematical expressions parser. * * \sa BandMathImageFilter * * * \ingroup OTBMathParser */ class ITK_EXPORT Parser : public itk::LightObject { public: /** Standard class typedefs. */ typedef Parser Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** New macro for creation of through a Smart Pointer */ itkNewMacro(Self); /** Run-time type information (and related methods) */ itkTypeMacro(Parser, itk::LightObject); /** Convenient type definitions */ typedef Parser ParserType; typedef double ValueType; /** Type for function/number of arguments map */ typedef std::map FunctionMapType; /** Set the expression to be parsed */ virtual void SetExpr(const std::string & Expression); /** Trigger the parsing */ ValueType Eval(); /** Define a variable */ void DefineVar(const std::string &sName, ValueType *fVar); /** Clear all the defined variables */ void ClearVar(); /** Return the expression to be parsed */ const std::string& GetExpr() const; /** Return the list of variables */ const std::map& GetVar() const; /** Return a map of function names and associated number of arguments */ FunctionMapType GetFunList() const; /** Check Expression **/ bool CheckExpr(); protected: Parser(); ~Parser() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: Parser(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented typedef itk::SmartPointer ParserImplPtr; ParserImplPtr m_InternalParser; }; // end class }//end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbParserConditionDataNodeFeatureFunction.h000066400000000000000000000101031301006202600330400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbParserConditionDataNodeFeatureFunction_h #define otbParserConditionDataNodeFeatureFunction_h #include "otbDataNodeImageFunction.h" #include "otbPolyLineImageConstIterator.h" #include "otbMaskMuParserFunctor.h" namespace otb { /** \class ParserConditionDataNodeFeatureFunction * \brief Compute a ParserCondition based feature alongside a * datanode. * * This function evaluate a condition alongside a datanode. * The descriptor is the percentage of pixels iterated for which * the condition is true. * * \ingroup Functions * \sa DataNodeImageFunction * \sa SpectralAngleDataNodeFeatureFunction * * \ingroup OTBMathParser */ template < class TImage, class TCoordRep = double, class TPrecision = double > class ITK_EXPORT ParserConditionDataNodeFeatureFunction : public DataNodeImageFunction, TCoordRep, TPrecision> { public: /** Standard class typedefs. */ typedef ParserConditionDataNodeFeatureFunction Self; typedef DataNodeImageFunction, TCoordRep, TPrecision> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ParserConditionDataNodeFeatureFunction, DataNodeImageFunction); /** Some typedefs. */ typedef typename Superclass::DataNodeType DataNodeType; typedef typename DataNodeType::LineType LineType; typedef TImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType ScalarRealType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::IndexValueType IndexValueType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; typedef PolyLineImageConstIterator ImageLineIteratorType; typedef Functor::MaskMuParserFunctor ParserConditionFunctorType; typedef typename ParserConditionFunctorType::Pointer ParserConditionFunctorPointer; typedef std::vector OutputType; OutputType Evaluate( const DataNodeType& node ) const ITK_OVERRIDE; std::string GetExpression() const { return m_ParserConditionFunctor->GetExpression(); } void SetExpression(std::string expression) { m_ParserConditionFunctor->SetExpression(expression); } void SetSpectralAngleReferencePixel(const PixelType& pixel) { m_ParserConditionFunctor->SetSpectralAngleReferencePixel(pixel); } protected: ParserConditionDataNodeFeatureFunction(); ~ParserConditionDataNodeFeatureFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ParserConditionDataNodeFeatureFunction(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** ParserCondition Functor */ ParserConditionFunctorPointer m_ParserConditionFunctor; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbParserConditionDataNodeFeatureFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/MathParser/include/otbParserConditionDataNodeFeatureFunction.txx000066400000000000000000000064021301006202600334430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbParserConditionDataNodeFeatureFunction_txx #define otbParserConditionDataNodeFeatureFunction_txx #include "otbParserConditionDataNodeFeatureFunction.h" namespace otb { /** * Constructor */ template ParserConditionDataNodeFeatureFunction ::ParserConditionDataNodeFeatureFunction() { m_ParserConditionFunctor = ParserConditionFunctorType::New(); } /** * Standard "PrintSelf" method */ template void ParserConditionDataNodeFeatureFunction ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf( os, indent ); //os << indent << "ParserCondition : " << m_ParserConditionFunctor << std::endl; } template typename ParserConditionDataNodeFeatureFunction ::OutputType ParserConditionDataNodeFeatureFunction ::Evaluate( const DataNodeType& node ) const { // The parser evaluation can't be const since the parser state // changes at the first evaluation, but in fact we don't modify // anything here. // To fit with the rest of the framework, we try to keep the Evaluate // function const Self* _this = const_cast(this); ParserConditionFunctorType& parser = *(_this->m_ParserConditionFunctor); // Ugly things over const typename ImageLineIteratorType::PathType* path; switch (node.GetNodeType()) { case FEATURE_POINT: { itkExceptionMacro(<< "This DataNode type is not handle yet"); break; } case FEATURE_LINE: { path = node.GetLine(); break; } case FEATURE_POLYGON: { path = node.GetPolygonExteriorRing(); break; } default: { itkExceptionMacro(<< "This DataNode type is not handle yet"); break; } } ImageLineIteratorType lineIt(this->GetInputImage(), path); lineIt.GoToBegin(); double nbValidPixel = 0.; double nbVisitedPixel = 0.; while(!lineIt.IsAtEnd()) { if(this->IsInsideBuffer(lineIt.GetIndex())) { if( parser(this->GetInputImage()->GetPixel(lineIt.GetIndex())) ) { nbValidPixel += 1; } nbVisitedPixel += 1; } ++lineIt; } OutputType output; if(nbVisitedPixel == 0) { output.push_back(static_cast(0.)); } else { output.push_back(static_cast(nbValidPixel/nbVisitedPixel)); } output.push_back(static_cast(nbValidPixel)); output.push_back(static_cast(nbVisitedPixel)); return output; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParser/otb-module.cmake000066400000000000000000000010011301006202600240600ustar00rootroot00000000000000set(DOCUMENTATION "This module contains filters that can apply any mathematical expression to the pixels of an image. Note that classes based on MuParserX have better capabilities than the ones based on MuParser.") otb_module(OTBMathParser DEPENDS OTBCommon OTBITK OTBImageManipulation OTBMuParser OTBPath OTBVectorDataBase TEST_DEPENDS OTBImageBase OTBImageIO OTBObjectList OTBProjection OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/MathParser/src/000077500000000000000000000000001301006202600216065ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParser/src/CMakeLists.txt000066400000000000000000000005131301006202600243450ustar00rootroot00000000000000set(OTBMathParser_SRC otbParser.cxx ) add_library(OTBMathParser ${OTBMathParser_SRC}) target_link_libraries(OTBMathParser ${OTBCommon_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBMuParser_LIBRARIES} ${OTBPath_LIBRARIES} ${OTBVectorDataBase_LIBRARIES} ) otb_module_target(OTBMathParser) OTB-release-5.8/Modules/Filtering/MathParser/src/otbParser.cxx000066400000000000000000000147161301006202600243040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMath.h" #include "otbParser.h" #include "otb_muparser.h" namespace otb { class ITK_EXPORT ParserImpl : public itk::LightObject { public: /** Standard class typedefs. */ typedef ParserImpl Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** New macro for creation of through a Smart Pointer */ itkNewMacro(Self); /** Run-time type information (and related methods) */ itkTypeMacro(ParserImpl, itk::LightObject); /** Convenient type definitions */ typedef double ValueType; typedef mu::Parser::exception_type ExceptionType; /** Initialize user defined constants */ virtual void InitConst() { m_MuParser.DefineConst( "e", CONST_E ); m_MuParser.DefineConst( "log2e", CONST_LOG2E ); m_MuParser.DefineConst( "log10e", CONST_LOG10E ); m_MuParser.DefineConst( "ln2", CONST_LN2 ); m_MuParser.DefineConst( "ln10", CONST_LN10 ); m_MuParser.DefineConst( "pi", CONST_PI ); m_MuParser.DefineConst( "euler", CONST_EULER ); } /** Initialize user defined functions */ virtual void InitFun() { m_MuParser.DefineFun("ndvi", Self::NDVI); m_MuParser.DefineFun("NDVI", Self::NDVI); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS /* Starting with muParser 2.0.0, logical operators have been renamed to "&&" and "||", instead of "and" and "or". Reintroducing pre-2.0.0 operators, so formulas can be defined with "and" and "or" even after 2.0.0 */ m_MuParser.DefineOprt("and", Self::AND); m_MuParser.DefineOprt("or", Self::OR); #endif } /** Set the expression to be parsed */ virtual void SetExpr(const std::string & Expression) { m_MuParser.SetExpr(Expression); } /** Trigger the parsing */ ValueType Eval() { Parser::ValueType result = 0.0; try { result = m_MuParser.Eval(); } catch(ExceptionType &e) { ExceptionHandler(e); } return result; } /** Define a variable */ void DefineVar(const std::string &sName, ValueType *fVar) { try { m_MuParser.DefineVar(sName, fVar); } catch(ExceptionType &e) { ExceptionHandler(e); } } /** Clear all the defined variables */ void ClearVar() { m_MuParser.ClearVar(); } /** Return the expression to be parsed */ const std::string& GetExpr() const { return m_MuParser.GetExpr(); } /** Return the list of variables */ const std::map& GetVar() const { return m_MuParser.GetVar(); } /** Check Expression **/ bool CheckExpr() { try { m_MuParser.Eval(); } catch(ExceptionType &e) { ExceptionHandler(e); return false; } return true; } // Get the map with the functions Parser::FunctionMapType GetFunList() const { Parser::FunctionMapType output; const mu::funmap_type& funmap = m_MuParser.GetFunDef(); mu::funmap_type::const_iterator funItem; for (funItem = funmap.begin(); funItem != funmap.end(); ++funItem) { output[funItem->first] = funItem->second.GetArgc(); } return output; } /** Convert parser specific exception into itk exception */ virtual void ExceptionHandler(ExceptionType &e) { itkExceptionMacro( << std::endl << "Message: " << e.GetMsg() << std::endl << "Formula: " << e.GetExpr() << std::endl << "Token: " << e.GetToken() << std::endl << "Position: " << e.GetPos() << std::endl << std::endl); // << "Errc: " << e.GetCode() << std::endl); } /** Convert parser specific exception into itk debug macro */ virtual void ExceptionHandlerDebug(ExceptionType &e) { ExceptionHandler(e); } protected: ParserImpl() { InitFun(); InitConst(); } ~ParserImpl() ITK_OVERRIDE { } void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: ParserImpl(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented mu::Parser m_MuParser; //---------- User Defined Functions ----------//BEGIN static ValueType NDVI(ValueType r, ValueType niri) { if ( vcl_abs(r + niri) < 1E-6 ) { return 0.; } return (niri-r)/(niri+r); } #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS static ValueType AND(ValueType left, ValueType right) { return static_cast(left) && static_cast(right); } static ValueType OR(ValueType left, ValueType right) { return static_cast(left) || static_cast(right); } #endif //---------- User Defined Functions ----------//END }; // end class void Parser::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } Parser::Parser() : m_InternalParser( ParserImpl::New() ) { } Parser::~Parser() { } void Parser::SetExpr(const std::string & Expression) { m_InternalParser->SetExpr(Expression); } Parser::ValueType Parser::Eval() { return m_InternalParser->Eval(); } void Parser::DefineVar(const std::string &sName, Parser::ValueType *fVar) { m_InternalParser->DefineVar(sName, fVar); } void Parser::ClearVar() { m_InternalParser->ClearVar(); } bool Parser::CheckExpr() { return m_InternalParser->CheckExpr(); } const std::string& Parser::GetExpr() const { return m_InternalParser->GetExpr(); } // Get the map with the variables const std::map& Parser::GetVar() const { return m_InternalParser->GetVar(); } // Get the map with the functions Parser::FunctionMapType Parser::GetFunList() const { return m_InternalParser->GetFunList(); } }//end namespace otb OTB-release-5.8/Modules/Filtering/MathParser/test/000077500000000000000000000000001301006202600217765ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParser/test/CMakeLists.txt000066400000000000000000000057561301006202600245530ustar00rootroot00000000000000otb_module_test() set(OTBMathParserTests otbMathParserTestDriver.cxx otbMaskMuParserFilterNew.cxx otbMaskMuParserFilterTest.cxx otbParserConditionDataNodeFeatureFunction.cxx otbParserTest.cxx otbImageListToSingleImageFilterTest.cxx otbBandMathImageFilter.cxx ) add_executable(otbMathParserTestDriver ${OTBMathParserTests}) target_link_libraries(otbMathParserTestDriver ${OTBMathParser-Test_LIBRARIES}) otb_module_target_label(otbMathParserTestDriver) # Tests Declaration otb_add_test(NAME bfTuMaskMuParserFilterNew COMMAND otbMathParserTestDriver otbMaskMuParserFilterNew ) otb_add_test(NAME bfTvMaskMuParserFilterTest COMMAND otbMathParserTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvMaskMuParserFilterTest.tif ${TEMP}/bfTvMaskMuParserFilterTest.tif otbMaskMuParserFilterTest ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/bfTvMaskMuParserFilterTest.tif "(b1>100)*(b2>120)" ) otb_add_test(NAME bfTvParserConditionDataNodeFeatureFunction_Line_NDVI COMMAND otbMathParserTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvNDVIDataNodeFeatureFunctionOutput_Line.shp ${TEMP}/bfTvParserConditionDataNodeFeatureFunction_Line_NDVI.shp otbParserConditionDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_ROADS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvParserConditionDataNodeFeatureFunction_Line_NDVI.shp "ndvi(b3,b4) > 0.047" 0 ) otb_add_test(NAME bfTvParserConditionDataNodeFeatureFunction_Polygon_NDVI COMMAND otbMathParserTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvNDVIDataNodeFeatureFunctionOutput_Polygon.shp ${TEMP}/bfTvParserConditionDataNodeFeatureFunction_Polygon_NDVI.shp otbParserConditionDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_BUILDINGS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvParserConditionDataNodeFeatureFunction_Polygon_NDVI.shp "ndvi(b3,b4) > 0.047" 0 ) otb_add_test(NAME coTvParser COMMAND otbMathParserTestDriver otbParserTest ) otb_add_test(NAME coTuParser COMMAND otbMathParserTestDriver otbParserTestNew ) otb_add_test(NAME bfTuImageListToSingleImageFilterNew COMMAND otbMathParserTestDriver otbImageListToSingleImageFilterNew) otb_add_test(NAME bfTvImageListToSingleImageFilter COMMAND otbMathParserTestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvImageListToSingleImageFilter.tif ${TEMP}/bfTvImageListToSingleImageFilterOut.tif otbImageListToSingleImageFilter ${INPUTDATA}/poupees.png ${TEMP}/bfTvImageListToSingleImageFilterOut.tif ) otb_add_test(NAME bfTvBandMathImageFilterWithIdx COMMAND otbMathParserTestDriver otbBandMathImageFilterWithIdx ${TEMP}/bfTvBandMathImageFilterWithIdx1.tif ${TEMP}/bfTvBandMathImageFilterWithIdx2.tif ) otb_add_test(NAME bfTuBandMathImageFilter COMMAND otbMathParserTestDriver otbBandMathImageFilterNew) otb_add_test(NAME bfTvBandMathImageFilter COMMAND otbMathParserTestDriver otbBandMathImageFilter) OTB-release-5.8/Modules/Filtering/MathParser/test/otbBandMathImageFilter.cxx000066400000000000000000000217431301006202600270250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include //only for the isnan() test line 148 #include "otbMath.h" #include "otbImage.h" #include "otbBandMathImageFilter.h" #include "otbImageFileWriter.h" int otbBandMathImageFilterNew( int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double PixelType; //typedef float PixelType; typedef otb::Image ImageType; typedef otb::BandMathImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbBandMathImageFilter( int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double PixelType; //typedef float PixelType; typedef otb::Image ImageType; typedef otb::BandMathImageFilter FilterType; unsigned int i; const unsigned int N = 100; unsigned int FAIL_FLAG = 0; ImageType::SizeType size; size.Fill(N); ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image1 = ImageType::New(); ImageType::Pointer image2 = ImageType::New(); ImageType::Pointer image3 = ImageType::New(); image1->SetLargestPossibleRegion( region ); image1->SetBufferedRegion( region ); image1->SetRequestedRegion( region ); image1->Allocate(); image2->SetLargestPossibleRegion( region ); image2->SetBufferedRegion( region ); image2->SetRequestedRegion( region ); image2->Allocate(); image3->SetLargestPossibleRegion( region ); image3->SetBufferedRegion( region ); image3->SetRequestedRegion( region ); image3->Allocate(); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it1(image1, region); IteratorType it2(image2, region); IteratorType it3(image3, region); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3) { ImageType::IndexType i1 = it1.GetIndex(); ImageType::IndexType i2 = it2.GetIndex(); ImageType::IndexType i3 = it3.GetIndex(); it1.Set( i1[0] + i1[1] -50 ); it2.Set( i2[0] * i2[1] ); it3.Set( i3[0] + i3[1] * i3[1] ); } FilterType::Pointer filter = FilterType::New(); std::cout << "Number Of Threads : " << filter->GetNumberOfThreads() << std::endl; filter->SetNthInput(0, image1); filter->SetNthInput(1, image2); filter->SetNthInput(2, image3, "canal3"); filter->SetExpression("cos(2 * pi * b1)/(2 * pi * b2 + 1E-3)*sin(pi * canal3) + ndvi(b1, b2) * sqrt(2) * canal3"); filter->Update(); std::cout << "\n--- Standard Use\n"; std::cout << "Parsed Expression : " << filter->GetExpression() << std::endl; ImageType::Pointer output = filter->GetOutput(); IteratorType it(output, region); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(), it.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3, ++it) { ImageType::IndexType i1 = it1.GetIndex(); ImageType::IndexType i2 = it2.GetIndex(); ImageType::IndexType i3 = it3.GetIndex(); PixelType px1 = ( i1[0] + i1[1] -50 ); PixelType px2 = ( i2[0] * i2[1] ); PixelType px3 = ( i3[0] + i3[1] * i3[1] ); PixelType result = it.Get(); PixelType ndvi_expected; PixelType error; if ( vcl_abs( px1 + px2) < 1E-6 ) ndvi_expected = 0.0; else ndvi_expected = (px2-px1)/(px2+px1); PixelType expected = vcl_cos( 2 * otb::CONST_PI * px1 ) / ( 2 * otb::CONST_PI * px2 + 1E-3 ) * vcl_sin( otb::CONST_PI * px3 ) + ndvi_expected * vcl_sqrt(PixelType(2)) * px3; /* std::cout << "Pixel_1 = " << it1.Get() << " Pixel_2 = " << it2.Get() << " Pixel_3 = " << it3.Get() << " Result = " << it.Get() << " Expected = " << expected << std::endl; */ error = (result - expected) * (result - expected) / (result + expected); if ( error > 1E-9 ) { std::cout << "Error = " << error << " > 1E-9 -> TEST FAILLED" << std::endl << "Pixel_1 = " << it1.Get() << " Pixel_2 = " << it2.Get() << " Pixel_3 = " << it3.Get() << " Result = " << it.Get() << " Expected = " << expected << std::endl; FAIL_FLAG++; break; } } /** Edge Effect Handling */ std::cout << "\n--- Edge Effect Handling\n"; std::cout << "- +/-inf section\n"; filter->SetExpression("b1 / b2"); filter->Update(); std::cout << "- nan section\n"; it1.GoToBegin(); it2.GoToBegin(); it.GoToBegin(); for(i=1; i<=50; ++i , ++it1, ++it2, ++it){} if(vnl_math_isnan(it.Get())) std::cout << "Pixel_1 = " << it1.Get() << " Pixel_2 = " << it2.Get() << " Result = " << it.Get() << " Expected = nan\n" << std::endl; else { std::cout << "\nError > Bad Edge Effect Handling -> Test Failled\n" << "Pixel_1 = " << it1.Get() << " Pixel_2 = " << it2.Get() << " Result = " << it.Get() << " Expected = nan\n" << std::endl; FAIL_FLAG++; } if (FAIL_FLAG) { std::cout << "[FAILLED]" << std::endl; return EXIT_FAILURE; } std::cout << "[PASSED]" << std::endl; return EXIT_SUCCESS; } int otbBandMathImageFilterWithIdx( int itkNotUsed(argc), char* argv[]) { const char * outfname1 = argv[1]; const char * outfname2 = argv[2]; typedef double PixelType; //typedef float PixelType; typedef otb::Image ImageType; typedef otb::BandMathImageFilter FilterType; typedef otb::ImageFileWriter WriterType; const unsigned int N = 100; ImageType::SizeType size; size.Fill(N); ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::PointType origin; origin[0] = -25; origin[1] = -25; ImageType::SpacingType spacing; spacing[0] = 0.5; spacing[1] = 0.5; ImageType::Pointer image1 = ImageType::New(); ImageType::Pointer image2 = ImageType::New(); ImageType::Pointer image3 = ImageType::New(); image1->SetLargestPossibleRegion( region ); image1->SetBufferedRegion( region ); image1->SetRequestedRegion( region ); image1->Allocate(); image2->SetLargestPossibleRegion( region ); image2->SetBufferedRegion( region ); image2->SetRequestedRegion( region ); image2->Allocate(); image3->SetLargestPossibleRegion( region ); image3->SetBufferedRegion( region ); image3->SetRequestedRegion( region ); image3->Allocate(); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it1(image1, region); IteratorType it2(image2, region); IteratorType it3(image3, region); image1->SetOrigin(origin); image1->SetSpacing(spacing); image2->SetOrigin(origin); image2->SetSpacing(spacing); image3->SetOrigin(origin); image3->SetSpacing(spacing); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3) { ImageType::IndexType i1 = it1.GetIndex(); ImageType::IndexType i2 = it2.GetIndex(); ImageType::IndexType i3 = it3.GetIndex(); it1.Set( i1[0] + i1[1] -50 ); it2.Set( i2[0] * i2[1] ); it3.Set( i3[0] + i3[1] * i3[1] ); } FilterType::Pointer filter = FilterType::New(); std::cout << "Number Of Threads : " << filter->GetNumberOfThreads() << std::endl; filter->SetNthInput(0, image1); filter->SetNthInput(1, image2); filter->SetNthInput(2, image3); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS filter->SetExpression("(sqrt(idxX*idxX+idxY*idxY) < 50) ? b2 : b3"); #else filter->SetExpression("if(sqrt(idxX*idxX+idxY*idxY) < 50, b2, b3)"); #endif WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname1); writer->Update(); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS filter->SetExpression("(sqrt(idxPhyX*idxPhyX+idxPhyY*idxPhyY) < 25) ? b2 : b3"); #else filter->SetExpression("if(sqrt(idxPhyX*idxPhyX+idxPhyY*idxPhyY) < 25, b2, b3)"); #endif WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(filter->GetOutput()); writer2->SetFileName(outfname2); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParser/test/otbImageListToSingleImageFilterTest.cxx000066400000000000000000000071741301006202600315340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImageToImageListFilter.h" #include "otbImageListToSingleImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBandMathImageFilter.h" int otbImageListToSingleImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageList ImageListType; typedef otb::ImageListToSingleImageFilter ImageListToSingleImageFilter; // Instantiating object ImageListToSingleImageFilter::Pointer filter = ImageListToSingleImageFilter::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbImageListToSingleImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; char * infname = argv[1]; char * outfname1 = argv[2]; typedef float PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; // IO Typedef typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Filter Typedef typedef otb::VectorImageToImageListFilter VectorImageToImageListFilterType; typedef otb::ImageListToSingleImageFilter ImageListToSingleImageFilter; typedef otb::BandMathImageFilter BandMathImageFilterType; // Instantiating objects VectorImageToImageListFilterType::Pointer filter1 = VectorImageToImageListFilterType::New(); ImageListToSingleImageFilter::Pointer filter2_1 = ImageListToSingleImageFilter::New(); ImageListToSingleImageFilter::Pointer filter2_2 = ImageListToSingleImageFilter::New(); BandMathImageFilterType::Pointer filter3 = BandMathImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); // Reader reader->SetFileName(infname); // VectorImage to Image List filter1->SetInput(reader->GetOutput()); filter1->UpdateOutputInformation(); // Retrieve one image from the image list filter2_1->SetExtractedImagePosition(1); filter2_1->SetInput(filter1->GetOutput()); // Retrieve one image from the image list filter2_2->SetExtractedImagePosition(2); filter2_2->SetInput(filter1->GetOutput()); // Use an BandMath with the selected image filter3->SetNthInput(0,filter2_1->GetOutput()); filter3->SetNthInput(1,filter2_2->GetOutput()); #ifdef OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS filter3->SetExpression(" ( b2 > 1.0 ) ? b1/b2 : 0" ); #else filter3->SetExpression(" if( b2 > 1.0, b1/b2, 0)" ); #endif // Write the result writer->SetFileName(outfname1); writer->SetNumberOfDivisionsTiledStreaming(8); writer->SetInput(filter3->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParser/test/otbMaskMuParserFilterNew.cxx000066400000000000000000000021561301006202600274250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImage.h" #include "otbMaskMuParserFilter.h" int otbMaskMuParserFilterNew( int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputVectorImageType; typedef otb::Image OutputImageType; typedef otb::MaskMuParserFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParser/test/otbMaskMuParserFilterTest.cxx000066400000000000000000000040611301006202600276100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMaskMuParserFilter.h" int otbMaskMuParserFilterTest(int argc, char * argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0] << " infname outframe MuParserexpression" << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const char * expression = argv[3]; typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; typedef otb::MaskMuParserFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); reader->SetFileName(inputFilename); reader->GenerateOutputInformation(); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); std::string stringExpression(expression); filter->SetExpression(stringExpression); filter->UpdateOutputInformation(); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParser/test/otbMathParserTestDriver.cxx000066400000000000000000000010631301006202600273110ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMaskMuParserFilterNew); REGISTER_TEST(otbMaskMuParserFilterTest); REGISTER_TEST(otbParserConditionDataNodeFeatureFunctionNew); REGISTER_TEST(otbParserConditionDataNodeFeatureFunction); REGISTER_TEST(otbParserTestNew); REGISTER_TEST(otbParserTest); REGISTER_TEST(otbImageListToSingleImageFilterNew); REGISTER_TEST(otbImageListToSingleImageFilter); REGISTER_TEST(otbBandMathImageFilterNew); REGISTER_TEST(otbBandMathImageFilter); REGISTER_TEST(otbBandMathImageFilterWithIdx); } OTB-release-5.8/Modules/Filtering/MathParser/test/otbParserConditionDataNodeFeatureFunction.cxx000066400000000000000000000116741301006202600327650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbParserConditionDataNodeFeatureFunction.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataIntoImageProjectionFilter.h" #include "otbVectorDataFileWriter.h" #include "itkPreOrderTreeIterator.h" int otbParserConditionDataNodeFeatureFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::ParserConditionDataNodeFeatureFunction ParserConditionDataNodeFeaturefunctionType; ParserConditionDataNodeFeaturefunctionType::Pointer ParserConditionFeature = ParserConditionDataNodeFeaturefunctionType::New(); std::cout << ParserConditionFeature << std::endl; return EXIT_SUCCESS; } int otbParserConditionDataNodeFeatureFunction(int itkNotUsed(argc), char* argv[]) { const char * inputVD = argv[1]; const char * inputImg = argv[2]; const char * DEMDir = argv[3]; const char * outputVD = argv[4]; const char * expression = argv[5]; int DisplayWarnings = atoi(argv[6]); typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ImageReaderType; typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataIntoImageProjectionFilter VectorDataReProjFilter; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef otb::ParserConditionDataNodeFeatureFunction ParserConditionDataNodeFeaturefunctionType; typedef ParserConditionDataNodeFeaturefunctionType::OutputType ParserConditionFeatureOutputType; ImageReaderType::Pointer imgReader = ImageReaderType::New(); VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); VectorDataReProjFilter::Pointer vdReProjFilter = VectorDataReProjFilter::New(); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); ParserConditionDataNodeFeaturefunctionType::Pointer ParserConditionFeatureFunction = ParserConditionDataNodeFeaturefunctionType::New(); if (!DisplayWarnings) { imgReader->SetGlobalWarningDisplay(0); } otb::DEMHandler::Instance()->OpenDEMDirectory(DEMDir); vdReader->SetFileName(inputVD); vdReader->Update(); imgReader->SetFileName(inputImg); imgReader->UpdateOutputInformation(); imgReader->Update(); //Needed to set m_EndIndex, m_StartIndex in otbDataNodeImageFunction vdReProjFilter->SetInputImage(imgReader->GetOutput()); vdReProjFilter->SetInputVectorData(vdReader->GetOutput()); vdReProjFilter->SetUseOutputSpacingAndOriginFromImage(true); vdReProjFilter->Update(); ParserConditionFeatureFunction->SetExpression(expression); ParserConditionFeatureFunction->SetInputImage(imgReader->GetOutput()); // Output VectorDataType::Pointer outVD = VectorDataType::New(); // Retrieving root node DataNodeType::Pointer root = outVD->GetDataTree()->GetRoot()->Get(); // Create the document node DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree outVD->GetDataTree()->Add(document, root); // Create the folder node DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree outVD->GetDataTree()->Add(folder, document); TreeIteratorType itVector(vdReProjFilter->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsLineFeature() || itVector.Get()->IsPolygonFeature()) { const DataNodeType::Pointer currentGeometry = itVector.Get(); ParserConditionFeatureOutputType currentResult; currentResult = ParserConditionFeatureFunction->Evaluate(*(currentGeometry.GetPointer())); currentGeometry->SetFieldAsDouble("NDVI", (double) (currentResult[0])); outVD->GetDataTree()->Add(currentGeometry, folder); } ++itVector; } vdWriter->SetInput(outVD); vdWriter->SetFileName(outputVD); vdWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParser/test/otbParserTest.cxx000066400000000000000000000074161301006202600253330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMath.h" #include "otbParser.h" typedef otb::Parser ParserType; int otbParserTestNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiating object ParserType::Pointer parser = ParserType::New(); std::cout << parser << std::endl; return EXIT_SUCCESS; } void otbParserTest_ThrowIfNotEqual(double output, double ref, std::string testname, double epsilon = 1.0E-12) { std::cout << "Running test " << testname << std::endl; if (vcl_abs(output-ref) > epsilon) { itkGenericExceptionMacro( << "Got " << output << " while waiting for " << ref ); } std::cout << " -- OK" << std::endl; } void otbParserTest_ThrowIfNotEqual(int output, int ref, std::string testname = "") { std::cout << "Running test " << testname << std::endl; if (output != ref) { itkGenericExceptionMacro( << "Got " << output << " while waiting for " << ref ); } std::cout << " -- OK" << std::endl; } void otbParserTest_Numerical(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("10.0+3"); otbParserTest_ThrowIfNotEqual(parser->Eval(), 13.0, "Numerical"); } void otbParserTest_BuildInFun(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("cos(1.55)"); otbParserTest_ThrowIfNotEqual(parser->Eval(), vcl_cos(1.55), "BuildInFun"); } void otbParserTest_UserDefinedCst(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("ln10"); otbParserTest_ThrowIfNotEqual(parser->Eval(), vcl_log(10.0), "UserDefinedCst"); } void otbParserTest_UserDefinedFun(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("ndvi(100, 10)"); otbParserTest_ThrowIfNotEqual(parser->Eval(), (10.0-100.0)/(10.0+100.0), "UserDefinedFun"); } void otbParserTest_UserDefinedVars(void) { double var1 = 10.0; double var2 = 2.0; double var3 = 7.0; double var4 = 100.0; double var5 = 200.0; ParserType::Pointer parser = ParserType::New(); parser->DefineVar("var1", &var1); parser->DefineVar("var2", &var2); parser->DefineVar("var3", &var3); parser->DefineVar("var4", &var4); parser->DefineVar("var5", &var5); parser->SetExpr("(var1+var2-var3)*var4/var5"); otbParserTest_ThrowIfNotEqual(parser->Eval(), (var1+var2-var3)*var4/var5, "UserDefinedVars"); } void otbParserTest_Mixed(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("(7+10)/2+cos(pi/4)*10-10*ln10+ndvi(100, 10)"); otbParserTest_ThrowIfNotEqual(parser->Eval(), (7.0+10.0)/2.0+vcl_cos(otb::CONST_PI/4)*10.0-10.0*vcl_log(10.0)+(10.0-100.0)/(10.0+100.0), "Mixed"); } void otbParserTest_LogicalOperator(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("1 and 0"); otbParserTest_ThrowIfNotEqual(static_cast(parser->Eval()), 0, "LogicalOperator and"); parser->SetExpr("1 or 0"); otbParserTest_ThrowIfNotEqual(static_cast(parser->Eval()), 1, "LogicalOperator or"); } int otbParserTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otbParserTest_Numerical(); otbParserTest_BuildInFun(); otbParserTest_UserDefinedCst(); otbParserTest_UserDefinedFun(); otbParserTest_UserDefinedVars(); otbParserTest_Mixed(); otbParserTest_LogicalOperator(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParserX/000077500000000000000000000000001301006202600211475ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParserX/CMakeLists.txt000066400000000000000000000001321301006202600237030ustar00rootroot00000000000000project(OTBMathParserX) set(OTBMathParserX_LIBRARIES OTBMathParserX) otb_module_impl() OTB-release-5.8/Modules/Filtering/MathParserX/include/000077500000000000000000000000001301006202600225725ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParserX/include/otbBandMathXImageFilter.h000066400000000000000000000166731301006202600274040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBandMathXImageFilter_h #define otbBandMathXImageFilter_h #include "itkConstNeighborhoodIterator.h" #include "itkImageToImageFilter.h" #include "itkArray.h" #include "otbStreamingStatisticsVectorImageFilter.h" #include "otbParserX.h" #include namespace otb { /** \class BandMathXImageFilter * \brief Performs mathematical operations on the input images * according to the formula specified by the user. * * This filter is based on the mathematical parser library muParserX. * The built in functions and operators list is available at: * http://articles.beltoforion.de/article.php?a=muparserx. * * In order to use this filter, at least one input image is to be * set. An associated variable name can be specified or not by using * the corresponding SetNthInput method. For the jth (j=1..T) input image, if * no associated variable name has been specified, a default variable * name is given by concatenating the prefix "im" with the * corresponding input index plus one (for instance, im1 is related to the first input). * If the jth input image is multidimensional, then the variable imj represents a vector whose components are related to its bands. * In order to access the kth band, the variable observes the following pattern : imjbk. * * \sa Parser * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBMathParserX */ template< class TImage > class ITK_EXPORT BandMathXImageFilter : public itk::ImageToImageFilter< TImage , TImage > { public: /** Standard class typedefs. */ typedef BandMathXImageFilter< TImage > Self; typedef itk::ImageToImageFilter< TImage , TImage> Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer< const Self > ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BandMathXImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TImage ImageType; typedef typename ImageType::ConstPointer ConstImagePointer; typedef typename ImageType::Pointer ImagePointer; typedef typename ImageType::RegionType ImageRegionType; typedef typename itk::ConstNeighborhoodIterator::RadiusType RadiusType; typedef typename ImageType::PixelType::ValueType PixelValueType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::PointType OrigineType; typedef typename ImageType::SpacingType SpacingType; typedef ParserX ParserType; typedef typename ParserType::ValueType ValueType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Typedef for statistic computing. */ typedef StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef typename StreamingStatisticsVectorImageFilterType::Pointer StreamingStatisticsVectorImageFilterPointerType; typedef typename StreamingStatisticsVectorImageFilterType::MatrixType MatrixType; /** Set the nth filter input with or without a specified associated variable name */ using Superclass::SetNthInput; void SetNthInput( DataObjectPointerArraySizeType idx, const ImageType * image); void SetNthInput( DataObjectPointerArraySizeType idx, const ImageType * image, const std::string& varName); /** Return a pointer on the nth filter input */ ImageType * GetNthInput(DataObjectPointerArraySizeType idx); /** Set an expression to be parsed */ void SetManyExpressions(bool flag); /** Set an expression to be parsed */ void SetExpression(const std::string& expression); /** Return the nth expression to be parsed */ std::string GetExpression(int) const; /** Set a matrix (or a vector) */ void SetMatrix(const std::string& name, const std::string& definition); /** Set a constant */ void SetConstant(const std::string& name, double value); /** Export constants and expressions to a given filename */ void ExportContext(const std::string& filename); /** Import constants and expressions from a given filename */ void ImportContext(const std::string& filename); /** Return the variable and constant names */ std::vector GetVarNames() const; protected : BandMathXImageFilter(); ~BandMathXImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const ImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; private : bool globalStatsDetected() const { return (m_StatsVarDetected.size()>0); } typedef struct { std::string name; ValueType value; int type; int info[5]; } adhocStruct; BandMathXImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented void AddVariable(adhocStruct&); void CheckImageDimensions(); void PrepareParsers(); void PrepareParsersGlobStats(); void OutputsDimensions(); std::vector m_Expression; std::vector< std::vector > m_VParser; std::vector< std::vector > m_AImage; std::vector< adhocStruct > m_VVarName; std::vector< adhocStruct > m_VAllowedVarNameAuto; std::vector< adhocStruct > m_VAllowedVarNameAddedByUser; std::vector< adhocStruct > m_VFinalAllowedVarName; // m_VFinalAllowedVarName = m_VAllowedVarNameAuto + m_VAllowedVarNameAddedByUser std::vector< adhocStruct > m_VNotAllowedVarName; std::vector< unsigned int > m_outputsDimensions; unsigned int m_SizeNeighbourhood; std::vector< int > m_StatsVarDetected; // input image ID for which global statistics have been detected std::vector< unsigned int > m_NeighDetected; // input image ID for which neighbourhood have been detected std::vector < RadiusType > m_NeighExtremaSizes; long m_UnderflowCount; long m_OverflowCount; itk::Array m_ThreadUnderflow; itk::Array m_ThreadOverflow; bool m_ManyExpressions; }; }//end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBandMathXImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/MathParserX/include/otbBandMathXImageFilter.txx000066400000000000000000001171001301006202600277630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBandMathXImageFilter_txx #define otbBandMathXImageFilter_txx #include "otbBandMathXImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIterator.h" #include "itkImageScanlineConstIterator.h" #include "itkImageScanlineIterator.h" #include "itkImageRegionConstIteratorWithOnlyIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "otbMacro.h" #include #include #include namespace otb { /** Constructor */ template BandMathXImageFilter ::BandMathXImageFilter() { //This number will be incremented each time an image //is added over the one minimumrequired this->SetNumberOfRequiredInputs( 1 ); m_UnderflowCount = 0; m_OverflowCount = 0; m_ThreadUnderflow.SetSize(1); m_ThreadOverflow.SetSize(1); //idxX and idxY adhocStruct ahcX; ahcX.name = "idxX"; ahcX.type = 0; m_VAllowedVarNameAuto.push_back(ahcX); adhocStruct ahcY; ahcY.name = "idxY"; ahcY.type = 1; m_VAllowedVarNameAuto.push_back(ahcY); m_SizeNeighbourhood=10; m_ManyExpressions = true; } /** Destructor */ template BandMathXImageFilter ::~BandMathXImageFilter() { m_Expression.clear(); m_VParser.clear(); for(unsigned int i=0; i void BandMathXImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Expressions: " << std::endl; for (unsigned int i=0; i::NonpositiveMin() : " << itk::NumericTraits::NonpositiveMin() << std::endl; os << indent << "itk::NumericTraits::max() : " << itk::NumericTraits::max() << std::endl; } template void BandMathXImageFilter ::SetNthInput(DataObjectPointerArraySizeType idx, const ImageType * image) { std::stringstream sstm; sstm << "im" << (idx+1); this->SetNthInput(idx, image, sstm.str()); } template void BandMathXImageFilter ::SetNthInput(DataObjectPointerArraySizeType idx, const ImageType * image, const std::string& varName) { ImageType * imagebis = const_cast( image ); // Useful for call of UpdateOutputInformation() (see below) this->SetInput(idx, imagebis ); //imiPhyX and imiPhyY std::stringstream sstmPhyX; adhocStruct ahcPhyX; sstmPhyX << varName << "PhyX"; ahcPhyX.name = sstmPhyX.str(); ahcPhyX.type = 2; ahcPhyX.info[0] = idx; // Input image #ID m_VAllowedVarNameAuto.push_back(ahcPhyX); std::stringstream sstmPhyY; adhocStruct ahcPhyY; sstmPhyY << varName << "PhyY"; ahcPhyY.name = sstmPhyY.str(); ahcPhyY.type = 3; ahcPhyY.info[0] = idx; // Input image #ID m_VAllowedVarNameAuto.push_back(ahcPhyY); //imi std::stringstream sstm_glob; adhocStruct ahc_glob; sstm_glob << varName; ahc_glob.name = sstm_glob.str(); ahc_glob.type = 4; ahc_glob.info[0] = idx; // Input image #ID m_VAllowedVarNameAuto.push_back(ahc_glob); //Mandatory before call of GetNumberOfComponentsPerPixel //Really important not to call the filter's UpdateOutputInformation method here: //this method is not ready until all inputs, variables and expressions are set. imagebis->UpdateOutputInformation(); //imibj for (unsigned int j=0; jGetNumberOfComponentsPerPixel(); j++) { std::stringstream sstm; adhocStruct ahc; sstm << varName << "b" << (j+1); ahc.name = sstm.str(); ahc.type = 5; ahc.info[0] = idx; // Input image #ID ahc.info[1] = j; // Band #ID m_VAllowedVarNameAuto.push_back(ahc); } //imibjNkxp for (unsigned int j=0; jGetNumberOfComponentsPerPixel(); j++) for(unsigned int x=0; x<=m_SizeNeighbourhood; x++) for(unsigned int y=0; y<=m_SizeNeighbourhood; y++) { std::stringstream sstm; adhocStruct ahc; sstm << varName << "b" << (j+1) << "N" << 2*x+1 << "x" << 2*y+1; ahc.name = sstm.str(); ahc.type = 6; ahc.info[0] = idx; // Input image #ID ahc.info[1] = j; // Band #ID ahc.info[2] = 2*x+1; // Size x direction (matrix convention = cols) ahc.info[3] = 2*y+1; // Size y direction (matrix convention = rows) m_VAllowedVarNameAuto.push_back(ahc); } //imibjSTATS std::vector< std::string > statsNames; statsNames.push_back("Mini"); statsNames.push_back("Maxi"); statsNames.push_back("Mean"); statsNames.push_back("Sum"); statsNames.push_back("Var"); for (unsigned int j=0; jGetNumberOfComponentsPerPixel(); j++) for (unsigned int t=0; t TImage * BandMathXImageFilter ::GetNthInput(DataObjectPointerArraySizeType idx) { return const_cast(this->GetInput(idx)); } template< typename TImage > void BandMathXImageFilter ::SetManyExpressions(bool flag) { m_ManyExpressions = flag; } template< typename TImage > void BandMathXImageFilter ::SetExpression(const std::string& expression) { std::string expressionToBePushed = expression; if (expression.find(";") != std::string::npos) { std::ostringstream oss; oss << "cat("; for(unsigned int i=0; i < expression.size(); ++i) if (expression[i] == ';') oss << ","; else oss << expression[i]; oss << ")"; expressionToBePushed = oss.str(); } if (m_ManyExpressions) m_Expression.push_back(expressionToBePushed); else if (m_Expression.size() == 0) m_Expression.push_back(expressionToBePushed); if (m_Expression.size()>1) this->SetNthOutput( (DataObjectPointerArraySizeType) (m_Expression.size()) -1, ( TImage::New() ).GetPointer() ); this->Modified(); } template< typename TImage > void BandMathXImageFilter ::SetMatrix(const std::string& name, const std::string& definition) { for(unsigned int i=0; i > mat; std::istringstream iss( def ); std::string rows; while (std::getline( iss, rows, ';' ) ) { mat.push_back(std::vector(0)); std::istringstream iss2( rows ); std::string elmt; while (std::getline( iss2, elmt, ',' ) ) { std::istringstream iss3( elmt ); double val; iss3 >> val; mat.back().push_back(val); } } //Check dimensions of the matrix for (unsigned int i=0; i void BandMathXImageFilter ::SetConstant(const std::string& name, double value) { for(unsigned int i=0; i void BandMathXImageFilter ::ExportContext(const std::string& filename) { std::vector< std::string > vectI,vectF,vectM, vectFinal; for(unsigned int i=0; i void BandMathXImageFilter ::ImportContext(const std::string& filename) { std::ifstream importFile(filename.c_str(), std::ios::in); std::string wholeline,line,name,matrixdef; int pos,pos2,lineID=0,nbSuccesses=0; double value; if(importFile) { while(std::getline(importFile,wholeline)) { lineID++; pos = wholeline.find_first_not_of(' '); if (pos != (int) std::string::npos) { line = wholeline.substr(pos); if ( (line[0] == '#') && ((line[1] == 'I') || (line[1] == 'i') || (line[1] == 'F') || (line[1] == 'f')) ) { pos = line.find_first_not_of(' ',2); if (pos == (int) std::string::npos) itkExceptionMacro(<< "In file '"<< filename << "', line " << lineID << " : please, set the name and the value of the constant." << std::endl); std::string sub = line.substr(pos); pos = sub.find_first_of(' '); name = sub.substr(0,pos); if (sub.find_first_of('{',pos) != std::string::npos) itkExceptionMacro(<< "In file '"<< filename << "', line " << lineID << " : symbol #F found, but find vector/matrix definition. Please, set an integer or a float number." << std::endl); if (sub.find_first_not_of(' ',pos) == std::string::npos ) itkExceptionMacro(<< "In file '"<< filename << "', line " << lineID << " : please, set the value of the constant." << std::endl) std::istringstream iss( sub.substr(pos) ); iss >> value; SetConstant(name,value); nbSuccesses++; } else if ( (line[0] == '#') && ((line[1] == 'M') || (line[1] == 'm')) ) { pos = line.find_first_not_of(' ',2); if (pos == (int) std::string::npos) itkExceptionMacro(<< "In file '"<< filename << "', line " << lineID << " : please, set the name and the definition of the vector/matrix." << std::endl); std::string sub = line.substr(pos); pos = sub.find_first_of(' '); name = sub.substr(0,pos); pos2 = sub.find_first_of('{'); if (pos2 != (int) std::string::npos) matrixdef = sub.substr(pos2); else itkExceptionMacro(<< "In file '"<< filename << "', line " << lineID << " : symbol #M found, but couldn't not find vector/matrix definition." << std::endl); SetMatrix(name,matrixdef); nbSuccesses++; } else if ( (line[0] == '#') && ((line[1] == 'E') || (line[1] == 'e')) ) { pos = line.find_first_not_of(' ',2); if (pos == (int) std::string::npos) itkExceptionMacro(<< "In file '"<< filename << "', line " << lineID << " : symbol #E found, but couldn't not find any expression." << std::endl); std::string sub = line.substr(pos); SetExpression(sub); nbSuccesses++; } } }//while importFile.close(); if (nbSuccesses == 0) itkExceptionMacro(<< "No constant or expression could be set; please, ensure that the file '" << filename << "' is correct." << std::endl); } else itkExceptionMacro(<< "Could not open " << filename << "." << std::endl); } template< typename TImage > std::string BandMathXImageFilter ::GetExpression(int IDExpression) const { return m_Expression[IDExpression]; } template< typename TImage > std::vector BandMathXImageFilter ::GetVarNames() const { std::vector res; for(int y=0; y void BandMathXImageFilter ::AddVariable(adhocStruct &ahc) { bool found=false; for(unsigned int i=0; i void BandMathXImageFilter ::PrepareParsers() { if (m_Expression.size() == 0) itkExceptionMacro(<< "No expression set; please set at least one expression." << std::endl); // Generate variables names m_VVarName.clear(); m_VNotAllowedVarName.clear(); m_VFinalAllowedVarName.clear(); // m_VFinalAllowedVarName = m_VAllowedVarNameAuto + m_VAllowedVarNameAddedByUser // m_VFinalAllowedVarName = variable names dictionary for(unsigned int i=0; iSetExpr(this->GetExpression(IDExpression)); mup::var_maptype vmap = dummyParser->GetExprVar(); for (mup::var_maptype::iterator item = vmap.begin(); item!=vmap.end(); ++item) { bool OK=false; int i=0; while( ( !OK ) && (i < (int) m_VFinalAllowedVarName.size()) ) { if (item->first == m_VFinalAllowedVarName[i].name) OK=true; else i++; } if (OK) {AddVariable(m_VFinalAllowedVarName[i]); } else { adhocStruct ahc; ahc.name = item->first; m_VNotAllowedVarName.push_back(ahc); } } }// At this step, m_VVarName has been built //Checking formulas consistency if (m_VNotAllowedVarName.size()>0) { std::stringstream sstm; sstm << "Following variables not allowed : "; for(unsigned int i=0; iGetNumberOfThreads(); for (unsigned int k=0 ; k parserList; for (unsigned int i=0 ; iGetNumberOfInputs(); RadiusType dummyRadius; dummyRadius[0]=1; dummyRadius[1]=1; m_NeighExtremaSizes.resize(nbInputImages,dummyRadius); //Reset for(unsigned int i=0; iGetNthInput(m_AImage[i][j].info[0])->GetSpacing(); m_AImage[i][j].value = ValueType(static_cast(spacing[0])); } if (m_AImage[i][j].type == 3) //imiPhyY { SpacingType spacing = this->GetNthInput(m_AImage[i][j].info[0])->GetSpacing(); m_AImage[i][j].value = ValueType(static_cast(spacing[1])); } if (m_AImage[i][j].type == 4 ) // vector { unsigned int nbBands = this->GetNthInput(m_AImage[i][j].info[0])->GetNumberOfComponentsPerPixel(); m_AImage[i][j].value = ValueType(1,nbBands,initValue); } if (m_AImage[i][j].type == 5 ) // pixel { m_AImage[i][j].value = ValueType(initValue); } if (m_AImage[i][j].type == 6 ) // neighborhood { m_AImage[i][j].value = ValueType(m_AImage[i][j].info[3],m_AImage[i][j].info[2],initValue); //m_AImage[i][j].info[0] = Image ID bool found = false; for (unsigned int r=0; rDefineVar(m_AImage[i][j].name, &(m_AImage[i][j].value)); } initValue += 0.001; if (initValue>1.0) initValue=0.1; } } // Set expressions for (unsigned int k=0 ; kSetExpr(m_Expression[i]); } } } template< typename TImage > void BandMathXImageFilter ::PrepareParsersGlobStats() { // Must instantiate stats variables of the parsers // Note : at this stage, inputs have already been set to largest possible regions. for (unsigned int i=0; iSetInput( this->GetNthInput(m_StatsVarDetected[i]) ); filter->Update(); PixelType pix; //Variable length vector MatrixType mat; for(unsigned int t=0; tGetMinimum(); for (int b=0; b<(int) pix.GetSize(); b++) // for each band if (m_AImage[t][v].info[1] == b) // info[1] : band ID m_AImage[t][v].value = pix[b]; break; case 1: // maxi pix = filter->GetMaximum(); for (int b=0; b<(int) pix.GetSize(); b++) // for each band if (m_AImage[t][v].info[1] == b) // info[1] : band ID m_AImage[t][v].value = pix[b]; break; case 2: // mean pix = filter->GetMean(); for (int b=0; b<(int) pix.GetSize(); b++) // for each band if (m_AImage[t][v].info[1] == b) // info[1] : band ID m_AImage[t][v].value = pix[b]; break; break; case 3: // sum pix = filter->GetSum(); for (int b=0; b<(int) pix.GetSize(); b++) // for each band if (m_AImage[t][v].info[1] == b) // info[1] : band ID m_AImage[t][v].value = pix[b]; break; case 4: // stddev mat = filter->GetCovariance(); for (int b=0; b<(int) mat.Cols(); b++) // for each band if (m_AImage[t][v].info[1] == b) // info[1] : band ID m_AImage[t][v].value = mat(b,b); break; } } } } template< typename TImage > void BandMathXImageFilter< TImage > ::OutputsDimensions() { this->SetNumberOfRequiredOutputs((int) m_Expression.size()); m_outputsDimensions.clear(); for(int i=0; i<(int) m_Expression.size(); ++i) { ValueType value = m_VParser[0][i]->EvalRef(); switch (value.GetType()) { //ValueType case 'b': itkExceptionMacro(<< "Booleans not supported." << std::endl); break; case 'i': m_outputsDimensions.push_back(1); break; case 'f': m_outputsDimensions.push_back(1); break; case 'c': itkExceptionMacro(<< "Complex numbers not supported." << std::endl); break; case 'm': { const mup::matrix_type &vect = value.GetArray(); if ( vect.GetRows() == 1 ) //Vector m_outputsDimensions.push_back(vect.GetCols()); else //Matrix itkExceptionMacro(<< "Result of the evaluation can't be a matrix." << std::endl); } break; default: itkExceptionMacro(<< "Unknown output type : "<< value.GetType() << std::endl); break; } //std::cout << "Type = " << value.GetType() << " dimension = " << m_outputsDimensions.back() << std::endl; } } template< typename TImage > void BandMathXImageFilter< TImage > ::CheckImageDimensions(void) { // Check if input image dimensions match unsigned int nbInputImages = this->GetNumberOfInputs(); unsigned int inputSize[2]; inputSize[0] = this->GetNthInput(0)->GetLargestPossibleRegion().GetSize(0); inputSize[1] = this->GetNthInput(0)->GetLargestPossibleRegion().GetSize(1); for(unsigned int p = 1; p < nbInputImages; p++) if((inputSize[0] != this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(0)) || (inputSize[1] != this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(1))) { itkExceptionMacro(<< "Input images must have the same dimensions." << std::endl << "band #1 is [" << inputSize[0] << ";" << inputSize[1] << "]" << std::endl << "band #" << p+1 << " is [" << this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(0) << ";" << this->GetNthInput(p)->GetLargestPossibleRegion().GetSize(1) << "]"); } } template< typename TImage > void BandMathXImageFilter< TImage > ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); CheckImageDimensions(); PrepareParsers(); if (globalStatsDetected()) PrepareParsersGlobStats(); OutputsDimensions(); typedef itk::ImageBase< TImage::ImageDimension > ImageBaseType; typename ImageBaseType::Pointer outputPtr; int i=0; for ( itk::OutputDataObjectIterator it(this); !it.IsAtEnd(); i++, it++ ) { // Check whether the output is an image of the appropriate // dimension (use ProcessObject's version of the GetInput() // method since it returns the input as a pointer to a // DataObject as opposed to the subclass version which // static_casts the input to an TImage). outputPtr = dynamic_cast< ImageBaseType * >( it.GetOutput() ); if ( outputPtr ) outputPtr->SetNumberOfComponentsPerPixel(m_outputsDimensions[i]); } } template< typename TImage > void BandMathXImageFilter< TImage > ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); for(unsigned int i=0; iGetNumberOfInputs() ) { // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast( this->GetNthInput(m_NeighDetected[i]) ); ImageRegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius( m_NeighExtremaSizes[m_NeighDetected[i]] ); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg,msg2; msg << static_cast(this->GetNameOfClass()) << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); msg2 << "Requested region is (at least partially) outside the largest possible region (input #" << m_NeighDetected[i] << ")."; e.SetDescription(msg2.str().c_str()); e.SetDataObject(inputPtr); throw e; } } else itkExceptionMacro(<< "Requested input #" << m_NeighDetected[i] << ", but only " << this->GetNumberOfInputs() << " inputs are available." << std::endl); } template< typename TImage > void BandMathXImageFilter ::BeforeThreadedGenerateData() { unsigned int nbThreads = this->GetNumberOfThreads(); // Allocate and initialize the thread temporaries m_ThreadUnderflow.SetSize(nbThreads); m_ThreadUnderflow.Fill(0); m_ThreadOverflow.SetSize(nbThreads); m_ThreadOverflow.Fill(0); } template< typename TImage > void BandMathXImageFilter ::AfterThreadedGenerateData() { unsigned int nbThreads = this->GetNumberOfThreads(); unsigned int i; m_UnderflowCount = 0; m_OverflowCount = 0; // Accumulate counts for each thread for(i = 0; i < nbThreads; ++i) { m_UnderflowCount += m_ThreadUnderflow[i]; m_OverflowCount += m_ThreadOverflow[i]; } if((m_UnderflowCount != 0) || (m_OverflowCount!=0)) { std::stringstream sstm; sstm << std::endl << "The Following Parsed Expression : "; for(unsigned int t=0; tGetExpression(t) << std::endl; sstm << "Generated " << m_UnderflowCount << " Underflow(s) " << "And " << m_OverflowCount << " Overflow(s) " << std::endl << "The Parsed Expression, The Inputs And The Output " << "Type May Be Incompatible !"; otbWarningMacro(<< sstm.str()); } } template< typename TImage > void BandMathXImageFilter ::ThreadedGenerateData(const ImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { ValueType value; unsigned int nbInputImages = this->GetNumberOfInputs(); //----------------- --------- -----------------// //----------------- Iterators -----------------// //----------------- --------- -----------------// typedef itk::ImageScanlineConstIterator ImageScanlineConstIteratorType; typedef itk::ImageScanlineIterator ImageScanlineIteratorType; typedef itk::ImageRegionConstIteratorWithOnlyIndex IndexIteratorType; std::vector< ImageScanlineConstIteratorType > Vit; Vit.resize(nbInputImages); for(unsigned int j=0; j < nbInputImages; ++j) Vit[j] = ImageScanlineConstIteratorType (this->GetNthInput(j), outputRegionForThread); std::vector< ImageScanlineIteratorType > VoutIt; VoutIt.resize(m_Expression.size()); for(unsigned int j=0; j < VoutIt.size(); ++j) VoutIt[j] = ImageScanlineIteratorType (this->GetOutput(j), outputRegionForThread); //Special case : neighborhoods std::vector< itk::ConstNeighborhoodIterator > VNit; for(unsigned int j=0; j(radius, this->GetNthInput(m_VVarName[j].info[0]),outputRegionForThread)); // info[0] = Input image ID VNit.back().NeedToUseBoundaryConditionOn(); } // Index only iterator IndexIteratorType indexIterator(this->GetNthInput(0), outputRegionForThread); // Support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // iterator on variables typename std::vector::iterator iterVarStart = m_AImage[threadId].begin(); typename std::vector::iterator iterVarEnd = m_AImage[threadId].end(); typename std::vector::iterator iterVar = iterVarStart; // temporary output vectors std::vector tmpOutputs(m_Expression.size()); for(unsigned int k=0; ktype) { case 0 : //idxX iterVar->value = static_cast(indexIterator.GetIndex()[0]); break; case 1 : //idxY iterVar->value = static_cast(indexIterator.GetIndex()[1]); break; case 2 : //Spacing X (imiPhyX) //Nothing to do (already set inside BeforeThreadedGenerateData)" break; case 3 : //Spacing Y (imiPhyY) //Nothing to do (already set inside BeforeThreadedGenerateData)" break; case 4 : //vector // iterVar->info[0] : Input image #ID for(int p=0; p < iterVar->value.GetCols(); ++p) iterVar->value.At(0,p) = Vit[iterVar->info[0]].Get()[p]; break; case 5 : //pixel // iterVar->info[0] : Input image #ID // iterVar->info[1] : Band #ID iterVar->value = Vit[iterVar->info[0]].Get()[iterVar->info[1]]; break; case 6 : //neighborhood // iterVar->info[1] : Band #ID if (iterVar->info[2]*iterVar->info[3] != (int) VNit[ngbhNameIndex].Size() ) itkExceptionMacro(<< "Size of muparserx variable is different from its related otb neighborhood iterator") index=0; for(int rows=0; rowsinfo[3]; ++rows) for(int cols=0; colsinfo[2]; ++cols) { iterVar->value.At(rows,cols) = VNit[ngbhNameIndex].GetPixel(index)[iterVar->info[1]]; index++; } ngbhNameIndex++; break; case 7 : //Nothing to do : user defined variable or constant, which have already been set inside PrepareParsers (see above) break; case 8 : //Nothing to do : variable has already been set inside PrepareParsersGlobStats method (see above) break; default : itkExceptionMacro(<< "Type of the variable is unknown"); break; } iterVar++; }//End while on vars //----------------- ----------- -----------------// //----------------- Evaluations -----------------// //----------------- ----------- -----------------// for(unsigned int IDExpression=0; IDExpressionEvalRef(); switch (value.GetType()) { //ValueType case 'i': tmpOutputs[IDExpression][0] = value.GetInteger(); break; case 'f': tmpOutputs[IDExpression][0] = value.GetFloat(); break; case 'c': itkExceptionMacro(<< "Complex numbers are not supported." << std::endl); break; case 'm': { const mup::matrix_type &vect = value.GetArray(); if ( vect.GetRows() == 1 ) //Vector for(int p=0; p::NonpositiveMin())) { tmpOutputs[IDExpression][p] = itk::NumericTraits::NonpositiveMin(); m_ThreadUnderflow[threadId]++; } // Case value is equal to inf or superior to the maximum value // allowed by the PixelValueType cast else if (tmpOutputs[IDExpression][p] > double(itk::NumericTraits::max())) { tmpOutputs[IDExpression][p] = itk::NumericTraits::max(); m_ThreadOverflow[threadId]++; } } VoutIt[IDExpression].Set(tmpOutputs[IDExpression]); } for(unsigned int j=0; j < nbInputImages; ++j) { ++Vit[j]; } for(unsigned int j=0; j < m_Expression.size(); ++j) { ++VoutIt[j]; } for(unsigned int j=0; j < VNit.size(); ++j) { ++VNit[j]; } ++indexIterator; progress.CompletedPixel(); } for(unsigned int j=0; j < nbInputImages; ++j) { Vit[j].NextLine(); } for(unsigned int j=0; j < m_Expression.size(); ++j) { VoutIt[j].NextLine(); } } } }// end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParserX/include/otbParserX.h000066400000000000000000000060451301006202600250410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbParserX_h #define otbParserX_h #include "itkLightObject.h" #include "itkObjectFactory.h" #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++11-extensions" #include "mpParser.h" #pragma GCC diagnostic pop #else #include "mpParser.h" #endif namespace otb { class ParserXImpl; /** \class ParserX * \brief Definition of the standard floating point parser. * Standard implementation of the mathematical expressions parser. * * \sa BandMathImageFilter * * * \ingroup OTBMathParserX */ class ITK_EXPORT ParserX : public itk::LightObject { public: /** Standard class typedefs. */ typedef ParserX Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** New macro for creation of through a Smart Pointer */ itkNewMacro(Self); /** Run-time type information (and related methods) */ itkTypeMacro(ParserX, itk::LightObject); /** Convenient type definitions */ typedef ParserX ParserXType; typedef mup::Value ValueType; typedef mup::IValue IValueType; /** Set the expression to be parsed */ virtual void SetExpr(const std::string & Expression); /** Trigger the parsing */ ValueType Eval(); /** Trigger the parsing but return a const ref */ const IValueType & EvalRef(); /** Define a variable */ void DefineVar(const std::string &sName, ValueType *fVar); /** Define a constant */ //void DefineConst(const std::string &sName, ValueType *fVar); /** Clear all the defined variables */ void ClearVar(); /** Return the expression to be parsed */ const std::string& GetExpr() const; /** Return the list of variables */ const mup::var_maptype& GetVar() const; /** Return the list of expression variables (only make sense after having set up an expression) */ const mup::var_maptype& GetExprVar() const; /** Check Expression **/ bool CheckExpr(); protected: ParserX(); ~ParserX() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ParserX(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented typedef itk::SmartPointer ParserXImplPtr; ParserXImplPtr m_InternalParserX; }; // end class }//end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParserX/include/otbParserXPlugins.h000066400000000000000000000363701301006202600264070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbParserXPlugins_h #define otbParserXPlugins_h #include "itkMacro.h" #include "otbMath.h" #include "mpParser.h" #include namespace otb { class bands : public mup::ICallback { public: bands():ICallback(mup::cmFUNC, "bands", 2) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "bands - A bands selector"; } mup::IToken* Clone() const ITK_OVERRIDE { return new bands(*this); } }; class dotpr : public mup::ICallback { public: dotpr():ICallback(mup::cmFUNC, "dotpr", -1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "dotpr(m1,m2) - A vector/matrix dot product"; } mup::IToken* Clone() const ITK_OVERRIDE { return new dotpr(*this); } }; class ElementWiseDivision : public mup::IOprtBin { public: ElementWiseDivision():IOprtBin(_T("div"), (int)(mup::prMUL_DIV), mup::oaLEFT) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return _T("x div y - Element-wise division (vectors / matrices)"); } mup::IToken* Clone() const ITK_OVERRIDE { return new ElementWiseDivision(*this); } }; class DivisionByScalar : public mup::IOprtBin { public: DivisionByScalar():IOprtBin(_T("dv"), (int)(mup::prMUL_DIV), mup::oaLEFT) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return _T("x dv y - division of vectors / matrices by a scalar"); } mup::IToken* Clone() const ITK_OVERRIDE { return new DivisionByScalar(*this); } }; class ElementWiseMultiplication : public mup::IOprtBin { public: ElementWiseMultiplication():IOprtBin(_T("mult"), (int)(mup::prMUL_DIV), mup::oaLEFT) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return _T("x mult y - Element wise multiplication (vectors / matrices)"); } mup::IToken* Clone() const ITK_OVERRIDE { return new ElementWiseMultiplication(*this); } }; class MultiplicationByScalar : public mup::IOprtBin { public: MultiplicationByScalar():IOprtBin(_T("mlt"), (int)(mup::prMUL_DIV), mup::oaLEFT) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return _T("x mlt y - multiplication of vectors / matrices by a scalar"); } mup::IToken* Clone() const ITK_OVERRIDE { return new MultiplicationByScalar(*this); } }; class ElementWisePower : public mup::IOprtBin { public: ElementWisePower():IOprtBin(_T("pow"), (int) mup::prPOW, mup::oaRIGHT) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return _T("pow - Power for noncomplex vectors & matrices"); } mup::IToken* Clone() const ITK_OVERRIDE { return new ElementWisePower(*this); } }; class PowerByScalar : public mup::IOprtBin { public: PowerByScalar():IOprtBin(_T("pw"), (int)(mup::prMUL_DIV), mup::oaLEFT) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return _T("x pw y - power of vectors / matrices by a scalar"); } mup::IToken* Clone() const ITK_OVERRIDE { return new PowerByScalar(*this); } }; class ndvi : public mup::ICallback { public: ndvi():ICallback(mup::cmFUNC, "ndvi", 2) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "NDVI - Normalized Difference Vegetation Index"; } mup::IToken* Clone() const ITK_OVERRIDE { return new ndvi(*this); } }; class cat : public mup::ICallback { public: cat():ICallback(mup::cmFUNC, "cat", -1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "cat(m1,m2) - Values concatenation"; } mup::IToken* Clone() const ITK_OVERRIDE { return new cat(*this); } }; class mean : public mup::ICallback { public: mean():ICallback(mup::cmFUNC, "mean", -1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "mean(m1,m2,..) - mean of each neighborhood"; } mup::IToken* Clone() const ITK_OVERRIDE { return new mean(*this); } }; class var : public mup::ICallback { public: var():ICallback(mup::cmFUNC, "var", -1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "var(m1,m2,..) - variance of each neighborhood"; } mup::IToken* Clone() const ITK_OVERRIDE { return new var(*this); } }; class corr : public mup::ICallback { public: corr():ICallback(mup::cmFUNC, "corr", 2) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "corr(m1,m2) - variance of two variables m1 and m2"; } mup::IToken* Clone() const ITK_OVERRIDE { return new corr(*this); } }; class median : public mup::ICallback { public: median():ICallback(mup::cmFUNC, "median", -1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "median(m1,m2,..) - median value of each neighborhood"; } mup::IToken* Clone() const ITK_OVERRIDE { return new median(*this); } }; class maj : public mup::ICallback { public: maj():ICallback(mup::cmFUNC, "maj", -1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "maj(m1,m2,..) - majority value of each neighborhood"; } mup::IToken* Clone() const ITK_OVERRIDE { return new maj(*this); } }; //--------------------------------------------------------------------------------------------------------// class vnorm : public mup::ICallback { public: vnorm():ICallback(mup::cmFUNC, "vnorm", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vnorm(v1) - Norm for a vector : sqrt(sum of squared elements); works also with matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vnorm(*this); } }; class vmin : public mup::ICallback { public: vmin():ICallback(mup::cmFUNC, "vmin", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vmin(m1) - overall minimum"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vmin(*this); } }; class vmax : public mup::ICallback { public: vmax():ICallback(mup::cmFUNC, "vmax", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vmax(m1) - overall maximun"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vmax(*this); } }; class vect2scal : public mup::ICallback { public: vect2scal():ICallback(mup::cmFUNC, "vect2scal", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vect2scal - Convert one dimensional vector to scalar"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vect2scal(*this); } }; class vcos : public mup::ICallback { public: vcos():ICallback(mup::cmFUNC, "vcos", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vcos - Cosinus for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vcos(*this); } }; class vacos : public mup::ICallback { public: vacos():ICallback(mup::cmFUNC, "vacos", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vacos - Arccosinus for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vacos(*this); } }; class vsin : public mup::ICallback { public: vsin():ICallback(mup::cmFUNC, "vsin", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vsin - Sinus for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vsin(*this); } }; class vasin : public mup::ICallback { public: vasin():ICallback(mup::cmFUNC, "vasin", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vasin - Arcsinus for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vasin(*this); } }; class vtan : public mup::ICallback { public: vtan():ICallback(mup::cmFUNC, "vtan", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vtan - Tangent for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vtan(*this); } }; class vatan : public mup::ICallback { public: vatan():ICallback(mup::cmFUNC, "vatan", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vatan - Arctangent for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vatan(*this); } }; class vtanh : public mup::ICallback { public: vtanh():ICallback(mup::cmFUNC, "vtanh", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vtanh - Hyperbolic tangent for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vtanh(*this); } }; class vsinh : public mup::ICallback { public: vsinh():ICallback(mup::cmFUNC, "vsinh", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vsinh - Hyperbolic sinus for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vsinh(*this); } }; class vcosh : public mup::ICallback { public: vcosh():ICallback(mup::cmFUNC, "vcosh", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vcosh - Hyperbolic cosinus for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vcosh(*this); } }; class vlog : public mup::ICallback { public: vlog():ICallback(mup::cmFUNC, "vlog", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vlog - Log for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vlog(*this); } }; class vlog10 : public mup::ICallback { public: vlog10():ICallback(mup::cmFUNC, "vlog10", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vlog10 - Log10 for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vlog10(*this); } }; class vabs : public mup::ICallback { public: vabs():ICallback(mup::cmFUNC, "vabs", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vabs - Absolute value for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vabs(*this); } }; class vexp : public mup::ICallback { public: vexp():ICallback(mup::cmFUNC, "vexp", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vexp - Exponential for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vexp(*this); } }; class vsqrt : public mup::ICallback { public: vsqrt():ICallback(mup::cmFUNC, "vsqrt", 1) {} void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) ITK_OVERRIDE; const mup::char_type* GetDesc() const ITK_OVERRIDE { return "vsqrt - Sqrt for noncomplex vectors & matrices"; } mup::IToken* Clone() const ITK_OVERRIDE { return new vsqrt(*this); } }; }//end namespace otb #endif OTB-release-5.8/Modules/Filtering/MathParserX/otb-module.cmake000066400000000000000000000003451301006202600242220ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBMathParserX DEPENDS OTBCommon OTBITK OTBMuParserX OTBStatistics TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/MathParserX/src/000077500000000000000000000000001301006202600217365ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParserX/src/CMakeLists.txt000066400000000000000000000004531301006202600245000ustar00rootroot00000000000000set(OTBMathParserX_SRC otbParserX.cxx otbParserXPlugins.cxx ) add_library(OTBMathParserX ${OTBMathParserX_SRC}) target_link_libraries(OTBMathParserX ${OTBCommon_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBMuParserX_LIBRARIES} ${OTBStatistics_LIBRARIES} ) otb_module_target(OTBMathParserX) OTB-release-5.8/Modules/Filtering/MathParserX/src/otbParserX.cxx000066400000000000000000000176241301006202600245650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMath.h" #include "otbMacro.h" #include "otbParserX.h" #include "otbParserXPlugins.h" namespace otb { class ITK_EXPORT ParserXImpl : public itk::LightObject { public: /** Standard class typedefs. */ typedef ParserXImpl Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** New macro for creation of through a Smart Pointer */ itkNewMacro(Self); /** Run-time type information (and related methods) */ itkTypeMacro(ParserXImpl, itk::LightObject); /** Convenient type definitions */ typedef mup::Value ValueType; typedef mup::IValue IValueType; typedef mup::ParserError ExceptionType; /** Initialize user defined constants */ virtual void InitConst() { m_MuParserX.DefineConst( "log2e", CONST_LOG2E ); m_MuParserX.DefineConst( "log10e", CONST_LOG10E ); m_MuParserX.DefineConst( "ln2", CONST_LN2 ); m_MuParserX.DefineConst( "ln10", CONST_LN10 ); m_MuParserX.DefineConst( "euler", CONST_EULER ); } /** Initialize user defined functions */ virtual void InitFun() { m_MuParserX.DefineFun(new ndvi); m_MuParserX.DefineFun(new dotpr); m_MuParserX.DefineFun(new bands); m_MuParserX.DefineFun(new cat); m_MuParserX.DefineFun(new mean); m_MuParserX.DefineFun(new var); m_MuParserX.DefineFun(new median); m_MuParserX.DefineFun(new maj); m_MuParserX.DefineFun(new corr); m_MuParserX.DefineOprt(new ElementWiseDivision); m_MuParserX.DefineOprt(new ElementWiseMultiplication); m_MuParserX.DefineOprt(new ElementWisePower); m_MuParserX.DefineOprt(new DivisionByScalar); m_MuParserX.DefineOprt(new MultiplicationByScalar); m_MuParserX.DefineOprt(new PowerByScalar); m_MuParserX.DefineFun(new vnorm); m_MuParserX.DefineFun(new vmin); m_MuParserX.DefineFun(new vmax); m_MuParserX.DefineFun(new vect2scal); m_MuParserX.DefineFun(new vcos); m_MuParserX.DefineFun(new vacos); m_MuParserX.DefineFun(new vasin); m_MuParserX.DefineFun(new vatan); m_MuParserX.DefineFun(new vsin); m_MuParserX.DefineFun(new vtan); m_MuParserX.DefineFun(new vtanh); m_MuParserX.DefineFun(new vsinh); m_MuParserX.DefineFun(new vcosh); m_MuParserX.DefineFun(new vlog); m_MuParserX.DefineFun(new vlog10); m_MuParserX.DefineFun(new vabs); m_MuParserX.DefineFun(new vexp); m_MuParserX.DefineFun(new vsqrt); } /** Set the expression to be parsed */ virtual void SetExpr(const std::string & Expression) { m_MuParserX.SetExpr(Expression); } /** Trigger the parsing */ ValueType Eval() { //ParserX::ValueType result = 0.0; ValueType result = 0.0; try { result = m_MuParserX.Eval(); } catch(ExceptionType &e) { ExceptionHandler(e); } return result; } const IValueType & EvalRef() { try { return m_MuParserX.Eval(); } catch(ExceptionType &e) { ExceptionHandler(e); } return m_NullValue; } /** Define a variable */ void DefineVar(const std::string &sName, ValueType *fVar) { try { m_MuParserX.DefineVar(sName, mup::Variable(fVar)); } catch(ExceptionType &e) { ExceptionHandler(e); } } /** Define a constant */ /*void DefineConst(const std::string &sName, ValueType *fVar) { try { m_MuParserX.DefineConst(sName, mup::Variable(fVar)); } catch(ExceptionType &e) { ExceptionHandler(e); } }*/ /** Clear all the defined variables */ void ClearVar() { m_MuParserX.ClearVar(); } /** Return the expression to be parsed */ const std::string& GetExpr() const { return m_MuParserX.GetExpr(); } /** Return the list of variables */ const mup::var_maptype& GetVar() const { return m_MuParserX.GetVar(); } /** Return the list of expression variables (only make sense after having set up an expression) */ const mup::var_maptype& GetExprVar() const { try { return m_MuParserX.GetExprVar(); } catch(ExceptionType &e) { ExceptionHandler(e); } return m_MuParserX.GetExprVar(); } /** Check Expression **/ bool CheckExpr() { try { m_MuParserX.Eval(); } catch(ExceptionType &e) { ExceptionHandler(e); return false; } return true; } // Get the map with the functions /*ParserX::FunctionMapType GetFunList() const chris { ParserX::FunctionMapType output; const mu::funmap_type& funmap = m_MuParserX.GetFunDef(); mu::funmap_type::const_iterator funItem; for (funItem = funmap.begin(); funItem != funmap.end(); ++funItem) { output[funItem->first] = funItem->second.GetArgc(); } return output; }*/ /** Convert parser specific exception into itk exception */ virtual void ExceptionHandler(ExceptionType &e) const { itkExceptionMacro( << std::endl << "Message: " << e.GetMsg() << std::endl << "Formula: " << e.GetExpr() << std::endl << "Token: " << e.GetToken() << std::endl << "Position: " << e.GetPos() << std::endl << std::endl); // << "Errc: " << e.GetCode() << std::endl); } /** Convert parser specific exception into itk debug macro */ virtual void ExceptionHandlerDebug(ExceptionType &e) { ExceptionHandler(e); } protected: ParserXImpl() { m_NullValue = ValueType(0.0); InitFun(); InitConst(); } ~ParserXImpl() ITK_OVERRIDE { } void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: ParserXImpl(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented mup::ParserX m_MuParserX; ValueType m_NullValue; }; // end class void ParserX::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } ParserX::ParserX() : m_InternalParserX( ParserXImpl::New() ) { } ParserX::~ParserX() { } void ParserX::SetExpr(const std::string & Expression) { m_InternalParserX->SetExpr(Expression); } ParserX::ValueType ParserX::Eval() { return m_InternalParserX->Eval(); } const ParserX::IValueType & ParserX::EvalRef() { return m_InternalParserX->EvalRef(); } void ParserX::DefineVar(const std::string &sName, ValueType *fVar) { m_InternalParserX->DefineVar(sName, fVar); } void ParserX::ClearVar() { m_InternalParserX->ClearVar(); } bool ParserX::CheckExpr() { return m_InternalParserX->CheckExpr(); } const std::string& ParserX::GetExpr() const { return m_InternalParserX->GetExpr(); } // Get the map with the variables const mup::var_maptype& ParserX::GetVar() const { return m_InternalParserX->GetVar(); } /** Return the list of expression variables (only make sense after having set up an expression) */ const mup::var_maptype& ParserX::GetExprVar() const { return m_InternalParserX->GetExprVar(); } // Get the map with the functions /*ParserX::FunctionMapType ParserX::GetFunList() const chris { return m_InternalParserX->GetFunList(); }*/ }//end namespace otb OTB-release-5.8/Modules/Filtering/MathParserX/src/otbParserXPlugins.cxx000066400000000000000000000670761301006202600261350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbParserXPlugins.h" #include "otbMath.h" #include "itkNumericTraits.h" #include namespace otb { void bands::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) { if (a_iArgc != 2) return; assert(a_pArg[0]->GetType()=='m'); assert(a_pArg[1]->GetType()=='m'); // Get the argument from the argument input vector mup::matrix_type a = a_pArg[0]->GetArray(); mup::matrix_type b = a_pArg[1]->GetArray(); int nbcols = b.GetCols(); assert(a.GetRows()==1); // Bands selection is done on a row vector assert(b.GetRows()==1); // Bands selection is done by a row vector mup::matrix_type res(1,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector mup::matrix_type m1 = a_pArg[0]->GetArray(); int nbrows = m1.GetRows(); int nbcols = m1.GetCols(); mup::matrix_type res(1,a_iArgc-1,0.); for (int k=1; kGetType()=='m'); mup::matrix_type m2 = a_pArg[k]->GetArray(); assert(m2.GetRows() == nbrows); assert(m2.GetCols() == nbcols); for (int i=0; iGetType()=='m'); assert(a_pArg[1]->GetType()=='m'); const mup::matrix_type a = a_pArg[0]->GetArray(); const mup::matrix_type b = a_pArg[1]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); assert(nbrows == b.GetRows()); assert(nbcols == b.GetCols()); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; k 1e-9); res.At(p,k) = a.At(p,k).GetFloat() / b.At(p,k).GetFloat(); } // The return value is passed by writing it to the reference ret *ret = res; } void DivisionByScalar::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) { assert(a_pArg[0]->GetType()=='m'); const mup::matrix_type a = a_pArg[0]->GetArray(); mup::matrix_type b; double scalar = 0; switch (a_pArg[1]->GetType()) { case 'i': scalar = (double) a_pArg[1]->GetInteger(); break; case 'f': scalar = a_pArg[1]->GetFloat(); break; case 'm': b = a_pArg[1]->GetArray(); assert(b.GetRows() == 1); assert(b.GetCols() == 1); scalar = b.At(0,0); break; } assert(vcl_abs(scalar) > 1e-9); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); assert(a_pArg[1]->GetType()=='m'); const mup::matrix_type a = a_pArg[0]->GetArray(); const mup::matrix_type b = a_pArg[1]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); assert(nbrows == b.GetRows()); assert(nbcols == b.GetCols()); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); const mup::matrix_type a = a_pArg[0]->GetArray(); mup::matrix_type b; double scalar(1.); switch (a_pArg[1]->GetType()) { case 'i': scalar = (double) a_pArg[1]->GetInteger(); break; case 'f': scalar = a_pArg[1]->GetFloat(); break; case 'm': b = a_pArg[1]->GetArray(); assert(b.GetRows() == 1); assert(b.GetCols() == 1); scalar = b.At(0,0); break; } int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); assert(a_pArg[1]->GetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); const mup::matrix_type b = a_pArg[1]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); assert(nbrows == b.GetRows()); assert(nbcols == b.GetCols()); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; k= 0 ); res.At(p,k) = vcl_pow(a.At(p,k).GetFloat(),b.At(p,k).GetFloat()); } // The return value is passed by writing it to the reference ret *ret = res; } void PowerByScalar::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) { assert(a_pArg[0]->GetType()=='m'); const mup::matrix_type a = a_pArg[0]->GetArray(); mup::matrix_type b; double scalar(1.); switch (a_pArg[1]->GetType()) { case 'i': scalar = (double) a_pArg[1]->GetInteger(); break; case 'f': scalar = a_pArg[1]->GetFloat(); break; case 'm': b = a_pArg[1]->GetArray(); assert(b.GetRows() == 1); assert(b.GetCols() == 1); scalar = b.At(0,0); break; } int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetFloat(); mup::float_type niri = a_pArg[1]->GetFloat(); // The return value is passed by writing it to the reference ret if ( vcl_abs(r + niri) < 1E-6 ) *ret = 0.; else *ret = (niri-r)/(niri+r); } void cat::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) { std::vector vect; int nbcols; mup::matrix_type m1; for (int k=0; kGetType()) { case 'm': m1 = a_pArg[k]->GetArray(); nbcols = m1.GetCols(); assert(m1.GetRows()==1); for (int j=0; jGetInteger()); break; case 'f': vect.push_back( (double) a_pArg[k]->GetFloat()); break; } } // The return value is passed by writing it to the reference ret mup::matrix_type res(1,vect.size(),0.); for (unsigned int j=0; j vect; int nbrows,nbcols; mup::matrix_type m1; double sum; for (int k=0; kGetType()) { case 'm': m1 = a_pArg[k]->GetArray(); nbrows = m1.GetRows(); nbcols = m1.GetCols(); sum=0.0; for (int i=0; iGetInteger()); break; case 'f': vect.push_back( (double) a_pArg[k]->GetFloat()); break; } } // The return value is passed by writing it to the reference ret mup::matrix_type res(1,vect.size(),0.); for (unsigned int j=0; j vect; int nbrows,nbcols; mup::matrix_type m1; double sum,mean; for (int k=0; kGetType()) { case 'm': m1 = a_pArg[k]->GetArray(); nbrows = m1.GetRows(); nbcols = m1.GetCols(); sum=0.0; for (int i=0; i(vect[j]); *ret = res; } void corr::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) { assert(a_pArg[0]->GetType()=='m'); assert(a_pArg[1]->GetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); const mup::matrix_type b = a_pArg[1]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); assert(nbrows == b.GetRows()); assert(nbcols == b.GetCols()); double mean1=0.0; for (int i=0; i vect,tempvect; int nbrows,nbcols; mup::matrix_type m1; for (int k=0; kGetType()) { case 'm': m1 = a_pArg[k]->GetArray(); nbrows = m1.GetRows(); nbcols = m1.GetCols(); for (int i=0; iGetInteger()); break; case 'f': vect.push_back( (double) a_pArg[k]->GetFloat()); break; } } // The return value is passed by writing it to the reference ret mup::matrix_type res(1,vect.size(),0.); for (unsigned int j=0; j(vect[j]); *ret = res; } void maj::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) { std::vector vect,tempvect; int nbrows,nbcols,score,bestScore,majElmt; mup::matrix_type m1; for (int k=0; kGetType()) { case 'm': m1 = a_pArg[k]->GetArray(); nbrows = m1.GetRows(); nbcols = m1.GetCols(); for (int i=0; i bestScore) { bestScore=score; majElmt=tempvect[t]; } score=0; } } vect.push_back( majElmt ); break; case 'i': vect.push_back( (double) a_pArg[k]->GetInteger()); break; case 'f': vect.push_back( (double) a_pArg[k]->GetFloat()); break; } } // The return value is passed by writing it to the reference ret mup::matrix_type res(1,vect.size(),0.); for (unsigned int j=0; j(vect[j]); *ret = res; } //--------------------------------------------------------------------------------------------------------// void vnorm::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) { // Check for arg length if(a_iArgc != 1) return; int nbrows,nbcols; mup::matrix_type m1; double sum=0.0; assert( a_iArgc==1 ); assert(a_pArg[0]->GetType()=='m'); m1 = a_pArg[0]->GetArray(); nbrows = m1.GetRows(); nbcols = m1.GetCols(); for (int i=0; i vect; double min; int nbrows,nbcols; mup::matrix_type m1; assert(a_pArg[0]->GetType()=='m'); min = itk::NumericTraits::max(); m1 = a_pArg[0]->GetArray(); nbrows = m1.GetRows(); nbcols = m1.GetCols(); for (int i=0; i vect; double max; int nbrows,nbcols; mup::matrix_type m1; assert(a_pArg[0]->GetType()=='m'); max = itk::NumericTraits::min(); m1 = a_pArg[0]->GetArray(); nbrows = m1.GetRows(); nbcols = m1.GetCols(); for (int i=0; i max ) max = m1.At(i,j).GetFloat(); // The return value is passed by writing it to the reference ret mup::matrix_type res(1,1,max); *ret = res; } void vect2scal::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) { if(a_iArgc != 1) return; assert(a_pArg[0]->GetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); assert(a.GetRows() == 1); assert(a.GetCols() == 1); mup::float_type res; res = a.At(0,0).GetFloat(); // The return value is passed by writing it to the reference ret *ret = res; } void vcos::Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) { if(a_iArgc != 1) return; assert(a_pArg[0]->GetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; kGetType()=='m'); // Get the argument from the argument input vector const mup::matrix_type a = a_pArg[0]->GetArray(); int nbrows = a.GetRows(); int nbcols = a.GetCols(); mup::matrix_type res(nbrows,nbcols,0.); for (int k=0; k= 0 ); res.At(p,k) = vcl_sqrt(a.At(p,k).GetFloat()); } // The return value is passed by writing it to the reference ret *ret = res; } }//end namespace otb OTB-release-5.8/Modules/Filtering/MathParserX/test/000077500000000000000000000000001301006202600221265ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MathParserX/test/CMakeLists.txt000066400000000000000000000026061301006202600246720ustar00rootroot00000000000000otb_module_test() set(OTBMathParserXTests otbParserXTest.cxx otbBandMathXImageFilter.cxx otbMathParserXTestDriver.cxx ) add_executable(otbMathParserXTestDriver ${OTBMathParserXTests}) target_link_libraries(otbMathParserXTestDriver ${OTBMathParserX-Test_LIBRARIES}) otb_module_target_label(otbMathParserXTestDriver) otb_add_test(NAME coTvParserX COMMAND otbMathParserXTestDriver otbParserXTest ) otb_add_test(NAME coTuParserX COMMAND otbMathParserXTestDriver otbParserXTestNew ) otb_add_test(NAME bfTuBandMathXImageFilterNew COMMAND otbMathParserXTestDriver otbBandMathXImageFilterNew) otb_add_test(NAME bfTvBandMathXImageFilterConv COMMAND otbMathParserXTestDriver otbBandMathXImageFilterConv ${BASELINE_FILES}/bfTvExportBandMathX.txt ${TEMP}/bfTvExportBandMathXOut.txt ) otb_add_test(NAME bfTvBandMathXImageFilter COMMAND otbMathParserXTestDriver otbBandMathXImageFilter) otb_add_test(NAME bfTvBandMathXImageFilterWithIdx COMMAND otbMathParserXTestDriver otbBandMathXImageFilterWithIdx ${TEMP}/bfTvBandMathImageFilterWithIdx1.tif ${TEMP}/bfTvBandMathImageFilterWithIdx2.tif ) otb_add_test(NAME bfTvBandMathXImageFilterTxt COMMAND otbMathParserXTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvExportBandMathX.txt ${TEMP}/bfTvExportBandMathXOut.txt otbBandMathXImageFilterTxt ${BASELINE_FILES}/bfTvExportBandMathX.txt ${TEMP}/bfTvExportBandMathXOut.txt ) OTB-release-5.8/Modules/Filtering/MathParserX/test/otbBandMathXImageFilter.cxx000066400000000000000000000502401301006202600272770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include //only for the isnan() test line 148 #include "otbMath.h" #include "otbVectorImage.h" #include "otbBandMathXImageFilter.h" #include "otbImageFileWriter.h" #include "itkImageRegionIteratorWithIndex.h" int otbBandMathXImageFilterNew( int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::BandMathXImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbBandMathXImageFilter( int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::VectorImage ImageType; typedef ImageType::PixelType PixelType; typedef otb::BandMathXImageFilter FilterType; unsigned int i; const unsigned int N = 100, D1=3, D2=1, D3=1; ImageType::SizeType size; size.Fill(N); ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image1 = ImageType::New(); ImageType::Pointer image2 = ImageType::New(); ImageType::Pointer image3 = ImageType::New(); image1->SetLargestPossibleRegion( region ); image1->SetBufferedRegion( region ); image1->SetRequestedRegion( region ); image1->SetNumberOfComponentsPerPixel(D1); image1->Allocate(); image2->SetLargestPossibleRegion( region ); image2->SetBufferedRegion( region ); image2->SetRequestedRegion( region ); image2->SetNumberOfComponentsPerPixel(D2); image2->Allocate(); image3->SetLargestPossibleRegion( region ); image3->SetBufferedRegion( region ); image3->SetRequestedRegion( region ); image3->SetNumberOfComponentsPerPixel(D3); image3->Allocate(); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it1(image1, region); IteratorType it2(image2, region); IteratorType it3(image3, region); ImageType::PixelType val1, val2, val3; val1.SetSize(D1); val2.SetSize(D2); val3.SetSize(D3); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3) { ImageType::IndexType i1 = it1.GetIndex(); ImageType::IndexType i2 = it2.GetIndex(); ImageType::IndexType i3 = it3.GetIndex(); val1[0] = i1[0] + i1[1] -50; val1[1] = i1[0] * i1[1] -50; val1[2] = i1[0] / (i1[1]+1)+5; val2[0] = i2[0] * i2[1]; val3[0] = i3[0] + i3[1] * i3[1]; it1.Set(val1); it2.Set(val2); it3.Set(val3); } FilterType::Pointer filter = FilterType::New(); std::cout << "Number Of Threads : " << filter->GetNumberOfThreads() << std::endl; filter->SetNthInput(0, image1); filter->SetNthInput(1, image2); filter->SetNthInput(2, image3, "canal3"); filter->SetExpression("vcos(2 * pi * im1) div (2 * pi * bands(im2,{1,1,1}) + {3.38,3.38,3.38}) mult vsin(pi * bands(canal3,{1,1,1}))"); //Sub-test 1 filter->SetExpression("im1b1 / im2b1"); //Sub-test 2 (Edge Effect Handling) filter->Update(); //if (filter->GetNumberOfOutputs() != 2) ImageType::Pointer output1 = filter->GetOutput(0); ImageType::Pointer output2 = filter->GetOutput(1); std::cout << "\n--- Standard Use\n"; std::cout << "Parsed Expression : " << filter->GetExpression(0) << std::endl; //Sub-test 1 IteratorType itoutput1(output1, region); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(), itoutput1.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3, ++itoutput1) { ImageType::IndexType i1 = it1.GetIndex(); ImageType::IndexType i2 = it2.GetIndex(); ImageType::IndexType i3 = it3.GetIndex(); PixelType px1(D1),px2(D2),px3(D3); px1[0] = ( i1[0] + i1[1] -50 ); px1[1] = ( i1[0] * i1[1] -50 ); px1[2] = ( i1[0] / (i1[1]+1)+5 ); px2[0] = ( i2[0] * i2[1] ); px3[0] = ( i3[0] + i3[1] * i3[1] ); double result1 = itoutput1.Get()[0], result2 = itoutput1.Get()[1], result3 = itoutput1.Get()[2]; double error1,error2,error3; double expected1 = vcl_cos( 2 * otb::CONST_PI * px1[0] ) / ( 2 * otb::CONST_PI * px2[0] + 3.38 ) * vcl_sin( otb::CONST_PI * px3[0] ); double expected2 = vcl_cos( 2 * otb::CONST_PI * px1[1] ) / ( 2 * otb::CONST_PI * px2[0] + 3.38 ) * vcl_sin( otb::CONST_PI * px3[0] ); double expected3 = vcl_cos( 2 * otb::CONST_PI * px1[2] ) / ( 2 * otb::CONST_PI * px2[0] + 3.38 ) * vcl_sin( otb::CONST_PI * px3[0] ); /*std::cout << "Pixel_1 = " << it1.Get()[0] << " Pixel_2 = " << it2.Get()[0] << " Pixel_3 = " << it3.Get()[0] << " Result = " << itoutput1.Get()[0] << " Expected = " << expected1 << std::endl; */ error1 = (result1 - expected1) * (result1 - expected1) / (result1 + expected1); error2 = (result2 - expected2) * (result2 - expected2) / (result2 + expected2); error3 = (result3 - expected3) * (result3 - expected3) / (result3 + expected3); if ( ( error1 > 1E-9 ) || ( error2 > 1E-9 ) || ( error3 > 1E-9 )) { itkGenericExceptionMacro( < 1E-9 -> TEST FAILLED" << std::endl << "Pixel_1 = " << it1.Get()[0] << " Pixel_2 = " << it2.Get()[0] << " Pixel_3 = " << it3.Get()[0] << " Result = " << result1 << " Expected = " << expected1 << std::endl << "Error = " << error2 << " > 1E-9 -> TEST FAILLED" << std::endl << "Pixel_1 = " << it1.Get()[1] << " Pixel_2 = " << it2.Get()[0] << " Pixel_3 = " << it3.Get()[0] << " Result = " << result2 << " Expected = " << expected2 << std::endl << "Error = " << error3 << " > 1E-9 -> TEST FAILLED" << std::endl << "Pixel_1 = " << it1.Get()[2] << " Pixel_2 = " << it2.Get()[0] << " Pixel_3 = " << it3.Get()[0] << " Result = " << result3 << " Expected = " << expected3 << std::endl); } } //Sub-test 2 /** Edge Effect Handling */ IteratorType itoutput2(output2, region); std::cout << "\n--- Edge Effect Handling\n"; std::cout << "- +/-inf section\n"; std::cout << "- nan section\n"; it1.GoToBegin(); it2.GoToBegin(); itoutput2.GoToBegin(); for(i=1; i<=50; ++i , ++it1, ++it2, ++itoutput2){} if(vnl_math_isnan(itoutput2.Get()[0])) std::cout << "Pixel_1 = " << it1.Get() << " Pixel_2 = " << it2.Get() << " Result = " << itoutput2.Get() << " Expected = nan\n"; else itkGenericExceptionMacro( << "\nError > Bad Edge Effect Handling -> Test Failled\n" << "Pixel_1 = " << it1.Get() << " Pixel_2 = " << it2.Get() << " Result = " << itoutput2.Get() << " Expected = nan\n" ); std::cout << std::endl; return EXIT_SUCCESS; } int otbBandMathXImageFilterConv( int itkNotUsed(argc), char* argv []) { const char * inputFilename = argv[1]; typedef otb::VectorImage ImageType; typedef ImageType::PixelType PixelType; typedef otb::BandMathXImageFilter FilterType; const unsigned int N = 100, D1=3, D2=1, D3=1; ImageType::SizeType size; size.Fill(N); ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image1 = ImageType::New(); ImageType::Pointer image2 = ImageType::New(); ImageType::Pointer image3 = ImageType::New(); image1->SetLargestPossibleRegion( region ); image1->SetBufferedRegion( region ); image1->SetRequestedRegion( region ); image1->SetNumberOfComponentsPerPixel(D1); image1->Allocate(); image2->SetLargestPossibleRegion( region ); image2->SetBufferedRegion( region ); image2->SetRequestedRegion( region ); image2->SetNumberOfComponentsPerPixel(D2); image2->Allocate(); image3->SetLargestPossibleRegion( region ); image3->SetBufferedRegion( region ); image3->SetRequestedRegion( region ); image3->SetNumberOfComponentsPerPixel(D3); image3->Allocate(); typedef itk::ConstNeighborhoodIterator IteratorType; IteratorType::RadiusType radius; radius[0]=1; // Size x direction radius[1]=2; // Size y direction IteratorType it1(radius, image1, region); it1.NeedToUseBoundaryConditionOn(); IteratorType it2(radius, image2, region); it2.NeedToUseBoundaryConditionOn(); IteratorType it3(radius, image3, region); it3.NeedToUseBoundaryConditionOn(); PixelType::ValueType imageAb2Mini = itk::NumericTraits::max(); PixelType::ValueType imageAb3Mean = 0.0, n=0.0; PixelType::ValueType imageAb3Var = 0.0; PixelType::ValueType imageAb1Sum = 0.0; PixelType::ValueType im2b1Maxi = itk::NumericTraits::min(); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3) { ImageType::IndexType i1 = it1.GetIndex(); ImageType::IndexType i2 = it2.GetIndex(); ImageType::IndexType i3 = it3.GetIndex(); it1.GetCenterPixel()[0] = i1[0] + i1[1] -50; it1.GetCenterPixel()[1] = i1[0] * i1[1] -50; it1.GetCenterPixel()[2] = i1[0] / (i1[1]+1)+5; it2.GetCenterPixel()[0] = i2[0] * i2[1]; it3.GetCenterPixel()[0] = i3[0] + i3[1] * i3[1]; // Minimum of im1 band 2 if (imageAb2Mini > it1.GetCenterPixel()[1]) imageAb2Mini = it1.GetCenterPixel()[1]; // Mean of im1 band 3 imageAb3Mean += it1.GetCenterPixel()[2]; n++; // Var of im1 band 3 imageAb3Var += vcl_pow(it1.GetCenterPixel()[2],2.0); // Maximum of im2 band 1 if (im2b1Maxi < it2.GetCenterPixel()[0]) im2b1Maxi = it2.GetCenterPixel()[0]; //Sum of im1 band1 imageAb1Sum += it1.GetCenterPixel()[0]; } imageAb3Mean = imageAb3Mean /n; imageAb3Var = (n/(n-1)) * (imageAb3Var /n - imageAb3Mean*imageAb3Mean); //unbiased FilterType::Pointer filter = FilterType::New(); std::cout << "Number Of Threads : " << filter->GetNumberOfThreads() << std::endl; double expo = 1.1; filter->SetNthInput(0, image1,"imageA"); filter->SetNthInput(1, image2); filter->SetNthInput(2, image3, "canal3"); //filter->SetMatrix("kernel1","{ 0.1 , 0.2 , 0.3; 0.4 , 0.5 , 0.6; 0.7 , 0.8 , 0.9; 1.0 , 1.1 , 1.2; 1.3 , 1.4 , 1.5 }"); //filter->SetConstant("expo",expo); //filter->SetExpression("conv(kernel1,imageAb1N3x5,imageAb2N3x5); im2b1^1.1; vcos(canal3); mean(imageAb2N3x3); var(imageAb2N3x3); median(imageAb2N3x3)"); filter->ImportContext(inputFilename); //Equivalent to three commands above filter->SetExpression("(vmax(canal3b1N3x5)+vmin(canal3b1N3x5)) div {2.0} + {imageAb3Var} dv 2.0 + {imageAb2Mini / im2b1Maxi} mlt 3.4 + {imageAb3Mean / imageAb1Sum * imageAb3Var} pw 1.2 ; vect2scal(vacos({0.5}) + vasin({0.5}) + vatan({0.5})) > 2.0 ?{1}:{0}"); filter->Update(); if (filter->GetNumberOfOutputs() != 2) itkGenericExceptionMacro(<< "Wrong number of outputs."); ImageType::Pointer output1 = filter->GetOutput(0); ImageType::Pointer output2 = filter->GetOutput(1); if (output1->GetNumberOfComponentsPerPixel() != 7) itkGenericExceptionMacro(<< "Wrong number of components per pixel (input 1)."); if (output2->GetNumberOfComponentsPerPixel() != 2) itkGenericExceptionMacro(<< "Wrong number of components per pixel (input 2)."); std::cout << "\n--- Standard Use\n"; std::cout << "Parsed Expression 1 : " << filter->GetExpression(0) << std::endl; std::cout << "Parsed Expression 2 : " << filter->GetExpression(1) << std::endl; //Sub-test 1 IteratorType itoutput1(radius, output1, region); IteratorType itoutput2(radius, output2, region); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(), itoutput1.GoToBegin(), itoutput2.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3, ++itoutput1, ++itoutput2) { PixelType px1(output1->GetNumberOfComponentsPerPixel()); PixelType px2(output2->GetNumberOfComponentsPerPixel()); float coefs[15] = { 0.1f , 0.2f , 0.3f , 0.4f , 0.5f , 0.6f , 0.7f , 0.8f , 0.9f , 1.0f , 1.1f , 1.2f , 1.3f , 1.4f , 1.5f}; //expression 1 px1[0]=0; for(unsigned int i=0; i vect; for (int i=3; i<=11; i++) vect.push_back(it1.GetPixel(i)[1]); px1[4] = 0.0; for (unsigned int i=0; i vect2; for (unsigned int i=0; i 2.0 ) px2[1]=1.0; else px2[1]=0.0; //expression 1 double result1 = itoutput1.GetCenterPixel()[0], result2 = itoutput1.GetCenterPixel()[1], result3 = itoutput1.GetCenterPixel()[2], result4 = itoutput1.GetCenterPixel()[3], result5 = itoutput1.GetCenterPixel()[4] , result6 = itoutput1.GetCenterPixel()[5], result7 = itoutput1.GetCenterPixel()[6]; double error1,error2,error3,error4,error5,error6,error7; double expected1 = px1[0], expected2 = px1[1], expected3 = px1[2], expected4 = px1[3], expected5 = px1[4] , expected6 = px1[5], expected7 = px1[6]; error1 = (result1 - expected1) * (result1 - expected1) / (result1 + expected1); error2 = (result2 - expected2) * (result2 - expected2) / (result2 + expected2); error3 = (result3 - expected3) * (result3 - expected3) / (result3 + expected3); error4 = (result4 - expected4) * (result4 - expected4) / (result4 + expected4); error5 = (result5 - expected5) * (result5 - expected5) / (result5 + expected5); error6 = (result6 - expected6) * (result6 - expected6) / (result6 + expected6); error7 = (result7 - expected7) * (result7 - expected7) / (result7 + expected7); //expression 2 double result8 = itoutput2.GetCenterPixel()[0]; double result9 = itoutput2.GetCenterPixel()[1]; double expected8 = px2[0]; double expected9 = px2[1]; double error8 = (result8 - expected8) * (result8 - expected8) / (result8 + expected8); double error9 = (result9 - expected9) * (result9 - expected9) / (result9 + expected9); if ( ( error1 > 1E-9 ) || ( error2 > 1E-9 ) || ( error3 > 1E-9 ) || ( error4 > 1E-9 ) || ( error5 > 1E-9 ) || ( error6 > 1E-9 ) || ( error7 > 1E-9 ) || (error8 > 1E-9) || (error9 > 1E-9)) { itkGenericExceptionMacro( << "TEST FAILLED" << std::endl << "Error1 = " << error1 << std::endl << " Result1 = " << result1 << " Expected1 = " << expected1 << std::endl << "Error2 = " << error2 << std::endl << " Result2 = " << result2 << " Expected2 = " << expected2 << std::endl << "Error3 = " << error3 << std::endl << " Result3 = " << result3 << " Expected3 = " << expected3 << std::endl << "Error4 = " << error4 << std::endl << " Result4 = " << result4 << " Expected4 = " << expected4 << std::endl << "Error5 = " << error5 << std::endl << " Result5 = " << result5 << " Expected5 = " << expected5 << std::endl << "Error6 = " << error6 << std::endl << " Result6 = " << result6 << " Expected6 = " << expected6 << std::endl << "Error7 = " << error7 << std::endl << " Result7 = " << result7 << " Expected7 = " << expected7 << std::endl << "Error8 = " << error8 << std::endl << " Result8 = " << result8 << " Expected8 = " << expected8 << std::endl << "Error9 = " << error9 << std::endl << " Result9 = " << result9 << " Expected9 = " << expected9 << std::endl); } } return EXIT_SUCCESS; } int otbBandMathXImageFilterTxt( int itkNotUsed(argc), char* argv []) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef otb::VectorImage ImageType; typedef otb::BandMathXImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); filter->ImportContext(inputFilename); filter->ExportContext(outputFilename); return EXIT_SUCCESS; } int otbBandMathXImageFilterWithIdx( int itkNotUsed(argc), char* argv[]) { const char * outfname1 = argv[1]; const char * outfname2 = argv[2]; typedef otb::VectorImage ImageType; typedef otb::BandMathXImageFilter FilterType; typedef otb::ImageFileWriter WriterType; const unsigned int N = 100, D1=1, D2=1, D3=1; ImageType::SizeType size; size.Fill(N); ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::PointType origin; origin[0] = -25; origin[1] = -25; ImageType::SpacingType spacing; spacing[0] = 0.5; spacing[1] = 0.5; ImageType::Pointer image1 = ImageType::New(); ImageType::Pointer image2 = ImageType::New(); ImageType::Pointer image3 = ImageType::New(); image1->SetLargestPossibleRegion( region ); image1->SetBufferedRegion( region ); image1->SetRequestedRegion( region ); image1->SetNumberOfComponentsPerPixel(D1); image1->Allocate(); image2->SetLargestPossibleRegion( region ); image2->SetBufferedRegion( region ); image2->SetRequestedRegion( region ); image2->SetNumberOfComponentsPerPixel(D2); image2->Allocate(); image3->SetLargestPossibleRegion( region ); image3->SetBufferedRegion( region ); image3->SetRequestedRegion( region ); image3->SetNumberOfComponentsPerPixel(D3); image3->Allocate(); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it1(image1, region); IteratorType it2(image2, region); IteratorType it3(image3, region); image1->SetOrigin(origin); image1->SetSpacing(spacing); image2->SetOrigin(origin); image2->SetSpacing(spacing); image3->SetOrigin(origin); image3->SetSpacing(spacing); for (it1.GoToBegin(), it2.GoToBegin(), it3.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2, ++it3) { ImageType::IndexType i1 = it1.GetIndex(); ImageType::IndexType i2 = it2.GetIndex(); ImageType::IndexType i3 = it3.GetIndex(); it1.Get()[0] = i1[0] + i1[1] -50; it2.Get()[0] = i2[0] * i2[1]; it3.Get()[0] = i3[0] + i3[1] * i3[1]; } FilterType::Pointer filter = FilterType::New(); std::cout << "Number Of Threads : " << filter->GetNumberOfThreads() << std::endl; filter->SetNthInput(0, image1); filter->SetNthInput(1, image2); filter->SetNthInput(2, image3); filter->SetExpression("(sqrt(idxX*idxX+idxY*idxY) < 50) ? im1b1 : im2b1"); filter->SetExpression("(sqrt(im2PhyX*im2PhyX+im2PhyY*im2PhyY) < 25) ? im2b1 : im3b1"); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput(0)); writer->SetFileName(outfname1); writer->Update(); WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(filter->GetOutput(1)); writer2->SetFileName(outfname2); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MathParserX/test/otbMathParserXTestDriver.cxx000066400000000000000000000005321301006202600275710ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbParserXTest); REGISTER_TEST(otbBandMathXImageFilter); REGISTER_TEST(otbParserXTestNew); REGISTER_TEST(otbBandMathXImageFilterNew); REGISTER_TEST(otbBandMathXImageFilterConv); REGISTER_TEST(otbBandMathXImageFilterTxt); REGISTER_TEST(otbBandMathXImageFilterWithIdx); } OTB-release-5.8/Modules/Filtering/MathParserX/test/otbParserXTest.cxx000066400000000000000000000100071301006202600256010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMath.h" #include "otbParserX.h" typedef otb::ParserX ParserType; int otbParserXTestNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiating object ParserType::Pointer parser = ParserType::New(); std::cout << parser << std::endl; return EXIT_SUCCESS; } void otbParserXTest_ThrowIfNotEqual(double output, double ref, std::string testname, double epsilon = 1.0E-12) { std::cout << "Running test " << testname << std::endl; if (vcl_abs(output-ref) > epsilon) { itkGenericExceptionMacro( << "Got " << output << " while waiting for " << ref ); } std::cout << " -- OK" << std::endl; } void otbParserXTest_ThrowIfNotEqual(bool output, bool ref, std::string testname = "") { std::cout << "Running test " << testname << std::endl; if (output != ref) { itkGenericExceptionMacro( << "Got " << output << " while waiting for " << ref ); } std::cout << " -- OK" << std::endl; } void otbParserXTest_Numerical(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("10.0+3"); otbParserXTest_ThrowIfNotEqual(parser->Eval(), 13.0, "Numerical"); } void otbParserXTest_BuildInFun(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("cos(1.55)"); otbParserXTest_ThrowIfNotEqual(parser->Eval(), vcl_cos(1.55), "BuildInFun"); } void otbParserXTest_UserDefinedCst(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("ln10"); otbParserXTest_ThrowIfNotEqual(parser->Eval(), vcl_log(10.0), "UserDefinedCst"); } void otbParserXTest_UserDefinedFun(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("ndvi(100, 10)"); otbParserXTest_ThrowIfNotEqual(parser->Eval(), (10.0-100.0)/(10.0+100.0), "UserDefinedFun"); } void otbParserXTest_UserDefinedVars(void) { ParserType::ValueType var1 = 10.0; ParserType::ValueType var2 = 2.0; ParserType::ValueType var3 = 7.0; ParserType::ValueType var4 = 100.0; ParserType::ValueType var5 = 200.0; double dvar1 = 10.0; double dvar2 = 2.0; double dvar3 = 7.0; double dvar4 = 100.0; double dvar5 = 200.0; ParserType::Pointer parser = ParserType::New(); parser->DefineVar("var1", &var1); parser->DefineVar("var2", &var2); parser->DefineVar("var3", &var3); parser->DefineVar("var4", &var4); parser->DefineVar("var5", &var5); parser->SetExpr("(var1+var2-var3)*var4/var5"); otbParserXTest_ThrowIfNotEqual(parser->Eval(), (dvar1+dvar2-dvar3)*dvar4/dvar5, "UserDefinedVars"); } void otbParserXTest_Mixed(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("(7+10)/2+cos(pi/4)*10-10*ln10+ndvi(100, 10)"); otbParserXTest_ThrowIfNotEqual(parser->Eval(), (7.0+10.0)/2.0+vcl_cos(otb::CONST_PI/4)*10.0-10.0*vcl_log(10.0)+(10.0-100.0)/(10.0+100.0), "Mixed"); } void otbParserXTest_LogicalOperator(void) { ParserType::Pointer parser = ParserType::New(); parser->SetExpr("true and false"); otbParserXTest_ThrowIfNotEqual(static_cast(parser->Eval()), false, "LogicalOperator and"); parser->SetExpr("true or false"); otbParserXTest_ThrowIfNotEqual(static_cast(parser->Eval()), true, "LogicalOperator or"); } int otbParserXTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otbParserXTest_Numerical(); otbParserXTest_BuildInFun(); otbParserXTest_UserDefinedCst(); otbParserXTest_UserDefinedFun(); otbParserXTest_UserDefinedVars(); otbParserXTest_Mixed(); otbParserXTest_LogicalOperator(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/000077500000000000000000000000001301006202600230765ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/CMakeLists.txt000066400000000000000000000000631301006202600256350ustar00rootroot00000000000000project(OTBMorphologicalPyramid) otb_module_impl() OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/000077500000000000000000000000001301006202600245215ustar00rootroot00000000000000otbMorphologicalPyramidAnalysisFilter.h000066400000000000000000000126471301006202600343310ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidAnalysisFilter_h #define otbMorphologicalPyramidAnalysisFilter_h #include "otbImageToImageListFilter.h" namespace otb { /** \class MorphologicalPyramidAnalysisFilter * \brief Multiscale analysis filter using the morphological pyramid algorithm. * * Pyramidal decomposition is based on the following statement : once an * image has been smoothed with a linear filter, it does not contain * any more high-frequency details. Therefore, it can be down-sampled * without any loss of information, according to Shannon Theorem. By * iterating the same smoothing on the down-sampled image, a * multi-resolution decomposition of the scene is * computed. If the smoothing filter is a morphological filter, this * is no longer true, as the filter is not linear. However, by keeping * the details possibly lost in the down-sampling operation, such a * decomposition can be used. * * The MorphologicalPyramidAnalysisFilter provide such a * decomposition. It's computation process is an iterative analyse * involving smoothing by the morphological filter, computing the * details lost in the smoothing, down-sampling the current image, and * computing the details lost in the down-sampling. * * \ingroup MultiScale * \sa MorphologicalPyramidSynthesisFilter, OpeningClosingMorphologicalFilter, * ClosingOpeningMorphologicalFilter * * \ingroup OTBMorphologicalPyramid */ template class ITK_EXPORT MorphologicalPyramidAnalysisFilter : public ImageToImageListFilter { public: /** Standard typedefs */ typedef MorphologicalPyramidAnalysisFilter Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(MorphologicalPyramidAnalysisFilter, MorphologicalPyramidAnalysisFilter); /** Input image dimension constant macro */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Template parameters typedefs */ typedef TMorphoFilter MorphoFilterType; typedef typename MorphoFilterType::KernelType KernelType; /** Output related typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; /** Input related typedefs */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::SpacingType SpacingType; /** Accessors */ itkSetMacro(NumberOfLevels, int); itkSetMacro(DecimationRatio, double); itkGetConstReferenceMacro(NumberOfLevels, int); itkGetConstReferenceMacro(DecimationRatio, double); /** * Get The Analyse image at each level of the pyramid. * \return The analysed image at each level of the pyramid. */ OutputImageListType* GetOutput(void) ITK_OVERRIDE; /** * Get The SupFilter details * \return The brighter details extracted from the filtering operation. */ OutputImageListType * GetSupFilter(void); /** * Get The InfFilter details * \return The darker details extracted from the filtering operation. */ OutputImageListType * GetInfFilter(void); /** * Get The SupDeci details * \return The brighter details extracted from the resampling operation. */ OutputImageListType * GetSupDeci(void); /** * Get The InfDeci details * \return The brighter details extracted from the resampling operation. */ OutputImageListType * GetInfDeci(void); protected: /** Constructor */ MorphologicalPyramidAnalysisFilter(); /** Destructor */ ~MorphologicalPyramidAnalysisFilter() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE {} // does nothing /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** Printself method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** Number of levels of the algorithm */ int m_NumberOfLevels; /** Subsampling scale used */ double m_DecimationRatio; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMorphologicalPyramidAnalysisFilter.txx" #endif #endif otbMorphologicalPyramidAnalysisFilter.txx000066400000000000000000000263321301006202600347210ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidAnalysisFilter_txx #define otbMorphologicalPyramidAnalysisFilter_txx #include "otbMorphologicalPyramidAnalysisFilter.h" #include "itkSubtractImageFilter.h" #include "itkMaximumImageFilter.h" #include "itkImageDuplicator.h" #include "otbMorphologicalPyramidResampler.h" #include "itkProgressAccumulator.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template MorphologicalPyramidAnalysisFilter ::MorphologicalPyramidAnalysisFilter() { this->SetNumberOfRequiredOutputs(2); m_DecimationRatio = 2.0; m_NumberOfLevels = 4; OutputImageListPointerType supFilter = OutputImageListType::New(); this->SetNthOutput(0, supFilter.GetPointer()); OutputImageListPointerType infFilter = OutputImageListType::New(); this->SetNthOutput(1, infFilter.GetPointer()); OutputImageListPointerType outputList = OutputImageListType::New(); this->SetNthOutput(2, outputList.GetPointer()); OutputImageListPointerType supDeci = OutputImageListType::New(); this->SetNthOutput(3, supDeci.GetPointer()); OutputImageListPointerType infDeci = OutputImageListType::New(); this->SetNthOutput(4, infDeci.GetPointer()); } /** * Destructor */ template MorphologicalPyramidAnalysisFilter ::~MorphologicalPyramidAnalysisFilter() {} /** * Get The Analyse image at each level of the pyramid. * \return The analysed image at each level of the pyramid. */ template typename MorphologicalPyramidAnalysisFilter ::OutputImageListType* MorphologicalPyramidAnalysisFilter ::GetOutput(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(2)); } /** * Get The SupFilter details * \return The brighter details extracted from the filtering operation. */ template typename MorphologicalPyramidAnalysisFilter ::OutputImageListType* MorphologicalPyramidAnalysisFilter ::GetSupFilter(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } /** * Get The InfFilter details * \return The darker details extracted from the filtering operation. */ template typename MorphologicalPyramidAnalysisFilter ::OutputImageListType* MorphologicalPyramidAnalysisFilter ::GetInfFilter(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(1)); } /** * Get The SupDeci details * \return The brighter details extracted from the resampling operation. */ template typename MorphologicalPyramidAnalysisFilter ::OutputImageListType* MorphologicalPyramidAnalysisFilter ::GetSupDeci(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(3)); } /** * Get The InfDeci details * \return The brighter details extracted from the resampling operation. */ template typename MorphologicalPyramidAnalysisFilter ::OutputImageListType* MorphologicalPyramidAnalysisFilter ::GetInfDeci(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(4)); } /** * Main computation method */ template void MorphologicalPyramidAnalysisFilter ::GenerateData(void) { // Input image pointer OutputImageListType * OutputImageList = this->GetOutput(); // Output images pointers OutputImageListType * supFilter = this->GetSupFilter(); OutputImageListType * infFilter = this->GetInfFilter(); OutputImageListType * supDeci = this->GetSupDeci(); OutputImageListType * infDeci = this->GetInfDeci(); // typedefs of the filters typedef itk::SubtractImageFilter SubtractFilterType; typedef itk::MaximumImageFilter MaxFilterType; typedef itk::ImageDuplicator DuplicatorType; typedef otb::MorphologicalPyramid::Resampler ResamplerType; // Input Image duplication to the currentImage Pointer typename DuplicatorType::Pointer duplicator = DuplicatorType::New(); duplicator->SetInputImage(this->GetInput()); duplicator->Update(); typename InputImageType::Pointer currentImage = duplicator->GetOutput(); typename InputImageType::Pointer upsampled; // Structuring element size computation const int structElementDimension = static_cast(vcl_ceil(this->GetDecimationRatio() / 2.)); // Structuring element creation KernelType structuringElement; structuringElement.SetRadius(structElementDimension); structuringElement.CreateStructuringElement(); // Filters declarations typename MorphoFilterType::Pointer morphoFilter; typename MaxFilterType::Pointer max; typename SubtractFilterType::Pointer subtract1, subtract2, subtract3, subtract4; typename ResamplerType::Pointer resampler1, resampler2; // Size declaration typename InputImageType::SizeType size; // local variables declarations and initializations int i = 0; int sizeTmp; //--------------------------------------------------------// // Main loop // //--------------------------------------------------------// // While the number of iterations is not reached otbMsgDevMacro(<< "Entering main loop"); while (i < this->GetNumberOfLevels()) { // morphological filtering morphoFilter = MorphoFilterType::New(); morphoFilter->SetKernel(structuringElement); morphoFilter->SetInput(currentImage); morphoFilter->Update(); // Maximum between current and filtered image max = MaxFilterType::New(); max->SetInput1(morphoFilter->GetOutput()); max->SetInput2(currentImage); max->Update(); // SupFilter detail image computation subtract1 = SubtractFilterType::New(); subtract1->SetInput1(max->GetOutput()); subtract1->SetInput2(morphoFilter->GetOutput()); subtract1->Update(); otbMsgDevMacro( << "MorphologicalPyramidAnalysisFilter: subtract1 OK " << subtract1->GetOutput()->GetLargestPossibleRegion().GetSize()); supFilter->PushBack(subtract1->GetOutput()); otbMsgDevMacro("MorphologicalPyramidAnalysisFilter: step " << i << " - Image appended to SupFilter"); // InfFilter detail image computation subtract2 = SubtractFilterType::New(); subtract2->SetInput1(max->GetOutput()); subtract2->SetInput2(currentImage); subtract2->Update(); otbMsgDevMacro( << "MorphologicalPyramidAnalysisFilter: subtract2 OK " << subtract2->GetOutput()->GetLargestPossibleRegion().GetSize()); infFilter->PushBack(subtract2->GetOutput()); otbMsgDevMacro("MorphologicalPyramidAnalysisFilter: step " << i << " - Image appended to InfFilter"); // New Size size = morphoFilter->GetOutput()->GetLargestPossibleRegion().GetSize(); for (unsigned int j = 0; j < InputImageType::ImageDimension; ++j) { sizeTmp = size[j]; // As we knwow that our values will always be positive ones, we can simulate round by ceil(value+0.5) size[j] = static_cast(vcl_ceil((static_cast(sizeTmp) / this->GetDecimationRatio()) + 0.5)); } otbMsgDevMacro(<< "New size: " << size); // Image subsampling // Current image becomes the newly subsampled image resampler1 = ResamplerType::New(); resampler1->SetInput(morphoFilter->GetOutput()); resampler1->SetSize(size); resampler1->Update(); currentImage = resampler1->GetOutput(); otbMsgDevMacro( << "MorphologicalPyramidAnalysisFilter: DownSampling OK " << currentImage->GetLargestPossibleRegion().GetSize()); // New current image is appended to the output list OutputImageList->PushBack(currentImage); // Image upsampling resampler2 = ResamplerType::New(); resampler2->SetInput(resampler1->GetOutput()); resampler2->SetSize(morphoFilter->GetOutput()->GetLargestPossibleRegion().GetSize()); resampler2->Update(); otbMsgDevMacro( << "MorphologicalPyramidAnalysisFilter: UpSampling OK " << resampler2->GetOutput()->GetLargestPossibleRegion().GetSize()); // Computation of the details lost in the subsampling operation max = MaxFilterType::New(); max->SetInput1(morphoFilter->GetOutput()); max->SetInput2(resampler2->GetOutput()); max->Update(); otbMsgDevMacro( << "MorphologicalPyramidAnalysisFilter: Max OK " << max->GetOutput()->GetLargestPossibleRegion().GetSize()); // InfDeci detail image computation subtract4 = SubtractFilterType::New(); subtract4->SetInput1(max->GetOutput()); subtract4->SetInput2(morphoFilter->GetOutput()); subtract4->Update(); otbMsgDevMacro( << "MorphologicalPyramidAnalysisFilter: subtract4 OK " << subtract4->GetOutput()->GetLargestPossibleRegion().GetSize()); infDeci->PushBack(subtract4->GetOutput()); otbMsgDevMacro("MorphologicalPyramidAnalysisFilter: step " << i << " - Image appended to InfDeci"); // SupDeci detail image computation subtract3 = SubtractFilterType::New(); subtract3->SetInput1(max->GetOutput()); subtract3->SetInput2(resampler2->GetOutput()); subtract3->Update(); otbMsgDevMacro( << "MorphologicalPyramidAnalysisFilter: subtract3 OK " << subtract3->GetOutput()->GetLargestPossibleRegion().GetSize()); supDeci->PushBack(subtract3->GetOutput()); otbMsgDevMacro("MorphologicalPyramidAnalysisFilter: step " << i << " - Image appended to SupDeci"); // Iteration ounter incrementation ++i; } otbMsgDevMacro(<< "Exiting main loop"); } /** * PrintSelf method */ template void MorphologicalPyramidAnalysisFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "DecimationRatio: " << m_DecimationRatio << std::endl; os << indent << "NumberOfLevels: " << m_NumberOfLevels << std::endl; } } // End namespace otb #endif otbMorphologicalPyramidMRToMSConverter.h000066400000000000000000000136231301006202600343440ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidMRToMSConverter_h #define otbMorphologicalPyramidMRToMSConverter_h #include "otbImageListToImageListFilter.h" namespace otb { namespace MorphologicalPyramid { /** * \class MRToMSConverter * \brief This class convert a multi resolution decomposition from the morphological pyramid to a multi-scale one. * * This class convert a multi resolution decomposition from the morphological pyramid to a multi-scale one. * * The operation consists in iterativly upsampling and adding decimation details to a given detail image. * * \sa MorphologicalPyramidAnalyseFilter * \sa MorphologicalPyramidSynthesisFilter * * \ingroup OTBMorphologicalPyramid */ template class ITK_EXPORT MRToMSConverter : public ImageListToImageListFilter { public: /** Standard typedefs */ typedef MRToMSConverter Self; typedef ImageListToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(MRToMSConverter, ImageListToImageListFilter); /** Input parameters typedefs */ typedef TInputImage InputImageType; typedef typename Superclass::InputImagePointer InputImagePointer; typedef typename Superclass::InputImageListType InputImageListType; typedef typename Superclass::InputImageListPointerType InputImageListPointerType; typedef typename InputImageListType::Iterator InputImageListIteratorType; /** Output parameters typedefs */ typedef TOutputImage OutputImageType; typedef typename Superclass::OutputImagePointer OutputImagePointerType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImageListPointerType OutputImageListPointerType; /** * Set The input list. * \param imageList The analysed image at each level of the pyramid. */ using Superclass::SetInput; void SetInput(const InputImageListType * imageList) ITK_OVERRIDE; /** * Set The SupFilter details * \param imageList The brighter details extracted from the filtering operation. */ void SetSupFilter(InputImageListType * imageList); /** * Set The InfFilter details * \param imageList The darker details extracted from the filtering operation. */ void SetInfFilter(InputImageListType * imageList); /** * Set The SupDeci details * \param imageList The brighter details extracted from the filtering operation. */ void SetSupDeci(InputImageListType * imageList); /** * Set The InfDeci details * \param imageList The darker details extracted from the filtering operation. */ void SetInfDeci(InputImageListType * imageList); /** * Get the input list. * \return The list of the analysed image at each pyramid level. */ InputImageListType* GetInput(void) ITK_OVERRIDE; /** * Get The SupFilter details * \return The brighter details extracted from the filtering operation. */ InputImageListType* GetSupFilter(void); /** * Get The InfFilter details * \return The darker details extracted from the filtering operation. */ InputImageListType* GetInfFilter(void); /** * Get The SupDeci details * \return The brighter details extracted from the resampling operation. */ InputImageListType* GetSupDeci(void); /** * Get The InfDeci details * \return The brighter details extracted from the resampling operation. */ InputImageListType* GetInfDeci(void); /** * Get The inputList at full resolution. * \return The analysed image at each pyramid level * resampled at full resolution. */ OutputImageListType* GetOutput(void) ITK_OVERRIDE; /** * Get The SupFilter details at full resolution. * \return The brighter details extracted from the filtering operation * resampled at full resolution. */ OutputImageListType * GetSupFilterFullResolution(void); /** * Get The InfFilter details at full resolution. * \return The darker details extracted from the filtering operation * resampled at full resolution. */ OutputImageListType * GetInfFilterFullResolution(void); /** * Get The SupDeci details at full resolution. * \return The brighter details extracted from the resampling operation * resampled at full resolution. */ OutputImageListType * GetSupDeciFullResolution(void); /** * Get The InfDeci details at full resolution. * \return The darker details extracted from the resampling operation * resampled at full resolution. */ OutputImageListType * GetInfDeciFullResolution(void); protected: /** Constructor */ MRToMSConverter(); /** Destructor */ ~MRToMSConverter() ITK_OVERRIDE {} /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: MRToMSConverter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented }; } // End namespace MorphologicalPyramid } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMorphologicalPyramidMRToMSConverter.txx" #endif #endif otbMorphologicalPyramidMRToMSConverter.txx000066400000000000000000000264421301006202600347430ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidMRToMSConverter_txx #define otbMorphologicalPyramidMRToMSConverter_txx #include "otbMorphologicalPyramidMRToMSConverter.h" #include "otbMorphologicalPyramidResampler.h" #include "otbMacro.h" namespace otb { namespace MorphologicalPyramid { /** * Constructor */ template MRToMSConverter ::MRToMSConverter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(2); OutputImageListPointerType supFilter = OutputImageListType::New(); this->SetNthOutput(0, supFilter.GetPointer()); OutputImageListPointerType infFilter = OutputImageListType::New(); this->SetNthOutput(1, infFilter.GetPointer()); OutputImageListPointerType outputList = OutputImageListType::New(); this->SetNthOutput(2, outputList.GetPointer()); OutputImageListPointerType supDeci = OutputImageListType::New(); this->SetNthOutput(3, supDeci.GetPointer()); OutputImageListPointerType infDeci = OutputImageListType::New(); this->SetNthOutput(4, infDeci.GetPointer()); } /** * Get The inputList at full resolution. * \return The analysed image at each pyramid level * resampled at full resolution. */ template typename MRToMSConverter ::OutputImageListType* MRToMSConverter ::GetOutput(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(2)); } /** * Get The SupFilter details at full resolution. * \return The brighter details extracted from the filtering operation. * resampled at full resolution. */ template typename MRToMSConverter ::OutputImageListType* MRToMSConverter ::GetSupFilterFullResolution(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } /** * Get The InfFilter details at full resolution. * \return The darker details extracted from the filtering operation. * resampled at full resolution. */ template typename MRToMSConverter ::OutputImageListType* MRToMSConverter ::GetInfFilterFullResolution(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(1)); } /** * Get The SupDeci details at full resolution. * \return The brighter details extracted from the resampling operation. * resampled at full resolution. */ template typename MRToMSConverter ::OutputImageListType* MRToMSConverter ::GetSupDeciFullResolution(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(3)); } /** * Get The InfDeci details at full resolution. * \return The brighter details extracted from the resampling operation. * resampled at full resolution. */ template typename MRToMSConverter ::OutputImageListType* MRToMSConverter ::GetInfDeciFullResolution(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(4)); } /** * Set The input list. * \param imageList The analysed image at each level of the pyramid. */ template void MRToMSConverter ::SetInput(const InputImageListType * imageList) { this->SetNthInput(2, const_cast(imageList)); } /** * Set The SupFilter details * \param imageList The brighter details extracted from the filtering operation. */ template void MRToMSConverter ::SetSupFilter(InputImageListType * imageList) { this->SetNthInput(0, const_cast(imageList)); } /** * Set The InfFilter details * \param imageList The darker details extracted from the filtering operation. */ template void MRToMSConverter ::SetInfFilter(InputImageListType * imageList) { this->SetNthInput(1, const_cast(imageList)); } /** * Set The SupDeci details * \param imageList The brighter details extracted from the filtering operation. */ template void MRToMSConverter ::SetSupDeci(InputImageListType * imageList) { this->SetNthInput(3, const_cast(imageList)); } /** * Set The InfDeci details * \param imageList The darker details extracted from the filtering operation. */ template void MRToMSConverter ::SetInfDeci(InputImageListType * imageList) { this->SetNthInput(4, const_cast(imageList)); } /** * Get the input list. * \return The list of the analysed image at each pyramid level. */ template typename MRToMSConverter ::InputImageListType* MRToMSConverter ::GetInput(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(2)); } /** * Get The SupFilter details. * \return The brighter details extracted from the filtering operation */ template typename MRToMSConverter ::InputImageListType* MRToMSConverter ::GetSupFilter(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(0)); } /** * Get The InfFilter details. * \return The darker details extracted from the filtering operation */ template typename MRToMSConverter ::InputImageListType* MRToMSConverter ::GetInfFilter(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(1)); } /** * Get The SupDeci details. * \return The brighter details extracted from the resampling operation */ template typename MRToMSConverter ::InputImageListType* MRToMSConverter ::GetSupDeci(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(3)); } /** * Get The InfDeci details. * \return The darker details extracted from the resampling operation. */ template typename MRToMSConverter ::InputImageListType* MRToMSConverter ::GetInfDeci(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(4)); } /** * Main computation method */ template void MRToMSConverter ::GenerateData() { // Input images lists pointers InputImageListPointerType supFilter = this->GetSupFilter(); InputImageListPointerType infFilter = this->GetInfFilter(); InputImageListPointerType supDeci = this->GetSupDeci(); InputImageListPointerType infDeci = this->GetInfDeci(); InputImageListPointerType inputList = this->GetInput(); // Output images lists pointers OutputImageListPointerType supFilterFullResolution = this->GetSupFilterFullResolution(); OutputImageListPointerType infFilterFullResolution = this->GetInfFilterFullResolution(); OutputImageListPointerType supDeciFullResolution = this->GetSupDeciFullResolution(); OutputImageListPointerType infDeciFullResolution = this->GetInfDeciFullResolution(); OutputImageListPointerType outputList = this->GetOutput(); // typedef of the resampling filter typedef otb::MorphologicalPyramid::Resampler ResamplerType; // Definition of the resampler filters typename ResamplerType::Pointer resampler; // Full resolution size typename InputImageType::SizeType frsize = supFilter->Front()->GetLargestPossibleRegion().GetSize(); otbMsgDevMacro(<< "MRToMSConverter: Full resolution size: " << frsize); // SupFilter resampling otbMsgDevMacro(<< "MRToMSConverter: SupFilter resampling."); InputImageListIteratorType it = supFilter->Begin(); // The first image does not need any resampling supFilterFullResolution->PushBack(it.Get()); ++it; for (; it != supFilter->End(); ++it) { resampler = ResamplerType::New(); resampler->SetSize(frsize); resampler->SetInput(it.Get()); resampler->Update(); supFilterFullResolution->PushBack(resampler->GetOutput()); } otbMsgDevMacro(<< "MRToMSConverter: InfFilter resampling."); // InfFilter resampling it = infFilter->Begin(); // The first image does not need any resampling infFilterFullResolution->PushBack(it.Get()); ++it; for (; it != infFilter->End(); ++it) { resampler = ResamplerType::New(); resampler->SetSize(frsize); resampler->SetInput(it.Get()); resampler->Update(); infFilterFullResolution->PushBack(resampler->GetOutput()); } if (inputList) { otbMsgDevMacro(<< "MRToMSConverter: Optional inputList resampling."); // Analyse image resampling it = inputList->Begin(); // The first image does not need any resampling outputList->PushBack(it.Get()); ++it; for (; it != inputList->End(); ++it) { resampler = ResamplerType::New(); resampler->SetSize(frsize); resampler->SetInput(it.Get()); resampler->Update(); outputList->PushBack(resampler->GetOutput()); } } if (supDeci) { otbMsgDevMacro(<< "MRToMSConverter: Optional supDeci resampling."); // SupDeci resampling it = supDeci->Begin(); // The first image does not need any resampling supDeciFullResolution->PushBack(it.Get()); ++it; for (; it != supDeci->End(); ++it) { resampler = ResamplerType::New(); resampler->SetSize(frsize); resampler->SetInput(it.Get()); resampler->Update(); supDeciFullResolution->PushBack(resampler->GetOutput()); } } if (infDeci) { otbMsgDevMacro(<< "MRToMSConverter: Optional infDeci resampling."); // InfDeci resampling it = infDeci->Begin(); // The first image does not need any resampling infDeciFullResolution->PushBack(it.Get()); ++it; for (; it != infDeci->End(); ++it) { resampler = ResamplerType::New(); resampler->SetSize(frsize); resampler->SetInput(it.Get()); resampler->Update(); infDeciFullResolution->PushBack(resampler->GetOutput()); } } } /** * PrintSelf method */ template void MRToMSConverter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace MorphologicalPyramid } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/otbMorphologicalPyramidResampler.h000066400000000000000000000071651301006202600334100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidResampler_h #define otbMorphologicalPyramidResampler_h #include "itkImageToImageFilter.h" namespace otb { namespace MorphologicalPyramid { /** * \class Resampler * \brief This class performs the resampling of the given image to the given size. * * This class performs the resampling of the given image to the given size.It is used * in the MorphologicalPyramidAnalyseFilter and MorphologicalPyramidSynthesisFilter. * * The resampling is done by the itk::ResampleImageFilter, templated with the interpolator * itk::LinearInterpolateImageFunction and the transform itk::ScaleTransform. * * \sa MorphologicalPyramidAnalyseFilter * \sa MorphologicalPyramidSynthesisFilter * \sa ResampleImageFilter * \sa LinearInterpolateImageFunction * \sa ScaleTransform * * \ingroup OTBMorphologicalPyramid */ template class ITK_EXPORT Resampler : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef Resampler Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(Resampler, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename InputImageType::Pointer InputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename TInputImage::PixelType PixelType; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename OutputImageType::SizeType SizeType; typedef typename OutputImageType::SpacingType SpacingType; /** Size parameter accessor */ itkSetMacro(Size, SizeType); itkGetMacro(Size, SizeType); protected: /** Constructor */ Resampler(); /** Destructor */ ~Resampler() ITK_OVERRIDE {} /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Configure input requested region to be the largest possible region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Configure output requested region to be the largest possible region */ void EnlargeOutputRequestedRegion(itk::DataObject * itkNotUsed(output)) ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: Resampler(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /// Output image size SizeType m_Size; }; } // End namespace MorphologicalPyramid } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMorphologicalPyramidResampler.txx" #endif #endif OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/otbMorphologicalPyramidResampler.txx000066400000000000000000000135761301006202600340070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidResampler_txx #define otbMorphologicalPyramidResampler_txx #include "otbMorphologicalPyramidResampler.h" #include "itkResampleImageFilter.h" #include "itkScalableAffineTransform.h" #include "itkNearestNeighborInterpolateImageFunction.h" #include "itkProgressAccumulator.h" namespace otb { namespace MorphologicalPyramid { /** * Constructor */ template Resampler ::Resampler() { for (unsigned int i = 0; i < InputImageType::ImageDimension; ++i) { m_Size[i] = 0; } } /** * Configure input requested region to be the largest possible region. */ template void Resampler ::GenerateInputRequestedRegion() { // Superclass method call Superclass::GenerateInputRequestedRegion(); // Input and output image pointers retrieval InputImagePointer inputPtr = const_cast (this->GetInput()); OutputImagePointer outputPtr = this->GetOutput(); // If the pointers are not correct if (!inputPtr || !outputPtr) { // exit return; } // else // Configure input requested region to be the largest possible region inputPtr->SetRequestedRegion(inputPtr->GetLargestPossibleRegion()); } /** * Configure output requested region to be the largest possible region */ template void Resampler ::EnlargeOutputRequestedRegion(itk::DataObject *itkNotUsed(output)) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } /** * Generate output information */ template void Resampler ::GenerateOutputInformation() { // Superclass method call Superclass::GenerateOutputInformation(); // Input and output image pointers retrieval InputImageConstPointer inputPtr = this->GetInput(); OutputImagePointer outputPtr = this->GetOutput(); // If the pointers are not correct if (!inputPtr || !outputPtr) { // exit return; } unsigned int i; // Computing output spacing, size and index from input data const typename InputImageType::SpacingType& inputSpacing = inputPtr->GetSpacing(); const typename InputImageType::IndexType& inputStartIndex = inputPtr->GetLargestPossibleRegion().GetIndex(); typename OutputImageType::IndexType outputStartIndex; typename OutputImageType::SpacingType spacing; for (i = 0; i < OutputImageType::ImageDimension; ++i) { outputStartIndex[i] = inputStartIndex[i]; } outputPtr->SetSpacing(inputSpacing); typename OutputImageType::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(this->GetSize()); outputLargestPossibleRegion.SetIndex(outputStartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); } /** * Main computation method */ template void Resampler ::GenerateData() { typename OutputImageType::Pointer result; // Filters typedefs typedef itk::ResampleImageFilter ResampleFilterType; typedef itk::ScalableAffineTransform TransformType; typedef itk::LinearInterpolateImageFunction InterpolatorType; // Resampling filter creation typename ResampleFilterType::Pointer resampler = ResampleFilterType::New(); typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); typename TransformType::Pointer transform = TransformType::New(); // Scale parameters computation typename TransformType::InputVectorType scales; typename InputImageType::SizeType inputSize = this->GetInput()->GetLargestPossibleRegion().GetSize(); typename InputImageType::SpacingType inputSpacing = this->GetInput()->GetSpacing(); scales[0] = static_cast(inputSize[0]) / static_cast(m_Size[0]); scales[1] = static_cast(inputSize[1]) / static_cast(m_Size[1]); transform->SetScale(scales); transform->SetCenter(this->GetInput()->GetOrigin()); typename TransformType::OutputVectorType translation; translation[0] = 0.5 * inputSpacing[0] * (scales[0] - 1.0); translation[1] = 0.5 * inputSpacing[1] * (scales[1] - 1.0); transform->SetTranslation(translation); // Resampling filter set up resampler->SetTransform(transform); resampler->SetInterpolator(interpolator); resampler->SetOutputOrigin(this->GetInput()->GetOrigin()); resampler->SetSize(this->GetSize()); resampler->SetOutputSpacing(inputSpacing); resampler->ReleaseDataFlagOn(); // Progress accumulator itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); progress->RegisterInternalFilter(resampler, .5f); // Input image connexion resampler->SetInput(this->GetInput()); resampler->Update(); result = resampler->GetOutput(); /** Output filter connexion */ this->GraftOutput(result); } /** * PrintSelf method */ template void Resampler ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Size: " << m_Size << std::endl; } } // End namespace MorphologicalPyramid } // End namespace otb #endif otbMorphologicalPyramidSegmentationFilter.h000066400000000000000000000170111301006202600351710ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidSegmentationFilter_h #define otbMorphologicalPyramidSegmentationFilter_h #include "otbImageListToImageListFilter.h" namespace otb { /** \class MorphologicalPyramidSegmentationFilter * \brief This filter performs a segmentation of the details supFilter and infFilter extracted * with the morphological pyramid. * * The first step is to convert the multi-resolution analysis from the pyramid to a multi-scale one using the * MRToMSConverter filter. * * The segmentation algorithm used is based on seeds extraction using the ImageToPointSetFilter, followed by * a connected threshold segmentation using the ConnectedThresholdImageFilter. A final relabelling step is done * with the LabelImageFilter and RelabelImageFilter to remove object whose sizes are to small regarding the * MinimumObjectSize parameter. The threshold for seeds extraction and segmentation are computed using quantiles. * * A pre processing step is applied by multiplying the full resolution brighter details (resp. darker details) * with the original image (resp. the inverted original image). This performs an enhancement of the regions contour * precision. * * The details from the pyramid are set via the SetBrighterDetails() and SetDarkerDetails() methods. The brighter and * darker details depends on the filter used in the pyramid analysis. If the OpeningClosing filter is used, then the * brighter details are those from the supFilter image list, whereas if the ClosingOpening filter is used, the brighter * details are those from the infFilter list. * * The output of the segmentation filter is a single segmentation images list, containing first the brighter details * segmentation from higher scale to lower, and then the darker details in the same order. The attention of the used * is drawn to the fact that since the label filter used internally will deal with a large number of labels, so the * OutputPixelType is required to be sufficiently precise. Unsigned short or Unsigned long would be a good choice, * unless the user has a very good reason to think that a less precise type will be sufficient. * * \ingroup MultiScale * \sa MorphologicalPyramidSynthesisFilter, OpeningClosingMorphologicalFilter, * ClosingOpeningMorphologicalFilter, Segmenter, MRToMSConverter, Resampler * * \ingroup OTBMorphologicalPyramid */ template class ITK_EXPORT MorphologicalPyramidSegmentationFilter : public ImageListToImageListFilter { public: /** Standard typedefs */ typedef MorphologicalPyramidSegmentationFilter Self; typedef ImageListToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(MorphologicalPyramidSegmentationFilter, ImageListToImageListFilter); /** Input image dimension constant macro */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Output related typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename OutputImageListType::Iterator OutputImageListIteratorType; /** Input related typedefs */ typedef typename Superclass::InputImageType InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename Superclass::InputImageListType InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; /** Vector of number of objects */ typedef std::vector NumberOfObjectsVectorType; /** Min object size parameter accessor */ itkSetMacro(MinimumObjectSize, unsigned long); itkGetMacro(MinimumObjectSize, unsigned long); /** Quantile for seeds extraction */ itkSetMacro(SeedsQuantile, double); itkGetMacro(SeedsQuantile, double); /** Quantile for connected thresholding */ itkSetMacro(ConnectedThresholdQuantile, double); itkGetMacro(ConnectedThresholdQuantile, double); /** * Get a vector containing the number of segmented objects for each image. * \return The vector. */ NumberOfObjectsVectorType GetNumberOfObjectsVector(void); /** * Set the reference image. * \param image The reference image which was decomposed by the pyramid. */ void SetReferenceImage(InputImageType * image); /** * Set the brighter details from the pyramid. The brighter details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \param imageList The brighter details extracted from the filtering operation. */ void SetBrighterDetails(InputImageListType * imageList); /** * Set the darker details from the pyramid. The darker details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \param imageList The darker details extracted from the filtering operation. */ void SetDarkerDetails(InputImageListType * imageList); /** * Get the reference image * \return The reference image. */ InputImageType* GetReferenceImage(void); /** * Get the brighter details from the pyramid. The brighter details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \return The brighter details extracted from the resampling operation. */ InputImageListType* GetBrighterDetails(void); /** * Get the darker details from the pyramid. The darker details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \return The darker details extracted from the resampling operation. */ InputImageListType *GetDarkerDetails(void); protected: /** Constructor */ MorphologicalPyramidSegmentationFilter(); /** Destructor */ ~MorphologicalPyramidSegmentationFilter() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE {} // does nothing /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** Printself method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: unsigned long m_MinimumObjectSize; /** Quantile for seeds determination */ double m_SeedsQuantile; /** Quantile to set the connectedThresholdFilter threshold */ double m_ConnectedThresholdQuantile; /** Number of segmented objects per images */ NumberOfObjectsVectorType m_NumberOfObjectsVector; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMorphologicalPyramidSegmentationFilter.txx" #endif #endif otbMorphologicalPyramidSegmentationFilter.txx000066400000000000000000000164371301006202600356000ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidSegmentationFilter_txx #define otbMorphologicalPyramidSegmentationFilter_txx #include "otbMorphologicalPyramidSegmentationFilter.h" #include "otbMorphologicalPyramidMRToMSConverter.h" #include "otbMorphologicalPyramidSegmenter.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template MorphologicalPyramidSegmentationFilter ::MorphologicalPyramidSegmentationFilter() { this->SetNumberOfRequiredInputs(3); m_MinimumObjectSize = 10; m_SeedsQuantile = 0.9; m_ConnectedThresholdQuantile = 0.9; } /** * Destructor */ template MorphologicalPyramidSegmentationFilter ::~MorphologicalPyramidSegmentationFilter() {} /** * Set the reference image. * \param image The reference image which was decomposed by the pyramid. */ template void MorphologicalPyramidSegmentationFilter ::SetReferenceImage(InputImageType * image) { this->SetNthInput(0, const_cast(image)); } /** * Set the brighter details from the pyramid. The brighter details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \param imageList The brighter details extracted from the filtering operation. */ template void MorphologicalPyramidSegmentationFilter ::SetBrighterDetails(InputImageListType * imageList) { this->SetNthInput(1, const_cast(imageList)); } /** * Set the darker details from the pyramid. The darker details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \param imageList The darker details extracted from the filtering operation. */ template void MorphologicalPyramidSegmentationFilter ::SetDarkerDetails(InputImageListType * imageList) { this->SetNthInput(2, const_cast(imageList)); } /** * Get the reference image * \return The reference image. */ template typename MorphologicalPyramidSegmentationFilter ::InputImageType* MorphologicalPyramidSegmentationFilter ::GetReferenceImage(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(0)); } /** * Get the brighter details from the pyramid. The brighter details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \param imageList The brighter details extracted from the filtering operation. */ template typename MorphologicalPyramidSegmentationFilter ::InputImageListType* MorphologicalPyramidSegmentationFilter ::GetBrighterDetails(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(1)); } /** * Get the darker details from the pyramid. The darker details are the supFilter or * infFilter details from the pyramid, depending on the morphological filter used. * \return The darker details extracted from the resampling operation. */ template typename MorphologicalPyramidSegmentationFilter ::InputImageListType* MorphologicalPyramidSegmentationFilter ::GetDarkerDetails(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(2)); } /** * Get a vector containing the number of segmented objects for each image. * \return The vector. */ template typename MorphologicalPyramidSegmentationFilter ::NumberOfObjectsVectorType MorphologicalPyramidSegmentationFilter ::GetNumberOfObjectsVector(void) { return m_NumberOfObjectsVector; } /** * Main computation method */ template void MorphologicalPyramidSegmentationFilter ::GenerateData(void) { // Reference image pointer InputImagePointerType referenceImage = this->GetReferenceImage(); otbMsgDevMacro("SegmentationFilter: reference image size: " << referenceImage->GetLargestPossibleRegion().GetSize()); // Output images list pointer OutputImageListPointerType outputList = this->GetOutput(); // Multi resolution to multi scale filter typedef typedef otb::MorphologicalPyramid::MRToMSConverter MRToMSConverterType; // Segmentation filter typedef typedef otb::MorphologicalPyramid::Segmenter SegmenterType; // MR To MS conversion typename MRToMSConverterType::Pointer mrtoms = MRToMSConverterType::New(); mrtoms->SetSupFilter(this->GetBrighterDetails()); mrtoms->SetInfFilter(this->GetDarkerDetails()); mrtoms->Update(); // Full resolution Input images lists pointers InputImageListPointerType brighter = mrtoms->GetSupFilterFullResolution(); InputImageListPointerType darker = mrtoms->GetInfFilterFullResolution(); // Segmentation filter definition typename InputImageListType::Iterator it; // Segment the supFilter details for (it = brighter->Begin(); it != brighter->End(); ++it) { typename SegmenterType::Pointer segmenter = SegmenterType::New(); segmenter->SetMinimumObjectSize(m_MinimumObjectSize); segmenter->SetSeedsQuantile(m_SeedsQuantile); segmenter->SetConnectedThresholdQuantile(m_ConnectedThresholdQuantile); segmenter->SetOriginalImage(referenceImage); segmenter->SetDetailsImage(it.Get()); segmenter->Update(); m_NumberOfObjectsVector.push_back(segmenter->GetNumberOfObjects()); outputList->PushBack(segmenter->GetOutput()); } // Segment the infFilter details for (it = darker->Begin(); it != darker->End(); ++it) { typename SegmenterType::Pointer segmenter = SegmenterType::New(); segmenter->SetMinimumObjectSize(m_MinimumObjectSize); segmenter->SetSeedsQuantile(m_SeedsQuantile); segmenter->SetConnectedThresholdQuantile(m_ConnectedThresholdQuantile); segmenter->SetOriginalImage(referenceImage); segmenter->SetSegmentDarkDetailsBool(true); segmenter->SetDetailsImage(it.Get()); segmenter->Update(); m_NumberOfObjectsVector.push_back(segmenter->GetNumberOfObjects()); outputList->PushBack(segmenter->GetOutput()); } } /** * PrintSelf method */ template void MorphologicalPyramidSegmentationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/otbMorphologicalPyramidSegmenter.h000066400000000000000000000126721301006202600334060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidSegmenter_h #define otbMorphologicalPyramidSegmenter_h #include "itkImageToImageFilter.h" namespace otb { namespace MorphologicalPyramid { /** * \class Segmenter * \brief This class performs the segmentation of a detail image extracted from a * morphological pyramid analysis. * * This class performs the segmentation of a detail image extracted from a * morphological pyramid analysis. * * The Segmentation is performed using the ConnectedThresholdImageFilter. The seeds * are extracted from the image using the ImageToPointSetFilter. The thresolds are set * by using quantiles computed with the HistogramGenerator. * * \sa MorphologicalPyramidAnalyseFilter * \sa MorphologicalPyramidSynthesisFilter * \sa ResampleImageFilter * \sa LinearInterpolateImageFunction * \sa ScaleTransform * * \ingroup OTBMorphologicalPyramid */ template class ITK_EXPORT Segmenter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef Segmenter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(Segmenter, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::Pointer InputImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::SizeType SizeType; typedef typename OutputImageType::SpacingType SpacingType; /** ImageDimension constants */ itkStaticConstMacro(DetailsImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OriginalImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** * Set the details image. * \param detailsImage The details image from the morphological pyramid */ void SetDetailsImage(const InputImageType * detailsImage); /** * Get the details image. * \return detailsImage The input details image. */ InputImageType * GetDetailsImage(void); /** * Set the original image. * \param originalImage The original image to segment. */ void SetOriginalImage(const InputImageType * originalImage); /** * Get the original image. * \return originalImage The original image to segment. */ InputImageType * GetOriginalImage(void); /** Min object size parameter accessor */ itkSetMacro(MinimumObjectSize, unsigned long); itkGetMacro(MinimumObjectSize, unsigned long); /** Quantile for seeds extraction */ itkSetMacro(SeedsQuantile, double); itkGetMacro(SeedsQuantile, double); /** Quantile for connected thresholding */ itkSetMacro(ConnectedThresholdQuantile, double); itkGetMacro(ConnectedThresholdQuantile, double); /** Toogle the darker detail segmentation */ itkSetMacro(SegmentDarkDetailsBool, bool); itkGetMacro(SegmentDarkDetailsBool, bool); itkBooleanMacro(SegmentDarkDetailsBool); /** Get the number of segmented objects */ itkGetMacro(NumberOfObjects, OutputPixelType); protected: /** Constructor */ Segmenter(); /** Destructor */ ~Segmenter() ITK_OVERRIDE {} /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Configure the input datas. */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** * Configure the output data. */ using Superclass::EnlargeOutputRequestedRegion; void EnlargeOutputRequestedRegion(void); private: Segmenter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** Minimum size for the segmented object */ unsigned long m_MinimumObjectSize; /** Quantile for seeds determination */ double m_SeedsQuantile; /** Quantile to set the connectedThresholdFilter threshold */ double m_ConnectedThresholdQuantile; /** Set to true if the details to segment are darker than background */ bool m_SegmentDarkDetailsBool; /** Number of segmented objects */ OutputPixelType m_NumberOfObjects; }; } // End namespace MorphologicalPyramid } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMorphologicalPyramidSegmenter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/otbMorphologicalPyramidSegmenter.txx000066400000000000000000000245661301006202600340070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidSegmenter_txx #define otbMorphologicalPyramidSegmenter_txx #include "otbMorphologicalPyramidSegmenter.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkConnectedThresholdImageFilter.h" #include "itkConnectedComponentImageFilter.h" #include "itkRelabelComponentImageFilter.h" #include "itkThresholdImageFilter.h" #include "itkMultiplyImageFilter.h" #include "itkCastImageFilter.h" #include "itkInvertIntensityImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbThresholdImageToPointSetFilter.h" #include "itkScalarImageToHistogramGenerator.h" #include "itkMinimumMaximumImageCalculator.h" namespace otb { namespace MorphologicalPyramid { /** * Constructor */ template Segmenter ::Segmenter() { this->SetNumberOfRequiredInputs(2); m_SeedsQuantile = 0.9; m_MinimumObjectSize = 10; m_SegmentDarkDetailsBool = false; m_NumberOfObjects = 0; m_ConnectedThresholdQuantile = 0.9; } /** * Set the details image. * \param detailsImage The details image from the morphological pyramid */ template void Segmenter ::SetDetailsImage(const InputImageType * detailsImage) { this->SetNthInput(0, const_cast(detailsImage)); } /** * Set the details image. * \return detailsImage The input details image. */ template typename Segmenter::InputImageType * Segmenter ::GetDetailsImage(void) { return const_cast(this->GetInput(0)); } /** * Set the original image. * \param originalImage The original image to segment. */ template void Segmenter ::SetOriginalImage(const InputImageType * originalImage) { this->SetNthInput(1, const_cast(originalImage)); } /** * Get the original image. * \return originalImage The original image to segment. */ template typename Segmenter::InputImageType * Segmenter ::GetOriginalImage(void) { return const_cast(this->GetInput(1)); } /** * Configure the input datas. */ template void Segmenter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the inputs InputImagePointerType detailsPtr = const_cast(this->GetInput(0)); InputImagePointerType origPtr = const_cast(this->GetInput(1)); if (!detailsPtr || !origPtr) { return; } // We need to // configure the inputs such that all the data is available. detailsPtr->SetRequestedRegion(detailsPtr->GetLargestPossibleRegion()); origPtr->SetRequestedRegion(origPtr->GetLargestPossibleRegion()); } /** * Configure the output data */ template void Segmenter ::EnlargeOutputRequestedRegion(void) { this->GetOutput() ->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } /** * Main computation method */ template void Segmenter ::GenerateData() { // Input images pointers InputImagePointerType details = this->GetDetailsImage(); InputImagePointerType original = this->GetOriginalImage(); // Typedefs for details image enhancement typedef double FloatPixelType; typedef otb::Image FloatImageType; typedef itk::InvertIntensityImageFilter InvertFilterType; typedef itk::MultiplyImageFilter MultiplyFilterType; typedef itk::CastImageFilter CastImageFilterType; typedef itk::MinimumMaximumImageCalculator MinMaxCalculatorType; //Typedefs for seeds extraction typedef itk::PointSet PointSetType; typedef otb::ThresholdImageToPointSetFilter PointSetFilterType; typedef typename PointSetType::PointsContainer::Iterator PointSetIteratorType; // Typedefs for segmentation typedef itk::ConnectedThresholdImageFilter ConnectedFilterType; typedef itk::ConnectedComponentImageFilter LabelFilterType; typedef itk::RelabelComponentImageFilter RelabelFilterType; typedef itk::ThresholdImageFilter ThresholdFilterType; // Typedefs for statistics computation typedef itk::Statistics::ScalarImageToHistogramGenerator HistGeneratorType; ///////////////////////////////////// //// Details image enhancement ////// ///////////////////////////////////// // Filters instantiation typename InvertFilterType::Pointer invert; typename CastImageFilterType::Pointer cast1 = CastImageFilterType::New(); typename CastImageFilterType::Pointer cast2 = CastImageFilterType::New(); typename MultiplyFilterType::Pointer mult = MultiplyFilterType::New(); typename MinMaxCalculatorType::Pointer minMax = MinMaxCalculatorType::New(); // Pipeline connection cast1->SetInput(details); minMax->SetImage(original); minMax->ComputeMaximum(); // If we want to segment darker detail, the original image must have its itensity inverted if (m_SegmentDarkDetailsBool) { invert = InvertFilterType::New(); invert->SetInput(original); invert->SetMaximum(minMax->GetMaximum()); cast2->SetInput(invert->GetOutput()); } else { cast2->SetInput(original); } mult->SetInput1(cast1->GetOutput()); mult->SetInput2(cast2->GetOutput()); mult->Update(); ///////////////////////////////////// //// Thresholds computation ///////// ///////////////////////////////////// // Filter instantiation typename HistGeneratorType::Pointer histogram = HistGeneratorType::New(); // Seeds Threshold is computed from the quantile histogram->SetInput(details); histogram->SetNumberOfBins(255); histogram->SetMarginalScale(10.0); histogram->Compute(); InputPixelType pointSetThreshold = static_cast(histogram->GetOutput()->Quantile(0, m_SeedsQuantile)); // Segmentation Threshold is computed from the quantile histogram = HistGeneratorType::New(); histogram->SetInput(mult->GetOutput()); histogram->SetNumberOfBins(255); histogram->SetMarginalScale(10.0); histogram->Compute(); InputPixelType connectedThresholdValue = static_cast(histogram->GetOutput()->Quantile(0, m_ConnectedThresholdQuantile)); ///////////////////////////////////// //// Seeds extraction /////////////// ///////////////////////////////////// typename PointSetFilterType::Pointer pointSetFilter = PointSetFilterType::New(); pointSetFilter->SetInput(0, details); pointSetFilter->SetLowerThreshold(pointSetThreshold); pointSetFilter->Update(); ///////////////////////////////////// //// Segmentation /////////////////// ///////////////////////////////////// // Filters instantiation typename ConnectedFilterType::Pointer connectedThreshold = ConnectedFilterType::New(); typename LabelFilterType::Pointer labeler = LabelFilterType::New(); typename RelabelFilterType::Pointer relabeler = RelabelFilterType::New(); typename ThresholdFilterType::Pointer threshold = ThresholdFilterType::New(); //Passing seeds to the connected filter connectedThreshold = ConnectedFilterType::New(); connectedThreshold->ClearSeeds(); connectedThreshold->SetInput(mult->GetOutput()); PointSetIteratorType it = pointSetFilter->GetOutput()->GetPoints()->Begin(); while (it != pointSetFilter->GetOutput()->GetPoints()->End()) { typename OutputImageType::IndexType index; index[0] = static_cast(it.Value()[0]); index[1] = static_cast(it.Value()[1]); connectedThreshold->AddSeed(index); ++it; } // segmentation connectedThreshold->SetLower(connectedThresholdValue); // labelling labeler = LabelFilterType::New(); relabeler = RelabelFilterType::New(); labeler->SetInput(connectedThreshold->GetOutput()); relabeler->SetInput(labeler->GetOutput()); relabeler->SetMinimumObjectSize(m_MinimumObjectSize); relabeler->Update(); // In some cases it might happen that the whole extent of the image is segmented as a single region. // Since this is not desirable, we test this case here to avoid it. threshold = ThresholdFilterType::New(); threshold->SetInput(relabeler->GetOutput()); OutputPixelType num = 0; if (relabeler->GetNumberOfObjects() == 1) { unsigned int surface = mult->GetOutput()->GetLargestPossibleRegion().GetSize()[0] * mult->GetOutput()->GetLargestPossibleRegion().GetSize()[1]; if (relabeler->GetSizeOfObjectsInPixels()[0] == surface) { num = 0; } else { num = 1; } } else { num = static_cast(relabeler->GetNumberOfObjects()); } threshold->ThresholdOutside(0, num); // Output connection threshold->GraftOutput(this->GetOutput()); threshold->Update(); this->GraftOutput(threshold->GetOutput()); m_NumberOfObjects = num; } /** * PrintSelf method */ template void Segmenter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace MorphologicalPyramid } // End namespace otb #endif otbMorphologicalPyramidSynthesisFilter.h000066400000000000000000000130621301006202600345270ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidSynthesisFilter_h #define otbMorphologicalPyramidSynthesisFilter_h #include "otbImageToImageListFilter.h" namespace otb { /** * \class MorphologicalPyramidSynthesisFilter * \brief Recomposition of the multiscale analysis performed with * a MorphologicalPyramidAnalyseFilter. * * Once a morphological pyramidal decompisition has been made, it is * possible to rebuild without any loss of information the original * image at full resolution. The MorphologicalPyramidsynthesisFilter * provides such a functionality. At each iteration, it performs the * up-sampling of the current image using the * otb::morphologicalPyramid::Resampler filter, the addition of * the details lost in down-sampling, and the addition of the details * lost in smoothing. * * \ingroup MultiScale * \sa MorphologicalPyramidAnalyseFilter * \sa MorphologicalPyramidResampler * * \ingroup OTBMorphologicalPyramid */ template class ITK_EXPORT MorphologicalPyramidSynthesisFilter : public ImageToImageListFilter { public: /** Standard typedefs */ typedef MorphologicalPyramidSynthesisFilter Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(MorphologicalPyramidSynthesisFilter, MorphologicalPyramidSynthesisFilter); /** Input image dimension constant macro */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Output related typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::OutputImageListType::Iterator ImageListIterator; typedef typename Superclass::OutputImageListType::ReverseIterator ImageListReverseIterator; /** Input related typedefs */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::SpacingType SpacingType; typedef otb::ImageList InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; /** Size vector typedefs */ typedef std::vector SizeVectorType; typedef typename SizeVectorType::iterator SizeIterator; typedef typename SizeVectorType::reverse_iterator SizeReverseIterator; /** * Set The SupFilter details * \param imageList The brighter details extracted from the filtering operation. */ void SetSupFilter(InputImageListType * imageList); /** * Set The InfFilter details * \param imageList The darker details extracted from the filtering operation. */ void SetInfFilter(InputImageListType * imageList); /** * Set The SupDeci details * \param imageList The brighter details extracted from the filtering operation. */ void SetSupDeci(InputImageListType * imageList); /** * Set The InfDeci details * \param imageList The darker details extracted from the filtering operation. */ void SetInfDeci(InputImageListType * imageList); /** * Get The SupFilter details * \return The brighter details extracted from the filtering operation. */ InputImageListType* GetSupFilter(void); /** * Get The InfFilter details * \return The darker details extracted from the filtering operation. */ InputImageListType* GetInfFilter(void); /** * Get The SupDeci details * \return The brighter details extracted from the resampling operation. */ InputImageListType* GetSupDeci(void); /** * Get The InfDeci details * \return The brighter details extracted from the resampling operation. */ InputImageListType* GetInfDeci(void); protected: /** Constructor */ MorphologicalPyramidSynthesisFilter(); /** Destructor */ ~MorphologicalPyramidSynthesisFilter() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE {} // does nothing /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** Printself method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMorphologicalPyramidSynthesisFilter.txx" #endif #endif otbMorphologicalPyramidSynthesisFilter.txx000066400000000000000000000206471301006202600351320ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalPyramidSynthesisFilter_txx #define otbMorphologicalPyramidSynthesisFilter_txx #include "otbMorphologicalPyramidSynthesisFilter.h" #include "otbMorphologicalPyramidResampler.h" #include "itkSubtractImageFilter.h" #include "itkAddImageFilter.h" #include "itkImageDuplicator.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template MorphologicalPyramidSynthesisFilter ::MorphologicalPyramidSynthesisFilter() { this->SetNumberOfRequiredInputs(5); } /** * Destructor */ template MorphologicalPyramidSynthesisFilter ::~MorphologicalPyramidSynthesisFilter() {} /** * Set The SupFilter details * \param imageList The brighter details extracted from the filtering operation. */ template void MorphologicalPyramidSynthesisFilter ::SetSupFilter(InputImageListType * imageList) { this->SetNthInput(1, const_cast(imageList)); } /** * Set The InfFilter details * \param imageList The darker details extracted from the filtering operation. */ template void MorphologicalPyramidSynthesisFilter ::SetInfFilter(InputImageListType * imageList) { this->SetNthInput(2, const_cast(imageList)); } /** * Set The SupDeci details * \param imageList The brighter details extracted from the filtering operation. */ template void MorphologicalPyramidSynthesisFilter ::SetSupDeci(InputImageListType * imageList) { this->SetNthInput(3, const_cast(imageList)); } /** * Set The InfDeci details * \param imageList The darker details extracted from the filtering operation. */ template void MorphologicalPyramidSynthesisFilter ::SetInfDeci(InputImageListType * imageList) { this->SetNthInput(4, const_cast(imageList)); } /** * Get The SupFilter details * \return The brighter details extracted from the filtering operation. */ template typename MorphologicalPyramidSynthesisFilter ::InputImageListType* MorphologicalPyramidSynthesisFilter ::GetSupFilter(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(1)); } /** * Get The InfFilter details * \return The darker details extracted from the filtering operation. */ template typename MorphologicalPyramidSynthesisFilter ::InputImageListType* MorphologicalPyramidSynthesisFilter ::GetInfFilter(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(2)); } /** * Get The SupDeci details * \return The brighter details extracted from the resampling operation. */ template typename MorphologicalPyramidSynthesisFilter ::InputImageListType* MorphologicalPyramidSynthesisFilter ::GetSupDeci(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(3)); } /** * Get The InfDeci details * \return The darker details extracted from the resampling operation. */ template typename MorphologicalPyramidSynthesisFilter ::InputImageListType* MorphologicalPyramidSynthesisFilter ::GetInfDeci(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(4)); } /** * Main computation method */ template void MorphologicalPyramidSynthesisFilter ::GenerateData(void) { otbMsgDevMacro(<< "MorphologicalPyramidSynthesisFilter : Entering main method."); // Input image pointer InputImageListType * supFilter = this->GetSupFilter(); InputImageListType * infFilter = this->GetInfFilter(); InputImageListType * supDeci = this->GetSupDeci(); InputImageListType * infDeci = this->GetInfDeci(); // Output pointer OutputImageListType * OutputImageList = this->GetOutput(); // typedefs of the filters typedef itk::SubtractImageFilter SubtractFilterType; typedef itk::AddImageFilter AddFilterType; typedef otb::MorphologicalPyramid::Resampler ResamplerType; typedef itk::ImageDuplicator DuplicatorType; // Input Image duplication to the currentImage Pointer typename DuplicatorType::Pointer duplicator = DuplicatorType::New(); duplicator->SetInputImage(this->GetInput()); duplicator->Update(); // Input Image duplication to the currentImage Pointer typename InputImageType::Pointer currentImage = duplicator->GetOutput(); // Filters declarations typename AddFilterType::Pointer add1, add2; typename SubtractFilterType::Pointer subtract1, subtract2; typename ResamplerType::Pointer resampler; // Size vector computation SizeVectorType size; ImageListIterator it = supFilter->Begin(); while (it != supFilter->End()) { size.push_back(it.Get()->GetLargestPossibleRegion().GetSize()); ++it; } otbMsgDevMacro(<< "MorphologicalPyramidSynthesisFilter : Size vector computation OK"); // Iterators definition ImageListReverseIterator itinfFilter = infFilter->ReverseBegin(); ImageListReverseIterator itsupFilter = supFilter->ReverseBegin(); ImageListReverseIterator itinfDeci = infDeci->ReverseBegin(); ImageListReverseIterator itsupDeci = supDeci->ReverseBegin(); SizeReverseIterator itSize = size.rbegin(); int i = 1; //--------------------------------------------------------// // Main loop // //--------------------------------------------------------// while (itinfFilter != infFilter->ReverseEnd() && itsupFilter != supFilter->ReverseEnd() && itinfDeci != infDeci->ReverseEnd() && itsupDeci != supDeci->ReverseEnd() && itSize != size.rend()) { ++i; // Upsampling current image resampler = ResamplerType::New(); resampler->SetSize(*itSize); resampler->SetInput(currentImage); resampler->Update(); otbMsgDevMacro(<< "MorphologicalPyramidSynthesisFilter: step " << i << " Upsampling OK"); // Adding *sup details from current level add1 = AddFilterType::New(); add1->SetInput1(resampler->GetOutput()); add1->SetInput2(itsupFilter.Get()); add2 = AddFilterType::New(); add2->SetInput1(add1->GetOutput()); add2->SetInput2(itsupDeci.Get()); // Adding *inf details from current level subtract1 = SubtractFilterType::New(); subtract1->SetInput1(add2->GetOutput()); subtract1->SetInput2(itinfFilter.Get()); subtract2 = SubtractFilterType::New(); subtract2->SetInput1(subtract1->GetOutput()); subtract2->SetInput2(itinfDeci.Get()); subtract2->Update(); otbMsgDevMacro(<< "MorphologicalPyramidSynthesisFilter: step " << i << " Details addition OK"); // Updating current image currentImage = subtract2->GetOutput(); OutputImageList->PushBack(currentImage); // Iterators incrementation ++itsupFilter; ++itinfFilter; ++itsupDeci; ++itinfDeci; ++itSize; } otbMsgDevMacro(<< "MorphologicalPyramidSynthesisFilter: Exiting main method."); } /** * PrintSelf method */ template void MorphologicalPyramidSynthesisFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/otb-module.cmake000066400000000000000000000012171301006202600261500ustar00rootroot00000000000000set(DOCUMENTATION "If the smoothing filter used in the pyramidal analysis is a morphological filter, one cannot safely subsample the filtered image without loss of information. However, by keeping the details possibly lost in the down-sampling operation, such a decomposition can be used. The Morphological Pyramid is an approach to such a decomposition. This module contains classes useful in meeting that goal.") otb_module(OTBMorphologicalPyramid DEPENDS OTBCommon OTBITK OTBImageBase OTBObjectList OTBPointSet TEST_DEPENDS OTBImageIO OTBMorphologicalProfiles OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/000077500000000000000000000000001301006202600240555ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/CMakeLists.txt000066400000000000000000000125331301006202600266210ustar00rootroot00000000000000otb_module_test() set(OTBMorphologicalPyramidTests otbMorphologicalPyramidTestDriver.cxx otbMorphologicalPyramidSegmentationFilterNew.cxx otbMorphologicalPyramidAnalysisFilter.cxx otbMorphologicalPyramidSegmenter.cxx otbMorphologicalPyramidSegmenterNew.cxx otbMorphologicalPyramidSynthesisFilter.cxx otbMorphologicalPyramidMRToMSConverter.cxx otbMorphologicalPyramidSynthesisFilterNew.cxx otbMorphologicalPyramidMRToMSConverterNew.cxx otbMorphologicalPyramidResampler.cxx otbMorphologicalPyramidAnalysisFilterNew.cxx otbMorphologicalPyramidResamplerNew.cxx otbMorphologicalPyramidSegmentationFilter.cxx ) add_executable(otbMorphologicalPyramidTestDriver ${OTBMorphologicalPyramidTests}) target_link_libraries(otbMorphologicalPyramidTestDriver ${OTBMorphologicalPyramid-Test_LIBRARIES}) otb_module_target_label(otbMorphologicalPyramidTestDriver) # Tests Declaration otb_add_test(NAME msTuMorphoPyrSegmentationFilterNew COMMAND otbMorphologicalPyramidTestDriver otbMorphologicalPyramidSegmentationFilterNew) otb_add_test(NAME msTvMorphoPyrAnalysisFilter COMMAND otbMorphologicalPyramidTestDriver --compare-n-images ${NOTOL} 5 ${BASELINE}/msPyrAn_mire_log_an_2.png ${TEMP}/msPyrAn_mire_log_an_2.png ${BASELINE}/msPyrAn_mire_log_sf_2.png ${TEMP}/msPyrAn_mire_log_sf_2.png ${BASELINE}/msPyrAn_mire_log_if_2.png ${TEMP}/msPyrAn_mire_log_if_2.png ${BASELINE}/msPyrAn_mire_log_sd_2.png ${TEMP}/msPyrAn_mire_log_sd_2.png ${BASELINE}/msPyrAn_mire_log_id_2.png ${TEMP}/msPyrAn_mire_log_id_2.png otbMorphologicalPyramidAnalysisFilter ${INPUTDATA}/mire_log.png ${TEMP}/msPyrAn_mire_log png 2 2.0) otb_add_test(NAME msTvMorphoPyrSegmentBright COMMAND otbMorphologicalPyramidTestDriver --compare-image ${NOTOL} ${BASELINE}/msPyrSegmenter_IKO_Halles_4_2_sf.tif ${TEMP}/msPyrSegmenter_IKO_Halles_4_2_sf.tif otbMorphologicalPyramidSegmenter ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_sf_full.hdr ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msPyrSegmenter_IKO_Halles_4_2_sf.tif 0 0.9 0.9 10 ) set_property(TEST msTvMorphoPyrSegmentBright PROPERTY DEPENDS msTvMorphoPyrMRToMSConverter) otb_add_test(NAME msTvMorphoPyrSegmentDark COMMAND otbMorphologicalPyramidTestDriver --compare-image ${NOTOL} ${BASELINE}/msPyrSegmenter_IKO_Halles_4_2_if.tif ${TEMP}/msPyrSegmenter_IKO_Halles_4_2_if.tif otbMorphologicalPyramidSegmenter ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_if_full.hdr ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msPyrSegmenter_IKO_Halles_4_2_if.tif 1 0.9 0.9 10 ) set_property(TEST msTvMorphoPyrSegmentDark PROPERTY DEPENDS msTvMorphoPyrMRToMSConverter) otb_add_test(NAME msTuMorphoPyrSegmenterNew COMMAND otbMorphologicalPyramidTestDriver otbMorphologicalPyramidSegmenterNew) otb_add_test(NAME msTvMorphoPyrSynthesisFilter COMMAND otbMorphologicalPyramidTestDriver --compare-image ${NOTOL} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msPyrSynth_IKO_Halles_4_2.tif otbMorphologicalPyramidSynthesisFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msPyrSynth_IKO_Halles_4_2.tif 4 2.0) otb_add_test(NAME msTvMorphoPyrMRToMSConverter COMMAND otbMorphologicalPyramidTestDriver --compare-n-images ${EPSILON_8} 3 ${BASELINE}/msPyrMRToMS_IKO_Halles_4_2_sf_full.hdr ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_sf_full.hdr ${BASELINE}/msPyrMRToMS_IKO_Halles_4_2_if_full.hdr ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_if_full.hdr ${BASELINE}/msPyrMRToMS_IKO_Halles_4_2_an_full.hdr ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_an_full.hdr otbMorphologicalPyramidMRToMSConverter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_sf_full.hdr ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_if_full.hdr ${TEMP}/msPyrMRToMS_IKO_Halles_4_2_an_full.hdr 4 2.0) otb_add_test(NAME msTuMorphoPyrSynthesisFilterNew COMMAND otbMorphologicalPyramidTestDriver otbMorphologicalPyramidSynthesisFilterNew) otb_add_test(NAME msTuMorphoPyrMRToMSConverterNew COMMAND otbMorphologicalPyramidTestDriver otbMorphologicalPyramidMRToMSConverterNew) otb_add_test(NAME msTvMorphoPyrResampler COMMAND otbMorphologicalPyramidTestDriver --compare-n-images ${EPSILON_8} 2 ${BASELINE}/msPyrResampler_IKO_LesHalles_256_2.hdr ${TEMP}/msPyrResampler_IKO_LesHalles_256_2.hdr ${BASELINE}/msPyrResampler_IKO_LesHalles_full.hdr ${TEMP}/msPyrResampler_IKO_LesHalles_full.hdr otbMorphologicalPyramidResampler ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msPyrResampler_IKO_LesHalles_256_2.hdr ${TEMP}/msPyrResampler_IKO_LesHalles_full.hdr 256 256 ) otb_add_test(NAME msTuMorphoPyrAnalysisFilterNew COMMAND otbMorphologicalPyramidTestDriver otbMorphologicalPyramidAnalysisFilterNew) otb_add_test(NAME msTuMorphoPyrResamplerNew COMMAND otbMorphologicalPyramidTestDriver otbMorphologicalPyramidResamplerNew) otb_add_test(NAME msTvMorphoPyrSegmentationFilter COMMAND otbMorphologicalPyramidTestDriver --compare-n-images ${NOTOL} 4 ${BASELINE}/msPyrSegmentation_IKO_Halles_2.tif ${TEMP}/msPyrSegmentation_IKO_Halles_2.tif ${BASELINE}/msPyrSegmentation_IKO_Halles_4.tif ${TEMP}/msPyrSegmentation_IKO_Halles_4.tif ${BASELINE}/msPyrSegmentation_IKO_Halles_5.tif ${TEMP}/msPyrSegmentation_IKO_Halles_5.tif ${BASELINE}/msPyrSegmentation_IKO_Halles_7.tif ${TEMP}/msPyrSegmentation_IKO_Halles_7.tif otbMorphologicalPyramidSegmentationFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msPyrSegmentation_IKO_Halles_ tif 4 2.0 0.9 0.9 10 ) otbMorphologicalPyramidAnalysisFilter.cxx000066400000000000000000000104161301006202600342300ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidAnalysisFilter.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbMorphologicalPyramidAnalysisFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; const unsigned int numberOfLevels = atoi(argv[4]); const float decimationRatio = atof(argv[5]); const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; typedef otb::MorphologicalPyramidAnalysisFilter PyramidFilterType; typedef PyramidFilterType::OutputImageListType::Iterator ImageListIterator; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Instantiation PyramidFilterType::Pointer pyramid = PyramidFilterType::New(); pyramid->SetNumberOfLevels(numberOfLevels); pyramid->SetDecimationRatio(decimationRatio); pyramid->SetInput(reader->GetOutput()); pyramid->Update(); // Retrieving iterators on the results images ImageListIterator itAnalyse = pyramid->GetOutput()->Begin(); ImageListIterator itSupFilter = pyramid->GetSupFilter()->Begin(); ImageListIterator itInfFilter = pyramid->GetInfFilter()->Begin(); ImageListIterator itInfDeci = pyramid->GetInfDeci()->Begin(); ImageListIterator itSupDeci = pyramid->GetSupDeci()->Begin(); WriterType::Pointer writer = WriterType::New(); int i = 1; // std::stringstream oss; std::ostringstream oss; // Writing the results images while ((itAnalyse != pyramid->GetOutput()->End()) && (itSupFilter != pyramid->GetSupFilter()->End()) && (itInfFilter != pyramid->GetInfFilter()->End()) && (itInfDeci != pyramid->GetInfDeci()->End()) && (itSupDeci != pyramid->GetSupDeci()->End()) ) { oss << outputFilenamePrefix << "_an_" << i << "." << outputFilenameSuffix; writer->SetInput(itAnalyse.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); oss << outputFilenamePrefix << "_sf_" << i << "." << outputFilenameSuffix; writer->SetInput(itSupFilter.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); oss << outputFilenamePrefix << "_if_" << i << "." << outputFilenameSuffix; writer->SetInput(itInfFilter.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); oss << outputFilenamePrefix << "_id_" << i << "." << outputFilenameSuffix; writer->SetInput(itInfDeci.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); std::cout << "File " << oss.str() << " written" << std::endl; oss.str(""); oss << outputFilenamePrefix << "_sd_" << i << "." << outputFilenameSuffix; writer->SetInput(itSupDeci.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); ++itAnalyse; ++itSupFilter; ++itInfFilter; ++itInfDeci; ++itSupDeci; ++i; } return EXIT_SUCCESS; } otbMorphologicalPyramidAnalysisFilterNew.cxx000066400000000000000000000033221301006202600347000ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidAnalysisFilter.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImage.h" int otbMorphologicalPyramidAnalysisFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; typedef otb::MorphologicalPyramidAnalysisFilter PyramidFilterType; // Instantiation PyramidFilterType::Pointer pyramid = PyramidFilterType::New(); std::cout << pyramid << std::endl; return EXIT_SUCCESS; } otbMorphologicalPyramidMRToMSConverter.cxx000066400000000000000000000065651301006202600342620ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidAnalysisFilter.h" #include "otbMorphologicalPyramidMRToMSConverter.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbMorphologicalPyramidMRToMSConverter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename1 = argv[2]; const char * outputFilename2 = argv[3]; const char * outputFilename3 = argv[4]; const unsigned int numberOfLevels = atoi(argv[5]); const float decimationRatio = atof(argv[6]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; typedef otb::MorphologicalPyramidAnalysisFilter PyramidAnalysisFilterType; typedef otb::MorphologicalPyramid::MRToMSConverter MRToMSConverterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Analysis PyramidAnalysisFilterType::Pointer pyramidAnalysis = PyramidAnalysisFilterType::New(); pyramidAnalysis->SetNumberOfLevels(numberOfLevels); pyramidAnalysis->SetDecimationRatio(decimationRatio); pyramidAnalysis->SetInput(reader->GetOutput()); // From multi resolution to multi scale MRToMSConverterType::Pointer mrtoms = MRToMSConverterType::New(); mrtoms->SetInput(pyramidAnalysis->GetOutput()); mrtoms->SetSupFilter(pyramidAnalysis->GetSupFilter()); mrtoms->SetSupDeci(pyramidAnalysis->GetSupDeci()); mrtoms->SetInfFilter(pyramidAnalysis->GetInfFilter()); mrtoms->SetInfDeci(pyramidAnalysis->GetInfDeci()); mrtoms->Update(); // Writing the output images WriterType::Pointer writer1 = WriterType::New(); writer1->SetFileName(outputFilename1); writer1->SetInput(mrtoms->GetSupFilterFullResolution()->Back()); writer1->Update(); WriterType::Pointer writer2 = WriterType::New(); writer2->SetFileName(outputFilename2); writer2->SetInput(mrtoms->GetInfFilterFullResolution()->Back()); writer2->Update(); WriterType::Pointer writer3 = WriterType::New(); writer3->SetFileName(outputFilename3); writer3->SetInput(mrtoms->GetOutput()->Back()); writer3->Update(); return EXIT_SUCCESS; } otbMorphologicalPyramidMRToMSConverterNew.cxx000066400000000000000000000024771301006202600347320ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidMRToMSConverter.h" #include "otbImage.h" int otbMorphologicalPyramidMRToMSConverterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::MorphologicalPyramid::MRToMSConverter MRToMSConverterType; // Instantiation MRToMSConverterType::Pointer mrtoms = MRToMSConverterType::New(); std::cout << mrtoms << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/otbMorphologicalPyramidResampler.cxx000066400000000000000000000045051301006202600333120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidResampler.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbMorphologicalPyramidResampler(int itkNotUsed(argc), char * argv[]) { const char* inputFilename = argv[1]; const char* outputFilename1 = argv[2]; const char* outputFilename2 = argv[3]; const unsigned int size_x = atoi(argv[4]); const unsigned int size_y = atoi(argv[5]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MorphologicalPyramid::Resampler ResamplerType; // Input image reading ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); InputImageType::SizeType size; size[0] = size_x; size[1] = size_y; // Instantiation ResamplerType::Pointer resampler = ResamplerType::New(); resampler->SetInput(reader->GetOutput()); resampler->SetSize(size); // File writing WriterType::Pointer writer = WriterType::New(); writer->SetInput(resampler->GetOutput()); writer->SetFileName(outputFilename1); writer->Update(); ResamplerType::Pointer resampler2 = ResamplerType::New(); resampler2->SetInput(resampler->GetOutput()); resampler2->SetSize(reader->GetOutput()->GetLargestPossibleRegion().GetSize()); WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(resampler2->GetOutput()); writer2->SetFileName(outputFilename2); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/otbMorphologicalPyramidResamplerNew.cxx000066400000000000000000000023311301006202600337570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidResampler.h" #include "otbImage.h" int otbMorphologicalPyramidResamplerNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::MorphologicalPyramid::Resampler ResamplerType; // Instantiation ResamplerType::Pointer resampler = ResamplerType::New(); std::cout << resampler << std::endl; return EXIT_SUCCESS; } otbMorphologicalPyramidSegmentationFilter.cxx000066400000000000000000000071531301006202600351060ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidSegmentationFilter.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbMorphologicalPyramidAnalysisFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbMorphologicalPyramidSegmentationFilter(int itkNotUsed(argc), char * argv[]) { const char* inputFilename = argv[1]; const char* outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; const unsigned int numberOfLevels = atoi(argv[4]); const double decimationRatio = atof(argv[5]); const float seedsQuantile = atof(argv[6]); const float segmentationQuantile = atof(argv[7]); const unsigned int minObjectSize = atoi(argv[8]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned short OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; typedef otb::MorphologicalPyramidAnalysisFilter PyramidFilterType; typedef otb::MorphologicalPyramidSegmentationFilter SegmentationFilterType; typedef SegmentationFilterType::OutputImageListIteratorType OutputListIteratorType; // Input images reading ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); //Analyse PyramidFilterType::Pointer pyramid = PyramidFilterType::New(); pyramid->SetNumberOfLevels(numberOfLevels); pyramid->SetDecimationRatio(decimationRatio); pyramid->SetInput(reader->GetOutput()); // Segmentation SegmentationFilterType::Pointer segmentation = SegmentationFilterType::New(); segmentation->SetReferenceImage(reader->GetOutput()); segmentation->SetBrighterDetails(pyramid->GetSupFilter()); segmentation->SetDarkerDetails(pyramid->GetInfFilter()); segmentation->SetSeedsQuantile(seedsQuantile); segmentation->SetConnectedThresholdQuantile(segmentationQuantile); segmentation->SetMinimumObjectSize(minObjectSize); segmentation->Update(); // Output writing OutputListIteratorType it = segmentation->GetOutput()->Begin(); WriterType::Pointer writer; int index = 1; std::stringstream oss; while (it != segmentation->GetOutput()->End()) { oss << outputFilenamePrefix << index << "." << outputFilenameSuffix; writer = WriterType::New(); writer->SetInput(it.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); std::cout << oss.str() << " file written." << std::endl; oss.str(""); ++index; ++it; } return EXIT_SUCCESS; } otbMorphologicalPyramidSegmentationFilterNew.cxx000066400000000000000000000024111301006202600355500ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidSegmentationFilter.h" #include "otbImage.h" int otbMorphologicalPyramidSegmentationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned short OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::MorphologicalPyramidSegmentationFilter SegmentationFilterType; // Instantiation SegmentationFilterType::Pointer filter = SegmentationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/otbMorphologicalPyramidSegmenter.cxx000066400000000000000000000045751301006202600333200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidSegmenter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbMorphologicalPyramidSegmenter(int itkNotUsed(argc), char * argv[]) { const char* inputFilename = argv[1]; const char* originalFilename = argv[2]; const char* outputFilename1 = argv[3]; const bool segmentDark = atoi(argv[4]); const float seedsQuantile = atof(argv[5]); const float segmentationQuantile = atof(argv[6]); const unsigned int minObjectSize = atoi(argv[7]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned short OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MorphologicalPyramid::Segmenter SegmenterType; // Input images reading ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(originalFilename); // Instantiation SegmenterType::Pointer segmenter = SegmenterType::New(); segmenter->SetDetailsImage(reader->GetOutput()); segmenter->SetOriginalImage(reader2->GetOutput()); segmenter->SetSegmentDarkDetailsBool(segmentDark); segmenter->SetSeedsQuantile(seedsQuantile); segmenter->SetConnectedThresholdQuantile(segmentationQuantile); segmenter->SetMinimumObjectSize(minObjectSize); // File writing WriterType::Pointer writer = WriterType::New(); writer->SetInput(segmenter->GetOutput()); writer->SetFileName(outputFilename1); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/otbMorphologicalPyramidSegmenterNew.cxx000066400000000000000000000023331301006202600337600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidSegmenter.h" #include "otbImage.h" int otbMorphologicalPyramidSegmenterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned short OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::MorphologicalPyramid::Segmenter SegmenterType; // Instantiation SegmenterType::Pointer segmenter = SegmenterType::New(); std::cout << segmenter << std::endl; return EXIT_SUCCESS; } otbMorphologicalPyramidSynthesisFilter.cxx000066400000000000000000000060421301006202600344360ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidAnalysisFilter.h" #include "otbMorphologicalPyramidSynthesisFilter.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbMorphologicalPyramidSynthesisFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const unsigned int numberOfLevels = atoi(argv[3]); const float decimationRatio = atof(argv[4]); const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; typedef otb::MorphologicalPyramidAnalysisFilter PyramidAnalysisFilterType; typedef otb::MorphologicalPyramidSynthesisFilter PyramidSynthesisFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Analysis PyramidAnalysisFilterType::Pointer pyramidAnalysis = PyramidAnalysisFilterType::New(); pyramidAnalysis->SetNumberOfLevels(numberOfLevels); pyramidAnalysis->SetDecimationRatio(decimationRatio); pyramidAnalysis->SetInput(reader->GetOutput()); pyramidAnalysis->Update(); // Synthesis PyramidSynthesisFilterType::Pointer pyramidSynthesis = PyramidSynthesisFilterType::New(); pyramidSynthesis->SetInput(pyramidAnalysis->GetOutput()->Back()); pyramidSynthesis->SetSupFilter(pyramidAnalysis->GetSupFilter()); pyramidSynthesis->SetSupDeci(pyramidAnalysis->GetSupDeci()); pyramidSynthesis->SetInfFilter(pyramidAnalysis->GetInfFilter()); pyramidSynthesis->SetInfDeci(pyramidAnalysis->GetInfDeci()); pyramidSynthesis->Update(); // Writing the output image WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(pyramidSynthesis->GetOutput()->Back()); writer->Update(); return EXIT_SUCCESS; } otbMorphologicalPyramidSynthesisFilterNew.cxx000066400000000000000000000024131301006202600351060ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMorphologicalPyramidSynthesisFilter.h" #include "otbImage.h" int otbMorphologicalPyramidSynthesisFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::MorphologicalPyramidSynthesisFilter PyramidSynthesisFilterType; // Instantiation PyramidSynthesisFilterType::Pointer filter = PyramidSynthesisFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/MorphologicalPyramid/test/otbMorphologicalPyramidTestDriver.cxx000066400000000000000000000013341301006202600334500ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMorphologicalPyramidSegmentationFilterNew); REGISTER_TEST(otbMorphologicalPyramidAnalysisFilter); REGISTER_TEST(otbMorphologicalPyramidSegmenter); REGISTER_TEST(otbMorphologicalPyramidSegmenterNew); REGISTER_TEST(otbMorphologicalPyramidSynthesisFilter); REGISTER_TEST(otbMorphologicalPyramidMRToMSConverter); REGISTER_TEST(otbMorphologicalPyramidSynthesisFilterNew); REGISTER_TEST(otbMorphologicalPyramidMRToMSConverterNew); REGISTER_TEST(otbMorphologicalPyramidResampler); REGISTER_TEST(otbMorphologicalPyramidAnalysisFilterNew); REGISTER_TEST(otbMorphologicalPyramidResamplerNew); REGISTER_TEST(otbMorphologicalPyramidSegmentationFilter); } OTB-release-5.8/Modules/Filtering/Path/000077500000000000000000000000001301006202600176455ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Path/CMakeLists.txt000066400000000000000000000000431301006202600224020ustar00rootroot00000000000000project(OTBPath) otb_module_impl() OTB-release-5.8/Modules/Filtering/Path/include/000077500000000000000000000000001301006202600212705ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Path/include/otbClosePathFunctor.h000066400000000000000000000042371301006202600253770ustar00rootroot00000000000000 /*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbClosePathFunctor_h #define otbClosePathFunctor_h #include "otbMath.h" namespace otb { /** \class ClosePathFunctor * \brief This filter close the input path, making the last point equal to the first one. * * This filter may be useful when a truly closed polygon is needed (to draw it for example) * * \sa UnaryFunctorObjectListFilter * * \ingroup Functor * * \ingroup OTBPath */ template class ClosePathFunctor { public: typedef typename TInput::VertexListType::ConstIterator VertexListConstIteratorType; typedef typename TInput::VertexListType::ConstPointer VertexListConstPointerType; typedef TOutput OutputPathType; typedef typename OutputPathType::Pointer OutputPathPointerType; ClosePathFunctor() {} virtual ~ClosePathFunctor() {} inline OutputPathPointerType operator ()(const TInput * input) { OutputPathPointerType newPath = OutputPathType::New(); newPath->Initialize(); typename TInput::VertexType lastVertex; if(input->GetVertexList()->Size()>0) { for (VertexListConstIteratorType vertexIt = input->GetVertexList()->Begin(); vertexIt != input->GetVertexList()->End(); ++vertexIt) { newPath->AddVertex(vertexIt.Value()); lastVertex = vertexIt.Value(); } if (lastVertex != input->GetVertexList()->Begin().Value()) { newPath->AddVertex(input->GetVertexList()->Begin().Value()); } } newPath->SetMetaDataDictionary(input->GetMetaDataDictionary()); return newPath; } }; } #endif OTB-release-5.8/Modules/Filtering/Path/include/otbCompacityPathFunction.h000066400000000000000000000051761301006202600264320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCompacityPathFunction_h #define otbCompacityPathFunction_h #include "otbPathFunction.h" #include "itkVectorContainer.h" namespace otb { /** * \class CompacityPathFunction * \brief Calculate the compacity of a path. * The formula of the compacity is : * \f[ compacity = 4 \pi Surface / Perimeter^{2} \f] * * The path must contain at least 3 points. * The result value is comprise between 0.0 and 1.0 * * \ingroup PathFunctions * * \ingroup OTBPath */ template class ITK_EXPORT CompacityPathFunction : public PathFunction { public: /** Standard class typedefs. */ typedef CompacityPathFunction Self; typedef PathFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(CompacityPathFunction, PathFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputPathType typedef support. */ typedef typename Superclass::InputPathType PathType; typedef typename Superclass::InputPathConstPointer PathConstPointer; typedef typename PathType::ContinuousIndexType VertexType; typedef itk::VectorContainer VertexListType; typedef typename VertexListType::ConstPointer VertexListPointer; typedef TOutput OutputType; typedef double RealType; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PathType& path) const ITK_OVERRIDE; virtual OutputType Evaluate() const; protected: CompacityPathFunction() {}; ~CompacityPathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: CompacityPathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbCompacityPathFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbCompacityPathFunction.txx000066400000000000000000000054731301006202600270260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCompacityPathFunction_txx #define otbCompacityPathFunction_txx #include "otbCompacityPathFunction.h" #include "itkNumericTraits.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { template void CompacityPathFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } template typename CompacityPathFunction::OutputType CompacityPathFunction ::Evaluate(const PathType& path) const { typedef double RealType; VertexListPointer vertexList; VertexType cindex; VertexType IndexOut; int nbPath; RealType Surface = 0.0; RealType Perimeter = 0.0; RealType Compacity; RealType x1, x2, y1, y2; vertexList = path.GetVertexList(); nbPath = vertexList->Size(); if (nbPath > 2) { for (int i = 0; i < nbPath; ++i) { cindex = vertexList->GetElement(i); x1 = cindex[0]; y1 = cindex[1]; if (i == (nbPath - 1)) { cindex = vertexList->GetElement(0); } else { cindex = vertexList->GetElement(i + 1); } x2 = cindex[0]; y2 = cindex[1]; RealType Norm; Norm = vcl_sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)); Perimeter += Norm; RealType P = x2 * (y2 - y1); RealType Q = y2 * (x2 - x1); Surface += (P - Q); } // FOR loop } // IF loop else { itkExceptionMacro(<< "CompacityPathFunction::Evaluate() FAILED -- path must contains at least 3 points"); } Surface /= 2.0; Compacity = Surface / (Perimeter * Perimeter); Compacity *= (4. * acos(-1.0)); return (static_cast(Compacity)); } template typename CompacityPathFunction::OutputType CompacityPathFunction ::Evaluate() const { if (!this->GetInputPath()) { otbMsgDevMacro(<< "Problem with GetInputPath"); return static_cast(itk::NumericTraits::max()); } OutputType Result = Evaluate(*(this->GetInputPath())); return Result; } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbDrawPathFilter.h000066400000000000000000000077141301006202600250370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawPathFilter_h #define otbDrawPathFilter_h #include "itkImageAndPathToImageFilter.h" namespace otb { /** \class DrawPathFilter * \brief This class can be used to draw a single path on an image. * * It encapsulates the use of the otb::DrawPathListFilter by internally creating * an otb::ObjectList of size one and passing it to a DrawPathListFilter. * * Please note that iterating this filter to draw several path is NOT efficient. If you * have several path to draw, consider using the otb::DrawPathListFilter. * * \sa DrawPathListFilter * * \ingroup PathFilters * \ingroup ImageFilters * * \ingroup OTBPath */ template class ITK_EXPORT DrawPathFilter : public itk::ImageAndPathToImageFilter { public: /** Standard class typedefs. */ typedef DrawPathFilter Self; typedef itk::ImageAndPathToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DrawPathFilter, itk::ImageAndPathToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TInputPath InputPathType; typedef typename InputPathType::Pointer InputPathPointer; typedef typename InputPathType::ConstPointer InputPathConstPointer; typedef typename InputPathType::InputType InputPathInputType; typedef typename InputPathType::OutputType InputPathOutputType; typedef typename InputPathType::IndexType InputPathIndexType; typedef typename InputPathType::OffsetType InputPathOffsetType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::ValueType OutputImageValueType; itkSetMacro(Value, OutputImagePixelType); itkGetConstReferenceMacro(Value, OutputImagePixelType); /** Set/Get the path input of this process object. Note: these methods are adding to get the proper name */ void SetInputPath(const TInputPath * path); const TInputPath * GetInputPath(void); protected: DrawPathFilter(); ~DrawPathFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: DrawPathFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputImagePixelType m_Value; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDrawPathFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbDrawPathFilter.txx000066400000000000000000000047061301006202600254310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawPathFilter_txx #define otbDrawPathFilter_txx #include "otbDrawPathFilter.h" #include "otbDrawPathListFilter.h" namespace otb { /** * Constructor */ template DrawPathFilter ::DrawPathFilter() { m_Value = static_cast(255.0); } template inline void DrawPathFilter ::SetInputPath(const TInputPath * path) { this->SetPathInput(path); } template const TInputPath * DrawPathFilter ::GetInputPath(void) { return this->GetPathInput(); } /** * Main computation method. */ template void DrawPathFilter ::GenerateData(void) { typedef otb::DrawPathListFilter DrawListFilterType; typedef typename DrawListFilterType::InputPathListType PathListType; typename PathListType::Pointer list = PathListType::New(); InputPathPointer path = const_cast(this->GetPathInput()); list->PushBack(path); typename DrawListFilterType::Pointer drawer = DrawListFilterType::New(); drawer->SetInput(this->GetImageInput()); drawer->SetInputPath(list); drawer->SetPathValue(m_Value); drawer->GraftOutput(this->GetOutput()); drawer->Update(); this->GraftOutput(drawer->GetOutput()); } /** * Printself Method */ template void DrawPathFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Path Value: " << m_Value << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbDrawPathListFilter.h000066400000000000000000000116621301006202600256700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawPathListFilter_h #define otbDrawPathListFilter_h #include "itkImageToImageFilter.h" #include "otbObjectList.h" namespace otb { /** \class DrawPathListFilter * \brief This class can be used to draw a list of path on an image. * * This filter first copy the input image to the output, with default casting operators. * It then uses the otb::PolyLineImageIterator to draw each polyline. This iterator uses * the general Bresenham algorithm known to be efficient in segment drawing. * * If the UsePathInternalValue is toggled, the filter check if the metadata dictionary of * the input path has a "Value" key. If it is the case, it will use this value to draw the * Path instead of the default value. If not, it will use the default value. * * \sa PolyLineParametricPathWithValue * \sa MetaDataDictionary * * \ingroup PathListFilters * \ingroup PathLists * * \ingroup OTBPath */ template class ITK_EXPORT DrawPathListFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef DrawPathListFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DrawPathListFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType InputImageSizeType; typedef typename InputImageType::ValueType InputImageValueType; typedef TInputPath InputPathType; typedef typename InputPathType::Pointer InputPathPointerType; typedef otb::ObjectList InputPathListType; typedef typename InputPathListType::ConstPointer InputPathListConstPointerType; typedef typename InputPathListType::Pointer InputPathListPointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::ConstPointer OutputImageConstPointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename OutputImageType::ValueType OutputImageValueType; typedef typename OutputImageType::IndexType OutputImageIndexType; typedef itk::ProcessObject ProcessObjectType; itkGetMacro(UseInternalPathValue, bool); itkSetMacro(UseInternalPathValue, bool); itkBooleanMacro(UseInternalPathValue); itkGetMacro(AddValue, bool); itkSetMacro(AddValue, bool); itkBooleanMacro(AddValue); itkSetMacro(PathValue, OutputImagePixelType); itkGetMacro(PathValue, OutputImagePixelType); /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Set/Get the path input of this process object. */ virtual void SetInputPath(InputPathListType *path); const InputPathListType * GetInputPath(void); protected: /** Constructor */ DrawPathListFilter(); /** Desctructor */ ~DrawPathListFilter() ITK_OVERRIDE {} /** Printself method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; private: DrawPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Default value to draw */ OutputImagePixelType m_PathValue; /** If set to true, the algorithm try to use path internal metadata dictionary value */ bool m_UseInternalPathValue; bool m_AddValue; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDrawPathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbDrawPathListFilter.txx000066400000000000000000000101321301006202600262530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDrawPathListFilter_txx #define otbDrawPathListFilter_txx #include "otbDrawPathListFilter.h" #include "itkImageRegionIterator.h" #include "otbPolyLineImageIterator.h" #include "itkMetaDataObject.h" namespace otb { /** * Constructor */ template DrawPathListFilter ::DrawPathListFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); m_PathValue = static_cast(255); m_UseInternalPathValue = false; m_AddValue = false; } template void DrawPathListFilter ::SetInputPath(InputPathListType *path) { this->ProcessObjectType::SetNthInput(1, const_cast(path)); } template const typename DrawPathListFilter::InputPathListType * DrawPathListFilter ::GetInputPath(void) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->ProcessObjectType::GetInput(1)); } /** * Main computation method */ template void DrawPathListFilter ::GenerateData(void) { OutputImagePointerType outputPtr = this->GetOutput(); InputImageConstPointerType inputPtr = this->GetInput(); InputPathListConstPointerType pathListPtr = this->GetInputPath(); outputPtr->SetRegions(inputPtr->GetLargestPossibleRegion()); outputPtr->Allocate(); outputPtr->FillBuffer(itk::NumericTraits::Zero); // First, we copy input to output typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionConstIterator InputIteratorType; typedef typename InputPathListType::ConstIterator PathListIteratorType; typedef PolyLineImageIterator PolyLineIteratorType; OutputIteratorType outIt(outputPtr, outputPtr->GetLargestPossibleRegion()); InputIteratorType inIt(inputPtr, inputPtr->GetLargestPossibleRegion()); for (outIt.GoToBegin(), inIt.GoToBegin(); (!outIt.IsAtEnd() && !inIt.IsAtEnd()); ++outIt, ++inIt) { outIt.Set(static_cast(inIt.Get())); } // Then we use otb::PolyLineImageIterator to draw polylines for (PathListIteratorType plIt = pathListPtr->Begin(); plIt != pathListPtr->End(); ++plIt) { OutputImagePixelType value = itk::NumericTraits::Zero; if (m_UseInternalPathValue && plIt.Get()->GetMetaDataDictionary().HasKey("Value")) { itk::ExposeMetaData(plIt.Get()->GetMetaDataDictionary(), "Value", value); } else { value = static_cast(m_PathValue); } PolyLineIteratorType imageIt(outputPtr, plIt.Get()); for (imageIt.GoToBegin(); !imageIt.IsAtEnd(); ++imageIt) { if (m_AddValue) { imageIt.Set(imageIt.Get() + 1); } else { imageIt.Set(value); } } } } /** * Printself method */ template void DrawPathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageFittingPolygonListFilter.h000066400000000000000000000074301301006202600300730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFittingPolygonListFilter_h #define otbImageFittingPolygonListFilter_h #include "otbPathListToPathListFilter.h" #include "otbMacro.h" #include "itkLineConstIterator.h" namespace otb { /** \class ImageFittingPolygonListFilter * \brief Slightly deform polygon to reach higher enery from the image * * Limitations: This filter is currently working with integer position * for the polygon vertices. It should be optimized for continuous positions. * * * \ingroup OTBPath */ template class ITK_EXPORT ImageFittingPolygonListFilter : public PathListToPathListFilter { public: /** Standard typedefs */ typedef ImageFittingPolygonListFilter Self; typedef PathListToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageFittingPolygonListFilter, PathListToPathListFilter); /** Template parameters typedefs */ typedef typename Superclass::PathType PathType; typedef typename Superclass::PathListType PathListType; typedef typename Superclass::PathPointerType PathPointerType; typedef typename PathListType::Pointer PathListPointerType; typedef typename PathListType::ConstIterator IteratorType; typedef typename PathType::VertexType VertexType; typedef typename PathType::VertexListType VertexListType; typedef typename VertexListType::ConstIterator VertexListConstIteratorType; typedef double RealType; typedef TImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::ConstPointer ImageConstPointerType; typedef itk::LineConstIterator LineConstIteratorType; /** * Set the input Likelihood image. * \param image The Likelihood image. */ void SetInputImage(const ImageType * image); /** * Get the input Likelihood image. * \return The input Likelihood image. */ const ImageType * GetInputImage(void); /** Set/Get the search radius. */ itkSetMacro(Radius, unsigned int); itkGetMacro(Radius, unsigned int); /** Set/Get the number of iteration. */ itkSetMacro(NumberOfIterations, unsigned int); itkGetMacro(NumberOfIterations, unsigned int); protected: /** Constructor */ ImageFittingPolygonListFilter(); /** Destructor */ ~ImageFittingPolygonListFilter() ITK_OVERRIDE {} /** GenerateData method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; virtual double computeValue(ImageConstPointerType image, VertexType middlePoint, VertexType previousPoint, VertexType nextPoint) const; unsigned int m_Radius; unsigned int m_NumberOfIterations; private: ImageFittingPolygonListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageFittingPolygonListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageFittingPolygonListFilter.txx000066400000000000000000000211561301006202600304700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFittingPolygonListFilter_txx #define otbImageFittingPolygonListFilter_txx #include "otbImageFittingPolygonListFilter.h" #include "otbPolyLineImageConstIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" namespace otb { /** * Constructor */ template ImageFittingPolygonListFilter ::ImageFittingPolygonListFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(2); m_Radius = 1; m_NumberOfIterations = 1; } template void ImageFittingPolygonListFilter ::SetInputImage(const ImageType * image) { this->itk::ProcessObject::SetNthInput(1, const_cast(image)); } template const typename ImageFittingPolygonListFilter ::ImageType * ImageFittingPolygonListFilter ::GetInputImage(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } //FIXME //There is an issue here with integer and continuous indexes //maybe we should use the itk::LineConstIterator template void ImageFittingPolygonListFilter ::GenerateData() { // I/O wiring ImageConstPointerType inputImagePtr = this->GetInputImage(); const PathListType * inputPtr = this->GetInput(); PathListType * outputPtr = this->GetOutput(); typename ImageType::RegionType regionLargest = inputImagePtr->GetLargestPossibleRegion(); typedef itk::ImageRegionConstIteratorWithIndex NeighborhoodIteratorType; typename ImageType::SizeType size; size[0] = 2 * m_Radius + 1; size[1] = 2 * m_Radius + 1; typename ImageType::RegionType region; region.SetSize(size); typename ImageType::IndexType start; //go through all the polygons in the list IteratorType it = inputPtr->Begin(); while (it != inputPtr->End()) { PathPointerType polygon = it.Get(); if (polygon->GetVertexList()->Size() > 2) { for (unsigned int iteration = 0; iteration < m_NumberOfIterations; ++iteration) { PathPointerType newPolygon = PathType::New(); VertexListConstIteratorType vertexIt = polygon->GetVertexList()->Begin(); //We are now going to go through all the vertex, we won't start to process // first as we need to know the last one for that. VertexType firstPoint = vertexIt.Value(); VertexType previousPoint = vertexIt.Value(); ++vertexIt; VertexType currentPoint = vertexIt.Value(); ++vertexIt; while (vertexIt != polygon->GetVertexList()->End()) { VertexType nextPoint = vertexIt.Value(); /** try all the possible neighbor for the current point * to factorize * */ { start[0] = static_cast(currentPoint[0] - m_Radius); start[1] = static_cast(currentPoint[1] - m_Radius); region.SetIndex(start); region.Crop(inputImagePtr->GetLargestPossibleRegion()); NeighborhoodIteratorType nIt(inputImagePtr, region); double maxValue = 0.0; VertexType maxPoint = currentPoint; nIt.GoToBegin(); while (!nIt.IsAtEnd()) { if (regionLargest.IsInside(nIt.GetIndex())) { VertexType middlePoint = static_cast(nIt.GetIndex()); double currentValue = computeValue(inputImagePtr, middlePoint, previousPoint, nextPoint); if (currentValue > maxValue) { maxValue = currentValue; maxPoint = middlePoint; } } ++nIt; } currentPoint = maxPoint; newPolygon->AddVertex(maxPoint); } /** End 'to factorize' */ ++vertexIt; previousPoint = currentPoint; currentPoint = nextPoint; } //We now need to process the last and the first point VertexType nextPoint = firstPoint; /** try all the possible neighbor for the current point * to factorize * */ { start[0] = static_cast(currentPoint[0] - m_Radius); start[1] = static_cast(currentPoint[1] - m_Radius); region.SetIndex(start); NeighborhoodIteratorType nIt(inputImagePtr, region); double maxValue = 0.0; VertexType maxPoint = currentPoint; nIt.GoToBegin(); while (!nIt.IsAtEnd()) { if (regionLargest.IsInside(nIt.GetIndex())) { VertexType middlePoint = static_cast(nIt.GetIndex()); double currentValue = computeValue(inputImagePtr, middlePoint, previousPoint, nextPoint); if (currentValue > maxValue) { maxValue = currentValue; maxPoint = middlePoint; } } ++nIt; } currentPoint = maxPoint; newPolygon->AddVertex(maxPoint); } /** End 'to factorize' */ previousPoint = currentPoint; currentPoint = firstPoint; vertexIt = newPolygon->GetVertexList()->Begin(); nextPoint = vertexIt.Value(); /** try all the possible neighbor for the current point * to factorize * */ { start[0] = static_cast(currentPoint[0] - m_Radius); start[1] = static_cast(currentPoint[1] - m_Radius); region.SetIndex(start); NeighborhoodIteratorType nIt(inputImagePtr, region); double maxValue = 0.0; VertexType maxPoint = currentPoint; nIt.GoToBegin(); while (!nIt.IsAtEnd()) { if (regionLargest.IsInside(nIt.GetIndex())) { VertexType middlePoint = static_cast(nIt.GetIndex()); double currentValue = computeValue(inputImagePtr, middlePoint, previousPoint, nextPoint); if (currentValue > maxValue) { maxValue = currentValue; maxPoint = middlePoint; } } ++nIt; } currentPoint = maxPoint; newPolygon->AddVertex(maxPoint); } /** End 'to factorize' */ polygon = newPolygon; //prepare the next iteration } } outputPtr->PushBack(polygon); ++it; } //going through the polygon list } template double ImageFittingPolygonListFilter ::computeValue(ImageConstPointerType image, VertexType middlePoint, VertexType previousPoint, VertexType nextPoint) const { typedef typename ImageType::IndexType IndexType; IndexType middleIndex; IndexType previousIndex; IndexType nextIndex; middleIndex[0] = static_cast(middlePoint[0]); middleIndex[1] = static_cast(middlePoint[1]); previousIndex[0] = static_cast(previousPoint[0]); previousIndex[1] = static_cast(previousPoint[1]); nextIndex[0] = static_cast(nextPoint[0]); nextIndex[1] = static_cast(nextPoint[1]); double currentValue = 0.0; unsigned int count = 0; //compute for first segment LineConstIteratorType itLineFirst(image, previousIndex, middleIndex); while (!itLineFirst.IsAtEnd()) { currentValue += itLineFirst.Get(); ++count; ++itLineFirst; } //compute for second segment LineConstIteratorType itLineSecond(image, nextIndex, middleIndex); while (!itLineSecond.IsAtEnd()) { currentValue += itLineSecond.Get(); ++count; ++itLineSecond; } return currentValue / count; } /** * PrintSelf Method */ template void ImageFittingPolygonListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageToEdgePathFilter.h000066400000000000000000000071221301006202600262450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToEdgePathFilter_h #define otbImageToEdgePathFilter_h #include "otbImageToPathFilter.h" namespace otb { /** * \class ImageToEdgePathFilter * \brief This filter compute the closed edge path of a labelled object * in an image (for example coming from a segmentation filter). Its output * is a Path. * * The input image is first surrounded by a 1 pixel wide border-line using the * ConstantPadImageFilter in order to deal with stuck-to-the-border * objects. The padding constant is chosen as regard to the ForegroundValue (label of * the object) to avoid confusion on foreground and background values. * * The edge computation is divided into two steps. * * First, a linear search is performed to detect a first pixel belonging to the edge of * the object. * * From that pixel and until the algorithm comes back to this position, the neighborhood * is iteratively and clock-wise searched to detect the next pixel in the edge. * * In case of linear object (in fact open edge), the algorithm will walk the object twice in * opposite directions, thus producing an edge with a null surface and twice the length of the * object as perimeter. * * This leads to consistent result for geometric descriptors (for instance compacity). * \sa ImageToPathFilter * * \ingroup OTBPath */ template class ITK_EXPORT ImageToEdgePathFilter : public ImageToPathFilter { public: /** standards typedefs */ typedef ImageToEdgePathFilter Self; typedef ImageToPathFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /// Creation through the object factory itkNewMacro(Self); /// Runtime information itkTypeMacro(ImageToEdgePathFilter, ImageToPathFilter); /// Template parameters typedef typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointerType InputImagePointerType; typedef typename Superclass::OutputPathType OutputPathType; typedef typename Superclass::OutputPathPointerType OutputPathPointerType; typedef typename OutputPathType::ContinuousIndexType ContinuousIndexType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::SizeType SizeType; /** Set and Get foreground value */ itkSetMacro(ForegroundValue, PixelType); itkGetConstMacro(ForegroundValue, PixelType); protected: ImageToEdgePathFilter(); ~ImageToEdgePathFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE {} //does nothing void GenerateData() ITK_OVERRIDE; private: ImageToEdgePathFilter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented PixelType m_ForegroundValue; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToEdgePathFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageToEdgePathFilter.txx000066400000000000000000000156601301006202600266470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToEdgePathFilter_txx #define otbImageToEdgePathFilter_txx #include "otbImageToEdgePathFilter.h" #include "otbMacro.h" #include "itkConstantPadImageFilter.h" #include "itkConstShapedNeighborhoodIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" namespace otb { /* * Constructor. */ template ImageToEdgePathFilter ::ImageToEdgePathFilter() { m_ForegroundValue = PixelType(255); } /** * Main computation method. */ template void ImageToEdgePathFilter ::GenerateData(void) { const InputImageType * inputImage = this->GetInput(); OutputPathType * outputPath = this->GetOutput(); otbMsgDebugMacro(<< "Foreground value : " << m_ForegroundValue); PixelType initPadConstant(0); if (initPadConstant == m_ForegroundValue) { initPadConstant = 1; } typedef itk::ConstantPadImageFilter PadFilterType; typedef itk::ConstShapedNeighborhoodIterator IteratorType; typedef itk::ImageRegionConstIteratorWithIndex LinearIteratorType; // Padding to deal with near the border objects. typename PadFilterType::Pointer pad = PadFilterType::New(); pad->SetInput(inputImage); pad->SetConstant(initPadConstant); SizeType padSize; padSize[ 0 ] = 1; padSize[ 1 ] = 1; pad->SetPadUpperBound(padSize); pad->SetPadLowerBound(padSize); pad->Update(); // Iterate on the image to get a starting point LinearIteratorType linIter(pad->GetOutput(), pad->GetOutput()->GetLargestPossibleRegion()); linIter.GoToBegin(); bool flag = true; while (flag && !linIter.IsAtEnd()) { if (linIter.Get() == m_ForegroundValue) { flag = false; } else { ++linIter; } } typename InputImageType::IndexType start = linIter.GetIndex(); // outputPath->AddVertex(start); // Neighborhood definition typename IteratorType::RadiusType radius; radius.Fill(1); IteratorType it(radius, pad->GetOutput(), pad->GetOutput()->GetLargestPossibleRegion()); const typename IteratorType::OffsetType LEFT = {{-1, 0}}; const typename IteratorType::OffsetType RIGHT = {{1, 0}}; const typename IteratorType::OffsetType UP = {{0, -1}}; const typename IteratorType::OffsetType DOWN = {{0, 1}}; const typename IteratorType::OffsetType LEFTUP = {{-1, -1}}; const typename IteratorType::OffsetType RIGHTDOWN = {{1, 1}}; const typename IteratorType::OffsetType RIGHTUP = {{1, -1}}; const typename IteratorType::OffsetType LEFTDOWN = {{-1, 1}}; const typename IteratorType::OffsetType CENTER = {{0, 0}}; it.ClearActiveList(); it.ActivateOffset(LEFT); it.ActivateOffset(RIGHT); it.ActivateOffset(UP); it.ActivateOffset(DOWN); it.ActivateOffset(CENTER); it.ActivateOffset(RIGHTUP); it.ActivateOffset(RIGHTDOWN); it.ActivateOffset(LEFTUP); it.ActivateOffset(LEFTDOWN); // The rotation vector allows getting the clock-wise next pixel std::vector rotation; rotation.push_back(RIGHT); rotation.push_back(RIGHTDOWN); rotation.push_back(DOWN); rotation.push_back(LEFTDOWN); rotation.push_back(LEFT); rotation.push_back(LEFTUP); rotation.push_back(UP); rotation.push_back(RIGHTUP); // Set up the iterator it.SetLocation(start); ContinuousIndexType newVertex = it.GetIndex(CENTER); if (it.GetPixel(RIGHT) == m_ForegroundValue) newVertex[0] -= 0.5; if (it.GetPixel(LEFT) == m_ForegroundValue) newVertex[0] += 0.5; if (it.GetPixel(UP) == m_ForegroundValue) newVertex[1] += 0.5; if (it.GetPixel(DOWN) == m_ForegroundValue) newVertex[1] -= 0.5; outputPath->AddVertex(newVertex); otbMsgDebugMacro(<< "START: " << start); // stopping flag flag = true; int nbMove = 0; // nexstart gives a clue of where to begin searching in next step of the search int nextStart = 0; // While the search has not eended while (flag) { // move is used to walk the neighnorhood clock-wise int move = nextStart; // edgeFound indicate that the edge has been found. bool EdgeFound = false; // LastWasPositive indicate whether the previous pixel belong to the object or not bool LastWasPositive(false); // While unexplored pixels remain and no edge was found while ((move < nextStart + 8) && (!EdgeFound)) { //otbMsgDevMacro(<<"SEARCH: "<AddVertex(newVertex); otbMsgDebugMacro(<< newVertex); // If we came back to our start point after a sufficient number of moves if ((it.GetIndex(CENTER) == start) && (nbMove >= 2)) { // search end flag = false; } else { // else for (int i = 0; i < 8; ++i) { // If we came back near our starting pointer after a sufficient number of moves if ((it.GetIndex(rotation[i]) == start) && (nbMove >= 2)) { // search end flag = false; } } } } // else else { // search ended, no pixel can be added to the edge path. flag = false; } nbMove++; } } template void ImageToEdgePathFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << "Foreground value : " << m_ForegroundValue << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageToPathFilter.h000066400000000000000000000043771301006202600254710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPathFilter_h #define otbImageToPathFilter_h #include "itkPathSource.h" namespace otb { /** * \class ImageToPathFilter * \brief Base class for filters taking an image as input, and producing an * output of type Path. * * \ingroup OTBPath */ template class ITK_EXPORT ImageToPathFilter : public itk::PathSource { public: /// Standard class typedefs typedef ImageToPathFilter Self; typedef itk::PathSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ProcessObject ProcessObjectType; /// Method for creation through the object factory itkNewMacro(Self); /// Runtime information itkTypeMacro(PathToImageFilter, PathSource); /// template parameters typedefs typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef TOutputPath OutputPathType; typedef typename OutputPathType::Pointer OutputPathPointerType; /// Input image dimension itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /// Input image Setters and getters using Superclass::SetInput; virtual void SetInput(const InputImageType * Image); const InputImageType * GetInput(void); protected: ImageToPathFilter(); ~ImageToPathFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageToPathFilter(const Self &); void operator =(const Self&); }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToPathFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageToPathFilter.txx000066400000000000000000000032111301006202600260470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPathFilter_txx #define otbImageToPathFilter_txx #include "otbImageToPathFilter.h" namespace otb { /** * Constructor. */ template ImageToPathFilter ::ImageToPathFilter() { this->SetNumberOfRequiredInputs(1); } /** * Input image setter. */ template void ImageToPathFilter ::SetInput(const InputImageType * image) { this->ProcessObjectType::SetNthInput(0, const_cast(image)); } /** * Input image getter. */ template const typename ImageToPathFilter::InputImageType * ImageToPathFilter ::GetInput(void) { return static_cast(this->ProcessObjectType::GetInput(0)); } /** * PrintSelf Method. */ template void ImageToPathFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageToPathListFilter.h000066400000000000000000000056361301006202600263240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPathListFilter_h #define otbImageToPathListFilter_h #include "otbPathListSource.h" namespace otb { /** \class ImageToPathListFilter * \brief Base class used to implement filters that have a image as input and a paths list as output. * * * \ingroup PathListFilters * \ingroup PathLists * * \ingroup OTBPath */ template //class ITK_EXPORT ImageToPathListFilter : public itk::PathSource class ITK_EXPORT ImageToPathListFilter : public PathListSource { public: /** Standard class typedefs. */ typedef ImageToPathListFilter Self; typedef PathListSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ProcessObject ProcessObjectType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageToPathListFilter, PathListSource); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename Superclass::OutputPathType OutputPathType; typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename Superclass::OutputPathPointerType OutputPathPointerType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Set/Get the image input of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputImageType * image); const InputImageType * GetInput(void); protected: ImageToPathListFilter(); ~ImageToPathListFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageToPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToPathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbImageToPathListFilter.txx000066400000000000000000000036111301006202600267070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToPathListFilter_txx #define otbImageToPathListFilter_txx #include "otbImageToPathListFilter.h" #include "itkProcessObject.h" namespace otb { /** * */ template ImageToPathListFilter ::ImageToPathListFilter() { // Modify superclass default values, can be overridden by subclasses this->SetNumberOfRequiredInputs(1); } /** * */ template void ImageToPathListFilter ::SetInput(const InputImageType *image) { // We have 1 input: an image // Process object is not const-correct so the const_cast is required here this->ProcessObjectType::SetNthInput(0, const_cast(image)); } template const typename ImageToPathListFilter::InputImageType * ImageToPathListFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObjectType::GetInput(0)); } /** * */ template void ImageToPathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbOrientationPathFunction.h000066400000000000000000000050211301006202600267620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOrientationPathFunction_h #define otbOrientationPathFunction_h #include "otbPathFunction.h" #include "itkVectorContainer.h" namespace otb { /** * \class OrientationPathFunction * \brief Calculate the orientation angle of a path defined by 2 points. * The result value is in radian. * * \ingroup PathFunctions * * \ingroup OTBPath */ template class ITK_EXPORT OrientationPathFunction : public PathFunction { public: /** Standard class typedefs. */ typedef OrientationPathFunction Self; typedef PathFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(OrientationPathFunction, PathFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputPathType typedef support. */ typedef typename Superclass::InputPathType PathType; typedef typename Superclass::InputPathConstPointer PathConstPointer; typedef typename PathType::ContinuousIndexType VertexType; typedef itk::VectorContainer VertexListType; typedef typename VertexListType::ConstPointer VertexListPointer; typedef TOutput OutputType; typedef double RealType; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PathType& path) const ITK_OVERRIDE; virtual OutputType Evaluate() const; protected: OrientationPathFunction() {}; ~OrientationPathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: OrientationPathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOrientationPathFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbOrientationPathFunction.txx000066400000000000000000000044471301006202600273710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOrientationPathFunction_txx #define otbOrientationPathFunction_txx #include "otbOrientationPathFunction.h" #include "otbPathFunction.h" #include "itkNumericTraits.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { template void OrientationPathFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } template typename OrientationPathFunction::OutputType OrientationPathFunction ::Evaluate(const PathType& path) const { typedef double RealType; VertexListPointer vertexList; VertexType cindex; VertexType IndexOut; int nbPath; RealType Theta; vertexList = path.GetVertexList(); nbPath = vertexList->Size(); if (nbPath == 2) { cindex = vertexList->GetElement(0); RealType x1 = cindex[0]; RealType y1 = cindex[1]; cindex = vertexList->GetElement(1); RealType x2 = cindex[0]; RealType y2 = cindex[1]; Theta = vcl_atan2(y2 - y1, x2 - x1); } // IF loop else { itkExceptionMacro(<< "OrientationPathFunction::Evaluate() FAILED -- path must have 2 points"); } return (static_cast(Theta)); } template typename OrientationPathFunction::OutputType OrientationPathFunction ::Evaluate() const { if (!this->GetInputPath()) { otbMsgDevMacro(<< "Problem with GetInputPath"); return static_cast(itk::NumericTraits::max()); } OutputType Result = Evaluate(*(this->GetInputPath())); return Result; } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathFunction.h000066400000000000000000000050221301006202600245470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathFunction_h #define otbPathFunction_h #include "itkFunctionBase.h" namespace otb { /** \class PathFunction * \brief Evaluates a function of an image over a specific path. * * PathFunction is a baseclass for all objects that evaluates * a function of an image using a path list. * This class is templated over the input image type, the path type * and the function output and the coordinate representation type * (e.g. float or double). * * The input path is set via method SetInputPath(). * * * \sa Path * * \ingroup PathFunction * * \ingroup OTBPath */ template class ITK_EXPORT PathFunction : public itk::FunctionBase { public: /** Standard class typedefs. */ typedef PathFunction Self; typedef itk::FunctionBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(PathFunction, itk::FunctionBase); /** InputPathType typedef support. */ typedef typename Superclass::InputType InputPathType; /** InputPathPointer typedef support */ typedef typename InputPathType::ConstPointer InputPathConstPointer; /** OutputType typedef support. */ typedef typename Superclass::OutputType OutputType; /** Set the input path. */ virtual void SetInputPath(const InputPathType * ptr); /** Get the input path. */ const InputPathType * GetInputPath() const { return m_Path.GetPointer(); } protected: PathFunction(); ~PathFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; InputPathConstPointer m_Path; private: PathFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPathFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathFunction.txx000066400000000000000000000025111301006202600251430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathFunction_txx #define otbPathFunction_txx #include "otbPathFunction.h" namespace otb { /** * Constructor */ template PathFunction ::PathFunction() { m_Path = ITK_NULLPTR; } /** * Standard "PrintSelf" method */ template void PathFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "InputPath: " << m_Path.GetPointer() << std::endl; } /** * Initialize by setting the input image */ template void PathFunction ::SetInputPath(const InputPathType * ptr) { // set the input path m_Path = ptr; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathLengthFunctor.h000066400000000000000000000026451301006202600255540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathLengthFunctor_h #define otbPathLengthFunctor_h #include "otbMath.h" namespace otb { /** \class PathLengthFunctor * \brief Select paths according to their length * * This functor gets the length of a path * and returns true if it is above the threshold, false otherwise. * * \ingroup Functor * * \ingroup OTBPath */ template class PathLengthFunctor { public: void SetThreshold(double threshold) { m_Threshold = threshold; } double GetThreshold(void) const { return m_Threshold; } PathLengthFunctor() { m_Threshold = 10; } ~PathLengthFunctor() {} inline bool operator ()(const TInput1& input) { double length = input->GetLength(); if (length > m_Threshold) { return true; } else { return false; } } private: double m_Threshold; }; } #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathListSource.h000066400000000000000000000165271301006202600250720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathListSource_h #define otbPathListSource_h // #include "itkProcessObject.h" // #include "itkDataObject.h" #include "otbObjectListSource.h" namespace otb { /** \class PathListSource * \brief Base class for filters with a PathList output type. * * PathListSource is the base class for all filters producing a PathList. * This class defines the GetOutput(). * * \ingroup DataSources * \ingroup Paths * \ingroup Lists * * \ingroup OTBPath */ template class ITK_EXPORT PathListSource : public ObjectListSource > { public: /** Standard class typedefs. */ typedef PathListSource Self; typedef ObjectListSource > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PathListSource, ObjectListSource); /** Some convenient typedefs. */ typedef itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef TOutputPath OutputPathType; typedef typename OutputPathType::Pointer OutputPathPointerType; typedef typename Superclass::OutputListType OutputPathListType; typedef typename OutputPathListType::Pointer OutputPathListPointerType; typedef typename OutputPathListType::ConstPointer OutputPathListConstPointerType; /** Get the output data of this process object. The output of this * function is not valid until an appropriate Update() method has * been called, either explicitly or implicitly. Both the filter * itself and the data object have Update() methods, and both * methods update the data. Here are three ways to use * GetOutput() and make sure the data is valid. In these * examples, \a image is a pointer to some Image object, and the * particular ProcessObjects involved are filters. The same * examples apply to non-image (e.g. Mesh) data as well. * * \code * anotherFilter->SetInput( someFilter->GetOutput() ); * anotherFilter->Update(); * \endcode * * In this situation, \a someFilter and \a anotherFilter are said * to constitute a \b pipeline. * * \code * image = someFilter->GetOutput(); * image->Update(); * \endcode * * \code * someFilter->Update(); * image = someFilter->GetOutput(); * \endcode * (In the above example, the two lines of code can be in * either order.) * * Note that Update() is not called automatically except within a * pipeline as in the first example. When \b streaming (using a * StreamingImageFilter) is activated, it may be more efficient to * use a pipeline than to call Update() once for each filter in * turn. * * For an image, the data generated is for the requested * Region, which can be set using ImageBase::SetRequestedRegion(). * By default, the largest possible region is requested. */ // OutputPathListType * GetOutput(void); // OutputPathListType * GetOutput(DataObjectPointerArraySizeType idx); /** Graft the specified DataObject onto this ProcessObject's output. * This method grabs a handle to the specified DataObject's path * data to use as its output's own path data. It also copies the * region ivars (RequestedRegion, BufferedRegion, * LargestPossibleRegion) and meta-data (Spacing, Origin) from the * specified data object into this filter's output data object. Most * importantly, however, it leaves the Source ivar untouched so the * original pipeline routing is intact. This method is used when a * process object is implemented using a mini-pipeline which is * defined in its GenerateData() method. The usage is: * * \code * // setup the mini-pipeline to process the input to this filter * firstFilterInMiniPipeline->SetInput( this->GetInput() ); * * // setup the mini-pipeline to calculate the correct regions * // and write to the appropriate bulk data block * lastFilterInMiniPipeline->GraftOutput( this->GetOutput() ); * * // execute the mini-pipeline * lastFilterInMiniPipeline->Update(); * * // graft the mini-pipeline output back onto this filter's output. * // this is needed to get the appropriate regions passed back. * this->GraftOutput( lastFilterInMiniPipeline->GetOutput() ); * \endcode * * For proper pipeline execution, a filter using a mini-pipeline * must implement the GeneratseInputRequestedRegion(), * GenerateOutputRequestedRegion(), GenerateOutputInformation() and * EnlargeOutputRequestedRegion() methods as necessary to reflect * how the mini-pipeline will execute (in other words, the outer * filter's pipeline mechanism must be consistent with what the * mini-pipeline will do). */ // just calls GraftNthOutput() // virtual void GraftOutput(OutputPathListType *output); /** Graft the specified data object onto this ProcessObject's idx'th * output. This is the similar to GraftOutput method except is * allows you specify which output is affected. The specified index * must be a valid output number (less than * ProcessObject::GetNumberOfOutputs()). See the GraftOutput for * general usage information. */ // virtual void GraftNthOutput(DataObjectPointerArraySizeType idx, OutputPathListType *output); /** Make a DataObject of the correct type to used as the specified * output. Every ProcessObject subclass must be able to create a * DataObject that can be used as a specified output. This method * is automatically called when DataObject::DisconnectPipeline() is * called. DataObject::DisconnectPipeline, disconnects a data object * from being an output of its current source. When the data object * is disconnected, the ProcessObject needs to construct a replacement * output data object so that the ProcessObject is in a valid state. * So DataObject::DisconnectPipeline eventually calls * ProcessObject::MakeOutput. Note that MakeOutput always returns a * SmartPointer to a DataObject. If a subclass of ImageSource has * multiple outputs of different types, then that class must provide * an implementation of MakeOutput(). */ // virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx); protected: PathListSource() {}; ~PathListSource() ITK_OVERRIDE {} // void PrintSelf(std::ostream& os, itk::Indent indent) const; private: PathListSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb // #ifndef OTB_MANUAL_INSTANTIATION // #include "otbPathListSource.txx" // #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathListToHistogramGenerator.h000066400000000000000000000111201301006202600277210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathListToHistogramGenerator_h #define otbPathListToHistogramGenerator_h #include "itkSampleToHistogramFilter.h" #include "itkHistogram.h" #include "itkListSample.h" #include "itkVector.h" #include "otbObjectList.h" //TODO : write a HistogramSource when outputting Histogram namespace otb { /** \class PathListToHistogramGenerator * \brief This class generates an histogram from a list of path. * * The concept of Histogram in ITK is quite generic. It has been designed to * manage multiple components data. This class facilitates the computation of * an histogram from a list of path. Internally it creates a List that is feed into * the ListSampleToHistogramGenerator. * * * \ingroup OTBPath */ template class PathListToHistogramGenerator : public itk::ProcessObject { public: /** Standard typedefs */ typedef PathListToHistogramGenerator Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(PathListToHistogramGenerator, itk::ProcessObject); /** standard New() method support */ itkNewMacro(Self); typedef TPath PathType; typedef typename PathType::Pointer PathPointer; typedef ObjectList PathListType; typedef TFunction FunctionType; typedef typename TFunction::OutputType RealType; typedef RealType MeasurementType; typedef itk::Vector ListSampleVectorType; typedef itk::Statistics::ListSample ListSampleType; typedef typename ListSampleType::Pointer ListSamplePointer; typedef typename ListSampleType::ConstPointer ListSampleConstPointer; typedef itk::Statistics::DenseFrequencyContainer2 FrequencyContainerType; typedef itk::Statistics::Histogram< MeasurementType, FrequencyContainerType > HistogramType; typedef itk::Statistics::SampleToHistogramFilter< ListSampleType, HistogramType> GeneratorType; typedef typename GeneratorType::Pointer GeneratorPointer; typedef typename HistogramType::Pointer HistogramPointer; typedef typename HistogramType::ConstPointer HistogramConstPointer; typedef typename HistogramType::SizeType SizeType; typedef typename HistogramType::MeasurementVectorType MeasurementVectorType; /** DataObject typedef*/ typedef typename Superclass::DataObjectPointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; void GraftNthOutput(unsigned int idx, itk::DataObject *graft); void GraftOutput(itk::DataObject *graft); public: /** Connects the input PathList for which the histogram is going to be computed */ using Superclass::SetInput; void SetInput(const PathListType* path); const PathListType* GetInput() const; // Return the output histogram. const HistogramType * GetOutput() const; /** Set number of histogram bins */ void SetNumberOfBins(const SizeType& size); /** Set marginal scale value to be passed to the histogram generator */ void SetMarginalScale(double marginalScale); void SetHistogramMin(const MeasurementVectorType& histogramMin); void SetHistogramMax(const MeasurementVectorType& histogramMax); void SetAutoMinMax(bool autoMinMax); protected: PathListToHistogramGenerator(); ~PathListToHistogramGenerator() ITK_OVERRIDE {} void GenerateData() ITK_OVERRIDE; DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE; using Superclass::MakeOutput; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GeneratorPointer m_HistogramGenerator; }; } // end of namespace OTB #ifndef OTB_MANUAL_INSTANTIATION #include "otbPathListToHistogramGenerator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathListToHistogramGenerator.txx000066400000000000000000000132611301006202600303250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathListToHistogramGenerator_txx #define otbPathListToHistogramGenerator_txx #include "otbPathListToHistogramGenerator.h" namespace otb { template PathListToHistogramGenerator ::PathListToHistogramGenerator() { m_HistogramGenerator = GeneratorType::New(); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->itk::ProcessObject::SetNthOutput(0, this->MakeOutput(0).GetPointer()); } template void PathListToHistogramGenerator ::SetInput(const PathListType* path) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(path)); } template const typename PathListToHistogramGenerator::PathListType* PathListToHistogramGenerator ::GetInput() const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } /** * //FIXME : should be done in a HistogramSource */ template void PathListToHistogramGenerator ::GraftOutput(itk::DataObject *graft) { this->GraftNthOutput(0, graft); } /** * //FIXME : should be done in a HistogramSource */ template void PathListToHistogramGenerator ::GraftNthOutput(unsigned int idx, itk::DataObject *graft) { if (idx >= this->GetNumberOfOutputs()) { itkExceptionMacro(<< "Requested to graft output " << idx << " but this filter only has " << this->GetNumberOfOutputs() << " Outputs."); } if (!graft) { itkExceptionMacro(<< "Requested to graft output that is a NULL pointer"); } itk::DataObject * output = const_cast(this->GetOutput()); // Call GraftImage to copy meta-information, regions, and the pixel container output->Graft(graft); } template typename PathListToHistogramGenerator::DataObjectPointer PathListToHistogramGenerator ::MakeOutput(DataObjectPointerArraySizeType) { DataObjectPointer output; output = static_cast(HistogramType::New().GetPointer()); return output; } template const typename PathListToHistogramGenerator::HistogramType * PathListToHistogramGenerator ::GetOutput() const { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } template void PathListToHistogramGenerator ::GenerateData() { // Get the input pathlist typename PathListType::ConstPointer pathList = this->GetInput(); // Path pointer PathPointer vertexList; ListSamplePointer listSample = ListSampleType::New(); int nbElementPathList = pathList->Size(); ListSampleVectorType ResultFunction; typename TFunction::Pointer function = TFunction::New(); for (int noPathList = 0; noPathList < nbElementPathList; noPathList++) { vertexList = pathList->GetNthElement(noPathList); //(*pathList)[noPathList]; function->SetInputPath(vertexList); ResultFunction[0] = static_cast(function->Evaluate()); // Set the ListSample MeasurementVectorSize once before the PushBack if(noPathList==0) listSample->SetMeasurementVectorSize(ResultFunction.Size()); listSample->PushBack(ResultFunction); } m_HistogramGenerator->SetInput(listSample); m_HistogramGenerator->GraftOutput(const_cast(this->GetOutput())); m_HistogramGenerator->Update(); this->GraftOutput(const_cast(m_HistogramGenerator->GetOutput())); } template void PathListToHistogramGenerator ::SetNumberOfBins(const SizeType& size) { m_HistogramGenerator->SetHistogramSize(size); } template void PathListToHistogramGenerator ::SetMarginalScale(double marginalScale) { m_HistogramGenerator->SetMarginalScale(marginalScale); } template void PathListToHistogramGenerator ::SetHistogramMin(const MeasurementVectorType& histogramMin) { m_HistogramGenerator->SetHistogramMin(histogramMin); } template void PathListToHistogramGenerator ::SetHistogramMax(const MeasurementVectorType& histogramMax) { m_HistogramGenerator->SetHistogramMax(histogramMax); } template void PathListToHistogramGenerator ::SetAutoMinMax(bool autoMinMax) { m_HistogramGenerator->SetAutoMinMax(autoMinMax); } template void PathListToHistogramGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << "PathList = " << this->GetInput() << std::endl; os << "HistogramGenerator = " << m_HistogramGenerator << std::endl; } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathListToPathListFilter.h000066400000000000000000000047471301006202600270340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathListToPathListFilter_h #define otbPathListToPathListFilter_h #include "otbObjectListToObjectListFilter.h" #include "otbObjectList.h" namespace otb { /** \class PathListToPathListFilter * \brief Base class for filter taking a PathList as input a returning a PathList. * * \ingroup OTBPath */ template class ITK_EXPORT PathListToPathListFilter : public ObjectListToObjectListFilter, ObjectList > { public: /** Standard typedefs */ typedef PathListToPathListFilter Self; typedef ObjectListToObjectListFilter, ObjectList > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(PathListToPathListFilter, ObjectListToObjectListFilter); /** Template parameters typedefs */ typedef typename Superclass::InputObjectType PathType; typedef typename Superclass::InputListType PathListType; typedef typename PathType::Pointer PathPointerType; typedef typename PathListType::Pointer PathListPointerType; typedef typename PathListType::ConstPointer PathListConstPointerType; typedef typename Superclass::OutputObjectType OutputPathType; typedef typename PathType::Pointer OutputPathPointerType; typedef typename Superclass::OutputListType OutputPathListType; typedef typename Superclass::OutputListPointer OutputPathListPointerType; protected: /** Constructor */ PathListToPathListFilter() {}; /** Destructor */ ~PathListToPathListFilter() ITK_OVERRIDE {} private: PathListToPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPathMeanDistanceFunctor.h000066400000000000000000000050411301006202600266570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPathMeanDistanceFunctor_h #define otbPathMeanDistanceFunctor_h #include "otbMacro.h" #include "otbMath.h" namespace otb { /** \class PathMeanDistanceFunctor * \brief Functor to select path according to the average distance between points * * This functor compute the average distance between each point of a path * and return true is the distance is above the threshold, false otherwise. * * \sa UnaryFunctorObjectListBooleanFilter * * \ingroup Functor * * \ingroup OTBPath */ template class PathMeanDistanceFunctor { public: void SetThreshold(double threshold) { m_Threshold = threshold; } double GetThreshold(void) const { return (m_Threshold); } PathMeanDistanceFunctor() { m_Threshold = 0.2; } ~PathMeanDistanceFunctor() {} inline bool operator ()(const TInput1& input) { double meanDistance = 0.0; typedef typename TInput1::ObjectType::VertexListType::ConstIterator VertexListConstIteratorType; typedef typename TInput1::ObjectType::VertexType VertexType; VertexListConstIteratorType beginIt = input->GetVertexList()->Begin(); VertexType v1 = beginIt.Value(); VertexType v2 = beginIt.Value(); ++beginIt; while (beginIt != input->GetVertexList()->End()) { v1 = v2; v2 = beginIt.Value(); meanDistance += vcl_sqrt(vcl_pow(v1[0] - v2[0], 2) + vcl_pow(v1[1] - v2[1], 2)); ++beginIt; } double nbVertices = static_cast(input->GetVertexList()->Size()); if (nbVertices > 1) { meanDistance = meanDistance / (nbVertices - 1); } else { itkGenericExceptionMacro(<< "Object with only one vertex!"); } /* std::cout << "Num vertex: " << nbVertices << std::endl; std::cout << "Mean dist: " << meanDistance << std::endl; */ if (meanDistance > m_Threshold) { return true; } else { return false; } } private: double m_Threshold; }; } #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPolyLineImageConstIterator.h000066400000000000000000000103031301006202600273620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolyLineImageConstIterator_h #define otbPolyLineImageConstIterator_h #include "itkIndex.h" #include "itkImage.h" #include "itkLineIterator.h" namespace otb { /** \class PolyLineImageConstIterator * \brief Uses the bresenham algorithm to iterate over a polyline on an image (const version). * * This iterator encapsulates the itk::LineIterator along with the VectorContainer iterator on * the vertex list of the polyline. * * \ingroup Iterators * \sa PolyLineParametricPath * \sa PolyLineParametricPathWithValue * \sa LineIterator * \sa LineConstIterator * \sa PolyLineImageIterator * * \ingroup OTBPath */ template class ITK_EXPORT PolyLineImageConstIterator { public: /** Standard typedefs */ typedef PolyLineImageConstIterator Self; itkStaticConstMacro(ImageIteratorDimension, unsigned int, TImage::ImageDimension); typedef typename TImage::IndexType IndexType; typedef typename TImage::IndexValueType IndexValueType; typedef typename TImage::OffsetType OffsetType; typedef typename TImage::OffsetValueType OffsetValueType; typedef typename TImage::SizeType SizeType; typedef typename TImage::SizeValueType SizeValueType; typedef typename TImage::RegionType RegionType; typedef typename TImage::SpacingType SpacingType; typedef typename TImage::PointType PointType; typedef TImage ImageType; typedef TPath PathType; typedef typename PathType::VertexType VertexType; typedef typename PathType::VertexListType VertexListType; typedef typename VertexListType::ConstIterator VertexIteratorType; typedef itk::LineIterator InternalImageIteratorType; typedef typename TImage::PixelContainer PixelContainer; typedef typename PixelContainer::Pointer PixelContainerPointer; typedef typename TImage::InternalPixelType InternalPixelType; typedef typename TImage::PixelType PixelType; typedef typename TImage::AccessorType AccessorType; /** Get the dimension (size) of the index. */ static unsigned int GetImageIteratorDimension() { return TImage::ImageDimension; } /** Get the index */ const IndexType GetIndex() { return m_InternalImageIterator.GetIndex(); } /** Get the pixel value */ const PixelType Get(void) const { return m_InternalImageIterator.Get(); } /** Is the iterator at the end of the line? */ bool IsAtEnd() { return (m_InternalVertexIterator == m_Path->GetVertexList()->End()) && m_InternalImageIterator.IsAtEnd(); } /** Move an iterator to the beginning of the line. */ void GoToBegin(); /** Walk forward along the line to the next index in the image. */ void operator ++(); /** operator= is provided to make sure the handle to the image is properly * reference counted. */ Self& operator =(const Self& it); /** Constructor establishes an iterator to walk along a line */ PolyLineImageConstIterator(const ImageType * imagePtr, const PathType * pathPtr); /** Default Destructor. */ virtual ~PolyLineImageConstIterator() {} protected: //made protected so other iterators can access /** Smart pointer to the source image. */ typename ImageType::ConstWeakPointer m_Image; /** Smart pointer to the path */ typename PathType::ConstPointer m_Path; InternalImageIteratorType m_InternalImageIterator; VertexIteratorType m_InternalVertexIterator; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPolyLineImageConstIterator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPolyLineImageConstIterator.txx000066400000000000000000000102701301006202600277610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolyLineImageConstIterator_txx #define otbPolyLineImageConstIterator_txx #include "otbPolyLineImageConstIterator.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template PolyLineImageConstIterator ::PolyLineImageConstIterator(const ImageType *imagePtr, const PathType * pathPtr) : m_InternalImageIterator(const_cast(imagePtr), imagePtr->GetLargestPossibleRegion().GetIndex(), imagePtr->GetLargestPossibleRegion().GetIndex()) { m_Image = imagePtr; m_Path = pathPtr; m_InternalVertexIterator = m_Path->GetVertexList()->Begin(); IndexType source, target; for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { source[i] = static_cast (vcl_floor(m_InternalVertexIterator.Value()[i] + 0.5)); } ++m_InternalVertexIterator; if (m_InternalVertexIterator != m_Path->GetVertexList()->End()) { for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { target[i] = static_cast (vcl_floor(m_InternalVertexIterator.Value()[i] + 0.5)); } } else { target = source; } m_InternalImageIterator = InternalImageIteratorType(const_cast (m_Image.GetPointer()), source, target); } template typename PolyLineImageConstIterator ::Self& PolyLineImageConstIterator ::operator = (const Self &it) { m_Image = it.m_Image; m_Path = it.m_Path; m_InternalImageIterator = it.m_InternalImageIterator; m_InternalVertexIterator = it.m_InternalVertexIterator; } template void PolyLineImageConstIterator ::GoToBegin(void) { m_InternalVertexIterator = m_Path->GetVertexList()->Begin(); IndexType source, target; for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { source[i] = static_cast (vcl_floor(m_InternalVertexIterator.Value()[i] + 0.5)); } ++m_InternalVertexIterator; if (m_InternalVertexIterator != m_Path->GetVertexList()->End()) { for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { target[i] = static_cast (vcl_floor(m_InternalVertexIterator.Value()[i] + 0.5)); } } else { target = source; } m_InternalImageIterator = InternalImageIteratorType(const_cast (m_Image.GetPointer()), source, target); } template void PolyLineImageConstIterator ::operator++ () { // otbMsgDebugMacro(<GetIndex()); ++m_InternalImageIterator; if (m_InternalImageIterator.IsAtEnd()) { if (m_InternalVertexIterator != m_Path->GetVertexList()->End()) { IndexType source; for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { source[i] = static_cast (vcl_floor(m_InternalVertexIterator.Value()[i] + 0.5)); } // otbMsgDebugMacro(<<"Source: "<GetVertexList()->End()) { IndexType target; for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) { target[i] = static_cast (vcl_floor(m_InternalVertexIterator.Value()[i] + 0.5)); } // otbMsgDebugMacro(<<"Target: "< (m_Image.GetPointer()), source, target); ++m_InternalImageIterator; } } } } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbPolyLineImageIterator.h000066400000000000000000000067351301006202600263710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolyLineImageIterator_h #define otbPolyLineImageIterator_h #include "otbPolyLineImageConstIterator.h" namespace otb { /** \class PolyLineImageIterator * \brief Uses the bresenham algorithm to iterate over a polyline on an image. * * This iterator encapsulates the itk::LineIterator along with the VectorContainer iterator on * the vertex list of the polyline. * * \ingroup Iterators * \sa PolyLineParametricPath * \sa PolyLineParametricPathWithValue * \sa LineIterator * \sa LineConstIterator * \sa PolyLineImageConstIterator * * \ingroup OTBPath */ template class ITK_EXPORT PolyLineImageIterator : public PolyLineImageConstIterator { public: /** Standard typedefs */ typedef PolyLineImageIterator Self; typedef PolyLineImageConstIterator Superclass; itkStaticConstMacro(ImageIteratorDimension, unsigned int, TImage::ImageDimension); typedef typename TImage::IndexType IndexType; typedef typename TImage::IndexValueType IndexValueType; typedef typename TImage::OffsetType OffsetType; typedef typename TImage::OffsetValueType OffsetValueType; typedef typename TImage::SizeType SizeType; typedef typename TImage::SizeValueType SizeValueType; typedef typename TImage::RegionType RegionType; typedef typename TImage::SpacingType SpacingType; typedef typename TImage::PointType PointType; typedef TImage ImageType; typedef TPath PathType; typedef typename PathType::VertexType VertexType; typedef typename PathType::VertexListType VertexListType; typedef typename VertexListType::ConstIterator VertexIteratorType; typedef itk::LineIterator InternalImageIteratorType; typedef typename TImage::PixelContainer PixelContainer; typedef typename PixelContainer::Pointer PixelContainerPointer; typedef typename TImage::InternalPixelType InternalPixelType; typedef typename TImage::PixelType PixelType; typedef typename TImage::AccessorType AccessorType; /** Set the pixel value */ void Set(const PixelType& value) { this->m_InternalImageIterator.Set(value); } /** Return a reference to the pixel * This method will provide the fastest access to pixel * data, but it will NOT support ImageAdaptors. */ PixelType& Value(void) { return this->m_InternalImageIterator.Value(); } Self & operator =(const Self& it) { this->Superclass::operator =(it); return *this; } /** Constructor establishes an iterator to walk along a line */ PolyLineImageIterator(ImageType * imagePtr, PathType * pathPtr) : Superclass(imagePtr, pathPtr) {}; /** Default Destructor. */ ~PolyLineImageIterator() ITK_OVERRIDE {} }; } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbRegionImageToRectangularPathListFilter.h000066400000000000000000000112211301006202600316430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Adapted from otbImageToPathListAlignFilter.h #ifndef otbRegionImageToRectangularPathListFilter_h #define otbRegionImageToRectangularPathListFilter_h #include "itkImageSource.h" #include "itkConceptChecking.h" #include "otbImage.h" #include "otbImageToPathListFilter.h" #include #include "otbVectorDataSource.h" #include "otbVectorData.h" namespace otb { /** \class RegionImageToRectangularPathListFilter * \brief Base class used to implement filter to model regions by rectangles. * * * \ingroup OTBPath */ template class ITK_EXPORT RegionImageToRectangularPathListFilter : public ImageToPathListFilter { public: /** Standard class typedefs. */ typedef RegionImageToRectangularPathListFilter Self; typedef ImageToPathListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RegionImageToRectangularPathListFilter, ImageToPathListFilter); // itkTypeMacro(ImageToPathListAlignFilter, itk::ImageSource); /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Some convenient typedefs. */ typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename InputImageType::PixelType PixelType; typedef typename Superclass::OutputPathType OutputPathType; // typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename Superclass::OutputPathPointerType OutputPathPointerType; // typedef float RealType; //typedef typename itk::NumericTraits::RealType RealType; typedef double RealType; // typedef typename itk::Image RealImageType; typedef typename otb::Image RealImageType; typedef typename RealImageType::Pointer RealImageTypePointer; typedef typename RealImageType::IndexType RealImageTypeIndexType; /** The minimum rectangular fit of returned rectangles. */ itkSetMacro(MinimumFit, double); itkGetConstReferenceMacro(MinimumFit, double); /** The minimum size of returned rectangles. */ itkSetMacro(MinimumSize, double); itkGetConstReferenceMacro(MinimumSize, double); //jgc /** Dimension of the image the iterator walks. This constant is needed so * that functions that are templated over image iterator type (as opposed to * being templated over pixel type and dimension) can have compile time * access to the dimension of the image that the iterator walks. */ itkStaticConstMacro(NDimensions, unsigned int, TInputImage::ImageDimension); protected: RegionImageToRectangularPathListFilter(); ~RegionImageToRectangularPathListFilter() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE{} // do nothing void GenerateData() ITK_OVERRIDE; double m_MinimumFit; double m_MinimumSize; int m_CrossTermFormula; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; //jgc typedef Image MarkerImageType; typename MarkerImageType::Pointer markerImage; private: RegionImageToRectangularPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRegionImageToRectangularPathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbRegionImageToRectangularPathListFilter.txx000066400000000000000000000435021301006202600322460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Adapted from otbImageToPathListAlignFilter.txx #ifndef otbRegionImageToRectangularPathListFilter_txx #define otbRegionImageToRectangularPathListFilter_txx #include #include #include "otbRegionImageToRectangularPathListFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkConstNeighborhoodIterator.h" #include "itkPathIterator.h" #include "itkImageLinearIteratorWithIndex.h" #include "otbMath.h" #include "itkNeighborhoodBinaryThresholdImageFunction.h" #include "itkFloodFilledImageFunctionConditionalIterator.h" #include "itkConstNeighborhoodIterator.h" #include "itkConstantBoundaryCondition.h" namespace otb { /** Constructor */ template RegionImageToRectangularPathListFilter ::RegionImageToRectangularPathListFilter() { this->SetNumberOfRequiredInputs(1); m_MinimumFit = 0.0; m_MinimumSize = 0.0; } /** Destructor */ template RegionImageToRectangularPathListFilter ::~RegionImageToRectangularPathListFilter() { } /* Algorithm */ template void RegionImageToRectangularPathListFilter ::GenerateData(void) { typename InputImageType::SizeType Taille; //this->DebugOn(); //itkDebugMacro(<< "RegionImageToRectangularPathListFilter::GenerateData() called"); // Get the input and output pointers const InputImageType * InputImage = this->GetInput(); OutputPathListType * OutputPath = this->GetOutput(); // Generate the image /* Filter algorithm */ Taille = InputImage->GetLargestPossibleRegion().GetSize(); itkDebugMacro(<< "Input image size : " << Taille); typename InputImageType::PointType origin; typename InputImageType::SpacingType spacing; origin = InputImage->GetOrigin(); spacing = InputImage->GetSpacing(); std::cout << "Image origin : " << origin << std::endl; std::cout << "Image spacing : " << spacing << std::endl; typedef itk::ImageRegionConstIterator IteratorType; IteratorType it(InputImage, InputImage->GetLargestPossibleRegion()); int pixelCount = 0; int regionCount = 0; int selectedRegionCount = 0; int pixelDebugNumber = 0; //20; int regionDebugNumber = 0; //5000; //20; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typename NeighborhoodIteratorType::RadiusType radius; radius.Fill(1); // square one-pixel neighborhood //2 std::cout << "radius : " << radius << std::endl; NeighborhoodIteratorType nit(radius, InputImage, InputImage->GetLargestPossibleRegion()); NeighborhoodIteratorType nit2(radius, InputImage, InputImage->GetLargestPossibleRegion()); // Set up the boundary condition to be zero padded (used on input image) itk::ConstantBoundaryCondition BC; //BC.SetConstant(itk::NumericTraits::Zero); BC.SetConstant(itk::NumericTraits::max()); nit.OverrideBoundaryCondition(&BC); // assign the boundary condition nit2.OverrideBoundaryCondition(&BC); // assign the boundary condition // Build a temporary image of chars for use in the flood algorithm markerImage = MarkerImageType::New(); typename MarkerImageType::RegionType markerRegion = InputImage->GetLargestPossibleRegion(); markerImage->SetLargestPossibleRegion(markerRegion); markerImage->SetBufferedRegion(markerRegion); markerImage->SetRequestedRegion(markerRegion); markerImage->Allocate(); unsigned char maxValue = itk::NumericTraits::max(); markerImage->FillBuffer(maxValue); unsigned char zeroValue = itk::NumericTraits::Zero; unsigned char regionValue; int neighbor; //markerImage->FillBuffer(itk::NumericTraits::max()); //typedef itk::ImageRegionIterator MarkerIteratorType; typedef itk::ImageRegionIteratorWithIndex MarkerIteratorType; MarkerIteratorType mit(markerImage, markerRegion); typedef typename TInputImage::IndexType IndexType; std::vector regionContainer; // Pb for growing from within loop typename std::vector::iterator regionIterator; typename std::vector::iterator regionIterator2; regionContainer.reserve(Taille[0] * Taille[1]); // to avoid growth problems IndexType explorerIndex; // position whose neighbors are to be checked for inclusion in current region try { OutputPath->Clear(); for (nit.GoToBegin(), pixelCount = 0; !nit.IsAtEnd(); ++nit) { pixelCount++; if (pixelCount <= pixelDebugNumber) { std::cout << "Pixel #" << pixelCount << " : " << nit.GetCenterPixel() << std::endl; for (neighbor = 1; neighbor <= 7; neighbor += 2) // 4 neighbors : above, left, right, below std::cout << "Neighbor #" << neighbor << " : " << nit.GetPixel(neighbor) << std::endl; } mit.SetIndex(nit.GetIndex()); if (mit.Get() == maxValue) // pixel not yet processed { mit.Set(zeroValue); regionContainer.clear(); regionContainer.push_back(nit.GetIndex()); regionValue = nit.GetCenterPixel(); regionCount++; if (pixelCount <= pixelDebugNumber) { std::cout << "Starting new region at " << nit.GetIndex() << " with value " << (unsigned short) regionValue << std::endl; } // Collect all pixels in same region (same value), reachable in 4-connectivity for (regionIterator = regionContainer.begin(); regionIterator != /*<*/ regionContainer.end(); ++regionIterator /* regionContainer grows within loop */) { // add neighbors not yet processed, until whole region has been collected (no "new" neighbor) explorerIndex = *regionIterator; nit2.SetLocation(explorerIndex); if (pixelCount <= pixelDebugNumber) std::cout << "Exploring neighbors of " << explorerIndex << std::endl; for (neighbor = 1; neighbor <= 7; neighbor += 2) if (nit2.GetPixel(neighbor) == regionValue) // ZZ and not yet processed... { mit.SetIndex(nit2.GetIndex(neighbor)); if (mit.Get() == maxValue) // pixel not yet processed { mit.Set(zeroValue); regionContainer.push_back(nit2.GetIndex(neighbor)); if (pixelCount <= pixelDebugNumber) { std::cout << "Adding " << nit2.GetIndex(neighbor) << std::endl; std::cout << "Added " << regionContainer.back() << std::endl; } } } } if (pixelCount <= pixelDebugNumber) { std::cout << "Region queue (" << regionContainer.size() << " elements) : " << std::endl; for (regionIterator = regionContainer.begin(); regionIterator != regionContainer.end(); ++regionIterator) std::cout << *regionIterator; std::cout << std::endl; } // Compute variance-covariance matrix of x-y coordinates of region pixels double sumX = 0, sumY = 0, sumX2 = 0, sumY2 = 0, sumXY = 0; double avgX, avgY, varX, varY, covarXY; int n = regionContainer.size(); for (regionIterator = regionContainer.begin(); regionIterator != regionContainer.end(); ++regionIterator) { explorerIndex = *regionIterator; sumX += explorerIndex[0]; sumY += explorerIndex[1]; sumX2 += explorerIndex[0] * explorerIndex[0]; sumY2 += explorerIndex[1] * explorerIndex[1]; sumXY += explorerIndex[0] * explorerIndex[1]; } avgX = (double) sumX / n; avgY = (double) sumY / n; varX = (double) sumX2 / n - avgX * avgX; varY = (double) sumY2 / n - avgY * avgY; covarXY = (double) sumXY / n - avgX * avgY; // Compute average deviation (or mean absolute deviation) matrix instead, because rectangles resulting from above statistics are too elongated double sumAX = 0, sumAY = 0, crossTermAXY = 0; double adevX, adevY, adevXY; double ax, ay; for (regionIterator = regionContainer.begin(); regionIterator != regionContainer.end(); ++regionIterator) { explorerIndex = *regionIterator; ax = vcl_abs(explorerIndex[0] - avgX); ay = vcl_abs(explorerIndex[1] - avgY); sumAX += ax; sumAY += ay; crossTermAXY += ax * ay; } adevX = sumAX / n; adevY = sumAY / n; adevXY = vcl_sqrt(crossTermAXY) / n; // Compute eigenvalues and eigenvectors of variance-covariance matrix (for DIRECTION) double delta, l1, l2, /* eigenvalues */ y1, y2, /* eigenvectors y coordinate, for x = 1*/ x1 = 1, /* first eigenvector x coordinate */ x2 = 1, /* second eigenvector x coordinate, 1 except in special case when covarXY == 0 */ alpha /* main direction */; delta = (varX - varY) * (varX - varY) + 4 * covarXY * covarXY; l1 = (varX + varY + vcl_sqrt(delta)) / 2; l2 = (varX + varY - vcl_sqrt(delta)) / 2; if (covarXY != 0.0) // ZZ or larger than a small epsilon ? (eg 10^(-15)...) { y1 = (l1 - varX) / covarXY; // for x1 = 1 y2 = (l2 - varX) / covarXY; // for x2 = 1 } else // matrix was already diagonal { y1 = 0; x2 = 0; y2 = 1; } // Compute eigenvalues and eigenvectors of absolute mean deviation matrix (for PROPORTIONS) double adelta, al1, al2, /* eigenvalues */ ay1, ay2, /* eigenvectors y coordinate, for x = 1*/ ax1 = 1, /* first eigenvector x coordinate */ ax2 = 1; /* second eigenvector x coordinate, 1 except in special case when covarXY == 0 */ adelta = (adevX - adevY) * (adevX - adevY) + 4 * adevXY * adevXY; al1 = (adevX + adevY + vcl_sqrt(adelta)) / 2; al2 = (adevX + adevY - vcl_sqrt(adelta)) / 2; if (adevXY != 0.0) // ZZ or larger than a small epsilon ? (eg 10^(-15)...) { ay1 = (al1 - adevX) / adevXY; // for x1 = 1 ay2 = (al2 - adevX) / adevXY; // for x2 = 1 } else // matrix was already diagonal { ay1 = 0; ax2 = 0; ay2 = 1; } if (y1 != 0) alpha = vcl_atan(1 / y1) * 180 / vnl_math::pi; else alpha = 90; if (alpha < 0) alpha += 180; // Conventionnaly given as a value between 0 and 180 degrees // Compute equivalent length and width (based on equal area criterion) double length, width; if (al2 != 0) { length = vcl_sqrt(vcl_abs(al1 / al2) * n); //length = vcl_sqrt(l1 / l2 * n); if (al1 != 0) width = vcl_abs(al2 / al1) * length; else // l1 == 0 and l2 == 0 { length = width = vcl_sqrt(static_cast(n)); // should happen only when n == 1 anyway } } else { length = n; // Arbitrary representation for degenerate case width = 1; } // Normalize eigenvectors (for following tests) double norm; norm = vcl_sqrt(x1 * x1 + y1 * y1); assert (norm != 0); //(by construction of eigenvectors) if (norm != 0) { x1 /= norm; y1 /= norm; } norm = vcl_sqrt(x2 * x2 + y2 * y2); assert (norm != 0); //(by construction of eigenvectors) if (norm != 0) { x2 /= norm; y2 /= norm; } // Normalize eigenvectors (for following tests) (No : used only for printing values for debugging) norm = vcl_sqrt(ax1 * ax1 + ay1 * ay1); assert (norm != 0); //(by construction of eigenvectors) if (norm != 0) { ax1 /= norm; ay1 /= norm; } norm = vcl_sqrt(ax2 * ax2 + ay2 * ay2); assert (norm != 0); //(by construction of eigenvectors) if (norm != 0) { ax2 /= norm; ay2 /= norm; } // Count the proportion of region pixels contained within rectangle model, to evaluate rectangular fit, or "rectangularity" // Rectangle model uses [x1, y1] and [x2, y2] for direction (angle), and size derived from adev matrix double vx, vy; // x-y coordinates relative to rectangle center double halfLength = length / 2, halfWidth = width / 2; // to write formulas more easily int countWithin = 0; // number of pixels contained within rectangle for (regionIterator = regionContainer.begin(); regionIterator != regionContainer.end(); ++regionIterator) { explorerIndex = *regionIterator; vx = explorerIndex[0] - avgX; vy = explorerIndex[1] - avgY; if (vcl_abs(vx * x1 + vy * y1) <= halfLength && vcl_abs(vx * x2 + vy * y2) <= halfWidth) countWithin++; } if (regionCount <= regionDebugNumber) { std::cout << std::endl << "Region " << regionCount << " (area = " << n << " pixels)" << std::endl; std::cout << "sumX = " << sumX << "; sumY = " << sumY << "; sumX2 = " << sumX2 << "; sumY2 = " << sumY2 << "; sumXY = " << sumXY << std::endl; std::cout << "avgX = " << avgX << "; avgY = " << avgY << std::endl; std::cout << "varX = " << varX << "; varY = " << varY << "; covarXY = " << covarXY << std::endl; std::cout << "adevX = " << adevX << "; adevY = " << adevY << "; adevXY = " << adevXY << std::endl; std::cout << "crossTermAXY = " << crossTermAXY << std::endl; std::cout << "eigenvalue 1 = " << l1 << "; eigenvalue 2 = " << l2 << std::endl; std::cout << "eigenvector 1 = [" << x1 << ", " << y1 << "]; eigenvector 2 = [" << x2 << ", " << y2 << "]" << std::endl; std::cout << "A-eigenvalue 1 = " << al1 << "; A-eigenvalue 2 = " << al2 << std::endl; std::cout << "A-eigenvector 1 = [" << ax1 << ", " << ay1 << "]; A-eigenvector 2 = [" << ax2 << ", " << ay2 << "]" << std::endl; std::cout << "length = " << length << "; width = " << width << std::endl; std::cout << "main direction = " << alpha << " degree" << std::endl; std::cout << "rectangular fit = " << (float) countWithin / n << std::endl; } // Build rectangle list, converting image coordinates into physical coordinates typedef typename OutputPathType::ContinuousIndexType ContinuousIndexType; ContinuousIndexType point; OutputPathPointerType path = OutputPathType::New(); path->Initialize(); point[0] = (avgX + x1 * halfLength + x2 * halfWidth) * spacing[0] + origin[0]; point[1] = (avgY + y1 * halfLength + y2 * halfWidth) * spacing[1] + origin[1]; path->AddVertex(point); if (regionCount <= regionDebugNumber) std::cout << "corner 1 : [" << point[0] << ", " << point[1] << "]" << std::endl; point[0] = (avgX - x1 * halfLength + x2 * halfWidth) * spacing[0] + origin[0]; point[1] = (avgY - y1 * halfLength + y2 * halfWidth) * spacing[1] + origin[1]; path->AddVertex(point); if (regionCount <= regionDebugNumber) std::cout << "corner 2 : [" << point[0] << ", " << point[1] << "]" << std::endl; point[0] = (avgX - x1 * halfLength - x2 * halfWidth) * spacing[0] + origin[0]; point[1] = (avgY - y1 * halfLength - y2 * halfWidth) * spacing[1] + origin[1]; path->AddVertex(point); if (regionCount <= regionDebugNumber) std::cout << "corner 3 : [" << point[0] << ", " << point[1] << "]" << std::endl; point[0] = (avgX + x1 * halfLength - x2 * halfWidth) * spacing[0] + origin[0]; point[1] = (avgY + y1 * halfLength - y2 * halfWidth) * spacing[1] + origin[1]; path->AddVertex(point); if (regionCount <= regionDebugNumber) std::cout << "corner 4 : [" << point[0] << ", " << point[1] << "]" << std::endl; point[0] = (avgX + x1 * halfLength + x2 * halfWidth) * spacing[0] + origin[0]; point[1] = (avgY + y1 * halfLength + y2 * halfWidth) * spacing[1] + origin[1]; path->AddVertex(point); path->SetValue((double) countWithin / n); if ((float) countWithin / n >= m_MinimumFit // keep only rectangles with fit larger than minimumFit && n >= m_MinimumSize) // and size larger than minimumSize { OutputPath->PushBack(path); selectedRegionCount++; } } } } catch (std::exception & e) { std::cerr << "Caught exception " << e.what() << std::endl; } std::cout << pixelCount << " pixels seen." << std::endl; std::cout << regionCount << " regions processed, " << selectedRegionCount << " regions selected." << std::endl; itkDebugMacro(<< "ImageToPathListAlignFilter::GenerateData() finished"); } // end update function template void RegionImageToRectangularPathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/include/otbVectorizationPathListFilter.h000066400000000000000000000136621301006202600276350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorizationPathListFilter_h #define otbVectorizationPathListFilter_h #include "otbPathListSource.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodIterator.h" #include "itkConstantBoundaryCondition.h" #include "otbImage.h" namespace otb { /** \class VectorizationPathListFilter * \brief This filter performs a vectorization from a line detector modulus and direction outputs. * * The output of this filter is an otb::ObjectList. * * This filter performs vectorization at non-grid position by using the barycenter of the few pixels with * non-null intensity in the given direction. A threshold can be set to tune the sensibility of the first point * detection. Path with less than three vertices are not kept by the filter. * * \ingroup PathListSource * * \ingroup OTBPath */ template class ITK_EXPORT VectorizationPathListFilter : public PathListSource { public: /** Standard typedefs */ typedef VectorizationPathListFilter Self; typedef PathListSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(VectorizationPathListFilter, PathListSource); /** Template parameters typedefs */ typedef TInputModulus InputModulusType; typedef typename InputModulusType::ConstPointer InputModulusConstPointerType; typedef typename InputModulusType::PixelType InputPixelType; typedef typename InputModulusType::PointType PointType; typedef typename InputModulusType::IndexType IndexType; typedef TInputDirection InputDirectionType; typedef typename InputDirectionType::ConstPointer InputDirectionConstPointerType; typedef TOutputPath OutputPathType; typedef typename OutputPathType::Pointer OutputPathPointerType; typedef typename OutputPathType::ContinuousIndexType VertexType; /** Derived typedefs */ typedef typename Superclass::OutputPathListType OutputPathListType; typedef typename Superclass::OutputPathListPointerType OutputPathListPointerType; /** Set/get the input modulus */ using Superclass::SetInput; void SetInput(InputModulusType * inputModulus); const InputModulusType * GetInput(void); /** Set/get the input direction */ void SetInputDirection(InputDirectionType * inputDirection); const InputDirectionType * GetInputDirection(void); itkSetMacro(AmplitudeThreshold, InputPixelType); itkGetMacro(AmplitudeThreshold, InputPixelType); protected: /** Other internal useful typedefs */ typedef otb::Image FlagImageType; typedef typename FlagImageType::Pointer FlagImagePointerType; typedef itk::ImageRegionConstIterator ModRegionIteratorType; typedef itk::ImageRegionConstIterator DirRegionIteratorType; typedef itk::ImageRegionIterator FlagRegionIteratorType; typedef itk::ConstantBoundaryCondition ModBCType; typedef itk::ConstantBoundaryCondition DirBCType; typedef itk::ConstantBoundaryCondition FlagBCType; typedef itk::ConstNeighborhoodIterator ModNeighborhoodIteratorType; typedef itk::ConstNeighborhoodIterator DirNeighborhoodIteratorType; typedef itk::NeighborhoodIterator FlagNeighborhoodIteratorType; typedef typename ModNeighborhoodIteratorType::RadiusType RadiusType; typedef typename ModNeighborhoodIteratorType::OffsetType OffsetType; typedef std::vector OffsetVectorType; typedef typename OutputPathType::VertexListType VertexListType; typedef typename VertexListType::ConstPointer VertexListPointerType; typedef typename VertexListType::ConstIterator VertexIteratorType; /** Constructor */ VectorizationPathListFilter(); /** Destructor */ ~VectorizationPathListFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** * Compute a vector of the 8 neighbors to explore from the direction and the type of search (forward or backward). * \param direction The direction * \param flagReverse The type of search * \return The neighborhood vector */ OffsetVectorType GetEightNeighborOffsetFromDirection(double direction, unsigned int flagReverse); /** * Compute a vector of the 3 neighbors to explore from the direction and the type of search (forward or backward). * \param direction The direction * \param flagReverse The type of search * \return The neighborhood vector */ OffsetVectorType GetThreeNeighborOffsetFromDirection(double direction, unsigned int flagReverse); private: VectorizationPathListFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Amplitude threshold to start following a path */ InputPixelType m_AmplitudeThreshold; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorizationPathListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Path/include/otbVectorizationPathListFilter.txx000066400000000000000000000457421301006202600302350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorizationPathListFilter_txx #define otbVectorizationPathListFilter_txx #include "otbVectorizationPathListFilter.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { /** * Constructor */ template VectorizationPathListFilter ::VectorizationPathListFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(2); m_AmplitudeThreshold = 1.0; } template void VectorizationPathListFilter ::SetInput(InputModulusType * inputModulus) { this->itk::ProcessObject::SetNthInput(0, const_cast(inputModulus)); } template const typename VectorizationPathListFilter ::InputModulusType * VectorizationPathListFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template void VectorizationPathListFilter ::SetInputDirection(InputDirectionType * inputDirection) { this->itk::ProcessObject::SetNthInput(1, const_cast(inputDirection)); } template const typename VectorizationPathListFilter ::InputDirectionType * VectorizationPathListFilter ::GetInputDirection(void) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } /** * Main computation method */ template void VectorizationPathListFilter ::GenerateData(void) { InputModulusConstPointerType modPtr = this->GetInput(); InputDirectionConstPointerType dirPtr = this->GetInputDirection(); OutputPathListPointerType outPtr = this->GetOutput(); typedef typename OffsetVectorType::iterator OffsetIteratorType; RadiusType radius; radius.Fill(2); OffsetVectorType offsetVector; // Creation of the flag image FlagImagePointerType flagImage = FlagImageType::New(); flagImage->SetRegions(modPtr->GetLargestPossibleRegion()); flagImage->Allocate(); flagImage->FillBuffer(false); // Iterators instantiation ModRegionIteratorType modIt(modPtr, modPtr->GetLargestPossibleRegion()); DirRegionIteratorType dirIt(dirPtr, dirPtr->GetLargestPossibleRegion()); FlagRegionIteratorType flagIt(flagImage, flagImage->GetLargestPossibleRegion()); for (modIt.GoToBegin(), dirIt.GoToBegin(), flagIt.GoToBegin(); (!modIt.IsAtEnd()) && (!dirIt.IsAtEnd()) && (!flagIt.IsAtEnd()); ++modIt, ++dirIt, ++flagIt) { if ((modIt.Get() > m_AmplitudeThreshold) && (!flagIt.Get())) { //this is a beginning, to follow in two directions OutputPathPointerType pathTempDirect = OutputPathType::New(); OutputPathPointerType pathTempReverse = OutputPathType::New(); OutputPathPointerType path = OutputPathType::New(); bool flagFinish; int flagReverse = 0; double totalAmplitude = 0; ModNeighborhoodIteratorType nModIt(radius, modPtr, modPtr->GetLargestPossibleRegion()); DirNeighborhoodIteratorType nDirIt(radius, dirPtr, dirPtr->GetLargestPossibleRegion()); FlagNeighborhoodIteratorType nFlagIt(radius, flagImage, flagImage->GetLargestPossibleRegion()); for (flagReverse = 0; flagReverse < 2; ++flagReverse) { nModIt.SetLocation(modIt.GetIndex()); nDirIt.SetLocation(dirIt.GetIndex()); nFlagIt.SetLocation(flagIt.GetIndex()); // temporary point PointType point; VertexType vertex; modPtr->TransformIndexToPhysicalPoint(nModIt.GetIndex(), point); modPtr->TransformPhysicalPointToContinuousIndex(point, vertex); if (flagReverse == 0) { flagIt.Set(true); // otbMsgDebugMacro(<<"Adding new vertex: "<AddVertex(vertex); } flagFinish = false; while (!flagFinish) { offsetVector = GetThreeNeighborOffsetFromDirection(nDirIt.GetCenterPixel(), flagReverse); OffsetIteratorType vecIt = offsetVector.begin(); bool flagFound = false; while (vecIt != offsetVector.end() && !flagFound) { flagFound = nModIt.GetPixel(*vecIt) > 0 && !nFlagIt.GetPixel(*vecIt); ++vecIt; } if (flagFound) { point.Fill(0); PointType tmpPoint; totalAmplitude = 0; for (vecIt = offsetVector.begin(); vecIt != offsetVector.end(); ++vecIt) { double currentAmplitude = nModIt.GetPixel(*vecIt); modPtr->TransformIndexToPhysicalPoint(nModIt.GetIndex(*vecIt), tmpPoint); point[0] += currentAmplitude * tmpPoint[0]; point[1] += currentAmplitude * tmpPoint[1]; totalAmplitude += currentAmplitude; } point[0] = point[0] / totalAmplitude; point[1] = point[1] / totalAmplitude; modPtr->TransformPhysicalPointToContinuousIndex(point, vertex); if (flagReverse == 0) { // otbMsgDevMacro(<<"Adding new vertex (direct): "<AddVertex(vertex); } else { // otbMsgDevMacro(<<"Adding new vertex (reverse): "<AddVertex(vertex); } // flag the pixel use nFlagIt.SetCenterPixel(true); //update the neighbor iterators so they are centered on the nearest pixel to the barycenter IndexType newIndex; if (modPtr->TransformPhysicalPointToIndex(point, newIndex)) { // otbMsgDevMacro(<<"Moving to new center: " << newIndex); nModIt.SetLocation(newIndex); nDirIt.SetLocation(newIndex); nFlagIt.SetLocation(newIndex); if (nModIt.GetCenterPixel() == 0) { //we need to check that in case the barycenter is out... flagFinish = true; } if (nFlagIt.GetCenterPixel()) { //we don't want to go back to the same pixels flagFinish = true; } } else { //new point outside image flagFinish = true; } } else { flagFinish = true; } } } VertexListPointerType vertexDirect = pathTempDirect->GetVertexList(); VertexListPointerType vertexReverse = pathTempReverse->GetVertexList(); unsigned int numberVertex = 0; VertexIteratorType vertexReverseIt = vertexReverse->End(); if (vertexReverseIt != vertexReverse->Begin()) { --vertexReverseIt; while (vertexReverseIt != vertexReverse->Begin()) { path->AddVertex(vertexReverseIt.Value()); ++numberVertex; --vertexReverseIt; } path->AddVertex(vertexReverseIt.Value()); } VertexIteratorType vertexDirectIt = vertexDirect->Begin(); while (vertexDirectIt != vertexDirect->End()) { path->AddVertex(vertexDirectIt.Value()); ++vertexDirectIt; ++numberVertex; } // otbMsgDebugMacro(<<"Path number of vertices: "< 3) { outPtr->PushBack(path); } } } } /** * Compute the 8 neighbors to explore from the direction and the type of search (forward or backward). * \param direction The direction * \param flagReverse The type of search * \return The neighborhood */ template typename VectorizationPathListFilter ::OffsetVectorType VectorizationPathListFilter ::GetEightNeighborOffsetFromDirection(double direction, unsigned int flagReverse) { int neighborhoodNumber = 0; OffsetVectorType offset; offset.reserve(8); if (direction > 0) { //find the direction in terms of 0, 1, 2, 3 neighborhoodNumber = (int) (direction / (CONST_PI_4) -1); } else { neighborhoodNumber = (int) ((direction + CONST_PI) / (CONST_PI_4) -1); neighborhoodNumber = (neighborhoodNumber + 4); //if the direction was <0 need to convert to 4, 5, 6, 7 } if (flagReverse) { //if the reverse flag is activated we need to look on the other side neighborhoodNumber = (neighborhoodNumber + 4) % 8; } OffsetType tmpOffset; switch (neighborhoodNumber) { case 0: tmpOffset[0] = 1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = 2; offset.push_back(tmpOffset); break; case 1: tmpOffset[0] = 1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 2; offset.push_back(tmpOffset); break; case 2: tmpOffset[0] = 0; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 0; offset.push_back(tmpOffset); break; case 3: tmpOffset[0] = -1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 2; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = -2; offset.push_back(tmpOffset); break; case 4: tmpOffset[0] = -1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = -2; offset.push_back(tmpOffset); break; case 5: tmpOffset[0] = -1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = -2; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = -2; offset.push_back(tmpOffset); break; case 6: tmpOffset[0] = 0; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 0; offset.push_back(tmpOffset); break; case 7: tmpOffset[0] = 1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = -2; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 2; tmpOffset[1] = 2; offset.push_back(tmpOffset); break; } return offset; } /** * Compute the 3 neighbors to explore from the direction and the type of search (forward or backward). * \param direction The direction * \param flagReverse The type of search * \return The neighborhood */ template typename VectorizationPathListFilter ::OffsetVectorType VectorizationPathListFilter ::GetThreeNeighborOffsetFromDirection(double direction, unsigned int flagReverse) { int neighborhoodNumber = 0; OffsetVectorType offset; offset.reserve(3); if (direction > 0) { //find the direction in terms of 0, 1, 2, 3 neighborhoodNumber = (int) (direction / (CONST_PI_4) -1); } else { neighborhoodNumber = (int) ((direction + CONST_PI) / (CONST_PI_4) -1); neighborhoodNumber = (neighborhoodNumber + 4); //if the direction was <0 need to convert to 4, 5, 6, 7 } if (flagReverse) { //if the reverse flag is activated we need to look on the other side neighborhoodNumber = (neighborhoodNumber + 4) % 8; } OffsetType tmpOffset; // otbMsgDevMacro(<<"Direction: " << neighborhoodNumber) switch (neighborhoodNumber) { case 0: tmpOffset[0] = 1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = 1; offset.push_back(tmpOffset); break; case 1: tmpOffset[0] = 1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 1; offset.push_back(tmpOffset); break; case 2: tmpOffset[0] = 0; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 0; offset.push_back(tmpOffset); break; case 3: tmpOffset[0] = -1; tmpOffset[1] = 1; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = -1; offset.push_back(tmpOffset); break; case 4: tmpOffset[0] = -1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = -1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = -1; offset.push_back(tmpOffset); break; case 5: tmpOffset[0] = -1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 0; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = -1; offset.push_back(tmpOffset); break; case 6: tmpOffset[0] = 0; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 0; offset.push_back(tmpOffset); break; case 7: tmpOffset[0] = 1; tmpOffset[1] = -1; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 0; offset.push_back(tmpOffset); tmpOffset[0] = 1; tmpOffset[1] = 1; offset.push_back(tmpOffset); break; } return offset; } /** * PrintSelf Method */ template void VectorizationPathListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Path/otb-module.cmake000066400000000000000000000011631301006202600227170ustar00rootroot00000000000000set(DOCUMENTATION "This module is related to the handling of paths. For instance, it contains the base class 'otbImageToPathFilter' for filters taking an image as input, and producing an output of type Path. another interesting class is 'otbPathFunction', which is the base class for all objects that evaluate a function of an image using a path list (computation of histograms for instance). And so on.") otb_module(OTBPath DEPENDS OTBVectorDataBase OTBImageBase OTBObjectList OTBITK OTBCommon TEST_DEPENDS OTBTestKernel OTBImageIO OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/Path/test/000077500000000000000000000000001301006202600206245ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Path/test/CMakeLists.txt000066400000000000000000000166371301006202600234010ustar00rootroot00000000000000otb_module_test() set(OTBPathTests otbPathTestDriver.cxx otbCompacityPathRectangle.cxx otbVectorizationPathListFilterNew.cxx otbRegionImageToRectangularPathListFilterNew.cxx otbImageToEdgePathFilter.cxx otbCompacityPathCircle.cxx otbDrawPathListFilterWithValue.cxx otbImageFittingPolygonListFilterNew.cxx otbDrawPath.cxx otbCompacityPathSquare.cxx otbPathLengthFunctor.cxx otbPathListToHistogramGenerator.cxx otbImageFittingPolygonListFilter.cxx otbImageToPathFilterNew.cxx otbImageToEdgePathFilterNew.cxx otbDrawPathListFilter.cxx otbDrawPathListFilterNew.cxx otbDrawPathFilter.cxx otbOrientationPath.cxx otbOrientationPathNew.cxx otbDrawPathFilterNew.cxx otbPolyLineImageConstIterator.cxx otbRegionImageToRectangularPathListFilter.cxx otbVectorizationPathListFilter.cxx otbPathListToPathListFilterNew.cxx otbPathListToHistogramGeneratorNew.cxx otbCompacityPathNew.cxx otbClosePathFunctor.cxx otbPolyLineImageIterator.cxx ) add_executable(otbPathTestDriver ${OTBPathTests}) target_link_libraries(otbPathTestDriver ${OTBPath-Test_LIBRARIES}) otb_module_target_label(otbPathTestDriver) # Tests Declaration otb_add_test(NAME feTuCompacityPathRectangle COMMAND otbPathTestDriver otbCompacityPathRectangle 10.0 20.0) otb_add_test(NAME feTuVectorizationPathListFilterNew COMMAND otbPathTestDriver otbVectorizationPathListFilterNew) otb_add_test(NAME feTuRegionImageToRectangularPathListFilterNew COMMAND otbPathTestDriver otbRegionImageToRectangularPathListFilterNew) otb_add_test(NAME feTvImageToEdgePathFilterBis COMMAND otbPathTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feImageToEdgePathFilter_maskrom.png ${TEMP}/feImageToEdgePathFilter_maskrom.png otbImageToEdgePathFilter ${INPUTDATA}/maskrom.png ${TEMP}/feImageToEdgePathFilter_maskrom.png 0 ) otb_add_test(NAME feTvImageToEdgePathFilter COMMAND otbPathTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feImageToEdgePathFilter_rcc8_mire4.png ${TEMP}/feImageToEdgePathFilter_rcc8_mire4.png otbImageToEdgePathFilter ${INPUTDATA}/rcc8_mire4.png ${TEMP}/feImageToEdgePathFilter_rcc8_mire4.png 255 ) otb_add_test(NAME feTuCompacityPathCircle COMMAND otbPathTestDriver otbCompacityPathCircle 1000) otb_add_test(NAME coTvDrawPathListFilterWithValue COMMAND otbPathTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvDrawPathListFilterWithValueOutput.png ${TEMP}/coTvDrawPathListFilterWithValueOutput.png otbDrawPathListFilterWithValue 512 512 20 ${TEMP}/coTvDrawPathListFilterWithValueOutput.png ) otb_add_test(NAME feTuImageFittingPolygonListFilterNew COMMAND otbPathTestDriver otbImageFittingPolygonListFilterNew) otb_add_test(NAME feTvDrawPathTestCarre COMMAND otbPathTestDriver --compare-image ${NOTOL} ${BASELINE}/feDrawPathDessinCarre.png ${TEMP}/feDrawPathDessinCarre.png otbDrawPathDessinCarre ${INPUTDATA}/DeuxTraits.png ${TEMP}/feDrawPathDessinCarre.png) otb_add_test(NAME feTuCompacityPathSquare COMMAND otbPathTestDriver otbCompacityPathSquare 10.0) otb_add_test(NAME bfTvPathLengthFunctor COMMAND otbPathTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfPathLengthFunctorTest.txt ${TEMP}/bfPathLengthFunctorTest.txt otbPathLengthFunctor ${INPUTDATA}/polygon.png ${TEMP}/bfPathLengthFunctorTest.txt ) otb_add_test(NAME coTuPathListToHistogramGenerator COMMAND otbPathTestDriver otbPathListToHistogramGenerator 100 2) otb_add_test(NAME feTvImageFittingPolygonListFilter COMMAND otbPathTestDriver --compare-ogr ${EPSILON_3} ${BASELINE_FILES}/feTvImageFittingPolygonListFilter_Output.shp ${TEMP}/feTvImageFittingPolygonListFilter_Output.shp otbImageFittingPolygonListFilter ${INPUTDATA}/polygon.png ${INPUTDATA}/polygon-start.shp ${TEMP}/feTvImageFittingPolygonListFilter_Output.shp 5 10 ) otb_add_test(NAME coTuImageToPathFilterNew COMMAND otbPathTestDriver otbImageToPathFilterNew) otb_add_test(NAME feTuImageToEdgePathFilterNew COMMAND otbPathTestDriver otbImageToEdgePathFilterNew) otb_add_test(NAME coTvDrawPathListFilter COMMAND otbPathTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvDrawPathListFilterOutput.png ${TEMP}/coTvDrawPathListFilterOutput.png otbDrawPathListFilter 512 512 20 ${TEMP}/coTvDrawPathListFilterOutput.png ) otb_add_test(NAME coTuDrawPathListFilterNew COMMAND otbPathTestDriver otbDrawPathListFilterNew) otb_add_test(NAME coTvDrawPatFilter COMMAND otbPathTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvDrawPathFilterOutput.png ${TEMP}/coTvDrawPathFilterOutput.png otbDrawPathFilter 512 512 20 ${TEMP}/coTvDrawPathFilterOutput.png ) otb_add_test(NAME feTuOrientationPath_090 COMMAND otbPathTestDriver otbOrientationPath 90.0) otb_add_test(NAME feTuOrientationPath_045 COMMAND otbPathTestDriver otbOrientationPath 45.0) otb_add_test(NAME feTuOrientationPath_000 COMMAND otbPathTestDriver otbOrientationPath 0.0) otb_add_test(NAME feTuOrientationPath1_80 COMMAND otbPathTestDriver otbOrientationPath 180.0) otb_add_test(NAME feTuOrientationPathNew COMMAND otbPathTestDriver otbOrientationPathNew) otb_add_test(NAME coTuDrawPatFilterNew COMMAND otbPathTestDriver otbDrawPathFilterNew ) otb_add_test(NAME coTvPolyLineImageConstIterator COMMAND otbPathTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/coTvPolyLineImageConstIterator.txt ${TEMP}/coTvPolyLineImageConstIterator.txt otbPolyLineImageConstIterator 512 512 20 ${TEMP}/coTvPolyLineImageConstIterator.txt ) otb_add_test(NAME feTvRegionImageToRectangularPathListFilter COMMAND otbPathTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feRectangle.txt ${TEMP}/feRectangle.txt otbRegionImageToRectangularPathListFilter ${INPUTDATA}/rectangle.png ${TEMP}/feRectangle.txt 0.9 #fit score 10) #minimum size otb_add_test(NAME feTvVectorizationPathListFilterImageOutput COMMAND otbPathTestDriver --compare-image ${EPSILON_8} ${BASELINE}/feTvVectorizationPathListOutput.png ${TEMP}/feTvVectorizationPathListOutput.png otbVectorizationPathListFilter ${INPUTDATA}/InputForRoadDetection_NonMaxRem.hdr ${INPUTDATA}/InputForRoadDetectionScalarProductDir.hdr ${TEMP}/feTvVectorizationPathListOutputIgnored.txt ${TEMP}/feTvVectorizationPathListOutput.png 0.0001 ) otb_add_test(NAME feTvVectorizationPathListFilterAsciiOutput COMMAND otbPathTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/feTvVectorizationPathListOutput.txt ${TEMP}/feTvVectorizationPathListOutput.txt otbVectorizationPathListFilter ${INPUTDATA}/InputForRoadDetection_NonMaxRem.hdr ${INPUTDATA}/InputForRoadDetectionScalarProductDir.hdr ${TEMP}/feTvVectorizationPathListOutput.txt ${TEMP}/feTvVectorizationPathListOutputIgnored.png 0.0005 ) otb_add_test(NAME coTuPathListToPathListFilterNew COMMAND otbPathTestDriver otbPathListToPathListFilterNew) otb_add_test(NAME coTuPathListToHistogramGeneratorNew COMMAND otbPathTestDriver otbPathListToHistogramGeneratorNew) otb_add_test(NAME feTuCompacityPathNew COMMAND otbPathTestDriver otbCompacityPathNew) otb_add_test(NAME bfTvClosePathFunctor COMMAND otbPathTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfClosePathFunctorTest.txt ${TEMP}/bfClosePathFunctorTest.txt otbClosePathFunctor ${INPUTDATA}/polygon.png ${TEMP}/bfClosePathFunctorTest.txt ) otb_add_test(NAME coTvPolyLineImageIterator COMMAND otbPathTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvPolyLineImageIterator.png ${TEMP}/coTvPolyLineImageIterator.png otbPolyLineImageIterator 512 512 20 ${TEMP}/coTvPolyLineImageIterator.png ) OTB-release-5.8/Modules/Filtering/Path/test/otbClosePathFunctor.cxx000066400000000000000000000073211301006202600253030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkConnectedComponentImageFilter.h" #include "otbPolygon.h" #include "otbObjectList.h" #include "otbImageToEdgePathFilter.h" #include "otbClosePathFunctor.h" #include "otbUnaryFunctorObjectListFilter.h" int otbClosePathFunctor(int argc, char * argv[]) { if (argc != 3) { std::cout << "Usage: " << argv[0]; std::cout << " inputImage outputFile" << std::endl; return 1; } typedef unsigned char InputPixelType; typedef unsigned short LabelPixelType; //FIXME doesn't seem to work with long int (64 bits problem ?) typedef otb::Image InputImageType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); typedef itk::ConnectedComponentImageFilter ConnectedComponentsFilterType; ConnectedComponentsFilterType::Pointer connectedComponentsFilter = ConnectedComponentsFilterType::New(); // connectedComponentsFilter->SetInput(reader->GetOutput()); connectedComponentsFilter->SetInput(reader->GetOutput()); connectedComponentsFilter->Update(); std::cout << "# regions: " << connectedComponentsFilter->GetObjectCount() << std::endl; typedef otb::Polygon PolygonType; typedef otb::ObjectList PolygonListType; typedef otb::ImageToEdgePathFilter PolygonFilterType; PolygonListType::Pointer polygonList = PolygonListType::New(); for (LabelPixelType label = 1; label <= connectedComponentsFilter->GetObjectCount(); ++label) { std::cerr << "."; PolygonFilterType::Pointer polygonFilter = PolygonFilterType::New(); polygonFilter->SetInput(connectedComponentsFilter->GetOutput()); polygonFilter->SetForegroundValue(label); polygonFilter->Update(); polygonList->PushBack(polygonFilter->GetOutput()); } typedef otb::ClosePathFunctor LengthFunctorType; typedef otb::UnaryFunctorObjectListFilter ClosePathFilterType; ClosePathFilterType::Pointer closePathFilter = ClosePathFilterType::New(); closePathFilter->SetInput(polygonList); closePathFilter->Update(); const char * outfile = argv[2]; std::ofstream file; file.open(outfile); typedef PolygonType::VertexListType VertexListType; typedef VertexListType::ConstIterator IteratorType; typedef PolygonListType::ConstIterator PolygonListIteratorType; for (PolygonListIteratorType pIt = closePathFilter->GetOutput()->Begin(); pIt != closePathFilter->GetOutput()->End(); ++pIt) { file << "--- New Polygon ---" << std::endl; PolygonType::Pointer polygon = pIt.Get(); IteratorType it; for (it = polygon->GetVertexList()->Begin(); it != polygon->GetVertexList()->End(); ++it) { file << it.Value() << std::endl; } } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbCompacityPathCircle.cxx000066400000000000000000000040451301006202600257470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCompacityPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" #include "otbMath.h" int otbCompacityPathCircle(int itkNotUsed(argc), char * argv[]) { unsigned int NbOfPoints((unsigned int) ::atoi(argv[1])); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::CompacityPathFunction FunctionType; typedef FunctionType::RealType RealType; PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); if (NbOfPoints < 2) { std::cout << "NbOfPoints must be greater than 2 !" << std::endl; return EXIT_FAILURE; } RealType deltaTheta; RealType Rho = 100.0; deltaTheta = 2. * otb::CONST_PI / static_cast(NbOfPoints); pathElt->Initialize(); for (unsigned int noTheta = 0; noTheta < NbOfPoints; noTheta++) { RealType Theta = deltaTheta * static_cast(noTheta); cindex[0] = (Rho * vcl_cos(Theta)); cindex[1] = (Rho * vcl_sin(Theta)); pathElt->AddVertex(cindex); } FunctionType::Pointer function = FunctionType::New(); function->SetInputPath(pathElt); RealType Result = function->Evaluate(); std::cout << "Compacity result: " << Result << std::endl; RealType Error; Error = vcl_abs(Result - static_cast(1.0)); if (Error > 1.E-5) { std::cout << "Error in estimation !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbCompacityPathNew.cxx000066400000000000000000000020141301006202600252710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCompacityPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" int otbCompacityPathNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::CompacityPathFunction FunctionType; FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbCompacityPathRectangle.cxx000066400000000000000000000041701301006202600264510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCompacityPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" #include "otbMath.h" int otbCompacityPathRectangle(int itkNotUsed(argc), char * argv[]) { double A ((double) ::atof(argv[1])); double B ((double) ::atof(argv[2])); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::CompacityPathFunction FunctionType; typedef FunctionType::RealType RealType; PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); if (A < 0) { std::cout << "retangle must be greater than 0.0 !" << std::endl; return EXIT_FAILURE; } if (B < 0) { std::cout << "rectangle must be greater than 0.0 !" << std::endl; return EXIT_FAILURE; } pathElt->Initialize(); cindex[0] = 100; cindex[1] = 100; pathElt->AddVertex(cindex); cindex[0] = 100 + A; cindex[1] = 100; pathElt->AddVertex(cindex); cindex[0] = 100 + A; cindex[1] = 100 + B; pathElt->AddVertex(cindex); cindex[0] = 100; cindex[1] = 100 + B; pathElt->AddVertex(cindex); FunctionType::Pointer function = FunctionType::New(); function->SetInputPath(pathElt); RealType Result = function->Evaluate(); std::cout << "Compacity result: " << Result << std::endl; RealType Error; Error = vcl_abs(Result - static_cast(otb::CONST_PI * A * B / (A + B) / (A + B))); if (Error > 1.E-9) { std::cout << "Error in estimation !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbCompacityPathSquare.cxx000066400000000000000000000036771301006202600260200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCompacityPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" #include "otbMath.h" int otbCompacityPathSquare(int itkNotUsed(argc), char * argv[]) { double A ((double) ::atof(argv[1])); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::CompacityPathFunction FunctionType; typedef FunctionType::RealType RealType; PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); if (A < 0) { std::cout << "square must be greater than 0.0 !" << std::endl; return EXIT_FAILURE; } pathElt->Initialize(); cindex[0] = 100; cindex[1] = 100; pathElt->AddVertex(cindex); cindex[0] = 100 + A; cindex[1] = 100; pathElt->AddVertex(cindex); cindex[0] = 100 + A; cindex[1] = 100 + A; pathElt->AddVertex(cindex); cindex[0] = 100; cindex[1] = 100 + A; pathElt->AddVertex(cindex); FunctionType::Pointer function = FunctionType::New(); function->SetInputPath(pathElt); RealType Result = function->Evaluate(); std::cout << "Compacity result: " << Result << std::endl; RealType Error; Error = vcl_abs(Result - static_cast(otb::CONST_PI_4)); if (Error > 1.E-9) { std::cout << "Error in Theta estimation :" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbDrawPath.cxx000066400000000000000000000054521301006202600235750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "itkPolyLineParametricPath.h" #include "otbImageFileReader.h" #include "otbDrawPathFilter.h" #include "otbImageFileWriter.h" int otbDrawPathDessinCarre(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef InputImageType::PointType InputImagePointType; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::DrawPathFilter DrawPathFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); PathType::Pointer VertexList = PathType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); InputImageType::ConstPointer image = reader->GetOutput(); InputImagePointType pos; PathType::ContinuousIndexType cindex; VertexList->Initialize(); /*1er Segment*/ pos[0] = 30; pos[1] = 30; image->TransformPhysicalPointToContinuousIndex(pos, cindex); VertexList->AddVertex(cindex); pos[0] = 30; pos[1] = 130; image->TransformPhysicalPointToContinuousIndex(pos, cindex); VertexList->AddVertex(cindex); /*2eme Segment*/ pos[0] = 90; pos[1] = 130; image->TransformPhysicalPointToContinuousIndex(pos, cindex); VertexList->AddVertex(cindex); /*3eme Segment*/ pos[0] = 90; pos[1] = 30; image->TransformPhysicalPointToContinuousIndex(pos, cindex); VertexList->AddVertex(cindex); /*4eme Segment*/ pos[0] = 30; pos[1] = 30; image->TransformPhysicalPointToContinuousIndex(pos, cindex); VertexList->AddVertex(cindex); DrawPathFilterType::Pointer DrawPath = DrawPathFilterType::New(); DrawPath->SetImageInput(reader->GetOutput()); DrawPath->SetInputPath(VertexList); writer->SetInput(DrawPath->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbDrawPathFilter.cxx000066400000000000000000000053301301006202600247360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDrawPathFilter.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkPolyLineParametricPath.h" int otbDrawPathFilter(int argc, char * argv[]) { if (argc != 5) { std::cout << "Usgage: " << argv[0] << " sizex sizey nbpoints outfname" << std::endl; return EXIT_SUCCESS; } const unsigned int sizex = atoi(argv[1]); const unsigned int sizey = atoi(argv[2]); const unsigned int nbpoints = atoi(argv[3]); const char * outfname = argv[4]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef PathType::VertexType VertexType; typedef otb::DrawPathFilter DrawPathFilterType; typedef otb::ImageFileWriter WriterType; ImageType::SizeType size; size[0] = sizex; size[1] = sizey; ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); PathType::Pointer path = PathType::New(); for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = 0; vertex1[1] = i * sizey / nbpoints; vertex2[0] = i * sizex / nbpoints; vertex2[1] = 0; path->AddVertex(vertex1); path->AddVertex(vertex2); } for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = i * sizex / nbpoints; vertex1[1] = sizey - 1; vertex2[0] = sizex - 1; vertex2[1] = i * sizey / nbpoints; path->AddVertex(vertex1); path->AddVertex(vertex2); } DrawPathFilterType::Pointer filter = DrawPathFilterType::New(); filter->SetImageInput(image); filter->SetInputPath(path); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbDrawPathFilterNew.cxx000066400000000000000000000023401301006202600254060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDrawPathFilter.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkPolyLineParametricPath.h" int otbDrawPathFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::DrawPathFilter DrawPathFilterType; DrawPathFilterType::Pointer filter = DrawPathFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbDrawPathListFilter.cxx000066400000000000000000000057411301006202600256000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDrawPathListFilter.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkPolyLineParametricPath.h" int otbDrawPathListFilter(int argc, char * argv[]) { if (argc != 5) { std::cout << "Usgage: " << argv[0] << " sizex sizey nbpoints outfname" << std::endl; return EXIT_SUCCESS; } const unsigned int sizex = atoi(argv[1]); const unsigned int sizey = atoi(argv[2]); const unsigned int nbpoints = atoi(argv[3]); const char * outfname = argv[4]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef PathType::VertexType VertexType; typedef otb::DrawPathListFilter DrawPathListFilterType; typedef DrawPathListFilterType::InputPathListType PathListType; typedef otb::ImageFileWriter WriterType; ImageType::SizeType size; size[0] = sizex; size[1] = sizey; ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); PathType::Pointer path1 = PathType::New(); for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = 0; vertex1[1] = i * sizey / nbpoints; vertex2[0] = i * sizex / nbpoints; vertex2[1] = 0; path1->AddVertex(vertex1); path1->AddVertex(vertex2); } PathType::Pointer path2 = PathType::New(); for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = i * sizex / nbpoints; vertex1[1] = sizey - 1; vertex2[0] = sizex - 1; vertex2[1] = i * sizey / nbpoints; path2->AddVertex(vertex1); path2->AddVertex(vertex2); } PathListType::Pointer pl = PathListType::New(); pl->PushBack(path1); pl->PushBack(path2); DrawPathListFilterType::Pointer filter = DrawPathListFilterType::New(); filter->SetInput(image); filter->SetInputPath(pl); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbDrawPathListFilterNew.cxx000066400000000000000000000023761301006202600262530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDrawPathListFilter.h" #include "otbImage.h" #include "itkPolyLineParametricPath.h" int otbDrawPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::DrawPathListFilter DrawPathListFilterType; // Instantiating object DrawPathListFilterType::Pointer filter = DrawPathListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbDrawPathListFilterWithValue.cxx000066400000000000000000000061401301006202600274230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDrawPathListFilter.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbPolyLineParametricPathWithValue.h" int otbDrawPathListFilterWithValue(int argc, char * argv[]) { if (argc != 5) { std::cout << "Usgage: " << argv[0] << " sizex sizey nbpoints outfname" << std::endl; return EXIT_SUCCESS; } const unsigned int sizex = atoi(argv[1]); const unsigned int sizey = atoi(argv[2]); const unsigned int nbpoints = atoi(argv[3]); const char * outfname = argv[4]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::PolyLineParametricPathWithValue PathType; typedef PathType::VertexType VertexType; typedef otb::DrawPathListFilter DrawPathListFilterType; typedef DrawPathListFilterType::InputPathListType PathListType; typedef otb::ImageFileWriter WriterType; ImageType::SizeType size; size[0] = sizex; size[1] = sizey; ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); PathType::Pointer path1 = PathType::New(); for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = 0; vertex1[1] = i * sizey / nbpoints; vertex2[0] = i * sizex / nbpoints; vertex2[1] = 0; path1->AddVertex(vertex1); path1->AddVertex(vertex2); } PathType::Pointer path2 = PathType::New(); for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = i * sizex / nbpoints; vertex1[1] = sizey - 1; vertex2[0] = sizex - 1; vertex2[1] = i * sizey / nbpoints; path2->AddVertex(vertex1); path2->AddVertex(vertex2); } PathListType::Pointer pl = PathListType::New(); path1->SetValue(200); pl->PushBack(path1); path2->SetValue(50); pl->PushBack(path2); DrawPathListFilterType::Pointer filter = DrawPathListFilterType::New(); filter->SetInput(image); filter->SetInputPath(pl); filter->SetUseInternalPathValue(true); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbImageFittingPolygonListFilter.cxx000066400000000000000000000104771301006202600300070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFittingPolygonListFilter.h" #include "otbPolygon.h" #include "otbImage.h" #include "otbVectorData.h" #include "otbImageFileReader.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "itkCannyEdgeDetectionImageFilter.h" #include "otbObjectList.h" #include #include int otbImageFittingPolygonListFilter(int itkNotUsed(argc), char * argv[]) { const char * imageFileName = argv[1]; const char * polyFileName = argv[2]; const char * outFileName = argv[3]; const int fittingRadius = atoi(argv[4]); const int fittingIters = atoi(argv[5]); const unsigned int Dimension = 2; typedef otb::Polygon PolygonType; typedef otb::Image ImageType; //Read the reference image and extract its contours typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFileName); typedef itk::CannyEdgeDetectionImageFilter CannyFilterType; CannyFilterType::Pointer canny = CannyFilterType::New(); canny->SetInput(reader->GetOutput()); //Read the original polygon list (kml file) typedef otb::VectorData<> VectorDataType; typedef VectorDataType::DataTreeType DataTreeType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::Pointer DataNodePointerType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer readerVector = VectorDataFileReaderType::New(); readerVector->SetFileName(polyFileName); readerVector->Update(); //Copy the polygons of the data tree in a polygon list typedef otb::ObjectList PolygonListType; PolygonListType::Pointer polygonList = PolygonListType::New(); TreeIteratorType it(readerVector->GetOutput()->GetDataTree()); it.GoToBegin(); while (!it.IsAtEnd()) { DataNodePointerType dataNode = it.Get(); if (dataNode->IsPolygonFeature()) { polygonList->PushBack(dataNode->GetPolygonExteriorRing()); } ++it; } //Fit the polygons on the image typedef otb::ImageFittingPolygonListFilter FittingPolygonType; FittingPolygonType::Pointer fittingPolygon = FittingPolygonType::New(); fittingPolygon->SetInput(polygonList); fittingPolygon->SetInputImage(canny->GetOutput()); fittingPolygon->SetRadius(fittingRadius); fittingPolygon->SetNumberOfIterations(fittingIters); fittingPolygon->Update(); //Write the improved polygon list (kml file) VectorDataType::Pointer data = VectorDataType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder->SetNodeType(otb::FOLDER); document->SetNodeId("DOCUMENT"); folder->SetNodeId("FOLDER"); DataNodeType::Pointer root = data->GetDataTree()->GetRoot()->Get(); data->GetDataTree()->Add(document, root); data->GetDataTree()->Add(folder, document); typedef PolygonListType::ConstIterator ListIteratorType; ListIteratorType listIt = fittingPolygon->GetOutput()->Begin(); while (listIt != fittingPolygon->GetOutput()->End()) { DataNodeType::Pointer polygon = DataNodeType::New(); polygon->SetNodeType(otb::FEATURE_POLYGON); polygon->SetNodeId("FEATURE_POLYGON"); polygon->SetPolygonExteriorRing(listIt.Get()); data->GetDataTree()->Add(polygon, folder); ++listIt; } typedef otb::VectorDataFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outFileName); writer->SetInput(data); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbImageFittingPolygonListFilterNew.cxx000066400000000000000000000022221301006202600304460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFittingPolygonListFilter.h" #include "otbPolygon.h" #include "otbImage.h" #include int otbImageFittingPolygonListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef otb::Polygon PolygonType; typedef otb::Image ImageType; typedef otb::ImageFittingPolygonListFilter FittingPolygonType; // Instantiating object FittingPolygonType::Pointer filter = FittingPolygonType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbImageToEdgePathFilter.cxx000066400000000000000000000073161301006202600261610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPolyLineParametricPath.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbImageToEdgePathFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageToEdgePathFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const unsigned int foreground((const unsigned int) ::atoi(argv[3])); const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef ImageType::IndexType IndexType; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageToEdgePathFilter ImageToEdgePathFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); ImageToEdgePathFilterType::Pointer pathFilter = ImageToEdgePathFilterType::New(); PixelType foregroundValue(foreground); pathFilter->SetForegroundValue(foregroundValue); pathFilter->SetInput(reader->GetOutput()); pathFilter->Update(); std::cout << " pathFilter = " << pathFilter << std::endl; PathType * outputPath = pathFilter->GetOutput(); typedef PathType::VertexType VertexType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstPointer VertexListTypePointer; VertexListTypePointer vertexList; VertexType cindex; VertexListTypePointer ptrVertexList = outputPath->GetVertexList(); std::cout << "Size : " << ptrVertexList->Size() << std::endl; // Initialize Output Image ImageType::Pointer outputImage = ImageType::New(); typedef itk::ImageRegionIteratorWithIndex IteratorType; outputImage->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); outputImage->Allocate(); outputImage->FillBuffer(255); // Create one iterator for the Input Image (this is a light object) IteratorType it(outputImage, outputImage->GetBufferedRegion()); for (unsigned int cpt = 0; cpt < ptrVertexList->Size(); ++cpt) { std::cout << " Point " << cpt << " : " << ptrVertexList->GetElement(cpt) << std::endl; IndexType pos; pos[0] = static_cast(ptrVertexList->GetElement(cpt)[0]); pos[1] = static_cast(ptrVertexList->GetElement(cpt)[1]); outputImage->SetPixel(pos, 0); } WriterType::Pointer writer = WriterType::New(); writer->SetInput(outputImage); writer->SetFileName(outputFilename); writer->Update(); /* VertexListConstIterator iter=ptrVertexList->Begin(); while( iter != ptrVertexList->End() ) { // it.Set( 255 ); std::cout <<" VERTEX : "<<(*iter).GetElement()<GetElement(1); x2 = cindex[0]; y2 = cindex[1]; fprintf(file,"%8.4f %8.3f\n", x1, y1); */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbImageToEdgePathFilterNew.cxx000066400000000000000000000022701301006202600266250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPolyLineParametricPath.h" #include "otbImageToEdgePathFilter.h" #include "otbImage.h" int otbImageToEdgePathFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageToEdgePathFilter ImageToEdgePathFilterType; ImageToEdgePathFilterType::Pointer filter = ImageToEdgePathFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbImageToPathFilterNew.cxx000066400000000000000000000022501301006202600260360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPolyLineParametricPath.h" #include "otbImageToPathFilter.h" #include "otbImage.h" int otbImageToPathFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::ImageToPathFilter ImageToPathFilterType; ImageToPathFilterType::Pointer pathFilter = ImageToPathFilterType::New(); std::cout << pathFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbOrientationPath.cxx000066400000000000000000000034141301006202600251670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbMath.h" #include "otbOrientationPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" int otbOrientationPath(int itkNotUsed(argc), char * argv[]) { double Theta((double) ::atof(argv[1])); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::OrientationPathFunction FunctionType; typedef FunctionType::RealType RealType; PathType::ContinuousIndexType cindex; PathType::Pointer pathElt = PathType::New(); Theta *= otb::CONST_PI / 180.; pathElt->Initialize(); cindex[0] = 30; cindex[1] = 30; pathElt->AddVertex(cindex); cindex[0] += 100 * vcl_cos(Theta); cindex[1] += 100 * vcl_sin(Theta); pathElt->AddVertex(cindex); FunctionType::Pointer function = FunctionType::New(); function->SetInputPath(pathElt); RealType ResultTheta = function->Evaluate(); std::cout.precision(10); std::cout << "Orientation found : " << ResultTheta << std::endl; if (vcl_abs(static_cast(ResultTheta - Theta)) >= 10e-15) { std::cout << "Error in Theta estimation:" << (ResultTheta - Theta) << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbOrientationPathNew.cxx000066400000000000000000000020171301006202600256370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbOrientationPathFunction.h" #include "itkPolyLineParametricPath.h" #include "itkMacro.h" int otbOrientationPathNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::OrientationPathFunction FunctionType; FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbPathLengthFunctor.cxx000066400000000000000000000073731301006202600254660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkConnectedComponentImageFilter.h" #include "otbPolygon.h" #include "otbObjectList.h" #include "otbImageToEdgePathFilter.h" #include "otbPathLengthFunctor.h" #include "otbUnaryFunctorObjectListBooleanFilter.h" int otbPathLengthFunctor(int argc, char * argv[]) { if (argc != 3) { std::cout << "Usage: " << argv[0]; std::cout << " inputImage outputFile" << std::endl; return 1; } typedef unsigned char InputPixelType; typedef unsigned short LabelPixelType; //FIXME doesn't seem to work with long int (64 bits problem ?) typedef otb::Image InputImageType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); typedef itk::ConnectedComponentImageFilter ConnectedComponentsFilterType; ConnectedComponentsFilterType::Pointer connectedComponentsFilter = ConnectedComponentsFilterType::New(); // connectedComponentsFilter->SetInput(reader->GetOutput()); connectedComponentsFilter->SetInput(reader->GetOutput()); connectedComponentsFilter->Update(); std::cout << "# regions: " << connectedComponentsFilter->GetObjectCount() << std::endl; typedef otb::Polygon PolygonType; typedef otb::ObjectList PolygonListType; typedef otb::ImageToEdgePathFilter PolygonFilterType; PolygonListType::Pointer polygonList = PolygonListType::New(); for (LabelPixelType label = 1; label <= connectedComponentsFilter->GetObjectCount(); ++label) { std::cerr << "."; PolygonFilterType::Pointer polygonFilter = PolygonFilterType::New(); polygonFilter->SetInput(connectedComponentsFilter->GetOutput()); polygonFilter->SetForegroundValue(label); polygonFilter->Update(); polygonList->PushBack(polygonFilter->GetOutput()); } typedef otb::PathLengthFunctor LengthFunctorType; typedef otb::UnaryFunctorObjectListBooleanFilter PathLengthFilterType; PathLengthFilterType::Pointer pathLengthFilter = PathLengthFilterType::New(); pathLengthFilter->SetInput(polygonList); pathLengthFilter->GetFunctor().SetThreshold(500); pathLengthFilter->Update(); const char * outfile = argv[2]; std::ofstream file; file.open(outfile); typedef PolygonType::VertexListType VertexListType; typedef VertexListType::ConstIterator IteratorType; typedef PolygonListType::ConstIterator PolygonListIteratorType; for (PolygonListIteratorType pIt = pathLengthFilter->GetOutput()->Begin(); pIt != pathLengthFilter->GetOutput()->End(); ++pIt) { file << "--- New Polygon ---" << std::endl; PolygonType::Pointer polygon = pIt.Get(); IteratorType it; for (it = polygon->GetVertexList()->Begin(); it != polygon->GetVertexList()->End(); ++it) { file << it.Value() << std::endl; } } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbPathListToHistogramGenerator.cxx000066400000000000000000000056611301006202600276450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPolyLineParametricPath.h" #include "otbOrientationPathFunction.h" #include "otbPathListToHistogramGenerator.h" #include "otbMath.h" int otbPathListToHistogramGenerator(int itkNotUsed(argc), char * argv[]) { unsigned int NbOfBins((unsigned int) ::atoi(argv[1])); unsigned int NbOfPointsPerHistogram((unsigned int) ::atoi(argv[2])); const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef PathType::Pointer PathPointer; typedef otb::ObjectList PathListType; typedef otb::OrientationPathFunction FunctionType; typedef otb::PathListToHistogramGenerator HistogramGeneratorType; PathType::ContinuousIndexType cindex; int NbAngle = NbOfPointsPerHistogram * NbOfBins; /* build segments list */ PathListType::Pointer PathList = PathListType::New(); PathList->Clear(); for (int i = 0; i < NbAngle; ++i) { PathPointer pathElt = PathType::New(); pathElt->Initialize(); cindex[0] = 30; cindex[1] = 30; pathElt->AddVertex(cindex); float Theta = 2.0 * static_cast(otb::CONST_PI) * static_cast(i) / static_cast(NbAngle); cindex[0] = 30 + vcl_cos(Theta); cindex[1] = 30 + vcl_sin(Theta); pathElt->AddVertex(cindex); PathList->PushBack(pathElt); } HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New(); typedef HistogramGeneratorType::SizeType HistogramSizeType; HistogramSizeType hsize(1); hsize[0] = NbOfBins; // number of bins for the Red channel histogramGenerator->SetInput(PathList); histogramGenerator->SetNumberOfBins(hsize); histogramGenerator->Update(); typedef HistogramGeneratorType::HistogramType HistogramType; const HistogramType * histogram = histogramGenerator->GetOutput(); const unsigned int histogramSize = histogram->Size(); std::cout << "Histogram size " << histogramSize << std::endl; for (unsigned int bin = 0; bin < histogramSize; bin++) { if (histogram->GetFrequency(bin, 0) != NbOfPointsPerHistogram) { std::cout << "Error in histogram value !" << std::endl; return EXIT_FAILURE; } std::cout << "bin = " << bin << " frequency = "; std::cout << histogram->GetFrequency(bin, 0) << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbPathListToHistogramGeneratorNew.cxx000066400000000000000000000022161301006202600303100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPolyLineParametricPath.h" #include "otbOrientationPathFunction.h" #include "otbPathListToHistogramGenerator.h" int otbPathListToHistogramGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::OrientationPathFunction FunctionType; typedef otb::PathListToHistogramGenerator GeneratorType; GeneratorType::Pointer histogram = GeneratorType::New(); std::cout << histogram << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbPathListToPathListFilterNew.cxx000066400000000000000000000020511301006202600273770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbPathListToPathListFilter.h" #include "itkPolyLineParametricPath.h" int otbPathListToPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef itk::PolyLineParametricPath PathType; typedef otb::PathListToPathListFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbPathTestDriver.cxx000066400000000000000000000024471301006202600247740ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbCompacityPathRectangle); REGISTER_TEST(otbVectorizationPathListFilterNew); REGISTER_TEST(otbRegionImageToRectangularPathListFilterNew); REGISTER_TEST(otbImageToEdgePathFilter); REGISTER_TEST(otbCompacityPathCircle); REGISTER_TEST(otbDrawPathListFilterWithValue); REGISTER_TEST(otbImageFittingPolygonListFilterNew); REGISTER_TEST(otbDrawPathDessinCarre); REGISTER_TEST(otbCompacityPathSquare); REGISTER_TEST(otbPathLengthFunctor); REGISTER_TEST(otbPathListToHistogramGenerator); REGISTER_TEST(otbImageFittingPolygonListFilter); REGISTER_TEST(otbImageToPathFilterNew); REGISTER_TEST(otbImageToEdgePathFilterNew); REGISTER_TEST(otbDrawPathListFilter); REGISTER_TEST(otbDrawPathListFilterNew); REGISTER_TEST(otbDrawPathFilter); REGISTER_TEST(otbOrientationPath); REGISTER_TEST(otbOrientationPathNew); REGISTER_TEST(otbDrawPathFilterNew); REGISTER_TEST(otbPolyLineImageConstIterator); REGISTER_TEST(otbRegionImageToRectangularPathListFilter); REGISTER_TEST(otbVectorizationPathListFilter); REGISTER_TEST(otbPathListToPathListFilterNew); REGISTER_TEST(otbPathListToHistogramGeneratorNew); REGISTER_TEST(otbCompacityPathNew); REGISTER_TEST(otbClosePathFunctor); REGISTER_TEST(otbPolyLineImageIterator); } OTB-release-5.8/Modules/Filtering/Path/test/otbPolyLineImageConstIterator.cxx000066400000000000000000000051521301006202600272770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPolyLineImageIterator.h" #include "itkPolyLineParametricPath.h" #include "otbImage.h" #include int otbPolyLineImageConstIterator(int argc, char * argv[]) { if (argc != 5) { std::cout << "Usgage: " << argv[0] << " sizex sizey nbpoints outfname" << std::endl; return EXIT_SUCCESS; } const unsigned int sizex = atoi(argv[1]); const unsigned int sizey = atoi(argv[2]); const unsigned int nbpoints = atoi(argv[3]); const char * outfname = argv[4]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef PathType::VertexType VertexType; typedef otb::PolyLineImageConstIterator ConstIteratorType; ImageType::SizeType size; size[0] = sizex; size[1] = sizey; ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->Allocate(); image->FillBuffer(255); PathType::Pointer path = PathType::New(); for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = 0; vertex1[1] = i * sizey / nbpoints; vertex2[0] = i * sizex / nbpoints; vertex2[1] = 0; path->AddVertex(vertex1); path->AddVertex(vertex2); } for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = i * sizex / nbpoints; vertex1[1] = sizey - 1; vertex2[0] = sizex - 1; vertex2[1] = i * sizey / nbpoints; path->AddVertex(vertex1); path->AddVertex(vertex2); } image->Update(); ConstIteratorType cit((const ImageType*) image, (const PathType*) path); std::ofstream flux(outfname); for (cit.GoToBegin(); !cit.IsAtEnd(); ++cit) { flux << cit.GetIndex() << std::endl; } flux.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbPolyLineImageIterator.cxx000066400000000000000000000053201301006202600262650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPolyLineImageIterator.h" #include "itkPolyLineParametricPath.h" #include "otbImage.h" #include "otbImageFileWriter.h" int otbPolyLineImageIterator(int argc, char * argv[]) { if (argc != 5) { std::cout << "Usgage: " << argv[0] << " sizex sizey nbpoints outfname" << std::endl; return EXIT_SUCCESS; } const unsigned int sizex = atoi(argv[1]); const unsigned int sizey = atoi(argv[2]); const unsigned int nbpoints = atoi(argv[3]); const char * outfname = argv[4]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef PathType::VertexType VertexType; typedef otb::PolyLineImageIterator IteratorType; typedef otb::ImageFileWriter WriterType; ImageType::SizeType size; size[0] = sizex; size[1] = sizey; ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); PathType::Pointer path = PathType::New(); for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = 0; vertex1[1] = i * sizey / nbpoints; vertex2[0] = i * sizex / nbpoints; vertex2[1] = 0; path->AddVertex(vertex1); path->AddVertex(vertex2); } for (unsigned int i = 1; i < nbpoints; ++i) { VertexType vertex1, vertex2; vertex1[0] = i * sizex / nbpoints; vertex1[1] = sizey - 1; vertex2[0] = sizex - 1; vertex2[1] = i * sizey / nbpoints; path->AddVertex(vertex1); path->AddVertex(vertex2); } IteratorType it(image, path); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { it.Set(255); // std::cout<SetInput(image); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbRegionImageToRectangularPathListFilter.cxx000066400000000000000000000046661301006202600315710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRegionImageToRectangularPathListFilter.h" #include "itkPolyLineParametricPath.h" #include "otbImageFileReader.h" #include #include int otbRegionImageToRectangularPathListFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned short InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->Update(); typedef otb::PolyLineParametricPathWithValue PathType; typedef otb::RegionImageToRectangularPathListFilter RectangleListFilterType; RectangleListFilterType::Pointer rectangleFilter = RectangleListFilterType::New(); rectangleFilter->SetInput(reader->GetOutput()); rectangleFilter->SetMinimumFit(::atof(argv[3])); rectangleFilter->SetMinimumSize(::atoi(argv[4])); rectangleFilter->Update(); typedef RectangleListFilterType::OutputPathListType ListType; ListType* pathList = rectangleFilter->GetOutput(); ListType::Iterator listIt = pathList->Begin(); FILE *file = fopen(outputFilename, "w"); if (file == ITK_NULLPTR) { fprintf(stderr, "Error, can't open file"); exit(-1); } while (listIt != pathList->End()) { for (PathType::VertexListType::ConstIterator vit = listIt.Get()->GetVertexList()->Begin(); vit != listIt.Get()->GetVertexList()->End(); ++vit) { double x = vit.Value()[0]; double y = vit.Value()[1]; fprintf(file, "%8.3f %8.3f\n", x, y); } double score = listIt.Get()->GetValue(); fprintf(file, "%8.3f\n", score); ++listIt; } fclose(file); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbRegionImageToRectangularPathListFilterNew.cxx000066400000000000000000000023321301006202600322270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRegionImageToRectangularPathListFilter.h" #include "itkPolyLineParametricPath.h" int otbRegionImageToRectangularPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned short InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::PolyLineParametricPathWithValue PathType; typedef otb::RegionImageToRectangularPathListFilter RectangleListFilterType; RectangleListFilterType::Pointer filter = RectangleListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbVectorizationPathListFilter.cxx000066400000000000000000000076021301006202600275410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorizationPathListFilter.h" #include "itkPolyLineParametricPath.h" #include "otbImageFileReader.h" #include #include "otbDrawPathListFilter.h" #include "otbImageFileWriter.h" int otbVectorizationPathListFilter(int itkNotUsed(argc), char * argv[]) { const char * modfname = argv[1]; const char * dirfname = argv[2]; const char * outfname = argv[3]; const char * outImagefname = argv[4]; const double thresh = atof(argv[5]); const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned char OutputPixelType; typedef otb::Image ImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileReader ReaderType; typedef itk::PolyLineParametricPath PathType; typedef otb::DrawPathListFilter DrawFilterType; typedef otb::VectorizationPathListFilter VectorizationPathListFilterType; typedef VectorizationPathListFilterType::OutputPathListType PathListType; typedef PathListType::ConstIterator PathListIteratorType; typedef PathType::VertexListType VertexListType; typedef VertexListType::ConstIterator VertexIteratorType; // Instantiating objects VectorizationPathListFilterType::Pointer filter = VectorizationPathListFilterType::New(); ReaderType::Pointer modReader = ReaderType::New(); ReaderType::Pointer dirReader = ReaderType::New(); modReader->SetFileName(modfname); dirReader->SetFileName(dirfname); filter->SetInput(modReader->GetOutput()); filter->SetInputDirection(dirReader->GetOutput()); filter->SetAmplitudeThreshold(thresh); filter->Update(); PathListType::Pointer pathList = filter->GetOutput(); PathListIteratorType pathListIt = pathList->Begin(); std::ofstream file; file.open(outfname); unsigned int counter = 0; while (pathListIt != pathList->End()) { file << "Path " << counter << ": "; for (VertexIteratorType vIt = pathListIt.Get()->GetVertexList()->Begin(); vIt != pathListIt.Get()->GetVertexList()->End(); ++vIt) { if (vIt != pathListIt.Get()->GetVertexList()->Begin()) { file << ", "; } file << vIt.Value(); } file << std::endl; ++pathListIt; ++counter; } file.close(); OutputImageType::Pointer output = OutputImageType::New(); output->SetRegions(modReader->GetOutput()->GetLargestPossibleRegion()); output->Allocate(); output->FillBuffer(255); DrawFilterType::Pointer drawer = DrawFilterType::New(); drawer->SetInput(output); drawer->SetInputPath(filter->GetOutput()); drawer->SetPathValue(0); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outImagefname); writer->SetInput(drawer->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Path/test/otbVectorizationPathListFilterNew.cxx000066400000000000000000000024701301006202600302110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorizationPathListFilter.h" #include "itkPolyLineParametricPath.h" int otbVectorizationPathListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef itk::PolyLineParametricPath PathType; typedef otb::VectorizationPathListFilter VectorizationPathListFilterType; // Instantiating object VectorizationPathListFilterType::Pointer filter = VectorizationPathListFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/000077500000000000000000000000001301006202600212605ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/CMakeLists.txt000066400000000000000000000001301301006202600240120ustar00rootroot00000000000000project(OTBPolarimetry) set(OTBPolarimetry_LIBRARIES OTBPolarimetry) otb_module_impl() OTB-release-5.8/Modules/Filtering/Polarimetry/include/000077500000000000000000000000001301006202600227035ustar00rootroot00000000000000otbMuellerToPolarisationDegreeAndPowerImageFilter.h000066400000000000000000000166431301006202600346760ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMuellerToPolarisationDegreeAndPowerImageFilter_h #define otbMuellerToPolarisationDegreeAndPowerImageFilter_h #include "otbUnaryFunctorImageFilter.h" #include "itkNumericTraits.h" #include "itkMatrix.h" #include "itkVector.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class MuellerToPolarisationDegreeAndPowerFunctor * \brief Evaluate the min and max polarisation degree and min and max power * from the Mueller image * * The order of the channels of the input image corresponds to : * \f$ \begin{pmatrix} * {channel #0 }&{channel #1 }&{channel #2 }&{channel #3 } \\ * {channel #4 }&{channel #5 }&{channel #6 }&{channel #7 } \\ * {channel #8 }&{channel #9 }&{channel #10}&{channel #11} \\ * {channel #12}&{channel #13}&{channel #14}&{channel #15} \\ * \end{pmatrix} \f$ * * The class process step by step while \f$ \tau <= 45 \f$ and for each \f$ \tau \f$, while \f$ \psi <= 90 \f$ : * 1. Define the incident Stokes vector: * - \f$ Si_{0} = 1 \f$ * - \f$ Si_{1} = \cos{\psi * \frac{\pi}{90}} * \cos{\tau * \frac{\pi}{90}} \f$ * - \f$ Si_{2} = \sin{\psi * \frac{\pi}{90}} * \cos{\tau * \frac{\pi}{90}} \f$ * - \f$ Si_{3} = \sin{\tau * \frac{\pi}{90}} \f$ * * 2. Evaluate the received Stokes vector : * - \f$ Sr = Si * MuellerMatrix \f$ * * 3. Evaluate power \f$ P \f$ and polarisation degree \f$ DegP \f$: * - \f$ P = \max{0, Sr_0} \f$ * - \f$ DegP = \sqrt{Sr_{1}^{2} + Sr_{2}^{2} + Sr_{3}^{2}} / Sr_{0} \f$ * * 4. Keep the smallest and the biggest power (\f$ P_{min}, P_{max} \f$) and polarisation degree (\f$ DegP_{min}, DegP_{max} \f$) ). * * Output value are: * - channel #0 : \f$ P_{min} \f$ * - channel #1 : \f$ P_{max} \f$ * - channel #2 : \f$ DegP_{min} \f$ * - channel #3 : \f$ DegP_{max} \f$ * * \ingroup Functor * \ingroup SARPolarimetry * * \sa MuellerToCircularPolarisationImageFilter * \sa MuellerToReciprocalCovarianceFunctor * * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class MuellerToPolarisationDegreeAndPowerFunctor { public: typedef typename TOutput::ValueType OutputValueType; typedef itk::Matrix MuellerMatrixType; typedef itk::Vector StokesVectorType; inline TOutput operator()( const TInput & Mueller ) const { double P; double deg_pol; double tau; double psi; StokesVectorType Si; StokesVectorType Sr; double l_PowerMin(itk::NumericTraits::max()); double l_PowerMax(itk::NumericTraits::min()); double l_PolarisationDegreeMin(itk::NumericTraits::max()); double l_PolarisationDegreeMax(itk::NumericTraits::min()); TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); MuellerMatrixType muellerMatrix; muellerMatrix[0][0] = Mueller[0]; muellerMatrix[0][1] = Mueller[1]; muellerMatrix[0][2] = Mueller[2]; muellerMatrix[0][3] = Mueller[3]; muellerMatrix[1][0] = Mueller[4]; muellerMatrix[1][1] = Mueller[5]; muellerMatrix[1][2] = Mueller[6]; muellerMatrix[1][3] = Mueller[7]; muellerMatrix[2][0] = Mueller[8]; muellerMatrix[2][1] = Mueller[9]; muellerMatrix[2][2] = Mueller[10]; muellerMatrix[2][3] = Mueller[11]; muellerMatrix[3][0] = Mueller[12]; muellerMatrix[3][1] = Mueller[13]; muellerMatrix[3][2] = Mueller[14]; muellerMatrix[3][3] = Mueller[15]; tau = -45.0; while (tau < 46.0) { psi = -90.0; while (psi < 91.0) { // Define the incident Stokes vector Si[0] = 1.0; Si[1] = cos(psi * m_PI_90) * cos(tau * m_PI_90); Si[2] = sin(psi * m_PI_90) * cos(tau * m_PI_90); Si[3] = sin(tau * m_PI_90); // Evaluate the received Stokes vector Sr = muellerMatrix * Si; //Evaluate Power and Polarisation degree P = Sr[0]; if (P < m_Epsilon) { deg_pol = 0.; } else { deg_pol = vcl_sqrt(Sr[1] * Sr[1] + Sr[2] * Sr[2] + Sr[3] * Sr[3]) / Sr[0]; } if (P > l_PowerMax) { l_PowerMax = P; } else { l_PowerMin = P; } if (deg_pol > l_PolarisationDegreeMax) { l_PolarisationDegreeMax = deg_pol; } else { l_PolarisationDegreeMin = deg_pol; } psi += 5.0; } tau += 5.0; } result[0] = l_PowerMin; result[1] = l_PowerMax; result[2] = l_PolarisationDegreeMin; result[3] = l_PolarisationDegreeMax; return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ MuellerToPolarisationDegreeAndPowerFunctor() : m_NumberOfComponentsPerPixel(4), m_Epsilon(1e-6), m_PI_90(2*CONST_PI_180) {} /** Destructor */ virtual ~MuellerToPolarisationDegreeAndPowerFunctor() {} private: unsigned int m_NumberOfComponentsPerPixel; const double m_Epsilon; const double m_PI_90; }; } /** \class otbMuellerToPolarisationDegreeAndPowerImageFilter * \brief Compute the polarization degree and power (4 channels : Power min and max, Polarization degree min and max) * from the Mueller image (16 real channels) * For more details, please refer to the class MuellerToPolarisationDegreeAndPowerFunctor. * * \ingroup SARPolarimetry * \sa MuellerToPolarisationDegreeAndPowerFunctor * * * \ingroup OTBPolarimetry */ template class ITK_EXPORT MuellerToPolarisationDegreeAndPowerImageFilter : public UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef MuellerToPolarisationDegreeAndPowerImageFilter Self; typedef typename Functor::MuellerToPolarisationDegreeAndPowerFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(MuellerToPolarisationDegreeAndPowerImageFilter, UnaryFunctorImageFilter); protected: MuellerToPolarisationDegreeAndPowerImageFilter() {} ~MuellerToPolarisationDegreeAndPowerImageFilter() ITK_OVERRIDE {} private: MuellerToPolarisationDegreeAndPowerImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbMuellerToReciprocalCovarianceImageFilter.h000066400000000000000000000130461301006202600336050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMuellerToReciprocalCovarianceImageFilter_h #define otbMuellerToReciprocalCovarianceImageFilter_h #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class MuellerToReciprocalCovarianceFunctor * \brief Evaluate the MLC image from the Mueller image * * Output value are: * - channel #0 : \f$ 0.5*(M_{11} + M_{22} + 2*M_{12}) \f$ * - channel #1 : \f$ 0.5*(M_{11} - M_{22}) \f$ * - channel #2 : \f$ 0.5*(M_{11} + M_{22} - 2*M_{12}) \f$ * - channel #3 : \f$ 0.5*(M_{13} + M_{23} + i*(M_{14}+M_{24})) \f$ * - channel #4 : \f$ 0.5*(M_{33} - M_{44} - 2*i*M_{34}) \f$ * - channel #5 : \f$ 0.5*(M_{13} - M_{23} - i*(M_{14}-M_{24})) \f$ * * Where \f$M_{ij}\f$ are the coefficients of the input Mueller matrix. * * Input pixel must have 10 channels (one for each Mueller matrix coeffcients). * The order of the channels corresponds to : * \f$ \begin{pmatrix} * {channel #0 }&{channel #1 }&{channel #2 }&{channel #3 } \\ * {channel #4 }&{channel #5 }&{channel #6 }&{channel #7 } \\ * {channel #8 }&{channel #9 }&{channel #10}&{channel #11} \\ * {channel #12}&{channel #13}&{channel #14}&{channel #15} \\ * \end{pmatrix} \f$ * * The output image has 6 channels : the diagonal and the upper element of the reciprocal matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa MuellerToCircularPolarisationImageFilter * \sa MuellerToPolarisationDegreeAndPowerImageFilter * * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class MuellerToReciprocalCovarianceFunctor { public: typedef std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Mueller ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); // Keep the upper diagonal of the matrix const double M11 = static_cast(Mueller[0]); const double M12 = static_cast(Mueller[1]); const double M13 = static_cast(Mueller[2]); const double M14 = static_cast(Mueller[3]); const double M22 = static_cast(Mueller[5]); const double M23 = static_cast(Mueller[6]); const double M24 = static_cast(Mueller[7]); const double M33 = static_cast(Mueller[10]); const double M34 = static_cast(Mueller[11]); const double M44 = static_cast(Mueller[15]); const ComplexType A(0.5*(M11+M22+2*M12)); const ComplexType B(0.5*vcl_sqrt(2.0)*(M13+M23), 0.5*vcl_sqrt(2.0)*(M14+M24)); const ComplexType C(-0.5*(M33+M44), -M34); const ComplexType E(M11-M22, 0.0); const ComplexType F(0.5*vcl_sqrt(2.0)*(M13-M23), 0.5*vcl_sqrt(2.0)*(M14-M24)); const ComplexType I(0.5*(M11+M22-2*M12)); result[0] = static_cast( A ); result[1] = static_cast( B ); result[2] = static_cast( C ); result[3] = static_cast( E ); result[4] = static_cast( F ); result[5] = static_cast( I ); return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ MuellerToReciprocalCovarianceFunctor() : m_NumberOfComponentsPerPixel(6) {} /** Destructor */ virtual ~MuellerToReciprocalCovarianceFunctor() {} private: unsigned int m_NumberOfComponentsPerPixel; }; } /** \class otbMuellerToReciprocalCovarianceImageFilter * \brief Compute the MLC image * from the Mueller image (16 real channels) * For more details, lease refer to the class MuellerToReciprocalCovarianceFunctor. * * \ingroup SARPolarimetry * \sa MuellerToReciprocalCovarianceFunctor * * * \ingroup OTBPolarimetry */ template class ITK_EXPORT MuellerToReciprocalCovarianceImageFilter : public UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef MuellerToReciprocalCovarianceImageFilter Self; typedef Functor::MuellerToReciprocalCovarianceFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(MuellerToReciprocalCovarianceImageFilter, UnaryFunctorImageFilter); protected: MuellerToReciprocalCovarianceImageFilter() {} ~MuellerToReciprocalCovarianceImageFilter() ITK_OVERRIDE {} private: MuellerToReciprocalCovarianceImageFilter(const Self&); // purposely not implemented void operator=(const Self&); // purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbMultiChannelsPolarimetricSynthesisFilter.h000066400000000000000000000171731301006202600337730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelsPolarimetricSynthesisFilter_h #define otbMultiChannelsPolarimetricSynthesisFilter_h #include "itkInPlaceImageFilter.h" #include "otbPolarimetricSynthesisFunctor.h" #include "otbPolarimetricData.h" #include namespace otb { /** \class MultiChannelsPolarimetricSynthesisFilter * \brief This class computes the polarimetric synthesis from two to four radar images, depening on the polarimetric architecture. * * It has the same behaviour as the PolarimetricSynthesisImageFilter expect the fact that it * considers a VectorImage as input which each channels is HH, HV, VH and VV (in this particular order). * * \ingroup SARPolarimetry * \sa PolarimetricSynthesisFilter * \sa PolarimetricSynthesisFunctor * * * \ingroup OTBPolarimetry */ template > class ITK_EXPORT MultiChannelsPolarimetricSynthesisFilter : public itk::InPlaceImageFilter { public: /** Standard class typedefs. */ typedef MultiChannelsPolarimetricSynthesisFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiChannelsPolarimetricSynthesisFilter, InPlaceImageFilter); /** Some typedefs. */ typedef std::complex InputPixelType; typedef TFunction FunctorType; typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename std::complex ComplexType; typedef typename itk::FixedArray ComplexArrayType; typedef typename itk::FixedArray IndexArrayType; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; } const FunctorType& GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { if (m_Functor != functor) { m_Functor = functor; this->Modified(); } } /** Set the Incident ElectroMagneticField */ void SetEi(ComplexArrayType ei) { m_Ei = ei; this->GetFunctor().SetEi(ei); this->Modified(); } /** Set the Reflected ElectroMagneticField */ void SetEr(ComplexArrayType er) { m_Er = er; this->GetFunctor().SetEr(er); this->Modified(); } /** Set/Get PsiI */ itkSetMacro(PsiI, double); itkGetMacro(PsiI, double); /** Set/Get KhiI */ itkSetMacro(KhiI, double); itkGetMacro(KhiI, double); /** Set/Get PsiR */ itkSetMacro(PsiR, double); itkGetMacro(PsiR, double); /** Set/Get KhiR */ itkSetMacro(KhiR, double); itkGetMacro(KhiR, double); /** Set/Get EmissionH */ itkSetMacro(EmissionH, bool); itkGetMacro(EmissionH, bool); /** Set/Get EmissionV */ itkSetMacro(EmissionV, bool); itkGetMacro(EmissionV, bool); /** Set/Get Mode */ itkSetMacro(Mode, int); itkGetMacro(Mode, int); /** Set the gain */ itkSetMacro(Gain, double); itkGetMacro(Gain, double); /** Force the copolar mode */ void ForceCoPolar(); /** Force the crosspolar mode */ void ForceCrossPolar(); protected: /** Constructor */ MultiChannelsPolarimetricSynthesisFilter(); /** Destructor */ ~MultiChannelsPolarimetricSynthesisFilter() ITK_OVERRIDE {} /** MultiChannelsPolarimetricSynthesisFilter can produce an image * which is a synthesis of channels HH, HV, VH and VV. * * As such, MultiChannelsPolarimetricSynthesisFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** MultiChannelsPolarimetricSynthesisFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Computation of the electromagnetic fields Ei Er */ void ComputeElectromagneticFields(); /** Verify and force the inputs, if only 2 or 3 channels are present */ void VerifyAndForceInputs(); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: MultiChannelsPolarimetricSynthesisFilter(const Self &); //purposely not implemented /** Psi Incident */ double m_PsiI; /** Khi Incident */ double m_KhiI; /** Psi Reflected */ double m_PsiR; /** Khi Reflected */ double m_KhiR; /** Gain */ double m_Gain; /** None = 0 , copolar = 1 , crosspolar = 2 */ int m_Mode; /** Champs Electromagnetic Incident */ ComplexArrayType m_Ei; /** Champs Electromagnetic Reflechi */ ComplexArrayType m_Er; /** Architecture Type */ PolarimetricData::Pointer m_ArchitectureType; FunctorType m_Functor; /** Emission mode */ bool m_EmissionH; bool m_EmissionV; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMultiChannelsPolarimetricSynthesisFilter.txx" #endif #endif otbMultiChannelsPolarimetricSynthesisFilter.txx000066400000000000000000000263431301006202600343070ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelsPolarimetricSynthesisFilter_txx #define otbMultiChannelsPolarimetricSynthesisFilter_txx #include #include "otbMultiChannelsPolarimetricSynthesisFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template MultiChannelsPolarimetricSynthesisFilter ::MultiChannelsPolarimetricSynthesisFilter() { this->SetNumberOfRequiredInputs(1); this->InPlaceOff(); SetEmissionH(false); SetEmissionV(false); SetGain(1); SetMode(0); m_ArchitectureType = PolarimetricData::New(); } /** * GenerateOutputInformation() */ template void MultiChannelsPolarimetricSynthesisFilter ::GenerateOutputInformation() { // do not call the superclass' implementation of this method since // this filter allows the input the output to be of different dimensions // get pointers to the input and output typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); if (!outputPtr || !inputPtr) { return; } // Set the output image largest possible region. Use a RegionCopier // so that the input and output images can be different dimensions. OutputImageRegionType outputLargestPossibleRegion; this->CallCopyInputRegionToOutputRegion(outputLargestPossibleRegion, inputPtr->GetLargestPossibleRegion()); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); // Set the output spacing and origin const itk::ImageBase *phyData; phyData = dynamic_cast*>(this->GetInput()); if (phyData) { // Copy what we can from the image from spacing and origin of the input // This logic needs to be augmented with logic that select which // dimensions to copy unsigned int i, j; const typename InputImageType::SpacingType& inputSpacing = inputPtr->GetSpacing(); const typename InputImageType::PointType& inputOrigin = inputPtr->GetOrigin(); const typename InputImageType::DirectionType& inputDirection = inputPtr->GetDirection(); typename OutputImageType::SpacingType outputSpacing; typename OutputImageType::PointType outputOrigin; typename OutputImageType::DirectionType outputDirection; // copy the input to the output and fill the rest of the // output with zeros. for (i = 0; i < Superclass::InputImageDimension; ++i) { outputSpacing[i] = inputSpacing[i]; outputOrigin[i] = inputOrigin[i]; for (j = 0; j < Superclass::OutputImageDimension; ++j) { if (j < Superclass::InputImageDimension) { outputDirection[j][i] = inputDirection[j][i]; } else { outputDirection[j][i] = 0.0; } } } for (; i < Superclass::OutputImageDimension; ++i) { outputSpacing[i] = 1.0; outputOrigin[i] = 0.0; for (j = 0; j < Superclass::OutputImageDimension; ++j) { if (j == i) { outputDirection[j][i] = 1.0; } else { outputDirection[j][i] = 0.0; } } } // set the spacing and origin outputPtr->SetSpacing(outputSpacing); outputPtr->SetOrigin(outputOrigin); outputPtr->SetDirection(outputDirection); } else { // pointer could not be cast back down itkExceptionMacro(<< "otb::MultiChannelsPolarimetricSynthesisFilter::GenerateOutputInformation " << "cannot cast input to " << typeid(itk::ImageBase*).name()); } } /** * ThreadedGenerateData Performs the pixel-wise addition */ template void MultiChannelsPolarimetricSynthesisFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImagePointer inputPtr = this->GetInput(); OutputImagePointer outputPtr = this->GetOutput(0); // Define the portion of the input to walk for this thread, using // the CallCopyOutputRegionToInputRegion method allows for the input // and output images to be different dimensions InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, inputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); ArchitectureType val = m_ArchitectureType->GetArchitectureType(); // Computation with 4 channels switch (val) { case HH_HV_VH_VV: while (!inputIt.IsAtEnd()) { outputIt.Set(m_Gain * GetFunctor() (inputIt.Get()[0], inputIt.Get()[1], inputIt.Get()[2], inputIt.Get()[3])); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } break; // With 3 channels : HH HV VV ou HH VH VV case HH_HV_VV: while (!inputIt.IsAtEnd()) { outputIt.Set(m_Gain * GetFunctor() (inputIt.Get()[0], inputIt.Get()[1], inputIt.Get()[1], inputIt.Get()[2])); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } break; // Only HH and HV are present case HH_HV: while (!inputIt.IsAtEnd()) { outputIt.Set(m_Gain * GetFunctor() (inputIt.Get()[0], inputIt.Get()[1], 0, 0)); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } break; // Only VH and VV are present case VH_VV: while (!inputIt.IsAtEnd()) { outputIt.Set(m_Gain * GetFunctor() (0, 0, inputIt.Get()[2], inputIt.Get()[3])); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } break; default: itkExceptionMacro("Unknown architecture : Polarimetric synthesis is impossible !"); return; } } /** * Computation of the electromagnetic fields Ei Er */ template void MultiChannelsPolarimetricSynthesisFilter ::ComputeElectromagneticFields() { ComplexArrayType AEi, AEr; /** Conversion coefficient Degre To Radian */ double DTOR = CONST_PI_180; double real, imag; real = vcl_cos(DTOR * m_PsiI) * vcl_cos(DTOR * m_KhiI); imag = -vcl_sin(DTOR * m_PsiI) * vcl_sin(DTOR * m_KhiI); ComplexType Ei0(real, imag); real = vcl_sin(DTOR * m_PsiI) * vcl_cos(DTOR * m_KhiI); imag = vcl_cos(DTOR * m_PsiI) * vcl_sin(DTOR * m_KhiI); ComplexType Ei1(real, imag); real = vcl_cos(DTOR * m_PsiR) * vcl_cos(DTOR * m_KhiR); imag = -vcl_sin(DTOR * m_PsiR) * vcl_sin(DTOR * m_KhiR); ComplexType Er0(real, imag); real = vcl_sin(DTOR * m_PsiR) * vcl_cos(DTOR * m_KhiR); imag = vcl_cos(DTOR * m_PsiR) * vcl_sin(DTOR * m_KhiR); ComplexType Er1(real, imag); AEi[0] = Ei0; AEi[1] = Ei1; AEr[0] = Er0; AEr[1] = Er1; this->SetEi(AEi); this->SetEr(AEr); } /** * Verify and force the inputs, if only 2 or 3 channels are present */ template void MultiChannelsPolarimetricSynthesisFilter ::VerifyAndForceInputs() { ArchitectureType val = m_ArchitectureType->GetArchitectureType(); switch (val) { case HH_HV_VH_VV: break; case HH_HV_VV: break; case HH_VH_VV: break; // Only HH and HV are present case HH_HV: // Forcing KhiI=0 PsiI=0 this->SetKhiI(0); this->SetPsiI(0); break; // Only VH and VV are present case VH_VV: // Forcing KhiI=0 PsiI=90 this->SetKhiI(0); this->SetPsiI(90); break; default: itkExceptionMacro("Unknown architecture : Polarimetric synthesis is impossible !!"); return; } if (GetMode() == 1) ForceCoPolar(); else if (GetMode() == 2) ForceCrossPolar(); } /** * BeforeThreadedGenerateData */ template void MultiChannelsPolarimetricSynthesisFilter ::BeforeThreadedGenerateData() { int NumberOfImages = this->GetInput()->GetNumberOfComponentsPerPixel(); // First Part. Determine the kind of architecture of the input picture m_ArchitectureType->DetermineArchitecture(NumberOfImages, GetEmissionH(), GetEmissionV()); // Second Part. Verify and force the inputs VerifyAndForceInputs(); // Third Part. Estimation of the incident field Ei and the reflected field Er ComputeElectromagneticFields(); } /** * Force Copolar mode */ template void MultiChannelsPolarimetricSynthesisFilter ::ForceCoPolar() { SetPsiR(m_PsiI); SetKhiR(m_KhiI); } /** * Force Crosspolar mode */ template void MultiChannelsPolarimetricSynthesisFilter ::ForceCrossPolar() { SetPsiR(m_PsiI + 90); SetKhiR(-m_KhiI); SetMode(2); } /** * Printself */ template void MultiChannelsPolarimetricSynthesisFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "PsiI: " << m_PsiI << std::endl; os << indent << "KhiI: " << m_KhiI << std::endl; os << indent << "PsiR: " << m_PsiR << std::endl; os << indent << "KhiR: " << m_KhiR << std::endl; os << indent << "Ei0 im: " << m_Ei[0].imag() << std::endl; os << indent << "Ei0 re: " << m_Ei[0].real() << std::endl; os << indent << "Ei1 im: " << m_Ei[1].imag() << std::endl; os << indent << "Ei1 re: " << m_Ei[1].real() << std::endl; os << indent << "Er0 im: " << m_Er[0].imag() << std::endl; os << indent << "Er0 re: " << m_Er[0].real() << std::endl; os << indent << "Er1 im: " << m_Er[1].imag() << std::endl; os << indent << "Er1 re: " << m_Er[1].real() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbPolarimetricData.h000066400000000000000000000047321301006202600270130ustar00rootroot00000000000000/*======================================================================== Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolarimetricData_h #define otbPolarimetricData_h #include "itkDataObject.h" #include "itkObjectFactory.h" namespace otb { /** \enum ArchitectureType * \brief This enumeration describes the different architectures we can find in polarimetry. * HH_HV_VH_VV (0), HH_HV_VV (1), HH_VH_VV (2), HH_HV(3), VH_VV (4), HH_VV (5). */ typedef enum { HH_HV_VH_VV = 0, HH_HV_VV = 1, HH_VH_VV = 2, HH_HV = 3, VH_VV = 4, HH_VV = 5, UNKNOWN_ARCHITECTURE = 6 } ArchitectureType; /** \class PolarimetricData * \brief This class allows determining the type of architecture we get. * * HH_HV_VH_VV (0), HH_HV_VV (1), HH_VH_VV (2), HH_HV(3), VH_VV (4), HH_VV (5). * * \ingroup SARPolarimetry * * \ingroup OTBPolarimetry */ class ITK_EXPORT PolarimetricData : public itk::DataObject { public: /** Standard typedefs */ typedef PolarimetricData Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(PolarimetricData, DataObject); /** Creation through object factory macro */ itkNewMacro(Self); /** Determine the kind of architecture of the input */ void DetermineArchitecture(bool *PresentInputImages); void DetermineArchitecture(int NumberOfImages, bool EmissionH, bool EmissionV); /** Set/Get ArchitectureType */ itkSetMacro(ArchitectureType, ArchitectureType); itkGetMacro(ArchitectureType, ArchitectureType); protected: /** Constructor */ PolarimetricData(); /** Destructor */ ~PolarimetricData() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PolarimetricData(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Architecture Type */ ArchitectureType m_ArchitectureType; }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbPolarimetricSynthesisFunctor.h000066400000000000000000000047511301006202600314750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolarimetricSynthesisFunctor_h #define otbPolarimetricSynthesisFunctor_h #include "otbMath.h" #include "vcl_complex.h" #include "itkFixedArray.h" namespace otb { namespace Functor { /** \class PolarimetricSynthesisFunctor * \brief Calculate the polarimetric synthesis * * This functor calculate the polarimetric synthesis using the electroMagneticField vectors as follow: * \f$ \sigma(\psi_{i},\chi_{i},\psi_{r},\chi_{r}) = \vec(E_{r})\cdot\left[ S \right] \vec(E_{i}) \f$ * * \ingroup Functor * \ingroup SARPolarimetry * * * \ingroup OTBPolarimetry */ template class PolarimetricSynthesisFunctor { public: /** Some typedefs. */ typedef typename std::complex ComplexType; typedef typename itk::FixedArray ComplexArrayType; /** Set the ElectroMagneticField Incident */ void SetEi(ComplexArrayType ei) { m_Ei = ei; } /** Set the ElectroMagneticField Reflected */ void SetEr(ComplexArrayType er) { m_Er = er; } /** Constructor */ PolarimetricSynthesisFunctor() { m_Ei.Fill(1); m_Er.Fill(1); } /** Destructor */ virtual ~PolarimetricSynthesisFunctor() {} inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svh, const TInput4& Svv) { ComplexType tmp; double scalar; tmp = vcl_conj(m_Er[0]) * (m_Ei[0] * static_cast(Shh) + m_Ei[1] * static_cast(Shv)) + vcl_conj(m_Er[1]) * (m_Ei[0] * static_cast(Svh) + m_Ei[1] * static_cast(Svv)); scalar = static_cast(vcl_abs(tmp)) * static_cast(vcl_abs(tmp)); return (static_cast(scalar)); } private: /** Electromagnetic Field Incident */ ComplexArrayType m_Ei; /** Electromagnetic Field Reflected */ ComplexArrayType m_Er; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbReciprocalBarnesDecompImageFilter.h000066400000000000000000000117341301006202600322460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalBarnesDecompImageFilter_h #define otbReciprocalBarnesDecompImageFilter_h #include "otbUnaryFunctorImageFilter.h" #include "otbMath.h" #include "vnl/algo/vnl_complex_eigensystem.h" #include namespace otb { namespace Functor { /** \class otbBarnesDecompFunctor * * \brief Evaluate the Huynen decomposition from the reciprocal Sinclair matrix image. * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalBarnesDecompFunctor { public: typedef typename std::complex ComplexType; typedef vnl_matrix VNLMatrixType; typedef vnl_vector VNLVectorType; typedef vnl_vector VNLDoubleVectorType; typedef std::vector VectorType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Covariance ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); VNLMatrixType qi(3,1); VNLMatrixType cov(3, 3); cov[0][0] = ComplexType(Covariance[0]); cov[0][1] = ComplexType(Covariance[1]); cov[0][2] = ComplexType(Covariance[2]); cov[1][0] = std::conj(ComplexType(Covariance[1])); cov[1][1] = ComplexType(Covariance[3]); cov[1][2] = ComplexType(Covariance[4]); cov[2][0] = std::conj(ComplexType(Covariance[2])); cov[2][1] = std::conj(ComplexType(Covariance[4])); cov[2][2] = ComplexType(Covariance[5]); qi[0][0]=ComplexType(1.,0.); qi[1][0]=ComplexType(0.,0.); qi[2][0]=ComplexType(0.,0.); ComplexType norm = (qi.conjugate_transpose()*cov*qi)[0][0]; VNLMatrixType ki = cov*qi / std::sqrt(norm); result[0] = static_cast(ki[0][0]); result[1] = static_cast(ki[1][0]); result[2] = static_cast(ki[2][0]); qi[0][0]=ComplexType(0.,0.); qi[1][0]=ComplexType(1./std::sqrt(2.),0.); qi[2][0]=ComplexType(0.,1./std::sqrt(2.)); norm = (qi.conjugate_transpose()*cov*qi)[0][0]; ki = cov*qi / std::sqrt(norm); result[3] = static_cast(ki[0][0]); result[4] = static_cast(ki[1][0]); result[5] = static_cast(ki[2][0]); qi[0][0]=ComplexType(0.,0.); qi[1][0]=ComplexType(0.,1./std::sqrt(2.)); qi[2][0]=ComplexType(1./std::sqrt(2.),0.); norm = (qi.conjugate_transpose()*cov*qi)[0][0]; ki = cov*qi / std::sqrt(norm); result[6] = static_cast(ki[0][0]); result[7] = static_cast(ki[1][0]); result[8] = static_cast(ki[2][0]); return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalBarnesDecompFunctor() : m_Epsilon(1e-6) {} /** Destructor */ virtual ~ReciprocalBarnesDecompFunctor() {} private: itkStaticConstMacro(m_NumberOfComponentsPerPixel, unsigned int, 9); const double m_Epsilon; }; } /** \class otbBarnesDecompImageFilter * \brief Compute the Barnes decomposition image (9 complex channels) * from the Reciprocal Covariance image (6 complex channels) * * For more details, please refer to the class ReciprocalBarnesDecompFunctor. * * \ingroup OTBPolarimetry * \sa ReciprocalBarnesDecompFunctor */ template class ITK_EXPORT ReciprocalBarnesDecompImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalBarnesDecompImageFilter Self; typedef typename Functor::ReciprocalBarnesDecompFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef otb::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalBarnesDecompImageFilter, UnaryFunctorImageFilter); protected: ReciprocalBarnesDecompImageFilter() {} ~ReciprocalBarnesDecompImageFilter() ITK_OVERRIDE {} private: ReciprocalBarnesDecompImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif otbReciprocalCoherencyToReciprocalMuellerImageFilter.h000066400000000000000000000142311301006202600353740ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalCoherencyToReciprocalMuellerImageFilter_h #define otbReciprocalCoherencyToReciprocalMuellerImageFilter_h #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class CoherencyToReciprocalMuellerFunctor * \brief Evaluate the reciprocal Mueller matrix from the reciprocal coherency matrix image * * Outpus are: * - channel #0 : \f$ 0.5*( C_{11}+C_{22}+C_{33} ) \f$ * - channel #1 : \f$ Re(C_{12}) + Im(C_{22}) \f$ * - channel #2 : \f$ Re(C_{13}) \f$ * - channel #3 : \f$ Im(C_{23}) \f$ * - channel #4 : \f$ Re(C_{12}) \f$ * - channel #5 : \f$ 0.5*( C_{11}+C_{22}-C_{33} ) \f$ * - channel #6 : \f$ Re(C_{23}) \f$ * - channel #7 : \f$ Im(C_{13}) \f$ * - channel #8 : \f$ -Re(C_{13}) \f$ * - channel #9 : \f$ -Re(C_{23}) \f$ * - channel #10 : \f$ 0.5.Re(VAL1) \f$ * - channel #11 : \f$ 0.5.Im(VAL0) \f$ * - channel #12 : \f$ Im(C_{23}) \f$ * - channel #13 : \f$ Im(C_{13}) \f$ * - channel #14 : \f$ 0.5.Im(VAL1^{*}) \f$ * - channel #15 : \f$ 0.5.Re(VAL0) \f$ * * With: * VAL0 = C_{33}+C_{12}-C_{11}-(C_{12}-C_{22})^{*} * VAL1 = -C_{33}+C_{12}-C_{11}-(C_{12}-C_{22})^{*} * * Where Coherency is the input pixel and contains: * - channel #0 : \f$ 0.5*(S_{hh}+S_{vv}).(S_{hh}+S_{vv})^{*} \f$ * - channel #1 : \f$ 0.5*(S_{hh}+S_{vv}).(S_{hh}-S_{vv})^{*} \f$ * - channel #2 : \f$ 0.5*(S_{hh}+S_{vv}).(2*S_{hv})^{*} \f$ * - channel #3 : \f$ 0.5*(S_{hh}-S_{vv}).(S_{hh}-S_{vv})^{*} \f$ * - channel #4 : \f$ 0.5*(S_{hh}-S_{vv}).(2*S_{hv})^{*} \f$ * - channel #5 : \f$ 0.5*(2*S_{hv}).(2*S_{hv})^{*} \f$ * * The output pixel has 16 channels * Element are stored from left to right, line by line. * * \ingroup SARPolarimetry * * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalCoherencyToReciprocalMuellerFunctor { public: typedef typename std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Coherency ) const { TOutput result; result.SetSize(NumberOfComponentsPerPixel); const double T1 = static_cast(Coherency[0].real()); const double T2 = static_cast(Coherency[3].real()); const double T3 = static_cast(Coherency[5].real()); ComplexType VAL4 = static_cast( (Coherency[1] - Coherency[3]) ); ComplexType VAL5 = static_cast( (Coherency[1] - Coherency[0]) ); ComplexType VAL0 = static_cast( Coherency[5] ) + VAL5 - vcl_conj(VAL4); ComplexType VAL1 = static_cast( -Coherency[5] ) + VAL5 - vcl_conj(VAL4); result[0] = 0.5*(T1+T2+T3); result[1] = static_cast( Coherency[1].real()+Coherency[3].imag() ); result[2] = static_cast( Coherency[2].real() ); result[3] = static_cast( Coherency[4].imag() ); result[4] = static_cast( Coherency[1].real() ); result[5] = 0.5*(T1+T2-T3); result[6] = static_cast( Coherency[4].real() ); result[7] = static_cast( Coherency[2].imag() ); result[8] = static_cast( -Coherency[2].real() ); result[9] = static_cast( -Coherency[4].real() ); result[10] = static_cast( 0.5*VAL1.real() ); result[11] = static_cast( 0.5*VAL0.imag() ); result[12] = static_cast( Coherency[4].imag() ); result[13] = static_cast( Coherency[2].imag() ); result[14] = static_cast( 0.5*vcl_conj(VAL1).imag() ); result[15] = static_cast( 0.5*VAL0.real() ); return result; } unsigned int GetOutputSize() { return NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalCoherencyToReciprocalMuellerFunctor() {} /** Destructor */ virtual ~ReciprocalCoherencyToReciprocalMuellerFunctor() {} private: itkStaticConstMacro(NumberOfComponentsPerPixel, unsigned int, 16); }; } /** \class otbReciprocalCoherencyToReciprocalMuellerImageFilter * \brief Compute the reciprocal Mueller matrix image (10 real channels) * from the Reciprocal coherency image (6 complex channels) * * For more datails, please refer to ReciprocalCoherencyToReciprocalMuellerFunctor. * * \ingroup SARPolarimetry * \sa ReciprocalCoherencyToReciprocalMuellerFunctor * * * \ingroup OTBPolarimetry */ template class ITK_EXPORT ReciprocalCoherencyToReciprocalMuellerImageFilter : public UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalCoherencyToReciprocalMuellerImageFilter Self; typedef typename Functor::ReciprocalCoherencyToReciprocalMuellerFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalCoherencyToReciprocalMuellerImageFilter, UnaryFunctorImageFilter); protected: ReciprocalCoherencyToReciprocalMuellerImageFilter() {} ~ReciprocalCoherencyToReciprocalMuellerImageFilter() ITK_OVERRIDE {} private: ReciprocalCoherencyToReciprocalMuellerImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif otbReciprocalCovarianceToCoherencyDegreeImageFilter.h000066400000000000000000000121021301006202600351440ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalCovarianceToCoherencyDegreeImageFilter_h #define otbReciprocalCovarianceToCoherencyDegreeImageFilter_h #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class ReciprocalCovarianceToCoherencyDegreeFunctor * \brief Evaluate the Coherency Degree coefficient from from the MLC image * * Output value are: * - channel #0 : \f$ abs(S_{hh}*S_{vv}}^{*}) / sqrt(S_{hh}*S_{hh}}^{*}) / sqrt(S_{vv}*S_{vv}}^{*}) \f$ * - channel #1 : \f$ abs(S_{hv}*S_{vv}}^{*}) / sqrt(S_{hv}*S_{hv}}^{*}) / sqrt(S_{vv}*S_{vv}}^{*}) \f$ * - channel #2 : \f$ abs(S_{hh}*S_{hv}}^{*}) / sqrt(S_{hh}*S_{hh}}^{*}) / sqrt(S_{hv}*S_{hv}}^{*}) \f$ * * * \ingroup Functor * \ingroup SARPolarimetry * * \sa MLCToCircularCoherencyDegreeImageFilter * \sa ReciprocalCovarianceToCoherencyImageFilter * * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalCovarianceToCoherencyDegreeFunctor { public: typedef double RealType; typedef typename std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Covariance ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); result.Fill(0.0); /* Using the convention * \f$ C_{11} = S_{hh}*S_{hh}^* \f$ * \f$ C_{12} = S_{hh}*S_{hv}^* \f$ * \f$ C_{13} = S_{hh}*S_{vv}^* \f$ * \f$ C_{22} = S_{hv}*S_{hv}^* \f$ * \f$ C_{23} = S_{hv}*S_{vv}^* \f$ * \f$ C_{33} = S_{vv}*S_{vv}^* \f$ */ const RealType C11 = static_cast(Covariance[0].real()); const ComplexType C12 = static_cast(Covariance[1]); const ComplexType C13 = static_cast(Covariance[2]); const RealType C22 = static_cast(Covariance[3].real()); const ComplexType C23 = static_cast(Covariance[4]); const RealType C33 = static_cast(Covariance[5].real()); if ((C11 >m_Epsilon) && (C33 > m_Epsilon)) { result[0] = vcl_abs(C13) / vcl_sqrt(C11 * C33); // |) } if ((C22 > m_Epsilon) && (C33 > m_Epsilon)) { result[1] = vcl_abs(C23) / vcl_sqrt(C22 * C33); // |) } if ((C11 > m_Epsilon) && (C22 > m_Epsilon) ) { result[2] = vcl_abs(C12) / vcl_sqrt(C11 * C22); // |) } return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalCovarianceToCoherencyDegreeFunctor() : m_NumberOfComponentsPerPixel(3), m_Epsilon(1e-6) {} /** Destructor */ virtual ~ReciprocalCovarianceToCoherencyDegreeFunctor() {} private: unsigned int m_NumberOfComponentsPerPixel; const double m_Epsilon; }; } /** \class otbReciprocalCovarianceToCoherencyDegreeImageFilter * \brief Compute the Coherency Degree coefficient * from the MLC image (6 complex channels) * For more details, lease refer to the class ReciprocalCovarianceToCoherencyDegreeFunctor. * * \ingroup SARPolarimetry * \sa ReciprocalCovarianceToCoherencyDegreeFunctor * * * \ingroup OTBPolarimetry */ template class ITK_EXPORT ReciprocalCovarianceToCoherencyDegreeImageFilter : public UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalCovarianceToCoherencyDegreeImageFilter Self; typedef typename Functor::ReciprocalCovarianceToCoherencyDegreeFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalCovarianceToCoherencyDegreeImageFilter, UnaryFunctorImageFilter); protected: ReciprocalCovarianceToCoherencyDegreeImageFilter() {} ~ReciprocalCovarianceToCoherencyDegreeImageFilter() ITK_OVERRIDE {} private: ReciprocalCovarianceToCoherencyDegreeImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif otbReciprocalCovarianceToReciprocalCoherencyImageFilter.h000066400000000000000000000121231301006202600360370ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalCovarianceToReciprocalCoherencyImageFilter_h #define otbReciprocalCovarianceToReciprocalCoherencyImageFilter_h #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class ReciprocalCovarianceToReciprocalCoherencyFunctor * \brief Evaluate the Coherency matrix from the Covariance image * * Output value are: * - channel #0 : \f$ 0.5 . (C33 + C13 + C13^{*} + C11) \f$ * - channel #1 : \f$ 0.5 . (-C33 - C13 + C13^{*} + C11) \f$ * - channel #2 : \f$ 0.5 . (\sqrt{2}.C12 + \sqrt{2}.C23^{*}) \f$ * - channel #3 : \f$ 0.5 . (C33 - C13 - C13^{*} + C11 \f$) * - channel #4 : \f$ 0.5 . (\sqrt{2}.C12 - \sqrt{2}.C23^{*}) \f$ * - channel #5 : \f$ 0.5 . (2 . C22) \f$ * * The output pixel has 6 channels : the diagonal and the upper element of the reciprocal matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa CovarianceToCircularCoherencyDegreeImageFilter * \sa ReciprocalCovarianceToReciprocalCoherencyDegreeImageFilter * * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalCovarianceToReciprocalCoherencyFunctor { public: typedef typename std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Covariance ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); const ComplexType C11 = static_cast(Covariance[0]); const ComplexType C12 = static_cast(Covariance[1]); const ComplexType C13 = static_cast(Covariance[2]); const ComplexType C22 = static_cast(Covariance[3]); const ComplexType C23 = static_cast(Covariance[4]); const ComplexType C33 = static_cast(Covariance[5]); const ComplexType two = ComplexType(2.0, 0.0); const ComplexType rootTwo = ComplexType(vcl_sqrt(2.0), 0.0); result[0] = static_cast( C33 + C13 + vcl_conj(C13) + C11 ); result[1] = static_cast( -C33 - C13 + vcl_conj(C13) + C11 ); result[2] = static_cast( rootTwo*C12 + rootTwo*vcl_conj(C23) ); result[3] = static_cast( C33 - C13 - vcl_conj(C13) + C11 ); result[4] = static_cast( rootTwo*C12 - rootTwo*vcl_conj(C23) ); result[5] = static_cast( two * C22 ); result /= 2.0; return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalCovarianceToReciprocalCoherencyFunctor() : m_NumberOfComponentsPerPixel(6) {} /** Destructor */ virtual ~ReciprocalCovarianceToReciprocalCoherencyFunctor() {} private: unsigned int m_NumberOfComponentsPerPixel; }; } /** \class otbReciprocalCovarianceToReciprocalCoherencyImageFilter * \brief Compute the Coherency image (6 complex channels) * from the Covariance image (6 complex channels) * * For more details, please refer to the class ReciprocalCovarianceToReciprocalCoherencyFunctor. * * \ingroup SARPolarimetry * \sa ReciprocalCovarianceToReciprocalCoherencyFunctor * * \ingroup OTBPolarimetry */ template class ITK_EXPORT ReciprocalCovarianceToReciprocalCoherencyImageFilter : public UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalCovarianceToReciprocalCoherencyImageFilter Self; typedef Functor::ReciprocalCovarianceToReciprocalCoherencyFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctorType; typedef UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalCovarianceToReciprocalCoherencyImageFilter, UnaryFunctorImageFilter); protected: ReciprocalCovarianceToReciprocalCoherencyImageFilter() {} ~ReciprocalCovarianceToReciprocalCoherencyImageFilter() ITK_OVERRIDE {} private: ReciprocalCovarianceToReciprocalCoherencyImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbReciprocalHAlphaImageFilter.h000066400000000000000000000165151301006202600310430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalHAlphaImageFilter_h #define otbReciprocalHAlphaImageFilter_h #include "otbUnaryFunctorImageFilter.h" #include "otbMath.h" #include "vnl/algo/vnl_complex_eigensystem.h" #include namespace otb { namespace Functor { /** \class otbHAlphaFunctor * \brief Evaluate the H-Alpha parameters from the reciprocal coherency matrix image. * * To process, we diagonalise the complex coherency matrix (size 3*3). We call \f$ SortedEigenValues \f$ the list that contains the * eigen values of the matrix sorted in decrease order. \f$ SortedEigenVector \f$ the corresponding list * of eigen vector. * * Output value are: * - channel #0 : \f$ entropy = -\sum_{i=0}^{2}{p[i].\log{p[i]}} / \log{3} \f$ * - channel #1 : \f$ \alpha = \sum_{i=0}^{2}{p[i].\alpha_{i} \f$ * - channel #2 : \f$ anisotropy = \frac {SortedEigenValues[1] - SortedEigenValues[2]}{SortedEigenValues[1] + SortedEigenValues[2]} \f$ * * Where: * - \f$ p[i] = max(SortedEigenValues[i], 0) / \sum_{i=0}^{2, SortedEigenValues[i]>0}{SortedEigenValues[i]} \f$ * - \f$ \alpha_{i} = \left| SortedEigenVector[i] \right|* \frac{180}{\pi}\f$ * * With, * - \f$ if p[i] < 0, p[i]=0 \f$ * - \f$ if p[i] > 1, p[i]=1 \f$ * - \f$ if \alpha_{i} > 90, \alpha_{i}=90 \f$ * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalHAlphaFunctor { public: typedef typename std::complex ComplexType; typedef vnl_matrix VNLMatrixType; typedef vnl_vector VNLVectorType; typedef vnl_vector VNLDoubleVectorType; typedef std::vector VectorType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Coherency ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); const double T0 = static_cast(Coherency[0].real()); const double T1 = static_cast(Coherency[3].real()); const double T2 = static_cast(Coherency[5].real()); VNLMatrixType vnlMat(3, 3, 0.); vnlMat[0][0] = ComplexType(T0, 0.); vnlMat[0][1] = ComplexType(Coherency[1]); vnlMat[0][2] = ComplexType(Coherency[2]); vnlMat[1][0] = std::conj(ComplexType(Coherency[1])); vnlMat[1][1] = ComplexType(T1, 0.); vnlMat[1][2] = ComplexType(Coherency[4]); vnlMat[2][0] = std::conj(ComplexType(Coherency[2])); vnlMat[2][1] = std::conj(ComplexType(Coherency[4])); vnlMat[2][2] = ComplexType(T2, 0.); // Only compute the left symmetry to respect the previous Hermitian Analisys code vnl_complex_eigensystem syst(vnlMat, false, true); const VNLMatrixType eigenVectors( syst.L ); const VNLVectorType eigenValues(syst.W); // Entropy estimation double totalEigenValues(0.0); double p[3]; double plog[3]; double entropy; double alpha; double anisotropy; // Sort eigen values in decreasing order VectorType sortedRealEigenValues(3, eigenValues[0].real()); sortedRealEigenValues[1] = eigenValues[1].real(); sortedRealEigenValues[2] = eigenValues[2].real(); std::sort( sortedRealEigenValues.begin(), sortedRealEigenValues.end() ); std::reverse( sortedRealEigenValues.begin(), sortedRealEigenValues.end() ); // Extract the first component of each the eigen vector sorted by eigen value decrease order VNLVectorType sortedGreaterEigenVector(3, eigenVectors[0][0]); for(unsigned int i=0; i<3; ++i) { if( vcl_abs( eigenValues[1].real()-sortedRealEigenValues[i] ) < m_Epsilon ) { sortedGreaterEigenVector[i] = eigenVectors[1][0]; } else if( vcl_abs( eigenValues[2].real()-sortedRealEigenValues[i] ) < m_Epsilon ) { sortedGreaterEigenVector[i] = eigenVectors[2][0]; } } totalEigenValues = 0.0; for (unsigned int k = 0; k < 3; ++k) { sortedRealEigenValues[k] = std::max(sortedRealEigenValues[k], 0.); totalEigenValues += sortedRealEigenValues[k]; } for (unsigned int k = 0; k < 3; ++k) { p[k] = sortedRealEigenValues[k] / totalEigenValues; if (p[k]0 when n-->0 plog[k]=0.0; else plog[k]=-p[k]*log(p[k])/log(3.0); } entropy = 0.0; for (unsigned int k = 0; k < 3; ++k) entropy += plog[k]; // alpha estimation double val0, val1, val2; double a0, a1, a2; val0 = std::abs(sortedGreaterEigenVector[0]); a0=acos(vcl_abs(val0)) * CONST_180_PI; val1 = std::abs(sortedGreaterEigenVector[1]); a1=acos(vcl_abs(val1)) * CONST_180_PI; val2= std::abs(sortedGreaterEigenVector[2]); a2=acos(vcl_abs(val2)) * CONST_180_PI; alpha=p[0]*a0 + p[1]*a1 + p[2]*a2; // Anisotropy estimation anisotropy=(sortedRealEigenValues[1] - sortedRealEigenValues[2])/(sortedRealEigenValues[1] + sortedRealEigenValues[2] + m_Epsilon); result[0] = static_cast(entropy); result[1] = static_cast(alpha); result[2] = static_cast(anisotropy); return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalHAlphaFunctor() : m_Epsilon(1e-6) {} /** Destructor */ virtual ~ReciprocalHAlphaFunctor() {} private: itkStaticConstMacro(m_NumberOfComponentsPerPixel, unsigned int, 3); const double m_Epsilon; }; } /** \class otbHAlphaImageFilter * \brief Compute the H-Alpha image (3 channels) * from the Reciprocal coherency image (6 complex channels) * * For more details, please refer to the class ReciprocalHAlphaFunctor. * * \ingroup OTBPolarimetry * \sa ReciprocalHAlphaFunctor * */ template class ITK_EXPORT ReciprocalHAlphaImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalHAlphaImageFilter Self; typedef typename Functor::ReciprocalHAlphaFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef otb::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalHAlphaImageFilter, UnaryFunctorImageFilter); protected: ReciprocalHAlphaImageFilter() {} ~ReciprocalHAlphaImageFilter() ITK_OVERRIDE {} private: ReciprocalHAlphaImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbReciprocalHuynenDecompImageFilter.h000066400000000000000000000076741301006202600323120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalHuynenDecompImageFilter_h #define otbReciprocalHuynenDecompImageFilter_h #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class ReciprocalHuynenDecompFunctor * * \brief Evaluate the Huynen decomposition from the reciprocal Sinclair matrix image. * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalHuynenDecompFunctor { public: typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Covariance ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); OutputValueType A0 = static_cast(Covariance[0].real() / 2.0); OutputValueType B0 = static_cast((Covariance[3] + Covariance[5]).real() / 2.0); OutputValueType B = static_cast(Covariance[3].real() - B0); OutputValueType C = static_cast(Covariance[1].real()); OutputValueType D = static_cast(-Covariance[1].imag()); OutputValueType E = static_cast(Covariance[4].real()); OutputValueType F = static_cast(Covariance[4].imag()); OutputValueType G = static_cast(Covariance[2].imag()); OutputValueType H = static_cast(Covariance[2].real()); result[0] = A0; result[1] = B0; result[2] = B; result[3] = C; result[4] = D; result[5] = E; result[6] = F; result[7] = G; result[8] = H; return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalHuynenDecompFunctor() : m_Epsilon(1e-6) {} /** Destructor */ virtual ~ReciprocalHuynenDecompFunctor() {} private: itkStaticConstMacro(m_NumberOfComponentsPerPixel, unsigned int, 9); const double m_Epsilon; }; } /** \class ReciprocalHuynenDecompImageFilter * \brief Compute the Huynen decomposition image (9 complex channels) * from the Reciprocal Covariance image (6 complex channels) * * For more details, please refer to the class ReciprocalHuynenDecompFunctor. * * \ingroup OTBPolarimetry * \sa ReciprocalHuynenDecompFunctor * */ template class ITK_EXPORT ReciprocalHuynenDecompImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalHuynenDecompImageFilter Self; typedef typename Functor::ReciprocalHuynenDecompFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef otb::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalHuynenDecompImageFilter, UnaryFunctorImageFilter); protected: ReciprocalHuynenDecompImageFilter() {} ~ReciprocalHuynenDecompImageFilter() ITK_OVERRIDE {} private: ReciprocalHuynenDecompImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter.h000066400000000000000000000146101301006202600410150ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter_h #define otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "vcl_complex.h" namespace otb { namespace Functor { /** \class ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor * \brief Compute the reciprocal Covariance circular matrix from the reciprocal Covariance linear matrix. * Extract from Antennas for radar and communications Harold Mott p 317. * * Output value are: * - channel #0 : \f$ 0.25 * (C33-i.\sqrt{2}.C23-C13+i.\sqrt{2}.C23^{*}-C13^{*}+2.C22-i.\sqrt{2}.C12+i.\sqrt{2}.C12^{*}+C11) \f$ * - channel #1 : \f$ 0.25 * (i.\sqrt{2}.C33+2.C23-i.\sqrt{2}.C13+i.\sqrt{2}.C13^{*}+2.C12^{*}-i.\sqrt{2}.C11) \f$ * - channel #2 : \f$ 0.25 * (-C33+i.\sqrt{2}.C23+C13+i.\sqrt{2}.C23^{*}+C13^{*}+2.C22-i.\sqrt{2}.C12-i.\sqrt{2}.C12^{*}-C11 ) \f$ * - channel #3 : \f$ 0.25 * (2.C33+2.C13+2.C13^{*}+2.C11)\f$ * - channel #4 : \f$ 0.25 * (i.\sqrt{2}.C33+i.\sqrt{2}.C13+2.C23^{*}-i.\sqrt{2}.C13^{*}+2.C12-i.\sqrt{2}.C11) \f$ * - channel #5 : \f$ 0.25 * (C33+i.\sqrt{2}.C23-C13-i.\sqrt{2}.C23^{*}-C13^{*}+2.C22+i.\sqrt{2}.C12-i.\sqrt{2}.C12^{*}+C11) \f$ * * Where Cij are related to the elements of the reciprocal linear covariance matrix. * * The output pixel has 6 channels : the diagonal and the upper element of the reciprocal matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa CovarianceToCoherencyDegreeImageFilter * \sa CovarianceToCoherencyImageFilter * * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor { public: typedef double RealType; typedef typename std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Covariance ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); result.Fill(0.0); const ComplexType C11 = static_cast( Covariance[0] ); // const ComplexType C12 = static_cast( Covariance[1] ); // const ComplexType C13 = static_cast( Covariance[2] ); // const ComplexType C22 = static_cast( Covariance[3] ); // <2.hv.hv*> const ComplexType C23 = static_cast( Covariance[4] ); // const ComplexType C33 = static_cast( Covariance[5] ); // const ComplexType cst1 = ComplexType(0.0, vcl_sqrt(2.0)); const ComplexType two = ComplexType(2.0, 0 ); result[0] = static_cast( C33-cst1*C23-C13+cst1*vcl_conj(C23)-vcl_conj(C13)+two*C22-cst1*C12+cst1*vcl_conj(C12)+C11 ) ; result[1] = static_cast( cst1*C33+two*C23-cst1*C13+cst1*vcl_conj(C13)+two*vcl_conj(C12)-cst1*C11 ); result[2] = static_cast( -C33+cst1*C23+C13+cst1*vcl_conj(C23)+vcl_conj(C13)+two*C22-cst1*C12-cst1*vcl_conj(C12)-C11 ) ; result[3] = static_cast( two*C33+two*C13+two*vcl_conj(C13)+two*C11 ) ; result[4] = static_cast( cst1*C33+cst1*C13+two*vcl_conj(C23)-cst1*vcl_conj(C13)+two*C12-cst1*C11 ) ; result[5] = static_cast( C33+cst1*C23-C13-cst1*vcl_conj(C23)-vcl_conj(C13)+two*C22+cst1*C12-cst1*vcl_conj(C12)+C11 ) ; result /= 4.0; return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor() : m_NumberOfComponentsPerPixel(6) {} /** Destructor */ virtual ~ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor() {} private: unsigned int m_NumberOfComponentsPerPixel; }; } /** \class otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter * \brief Compute the reciprocal Covariance circular matrix image from the reciprocal Covariance linear matrix image. * For more details, please refer to the class ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor. * * \ingroup SARPolarimetry * \sa ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor * * \ingroup OTBPolarimetry */ template class ITK_EXPORT ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter Self; typedef typename Functor::ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter, itk::UnaryFunctorImageFilter); protected: ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter() {} ~ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter() ITK_OVERRIDE {} private: ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbReciprocalPauliDecompImageFilter.h000066400000000000000000000067251301006202600321120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReciprocalPauliDecompImageFilter_h #define otbReciprocalPauliDecompImageFilter_h #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class ReciprocalPauliDecompFunctor * * \brief Evaluate the Pauli decomposition from the reciprocal Sinclair matrix image. * * \ingroup OTBPolarimetry */ template< class TInput, class TOutput> class ReciprocalPauliDecompFunctor { public: typedef typename TInput::ValueType InputValueType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator()( const TInput & Sinclair ) const { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); InputValueType sqrt2(std::sqrt(2.0),0.0); InputValueType Shh = static_cast(Sinclair[0]); InputValueType Shv = static_cast(Sinclair[1]); InputValueType Svv = static_cast(Sinclair[2]); result[0] = (Shh+Svv)/sqrt2; result[1] = (Shh-Svv)/sqrt2; result[2] = sqrt2*Shv; return result; } unsigned int GetOutputSize() { return m_NumberOfComponentsPerPixel; } /** Constructor */ ReciprocalPauliDecompFunctor() : m_Epsilon(1e-6) {} /** Destructor */ virtual ~ReciprocalPauliDecompFunctor() {} private: itkStaticConstMacro(m_NumberOfComponentsPerPixel, unsigned int, 3); const double m_Epsilon; }; } /** \class ReciprocalPauliDecompImageFilter * \brief Compute the Pauli decomposition image (3 complex channels) * from the Reciprocal Sinclair image (6 complex channels) * * For more details, please refer to the class ReciprocalPauliDecompFunctor. * * \ingroup OTBPolarimetry * \sa ReciprocalPauliDecompFunctor * */ template class ITK_EXPORT ReciprocalPauliDecompImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ReciprocalPauliDecompImageFilter Self; typedef typename Functor::ReciprocalPauliDecompFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType> FunctionType; typedef otb::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(ReciprocalPauliDecompImageFilter, UnaryFunctorImageFilter); protected: ReciprocalPauliDecompImageFilter() {this->SetNumberOfThreads(1);} ~ReciprocalPauliDecompImageFilter() ITK_OVERRIDE {} private: ReciprocalPauliDecompImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairImageFilter.h000066400000000000000000000104671301006202600274460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairImageFilter_h #define otbSinclairImageFilter_h #include "otbQuaternaryFunctorImageFilter.h" #include "otbSinclairToCovarianceMatrixFunctor.h" #include namespace otb { /** \class SinclairImageFilter * \brief Computes the Covariance matrix for the sinclair one. * * This class is parameterized over the type of the input images and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * The output image has 10 channels : the diagonal and the upper element of the matrix. * Element are stored from left to right, line by line. * * The class is templated by the 4 input image (HH, HV, VH and VV) and the used functor. * Available functors are : * - SinclairToCircularCovarianceMatrixFunctor (default one) * - SinclairToCoherencyMatrixFunctor * - SinclairToCovarianceMatrixFunctor * - SinclairToMuelleMatrixrFunctor * * \ingroup SARPolarimetry * * \sa SinclairImageFilter * \sa SinclairToCircularCovarianceMatrixFunctor * \sa SinclairToCoherencyMatrixFunctor * \sa SinclairToCovarianceMatrixFunctor * \sa SinclairToMuelleMatrixrFunctor * * * \ingroup OTBPolarimetry */ template > class ITK_EXPORT SinclairImageFilter : public otb::QuaternaryFunctorImageFilter { public: /** Standard typedefs */ typedef SinclairImageFilter Self; typedef otb::QuaternaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SinclairImageFilter, QuaternaryFunctorImageFilter); /** Template parameters typedefs */ typedef typename Superclass::Input1ImageType HHInputImageType; typedef typename Superclass::Input1ImagePointer HHInputImagePointer; typedef typename Superclass::Input2ImageType HVInputImageType; typedef typename Superclass::Input2ImagePointer HVInputImagePointer; typedef typename Superclass::Input3ImageType VHInputImageType; typedef typename Superclass::Input3ImagePointer VHInputImagePointer; typedef typename Superclass::Input4ImageType VVInputImageType; typedef typename Superclass::Input4ImagePointer VVInputImagePointer; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename Superclass::FunctorType FunctorType; void SetInputHH(const TInputImageHH * image); void SetInputHV(const TInputImageHV * image); void SetInputVH(const TInputImageVH * image); void SetInputVV(const TInputImageVV * image); protected: /** Constructor */ SinclairImageFilter() {} /** Destructor */ ~SinclairImageFilter() ITK_OVERRIDE {} void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SinclairImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSinclairImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairImageFilter.txx000066400000000000000000000062441301006202600300400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairImageFilter_txx #define otbSinclairImageFilter_txx #include "otbSinclairImageFilter.h" #include "otbMath.h" namespace otb { /** * Connect one of the operands for pixel-wise addition */ template void SinclairImageFilter ::SetInputHH(const TInputImageHH * image) { this->SetInput1(image); } /** * Connect one of the operands for pixel-wise addition */ template void SinclairImageFilter ::SetInputHV(const TInputImageHV * image) { this->SetInput2(image); } /** * Connect one of the operands for pixel-wise addition */ template void SinclairImageFilter ::SetInputVH(const TInputImageVH * image) { this->SetInput3(image); } /** * Connect one of the operands for pixel-wise addition */ template void SinclairImageFilter ::SetInputVV(const TInputImageVV * image) { this->SetInput4(image); } /** * Printself */ template void SinclairImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void SinclairImageFilter ::GenerateOutputInformation() { // Call to the superclass implementation Superclass::GenerateOutputInformation(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); // initialize the number of channels of the output image outputPtr->SetNumberOfComponentsPerPixel( this->GetFunctor().GetNumberOfComponentsPerPixel() ); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairReciprocalImageFilter.h000066400000000000000000000106571301006202600314530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairReciprocalImageFilter_h #define otbSinclairReciprocalImageFilter_h #include "itkTernaryFunctorImageFilter.h" #include "otbSinclairToReciprocalCovarianceMatrixFunctor.h" #include namespace otb { /** \class SinclairReciprocalImageFilter * \brief Convert the Sinclair reciprocal matrix. * * This class is parameterized over the type of the input images and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * The output image has 6 channels : the diagonal and the upper element of the reciprocal matrix. * Element a sotored from left to right, line by line. * * The class is templated by the 3 input image (HH, HV_VH and VV) and the used functor. * Available functors are : * - SinclairToReciprocalCovarianceMatrixFunctor (default one) * - SinclairToReciprocalCircularCovarianceMatrixFunctor * - SinclairToReciprocalCoherencyMatrixFunctor * * \ingroup SARPolarimetry * * \sa SinclairImageFilter * \sa SinclairToReciprocalCircularCovarianceMatrixFunctor * \sa SinclairToReciprocalCoherencyMatrixFunctor * \sa SinclairToReciprocalCovarianceMatrixFunctor * * * \ingroup OTBPolarimetry */ template > class ITK_EXPORT SinclairReciprocalImageFilter : public itk::TernaryFunctorImageFilter { public: /** Standard typedefs */ typedef SinclairReciprocalImageFilter Self; typedef itk::TernaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SinclairReciprocalImageFilter, itk::TernaryFunctorImageFilter); /** Template parameters typedefs */ typedef typename Superclass::Input1ImageType HHInputImageType; typedef typename Superclass::Input1ImagePointer HHInputImagePointer; typedef typename Superclass::Input2ImageType HV_VHInputImageType; typedef typename Superclass::Input2ImagePointer HV_VHInputImagePointer; typedef typename Superclass::Input3ImageType VVInputImageType; typedef typename Superclass::Input3ImagePointer VVInputImagePointer; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename Superclass::FunctorType FunctorType; void SetInputHH(const TInputImageHH * image); // This method set the second input, same as SetInputVH void SetInputHV(const TInputImageHV_VH * image); // This method set the second input, same as SetInputHV void SetInputVH(const TInputImageHV_VH * image); // This method set the second input, same as SetInputHV and SetInputHV void SetInputHV_VH(const TInputImageHV_VH * image); void SetInputVV(const TInputImageVV * image); protected: /** Constructor */ SinclairReciprocalImageFilter() {} /** Destructor */ ~SinclairReciprocalImageFilter() ITK_OVERRIDE {} void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SinclairReciprocalImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSinclairReciprocalImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairReciprocalImageFilter.txx000066400000000000000000000066411301006202600320450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairReciprocalImageFilter_txx #define otbSinclairReciprocalImageFilter_txx #include "otbSinclairReciprocalImageFilter.h" #include "otbMath.h" namespace otb { /** * Connect one of the operands for pixel-wise addition */ template void SinclairReciprocalImageFilter ::SetInputHH(const TInputImageHH * image) { this->SetInput1(image); } /** * Connect one of the operands for pixel-wise addition */ template void SinclairReciprocalImageFilter ::SetInputHV(const TInputImageHV_VH * image) { this->SetInput2(image); } /** * Connect one of the operands for pixel-wise addition */ template void SinclairReciprocalImageFilter ::SetInputVH(const TInputImageHV_VH * image) { this->SetInput2(image); } /** * Connect one of the operands for pixel-wise addition */ template void SinclairReciprocalImageFilter ::SetInputHV_VH(const TInputImageHV_VH * image) { this->SetInput2(image); } /** * Connect one of the operands for pixel-wise addition */ template void SinclairReciprocalImageFilter ::SetInputVV(const TInputImageVV * image) { this->SetInput3(image); } /** * Printself */ template void SinclairReciprocalImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void SinclairReciprocalImageFilter ::GenerateOutputInformation() { // Call to the superclass implementation Superclass::GenerateOutputInformation(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); // initialize the number of channels of the output image outputPtr->SetNumberOfComponentsPerPixel( this->GetFunctor().GetNumberOfComponentsPerPixel() ); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairToCircularCovarianceMatrixFunctor.h000066400000000000000000000106041301006202600340370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairToCircularCovarianceMatrixFunctor_h #define otbSinclairToCircularCovarianceMatrixFunctor_h #include "vcl_complex.h" #include "otbSinclairToCovarianceMatrixFunctor.h" namespace otb { namespace Functor { /** \class SinclairToCircularCovarianceMatrixFunctor * \brief Construct the fully polarimetric circular covariance matrix * with Sinclair matrix information. * * Output value are: * - channel #0 : \f$ S_{ll}.S_{ll}^{*} \f$ * - channel #1 : \f$ S_{ll}.S_{lr}^{*} \f$ * - channel #2 : \f$ S_{ll}.S_{rl}^{*} \f$ * - channel #3 : \f$ S_{ll}.S_{rr}^{*} \f$ * - channel #4 : \f$ S_{lr}.S_{lr}^{*} \f$ * - channel #5 : \f$ S_{lr}.S_{rl}^{*} \f$ * - channel #6 : \f$ S_{lr}.S_{rr}^{*} \f$ * - channel #7 : \f$ S_{rl}.S_{rl}^{*} \f$ * - channel #8 : \f$ S_{rl}.S_{rr}^{*} \f$ * - channel #9 : \f$ S_{rr}.S_{rr}^{*} \f$ * * With: * - \f$ S_{ll} = 0.5 * (S_{hh}+i*S_{hv}+i*S_{vh}-S_{vv}) \f$ * - \f$ S_{lr} = 0.5 * (i*S_{hh}+S_{hv}-S_{vh}+i*S_{vv}) \f$ * - \f$ S_{rl} = 0.5 * (i*S_{hh}-S_{hv}+S_{vh}+i*S_{vv}) \f$ * - \f$ S_{rr} = 0.5 * (-S_{hh}+i*S_{hv}+i*S_{vh}+S_{vv}) \f$ * * Extract from Antennas for radar and communications Harold Mott p 317. * * The output pixel has 10 channels : the diagonal and the upper element of the matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa SinclairImageFilter * \sa SinclairToCoherencyMatrixFunctor * \sa SinclairToCovarianceMatrixFunctor * \sa SinclairToMuellerMatrixFunctor * \sa SinclairToReciprocalCircularCovarianceMatrixFunctor * \sa SinclairToReciprocalCoherencyMatrixFunctor * \sa SinclairToReciprocalCovarianceMatrixFunctor * * * \ingroup OTBPolarimetry */ template class SinclairToCircularCovarianceMatrixFunctor { public: /** Some typedefs. */ typedef double RealType; typedef std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; typedef SinclairToCovarianceMatrixFunctor SinclairToCovarianceFunctorType; inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svh, const TInput4& Svv) { TOutput result; const ComplexType S_hh = static_cast(Shh); const ComplexType S_hv = static_cast(Shv); const ComplexType S_vh = static_cast(Svh); const ComplexType S_vv = static_cast(Svv); result.SetSize(m_NumberOfComponentsPerPixel); const ComplexType jS_hv = S_hv * ComplexType(0., 1.); const ComplexType jS_vh = S_vh * ComplexType(0., 1.); const ComplexType jS_hh = S_hh * ComplexType(0., 1.); const ComplexType jS_vv = S_vv * ComplexType(0., 1.); const ComplexType coef(0.5); const ComplexType Sll = coef*( S_hh+jS_hv+jS_vh-S_vv ); const ComplexType Slr = coef*( jS_hh+S_hv-S_vh+jS_vv ); const ComplexType Srl = coef*( jS_hh-S_hv+S_vh+jS_vv ); const ComplexType Srr = coef*( -S_hh+jS_hv+jS_vh+S_vv ); //const ComplexType conjSll = vcl_conj(Sll); //const ComplexType conjSlr = vcl_conj(Slr); //const ComplexType conjSrl = vcl_conj(Srl); //const ComplexType conjSrr = vcl_conj(Srr); SinclairToCovarianceFunctorType funct; return ( funct( Sll, Slr, Srl, Srr ) ); } unsigned int GetNumberOfComponentsPerPixel() { return m_NumberOfComponentsPerPixel; } /** Constructor */ SinclairToCircularCovarianceMatrixFunctor() : m_NumberOfComponentsPerPixel(10) {} /** Destructor */ virtual ~SinclairToCircularCovarianceMatrixFunctor() {} protected: private: unsigned int m_NumberOfComponentsPerPixel; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairToCoherencyMatrixFunctor.h000066400000000000000000000104061301006202600322170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairToCoherencyMatrixFunctor_h #define otbSinclairToCoherencyMatrixFunctor_h #include "vcl_complex.h" namespace otb { namespace Functor { /** \class SinclairToCoherencyMatrixFunctor * \brief Construct the fully polarimetric coherency matrix * with Sinclair matrix information. * * Output value are: * - channel #0 : \f$ (S_{hh}+S_{vv}).(S_{hh}+S_{vv})^{*} \f$ * - channel #1 : \f$ (S_{hh}+S_{vv}).(S_{hh}-S_{vv})^{*} \f$ * - channel #2 : \f$ (S_{hh}+S_{vv}).(S_{hv}+S_{vh})^{*} \f$ * - channel #3 : \f$ (S_{hh}+S_{vv}).(j(S_{hv}-S_{vh}))^{*} \f$ * - channel #4 : \f$ (S_{hh}-S_{vv}).(S_{hh}-S_{vv})^{*} \f$ * - channel #5 : \f$ (S_{hh}-S_{vv}).(S_{hv}+S_{vh})^{*} \f$ * - channel #6 : \f$ (S_{hh}-S_{vv}).(j(S_{hv}-S_{vh}))^{*} \f$ * - channel #7 : \f$ (S_{hv}+S_{vh}).(S_{hv}+S_{vh})^{*} \f$ * - channel #8 : \f$ (S_{hv}+S_{vh}).(j(S_{hv}-S_{vh}))^{*} \f$ * - channel #9 : \f$ j(S_{hv}-S_{vh}).(j(S_{hv}-S_{vh}))^{*} \f$ * * The output pixel has 10 channels : the diagonal and the upper element of the matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa SinclairImageFilter * \sa SinclairToCircularCovarianceMatrixFunctor * \sa SinclairToCovarianceFunctor * \sa SinclairToMuellerFunctor * \sa SinclairToReciprocalCircularCovarianceMatrixFunctor * \sa SinclairToReciprocalCoherencyMatrixFunctor * \sa SinclairToReciprocalCovarianceFunctor * * * \ingroup OTBPolarimetry */ template class SinclairToCoherencyMatrixFunctor { public: /** Some typedefs. */ typedef double RealType; typedef std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svh, const TInput4& Svv) { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); const ComplexType S_hh = static_cast(Shh); const ComplexType S_hv = static_cast(Shv); const ComplexType S_vh = static_cast(Svh); const ComplexType S_vv = static_cast(Svv); const ComplexType HHPlusVV = S_hh + S_vv; const ComplexType HHMinusVV = S_hh - S_vv; const ComplexType HVPlusVH = S_hv + S_vh; const ComplexType jHVMinusVH = (S_hv - S_vh) * ComplexType(0., 1.); result[0] = static_cast( std::norm(HHPlusVV) ); result[1] = static_cast( HHPlusVV * vcl_conj(HHMinusVV) ); result[2] = static_cast( HHPlusVV * vcl_conj(HVPlusVH) ); result[3] = static_cast( HHPlusVV * vcl_conj(jHVMinusVH) ); result[4] = static_cast( std::norm(HHMinusVV) ); result[5] = static_cast( HHMinusVV * vcl_conj(HVPlusVH) ); result[6] = static_cast( HHMinusVV * vcl_conj(jHVMinusVH) ); result[7] = static_cast( std::norm(HVPlusVH) ); result[8] = static_cast( HVPlusVH * vcl_conj(jHVMinusVH) ); result[9] = static_cast( std::norm(jHVMinusVH) ); result /= 2.0; return (result); } unsigned int GetNumberOfComponentsPerPixel() { return m_NumberOfComponentsPerPixel; } /** Constructor */ SinclairToCoherencyMatrixFunctor() {} /** Destructor */ virtual ~SinclairToCoherencyMatrixFunctor() {} protected: private: //itkStaticConstMacro(NumberOfComponentsPerPixel, unsigned int, 10); static const unsigned int m_NumberOfComponentsPerPixel = 10; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairToCovarianceMatrixFunctor.h000066400000000000000000000073131301006202600323550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairToCovarianceMatrixFunctor_h #define otbSinclairToCovarianceMatrixFunctor_h #include "vcl_complex.h" namespace otb { namespace Functor { /** \class SinclairToCovarianceMatrixFunctor * \brief Construct the fully polarimetric covariance matrix * with Sinclair matrix information. * * Output value are: * - channel #0 : \f$ S_{hh}.S_{hh}^{*} \f$ * - channel #1 : \f$ S_{hh}.S_{hv}^{*} \f$ * - channel #2 : \f$ S_{hh}.S_{vh}^{*} \f$ * - channel #3 : \f$ S_{hh}.S_{vv}^{*} \f$ * - channel #4 : \f$ S_{hv}.S_{hv}^{*} \f$ * - channel #5 : \f$ S_{hv}.S_{vh}^{*} \f$ * - channel #6 : \f$ S_{hv}.S_{vv}^{*} \f$ * - channel #7 : \f$ S_{vh}.S_{vh}^{*} \f$ * - channel #8 : \f$ S_{vh}.S_{vv}^{*} \f$ * - channel #9 : \f$ S_{vv}.S_{vv}^{*} \f$ * * The output pixel has 10 channels : the diagonal and the upper element of the matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa SinclairImageFilter * \sa SinclairToCircularCovarianceMatrixFunctor * \sa SinclairToCoherencyFunctor * \sa SinclairToMuellerFunctor * \sa SinclairToReciprocalCircularCovarianceMatrixFunctor * \sa SinclairToReciprocalCoherencyFunctor * \sa SinclairToReciprocalCovarianceMatrixFunctor * * * \ingroup OTBPolarimetry */ template class SinclairToCovarianceMatrixFunctor { public: /** Some typedefs. */ typedef typename std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svh, const TInput4& Svv) { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); const ComplexType S_hh = static_cast(Shh); const ComplexType S_hv = static_cast(Shv); const ComplexType S_vh = static_cast(Svh); const ComplexType S_vv = static_cast(Svv); result[0] = static_cast( std::norm(S_hh) ); result[1] = static_cast( S_hh*vcl_conj(S_hv) ); result[2] = static_cast( S_hh*vcl_conj(S_vh) ); result[3] = static_cast( S_hh*vcl_conj(S_vv) ); result[4] = static_cast( std::norm(S_hv) ); result[5] = static_cast( S_hv*vcl_conj(S_vh) ); result[6] = static_cast( S_hv*vcl_conj(S_vv) ); result[7] = static_cast( std::norm(S_vh) ); result[8] = static_cast( S_vh*vcl_conj(S_vv) ); result[9] = static_cast( std::norm(S_vv) ); return (result); } unsigned int GetNumberOfComponentsPerPixel() { return m_NumberOfComponentsPerPixel; } /** Constructor */ SinclairToCovarianceMatrixFunctor() {} /** Destructor */ virtual ~SinclairToCovarianceMatrixFunctor() {} protected: private: //itkStaticConstMacro(m_NumberOfComponentsPerPixel, unsigned int, 10); static const unsigned int m_NumberOfComponentsPerPixel = 10; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/include/otbSinclairToMuellerMatrixFunctor.h000066400000000000000000000143771301006202600317200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairToMuellerMatrixFunctor_h #define otbSinclairToMuellerMatrixFunctor_h #include "vcl_complex.h" namespace otb { namespace Functor { /** \class SinclairToMuellerMatrixFunctor * \brief Construct Mueller matrix with Sinclair matrix information. * Elements of the Mueller matrix are extract from Antennas for radar and communications * Harold Mott p 503 * * Output value are: * - channel #0 : \f$ 0.5 * \mathcal{Re}( T_{xx}.T_{xx}^{*} + T_{xy}.T_{xy}^{*} + T_{yx}.T_{yx}^{*} + T_{yy}.T_{yy}^{*} ) \f$ * - channel #1 : \f$ 0.5 * \mathcal{Re}( T_{xx}.T_{xx}^{*} - T_{xy}.T_{xy}^{*} + T_{yx}.T_{yx}^{*} - T_{yy}.T_{yy}^{*} ) \f$ * - channel #2 : \f$ \mathcal{Re}( T_{xx}.T_{xy}^{*} + T_{yx}.T_{yy}^{*} ) \f$ * - channel #3 : \f$ \mathcal{Im}( T_{xx}.T_{xy}^{*} + T_{yx}.T_{yy}^{*} ) \f$ * - channel #4 : \f$ 0.5 * \mathcal{Re}( T_{xx}.T_{xx}^{*} + T_{xy}.T_{xy}^{*} - T_{yx}.T_{yx}^{*} - T_{yy}.T_{yy}^{*} ) \f$ * - channel #5 : \f$ 0.5 * \mathcal{Re}( T_{xx}.T_{xx}^{*} - T_{xy}.T_{xy}^{*} - T_{yx}.T_{yx}^{*} + T_{yy}.T_{yy}^{*} ) \f$ * - channel #6 : \f$ \mathcal{Re}( T_{xx}.T_{xy}^{*} - T_{yx}.T_{yy}^{*} ) \f$ * - channel #7 : \f$ \mathcal{Im}( T_{xx}.T_{xy}^{*} - T_{yx}.T_{yy}^{*} ) \f$ * - channel #8 : \f$ \mathcal{Re}( T_{xx}.T_{yx}^{*} + T_{xy}.T_{yy}^{*} ) \f$ * - channel #9 : \f$ \mathcal{Im}( T_{xx}.T_{yx}^{*} - T_{xy}.T_{yy}^{*} ) \f$ * - channel #10 : \f$ \mathcal{Re}( T_{xx}.T_{yy}^{*} + T_{xy}.T_{yx}^{*} ) \f$ * - channel #11 : \f$ \mathcal{Im}( T_{xx}.T_{yy}^{*} - T_{xy}.T_{yx}^{*} ) \f$ * - channel #12 : \f$ \mathcal{Re}( T_{xx}.T_{yx}^{*} + T_{xy}.T_{yy}^{*} ) \f$ * - channel #13 : \f$ \mathcal{Im}( T_{xx}.T_{yx}^{*} - T_{xy}.T_{yy}^{*} ) \f$ * - channel #14 : \f$ \mathcal{Re}( T_{xx}.T_{yy}^{*} + T_{xy}.T_{yx}^{*} ) \f$ * - channel #15 : \f$ \mathcal{Im}( T_{xx}.T_{yy}^{*} - T_{xy}.T_{yx}^{*} ) \f$ * * With : * - \f$ T_{xx} = -S_{hh} \f$ * - \f$ T_{xy} = -S_{hv} \f$ * - \f$ T_{yx} = S_{vh} \f$ * - \f$ T_{yy} = S_{vv} \f$ * * Output is a not a complex. The output pixel has 16 channels : each element of the Mueller matrix. * The order of the channels corresponds to : * \f$ \begin{pmatrix} * {channel #0 }&{channel #1 }&{channel #2 }&{channel #3 } \\ * {channel #4 }&{channel #5 }&{channel #6 }&{channel #7 } \\ * {channel #8 }&{channel #9 }&{channel #10}&{channel #11} \\ * {channel #12}&{channel #13}&{channel #14}&{channel #15} \\ * \end{pmatrix} \f$ * * \ingroup Functor * \ingroup SARPolarimetry * * \sa SinclairImageFilter * \sa SinclairToCircularCovarianceMatrixFunctor * \sa SinclairToCoherencyMatrixFunctor * \sa SinclairToCovarianceMatrixFunctor * \sa SinclairToReciprocalCircularCovarianceMatrixFunctor * \sa SinclairToReciprocalCoherencyMatrixFunctor * \sa SinclairToReciprocalCovarianceMatrixFunctor * * * \ingroup OTBPolarimetry */ template class SinclairToMuellerMatrixFunctor { public: /** Some typedefs. */ typedef typename std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; typedef double RealType; inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svh, const TInput4& Svv) { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); const ComplexType Txx = static_cast(-Shh); const ComplexType Txy = static_cast(-Shv); const ComplexType Tyx = static_cast(Svh); const ComplexType Tyy = static_cast(Svv); const ComplexType conjTxx = vcl_conj(Txx); const ComplexType conjTxy = vcl_conj(Txy); const ComplexType conjTyx = vcl_conj(Tyx); const ComplexType conjTyy = vcl_conj(Tyy); result[0] = static_cast( 0.5 * ( std::norm(Txx) + std::norm(Txy) + std::norm(Tyx) + std::norm(Tyy) ) ); result[1] = static_cast( 0.5 * ( std::norm(Txx) - std::norm(Txy) + std::norm(Tyx) - std::norm(Tyy) ) ); result[2] = static_cast( (Txx*conjTxy + Tyx*conjTyy).real() ); result[3] = static_cast( (Txx*conjTxy + Tyx*conjTyy).imag() ); result[4] = static_cast( 0.5 * (std::norm(Txx) + std::norm(Txy) - std::norm(Tyx) - std::norm(Tyy) ) ); result[5] = static_cast( 0.5 * (std::norm(Txx) - std::norm(Txy) - std::norm(Tyx) + std::norm(Tyy) ) ); result[6] = static_cast( (Txx*conjTxy - Tyx*conjTyy).real() ); result[7] = static_cast( (Txx*conjTxy - Tyx*conjTyy).imag() ); result[8] = static_cast( (Txx*conjTyx + Txy*conjTyy).real() ); result[9] = static_cast( (Txx*conjTyx - Txy*conjTyy).real() ); result[10] = static_cast( (Txx*conjTyy + Txy*conjTyx).real() ); result[11] = static_cast( (Txx*conjTyy - Txy*conjTyx).imag() ); result[12] = static_cast( (conjTxx*Tyx + conjTxy*Tyy).imag() ); result[13] = static_cast( (conjTxx*Tyx - conjTxy*Tyy).imag() ); result[14] = static_cast( (conjTxx*Tyy + conjTxy*Tyx).imag() ); result[15] = static_cast( (Txx*conjTyy - Txy*conjTyx).real() ); return (result); } unsigned int GetNumberOfComponentsPerPixel() { return m_NumberOfComponentsPerPixel; } /** Constructor */ SinclairToMuellerMatrixFunctor() : m_NumberOfComponentsPerPixel(16) {} /** Destructor */ virtual ~SinclairToMuellerMatrixFunctor() {} protected: private: unsigned int m_NumberOfComponentsPerPixel; }; } // namespace Functor } // namespace otb #endif otbSinclairToReciprocalCircularCovarianceMatrixFunctor.h000066400000000000000000000071771301006202600357770ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairToReciprocalCircularCovarianceMatrixFunctor_h #define otbSinclairToReciprocalCircularCovarianceMatrixFunctor_h #include "vcl_complex.h" #include "otbSinclairToReciprocalCovarianceMatrixFunctor.h" namespace otb { namespace Functor { /** \class SinclairToReciprocalCircularCovarianceMatrixFunctor * \brief Construct the fully reciprocal polarimetric circular covariance matrix * with Sinclair matrix information. * * Output value are: * - channel #0 : \f$ S_{ll}.S_{ll}^{*} \f$ * - channel #1 : \f$ S_{ll}.S_{lr}^{*} \f$ * - channel #2 : \f$ S_{ll}.S_{rr}^{*} \f$ * - channel #3 : \f$ S_{lr}.S_{lr}^{*} \f$ * - channel #4 : \f$ S_{lr}.S_{rr}^{*} \f$ * - channel #5 : \f$ S_{rr}.S_{rr}^{*} \f$ * * This is a adaptation of the SinclairToCircularCovarianceMatrixFunctor, where \f$ S_{hv}=S_{vh} \f$. * * The output pixel has 6 channels : the diagonal and the upper element of the reciprocal matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa SinclairToCircularCovarianceMatrixFunctor * \sa SinclairImageFilter * \sa SinclairToCoherencyMatrixFunctor * \sa SinclairToCovarianceMatrixFunctor * \sa SinclairToMuellerMatrixFunctor * \sa SinclairToReciprocalCoherencyMatrixFunctor * \sa SinclairToReciprocalCovarianceMatrixFunctor * * * \ingroup OTBPolarimetry */ template class SinclairToReciprocalCircularCovarianceMatrixFunctor { public: /** Some typedefs. */ typedef double RealType; typedef std::complex ComplexType; typedef typename TOutput::ValueType OutputValueType; typedef SinclairToReciprocalCovarianceMatrixFunctor SinclairToReciprocalCovarianceFunctorType; inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svv) { TOutput result; result.SetSize(m_NumberOfComponentsPerPixel); const ComplexType S_hh = static_cast(Shh); const ComplexType S_hv = static_cast(Shv); const ComplexType S_vv = static_cast(Svv); const ComplexType coef(0.5); const ComplexType j2S_hv = S_hv * ComplexType(0.0, 2.0); const ComplexType jS_hh = S_hh * ComplexType(0.0, 1.0); const ComplexType jS_vv = S_vv * ComplexType(0.0, 1.0); const ComplexType Sll = coef * ( S_hh+j2S_hv-S_vv ); const ComplexType Slr = coef * ( jS_hh + jS_vv ); const ComplexType Srr = coef * ( -S_hh+j2S_hv+S_vv ); SinclairToReciprocalCovarianceFunctorType funct; return ( funct(Sll, Slr, Srr ) ); } unsigned int GetNumberOfComponentsPerPixel() { return m_NumberOfComponentsPerPixel; } /** Constructor */ SinclairToReciprocalCircularCovarianceMatrixFunctor() : m_NumberOfComponentsPerPixel(6) {} /** Destructor */ virtual ~SinclairToReciprocalCircularCovarianceMatrixFunctor() {} protected: private: unsigned int m_NumberOfComponentsPerPixel; }; } // namespace Functor } // namespace otb #endif otbSinclairToReciprocalCoherencyMatrixFunctor.h000066400000000000000000000073021301006202600341450ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairToReciprocalCoherencyMatrixFunctor_h #define otbSinclairToReciprocalCoherencyMatrixFunctor_h #include "itkMacro.h" #include "vcl_complex.h" #include "otbMath.h" #include "vnl/vnl_matrix.h" namespace otb { namespace Functor { /** \class SinclairToReciprocalCoherencyMatrixFunctor * \brief Construct the reciprocal fully polarimetric coherency matrix * with Sinclair matrix information. * * Output value are: * - channel #0 : \f$ (S_{hh}+S_{vv}).(S_{hh}+S_{vv})^{*} \f$ * - channel #1 : \f$ (S_{hh}+S_{vv}).(S_{hh}-S_{vv})^{*} \f$ * - channel #2 : \f$ (S_{hh}+S_{vv}).(2*S_{hv})^{*} \f$ * - channel #3 : \f$ (S_{hh}-S_{vv}).(S_{hh}-S_{vv})^{*} \f$ * - channel #4 : \f$ (S_{hh}-S_{vv}).(2*S_{hv})^{*} \f$ * - channel #5 : \f$ (2*S_{hv}).(2*S_{hv})^{*} \f$ * * This is a adaptation of the SinclairToCoherencyFunctor, where \f$ S_{hv}=S_{vh} \f$. * * The output pixel has 6 channels : the diagonal and the upper element of the reciprocal matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa SinclairImageFilter * \sa SinclairToCircularCovarianceMatrixFunctor * \sa SinclairToCoherencyMatrixFunctor * \sa SinclairToCovarianceMatrixFunctor * \sa SinclairToMuellerMatrixFunctor * \sa SinclairToReciprocalCircularCovarianceMatrixFunctor * \sa SinclairToReciprocalCovarianceMatrixFunctor * * * \ingroup OTBPolarimetry */ template class SinclairToReciprocalCoherencyMatrixFunctor { public: /** Some typedefs. */ typedef typename std::complex ComplexType; typedef vnl_matrix VNLMatrixType; typedef typename TOutput::ValueType OutputValueType; itkStaticConstMacro(NumberOfComponentsPerPixel, unsigned int, 6); inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svv) { TOutput result; result.SetSize(NumberOfComponentsPerPixel); const ComplexType S_hh = static_cast(Shh); const ComplexType S_hv = static_cast(Shv); const ComplexType S_vv = static_cast(Svv); VNLMatrixType f3p(3, 1, 0.); f3p[0][0]= (S_hh + S_vv) / ComplexType( std::sqrt(2.0) , 0.0); f3p[1][0]= (S_hh - S_vv) / ComplexType( std::sqrt(2.0) , 0.0); f3p[2][0]= ComplexType( std::sqrt(2.0) , 0.0) * S_hv; VNLMatrixType res = f3p*f3p.conjugate_transpose(); result[0] = static_cast( res[0][0] ); result[1] = static_cast( res[0][1] ); result[2] = static_cast( res[0][2] ); result[3] = static_cast( res[1][1] ); result[4] = static_cast( res[1][2] ); result[5] = static_cast( res[2][2] ); return (result); } unsigned int GetNumberOfComponentsPerPixel() { return NumberOfComponentsPerPixel; } /** Constructor */ SinclairToReciprocalCoherencyMatrixFunctor() {} /** Destructor */ virtual ~SinclairToReciprocalCoherencyMatrixFunctor() {} protected: private: }; } // namespace Functor } // namespace otb #endif otbSinclairToReciprocalCovarianceMatrixFunctor.h000066400000000000000000000071071301006202600343030ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinclairToReciprocalCovarianceMatrixFunctor_h #define otbSinclairToReciprocalCovarianceMatrixFunctor_h #include "vcl_complex.h" #include "otbMath.h" #include "vnl/vnl_matrix.h" namespace otb { namespace Functor { /** \class SinclairToReciprocalCovarianceMatrixFunctor * \brief Construct the reciprocal fully polarimetric covariance matrix * with Sinclair matrix information. * * Output value are: * - channel #0 : \f$ S_{hh}.S_{hh}^{*} \f$ * - channel #1 : \f$ \sqrt{2}.S_{hh}.S_{hv}^{*} \f$ * - channel #2 : \f$ S_{hh}.S_{vv}^{*} \f$ * - channel #3 : \f$ 2.S_{hv}.S_{hv}^{*} \f$ * - channel #4 : \f$ \sqrt{2}.S_{hv}.S_{vv}^{*} \f$ * - channel #5 : \f$ S_{vv}.S_{vv}^{*} \f$ * * This is a adaptation of the SinclairToCovarianceMatrixFunctor, where \f$ S_{hv}=S_{vh} \f$. * * The output pixel has 6 channels : the diagonal and the upper element of the reciprocal matrix. * Element are stored from left to right, line by line. * * \ingroup Functor * \ingroup SARPolarimetry * * \sa SinclairToCovarianceMatrixFunctor * \sa SinclairImageFilter * \sa SinclairToCircularCovarianceMatrixFunctor * \sa SinclairToCoherencyeMatrixFunctor * \sa SinclairToMuellereMatrixFunctor * \sa SinclairToReciprocalCircularCovarianceMatrixFunctor * \sa SinclairToReciprocalCoherencyeMatrixFunctor * * * \ingroup OTBPolarimetry */ template class SinclairToReciprocalCovarianceMatrixFunctor { public: /** Some typedefs. */ typedef typename std::complex ComplexType; typedef vnl_matrix VNLMatrixType; typedef typename TOutput::ValueType OutputValueType; inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv, const TInput3& Svv) { TOutput result; result.SetSize(NumberOfComponentsPerPixel); const ComplexType S_hh = static_cast(Shh); const ComplexType S_hv = static_cast(Shv); const ComplexType S_vv = static_cast(Svv); VNLMatrixType f3l(3, 1, 0.); f3l[0][0]=S_hh; f3l[1][0]=ComplexType(std::sqrt(2.0),0.0)*S_hv; f3l[2][0]=S_vv; VNLMatrixType res = f3l*f3l.conjugate_transpose(); result[0] = static_cast( res[0][0] ); result[1] = static_cast( res[0][1] ); result[2] = static_cast( res[0][2] ); result[3] = static_cast( res[1][1] ); result[4] = static_cast( res[1][2] ); result[5] = static_cast( res[2][2] ); return (result); } unsigned int GetNumberOfComponentsPerPixel() { return NumberOfComponentsPerPixel; } /** Constructor */ SinclairToReciprocalCovarianceMatrixFunctor() {} /** Destructor */ virtual ~SinclairToReciprocalCovarianceMatrixFunctor() {} protected: private: //itkStaticConstMacro(NumberOfComponentsPerPixel, unsigned int, 6); static const unsigned int NumberOfComponentsPerPixel = 6; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Polarimetry/otb-module.cmake000066400000000000000000000011001301006202600243210ustar00rootroot00000000000000set(DOCUMENTATION "This module is concerned with Synthetic Aperture Radar images. The ability of radar polarimetry to obtain more information about physical properties of the surface than single-channel SAR data has led to a wide range of applications. Here, the user can find (for instance) classes to handle different representations of a polarisation state, to perform polarimetry synthesis, and so on.") otb_module(OTBPolarimetry DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/Polarimetry/src/000077500000000000000000000000001301006202600220475ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/src/CMakeLists.txt000066400000000000000000000003171301006202600246100ustar00rootroot00000000000000set(OTBPolarimetry_SRC otbPolarimetricData.cxx ) add_library(OTBPolarimetry ${OTBPolarimetry_SRC}) target_link_libraries(OTBPolarimetry ${OTBCommon_LIBRARIES} ) otb_module_target(OTBPolarimetry) OTB-release-5.8/Modules/Filtering/Polarimetry/src/otbPolarimetricData.cxx000066400000000000000000000047671301006202600265420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPolarimetricData.h" namespace otb { /** * Constructor */ PolarimetricData ::PolarimetricData() { SetArchitectureType(UNKNOWN_ARCHITECTURE); } void PolarimetricData ::DetermineArchitecture(bool *IsPresent) { // With all the channels if (IsPresent[0] && IsPresent[1] && IsPresent[2] && IsPresent[3]) { SetArchitectureType(HH_HV_VH_VV); } else // With 3 channels : HH HV VV if (IsPresent[0] && IsPresent[1] && !IsPresent[2] && IsPresent[3]) { SetArchitectureType(HH_HV_VV); } else // With 3 channels : HH VH VV if (IsPresent[0] && !IsPresent[1] && IsPresent[2] && IsPresent[3]) { SetArchitectureType(HH_VH_VV); } else // Only HH and HV are present if (IsPresent[0] && IsPresent[1] && !IsPresent[2] && !IsPresent[3]) { SetArchitectureType(HH_HV); } else // Only VH and VV are present if (!IsPresent[0] && !IsPresent[1] && IsPresent[2] && IsPresent[3]) { SetArchitectureType(VH_VV); } else // Only HH and VV are present if (IsPresent[0] && !IsPresent[1] && !IsPresent[2] && IsPresent[3]) { SetArchitectureType(HH_VV); } else { SetArchitectureType(UNKNOWN_ARCHITECTURE); } } void PolarimetricData ::DetermineArchitecture(int NumberOfImages, bool EmissionH, bool EmissionV) { switch (NumberOfImages) { case 4: SetArchitectureType(HH_HV_VH_VV); break; case 3: SetArchitectureType(HH_HV_VV); break; case 2: if (EmissionH && !EmissionV) { SetArchitectureType(HH_HV); } else if (!EmissionH && EmissionV) { SetArchitectureType(VH_VV); } break; default: itkExceptionMacro("Unknown architecture !"); return; } } /**PrintSelf method */ void PolarimetricData ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "ArchitectureType " << m_ArchitectureType << " : " << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Filtering/Polarimetry/test/000077500000000000000000000000001301006202600222375ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/CMakeLists.txt000066400000000000000000000437561301006202600250160ustar00rootroot00000000000000otb_module_test() set(OTBPolarimetryTests otbPolarimetryTestDriver.cxx otbMuellerToPolarisationDegreeAndPowerImageFilter.cxx otbVectorMultiChannelsPolarimetricSynthesisFilter.cxx otbReciprocalHAlphaImageFilter.cxx otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilterNew.cxx otbReciprocalCovarianceToReciprocalCoherencyImageFilter.cxx otbReciprocalHAlphaImageFilterNew.cxx otbSinclairToCoherencyMatrixFunctor.cxx otbPolarimetricSynthesisFunctor.cxx otbMultiChannelsPolarimetricSynthesisFilter.cxx otbSinclairImageFilter.cxx otbReciprocalCovarianceToReciprocalCoherencyImageFilterNew.cxx otbSinclairToCircularCovarianceMatrixFunctor.cxx otbSinclairReciprocalImageFilter.cxx otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter.cxx otbReciprocalCoherencyToReciprocalMuellerImageFilter.cxx otbSinclairToReciprocalCovarianceMatrixFunctor.cxx otbReciprocalCovarianceToCoherencyDegreeImageFilterNew.cxx otbMuellerToReciprocalCovarianceImageFilter.cxx otbReciprocalCoherencyToReciprocalMuellerImageFilterNew.cxx otbSinclairToMuellerMatrixFunctor.cxx otbMuellerToReciprocalCovarianceFunctor.cxx otbPolarimetricData.cxx otbMuellerToReciprocalCovarianceImageFilterNew.cxx otbSinclairToReciprocalCoherencyMatrixFunctor.cxx otbSinclairToReciprocalCircularCovarianceMatrixFunctor.cxx otbMultiChannelsPolarimetricSynthesisFilterNew.cxx otbSinclairToCovarianceMatrixFunctor.cxx otbReciprocalCovarianceToCoherencyDegreeImageFilter.cxx otbMuellerToPolarisationDegreeAndPowerImageFilterNew.cxx otbReciprocalBarnesDecomp.cxx otbReciprocalHuynenDecomp.cxx otbReciprocalPauliDecomp.cxx ) add_executable(otbPolarimetryTestDriver ${OTBPolarimetryTests}) target_link_libraries(otbPolarimetryTestDriver ${OTBPolarimetry-Test_LIBRARIES}) otb_module_target_label(otbPolarimetryTestDriver) # Tests Declaration otb_add_test(NAME saTvMuellerToPolarisationDegreeAndPowerImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvMuellerToPolarisationDegreeAndPowerImageFilter.tif ${TEMP}/saTvMuellerToPolarisationDegreeAndPowerImageFilter.tif otbMuellerToPolarisationDegreeAndPowerImageFilter ${BASELINE}/saTvSinclairImageFilter_SinclairToMueller.tif ${TEMP}/saTvMuellerToPolarisationDegreeAndPowerImageFilter.tif ) otb_add_test(NAME saTvVectorMultiChannelsPolarimetricSynthesisFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvMultiPolarimetricSynthesis1.tif ${TEMP}/resMultiPolarimetricSynthesis1.tif otbVectorMultiChannelsPolarimetricSynthesisFilter ${INPUTDATA}/RSAT2_AltonaExtract_1000_1000_100_100.hdr ${TEMP}/resMultiPolarimetricSynthesis1.tif 10.0 # PsiI 0.0 # KhiI 0.0 # PsiR 0.0 # KhiR ) otb_add_test(NAME saTvReciprocalHAlphaImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvReciprocalHAlphaImageFilter.tif ${TEMP}/saTvReciprocalHAlphaImageFilter.tif otbReciprocalHAlphaImageFilter ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif 5 ${TEMP}/saTvReciprocalHAlphaImageFilter.tif ) otb_add_test(NAME saTvReciprocalBarnesDecompImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvReciprocalBarnesDecompImageFilter.tif ${TEMP}/saTvReciprocalBarnesDecompImageFilter.tif otbReciprocalBarnesDecompImageFilter ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif 5 ${TEMP}/saTvReciprocalBarnesDecompImageFilter.tif ) otb_add_test(NAME saTvReciprocalHuynenDecompImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvReciprocalHuynenDecompImageFilter.tif ${TEMP}/saTvReciprocalHuynenDecompImageFilter.tif otbReciprocalHuynenDecompImageFilter ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif 5 ${TEMP}/saTvReciprocalHuynenDecompImageFilter.tif ) otb_add_test(NAME saTvReciprocalPauliDecompImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvReciprocalPauliDecompImageFilter.tif ${TEMP}/saTvReciprocalPauliDecompImageFilter.tif otbReciprocalPauliDecompImageFilter ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvReciprocalPauliDecompImageFilter.tif ) otb_add_test(NAME saTuReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilterNew ) otb_add_test(NAME saTvReciprocalCovarianceToReciprocalCoherencyImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCoherency.tif ${TEMP}/saTvMLCToCoherencyImageFilter.tif otbReciprocalCovarianceToReciprocalCoherencyImageFilter ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif ${TEMP}/saTvMLCToCoherencyImageFilter.tif ) otb_add_test(NAME saTuReciprocalHAlphaImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalHAlphaImageFilterNew ) otb_add_test(NAME saTuReciprocalBarnesDecompImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalBarnesDecompImageFilterNew ) otb_add_test(NAME saTuReciprocalHuynenDecompImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalHuynenDecompImageFilterNew ) otb_add_test(NAME saTuReciprocalPauliDecompImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalPauliDecompImageFilterNew ) otb_add_test(NAME saTuSinclairToCoherencyMatrixFunctor COMMAND otbPolarimetryTestDriver otbSinclairToCoherencyMatrixFunctor ) otb_add_test(NAME saTuPolarimetricSynthesisFunctor COMMAND otbPolarimetryTestDriver otbPolarimetricSynthesisFunctor ) otb_add_test(NAME saTvMultiChannelsPolarimetricSynthesisFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvMultiPolarimetricSynthesis2.tif ${TEMP}/resMultiPolarimetricSynthesis2.tif otbMultiChannelsPolarimetricSynthesisFilter ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/resMultiPolarimetricSynthesis2.tif 32.0 # PsiI 22.0 # KhiI 58.0 # PsiR 45.0 # KhiR ) otb_add_test(NAME saTvMultiChannelsPolarimetricSynthesisFilter_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvMultiPolarimetricSynthesis2.tif ${TEMP}/resMultiPolarimetricSynthesis2_C.tif otbMultiChannelsPolarimetricSynthesisFilter ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/resMultiPolarimetricSynthesis2_C.tif 32.0 # PsiI 22.0 # KhiI 58.0 # PsiR 45.0 # KhiR ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToMueller COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToMueller.tif ${TEMP}/saTvSinclairImageFilter_SinclairToMueller.tif otbSinclairImageFilter SinclairToMuellerMatrix ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToMueller.tif ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToMueller_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToMueller.tif ${TEMP}/saTvSinclairImageFilter_SinclairToMueller_C.tif otbSinclairImageFilter SinclairToMuellerMatrix ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToMueller_C.tif ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToCovariance COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToCovariance.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCovariance.tif otbSinclairImageFilter SinclairToCovarianceMatrix ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCovariance.tif ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToCovariance_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToCovariance.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCovariance_C.tif otbSinclairImageFilter SinclairToCovarianceMatrix ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCovariance_C.tif ) otb_add_test(NAME saTuSinclairImageFilterNew COMMAND otbPolarimetryTestDriver otbSinclairImageFilterNew ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix.tif otbSinclairImageFilter SinclairToCircularCovarianceMatrix ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix.tif ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix_C.tif otbSinclairImageFilter SinclairToCircularCovarianceMatrix ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCircularCovarianceMatrix_C.tif ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToCoherency COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToCoherency.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCoherency.tif otbSinclairImageFilter SinclairToCoherencyMatrix ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCoherency.tif ) otb_add_test(NAME saTvSinclairImageFilter_SinclairToCoherency_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToCoherency.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCoherency_C.tif otbSinclairImageFilter SinclairToCoherencyMatrix ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToCoherency_C.tif ) otb_add_test(NAME saTuReciprocalCovarianceToReciprocalCoherencyImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalCovarianceToReciprocalCoherencyImageFilterNew ) otb_add_test(NAME saTuSinclairToCircularCovarianceMatrixFunctor COMMAND otbPolarimetryTestDriver otbSinclairToCircularCovarianceMatrixFunctor ) otb_add_test(NAME saTuSinclairReciprocalImageFilterNew COMMAND otbPolarimetryTestDriver otbSinclairReciprocalImageFilterNew ) otb_add_test(NAME saTvSinclairReciprocalImageFilter_SinclairToReciprocalCovariance COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif otbSinclairReciprocalImageFilter SinclairToReciprocalCovarianceMatrix ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif ) otb_add_test(NAME saTvSinclairReciprocalImageFilter_SinclairToReciprocalCovariance_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCovariance_C.tif otbSinclairReciprocalImageFilter SinclairToReciprocalCovarianceMatrix ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCovariance_C.tif ) otb_add_test(NAME saTvSinclairReciprocalImageFilter_SinclairToReciprocalCircularCovarianceMatrix COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCircularCovarianceMatrix.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCircularCovarianceMatrix.tif otbSinclairReciprocalImageFilter SinclairToReciprocalCircularCovarianceMatrix ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCircularCovarianceMatrix.tif ) otb_add_test(NAME saTvSinclairReciprocalImageFilter_SinclairToReciprocalCircularCovarianceMatrix_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCircularCovarianceMatrix.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCircularCovarianceMatrix_C.tif otbSinclairReciprocalImageFilter SinclairToReciprocalCircularCovarianceMatrix ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCircularCovarianceMatrix_C.tif ) otb_add_test(NAME saTvSinclairReciprocalImageFilter_SinclairToReciprocalCoherency COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCoherency.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCoherency.tif otbSinclairReciprocalImageFilter SinclairToReciprocalCoherencyMatrix ${INPUTDATA}/RSAT_imagery_HH.tif ${INPUTDATA}/RSAT_imagery_HV.tif ${INPUTDATA}/RSAT_imagery_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCoherency.tif ) otb_add_test(NAME saTvSinclairReciprocalImageFilter_SinclairToReciprocalCoherency_C COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCoherency.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCoherency_C.tif otbSinclairReciprocalImageFilter SinclairToReciprocalCoherencyMatrix ${INPUTDATA}/RSAT_imageryC_HH.tif ${INPUTDATA}/RSAT_imageryC_HV.tif ${INPUTDATA}/RSAT_imageryC_VV.tif ${TEMP}/saTvSinclairImageFilter_SinclairToReciprocalCoherency_C.tif ) otb_add_test(NAME saTvReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCircularCovarianceMatrix.tif ${TEMP}/saTvMLCToCircularCoherencyDegreeImageFilter.tif otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif ${TEMP}/saTvMLCToCircularCoherencyDegreeImageFilter.tif ) otb_add_test(NAME saTvReciprocalCoherencyToReciprocalMuellerImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToMueller.tif ${TEMP}/saTvReciprocalCoherencyToMuellerImageFilter.tif otbReciprocalCoherencyToReciprocalMuellerImageFilter ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCoherency.tif ${TEMP}/saTvReciprocalCoherencyToMuellerImageFilter.tif ) otb_add_test(NAME saTuSinclairToReciprocalCovarianceMatrixFunctor COMMAND otbPolarimetryTestDriver otbSinclairToReciprocalCovarianceMatrixFunctor ) otb_add_test(NAME saTuReciprocalCovarianceToCoherencyDegreeImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalCovarianceToCoherencyDegreeImageFilterNew ) otb_add_test(NAME saTvMuellerToReciprocalCovarianceImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif ${TEMP}/saTvMuellerToMLCImageFilter.tif otbMuellerToReciprocalCovarianceImageFilter ${BASELINE}/saTvSinclairImageFilter_SinclairToMueller.tif ${TEMP}/saTvMuellerToMLCImageFilter.tif ) otb_add_test(NAME saTuReciprocalCoherencyToReciprocalMuellerImageFilterNew COMMAND otbPolarimetryTestDriver otbReciprocalCoherencyToReciprocalMuellerImageFilterNew ) otb_add_test(NAME saTuSinclairToMuellerMatrixFunctor COMMAND otbPolarimetryTestDriver otbSinclairToMuellerMatrixFunctor ) otb_add_test(NAME saTvMuellerToReciprocalCovarianceFunctor COMMAND otbPolarimetryTestDriver otbMuellerToReciprocalCovarianceFunctor ) otb_add_test(NAME saTuPolarimetricDataNew COMMAND otbPolarimetryTestDriver otbPolarimetricDataNew ) otb_add_test(NAME saTvPolarimetricDataTest COMMAND otbPolarimetryTestDriver otbPolarimetricDataTest ) otb_add_test(NAME saTuMuellerToReciprocalCovarianceImageFilterNew COMMAND otbPolarimetryTestDriver otbMuellerToReciprocalCovarianceImageFilterNew ) otb_add_test(NAME saTuSinclairToReciprocalCoherencyMatrixFunctor COMMAND otbPolarimetryTestDriver otbSinclairToReciprocalCoherencyMatrixFunctor ) otb_add_test(NAME saTuSinclairToReciprocalCircularCovarianceMatrixFunctor COMMAND otbPolarimetryTestDriver otbSinclairToReciprocalCircularCovarianceMatrixFunctor ) otb_add_test(NAME saTuMultiChannelsPolarimetricSynthesisFilterNew COMMAND otbPolarimetryTestDriver otbMultiChannelsPolarimetricSynthesisFilterNew ) otb_add_test(NAME saTuSinclairToCovarianceMatrixFunctor COMMAND otbPolarimetryTestDriver otbSinclairToCovarianceMatrixFunctor ) otb_add_test(NAME saTvReciprocalCovarianceToCoherencyDegreeImageFilter COMMAND otbPolarimetryTestDriver --compare-image ${EPSILON_7} ${BASELINE}/saTvMLCToCoherencyDegreeImageFilter.tif ${TEMP}/saTvMLCToCoherencyDegreeImageFilter.tif otbReciprocalCovarianceToCoherencyDegreeImageFilter ${BASELINE}/saTvSinclairImageFilter_SinclairToReciprocalCovariance.tif ${TEMP}/saTvMLCToCoherencyDegreeImageFilter.tif ) otb_add_test(NAME saTuMuellerToPolarisationDegreeAndPowerImageFilterNew COMMAND otbPolarimetryTestDriver otbMuellerToPolarisationDegreeAndPowerImageFilterNew ) otbMuellerToPolarisationDegreeAndPowerImageFilter.cxx000066400000000000000000000032621301006202600345760ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMuellerToPolarisationDegreeAndPowerImageFilter.h" #include "otbSinclairImageFilter.h" #include "otbSinclairToMuellerMatrixFunctor.h" int otbMuellerToPolarisationDegreeAndPowerImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double PixelType; typedef otb::VectorImage RealImageType; typedef otb::MuellerToPolarisationDegreeAndPowerImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbMuellerToPolarisationDegreeAndPowerImageFilterNew.cxx000066400000000000000000000021661301006202600352520ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbMuellerToPolarisationDegreeAndPowerImageFilter.h" int otbMuellerToPolarisationDegreeAndPowerImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::MuellerToPolarisationDegreeAndPowerImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbMuellerToReciprocalCovarianceFunctor.cxx000066400000000000000000000053211301006202600327410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMuellerToReciprocalCovarianceImageFilter.h" #include "itkVariableLengthVector.h" #include int otbMuellerToReciprocalCovarianceFunctor(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef std::complex ComplexType; typedef itk::VariableLengthVector VectorDoubleType; typedef itk::VariableLengthVector VectorComplexType; typedef otb::Functor::MuellerToReciprocalCovarianceFunctor FunctorType; VectorDoubleType input; input.SetSize(16); VectorComplexType outputFunct; outputFunct.SetSize(6); VectorComplexType result; result.SetSize(6); double val = 0; for(unsigned int i=0; i 1e-10 || vcl_abs(result[0].imag()-outputFunct[0].imag()) > 1e-10 || vcl_abs(result[1].real()-outputFunct[1].real()) > 1e-10 || vcl_abs(result[1].imag()-outputFunct[1].imag()) > 1e-10 || vcl_abs(result[2].real()-outputFunct[2].real()) > 1e-10 || vcl_abs(result[2].imag()-outputFunct[2].imag()) > 1e-10 || vcl_abs(result[3].real()-outputFunct[3].real()) > 1e-10 || vcl_abs(result[3].imag()-outputFunct[3].imag()) > 1e-10 || vcl_abs(result[4].real()-outputFunct[4].real()) > 1e-10 || vcl_abs(result[4].imag()-outputFunct[4].imag()) > 1e-10 || vcl_abs(result[5].real()-outputFunct[5].real()) > 1e-10 || vcl_abs(result[5].imag()-outputFunct[5].imag()) > 1e-10 ) { std::cout<<"Test gives :"< ComplexPixelType; typedef otb::VectorImage RealImageType; typedef otb::VectorImage ComplexImageType; typedef otb::MuellerToReciprocalCovarianceImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename ); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbMuellerToReciprocalCovarianceImageFilterNew.cxx000066400000000000000000000024151301006202600341050ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbMuellerToReciprocalCovarianceImageFilter.h" int otbMuellerToReciprocalCovarianceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef std::complex ComplexPixelType; typedef otb::VectorImage ImageType; typedef otb::VectorImage ComplexImageType; typedef otb::MuellerToReciprocalCovarianceImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbMultiChannelsPolarimetricSynthesisFilter.cxx000066400000000000000000000104101301006202600336650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelsPolarimetricSynthesisFilter.h" int otbMultiChannelsPolarimetricSynthesisFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * inputFilename3 = argv[3]; const char * outputFilename = argv[4]; double PsiI = strtod(argv[5], ITK_NULLPTR); double KhiI = strtod(argv[6], ITK_NULLPTR); double PsiR = strtod(argv[7], ITK_NULLPTR); double KhiR = strtod(argv[8], ITK_NULLPTR); typedef std::complex InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::VectorImage InputVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelsPolarimetricSynthesisFilter FilterType; FilterType::Pointer polarimetricSynthesis = FilterType::New(); polarimetricSynthesis->SetPsiI(PsiI); polarimetricSynthesis->SetKhiI(KhiI); polarimetricSynthesis->SetPsiR(PsiR); polarimetricSynthesis->SetKhiR(KhiR); ReaderType::Pointer reader1 = ReaderType::New(); ReaderType::Pointer reader2 = ReaderType::New(); ReaderType::Pointer reader3 = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); reader3->SetFileName(inputFilename3); writer->SetFileName(outputFilename); reader1->Update(); reader2->Update(); reader3->Update(); InputVectorImageType::Pointer outputPtr = InputVectorImageType::New(); InputVectorImageType::IndexType start; start[0] = 0; start[1] = 0; InputVectorImageType::SizeType size = reader1->GetOutput()->GetLargestPossibleRegion().GetSize(); InputVectorImageType::RegionType region; region.SetSize(size); region.SetIndex(start); outputPtr->SetRegions(region); outputPtr->SetNumberOfComponentsPerPixel(3); outputPtr->Allocate(); InputVectorImageType::PixelType pix0; pix0.SetSize(3); InputPixelType complexpix(0, 0); pix0.Fill(complexpix); outputPtr->FillBuffer(pix0); InputVectorImageType::Pointer vectorImage = InputVectorImageType::New(); // Copy of the pictures in a vector itk::ImageRegionConstIterator inputIt1(reader1->GetOutput(), reader1->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionConstIterator inputIt2(reader2->GetOutput(), reader2->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionConstIterator inputIt3(reader3->GetOutput(), reader3->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionIterator outputIt(outputPtr, outputPtr->GetLargestPossibleRegion()); inputIt1.GoToBegin(); inputIt2.GoToBegin(); inputIt3.GoToBegin(); outputIt.GoToBegin(); while (!inputIt1.IsAtEnd()) { InputVectorImageType::PixelType pix; pix.SetSize(4); pix[0] = inputIt1.Get(); pix[1] = inputIt2.Get(); pix[2] = inputIt3.Get(); outputIt.Set(pix); ++inputIt1; ++inputIt2; ++inputIt3; ++outputIt; } polarimetricSynthesis->SetInput(outputPtr); writer->SetInput(polarimetricSynthesis->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbMultiChannelsPolarimetricSynthesisFilterNew.cxx000066400000000000000000000023371301006202600342710ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbMultiChannelsPolarimetricSynthesisFilter.h" int otbMultiChannelsPolarimetricSynthesisFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::MultiChannelsPolarimetricSynthesisFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbPolarimetricData.cxx000066400000000000000000000023011301006202600267100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbPolarimetricData.h" int otbPolarimetricDataNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { otb::PolarimetricData::Pointer data = otb::PolarimetricData::New(); return EXIT_SUCCESS; } int otbPolarimetricDataTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { otb::PolarimetricData::Pointer data = otb::PolarimetricData::New(); data->SetArchitectureType(static_cast(5)); data->DetermineArchitecture(3, true, false); bool tab[4]; tab[0] = true; tab[1] = false; tab[2] = false; tab[3] = true; data->DetermineArchitecture(tab); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbPolarimetricSynthesisFunctor.cxx000066400000000000000000000032111301006202600313720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "vcl_complex.h" #include "vcl_cmath.h" #include "otbPolarimetricSynthesisFunctor.h" int otbPolarimetricSynthesisFunctor(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef std::complex ComplexType; typedef otb::Functor::PolarimetricSynthesisFunctor FunctorType; double result(449.); double outputFunct(0.); FunctorType funct; FunctorType::ComplexArrayType l_Ei; FunctorType::ComplexArrayType l_Er; l_Ei[0] = ComplexType(0.5, 0); l_Ei[1] = ComplexType(1., 1.2); l_Er[0] = ComplexType(-2.5, 0.); l_Er[1] = ComplexType(0., 1.5); funct.SetEi(l_Ei); funct.SetEi(l_Er); outputFunct = funct.operator ()( ComplexType(1.5, 4.5), ComplexType(2.5, 3.5), ComplexType(3.5, 2.5), ComplexType(4.5, 1.5) ); if( vcl_abs(result-outputFunct) > 1e-10 ) { std::cout<<"Test gives :"< PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalBarnesDecompImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbReciprocalBarnesDecompImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilenameHH = argv[1]; const char * inputFilenameHV = argv[2]; const char * inputFilenameVV = argv[3]; int size = atoi(argv[4]); const char * outputFilename = argv[5]; typedef std::complex ComplexPixelType; const unsigned int Dimension = 2; typedef otb::Image ComplexImageType; typedef otb::VectorImage ComplexVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SinclairReciprocalImageFilter > SinclairToCovFilterType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::PerBandVectorImageFilter PerBandMeanFilterType; typedef otb::ReciprocalBarnesDecompImageFilter FilterType; ReaderType::Pointer readerHH = ReaderType::New(); ReaderType::Pointer readerHV = ReaderType::New(); ReaderType::Pointer readerVV = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); SinclairToCovFilterType::Pointer sinclairtocov = SinclairToCovFilterType::New(); PerBandMeanFilterType::Pointer perBand = PerBandMeanFilterType::New(); FilterType::Pointer barnesfilter = FilterType::New(); MeanFilterType::InputSizeType radius; radius.Fill( size ); perBand->GetFilter()->SetRadius(radius); readerHH->SetFileName(inputFilenameHH); readerHV->SetFileName(inputFilenameHV); readerVV->SetFileName(inputFilenameVV); sinclairtocov->SetInputHH(readerHH->GetOutput()); sinclairtocov->SetInputHV_VH(readerHV->GetOutput()); sinclairtocov->SetInputVV(readerVV->GetOutput()); perBand->SetInput(sinclairtocov->GetOutput()); barnesfilter->SetInput(perBand->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(barnesfilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReciprocalCoherencyToReciprocalMuellerImageFilter.cxx000066400000000000000000000034101301006202600353000ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbReciprocalCoherencyToReciprocalMuellerImageFilter.h" int otbReciprocalCoherencyToReciprocalMuellerImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double PixelType; typedef std::complex InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::VectorImage RealImageType; typedef otb::ReciprocalCoherencyToReciprocalMuellerImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReciprocalCoherencyToReciprocalMuellerImageFilterNew.cxx000066400000000000000000000021571301006202600357610ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbReciprocalCoherencyToReciprocalMuellerImageFilter.h" int otbReciprocalCoherencyToReciprocalMuellerImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalCoherencyToReciprocalMuellerImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } otbReciprocalCovarianceToCoherencyDegreeImageFilter.cxx000066400000000000000000000032651301006202600350650ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbReciprocalCovarianceToCoherencyDegreeImageFilter.h" int otbReciprocalCovarianceToCoherencyDegreeImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double PixelType; typedef std::complex InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::ReciprocalCovarianceToCoherencyDegreeImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReciprocalCovarianceToCoherencyDegreeImageFilterNew.cxx000066400000000000000000000021551301006202600355340ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbReciprocalCovarianceToCoherencyDegreeImageFilter.h" int otbReciprocalCovarianceToCoherencyDegreeImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalCovarianceToCoherencyDegreeImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } otbReciprocalCovarianceToReciprocalCoherencyImageFilter.cxx000066400000000000000000000031721301006202600357520ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbReciprocalCovarianceToReciprocalCoherencyImageFilter.h" int otbReciprocalCovarianceToReciprocalCoherencyImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double PixelType; typedef std::complex InputPixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalCovarianceToReciprocalCoherencyImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReciprocalCovarianceToReciprocalCoherencyImageFilterNew.cxx000066400000000000000000000021711301006202600364220ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbReciprocalCovarianceToReciprocalCoherencyImageFilter.h" int otbReciprocalCovarianceToReciprocalCoherencyImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalCovarianceToReciprocalCoherencyImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbReciprocalHAlphaImageFilter.cxx000066400000000000000000000066631301006202600307550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbReciprocalHAlphaImageFilter.h" #include "itkMeanImageFilter.h" #include "otbPerBandVectorImageFilter.h" #include "otbSinclairReciprocalImageFilter.h" #include "otbSinclairToReciprocalCoherencyMatrixFunctor.h" int otbReciprocalHAlphaImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilenameHH = argv[1]; const char * inputFilenameHV = argv[2]; const char * inputFilenameVV = argv[3]; int size = atoi(argv[4]); const char * outputFilename = argv[5]; typedef std::complex ComplexPixelType; const unsigned int Dimension = 2; typedef otb::Image ComplexImageType; typedef otb::VectorImage ComplexVectorImageType; typedef otb::VectorImage RealVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SinclairReciprocalImageFilter > SinclairToCovFilterType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::PerBandVectorImageFilter PerBandMeanFilterType; typedef otb::ReciprocalHAlphaImageFilter HAlphaFilterType; ReaderType::Pointer readerHH = ReaderType::New(); ReaderType::Pointer readerHV = ReaderType::New(); ReaderType::Pointer readerVV = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); SinclairToCovFilterType::Pointer sinclairtocov = SinclairToCovFilterType::New(); PerBandMeanFilterType::Pointer perBand = PerBandMeanFilterType::New(); HAlphaFilterType::Pointer haafilter = HAlphaFilterType::New(); MeanFilterType::InputSizeType radius; radius.Fill( size ); perBand->GetFilter()->SetRadius(radius); readerHH->SetFileName(inputFilenameHH); readerHV->SetFileName(inputFilenameHV); readerVV->SetFileName(inputFilenameVV); sinclairtocov->SetInputHH(readerHH->GetOutput()); sinclairtocov->SetInputHV_VH(readerHV->GetOutput()); sinclairtocov->SetInputVV(readerVV->GetOutput()); perBand->SetInput(sinclairtocov->GetOutput()); haafilter->SetInput(perBand->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(haafilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbReciprocalHAlphaImageFilterNew.cxx000066400000000000000000000020551301006202600314160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbReciprocalHAlphaImageFilter.h" int otbReciprocalHAlphaImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalHAlphaImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbReciprocalHuynenDecomp.cxx000066400000000000000000000074031301006202600300760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkMeanImageFilter.h" #include "otbReciprocalHuynenDecompImageFilter.h" #include "otbPerBandVectorImageFilter.h" #include "otbSinclairReciprocalImageFilter.h" #include "otbSinclairToReciprocalCoherencyMatrixFunctor.h" int otbReciprocalHuynenDecompImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalHuynenDecompImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbReciprocalHuynenDecompImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilenameHH = argv[1]; const char * inputFilenameHV = argv[2]; const char * inputFilenameVV = argv[3]; int size = atoi(argv[4]); const char * outputFilename = argv[5]; typedef std::complex ComplexPixelType; const unsigned int Dimension = 2; typedef otb::Image ComplexImageType; typedef otb::VectorImage ComplexVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SinclairReciprocalImageFilter > SinclairToCovFilterType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::PerBandVectorImageFilter PerBandMeanFilterType; typedef otb::ReciprocalHuynenDecompImageFilter FilterType; ReaderType::Pointer readerHH = ReaderType::New(); ReaderType::Pointer readerHV = ReaderType::New(); ReaderType::Pointer readerVV = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); SinclairToCovFilterType::Pointer sinclairtocov = SinclairToCovFilterType::New(); PerBandMeanFilterType::Pointer perBand = PerBandMeanFilterType::New(); FilterType::Pointer huynenfilter = FilterType::New(); MeanFilterType::InputSizeType radius; radius.Fill( size ); perBand->GetFilter()->SetRadius(radius); readerHH->SetFileName(inputFilenameHH); readerHV->SetFileName(inputFilenameHV); readerVV->SetFileName(inputFilenameVV); sinclairtocov->SetInputHH(readerHH->GetOutput()); sinclairtocov->SetInputHV_VH(readerHV->GetOutput()); sinclairtocov->SetInputVV(readerVV->GetOutput()); perBand->SetInput(sinclairtocov->GetOutput()); huynenfilter->SetInput(perBand->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(huynenfilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter.cxx000066400000000000000000000033551301006202600407300ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter.h" int otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double PixelType; typedef std::complex InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilterNew.cxx000066400000000000000000000022461301006202600414000ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Polarimetry/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter.h" int otbReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalLinearCovarianceToReciprocalCircularCovarianceImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbReciprocalPauliDecomp.cxx000066400000000000000000000055131301006202600277020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbReciprocalPauliDecompImageFilter.h" #include "otbNRIBandImagesToOneNComplexBandsImage.h" int otbReciprocalPauliDecompImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ReciprocalPauliDecompImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbReciprocalPauliDecompImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilenameHH = argv[1]; const char * inputFilenameHV = argv[2]; const char * inputFilenameVV = argv[3]; const char * outputFilename = argv[4]; typedef std::complex ComplexPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ComplexVectorImageType; typedef otb::VectorImage RealVectorImageType; typedef otb::NRIBandImagesToOneNComplexBandsImage NRITOOneCFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReciprocalPauliDecompImageFilter FilterType; ReaderType::Pointer readerHH = ReaderType::New(); ReaderType::Pointer readerHV = ReaderType::New(); ReaderType::Pointer readerVV = ReaderType::New(); NRITOOneCFilterType::Pointer nriToOneCfilter = NRITOOneCFilterType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer paulifilter = FilterType::New(); readerHH->SetFileName(inputFilenameHH); readerHV->SetFileName(inputFilenameHV); readerVV->SetFileName(inputFilenameVV); nriToOneCfilter->SetInput(0,readerHH->GetOutput()); nriToOneCfilter->SetInput(1,readerHV->GetOutput()); nriToOneCfilter->SetInput(2,readerVV->GetOutput()); paulifilter->SetInput(nriToOneCfilter->GetOutput()); writer->SetFileName(outputFilename); writer->SetInput(paulifilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbSinclairImageFilter.cxx000066400000000000000000000132371301006202600273530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSinclairImageFilter.h" #include "otbSinclairToCircularCovarianceMatrixFunctor.h" #include "otbSinclairToCoherencyMatrixFunctor.h" #include "otbSinclairToMuellerMatrixFunctor.h" #include "otbMultiChannelExtractROI.h" int otbSinclairImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef std::complex ComplexType; typedef otb::Image CplxImageType; typedef otb::VectorImage VCplxImageType; typedef otb::SinclairImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } template int generic_SinclairImageFilter(int itkNotUsed(argc), char * argv[]) { const char * outputFilename = argv[4]; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileWriter WriterType; const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * inputFilename3 = argv[3]; typedef otb::Image InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::MultiChannelExtractROI ExtractROIType; typedef otb::SinclairImageFilter FilterType; typename FilterType::Pointer filter = FilterType::New(); typename ReaderType::Pointer reader1 = ReaderType::New(); typename ReaderType::Pointer reader2 = ReaderType::New(); typename ReaderType::Pointer reader3 = ReaderType::New(); reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); reader3->SetFileName(inputFilename3); filter->SetInputHH(reader1->GetOutput()); filter->SetInputHV(reader2->GetOutput()); filter->SetInputVH(reader2->GetOutput()); filter->SetInputVV(reader3->GetOutput()); filter->UpdateOutputInformation(); typename ExtractROIType::Pointer extract = ExtractROIType::New(); extract->SetStartX(10); extract->SetStartY(10); extract->SetSizeX(30); extract->SetSizeY(30); extract->SetInput(filter->GetOutput()); typename WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput( extract->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } int otbSinclairImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; typedef double OutputRealPixelType; typedef otb::Image InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::VectorImage OutputRealImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "SinclairToCovarianceMatrix") return (generic_SinclairImageFilter > (argc, argv)); else if (strArgv == "SinclairToCircularCovarianceMatrix") return (generic_SinclairImageFilter > (argc, argv)); else if (strArgv == "SinclairToCoherencyMatrix") return (generic_SinclairImageFilter > (argc, argv)); else if (strArgv == "SinclairToMuellerMatrix") return (generic_SinclairImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbSinclairReciprocalImageFilter.cxx000066400000000000000000000114661301006202600313610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSinclairReciprocalImageFilter.h" #include "otbSinclairToReciprocalCircularCovarianceMatrixFunctor.h" #include "otbSinclairToReciprocalCoherencyMatrixFunctor.h" #include "otbMultiChannelExtractROI.h" int otbSinclairReciprocalImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef std::complex ComplexType; typedef otb::Image CplxImageType; typedef otb::VectorImage VCplxImageType; typedef otb::SinclairReciprocalImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } template int generic_SinclairReciprocalImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename1 = argv[1]; const char * inputFilename2 = argv[2]; const char * inputFilename3 = argv[3]; const char * outputFilename = argv[4]; typedef otb::Image InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelExtractROI ExtractROIType; typedef otb::SinclairReciprocalImageFilter FilterType; typename FilterType::Pointer filter = FilterType::New(); typename ReaderType::Pointer reader1 = ReaderType::New(); typename ReaderType::Pointer reader2 = ReaderType::New(); typename ReaderType::Pointer reader3 = ReaderType::New(); reader1->SetFileName(inputFilename1); reader2->SetFileName(inputFilename2); reader3->SetFileName(inputFilename3); filter->SetInputHH(reader1->GetOutput()); filter->SetInputHV_VH(reader2->GetOutput()); filter->SetInputVV(reader3->GetOutput()); typename ExtractROIType::Pointer extract = ExtractROIType::New(); extract->SetStartX(10); extract->SetStartY(10); extract->SetSizeX(30); extract->SetSizeY(30); extract->SetInput( filter->GetOutput() ); typename WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput( extract->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } int otbSinclairReciprocalImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; typedef otb::Image InputImageType; typedef otb::VectorImage OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "SinclairToReciprocalCovarianceMatrix") return (generic_SinclairReciprocalImageFilter > (argc, argv)); else if (strArgv == "SinclairToReciprocalCircularCovarianceMatrix") return (generic_SinclairReciprocalImageFilter > (argc, argv)); else if (strArgv == "SinclairToReciprocalCoherencyMatrix") return (generic_SinclairReciprocalImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Polarimetry/test/otbSinclairToCircularCovarianceMatrixFunctor.cxx000066400000000000000000000044761301006202600337600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSinclairToCircularCovarianceMatrixFunctor.h" #include "itkVariableLengthVector.h" int otbSinclairToCircularCovarianceMatrixFunctor(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef std::complex ComplexType; typedef itk::VariableLengthVector OutputType; typedef otb::Functor::SinclairToCircularCovarianceMatrixFunctor FunctorType; OutputType result(10); FunctorType funct; OutputType outputFunct; result[0] = ComplexType( 32., 0. ); result[1] = ComplexType( 24., 0. ); result[2] = ComplexType( 16., 0.); result[3] = ComplexType( 8., 0 ); result[4] = ComplexType( 18., 0. ); result[5] = ComplexType( 12. , 0. ); result[6] = ComplexType( 6. , 0. ); result[7] = ComplexType( 8, 0. ); result[8] = ComplexType( 4., 0. ); result[9] = ComplexType( 2, 0. ); outputFunct = funct.operator ()( ComplexType(1., 4.), ComplexType(2., 3.), ComplexType(3., 2.), ComplexType(4., 1.) ); if( vcl_abs(result[0]-outputFunct[0]) > 1e-10 || vcl_abs(result[1]-outputFunct[1]) > 1e-10 || vcl_abs(result[2]-outputFunct[2]) > 1e-10 || vcl_abs(result[3]-outputFunct[3]) > 1e-10 || vcl_abs(result[4]-outputFunct[4]) > 1e-10 || vcl_abs(result[5]-outputFunct[5]) > 1e-10 || vcl_abs(result[6]-outputFunct[6]) > 1e-10 || vcl_abs(result[7]-outputFunct[7]) > 1e-10 || vcl_abs(result[8]-outputFunct[8]) > 1e-10 || vcl_abs(result[9]-outputFunct[9]) > 1e-10) { std::cout<<"Test gives :"< ComplexType; typedef itk::VariableLengthVector OutputType; typedef otb::Functor::SinclairToCoherencyMatrixFunctor FunctorType; OutputType result(10); FunctorType funct; OutputType outputFunct; result[0] = ComplexType(25., 0.); result[1] = ComplexType( 0., -15.); result[2] = ComplexType(25., 0.); result[3] = ComplexType(-5., 0.); result[4] = ComplexType( 9., 0.); result[5] = ComplexType( 0., 15.); result[6] = ComplexType( 0., -3.); result[7] = ComplexType(25., 0.); result[8] = ComplexType(-5., 0.); result[9] = ComplexType( 1., 0.); outputFunct = funct.operator ()( ComplexType(1., 4.), ComplexType(2., 3.), ComplexType(3., 2.), ComplexType(4., 1.) ); if( vcl_abs(result[0]-outputFunct[0]) > 1e-10 || vcl_abs(result[1]-outputFunct[1]) > 1e-10 || vcl_abs(result[2]-outputFunct[2]) > 1e-10 || vcl_abs(result[3]-outputFunct[3]) > 1e-10 || vcl_abs(result[4]-outputFunct[4]) > 1e-10 || vcl_abs(result[5]-outputFunct[5]) > 1e-10 || vcl_abs(result[6]-outputFunct[6]) > 1e-10 || vcl_abs(result[7]-outputFunct[7]) > 1e-10 || vcl_abs(result[8]-outputFunct[8]) > 1e-10 || vcl_abs(result[9]-outputFunct[9]) > 1e-10) { std::cout<<"Test gives :"< ComplexType; typedef itk::VariableLengthVector OutputType; typedef otb::Functor::SinclairToCovarianceMatrixFunctor FunctorType; OutputType result(10); FunctorType funct; OutputType outputFunct; result[0] = ComplexType(17., 0. ); result[1] = ComplexType(14., 5.); result[2] = ComplexType(11., 10.); result[3] = ComplexType( 8., 15.); result[4] = ComplexType(13., 0.); result[5] = ComplexType(12., 5.); result[6] = ComplexType(11., 10.); result[7] = ComplexType(13., 0.); result[8] = ComplexType(14., 5.); result[9] = ComplexType(17., 0.); outputFunct = funct.operator ()( ComplexType(1., 4.), ComplexType(2., 3.), ComplexType(3., 2.), ComplexType(4., 1.) ); if( vcl_abs(result[0]-outputFunct[0]) > 1e-10 || vcl_abs(result[1]-outputFunct[1]) > 1e-10 || vcl_abs(result[2]-outputFunct[2]) > 1e-10 || vcl_abs(result[3]-outputFunct[3]) > 1e-10 || vcl_abs(result[4]-outputFunct[4]) > 1e-10 || vcl_abs(result[5]-outputFunct[5]) > 1e-10 || vcl_abs(result[6]-outputFunct[6]) > 1e-10 || vcl_abs(result[7]-outputFunct[7]) > 1e-10 || vcl_abs(result[8]-outputFunct[8]) > 1e-10 || vcl_abs(result[9]-outputFunct[9]) > 1e-10) { std::cout<<"Test gives :"< ComplexType; typedef itk::VariableLengthVector OutputType; typedef otb::Functor::SinclairToMuellerMatrixFunctor FunctorType; OutputType result(16); FunctorType funct; OutputType outputFunct; result[0] = 30.; result[1] = 0.; result[2] = 28.; result[3] = 10.; result[4] = 0.; result[5] = 4.; result[6] = 0.; result[7] = 0.; result[8] = -22.; result[9] = 0.; result[10] = -20.; result[11] = -10.; result[12] = 20.; result[13] = 0.; result[14] = 20.; result[15] = 4.; outputFunct = funct.operator ()( ComplexType(1., 4.), ComplexType(2., 3.), ComplexType(3., 2.), ComplexType(4., 1.) ); if( vcl_abs(result[0]-outputFunct[0]) > 1e-10 || vcl_abs(result[1]-outputFunct[1]) > 1e-10 || vcl_abs(result[2]-outputFunct[2]) > 1e-10 || vcl_abs(result[3]-outputFunct[3]) > 1e-10 || vcl_abs(result[4]-outputFunct[4]) > 1e-10 || vcl_abs(result[5]-outputFunct[5]) > 1e-10 || vcl_abs(result[6]-outputFunct[6]) > 1e-10 || vcl_abs(result[7]-outputFunct[7]) > 1e-10 || vcl_abs(result[8]-outputFunct[8]) > 1e-10 || vcl_abs(result[9]-outputFunct[9]) > 1e-10 || vcl_abs(result[10]-outputFunct[10]) > 1e-10 || vcl_abs(result[11]-outputFunct[11]) > 1e-10 || vcl_abs(result[12]-outputFunct[12]) > 1e-10 || vcl_abs(result[13]-outputFunct[13]) > 1e-10 || vcl_abs(result[14]-outputFunct[14]) > 1e-10 || vcl_abs(result[15]-outputFunct[15]) > 1e-10 ) { std::cout<<"Test gives :"< ComplexType; typedef itk::VariableLengthVector OutputType; typedef otb::Functor::SinclairToReciprocalCircularCovarianceMatrixFunctor FunctorType; OutputType result(6); FunctorType funct; OutputType outputFunct; result[0] = ComplexType( 25., 0.); result[1] = ComplexType( 25.4558441227157,-1.4142135623731); result[2] = ComplexType( 11., -2.); result[3] = ComplexType( 26., 0.); result[4] = ComplexType( 11.3137084989848,-1.41421356237309); result[5] = ComplexType( 5, .0); outputFunct = funct.operator ()( ComplexType(1., 4.), ComplexType(2., 3.), ComplexType(3., 2.) ); if( vcl_abs(result[0]-outputFunct[0]) > 1e-10 || vcl_abs(result[1]-outputFunct[1]) > 1e-10 || vcl_abs(result[2]-outputFunct[2]) > 1e-10 || vcl_abs(result[3]-outputFunct[3]) > 1e-10 || vcl_abs(result[4]-outputFunct[4]) > 1e-10 || vcl_abs(result[5]-outputFunct[5]) > 1e-10 ) { std::cout.precision(15); std::cout<<"Test gives :"< ComplexType; typedef itk::VariableLengthVector OutputType; typedef otb::Functor::SinclairToReciprocalCoherencyMatrixFunctor FunctorType; OutputType result(6); FunctorType funct; OutputType outputFunct; result[0] = ComplexType(26., 0.); result[1] = ComplexType( 2., -10.); result[2] = ComplexType(26., 0.); result[3] = ComplexType( 4., 0.); result[4] = ComplexType( 2., 10.); result[5] = ComplexType(26., 0.); outputFunct = funct.operator ()( ComplexType(1., 4.), ComplexType(2., 3.), ComplexType(3., 2.) ); if( vcl_abs(result[0]-outputFunct[0]) > 1e-10 || vcl_abs(result[1]-outputFunct[1]) > 1e-10 || vcl_abs(result[2]-outputFunct[2]) > 1e-10 || vcl_abs(result[3]-outputFunct[3]) > 1e-10 || vcl_abs(result[4]-outputFunct[4]) > 1e-10 || vcl_abs(result[5]-outputFunct[5]) > 1e-10 ) { std::cout<<"Test gives :"< ComplexType; typedef itk::VariableLengthVector OutputType; typedef otb::Functor::SinclairToReciprocalCovarianceMatrixFunctor FunctorType; OutputType result(6); FunctorType funct; OutputType outputFunct; result[0] = ComplexType(17., 0.); result[1] = ComplexType(19.7989898732233,7.07106781186548); result[2] = ComplexType(11., 10.); result[3] = ComplexType(26., 0.); result[4] = ComplexType(16.9705627484771,7.07106781186548); result[5] = ComplexType(13., 0.); outputFunct = funct.operator ()( ComplexType(1., 4.), ComplexType(2., 3.), ComplexType(3., 2.) ); if( vcl_abs(result[0]-outputFunct[0]) > 1e-10 || vcl_abs(result[1]-outputFunct[1]) > 1e-10 || vcl_abs(result[2]-outputFunct[2]) > 1e-10 || vcl_abs(result[3]-outputFunct[3]) > 1e-10 || vcl_abs(result[4]-outputFunct[4]) > 1e-10 || vcl_abs(result[5]-outputFunct[5]) > 1e-10) { std::cout<<"Test gives :"< #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelsPolarimetricSynthesisFilter.h" int otbVectorMultiChannelsPolarimetricSynthesisFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; double PsiI = strtod(argv[3], ITK_NULLPTR); double KhiI = strtod(argv[4], ITK_NULLPTR); double PsiR = strtod(argv[5], ITK_NULLPTR); double KhiR = strtod(argv[6], ITK_NULLPTR); typedef std::complex InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelsPolarimetricSynthesisFilter FilterType; FilterType::Pointer polarimetricSynthesis = FilterType::New(); polarimetricSynthesis->SetPsiI(PsiI); polarimetricSynthesis->SetKhiI(KhiI); polarimetricSynthesis->SetPsiR(PsiR); polarimetricSynthesis->SetKhiR(KhiR); polarimetricSynthesis->SetEmissionH(true); polarimetricSynthesis->SetEmissionV(true); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); polarimetricSynthesis->SetInput(reader->GetOutput()); writer->SetInput(polarimetricSynthesis->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/000077500000000000000000000000001301006202600210655ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Projection/CMakeLists.txt000066400000000000000000000001251301006202600236230ustar00rootroot00000000000000project(OTBProjection) set(OTBProjection_LIBRARIES OTBProjection) otb_module_impl() OTB-release-5.8/Modules/Filtering/Projection/include/000077500000000000000000000000001301006202600225105ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Projection/include/otbEckert4MapProjection.h000066400000000000000000000044051301006202600273650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEckert4MapProjection_h #define otbEckert4MapProjection_h #include "otbGenericMapProjection.h" namespace otb { /** \class Eckert4MapProjection * \brief This class implements the Eckert4 map projection. * * It converts coordinates in longitude, latitude (WGS84) to Eckert4 map coordinates. * * \ingroup OTBProjection */ template class ITK_EXPORT Eckert4MapProjection : public GenericMapProjection { public: /** Standard class typedefs. */ typedef Eckert4MapProjection Self; typedef GenericMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Eckert4MapProjection, GenericMapProjection); virtual void SetFalseEasting(double falseEasting); virtual void SetFalseNorthing(double falseNorthing); virtual double GetFalseNorthing() const; virtual double GetFalseEasting() const; virtual void SetParameters(double falseEasting, double falseNorthing); using Superclass::SetParameters; protected: Eckert4MapProjection(); ~Eckert4MapProjection() ITK_OVERRIDE; private: Eckert4MapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbEckert4MapProjection.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbEckert4MapProjection.txx000066400000000000000000000047511301006202600277650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEckert4MapProjection_txx #define otbEckert4MapProjection_txx #include "otbEckert4MapProjection.h" #include "otbUtils.h" namespace otb { template Eckert4MapProjection ::Eckert4MapProjection() { this->SetWkt("ossimEckert4Projection"); } template Eckert4MapProjection ::~Eckert4MapProjection() { } ///False easting specification template void Eckert4MapProjection ::SetFalseEasting(double falseEasting) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->Modified(); } ///False Northing specification template void Eckert4MapProjection ::SetFalseNorthing(double falseNorthing) { this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } ///Get the false northing coordinates (avoid negative values) template double Eckert4MapProjection ::GetFalseNorthing() const { double falseNorthing = atof(this->GetParameter("FalseNorthing").c_str()); return falseNorthing; } ///Get the false easting coordinates (avoid negative values) template double Eckert4MapProjection ::GetFalseEasting() const { double falseEasting = atof(this->GetParameter("FalseEasting").c_str()); return falseEasting; } template void Eckert4MapProjection ::SetParameters(double falseEasting, double falseNorthing) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGCPsToRPCSensorModelImageFilter.h000066400000000000000000000162011301006202600313160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGCPsToRPCSensorModelImageFilter_h #define otbGCPsToRPCSensorModelImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "otbDEMHandler.h" #include "otbImageKeywordlist.h" namespace otb { /** \class GCPsToRPCSensorModelImageFilter * \brief This filter estimates a RPC sensor models from GCPs. * * This filters estimates an RPC sensor model from a list of user * defined GCPs. Internally, it uses an ossimRpcSolver, which performs * the estimation using the well known least-square method. * * The UseImageGCPs flag allows importing GCPs from the image * metadata, if any. * * GCPs can be passed to the filter using one of the AddGCP method * implementation. * * The first implementation takes geographic points with elevation (3D * points). * * The second implementation accepts geographic points without the * elevation information. In this case, either the mean elevation or * an elevation fetch from a SRT directory is used, depending on the * value of the UseDEM flag. * * If UseDEM is set to true, the DEMHandler is used to retrieve the * elevation information. The user can either set its own DEMHandler * using the appropriate setter, or configure the existing internal * DEMHandler using the Getter. * * The RMS (root mean square) ground error is available through the * appropriate getter. * * Please note that GCPs are inferred to be given in physical * coordinates. This is seamless in most cases. * * Please note that at least 16 GCPs are required to estimate a proper * RPC sensor model, although no warning will be reported to the user * if the number of GCPs is lower than 16. * * This filter does not modify the image buffer, but only the * metadata. Therefore, it provides in-place support, which is * enabled by default. Call InPlaceOff() to change the default * behavior. * * The output image can be given to the OrthorectificationFilter. * * * \ingroup OTBProjection */ template class ITK_EXPORT GCPsToRPCSensorModelImageFilter : public itk::CastImageFilter { public: /** Standard class typedefs. */ typedef GCPsToRPCSensorModelImageFilter Self; typedef itk::CastImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** GCPs typedefs */ typedef itk::Point Point2DType; typedef itk::Point Point3DType; typedef std::pair GCPType; typedef std::vector GCPsContainerType; typedef std::vector ErrorsContainerType; typedef itk::ContinuousIndex<> ContinuousIndexType; typedef itk::ContinuousIndex Continuous3DIndexType; /** DEM typedef */ typedef otb::DEMHandler DEMHandlerType; typedef typename DEMHandlerType::Pointer DEMHandlerPointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GCPsToRPCSensorModelImageFilter, CastImageFilter); /** Extract dimension from input and output image. */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Set/Get/toogle the UseImageGCPs flag */ // itkSetMacro(UseImageGCPs, bool); // itkGetMacro(UseImageGCPs, bool); // itkBooleanMacro(UseImageGCPs); void SetUseImageGCPs(bool use); void LoadImageGCPs(); /** Set/Get/toogle the UseDEM flag */ itkSetMacro(UseDEM, bool); itkGetMacro(UseDEM, bool); itkBooleanMacro(UseDEM); /** Set/Get the mean elevation */ itkSetMacro(MeanElevation, double); itkGetConstReferenceMacro(MeanElevation, double); /** Set/Get the DEMHandler */ itkSetObjectMacro(DEMHandler, DEMHandlerType); itkGetObjectMacro(DEMHandler, DEMHandlerType); /** Get the residual ground error */ itkGetConstReferenceMacro(RMSGroundError, double); /** Get the Error container */ ErrorsContainerType& GetErrorsContainer(); /** Get the mean error */ itkGetConstReferenceMacro(MeanError, double); /** Get the GCPsContainer * \return The GCPs container */ GCPsContainerType& GetGCPsContainer(); /** Set the GCP container */ void SetGCPsContainer(const GCPsContainerType& container); /** Get Keywordlist */ itkGetConstReferenceMacro(Keywordlist, ImageKeywordlist); /** Add a GCP to the GCPContainer. This version of the AddGCP method * accepts a 3D ground point and does not use DEM or MeanElevation * to handle the elevation */ void AddGCP(const Point2DType& sensorPoint, const Point3DType& groundPoint); /** Add A GCP to the GCPContainer. This version of the AddGCP method * accepts a 3D ground point and use the DEM or MeanElevation to get * the corresponding elevation before calling the AddGCP acception 3D * ground points.*/ void AddGCP(const Point2DType& sensorPoint, const Point2DType& groundPoint); /** Remove a GCP given by it's coordinates */ void RemoveGCP(unsigned int id); /** Clear all GCPs */ void ClearGCPs(); protected: /** Constructor */ GCPsToRPCSensorModelImageFilter(); /** Destructor */ ~GCPsToRPCSensorModelImageFilter() ITK_OVERRIDE; /** The PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Actual estimation of the sensor model takes place in the * GenerateOutputInformation() method */ void GenerateOutputInformation() ITK_OVERRIDE; /** Drive the model up-to-date flag */ void Modified() const ITK_OVERRIDE; private: GCPsToRPCSensorModelImageFilter (const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** Transform all GCPs and compute the error and mean error */ void ComputeErrors(); /** True to use GCPs from image metadata as well */ bool m_UseImageGCPs; /** The residual ground error */ double m_RMSGroundError; /** The GCP error list */ ErrorsContainerType m_ErrorsContainer; /** The mean error */ double m_MeanError; /** True if a DEM should be used */ bool m_UseDEM; /** If no DEM is used, a MeanElevation * over the image is used instead */ double m_MeanElevation; /** The DEMHandler */ DEMHandlerPointerType m_DEMHandler; /** Container of GCPs */ GCPsContainerType m_GCPsContainer; /** Keywordlist */ ImageKeywordlist m_Keywordlist; /** Flag to see if model is up-to-date */ mutable bool m_ModelUpToDate; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGCPsToRPCSensorModelImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGCPsToRPCSensorModelImageFilter.txx000066400000000000000000000212331301006202600317130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGCPsToRPCSensorModelImageFilter_txx #define otbGCPsToRPCSensorModelImageFilter_txx #include "otbGCPsToRPCSensorModelImageFilter.h" #include "otbRPCSolverAdapter.h" #include "otbGenericRSTransform.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" namespace otb { template GCPsToRPCSensorModelImageFilter ::GCPsToRPCSensorModelImageFilter() : m_UseImageGCPs(false), m_RMSGroundError(0.), m_ErrorsContainer(), m_MeanError(0.), m_UseDEM(false), m_MeanElevation(0.), m_DEMHandler(), m_GCPsContainer(), m_ModelUpToDate(false) { // This filter does not modify the image buffer, but only its // metadata.Therefore, it can be run inplace to reduce memory print. // CastImageFilter has InPlaceOff by default (see UnaryFunctorImgeFilter constructor) this->InPlaceOn(); // Clear the GCPs container this->ClearGCPs(); /** Create the DEM handler */ m_DEMHandler = DEMHandler::Instance(); } template GCPsToRPCSensorModelImageFilter ::~GCPsToRPCSensorModelImageFilter() { // Clear the GCPs container this->ClearGCPs(); } template void GCPsToRPCSensorModelImageFilter ::Modified() const { // Call superclass implementation this->Superclass::Modified(); // Deactivate up-to-date flag m_ModelUpToDate = false; } template typename GCPsToRPCSensorModelImageFilter ::GCPsContainerType& GCPsToRPCSensorModelImageFilter ::GetGCPsContainer() { // return the GCPs container return m_GCPsContainer; } template typename GCPsToRPCSensorModelImageFilter ::ErrorsContainerType& GCPsToRPCSensorModelImageFilter ::GetErrorsContainer() { // return the GCPs container return m_ErrorsContainer; } template void GCPsToRPCSensorModelImageFilter ::SetGCPsContainer(const GCPsContainerType& container) { // Set the GCPs container m_GCPsContainer = container; // Call modified method this->Modified(); } template void GCPsToRPCSensorModelImageFilter ::AddGCP(const Point2DType& sensorPoint, const Point3DType& groundPoint) { // Create a new GCP GCPType newGCP(sensorPoint, groundPoint); // Add it to the container m_GCPsContainer.push_back(newGCP); // Call the modified method */ this->Modified(); } template void GCPsToRPCSensorModelImageFilter ::AddGCP(const Point2DType& sensorPoint, const Point2DType& groundPoint) { // Create the ground point with elevation Point3DType groundPointWithElevation; // Fill it with ground point data groundPointWithElevation[0] = groundPoint[0]; groundPointWithElevation[1] = groundPoint[1]; // Check whether we are using a DEM or not if (m_UseDEM) { // If so, use it to get the elevation double height = m_DEMHandler->GetHeightAboveEllipsoid(groundPoint); // To avoid nan value if (height != height) height = 0; groundPointWithElevation[2] = height; } else { // Use the MeanElevation value groundPointWithElevation[2] = m_MeanElevation; } // Call the 3D version of the method this->AddGCP(sensorPoint, groundPointWithElevation); } template void GCPsToRPCSensorModelImageFilter ::RemoveGCP(unsigned int id) { if (id < m_GCPsContainer.size()) { m_GCPsContainer.erase(m_GCPsContainer.begin() + id); } this->Modified(); } template void GCPsToRPCSensorModelImageFilter ::ClearGCPs() { m_GCPsContainer.clear(); this->Modified(); } template void GCPsToRPCSensorModelImageFilter ::SetUseImageGCPs(bool use) { // Set the internal value m_UseImageGCPs = use; this->LoadImageGCPs(); } template void GCPsToRPCSensorModelImageFilter ::LoadImageGCPs() { // First, retrieve the image pointer typename TImage::Pointer imagePtr = this->GetOutput(); // Iterate on the image GCPs for (unsigned int i = 0; i < imagePtr->GetGCPCount(); ++i) { // Store row/col in an index typename TImage::IndexType index; index[0] = static_cast(imagePtr->GetGCPCol(i)); index[1] = static_cast(imagePtr->GetGCPRow(i)); // Transform to physical point Point2DType sensorPoint; imagePtr->TransformIndexToPhysicalPoint(index, sensorPoint); // Sensor and Ground points Point3DType groundPoint; groundPoint[0] = imagePtr->GetGCPX(i); // Lon groundPoint[1] = imagePtr->GetGCPY(i); // Lat groundPoint[2] = imagePtr->GetGCPZ(i); // Search image GCPs and remove them from container bool found = false; unsigned int currentGCP = 0; while ((currentGCP < m_GCPsContainer.size()) && !found) { if ((m_GCPsContainer[currentGCP].first == sensorPoint) && (m_GCPsContainer[currentGCP].second == groundPoint)) { // If we don't use image GCPs, erase the GCP if (!m_UseImageGCPs) m_GCPsContainer.erase(m_GCPsContainer.begin() + currentGCP); found = true; } currentGCP++; } // If we use image GCPs, add it to the container if (m_UseImageGCPs && !found) this->AddGCP(sensorPoint, groundPoint); } this->Modified(); } template void GCPsToRPCSensorModelImageFilter ::ComputeErrors() { typedef GenericRSTransform RSTransformType; RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetInputKeywordList(m_Keywordlist); rsTransform->InstantiateTransform(); ContinuousIndexType idFix, idOut; Continuous3DIndexType idOut3D, idTrans3D; Point2DType sensorPoint; Point3DType groundPoint; double sum = 0.; m_MeanError = 0.; // Clear Error container m_ErrorsContainer.clear(); for (unsigned int i = 0; i < m_GCPsContainer.size(); ++i) { // GCP value sensorPoint = m_GCPsContainer[i].first; groundPoint = m_GCPsContainer[i].second; // Compute Transform Point3DType groundPointTemp, sensorPointTemp; sensorPointTemp[0] = sensorPoint[0]; sensorPointTemp[1] = sensorPoint[1]; sensorPointTemp[2] = groundPoint[2]; groundPointTemp = rsTransform->TransformPoint(sensorPointTemp); // Compute Euclidian distance idFix[0] = sensorPoint[0]; idFix[1] = sensorPoint[1]; idOut3D[0] = groundPoint[0]; idOut3D[1] = groundPoint[1]; idOut3D[2] = groundPoint[2]; idTrans3D[0] = groundPointTemp[0]; idTrans3D[1] = groundPointTemp[1]; idTrans3D[2] = groundPointTemp[2]; double error = idOut3D.EuclideanDistanceTo(idTrans3D); // Add error to the container m_ErrorsContainer.push_back(error); // Compute mean error sum += error; } m_MeanError = sum / static_cast(m_ErrorsContainer.size()); } template void GCPsToRPCSensorModelImageFilter ::GenerateOutputInformation() { // First, call the superclass implementation Superclass::GenerateOutputInformation(); // First, retrieve the image pointer typename TImage::Pointer imagePtr = this->GetOutput(); if(!m_ModelUpToDate) { double rmsError; ImageKeywordlist otb_kwl; otb::RPCSolverAdapter::Solve(m_GCPsContainer, rmsError, otb_kwl); // Retrieve the residual ground error m_RMSGroundError = rmsError; // Compute errors this->ComputeErrors(); m_Keywordlist = otb_kwl; m_ModelUpToDate = true; } // Update image keywordlist. We need to do it at each stream // because it will be overwritten by up-stream // GenerateOutputInformation() calls. itk::MetaDataDictionary& dict = imagePtr->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, m_Keywordlist); } template void GCPsToRPCSensorModelImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "UseImageGCPs: " << (m_UseImageGCPs ? "yes" : "no") << std::endl; os << indent << "UseDEM: " << (m_UseDEM ? "yes" : "no") << std::endl; if (!m_UseDEM) { os << indent << "MeanElevation: " << m_MeanElevation << std::endl; } os << indent << "RMS ground error: " << m_RMSGroundError << std::endl; } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGenericRSResampleImageFilter.h000066400000000000000000000251021301006202600310110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericRSResampleImageFilter_h #define otbGenericRSResampleImageFilter_h #include "otbStreamingResampleImageFilter.h" #include "otbPhysicalToRPCSensorModelImageFilter.h" namespace otb { /** \class GenericRSResampleImageFilter * \brief This class is a composite filter that allows you to project * an input image from any coordinate system to any other one. The * coordinate systems can be defined by their projection reference, * the keyword list or a meta data dictionary. * * This class uses the otb::StreamingResampleImageFilter. It defines * and uses a otb::GenericRSTransform using the input/output coordinate * system information listed below. This class can resample the input to an * output image with the Size/Origin/Spacing/StartIndex defined by * the user. Note that there are no default values for all the * parmeters, so it is mandatory to set correct parameters to have a * correct result. * * The methods SetOutputParmatersFromMap can estimate the output * image parameters Size/Origin/Spacing so the hole image can be * reprojected without setting any output parameter. * * \ingroup Projection * * * \ingroup OTBProjection **/ template class ITK_EXPORT GenericRSResampleImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef GenericRSResampleImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GenericRSResampleImageFilter, itk::ImageToImageFilter); /** Typedef parameters*/ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::PointType OutputPointType; /** Internal filters typedefs*/ typedef StreamingResampleImageFilter ResamplerType; typedef typename ResamplerType::Pointer ResamplerPointerType; typedef typename ResamplerType::TransformType TransformType; typedef typename ResamplerType::SizeType SizeType; typedef typename ResamplerType::SpacingType SpacingType; typedef typename ResamplerType::OriginType OriginType; typedef typename ResamplerType::IndexType IndexType; typedef typename ResamplerType::RegionType RegionType; typedef typename ResamplerType::InterpolatorType InterpolatorType; /** Estimate the rpc model */ typedef PhysicalToRPCSensorModelImageFilter InputRpcModelEstimatorType; typedef typename InputRpcModelEstimatorType::Pointer InputRpcModelEstimatorPointerType; typedef PhysicalToRPCSensorModelImageFilter OutputRpcModelEstimatorType; typedef typename OutputRpcModelEstimatorType::Pointer OutputRpcModelEstimatorPointerType; /** Specialisation of OptResampleFilter with a remote * sensing transform */ typedef GenericRSTransform<> GenericRSTransformType; typedef typename GenericRSTransformType::Pointer GenericRSTransformPointerType; typedef itk::ImageBase ImageBaseType; /** The Displacement field spacing & size */ otbSetObjectMemberMacro(Resampler, DisplacementFieldSpacing, SpacingType); otbGetObjectMemberConstReferenceMacro(Resampler, DisplacementFieldSpacing, SpacingType); /** The resampled image parameters */ /** Output Origin */ void SetOutputOrigin(const OriginType & origin) { m_Resampler->SetOutputOrigin(origin); this->Modified(); } otbGetObjectMemberConstReferenceMacro(Resampler, OutputOrigin, OriginType); /** Output Start index */ otbSetObjectMemberMacro(Resampler, OutputStartIndex, IndexType); otbGetObjectMemberConstReferenceMacro(Resampler, OutputStartIndex, IndexType); /** Output Size */ otbSetObjectMemberMacro(Resampler, OutputSize, SizeType); otbGetObjectMemberConstReferenceMacro(Resampler, OutputSize, SizeType); /** Output Spacing */ otbSetObjectMemberMacro(Resampler, OutputSpacing, SpacingType); otbGetObjectMemberConstReferenceMacro(Resampler, OutputSpacing, SpacingType); /** Methods to Set/Get the interpolator */ void SetInterpolator(InterpolatorType * interpolator) { m_Resampler->SetInterpolator(interpolator); this->Modified(); } otbGetObjectMemberConstMacro(Resampler, Interpolator, const InterpolatorType *); /** Default Edge padding value */ otbSetObjectMemberMacro(Resampler, EdgePaddingValue, typename OutputImageType::PixelType); otbGetObjectMemberMacro(Resampler, EdgePaddingValue, typename OutputImageType::PixelType); /** * Set/Get input & output projections. * Set/Get input & output keywordlist * The macro are not used here cause the input and the output are * inversed. */ void SetInputProjectionRef(const std::string& ref) { m_Transform->SetOutputProjectionRef(ref); this->Modified(); } std::string GetInputProjectionRef() const { return m_Transform->GetOutputProjectionRef(); } void SetOutputProjectionRef(const std::string& ref) { m_Transform->SetInputProjectionRef(ref); this->Modified(); } std::string GetOutputProjectionRef() const { return m_Transform->GetInputProjectionRef(); } /** Set/Get Input Keywordlist*/ void SetInputKeywordList(const ImageKeywordlist& kwl) { m_Transform->SetOutputKeywordList(kwl); this->Modified(); } const ImageKeywordlist GetInputKeywordList() { return m_Transform->GetOutputKeywordList(); } /** Set/Get output Keywordlist*/ void SetOutputKeywordList(const ImageKeywordlist& kwl) { m_Transform->SetInputKeywordList(kwl); this->Modified(); } const ImageKeywordlist GetOutputKeywordList() { return m_Transform->GetInputKeywordList(); } /** Useful to set the output parameters from an existing image*/ void SetOutputParametersFromImage(const ImageBaseType * image); /** Useful to set output parmaters form an existing image with type * different from input or output image */ template void SetOutputParametersFromImage(const TImageType * image); /** Useful to set the output parameters using a map (UTM|WGS84) and * a spacing set by the user */ void SetOutputParametersFromMap(const std::string map, const SpacingType& spacing); /** Useful to set the output parameters from a projectionRef, the * output size, spacing and origin are estimated */ void SetOutputParametersFromMap(const std::string projectionRef); /** Set/Get the grid size for rpc estimator*/ void SetInputRpcGridSize(const SizeType& gridSize) { m_InputRpcEstimator->SetGridSize(gridSize); this->Modified(); } /** unsigned int as parameter */ void SetInputRpcGridSize(unsigned int gridSize) { m_InputRpcEstimator->SetGridSize(gridSize); this->Modified(); } /** Get the input rpc model estimator grid size used */ const SizeType & GetInputRpcGridSize() const { return m_InputRpcEstimator->GetGridSize(); } /** Macro to tune the EstimateInputRpcModel flag */ itkSetMacro(EstimateInputRpcModel, bool); itkGetMacro(EstimateInputRpcModel, bool); itkBooleanMacro(EstimateInputRpcModel); /** Macro to Set/Get the grid size for rpc estimator*/ void SetOutputRpcGridSize(const SizeType& gridSize) { m_OutputRpcEstimator->SetGridSize(gridSize); this->Modified(); } /** unsigned int as parameter */ void SetOutputRpcGridSize(unsigned int gridSize) { m_OutputRpcEstimator->SetGridSize(gridSize); this->Modified(); } /** Get the output rpc model estimator grid size used */ const SizeType & GetOutputRpcGridSize() const { return m_OutputRpcEstimator->GetGridSize(); } /** Macro to tune the EstimateOutputRpcModel flag */ itkSetMacro(EstimateOutputRpcModel, bool); itkGetMacro(EstimateOutputRpcModel, bool); itkBooleanMacro(EstimateOutputRpcModel); /** Set number of threads for Displacement field generator */ void SetDisplacementFilterNumberOfThreads(unsigned int nbThread) { m_Resampler->SetDisplacementFilterNumberOfThreads(nbThread); } /** Override itk::ProcessObject method to let the internal filter do the propagation */ void PropagateRequestedRegion(itk::DataObject *output) ITK_OVERRIDE; protected: GenericRSResampleImageFilter(); /** Destructor */ ~GenericRSResampleImageFilter() ITK_OVERRIDE {}; void GenerateData() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; virtual void UpdateTransform(); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GenericRSResampleImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Method to estimate the input & output rpc model void EstimateOutputRpcModel(); void EstimateInputRpcModel(); // boolean that allow the estimation of the input rpc model bool m_EstimateInputRpcModel; bool m_EstimateOutputRpcModel; bool m_RpcEstimationUpdated; // Filters pointers ResamplerPointerType m_Resampler; InputRpcModelEstimatorPointerType m_InputRpcEstimator; OutputRpcModelEstimatorPointerType m_OutputRpcEstimator; GenericRSTransformPointerType m_Transform; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGenericRSResampleImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGenericRSResampleImageFilter.txx000066400000000000000000000323161301006202600314120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGenericRSResampleImageFilter_txx #define otbGenericRSResampleImageFilter_txx #include "otbGenericRSResampleImageFilter.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "itkProgressAccumulator.h" #include "itkPoint.h" #include "ogr_spatialref.h" #include "cpl_conv.h" #include "otbGeoInformationConversion.h" #include "otbImageToGenericRSOutputParameters.h" namespace otb { template GenericRSResampleImageFilter ::GenericRSResampleImageFilter() { // flags initialization m_EstimateInputRpcModel = false; m_EstimateOutputRpcModel = false; m_RpcEstimationUpdated = false; // internal filters instantiation m_Resampler = ResamplerType::New(); m_InputRpcEstimator = InputRpcModelEstimatorType::New(); m_OutputRpcEstimator= OutputRpcModelEstimatorType::New(); m_Transform = GenericRSTransformType::New(); /** Set number of threads to 1 for Displacement field generator (use for faster access to * OSSIM elevation source, which does not handle multithreading when accessing to DEM data) */ this->SetDisplacementFilterNumberOfThreads(1); } template void GenericRSResampleImageFilter ::GenerateData() { // Set up progress reporting typename itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); progress->RegisterInternalFilter(m_Resampler, 1.f); m_Resampler->GraftOutput(this->GetOutput()); m_Resampler->UpdateOutputData(m_Resampler->GetOutput()); this->GraftOutput(m_Resampler->GetOutput()); } /** * Generate the right output requested region following the * parameters set by the user * */ template void GenericRSResampleImageFilter ::GenerateOutputInformation() { // Estimate the output rpc Model if needed if (m_EstimateOutputRpcModel) this->EstimateOutputRpcModel(); // Estimate the input rpc model if it is needed if (m_EstimateInputRpcModel && !m_RpcEstimationUpdated) { this->EstimateInputRpcModel(); } // Instantiate the RS transform this->UpdateTransform(); m_Resampler->SetInput(this->GetInput()); m_Resampler->SetTransform(m_Transform); m_Resampler->SetDisplacementFieldSpacing(this->GetDisplacementFieldSpacing()); m_Resampler->GraftOutput(this->GetOutput()); m_Resampler->UpdateOutputInformation(); this->GraftOutput(m_Resampler->GetOutput()); // Encapsulate output projRef and keywordlist itk::MetaDataDictionary& dict = this->GetOutput()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, this->GetOutputProjectionRef()); if (this->GetOutputKeywordList().GetSize() > 0) { itk::EncapsulateMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, this->GetOutputKeywordList()); } } /** * Method to estimate the rpc model of the output using a temporary image */ template void GenericRSResampleImageFilter ::EstimateOutputRpcModel() { // Temp image : not allocated but with the same metadata than the // output typename OutputImageType::Pointer tempPtr = OutputImageType::New(); typename OutputImageType::RegionType region; region.SetSize(this->GetOutputSize()); region.SetIndex(this->GetOutputStartIndex() ); tempPtr->SetRegions(region); // Encapsulate the output metadata in the temp image itk::MetaDataDictionary& tempDict = tempPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData(tempDict, MetaDataKey::ProjectionRefKey, this->GetOutputProjectionRef() ); itk::EncapsulateMetaData(tempDict, MetaDataKey::OSSIMKeywordlistKey, this->GetOutputKeywordList()); // Estimate the rpc model from the temp image m_OutputRpcEstimator->SetInput(tempPtr); m_OutputRpcEstimator->UpdateOutputInformation(); // Encapsulate the estimated rpc model in the output if (m_OutputRpcEstimator->GetOutput()->GetImageKeywordlist().GetSize() > 0) { // Fill the transform with the right kwl m_Transform->SetInputKeywordList( m_OutputRpcEstimator->GetOutput()->GetImageKeywordlist()); } } /** * Fill with the default dict of the input and the output * and instantiate the transform */ template void GenericRSResampleImageFilter ::UpdateTransform() { if (!m_EstimateInputRpcModel) { m_Transform->SetOutputDictionary(this->GetInput()->GetMetaDataDictionary()); m_Transform->SetOutputProjectionRef(this->GetInput()->GetProjectionRef()); m_Transform->SetOutputKeywordList(this->GetInput()->GetImageKeywordlist()); } m_Transform->InstantiateTransform(); } template void GenericRSResampleImageFilter ::PropagateRequestedRegion(itk::DataObject *output) { if (this->m_Updating) return; // Retrieve output requested region m_Resampler->GetOutput()->SetRequestedRegion(output); m_Resampler->GetOutput()->PropagateRequestedRegion(); } /** * Method to estimate the rpc model of the input using a temporary * image to avoid adding this rpc estimator filter in the minipipeline. * */ template void GenericRSResampleImageFilter ::EstimateInputRpcModel() { // Temp image : not allocated but with the sampe metadata as the // output typename InputImageType::Pointer tempPtr = InputImageType::New(); tempPtr->SetRegions(this->GetInput()->GetLargestPossibleRegion()); tempPtr->CopyInformation(this->GetInput()); // Estimate the rpc model with the temp image m_InputRpcEstimator->SetInput(tempPtr); m_InputRpcEstimator->UpdateOutputInformation(); // No need to ITK_OVERRIDE the input kwl, just setup the // transform with the kwl estimated if(m_InputRpcEstimator->GetInput()->GetImageKeywordlist().GetSize() > 0) m_Transform->SetOutputKeywordList(m_InputRpcEstimator->GetOutput()->GetImageKeywordlist()); // Update the flag for input rpcEstimation in order to not compute // the rpc model for each stream m_RpcEstimationUpdated = true; } /** * Method used to copy the parameters of the input image * */ template void GenericRSResampleImageFilter ::SetOutputParametersFromImage(const ImageBaseType * image) { const InputImageType * src = dynamic_cast(image); this->SetOutputOrigin ( src->GetOrigin() ); this->SetOutputSpacing ( src->GetSpacing() ); this->SetOutputStartIndex ( src->GetLargestPossibleRegion().GetIndex() ); this->SetOutputSize ( src->GetLargestPossibleRegion().GetSize() ); this->SetOutputProjectionRef(src->GetProjectionRef()); this->SetOutputKeywordList(src->GetImageKeywordlist()); } /** * Method used to copy the parameters of the input image * */ template template void GenericRSResampleImageFilter ::SetOutputParametersFromImage(const TImageType * image) { this->SetOutputOrigin ( image->GetOrigin() ); this->SetOutputSpacing ( image->GetSpacing() ); this->SetOutputStartIndex ( image->GetLargestPossibleRegion().GetIndex() ); this->SetOutputSize ( image->GetLargestPossibleRegion().GetSize() ); this->SetOutputProjectionRef(image->GetProjectionRef()); this->SetOutputKeywordList(image->GetImageKeywordlist()); } /** * Method used to project the input image in a defined srs, estimating * the output size and origin. The spacing is set by the user. The * supported projection are UTM and WGS84. * */ template void GenericRSResampleImageFilter ::SetOutputParametersFromMap(const std::string map, const SpacingType& spacing) { // Get the input Image const InputImageType* input = this->GetInput(); // Update the transform with input information // Done here because the transform is not instantiated // yet this->UpdateTransform(); // Needed variable std::string projectionRef; // The inverse transform is need here GenericRSTransformPointerType invTransform = GenericRSTransformType::New(); m_Transform->GetInverse(invTransform); if(strcmp(map.c_str(),"UTM")== 0) { // Build the UTM transform : Need the zone & the hemisphere // For this we us the geographic coordinate of the input UL corner typedef itk::Point GeoPointType; // get the utm zone and hemisphere using the input UL corner // geographic coordinates typename InputImageType::PointType pSrc; IndexType index; GeoPointType geoPoint; index[0] = input->GetLargestPossibleRegion().GetIndex()[0]; index[1] = input->GetLargestPossibleRegion().GetIndex()[1]; input->TransformIndexToPhysicalPoint(index, pSrc); // The first transform of the inverse transform : input -> WGS84 geoPoint = invTransform->GetTransform()->GetFirstTransform()->TransformPoint(pSrc); // Guess the zone and the hemisphere int zone = Utils::GetZoneFromGeoPoint(geoPoint[0], geoPoint[1]); bool hem = (geoPoint[1]>1e-10)?true:false; // Build the output UTM projection ref OGRSpatialReferenceH oSRS = OSRNewSpatialReference(ITK_NULLPTR); OSRSetProjCS(oSRS, "UTM"); OSRSetWellKnownGeogCS(oSRS, "WGS84"); OSRSetUTM(oSRS, zone, hem); char * utmRefC = ITK_NULLPTR; OSRExportToWkt(oSRS, &utmRefC); projectionRef = utmRefC; CPLFree(utmRefC); OSRRelease(oSRS); } else if(strcmp(map.c_str(),"WGS84")==0) { projectionRef = otb::GeoInformationConversion::ToWKT(4326); //WGS84 } else { itkExceptionMacro("The output map "< OutputParametersEstimatorType; typename OutputParametersEstimatorType::Pointer genericRSEstimator = OutputParametersEstimatorType::New(); genericRSEstimator->SetInput(input); genericRSEstimator->SetOutputProjectionRef(projectionRef); genericRSEstimator->ForceSpacingTo(spacing); genericRSEstimator->Compute(); // Update the Output Parameters this->SetOutputProjectionRef(projectionRef); this->SetOutputOrigin(genericRSEstimator->GetOutputOrigin()); this->SetOutputSpacing(genericRSEstimator->GetOutputSpacing()); this->SetOutputSize(genericRSEstimator->GetOutputSize()); this->UpdateTransform(); } /** * Used to project the input image in a srs defined by its WKT * projectionRef (as parameter) only. estimating the output size, spacing * and origin. * */ template void GenericRSResampleImageFilter ::SetOutputParametersFromMap(const std::string projectionRef) { const InputImageType* input = this->GetInput(); // Compute the output parameters typedef otb::ImageToGenericRSOutputParameters OutputParametersEstimatorType; typename OutputParametersEstimatorType::Pointer genericRSEstimator = OutputParametersEstimatorType::New(); genericRSEstimator->SetInput(input); genericRSEstimator->SetOutputProjectionRef(projectionRef); genericRSEstimator->Compute(); // Update the Output Parameters this->SetOutputProjectionRef(projectionRef); this->SetOutputOrigin(genericRSEstimator->GetOutputOrigin()); this->SetOutputSpacing(genericRSEstimator->GetOutputSpacing()); this->SetOutputSize(genericRSEstimator->GetOutputSize()); this->UpdateTransform(); } template void GenericRSResampleImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "EstimateInputRpcModel:" << (m_EstimateInputRpcModel ? "On" : "Off") << std::endl; os << indent << "EstimateOutputRpcModel:" << (m_EstimateOutputRpcModel ? "On" : "Off") << std::endl; os << indent << "RpcEstimationUpdated:" << (m_RpcEstimationUpdated ? "True" : "False") << std::endl; os << indent << "OutputOrigin: " << m_Resampler->GetOutputOrigin() << std::endl; os << indent << "OutputSpacing: " << m_Resampler->GetOutputSpacing() << std::endl; os << indent << "OutputStartIndex: " << m_Resampler->GetOutputStartIndex() << std::endl; os << indent << "OutputSize: " << m_Resampler->GetOutputSize() << std::endl; os << indent << "GenericRSTransform: " << std::endl; m_Transform->Print(os, indent.GetNextIndent()); } } #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGeographicalDistance.h000066400000000000000000000061361301006202600274340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeographicalDistance_h #define otbGeographicalDistance_h #include "itkNumericTraits.h" #include "itkDistanceMetric.h" namespace otb { /** * \class GeographicalDistance * \brief Compute the metric distance between two geographical points * * Vector length must be at least two, otherwise the Evaluate method * will throw an exception. * * First dimension is assumed to be the longitude, and second * dimension is assumed to be the latitude. * * This distance uses the Haversine formula, which can be found here: * http://www.movable-type.co.uk/scripts/latlong.html * * Please note that the computation makes use of the earth radius in * meters. Mean radius (6371 km) is used as a default value, but one * might use local values from spheroid or geoid for better precision. * * * \ingroup OTBProjection */ template class ITK_EXPORT GeographicalDistance : public itk::Statistics::DistanceMetric { public: /** Standard class typedefs. */ typedef GeographicalDistance Self; typedef itk::Statistics::DistanceMetric Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(GeographicalDistance, itk::Statistics::DistanceMetric); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Useful typedefs */ typedef TVector VectorType; /** Gets the distance between the origin point and x. This function * work with SetOrigin() function */ double Evaluate(const VectorType & x) const ITK_OVERRIDE; /* Gets the distance between x and y points */ double Evaluate(const VectorType & x, const VectorType & y) const ITK_OVERRIDE; /** Set the earth radius */ itkSetMacro(EarthRadius, double); /** Get the earth radius */ itkGetMacro(EarthRadius, double); protected: /** Constructor */ GeographicalDistance(); /** Destructor */ ~GeographicalDistance() ITK_OVERRIDE{} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GeographicalDistance(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Earth radius */ double m_EarthRadius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbGeographicalDistance.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGeographicalDistance.txx000066400000000000000000000050751301006202600300310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeographicalDistance_txx #define otbGeographicalDistance_txx #include "otbGeographicalDistance.h" #include "otbMath.h" namespace otb { template GeographicalDistance ::GeographicalDistance() : m_EarthRadius(6371000) {} template double GeographicalDistance ::Evaluate(const VectorType & x) const { // First check if vector length is sufficient if(x.Size()<2) itkExceptionMacro(<<"Vector length must be at least 2 to compute geographical distance."); // Call evaluate implementation with the first point being the // origin VectorType origin(x); origin[0]=this->GetOrigin()[0]; origin[1]=this->GetOrigin()[1]; return this->Evaluate(origin, x); } template double GeographicalDistance ::Evaluate(const VectorType & x, const VectorType & y) const { // First check if vector length is sufficient if(x.Size()<2 || y.Size()<2) itkExceptionMacro(<<"Vector length must be at least 2 to compute geographical distance."); // Build some const variables const double One = itk::NumericTraits::One; const double Two = One + One; const double Deg2Rad = CONST_PI/180.; // Compute latitude and longitude differences double dLat = (vcl_fabs(x[1] - y[1])) * Deg2Rad; double dLon = (vcl_fabs(x[0] - y[0])) * Deg2Rad; // Compute dx in meters double a = vcl_sin(dLat / Two) * vcl_sin(dLat / Two) + vcl_cos(y[1] * Deg2Rad) * vcl_cos( x[1] * Deg2Rad) * vcl_sin(dLon / Two) * vcl_sin(dLon / Two); double c = Two * vcl_atan2(vcl_sqrt(a), vcl_sqrt(One - a)); double d = m_EarthRadius * c; // Return result return d; } template void GeographicalDistance ::PrintSelf(std::ostream & os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); // Earth radius os< ogr::UniqueGeometryPtr operator()(TGeometry const* in) const; private: ReprojectTransformationFunctor const& m_Reprojector; }; /**\ingroup Projection GeometriesFilters * Internal functor used to reproject a \c OGRGeometry: \em In-Place transformation policy. * \since OTB v 3.14.0 */ struct InPlace { InPlace(ReprojectTransformationFunctor const& reprojector) : m_Reprojector(reprojector){} template void operator()(TGeometry * inout) const; private: ReprojectTransformationFunctor const& m_Reprojector; }; ogr::UniqueGeometryPtr operator()(OGRGeometry const* in) const; void apply_inplace (OGRGeometry * inout) const; typedef otb::GenericRSTransform InternalTransformType; typedef InternalTransformType::Pointer InternalTransformPointerType; /** * Setter for the 1-point transformation functor. * \param[in] transform transformation functor to apply on single points. * \throw None */ void SetOnePointTransformation(InternalTransformPointerType transform); private: /** * Transforms one single point thanks to \c m_Transform. * \param[in,out] g point to transform * \throw Whatever is thrown by \c m_Transform::operator() */ void do_transform(OGRPoint & g) const; // void do_transform(OGRLinearRing & g) const; /** * Transforms all the points from a line-string, thanks to \c m_Transform. * \param[in,out] g line-string to transform * \throw Whatever is thrown by \c m_Transform::operator() */ void do_transform(OGRLineString & g) const; // void do_transform(OGRCurve & g) const; /** * Transforms all the rings from a polygon. * \param[in,out] g polygon to transform * \throw Whatever is thrown by \c m_Transform::operator() */ void do_transform(OGRPolygon & g) const; #if 0 void do_transform(OGRSurface & g) const; void do_transform(OGRMultiLineString & g) const; void do_transform(OGRMultiPoint & g) const; void do_transform(OGRMultiPolygon & g) const; #endif /** * Transforms all the geometries from a geometreis collection. * \param[in,out] g polygon to transform * \throw Whatever is thrown by \c m_Transform::operator() */ void do_transform(OGRGeometryCollection & g) const; /** Transformation functor that operates on one single \c OGRPoint. */ InternalTransformPointerType m_Transform; }; } // internal namespace /**\ingroup Projection GeometriesFilters * \class GeometriesProjectionFilter * Projection filter for OGR geometries sets. * \since OTB v 3.14.0 * * \param[in] InputGeometriesSet * \param[in] InputKeywordList if the \em InputGeometriesSet doesn't have a * projection reference (i.e. a \c OGRSpatialReference), this filter will use * the \em InputKeywordList to describe the positionning of the geometries set. * * \param[in,out] OutputGeometriesSet This set of geometries needs to be given to * the filter (in order to set the exact output file/OGR driver). However the * filter is in charge of filling the geometries set. * \param[in] OutputProjectionRef wkt description of the \c OGRSpatialReference * to project the \em InputGeometriesSet into. * \param[in] OutputKeywordList if no \em OutputProjectionRef is set, the * projection will be done according to the \em OutputKeywordList. * * \note Unlike \c VectorDataProjectionFilter, we have to explicitly set which * to use between projection reference or keyword list. There is no \em * MetaDataDictionary property. * * \note This filter does not support \em in-place transformation as the spatial * references of the new layer are expected to change. * * \ingroup OTBProjection */ class OTBProjection_EXPORT GeometriesProjectionFilter : public GeometriesToGeometriesFilter { public: /**\name Standard ITK typedefs */ //@{ typedef GeometriesProjectionFilter Self; typedef GeometriesToGeometriesFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //@} /**\name Standard macros */ //@{ /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GeometriesProjectionFilter, GeometriesToGeometriesFilter); //@} /**\name I/O typedefs */ //@{ typedef Superclass::InputGeometriesType InputGeometriesType; // typedef Superclass::InputGeometriesPointer InputGeometriesPointer; typedef Superclass::OutputGeometriesType OutputGeometriesType; // typedef Superclass::OutputGeometriesPointer OutputGeometriesPointer; typedef ogr::ImageReference ImageReference; //@} private: /** * Hook used to determine the \c OGRSpatialReference when creating a new layer. * \param[in] source source \c Layer for reference (in case it has relevant * information). * \return a \c OGRSpatialReference that matches the \em OutputProjectionRef * of the filter. It's up to the caller to take responsibility of the returned * object. */ OGRSpatialReference* DoDefineNewLayerSpatialReference(ogr::Layer const& source) const ITK_OVERRIDE; /** * Hook that actually filters an OGR \c Layer. * \param[in] source Input layer * \param[in,out] destination Output layer * * Before forwarding the transformation to the \c m_TransformationFunctor, * this specialization finishes initializing the inner transformation functor. * Indeed some values depend on the current layer to reproject and thus, the * inner-filter working on \c ogr::DataSource cannot be globally configured * once and for all. */ void DoProcessLayer(ogr::Layer const& source, ogr::Layer & destination) const ITK_OVERRIDE; /** Hook used to conclude the initialization phase. * Global \c ogr::DataSource settings for the \c m_Transform functor are * forwarded to the functor. \c ogr::Layer specific settings will be set at * the last moment from \c DoProcessLayer(). */ void DoFinalizeInitialization() ITK_OVERRIDE; /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ void DoFinalizeInitialisation() { otbWarningMacro( << "DoFinalizeInitialisation has been deprecated. Please use DoFinalizeInitialization() instead"); this->DoFinalizeInitialization(); } /** * Hook used to define the fields of the new layer. * \param[in] source source \c Layer -- for reference * \param[in,out] dest destination \c Layer * * Just forwards the fields definition to the \c FieldTransformationPolicy * encapsuled in the \c TransformationFunctorDispatcherType. */ void DoDefineNewLayerFields(ogr::Layer const& source, ogr::Layer & dest) const ITK_OVERRIDE; protected: /** Default constructor. */ GeometriesProjectionFilter(); /** Destructor. */ ~GeometriesProjectionFilter() ITK_OVERRIDE; /** Computes output information. * \post \c m_OutputProjectionRef contains all its related meta-data */ void GenerateOutputInformation(void) ITK_OVERRIDE; public: /**\name Image Reference (origin, spacing) */ //@{ void SetInputSpacing(ImageReference::SpacingType const& spacing); void SetOutputSpacing(ImageReference::SpacingType const& spacing); void SetInputOrigin(ImageReference::OriginType const& origin); void SetOutputOrigin(ImageReference::OriginType const& origin); //@} /**\name Keywords lists accessors and mutators */ //@{ itkGetMacro(InputKeywordList, ImageKeywordlist); void SetInputKeywordList(const ImageKeywordlist& kwl); itkGetMacro(OutputKeywordList, ImageKeywordlist); void SetOutputKeywordList(const ImageKeywordlist& kwl); //@} /**\name Projection references accessors and mutators * Projection references accessors and mutators. * As the Input Projection Reference comes from the Input Geometries set, it * can't be set independently. */ //@{ itkSetStringMacro(OutputProjectionRef); itkGetStringMacro(OutputProjectionRef); //@} private: /**\name Functor definition */ //@{ typedef internal::ReprojectTransformationFunctor TransformationFunctorType; typedef TransformationFunctorType::TransformedElementType TransformedElementType; typedef TransformationFunctorDispatcher TransformationFunctorDispatcherType; TransformationFunctorDispatcherType m_TransformationFunctor; //@} /**\name 1 Point Transformation definition */ //@{ typedef TransformationFunctorType::InternalTransformType InternalTransformType; typedef TransformationFunctorType::InternalTransformPointerType InternalTransformPointerType; InternalTransformPointerType m_Transform; //@} /**\name Image Reference (origin, spacing) */ //@{ ImageReference m_InputImageReference; ImageReference m_OutputImageReference; //@} std::string m_OutputProjectionRef; // in WKT format! ImageKeywordlist m_InputKeywordList; ImageKeywordlist m_OutputKeywordList; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGeometriesProjectionFilter.txx" #endif #endif // otbGeometriesProjectionFilter_h OTB-release-5.8/Modules/Filtering/Projection/include/otbGeometriesProjectionFilter.txx000066400000000000000000000061421301006202600312730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeometriesProjectionFilter_txx #define otbGeometriesProjectionFilter_txx /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesProjectionFilter.h" /*===========================================================================*/ /*====================[ ReprojectTransformationFunctor ]=====================*/ /*===========================================================================*/ template inline otb::ogr::UniqueGeometryPtr otb::internal::ReprojectTransformationFunctor::ByCopy::operator()(TGeometry const* in) const { boost::interprocess::unique_ptr out(in ? static_cast (in->clone()) : ITK_NULLPTR); // OGR clone doesn't use covariant return ... if (out) m_Reprojector.do_transform(*out); ogr::UniqueGeometryPtr res(out.release()); return otb::move(res); } template inline void otb::internal::ReprojectTransformationFunctor::InPlace::operator()(TGeometry * inout) const { if (inout) m_Reprojector.do_transform(*inout); } inline void otb::internal::ReprojectTransformationFunctor::SetOnePointTransformation(InternalTransformPointerType transform) { m_Transform = transform; } /*===========================================================================*/ /*======================[ GeometriesProjectionFilter ]=======================*/ /*===========================================================================*/ inline void otb::GeometriesProjectionFilter::SetInputSpacing(ImageReference::SpacingType const& spacing) { m_InputImageReference.SetSpacing(spacing); } inline void otb::GeometriesProjectionFilter::SetOutputSpacing(ImageReference::SpacingType const& spacing) { m_OutputImageReference.SetSpacing(spacing); } inline void otb::GeometriesProjectionFilter::SetInputOrigin(ImageReference::OriginType const& origin) { m_InputImageReference.SetOrigin(origin); } inline void otb::GeometriesProjectionFilter::SetOutputOrigin(ImageReference::OriginType const& origin) { m_OutputImageReference.SetOrigin(origin); } inline void otb::GeometriesProjectionFilter::SetInputKeywordList(const ImageKeywordlist& kwl) { this->m_InputKeywordList = kwl; this->Modified(); } inline void otb::GeometriesProjectionFilter::SetOutputKeywordList(const ImageKeywordlist& kwl) { this->m_OutputKeywordList = kwl; this->Modified(); } #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGroundSpacingImageFunction.h000066400000000000000000000074601301006202600306110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGroundSpacingImageFunction_h #define otbGroundSpacingImageFunction_h #include "itkImageFunction.h" #include "itkNumericTraits.h" #include "otbGenericRSTransform.h" namespace otb { /** * \class GroundSpacingImageFunction * \brief Calculate the approximate ground spacing in X and Y directions * * This uses the 'Haversine' formula to calculate great-circle distances between * the two points (that is, the shortest distance over the Earth's surface) * giving an 'as-the-crow-flies' distance between the points (ignoring any hills!). * * \ingroup ImageFunctions * * \ingroup OTBProjection */ template class ITK_EXPORT GroundSpacingImageFunction : public itk::ImageFunction, TCoordRep> { public: /** Standard class typedefs. */ typedef GroundSpacingImageFunction Self; /** Datatype used for the density */ typedef float ValueType; //typedef std::pair FloatType; typedef itk::Vector FloatType; typedef itk::ImageFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(GroundSpacingImageFunction, itk::ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::OutputType OutputType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef otb::GenericRSTransform TransformType; typedef typename IndexType::IndexValueType IndexValueType; itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ FloatType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ FloatType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } FloatType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } PointType GetPixelLocation(const IndexType& index) const; protected: GroundSpacingImageFunction(); ~GroundSpacingImageFunction() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GroundSpacingImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ValueType m_R; ValueType m_Deg2radCoef; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbGroundSpacingImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbGroundSpacingImageFunction.txx000066400000000000000000000107621301006202600312040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) CS Systemes d'information. All rights reserved. See CSCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGroundSpacingImageFunction_txx #define otbGroundSpacingImageFunction_txx #include "otbMath.h" #include "itkConstNeighborhoodIterator.h" #include "otbGroundSpacingImageFunction.h" namespace otb { /** * Constructor */ template GroundSpacingImageFunction ::GroundSpacingImageFunction() { m_R = 6371000; m_Deg2radCoef = CONST_PI / 180; } /** * */ template void GroundSpacingImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } /** * */ template typename GroundSpacingImageFunction ::FloatType GroundSpacingImageFunction ::EvaluateAtIndex(const IndexType& index) const { FloatType var; if (!this->GetInputImage()) { var.Fill(itk::NumericTraits::min()); return var; } PointType point = this->GetPixelLocation(index); IndexType indexSrcX, indexSrcY; indexSrcX[0] = static_cast(vcl_fabs(static_cast(this->GetInputImage()->GetLargestPossibleRegion(). GetSize()[0] - index[0]))); // x position indexSrcX[1] = index[1]; // y position indexSrcY[0] = index[0]; // x position indexSrcY[1] = static_cast(vcl_fabs(static_cast(this->GetInputImage()->GetLargestPossibleRegion(). GetSize()[1] - index[1]))); PointType pointSrcX = this->GetPixelLocation(indexSrcX); PointType pointSrcY = this->GetPixelLocation(indexSrcY); ValueType dLatX = (vcl_fabs(pointSrcX[1] - point[1])) * m_Deg2radCoef; ValueType dLonX = (vcl_fabs(pointSrcX[0] - point[0])) * m_Deg2radCoef; const ValueType One = itk::NumericTraits::One; const ValueType Two = One + One; ValueType aX = vcl_sin(dLatX / Two) * vcl_sin(dLatX / Two) + vcl_cos(point[1] * m_Deg2radCoef) * vcl_cos( pointSrcX[1] * m_Deg2radCoef) * vcl_sin(dLonX / Two) * vcl_sin(dLonX / Two); ValueType cX = Two * vcl_atan2(vcl_sqrt(aX), vcl_sqrt(One - aX)); ValueType dX = m_R * cX; ValueType dLatY = (vcl_fabs(pointSrcY[1] - point[1])) * m_Deg2radCoef; ValueType dLonY = (vcl_fabs(pointSrcY[0] - point[0])) * m_Deg2radCoef; ValueType aY = vcl_sin(dLatY / Two) * vcl_sin(dLatY / Two) + vcl_cos(point[1] * m_Deg2radCoef) * vcl_cos( pointSrcY[1] * m_Deg2radCoef) * vcl_sin(dLonY / Two) * vcl_sin(dLonY / Two); ValueType cY = Two * vcl_atan2(vcl_sqrt(aY), vcl_sqrt(One - aY)); ValueType dY = m_R * cY; //FloatType var; var[0] = dX / (vcl_fabs(static_cast(indexSrcX[0] - index[0]))); var[1] = dY / (vcl_fabs(static_cast(indexSrcY[1] - index[1]))); return var; } template typename GroundSpacingImageFunction ::PointType GroundSpacingImageFunction ::GetPixelLocation(const IndexType& index) const { PointType inputPoint; inputPoint[0] = index[0]; inputPoint[1] = index[1]; if (!this->GetInputImage()) { itkExceptionMacro(<< "No input image!"); } TransformType::Pointer transform = TransformType::New(); const itk::MetaDataDictionary& inputDict = this->GetInputImage()->GetMetaDataDictionary(); transform->SetInputDictionary(inputDict); transform->SetInputOrigin(this->GetInputImage()->GetOrigin()); transform->SetInputSpacing(this->GetInputImage()->GetSpacing()); transform->InstantiateTransform(); return transform->TransformPoint(inputPoint); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbImageToEnvelopeVectorDataFilter.h000066400000000000000000000101771301006202600315420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToEnvelopeVectorDataFilter_h #define otbImageToEnvelopeVectorDataFilter_h #include "otbVectorDataSource.h" #include "otbGenericRSTransform.h" namespace otb { /** \class ImageToEnvelopeVectorDataFilter * \brief Build a vector data containing the polygon of the image envelope * * This filter uses the GenericRSTransform to project the four corners of the image into ground position. * If the sampling rate is not null, the image edges are also projected (using one point every * "m_SamplingRate" pixels). * In case of raw image geometry, a DEM directory or average elevation can be set for better accuracy. * * This filter supports user-specified output projection. If no projection is defined, the standard WGS84 * projection will be used. * * \ingroup VectorDataFilter * \ingroup Projection * * * \ingroup OTBProjection */ template class ITK_EXPORT ImageToEnvelopeVectorDataFilter : public otb::VectorDataSource { public: /** Standard class typedefs. */ typedef ImageToEnvelopeVectorDataFilter Self; typedef otb::VectorDataSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef TOutputVectorData OutputVectorDataType; typedef typename TInputImage::ConstPointer InputImagePointer; typedef typename TOutputVectorData::Pointer OutputVectorDataPointer; /** Some typedefs. */ typedef otb::GenericRSTransform InternalTransformType; typedef typename InternalTransformType::Pointer InternalTransformPointerType; typedef typename OutputVectorDataType ::DataNodeType OutputDataNodeType; typedef typename OutputVectorDataType ::DataNodePointerType OutputDataNodePointerType; typedef typename OutputVectorDataType ::DataTreePointerType OutputDataTreePointerType; typedef typename OutputVectorDataType ::DataTreeType::TreeNodeType OutputInternalTreeNodeType; typedef typename OutputDataNodeType::PolygonType PolygonType; /** Set input image */ using Superclass::SetInput; void SetInput(const InputImageType *input); /** Get input image */ const InputImageType * GetInput(); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageToEnvelopeVectorDataFilter, VectorDataSource); /** Set/Get output projection (default is WGS84) */ itkSetStringMacro(OutputProjectionRef); itkGetStringMacro(OutputProjectionRef); itkSetMacro(SamplingRate, unsigned int); itkGetMacro(SamplingRate, unsigned int); protected: ImageToEnvelopeVectorDataFilter(); ~ImageToEnvelopeVectorDataFilter() ITK_OVERRIDE {} void GenerateOutputInformation(void) ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; void InstantiateTransform(); private: ImageToEnvelopeVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InternalTransformPointerType m_Transform; std::string m_OutputProjectionRef; unsigned int m_SamplingRate; // Sampling rate for edges (in pixels) }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToEnvelopeVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbImageToEnvelopeVectorDataFilter.txx000066400000000000000000000171451301006202600321400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToEnvelopeVectorDataFilter_txx #define otbImageToEnvelopeVectorDataFilter_txx #include "otbImageToEnvelopeVectorDataFilter.h" #include "otbDataNode.h" namespace otb { /** * Constructor */ template ImageToEnvelopeVectorDataFilter ::ImageToEnvelopeVectorDataFilter() : m_SamplingRate(0) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_OutputProjectionRef.clear(); // Build output this->SetNthOutput(0, OutputVectorDataType::New()); } template void ImageToEnvelopeVectorDataFilter ::SetInput(const InputImageType *input) { // process object is not const-correct, the const_cast // is required here. this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template const TInputImage * ImageToEnvelopeVectorDataFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) return ITK_NULLPTR; return dynamic_cast (this->itk::ProcessObject::GetInput(0)); } template void ImageToEnvelopeVectorDataFilter ::GenerateOutputInformation(void) { // Call superclass implementation Superclass::GenerateOutputInformation(); // Ensure transform instantiation this->InstantiateTransform(); // Add projection info to output OutputVectorDataPointer output = this->GetOutput(); itk::MetaDataDictionary& dict = output->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, m_Transform->GetOutputProjectionRef()); } template void ImageToEnvelopeVectorDataFilter ::GenerateInputRequestedRegion(void) { // Call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve input image pointer typename InputImageType::Pointer inputPtr = const_cast(this->GetInput()); typename InputImageType::RegionType requestedRegion = inputPtr->GetRequestedRegion(); typename InputImageType::SizeType size = requestedRegion.GetSize(); size.Fill(0); requestedRegion.SetSize(size); typename InputImageType::IndexType index = requestedRegion.GetIndex(); index.Fill(0); requestedRegion.SetIndex(index); inputPtr->SetRequestedRegion(requestedRegion); } template void ImageToEnvelopeVectorDataFilter ::InstantiateTransform(void) { // Project into output projection typename InputImageType::ConstPointer inputPtr = this->GetInput(); m_Transform = InternalTransformType::New(); m_Transform->SetOutputProjectionRef(m_OutputProjectionRef); m_Transform->SetInputProjectionRef(inputPtr->GetProjectionRef()); m_Transform->SetInputKeywordList(inputPtr->GetImageKeywordlist()); m_Transform->InstantiateTransform(); } template void ImageToEnvelopeVectorDataFilter ::GenerateData(void) { // Retrieve input and output pointers typename InputImageType::ConstPointer inputPtr = this->GetInput(); OutputVectorDataPointer outputPtr = this->GetOutput(); // Compute corners as index itk::ContinuousIndex ul( inputPtr->GetLargestPossibleRegion().GetIndex()); // move 'ul' to the corner of the first pixel ul[0] += -0.5; ul[1] += -0.5; itk::ContinuousIndex ur(ul); itk::ContinuousIndex lr(ul); itk::ContinuousIndex ll(ul); typename InputImageType::SizeType size = inputPtr->GetLargestPossibleRegion().GetSize(); ur[0]+=size[0]; ll[1]+=size[1]; lr[0]+=size[0]; lr[1]+=size[1]; // Get corners as physical points typename InputImageType::PointType ulp, urp, lrp, llp, current; inputPtr->TransformContinuousIndexToPhysicalPoint(ul, ulp); inputPtr->TransformContinuousIndexToPhysicalPoint(ur, urp); inputPtr->TransformContinuousIndexToPhysicalPoint(lr, lrp); inputPtr->TransformContinuousIndexToPhysicalPoint(ll, llp); this->InstantiateTransform(); itk::ContinuousIndex edgeIndex; typename InputImageType::PointType edgePoint; // Build envelope polygon typename PolygonType::Pointer envelope = PolygonType::New(); typename PolygonType::VertexType vertex; current = m_Transform->TransformPoint(ulp); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); if (m_SamplingRate>0) { edgeIndex = ul; edgeIndex[0]+=m_SamplingRate; while (edgeIndex[0]TransformContinuousIndexToPhysicalPoint(edgeIndex, edgePoint); current = m_Transform->TransformPoint(edgePoint); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); edgeIndex[0]+=m_SamplingRate; } } current = m_Transform->TransformPoint(urp); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); if (m_SamplingRate>0) { edgeIndex = ur; edgeIndex[1]+=m_SamplingRate; while (edgeIndex[1]TransformContinuousIndexToPhysicalPoint(edgeIndex, edgePoint); current = m_Transform->TransformPoint(edgePoint); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); edgeIndex[1]+=m_SamplingRate; } } current = m_Transform->TransformPoint(lrp); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); if (m_SamplingRate>0) { edgeIndex = lr; edgeIndex[0]-=m_SamplingRate; while (edgeIndex[0]>ll[0]) { inputPtr->TransformContinuousIndexToPhysicalPoint(edgeIndex, edgePoint); current = m_Transform->TransformPoint(edgePoint); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); edgeIndex[0]-=m_SamplingRate; } } current = m_Transform->TransformPoint(llp); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); if (m_SamplingRate>0) { edgeIndex = ll; edgeIndex[1]-=m_SamplingRate; while (edgeIndex[1]>ul[1]) { inputPtr->TransformContinuousIndexToPhysicalPoint(edgeIndex, edgePoint); current = m_Transform->TransformPoint(edgePoint); vertex[0] = current[0]; vertex[1] = current[1]; envelope->AddVertex(vertex); edgeIndex[1]-=m_SamplingRate; } } // Add polygon to the VectorData tree OutputDataTreePointerType tree = outputPtr->GetDataTree(); // Create the output tree root OutputDataNodePointerType root = tree->GetRoot()->Get(); OutputDataNodePointerType document = OutputDataNodeType::New(); document->SetNodeType(DOCUMENT); tree->Add(document, root); OutputDataNodePointerType newDataNode = OutputDataNodeType::New(); newDataNode->SetPolygonExteriorRing(envelope); tree->Add(newDataNode, document); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbImportGeoInformationImageFilter.h000066400000000000000000000066151301006202600316220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImportGeoInformationImageFilter_h #define otbImportGeoInformationImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" namespace otb { /** \class ImportGeoInformationImageFilter * \brief This filter is a helper class to import metadata * from an existing image into a non-georeferenced image. * * It derives from itk::CastImageFilter since it overwrites * its output if possible. Default behavior is InPlaceOn as * the other filters which only modify metadata information * This class has been written as a workaround * for the bug http://public.kitware.com/Bug/bug.php?op=show&bugid=4625&pos=0. * There should be no needs for this filter in a standard pipeline. * * \sa InPlaceImageFilter * \sa ImageBase * * \ingroup OTBProjection */ template class ITK_EXPORT ImportGeoInformationImageFilter : public itk::CastImageFilter { public: /** Standard typedefs */ typedef ImportGeoInformationImageFilter Self; typedef itk::CastImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImportGeoInformationImageFilter, CastImageFilter); /** Template parameters typedefs */ typedef TImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::ConstPointer ImageConstPointerType; typedef TSourceImage SourceImageType; typedef SourceImageType SourceImagePointerType; /** * Set the source for geo information. * \param source The source image. */ void SetSource(const TSourceImage * source); /** * Get the source for geo information. * \return The source image. */ const TSourceImage * GetSource(void); protected: /** Constructor */ ImportGeoInformationImageFilter(); /** Destructor */ ~ImportGeoInformationImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Override VerifyInputInformation() since this filter's inputs do * not need to occupy the same physical space. * * \sa ProcessObject::VerifyInputInformation */ void VerifyInputInformation() ITK_OVERRIDE {} private: ImportGeoInformationImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImportGeoInformationImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbImportGeoInformationImageFilter.txx000066400000000000000000000065361301006202600322200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImportGeoInformationImageFilter_txx #define otbImportGeoInformationImageFilter_txx #include "otbImportGeoInformationImageFilter.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" namespace otb { /** * Constructor */ template ImportGeoInformationImageFilter ::ImportGeoInformationImageFilter() { this->InPlaceOn(); this->SetNumberOfRequiredInputs(2); } template void ImportGeoInformationImageFilter ::SetSource(const TSourceImage * source) { this->SetNthInput(1, const_cast(source)); } template const TSourceImage * ImportGeoInformationImageFilter ::GetSource() { return static_cast(this->itk::ProcessObject::GetInput(1)); } template void ImportGeoInformationImageFilter ::GenerateInputRequestedRegion(void) { Superclass::GenerateInputRequestedRegion(); typename SourceImageType::RegionType region; typename SourceImageType::SizeType size; typename SourceImageType::IndexType index; size.Fill(0); index.Fill(0); region.SetSize(size); region.SetIndex(index); SourceImageType * sourcePtr = const_cast(this->GetSource()); sourcePtr->SetRequestedRegion(region); } template void ImportGeoInformationImageFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); // Get output and source pointer ImagePointerType outputPtr = this->GetOutput(); SourceImageType * sourcePtr = const_cast(this->GetSource()); // Import metdata outputPtr->CopyInformation(sourcePtr); outputPtr->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); outputPtr->SetNumberOfComponentsPerPixel(this->GetInput()->GetNumberOfComponentsPerPixel()); } // template // void // ImportGeoInformationImageFilter // ::GenerateData(void) // { // // Get output and source pointer // ImagePointerType outputPtr = this->GetOutput(); // SourceImageType * sourcePtr =const_cast(this->GetSource()); // // Import metdata // outputPtr->CopyInformation(sourcePtr); // // Don't forget to copy also the origin and spacing, not handled by the CopyInformation method. // outputPtr->SetOrigin(sourcePtr->GetOrigin()); // outputPtr->SetSpacing(sourcePtr->GetSpacing()); // } /** * PrintSelf Method */ template void ImportGeoInformationImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbLambert2EtenduProjection.h000066400000000000000000000043341301006202600302440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLambert2EtenduProjection_h #define otbLambert2EtenduProjection_h #include "otbLambertConformalConicMapProjection.h" namespace otb { /** \class Lambert2EtenduProjection * \brief This class implements the Lambert 2 Etendu map projection. * It converts coordinates in longitude, latitude (WGS84) to Lambert 2 Etendu map coordinates. * * * \ingroup OTBProjection */ template class ITK_EXPORT Lambert2EtenduProjection : public LambertConformalConicMapProjection { public: /** Standard class typedefs. */ typedef Lambert2EtenduProjection Self; typedef LambertConformalConicMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Lambert2EtenduProjection, LambertConformalConicMapProjection); protected: Lambert2EtenduProjection() { this->SetParameter("OriginX", "2.33722778"); this->SetParameter("OriginY", "46.8"); this->SetParameter("Datum", "NTF"); this->SetParameter("FalseNorthing", "2200000"); this->SetParameter("FalseEasting", "600000"); this->SetParameter("StandardParallel1", "45.89891944"); this->SetParameter("StandardParallel2", "47.69601389"); } ~Lambert2EtenduProjection() ITK_OVERRIDE {} private: Lambert2EtenduProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbLambert3CartoSudProjection.h000066400000000000000000000047251301006202600305510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLambert3CartoSudProjection_h #define otbLambert3CartoSudProjection_h #include "otbLambertConformalConicMapProjection.h" namespace otb { /** \class Lambert3CartoSudProjection * \brief This class implements the Lambert3CartoSud map projection (RGF93 french geodesic system). * It converts coordinates in longitude, latitude (WGS84) to Lambert 3 map coordinates. * * * \ingroup OTBProjection */ template class ITK_EXPORT Lambert3CartoSudProjection : public LambertConformalConicMapProjection { public: /** Standard class typedefs. */ typedef Lambert3CartoSudProjection Self; typedef LambertConformalConicMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Lambert3CartoSudProjection, LambertConformalConicMapProjection); protected: Lambert3CartoSudProjection() { this->SetParameter("OriginX", "3"); this->SetParameter("OriginY", "46.5"); this->SetParameter("Datum", "WE"); this->SetParameter("FalseNorthing", "3200000"); this->SetParameter("FalseEasting", "600000"); this->SetParameter("StandardParallel1", "43.1992913888888888888888888889"); this->SetParameter("StandardParallel2", "44.9960938888888888888888888888"); } virtual ~Lambert3CartoSudProjection() {} private: Lambert3CartoSudProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbLambert93Projection.h000066400000000000000000000042451301006202600271720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLambert93Projection_h #define otbLambert93Projection_h #include "otbLambertConformalConicMapProjection.h" namespace otb { /** \class Lambert93Projection * \brief This class implements the Lambert93 map projection (RGF93 french geodesic system). * It converts coordinates in longitude, latitude (WGS84) to Lambert 93 map coordinates. * * * \ingroup OTBProjection */ template class ITK_EXPORT Lambert93Projection : public LambertConformalConicMapProjection { public: /** Standard class typedefs. */ typedef Lambert93Projection Self; typedef LambertConformalConicMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Lambert93Projection, LambertConformalConicMapProjection); protected: Lambert93Projection() { this->SetParameter("OriginX", "3"); this->SetParameter("OriginY", "46.5"); this->SetParameter("Datum", "WE"); this->SetParameter("FalseNorthing", "6600000"); this->SetParameter("FalseEasting", "700000"); this->SetParameter("StandardParallel1", "44"); this->SetParameter("StandardParallel2", "49"); } ~Lambert93Projection() ITK_OVERRIDE {} private: Lambert93Projection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbLambertConformalConicMapProjection.h000066400000000000000000000051601301006202600322660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLambertConformalConicMapProjection_h #define otbLambertConformalConicMapProjection_h #include "otbGenericMapProjection.h" namespace otb { /** \class LambertConformalConicMapProjection * \brief This class implements the Lambert Conformal Conic map projection. * It converts coordinates in longitude, latitude (WGS84) to Lambert Conformal Conic map coordinates. * * * \ingroup OTBProjection */ template class ITK_EXPORT LambertConformalConicMapProjection : public GenericMapProjection { public: /** Standard class typedefs. */ typedef LambertConformalConicMapProjection Self; typedef GenericMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LambertConformalConicMapProjection, GenericMapProjection); void SetStandardParallel1(double degree); void SetStandardParallel2(double degree); void SetStandardParallels(double parallel1Degree, double parallel2Degree); void SetFalseEasting(double falseEasting); void SetFalseNorthing(double falseNorthing); double GetFalseNorthing() const; double GetFalseEasting() const; void SetAllParameters(double parallel1Degree, double parallel2Degree, double falseEasting, double falseNorthing); protected: LambertConformalConicMapProjection(); ~LambertConformalConicMapProjection() ITK_OVERRIDE {}; private: LambertConformalConicMapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLambertConformalConicMapProjection.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbLambertConformalConicMapProjection.txx000066400000000000000000000073031301006202600326630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLambertConformalConicMapProjection_txx #define otbLambertConformalConicMapProjection_txx #include "otbLambertConformalConicMapProjection.h" #include "otbUtils.h" namespace otb { template LambertConformalConicMapProjection ::LambertConformalConicMapProjection() { this->SetWkt("ossimLambertConformalConicProjection"); } /// Parallel1 specification template void LambertConformalConicMapProjection ::SetStandardParallel1(double degree) { this->SetParameter("StandardParallel1", Utils::ConvertToString(degree)); this->Modified(); } /// Parallel2 specification template void LambertConformalConicMapProjection ::SetStandardParallel2(double degree) { this->SetParameter("StandardParallel2", Utils::ConvertToString(degree)); this->Modified(); } /// Specification of the 2 parallels template void LambertConformalConicMapProjection ::SetStandardParallels(double parallel1Degree, double parallel2Degree) { this->SetParameter("StandardParallel1", Utils::ConvertToString(parallel1Degree)); this->SetParameter("StandardParallel2", Utils::ConvertToString(parallel2Degree)); this->Modified(); } /// False easting specification template void LambertConformalConicMapProjection ::SetFalseEasting(double falseEasting) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->Modified(); } /// False Northing specification template void LambertConformalConicMapProjection ::SetFalseNorthing(double falseNorthing) { this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } /// Set the parameters template void LambertConformalConicMapProjection ::SetAllParameters(double parallel1Degree, double parallel2Degree, double falseEasting, double falseNorthing) { this->SetParameter("StandardParallel1", Utils::ConvertToString(parallel1Degree)); this->SetParameter("StandardParallel2", Utils::ConvertToString(parallel2Degree)); this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } /// Get the False Northing (avoid negative coordinates) template double LambertConformalConicMapProjection ::GetFalseNorthing() const { double falseNorthing = atof(this->GetParameter("FalseNorthing").c_str()); return falseNorthing; } ///Get the False Easting (avoid negative coordinates) template double LambertConformalConicMapProjection ::GetFalseEasting() const { double falseEasting = atof(this->GetParameter("FalseEasting").c_str()); return falseEasting; } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbLeastSquareAffineTransformEstimator.h000066400000000000000000000124321301006202600325160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLeastSquareAffineTransformEstimator_h #define otbLeastSquareAffineTransformEstimator_h #include "itkObject.h" #include "itkObjectFactory.h" #include "itkMatrix.h" #include "itkVector.h" #include "itkAffineTransform.h" namespace otb { /** \class LeastSquareAffineTransformEstimator * \brief This class provide the affine transform LSQR estimation * * This class uses the classical least square optimisation to estimate * an affine transform from a set of tie points. * * This implementation supports points of any dimension. * * Tie points can be added through the AddTiePoints() method. * * The ClearTiePoints() method allows removing all the tie points * that has been previously set. * * Once all the tie points have been fed into the estimator, the * Compute() method will perform the optimization. * * Matrix of the estimated affine transform can be retrieved using the * GetMatrix() method. * * Offset of the estimated affine transform can be retrieved using the * GetOffset() method. * * Alternatively, the GetAffineTransform() methods return a pointer to * a fully set-up forward affine transform (\sa AffineTransform). * * Estimation errors are available per dimension using the * GetRMSError() (root mean square location error) or * GetRelativeResidual() (relative residual error). * * NOTE: All computation are performed in double. Results are casted * back to TPoint::CoordRepType. * * * \ingroup OTBProjection */ template class ITK_EXPORT LeastSquareAffineTransformEstimator : public itk::Object { public: /** Standard class typedefs. */ typedef LeastSquareAffineTransformEstimator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LeastSquareAffineTransformEstimator, Object); /** Extract dimension from input and output image. */ itkStaticConstMacro(PointDimension, unsigned int, TPoint::PointDimension); /** Points typedefs */ typedef TPoint PointType; typedef typename PointType::CoordRepType PrecisionType; typedef itk::CovariantVector CovariantVectorType; typedef std::pair TiePointsType; typedef std::vector TiePointsContainerType; /** Affine transform components typedefs */ typedef itk::Matrix MatrixType; typedef itk::Vector VectorType; typedef itk::AffineTransform AffineTransformType; typedef typename AffineTransformType::Pointer AffineTransformPointerType; /** Get the affine transform matrix */ itkGetConstReferenceMacro(Matrix, MatrixType); /** Get the affine transform offset */ itkGetConstReferenceMacro(Offset, VectorType); /** Get the estimated affine transform */ itkGetObjectMacro(AffineTransform, AffineTransformType); /** Get the RMS error */ itkGetConstReferenceMacro(RMSError, CovariantVectorType); /** Get the relative residual */ itkGetConstReferenceMacro(RelativeResidual, CovariantVectorType); /** Get the GCPsContainer * \return The GCPs container */ TiePointsContainerType& GetTiePointsContainer(); /** Set the GCP container */ void SetTiePointsContainer(const TiePointsContainerType& container); /** Add a pair of tie points */ void AddTiePoints(const PointType& src, const PointType& dst); /** Clear all tie points */ void ClearTiePoints(); /** The Compute method does the affine least square estimation */ void Compute(); protected: /** Constructor */ LeastSquareAffineTransformEstimator(); /** Destructor */ ~LeastSquareAffineTransformEstimator() ITK_OVERRIDE; /** The PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LeastSquareAffineTransformEstimator (const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** Container of GCPs */ TiePointsContainerType m_TiePointsContainer; /** RMS error */ CovariantVectorType m_RMSError; /** Relative residual */ CovariantVectorType m_RelativeResidual; /** Affine transform matrix */ MatrixType m_Matrix; /** Affine transform offset */ VectorType m_Offset; /** Affine transform */ AffineTransformPointerType m_AffineTransform; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLeastSquareAffineTransformEstimator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbLeastSquareAffineTransformEstimator.txx000066400000000000000000000127461301006202600331220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLeastSquareAffineTransformEstimator_txx #define otbLeastSquareAffineTransformEstimator_txx #include #include #include #include "otbMacro.h" #include "otbLeastSquareAffineTransformEstimator.h" namespace otb { template LeastSquareAffineTransformEstimator ::LeastSquareAffineTransformEstimator() : m_TiePointsContainer(), m_RMSError(), m_RelativeResidual(), m_Matrix(), m_Offset(), m_AffineTransform() { // Build the affine transform object m_AffineTransform = AffineTransformType::New(); } template LeastSquareAffineTransformEstimator ::~LeastSquareAffineTransformEstimator() { // Clear the tie points list this->ClearTiePoints(); } template typename LeastSquareAffineTransformEstimator ::TiePointsContainerType& LeastSquareAffineTransformEstimator ::GetTiePointsContainer() { return m_TiePointsContainer; } template void LeastSquareAffineTransformEstimator ::SetTiePointsContainer(const TiePointsContainerType& container) { m_TiePointsContainer = container; } template void LeastSquareAffineTransformEstimator ::ClearTiePoints() { // Clear the container m_TiePointsContainer.clear(); } template void LeastSquareAffineTransformEstimator ::AddTiePoints(const PointType& src, const PointType& dst) { // Build the tie point TiePointsType tpoints(src, dst); // Add it to the container m_TiePointsContainer.push_back(tpoints); } template void LeastSquareAffineTransformEstimator ::Compute() { // Get the number of tie points unsigned int nbPoints = m_TiePointsContainer.size(); // Check if there are some points in if (nbPoints == 0) { itkExceptionMacro(<< "No tie points were given to the LeastSquareAffineTransformEstimator"); } // Convenient typedefs typedef vnl_sparse_matrix VnlMatrixType; typedef vnl_vector VnlVectorType; // Step 1: build linear systems // Build one linear system per dimension std::vector matrixPerDim(PointDimension, VnlMatrixType(nbPoints, PointDimension + 1)); std::vector vectorPerDim(PointDimension, VnlVectorType(nbPoints)); // Iterate on points for (unsigned int pId = 0; pId < nbPoints; ++pId) { // Iterate on dimension for (unsigned int dim1 = 0; dim1 < PointDimension; ++dim1) { // Fill the vector vectorPerDim[dim1][pId] = static_cast(m_TiePointsContainer[pId].second[dim1]); // Iterate on dimension (second loop) for (unsigned int dim2 = 0; dim2 < PointDimension; ++dim2) { matrixPerDim[dim1](pId, dim2) = static_cast(m_TiePointsContainer[pId].first[dim2]); } // Fill the last column matrixPerDim[dim1](pId, PointDimension) = 1.; } } // Step 2: Solve linear systems for (unsigned int dim1 = 0; dim1 < PointDimension; ++dim1) { // Declare a linear system vnl_sparse_matrix_linear_system linearSystem(matrixPerDim[dim1], vectorPerDim[dim1]); // Check if there are enough points to solve if (linearSystem.get_number_of_unknowns() > nbPoints * PointDimension) { itkExceptionMacro(<< "There are " << linearSystem.get_number_of_unknowns() << " unknowns in the linear systems but only " << nbPoints << " points are provided."); } otbMsgDebugMacro(<< "Number of unknowns: " << linearSystem.get_number_of_unknowns()); otbMsgDebugMacro(<< "Number of equations: " << nbPoints); // A vector where the solution will be stored vnl_vector solution(PointDimension + 1); // Declare the solver vnl_lsqr linearSystemSolver(linearSystem); // And solve it linearSystemSolver.minimize(solution); // Get the RMS Error for that dimension m_RMSError[dim1] = linearSystem.get_rms_error(solution); // Get the relative residual m_RelativeResidual[dim1] = linearSystem.get_relative_residual(solution); // Fill the affine transform matrix for (unsigned int dim2 = 0; dim2 < PointDimension; ++dim2) { m_Matrix(dim1, dim2) = static_cast(solution[dim2]); } // Fill the offset m_Offset[dim1] = static_cast(solution[PointDimension]); } // Set the affine transform parameters m_AffineTransform->SetMatrix(m_Matrix); m_AffineTransform->SetOffset(m_Offset); } template void LeastSquareAffineTransformEstimator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Number of tie points: " << m_TiePointsContainer.size() << std::endl; os << indent << "RMS error: " << m_RMSError << std::endl; os << indent << "Relative residual: " << m_RelativeResidual << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbMapProjectionDeprecated.h000066400000000000000000000046061301006202600301270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMapProjectionDeprecated_h #define otbMapProjectionDeprecated_h #include "otbGenericMapProjection.h" namespace otb { namespace MapProjectionType { enum MapProj { ALBERS, AZIMEQUDIST, BNG, BONNE, CADRG, CASSINI, CYLEQUAREA, ECKERT6, GNOMONIC, LLXY, EQUDISTCYL, MERCATOR, MILLER, NEWZEALANDMAPGRID, OBLIQUEMERCATOR, ORTHOGRAPHIC, POLARSTEREO, POLYCONIC, SPACEOBLIQUEMERCATOR, STEREOGRAPHIC, TRANSCYLEQUAREA, UPS, VANDERGRINTEN, }; } /** \class MapProjectionDeprecated * \brief The only purpose of this class is to maintain backward compatibility. * * GenericMapProjection should be used instead. * * * * \ingroup OTBProjection */ template class ITK_EXPORT MapProjectionDeprecated : public GenericMapProjection { public: /** Standard class typedefs. */ typedef MapProjectionDeprecated Self; typedef GenericMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MapProjectionDeprecated, GenericMapProjection); protected: MapProjectionDeprecated(); ~MapProjectionDeprecated() ITK_OVERRIDE {}; private: MapProjectionDeprecated(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMapProjectionDeprecated.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbMapProjectionDeprecated.txx000066400000000000000000000075141301006202600305240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMapProjectionDeprecated_txx #define otbMapProjectionDeprecated_txx #include "otbMapProjectionDeprecated.h" namespace otb { template inline std::string GetMapProjectionDeprecatedString() { return ""; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Albers"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "AzimEquDist"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Bng"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Bonne"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Cadrg"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Cassini"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "CylEquArea"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Eckert6"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Gnomonic"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Llxy"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "EquDistCyl"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Mercator"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Miller"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "NewZealandMapGrid"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "ObliqueMercator"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "OrthoGraphic"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "PolarStereo"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Polyconic"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "SpaceObliqueMercator"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Stereographic"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "TransCylEquArea"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "Ups"; } template<> inline std::string GetMapProjectionDeprecatedString() { return "VanDerGrinten"; } template MapProjectionDeprecated ::MapProjectionDeprecated() { this->SetWkt(GetMapProjectionDeprecatedString()); } } #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbMapProjections.h000066400000000000000000000224011301006202600263220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMapProjections_h #define otbMapProjections_h #include "otbMapProjectionDeprecated.h" #include "otbUtmMapProjection.h" #include "otbLambert2EtenduProjection.h" #include "otbLambert3CartoSudProjection.h" #include "otbLambert93Projection.h" #include "otbEckert4MapProjection.h" #include "otbSinusoidalMapProjection.h" #include "otbMollweidMapProjection.h" #include "otbSVY21MapProjection.h" namespace otb { typedef Eckert4MapProjection Eckert4InverseProjection; typedef Eckert4MapProjection Eckert4ForwardProjection; typedef LambertConformalConicMapProjection LambertConformalConicInverseProjection; typedef LambertConformalConicMapProjection LambertConformalConicForwardProjection; typedef Lambert2EtenduProjection Lambert2EtenduInverseProjection; typedef Lambert2EtenduProjection Lambert2EtenduForwardProjection; typedef Lambert3CartoSudProjection Lambert3CartoSudInverseProjection; typedef Lambert3CartoSudProjection Lambert3CartoSudForwardProjection; typedef Lambert93Projection Lambert93InverseProjection; typedef Lambert93Projection Lambert93ForwardProjection; typedef SVY21MapProjection SVY21InverseProjection; typedef SVY21MapProjection SVY21ForwardProjection; typedef MollweidMapProjection MollweidInverseProjection; typedef MollweidMapProjection MollweidForwardProjection; typedef SinusoidalMapProjection SinusoidalInverseProjection; typedef SinusoidalMapProjection SinusoidalForwardProjection; typedef TransMercatorMapProjection TransMercatorInverseProjection; typedef TransMercatorMapProjection TransMercatorForwardProjection; typedef UtmMapProjection UtmInverseProjection; typedef UtmMapProjection UtmForwardProjection; // Definitions to maintain backward compatibility, but the GenericMapProjection // should be used instead. typedef MapProjectionDeprecated AlbersInverseProjection; typedef MapProjectionDeprecated AlbersForwardProjection; typedef MapProjectionDeprecated AzimEquDistInverseProjection; typedef MapProjectionDeprecated AzimEquDistForwardProjection; typedef MapProjectionDeprecated BngInverseProjection; typedef MapProjectionDeprecated BngForwardProjection; typedef MapProjectionDeprecated BonneInverseProjection; typedef MapProjectionDeprecated BonneForwardProjection; typedef MapProjectionDeprecated CadrgInverseProjection; typedef MapProjectionDeprecated CadrgForwardProjection; typedef MapProjectionDeprecated CassiniInverseProjection; typedef MapProjectionDeprecated CassiniForwardProjection; typedef MapProjectionDeprecated CylEquAreaInverseProjection; typedef MapProjectionDeprecated CylEquAreaForwardProjection; typedef MapProjectionDeprecated Eckert6InverseProjection; typedef MapProjectionDeprecated Eckert6ForwardProjection; typedef MapProjectionDeprecated GnomonicInverseProjection; typedef MapProjectionDeprecated GnomonicForwardProjection; typedef MapProjectionDeprecated LlxyInverseProjection; typedef MapProjectionDeprecated LlxyForwardProjection; typedef MapProjectionDeprecated EquDistCylInverseProjection; typedef MapProjectionDeprecated EquDistCylForwardProjection; typedef MapProjectionDeprecated MercatorInverseProjection; typedef MapProjectionDeprecated MercatorForwardProjection; typedef MapProjectionDeprecated MillerInverseProjection; typedef MapProjectionDeprecated MillerForwardProjection; typedef MapProjectionDeprecated NewZealandMapGridInverseProjection; typedef MapProjectionDeprecated NewZealandMapGridForwardProjection; typedef MapProjectionDeprecated ObliqueMercatorInverseProjection; typedef MapProjectionDeprecated ObliqueMercatorForwardProjection; typedef MapProjectionDeprecated OrthoGraphicInverseProjection; typedef MapProjectionDeprecated OrthoGraphicForwardProjection; typedef MapProjectionDeprecated PolarStereoInverseProjection; typedef MapProjectionDeprecated PolarStereoForwardProjection; typedef MapProjectionDeprecated PolyconicInverseProjection; typedef MapProjectionDeprecated PolyconicForwardProjection; typedef MapProjectionDeprecated SpaceObliqueMercatorInverseProjection; typedef MapProjectionDeprecated SpaceObliqueMercatorForwardProjection; typedef MapProjectionDeprecated StereographicInverseProjection; typedef MapProjectionDeprecated StereographicForwardProjection; typedef MapProjectionDeprecated TransCylEquAreaInverseProjection; typedef MapProjectionDeprecated TransCylEquAreaForwardProjection; typedef MapProjectionDeprecated UpsInverseProjection; typedef MapProjectionDeprecated UpsForwardProjection; typedef MapProjectionDeprecated VanDerGrintenInverseProjection; typedef MapProjectionDeprecated VanDerGrintenForwardProjection; } //namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbMollweidMapProjection.h000066400000000000000000000044261301006202600276430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMollweidMapProjection_h #define otbMollweidMapProjection_h #include "otbGenericMapProjection.h" namespace otb { /** \class MollweidMapProjection * \brief This class implements the Mollweid map projection. * It converts coordinates in longitude, latitude (WGS84) to Mollweid map coordinates. * * \ingroup OTBProjection */ template class ITK_EXPORT MollweidMapProjection : public GenericMapProjection { public: /** Standard class typedefs. */ typedef MollweidMapProjection Self; typedef GenericMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MollweidMapProjection, GenericMapProjection); virtual void SetFalseEasting(double falseEasting); virtual void SetFalseNorthing(double falseNorthing); virtual double GetFalseNorthing() const; virtual double GetFalseEasting() const; virtual void SetParameters(double falseEasting, double falseNorthing); using Superclass::SetParameters; protected: MollweidMapProjection(); ~MollweidMapProjection() ITK_OVERRIDE; private: MollweidMapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMollweidMapProjection.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbMollweidMapProjection.txx000066400000000000000000000047501301006202600302370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMollweidMapProjection_txx #define otbMollweidMapProjection_txx #include "otbMollweidMapProjection.h" #include "otbUtils.h" namespace otb { template MollweidMapProjection ::MollweidMapProjection() { this->SetWkt("ossimMollweidProjection"); } template MollweidMapProjection ::~MollweidMapProjection() { } ///Set the false easting template void MollweidMapProjection ::SetFalseEasting(double falseEasting) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->Modified(); } ///Set the false Northing template void MollweidMapProjection ::SetFalseNorthing(double falseNorthing) { this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } ///\return the false northing (avoid negative coordinates) template double MollweidMapProjection ::GetFalseNorthing() const { double falseNorthing = atof(this->GetParameter("FalseNorthing").c_str()); return falseNorthing; } ///\return the false easting (avoid negative coordinates) template double MollweidMapProjection ::GetFalseEasting() const { double falseEasting = atof(this->GetParameter("FalseEasting").c_str()); return falseEasting; } template void MollweidMapProjection ::SetParameters(double falseEasting, double falseNorthing) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbOrthoRectificationFilter.h000066400000000000000000000064761301006202600303500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOrthoRectificationFilter_h #define otbOrthoRectificationFilter_h #include #include #include #include "otbGenericRSResampleImageFilter.h" #include "otbCompositeTransform.h" #include "otbInverseSensorModel.h" #include "otbVectorImage.h" #include "otbImage.h" namespace otb { /** \class OrthoRectificationFilter * * \brief Class for Orthorectifying an image * * This class is used to apply map projection and sensor model transformation * to orthorectify an image, with or without DEM. * * \ingroup Projection * * \example Projections/OrthoRectificationExample.cxx * * * \ingroup OTBProjection */ template class ITK_EXPORT OrthoRectificationFilter : public GenericRSResampleImageFilter { public: /** Standard class typedefs */ typedef GenericRSResampleImageFilter Superclass; typedef OrthoRectificationFilter Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** types definitions */ typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::SpacingType SpacingType; typedef typename TInputImage::PointType PointType; typedef typename TInputImage::RegionType RegionType; typedef typename TOutputImage::PixelType OutputPixelType; /** output map projection */ typedef TMapProjection MapProjectionType; typedef typename TMapProjection::Pointer MapProjectionPointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(OrthoRectificationFilter, GenericRSResampleImageFilter); /** Accessors */ virtual void SetMapProjection(MapProjectionType* arg) { if (this->m_MapProjection != arg) { this->m_MapProjection = arg; this->Modified(); } } itkGetObjectMacro(MapProjection, MapProjectionType); protected: OrthoRectificationFilter(); ~OrthoRectificationFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; private: OrthoRectificationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Map Projection used to transform cartographic coordinates in geographic coordinates */ MapProjectionPointerType m_MapProjection; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOrthoRectificationFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbOrthoRectificationFilter.txx000066400000000000000000000052651301006202600307370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOrthoRectificationFilter_txx #define otbOrthoRectificationFilter_txx #include "otbOrthoRectificationFilter.h" #include "itkMetaDataObject.h" namespace otb { template OrthoRectificationFilter ::OrthoRectificationFilter(): m_MapProjection(ITK_NULLPTR) {} template OrthoRectificationFilter ::~OrthoRectificationFilter() {} template void OrthoRectificationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "OrthoRectification" << "\n"; } template void OrthoRectificationFilter ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); } template void OrthoRectificationFilter ::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); if(!m_MapProjection.IsNull() && !m_MapProjection->GetWkt().empty()) { // fill up the metadata information for ProjectionRef itk::MetaDataDictionary& dict = this->GetOutput()->GetMetaDataDictionary(); std::string projectionRef = m_MapProjection->GetWkt(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, projectionRef); // Fill the GenericRSTransform with those information this->SetOutputProjectionRef(projectionRef); this->UpdateTransform(); } } } //namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbPhysicalToRPCSensorModelImageFilter.h000066400000000000000000000111731301006202600323010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPhysicalToRPCSensorModelImageFilter_h #define otbPhysicalToRPCSensorModelImageFilter_h #include "otbGCPsToRPCSensorModelImageFilter.h" #include "otbGenericRSTransform.h" namespace otb { /** \class PhysicalToRPCSensorModelImageFilter * \brief This filter estimates a RPC sensor models from a physical model. * * This filters estimates an RPC sensor model from a list of points * homologous point in the physical coordinate system and the WGS84 * CS. * * The number of points used to estimate the rpc sensor model is * defined by the GridSize, note that at least 16 points are needed * to estimate a proper RPC sensor model, there are no warning when * the model estimated is inaccurate. * * The UseImageGCPs flag allows importing GCPs from the image * metadata, if any.(TODO) * * GCPs can be passed to the filter using one of the AddGCP method * implementation.(TODO) * * Depending on the value of the DEMDirectory, an elevation fetched * from the SRT directory is used.(TODO) * * This filter does not modify the image buffer, but only the * metadata. Therefore, it provides in-place support, which is * enabled by default. Call InPlaceOff() to change the default * behavior. * * \ingroup Projections * * \ingroup OTBProjection */ template class ITK_EXPORT PhysicalToRPCSensorModelImageFilter : public itk::CastImageFilter { public: /** Standard class typedefs. */ typedef PhysicalToRPCSensorModelImageFilter Self; typedef itk::CastImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PhysicalToRPCSensorModelImageFilter, CastImageFilter); /** template parameters typedef */ typedef TImage ImageType; typedef typename ImageType::PointType PointType; typedef typename ImageType::SizeType SizeType; /** GCPsToSensor model filter */ typedef GCPsToRPCSensorModelImageFilter GCPsToSensorModelType; typedef typename GCPsToSensorModelType::Pointer GCPsToSensorModelPointerType; typedef typename GCPsToSensorModelType::Point2DType Point2DType; typedef typename GCPsToSensorModelType::Point3DType Point3DType; typedef typename GCPsToSensorModelType::GCPType GCPType; typedef typename GCPsToSensorModelType::GCPsContainerType GCPsContainerType; typedef typename GCPsToSensorModelType::ErrorsContainerType ErrorsContainerType; /** Remote Sensing Transform */ typedef GenericRSTransform<> RSTransformType; typedef typename RSTransformType::Pointer RSTransformPointerType; /** Set/Get the grid size*/ itkSetMacro(GridSize, SizeType); itkGetConstReferenceMacro(GridSize, SizeType); /** Set Grid size with an unsigned int parmeter*/ void SetGridSize(unsigned int inSize) { SizeType iSize; iSize.Fill(inSize); if(m_GridSize != iSize) { m_GridSize = iSize; this->Modified(); } } /** Reimplement the method Modified() */ void Modified() const ITK_OVERRIDE; protected: /** Constructor */ PhysicalToRPCSensorModelImageFilter(); /** Destructor */ ~PhysicalToRPCSensorModelImageFilter() ITK_OVERRIDE; /** The PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Generate the Output image information*/ void GenerateOutputInformation() ITK_OVERRIDE; private: PhysicalToRPCSensorModelImageFilter(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** The rpc model estimator */ GCPsToSensorModelPointerType m_GCPsToSensorModelFilter; SizeType m_GridSize; mutable bool m_OutputInformationGenerated; }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPhysicalToRPCSensorModelImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbPhysicalToRPCSensorModelImageFilter.txx000066400000000000000000000073231301006202600326770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPhysicalToRPCSensorModelImageFilter_txx #define otbPhysicalToRPCSensorModelImageFilter_txx #include "otbPhysicalToRPCSensorModelImageFilter.h" #include "otbDEMHandler.h" namespace otb { template PhysicalToRPCSensorModelImageFilter ::PhysicalToRPCSensorModelImageFilter() { // This filter does not modify the image buffer, but only its // metadata.Therefore, it can be run inplace to reduce memory print. // CastImageFilter has InPlaceOff by default (see UnaryFunctorImgeFilter constructor) this->InPlaceOn(); // Initialize the rpc estimator m_GCPsToSensorModelFilter = GCPsToSensorModelType::New(); // Initialize the gridSize : 16 points to have a correct estimation // of the model m_GridSize.Fill(4); // Flag initilalisation m_OutputInformationGenerated = false; } template PhysicalToRPCSensorModelImageFilter ::~PhysicalToRPCSensorModelImageFilter() { } template void PhysicalToRPCSensorModelImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if(!m_OutputInformationGenerated) { // Get the input ImageType * input = const_cast(this->GetInput()); // Build the grid // Generate GCPs from physical sensor model RSTransformPointerType rsTransform = RSTransformType::New(); rsTransform->SetInputKeywordList(input->GetImageKeywordlist()); rsTransform->InstantiateTransform(); // Compute the size of the grid typename ImageType::SizeType size = input->GetLargestPossibleRegion().GetSize(); double gridSpacingX = size[0]/m_GridSize[0]; double gridSpacingY = size[1]/m_GridSize[1]; for(unsigned int px = 0; pxGetOrigin(); inputPoint[0] += (px * gridSpacingX + 0.5) * input->GetSpacing()[0]; inputPoint[1] += (py * gridSpacingY + 0.5) * input->GetSpacing()[1]; PointType outputPoint = rsTransform->TransformPoint(inputPoint); m_GCPsToSensorModelFilter->AddGCP(inputPoint, outputPoint); } } m_GCPsToSensorModelFilter->SetInput(input); m_GCPsToSensorModelFilter->UpdateOutputInformation(); otbGenericMsgDebugMacro(<<"RPC model estimated. RMS ground error: "<GetRMSGroundError() <<", Mean error: "<GetMeanError()); // Encapsulate the keywordlist itk::MetaDataDictionary& dict = this->GetOutput()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, m_GCPsToSensorModelFilter->GetKeywordlist()); // put the flag to true m_OutputInformationGenerated = true; } } template void PhysicalToRPCSensorModelImageFilter ::Modified() const { Superclass::Modified(); m_OutputInformationGenerated= false; } template void PhysicalToRPCSensorModelImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbPleiadesPToXSAffineTransformCalculator.h000066400000000000000000000076261301006202600330440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPleiadesPToXSAffineTransformCalculator__h #define otbPleiadesPToXSAffineTransformCalculator__h #include "itkLightObject.h" #include "itkScalableAffineTransform.h" #include "itkImageBase.h" #include "OTBProjectionExport.h" namespace otb { /** * \class PleiadesPToXSAffineTransformCalculator * \brief Compute the affine transform linking P and XS pixel position for Pleiades sensor bundles * * Pleiades sensor bundle are exactly homotetic, it is therefore * possible to corregister the pancrhomatic and multispectral images * with a simple affine transform without using any sensor * modelling. This yields a very accurate corregistration and avoid the * use of a DSM which may cause registration errors due to height errors. * * This calculator is a helper class to build the affine transform. It * consists in only two static methods: one to check if the transform * calculation applies to the given pair of images, the other to * actually estimate the transform. * * The estimated transform returned by the latter transforms * pancrhomatic image positions to multispectral image positions. If * the inverse transform is needed, one can call the GetInverse() * method of the transform to retrieve it. * * * \ingroup OTBProjection */ class OTBProjection_EXPORT PleiadesPToXSAffineTransformCalculator : public itk::LightObject { public: typedef PleiadesPToXSAffineTransformCalculator Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkTypeMacro(PleiadesPToXSAffineTransformCalculator,itk::LightObject); typedef itk::ScalableAffineTransform TransformType; typedef TransformType::OutputVectorType OffsetType; /** * This function checks if the transform calculation applies to the * given pair of images. Checked items are: * - Both images are successfully undertood by OTB as Pleiades images, * - Both images processing level is SENSOR", * - XS and Pan ids (except last 4 letters) are equal. * \return True if the calculation applies */ static bool CanCompute(const itk::ImageBase<2> * panchromaticImage, const itk::ImageBase<2> * xsImage); /** * This function computes the offset in pan pixels for a pair of * image. Note that the CanCompute() method is first called, and * that an exception will be raised if computation can not be done. * * \return The computed transform */ static OffsetType ComputeOffset(const itk::ImageBase<2> * panchromaticImage, const itk::ImageBase<2> * xsImage); /** * This function computes the transform for a pair of image. Note * that the CanCompute() method is first called, and that an * exception will be raised if computation can not be done. * * This function reads both images support data and builds a * transform that will exactly coregister the images. * * \return The computed transform */ static TransformType::Pointer Compute(const itk::ImageBase<2> * panchromaticImage, const itk::ImageBase<2> * xsImage); private: PleiadesPToXSAffineTransformCalculator(); // purposely not implemented PleiadesPToXSAffineTransformCalculator(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbProjectiveProjectionImageFilter.h000066400000000000000000000111461301006202600316510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProjectiveProjectionImageFilter_h #define otbProjectiveProjectionImageFilter_h #include "itkMacro.h" #include "otbUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class ProjectiveProjectionFunctor * * \brief TODO * * * \ingroup OTBProjection */ template class ProjectiveProjectionFunctor { public: typedef TInput InputType; typedef TOutput OutputType; typedef TPrecision PrecisionType; ProjectiveProjectionFunctor() : m_OutputSize(0) {} virtual ~ProjectiveProjectionFunctor() {} unsigned int GetOutputSize() { return m_OutputSize; } const InputType& GetProjectionDirection() { return m_ProjectionDirection; } void SetProjectionDirection(const InputType& p) { m_ProjectionDirection = p; m_OutputSize = m_ProjectionDirection.Size(); } bool operator !=(const ProjectiveProjectionFunctor& itkNotUsed(other)) const { return false; } bool operator ==(const ProjectiveProjectionFunctor& other) const { return !(*this != other); } OutputType operator ()(const InputType& in) { PrecisionType dotProduct = 0; for (unsigned int i = 0; i < in.Size(); ++i) { dotProduct += in[i] * m_ProjectionDirection[i]; } OutputType projected(in.Size()); for (unsigned int j = 0; j < in.Size(); ++j) { projected[j] = in[j] / dotProduct; } return projected; } private: unsigned int m_OutputSize; InputType m_ProjectionDirection; }; } /** \class ProjectiveProjectionImageFilter * * \brief Applies a projective projection to each pixel of an image * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBProjection */ template class ITK_EXPORT ProjectiveProjectionImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ProjectiveProjectionImageFilter Self; typedef otb::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Functor::ProjectiveProjectionFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType, TPrecision> FunctorType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ProjectiveProjectionImageFilter, otb::UnaryFunctorImageFilter); /** Pixel types. */ typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; const InputPixelType& GetProjectionDirection() { return this->GetFunctor().GetProjectionDirection(); } void SetProjectionDirection(const InputPixelType& p) { this->GetFunctor().SetProjectionDirection(p); this->Modified(); } protected: ProjectiveProjectionImageFilter(); ~ProjectiveProjectionImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation(); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); typename Superclass::InputImagePointer inputPtr = this->GetInput(); outputPtr->SetNumberOfComponentsPerPixel( // propagate vector length info this->GetInput()->GetNumberOfComponentsPerPixel()); } private: ProjectiveProjectionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbProjectiveProjectionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbProjectiveProjectionImageFilter.txx000066400000000000000000000022261301006202600322440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProjectiveProjectionImageFilter_txx #define otbProjectiveProjectionImageFilter_txx #include "otbProjectiveProjectionImageFilter.h" namespace otb { template ProjectiveProjectionImageFilter ::ProjectiveProjectionImageFilter() { } template void ProjectiveProjectionImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbROIdataConversion.h000066400000000000000000000063351301006202600267260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbROIdataConversion_h #define otbROIdataConversion_h #include #include "otbImage.h" #include "itkImageToImageFilter.h" namespace otb { /** \class ROIdataConversion * \brief image data to vector conversion. * * A class that extract pixel value from an input image according to a ROI * image and outputs it on a vector of PixelType. * * \ingroup OTBProjection */ template class ROIdataConversion : public itk::ImageToImageFilter > { public: typedef ROIdataConversion Self; typedef itk::ImageToImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(ROIdataConversion, itk::ImageToImageFilter); typedef TInputImage InputImageType; typedef typename TInputImage::PixelType InputImagePixelType; typedef typename TInputImage::Pointer InputImagePointerType; typedef TInputROIImage InputROIImageType; typedef typename TInputROIImage::Pointer InputROIImagePointerType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::SizeType::SizeValueType SizeValueType; /** Gets/Sets the input image */ const InputImageType * GetInputImage() { return this->Superclass::GetInput(); } void SetInputImage(const InputImageType * img) { this->Superclass::SetInput(img); } /** Gets/Sets the ROI image */ InputROIImageType * GetROIImage() { return static_cast (this->itk::ProcessObject::GetInput(1)); } void SetROIImage(const InputROIImageType * img) { this->itk::ProcessObject::SetNthInput(1, const_cast(img)); } protected: ROIdataConversion(); ~ROIdataConversion() ITK_OVERRIDE {} void GenerateOutputInformation() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } /** Performs its job! */ void GenerateData() ITK_OVERRIDE; /** Count the number for sample in the training area */ SizeValueType GetNumberOfSample(); }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbROIdataConversion.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbROIdataConversion.txx000066400000000000000000000070321301006202600273150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbROIdataConversion_txx #define otbROIdataConversion_txx #include "itkVector.h" #include "otbROIdataConversion.h" #include "itkImageRegionIterator.h" namespace otb { template ROIdataConversion ::ROIdataConversion() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(2); } template void ROIdataConversion ::GenerateOutputInformation(void) { typename OutputImageType::Pointer outputPtr = this->GetOutput(); typename OutputImageType::SizeType outputSize = outputPtr->GetRequestedRegion().GetSize(); outputSize[0] = GetNumberOfSample(); outputPtr->SetRegions(outputSize); } template void ROIdataConversion ::GenerateInputRequestedRegion(void) { typename InputImageType::Pointer inputImagePtr = const_cast(this->GetInputImage()); typename InputROIImageType::Pointer inputROIPtr = this->GetROIImage(); inputImagePtr->SetRequestedRegion(inputImagePtr->GetLargestPossibleRegion()); inputROIPtr->SetRequestedRegion(inputROIPtr->GetLargestPossibleRegion()); } template void ROIdataConversion ::GenerateData() { typename InputImageType::Pointer inputImagePtr = const_cast(this->GetInputImage()); typename InputROIImageType::ConstPointer inputROIPtr = this->GetROIImage(); typename OutputImageType::Pointer outputPtr = this->GetOutput(); outputPtr->Allocate(); typename InputImageType::PixelType zero; itk::NumericTraits::SetLength(zero, outputPtr->GetNumberOfComponentsPerPixel()); outputPtr->FillBuffer(zero); itk::ImageRegionConstIterator inputIter (inputImagePtr, inputImagePtr->GetRequestedRegion()); itk::ImageRegionConstIterator trainingIter (inputROIPtr, inputROIPtr->GetRequestedRegion()); itk::ImageRegionIterator outputIter (outputPtr, outputPtr->GetRequestedRegion()); inputIter.GoToBegin(); trainingIter.GoToBegin(); outputIter.GoToBegin(); while (!trainingIter.IsAtEnd()) { if (trainingIter.Get() != 0) { outputIter.Set(inputIter.Get()); ++outputIter; } ++inputIter; ++trainingIter; } } template typename ROIdataConversion::SizeValueType ROIdataConversion ::GetNumberOfSample() { InputROIImagePointerType inputROIPtr = GetROIImage(); itk::ImageRegionConstIterator trainingIter(inputROIPtr, inputROIPtr->GetRequestedRegion()); trainingIter.GoToBegin(); SizeValueType count = 0L; while (!trainingIter.IsAtEnd()) { if (trainingIter.Get() != 0) count++; ++trainingIter; } return count; } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbRationalTransform.h000066400000000000000000000146711301006202600270440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRationalTransform_h #define otbRationalTransform_h #include "otbTransform.h" #include "itkMacro.h" namespace otb { /** \class RationalTransform * \brief This class implements a rational transfom * * A rational transform is a quotient of two polynomial functions. * * The degree of the numerator and denominator polynomial functions * can be set using the appropriate setters. * * The number of parameters is then the number of dimensions times * the numerator degree plus one times the denominator degree plus * one. * * Parameters in the parameters vector are in the following order: * dim0num0 dim0num1 ... dim0numN dim0denom0 dim0denom1 * ... dim0denomM ... dim1num0 ... dimDdenomM. * * \ingroup Transform * * \ingroup OTBProjection **/ template class ITK_EXPORT RationalTransform : public Transform { public: /** Standard class typedefs. */ typedef Transform Superclass; typedef RationalTransform Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; typedef itk::Vector SpacingType; typedef itk::Point OriginType; typedef typename Superclass::InverseTransformBasePointer InverseTransformBasePointer; typedef typename Superclass::ParametersType ParametersType; typedef typename Superclass::ParametersValueType ParametersValueType; typedef typename Superclass::NumberOfParametersType NumberOfParametersType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RationalTransform, Transform); itkStaticConstMacro(SpaceDimension, unsigned int, Dimension); /** Set the numerator degree */ void SetNumeratorDegree(unsigned int value) { this->m_NumeratorDegree = value; this->InitializeParameters(); } /** Get the numerator degree */ itkGetConstMacro(NumeratorDegree, unsigned int); /** Set the numerator degree */ void SetDenominatorDegree(unsigned int value) { this->m_DenominatorDegree = value; this->InitializeParameters(); } /** Get the denominator degree */ itkGetConstMacro(DenominatorDegree, unsigned int); /** The transform point method */ OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE { // Check for consistency if(this->GetNumberOfParameters() != this->m_Parameters.size()) { { itkExceptionMacro(<<"Wrong number of parameters: found "<m_Parameters.Size()<<", expected "<GetNumberOfParameters()); } } InputPointType inputPoint = point; OutputPointType outputPoint; unsigned int dimensionStride = (m_DenominatorDegree+1)+(m_NumeratorDegree+1); // Compute RPC transform for(unsigned int dim = 0; dim < SpaceDimension; ++dim) { //1) Initialize numerator and denominator TScalarType num = itk::NumericTraits::Zero; TScalarType denom = itk::NumericTraits::Zero; TScalarType currentPower = 1.; // 2) Compute numerator for(unsigned int numDegree = 0; numDegree <= m_NumeratorDegree; ++numDegree) { num+=this->m_Parameters[dim*dimensionStride+numDegree]*currentPower; currentPower*=inputPoint[dim]; } //3) Compute denominator currentPower = 1.; for(unsigned int denomDegree = 0; denomDegree <= m_DenominatorDegree; ++denomDegree) { denom+=this->m_Parameters[dim*dimensionStride+m_NumeratorDegree+denomDegree+1]*currentPower; currentPower*=inputPoint[dim]; } //4) Fill the output outputPoint[dim]=num/denom; } // Return the output point return outputPoint; } /** Get the number of parameters */ NumberOfParametersType GetNumberOfParameters() const ITK_OVERRIDE { return (static_cast ( (m_NumeratorDegree +1 + m_DenominatorDegree+1)*SpaceDimension )); } // Set parameter method void SetParameters(const typename Superclass::ParametersType & params) ITK_OVERRIDE { // Check for the appropriate size if(params.Size() != this->GetNumberOfParameters()) { itkExceptionMacro(<<"Wrong number of parameters: found "<GetNumberOfParameters()); } // Set parametersg this->m_Parameters = params; } /** Initialize Parameters size */ void InitializeParameters() { this->m_Parameters.SetSize(this->GetNumberOfParameters()); this->m_Parameters.Fill(0); unsigned int dimensionStride = (m_DenominatorDegree+1)+(m_NumeratorDegree+1); for(unsigned int dim = 0; dim < SpaceDimension; ++dim) { this->m_Parameters[ dimensionStride *dim + m_NumeratorDegree+1] = 1.; } } protected: RationalTransform() : Superclass(16), m_NumeratorDegree(3), m_DenominatorDegree(3) { this->InitializeParameters(); } ~RationalTransform() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << indent << "Numerator Degree : " << m_NumeratorDegree << std::endl; os << indent << "Denominator Degree : " << m_DenominatorDegree << std::endl; } private: RationalTransform(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Degree of numerator unsigned int m_NumeratorDegree; // Degree of denominator unsigned int m_DenominatorDegree; }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbSVY21MapProjection.h000066400000000000000000000043541301006202600267130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVY21MapProjection_h #define otbSVY21MapProjection_h #include "otbTransMercatorMapProjection.h" namespace otb { /** \class SVY21MapProjection * \brief This class implements the SVY21 map projection (Singapore geodesic system). * It converts coordinates in longitude, latitude (WGS84) to SVY21 map coordinates. * * * \ingroup OTBProjection */ template class ITK_EXPORT SVY21MapProjection : public TransMercatorMapProjection { public: /** Standard class typedefs. */ typedef SVY21MapProjection Self; typedef TransMercatorMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SVY21MapProjection, TransMercatorMapProjection); protected: SVY21MapProjection() { this->SetParameter("OriginX", "103.83333333333333"); this->SetParameter("OriginY", "1.3666666666666667"); this->SetParameter("Datum", "WE"); this->SetParameter("FalseNorthing", "38744.572"); this->SetParameter("FalseEasting", "28001.642"); this->SetParameter("ScaleFactor", "1.00"); } ~SVY21MapProjection() ITK_OVERRIDE {} private: SVY21MapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbSinusoidalMapProjection.h000066400000000000000000000044611301006202600302000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinusoidalMapProjection_h #define otbSinusoidalMapProjection_h #include "otbGenericMapProjection.h" namespace otb { /** \class SinusoidalMapProjection * \brief This class implements the Sinusoidal map projection. * It converts coordinates in longitude, latitude (WGS84) to Sinusoidal map coordinates. * * \ingroup OTBProjection */ template class ITK_EXPORT SinusoidalMapProjection : public GenericMapProjection { public: /** Standard class typedefs. */ typedef SinusoidalMapProjection Self; typedef GenericMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SinusoidalMapProjection, GenericMapProjection); virtual void SetFalseEasting(double falseEasting); virtual void SetFalseNorthing(double falseNorthing); virtual double GetFalseNorthing() const; virtual double GetFalseEasting() const; virtual void SetParameters(double falseEasting, double falseNorthing); using Superclass::SetParameters; protected: SinusoidalMapProjection(); ~SinusoidalMapProjection() ITK_OVERRIDE; private: SinusoidalMapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSinusoidalMapProjection.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbSinusoidalMapProjection.txx000066400000000000000000000047541301006202600306010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSinusoidalMapProjection_txx #define otbSinusoidalMapProjection_txx #include "otbSinusoidalMapProjection.h" #include "otbUtils.h" namespace otb { template SinusoidalMapProjection ::SinusoidalMapProjection() { this->SetWkt("ossimSinusoidalProjection"); } template SinusoidalMapProjection ::~SinusoidalMapProjection() { } ///Set the false Easting template void SinusoidalMapProjection ::SetFalseEasting(double falseEasting) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->Modified(); } ///Set the False Northing template void SinusoidalMapProjection ::SetFalseNorthing(double falseNorthing) { this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } ///\return the False Northing (avoid negative coordinates) template double SinusoidalMapProjection ::GetFalseNorthing() const { double falseNorthing = atof(this->GetParameter("FalseNorthing").c_str()); return falseNorthing; } ///\return the False Easting (avoid negative coordinates) template double SinusoidalMapProjection ::GetFalseEasting() const { double falseEasting = atof(this->GetParameter("FalseEasting").c_str()); return falseEasting; } template void SinusoidalMapProjection ::SetParameters(double falseEasting, double falseNorthing) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } } #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbTileMapTransform.h000066400000000000000000000060431301006202600266200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileMapTransform_h #define otbTileMapTransform_h // Only for the enum definition #include "otbGenericMapProjection.h" namespace otb { /** \class TileMapTransform * \brief to do * * \ingroup OTBProjection **/ template class ITK_EXPORT TileMapTransform : public Transform // Number of dimensions in the output space { public: /** Standard class typedefs. */ typedef TileMapTransform Self; typedef Transform Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TileMapTransform, Transform); static const TransformDirection::TransformationDirection DirectionOfMapping = TTransformDirection; itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions); itkStaticConstMacro(SpaceDimension, unsigned int, NInputDimensions); itkStaticConstMacro(ParametersDimension, unsigned int, NInputDimensions * (NInputDimensions + 1)); itkGetConstMacro(Depth, int); itkSetMacro(Depth, int); void SetLevel(unsigned int level); unsigned int GetLevel() const; OutputPointType TransformPoint(const InputPointType& point) const ITK_OVERRIDE; virtual void PrintMap() const; /** FIXME with a Mercator projection definition*/ virtual std::string GetWkt() const { return "TileMapTransform"; } protected: TileMapTransform(); ~TileMapTransform() ITK_OVERRIDE; private: TileMapTransform(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented int m_Depth; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTileMapTransform.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbTileMapTransform.txx000066400000000000000000000067061301006202600272220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileMapTransform_txx #define otbTileMapTransform_txx #include "otbTileMapTransform.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { template TileMapTransform ::TileMapTransform() : Superclass(ParametersDimension), m_Depth(0) {} template TileMapTransform ::~TileMapTransform() {} template typename TileMapTransform::OutputPointType TileMapTransform ::TransformPoint(const InputPointType& point) const { OutputPointType outputPoint; if (DirectionOfMapping == TransformDirection::INVERSE) { outputPoint[0] = static_cast(point[0])/(1 << m_Depth)/256 *360.0-180.0; double y = static_cast(point[1])/(1 << m_Depth)/256; double ex = exp(4*CONST_PI*(y-0.5)); outputPoint[1] = -180.0/CONST_PI*asin((ex-1)/(ex+1)); } if (DirectionOfMapping == TransformDirection::FORWARD) { double x = (180.0 + point[0]) / 360.0; double y = - point[1] * CONST_PI / 180; // convert to radians y = 0.5 * log((1+sin(y)) / (1 - sin(y))); y *= 1.0/(2 * CONST_PI); // scale factor from radians to normalized y += 0.5; // and make y range from 0 - 1 outputPoint[0] = floor(x*pow(2., static_cast(m_Depth))*256); outputPoint[1] = floor(y*pow(2., static_cast(m_Depth))*256); } return outputPoint; } template void TileMapTransform ::PrintMap() const {} template void TileMapTransform ::SetLevel(unsigned int level) { this->SetDepth(level); } template unsigned int TileMapTransform ::GetLevel() const { return this->GetDepth(); } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbTransMercatorMapProjection.h000066400000000000000000000047061301006202600306540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTransMercatorMapProjection_h #define otbTransMercatorMapProjection_h #include "otbGenericMapProjection.h" namespace otb { /** \class TransMercatorMapProjection * \brief This class implements the TransMercator map projection. * It converts coordinates in longitude, latitude (WGS84) to TransMercator map coordinates. * * * \ingroup OTBProjection */ template class ITK_EXPORT TransMercatorMapProjection : public GenericMapProjection { public: /** Standard class typedefs. */ typedef TransMercatorMapProjection Self; typedef GenericMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TransMercatorMapProjection, GenericMapProjection); virtual void SetFalseEasting(double falseEasting); virtual void SetFalseNorthing(double falseNorthing); virtual void SetScaleFactor(double scaleFactor); virtual void SetParameters(double falseEasting, double falseNorthing, double scaleFactor); using Superclass::SetParameters; virtual double GetFalseNorthing() const; virtual double GetFalseEasting() const; virtual double GetScaleFactor() const; protected: TransMercatorMapProjection(); ~TransMercatorMapProjection() ITK_OVERRIDE; private: TransMercatorMapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTransMercatorMapProjection.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbTransMercatorMapProjection.txx000066400000000000000000000070551301006202600312500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTransMercatorMapProjection_txx #define otbTransMercatorMapProjection_txx #include "otbTransMercatorMapProjection.h" #include "otbUtils.h" namespace otb { template TransMercatorMapProjection ::TransMercatorMapProjection() { this->SetWkt("ossimTransMercatorProjection"); this->SetParameter("OriginX", "49.83"); //TODO check where this is coming from this->SetParameter("OriginY", "6.16"); // FIXME // ossimEllipsoid ellipsoid = *(ossimEllipsoidFactory::instance()->create("WE")); // ossimGpt origin(49.83, 6.16); //TODO check where this is coming from // this->m_MapProjection->setEllipsoid(ellipsoid); // this->m_MapProjection->setOrigin(origin); } /// Desctructor template TransMercatorMapProjection ::~TransMercatorMapProjection() { } ///Set the false Easting template void TransMercatorMapProjection ::SetFalseEasting(double falseEasting) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->Modified(); } ///Set the False Northing template void TransMercatorMapProjection ::SetFalseNorthing(double falseNorthing) { this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->Modified(); } ///Set the scale factor template void TransMercatorMapProjection ::SetScaleFactor(double scaleFactor) { this->SetParameter("ScaleFactor", Utils::ConvertToString(scaleFactor)); this->Modified(); } ///Set the parameters template void TransMercatorMapProjection ::SetParameters(double falseEasting, double falseNorthing, double scaleFactor) { this->SetParameter("FalseEasting", Utils::ConvertToString(falseEasting)); this->SetParameter("FalseNorthing", Utils::ConvertToString(falseNorthing)); this->SetParameter("ScaleFactor", Utils::ConvertToString(scaleFactor)); this->Modified(); } ///\return the scale factor template double TransMercatorMapProjection ::GetScaleFactor() const { double scaleFactor = atof(this->GetParameter("ScaleFactor").c_str()); return scaleFactor; } ///\return the false northing (avoid negative coordinates) template double TransMercatorMapProjection ::GetFalseNorthing() const { double falseNorthing = atof(this->GetParameter("FalseNorthing").c_str()); return falseNorthing; } ///\return the false easting (avoid negative coordinates) template double TransMercatorMapProjection ::GetFalseEasting() const { double falseEasting = atof(this->GetParameter("FalseEasting").c_str()); return falseEasting; } } #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbUtmMapProjection.h000066400000000000000000000042351301006202600266320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUtmMapProjection_h #define otbUtmMapProjection_h #include "otbGenericMapProjection.h" namespace otb { /** \class UtmMapProjection * \brief This class implements the UTM map projection. * * It converts coordinates in longitude, latitude (WGS84) to UTM map coordinates. * * * \ingroup OTBProjection */ template class ITK_EXPORT UtmMapProjection : public GenericMapProjection { public: /** Standard class typedefs. */ typedef UtmMapProjection Self; typedef GenericMapProjection Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::ScalarType ScalarType; typedef itk::Point InputPointType; typedef itk::Point OutputPointType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UtmMapProjection, GenericMapProjection); virtual void SetZone(long zone); virtual void SetHemisphere(char hemisphere); virtual int GetZone() const; virtual char GetHemisphere() const; virtual void SetZoneAndHemisphereFromGeoPoint(const InputPointType& geoPoint); protected: UtmMapProjection(); ~UtmMapProjection() ITK_OVERRIDE {}; private: UtmMapProjection(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUtmMapProjection.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbUtmMapProjection.txx000066400000000000000000000044531301006202600272300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUtmMapProjection_txx #define otbUtmMapProjection_txx #include "otbUtmMapProjection.h" #include "otbUtils.h" namespace otb { template UtmMapProjection ::UtmMapProjection() { this->SetWkt("ossimUtmProjection"); } ///Set the zone template void UtmMapProjection ::SetZone(long zone) { this->SetParameter("Zone", Utils::ConvertToString(zone)); this->Modified(); } ///Set the hemisphere template void UtmMapProjection ::SetHemisphere(char hemisphere) { this->SetParameter("Hemisphere", Utils::ConvertToString(hemisphere)); this->Modified(); } template void UtmMapProjection ::SetZoneAndHemisphereFromGeoPoint(const InputPointType& geoPoint) { if (geoPoint[1] > 0.) this->SetParameter("Hemisphere", "N"); else this->SetParameter("Hemisphere", "S"); int zone = Utils::GetZoneFromGeoPoint(geoPoint[0], geoPoint[1]); this->SetParameter("Zone", Utils::ConvertToString(zone)); } ///\return the zone template int UtmMapProjection ::GetZone() const { int zone = atoi(this->GetParameter("Zone").c_str()); return zone; } ///\return the hemisphere template char UtmMapProjection ::GetHemisphere() const { //If this happens, we have to better control the instantiation of //the projection. assert(this->GetParameter("Hemisphere").size() > 0); char hemisphere = this->GetParameter("Hemisphere")[0]; return hemisphere; } } #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbVectorDataIntoImageProjectionFilter.h000066400000000000000000000104011301006202600324160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataIntoImageProjectionFilter_h #define otbVectorDataIntoImageProjectionFilter_h #include "otbImage.h" #include "otbVectorDataProjectionFilter.h" #include "otbVectorDataExtractROI.h" namespace otb { /** \class VectorDataIntoImageProjectionFilter * \brief Reproject vector data into the coordinate system of an image * * * \ingroup VectorDataFilter * \ingroup Projection * * * * \ingroup OTBProjection */ template class ITK_EXPORT VectorDataIntoImageProjectionFilter : public otb::VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataIntoImageProjectionFilter Self; typedef otb::VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** VectorData typedefs. */ typedef TInputVectorData InputVectorDataType; typedef typename TInputVectorData::ConstPointer InputVectorDataPointer; /** Image typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer ImagePointerType; typedef itk::Vector SpacingType; typedef itk::Point OriginType; // use to display vectordata typedef itk::PreOrderTreeIterator TreeIteratorType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataIntoImageProjectionFilter, VectorDataToVectorDataFilter); void SetInputVectorData(InputVectorDataPointer input) { this->SetInput(input); } void SetInputImage(ImagePointerType input) { m_InputImage = input; } /** Set the origin of the output vector data. * \sa GetOrigin() */ itkSetMacro(OutputOrigin, OriginType); virtual void SetOutputOrigin(const double origin[2]); virtual void SetOutputOrigin(const float origin[2]); itkGetConstReferenceMacro(OutputOrigin, OriginType); /** Set the spacing (size of a pixel) of the output vector data. * \sa GetSpacing() */ virtual void SetOutputSpacing(const SpacingType& spacing); virtual void SetOutputSpacing(const double spacing[2]); virtual void SetOutputSpacing(const float spacing[2]); itkGetConstReferenceMacro(OutputSpacing, SpacingType); virtual void SetUseOutputSpacingAndOriginFromImage(bool flag); protected: VectorDataIntoImageProjectionFilter(); ~VectorDataIntoImageProjectionFilter() ITK_OVERRIDE {} void GenerateData(void) ITK_OVERRIDE; // Projection filter typedef VectorDataProjectionFilter VectorDataProjectionFilterType; typedef VectorDataExtractROI VectorDataExtractROIType; typedef typename VectorDataExtractROIType::RegionType RemoteSensingRegionType; private: VectorDataIntoImageProjectionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ImagePointerType m_InputImage; typename VectorDataProjectionFilterType::Pointer m_VdProjFilter; typename VectorDataExtractROIType::Pointer m_VdExtractFilter; SpacingType m_OutputSpacing; OriginType m_OutputOrigin; bool m_UseOutputSpacingAndOriginFromImage; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataIntoImageProjectionFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbVectorDataIntoImageProjectionFilter.txx000066400000000000000000000176611301006202600330310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataIntoImageProjectionFilter_txx #define otbVectorDataIntoImageProjectionFilter_txx #include "otbVectorDataIntoImageProjectionFilter.h" #include "otb_boost_string_header.h" namespace otb { /** * Constructor */ template VectorDataIntoImageProjectionFilter ::VectorDataIntoImageProjectionFilter() { m_OutputSpacing.Fill(1); m_OutputOrigin.Fill(0); m_UseOutputSpacingAndOriginFromImage = false; m_VdExtractFilter = VectorDataExtractROIType::New(); m_VdProjFilter = VectorDataProjectionFilterType::New(); m_VdProjFilter->SetInput(m_VdExtractFilter->GetOutput()); } template void VectorDataIntoImageProjectionFilter ::SetUseOutputSpacingAndOriginFromImage(bool flag) { m_UseOutputSpacingAndOriginFromImage = flag; } //---------------------------------------------------------------------------- template void VectorDataIntoImageProjectionFilter ::SetOutputSpacing(const SpacingType& spacing) { itkDebugMacro("setting Spacing to " << spacing); if (this->m_OutputSpacing != spacing) { this->m_OutputSpacing = spacing; this->Modified(); } } //---------------------------------------------------------------------------- template void VectorDataIntoImageProjectionFilter ::SetOutputSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetOutputSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataIntoImageProjectionFilter ::SetOutputSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetOutputSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataIntoImageProjectionFilter ::SetOutputOrigin(const double origin[2]) { OriginType p(origin); this->SetOutputOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataIntoImageProjectionFilter ::SetOutputOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetOutputOrigin(p); } /** * GenerateData Performs the coordinate conversion for each element in the tree */ template void VectorDataIntoImageProjectionFilter ::GenerateData(void) { m_VdExtractFilter->SetInput(this->GetInput()); typedef typename ImageType::PointType PointType; typedef typename ImageType::SizeType SizeType; if (m_InputImage.IsNull()) { itkExceptionMacro("Invalid input image."); } /*std::cout << "Spacing of the input image: "<< m_InputImage->GetSpacing() << std::endl; std::cout << "Origin of the input image: "<< m_InputImage->GetOrigin() << std::endl; std::cout << "Size of the input image: "<< m_InputImage->GetLargestPossibleRegion() << std::endl; std::cout << "ProjRef of the input image: "<< m_InputImage->GetProjectionRef() << std::endl; std::cout << "ProjRef of the input vector data: "<< this->GetInput()->GetProjectionRef() << std::endl; */ // Get the index of the corner of the image PointType pul, pur, pll, plr; itk::ContinuousIndex ul(m_InputImage->GetLargestPossibleRegion().GetIndex()); ul[0] += -0.5; ul[1] += -0.5; itk::ContinuousIndex ur(ul); itk::ContinuousIndex ll(ul); itk::ContinuousIndex lr(ul); SizeType size = m_InputImage->GetLargestPossibleRegion().GetSize(); ur[0] += size[0]; lr[0] += size[0]; lr[1] += size[1]; ll[1] += size[1]; //std::cout << "bounding box of the input image (pixel): "<< ur << ", " << ul << ", " << lr << ", " << ll << std::endl; // Transform to physical point m_InputImage->TransformContinuousIndexToPhysicalPoint(ul, pul); m_InputImage->TransformContinuousIndexToPhysicalPoint(ur, pur); m_InputImage->TransformContinuousIndexToPhysicalPoint(ll, pll); m_InputImage->TransformContinuousIndexToPhysicalPoint(lr, plr); //std::cout << "bounding box of the input image (physical): "<< pur << ", " << pul << ", " << plr << ", " << pll << std::endl; // Build the cartographic region RemoteSensingRegionType rsRegion; typename RemoteSensingRegionType::IndexType rsOrigin; typename RemoteSensingRegionType::SizeType rsSize; rsOrigin[0] = std::min(pul[0], plr[0]); rsOrigin[1] = std::min(pul[1], plr[1]); rsSize[0] = vcl_abs(pul[0] - plr[0]); rsSize[1] = vcl_abs(pul[1] - plr[1]); rsRegion.SetOrigin(rsOrigin); rsRegion.SetSize(rsSize); if (m_InputImage->GetProjectionRef().empty() || boost::algorithm::istarts_with(m_InputImage->GetProjectionRef(), "LOCAL_CS") ) { rsRegion.SetKeywordList(m_InputImage->GetImageKeywordlist()); } else { rsRegion.SetRegionProjection(m_InputImage->GetProjectionRef()); } //std::cout << "remote sensing region origin and size (physical): " << rsOrigin << ", " << rsSize << std::endl; //std::cout << "remote sensing region ProjRef: " << rsRegion.GetRegionProjection() << std::endl; // Set the cartographic region to the extract roi filter m_VdExtractFilter->SetRegion(rsRegion); // Reproject VectorData in image projection m_VdProjFilter->SetInputProjectionRef(this->GetInput()->GetProjectionRef()); if (m_InputImage->GetProjectionRef().empty() || boost::algorithm::istarts_with(m_InputImage->GetProjectionRef(), "LOCAL_CS") ) { m_VdProjFilter->SetOutputKeywordList(m_InputImage->GetImageKeywordlist()); } else { m_VdProjFilter->SetOutputProjectionRef(m_InputImage->GetProjectionRef()); } if (m_UseOutputSpacingAndOriginFromImage) { m_VdProjFilter->SetOutputOrigin(m_InputImage->GetOrigin()); m_VdProjFilter->SetOutputSpacing(m_InputImage->GetSpacing()); } else { m_VdProjFilter->SetOutputOrigin(this->GetOutputOrigin()); m_VdProjFilter->SetOutputSpacing(this->GetOutputSpacing()); } m_VdProjFilter->Update(); /* TreeIteratorType itVector(m_VdProjFilter->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPolygonFeature()) { std::cout << "----------\n" <GetNodeTypeAsString() << std::endl; std::cout << "List of vertices: " << ": " <GetPolygonExteriorRing()->GetVertexList()->Size(); itPoints++) { std::cout << "vertex[" << itPoints << "]: " << itVector.Get()->GetPolygonExteriorRing()->GetVertexList()->GetElement(itPoints) <GetPolygonExteriorRing()->GetBoundingRegion() << std::endl; } ++itVector; } */ if (m_UseOutputSpacingAndOriginFromImage) { m_VdProjFilter->GetOutput()->SetProjectionRef(""); } this->GraftOutput(m_VdProjFilter->GetOutput()); this->UpdateProgress(1.0f); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbVectorDataProjectionFilter.h000066400000000000000000000204241301006202600306270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataProjectionFilter_h #define otbVectorDataProjectionFilter_h #include "otbVectorDataToVectorDataFilter.h" #include "otbGenericRSTransform.h" #include "otbImageKeywordlist.h" namespace otb { /** \class VectorDataProjectionFilter * \brief Reproject vector data in a different coordinate system * * This class is used to reproject vector data into a different coordinate system. * the input and output coordinate system can be a map projection, a raw image from a * sensor (the sensor model will be used), or the local coordinate system of an image. * * This filter works on otb::VectorData as input and output. * * The process goes as follow: * - offset/scaling of the input coordinates * - transform to get the data in geographic coordinates (lon/lat) * - transform from geographic coordinates * - offset/scaling of the output coordinates * * Each of this step is optional and would default to an identity transform if nothing * is specified. * * The offset/scaling steps are necessary only when working with the local coordinate * system of the image (origin on the top left). The value need to be provided by the * SetInputSpacing, SetInputOrigin, SetOutputSpacing and SetOutputOrigin methods. * * The two transforms derived from itk::Transform and will be instantiated as * otb::GenericMapProjection or otb::InverseSensorModel or otb::ForwardSensorModel * (according to the available information). * * \ingroup VectorDataFilter * \ingroup Projection * * \example Projections/VectorDataProjectionExample.cxx * * * \ingroup OTBProjection */ template class ITK_EXPORT VectorDataProjectionFilter : public otb::VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataProjectionFilter Self; typedef otb::VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputVectorData InputVectorDataType; typedef TOutputVectorData OutputVectorDataType; typedef typename TInputVectorData::ConstPointer InputVectorDataPointer; typedef typename TOutputVectorData::Pointer OutputVectorDataPointer; /** Some typedefs. */ typedef itk::Transform GenericTransformType; typedef typename GenericTransformType::Pointer GenericTransformPointerType; // typedef otb::CompositeTransform InternalTransformType; typedef otb::GenericRSTransform InternalTransformType; typedef typename InternalTransformType::Pointer InternalTransformPointerType; typedef itk::Vector SpacingType; typedef itk::Point OriginType; typedef typename OutputVectorDataType::DataNodeType OutputDataNodeType; typedef typename InputVectorDataType::DataNodeType InputDataNodeType; typedef typename InputVectorDataType::DataTreeType::TreeNodeType InputInternalTreeNodeType; typedef typename OutputVectorDataType::DataTreeType::TreeNodeType OutputInternalTreeNodeType; typedef typename InputDataNodeType::PointType InputPointType; typedef typename InputDataNodeType::LineType InputLineType; typedef typename InputDataNodeType::PolygonType InputPolygonType; typedef typename InputDataNodeType::PolygonListType InputPolygonListType; typedef typename InputLineType::Pointer InputLinePointerType; typedef typename InputPolygonType::Pointer InputPolygonPointerType; typedef typename InputPolygonListType::Pointer InputPolygonListPointerType; typedef typename OutputDataNodeType::PointType OutputPointType; typedef typename OutputDataNodeType::LineType OutputLineType; typedef typename OutputDataNodeType::PolygonType OutputPolygonType; typedef typename OutputDataNodeType::PolygonListType OutputPolygonListType; typedef typename OutputLineType::Pointer OutputLinePointerType; typedef typename OutputPolygonType::Pointer OutputPolygonPointerType; typedef typename OutputPolygonListType::Pointer OutputPolygonListPointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataProjectionFilter, VectorDataToVectorDataFilter); /** Set/Get for input and output projections. */ itkSetStringMacro(InputProjectionRef); itkGetStringMacro(InputProjectionRef); itkSetStringMacro(OutputProjectionRef); itkGetStringMacro(OutputProjectionRef); itkGetMacro(InputKeywordList, ImageKeywordlist); void SetInputKeywordList(const ImageKeywordlist& kwl) { this->m_InputKeywordList = kwl; this->Modified(); } itkGetMacro(OutputKeywordList, ImageKeywordlist); void SetOutputKeywordList(const ImageKeywordlist& kwl) { this->m_OutputKeywordList = kwl; this->Modified(); } /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(InputOrigin, OriginType); virtual void SetInputOrigin(const double origin[2]); virtual void SetInputOrigin(const float origin[2]); itkGetConstReferenceMacro(InputOrigin, OriginType); /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ virtual void SetInputSpacing(const SpacingType& spacing); virtual void SetInputSpacing(const double spacing[2]); virtual void SetInputSpacing(const float spacing[2]); itkGetConstReferenceMacro(InputSpacing, SpacingType); /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(OutputOrigin, OriginType); virtual void SetOutputOrigin(const double origin[2]); virtual void SetOutputOrigin(const float origin[2]); itkGetConstReferenceMacro(OutputOrigin, OriginType); /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ virtual void SetOutputSpacing(const SpacingType& spacing); virtual void SetOutputSpacing(const double spacing[2]); virtual void SetOutputSpacing(const float spacing[2]); itkGetConstReferenceMacro(OutputSpacing, SpacingType); protected: VectorDataProjectionFilter(); ~VectorDataProjectionFilter() ITK_OVERRIDE {} OutputPointType ProcessPoint(InputPointType point) const ITK_OVERRIDE; OutputLinePointerType ProcessLine(InputLinePointerType line) const ITK_OVERRIDE; OutputPolygonPointerType ProcessPolygon(InputPolygonPointerType polygon) const ITK_OVERRIDE; OutputPolygonListPointerType ProcessPolygonList(InputPolygonListPointerType polygonList) const ITK_OVERRIDE; virtual void InstantiateTransform(void); /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ void InstanciateTransform() { otbWarningMacro( << "InstanciateTransform has been deprecated. Please use InstanciateTransform() instead"); this->InstantiateTransform(); } void GenerateOutputInformation(void) ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; private: VectorDataProjectionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InternalTransformPointerType m_Transform; std::string m_InputProjectionRef; std::string m_OutputProjectionRef; ImageKeywordlist m_InputKeywordList; ImageKeywordlist m_OutputKeywordList; SpacingType m_InputSpacing; OriginType m_InputOrigin; SpacingType m_OutputSpacing; OriginType m_OutputOrigin; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataProjectionFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbVectorDataProjectionFilter.txx000066400000000000000000000303131301006202600312210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataProjectionFilter_txx #define otbVectorDataProjectionFilter_txx #include "otbVectorDataProjectionFilter.h" #include "itkProgressReporter.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "itkTimeProbe.h" namespace otb { /** * Constructor */ template VectorDataProjectionFilter ::VectorDataProjectionFilter() { m_InputProjectionRef.clear(); m_OutputProjectionRef.clear(); m_InputKeywordList.Clear(); m_OutputKeywordList.Clear(); m_InputSpacing.Fill(1); m_InputOrigin.Fill(0); m_OutputSpacing.Fill(1); m_OutputOrigin.Fill(0); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetInputSpacing(const SpacingType& spacing) { itkDebugMacro("setting Spacing to " << spacing); if (this->m_InputSpacing != spacing) { this->m_InputSpacing = spacing; this->Modified(); } } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetInputSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetInputSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetInputSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetInputSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetInputOrigin(const double origin[2]) { OriginType p(origin); this->SetInputOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetInputOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetInputOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetOutputSpacing(const SpacingType& spacing) { itkDebugMacro("setting Spacing to " << spacing); if (this->m_OutputSpacing != spacing) { this->m_OutputSpacing = spacing; this->Modified(); } } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetOutputSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetOutputSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetOutputSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetOutputSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetOutputOrigin(const double origin[2]) { OriginType p(origin); this->SetOutputOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataProjectionFilter ::SetOutputOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetOutputOrigin(p); } template void VectorDataProjectionFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); OutputVectorDataPointer output = this->GetOutput(); itk::MetaDataDictionary& dict = output->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, m_OutputProjectionRef); } /** * Convert point */ template typename VectorDataProjectionFilter::OutputPointType VectorDataProjectionFilter ::ProcessPoint(InputPointType pointCoord) const { itk::Point point; point = m_Transform->TransformPoint(pointCoord); return point; } /** * Convert line */ template typename VectorDataProjectionFilter::OutputLinePointerType VectorDataProjectionFilter ::ProcessLine(InputLinePointerType line) const { typedef typename InputLineType::VertexListType::ConstPointer VertexListConstPointerType; typedef typename InputLineType::VertexListConstIteratorType VertexListConstIteratorType; VertexListConstPointerType vertexList = line->GetVertexList(); VertexListConstIteratorType it = vertexList->Begin(); typename OutputLineType::Pointer newLine = OutputLineType::New(); while (it != vertexList->End()) { itk::Point point; itk::ContinuousIndex index; typename InputLineType::VertexType pointCoord = it.Value(); point = m_Transform->TransformPoint(pointCoord); index[0] = point[0]; index[1] = point[1]; // otbMsgDevMacro(<< "Converting: " << it.Value() << " -> " << pointCoord << " -> " << point << " -> " << index); newLine->AddVertex(index); ++it; } return newLine; } /** * Convert polygon */ template typename VectorDataProjectionFilter::OutputPolygonPointerType VectorDataProjectionFilter ::ProcessPolygon(InputPolygonPointerType polygon) const { typedef typename InputPolygonType::VertexListType::ConstPointer VertexListConstPointerType; typedef typename InputPolygonType::VertexListConstIteratorType VertexListConstIteratorType; VertexListConstPointerType vertexList = polygon->GetVertexList(); VertexListConstIteratorType it = vertexList->Begin(); typename OutputPolygonType::Pointer newPolygon = OutputPolygonType::New(); while (it != vertexList->End()) { itk::Point point; itk::ContinuousIndex index; typename InputPolygonType::VertexType pointCoord = it.Value(); point = m_Transform->TransformPoint(pointCoord); index[0] = point[0]; index[1] = point[1]; newPolygon->AddVertex(index); ++it; } return newPolygon; } /** * Convert polygon list */ template typename VectorDataProjectionFilter::OutputPolygonListPointerType VectorDataProjectionFilter ::ProcessPolygonList(InputPolygonListPointerType polygonList) const { OutputPolygonListPointerType newPolygonList = OutputPolygonListType::New(); for (typename InputPolygonListType::ConstIterator it = polygonList->Begin(); it != polygonList->End(); ++it) { newPolygonList->PushBack(this->ProcessPolygon(it.Get())); } return newPolygonList; } /** * Instantiate the transformation according to information */ template void VectorDataProjectionFilter ::InstantiateTransform(void) { // otbMsgDevMacro(<< "Information to instantiate transform (VectorDataProjectionFilter): "); // otbMsgDevMacro(<< " * Input Origin: " << m_InputOrigin); // otbMsgDevMacro(<< " * Input Spacing: " << m_InputSpacing); // otbMsgDevMacro(<< " * Input keyword list: " // << ((m_InputKeywordList.GetSize() == 0)?"Empty":"Full")); // otbMsgDevMacro(<< " * Input projection: " << m_InputProjectionRef); // otbMsgDevMacro(<< " * Output keyword list: " // << ((m_OutputKeywordList.GetSize() == 0)?"Empty":"Full")); // otbMsgDevMacro(<< " * Output projection: " << m_OutputProjectionRef); // otbMsgDevMacro(<< " * Output Origin: " << m_OutputOrigin); // otbMsgDevMacro(<< " * Output Spacing: " << m_OutputSpacing); m_Transform = InternalTransformType::New(); InputVectorDataPointer input = this->GetInput(); const itk::MetaDataDictionary& inputDict = input->GetMetaDataDictionary(); OutputVectorDataPointer output = this->GetOutput(); itk::MetaDataDictionary& outputDict = output->GetMetaDataDictionary(); // m_Transform->SetInputDictionary(input->GetMetaDataDictionary()); m_Transform->SetInputDictionary(inputDict); m_Transform->SetOutputDictionary(output->GetMetaDataDictionary()); m_Transform->SetInputProjectionRef(m_InputProjectionRef); m_Transform->SetOutputProjectionRef(m_OutputProjectionRef); m_Transform->SetInputKeywordList(m_InputKeywordList); m_Transform->SetOutputKeywordList(m_OutputKeywordList); m_Transform->SetInputSpacing(m_InputSpacing); m_Transform->SetInputOrigin(m_InputOrigin); m_Transform->SetOutputSpacing(m_OutputSpacing); m_Transform->SetOutputOrigin(m_OutputOrigin); m_Transform->InstantiateTransform(); // retrieve the output projection ref // if it is not specified and end up being geographic, // only the m_Transform will know m_OutputProjectionRef = m_Transform->GetOutputProjectionRef(); //If the projection information for the output is provided, propagate it if (m_OutputKeywordList.GetSize() != 0) { itk::EncapsulateMetaData(outputDict, MetaDataKey::OSSIMKeywordlistKey, m_OutputKeywordList); } if (!m_OutputProjectionRef.empty()) { itk::EncapsulateMetaData(outputDict, MetaDataKey::ProjectionRefKey, m_OutputProjectionRef); } output->SetSpacing(m_OutputSpacing); output->SetOrigin(m_OutputOrigin); } /** * GenerateData Performs the coordinate conversion for each element in the tree */ template void VectorDataProjectionFilter ::GenerateData(void) { this->AllocateOutputs(); InputVectorDataPointer inputPtr = this->GetInput(); OutputVectorDataPointer outputPtr = this->GetOutput(); //Instantiate the transform this->InstantiateTransform(); typedef typename OutputVectorDataType::DataTreePointerType OutputDataTreePointerType; OutputDataTreePointerType tree = outputPtr->GetDataTree(); // Get the input tree root InputInternalTreeNodeType * inputRoot = const_cast(inputPtr->GetDataTree()->GetRoot()); // Create the output tree root typedef typename OutputVectorDataType::DataNodePointerType OutputDataNodePointerType; OutputDataNodePointerType newDataNode = OutputDataNodeType::New(); newDataNode->SetNodeType(inputRoot->Get()->GetNodeType()); newDataNode->SetNodeId(inputRoot->Get()->GetNodeId()); typename OutputInternalTreeNodeType::Pointer outputRoot = OutputInternalTreeNodeType::New(); outputRoot->Set(newDataNode); tree->SetRoot(outputRoot); // Start recursive processing itk::TimeProbe chrono; chrono.Start(); this->ProcessNode(inputRoot, outputRoot); chrono.Stop(); otbMsgDevMacro(<< "VectoDataProjectionFilter: features Processed in " << chrono.GetMean() << " seconds."); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbVectorDataTransformFilter.h000066400000000000000000000111751301006202600304710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataTransformFilter_h #define otbVectorDataTransformFilter_h #include "otbVectorDataToVectorDataFilter.h" #include "itkTransform.h" #include "otbImageKeywordlist.h" #include "otbVectorData.h" namespace otb { /** \class VectorDataTransformFilter * \brief Apply a Transform To a VectorData * * This class is used to reproject vector data using a itk::Transform * the input and output coordinate system are the same * * \ingroup VectorDataFilter * \ingroup Projection * * \ingroup OTBProjection */ template class ITK_EXPORT VectorDataTransformFilter : public otb::VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataTransformFilter Self; typedef otb::VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputVectorData InputVectorDataType; typedef TOutputVectorData OutputVectorDataType; typedef typename TInputVectorData::ConstPointer InputVectorDataPointer; typedef typename TOutputVectorData::Pointer OutputVectorDataPointer; /** Some typedefs. */ typedef itk::Transform GenericTransformType; typedef typename GenericTransformType::Pointer GenericTransformPointerType; typedef itk::Vector SpacingType; typedef itk::Point OriginType; typedef typename InputVectorDataType::DataNodePointerType InputDataNodePointerType; typedef typename OutputVectorDataType::DataNodeType OutputDataNodeType; typedef typename OutputVectorDataType::DataNodePointerType OutputDataNodePointerType; typedef typename OutputVectorDataType::DataTreePointerType OutputDataTreePointerType; typedef typename InputVectorDataType::DataTreeType::TreeNodeType InputInternalTreeNodeType; typedef typename OutputVectorDataType::DataTreeType::TreeNodeType OutputInternalTreeNodeType; typedef typename InputInternalTreeNodeType::ChildrenListType InputChildrenListType; typedef typename OutputDataNodeType::PointType PointType; typedef typename OutputDataNodeType::LineType LineType; typedef typename OutputDataNodeType::LineConstPointerType LineConstPointerType; typedef typename OutputDataNodeType::LinePointerType LinePointerType; typedef typename OutputDataNodeType::PolygonType PolygonType; typedef typename OutputDataNodeType::PolygonConstPointerType PolygonConstPointerType; typedef typename OutputDataNodeType::PolygonPointerType PolygonPointerType; typedef typename OutputDataNodeType::PolygonListType PolygonListType; typedef typename OutputDataNodeType::PolygonListConstPointerType PolygonListConstPointerType; typedef typename OutputDataNodeType::PolygonListPointerType PolygonListPointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataTransformFilter, VectorDataToVectorDataFilter); /** Set The Transform applied to VectorData*/ itkSetObjectMacro(Transform, GenericTransformType); itkGetObjectMacro(Transform, GenericTransformType); protected: VectorDataTransformFilter(); ~VectorDataTransformFilter() ITK_OVERRIDE {}; PointType ProcessPoint(PointType point) const ITK_OVERRIDE; LinePointerType ProcessLine(LinePointerType line) const ITK_OVERRIDE; PolygonPointerType ProcessPolygon(PolygonPointerType polygon) const ITK_OVERRIDE; PolygonListPointerType ProcessPolygonList(PolygonListPointerType polygonList) const ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; private: VectorDataTransformFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented GenericTransformPointerType m_Transform; }; } // end namespace otb #ifndef ITK_MANUAL_INSTANTIATION #include "otbVectorDataTransformFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Projection/include/otbVectorDataTransformFilter.txx000066400000000000000000000130551301006202600310640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataTransformFilter_txx #define otbVectorDataTransformFilter_txx #include "otbVectorDataTransformFilter.h" #include "itkProgressReporter.h" #include #include "itkTimeProbe.h" namespace otb { /** * Constructor */ template VectorDataTransformFilter ::VectorDataTransformFilter() { // m_Transform = GenericTransformType::New(); // with ITK v4 you can't instantiate a transform (virtual). We do NOT want to // use the otb::Transform or we loose the capability of using all the existing // itk transform, so we just keep it as NULL and you have to be careful not // to burn yourself when using it. m_Transform = ITK_NULLPTR; } /** * Convert point */ template typename VectorDataTransformFilter::PointType VectorDataTransformFilter ::ProcessPoint(PointType pointCoord) const { itk::Point point; point = m_Transform->TransformPoint(pointCoord); return point; } /** * Convert line */ template typename VectorDataTransformFilter::LinePointerType VectorDataTransformFilter ::ProcessLine(LinePointerType line) const { typedef typename LineType::VertexListType::ConstPointer VertexListConstPointerType; typedef typename LineType::VertexListConstIteratorType VertexListConstIteratorType; VertexListConstPointerType vertexList = line->GetVertexList(); VertexListConstIteratorType it = vertexList->Begin(); typename LineType::Pointer newLine = LineType::New(); while ( it != vertexList->End()) { itk::Point point; itk::ContinuousIndex index; typename LineType::VertexType pointCoord = it.Value(); point = m_Transform->TransformPoint(pointCoord); index[0]=point[0]; index[1]=point[1]; if (!vnl_math_isnan(index[0]) && !vnl_math_isnan(index[1])) newLine->AddVertex(index); ++it; } return newLine; } /** * Convert polygon */ template typename VectorDataTransformFilter::PolygonPointerType VectorDataTransformFilter ::ProcessPolygon(PolygonPointerType polygon) const { typedef typename PolygonType::VertexListType::ConstPointer VertexListConstPointerType; typedef typename PolygonType::VertexListConstIteratorType VertexListConstIteratorType; VertexListConstPointerType vertexList = polygon->GetVertexList(); VertexListConstIteratorType it = vertexList->Begin(); typename PolygonType::Pointer newPolygon = PolygonType::New(); while ( it != vertexList->End()) { itk::Point point; itk::ContinuousIndex index; typename PolygonType::VertexType pointCoord = it.Value(); point = m_Transform->TransformPoint(pointCoord); index[0]=point[0]; index[1]=point[1]; if( !vnl_math_isnan(index[0]) && !vnl_math_isnan(index[1]) ) newPolygon->AddVertex(index); ++it; } return newPolygon; } /** * Convert polygon list */ template typename VectorDataTransformFilter::PolygonListPointerType VectorDataTransformFilter ::ProcessPolygonList(PolygonListPointerType polygonList) const { PolygonListPointerType newPolygonList = PolygonListType::New(); for (typename PolygonListType::ConstIterator it = polygonList->Begin(); it != polygonList->End(); ++it) { newPolygonList->PushBack(this->ProcessPolygon(it.Get())); } return newPolygonList; } /** * GenerateData Performs the coordinate conversion for each element in the tree */ template void VectorDataTransformFilter ::GenerateData(void) { Superclass::GenerateOutputInformation(); this->AllocateOutputs(); InputVectorDataPointer inputPtr = this->GetInput(); OutputVectorDataPointer outputPtr = this->GetOutput(); outputPtr->SetProjectionRef(inputPtr->GetProjectionRef()); OutputDataTreePointerType tree = outputPtr->GetDataTree(); // Get the input tree root InputInternalTreeNodeType * inputRoot = const_cast(inputPtr->GetDataTree()->GetRoot()); // Create the output tree root OutputDataNodePointerType newDataNode = OutputDataNodeType::New(); newDataNode->SetNodeType(inputRoot->Get()->GetNodeType()); newDataNode->SetNodeId(inputRoot->Get()->GetNodeId()); typename OutputInternalTreeNodeType::Pointer outputRoot = OutputInternalTreeNodeType::New(); outputRoot->Set(newDataNode); tree->SetRoot(outputRoot); // Start recursive processing itk::TimeProbe chrono; chrono.Start(); this->ProcessNode(inputRoot, outputRoot); chrono.Stop(); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Projection/otb-module.cmake000066400000000000000000000015641301006202600241440ustar00rootroot00000000000000set(DOCUMENTATION "Map projections describe the link between geographic coordinates and cartographic ones. So map projections allow representing a 2-dimensional manifold of a 3-dimensional space (the Earth surface) in a 2-dimensional space (a map which used to be a sheet of paper!). This module provides classes generically related to this purpose. for instance, user can handle OGR data type, find RPC solvers, re-project input vector data over input images, and so on.") otb_module(OTBProjection ENABLE_SHARED DEPENDS OTBBoostAdapters OTBCommon OTBGDAL OTBGdalAdapters OTBITK OTBImageBase OTBImageManipulation OTBMetadata OTBOSSIMAdapters OTBTransform OTBVectorDataBase OTBVectorDataManipulation TEST_DEPENDS OTBCommandLineParser OTBImageIO OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/Projection/src/000077500000000000000000000000001301006202600216545ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Projection/src/CMakeLists.txt000066400000000000000000000010121301006202600244060ustar00rootroot00000000000000set(OTBProjection_SRC otbGeometriesProjectionFilter.cxx otbPleiadesPToXSAffineTransformCalculator.cxx ) add_library(OTBProjection ${OTBProjection_SRC}) target_link_libraries(OTBProjection ${OTBVectorDataBase_LIBRARIES} ${OTBGdalAdapters_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBMetadata_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBGDAL_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBProjection) OTB-release-5.8/Modules/Filtering/Projection/src/otbGeometriesProjectionFilter.cxx000066400000000000000000000204121301006202600304120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesProjectionFilter.h" #include #include #include "ogr_srs_api.h" // OCTDestroyCoordinateTransformation #include "ogr_spatialref.h" // OGRCoordinateTransformation #include "itkMacro.h" #include "otbGeometriesSet.h" #include "itkMetaDataObject.h" #include "otbOGRGeometryWrapper.h" #include "otbOGRGeometriesVisitor.h" /*===========================================================================*/ /*======================[ Reprojection Transformation ]======================*/ /*===========================================================================*/ #if 0 void do_transform(OGRLinearRing & g) const { assert(!"don't know how to reproject a ring yet"); } #endif void otb::internal::ReprojectTransformationFunctor::do_transform(OGRPoint & g) const { typedef InternalTransformType::InputPointType InputPointType; typedef InternalTransformType::OutputPointType OutputPointType; // in our case: BOOST_MPL_ASSERT((boost::is_same)); const double rawPoint[] = { g.getX(), g.getY() }; const InputPointType inPoint(rawPoint); const OutputPointType outPoint = m_Transform->TransformPoint(inPoint); g.setX(outPoint[0]); g.setY(outPoint[1]); } void otb::internal::ReprojectTransformationFunctor::do_transform(OGRLineString & g) const { OGRPoint point; for (int i=0, N=g.getNumPoints(); i!=N; ++i) { g.getPoint(i, &point); do_transform(point); // no need to go through the redispatch cycle g.setPoint(i, &point); } } #if 0 void otb::internal::ReprojectTransformationFunctor::do_transform(OGRCurve & g) const { assert(!"OGRCurve is just an interface, they can't be reprojected yet"); } #endif void otb::internal::ReprojectTransformationFunctor::do_transform(OGRPolygon & g) const { // Note: OGRPolygon interface states that rings obtained through // getInteriorRing() and getExteriorRing() shall not be modified. // In this context, it seems to make sense as it gives a direct access to the // ring (yes this is a de-encapsulation), and the polygon is a fresh one has // just been cloned in the () operator. // The fact that OGRPolygon::transform() directly works on each sub-ring seems // to confirm that hyppothesis. for (int i=0, N=g.getNumInteriorRings(); i!=N; ++i) { OGRLinearRing * ring = g.getInteriorRing(i); assert(ring && "Rings in polygons are not expected to be nil"); if (ring) { do_transform(*ring); // no need to go through the redispatch cycle // how to commit the change ? Are ring modifications automatically committed ? } } OGRLinearRing * ring = g.getExteriorRing(); assert(ring && "Rings in polygons are not expected to be nil"); if (ring) { do_transform(*ring); // no need to go through the redispatch cycle // how to commit the change ? Are ring modifications automatically committed ? } } #if 0 void otb::internal::ReprojectTransformationFunctor::do_transform(OGRSurface & g) const { assert(!"OGRSurface is just an interface, they can't be reprojected yet"); } void otb::internal::ReprojectTransformationFunctor::do_transform(OGRMultiLineString & g) const { } void otb::internal::ReprojectTransformationFunctor::do_transform(OGRMultiPoint & g) const { } void otb::internal::ReprojectTransformationFunctor::do_transform(OGRMultiPolygon & g) const { } #endif void otb::internal::ReprojectTransformationFunctor::do_transform(OGRGeometryCollection & col) const { for (int i=0, N=col.getNumGeometries(); i!=N; ++i) { OGRGeometry * g = col.getGeometryRef(i); assert(g && "geometries to transform shall not be null"); apply_inplace(g); } } otb::ogr::UniqueGeometryPtr otb::internal::ReprojectTransformationFunctor::operator()(OGRGeometry const* in) const // otb::internal::ReprojectTransformationFunctor::apply(OGRGeometry const* in) const { otb::ogr::UniqueGeometryPtr res = ogr::apply(in, ByCopy(*this)); return otb::move(res); } void otb::internal::ReprojectTransformationFunctor::apply_inplace(OGRGeometry * inout) const { if (inout) ogr::apply(inout, InPlace(*this)); } /*===========================================================================*/ /*======================[ GeometriesProjectionFilter ]=======================*/ /*===========================================================================*/ otb::GeometriesProjectionFilter::GeometriesProjectionFilter() : m_InputImageReference(*this) , m_OutputImageReference(*this) { } /*virtual*/ otb::GeometriesProjectionFilter::~GeometriesProjectionFilter() { } /*virtual*/ void otb::GeometriesProjectionFilter::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); OutputGeometriesType::Pointer output = this->GetOutput(); itk::MetaDataDictionary& dict = output->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, m_OutputProjectionRef); } /*virtual*/ void otb::GeometriesProjectionFilter::DoFinalizeInitialization() { m_Transform = InternalTransformType::New(); // The InputProjectionRef can only be set once per layer, once the layer to // process is known // m_Transform->SetInputProjectionRef(m_InputProjectionRef); m_Transform->SetOutputProjectionRef(m_OutputProjectionRef); m_Transform->SetInputKeywordList(m_InputKeywordList); m_Transform->SetOutputKeywordList(m_OutputKeywordList); m_Transform->SetInputSpacing(m_InputImageReference.GetSpacing()); m_Transform->SetInputOrigin(m_InputImageReference.GetOrigin()); m_Transform->SetOutputSpacing(m_OutputImageReference.GetSpacing()); m_Transform->SetOutputOrigin(m_OutputImageReference.GetOrigin()); // As the InputProjectionRef can't be known yet, InstantiateTransform() will // be called from DoProcessLayer // m_Transform->InstantiateTransform(); m_TransformationFunctor->SetOnePointTransformation(m_Transform); // retrieve the output projection ref // if it is not specified and end up being geographic, // only the m_Transform will know m_OutputProjectionRef = m_Transform->GetOutputProjectionRef(); // InputGeometriesType::ConstPointer input = this->GetInput(); OutputGeometriesType::Pointer output = this->GetOutput(); output->SetImageReference(m_OutputImageReference); } /*virtual*/ OGRSpatialReference* otb::GeometriesProjectionFilter::DoDefineNewLayerSpatialReference( ogr::Layer const& itkNotUsed(source)) const { if (!m_OutputProjectionRef.empty()) { char const* wkt_string = m_OutputProjectionRef.c_str(); OGRSpatialReference * osr = static_cast (OSRNewSpatialReference(wkt_string)); return osr; } else { return ITK_NULLPTR; } } /*virtual*/ void otb::GeometriesProjectionFilter::DoProcessLayer(ogr::Layer const& source, ogr::Layer & destination) const { // Finish the initialization phase as somethings depends on the current layer // to process. m_Transform->SetInputProjectionRef(source.GetProjectionRef()); m_Transform->InstantiateTransform(); if (source == destination) { itkExceptionMacro(<<"Geometries projection filter cannot work in-place as the resulting layers will have a new spatial reference." " Please supply too different geometries sets to work on."); } m_TransformationFunctor(source, destination); // if TransformedElementType == layer } /*virtual*/ void otb::GeometriesProjectionFilter::DoDefineNewLayerFields(ogr::Layer const& source, ogr::Layer & dest) const { m_TransformationFunctor.DefineFields(source, dest); } OTB-release-5.8/Modules/Filtering/Projection/src/otbPleiadesPToXSAffineTransformCalculator.cxx000066400000000000000000000150671301006202600325610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPleiadesPToXSAffineTransformCalculator.h" #include "otbPleiadesImageMetadataInterface.h" #include "otbDateTimeAdapter.h" #include "otbImageKeywordlist.h" #include "itkMetaDataObject.h" namespace otb { bool PleiadesPToXSAffineTransformCalculator ::CanCompute(const itk::ImageBase<2> * panchromaticImage, const itk::ImageBase<2> * xsImage) { bool isPanPHR = false; bool isXSPHR = false; otb::PleiadesImageMetadataInterface::Pointer phrIMI = otb::PleiadesImageMetadataInterface::New(); phrIMI->SetMetaDataDictionary(panchromaticImage->GetMetaDataDictionary()); isPanPHR = phrIMI->CanRead(); phrIMI->SetMetaDataDictionary(xsImage->GetMetaDataDictionary()); isXSPHR = phrIMI->CanRead(); if (isPanPHR && isXSPHR) { ImageKeywordlist kwlPan; ImageKeywordlist kwlXS; itk::ExposeMetaData( panchromaticImage->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwlPan); itk::ExposeMetaData( xsImage->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwlXS); // Get geometric processing std::string panProcessing = kwlPan.GetMetadataByKey("support_data.processing_level"); std::string xsProcessing = kwlXS.GetMetadataByKey("support_data.processing_level"); if (panProcessing.compare("SENSOR") == 0 && xsProcessing.compare("SENSOR") == 0) { std::string pid = kwlPan.GetMetadataByKey("image_id"); std::string xsid = kwlXS.GetMetadataByKey("image_id"); pid = pid.substr(0,pid.size()-4); xsid = xsid.substr(0,xsid.size()-4); if(pid == xsid) { return true; } } } return false; } PleiadesPToXSAffineTransformCalculator ::OffsetType PleiadesPToXSAffineTransformCalculator ::ComputeOffset(const itk::ImageBase<2> * panchromaticImage, const itk::ImageBase<2> * xsImage) { if(!CanCompute(panchromaticImage,xsImage)) { itkGenericExceptionMacro("Can not compute affine transform between images, they do not correspond to Pleiades sensor bundle."); } ImageKeywordlist kwlPan; ImageKeywordlist kwlXS; itk::ExposeMetaData( panchromaticImage->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwlPan); itk::ExposeMetaData( xsImage->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, kwlXS); // Compute time delta std::string strStartTimePan = kwlPan.GetMetadataByKey("support_data.time_range_start"); std::string strStartTimeXS = kwlXS.GetMetadataByKey("support_data.time_range_start"); DateTimeAdapter::Pointer startTimePan = DateTimeAdapter::New(); DateTimeAdapter::Pointer startTimeXS = DateTimeAdapter::New(); startTimePan->SetFromIso8601(strStartTimePan); startTimeXS->SetFromIso8601(strStartTimeXS); double timeDelta = startTimeXS->GetDeltaInSeconds(startTimePan); // Retrieve line period in Pan std::string tmpStr = kwlPan.GetMetadataByKey("support_data.line_period"); double linePeriodPan = atof(tmpStr.c_str()); // Retrieve column start tmpStr = kwlPan.GetMetadataByKey("support_data.swath_first_col"); int colStartPan = atoi(tmpStr.c_str()); tmpStr = kwlXS.GetMetadataByKey("support_data.swath_first_col"); int colStartXS = atoi(tmpStr.c_str()); /** This code compute the shift between PAN and XS image from a bundle product in SENSOR geometry level using acquisition start time of XS and PAN images, as well as PAN sampling rate to get the shift in lines and FIRST_COL metadata to get shift in columns. Here are two examples of how this computation is done: Product 6543 XS PA START 17:16:57.2374640 17:16:57.2373170 Te 0.294 0.0735 FIRST_COL 3577 14304 deltaMS-PA = 0.000147 deltaMS-PA_nb_lin = deltaMS-PA / (TePA / 1000) = 2 lines deltacolMS-PA = (FIRST_COL _MS -1 )*4 + 1 - FIRST_COL_PA = 1 column Product 0445 XS PA START 17:20:45.2371140 17:20:45.2369670 Te 0.294 0.0735 FIRST_COL 526 2101 deltaMS-PA = 0.000147 deltaMS-PA_nb_lin = deltaMS-PA / (TePA / 1000) = 2 lines deltacolMS-PA = (FIRST_COL _MS -1 )*4 + 1 - FIRST_COL_PA = 0 column In order to get a transform from PAN physical space to XS physical space, we have to take into account two additional effects: - The shifts above must be multiplied by -1 to get the correct transform direction, - In SENSOR geometry level, sampling grids of XS and PAN product are phased, which means that a shift of 1.5 pixels must be added in both directions in order to get the upper-left corners of XS and PAN pixels to match. This leads to the following formula: */ double lineShift_MS_P = -vcl_floor((timeDelta/(linePeriodPan/1000)+0.5))+1.5; double colShift_MS_P = -((colStartXS-1)*4 - colStartPan + 1)+1.5; OffsetType offset; offset[0] = colShift_MS_P; offset[1] = lineShift_MS_P; return offset; } PleiadesPToXSAffineTransformCalculator ::TransformType::Pointer PleiadesPToXSAffineTransformCalculator ::Compute(const itk::ImageBase<2> * panchromaticImage, const itk::ImageBase<2> * xsImage) { // Compute the offset OffsetType offset = ComputeOffset(panchromaticImage,xsImage); // Apply the scaling typedef itk::ScalableAffineTransform TransformType; TransformType::Pointer transform = TransformType::New(); transform->SetIdentity(); // Apply the offset transform->Translate(offset); // Apply the scaling transform->Scale(0.25); return transform; } } // End namespace otb OTB-release-5.8/Modules/Filtering/Projection/test/000077500000000000000000000000001301006202600220445ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Projection/test/CMakeLists.txt000066400000000000000000001343411301006202600246120ustar00rootroot00000000000000otb_module_test() set(OTBProjectionTests otbSensorModel.cxx otbProjectionTestDriver.cxx otbVectorDataProjectionFilterFromGeoToMap.cxx otbOrthoRectificationFilter.cxx otbGCPsToRPCSensorModelImageFilterNew.cxx otbMapProjection.cxx otbGenericRSResampleImageFilter.cxx otbGeometriesProjectionFilter.cxx otbGenericRSTransformGenericTest.cxx otbLeastSquareAffineTransformEstimatorNew.cxx otbVectorDataTransformFilter.cxx otbRationalTransformToDisplacementFieldSource.cxx otbImportGeoInformationImageFilterNew.cxx otbVectorDataProjectionFilterFromMapToSensor.cxx otbCompositeTransformNew.cxx otbRationalTransform.cxx otbGeometriesProjectionFilterFromMapToSensor.cxx otbImageToEnvelopeVectorDataFilter.cxx otbMapProjectionsNew.cxx otbOrthoRectificationFilterNew.cxx otbImageToGenericRSOutputParameters.cxx otbGeometriesProjectionFilterFromMapToGeo.cxx otbROIdataConversion.cxx otbProjectionBaseNew.cxx otbVectorDataProjectionFilterFromMapToGeo.cxx otbPhysicalToRPCSensorModelImageFilter.cxx otbGeometriesProjectionFilterFromGeoToMap.cxx otbVectorDataProjectionFilterFromMapToImage.cxx otbGenericRSTransformFromImage.cxx otbCompositeTransform.cxx otbLeastSquareAffineTransformEstimator.cxx otbSpectralAngleDataNodeFeatureFunction.cxx otbROIdataConversionNew.cxx otbGCPsToRPCSensorModelImageFilterCheckRpcModel.cxx otbGeographicalDistance.cxx otbTileImageFilterRSTransformTest.cxx otbGCPsToRPCSensorModelImageFilterAndOrtho.cxx otbVectorDataIntoImageProjectionFilterTest.cxx otbVectorDataExtractROIandProjection.cxx otbGCPsToRPCSensorModelImageFilterWithoutDEM.cxx otbGeometriesProjectionFilterFromMapToImage.cxx otbGeometriesProjectionFilterFromMapToEPSG.cxx otbVectorDataProjectionFilter.cxx otbUtmMapProjection.cxx otbVectorDataProjectionFilterNew.cxx otbTileMapTransform.cxx otbImportGeoInformationImageFilter.cxx ) set(GEOMGCP "pleiades/pleiades-1" #LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2} "wv2/wv2-1" #LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} "spot6/spot6-1" #LARGEINPUT{SPOT6/600143101-Primary-Bundle-JP2-LOSSLESS/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201212071020271_SEN_600143101_R1C1.JP2} "QB/qb-1" #LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} "ikonos/ikonos-1" #LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_nir_0000000.tif} "rapideye/rapideye-1" #LARGEINPUT{RAPIDEYE/level1B/2008-12-25T005918_RE3_1B-NAC_397971_12345_band3.ntf} "sentinel1/sentinel1-1" #LARGEINPUT{SENTINEL1/S1A_S6_SLC__1SSV_20150619T195043/measurement/s1a-s6-slc-vv-20150619t195043-20150619t195101-006447-00887d-001.tiff} ) set(NEEDEDKW "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff" #Pleiades "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff" #World view 2 "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff" #Spot 6 "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff" #QB "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff" #Ikonos "line_den_coeff line_num_coeff samp_den_coeff samp_num_coeff" #Rapideye "number_lines number_samples orbitList support_data.geom.bursts support_data.geom.gcp support_data.pulse_repetition_frequency support_data.radar_frequency support_data.range_sampling_rate support_data.slant_range_to_first_pixel" # Sentinel1 ) set(GEOTOL 1 # Pleiades 1 # Worldview2 1 # Spot 6 1 # QB 1 # Ikonos 1 # Rapideye 5 # Sentinel1 ) set( GEOM_TESTNB 0) foreach( file ${GEOMGCP} ) list(GET GEOMGCP ${GEOM_TESTNB} current_geomgcp ) list(GET NEEDEDKW ${GEOM_TESTNB} current_neededkw ) list(GET GEOTOL ${GEOM_TESTNB} current_geotol ) math(EXPR GEOM_TESTNB "${GEOM_TESTNB} + 1") string(FIND ${current_geomgcp} "/" POS) math(EXPR POS "${POS} + 1") string(LENGTH ${current_geomgcp} LENGTH) math(EXPR SIZE "${LENGTH} - ${POS}") string(SUBSTRING ${current_geomgcp} ${POS} ${SIZE} TESTNAME) otb_add_test(NAME prTvSensorModel_${TESTNAME} COMMAND otbProjectionTestDriver otbSensorModel ${INPUTDATA}/${current_geomgcp}.geom ${INPUTDATA}/${current_geomgcp}.gcp ${TEMP}/${TESTNAME}.gcp # baseline (produced only if argv[7] == 1) ${current_neededkw} 1 # imgTol ${current_geotol} # geoTol 0 # create baseline (argv[7]) 1 # mode verbose 1 # 0 : no keyword check 1 : check needed keywords ) endforeach() #Faulty sensors #set(GEOMGCP #"radarsat2/gd-radarsat2-1" #LARGEINPUT{RADARSAT2/ALTONA/Fine_Quad-Pol_Dataset/PK6621_DK406_FQ9_20080405_124900_HH_VV_HV_VH_SLC_Altona/imagery_HH.tif} #"terrasarx/gd-terrasarx-1" #LARGEINPUT{TERRASARX/TORONTO/TSX1_SAR__SSC/IMAGEDATA/IMAGE_HH_SRA_spot_074.cos} #"terrasarx/gd-terrasarx-1" #LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} #"palsar/gd-palsar-1" #LARGEINPUT{PALSAR/200801280007/l1data/IMG-HH-ALPSRP037120700-H1.1__A} Ne reconnaît pas l'image #"s1/gd-s1-A" #LARGEINPUT{SENTINEL1/S1A_S6_SLC__1SSV_20150619T195043/measurement/s1a-s6-slc-vv-20150619t195043-20150619t195101-006447-00887d-001.tiff} #) #Other sensor : no keyword check set(GEOMGCP "ers2/ers2-1" #LARGEINPUT{SAR_ERS2_SLCI_SCENE1/DAT_01.001} "spot5/spot5-1" #LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} "geoeye1/geoeye1-1" #LARGEINPUT{GEOEYE/MARCILLOLES/po_350134_bgrn_0000001.tif} ) set( GEOM_TESTNB 0) foreach( file ${GEOMGCP} ) list(GET GEOMGCP ${GEOM_TESTNB} current_geomgcp ) math(EXPR GEOM_TESTNB "${GEOM_TESTNB} + 1") string(FIND ${current_geomgcp} "/" POS) math(EXPR POS "${POS} + 1") string(LENGTH ${current_geomgcp} LENGTH) math(EXPR SIZE "${LENGTH} - ${POS}") string(SUBSTRING ${current_geomgcp} ${POS} ${SIZE} TESTNAME) otb_add_test(NAME prTvSensorModel_${TESTNAME} COMMAND otbProjectionTestDriver #BASELINE_FILES otbSensorModel ${INPUTDATA}/${current_geomgcp}.geom ${INPUTDATA}/${current_geomgcp}.gcp ${TEMP}/${TESTNAME}.gcp # baseline (produced only if argv[7] == 1) "Foo" 1 # imgTol 1 # geoTol 0 # create baseline (argv[7]) 1 # mode verbose 0 # 0 : no keyword check 1 : check needed keywords ) endforeach() add_executable(otbProjectionTestDriver ${OTBProjectionTests}) target_link_libraries(otbProjectionTestDriver ${OTBProjection-Test_LIBRARIES}) otb_module_target_label(otbProjectionTestDriver) # Tests Declaration otb_add_test(NAME prTuVectorDataProjectionFilterFromGeoToMap COMMAND otbProjectionTestDriver otbVectorDataProjectionFilterFromGeoToMap ${INPUTDATA}/ToulousePointsWGS.sqlite ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/prTvVectorDataProjectionFilterFromGeoToMap.shp ) #------------------------------------------------------------------------ #-------------------- OrthoRectification tests -------------------------- #------------------------------------------------------------------------ set(IMG_TEST_ORTHO PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2 WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF SPOT6/600143101-Primary-Bundle-JP2-LOSSLESS/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201212071020271_SEN_600143101_R1C1.JP2 QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF IKONOS/BLOSSEVILLE/po_2619900_nir_0000000.tif RAPIDEYE/level1B/2008-12-25T005918_RE3_1B-NAC_397971_12345_band3.ntf SENTINEL1/S1A_S6_SLC__1SSV_20150619T195043/measurement/s1a-s6-slc-vv-20150619t195043-20150619t195101-006447-00887d-001.tiff ) set(IMG_TYPE "pleiades-1" "wv2-1" "spot6-1" "qb-1" "ikonos-1" "rapideye-1" "sentinel1" ) set(GEOMGCP "pleiades/pleiades-1" #LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2} "wv2/wv2-1" #LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} "spot6/spot6-1" #LARGEINPUT{SPOT6/600143101-Primary-Bundle-JP2-LOSSLESS/PROD_SPOT6_001/VOL_SPOT6_001_A/IMG_SPOT6_MS_001_A/IMG_SPOT6_MS_201212071020271_SEN_600143101_R1C1.JP2} "QB/qb-1" #LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} "ikonos/ikonos-1" #LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_nir_0000000.tif} "rapideye/rapideye-1" #LARGEINPUT{RAPIDEYE/level1B/2008-12-25T005918_RE3_1B-NAC_397971_12345_band3.ntf} "sentinel1/sentinel1-1" #LARGEINPUT{SENTINEL1/S1A_S6_SLC__1SSV_20150619T195043/measurement/s1a-s6-slc-vv-20150619t195043-20150619t195101-006447-00887d-001.tiff} ) set(ORIGINSX 370000 291835 425000 375000 340000 430000 787422 ) set(ORIGINSY 4830000 4640740 4580000 4823000 5524000 6190000 1664034 ) set(UTMZONES 31 33 31 31 31 55 26 ) set(HEMIS N N N N N S N ) set(RESOL 0.5 0.5 0.5 0.5 0.5 0.5 4 ) set(GRIDSPACING 4 4 4 4 4 4 4 32 ) set(ISCOMPLEX 0 0 0 0 0 0 1 ) set(MODE "noDEM" "DEMSRTM" "DEMGTIFF" ) set(DEMDIR "noDEM" "${INPUTDATA}/DEM/srtm_directory" "${INPUTDATA}/DEM/tif_directory" ) set( IMGNB 0) foreach(current_img ${IMG_TEST_ORTHO}) list(GET IMG_TYPE ${IMGNB} current_imgtype ) list(GET GEOMGCP ${IMGNB} current_geomgcp ) list(GET ORIGINSX ${IMGNB} current_originx ) list(GET ORIGINSY ${IMGNB} current_originy ) list(GET UTMZONES ${IMGNB} current_zone ) list(GET HEMIS ${IMGNB} current_hemis ) list(GET RESOL ${IMGNB} current_resol ) list(GET GRIDSPACING ${IMGNB} current_grid_spacing) list(GET ISCOMPLEX ${IMGNB} current_is_compex) math(EXPR IMGNB "${IMGNB} + 1") set( MODENB 0) foreach( current_mode ${MODE} ) list(GET DEMDIR ${MODENB} current_demdir ) math(EXPR MODENB "${MODENB} + 1") otb_add_test(NAME prTvOrthoRectification_${current_imgtype}_${current_mode} COMMAND otbProjectionTestDriver --compare-image ${EPSILON_4} ${BASELINE}/prTvOrthoRectification_${current_imgtype}_${current_mode}.tif ${TEMP}/prTvOrthoRectification_${current_imgtype}_${current_mode}.tif otbOrthoRectificationFilter LARGEINPUT{${current_img}?&geom=${INPUTDATA}/${current_geomgcp}.geom} ${TEMP}/prTvOrthoRectification_${current_imgtype}_${current_mode}.tif ${current_originx} ${current_originy} 500 500 ${current_resol} -${current_resol} ${current_zone} ${current_hemis} ${current_grid_spacing} # Spacing of the displacement field ${MODENB} ${current_demdir} ${current_is_compex} ) endforeach() endforeach() #------------------------------------------------------------------------ #----------------- OrthoRectification tests (end) ----------------------- #------------------------------------------------------------------------ otb_add_test(NAME prTuGCPsToRPCSensorModelImageFilterNew COMMAND otbProjectionTestDriver otbGCPsToRPCSensorModelImageFilterNew) otb_add_test(NAME prTvMapProjection COMMAND otbProjectionTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvMapProjection.txt ${TEMP}/prTvMapProjection.txt otbMapProjection ${TEMP}/prTvMapProjection.txt ) otb_add_test(NAME prTuotbGenericRSResampleImageFilterNew COMMAND otbProjectionTestDriver otbGenericRSResampleImageFilterNew ) otb_add_test(NAME prTvotbGenericRSResampleImageFilter COMMAND otbProjectionTestDriver --compare-image ${EPSILON_4} ${BASELINE}/prTvotbGenericRSResampleImageFilterOutput.tif ${TEMP}/prTvotbGenericRSResampleImageFilterOutput.tif otbGenericRSResampleImageFilter LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} 1000 15 0 1 ${TEMP}/prTvotbGenericRSResampleImageFilterOutput.tif ) otb_add_test(NAME prTvGeometriesProjectionFilterLines COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterLines.shp ${TEMP}/prTvGeometriesProjectionFilterLines.shp otbGeometriesProjectionFilter ${INPUTDATA}/ToulouseRoad-examples.shp ${TEMP}/prTvGeometriesProjectionFilterLines.shp ) otb_add_test(NAME prTvGeometriesProjectionFilterPoints COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterPoints.shp ${TEMP}/prTvGeometriesProjectionFilterPoints.shp otbGeometriesProjectionFilter ${INPUTDATA}/ToulousePoints-examples.shp ${TEMP}/prTvGeometriesProjectionFilterPoints.shp ) otb_add_test(NAME prTvGeometriesProjectionFilterPolygons COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterPolygons.shp ${TEMP}/prTvGeometriesProjectionFilterPolygons.shp otbGeometriesProjectionFilter ${INPUTDATA}/Capitole-Shadows.shp ${TEMP}/prTvGeometriesProjectionFilterPolygons.shp ) otb_add_test(NAME prTvGenericRSTransformGenericTestEPSG4326toEPSG32631 COMMAND otbProjectionTestDriver otbGenericRSTransformGenericTest 1.3561728980 43.4876035537 367077.72312001337 4816277.086791252 EPSG 4326 EPSG 32631 GEO 1e-3 PHYSICAL 1e-3 NOELEV) otb_add_test(NAME prTvGenericRSTransformGenericTestWGS84toEPSG3857 COMMAND otbProjectionTestDriver otbGenericRSTransformGenericTest 1.48353 43.55968 165145.804154 5397552.58726 EPSG 4326 EPSG 3857 GEO 1e-3 PHYSICAL 1e-3 NOELEV) otb_add_test(NAME prTvGenericRSTransformGenericTestEPSG4326toEPSG4326 COMMAND otbProjectionTestDriver otbGenericRSTransformGenericTest 1.35617289802566 43.4876035537 1.35617289802566 43.4876035537 EPSG 4326 EPSG 4326 GEO 1e-6 GEO 1e-6 NOELEV) otb_add_test(NAME prTuLeastSquareAffineTransformEstimatorNew COMMAND otbProjectionTestDriver otbLeastSquareAffineTransformEstimatorNew) otb_add_test(NAME prTuVectorDataTransformFilterNew COMMAND otbProjectionTestDriver otbVectorDataTransformFilterNew) otb_add_test(NAME prTvVectorDataTransformFilter COMMAND otbProjectionTestDriver --compare-ogr ${EPSILON_4} ${BASELINE_FILES}/prTvVectorDataTransformFilter_Translation.shp ${TEMP}/prTvVectorDataTransformFilter_Translation.shp otbVectorDataTransformFilter LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${INPUTDATA}/ToulouseRoad-examples.shp ${TEMP}/prTvVectorDataTransformFilter_Translation.shp ) otb_add_test(NAME prTvRationalTransformToDisplacementFieldSourceTest COMMAND otbProjectionTestDriver --compare-image ${EPSILON_9} ${BASELINE}/prTvRationalTransformToDisplacementFieldSourceTest.hdr ${TEMP}/prTvRationalTransformToDisplacementFieldSourceTest.hdr otbRationalTransformToDisplacementFieldSourceTest ${TEMP}/prTvRationalTransformToDisplacementFieldSourceTest.hdr ) otb_add_test(NAME bfTuImportGeoInformationImageFilterNew COMMAND otbProjectionTestDriver otbImportGeoInformationImageFilterNew) otb_add_test(NAME prTvVectorDataProjectionFilterFromMapToSensor COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToSensor.shp ${TEMP}/prTvVectorDataProjectionFilterFromMapToSensor.shp otbVectorDataProjectionFilterFromMapToSensor ${INPUTDATA}/ToulousePoints-examples.shp LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/prTvVectorDataProjectionFilterFromMapToSensor.shp ) otb_add_test(NAME prTuCompositeTransformNew COMMAND otbProjectionTestDriver otbCompositeTransformNew ) otb_add_test(NAME prTvRationalTransform COMMAND otbProjectionTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/otbRationalTransformOutput.txt ${TEMP}/otbRationalTransformOutput.txt otbRationalTransform ${TEMP}/otbRationalTransformOutput.txt 0 0 1 1 10 10 -10 -10 ) otb_add_test(NAME prTuRationalTransformNew COMMAND otbProjectionTestDriver otbRationalTransformNew) otb_add_test(NAME prTvGeometriesProjectionFilterFromMapToSensor COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToSensor.shp ${TEMP}/prTvGeometriesProjectionFilterFromMapToSensor.shp otbGeometriesProjectionFilterFromMapToSensor ${INPUTDATA}/ToulousePoints-examples.shp LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/prTvGeometriesProjectionFilterFromMapToSensor.shp ) otb_add_test(NAME prTvImageToEnvelopeVectorDataFilter COMMAND otbProjectionTestDriver --compare-ogr ${EPSILON_6} ${BASELINE_FILES}/prTvImageToEnvelopeVectorDataFilterOutput.kml ${TEMP}/prTvImageToEnvelopeVectorDataFilterOutput.kml otbImageToEnvelopeVectorDataFilter LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/prTvImageToEnvelopeVectorDataFilterOutput.kml ) otb_add_test(NAME prTuImageToEnvelopeVectorDataFilterNew COMMAND otbProjectionTestDriver otbImageToEnvelopeVectorDataFilterNew) otb_add_test(NAME prTuMapProjectionsNew COMMAND otbProjectionTestDriver otbMapProjectionsNew ) otb_add_test(NAME prTvMapProjectionsTest COMMAND otbProjectionTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvMapProjectionsTest.txt ${TEMP}/prTvMapProjectionsTest.txt otbMapProjectionsTest ${TEMP}/prTvMapProjectionsTest.txt ) otb_add_test(NAME prTuOrthoRectificationFilterNew COMMAND otbProjectionTestDriver otbOrthoRectificationFilterNew ) otb_add_test(NAME prTvImageToGenericRSOutputParameters COMMAND otbProjectionTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/prTvImageToGenericRSOutputParametersOutput.txt ${TEMP}/prTvImageToGenericRSOutputParametersOutput.txt otbImageToGenericRSOutputParameters LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/prTvImageToGenericRSOutputParametersOutput.txt ) otb_add_test(NAME prTuImageToGenericRSOutputParametersNew COMMAND otbProjectionTestDriver otbImageToGenericRSOutputParametersNew) otb_add_test(NAME prTvGeometriesProjectionFilterFromMapToGeo COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToGeo.kml ${TEMP}/prTvGeometriesProjectionFilterFromMapToGeo.shp otbGeometriesProjectionFilterFromMapToGeo ${INPUTDATA}/ToulousePoints-examples.shp ${TEMP}/prTvGeometriesProjectionFilterFromMapToGeo.shp ) otb_add_test(NAME leTvROIdataConversion COMMAND otbProjectionTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvROIdataConversion.txt ${TEMP}/leTvROIdataConversion.txt otbROIdataConversion ${INPUTDATA}/ImageLineDir.bsq.hdr ${INPUTDATA}/ImageLine.bsq.hdr ${TEMP}/leTvROIdataConversion.txt ) otb_add_test(NAME prTuProjectionBaseNew COMMAND otbProjectionTestDriver otbProjectionBaseNew ) otb_add_test(NAME prTvVectorDataProjectionFilterFromMapToGeo COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToGeo.kml ${TEMP}/prTvVectorDataProjectionFilterFromMapToGeo.kml otbVectorDataProjectionFilterFromMapToGeo ${INPUTDATA}/ToulousePoints-examples.shp ${TEMP}/prTvVectorDataProjectionFilterFromMapToGeo.kml ) otb_add_test(NAME prTvPhysicalToRPCSensorModelImageFilter COMMAND otbProjectionTestDriver otbPhysicalToRPCSensorModelImageFilter ${INPUTDATA}/ToulouseExtract_WithGeom.tif 15 ${TEMP}/prTvotbPhysicalToRPCSensorModelImageFilter.tif ) otb_add_test(NAME prTuPhysicalToRPCSensorModelImageFilterNew COMMAND otbProjectionTestDriver otbPhysicalToRPCSensorModelImageFilter ) otb_add_test(NAME prTuGeometriesProjectionFilterFromGeoToMap COMMAND otbProjectionTestDriver otbGeometriesProjectionFilterFromGeoToMap ${INPUTDATA}/ToulousePointsWGS.sqlite ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/prTvGeometriesProjectionFilterFromGeoToMap.shp ) otb_add_test(NAME prTvVectorDataProjectionFilterFromMapToImage COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToImage.shp ${TEMP}/prTvVectorDataProjectionFilterFromMapToImage.shp otbVectorDataProjectionFilterFromMapToImage ${INPUTDATA}/ToulousePoints-examples.shp ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/prTvVectorDataProjectionFilterFromMapToImage.shp ) otb_add_test(NAME prTvGenericRSTransformPleiadesToulouseGeodesicPointChecking COMMAND otbProjectionTestDriver otbGenericRSTransformImageAndMNTToWGS84ConversionChecking LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R2C1.JP2} ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 20000 28010 # IGN reference point based inside CNES (site 31555A point c) 1.48353 43.55968 # IGN reference point lon/lat 192.205 # IGN reference point elevation (prec < 10 cm) 37 # Tolerance in pixels (performances in february 2012) 20 # Tolerance in meters (performances in february 2012) ) otb_add_test(NAME prTvGenericRSTransformPleiadesToulouseGeodesicPointChecking_PRE COMMAND otbProjectionTestDriver otbGenericRSTransformImageAndMNTToWGS84ConversionChecking LARGEINPUT{PLEIADES-PRE/TLSE_TIFF_PRIMARY_DIMAPv2_MS_lossly_12bits/IMG_PHR1A_MS_002/IMG_PHR1A_MS_201006181052297_SEN_IPU_20111025_3077-004_R1C1.TIF} ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 6933 6472 # IGN reference point based inside CNES (site 31555A point c) 1.48353 43.55968 # IGN reference point lon/lat 192.205 # IGN reference point elevation (prec < 10 cm) 35 # Tolerance in pixels (performances in february 2012) 20 # Tolerance in meters (performances in february 2012) ) otb_add_test(NAME prTvGenericRSTransformFromImage COMMAND otbProjectionTestDriver otbGenericRSTransformFromImage ${INPUTDATA}/WithoutProjRefWithKeywordlist.tif) otb_add_test(NAME prTvGenericRSTransformQuickbirdToulouseGeodesicPointChecking COMMAND otbProjectionTestDriver otbGenericRSTransformImageAndMNTToWGS84ConversionChecking LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${INPUTDATA}/DEM/srtm_directory/ ${INPUTDATA}/DEM/egm96.grd 16271 15647 # IGN reference point based inside CNES (site 31555A point c) 1.48353 43.55968 # IGN reference point lon/lat 192.205 # IGN reference point elevation (prec < 10 cm) 24 # Tolerance in pixels according to DigitalGlobe specification 23 # Tolerance in meters according to DigitalGlobe specification ) otb_add_test(NAME prTvCompositeTransform COMMAND otbProjectionTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvCompositeTransform.txt ${TEMP}/prTvCompositeTransform.txt otbCompositeTransform LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/prTvCompositeTransform.txt ) otb_add_test(NAME prTvLeastSquareAffineTransformEstimator COMMAND otbProjectionTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/otbLeastSquareAffineTransformEstimatorOutput.txt ${TEMP}/otbLeastSquareAffineTransformEstimatorOutput.txt otbLeastSquareAffineTransformEstimator ${TEMP}/otbLeastSquareAffineTransformEstimatorOutput.txt 840 394 783 7907 9925 11943 798 911 197 5831 7738 9645 335 768 277 5356 6737 8118 553 477 628 6867 8526 10185 364 513 952 9090 10920 12750 916 635 717 8485 10754 13023 141 606 16 2687 3451 4215 242 137 804 6428 7612 8796 156 400 129 2669 3355 4041 108 998 218 5636 6961 8286 512 839 612 8162 10126 12090 296 637 524 6522 7980 9438 493 972 292 6435 8193 9951 771 526 769 8268 10335 12402 400 891 283 5955 7530 9105 352 807 919 10023 12102 14181 ) otb_add_test(NAME bfTvSpectralAngleDataNodeFeatureFunction_Polygon COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvSpectralAngleDataNodeFeatureFunctionOutput_Polygon.shp ${TEMP}/bfTvSpectralAngleDataNodeFeatureFunctionOutput_Polygon.shp otbSpectralAngleDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_BUILDINGS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvSpectralAngleDataNodeFeatureFunctionOutput_Polygon.shp 0 ) otb_add_test(NAME bfTuSpectralAngleDataNodeFeatureFunctionNew COMMAND otbProjectionTestDriver otbSpectralAngleDataNodeFeatureFunctionNew ) otb_add_test(NAME bfTvSpectralAngleDataNodeFeatureFunction_Line COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvSpectralAngleDataNodeFeatureFunctionOutput_Line.shp ${TEMP}/bfTvSpectralAngleDataNodeFeatureFunctionOutput_Line.shp otbSpectralAngleDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_ROADS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvSpectralAngleDataNodeFeatureFunctionOutput_Line.shp 0 ) otb_add_test(NAME leTuROIdataConversionNew COMMAND otbProjectionTestDriver otbROIdataConversionNew) otb_add_test(NAME prTvGCPsToRPCSensorModelImageCheckInputGcpPointsProjection_WithDEM COMMAND otbProjectionTestDriver otbGCPsToRPCSensorModelImageFilterCheckRpcModel -in ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -dem ${INPUTDATA}/DEM/srtm_directory -gcp 2000 2000 1.4181 43.6147 135.084 2000 2050 1.41811 43.6135 134.185 2000 2100 1.41812 43.6123 135.728 2000 2150 1.41812 43.6111 140.437 2000 2200 1.41813 43.6099 141.985 2000 2250 1.41813 43.6087 138.257 2000 2300 1.41814 43.6075 136.908 2000 2350 1.41815 43.6062 129.787 2000 2400 1.41815 43.605 126.295 2000 2450 1.41816 43.6038 136.66 2050 2000 1.41968 43.6147 135.682 2050 2050 1.41969 43.6135 135 2050 2100 1.4197 43.6123 134.7 2050 2150 1.4197 43.6111 140.348 2050 2200 1.41971 43.6099 143.342 2050 2250 1.41972 43.6087 138.644 2050 2300 1.41972 43.6075 137.985 2050 2350 1.41973 43.6062 137.348 2050 2400 1.41973 43.605 125.707 2050 2450 1.41974 43.6038 130.963 2100 2000 1.42127 43.6147 135.329 2100 2050 1.42127 43.6135 137.984 2100 2100 1.42128 43.6123 137.291 2100 2150 1.42129 43.6111 138.949 2100 2200 1.42129 43.6099 140.584 2100 2250 1.4213 43.6087 142.13 2100 2300 1.4213 43.6075 138.452 2100 2350 1.42131 43.6063 137.792 2100 2400 1.42132 43.605 136.434 2100 2450 1.42132 43.6038 130.481 2150 2000 1.42285 43.6147 135.332 2150 2050 1.42286 43.6135 136.651 2150 2100 1.42286 43.6123 136.629 2150 2150 1.42287 43.6111 139.551 2150 2200 1.42287 43.6099 138.204 2150 2250 1.42288 43.6087 145.283 2150 2300 1.42289 43.6075 137.505 2150 2350 1.42289 43.6063 137.57 2150 2400 1.4229 43.605 134.733 2150 2450 1.4229 43.6038 131.314 2200 2000 1.42443 43.6148 138.407 2200 2050 1.42444 43.6135 139.594 2200 2100 1.42444 43.6123 139.942 2200 2150 1.42445 43.6111 140.982 2200 2200 1.42446 43.6099 138.061 2200 2250 1.42446 43.6087 143.539 2200 2300 1.42447 43.6075 140.254 2200 2350 1.42447 43.6063 136.862 2200 2400 1.42448 43.605 139.257 2200 2450 1.42449 43.6038 133.532 2250 2000 1.42601 43.6148 140.76 2250 2050 1.42602 43.6135 139.717 2250 2100 1.42603 43.6123 139.331 2250 2150 1.42603 43.6111 137.95 2250 2200 1.42604 43.6099 136.37 2250 2250 1.42604 43.6087 139.675 2250 2300 1.42605 43.6075 142.744 2250 2350 1.42606 43.6063 138.594 2250 2400 1.42606 43.6051 142.685 2250 2450 1.42607 43.6038 136.393 2300 2000 1.4276 43.6148 141.979 2300 2050 1.4276 43.6135 140.486 2300 2100 1.42761 43.6123 142.465 2300 2150 1.42761 43.6111 143.805 2300 2200 1.42762 43.6099 140.161 2300 2250 1.42762 43.6087 140.587 2300 2300 1.42763 43.6075 142.85 2300 2350 1.42764 43.6063 143.652 2300 2400 1.42764 43.6051 144.587 2300 2450 1.42765 43.6038 135.548 2350 2000 1.42918 43.6148 139.286 2350 2050 1.42918 43.6136 142.901 2350 2100 1.42919 43.6123 143.92 2350 2150 1.4292 43.6111 145.468 2350 2200 1.4292 43.6099 142.063 2350 2250 1.42921 43.6087 141.327 2350 2300 1.42921 43.6075 140.21 2350 2350 1.42922 43.6063 144.686 2350 2400 1.42922 43.6051 142.948 2350 2450 1.42923 43.6038 136.852 2400 2000 1.43076 43.6148 142.428 2400 2050 1.43077 43.6136 142.015 2400 2100 1.43077 43.6123 141.832 2400 2150 1.43078 43.6111 142.742 2400 2200 1.43078 43.6099 142.89 2400 2250 1.43079 43.6087 141.337 2400 2300 1.43079 43.6075 140.138 2400 2350 1.4308 43.6063 144.412 2400 2400 1.43081 43.6051 143.224 2400 2450 1.43081 43.6038 133.995 2450 2000 1.43234 43.6148 142.162 2450 2050 1.43235 43.6136 139.831 2450 2100 1.43235 43.6123 140.736 2450 2150 1.43236 43.6111 140.871 2450 2200 1.43236 43.6099 142.21 2450 2250 1.43237 43.6087 141.501 2450 2300 1.43238 43.6075 138.911 2450 2350 1.43238 43.6063 144.66 2450 2400 1.43239 43.6051 144.932 2450 2450 1.43239 43.6038 136.794 -err 10 # Tolerance in meters, the first goal of this test ) otb_add_test(NAME prTvGCPsToRPCSensorModelImageCheckInputGcpPointsProjection_WithoutDEM COMMAND otbProjectionTestDriver otbGCPsToRPCSensorModelImageFilterCheckRpcModel -in ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif -gcp 2000 2000 1.41809 43.6143 0 2000 2050 1.4181 43.6131 0 2000 2100 1.4181 43.6119 0 2000 2150 1.41811 43.6107 0 2000 2200 1.41812 43.6095 0 2000 2250 1.41812 43.6083 0 2000 2300 1.41813 43.6071 0 2000 2350 1.41814 43.6058 0 2000 2400 1.41814 43.6046 0 2000 2450 1.41815 43.6034 0 2050 2000 1.41967 43.6143 0 2050 2050 1.41968 43.6131 0 2050 2100 1.41969 43.6119 0 2050 2150 1.41969 43.6107 0 2050 2200 1.4197 43.6095 0 2050 2250 1.41971 43.6083 0 2050 2300 1.41971 43.6071 0 2050 2350 1.41972 43.6059 0 2050 2400 1.41973 43.6046 0 2050 2450 1.41973 43.6034 0 2100 2000 1.42126 43.6143 0 2100 2050 1.42126 43.6131 0 2100 2100 1.42127 43.6119 0 2100 2150 1.42128 43.6107 0 2100 2200 1.42128 43.6095 0 2100 2250 1.42129 43.6083 0 2100 2300 1.4213 43.6071 0 2100 2350 1.4213 43.6059 0 2100 2400 1.42131 43.6046 0 2100 2450 1.42132 43.6034 0 2150 2000 1.42284 43.6143 0 2150 2050 1.42285 43.6131 0 2150 2100 1.42285 43.6119 0 2150 2150 1.42286 43.6107 0 2150 2200 1.42286 43.6095 0 2150 2250 1.42287 43.6083 0 2150 2300 1.42288 43.6071 0 2150 2350 1.42288 43.6059 0 2150 2400 1.42289 43.6046 0 2150 2450 1.4229 43.6034 0 2200 2000 1.42442 43.6144 0 2200 2050 1.42443 43.6131 0 2200 2100 1.42443 43.6119 0 2200 2150 1.42444 43.6107 0 2200 2200 1.42445 43.6095 0 2200 2250 1.42445 43.6083 0 2200 2300 1.42446 43.6071 0 2200 2350 1.42447 43.6059 0 2200 2400 1.42447 43.6046 0 2200 2450 1.42448 43.6034 0 2250 2000 1.42601 43.6144 0 2250 2050 1.42601 43.6131 0 2250 2100 1.42602 43.6119 0 2250 2150 1.42602 43.6107 0 2250 2200 1.42603 43.6095 0 2250 2250 1.42604 43.6083 0 2250 2300 1.42604 43.6071 0 2250 2350 1.42605 43.6059 0 2250 2400 1.42605 43.6047 0 2250 2450 1.42606 43.6034 0 2300 2000 1.42759 43.6144 0 2300 2050 1.42759 43.6131 0 2300 2100 1.4276 43.6119 0 2300 2150 1.42761 43.6107 0 2300 2200 1.42761 43.6095 0 2300 2250 1.42762 43.6083 0 2300 2300 1.42762 43.6071 0 2300 2350 1.42763 43.6059 0 2300 2400 1.42764 43.6047 0 2300 2450 1.42764 43.6034 0 2350 2000 1.42917 43.6144 0 2350 2050 1.42918 43.6131 0 2350 2100 1.42918 43.6119 0 2350 2150 1.42919 43.6107 0 2350 2200 1.42919 43.6095 0 2350 2250 1.4292 43.6083 0 2350 2300 1.42921 43.6071 0 2350 2350 1.42921 43.6059 0 2350 2400 1.42922 43.6047 0 2350 2450 1.42922 43.6034 0 2400 2000 1.43075 43.6144 0 2400 2050 1.43076 43.6131 0 2400 2100 1.43076 43.6119 0 2400 2150 1.43077 43.6107 0 2400 2200 1.43078 43.6095 0 2400 2250 1.43078 43.6083 0 2400 2300 1.43079 43.6071 0 2400 2350 1.43079 43.6059 0 2400 2400 1.4308 43.6047 0 2400 2450 1.43081 43.6034 0 2450 2000 1.43234 43.6144 0 2450 2050 1.43234 43.6132 0 2450 2100 1.43235 43.6119 0 2450 2150 1.43235 43.6107 0 2450 2200 1.43236 43.6095 0 2450 2250 1.43236 43.6083 0 2450 2300 1.43237 43.6071 0 2450 2350 1.43238 43.6059 0 2450 2400 1.43238 43.6047 0 2450 2450 1.43239 43.6034 0 -err 10 # Tolerance in meters, the first goal of this test ) otb_add_test(NAME prTuGeographicalDistanceNew COMMAND otbProjectionTestDriver otbGeographicalDistanceNew) otb_add_test(NAME prTvGeographicalDistance COMMAND otbProjectionTestDriver otbGeographicalDistance -1.84944 53.14722 0.14056 52.20444 170254.85084 ${EPSILON_4} ) otb_add_test(NAME prTvTileImageFilterGenericRSTransformTest_TLSE_DIMAPv2 COMMAND otbProjectionTestDriver otbTileImageFilterRSTransformTest 1 3 LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2} LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R2C1.JP2} LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R3C1.JP2} ) otb_add_test(NAME prTvTileImageFilterGenericRSTransformTest_LASVEGAS_DIMAPv1 COMMAND otbProjectionTestDriver otbTileImageFilterRSTransformTest 1 3 LARGEINPUT{PLEIADES/LASVEGAS_JP2_DIMAPv1_PRIMARY_PMS_lossless_12bits/IMGPHR_PHR1A_SENSOR_20120217_IPU_20120217_5374-001_V1/IMG_R1C1.JP2} LARGEINPUT{PLEIADES/LASVEGAS_JP2_DIMAPv1_PRIMARY_PMS_lossless_12bits/IMGPHR_PHR1A_SENSOR_20120217_IPU_20120217_5374-001_V1/IMG_R2C1.JP2} LARGEINPUT{PLEIADES/LASVEGAS_JP2_DIMAPv1_PRIMARY_PMS_lossless_12bits/IMGPHR_PHR1A_SENSOR_20120217_IPU_20120217_5374-001_V1/IMG_R3C1.JP2} ) otb_add_test(NAME prTvGCPsToRPCSensorModelImageFilterAndOrtho COMMAND otbProjectionTestDriver --compare-image ${EPSILON_4} ${BASELINE}/otbGCPsToRPCSensorModelImageFilterAndOrthoOutput.tif ${TEMP}/otbGCPsToRPCSensorModelImageFilterAndOrthoOutput.tif otbGCPsToRPCSensorModelImageFilterAndOrtho ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif ${TEMP}/otbGCPsToRPCSensorModelImageFilterAndOrthoOutput.tif 372332.21875 4830255.50000 507 534 2.5 -2.5 31 N 2000 2000 1.41809 43.6143 0 2000 2050 1.4181 43.6131 0 2000 2100 1.4181 43.6119 0 2000 2150 1.41811 43.6107 0 2000 2200 1.41812 43.6095 0 2000 2250 1.41812 43.6083 0 2000 2300 1.41813 43.6071 0 2000 2350 1.41814 43.6058 0 2000 2400 1.41814 43.6046 0 2000 2450 1.41815 43.6034 0 2050 2000 1.41967 43.6143 0 2050 2050 1.41968 43.6131 0 2050 2100 1.41969 43.6119 0 2050 2150 1.41969 43.6107 0 2050 2200 1.4197 43.6095 0 2050 2250 1.41971 43.6083 0 2050 2300 1.41971 43.6071 0 2050 2350 1.41972 43.6059 0 2050 2400 1.41973 43.6046 0 2050 2450 1.41973 43.6034 0 2100 2000 1.42126 43.6143 0 2100 2050 1.42126 43.6131 0 2100 2100 1.42127 43.6119 0 2100 2150 1.42128 43.6107 0 2100 2200 1.42128 43.6095 0 2100 2250 1.42129 43.6083 0 2100 2300 1.4213 43.6071 0 2100 2350 1.4213 43.6059 0 2100 2400 1.42131 43.6046 0 2100 2450 1.42132 43.6034 0 2150 2000 1.42284 43.6143 0 2150 2050 1.42285 43.6131 0 2150 2100 1.42285 43.6119 0 2150 2150 1.42286 43.6107 0 2150 2200 1.42286 43.6095 0 2150 2250 1.42287 43.6083 0 2150 2300 1.42288 43.6071 0 2150 2350 1.42288 43.6059 0 2150 2400 1.42289 43.6046 0 2150 2450 1.4229 43.6034 0 2200 2000 1.42442 43.6144 0 2200 2050 1.42443 43.6131 0 2200 2100 1.42443 43.6119 0 2200 2150 1.42444 43.6107 0 2200 2200 1.42445 43.6095 0 2200 2250 1.42445 43.6083 0 2200 2300 1.42446 43.6071 0 2200 2350 1.42447 43.6059 0 2200 2400 1.42447 43.6046 0 2200 2450 1.42448 43.6034 0 2250 2000 1.42601 43.6144 0 2250 2050 1.42601 43.6131 0 2250 2100 1.42602 43.6119 0 2250 2150 1.42602 43.6107 0 2250 2200 1.42603 43.6095 0 2250 2250 1.42604 43.6083 0 2250 2300 1.42604 43.6071 0 2250 2350 1.42605 43.6059 0 2250 2400 1.42605 43.6047 0 2250 2450 1.42606 43.6034 0 2300 2000 1.42759 43.6144 0 2300 2050 1.42759 43.6131 0 2300 2100 1.4276 43.6119 0 2300 2150 1.42761 43.6107 0 2300 2200 1.42761 43.6095 0 2300 2250 1.42762 43.6083 0 2300 2300 1.42762 43.6071 0 2300 2350 1.42763 43.6059 0 2300 2400 1.42764 43.6047 0 2300 2450 1.42764 43.6034 0 2350 2000 1.42917 43.6144 0 2350 2050 1.42918 43.6131 0 2350 2100 1.42918 43.6119 0 2350 2150 1.42919 43.6107 0 2350 2200 1.42919 43.6095 0 2350 2250 1.4292 43.6083 0 2350 2300 1.42921 43.6071 0 2350 2350 1.42921 43.6059 0 2350 2400 1.42922 43.6047 0 2350 2450 1.42922 43.6034 0 2400 2000 1.43075 43.6144 0 2400 2050 1.43076 43.6131 0 2400 2100 1.43076 43.6119 0 2400 2150 1.43077 43.6107 0 2400 2200 1.43078 43.6095 0 2400 2250 1.43078 43.6083 0 2400 2300 1.43079 43.6071 0 2400 2350 1.43079 43.6059 0 2400 2400 1.4308 43.6047 0 2400 2450 1.43081 43.6034 0 2450 2000 1.43234 43.6144 0 2450 2050 1.43234 43.6132 0 2450 2100 1.43235 43.6119 0 2450 2150 1.43235 43.6107 0 2450 2200 1.43236 43.6095 0 2450 2250 1.43236 43.6083 0 2450 2300 1.43237 43.6071 0 2450 2350 1.43238 43.6059 0 2450 2400 1.43238 43.6047 0 2450 2450 1.43239 43.6034 0 ) #otb_add_test(NAME prTvVectorDataExtractROIandProjection COMMAND otbProjectionTestDriver #otbVectorDataExtractROIandProjection #LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} #) otb_add_test(NAME prTvGCPsToRPCSensorModelImageFilterWithoutDEM COMMAND otbProjectionTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/otbGCPsToRPCSensorModelImageFilterWithoutDEMOutput.txt ${TEMP}/otbGCPsToRPCSensorModelImageFilterWithoutDEMOutput.txt otbGCPsToRPCSensorModelImageFilterWithoutDEM ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif ${TEMP}/otbGCPsToRPCSensorModelImageFilterWithoutDEMOutput.txt 2000 2000 1.41809 43.6143 0 2000 2050 1.4181 43.6131 0 2000 2100 1.4181 43.6119 0 2000 2150 1.41811 43.6107 0 2000 2200 1.41812 43.6095 0 2000 2250 1.41812 43.6083 0 2000 2300 1.41813 43.6071 0 2000 2350 1.41814 43.6058 0 2000 2400 1.41814 43.6046 0 2000 2450 1.41815 43.6034 0 2050 2000 1.41967 43.6143 0 2050 2050 1.41968 43.6131 0 2050 2100 1.41969 43.6119 0 2050 2150 1.41969 43.6107 0 2050 2200 1.4197 43.6095 0 2050 2250 1.41971 43.6083 0 2050 2300 1.41971 43.6071 0 2050 2350 1.41972 43.6059 0 2050 2400 1.41973 43.6046 0 2050 2450 1.41973 43.6034 0 2100 2000 1.42126 43.6143 0 2100 2050 1.42126 43.6131 0 2100 2100 1.42127 43.6119 0 2100 2150 1.42128 43.6107 0 2100 2200 1.42128 43.6095 0 2100 2250 1.42129 43.6083 0 2100 2300 1.4213 43.6071 0 2100 2350 1.4213 43.6059 0 2100 2400 1.42131 43.6046 0 2100 2450 1.42132 43.6034 0 2150 2000 1.42284 43.6143 0 2150 2050 1.42285 43.6131 0 2150 2100 1.42285 43.6119 0 2150 2150 1.42286 43.6107 0 2150 2200 1.42286 43.6095 0 2150 2250 1.42287 43.6083 0 2150 2300 1.42288 43.6071 0 2150 2350 1.42288 43.6059 0 2150 2400 1.42289 43.6046 0 2150 2450 1.4229 43.6034 0 2200 2000 1.42442 43.6144 0 2200 2050 1.42443 43.6131 0 2200 2100 1.42443 43.6119 0 2200 2150 1.42444 43.6107 0 2200 2200 1.42445 43.6095 0 2200 2250 1.42445 43.6083 0 2200 2300 1.42446 43.6071 0 2200 2350 1.42447 43.6059 0 2200 2400 1.42447 43.6046 0 2200 2450 1.42448 43.6034 0 2250 2000 1.42601 43.6144 0 2250 2050 1.42601 43.6131 0 2250 2100 1.42602 43.6119 0 2250 2150 1.42602 43.6107 0 2250 2200 1.42603 43.6095 0 2250 2250 1.42604 43.6083 0 2250 2300 1.42604 43.6071 0 2250 2350 1.42605 43.6059 0 2250 2400 1.42605 43.6047 0 2250 2450 1.42606 43.6034 0 2300 2000 1.42759 43.6144 0 2300 2050 1.42759 43.6131 0 2300 2100 1.4276 43.6119 0 2300 2150 1.42761 43.6107 0 2300 2200 1.42761 43.6095 0 2300 2250 1.42762 43.6083 0 2300 2300 1.42762 43.6071 0 2300 2350 1.42763 43.6059 0 2300 2400 1.42764 43.6047 0 2300 2450 1.42764 43.6034 0 2350 2000 1.42917 43.6144 0 2350 2050 1.42918 43.6131 0 2350 2100 1.42918 43.6119 0 2350 2150 1.42919 43.6107 0 2350 2200 1.42919 43.6095 0 2350 2250 1.4292 43.6083 0 2350 2300 1.42921 43.6071 0 2350 2350 1.42921 43.6059 0 2350 2400 1.42922 43.6047 0 2350 2450 1.42922 43.6034 0 2400 2000 1.43075 43.6144 0 2400 2050 1.43076 43.6131 0 2400 2100 1.43076 43.6119 0 2400 2150 1.43077 43.6107 0 2400 2200 1.43078 43.6095 0 2400 2250 1.43078 43.6083 0 2400 2300 1.43079 43.6071 0 2400 2350 1.43079 43.6059 0 2400 2400 1.4308 43.6047 0 2400 2450 1.43081 43.6034 0 2450 2000 1.43234 43.6144 0 2450 2050 1.43234 43.6132 0 2450 2100 1.43235 43.6119 0 2450 2150 1.43235 43.6107 0 2450 2200 1.43236 43.6095 0 2450 2250 1.43236 43.6083 0 2450 2300 1.43237 43.6071 0 2450 2350 1.43238 43.6059 0 2450 2400 1.43238 43.6047 0 2450 2450 1.43239 43.6034 0 ) otb_add_test(NAME prTvGeometriesProjectionFilterFromMapToImage COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToImage.shp ${TEMP}/prTvGeometriesProjectionFilterFromMapToImage.shp otbGeometriesProjectionFilterFromMapToImage ${INPUTDATA}/ToulousePoints-examples.shp ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/prTvGeometriesProjectionFilterFromMapToImage.shp ) otb_add_test(NAME prTvGeometriesProjectionFilterFromMapToEPSG_UTM COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterLines.shp ${TEMP}/prTvGeometriesProjectionFilterFromMapToEPSG_UTM.shp otbGeometriesProjectionFilterFromMapToEPSG ${INPUTDATA}/ToulouseRoad-examples.shp ${TEMP}/prTvGeometriesProjectionFilterFromMapToEPSG_UTM.shp 32631 ) otb_add_test(NAME prTvGeometriesProjectionFilterFromMapToEPSG_WGS84 COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterFromMapToGeo.kml ${TEMP}/prTvGeometriesProjectionFilterFromMapToEPSG_WGS84.shp otbGeometriesProjectionFilterFromMapToEPSG ${INPUTDATA}/ToulousePoints-examples.shp ${TEMP}/prTvGeometriesProjectionFilterFromMapToEPSG_WGS84.shp 4326 ) otb_add_test(NAME prTvVectorDataProjectionFilterPoints COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterPoints.shp ${TEMP}/prTvVectorDataProjectionFilterPoints.shp otbVectorDataProjectionFilter ${INPUTDATA}/ToulousePoints-examples.shp ${TEMP}/prTvVectorDataProjectionFilterPoints.shp ) otb_add_test(NAME prTvVectorDataProjectionFilterLines COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterLines.shp ${TEMP}/prTvVectorDataProjectionFilterLines.shp otbVectorDataProjectionFilter ${INPUTDATA}/ToulouseRoad-examples.shp ${TEMP}/prTvVectorDataProjectionFilterLines.shp ) otb_add_test(NAME prTvVectorDataProjectionFilterPolygons COMMAND otbProjectionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/prTvVectorDataProjectionFilterPolygons.shp ${TEMP}/prTvVectorDataProjectionFilterPolygons.shp otbVectorDataProjectionFilter ${INPUTDATA}/Capitole-Shadows.shp ${TEMP}/prTvVectorDataProjectionFilterPolygons.shp ) otb_add_test(NAME prTvUtmMapProjection COMMAND otbProjectionTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvUtmMapProjection.txt ${TEMP}/prTvUtmMapProjection.txt otbUtmMapProjection ${TEMP}/prTvUtmMapProjection.txt ) otb_add_test(NAME prTuVectorDataProjectionFilterNew COMMAND otbProjectionTestDriver otbVectorDataProjectionFilterNew ) otb_add_test(NAME prTvTileMapTransform COMMAND otbProjectionTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/prTvTileMapTransform.txt ${TEMP}/prTvTileMapTransform.txt otbTileMapTransform ${TEMP}/prTvTileMapTransform.txt ) otb_add_test(NAME bfTvImportGeoInformationImageFilter COMMAND otbProjectionTestDriver --compare-metadata ${NOTOL} ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/bfTvImportGeoInformationOutput.img otbImportGeoInformationImageFilter ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/bfTvImportGeoInformationOutput.img ) set(GenericConversionChecking_INPUTS LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} #LARGEINPUT{SPOT4/RIO_DE_JANEIRO/IMAG_01.DAT LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} LARGEINPUT{RADARSAT1/GOMA2/SCENE01/DAT_01.001} LARGEINPUT{RADARSAT2/ALTONA/Fine_Quad-Pol_Dataset/PK6621_DK406_FQ9_20080405_124900_HH_VV_HV_VH_SLC_Altona/imagery_HH.tif} LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} #LARGEINPUT{GEOEYE/LES_ROCHES/po_350134_bgrn_0000000.tif #LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_pan_0000000.tif #LARGEINPUT{PALSAR/ALOS-H1_1__A-ORBIT__ALPSRP037120700.tif #LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF LARGEINPUT{TERRASARX/PANGKALANBUUN/TSX1_SAR__SSC______SM_D_SRA_20080313T221955_20080313T222003.xml} LARGEINPUT{ENVISAT_ASAR_SCENE01/ASA_APS_1PNDPA20030821_7713.N1} #LARGEINPUT{COSMOSKYMED/Toulouse_spotlight/CSKS3_GTC_B_S2_08_HH_RD_SF_20110418180325_20110418180332.h5 #LARGEINPUT{MODIS/MOD13Q1/MOD13Q1.A2010001.h17v05.005.2010028003734.hdf #LARGEINPUT{ONERA/spa3_0215_rad.dat #LARGEINPUT{RAPIDEYE/level3A/2008-12-25T005918_RE3_3A-NAC_752656_40091.tif ) #set(VectorDataIntoImage_FILES #LARGEINPUT{QB_EXTRACT/qb_extract_00_withgeom.tif} #LARGEINPUT{QB_EXTRACT/qb_extract_00_withgeom_ENVI.hdr} #LARGEINPUT{QB_EXTRACT/qb_extract_11_withgeom.tif} #LARGEINPUT{QB_EXTRACT/qb_extract_11_withgeom_ENVI.hdr} #LARGEINPUT{QB_EXTRACT/qb_utm.tif} #LARGEINPUT{QB_EXTRACT/qb_utm_withgeom.tif} #LARGEINPUT{QB_EXTRACT/qb_wgs84.tif} #LARGEINPUT{QB_EXTRACT/qb_wgs84_withgeom.tif} #LARGEINPUT{QB_EXTRACT/qb_wgs84_worldfile.tif} #) #set( VectorDataIntoImage_TESTNB 0) #foreach( file ${VectorDataIntoImage_FILES} ) #math(EXPR VectorDataIntoImage_TESTNB "${VectorDataIntoImage_TESTNB} + 1") #otb_add_test(NAME prTvVectorDataIntoImageProjectionFilter_${VectorDataIntoImage_TESTNB} COMMAND otbProjectionTestDriver #otbVectorDataIntoImageProjectionFilterTest #${file} #${OTB_DATA_LARGEINPUT_ROOT}/VECTOR/MidiPyrenees/natural.shp #${INPUTDATA}/DEM/srtm_directory #3 ) #endforeach() set(SENSOR_TYPES "QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF" "GEOEYE/LES_ROCHES/po_350134_bgrn_0000000.tif" "WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL/09DEC10103019-M2AS-052298844010_01_P001.TIF" ) foreach( file ${SENSOR_TYPES}) # Get the sensor name set(sharp_regexp "([0-9A-Za-z_]*)[ ]*/[ ]*(.*)") string(REGEX REPLACE "${sharp_regexp}" "\\1" sensor_name "${file}") # Tests otb_add_test(NAME prTvotbGenericRSResampleImageFilterFromMap_${sensor_name} COMMAND otbProjectionTestDriver --compare-image ${EPSILON_4} ${BASELINE}/prTvotbGenericRSResampleImageFilterOutputFromMap_${sensor_name}.tif ${TEMP}/prTvotbGenericRSResampleImageFilterOutputFromMap_${sensor_name}.tif otbGenericRSResampleImageFilterFromMap LARGEINPUT{${file}} 15 0 ${TEMP}/prTvotbGenericRSResampleImageFilterOutputFromMap_${sensor_name}.tif ) endforeach() OTB-release-5.8/Modules/Filtering/Projection/test/otbCompositeTransform.cxx000066400000000000000000000050171301006202600271360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbCompositeTransform.h" #include "otbMapProjections.h" #include "otbInverseSensorModel.h" int otbCompositeTransform(int argc, char* argv[]) { if (argc != 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } char * filename = argv[1]; char * outFilename = argv[2]; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(filename); reader->UpdateOutputInformation(); typedef otb::UtmInverseProjection MapProjectionType; int utmZone = 31; char utmHemisphere = 'N'; MapProjectionType::Pointer mapProjection = MapProjectionType::New(); mapProjection->SetZone(utmZone); mapProjection->SetHemisphere(utmHemisphere); typedef otb::InverseSensorModel SensorModelType; SensorModelType::Pointer sensorModel = SensorModelType::New(); sensorModel->SetImageGeometry(reader->GetOutput()->GetImageKeywordlist()); if( sensorModel->IsValidSensorModel() == false ) { std::cout<<"Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!"< CompositeTransformType; CompositeTransformType::Pointer compositeTransform = CompositeTransformType::New(); compositeTransform->SetFirstTransform(mapProjection); compositeTransform->SetSecondTransform(sensorModel); std::ofstream file; file.open(outFilename); file << std::setprecision(15); itk::Point point; point[0] = 374100; point[1] = 4829000; file << "Standard Composite transform: " << std::endl; file << point << " -> "; file << compositeTransform->TransformPoint(point); file << std::endl << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbCompositeTransformNew.cxx000066400000000000000000000021511301006202600276040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCompositeTransform.h" #include "otbMapProjections.h" #include "otbInverseSensorModel.h" int otbCompositeTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::UtmInverseProjection MapProjectionType; typedef otb::InverseSensorModel SensorModelType; typedef otb::CompositeTransform CompositeTransformType; CompositeTransformType::Pointer transform = CompositeTransformType::New(); std::cout << transform << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGCPsToRPCSensorModelImageFilterAndOrtho.cxx000066400000000000000000000114521301006202600326670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbGCPsToRPCSensorModelImageFilter.h" #include "otbImageFileWriter.h" #include "otbMapProjections.h" #include "otbOrthoRectificationFilter.h" #include "otbMapProjections.h" int otbGCPsToRPCSensorModelImageFilterAndOrtho(int argc, char* argv[]) { if (argc < 11) { std::cerr << "Usage: " << argv[0] << " infname outfname a1x a1y b1x b1y b1z ... aNx aNy bNx bNy bNz " << std::endl; return EXIT_FAILURE; } else if ((argc - 11) % 5 != 0) { std::cerr << "Inconsistent GCPs description!" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::GCPsToRPCSensorModelImageFilter GCPsToSensorModelFilterType; typedef GCPsToSensorModelFilterType::Point2DType Point2DType; typedef GCPsToSensorModelFilterType::Point3DType Point3DType; typedef otb::ImageFileWriter WriterType; typedef otb::UtmInverseProjection UtmMapProjectionType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->UpdateOutputInformation(); GCPsToSensorModelFilterType::Pointer rpcEstimator = GCPsToSensorModelFilterType::New(); rpcEstimator->SetInput(reader->GetOutput()); unsigned int nbGCPs = (argc - 11) / 5; std::cout << "Receiving " << nbGCPs << " from command line." << std::endl; for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { Point2DType sensorPoint; sensorPoint[0] = atof(argv[11 + gcpId * 5]); sensorPoint[1] = atof(argv[12 + gcpId * 5]); Point3DType geoPoint; geoPoint[0] = atof(argv[13 + 5 * gcpId]); geoPoint[1] = atof(argv[14 + 5 * gcpId]); geoPoint[2] = atof(argv[15 + 5 * gcpId]); std::cout << "Adding GCP sensor: " << sensorPoint << " <-> geo: " << geoPoint << std::endl; rpcEstimator->AddGCP(sensorPoint, geoPoint); } rpcEstimator->GetOutput()->UpdateOutputInformation(); // Set floatfield to format properly std::cout.setf(std::ios::fixed, std::ios::floatfield); std::cout.precision(10); std::cout << rpcEstimator->GetOutput()->GetImageKeywordlist() << std::endl; std::cout << "Residual ground error: " << rpcEstimator->GetRMSGroundError() << std::endl; // Orthorectify the output image WriterType::Pointer writer = WriterType::New(); OrthoRectifFilterType::Pointer orthoRectifFilter = OrthoRectifFilterType::New(); UtmMapProjectionType::Pointer utmMapProjection = UtmMapProjectionType::New(); orthoRectifFilter->SetInput(rpcEstimator->GetOutput()); ImageType::IndexType start; start[0] = 0; start[1] = 0; orthoRectifFilter->SetOutputStartIndex(start); ImageType::SizeType size; size[0] = atoi(argv[5]); // X size size[1] = atoi(argv[6]); //Y size orthoRectifFilter->SetOutputSize(size); ImageType::SpacingType spacing; spacing[0] = atof(argv[7]); spacing[1] = atof(argv[8]); orthoRectifFilter->SetOutputSpacing(spacing); ImageType::PointType origin; origin[0] = strtod(argv[3], ITK_NULLPTR); //Origin easting origin[1] = strtod(argv[4], ITK_NULLPTR); //Origin northing orthoRectifFilter->SetOutputOrigin(origin); utmMapProjection->SetZone(atoi(argv[9])); utmMapProjection->SetHemisphere(argv[10][0]); orthoRectifFilter->SetMapProjection(utmMapProjection); ImageType::PixelType no_data(reader->GetOutput()->GetNumberOfComponentsPerPixel()); no_data.Fill(0.0); orthoRectifFilter->SetEdgePaddingValue(no_data); // Displacement Field spacing ImageType::SpacingType gridSpacing; gridSpacing[0] = 16.0 * atof(argv[7]); gridSpacing[1] = 16.0 * atof(argv[8]); orthoRectifFilter->SetDisplacementFieldSpacing(gridSpacing); writer->SetInput(orthoRectifFilter->GetOutput()); writer->SetFileName(outfname); writer->SetNumberOfDivisionsTiledStreaming(4); writer->Update(); return EXIT_SUCCESS; } otbGCPsToRPCSensorModelImageFilterCheckRpcModel.cxx000066400000000000000000000156721301006202600335450ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Projection/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbCommandLineArgumentParser.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbGCPsToRPCSensorModelImageFilter.h" #include "otbGenericRSTransform.h" #include "otbGeographicalDistance.h" int otbGCPsToRPCSensorModelImageFilterCheckRpcModel(int argc, char * argv[]) { // Set command line arguments typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOption("--DEMDirectory", "Path to the DEM directory ", "-dem", 1, false); parser->AddOptionNParams("--GroudControlPoints", "Ground Control Points to estimate sensor model a1x a1y b1x b1y b1z ... aNx aNy aNz bNx bNy bNz", "-gcp", true); parser->AddOption("--ErrorAllowed", "Error allowed to declare a point not good ", "-err", 1, false); // Parse the command line typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); } catch ( itk::ExceptionObject & err ) { std::string descriptionException = err.GetDescription(); if (descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos) { return EXIT_SUCCESS; } if (descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos) { return EXIT_SUCCESS; } return EXIT_FAILURE; } // Check if the number of gcp pairs point is consistent unsigned int nbPoints = parseResult->GetNumberOfParameters("--GroudControlPoints"); if (nbPoints % 5 != 0) { std::cerr << "Inconsistent GCPs description!" << std::endl; return EXIT_FAILURE; } typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::GCPsToRPCSensorModelImageFilter GCPsToSensorModelFilterType; typedef GCPsToSensorModelFilterType::Point2DType Point2DType; typedef GCPsToSensorModelFilterType::Point3DType Point3DType; typedef otb::GenericRSTransform GenericRSTransformType; typedef otb::GeographicalDistance GeoDistanceType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(parseResult->GetInputImage()); reader->UpdateOutputInformation(); GCPsToSensorModelFilterType::Pointer rpcEstimator = GCPsToSensorModelFilterType::New(); rpcEstimator->SetInput(reader->GetOutput()); unsigned int nbGCPs = nbPoints / 5; std::cout << "Receiving " << nbPoints << " from command line." << std::endl; for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { Point2DType sensorPoint; sensorPoint[0] = parseResult->GetParameterFloat("--GroudControlPoints", gcpId * 5); sensorPoint[1] = parseResult->GetParameterFloat("--GroudControlPoints", 1 + gcpId * 5); Point3DType geoPoint; geoPoint[0] = parseResult->GetParameterFloat("--GroudControlPoints", 2 + gcpId * 5); geoPoint[1] = parseResult->GetParameterFloat("--GroudControlPoints", 3 + gcpId * 5); geoPoint[2] = parseResult->GetParameterFloat("--GroudControlPoints", 4 + gcpId * 5); std::cout << "Adding GCP sensor: " << sensorPoint << " <-> geo: " << geoPoint << std::endl; rpcEstimator->AddGCP(sensorPoint, geoPoint); } // Estimate the rpc model rpcEstimator->GetOutput()->UpdateOutputInformation(); // Instancicate a GenericRSTransform in order to transform the // indexes, using the rpcModel estimated, into geographical // coordiantes. // The test will check for nan coordinates, and the distance between // geographical coordinates. GenericRSTransformType::Pointer grsTrasnform = GenericRSTransformType::New(); grsTrasnform->SetInputKeywordList(rpcEstimator->GetKeywordlist()); std::cout<GetKeywordlist()<SetOutputProjectionRef("4326"); // Set the DEM Directory if any if(parseResult->IsOptionPresent("--DEMDirectory")) { otb::DEMHandler::Instance()->OpenDEMDirectory(parseResult->GetParameterString("--DEMDirectory")); } else { otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(0); } grsTrasnform->InstantiateTransform(); // Test GeoDistanceType::Pointer geoDistance = GeoDistanceType::New(); bool isErrorDetected = false; for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { Point3DType point; point[0] = parseResult->GetParameterFloat("--GroudControlPoints", gcpId * 5); point[1] = parseResult->GetParameterFloat("--GroudControlPoints", 1 + gcpId * 5); point[2] = parseResult->GetParameterFloat("--GroudControlPoints", 4 + gcpId * 5); Point3DType transformedPoint; transformedPoint = grsTrasnform->TransformPoint(point); Point2DType transformedPoint2D; transformedPoint2D[0] = transformedPoint[0]; transformedPoint2D[1] = transformedPoint[1]; // reference point Point2DType geoPoint; geoPoint[0] = parseResult->GetParameterFloat("--GroudControlPoints", 2 + gcpId * 5); geoPoint[1] = parseResult->GetParameterFloat("--GroudControlPoints", 3 + gcpId * 5); // Search for nans if ( vnl_math_isnan(transformedPoint2D[0]) || vnl_math_isnan(transformedPoint2D[1]) ) { std::cout << "Reference : "<< geoPoint <<" --> Result of the reprojection using the estimated RpcModel "<< transformedPoint2D << std::endl; std::cout<<"The result of the projection is nan, there is a problem with the estimated RpcModel " << std::endl<Evaluate(geoPoint, transformedPoint2D); if( residual > parseResult->GetParameterFloat("--ErrorAllowed")) { std::cout << "Reference : "<< geoPoint <<" --> Result of the reprojection using the estimated RpcModel " << transformedPoint2D << std::endl << " Residual ["<< residual << "] is higher than the tolerance [" << parseResult->GetParameterFloat("--ErrorAllowed") <<"], there is a problem with the estimated RpcModel" < ImageType; typedef otb::GCPsToRPCSensorModelImageFilter GCPToSensorModelFilterType; // Instantiation GCPToSensorModelFilterType::Pointer filter = GCPToSensorModelFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGCPsToRPCSensorModelImageFilterWithoutDEM.cxx000066400000000000000000000053311301006202600331410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbGCPsToRPCSensorModelImageFilter.h" int otbGCPsToRPCSensorModelImageFilterWithoutDEM(int argc, char* argv[]) { if (argc < 3) { std::cerr << "Usage: " << argv[0] << " infname outfname a1x a1y b1x b1y b1z ... aNx aNy bNx bNy bNz" << std::endl; return EXIT_FAILURE; } else if ((argc - 3) % 5 != 0) { std::cerr << "Inconsistent GCPs description!" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::GCPsToRPCSensorModelImageFilter GCPsToSensorModelFilterType; typedef GCPsToSensorModelFilterType::Point2DType Point2DType; typedef GCPsToSensorModelFilterType::Point3DType Point3DType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); GCPsToSensorModelFilterType::Pointer rpcEstimator = GCPsToSensorModelFilterType::New(); rpcEstimator->SetInput(reader->GetOutput()); unsigned int nbGCPs = (argc - 3) / 5; std::cout << "Receiving " << nbGCPs << " from command line." << std::endl; for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { Point2DType sensorPoint; sensorPoint[0] = atof(argv[3 + gcpId * 5]); sensorPoint[1] = atof(argv[4 + gcpId * 5]); Point3DType geoPoint; geoPoint[0] = atof(argv[5 + 5 * gcpId]); geoPoint[1] = atof(argv[6 + 5 * gcpId]); geoPoint[2] = atof(argv[7 + 5 * gcpId]); std::cout << "Adding GCP sensor: " << sensorPoint << " <-> geo: " << geoPoint << std::endl; rpcEstimator->AddGCP(sensorPoint, geoPoint); } rpcEstimator->GetOutput()->UpdateOutputInformation(); std::ofstream ofs; ofs.open(outfname); // Set floatfield to format properly ofs.setf(std::ios::fixed, std::ios::floatfield); ofs.precision(10); ofs << rpcEstimator->GetOutput()->GetImageKeywordlist() << std::endl; ofs << "Residual ground error: " << rpcEstimator->GetRMSGroundError() << std::endl; ofs.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGenericRSResampleImageFilter.cxx000066400000000000000000000136751301006202600307340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGenericRSResampleImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include // Extract ROI #include "otbMultiChannelExtractROI.h" // Images definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::SizeType SizeType; typedef otb::GenericRSResampleImageFilter ImageResamplerType; typedef ImageResamplerType::OriginType OriginType; typedef ImageResamplerType::SpacingType SpacingType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; int otbGenericRSResampleImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { // SmartPointer instantiation ImageResamplerType::Pointer resampler = ImageResamplerType::New(); std::cout << resampler << std::endl; return EXIT_SUCCESS; } int otbGenericRSResampleImageFilter(int itkNotUsed(argc), char* argv[]) { // SmartPointer instantiation ImageResamplerType::Pointer resampler = ImageResamplerType::New(); const char * infname = argv[1]; const char * outfname = argv[6]; unsigned int isize = atoi(argv[2]); double iGridSpacing = atof(argv[3]); int useInRpc = atoi(argv[4]); int useOutRpc = atoi(argv[5]); ReaderType::Pointer reader = ReaderType::New(); // Read the input image reader->SetFileName(infname); reader->UpdateOutputInformation(); // Fill the output size with the user selection SizeType size; size.Fill(isize); // Set the origin & the spacing of the output OriginType origin; origin[0] = 367340; origin[1] = 4.83467e+06; SpacingType spacing; spacing[0] = 0.6; spacing[1] = -0.6; // Build the output projection ref : UTM ref OGRSpatialReference oSRS; oSRS.SetProjCS("UTM"); oSRS.SetUTM(31, true); char * utmRef = ITK_NULLPTR; oSRS.exportToWkt(&utmRef); // Displacement Field spacing SpacingType gridSpacing; gridSpacing[0] = iGridSpacing; gridSpacing[1] = -iGridSpacing; // Default value builder ImageType::PixelType defaultValue; itk::NumericTraits::SetLength(defaultValue, reader->GetOutput()->GetNumberOfComponentsPerPixel()); // Set the Resampler Parameters resampler->SetInput(reader->GetOutput()); resampler->SetDisplacementFieldSpacing(gridSpacing); resampler->SetOutputOrigin(origin); resampler->SetOutputSize(size); resampler->SetOutputSpacing(spacing); resampler->SetOutputProjectionRef(utmRef); resampler->SetEdgePaddingValue(defaultValue); if (useInRpc) { resampler->SetInputRpcGridSize(20); resampler->EstimateInputRpcModelOn(); } if (useOutRpc) { resampler->SetOutputRpcGridSize(20); resampler->EstimateOutputRpcModelOn(); } // Write the resampled image WriterType::Pointer writer= WriterType::New(); writer->SetNumberOfDivisionsTiledStreaming(4); writer->SetFileName(outfname); writer->SetInput(resampler->GetOutput()); writer->Update(); std::cout << resampler << std::endl; return EXIT_SUCCESS; } int otbGenericRSResampleImageFilterFromMap(int itkNotUsed(argc), char* argv[]) { typedef otb::MultiChannelExtractROI ExtractROIType; // SmartPointer instantiation ExtractROIType::Pointer extractor = ExtractROIType::New(); ImageResamplerType::Pointer resampler = ImageResamplerType::New(); const char * infname = argv[1]; const char * outfname = argv[4]; double iGridSpacing = atof(argv[2]); int useInRpc = atoi(argv[3]); // Reader Instantiation ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->UpdateOutputInformation(); SpacingType spacing; spacing[0] = 2.5; spacing[1] = -2.5; // Displacement Field spacing SpacingType gridSpacing; gridSpacing[0] = iGridSpacing; gridSpacing[1] = -iGridSpacing; // Default value builder ImageType::PixelType defaultValue; itk::NumericTraits::SetLength(defaultValue, reader->GetOutput()->GetNumberOfComponentsPerPixel()); // Extract a roi centered on the input center ImageType::RegionType roi; ImageType::IndexType roiIndex; SizeType roiSize; // Fill the size roiSize.Fill(250); // Fill the start index roiIndex[0] = (unsigned int)((reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0] - roiSize[0]) /2); roiIndex[1] = (unsigned int)((reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1] - roiSize[1]) /2); roi.SetIndex(roiIndex); roi.SetSize(roiSize); extractor->SetExtractionRegion(roi); extractor->SetInput(reader->GetOutput()); extractor->UpdateOutputInformation(); // Set the Resampler Parameters resampler->SetInput(extractor->GetOutput()); resampler->SetDisplacementFieldSpacing(gridSpacing); resampler->SetOutputParametersFromMap("UTM", spacing); if (useInRpc) { resampler->SetInputRpcGridSize(20); resampler->EstimateInputRpcModelOn(); } // Write the resampled image WriterType::Pointer writer= WriterType::New(); writer->SetAutomaticTiledStreaming(); writer->SetFileName(outfname); writer->SetInput(resampler->GetOutput()); writer->Update(); std::cout << resampler << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGenericRSTransformFromImage.cxx000066400000000000000000000210471301006202600306050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbGenericRSTransform.h" #include #include "itkEuclideanDistanceMetric.h" #include "otbGeographicalDistance.h" #include "otbDEMHandler.h" typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::GenericRSTransform<> TransformType; typedef TransformType::InputPointType PointType; typedef otb::GenericRSTransform Transform3DType; typedef Transform3DType::InputPointType Point3DType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef itk::Statistics::EuclideanDistanceMetric Distance3DType; typedef otb::GeographicalDistance GeoDistanceType; typedef otb::GeographicalDistance GeoDistance3DType; int otbGenericRSTransformFromImage(int itkNotUsed(argc), char* argv[]) { /* * This test checks if we can instantiate a GenericRSTransform from the image information * without throwing an exception */ // Reader ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); // Build wgs ref OGRSpatialReference oSRS; oSRS.SetWellKnownGeogCS("WGS84"); char * wgsRef = ITK_NULLPTR; oSRS.exportToWkt(&wgsRef); // Instantiate WGS->Image transform TransformType::Pointer wgs2img = TransformType::New(); wgs2img->SetInputProjectionRef(wgsRef); wgs2img->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); wgs2img->SetOutputKeywordList(reader->GetOutput()->GetImageKeywordlist()); wgs2img->InstantiateTransform(); // Instantiate Image->WGS transform TransformType::Pointer img2wgs = TransformType::New(); img2wgs->SetInputProjectionRef(reader->GetOutput()->GetProjectionRef()); img2wgs->SetInputKeywordList(reader->GetOutput()->GetImageKeywordlist()); img2wgs->SetOutputProjectionRef(wgsRef); img2wgs->InstantiateTransform(); return EXIT_SUCCESS; } int otbGenericRSTransformImageAndMNTToWGS84ConversionChecking(int itkNotUsed(argc), char* argv[]) { std::string infname = argv[1]; std::string demdir = argv[2]; ImageType::PointType refImgPt, refGeoPt, estimatedImgPt, estimatedGeoPt; refImgPt[0] = atof(argv[4]); refImgPt[1] = atof(argv[5]); refGeoPt[0] = atof(argv[6]); refGeoPt[1] = atof(argv[7]); double refHeight = atof(argv[8]); double imgTol = atof(argv[9]); double geoTol = atof(argv[10]); Point3DType refImgPt3d, refGeoPt3d,estimatedImgPt3d, estimatedGeoPt3d; refImgPt3d[0] = refImgPt[0]; refImgPt3d[1] = refImgPt[1]; refGeoPt3d[0] = refGeoPt[0]; refGeoPt3d[1] = refGeoPt[1]; bool pass = true; // Reader ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); // Build wgs ref OGRSpatialReference oSRS; oSRS.SetWellKnownGeogCS("WGS84"); char * wgsRef = ITK_NULLPTR; oSRS.exportToWkt(&wgsRef); DistanceType::Pointer distance = DistanceType::New(); Distance3DType::Pointer distance3d = Distance3DType::New(); GeoDistanceType::Pointer geoDistance = GeoDistanceType::New(); GeoDistance3DType::Pointer geoDistance3d = GeoDistance3DType::New(); otb::DEMHandler::Pointer demHandler = otb::DEMHandler::Instance(); demHandler->OpenDEMDirectory(argv[2]); demHandler->OpenGeoidFile(argv[3]); double heightAboveEllipsoid = demHandler->GetHeightAboveEllipsoid(refGeoPt); // Instantiate WGS->Image transform TransformType::Pointer wgs2img = TransformType::New(); wgs2img->SetInputProjectionRef(wgsRef); wgs2img->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); wgs2img->SetOutputKeywordList(reader->GetOutput()->GetImageKeywordlist()); wgs2img->InstantiateTransform(); // Instantiate Image->WGS transform TransformType::Pointer img2wgs = TransformType::New(); img2wgs->SetInputProjectionRef(reader->GetOutput()->GetProjectionRef()); img2wgs->SetInputKeywordList(reader->GetOutput()->GetImageKeywordlist()); img2wgs->SetOutputProjectionRef(wgsRef); img2wgs->InstantiateTransform(); // Instantiate WGS->Image transform 3D Transform3DType::Pointer wgs2img3d = Transform3DType::New(); wgs2img3d->SetInputProjectionRef(wgsRef); wgs2img3d->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); wgs2img3d->SetOutputKeywordList(reader->GetOutput()->GetImageKeywordlist()); wgs2img3d->InstantiateTransform(); // Instantiate Image->WGS transform 3D Transform3DType::Pointer img2wgs3d = Transform3DType::New(); img2wgs3d->SetInputProjectionRef(reader->GetOutput()->GetProjectionRef()); img2wgs3d->SetInputKeywordList(reader->GetOutput()->GetImageKeywordlist()); img2wgs3d->SetOutputProjectionRef(wgsRef); img2wgs3d->InstantiateTransform(); std::cout<< std::setprecision(8) << std::endl; std::cout<<"References: "<TransformPoint(refGeoPt); std::cout<<"Inverse(refGeo): "< "<< estimatedImgPt <Evaluate(refImgPt, estimatedImgPt); std::cout<<"Residual: "< imgTol) { pass = false; std::cerr<<"Image residual is too high: "<TransformPoint(refImgPt); std::cout<<"Forward(refImg): "< " << estimatedGeoPt<Evaluate(refGeoPt, estimatedGeoPt); std::cout<<"Residual: "< geoTol) { pass = false; std::cerr<<"Geographic (WGS84) residual is too high: "<TransformPoint(refImgPt3d); std::cout<<"Forward(refImg): "< " << estimatedGeoPt3d<Evaluate(refGeoPt3d, estimatedGeoPt3d); std::cout<<"Residual: "< geoTol) { pass = false; std::cerr<<"Geographic (WGS84) residual is too high: "<TransformPoint(refGeoPt3d); std::cout<<"Inverse(refGeo): "< "<< estimatedImgPt3d <Evaluate(refImgPt3d, estimatedImgPt3d); std::cout<<"Residual: "< imgTol) { pass = false; std::cerr<<"Image residual is too high: "<TransformPoint(refImgPt3d); std::cout<<"Forward(refImg): "< " << estimatedGeoPt3d<Evaluate(refGeoPt3d, estimatedGeoPt3d); std::cout<<"Residual: "< geoTol) { pass = false; std::cerr<<"Geographic (WGS84) residual is too high: "<TransformPoint(refGeoPt3d); std::cout<<"Inverse(refGeo): "< "<< estimatedImgPt <Evaluate(refImgPt3d, estimatedImgPt3d); std::cout<<"Residual: "< imgTol) { pass = false; std::cerr<<"Image residual is too high: "< ImageType; typedef otb::ImageFileReader ReaderType; typedef ImageType::PointType PointType; typedef otb::GenericRSTransform<> TransformType; typedef itk::Statistics::EuclideanDistanceMetric PointEuclideanDistanceMetricType; typedef otb::GeographicalDistance GeographicalDistanceType; int otbGenericRSTransformGenericTest(int argc, char * argv[]) { if(argc<14) { std::cerr<<"Usage: "<SetFileName(argv[6]); reader->UpdateOutputInformation(); transform->SetInputProjectionRef(reader->GetOutput()->GetProjectionRef()); transform->SetInputKeywordList(reader->GetOutput()->GetImageKeywordlist()); std::cout<<"Input projection read from image: "<SetInputProjectionRef(argv[6]); std::cout<<"Input projection read from wkt: "<SetInputProjectionRef(wktFromEpsg); std::cout<<"Input projection read from epsg code: "<SetFileName(argv[8]); reader->UpdateOutputInformation(); transform->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); transform->SetOutputKeywordList(reader->GetOutput()->GetImageKeywordlist()); std::cout<<"Output projection read from image: "<SetOutputProjectionRef(argv[6]); std::cout<<"Output projection read from wkt: "<SetOutputProjectionRef(wktFromEpsg); std::cout<<"Output projection read from epsg code: "<SetDefaultHeightAboveEllipsoid(averageElevation); std::cout<<"Average elevation "<OpenDEMDirectory(argv[14]); std::cout<<"Elevation from DEM "<InstantiateTransform(); // Generate the inverse transform TransformType::Pointer inverseTransform = TransformType::New(); transform->GetInverse(inverseTransform); std::cout<TransformPoint(refInPoint); std::cout<<"transform("<TransformPoint(refOutPoint); std::cout<<"transform("<Evaluate(outPoint, refOutPoint); } else if(outDistType == "GEO") { std::cout<<"Output precision checked using Haversine distance."<Evaluate(outPoint, refOutPoint); } else { std::cerr<<"Failed to read out distance flag. Should be one of PHYSICAL, GEO."<outThreshold) { failed = true; std::cerr<<"Output residual ("<Evaluate(inPoint, refInPoint); } else if(inDistType == "GEO") { std::cout<<"Input precision checked using Haversine distance."<Evaluate(inPoint, refInPoint); } else { std::cerr<<"Failed to read in distance flag. Should be one of PHYSICAL, GEO."<inThreshold) { failed = true; std::cerr<<"Input residual ("< PointType; typedef otb::GeographicalDistance DistanceType; // Instantiation DistanceType::Pointer distance = DistanceType::New(); return EXIT_SUCCESS; } int otbGeographicalDistance(int itkNotUsed(argc), char * argv[]) { typedef itk::Point PointType; typedef otb::GeographicalDistance GeoDistanceType; GeoDistanceType::Pointer geoDistance = GeoDistanceType::New(); PointType a, b; a[0] = atof(argv[1]); a[1] = atof(argv[2]); b[0] = atof(argv[3]); b[1] = atof(argv[4]); GeoDistanceType::OriginType o(2); o[0] = b[0]; o[1] = b[1]; double expectedDistance = atof(argv[5]); double tolerance = atof(argv[6]); double distEvaluate2 = geoDistance->Evaluate(a, b); double distEvaluate2Null = geoDistance->Evaluate(a, a); geoDistance->SetOrigin(o); double distEvaluate1 = geoDistance->Evaluate(a); double distEvaluate1Null = geoDistance->Evaluate(b); // Check results bool failFlag = false; std::cerr.setf(std::ios_base::fixed); std::cerr.precision(5); if(vcl_abs(distEvaluate1 - expectedDistance) > tolerance) { std::cerr<<"Evaluate("< tolerance) { std::cerr<<"Evaluate("< tolerance) { std::cerr<<"Evaluate("< tolerance) { std::cerr<<"Evaluate("< #include "otbGeometriesSet.h" #include "otbStandardFilterWatcher.h" /*===========================================================================*/ /*==============================[ other stuff ]==============================*/ /*===========================================================================*/ int otbGeometriesProjectionFilter(int argc, char * argv[]) { if (argc < 3) { std::cerr << argv[0] << " []\n"; return EXIT_FAILURE; } typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( argv[1], otb::ogr::DataSource::Modes::Read); InputGeometriesType::Pointer in_set = InputGeometriesType::New(input); typedef otb::GeometriesProjectionFilter GeometriesFilterType; GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); filter->SetInput(in_set); const std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; filter->SetOutputProjectionRef(projectionRefWkt); otb::StandardFilterWatcher watcher(filter, "GeometriesProjection"); otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New( argv[2], otb::ogr::DataSource::Modes::Update_LayerCreateOnly); OutputGeometriesType::Pointer out_set = OutputGeometriesType::New(output); filter->SetOutput(out_set); filter->Update(); //Output the tree in a text file if (argc >= 4) { std::ofstream file(argv[3]); file << "Original data\n" << in_set << "\n\n"; file << "Reprojected data\n" << out_set << "\n\n"; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGeometriesProjectionFilterFromGeoToMap.cxx000066400000000000000000000053161301006202600330300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" #include "otbImage.h" #include "otbImageFileReader.h" /*===========================================================================*/ /*==============================[ other stuff ]==============================*/ /*===========================================================================*/ int otbGeometriesProjectionFilterFromGeoToMap(int argc, char * argv[]) { if (argc < 4) { std::cerr << argv[0] << " " << " \n"; return EXIT_FAILURE; } // Input Geometries set typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( argv[1], otb::ogr::DataSource::Modes::Read); InputGeometriesType::Pointer in_set = InputGeometriesType::New(input); // Input Keywordlist (from image) typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); // Output Geometries Set otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New( argv[3], otb::ogr::DataSource::Modes::Overwrite); OutputGeometriesType::Pointer out_set = OutputGeometriesType::New(output); // Filter typedef otb::GeometriesProjectionFilter GeometriesFilterType; GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); filter->SetInput(in_set); filter->SetOutput(out_set); filter->SetOutputProjectionRef(imageReader->GetOutput()->GetProjectionRef()); filter->SetOutputOrigin(imageReader->GetOutput()->GetOrigin()); filter->SetOutputSpacing(imageReader->GetOutput()->GetSpacing()); filter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGeometriesProjectionFilterFromMapToEPSG.cxx000066400000000000000000000035011301006202600330460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbOGR.h" #include "otbGeometriesSet.h" #include "otbGeometriesProjectionFilter.h" int otbGeometriesProjectionFilterFromMapToEPSG(int argc, char * argv[]) { if (argc < 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char* inputVDFilename = argv[1]; const char* outputVDFilename = argv[2]; int epsg = atoi(argv[3]); typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( inputVDFilename, otb::ogr::DataSource::Modes::Read); InputGeometriesType::Pointer in_set = InputGeometriesType::New(input); typedef otb::GeometriesProjectionFilter GeometriesFilterType; GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); filter->SetInput(in_set); filter->SetOutputProjectionRef( otb::GeoInformationConversion::ToWKT(epsg) ); otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New( outputVDFilename, otb::ogr::DataSource::Modes::Overwrite); OutputGeometriesType::Pointer out_set = OutputGeometriesType::New(output); filter->SetOutput(out_set); filter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGeometriesProjectionFilterFromMapToGeo.cxx000066400000000000000000000042431301006202600330260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" #include "otbImage.h" #include "otbImageFileReader.h" /*===========================================================================*/ /*==============================[ other stuff ]==============================*/ /*===========================================================================*/ int otbGeometriesProjectionFilterFromMapToGeo(int argc, char* argv[]) { if (argc < 2) { std::cerr << argv[0] << " \n"; return EXIT_FAILURE; } // Input Geometries set typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( argv[1], otb::ogr::DataSource::Modes::Read); InputGeometriesType::Pointer in_set = InputGeometriesType::New(input); // Output Geometries Set otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New( argv[2], otb::ogr::DataSource::Modes::Overwrite); OutputGeometriesType::Pointer out_set = OutputGeometriesType::New(output); // Filter typedef otb::GeometriesProjectionFilter GeometriesFilterType; GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); filter->SetInput(in_set); filter->SetOutput(out_set); filter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGeometriesProjectionFilterFromMapToImage.cxx000066400000000000000000000053201301006202600333330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" #include "otbImage.h" #include "otbImageFileReader.h" /*===========================================================================*/ /*==============================[ other stuff ]==============================*/ /*===========================================================================*/ int otbGeometriesProjectionFilterFromMapToImage(int argc, char * argv[]) { if (argc < 4) { std::cerr << argv[0] << " " << " \n"; return EXIT_FAILURE; } // Input Geometries set typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( argv[1], otb::ogr::DataSource::Modes::Read); InputGeometriesType::Pointer in_set = InputGeometriesType::New(input); // Input Keywordlist (from image) typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); // Output Geometries Set otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New( argv[3], otb::ogr::DataSource::Modes::Overwrite); OutputGeometriesType::Pointer out_set = OutputGeometriesType::New(output); // Filter typedef otb::GeometriesProjectionFilter GeometriesFilterType; GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); filter->SetInput(in_set); filter->SetOutput(out_set); filter->SetOutputProjectionRef(imageReader->GetOutput()->GetProjectionRef()); filter->SetOutputOrigin(imageReader->GetOutput()->GetOrigin()); filter->SetOutputSpacing(imageReader->GetOutput()->GetSpacing()); filter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbGeometriesProjectionFilterFromMapToSensor.cxx000066400000000000000000000053221301006202600335640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ /*===========================================================================*/ /*===============================[ Includes ]================================*/ /*===========================================================================*/ #include "otbGeometriesProjectionFilter.h" #include "otbGeometriesSet.h" #include "otbImage.h" #include "otbImageFileReader.h" /*===========================================================================*/ /*==============================[ other stuff ]==============================*/ /*===========================================================================*/ int otbGeometriesProjectionFilterFromMapToSensor(int argc, char * argv[]) { if (argc < 4) { std::cerr << argv[0] << " " << " \n"; return EXIT_FAILURE; } // Input Geometries set typedef otb::GeometriesSet InputGeometriesType; typedef otb::GeometriesSet OutputGeometriesType; otb::ogr::DataSource::Pointer input = otb::ogr::DataSource::New( argv[1], otb::ogr::DataSource::Modes::Read); InputGeometriesType::Pointer in_set = InputGeometriesType::New(input); // Input Keywordlist (from image) typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); // Output Geometries Set otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New( argv[3], otb::ogr::DataSource::Modes::Overwrite); OutputGeometriesType::Pointer out_set = OutputGeometriesType::New(output); // Filter typedef otb::GeometriesProjectionFilter GeometriesFilterType; GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); filter->SetInput(in_set); filter->SetOutput(out_set); filter->SetOutputKeywordList(imageReader->GetOutput()->GetImageKeywordlist()); filter->SetOutputOrigin(imageReader->GetOutput()->GetOrigin()); filter->SetOutputSpacing(imageReader->GetOutput()->GetSpacing()); filter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbImageToEnvelopeVectorDataFilter.cxx000066400000000000000000000033441301006202600314470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageToEnvelopeVectorDataFilter.h" #include "otbVectorData.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" typedef unsigned short PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileWriter WriterType; typedef otb::ImageToEnvelopeVectorDataFilter FilterType; int otbImageToEnvelopeVectorDataFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { // Instantiation FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbImageToEnvelopeVectorDataFilter(int itkNotUsed(argc), char* argv[]) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbImageToGenericRSOutputParameters.cxx000066400000000000000000000062261301006202600316370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToGenericRSOutputParameters.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbMapProjections.h" #include #include typedef otb::VectorImage ImageType; typedef otb::ImageToGenericRSOutputParameters FilterType; int otbImageToGenericRSOutputParametersNew (int itkNotUsed(argc), char * itkNotUsed(argv)[]) { FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbImageToGenericRSOutputParameters (int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; typedef ImageType::SizeType SizeType; typedef ImageType::SpacingType SpacingType; typedef otb::ImageFileReader ReaderType; // Reader ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->UpdateOutputInformation(); // ForceSize SizeType size; size[0] = 400; size[1] = 399; SpacingType spacing; spacing[0] = 0.000006; spacing[1] = -0.000006; // Filter : Target SRS : WGS84 FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetOutputProjectionRef("4326"); //WGS84 filter->Compute(); // Output file std::ofstream outfile(outfname); outfile<<"Output Parameters for SRID : 4326 (WGS84)"<GetOutputOrigin()<GetOutputSpacing()<GetOutputSize()<SetOutputProjectionRef("32631"); // UTM 31 N filter->Compute(); outfile<<"Output Parameters for SRID : 32631 (UTM 31 N)"<GetOutputOrigin()<GetOutputSpacing()<GetOutputSize()<GetWkt(); filter->SetOutputProjectionRef(lambertRef); filter->Compute(); outfile<<"Output Parameters for SRS : Lambert II Etendu"<GetOutputOrigin()<GetOutputSpacing()<GetOutputSize()< ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImportGeoInformationImageFilter ImportGeoInformationImageFilterType; // Instantiating objects ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ImportGeoInformationImageFilterType::Pointer import = ImportGeoInformationImageFilterType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); ImageType::IndexType index; index.Fill(0); ImageType::RegionType region; region.SetIndex(index); region.SetSize(reader->GetOutput()->GetLargestPossibleRegion().GetSize()); ImageType::Pointer black = ImageType::New(); black->SetRegions(region); black->Allocate(); black->FillBuffer(128); std::cout << "black: " << black->GetLargestPossibleRegion() << std::endl; black->SetOrigin(reader->GetOutput()->GetOrigin()); black->SetSpacing(reader->GetOutput()->GetSpacing()); import->SetInput(black); import->SetSource(reader->GetOutput()); // import->Update(); // std::cout<<"import output: "<GetOutput()<SetFileName(outfname); writer->SetInput(import->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbImportGeoInformationImageFilterNew.cxx000066400000000000000000000023251301006202600321750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImportGeoInformationImageFilter.h" #include "otbImage.h" int otbImportGeoInformationImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImportGeoInformationImageFilter ImportGeoInformationImageFilterType; // Instantiating object ImportGeoInformationImageFilterType::Pointer filter = ImportGeoInformationImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbLeastSquareAffineTransformEstimator.cxx000066400000000000000000000055211301006202600324260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" #include "otbLeastSquareAffineTransformEstimator.h" #include "itkPoint.h" int otbLeastSquareAffineTransformEstimator(int argc, char* argv[]) { if (argc < 8) { std::cerr << "Usage: " << argv[0] << " outfname a1x a1y a1z b1x b1y b1z ... aNx aNy aNz bNx bNy bNz" << std::endl; return EXIT_FAILURE; } if ((argc - 2) % 6 != 0) { std::cerr << "Inconsistent points description." << std::endl; return EXIT_FAILURE; } const char * outfname = argv[1]; typedef itk::Point PointType; typedef otb::LeastSquareAffineTransformEstimator EstimatorType; // instantiation EstimatorType::Pointer estimator = EstimatorType::New(); // nb points unsigned int nbTiePoints = (argc - 2) / 6; std::cout << "Reading " << nbTiePoints << " tie points from command line." << std::endl; for (unsigned int pId = 0; pId < nbTiePoints; ++pId) { PointType p1, p2; // Reading first point p1[0] = atof(argv[2 + pId * 6]); p1[1] = atof(argv[3 + pId * 6]); p1[2] = atof(argv[4 + pId * 6]); // Reading second point p2[0] = atof(argv[5 + pId * 6]); p2[1] = atof(argv[6 + pId * 6]); p2[2] = atof(argv[7 + pId * 6]); std::cout << "Adding tie points " << p1 << " <-> " << p2 << std::endl; // Add it to the estimator estimator->AddTiePoints(p1, p2); } // Trigger computation estimator->Compute(); std::ofstream ofs; ofs.open(outfname); // Set floatfield to format properly ofs.setf(std::ios::fixed, std::ios::floatfield); ofs.precision(10); ofs << "Estimated affine matrix: " << std::endl; ofs << estimator->GetMatrix() << std::endl; ofs << "Estimated affine offset: " << std::endl; ofs << estimator->GetOffset() << std::endl; ofs << "RMS error: " << std::endl; ofs << estimator->GetRMSError() << std::endl; ofs << "Relative residual: " << std::endl; ofs << estimator->GetRelativeResidual() << std::endl; ofs.close(); // Testing the GetTiePointsContainer() method EstimatorType::TiePointsContainerType container = estimator->GetTiePointsContainer(); // Get the output transform */ EstimatorType::AffineTransformPointerType transform = estimator->GetAffineTransform(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbLeastSquareAffineTransformEstimatorNew.cxx000066400000000000000000000020401301006202600330710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbLeastSquareAffineTransformEstimator.h" #include "itkPoint.h" int otbLeastSquareAffineTransformEstimatorNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef itk::Point PointType; typedef otb::LeastSquareAffineTransformEstimator EstimatorType; // instantiation EstimatorType::Pointer estimator = EstimatorType::New(); std::cout << estimator << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbMapProjection.cxx000066400000000000000000000115661301006202600260600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" #include "otbImage.h" #include "otbMapProjections.h" int otbMapProjection(int itkNotUsed(argc), char* argv[]) { const char * outFileName = argv[1]; std::ofstream file; itk::Point point; point[0] = 1.44; point[1] = 43.6050; itk::Point point2; file.open(outFileName); file << std::setprecision(15); /** Test the output of the projection in Wkt format*/ otb::UtmForwardProjection::Pointer lUtmProjection2 = otb::UtmForwardProjection::New(); point2 = lUtmProjection2->TransformPoint(point); file << lUtmProjection2->GetWkt() << std::endl << std::endl; file << "Forward projection: " << std::endl; file << point << " -> "; file << point2; file << std::endl << std::endl; otb::UtmInverseProjection::Pointer lUtmProjection = otb::UtmInverseProjection::New(); file << lUtmProjection->GetWkt() << std::endl << std::endl; file << "Inverse projection: " << std::endl; file << point2 << " -> "; file << lUtmProjection->TransformPoint(point2); file << std::endl << std::endl; otb::Lambert2EtenduForwardProjection::Pointer lLambert2Etendu2 = otb::Lambert2EtenduForwardProjection::New(); point2 = lLambert2Etendu2->TransformPoint(point); file << lLambert2Etendu2->GetWkt() << std::endl << std::endl; file << "Forward projection: " << std::endl; file << point << " -> "; file << point2; file << std::endl << std::endl; otb::Lambert2EtenduInverseProjection::Pointer lLambert2Etendu = otb::Lambert2EtenduInverseProjection::New(); file << lLambert2Etendu->GetWkt() << std::endl << std::endl; file << "Inverse projection: " << std::endl; file << point2 << " -> "; file << lLambert2Etendu->TransformPoint(point2); file << std::endl << std::endl; otb::Lambert93ForwardProjection::Pointer lLambert93_2 = otb::Lambert93ForwardProjection::New(); point2 = lLambert93_2->TransformPoint(point); file << lLambert93_2->GetWkt() << std::endl << std::endl; file << "Forward projection: " << std::endl; file << point << " -> "; file << point2; file << std::endl << std::endl; otb::Lambert93InverseProjection::Pointer lLambert93 = otb::Lambert93InverseProjection::New(); file << lLambert93->GetWkt() << std::endl << std::endl; file << "Inverse projection: " << std::endl; file << point2 << " -> "; file << lLambert93->TransformPoint(point2); file << std::endl << std::endl; otb::MercatorForwardProjection::Pointer lMercatorProjection2 = otb::MercatorForwardProjection::New(); point2 = lMercatorProjection2->TransformPoint(point); file << lMercatorProjection2->GetWkt() << std::endl << std::endl; file << "Forward projection: " << std::endl; file << point << " -> "; file << point2; file << std::endl << std::endl; otb::MercatorInverseProjection::Pointer lMercatorProjection = otb::MercatorInverseProjection::New(); file << lMercatorProjection->GetWkt() << std::endl << std::endl; file << "Inverse projection: " << std::endl; file << point2 << " -> "; file << lMercatorProjection->TransformPoint(point2); file << std::endl << std::endl; // Moving to GenericMapProjection, change the access lUtmProjection->SetParameter("MetersPerPixelX", "1"); lUtmProjection->SetParameter("MetersPerPixelY", "1"); file << "\n\n *** Test accessors *** \n\n"; file << std::setprecision(15); file << "Origin: \t" << lUtmProjection->GetParameter("Origin") << std::endl; file << "False northing: \t" << lUtmProjection->GetParameter("FalseNorthing") << std::endl; file << "False easting: \t" << lUtmProjection->GetParameter("FalseEasting") << std::endl; file << "Parallel 1: \t" << lUtmProjection->GetParameter("StandardParallel1") << std::endl; file << "Parallel 2: \t" << lUtmProjection->GetParameter("StandardParallel2") << std::endl; // file << "Name: \t" << lUtmProjection->GetProjectionName() << std::endl; // file << "Geo: \t" << lUtmProjection->IsGeographic() << std::endl; file << "A: \t" << lUtmProjection->GetParameter("A") << std::endl; file << "B: \t" << lUtmProjection->GetParameter("B") << std::endl; file << "F: \t" << lUtmProjection->GetParameter("F") << std::endl; file << "m per pix: \t" << lUtmProjection->GetParameter("MetersPerPixel") << std::endl; file << "degree per pix: \t" << lUtmProjection->GetParameter("DecimalDegreesPerPixel") << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbMapProjectionsNew.cxx000066400000000000000000000302511301006202600267050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itkMacro.h" #include "otbImage.h" #include "otbMapProjections.h" int otbMapProjectionsNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { otb::AlbersInverseProjection::Pointer lAlbersProjection = otb::AlbersInverseProjection::New(); otb::AlbersForwardProjection::Pointer lAlbersProjection2 = otb::AlbersForwardProjection::New(); otb::AzimEquDistInverseProjection::Pointer lAzimEquDistProjection = otb::AzimEquDistInverseProjection::New(); otb::AzimEquDistForwardProjection::Pointer lAzimEquDistProjection2 = otb::AzimEquDistForwardProjection::New(); //Comment for OTB 2.2.0 because OSSIM error code -> generate Exception Fault on VS 7.1 only on Debug mode. // otb::BngInverseProjection::Pointer lBngProjection = otb::BngInverseProjection::New(); // otb::BngForwardProjection::Pointer lBngProjection2 = otb::BngForwardProjection::New(); otb::BonneInverseProjection::Pointer lBonneProjection = otb::BonneInverseProjection::New(); otb::BonneForwardProjection::Pointer lBonneProjection2 = otb::BonneForwardProjection::New(); otb::CadrgInverseProjection::Pointer lCadrgProjection = otb::CadrgInverseProjection::New(); otb::CadrgForwardProjection::Pointer lCadrgProjection2 = otb::CadrgForwardProjection::New(); otb::CassiniInverseProjection::Pointer lCassiniProjection = otb::CassiniInverseProjection::New(); otb::CassiniForwardProjection::Pointer lCassiniProjection2 = otb::CassiniForwardProjection::New(); otb::CylEquAreaInverseProjection::Pointer lCylEquAreaProjection = otb::CylEquAreaInverseProjection::New(); otb::CylEquAreaForwardProjection::Pointer lCylEquAreaProjection2 = otb::CylEquAreaForwardProjection::New(); otb::Eckert4InverseProjection::Pointer lEckert4Projection = otb::Eckert4InverseProjection::New(); otb::Eckert4ForwardProjection::Pointer lEckert4Projection2 = otb::Eckert4ForwardProjection::New(); otb::Eckert6InverseProjection::Pointer lEckert6Projection = otb::Eckert6InverseProjection::New(); otb::Eckert6ForwardProjection::Pointer lEckert6Projection2 = otb::Eckert6ForwardProjection::New(); otb::GnomonicInverseProjection::Pointer lGnomonicProjection = otb::GnomonicInverseProjection::New(); otb::GnomonicForwardProjection::Pointer lGnomonicProjection2 = otb::GnomonicForwardProjection::New(); otb::LambertConformalConicInverseProjection::Pointer lLambertConformalConicProjection = otb::LambertConformalConicInverseProjection::New(); otb::LambertConformalConicForwardProjection::Pointer lLambertConformalConicProjection2 = otb::LambertConformalConicForwardProjection::New(); otb::LlxyInverseProjection::Pointer lLlxyProjection = otb::LlxyInverseProjection::New(); otb::LlxyForwardProjection::Pointer lLlxyProjection2 = otb::LlxyForwardProjection::New(); otb::EquDistCylInverseProjection::Pointer lEquDistCylProjection = otb::EquDistCylInverseProjection::New(); otb::EquDistCylForwardProjection::Pointer lEquDistCylProjection2 = otb::EquDistCylForwardProjection::New(); otb::MercatorInverseProjection::Pointer lMercatorProjection = otb::MercatorInverseProjection::New(); otb::MercatorForwardProjection::Pointer lMercatorProjection2 = otb::MercatorForwardProjection::New(); otb::MillerInverseProjection::Pointer lMillerProjection = otb::MillerInverseProjection::New(); otb::MillerForwardProjection::Pointer lMillerProjection2 = otb::MillerForwardProjection::New(); otb::MollweidInverseProjection::Pointer lMollweidProjection = otb::MollweidInverseProjection::New(); otb::MollweidForwardProjection::Pointer lMollweidProjection2 = otb::MollweidForwardProjection::New(); otb::NewZealandMapGridInverseProjection::Pointer lNewZealandMapGridProjection = otb::NewZealandMapGridInverseProjection::New(); otb::NewZealandMapGridForwardProjection::Pointer lNewZealandMapGridProjection2 = otb::NewZealandMapGridForwardProjection::New(); otb::ObliqueMercatorInverseProjection::Pointer lObliqueMercatorProjection = otb::ObliqueMercatorInverseProjection::New(); otb::ObliqueMercatorForwardProjection::Pointer lObliqueMercatorProjection2 = otb::ObliqueMercatorForwardProjection::New(); otb::OrthoGraphicInverseProjection::Pointer lOrthoGraphicProjection = otb::OrthoGraphicInverseProjection::New(); otb::OrthoGraphicForwardProjection::Pointer lOrthoGraphicProjection2 = otb::OrthoGraphicForwardProjection::New(); otb::PolarStereoInverseProjection::Pointer lPolarStereoProjection = otb::PolarStereoInverseProjection::New(); otb::PolarStereoForwardProjection::Pointer lPolarStereoProjection2 = otb::PolarStereoForwardProjection::New(); otb::PolyconicInverseProjection::Pointer lPolyconicProjection = otb::PolyconicInverseProjection::New(); otb::PolyconicForwardProjection::Pointer lPolyconicProjection2 = otb::PolyconicForwardProjection::New(); otb::SinusoidalInverseProjection::Pointer lSinusoidalProjection = otb::SinusoidalInverseProjection::New(); otb::SinusoidalForwardProjection::Pointer lSinusoidalProjection2 = otb::SinusoidalForwardProjection::New(); otb::SpaceObliqueMercatorInverseProjection::Pointer lSpaceObliqueMercatorProjection = otb::SpaceObliqueMercatorInverseProjection::New(); otb::SpaceObliqueMercatorForwardProjection::Pointer lSpaceObliqueMercatorProjection2 = otb::SpaceObliqueMercatorForwardProjection::New(); otb::StereographicInverseProjection::Pointer lStereographicProjection = otb::StereographicInverseProjection::New(); otb::StereographicForwardProjection::Pointer lStereographicProjection2 = otb::StereographicForwardProjection::New(); otb::TransCylEquAreaInverseProjection::Pointer lTransCylEquAreaProjection = otb::TransCylEquAreaInverseProjection::New(); otb::TransCylEquAreaForwardProjection::Pointer lTransCylEquAreaProjection2 = otb::TransCylEquAreaForwardProjection::New(); otb::TransMercatorInverseProjection::Pointer lTransMercatorProjection = otb::TransMercatorInverseProjection::New(); otb::TransMercatorForwardProjection::Pointer lTransMercatorProjection2 = otb::TransMercatorForwardProjection::New(); otb::UpsInverseProjection::Pointer lUpsProjection = otb::UpsInverseProjection::New(); otb::UpsForwardProjection::Pointer lUpsProjection2 = otb::UpsForwardProjection::New(); otb::UtmInverseProjection::Pointer lUtmProjection = otb::UtmInverseProjection::New(); otb::UtmForwardProjection::Pointer lUtmProjection2 = otb::UtmForwardProjection::New(); otb::VanDerGrintenInverseProjection::Pointer lVanDerGrintenProjection = otb::VanDerGrintenInverseProjection::New(); otb::VanDerGrintenForwardProjection::Pointer lVanDerGrintenProjection2 = otb::VanDerGrintenForwardProjection::New(); otb::Lambert2EtenduInverseProjection::Pointer lLambert2Etendu = otb::Lambert2EtenduInverseProjection::New(); otb::Lambert2EtenduForwardProjection::Pointer lLambert2Etendu2 = otb::Lambert2EtenduForwardProjection::New(); otb::Lambert93InverseProjection::Pointer lLambert93 = otb::Lambert93InverseProjection::New(); otb::Lambert93ForwardProjection::Pointer lLambert93_2 = otb::Lambert93ForwardProjection::New(); otb::SVY21InverseProjection::Pointer lSVY21 = otb::SVY21InverseProjection::New(); otb::SVY21ForwardProjection::Pointer lSVY21_2 = otb::SVY21ForwardProjection::New(); return EXIT_SUCCESS; } //Test the specific accessors for some map projection int otbMapProjectionsTest(int itkNotUsed(argc), char * argv[]) { char * filename = argv[1]; std::ofstream file; file.open(filename); otb::Eckert4InverseProjection::Pointer lEckert4Projection = otb::Eckert4InverseProjection::New(); file << lEckert4Projection->GetFalseEasting() << std::endl; file << lEckert4Projection->GetFalseNorthing() << std::endl; lEckert4Projection->SetFalseEasting(500000); lEckert4Projection->SetFalseNorthing(500000); file << lEckert4Projection->GetFalseEasting() << std::endl; file << lEckert4Projection->GetFalseNorthing() << std::endl; lEckert4Projection->SetParameters(200000, 300000); file << lEckert4Projection->GetFalseEasting() << std::endl; file << lEckert4Projection->GetFalseNorthing() << std::endl; otb::Eckert4ForwardProjection::Pointer lEckert4Projection2 = otb::Eckert4ForwardProjection::New(); file << lEckert4Projection2->GetFalseEasting() << std::endl; file << lEckert4Projection2->GetFalseNorthing() << std::endl; lEckert4Projection2->SetFalseEasting(500000); lEckert4Projection2->SetFalseNorthing(500000); file << lEckert4Projection2->GetFalseEasting() << std::endl; file << lEckert4Projection2->GetFalseNorthing() << std::endl; lEckert4Projection2->SetParameters(200000, 300000); file << lEckert4Projection2->GetFalseEasting() << std::endl; file << lEckert4Projection2->GetFalseNorthing() << std::endl; otb::MollweidInverseProjection::Pointer lMollweidProjection = otb::MollweidInverseProjection::New(); file << lMollweidProjection->GetFalseEasting() << std::endl; file << lMollweidProjection->GetFalseNorthing() << std::endl; lMollweidProjection->SetFalseEasting(500000); lMollweidProjection->SetFalseNorthing(500000); file << lMollweidProjection->GetFalseEasting() << std::endl; file << lMollweidProjection->GetFalseNorthing() << std::endl; lMollweidProjection->SetParameters(200000, 300000); file << lMollweidProjection->GetFalseEasting() << std::endl; file << lMollweidProjection->GetFalseNorthing() << std::endl; otb::MollweidForwardProjection::Pointer lMollweidProjection2 = otb::MollweidForwardProjection::New(); file << lMollweidProjection2->GetFalseEasting() << std::endl; file << lMollweidProjection2->GetFalseNorthing() << std::endl; lMollweidProjection2->SetFalseEasting(500000); lMollweidProjection2->SetFalseNorthing(500000); file << lMollweidProjection2->GetFalseEasting() << std::endl; file << lMollweidProjection2->GetFalseNorthing() << std::endl; lMollweidProjection2->SetParameters(200000, 300000); file << lMollweidProjection2->GetFalseEasting() << std::endl; file << lMollweidProjection2->GetFalseNorthing() << std::endl; otb::SinusoidalInverseProjection::Pointer lSinusoidalProjection = otb::SinusoidalInverseProjection::New(); file << lSinusoidalProjection->GetFalseEasting() << std::endl; file << lSinusoidalProjection->GetFalseNorthing() << std::endl; lSinusoidalProjection->SetFalseEasting(500000); lSinusoidalProjection->SetFalseNorthing(500000); file << lSinusoidalProjection->GetFalseEasting() << std::endl; file << lSinusoidalProjection->GetFalseNorthing() << std::endl; lSinusoidalProjection->SetParameters(200000, 300000); file << lSinusoidalProjection->GetFalseEasting() << std::endl; file << lSinusoidalProjection->GetFalseNorthing() << std::endl; otb::SinusoidalForwardProjection::Pointer lSinusoidalProjection2 = otb::SinusoidalForwardProjection::New(); file << lSinusoidalProjection2->GetFalseEasting() << std::endl; file << lSinusoidalProjection2->GetFalseNorthing() << std::endl; lSinusoidalProjection2->SetFalseEasting(500000); lSinusoidalProjection2->SetFalseNorthing(500000); file << lSinusoidalProjection2->GetFalseEasting() << std::endl; file << lSinusoidalProjection2->GetFalseNorthing() << std::endl; lSinusoidalProjection2->SetParameters(200000, 300000); file << lSinusoidalProjection2->GetFalseEasting() << std::endl; file << lSinusoidalProjection2->GetFalseNorthing() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbOrthoRectificationFilter.cxx000066400000000000000000000124061301006202600302450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // iostream is used for general output #include #include #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMapProjections.h" #include "itkUnaryFunctorImageFilter.h" //#include "itkComplexToModulusImageFilter.h" #include "otbDEMHandler.h" #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbOrthoRectificationFilter.h" #include "otbMapProjections.h" #include "otbComplexToIntensityImageFilter.h" #include "otbPerBandVectorImageFilter.h" int otbOrthoRectificationFilter(int argc, char* argv[]) { if (argc != 15) { std::cout << argv[0] << " " " " " " << std::endl; return EXIT_FAILURE; } typedef std::complex ComplexPixelType; typedef otb::VectorImage ComplexVectorImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ComplexReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::UtmInverseProjection UtmMapProjectionType; // Handling of complex images typedef otb::Image ComplexImageType; typedef otb::Image ImageType; typedef otb::ComplexToIntensityImageFilter IntensityFilterType; typedef otb::PerBandVectorImageFilter PerBandIntensityFilterType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; //Allocate pointer ReaderType::Pointer reader = ReaderType::New(); ComplexReaderType::Pointer cReader = ComplexReaderType::New(); WriterType::Pointer writer = WriterType::New(); PerBandIntensityFilterType::Pointer intensityFilter = PerBandIntensityFilterType::New(); OrthoRectifFilterType::Pointer orthoRectifFilter = OrthoRectifFilterType::New(); UtmMapProjectionType::Pointer utmMapProjection = UtmMapProjectionType::New(); writer->SetFileName(argv[2]); bool isComplex = atoi(argv[14]); if(isComplex) { cReader->SetFileName(argv[1]); cReader->GenerateOutputInformation(); intensityFilter->SetInput(cReader->GetOutput()); VectorImageType::PixelType no_data(cReader->GetOutput()->GetNumberOfComponentsPerPixel()); no_data.Fill(0); orthoRectifFilter->SetEdgePaddingValue(no_data); orthoRectifFilter->SetInput(intensityFilter->GetOutput()); } else { reader->SetFileName(argv[1]); reader->GenerateOutputInformation(); VectorImageType::PixelType no_data(reader->GetOutput()->GetNumberOfComponentsPerPixel()); no_data.Fill(0); orthoRectifFilter->SetEdgePaddingValue(no_data); orthoRectifFilter->SetInput(reader->GetOutput()); } VectorImageType::IndexType start; start[0] = 0; start[1] = 0; orthoRectifFilter->SetOutputStartIndex(start); VectorImageType::SizeType size; size[0] = atoi(argv[5]); // X size size[1] = atoi(argv[6]); //Y size orthoRectifFilter->SetOutputSize(size); VectorImageType::SpacingType spacing; spacing[0] = atof(argv[7]); spacing[1] = atof(argv[8]); orthoRectifFilter->SetOutputSpacing(spacing); VectorImageType::PointType origin; origin[0] = strtod(argv[3], ITK_NULLPTR); //Origin easting origin[1] = strtod(argv[4], ITK_NULLPTR); //Origin northing orthoRectifFilter->SetOutputOrigin(origin); utmMapProjection->SetZone(atoi(argv[9])); utmMapProjection->SetHemisphere(argv[10][0]); orthoRectifFilter->SetMapProjection(utmMapProjection); // Displacement Field spacing VectorImageType::SpacingType gridSpacing; gridSpacing[0] = atof(argv[11]); gridSpacing[1] = -atof(argv[11]); orthoRectifFilter->SetDisplacementFieldSpacing(gridSpacing); // manage demHandler if (atoi(argv[12])==1) //mode = no DEM { otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(135.8); } else if ( (atoi(argv[12])==2) || (atoi(argv[12])==3) ) //mode = DEM SRTM || DEM GTIFF { otb::DEMHandler::Instance()->OpenDEMDirectory(argv[13]); } writer->SetInput(orthoRectifFilter->GetOutput()); writer->SetNumberOfDivisionsTiledStreaming(4); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbOrthoRectificationFilterNew.cxx000066400000000000000000000022501301006202600307130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbMapProjections.h" #include "otbOrthoRectificationFilter.h" int otbOrthoRectificationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Image ImageType; typedef otb::UtmInverseProjection UtmMapProjectionType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; OrthoRectifFilterType::Pointer filter = OrthoRectifFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbPhysicalToRPCSensorModelImageFilter.cxx000066400000000000000000000037701301006202600322140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPhysicalToRPCSensorModelImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbPhysicalToRPCSensorModelImageFilter(int argc, char* argv[]) { // Images definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::PhysicalToRPCSensorModelImageFilter PhysicalToSensorModelType; // Object instantiation PhysicalToSensorModelType::Pointer estimator = PhysicalToSensorModelType::New(); if(argc == 4) { const char * infname = argv[1]; unsigned int gridSize = atoi(argv[2]); const char * outfname = argv[3]; // Reader typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); // Set the fileName reader->SetFileName(infname); reader->UpdateOutputInformation(); // wire the filter estimator->SetInput(reader->GetOutput()); estimator->SetGridSize(gridSize); // Write the resampled image typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer= WriterType::New(); writer->SetAutomaticTiledStreaming(); writer->SetFileName(outfname); writer->SetInput(estimator->GetOutput()); writer->Update(); } else { std::cout <<"Unit Test" << std::endl; } return 0; } OTB-release-5.8/Modules/Filtering/Projection/test/otbProjectionBaseNew.cxx000066400000000000000000000016771301006202600266710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbMapProjections.h" int otbProjectionBaseNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { otb::AlbersInverseProjection::Pointer lAlbersProjection = otb::AlbersInverseProjection::New(); otb::AzimEquDistForwardProjection::Pointer lAzimEquDistProjection = otb::AzimEquDistForwardProjection::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbProjectionTestDriver.cxx000066400000000000000000000056511301006202600274340ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbSensorModel); REGISTER_TEST(otbVectorDataProjectionFilterFromGeoToMap); REGISTER_TEST(otbOrthoRectificationFilter); REGISTER_TEST(otbGCPsToRPCSensorModelImageFilterNew); REGISTER_TEST(otbMapProjection); REGISTER_TEST(otbGenericRSResampleImageFilterNew); REGISTER_TEST(otbGenericRSResampleImageFilter); REGISTER_TEST(otbGenericRSResampleImageFilterFromMap); REGISTER_TEST(otbGeometriesProjectionFilter); REGISTER_TEST(otbGenericRSTransformGenericTest); REGISTER_TEST(otbLeastSquareAffineTransformEstimatorNew); REGISTER_TEST(otbVectorDataTransformFilterNew); REGISTER_TEST(otbVectorDataTransformFilter); REGISTER_TEST(otbRationalTransformToDisplacementFieldSourceTest); REGISTER_TEST(otbImportGeoInformationImageFilterNew); REGISTER_TEST(otbVectorDataProjectionFilterFromMapToSensor); REGISTER_TEST(otbCompositeTransformNew); REGISTER_TEST(otbRationalTransformNew); REGISTER_TEST(otbRationalTransform); REGISTER_TEST(otbGeometriesProjectionFilterFromMapToSensor); REGISTER_TEST(otbImageToEnvelopeVectorDataFilterNew); REGISTER_TEST(otbImageToEnvelopeVectorDataFilter); REGISTER_TEST(otbMapProjectionsNew); REGISTER_TEST(otbMapProjectionsTest); REGISTER_TEST(otbOrthoRectificationFilterNew); REGISTER_TEST(otbImageToGenericRSOutputParametersNew); REGISTER_TEST(otbImageToGenericRSOutputParameters); REGISTER_TEST(otbGeometriesProjectionFilterFromMapToGeo); REGISTER_TEST(otbROIdataConversion); REGISTER_TEST(otbProjectionBaseNew); REGISTER_TEST(otbVectorDataProjectionFilterFromMapToGeo); REGISTER_TEST(otbPhysicalToRPCSensorModelImageFilter); REGISTER_TEST(otbGeometriesProjectionFilterFromGeoToMap); REGISTER_TEST(otbVectorDataProjectionFilterFromMapToImage); REGISTER_TEST(otbGenericRSTransformFromImage); REGISTER_TEST(otbGenericRSTransformImageAndMNTToWGS84ConversionChecking); REGISTER_TEST(otbCompositeTransform); REGISTER_TEST(otbLeastSquareAffineTransformEstimator); REGISTER_TEST(otbSpectralAngleDataNodeFeatureFunctionNew); REGISTER_TEST(otbSpectralAngleDataNodeFeatureFunction); REGISTER_TEST(otbROIdataConversionNew); REGISTER_TEST(otbGCPsToRPCSensorModelImageFilterCheckRpcModel); REGISTER_TEST(otbGeographicalDistanceNew); REGISTER_TEST(otbGeographicalDistance); REGISTER_TEST(otbTileImageFilterRSTransformTest); REGISTER_TEST(otbGCPsToRPCSensorModelImageFilterAndOrtho); REGISTER_TEST(otbVectorDataIntoImageProjectionFilterCompareImplTest); REGISTER_TEST(otbVectorDataExtractROIandProjection); REGISTER_TEST(otbGCPsToRPCSensorModelImageFilterWithoutDEM); REGISTER_TEST(otbGeometriesProjectionFilterFromMapToImage); REGISTER_TEST(otbGeometriesProjectionFilterFromMapToEPSG); REGISTER_TEST(otbVectorDataProjectionFilter); REGISTER_TEST(otbUtmMapProjection); REGISTER_TEST(otbVectorDataProjectionFilterNew); REGISTER_TEST(otbTileMapTransform); REGISTER_TEST(otbImportGeoInformationImageFilter); } OTB-release-5.8/Modules/Filtering/Projection/test/otbROIdataConversion.cxx000066400000000000000000000041431301006202600266300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbROIdataConversion.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkImageRegionIterator.h" #include int otbROIdataConversion(int itkNotUsed(argc), char* argv[]) { typedef double PixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image ROIImageType; typedef otb::ROIdataConversion ConverterType; typedef ConverterType::OutputImageType OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ROIReaderType; ConverterType::Pointer converter = ConverterType::New(); ReaderType::Pointer readerIm = ReaderType::New(); ReaderType::Pointer readerTr = ROIReaderType::New(); readerIm->SetFileName(argv[1]); readerTr->SetFileName(argv[2]); readerIm->Update(); readerTr->Update(); converter->SetInput(readerIm->GetOutput()); converter->SetROIImage(readerTr->GetOutput()); converter->Update(); std::ofstream file; file.open(argv[3]); itk::ImageRegionIterator outputIter(converter->GetOutput(), converter->GetOutput()->GetLargestPossibleRegion()); outputIter.GoToBegin(); while (!outputIter.IsAtEnd()) { file << outputIter.Get() << " "; ++outputIter; } file << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbROIdataConversionNew.cxx000066400000000000000000000021661301006202600273050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbROIdataConversion.h" #include "otbVectorImage.h" int otbROIdataConversionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image ROIImageType; typedef otb::ROIdataConversion ConverterType; ConverterType::Pointer converter = ConverterType::New(); std::cout << converter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbRationalTransform.cxx000066400000000000000000000047561301006202600267560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRationalTransform.h" #include int otbRationalTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::RationalTransform<> RationalTransformType; // Instantiation RationalTransformType::Pointer rt = RationalTransformType::New(); return EXIT_SUCCESS; } int otbRationalTransform(int argc, char* argv[]) { typedef otb::RationalTransform<> RationalTransformType; // Instantiation RationalTransformType::Pointer rt = RationalTransformType::New(); rt->SetNumeratorDegree(4); rt->SetDenominatorDegree(4); RationalTransformType::ParametersType params(rt->GetNumberOfParameters()); params.Fill(1.); // Rational is // fx(x, y) = (1+2*x+3*x^2+4*x^3+5*x^4)/(6+7*x+8*x^2+9*x^3+10*x^4) // fy(x, y) = (11+12*y+13*y^2+14*y^3+15*y^4)/(16+17*y+18*y^2+19*y^3+20*y^4) params[0]=1; params[1]=2; params[2]=3; params[3]=4; params[4]=5; params[5]=6; params[6]=7; params[7]=8; params[8]=9; params[9]=10; params[10]=11; params[11]=12; params[12]=13; params[13]=14; params[14]=15; params[15]=16; params[16]=17; params[17]=18; params[18]=19; params[19]=20; rt->SetParameters(params); RationalTransformType::InputPointType inputPoint; RationalTransformType::OutputPointType outputPoint; std::ofstream ofs; ofs.open(argv[1]); // Set floatfield to format writing properly ofs.setf(std::ios::fixed, std::ios::floatfield); ofs.precision(10); unsigned int idx = 2; ofs<<"Rational function is: "<TransformPoint(inputPoint); ofs< "< #include "itkVector.h" #include "otbImage.h" #include "otbRationalTransform.h" #include "itkTransformToDisplacementFieldSource.h" #include "otbImageFileWriter.h" int otbRationalTransformToDisplacementFieldSourceTest(int argc, char* argv[]) { /** Check command line arguments. */ if( argc < 2 ) { std::cerr << "You must supply output filename" << std::endl; return EXIT_FAILURE; } std::string fileName = argv[ 1 ]; /** Typedefs. */ const unsigned int Dimension = 2; typedef float ScalarPixelType; typedef double CoordRepresentationType; typedef itk::Vector VectorPixelType; typedef otb::Image DisplacementFieldImageType; typedef otb::RationalTransform TransformType; typedef TransformType::ParametersType ParametersType; typedef itk::TransformToDisplacementFieldSource< DisplacementFieldImageType, CoordRepresentationType > DisplacementFieldGeneratorType; typedef DisplacementFieldGeneratorType::SizeType SizeType; typedef DisplacementFieldGeneratorType::SpacingType SpacingType; typedef DisplacementFieldGeneratorType::OriginType OriginType; typedef DisplacementFieldGeneratorType::IndexType IndexType; typedef otb::ImageFileWriter WriterType; /** Create output information. */ SizeType size; size.Fill( 20 ); IndexType index; index.Fill( 0 ); SpacingType spacing; spacing.Fill( 0.7 ); OriginType origin; origin.Fill( -10.0 ); /** Create transform. */ TransformType::Pointer transform = TransformType::New(); /** Create and set parameters. */ transform->SetNumeratorDegree(4); transform->SetDenominatorDegree(4); ParametersType parameters( transform->GetNumberOfParameters() ); // Rational is // fx(x, y) = (1+2*x+3*x^2+4*x^3+5*x^4)/(6+7*x+8*x^2+9*x^3+10*x^4) // fy(x, y) = (11+12*y+13*y^2+14*y^3+15*y^4)/(16+17*y+18*y^2+19*y^3+20*y^4) parameters[0]=1; parameters[1]=2; parameters[2]=3; parameters[3]=4; parameters[4]=5; parameters[5]=6; parameters[6]=7; parameters[7]=8; parameters[8]=9; parameters[9]=10; parameters[10]=11; parameters[11]=12; parameters[12]=13; parameters[13]=14; parameters[14]=15; parameters[15]=16; parameters[16]=17; parameters[17]=18; parameters[18]=19; parameters[19]=20; transform->SetParameters( parameters ); /** Create an setup deformation field generator. */ DisplacementFieldGeneratorType::Pointer defGenerator = DisplacementFieldGeneratorType::New(); std::cout << "Name of Class: " << defGenerator->GetNameOfClass() << std::endl; defGenerator->SetOutputSize( size ); defGenerator->SetOutputSpacing( spacing ); defGenerator->SetOutputOrigin( origin ); defGenerator->SetOutputIndex( index ); // // for coverage, exercise access methods spacing = defGenerator->GetOutputSpacing(); origin = defGenerator->GetOutputOrigin(); DisplacementFieldGeneratorType::DirectionType direction = defGenerator->GetOutputDirection(); std::cout << "Spacing " << spacing << " Origin " << origin << std::endl << "Direction " << direction << std::endl; //defGenerator->SetOutputDirection( direction ); defGenerator->SetTransform( transform ); std::cout << "Transform: " << defGenerator->GetTransform() << std::endl; DisplacementFieldGeneratorType::OutputImageRegionType outputRegion = defGenerator->GetOutputRegion(); defGenerator->SetOutputRegion(outputRegion); /** Write deformation field to disk. */ WriterType::Pointer writer = WriterType::New(); writer->SetInput( defGenerator->GetOutput() ); writer->SetFileName( fileName.c_str() ); try { writer->Update(); } catch ( itk::ExceptionObject & e ) { std::cerr << "Exception detected while generating deformation field" << argv[1]; std::cerr << " : " << e.GetDescription(); return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbSensorModel.cxx000066400000000000000000000417471301006202600255440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbForwardSensorModel.h" #include "otbInverseSensorModel.h" #include "otbDEMHandler.h" #include #include "itkEuclideanDistanceMetric.h" #include "otbGeographicalDistance.h" #include "otbGenericRSTransform.h" #include "ossim/projection/ossimProjection.h" #include "ossim/projection/ossimSensorModelFactory.h" #include "ossim/ossimPluginProjectionFactory.h" typedef std::list< itk::Point > pointsContainerType; typedef std::list< itk::Point > geo3dPointsContainerType; typedef otb::VectorImage ImageType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::GeographicalDistance GeographicalDistanceType; int produceGCP(char * outputgcpfilename, const otb::ImageKeywordlist& kwlist, bool useForwardSensorModel=true, double z=16.19688987731934) { itk::Point imagePoint; itk::Point geoPoint; // otbForwardSensorModel typedef otb::ForwardSensorModel ForwardSensorModelType; ForwardSensorModelType::Pointer forwardSensorModel = ForwardSensorModelType::New(); forwardSensorModel->SetImageGeometry(kwlist); if( forwardSensorModel->IsValidSensorModel() == false ) { std::cout<<"Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!"<SetDefaultHeightAboveEllipsoid(z); // ossim classes ossimKeywordlist ossimKwlist; kwlist.convertToOSSIMKeywordlist(ossimKwlist); ossimProjection* ossimSensorModel = ossimSensorModelFactory::instance()->createProjection(ossimKwlist); if (ossimSensorModel == ITK_NULLPTR) { ossimSensorModel = ossimplugins::ossimPluginProjectionFactory::instance()->createProjection(ossimKwlist); } if (ossimSensorModel == ITK_NULLPTR) // Model validity { std::cerr << "Invalid sensor model (ossimSensorModel is NULL)" << std::endl; return EXIT_FAILURE; } std::ofstream file(outputgcpfilename, std::ios::out | std::ios::trunc); if (file) { for(double x=10.0; x<300.0; x+=50.) for(double y=10.0; y<300.0; y+=50.) { imagePoint[0]=x; imagePoint[1]=y; if (useForwardSensorModel) // otbForwardSensorModel { geoPoint = forwardSensorModel->TransformPoint(imagePoint); } else // ossim classes { ossimDpt ossimPoint(otb::internal::ConvertToOSSIMFrame(imagePoint[0]), //x otb::internal::ConvertToOSSIMFrame(imagePoint[1])); //y ossimGpt ossimGPoint; ossimSensorModel->lineSampleHeightToWorld(ossimPoint,z, ossimGPoint); geoPoint[0] = ossimGPoint.lon; geoPoint[1] = ossimGPoint.lat; } file << std::setprecision(16) << x << " " << y << " " << geoPoint[0] << " " << geoPoint[1] << " " << z << std::endl; } } else { std::cerr << "Couldn't open " << outputgcpfilename << std::endl; return EXIT_FAILURE; } file.close(); return EXIT_SUCCESS; } bool provideGCP(char * gcpfilename, pointsContainerType& imgPt, geo3dPointsContainerType& geo3dPt) { itk::Point imagePoint; itk::Point geo3dPoint; std::ifstream file(gcpfilename,std::ios::in); if (file) { std::string line; while(getline(file,line)) { if (line.find_first_of("#") != 0) { std::istringstream iss(line); iss >> imagePoint[0] >> imagePoint[1] >> geo3dPoint[0] >> geo3dPoint[1] >> geo3dPoint[2]; imgPt.push_back(imagePoint); geo3dPt.push_back(geo3dPoint); } } file.close(); } else return false; return true; } int otbSensorModel(int argc, char* argv[]) { if (argc != 10) { std::cout << argv[0] << " " <<" " << std::endl; return EXIT_FAILURE; } char * geomfilename = argv[1]; char * gcpfilename = argv[2]; char * outFilename = argv[3]; std::istringstream iss(argv[4]); double imgTol = atof(argv[5]); double geoTol = atof(argv[6]); int writeBaseline = atoi(argv[7]); int modeVerbose = atoi(argv[8]); bool checkNeededKw = atoi(argv[9]); // ------------------- // Some instantiations // ------------------- otb::ImageKeywordlist kwlist = otb::ReadGeometryFromGEOMFile(geomfilename); if (!(kwlist.GetSize() > 0)) { std::cerr<<"ImageKeywordlist is empty."< ForwardSensorModelType; ForwardSensorModelType::Pointer forwardSensorModel = ForwardSensorModelType::New(); if( !forwardSensorModel ) { std::cerr<<"Invalid sensor model (ForwardSensorModelType::Pointer is NULL)"<SetImageGeometry(kwlist); if( forwardSensorModel->IsValidSensorModel() == false ) { std::cerr<<"Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!"< InverseSensorModelType; InverseSensorModelType::Pointer inverseSensorModel = InverseSensorModelType::New(); if( !inverseSensorModel ) { std::cerr<<"Invalid sensor model (InverseSensorModelType::Pointer is NULL)"<SetImageGeometry(kwlist); if( inverseSensorModel->IsValidSensorModel() == false ) { std::cerr<<"Invalid Model pointer m_Model == NULL!\n The ossim keywordlist is invalid!"< GRSTransformType; // Instantiate Image->WGS transform GRSTransformType::Pointer img2wgs = GRSTransformType::New(); if( !img2wgs ) { std::cerr<<"Invalid sensor model (GRSTransformType::Pointer is NULL)"<SetInputProjectionRef(""); img2wgs->SetOutputProjectionRef(wgsRef); img2wgs->SetInputKeywordList(kwlist); img2wgs->InstantiateTransform(); // Instantiate WGS->Image transform GRSTransformType::Pointer wgs2img = GRSTransformType::New(); if( !wgs2img ) { std::cerr<<"Invalid sensor model (GRSTransformType::Pointer is NULL)"<SetInputProjectionRef(""); wgs2img->SetOutputProjectionRef(wgsRef); wgs2img->SetOutputKeywordList(kwlist); wgs2img->InstantiateTransform(); // ossim classes ossimKeywordlist ossimKwlist; kwlist.convertToOSSIMKeywordlist(ossimKwlist); ossimProjection* ossimSensorModel = ossimSensorModelFactory::instance()->createProjection(ossimKwlist); if (ossimSensorModel == ITK_NULLPTR) { ossimSensorModel = ossimplugins::ossimPluginProjectionFactory::instance()->createProjection(ossimKwlist); } if (ossimSensorModel == ITK_NULLPTR) // Model validity { std::cerr << "Invalid sensor model (ossimSensorModel is NULL)" << std::endl; return EXIT_FAILURE; } itk::Point imagePoint; itk::Point geoPoint,geoPointGCP; itk::Point geo3dPoint; itk::Point geoPointGRS; itk::Point geoPointOSSIM; itk::Point reversedImagePoint; itk::Point reversedImagePointGRS; pointsContainerType pointsContainer; geo3dPointsContainerType geo3dPointsContainer; bool okStatus = provideGCP(gcpfilename,pointsContainer,geo3dPointsContainer); if (!okStatus) { std::cerr << "File" << gcpfilename << " couldn't be opened" << std::endl; return EXIT_FAILURE; } DistanceType::Pointer distance = DistanceType::New(); GeographicalDistanceType::Pointer geoDistance = GeographicalDistanceType::New(); //-------------------------- // Some instantiations (end) //-------------------------- //----------- // Tests core //----------- // #1 keywordlist, only check the needed keywords /*-------------------------------------*/ if (checkNeededKw) { //Split the string into many tokens, with whitespaces as separators std::list neededKw; copy(std::istream_iterator(iss), std::istream_iterator(), back_inserter(neededKw)); std::list missingKw; for(std::list::iterator neededIt=neededKw.begin(); neededIt!=neededKw.end(); ++neededIt) { bool foundNeededKw = false; for(KeywordlistMapType::iterator kwlistIt=kwmap.begin(); kwlistIt!=kwmap.end(); ++kwlistIt) { std::size_t found = kwlistIt->first.find(*neededIt); if (found!=std::string::npos) { foundNeededKw = true; } } if (!foundNeededKw) missingKw.push_back(*neededIt); } if ( (neededKw.size()>0) && (missingKw.size()>0) ) { std::cerr << "Some keywords were not found; missing keywords : " << std::endl; for (std::list::iterator itm = missingKw.begin(); itm != missingKw.end(); ++itm) std::cerr << *itm << std::endl; return EXIT_FAILURE; } } /*-------------------------------------*/ pointsContainerType::iterator pointsIt=pointsContainer.begin(); geo3dPointsContainerType::iterator geo3dPointsIt=geo3dPointsContainer.begin(); //for(; pointsIt!=pointsContainer.end(); ++pointsIt) while( (pointsIt!=pointsContainer.end()) && (geo3dPointsIt!=geo3dPointsContainer.end()) ) { imagePoint = *pointsIt; geo3dPoint = *geo3dPointsIt; double z=geo3dPoint[2]; otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(z); // otbForwardSensorModel and otbInverseSensorModel geoPoint = forwardSensorModel->TransformPoint(imagePoint); reversedImagePoint = inverseSensorModel->TransformPoint(geoPoint); // otbGenericRSTransform geoPointGRS = img2wgs->TransformPoint(imagePoint); reversedImagePointGRS = wgs2img->TransformPoint(geoPointGRS); // ossim classes ossimDpt ossimPoint(otb::internal::ConvertToOSSIMFrame(imagePoint[0]), //x otb::internal::ConvertToOSSIMFrame(imagePoint[1])); //y ossimGpt ossimGPoint; ossimSensorModel->lineSampleHeightToWorld(ossimPoint,z, ossimGPoint); geoPointOSSIM[0] = ossimGPoint.lon; geoPointOSSIM[1] = ossimGPoint.lat; // Just for debug purpose if (modeVerbose) { std::cout << ">>>>>>>>>>>>>> ---------------------" << std::endl; std::cout << ">>>>>>>>>>>>>>" << geomfilename << std::endl; std::cout << ">>>>>>>>>>>>>>" << std::setprecision(15) << "Image to geo (Inverse/Forward SensorModel): " << imagePoint << " -> " << geoPoint << "\n"; std::cout << ">>>>>>>>>>>>>>" << std::setprecision(15) << "Geo to image (Inverse/Forward SensorModel): " << geoPoint << " -> " << reversedImagePoint << "\n"; std::cout << ">>>>>>>>>>>>>>" << std::setprecision(15) << "Image to geo (GenericRSTransform): " << imagePoint << " -> " << geoPointGRS << "\n"; std::cout << ">>>>>>>>>>>>>>" << std::setprecision(15) << "Geo to image (GenericRSTransform): " << geoPointGRS << " -> " << reversedImagePointGRS << "\n"; std::cout << ">>>>>>>>>>>>>>" << std::setprecision(15) << "Image to geo (OSSIM): " << imagePoint << " -> " << geoPointOSSIM << "\n"; } // 3. Results should be plausible (no NaN and no clearly out of bound results) /*-------------------------------------*/ if ( (ossim::isnan(geoPoint[0])) || (ossim::isnan(geoPoint[1])) ) { std::cerr << " Nan results (otbForwardSensorModel otbInverseSensorModel) : image to geo: " << imagePoint << " -> " << geoPoint << "\n"; return EXIT_FAILURE; } if ( (ossim::isnan(geoPointGRS[0])) || (ossim::isnan(geoPointGRS[1])) ) { std::cerr << "Nan results (otbGenericRSTransform) : image to geo: " << imagePoint << " -> " << geoPointGRS << "\n"; return EXIT_FAILURE; } if ( (ossim::isnan(reversedImagePoint[0])) || (ossim::isnan(reversedImagePoint[1])) ) { std::cerr << "Nan results (otbForwardSensorModel otbInverseSensorModel) : geo to image: " << geoPoint << " -> " << reversedImagePoint << "\n"; return EXIT_FAILURE; } if ( (ossim::isnan(reversedImagePointGRS[0])) || (ossim::isnan(reversedImagePointGRS[1])) ) { std::cerr << "Nan results (otbGenericRSTransform) : geo to image: " << geoPointGRS << " -> " << reversedImagePointGRS << "\n"; return EXIT_FAILURE; } if ( !((geoPoint[0]>=-180.0) && (geoPoint[0]<=180.0)) || !((geoPoint[1]>=-90.0) && (geoPoint[1]<=90.0)) ) { std::cerr << "GeoPoint out of bound (otbForwardSensorModel otbInverseSensorModel) : " << geoPoint << "\n"; return EXIT_FAILURE; } if ( !((geoPointGRS[0]>=-180.0) && (geoPointGRS[0]<=180.0)) || !((geoPointGRS[1]>=-90.0) && (geoPointGRS[1]<=90.0)) ) { std::cerr << "GeoPoint out of bound (otbGenericRSTransform) : " << geoPointGRS << "\n"; return EXIT_FAILURE; } /*-------------------------------------*/ //2. Check that the encapsulation does not modify results /*-------------------------------------*/ // Inverse/Forward SensorModel VS GenericRSTransform double dist1 = geoDistance->Evaluate(geoPoint, geoPointGRS); if (dist1>geoTol) { std::cerr << "Geo distance between otbForwardSensorModel and otbGenericRSTransform too high : " << "dist = " << dist1 << " (tol = " << geoTol << ")" << std::endl; return EXIT_FAILURE; } // Inverse/Forward SensorModel VS OSSIM double dist2 = geoDistance->Evaluate(geoPoint, geoPointOSSIM); if (dist2>geoTol) { std::cerr << "Geo distance between otbForwardSensorModel and OSSIM too high : " << "dist = " << dist2 << " (tol = " << geoTol << ")" << std::endl; return EXIT_FAILURE; } /*-------------------------------------*/ //4. Round tripping error /*-------------------------------------*/ //for otbForwardSensorModel otbInverseSensorModel classes double dist3 = distance->Evaluate(imagePoint, reversedImagePoint); if (dist3>imgTol) { std::cerr << "Round tripping error for otbForwardSensorModel / otbInverseSensorModel too high : " << "dist(imagePoint,reversedImagePoint) = " << dist3 << " (tol = " << imgTol << ")" << std::endl; return EXIT_FAILURE; } //for otbGenericRSTransform class double dist4 = distance->Evaluate(imagePoint, reversedImagePointGRS); if (dist4>imgTol) { std::cerr << "Round tripping error for otbGenericRSTransform too high : " << "dist(imagePoint,reversedImagePoint) = " << dist4 << " (tol = " << imgTol << ")" << std::endl; return EXIT_FAILURE; } /*-------------------------------------*/ //5. Stability check /*-------------------------------------*/ geoPointGCP[0] = geo3dPoint[0]; geoPointGCP[1] = geo3dPoint[1]; double dist5 = geoDistance->Evaluate(geoPoint, geoPointGCP); double dist6 = geoDistance->Evaluate(geoPointGRS, geoPointGCP); double dist7 = geoDistance->Evaluate(geoPointOSSIM, geoPointGCP); if (modeVerbose) { std::cout << ">>>>>>>>>>>>>>" << "Forward SensorModel VS GCP : " << dist5 << std::endl; std::cout << ">>>>>>>>>>>>>>" << "GenericRSTransform VS GCP : " << dist6 << std::endl; std::cout << ">>>>>>>>>>>>>>" << "OSSIM VS GCP : " << dist7 << std::endl; } if (dist5>geoTol) { std::cerr << "Result for Forward SensorModel is unstable : dist from baseline = " << dist5 << " (tol = " << geoTol << ")" << std::endl; return EXIT_FAILURE; } if (dist6>geoTol) { std::cerr << "Result for GenericRSTransform is unstable : dist from baseline = " << dist6 << " (tol = " << geoTol << ")" << std::endl; return EXIT_FAILURE; } /*-------------------------------------*/ ++pointsIt; ++geo3dPointsIt; } //----------------- // Tests core (end) //----------------- return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbSpectralAngleDataNodeFeatureFunction.cxx000066400000000000000000000122741301006202600324510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSpectralAngleDataNodeFeatureFunction.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataIntoImageProjectionFilter.h" #include "otbVectorDataFileWriter.h" #include "itkPreOrderTreeIterator.h" int otbSpectralAngleDataNodeFeatureFunctionNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::SpectralAngleDataNodeFeatureFunction DataNodeFeaturefunctionType; DataNodeFeaturefunctionType::Pointer featureFunction = DataNodeFeaturefunctionType::New(); std::cout << featureFunction << std::endl; return EXIT_SUCCESS; } int otbSpectralAngleDataNodeFeatureFunction(int itkNotUsed(argc), char* argv[]) { const char * inputVD = argv[1]; const char * inputImg = argv[2]; const char * DEMDir = argv[3]; const char * outputVD = argv[4]; int DisplayWarnings = atoi(argv[5]); typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ImageReaderType; typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataIntoImageProjectionFilter VectorDataReProjFilter; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef otb::SpectralAngleDataNodeFeatureFunction FeaturefunctionType; typedef FeaturefunctionType::OutputType FeatureOutputType; ImageReaderType::Pointer imgReader = ImageReaderType::New(); VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); VectorDataReProjFilter::Pointer vdReProjFilter = VectorDataReProjFilter::New(); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); FeaturefunctionType::Pointer featureFunction = FeaturefunctionType::New(); if (!DisplayWarnings) { imgReader->SetGlobalWarningDisplay(0); } otb::DEMHandler::Instance()->OpenDEMDirectory(DEMDir); vdReader->SetFileName(inputVD); vdReader->Update(); imgReader->SetFileName(inputImg); imgReader->UpdateOutputInformation(); imgReader->Update(); //Needed to set m_EndIndex, m_StartIndex in otbDataNodeImageFunction vdReProjFilter->SetInputImage(imgReader->GetOutput()); vdReProjFilter->SetInputVectorData(vdReader->GetOutput()); vdReProjFilter->SetUseOutputSpacingAndOriginFromImage(true); vdReProjFilter->Update(); std::cout<< "vdReProjFilter->GetOutput()->Size(): " << vdReProjFilter->GetOutput()->Size() << std::endl; featureFunction->SetInputImage(imgReader->GetOutput()); featureFunction->SetRadius(0); // Output VectorDataType::Pointer outVD = VectorDataType::New(); // Retrieving root node DataNodeType::Pointer root = outVD->GetDataTree()->GetRoot()->Get(); // Create the document node DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree outVD->GetDataTree()->Add(document, root); // Create the folder node DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree outVD->GetDataTree()->Add(folder, document); TreeIteratorType itVector(vdReProjFilter->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsLineFeature() || itVector.Get()->IsPolygonFeature()) { const DataNodeType::Pointer currentGeometry = itVector.Get(); FeatureOutputType currentResult; currentResult = featureFunction->Evaluate(*(currentGeometry.GetPointer())); currentGeometry->SetFieldAsDouble("RADIOM", (double)(currentResult[0])); outVD->GetDataTree()->Add(currentGeometry, folder); } ++itVector; } vdWriter->SetInput(outVD); vdWriter->SetFileName(outputVD); vdWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbTileImageFilterRSTransformTest.cxx000066400000000000000000000077671301006202600313250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbTileImageFilter.h" #include "otbImageFileReader.h" #include "otbGeographicalDistance.h" #include "otbGenericRSTransform.h" #include typedef otb::Image ImageType; typedef otb::TileImageFilter TileImageFilterType; typedef otb::ImageFileReader ImageReaderType; typedef otb::GenericRSTransform<> RSTransformType; typedef ImageType::PointType PointType; typedef otb::GeographicalDistance GeographicalDistanceType; int otbTileImageFilterRSTransformTest(int argc, char * argv[]) { TileImageFilterType::SizeType layout; layout[0]=atoi(argv[1]); layout[1]=atoi(argv[2]); double threshold = 1e-20; unsigned int numberOfImages = layout[0] * layout[1]; std::vector readers; std::vector points; std::vector transforms; TileImageFilterType::Pointer tileFilter = TileImageFilterType::New(); tileFilter->SetLayout(layout); otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(0); for(unsigned int i = 0; i (unsigned int)argc) { std::cerr<<"Not enough images to support layout!"<SetFileName(argv[i+3]); reader->UpdateOutputInformation(); readers.push_back(reader); // Compute tile center PointType center = reader->GetOutput()->GetOrigin(); center[0] += reader->GetOutput()->GetSpacing()[0] * reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]/2; center[1] += reader->GetOutput()->GetSpacing()[1] * reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]/2; points.push_back(center); // Set-up transform RSTransformType::Pointer rsTransform = RSTransformType::New(); rsTransform->SetInputKeywordList(reader->GetOutput()->GetImageKeywordlist()); rsTransform->InstantiateTransform(); transforms.push_back(rsTransform); tileFilter->SetInput(i,reader->GetOutput()); } tileFilter->GetOutput()->UpdateOutputInformation(); // Build RS transform for tiled image RSTransformType::Pointer mosaicRsTransform = RSTransformType::New(); mosaicRsTransform->SetInputKeywordList(tileFilter->GetOutput()->GetImageKeywordlist()); mosaicRsTransform->InstantiateTransform(); // Check that individual RSTransform gives the same result as tiled // transform GeographicalDistanceType::Pointer distance = GeographicalDistanceType::New(); std::cout<TransformPoint(points.at(i)); PointType mosaicPoint = mosaicRsTransform->TransformPoint(points.at(i)); double distValue = distance->Evaluate(tilePoint,mosaicPoint); std::cout<<"Tile "< threshold) { std::cerr<<"Projection consistency problem in tile "< #include #include "otbTileMapTransform.h" int otbTileMapTransform(int itkNotUsed(argc), char* argv[]) { const char * outFileName = argv[1]; std::ofstream file; file.open(outFileName); typedef otb::TileMapTransform ProjectionType; ProjectionType::Pointer projection = ProjectionType::New(); projection->SetLevel(10); file << std::setprecision(15); file << "Forward projection: level " << projection->GetLevel() << std::endl; itk::Point point; point[0] = 0; //lon point[1] = 0; //lat file << point << " -> "; file << projection->TransformPoint(point); file << std::endl << std::endl; point[0] = 1.48; //lon point[1] = 43.55; //lat file << point << " -> "; file << projection->TransformPoint(point); file << std::endl << std::endl; typedef otb::TileMapTransform InverseProjectionType; InverseProjectionType::Pointer inverseProjection = InverseProjectionType::New(); inverseProjection->SetLevel(10); file << "Inverse projection: level " << inverseProjection->GetLevel() << std::endl; point[0] = 132149; //X point[1] = 95774; //Y file << point << " -> "; file << inverseProjection->TransformPoint(point); file << std::endl << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbUtmMapProjection.cxx000066400000000000000000000057221301006202600265430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbMacro.h" #include "otbImage.h" #include "otbMapProjections.h" #include "otbUtils.h" int otbUtmMapProjection(int itkNotUsed(argc), char* argv[]) { const char * outFileName = argv[1]; std::ofstream file; file.open(outFileName); /** Test the output of the projection in Wkt format*/ otb::UtmInverseProjection::Pointer lUtmProjection = otb::UtmInverseProjection::New(); file << lUtmProjection->GetWkt() << std::endl << std::endl; lUtmProjection->SetHemisphere('S'); file << "We should be in the south hemisphere now\n"; file << lUtmProjection->GetWkt() << std::endl << std::endl; lUtmProjection->SetZone(48); file << "We should be in zone 48\n"; file << lUtmProjection->GetWkt() << std::endl << std::endl; lUtmProjection->SetHemisphere('N'); file << "And back in the north hemisphere\n"; file << lUtmProjection->GetWkt() << std::endl << std::endl; otb::UtmForwardProjection::Pointer lUtmProjection2 = otb::UtmForwardProjection::New(); file << lUtmProjection2->GetWkt() << std::endl << std::endl; lUtmProjection2->SetHemisphere('S'); file << "We should be in the south hemisphere now\n"; file << lUtmProjection2->GetWkt() << std::endl << std::endl; lUtmProjection2->SetZone(48); file << "We should be in zone 48\n"; file << lUtmProjection2->GetWkt() << std::endl << std::endl; lUtmProjection2->SetHemisphere('N'); file << "And back in the north hemisphere\n"; file << lUtmProjection2->GetWkt() << std::endl << std::endl; lUtmProjection2->SetHemisphere('S'); //Back in the south to make sure the following works otb::UtmForwardProjection::InputPointType groundPoint; groundPoint[0] = -4.5; groundPoint[1] = 48.5; lUtmProjection2->SetZoneAndHemisphereFromGeoPoint(groundPoint); file << "We should be in zone 30 in north hemisphere\n"; file << lUtmProjection2->GetWkt() << std::endl << std::endl; //And checking accesors file << "Zone should be 30: " << lUtmProjection2->GetZone() << "\n"; file << "Hemisphere should be N: " << lUtmProjection2->GetHemisphere() << "\n"; groundPoint[0] = 1.5; groundPoint[1] = 43.5; file << "Zone should be 31: " << otb::Utils::GetZoneFromGeoPoint(groundPoint[0], groundPoint[1]) << "\n"; groundPoint[0] = 5; groundPoint[1] = 60; file << "Zone should be 32 (exception near Norway): " << otb::Utils::GetZoneFromGeoPoint(groundPoint[0], groundPoint[1]) << "\n"; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataExtractROIandProjection.cxx000066400000000000000000000072451301006202600317660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbImage.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include "otbVectorDataExtractROI.h" #include #include int otbVectorDataExtractROIandProjection(int itkNotUsed(argc), char * argv[]) { //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); // projection->Update(); std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; projection->SetOutputProjectionRef(projectionRefWkt); //Convert the vector data into an image typedef otb::Image ImageType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; origin[0] = 374149.980555821; //UL easting origin[1] = 4829183.99443839; //UL northing ImageType::SpacingType spacing; spacing[0] = 0.6; spacing[1] = -0.6; typedef otb::RemoteSensingRegion RegionType; RegionType region; RegionType::SizeType sizeInUnit; sizeInUnit[0] = size[0] * spacing[0]; sizeInUnit[1] = size[1] * spacing[1]; region.SetSize(sizeInUnit); region.SetOrigin(origin); region.SetRegionProjection(projectionRefWkt); typedef otb::VectorDataExtractROI ExtractROIType; ExtractROIType::Pointer extractROI = ExtractROIType::New(); extractROI->SetRegion(region); extractROI->SetInput(projection->GetOutput()); extractROI->Update(); unsigned int elementsKeptAfterProj = extractROI->GetOutput()->Size(); std::cout << "After projection: kept " << elementsKeptAfterProj << " features." << std::endl; extractROI->SetInput(reader->GetOutput()); extractROI->Update(); unsigned int elementsKeptAfterReader = extractROI->GetOutput()->Size(); std::cout << "Directly from reader: kept " << elementsKeptAfterReader << " features." << std::endl; if (elementsKeptAfterProj != elementsKeptAfterReader) { std::cout<<"Test supposed to fail: shows the error induced by extract+project regarding project+extract" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataIntoImageProjectionFilterTest.cxx000066400000000000000000000201341301006202600331710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbMacro.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbVectorDataIntoImageProjectionFilter.h" /* * Tests prTvVectorDataIntoImageProjectionFilterTest_2 and * prTvVectorDataIntoImageProjectionFilterTest_4 failed because of the bug http://bugs.orfeo-toolbox.org/view.php?id=333. */ /*int otbVectorDataIntoImageProjectionFilterTest(int itkNotUsed(argc), char * argv[]) { typedef float PixelType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; // Vector Data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataIntoImageProjectionFilter VectorDataIntoImageProjectionFilterType; std::string imageInputFilename = argv[1]; std::string vectorDataInputFilename = argv[2]; std::string demDirectory = argv[3]; int expectedFeatures = atoi(argv[4]); otb::DEMHandler::Instance()->OpenDEMDirectory(demDirectory); // Read the image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageInputFilename); reader->UpdateOutputInformation(); // Read the Vector Data VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); vdReader->SetFileName(vectorDataInputFilename); vdReader->Update(); VectorDataIntoImageProjectionFilterType::Pointer vdReProjFilter = VectorDataIntoImageProjectionFilterType::New(); vdReProjFilter->SetInputImage(reader->GetOutput()); vdReProjFilter->SetInputVectorData(vdReader->GetOutput()); vdReProjFilter->Update(); int nbElem = 0; typedef itk::PreOrderTreeIterator TreeIteratorType; TreeIteratorType itVector(vdReProjFilter->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if ( !itVector.Get()->IsRoot() && !itVector.Get()->IsFolder() && !itVector.Get()->IsDocument()) { nbElem++; } ++itVector; } if (nbElem != expectedFeatures) { std::cerr << "Kept " << nbElem << " features, but expected " << expectedFeatures << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }*/ int otbVectorDataIntoImageProjectionFilterCompareImplTest(int itkNotUsed(argc), char * argv[]) { typedef float PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; // Vector Data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; // typedef otb::VectorDataIntoImageProjectionFilter VectorDataReProjFilter; typedef otb::VectorDataProjectionFilter VectorDataProjectionFilterType; typedef otb::VectorDataExtractROI VectorDataExtractROIType; typedef VectorDataExtractROIType::RegionType RemoteSensingRegionType; std::string imageInputFilename = argv[1]; std::string vectorDataInputFilename = argv[2]; std::string demDirectory = argv[3]; std::string vectorDataOutputFilename = argv[4]; std::string vectorDataOutputFilename2 = argv[5]; std::cout << imageInputFilename << "\n" << vectorDataInputFilename << "\n" << demDirectory << "\n" << vectorDataOutputFilename << "\n" << vectorDataOutputFilename2 << std::endl; if (!demDirectory.empty()) { otb::DEMHandler::Instance()->OpenDEMDirectory(demDirectory); } // Read the image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageInputFilename); reader->UpdateOutputInformation(); // read the Vector Data VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); vdReader->SetFileName(vectorDataInputFilename); vdReader->Update(); VectorDataReProjFilter::Pointer vdReProjFilter = VectorDataReProjFilter::New(); vdReProjFilter->SetInputImage(reader->GetOutput()); vdReProjFilter->SetInputVectorData(vdReader->GetOutput()); std::string stateOutput =""; if (atoi(argv[6]) == 1) { stateOutput = "true"; vdReProjFilter->SetUseOutputSpacingAndOriginFromImage(true); } else { stateOutput = "false"; vdReProjFilter->SetUseOutputSpacingAndOriginFromImage(false); } //---------- // WRITE //vdReProjFilter->Update(); VectorDataWriterType::Pointer vdwriter = VectorDataWriterType::New(); vdwriter->SetFileName(vectorDataOutputFilename); vdwriter->SetInput(vdReProjFilter->GetOutput()); vdwriter->Update(); //------- // do the same with old code VectorDataProjectionFilterType::Pointer vproj; VectorDataExtractROIType::Pointer vdextract; // Extract The part of the VectorData that actually overlaps with // the image extent vdextract = VectorDataExtractROIType::New(); vdextract->SetInput(vdReader->GetOutput()); // Find the geographic region of interest // Ge the index of the corner of the image ImageType::IndexType ul, ur, ll, lr; ImageType::PointType pul, pur, pll, plr; ul = reader->GetOutput()->GetLargestPossibleRegion().GetIndex(); ur = ul; ll = ul; lr = ul; ur[0] += reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]; lr[0] += reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]; lr[1] += reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]; ll[1] += reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]; // Transform to physical point reader->GetOutput()->TransformIndexToPhysicalPoint(ul, pul); reader->GetOutput()->TransformIndexToPhysicalPoint(ur, pur); reader->GetOutput()->TransformIndexToPhysicalPoint(ll, pll); reader->GetOutput()->TransformIndexToPhysicalPoint(lr, plr); // Build the cartographic region RemoteSensingRegionType rsRegion; RemoteSensingRegionType::IndexType rsOrigin; RemoteSensingRegionType::SizeType rsSize; rsOrigin[0] = std::min(pul[0], plr[0]); rsOrigin[1] = std::min(pul[1], plr[1]); rsSize[0] = vcl_abs(pul[0] - plr[0]); rsSize[1] = vcl_abs(pul[1] - plr[1]); rsRegion.SetOrigin(rsOrigin); rsRegion.SetSize(rsSize); rsRegion.SetRegionProjection(reader->GetOutput()->GetProjectionRef()); rsRegion.SetKeywordList(reader->GetOutput()->GetImageKeywordlist()); // Set the cartographic region to the extract roi filter vdextract->SetRegion(rsRegion); // Reproject VectorData in image projection vproj = VectorDataProjectionFilterType::New(); vproj->SetInput(vdextract->GetOutput()); vproj->SetInputProjectionRef(vdReader->GetOutput()->GetProjectionRef()); vproj->SetOutputKeywordList(reader->GetOutput()->GetImageKeywordlist()); vproj->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); vproj->SetOutputOrigin(reader->GetOutput()->GetOrigin()); vproj->SetOutputSpacing(reader->GetOutput()->GetSpacing()); //---------- // WRITE VectorDataWriterType::Pointer vdwriter2 = VectorDataWriterType::New(); vdwriter2->SetFileName(vectorDataOutputFilename2); vdwriter2->SetInput(vproj->GetOutput()); vdwriter2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataProjectionFilter.cxx000066400000000000000000000062351301006202600305420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataProjectionFilter.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbStandardFilterWatcher.h" int otbVectorDataProjectionFilter(int argc, char * argv[]) { if (argc < 3) { std::cout << argv[0] << " []" << std::endl; return EXIT_FAILURE; } typedef otb::VectorData InputVectorDataType; typedef otb::VectorData OutputVectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); typedef otb::VectorDataProjectionFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); vectorDataProjection->SetInput(reader->GetOutput()); std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; vectorDataProjection->SetOutputProjectionRef(projectionRefWkt); otb::StandardFilterWatcher watcher(vectorDataProjection, "VectorDataProjection"); typedef otb::VectorDataFileWriter VectorDataFileWriterType; VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); //Output the tree in a text file if (argc >= 4) { const char * outfile = argv[3]; std::ofstream file; file.open(outfile); InputVectorDataType::Pointer data; data = reader->GetOutput(); file << "Original data" << std::endl; file << data; file << std::endl << std::endl; OutputVectorDataType::Pointer data2; data2 = vectorDataProjection->GetOutput(); file << "Reprojected data" << std::endl; file << data2; file << std::endl << std::endl; file.close(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataProjectionFilterFromGeoToMap.cxx000066400000000000000000000042721301006202600327610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataProjectionFilter.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbVectorDataProjectionFilterFromGeoToMap(int argc, char * argv[]) { if (argc < 2) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::VectorData InputVectorDataType; typedef otb::VectorData OutputVectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); typedef otb::VectorDataProjectionFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); vectorDataProjection->SetInput(reader->GetOutput()); vectorDataProjection->SetOutputProjectionRef(imageReader->GetOutput()->GetProjectionRef()); typedef otb::VectorDataFileWriter VectorDataFileWriterType; VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataProjectionFilterFromMapToGeo.cxx000066400000000000000000000034401301006202600327550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataProjectionFilter.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" int otbVectorDataProjectionFilterFromMapToGeo(int argc, char * argv[]) { if (argc < 2) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::VectorData InputVectorDataType; typedef otb::VectorData OutputVectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); typedef otb::VectorDataProjectionFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); vectorDataProjection->SetInput(reader->GetOutput()); typedef otb::VectorDataFileWriter VectorDataFileWriterType; VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataProjectionFilterFromMapToImage.cxx000066400000000000000000000046121301006202600332670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataProjectionFilter.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbVectorDataProjectionFilterFromMapToImage(int argc, char * argv[]) { if (argc < 4) { std::cout << argv[0] << " " << " " << std::endl; return EXIT_FAILURE; } typedef otb::VectorData InputVectorDataType; typedef otb::VectorData OutputVectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); typedef otb::VectorDataProjectionFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); vectorDataProjection->SetInput(reader->GetOutput()); vectorDataProjection->SetOutputProjectionRef(imageReader->GetOutput()->GetProjectionRef()); vectorDataProjection->SetOutputOrigin(imageReader->GetOutput()->GetOrigin()); vectorDataProjection->SetOutputSpacing(imageReader->GetOutput()->GetSpacing()); typedef otb::VectorDataFileWriter VectorDataFileWriterType; VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataProjectionFilterFromMapToSensor.cxx000066400000000000000000000046141301006202600335200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataProjectionFilter.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbImage.h" #include "otbImageFileReader.h" int otbVectorDataProjectionFilterFromMapToSensor(int argc, char * argv[]) { if (argc < 4) { std::cout << argv[0] << " " << " " << std::endl; return EXIT_FAILURE; } typedef otb::VectorData InputVectorDataType; typedef otb::VectorData OutputVectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); typedef otb::Image ImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); typedef otb::VectorDataProjectionFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); vectorDataProjection->SetInput(reader->GetOutput()); vectorDataProjection->SetOutputKeywordList(imageReader->GetOutput()->GetImageKeywordlist()); vectorDataProjection->SetOutputOrigin(imageReader->GetOutput()->GetOrigin()); vectorDataProjection->SetOutputSpacing(imageReader->GetOutput()->GetSpacing()); typedef otb::VectorDataFileWriter VectorDataFileWriterType; VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataProjectionFilterNew.cxx000066400000000000000000000021251301006202600312060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorDataProjectionFilter.h" #include "otbVectorData.h" int otbVectorDataProjectionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::VectorData InputVectorDataType; typedef otb::VectorData OutputVectorDataType; typedef otb::VectorDataProjectionFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorData = VectorDataFilterType::New(); std::cout << vectorData << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Projection/test/otbVectorDataTransformFilter.cxx000066400000000000000000000073141301006202600304000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataTransformFilter.h" #include "itkAffineTransform.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbVectorDataProjectionFilter.h" // common typedefs typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataTransformFilter VectorDataTransformType; int otbVectorDataTransformFilterNew (int itkNotUsed(argc), char * itkNotUsed(argv)[]) { VectorDataTransformType::Pointer transformFilter = VectorDataTransformType::New(); return EXIT_SUCCESS; } int otbVectorDataTransformFilter (int itkNotUsed(argc), char * argv[]) { typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorDataFileReader VectorDataFileReaderType; typedef otb::VectorDataFileWriter VectorDataFileWriterType; typedef otb::VectorDataProjectionFilter VDProjectionFilterType; // Instantiate the image reader ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); VectorDataFileReaderType::Pointer vdreader = VectorDataFileReaderType::New(); vdreader->SetFileName(argv[2]); vdreader->Update(); // Reproject the VectorData In the image coordinate system VDProjectionFilterType::Pointer vdproj = VDProjectionFilterType::New(); vdproj->SetInput(vdreader->GetOutput()); vdproj->SetInputProjectionRef(vdreader->GetOutput()->GetProjectionRef()); vdproj->SetOutputKeywordList(reader->GetOutput()->GetImageKeywordlist()); vdproj->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); // Test the translation using the ApplyTransformTo typedef itk::AffineTransform TransformType; typedef TransformType::OutputVectorType TranslationParamType; // Set up the transform (Apply a translation of 8 pixels in the y direction) TransformType::Pointer transform = TransformType::New(); TranslationParamType translationParam; translationParam[0] = 0; translationParam[1] = 8. * reader->GetOutput()->GetSpacing()[1]; transform->SetTranslation(translationParam); VectorDataTransformType::Pointer transformFilter = VectorDataTransformType::New(); transformFilter->SetInput(vdproj->GetOutput()); transformFilter->SetTransform(transform); // retransform int the input vector projection VDProjectionFilterType::Pointer reverseVdProj = VDProjectionFilterType::New(); reverseVdProj->SetInput(transformFilter->GetOutput()); reverseVdProj->SetOutputProjectionRef(vdreader->GetOutput()->GetProjectionRef()); reverseVdProj->SetInputKeywordList(reader->GetOutput()->GetImageKeywordlist()); reverseVdProj->SetInputProjectionRef(reader->GetOutput()->GetProjectionRef()); //Write the vectordata VectorDataFileWriterType::Pointer vdwriter = VectorDataFileWriterType::New(); vdwriter->SetInput(reverseVdProj->GetOutput()); vdwriter->SetFileName(argv[3]); vdwriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Smoothing/000077500000000000000000000000001301006202600207205ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Smoothing/CMakeLists.txt000066400000000000000000000000501301006202600234530ustar00rootroot00000000000000project(OTBSmoothing) otb_module_impl() OTB-release-5.8/Modules/Filtering/Smoothing/include/000077500000000000000000000000001301006202600223435ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Smoothing/include/otbMeanShiftSmoothingImageFilter.h000066400000000000000000000605001301006202600311010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanShiftSmoothingImageFilter_h #define otbMeanShiftSmoothingImageFilter_h #include "otbImage.h" #include "otbVectorImage.h" #include "itkImageToImageFilter.h" #include "itkImageRegionConstIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" #include namespace otb { namespace Meanshift { template inline T simple_pow(T const& v, unsigned int p) { T res = 1; for (unsigned int i = 0; i != p; ++i) { res *= v; } return res; } /** \class SpatialRangeJointDomainTransform * * * Functor returning the joint spatial-range representation of a pixel, i.e. the * concatenation of range components and coordinates as a vector. Components are * scaled by their respective spatial and range bandwidth. * * \ingroup OTBSmoothing */ template class SpatialRangeJointDomainTransform { public: typedef double RealType; SpatialRangeJointDomainTransform() { } // ~SpatialRangeJointDomainTransform() {} typename TOutputJointImage::PixelType operator()(const typename TInputImage::PixelType & inputPixel, const typename TInputImage::IndexType & index) const { typename TOutputJointImage::PixelType jointPixel(m_ImageDimension + m_NumberOfComponentsPerPixel); for (unsigned int comp = 0; comp < m_ImageDimension; comp++) { jointPixel[comp] = index[comp] + m_GlobalShift[comp]; } for (unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; comp++) { jointPixel[m_ImageDimension + comp] = inputPixel[comp]; } return jointPixel; } void Initialize(unsigned int _ImageDimension, unsigned int numberOfComponentsPerPixel_, typename TInputImage::IndexType globalShift_) { m_ImageDimension = _ImageDimension; m_NumberOfComponentsPerPixel = numberOfComponentsPerPixel_; m_OutputSize = m_ImageDimension + m_NumberOfComponentsPerPixel; m_GlobalShift = globalShift_; } unsigned int GetOutputSize() const { return m_OutputSize; } private: unsigned int m_ImageDimension; unsigned int m_NumberOfComponentsPerPixel; unsigned int m_OutputSize; typename TInputImage::IndexType m_GlobalShift; }; class KernelUniform { public: typedef double RealType; // KernelUniform() {} // ~KernelUniform() {} RealType operator()(RealType x) const { return (x <= 1) ? 1.0 : 0.0; } RealType GetRadius(RealType bandwidth) const { return bandwidth; } }; class KernelGaussian { public: typedef double RealType; // KernelGaussian() {} // ~KernelGaussian() {} RealType operator()(RealType x) const { return vcl_exp(-0.5 * x); } RealType GetRadius(RealType bandwidth) const { return 3.0 * bandwidth; } }; /** \class FastImageRegionConstIterator * * Iterator for reading pixels over an image region, specialized for faster * access to pixels in vector images through the method GetPixelPointer * * \ingroup OTBSmoothing */ template class FastImageRegionConstIterator: public itk::ImageRegionConstIterator { public: /** Standard class typedef. */ typedef FastImageRegionConstIterator Self; typedef itk::ImageRegionConstIterator Superclass; typedef typename Superclass::ImageType ImageType; typedef typename Superclass::RegionType RegionType; typedef typename TImage::PixelType PixelType; typedef typename TImage::InternalPixelType InternalPixelType; itkTypeMacro(FastImageRegionConstIterator, ImageRegionConstIterator) ; FastImageRegionConstIterator() : Superclass() { } FastImageRegionConstIterator(const ImageType *ptr, const RegionType ®ion) : Superclass(ptr, region) { m_NumberOfComponentsPerPixel = ptr->GetNumberOfComponentsPerPixel(); } const InternalPixelType * GetPixelPointer() const { return this->m_Buffer + (this->m_Offset * m_NumberOfComponentsPerPixel); } private: unsigned int m_NumberOfComponentsPerPixel; }; #if 0 //disable bucket mode /** \class BucketImage * * This class indexes pixels in a N-dimensional image into a N+1-dimensional * array of buckets. Each pixel is stored into one bucket depending on its * position on the lattice (the width of a bucket is given at construction) and * one spectral component (also given at construction by spectralCoordinate). * * The (spatially and spectrally) neighboring buckets of pixels can then be * obtained by using GetNeighborhoodBucketListIndices(). * * \ingroup OTBSmoothing */ template class BucketImage { public: typedef TImage ImageType; typedef typename ImageType::ConstPointer ImageConstPointerType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::InternalPixelType InternalPixelType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::IndexType IndexType; typedef double RealType; static const unsigned int ImageDimension = ImageType::ImageDimension; /** The bucket image has dimension N+1 (ie. usually 3D for most images) */ typedef std::vector BucketImageSizeType; typedef std::vector BucketImageIndexType; //typedef std::vector BucketImageIndexType; /** pixel buckets typedefs and declarations */ typedef const typename ImageType::InternalPixelType * ImageDataPointerType; typedef std::vector BucketType; typedef std::vector BucketListType; BucketImage() { } /** Constructor for the bucket image. It operates on the specified * region. * spatialRadius specifies the width of a bucket in pixels. * rangeRadius is the spectral width for the specified spectral coordinate in * one bucket. * spectralCoordinate is the index of the pixel used for classification in buckets. */ BucketImage(ImageConstPointerType image, const RegionType & region, RealType spatialRadius, RealType rangeRadius, unsigned int spectralCoordinate) : m_Image(image), m_Region(region), m_SpatialRadius(spatialRadius), m_RangeRadius(rangeRadius), m_SpectralCoordinate(spectralCoordinate) { // Find max and min of the used spectral band itk::ImageRegionConstIterator inputIt(m_Image, m_Region); inputIt.GoToBegin(); InternalPixelType minValue = inputIt.Get()[spectralCoordinate]; InternalPixelType maxValue = minValue; ++inputIt; while (!inputIt.IsAtEnd()) { const PixelType &p = inputIt.Get(); minValue = vcl_min(minValue, p[m_SpectralCoordinate]); maxValue = vcl_max(maxValue, p[m_SpectralCoordinate]); ++inputIt; } m_MinValue = minValue; m_MaxValue = maxValue; // Compute bucket image dimensions. Note: empty buckets are at each border // to simplify image border issues m_DimensionVector.resize(ImageDimension + 1); // NB: pays for a 0-innit for (unsigned int dim = 0; dim < ImageDimension; ++dim) { m_DimensionVector[dim] = m_Region.GetSize()[dim] / m_SpatialRadius + 3; } m_DimensionVector[ImageDimension] = (unsigned int) ((maxValue - minValue) / m_RangeRadius) + 3; unsigned int numBuckets = m_DimensionVector[0]; for (unsigned int dim = 1; dim <= ImageDimension; ++dim) numBuckets *= m_DimensionVector[dim]; m_BucketList.resize(numBuckets); // Build buckets itk::ImageRegionConstIteratorWithIndex it(m_Image, m_Region); it.GoToBegin(); // this iterator is only used to get the pixel data pointer FastImageRegionConstIterator fastIt(m_Image, m_Region); fastIt.GoToBegin(); while (!it.IsAtEnd()) { const IndexType & index = it.GetIndex(); const PixelType & pixel = it.Get(); // Find which bucket this pixel belongs to const BucketImageIndexType bucketIndex = GetBucketIndex(pixel, index); unsigned int bucketListIndex = BucketIndexToBucketListIndex(bucketIndex); assert(bucketListIndex < numBuckets); m_BucketList[bucketListIndex].push_back(fastIt.GetPixelPointer()); ++it; ++fastIt; } // Prepare neighborhood offset vector // BucketImageIndexType zeroOffsetIndex(ImageDimension+1); std::vector neighborsIndexList; neighborsIndexList.reserve(simple_pow(3, ImageDimension + 1)); neighborsIndexList.resize(1, BucketImageIndexType(ImageDimension + 1)); // zeroOffsetIndex // neighborsIndexList.push_back(zeroOffsetIndex); for (unsigned dim = 0; dim <= ImageDimension; ++dim) { // take all neighbors already in the list and add their direct neighbor // along the current dim const unsigned int curSize = neighborsIndexList.size(); for (unsigned int i = 0; i < curSize; ++i) { BucketImageIndexType index = neighborsIndexList[i]; index[dim]--; neighborsIndexList.push_back(index); index[dim] += 2; neighborsIndexList.push_back(index); } } // Convert all neighbors n-dimensional indices to bucket list 1D indices const unsigned int neighborhoodOffsetVectorSize = neighborsIndexList.size(); m_NeighborhoodOffsetVector.reserve(neighborhoodOffsetVectorSize); for (unsigned int i = 0; i < neighborhoodOffsetVectorSize; ++i) { const int listIndex = BucketIndexToBucketListIndex(neighborsIndexList[i]); m_NeighborhoodOffsetVector.push_back(listIndex); } } ~BucketImage() { } /** Returns the N+1-dimensional bucket index for a given pixel value at the given index */ BucketImageIndexType GetBucketIndex(const PixelType & pixel, const IndexType & index) { BucketImageIndexType bucketIndex(ImageDimension + 1); for (unsigned int dim = 0; dim < ImageDimension; ++dim) { bucketIndex[dim] = (index[dim] - m_Region.GetIndex()[dim]) / m_SpatialRadius + 1; } bucketIndex[ImageDimension] = (pixel[m_SpectralCoordinate] - m_MinValue) / m_RangeRadius + 1; return bucketIndex; } /** Converts a N+1-dimensional bucket index into the 1D list index usable by GetBucket() */ int BucketIndexToBucketListIndex(const BucketImageIndexType & bucketIndex) const { int bucketListIndex = bucketIndex[0]; for (unsigned int dim = 1; dim <= ImageDimension; ++dim) { bucketListIndex = bucketListIndex * m_DimensionVector[dim] + bucketIndex[dim]; } return bucketListIndex; } /** Retrieves the list of all buckets in the neighborhood of the given bucket */ std::vector GetNeighborhoodBucketListIndices(int bucketIndex) const { const unsigned int neighborhoodOffsetVectorSize = m_NeighborhoodOffsetVector.size(); std::vector indices(neighborhoodOffsetVectorSize); for (unsigned int i = 0; i < neighborhoodOffsetVectorSize; ++i) { indices[i] = bucketIndex + m_NeighborhoodOffsetVector[i]; } return indices; } /* Returns the list of pixels (actually pointer to pixel data) contained in a bucket */ const BucketType & GetBucket(unsigned int index) const { return m_BucketList[index]; } unsigned int GetNumberOfNeighborBuckets() const { return m_NeighborhoodOffsetVector.size(); } private: /** Input image */ ImageConstPointerType m_Image; /** Processed region */ RegionType m_Region; /** Spatial radius of one bucket of pixels */ RealType m_SpatialRadius; /** Range radius (at a single dimension) of one bucket of pixels */ RealType m_RangeRadius; /** pixels are separated in buckets depending on their spatial position and also their value at one coordinate */ unsigned int m_SpectralCoordinate; /** Min and Max of selected spectral coordinate */ InternalPixelType m_MinValue; InternalPixelType m_MaxValue; /** the buckets are stored in this list */ BucketListType m_BucketList; /** This vector holds the dimensions of the 3D (ND?) bucket image */ BucketImageSizeType m_DimensionVector; /** Vector of offsets in the buckets list to get all buckets in the * neighborhood */ std::vector m_NeighborhoodOffsetVector; }; #endif } // end namespace Meanshift /** \class MeanShiftSmoothingImageFilter * * * Mean shift is an edge-preserving smoothing algorithm often used in image * processing and segmentation. It will iteratively smooth a given pixel with * its neighbors that are within a spatial distance (set using * SetSpatialBandwidth()) and within a spectral range (set using * SetRangeBandwidth()). The resulting filtered image can be retrieved by * GetOutput() or GetRangeOutput(). Parameter SetRangeBandwidthRamp() * allows linearly adapting the range bandwidth to the intensity of * each channel if set greater than 0 (default value is 0). * * There are additional output images, as explained below. * Internally, the algorithm will iteratively update a pixel both in position * and spectral value, with respect to its neighbors, until convergence to a * local mode. The map of the distance traveled by pixels is obtained by * GetSpatialOutput(). A map of detected local modes is also available in * GetLabelOutput() and can be seen as a first segmentation of the input image, * although usually highly oversegmented. * Finally, GetIterationOutput() will return the number of algorithm iterations * for each pixel. * * The class template parameter TKernel allows one to choose how pixels in the * spatial and spectral neighborhood of a given pixel participate in the * smoothed result. By default, a uniform kernel is used (KernelUniform), giving * an equal weight to all neighbor pixels. KernelGaussian can also be used, * although the computation time is significantly higher. The TKernel class * should define operator(), taking a squared norm as parameter and returning a * real value between 0 and 1. It should also define GetRadius(), converting the * spatial bandwidth parameter to the spatial radius defining how many pixels * are in the processing window local to a pixel. * * MeanShifVector squared norm is compared with Threshold (set using Get/Set accessor) to define pixel convergence (1e-3 by default). * MaxIterationNumber defines maximum iteration number for each pixel convergence (set using Get/Set accessor). Set to 4 by default. * ModeSearch is a boolean value, to choose between optimized and non optimized algorithm. If set to true (by default), assign mode value to each pixel on a path covered in convergence steps. * * For more information on mean shift techniques, one might consider reading the following article: * * D. Comaniciu, P. Meer, "Mean Shift: A Robust Approach Toward Feature Space Analysis," IEEE Transactions on * Pattern Analysis and Machine Intelligence, vol. 24, no. 5, pp. 603-619, May, 2002 * D. Comaniciu, P. Meer, "Robust analysis of feature spaces: color image segmentation," cvpr, p. 750, 1997 * IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'97), 1997 * D. Comaniciu, P. Meer, "Mean Shift Analysis and Applications," iccv, p. 1197, Seventh International Conference * on Computer Vision (ICCV'99) - Volume 2, 1999 * * \sa MeanShiftSegmentationFilter * * \ingroup ImageSegmentation * \ingroup ImageEnhancement * * \ingroup OTBSmoothing */ template > class ITK_EXPORT MeanShiftSmoothingImageFilter: public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef MeanShiftSmoothingImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef double RealType; /** Type macro */ itkTypeMacro(MeanShiftSmoothingImageFilter, ImageToImageFilter) ; itkNewMacro(Self) ; /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexValueType InputIndexValueType; typedef typename InputImageType::PointType PointType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SizeType SizeType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::RegionType OutputRegionType; typedef TOutputIterationImage OutputIterationImageType; typedef unsigned long LabelType; typedef otb::Image OutputLabelImageType; typedef otb::VectorImage OutputSpatialImageType; typedef typename OutputSpatialImageType::Pointer OutputSpatialImagePointerType; typedef typename OutputSpatialImageType::PixelType OutputSpatialPixelType; typedef TKernel KernelType; itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); typedef itk::VariableLengthVector RealVector; typedef otb::VectorImage RealVectorImageType; typedef otb::Image ModeTableImageType; /** Sets the spatial bandwidth (or radius in the case of a uniform kernel) * of the neighborhood for each pixel */ itkSetMacro(SpatialBandwidth, RealType); itkGetConstReferenceMacro(SpatialBandwidth, RealType); /** Sets the spectral bandwidth (or radius for a uniform kernel) for pixels * to be included in the same mode */ itkSetMacro(RangeBandwidth, RealType); itkGetConstReferenceMacro(RangeBandwidth, RealType); /** Sets the range bandwidth ramp. If > 0, the range bandwidth * will be y = RangeBandwidthRamp * x + RangeBandwidth, where x is * the band value. */ itkSetMacro(RangeBandwidthRamp, RealType); itkGetConstReferenceMacro(RangeBandwidthRamp,RealType); /** Sets the maximum number of algorithm iterations */ itkGetConstReferenceMacro(MaxIterationNumber, unsigned int); itkSetMacro(MaxIterationNumber, unsigned int); /** Sets the threshold value for the mean shift vector's squared norm, * under which convergence is assumed */ itkGetConstReferenceMacro(Threshold, double); itkSetMacro(Threshold, double); /** Toggle mode search, which is enabled by default. * When off, the output label image is not available * Be careful, with this option, the result will slightly depend on thread number. */ itkSetMacro(ModeSearch, bool); itkGetConstReferenceMacro(ModeSearch, bool); #if 0 /** Toggle bucket optimization, which is disabled by default. */ itkSetMacro(BucketOptimization, bool); itkGetConstReferenceMacro(BucketOptimization, bool); #endif /** Global shift allows tackling down numerical instabilities by aligning pixel indices when performing tile processing */ itkSetMacro(GlobalShift,InputIndexType); /** Returns the const spatial image output,spatial image output is a displacement map (pixel position after convergence minus pixel index) */ const OutputSpatialImageType * GetSpatialOutput() const; /** Returns the const spectral image output */ const OutputImageType * GetRangeOutput() const; /** Returns the const number of iterations map. */ const OutputIterationImageType * GetIterationOutput() const; /** Returns the const image of region labels. This output does not have sense without mode search optimization (each label codes for one mode)*/ const OutputLabelImageType * GetLabelOutput() const; /** Returns the spatial image output,spatial image output is a displacement map (pixel position after convergence minus pixel index) */ OutputSpatialImageType * GetSpatialOutput(); /** Returns the spectral image output */ OutputImageType * GetRangeOutput(); /** Returns the number of iterations done at each pixel */ OutputIterationImageType * GetIterationOutput(); /** Returns the image of region labels. This output does not have sense without mode search optimization (each label codes for one mode) */ OutputLabelImageType * GetLabelOutput(); protected: /** GenerateOutputInformation * Define output pixel size * **/ void GenerateOutputInformation(void) ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** MeanShiftFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() * routine which is called for each processing thread. The output * image data is allocated automatically by the superclass prior to * calling ThreadedGenerateData(). ThreadedGenerateData can only * write to the portion of the output image specified by the * parameter "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; /** Allocates the outputs (need to be reimplemented since outputs have different type) */ void AllocateOutputs() ITK_OVERRIDE; /** Constructor */ MeanShiftSmoothingImageFilter(); /** Destructor */ ~MeanShiftSmoothingImageFilter() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; virtual void CalculateMeanShiftVector(const typename RealVectorImageType::Pointer inputImagePtr, const RealVector& jointPixel, const OutputRegionType& outputRegion, const RealVector& bandwidth, RealVector& meanShiftVector); #if 0 virtual void CalculateMeanShiftVectorBucket(const RealVector& jointPixel, RealVector& meanShiftVector); #endif private: MeanShiftSmoothingImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Range bandwidth */ RealType m_RangeBandwidth; /** Coefficient */ RealType m_RangeBandwidthRamp; /** Spatial bandwidth */ RealType m_SpatialBandwidth; /** Radius of pixel neighborhood, determined by the kernel from the spatial bandwidth */ InputSizeType m_SpatialRadius; /** Threshold on the squared norm of the mean shift vector to decide when to stop iterating **/ double m_Threshold; /** Maximum number of iterations **/ unsigned int m_MaxIterationNumber; /** Kernel object, implementing operator() which returns a weight between 0 and 1 * depending on the squared norm given in parameter **/ KernelType m_Kernel; /** Number of components per pixel in the input image */ unsigned int m_NumberOfComponentsPerPixel; /** Input data in the joint spatial-range domain, scaled by the bandwidths */ typename RealVectorImageType::Pointer m_JointImage; /** Image to store the status at each pixel: * 0 : no mode has been found yet * 1 : a mode has been assigned to this pixel * 2 : pixel is in the path of the currently processed pixel and a mode will * be assigned to it */ typename ModeTableImageType::Pointer m_ModeTable; /** Boolean to enable mode search */ bool m_ModeSearch; #if 0 /** Boolean to enable bucket optimization */ bool m_BucketOptimization; #endif /** Mode counters (local to each thread) */ itk::VariableLengthVector m_NumLabels; /** Number of bits used to represent the threadId in the most significant bits of labels */ unsigned int m_ThreadIdNumberOfBits; #if 0 typedef Meanshift::BucketImage BucketImageType; BucketImageType m_BucketImage; #endif InputIndexType m_GlobalShift; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMeanShiftSmoothingImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Smoothing/include/otbMeanShiftSmoothingImageFilter.txx000066400000000000000000001011561301006202600315000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanShiftSmoothingImageFilter_txx #define otbMeanShiftSmoothingImageFilter_txx #include "otbMeanShiftSmoothingImageFilter.h" #include "itkImageRegionIterator.h" #include "otbUnaryFunctorWithIndexWithOutputSizeImageFilter.h" #include "otbMacro.h" #include "itkProgressReporter.h" namespace otb { template MeanShiftSmoothingImageFilter::MeanShiftSmoothingImageFilter() : m_RangeBandwidth(16.), m_RangeBandwidthRamp(0), m_SpatialBandwidth(3) // , m_SpatialRadius(???) , m_Threshold(1e-3), m_MaxIterationNumber(10) // , m_Kernel(...) , m_NumberOfComponentsPerPixel(0) // , m_JointImage(0) // , m_ModeTable(0) , m_ModeSearch(true) , m_ThreadIdNumberOfBits(0) #if 0 , m_BucketOptimization(false) #endif { this->SetNumberOfRequiredOutputs(4); this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputSpatialImageType::New()); this->SetNthOutput(2, OutputIterationImageType::New()); this->SetNthOutput(3, OutputLabelImageType::New()); m_GlobalShift.Fill(0); } template MeanShiftSmoothingImageFilter::~MeanShiftSmoothingImageFilter() { } template const typename MeanShiftSmoothingImageFilter::OutputSpatialImageType * MeanShiftSmoothingImageFilter::GetSpatialOutput() const { return static_cast (this->itk::ProcessObject::GetOutput(1)); } template typename MeanShiftSmoothingImageFilter::OutputSpatialImageType * MeanShiftSmoothingImageFilter::GetSpatialOutput() { return static_cast (this->itk::ProcessObject::GetOutput(1)); } template const typename MeanShiftSmoothingImageFilter::OutputImageType * MeanShiftSmoothingImageFilter::GetRangeOutput() const { return static_cast (this->itk::ProcessObject::GetOutput(0)); } template typename MeanShiftSmoothingImageFilter::OutputImageType * MeanShiftSmoothingImageFilter::GetRangeOutput() { return static_cast (this->itk::ProcessObject::GetOutput(0)); } template typename MeanShiftSmoothingImageFilter::OutputIterationImageType * MeanShiftSmoothingImageFilter::GetIterationOutput() { return static_cast (this->itk::ProcessObject::GetOutput(2)); } template const typename MeanShiftSmoothingImageFilter::OutputIterationImageType * MeanShiftSmoothingImageFilter::GetIterationOutput() const { return static_cast (this->itk::ProcessObject::GetOutput(2)); } template typename MeanShiftSmoothingImageFilter::OutputLabelImageType * MeanShiftSmoothingImageFilter::GetLabelOutput() { return static_cast (this->itk::ProcessObject::GetOutput(3)); } template const typename MeanShiftSmoothingImageFilter::OutputLabelImageType * MeanShiftSmoothingImageFilter::GetLabelOutput() const { return static_cast (this->itk::ProcessObject::GetOutput(3)); } template void MeanShiftSmoothingImageFilter::AllocateOutputs() { typename OutputSpatialImageType::Pointer spatialOutputPtr = this->GetSpatialOutput(); typename OutputImageType::Pointer rangeOutputPtr = this->GetRangeOutput(); typename OutputIterationImageType::Pointer iterationOutputPtr = this->GetIterationOutput(); typename OutputLabelImageType::Pointer labelOutputPtr = this->GetLabelOutput(); spatialOutputPtr->SetBufferedRegion(spatialOutputPtr->GetRequestedRegion()); spatialOutputPtr->Allocate(); rangeOutputPtr->SetBufferedRegion(rangeOutputPtr->GetRequestedRegion()); rangeOutputPtr->Allocate(); iterationOutputPtr->SetBufferedRegion(iterationOutputPtr->GetRequestedRegion()); iterationOutputPtr->Allocate(); labelOutputPtr->SetBufferedRegion(labelOutputPtr->GetRequestedRegion()); labelOutputPtr->Allocate(); } template void MeanShiftSmoothingImageFilter::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); m_NumberOfComponentsPerPixel = this->GetInput()->GetNumberOfComponentsPerPixel(); if (this->GetSpatialOutput()) { this->GetSpatialOutput()->SetNumberOfComponentsPerPixel(ImageDimension); // image lattice } if (this->GetRangeOutput()) { this->GetRangeOutput()->SetNumberOfComponentsPerPixel(m_NumberOfComponentsPerPixel); } } template void MeanShiftSmoothingImageFilter::GenerateInputRequestedRegion() { // Call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve input pointers InputImagePointerType inPtr = const_cast (this->GetInput()); OutputImagePointerType outRangePtr = this->GetRangeOutput(); // Check pointers before using them if (!inPtr || !outRangePtr) { return; } // Retrieve requested region (TODO: check if we need to handle // region for outHDispPtr) RegionType outputRequestedRegion = outRangePtr->GetRequestedRegion(); // Pad by the appropriate radius RegionType inputRequestedRegion = outputRequestedRegion; // Initializes the spatial radius from kernel bandwidth m_SpatialRadius.Fill(m_Kernel.GetRadius(m_SpatialBandwidth)); InputSizeType margin; for(unsigned int comp = 0; comp < ImageDimension; ++comp) { margin[comp] = (m_MaxIterationNumber * m_SpatialRadius[comp]) + 1; } inputRequestedRegion.PadByRadius(margin); // Crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inPtr->GetLargestPossibleRegion())) { inPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inPtr); throw e; } } template void MeanShiftSmoothingImageFilter::BeforeThreadedGenerateData() { // typedef itk::ImageRegionConstIteratorWithIndex InputIteratorWithIndexType; // typedef itk::ImageRegionIterator JointImageIteratorType; OutputSpatialImagePointerType outSpatialPtr = this->GetSpatialOutput(); OutputImagePointerType outRangePtr = this->GetRangeOutput(); typename InputImageType::ConstPointer inputPtr = this->GetInput(); typename OutputIterationImageType::Pointer iterationOutput = this->GetIterationOutput(); typename OutputSpatialImageType::Pointer spatialOutput = this->GetSpatialOutput(); //InputIndexType index; m_SpatialRadius.Fill(m_Kernel.GetRadius(m_SpatialBandwidth)); m_NumberOfComponentsPerPixel = this->GetInput()->GetNumberOfComponentsPerPixel(); // Allocate output images this->AllocateOutputs(); // Initialize output images to zero iterationOutput->FillBuffer(0); OutputSpatialPixelType zero(spatialOutput->GetNumberOfComponentsPerPixel()); zero.Fill(0); spatialOutput->FillBuffer(zero); // m_JointImage is the input data expressed in the joint spatial-range // domain, i.e. spatial coordinates are concatenated to the range values. // Moreover, pixel components in this image are normalized by their respective // (spatial or range) bandwidth. typedef Meanshift::SpatialRangeJointDomainTransform FunctionType; typedef otb::UnaryFunctorWithIndexWithOutputSizeImageFilter JointImageFunctorType; typename JointImageFunctorType::Pointer jointImageFunctor = JointImageFunctorType::New(); jointImageFunctor->SetInput(inputPtr); jointImageFunctor->GetFunctor().Initialize(ImageDimension, m_NumberOfComponentsPerPixel, m_GlobalShift); jointImageFunctor->GetOutput()->SetRequestedRegion(this->GetInput()->GetBufferedRegion()); jointImageFunctor->Update(); m_JointImage = jointImageFunctor->GetOutput(); #if 0 if (m_BucketOptimization) { // Create bucket image // Note: because values in the input m_JointImage are normalized, the // rangeRadius argument is just 1 m_BucketImage = BucketImageType(static_cast (m_JointImage), m_JointImage->GetRequestedRegion(), m_Kernel.GetRadius(m_SpatialBandwidth), 1, ImageDimension); } #endif /* // Allocate the joint domain image m_JointImage = RealVectorImageType::New(); m_JointImage->SetNumberOfComponentsPerPixel(ImageDimension + m_NumberOfComponentsPerPixel); m_JointImage->SetRegions(inputPtr->GetRequestedRegion()); m_JointImage->Allocate(); InputIteratorWithIndexType inputIt(inputPtr, inputPtr->GetRequestedRegion()); JointImageIteratorType jointIt(m_JointImage, inputPtr->GetRequestedRegion()); // Initialize the joint image with scaled values inputIt.GoToBegin(); jointIt.GoToBegin(); while (!inputIt.IsAtEnd()) { typename InputImageType::PixelType const& inputPixel = inputIt.Get(); index = inputIt.GetIndex(); RealVector & jointPixel = jointIt.Get(); for(unsigned int comp = 0; comp < ImageDimension; comp++) { jointPixel[comp] = index[comp] / m_SpatialBandwidth; } for(unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; comp++) { jointPixel[ImageDimension + comp] = inputPixel[comp] / m_RangeBandwidth; } // jointIt.Set(jointPixel); ++inputIt; ++jointIt; } */ //TODO don't create mode table iterator when ModeSearch is set to false m_ModeTable = ModeTableImageType::New(); m_ModeTable->SetRegions(inputPtr->GetRequestedRegion()); m_ModeTable->Allocate(); m_ModeTable->FillBuffer(0); if (m_ModeSearch) { // Image to store the status at each pixel: // 0 : no mode has been found yet // 1 : a mode has been assigned to this pixel // 2 : a mode will be assigned to this pixel // Initialize counters for mode (also used for mode labeling) // Most significant bits of label counters are used to identify the thread // Id. unsigned int numThreads; numThreads = this->GetNumberOfThreads(); m_ThreadIdNumberOfBits = -1; unsigned int n = numThreads; while (n != 0) { n >>= 1; m_ThreadIdNumberOfBits++; } if (m_ThreadIdNumberOfBits == 0) m_ThreadIdNumberOfBits = 1; // minimum 1 bit m_NumLabels.SetSize(numThreads); for (unsigned int i = 0; i < numThreads; i++) { m_NumLabels[i] = static_cast (i) << (sizeof(LabelType) * 8 - m_ThreadIdNumberOfBits); } } } // Calculates the mean shift vector at the position given by jointPixel template void MeanShiftSmoothingImageFilter::CalculateMeanShiftVector( const typename RealVectorImageType::Pointer jointImage, const RealVector& jointPixel, const OutputRegionType& outputRegion, const RealVector & bandwidth, RealVector& meanShiftVector) { const unsigned int jointDimension = ImageDimension + m_NumberOfComponentsPerPixel; InputIndexType inputIndex; InputIndexType regionIndex; InputSizeType regionSize; assert(meanShiftVector.GetSize() == jointDimension); meanShiftVector.Fill(0); // Calculates current pixel neighborhood region, restricted to the output image region for (unsigned int comp = 0; comp < ImageDimension; ++comp) { inputIndex[comp] = vcl_floor(jointPixel[comp] + 0.5) - m_GlobalShift[comp]; regionIndex[comp] = vcl_max(static_cast (outputRegion.GetIndex().GetElement(comp)), static_cast (inputIndex[comp] - m_SpatialRadius[comp] - 1)); const long int indexRight = vcl_min( static_cast (outputRegion.GetIndex().GetElement(comp) + outputRegion.GetSize().GetElement(comp) - 1), static_cast (inputIndex[comp] + m_SpatialRadius[comp] + 1)); regionSize[comp] = vcl_max(0l, indexRight - static_cast (regionIndex[comp]) + 1); } RegionType neighborhoodRegion; neighborhoodRegion.SetIndex(regionIndex); neighborhoodRegion.SetSize(regionSize); RealType weightSum = 0; RealVector shifts(jointDimension); // An iterator on the neighborhood of the current pixel (in joint // spatial-range domain) otb::Meanshift::FastImageRegionConstIterator it(jointImage, neighborhoodRegion); //itk::ImageRegionConstIterator it(jointImage, neighborhoodRegion); it.GoToBegin(); while (!it.IsAtEnd()) { const RealType *jointNeighbor = it.GetPixelPointer(); // Compute the squared norm of the difference // This is the L2 norm, TODO: replace by the templated norm RealType norm2 = 0; for (unsigned int comp = 0; comp < jointDimension; comp++) { shifts[comp] = jointNeighbor[comp] - jointPixel[comp]; double d = shifts[comp] / bandwidth[comp]; norm2 += d*d; } // Compute pixel weight from kernel const RealType weight = m_Kernel(norm2); /* // The following code is an alternative way to compute norm2 and weight // It separates the norms of spatial and range elements RealType spatialNorm2; RealType rangeNorm2; spatialNorm2 = 0; for (unsigned int comp = 0; comp < ImageDimension; comp++) { RealType d; d = jointNeighbor[comp] - jointPixel[comp]; spatialNorm2 += d*d; } if(spatialNorm2 >= 1.0) { weight = 0; } else { rangeNorm2 = 0; for (unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; comp++) { RealType d; d = jointNeighbor[ImageDimension + comp] - jointPixel[ImageDimension + comp]; rangeNorm2 += d*d; } weight = (rangeNorm2 <= 1.0)? 1.0 : 0.0; } */ // Update sum of weights weightSum += weight; // Update mean shift vector for (unsigned int comp = 0; comp < jointDimension; comp++) { meanShiftVector[comp] += weight * shifts[comp]; } ++it; } if (weightSum > 0) { for (unsigned int comp = 0; comp < jointDimension; comp++) { meanShiftVector[comp] = meanShiftVector[comp] / weightSum; } } } #if 0 // Calculates the mean shift vector at the position given by jointPixel template void MeanShiftSmoothingImageFilter::CalculateMeanShiftVectorBucket( const RealVector& jointPixel, RealVector& meanShiftVector) { const unsigned int jointDimension = ImageDimension + m_NumberOfComponentsPerPixel; RealType weightSum = 0; for (unsigned int comp = 0; comp < jointDimension; comp++) { meanShiftVector[comp] = 0; } RealVector jointNeighbor(ImageDimension + m_NumberOfComponentsPerPixel); InputIndexType index; for (unsigned int dim = 0; dim < ImageDimension; ++dim) { index[dim] = jointPixel[dim] * m_SpatialBandwidth + 0.5; } const std::vector neighborBuckets = m_BucketImage.GetNeighborhoodBucketListIndices( m_BucketImage.BucketIndexToBucketListIndex( m_BucketImage.GetBucketIndex( jointPixel, index))); unsigned int numNeighbors = m_BucketImage.GetNumberOfNeighborBuckets(); for (unsigned int neighborIndex = 0; neighborIndex < numNeighbors; ++neighborIndex) { const typename BucketImageType::BucketType & bucket = m_BucketImage.GetBucket(neighborBuckets[neighborIndex]); if (bucket.empty()) continue; typename BucketImageType::BucketType::const_iterator it = bucket.begin(); while (it != bucket.end()) { jointNeighbor.SetData(const_cast (*it)); // Compute the squared norm of the difference // This is the L2 norm, TODO: replace by the templated norm RealType norm2 = 0; for (unsigned int comp = 0; comp < jointDimension; comp++) { const RealType d = jointNeighbor[comp] - jointPixel[comp]; norm2 += d * d; } // Compute pixel weight from kernel const RealType weight = m_Kernel(norm2); // Update sum of weights weightSum += weight; // Update mean shift vector for (unsigned int comp = 0; comp < jointDimension; comp++) { meanShiftVector[comp] += weight * jointNeighbor[comp]; } ++it; } } if (weightSum > 0) { for (unsigned int comp = 0; comp < jointDimension; comp++) { meanShiftVector[comp] = meanShiftVector[comp] / weightSum - jointPixel[comp]; } } } #endif template void MeanShiftSmoothingImageFilter ::ThreadedGenerateData(const OutputRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // at the first iteration // Retrieve output images pointers typename OutputSpatialImageType::Pointer spatialOutput = this->GetSpatialOutput(); typename OutputImageType::Pointer rangeOutput = this->GetRangeOutput(); typename OutputIterationImageType::Pointer iterationOutput = this->GetIterationOutput(); typename OutputLabelImageType::Pointer labelOutput = this->GetLabelOutput(); // Get input image pointer typename InputImageType::ConstPointer input = this->GetInput(); // defines input and output iterators typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionIterator OutputSpatialIteratorType; typedef itk::ImageRegionIterator OutputIterationIteratorType; typedef itk::ImageRegionIterator OutputLabelIteratorType; const unsigned int jointDimension = ImageDimension + m_NumberOfComponentsPerPixel; typename OutputImageType::PixelType rangePixel(m_NumberOfComponentsPerPixel); typename OutputSpatialImageType::PixelType spatialPixel(ImageDimension); RealVector jointPixel(jointDimension); RealVector bandwidth(jointDimension); for (unsigned int comp = 0; comp < ImageDimension; comp++) bandwidth[comp] = m_SpatialBandwidth; itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); RegionType const& requestedRegion = input->GetRequestedRegion(); typedef itk::ImageRegionConstIteratorWithIndex JointImageIteratorType; JointImageIteratorType jointIt(m_JointImage, outputRegionForThread); OutputIteratorType rangeIt(rangeOutput, outputRegionForThread); OutputSpatialIteratorType spatialIt(spatialOutput, outputRegionForThread); OutputIterationIteratorType iterationIt(iterationOutput, outputRegionForThread); OutputLabelIteratorType labelIt(labelOutput, outputRegionForThread); typedef itk::ImageRegionIterator ModeTableImageIteratorType; ModeTableImageIteratorType modeTableIt(m_ModeTable, outputRegionForThread); jointIt.GoToBegin(); rangeIt.GoToBegin(); spatialIt.GoToBegin(); iterationIt.GoToBegin(); modeTableIt.GoToBegin(); labelIt.GoToBegin(); unsigned int iteration = 0; // Mean shift vector, updating the joint pixel at each iteration RealVector meanShiftVector(jointDimension); // Variables used by mode search optimization // List of indices where the current pixel passes through std::vector pointList; if (m_ModeSearch) pointList.resize(m_MaxIterationNumber); // Number of times an already processed candidate pixel is encountered, resulting in no // further computation (Used for statistics only) unsigned int numBreaks = 0; // index of the current pixel updated during the mean shift loop InputIndexType modeCandidate; for (; !jointIt.IsAtEnd(); ++jointIt, ++rangeIt, ++spatialIt, ++iterationIt, ++modeTableIt, ++labelIt, progress.CompletedPixel()) { // if pixel has been already processed (by mode search optimization), skip typename ModeTableImageType::InternalPixelType const& currentPixelMode = modeTableIt.Get(); if (m_ModeSearch && currentPixelMode == 1) { numBreaks++; continue; } bool hasConverged = false; // get input pixel in the joint spatial-range domain (with components // normalized by bandwidth) const RealVector &jointPixelVal = jointIt.Get(); // Pixel in the joint spatial-range domain for (unsigned int comp = 0; comp < jointDimension; comp++) jointPixel[comp] = jointPixelVal[comp]; for (unsigned int comp = ImageDimension; comp < jointDimension; comp++) bandwidth[comp] = m_RangeBandwidthRamp*jointPixel[comp]+m_RangeBandwidth; // index of the currently processed output pixel InputIndexType currentIndex = jointIt.GetIndex(); // Number of points currently in the pointList unsigned int pointCount = 0; // Note: used only in mode search optimization iteration = 0; while ((iteration < m_MaxIterationNumber) && (!hasConverged)) { if (m_ModeSearch) { // Find index of the pixel closest to the current jointPixel (not normalized by bandwidth) for (unsigned int comp = 0; comp < ImageDimension; comp++) { modeCandidate[comp] = vcl_floor(jointPixel[comp] - m_GlobalShift[comp] + 0.5); } // Check status of candidate mode // If pixel candidate has status 0 (no mode assigned) or 1 (mode assigned) // but not 2 (pixel in current search path), and pixel has actually moved // from its initial position, and pixel candidate is inside the output // region, then perform optimization tasks if (modeCandidate != currentIndex && m_ModeTable->GetPixel(modeCandidate) != 2 && outputRegionForThread.IsInside(modeCandidate)) { // Obtain the data point to see if it close to jointPixel RealType diff = 0; RealVector const& candidatePixel = m_JointImage->GetPixel(modeCandidate); for (unsigned int comp = ImageDimension; comp < jointDimension; comp++) { const RealType d = (candidatePixel[comp] - jointPixel[comp])/bandwidth[comp]; diff += d * d; } if (diff < 0.5) // Spectral value is close enough { // If no mode has been associated to the candidate pixel then // associate it to the upcoming mode if (m_ModeTable->GetPixel(modeCandidate) == 0) { // Add the candidate to the list of pixels that will be assigned the // finally calculated mode value pointList[pointCount++] = modeCandidate; m_ModeTable->SetPixel(modeCandidate, 2); } else // == 1 { // The candidate pixel has already been assigned to a mode // Assign the same value rangePixel = rangeOutput->GetPixel(modeCandidate); for (unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; comp++) { jointPixel[ImageDimension + comp] = rangePixel[comp]; } // Update the mode table because pixel will be assigned just now modeTableIt.Set(2); // m_ModeTable->SetPixel(currentIndex, 2); // bypass further calculation numBreaks++; break; } } } } // end if (m_ModeSearch) //Calculate meanShiftVector #if 0 if (m_BucketOptimization) { this->CalculateMeanShiftVectorBucket(jointPixel, meanShiftVector); } else { #endif this->CalculateMeanShiftVector(m_JointImage, jointPixel, requestedRegion, bandwidth, meanShiftVector); #if 0 } #endif // Compute mean shift vector squared norm (not normalized by bandwidth) // and add mean shift vector to current joint pixel double meanShiftVectorSqNorm = 0; for (unsigned int comp = 0; comp < jointDimension; comp++) { const double v = meanShiftVector[comp]; meanShiftVectorSqNorm += v * v; jointPixel[comp] += meanShiftVector[comp]; } //TODO replace SSD Test with templated metric hasConverged = meanShiftVectorSqNorm < m_Threshold; iteration++; } for (unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; comp++) { rangePixel[comp] = jointPixel[ImageDimension + comp]; } for (unsigned int comp = 0; comp < ImageDimension; comp++) { spatialPixel[comp] = jointPixel[comp] - currentIndex[comp] - m_GlobalShift[comp]; } rangeIt.Set(rangePixel); spatialIt.Set(spatialPixel); const typename OutputIterationImageType::PixelType iterationPixel = iteration; iterationIt.Set(iterationPixel); if (m_ModeSearch) { // Update the mode table now that the current pixel has been assigned modeTableIt.Set(1); // m_ModeTable->SetPixel(currentIndex, 1); // If the loop exited with hasConverged or too many iterations, then we have a new mode LabelType label; if (hasConverged || iteration == m_MaxIterationNumber) { m_NumLabels[threadId]++; label = m_NumLabels[threadId]; } else // the loop exited through a break. Use the already assigned mode label { label = labelOutput->GetPixel(modeCandidate); } labelIt.Set(label); // Also assign all points in the list to the same mode for (unsigned int i = 0; i < pointCount; i++) { rangeOutput->SetPixel(pointList[i], rangePixel); m_ModeTable->SetPixel(pointList[i], 1); labelOutput->SetPixel(pointList[i], label); } } else // if ModeSearch is not set LabelOutput can't be generated { LabelType labelZero = 0; labelIt.Set(labelZero); } } // std::cout << "numBreaks: " << numBreaks << " Break ratio: " << numBreaks / (RealType)outputRegionForThread.GetNumberOfPixels() << std::endl; } /* after threaded convergence test */ template void MeanShiftSmoothingImageFilter::AfterThreadedGenerateData() { typename OutputLabelImageType::Pointer labelOutput = this->GetLabelOutput(); typedef itk::ImageRegionIterator OutputLabelIteratorType; OutputLabelIteratorType labelIt(labelOutput, labelOutput->GetRequestedRegion()); // Reassign mode labels // Note: Labels are only computed when mode search optimization is enabled if (m_ModeSearch) { // New labels will be consecutive. The following vector contains the new // start label for each thread. itk::VariableLengthVector newLabelOffset; newLabelOffset.SetSize(this->GetNumberOfThreads()); newLabelOffset[0] = 0; for (itk::ThreadIdType i = 1; i < this->GetNumberOfThreads(); i++) { // Retrieve the number of labels in the thread by removing the threadId // from the most significant bits LabelType localNumLabel = m_NumLabels[i - 1] & ((static_cast (1) << (sizeof(LabelType) * 8 - m_ThreadIdNumberOfBits)) - static_cast (1)); newLabelOffset[i] = localNumLabel + newLabelOffset[i - 1]; } labelIt.GoToBegin(); while (!labelIt.IsAtEnd()) { LabelType const label = labelIt.Get(); // Get threadId from most significant bits const itk::ThreadIdType threadId = label >> (sizeof(LabelType) * 8 - m_ThreadIdNumberOfBits); // Relabeling // First get the label number by removing the threadId bits // Then add the label offset specific to the threadId LabelType newLabel = label & ((static_cast (1) << (sizeof(LabelType) * 8 - m_ThreadIdNumberOfBits)) - static_cast (1)); newLabel += newLabelOffset[threadId]; labelIt.Set(newLabel); ++labelIt; } } } template void MeanShiftSmoothingImageFilter::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Spatial bandwidth: " << m_SpatialBandwidth << std::endl; os << indent << "Range bandwidth: " << m_RangeBandwidth << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Smoothing/otb-module.cmake000066400000000000000000000004441301006202600237730ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes that allow image smoothing (it contains mean shift smoothing for instance).") otb_module(OTBSmoothing DEPENDS OTBImageBase OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/Smoothing/test/000077500000000000000000000000001301006202600216775ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Smoothing/test/CMakeLists.txt000066400000000000000000000131341301006202600244410ustar00rootroot00000000000000otb_module_test() set(OTBSmoothingTests otbSmoothingTestDriver.cxx otbMeanShiftSmoothingImageFilter.cxx otbMeanShiftSmoothingImageFilterSpatialStability.cxx otbMeanShiftSmoothingImageFilterNew.cxx otbMeanShiftSmoothingImageFilterThreading.cxx ) add_executable(otbSmoothingTestDriver ${OTBSmoothingTests}) target_link_libraries(otbSmoothingTestDriver ${OTBSmoothing-Test_LIBRARIES}) otb_module_target_label(otbSmoothingTestDriver) # Tests Declaration otb_add_test(NAME bfTvMeanShiftSmoothingImageFilterOptim COMMAND otbSmoothingTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvMeanShiftFilterSpectralOutputOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterSpectralOutputOptim.tif otbMeanShiftSmoothingImageFilter ${INPUTDATA}/MeanShiftTest.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterSpatialOutputOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterSpectralOutputOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterIterationOutputOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterLabelOutputOptim.tif 2 10 0.1 10 1 ) otb_add_test(NAME bfTuMeanShiftSmoothingImageFilterSPOT5 COMMAND otbSmoothingTestDriver otbMeanShiftSmoothingImageFilter ${INPUTDATA}/SPOT5_EXTRACTS/Arcachon/Arcachon_extrait_3852_3319_546_542.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpatialOutput_SPOT5.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpectralOutput_SPOT5.tif ${TEMP}/bfMeanShiftSmoothingImageFilterIterationOutput_SPOT5.tif ${TEMP}/bfMeanShiftSmoothingImageFilterLabelOutput_SPOT5.tif 4 10 0.1 100 ) otb_add_test(NAME bfTvMeanShiftSmoothingImageFilterNonOptim COMMAND otbSmoothingTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvMeanShiftFilterSpectralOutputNonOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterSpectralOutputNonOptim.tif otbMeanShiftSmoothingImageFilter ${INPUTDATA}/MeanShiftTest.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterSpatialOutputNonOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterSpectralOutputNonOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterIterationOutputNonOptim.tif ${TEMP}/bfTvMeanShiftSmoothingImageFilterLabelOutputNonOptim.tif 2 10 0.1 10 0 ) otb_add_test(NAME bfTuMeanShiftSmoothingImageFilterROIQBMul4 COMMAND otbSmoothingTestDriver otbMeanShiftSmoothingImageFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpatialOutput_ROIQBMul4.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpectralOutput_ROIQBMul4.tif ${TEMP}/bfMeanShiftSmoothingImageFilterIterationOutput_ROIQBMul4.tif ${TEMP}/bfMeanShiftSmoothingImageFilterLabelOutput_ROIQBMul4.tif 4 50 0.1 100 ) otb_add_test(NAME bfTvMeanShiftSmoothingImageFilterQBSuburbNonOptim COMMAND otbSmoothingTestDriver --compare-n-images ${EPSILON_7} 3 ${BASELINE}/bfMeanShiftSmoothingImageFilterSpatialOutput_QBSuburbNonOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpatialOutput_QBSuburbNonOptim.tif ${BASELINE}/bfMeanShiftSmoothingImageFilterSpectralOutput_QBSuburbNonOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpectralOutput_QBSuburbNonOptim.tif ${BASELINE}/bfMeanShiftSmoothingImageFilterIterationOutput_QBSuburbNonOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterIterationOutput_QBSuburbNonOptim.tif otbMeanShiftSmoothingImageFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfMeanShiftSmoothingImageFilterSpatialOutput_QBSuburbNonOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpectralOutput_QBSuburbNonOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterIterationOutput_QBSuburbNonOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterLabelOutput_QBSuburbNonOptim.tif 4 25 0.1 100 0 ) otb_add_test(NAME bfTuMeanShiftSmoothingImageFilterQBSuburbOptim COMMAND otbSmoothingTestDriver otbMeanShiftSmoothingImageFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfMeanShiftSmoothingImageFilterSpatialOutput_QBSuburbOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpectralOutput_QBSuburbOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterIterationOutput_QBSuburbOptim.tif ${TEMP}/bfMeanShiftSmoothingImageFilterLabelOutput_QBSuburbOptim.tif 4 25 0.1 100 1 ) otb_add_test(NAME bfTvMeanShiftSmoothingImageFilterQBPAN COMMAND otbSmoothingTestDriver otbMeanShiftSmoothingImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpatialOutput_PAN.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpectralOutput_PAN.tif ${TEMP}/bfMeanShiftSmoothingImageFilterIterationOutput_PAN.tif ${TEMP}/bfMeanShiftSmoothingImageFilterLabelOutput_PAN.tif 5 15 1.0 100 ) otb_add_test(NAME bfTuMeanShiftSmoothingImageFilterQBRoad COMMAND otbSmoothingTestDriver otbMeanShiftSmoothingImageFilter ${INPUTDATA}/qb_RoadExtract.img ${TEMP}/bfMeanShiftSmoothingImageFilterSpatialOutput_QBRoad.tif ${TEMP}/bfMeanShiftSmoothingImageFilterSpectralOutput_QBRoad.tif ${TEMP}/bfMeanShiftSmoothingImageFilterIterationOutput_QBRoad.tif ${TEMP}/bfMeanShiftSmoothingImageFilterLabelOutput_QBRoad.tif 4 30 0.1 100 ) otb_add_test(NAME bfTuMeanShiftSmoothingImageFilterSpatialStability COMMAND otbSmoothingTestDriver otbMeanShiftSmoothingImageFilterSpatialStability ${INPUTDATA}/ROI_QB_MUL_4.tif 4 50 0.1 40 100 100 512 512 ) otb_add_test(NAME bfTvMeanShiftSmoothingImageFilterThreadingNonOpt COMMAND otbSmoothingTestDriver --compare-image ${EPSILON_7} ${TEMP}/bfMeanShiftSmoothingImageFilter2SingleThreading_SPOT5.tif ${TEMP}/bfMeanShiftSmoothingImageFilter2MultiThreading_SPOT5.tif otbMeanShiftSmoothingImageFilterThreading ${INPUTDATA}/SPOT5_EXTRACTS/Arcachon/Arcachon_extrait_3852_3319_546_542.tif ${TEMP}/bfMeanShiftSmoothingImageFilter2SingleThreading_SPOT5.tif ${TEMP}/bfMeanShiftSmoothingImageFilter2MultiThreading_SPOT5.tif 4 10 0 ) OTB-release-5.8/Modules/Filtering/Smoothing/test/otbMeanShiftSmoothingImageFilter.cxx000066400000000000000000000075141301006202600310160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMeanShiftSmoothingImageFilter.h" int otbMeanShiftSmoothingImageFilter(int argc, char * argv[]) { if (argc != 10 && argc != 11) { std::cerr << "Usage: " << argv[0] << " infname spatialfname spectralfname iterationfname labelfname spatialBandwidth rangeBandwidth threshold maxiterationnumber (usemodesearch)" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * spatialfname = argv[2]; const char * spectralfname = argv[3]; const char * iterationfname = argv[4]; const char * labelfname = argv[5]; const double spatialBandwidth = atof(argv[6]); const double rangeBandwidth = atof(argv[7]); const double threshold = atof(argv[8]); const unsigned int maxiterationnumber = atoi(argv[9]); bool usemodesearch = true; if(argc==11) { usemodesearch = atoi(argv[10])!=0; } /* maxit - threshold */ const unsigned int Dimension = 2; typedef float PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MeanShiftSmoothingImageFilter FilterType; typedef FilterType::OutputIterationImageType IterationImageType; typedef otb::ImageFileWriter IterationWriterType; typedef FilterType::OutputSpatialImageType SpatialImageType; typedef otb::ImageFileWriter SpatialWriterType; typedef FilterType::OutputLabelImageType LabelImageType; typedef otb::ImageFileWriter LabelWriterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Set filter parameters filter->SetSpatialBandwidth(spatialBandwidth); filter->SetRangeBandwidth(rangeBandwidth); filter->SetThreshold(threshold); filter->SetMaxIterationNumber(maxiterationnumber); filter->SetInput(reader->GetOutput()); filter->SetModeSearch(usemodesearch); //filter->SetNumberOfThreads(1); SpatialWriterType::Pointer writer1 = SpatialWriterType::New(); WriterType::Pointer writer2 = WriterType::New(); IterationWriterType::Pointer writer4 = IterationWriterType::New(); writer1->SetFileName(spatialfname); writer2->SetFileName(spectralfname); writer4->SetFileName(iterationfname); writer1->SetInput(filter->GetSpatialOutput()); writer2->SetInput(filter->GetRangeOutput()); writer4->SetInput(filter->GetIterationOutput()); if (usemodesearch) //mode label image is only available with mode search optimization { LabelWriterType::Pointer writer5 = LabelWriterType::New(); writer5->SetFileName(labelfname); writer5->SetInput(filter->GetLabelOutput()); writer5->Update(); } writer1->Update(); writer2->Update(); writer4->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Smoothing/test/otbMeanShiftSmoothingImageFilterNew.cxx000066400000000000000000000024101301006202600314560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMeanShiftSmoothingImageFilter.h" int otbMeanShiftSmoothingImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef short PixelType; typedef double OutputPixelType; typedef otb::VectorImage OutputImageType; typedef otb::VectorImage ImageType; typedef otb::MeanShiftSmoothingImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbMeanShiftSmoothingImageFilterSpatialStability.cxx000066400000000000000000000155411301006202600341410ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Smoothing/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbMeanShiftSmoothingImageFilter.h" #include "otbDifferenceImageFilter.h" #include "otbMultiChannelExtractROI.h" #include int otbMeanShiftSmoothingImageFilterSpatialStability(int argc, char * argv[]) { if (argc != 10) { std::cerr << "Usage: " << argv[0] << " infname spatialdifffname spectraldifffname spatialBandwidth rangeBandwidth threshold maxiterationnumber startx starty sizex sizey" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const double spatialBandwidth = atof(argv[2]); const double rangeBandwidth = atof(argv[3]); const double threshold = atof(argv[4]); const unsigned int maxiterationnumber = atoi(argv[5]); const unsigned int startX = atoi(argv[6]); const unsigned int startY = atoi(argv[7]); const unsigned int sizeX = atoi(argv[8]); const unsigned int sizeY = atoi(argv[9]); /* maxit - threshold */ const unsigned int Dimension = 2; typedef float PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::MeanShiftSmoothingImageFilter FilterType; typedef FilterType::OutputSpatialImageType SpatialImageType; typedef SpatialImageType::InternalPixelType SpatialPixelType; typedef otb::MultiChannelExtractROI ExtractROIFilterType; typedef otb::MultiChannelExtractROI SpatialExtractROIFilterType; typedef otb::DifferenceImageFilter SubtractFilterType; typedef otb::DifferenceImageFilter SpatialSubtractFilterType; // Instantiating object FilterType::Pointer MSfilter = FilterType::New(); FilterType::Pointer MSfilterROI = FilterType::New(); ExtractROIFilterType::Pointer filterROI = ExtractROIFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); //first pipeline // Set filter parameters MSfilter->SetSpatialBandwidth(spatialBandwidth); MSfilter->SetRangeBandwidth(rangeBandwidth); MSfilter->SetThreshold(threshold); MSfilter->SetMaxIterationNumber(maxiterationnumber); MSfilter->SetInput(reader->GetOutput()); MSfilter->SetModeSearch(false); MSfilter->Update(); //second pipeline filterROI->SetInput(reader->GetOutput()); filterROI->SetStartX(startX); filterROI->SetStartY(startY); filterROI->SetSizeX(sizeX); filterROI->SetSizeY(sizeY); filterROI->UpdateOutputInformation(); MSfilterROI->SetSpatialBandwidth(spatialBandwidth); MSfilterROI->SetRangeBandwidth(rangeBandwidth); MSfilterROI->SetThreshold(threshold); MSfilterROI->SetMaxIterationNumber(maxiterationnumber); MSfilterROI->SetInput(filterROI->GetOutput()); MSfilterROI->SetModeSearch(false); // GlobalShift ensure spatial stability ImageType::IndexType globalShift; globalShift[0]=startX; globalShift[1]=startY; MSfilterROI->SetGlobalShift(globalShift); //compare output const unsigned int border=maxiterationnumber*spatialBandwidth+1; const unsigned int startXROI2=border; const unsigned int startXROI=border+startX; const unsigned int startYROI2=border; const unsigned int startYROI=border+startY; const unsigned int sizeXROI=sizeX-2*border; const unsigned int sizeYROI=sizeY-2*border; SpatialExtractROIFilterType::Pointer filterROISpatial1 = SpatialExtractROIFilterType::New(); filterROISpatial1->SetInput(MSfilter->GetSpatialOutput()); filterROISpatial1->SetStartX(startXROI); filterROISpatial1->SetStartY(startYROI); filterROISpatial1->SetSizeX(sizeXROI); filterROISpatial1->SetSizeY(sizeYROI); SpatialExtractROIFilterType::Pointer filterROISpatial2 = SpatialExtractROIFilterType::New(); filterROISpatial2->SetInput(MSfilterROI->GetSpatialOutput()); filterROISpatial2->SetStartX(startXROI2); filterROISpatial2->SetStartY(startYROI2); filterROISpatial2->SetSizeX(sizeXROI); filterROISpatial2->SetSizeY(sizeYROI); SpatialSubtractFilterType::Pointer filterSubSpatial = SpatialSubtractFilterType::New(); filterSubSpatial->SetValidInput(filterROISpatial1->GetOutput()); filterSubSpatial->SetTestInput(filterROISpatial2->GetOutput()); filterSubSpatial->Update(); SpatialImageType::PixelType spatialOutputDiff = filterSubSpatial->GetTotalDifference(); ExtractROIFilterType::Pointer filterROISpectral1 = ExtractROIFilterType::New(); filterROISpectral1->SetInput(MSfilter->GetRangeOutput()); filterROISpectral1->SetStartX(startXROI); filterROISpectral1->SetStartY(startYROI); filterROISpectral1->SetSizeX(sizeXROI); filterROISpectral1->SetSizeY(sizeYROI); ExtractROIFilterType::Pointer filterROISpectral2 = ExtractROIFilterType::New(); filterROISpectral2->SetInput(MSfilterROI->GetRangeOutput()); filterROISpectral2->SetStartX(startXROI2); filterROISpectral2->SetStartY(startYROI2); filterROISpectral2->SetSizeX(sizeXROI); filterROISpectral2->SetSizeY(sizeYROI); SubtractFilterType::Pointer filterSubSpectral = SubtractFilterType::New(); filterSubSpectral->SetValidInput(filterROISpectral1->GetOutput()); filterSubSpectral->SetTestInput(filterROISpectral2->GetOutput()); filterSubSpectral->Update(); ImageType::PixelType spectralOutputDiff = filterSubSpectral->GetTotalDifference(); bool spatialUnstable = false; bool spectralUnstable = false; for(unsigned int i = 0; i < spatialOutputDiff.Size(); ++i) { if(spatialOutputDiff[i] > 0) { spatialUnstable = true; } } for(unsigned int i = 0; i < spectralOutputDiff.Size(); ++i) { if(spectralOutputDiff[i] > 0) { spectralUnstable = true; } } std::cerr< ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MeanShiftSmoothingImageFilter FilterType; // Instantiating object FilterType::Pointer filterSingle = FilterType::New(); FilterType::Pointer filterMulti = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Set filter parameters filterSingle->SetSpatialBandwidth(spatialBandwidth); filterSingle->SetRangeBandwidth(rangeBandwidth); filterSingle->SetInput(reader->GetOutput()); filterSingle->SetModeSearch(useModeSearch); filterSingle->SetNumberOfThreads(1); filterMulti->SetSpatialBandwidth(spatialBandwidth); filterMulti->SetRangeBandwidth(rangeBandwidth); filterMulti->SetInput(reader->GetOutput()); filterMulti->SetModeSearch(useModeSearch); WriterType::Pointer writerSingle = WriterType::New(); WriterType::Pointer writerMulti = WriterType::New(); writerSingle->SetFileName(outputSingleThreadFileName); writerMulti->SetFileName(outputMultiThreadFileName); writerSingle->SetInput(filterSingle->GetRangeOutput()); writerMulti->SetInput(filterMulti->GetRangeOutput()); writerSingle->Update(); writerMulti->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Smoothing/test/otbSmoothingTestDriver.cxx000066400000000000000000000004321301006202600271120ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMeanShiftSmoothingImageFilter); REGISTER_TEST(otbMeanShiftSmoothingImageFilterSpatialStability); REGISTER_TEST(otbMeanShiftSmoothingImageFilterNew); REGISTER_TEST(otbMeanShiftSmoothingImageFilterThreading); } OTB-release-5.8/Modules/Filtering/Statistics/000077500000000000000000000000001301006202600211035ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/CMakeLists.txt000066400000000000000000000001251301006202600236410ustar00rootroot00000000000000project(OTBStatistics) set(OTBStatistics_LIBRARIES OTBStatistics) otb_module_impl() OTB-release-5.8/Modules/Filtering/Statistics/include/000077500000000000000000000000001301006202600225265ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/include/otbConcatenateSampleListFilter.h000066400000000000000000000056221301006202600310010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateSampleListFilter_h #define otbConcatenateSampleListFilter_h #include "otbListSampleToListSampleFilter.h" namespace otb { namespace Statistics { /** \class ConcatenateSampleListFilter * \brief This class concatenates several sample list into a single one. * * For the sake of genericity on the MeasurementVector type, no casting is applied so * this filter does not allow different input/output SampleList. * * \sa ListSampleToListSampleFilter * * \ingroup OTBStatistics */ template < class TSampleList > class ITK_EXPORT ConcatenateSampleListFilter : public otb::Statistics::ListSampleToListSampleFilter { public: /** Standard class typedefs */ typedef ConcatenateSampleListFilter Self; typedef otb::Statistics::ListSampleToListSampleFilter Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ConcatenateSampleListFilter, otb::Statistics::ListSampleToListSampleFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); /** SampleList typedefs */ typedef TSampleList SampleListType; typedef typename SampleListType::Pointer SampleListPointer; typedef typename SampleListType::ConstPointer SampleListConstPointer; typedef typename SampleListType::MeasurementVectorType MeasurementVectorType; typedef typename MeasurementVectorType::ValueType ValueType; /** Method to set/get the input list sample */ void AddInput( const SampleListType * inputPtr ); using Superclass::AddInput; protected: /** This method causes the filter to generate its output. */ void GenerateData() ITK_OVERRIDE; ConcatenateSampleListFilter(); ~ConcatenateSampleListFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ConcatenateSampleListFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; // end of class ImageToListGenerator } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConcatenateSampleListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbConcatenateSampleListFilter.txx000066400000000000000000000061321301006202600313720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateSampleListFilter_txx #define otbConcatenateSampleListFilter_txx #include "otbConcatenateSampleListFilter.h" #include "itkProgressReporter.h" namespace otb { namespace Statistics { template < class TSampleList> ConcatenateSampleListFilter ::ConcatenateSampleListFilter() {} template void ConcatenateSampleListFilter ::AddInput( const SampleListType * inputPtr ) { // Process object is not const-correct so the const_cast is required here Superclass::ProcessObject::AddInput(const_cast< SampleListType* >( inputPtr ) ); } template void ConcatenateSampleListFilter ::GenerateData() { // Retrieve output pointers SampleListPointer outputSampleListPtr = this->GetOutput(); // Clear any previous output outputSampleListPtr->Clear(); // Set the measurement vector size (based on the first listsample) outputSampleListPtr->SetMeasurementVectorSize(static_cast( Superclass::ProcessObject::GetInput(0))->GetMeasurementVectorSize()); // Evaluate the total number of samples for progress reporting unsigned long totalNumberOfSamples = 0; for(unsigned int inputIndex = 0; inputIndexGetNumberOfInputs(); ++inputIndex) { // Retrieve the ListSample typename SampleListType::ConstPointer inputPtr = static_cast (Superclass::ProcessObject::GetInput(inputIndex)); totalNumberOfSamples += inputPtr->Size(); } // Set-up progress reporting itk::ProgressReporter progress(this, 0, totalNumberOfSamples); for(unsigned int inputIndex = 0; inputIndexGetNumberOfInputs(); ++inputIndex) { // Retrieve the ListSample typename SampleListType::ConstPointer inputSampleListPtr = static_cast (Superclass::ProcessObject::GetInput(inputIndex)); typename SampleListType::ConstIterator inputIt = inputSampleListPtr->Begin(); // Iterate on the InputSampleList while(inputIt != inputSampleListPtr->End()) { // Add the current output sample to the output SampleList outputSampleListPtr->PushBack(inputIt.GetMeasurementVector()); // Update progress progress.CompletedPixel(); ++inputIt; } } } template void ConcatenateSampleListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); os<GetNumberOfInputs(); } } // End namespace Statistics } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbContinuousMinimumMaximumImageCalculator.h000066400000000000000000000122661301006202600334300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbContinuousMinimumMaximumImageCalculator_h #define otbContinuousMinimumMaximumImageCalculator_h #include "itkObject.h" #include "itkObjectFactory.h" #include "itkNumericTraits.h" namespace otb { /** \class ContinuousMinimumMaximumImageCalculator * \brief Compute the continuous maximum and the minimum of an image * * To compute the continuous maximum and the minimum of an image, this * class uses a simple polynomial interpolation. * * First traditional discrete maximum and minimum are found. Then a second * order polynomial is fitted between these extrema and their neighboring * pixels. * * The continuous extrema is assumed to be at the zero of the first order * derivative of this polynom. * * If we denote \f$ (x_0, y_0) \f$ the extrema and \f$ (x_{-1}, y_{-1}) \f$ and * \f$ (x_1, y_1) \f$ its neighbor, the second degree polynom verify the * following equations: * * * \f[ * y_{-1} = a*x_{-1}^2 + b*x_{-1} +c * y_0 = a*x_0^2 + b*x_0 +c * y_1 = a*x_1^2 + b*x_1 +c * \f] * * The maximum is at \f$ -b/2a \f$ with is * \f$ -\frac{(y_1-y_{-1})}{(2*(y_{-1}+y_1-2*y_0))} \f$ * * Remark: image is assumed to be 2 dimensionnal * * * * \ingroup OTBStatistics */ template class ITK_EXPORT ContinuousMinimumMaximumImageCalculator : public itk::Object { public: /** Standard class typedefs. */ typedef ContinuousMinimumMaximumImageCalculator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ContinuousMinimumMaximumImageCalculator, Object); /** Type definition for the input image. */ typedef TInputImage ImageType; /** Pointer type for the image. */ typedef typename TInputImage::Pointer ImagePointer; /** Const Pointer type for the image. */ typedef typename TInputImage::ConstPointer ImageConstPointer; /** Type definition for the input image pixel type. */ typedef typename TInputImage::PixelType PixelType; /** Type definition for the input image real pixel type. */ typedef typename itk::NumericTraits::RealType RealPixelType; /** Type definition for the input image index type. */ typedef typename TInputImage::IndexType IndexType; /** Type definition for the input image index type. */ typedef typename TInputImage::PointType ContinuousIndexType; /** Type definition for the input image region type. */ typedef typename TInputImage::RegionType RegionType; /** Set the input image. */ itkSetConstObjectMacro(Image, ImageType); /** Compute the minimum value of intensity of the input image. */ void ComputeMinimum(void); /** Compute the maximum value of intensity of the input image. */ void ComputeMaximum(void); /** Compute the minimum and maximum values of intensity of the input image. */ void Compute(void); /** Return the minimum intensity value. */ itkGetMacro(Minimum, PixelType); /** Return the maximum intensity value. */ itkGetMacro(Maximum, PixelType); /** Return the index of the minimum intensity value. */ itkGetConstReferenceMacro(IndexOfMinimum, IndexType); /** Return the index of the maximum intensity value. */ itkGetConstReferenceMacro(IndexOfMaximum, IndexType); /** Return the index of the minimum intensity value. */ itkGetConstReferenceMacro(ContinuousIndexOfMinimum, ContinuousIndexType); /** Return the index of the maximum intensity value. */ itkGetConstReferenceMacro(ContinuousIndexOfMaximum, ContinuousIndexType); /** Set the region over which the values will be computed */ void SetRegion(const RegionType& region); protected: ContinuousMinimumMaximumImageCalculator(); ~ContinuousMinimumMaximumImageCalculator() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; PixelType m_Minimum; PixelType m_Maximum; ImageConstPointer m_ContinuousImage; IndexType m_IndexOfMinimum; IndexType m_IndexOfMaximum; ContinuousIndexType m_ContinuousIndexOfMinimum; ContinuousIndexType m_ContinuousIndexOfMaximum; ImageConstPointer m_Image; RegionType m_Region; bool m_RegionSetByUser; private: ContinuousMinimumMaximumImageCalculator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbContinuousMinimumMaximumImageCalculator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbContinuousMinimumMaximumImageCalculator.txx000066400000000000000000000217361301006202600340260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbContinuousMinimumMaximumImageCalculator_txx #define otbContinuousMinimumMaximumImageCalculator_txx #include "otbContinuousMinimumMaximumImageCalculator.h" #include "itkImageRegionConstIteratorWithIndex.h" namespace otb { /* * Constructor */ template ContinuousMinimumMaximumImageCalculator ::ContinuousMinimumMaximumImageCalculator() { m_Image = TInputImage::New(); m_Maximum = itk::NumericTraits::NonpositiveMin(); m_Minimum = itk::NumericTraits::max(); m_IndexOfMinimum.Fill(0); m_IndexOfMaximum.Fill(0); m_RegionSetByUser = false; } /* * Compute Min and Max of m_Image */ template void ContinuousMinimumMaximumImageCalculator ::Compute(void) { if (!m_RegionSetByUser) { m_Region = m_Image->GetRequestedRegion(); } itk::ImageRegionConstIteratorWithIndex it(m_Image, m_Region); m_Maximum = itk::NumericTraits::NonpositiveMin(); m_Minimum = itk::NumericTraits::max(); while (!it.IsAtEnd()) { const RealPixelType value = it.Get(); if (value > static_cast(m_Maximum)) { m_Maximum = static_cast(value); m_IndexOfMaximum = it.GetIndex(); } if (value < static_cast(m_Minimum)) { m_Minimum = static_cast(value); m_IndexOfMinimum = it.GetIndex(); } ++it; } IndexType indexNeighbor; { //Continuous Minimum calculation //Compute horizontal offset indexNeighbor[0] = m_IndexOfMinimum[0] - 1; indexNeighbor[1] = m_IndexOfMinimum[1]; it.SetIndex(indexNeighbor); const RealPixelType leftValue = it.Get(); indexNeighbor[0] = m_IndexOfMinimum[0] + 1; indexNeighbor[1] = m_IndexOfMinimum[1]; it.SetIndex(indexNeighbor); const RealPixelType rightValue = it.Get(); double hOffset = -(rightValue - leftValue) / (2 * (rightValue + leftValue - 2 * m_Minimum)); //Compute vertical offset indexNeighbor[0] = m_IndexOfMinimum[0]; indexNeighbor[1] = m_IndexOfMinimum[1] - 1; it.SetIndex(indexNeighbor); const RealPixelType topValue = it.Get(); indexNeighbor[0] = m_IndexOfMinimum[0]; indexNeighbor[1] = m_IndexOfMinimum[1] + 1; it.SetIndex(indexNeighbor); const RealPixelType bottomValue = it.Get(); double vOffset = -(bottomValue - topValue) / (2 * (bottomValue + topValue - 2 * m_Minimum)); m_ContinuousIndexOfMinimum[0] = m_IndexOfMinimum[0] + hOffset; m_ContinuousIndexOfMinimum[1] = m_IndexOfMinimum[1] + vOffset; } { //Continuous Maximum calculation //Compute horizontal offset indexNeighbor[0] = m_IndexOfMaximum[0] - 1; indexNeighbor[1] = m_IndexOfMaximum[1]; it.SetIndex(indexNeighbor); const RealPixelType leftValue = it.Get(); indexNeighbor[0] = m_IndexOfMaximum[0] + 1; indexNeighbor[1] = m_IndexOfMaximum[1]; it.SetIndex(indexNeighbor); const RealPixelType rightValue = it.Get(); double hOffset = -(rightValue - leftValue) / (2 * (rightValue + leftValue - 2 * m_Maximum)); //Compute vertical offset indexNeighbor[0] = m_IndexOfMaximum[0]; indexNeighbor[1] = m_IndexOfMaximum[1] - 1; it.SetIndex(indexNeighbor); const RealPixelType topValue = it.Get(); indexNeighbor[0] = m_IndexOfMaximum[0]; indexNeighbor[1] = m_IndexOfMaximum[1] + 1; it.SetIndex(indexNeighbor); const RealPixelType bottomValue = it.Get(); double vOffset = -(bottomValue - topValue) / (2 * (bottomValue + topValue - 2 * m_Maximum)); m_ContinuousIndexOfMaximum[0] = m_IndexOfMaximum[0] + hOffset; m_ContinuousIndexOfMaximum[1] = m_IndexOfMaximum[1] + vOffset; } } /* * Compute the minimum intensity value of the image */ template void ContinuousMinimumMaximumImageCalculator ::ComputeMinimum(void) { if (!m_RegionSetByUser) { m_Region = m_Image->GetRequestedRegion(); } itk::ImageRegionConstIteratorWithIndex it(m_Image, m_Region); m_Minimum = itk::NumericTraits::max(); while (!it.IsAtEnd()) { const RealPixelType value = it.Get(); if (value < static_cast(m_Minimum)) { m_Minimum = static_cast(value); m_IndexOfMinimum = it.GetIndex(); } ++it; } IndexType indexNeighbor; //Compute horizontal offset indexNeighbor[0] = m_IndexOfMinimum[0] - 1; indexNeighbor[1] = m_IndexOfMinimum[1]; it.SetIndex(indexNeighbor); const RealPixelType leftValue = it.Get(); indexNeighbor[0] = m_IndexOfMinimum[0] + 1; indexNeighbor[1] = m_IndexOfMinimum[1]; it.SetIndex(indexNeighbor); const RealPixelType rightValue = it.Get(); double hOffset = -(rightValue - leftValue) / (2 * (rightValue + leftValue - 2 * m_Minimum)); //Compute vertical offset indexNeighbor[0] = m_IndexOfMinimum[0]; indexNeighbor[1] = m_IndexOfMinimum[1] - 1; it.SetIndex(indexNeighbor); const RealPixelType topValue = it.Get(); indexNeighbor[0] = m_IndexOfMinimum[0]; indexNeighbor[1] = m_IndexOfMinimum[1] + 1; it.SetIndex(indexNeighbor); const RealPixelType bottomValue = it.Get(); double vOffset = -(bottomValue - topValue) / (2 * (bottomValue + topValue - 2 * m_Minimum)); m_ContinuousIndexOfMinimum[0] = m_IndexOfMinimum[0] + hOffset; m_ContinuousIndexOfMinimum[1] = m_IndexOfMinimum[1] + vOffset; } /* * Compute the maximum intensity value of the image */ template void ContinuousMinimumMaximumImageCalculator ::ComputeMaximum(void) { if (!m_RegionSetByUser) { m_Region = m_Image->GetRequestedRegion(); } itk::ImageRegionConstIteratorWithIndex it(m_Image, m_Region); m_Maximum = itk::NumericTraits::NonpositiveMin(); while (!it.IsAtEnd()) { const RealPixelType value = it.Get(); if (value > static_cast(m_Maximum)) { m_Maximum = static_cast(value); m_IndexOfMaximum = it.GetIndex(); } ++it; } //Solve equations a, b, c // y0 = a*x0^2 + b*x0 +c // y1 = a*x1^2 + b*x1 +c // y2 = a*x2^2 + b*x2 +c // // y0 = a - b +c // y1 = c // y2 = a + b +c // // // Max is at -b/2a // -(y2-y0)/(2*(y0+y2-2y1)) IndexType indexNeighbor; //Compute horizontal offset indexNeighbor[0] = m_IndexOfMaximum[0] - 1; indexNeighbor[1] = m_IndexOfMaximum[1]; it.SetIndex(indexNeighbor); const RealPixelType leftValue = it.Get(); indexNeighbor[0] = m_IndexOfMaximum[0] + 1; indexNeighbor[1] = m_IndexOfMaximum[1]; it.SetIndex(indexNeighbor); const RealPixelType rightValue = it.Get(); double hOffset = -(rightValue - leftValue) / (2 * (rightValue + leftValue - 2 * m_Maximum)); //Compute vertical offset indexNeighbor[0] = m_IndexOfMaximum[0]; indexNeighbor[1] = m_IndexOfMaximum[1] - 1; it.SetIndex(indexNeighbor); const RealPixelType topValue = it.Get(); indexNeighbor[0] = m_IndexOfMaximum[0]; indexNeighbor[1] = m_IndexOfMaximum[1] + 1; it.SetIndex(indexNeighbor); const RealPixelType bottomValue = it.Get(); double vOffset = -(bottomValue - topValue) / (2 * (bottomValue + topValue - 2 * m_Maximum)); m_ContinuousIndexOfMaximum[0] = m_IndexOfMaximum[0] + hOffset; m_ContinuousIndexOfMaximum[1] = m_IndexOfMaximum[1] + vOffset; } template void ContinuousMinimumMaximumImageCalculator ::SetRegion(const RegionType& region) { m_Region = region; m_RegionSetByUser = true; } template void ContinuousMinimumMaximumImageCalculator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Minimum: " << static_cast::PrintType>(m_Minimum) << std::endl; os << indent << "Maximum: " << static_cast::PrintType>(m_Maximum) << std::endl; os << indent << "Index of Minimum: " << m_IndexOfMinimum << std::endl; os << indent << "Index of Maximum: " << m_IndexOfMaximum << std::endl; os << indent << "Continuous Index of Minimum: " << m_ContinuousIndexOfMinimum << std::endl; os << indent << "Continuous Index of Maximum: " << m_ContinuousIndexOfMaximum << std::endl; os << indent << "Image: " << std::endl; m_Image->Print(os, indent.GetNextIndent()); os << indent << "Region: " << std::endl; m_Region.Print(os, indent.GetNextIndent()); os << indent << "Region set by User: " << m_RegionSetByUser << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbGaussianAdditiveNoiseSampleListFilter.h000066400000000000000000000106241301006202600327750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGaussianAdditiveNoiseSampleListFilter_h #define otbGaussianAdditiveNoiseSampleListFilter_h #include "otbListSampleToListSampleFilter.h" namespace otb { namespace Statistics { /** \class GaussianAdditiveNoiseSampleListFilter * \brief This class generate a noised version of the input sample list * * For each component of the samples, a white gaussian random is added. * * It use the MersenneTwisterRandomVariateGenerator to generate a * sequence of numbers following the normal law considered as White * Gaussian Noise. * Mean and Variance are set via the methods SetMean() and SetVariance(). * The input SampleList can be noised m_NumberOfIteration times via the * method SetNumberOfIteration() * * \sa ListSampleToListSampleFilter * * \ingroup OTBStatistics */ template < class TInputSampleList, class TOutputSampleList = TInputSampleList > class ITK_EXPORT GaussianAdditiveNoiseSampleListFilter : public otb::Statistics::ListSampleToListSampleFilter { public: /** Standard class typedefs */ typedef GaussianAdditiveNoiseSampleListFilter Self; typedef otb::Statistics::ListSampleToListSampleFilter Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(GaussianAdditiveNoiseSampleListFilter, otb::Statistics::ListSampleToListSampleFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputSampleList typedefs */ typedef TInputSampleList InputSampleListType; typedef typename InputSampleListType::Pointer InputSampleListPointer; typedef typename InputSampleListType::ConstPointer InputSampleListConstPointer; typedef typename InputSampleListType::MeasurementVectorType InputMeasurementVectorType; typedef typename InputMeasurementVectorType::ValueType InputValueType; /** OutputSampleList typedefs */ typedef TOutputSampleList OutputSampleListType; typedef typename OutputSampleListType::Pointer OutputSampleListPointer; typedef typename OutputSampleListType::ConstPointer OutputSampleListConstPointer; typedef typename OutputSampleListType::MeasurementVectorType OutputMeasurementVectorType; typedef typename OutputMeasurementVectorType::ValueType OutputValueType; /** Set/Get the Shifts for this sample list */ itkSetMacro(Mean, double); itkGetMacro(Mean, double); /** Set/Get the Scales for this sample list */ itkSetMacro(Variance, double); itkGetMacro(Variance, double); /** Set how many times the ListSample must be noised */ itkSetMacro(NumberOfIteration, unsigned int); itkGetMacro(NumberOfIteration, unsigned int); protected: /** This method causes the filter to generate its output. */ void GenerateData() ITK_OVERRIDE; /** Generate a white gaussian noise with mean m_Mean and variance * m_Variance */ void GenerateRandomSequence(); GaussianAdditiveNoiseSampleListFilter(); ~GaussianAdditiveNoiseSampleListFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GaussianAdditiveNoiseSampleListFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented // Mean and variance for the white gaussian noise to generate double m_Mean; double m_Variance; std::vector m_WhiteGaussianNoiseCoefficients; unsigned int m_NumberOfIteration; }; // end of class ImageToListGenerator } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGaussianAdditiveNoiseSampleListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbGaussianAdditiveNoiseSampleListFilter.txx000066400000000000000000000101711301006202600333660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGaussianAdditiveNoiseSampleListFilter_txx #define otbGaussianAdditiveNoiseSampleListFilter_txx #include "otbGaussianAdditiveNoiseSampleListFilter.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "itkProgressReporter.h" namespace otb { namespace Statistics { template < class TInputSampleList, class TOutputSampleList > GaussianAdditiveNoiseSampleListFilter ::GaussianAdditiveNoiseSampleListFilter() { m_Mean = 0.; m_Variance = 1e-3; m_NumberOfIteration = 1; } template < class TInputSampleList, class TOutputSampleList > void GaussianAdditiveNoiseSampleListFilter ::GenerateRandomSequence() { typedef itk::Statistics::MersenneTwisterRandomVariateGenerator GeneratorType; GeneratorType::Pointer generator = GeneratorType::GetInstance(); // Clear the coefficients vector first m_WhiteGaussianNoiseCoefficients.clear(); // Get the size of the measurement vectors unsigned int size = this->GetInput()->GetMeasurementVectorSize(); if(size == 0) { itkExceptionMacro(<< "MeasurementVector size is "<GetNormalVariate(m_Mean, m_Variance); m_WhiteGaussianNoiseCoefficients.push_back(ran); } } template < class TInputSampleList, class TOutputSampleList > void GaussianAdditiveNoiseSampleListFilter ::GenerateData() { // Retrieve input and output pointers InputSampleListConstPointer inputSampleListPtr = this->GetInput(); OutputSampleListPointer outputSampleListPtr = this->GetOutput(); // Clear any previous output outputSampleListPtr->Clear(); // Set the measurement vector size outputSampleListPtr->SetMeasurementVectorSize(inputSampleListPtr->GetMeasurementVectorSize()); // Set-up progress reporting itk::ProgressReporter progress(this, 0, inputSampleListPtr->Size()*m_NumberOfIteration); // Iterate m_NumberOfIteration-times the noising process for (unsigned int currIteration = 0; currIteration< m_NumberOfIteration; currIteration++) { typename InputSampleListType::ConstIterator inputIt = inputSampleListPtr->Begin(); // Iterate on the InputSampleList while(inputIt != inputSampleListPtr->End()) { // Generate Random sequence this->GenerateRandomSequence(); // Retrieve current input sample InputMeasurementVectorType currentInputMeasurement = inputIt.GetMeasurementVector(); // Build current output sample OutputMeasurementVectorType currentOutputMeasurement; currentOutputMeasurement.SetSize(currentInputMeasurement.GetSize()); // Add the white noise to each component of the sample for(unsigned int idx = 0; idx < inputSampleListPtr->GetMeasurementVectorSize(); ++idx) { currentOutputMeasurement[idx] = static_cast( (static_cast(currentInputMeasurement[idx])+m_WhiteGaussianNoiseCoefficients[idx])); } // Add the current output sample to the output SampleList outputSampleListPtr->PushBack(currentOutputMeasurement); // Update progress progress.CompletedPixel(); ++inputIt; } } } template < class TInputSampleList, class TOutputSampleList > void GaussianAdditiveNoiseSampleListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); } } // End namespace Statistics } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbHistogramStatisticsFunction.h000066400000000000000000000064331301006202600311300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHistogramStatisticsFunction_h #define otbHistogramStatisticsFunction_h #include "itkNumericTraits.h" #include "itkHistogramAlgorithmBase.h" namespace otb { /** \class HistogramStatisticsFunction * \brief Computes parameters for a histogram. * * You plug in the target histogram using SetInputHistogram method and * get the entropy value from the histogram by calling the method GetEntropy * or the GenerateData method. * * \ingroup Function * * \ingroup OTBStatistics */ template class HistogramStatisticsFunction : public itk::HistogramAlgorithmBase { public: /**Standard class typedefs. */ typedef HistogramStatisticsFunction Self; typedef itk::HistogramAlgorithmBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename TInputHistogram::MeasurementType MeasurementType; typedef typename TInputHistogram::AbsoluteFrequencyType FrequencyType; //FIXME several possibilities in the new framework typedef typename itk::NumericTraits::RealType RealType; /**Standard Macros */ itkTypeMacro(HistogramStatisticsFunction, HistogramAlgorithmsBase); itkNewMacro(Self); /** Typedef for the output type */ typedef std::vector OutputType; /** Returns the entropy value */ OutputType GetEntropy(); /** Returns the mean value from histogram*/ OutputType GetMean(); /** Returns the covariance value from histogram*/ OutputType GetCovariance(); /** Stores the histogram pointer */ void SetInputHistogram(const TInputHistogram * histogram) { if (m_InputHistogram != histogram) { m_InputHistogram = histogram; this->Modified(); m_IsModified = true; } } /** Calculates the thresholds and save them */ void Compute() ITK_OVERRIDE { this->GenerateData(); } protected: HistogramStatisticsFunction(); ~HistogramStatisticsFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Calculates the thresholds and save them */ void GenerateData(); /** Calculate the entropy value */ void CalculateEntropy(); /** Calculate mean value */ void CalculateMean(); /** Calculate covariance value */ void CalculateCovariance(); private: OutputType m_entropy; OutputType m_mean; OutputType m_covariance; bool m_IsModified; /** Target histogram data pointer */ typename TInputHistogram::ConstPointer m_InputHistogram; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbHistogramStatisticsFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbHistogramStatisticsFunction.txx000066400000000000000000000127201301006202600315200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHistogramStatisticsFunction_txx #define otbHistogramStatisticsFunction_txx #include "otbHistogramStatisticsFunction.h" namespace otb { template HistogramStatisticsFunction ::HistogramStatisticsFunction() { m_IsModified = true; } template typename HistogramStatisticsFunction::OutputType HistogramStatisticsFunction ::GetEntropy() { if (m_IsModified == true) { this->Update(); } return m_entropy; } template typename HistogramStatisticsFunction::OutputType HistogramStatisticsFunction ::GetMean() { if (m_IsModified == true) { this->Update(); } return m_mean; } template typename HistogramStatisticsFunction::OutputType HistogramStatisticsFunction ::GetCovariance() { if (m_IsModified == true) { this->Update(); } return m_covariance; } template void HistogramStatisticsFunction ::CalculateEntropy() { typename TInputHistogram::ConstPointer histogram = m_InputHistogram; typename TInputHistogram::ConstIterator iter = histogram->Begin(); typename TInputHistogram::ConstIterator end = histogram->End(); RealType entropy = itk::NumericTraits::Zero; FrequencyType globalFrequency = histogram->GetTotalFrequency(); if (globalFrequency == 0) { itkExceptionMacro(<< "Histogram must contain at least 1 element."); } while (iter != end) { RealType Proba = static_cast(iter.GetFrequency()); Proba /= static_cast(globalFrequency); if (Proba != 0.0) { entropy -= Proba * vcl_log(Proba); } ++iter; } m_entropy.resize(1); m_entropy[0] = static_cast(entropy); } template void HistogramStatisticsFunction ::CalculateMean() { typename TInputHistogram::ConstPointer histogram = m_InputHistogram; unsigned int NumberOfDimension = histogram->GetSize().GetSize(); m_mean.resize(NumberOfDimension); if (histogram->GetTotalFrequency() == 0) { itkExceptionMacro(<< "Histogram must contain at least 1 element."); } if (NumberOfDimension > 2) { itkExceptionMacro(<< "Histogram must have 1 or 2 dimension."); } for (unsigned int noDim = 0; noDim < NumberOfDimension; noDim++) { MeasurementType mean = itk::NumericTraits::Zero; for (unsigned int i = 0; i < histogram->GetSize()[noDim]; ++i) { MeasurementType val = histogram->GetMeasurement(i, noDim); FrequencyType freq = histogram->GetFrequency(i, noDim); mean += val * freq; } mean /= histogram->GetTotalFrequency(); m_mean[noDim] = static_cast(mean); } } template void HistogramStatisticsFunction ::CalculateCovariance() { CalculateMean(); typename TInputHistogram::ConstPointer histogram = m_InputHistogram; unsigned int NumberOfDimension = histogram->GetSize().GetSize(); m_covariance.resize(NumberOfDimension * NumberOfDimension); if (histogram->GetTotalFrequency() == 0) { itkExceptionMacro(<< "Histogram must contain at least 1 element."); } for (unsigned int noDimX = 0; noDimX < NumberOfDimension; noDimX++) for (unsigned int noDimY = 0; noDimY < NumberOfDimension; noDimY++) { MeasurementType covariance = itk::NumericTraits::Zero; for (unsigned int i = 0; i < histogram->GetSize()[noDimX]; ++i) for (unsigned int j = 0; j < histogram->GetSize()[noDimY]; ++j) { MeasurementType valX = histogram->GetMeasurement(i, noDimX); MeasurementType valY = histogram->GetMeasurement(j, noDimY); FrequencyType freqX = histogram->GetFrequency(i, noDimX); FrequencyType freqY = histogram->GetFrequency(j, noDimY); valX -= static_cast(m_mean[noDimX]); valY -= static_cast(m_mean[noDimY]); covariance += ((valX * freqX) * (valY * freqY)); } covariance /= histogram->GetTotalFrequency(); m_covariance[noDimX * NumberOfDimension + noDimY] = static_cast(covariance); } } template void HistogramStatisticsFunction ::GenerateData() { CalculateEntropy(); CalculateMean(); CalculateCovariance(); m_IsModified = false; } template void HistogramStatisticsFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleGenerator.h000066400000000000000000000174641301006202600273440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleGenerator_h #define otbListSampleGenerator_h #include "itkProcessObject.h" #include "itkListSample.h" #include "itkPreOrderTreeIterator.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { /** \class ListSampleGenerator * \brief Produces a ListSample from a VectorImage and a VectorData * * This filter produces two ListSample for learning and validation of * learning algorithms. The repartition between the learning and validation * ListSample can be adjusted using the SetValidationTrainingProportion() * method. * * The size of the training and validation ListSample can be limited using the * SetMaxTrainingSize() and SetMaxValidationSize() methods. * * Classes are specified by the VectorData with a metadata identified by * a specific key. This key can be provided by the SetClassKey() method * (using "Class" as a default key). * * The input VectorData is supposed to be fully contained within the image extent * * * \ingroup OTBStatistics */ template class ITK_EXPORT ListSampleGenerator : public itk::ProcessObject { public: /** Standard class typedefs */ typedef ListSampleGenerator Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ListSampleGenerator, itk::ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::IndexType ImageIndexType; typedef typename ImageType::RegionType ImageRegionType; typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** List to store the pixel values */ typedef typename ImageType::PixelType SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef typename ListSampleType::Pointer ListSamplePointerType; /** List to store the corresponding labels */ typedef int ClassLabelType; typedef itk::FixedArray LabelType; //note could be templated by an std:::string typedef itk::Statistics::ListSample ListLabelType; typedef typename ListLabelType::Pointer ListLabelPointerType; /** Connects the input image for which the sample list is going to be extracted */ using Superclass::SetInput; void SetInput(const ImageType *); const ImageType * GetInput() const; /** Connects the vector data for which the sample list is going to be extracted * if this is the only input vector data, both the training and validation samples * come from it */ void SetInputVectorData(const VectorDataType *); const VectorDataType * GetInputVectorData() const; // Build the outputs typedef itk::DataObject::Pointer DataObjectPointer; DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; //virtual void Update(); /** Accessors */ itkGetConstMacro(MaxTrainingSize, long int); itkSetMacro(MaxTrainingSize, long int); itkGetConstMacro(PolygonEdgeInclusion, bool); itkSetMacro(PolygonEdgeInclusion, bool); itkGetConstMacro(MaxValidationSize, long int); itkSetMacro(MaxValidationSize, long int); itkGetConstMacro(ValidationTrainingProportion, double); itkSetClampMacro(ValidationTrainingProportion, double, 0.0, 1.0); itkGetConstMacro(BoundByMin, bool); itkSetMacro(BoundByMin, bool); itkGetConstMacro(NumberOfClasses, unsigned short); typedef std::map SampleNumberType; SampleNumberType GetClassesSamplesNumberTraining(void) const { return m_ClassesSamplesNumberTraining; } SampleNumberType GetClassesSamplesNumberValidation(void) const { return m_ClassesSamplesNumberValidation; } itkGetStringMacro(ClassKey); itkSetStringMacro(ClassKey); itkGetConstMacro(ClassMinSize, double); /** Returns the Training ListSample as a data object */ ListSampleType * GetTrainingListSample(); /** Returns the Trainingn label ListSample as a data object */ ListLabelType * GetTrainingListLabel(); /** Returns the label sample list as a data object */ ListSampleType * GetValidationListSample(); /** Returns the label sample list as a data object */ ListLabelType * GetValidationListLabel(); // Get the map size std::map GetClassesSize() const { return m_ClassesSize; } protected: ListSampleGenerator(); ~ListSampleGenerator() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Triggers the Computation of the sample list */ void GenerateData(void) ITK_OVERRIDE; void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Compute the calss statistics*/ void GenerateClassStatistics(); private: ListSampleGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename DataNodeType::PolygonPointerType PolygonPointerType; typedef typename DataNodeType::PolygonListType PolygonListType; typedef typename DataNodeType::PolygonListPointerType PolygonListPointerType; typedef itk::PreOrderTreeIterator TreeIteratorType; void ComputeClassSelectionProbability(); // Crop the polygon wrt the image largest region, // and return the resulting size in pixel units // This does not handle interior rings double GetPolygonAreaInPixelsUnits(DataNodeType* polygonDataNode, ImageType* image); long int m_MaxTrainingSize; // number of training samples (-1 = no limit) long int m_MaxValidationSize; // number of validation samples (-1 = no limit) double m_ValidationTrainingProportion; // proportion of training vs validation // (0.0 = all training, 1.0 = all validation) bool m_BoundByMin; //Bound the number of samples by the class having the fewer bool m_PolygonEdgeInclusion; // if true take into consideration pixel which are on polygon edge // useful, when dealing with small polygon area (1 or two pixels) // false by default unsigned short m_NumberOfClasses; std::string m_ClassKey; double m_ClassMinSize; std::map m_ClassesSize; std::map m_ClassesProbTraining; std::map m_ClassesProbValidation; std::map m_ClassesSamplesNumberTraining; //Just a counter std::map m_ClassesSamplesNumberValidation; //Just a counter typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; RandomGeneratorType::Pointer m_RandomGenerator; }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbListSampleGenerator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleGenerator.txx000066400000000000000000000420561301006202600277330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleGenerator_txx #define otbListSampleGenerator_txx #include "otbListSampleGenerator.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "otbRemoteSensingRegion.h" #include "otbVectorDataProjectionFilter.h" #include "otbMacro.h" namespace otb { /*template void printVectorData(TVectorData * vectorData, string msg = "") { typedef TVectorData VectorDataType; typedef itk::PreOrderTreeIterator TreeIteratorType; TreeIteratorType itVector(vectorData->GetDataTree()); itVector.GoToBegin(); if (!msg.empty()) { std::cout<< msg << std::endl; } while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPolygonFeature()) { std::cout << itVector.Get()->GetNodeTypeAsString() << std::endl; for (unsigned int itPoints = 0; itPoints < itVector.Get()->GetPolygonExteriorRing()->GetVertexList()->Size(); itPoints++) { std::cout << "vertex[" << itPoints << "]: " << itVector.Get()->GetPolygonExteriorRing()->GetVertexList()->GetElement(itPoints) <GetPolygonExteriorRing()->GetBoundingRegion() << std::endl; } ++itVector; } }*/ template ListSampleGenerator ::ListSampleGenerator() : m_MaxTrainingSize(-1), m_MaxValidationSize(-1), m_ValidationTrainingProportion(0.0), m_BoundByMin(true), m_PolygonEdgeInclusion(false), m_NumberOfClasses(0), m_ClassKey("Class"), m_ClassMinSize(-1) { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(4); // Register the outputs this->itk::ProcessObject::SetNthOutput(0, this->MakeOutput(0).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(2, this->MakeOutput(2).GetPointer()); this->itk::ProcessObject::SetNthOutput(3, this->MakeOutput(3).GetPointer()); m_RandomGenerator = RandomGeneratorType::GetInstance(); } template void ListSampleGenerator ::SetInput(const ImageType * image) { this->ProcessObject::SetNthInput(0, const_cast(image)); } template const TImage * ListSampleGenerator ::GetInput() const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->ProcessObject::GetInput(0)); } template void ListSampleGenerator ::SetInputVectorData(const VectorDataType * vectorData) { this->ProcessObject::SetNthInput(1, const_cast(vectorData)); //printVectorData(vectorData); } template const TVectorData * ListSampleGenerator ::GetInputVectorData() const { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->ProcessObject::GetInput(1)); } template typename ListSampleGenerator::DataObjectPointer ListSampleGenerator ::MakeOutput(DataObjectPointerArraySizeType idx) { DataObjectPointer output; switch (idx) { case 0: output = static_cast(ListSampleType::New().GetPointer()); break; case 1: output = static_cast(ListLabelType::New().GetPointer()); break; case 2: output = static_cast(ListSampleType::New().GetPointer()); break; case 3: output = static_cast(ListLabelType::New().GetPointer()); break; default: output = static_cast(ListSampleType::New().GetPointer()); break; } return output; } // Get the Training ListSample template typename ListSampleGenerator::ListSampleType* ListSampleGenerator ::GetTrainingListSample() { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } // Get the Training label ListSample template typename ListSampleGenerator::ListLabelType* ListSampleGenerator ::GetTrainingListLabel() { return dynamic_cast(this->itk::ProcessObject::GetOutput(1)); } // Get the validation ListSample template typename ListSampleGenerator::ListSampleType* ListSampleGenerator ::GetValidationListSample() { return dynamic_cast(this->itk::ProcessObject::GetOutput(2)); } // Get the validation label ListSample template typename ListSampleGenerator::ListLabelType* ListSampleGenerator ::GetValidationListLabel() { return dynamic_cast(this->itk::ProcessObject::GetOutput(3)); } template void ListSampleGenerator ::GenerateInputRequestedRegion() { ImagePointerType img = static_cast(this->ProcessObject::GetInput(0)); if(img.IsNotNull()) { // Requested regions will be generated during GenerateData // call. For now request an empty region so as to avoid requesting // the largest possible region (fixes bug #943 ) typename ImageType::RegionType dummyRegion; typename ImageType::SizeType dummySize; dummySize.Fill(0); dummyRegion.SetSize(dummySize); img->SetRequestedRegion(dummyRegion); } } template void ListSampleGenerator ::GenerateData() { // Get the inputs ImagePointerType image = const_cast(this->GetInput()); VectorDataPointerType vectorData = const_cast(this->GetInputVectorData()); // Get the outputs ListSamplePointerType trainingListSample = this->GetTrainingListSample(); ListLabelPointerType trainingListLabel = this->GetTrainingListLabel(); ListSamplePointerType validationListSample = this->GetValidationListSample(); ListLabelPointerType validationListLabel = this->GetValidationListLabel(); // Gather some information about the relative size of the classes // We would like to have the same number of samples per class this->GenerateClassStatistics(); this->ComputeClassSelectionProbability(); // Clear the sample lists trainingListSample->Clear(); trainingListLabel->Clear(); validationListSample->Clear(); validationListLabel->Clear(); // Set MeasurementVectorSize for each sample list trainingListSample->SetMeasurementVectorSize(image->GetNumberOfComponentsPerPixel()); // stores label as integers,so put the size to 1 trainingListLabel->SetMeasurementVectorSize(1); validationListSample->SetMeasurementVectorSize(image->GetNumberOfComponentsPerPixel()); // stores label as integers,so put the size to 1 validationListLabel->SetMeasurementVectorSize(1); m_ClassesSamplesNumberTraining.clear(); m_ClassesSamplesNumberValidation.clear(); typename ImageType::RegionType imageLargestRegion = image->GetLargestPossibleRegion(); TreeIteratorType itVector(vectorData->GetDataTree()); for (itVector.GoToBegin(); !itVector.IsAtEnd(); ++itVector) { if (itVector.Get()->IsPolygonFeature()) { PolygonPointerType exteriorRing = itVector.Get()->GetPolygonExteriorRing(); typename ImageType::RegionType polygonRegion = otb::TransformPhysicalRegionToIndexRegion(exteriorRing->GetBoundingRegion(), image.GetPointer()); const bool hasIntersection = polygonRegion.Crop(imageLargestRegion); if (!hasIntersection) { continue; } image->SetRequestedRegion(polygonRegion); image->PropagateRequestedRegion(); image->UpdateOutputData(); typedef itk::ImageRegionConstIteratorWithIndex IteratorType; IteratorType it(image, polygonRegion); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { itk::ContinuousIndex point; image->TransformIndexToPhysicalPoint(it.GetIndex(), point); if ( exteriorRing->IsInside(point) || (this->GetPolygonEdgeInclusion() && exteriorRing->IsOnEdge(point)) ) { PolygonListPointerType interiorRings = itVector.Get()->GetPolygonInteriorRings(); bool isInsideInteriorRing = false; for (typename PolygonListType::Iterator interiorRing = interiorRings->Begin(); interiorRing != interiorRings->End(); ++interiorRing) { if ( interiorRing.Get()->IsInside(point) || (this->GetPolygonEdgeInclusion() && interiorRing.Get()->IsOnEdge(point)) ) { isInsideInteriorRing = true; break; } } if (isInsideInteriorRing) { continue; // skip this pixel and continue } double randomValue = m_RandomGenerator->GetUniformVariate(0.0, 1.0); if (randomValue < m_ClassesProbTraining[itVector.Get()->GetFieldAsInt(m_ClassKey)]) { //Add the sample to the training list trainingListSample->PushBack(it.Get()); trainingListLabel->PushBack(itVector.Get()->GetFieldAsInt(m_ClassKey)); m_ClassesSamplesNumberTraining[itVector.Get()->GetFieldAsInt(m_ClassKey)] += 1; } else if (randomValue < m_ClassesProbTraining[itVector.Get()->GetFieldAsInt(m_ClassKey)] + m_ClassesProbValidation[itVector.Get()->GetFieldAsInt(m_ClassKey)]) { //Add the sample to the validation list validationListSample->PushBack(it.Get()); validationListLabel->PushBack(itVector.Get()->GetFieldAsInt(m_ClassKey)); m_ClassesSamplesNumberValidation[itVector.Get()->GetFieldAsInt(m_ClassKey)] += 1; } //Note: some samples may not be used at all } } } } assert(trainingListSample->Size() == trainingListLabel->Size()); assert(validationListSample->Size() == validationListLabel->Size()); this->UpdateProgress(1.0f); } template void ListSampleGenerator ::GenerateClassStatistics() { m_ClassesSize.clear(); ImageType* image = const_cast (this->GetInput()); typename VectorDataType::ConstPointer vectorData = this->GetInputVectorData(); // Compute cumulative area of all polygons of each class TreeIteratorType itVector(vectorData->GetDataTree()); for (itVector.GoToBegin(); !itVector.IsAtEnd(); ++itVector) { DataNodeType* datanode = itVector.Get(); if (datanode->IsPolygonFeature()) { double area = GetPolygonAreaInPixelsUnits(datanode, image); m_ClassesSize[datanode->GetFieldAsInt(m_ClassKey)] += area; } } m_NumberOfClasses = m_ClassesSize.size(); } template void ListSampleGenerator ::ComputeClassSelectionProbability() { m_ClassesProbTraining.clear(); m_ClassesProbValidation.clear(); // Sanity check if (m_ClassesSize.empty()) { itkGenericExceptionMacro(<< "No training sample found inside image"); } // Go through the classes size to find the smallest one double minSize = itk::NumericTraits::max(); for (std::map::const_iterator itmap = m_ClassesSize.begin(); itmap != m_ClassesSize.end(); ++itmap) { if (minSize > itmap->second) { minSize = itmap->second; } } // Apply the proportion between training and validation samples (all training by default) double minSizeTraining = minSize * (1.0 - m_ValidationTrainingProportion); double minSizeValidation = minSize * m_ValidationTrainingProportion; // Apply the limit if specified by the user if(m_BoundByMin) { if ((m_MaxTrainingSize != -1) && (m_MaxTrainingSize < minSizeTraining)) { minSizeTraining = m_MaxTrainingSize; } if ((m_MaxValidationSize != -1) && (m_MaxValidationSize < minSizeValidation)) { minSizeValidation = m_MaxValidationSize; } } // Compute the probability selection for each class for (std::map::const_iterator itmap = m_ClassesSize.begin(); itmap != m_ClassesSize.end(); ++itmap) { if (m_BoundByMin) { m_ClassesProbTraining[itmap->first] = minSizeTraining / itmap->second; m_ClassesProbValidation[itmap->first] = minSizeValidation / itmap->second; } else { long int maxSizeT = (itmap->second)*(1.0 - m_ValidationTrainingProportion); long int maxSizeV = (itmap->second)*m_ValidationTrainingProportion; // Check if max sizes respect the maximum bounds double correctionRatioTrain = 1.0; if((m_MaxTrainingSize > -1) && (m_MaxTrainingSize < maxSizeT)) { correctionRatioTrain = (double)(m_MaxTrainingSize) / (double)(maxSizeT); } double correctionRatioValid = 1.0; if((m_MaxValidationSize > -1) && (m_MaxValidationSize < maxSizeV)) { correctionRatioValid = (double)(m_MaxValidationSize) / (double)(maxSizeV); } double correctionRatio = std::min(correctionRatioTrain,correctionRatioValid); m_ClassesProbTraining[itmap->first] = correctionRatio*(1.0 - m_ValidationTrainingProportion); m_ClassesProbValidation[itmap->first] = correctionRatio*m_ValidationTrainingProportion; } } } template double ListSampleGenerator ::GetPolygonAreaInPixelsUnits(DataNodeType* polygonDataNode, ImageType* image) { const double pixelArea = vcl_abs(image->GetSpacing()[0] * image->GetSpacing()[1]); // Compute area of exterior ring in pixels PolygonPointerType exteriorRing = polygonDataNode->GetPolygonExteriorRing(); double area = exteriorRing->GetArea() / pixelArea; // Remove contribution of all interior rings PolygonListPointerType interiorRings = polygonDataNode->GetPolygonInteriorRings(); for (typename PolygonListType::Iterator interiorRing = interiorRings->Begin(); interiorRing != interiorRings->End(); ++interiorRing) { area -= interiorRing.Get()->GetArea() / pixelArea; } return area; } template void ListSampleGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "* MaxTrainingSize: " << m_MaxTrainingSize << "\n"; os << indent << "* MaxValidationSize: " << m_MaxValidationSize << "\n"; os << indent << "* Proportion: " << m_ValidationTrainingProportion << "\n"; os << indent << "* Input data:\n"; if (m_ClassesSize.empty()) { os << indent << "Empty\n"; } else { for (std::map::const_iterator itmap = m_ClassesSize.begin(); itmap != m_ClassesSize.end(); ++itmap) { os << indent << itmap->first << ": " << itmap->second << "\n"; } } os << "\n" << indent << "* Training set:\n"; if (m_ClassesProbTraining.empty()) { os << indent << "Not computed\n"; } else { os << indent << "** Selection probability:\n"; for (std::map::const_iterator itmap = m_ClassesProbTraining.begin(); itmap != m_ClassesProbTraining.end(); ++itmap) { os << indent << itmap->first << ": " << itmap->second << "\n"; } os << indent << "** Number of selected samples:\n"; for (std::map::const_iterator itmap = m_ClassesSamplesNumberTraining.begin(); itmap != m_ClassesSamplesNumberTraining.end(); ++itmap) { os << indent << itmap->first << ": " << itmap->second << "\n"; } } os << "\n" << indent << "* Validation set:\n"; if (m_ClassesProbValidation.empty()) { os << indent << "Not computed\n"; } else { os << indent << "** Selection probability:\n"; for (std::map::const_iterator itmap = m_ClassesProbValidation.begin(); itmap != m_ClassesProbValidation.end(); ++itmap) { os << indent << itmap->first << ": " << itmap->second << "\n"; } os << indent << "** Number of selected samples:\n"; for (std::map::const_iterator itmap = m_ClassesSamplesNumberValidation.begin(); itmap != m_ClassesSamplesNumberValidation.end(); ++itmap) { os << indent << itmap->first << ": " << itmap->second << "\n"; } } } } #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleSource.h000066400000000000000000000061021301006202600266410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleSource_h #define otbListSampleSource_h #include "itkProcessObject.h" #include "itkDataObjectDecorator.h" namespace otb { namespace Statistics { /** \class ListSampleSource * \brief This class is a base class for filters using ListSample as * input and returning ListSample. * * * This filter provides pipeline support since * itk::Statistics::ListSample is a DataObject * the output sample list. * * * \ingroup OTBStatistics */ template < class TInputSampleList, class TOutputSampleList = TInputSampleList > class ITK_EXPORT ListSampleSource : public itk::ProcessObject { public: /** Standard class typedefs */ typedef ListSampleSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ListSampleSource, itk::ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); /** OutputSampleList typedefs */ typedef TOutputSampleList OutputSampleListType; typedef typename OutputSampleListType::Pointer OutputSampleListPointer; typedef typename OutputSampleListType::ConstPointer OutputSampleListConstPointer; typedef typename OutputSampleListType::MeasurementVectorType OutputMeasurementVectorType; typedef typename OutputMeasurementVectorType::ValueType OutputValueType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** ListSample is not a DataObject, we need to decorate it to push it down * a ProcessObject's pipeline */ typedef itk::DataObject::Pointer DataObjectPointer; /** Returns the output sample list as a data object */ OutputSampleListType * GetOutput(); protected: /** Standard itk::ProcessObject subclass method. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; ListSampleSource(); ~ListSampleSource() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ListSampleSource(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; // end of class ListSampleSource } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbListSampleSource.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleSource.txx000066400000000000000000000041131301006202600272350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleSource_txx #define otbListSampleSource_txx #include "otbListSampleSource.h" namespace otb { namespace Statistics { template < class TInputSampleList, class TOutputSampleList > ListSampleSource ::ListSampleSource() { this->SetNumberOfRequiredOutputs(1); // Generate the output sample list typename OutputSampleListType::Pointer outputPtr = static_cast< OutputSampleListType * >(this->MakeOutput(0).GetPointer()); this->ProcessObject::SetNthOutput(0, outputPtr.GetPointer()); } template < class TInputSampleList, class TOutputSampleList > typename ListSampleSource ::DataObjectPointer ListSampleSource ::MakeOutput(DataObjectPointerArraySizeType) { OutputSampleListPointer outputSampleList = OutputSampleListType::New(); return static_cast(outputSampleList); } template < class TInputSampleList, class TOutputSampleList > typename ListSampleSource ::OutputSampleListType * ListSampleSource ::GetOutput() { return static_cast (this->ProcessObject::GetOutput(0) ); } template < class TInputSampleList, class TOutputSampleList > void ListSampleSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); } } // End namespace Statistics } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleToBalancedListSampleFilter.h000066400000000000000000000145231301006202600325470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToBalancedListSampleFilter_h #define otbListSampleToBalancedListSampleFilter_h #include "otbGaussianAdditiveNoiseSampleListFilter.h" #include "itkDataObjectDecorator.h" #include "otbMacro.h" namespace otb { namespace Statistics { /** \class ListSampleToBalancedListSampleFilter * \brief This class generate a balanced ListSample in order to have * fair distribution of learning samples. * * The maximum number of samples with same labels are first * computed. This maximum number by the m_BalacingFactor determines * the final number of samples belonging to each label. * * Mean and Variance are set via the methods SetMean() and SetVariance(). * * \sa ListSampleToListSampleFilter, GaussianAdditiveNoiseSampleListFilter * * \ingroup OTBStatistics */ template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList = TInputSampleList > class ITK_EXPORT ListSampleToBalancedListSampleFilter : public otb::Statistics::ListSampleToListSampleFilter { public: /** Standard class typedefs */ typedef ListSampleToBalancedListSampleFilter Self; typedef otb::Statistics::ListSampleToListSampleFilter Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ListSampleToBalancedListSampleFilter, otb::Statistics::ListSampleToListSampleFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputSampleList typedefs */ typedef TInputSampleList InputSampleListType; typedef typename InputSampleListType::Pointer InputSampleListPointer; typedef typename InputSampleListType::ConstPointer InputSampleListConstPointer; typedef typename InputSampleListType::MeasurementVectorType InputMeasurementVectorType; typedef typename InputMeasurementVectorType::ValueType InputValueType; /** LabelSampleList typedefs */ typedef TLabelSampleList LabelSampleListType; typedef typename LabelSampleListType::Pointer LabelSampleListPointer; typedef typename LabelSampleListType::ConstPointer LabelSampleListConstPointer; typedef typename LabelSampleListType::MeasurementVectorType LabelMeasurementVectorType; typedef typename LabelMeasurementVectorType::ValueType LabelValueType; typedef itk::DataObjectDecorator< LabelSampleListType > LabelSampleListObjectType; /** OutputSampleList typedefs */ typedef TOutputSampleList OutputSampleListType; typedef typename OutputSampleListType::Pointer OutputSampleListPointer; typedef typename OutputSampleListType::ConstPointer OutputSampleListConstPointer; typedef typename OutputSampleListType::MeasurementVectorType OutputMeasurementVectorType; typedef typename OutputMeasurementVectorType::ValueType OutputValueType; /** DataObject typedef*/ typedef typename Superclass::DataObjectPointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Filter adding noise to a ListSample */ typedef otb::Statistics::GaussianAdditiveNoiseSampleListFilter GaussianAdditiveNoiseType; typedef typename GaussianAdditiveNoiseType::Pointer GaussianAdditiveNoisePointerType; /** Get/Set the label sample list */ void SetInputLabel( const LabelSampleListType * label ); /** Returns the label sample list */ const LabelSampleListType * GetInputLabel() const; /** Returns the label sample list as a data object */ LabelSampleListType * GetOutputLabel(); /** Set/Get the mean for the white gaussian noise to generate */ otbSetObjectMemberMacro(AddGaussianNoiseFilter, Mean, double); otbGetObjectMemberConstMacro(AddGaussianNoiseFilter, Mean, double); /** Set/Get the variance for the white gaussian noise to generate */ otbSetObjectMemberMacro(AddGaussianNoiseFilter, Variance, double); otbGetObjectMemberConstMacro(AddGaussianNoiseFilter, Variance, double); /** Set/Get the multiplicative factor : this value is used to * determine the maximum number of samples in each label in order * to reach a balanced output ListSample */ itkSetMacro(BalancingFactor, unsigned int); itkGetMacro(BalancingFactor, unsigned int); protected: /** This method causes the filter to generate its output. */ void GenerateData() ITK_OVERRIDE; /** In order to respect the fair data principle, the number of samples for * each label must be the same. This method computes the label that * have the higher number of sample. */ void ComputeMaxSampleFrequency(); /** Make Output */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; ListSampleToBalancedListSampleFilter(); ~ListSampleToBalancedListSampleFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ListSampleToBalancedListSampleFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented GaussianAdditiveNoisePointerType m_AddGaussianNoiseFilter; std::vector m_MultiplicativeCoefficient; unsigned int m_BalancingFactor; }; // end of class ListSampleToBalancedListSampleFilter } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbListSampleToBalancedListSampleFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleToBalancedListSampleFilter.txx000066400000000000000000000244711301006202600331460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToBalancedListSampleFilter_txx #define otbListSampleToBalancedListSampleFilter_txx #include "otbListSampleToBalancedListSampleFilter.h" #include "itkProgressReporter.h" #include "itkHistogram.h" #include "itkNumericTraits.h" namespace otb { namespace Statistics { // constructor template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > ListSampleToBalancedListSampleFilter ::ListSampleToBalancedListSampleFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(2); // Create the second output //this->itk::ProcessObject::SetNthOutput(0, this->MakeOutput(0).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer()); m_AddGaussianNoiseFilter = GaussianAdditiveNoiseType::New(); m_BalancingFactor = 5; } template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > typename ListSampleToBalancedListSampleFilter ::DataObjectPointer ListSampleToBalancedListSampleFilter ::MakeOutput(DataObjectPointerArraySizeType idx) { DataObjectPointer output; switch (idx) { case 0: Superclass::MakeOutput(0); break; case 1: { output = static_cast(LabelSampleListType::New().GetPointer()); break; } default: output = static_cast(InputSampleListType::New().GetPointer()); break; } return output; } // Method to set the SampleList as DataObject template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > void ListSampleToBalancedListSampleFilter ::SetInputLabel( const LabelSampleListType * labelPtr ) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast< LabelSampleListType* >( labelPtr ) ); } // Method to get the SampleList as DataObject template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > const typename ListSampleToBalancedListSampleFilter ::LabelSampleListType * ListSampleToBalancedListSampleFilter ::GetInputLabel() const { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1) ); } // Get the output label SampleList as DataObject template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > typename ListSampleToBalancedListSampleFilter ::LabelSampleListType * ListSampleToBalancedListSampleFilter ::GetOutputLabel() { return dynamic_cast(this->itk::ProcessObject::GetOutput(1)); } // Get the max sample number having the same label template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > void ListSampleToBalancedListSampleFilter ::ComputeMaxSampleFrequency() { // Iterate on the labelSampleList to get the min and max label LabelValueType maxLabel = itk::NumericTraits::min(); // Number of bins to add to the histogram typename LabelSampleListType::ConstPointer labelPtr = this->GetInputLabel(); typename LabelSampleListType::ConstIterator labelIt = labelPtr->Begin(); while(labelIt != labelPtr->End()) { // Get the current label sample LabelMeasurementVectorType currentInputMeasurement = labelIt.GetMeasurementVector(); if (currentInputMeasurement[0] > maxLabel) maxLabel = currentInputMeasurement[0]; ++labelIt; } // Prepare histogram with dimension 1 : default template parameters typedef typename itk::Statistics::Histogram HistogramType; typename HistogramType::Pointer histogram = HistogramType::New(); typename HistogramType::SizeType size(1); size.Fill(maxLabel +1); histogram->SetMeasurementVectorSize(1); // we need only one dimension histogram->Initialize(size); labelIt = labelPtr->Begin(); while (labelIt != labelPtr->End()) { // Get the current label sample LabelMeasurementVectorType currentInputMeasurement = labelIt.GetMeasurementVector(); histogram->IncreaseFrequency(currentInputMeasurement[0], 1); ++labelIt; } // Iterate through the histogram to get the maximum unsigned int maxvalue = 0; HistogramType::Iterator iter = histogram->Begin(); while ( iter != histogram->End() ) { if( static_cast(iter.GetFrequency()) > maxvalue ) maxvalue = static_cast(iter.GetFrequency()); ++iter; } // Number of sample per label to reach in order to have a balanced // ListSample unsigned int balancedFrequency = m_BalancingFactor * maxvalue; // Guess how much noised samples must be added per sample to get // a balanced ListSample : Computed using the // - Frequency of each label (stored in the histogram) // - The value maxvalue by m_BalancingFactor // The std::vector below stores the multiplicative factor iter = histogram->Begin(); while ( iter != histogram->End() ) { if(iter.GetFrequency() - 1e-10 < 0.) m_MultiplicativeCoefficient.push_back(0); else { unsigned int coeff = static_cast(balancedFrequency/iter.GetFrequency()); m_MultiplicativeCoefficient.push_back(coeff); } ++iter; } } template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > void ListSampleToBalancedListSampleFilter ::GenerateData() { // Get the how much each sample must be expanded this->ComputeMaxSampleFrequency(); // Retrieve input and output pointers InputSampleListConstPointer inputSampleListPtr = this->GetInput(); LabelSampleListConstPointer labelSampleListPtr = this->GetInputLabel(); OutputSampleListPointer outputSampleListPtr = this->GetOutput(); LabelSampleListPointer outputLabel = this->GetOutputLabel(); // Clear any previous output outputSampleListPtr->Clear(); // Set the measurement vectors size outputSampleListPtr->SetMeasurementVectorSize(inputSampleListPtr->GetMeasurementVectorSize()); outputLabel->SetMeasurementVectorSize(labelSampleListPtr->GetMeasurementVectorSize()); typename InputSampleListType::ConstIterator inputIt = inputSampleListPtr->Begin(); typename LabelSampleListType::ConstIterator labelIt = labelSampleListPtr->Begin(); // Set-up progress reporting itk::ProgressReporter progress(this, 0, inputSampleListPtr->Size()); // Noising filter GaussianAdditiveNoisePointerType noisingFilter = GaussianAdditiveNoiseType::New(); // Iterate on the InputSampleList while(inputIt != inputSampleListPtr->End() && labelIt != labelSampleListPtr->End()) { // Retrieve current input sample InputMeasurementVectorType currentInputMeasurement = inputIt.GetMeasurementVector(); // Retrieve the current label LabelMeasurementVectorType currentLabelMeasurement = labelIt.GetMeasurementVector(); // Build a temporary ListSample with the current // measurement vector to generate noised versions of this // measurement vector InputSampleListPointer tempListSample = InputSampleListType::New(); tempListSample->SetMeasurementVectorSize(inputSampleListPtr->GetMeasurementVectorSize()); tempListSample->PushBack(currentInputMeasurement); // Get how many times we have to noise this sample unsigned int iterations = m_MultiplicativeCoefficient[currentLabelMeasurement[0]]; // Noising filter //GaussianAdditiveNoisePointerType noisingFilter = GaussianAdditiveNoiseType::New(); noisingFilter->SetInput(tempListSample); noisingFilter->SetNumberOfIteration(iterations); noisingFilter->Update(); // Build current output sample OutputMeasurementVectorType currentOutputMeasurement; currentOutputMeasurement.SetSize(currentInputMeasurement.GetSize()); // Cast the current sample in outputSampleValue for(unsigned int idx = 0; idx < inputSampleListPtr->GetMeasurementVectorSize(); ++idx) currentOutputMeasurement[idx] = static_cast(currentInputMeasurement[idx]); // Add the current input casted sample to the output SampleList outputSampleListPtr->PushBack(currentOutputMeasurement); // Add the currentsample list label outputLabel->PushBack(currentLabelMeasurement); // Add the noised versions of the current sample to OutputSampleList typename OutputSampleListType::ConstIterator tempIt = noisingFilter->GetOutput()->Begin(); while(tempIt != noisingFilter->GetOutput()->End()) { // Get the noised sample of the current measurement vector OutputMeasurementVectorType currentTempMeasurement = tempIt.GetMeasurementVector(); // Add to output SampleList outputSampleListPtr->PushBack(currentTempMeasurement); // Add a label in the output ListSample outputLabel->PushBack(currentLabelMeasurement); ++tempIt; } // Update progress progress.CompletedPixel(); ++inputIt; ++ labelIt; } } template < class TInputSampleList, class TLabelSampleList, class TOutputSampleList > void ListSampleToBalancedListSampleFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); } } // End namespace Statistics } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleToHistogramListGenerator.h000066400000000000000000000127701301006202600323540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToHistogramListGenerator_h #define otbListSampleToHistogramListGenerator_h #include "itkNumericTraits.h" #include "itkProcessObject.h" #include "itkHistogram.h" #include "itkStatisticsAlgorithm.h" #include "otbObjectList.h" namespace otb { /** \class ListSampleToHistogramListGenerator * \brief Generates a list of 1D Histograms from a ListSample * This class is similar to * ListSampleToVariableDimensionHistogramGenerator, except from the * fact that it computes one histogram per channel instead of a * single joint-histogram. The output is a Histogram list (\sa * ObjectList). * \sa ListSampleToVariableDimensionHistogram * * \ingroup OTBStatistics */ template class ITK_EXPORT ListSampleToHistogramListGenerator : public itk::ProcessObject { public: /** Standard typedefs */ typedef ListSampleToHistogramListGenerator Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ListSampleToHistogramListGenerator, itk::ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); /** typedef the input ListSample type */ typedef TListSample ListSampleType; /** Type needed for defining the limits of the histogram bins */ typedef typename itk::NumericTraits ::RealType HistogramMeasurementRealType; typedef itk::Statistics::Histogram HistogramType; typedef typename HistogramType::SizeType HistogramSizeType; typedef typename TListSample::MeasurementVectorType MeasurementVectorType; typedef ObjectList HistogramListType; typedef typename HistogramListType::Pointer HistogramListPointerType; typedef typename TListSample::ConstPointer ListSampleConstPointerType; /** DataObject typedef*/ typedef typename Superclass::DataObjectPointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; // Set/Get the input list sample void SetListSample(const ListSampleType* inputlist); const ListSampleType* GetListSample() const; // Get the output histogram const HistogramListType* GetOutput(); // /** plug in the ListSample object */ // void SetListSample(const TListSample* list) // { // m_List = list; // } /** Set the no data value. These value are ignored in histogram * computation if NoDataFlag is On */ itkSetMacro(NoDataValue, THistogramMeasurement); /** Set the no data value. These value are ignored in histogram * computation if NoDataFlag is On */ itkGetConstReferenceMacro(NoDataValue, THistogramMeasurement); /** Set the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkSetMacro(NoDataFlag, bool); /** Get the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkGetMacro(NoDataFlag, bool); /** Toggle the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkBooleanMacro(NoDataFlag); void SetMarginalScale(float scale) { m_MarginalScale = scale; } void SetNumberOfBins(unsigned int size) { m_Size[0] = size; } // HistogramListPointerType GetOutput() const // { return m_HistogramList; } itkSetMacro(AutoMinMax, bool); itkGetConstReferenceMacro(AutoMinMax, bool); void SetHistogramMin(const MeasurementVectorType& histogramMin) { m_HistogramMin = histogramMin; m_AutoMinMax = false; } void SetHistogramMax(const MeasurementVectorType& histogramMax) { m_HistogramMax = histogramMax; m_AutoMinMax = false; } protected: ListSampleToHistogramListGenerator(); ~ListSampleToHistogramListGenerator() ITK_OVERRIDE {} void GenerateData() ITK_OVERRIDE; DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: //ListSampleConstPointerType m_List; HistogramSizeType m_Size; float m_MarginalScale; MeasurementVectorType m_HistogramMin; MeasurementVectorType m_HistogramMax; bool m_AutoMinMax; //HistogramListPointerType m_HistogramList; bool m_NoDataFlag; THistogramMeasurement m_NoDataValue; }; // end of class } // end of namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbListSampleToHistogramListGenerator.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleToHistogramListGenerator.txx000066400000000000000000000232371301006202600327500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToHistogramListGenerator_txx #define otbListSampleToHistogramListGenerator_txx #include "otbListSampleToHistogramListGenerator.h" #include "itkArray.h" #include "otbMacro.h" namespace otb { template ListSampleToHistogramListGenerator ::ListSampleToHistogramListGenerator() : m_Size(10), m_MarginalScale(100), m_AutoMinMax(true), m_NoDataFlag(false), m_NoDataValue(itk::NumericTraits::Zero) { m_Size.Fill(255); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->itk::ProcessObject::SetNthOutput(0, this->MakeOutput(0).GetPointer()); } // Set the input ListSample template void ListSampleToHistogramListGenerator ::SetListSample(const ListSampleType* inputlist) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(inputlist)); } // Get the input ListSample template const typename ListSampleToHistogramListGenerator ::ListSampleType* ListSampleToHistogramListGenerator ::GetListSample() const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } // Get the output template const typename ListSampleToHistogramListGenerator ::HistogramListType* ListSampleToHistogramListGenerator ::GetOutput() { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } // MakeOutput implementation template typename ListSampleToHistogramListGenerator ::DataObjectPointer ListSampleToHistogramListGenerator ::MakeOutput(DataObjectPointerArraySizeType itkNotUsed(idx)) { DataObjectPointer output; output = static_cast(HistogramListType::New().GetPointer()); return output; } // GenerateData template void ListSampleToHistogramListGenerator ::GenerateData() { otbMsgDebugMacro(<< "ListSampleToHistogramListGenerator::GenerateData(): Entering"); // Get the input ListSample const ListSampleType* inputList = this->GetListSample(); // Get a pointer on the output typename HistogramListType::Pointer histogramList = const_cast(this->GetOutput()); if (!m_AutoMinMax) { if (m_HistogramMin.GetSize() != inputList->GetMeasurementVectorSize()) { itkExceptionMacro("Sample list measurement vectors and histogram min have different dimensions !"); } if (m_HistogramMax.GetSize() != inputList->GetMeasurementVectorSize()) { itkExceptionMacro("Sample list measurement vectors and histogram max have different dimensions !"); } } typename TListSample::MeasurementVectorType lower(inputList->GetMeasurementVectorSize()); typename TListSample::MeasurementVectorType upper(inputList->GetMeasurementVectorSize()); typename TListSample::MeasurementVectorType h_upper(inputList->GetMeasurementVectorSize()); typename TListSample::MeasurementVectorType h_lower(inputList->GetMeasurementVectorSize()); bool clipBinsAtEnds = true; // must test for the list size to avoid making FindSampleBound() segfault. // Also, the min and max can't be found automatically in that case. We can // only return an empty histogram if (m_AutoMinMax && inputList->Size() != 0) { itk::Statistics::Algorithm::FindSampleBound(inputList, inputList->Begin(), inputList->End(), lower, upper); float margin; for (unsigned int i = 0; i < inputList->GetMeasurementVectorSize(); ++i) { if (!itk::NumericTraits::is_integer) { margin = ((THistogramMeasurement) (upper[i] - lower[i]) / (THistogramMeasurement) m_Size[0]) / (THistogramMeasurement) m_MarginalScale; h_upper[i] = (THistogramMeasurement) (upper[i] + margin); if (h_upper[i] <= upper[i]) { // an overflow has occurred therefore set upper to upper h_upper[i] = upper[i]; // Histogram measurement type would force the clipping the max value. // Therefore we must call the following to include the max value: clipBinsAtEnds = false; // The above function is okay since here we are within the autoMinMax // computation and clearly the user intended to include min and max. } } else { h_upper[i] = ((THistogramMeasurement) upper[i]) + itk::NumericTraits::One; if (h_upper[i] <= upper[i]) { // an overflow has occurred therefore set upper to upper h_upper[i] = upper[i]; // Histogram measurement type would force the clipping the max value. // Therefore we must call the following to include the max value: clipBinsAtEnds = false; // The above function is okay since here we are within the autoMinMax // computation and clearly the user intended to include min and max. } } h_lower[i] = (THistogramMeasurement) lower[i]; } } else { h_lower = m_HistogramMin; h_upper = m_HistogramMax; } // Clearing previous histograms histogramList->Clear(); // For each dimension for (unsigned int comp = 0; comp < inputList->GetMeasurementVectorSize(); ++comp) { // initialize the Histogram object using the sizes and // the upper and lower bound from the FindSampleBound function typename HistogramType::MeasurementVectorType comp_lower(inputList->GetMeasurementVectorSize()); typename HistogramType::MeasurementVectorType comp_upper(inputList->GetMeasurementVectorSize()); comp_lower[0] = h_lower[comp]; comp_upper[0] = h_upper[comp]; otbMsgDevMacro( << "ListSampleToHistogramListGenerator::GenerateData(): Initializing histogram " << comp << " with (size= " << m_Size << ", lower = " << comp_lower << ", upper = " << comp_upper << ")"); // Create a new histogrma for this component : size of the // measurement vector is : 1 histogramList->PushBack(HistogramType::New()); histogramList->Back()->SetMeasurementVectorSize(1); histogramList->Back()->SetClipBinsAtEnds(clipBinsAtEnds); histogramList->Back()->Initialize(m_Size, comp_lower, comp_upper); typename TListSample::ConstIterator iter = inputList->Begin(); typename TListSample::ConstIterator last = inputList->End(); typename HistogramType::IndexType index; typename HistogramType::MeasurementVectorType hvector(inputList->GetMeasurementVectorSize()); while (iter != last) { hvector[0] = static_cast(iter.GetMeasurementVector()[comp]); histogramList->Back()->GetIndex(hvector, index); if( (!m_NoDataFlag) || hvector[0]!=m_NoDataValue ) { if (!histogramList->Back()->IsIndexOutOfBounds(index)) { // if the measurement vector is out of bound then // the GetIndex method has returned an index set to the max size of // the invalid dimension - even if the hvector is less than the minimum // bin value. // If the index isn't valid, we don't increase the frequency. // See the comments in Histogram->GetIndex() for more info. histogramList->Back()->IncreaseFrequencyOfIndex(index, 1); } } ++iter; } } otbMsgDebugMacro(<< "ListSampleToHistogramListGenerator::GenerateData(): Leaving"); } template void ListSampleToHistogramListGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "AutoMinMax: " << m_AutoMinMax << std::endl; os << indent << "Size: " << m_Size << std::endl; os << indent << "MarginalScale: " << m_MarginalScale << std::endl; os << indent << "HistogramMin: " << m_HistogramMin << std::endl; os << indent << "HistogramMax: " << m_HistogramMax << std::endl; } } // end of namespace itk #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleToListSampleFilter.h000066400000000000000000000076141301006202600311400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToListSampleFilter_h #define otbListSampleToListSampleFilter_h #include "otbListSampleSource.h" namespace otb { namespace Statistics { /** \class ListSampleToListSampleFilter * \brief This class is a base class for filters using ListSample as * input and returning ListSample. * * * This filter provide pipeline support for itk::Statistics::ListSample via itk::DataObjectDecorator for * both the input and the output sample list. * * * \ingroup OTBStatistics */ template < class TInputSampleList, class TOutputSampleList = TInputSampleList > class ITK_EXPORT ListSampleToListSampleFilter : public ListSampleSource { public: /** Standard class typedefs */ typedef ListSampleToListSampleFilter Self; typedef ListSampleSource Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ListSampleToListSampleFilter, ListSampleSource); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputSampleList typedefs */ typedef TInputSampleList InputSampleListType; typedef typename InputSampleListType::Pointer InputSampleListPointer; typedef typename InputSampleListType::ConstPointer InputSampleListConstPointer; typedef typename InputSampleListType::MeasurementVectorType InputMeasurementVectorType; typedef typename InputMeasurementVectorType::ValueType InputValueType; /** OutputSampleList typedefs */ typedef typename Superclass::OutputSampleListType OutputSampleListType; typedef typename Superclass::OutputSampleListPointer OutputSampleListPointer; typedef typename Superclass::OutputSampleListConstPointer OutputSampleListConstPointer; typedef typename Superclass::OutputMeasurementVectorType OutputMeasurementVectorType; typedef typename Superclass::OutputValueType OutputValueType; /** ListSample is not a DataObject, we need to decorate it to push it down * a ProcessObject's pipeline */ typedef itk::DataObject::Pointer DataObjectPointer; //typedef itk::DataObjectDecorator< InputSampleListType > InputSampleListObjectType; //typedef typename Superclass::OutputSampleListObjectType OutputSampleListObjectType; /** Method to set/get the input list sample */ using Superclass::SetInput; void SetInput( const InputSampleListType * inputPtr ); //void SetInput( const InputSampleListObjectType * inputPtr ); /** Returns the input sample list */ //const InputSampleListType * GetInputSampleList() const; /** Returns the input sample list as a data object */ const InputSampleListType * GetInput() const; protected: ListSampleToListSampleFilter(); ~ListSampleToListSampleFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ListSampleToListSampleFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; // end of class ListSampleToListSampleFilter } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbListSampleToListSampleFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbListSampleToListSampleFilter.txx000066400000000000000000000041041301006202600315230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToListSample_txx #define otbListSampleToListSample_txx #include "otbListSampleToListSampleFilter.h" #include "itkProgressReporter.h" namespace otb { namespace Statistics { template < class TInputSampleList, class TOutputSampleList > ListSampleToListSampleFilter ::ListSampleToListSampleFilter() { this->SetNumberOfRequiredInputs(1); } template < class TInputSampleList, class TOutputSampleList > void ListSampleToListSampleFilter ::SetInput( const InputSampleListType * inputPtr ) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast< InputSampleListType* >( inputPtr ) ); } template < class TInputSampleList, class TOutputSampleList > const typename ListSampleToListSampleFilter ::InputSampleListType * ListSampleToListSampleFilter ::GetInput() const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } template < class TInputSampleList, class TOutputSampleList > void ListSampleToListSampleFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); } } // End namespace Statistics } // End namespace otb #endif otbListSampleToVariableDimensionHistogramGenerator.h000066400000000000000000000105501301006202600347470ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToVariableDimensionHistogramGenerator_h #define otbListSampleToVariableDimensionHistogramGenerator_h #include "itkProcessObject.h" #include "itkHistogram.h" #include "itkStatisticsAlgorithm.h" namespace otb { /** \class ListSampleToVariableDimensionHistogramGenerator * \brief Generates a VariableDimensionHistogram from a ListSample * * This class is a fork from itk::ListSampleToHistogramGenerator * adapted to produce VariableDimensionHistogram, whose dimension can * be chosen at runtime. * * Since the MeasurementVectorSize template parameter is no longer * needed, it has been removed. * * For more information, please refer to the * ListSampleToHistogramGenerator class documentation. * * \sa VariableDimensionHistogram, ListSample, ListSampleToHistogramGenerator * * \ingroup OTBStatistics */ template class ITK_EXPORT ListSampleToVariableDimensionHistogramGenerator : public itk::ProcessObject { public: /** Standard typedefs */ typedef ListSampleToVariableDimensionHistogramGenerator Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ListSampleToVariableDimensionHistogramGenerator, itk::ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); /** typedef the ListSampleType */ typedef TListSample ListSampleType; /** Type needed for defining the limits of the histogram bins */ typedef typename itk::NumericTraits::RealType HistogramMeasurementRealType; typedef itk::Statistics::Histogram HistogramType; typedef typename HistogramType::SizeType HistogramSizeType; typedef typename HistogramType::MeasurementVectorType MeasurementVectorType; /** DataObject typedef*/ typedef typename Superclass::DataObjectPointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; // Set/Get the input list sample void SetListSample(const ListSampleType* inputlist); const ListSampleType* GetListSample() const; // Get the output histogram const HistogramType* GetOutput(); void SetMarginalScale(float scale) { m_MarginalScale = scale; } void SetNumberOfBins(HistogramSizeType sizes) { m_Sizes = sizes; } itkSetMacro(AutoMinMax, bool); itkGetConstReferenceMacro(AutoMinMax, bool); void SetHistogramMin(const MeasurementVectorType& histogramMin) { m_HistogramMin = histogramMin; m_AutoMinMax = false; } void SetHistogramMax(const MeasurementVectorType& histogramMax) { m_HistogramMax = histogramMax; m_AutoMinMax = false; } protected: ListSampleToVariableDimensionHistogramGenerator(); ~ListSampleToVariableDimensionHistogramGenerator() ITK_OVERRIDE {} void GenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; private: HistogramSizeType m_Sizes; float m_MarginalScale; MeasurementVectorType m_HistogramMin; MeasurementVectorType m_HistogramMax; bool m_AutoMinMax; }; // end of class } // end of namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbListSampleToVariableDimensionHistogramGenerator.txx" #endif #endif otbListSampleToVariableDimensionHistogramGenerator.txx000066400000000000000000000231631301006202600353470ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbListSampleToVariableDimensionHistogramGenerator_txx #define otbListSampleToVariableDimensionHistogramGenerator_txx #include "otbListSampleToVariableDimensionHistogramGenerator.h" #include "otbMacro.h" #include "itkStatisticsAlgorithm.h" namespace otb { template ListSampleToVariableDimensionHistogramGenerator ::ListSampleToVariableDimensionHistogramGenerator():m_Sizes(1) { m_MarginalScale = 100; m_AutoMinMax = true; this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->itk::ProcessObject::SetNthOutput(0, this->MakeOutput(0).GetPointer()); } // Set the input sample list template void ListSampleToVariableDimensionHistogramGenerator ::SetListSample(const ListSampleType* inputlist) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(inputlist)); } // Get the input sample list template const typename ListSampleToVariableDimensionHistogramGenerator ::ListSampleType* ListSampleToVariableDimensionHistogramGenerator ::GetListSample() const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } // Get the output Histogram template const typename ListSampleToVariableDimensionHistogramGenerator ::HistogramType* ListSampleToVariableDimensionHistogramGenerator ::GetOutput() { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } // MakeOutput implementation template typename ListSampleToVariableDimensionHistogramGenerator ::DataObjectPointer ListSampleToVariableDimensionHistogramGenerator ::MakeOutput(DataObjectPointerArraySizeType itkNotUsed(idx)) { DataObjectPointer output; output = static_cast(HistogramType::New().GetPointer()); return output; } // GenerateData method, template void ListSampleToVariableDimensionHistogramGenerator ::GenerateData() { // Get the input ListSample const ListSampleType * inputList = this->GetListSample(); // Get a pointer on the output typename HistogramType::Pointer histogram = const_cast(this->GetOutput()); otbMsgDebugMacro(<< "ListSampleToVariableDimensionHistogramGenerator::GenerateData(): Entering"); // TODO : Sanity checks if (m_Sizes.GetSize() != inputList->GetMeasurementVectorSize()) { itkExceptionMacro("Sample list measurement vectors and histogram bin sizes vector have different dimensions !"); } if (!m_AutoMinMax) { if (m_HistogramMin.GetSize() != inputList->GetMeasurementVectorSize()) { itkExceptionMacro("Sample list measurement vectors and histogram min have different dimensions !"); } if (m_HistogramMax.GetSize() != inputList->GetMeasurementVectorSize()) { itkExceptionMacro("Sample list measurement vectors and histogram max have different dimensions !"); } } typename TListSample::MeasurementVectorType lower(inputList->GetMeasurementVectorSize()); typename TListSample::MeasurementVectorType upper(inputList->GetMeasurementVectorSize()); typename HistogramType::MeasurementVectorType h_upper(inputList->GetMeasurementVectorSize()); typename HistogramType::MeasurementVectorType h_lower(inputList->GetMeasurementVectorSize()); // must test for the list size to avoid making FindSampleBound() segfault. // Also, the min and max can't be found automatically in that case. We can // only return an empty histogram if (m_AutoMinMax && inputList->Size() != 0) { itk::Statistics::Algorithm::FindSampleBound(inputList, inputList->Begin(), inputList->End(), lower, upper); float margin; for (unsigned int i = 0; i < inputList->GetMeasurementVectorSize(); ++i) { if (!itk::NumericTraits::is_integer) { margin = ((THistogramMeasurement) (upper[i] - lower[i]) / (THistogramMeasurement) m_Sizes[i]) / (THistogramMeasurement) m_MarginalScale; h_upper[i] = (THistogramMeasurement) (upper[i] + margin); if (h_upper[i] <= upper[i]) { // an overflow has occurred therefore set upper to upper h_upper[i] = upper[i]; // Histogram measurement type would force the clipping the max value. // Therefore we must call the following to include the max value: histogram->SetClipBinsAtEnds(false); // The above function is okay since here we are within the autoMinMax // computation and clearly the user intended to include min and max. } } else { h_upper[i] = ((THistogramMeasurement) upper[i]) + itk::NumericTraits::One; if (h_upper[i] <= upper[i]) { // an overflow has occurred therefore set upper to upper h_upper[i] = upper[i]; // Histogram measurement type would force the clipping the max value. // Therefore we must call the following to include the max value: histogram->SetClipBinsAtEnds(false); // The above function is okay since here we are within the autoMinMax // computation and clearly the user intended to include min and max. } } h_lower[i] = (THistogramMeasurement) lower[i]; } } else { h_lower = m_HistogramMin; h_upper = m_HistogramMax; } // initialize the Histogram object using the sizes and // the upper and lower bound from the FindSampleBound function // Have to Set the MeasurementVectorSize histogram->SetMeasurementVectorSize(inputList->GetMeasurementVectorSize()); otbMsgDevMacro( << "ListSampleToVariableDimensionHistogramGenerator::GenerateData(): Initializing histogram with (sizes= " << m_Sizes << ", lower = " << h_lower << ", upper = " << h_upper << ")"); histogram->Initialize(m_Sizes, h_lower, h_upper); otbMsgDevMacro(<< "ListSampleToVariableDimensionHistogramGenerator::GenerateData(): Histogram initialized"); typename TListSample::ConstIterator iter = inputList->Begin(); typename TListSample::ConstIterator last = inputList->End(); typename HistogramType::IndexType index(inputList->GetMeasurementVectorSize()); typename TListSample::MeasurementVectorType lvector(inputList->GetMeasurementVectorSize()); typename HistogramType::MeasurementVectorType hvector(inputList->GetMeasurementVectorSize()); unsigned int i; otbMsgDevMacro(<< "ListSampleToVariableDimensionHistogramGenerator::GenerateData(): Filling the histogram"); while (iter != last) { lvector = iter.GetMeasurementVector(); for (i = 0; i < inputList->GetMeasurementVectorSize(); ++i) { hvector[i] = (THistogramMeasurement) lvector[i]; } histogram->GetIndex(hvector, index); if (!histogram->IsIndexOutOfBounds(index)) { // if the measurement vector is out of bound then // the GetIndex method has returned an index set to the max size of // the invalid dimension - even if the hvector is less than the minimum // bin value. // If the index isn't valid, we don't increase the frequency. // See the comments in Histogram->GetIndex() for more info. histogram->IncreaseFrequencyOfIndex(index, 1); } ++iter; } otbMsgDebugMacro(<< "ListSampleToVariableDimensionHistogramGenerator::GenerateData(): Leaving"); } template void ListSampleToVariableDimensionHistogramGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "AutoMinMax: " << m_AutoMinMax << std::endl; os << indent << "Sizes: " << m_Sizes << std::endl; os << indent << "MarginalScale: " << m_MarginalScale << std::endl; os << indent << "HistogramMin: " << m_HistogramMin << std::endl; os << indent << "HistogramMax: " << m_HistogramMax << std::endl; } } // end of namespace itk #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbLocalHistogramImageFunction.h000066400000000000000000000122761301006202600307750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalHistogramImageFunction_h #define otbLocalHistogramImageFunction_h #include "itkImageFunction.h" #include "itkHistogram.h" #include "itkNumericTraits.h" namespace otb { /** * \class LocalHistogramImageFunction * \brief Calculate a local histogram over a specified circular neighborhood * * This image function computes the local histogram of the pixels lying * in a circular neighborhood around the given position. * * Pixel count can be optionnaly weighted by a gaussian kernel with * \f$ \sigma = 0.5 radius \f$ so that pixel far from the center position * account less in the histogram than pixel near the center position. * This option can be deactivated using the GaussianSmoothing flag. * * Histogram mininimum value, maximum value and number of bins can be * set using the Setters/Getters. * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double). * * \ingroup ImageFunctions * * \ingroup OTBStatistics */ template class ITK_EXPORT LocalHistogramImageFunction : public itk::ImageFunction< TInputImage, typename itk::Statistics::Histogram::Pointer, TCoordRep > { public: /** Standard class typedefs. */ typedef LocalHistogramImageFunction Self; typedef itk::ImageFunction< TInputImage, typename itk::Statistics::Histogram::Pointer, TCoordRep > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(LocalHistogramImageFunction, ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; typedef typename Superclass::OutputType OutputType; typedef itk::Statistics::Histogram HistogramType; typedef typename HistogramType::Pointer HistogramPointer; typedef TCoordRep CoordRepType; /** Dimension of the underlying image. */ itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the radius of the neighborhood over which the * statistics are evaluated */ itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); /** Set/Get the number of histogram bins. Default is 128. */ itkSetClampMacro( NumberOfHistogramBins, unsigned long, 1, itk::NumericTraits::max() ); itkGetConstMacro( NumberOfHistogramBins, unsigned long ); itkSetMacro( HistogramMin, double ); itkGetConstReferenceMacro( HistogramMin, double ); itkSetMacro( HistogramMax, double ); itkGetConstReferenceMacro( HistogramMax, double ); itkSetMacro(GaussianSmoothing, bool); itkGetConstReferenceMacro(GaussianSmoothing, bool); itkBooleanMacro(GaussianSmoothing); protected: LocalHistogramImageFunction(); ~LocalHistogramImageFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LocalHistogramImageFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NeighborhoodRadius; unsigned long m_NumberOfHistogramBins; double m_HistogramMin; double m_HistogramMax; bool m_GaussianSmoothing; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLocalHistogramImageFunction.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbLocalHistogramImageFunction.txx000066400000000000000000000111761301006202600313670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalHistogramImageFunction_txx #define otbLocalHistogramImageFunction_txx #include "otbLocalHistogramImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "itkExtractImageFilter.h" #include "otbMath.h" namespace otb { /** * Constructor */ template LocalHistogramImageFunction ::LocalHistogramImageFunction() : m_NeighborhoodRadius(1), m_NumberOfHistogramBins(128), m_HistogramMin(0), m_HistogramMax(1), m_GaussianSmoothing(true) { } template void LocalHistogramImageFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " Neighborhood radius value : " << this->GetNeighborhoodRadius() << std::endl; os << indent << " Number Of Histogram Bins : " << this->GetNumberOfHistogramBins() << std::endl; os << indent << " Histogram Minimum : " << this->GetHistogramMin() << std::endl; os << indent << " Histogram Maximum : " << this->GetHistogramMax() << std::endl; } template typename LocalHistogramImageFunction::OutputType LocalHistogramImageFunction ::EvaluateAtIndex(const IndexType& index) const { typename HistogramType::Pointer histogram = HistogramType::New(); typename HistogramType::SizeType size(this->GetInputImage()->GetNumberOfComponentsPerPixel()); size.Fill(this->GetNumberOfHistogramBins()); typename HistogramType::MeasurementVectorType lowerBound(this->GetInputImage()->GetNumberOfComponentsPerPixel()); typename HistogramType::MeasurementVectorType upperBound(this->GetInputImage()->GetNumberOfComponentsPerPixel()); lowerBound.Fill( static_cast(this->GetHistogramMin()) ); upperBound.Fill( static_cast(this->GetHistogramMax()) ); histogram->SetMeasurementVectorSize(this->GetInputImage()->GetNumberOfComponentsPerPixel()); histogram->Initialize(size, lowerBound, upperBound ); histogram->SetToZero(); // Check for input image if( !this->GetInputImage() ) { return histogram; } // Check for out of buffer if ( !this->IsInsideBuffer( index ) ) { return histogram; } // Create an N-d neighborhood kernel, using a zeroflux boundary condition typename InputImageType::SizeType kernelSize; kernelSize.Fill( m_NeighborhoodRadius ); itk::ConstNeighborhoodIterator it(kernelSize, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion()); // Set the iterator at the desired location it.SetLocation(index); // Define a gaussian kernel around the center location double squaredRadius = m_NeighborhoodRadius * m_NeighborhoodRadius; double squaredSigma = 0.25 * squaredRadius; // Offset to be used in the loops typename InputImageType::OffsetType offset; // Fill the histogram for(int i = -(int)m_NeighborhoodRadius; i< (int)m_NeighborhoodRadius; ++i) { for(int j = -(int)m_NeighborhoodRadius; j< (int)m_NeighborhoodRadius; ++j) { // Check if the current pixel lies within a disc of radius m_NeighborhoodRadius double currentSquaredRadius = i*i+j*j; if(currentSquaredRadius < squaredRadius) { // If so, compute the gaussian weighting (this could be // computed once for all for the sake of optimisation) if necessary double gWeight = 1.; if(m_GaussianSmoothing) { gWeight = (1/vcl_sqrt(otb::CONST_2PI*squaredSigma)) * vcl_exp(- currentSquaredRadius/(2*squaredSigma)); } // Compute pixel location offset[0]=i; offset[1]=j; // Get the current value typename HistogramType::MeasurementVectorType sample(this->GetInputImage()->GetNumberOfComponentsPerPixel()); sample[0] = it.GetPixel(offset); // Populate histogram histogram->IncreaseFrequencyOfMeasurement(sample, gWeight); } } } return histogram; } } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbNormalizeVectorImageFilter.h000066400000000000000000000143331301006202600306440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalizeVectorImageFilter_h #define otbNormalizeVectorImageFilter_h #include #include #include #include #include namespace otb { namespace Functor { /** \brief NormalizeVectorImageFunctor * \brief this functor performs affine transformation on VariableLengthVectors */ template < class TInput, class TOutput > class NormalizeVectorImageFunctor { public: NormalizeVectorImageFunctor() { } virtual ~NormalizeVectorImageFunctor () { } typedef typename itk::NumericTraits< TInput >::RealType RealVectorType; typedef typename itk::NumericTraits< typename RealVectorType::ValueType >::RealType RealType; TOutput operator() ( const TInput & input ) { unsigned int length = input.Size(); TOutput output ( length ); for ( unsigned int i = 0; i < length; ++i ) { output[i] = static_cast( ( static_cast< RealType >( input[i] ) - m_Mean[i] ) / m_StdDev[i] ); } return output; } template < class T > void SetMean ( const itk::VariableLengthVector & m ) { m_Mean.SetSize( m.Size() ); for ( unsigned int i = 0; i < m_Mean.Size(); ++i ) m_Mean[i] = static_cast< RealType >( m[i] ); } RealVectorType GetMean() const { return this->m_Mean; } template < class T> void SetStdDev ( const itk::VariableLengthVector & sigma ) { m_StdDev.SetSize( sigma.Size() ); for ( unsigned int i = 0; i < m_StdDev.Size(); ++i ) { m_StdDev[i] = static_cast< RealType >( sigma[i] ); if ( m_StdDev[i] == itk::NumericTraits< RealType >::Zero ) { throw itk::ExceptionObject(__FILE__, __LINE__, "Cannot divide by zero !", ITK_LOCATION); } } } template < class T > void SetVariance ( const itk::VariableLengthVector & var ) { m_StdDev.SetSize( var.Size() ); for ( unsigned int i = 0; i < m_StdDev.Size(); ++i ) { m_StdDev[i] = vcl_sqrt( static_cast< RealType >( var[i] ) ); if ( m_StdDev[i] == itk::NumericTraits< RealType >::Zero ) { throw itk::ExceptionObject(__FILE__, __LINE__, "Cannot divide by zero !", ITK_LOCATION); } } } RealVectorType GetStdDev() const { return this->m_StdDev; } protected: RealVectorType m_Mean; RealVectorType m_StdDev; }; // end of class NormalizeVectorImageFunctor } // end of namespace Functor /** \class NormalizeVectorImageFilter * \brief Normalize an VectorImage by setting its mean to zero and possibly variance to one (band by band). * * NormalizeVectorImageFilter shifts and scales an image so that the pixels in the image * have a zero mean and unit variance. * * This filter uses StreamingStatisticsVectorImageFilter to compute the mean and variance of * the input and then applies the dedicated functor. * * \sa StreamingStatisticsVectorImageFilter * * \ingroup OTBStatistics */ template < class TInputImage, class TOutputImage > class ITK_EXPORT NormalizeVectorImageFilter : public UnaryFunctorVectorImageFilter< TInputImage, TOutputImage, Functor::NormalizeVectorImageFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType > > { public: /** Standard class typedefs */ typedef NormalizeVectorImageFilter Self; typedef UnaryFunctorVectorImageFilter< TInputImage, TOutputImage, Functor::NormalizeVectorImageFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NormalizeVectorImageFilter, ImageToImageFilter); typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename itk::NumericTraits< typename TInputImage::PixelType >::RealType RealVectorType; typedef typename itk::NumericTraits< typename RealVectorType::ValueType >::RealType RealType; typedef StreamingStatisticsVectorImageFilter< InputImageType > CovarianceEstimatorFilterType; typedef typename CovarianceEstimatorFilterType::Pointer CovarianceEstimatorFilterPointerType; itkGetConstMacro(CovarianceEstimator, CovarianceEstimatorFilterType*); template < class T > void SetMean ( const itk::VariableLengthVector & m ) { this->GetFunctor().SetMean( m ); m_IsGivenMean = true; m_UseMean = true; this->Modified(); } template < class T > void SetStdDev ( const itk::VariableLengthVector & sigma ) { this->GetFunctor().SetStdDev( sigma ); m_IsGivenStdDev = true; m_UseStdDev = true; this->Modified(); } template < class T > void SetVariance ( const itk::VariableLengthVector & var ) { this->GetFunctor().SetVariance( var ); m_IsGivenStdDev = true; m_UseStdDev = true; this->Modified(); } itkSetMacro(UseMean, bool); itkSetMacro(UseStdDev, bool); protected: NormalizeVectorImageFilter (); ~NormalizeVectorImageFilter() ITK_OVERRIDE { } void GenerateOutputInformation() ITK_OVERRIDE; private: NormalizeVectorImageFilter ( const Self & ); void operator=( const Self & ); bool m_IsGivenMean; bool m_IsGivenStdDev; bool m_UseMean; bool m_UseStdDev; CovarianceEstimatorFilterPointerType m_CovarianceEstimator; }; // end of class NormalizeVectorImageFilter } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNormalizeVectorImageFilter.txx" #endif #endif // otbNormalizeVectorImageFilter_h OTB-release-5.8/Modules/Filtering/Statistics/include/otbNormalizeVectorImageFilter.txx000066400000000000000000000047551301006202600312470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalizeVectorImageFilter_txx #define otbNormalizeVectorImageFilter_txx #include "otbNormalizeVectorImageFilter.h" namespace otb { template < class TInputImage, class TOutputImage > NormalizeVectorImageFilter< TInputImage, TOutputImage > ::NormalizeVectorImageFilter () { m_IsGivenMean = false; m_IsGivenStdDev = false; m_UseMean = true; m_UseStdDev = true; m_CovarianceEstimator = CovarianceEstimatorFilterType::New(); } template < class TInputImage, class TOutputImage > void NormalizeVectorImageFilter< TInputImage, TOutputImage > ::GenerateOutputInformation() { // Call superclass implementation Superclass::GenerateOutputInformation(); if( (m_UseMean && !m_IsGivenMean) || (m_UseStdDev && !m_IsGivenStdDev)) { m_CovarianceEstimator->SetInput( const_cast( this->GetInput() ) ); m_CovarianceEstimator->Update(); } if ( !m_UseMean ) { typename TInputImage::PixelType vector ( this->GetInput()->GetNumberOfComponentsPerPixel() ); vector.Fill( itk::NumericTraits< typename TInputImage::PixelType::ValueType >::Zero ); this->GetFunctor().SetMean( vector ); } if ( !m_UseStdDev ) { typename TInputImage::PixelType vector ( this->GetInput()->GetNumberOfComponentsPerPixel() ); vector.Fill( itk::NumericTraits< typename TInputImage::PixelType::ValueType >::One ); this->GetFunctor().SetStdDev( vector ); } if ( !m_IsGivenMean ) { this->GetFunctor().SetMean( m_CovarianceEstimator->GetMean() ); if ( !m_IsGivenStdDev && m_UseStdDev ) { typename StreamingStatisticsVectorImageFilter< InputImageType >::RealPixelType sigma ( this->GetInput()->GetNumberOfComponentsPerPixel() ); for ( unsigned int i = 0; i < sigma.Size(); ++i ) sigma[i] = vcl_sqrt( m_CovarianceEstimator->GetCovariance()(i, i) ); this->GetFunctor().SetStdDev( sigma ); } } } } // end of namespace otb #endif // otbNormalizeVectorImageFilter_txx OTB-release-5.8/Modules/Filtering/Statistics/include/otbPatternSampler.h000066400000000000000000000075231301006202600263540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPatternSampler_h #define otbPatternSampler_h #include "otbSamplerBase.h" namespace otb { /** * \class PatternSampler * * \brief Periodic sampler for iteration loops * * This class allows doing periodic sampling during an iteration loop. * * \ingroup OTBStatistics */ class ITK_EXPORT PatternSampler : public SamplerBase { public: typedef PatternSampler Self; typedef SamplerBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Internal parameters, only contains an offset to shift the periodic * sampling */ typedef struct Parameter { /** Maximum size of the internal patterns */ unsigned long MaxPatternSize; /** First sampling pattern */ std::vector Pattern1; /** Second sampling pattern (can be empty). * It is called when the first pattern returns false */ std::vector Pattern2; /** Seed used to randomly generate patterns (used only if greater than 0) */ unsigned int Seed; bool operator!=(const struct Parameter & param) const; } ParameterType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PatternSampler,SamplerBase); /** Setter for internal parameters */ void SetParameters(const ParameterType ¶m) { if (m_Parameters != param) { this->Modified(); m_Parameters = param; } } /** Getter for internal parameters */ ParameterType GetParameters() { return m_Parameters; } /** * Method that resets the internal state of the sampler */ void Reset(void) ITK_OVERRIDE; /** * Method to call during iteration, returns true if the sample is selected, * and false otherwise. */ bool TakeSample(void); /** Import sampling patterns from an input string * Two patterns may be given, separated by a slash * Beware, the second pattern may be empty */ static void ImportPatterns( const std::string &data, ParameterType ¶m); /** Export the sampling patterns in the input parameter to * an output string. If the second pattern is not empty, it will be * concatenated to the output string, separated by a slash */ static void ExportPatterns( const ParameterType ¶m, std::string &data); protected: /** Constructor */ PatternSampler(); /** Destructor */ ~PatternSampler() ITK_OVERRIDE {} private: // Not implemented PatternSampler(const Self&); void operator=(const Self&); /** Generate a random array of booleans */ std::vector RandArray(unsigned long N,unsigned long T); /** Find a suitable size for internal patterns */ unsigned long FindBestSize(unsigned long tot); /** Internal parameters for the sampler */ ParameterType m_Parameters; /** Index tracking the position in first internal pattern */ unsigned long m_Index1; /** Index tracking the position in the second internal pattern */ unsigned long m_Index2; /** Helper function to decode boolean sequence * Caracters converted into true : '1' 'X' 'y' 'Y' '|' '+' * Caracters converted into false : '0' '_' 'n' 'N' '.' '-' * Other caracters will return a 2 */ static unsigned int ParseSymbol(const char &s); }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbPeriodicSampler.h000066400000000000000000000052711301006202600264730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPeriodicSampler_h #define otbPeriodicSampler_h #include "otbSamplerBase.h" namespace otb { /** * \class PeriodicSampler * * \brief Periodic sampler for iteration loops * * This class allows doing periodic sampling during an iteration loop. * * \ingroup OTBStatistics */ class ITK_EXPORT PeriodicSampler : public SamplerBase { public: typedef PeriodicSampler Self; typedef SamplerBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Internal parameters, only contains an offset to shift the periodic * sampling */ typedef struct Parameter { /** Offset that shifts the whole periodic sampling * (disabled if jitter is used) */ unsigned long Offset; /** Maximum jitter to introduce (0 means no jitter) */ unsigned long MaxJitter; bool operator!=(const struct Parameter & param) const; } ParameterType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PeriodicSampler,SamplerBase); /** Setter for internal parameters */ void SetParameters(const ParameterType ¶m) { if (m_Parameters != param) { this->Modified(); m_Parameters = param; } } /** Getter for internal parameters */ ParameterType GetParameters() { return m_Parameters; } /** * Method that resets the internal state of the sampler */ void Reset(void) ITK_OVERRIDE; /** * Method to call during iteration, returns true if the sample is selected, * and false otherwise. */ bool TakeSample(void); protected: /** Constructor */ PeriodicSampler(); /** Destructor */ ~PeriodicSampler() ITK_OVERRIDE {} private: // Not implemented PeriodicSampler(const Self&); void operator=(const Self&); /** Internal parameters for the sampler */ ParameterType m_Parameters; /** Internal width for jitter */ double m_JitterSize; /** Internal current offset value * (either fixed, or reset each time a sample is taken)*/ double m_OffsetValue; }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbRandomSampler.h000066400000000000000000000051421301006202600261520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRandomSampler_h #define otbRandomSampler_h #include "otbSamplerBase.h" namespace otb { /** * \class RandomSampler * * \brief Random sampler for iteration loops * * This class allows doing random sampling during an iteration loop. * It uses the MersenneTwisterRandomGenerator. * * \ingroup OTBStatistics */ class ITK_EXPORT RandomSampler : public SamplerBase { public: typedef RandomSampler Self; typedef SamplerBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Internal parameters, only contains an offset to shift the periodic * sampling */ typedef struct Parameter { /** Maximum buffer size to generate permutations */ unsigned long MaxBufferSize; bool operator!=(const struct Parameter & param) const; } ParameterType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(RandomSampler,SamplerBase); /** Setter for internal parameters */ void SetParameters(const ParameterType ¶m) { if (m_Parameters != param) { this->Modified(); m_Parameters = param; } } /** Getter for internal parameters */ ParameterType GetParameters() { return m_Parameters; } /** * Reset internal counter (to be called before starting iteration) */ void Reset(void) ITK_OVERRIDE; /** * Method to call during iteration, returns true if the sample is selected, * and false otherwise. */ bool TakeSample(void); protected: /** Constructor */ RandomSampler(); /** Destructor */ ~RandomSampler() ITK_OVERRIDE {} private: // Not implemented RandomSampler(const Self&); void operator=(const Self&); /** Internal parameters for the sampler */ ParameterType m_Parameters; /** Internal list of positions to select */ std::vector m_Positions; /** Internal current position */ std::vector::iterator m_CurrentPosition; }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbSamplerBase.h000066400000000000000000000052351301006202600256070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSamplerBase_h #define otbSamplerBase_h #include "itkObject.h" #include "itkObjectFactory.h" namespace otb { /** * \class SamplerBase * * \brief This is a base class for sampling methods * * \ingroup OTBStatistics */ class ITK_EXPORT SamplerBase : public itk::Object { public: typedef SamplerBase Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Runtime information support. */ itkTypeMacro(SamplerBase, itk::Object); /** * Reset internal counter (to be called before starting iteration) */ virtual void Reset(void); /** method to set the number of needed and total elements * the sampling rate is automatically updated */ void SetNumberOfElements(unsigned long needed, unsigned long total); /** method to set the sampling rate, if the total number of elements * is given, the number of needed elements is updated */ void SetRate(double rate, unsigned long total=0UL); /** Get macro for sampling rate */ itkGetMacro(Rate,double); /** Get macro for the total number of elements */ itkGetMacro(TotalElements,unsigned long); /** Get macro for the number of needed elements */ itkGetMacro(NeededElements,unsigned long); /** Get macro for the current number of chosen elements */ itkGetMacro(ChosenElements, unsigned long); /** Get macro for the current number of processed elements */ itkGetMacro(ProcessedElements,unsigned long); protected: /** Constructor */ SamplerBase(); /** Destructor */ ~SamplerBase() ITK_OVERRIDE {} /** Current count of selected elements */ unsigned long m_ChosenElements; /** Current count of encountered elements during iteration */ unsigned long m_ProcessedElements; private: // Not implemented SamplerBase(const Self&); void operator=(const Self&); /** Total number of elements during the iteration */ unsigned long m_TotalElements; /** Number of elements to select during the iteration */ unsigned long m_NeededElements; /** Sampling rate */ double m_Rate; }; } // namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbShiftScaleSampleListFilter.h000066400000000000000000000100211301006202600305670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbShiftScaleSampleListFilter_h #define otbShiftScaleSampleListFilter_h #include "otbListSampleToListSampleFilter.h" namespace otb { namespace Statistics { /** \class ShiftScaleSampleListFilter * \brief This class generate a shifted and scaled version of the input sample list * * For each component of the sample, the following formula is applied : * * \f[ output = \frac{input - shift}{scale} \f] * * Beware that the behaviour differs from itk::ShiftScaleImageFilter * (which add shift instead of subtracting it). * * Standard casting is applied between input and output type. * * Shifts and scales can be set via the SetShift() and SetScales() methods. * * \sa ListSampleToListSampleFilter * * \ingroup OTBStatistics */ template < class TInputSampleList, class TOutputSampleList = TInputSampleList > class ITK_EXPORT ShiftScaleSampleListFilter : public otb::Statistics::ListSampleToListSampleFilter { public: /** Standard class typedefs */ typedef ShiftScaleSampleListFilter Self; typedef otb::Statistics::ListSampleToListSampleFilter Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ShiftScaleSampleListFilter, otb::Statistics::ListSampleToListSampleFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputSampleList typedefs */ typedef TInputSampleList InputSampleListType; typedef typename InputSampleListType::Pointer InputSampleListPointer; typedef typename InputSampleListType::ConstPointer InputSampleListConstPointer; typedef typename InputSampleListType::MeasurementVectorType InputMeasurementVectorType; typedef typename InputMeasurementVectorType::ValueType InputValueType; /** OutputSampleList typedefs */ typedef TOutputSampleList OutputSampleListType; typedef typename OutputSampleListType::Pointer OutputSampleListPointer; typedef typename OutputSampleListType::ConstPointer OutputSampleListConstPointer; typedef typename OutputSampleListType::MeasurementVectorType OutputMeasurementVectorType; typedef typename OutputMeasurementVectorType::ValueType OutputValueType; /** Set/Get the Shifts for this sample list */ itkSetMacro(Shifts, InputMeasurementVectorType); itkGetMacro(Shifts, InputMeasurementVectorType); /** Set/Get the Scales for this sample list */ itkSetMacro(Scales, InputMeasurementVectorType); itkGetMacro(Scales, InputMeasurementVectorType); protected: /** This method causes the filter to generate its output. */ void GenerateData() ITK_OVERRIDE; ShiftScaleSampleListFilter(); ~ShiftScaleSampleListFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ShiftScaleSampleListFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** The vector of Shifts */ InputMeasurementVectorType m_Shifts; /** The vector of Scales */ InputMeasurementVectorType m_Scales; }; // end of class ShiftScaleSampleListFilter } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbShiftScaleSampleListFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbShiftScaleSampleListFilter.txx000066400000000000000000000073731301006202600312030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbShiftScaleSampleListFilter_txx #define otbShiftScaleSampleListFilter_txx #include "otbShiftScaleSampleListFilter.h" #include "itkProgressReporter.h" namespace otb { namespace Statistics { template < class TInputSampleList, class TOutputSampleList > ShiftScaleSampleListFilter ::ShiftScaleSampleListFilter(){} template < class TInputSampleList, class TOutputSampleList > void ShiftScaleSampleListFilter ::GenerateData() { // Retrieve input and output pointers InputSampleListConstPointer inputSampleListPtr = this->GetInput(); OutputSampleListPointer outputSampleListPtr = this->GetOutput(); outputSampleListPtr->SetMeasurementVectorSize(inputSampleListPtr->GetMeasurementVectorSize()); // Check if the inputSampleList is not empty if(inputSampleListPtr->Size() == 0) itkExceptionMacro(<< "Input Sample List is empty"); // Check if the size of the scale and the shift measurement vectors // are the same than the input vector if(inputSampleListPtr->GetMeasurementVectorSize() != m_Scales.Size() || inputSampleListPtr->GetMeasurementVectorSize() != m_Shifts.Size()) itkExceptionMacro(<< "Inconsistent measurement vector size : Input Sample List size " << inputSampleListPtr->GetMeasurementVectorSize() << " Scale measurement vector size " <Clear(); typename InputSampleListType::ConstIterator inputIt = inputSampleListPtr->Begin(); // Set-up progress reporting itk::ProgressReporter progress(this, 0, inputSampleListPtr->Size()); // Iterate on the InputSampleList while(inputIt != inputSampleListPtr->End()) { // Retrieve current input sample InputMeasurementVectorType currentInputMeasurement = inputIt.GetMeasurementVector(); // Build current output sample OutputMeasurementVectorType currentOutputMeasurement; currentOutputMeasurement.SetSize(currentInputMeasurement.GetSize()); // Center and reduce each component for(unsigned int idx = 0; idx < invertedScales.Size(); ++idx) { currentOutputMeasurement[idx] = static_cast( (currentInputMeasurement[idx]-m_Shifts[idx])*invertedScales[idx]); } // Add the current output sample to the output SampleList outputSampleListPtr->PushBack(currentOutputMeasurement); // Update progress progress.CompletedPixel(); ++inputIt; } } template < class TInputSampleList, class TOutputSampleList > void ShiftScaleSampleListFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); } } // End namespace Statistics } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingCompareImageFilter.h000066400000000000000000000243611301006202600307630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingCompareImageFilter_h #define otbStreamingCompareImageFilter_h #include "otbPersistentImageFilter.h" #include "itkNumericTraits.h" #include "itkArray.h" #include "itkSimpleDataObjectDecorator.h" #include "otbPersistentFilterStreamingDecorator.h" namespace otb { /** \class PersistentCompareImageFilter * \brief Compute mean squared error, mean absolute error and PSNR of two imagee using the output requested region. * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output estimators will be the estimators of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the estimators once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentCompareImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentCompareImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentCompareImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Type to use for computations. */ typedef typename itk::NumericTraits::RealType RealType; /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; /** Type of DataObjects used for scalar outputs */ typedef itk::SimpleDataObjectDecorator RealObjectType; typedef itk::SimpleDataObjectDecorator PixelObjectType; /** Get the inputs */ const TInputImage * GetInput1(); const TInputImage * GetInput2(); /** Connect one the first operands. */ void SetInput1(const TInputImage *image); /** Connect one the second operands. */ void SetInput2(const TInputImage *image); /** Return the computed PSNR. */ RealType GetPSNR() const { return this->GetPSNROutput()->Get(); } RealObjectType* GetPSNROutput(); const RealObjectType* GetPSNROutput() const; /** Return the computed MSE. */ RealType GetMSE() const { return this->GetMSEOutput()->Get(); } RealObjectType* GetMSEOutput(); const RealObjectType* GetMSEOutput() const; /** Return the computed MAE. */ RealType GetMAE() const { return this->GetMAEOutput()->Get(); } RealObjectType* GetMAEOutput(); const RealObjectType* GetMAEOutput() const; /** Return the Number of Pixel which are different. */ RealType GetDiffCount() const { return this->GetDiffCountOutput()->Get(); } RealObjectType* GetDiffCountOutput(); const RealObjectType* GetDiffCountOutput() const; itkGetMacro(PhysicalSpaceCheck,bool); itkSetMacro(PhysicalSpaceCheck,bool); /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; protected: PersistentCompareImageFilter(); ~PersistentCompareImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Allows skipping the verification of physical space between * the two input images (see flag m_PhysicalSpaceCheck) */ void VerifyInputInformation() ITK_OVERRIDE; private: PersistentCompareImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented itk::Array m_SquareOfDifferences; itk::Array m_AbsoluteValueOfDifferences; itk::Array m_ThreadMinRef; itk::Array m_ThreadMaxRef; itk::Array m_Count; itk::Array m_DiffCount; bool m_PhysicalSpaceCheck; }; // end of class PersistentCompareImageFilter /*===========================================================================*/ /** \class StreamingCompareImageFilter * \brief This class streams the whole input image through the PersistentCompareImageFilter. * * This way, it allows computing estimator on two images. It calls the * Reset() method of the PersistentCompareImageFilter before streaming the image and the * Synthetize() method of the PersistentCompareImageFilter after having streamed the image * to compute the estimators. The accessor on the results are wrapping the accessors of the * internal PersistentCompareImageFilter. * * This filter can be used as: * \code * typedef otb::StreamingCompareImageFilter CompareType; * CompareType::Pointer estimators = CompareType::New(); * estimators->SetInput(reader->GetOutput()); * estimators->Update(); * std::cout << estimators-> GetMSE() << std::endl; * std::cout << estimators-> GetPSNR() << std::endl; * \endcode * * \sa PersistentCompareImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * * \ingroup OTBStatistics */ template class ITK_EXPORT StreamingCompareImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingCompareImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingCompareImageFilter, PersistentFilterStreamingDecorator); typedef typename Superclass::FilterType CompareFilterType; typedef typename CompareFilterType::PixelType PixelType; typedef typename CompareFilterType::RealType RealType; typedef TInputImage InputImageType; /** Type of DataObjects used for scalar outputs */ typedef itk::SimpleDataObjectDecorator RealObjectType; typedef itk::SimpleDataObjectDecorator PixelObjectType; /** Connect one the first operands. */ void SetInput1(InputImageType * input) { this->GetFilter()->SetInput1(input); } /** Connect one the second operands. */ void SetInput2(InputImageType * input) { this->GetFilter()->SetInput2(input); } /** Return the computed PSNR. */ RealType GetPSNR() const { return this->GetFilter()->GetPSNROutput()->Get(); } RealObjectType* GetPSNROutput() { return this->GetFilter()->GetPSNROutput(); } const RealObjectType* GetPSNROutput() const { return this->GetFilter()->GetPSNROutput(); } /** Return the computed MSE. */ RealType GetMSE() const { return this->GetMSEOutput()->Get(); } RealObjectType* GetMSEOutput() { return this->GetFilter()->GetMSEOutput(); } const RealObjectType* GetMSEOutput() const { return this->GetFilter()->GetMSEOutput(); } /** Return the computed MAE. */ RealType GetMAE() const { return this->GetFilter()->GetMAEOutput()->Get(); } RealObjectType* GetMAEOutput() { return this->GetFilter()->GetMAEOutput(); } const RealObjectType* GetMAEOutput() const { return this->GetFilter()->GetMAEOutput(); } /** Return the Number of Pixel different. */ RealType GetDiffCount() const { return this->GetFilter()->GetDiffCountOutput()->Get(); } RealObjectType* GetDiffCountOutput() { return this->GetFilter()->GetDiffCountOutput(); } const RealObjectType* GetDiffCountOutput() const { return this->GetFilter()->GetDiffCountOutput(); } /** Set the PhysicalSpaceCheck flag */ void SetPhysicalSpaceCheck(bool flag) { this->GetFilter()->SetPhysicalSpaceCheck(flag); } /** Get the PhysicalSpaceCheck flag */ bool GetPhysicalSpaceCheck() { return this->GetFilter()->GetPhysicalSpaceCheck(); } protected: /** Constructor */ StreamingCompareImageFilter() {}; /** Destructor */ ~StreamingCompareImageFilter() ITK_OVERRIDE {} private: StreamingCompareImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingCompareImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingCompareImageFilter.txx000066400000000000000000000256771301006202600313720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingCompareImageFilter_txx #define otbStreamingCompareImageFilter_txx #include "otbStreamingCompareImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkMath.h" #include "otbMacro.h" namespace otb { template PersistentCompareImageFilter ::PersistentCompareImageFilter() : m_SquareOfDifferences(1), m_AbsoluteValueOfDifferences(1), m_ThreadMinRef(1), m_ThreadMaxRef(1), m_Count(1), m_DiffCount(1), m_PhysicalSpaceCheck(true) { this->SetNumberOfRequiredInputs( 2 ); // first output is a copy of the image, DataObject created by // superclass // allocate the data objects for the outputs which are // just decorators around real types for (int i = 1; i < 5; ++i) { typename RealObjectType::Pointer output = static_cast(this->MakeOutput(i).GetPointer()); this->itk::ProcessObject::SetNthOutput(i, output.GetPointer()); } this->GetPSNROutput()->Set(itk::NumericTraits::max()); this->GetMSEOutput()->Set(itk::NumericTraits::max()); this->GetMAEOutput()->Set(itk::NumericTraits::max()); this->GetDiffCountOutput()->Set(itk::NumericTraits::Zero); this->Reset(); } /** * Connect one of the first operand */ template void PersistentCompareImageFilter ::SetInput1(const TInputImage *image) { // The ProcessObject is not const-correct so the const_cast is required here this->SetNthInput(0, const_cast(image)); } /** * Connect one of the second operand */ template void PersistentCompareImageFilter ::SetInput2(const TInputImage *image) { // The ProcessObject is not const-correct so the const_cast is required here this->SetNthInput(1, const_cast(image)); } template const TInputImage * PersistentCompareImageFilter ::GetInput1() { if (this->GetNumberOfInputs()<1) { return 0; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TInputImage * PersistentCompareImageFilter ::GetInput2() { if (this->GetNumberOfInputs()<2) { return 0; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template typename itk::DataObject::Pointer PersistentCompareImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { switch (output) { case 0: return static_cast(TInputImage::New().GetPointer()); break; case 1: case 2: case 3: case 4: return static_cast(RealObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputImage::New().GetPointer()); break; } } template typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetPSNROutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetPSNROutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetMSEOutput() { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template const typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetMSEOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetMAEOutput() { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template const typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetMAEOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetDiffCountOutput() { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template const typename PersistentCompareImageFilter::RealObjectType* PersistentCompareImageFilter ::GetDiffCountOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template void PersistentCompareImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentCompareImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentCompareImageFilter ::Synthetize() { int i; unsigned long count; unsigned long diffCount; RealType squareOfDifferences, absoluteValueOfDifferences; int numberOfThreads = this->GetNumberOfThreads(); PixelType minimumRef, maximumRef; RealType mse; RealType mae; RealType psnr; squareOfDifferences = absoluteValueOfDifferences = itk::NumericTraits::Zero; count = 0; diffCount=0; // Find min/max and the accumulate count and difference of squares over all threads minimumRef = itk::NumericTraits::max(); maximumRef = itk::NumericTraits::NonpositiveMin(); for (i = 0; i < numberOfThreads; ++i) { count += m_Count[i]; diffCount += m_DiffCount[i]; squareOfDifferences += m_SquareOfDifferences[i]; absoluteValueOfDifferences += m_AbsoluteValueOfDifferences[i]; if (m_ThreadMinRef[i] < minimumRef) { minimumRef = m_ThreadMinRef[i]; } if (m_ThreadMaxRef[i] > maximumRef) { maximumRef = m_ThreadMaxRef[i]; } } // compute mse mse = (count != 0) ? squareOfDifferences / static_cast(count) : 0.; // compute mse mae = (count != 0) ? absoluteValueOfDifferences / static_cast(count) : 0.; //compute psnr psnr = (vcl_abs(mse)>0.0000000001 && (maximumRef-minimumRef)>0.0000000001) ? 10.*vcl_log10(((maximumRef-minimumRef)*(maximumRef-minimumRef))/mse):0.; // Set the output this->GetMSEOutput()->Set(mse); this->GetMAEOutput()->Set(mae); this->GetPSNROutput()->Set(psnr); this->GetDiffCountOutput()->Set(static_cast(diffCount)); } template void PersistentCompareImageFilter ::Reset() { int numberOfThreads = this->GetNumberOfThreads(); // Resize the thread temporaries m_Count.SetSize(numberOfThreads); m_DiffCount.SetSize(numberOfThreads); m_SquareOfDifferences.SetSize(numberOfThreads); m_AbsoluteValueOfDifferences.SetSize(numberOfThreads); m_ThreadMinRef.SetSize(numberOfThreads); m_ThreadMaxRef.SetSize(numberOfThreads); // Initialize the temporaries m_Count.Fill(itk::NumericTraits::Zero); m_DiffCount.Fill(itk::NumericTraits::Zero); m_SquareOfDifferences.Fill(itk::NumericTraits::Zero); m_AbsoluteValueOfDifferences.Fill(itk::NumericTraits::Zero); m_ThreadMinRef.Fill(itk::NumericTraits::max()); m_ThreadMaxRef.Fill(itk::NumericTraits::NonpositiveMin()); } template void PersistentCompareImageFilter ::VerifyInputInformation() { if (m_PhysicalSpaceCheck) Superclass::VerifyInputInformation(); } template void PersistentCompareImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { /** * Grab the input */ InputImagePointer inputPtr1 = const_cast(this->GetInput(0)); InputImagePointer inputPtr2 = const_cast(this->GetInput(1)); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); RealType realValue1, realValue2; PixelType value1, value2; itk::ImageRegionConstIterator it1(inputPtr1, outputRegionForThread); itk::ImageRegionConstIterator it2(inputPtr2, outputRegionForThread); it1.GoToBegin(); it2.GoToBegin(); // do the work while (!it1.IsAtEnd() && !it2.IsAtEnd()) { value1 = it1.Get(); realValue1 = static_cast(value1); value2 = it2.Get(); realValue2 = static_cast(value2); if (value1 < m_ThreadMinRef[threadId]) { m_ThreadMinRef[threadId] = value1; } if (value1 > m_ThreadMaxRef[threadId]) { m_ThreadMaxRef[threadId] = value1; } RealType diffVal = realValue1 - realValue2; m_SquareOfDifferences[threadId] += diffVal * diffVal; m_AbsoluteValueOfDifferences[threadId] += vcl_abs( diffVal ); if (! itk::Math::FloatAlmostEqual(realValue1, realValue2)) { m_DiffCount[threadId]++; } m_Count[threadId]++; ++it1; ++it2; progress.CompletedPixel(); } } template void PersistentCompareImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "PSNR: " << this->GetPSNR() << std::endl; os << indent << "MSE: " << this->GetMSE() << std::endl; os << indent << "MAE: " << this->GetMAE() << std::endl; os << indent << "Count: " << this->GetDiffCount() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingHistogramVectorImageFilter.h000066400000000000000000000232211301006202600325070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingHistogramVectorImageFilter_h #define otbStreamingHistogramVectorImageFilter_h #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "otbObjectList.h" #include "itkStatisticsAlgorithm.h" #include "itkNumericTraits.h" #include "itkHistogram.h" namespace otb { /** \class PersistentHistogramVectorImageFilter * \brief Compute the histogram of a large image using streaming * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output histogram will be the histogram of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the histogram once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentHistogramVectorImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentHistogramVectorImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentHistogramVectorImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; typedef typename TInputImage::InternalPixelType InternalPixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Type to use for computations. */ typedef typename itk::NumericTraits::RealType RealType; typedef itk::VariableLengthVector RealPixelType; /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Types for histogram */ typedef itk::Statistics::DenseFrequencyContainer2 DFContainerType; typedef typename itk::NumericTraits::RealType HistogramMeasurementRealType; typedef itk::Statistics::Histogram HistogramType; typedef itk::VariableLengthVector< unsigned int > CountVectorType; typedef PixelType MeasurementVectorType; typedef ObjectList HistogramListType; typedef typename HistogramListType::Pointer HistogramListPointerType; typedef typename std::vector ArrayHistogramListType; /** Set the no data value. These value are ignored in histogram * computation if NoDataFlag is On */ itkSetMacro(NoDataValue, InternalPixelType); /** Set the no data value. These value are ignored in histogram * computation if NoDataFlag is On */ itkGetConstReferenceMacro(NoDataValue, InternalPixelType); /** Set the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkSetMacro(NoDataFlag, bool); /** Get the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkGetMacro(NoDataFlag, bool); /** Toggle the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkBooleanMacro(NoDataFlag); inline void SetNumberOfBins( unsigned int i, CountVectorType::ValueType size ) { m_Size[ i ] = size; } inline void SetNumberOfBins( const CountVectorType& size ) { m_Size = size; } /** Return the computed histogram list */ HistogramListType* GetHistogramListOutput(); const HistogramListType* GetHistogramListOutput() const; /** Get the minimum values for histograms */ itkGetConstReferenceMacro(HistogramMin,MeasurementVectorType); /** Set the minimum values for histograms */ itkSetMacro(HistogramMin,MeasurementVectorType); /** Get the maximum values for histograms */ itkGetConstReferenceMacro(HistogramMax,MeasurementVectorType); /** Set the maximum values for histograms */ itkSetMacro(HistogramMax,MeasurementVectorType); /** Set the subsampling rate */ itkSetMacro(SubSamplingRate, unsigned int); /** Get the subsampling rate */ itkGetMacro(SubSamplingRate, unsigned int); /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; protected: PersistentHistogramVectorImageFilter(); ~PersistentHistogramVectorImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentHistogramVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ArrayHistogramListType m_ThreadHistogramList; CountVectorType m_Size; MeasurementVectorType m_HistogramMin; MeasurementVectorType m_HistogramMax; bool m_NoDataFlag; InternalPixelType m_NoDataValue; /** Set the subsampling along each direction */ unsigned int m_SubSamplingRate; }; // end of class PersistentStatisticsVectorImageFilter /**===========================================================================*/ /** \class StreamingHistogramVectorImageFilter * \brief This class streams the whole input image through the PersistentHistogramVectorImageFilter. * * This way, it allows computing the min/max of this image. It calls the * Reset() method of the PersistentHistogramVectorImageFilter before streaming the image and the * Synthetize() method of the PersistentHistogramVectorImageFilter after having streamed the image * to compute the statistics. The accessor on the results are wrapping the accessors of the * internal PersistentMinMaxImageFilter. * * \sa PersistentStatisticsVectorImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT StreamingHistogramVectorImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingHistogramVectorImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingHistogramVectorImageFilter, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef typename Superclass::FilterType InternalFilterType; /** Types needed for histograms */ typedef typename InternalFilterType::HistogramType HistogramType; typedef typename InternalFilterType::HistogramListType HistogramListType; using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Return the computed histogram */ HistogramListType* GetHistogramList() { return this->GetFilter()->GetHistogramListOutput(); } protected: /** Constructor */ StreamingHistogramVectorImageFilter() {}; /** Destructor */ ~StreamingHistogramVectorImageFilter() ITK_OVERRIDE {} private: StreamingHistogramVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingHistogramVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingHistogramVectorImageFilter.txx000066400000000000000000000237371301006202600331170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingHistogramVectorImageFilter_txx #define otbStreamingHistogramVectorImageFilter_txx #include "otbStreamingHistogramVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentHistogramVectorImageFilter ::PersistentHistogramVectorImageFilter() : m_ThreadHistogramList(), m_Size(), m_HistogramMin(), m_HistogramMax(), m_NoDataFlag(false), m_NoDataValue(itk::NumericTraits::Zero), m_SubSamplingRate(1) { // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around pixel types and histogram list m_Size.Fill(255); HistogramListPointerType output = static_cast(this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, output.GetPointer()); } template itk::DataObject::Pointer PersistentHistogramVectorImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { itk::DataObject::Pointer ret; switch (output) { case 0: ret = static_cast(TInputImage::New().GetPointer()); break; case 1: ret = static_cast(HistogramListType::New().GetPointer()); break; } return ret; } template typename PersistentHistogramVectorImageFilter::HistogramListType* PersistentHistogramVectorImageFilter ::GetHistogramListOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentHistogramVectorImageFilter::HistogramListType* PersistentHistogramVectorImageFilter ::GetHistogramListOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void PersistentHistogramVectorImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentHistogramVectorImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentHistogramVectorImageFilter ::Reset() { TInputImage * inputPtr = const_cast(this->GetInput()); inputPtr->UpdateOutputInformation(); unsigned int numberOfThreads = this->GetNumberOfThreads(); unsigned int numberOfComponent = inputPtr->GetNumberOfComponentsPerPixel(); // TODO which is the good value ? (false in MVD2) bool clipBins = false; // if histogram Min and Max have the wrong size : set to default [0, 255] if (m_HistogramMin.Size() != numberOfComponent || m_HistogramMax.Size() != numberOfComponent) { m_HistogramMin.SetSize(numberOfComponent); m_HistogramMax.SetSize(numberOfComponent); m_HistogramMin.Fill(itk::NumericTraits::Zero); m_HistogramMax.Fill(255); } // Setup output histogram HistogramListType* outputHisto = this->GetHistogramListOutput(); outputHisto->Clear(); for (unsigned int k=0; kSetClipBinsAtEnds(clipBins); typename HistogramType::SizeType size; size.SetSize(1); size.Fill( m_Size[ k ] ); histogram->SetMeasurementVectorSize(1); histogram->Initialize( size, bandMin, bandMax ); outputHisto->PushBack(histogram); } // Setup HistogramLists for each thread m_ThreadHistogramList.clear(); for (unsigned int i=0; iClear(); for (unsigned int k=0; kSetClipBinsAtEnds(clipBins); typename HistogramType::SizeType size; size.SetSize(1); size.Fill( m_Size[ k ] ); histogram->SetMeasurementVectorSize(1); histogram->Initialize(size, bandMin, bandMax ); histoList->PushBack(histogram); } m_ThreadHistogramList.push_back(histoList); } } template void PersistentHistogramVectorImageFilter ::Synthetize() { HistogramListType* outputHisto = this->GetHistogramListOutput(); int numberOfThreads = this->GetNumberOfThreads(); unsigned int numberOfComponent = this->GetInput()->GetNumberOfComponentsPerPixel(); // copy histograms to output for (int i = 0; i < numberOfThreads; ++i) { for (unsigned int j = 0; j < numberOfComponent; ++j) { HistogramType* outHisto = outputHisto->GetNthElement(j); HistogramType* threadHisto = m_ThreadHistogramList[i]->GetNthElement(j); typename HistogramType::Iterator iterOutput = outHisto->Begin(); typename HistogramType::Iterator iterThread = threadHisto->Begin(); while (iterOutput != outHisto->End() && iterThread != threadHisto->End()) { iterOutput.SetFrequency(iterOutput.GetFrequency()+iterThread.GetFrequency()); ++iterOutput; ++iterThread; } } } } template void PersistentHistogramVectorImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { /** * Grab the input */ InputImagePointer inputPtr = const_cast(this->GetInput()); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); typename HistogramType::IndexType index; itk::ImageRegionConstIteratorWithIndex it(inputPtr, outputRegionForThread); it.GoToBegin(); bool skipSample = false; // do the work while (!it.IsAtEnd()) { if (m_SubSamplingRate > 1) { skipSample = false; for (unsigned int i=0; iGetNthElement(j)->GetIndex(value, index); if (!m_ThreadHistogramList[threadId]->GetNthElement(j)->IsIndexOutOfBounds(index)) { // if the measurement vector is out of bound then // the GetIndex method has returned an index set to the max size of // the invalid dimension - even if the hvector is less than the minimum // bin value. // If the index isn't valid, we don't increase the frequency. // See the comments in Histogram->GetIndex() for more info. m_ThreadHistogramList[threadId]->GetNthElement(j)->IncreaseFrequencyOfIndex(index, 1); } } } ++it; progress.CompletedPixel(); } } template void PersistentHistogramVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Histogram minimum: " << this->GetHistogramMin() << std::endl; os << indent << "Histogram maximum: " << this->GetHistogramMax() << std::endl; os << indent << "Number of bins: " << m_Size[0] << std::endl; if (m_NoDataFlag) { os << indent << "Use NoData: true" << std::endl; } else { os << indent << "Use NoData: false" << std::endl; } os << indent << "NoData value: " << this->GetNoDataValue() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingMinMaxImageFilter.h000066400000000000000000000224171301006202600305660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingMinMaxImageFilter_h #define otbStreamingMinMaxImageFilter_h #include #include "otbPersistentImageFilter.h" #include "itkNumericTraits.h" #include "itkSimpleDataObjectDecorator.h" #include "otbPersistentFilterStreamingDecorator.h" namespace otb { /** \class PersistentMinMaxImageFilter * \brief Compute min. max of an image using the output requested region. * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output min/max will be the statistics of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the min/max once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentMinMaxImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentMinMaxImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentMinMaxImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Type of DataObjects used for scalar outputs */ typedef itk::SimpleDataObjectDecorator PixelObjectType; typedef itk::SimpleDataObjectDecorator IndexObjectType; /** Return the computed Minimum. */ PixelType GetMinimum() const { return this->GetMinimumOutput()->Get(); } PixelObjectType* GetMinimumOutput(); const PixelObjectType* GetMinimumOutput() const; /** Return the computed Maximum. */ PixelType GetMaximum() const { return this->GetMaximumOutput()->Get(); } PixelObjectType* GetMaximumOutput(); const PixelObjectType* GetMaximumOutput() const; /** Return the computed Minimum. */ IndexType GetMinimumIndex() const { return this->GetMinimumIndexOutput()->Get(); } IndexObjectType* GetMinimumIndexOutput(); const IndexObjectType* GetMinimumIndexOutput() const; /** Return the computed Maximum. */ IndexType GetMaximumIndex() const { return this->GetMaximumIndexOutput()->Get(); } IndexObjectType* GetMaximumIndexOutput(); const IndexObjectType* GetMaximumIndexOutput() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; protected: PersistentMinMaxImageFilter(); ~PersistentMinMaxImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentMinMaxImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::vector m_ThreadMin; std::vector m_ThreadMax; std::vector m_ThreadMinIndex; std::vector m_ThreadMaxIndex; }; // end of class PersistentMinMaxImageFilter /** \class StreamingMinMaxImageFilter * \brief This class streams the whole input image through the PersistentMinMaxImageFilter. * * This way, it allows computing the minimum and maximum of this image. * * It calls the Reset() method of the PersistentMinMaxImageFilter before streaming * the image and the Synthetize() method of the PersistentMinMaxImageFilter after * having streamed the image to compute the statistics. * * This filter can be used as: * \code * typedef otb::StreamingMinMaxImageFilter MinMaxType; * MinMaxType::Pointer minmax = MinMaxType::New(); * minmax->SetInput(reader->GetOutput()); * minmax->Update(); * std::cout << minmax-> GetMaximum() << std::endl; * std::cout << minmax-> GetMinimum() << std::endl; * std::cout << minmax-> GetMaximumIndex() << std::endl; * std::cout << minmax-> GetMinimumIndex() << std::endl; * \endcode * * \sa PersistentMinMaxImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT StreamingMinMaxImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingMinMaxImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingMinMaxImageFilter, PersistentFilterStreamingDecorator); typedef typename Superclass::FilterType StatFilterType; typedef typename StatFilterType::PixelType PixelType; typedef typename StatFilterType::IndexType IndexType; typedef typename StatFilterType::PixelObjectType PixelObjectType; typedef typename StatFilterType::IndexObjectType IndexObjectType; typedef TInputImage InputImageType; using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Return the computed Minimum. */ PixelType GetMinimum() const { return this->GetFilter()->GetMinimumOutput()->Get(); } PixelObjectType* GetMinimumOutput() { return this->GetFilter()->GetMinimumOutput(); } const PixelObjectType* GetMinimumOutput() const { return this->GetFilter()->GetMinimumOutput(); } /** Return the computed Maximum. */ PixelType GetMaximum() const { return this->GetFilter()->GetMaximumOutput()->Get(); } PixelObjectType* GetMaximumOutput() { return this->GetFilter()->GetMaximumOutput(); } const PixelObjectType* GetMaximumOutput() const { return this->GetFilter()->GetMaximumOutput(); } /** Return the computed Minimum. */ IndexType GetMinimumIndex() const { return this->GetFilter()->GetMinimumIndexOutput()->Get(); } IndexObjectType* GetMinimumIndexOutput() { return this->GetFilter()->GetMinimumIndexOutput(); } const IndexObjectType* GetMinimumIndexOutput() const { return this->GetFilter()->GetMinimumIndexOutput(); } /** Return the computed Maximum. */ IndexType GetMaximumIndex() const { return this->GetFilter()->GetMaximumIndexOutput()->Get(); } IndexObjectType* GetMaximumIndexOutput() { return this->GetFilter()->GetMaximumIndexOutput(); } const IndexObjectType* GetMaximumIndexOutput() const { return this->GetFilter()->GetMaximumIndexOutput(); } protected: /** Constructor */ StreamingMinMaxImageFilter() {} /** Destructor */ ~StreamingMinMaxImageFilter() ITK_OVERRIDE {} private: StreamingMinMaxImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingMinMaxImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingMinMaxImageFilter.txx000066400000000000000000000177771301006202600311770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingMinMaxImageFilter_txx #define otbStreamingMinMaxImageFilter_txx #include "otbStreamingMinMaxImageFilter.h" #include #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentMinMaxImageFilter ::PersistentMinMaxImageFilter() { // TODO : SetNumberOfRequiredOutputs // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around pixel & index types for (int i = 1; i < 5; ++i) { this->itk::ProcessObject::SetNthOutput(i, this->MakeOutput(i)); } this->GetMinimumOutput()->Set(itk::NumericTraits::max()); this->GetMaximumOutput()->Set(itk::NumericTraits::NonpositiveMin()); this->Reset(); } template typename itk::DataObject::Pointer PersistentMinMaxImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { itk::DataObject::Pointer ret; switch (output) { case 0: ret = static_cast(TInputImage::New().GetPointer()); break; case 1: case 2: ret = static_cast(PixelObjectType::New().GetPointer()); break; case 3: case 4: ret = static_cast(IndexObjectType::New().GetPointer()); break; } return ret; } template typename PersistentMinMaxImageFilter::PixelObjectType* PersistentMinMaxImageFilter ::GetMinimumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentMinMaxImageFilter::PixelObjectType* PersistentMinMaxImageFilter ::GetMinimumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename PersistentMinMaxImageFilter::PixelObjectType* PersistentMinMaxImageFilter ::GetMaximumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template const typename PersistentMinMaxImageFilter::PixelObjectType* PersistentMinMaxImageFilter ::GetMaximumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template typename PersistentMinMaxImageFilter::IndexObjectType* PersistentMinMaxImageFilter ::GetMinimumIndexOutput() { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template const typename PersistentMinMaxImageFilter::IndexObjectType* PersistentMinMaxImageFilter ::GetMinimumIndexOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template typename PersistentMinMaxImageFilter::IndexObjectType* PersistentMinMaxImageFilter ::GetMaximumIndexOutput() { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template const typename PersistentMinMaxImageFilter::IndexObjectType* PersistentMinMaxImageFilter ::GetMaximumIndexOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template void PersistentMinMaxImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentMinMaxImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentMinMaxImageFilter ::Synthetize() { int i; int numberOfThreads = this->GetNumberOfThreads(); PixelType minimum = itk::NumericTraits::max(); PixelType maximum = itk::NumericTraits::NonpositiveMin(); IndexType minimumIdx; IndexType maximumIdx; for (i = 0; i < numberOfThreads; ++i) { if (m_ThreadMin[i] < minimum) { minimum = m_ThreadMin[i]; minimumIdx = m_ThreadMinIndex[i]; } if (m_ThreadMax[i] > maximum) { maximum = m_ThreadMax[i]; maximumIdx = m_ThreadMaxIndex[i]; } } // Set the outputs this->GetMinimumOutput()->Set(minimum); this->GetMaximumOutput()->Set(maximum); this->GetMinimumIndexOutput()->Set(minimumIdx); this->GetMaximumIndexOutput()->Set(maximumIdx); } template void PersistentMinMaxImageFilter ::Reset() { int numberOfThreads = this->GetNumberOfThreads(); m_ThreadMin.resize(numberOfThreads); m_ThreadMax.resize(numberOfThreads); std::fill(m_ThreadMin.begin(), m_ThreadMin.end(), itk::NumericTraits::max()); std::fill(m_ThreadMax.begin(), m_ThreadMax.end(), itk::NumericTraits::NonpositiveMin()); IndexType zeroIdx; zeroIdx.Fill(0); m_ThreadMinIndex.resize(numberOfThreads); m_ThreadMaxIndex.resize(numberOfThreads); std::fill(m_ThreadMinIndex.begin(), m_ThreadMinIndex.end(), zeroIdx); std::fill(m_ThreadMaxIndex.begin(), m_ThreadMaxIndex.end(), zeroIdx); } template void PersistentMinMaxImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); InputImagePointer inputPtr = const_cast(this->GetInput(0)); itk::ImageRegionConstIterator it(inputPtr, outputRegionForThread); it.GoToBegin(); // do the work while (!it.IsAtEnd()) { PixelType value = it.Get(); if (value < m_ThreadMin[threadId]) { m_ThreadMin[threadId] = value; m_ThreadMinIndex[threadId] = it.GetIndex(); } if (value > m_ThreadMax[threadId]) { m_ThreadMax[threadId] = value; m_ThreadMaxIndex[threadId] = it.GetIndex(); } ++it; progress.CompletedPixel(); } } template void PersistentMinMaxImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Minimum: " << static_cast::PrintType>(this->GetMinimum()) << std::endl; os << indent << "Maximum: " << static_cast::PrintType>(this->GetMaximum()) << std::endl; os << indent << "Minimum Index: " << this->GetMinimumIndex() << std::endl; os << indent << "Maximum Index: " << this->GetMaximumIndex() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingMinMaxVectorImageFilter.h000066400000000000000000000237251301006202600317540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingMinMaxVectorImageFilter_h #define otbStreamingMinMaxVectorImageFilter_h #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "itkSimpleDataObjectDecorator.h" #include "itkImageRegionSplitter.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" namespace otb { /** \class PersistentMinMaxVectorImageFilter * \brief Compute min. max of a large image using streaming * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output statistics will be the statitics of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the statistics once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentMinMaxVectorImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentMinMaxVectorImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentMinMaxVectorImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; typedef typename TInputImage::InternalPixelType InternalPixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Type to use for computations. */ typedef typename itk::NumericTraits::RealType RealType; typedef itk::VariableLengthVector RealPixelType; /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Type of DataObjects used for scalar outputs */ typedef typename itk::VariableSizeMatrix MatrixType; typedef typename std::vector ArrayMatrixType; typedef typename itk::Array ArrayLongPixelType; typedef typename std::vector ArrayRealPixelType; typedef typename std::vector ArrayPixelType; typedef itk::SimpleDataObjectDecorator RealPixelObjectType; typedef itk::SimpleDataObjectDecorator PixelObjectType; typedef itk::SimpleDataObjectDecorator MatrixObjectType; /** Set the no data value. These value are ignored in histogram * computation if NoDataFlag is On */ itkSetMacro(NoDataValue, InternalPixelType); /** Set the no data value. These value are ignored in histogram * computation if NoDataFlag is On */ itkGetConstReferenceMacro(NoDataValue, InternalPixelType); /** Set the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkSetMacro(NoDataFlag, bool); /** Get the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkGetMacro(NoDataFlag, bool); /** Toggle the NoDataFlag. If set to true, samples with values equal to * m_NoDataValue are ignored. */ itkBooleanMacro(NoDataFlag); /** Return the computed Minimum. */ PixelType GetMinimum() const { return this->GetMinimumOutput()->Get(); } PixelObjectType* GetMinimumOutput(); const PixelObjectType* GetMinimumOutput() const; /** Return the computed Maximum. */ PixelType GetMaximum() const { return this->GetMaximumOutput()->Get(); } PixelObjectType* GetMaximumOutput(); const PixelObjectType* GetMaximumOutput() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; protected: PersistentMinMaxVectorImageFilter(); ~PersistentMinMaxVectorImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentMinMaxVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ArrayPixelType m_ThreadMin; ArrayPixelType m_ThreadMax; bool m_NoDataFlag; InternalPixelType m_NoDataValue; }; // end of class PersistentStatisticsVectorImageFilter /**===========================================================================*/ /** \class StreamingMinMaxVectorImageFilter * \brief This class streams the whole input image through the PersistentMinMaxVectorImageFilter. * * This way, it allows computing the min/max of this image. It calls the * Reset() method of the PersistentMinMaxVectorImageFilter before streaming the image and the * Synthetize() method of the PersistentMinMaxVectorImageFilter after having streamed the image * to compute the statistics. The accessor on the results are wrapping the accessors of the * internal PersistentMinMaxImageFilter. * * \sa PersistentStatisticsVectorImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT StreamingMinMaxVectorImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingMinMaxVectorImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingMinMaxVectorImageFilter, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef typename Superclass::FilterType StatFilterType; typedef typename StatFilterType::PixelType PixelType; typedef typename StatFilterType::RealType RealType; typedef typename StatFilterType::RealPixelType RealPixelType; typedef typename StatFilterType::MatrixType MatrixType; typedef typename StatFilterType::ArrayMatrixType ArrayMatrixType; typedef typename StatFilterType::ArrayLongPixelType ArrayLongPixelType; typedef typename StatFilterType::ArrayRealPixelType ArrayRealPixelType; typedef typename StatFilterType::ArrayPixelType ArrayPixelType; /** Type of DataObjects used for scalar outputs */ typedef typename StatFilterType::RealPixelObjectType RealPixelObjectType; typedef typename StatFilterType::PixelObjectType PixelObjectType; typedef typename StatFilterType::MatrixObjectType MatrixObjectType; using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Return the computed Minimum. */ PixelType GetMinimum() const { return this->GetFilter()->GetMinimumOutput()->Get(); } PixelObjectType* GetMinimumOutput() { return this->GetFilter()->GetMinimumOutput(); } const PixelObjectType* GetMinimumOutput() const { return this->GetFilter()->GetMinimumOutput(); } /** Return the computed Maximum. */ PixelType GetMaximum() const { return this->GetFilter()->GetMaximumOutput()->Get(); } PixelObjectType* GetMaximumOutput() { return this->GetFilter()->GetMaximumOutput(); } const PixelObjectType* GetMaximumOutput() const { return this->GetFilter()->GetMaximumOutput(); } protected: /** Constructor */ StreamingMinMaxVectorImageFilter() {}; /** Destructor */ ~StreamingMinMaxVectorImageFilter() ITK_OVERRIDE {} private: StreamingMinMaxVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingMinMaxVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingMinMaxVectorImageFilter.txx000066400000000000000000000171651301006202600323510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingMinMaxVectorImageFilter_txx #define otbStreamingMinMaxVectorImageFilter_txx #include "otbStreamingMinMaxVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentMinMaxVectorImageFilter ::PersistentMinMaxVectorImageFilter() : m_NoDataFlag(false), m_NoDataValue(itk::NumericTraits::Zero) { // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around pixel types for (int i = 1; i < 3; ++i) { typename PixelObjectType::Pointer output = static_cast(this->MakeOutput(i).GetPointer()); this->itk::ProcessObject::SetNthOutput(i, output.GetPointer()); } } template itk::DataObject::Pointer PersistentMinMaxVectorImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { itk::DataObject::Pointer ret; switch (output) { case 0: ret = static_cast(TInputImage::New().GetPointer()); break; case 1: case 2: ret = static_cast(PixelObjectType::New().GetPointer()); break; } return ret; } template typename PersistentMinMaxVectorImageFilter::PixelObjectType* PersistentMinMaxVectorImageFilter ::GetMinimumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentMinMaxVectorImageFilter::PixelObjectType* PersistentMinMaxVectorImageFilter ::GetMinimumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename PersistentMinMaxVectorImageFilter::PixelObjectType* PersistentMinMaxVectorImageFilter ::GetMaximumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template const typename PersistentMinMaxVectorImageFilter::PixelObjectType* PersistentMinMaxVectorImageFilter ::GetMaximumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template void PersistentMinMaxVectorImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentMinMaxVectorImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentMinMaxVectorImageFilter ::Reset() { TInputImage * inputPtr = const_cast(this->GetInput()); inputPtr->UpdateOutputInformation(); unsigned int numberOfThreads = this->GetNumberOfThreads(); unsigned int numberOfComponent = inputPtr->GetNumberOfComponentsPerPixel(); // Variable Initialization PixelType tempPixel; tempPixel.SetSize(numberOfComponent); tempPixel.Fill(itk::NumericTraits::NonpositiveMin()); this->GetMaximumOutput()->Set(tempPixel); tempPixel.Fill(itk::NumericTraits::max()); this->GetMinimumOutput()->Set(tempPixel); PixelType tempTemporiesPixel; tempTemporiesPixel.SetSize(numberOfComponent); tempTemporiesPixel.Fill(itk::NumericTraits::max()); m_ThreadMin = ArrayPixelType(numberOfThreads, tempTemporiesPixel); tempTemporiesPixel.Fill(itk::NumericTraits::NonpositiveMin()); m_ThreadMax = ArrayPixelType(numberOfThreads, tempTemporiesPixel); } template void PersistentMinMaxVectorImageFilter ::Synthetize() { int i; int numberOfThreads = this->GetNumberOfThreads(); unsigned int numberOfComponent = this->GetInput()->GetNumberOfComponentsPerPixel(); PixelType minimumVector; minimumVector.SetSize(numberOfComponent); minimumVector.Fill(itk::NumericTraits::max()); PixelType maximumVector; maximumVector.SetSize(numberOfComponent); maximumVector.Fill(itk::NumericTraits::NonpositiveMin()); // Find the min/max over all threads and accumulate count, sum and // sum of squares for (i = 0; i < numberOfThreads; ++i) { for (unsigned int j = 0; j < numberOfComponent; ++j) { if (m_ThreadMin[i][j] < minimumVector[j]) { minimumVector[j] = m_ThreadMin[i][j]; } if (m_ThreadMax[i][j] > maximumVector[j]) { maximumVector[j] = m_ThreadMax[i][j]; } } } // end for( i = 0; i < numberOfThreads; ++i) // Set the outputs this->GetMinimumOutput()->Set(minimumVector); this->GetMaximumOutput()->Set(maximumVector); } template void PersistentMinMaxVectorImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { /** * Grab the input */ InputImagePointer inputPtr = const_cast(this->GetInput()); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); itk::ImageRegionConstIteratorWithIndex it(inputPtr, outputRegionForThread); it.GoToBegin(); // do the work while (!it.IsAtEnd()) { //IndexType index = it.GetIndex(); PixelType vectorValue = it.Get(); for (unsigned int j = 0; j < vectorValue.GetSize(); ++j) { InternalPixelType value = vectorValue[j]; if( (!m_NoDataFlag) || value!=m_NoDataValue ) { if (value < m_ThreadMin[threadId][j]) { m_ThreadMin[threadId][j] = value; } if (value > m_ThreadMax[threadId][j]) { m_ThreadMax[threadId][j] = value; } } } ++it; progress.CompletedPixel(); } } template void PersistentMinMaxVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Minimum: " << this->GetMinimumOutput()->Get() << std::endl; os << indent << "Maximum: " << this->GetMaximumOutput()->Get() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingStatisticsImageFilter.h000066400000000000000000000271471301006202600315340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingStatisticsImageFilter_h #define otbStreamingStatisticsImageFilter_h #include "otbPersistentImageFilter.h" #include "itkNumericTraits.h" #include "itkArray.h" #include "itkSimpleDataObjectDecorator.h" #include "otbPersistentFilterStreamingDecorator.h" namespace otb { /** \class PersistentStatisticsImageFilter * \brief Compute min. max, variance and mean of an image using the output requested region. * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output statistics will be the statitics of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the statistics once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentStatisticsImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentStatisticsImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentStatisticsImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Type to use for computations. */ typedef typename itk::NumericTraits::RealType RealType; /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Type of DataObjects used for scalar outputs */ typedef itk::SimpleDataObjectDecorator RealObjectType; typedef itk::SimpleDataObjectDecorator PixelObjectType; /** Return the computed Minimum. */ PixelType GetMinimum() const { return this->GetMinimumOutput()->Get(); } PixelObjectType* GetMinimumOutput(); const PixelObjectType* GetMinimumOutput() const; /** Return the computed Maximum. */ PixelType GetMaximum() const { return this->GetMaximumOutput()->Get(); } PixelObjectType* GetMaximumOutput(); const PixelObjectType* GetMaximumOutput() const; /** Return the computed Mean. */ RealType GetMean() const { return this->GetMeanOutput()->Get(); } RealObjectType* GetMeanOutput(); const RealObjectType* GetMeanOutput() const; /** Return the computed Standard Deviation. */ RealType GetSigma() const { return this->GetSigmaOutput()->Get(); } RealObjectType* GetSigmaOutput(); const RealObjectType* GetSigmaOutput() const; /** Return the computed Variance. */ RealType GetVariance() const { return this->GetVarianceOutput()->Get(); } RealObjectType* GetVarianceOutput(); const RealObjectType* GetVarianceOutput() const; /** Return the compute Sum. */ RealType GetSum() const { return this->GetSumOutput()->Get(); } RealObjectType* GetSumOutput(); const RealObjectType* GetSumOutput() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; itkSetMacro(IgnoreInfiniteValues, bool); itkGetMacro(IgnoreInfiniteValues, bool); itkSetMacro(IgnoreUserDefinedValue, bool); itkGetMacro(IgnoreUserDefinedValue, bool); itkSetMacro(UserIgnoredValue, RealType); itkGetMacro(UserIgnoredValue, RealType); protected: PersistentStatisticsImageFilter(); ~PersistentStatisticsImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentStatisticsImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented itk::Array m_ThreadSum; itk::Array m_SumOfSquares; itk::Array m_Count; itk::Array m_ThreadMin; itk::Array m_ThreadMax; /* Ignored values */ bool m_IgnoreInfiniteValues; bool m_IgnoreUserDefinedValue; RealType m_UserIgnoredValue; std::vector m_IgnoredInfinitePixelCount; std::vector m_IgnoredUserPixelCount; }; // end of class PersistentStatisticsImageFilter /*===========================================================================*/ /** \class StreamingStatisticsImageFilter * \brief This class streams the whole input image through the PersistentStatisticsImageFilter. * * This way, it allows computing the first order global statistics of this image. It calls the * Reset() method of the PersistentStatisticsImageFilter before streaming the image and the * Synthetize() method of the PersistentStatisticsImageFilter after having streamed the image * to compute the statistics. The accessor on the results are wrapping the accessors of the * internal PersistentStatisticsImageFilter. * By default infinite values are ignored, use IgnoreInfiniteValues accessor to consider * infinite values in the computation. * * This filter can be used as: * \code * typedef otb::StreamingStatisticsImageFilter StatisticsType; * StatisticsType::Pointer statistics = StatisticsType::New(); * statistics->SetInput(reader->GetOutput()); * statistics->Update(); * std::cout << statistics-> GetMaximum() << std::endl; * std::cout << statistics-> GetMinimum() << std::endl; * \endcode * * \sa PersistentStatisticsImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT StreamingStatisticsImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingStatisticsImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingStatisticsImageFilter, PersistentFilterStreamingDecorator); typedef typename Superclass::FilterType StatFilterType; typedef typename StatFilterType::PixelType PixelType; typedef typename StatFilterType::RealType RealType; typedef TInputImage InputImageType; /** Type of DataObjects used for scalar outputs */ typedef itk::SimpleDataObjectDecorator RealObjectType; typedef itk::SimpleDataObjectDecorator PixelObjectType; using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Return the computed Minimum. */ PixelType GetMinimum() const { return this->GetFilter()->GetMinimumOutput()->Get(); } PixelObjectType* GetMinimumOutput() { return this->GetFilter()->GetMinimumOutput(); } const PixelObjectType* GetMinimumOutput() const { return this->GetFilter()->GetMinimumOutput(); } /** Return the computed Maximum. */ PixelType GetMaximum() const { return this->GetFilter()->GetMaximumOutput()->Get(); } PixelObjectType* GetMaximumOutput() { return this->GetFilter()->GetMaximumOutput(); } const PixelObjectType* GetMaximumOutput() const { return this->GetFilter()->GetMaximumOutput(); } /** Return the computed Mean. */ RealType GetMean() const { return this->GetFilter()->GetMeanOutput()->Get(); } RealObjectType* GetMeanOutput() { return this->GetFilter()->GetMeanOutput(); } const RealObjectType* GetMeanOutput() const { return this->GetFilter()->GetMeanOutput(); } /** Return the computed Standard Deviation. */ RealType GetSigma() const { return this->GetSigmaOutput()->Get(); } RealObjectType* GetSigmaOutput() { return this->GetFilter()->GetSigmaOutput(); } const RealObjectType* GetSigmaOutput() const { return this->GetFilter()->GetSigmaOutput(); } /** Return the computed Variance. */ RealType GetVariance() const { return this->GetFilter()->GetVarianceOutput()->Get(); } RealObjectType* GetVarianceOutput() { return this->GetFilter()->GetVarianceOutput(); } const RealObjectType* GetVarianceOutput() const { return this->GetFilter()->GetVarianceOutput(); } /** Return the compute Sum. */ RealType GetSum() const { return this->GetFilter()->GetSumOutput()->Get(); } RealObjectType* GetSumOutput() { return this->GetFilter()->GetSumOutput(); } const RealObjectType* GetSumOutput() const { return this->GetFilter()->GetSumOutput(); } otbSetObjectMemberMacro(Filter, IgnoreInfiniteValues, bool); otbGetObjectMemberMacro(Filter, IgnoreInfiniteValues, bool); otbSetObjectMemberMacro(Filter, IgnoreUserDefinedValue, bool); otbGetObjectMemberMacro(Filter, IgnoreUserDefinedValue, bool); otbSetObjectMemberMacro(Filter, UserIgnoredValue, RealType); otbGetObjectMemberMacro(Filter, UserIgnoredValue, RealType); protected: /** Constructor */ StreamingStatisticsImageFilter() {}; /** Destructor */ ~StreamingStatisticsImageFilter() ITK_OVERRIDE {} private: StreamingStatisticsImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingStatisticsImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingStatisticsImageFilter.txx000066400000000000000000000277221301006202600321270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingStatisticsImageFilter_txx #define otbStreamingStatisticsImageFilter_txx #include "otbStreamingStatisticsImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentStatisticsImageFilter ::PersistentStatisticsImageFilter() : m_ThreadSum(1), m_SumOfSquares(1), m_Count(1), m_ThreadMin(1), m_ThreadMax(1), m_IgnoreInfiniteValues(true), m_IgnoreUserDefinedValue(false) { // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around pixel types for (int i = 1; i < 3; ++i) { typename PixelObjectType::Pointer output = static_cast(this->MakeOutput(i).GetPointer()); this->itk::ProcessObject::SetNthOutput(i, output.GetPointer()); } // allocate the data objects for the outputs which are // just decorators around real types for (int i = 3; i < 7; ++i) { typename RealObjectType::Pointer output = static_cast(this->MakeOutput(i).GetPointer()); this->itk::ProcessObject::SetNthOutput(i, output.GetPointer()); } this->GetMinimumOutput()->Set(itk::NumericTraits::max()); this->GetMaximumOutput()->Set(itk::NumericTraits::NonpositiveMin()); this->GetMeanOutput()->Set(itk::NumericTraits::max()); this->GetSigmaOutput()->Set(itk::NumericTraits::max()); this->GetVarianceOutput()->Set(itk::NumericTraits::max()); this->GetSumOutput()->Set(itk::NumericTraits::Zero); // Initiate the infinite ignored pixel counters m_IgnoredInfinitePixelCount= std::vector(this->GetNumberOfThreads(), 0); m_IgnoredUserPixelCount= std::vector(this->GetNumberOfThreads(), 0); this->Reset(); } template typename itk::DataObject::Pointer PersistentStatisticsImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { switch (output) { case 0: return static_cast(TInputImage::New().GetPointer()); break; case 1: return static_cast(PixelObjectType::New().GetPointer()); break; case 2: return static_cast(PixelObjectType::New().GetPointer()); break; case 3: case 4: case 5: case 6: return static_cast(RealObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputImage::New().GetPointer()); break; } } template typename PersistentStatisticsImageFilter::PixelObjectType* PersistentStatisticsImageFilter ::GetMinimumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentStatisticsImageFilter::PixelObjectType* PersistentStatisticsImageFilter ::GetMinimumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename PersistentStatisticsImageFilter::PixelObjectType* PersistentStatisticsImageFilter ::GetMaximumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template const typename PersistentStatisticsImageFilter::PixelObjectType* PersistentStatisticsImageFilter ::GetMaximumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetMeanOutput() { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template const typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetMeanOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetSigmaOutput() { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template const typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetSigmaOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetVarianceOutput() { return static_cast(this->itk::ProcessObject::GetOutput(5)); } template const typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetVarianceOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(5)); } template typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetSumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(6)); } template const typename PersistentStatisticsImageFilter::RealObjectType* PersistentStatisticsImageFilter ::GetSumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(6)); } template void PersistentStatisticsImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentStatisticsImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentStatisticsImageFilter ::Synthetize() { int i; long count; RealType sumOfSquares; int numberOfThreads = this->GetNumberOfThreads(); PixelType minimum; PixelType maximum; RealType mean = itk::NumericTraits::Zero; RealType sigma = itk::NumericTraits::Zero; RealType variance = itk::NumericTraits::Zero; RealType sum; sum = sumOfSquares = itk::NumericTraits::Zero; count = 0; // Find the min/max over all threads and accumulate count, sum and // sum of squares minimum = itk::NumericTraits::max(); maximum = itk::NumericTraits::NonpositiveMin(); for (i = 0; i < numberOfThreads; ++i) { count += m_Count[i]; sum += m_ThreadSum[i]; sumOfSquares += m_SumOfSquares[i]; if (m_ThreadMin[i] < minimum) { minimum = m_ThreadMin[i]; } if (m_ThreadMax[i] > maximum) { maximum = m_ThreadMax[i]; } } if (count > 0) { // compute statistics mean = sum / static_cast(count); if (count > 1) { // unbiased estimate variance = (sumOfSquares - (sum * sum / static_cast(count))) / static_cast(count - 1); sigma = vcl_sqrt(variance); } } else { itkWarningMacro(<<"No pixel found to compute statistics!"); } // Set the outputs this->GetMinimumOutput()->Set(minimum); this->GetMaximumOutput()->Set(maximum); this->GetMeanOutput()->Set(mean); this->GetSigmaOutput()->Set(sigma); this->GetVarianceOutput()->Set(variance); this->GetSumOutput()->Set(sum); } template void PersistentStatisticsImageFilter ::Reset() { int numberOfThreads = this->GetNumberOfThreads(); // Resize the thread temporaries m_Count.SetSize(numberOfThreads); m_SumOfSquares.SetSize(numberOfThreads); m_ThreadSum.SetSize(numberOfThreads); m_ThreadMin.SetSize(numberOfThreads); m_ThreadMax.SetSize(numberOfThreads); // Initialize the temporaries m_Count.Fill(itk::NumericTraits::Zero); m_ThreadSum.Fill(itk::NumericTraits::Zero); m_SumOfSquares.Fill(itk::NumericTraits::Zero); m_ThreadMin.Fill(itk::NumericTraits::max()); m_ThreadMax.Fill(itk::NumericTraits::NonpositiveMin()); if (m_IgnoreInfiniteValues) { m_IgnoredInfinitePixelCount= std::vector(numberOfThreads, 0); } if (m_IgnoreUserDefinedValue) { m_IgnoredUserPixelCount= std::vector(this->GetNumberOfThreads(), 0); } } template void PersistentStatisticsImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { /** * Grab the input */ InputImagePointer inputPtr = const_cast(this->GetInput(0)); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); RealType realValue; PixelType value; itk::ImageRegionConstIterator it(inputPtr, outputRegionForThread); it.GoToBegin(); // do the work while (!it.IsAtEnd()) { value = it.Get(); realValue = static_cast(value); if (m_IgnoreInfiniteValues && !(vnl_math_isfinite(realValue))) { m_IgnoredInfinitePixelCount[threadId] ++; } else { if (m_IgnoreUserDefinedValue && (value == m_UserIgnoredValue)) { m_IgnoredUserPixelCount[threadId] ++; } else { if (value < m_ThreadMin[threadId]) { m_ThreadMin[threadId] = value; } if (value > m_ThreadMax[threadId]) { m_ThreadMax[threadId] = value; } m_ThreadSum[threadId] += realValue; m_SumOfSquares[threadId] += (realValue * realValue); m_Count[threadId]++; } } ++it; progress.CompletedPixel(); } } template void PersistentStatisticsImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Minimum: " << static_cast::PrintType>(this->GetMinimum()) << std::endl; os << indent << "Maximum: " << static_cast::PrintType>(this->GetMaximum()) << std::endl; os << indent << "Sum: " << this->GetSum() << std::endl; os << indent << "Mean: " << this->GetMean() << std::endl; os << indent << "Sigma: " << this->GetSigma() << std::endl; os << indent << "Variance: " << this->GetVariance() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingStatisticsMapFromLabelImageFilter.h000066400000000000000000000237211301006202600337500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingStatisticsMapFromLabelImageFilter_h #define otbStreamingStatisticsMapFromLabelImageFilter_h #include "otbPersistentImageFilter.h" #include "itkNumericTraits.h" #include "itkArray.h" #include "itkSimpleDataObjectDecorator.h" #include "otbPersistentFilterStreamingDecorator.h" namespace otb { /** \class PersistentStreamingStatisticsMapFromLabelImageFilter * \brief Computes mean radiometric value for each label of a label image, based on a support VectorImage * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output statistics will be the statitics of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the statistics once the regions have been processed via the pipeline, use the Synthetize() method. * * \todo Implement other statistics (min, max, stddev...) * * \sa StreamingStatisticsMapFromLabelImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentStreamingStatisticsMapFromLabelImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentStreamingStatisticsMapFromLabelImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentStreamingStatisticsMapFromLabelImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputVectorImage VectorImageType; typedef typename TInputVectorImage::Pointer InputVectorImagePointer; typedef TLabelImage LabelImageType; typedef typename TLabelImage::Pointer LabelImagePointer; typedef typename VectorImageType::PixelType VectorPixelType; typedef typename LabelImageType::PixelType LabelPixelType; typedef std::map > MeanValueMapType; typedef std::map LabelPopulationMapType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputVectorImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputVectorImage::ImageDimension); /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; typedef itk::ImageBase ImageBaseType; typedef typename ImageBaseType::RegionType InputImageRegionType; /** Type of DataObjects used for scalar outputs */ typedef itk::SimpleDataObjectDecorator MeanValueMapObjectType; /** Set input label image */ virtual void SetInputLabelImage( const LabelImageType *image); /** Get input label image */ virtual const LabelImageType * GetInputLabelImage(); /** Return the computed Mean for each label in the input label image */ MeanValueMapType GetMeanValueMap() const; /** Return the computed number of labeled pixels for each label in the input label image */ LabelPopulationMapType GetLabelPopulationMap() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; /** Due to heterogeneous input template GenerateInputRequestedRegion must be reimplemented using explicit cast **/ /** This new implementation is inspired by the one of itk::ImageToImageFilter **/ void GenerateInputRequestedRegion() ITK_OVERRIDE; protected: PersistentStreamingStatisticsMapFromLabelImageFilter(); ~PersistentStreamingStatisticsMapFromLabelImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** GenerateData. */ void GenerateData() ITK_OVERRIDE; private: PersistentStreamingStatisticsMapFromLabelImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented MeanValueMapType m_RadiometricValueAccumulator; LabelPopulationMapType m_LabelPopulation; }; // end of class PersistentStreamingStatisticsMapFromLabelImageFilter /*===========================================================================*/ /** \class StreamingStatisticsMapFromLabelImageFilter * \brief Computes mean radiometric value for each label of a label image, based on a support VectorImage * * Currently the class only computes the mean value. * * This class streams the whole input image through the PersistentStreamingStatisticsMapFromLabelImageFilter. * * This way, it allows computing the first order global statistics of this image. * It calls the Reset() method of the PersistentStatisticsImageFilter before streaming * the image and the Synthetize() method of the PersistentStatisticsImageFilter * after having streamed the image to compute the statistics. * The accessor on the results are wrapping the accessors of the * internal PersistentStatisticsImageFilter. * * This filter can be used as: * \code * typedef otb::StreamingStatisticsMapFromLabelImageFilter StatisticsType; * StatisticsType::Pointer statistics = StatisticsType::New(); * statistics->SetInput(reader->GetOutput()); * statistics->Update(); * StatisticsType::MeanValueMapType meanValueMap = statistics->GetMeanValueMap(); * StatisticsType::MeanValueMapType::const_iterator end = meanValueMap(); * for (StatisticsType::MeanValueMapType::const_iterator it = meanValueMap.begin(); it != end; ++it) * { * std::cout << "label : " << it->first << " , "; * << "mean value : " << it->second << std::endl; * } * \endcode * * \todo Implement other statistics (min, max, stddev...) * \todo Reimplement as a multi-threaded filter * * \sa PersistentStatisticsImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT StreamingStatisticsMapFromLabelImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingStatisticsMapFromLabelImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingStatisticsMapFromLabelImageFilter, PersistentFilterStreamingDecorator); typedef TInputVectorImage VectorImageType; typedef TLabelImage LabelImageType; typedef typename Superclass::FilterType::MeanValueMapType MeanValueMapType; typedef typename Superclass::FilterType::MeanValueMapObjectType MeanValueMapObjectType; typedef typename Superclass::FilterType::LabelPopulationMapType LabelPopulationMapType; /** Set input multispectral image */ using Superclass::SetInput; void SetInput(const VectorImageType * input) { this->GetFilter()->SetInput(input); } /** Get input multispectral image */ const VectorImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Set input label image (monoband) */ void SetInputLabelImage(const LabelImageType * input) { this->GetFilter()->SetInputLabelImage(input); } /** Get input label image (monoband) */ const LabelImageType * GetInputLabelImage() { return this->GetFilter()->GetInputLabelImage(); } /** Return the computed Mean for each label */ MeanValueMapType GetMeanValueMap() const { return this->GetFilter()->GetMeanValueMap(); } /** Return the computed number of labeled pixels for each label */ LabelPopulationMapType GetLabelPopulationMap() const { return this->GetFilter()->GetLabelPopulationMap(); } protected: /** Constructor */ StreamingStatisticsMapFromLabelImageFilter() {} /** Destructor */ ~StreamingStatisticsMapFromLabelImageFilter() ITK_OVERRIDE {} private: StreamingStatisticsMapFromLabelImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingStatisticsMapFromLabelImageFilter.txx" #endif #endif otbStreamingStatisticsMapFromLabelImageFilter.txx000066400000000000000000000202501301006202600342570ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingStatisticsMapFromLabelImageFilter_txx #define otbStreamingStatisticsMapFromLabelImageFilter_txx #include "otbStreamingStatisticsMapFromLabelImageFilter.h" #include "itkInputDataObjectIterator.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentStreamingStatisticsMapFromLabelImageFilter ::PersistentStreamingStatisticsMapFromLabelImageFilter() { // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around pixel types typename MeanValueMapObjectType::Pointer output = static_cast(this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, output.GetPointer()); this->Reset(); } template typename itk::DataObject::Pointer PersistentStreamingStatisticsMapFromLabelImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { switch (output) { case 0: return static_cast(TInputVectorImage::New().GetPointer()); break; case 1: return static_cast(MeanValueMapObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputVectorImage::New().GetPointer()); break; } } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::SetInputLabelImage(const LabelImageType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast< LabelImageType * >( input ) ); } template const typename PersistentStreamingStatisticsMapFromLabelImageFilter::LabelImageType* PersistentStreamingStatisticsMapFromLabelImageFilter ::GetInputLabelImage() { return static_cast< const TLabelImage * > (this->itk::ProcessObject::GetInput(1)); } template typename PersistentStreamingStatisticsMapFromLabelImageFilter::MeanValueMapType PersistentStreamingStatisticsMapFromLabelImageFilter ::GetMeanValueMap() const { return m_RadiometricValueAccumulator; } template typename PersistentStreamingStatisticsMapFromLabelImageFilter::LabelPopulationMapType PersistentStreamingStatisticsMapFromLabelImageFilter ::GetLabelPopulationMap() const { return m_LabelPopulation; } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::Synthetize() { typename MeanValueMapType::iterator it; for(it = m_RadiometricValueAccumulator.begin(); it != m_RadiometricValueAccumulator.end(); it++) { it->second = it->second / m_LabelPopulation[it->first]; } } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::Reset() { m_RadiometricValueAccumulator.clear(); } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::GenerateInputRequestedRegion() { // The Requested Regions of all the inputs are set to their Largest Possible Regions this->itk::ProcessObject::GenerateInputRequestedRegion(); // Iteration over all the inputs of the current filter (this) for( itk::InputDataObjectIterator it( this ); !it.IsAtEnd(); it++ ) { // Check whether the input is an image of the appropriate dimension // dynamic_cast of all the input images as itk::ImageBase objects // in order to pass the if ( input ) test whatever the inputImageType (vectorImage or labelImage) ImageBaseType * input = dynamic_cast< ImageBaseType *>( it.GetInput() ); if ( input ) { // Use the function object RegionCopier to copy the output region // to the input. The default region copier has default implementations // to handle the cases where the input and output are the same // dimension, the input a higher dimension than the output, and the // input a lower dimension than the output. InputImageRegionType inputRegion; this->CallCopyOutputRegionToInputRegion( inputRegion, this->GetOutput()->GetRequestedRegion() ); input->SetRequestedRegion(inputRegion); } } } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::GenerateData() { /** * Grab the input */ InputVectorImagePointer inputPtr = const_cast(this->GetInput()); LabelImagePointer labelInputPtr = const_cast(this->GetInputLabelImage()); itk::ImageRegionConstIterator inIt(inputPtr, inputPtr->GetRequestedRegion()); itk::ImageRegionConstIterator labelIt(labelInputPtr, labelInputPtr->GetRequestedRegion()); itk::VariableLengthVector zeroValue(inputPtr->GetNumberOfComponentsPerPixel()); zeroValue.Fill(0.0); typename VectorImageType::PixelType value; typename LabelImageType::PixelType label; // do the work for (inIt.GoToBegin(), labelIt.GoToBegin(); !inIt.IsAtEnd() && !labelIt.IsAtEnd(); ++inIt, ++labelIt) { value = inIt.Get(); label = labelIt.Get(); if (m_RadiometricValueAccumulator.count(label)<=0) //add new element to the map { // use a zero pixel with the right number of components to support scalar images m_RadiometricValueAccumulator[label] = (zeroValue + value); m_LabelPopulation[label] = 1; } else { m_RadiometricValueAccumulator[label] += value; m_LabelPopulation[label] ++; } } } template void PersistentStreamingStatisticsMapFromLabelImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingStatisticsVectorImageFilter.h000066400000000000000000000374401301006202600327140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingStatisticsVectorImageFilter_h #define otbStreamingStatisticsVectorImageFilter_h #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "itkSimpleDataObjectDecorator.h" #include "itkImageRegionSplitter.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" namespace otb { /** \class PersistentStreamingStatisticsVectorImageFilter * \brief Compute covariance & correlation of a large image using streaming * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output statistics will be the statitics of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the statistics once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentStreamingStatisticsVectorImageFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentStreamingStatisticsVectorImageFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentStreamingStatisticsVectorImageFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename ImageType::Pointer InputImagePointer; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::InternalPixelType InternalPixelType; typedef TPrecision PrecisionType; typedef PrecisionType RealType; /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Type to use for computations. */ typedef itk::VariableSizeMatrix MatrixType; typedef itk::VariableLengthVector RealPixelType; /** Type of DataObjects used for outputs */ typedef itk::SimpleDataObjectDecorator RealObjectType; typedef itk::SimpleDataObjectDecorator IndexObjectType; typedef itk::SimpleDataObjectDecorator PixelObjectType; typedef itk::SimpleDataObjectDecorator RealPixelObjectType; typedef itk::SimpleDataObjectDecorator MatrixObjectType; /** Return the computed Min */ PixelType GetMinimum() const { return this->GetMinOutput()->Get(); } PixelObjectType* GetMinimumOutput(); const PixelObjectType* GetMinimumOutput() const; /** Return the computed Max index */ PixelType GetMaximum() const { return this->GetMaxOutput()->Get(); } PixelObjectType* GetMaximumOutput(); const PixelObjectType* GetMaximumOutput() const; /** Return the global mean of all the internal pixel values * (flattening the multispectral image as a 1D-vector) */ RealType GetComponentMean() const { return this->GetComponentMeanOutput()->Get(); } RealObjectType* GetComponentMeanOutput(); const RealObjectType* GetComponentMeanOutput() const; /** Return the global correlation of all the internal pixel values * (flattening the multispectral image as a 1D-vector) */ RealType GetComponentCorrelation() const { return this->GetComponentCorrelationOutput()->Get(); } RealObjectType* GetComponentCorrelationOutput(); const RealObjectType* GetComponentCorrelationOutput() const; /** Return the global covariance of all the internal pixel values * (flattening the multispectral image as a 1D-vector) */ RealType GetComponentCovariance() const { return this->GetComponentCovarianceOutput()->Get(); } RealObjectType* GetComponentCovarianceOutput(); const RealObjectType* GetComponentCovarianceOutput() const; /** Return the computed Mean. */ RealPixelType GetMean() const { return this->GetMeanOutput()->Get(); } RealPixelObjectType* GetMeanOutput(); const RealPixelObjectType* GetMeanOutput() const; /** Return the computed Sum. */ RealPixelType GetSum() const { return this->GetSumOutput()->Get(); } RealPixelObjectType* GetSumOutput(); const RealPixelObjectType* GetSumOutput() const; /** Return the computed Covariance. */ MatrixType GetCorrelation() const { return this->GetCorrelation()->Get(); } MatrixObjectType* GetCorrelationOutput(); const MatrixObjectType* GetCorrelationOutput() const; /** Return the computed Covariance. */ MatrixType GetCovariance() const { return this->GetCovarianceOutput()->Get(); } MatrixObjectType* GetCovarianceOutput(); const MatrixObjectType* GetCovarianceOutput() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; void Reset(void) ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; itkSetMacro(EnableMinMax, bool); itkGetMacro(EnableMinMax, bool); itkSetMacro(EnableFirstOrderStats, bool); itkGetMacro(EnableFirstOrderStats, bool); itkSetMacro(EnableSecondOrderStats, bool); itkGetMacro(EnableSecondOrderStats, bool); itkSetMacro(IgnoreInfiniteValues, bool); itkGetMacro(IgnoreInfiniteValues, bool); itkSetMacro(IgnoreUserDefinedValue, bool); itkGetMacro(IgnoreUserDefinedValue, bool); itkSetMacro(UserIgnoredValue, InternalPixelType); itkGetMacro(UserIgnoredValue, InternalPixelType); itkSetMacro(UseUnbiasedEstimator, bool); itkGetMacro(UseUnbiasedEstimator, bool); protected: PersistentStreamingStatisticsVectorImageFilter(); ~PersistentStreamingStatisticsVectorImageFilter() ITK_OVERRIDE {} /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentStreamingStatisticsVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented bool m_EnableMinMax; bool m_EnableFirstOrderStats; bool m_EnableSecondOrderStats; /* use an unbiased estimator to compute the covariance */ bool m_UseUnbiasedEstimator; std::vector m_ThreadMin; std::vector m_ThreadMax; std::vector m_ThreadFirstOrderComponentAccumulators; std::vector m_ThreadSecondOrderComponentAccumulators; std::vector m_ThreadFirstOrderAccumulators; std::vector m_ThreadSecondOrderAccumulators; /* Ignored values */ bool m_IgnoreInfiniteValues; bool m_IgnoreUserDefinedValue; InternalPixelType m_UserIgnoredValue; std::vector m_IgnoredInfinitePixelCount; std::vector m_IgnoredUserPixelCount; }; // end of class PersistentStreamingStatisticsVectorImageFilter /**===========================================================================*/ /** \class StreamingStatisticsVectorImageFilter * \brief This class streams the whole input image through the PersistentStatisticsImageFilter. * * This way, it allows computing the first and second order global statistics of this image. It calls the * Reset() method of the PersistentStreamingStatisticsVectorImageFilter before streaming the image and the * Synthetize() method of the PersistentStreamingStatisticsVectorImageFilter after having streamed the image * to compute the statistics. The accessor on the results are wrapping the accessors of the * internal PersistentStreamingStatisticsVectorImageFilter. * By default infinite values are ignored, use IgnoreInfiniteValues accessor to consider * infinite values in the computation. * * \sa PersistentStreamingStatisticsVectorImageFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template::RealType> class ITK_EXPORT StreamingStatisticsVectorImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingStatisticsVectorImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingStatisticsVectorImageFilter, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef typename Superclass::FilterType StatFilterType; /** Type of DataObjects used for outputs */ typedef typename StatFilterType::PixelType PixelType; typedef typename StatFilterType::RealType RealType; typedef typename StatFilterType::RealObjectType RealObjectType; typedef typename StatFilterType::RealPixelType RealPixelType; typedef typename StatFilterType::RealPixelObjectType RealPixelObjectType; typedef typename StatFilterType::MatrixType MatrixType; typedef typename StatFilterType::MatrixObjectType MatrixObjectType; typedef typename StatFilterType::InternalPixelType InternalPixelType; using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Return the computed Minimum. */ RealPixelType GetMinimum() const { return this->GetFilter()->GetMinimumOutput()->Get(); } RealPixelObjectType* GetMinimumOutput() { return this->GetFilter()->GetMinimumOutput(); } const RealPixelObjectType* GetMinimumOutput() const { return this->GetFilter()->GetMinimumOutput(); } /** Return the computed Maximum. */ RealPixelType GetMaximum() const { return this->GetFilter()->GetMaximumOutput()->Get(); } RealPixelObjectType* GetMaximumOutput() { return this->GetFilter()->GetMaximumOutput(); } const RealPixelObjectType* GetMaximumOutput() const { return this->GetFilter()->GetMaximumOutput(); } /** Return the computed Mean. */ RealPixelType GetMean() const { return this->GetFilter()->GetMeanOutput()->Get(); } RealPixelObjectType* GetMeanOutput() { return this->GetFilter()->GetMeanOutput(); } const RealPixelObjectType* GetMeanOutput() const { return this->GetFilter()->GetMeanOutput(); } /** Return the computed Sum. */ RealPixelType GetSum() const { return this->GetFilter()->GetSumOutput()->Get(); } RealPixelObjectType* GetSumOutput() { return this->GetFilter()->GetSumOutput(); } const RealPixelObjectType* GetSumOutput() const { return this->GetFilter()->GetSumOutput(); } /** Return the computed Covariance. */ MatrixType GetCovariance() const { return this->GetFilter()->GetCovarianceOutput()->Get(); } MatrixObjectType* GetCovarianceOutput() { return this->GetFilter()->GetCovarianceOutput(); } const MatrixObjectType* GetCovarianceOutput() const { return this->GetFilter()->GetCovarianceOutput(); } /** Return the computed Covariance. */ MatrixType GetCorrelation() const { return this->GetFilter()->GetCorrelationOutput()->Get(); } MatrixObjectType* GetCorrelationOutput() { return this->GetFilter()->GetCorrelationOutput(); } const MatrixObjectType* GetCorrelationOutput() const { return this->GetFilter()->GetCorrelationOutput(); } /** Return the computed Mean. */ RealType GetComponentMean() const { return this->GetFilter()->GetComponentMeanOutput()->Get(); } RealObjectType* GetComponentMeanOutput() { return this->GetFilter()->GetComponentMeanOutput(); } const RealObjectType* GetComponentMeanOutput() const { return this->GetFilter()->GetComponentMeanOutput(); } /** Return the computed Covariance. */ RealType GetComponentCovariance() const { return this->GetFilter()->GetComponentCovarianceOutput()->Get(); } RealObjectType* GetComponentCovarianceOutput() { return this->GetFilter()->GetComponentCovarianceOutput(); } const RealObjectType* GetComponentCovarianceOutput() const { return this->GetFilter()->GetComponentCovarianceOutput(); } /** Return the computed Covariance. */ RealType GetComponentCorrelation() const { return this->GetFilter()->GetComponentCorrelationOutput()->Get(); } RealObjectType* GetComponentCorrelationOutput() { return this->GetFilter()->GetComponentCorrelationOutput(); } const RealObjectType* GetComponentCorrelationOutput() const { return this->GetFilter()->GetComponentCorrelationOutput(); } otbSetObjectMemberMacro(Filter, EnableMinMax, bool); otbGetObjectMemberMacro(Filter, EnableMinMax, bool); otbSetObjectMemberMacro(Filter, EnableFirstOrderStats, bool); otbGetObjectMemberMacro(Filter, EnableFirstOrderStats, bool); otbSetObjectMemberMacro(Filter, EnableSecondOrderStats, bool); otbGetObjectMemberMacro(Filter, EnableSecondOrderStats, bool); otbSetObjectMemberMacro(Filter, IgnoreInfiniteValues, bool); otbGetObjectMemberMacro(Filter, IgnoreInfiniteValues, bool); otbSetObjectMemberMacro(Filter, IgnoreUserDefinedValue, bool); otbGetObjectMemberMacro(Filter, IgnoreUserDefinedValue, bool); otbSetObjectMemberMacro(Filter, UserIgnoredValue, InternalPixelType); otbGetObjectMemberMacro(Filter, UserIgnoredValue, InternalPixelType); otbSetObjectMemberMacro(Filter, UseUnbiasedEstimator, bool); otbGetObjectMemberMacro(Filter, UseUnbiasedEstimator, bool); protected: /** Constructor */ StreamingStatisticsVectorImageFilter() {} /** Destructor */ ~StreamingStatisticsVectorImageFilter() ITK_OVERRIDE {} private: StreamingStatisticsVectorImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingStatisticsVectorImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbStreamingStatisticsVectorImageFilter.txx000066400000000000000000000525501301006202600333070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingStatisticsVectorImageFilter_txx #define otbStreamingStatisticsVectorImageFilter_txx #include "otbStreamingStatisticsVectorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentStreamingStatisticsVectorImageFilter ::PersistentStreamingStatisticsVectorImageFilter() : m_EnableMinMax(true), m_EnableFirstOrderStats(true), m_EnableSecondOrderStats(true), m_UseUnbiasedEstimator(true), m_IgnoreInfiniteValues(true), m_IgnoreUserDefinedValue(false), m_UserIgnoredValue(itk::NumericTraits::Zero) { // first output is a copy of the image, DataObject created by // superclass // allocate the data objects for the outputs which are // just decorators around vector/matrix types for (unsigned int i = 1; i < 10; ++i) { this->itk::ProcessObject::SetNthOutput(i, this->MakeOutput(i).GetPointer()); } // Initiate ignored pixel counters m_IgnoredInfinitePixelCount= std::vector(this->GetNumberOfThreads(), 0); m_IgnoredUserPixelCount= std::vector(this->GetNumberOfThreads(), 0); } template itk::DataObject::Pointer PersistentStreamingStatisticsVectorImageFilter ::MakeOutput(DataObjectPointerArraySizeType output) { switch (output) { case 0: return static_cast(TInputImage::New().GetPointer()); break; case 1: case 2: // min/max return static_cast(PixelObjectType::New().GetPointer()); break; case 3: case 4: // mean / sum return static_cast(RealPixelObjectType::New().GetPointer()); break; case 5: case 6: // covariance / correlation return static_cast(MatrixObjectType::New().GetPointer()); break; case 7: case 8: case 9: // component mean, component covariance, component correlation return static_cast(RealObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputImage::New().GetPointer()); break; } } template typename PersistentStreamingStatisticsVectorImageFilter::PixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetMinimumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentStreamingStatisticsVectorImageFilter::PixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetMinimumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename PersistentStreamingStatisticsVectorImageFilter::PixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetMaximumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template const typename PersistentStreamingStatisticsVectorImageFilter::PixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetMaximumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(2)); } template typename PersistentStreamingStatisticsVectorImageFilter::RealObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetComponentMeanOutput() { return static_cast(this->itk::ProcessObject::GetOutput(7)); } template const typename PersistentStreamingStatisticsVectorImageFilter::RealObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetComponentMeanOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(7)); } template typename PersistentStreamingStatisticsVectorImageFilter::RealObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetComponentCorrelationOutput() { return static_cast(this->itk::ProcessObject::GetOutput(8)); } template const typename PersistentStreamingStatisticsVectorImageFilter::RealObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetComponentCorrelationOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(8)); } template typename PersistentStreamingStatisticsVectorImageFilter::RealObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetComponentCovarianceOutput() { return static_cast(this->itk::ProcessObject::GetOutput(9)); } template const typename PersistentStreamingStatisticsVectorImageFilter::RealObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetComponentCovarianceOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(9)); } template typename PersistentStreamingStatisticsVectorImageFilter::RealPixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetMeanOutput() { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template const typename PersistentStreamingStatisticsVectorImageFilter::RealPixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetMeanOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(3)); } template typename PersistentStreamingStatisticsVectorImageFilter::RealPixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetSumOutput() { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template const typename PersistentStreamingStatisticsVectorImageFilter::RealPixelObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetSumOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(4)); } template typename PersistentStreamingStatisticsVectorImageFilter::MatrixObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetCorrelationOutput() { return static_cast(this->itk::ProcessObject::GetOutput(5)); } template const typename PersistentStreamingStatisticsVectorImageFilter::MatrixObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetCorrelationOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(5)); } template typename PersistentStreamingStatisticsVectorImageFilter::MatrixObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetCovarianceOutput() { return static_cast(this->itk::ProcessObject::GetOutput(6)); } template const typename PersistentStreamingStatisticsVectorImageFilter::MatrixObjectType* PersistentStreamingStatisticsVectorImageFilter ::GetCovarianceOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(6)); } template void PersistentStreamingStatisticsVectorImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentStreamingStatisticsVectorImageFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentStreamingStatisticsVectorImageFilter ::Reset() { TInputImage * inputPtr = const_cast(this->GetInput()); inputPtr->UpdateOutputInformation(); unsigned int numberOfThreads = this->GetNumberOfThreads(); unsigned int numberOfComponent = inputPtr->GetNumberOfComponentsPerPixel(); if (m_EnableMinMax) { PixelType tempPixel; tempPixel.SetSize(numberOfComponent); tempPixel.Fill(itk::NumericTraits::max()); this->GetMinimumOutput()->Set(tempPixel); tempPixel.Fill(itk::NumericTraits::NonpositiveMin()); this->GetMaximumOutput()->Set(tempPixel); PixelType tempTemporiesPixel; tempTemporiesPixel.SetSize(numberOfComponent); tempTemporiesPixel.Fill(itk::NumericTraits::max()); m_ThreadMin = std::vector(numberOfThreads, tempTemporiesPixel); tempTemporiesPixel.Fill(itk::NumericTraits::NonpositiveMin()); m_ThreadMax = std::vector(numberOfThreads, tempTemporiesPixel); } if (m_EnableSecondOrderStats) { m_EnableFirstOrderStats = true; } if (m_EnableFirstOrderStats) { RealPixelType zeroRealPixel; zeroRealPixel.SetSize(numberOfComponent); zeroRealPixel.Fill(itk::NumericTraits::ZeroValue()); this->GetMeanOutput()->Set(zeroRealPixel); this->GetSumOutput()->Set(zeroRealPixel); m_ThreadFirstOrderAccumulators.resize(numberOfThreads); std::fill(m_ThreadFirstOrderAccumulators.begin(), m_ThreadFirstOrderAccumulators.end(), zeroRealPixel); RealType zeroReal = itk::NumericTraits::ZeroValue(); m_ThreadFirstOrderComponentAccumulators.resize(numberOfThreads); std::fill(m_ThreadFirstOrderComponentAccumulators.begin(), m_ThreadFirstOrderComponentAccumulators.end(), zeroReal); } if (m_EnableSecondOrderStats) { MatrixType zeroMatrix; zeroMatrix.SetSize(numberOfComponent, numberOfComponent); zeroMatrix.Fill(itk::NumericTraits::Zero); this->GetCovarianceOutput()->Set(zeroMatrix); this->GetCorrelationOutput()->Set(zeroMatrix); m_ThreadSecondOrderAccumulators.resize(numberOfThreads); std::fill(m_ThreadSecondOrderAccumulators.begin(), m_ThreadSecondOrderAccumulators.end(), zeroMatrix); RealType zeroReal = itk::NumericTraits::ZeroValue(); m_ThreadSecondOrderComponentAccumulators.resize(numberOfThreads); std::fill(m_ThreadSecondOrderComponentAccumulators.begin(), m_ThreadSecondOrderComponentAccumulators.end(), zeroReal); } if (m_IgnoreInfiniteValues) { m_IgnoredInfinitePixelCount= std::vector(numberOfThreads, 0); } if (m_IgnoreUserDefinedValue) { m_IgnoredUserPixelCount= std::vector(this->GetNumberOfThreads(), 0); } } template void PersistentStreamingStatisticsVectorImageFilter ::Synthetize() { TInputImage * inputPtr = const_cast(this->GetInput()); const unsigned int nbPixels = inputPtr->GetLargestPossibleRegion().GetNumberOfPixels(); const unsigned int numberOfComponent = inputPtr->GetNumberOfComponentsPerPixel(); PixelType minimum; minimum.SetSize(numberOfComponent); minimum.Fill(itk::NumericTraits::max()); PixelType maximum; maximum.SetSize(numberOfComponent); maximum.Fill(itk::NumericTraits::NonpositiveMin()); RealPixelType streamFirstOrderAccumulator(numberOfComponent); streamFirstOrderAccumulator.Fill(itk::NumericTraits::Zero); MatrixType streamSecondOrderAccumulator(numberOfComponent, numberOfComponent); streamSecondOrderAccumulator.Fill(itk::NumericTraits::Zero); RealType streamFirstOrderComponentAccumulator = itk::NumericTraits::Zero; RealType streamSecondOrderComponentAccumulator = itk::NumericTraits::Zero; unsigned int ignoredInfinitePixelCount = 0; unsigned int ignoredUserPixelCount = 0; // Accumulate results from all threads const itk::ThreadIdType numberOfThreads = this->GetNumberOfThreads(); for (itk::ThreadIdType threadId = 0; threadId < numberOfThreads; ++threadId) { if (m_EnableMinMax) { const PixelType& threadMin = m_ThreadMin [threadId]; const PixelType& threadMax = m_ThreadMax [threadId]; for (unsigned int j = 0; j < numberOfComponent; ++j) { if (threadMin[j] < minimum[j]) { minimum[j] = threadMin[j]; } if (threadMax[j] > maximum[j]) { maximum[j] = threadMax[j]; } } } if (m_EnableFirstOrderStats) { streamFirstOrderAccumulator += m_ThreadFirstOrderAccumulators[threadId]; streamFirstOrderComponentAccumulator += m_ThreadFirstOrderComponentAccumulators[threadId]; } if (m_EnableSecondOrderStats) { streamSecondOrderAccumulator += m_ThreadSecondOrderAccumulators[threadId]; streamSecondOrderComponentAccumulator += m_ThreadSecondOrderComponentAccumulators[threadId]; } // Ignored Infinite Pixels ignoredInfinitePixelCount += m_IgnoredInfinitePixelCount[threadId]; // Ignored Pixels ignoredUserPixelCount += m_IgnoredUserPixelCount[threadId]; } // There cannot be more ignored pixels than read pixels. assert( nbPixels >= ignoredInfinitePixelCount + ignoredUserPixelCount ); if( nbPixels < ignoredInfinitePixelCount + ignoredUserPixelCount ) { itkExceptionMacro( "nbPixels < ignoredInfinitePixelCount + ignoredUserPixelCount" ); } unsigned int nbRelevantPixels = nbPixels - (ignoredInfinitePixelCount + ignoredUserPixelCount); if( nbRelevantPixels==0 ) { itkExceptionMacro( "Statistics cannot be calculated with zero relevant pixels." ); } // Final calculations if (m_EnableMinMax) { this->GetMinimumOutput()->Set(minimum); this->GetMaximumOutput()->Set(maximum); } if (m_EnableFirstOrderStats) { this->GetComponentMeanOutput()->Set(streamFirstOrderComponentAccumulator / (nbRelevantPixels * numberOfComponent)); this->GetMeanOutput()->Set(streamFirstOrderAccumulator / nbRelevantPixels); this->GetSumOutput()->Set(streamFirstOrderAccumulator); } if (m_EnableSecondOrderStats) { MatrixType cor = streamSecondOrderAccumulator / nbRelevantPixels; this->GetCorrelationOutput()->Set(cor); const RealPixelType& mean = this->GetMeanOutput()->Get(); double regul = 1.0; double regulComponent = 1.0; if( m_UseUnbiasedEstimator && nbRelevantPixels>1 ) { regul = static_cast< double >( nbRelevantPixels ) / ( static_cast< double >( nbRelevantPixels ) - 1.0 ); } if( m_UseUnbiasedEstimator && (nbRelevantPixels * numberOfComponent) > 1 ) { regulComponent = static_cast< double >(nbRelevantPixels * numberOfComponent) / ( static_cast< double >(nbRelevantPixels * numberOfComponent) - 1.0 ); } MatrixType cov = cor; for (unsigned int r = 0; r < numberOfComponent; ++r) { for (unsigned int c = 0; c < numberOfComponent; ++c) { cov(r, c) = regul * (cov(r, c) - mean[r] * mean[c]); } } this->GetCovarianceOutput()->Set(cov); this->GetComponentMeanOutput()->Set(streamFirstOrderComponentAccumulator / (nbRelevantPixels * numberOfComponent)); this->GetComponentCorrelationOutput()->Set(streamSecondOrderComponentAccumulator / (nbRelevantPixels * numberOfComponent)); this->GetComponentCovarianceOutput()->Set( regulComponent * (this->GetComponentCorrelation() - (this->GetComponentMean() * this->GetComponentMean()))); } } template void PersistentStreamingStatisticsVectorImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Grab the input InputImagePointer inputPtr = const_cast(this->GetInput()); PixelType& threadMin = m_ThreadMin [threadId]; PixelType& threadMax = m_ThreadMax [threadId]; itk::ImageRegionConstIteratorWithIndex it(inputPtr, outputRegionForThread); for (it.GoToBegin(); !it.IsAtEnd(); ++it, progress.CompletedPixel()) { const PixelType& vectorValue = it.Get(); float finiteProbe = 0.; bool userProbe = m_IgnoreUserDefinedValue; for (unsigned int j = 0; j < vectorValue.GetSize(); ++j) { finiteProbe += (float)(vectorValue[j]); userProbe = userProbe && (vectorValue[j] == m_UserIgnoredValue); } if (m_IgnoreInfiniteValues && !(vnl_math_isfinite(finiteProbe))) { m_IgnoredInfinitePixelCount[threadId] ++; } else { if (userProbe) { m_IgnoredUserPixelCount[threadId] ++; } else { if (m_EnableMinMax) { for (unsigned int j = 0; j < vectorValue.GetSize(); ++j) { if (vectorValue[j] < threadMin[j]) { threadMin[j] = vectorValue[j]; } if (vectorValue[j] > threadMax[j]) { threadMax[j] = vectorValue[j]; } } } if (m_EnableFirstOrderStats) { RealPixelType& threadFirstOrder = m_ThreadFirstOrderAccumulators [threadId]; RealType& threadFirstOrderComponent = m_ThreadFirstOrderComponentAccumulators [threadId]; threadFirstOrder += vectorValue; for (unsigned int i = 0; i < vectorValue.GetSize(); ++i) { threadFirstOrderComponent += vectorValue[i]; } } if (m_EnableSecondOrderStats) { MatrixType& threadSecondOrder = m_ThreadSecondOrderAccumulators[threadId]; RealType& threadSecondOrderComponent = m_ThreadSecondOrderComponentAccumulators[threadId]; for (unsigned int r = 0; r < threadSecondOrder.Rows(); ++r) { for (unsigned int c = 0; c < threadSecondOrder.Cols(); ++c) { threadSecondOrder(r, c) += vectorValue[r] * vectorValue[c]; } } threadSecondOrderComponent += vectorValue.GetSquaredNorm(); } } } } } template void PersistentStreamingStatisticsVectorImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Min: " << this->GetMinimumOutput()->Get() << std::endl; os << indent << "Max: " << this->GetMaximumOutput()->Get() << std::endl; os << indent << "Mean: " << this->GetMeanOutput()->Get() << std::endl; os << indent << "Covariance: " << this->GetCovarianceOutput()->Get() << std::endl; os << indent << "Correlation: " << this->GetCorrelationOutput()->Get() << std::endl; os << indent << "Component Mean: " << this->GetComponentMeanOutput()->Get() << std::endl; os << indent << "Component Covariance: " << this->GetComponentCovarianceOutput()->Get() << std::endl; os << indent << "Component Correlation: " << this->GetComponentCorrelationOutput()->Get() << std::endl; os << indent << "UseUnbiasedEstimator: " << (this->m_UseUnbiasedEstimator ? "true" : "false") << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbVarianceImageFilter.h000066400000000000000000000112161301006202600272460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVarianceImageFilter_h #define otbVarianceImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" #include "itkNumericTraits.h" namespace otb { /** \class VarianceImageFilter * \brief Applies an averaging filter to an image * * Computes an image where a given pixel is the value over the standard 8, 26, etc. connected * neighborhood. This calculation uses a ZeroFluxNeumannBoundaryCondition. * * * \sa Image * \sa Neighborhood * \sa NeighborhoodOperator * \sa NeighborhoodIterator * * \ingroup IntensityImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT VarianceImageFilter : public itk::ImageToImageFilter { public: /** Extract dimension from input and output image. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Convenient typedefs for simplifying declarations. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; /** Standard class typedefs. */ typedef VarianceImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VarianceImageFilter, ImageToImageFilter); /** Image typedef support. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename itk::NumericTraits::RealType InputRealType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; /** Set the radius of the neighborhood used to compute the mean. */ itkSetMacro(Radius, InputSizeType); /** Get the radius of the neighborhood used to compute the mean */ itkGetConstReferenceMacro(Radius, InputSizeType); /** VarianceImageFilter needs a larger input requested region than * the output requested region. As such, VarianceImageFilter needs * to provide an implementation for GenerateInputRequestedRegion() * in order to inform the pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(InputHasNumericTraitsCheck, (itk::Concept::HasNumericTraits)); /** End concept checking */ #endif protected: VarianceImageFilter(); ~VarianceImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** VarianceImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() * routine which is called for each processing thread. The output * image data is allocated automatically by the superclass prior to * calling ThreadedGenerateData(). ThreadedGenerateData can only * write to the portion of the output image specified by the * parameter "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: VarianceImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented InputSizeType m_Radius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVarianceImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbVarianceImageFilter.txx000066400000000000000000000123161301006202600276440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVarianceImageFilter_txx #define otbVarianceImageFilter_txx #include "otbVarianceImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" namespace otb { template VarianceImageFilter ::VarianceImageFilter() { m_Radius.Fill(1); } template void VarianceImageFilter ::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast(this->GetInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if (!inputPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius(m_Radius); // crop the input requested region at the input's largest possible region if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion())) { inputPtr->SetRequestedRegion(inputRequestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion(inputRequestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template void VarianceImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { unsigned int i; itk::ZeroFluxNeumannBoundaryCondition nbc; itk::ConstNeighborhoodIterator bit; itk::ImageRegionIterator it; // Allocate output typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); // Find the data-set boundary "faces" typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType faceList; itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator bC; faceList = bC(input, outputRegionForThread, m_Radius); typename itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator::FaceListType::iterator fit; // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); InputRealType sum; InputRealType sumOfSquares; // Process each of the boundary faces. These are N-d regions which border // the edge of the buffer. for (fit = faceList.begin(); fit != faceList.end(); ++fit) { bit = itk::ConstNeighborhoodIterator(m_Radius, input, *fit); unsigned int neighborhoodSize = bit.Size(); it = itk::ImageRegionIterator(output, *fit); bit.OverrideBoundaryCondition(&nbc); bit.GoToBegin(); while (!bit.IsAtEnd()) { sum = itk::NumericTraits::Zero; sumOfSquares = itk::NumericTraits::Zero; for (i = 0; i < neighborhoodSize; ++i) { const InputRealType value = static_cast(bit.GetPixel(i)); sum += value; sumOfSquares += value * value; } // get the mean value const double num = static_cast(neighborhoodSize); it.Set(static_cast(sumOfSquares - (sum * sum / num)) / (num - 1.0)); ++bit; ++it; progress.CompletedPixel(); } } } /** * Standard "PrintSelf" method */ template void VarianceImageFilter ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbVectorImageToIntensityImageFilter.h000066400000000000000000000075121301006202600321410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToIntensityImageFilter_h #define otbVectorImageToIntensityImageFilter_h #include "itkImageToImageFilter.h" namespace otb { /** \class VectorImageToIntensityImageFilter * \brief This filter implements the computation of the mean of the spectral values of each pixel. * * The spectral mean * is defined as: * * \f[ SM = \frac{1}{n_{b}} \times \sum_{b=1}^{n_{b}}p(b) \f] * with \f$b\f$ being the spectral band and \f$p\f$ * the current pixel. * * Since the spectral mean deals with multi-bands image, the InputImage pixels are supposed to * support the [] operator, and the input image to support the GetNumberOfComponentsPerPixel() method. * * \sa VectorImage * * This filter is implemented as a multithreaded filter. * * \ingroup IntensityImageFilters * \ingroup Threading * \ingroup Streamed * * \ingroup OTBStatistics */ template class ITK_EXPORT VectorImageToIntensityImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef VectorImageToIntensityImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(VectorImageToIntensityImageFilter, itk::ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; protected: /** Constructor */ VectorImageToIntensityImageFilter(); /** Destructor */ ~VectorImageToIntensityImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** VectorImageToIntensityImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: VectorImageToIntensityImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorImageToIntensityImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbVectorImageToIntensityImageFilter.txx000066400000000000000000000052221301006202600325310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToIntensityImageFilter_txx #define otbVectorImageToIntensityImageFilter_txx #include "otbVectorImageToIntensityImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "otbMacro.h" #include "otbMath.h" namespace otb { /** * Constructor */ template VectorImageToIntensityImageFilter ::VectorImageToIntensityImageFilter() { } template void VectorImageToIntensityImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImageConstPointerType inputPtr = this->GetInput(); OutputImagePointerType outputPtr = this->GetOutput(); // Define the portion of the input to walk for this thread, using // the CallCopyOutputRegionToInputRegion method allows for the input // and output images to be different dimensions InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators itk::ImageRegionConstIterator inputIt(inputPtr, inputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd() && !outputIt.IsAtEnd()) { double sum = 0.0; InputPixelType pixel = inputIt.Get(); for (unsigned int i = 0; i < pixel.Size(); ++i) { sum += pixel[i]; } sum /= pixel.Size(); outputIt.Set(static_cast(sum)); ++inputIt; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } /** * PrintSelf Method */ template void VectorImageToIntensityImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbVectorImageToMatrixImageFilter.h000066400000000000000000000166101301006202600314160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToMatrixFilter_h #define otbVectorImageToMatrixFilter_h #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "itkSimpleDataObjectDecorator.h" #include "itkImageRegionSplitter.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" namespace otb { /** \class PersistentVectorImageToMatrixFilter * \brief Compute covariance & correlation of a large image using streaming * * This filter persists its temporary data. It means that if you Update it n times on n different * requested regions, the output statistics will be the statitics of the whole set of n regions. * * To reset the temporary data, one should call the Reset() function. * * To get the statistics once the regions have been processed via the pipeline, use the Synthetize() method. * * \sa PersistentImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * * \ingroup OTBStatistics */ template class ITK_EXPORT PersistentVectorImageToMatrixFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentVectorImageToMatrixFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentVectorImageToMatrixFilter, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage ImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; typedef typename TInputImage::InternalPixelType InternalPixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Type to use for computations. */ //typedef typename itk::NumericTraits::RealType RealType; typedef InternalPixelType RealType; typedef itk::VariableLengthVector RealPixelType; /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Type of DataObjects used for scalar outputs */ typedef vnl_matrix MatrixType; typedef itk::SimpleDataObjectDecorator MatrixObjectType; /** Return the computed matrix as a DataObject */ MatrixObjectType* GetMatrixOutput(); const MatrixObjectType* GetMatrixOutput() const; /** Make a DataObject of the correct type to be used as the specified * output. */ DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Pass the input through unmodified. Do this by Grafting in the * AllocateOutputs method. */ void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; protected: PersistentVectorImageToMatrixFilter(); ~PersistentVectorImageToMatrixFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentVectorImageToMatrixFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // end of class PersistentVectorImageToMatrixFilter /**===========================================================================*/ /** \class VectorImageToMatrixImageFilter * \brief This class streams the whole input image through the PersistentStatisticsImageFilter. * * This way, it allows computing the first order global statistics of this image. It calls the * Reset() method of the PersistentStatisticsImageFilter before streaming the image and the * Synthetize() method of the PersistentStatisticsImageFilter after having streamed the image * to compute the statistics. The accessor on the results are wrapping the accessors of the * internal PersistentStatisticsImageFilter. * * \sa PersistentVectorImageToMatrixFilter * \sa PersistentImageFilter * \sa PersistentFilterStreamingDecorator * \sa StreamingImageVirtualWriter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup OTBStatistics */ template class ITK_EXPORT VectorImageToMatrixImageFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef VectorImageToMatrixImageFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(VectorImageToMatrixImageFilter, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef typename Superclass::FilterType PersistentFilterType; typedef typename PersistentFilterType::MatrixType MatrixType; typedef typename PersistentFilterType::MatrixObjectType MatrixObjectType; using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Return the computed Mean. */ const MatrixType& GetMatrix() const { return this->GetMatrixOutput()->Get(); } MatrixObjectType* GetMatrixOutput() { return this->GetFilter()->GetMatrixOutput(); } const MatrixObjectType* GetMatrixOutput() const { return this->GetFilter()->GetMatrixOutput(); } protected: /** Constructor */ VectorImageToMatrixImageFilter() {}; /** Destructor */ ~VectorImageToMatrixImageFilter() ITK_OVERRIDE {} private: VectorImageToMatrixImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorImageToMatrixImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Statistics/include/otbVectorImageToMatrixImageFilter.txx000066400000000000000000000116771301006202600320220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorImageToMatrixFilter_txx #define otbVectorImageToMatrixFilter_txx #include "otbVectorImageToMatrixImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkProgressReporter.h" #include "otbMacro.h" namespace otb { template PersistentVectorImageToMatrixFilter ::PersistentVectorImageToMatrixFilter() { // first output is a copy of the image, DataObject created by // superclass // // allocate the data objects for the outputs which are // just decorators around vector/matric types this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer()); } template itk::DataObject::Pointer PersistentVectorImageToMatrixFilter ::MakeOutput(DataObjectPointerArraySizeType output) { switch (output) { case 0: return static_cast(TInputImage::New().GetPointer()); break; case 1: return static_cast(MatrixObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputImage::New().GetPointer()); break; } } template typename PersistentVectorImageToMatrixFilter::MatrixObjectType* PersistentVectorImageToMatrixFilter ::GetMatrixOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentVectorImageToMatrixFilter::MatrixObjectType* PersistentVectorImageToMatrixFilter ::GetMatrixOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void PersistentVectorImageToMatrixFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentVectorImageToMatrixFilter ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentVectorImageToMatrixFilter ::Reset() { TInputImage * inputPtr = const_cast(this->GetInput()); inputPtr->UpdateOutputInformation(); this->GetMatrixOutput()->Get().set_size( inputPtr->GetNumberOfComponentsPerPixel(), inputPtr->GetLargestPossibleRegion().GetNumberOfPixels()); } template void PersistentVectorImageToMatrixFilter ::Synthetize() { } template void PersistentVectorImageToMatrixFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Grab the input InputImagePointer inputPtr = const_cast(this->GetInput()); const unsigned int width = this->GetInput()->GetLargestPossibleRegion().GetSize()[0]; itk::ImageRegionConstIteratorWithIndex it(inputPtr, outputRegionForThread); for (it.GoToBegin(); !it.IsAtEnd(); ++it, progress.CompletedPixel()) { const IndexType& idx = it.GetIndex(); unsigned int col = idx[0] + idx[1] * width; const PixelType& vectorValue = it.Get(); MatrixType& m = this->GetMatrixOutput()->Get(); for (unsigned int r = 0; r < vectorValue.Size(); ++r) { m(r, col) = vectorValue[r]; } } } template void PersistentVectorImageToMatrixFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/Statistics/otb-module.cmake000066400000000000000000000014601301006202600241550ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes related to statistical calculation. One part of them is dedicated to the handling of ListSample (measurements stored in a list type structure -as opposed to -). For instance, it is possible to concatenate several sample lists into a single one, to generate a noised version of the input sample list, and so on. The other part works on images and labelMaps and allows the calculation of classical statistics (min max mean histogram).") otb_module(OTBStatistics DEPENDS OTBCommon OTBITK OTBImageBase OTBObjectList OTBProjection OTBStreaming TEST_DEPENDS OTBCommandLineParser OTBImageIO OTBImageManipulation OTBInterpolation OTBTestKernel OTBVectorDataBase OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/Statistics/src/000077500000000000000000000000001301006202600216725ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/src/CMakeLists.txt000066400000000000000000000006231301006202600244330ustar00rootroot00000000000000set(OTBStatistics_SRC otbSamplerBase.cxx otbPeriodicSampler.cxx otbPatternSampler.cxx otbRandomSampler.cxx ) add_library(OTBStatistics ${OTBStatistics_SRC}) target_link_libraries(OTBStatistics ${OTBCommon_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBObjectList_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBStreaming_LIBRARIES} ) otb_module_target(OTBStatistics) OTB-release-5.8/Modules/Filtering/Statistics/src/otbPatternSampler.cxx000066400000000000000000000141611301006202600260670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPatternSampler.h" #include "otbMath.h" #include "otbMacro.h" #include namespace otb { bool PatternSampler::ParameterType::operator!=(const PatternSampler::ParameterType & param) const { return bool((MaxPatternSize != param.MaxPatternSize)|| (Pattern1 != param.Pattern1)|| (Pattern2 != param.Pattern2)|| (Seed != param.Seed)); } PatternSampler::PatternSampler() : m_Index1(0UL) , m_Index2(0UL) { this->m_Parameters.MaxPatternSize = 1000; this->m_Parameters.Pattern1.clear(); this->m_Parameters.Pattern2.clear(); this->m_Parameters.Seed = 121212; } void PatternSampler::Reset(void) { Superclass::Reset(); m_Index1 = 0UL; m_Index2 = 0UL; // if seed is not 0, generate patterns // since the pattern depend on the sampling rate they should be regenerated // in order to keep existing patterns, the seed should be set to 0 if (this->m_Parameters.Seed) { unsigned long T1 = FindBestSize(this->GetTotalElements()); unsigned long N1 = static_cast(vcl_floor( this->GetRate() * T1 )); double selected_ratio = static_cast(N1)/static_cast(T1); unsigned long taken = static_cast(selected_ratio*static_cast(this->GetTotalElements())); unsigned long left = this->GetNeededElements() - taken; unsigned long newtot = this->GetTotalElements() - taken; unsigned long T2 = 0; unsigned long N2 = 0; if (left>0) { double ratio2 = 0.0; if (newtot>0) ratio2 = static_cast(left)/static_cast(newtot); T2 = FindBestSize(this->GetTotalElements()/T1*(T1-N1)); if (T2>0) { N2 = static_cast(vcl_ceil( ratio2 * T2 )); } } std::srand ( m_Parameters.Seed ); this->m_Parameters.Pattern1 = RandArray(N1,T1); if (T2>0) this->m_Parameters.Pattern2 = RandArray(N2,T2); } } bool PatternSampler::TakeSample(void) { bool ret = false; this->m_ProcessedElements += 1UL; if (this->m_ChosenElements >= this->GetNeededElements()) return false; // Test selection with first pattern ret = this->m_Parameters.Pattern1[m_Index1]; m_Index1++; if (m_Index1 >= this->m_Parameters.Pattern1.size()) m_Index1=0UL; if(!ret && this->m_Parameters.Pattern2.size()) { // Test selection with second pattern ret = this->m_Parameters.Pattern2[m_Index2]; m_Index2++; if (m_Index2 >= this->m_Parameters.Pattern2.size()) m_Index2=0UL; } if (ret) { this->m_ChosenElements += 1UL; } return ret; } // [static] void PatternSampler::ImportPatterns(const std::string &data, ParameterType ¶m) { // clear output patterns param.Pattern1.clear(); param.Pattern2.clear(); // split the string on slash caracters size_t sep1 = data.find('/'); // convert string into bool sequence for (size_t pos=0 ; pos < data.size() ; ++pos) { if (pos == sep1) break; switch (ParseSymbol(data[pos])) { case 0: { param.Pattern1.push_back(false); break; } case 1: { param.Pattern1.push_back(true); break; } default: { break; } } } if (sep1 != std::string::npos) { size_t sep2 = data.find('/',sep1+1); for (size_t pos=(sep1+1) ; pos < data.size() ; ++pos) { if (pos == sep2) break; switch (ParseSymbol(data[pos])) { case 0: { param.Pattern2.push_back(false); break; } case 1: { param.Pattern2.push_back(true); break; } default: { break; } } } } } // [static] void PatternSampler::ExportPatterns(const ParameterType ¶m, std::string &data) { // clear output string data.clear(); // format output patterns for (unsigned int i=0 ; i< param.Pattern1.size() ; ++i) { if (param.Pattern1[i]) { data.push_back('1'); } else { data.push_back('0'); } } if (param.Pattern2.size()) { data.push_back('/'); } for (unsigned int i=0 ; i< param.Pattern2.size() ; ++i) { if (param.Pattern2[i]) { data.push_back('1'); } else { data.push_back('0'); } } } unsigned int PatternSampler::ParseSymbol(const char &s) { if ((s == '1') || (s == 'X') || (s == 'y') || (s == 'Y') || (s == '|') || (s == '+') ) { return 1; } else if ((s == '0') || (s == '_') || (s == 'n') || (s == 'N') || (s == '.') || (s == '-') ) { return 0; } return 2; } std::vector PatternSampler::RandArray(unsigned long N,unsigned long T) { if (N>T) itkGenericExceptionMacro(<< "N must be <= to T (aka m_SamplingTabSize)." << std::endl); std::vector res(T,0); for(unsigned long i=0; i= 2; size--) if (tot%size == 0) return size; otbWarningMacro(<<"prime number > m_Parameters.MaxPatternSize (" << tot << ">" << m_Parameters.MaxPatternSize << ")."<< std::endl ); // fallback : return the maximum size return m_Parameters.MaxPatternSize; } } // namespace otb OTB-release-5.8/Modules/Filtering/Statistics/src/otbPeriodicSampler.cxx000066400000000000000000000047731301006202600262200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPeriodicSampler.h" #include "otbMath.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { bool PeriodicSampler::ParameterType::operator!=(const PeriodicSampler::ParameterType & param) const { return bool((Offset != param.Offset)|| (MaxJitter != param.MaxJitter)); } void PeriodicSampler::Reset(void) { Superclass::Reset(); // Detect maximum jitter size, clamp with (T/N - 1) m_JitterSize = std::min((double) this->m_Parameters.MaxJitter, 1.0/this->GetRate() - 1.0); if (m_JitterSize > 0.0) { // Using jitter : compute random offset value m_OffsetValue = itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance() ->GetUniformVariate(0.0,m_JitterSize); } else { // Using a constant offset value, between 0 and T/N m_OffsetValue = (double)this->m_Parameters.Offset; while (m_OffsetValue >= 1.0/this->GetRate()) { m_OffsetValue -= 1.0/this->GetRate(); } } } bool PeriodicSampler::TakeSample(void) { bool ret = false; // Take p elements among N, while iterating on the full set (current index i) // where k elements have already been selected. The offset is in the intervall // [0, N/p] // val = (i - offset)*p/N - k // if ceil(val) > 0; then take the sample this->m_ProcessedElements += 1UL; double val = ((double)(this->m_ProcessedElements) - m_OffsetValue )*this->GetRate() - (double)(this->m_ChosenElements); if (0 < (int)(vcl_ceil(val))) { this->m_ChosenElements += 1UL; if (m_JitterSize > 0.0) { // Using jitter : compute random offset value m_OffsetValue = itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance() ->GetUniformVariate(0.0,m_JitterSize); } ret = true; } return ret; } PeriodicSampler::PeriodicSampler() { this->m_Parameters.Offset = 0UL; this->m_Parameters.MaxJitter = 0UL; m_JitterSize = 0.0; m_OffsetValue = 0.0; } } OTB-release-5.8/Modules/Filtering/Statistics/src/otbRandomSampler.cxx000066400000000000000000000060521301006202600256720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRandomSampler.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "otbMath.h" #include namespace otb { bool RandomSampler::ParameterType::operator!=(const RandomSampler::ParameterType & param) const { return bool(MaxBufferSize != param.MaxBufferSize); } void RandomSampler::Reset(void) { Superclass::Reset(); // Generate list of positions m_Positions.clear(); unsigned int seed = itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->GetSeed(); std::srand(seed); unsigned long currentOffset = 0UL; unsigned long bufferSize, needed; std::vector buffer; while (currentOffset < this->GetTotalElements()) { // shuffle a buffer bufferSize = std::min( this->GetTotalElements() - currentOffset, m_Parameters.MaxBufferSize); if (bufferSize == this->GetTotalElements()) { needed = this->GetNeededElements(); } else { // try to handle cases where there is less than 1 needed sample per buffer double sizeRatio1 = static_cast(currentOffset)/ static_cast(this->GetTotalElements()); double sizeRatio2 = static_cast(currentOffset+bufferSize)/ static_cast(this->GetTotalElements()); needed = static_cast( sizeRatio2 * (double)this->GetNeededElements()) - static_cast( sizeRatio1 * (double)this->GetNeededElements()); } buffer.clear(); buffer.resize(bufferSize,0); // switch ON the first 'needed' booleans for (unsigned long k=0UL ; km_ProcessedElements >= this->GetTotalElements() || this->m_ChosenElements >= this->GetNeededElements()) { this->m_ProcessedElements += 1UL; return false; } if (this->m_ProcessedElements == *m_CurrentPosition) { ret = true; this->m_ChosenElements += 1UL; ++m_CurrentPosition; } this->m_ProcessedElements += 1UL; return ret; } RandomSampler::RandomSampler() { this->m_Parameters.MaxBufferSize = 100000000; } } OTB-release-5.8/Modules/Filtering/Statistics/src/otbSamplerBase.cxx000066400000000000000000000046111301006202600253230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSamplerBase.h" #include "otbMath.h" #include "itkMath.h" #include namespace otb { void SamplerBase::Reset(void) { this->m_ChosenElements = 0UL; this->m_ProcessedElements = 0UL; } void SamplerBase::SetNumberOfElements(unsigned long needed, unsigned long total) { bool modified = false; unsigned long neededChecked = needed; if (needed > total) { itkWarningMacro(<< "Needed elements (" << needed << ") will be clamped to total elements (" << total << ")" << std::endl); neededChecked = total; } if (m_NeededElements != neededChecked) { m_NeededElements = neededChecked; modified = true; } if (m_TotalElements != total) { m_TotalElements = total; modified = true; } if (modified) { if (m_TotalElements > 0) { m_Rate = (double)(m_NeededElements) / (double)(m_TotalElements); } else { m_Rate = 0.0; } this->Modified(); } } void SamplerBase::SetRate(double rate, unsigned long total) { bool modified = false; double rateChecked = rate; if (rate > 1.0) { itkWarningMacro(<< "Rate (" << rate << ") will be clamped to 1.0" << std::endl); rateChecked = 1.0; } if (rate < 0.0) { itkWarningMacro(<< "Rate (" << rate << ") will be clamped to 0.0" << std::endl); rateChecked = 0.0; } if (std::fabs(m_Rate-rateChecked) > 1e-12) { m_Rate = rateChecked; modified = true; } if (m_TotalElements != total) { m_TotalElements = total; modified = true; } if (modified) { m_NeededElements = (unsigned long)(vcl_floor(0.5 + m_Rate * (double)(m_TotalElements) )); this->Modified(); } } SamplerBase::SamplerBase() : m_ChosenElements(0UL) , m_ProcessedElements(0UL) , m_TotalElements(0UL) , m_NeededElements(0UL) , m_Rate(0.0) { } } OTB-release-5.8/Modules/Filtering/Statistics/test/000077500000000000000000000000001301006202600220625ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/test/CMakeLists.txt000066400000000000000000000430141301006202600246240ustar00rootroot00000000000000otb_module_test() set(OTBStatisticsTests otbStatisticsTestDriver.cxx otbListSampleToHistogramListGeneratorNew.cxx otbStreamingMinMaxImageFilter.cxx otbStreamingMinMaxVectorImageFilterNew.cxx otbVarianceImageFilterNew.cxx otbStreamingStatisticsImageFilterNew.cxx otbListSampleToVariableDimensionHistogramGeneratorNew.cxx otbStreamingHistogramVectorImageFilter.cxx otbStreamingStatisticsVectorImageFilterNew.cxx otbRealImageToComplexImageFilterTest.cxx otbHistogramStatisticsFunction.cxx otbContinuousMinimumMaximumImageCalculatorTest.cxx otbGaussianAdditiveNoiseSampleListFilter.cxx otbNormalizeVectorImageFilter.cxx otbVectorImageToMatrixImageFilter.cxx otbListSampleToVariableDimensionHistogramGenerator.cxx otbStreamingMinMaxImageFilterNew.cxx otbShiftScaleSampleListFilter.cxx otbVectorImageToIntensityImageFilter.cxx otbVarianceImageFilter.cxx otbConcatenateSampleListFilter.cxx otbLocalHistogramImageFunctionTest.cxx otbVectorImageToIntensityImageFilterNew.cxx otbProjectiveProjection.cxx otbShiftScaleVectorImageFilterTest.cxx otbContinuousMinimumMaximumImageCalculatorNew.cxx otbStreamingCompareImageFilter.cxx otbStreamingStatisticsMapFromLabelImageFilterTest.cxx otbLocalHistogramImageFunctionNew.cxx otbRealAndImaginaryImageToComplexImageFilterTest.cxx otbStreamingStatisticsImageFilter.cxx otbListSampleToBalancedListSampleFilter.cxx otbStreamingStatisticsVectorImageFilter.cxx otbStreamingMinMaxVectorImageFilter.cxx otbListSampleGeneratorTest.cxx otbImaginaryImageToComplexImageFilterTest.cxx otbListSampleToHistogramListGenerator.cxx otbSamplerTest.cxx ) add_executable(otbStatisticsTestDriver ${OTBStatisticsTests}) target_link_libraries(otbStatisticsTestDriver ${OTBStatistics-Test_LIBRARIES}) otb_module_target_label(otbStatisticsTestDriver) # Tests Declaration otb_add_test(NAME bfTuListSampleToHistogramListGeneratorNew COMMAND otbStatisticsTestDriver otbListSampleToHistogramListGeneratorNew) otb_add_test(NAME bfTvStreamingMinMaxImageFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvStreamingMinMaxImageFilterResults.txt ${TEMP}/bfTvStreamingMinMaxImageFilterResults.txt otbStreamingMinMaxImageFilter ${INPUTDATA}/couleurs_extrait.png ${TEMP}/bfTvStreamingMinMaxImageFilterResults.txt ) otb_add_test(NAME bfTuStreamingMinMaxVectorImageFilterNew COMMAND otbStatisticsTestDriver otbStreamingMinMaxVectorImageFilterNew) otb_add_test(NAME bfTuVarianceImageFilterNew COMMAND otbStatisticsTestDriver otbVarianceImageFilterNew) otb_add_test(NAME bfTuStreamingStatisticsImageFilterNew COMMAND otbStatisticsTestDriver otbStreamingStatisticsImageFilterNew) otb_add_test(NAME bfTuListSampleToVariableDimensionHistogramGeneratorNew COMMAND otbStatisticsTestDriver otbListSampleToVariableDimensionHistogramGeneratorNew) otb_add_test(NAME bfTuStreamingHistogramVIFilterNew COMMAND otbStatisticsTestDriver otbStreamingHistogramVectorImageFilterNew ) otb_add_test(NAME bfTvStreamingHistogramVIFilterTest COMMAND otbStatisticsTestDriver otbStreamingHistogramVectorImageFilterTest ) otb_add_test(NAME bfTuStreamingStatisticsVectorImageFilterNew COMMAND otbStatisticsTestDriver otbStreamingStatisticsVectorImageFilterNew) otb_add_test(NAME bfTvRealImageToComplexImageFilterTest COMMAND otbStatisticsTestDriver otbRealImageToComplexImageFilterTest ${INPUTDATA}/GomaAvant.png ) otb_add_test(NAME coTuHistogramStatisticsFunction COMMAND otbStatisticsTestDriver otbHistogramStatisticsFunction 100) otb_add_test(NAME bfTvContinuousMinimumMaximumImageCalculatorTest COMMAND otbStatisticsTestDriver otbContinuousMinimumMaximumImageCalculatorTest ${INPUTDATA}/QB_Suburb.png ) otb_add_test(NAME leTuGaussianAdditiveNoiseSampleListFilterNew COMMAND otbStatisticsTestDriver otbGaussianAdditiveNoiseSampleListFilterNew) otb_add_test(NAME leTvGaussianAdditiveNoiseSampleListFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvGaussianAdditiveNoiseSampleListFilterOutput.txt ${TEMP}/leTvGaussianAdditiveNoiseSampleListFilterOutput.txt otbGaussianAdditiveNoiseSampleListFilter ${TEMP}/leTvGaussianAdditiveNoiseSampleListFilterOutput.txt 2 -1 -3 1 2 -2 -5 -1 -3 0 -1 ) otb_add_test(NAME bfTuNormalizeVectorImageFilter COMMAND otbStatisticsTestDriver otbNormalizeVectorImageFilterNewTest) otb_add_test(NAME bfTvNormalizeVectorImageFilter COMMAND otbStatisticsTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvNormalizeVectorImageFilter.tif ${TEMP}/bfTvNormalizeVectorImageFilter.tif otbNormalizeVectorImageFilterTest -in ${INPUTDATA}/cupriteSubHsi.tif -out ${TEMP}/bfTvNormalizeVectorImageFilter.tif) otb_add_test(NAME bfTuVectorImageToMatrixNew COMMAND otbStatisticsTestDriver otbVectorImageToMatrixNewTest) otb_add_test(NAME bfTvVectorImageToMatrix COMMAND otbStatisticsTestDriver otbVectorImageToMatrixTest) otb_add_test(NAME bfTvListSampleToVariableDimensionHistogramGenerator COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvListSampleToVariableDimensionHistogramGeneratorOutput.txt ${TEMP}/bfTvListSampleToVariableDimensionHistogramGeneratorOutput.txt otbListSampleToVariableDimensionHistogramGenerator ${INPUTDATA}/couleurs.tif ${TEMP}/bfTvListSampleToVariableDimensionHistogramGeneratorOutput.txt 10 1 ) otb_add_test(NAME bfTuStreamingMinMaxImageFilterNew COMMAND otbStatisticsTestDriver otbStreamingMinMaxImageFilterNew) otb_add_test(NAME leTuShiftScaleSampleListFilterNew COMMAND otbStatisticsTestDriver otbShiftScaleSampleListFilterNew) otb_add_test(NAME leTvShiftScaleSampleListFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvShiftScaleSampleListFilterOutput.txt ${TEMP}/leTvShiftScaleSampleListFilterOutput.txt otbShiftScaleSampleListFilter ${TEMP}/leTvShiftScaleSampleListFilterOutput.txt 2 -1 -3 1 2 -2 -5 -1 -3 0 -1 ) otb_add_test(NAME bfTvVectorImageToIntensityImageFilter COMMAND otbStatisticsTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvVectorImageToIntensityImageOutput.tif ${TEMP}/bfTvVectorImageToIntensityImageOutput.tif otbVectorImageToIntensityImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif ${TEMP}/bfTvVectorImageToIntensityImageOutput.tif ) otb_add_test(NAME bfTvVarianceImageFilter COMMAND otbStatisticsTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfVarianceImageFilter.tif ${TEMP}/bfVarianceImageFilter.tif otbVarianceImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/bfVarianceImageFilter.tif ) otb_add_test(NAME leTuConcatenateSampleListFilterNew COMMAND otbStatisticsTestDriver otbConcatenateSampleListFilterNew) otb_add_test(NAME leTvConcatenateSampleListFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvConcatenateSampleListFilterOutput.txt ${TEMP}/leTvConcatenateSampleListFilterOutput.txt otbConcatenateSampleListFilter ${TEMP}/leTvConcatenateSampleListFilterOutput.txt 2 3 2 -1 -3 1 2 -2 -5 -1 -3 0 -1 ) otb_add_test(NAME feTvLocalHistogramImageFunctionTest COMMAND otbStatisticsTestDriver --compare-ascii ${EPSILON_8} ${BASELINE_FILES}/feLocalHistogramImage.txt ${TEMP}/feLocalHistogramImage.txt otbLocalHistogramImageFunctionTest ${INPUTDATA}/pyramide.tif ${TEMP}/feLocalHistogramImage.txt 127 127 127 0 128 ) otb_add_test(NAME bfTuVectorImageToIntensityImageFilterNew COMMAND otbStatisticsTestDriver otbVectorImageToIntensityImageFilterNew) otb_add_test(NAME bfTuProjectiveProjectionNew COMMAND otbStatisticsTestDriver otbProjectiveProjectionNew) otb_add_test(NAME bfTvProjectiveProjectionTestHighSNR COMMAND otbStatisticsTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvProjectiveProjectionTestHighSNR.tif ${TEMP}/bfTvProjectiveProjectionTestHighSNR.tif otbProjectiveProjectionTestHighSNR ${INPUTDATA}/cupriteSubHsi.tif 3 ${TEMP}/bfTvProjectiveProjectionTestHighSNR.tif) otb_add_test(NAME bfTvShiftScaleVectorImageFilter COMMAND otbStatisticsTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvShiftScaleVImageOutput.tif ${TEMP}/bfTvShiftScaleVImageOutput.tif otbShiftScaleVectorImageFilterTest ${INPUTDATA}/qb_RoadExtract.img.hdr ${TEMP}/bfTvShiftScaleVImageOutput.tif ) otb_add_test(NAME bfTuContinuousMinimumMaximumImageCalculatorNew COMMAND otbStatisticsTestDriver otbContinuousMinimumMaximumImageCalculatorNew ) otb_add_test(NAME bfTuStreamingCompareImageFilterNew COMMAND otbStatisticsTestDriver otbStreamingCompareImageFilterNew) otb_add_test(NAME bfTvStreamingCompareImageFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfStreamingCompareImageFilterResults.txt ${TEMP}/bfStreamingCompareImageFilterResults.txt otbStreamingCompareImageFilter ${INPUTDATA}/small_poupees_1canal.hd ${TEMP}/bfStreamingCompareImageFilterResults.txt) otb_add_test(NAME feTuLocalHistogramImageFunctionNew COMMAND otbStatisticsTestDriver otbLocalHistogramImageFunctionNew ) otb_add_test(NAME bfTvRealAndImaginaryImageToComplexImageFilterTest COMMAND otbStatisticsTestDriver otbRealAndImaginaryImageToComplexImageFilterTest ${INPUTDATA}/GomaAvant.png ${INPUTDATA}/GomaApres.png ) otb_add_test(NAME bfTvStreamingStatisticsImageFilterWithNaNs COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfStreamingStatisticsImageFilterWithNaNsResults.txt ${TEMP}/bfStreamingStatisticsImageFilterWithNaNsResults.txt otbStreamingStatisticsImageFilter ${INPUTDATA}/small_poupees_1canalWithNaNs.TIF ${TEMP}/bfStreamingStatisticsImageFilterWithNaNsResults.txt) otb_add_test(NAME bfTvStreamingStatisticsImageFilterWithBckGrdVal COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfStreamingStatisticsImageFilterWithBckGrdValResults.txt ${TEMP}/bfStreamingStatisticsImageFilterWithBckGrdValResults.txt otbStreamingStatisticsImageFilter ${INPUTDATA}/small_poupees_1canalWithNaNs.TIF ${TEMP}/bfStreamingStatisticsImageFilterWithBckGrdValResults.txt 0 ) otb_add_test(NAME bfTvStreamingStatisticsImageFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfStreamingStatisticsImageFilterResults.txt ${TEMP}/bfStreamingStatisticsImageFilterResults.txt otbStreamingStatisticsImageFilter ${INPUTDATA}/small_poupees_1canal.hd ${TEMP}/bfStreamingStatisticsImageFilterResults.txt) foreach(inputFileType "UINT8" "UINT16" "INT16" "UINT32" "INT32" "FLOAT" "DOUBLE") foreach(sizeType "LARGE" "SMALL") string(TOLOWER ${sizeType} lsizeType) if( sizeType STREQUAL "LARGE" ) set(size "2048") else() set(size "256") endif() # Derive output file names set(OUTFILENAME RGBSquares${inputFileType}_${lsizeType}.tif) set(OUTLABELFILENAME RGBSquares${inputFileType}_${lsizeType}_Labels.tif) set(writeOutputImagesRq "0") otb_add_test(NAME bfTvStreamingStatisticsMapFromLabelImageFilterTest${inputFileType}${lsizeType} COMMAND otbStatisticsTestDriver otbStreamingStatisticsMapFromLabelImageFilterTest ${inputFileType} ${size} ${size} ${writeOutputImagesRq} ${TEMP}/${OUTFILENAME} ${TEMP}/${OUTLABELFILENAME} ) endforeach() endforeach() otb_add_test(NAME leTuListSampleToBalancedListSampleFilterNew COMMAND otbStatisticsTestDriver otbListSampleToBalancedListSampleFilterNew) otb_add_test(NAME leTvListSampleToBalancedListSampleFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvListSampleToBalancedListSampleFilterOutput.txt ${TEMP}/leTvListSampleToBalancedListSampleFilterOutput.txt otbListSampleToBalancedListSampleFilter ${TEMP}/leTvListSampleToBalancedListSampleFilterOutput.txt 2 -1 -3 0 # The third element is the label of the SampleList 1 2 1 -2 -5 0 -1 -3 1 0 -1 1 -3 1 1 -5 2 1 2 1 1 2 8 1 1 -4 0 -1 5 4 2 5 1 0 -5 0 1 -1 2 ) otb_add_test(NAME bfTvStreamingStatisticsVectorImageFilterWithNaNs COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvStreamingStatisticsVectorImageFilterWithNaNsResults.txt ${TEMP}/bfTvStreamingStatisticsVectorImageFilterWithNaNsResults.txt otbStreamingStatisticsVectorImageFilter ${INPUTDATA}/small_poupees_WithNaNs.TIF ${TEMP}/bfTvStreamingStatisticsVectorImageFilterWithNaNsResults.txt ) otb_add_test(NAME bfTvStreamingStatisticsVectorImageFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvStreamingStatisticsVectorImageFilterResults.txt ${TEMP}/bfTvStreamingStatisticsVectorImageFilterResults.txt otbStreamingStatisticsVectorImageFilter ${INPUTDATA}/couleurs_extrait.png ${TEMP}/bfTvStreamingStatisticsVectorImageFilterResults.txt ) otb_add_test(NAME bfTvStreamingStatisticsVectorImageFilterWithBckGrdVal COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvStreamingStatisticsVectorImageFilterWithBckGrdValResults.txt ${TEMP}/bfTvStreamingStatisticsVectorImageFilterWithBckGrdValResults.txt otbStreamingStatisticsVectorImageFilter ${INPUTDATA}/small_poupees_WithNaNs.TIF ${TEMP}/bfTvStreamingStatisticsVectorImageFilterWithBckGrdValResults.txt 0 ) otb_add_test(NAME bfTvStreamingMinMaxVectorImageFilter COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvStreamingMinMaxVectorImageFilterResults.txt ${TEMP}/bfTvStreamingMinMaxVectorImageFilterResults.txt otbStreamingMinMaxVectorImageFilter ${INPUTDATA}/couleurs_extrait.png ${TEMP}/bfTvStreamingMinMaxVectorImageFilterResults.txt ) otb_add_test(NAME leTuListSampleGeneratorNew COMMAND otbStatisticsTestDriver otbListSampleGeneratorNew) otb_add_test(NAME leTvListSampleGenerator4 COMMAND otbStatisticsTestDriver --compare-n-ascii ${NOTOL} 2 ${BASELINE_FILES}/leTvListSampleGenerator4.txt ${TEMP}/leTvListSampleGenerator4.txt ${BASELINE_FILES}/leTvListSampleGeneratorValidation4.txt ${TEMP}/leTvListSampleGeneratorValidation4.txt otbListSampleGenerator ${EXAMPLEDATA}/qb_RoadExtract.tif ${EXAMPLEDATA}/qb_RoadExtract_classification.shp ${TEMP}/leTvListSampleGenerator4.txt ${TEMP}/leTvListSampleGeneratorValidation4.txt -1 -1 0.5 0 ) otb_add_test(NAME leTvListSampleGenerator5 COMMAND otbStatisticsTestDriver --compare-n-ascii ${NOTOL} 2 ${BASELINE_FILES}/leTvListSampleGenerator5.txt ${TEMP}/leTvListSampleGenerator5.txt ${BASELINE_FILES}/leTvListSampleGeneratorValidation5.txt ${TEMP}/leTvListSampleGeneratorValidation5.txt otbListSampleGenerator ${EXAMPLEDATA}/qb_RoadExtract.tif ${EXAMPLEDATA}/qb_RoadExtract_classification.shp ${TEMP}/leTvListSampleGenerator5.txt ${TEMP}/leTvListSampleGeneratorValidation5.txt 8000 8000 0.5 0 ) otb_add_test(NAME leTvListSampleGenerator6 COMMAND otbStatisticsTestDriver --compare-n-ascii ${NOTOL} 2 ${BASELINE_FILES}/leTvListSampleGenerator6.txt ${TEMP}/leTvListSampleGenerator6.txt ${BASELINE_FILES}/leTvListSampleGeneratorValidation6.txt ${TEMP}/leTvListSampleGeneratorValidation6.txt otbListSampleGenerator ${EXAMPLEDATA}/qb_RoadExtract.tif ${EXAMPLEDATA}/qb_RoadExtract_classification.shp ${TEMP}/leTvListSampleGenerator6.txt ${TEMP}/leTvListSampleGeneratorValidation6.txt 15000 15000 0.5 0 ) otb_add_test(NAME leTvListSampleGenerator1 COMMAND otbStatisticsTestDriver --compare-n-ascii ${NOTOL} 2 ${BASELINE_FILES}/leTvListSampleGenerator1.txt ${TEMP}/leTvListSampleGenerator1.txt ${BASELINE_FILES}/leTvListSampleGeneratorValidation1.txt ${TEMP}/leTvListSampleGeneratorValidation1.txt otbListSampleGenerator ${EXAMPLEDATA}/qb_RoadExtract.tif ${EXAMPLEDATA}/qb_RoadExtract_classification.shp ${TEMP}/leTvListSampleGenerator1.txt ${TEMP}/leTvListSampleGeneratorValidation1.txt -1 -1 0 1 ) otb_add_test(NAME leTvListSampleGenerator2 COMMAND otbStatisticsTestDriver --compare-n-ascii ${NOTOL} 2 ${BASELINE_FILES}/leTvListSampleGenerator2.txt ${TEMP}/leTvListSampleGenerator2.txt ${BASELINE_FILES}/leTvListSampleGeneratorValidation2.txt ${TEMP}/leTvListSampleGeneratorValidation2.txt otbListSampleGenerator ${EXAMPLEDATA}/qb_RoadExtract.tif ${EXAMPLEDATA}/qb_RoadExtract_classification.shp ${TEMP}/leTvListSampleGenerator2.txt ${TEMP}/leTvListSampleGeneratorValidation2.txt -1 -1 0.5 1 ) otb_add_test(NAME leTvListSampleGenerator3 COMMAND otbStatisticsTestDriver --compare-n-ascii ${NOTOL} 2 ${BASELINE_FILES}/leTvListSampleGenerator3.txt ${TEMP}/leTvListSampleGenerator3.txt ${BASELINE_FILES}/leTvListSampleGeneratorValidation3.txt ${TEMP}/leTvListSampleGeneratorValidation3.txt otbListSampleGenerator ${EXAMPLEDATA}/qb_RoadExtract.tif ${EXAMPLEDATA}/qb_RoadExtract_classification.shp ${TEMP}/leTvListSampleGenerator3.txt ${TEMP}/leTvListSampleGeneratorValidation3.txt 100 200 0.5 1 ) otb_add_test(NAME bfTvImaginaryImageToComplexImageFilterTest COMMAND otbStatisticsTestDriver otbImaginaryImageToComplexImageFilterTest ${INPUTDATA}/GomaAvant.png ) otb_add_test(NAME bfTvListSampleToHistogramListGenerator COMMAND otbStatisticsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfTvListSampleToVariableDimensionHistogramGeneratorOutput.txt ${TEMP}/bfTvListSampleToHistogramListGeneratorOutput.txt otbListSampleToHistogramListGenerator ${INPUTDATA}/couleurs.tif ${TEMP}/bfTvListSampleToHistogramListGeneratorOutput.txt 10 1 ) otb_add_test(NAME bfTvPeriodicSamplerTest COMMAND otbStatisticsTestDriver otbPeriodicSamplerTest) otb_add_test(NAME bfTvPatternSamplerTest COMMAND otbStatisticsTestDriver otbPatternSamplerTest) otb_add_test(NAME bfTvRandomSamplerTest COMMAND otbStatisticsTestDriver otbRandomSamplerTest) OTB-release-5.8/Modules/Filtering/Statistics/test/StreamingStat.cxx000066400000000000000000000020361301006202600253740ustar00rootroot00000000000000#include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbStreamingStatisticsImageFilter.h" #include "otbVectorImageTo3DScalarImageFilter.h" int main(int itkNotUsed(argc), char ** argv) { typedef otb::Image Image3DType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(argv[1]); typedef otb::VectorImageTo3DScalarImageFilter VectorImageTo3DScalarImageFilterType; VectorImageTo3DScalarImageFilterType::Pointer filter1 = VectorImageTo3DScalarImageFilterType::New(); typedef otb::StreamingStatisticsImageFilter statFilterType; statFilterType::Pointer statFilter = statFilterType::New(); filter1->SetInput(reader1->GetOutput()); // filter1->Update(); statFilter->SetInput(filter1->GetOutput()); statFilter->Update(); std::cout << statFilter->GetMean() << std::endl; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbConcatenateSampleListFilter.cxx000066400000000000000000000054761301006202600307170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "itkVariableLengthVector.h" #include "otbConcatenateSampleListFilter.h" #include typedef itk::VariableLengthVector DoubleSampleType; typedef itk::Statistics::ListSample DoubleSampleListType; typedef otb::Statistics::ConcatenateSampleListFilter ConcatenateFilterType; int otbConcatenateSampleListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { ConcatenateFilterType::Pointer instance = ConcatenateFilterType::New(); return EXIT_SUCCESS; } int otbConcatenateSampleListFilter(int itkNotUsed(argc), char * argv[]) { // Compute the number of samples const char * outfname = argv[1]; unsigned int sampleSize = atoi(argv[2]); unsigned int nbSamples1 = atoi(argv[3]); unsigned int nbSamples2 = atoi(argv[4]); DoubleSampleListType::Pointer inputSampleList1 = DoubleSampleListType::New(); inputSampleList1->SetMeasurementVectorSize(sampleSize); DoubleSampleListType::Pointer inputSampleList2 = DoubleSampleListType::New(); inputSampleList2->SetMeasurementVectorSize(sampleSize); ConcatenateFilterType::Pointer filter = ConcatenateFilterType::New(); filter->AddInput(inputSampleList1); filter->AddInput(inputSampleList2); DoubleSampleType sample(sampleSize); unsigned int index = 5; std::ofstream ofs(outfname); ofs<<"Sample size: "<PushBack(sample); } ofs<<"Input samples 2: "<PushBack(sample); } filter->Update(); DoubleSampleListType::ConstIterator outIt = filter->GetOutput()->Begin(); ofs<<"Output samples: "<GetOutput()->End()) { ofs< InputImageType; typedef otb::ContinuousMinimumMaximumImageCalculator FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbContinuousMinimumMaximumImageCalculatorTest.cxx000066400000000000000000000065641301006202600342030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbContinuousMinimumMaximumImageCalculator.h" #include "itkSize.h" int otbContinuousMinimumMaximumImageCalculatorTest(int, char *[]) { typedef short int PixelType; typedef itk::Size<2> SizeType; typedef otb::Image ImageType; typedef otb::ContinuousMinimumMaximumImageCalculator MinMaxCalculatorType; /* Define the image size and physical coordinates */ SizeType size = {{20, 20}}; double origin[2] = { 0.0, 0.0}; double spacing[2] = { 1, 1}; int flag = 0; /* Did this test program work? */ std::cout << "Testing Minimum and Maximum Image Calculator:\n"; // Allocate a simple test image ImageType::Pointer image = ImageType::New(); ImageType::RegionType region; region.SetSize(size); image->SetLargestPossibleRegion(region); image->SetRequestedRegion(region); image->SetBufferedRegion(region); image->Allocate(); // Set origin and spacing of physical coordinates image->SetOrigin(origin); image->SetSpacing(spacing); PixelType minimum = -52; PixelType maximum = 103; // Initialize the image contents with the minimum value itk::Index<2> index; for (int row = 0; row < 20; row++) { index[1] = row; for (int col = 0; col < 20; col++) { index[0] = col; image->SetPixel(index, minimum); } } // Set voxel (10, 10) to maximum value index[0] = 10; index[1] = 10; image->SetPixel(index, maximum); index[0] = 10; index[1] = 11; image->SetPixel(index, 41); // Create and initialize the calculator MinMaxCalculatorType::Pointer calculator = MinMaxCalculatorType::New(); calculator->SetImage(image); calculator->Compute(); // Return minimum of intensity PixelType minimumResult = calculator->GetMinimum(); std::cout << "The Minimum intensity value is : " << minimumResult << std::endl; std::cout << "Its index position is : " << calculator->GetContinuousIndexOfMinimum() << std::endl; if (minimumResult != minimum) { std::cout << "Minimum Value is wrong : " << minimumResult; std::cout << " != " << minimum << std::endl; flag = 1; } // Return maximum of intensity PixelType maximumResult = calculator->GetMaximum(); std::cout << "The Maximum intensity value is : " << maximumResult << std::endl; std::cout << "Its index position is : " << calculator->GetContinuousIndexOfMaximum() << std::endl; if (maximumResult != maximum) { std::cout << "Maximum Value is wrong : " << maximumResult; std::cout << " != " << maximum << std::endl; flag = 2; } // Return results of test if (flag != 0) { std::cout << "*** Some tests failed" << std::endl; return flag; } else { std::cout << "All tests successfully passed" << std::endl; return EXIT_SUCCESS; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbGaussianAdditiveNoiseSampleListFilter.cxx000066400000000000000000000053351301006202600327070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "otbGaussianAdditiveNoiseSampleListFilter.h" #include typedef itk::VariableLengthVector DoubleSampleType; typedef itk::Statistics::ListSample DoubleSampleListType; typedef itk::VariableLengthVector FloatSampleType; typedef itk::Statistics::ListSample FloatSampleListType; typedef otb::Statistics::GaussianAdditiveNoiseSampleListFilter GaussianFilterType; int otbGaussianAdditiveNoiseSampleListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { GaussianFilterType::Pointer filter = GaussianFilterType::New(); return EXIT_SUCCESS; } int otbGaussianAdditiveNoiseSampleListFilter(int argc, char * argv[]) { if (argc < 4) { std::cout << "Usage : test_driver output_filename sample_size samples... " << std::endl; return EXIT_FAILURE; } // Compute the number of samples const char * outfname = argv[1]; unsigned int sampleSize = atoi(argv[2]); if (sampleSize == 0) { std::cerr << "Sample size is null!" << std::endl; return EXIT_FAILURE; } unsigned int nbSamples = (argc-3)/sampleSize; FloatSampleListType::Pointer inputSampleList = FloatSampleListType::New(); inputSampleList->SetMeasurementVectorSize(sampleSize); GaussianFilterType::Pointer filter = GaussianFilterType::New(); filter->SetInput(inputSampleList); // Input Sample FloatSampleType sample(sampleSize); unsigned int index = 3; std::ofstream ofs(outfname); ofs<<"Sample size: "<PushBack(sample); } filter->Update(); DoubleSampleListType::ConstIterator outIt = filter->GetOutput()->Begin(); ofs<<"Output samples: "<GetOutput()->End()) { ofs< HistogramType; HistogramType::Pointer histogram = HistogramType::New(); // initialize histogram HistogramType::SizeType size(1); size.Fill(NbOfBins); HistogramType::MeasurementVectorType lowerBound(1); HistogramType::MeasurementVectorType upperBound(1); lowerBound[0] = 0.0; upperBound[0] = NbOfBins; histogram->SetMeasurementVectorSize(1); histogram->Initialize(size, lowerBound, upperBound); // create histogram with same value for each frequency for (HistogramType::Iterator iter = histogram->Begin(); iter != histogram->End(); ++iter) { iter.SetFrequency(1.0); } typedef otb::HistogramStatisticsFunction HistogramStatisticsFunctionType; HistogramStatisticsFunctionType::Pointer HistogramStatisticsFunction = HistogramStatisticsFunctionType::New(); HistogramStatisticsFunction->SetInputHistogram(histogram.GetPointer()); MeasurementType Entropy; MeasurementType Mean; MeasurementType Covariance; std::cout << "Update OK : " << std::endl; std::cout << "Entropy 1 : " << HistogramStatisticsFunction->GetEntropy()[0] << std::endl; Entropy = HistogramStatisticsFunction->GetEntropy()[0]; std::cout << "Entropy 1 : " << Entropy << std::endl; if (vcl_abs(Entropy - vcl_log(static_cast(NbOfBins))) > 0.00001) { std::cout << "Error in entropy estimation" << std::endl; return EXIT_FAILURE; } Mean = HistogramStatisticsFunction->GetMean()[0]; std::cout << "Mean 1 : " << Mean << std::endl; if (Mean != NbOfBins / 2.) { std::cout << "Error in mean estimation" << std::endl; return EXIT_FAILURE; } Covariance = HistogramStatisticsFunction->GetCovariance()[0]; std::cout << "Covariance 1 : " << Covariance << std::endl; if (Covariance != 0) { std::cout << "Error in covariance estimation" << std::endl; return EXIT_FAILURE; } // create histogram just all value equal to zero except the first one for (HistogramType::Iterator iter = histogram->Begin(); iter != histogram->End(); ++iter) { if (iter == histogram->Begin()) { iter.SetFrequency(1.0); } else { iter.SetFrequency(0.0); } } HistogramStatisticsFunction->Compute(); Entropy = HistogramStatisticsFunction->GetEntropy()[0]; std::cout << "Entropy 2 : " << Entropy << std::endl; if (Entropy != 0.0) { std::cout << "Error in entropy estimation" << std::endl; return EXIT_FAILURE; } Mean = HistogramStatisticsFunction->GetMean()[0]; std::cout << "Mean 2 : " << Mean << std::endl; if (Mean != 0.5) { std::cout << "Error in mean estimation" << std::endl; return EXIT_FAILURE; } Covariance = HistogramStatisticsFunction->GetCovariance()[0]; std::cout << "Covariance 2 : " << Covariance << std::endl; if (Covariance != 0) { std::cout << "Error in covariance estimation" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbImaginaryImageToComplexImageFilterTest.cxx000066400000000000000000000044731301006202600330120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImaginaryImageToComplexImageFilter.h" #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "itkComplexToImaginaryImageFilter.h" #include "otbStreamingCompareImageFilter.h" int otbImaginaryImageToComplexImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; typedef double PixelType; typedef std::complex ComplexPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::Image ComplexImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImaginaryImageToComplexImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); filter->SetInput(reader->GetOutput()); filter->Update(); typedef itk::ComplexToImaginaryImageFilter ImageFilterType; ImageFilterType::Pointer filterImaginaryPart = ImageFilterType::New(); filterImaginaryPart->SetInput(filter->GetOutput()); typedef otb::StreamingCompareImageFilter CompareImageFilterType; CompareImageFilterType::Pointer compareImaginaryImageFilter = CompareImageFilterType::New(); compareImaginaryImageFilter->SetInput1(filterImaginaryPart->GetOutput()); compareImaginaryImageFilter->SetInput2(reader->GetOutput()); compareImaginaryImageFilter->Update(); if(compareImaginaryImageFilter->GetMSE() > 0.0000001) { std::cout << " Invalid ImaginaryPart ! MSE: "<< compareImaginaryImageFilter->GetMSE() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbListSampleGeneratorTest.cxx000066400000000000000000000123531301006202600301030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbListSampleGenerator.h" int otbListSampleGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorImage ImageType; typedef otb::VectorData VectorDataType; typedef otb::ListSampleGenerator ListSampleGeneratorType; ListSampleGeneratorType::Pointer generator = ListSampleGeneratorType::New(); std::cout << generator << std::endl; return EXIT_SUCCESS; } int otbListSampleGenerator(int argc, char* argv[]) { if (argc != 9) { std::cerr << "Usage: " << argv[0] << " inputImage inputVectorData outputTrainingFile outputValidationFile" << " maxTrainingSize maxValidationSize validationTrainingProportion boundByMin" << std::endl; return EXIT_FAILURE; } std::string imageFilename = argv[1]; std::string vectorDataFilename = argv[2]; std::string outputSampleList = argv[3]; std::string outputSampleListValidation = argv[4]; int maxTrainingSize = atoi(argv[5]); int maxValidationSize = atoi(argv[6]); double validationTrainingProportion = atof(argv[7]); bool boundByMin = static_cast(atoi(argv[8])); std::string classKey = "Class"; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFilename); reader->UpdateOutputInformation(); typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; VectorDataReaderType::Pointer vectorReader = VectorDataReaderType::New(); vectorReader->SetFileName(vectorDataFilename); vectorReader->Update(); std::cout << "Number of elements in the tree: " << vectorReader->GetOutput()->Size() << std::endl; typedef otb::ListSampleGenerator ListSampleGeneratorType; ListSampleGeneratorType::Pointer generator = ListSampleGeneratorType::New(); generator->SetMaxTrainingSize(maxTrainingSize); generator->SetMaxValidationSize(maxValidationSize); generator->SetValidationTrainingProportion(validationTrainingProportion); generator->SetBoundByMin(boundByMin); generator->SetInput(reader->GetOutput()); generator->SetInputVectorData(vectorReader->GetOutput()); std::cout << generator << std::endl; generator->Update(); std::cout << generator << std::endl; std::cout << "Number of classes: " << generator->GetNumberOfClasses() << std::endl; { ListSampleGeneratorType::ListSamplePointerType samples = generator->GetTrainingListSample(); ListSampleGeneratorType::ListLabelPointerType labels = generator->GetTrainingListLabel(); typedef ListSampleGeneratorType::ListSampleType::ConstIterator SampleIterator; typedef ListSampleGeneratorType::ListLabelType::ConstIterator LabelIterator; std::ofstream trainingFile; trainingFile.open(outputSampleList.c_str()); SampleIterator sampleIt = samples->Begin(); LabelIterator labelIt = labels->Begin(); while (sampleIt != samples->End()) { trainingFile << labelIt.GetMeasurementVector()[0]; for (unsigned int i = 0; i < sampleIt.GetMeasurementVector().Size(); ++i) { // Careful, the numbering is 1..N in libsvm trainingFile << " " << i + 1 << ":" << sampleIt.GetMeasurementVector()[i]; } trainingFile << "\n"; ++sampleIt; ++labelIt; } trainingFile.close(); } { ListSampleGeneratorType::ListSamplePointerType samples = generator->GetValidationListSample(); ListSampleGeneratorType::ListLabelPointerType labels = generator->GetValidationListLabel(); typedef ListSampleGeneratorType::ListSampleType::ConstIterator SampleIterator; typedef ListSampleGeneratorType::ListLabelType::ConstIterator LabelIterator; std::ofstream validationFile; validationFile.open(outputSampleListValidation.c_str()); SampleIterator sampleIt = samples->Begin(); LabelIterator labelIt = labels->Begin(); while (sampleIt != samples->End()) { validationFile << labelIt.GetMeasurementVector()[0]; for (unsigned int i = 0; i < sampleIt.GetMeasurementVector().Size(); ++i) { // Careful, the numbering is 1..N in libsvm validationFile << " " << i + 1 << ":" << sampleIt.GetMeasurementVector()[i]; } validationFile << "\n"; ++sampleIt; ++labelIt; } validationFile.close(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbListSampleToBalancedListSampleFilter.cxx000066400000000000000000000071501301006202600324540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "otbListSampleToBalancedListSampleFilter.h" #include typedef itk::VariableLengthVector DoubleSampleType; typedef itk::Statistics::ListSample DoubleSampleListType; typedef itk::VariableLengthVector IntegerSampleType; typedef itk::Statistics::ListSample IntegerSampleListType; typedef itk::VariableLengthVector FloatSampleType; typedef itk::Statistics::ListSample FloatSampleListType; typedef otb::Statistics::ListSampleToBalancedListSampleFilter BalancingFilterType; int otbListSampleToBalancedListSampleFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { BalancingFilterType::Pointer filter = BalancingFilterType::New(); return EXIT_SUCCESS; } int otbListSampleToBalancedListSampleFilter(int argc, char * argv[]) { // Compute the number of samples const char * outfname = argv[1]; unsigned int sampleSize = atoi(argv[2]); unsigned int nbSamples = (argc-3)/(sampleSize+1); // +1 cause the // label is added // in the commandline IntegerSampleListType::Pointer labelSampleList = IntegerSampleListType::New(); labelSampleList->SetMeasurementVectorSize(1); FloatSampleListType::Pointer inputSampleList = FloatSampleListType::New(); inputSampleList->SetMeasurementVectorSize(sampleSize); BalancingFilterType::Pointer filter = BalancingFilterType::New(); filter->SetInput(inputSampleList); filter->SetInputLabel(labelSampleList); // Input Sample FloatSampleType sample(sampleSize); IntegerSampleType label(1); unsigned int index = 3; std::ofstream ofs(outfname); ofs<<"Sample size: "<PushBack(sample); labelSampleList->PushBack(label); } filter->Update(); DoubleSampleListType::ConstIterator outIt = filter->GetOutput()->Begin(); ofs<<"Output samples: "<GetOutput()->End()) { ofs<GetOutputLabel()->Begin(); ofs<<"Output Label samples: "<GetOutputLabel()->End()) { ofs<GetOutput()->Size() << std::endl; std::cout <<"Output balanced Labeled SampleList Size : "<< filter->GetOutputLabel()->Size() << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbListSampleToHistogramListGenerator.cxx000066400000000000000000000050051301006202600322540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkListSample.h" #include "otbListSampleToHistogramListGenerator.h" #include "otbImageFileReader.h" #include "itkImageRegionIterator.h" int otbListSampleToHistogramListGenerator(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef VectorImageType::PixelType VectorPixelType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::ListSampleToHistogramListGenerator HistogramGeneratorType; typedef otb::ImageFileReader ReaderType; // Instantiation ReaderType::Pointer reader = ReaderType::New(); HistogramGeneratorType::Pointer generator = HistogramGeneratorType::New(); ListSampleType::Pointer ls = ListSampleType::New(); reader->SetFileName(argv[1]); reader->Update(); // Set the size of the ListSample Measurement Vector ls->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); itk::ImageRegionConstIterator it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { ls->PushBack(it.Get()); } float mscale = atof(argv[4]); unsigned int nbBins = atoi(argv[3]); generator->SetListSample(ls); generator->SetNumberOfBins(nbBins); generator->SetMarginalScale(mscale); generator->Update(); std::ofstream ofs; ofs.open(argv[2]); for (unsigned int comp = 0; comp < reader->GetOutput()->GetNumberOfComponentsPerPixel(); ++comp) { ofs << "Channel: " << comp << " histogram: " << std::endl; for (unsigned int bin = 0; bin < nbBins; ++bin) { ofs << generator->GetOutput()->GetNthElement(comp)->GetFrequency(bin) << "\t"; } ofs << std::endl; } ofs.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbListSampleToHistogramListGeneratorNew.cxx000066400000000000000000000024771301006202600327400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkListSample.h" #include "otbListSampleToHistogramListGenerator.h" int otbListSampleToHistogramListGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef VectorImageType::PixelType VectorPixelType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::ListSampleToHistogramListGenerator HistogramGeneratorType; // Instantiation HistogramGeneratorType::Pointer generator = HistogramGeneratorType::New(); std::cout << generator << std::endl; return EXIT_SUCCESS; } otbListSampleToVariableDimensionHistogramGenerator.cxx000066400000000000000000000052311301006202600346560ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkListSample.h" #include "otbListSampleToVariableDimensionHistogramGenerator.h" #include "otbImageFileReader.h" #include "itkImageRegionIterator.h" int otbListSampleToVariableDimensionHistogramGenerator(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef VectorImageType::PixelType VectorPixelType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::ListSampleToVariableDimensionHistogramGenerator HistogramGeneratorType; typedef otb::ImageFileReader ReaderType; // Instantiation ReaderType::Pointer reader = ReaderType::New(); HistogramGeneratorType::Pointer generator = HistogramGeneratorType::New(); ListSampleType::Pointer ls = ListSampleType::New(); reader->SetFileName(argv[1]); reader->Update(); // Set the size of the ListSample Measurement Vector ls->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); itk::ImageRegionConstIterator it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { ls->PushBack(it.Get()); } HistogramGeneratorType::HistogramSizeType nbBins(reader->GetOutput()->GetNumberOfComponentsPerPixel()); nbBins.Fill(atoi(argv[3])); float mscale = atof(argv[4]); generator->SetListSample(ls); generator->SetNumberOfBins(nbBins); generator->SetMarginalScale(mscale); generator->Update(); std::ofstream ofs; ofs.open(argv[2]); for (unsigned int comp = 0; comp < reader->GetOutput()->GetNumberOfComponentsPerPixel(); ++comp) { ofs << "Channel: " << comp << " histogram: " << std::endl; for (unsigned int bin = 0; bin < static_cast(nbBins[comp]); ++bin) { ofs << generator->GetOutput()->GetFrequency(bin, comp) << "\t"; } ofs << std::endl; } ofs.close(); return EXIT_SUCCESS; } otbListSampleToVariableDimensionHistogramGeneratorNew.cxx000066400000000000000000000025461301006202600353360ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkListSample.h" #include "otbListSampleToVariableDimensionHistogramGenerator.h" int otbListSampleToVariableDimensionHistogramGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef VectorImageType::PixelType VectorPixelType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::ListSampleToVariableDimensionHistogramGenerator HistogramGeneratorType; // Instantiation HistogramGeneratorType::Pointer generator = HistogramGeneratorType::New(); std::cout << generator << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbLocalHistogramImageFunctionNew.cxx000066400000000000000000000020251301006202600313450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbLocalHistogramImageFunction.h" int otbLocalHistogramImageFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::LocalHistogramImageFunction FunctionType; FunctionType::Pointer function = FunctionType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbLocalHistogramImageFunctionTest.cxx000066400000000000000000000042171301006202600315400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbLocalHistogramImageFunction.h" int otbLocalHistogramImageFunctionTest(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::LocalHistogramImageFunction FunctionType; ReaderType::Pointer reader = ReaderType::New(); FunctionType::Pointer function = FunctionType::New(); reader->SetFileName(inputFilename); reader->Update(); function->SetInputImage(reader->GetOutput()); InputImageType::IndexType index; index[0] = atoi(argv[3]); index[1] = atoi(argv[4]); function->SetNeighborhoodRadius(atoi(argv[5])); function->SetHistogramMin(atoi(argv[6])); function->SetHistogramMax(atoi(argv[7])); function->GaussianSmoothingOff(); FunctionType::OutputType Result; Result = function->EvaluateAtIndex(index); std::ofstream outputStream(outputFilename); outputStream << std::setprecision(10) << std::endl; outputStream << "Index: " << index << std::endl; for (unsigned int i = 0; i < function->GetNumberOfHistogramBins(); ++i) { outputStream << "Bin[" << i << "] = " << "[" << Result->GetBinMin(0, i) << ", " << Result->GetBinMax(0, i) << "[ -> " << Result->GetFrequency(i, 0) << std::endl; } outputStream.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbNormalizeVectorImageFilter.cxx000066400000000000000000000060431301006202600305520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbNormalizeVectorImageFilter.h" int otbNormalizeVectorImageFilterNewTest ( int itkNotUsed(argc), char* itkNotUsed(argv) [] ) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; typedef otb::NormalizeVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbNormalizeVectorImageFilterTest ( int argc, char* argv[] ) { typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOutputImage(); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs horizonal sobel on a vector image\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName = parseResult->GetInputImage(); std::string outputImageName = parseResult->GetOutputImage(); // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Image filtering typedef otb::NormalizeVectorImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); typedef otb::ImageFileWriter< ImageType > ImageWriterType; ImageWriterType::Pointer writer = ImageWriterType::New(); writer->SetFileName( outputImageName ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbProjectiveProjection.cxx000066400000000000000000000103231301006202600274610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbDotProductImageFilter.h" #include "otbProjectiveProjectionImageFilter.h" #include "otbMatrixImageFilter.h" #include "otbVectorImageToMatrixImageFilter.h" #include "otbStreamingStatisticsImageFilter.h" #include "otbStreamingStatisticsVectorImageFilter.h" const unsigned int Dimension = 2; typedef double PixelType; typedef double PrecisionType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ProjectiveProjectionImageFilter ProjectiveProjectionImageFilterType; typedef otb::DotProductImageFilter DotProductImageFilterType; typedef otb::MatrixImageFilter MatrixImageFilterType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; typedef otb::ImageFileWriter WriterType; typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef otb::StreamingStatisticsImageFilter StreamingStatisticsImageFilterType; typedef StreamingStatisticsVectorImageFilterType::MatrixType MatrixType; int otbProjectiveProjectionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { ProjectiveProjectionImageFilterType::Pointer filter = ProjectiveProjectionImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbProjectiveProjectionTestHighSNR(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const unsigned int nbEndmembers = atoi(argv[2]); const char * outputImage = argv[3]; ReaderType::Pointer readerImage = ReaderType::New(); readerImage->SetFileName(inputImage); std::cout << "Computing image stats" << std::endl; StreamingStatisticsVectorImageFilterType::Pointer statsInput = \ StreamingStatisticsVectorImageFilterType::New(); statsInput->SetInput(readerImage->GetOutput()); statsInput->Update(); std::cout << "Computing SVD of correlation matrix" << std::endl; // Take the correlation matrix vnl_matrix R = statsInput->GetCorrelation().GetVnlMatrix(); // Apply SVD vnl_svd svd(R); vnl_matrix U = svd.U(); vnl_matrix Ud = U.get_n_columns(0, nbEndmembers).transpose(); std::cout << "Apply dimensionnality reduction" << std::endl; // Xd = Ud.'*M; MatrixImageFilterType::Pointer mulUd = MatrixImageFilterType::New(); mulUd->SetInput(readerImage->GetOutput()); mulUd->SetMatrix(Ud); mulUd->MatrixByVectorOn(); mulUd->UpdateOutputInformation(); VectorImageType::Pointer Xd = mulUd->GetOutput(); // Compute mean(Xd) std::cout << "Compute mean(Xd)" << std::endl; StreamingStatisticsVectorImageFilterType::Pointer statsXd = \ StreamingStatisticsVectorImageFilterType::New(); statsXd->SetInput(Xd); statsXd->Update(); VectorImageType::PixelType Xdmean = statsXd->GetMean(); // Compute Xd ./ repmat( sum( Xd .* repmat(u, [1 N]) ) , [d 1]); // -> divides each pixel component by the dot product std::cout << "Compute projective projection" << std::endl; ProjectiveProjectionImageFilterType::Pointer proj = ProjectiveProjectionImageFilterType::New(); proj->SetInput(Xd); proj->SetProjectionDirection(Xdmean); std::cout << "Write output" << std::endl; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImage); writer->SetInput(proj->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbRealAndImaginaryImageToComplexImageFilterTest.cxx000066400000000000000000000066201301006202600341560ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRealAndImaginaryImageToComplexImageFilter.h" #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkComplexToRealImageFilter.h" #include "itkComplexToImaginaryImageFilter.h" #include "otbStreamingCompareImageFilter.h" int otbRealAndImaginaryImageToComplexImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputFilenameRealPart = argv[1]; const char * inputFilenameImagPart = argv[2]; typedef double PixelType; typedef std::complex ComplexPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::Image ComplexImageType; typedef otb::ImageFileReader ReaderType; typedef otb::RealAndImaginaryImageToComplexImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer readerRealPart = ReaderType::New(); ReaderType::Pointer readerImagPart = ReaderType::New(); readerRealPart->SetFileName(inputFilenameRealPart); readerImagPart->SetFileName(inputFilenameImagPart); readerRealPart->UpdateOutputInformation(); readerImagPart->UpdateOutputInformation(); filter->SetInputRealPart(readerRealPart->GetOutput()); filter->SetInputImaginaryPart(readerImagPart->GetOutput()); filter->Update(); typedef itk::ComplexToRealImageFilter RealImageFilterType; RealImageFilterType::Pointer filterRealPart = RealImageFilterType::New(); filterRealPart->SetInput(filter->GetOutput()); typedef otb::StreamingCompareImageFilter CompareImageFilterType; CompareImageFilterType::Pointer compareRealImageFilter = CompareImageFilterType::New(); compareRealImageFilter->SetInput1(filterRealPart->GetOutput()); compareRealImageFilter->SetInput2(readerRealPart->GetOutput()); compareRealImageFilter->Update(); if(compareRealImageFilter->GetMSE() > 0.0000001) { std::cout << " Invalid RealPart ! MSE: "<< compareRealImageFilter->GetMSE() << std::endl; return EXIT_FAILURE; } typedef itk::ComplexToImaginaryImageFilter ImaginaryImageFilterType; ImaginaryImageFilterType::Pointer filterImagPart = ImaginaryImageFilterType::New(); filterImagPart->SetInput(filter->GetOutput()); CompareImageFilterType::Pointer compareImagImageFilter = CompareImageFilterType::New(); compareImagImageFilter->SetInput1(filterImagPart->GetOutput()); compareImagImageFilter->SetInput2(readerImagPart->GetOutput()); compareImagImageFilter->Update(); if(compareImagImageFilter->GetMSE() > 0.0000001) { std::cout << " Invalid ImagPart ! MSE: "<< compareImagImageFilter->GetMSE() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbRealImageToComplexImageFilterTest.cxx000066400000000000000000000043601301006202600317500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRealImageToComplexImageFilter.h" #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "itkComplexToRealImageFilter.h" #include "otbStreamingCompareImageFilter.h" int otbRealImageToComplexImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; typedef double PixelType; typedef std::complex ComplexPixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::Image ComplexImageType; typedef otb::ImageFileReader ReaderType; typedef otb::RealImageToComplexImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); filter->SetInput(reader->GetOutput()); filter->Update(); typedef itk::ComplexToRealImageFilter ImageFilterType; ImageFilterType::Pointer filterRealPart = ImageFilterType::New(); filterRealPart->SetInput(filter->GetOutput()); typedef otb::StreamingCompareImageFilter CompareImageFilterType; CompareImageFilterType::Pointer compareRealImageFilter = CompareImageFilterType::New(); compareRealImageFilter->SetInput1(filterRealPart->GetOutput()); compareRealImageFilter->SetInput2(reader->GetOutput()); compareRealImageFilter->Update(); if(compareRealImageFilter->GetMSE() > 0.0000001) { std::cout << " Invalid RealPart ! MSE: "<< compareRealImageFilter->GetMSE() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbSamplerTest.cxx000066400000000000000000000124461301006202600255650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPeriodicSampler.h" #include "otbPatternSampler.h" #include "otbRandomSampler.h" #include "itkMersenneTwisterRandomVariateGenerator.h" template std::string RunSampler(SamplerType *sampler, unsigned long total) { std::string output; std::ostringstream oss; sampler->Reset(); for (unsigned long i=0UL ; i < total ; ++i) { if (sampler->TakeSample()) { oss << "X"; } else { oss << "_"; } } output = oss.str(); std::cout << "Sampling result : "<< output << std::endl; return output; } int otbPeriodicSamplerTest(int, char *[]) { otb::PeriodicSampler::Pointer sampler = otb::PeriodicSampler::New(); otb::PeriodicSampler::ParameterType param; param.Offset = 2; param.MaxJitter = 0; sampler->SetNumberOfElements(5,23); sampler->SetParameters(param); std::string test1 = RunSampler(sampler,23); if ( sampler->GetChosenElements() != sampler->GetNeededElements() ) { std::cout << "1 - Wrong nb of needed elements :" << std::endl; std::cout << " expected : " << sampler->GetNeededElements() << std::endl; std::cout << " got : " << sampler->GetChosenElements() << std::endl; return EXIT_FAILURE; } std::string baseline1("__X___X____X___X____X__"); if (test1 != baseline1) { std::cout << "1 - Wrong sampling sequence :" << std::endl; std::cout << " expected : " << baseline1 << std::endl; std::cout << " got : " << test1 << std::endl; return EXIT_FAILURE; } param.Offset = 0; param.MaxJitter = 10; sampler->SetRate(0.2,50); sampler->SetParameters(param); std::string test2 = RunSampler(sampler,50); if ( sampler->GetChosenElements() != sampler->GetNeededElements() ) { std::cout << "2 - Wrong nb of needed elements :" << std::endl; std::cout << " expected : " << sampler->GetNeededElements() << std::endl; std::cout << " got : " << sampler->GetChosenElements() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbPatternSamplerTest(int, char *[]) { otb::PatternSampler::Pointer sampler = otb::PatternSampler::New(); otb::PatternSampler::ParameterType param; param.Seed = 121212; param.MaxPatternSize = 100; sampler->SetNumberOfElements(5,23); sampler->SetParameters(param); std::string test1 = RunSampler(sampler,23); if ( sampler->GetChosenElements() != sampler->GetNeededElements() ) { std::cout << "1 - Wrong nb of needed elements :" << std::endl; std::cout << " expected : " << sampler->GetNeededElements() << std::endl; std::cout << " got : " << sampler->GetChosenElements() << std::endl; return EXIT_FAILURE; } param.Seed = 0; param.Pattern1.clear(); param.Pattern1.push_back(false); param.Pattern1.push_back(true); param.Pattern1.push_back(false); param.Pattern1.push_back(false); param.Pattern1.push_back(true); param.Pattern1.push_back(true); param.Pattern1.push_back(false); param.Pattern2.clear(); // here, the pattern is imposed so the sampling rate will be ignored sampler->SetRate(0.34,23); sampler->SetParameters(param); std::string test2 = RunSampler(sampler,23); std::string baseline2("_X__XX__X__XX__X__X____"); if (test2 != baseline2) { std::cout << "2 - Wrong sampling sequence :" << std::endl; std::cout << " expected : " << baseline2 << std::endl; std::cout << " got : " << test2 << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbRandomSamplerTest(int, char *[]) { itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->SetSeed(121212); otb::RandomSampler::Pointer sampler = otb::RandomSampler::New(); otb::RandomSampler::ParameterType param; param.MaxBufferSize = 100000000; sampler->SetNumberOfElements(5,23); sampler->SetParameters(param); std::string test1 = RunSampler(sampler,23); if ( sampler->GetChosenElements() != sampler->GetNeededElements() ) { std::cout << "1 - Wrong nb of needed elements :" << std::endl; std::cout << " expected : " << sampler->GetNeededElements() << std::endl; std::cout << " got : " << sampler->GetChosenElements() << std::endl; return EXIT_FAILURE; } param.MaxBufferSize = 5; sampler->SetRate(0.1,23); sampler->SetParameters(param); std::string test2 = RunSampler(sampler,23); if ( sampler->GetChosenElements() != sampler->GetNeededElements() ) { std::cout << "2 - Wrong nb of needed elements :" << std::endl; std::cout << " expected : " << sampler->GetNeededElements() << std::endl; std::cout << " got : " << sampler->GetChosenElements() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbShiftScaleSampleListFilter.cxx000066400000000000000000000053641301006202600305140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "itkVariableLengthVector.h" #include "otbShiftScaleSampleListFilter.h" #include typedef itk::VariableLengthVector DoubleSampleType; typedef itk::Statistics::ListSample DoubleSampleListType; typedef itk::VariableLengthVector FloatSampleType; typedef itk::Statistics::ListSample FloatSampleListType; typedef otb::Statistics::ShiftScaleSampleListFilter ShiftScaleFilterType; int otbShiftScaleSampleListFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { ShiftScaleFilterType::Pointer instance = ShiftScaleFilterType::New(); return EXIT_SUCCESS; } int otbShiftScaleSampleListFilter(int argc, char * argv[]) { // Compute the number of samples const char * outfname = argv[1]; unsigned int sampleSize = atoi(argv[2]); unsigned int nbSamples = (argc-2*sampleSize-2)/sampleSize; FloatSampleListType::Pointer inputSampleList = FloatSampleListType::New(); inputSampleList->SetMeasurementVectorSize(sampleSize); ShiftScaleFilterType::Pointer filter = ShiftScaleFilterType::New(); filter->SetInput(inputSampleList); FloatSampleType sample(sampleSize); unsigned int index = 3; std::ofstream ofs(outfname); ofs<<"Sample size: "<SetShifts(sample); for(unsigned int i = 0; iSetScales(sample); ofs<<"Input samples: "<PushBack(sample); } filter->Update(); DoubleSampleListType::ConstIterator outIt = filter->GetOutput()->Begin(); ofs<<"Output samples: "<GetOutput()->End()) { ofs< InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::Image ImageType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VI2ILFilterType; //Statistics estimator typedef otb::StreamingStatisticsImageFilter StreamingStatisticsImageFilterType; typedef otb::ShiftScaleVectorImageFilter ShiftScaleVImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::VariableLengthVector MeasurementType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); // Instantiating object ShiftScaleVImageFilterType::Pointer filter = ShiftScaleVImageFilterType::New(); filter->SetInput(reader->GetOutput()); // Build a Measurement Vector of mean MeasurementType mean; // Build a MeasurementVector of variance MeasurementType variance; int nbBands = reader->GetOutput()->GetNumberOfComponentsPerPixel(); ImageType::SizeType size; size = reader->GetOutput()->GetLargestPossibleRegion().GetSize(); //set the measurement vectors size mean.SetSize(nbBands); mean.Fill(0.); variance.SetSize(nbBands); variance.Fill(0.); //Splitting image into channels VI2ILFilterType::Pointer vi2ilFilter = VI2ILFilterType::New(); vi2ilFilter->SetInput(reader->GetOutput()); vi2ilFilter->GenerateOutputInformation(); ImageListType::Iterator ilIt = vi2ilFilter->GetOutput()->Begin(); unsigned int i = 0; //Iterate over each bands on the input vector image while (ilIt != vi2ilFilter->GetOutput()->End()) { StreamingStatisticsImageFilterType::Pointer statsEstimator = StreamingStatisticsImageFilterType::New(); statsEstimator->SetInput(ilIt.Get()); statsEstimator->Update(); //Compute mean over band number i mean[i] = statsEstimator->GetMean(); //Compute variance over band i variance[i] = statsEstimator->GetVariance(); ++ilIt; ++i; } std::cout<< "mean: " << mean << std::endl; std::cout<< "variance: " << variance << std::endl; filter->SetScale(variance); filter->SetShift(mean); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStatisticsTestDriver.cxx000066400000000000000000000052031301006202600274610ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbListSampleToHistogramListGeneratorNew); REGISTER_TEST(otbStreamingMinMaxImageFilter); REGISTER_TEST(otbStreamingMinMaxVectorImageFilterNew); REGISTER_TEST(otbVarianceImageFilterNew); REGISTER_TEST(otbStreamingStatisticsImageFilterNew); REGISTER_TEST(otbListSampleToVariableDimensionHistogramGeneratorNew); REGISTER_TEST(otbStreamingHistogramVectorImageFilterNew); REGISTER_TEST(otbStreamingHistogramVectorImageFilterTest); REGISTER_TEST(otbStreamingStatisticsVectorImageFilterNew); REGISTER_TEST(otbRealImageToComplexImageFilterTest); REGISTER_TEST(otbHistogramStatisticsFunction); REGISTER_TEST(otbGaussianAdditiveNoiseSampleListFilterNew); REGISTER_TEST(otbGaussianAdditiveNoiseSampleListFilter); REGISTER_TEST(otbNormalizeVectorImageFilterNewTest); REGISTER_TEST(otbNormalizeVectorImageFilterTest); REGISTER_TEST(otbVectorImageToMatrixNewTest); REGISTER_TEST(otbVectorImageToMatrixTest); REGISTER_TEST(otbListSampleToVariableDimensionHistogramGenerator); REGISTER_TEST(otbStreamingMinMaxImageFilterNew); REGISTER_TEST(otbShiftScaleSampleListFilterNew); REGISTER_TEST(otbShiftScaleSampleListFilter); REGISTER_TEST(otbVectorImageToIntensityImageFilter); REGISTER_TEST(otbVarianceImageFilter); REGISTER_TEST(otbConcatenateSampleListFilterNew); REGISTER_TEST(otbConcatenateSampleListFilter); REGISTER_TEST(otbLocalHistogramImageFunctionTest); REGISTER_TEST(otbVectorImageToIntensityImageFilterNew); REGISTER_TEST(otbProjectiveProjectionNew); REGISTER_TEST(otbProjectiveProjectionTestHighSNR); REGISTER_TEST(otbShiftScaleVectorImageFilterTest); REGISTER_TEST(otbContinuousMinimumMaximumImageCalculatorNew); REGISTER_TEST(otbStreamingCompareImageFilterNew); REGISTER_TEST(otbStreamingCompareImageFilter); REGISTER_TEST(otbStreamingStatisticsMapFromLabelImageFilterTest); REGISTER_TEST(otbLocalHistogramImageFunctionNew); REGISTER_TEST(otbRealAndImaginaryImageToComplexImageFilterTest); REGISTER_TEST(otbStreamingStatisticsImageFilter); REGISTER_TEST(otbListSampleToBalancedListSampleFilterNew); REGISTER_TEST(otbListSampleToBalancedListSampleFilter); REGISTER_TEST(otbStreamingStatisticsVectorImageFilter); REGISTER_TEST(otbStreamingMinMaxVectorImageFilter); REGISTER_TEST(otbListSampleGeneratorNew); REGISTER_TEST(otbListSampleGenerator); REGISTER_TEST(otbImaginaryImageToComplexImageFilterTest); REGISTER_TEST(otbListSampleToHistogramListGenerator); REGISTER_TEST(otbContinuousMinimumMaximumImageCalculatorTest); REGISTER_TEST(otbPeriodicSamplerTest); REGISTER_TEST(otbPatternSamplerTest); REGISTER_TEST(otbRandomSamplerTest); } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingCompareImageFilter.cxx000066400000000000000000000050111301006202600306610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkShiftScaleImageFilter.h" #include "otbStreamingCompareImageFilter.h" #include "otbImageFileReader.h" #include "otbImage.h" #include #include "otbStreamingTraits.h" int otbStreamingCompareImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::StreamingCompareImageFilter StreamingCompareImageFilterType; // Instantiating object StreamingCompareImageFilterType::Pointer filter = StreamingCompareImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbStreamingCompareImageFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingCompareImageFilter StreamingCompareImageFilterType; typedef itk::ShiftScaleImageFilter ShiftFilterType; // Instantiating object StreamingCompareImageFilterType::Pointer filter = StreamingCompareImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); ShiftFilterType::Pointer shiftFilter = ShiftFilterType::New(); shiftFilter->SetInput (reader->GetOutput()); shiftFilter->SetScale(1); shiftFilter->SetShift(10); filter->SetInput1(reader->GetOutput()); filter->SetInput2(shiftFilter->GetOutput()); filter->Update(); std::ofstream file; file.open(outfname); file << "MSE: " << filter->GetMSE() << std::endl; file << "MAE: " << filter->GetMAE() << std::endl; file << "PSNR: " << filter->GetPSNR() << std::endl; file << "Count: " << filter->GetDiffCount() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingHistogramVectorImageFilter.cxx000066400000000000000000000106021301006202600324150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStreamingHistogramVectorImageFilter.h" #include "otbVectorImage.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbObjectList.h" #include "itkHistogram.h" typedef otb::VectorImage VectorImageType; typedef otb::StreamingHistogramVectorImageFilter SHVIFType; typedef itk::NumericTraits< VectorImageType::InternalPixelType >::RealType RealType; typedef RealType MeasurementType; typedef itk::Statistics::Histogram< MeasurementType > Histogram; typedef otb::ObjectList< Histogram > HistogramList; int otbStreamingHistogramVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { SHVIFType::Pointer SHVIFFilter = SHVIFType::New(); std::cout << SHVIFFilter << std::endl; return EXIT_SUCCESS; } int otbStreamingHistogramVectorImageFilterTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Allocate input image const unsigned int nbComp = 2; VectorImageType::SizeType size; size.Fill(4); VectorImageType::IndexType idx; idx.Fill(0); VectorImageType::RegionType region; region.SetSize(size); region.SetIndex(idx); VectorImageType::Pointer image = VectorImageType::New(); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(nbComp); image->Allocate(); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it(image, region); it.GoToBegin(); VectorImageType::PixelType pixel(nbComp); VectorImageType::IndexType index; while( !it.IsAtEnd() ) { index = it.GetIndex(); pixel[0]=index[0]; pixel[1]=index[1]; it.Set(pixel); ++it; } //Histogram computation SHVIFType::Pointer SHVIFFilter = SHVIFType::New(); SHVIFFilter->GetFilter()->SetInput(image); SHVIFType::FilterType::CountVectorType bins( nbComp ); bins[0]=2; bins[1]=2; SHVIFFilter->GetFilter()->SetNumberOfBins( bins ); VectorImageType::PixelType pixelMin(nbComp); pixelMin[0]=0; pixelMin[1]=0; VectorImageType::PixelType pixelMax(nbComp); pixelMax[0]=3; pixelMax[1]=3; SHVIFFilter->GetFilter()->SetHistogramMin( pixelMin ); SHVIFFilter->GetFilter()->SetHistogramMax( pixelMax ); SHVIFFilter->Update(); HistogramList::Pointer histograms = SHVIFFilter->GetHistogramList(); std::cout << "Histogram list size " << histograms->Size() << std::endl; unsigned int channel = 0; // first channel Histogram::Pointer histogram( histograms->GetNthElement( channel ) ); unsigned int histogramSize = histogram->Size(); std::cout << "Histogram size " << histogramSize << std::endl; std::cout << "Histogram of the first component" << std::endl; // We expect to have 2 bins, each with a frequency of 8. const unsigned int expectedFrequency = 8; for( unsigned int bin=0; bin < histogramSize; bin++ ) { if( histogram->GetFrequency( bin, channel ) != expectedFrequency ) { std::cerr << "Error in bin= " << bin << " channel = " << channel << std::endl; std::cerr << "Frequency was= " << histogram->GetFrequency( bin, channel ) << " Instead of the expected " << expectedFrequency << std::endl; return EXIT_FAILURE; } } channel = 1; histogram = histograms->GetNthElement( channel ) ; histogramSize = histogram->Size(); std::cout << "Histogram size " << histogramSize << std::endl; std::cout << "Histogram of the second component" << std::endl; for( unsigned int bin=0; bin < histogramSize; bin++ ) { if( histogram->GetFrequency( bin, 0 ) != expectedFrequency ) { std::cerr << "Error in bin= " << bin << " channel = " << channel << std::endl; std::cerr << "Frequency was= " << histogram->GetFrequency( bin, 0 ) << " Instead of the expected " << expectedFrequency << std::endl; return EXIT_FAILURE; } } //FIXME: whe should test also here the support of no data value return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingMinMaxImageFilter.cxx000066400000000000000000000034161301006202600304730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbStreamingMinMaxImageFilter.h" #include "otbImageFileReader.h" #include #include "otbStreamingTraits.h" #include "otbStandardFilterWatcher.h" int otbStreamingMinMaxImageFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingMinMaxImageFilter StreamingMinMaxImageFilterType; // Instantiating object StreamingMinMaxImageFilterType::Pointer filter = StreamingMinMaxImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); filter->GetStreamer()->SetNumberOfLinesStrippedStreaming( 10 ); filter->SetInput(reader->GetOutput()); otb::StandardFilterWatcher watcher(filter, "Min Max Computation"); filter->Update(); std::ofstream file; file.open(outfname); file << "Minimum: " << filter->GetMinimum() << std::endl; file << "Maximum: " << filter->GetMaximum() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingMinMaxImageFilterNew.cxx000066400000000000000000000021641301006202600311440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingMinMaxImageFilter.h" #include "otbImage.h" int otbStreamingMinMaxImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::StreamingMinMaxImageFilter StreamingMinMaxImageFilterType; // Instantiating object StreamingMinMaxImageFilterType::Pointer filter = StreamingMinMaxImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingMinMaxVectorImageFilter.cxx000066400000000000000000000034441301006202600316570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingMinMaxVectorImageFilter.h" #include "otbImageFileReader.h" #include #include "otbStreamingTraits.h" #include "otbStandardFilterWatcher.h" int otbStreamingMinMaxVectorImageFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingMinMaxVectorImageFilter StreamingMinMaxVectorImageFilterType; // Instantiating object StreamingMinMaxVectorImageFilterType::Pointer filter = StreamingMinMaxVectorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); filter->GetStreamer()->SetNumberOfLinesStrippedStreaming( 10 ); filter->SetInput(reader->GetOutput()); otb::StandardFilterWatcher watcher(filter, "Min Max Computation"); filter->Update(); std::ofstream file; file.open(outfname); file << "Minimum: " << filter->GetMinimum() << std::endl; file << "Maximum: " << filter->GetMaximum() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingMinMaxVectorImageFilterNew.cxx000066400000000000000000000022441301006202600323260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingMinMaxVectorImageFilter.h" #include "otbVectorImage.h" int otbStreamingMinMaxVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::VectorImage ImageType; typedef otb::StreamingMinMaxVectorImageFilter StreamingMinMaxVectorImageFilterType; // Instantiating object StreamingMinMaxVectorImageFilterType::Pointer filter = StreamingMinMaxVectorImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingStatisticsImageFilter.cxx000066400000000000000000000044121301006202600314310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingStatisticsImageFilter.h" #include "itkStatisticsImageFilter.h" #include "otbImageFileReader.h" #include "otbImage.h" #include #include "otbStreamingTraits.h" int otbStreamingStatisticsImageFilter(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; float userIgnoredValue = 0.; if (argc>3) { userIgnoredValue = atof(argv[3]); } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingStatisticsImageFilter StreamingStatisticsImageFilterType; //typedef itk::StatisticsImageFilter StreamingStatisticsImageFilterType; // Instantiating object StreamingStatisticsImageFilterType::Pointer filter = StreamingStatisticsImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); filter->GetStreamer()->SetNumberOfLinesStrippedStreaming( 10 ); filter->SetInput(reader->GetOutput()); if (argc>3) { filter->SetIgnoreUserDefinedValue(true); filter->SetUserIgnoredValue(userIgnoredValue); } filter->Update(); std::ofstream file; file.open(outfname); file << "Minimum: " << filter->GetMinimum() << std::endl; file << "Maximum: " << filter->GetMaximum() << std::endl; file << std::fixed; file.precision(5); file << "Sum: " << filter->GetSum() << std::endl; file << "Mean: " << filter->GetMean() << std::endl; file << "Sigma: " << filter->GetSigma() << std::endl; file << "Variance: " << filter->GetVariance() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingStatisticsImageFilterNew.cxx000066400000000000000000000022141301006202600321010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingStatisticsImageFilter.h" #include "otbImage.h" int otbStreamingStatisticsImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::StreamingStatisticsImageFilter StreamingStatisticsImageFilterType; // Instantiating object StreamingStatisticsImageFilterType::Pointer filter = StreamingStatisticsImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbStreamingStatisticsMapFromLabelImageFilterTest.cxx000066400000000000000000000237121301006202600344400ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Statistics/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImage.h" #include #include "otbImageFileWriter.h" #include "otbStreamingStatisticsMapFromLabelImageFilter.h" template int generic_StreamingStatisticsMapFromLabelImageFilterTest(int itkNotUsed(argc), char * argv[]) { typedef unsigned int LabelPixelType; const unsigned int Dimension = 2; const unsigned int nbComponents = 3; typedef typename otb::VectorImage VectorImageType; typedef typename VectorImageType::PixelType VectorPixelType; typedef typename VectorImageType::Pointer VectorPointerType; typedef typename otb::Image LabelImageType; typedef typename LabelImageType::Pointer LabelImagePointerType; typedef typename itk::ImageRegionIteratorWithIndex VIteratorType; typedef typename itk::ImageRegionIteratorWithIndex IteratorType; typedef typename otb::StreamingStatisticsMapFromLabelImageFilter StreamingStatisticsMapFromLabelImageFilterType; typedef typename StreamingStatisticsMapFromLabelImageFilterType::Pointer StreamingStatisticsMapFromLabelImageFilterPointerType; typedef typename StreamingStatisticsMapFromLabelImageFilterType::MeanValueMapType MeanValueMapType; typedef typename StreamingStatisticsMapFromLabelImageFilterType::LabelPopulationMapType LabelPopulationMapType; VectorPointerType supportImage = VectorImageType::New(); LabelImagePointerType labelImage = LabelImageType::New(); typedef otb::ImageFileWriter WriterType; typedef typename WriterType::Pointer WriterPointerType; typedef otb::ImageFileWriter LWriterType; typedef typename LWriterType::Pointer LWriterPointerType; VectorPixelType redColor(nbComponents), greenColor(nbComponents), blueColor(nbComponents); redColor[0] = 255, redColor[1] = 0, redColor[2] = 0; greenColor[0] = 0, greenColor[1] = 255, greenColor[2] = 0; blueColor[0] = 0, blueColor[1] = 0, blueColor[2] = 255; LabelPixelType redLabel = 10, greenLabel = 20, blueLabel = 30; typename VectorImageType::SizeType size; typename VectorImageType::IndexType start; typename VectorImageType::RegionType region; size[0] = atoi(argv[2]); // size along X size[1] = atoi(argv[3]); // size along Y start[0] = 0; // first index on X start[1] = 0; // first index on Y region.SetIndex(start); region.SetSize(size); supportImage->SetNumberOfComponentsPerPixel(nbComponents); supportImage->SetRegions(region); supportImage->Allocate(); supportImage->FillBuffer(blueColor); labelImage->SetRegions(region); labelImage->Allocate(); labelImage->FillBuffer(blueLabel); typename VectorImageType::SizeType sizeSelectRed, sizeSelectGreen; typename VectorImageType::IndexType startSelectRed, startSelectGreen; typename VectorImageType::RegionType regionSelectRed, regionSelectGreen; sizeSelectRed[0] = size[0] / 4.0; // size along X sizeSelectRed[1] = size[1] / 4.0; // size along Y sizeSelectGreen[0] = size[0] / 2.0; ; // size along X sizeSelectGreen[1] = size[1] / 2.0; ; // size along Y startSelectRed[0] = (size[0] - sizeSelectRed[0] - sizeSelectGreen[0]) / 3.0; // first index on X startSelectRed[1] = (size[1] - sizeSelectRed[1] - sizeSelectGreen[1]) / 3.0; // first index on Y startSelectGreen[0] = size[0] - startSelectRed[0] - sizeSelectGreen[0]; // first index on X startSelectGreen[1] = size[1] - startSelectRed[1] - sizeSelectGreen[1]; // first index on X regionSelectRed.SetIndex(startSelectRed); regionSelectRed.SetSize(sizeSelectRed); regionSelectGreen.SetIndex(startSelectGreen); regionSelectGreen.SetSize(sizeSelectGreen); std::cout << "size = " << size << std::endl; std::cout << "sizeSelectRed = " << sizeSelectRed << std::endl; std::cout << "sizeSelectGreen = " << sizeSelectGreen << std::endl; std::cout << "startSelectRed = " << startSelectRed << std::endl; std::cout << "startSelectGreen = " << startSelectGreen << std::endl << std::endl; VIteratorType supportImageRedIterator(supportImage, regionSelectRed); IteratorType labelImageRedIterator(labelImage, regionSelectRed); labelImageRedIterator.GoToBegin(); for(supportImageRedIterator.GoToBegin(); !supportImageRedIterator.IsAtEnd(); ++supportImageRedIterator) { supportImageRedIterator.Set(redColor); labelImageRedIterator.Set(redLabel); ++labelImageRedIterator; } VIteratorType supportImageGreenIterator(supportImage, regionSelectGreen); IteratorType labelImageGreenIterator(labelImage, regionSelectGreen); labelImageGreenIterator.GoToBegin(); for(supportImageGreenIterator.GoToBegin(); !supportImageGreenIterator.IsAtEnd(); ++supportImageGreenIterator) { supportImageGreenIterator.Set(greenColor); labelImageGreenIterator.Set(greenLabel); ++labelImageGreenIterator; } //Optional writing of the generated images if (atoi(argv[4]) != 0) { WriterPointerType writer = WriterType::New(); writer->SetFileName(argv[5]); writer->SetInput(supportImage); writer->Update(); LWriterPointerType lwriter = LWriterType::New(); lwriter->SetFileName(argv[6]); lwriter->SetInput(labelImage); lwriter->Update(); } unsigned int nbPixels = size[0] * size[1]; unsigned int nbRedPixBL = sizeSelectRed[0] * sizeSelectRed[1]; unsigned int nbGreenPixBL = sizeSelectGreen[0] * sizeSelectGreen[1]; unsigned int nbBluePixBL = nbPixels - nbRedPixBL - nbGreenPixBL; std::cout << "nbPixels = " << nbPixels << std::endl; std::cout << "nbRedPixBL = " << nbRedPixBL << std::endl; std::cout << "nbGreenPixBL = " << nbGreenPixBL << std::endl; std::cout << "nbBluePixBL = " << nbBluePixBL << std::endl << std::endl; StreamingStatisticsMapFromLabelImageFilterPointerType m_StatisticsMapFromLabelImageFilter; m_StatisticsMapFromLabelImageFilter = StreamingStatisticsMapFromLabelImageFilterType::New(); m_StatisticsMapFromLabelImageFilter->SetInput(supportImage); m_StatisticsMapFromLabelImageFilter->SetInputLabelImage(labelImage); m_StatisticsMapFromLabelImageFilter->Update(); LabelPopulationMapType labelPopulationMapBL; labelPopulationMapBL[redLabel] = nbRedPixBL; labelPopulationMapBL[greenLabel] = nbGreenPixBL; labelPopulationMapBL[blueLabel] = nbBluePixBL; LabelPopulationMapType labelPopulationMap = m_StatisticsMapFromLabelImageFilter->GetLabelPopulationMap(); MeanValueMapType labelToMeanIntensityMapBL; labelToMeanIntensityMapBL[redLabel] = redColor; labelToMeanIntensityMapBL[greenLabel] = greenColor; labelToMeanIntensityMapBL[blueLabel] = blueColor; MeanValueMapType labelToMeanIntensityMap = m_StatisticsMapFromLabelImageFilter->GetMeanValueMap(); if ( (labelPopulationMap != labelPopulationMapBL) || (labelToMeanIntensityMap != labelToMeanIntensityMapBL) ) { if (labelPopulationMap != labelPopulationMapBL) { typename LabelPopulationMapType::iterator itlabelPopulationMap; std::cout << std::endl; std::cout << "ERROR with m_StatisticsMapFromLabelImageFilter->GetLabelPopulationMap()" << std::endl; for (itlabelPopulationMap = labelPopulationMap.begin(); itlabelPopulationMap != labelPopulationMap.end(); ++itlabelPopulationMap) { std::cout << " labelPopulationMap[" << itlabelPopulationMap->first << "] = " << labelPopulationMap[itlabelPopulationMap->first] << std::endl; std::cout << " labelPopulationMapBL[" << itlabelPopulationMap->first << "] = " << labelPopulationMapBL[itlabelPopulationMap->first] << std::endl << std::endl; } } if (labelToMeanIntensityMap != labelToMeanIntensityMapBL) { typename MeanValueMapType::iterator itMeanValueMap; std::cout << std::endl; std::cout << "ERROR with m_StatisticsMapFromLabelImageFilter->GetMeanValueMap()" << std::endl; for (itMeanValueMap = labelToMeanIntensityMap.begin(); itMeanValueMap != labelToMeanIntensityMap.end(); ++itMeanValueMap) { std::cout << " labelToMeanIntensityMap[" << itMeanValueMap->first << "] = " << labelToMeanIntensityMap[itMeanValueMap->first] << std::endl; std::cout << " labelToMeanIntensityMapBL[" << itMeanValueMap->first << "] = " << labelToMeanIntensityMapBL[itMeanValueMap->first] << std::endl << std::endl; } } return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbStreamingStatisticsMapFromLabelImageFilterTest(int argc, char * argv[]) { if (strcmp(argv[1], "UINT8") == 0) { return generic_StreamingStatisticsMapFromLabelImageFilterTest (argc, argv); } if (strcmp(argv[1], "UINT16") == 0) { return generic_StreamingStatisticsMapFromLabelImageFilterTest (argc, argv); } if (strcmp(argv[1], "INT16") == 0) { return generic_StreamingStatisticsMapFromLabelImageFilterTest (argc, argv); } if (strcmp(argv[1], "UINT32") == 0) { return generic_StreamingStatisticsMapFromLabelImageFilterTest (argc, argv); } if (strcmp(argv[1], "INT32") == 0) { return generic_StreamingStatisticsMapFromLabelImageFilterTest (argc, argv); } if (strcmp(argv[1], "FLOAT") == 0) { return generic_StreamingStatisticsMapFromLabelImageFilterTest (argc, argv); } if (strcmp(argv[1], "DOUBLE") == 0) { return generic_StreamingStatisticsMapFromLabelImageFilterTest (argc, argv); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingStatisticsVectorImageFilter.cxx000066400000000000000000000047121301006202600326170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingStatisticsVectorImageFilter.h" #include "otbImageFileReader.h" #include "otbVectorImage.h" #include #include "otbStreamingTraits.h" int otbStreamingStatisticsVectorImageFilter(int argc, char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; float userIgnoredValue = 0.; if (argc>3) { userIgnoredValue = atof(argv[3]); } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; // Instantiating object StreamingStatisticsVectorImageFilterType::Pointer filter = StreamingStatisticsVectorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); filter->GetStreamer()->SetNumberOfLinesStrippedStreaming( 10 ); filter->SetInput(reader->GetOutput()); if (argc>3) { filter->SetIgnoreUserDefinedValue(true); filter->SetUserIgnoredValue(userIgnoredValue); } filter->Update(); std::ofstream file; file.open(outfname); file << "Minimum: " << filter->GetMinimum() << std::endl; file << "Maximum: " << filter->GetMaximum() << std::endl; file << std::fixed; file.precision(5); file << "Sum: " << filter->GetSum() << std::endl; file << "Mean: " << filter->GetMean() << std::endl; file << "Correlation: " << filter->GetCorrelation() << std::endl; file << "Covariance: " << filter->GetCovariance() << std::endl; file << "Component Mean: " << filter->GetComponentMean() << std::endl; file << "Component Correlation: " << filter->GetComponentCorrelation() << std::endl; file << "Component Covariance: " << filter->GetComponentCovariance() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbStreamingStatisticsVectorImageFilterNew.cxx000066400000000000000000000022741301006202600332720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbStreamingStatisticsVectorImageFilter.h" #include "otbVectorImage.h" int otbStreamingStatisticsVectorImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::VectorImage ImageType; typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; // Instantiating object StreamingStatisticsVectorImageFilterType::Pointer filter = StreamingStatisticsVectorImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbVarianceImageFilter.cxx000066400000000000000000000026721301006202600271630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVarianceImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbVarianceImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VarianceImageFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbVarianceImageFilterNew.cxx000066400000000000000000000020311301006202600276220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVarianceImageFilter.h" #include "otbImage.h" int otbVarianceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::VarianceImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbVectorImageToIntensityImageFilter.cxx000066400000000000000000000034641301006202600320520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToIntensityImageFilter.h" int otbVectorImageToIntensityImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorImageToIntensityImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); InputImageType::PixelType refPixel; filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbVectorImageToIntensityImageFilterNew.cxx000066400000000000000000000024701301006202600325200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbVectorImageToIntensityImageFilter.h" int otbVectorImageToIntensityImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::VectorImageToIntensityImageFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Statistics/test/otbVectorImageToMatrixImageFilter.cxx000066400000000000000000000050351301006202600313240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImageToMatrixImageFilter.h" #include "otbVectorImage.h" #include "itkImageRegionIteratorWithIndex.h" const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; typedef VectorImageToMatrixImageFilterType::MatrixType MatrixType; int otbVectorImageToMatrixNewTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { VectorImageToMatrixImageFilterType::Pointer vim2matrix = VectorImageToMatrixImageFilterType::New(); std::cout << vim2matrix << std::endl; return EXIT_SUCCESS; } int otbVectorImageToMatrixTest(int itkNotUsed(argc), char * itkNotUsed(argv) []) { ImageType::Pointer image = ImageType::New(); const unsigned int Size = 10; const unsigned int NbComponent = 4; ImageType::RegionType region; region.SetIndex(0, 0); region.SetIndex(1, 0); region.SetSize(0, Size); region.SetSize(1, Size); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(NbComponent); image->Allocate(); itk::ImageRegionIteratorWithIndex it(image, image->GetLargestPossibleRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { ImageType::IndexType idx = it.GetIndex(); ImageType::PixelType value; value.SetSize(NbComponent); for (unsigned int k = 0; k < NbComponent; ++k) { value[k] = idx[0] + idx[1] * Size + k; } it.Set(value); } VectorImageToMatrixImageFilterType::Pointer vim2matrix = \ VectorImageToMatrixImageFilterType::New(); vim2matrix->SetInput(image); vim2matrix->Update(); MatrixType m = vim2matrix->GetMatrix(); std::cout << m << std::endl; for (unsigned int j = 0; j < m.cols(); ++j) { unsigned int x = j % Size; unsigned int y = j / Size; for (unsigned int i = 0; i < m.rows(); ++i) { if ( m(i, j) != x + y * Size + i ) { return EXIT_FAILURE; } } } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/TimeSeries/000077500000000000000000000000001301006202600210225ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/TimeSeries/CMakeLists.txt000066400000000000000000000000521301006202600235570ustar00rootroot00000000000000project(OTBTimeSeries) otb_module_impl() OTB-release-5.8/Modules/Filtering/TimeSeries/include/000077500000000000000000000000001301006202600224455ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/TimeSeries/include/otbEnvelopeSavitzkyGolayInterpolationFunctor.h000066400000000000000000000062571301006202600337640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEnvelopeSavitzkyGolayInterpolationFunctor_h #define otbEnvelopeSavitzkyGolayInterpolationFunctor_h #include "otbSavitzkyGolayInterpolationFunctor.h" namespace otb { namespace Functor { /** \class otbEnvelopeSavitzkyGolayInterpolationFunctor * * \brief: This class implements a Savitzky-Golay interpolation * fitting the upper or lower envelope of the series being interpolated. * * \sa otbSavitzkyGolayInterpolationFunctor * * \ingroup OTBTimeSeries */ template class EnvelopeSavitzkyGolayInterpolationFunctor { public: typedef typename TSeries::ValueType ValueType; typedef typename TDates::ValueType DateType; typedef typename TWeight::ValueType WeightType; static const unsigned int Degree = 2; typedef double CoefficientPrecisionType; typedef otb::PolynomialTimeSeries< Degree, CoefficientPrecisionType > TSFunctionType; static const unsigned int nbDates = TSeries::Dimension; typedef otb::Functor::SavitzkyGolayInterpolationFunctor SGFunctorType; /// Constructor EnvelopeSavitzkyGolayInterpolationFunctor() : m_Iterations(2), m_UpperEnvelope(true), m_DecreaseFactor(0.5) { } /// Destructor virtual ~EnvelopeSavitzkyGolayInterpolationFunctor() {} inline void SetWeights(const TWeight weights) { for(unsigned int i=0; i0.0 && df <1.0) m_DecreaseFactor = df; } inline void SetIterations(unsigned int its) { m_Iterations = its; } inline TSeries operator ()(const TSeries& series) { TSeries outSeries = m_SGFunctor(series); for(unsigned int i=0; iseries[j] ) m_WeightSeries[j] = m_WeightSeries[j]*m_DecreaseFactor; } m_SGFunctor.SetWeights(m_WeightSeries); outSeries = m_SGFunctor(series); } return outSeries; } private: TWeight m_WeightSeries; SGFunctorType m_SGFunctor; unsigned int m_Iterations; bool m_UpperEnvelope; double m_DecreaseFactor; }; } } //namespace otb #endif OTB-release-5.8/Modules/Filtering/TimeSeries/include/otbSavitzkyGolayInterpolationFunctor.h000066400000000000000000000101321301006202600322510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSavitzkyGolayInterpolationFunctor_h #define otbSavitzkyGolayInterpolationFunctor_h #include "otbTimeSeries.h" #include "otbTimeSeriesLeastSquareFittingFunctor.h" namespace otb { namespace Functor { /** \class otbSavitzkyGolayInterpolationFunctor * * \brief: This functor implements a local polynomial regression (of * degree k) on a series of values (of at least k+1 points which are * treated as being equally spaced in the series) to determine the * smoothed value for each point. * * In this implementation, the interpolation is performed by least * squares fitting. The size of the moving window for the * interpolation can be set using the radius variable. If needed, * weights for each value of the series to be used by the least * squares estimation can be set (the higher the weight, the lower the * confidence in the value). * * Savitzky, A.; Golay, M.J.E. (1964). "Smoothing and Differentiation of * Data by Simplified Least Squares Procedures". Analytical Chemistry 36 * (8): 1627-1639. doi:10.1021/ac60214a047 * * \sa otbTimeSeriesLeastSquareFittingFunctor * * * \ingroup OTBTimeSeries */ template class SavitzkyGolayInterpolationFunctor { public: typedef typename TSeries::ValueType ValueType; typedef typename TDates::ValueType DateType; typedef typename TWeight::ValueType WeightType; typedef double CoefficientPrecisionType; typedef otb::PolynomialTimeSeries< Degree, CoefficientPrecisionType > TSFunctionType; static const unsigned int nbDates = TSeries::Dimension; static const unsigned int InterpolatedLength = 2*Radius+1; typedef itk::FixedArray< ValueType, InterpolatedLength> InterpolatedSeriesType; typedef itk::FixedArray< DateType, InterpolatedLength> InterpolatedDatesType; typedef itk::FixedArray< WeightType, InterpolatedLength> InterpolatedWeightType; typedef otb::Functor::TimeSeriesLeastSquareFittingFunctor TLSFunctorType; /// Constructor SavitzkyGolayInterpolationFunctor() { } /// Destructor virtual ~SavitzkyGolayInterpolationFunctor() {} inline void SetWeights(const TWeight weights) { for(unsigned int i = 0; i < m_WeightSeries.Size(); ++i) m_WeightSeries[i] = weights[i]; } inline void SetDates(const TDates doy) { for(unsigned int i = 0; i < m_DoySeries.Size(); ++i) m_DoySeries[i] = doy[i]; } inline TSeries operator ()(const TSeries& series) const { TSeries outSeries; unsigned int firstSample = Radius; unsigned int lastSample = nbDates - Radius - 1; for(unsigned int i = 0; i namespace otb { template class PolynomialTimeSeries { public: typedef TCoefPrecision CoefficientsPrecisionType; typedef itk::FixedArray< CoefficientsPrecisionType, TDegree+1 > CoefficientsType; /// Constructor PolynomialTimeSeries() { } /// Destructor virtual ~PolynomialTimeSeries() {} inline void SetCoefficients(CoefficientsType& coeffs) { for(unsigned int i=0; i<=TDegree; ++i) m_Coefficients[i] = coeffs[i]; } inline TCoefPrecision GetCoefficient(unsigned int co) const { return m_Coefficients[co]; } inline CoefficientsType GetCoefficients() const { return m_Coefficients; } inline CoefficientsPrecisionType GetValue( CoefficientsPrecisionType val) const { CoefficientsPrecisionType tmpVal = 0; for( unsigned int i=0; i<=TDegree; ++i) tmpVal += m_Coefficients[i]*vcl_pow(val, static_cast(i)); return tmpVal; } private: CoefficientsType m_Coefficients; }; } #endif OTB-release-5.8/Modules/Filtering/TimeSeries/include/otbTimeSeriesLeastSquareFittingFunctor.h000066400000000000000000000104141301006202600324340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTimeSeriesLSFF_h #define otbTimeSeriesLSFF_h #include "vnl/algo/vnl_matrix_inverse.h" #include "vnl/vnl_transpose.h" #include "vnl/vnl_matrix.h" namespace otb { namespace Functor { /** \class TimeSeriesLeastSquareFittingFunctor * \brief Implements a least squares fitting of a time profile * * This functor * implements a least squares fitting of a time profile. The time * series as well as the date series are supposed to accept the [] * syntax to get the values and the Size() method to get their * length. The fitting is performed using a time function which is * just a weighted sum of basis functions : \f$ f(t) = c_0 * * \phi_0(t) + c_1 * \phi_1(t) + c_1 * \phi_1(t) + \cdots \f$ Using * a matrix notation, this can be written as follows : * \f$ F = \Phi c \f$ * \f$ F = ( f(t_i) ) \f$ * \f$ c = ( c_j ) \f$ * \f$ \Phi_{ij} = ( \phi_j(t_i) ) \f$ * If information about the error * of each measure is available, it can be provided using a weight * series \f$\sigma_i\f$ (the higher the error, the higher the \f$ \sigma_i \f$. The problem then becomes: * \f$ b = A c \f$ * \f$ b = (\frac{ f(t_i) }{\sigma_i}) \f$ * \f$ A_{ij} = \frac{\Phi_{ij}}{\sigma_i} \f$ * * * * \ingroup OTBTimeSeries */ template class TimeSeriesLeastSquareFittingFunctor { public: typedef typename TTimeFunction::CoefficientsType CoefficientsType; /// Constructor TimeSeriesLeastSquareFittingFunctor() { for(unsigned int i=0; iEstimateTimeFunction(series); TSeriesType outSeries; for(unsigned int i = 0; i < m_DoySeries.Size(); ++i) outSeries[i] = estFunction.GetValue( m_DoySeries[i] ); return outSeries; } inline void SetDates(const TDateType& doy) { for(unsigned int i = 0; i < doy.Size(); ++i) m_DoySeries[i] = doy[i]; } inline void SetWeights(const TWeightType& weights) { for(unsigned int i=0; iEstimateTimeFunction(series)).GetCoefficients(); } inline TTimeFunction EstimateTimeFunction(const TSeriesType& series) const { TTimeFunction estFunction; unsigned int nbDates = m_DoySeries.Size(); unsigned int nbCoefs = estFunction.GetCoefficients().Size(); // b = A * c vnl_matrix A(nbDates, nbCoefs); vnl_matrix b(nbDates, 1); // fill the matrices typename TTimeFunction::CoefficientsType tmpCoefs; for(unsigned int j = 0; j < nbCoefs; ++j) tmpCoefs[j] = 0.0; for(unsigned int i = 0; i < nbDates; ++i) { b.put(i, 0, series[i] / m_WeightSeries[i]); for(unsigned int j = 0; j < nbCoefs; ++j) { tmpCoefs[j] = 1.0; estFunction.SetCoefficients(tmpCoefs); A.put(i, j, estFunction.GetValue(m_DoySeries[i]) / m_WeightSeries[i]); tmpCoefs[j] = 0.0; } } // solve the problem c = (At * A)^-1*At*b vnl_matrix atainv = vnl_matrix_inverse(vnl_transpose(A) * A); vnl_matrix atainvat = atainv * vnl_transpose(A); vnl_matrix c = atainvat * b; for(unsigned int j = 0; j < nbCoefs; ++j) tmpCoefs[j] = c.get(j, 0); estFunction.SetCoefficients(tmpCoefs); return estFunction; } private: /// TDateType m_DoySeries; TWeightType m_WeightSeries; }; } } //namespace otb #endif OTB-release-5.8/Modules/Filtering/TimeSeries/otb-module.cmake000066400000000000000000000002231301006202600240700ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBTimeSeries DEPENDS OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/TimeSeries/test/000077500000000000000000000000001301006202600220015ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/TimeSeries/test/CMakeLists.txt000066400000000000000000000033231301006202600245420ustar00rootroot00000000000000otb_module_test() set(OTBTimeSeriesTests otbEnvelopeSavitzkyGolayInterpolationFunctorTest.cxx otbPolynomialTimeSeriesTest.cxx otbSavitzkyGolayInterpolationFunctorNew.cxx otbSavitzkyGolayInterpolationFunctorTest.cxx otbTimeSeriesLeastSquareFittingFunctorNew.cxx otbTimeSeriesLeastSquareFittingFunctorTest.cxx otbTimeSeriesLeastSquareFittingFunctorWeightsTest.cxx otbTimeSeriesTestDriver.cxx ) add_executable(otbTimeSeriesTestDriver ${OTBTimeSeriesTests}) target_link_libraries(otbTimeSeriesTestDriver ${OTBTimeSeries-Test_LIBRARIES}) otb_module_target_label(otbTimeSeriesTestDriver) otb_add_test(NAME mtTvEnvelopeSavitzkyGolayInterpolationFunctorTest COMMAND otbTimeSeriesTestDriver otbEnvelopeSavitzkyGolayInterpolationFunctorTest ) otb_add_test(NAME mtTvPolynomialTimeSeriesTest1 COMMAND otbTimeSeriesTestDriver otbPolynomialTimeSeriesTest ) otb_add_test(NAME mtTuSavitzkyGolayInterpolationFunctor COMMAND otbTimeSeriesTestDriver otbSavitzkyGolayInterpolationFunctorNew ) otb_add_test(NAME mtTvSavitzkyGolayInterpolationFunctorTest COMMAND otbTimeSeriesTestDriver otbSavitzkyGolayInterpolationFunctorTest ) otb_add_test(NAME mtTuTimeSeriesLeastSquaresFittingFunctor COMMAND otbTimeSeriesTestDriver otbTimeSeriesLeastSquareFittingFunctorNew ) otb_add_test(NAME mtTvTimeSeriesLeastSquaresFittingFunctor2 COMMAND otbTimeSeriesTestDriver otbTimeSeriesLeastSquareFittingFunctorTest 10 0.3 3.123 ) otb_add_test(NAME mtTvTimeSeriesLeastSquaresFittingFunctor COMMAND otbTimeSeriesTestDriver otbTimeSeriesLeastSquareFittingFunctorTest 1 2 3 ) otb_add_test(NAME mtTvTimeSeriesLeastSquaresFittingFunctorWeights COMMAND otbTimeSeriesTestDriver otbTimeSeriesLeastSquareFittingFunctorWeightsTest 1 2 3 ) otbEnvelopeSavitzkyGolayInterpolationFunctorTest.cxx000066400000000000000000000040631301006202600344450ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/TimeSeries/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbEnvelopeSavitzkyGolayInterpolationFunctor.h" #include "otbTimeSeries.h" int otbEnvelopeSavitzkyGolayInterpolationFunctorTest(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef float PixelType; typedef unsigned int DoYType; const unsigned int nbDates = 100; typedef itk::FixedArray< PixelType, nbDates > SeriesType; typedef itk::FixedArray< DoYType, nbDates > DatesType; const unsigned int Radius = 2; // Create a time series SeriesType inSeries; SeriesType cleanSeries; SeriesType weightSeries; DatesType doySeries; for(unsigned int i=0; i FunctorType; FunctorType f; f.SetWeights( weightSeries ); f.SetDates( doySeries ); f.SetUpperEnvelope(); f.SetDecreaseFactor(0.9); f.SetIterations(4); SeriesType outSeries = f(inSeries); double interpolError = 0.0; for(unsigned int i=0; i 0.1) { std::cout << "Interpolation error = " << interpolError << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/TimeSeries/test/otbPolynomialTimeSeriesTest.cxx000066400000000000000000000024451301006202600302140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTimeSeries.h" int otbPolynomialTimeSeriesTest(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef double CoefficientPrecisionType; const unsigned int Degree = 2; typedef otb::PolynomialTimeSeries< Degree, CoefficientPrecisionType > FunctionType; typedef FunctionType::CoefficientsType CoefficientsType; CoefficientsType coefs; coefs[0] = 1; coefs[1] = 2; coefs[2] = 4; FunctionType f; f.SetCoefficients( coefs ); for( unsigned int i=0; i<=Degree; ++i) if(coefs[i] != f.GetCoefficient(i)) return EXIT_FAILURE; int VALMAX = 10; for(int val = -VALMAX; val <= VALMAX; ++val) if( f.GetValue( val ) != (coefs[0]+coefs[1]*val+coefs[2]*val*val) ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/TimeSeries/test/otbSavitzkyGolayInterpolationFunctorNew.cxx000066400000000000000000000020231301006202600326320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSavitzkyGolayInterpolationFunctor.h" int otbSavitzkyGolayInterpolationFunctorNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef float PixelType; typedef unsigned int DoYType; typedef itk::FixedArray< PixelType > SeriesType; typedef itk::FixedArray< DoYType > DatesType; const unsigned int Radius = 2; typedef otb::Functor::SavitzkyGolayInterpolationFunctor FunctorType; FunctorType f; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/TimeSeries/test/otbSavitzkyGolayInterpolationFunctorTest.cxx000066400000000000000000000035671301006202600330360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSavitzkyGolayInterpolationFunctor.h" int otbSavitzkyGolayInterpolationFunctorTest(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef float PixelType; typedef unsigned int DoYType; const unsigned int nbDates = 100; typedef itk::FixedArray< PixelType, nbDates > SeriesType; typedef itk::FixedArray< DoYType, nbDates > DatesType; const unsigned int Radius = 2; // Create a time series SeriesType inSeries; SeriesType weightSeries; DatesType doySeries; for(unsigned int i=0; i FunctorType; FunctorType f; f.SetWeights( weightSeries ); f.SetDates( doySeries ); SeriesType outSeries = f(inSeries); double interpolError = 0.0; for(unsigned int i=0; i 0.15) { std::cout << "Interpolation error = " << interpolError << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/TimeSeries/test/otbTimeSeriesLeastSquareFittingFunctorNew.cxx000066400000000000000000000022731301006202600330210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTimeSeriesLeastSquareFittingFunctor.h" #include "otbTimeSeries.h" int otbTimeSeriesLeastSquareFittingFunctorNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef float PixelType; typedef unsigned int DoYType; typedef itk::FixedArray< PixelType > SeriesType; typedef itk::FixedArray< DoYType > DatesType; typedef double CoefficientPrecisionType; const unsigned int Degree = 2; typedef otb::PolynomialTimeSeries< Degree, CoefficientPrecisionType > FunctionType; typedef otb::Functor::TimeSeriesLeastSquareFittingFunctor FunctorType; FunctorType f; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/TimeSeries/test/otbTimeSeriesLeastSquareFittingFunctorTest.cxx000066400000000000000000000037361301006202600332140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTimeSeriesLeastSquareFittingFunctor.h" #include "otbTimeSeries.h" int otbTimeSeriesLeastSquareFittingFunctorTest(int itkNotUsed(argc), char* argv[]) { const unsigned int Degree = 2; typedef double CoefficientPrecisionType; typedef otb::PolynomialTimeSeries< Degree, CoefficientPrecisionType > FunctionType; const unsigned int nbDates = 100; typedef float PixelType; typedef unsigned int DoYType; typedef itk::FixedArray< PixelType, nbDates > SeriesType; typedef itk::FixedArray< DoYType, nbDates > DatesType; typedef otb::Functor::TimeSeriesLeastSquareFittingFunctor FunctorType; DatesType doySeries; // one acquisition every 2 days for(unsigned int i = 0; i0.01) { std::cout << outCoefs[i] << " != " << inCoefs[i] << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } otbTimeSeriesLeastSquareFittingFunctorWeightsTest.cxx000066400000000000000000000043341301006202600344630ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/TimeSeries/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTimeSeriesLeastSquareFittingFunctor.h" #include "otbTimeSeries.h" int otbTimeSeriesLeastSquareFittingFunctorWeightsTest(int itkNotUsed(argc), char* argv[]) { const unsigned int Degree = 2; typedef double CoefficientPrecisionType; typedef otb::PolynomialTimeSeries< Degree, CoefficientPrecisionType > FunctionType; const unsigned int nbDates = 100; typedef float PixelType; typedef unsigned int DoYType; typedef itk::FixedArray< PixelType, nbDates > SeriesType; typedef itk::FixedArray< DoYType, nbDates > DatesType; typedef otb::Functor::TimeSeriesLeastSquareFittingFunctor FunctorType; DatesType doySeries; // one acquisition every 2 days for(unsigned int i = 0; i0.01) { std::cout << outCoefs[i] << " != " << inCoefs[i] << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/TimeSeries/test/otbTimeSeriesTestDriver.cxx000066400000000000000000000007251301006202600273230ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbEnvelopeSavitzkyGolayInterpolationFunctorTest); REGISTER_TEST(otbPolynomialTimeSeriesTest); REGISTER_TEST(otbSavitzkyGolayInterpolationFunctorNew); REGISTER_TEST(otbSavitzkyGolayInterpolationFunctorTest); REGISTER_TEST(otbTimeSeriesLeastSquareFittingFunctorNew); REGISTER_TEST(otbTimeSeriesLeastSquareFittingFunctorTest); REGISTER_TEST(otbTimeSeriesLeastSquareFittingFunctorWeightsTest); } OTB-release-5.8/Modules/Filtering/VectorDataManipulation/000077500000000000000000000000001301006202600233665ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/CMakeLists.txt000066400000000000000000000000651301006202600261270ustar00rootroot00000000000000project(OTBVectorDataManipulation) otb_module_impl() OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/000077500000000000000000000000001301006202600250115ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbConcatenateVectorDataFilter.h000066400000000000000000000074361301006202600332500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateVectorDataFilter_h #define otbConcatenateVectorDataFilter_h #include "otbVectorDataToVectorDataFilter.h" #include "otbVectorData.h" #include "itkPreOrderTreeIterator.h" namespace otb { /** \class ConcatenateVectorDataFilter * \brief Produces a VectorData from the concatenation * of several input vectordatas. * * This generator produces a unique vector by concatening several * inputs set via the method AddInput(VectorData *). * * Note that the input vectordatas must have the same node type, * this is due that vectordata creation does not support multiple geometries * in a single vectordata. * Warning : this filter does not create a deep copy of each node. * * * \ingroup OTBVectorDataManipulation */ template class ITK_EXPORT ConcatenateVectorDataFilter : public VectorDataSource { public: /** Standard class typedefs */ typedef ConcatenateVectorDataFilter Self; typedef VectorDataSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ConcatenateVectorDataFilter, VectorDataSource); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef typename DataNodeType::PolygonType::RegionType RegionType; typedef typename DataNodeType::PointType PointType; typedef typename DataNodeType::PolygonType::VertexType VertexType; typedef typename DataNodeType::LineType LineType; typedef typename VectorDataType::DataTreeType DataTreeType; typedef typename DataTreeType::TreeNodeType TreeNodeType; typedef typename TreeNodeType::ChildrenListType ChildrenListType; typedef typename std::vector PointVectorType; /** Connects the VectorDatas from which the localizations are going to be extracted. */ void AddInput(const VectorDataType *); using Superclass::AddInput; const VectorDataType * GetInput(unsigned int idx) const; protected: ConcatenateVectorDataFilter(); ~ConcatenateVectorDataFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Triggers the Computation of the sample list */ void GenerateData(void) ITK_OVERRIDE; /** Recursive method to visit efficiently the vectordata*/ void ProcessNode(TreeNodeType * source, DataNodeType * outputDocument); private: ConcatenateVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented DataNodePointerType m_Folder; DataNodePointerType m_Document; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConcatenateVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbConcatenateVectorDataFilter.txx000066400000000000000000000120631301006202600336340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConcatenateVectorDataFilter_txx #define otbConcatenateVectorDataFilter_txx #include "otbConcatenateVectorDataFilter.h" #include "otbMath.h" #include "itkTimeProbe.h" namespace otb { template ConcatenateVectorDataFilter ::ConcatenateVectorDataFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); m_Folder = DataNodeType::New(); m_Folder->SetNodeType(otb::FOLDER); m_Document = DataNodeType::New(); m_Document->SetNodeType(otb::DOCUMENT); } template void ConcatenateVectorDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } template void ConcatenateVectorDataFilter ::AddInput(const VectorDataType * vectorData) { for ( unsigned idx = 0; idx < this->GetNumberOfIndexedInputs(); ++idx ) { if ( !this->GetInput( idx ) ) { this->Superclass::SetNthInput( idx, const_cast(vectorData) ); return; } } this->Superclass::SetNthInput( this->GetNumberOfIndexedInputs(), const_cast(vectorData)); } template const TVectorData * ConcatenateVectorDataFilter ::GetInput(unsigned int idx) const { if (this->GetNumberOfInputs() < idx) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(idx)); } template void ConcatenateVectorDataFilter ::GenerateData() { // TODO : no checking is done on the inputs, do checking to avoid // TODO : Check if they are in the same coordinate system (tricky) // Start recursive processing // Copy the input MetaDataDictionary in the output VectorData //this->GetOutput()->SetMetaDataDictionary(this->GetInput(0)->GetMetaDataDictionary()); // Prepare the output //typename DataNodeType::Pointer outputRoot = this->GetOutput()->GetDataTree()->GetRoot()->Get(); typename DataTreeType::Pointer outputTree = this->GetOutput()->GetDataTree(); typename TreeNodeType::Pointer inputRoot = const_cast(this->GetInput(0)->GetDataTree()->GetRoot()); outputTree->SetRoot(inputRoot); typename DataNodeType::Pointer outputDocument = this->GetOutput()->GetDataTree()->GetRoot()->GetChild(0)->Get(); // Adding the layer to the data tree // this->GetOutput()->GetDataTree()->Add(m_Document, outputRoot); // this->GetOutput()->GetDataTree()->Add(m_Folder, m_Document); // Retrieve all the inputs for(unsigned int idx = 1; idx < this->GetNumberOfInputs(); ++idx) { // Add the current vectordata TreeNodeType * currentInputRoot = const_cast(this->GetInput(idx)->GetDataTree()->GetRoot()); ProcessNode(currentInputRoot, outputDocument); } } template void ConcatenateVectorDataFilter ::ProcessNode(TreeNodeType * source, DataNodeType * outputDocument) { if (source == ITK_NULLPTR) return; // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // For each child typename ChildrenListType::iterator it; for (it = children.begin(); it != children.end(); ++it) { // get the data node DataNodePointerType dataNode = (*it)->Get(); switch (dataNode->GetNodeType()) { case ROOT: { ProcessNode((*it), outputDocument); break; } case DOCUMENT: { ProcessNode((*it), outputDocument); break; } case FOLDER: { ProcessNode((*it), outputDocument); break; } case FEATURE_POINT: { this->GetOutput()->GetDataTree()->Add(dataNode, outputDocument); break; } case FEATURE_LINE: { this->GetOutput()->GetDataTree()->Add(dataNode, outputDocument); break; } case FEATURE_POLYGON: { this->GetOutput()->GetDataTree()->Add(dataNode, outputDocument); break; } case FEATURE_MULTIPOINT: { ProcessNode((*it), outputDocument); break; } case FEATURE_MULTILINE: { ProcessNode((*it), outputDocument); break; } case FEATURE_MULTIPOLYGON: { ProcessNode((*it), outputDocument); break; } case FEATURE_COLLECTION: { ProcessNode((*it), outputDocument); break; } } } } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbCorrectPolygonFunctor.h000066400000000000000000000034611301006202600322050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCorrectPolygonFunctor_h #define otbCorrectPolygonFunctor_h #include "otbSimplifyPathFunctor.h" #include "otbClosePathFunctor.h" namespace otb { /** \class CorrectPolygonFunctor * \brief This filter simplify and close the input polygon, making the last point equal to the first one. * * This filter may be useful when a truly closed polygon is needed (to draw it for example) * * \sa UnaryFunctorObjectListFilter * * \ingroup Functor * * \ingroup OTBVectorDataManipulation */ template class CorrectPolygonFunctor { public: typedef TPolygon PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; /** Some typedefs specific to functors*/ typedef otb::SimplifyPathFunctor SimplifyFunctorType; typedef ClosePathFunctor CloseFunctorType; CorrectPolygonFunctor() {} ~CorrectPolygonFunctor() {} inline PolygonPointerType operator ()(const TPolygon * input) { /**create functors */ SimplifyFunctorType simplifyFunctor; CloseFunctorType closeFunctor; simplifyFunctor.SetTolerance(0.0); /** Erase aligned points and close polygon*/ return closeFunctor (simplifyFunctor(input)); } }; } #endif otbDBOverlapDataNodeFeatureFunction.h000066400000000000000000000066541301006202600340630ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDBOverlapDataNodeFeatureFunction_h #define otbDBOverlapDataNodeFeatureFunction_h #include "otbDataNodeVectorDataFunction.h" #include "itkPreOrderTreeIterator.h" namespace otb { /** \class DBOverlapDataNodeFeatureFunction * \brief * * * \ingroup Functions * \sa DataNodeVectorDataFunction * * \ingroup OTBVectorDataManipulation */ template < class TCoordRep = double, class TPrecision = double > class ITK_EXPORT DBOverlapDataNodeFeatureFunction : public DataNodeVectorDataFunction, TCoordRep, TPrecision> { public: /** Standard class typedefs. */ typedef DBOverlapDataNodeFeatureFunction Self; typedef DataNodeVectorDataFunction, TCoordRep, TPrecision> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DBOverlapDataNodeFeatureFunction, DataNodeVectorDataFunction); /** Some typedefs. */ typedef typename Superclass::DataNodeType DataNodeType; typedef typename DataNodeType::PointType PointType; typedef typename DataNodeType::LineType LineType; typedef typename LineType::VertexType VertexType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename Superclass::VectorDataType VectorDataType; typedef typename VectorDataType::DataTreeType DataTreeType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; typedef std::vector OutputType; OutputType Evaluate( const DataNodeType& node ) const ITK_OVERRIDE; /** Set/Get methods */ itkGetConstMacro(DistanceThreshold, PrecisionType); itkSetMacro(DistanceThreshold, PrecisionType); /** Method to compute the distance of a point to a segment */ double ComputeEuclideanDistanceMetricToSegment(VertexType q1, VertexType q2, VertexType p) const; protected: DBOverlapDataNodeFeatureFunction(); ~DBOverlapDataNodeFeatureFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: DBOverlapDataNodeFeatureFunction(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Road / Building distance Threshold */ PrecisionType m_DistanceThreshold; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbDBOverlapDataNodeFeatureFunction.txx" #endif #endif otbDBOverlapDataNodeFeatureFunction.txx000066400000000000000000000124231301006202600344460ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDBOverlapDataNodeFeatureFunction_txx #define otbDBOverlapDataNodeFeatureFunction_txx #include "otbDBOverlapDataNodeFeatureFunction.h" namespace otb { /** * Constructor */ template DBOverlapDataNodeFeatureFunction ::DBOverlapDataNodeFeatureFunction() :m_DistanceThreshold(50)//in physical coordinates { } /** * Standard "PrintSelf" method */ template void DBOverlapDataNodeFeatureFunction ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf( os, indent ); os << indent << "Distance Threshold: " << m_DistanceThreshold << std::endl; } /** * Method to compute the distance of a point to a segment */ template double DBOverlapDataNodeFeatureFunction ::ComputeEuclideanDistanceMetricToSegment(VertexType q1, VertexType q2, VertexType p) const { // Length of the segment double l2 = q1.SquaredEuclideanDistanceTo(q2); // Is the projection of p on the segment inside (0 1e-10 ) u = 1.; double x = q1[0] + u *(q2[0] - q1[0] ); double y = q1[1] + u *(q2[1] - q1[1] ); double dx = x - p[0]; double dy = y - p[1]; return vcl_sqrt(dx*dx + dy*dy); } template typename DBOverlapDataNodeFeatureFunction ::OutputType DBOverlapDataNodeFeatureFunction ::Evaluate( const DataNodeType& node ) const { OutputType output; //build the tmp DataTree containing polygon within the radius typename VectorDataType::Pointer tmpDataTree = VectorDataType::New(); typename DataNodeType::Pointer root = tmpDataTree->GetDataTree()->GetRoot()->Get(); typename DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); tmpDataTree->GetDataTree()->Add(document, root); TreeIteratorType itVector(this->GetInputVectorData()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPolygonFeature()) { typename DataNodeType::Pointer currentGeometry = itVector.Get(); unsigned int i=0; while (iGetPolygonExteriorRing()->GetVertexList()->Size()) { unsigned int j=0; while (jGetVertexList()->Size()-1) { double dist; dist = this->ComputeEuclideanDistanceMetricToSegment(node.GetLine()->GetVertexList()->GetElement(j), node.GetLine()->GetVertexList()->GetElement(j+1), currentGeometry->GetPolygonExteriorRing()->GetVertexList()->GetElement(i)); //std::cout << "dist: " << dist << std::endl; //std::cout << "m_DistanceThreshold: " << m_DistanceThreshold << std::endl; if (dist <= m_DistanceThreshold) { //Add the current polygon to the tmp DataTree //jump to the next one tmpDataTree->GetDataTree()->Add(currentGeometry, document); j = node.GetLine()->GetVertexList()->Size(); i = currentGeometry->GetPolygonExteriorRing()->GetVertexList()->Size(); } ++j; } ++i; } } ++itVector; } /* std::cout << this->GetInputVectorData()->GetDataTree()->Count() << std::endl; std::cout << tmpDataTree->GetDataTree()->Count() << std::endl; */ unsigned int crossAcc = 0; unsigned int nbBuildings = 0; TreeIteratorType it(tmpDataTree->GetDataTree()); it.GoToBegin(); while (!it.IsAtEnd()) { if (it.Get()->IsPolygonFeature()) { typename DataNodeType::Pointer currentGeometry = it.Get(); nbBuildings ++; for (unsigned int i=0; iGetVertexList()->Size()-1; ++i) { if(currentGeometry->GetPolygonExteriorRing()->NbCrossing(node.GetLine()->GetVertexList()->GetElement(i), node.GetLine()->GetVertexList()->GetElement(i+1))) { crossAcc ++; break; } } } ++it; } if(nbBuildings == 0) { output.push_back(static_cast(0.)); } else { output.push_back(static_cast((double)(crossAcc)/(double)(nbBuildings))); } output.push_back(static_cast(crossAcc)); output.push_back(static_cast(nbBuildings)); return output; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbPolygonCompacityFunctor.h000066400000000000000000000034271301006202600325360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolygonCompacityFunctor_h #define otbPolygonCompacityFunctor_h #include "otbMath.h" namespace otb { /** \class PolygonCompacityFunctor * \brief Select polygons according to their compacity * * This functor compute the compacity of a polygon * and return true is the distance is above the threshold, false otherwise. * * The compacity is defined as: * * \f$ 4\pi \frac{A}{L^2}\f$ * * where \f$ A \f$ is the area (obtained by the method GetArea() ) * and \f$ L \f$ the perimeter (obtained by the method GetLength() ). * * \ingroup Functor * * \ingroup OTBVectorDataManipulation */ template class PolygonCompacityFunctor { public: void SetThreshold(double threshold) { m_Threshold = threshold; } double GetThreshold(void) const { return m_Threshold; } PolygonCompacityFunctor() { m_Threshold = 0.2; } ~PolygonCompacityFunctor() {} inline bool operator ()(const TInput1& input) { double circularityRatio = 4*CONST_PI*input->GetArea() / vnl_math_sqr(input->GetLength()); if (circularityRatio > m_Threshold) { return true; } else { return false; } } private: double m_Threshold; }; } #endif otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction.h000066400000000000000000000142561301006202600416110ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction_h #define otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction_h #include "otbDataNodeImageFunction.h" #include "otbBinarySpectralAngleFunctor.h" #include "otbPolyLineImageConstIterator.h" #include "itkLineConstIterator.h" #include "itkVariableLengthVector.h" namespace otb { /** \class RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction * \brief Compute the spectral angle between the radiometry along * a line and its neighborhood * * This function compares the radiometry along a datanode with the * radiometry of the neighborhood. * * It computes the mean of a rectangular area around each line segment, * and the mean of two rectangular areas on each side of the line segment. * The descriptor is the spectral angle between the two values, * scaled by \$f\pi\$f. * * The width of the area around a line segment can be specified with * SetCenterRadius. * * The neighborhood area can be specified by two radius, using SetNeighborhoodBeginRadius * and SetNeighborhoodEndRadius. * * * \ingroup Functions * \sa DataNodeImageFunction * \sa NDVIDataNodeFeatureFunction * * \ingroup OTBVectorDataManipulation */ template < class TImage, class TCoordRep = double, class TPrecision = double > class ITK_EXPORT RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction : public DataNodeImageFunction, TCoordRep, TPrecision> { public: /** Standard class typedefs. */ typedef RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction Self; typedef DataNodeImageFunction, TCoordRep, TPrecision> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction, DataNodeImageFunction); /** Some typedefs. */ typedef typename Superclass::DataNodeType DataNodeType; typedef typename DataNodeType::LineType LineType; typedef typename LineType::Pointer LinePointer; typedef typename LineType::ContinuousIndexType ContinuousIndexType; typedef typename LineType::VertexListConstIteratorType VertexListConstIteratorType; typedef TImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType ScalarRealType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::IndexValueType IndexValueType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; typedef itk::VariableLengthVector ReferencePixelType; typedef PolyLineImageConstIterator ImageLineIteratorType; typedef itk::LineConstIterator LineIteratorType; typedef Functor::BinarySpectralAngleFunctor SpectralAngleFunctorType; typedef std::pair IndexPairType; typedef std::vector OutputType; /* Compute the descriptor value along this DataNode */ OutputType Evaluate( const DataNodeType& node ) const ITK_OVERRIDE; /* Get the radius used to define the area around a line segment. * A radius of 0 means that the area is reduced to a line joining * the two segments extremities. */ itkGetConstMacro(CenterRadius, unsigned int); /* Set the radius used to define the area around a line segment. * A radius of 0 means that the area is reduced to a line joining * the two segments extremities. */ itkSetMacro(CenterRadius, unsigned int); /* Get the radius used to define the start of the neighboring area. * Typically this value must be greater than CenterRadius */ itkGetConstMacro(NeighborhoodBeginRadius, unsigned int); /* Set the radius used to define the start of the neighboring area. * Typically this value must be greater than CenterRadius */ itkSetMacro(NeighborhoodBeginRadius, unsigned int); /* Get the radius used to define the end of the neighboring area. * Typically this value must be greater than NeighborhoodBeginRadius */ itkGetConstMacro(NeighborhoodEndRadius, unsigned int); /* Set the radius used to define the end of the neighboring area. * Typically this value must be greater than NeighborhoodBeginRadius */ itkSetMacro(NeighborhoodEndRadius, unsigned int); protected: RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction(); ~RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Center radius */ unsigned int m_CenterRadius; /** Neighborhood start radius */ unsigned int m_NeighborhoodBeginRadius; /** Neighborhood end radius */ unsigned int m_NeighborhoodEndRadius; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction.txx" #endif #endif otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction.txx000066400000000000000000000164001301006202600421760ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction_txx #define otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction_txx #include "otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction.h" namespace otb { /** * Constructor */ template RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction::RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction() : m_CenterRadius(1), m_NeighborhoodBeginRadius(2), m_NeighborhoodEndRadius(3) { } /** * Standard "PrintSelf" method */ template void RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template typename RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction::OutputType RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction< TImage, TCoordRep, TPrecision>::Evaluate(const DataNodeType& node) const { // TODO faire avce un ikk const typename ImageLineIteratorType::PathType* path; switch (node.GetNodeType()) { case FEATURE_POINT: { itkExceptionMacro(<< "This DataNode type is not handled yet"); break; } case FEATURE_LINE: { path = node.GetLine(); break; } case FEATURE_POLYGON: { path = node.GetPolygonExteriorRing(); break; } default: { itkExceptionMacro(<< "This DataNode type is not handle yet"); break; } } std::vector > splitedLineIdNeigh; std::vector > splitedLineIdCentral; // Split line and polygon into segment (ie. line with two vertex VertexListConstIteratorType it1 = path->GetVertexList()->Begin(); VertexListConstIteratorType it2 = path->GetVertexList()->Begin(); VertexListConstIteratorType itStop = path->GetVertexList()->End(); ++it2; if (it2 == itStop) { itkExceptionMacro(<< "Invalid DataNode, must at least contain two points"); } while (it1 != itStop && it2 != itStop) { IndexType id1, id2; id1[0] = static_cast (it1.Value()[0]); id1[1] = static_cast (it1.Value()[1]); id2[0] = static_cast (it2.Value()[0]); id2[1] = static_cast (it2.Value()[1]); // Compute the direction of the current line itk::Vector direction; direction[0] = it2.Value()[0] - it1.Value()[0]; direction[1] = it2.Value()[1] - it1.Value()[1]; direction.Normalize(); // Compute the orthogonal direction of the current line itk::Vector orthogonalDirection; orthogonalDirection[0] = direction[1]; orthogonalDirection[1] = -direction[0]; splitedLineIdCentral.push_back(IndexPairType(id1, id2)); for (unsigned int j = 1; j <= m_CenterRadius; ++j) { IndexType shift11, shift12; shift11[0] = id1[0] - j * orthogonalDirection[0]; shift11[1] = id1[1] - j * orthogonalDirection[1]; shift12[0] = id1[0] + j * orthogonalDirection[0]; shift12[1] = id1[1] + j * orthogonalDirection[1]; IndexType shift21, shift22; shift21[0] = id2[0] - j * orthogonalDirection[0]; shift21[1] = id2[1] - j * orthogonalDirection[1]; shift22[0] = id2[0] + j * orthogonalDirection[0]; shift22[1] = id2[1] + j * orthogonalDirection[1]; splitedLineIdCentral.push_back(IndexPairType(shift11, shift21)); splitedLineIdCentral.push_back(IndexPairType(shift12, shift22)); } for (unsigned int j = m_NeighborhoodBeginRadius; j <= m_NeighborhoodEndRadius; ++j) { IndexType shift11, shift12; shift11[0] = id1[0] - j * orthogonalDirection[0]; shift11[1] = id1[1] - j * orthogonalDirection[1]; shift12[0] = id1[0] + j * orthogonalDirection[0]; shift12[1] = id1[1] + j * orthogonalDirection[1]; IndexType shift21, shift22; shift21[0] = id2[0] - j * orthogonalDirection[0]; shift21[1] = id2[1] - j * orthogonalDirection[1]; shift22[0] = id2[0] + j * orthogonalDirection[0]; shift22[1] = id2[1] + j * orthogonalDirection[1]; splitedLineIdNeigh.push_back(IndexPairType(shift11, shift21)); splitedLineIdNeigh.push_back(IndexPairType(shift12, shift22)); } ++it1; ++it2; } // in FEATURE_POLYGON case, first point appears twice (first vertex and last vertew, thus we create a line of 1 point...) if (node.GetNodeType() == FEATURE_POLYGON) { splitedLineIdCentral.pop_back(); splitedLineIdNeigh.pop_back(); splitedLineIdNeigh.pop_back(); } double centralNbVisitedPixel = 0.; PixelType centralRadiomAcc(this->GetInputImage()->GetNumberOfComponentsPerPixel()); centralRadiomAcc.Fill(0); for (unsigned int i = 0; i < splitedLineIdCentral.size(); ++i) { LineIteratorType lineIt(this->GetInputImage(), splitedLineIdCentral[i].first, splitedLineIdCentral[i].second); lineIt.GoToBegin(); while (!lineIt.IsAtEnd()) { if (this->IsInsideBuffer(lineIt.GetIndex())) { centralRadiomAcc += this->GetInputImage()->GetPixel( lineIt.GetIndex() ); centralNbVisitedPixel += 1; } ++lineIt; } } double neighNbVisitedPixel = 0.; PixelType neighborRadiomAcc(this->GetInputImage()->GetNumberOfComponentsPerPixel()); neighborRadiomAcc.Fill(0); for (unsigned int i = 0; i < splitedLineIdNeigh.size(); ++i) { LineIteratorType lineIt(this->GetInputImage(), splitedLineIdNeigh[i].first, splitedLineIdNeigh[i].second); lineIt.GoToBegin(); while (!lineIt.IsAtEnd()) { if (this->IsInsideBuffer(lineIt.GetIndex())) { neighborRadiomAcc += this->GetInputImage()->GetPixel( lineIt.GetIndex() ); neighNbVisitedPixel += 1; } ++lineIt; } } OutputType output; if (centralNbVisitedPixel > 0 && neighNbVisitedPixel > 0) { // Compute averaged radiometry in both areas centralRadiomAcc /= centralNbVisitedPixel; neighborRadiomAcc /= neighNbVisitedPixel; // Compute the spectral angle between the center area and the neighbor area SpectralAngleFunctorType spectralAngleFunctor; double angle = spectralAngleFunctor(neighborRadiomAcc, centralRadiomAcc); // Make sure we are in [0, 1] interval angle /= otb::CONST_PI; output.push_back(static_cast (angle)); } else { output.push_back(static_cast (0.)); } // TODO: handle streaming, need to output the current state return output; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbSimplifyPathFunctor.h000066400000000000000000000106271301006202600316470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimplifyPathFunctor_h #define otbSimplifyPathFunctor_h #include "otbMath.h" namespace otb { /** \class SimplifyPathFunctor * \brief This filter performs a simplification of the input path. * * It reduces the number of vertices in each path, according to a tolerance criterion. It aims at * removing aligned vertices while keeping sharp angular points. * * In order to ensure the unicity of its output, each path is considered first from begin to end, then * from begin to the first vertex before the end. At each step, the consistency of the path is checked : * the equation of the line passing by the first and last vertices is computed. Then, for each * vertices between them, the euclidean distance to this line is computed. If for one vertex, this distance * is upper than the tolerance threshold, the path is considered to be inconsistent and no vertices can be removed. * * If the path is considered consistent (which will occur at least with a 2 vertices path), * only the beginning and ending * vertices are kept and a new search iteration begin at its end. * * This filter is part of the road extraction framework. * * \sa UnaryFunctorObjectListFilter * * \ingroup Functor * * \ingroup OTBVectorDataManipulation */ template class SimplifyPathFunctor { public: typedef typename TInput::VertexListType::ConstIterator VertexListConstIteratorType; typedef typename TInput::VertexListType::ConstPointer VertexListConstPointerType; typedef TOutput OutputPathType; typedef typename OutputPathType::Pointer OutputPathPointerType; void SetTolerance(double Tolerance) { m_Tolerance = Tolerance; } double GetTolerance(void) const { return (m_Tolerance); } SimplifyPathFunctor() { m_Tolerance = 1.0; } ~SimplifyPathFunctor() {} inline OutputPathPointerType operator ()(const TInput * input) { OutputPathPointerType newPath = OutputPathType::New(); newPath->Initialize(); // Getting the verices list of the current input paths VertexListConstPointerType vertexList = input->GetVertexList(); if(vertexList->Size()>0) { VertexListConstIteratorType beginIt = vertexList->Begin(); VertexListConstIteratorType beforeTheEndIt = --(vertexList->End()); // Add the first vertex newPath->AddVertex(beginIt.Value()); while (beginIt != beforeTheEndIt) { VertexListConstIteratorType endIt = beforeTheEndIt; // while the segment is not consistent, decrement endIt while (!this->TestPathConsistency(beginIt, endIt)) { --endIt; } // Add the final vertex newPath->AddVertex(endIt.Value()); beginIt = endIt; } } newPath->SetMetaDataDictionary(input->GetMetaDataDictionary()); return newPath; } private: double m_Tolerance; bool TestPathConsistency(VertexListConstIteratorType begin, VertexListConstIteratorType end) const { VertexListConstIteratorType segmentIt = begin; ++segmentIt; //Compute the distance of a point to a segment based on the cross product while (segmentIt != end) { double crossProduct = (end.Value()[0] - begin.Value()[0]) * (segmentIt.Value()[1] - begin.Value()[1]) - (end.Value()[1] - begin.Value()[1]) * (segmentIt.Value()[0] - begin.Value()[0]); double lengthSeg = (end.Value()[0] - begin.Value()[0]) * (end.Value()[0] - begin.Value()[0]) + (end.Value()[1] - begin.Value()[1]) * (end.Value()[1] - begin.Value()[1]); if (lengthSeg == 0) return false; double distsq = crossProduct * crossProduct / lengthSeg; if (distsq > static_cast(m_Tolerance)) { return false; } ++segmentIt; } return true; } }; } #endif otbSpectralAngleDataNodeFeatureFunction.h000066400000000000000000000113101301006202600347520ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralAngleDataNodeFeatureFunction_h #define otbSpectralAngleDataNodeFeatureFunction_h #include "otbDataNodeImageFunction.h" #include "otbBinarySpectralAngleFunctor.h" #include "otbPolyLineImageConstIterator.h" #include "itkLineConstIterator.h" #include "itkVariableLengthVector.h" namespace otb { /** \class SpectralAngleDataNodeFeatureFunction * \brief Compute a spectral angle based feature alongside a * datanode. * * This function compute a spectral angle alongside a datanode. * The feature is the mean spectral angle regarding a * reference pixel alongside the tested datanode. * * The output has three elements: * - #0: mean spectral angle of a neighborhood around the datanode, weighted to fit in [0, 1] interval * - #1: accumulator of the spectral angle alongside the datanode * - #2: number of visited pixel * * \ingroup Functions * \sa DataNodeImageFunction * \sa NDVIDataNodeFeatureFunction * * \ingroup OTBVectorDataManipulation */ template < class TImage, class TCoordRep = double, class TPrecision = double > class ITK_EXPORT SpectralAngleDataNodeFeatureFunction : public DataNodeImageFunction, TCoordRep, TPrecision> { public: /** Standard class typedefs. */ typedef SpectralAngleDataNodeFeatureFunction Self; typedef DataNodeImageFunction, TCoordRep, TPrecision> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SpectralAngleDataNodeFeatureFunction, DataNodeImageFunction); /** Some typedefs. */ typedef typename Superclass::DataNodeType DataNodeType; typedef typename DataNodeType::LineType LineType; typedef typename LineType::Pointer LinePointer; typedef typename LineType::ContinuousIndexType ContinuousIndexType; typedef typename LineType::VertexListConstIteratorType VertexListConstIteratorType; typedef TImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType ScalarRealType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::IndexValueType IndexValueType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; typedef itk::VariableLengthVector ReferencePixelType; typedef PolyLineImageConstIterator ImageLineIteratorType; typedef itk::LineConstIterator LineIteratorType; typedef Functor::BinarySpectralAngleFunctor SpectralAngleFunctorType; typedef std::pair IndexPairType; typedef std::vector OutputType; OutputType Evaluate( const DataNodeType& node ) const ITK_OVERRIDE; /** Set/Get methods */ itkGetConstMacro(RefPixel, PixelType); itkSetMacro(RefPixel, PixelType); itkGetConstMacro(Radius, unsigned int); itkSetMacro(Radius, unsigned int); protected: SpectralAngleDataNodeFeatureFunction(); ~SpectralAngleDataNodeFeatureFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SpectralAngleDataNodeFeatureFunction(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** SpectralAngle Functor & ReferencePixel*/ ReferencePixelType m_RefPixel; SpectralAngleFunctorType m_SpectralAngleFunctor; /** Neighborhood radius */ unsigned int m_Radius; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbSpectralAngleDataNodeFeatureFunction.txx" #endif #endif otbSpectralAngleDataNodeFeatureFunction.txx000066400000000000000000000142131301006202600353530ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralAngleDataNodeFeatureFunction_txx #define otbSpectralAngleDataNodeFeatureFunction_txx #include "otbSpectralAngleDataNodeFeatureFunction.h" namespace otb { /** * Constructor */ template SpectralAngleDataNodeFeatureFunction::SpectralAngleDataNodeFeatureFunction() : m_Radius(2) { //Example for QuickBird images (on a specific image) m_RefPixel.SetSize(4); m_RefPixel.SetElement(0, 252.284); m_RefPixel.SetElement(1, 357.3); m_RefPixel.SetElement(2, 232.644); m_RefPixel.SetElement(3, 261.558); } /** * Standard "PrintSelf" method */ template void SpectralAngleDataNodeFeatureFunction::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Reference Pixel: " << m_RefPixel << std::endl; } template typename SpectralAngleDataNodeFeatureFunction::OutputType SpectralAngleDataNodeFeatureFunction< TImage, TCoordRep, TPrecision>::Evaluate(const DataNodeType& node) const { // TODO faire avce un ikk const typename ImageLineIteratorType::PathType* path; switch (node.GetNodeType()) { case FEATURE_POINT: { itkExceptionMacro(<< "This DataNode type is not handle yet"); break; } case FEATURE_LINE: { path = node.GetLine(); break; } case FEATURE_POLYGON: { path = node.GetPolygonExteriorRing(); break; } default: { itkExceptionMacro(<< "This DataNode type is not handle yet"); break; } } std::vector > splitedLineIdNeigh; std::vector > splitedLineIdCentral; // Split line and polygon into segment (ie. line with two vertex VertexListConstIteratorType it1 = path->GetVertexList()->Begin(); VertexListConstIteratorType it2 = path->GetVertexList()->Begin(); VertexListConstIteratorType itStop = path->GetVertexList()->End(); ++it2; if (it2 == itStop) { itkExceptionMacro(<< "Invalid DataNode, must at least contain two points"); } while (it1 != itStop && it2 != itStop) { IndexType id1, id2; id1[0] = static_cast (it1.Value()[0]); id1[1] = static_cast (it1.Value()[1]); id2[0] = static_cast (it2.Value()[0]); id2[1] = static_cast (it2.Value()[1]); // Compute the direction of the current line itk::Vector direction; direction[0] = it2.Value()[0] - it1.Value()[0]; direction[1] = it2.Value()[1] - it1.Value()[1]; direction.Normalize(); // Compute the orthogonal direction of the current line itk::Vector orthogonalDirection; orthogonalDirection[0] = direction[1]; orthogonalDirection[1] = -direction[0]; splitedLineIdCentral.push_back(IndexPairType(id1, id2)); for (unsigned int j = 1; j <= m_Radius; ++j) { IndexType shift11, shift12; shift11[0] = id1[0] - j * orthogonalDirection[0]; shift11[1] = id1[1] - j * orthogonalDirection[1]; shift12[0] = id1[0] + j * orthogonalDirection[0]; shift12[1] = id1[1] + j * orthogonalDirection[1]; IndexType shift21, shift22; shift21[0] = id2[0] - j * orthogonalDirection[0]; shift21[1] = id2[1] - j * orthogonalDirection[1]; shift22[0] = id2[0] + j * orthogonalDirection[0]; shift22[1] = id2[1] + j * orthogonalDirection[1]; splitedLineIdCentral.push_back(IndexPairType(shift11, shift21)); splitedLineIdCentral.push_back(IndexPairType(shift12, shift22)); } ++it1; ++it2; } // in FEATURE_POLYGON case, first point appears twice (first vertex and last vertew, thus we create a line of 1 point...) if (node.GetNodeType() == FEATURE_POLYGON) { splitedLineIdCentral.pop_back(); } double centralAccSpectralAngle = 0.; //double centralAccSpectralAngleSecondOrder = 0.; double centralNbVisitedPixel = 0.; for (unsigned int i = 0; i < splitedLineIdCentral.size(); ++i) { LineIteratorType lineIt(this->GetInputImage(), splitedLineIdCentral[i].first, splitedLineIdCentral[i].second); lineIt.GoToBegin(); while (!lineIt.IsAtEnd()) { if (this->IsInsideBuffer(lineIt.GetIndex())) { PixelType currPixel = this->GetInputImage()->GetPixel( lineIt.GetIndex() ); double angle = m_SpectralAngleFunctor(currPixel, this->GetRefPixel()); centralAccSpectralAngle += angle; //centralAccSpectralAngleSecondOrder += angle * angle; centralNbVisitedPixel += 1; } ++lineIt; } } OutputType output; double meanCentral = 0.; //double stddevCentral = 0.; if (centralNbVisitedPixel != 0.) { meanCentral = static_cast (centralAccSpectralAngle) / centralNbVisitedPixel; //stddevCentral = vcl_sqrt( centralAccSpectralAngleSecondOrder/centralNbVisitedPixel - meanCentral*meanCentral ); } if (meanCentral == 0.) { output.push_back(static_cast (0.)); } else { // Compute the descriptor here // meanCentral is in [0, pi] // We need a descriptor in [0 1] double descriptor = meanCentral / otb::CONST_PI; output.push_back(static_cast( descriptor )); } output.push_back(static_cast (centralAccSpectralAngle)); output.push_back(static_cast (centralNbVisitedPixel)); return output; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbVectorDataAdapter.h000066400000000000000000000071021301006202600312240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataAdapter_h #define otbVectorDataAdapter_h #include "otbVectorDataToVectorDataFilter.h" namespace otb { /** \class VectorDataAdapter * \brief Helper class to convert the vector data to generic type * * * \ingroup OTBVectorDataManipulation */ template class ITK_EXPORT VectorDataAdapter : public otb::VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataAdapter Self; typedef otb::VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataAdapter, VectorDataToVectorDataFilter); typedef TInputVectorData InputVectorDataType; typedef TOutputVectorData OutputVectorDataType; typedef typename OutputVectorDataType::DataNodeType OutputDataNodeType; typedef typename InputVectorDataType::DataNodeType InputDataNodeType; typedef typename InputDataNodeType::PointType InputPointType; typedef typename InputDataNodeType::LineType InputLineType; typedef typename InputDataNodeType::PolygonType InputPolygonType; typedef typename InputDataNodeType::PolygonListType InputPolygonListType; typedef typename InputLineType::Pointer InputLinePointerType; typedef typename InputPolygonType::Pointer InputPolygonPointerType; typedef typename InputPolygonListType::Pointer InputPolygonListPointerType; typedef typename OutputDataNodeType::PointType OutputPointType; typedef typename OutputDataNodeType::LineType OutputLineType; typedef typename OutputDataNodeType::PolygonType OutputPolygonType; typedef typename OutputDataNodeType::PolygonListType OutputPolygonListType; typedef typename OutputLineType::Pointer OutputLinePointerType; typedef typename OutputPolygonType::Pointer OutputPolygonPointerType; typedef typename OutputPolygonListType::Pointer OutputPolygonListPointerType; protected: VectorDataAdapter() {}; ~VectorDataAdapter() ITK_OVERRIDE {} OutputPointType ProcessPoint(InputPointType point) const ITK_OVERRIDE; OutputLinePointerType ProcessLine(InputLinePointerType line) const ITK_OVERRIDE; OutputPolygonPointerType ProcessPolygon(InputPolygonPointerType polygon) const ITK_OVERRIDE; OutputPolygonListPointerType ProcessPolygonList(InputPolygonListPointerType polygonList) const ITK_OVERRIDE; private: VectorDataAdapter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataAdapter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbVectorDataAdapter.txx000066400000000000000000000072531301006202600316270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataAdapterFilter_txx #define otbVectorDataAdapterFilter_txx #include "otbVectorDataAdapter.h" namespace otb { /** * Convert point */ template typename VectorDataAdapter::OutputPointType VectorDataAdapter ::ProcessPoint(InputPointType pointCoord) const { OutputPointType point; point[0] = pointCoord[0]; point[1] = pointCoord[1]; if (OutputPointType::PointDimension == 3) { point[2] = pointCoord[2]; } return point; } /** * Convert line */ template typename VectorDataAdapter::OutputLinePointerType VectorDataAdapter ::ProcessLine(InputLinePointerType line) const { typedef typename InputLineType::VertexListType::ConstPointer VertexListConstPointerType; typedef typename InputLineType::VertexListConstIteratorType VertexListConstIteratorType; VertexListConstPointerType vertexList = line->GetVertexList(); VertexListConstIteratorType it = vertexList->Begin(); typename OutputLineType::Pointer newLine = OutputLineType::New(); while (it != vertexList->End()) { typename OutputLineType::VertexType index; typename InputLineType::VertexType pointCoord = it.Value(); index[0] = pointCoord[0]; index[1] = pointCoord[1]; // fixme handle 2.5D ? newLine->AddVertex(index); ++it; } return newLine; } /** * Convert polygon */ template typename VectorDataAdapter::OutputPolygonPointerType VectorDataAdapter ::ProcessPolygon(InputPolygonPointerType polygon) const { typedef typename InputPolygonType::VertexListType::ConstPointer VertexListConstPointerType; typedef typename InputPolygonType::VertexListConstIteratorType VertexListConstIteratorType; VertexListConstPointerType vertexList = polygon->GetVertexList(); VertexListConstIteratorType it = vertexList->Begin(); typename OutputPolygonType::Pointer newPolygon = OutputPolygonType::New(); while (it != vertexList->End()) { typename OutputPolygonType::VertexType index; typename InputPolygonType::VertexType pointCoord = it.Value(); index[0] = pointCoord[0]; index[1] = pointCoord[1]; // fixme handle 2.5D ? newPolygon->AddVertex(index); ++it; } return newPolygon; } /** * Convert polygon list */ template typename VectorDataAdapter::OutputPolygonListPointerType VectorDataAdapter ::ProcessPolygonList(InputPolygonListPointerType polygonList) const { OutputPolygonListPointerType newPolygonList = OutputPolygonListType::New(); for (typename InputPolygonListType::ConstIterator it = polygonList->Begin(); it != polygonList->End(); ++it) { newPolygonList->PushBack(this->ProcessPolygon(it.Get())); } return newPolygonList; } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbVectorDataExtractROI.h000066400000000000000000000131451301006202600316340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataExtractROI_h #define otbVectorDataExtractROI_h #include "otbVectorDataToVectorDataFilter.h" #include "otbRemoteSensingRegion.h" #include "otbDEMHandler.h" #include "itkMacro.h" #include "itkPreOrderTreeIterator.h" namespace otb { /** \class VectorDataExtractROI * \brief Extract a subset of a Vector Data based on location * * The region to extract is specified by a otb::RemoteSensingRegion * object. This region contains its own projection reference that may be * different from the projection of the vector data. * * The projection of the vector data will not be modified by this filter * if you need to change the projection, refer to otb::VectorDataProjectionFilter * * \note Parameter to this class for input and outputs are vectorData * * \sa RemoteSensingRegion * \sa VectorDataProjectionFilter * * \ingroup VectorDataFilter * * \example Projections/VectorDataExtractROIExample.cxx * * \ingroup OTBVectorDataManipulation */ template class ITK_EXPORT VectorDataExtractROI : public VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataExtractROI Self; typedef VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataExtractROI, VectorDataToVectorDataFilter); /** Image type information*/ typedef TVectorData VectorDataType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef typename VectorDataType::DataTreeType DataTreeType; typedef typename DataNodeType::PolygonPointerType PolygonPointerType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename DataNodeType::LineType LineType; typedef typename DataNodeType::LinePointerType LinePointerType; typedef typename DataNodeType::PointType PointType; /** Need Vertex and Vertex List Type*/ typedef typename PolygonType::VertexType VertexType; typedef typename PolygonType::VertexListType VertexListType; typedef typename PolygonType::VertexListPointer VertexListPointer; /** TODO : automate the dimension of the region*/ typedef otb::RemoteSensingRegion RegionType; typedef typename RegionType::IndexType IndexType; typedef typename RegionType::SizeType SizeType; typedef itk::Point ProjPointType; typedef itk::PreOrderTreeIterator InputTreeIteratorType; typedef typename VectorDataType::DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename InternalTreeNodeType::ChildrenListType ChildrenListType; /** Method to Set/Get the Region of intereset*/ void SetRegion(const RegionType& region) { m_ROI = region; } const RegionType& GetRegion() {return m_ROI; } protected: VectorDataExtractROI(); ~VectorDataExtractROI() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Method to compare the projection embedded in the cartoRegion And the the InputVectorData*/ virtual void CompareInputAndRegionProjection(); /** Method to project from carto reference to Geo axis*/ virtual void ProjectRegionToInputVectorProjection(); /** Improve the Projected roi*/ virtual RegionType ComputeVertexListBoundingRegion(typename VertexListType::ConstPointer vertexlist); /** Method to transform itk::Point to itk::ContinuousIndex*/ virtual VertexType PointToContinuousIndex(ProjPointType point); /** Prototype of the generate data method*/ void GenerateData(void) ITK_OVERRIDE; /** Method to check if the polygon Bounding Box ha ve a non-null intersection with the ROI*/ virtual bool IsPolygonIntersectionNotNull(PolygonPointerType polygon); /** Method to check if the line Bounding Box ha ve a non-null intersection with the ROI*/ virtual bool IsLineIntersectionNotNull(LinePointerType line); virtual void ProcessNode(InternalTreeNodeType * source, InternalTreeNodeType * destination); using Superclass::ProcessNode; private: VectorDataExtractROI(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented int CounterClockWise(PointType firstPoint, PointType secondPoint, PointType thirdPoint); bool IsSegmentIntersectSegment(LinePointerType segmentLineAB, LinePointerType segmentLineCD); bool m_ProjectionNeeded; RegionType m_ROI; RegionType m_GeoROI; unsigned int m_Kept; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataExtractROI.txx" #endif #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbVectorDataExtractROI.txx000066400000000000000000000406411301006202600322310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataExtractROI_txx #define otbVectorDataExtractROI_txx #include "otbVectorDataExtractROI.h" #include "otbGenericMapProjection.h" #include "itkIdentityTransform.h" #include "otbGenericRSTransform.h" #include "otbObjectList.h" #include "otbMacro.h" #include "itkProgressReporter.h" #include "itkTimeProbe.h" namespace otb { /** * */ template VectorDataExtractROI ::VectorDataExtractROI() : m_ProjectionNeeded(false), m_ROI(), m_Kept(0) { } /** * */ template void VectorDataExtractROI ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } /** * */ template void VectorDataExtractROI ::GenerateData(void) { this->AllocateOutputs(); typename VectorDataType::ConstPointer inputPtr = this->GetInput(); typename VectorDataType::Pointer outputPtr = this->GetOutput(); // Find out the projection needed if (!inputPtr->GetProjectionRef().empty()) outputPtr->SetProjectionRef(inputPtr->GetProjectionRef()); /** Need to check if it is necessary to project the roi*/ this->CompareInputAndRegionProjection(); /** If Projection of the region is needed, we project on the vectorData coordinate axis*/ if (m_ProjectionNeeded) { otbMsgDevMacro(<< "Reprojecting region in vector data projection"); this->ProjectRegionToInputVectorProjection(); } else { otbMsgDevMacro(<< "Region and vector data projection are similar"); m_GeoROI = m_ROI; } otbMsgDevMacro(<< "ROI: " << this->m_ROI); otbMsgDevMacro(<< "GeoROI: " << this->m_GeoROI); // Retrieve the output tree typename VectorDataType::DataTreePointerType tree = outputPtr->GetDataTree(); // Get the input tree root InternalTreeNodeType * inputRoot = const_cast(inputPtr->GetDataTree()->GetRoot()); // Create the output tree root DataNodePointerType newDataNode = DataNodeType::New(); newDataNode->SetNodeType(inputRoot->Get()->GetNodeType()); newDataNode->SetNodeId(inputRoot->Get()->GetNodeId()); typename InternalTreeNodeType::Pointer outputRoot = InternalTreeNodeType::New(); outputRoot->Set(newDataNode); tree->SetRoot(outputRoot); m_Kept = 0; // Start recursive processing itk::TimeProbe chrono; chrono.Start(); ProcessNode(inputRoot, outputRoot); chrono.Stop(); otbMsgDevMacro( << "VectorDataExtractROI: " << m_Kept << " Features processed in " << chrono.GetMean() << " seconds."); } /*End GenerateData()*/ template void VectorDataExtractROI ::ProcessNode(InternalTreeNodeType * source, InternalTreeNodeType * destination) { // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // For each child for (typename ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { typename InternalTreeNodeType::Pointer newContainer; DataNodePointerType dataNode = (*it)->Get(); DataNodePointerType newDataNode = DataNodeType::New(); newDataNode->SetNodeType(dataNode->GetNodeType()); newDataNode->SetNodeId(dataNode->GetNodeId()); newDataNode->SetMetaDataDictionary(dataNode->GetMetaDataDictionary()); switch (dataNode->GetNodeType()) { case ROOT: { newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); ++m_Kept; break; } case DOCUMENT: { newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; ProcessNode((*it), newContainer); break; } case FOLDER: { newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; ProcessNode((*it), newContainer); break; } case FEATURE_POINT: { if (m_GeoROI.IsInside(this->PointToContinuousIndex(dataNode->GetPoint()))) { newDataNode->SetPoint(dataNode->GetPoint()); newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; } break; } case FEATURE_LINE: { if (this->IsLineIntersectionNotNull(dataNode->GetLine())) { newDataNode->SetLine(dataNode->GetLine()); newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; } break; } case FEATURE_POLYGON: { if (this->IsPolygonIntersectionNotNull(dataNode->GetPolygonExteriorRing())) { newDataNode->SetPolygonExteriorRing(dataNode->GetPolygonExteriorRing()); newDataNode->SetPolygonInteriorRings(dataNode->GetPolygonInteriorRings()); newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; } break; } case FEATURE_MULTIPOINT: { newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; ProcessNode((*it), newContainer); break; } case FEATURE_MULTILINE: { newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; ProcessNode((*it), newContainer); break; } case FEATURE_MULTIPOLYGON: { newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; ProcessNode((*it), newContainer); break; } case FEATURE_COLLECTION: { newContainer = InternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ++m_Kept; ProcessNode((*it), newContainer); break; } } } } /** * */ template bool VectorDataExtractROI ::IsPolygonIntersectionNotNull(PolygonPointerType polygon) { // Get the VertexList // -2 cause we don't want the last point // which is the same as the first one (closed Ring) for (unsigned int i = 0; iGetVertexList()->Size() - 2; ++i ) { // Get the components of the polygon 2 by 2 VertexType firstVertex; VertexType secondVertex; firstVertex = polygon->GetVertexList()->GetElement(i); secondVertex = polygon->GetVertexList()->GetElement(i+1); // Build a line with each two vertex typename LineType::Pointer line = LineType::New(); line->AddVertex(firstVertex); line->AddVertex(secondVertex); if (this->IsLineIntersectionNotNull(line)) return true; } return false; } /** * */ template bool VectorDataExtractROI ::IsLineIntersectionNotNull(LinePointerType line) { RegionType lineRegion(line->GetBoundingRegion()); // if the line bounding box have a null // intersection with the geoROI // the line and the region do not intersect if (!lineRegion.Crop(m_GeoROI)) { return false; } else { // Get the VertexList for (unsigned int i = 0; iGetVertexList()->Size() -1; ++i ) { // Get the components of the line 2 by 2 VertexType firstVertex; VertexType secondVertex; firstVertex = line->GetVertexList()->GetElement(i); secondVertex = line->GetVertexList()->GetElement(i+1); // ------------------- // Case 1 : Check if one of the two points are in the region PointType firstPoint, secondPoint; firstPoint[0] = firstVertex[0]; firstPoint[1] = firstVertex[1]; secondPoint[0] = secondVertex[0]; secondPoint[1] = secondVertex[1]; if (m_GeoROI.IsInside(this->PointToContinuousIndex(firstPoint)) || m_GeoROI.IsInside(this->PointToContinuousIndex(secondPoint))) { return true; } else { // ------------------- // Case 2 : If any of the point is in the region if (!m_GeoROI.IsInside(this->PointToContinuousIndex(firstPoint)) && !m_GeoROI.IsInside(this->PointToContinuousIndex(secondPoint))) { // Build a line with each two vertex typename LineType::Pointer tempLine = LineType::New(); tempLine->AddVertex(firstVertex); tempLine->AddVertex(secondVertex); // Check if the intersection is not null RegionType region(tempLine->GetBoundingRegion()); if (region.Crop(m_GeoROI)) return true; // ------------------- // TODO : check if the segment cut // one of the region edges } } } } return false; } template bool VectorDataExtractROI ::IsSegmentIntersectSegment(LinePointerType segmentLineAB, LinePointerType segmentLineCD) { PointType vertexA, vertexB, vertexC, vertexD; vertexA = segmentLineAB->GetVertexList()->GetElement(0); vertexB = segmentLineAB->GetVertexList()->GetElement(1); vertexC = segmentLineCD->GetVertexList()->GetElement(0); vertexD = segmentLineCD->GetVertexList()->GetElement(1); int CounterClockWiseValueWithC = CounterClockWise(vertexA, vertexB, vertexC); int CounterClockWiseValueWithD = CounterClockWise(vertexA, vertexB, vertexD); if(CounterClockWiseValueWithC == CounterClockWiseValueWithD) { return false; } int CounterClockWiseValueWithA = CounterClockWise(vertexC, vertexD, vertexA); int CounterClockWiseValueWithB = CounterClockWise(vertexC, vertexD, vertexB); if(CounterClockWiseValueWithA == CounterClockWiseValueWithB) { return false; } return true; } template int VectorDataExtractROI ::CounterClockWise(PointType firstPoint, PointType secondPoint, PointType thirdPoint) { PointType SecondMinusFirstPoint; PointType ThirdMinusFirstPoint; SecondMinusFirstPoint = secondPoint - firstPoint; ThirdMinusFirstPoint = thirdPoint - firstPoint; double dX1dY2MinusdY1dX2; dX1dY2MinusdY1dX2 = static_cast( SecondMinusFirstPoint[0]*ThirdMinusFirstPoint[1] - SecondMinusFirstPoint[1]*ThirdMinusFirstPoint[0]); if( dX1dY2MinusdY1dX2 > 0.0) { return 1; } if( dX1dY2MinusdY1dX2 < 0.0) { return -1; } double dX1dX2; double dY1dY2; dX1dX2 = static_cast(SecondMinusFirstPoint[0] * ThirdMinusFirstPoint[0]); dY1dY2 = static_cast(SecondMinusFirstPoint[1] * ThirdMinusFirstPoint[1]); if( (dX1dX2 < 0.0) || (dY1dY2 < 0.0) ) { return -1; } double dX1dX1, dX2dX2, dY1dY1, dY2dY2; dX1dX1 = static_cast(SecondMinusFirstPoint[0] * SecondMinusFirstPoint[0]); dX2dX2 = static_cast(ThirdMinusFirstPoint[0] * ThirdMinusFirstPoint[0]); dY1dY1 = static_cast(SecondMinusFirstPoint[1] * SecondMinusFirstPoint[1]); dY2dY2 = static_cast(ThirdMinusFirstPoint[1] * ThirdMinusFirstPoint[1]); if( (dX1dX1+dY1dY1) < (dX2dX2 + dY2dY2) ) { return 1; } return 0; } /** * CompareInputAndRegionProjection */ template void VectorDataExtractROI ::CompareInputAndRegionProjection() { std::string regionProjection = m_ROI.GetRegionProjection(); std::string inputVectorProjection = this->GetInput()->GetProjectionRef(); //FIXME: the string comparison is not sufficient to say that two //projections are different if (regionProjection == inputVectorProjection) m_ProjectionNeeded = false; else m_ProjectionNeeded = true; } /** * ProjectRegionToInputVectorProjection */ template void VectorDataExtractROI ::ProjectRegionToInputVectorProjection() { /* Use the RS Generic projection */ typedef otb::GenericRSTransform<> GenericRSTransformType; typename GenericRSTransformType::Pointer genericTransform = GenericRSTransformType::New(); /** Set up the projection */ genericTransform->SetInputProjectionRef(m_ROI.GetRegionProjection()); genericTransform->SetInputKeywordList(m_ROI.GetKeywordList()); genericTransform->SetOutputProjectionRef(this->GetInput()->GetProjectionRef()); const itk::MetaDataDictionary& inputDict = this->GetInput()->GetMetaDataDictionary(); genericTransform->SetOutputDictionary(inputDict); genericTransform->SetOutputOrigin(this->GetInput()->GetOrigin()); genericTransform->SetOutputSpacing(this->GetInput()->GetSpacing()); genericTransform->InstantiateTransform(); otbMsgDevMacro(<< genericTransform); typename VertexListType::Pointer regionCorners = VertexListType::New(); ProjPointType point1, point2, point3, point4; /** Compute the extremities of the region*/ point1[0] = m_ROI.GetOrigin()[0]; point1[1] = m_ROI.GetOrigin()[1]; point2[0] = m_ROI.GetOrigin()[0] + m_ROI.GetSize()[0]; point2[1] = m_ROI.GetOrigin()[1]; point3[0] = m_ROI.GetOrigin()[0] + m_ROI.GetSize()[0]; point3[1] = m_ROI.GetOrigin()[1] + m_ROI.GetSize()[1]; point4[0] = m_ROI.GetOrigin()[0]; point4[1] = m_ROI.GetOrigin()[1] + m_ROI.GetSize()[1]; /** Fill the vertex List : First Convert Point To*/ regionCorners->InsertElement(regionCorners->Size(), this->PointToContinuousIndex(genericTransform->TransformPoint(point1))); regionCorners->InsertElement(regionCorners->Size(), this->PointToContinuousIndex(genericTransform->TransformPoint(point2))); regionCorners->InsertElement(regionCorners->Size(), this->PointToContinuousIndex(genericTransform->TransformPoint(point3))); regionCorners->InsertElement(regionCorners->Size(), this->PointToContinuousIndex(genericTransform->TransformPoint(point4))); /** Due to The projection : the Projected ROI can be rotated */ m_GeoROI = this->ComputeVertexListBoundingRegion(regionCorners.GetPointer()); m_GeoROI.SetRegionProjection(this->GetInput()->GetProjectionRef()); } /** * itk::Point to ContinuousIndex */ template typename VectorDataExtractROI ::VertexType VectorDataExtractROI ::PointToContinuousIndex(ProjPointType point) { VertexType vertex; vertex[0] = point[0]; vertex[1] = point[1]; return vertex; } /** * ComputeVertexListBoundingRegion */ template typename VectorDataExtractROI ::RegionType VectorDataExtractROI ::ComputeVertexListBoundingRegion(typename VertexListType::ConstPointer vertexlist) { double x = 0., y = 0.; IndexType index; IndexType maxId; SizeType size; index.Fill(0.); maxId.Fill(0.); size.Fill(0.); typename VertexListType::ConstIterator it = vertexlist->Begin(); if (vertexlist->Size() > 0) { x = static_cast(it.Value()[0]); y = static_cast(it.Value()[1]); index[0] = x; index[1] = y; maxId[0] = x; maxId[1] = y; ++it; while (it != vertexlist->End()) { x = static_cast(it.Value()[0]); y = static_cast(it.Value()[1]); // Index search if (x < index[0]) { index[0] = x; } if (y > index[1]) { index[1] = y; } // Max Id search for size computation if (x > maxId[0]) { maxId[0] = x; } if (y < maxId[1]) { maxId[1] = y; } ++it; } size[0] = maxId[0] - index[0]; size[1] = maxId[1] - index[1]; } RegionType region; region.SetSize(size); region.SetOrigin(index); return region; } } // end namespace otb #endif otbVectorDataToRandomLineGenerator.h000066400000000000000000000105331301006202600337710ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToRandomLineGenerator_h #define otbVectorDataToRandomLineGenerator_h #include "otbVectorDataSource.h" #include "otbVectorData.h" #include "itkPreOrderTreeIterator.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { /** \class VectorDataToRandomLineGenerator * \brief Produces a VectorData Containing Random Lines * * This generator produces a unique vector data containing * randomly generated lines inside polygons contained in the input * vectorData. * * The user can set the range of point per line through * SetMinLineSize() and SetMaxLineSize(). * The generated line number per polygon can be set through * SetNumberOfOutputLine * * \sa VectorDataSource * * \ingroup OTBVectorDataManipulation */ template class ITK_EXPORT VectorDataToRandomLineGenerator : public VectorDataSource { public: /** Standard class typedefs */ typedef VectorDataToRandomLineGenerator Self; typedef VectorDataSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToRandomLineGenerator, VectorDataSource); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::PolygonType::RegionType RegionType; typedef typename DataNodeType::PointType PointType; typedef typename DataNodeType::LineType LineType; typedef typename DataNodeType::LineType::VertexType VertexType; typedef typename std::vector PointVectorType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; /** Connects the VectorData from which the extend will be extracted. */ using Superclass::SetInput; void SetInput(const VectorDataType *); const VectorDataType * GetInput() const; itkGetConstMacro(NumberOfOutputLine, unsigned int); itkSetMacro(NumberOfOutputLine, unsigned int); itkGetConstMacro(MinLineSize, unsigned int); itkSetMacro(MinLineSize, unsigned int); itkGetConstMacro(MaxLineSize, unsigned int); itkSetMacro(MaxLineSize, unsigned int); /** Set the seed for random number generator */ void SetSeed(unsigned int seed) { m_RandomGenerator->SetSeed(seed); m_RandomSizeGenerator->SetSeed(seed); } protected: VectorDataToRandomLineGenerator(); ~VectorDataToRandomLineGenerator() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Triggers the Computation of the sample list */ void GenerateData(void) ITK_OVERRIDE; PointVectorType RandomPointsGenerator(DataNodeType * node); private: VectorDataToRandomLineGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string GetNextID() { std::ostringstream oss; oss << m_CurrentID++; return oss.str(); } RandomGeneratorType::Pointer m_RandomGenerator; RandomGeneratorType::Pointer m_RandomSizeGenerator; unsigned int m_NumberOfOutputLine; unsigned int m_MinLineSize; unsigned int m_MaxLineSize; unsigned int m_CurrentID; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToRandomLineGenerator.txx" #endif #endif otbVectorDataToRandomLineGenerator.txx000066400000000000000000000116001301006202600343610ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToRandomLineGenerator_txx #define otbVectorDataToRandomLineGenerator_txx #include "otbVectorDataToRandomLineGenerator.h" #include "otbMath.h" namespace otb { template VectorDataToRandomLineGenerator ::VectorDataToRandomLineGenerator() : m_NumberOfOutputLine(100), m_MinLineSize(2), m_MaxLineSize(10), m_CurrentID(0) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_RandomGenerator = RandomGeneratorType::GetInstance(); m_RandomSizeGenerator = RandomGeneratorType::GetInstance(); } template void VectorDataToRandomLineGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "Required Number of Output Line: " << m_NumberOfOutputLine << std::endl; } template void VectorDataToRandomLineGenerator ::SetInput(const VectorDataType * vectorData) { this->Superclass::SetNthInput(0, const_cast(vectorData)); } template const TVectorData * VectorDataToRandomLineGenerator ::GetInput() const { return static_cast(this->Superclass::GetInput(0)); } template typename VectorDataToRandomLineGenerator ::PointVectorType VectorDataToRandomLineGenerator ::RandomPointsGenerator(DataNodeType * node) { // Output PointVectorType vPoint; // Gathering Information RegionType generatorRegion = node->GetPolygonExteriorRing()->GetBoundingRegion(); typename RegionType::SizeType generatorRegionSize = generatorRegion.GetSize(); typename RegionType::IndexType generatorRegionIndex = generatorRegion.GetIndex(); //typename RegionType::IndexType generatorRegionOrigin = generatorRegion.GetOrigin(); // Generation PointType rangeMin, rangeMax; for(unsigned int dim = 0; dim < 2; ++dim) { rangeMin[dim] = generatorRegionIndex[dim]; rangeMax[dim] = generatorRegionIndex[dim] + generatorRegionSize[dim]; } unsigned int nbPoint = this->m_RandomSizeGenerator->GetUniformVariate(this->GetMinLineSize(), this->GetMaxLineSize()); while(nbPoint > 0) { VertexType candidate; for(unsigned int dim = 0; dim < 2; ++dim) { candidate[dim] = this->m_RandomGenerator->GetUniformVariate(rangeMin[dim], rangeMax[dim]); } if(node->GetPolygonExteriorRing()->IsInside(candidate)) { PointType point; point[0] = candidate[0]; point[1] = candidate[1]; vPoint.push_back(point); nbPoint --; } } return vPoint; } template void VectorDataToRandomLineGenerator ::GenerateData() { this->GetOutput()->SetMetaDataDictionary(this->GetInput()->GetMetaDataDictionary()); // Retrieving root node typename DataNodeType::Pointer root = this->GetOutput()->GetDataTree()->GetRoot()->Get(); // Create the document node typename DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(document, root); // Iterates through the polygon features and generates random Lines inside the polygon typename VectorDataType::ConstPointer vectorData = static_cast(this->GetInput()); TreeIteratorType itVector(vectorData->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPolygonFeature()) { for(unsigned int i=0; iGetNumberOfOutputLine(); ++i) { typename DataNodeType::Pointer currentGeometry = DataNodeType::New(); currentGeometry->SetNodeId(this->GetNextID()); currentGeometry->SetNodeType(otb::FEATURE_LINE); typename LineType::Pointer line = LineType::New(); currentGeometry->SetLine(line); PointVectorType vPoints = RandomPointsGenerator(itVector.Get()); for (typename PointVectorType::const_iterator it = vPoints.begin(); it != vPoints.end(); ++it) { VertexType vertex; vertex[0] = (*it)[0]; vertex[1] = (*it)[1]; currentGeometry->GetLine()->AddVertex(vertex); } this->GetOutput(0)->GetDataTree()->Add(currentGeometry, document); } } ++itVector; } } } // end namespace otb #endif otbVectorDataToSpecificDescriptionFilterBase.h000066400000000000000000000060221301006202600357620ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToSpecificDescriptionFilterBase_h #define otbVectorDataToSpecificDescriptionFilterBase_h #include "otbVectorDataToVectorDataFilter.h" namespace otb { /** \class VectorDataToSpecificDescriptionFilterBase * \brief Base class for VectorDataToSpecificDescriptionFilters. * * VectorDataToSpecificDescriptionFilterBase is a base class, it is * supposed to be used through a inheriting class. * Input and output are both VectorDatas. Each data node of the * output VectorData contains its score regarding to the associated * descriptors. * * * \ingroup VectorDataFilter * \sa VectorDataToRoadDescriptionFilter * \sa VectorDataToBuildingDescriptionFilter * * \ingroup OTBVectorDataManipulation */ template class ITK_EXPORT VectorDataToSpecificDescriptionFilterBase : public VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataToSpecificDescriptionFilterBase Self; typedef VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToSpecificDescriptionFilterBase, VectorDataToVectorDataFilter); /** Some typedefs. */ typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointer; typedef typename VectorDataType::DataNodeType DataNodeType; typedef itk::DataObject::Pointer DataObjectPointer; typedef itk::DataObject DataObject; /** Support accessors. */ virtual void AddSupport(const itk::DataObject * support, unsigned int idx); const itk::DataObject * GetSupport(unsigned int idx); protected: /** Constructor */ VectorDataToSpecificDescriptionFilterBase(); /** Destructor */ ~VectorDataToSpecificDescriptionFilterBase() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: VectorDataToSpecificDescriptionFilterBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToSpecificDescriptionFilterBase.txx" #endif #endif otbVectorDataToSpecificDescriptionFilterBase.txx000066400000000000000000000040541301006202600363610ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToSpecificDescriptionFilterBase_txx #define otbVectorDataToSpecificDescriptionFilterBase_txx #include "otbVectorDataToSpecificDescriptionFilterBase.h" namespace otb { // Constructor template VectorDataToSpecificDescriptionFilterBase ::VectorDataToSpecificDescriptionFilterBase() { this->SetNumberOfRequiredInputs(1); } template void VectorDataToSpecificDescriptionFilterBase ::AddSupport(const DataObject * support, unsigned int idx) { // Process object is not const-correct so the const_cast is required here // input(0) is dedicated to the input vector data, support #i is // stored in input(i+1) this->itk::ProcessObject::SetNthInput(idx+1, const_cast(support)); } template const typename VectorDataToSpecificDescriptionFilterBase ::DataObject * VectorDataToSpecificDescriptionFilterBase ::GetSupport(unsigned int idx) { if (this->GetNumberOfInputs() < idx+2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(idx+1)); } // PrintSelf Method template void VectorDataToSpecificDescriptionFilterBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os<GetNumberOfInputs())-1< class ITK_EXPORT VectorDataToVectorDataFilter : public VectorDataSource { public: /** Standard class typedefs. */ typedef VectorDataToVectorDataFilter Self; typedef VectorDataSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToVectorDataFilter, VectorDataSource); /** Some typedefs. */ typedef TInputVectorData InputVectorDataType; typedef TOutputVectorData OutputVectorDataType; typedef typename TInputVectorData::ConstPointer InputVectorDataPointer; typedef typename TOutputVectorData::Pointer OutputVectorDataPointer; typedef typename InputVectorDataType::DataNodeType InputDataNodeType; typedef typename OutputVectorDataType::DataNodeType OutputDataNodeType; typedef typename InputVectorDataType::DataTreeType::TreeNodeType InputInternalTreeNodeType; typedef typename OutputVectorDataType::DataTreeType::TreeNodeType OutputInternalTreeNodeType; typedef typename InputDataNodeType::PointType InputPointType; typedef typename InputDataNodeType::LineType InputLineType; typedef typename InputDataNodeType::PolygonType InputPolygonType; typedef typename InputDataNodeType::PolygonListType InputPolygonListType; typedef typename InputLineType::Pointer InputLinePointerType; typedef typename InputPolygonType::Pointer InputPolygonPointerType; typedef typename InputPolygonListType::Pointer InputPolygonListPointerType; typedef typename OutputDataNodeType::PointType OutputPointType; typedef typename OutputDataNodeType::LineType OutputLineType; typedef typename OutputDataNodeType::PolygonType OutputPolygonType; typedef typename OutputDataNodeType::PolygonListType OutputPolygonListType; typedef typename OutputLineType::Pointer OutputLinePointerType; typedef typename OutputPolygonType::Pointer OutputPolygonPointerType; typedef typename OutputPolygonListType::Pointer OutputPolygonListPointerType; typedef itk::DataObject::Pointer DataObjectPointer; using Superclass::SetInput; virtual void SetInput(const InputVectorDataType *input); const InputVectorDataType * GetInput(void); protected: /** Constructor */ VectorDataToVectorDataFilter(); /** Destructor */ ~VectorDataToVectorDataFilter() ITK_OVERRIDE {} virtual OutputPointType ProcessPoint(InputPointType itkNotUsed(point)) const { itkExceptionMacro( << "Subclass should reimplement this method"); } virtual OutputLinePointerType ProcessLine(InputLinePointerType itkNotUsed(line)) const { itkExceptionMacro( << "Subclass should reimplement this method"); } virtual OutputPolygonPointerType ProcessPolygon(InputPolygonPointerType itkNotUsed(polygon)) const { itkExceptionMacro( << "Subclass should reimplement this method"); } virtual OutputPolygonListPointerType ProcessPolygonList(InputPolygonListPointerType itkNotUsed(polygonList)) const { itkExceptionMacro( << "Subclass should reimplement this method"); } void GenerateOutputInformation(void) ITK_OVERRIDE; void GenerateData(void) ITK_OVERRIDE; /** Go through the vector data tree and process the nodes */ virtual void ProcessNode(InputInternalTreeNodeType * source, OutputInternalTreeNodeType * destination) const; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: VectorDataToVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/include/otbVectorDataToVectorDataFilter.txx000066400000000000000000000172231301006202600337520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToVectorDataFilter_txx #define otbVectorDataToVectorDataFilter_txx #include "otbVectorDataToVectorDataFilter.h" #include "itkProgressReporter.h" #include "otbDataNode.h" #include "itkTimeProbe.h" namespace otb { /** * Constructor */ template VectorDataToVectorDataFilter ::VectorDataToVectorDataFilter() { this->SetNumberOfRequiredInputs(1); } template void VectorDataToVectorDataFilter ::SetInput(const InputVectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template const typename VectorDataToVectorDataFilter::InputVectorDataType * VectorDataToVectorDataFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template void VectorDataToVectorDataFilter ::GenerateOutputInformation(void) { Superclass::GenerateOutputInformation(); OutputVectorDataPointer output = this->GetOutput(); typename InputVectorDataType::ConstPointer input = this->GetInput(); output->SetMetaDataDictionary(input->GetMetaDataDictionary()); } /** * GenerateData Performs the coordinate conversion for each element in the tree */ template void VectorDataToVectorDataFilter ::GenerateData(void) { this->AllocateOutputs(); InputVectorDataPointer inputPtr = this->GetInput(); OutputVectorDataPointer outputPtr = this->GetOutput(); typedef typename OutputVectorDataType::DataTreePointerType OutputDataTreePointerType; OutputDataTreePointerType tree = outputPtr->GetDataTree(); // Get the input tree root InputInternalTreeNodeType * inputRoot = const_cast(inputPtr->GetDataTree()->GetRoot()); // Create the output tree root typedef typename OutputVectorDataType::DataNodePointerType OutputDataNodePointerType; OutputDataNodePointerType newDataNode = OutputDataNodeType::New(); newDataNode->SetNodeType(inputRoot->Get()->GetNodeType()); newDataNode->SetNodeId(inputRoot->Get()->GetNodeId()); typename OutputInternalTreeNodeType::Pointer outputRoot = OutputInternalTreeNodeType::New(); outputRoot->Set(newDataNode); tree->SetRoot(outputRoot); // Start recursive processing itk::TimeProbe chrono; chrono.Start(); this->ProcessNode(inputRoot, outputRoot); chrono.Stop(); otbMsgDevMacro(<< "VectoDataProjectionFilter: features Processed in " << chrono.GetMean() << " seconds."); } template void VectorDataToVectorDataFilter ::ProcessNode(InputInternalTreeNodeType * source, OutputInternalTreeNodeType * destination) const { // Get the children list from the input node typedef typename InputInternalTreeNodeType::ChildrenListType InputChildrenListType; InputChildrenListType children = source->GetChildrenList(); // For each child typename InputChildrenListType::const_iterator it = children.begin(); while (it != children.end()) { typename OutputInternalTreeNodeType::Pointer newContainer; typedef typename InputVectorDataType::DataNodePointerType InputDataNodePointerType; typedef typename OutputVectorDataType::DataNodePointerType OutputDataNodePointerType; // Copy input DataNode info InputDataNodePointerType dataNode = (*it)->Get(); OutputDataNodePointerType newDataNode = OutputDataNodeType::New(); newDataNode->SetNodeType(dataNode->GetNodeType()); newDataNode->SetNodeId(dataNode->GetNodeId()); newDataNode->SetMetaDataDictionary(dataNode->GetMetaDataDictionary()); switch (dataNode->GetNodeType()) { case ROOT: { newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); break; } case DOCUMENT: { newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); break; } case FOLDER: { newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); break; } case FEATURE_POINT: { newDataNode->SetPoint(this->ProcessPoint(dataNode->GetPoint())); newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); break; } case FEATURE_LINE: { newDataNode->SetLine(this->ProcessLine(dataNode->GetLine())); newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); break; } case FEATURE_POLYGON: { newDataNode->SetPolygonExteriorRing(this->ProcessPolygon(dataNode->GetPolygonExteriorRing())); newDataNode->SetPolygonInteriorRings(this->ProcessPolygonList(dataNode->GetPolygonInteriorRings())); newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); break; } case FEATURE_MULTIPOINT: { newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); break; } case FEATURE_MULTILINE: { newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); break; } case FEATURE_MULTIPOLYGON: { newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); break; } case FEATURE_COLLECTION: { newContainer = OutputInternalTreeNodeType::New(); newContainer->Set(newDataNode); destination->AddChild(newContainer); ProcessNode((*it), newContainer); break; } } ++it; } } /** * PrintSelf Method */ template void VectorDataToVectorDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/VectorDataManipulation/otb-module.cmake000066400000000000000000000007741301006202600264470ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes related to the handling of vector data (see also VectorDataBase and VectorDataManipulation modules).") otb_module(OTBVectorDataManipulation DEPENDS OTBCommon OTBITK OTBImageBase OTBImageManipulation OTBOSSIMAdapters OTBObjectList OTBPath OTBTransform OTBVectorDataBase TEST_DEPENDS OTBCommandLineParser OTBImageIO OTBProjection OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/000077500000000000000000000000001301006202600243455ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/CMakeLists.txt000066400000000000000000000130171301006202600271070ustar00rootroot00000000000000otb_module_test() set(OTBVectorDataManipulationTests otbVectorDataManipulationTestDriver.cxx otbDBOverlapDataNodeFeatureFunction.cxx otbVectorDataExtractROI.cxx otbVectorDataToSpecificDescriptionFilterBase.cxx otbVectorDataToVectorDataFilterNew.cxx otbPolygonCompacityFunctor.cxx otbVectorDataToRandomLineGenerator.cxx otbConcatenateVectorDataFilter.cxx otbVectorDataExtractROINew.cxx otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction.cxx ) add_executable(otbVectorDataManipulationTestDriver ${OTBVectorDataManipulationTests}) target_link_libraries(otbVectorDataManipulationTestDriver ${OTBVectorDataManipulation-Test_LIBRARIES}) otb_module_target_label(otbVectorDataManipulationTestDriver) # Tests Declaration otb_add_test(NAME bfTvDBOverlapDataNodeFeatureFunction COMMAND otbVectorDataManipulationTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvDBOverlapDataNodeFeatureFunctionOutput.shp ${TEMP}/bfTvDBOverlapDataNodeFeatureFunctionOutput.shp otbDBOverlapDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_ROADS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_BUILDINGS.shp ${TEMP}/bfTvDBOverlapDataNodeFeatureFunctionOutput.shp 0 ) otb_add_test(NAME bfTuDBOverlapDataNodeFeatureFunctionNew COMMAND otbVectorDataManipulationTestDriver otbDBOverlapDataNodeFeatureFunctionNew ) otb_add_test(NAME coTvVectorDataExtractROI COMMAND otbVectorDataManipulationTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/coVectorDataExtractROIOutput.shp ${TEMP}/coVectorDataExtractROIOutput.shp otbVectorDataExtractROI ${INPUTDATA}/ToulousePoints-examples.shp ${TEMP}/coVectorDataExtractROIOutput.shp 374369.48850211215904 4853951.786124914 # Origin of the RemoteSensingRegion 1000.25 -25000.2 # Size of the Cartoregion ) otb_add_test(NAME coTvVectorDataExtractROI2 COMMAND otbVectorDataManipulationTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/coVectorDataExtractROIOutput2.shp ${TEMP}/coVectorDataExtractROIOutput2.shp otbVectorDataExtractROI ${INPUTDATA}/ToulousePoints-examples.shp ${TEMP}/coVectorDataExtractROIOutput2.shp 374369.48850211215904 4828951.58612491376698 # Origin of the RemoteSensingRegion 1000.25 25000.2 # Size of the Cartoregion ) otb_add_test(NAME fzTuVectorDataToSpecificDescriptionFilterBaseNew COMMAND otbVectorDataManipulationTestDriver otbVectorDataToSpecificDescriptionFilterBaseNew) otb_add_test(NAME coTuVectorDataToVectorDataFilterNew COMMAND otbVectorDataManipulationTestDriver otbVectorDataToVectorDataFilterNew) otb_add_test(NAME bfTvPolygonCompacityFunctor COMMAND otbVectorDataManipulationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/bfPolygonCompacityFunctorTest.txt ${TEMP}/bfPolygonCompacityFunctorTest.txt otbPolygonCompacityFunctor ${INPUTDATA}/polygon.png ${TEMP}/bfPolygonCompacityFunctorTest.txt ) otb_add_test(NAME bfTvVectorDataToRandomLineGenerator COMMAND otbVectorDataManipulationTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvVectorDataToRandomLineGeneratorOutput.shp ${TEMP}/bfTvVectorDataToRandomLineGeneratorOutput.shp otbVectorDataToRandomLineGenerator ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01Polygons.shp ${TEMP}/bfTvVectorDataToRandomLineGeneratorOutput.shp ) otb_add_test(NAME bfTuVectorDataToRandomLineGeneratorNew COMMAND otbVectorDataManipulationTestDriver otbVectorDataToRandomLineGeneratorNew ) otb_add_test(NAME bfTuConcatenateVectorDataFilterNew COMMAND otbVectorDataManipulationTestDriver otbConcatenateVectorDataFilterNew ) otb_add_test(NAME bfTvConcatenateVectorDataFilter COMMAND otbVectorDataManipulationTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/otbConcatenateVectorDataFilter_Output.shp ${TEMP}/otbConcatenateVectorDataFilter_Output.shp otbConcatenateVectorDataFilter -in ${INPUTDATA}/france_coastline.shp ${INPUTDATA}/waterways.shp -out ${TEMP}/otbConcatenateVectorDataFilter_Output.shp ) otb_add_test(NAME coTuVectorDataExtractROINew COMMAND otbVectorDataManipulationTestDriver otbVectorDataExtractROINew) otb_add_test(NAME bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction_Polygon COMMAND otbVectorDataManipulationTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionOutput_Polygon.shp ${TEMP}/bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionOutput_Polygon.shp otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_BUILDINGS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionOutput_Polygon.shp 0 ) otb_add_test(NAME bfTuRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionNew COMMAND otbVectorDataManipulationTestDriver otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionNew ) otb_add_test(NAME bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction_Line COMMAND otbVectorDataManipulationTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionOutput_Line.shp ${TEMP}/bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionOutput_Line.shp otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_ROADS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionOutput_Line.shp 0 ) OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/otbConcatenateVectorDataFilter.cxx000066400000000000000000000051521301006202600331500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbCommandLineArgumentParser.h" // Images #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" // Concatener #include "otbConcatenateVectorDataFilter.h" typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader ReaderType; typedef otb::VectorDataFileWriter WriterType; typedef otb::ConcatenateVectorDataFilter ConcatenateFilterType; int otbConcatenateVectorDataFilterNew (int itkNotUsed(argc), char * itkNotUsed(argv) []) { ConcatenateFilterType::Pointer concatenate = ConcatenateFilterType::New(); return EXIT_SUCCESS; } int otbConcatenateVectorDataFilter (int argc, char * argv[]) { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOptionNParams("--InputVectorDatas","Input VectorDatas to concatenate ", "-in", true); parser->AddOption("--OutputVectorData","Output concatenated VectorData","-out", true); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); parser->ParseCommandLine(argc, argv, parseResult); // Get number of input vectorDatas unsigned int nbInputs = parseResult->GetNumberOfParameters("--InputVectorDatas"); // Instantiate a concatenate filter // Concatenate the vector datas ConcatenateFilterType::Pointer concatenate = ConcatenateFilterType::New(); for (unsigned int idx = 0; idx < nbInputs; ++idx) { // Reader object ReaderType::Pointer reader = ReaderType::New(); //std::cout << << std::endl; reader->SetFileName(parseResult->GetParameterString("--InputVectorDatas", idx )); reader->Update(); concatenate->AddInput(reader->GetOutput()); } // Write the output WriterType::Pointer writer = WriterType::New(); writer->SetFileName(parseResult->GetParameterString("--OutputVectorData")); writer->SetInput(concatenate->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbDBOverlapDataNodeFeatureFunction.cxx000066400000000000000000000101161301006202600337560ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDBOverlapDataNodeFeatureFunction.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" int otbDBOverlapDataNodeFeatureFunctionNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double CoordRepType; typedef double PrecisionType; typedef otb::DBOverlapDataNodeFeatureFunction DataNodeFeaturefunctionType; DataNodeFeaturefunctionType::Pointer DBOverlapFeature = DataNodeFeaturefunctionType::New(); std::cout << DBOverlapFeature<< std::endl; return EXIT_SUCCESS; } int otbDBOverlapDataNodeFeatureFunction(int itkNotUsed(argc), char* argv[]) { const char * inputVD = argv[1]; const char * inputDB = argv[2]; const char * outputVD = argv[3]; int DisplayWarnings = atoi(argv[4]); typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef otb::DBOverlapDataNodeFeatureFunction DataNodeFunctionType; typedef DataNodeFunctionType::OutputType FeatureOutputType; VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); VectorDataReaderType::Pointer vdDBReader = VectorDataReaderType::New(); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); DataNodeFunctionType::Pointer function = DataNodeFunctionType::New(); if (!DisplayWarnings) { vdReader->SetGlobalWarningDisplay(0); } vdReader->SetFileName(inputVD); vdReader->Update(); vdDBReader->SetFileName(inputDB); vdDBReader->Update(); function->SetInputVectorData(vdDBReader->GetOutput()); function->SetDistanceThreshold(0.003); // Output VectorDataType::Pointer outVD = VectorDataType::New(); // Retrieving root node DataNodeType::Pointer root = outVD->GetDataTree()->GetRoot()->Get(); // Create the document node DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree outVD->GetDataTree()->Add(document, root); // Create the folder node DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree outVD->GetDataTree()->Add(folder, document); TreeIteratorType itVector(vdReader->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsLineFeature() || itVector.Get()->IsPolygonFeature()) { const DataNodeType::Pointer currentGeometry = itVector.Get(); FeatureOutputType currentResult; currentResult = function->Evaluate(*(currentGeometry.GetPointer())); currentGeometry->SetFieldAsDouble("DBOVER", (double)(currentResult[0])); outVD->GetDataTree()->Add(currentGeometry, folder); } ++itVector; } vdWriter->SetInput(outVD); vdWriter->SetFileName(outputVD); vdWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/otbPolygonCompacityFunctor.cxx000066400000000000000000000073271301006202600324500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkConnectedComponentImageFilter.h" #include "otbPolygon.h" #include "otbObjectList.h" #include "otbImageToEdgePathFilter.h" #include "otbPolygonCompacityFunctor.h" #include "otbUnaryFunctorObjectListBooleanFilter.h" int otbPolygonCompacityFunctor(int argc, char * argv[]) { if (argc != 3) { std::cout << "Usage: " << argv[0]; std::cout << " inputImage outputFile" << std::endl; return 1; } typedef unsigned char InputPixelType; typedef unsigned short LabelPixelType; //FIXME doesn't seem to work with long int (64 bits problem ?) typedef otb::Image InputImageType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); typedef itk::ConnectedComponentImageFilter ConnectedComponentsFilterType; ConnectedComponentsFilterType::Pointer connectedComponentsFilter = ConnectedComponentsFilterType::New(); // connectedComponentsFilter->SetInput(reader->GetOutput()); connectedComponentsFilter->SetInput(reader->GetOutput()); connectedComponentsFilter->Update(); std::cout << "# regions: " << connectedComponentsFilter->GetObjectCount() << std::endl; typedef otb::Polygon PolygonType; typedef otb::ObjectList PolygonListType; typedef otb::ImageToEdgePathFilter PolygonFilterType; PolygonListType::Pointer polygonList = PolygonListType::New(); for (LabelPixelType label = 1; label <= connectedComponentsFilter->GetObjectCount(); ++label) { std::cerr << "."; PolygonFilterType::Pointer polygonFilter = PolygonFilterType::New(); polygonFilter->SetInput(connectedComponentsFilter->GetOutput()); polygonFilter->SetForegroundValue(label); polygonFilter->Update(); polygonList->PushBack(polygonFilter->GetOutput()); } typedef otb::PolygonCompacityFunctor CompacityFunctorType; typedef otb::UnaryFunctorObjectListBooleanFilter CompacityFilterType; CompacityFilterType::Pointer compacityFilter = CompacityFilterType::New(); compacityFilter->SetInput(polygonList); compacityFilter->Update(); const char * outfile = argv[2]; std::ofstream file; file.open(outfile); typedef PolygonType::VertexListType VertexListType; typedef VertexListType::ConstIterator IteratorType; typedef PolygonListType::ConstIterator PolygonListIteratorType; for (PolygonListIteratorType pIt = compacityFilter->GetOutput()->Begin(); pIt != compacityFilter->GetOutput()->End(); ++pIt) { file << "--- New Polygon ---" << std::endl; PolygonType::Pointer polygon = pIt.Get(); IteratorType it; for (it = polygon->GetVertexList()->Begin(); it != polygon->GetVertexList()->End(); ++it) { file << it.Value() << std::endl; } } file.close(); return EXIT_SUCCESS; } otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction.cxx000066400000000000000000000124201301006202600415070ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataIntoImageProjectionFilter.h" #include "otbVectorDataFileWriter.h" #include "itkPreOrderTreeIterator.h" int otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction DataNodeFeaturefunctionType; DataNodeFeaturefunctionType::Pointer featureFunction = DataNodeFeaturefunctionType::New(); std::cout << featureFunction << std::endl; return EXIT_SUCCESS; } int otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction(int itkNotUsed(argc), char* argv[]) { const char * inputVD = argv[1]; const char * inputImg = argv[2]; const char * DEMDir = argv[3]; const char * outputVD = argv[4]; int DisplayWarnings = atoi(argv[5]); typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ImageReaderType; typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataIntoImageProjectionFilter VectorDataReProjFilter; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef otb::RadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction FeaturefunctionType; typedef FeaturefunctionType::OutputType FeatureOutputType; ImageReaderType::Pointer imgReader = ImageReaderType::New(); VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); VectorDataReProjFilter::Pointer vdReProjFilter = VectorDataReProjFilter::New(); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); FeaturefunctionType::Pointer featureFunction = FeaturefunctionType::New(); if (!DisplayWarnings) { imgReader->SetGlobalWarningDisplay(0); } otb::DEMHandler::Instance()->OpenDEMDirectory(DEMDir); vdReader->SetFileName(inputVD); vdReader->Update(); imgReader->SetFileName(inputImg); imgReader->UpdateOutputInformation(); imgReader->Update(); //Needed to set m_EndIndex, m_StartIndex in otbDataNodeImageFunction vdReProjFilter->SetInputImage(imgReader->GetOutput()); vdReProjFilter->SetInputVectorData(vdReader->GetOutput()); vdReProjFilter->SetUseOutputSpacingAndOriginFromImage(true); vdReProjFilter->Update(); std::cout<< "vdReProjFilter->GetOutput()->Size(): " << vdReProjFilter->GetOutput()->Size() << std::endl; featureFunction->SetInputImage(imgReader->GetOutput()); // Output VectorDataType::Pointer outVD = VectorDataType::New(); // Retrieving root node DataNodeType::Pointer root = outVD->GetDataTree()->GetRoot()->Get(); // Create the document node DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree outVD->GetDataTree()->Add(document, root); // Create the folder node DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree outVD->GetDataTree()->Add(folder, document); TreeIteratorType itVector(vdReProjFilter->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsLineFeature() || itVector.Get()->IsPolygonFeature()) { const DataNodeType::Pointer currentGeometry = itVector.Get(); FeatureOutputType currentResult; currentResult = featureFunction->Evaluate(*(currentGeometry.GetPointer())); currentGeometry->SetFieldAsDouble("RADIOM_HOM", (double)(currentResult[0])); outVD->GetDataTree()->Add(currentGeometry, folder); } ++itVector; } vdWriter->SetInput(outVD); vdWriter->SetFileName(outputVD); vdWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/otbVectorDataExtractROI.cxx000066400000000000000000000055131301006202600315430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataExtractROI.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" int otbVectorDataExtractROI(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const long int startX = atoi(argv[3]); const long int startY = atoi(argv[4]); const long int sizeX = atoi(argv[5]); const long int sizeY = atoi(argv[6]); typedef double Type; typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataExtractROI FilterType; typedef otb::VectorDataFileReader VectorDataFileReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef otb::RemoteSensingRegion TypedRegion; /** Instantiation of pointer objects*/ FilterType::Pointer filter = FilterType::New(); VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); VectorDataWriterType::Pointer writer = VectorDataWriterType::New(); /** Edit The cartoRegion*/ TypedRegion region; TypedRegion::SizeType size; TypedRegion::IndexType index; size[0] = sizeX; size[1] = sizeY; index[0] = startX; index[1] = startY; /*Set the projection */ std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; region.SetSize(size); region.SetOrigin(index); region.SetRegionProjection(projectionRefWkt); /** */ reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetRegion(region); /** Write the shapefile*/ writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/otbVectorDataExtractROINew.cxx000066400000000000000000000016671301006202600322230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorData.h" #include "otbVectorDataExtractROI.h" int otbVectorDataExtractROINew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataExtractROI FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbVectorDataManipulationTestDriver.cxx000066400000000000000000000014231301006202600341500ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbDBOverlapDataNodeFeatureFunctionNew); REGISTER_TEST(otbDBOverlapDataNodeFeatureFunction); REGISTER_TEST(otbVectorDataExtractROI); REGISTER_TEST(otbVectorDataToSpecificDescriptionFilterBaseNew); REGISTER_TEST(otbVectorDataToVectorDataFilterNew); REGISTER_TEST(otbPolygonCompacityFunctor); REGISTER_TEST(otbVectorDataToRandomLineGeneratorNew); REGISTER_TEST(otbVectorDataToRandomLineGenerator); REGISTER_TEST(otbConcatenateVectorDataFilterNew); REGISTER_TEST(otbConcatenateVectorDataFilter); REGISTER_TEST(otbVectorDataExtractROINew); REGISTER_TEST(otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunctionNew); REGISTER_TEST(otbRadiometryHomogenousWithNeighborhoodDataNodeFeatureFunction); } OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/otbVectorDataToRandomLineGenerator.cxx000066400000000000000000000042761301006202600337660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbVectorDataToRandomLineGenerator.h" int otbVectorDataToRandomLineGeneratorNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataToRandomLineGenerator GeneratorType; // instantiation GeneratorType::Pointer generator = GeneratorType::New(); std::cout << generator << std::endl; return EXIT_SUCCESS; } int otbVectorDataToRandomLineGenerator(int itkNotUsed(argc), char* argv[]) { const char * inputVD = argv[1]; const char * outputVD = argv[2]; typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef otb::VectorDataToRandomLineGenerator GeneratorType; // instantiation VectorDataReaderType::Pointer reader = VectorDataReaderType::New(); VectorDataWriterType::Pointer writer = VectorDataWriterType::New(); GeneratorType::Pointer generator = GeneratorType::New(); reader->SetFileName(inputVD); reader->Update(); generator->SetInput(reader->GetOutput()); generator->SetSeed(0); // enable reproducible random number sequence generator->SetNumberOfOutputLine(20); generator->SetMinLineSize(5); generator->SetMaxLineSize(20); generator->Update(); writer->SetFileName(outputVD); writer->SetInput(generator->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbVectorDataToSpecificDescriptionFilterBase.cxx000066400000000000000000000022561301006202600356760ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataManipulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataToSpecificDescriptionFilterBase.h" #include "otbVectorData.h" int otbVectorDataToSpecificDescriptionFilterBaseNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef float PrecisionType; typedef otb::VectorData VectorDataType; typedef otb::VectorDataToSpecificDescriptionFilterBase VectorDataToSpecificDescriptionFilterType; VectorDataToSpecificDescriptionFilterType::Pointer filter = VectorDataToSpecificDescriptionFilterType::New(); std::cout< InputVectorDataType; typedef otb::VectorData OutputVectorDataType; typedef otb::VectorDataToVectorDataFilter VectorDataFilterType; VectorDataFilterType::Pointer vectorData = VectorDataFilterType::New(); std::cout << vectorData << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataRendering/000077500000000000000000000000001301006202600226435ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataRendering/CMakeLists.txt000066400000000000000000000001601301006202600254000ustar00rootroot00000000000000project(OTBVectorDataRendering) set(OTBVectorDataRendering_LIBRARIES OTBVectorDataRendering) otb_module_impl() OTB-release-5.8/Modules/Filtering/VectorDataRendering/include/000077500000000000000000000000001301006202600242665ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataRendering/include/otbMapnikAdapter.h000066400000000000000000000065241301006202600276730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMapnikAdapter_h #define otbMapnikAdapter_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #include #include #include #include #include #include #include #include #include #include #include #pragma GCC diagnostic pop #else #include #include #include #include #include #include #include #include #include #include #include #endif #ifdef OTB_MAPNIK_COMPATIBILITY_API07 namespace mapnik { typedef Layer layer; typedef Image32 image_32; } #endif namespace otb { namespace mapnik_otb { // this should be removed once mapnik support for version < 2.0 is dropped. // should be around 01/2013. #ifdef OTB_MAPNIK_COMPATIBILITY_API07 static size_t get_num_layer(const mapnik::Map& map) { return map.layerCount(); } static unsigned get_height(const mapnik::Map& map) { return map.getHeight(); } static unsigned get_width(const mapnik::Map& map) { return map.getWidth(); } typedef mapnik::Envelope box2d; static void zoom_to_box(mapnik::Map* map, const mapnik::Envelope& envelope) { map->zoomToBox(envelope); } typedef mapnik::geometry2d geom; static geom* create_geom(int geom_type) { geom* g = 0; switch (geom_type) { case mapnik::Point: g = new mapnik::point >; case mapnik::LineString: g = new mapnik::line_string , mapnik::vertex_vector2>; case mapnik::Polygon: g = new mapnik::polygon, mapnik::vertex_vector2>; default: std::cerr << "Please fix otb::mapnik_otb::create_geom for mapnik 0.7" << std::endl; } return g; } #else static size_t get_num_layer(const mapnik::Map& map) { return map.layer_count(); } static unsigned get_height(const mapnik::Map& map) { return map.height(); } static unsigned get_width(const mapnik::Map& map) { return map.width(); } typedef mapnik::box2d box2d; static void zoom_to_box(mapnik::Map* map, const mapnik::box2d& envelope) { map->zoom_to_box(envelope); } typedef mapnik::vertex vertex2d; typedef mapnik::geometry geom; static geom* create_geom(mapnik::eGeomType geom_type) { return new geom(geom_type); } #endif } } #endif OTB-release-5.8/Modules/Filtering/VectorDataRendering/include/otbVectorDataStyle.h000066400000000000000000000045621301006202600302300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataStyle_h #define otbVectorDataStyle_h #include "itkLightObject.h" #include "itkObjectFactory.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #include #pragma GCC diagnostic pop #else #include #endif namespace otb { /** \class VectorDataStyle * \brief Load style into a mapnik::Map * * \sa VectorDataToMapFilter * * \ingroup OTBVectorDataRendering */ class ITK_EXPORT VectorDataStyle : public itk::LightObject { public: /** Standard class typedefs. */ typedef VectorDataStyle Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataStyle, LightObject); void LoadOSMStyle(mapnik::Map& mapnikMap) const; void LoadBinaryRasterizationStyle(mapnik::Map& mapnikMap) const; /** Get/Set the size of the scale factor. */ double GetScaleFactor() const { return m_ScaleFactor; } void SetScaleFactor(double scale) { m_ScaleFactor = scale; } protected: /** Constructor */ VectorDataStyle() : m_ScaleFactor(1.0){}; /** Destructor */ virtual ~VectorDataStyle() {} /**PrintSelf method */ virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; private: VectorDataStyle(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented //this parameter is used only in the case of sensor geometry //to adjust the scale double m_ScaleFactor; }; // end class } // end namespace otb #endif OTB-release-5.8/Modules/Filtering/VectorDataRendering/include/otbVectorDataToImageFilter.h000066400000000000000000000167151301006202600316260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToImageFilter_h #define otbVectorDataToImageFilter_h #include "itkImageSource.h" #include "otbRGBAPixelConverter.h" #include "otbVectorDataExtractROI.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #include #include #pragma GCC diagnostic pop #else #include #include #endif namespace otb { /** \class VectorDataToImageFilter * \brief DEPRECATED: See VectorDataToImageFilter * \deprecated use VectorDataToImageFilter instead * \sa VectorDataToImageFilter * * \ingroup OTBVectorDataRendering */ template class ITK_EXPORT VectorDataToImageFilter : public itk::ImageSource { public: /** Standard class typedefs. */ typedef VectorDataToImageFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToImageFilter, ImageSource); /** Some typedefs. */ typedef TVectorData VectorDataType; typedef TImage ImageType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::Pointer ImagePointer; typedef typename VectorDataType::ConstPointer VectorDataConstPointer; typedef typename VectorDataType::DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename InternalTreeNodeType::ChildrenListType ChildrenListType; typedef VectorDataExtractROI VectorDataExtractROIType; typedef RemoteSensingRegion RemoteSensingRegionType; typedef typename RemoteSensingRegionType::SizeType SizePhyType; /** Number of dimensions. */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Image size typedef. */ typedef itk::Size SizeType; /** Image index typedef. */ typedef typename TImage::IndexType IndexType; /** Image spacing, origin and direction typedef */ typedef typename TImage::SpacingType SpacingType; typedef typename TImage::PointType OriginType; typedef typename TImage::DirectionType DirectionType; /** Region typedef */ typedef typename TImage::RegionType RegionType; /** RGBA Converter typedef */ typedef RGBAPixelConverter RGBAConverterType; /** typedef specific to mapnik */ typedef boost::shared_ptr datasource_ptr; /** */ typedef enum { OSM, Binary } RenderingStyleType; /** Set/Get the vector data input of this process object. */ using Superclass::SetInput; virtual void SetInput(const VectorDataType *input); virtual void SetInput(unsigned int idx, const VectorDataType *input); const VectorDataType * GetInput(void); const VectorDataType * GetInput(unsigned int idx); /** Set the size of the output image. */ itkSetMacro(Size, SizeType); /** Get the size of the output image. */ itkGetConstReferenceMacro(Size, SizeType); /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(Origin, OriginType); virtual void SetOrigin(const double origin[2]); virtual void SetOrigin(const float origin[2]); itkGetConstReferenceMacro(Origin, OriginType); /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ virtual void SetSpacing(const SpacingType& spacing); virtual void SetSpacing(const double spacing[2]); virtual void SetSpacing(const float spacing[2]); itkGetConstReferenceMacro(Spacing, SpacingType); /** Get/Set methods for the scale factor */ itkSetMacro(ScaleFactor, double); itkGetMacro(ScaleFactor, double); /** */ void AddStyle(const std::string& style) { m_StyleList.push_back(style); } /** Clear the style list */ void ClearStyleList() { m_StyleList.clear(); } /** Specify if the output image is to be uses as an overlar * (with transparent background) or not (with blue background). */ itkSetMacro(UseAsOverlay, bool); itkGetMacro(UseAsOverlay, bool); itkBooleanMacro(UseAsOverlay); /** Get/Set methods for the rendering style type (OSM or Binary) */ itkSetMacro(RenderingStyleType, RenderingStyleType); itkGetMacro(RenderingStyleType, RenderingStyleType); /** Add accessors to the font filename */ itkSetStringMacro(FontFileName); itkGetStringMacro(FontFileName); /** Add accessors to the Projection in the WKT format */ itkSetStringMacro(VectorDataProjectionWKT); itkGetStringMacro(VectorDataProjectionWKT); protected: /** Constructor */ VectorDataToImageFilter(); /** Destructor */ virtual ~VectorDataToImageFilter() {} /**PrintSelf method */ virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; virtual void GenerateOutputInformation(); virtual void GenerateData(void); virtual void BeforeThreadedGenerateData(); private: VectorDataToImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void ProcessNode(InternalTreeNodeType * source, datasource_ptr mDatasource); SpacingType m_Spacing; OriginType m_Origin; SizeType m_Size; IndexType m_StartIndex; DirectionType m_Direction; // font file name std::string m_FontFileName; //This factor is used to flip the data on the Y axis when using a //sensor model geometry (where the Y coordinate increases top-down) int m_SensorModelFlip; //this parameter is used only in the case of sensor geometry //to adjust the scale double m_ScaleFactor; //style list std::vector m_StyleList; //Overlay option: change the backgroup (blue or transparent) bool m_UseAsOverlay; //Projection in the proj.4 format (for mapnik) std::string m_VectorDataProjectionProj4; //Projection in the WKT format std::string m_VectorDataProjectionWKT; //Rendering style type RenderingStyleType m_RenderingStyleType; //RGBA Converter typename RGBAConverterType::Pointer m_RGBAConverter; //Internal Tiling unsigned int m_NbTile; std::vector m_TilingRegions; std::vector m_Maps; std::vector< std::vector > m_VectorDataExtractors; }; // end class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/VectorDataRendering/include/otbVectorDataToImageFilter.txx000066400000000000000000000507401301006202600322160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToImageFilter_txx #define otbVectorDataToImageFilter_txx #include #include "otbVectorDataToImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageIteratorWithIndex.h" #include "otbVectorDataStyle.h" #include "itkRGBAPixel.h" #include "ogr_spatialref.h" #include "otbMapnikAdapter.h" namespace otb { /** * Constructor */ template VectorDataToImageFilter ::VectorDataToImageFilter() : m_StyleList(), m_UseAsOverlay(true), m_RenderingStyleType(OSM) { this->SetNumberOfRequiredInputs(1); m_Spacing.Fill(1.0); m_Origin.Fill(0.0); m_Direction.SetIdentity(); m_Size.Fill(0); m_StartIndex.Fill(0); m_SensorModelFlip = 1; m_ScaleFactor = 1.0; m_VectorDataProjectionProj4 = ""; m_VectorDataProjectionWKT = ""; } template void VectorDataToImageFilter ::SetInput(const VectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template void VectorDataToImageFilter ::SetInput(unsigned int idx, const VectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(idx, const_cast(input)); } template const typename VectorDataToImageFilter::VectorDataType * VectorDataToImageFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return 0; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template const typename VectorDataToImageFilter::VectorDataType * VectorDataToImageFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } //---------------------------------------------------------------------------- template void VectorDataToImageFilter ::SetSpacing(const SpacingType& spacing) { if (this->m_Spacing != spacing) { this->m_Spacing = spacing; this->Modified(); } } //---------------------------------------------------------------------------- template void VectorDataToImageFilter ::SetSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToImageFilter ::SetSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToImageFilter ::SetOrigin(const double origin[2]) { OriginType p(origin); this->SetOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataToImageFilter ::SetOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetOrigin(p); } /** * Inform pipeline of required output region */ template void VectorDataToImageFilter ::GenerateOutputInformation() { // we can't call the superclass method here. // get pointers to the input and output ImagePointer outputPtr = this->GetOutput(); if (!outputPtr) { return; } // Set the size of the output region typename TImage::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(m_Size); outputLargestPossibleRegion.SetIndex(m_StartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); // Set spacing and origin outputPtr->SetSpacing(m_Spacing); outputPtr->SetOrigin(m_Origin); outputPtr->SetDirection(m_Direction); itk::MetaDataDictionary& dict = outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData (dict, MetaDataKey::ProjectionRefKey, static_cast(m_VectorDataProjectionWKT)); //TODO update or check the projection information return; } /** * BeforeThreadedGenerateData */ template void VectorDataToImageFilter ::BeforeThreadedGenerateData(void) { Superclass::BeforeThreadedGenerateData(); //Font Handling if(!m_FontFileName.empty()) mapnik::freetype_engine::register_font(m_FontFileName); //Handle the style type using helper class otb::VectorDataStyle::Pointer styleLoader = otb::VectorDataStyle::New(); styleLoader->SetScaleFactor(m_ScaleFactor); //We assume that all the data are reprojected before using OTB. VectorDataConstPointer input = this->GetInput(); //Converting the projection string to the proj.4 format itk::ExposeMetaData( input->GetMetaDataDictionary(), MetaDataKey::ProjectionRefKey, m_VectorDataProjectionWKT); otbMsgDebugMacro(<< "WKT -> " << m_VectorDataProjectionWKT); m_SensorModelFlip = 1; if (m_VectorDataProjectionWKT == "") { //We assume that it is an image in sensor model geometry //and tell mapnik that this is utm //(with a resolution of 1m per unit) m_VectorDataProjectionProj4 = "+proj=utm +zone=31 +ellps=WGS84"; m_SensorModelFlip = -1; otbMsgDevMacro(<< "The output map will be in sensor geometry"); } else { OGRSpatialReferenceH oSRS = OSRNewSpatialReference(m_VectorDataProjectionWKT.c_str()); char * pszProj4; OSRExportToProj4(oSRS, &pszProj4); m_VectorDataProjectionProj4 = pszProj4; CPLFree(pszProj4); OSRRelease(oSRS); m_SensorModelFlip = 1; otbMsgDevMacro(<< "The output map will be carto/geo geometry"); } otbMsgDebugMacro(<< "Proj.4 -> " << m_VectorDataProjectionProj4); //Internal Tiling Support //Workaround to overcome mapnik maximum tile size limitation ImagePointer output = this->GetOutput(); RegionType requestedRegion = output->GetRequestedRegion(); otbMsgDevMacro("requestedRegion: " << requestedRegion); m_NbTile = (vcl_pow(std::max(vcl_floor((double)requestedRegion.GetSize()[0] / 16000), vcl_floor((double)requestedRegion.GetSize()[1] / 16000))+1, 2)); //std::cout << "nbTile: " << m_NbTile << std::endl; //std::cout << "requestedRegion: " << requestedRegion << std::endl; m_TilingRegions.resize(m_NbTile); m_Maps.resize(m_NbTile); m_VectorDataExtractors.resize(m_NbTile); unsigned int tilingRegionsIdx = 0; unsigned int stdXOffset; unsigned int stdYOffset; stdXOffset = vcl_floor((double)requestedRegion.GetSize()[0]/ (m_NbTile/2))+1; stdYOffset = vcl_floor((double)requestedRegion.GetSize()[1]/ (m_NbTile/2))+1; for(unsigned int i=0; i < vcl_floor((double)(m_NbTile)/2 + 0.5); ++i) { for(unsigned int j=0; j < vcl_floor((double)(m_NbTile)/2 + 0.5); ++j) { //Set Regions SizeType size; IndexType index; if(m_NbTile == 1) { index = requestedRegion.GetIndex(); size = requestedRegion.GetSize(); } else { index[0] = requestedRegion.GetIndex()[0] + i * stdXOffset; index[1] = requestedRegion.GetIndex()[1] + j * stdYOffset; size[0] = std::min((unsigned int)(requestedRegion.GetSize()[0] - index[0]), stdXOffset); size[1] = std::min((unsigned int)(requestedRegion.GetSize()[1] - index[1]), stdYOffset); } m_TilingRegions[tilingRegionsIdx].SetIndex(index); m_TilingRegions[tilingRegionsIdx].SetSize(size); //std::cout << "tileRegions[" << tilingRegionsIdx << "] : " // << m_TilingRegions[tilingRegionsIdx] << std::endl; //Set Maps m_Maps[tilingRegionsIdx] = mapnik::Map(); ////Load the style type switch (m_RenderingStyleType) { case OSM: { styleLoader->LoadOSMStyle(m_Maps[tilingRegionsIdx]); if (m_UseAsOverlay) { //Set the default backgroup to transparent m_Maps[tilingRegionsIdx].set_background(mapnik::color(255, 255, 255, 0)); } else { m_Maps[tilingRegionsIdx].set_background(mapnik::color("#b5d0d0")); } break; } case Binary: { styleLoader->LoadBinaryRasterizationStyle(m_Maps[tilingRegionsIdx]); //Set the backgroup to white m_Maps[tilingRegionsIdx].set_background(mapnik::color("#ffffff")); break; } default: { itkExceptionMacro(<< "Style Type Not Supported!"); break; } } ////Set Mapnik projection information m_Maps[tilingRegionsIdx].set_srs(m_VectorDataProjectionProj4); //Set VectorData extracts m_VectorDataExtractors[tilingRegionsIdx].resize(this->GetNumberOfInputs()); for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { if (this->GetInput(idx)) { RemoteSensingRegionType rsRegion; SizePhyType sizePhy; sizePhy[0] = size[0] * m_Spacing[0]; sizePhy[1] = size[1] * m_Spacing[1]; rsRegion.SetSize(sizePhy); OriginType origin; origin[0] = m_Origin[0] + (static_cast(index[0]) - 0.5) * m_Spacing[0]; origin[1] = m_Origin[1] + (static_cast(index[1]) - 0.5) * m_Spacing[1]; rsRegion.SetOrigin(origin); rsRegion.SetRegionProjection(m_VectorDataProjectionWKT); //std::cout << "m_SensorModelFlip: " << m_SensorModelFlip << std::endl; //std::cout << "rsTileRegions[" << tilingRegionsIdx << "] : " // << rsRegion << std::endl; m_VectorDataExtractors[tilingRegionsIdx][idx] = VectorDataExtractROIType::New(); m_VectorDataExtractors[tilingRegionsIdx][idx]->SetRegion(rsRegion); m_VectorDataExtractors[tilingRegionsIdx][idx]->SetInput(this->GetInput(idx)); } } tilingRegionsIdx ++; } } } /** * Generate Data */ template void VectorDataToImageFilter ::GenerateData(void) { this->AllocateOutputs(); this->BeforeThreadedGenerateData(); if (m_StyleList.size() == 0) { switch (m_RenderingStyleType) { case OSM: { //Add default styles itkExceptionMacro(<< "No style is provided for the vector data"); break; } case Binary: { //Add default styles this->AddStyle("binary-rasterization"); break; } default: { itkExceptionMacro(<< "No style is provided for the vector data"); break; } } } ImagePointer output = this->GetOutput(); for (unsigned int tileIdx = 0; tileIdx < m_NbTile; ++tileIdx) { //Delete the previous layers from the map int numberLayer = mapnik_otb::get_num_layer(m_Maps[tileIdx]); for (int i = numberLayer - 1; i >= 0; i--) //yes, int. { m_Maps[tileIdx].removeLayer(i); } m_Maps[tileIdx].resize(m_TilingRegions[tileIdx].GetSize()[0], m_TilingRegions[tileIdx].GetSize()[1]); RemoteSensingRegionType rsRegion; for (unsigned int vdIdx = 0; vdIdx < this->GetNumberOfInputs(); ++vdIdx) { if (this->GetInput(vdIdx)) { datasource_ptr mDatasource = datasource_ptr(new mapnik::memory_datasource); rsRegion = m_VectorDataExtractors[tileIdx][vdIdx]->GetRegion(); m_VectorDataExtractors[tileIdx][vdIdx]->Update(); VectorDataConstPointer input = m_VectorDataExtractors[tileIdx][vdIdx]->GetOutput(); InternalTreeNodeType * inputRoot = const_cast(input->GetDataTree()->GetRoot()); ProcessNode(inputRoot, mDatasource); otbMsgDevMacro("Datasource size: " << mDatasource->size()); std::stringstream layerName; layerName << "layer-" << tileIdx; mapnik::layer lyr(layerName.str()); lyr.set_srs(m_VectorDataProjectionProj4); lyr.set_datasource(mDatasource); for (unsigned int i = 0; i < m_StyleList.size(); ++i) { lyr.add_style(m_StyleList[i]); } m_Maps[tileIdx].addLayer(lyr); } } assert((m_SensorModelFlip == 1) || (m_SensorModelFlip == -1)); mapnik_otb::box2d envelope( rsRegion.GetOrigin(0), m_SensorModelFlip*(rsRegion.GetOrigin(1) + rsRegion.GetSize(1)), rsRegion.GetOrigin(0) + rsRegion.GetSize(0), m_SensorModelFlip*(rsRegion.GetOrigin(1)) ); mapnik_otb::zoom_to_box(&m_Maps[tileIdx], envelope); otbMsgDebugMacro(<< "Envelope: " << envelope); otbMsgDebugMacro(<< "Map scale: " << m_Maps[tileIdx].scale_denominator()); mapnik::image_32 buf(mapnik_otb::get_width(m_Maps[tileIdx]), mapnik_otb::get_height(m_Maps[tileIdx])); mapnik::agg_renderer ren(m_Maps[tileIdx], buf); ren.apply(); const unsigned char * src = buf.raw_data(); itk::ImageRegionIterator it(output, m_TilingRegions[tileIdx]); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { itk::RGBAPixel pix; pix[0] = *src; pix[1] = *(src+1); pix[2] = *(src+2); pix[3] = *(src+3); src += 4; it.Set(m_RGBAConverter->Convert(pix)); } } } template void VectorDataToImageFilter ::ProcessNode(InternalTreeNodeType * source, datasource_ptr mDatasource) { typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // For each child for (typename ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { // Copy input DataNode info DataNodePointerType dataNode = (*it)->Get(); switch (dataNode->GetNodeType()) { case otb::ROOT: { ProcessNode((*it), mDatasource); break; } case otb::DOCUMENT: { ProcessNode((*it), mDatasource); break; } case otb::FOLDER: { ProcessNode((*it), mDatasource); break; } case FEATURE_POINT: { mapnik_otb::geom* point = mapnik_otb::create_geom(mapnik::Point); point->move_to(dataNode->GetPoint()[0], m_SensorModelFlip * dataNode->GetPoint()[1]); // std::cout << dataNode->GetPoint()[0] << ", " << dataNode->GetPoint()[1] << std::endl; typedef boost::shared_ptr raster_ptr; typedef mapnik::feature Feature; typedef boost::shared_ptr feature_ptr; feature_ptr mfeature = feature_ptr(new Feature(1)); mfeature->add_geometry(point); mapnik::transcoder tr("ISO-8859-15"); if (dataNode->HasField("place_name")) boost::put(*mfeature, "name", tr.transcode((dataNode->GetFieldAsString("place_name")).c_str())); boost::put(*mfeature, "place", tr.transcode("city")); boost::put(*mfeature, "capital", tr.transcode("yes")); //FIXME more a question of style boost::put(*mfeature, "geometry", tr.transcode("point")); mDatasource->push(mfeature); break; } case otb::FEATURE_LINE: { mapnik_otb::geom* line = mapnik_otb::create_geom(mapnik::LineString); typedef typename DataNodeType::LineType::VertexListConstIteratorType VertexIterator; VertexIterator itVertex = dataNode->GetLine()->GetVertexList()->Begin(); while (itVertex != dataNode->GetLine()->GetVertexList()->End()) { // std::cout << itVertex.Value()[0] << ", " << itVertex.Value()[1] << std::endl; line->line_to(itVertex.Value()[0], m_SensorModelFlip * itVertex.Value()[1]); ++itVertex; } // std::cout << "Num points: " << line->num_points() << std::endl; typedef boost::shared_ptr raster_ptr; typedef mapnik::feature Feature; typedef boost::shared_ptr feature_ptr; feature_ptr mfeature = feature_ptr(new Feature(1)); mfeature->add_geometry(line); mapnik::transcoder tr("ISO-8859-15"); if (dataNode->HasField("name")) boost::put(*mfeature, "name", tr.transcode((dataNode->GetFieldAsString("name")).c_str())); if (dataNode->HasField("NAME")) boost::put(*mfeature, "name", tr.transcode((dataNode->GetFieldAsString("NAME")).c_str())); // std::cout << mfeature->props().size() << std::endl; // std::cout << " -> " << (*mfeature)["name"] << std::endl; // std::cout << "Name: " << dataNode->GetFieldAsString("NAME") << std::endl; // std::cout << "Type: " << dataNode->GetFieldAsString("TYPE") << std::endl; // std::cout << "OSM ID: " << dataNode->GetFieldAsString("osm_id") << std::endl; if (dataNode->HasField("type")) boost::put(*mfeature, "highway", tr.transcode((dataNode->GetFieldAsString("type")).c_str())); if (dataNode->HasField("TYPE")) boost::put(*mfeature, "highway", tr.transcode((dataNode->GetFieldAsString("TYPE")).c_str())); boost::put(*mfeature, "geometry", tr.transcode("line")); mDatasource->push(mfeature); break; } case FEATURE_POLYGON: { mapnik_otb::geom* polygon = mapnik_otb::create_geom(mapnik::Polygon); typedef typename DataNodeType::PolygonType::VertexListConstIteratorType VertexIterator; VertexIterator itVertex = dataNode->GetPolygonExteriorRing()->GetVertexList()->Begin(); while (itVertex != dataNode->GetPolygonExteriorRing()->GetVertexList()->End()) { polygon->line_to(itVertex.Value()[0], m_SensorModelFlip * itVertex.Value()[1]); ++itVertex; } typedef boost::shared_ptr raster_ptr; typedef mapnik::feature Feature; typedef boost::shared_ptr feature_ptr; feature_ptr mfeature = feature_ptr(new Feature(1)); mfeature->add_geometry(polygon); mapnik::transcoder tr("ISO-8859-15"); boost::put(*mfeature, "geometry", tr.transcode("polygon")); mDatasource->push(mfeature); break; } case FEATURE_MULTIPOINT: { itkExceptionMacro( << "This type (FEATURE_MULTIPOINT) is not handle (yet) by VectorDataToImageFilter(), please request for it"); break; } case FEATURE_MULTILINE: { itkExceptionMacro( << "This type (FEATURE_MULTILINE) is not handle (yet) by VectorDataToImageFilter(), please request for it"); break; } case FEATURE_MULTIPOLYGON: { itkExceptionMacro( << "This type (FEATURE_MULTIPOLYGON) is not handle (yet) by VectorDataToImageFilter(), please request for it"); break; } case FEATURE_COLLECTION: { itkExceptionMacro( << "This type (FEATURE_COLLECTION) is not handle (yet) by VectorDataToImageFilter(), please request for it"); break; } } } } /** * PrintSelf Method */ template void VectorDataToImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/Filtering/VectorDataRendering/include/otbVectorDataToMapFilter.h000066400000000000000000000207361301006202600313170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToMapFilter_h #define otbVectorDataToMapFilter_h #include "itkImageSource.h" #include "otbRGBAPixelConverter.h" #include "otbVectorDataExtractROI.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #include #include #pragma GCC diagnostic pop #else #include #include #endif namespace otb { /** \class VectorDataToMapFilter * \brief EXPERIMENTAL FEATURE Render a vector data into an image * * To use this class, you need to compile the library with the option OTB_USE_MAPNIK * to ON. You also need to install mapnik on your machine (http://www.mapnik.org) * * We assume that all the data have been reprojected before in the desired cartographic, * geographic or sensor model projection (using the otb::VectorDataProjectionFilter). * This filter does not use the projection capabilities of mapnik. * * According to the class otb::VectorDataStyle, this filter supports * two different rendering style types: OSM and Binary. * The OSM style type provides styles to render a vector data the * OSM way. These styles must be specified usind the method * "AddStyle()". * The Binary style type provides automatically a set of styles to * render a vectro data as a binary mask (foreground pixel value * 255, background pixel value 0). * * Note: * This class only support the following types as TImage template * parameter: * otb::Image, * otb::Image< itk::RGBAPixel >, * otb::Image< itk::RGBPixel >. * * * \ingroup OTBVectorDataRendering */ template class ITK_EXPORT VectorDataToMapFilter : public itk::ImageSource { public: /** Standard class typedefs. */ typedef VectorDataToMapFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToMapFilter, ImageSource); /** Some typedefs. */ typedef TVectorData VectorDataType; typedef TImage ImageType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::Pointer ImagePointer; typedef typename VectorDataType::ConstPointer VectorDataConstPointer; typedef typename VectorDataType::DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename InternalTreeNodeType::ChildrenListType ChildrenListType; typedef VectorDataExtractROI VectorDataExtractROIType; typedef RemoteSensingRegion RemoteSensingRegionType; typedef typename RemoteSensingRegionType::SizeType SizePhyType; /** Number of dimensions. */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Image size typedef. */ typedef itk::Size SizeType; /** Image index typedef. */ typedef typename TImage::IndexType IndexType; /** Image spacing, origin and direction typedef */ typedef typename TImage::SpacingType SpacingType; typedef typename TImage::PointType OriginType; typedef typename TImage::DirectionType DirectionType; /** Region typedef */ typedef typename TImage::RegionType RegionType; /** RGBA Converter typedef */ typedef RGBAPixelConverter RGBAConverterType; /** typedef specific to mapnik */ typedef boost::shared_ptr datasource_ptr; /** */ typedef enum { OSM, Binary } RenderingStyleType; /** Set/Get the vector data input of this process object. */ using Superclass::SetInput; virtual void SetInput(const VectorDataType *input); virtual void SetInput(unsigned int idx, const VectorDataType *input); const VectorDataType * GetInput(void); const VectorDataType * GetInput(unsigned int idx); /** Set the size of the output image. */ itkSetMacro(Size, SizeType); /** Get the size of the output image. */ itkGetConstReferenceMacro(Size, SizeType); /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(Origin, OriginType); virtual void SetOrigin(const double origin[2]); virtual void SetOrigin(const float origin[2]); itkGetConstReferenceMacro(Origin, OriginType); /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ virtual void SetSpacing(const SpacingType& spacing); virtual void SetSpacing(const double spacing[2]); virtual void SetSpacing(const float spacing[2]); itkGetConstReferenceMacro(Spacing, SpacingType); /** Get/Set methods for the scale factor */ itkSetMacro(ScaleFactor, double); itkGetMacro(ScaleFactor, double); /** */ void AddStyle(const std::string& style) { m_StyleList.push_back(style); } /** Clear the style list */ void ClearStyleList() { m_StyleList.clear(); } /** Specify if the output image is to be uses as an overlar * (with transparent background) or not (with blue background). */ itkSetMacro(UseAsOverlay, bool); itkGetMacro(UseAsOverlay, bool); itkBooleanMacro(UseAsOverlay); /** Get/Set methods for the rendering style type (OSM or Binary) */ itkSetMacro(RenderingStyleType, RenderingStyleType); itkGetMacro(RenderingStyleType, RenderingStyleType); /** Add accessors to the font filename */ itkSetStringMacro(FontFileName); itkGetStringMacro(FontFileName); /** Add accessors to the Projection in the WKT format */ itkSetStringMacro(VectorDataProjectionWKT); itkGetStringMacro(VectorDataProjectionWKT); protected: /** Constructor */ VectorDataToMapFilter(); /** Destructor */ virtual ~VectorDataToMapFilter() {} /**PrintSelf method */ virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; virtual void GenerateOutputInformation(); virtual void GenerateData(void); virtual void BeforeThreadedGenerateData(); private: VectorDataToMapFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void ProcessNode(InternalTreeNodeType * source, datasource_ptr mDatasource); SpacingType m_Spacing; OriginType m_Origin; SizeType m_Size; IndexType m_StartIndex; DirectionType m_Direction; // font file name std::string m_FontFileName; //This factor is used to flip the data on the Y axis when using a //sensor model geometry (where the Y coordinate increases top-down) int m_SensorModelFlip; //this parameter is used only in the case of sensor geometry //to adjust the scale double m_ScaleFactor; //style list std::vector m_StyleList; //Overlay option: change the backgroup (blue or transparent) bool m_UseAsOverlay; //Projection in the proj.4 format (for mapnik) std::string m_VectorDataProjectionProj4; //Projection in the WKT format std::string m_VectorDataProjectionWKT; //Rendering style type RenderingStyleType m_RenderingStyleType; //RGBA Converter typename RGBAConverterType::Pointer m_RGBAConverter; //Internal Tiling unsigned int m_NbTile; std::vector m_TilingRegions; std::vector m_Maps; std::vector< std::vector > m_VectorDataExtractors; }; // end class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/VectorDataRendering/include/otbVectorDataToMapFilter.txx000066400000000000000000000506541301006202600317150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToMapFilter_txx #define otbVectorDataToMapFilter_txx #include #include "otbVectorDataToMapFilter.h" #include "itkImageRegionIterator.h" #include "itkImageIteratorWithIndex.h" #include "otbVectorDataStyle.h" #include "itkRGBAPixel.h" #include "otbMapnikAdapter.h" #include "ogr_spatialref.h" namespace otb { /** * Constructor */ template VectorDataToMapFilter ::VectorDataToMapFilter() : m_StyleList(), m_UseAsOverlay(true), m_RenderingStyleType(OSM) { this->SetNumberOfRequiredInputs(1); m_Spacing.Fill(1.0); m_Origin.Fill(0.0); m_Direction.SetIdentity(); m_Size.Fill(0); m_StartIndex.Fill(0); m_SensorModelFlip = 1; m_ScaleFactor = 1.0; m_VectorDataProjectionProj4 = ""; m_VectorDataProjectionWKT = ""; } template void VectorDataToMapFilter ::SetInput(const VectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template void VectorDataToMapFilter ::SetInput(unsigned int idx, const VectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(idx, const_cast(input)); } template const typename VectorDataToMapFilter::VectorDataType * VectorDataToMapFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return 0; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template const typename VectorDataToMapFilter::VectorDataType * VectorDataToMapFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } //---------------------------------------------------------------------------- template void VectorDataToMapFilter ::SetSpacing(const SpacingType& spacing) { if (this->m_Spacing != spacing) { this->m_Spacing = spacing; this->Modified(); } } //---------------------------------------------------------------------------- template void VectorDataToMapFilter ::SetSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToMapFilter ::SetSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToMapFilter ::SetOrigin(const double origin[2]) { OriginType p(origin); this->SetOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataToMapFilter ::SetOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetOrigin(p); } /** * Inform pipeline of required output region */ template void VectorDataToMapFilter ::GenerateOutputInformation() { // we can't call the superclass method here. // get pointers to the input and output ImagePointer outputPtr = this->GetOutput(); if (!outputPtr) { return; } // Set the size of the output region typename TImage::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(m_Size); outputLargestPossibleRegion.SetIndex(m_StartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); // Set spacing and origin outputPtr->SetSpacing(m_Spacing); outputPtr->SetOrigin(m_Origin); outputPtr->SetDirection(m_Direction); itk::MetaDataDictionary& dict = outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData (dict, MetaDataKey::ProjectionRefKey, static_cast(m_VectorDataProjectionWKT)); //TODO update or check the projection information return; } /** * BeforeThreadedGenerateData */ template void VectorDataToMapFilter ::BeforeThreadedGenerateData(void) { Superclass::BeforeThreadedGenerateData(); //Font Handling if(!m_FontFileName.empty()) mapnik::freetype_engine::register_font(m_FontFileName); //Handle the style type using helper class otb::VectorDataStyle::Pointer styleLoader = otb::VectorDataStyle::New(); styleLoader->SetScaleFactor(m_ScaleFactor); //We assume that all the data are reprojected before using OTB. VectorDataConstPointer input = this->GetInput(); //Converting the projection string to the proj.4 format itk::ExposeMetaData( input->GetMetaDataDictionary(), MetaDataKey::ProjectionRefKey, m_VectorDataProjectionWKT); otbMsgDebugMacro(<< "WKT -> " << m_VectorDataProjectionWKT); m_SensorModelFlip = 1; if (m_VectorDataProjectionWKT == "") { //We assume that it is an image in sensor model geometry //and tell mapnik that this is utm //(with a resolution of 1m per unit) m_VectorDataProjectionProj4 = "+proj=utm +zone=31 +ellps=WGS84"; m_SensorModelFlip = -1; otbMsgDevMacro(<< "The output map will be in sensor geometry"); } else { OGRSpatialReferenceH oSRS = OSRNewSpatialReference(m_VectorDataProjectionWKT.c_str()); char * pszProj4; OSRExportToProj4(oSRS, &pszProj4); m_VectorDataProjectionProj4 = pszProj4; CPLFree(pszProj4); OSRRelease(oSRS); m_SensorModelFlip = 1; otbMsgDevMacro(<< "The output map will be carto/geo geometry"); } otbMsgDebugMacro(<< "Proj.4 -> " << m_VectorDataProjectionProj4); //Internal Tiling Support //Workaround to overcome mapnik maximum tile size limitation ImagePointer output = this->GetOutput(); RegionType requestedRegion = output->GetRequestedRegion(); otbMsgDevMacro("requestedRegion: " << requestedRegion); m_NbTile = (vcl_pow(std::max(vcl_floor((double)requestedRegion.GetSize()[0] / 16000), vcl_floor((double)requestedRegion.GetSize()[1] / 16000))+1, 2)); //std::cout << "nbTile: " << m_NbTile << std::endl; //std::cout << "requestedRegion: " << requestedRegion << std::endl; m_TilingRegions.resize(m_NbTile); m_Maps.resize(m_NbTile); m_VectorDataExtractors.resize(m_NbTile); unsigned int tilingRegionsIdx = 0; unsigned int stdXOffset; unsigned int stdYOffset; stdXOffset = vcl_floor((double)requestedRegion.GetSize()[0]/ (m_NbTile/2))+1; stdYOffset = vcl_floor((double)requestedRegion.GetSize()[1]/ (m_NbTile/2))+1; for(unsigned int i=0; i < vcl_floor((double)(m_NbTile)/2 + 0.5); ++i) { for(unsigned int j=0; j < vcl_floor((double)(m_NbTile)/2 + 0.5); ++j) { //Set Regions SizeType size; IndexType index; if(m_NbTile == 1) { index = requestedRegion.GetIndex(); size = requestedRegion.GetSize(); } else { index[0] = requestedRegion.GetIndex()[0] + i * stdXOffset; index[1] = requestedRegion.GetIndex()[1] + j * stdYOffset; size[0] = std::min((unsigned int)(requestedRegion.GetSize()[0] - index[0]), stdXOffset); size[1] = std::min((unsigned int)(requestedRegion.GetSize()[1] - index[1]), stdYOffset); } m_TilingRegions[tilingRegionsIdx].SetIndex(index); m_TilingRegions[tilingRegionsIdx].SetSize(size); //std::cout << "tileRegions[" << tilingRegionsIdx << "] : " // << m_TilingRegions[tilingRegionsIdx] << std::endl; //Set Maps m_Maps[tilingRegionsIdx] = mapnik::Map(); ////Load the style type switch (m_RenderingStyleType) { case OSM: { styleLoader->LoadOSMStyle(m_Maps[tilingRegionsIdx]); if (m_UseAsOverlay) { //Set the default backgroup to transparent m_Maps[tilingRegionsIdx].set_background(mapnik::color(255, 255, 255, 0)); } else { m_Maps[tilingRegionsIdx].set_background(mapnik::color("#b5d0d0")); } break; } case Binary: { styleLoader->LoadBinaryRasterizationStyle(m_Maps[tilingRegionsIdx]); //Set the backgroup to white m_Maps[tilingRegionsIdx].set_background(mapnik::color("#ffffff")); break; } default: { itkExceptionMacro(<< "Style Type Not Supported!"); break; } } ////Set Mapnik projection information m_Maps[tilingRegionsIdx].set_srs(m_VectorDataProjectionProj4); //Set VectorData extracts m_VectorDataExtractors[tilingRegionsIdx].resize(this->GetNumberOfInputs()); for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { if (this->GetInput(idx)) { RemoteSensingRegionType rsRegion; SizePhyType sizePhy; sizePhy[0] = size[0] * m_Spacing[0]; sizePhy[1] = size[1] * m_Spacing[1]; rsRegion.SetSize(sizePhy); OriginType origin; origin[0] = m_Origin[0] + (static_cast(index[0]) - 0.5) * m_Spacing[0]; origin[1] = m_Origin[1] + (static_cast(index[1]) - 0.5) * m_Spacing[1]; rsRegion.SetOrigin(origin); rsRegion.SetRegionProjection(m_VectorDataProjectionWKT); //std::cout << "m_SensorModelFlip: " << m_SensorModelFlip << std::endl; //std::cout << "rsTileRegions[" << tilingRegionsIdx << "] : " // << rsRegion << std::endl; m_VectorDataExtractors[tilingRegionsIdx][idx] = VectorDataExtractROIType::New(); m_VectorDataExtractors[tilingRegionsIdx][idx]->SetRegion(rsRegion); m_VectorDataExtractors[tilingRegionsIdx][idx]->SetInput(this->GetInput(idx)); } } tilingRegionsIdx ++; } } } /** * Generate Data */ template void VectorDataToMapFilter ::GenerateData(void) { this->AllocateOutputs(); this->BeforeThreadedGenerateData(); if (m_StyleList.size() == 0) { switch (m_RenderingStyleType) { case OSM: { //Add default styles itkExceptionMacro(<< "No style is provided for the vector data"); break; } case Binary: { //Add default styles this->AddStyle("binary-rasterization"); break; } default: { itkExceptionMacro(<< "No style is provided for the vector data"); break; } } } ImagePointer output = this->GetOutput(); for (unsigned int tileIdx = 0; tileIdx < m_NbTile; ++tileIdx) { //Delete the previous layers from the map int numberLayer = mapnik_otb::get_num_layer(m_Maps[tileIdx]); for (int i = numberLayer - 1; i >= 0; i--) //yes, int. { m_Maps[tileIdx].removeLayer(i); } m_Maps[tileIdx].resize(m_TilingRegions[tileIdx].GetSize()[0], m_TilingRegions[tileIdx].GetSize()[1]); RemoteSensingRegionType rsRegion; for (unsigned int vdIdx = 0; vdIdx < this->GetNumberOfInputs(); ++vdIdx) { if (this->GetInput(vdIdx)) { datasource_ptr mDatasource = datasource_ptr(new mapnik::memory_datasource); rsRegion = m_VectorDataExtractors[tileIdx][vdIdx]->GetRegion(); m_VectorDataExtractors[tileIdx][vdIdx]->Update(); VectorDataConstPointer input = m_VectorDataExtractors[tileIdx][vdIdx]->GetOutput(); InternalTreeNodeType * inputRoot = const_cast(input->GetDataTree()->GetRoot()); ProcessNode(inputRoot, mDatasource); otbMsgDevMacro("Datasource size: " << mDatasource->size()); std::stringstream layerName; layerName << "layer-" << tileIdx; mapnik::layer lyr(layerName.str()); lyr.set_srs(m_VectorDataProjectionProj4); lyr.set_datasource(mDatasource); for (unsigned int i = 0; i < m_StyleList.size(); ++i) { lyr.add_style(m_StyleList[i]); } m_Maps[tileIdx].addLayer(lyr); } } assert((m_SensorModelFlip == 1) || (m_SensorModelFlip == -1)); mapnik_otb::box2d envelope( rsRegion.GetOrigin(0), m_SensorModelFlip*(rsRegion.GetOrigin(1) + rsRegion.GetSize(1)), rsRegion.GetOrigin(0) + rsRegion.GetSize(0), m_SensorModelFlip*(rsRegion.GetOrigin(1)) ); mapnik_otb::zoom_to_box(&m_Maps[tileIdx], envelope); otbMsgDebugMacro(<< "Envelope: " << envelope); otbMsgDebugMacro(<< "Map scale: " << m_Maps[tileIdx].scale_denominator()); mapnik::image_32 buf(mapnik_otb::get_width(m_Maps[tileIdx]), mapnik_otb::get_height(m_Maps[tileIdx])); mapnik::agg_renderer ren(m_Maps[tileIdx], buf); ren.apply(); const unsigned char * src = buf.raw_data(); itk::ImageRegionIterator it(output, m_TilingRegions[tileIdx]); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { itk::RGBAPixel pix; pix[0] = *src; pix[1] = *(src+1); pix[2] = *(src+2); pix[3] = *(src+3); src += 4; it.Set(m_RGBAConverter->Convert(pix)); } } } template void VectorDataToMapFilter ::ProcessNode(InternalTreeNodeType * source, datasource_ptr mDatasource) { typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // For each child for (typename ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { // Copy input DataNode info DataNodePointerType dataNode = (*it)->Get(); switch (dataNode->GetNodeType()) { case otb::ROOT: { ProcessNode((*it), mDatasource); break; } case otb::DOCUMENT: { ProcessNode((*it), mDatasource); break; } case otb::FOLDER: { ProcessNode((*it), mDatasource); break; } case FEATURE_POINT: { mapnik_otb::geom* point = mapnik_otb::create_geom(mapnik::Point); point->move_to(dataNode->GetPoint()[0], m_SensorModelFlip * dataNode->GetPoint()[1]); // std::cout << dataNode->GetPoint()[0] << ", " << dataNode->GetPoint()[1] << std::endl; typedef boost::shared_ptr raster_ptr; typedef mapnik::feature Feature; typedef boost::shared_ptr feature_ptr; feature_ptr mfeature = feature_ptr(new Feature(1)); mfeature->add_geometry(point); mapnik::transcoder tr("ISO-8859-15"); if (dataNode->HasField("place_name")) boost::put(*mfeature, "name", tr.transcode((dataNode->GetFieldAsString("place_name")).c_str())); boost::put(*mfeature, "place", tr.transcode("city")); boost::put(*mfeature, "capital", tr.transcode("yes")); //FIXME more a question of style boost::put(*mfeature, "geometry", tr.transcode("point")); mDatasource->push(mfeature); break; } case otb::FEATURE_LINE: { mapnik_otb::geom* line = mapnik_otb::create_geom(mapnik::LineString); typedef typename DataNodeType::LineType::VertexListConstIteratorType VertexIterator; VertexIterator itVertex = dataNode->GetLine()->GetVertexList()->Begin(); while (itVertex != dataNode->GetLine()->GetVertexList()->End()) { // std::cout << itVertex.Value()[0] << ", " << itVertex.Value()[1] << std::endl; line->line_to(itVertex.Value()[0], m_SensorModelFlip * itVertex.Value()[1]); ++itVertex; } // std::cout << "Num points: " << line->num_points() << std::endl; typedef boost::shared_ptr raster_ptr; typedef mapnik::feature Feature; typedef boost::shared_ptr feature_ptr; feature_ptr mfeature = feature_ptr(new Feature(1)); mfeature->add_geometry(line); mapnik::transcoder tr("ISO-8859-15"); if (dataNode->HasField("name")) boost::put(*mfeature, "name", tr.transcode((dataNode->GetFieldAsString("name")).c_str())); if (dataNode->HasField("NAME")) boost::put(*mfeature, "name", tr.transcode((dataNode->GetFieldAsString("NAME")).c_str())); // std::cout << mfeature->props().size() << std::endl; // std::cout << " -> " << (*mfeature)["name"] << std::endl; // std::cout << "Name: " << dataNode->GetFieldAsString("NAME") << std::endl; // std::cout << "Type: " << dataNode->GetFieldAsString("TYPE") << std::endl; // std::cout << "OSM ID: " << dataNode->GetFieldAsString("osm_id") << std::endl; if (dataNode->HasField("type")) boost::put(*mfeature, "highway", tr.transcode((dataNode->GetFieldAsString("type")).c_str())); if (dataNode->HasField("TYPE")) boost::put(*mfeature, "highway", tr.transcode((dataNode->GetFieldAsString("TYPE")).c_str())); boost::put(*mfeature, "geometry", tr.transcode("line")); mDatasource->push(mfeature); break; } case FEATURE_POLYGON: { mapnik_otb::geom* polygon = mapnik_otb::create_geom(mapnik::Polygon); typedef typename DataNodeType::PolygonType::VertexListConstIteratorType VertexIterator; VertexIterator itVertex = dataNode->GetPolygonExteriorRing()->GetVertexList()->Begin(); while (itVertex != dataNode->GetPolygonExteriorRing()->GetVertexList()->End()) { polygon->line_to(itVertex.Value()[0], m_SensorModelFlip * itVertex.Value()[1]); ++itVertex; } typedef boost::shared_ptr raster_ptr; typedef mapnik::feature Feature; typedef boost::shared_ptr feature_ptr; feature_ptr mfeature = feature_ptr(new Feature(1)); mfeature->add_geometry(polygon); mapnik::transcoder tr("ISO-8859-15"); boost::put(*mfeature, "geometry", tr.transcode("polygon")); mDatasource->push(mfeature); break; } case FEATURE_MULTIPOINT: { itkExceptionMacro( << "This type (FEATURE_MULTIPOINT) is not handle (yet) by VectorDataToMapFilter(), please request for it"); break; } case FEATURE_MULTILINE: { itkExceptionMacro( << "This type (FEATURE_MULTILINE) is not handle (yet) by VectorDataToMapFilter(), please request for it"); break; } case FEATURE_MULTIPOLYGON: { itkExceptionMacro( << "This type (FEATURE_MULTIPOLYGON) is not handle (yet) by VectorDataToMapFilter(), please request for it"); break; } case FEATURE_COLLECTION: { itkExceptionMacro( << "This type (FEATURE_COLLECTION) is not handle (yet) by VectorDataToMapFilter(), please request for it"); break; } } } } /** * PrintSelf Method */ template void VectorDataToMapFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/Filtering/VectorDataRendering/otb-module.cmake000066400000000000000000000006341301006202600257170ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes related to the rasterization of OpenStreetMap vector data onto images") otb_module(OTBVectorDataRendering DEPENDS OTBVectorDataManipulation OTBMapnik OTBITK OTBGDAL OTBCommon TEST_DEPENDS OTBVectorDataBase OTBTestKernel OTBImageIO OTBProjection OTBVectorDataIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/VectorDataRendering/src/000077500000000000000000000000001301006202600234325ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataRendering/src/CMakeLists.txt000066400000000000000000000006611301006202600261750ustar00rootroot00000000000000set(OTBVectorDataRendering_SRC otbVectorDataStyle.cxx ) if(CMAKE_COMPILER_IS_GNUCXX) set_source_files_properties( ${CMAKE_CURRENT_SOURCE_DIR}/otbVectorDataStyle.cxx COMPILE_FLAGS "-fno-var-tracking") endif() add_library(OTBVectorDataRendering ${OTBVectorDataRendering_SRC}) target_link_libraries(OTBVectorDataRendering ${OTBMapnik_LIBRARIES} ${OTBVectorDataBase_LIBRARIES} ) otb_module_target(OTBVectorDataRendering) OTB-release-5.8/Modules/Filtering/VectorDataRendering/src/otbVectorDataStyle.cxx000066400000000000000000002242051301006202600277450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataStyle.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include #include #include #ifndef OTB_MAPNIK_COMPATIBILITY_API07 #include #endif #pragma GCC diagnostic pop #else #include #include #include #ifndef OTB_MAPNIK_COMPATIBILITY_API07 #include #endif #endif namespace otb { namespace mapnik_otb { // this should be removed once mapnik support for version < 2.0 is dropped. // should be around 01/2013. #ifdef OTB_MAPNIK_COMPATIBILITY_API07 typedef mapnik::rule_type rule; static mapnik::filter_ptr parse_expression(std::string const& wkt) { return mapnik::create_filter(wkt); } static shared_ptr create_text_symbolizer( mapnik::filter_ptr filter, std::string const& face_name, unsigned size, mapnik::color const& fill) { shared_ptr p( new mapnik::text_symbolizer( "name", face_name, size, fill)); return p; } #else typedef mapnik::rule rule; static mapnik::expression_ptr parse_expression(std::string const& wkt) { return mapnik::parse_expression(wkt); } static boost::shared_ptr create_text_symbolizer( mapnik::expression_ptr filter, std::string const& face_name, unsigned size, mapnik::color const& fill) { boost::shared_ptr p( new mapnik::text_symbolizer( filter, face_name, size, fill)); return p; } #endif } /** * PrintSelf Method */ void VectorDataStyle ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } void VectorDataStyle ::LoadBinaryRasterizationStyle(mapnik::Map& mapnikMap) const { { mapnik::feature_type_style style; { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[geometry] = 'line'")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#000000"), 1); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[geometry] = 'polygon'")); { mapnik::polygon_symbolizer geom = mapnik::polygon_symbolizer(); geom.set_fill(mapnik::color("#000000")); geom.set_gamma(0.0); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[geometry] = 'point'")); { mapnik::point_symbolizer geom = mapnik::point_symbolizer(); rule.append(geom); } style.add_rule(rule); } mapnikMap.insert_style("binary-rasterization", style); } } void VectorDataStyle ::LoadOSMStyle(mapnik::Map& mapnikMap) const { { mapnik::feature_type_style style; { mapnik_otb::rule rule; rule.set_max_scale(static_cast(250000000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(600000ULL / m_ScaleFactor)); { mapnik::polygon_symbolizer geom = mapnik::polygon_symbolizer(); geom.set_fill(mapnik::color("#f2efe9")); rule.append(geom); } style.add_rule(rule); } mapnikMap.insert_style("world", style); } { mapnik::feature_type_style style; { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[place] = 'city' and [capital]='yes'")); rule.set_max_scale(static_cast(50000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(10000000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 9, mapnik::color("#000")); textSymb0->set_halo_radius(1); textSymb0->set_wrap_width(0); textSymb0->set_displacement(0.0, 0); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[place] = 'city' and [capital]='yes'")); rule.set_max_scale(static_cast(10000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(2000000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 11, mapnik::color("#000")); textSymb0->set_halo_radius(1); textSymb0->set_wrap_width(0); textSymb0->set_displacement(0.0, 0); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[place] = 'city' and not [capital]='yes'")); rule.set_max_scale(static_cast(10000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(2000000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 8, mapnik::color("#000")); textSymb0->set_halo_radius(1); textSymb0->set_wrap_width(0); textSymb0->set_displacement(0.0, 0); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[place] = 'city'")); rule.set_max_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(500000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 11, mapnik::color("#000")); textSymb0->set_halo_radius(1); textSymb0->set_wrap_width(0); textSymb0->set_displacement(0.0, 0); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[place] = 'city'")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 14, mapnik::color("#000")); textSymb0->set_halo_radius(1); textSymb0->set_wrap_width(0); textSymb0->set_displacement(0.0, 0); rule.append(*textSymb0); style.add_rule(rule); } mapnikMap.insert_style("city", style); } { mapnik::feature_type_style style; { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 1")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 2")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 3")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 4")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 5")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 6")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 7")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and [length] = 8")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 1")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 2")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 3")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 4")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 5")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 6")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 7")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' and [length] = 8")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 1")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 2")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 3")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 4")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 5")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 6")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 7")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' and [length] = 8")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 1")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 2")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 3")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 4")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 5")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 6")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 7")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' and [length] = 8")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 1")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 2")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 3")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 4")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 5")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 6")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 7")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and [length] = 8")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' or [highway] = 'primary'")); rule.set_max_scale(static_cast(75000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 8, mapnik::color("black")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(0); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary'")); rule.set_max_scale(static_cast(75000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 8, mapnik::color("black")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); textSymb0->set_halo_fill(mapnik::color("#fed7a5")); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' or [highway] = 'primary'")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 9, mapnik::color("black")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(0); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' or [highway] = 'primary'")); rule.set_max_scale(static_cast(20000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 10, mapnik::color("black")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(0); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary'")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 9, mapnik::color("black")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); textSymb0->set_halo_fill(mapnik::color("#fed7a5")); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary'")); rule.set_max_scale(static_cast(20000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 10, mapnik::color("black")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); textSymb0->set_halo_fill(mapnik::color("#fed7a5")); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary'")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 9, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary'")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 11, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(10000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[highway] = 'proposed' or [highway]='construction'")); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 9, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(10000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[highway] = 'proposed' or [highway]='construction'")); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 11, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'unclassified' or [highway] = 'residential'")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 9, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); textSymb0->set_label_spacing(300); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'unclassified' or [highway] = 'residential'")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 11, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); textSymb0->set_label_spacing(400); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_else(true); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 9, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); rule.append(*textSymb0); style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_else(true); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100ULL / m_ScaleFactor)); boost::shared_ptr textSymb0 = mapnik_otb::create_text_symbolizer(mapnik_otb::parse_expression("[name]"), "DejaVu Sans Book", 11, mapnik::color("#000")); textSymb0->set_label_placement(mapnik::LINE_PLACEMENT); textSymb0->set_halo_radius(1); rule.append(*textSymb0); style.add_rule(rule); } mapnikMap.insert_style("roads-text", style); } { mapnik::feature_type_style style; { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' or [highway] = 'motorway_link'")); rule.set_max_scale(static_cast(25000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#809bc0"), 0.5); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' or [highway] = 'motorway_link'")); rule.set_max_scale(static_cast(5000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(2000000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#809bc0"), 1); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' or [highway] = 'motorway_link'")); rule.set_max_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#809bc0"), 1.4); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' or [highway] = 'motorway_link'")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(500000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#809bc0"), 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' or [highway] = 'motorway_link'")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(200000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#809bc0"), 2.5); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' or [highway] = 'trunk_link'")); rule.set_max_scale(static_cast(25000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#a9dba9"), 0.4); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' or [highway] = 'trunk_link'")); rule.set_max_scale(static_cast(5000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(2000000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#97d397"), 1); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' or [highway] = 'trunk_link'")); rule.set_max_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(500000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#97d397"), 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'trunk' or [highway] = 'trunk_link'")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(200000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#97d397"), 2.5); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' or [highway] = 'primary_link'")); rule.set_max_scale(static_cast(5000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(2000000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#ec989a"), 0.5); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' or [highway] = 'primary_link'")); rule.set_max_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#ec989a"), 1.2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' or [highway] = 'primary_link'")); rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(500000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#ec989a"), 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'primary' or [highway] = 'primary_link'")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(200000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#ec989a"), 2.5); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' or [highway] = 'secondary_link'")); rule.set_max_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(500000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#fecc8b"), 1); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'secondary' or [highway] = 'secondary_link'")); rule.set_max_scale(static_cast(500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#fecc8b"), 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(10000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway] = 'rail'")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#aaa"), 0.6); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway] = 'rail' and not ([tunnel]='yes' or [tunnel]='true')")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#aaa"), 1); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(2000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway] = 'rail' and ([tunnel]='yes' or [tunnel]='true')")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#aaa"), 1); stroke.add_dash(5, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(2500000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression( "[railway] = 'tram' or [railway] = 'light_rail' or [railway] = 'narrow_gauge'")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#ccc"), 1); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway] = 'rail' and not ([tunnel]='yes' or [tunnel]='true')")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#aaa"), 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway] = 'rail' and ([tunnel]='yes' or [tunnel]='true')")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#aaa"), 2); stroke.add_dash(5, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(1000000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression( "[railway] = 'tram' or [railway] = 'light_rail' or [railway] = 'narrow_gauge'")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#aaa"), 1); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway] = 'preserved'")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#aaa"), 1.5); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway] = 'preserved'")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999999"), 3); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("white"), 1); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.add_dash(0, 1); stroke.add_dash(8, 1); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); rule.set_filter(mapnik_otb::parse_expression("[railway]='monorail'")); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#fff"), 4); stroke.set_opacity (0.4); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#777"), 3.0); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); stroke.add_dash(2, 3); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } mapnikMap.insert_style("roads", style); } { mapnik::feature_type_style style; { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and not ([tunnel] = 'yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#506077"), 3); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'trunk' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#477147"), 3); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'primary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(200000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(100000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#8d4346"), 3); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'secondary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(150000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(75000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#a37b48"), 2.5); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and not ([tunnel] = 'yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#506077"), 6.5); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'trunk' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#477147"), 7.5); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'primary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#8d4346"), 7.5); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'secondary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(75000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(25000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#a37b48"), 8.5); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'motorway' and not ([tunnel] = 'yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(20000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#506077"), 10); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'trunk' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(20000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#477147"), 11.5); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'primary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(20000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#8d4346"), 11.5); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'secondary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#a37b48"), 11.5); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'motorway' and not ([tunnel] = 'yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#506077"), 13); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'trunk' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#477147"), 16); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'primary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#8d4346"), 16); stroke.set_line_join(mapnik::ROUND_JOIN); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'secondary' and not ([tunnel] = 'yes' or [tunnel] = 'true' or [tunnel] = '1')")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#a37b48"), 16); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'tertiary' and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#bbb"), 6); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 6); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'residential' or [highway] = 'minor' or [highway] = 'unclassified' or " "[highway] = 'road') and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 3); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'residential' or [highway] = 'minor' or [highway] = 'unclassified' or " "[highway] = 'road') and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 3); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(25000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#bbb"), 7.5); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'tertiary' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(25000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 7.5); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'residential' or [highway] = 'minor' or [highway] = 'unclassified' or " "[highway] = 'road') and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(25000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 4.5); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'residential' or [highway] = 'minor' or [highway] = 'unclassified' or " "[highway] = 'road') and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(25000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 4.5); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'tertiary' or [highway] = 'residential' or [highway] = 'minor' or " "[highway] = 'unclassified' or [highway] = 'road') and not ([tunnel]='yes' or " "[tunnel]='true')")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#bbb"), 11); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'tertiary' or [highway] = 'residential' or [highway] = 'minor' or " "[highway] = 'unclassified' or [highway] = 'road') and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(5000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 11); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'tertiary' or [highway] = 'residential' or [highway] = 'minor' or " "[highway] = 'unclassified' or [highway] = 'road') and not ([tunnel]='yes' or " "[tunnel]='true')")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#bbb"), 16); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "([highway] = 'tertiary' or [highway] = 'residential' or [highway] = 'minor' or " "[highway] = 'unclassified' or [highway] = 'road') and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(5000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 16); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'service' and not ([service]='parking_aisle' or [tunnel]='yes' or " "[tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(25000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 3); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'service' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(25000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 3); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression( "[highway] = 'service' and not ([service]='parking_aisle' or[tunnel]='yes' or " "[tunnel]='true')")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 8); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'service' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(25000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 8); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'service' and [service]='parking_aisle'")); rule.set_max_scale(static_cast(10000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(1000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("#999"), 4); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 2); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(100000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(50000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 2); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 3.6); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(50000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(20000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 3.6); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(20000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(10000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 6.5); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(20000ULL / m_ScaleFactor)); rule.set_min_scale(static_cast(10000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 6.5); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and not ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(10000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 9); stroke.set_line_join(mapnik::ROUND_JOIN); stroke.set_line_cap(mapnik::ROUND_CAP); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } { mapnik_otb::rule rule; rule.set_filter(mapnik_otb::parse_expression("[highway] = 'pedestrian' and ([tunnel]='yes' or [tunnel]='true')")); rule.set_max_scale(static_cast(10000ULL / m_ScaleFactor)); { mapnik::line_symbolizer geom = mapnik::line_symbolizer(); mapnik::stroke stroke = mapnik::stroke(mapnik::color("grey"), 9); stroke.add_dash(4, 2); geom.set_stroke(stroke); rule.append(geom); } style.add_rule(rule); } mapnikMap.insert_style("minor-roads-casing", style); } } } //namespace otb OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/000077500000000000000000000000001301006202600236225ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/CMakeLists.txt000066400000000000000000000065261301006202600263730ustar00rootroot00000000000000otb_module_test() set(OTBVectorDataRenderingTests otbVectorDataRenderingTestDriver.cxx otbVectorDataToMapFilterWorld.cxx otbVectorDataToMapFilter.cxx otbVectorDataToMapFilterNew.cxx otbVectorDataToMapFilterNoFonts.cxx otbVectorDataToImageFilter.cxx otbVectorDataToMapFilterSensorModel.cxx ) add_executable(otbVectorDataRenderingTestDriver ${OTBVectorDataRenderingTests}) target_link_libraries(otbVectorDataRenderingTestDriver ${OTBVectorDataRendering-Test_LIBRARIES}) otb_module_target_label(otbVectorDataRenderingTestDriver) # Tests Declaration otb_add_test(NAME coTvVectorDataToMapFilterWorld COMMAND otbVectorDataRenderingTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvVectorDataToMapFilterWorld.png ${TEMP}/coTvVectorDataToMapFilterWorld.png otbVectorDataToMapFilterWorld ${INPUTDATA}/world_boundaries/world_boundaries_m.shp ${INPUTDATA}/world_boundaries/places.shp ${TEMP}/coTvVectorDataToMapFilterWorld.png 500 500 #Size -20 60 #lon/lat 0.1 -0.1 #spacing lon/lat ${INPUTDATA}/DejaVuSans.ttf # font ) otb_add_test(NAME coTvVectorDataToMapFilterBinary COMMAND otbVectorDataRenderingTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvVectorDataToMapFilterBinary.png ${TEMP}/coTvVectorDataToMapFilterBinary.png otbVectorDataToMapFilterBinary LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} ${TEMP}/coTvVectorDataToMapFilterBinary.png ) otb_add_test(NAME coTvVectorDataToMapFilter COMMAND otbVectorDataRenderingTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvVectorDataToMapFilter.png ${TEMP}/coTvVectorDataToMapFilter.png otbVectorDataToMapFilter LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} ${TEMP}/coTvVectorDataToMapFilter.png ${INPUTDATA}/DejaVuSans.ttf # font ) otb_add_test(NAME coTuVectorDataToMapFilterNew COMMAND otbVectorDataRenderingTestDriver otbVectorDataToMapFilterNew ) otb_add_test(NAME coTvVectorDataToMapFilterNoFonts COMMAND otbVectorDataRenderingTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvVectorDataToMapFilterNoFonts.png ${TEMP}/coTvVectorDataToMapFilterNoFonts.png otbVectorDataToMapFilterNoFonts LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} ${TEMP}/coTvVectorDataToMapFilterNoFonts.png ) otb_add_test(NAME coTvVectorDataToImageFilter COMMAND otbVectorDataRenderingTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvVectorDataToMapFilter.png ${TEMP}/coTvVectorDataToImageFilter.png otbVectorDataToImageFilter LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} ${TEMP}/coTvVectorDataToImageFilter.png ${INPUTDATA}/DejaVuSans.ttf # font ) otb_add_test(NAME coTvVectorDataToImageFilterBinary COMMAND otbVectorDataRenderingTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvVectorDataToMapFilterBinary.png ${TEMP}/coTvVectorDataToImageFilterBinary.png otbVectorDataToImageFilterBinary LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} ${TEMP}/coTvVectorDataToImageFilterBinary.png ) otb_add_test(NAME coTvVectorDataToMapFilterSensorModel COMMAND otbVectorDataRenderingTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvVectorDataToMapFilterSensorModel.png ${TEMP}/coTvVectorDataToMapFilterSensorModel.png otbVectorDataToMapFilterSensorModel LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/coTvVectorDataToMapFilterSensorModel.png ${INPUTDATA}/DejaVuSans.ttf # font ) OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/otbVectorDataRenderingTestDriver.cxx000066400000000000000000000006641301006202600327670ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbVectorDataToMapFilterWorld); REGISTER_TEST(otbVectorDataToMapFilter); REGISTER_TEST(otbVectorDataToMapFilterBinary); REGISTER_TEST(otbVectorDataToMapFilterNew); REGISTER_TEST(otbVectorDataToMapFilterNoFonts); REGISTER_TEST(otbVectorDataToImageFilter); REGISTER_TEST(otbVectorDataToImageFilterBinary); REGISTER_TEST(otbVectorDataToMapFilterSensorModel); } OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/otbVectorDataToImageFilter.cxx000066400000000000000000000161461301006202600315330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include #include #include "itkRGBAPixel.h" #include "otbImage.h" #include "otbVectorDataToImageFilter.h" int otbVectorDataToImageFilter(int argc, char * argv []) { if (argc < 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; projection->SetOutputProjectionRef(projectionRefWkt); //Convert the vector data into an image typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; origin[0] = 374149.980555821; //UL easting origin[1] = 4829183.99443839; //UL northing ImageType::SpacingType spacing; spacing[0] = 0.6; spacing[1] = -0.6; typedef otb::RemoteSensingRegion RegionType; RegionType region; RegionType::SizeType sizeInUnit; sizeInUnit[0] = size[0] * spacing[0]; sizeInUnit[1] = size[1] * spacing[1]; region.SetSize(sizeInUnit); region.SetOrigin(origin); region.SetRegionProjection(projectionRefWkt); typedef otb::VectorDataExtractROI ExtractROIType; ExtractROIType::Pointer extractROI = ExtractROIType::New(); extractROI->SetRegion(region); extractROI->SetInput(projection->GetOutput()); typedef otb::VectorDataToImageFilter VectorDataToImageFilterType; VectorDataToImageFilterType::Pointer vectorDataRendering = VectorDataToImageFilterType::New(); vectorDataRendering->SetInput(extractROI->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); vectorDataRendering->SetFontFileName(argv[3]); vectorDataRendering->AddStyle("minor-roads-casing"); vectorDataRendering->AddStyle("roads-text"); //Save the image in a file typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(vectorDataRendering->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } int otbVectorDataToImageFilterBinary(int argc, char * argv []) { if (argc < 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; projection->SetOutputProjectionRef(projectionRefWkt); //Convert the vector data into an image typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; origin[0] = 374149.980555821; //UL easting origin[1] = 4829183.99443839; //UL northing ImageType::SpacingType spacing; spacing[0] = 0.6; spacing[1] = -0.6; typedef otb::RemoteSensingRegion RegionType; RegionType region; RegionType::SizeType sizeInUnit; sizeInUnit[0] = size[0] * spacing[0]; sizeInUnit[1] = size[1] * spacing[1]; region.SetSize(sizeInUnit); region.SetOrigin(origin); region.SetRegionProjection(projectionRefWkt); typedef otb::VectorDataExtractROI ExtractROIType; ExtractROIType::Pointer extractROI = ExtractROIType::New(); extractROI->SetRegion(region); extractROI->SetInput(projection->GetOutput()); typedef otb::VectorDataToImageFilter VectorDataToImageFilterType; VectorDataToImageFilterType::Pointer vectorDataRendering = VectorDataToImageFilterType::New(); vectorDataRendering->SetInput(extractROI->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); vectorDataRendering->SetRenderingStyleType(VectorDataToImageFilterType::Binary); //Save the image in a file typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(vectorDataRendering->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/otbVectorDataToMapFilter.cxx000066400000000000000000000161141301006202600312210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include #include #include "itkRGBAPixel.h" #include "otbImage.h" #include "otbVectorDataToMapFilter.h" int otbVectorDataToMapFilter(int argc, char* argv []) { if (argc < 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; projection->SetOutputProjectionRef(projectionRefWkt); //Convert the vector data into an image typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; origin[0] = 374149.980555821; //UL easting origin[1] = 4829183.99443839; //UL northing ImageType::SpacingType spacing; spacing[0] = 0.6; spacing[1] = -0.6; typedef otb::RemoteSensingRegion RegionType; RegionType region; RegionType::SizeType sizeInUnit; sizeInUnit[0] = size[0] * spacing[0]; sizeInUnit[1] = size[1] * spacing[1]; region.SetSize(sizeInUnit); region.SetOrigin(origin); region.SetRegionProjection(projectionRefWkt); typedef otb::VectorDataExtractROI ExtractROIType; ExtractROIType::Pointer extractROI = ExtractROIType::New(); extractROI->SetRegion(region); extractROI->SetInput(projection->GetOutput()); typedef otb::VectorDataToMapFilter VectorDataToMapFilterType; VectorDataToMapFilterType::Pointer vectorDataRendering = VectorDataToMapFilterType::New(); vectorDataRendering->SetInput(extractROI->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); vectorDataRendering->SetFontFileName(argv[3]); vectorDataRendering->AddStyle("minor-roads-casing"); vectorDataRendering->AddStyle("roads-text"); //Save the image in a file typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(vectorDataRendering->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } int otbVectorDataToMapFilterBinary(int argc, char* argv []) { if (argc < 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; projection->SetOutputProjectionRef(projectionRefWkt); //Convert the vector data into an image typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; origin[0] = 374149.980555821; //UL easting origin[1] = 4829183.99443839; //UL northing ImageType::SpacingType spacing; spacing[0] = 0.6; spacing[1] = -0.6; typedef otb::RemoteSensingRegion RegionType; RegionType region; RegionType::SizeType sizeInUnit; sizeInUnit[0] = size[0] * spacing[0]; sizeInUnit[1] = size[1] * spacing[1]; region.SetSize(sizeInUnit); region.SetOrigin(origin); region.SetRegionProjection(projectionRefWkt); typedef otb::VectorDataExtractROI ExtractROIType; ExtractROIType::Pointer extractROI = ExtractROIType::New(); extractROI->SetRegion(region); extractROI->SetInput(projection->GetOutput()); typedef otb::VectorDataToMapFilter VectorDataToMapFilterType; VectorDataToMapFilterType::Pointer vectorDataRendering = VectorDataToMapFilterType::New(); vectorDataRendering->SetInput(extractROI->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); vectorDataRendering->SetRenderingStyleType(VectorDataToMapFilterType::Binary); //Save the image in a file typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(vectorDataRendering->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/otbVectorDataToMapFilterNew.cxx000066400000000000000000000022411301006202600316670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkRGBAPixel.h" #include "otbImage.h" #include "otbVectorData.h" #include "otbVectorDataToMapFilter.h" int otbVectorDataToMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorData<> VectorDataType; typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; typedef otb::VectorDataToMapFilter VectorDataToMapFilterType; VectorDataToMapFilterType::Pointer vectorDataRendering = VectorDataToMapFilterType::New(); std::cout << vectorDataRendering << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/otbVectorDataToMapFilterNoFonts.cxx000066400000000000000000000076061301006202600325360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include #include #include "itkRGBAPixel.h" #include "otbImage.h" #include "otbVectorDataToMapFilter.h" int otbVectorDataToMapFilterNoFonts(int argc, char * argv []) { if (argc < 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); std::string projectionRefWkt = "PROJCS[\"UTM Zone 31, Northern Hemisphere\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]], AXIS[\"Lat\", NORTH], AXIS[\"Long\", EAST], AUTHORITY[\"EPSG\",\"4326\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", 3], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", 0], UNIT[\"Meter\", 1]]"; projection->SetOutputProjectionRef(projectionRefWkt); //Convert the vector data into an image typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; origin[0] = 374149.980555821; //UL easting origin[1] = 4829183.99443839; //UL northing ImageType::SpacingType spacing; spacing[0] = 0.6; spacing[1] = -0.6; typedef otb::RemoteSensingRegion RegionType; RegionType region; RegionType::SizeType sizeInUnit; sizeInUnit[0] = size[0] * spacing[0]; sizeInUnit[1] = size[1] * spacing[1]; region.SetSize(sizeInUnit); region.SetOrigin(origin); region.SetRegionProjection(projectionRefWkt); typedef otb::VectorDataExtractROI ExtractROIType; ExtractROIType::Pointer extractROI = ExtractROIType::New(); extractROI->SetRegion(region); extractROI->SetInput(projection->GetOutput()); typedef otb::VectorDataToMapFilter VectorDataToMapFilterType; VectorDataToMapFilterType::Pointer vectorDataRendering = VectorDataToMapFilterType::New(); vectorDataRendering->SetInput(extractROI->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); vectorDataRendering->AddStyle("minor-roads-casing"); //Save the image in a file typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(vectorDataRendering->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/otbVectorDataToMapFilterSensorModel.cxx000066400000000000000000000076101301006202600333750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVectorDataFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include "itkRGBAPixel.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbVectorDataToMapFilter.h" int otbVectorDataToMapFilterSensorModel(int argc, char * argv []) { if (argc < 5) { std::cout << argv[0] << " " << " " << "" << std::endl; return EXIT_FAILURE; } //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); //Read the image (only for the information) typedef otb::Image SensorImageType; typedef otb::ImageFileReader ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; ProjectionFilterType::Pointer projection = ProjectionFilterType::New(); projection->SetInput(reader->GetOutput()); projection->SetOutputKeywordList(imageReader->GetOutput()->GetImageKeywordlist()); projection->SetOutputOrigin(imageReader->GetOutput()->GetOrigin()); projection->SetOutputSpacing(imageReader->GetOutput()->GetSpacing()); //Convert the vector data into an image typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; ImageType::SizeType size; size[0] = 500; size[1] = 500; ImageType::PointType origin; // origin[0] = imageReader->GetOutput()->GetOrigin()[0]; // origin[1] = imageReader->GetOutput()->GetOrigin()[1]; origin[0] = 11052; origin[1] = 7585; ImageType::SpacingType spacing; // spacing[0] = imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]/static_cast(size[0]); // spacing[1] = imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]/static_cast(size[1]); spacing[0] = 500 / static_cast(size[0]); spacing[1] = 500 / static_cast(size[1]); std::cout << "Size: " << size << std::endl; std::cout << "Origin: " << origin << std::endl; std::cout << "Spacing: " << spacing << std::endl; typedef otb::VectorDataToMapFilter VectorDataToMapFilterType; VectorDataToMapFilterType::Pointer vectorDataRendering = VectorDataToMapFilterType::New(); vectorDataRendering->SetInput(projection->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); vectorDataRendering->SetFontFileName(argv[4]); vectorDataRendering->AddStyle("minor-roads-casing"); vectorDataRendering->AddStyle("roads-text"); //Save the image in a file typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(vectorDataRendering->GetOutput()); writer->SetFileName(argv[3]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/VectorDataRendering/test/otbVectorDataToMapFilterWorld.cxx000066400000000000000000000071261301006202600322340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include #include #include "itkRGBAPixel.h" #include "otbImage.h" #include "otbVectorDataToMapFilter.h" int otbVectorDataToMapFilterWorld(int argc, char * argv []) { if (argc < 11) { std::cout << argv[0] << " " << " " << " " << " " << " " << " " << std::endl; return EXIT_FAILURE; } //Read the vector data typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; //Reproject the vector data in the proper projection typedef otb::VectorDataProjectionFilter ProjectionFilterType; std::string outputProjRef("GEOGCS[\"GCS_WGS_1984\", DATUM[\"D_WGS_1984\", " "SPHEROID[\"WGS_1984\", 6378137, 298.257223563]], PRIMEM[\"Greenwich\", 0]," " UNIT[\"Degree\", 0.017453292519943295]]"); VectorDataFileReaderType::Pointer reader0 = VectorDataFileReaderType::New(); reader0->SetFileName(argv[1]); ProjectionFilterType::Pointer projection0 = ProjectionFilterType::New(); projection0->SetInput(reader0->GetOutput()); projection0->SetOutputProjectionRef(outputProjRef); VectorDataFileReaderType::Pointer reader1 = VectorDataFileReaderType::New(); reader1->SetFileName(argv[2]); ProjectionFilterType::Pointer projection1 = ProjectionFilterType::New(); projection1->SetInput(reader1->GetOutput()); projection1->SetOutputProjectionRef(outputProjRef); //Convert the vector data into an image typedef itk::RGBAPixel PixelType; typedef otb::Image ImageType; ImageType::SizeType size; size[0] = atoi(argv[4]); size[1] = atoi(argv[5]); ImageType::PointType origin; origin[0] = atof(argv[6]); origin[1] = atof(argv[7]); ImageType::SpacingType spacing; spacing[0] = atof(argv[8]); spacing[1] = atof(argv[9]); typedef otb::VectorDataToMapFilter VectorDataToMapFilterType; VectorDataToMapFilterType::Pointer vectorDataRendering = VectorDataToMapFilterType::New(); vectorDataRendering->SetInput(0, projection0->GetOutput()); vectorDataRendering->SetInput(1, projection1->GetOutput()); vectorDataRendering->SetSize(size); vectorDataRendering->SetOrigin(origin); vectorDataRendering->SetSpacing(spacing); vectorDataRendering->SetFontFileName(argv[10]); vectorDataRendering->AddStyle("world"); vectorDataRendering->AddStyle("city"); vectorDataRendering->UseAsOverlayOff(); //Save the image in a file typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(vectorDataRendering->GetOutput()); writer->SetFileName(argv[3]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/000077500000000000000000000000001301006202600203605ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Wavelet/CMakeLists.txt000066400000000000000000000001141301006202600231140ustar00rootroot00000000000000project(OTBWavelet) set(OTBWavelet_LIBRARIES OTBWavelet) otb_module_impl() OTB-release-5.8/Modules/Filtering/Wavelet/include/000077500000000000000000000000001301006202600220035ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Wavelet/include/otbSubsampleImageFilter.h000066400000000000000000000125371301006202600267350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSubsampleImageFilter_h #define otbSubsampleImageFilter_h #include "itkImageToImageFilter.h" #include "itkImage.h" //Just to get the forward/inverse definitions #include "otbWaveletOperatorBase.h" namespace otb { /** \class SubsampleImageFilter * \brief Performs a down sampling of an image * * This class performs a simple resampling image filtering. * * The third template is a Wavelet::FORWARD/Wavelet::INVERSE Wavelet::WaveletDirection * enumeration type. With Wavelet::FORWARD, the output image is of the same size of the one of * the input image. But the output image contains only co-located subsample, the rest being 0. * When Wavelet::INVERSE is used, the input image is considered as the sub-sampled. Then, the output * image is larger. Initial pixel values are preserved but the output image is interleaved with * 0. * * \sa ResampleImageFilter * \sa SubsampleImageRegionConstIterator * \sa DecimateImageFilter * * \ingroup OTBWavelet */ template class ITK_EXPORT SubsampleImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef SubsampleImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SubsampleImageFilter, ImageToImageFilter); /** Extract dimension from input and output image. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Direction definition */ typedef Wavelet::WaveletDirection DirectionOfTransformationEnumType; itkStaticConstMacro(DirectionOfTransformation, DirectionOfTransformationEnumType, TDirectionOfTransformation); /** Image typedef support. */ typedef TInputImage InputImageType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::IndexType InputImageIndexType; typedef typename InputImageIndexType::IndexValueType InputImageIndexValueType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename OutputImageType::IndexType OutputImageIndexType; typedef typename OutputImageType::PixelType OutputPixelType; /** Set/Get the SubsampleFactor */ itkGetMacro(SubsampleFactor, const InputImageIndexType &); itkSetMacro(SubsampleFactor, InputImageIndexType &); void SetSubSampleFactor(InputImageIndexValueType factor) { InputImageIndexType indexFactor; indexFactor.Fill(factor); SetSubSampleFactor(indexFactor); } protected: SubsampleImageFilter () { m_SubsampleFactor.Fill(1); //this->SetNumberOfThreads(1); } ~SubsampleImageFilter() ITK_OVERRIDE {} /** Internal test function to check if there is any direction to subsample */ bool IsSubsampleFactorOne() const; /** Since input and output image are very likely to be of different size. * Region estimation functions has to be reimplemented */ void CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) ITK_OVERRIDE; void CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) ITK_OVERRIDE; /** Output image region size is not of the same dimension as the input. * That is why GenerateOutputInformation has to be redefined. */ void GenerateOutputInformation() ITK_OVERRIDE; /** Set output image to 0 before processing */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Allows multithreading */ void ThreadedGenerateData (const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SubsampleImageFilter (const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented InputImageIndexType m_SubsampleFactor; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSubsampleImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbSubsampleImageFilter.txx000066400000000000000000000144521301006202600273270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSubsampleImageFilter_txx #define otbSubsampleImageFilter_txx #include "otbSubsampleImageFilter.h" #include "otbMacro.h" #include "otbSubsampledImageRegionIterator.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template void SubsampleImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "SubsampleFactor = [" << m_SubsampleFactor[0]; for (unsigned int i = 1; i < InputImageDimension; ++i) { os << ", " << m_SubsampleFactor[i]; } os << "]\n"; } template bool SubsampleImageFilter ::IsSubsampleFactorOne() const { for (unsigned int i = 0; i < InputImageDimension; ++i) { if (m_SubsampleFactor[i] != 1) return false; } return true; } template void SubsampleImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (!IsSubsampleFactorOne()) { OutputImageRegionType newRegion; this->CallCopyInputRegionToOutputRegion(newRegion, this->GetInput()->GetLargestPossibleRegion()); this->GetOutput()->SetRegions(newRegion); } } template void SubsampleImageFilter ::CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) { Superclass::CallCopyOutputRegionToInputRegion(destRegion, srcRegion); if (static_cast(DirectionOfTransformation) == Wavelet::INVERSE) { typename OutputImageRegionType::IndexType srcIndex = srcRegion.GetIndex(); typename OutputImageRegionType::SizeType srcSize = srcRegion.GetSize(); typename InputImageRegionType::IndexType destIndex; typename InputImageRegionType::SizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { // TODO: This seems not right in odd index cases destIndex[i] = srcIndex[i] / m_SubsampleFactor[i]; destSize[i] = srcSize[i] / m_SubsampleFactor[i]; } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void SubsampleImageFilter ::CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) { Superclass::CallCopyInputRegionToOutputRegion(destRegion, srcRegion); if (static_cast(DirectionOfTransformation) == Wavelet::INVERSE) { typename InputImageRegionType::IndexType srcIndex = srcRegion.GetIndex(); typename InputImageRegionType::SizeType srcSize = srcRegion.GetSize(); typename OutputImageRegionType::IndexType destIndex; typename OutputImageRegionType::SizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { destIndex[i] = srcIndex[i] * m_SubsampleFactor[i]; destSize[i] = srcSize[i] * m_SubsampleFactor[i]; } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void SubsampleImageFilter ::BeforeThreadedGenerateData() { OutputImagePointerType output = this->GetOutput(); output->FillBuffer(0); } template void SubsampleImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { OutputImagePointerType output = this->GetOutput(); SubsampledImageRegionIterator outputIter (this->GetOutput(), outputRegionForThread); outputIter.SetSubsampleFactor(1); outputIter.GoToBegin(); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); SubsampledImageRegionConstIterator inputIter (this->GetInput(), inputRegionForThread); if (static_cast(itkGetStaticConstMacro(DirectionOfTransformation)) == static_cast(Wavelet::FORWARD)) { inputIter.SetSubsampleFactor(GetSubsampleFactor()); inputIter.GoToBegin(); while (!inputIter.IsAtEnd()) { outputIter.SetOffset( static_cast::OffsetType> (inputIter.GetOffset())); outputIter.Set(static_cast(inputIter.Get())); ++inputIter; } } else { inputIter.SetSubsampleFactor(1); inputIter.GoToBegin(); while (!inputIter.IsAtEnd()) { InputImageIndexType inputIndex = inputIter.GetIndex(); OutputImageIndexType outputIndex; for (unsigned int i = 0; i < OutputImageDimension; ++i) { outputIndex[i] = inputIndex[i] * m_SubsampleFactor[i]; } outputIter.SetIndex(outputIndex); outputIter.Set(static_cast(inputIter.Get())); ++inputIter; } } } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletFilterBank.h000066400000000000000000000461051301006202600262400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletFilterBank_h #define otbWaveletFilterBank_h #include "itkProgressReporter.h" #include "itkImageToImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkNeighborhoodInnerProduct.h" #include "otbWaveletOperatorBase.h" namespace otb { /** \class WaveletFilterBank * \brief One level stationary wavelet transform * * This implementation performs a low-pass / high-pass wavelet transformation * of an image. The wavelet transformation is defined by a inner product * (ie. convolution-like operation). * * the inner operator are supposed to be defined through 1D filters. Then, the * forward transformation yields \f$ 2^{\text{Dim}} \f$ output images, while the inverse * transformation requires \f$ 2^{\text{Dim}} \f$ input image for one output. * * In case of 1D, GetOutput(0) -> LowPass * * GetOutput(1) -> HighPass * * In case of 2D, Line (Dim 1) Col (Dim 0) * * GetOutput(0) -> LowPass, LowPass * * GetOutput(1) -> LowPass, HighPass * * GetOutput(2) -> HighPass, LowPass * * GetOutput(3) -> HighPass, HighPass * * In case of nD data, assume x_n=0 stands for LowPass and x_n=1 stands for HighPass * at a give dimension n. Then * * GetOutput( x_(n-1) << (n-1) + x_(n-2) << (n-2) + ... + x_1 << 1 + x_0 ) * * Dim (n-1) Dim (n-2) Dim (n-3) ... Dim 1 Dim 0 * * -> x_(n-1) x_(n-2) x_(n-3) x_1 x_0 * * And conversely in the inverse transformation. * * \todo: At present version, there is not consideration on meta data information that can be transmitted * from the input(s) to the output(s)... * * The two choice (Wavelet::FORWARD/Wavelet::INVERSE) yield specific implementation of the templates (header redeclaration * is given at bottom of otbWaveletFilterBank.h for the Wavelet::INVERSE case) * * \sa WaveletOperator * * \ingroup Streamed * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletFilterBank : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef WaveletFilterBank Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletFilterBank, ImageToImageFilter); protected: WaveletFilterBank(); virtual ~WaveletFilterBank(); private: WaveletFilterBank(const Self &); void operator =(const Self&); }; // end of class /** \class WaveletFilterBank * \brief Template specialization of FilterBank for forward transformation * * This implementation performs a low-pass / high-pass wavelet transformation * of an image. The wavelet transformation is defined by a inner product * (ie. convolution-like operation). * * The inner operator are supposed to be defined through 1D filters. Then, the * forward transformation yields \f$ 2^{\text{Dim}} \f$ output images, while the inverse * transformation requires \f$ 2^{\text{Dim}} \f$ input image for one output. * * In case of 1D, GetOutput(0) -> LowPass * * GetOutput(1) -> HighPass * * In case of 2D, Line (Dim 1) Col (Dim 0) * * GetOutput(0) -> LowPass, LowPass * * GetOutput(1) -> LowPass, HighPass * * GetOutput(2) -> HighPass, LowPass * * GetOutput(3) -> HighPass, HighPass * * In case of nD data, assume x_n=0 stands for LowPass and x_n=1 stands for HighPass * at a give dimension n. Then * * GetOutput( x_(n-1) << (n-1) + x_(n-2) << (n-2) + ... + x_1 << 1 + x_0 ) * * Dim (n-1) Dim (n-2) Dim (n-3) ... Dim 1 Dim 0 * * -> x_(n-1) x_(n-2) x_(n-3) x_1 x_0 * * And conversely in the inverse transformation. * * \todo: At present version, there is not consideration on meta data information that can be transmitted * from the input(s) to the output(s)... * * \sa WaveletOperator * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletFilterBank : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef WaveletFilterBank Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletFilterBank, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::PixelType OutputPixelType; typedef TWaveletOperator WaveletOperatorType; typedef typename WaveletOperatorType::LowPassOperator LowPassOperatorType; typedef typename WaveletOperatorType::HighPassOperator HighPassOperatorType; typedef Wavelet::WaveletDirection DirectionOfTransformationEnumType; itkStaticConstMacro(DirectionOfTransformation, DirectionOfTransformationEnumType, Wavelet::FORWARD); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** * Set/Get the level of up sampling of the filter used in the A-trou algorithm. */ itkGetMacro(UpSampleFilterFactor, unsigned int); itkSetMacro(UpSampleFilterFactor, unsigned int); /** * Set/Get the level of down sampling of the image used in forward algorithm. * (or upsampling in the inverse case) * * In this implementation, we are not dealing with M-band decomposition then m_SubsampleImageFactor * is most likely to be 1 or 2... but in any case integer and not real... */ itkGetMacro(SubsampleImageFactor, unsigned int); itkSetMacro(SubsampleImageFactor, unsigned int); protected: WaveletFilterBank(); ~WaveletFilterBank() ITK_OVERRIDE {} /** GenerateOutputInformation * Set the size of the output image depending on the decimation factor * Copy information from the input image if existing. **/ void GenerateOutputInformation() ITK_OVERRIDE; /** The forward transformation needs a larger input requested * region than the output requested region (larger by subsampling * but also by the kernel size used in the filter bank). * * Then, the class needs to provide an implementation * for GenerateInputRequestedRegion() in order to inform the * pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) ITK_OVERRIDE; /** BeforeThreadedGenerateData. * It allocates also internal images */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Internal Data Allocation * If m_SubsampleImageFactor != 1, internal data with progressive region size * subsampling if required... */ virtual void AllocateInternalData(const OutputImageRegionType& outputRegion); /** AfterThreadedGenerateData. * It enforce memory destruction of internal images */ void AfterThreadedGenerateData() ITK_OVERRIDE; /** CallCopyOutputRegionToInputRegion * Since input and output image may be of different size when a * subsampling factor has tp be applied, Region estimation * functions has to be reimplemented */ void CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) ITK_OVERRIDE; void CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) ITK_OVERRIDE; /** CallCopyOutputRegionToInputRegion * This function is also redefined in order to adapt the shape of the regions with * resect to the direction (among the dimensions) of the filtering. */ virtual void CallCopyOutputRegionToInputRegion(unsigned int direction, InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion); virtual void CallCopyInputRegionToOutputRegion(unsigned int direction, OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion); /** Generate data redefinition */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Iterative call to the forward filter bank at each dimension. */ virtual void ThreadedGenerateDataAtDimensionN(unsigned int idx, unsigned int direction, itk::ProgressReporter& reporter, const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId); private: WaveletFilterBank(const Self &); void operator =(const Self&); unsigned int m_UpSampleFilterFactor; unsigned int m_SubsampleImageFactor; /** the easiest way to store internal images is to keep track of the splits * at each direction. Then, std::vector< InternalImagesTabular > is a tab of * size ImageDimension-1 and each InternalImagesTabular contains intermediate * images. */ typedef std::vector InternalImagesTabular; std::vector m_InternalImages; }; // end of class /** \class WaveletFilterBank * \brief Template specialization of FilterBank for inverse transformation * * This implementation performs a low-pass / high-pass wavelet transformation * of an image. The wavelet transformation is defined by a inner product * (ie. convolution-like operation). * * The inner operator are supposed to be defined through 1D filters. Then, the * forward transformation yields \f$ 2^{\text{Dim}} \f$ output images, while the inverse * transformation requires \f$ 2^{\text{Dim}} \f$ input image for one output. * * In case of 1D, GetOutput(0) -> LowPass * * GetOutput(1) -> HighPass * * In case of 2D, Line (Dim 1) Col (Dim 0) * * GetOutput(0) -> LowPass, LowPass * * GetOutput(1) -> LowPass, HighPass * * GetOutput(2) -> HighPass, LowPass * * GetOutput(3) -> HighPass, HighPass * * In case of nD data, assume x_n=0 stands for LowPass and x_n=1 stands for HighPass * at a give dimension n. Then * * GetOutput( x_(n-1) << (n-1) + x_(n-2) << (n-2) + ... + x_1 << 1 + x_0 ) * * Dim (n-1) Dim (n-2) Dim (n-3) ... Dim 1 Dim 0 * * -> x_(n-1) x_(n-2) x_(n-3) x_1 x_0 * * And conversely in the inverse transformation. * * \todo: At present version, there is not consideration on meta data information that can be transmitted * from the input(s) to the output(s)... * * \sa WaveletOperator * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletFilterBank : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef WaveletFilterBank Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletFilterBank, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::PixelType OutputPixelType; typedef TWaveletOperator WaveletOperatorType; typedef typename WaveletOperatorType::LowPassOperator LowPassOperatorType; typedef typename WaveletOperatorType::HighPassOperator HighPassOperatorType; typedef Wavelet::WaveletDirection DirectionOfTransformationEnumType; itkStaticConstMacro(DirectionOfTransformation, DirectionOfTransformationEnumType, Wavelet::INVERSE); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** * Set/Get the level of up sampling of the filter used in the A-trou algorithm. */ itkGetMacro(UpSampleFilterFactor, unsigned int); itkSetMacro(UpSampleFilterFactor, unsigned int); /** * Set/Get the level of down sampling of the image used in forward algorithm. * (or upsampling in the inverse case) * * In this implementation, we are dealing with M-band decomposition then m_SubsampleImageFactor * is most likely to be 1 or 2... but in any case integer and not real... */ itkGetMacro(SubsampleImageFactor, unsigned int); itkSetMacro(SubsampleImageFactor, unsigned int); protected: WaveletFilterBank(); ~WaveletFilterBank() ITK_OVERRIDE {} /** GenerateOutputInformation * Set the size of the output image depending on the decimation factor * Copy information from the input image if existing. **/ void GenerateOutputInformation() ITK_OVERRIDE; /** The inverse transformation needs larger inputs requested * region than the output requested region (larger by subsampling * but also by the kernel size used in the filter bank). * * Then, the class needs to provide an implementation * for GenerateInputRequestedRegion() in order to inform the * pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) ITK_OVERRIDE; /** BeforeThreadedGenerateData * If SubsampleImageFactor neq 1, it is necessary to up sample input images in the Wavelet::INVERSE mode */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Internal Data Allocation * If m_SubsampleImageFactor != 1, internal data with progressive region size * subsampling if required... */ virtual void AllocateInternalData(const OutputImageRegionType& outputRegion); /** AfterThreadedGenerateData. * It enforce memory destruction of internal images */ void AfterThreadedGenerateData() ITK_OVERRIDE; /** CallCopyOutputRegionToInputRegion * Since input and output image may be of different size when a * subsampling factor has tp be applied, Region estimation * functions has to be reimplemented */ void CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) ITK_OVERRIDE; void CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) ITK_OVERRIDE; /** CallCopyOutputRegionToInputRegion * This function is also redefined in order to adapt the shape of the regions with * resect to the direction (among the dimensions) of the filtering. */ virtual void CallCopyOutputRegionToInputRegion(unsigned int direction, InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion); virtual void CallCopyInputRegionToOutputRegion(unsigned int direction, OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion); /** Generate data redefinition */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** * Iterative call to the forward filter bank at each dimension. * Used for the multiresolution case only. */ virtual void ThreadedGenerateDataAtDimensionN(unsigned int direction, itk::ProgressReporter& reporter, const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId); private: WaveletFilterBank(const Self &); void operator =(const Self&); unsigned int m_UpSampleFilterFactor; unsigned int m_SubsampleImageFactor; /** the easiest way to store internal images is to keep track of the splits * at each direction. Then, std::vector< InternalImagesTabular > is a tab of * size ImageDimension-1 and each InternalImagesTabular contains intermediate * images. Internal images are used for multiresolution case only. */ typedef std::vector InternalImagesTabular; std::vector m_InternalImages; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbWaveletFilterBank.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletFilterBank.txx000066400000000000000000001322031301006202600266270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletFilterBank_txx #define otbWaveletFilterBank_txx #include "otbWaveletFilterBank.h" #include "otbSubsampleImageFilter.h" #include "otbSubsampledImageRegionConstIterator.h" #include "itkPeriodicBoundaryCondition.h" // FIXME #define __myDebug__ 0 namespace otb { /** * Template Specialization for the Wavelet::FORWARD case */ template WaveletFilterBank ::WaveletFilterBank () { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredInputs(1); unsigned int numOfOutputs = 1 << InputImageDimension; this->SetNumberOfRequiredOutputs(numOfOutputs); for (unsigned int i = 0; i < numOfOutputs; ++i) { this->SetNthOutput(i, OutputImageType::New()); } m_UpSampleFilterFactor = 0; m_SubsampleImageFactor = 1; //this->SetNumberOfThreads(1); } template void WaveletFilterBank ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (GetSubsampleImageFactor() == 1) return; #if __myDebug__ otbGenericMsgDebugMacro(<< " down sampling output regions by a factor of " << GetSubsampleImageFactor()); otbGenericMsgDebugMacro(<< "initial region " << this->GetInput()->GetLargestPossibleRegion().GetSize()[0] << "," << this->GetInput()->GetLargestPossibleRegion().GetSize()[1]); #endif OutputImageRegionType newRegion; this->CallCopyInputRegionToOutputRegion(newRegion, this->GetInput()->GetLargestPossibleRegion()); for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { this->GetOutput(i)->SetRegions(newRegion); } #if __myDebug__ otbGenericMsgDebugMacro(<< "new region output " << newRegion.GetSize()[0] << "," << newRegion.GetSize()[1]); #endif } template void WaveletFilterBank ::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { Superclass::GenerateInputRequestedRegion(); // Filter length calculation LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(0); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); unsigned int radius = lowPassOperator.GetRadius()[0]; HighPassOperatorType highPassOperator; highPassOperator.SetDirection(0); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); if (radius < highPassOperator.GetRadius()[0]) radius = highPassOperator.GetRadius()[0]; // Get the requested region and pad it InputImagePointerType input = const_cast(this->GetInput()); InputImageRegionType inputRegion = input->GetRequestedRegion(); inputRegion.PadByRadius(radius); if (inputRegion.Crop(input->GetLargestPossibleRegion())) { input->SetRequestedRegion(inputRegion); } else { input->SetRequestedRegion(inputRegion); itk::InvalidRequestedRegionError err(__FILE__, __LINE__); err.SetLocation(ITK_LOCATION); err.SetDescription("Requested region is (at least partially) outside the largest possible region."); err.SetDataObject(input); throw err; } } template void WaveletFilterBank ::BeforeThreadedGenerateData() { unsigned int one = 1; if (m_SubsampleImageFactor > 1) { // Check the dimension for (unsigned int i = 0; i < InputImageDimension; ++i) { if ((m_SubsampleImageFactor * (this->GetInput()->GetRequestedRegion().GetSize()[i] / m_SubsampleImageFactor)) != this->GetInput()->GetRequestedRegion().GetSize()[i]) { itk::InvalidRequestedRegionError err(__FILE__, __LINE__); err.SetLocation(ITK_LOCATION); err.SetDescription("Requested region dimension cannot be used in multiresolution analysis (crop it)."); err.SetDataObject(const_cast(this->GetInput())); throw err; } } if (InputImageDimension > 1) { // Internal images will be used only if m_SubsampledInputImages != 1 m_InternalImages.resize(InputImageDimension - 1); for (unsigned int i = 0; i < m_InternalImages.size(); ++i) { // the size is linked to the SubsampleImageFactor that is assume to be 2!!! m_InternalImages[InputImageDimension - 2 - i].resize( one << (i + 1)); } OutputImageRegionType intermediateRegion; this->Superclass::CallCopyInputRegionToOutputRegion(intermediateRegion, this->GetInput()->GetLargestPossibleRegion()); AllocateInternalData(intermediateRegion); } } } template void WaveletFilterBank ::AllocateInternalData (const OutputImageRegionType& outputRegion) { OutputImageRegionType smallerRegion; OutputImageRegionType largerRegion = outputRegion; for (unsigned int direction = 0; direction < InputImageDimension - 1; direction++) { this->CallCopyInputRegionToOutputRegion(InputImageDimension - 1 - direction, smallerRegion, largerRegion); for (unsigned int i = 0; i < m_InternalImages[direction].size(); ++i) { m_InternalImages[InputImageDimension - 2 - direction][i] = OutputImageType::New(); m_InternalImages[InputImageDimension - 2 - direction][i]->SetRegions(smallerRegion); m_InternalImages[InputImageDimension - 2 - direction][i]->Allocate(); m_InternalImages[InputImageDimension - 2 - direction][i]->FillBuffer(0); } largerRegion = smallerRegion; } } template void WaveletFilterBank ::AfterThreadedGenerateData() { if (m_SubsampleImageFactor > 1 && InputImageDimension > 1) { m_InternalImages.clear(); } } template void WaveletFilterBank ::CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) { Superclass::CallCopyOutputRegionToInputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { OutputIndexType srcIndex = srcRegion.GetIndex(); OutputSizeType srcSize = srcRegion.GetSize(); InputIndexType destIndex; InputSizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { destIndex[i] = srcIndex[i] * GetSubsampleImageFactor(); destSize[i] = srcSize[i] * GetSubsampleImageFactor(); } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); #if 0 // Contrairement a Wavelet::INVERSE, ici ca ne sera a rien apparemment... // Region Padding LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(0); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); unsigned long radius[InputImageDimension]; radius[0] = lowPassOperator.GetRadius()[0]; HighPassOperatorType highPassOperator; highPassOperator.SetDirection(0); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); if (radius[0] < highPassOperator.GetRadius()[0]) radius[0] = highPassOperator.GetRadius()[0]; for (unsigned int i = 1; i < InputImageDimension; ++i) radius[i] = 0; InputImageRegionType paddedRegion = destRegion; paddedRegion.PadByRadius(radius); if (paddedRegion.Crop(this->GetInput()->GetLargestPossibleRegion())) { destRegion = paddedRegion; } #endif } } template void WaveletFilterBank ::CallCopyOutputRegionToInputRegion (unsigned int direction, InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) { Superclass::CallCopyOutputRegionToInputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { OutputIndexType srcIndex = srcRegion.GetIndex(); OutputSizeType srcSize = srcRegion.GetSize(); InputIndexType destIndex; InputSizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { if (i == direction) { destIndex[i] = srcIndex[i] * GetSubsampleImageFactor(); destSize[i] = srcSize[i] * GetSubsampleImageFactor(); } else { destIndex[i] = srcIndex[i]; destSize[i] = srcSize[i]; } } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void WaveletFilterBank ::CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) { Superclass::CallCopyInputRegionToOutputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { typename InputImageRegionType::IndexType srcIndex = srcRegion.GetIndex(); typename InputImageRegionType::SizeType srcSize = srcRegion.GetSize(); typename OutputImageRegionType::IndexType destIndex; typename OutputImageRegionType::SizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { // TODO: This seems not right in odd index cases destIndex[i] = srcIndex[i] / GetSubsampleImageFactor(); destSize[i] = srcSize[i] / GetSubsampleImageFactor(); } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void WaveletFilterBank ::CallCopyInputRegionToOutputRegion (unsigned int direction, OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) { Superclass::CallCopyInputRegionToOutputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { typename InputImageRegionType::IndexType srcIndex = srcRegion.GetIndex(); typename InputImageRegionType::SizeType srcSize = srcRegion.GetSize(); typename OutputImageRegionType::IndexType destIndex; typename OutputImageRegionType::SizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { if (i == direction) { // TODO: This seems not right in odd index cases destIndex[i] = srcIndex[i] / GetSubsampleImageFactor(); destSize[i] = srcSize[i] / GetSubsampleImageFactor(); } else { destIndex[i] = srcIndex[i]; destSize[i] = srcSize[i]; } } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void WaveletFilterBank ::ThreadedGenerateData (const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { unsigned int dir = InputImageDimension - 1; if ((1 << dir) >= static_cast(this->GetNumberOfOutputs())) { std::ostringstream msg; msg << "Output number 1<<" << dir << " = " << (1 << dir) << " not allocated\n"; msg << "Number of expected outputs " << this->GetNumberOfOutputs() << "\n"; throw itk::ExceptionObject(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); } itk::ProgressReporter reporter(this, threadId, outputRegionForThread.GetNumberOfPixels() * this->GetNumberOfOutputs() * 2); const InputImageType * input = this->GetInput(); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); OutputImagePointerType outputLowPass = this->GetOutput(0); OutputImagePointerType outputHighPass = this->GetOutput(1 << dir); // On multidimensional case, if m_SubsampleImageFactor != 1, we need internal images of different size if (dir != 0 && m_SubsampleImageFactor > 1) { outputLowPass = m_InternalImages[dir - 1][0]; outputHighPass = m_InternalImages[dir - 1][1]; } // typedef for the iterations over the input image typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::NeighborhoodInnerProduct InnerProductType; typedef itk::ImageRegionIterator IteratorType; // Prepare the subsampling image factor, if any. typedef SubsampledImageRegionConstIterator SubsampleIteratorType; typename SubsampleIteratorType::IndexType subsampling; subsampling.Fill(1); subsampling[dir] = GetSubsampleImageFactor(); // Inner product InnerProductType innerProduct; // High pass part calculation HighPassOperatorType highPassOperator; highPassOperator.SetDirection(dir); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); SubsampleIteratorType subItHighPass(input, inputRegionForThread); subItHighPass.SetSubsampleFactor(subsampling); subItHighPass.GoToBegin(); NeighborhoodIteratorType itHighPass(highPassOperator.GetRadius(), input, inputRegionForThread); itk::PeriodicBoundaryCondition boundaryCondition; itHighPass.OverrideBoundaryCondition(&boundaryCondition); IteratorType outHighPass(outputHighPass, subItHighPass.GenerateOutputInformation()); outHighPass.GoToBegin(); while (!subItHighPass.IsAtEnd() && !outHighPass.IsAtEnd()) { itHighPass.SetLocation(subItHighPass.GetIndex()); outHighPass.Set(innerProduct(itHighPass, highPassOperator)); ++subItHighPass; ++outHighPass; reporter.CompletedPixel(); } // Low pass part calculation LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(dir); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); SubsampleIteratorType subItLowPass(input, inputRegionForThread); subItLowPass.SetSubsampleFactor(subsampling); subItLowPass.GoToBegin(); NeighborhoodIteratorType itLowPass(lowPassOperator.GetRadius(), input, inputRegionForThread); itLowPass.OverrideBoundaryCondition(&boundaryCondition); IteratorType outLowPass(outputLowPass, subItLowPass.GenerateOutputInformation()); outLowPass.GoToBegin(); while (!subItLowPass.IsAtEnd() && !outLowPass.IsAtEnd()) { itLowPass.SetLocation(subItLowPass.GetIndex()); outLowPass.Set(innerProduct(itLowPass, lowPassOperator)); ++subItLowPass; ++outLowPass; reporter.CompletedPixel(); } if (dir > 0) { // Note that outputImageRegion correspond to the actual region of (local) input ! OutputImageRegionType outputImageRegion; this->CallCopyInputRegionToOutputRegion(dir, outputImageRegion, inputRegionForThread); ThreadedGenerateDataAtDimensionN(0, dir - 1, reporter, outputImageRegion, threadId); ThreadedGenerateDataAtDimensionN(1 << dir, dir - 1, reporter, outputImageRegion, threadId); } } template void WaveletFilterBank ::ThreadedGenerateDataAtDimensionN (unsigned int idx, unsigned int direction, itk::ProgressReporter& reporter, const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Note that outputRegionForThread correspond to the actual region of input ! OutputImagePointerType input = this->GetOutput(idx); OutputImagePointerType outputHighPass = this->GetOutput(idx + (1 << direction)); OutputImagePointerType outputLowPass = OutputImageType::New(); OutputImageRegionType outputImageRegion; this->CallCopyInputRegionToOutputRegion(direction, outputImageRegion, outputRegionForThread); if (m_SubsampleImageFactor > 1) { input = m_InternalImages[direction][idx / (1 << (direction + 1))]; if (direction != 0) { outputLowPass = m_InternalImages[direction - 1][idx / (1 << direction)]; outputHighPass = m_InternalImages[direction - 1][idx / (1 << direction) + 1]; } } if (direction == 0) { // The output image has to be allocated // May be not valid on multithreaded process ??? outputLowPass->SetRegions(outputImageRegion); outputLowPass->Allocate(); // FIXME Check this line... outputLowPass->FillBuffer(0); } /** Inner product iterators */ typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::NeighborhoodInnerProduct InnerProductType; typedef itk::ImageRegionIterator IteratorType; // Prepare the subsampling image factor, if any. typedef SubsampledImageRegionConstIterator SubsampleIteratorType; typename SubsampleIteratorType::IndexType subsampling; subsampling.Fill(1); subsampling[direction] = GetSubsampleImageFactor(); // Inner products InnerProductType innerProduct; // High pass part calculation HighPassOperatorType highPassOperator; highPassOperator.SetDirection(direction); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); SubsampleIteratorType subItHighPass(input, outputRegionForThread); subItHighPass.SetSubsampleFactor(subsampling); subItHighPass.GoToBegin(); NeighborhoodIteratorType itHighPass(highPassOperator.GetRadius(), input, outputRegionForThread); itk::PeriodicBoundaryCondition boundaryCondition; itHighPass.OverrideBoundaryCondition(&boundaryCondition); IteratorType outHighPass(outputHighPass, subItHighPass.GenerateOutputInformation()); outHighPass.GoToBegin(); while (!subItHighPass.IsAtEnd() && !outHighPass.IsAtEnd()) { itHighPass.SetLocation(subItHighPass.GetIndex()); outHighPass.Set(innerProduct(itHighPass, highPassOperator)); ++subItHighPass; ++outHighPass; reporter.CompletedPixel(); } // Low pass part calculation LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(direction); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); SubsampleIteratorType subItLowPass(input, outputRegionForThread); subItLowPass.SetSubsampleFactor(subsampling); subItLowPass.GoToBegin(); NeighborhoodIteratorType itLowPass(lowPassOperator.GetRadius(), input, outputRegionForThread); itLowPass.OverrideBoundaryCondition(&boundaryCondition); IteratorType outLowPass(outputLowPass, subItLowPass.GenerateOutputInformation()); outLowPass.GoToBegin(); while (!subItLowPass.IsAtEnd() && !outLowPass.IsAtEnd()) { itLowPass.SetLocation(subItLowPass.GetIndex()); outLowPass.Set(innerProduct(itLowPass, lowPassOperator)); ++subItLowPass; ++outLowPass; reporter.CompletedPixel(); } // Swap input and lowPassOutput itk::ImageRegionConstIterator inIt(outputLowPass, outputImageRegion); IteratorType outIt((direction != 0 && m_SubsampleImageFactor > 1) ? static_cast(m_InternalImages[direction - 2][idx / (1 << (direction - 1))]) : this->GetOutput(idx), outputImageRegion); for (inIt.GoToBegin(), outIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt, ++outIt) { outIt.Set(inIt.Get()); } if (direction != 0) { ThreadedGenerateDataAtDimensionN(idx, direction - 1, reporter, outputImageRegion, threadId); ThreadedGenerateDataAtDimensionN(idx + (1 << direction), direction - 1, reporter, outputImageRegion, threadId); } } /** * Template Specialization for the Wavelet::INVERSE case */ template WaveletFilterBank ::WaveletFilterBank () { this->SetNumberOfRequiredInputs(1 << InputImageDimension); m_UpSampleFilterFactor = 0; m_SubsampleImageFactor = 1; // TODO: For now, we force the number threads to 1 because there is a bug with multithreading in INVERSE transform // Resulting in discontinuities in the reconstructed images this->SetNumberOfThreads(1); } template void WaveletFilterBank ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); for (unsigned int i = 1; i < this->GetNumberOfInputs(); ++i) { for (unsigned int dim = 0; dim < InputImageDimension; dim++) { if (this->GetInput(0)->GetLargestPossibleRegion().GetSize()[dim] != this->GetInput(i)->GetLargestPossibleRegion().GetSize()[dim]) { throw itk::ExceptionObject(__FILE__, __LINE__, "Input images are not of the same dimension", ITK_LOCATION); } } } #if __myDebug__ otbGenericMsgDebugMacro(<< " up sampling output regions by a factor of " << GetSubsampleImageFactor()); otbGenericMsgDebugMacro(<< "initial region " << this->GetInput(0)->GetLargestPossibleRegion().GetSize()[0] << "," << this->GetInput(0)->GetLargestPossibleRegion().GetSize()[1]); #endif OutputImageRegionType newRegion; this->CallCopyInputRegionToOutputRegion(newRegion, this->GetInput(0)->GetLargestPossibleRegion()); this->GetOutput()->SetRegions(newRegion); #if __myDebug__ otbGenericMsgDebugMacro(<< "new region output " << newRegion.GetSize()[0] << "," << newRegion.GetSize()[1]); #endif } template void WaveletFilterBank ::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { Superclass::GenerateInputRequestedRegion(); // Filter length calculation LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(0); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); unsigned int radius = lowPassOperator.GetRadius()[0]; HighPassOperatorType highPassOperator; highPassOperator.SetDirection(0); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); if (radius < highPassOperator.GetRadius()[0]) radius = highPassOperator.GetRadius()[0]; // Get the requested regionand pad it for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { InputImagePointerType input = const_cast(this->GetInput(idx)); InputImageRegionType inputRegion = input->GetRequestedRegion(); inputRegion.PadByRadius(radius); if (inputRegion.Crop(input->GetLargestPossibleRegion())) { input->SetRequestedRegion(inputRegion); } else { input->SetRequestedRegion(inputRegion); itk::InvalidRequestedRegionError err(__FILE__, __LINE__); err.SetLocation(ITK_LOCATION); err.SetDescription("Requested region is (at least partially) outside the largest possible region."); err.SetDataObject(input); throw err; } } } template void WaveletFilterBank ::BeforeThreadedGenerateData() { unsigned int one = 1; if (InputImageDimension > 1) { // Internal images will be used only if m_SubsampleImageFactor != 1 m_InternalImages.resize(InputImageDimension - 1); for (unsigned int i = 0; i < m_InternalImages.size(); ++i) { // the size is linked to the SubsampleImageFactor that is assume to be 2!!! m_InternalImages[i].resize( one << (i + 1)); } OutputImageRegionType intermediateRegion; Superclass::CallCopyInputRegionToOutputRegion(intermediateRegion, this->GetInput(0)->GetLargestPossibleRegion()); AllocateInternalData(intermediateRegion); } } template void WaveletFilterBank ::AllocateInternalData (const OutputImageRegionType& outputRegion) { OutputImageRegionType largerRegion; OutputImageRegionType smallerRegion = outputRegion; for (unsigned int direction = 0; direction < InputImageDimension - 1; direction++) { this->CallCopyInputRegionToOutputRegion(direction, largerRegion, smallerRegion); for (unsigned int i = 0; i < m_InternalImages[direction].size(); ++i) { m_InternalImages[direction][i] = OutputImageType::New(); m_InternalImages[direction][i]->SetRegions(largerRegion); m_InternalImages[direction][i]->Allocate(); m_InternalImages[direction][i]->FillBuffer(0); } smallerRegion = largerRegion; } } template void WaveletFilterBank ::AfterThreadedGenerateData() { if (m_SubsampleImageFactor > 1 && InputImageDimension > 1) { m_InternalImages.clear(); } } template void WaveletFilterBank ::CallCopyOutputRegionToInputRegion (InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) { Superclass::CallCopyOutputRegionToInputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { OutputIndexType srcIndex = srcRegion.GetIndex(); OutputSizeType srcSize = srcRegion.GetSize(); InputIndexType destIndex; InputSizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { // TODO: This seems not right in odd index cases destIndex[i] = srcIndex[i] / GetSubsampleImageFactor(); destSize[i] = srcSize[i] / GetSubsampleImageFactor(); } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); #if 1 // Region Padding LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(0); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); typename InputImageRegionType::SizeType radius; radius[0] = lowPassOperator.GetRadius()[0]; HighPassOperatorType highPassOperator; highPassOperator.SetDirection(0); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); if (radius[0] < highPassOperator.GetRadius()[0]) radius[0] = highPassOperator.GetRadius()[0]; for (unsigned int i = 1; i < InputImageDimension; ++i) radius[i] = 0; // for ( unsigned int i = 0; i < InputImageDimension; ++i ) // { // radius[i] = lowPassOperator.GetRadius()[i]; // if ( radius[i] < highPassOperator.GetRadius()[i] ) // radius[i] = highPassOperator.GetRadius()[i]; // } InputImageRegionType paddedRegion = destRegion; paddedRegion.PadByRadius(radius); if (paddedRegion.Crop(this->GetInput(0)->GetLargestPossibleRegion())) { destRegion = paddedRegion; } #endif } } template void WaveletFilterBank ::CallCopyInputRegionToOutputRegion (OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) { Superclass::CallCopyInputRegionToOutputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { OutputIndexType srcIndex = srcRegion.GetIndex(); OutputSizeType srcSize = srcRegion.GetSize(); InputIndexType destIndex; InputSizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { destIndex[i] = srcIndex[i] * GetSubsampleImageFactor(); destSize[i] = srcSize[i] * GetSubsampleImageFactor(); } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void WaveletFilterBank ::CallCopyOutputRegionToInputRegion (unsigned int direction, InputImageRegionType& destRegion, const OutputImageRegionType& srcRegion) { Superclass::CallCopyOutputRegionToInputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { OutputIndexType srcIndex = srcRegion.GetIndex(); OutputSizeType srcSize = srcRegion.GetSize(); InputIndexType destIndex; InputSizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { if (i == direction) { // TODO: This seems not right in odd index cases destIndex[i] = srcIndex[i] / GetSubsampleImageFactor(); destSize[i] = srcSize[i] / GetSubsampleImageFactor(); } else { destIndex[i] = srcIndex[i]; destSize[i] = srcSize[i]; } } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void WaveletFilterBank ::CallCopyInputRegionToOutputRegion (unsigned int direction, OutputImageRegionType& destRegion, const InputImageRegionType& srcRegion) { Superclass::CallCopyInputRegionToOutputRegion(destRegion, srcRegion); if (GetSubsampleImageFactor() > 1) { typename InputImageRegionType::IndexType srcIndex = srcRegion.GetIndex(); typename InputImageRegionType::SizeType srcSize = srcRegion.GetSize(); typename OutputImageRegionType::IndexType destIndex; typename OutputImageRegionType::SizeType destSize; for (unsigned int i = 0; i < InputImageDimension; ++i) { if (i == direction) { destIndex[i] = srcIndex[i] * GetSubsampleImageFactor(); destSize[i] = srcSize[i] * GetSubsampleImageFactor(); } else { destIndex[i] = srcIndex[i]; destSize[i] = srcSize[i]; } } destRegion.SetIndex(destIndex); destRegion.SetSize(destSize); } } template void WaveletFilterBank ::ThreadedGenerateData (const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { itk::ProgressReporter reporter(this, threadId, outputRegionForThread.GetNumberOfPixels() * this->GetNumberOfInputs()); InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); unsigned int dir = 0; // Low pass part calculation LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(dir); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); // High pass part calculation HighPassOperatorType highPassOperator; highPassOperator.SetDirection(dir); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); // typedef for the iterations over the input image typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::NeighborhoodInnerProduct InnerProductType; // Faces iterations typename NeighborhoodIteratorType::RadiusType radiusMax; for (unsigned int idx = 0; idx < OutputImageDimension; ++idx) { radiusMax[idx] = lowPassOperator.GetRadius(idx); if (radiusMax[idx] < highPassOperator.GetRadius(idx)) radiusMax[idx] = highPassOperator.GetRadius(idx); } // The multiresolution case requires a SubsampleImageFilter step if (m_SubsampleImageFactor > 1) { for (unsigned int i = 0; i < this->GetNumberOfInputs(); i += 2) { InputImagePointerType imgLowPass = const_cast(this->GetInput(i)); InputImagePointerType imgHighPass = const_cast(this->GetInput(i + 1)); OutputImagePointerType outputImage = this->GetOutput(); if (dir != InputImageDimension - 1) { outputImage = m_InternalImages[0][i / 2]; } typedef otb::SubsampleImageFilter FilterType; typename FilterType::InputImageIndexType delta; delta.Fill(1); delta[dir] = this->GetSubsampleImageFactor(); InputImagePointerType cropedLowPass = InputImageType::New(); cropedLowPass->SetRegions(inputRegionForThread); cropedLowPass->Allocate(); cropedLowPass->FillBuffer(0.); itk::ImageRegionIterator cropedLowPassIt(cropedLowPass, inputRegionForThread); itk::ImageRegionIterator imgLowPassIt(imgLowPass, inputRegionForThread); for (cropedLowPassIt.GoToBegin(), imgLowPassIt.GoToBegin(); !cropedLowPassIt.IsAtEnd() && !imgLowPassIt.IsAtEnd(); ++cropedLowPassIt, ++imgLowPassIt) { cropedLowPassIt.Set(imgLowPassIt.Get()); } typename FilterType::Pointer overSampledLowPass = FilterType::New(); overSampledLowPass->SetInput(cropedLowPass); overSampledLowPass->SetSubsampleFactor(delta); overSampledLowPass->Update(); InputImagePointerType cropedHighPass = InputImageType::New(); cropedHighPass->SetRegions(inputRegionForThread); cropedHighPass->Allocate(); cropedHighPass->FillBuffer(0.); itk::ImageRegionIterator cropedHighPassIt(cropedHighPass, inputRegionForThread); itk::ImageRegionIterator imgHighPassIt(imgHighPass, inputRegionForThread); for (cropedHighPassIt.GoToBegin(), imgHighPassIt.GoToBegin(); !cropedHighPassIt.IsAtEnd() && !imgHighPassIt.IsAtEnd(); ++cropedHighPassIt, ++imgHighPassIt) { cropedHighPassIt.Set(imgHighPassIt.Get()); } typename FilterType::Pointer overSampledHighPass = FilterType::New(); overSampledHighPass->SetInput(cropedHighPass); overSampledHighPass->SetSubsampleFactor(delta); overSampledHighPass->Update(); InnerProductType innerProduct; itk::ImageRegionIterator out (outputImage, overSampledLowPass->GetOutput()->GetRequestedRegion()); NeighborhoodIteratorType lowIter(lowPassOperator.GetRadius(), overSampledLowPass->GetOutput(), overSampledLowPass->GetOutput()->GetRequestedRegion()); itk::PeriodicBoundaryCondition boundaryCondition; lowIter.OverrideBoundaryCondition(&boundaryCondition); NeighborhoodIteratorType highIter(highPassOperator.GetRadius(), overSampledHighPass->GetOutput(), overSampledHighPass->GetOutput()->GetRequestedRegion()); highIter.OverrideBoundaryCondition(&boundaryCondition); lowIter.GoToBegin(); highIter.GoToBegin(); out.GoToBegin(); while (!out.IsAtEnd()) { out.Set(innerProduct(lowIter, lowPassOperator) + innerProduct(highIter, highPassOperator)); ++lowIter; ++highIter; ++out; reporter.CompletedPixel(); } } // end for each overSampledLowPass/overSampledhighPass pair of entry } else // multiscale case { for (unsigned int i = 0; i < this->GetNumberOfInputs(); i += 2) { InputImagePointerType imgLowPass = const_cast(this->GetInput(i)); InputImagePointerType imgHighPass = const_cast(this->GetInput(i + 1)); OutputImagePointerType outputImage = this->GetOutput(); if (dir != InputImageDimension - 1) { outputImage = m_InternalImages[0][i / 2]; } InnerProductType innerProduct; itk::ImageRegionIterator out(outputImage, imgLowPass->GetRequestedRegion()); NeighborhoodIteratorType lowIter(lowPassOperator.GetRadius(), imgLowPass, imgLowPass->GetRequestedRegion()); itk::PeriodicBoundaryCondition boundaryCondition; lowIter.OverrideBoundaryCondition(&boundaryCondition); NeighborhoodIteratorType highIter(highPassOperator.GetRadius(), imgHighPass, imgLowPass->GetRequestedRegion()); highIter.OverrideBoundaryCondition(&boundaryCondition); lowIter.GoToBegin(); highIter.GoToBegin(); out.GoToBegin(); while (!out.IsAtEnd()) { out.Set((innerProduct(lowIter, lowPassOperator) + innerProduct(highIter, highPassOperator)) / 2.); ++lowIter; ++highIter; ++out; reporter.CompletedPixel(); } } // end for each imgLowPass/imghighPass pair of entry } // end multiscale case if (dir != InputImageDimension - 1) { // Note that outputImageRegion correspond to the actual region of (local) input ! OutputImageRegionType outputImageRegion; this->CallCopyInputRegionToOutputRegion(dir, outputImageRegion, inputRegionForThread); ThreadedGenerateDataAtDimensionN(dir + 1, reporter, outputImageRegion, threadId); } } template void WaveletFilterBank ::ThreadedGenerateDataAtDimensionN (unsigned int direction, itk::ProgressReporter& reporter, const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { OutputImageRegionType outputImageRegion; this->CallCopyInputRegionToOutputRegion(direction, outputImageRegion, outputRegionForThread); // Low pass part calculation LowPassOperatorType lowPassOperator; lowPassOperator.SetDirection(direction); lowPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); lowPassOperator.CreateDirectional(); // High pass part calculation HighPassOperatorType highPassOperator; highPassOperator.SetDirection(direction); highPassOperator.SetUpSampleFactor(this->GetUpSampleFilterFactor()); highPassOperator.CreateDirectional(); // typedef for the iterations over the input image typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef itk::NeighborhoodInnerProduct InnerProductType; // Faces iterations typename NeighborhoodIteratorType::RadiusType radiusMax; for (unsigned int i = 0; i < InputImageDimension; ++i) { radiusMax[i] = lowPassOperator.GetRadius(i); if (radiusMax[i] < highPassOperator.GetRadius(i)) radiusMax[i] = highPassOperator.GetRadius(i); } // The multiresolution case requires a SubsampleImageFilter step if (m_SubsampleImageFactor > 1) { for (unsigned int i = 0; i < m_InternalImages[direction - 1].size(); i += 2) { InputImagePointerType imgLowPass = m_InternalImages[direction - 1][i]; InputImagePointerType imgHighPass = m_InternalImages[direction - 1][i + 1]; OutputImagePointerType outputImage = this->GetOutput(); if (direction < InputImageDimension - 1) { outputImage = m_InternalImages[direction][i / 2]; } typedef otb::SubsampleImageFilter FilterType; typename FilterType::InputImageIndexType delta; delta.Fill(1); delta[direction] = this->GetSubsampleImageFactor(); InputImagePointerType cropedLowPass = InputImageType::New(); cropedLowPass->SetRegions(outputRegionForThread); cropedLowPass->Allocate(); cropedLowPass->FillBuffer(0.); itk::ImageRegionIterator cropedLowPassIt(cropedLowPass, outputRegionForThread); itk::ImageRegionIterator imgLowPassIt(imgLowPass, outputRegionForThread); for (cropedLowPassIt.GoToBegin(), imgLowPassIt.GoToBegin(); !cropedLowPassIt.IsAtEnd() && !imgLowPassIt.IsAtEnd(); ++cropedLowPassIt, ++imgLowPassIt) { cropedLowPassIt.Set(imgLowPassIt.Get()); } typename FilterType::Pointer overSampledLowPass = FilterType::New(); overSampledLowPass->SetInput(cropedLowPass); overSampledLowPass->SetSubsampleFactor(delta); overSampledLowPass->Update(); InputImagePointerType cropedHighPass = InputImageType::New(); cropedHighPass->SetRegions(outputRegionForThread); cropedHighPass->Allocate(); cropedHighPass->FillBuffer(0.); itk::ImageRegionIterator cropedHighPassIt(cropedHighPass, outputRegionForThread); itk::ImageRegionIterator imgHighPassIt(imgHighPass, outputRegionForThread); for (cropedHighPassIt.GoToBegin(), imgHighPassIt.GoToBegin(); !cropedHighPassIt.IsAtEnd() && !imgHighPassIt.IsAtEnd(); ++cropedHighPassIt, ++imgHighPassIt) { cropedHighPassIt.Set(imgHighPassIt.Get()); } typename FilterType::Pointer overSampledHighPass = FilterType::New(); overSampledHighPass->SetInput(cropedHighPass); overSampledHighPass->SetSubsampleFactor(delta); overSampledHighPass->Update(); InnerProductType innerProduct; itk::ImageRegionIterator out(outputImage, overSampledLowPass->GetOutput()->GetRequestedRegion()); // TODO: This might be the cause of the multithreading bug : we use a neighborhood iterator on cropped data // Are we sure that we have cropped enough data to access the neighborhood ? NeighborhoodIteratorType lowIter(lowPassOperator.GetRadius(), overSampledLowPass->GetOutput(), overSampledLowPass->GetOutput()->GetRequestedRegion()); itk::PeriodicBoundaryCondition boundaryCondition; lowIter.OverrideBoundaryCondition(&boundaryCondition); NeighborhoodIteratorType highIter(highPassOperator.GetRadius(), overSampledHighPass->GetOutput(), overSampledHighPass->GetOutput()->GetRequestedRegion()); highIter.OverrideBoundaryCondition(&boundaryCondition); lowIter.GoToBegin(); highIter.GoToBegin(); out.GoToBegin(); while (!out.IsAtEnd()) { out.Set(innerProduct(lowIter, lowPassOperator) + innerProduct(highIter, highPassOperator)); ++lowIter; ++highIter; ++out; reporter.CompletedPixel(); } } // end for each overSampledLowPass/overSampledhighPass pair of entry } else // multiscale case { for (unsigned int i = 0; i < m_InternalImages[direction - 1].size(); i += 2) { InputImagePointerType imgLowPass = m_InternalImages[direction - 1][i]; InputImagePointerType imgHighPass = m_InternalImages[direction - 1][i + 1]; OutputImagePointerType outputImage = this->GetOutput(); if (direction < InputImageDimension - 1) { outputImage = m_InternalImages[direction][i / 2]; } InnerProductType innerProduct; itk::ImageRegionIterator out(outputImage, imgLowPass->GetRequestedRegion()); NeighborhoodIteratorType lowIter(lowPassOperator.GetRadius(), imgLowPass, imgLowPass->GetRequestedRegion()); itk::PeriodicBoundaryCondition boundaryCondition; lowIter.OverrideBoundaryCondition(&boundaryCondition); NeighborhoodIteratorType highIter(highPassOperator.GetRadius(), imgHighPass, imgLowPass->GetRequestedRegion()); highIter.OverrideBoundaryCondition(&boundaryCondition); lowIter.GoToBegin(); highIter.GoToBegin(); out.GoToBegin(); while (!out.IsAtEnd()) { out.Set((innerProduct(lowIter, lowPassOperator) + innerProduct(highIter, highPassOperator)) / 2.); ++lowIter; ++highIter; ++out; reporter.CompletedPixel(); } } // end for each imgLowPass/imghighPass pair of entry } if (direction < InputImageDimension - 1) { ThreadedGenerateDataAtDimensionN(direction + 1, reporter, outputImageRegion, threadId); } } } // end of namespace #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletGenerator.h000066400000000000000000000056071301006202600261470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletGenerator_h #define otbWaveletGenerator_h #include #include "itkLightObject.h" #include "itkObjectFactory.h" namespace otb { namespace Wavelet { enum Wavelet { HAAR = 0, DAUBECHIES4 = 1, DB4 = 1, DAUBECHIES6 = 2, DB6 = 2, DAUBECHIES8 = 3, DB8 = 3, DAUBECHIES12 = 4, DB12 = 4, DAUBECHIES20 = 5, DB20 = 5, SPLINE_BIORTHOGONAL_2_4, // 6 SPLINE_BIORTHOGONAL_4_4, // 7 SYMLET8, // 8 TotalNumberOfDefinedMotherWavelets }; } /** \class WaveletGenerator * \brief Wavelet coefficient definition * * The wavelet coefficient definitions mainly come from * "Ten Lecture on Wavelets", of Ingrid Daubechies, * Society for Industrial and Applied Mathematics, 1992. * * The class is templated with the wavelet ID from the * Wavelet::Wavelet type. The members throw an * exception if the template specialization is not defined * according to the wavelet ID. * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletGenerator : public itk::LightObject { public: /** Standard typedefs */ typedef WaveletGenerator Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletGenerator, LightObject); /** Typedef similar to itk::NeighborhoodOperator */ typedef std::vector CoefficientVector; /** * GetWaveletName * By default (without template specification) it does nothing usable */ const char * GetWaveletName() const; /** * GetLowPassCoefficientVector * By default (without template specification) it does nothing usable */ void GetLowPassCoefficientVector(CoefficientVector& coeff) const; /** * GetHighPassCoefficientVector * By default (without template specification) it does nothing usable */ void GetHighPassCoefficientVector(CoefficientVector& coeff) const; protected: WaveletGenerator() {} ~WaveletGenerator() ITK_OVERRIDE {} private: WaveletGenerator(const Self &); // not implemented void operator =(const Self&); // not implemented }; // end of class } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletHighPassOperator.h000066400000000000000000000055461301006202600274450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletHighPassOperator_h #define otbWaveletHighPassOperator_h #include "otbWaveletOperatorBase.h" namespace otb { /** * \class WaveletHighPassOperator * \brief Specific implementation of the mother wavelet part of * wavelet transformator * * This class implements the generic construction of the high pass filter * in a wavelet transformation. * * \sa WaveletOperator * \sa WaveletGenerator * * \ingroup OTBWavelet */ template > class ITK_EXPORT WaveletHighPassOperator : public WaveletOperatorBase { public: /** Standard typedefs */ typedef WaveletHighPassOperator Self; typedef WaveletOperatorBase Superclass; itkTypeMacro(WaveletHighPassOperator, WaveletOperatorBase); typedef typename Superclass::SizeType SizeType; static const Wavelet::WaveletDirection DirectionOfTransformation = TDirectionOfTransformation; protected: void PrintSelf(std::ostream& os, itk::Indent i) const ITK_OVERRIDE { os << i << "WaveletHighPassOperator {this=" << this << "}" << std::endl; Superclass::PrintSelf(os, i.GetNextIndent()); } /** * Typedef support for coefficient vector type. Necessary to * work around compiler bug on VC++. */ typedef typename Superclass::CoefficientVector CoefficientVector; typedef typename Superclass::PixelType PixelType; /** * Set operator coefficients. */ CoefficientVector GenerateCoefficients() ITK_OVERRIDE { CoefficientVector coeff; if (DirectionOfTransformation == Wavelet::FORWARD) { this->m_WaveletGenerator->GetHighPassCoefficientVector(coeff); } if (DirectionOfTransformation == Wavelet::INVERSE) { this->m_WaveletGenerator->GetLowPassCoefficientVector(coeff); Superclass::GenerateInverseHighPassFilterFromLowPassFilter(coeff); } Superclass::UpSamplingCoefficients(coeff); return coeff; } }; // end of class } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletLowPassOperator.h000066400000000000000000000055301301006202600273200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletLowPassOperator_h #define otbWaveletLowPassOperator_h #include "otbWaveletOperatorBase.h" namespace otb { /** * \class WaveletLowPassOperator * \brief Specific implementation of scale part of wavelet transformator * * This class implements the generic construction of the low pass filter * in a wavelet transformation. * * \sa WaveletOperatorBase * \sa WaveletGenerator * * \ingroup OTBWavelet */ template > class ITK_EXPORT WaveletLowPassOperator : public WaveletOperatorBase { public: /** Standard typedefs */ typedef WaveletLowPassOperator Self; typedef WaveletOperatorBase Superclass; itkTypeMacro(WaveletLowPassOperator, WaveletOperatorBase); typedef typename Superclass::SizeType SizeType; static const Wavelet::WaveletDirection DirectionOfTransformation = TDirectionOfTransformation; protected: void PrintSelf(std::ostream& os, itk::Indent i) const ITK_OVERRIDE { os << i << "WaveletLowPassOperator {this=" << this << "}" << std::endl; Superclass::PrintSelf(os, i.GetNextIndent()); } /** * Typedef support for coefficient vector type. Necessary to * work around compiler bug on VC++. */ typedef typename Superclass::CoefficientVector CoefficientVector; typedef typename Superclass::PixelType PixelType; /** * Set operator coefficients. */ CoefficientVector GenerateCoefficients() ITK_OVERRIDE { CoefficientVector coeff; if (DirectionOfTransformation == Wavelet::FORWARD) { this->m_WaveletGenerator->GetLowPassCoefficientVector(coeff); } if (DirectionOfTransformation == Wavelet::INVERSE) { this->m_WaveletGenerator->GetHighPassCoefficientVector(coeff); Superclass::GenerateInverseLowPassFilterFromHighPassFilter(coeff); } Superclass::UpSamplingCoefficients(coeff); return coeff; } }; // end of class } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletOperator.h000066400000000000000000000044471301006202600260150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletOperator_h #define otbWaveletOperator_h #include "itkMacro.h" #include "itkNeighborhoodOperator.h" // This include is needed here to define Wavelet::Wavelet... #include "otbWaveletGenerator.h" #include "otbWaveletLowPassOperator.h" #include "otbWaveletHighPassOperator.h" namespace otb { /** * \class WaveletOperator * * \brief A Generic NeighborhoodOperator wavelets filter set defined for templation * * This class is the general class to be used for template definition of any * Wavelet decomposition. It contains only typedef that give access to specific * LowPass and HighPass filters in a dyadic decomposition frame. * * Note: It is not an operator as it stands * * \sa WaveletOperatorBase * \sa WaveletLowPassOperator * \sa WaveletHighPassOperator * * \ingroup OTBWavelet */ template > class ITK_EXPORT WaveletOperator { public: /** Standard typedefs */ typedef WaveletOperator Self; /** Typedefs redirections */ typedef WaveletLowPassOperator< TMotherWaveletOperator, TDirectionOfTransformation, TPixel, VDimension, TAllocator> LowPassOperator; typedef WaveletHighPassOperator< TMotherWaveletOperator, TDirectionOfTransformation, TPixel, VDimension, TAllocator> HighPassOperator; private: /** * This class may not be instantiated * Intentionally not implemented */ WaveletOperator (); WaveletOperator (const Self &); ~WaveletOperator(); }; } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletOperatorBase.h000066400000000000000000000211011301006202600265720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletOperatorBase_h #define otbWaveletOperatorBase_h #include "itkMacro.h" #include "itkNeighborhoodOperator.h" // This include is needed here to define MotherWaveletOperatorEnum... #include "otbWaveletGenerator.h" namespace otb { namespace Wavelet { enum WaveletDirection {FORWARD = 0, INVERSE = 1}; } /** * \class WaveletOperatorBase * * \brief A NeighborhoodOperator wavelet base class * * This class is the mother class for any wavelet operator that requires * "a-trou" approach for shift-invariant wavelet transform. This class has * to be derived, it cannot be used directly since GenerateCoefficients() method * is still pure virtual. * * Any wavelet operator that inherits from this WaveletOperatorBase is to be used * as a NeighborhoodOperator that should be applied to a * NeighborhoodIterator using the NeighborhoodInnerProduct method. * * It is assumed that any wavelet definition is directional. * * Set the level of up-sampling though SetUpSampleFactor() before calling * CreateDirectional(). Each class that inherits from WaveletOperatorBase has * to re-implement GenerateCoefficients(). * * The name of the wavelet is defined here but left pure virtual. It is defined * with the LowPass and HighPass inheritance. * * \sa WaveletLowPassOperator * \sa WaveletHighPassOperator * \sa NeighborhoodOperator * \sa Neighborhood * * \ingroup Operators * * \ingroup OTBWavelet */ template > class ITK_EXPORT WaveletOperatorBase : public itk::NeighborhoodOperator { public: /** Standard typedefs */ typedef WaveletOperatorBase Self; typedef itk::NeighborhoodOperator Superclass; itkTypeMacro(WaveletOperatorBase, NeighborhoodOperator); typedef typename Superclass::SizeType SizeType; typedef Wavelet::Wavelet MotherWaveletOperatorEnumType; itkStaticConstMacro(MotherWaveletOperator, MotherWaveletOperatorEnumType, TMotherWaveletOperator); /** Construction */ WaveletOperatorBase() : m_UpSampleFactor(0) { m_WaveletGenerator = WaveletGeneratorType::New(); } /** Construction by copy */ WaveletOperatorBase(const Self &other) : itk::NeighborhoodOperator (other), m_UpSampleFactor(other.GetUpSampleFactor()) { m_WaveletGenerator = WaveletGeneratorType::New(); } ~WaveletOperatorBase() ITK_OVERRIDE {} /** Assignment operator */ Self & operator =(const Self& other) { Superclass::operator =(other); m_UpSampleFactor = other.GetUpSampleFactor(); return *this; } /** * Get the level of up sampling of the filter */ unsigned int GetUpSampleFactor() const { return this->m_UpSampleFactor; } /** * Set the level of up sampling of the filter */ void SetUpSampleFactor(unsigned int upSampleFactor) { this->m_UpSampleFactor = upSampleFactor; } /** * Get the name of the wavelet when necessary */ virtual const char * GetWaveletName() const { return this->m_WaveletGenerator->GetWaveletName(); } protected: /** * Prints some debugging information */ void PrintSelf(std::ostream& os, itk::Indent i) const ITK_OVERRIDE; typedef WaveletGenerator WaveletGeneratorType; typedef typename WaveletGeneratorType::Pointer WaveletGeneratorPointerType; /** * Typedef support for coefficient vector type. Necessary to * work around compiler bug on VC++. */ typedef typename Superclass::CoefficientVector CoefficientVector; typedef typename Superclass::PixelType PixelType; /** * Perform the "a-trou" algorithm for shift-invariant transformation. * It transforms the filter \f$ H(z) \f$ into \f$ H(z^2) \f$. */ void UpSamplingCoefficients(CoefficientVector& coeff); /** * Performs filter reversion, ie. \f$ H(z^{-1}) \f$. */ void RevertFilter(CoefficientVector& coeff); /** * Performs the definition of high pass filter in an orthogonal framework * It follows conjugate quadrature filter (CQF) of the chapter 5 of * "Ten Lecture on Wavelets", of Ingrid Daubechies, * Society for Industrial and Applied Mathematics, 1992. * * It defines filter coefficients as \f$ G(z) = z H(-z^{-1}) \f$. * According to Daubechies'notation, it concerns the synthesis (Inverse) * part of the filter banc. */ void GenerateInverseHighPassFilterFromLowPassFilter(CoefficientVector& coeff); /** * Performs the definition of low pass filter in the reconstruction * step of the conjugate quadrature filter (CQF) framework. * * It defines filter coefficients as \f$ {\tilde H}(z) = G(-z) \f$. */ void GenerateInverseLowPassFilterFromHighPassFilter(CoefficientVector& coeff); /** * Reduce extra zeros on filters */ void ReduceFilterLength(CoefficientVector& coeff); /** Arranges coefficients spatially in the memory buffer. */ void Fill(const CoefficientVector& coeff) ITK_OVERRIDE { this->FillCenteredDirectional(coeff); } #if 0 /** * Performs the definition of high pass filter from low pass in a * bi-orthogonal framework (ie. Quadrature mirror filter). * It defines filter coefficients as \f$ g_n = (-1)^{n+1} h_{-n} \f$ */ void GetHighPassFilterFromQuadratureLowPassFilter(CoefficientVector& coeff) { unsigned int length = coeff.size(); CoefficientVector highPassCoeff (length); int medianPosition = static_cast(length) / 2; highPassCoeff[medianPosition] = -coeff[medianPosition]; double sign = 1.; for (int i = 1; i <= medianPosition; ++i) { highPassCoeff[medianPosition + i] = sign * coeff[medianPosition - i]; highPassCoeff[medianPosition - i] = sign * coeff[medianPosition + i]; sign *= -1.; } coeff = highPassCoeff; } /** * Performs the definition of synthesis filter from analysis one. * Input is the forward low pass filter coefficients. * It performs \f$ {\tilde G}(z) = -H(-z) \f$. */ void GetInverseHighPassFilterFromForwardLowPassFilter(CoefficientVector& coeff) { unsigned long length = static_cast(coeff.size()); unsigned long medianPosition = length / 2; // Wavelet coefficients are always of add size, so that 2*medianPosition < length coeff[medianPosition] *= -1.; for (unsigned int i = 2; i <= medianPosition; i += 2) { coeff[medianPosition + i] *= -1.; coeff[medianPosition - i] *= -1.; } } /** * Performs the definition of synthesis filter from analysis one. * Input is the forward high pass filter coefficients. It is valid * for orthogonal and biorthogonal cases. * It performs \f$ {\tilde H}(z) = G(-z) \f$. */ void GetInverseLowPassFilterFromForwardHighPassFilter(CoefficientVector& coeff) { unsigned long length = static_cast(coeff.size()); unsigned long medianPosition = length / 2; // Wavelet coefficients are always of add size, so that 2*medianPosition < length for (unsigned int i = 1; i <= medianPosition; i += 2) { coeff[medianPosition + i] *= -1.; coeff[medianPosition - i] *= -1.; } } /** * Performs the definition of high pass filter from the inverse low pass one * in a Quadrature Mirror Filter bank framework. It is then valid to * define high pass filters from orthogonal and biorthogonal wavelets... * Input are the inverse low pass filter coefficients. * It performs \f$ G(z) = {\tilde H}(-z)\f$. */ void GetForwardHighPassFilterFromInverseLowPassFilter(CoefficientVector& coeff) { GetInverseLowPassFilterFromForwardHighPassFilter(coeff); } #endif unsigned int m_UpSampleFactor; WaveletGeneratorPointerType m_WaveletGenerator; }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbWaveletOperatorBase.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletOperatorBase.txx000066400000000000000000000117271301006202600272030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletOperatorBase_txx #define otbWaveletOperatorBase_txx #include "otbWaveletOperatorBase.h" #include namespace otb { template void WaveletOperatorBase ::PrintSelf(std::ostream& os, itk::Indent i) const { os << i << "Wavelet kind : " << GetWaveletName() << "\n"; os << i << "Up-Sampling factor " << GetUpSampleFactor() << "\n"; Superclass::PrintSelf(os, i.GetNextIndent()); os << i << "Wavelet coeff: [ "; for (typename Superclass::ConstIterator iter = Superclass::Begin(); iter != Superclass::End(); ++iter) { os << *iter << ' '; } os << "]\n"; } template void WaveletOperatorBase ::UpSamplingCoefficients(CoefficientVector& coeff) { if (m_UpSampleFactor <= 1) return; unsigned long radius = static_cast(coeff.size()) >> 1; unsigned long upSampleRadius = radius * m_UpSampleFactor; CoefficientVector upSampledCoeff ( 2 * upSampleRadius + 1 ); upSampledCoeff.assign(2 * upSampleRadius + 1, 0.); upSampledCoeff[upSampleRadius] = coeff[radius]; for (unsigned int i = 1; i <= radius; ++i) { upSampledCoeff[upSampleRadius + m_UpSampleFactor * i] = coeff[radius + i]; upSampledCoeff[upSampleRadius - m_UpSampleFactor * i] = coeff[radius - i]; } coeff = upSampledCoeff; } template void WaveletOperatorBase ::RevertFilter(CoefficientVector& coeff) { const unsigned int length = coeff.size(); const unsigned int medianPosition = length / 2; CoefficientVector newCoeff(length); newCoeff[medianPosition] = coeff[medianPosition]; for (unsigned int i = 1; i <= medianPosition; ++i) { newCoeff[medianPosition + i] = coeff[medianPosition - i]; newCoeff[medianPosition - i] = coeff[medianPosition + i]; } coeff = newCoeff; } template void WaveletOperatorBase ::GenerateInverseHighPassFilterFromLowPassFilter(CoefficientVector& coeff) { const unsigned int length = coeff.size(); CoefficientVector highPassCoeff(length + 2); double sign = -1; for (unsigned int i = 0; i < length; ++i) { highPassCoeff[i] = sign * coeff[i]; sign *= -1.; } highPassCoeff[length] = 0.; highPassCoeff[length + 1] = 0.; coeff = highPassCoeff; // Note that the 0.0 value is obtained by affectation and not by // computation. It is fine to do an == comparison while ((coeff[0] == coeff[coeff.size() - 1]) && (coeff[0] == 0.0)) { ReduceFilterLength(coeff); } } template void WaveletOperatorBase ::GenerateInverseLowPassFilterFromHighPassFilter(CoefficientVector& coeff) { const unsigned int length = coeff.size(); CoefficientVector highPassCoeff(length + 2); double sign = 1; for (unsigned int i = 0; i < length; ++i) { highPassCoeff[i] = sign * coeff[i]; sign *= -1.; } highPassCoeff[length] = 0.; highPassCoeff[length + 1] = 0.; coeff = highPassCoeff; // Note that the 0.0 value is obtained by affectation and not by // computation. It is fine to do an == comparison while ((coeff[0] == coeff[coeff.size() - 1]) && (coeff[0] == 0.0)) { assert(coeff.size() > 1); ReduceFilterLength(coeff); } } template void WaveletOperatorBase ::ReduceFilterLength(CoefficientVector& coeff) { const unsigned int length = coeff.size(); assert(length >= 2); CoefficientVector newFilter(length - 2); for (unsigned int i = 0; i < newFilter.size(); ++i) { newFilter[i] = coeff[i + 1]; } coeff = newFilter; } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletPacketDecompositionCosts.h000066400000000000000000000044701301006202600311760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletPacketDecompositionCosts_h #define otbWaveletPacketDecompositionCosts_h #include "itkObject.h" #include "itkMacro.h" #include "itkObjectFactory.h" namespace otb { /** \class FullyDecomposedWaveletPacketCost * \brief Cost evaluation to be used into the Wavelet Packet decomposition class. * * This class implements the criteria to perform fully decomposed wavelet packet. * It is based on the depth of the decomposition only... * * \sa WaveletPacketForwardTransform * * \ingroup OTBWavelet */ template class ITK_EXPORT FullyDecomposedWaveletPacketCost : public itk::Object { public: /** Standard typedefs */ typedef FullyDecomposedWaveletPacketCost Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(FullyDecomposedWaveletPacketCost, Object); typedef TImage ImageType; /** Access to the data */ static unsigned int NumberOfAllowedDecompositions; /** Evaluate the cost */ bool Evaluate(unsigned int decomposition, const ImageType * itkNotUsed(image)) { return (decomposition < NumberOfAllowedDecompositions); } protected: FullyDecomposedWaveletPacketCost () {} ~FullyDecomposedWaveletPacketCost() ITK_OVERRIDE {} private: FullyDecomposedWaveletPacketCost (const Self &); // not implemented void operator =(const Self&); }; // end of class template unsigned int FullyDecomposedWaveletPacketCost::NumberOfAllowedDecompositions = 1; } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletPacketTransform.h000066400000000000000000000343461301006202600273260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletPacketTransform_h #define otbWaveletPacketTransform_h #include "itkProgressAccumulator.h" #include "otbImageToImageListFilter.h" #include "otbImageListToImageFilter.h" #include "otbWaveletGenerator.h" #include "otbWaveletOperatorBase.h" #include "otbWaveletPacketDecompositionCosts.h" namespace otb { /** \class WaveletPacketTransform * \brief Wavelet packet transformation framework * * This class defines the Wavelet Packet transformation of an image * by using a (templated) elementary wavelet transform and (templated) * cost criteria to stop the decomposition. * * It yields a list of images on the Wavelet::FORWARD decomposition. Conversely, * it takes an image list but yield a single list on the Wavelet::INVERSE transformation. * Hence, the Forward vs Inverse transformation has been split into two classes * (templated with otb::Wavelet::FORWARD and otb::Wavelet::INVERSE). The Forward class comes from * ImageToImageListFilter while the latter comes from a * ImageListToImageFilter. Thse two classes have specific declaration * and implementation. * * The user is supposed to initialize Cost properly (through GetCost() macro) * depending on its type before calling an Update(). The Cost class has to contain * a New() and Evaluate() function. * * \sa FullyDecomposedWaveletPacketCost * \sa WaveletFilterBank * \sa WaveletTransform * * \ingroup OTBWavelet */ template > class ITK_EXPORT WaveletPacketTransform : public itk::ImageSource { public: /** Standard typedefs */ typedef WaveletPacketTransform Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletPacketTransform, ImageSource); protected: /** But this class cannot do any thing! No constructor is implemented */ WaveletPacketTransform(); virtual ~WaveletPacketTransform(); private: WaveletPacketTransform (const Self &); void operator =(const Self&); }; /** \class WaveletPacketTransform * \brief Wavelet packet forward transformation framework * * This class defines the Wavelet Packet transformation of an image * by using a (templated) elementary wavelet transform and (templated) * cost criteria to stop the decomposition. * * It yields a list of images on the Wavelet::FORWARD decomposition. Conversely, * it takes an image list but yield a single list on the Wavelet::INVERSE transformation. * Hence, the Forward vs Inverse transformation has been split into two classes * (templated with otb::Wavelet::FORWARD and otb::Wavelet::INVERSE). The Forward class comes from * ImageToImageListFilter while the latter comes from a * ImageListToImageFilter. Thse two classes have specific declaration * and implementation. * * The user is supposed to initialize Cost properly (through GetCost() macro) * depending on its type before calling an Update(). The Cost class has to contain * a New() and Evaluate() function. * * This is the specific declaration of the Forward transformation. * * \sa FullyDecomposedWaveletPacketCost * \sa WaveletFilterBank * \sa WaveletTransform * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletPacketTransform : public ImageToImageListFilter { public: /** Standard typedefs */ typedef WaveletPacketTransform Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletPacketTransform, ImageToImageListFilter); typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::Iterator OutputImageIterator; typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; typedef ObjectList FilterListType; typedef typename FilterListType::Pointer FilterListPointerType; typedef typename FilterListType::Iterator FilterListIterator; itkGetObjectMacro(FilterList, FilterListType); typedef TCost CostType; typedef typename CostType::Pointer CostPointerType; itkGetObjectMacro(Cost, CostType); typedef Wavelet::WaveletDirection DirectionOfTransformationEnumType; itkStaticConstMacro(DirectionOfTransformation, DirectionOfTransformationEnumType, Wavelet::FORWARD); /** Get the recursive description of the packet decomposition */ const std::vector& GetWaveletPacketRule() const { return this->m_WaveletPacketRule; } /** Get information on the decomposition */ itkGetMacro(NumberOfFilters, unsigned int); itkGetMacro(DepthOfDecomposition, unsigned int); itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** * Set/Get the level of down sampling of the image used in forward algorithm. * (or upsampling in the inverse case) * * In this implementation, we are not (yet?) dealing with M-band decomposition * then m_SubsampleImageFactor is most likely to be 1 or 2... but in any case integer * and not real... */ itkGetMacro(SubsampleImageFactor, unsigned int); itkSetMacro(SubsampleImageFactor, unsigned int); protected: WaveletPacketTransform(); ~WaveletPacketTransform() ITK_OVERRIDE {} /** Generate data redefinition. * This class does not performs multi-threading directly. But it uses step by step the * GenerateData() of TFilter. If This one can thread, the transformation is threaded * (e.g. WaveletFilterBank) */ void GenerateData() ITK_OVERRIDE; /** Performs (if any) the local decomposition (called recursively) */ virtual void GenerateData(unsigned int depth, OutputImageType * outputPtr, itk::ProgressAccumulator * accumulator); private: WaveletPacketTransform (const Self &); void operator =(const Self&); /** * For multiscale decomposition, m_SubsampleImageFactor is set to 1. * It yields also a stationnary decomposition. * For multiresolution decomposition, most of the time, m_SubsampleImageFactor is * to be set to 2. This is its default value. */ unsigned int m_SubsampleImageFactor; // Internal informative data unsigned int m_NumberOfFilters; unsigned int m_DepthOfDecomposition; FilterListPointerType m_FilterList; CostPointerType m_Cost; std::vector m_WaveletPacketRule; }; // end of class /** \class WaveletPacketTransform * \brief Wavelet packet inverse transformation framework * * This class defines the Wavelet Packet transformation of an image * by using a (templated) elementary wavelet transform and (templated) * cost criteria to stop the decomposition. * * It yields a list of images on the Wavelet::FORWARD decomposition. Conversely, * it takes an image list but yield a single list on the Wavelet::INVERSE transformation. * Hence, the Forward vs Inverse transformation has been split into two classes * (templated with otb::Wavelet::FORWARD and otb::Wavelet::INVERSE). The Forward class comes from * ImageToImageListFilter while the latter comes from a * ImageListToImageFilter. Thse two classes have specific declaration * and implementation. * * This is the specific declaration of the Inverse transformation. * * In this specialization, the Cost template class is not useful and then * declared to as FullyDecomposedWaveletPacketCost. * * \sa FullyDecomposedWaveletPacketCost * \sa WaveletFilterBank * \sa WaveletTransform * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletPacketTransform > : public ImageListToImageFilter { public: /** Standard typedefs */ typedef WaveletPacketTransform Self; typedef ImageListToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletPacketTransform, ImageListToImageFilter); typedef typename Superclass::InputImageType InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::ValueType ValueType; typedef typename Superclass::InputImageListType InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::Iterator InputImageIterator; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename OutputImageType::IndexType OutputImageIndexType; typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; typedef ObjectList FilterListType; typedef typename FilterListType::Pointer FilterListPointerType; typedef typename FilterListType::Iterator FilterListIterator; itkGetObjectMacro(FilterList, FilterListType); typedef Wavelet::WaveletDirection DirectionOfTransformationEnumType; itkStaticConstMacro(DirectionOfTransformation, DirectionOfTransformationEnumType, Wavelet::INVERSE); /** Get/Set the decomposition rule */ const std::vector& GetWaveletPacketRule() const { return this->m_WaveletPacketRule; } void SetWaveletPacketRule(const std::vector& rule) { this->m_WaveletPacketRule = rule; this->Modified(); } /** * Set/Get the level of down sampling of the image used in forward algorithm. * (or upsampling in the inverse case) * * In this implementation, we are not (yet?) dealing with M-band decomposition * then m_SubsampleImageFactor is most likely to be 1 or 2... but in any case integer * and not real... */ itkGetMacro(SubsampleImageFactor, unsigned int); itkSetMacro(SubsampleImageFactor, unsigned int); /** Get information on the decomposition */ itkGetMacro(NumberOfFilters, unsigned int); itkGetMacro(DepthOfDecomposition, unsigned int); itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); protected: WaveletPacketTransform(); ~WaveletPacketTransform() ITK_OVERRIDE {} /** GenerateOutputInformation * Set the size of the output image depending on the decimation factor * Copy information from the input image if existing. **/ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate data redefinition. * This class does not performs multi-threading directly. But it uses step by step the * GenerateData() of TFilter. If This one can thread, the transformation is threaded * (e.g. WaveletFilterBank) */ void GenerateData() ITK_OVERRIDE; /** Performs (if any) the local decomposition (called recursively) */ virtual unsigned int SetInputFilters(unsigned int& ruleID, InputImageIterator& inputIter, unsigned int filterID); /** Get the depth of decomposition and the number of filters from m_WaveletPacketRule */ void InterpretRule(); void InterpretRule(unsigned int& ruleID, unsigned int curDepth); private: WaveletPacketTransform (const Self &); void operator =(const Self&); /** * For multiscale decomposition, m_SubsampleImageFactor is set to 1. * It yields also a stationnary decomposition. * For multiresolution decomposition, most of the time, m_SubsampleImageFactor is * to be set to 2. This is its default value. */ unsigned int m_SubsampleImageFactor; // Internal informative data unsigned int m_NumberOfFilters; unsigned int m_DepthOfDecomposition; FilterListPointerType m_FilterList; std::vector m_WaveletPacketRule; }; // end of class } // end of namespace #ifndef OTB_MANUAL_INSTANTIATION #include "otbWaveletPacketTransform.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletPacketTransform.txx000066400000000000000000000220631301006202600277130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletPacketTransform_txx #define otbWaveletPacketTransform_txx #include "otbWaveletPacketTransform.h" #include "otbMacro.h" namespace otb { /** * Template specialization for the Wavelet::FORWARD transformation */ template WaveletPacketTransform ::WaveletPacketTransform () : m_SubsampleImageFactor(2), m_NumberOfFilters(0), m_DepthOfDecomposition(0) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageListType::New()); m_FilterList = FilterListType::New(); m_Cost = CostType::New(); } template void WaveletPacketTransform ::GenerateData() { /* * Start with a decomposition */ m_WaveletPacketRule.clear(); m_NumberOfFilters = 0; m_DepthOfDecomposition = 0; itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); GenerateData(0, this->GetInput(), progress); } template void WaveletPacketTransform ::GenerateData (unsigned int depth, OutputImageType * outputPtr, itk::ProgressAccumulator * progress) { // We cannot know in advance the nomber of filters in this mini-pipeline // So we decrease the weight of each filter in order to tend to 1... slowly... static float accumulatorWeight = 1.; if (this->GetCost()->Evaluate(depth, outputPtr)) { if (m_DepthOfDecomposition < depth) m_DepthOfDecomposition = depth; m_WaveletPacketRule.push_back(true); this->GetFilterList()->PushBack(FilterType::New()); FilterPointerType filter = this->GetFilterList()->GetNthElement(m_NumberOfFilters); m_NumberOfFilters++; filter->SetSubsampleImageFactor(GetSubsampleImageFactor()); if (GetSubsampleImageFactor() == 1) filter->SetUpSampleFilterFactor(depth); accumulatorWeight /= 2.; progress->RegisterInternalFilter(filter, accumulatorWeight); filter->SetInput(outputPtr); filter->Update(); for (unsigned int idx = 0; idx < filter->GetNumberOfOutputs(); ++idx) { GenerateData(depth + 1, filter->GetOutput(idx), progress); } } else { m_WaveletPacketRule.push_back(false); this->GetOutput()->PushBack(outputPtr); } } /** * Template specialozation for the Wavelet::INVERSE transformation */ template WaveletPacketTransform > ::WaveletPacketTransform () : m_SubsampleImageFactor(2), m_NumberOfFilters(0), m_DepthOfDecomposition(0) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageType::New()); m_FilterList = FilterListType::New(); } template void WaveletPacketTransform > ::GenerateOutputInformation() { if (m_NumberOfFilters == 0) InterpretRule(); this->GetOutput()->CopyInformation(this->GetInput()->GetNthElement(0)); InputImageRegionType inputRegion = this->GetInput()->GetNthElement(0)->GetLargestPossibleRegion(); SizeType inputSize = inputRegion.GetSize(); IndexType inputIndex = inputRegion.GetIndex(); OutputImageSizeType outputSize; OutputImageIndexType outputIndex; for (unsigned int i = 0; i < InputImageDimension; ++i) { outputIndex[i] = inputIndex[i] * GetSubsampleImageFactor() * GetDepthOfDecomposition(); outputSize[i] = inputSize[i] * GetSubsampleImageFactor() * GetDepthOfDecomposition(); } otbMsgDevMacro(<< "Output Size [" << outputSize[0] << "," << outputSize[1] << "]"); OutputImageRegionType outputRegion; outputRegion.SetIndex(outputIndex); outputRegion.SetSize(outputSize); this->GetOutput()->SetRegions(outputRegion); } template void WaveletPacketTransform > ::GenerateData() { if (m_WaveletPacketRule[0] != true) { throw itk::ExceptionObject(__FILE__, __LINE__, "No decomposition to perform in Generic data... Check WaveletPacketRule tab", ITK_LOCATION); } if (m_NumberOfFilters == 0) InterpretRule(); otbMsgDevMacro(<< "nbFilter = " << m_NumberOfFilters); otbMsgDevMacro(<< "depth = " << m_DepthOfDecomposition); otbMsgDevMacro(<< "rule size = " << m_WaveletPacketRule.size()); if (m_NumberOfFilters == 0) { throw itk::ExceptionObject(__FILE__, __LINE__, "No filter found in the decomposition tree... Check WaveletPacketRule tab", ITK_LOCATION); } InputImageIterator inputIterator = this->GetInput()->Begin(); unsigned int pos = 1; SetInputFilters(pos, inputIterator, 0); if (pos != m_WaveletPacketRule.size() || inputIterator != this->GetInput()->End()) { throw itk::ExceptionObject(__FILE__, __LINE__, "Bad decomposition tree implementation...", ITK_LOCATION); } m_FilterList->GetNthElement(0)->GraftOutput(this->GetOutput()); itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); for (pos = m_NumberOfFilters; pos > 0; pos--) { FilterPointerType filter = m_FilterList->GetNthElement(pos - 1); progress->RegisterInternalFilter(filter, 1.f / static_cast(m_NumberOfFilters)); filter->Update(); } this->GraftOutput(m_FilterList->GetNthElement(0)->GetOutput()); } template unsigned int WaveletPacketTransform > ::SetInputFilters (unsigned int& ruleID, InputImageIterator& imgIt, unsigned int filterID) { unsigned int nextFilterID = filterID + 1; if (ruleID == m_WaveletPacketRule.size()) return m_FilterList->Size(); const unsigned int filterBankInputSize=1 << InputImageDimension; for (unsigned int i = 0; i < filterBankInputSize; ++i) { if (m_WaveletPacketRule[ruleID++] == true) { m_FilterList->GetNthElement(filterID)->SetInput(i, m_FilterList->GetNthElement(nextFilterID)->GetOutput()); nextFilterID = SetInputFilters(ruleID, imgIt, nextFilterID); } else { m_FilterList->GetNthElement(filterID)->SetInput(i, imgIt.Get()); ++imgIt; } } return nextFilterID; } template void WaveletPacketTransform > ::InterpretRule() { if (m_FilterList && m_FilterList->Size() != 0) { if (m_NumberOfFilters != 0) itkExceptionMacro(<< "Incoherency between member value"); } m_NumberOfFilters = 0; m_DepthOfDecomposition = 0; for (unsigned int posRule = 0; posRule < m_WaveletPacketRule.size(); posRule++) InterpretRule(posRule, 0); } template void WaveletPacketTransform > ::InterpretRule (unsigned int& ruleID, unsigned int curDepth) { if (curDepth > m_DepthOfDecomposition) m_DepthOfDecomposition = curDepth; if (m_WaveletPacketRule[ruleID] == true) { m_FilterList->PushBack(FilterType::New()); FilterPointerType filter = m_FilterList->GetNthElement(m_NumberOfFilters); filter->SetSubsampleImageFactor(GetSubsampleImageFactor()); if (GetSubsampleImageFactor() == 1) filter->SetUpSampleFilterFactor(curDepth); m_NumberOfFilters++; const unsigned int filterBankInputSize = 1 << InputImageDimension; for (unsigned int i = 0; i < filterBankInputSize; ++i) { ruleID++; InterpretRule(ruleID, curDepth + 1); } } } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletTransform.h000066400000000000000000000310331301006202600261640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletTransform_h #define otbWaveletTransform_h #include "otbImageToImageListFilter.h" #include "otbImageListToImageFilter.h" #include "otbObjectList.h" #include "otbWaveletGenerator.h" #include "otbWaveletOperatorBase.h" namespace otb { /** \class WaveletTransform * \brief Wavelet transformation framework * * This class defines the Wavelet transformation of an image * by using a (templated) elementary wavelet transform. * * Here the number of decomposition is given. The output is given * in the GetOutput() list of images ranked from the low-pass part to the * highest frequency part. * * Output image organization depends on the number of Dim on the image * In the OutputList, the first image is always the low passed one. Next, * follow the high Passed images of the lowest decomposition (ask * GetFilter(0)->GetNumberOfOutputs() to know the length) and so on until * the high passed images of the highest decomposition. * * \sa WaveletFilterBank * \sa WaveletPacketTransform * * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletTransform : public itk::ImageSource { public: /** Standard typedefs */ typedef WaveletTransform Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletTransform, ImageSource); protected: /** But this class cannot do any thing! No constructor is implemented */ WaveletTransform(); virtual ~WaveletTransform(); private: WaveletTransform (const Self &); void operator =(const Self&); }; /** \class WaveletTransform * \brief Forward Wavelet transformation framework * * This class defines the Wavelet transformation of an image * by using a (templated) elementary wavelet transform. * * Here the number of decomposition is given. The output is given * in the GetOutput() list of images ranked from the low-pass part to the * highest frequency part. * * Output image organization depends on the number of Dim on the image * In the OutputList, the first image is always the low passed one. Next, * follow the high Passed images of the lowest decomposition (ask * GetFilter(0)->GetNumberOfOutputs() to know the length) and so on until * the high passed images of the highest decomposition. * * Here is the specialization of the Wavelet::FORWARD transformation. * * \sa WaveletFilterBank * \sa WaveletPacketTransform * * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletTransform : public ImageToImageListFilter { public: /** Standard typedefs */ typedef WaveletTransform Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletTransform, ImageToImageListFilter); typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::Iterator OutputImageIterator; typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; typedef ObjectList FilterListType; typedef typename FilterListType::Pointer FilterListPointerType; typedef typename FilterListType::Iterator FilterListIterator; itkGetObjectMacro(FilterList, FilterListType); FilterType * GetNthFilter(unsigned int idx) const { if (idx >= m_NumberOfDecompositions) { itkExceptionMacro(<< "Impossible to GetNthFilter with the index element " << idx << "; this element don't exist, the size of the filter list is " << m_FilterList->Size() << "."); } return static_cast(m_FilterList->GetNthElement(idx)); } typedef Wavelet::WaveletDirection DirectionOfTransformationEnumType; itkStaticConstMacro(DirectionOfTransformation, DirectionOfTransformationEnumType, Wavelet::FORWARD); itkGetMacro(NumberOfDecompositions, unsigned int); itkSetMacro(NumberOfDecompositions, unsigned int); itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** * Set/Get the level of down sampling of the image used in forward algorithm. * (or upsampling in the inverse case) * * In this implementation, we are not (yet?) dealing with M-band decomposition * then m_SubsampleImageFactor is most likely to be 1 or 2... but in any case integer * and not real... */ itkGetMacro(SubsampleImageFactor, unsigned int); itkSetMacro(SubsampleImageFactor, unsigned int); protected: WaveletTransform(); ~WaveletTransform() ITK_OVERRIDE {} /** Generate data redefinition */ void GenerateData() ITK_OVERRIDE; private: WaveletTransform (const Self &); void operator =(const Self&); /** * Number of decomposition of the multi-scale/-resolution decomposition. */ unsigned int m_NumberOfDecompositions; /** * For multiscale decomposition, m_SubsampleImageFactor is set to 1. * It yields also a stationary decomposition. * For multiresolution decomposition, most of the time, m_SubsampleImageFactor is * to be set to 2. This is its default value. */ unsigned int m_SubsampleImageFactor; /** * The list of filter is necessary to keep the pipeline updated. */ FilterListPointerType m_FilterList; }; // end of Forward class /** \class WaveletTransform * \brief Inverse Wavelet transformation framework * * This class defines the Wavelet transformation of an image * by using a (templated) elementary wavelet transform. * * Here the number of decomposition is given. The output is given * in the GetOutput() list of images ranked from the low-pass part to the * highest frequency part. * * Output image organization depends on the number of Dim on the image * In the OutputList, the first image is always the low passed one. Next, * follow the high Passed images of the lowest decomposition (ask * GetFilter(0)->GetNumberOfOutputs() to know the length) and so on until * the high passed images of the highest decomposition. * * Here is the specialization of the Wavelet::INVERSE transformation. * * The filter should be implemented with TInputImage for input and output image * template. Transtyping to TOutputImage is performed by standard C++-style at pixel * level. * * \sa WaveletFilterBank * \sa WaveletPacketTransform * * * \ingroup OTBWavelet */ template class ITK_EXPORT WaveletTransform : public ImageListToImageFilter { public: /** Standard typedefs */ typedef WaveletTransform Self; typedef ImageListToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(WaveletTransform, ImageListToImageFilter); typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::ValueType ValueType; typedef typename Superclass::InputImageListType InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::Iterator InputImageIterator; typedef typename Superclass::OutputImageType OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::SizeType OutputImageSizeType; typedef typename OutputImageType::IndexType OutputImageIndexType; typedef typename OutputImageType::ValueType OutputValueType; typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; typedef ObjectList FilterListType; typedef typename FilterListType::Pointer FilterListPointerType; typedef typename FilterListType::Iterator FilterListIterator; itkGetObjectMacro(FilterList, FilterListType); FilterType * GetNthFilter(unsigned int idx) const { if (idx >= m_NumberOfDecompositions) { itkExceptionMacro(<< "Impossible to GetNthFilter with the index element " << idx << "; this element don't exist, the size of the filter list is " << m_FilterList->Size() << "."); } return static_cast(m_FilterList->GetNthElement(idx)); } typedef Wavelet::WaveletDirection DirectionOfTransformationEnumType; itkStaticConstMacro(DirectionOfTransformation, DirectionOfTransformationEnumType, Wavelet::INVERSE); itkGetMacro(NumberOfDecompositions, unsigned int); itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** * Set/Get the level of down sampling of the image used in forward algorithm. * (or upsampling in the inverse case) * * In this implementation, we are not (yet?) dealing with M-band decomposition * then m_SubsampleImageFactor is most likely to be 1 or 2... but in any case integer * and not real... */ itkGetMacro(SubsampleImageFactor, unsigned int); itkSetMacro(SubsampleImageFactor, unsigned int); protected: WaveletTransform(); ~WaveletTransform() ITK_OVERRIDE {} /** GenerateOutputInformation * Set the size of the output image depending on the decimation factor * Copy information from the input image if existing. **/ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate data redefinition */ void GenerateData() ITK_OVERRIDE; private: WaveletTransform (const Self &); void operator =(const Self&); /** * Number of decomposition of the multi-scale/-resolution decomposition. */ unsigned int m_NumberOfDecompositions; /** * For multiscale decomposition, m_SubsampleImageFactor is set to 1 (default). * It yields also a stationnary decomposition. * For multiresolution decomposition, most of the time, m_SubsampleImageFactor is * to be set to 2. */ unsigned int m_SubsampleImageFactor; /** * The list of filter is necessary to keep the papeline updated. */ FilterListPointerType m_FilterList; }; // end of inverse class } // end of namespace #ifndef OTB_MANUAL_INSTANTIATION #include "otbWaveletTransform.txx" #endif #endif OTB-release-5.8/Modules/Filtering/Wavelet/include/otbWaveletTransform.txx000066400000000000000000000176621301006202600265740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaveletTransform_txx #define otbWaveletTransform_txx #include "otbWaveletTransform.h" #include "itkImageRegionIterator.h" #include "itkProgressAccumulator.h" #include "otbMacro.h" namespace otb { /** * Template Specialization for the Wavelet::FORWARD case */ template WaveletTransform ::WaveletTransform () : m_NumberOfDecompositions(1), m_SubsampleImageFactor(2) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageListType::New()); m_FilterList = FilterListType::New(); } template void WaveletTransform ::GenerateData() { itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); GetFilterList()->Resize(GetNumberOfDecompositions()); this->GetFilterList()->SetNthElement(0, FilterType::New()); FilterPointerType filter = this->GetFilterList()->GetNthElement(0); //GetNthFilter( 0 ); filter->SetInput(this->GetInput()); filter->SetSubsampleImageFactor(GetSubsampleImageFactor()); otbMsgDevMacro(<<"Allocating " << (1 + GetNumberOfDecompositions() * (filter->GetNumberOfOutputs() - 1)) << " output\n"); this->GetOutput()->Resize( 1 + GetNumberOfDecompositions() * (filter->GetNumberOfOutputs() - 1)); otbMsgDevMacro(<<"Using " << this->GetOutput()->Size() << " outputs..."); for (unsigned int idx = 0; idx < this->GetOutput()->Size(); ++idx) { this->GetOutput()->SetNthElement(idx, OutputImageType::New()); } progress->RegisterInternalFilter(filter, 1.f / static_cast(GetNumberOfDecompositions())); filter->Update(); for (unsigned int idx = 1; idx < filter->GetNumberOfOutputs(); ++idx) { this->GetOutput()->SetNthElement( this->GetOutput()->Size() - filter->GetNumberOfOutputs() + idx, filter->GetOutput(idx)); } for (unsigned int nbDecomp = 1; nbDecomp < GetNumberOfDecompositions(); nbDecomp++) { this->GetFilterList()->SetNthElement(nbDecomp, FilterType::New()); filter = this->GetFilterList()->GetNthElement(nbDecomp); //this->GetNthFilter( nbDecomp ); filter->SetInput(this->GetNthFilter(nbDecomp - 1)->GetOutput(0)); filter->SetSubsampleImageFactor(GetSubsampleImageFactor()); if (GetSubsampleImageFactor() == 1) filter->SetUpSampleFilterFactor(nbDecomp + 1); progress->RegisterInternalFilter(filter, 1.f / static_cast(GetNumberOfDecompositions())); filter->Update(); for (unsigned int idx = 1; idx < filter->GetNumberOfOutputs(); ++idx) { this->GetOutput()->SetNthElement( this->GetOutput()->Size() - 1 - (nbDecomp + 1) * (filter->GetNumberOfOutputs() - 1) + idx, filter->GetOutput(idx)); } } this->GetOutput()->SetNthElement(0, filter->GetOutput(0)); } /** * Template Specialization for the Wavelet::INVERSE case */ template WaveletTransform ::WaveletTransform () : m_NumberOfDecompositions(1), m_SubsampleImageFactor(2) { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageType::New()); m_FilterList = FilterListType::New(); } template void WaveletTransform ::GenerateOutputInformation() { this->GetOutput()->CopyInformation(this->GetInput()->GetNthElement(0)); if (GetSubsampleImageFactor() != 1) { InputImageRegionType inputRegion = this->GetInput()->GetNthElement(0)->GetLargestPossibleRegion(); SizeType inputSize = inputRegion.GetSize(); IndexType inputIndex = inputRegion.GetIndex(); OutputImageSizeType outputSize; OutputImageIndexType outputIndex; for (unsigned int i = 0; i < InputImageDimension; ++i) { outputIndex[i] = inputIndex[i] * GetSubsampleImageFactor() * GetNumberOfDecompositions(); outputSize[i] = inputSize[i] * GetSubsampleImageFactor() * GetNumberOfDecompositions(); } OutputImageRegionType outputRegion; outputRegion.SetIndex(outputIndex); outputRegion.SetSize(outputSize); this->GetOutput()->SetRegions(outputRegion); } } template void WaveletTransform ::GenerateData() { FilterPointerType filter = FilterType::New(); const unsigned int filterbankInputSize = 1 << InputImageDimension; m_NumberOfDecompositions = (this->GetInput()->Size() - 1)/(filterbankInputSize - 1); otbMsgDevMacro(<< "Found " << m_NumberOfDecompositions << " decompositions"); itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); this->GetFilterList()->Resize(GetNumberOfDecompositions()); InputImageIterator inputIterator = this->GetInput()->Begin(); this->GetFilterList()->SetNthElement(0, FilterType::New()); filter = this->GetNthFilter(0); for (unsigned int i = 0; i < filterbankInputSize; ++i) { filter->SetInput(i, inputIterator.Get()); ++inputIterator; } filter->SetSubsampleImageFactor(GetSubsampleImageFactor()); if (GetSubsampleImageFactor() == 1) { filter->SetUpSampleFilterFactor(GetNumberOfDecompositions()); } progress->RegisterInternalFilter(filter, 1.f / static_cast(GetNumberOfDecompositions())); filter->Update(); for (unsigned int idx = 1; idx < GetNumberOfDecompositions(); ++idx) { this->GetFilterList()->SetNthElement(idx, FilterType::New()); filter = this->GetNthFilter(idx); filter->SetInput(0, this->GetNthFilter(idx - 1)->GetOutput()); for (unsigned int i = 1; i < filterbankInputSize; ++i) { filter->SetInput(i, inputIterator.Get()); ++inputIterator; } filter->SetSubsampleImageFactor(GetSubsampleImageFactor()); if (GetSubsampleImageFactor() == 1) { filter->SetUpSampleFilterFactor(GetNumberOfDecompositions() - idx); } progress->RegisterInternalFilter(filter, 1.f / static_cast(GetNumberOfDecompositions())); filter->Update(); } // This step is necessary to transtype output image to the wanted format this->GetOutput()->CopyInformation(filter->GetOutput()); this->GetOutput()->SetRegions(filter->GetOutput()->GetLargestPossibleRegion()); this->GetOutput()->Allocate(); this->GetOutput()->FillBuffer(0); itk::ImageRegionIterator outputIter (this->GetOutput(), this->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionConstIterator outFltIter (filter->GetOutput(), filter->GetOutput()->GetLargestPossibleRegion()); for (outputIter.GoToBegin(), outFltIter.GoToBegin(); !outputIter.IsAtEnd(); ++outputIter, ++outFltIter) { outputIter.Set(static_cast(outFltIter.Get())); } } } // end of namespace otb #endif OTB-release-5.8/Modules/Filtering/Wavelet/otb-module.cmake000066400000000000000000000003761301006202600234370ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes for wavelet analysis.") otb_module(OTBWavelet DEPENDS OTBCommon OTBITK OTBObjectList TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Filtering/Wavelet/src/000077500000000000000000000000001301006202600211475ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Wavelet/src/CMakeLists.txt000066400000000000000000000003541301006202600237110ustar00rootroot00000000000000set(OTBWavelet_SRC otbWaveletGenerator.cxx ) add_library(OTBWavelet ${OTBWavelet_SRC}) target_link_libraries(OTBWavelet ${OTBCommon_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_module_target(OTBWavelet) OTB-release-5.8/Modules/Filtering/Wavelet/src/otbWaveletGenerator.cxx000066400000000000000000000323701301006202600256630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWaveletGenerator.h" #include #include "itkMacro.h" #include "otbMath.h" namespace otb { /** * Standard (useless) definition for unknown wavelet */ template const char * WaveletGenerator ::GetWaveletName() const { std::ostringstream msg; msg << "The mother wavelet ID " << TMotherWaveletOperator; msg << " is unknown or has to be implemented...\n"; throw itk::ExceptionObject(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); return "Unknown"; } template void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& itkNotUsed(coeff)) const { std::ostringstream msg; msg << "The mother wavelet ID " << TMotherWaveletOperator; msg << " is unknown or has to be implemented...\n"; throw itk::ExceptionObject(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); } template void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& itkNotUsed(coeff)) const { std::ostringstream msg; msg << "The mother wavelet ID " << TMotherWaveletOperator; msg << " is unknown or has to be implemented (check the txx file)...\n"; throw itk::ExceptionObject(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); } /** * Template specialization for the Haar wavelet */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("Haar"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(3); // stands for z^{-1} coeff[0] = 0.0; // stands for z^0 coeff[1] = 0.5 * CONST_SQRT2; // stands for z^1 coeff[2] = 0.5 * CONST_SQRT2; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(3); // stands for z^{-1} coeff[0] = 0.; // stands for z^0 coeff[1] = -0.5 * CONST_SQRT2; // stands for z^1 coeff[2] = 0.5 * CONST_SQRT2; } /** * Template specialization for the Daubechies 4 wavelet */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("Daubechies_4"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(5); coeff[0] = 0.; coeff[1] = (1 + CONST_SQRT3) / 8.0 * CONST_SQRT2; coeff[2] = (3 + CONST_SQRT3) / 8.0 * CONST_SQRT2; coeff[3] = (3 - CONST_SQRT3) / 8.0 * CONST_SQRT2; coeff[4] = (1 - CONST_SQRT3) / 8.0 * CONST_SQRT2; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(5); coeff[0] = 0; coeff[1] = -(1 - CONST_SQRT3) / 8.0 * CONST_SQRT2; coeff[2] = (3 - CONST_SQRT3) / 8.0 * CONST_SQRT2; coeff[3] = -(3 + CONST_SQRT3) / 8.0 * CONST_SQRT2; coeff[4] = (1 + CONST_SQRT3) / 8.0 * CONST_SQRT2; } /** * Template specialization for the Daubechies 6 tap wavelet */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("Daubechies_6"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(7); coeff[0] = 0.; coeff[1] = 0.332670552950; coeff[2] = 0.806891509311; coeff[3] = 0.459877502118; coeff[4] = -0.135011020010; coeff[5] = -0.085441273882; coeff[6] = 0.035226291882; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(7); coeff[0] = 0.; coeff[1] = -0.035226291882; coeff[2] = -0.085441273882; coeff[3] = 0.135011020010; coeff[4] = 0.459877502118; coeff[5] = -0.806891509311; coeff[6] = 0.332670552950; } /** * Template specialization for the Daubechies 8 wavelet */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("Daubechies_8"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 0.; coeff[1] = 0.2303778133090; coeff[2] = 0.7148465705530; coeff[3] = 0.630880767930; coeff[4] = -0.0279837694170; coeff[5] = -0.1870348117190; coeff[6] = 0.0308413818360; coeff[7] = 0.0328830116670; coeff[8] = -0.0105974017850; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 0.; coeff[1] = 0.0105974017850; coeff[2] = 0.0328830116670; coeff[3] = -0.0308413818360; coeff[4] = -0.1870348117190; coeff[5] = 0.0279837694170; coeff[6] = 0.630880767930; coeff[7] = -0.7148465705530; coeff[8] = 0.2303778133090; } /** * Template specialization for the Daubechies 12 tap wavelet */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("Daubechies_12"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(13); coeff[0] = 0.; coeff[1] = 0.1115407433501095; coeff[2] = 0.4946238903984533; coeff[3] = 0.7511339080210959; coeff[4] = 0.3152503517091982; coeff[5] = -0.2262646939654400; coeff[6] = -0.1297668675672625; coeff[7] = 0.0975016055873225; coeff[8] = 0.0275228655303053; coeff[9] = -0.0315820393184862; coeff[10] = 0.0005538422011614; coeff[11] = 0.0047772575119455; coeff[12] = -0.0010773010853085; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(13); coeff[0] = 0.; coeff[1] = 0.0010773010853085; coeff[2] = 0.0047772575119455; coeff[3] = -0.0005538422011614; coeff[4] = -0.0315820393184862; coeff[5] = -0.0275228655303053; coeff[6] = 0.0975016055873225; coeff[7] = 0.1297668675672625; coeff[8] = -0.2262646939654400; coeff[9] = -0.3152503517091982; coeff[10] = 0.7511339080210959; coeff[11] = -0.4946238903984533; coeff[12] = 0.1115407433501095; } /** * Template specialization for the Daubechies 20 tap wavelet */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("Daubechies_20"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(21); coeff[0] = 0.; coeff[1] = 0.026670057901; coeff[2] = 0.188176800078; coeff[3] = 0.527201188932; coeff[4] = 0.688459039454; coeff[5] = 0.281172343661; coeff[6] = -0.249846424327; coeff[7] = -0.195946274377; coeff[8] = 0.127369340336; coeff[9] = 0.093057364604; coeff[10] = -0.071394147166; coeff[11] = -0.029457536822; coeff[12] = 0.033212674059; coeff[13] = 0.003606553567; coeff[14] = -0.010733175483; coeff[15] = 0.001395351747; coeff[16] = 0.001992405295; coeff[17] = -0.000685856695; coeff[18] = -0.000116466855; coeff[19] = 0.000093588670; coeff[20] = -0.000013264203; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(21); coeff[0] = 0.; coeff[1] = 0.000013264203; coeff[2] = 0.000093588670; coeff[3] = 0.000116466855; coeff[4] = -0.000685856695; coeff[5] = -0.001992405295; coeff[6] = 0.001395351747; coeff[7] = 0.010733175483; coeff[8] = 0.003606553567; coeff[9] = -0.033212674059; coeff[10] = -0.029457536822; coeff[11] = 0.071394147166; coeff[12] = 0.093057364604; coeff[13] = -0.127369340336; coeff[14] = -0.195946274377; coeff[15] = 0.249846424327; coeff[16] = 0.281172343661; coeff[17] = -0.688459039454; coeff[18] = 0.527201188932; coeff[19] = -0.188176800078; coeff[20] = 0.026670057901; } /** * Template specialization for the Spline Biorthogonal Wavelet. * * M.Antonini, M.Barlaud, P.Mathieu, I.Daubechies * Image Coding Using Wavelet Transform * IEEE Transactions on Image Processing, * vol 1(2), pp:205-220, April 1992 */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("SplineBiorthoonal_2_4"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 3.0 / 128.0 * CONST_SQRT2; coeff[1] = -3.0 / 64.0 * CONST_SQRT2; coeff[2] = -1.0 / 8.0 * CONST_SQRT2; coeff[3] = 19.0 / 64.0 * CONST_SQRT2; coeff[4] = 45.0 / 64.0 * CONST_SQRT2; coeff[5] = 19.0 / 64.0 * CONST_SQRT2; coeff[6] = -1.0 / 8.0 * CONST_SQRT2; coeff[7] = -3.0 / 64.0 * CONST_SQRT2; coeff[8] = 3.0 / 128.0 * CONST_SQRT2; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 0.; coeff[1] = 0.; coeff[2] = 0.; coeff[3] = 0.; coeff[4] = -1.0 / 4.0 * CONST_SQRT2; coeff[5] = 1.0 / 2.0 * CONST_SQRT2; coeff[6] = -1.0 / 4.0 * CONST_SQRT2; coeff[7] = 0.; coeff[8] = 0.; } /** * Template specialization for the Spline Biorthogonal Wavelet. * * M.Antonini, M.Barlaud, P.Mathieu, I.Daubechies * Image Coding Using Wavelet Transform * IEEE Transactions on Image Processing, * vol 1(2), pp:205-220, April 1992 * * Also in Daubechies's "Ten Lectures on Wavelet": in * less disparate filter lengths, pp 278--279. * * Also known as 7/9 filter. */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("SplineBiorthoonal_4_4"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 0.026748757411 * CONST_SQRT2; coeff[1] = -0.016864118443 * CONST_SQRT2; coeff[2] = -0.078223266529 * CONST_SQRT2; coeff[3] = 0.266864118443 * CONST_SQRT2; coeff[4] = 0.602949018236 * CONST_SQRT2; coeff[5] = 0.266864118443 * CONST_SQRT2; coeff[6] = -0.078223266529 * CONST_SQRT2; coeff[7] = -0.016864118443 * CONST_SQRT2; coeff[8] = 0.026748757411 * CONST_SQRT2; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 0.; coeff[1] = 0.; coeff[2] = 0.045635881557 * CONST_SQRT2; coeff[3] = -0.028771763114 * CONST_SQRT2; coeff[4] = -0.295635881557 * CONST_SQRT2; coeff[5] = 0.557543526229 * CONST_SQRT2; coeff[6] = -0.295635881557 * CONST_SQRT2; coeff[7] = -0.028771763114 * CONST_SQRT2; coeff[8] = 0.045635881557 * CONST_SQRT2; } /** * Template specialization for the Symlet 8 tap orthogonal wavelet */ template <> const char * WaveletGenerator::GetWaveletName() const { static const std::string waveletName ("Symlet_8"); return waveletName.c_str(); } template <> void WaveletGenerator ::GetLowPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 0.; coeff[1] = -0.075765714789273; coeff[2] = -0.029635527645999; coeff[3] = 0.497618667632015; coeff[4] = 0.803738751805916; coeff[5] = 0.297857795605277; coeff[6] = -0.099219543576847; coeff[7] = -0.012603967262038; coeff[8] = 0.032223100604043; } template <> void WaveletGenerator ::GetHighPassCoefficientVector(CoefficientVector& coeff) const { coeff.resize(9); coeff[0] = 0.; coeff[1] = -0.032223100604043; coeff[2] = -0.012603967262038; coeff[3] = 0.099219543576847; coeff[4] = 0.297857795605277; coeff[5] = -0.803738751805916; coeff[6] = 0.497618667632015; coeff[7] = 0.029635527645999; coeff[8] = -0.075765714789273; } /* * Forcing instantiation */ template class WaveletGenerator; template class WaveletGenerator; template class WaveletGenerator; template class WaveletGenerator; template class WaveletGenerator; template class WaveletGenerator; template class WaveletGenerator; template class WaveletGenerator; template class WaveletGenerator; } // end of namespace otb OTB-release-5.8/Modules/Filtering/Wavelet/test/000077500000000000000000000000001301006202600213375ustar00rootroot00000000000000OTB-release-5.8/Modules/Filtering/Wavelet/test/CMakeLists.txt000066400000000000000000000440671301006202600241120ustar00rootroot00000000000000otb_module_test() set(OTBWaveletTests otbWaveletTestDriver.cxx otbWaveletOperator.cxx otbWaveletPacketTransform.cxx otbWaveletTransform.cxx otbSubsampleImageFilter.cxx otbSubsampleImageFilterNew.cxx otbWaveletInverseFilterBankNew.cxx otbWaveletInverseTransformNew.cxx otbWaveletTransformNew.cxx otbWaveletPacketInverseTransformNew.cxx otbWaveletFilterBank.cxx otbWaveletPacketTransformNew.cxx otbWaveletFilterBankNew.cxx otbWaveletOperatorNew.cxx ) add_executable(otbWaveletTestDriver ${OTBWaveletTests}) target_link_libraries(otbWaveletTestDriver ${OTBWavelet-Test_LIBRARIES}) otb_module_target_label(otbWaveletTestDriver) # Tests Declaration otb_add_test(NAME msTuWaveletOperator COMMAND otbWaveletTestDriver otbWaveletOperator ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformSPLINE_BIORTHOGONAL_4_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleSPLINE_BIORTHOGONAL_4_4.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleSPLINE_BIORTHOGONAL_4_4.tif 2 1 7 #SPLINE_BIORTHOGONAL_4_4 ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformHaar COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleHaar.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleHaar.tif 2 1 0 #Haar ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformDB8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB8.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB8.tif 2 1 3 #DB8 ) otb_add_test(NAME msTvWaveletPacketTransformDB4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB4.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB4.tif 2 2 1 #DB4 ) otb_add_test(NAME msTvWaveletPacketTransformDB20 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB20.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB20.tif 2 2 5 #DB20 ) otb_add_test(NAME msTvWaveletPacketTransformDB6 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB6.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB6.tif 2 2 2 #DB6 ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformSPLINE_BIORTHOGONAL_2_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleSPLINE_BIORTHOGONAL_2_4.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleSPLINE_BIORTHOGONAL_2_4.tif 2 1 6 #SPLINE_BIORTHOGONAL_2_4 ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformDB6 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB6.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB6.tif 2 1 2 #DB6 ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformDB4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB4.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB4.tif 2 1 1 #DB4 ) otb_add_test(NAME msTvWaveletPacketTransformDB8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB8.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB8.tif 2 2 3 #DB8 ) otb_add_test(NAME msTvWaveletPacketTransformSYMLET8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketSYMLET8.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketSYMLET8.tif 2 2 8 #SYMLET8 ) otb_add_test(NAME msTvWaveletPacketTransformHaar COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketHaar.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketHaar.tif 2 2 0 #Haar ) otb_add_test(NAME msTvWaveletPacketTransformSPLINE_BIORTHOGONAL_2_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketSPLINE_BIORTHOGONAL_2_4.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketSPLINE_BIORTHOGONAL_2_4.tif 2 2 6 #SPLINE_BIORTHOGONAL_2_4 ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformDB20 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB20.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB20.tif 2 1 5 #DB20 ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformSYMLET8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleSYMLET8.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleSYMLET8.tif 2 1 8 #SYMLET8 ) otb_add_test(NAME msTvWaveletPacketTransformSPLINE_BIORTHOGONAL_4_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketSPLINE_BIORTHOGONAL_4_4.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketSPLINE_BIORTHOGONAL_4_4.tif 2 2 7 #SPLINE_BIORTHOGONAL_4_4 ) otb_add_test(NAME msTvWaveletPacketTransformDB12 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB12.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketDB12.tif 2 2 4 #DB12 ) otb_add_test(NAME msTvWaveletPacketMultiScaleTransformDB12 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB12.tif otbWaveletPacketTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltPacketMultiScaleDB12.tif 2 1 4 #DB12 ) otb_add_test(NAME msTvWaveletTransformDB4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB4.tif 2 2 1 #DB4 ) otb_add_test(NAME msTvWaveletTransformDB6 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB6.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB6.tif 2 2 2 #DB6 ) otb_add_test(NAME msTvWaveletMultiScaleTransformSYMLET8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleSYMLET8.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleSYMLET8.tif 2 1 8 #SYMLET8 ) otb_add_test(NAME msTvWaveletMultiScaleTransformSPLINE_BIORTHOGONAL_2_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleSPLINE_BIORTHOGONAL_2_4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleSPLINE_BIORTHOGONAL_2_4.tif 2 1 6 #SPLINE_BIORTHOGONAL_2_4 ) otb_add_test(NAME msTvWaveletTransformDB8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB8.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB8.tif 2 2 3 #DB8 ) otb_add_test(NAME msTvWaveletMultiScaleTransformSPLINE_BIORTHOGONAL_4_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleSPLINE_BIORTHOGONAL_4_4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleSPLINE_BIORTHOGONAL_4_4.tif 2 1 7 #SPLINE_BIORTHOGONAL_4_4 ) otb_add_test(NAME msTvWaveletTransformDB20 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB20.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB20.tif 2 2 5 #DB20 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB8_1 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB8_1.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB8_1.tif 2 1 3 #DB8 1 ) otb_add_test(NAME msTvWaveletMultiScaleTransformHaar_1 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar_1.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar_1.tif 2 1 0 #Haar 1 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB4_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4_4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4_4.tif 2 1 1 #DB4 4 ) otb_add_test(NAME msTvWaveletMultiScaleTransformHaar_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar_4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar_4.tif 2 1 0 #Haar 4 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB4_1 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4_1.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4_1.tif 2 1 1 #DB4 1 ) otb_add_test(NAME msTvWaveletMultiScaleTransformHaar_8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar_8.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar_8.tif 2 1 0 #Haar 8 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB4_8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4_8.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4_8.tif 2 1 1 #DB4 8 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB6_1 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB6_1.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB6_1.tif 2 1 2 #DB6 1 ) otb_add_test(NAME msTvWaveletTransformSPLINE_BIORTHOGONAL_2_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltSPLINE_BIORTHOGONAL_2_4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltSPLINE_BIORTHOGONAL_2_4.tif 2 2 6 #SPLINE_BIORTHOGONAL_2_4 ) otb_add_test(NAME msTvWaveletTransformSYMLET8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltSYMLET8.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltSYMLET8.tif 2 2 8 #SYMLET8 ) otb_add_test(NAME msTvWaveletTransformSPLINE_BIORTHOGONAL_4_4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltSPLINE_BIORTHOGONAL_4_4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltSPLINE_BIORTHOGONAL_4_4.tif 2 2 7 #SPLINE_BIORTHOGONAL_4_4 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB12 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB12.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB12.tif 2 1 4 #DB12 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB4 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB4.tif 2 1 1 #DB4 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB6 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB6.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB6.tif 2 1 2 #DB6 ) otb_add_test(NAME msTvWaveletMultiScaleTransformHaar COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleHaar.tif 2 1 0 #Haar ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB8 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB8.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB8.tif 2 1 3 #DB8 ) otb_add_test(NAME msTvWaveletTransformDB12 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB12.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltDB12.tif 2 2 4 #DB12 ) otb_add_test(NAME msTvWaveletMultiScaleTransformDB20 COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB20.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltMultiScaleDB20.tif 2 1 5 #DB20 ) otb_add_test(NAME msTvWaveletTransformHaar COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltHaar.tif otbWaveletTransform ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_WvltHaar.tif 2 2 0 #Haar ) otb_add_test(NAME msTvSubsampleImageFilter COMMAND otbWaveletTestDriver --compare-image ${NOTOL} ${TEMP}/msSubsampleImageFilterOversampled.tif ${TEMP}/msSubsampleImageFilterOnePixelOutOf2.tif otbSubsampleImageFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msSubsampleImageFilterOversampled.tif ${TEMP}/msSubsampleImageFilterOnePixelOutOf2.tif ) otb_add_test(NAME msTuSubsampleImageFilterNew COMMAND otbWaveletTestDriver otbSubsampleImageFilterNew) otb_add_test(NAME msTuWaveletInverseFilterBankNew COMMAND otbWaveletTestDriver otbWaveletInverseFilterBankNew) otb_add_test(NAME msTuWaveletInverseTransformNew COMMAND otbWaveletTestDriver otbWaveletInverseTransformNew) otb_add_test(NAME msTuWaveletTransformNew COMMAND otbWaveletTestDriver otbWaveletTransformNew) otb_add_test(NAME msTuWaveletPacketInverseTransformNew COMMAND otbWaveletTestDriver otbWaveletPacketInverseTransformNew) otb_add_test(NAME msTvWaveletMultiScaleFilterBank COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_FilterBankMultiScale.tif otbWaveletFilterBank ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif 1 ${TEMP}/ROI_IKO_PAN_LesHalles_FilterBankMultiScale.tif ) otb_add_test(NAME msTvWaveletFilterBank COMMAND otbWaveletTestDriver --compare-image ${EPSILON_6} ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ROI_IKO_PAN_LesHalles_FilterBank.tif otbWaveletFilterBank ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif 2 ${TEMP}/ROI_IKO_PAN_LesHalles_FilterBank.tif ) otb_add_test(NAME msTuWaveletPacketTransformNew COMMAND otbWaveletTestDriver otbWaveletPacketTransformNew) otb_add_test(NAME msTuWaveletFilterBankNew COMMAND otbWaveletTestDriver otbWaveletFilterBankNew) otb_add_test(NAME msTuWaveletOperatorNew COMMAND otbWaveletTestDriver otbWaveletOperatorNew ) OTB-release-5.8/Modules/Filtering/Wavelet/test/otbSubsampleImageFilter.cxx000066400000000000000000000042571301006202600266440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSubsampleImageFilter.h" int otbSubsampleImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName1 = argv[2]; const char * outputFileName2 = argv[3]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); typedef otb::SubsampleImageFilter InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); invFilter->SetInput(reader->GetOutput()); itk::Index delta = {{2, 2}}; invFilter->SetSubsampleFactor(delta); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer1 = WriterType::New(); writer1->SetFileName(outputFileName1); writer1->SetInput(invFilter->GetOutput()); writer1->Update(); typedef otb::SubsampleImageFilter ForwardFilterType; ForwardFilterType::Pointer filter = ForwardFilterType::New(); filter->SetInput(invFilter->GetOutput()); filter->SetSubsampleFactor(invFilter->GetSubsampleFactor()); WriterType::Pointer writer2 = WriterType::New(); writer2->SetFileName(outputFileName2); writer2->SetInput(filter->GetOutput()); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbSubsampleImageFilterNew.cxx000066400000000000000000000023121301006202600273040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSubsampleImageFilter.h" int otbSubsampleImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::SubsampleImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletFilterBank.cxx000066400000000000000000000051301301006202600261400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" int otbWaveletFilterBank(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const unsigned int decimFactor = atoi(argv[2]); // 1 for multiscale, 2 for multiresolution const char * outputFileName = argv[3]; const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; /* Reading */ ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); /* Wavelet choice */ //const otb::Wavelet::Wavelet wvltID = otb::Wavelet::HAAR; const otb::Wavelet::Wavelet wvltID = otb::Wavelet::SYMLET8; /* Forward Transformation */ typedef otb::WaveletOperator WaveletOperator; typedef otb::WaveletFilterBank FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetSubsampleImageFactor(decimFactor); /* Inverse Transformation */ typedef otb::WaveletOperator InvWaveletOperator; typedef otb::WaveletFilterBank InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); for (unsigned int i = 0; i < filter->GetNumberOfOutputs(); ++i) invFilter->SetInput(i, filter->GetOutput(i)); invFilter->SetSubsampleImageFactor(filter->GetSubsampleImageFactor()); /* Saving output */ typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(invFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletFilterBankNew.cxx000066400000000000000000000024721301006202600266200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" int otbWaveletFilterBankNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; /* Wavelet choice */ //const otb::Wavelet::Wavelet wvltID = otb::Wavelet::HAAR; const otb::Wavelet::Wavelet wvltID = otb::Wavelet::DB4; typedef otb::WaveletOperator WaveletOperator; typedef otb::WaveletFilterBank FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletInverseFilterBankNew.cxx000066400000000000000000000025441301006202600301540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" int otbWaveletInverseFilterBankNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; /* Wavelet choice */ //const otb::Wavelet::Wavelet wvltID = otb::Wavelet::HAAR; const otb::Wavelet::Wavelet wvltID = otb::Wavelet::SYMLET8; /* Inverse Transformation */ typedef otb::WaveletOperator WaveletOperator; typedef otb::WaveletFilterBank FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletInverseTransformNew.cxx000066400000000000000000000030751301006202600301060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletTransform.h" int otbWaveletInverseTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; /* Wavelet choice */ const otb::Wavelet::Wavelet wvltID = otb::Wavelet::SYMLET8; /* Inverse Transformation */ typedef otb::WaveletOperator InverseWaveletOperator; typedef otb::WaveletFilterBank InverseFilterBank; typedef otb::WaveletTransform InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); std::cout << invFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletOperator.cxx000066400000000000000000000027041301006202600257160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWaveletOperator.h" int otbWaveletOperator(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const otb::Wavelet::WaveletDirection directionID = otb::Wavelet::FORWARD; const otb::Wavelet::Wavelet wvltID = otb::Wavelet::HAAR; const int Dimension = 2; typedef double PixelType; typedef otb::WaveletOperator WaveletOperator; typedef WaveletOperator::LowPassOperator LowPassOperatorType; typedef WaveletOperator::HighPassOperator HighPassOperatorType; LowPassOperatorType h_filter; h_filter.SetDirection(0); h_filter.SetUpSampleFactor(2); h_filter.CreateDirectional(); HighPassOperatorType g_filter; g_filter.SetDirection(0); g_filter.SetUpSampleFactor(2); g_filter.CreateDirectional(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletOperatorNew.cxx000066400000000000000000000024371301006202600263730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWaveletOperator.h" int otbWaveletOperatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const otb::Wavelet::WaveletDirection directionID = otb::Wavelet::INVERSE; const otb::Wavelet::Wavelet wvltID = otb::Wavelet::SPLINE_BIORTHOGONAL_4_4; const int Dimension = 2; typedef double PixelType; typedef otb::WaveletOperator WaveletOperator; typedef WaveletOperator::LowPassOperator LowPassOperatorType; LowPassOperatorType h_filter; typedef WaveletOperator::HighPassOperator HighPassOperatorType; HighPassOperatorType g_filter; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletPacketInverseTransformNew.cxx000066400000000000000000000032101301006202600312250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletPacketTransform.h" int otbWaveletPacketInverseTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; /* Wavelet choice */ //const otb::Wavelet::Wavelet wvltID = otb::Wavelet::HAAR; const otb::Wavelet::Wavelet wvltID = otb::Wavelet::DB8; /* Inverse Transformation */ typedef otb::WaveletOperator InverseWaveletOperator; typedef otb::WaveletFilterBank InverseFilterBank; typedef otb::WaveletPacketTransform InvFilterType; InvFilterType::Pointer invFilter = InvFilterType::New(); std::cout << invFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletPacketTransform.cxx000066400000000000000000000107641301006202600272330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletPacketTransform.h" template int otbWaveletPacketTransform_generic(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int level = atoi(argv[3]); const unsigned int decimFactor = atoi(argv[4]); const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; /* Reading */ ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); /* Wavelet choice */ const otb::Wavelet::Wavelet wvltID = TWavelet; /* Wavelet packet configuration */ typedef otb::FullyDecomposedWaveletPacketCost CostType; CostType::NumberOfAllowedDecompositions = level; /* Forward Transformation */ typedef otb::WaveletOperator WaveletOperator; typedef otb::WaveletFilterBank ForwardFilterBank; typedef otb::WaveletPacketTransform FilterType; typename FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetSubsampleImageFactor(decimFactor); filter->Update(); /* Inverse Transformation */ typedef otb::WaveletOperator InvWaveletOperator; typedef otb::WaveletFilterBank InvFilterBank; typedef otb::WaveletPacketTransform InvFilterType; typename InvFilterType::Pointer invFilter = InvFilterType::New(); invFilter->SetInput(filter->GetOutput()); invFilter->SetWaveletPacketRule(filter->GetWaveletPacketRule()); invFilter->SetSubsampleImageFactor(decimFactor); invFilter->Update(); /* Writing the output */ typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(invFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbWaveletPacketTransform(int argc, char * argv[]) { if (argc != 6) { std::cerr << "Usage: " << argv[0] << " " << std::endl; return EXIT_FAILURE; } int waveletType = atoi(argv[5]); switch (waveletType) { case 0: return otbWaveletPacketTransform_generic (argc, argv); break; case 1: return otbWaveletPacketTransform_generic (argc, argv); break; case 2: return otbWaveletPacketTransform_generic (argc, argv); break; case 3: return otbWaveletPacketTransform_generic (argc, argv); break; case 4: return otbWaveletPacketTransform_generic (argc, argv); break; case 5: return otbWaveletPacketTransform_generic (argc, argv); break; case 6: return otbWaveletPacketTransform_generic (argc, argv); break; case 7: return otbWaveletPacketTransform_generic (argc, argv); break; case 8: return otbWaveletPacketTransform_generic (argc, argv); break; default: std::cerr << "No more wavelet available\n"; return EXIT_FAILURE; } } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletPacketTransformNew.cxx000066400000000000000000000032541301006202600277010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletPacketTransform.h" int otbWaveletPacketTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; /* Wavelet choice */ const otb::Wavelet::Wavelet wvltID = otb::Wavelet::HAAR; // const otb::Wavelet::Wavelet wvltID = otb::Wavelet::SYMLET8; /* Wavelet packet configuration */ typedef otb::FullyDecomposedWaveletPacketCost CostType; CostType::NumberOfAllowedDecompositions = 1; /* Forward Transformation */ typedef otb::WaveletOperator WaveletOperator; typedef otb::WaveletFilterBank ForwardFilterBank; typedef otb::WaveletPacketTransform FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletTestDriver.cxx000066400000000000000000000011501301006202600262100ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbWaveletOperator); REGISTER_TEST(otbWaveletPacketTransform); REGISTER_TEST(otbWaveletTransform); REGISTER_TEST(otbSubsampleImageFilter); REGISTER_TEST(otbSubsampleImageFilterNew); REGISTER_TEST(otbWaveletInverseFilterBankNew); REGISTER_TEST(otbWaveletInverseTransformNew); REGISTER_TEST(otbWaveletTransformNew); REGISTER_TEST(otbWaveletPacketInverseTransformNew); REGISTER_TEST(otbWaveletFilterBank); REGISTER_TEST(otbWaveletPacketTransformNew); REGISTER_TEST(otbWaveletFilterBankNew); REGISTER_TEST(otbWaveletOperatorNew); } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletTransform.cxx000066400000000000000000000106661301006202600261040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletTransform.h" template int otbWaveletTransform_generic(int argc, char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int level = atoi(argv[3]); const unsigned int decimFactor = atoi(argv[4]); if (argc == 7) { unsigned int NbOfThreads = atoi(argv[6]); itk::MultiThreader::SetGlobalDefaultNumberOfThreads(NbOfThreads); } const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; /* Reading */ ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); /* Wavelet choice */ const otb::Wavelet::Wavelet wvltID = TWavelet; /* Forward Transformation */ typedef otb::WaveletOperator WaveletOperator; typedef otb::WaveletFilterBank ForwardFilterBank; typedef otb::WaveletTransform FilterType; typename FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetNumberOfDecompositions(level); filter->SetSubsampleImageFactor(decimFactor); filter->Update(); /* Inverse Transformation */ typedef otb::WaveletOperator InvWaveletOperator; typedef otb::WaveletFilterBank InverseFilterBank; typedef otb::WaveletTransform InvFilterType; typename InvFilterType::Pointer invFilter = InvFilterType::New(); invFilter->SetInput(filter->GetOutput()); invFilter->SetSubsampleImageFactor(decimFactor); invFilter->Update(); /* Writing the output */ typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(invFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbWaveletTransform(int argc, char * argv[]) { if ((argc > 7) || (argc<6)) { std::cerr << "Usage: " << argv[0] << " (optional)" << std::endl; return EXIT_FAILURE; } int waveletType = atoi(argv[5]); switch (waveletType) { case 0: return otbWaveletTransform_generic (argc, argv); break; case 1: return otbWaveletTransform_generic (argc, argv); break; case 2: return otbWaveletTransform_generic (argc, argv); break; case 3: return otbWaveletTransform_generic (argc, argv); break; case 4: return otbWaveletTransform_generic (argc, argv); break; case 5: return otbWaveletTransform_generic (argc, argv); break; case 6: return otbWaveletTransform_generic (argc, argv); break; case 7: return otbWaveletTransform_generic (argc, argv); break; case 8: return otbWaveletTransform_generic (argc, argv); break; default: std::cerr << "No more wavelet available\n"; return EXIT_FAILURE; } } OTB-release-5.8/Modules/Filtering/Wavelet/test/otbWaveletTransformNew.cxx000066400000000000000000000026661301006202600265570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletTransform.h" int otbWaveletTransformNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; /* Wavelet choice */ const otb::Wavelet::Wavelet wvltID = otb::Wavelet::SYMLET8; /* Forward Transformation */ typedef otb::WaveletOperator WaveletOperator; typedef otb::WaveletFilterBank ForwardFilterBank; typedef otb::WaveletTransform FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/000077500000000000000000000000001301006202600162715ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/Fuzzy/000077500000000000000000000000001301006202600174205ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/Fuzzy/CMakeLists.txt000066400000000000000000000001061301006202600221550ustar00rootroot00000000000000project(OTBFuzzy) set(OTBFuzzy_LIBRARIES OTBFuzzy) otb_module_impl() OTB-release-5.8/Modules/Fusion/Fuzzy/include/000077500000000000000000000000001301006202600210435ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/Fuzzy/include/otbFuzzyDescriptorsModelManager.h000066400000000000000000000046031301006202600275510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFuzzyDescriptorsModelManager_h #define otbFuzzyDescriptorsModelManager_h #include #include #include namespace otb { /** \class FuzzyDescriptorsModelManager * \brief Read a xml file where are stored several statistics * * To get a specific statistic Measurement vector, use the method * GetStatisticVectorByName(name) which allow you to get the * Measurement vector for the statistic set as parameter. * * * * \ingroup OTBFuzzy */ class FuzzyDescriptorsModelManager { public: /** Standard class typedefs */ typedef FuzzyDescriptorsModelManager Self; /** Convenient typedef */ typedef std::vector ParameterType; typedef std::pair PairType; typedef std::vector< PairType > DescriptorsModelType; typedef std::vector< std::string > DescriptorListType; /** Method to get descriptors */ static PairType GetDescriptor(const char * model, const DescriptorsModelType & descModel); /** Method to get descriptor List */ static DescriptorListType GetDescriptorList(const DescriptorsModelType & descModel); /** Method to set descriptors */ static void AddDescriptor( PairType modelPair, DescriptorsModelType & descModel ); static void AddDescriptor( std::string key, ParameterType model, DescriptorsModelType & descModel ); /** Print a model */ static void Print( const DescriptorsModelType & descModel ); /** Read a model from a xml file */ static DescriptorsModelType Read(const std::string & filename); /** Write a model in a xml file */ static void Save(const std::string & filename, DescriptorsModelType & model ); FuzzyDescriptorsModelManager(); virtual ~FuzzyDescriptorsModelManager() {} private: }; // end of class FuzzyDescriptorsModelManager } // end of namespace otb #endif OTB-release-5.8/Modules/Fusion/Fuzzy/include/otbFuzzyVariable.h000066400000000000000000000077311301006202600245260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFuzzyVariable_h #define otbFuzzyVariable_h #include "itkDataObject.h" #include "itkFixedArray.h" #include "itkObjectFactory.h" namespace otb { /** \class FuzzyVariable * \brief Class to represent a fuzzy N-valued variable. * * A fuzzy variable is defined as a set of qualitative values for a * magnitude. These values are ordered, as for instance Low, Medium, * High. The semantics are not used here. This class holds a * vector where each component is the membership value for each one * of the qualitative values of the variable (MEDIUM = 0.9). Each * membership function is modeled by a trapezoidal function for which * 4 values have to be provided. * In addition, 2 more values can be provided to define the min and * the max. By default, they are 0 and 1 respectively. * * * \ingroup OTBFuzzy */ template class ITK_EXPORT FuzzyVariable : public itk::DataObject { public: /** Standard class typedefs */ typedef FuzzyVariable Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(FuzzyVariable, DataObject); /** Label typedef */ typedef TLabel LabelType; /** Precision typedef */ typedef TPrecision PrecisionType; /** Type to hold the membership values */ typedef std::map MembershipValueType; typedef itk::FixedArray< PrecisionType, 6> ParametersType; typedef std::map ParametersMapType; /** Get the membership related to one label */ PrecisionType GetMembership(const LabelType & var, const PrecisionType & value) const; /** Get all the memberships */ MembershipValueType GetMembership(const PrecisionType & value) const; /** Get the label with the highest membership */ LabelType GetMaxVar(const PrecisionType & value) const; /** Set the membership for a given Label */ void SetMembership(const LabelType & var, const PrecisionType & v1, const PrecisionType & v2, const PrecisionType & v3, const PrecisionType & v4); void SetMembership(const LabelType & var, const PrecisionType & v1, const PrecisionType & v2, const PrecisionType & v3, const PrecisionType & v4, const PrecisionType & min, const PrecisionType & max); /** Remove a given label from the membership table */ void RemoveMembership(const LabelType & var); /** Clear all memberships */ void Clear(); /** Print a MembershipValueType */ static std::ostream& PrintMembershipValueType(std::ostream & out, const MembershipValueType& membership); protected: /** Constructor */ FuzzyVariable(); /** Destructor */ ~FuzzyVariable() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** Map containing the membership functions */ ParametersMapType m_MembershipFunctions; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFuzzyVariable.txx" #endif #endif OTB-release-5.8/Modules/Fusion/Fuzzy/include/otbFuzzyVariable.txx000066400000000000000000000164201301006202600251150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFuzzyVariable_txx #define otbFuzzyVariable_txx #include "otbFuzzyVariable.h" #include "otbMacro.h" namespace otb { template FuzzyVariable::FuzzyVariable() {} template void FuzzyVariable::SetMembership(const LabelType& var, const PrecisionType & v1, const PrecisionType & v2, const PrecisionType & v3, const PrecisionType & v4) { // Check if values are ordered correctly if( v1>v2 || v2>v3 || v3>v4) itkExceptionMacro(<< "Values have to be v1<=v2<=v3<=v4"); // Build the membership parameters ParametersType parameters; parameters[0] = v1; parameters[1] = v2; parameters[2] = v3; parameters[3] = v4; parameters[4] = static_cast(0); parameters[5] = static_cast(1); // Insert it in the parameters map m_MembershipFunctions[var]=parameters; // Call modified this->Modified(); } template void FuzzyVariable::SetMembership(const LabelType& var, const PrecisionType & v1, const PrecisionType & v2, const PrecisionType & v3, const PrecisionType & v4, const PrecisionType & min, const PrecisionType & max) { // Check if values are ordered correctly if( v1>v2 || v2>v3 || v3>v4) itkExceptionMacro(<< "Values have to be v1<=v2<=v3<=v4"); if( min>=max) itkExceptionMacro(<< "Values have to be minModified(); } template void FuzzyVariable ::RemoveMembership(const LabelType & var) { // Erase one parameter m_MembershipFunctions.erase(var); // Call Modified() this->Modified(); } template void FuzzyVariable ::Clear() { // Clear the membership parameters map m_MembershipFunctions.clear(); // Call Modified() this->Modified(); } template typename FuzzyVariable ::PrecisionType FuzzyVariable ::GetMembership(const LabelType & var, const PrecisionType & value) const { // Declare output PrecisionType output = itk::NumericTraits::Zero; // Retrieve parameters for the given membership function typename ParametersMapType::const_iterator mapIt = m_MembershipFunctions.find(var); // If var exists in the parameters map if(mapIt!=m_MembershipFunctions.end()) { // Retrieve parameters ParametersType parameters = mapIt->second; // Remaining of the code is trapezoidal function if( value < parameters[0] || value >= parameters[3] ) { output = parameters[4]; } else if( value >= parameters[0] && value < parameters[1] ) { if(parameters[1]>parameters[0]) { output = static_cast(parameters[4] + (value - parameters[0]) /(parameters[1] - parameters[0]) *(parameters[5] - parameters[4])); } else { output = parameters[5]; } } if( value >= parameters[1] && value < parameters[2] ) { output = parameters[5]; } if( value >= parameters[2] && value < parameters[3] ) { if(parameters[3]>parameters[2]) { output = static_cast(parameters[4] + (parameters[3] - value) /(parameters[3] - parameters[2]) *(parameters[5] - parameters[4])); } else { output = parameters[5]; } } } // Return the membership value return output; } template typename FuzzyVariable ::MembershipValueType FuzzyVariable ::GetMembership(const PrecisionType & value) const { // Build the output membership map MembershipValueType output; // Walk the membership parameters map for(typename ParametersMapType::const_iterator mapIt = m_MembershipFunctions.begin(); mapIt!=m_MembershipFunctions.end(); ++mapIt) { // Compute the membership output[mapIt->first] = this->GetMembership(mapIt->first, value); } // Return output return output; } template typename FuzzyVariable ::LabelType FuzzyVariable ::GetMaxVar(const PrecisionType & value) const { // If parameters map is empty, throw an exception if(m_MembershipFunctions.empty()) { itkExceptionMacro(<<"Membership parameters map is empty"); } // First retrieve all membership values MembershipValueType memberships = this->GetMembership(value); // Define an iterator on the membership parameters map typename MembershipValueType::const_iterator mapIt = memberships.begin(); // Look for the higher value LabelType higherVar = mapIt->first; PrecisionType higherVal = mapIt->second; ++mapIt; while(mapIt!=memberships.end()) { if(mapIt->second > higherVal) { higherVal = mapIt->second; higherVar = mapIt->first; } ++mapIt; } // Return the higher var return higherVar; } template void FuzzyVariable ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template std::ostream & FuzzyVariable ::PrintMembershipValueType(std::ostream & out, const MembershipValueType & labelMap) { // Define an iterator on the label set typedef std::map LabelMapType; typename LabelMapType::const_iterator it = labelMap.begin(); // Open the set out<<"{"; // Append the set elements while(it != labelMap.end()) { out<first<<" : "<second; ++it; if(it != labelMap.end()) out<<", "; } // close the set out<<"}"; // Return return out; } } // end namespace otb #endif OTB-release-5.8/Modules/Fusion/Fuzzy/otb-module.cmake000066400000000000000000000010161301006202600224670ustar00rootroot00000000000000set(DOCUMENTATION "A fuzzy variable is defined as a set of qualitative values for a magnitude. These values are ordered, as for instance Low, Medium, High. This module contains classes able to hold a vector where each component is the membership value for each one of the qualitative values. it also contains classes able to handle xml files where are stored several statistics.") otb_module(OTBFuzzy DEPENDS OTBCommon OTBTinyXML OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Fusion/Fuzzy/src/000077500000000000000000000000001301006202600202075ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/Fuzzy/src/CMakeLists.txt000066400000000000000000000003271301006202600227510ustar00rootroot00000000000000set(OTBFuzzy_SRC otbFuzzyDescriptorsModelManager.cxx ) add_library(OTBFuzzy ${OTBFuzzy_SRC}) target_link_libraries(OTBFuzzy ${OTBCommon_LIBRARIES} ${OTBTinyXML_LIBRARIES} ) otb_module_target(OTBFuzzy) OTB-release-5.8/Modules/Fusion/Fuzzy/src/otbFuzzyDescriptorsModelManager.cxx000066400000000000000000000136201301006202600272670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFuzzyDescriptorsModelManager.h" #include "itkMacro.h" #include "itksys/SystemTools.hxx" #include "otb_tinyxml.h" namespace otb { FuzzyDescriptorsModelManager ::FuzzyDescriptorsModelManager() {} FuzzyDescriptorsModelManager::PairType FuzzyDescriptorsModelManager ::GetDescriptor(const char * model, const DescriptorsModelType & descModel) { PairType out; bool found = false; DescriptorsModelType::const_iterator it = descModel.begin(); while( it!=descModel.end() && found == false) { if( (*it).first == model ) { found = true; out = (*it); } ++it; } if( found == false ) { itkGenericExceptionMacro(<<"No models named "< model, DescriptorsModelType & descModel ) { PairType lPair( key, model ); descModel.push_back(lPair); } void FuzzyDescriptorsModelManager ::Print( const DescriptorsModelType & descModel ) { for(unsigned int i=0; iNextSiblingElement() ) { PairType currentDescriptor; // Store the descriptor type name currentDescriptor.first = currentStat->Attribute("name"); // The size is not stored in the XML file // Store the value in a std::vector, get the size and then // build a measurement vector ParameterType param; for( TiXmlElement* sample = currentStat->FirstChildElement("Parameter"); sample != ITK_NULLPTR; sample = sample->NextSiblingElement() ) { // Get the current value of the descriptor double value; sample->QueryDoubleAttribute("value", &value); // Store the value param.push_back(value); } // Add descriptor parameters currentDescriptor.second = param; // Add the pai to the model descModel.push_back(currentDescriptor); } return descModel; } void FuzzyDescriptorsModelManager ::Save(const std::string & filename, DescriptorsModelType & model ) { // Check if the filename is not empty if( filename.empty() == true ) { itkGenericExceptionMacro(<<"The XML output FileName is empty"); } // Check that the right extension is given : expected .xml */ if (itksys::SystemTools::GetFilenameLastExtension(filename) != ".xml") { itkGenericExceptionMacro(<SetAttribute("name", model[i].first.c_str()); root->LinkEndChild( desc ); ParameterType param = model[i].second; // Store the value for this statistic for(unsigned int cindex = 0; cindex < param.size(); ++cindex) { // For each value in Measurementvector TiXmlElement * curStatisticVector = new TiXmlElement("Parameter"); curStatisticVector->SetDoubleAttribute("value", param[cindex]); desc->LinkEndChild(curStatisticVector); } } // Finally, write the file doc.SaveFile( filename.c_str() ); } FuzzyDescriptorsModelManager::DescriptorListType FuzzyDescriptorsModelManager ::GetDescriptorList(const DescriptorsModelType & descModel) { DescriptorListType out; DescriptorsModelType::const_iterator it = descModel.begin(); while( it!=descModel.end()) { out.push_back((*it).first); ++it; } return out; } } // End namespace otb OTB-release-5.8/Modules/Fusion/Fuzzy/test/000077500000000000000000000000001301006202600203775ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/Fuzzy/test/CMakeLists.txt000066400000000000000000000022731301006202600231430ustar00rootroot00000000000000otb_module_test() set(OTBFuzzyTests otbFuzzyTestDriver.cxx otbFuzzyVariableSetValue.cxx otbFuzzyVariable2Values.cxx otbFuzzyVariableNew.cxx otbFuzzyVariableDSApplied.cxx otbFuzzyVariableGetMaxVar.cxx otbFuzzyDescriptorsModelManager.cxx ) add_executable(otbFuzzyTestDriver ${OTBFuzzyTests}) target_link_libraries(otbFuzzyTestDriver ${OTBFuzzy-Test_LIBRARIES}) otb_module_target_label(otbFuzzyTestDriver) # Tests Declaration otb_add_test(NAME fzTvFuzzyVariableSetValue COMMAND otbFuzzyTestDriver otbFuzzyVariableSetValue) otb_add_test(NAME fzTvFuzzyVariable2Values COMMAND otbFuzzyTestDriver otbFuzzyVariable2Values) otb_add_test(NAME fzTuFuzzyVariableNew COMMAND otbFuzzyTestDriver otbFuzzyVariableNew) otb_add_test(NAME fzTvFuzzyVariableDSApplied COMMAND otbFuzzyTestDriver otbFuzzyVariableDSApplied) otb_add_test(NAME fzTvFuzzyVariableGetMaxVar COMMAND otbFuzzyTestDriver otbFuzzyVariableGetMaxVar) otb_add_test(NAME fzTvFuzzyDescriptorsModelManagerTest COMMAND otbFuzzyTestDriver otbFuzzyDescriptorsModelManagerTest ${TEMP}/fzTvFuzzyDescriptorsModelManager.xml ) otb_add_test(NAME fzTuFuzzyDescriptorsModelManagerNew COMMAND otbFuzzyTestDriver otbFuzzyDescriptorsModelManagerNew) OTB-release-5.8/Modules/Fusion/Fuzzy/test/otbFuzzyDescriptorsModelManager.cxx000066400000000000000000000041461301006202600274620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFuzzyDescriptorsModelManager.h" #include #include #include "itkMacro.h" int otbFuzzyDescriptorsModelManagerNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { otb::FuzzyDescriptorsModelManager mng; return EXIT_SUCCESS; } int otbFuzzyDescriptorsModelManagerTest(int itkNotUsed(argc), char* argv[]) { otb::FuzzyDescriptorsModelManager::DescriptorsModelType model; otb::FuzzyDescriptorsModelManager::ParameterType param; otb::FuzzyDescriptorsModelManager::PairType couple; couple.first = "desc1"; param.push_back(0); param.push_back(1); couple.second = param; otb::FuzzyDescriptorsModelManager::AddDescriptor(couple, model); param.clear(); param.push_back(9); param.push_back(8); param.push_back(7); param.push_back(6); otb::FuzzyDescriptorsModelManager::AddDescriptor("desc2", param, model); otb::FuzzyDescriptorsModelManager::Save(argv[1], model); otb::FuzzyDescriptorsModelManager::DescriptorsModelType modelRead; modelRead = otb::FuzzyDescriptorsModelManager::Read(argv[1]); otb::FuzzyDescriptorsModelManager::DescriptorListType list; list = otb::FuzzyDescriptorsModelManager::GetDescriptorList(model); if(modelRead != model) { std::cout<<"Written model and read model from the written one differs."< FuzzyVarType; FuzzyVarType::Pointer fv = FuzzyVarType::New(); /* We define 2 trapezoidal functions for Low and High values | 1 |--------------\ ----------------- | \ / | \ / | Low X High | / \ | / \ |--------------/------------------------------- 0 0.3 0.7 1 */ fv->SetMembership("Low", 0, 0, 0.3, 0.7); fv->SetMembership("High", 0.3, 0.7, 1.0, 1.0); PrecisionType mem; mem = fv->GetMembership("Low", 0.2); if( mem != 1 ) return EXIT_FAILURE; mem = fv->GetMembership("Low", 0.9); if( mem != 0 ) return EXIT_FAILURE; mem = fv->GetMembership("Low", 0.5); if( mem != 0.5 ) return EXIT_FAILURE; mem = fv->GetMembership("High", 0.2); if( mem != 0 ) return EXIT_FAILURE; mem = fv->GetMembership("High", 0.9); if( mem != 1 ) return EXIT_FAILURE; mem = fv->GetMembership("High", 0.5); if( mem != 0.5 ) return EXIT_FAILURE; // For the sake of coverage fv->RemoveMembership("Low"); fv->Clear(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/Fuzzy/test/otbFuzzyVariableDSApplied.cxx000066400000000000000000000034511301006202600261560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFuzzyVariable.h" int otbFuzzyVariableDSApplied(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef float PrecisionType; typedef otb::FuzzyVariable FuzzyVarType; FuzzyVarType::Pointer fv = FuzzyVarType::New(); fv->SetMembership("H1", 0, 0, 0.1, 0.5, 0, 0.8); fv->SetMembership("!H1", 0.5, 0.8, 1.0, 1.0, 0, 0.8); fv->SetMembership("Theta", 0.1, 0.5, 0.5, 0.8, 0.2, 1); std::string maxVar; PrecisionType pos; PrecisionType memH1; PrecisionType memH1_; PrecisionType memTheta; for(unsigned int i=0; i<=100; ++i) { pos = (PrecisionType)i/100; maxVar = fv->GetMaxVar(pos); memH1 = fv->GetMembership("H1", pos); memH1_ = fv->GetMembership("!H1", pos); memTheta = fv->GetMembership("Theta", pos); std::cout << "Memberships(" << pos << "): [" << memH1 << ", " << memH1_ << ", " << memTheta <<"] - MaxVar(" << pos << ") : " << maxVar << std::endl; } fv->RemoveMembership("H1"); fv->RemoveMembership("!H1"); fv->RemoveMembership("Theta"); fv->Clear(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/Fuzzy/test/otbFuzzyVariableGetMaxVar.cxx000066400000000000000000000022001301006202600261760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFuzzyVariable.h" int otbFuzzyVariableGetMaxVar(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef float PrecisionType; typedef otb::FuzzyVariable FuzzyVarType; FuzzyVarType::Pointer fv = FuzzyVarType::New(); fv->SetMembership("Low", 0, 0, 0.25, 0.5); fv->SetMembership("MediumLow", 0, 0.2, 0.5, 0.6); fv->SetMembership("MediumHigh", 0.5, 0.6, 0.8, 1); fv->SetMembership("High", 0.5, 0.75, 1.0, 1.0); std::string maxVar = fv->GetMaxVar(0.4); if( maxVar != "MediumLow" ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/Fuzzy/test/otbFuzzyVariableNew.cxx000066400000000000000000000015561301006202600251060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFuzzyVariable.h" int otbFuzzyVariableNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef float PrecisionType; typedef unsigned short LabelType; typedef otb::FuzzyVariable FuzzyVarType; FuzzyVarType::Pointer fv = FuzzyVarType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/Fuzzy/test/otbFuzzyVariableSetValue.cxx000066400000000000000000000026311301006202600261000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFuzzyVariable.h" int otbFuzzyVariableSetValue(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef float PrecisionType; typedef otb::FuzzyVariable FuzzyVarType; FuzzyVarType::Pointer fv = FuzzyVarType::New(); fv->SetMembership("Low", 0, 0, 0.25, 0.75); fv->SetMembership("Medium", 0, 0.25, 0.75, 1); fv->SetMembership("High", 0.25, 0.75, 1.0, 1.0); FuzzyVarType::MembershipValueType memValues = fv->GetMembership(0.5); FuzzyVarType::PrintMembershipValueType(std::cout, memValues); if( memValues["Low"] != static_cast((0.75-0.5)/(0.75-0.25)) ) return EXIT_FAILURE; if( memValues["Medium"] != static_cast(1) ) return EXIT_FAILURE; if( memValues["High"] != static_cast((0.75-0.5)/(0.75-0.25)) ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/MajorityVoting/000077500000000000000000000000001301006202600212565ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/MajorityVoting/CMakeLists.txt000066400000000000000000000000551301006202600240160ustar00rootroot00000000000000project(OTBMajorityVoting) otb_module_impl() OTB-release-5.8/Modules/Fusion/MajorityVoting/include/000077500000000000000000000000001301006202600227015ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/MajorityVoting/include/otbNeighborhoodMajorityVotingImageFilter.h000066400000000000000000000177711301006202600332220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeighborhoodMajorityVotingImageFilter_h #define otbNeighborhoodMajorityVotingImageFilter_h // First make sure that the configuration is available. // This line can be removed once the optimized versions // gets integrated into the main directories. #include "itkConfigure.h" #include "itkUnaryFunctorImageFilter.h" #include "itkMorphologyImageFilter.h" #include "itkBinaryBallStructuringElement.h" namespace otb { /** * \class NeighborhoodMajorityVotingImageFilter * Neighborhood Majority Voting of an image * * Filters a labeled image using Majority Voting in a specified neighbordhood. Majority Voting takes the * more representative value of all the pixels identified by the structuring element and then sets the * center pixel to this label value. * * If the maximum number of votes is not unique, i.e., if more than one label have a maximum number of * votes, AND if the Boolean m_KeepOriginalLabelBool == false, then an "Undecided" label is assigned to that output pixel. * Otherwise, if m_KeepOriginalLabelBool == true, this output pixel keeps its Original value. * * NOT classified input pixels are assumed to belong to the m_LabelForNoDataPixels labeled class. * Those pixels keep their Original m_LabelForNoDataPixels label in the output image. * * The structuring element is assumed to be composed of binary * values (zero or one). Only elements of the structuring element * having values > 0 are candidates for affecting the center pixel. * * For the each input image pixel, * - NeighborhoodIterator gives neighbors of the pixel. * - Evaluate() member function returns the more representative label value among * the image neighbors where the kernel has elements > 0. * - Replace the original label value with the more representative label value * * \sa MorphologyImageFilter, GrayscaleFunctionDilateImageFilter, BinaryDilateImageFilter * \ingroup ImageEnhancement MathematicalMorphologyImageFilters * * \ingroup OTBMajorityVoting */ template< class TInputImage, class TOutputImage=TInputImage, class TKernel=typename itk::BinaryBallStructuringElement > class ITK_EXPORT NeighborhoodMajorityVotingImageFilter : public itk::MorphologyImageFilter { public: /** Standard class typedefs. */ typedef NeighborhoodMajorityVotingImageFilter Self; typedef itk::MorphologyImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(NeighborhoodMajorityVotingImageFilter, itk::MorphologyImageFilter); /** Declaration of pixel type. */ typedef typename Superclass::PixelType PixelType; /** Kernel (structuring element) iterator. */ typedef typename Superclass::KernelIteratorType KernelIteratorType; /** Neighborhood iterator type. */ typedef typename Superclass::NeighborhoodIteratorType NeighborhoodIteratorType; /** Kernel typedef. */ typedef typename Superclass::KernelType KernelType; /** Default boundary condition type */ typedef typename Superclass::DefaultBoundaryConditionType DefaultBoundaryConditionType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); itkStaticConstMacro(KernelDimension, unsigned int, TKernel::NeighborhoodDimension); /** Type of the pixels in the Kernel. */ typedef typename TKernel::PixelType KernelPixelType; #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(InputConvertibleToOutputCheck, (itk::Concept::Convertible)); itkConceptMacro(SameDimensionCheck1, (itk::Concept::SameDimension)); itkConceptMacro(SameDimensionCheck2, (itk::Concept::SameDimension)); itkConceptMacro(InputGreaterThanComparableCheck, (itk::Concept::GreaterThanComparable)); itkConceptMacro(KernelGreaterThanComparableCheck, (itk::Concept::GreaterThanComparable)); /** End concept checking */ #endif //Creates a SetLabelForNoDataPixels method virtual void SetLabelForNoDataPixels(const PixelType _arg) { itkDebugMacro("setting LabelForNoDataPixels to " << _arg); if (this->m_LabelForNoDataPixels != _arg) { this->m_LabelForNoDataPixels = _arg; m_MajorityVotingBoundaryCondition.SetConstant(m_LabelForNoDataPixels); this->OverrideBoundaryCondition(&m_MajorityVotingBoundaryCondition); this->Modified(); } } //Creates a SetLabelForUndecidedPixels method itkSetMacro(LabelForUndecidedPixels, PixelType); //Creates a SetKeepOriginalLabelBool method itkSetMacro(KeepOriginalLabelBool, bool); //Process only isolated pixels itkSetMacro(OnlyIsolatedPixels, bool); itkSetMacro(IsolatedThreshold, unsigned int); protected: NeighborhoodMajorityVotingImageFilter(); ~NeighborhoodMajorityVotingImageFilter() ITK_OVERRIDE {}; /** Evaluate image neighborhood with kernel to find the new value * for the center pixel value * * It will return the more representative label value of the labeled image pixels whose corresponding * element in the structuring element is positive. This version of * Evaluate is used for non-boundary pixels. */ PixelType Evaluate(const NeighborhoodIteratorType &nit, const KernelIteratorType kernelBegin, const KernelIteratorType kernelEnd) ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; //Type to store the useful information from the label histogram struct HistoSummary { unsigned int freqCenterLabel; PixelType majorityLabel; bool majorityUnique; }; struct CompareHistoFequencies { typedef std::pair HistoValueType; bool operator()(const HistoValueType& a, const HistoValueType& b) { return a.second > b.second; } }; //Get a histogram of frequencies of labels with the 2 highest // frequencies sorted in decreasing order and return the frequency // of the label of the center pixel const HistoSummary ComputeNeighborhoodHistogramSummary(const NeighborhoodIteratorType &nit, const KernelIteratorType kernelBegin, const KernelIteratorType kernelEnd) const; private: NeighborhoodMajorityVotingImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented // Default boundary condition for majority voting filter, defaults to DefaultBoundaryConditionType m_MajorityVotingBoundaryCondition; PixelType m_LabelForNoDataPixels; PixelType m_LabelForUndecidedPixels; bool m_KeepOriginalLabelBool; //Choose to filter only isolated pixels bool m_OnlyIsolatedPixels; //The center pixel is isolated if there are fewer neighbours than //this threshold with the same label unsigned int m_IsolatedThreshold; }; // end of class } // end namespace otb #ifndef ITK_MANUAL_INSTANTIATION #include "otbNeighborhoodMajorityVotingImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Fusion/MajorityVoting/include/otbNeighborhoodMajorityVotingImageFilter.txx000066400000000000000000000142711301006202600336060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeighborhoodMajorityVotingImageFilter_txx #define otbNeighborhoodMajorityVotingImageFilter_txx // First make sure that the configuration is available. // This line can be removed once the optimized versions // gets integrated into the main directories. #include "otbNeighborhoodMajorityVotingImageFilter.h" #include "itkDefaultConvertPixelTraits.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" namespace otb { /** * Constructor */ template NeighborhoodMajorityVotingImageFilter::NeighborhoodMajorityVotingImageFilter() { this->SetLabelForNoDataPixels(itk::NumericTraits::NonpositiveMin()); //m_LabelForNoDataPixels = 0 this->SetLabelForUndecidedPixels(itk::NumericTraits::NonpositiveMin()); //m_LabelForUndecidedPixels = 0 this->SetKeepOriginalLabelBool(true); //m_KeepOriginalLabelBool = true this->SetOnlyIsolatedPixels(false); //process all pixels this->SetIsolatedThreshold(1); } template typename NeighborhoodMajorityVotingImageFilter::PixelType NeighborhoodMajorityVotingImageFilter::Evaluate(const NeighborhoodIteratorType &nit, const KernelIteratorType kernelBegin, const KernelIteratorType kernelEnd) { const PixelType centerPixel = nit.GetCenterPixel(); if (centerPixel == m_LabelForNoDataPixels) { return m_LabelForNoDataPixels; } else { //Get a histogram of label frequencies where the 2 highest are at the beginning and sorted const HistoSummary histoSummary = this->ComputeNeighborhoodHistogramSummary(nit, kernelBegin, kernelEnd); if(m_OnlyIsolatedPixels && histoSummary.freqCenterLabel > m_IsolatedThreshold) { //If we want to filter only isolated pixels, keep the label if //there are enough pixels with the center label to consider that //it is not isolated return centerPixel; } else { //If the majorityLabel is NOT unique in the neighborhood if(!histoSummary.majorityUnique) { if (m_KeepOriginalLabelBool == true) { return centerPixel; } else { return m_LabelForUndecidedPixels; } } //Extraction of the more representative Label in the neighborhood (majorityLabel) return histoSummary.majorityLabel; } }//END if (centerPixel != m_LabelForNoDataPixels) } template const typename NeighborhoodMajorityVotingImageFilter::HistoSummary NeighborhoodMajorityVotingImageFilter::ComputeNeighborhoodHistogramSummary(const NeighborhoodIteratorType &nit, const KernelIteratorType kernelBegin, const KernelIteratorType kernelEnd) const { typedef std::map HistogramType; typedef std::vector > HistoAsVectorType; HistogramType histoNeigh; unsigned int i = 0; for (KernelIteratorType kernel_it = kernelBegin; kernel_it < kernelEnd; ++kernel_it, ++i) { // if structuring element is positive, use the pixel under that element // in the image // note we use GetPixel() on the SmartNeighborhoodIterator to // respect boundary conditions const PixelType label = nit.GetPixel(i); if ((*kernel_it > itk::NumericTraits::Zero) && (label != m_LabelForNoDataPixels)) { histoNeigh[label] += 1; } } HistoAsVectorType histoNeighVec(histoNeigh.begin(), histoNeigh.end()); //Sort the 2 max elements to the beginning std::nth_element(histoNeighVec.begin(), histoNeighVec.begin()+1, histoNeighVec.end(), CompareHistoFequencies()); typename NeighborhoodMajorityVotingImageFilter::HistoSummary result; result.freqCenterLabel = histoNeigh[nit.GetCenterPixel()]; result.majorityLabel = histoNeighVec[0].first; result.majorityUnique = (histoNeighVec[0].second != histoNeighVec[1].second); return result; } template void NeighborhoodMajorityVotingImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); TOutputImage* outputPtr = this->GetOutput(); // Set the NoData value using the background const unsigned int & nbBands = outputPtr->GetNumberOfComponentsPerPixel(); std::vector noDataValueAvailable; noDataValueAvailable.resize(nbBands,true); std::vector noDataValue; noDataValue.resize(nbBands,0.0); for (unsigned int i=0 ; i::GetNthComponent(i,m_LabelForNoDataPixels); } itk::MetaDataDictionary& dict = outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); } } // end namespace otb #endif OTB-release-5.8/Modules/Fusion/MajorityVoting/otb-module.cmake000066400000000000000000000006101301006202600243240ustar00rootroot00000000000000set(DOCUMENTATION "Majority voting takes the more representative label of all the pixels identified by the structuring element and then sets the center pixel to this label value (see also DempsterShafer module).") otb_module(OTBMajorityVoting DEPENDS OTBITK OTBOSSIMAdapters TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Fusion/MajorityVoting/test/000077500000000000000000000000001301006202600222355ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/MajorityVoting/test/CMakeLists.txt000066400000000000000000000033271301006202600250020ustar00rootroot00000000000000otb_module_test() set(OTBMajorityVotingTests otbMajorityVotingTestDriver.cxx otbNeighborhoodMajorityVotingImageFilterNew.cxx otbNeighborhoodMajorityVotingImageFilterTest.cxx ) add_executable(otbMajorityVotingTestDriver ${OTBMajorityVotingTests}) target_link_libraries(otbMajorityVotingTestDriver ${OTBMajorityVoting-Test_LIBRARIES}) otb_module_target_label(otbMajorityVotingTestDriver) # Tests Declaration otb_add_test(NAME leTuNeighborhoodMajorityVotingImageFilterNew COMMAND otbMajorityVotingTestDriver otbNeighborhoodMajorityVotingImageFilterNew) otb_add_test(NAME leTvNeighborhoodMajorityVotingImageFilterTest COMMAND otbMajorityVotingTestDriver --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_4Cls_N_Classified_OTB_NMV_x2_y5_nodv10_undv7.tif ${TEMP}/QB_1_ortho_4Cls_N_Classified_OTB_NMV_x2_y5_nodv10_undv7.tif otbNeighborhoodMajorityVotingImageFilterTest ${INPUTDATA}/Classification/QB_1_ortho_4Cls_N_Classified_OTB.tif ${TEMP}/QB_1_ortho_4Cls_N_Classified_OTB_NMV_x2_y5_nodv10_undv7.tif false #KeepOriginalLabelBool 2 #xRadius 5 #yRadius 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels 0 #OnlyIsolatedPixels ) otb_add_test(NAME leTvNeighborhoodMajorityVotingIsolThresPixTest COMMAND otbMajorityVotingTestDriver otbNeighborhoodMajorityVotingImageFilterIsolatedTest ) otb_add_test(NAME leTvSVMImageClassificationFilterWithNeighborhoodMajorityVoting COMMAND otbMajorityVotingTestDriver --compare-image ${NOTOL} ${BASELINE}/leSVMImageClassificationWithNMVFilterOutput.tif ${TEMP}/leSVMImageClassificationWithNMVFilterOutput.tif otbNeighborhoodMajorityVotingImageFilterTest ${BASELINE}/leSVMImageClassificationFilterOutput.tif ${TEMP}/leSVMImageClassificationWithNMVFilterOutput.tif false ) OTB-release-5.8/Modules/Fusion/MajorityVoting/test/otbMajorityVotingTestDriver.cxx000066400000000000000000000003661301006202600304740ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbNeighborhoodMajorityVotingImageFilterNew); REGISTER_TEST(otbNeighborhoodMajorityVotingImageFilterTest); REGISTER_TEST(otbNeighborhoodMajorityVotingImageFilterIsolatedTest); } OTB-release-5.8/Modules/Fusion/MajorityVoting/test/otbNeighborhoodMajorityVotingImageFilterNew.cxx000066400000000000000000000044751301006202600336000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbNeighborhoodMajorityVotingImageFilter.h" int otbNeighborhoodMajorityVotingImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputLabelPixelType; // 8 bits typedef unsigned short OutputLabelPixelType; // 16 bits const unsigned int Dimension = 2; typedef otb::Image InputLabelImageType; typedef otb::Image OutputLabelImageType; // Binary ball Structuring Element type typedef itk::BinaryBallStructuringElement BallStructuringType; // Neighborhood majority voting filter types typedef otb::NeighborhoodMajorityVotingImageFilter NeighborhoodMajorityVotingFilter3ArgsType; typedef otb::NeighborhoodMajorityVotingImageFilter NeighborhoodMajorityVotingFilter2ArgsType; typedef otb::NeighborhoodMajorityVotingImageFilter NeighborhoodMajorityVotingFilter1ArgType; // Neighborhood majority voting filters NeighborhoodMajorityVotingFilter3ArgsType::Pointer NeighMajVotingFilter3Args = NeighborhoodMajorityVotingFilter3ArgsType::New(); NeighborhoodMajorityVotingFilter2ArgsType::Pointer NeighMajVotingFilter2Args = NeighborhoodMajorityVotingFilter2ArgsType::New(); NeighborhoodMajorityVotingFilter1ArgType::Pointer NeighMajVotingFilter1Arg = NeighborhoodMajorityVotingFilter1ArgType::New(); std::cout << NeighMajVotingFilter3Args << std::endl; std::cout << std::endl; std::cout << NeighMajVotingFilter2Args << std::endl; std::cout << std::endl; std::cout << NeighMajVotingFilter1Arg << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/MajorityVoting/test/otbNeighborhoodMajorityVotingImageFilterTest.cxx000066400000000000000000000127741301006202600337670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include #include "otbImageFileWriter.h" #include "otbNeighborhoodMajorityVotingImageFilter.h" #include "itkTimeProbe.h" int otbNeighborhoodMajorityVotingImageFilterTest(int argc, char* argv[]) { typedef unsigned char IOLabelPixelType; // 8 bits const unsigned int Dimension = 2; typedef otb::Image IOLabelImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Neighborhood majority voting filter type typedef otb::NeighborhoodMajorityVotingImageFilter NeighborhoodMajorityVotingFilterType; // Binary ball Structuring Element type typedef NeighborhoodMajorityVotingFilterType::KernelType StructuringType; typedef StructuringType::RadiusType RadiusType; const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Neighborhood majority voting filter NeighborhoodMajorityVotingFilterType::Pointer NeighMajVotingFilter; NeighMajVotingFilter = NeighborhoodMajorityVotingFilterType::New(); NeighMajVotingFilter->SetInput(reader->GetOutput()); StructuringType seBall; RadiusType rad; std::string KeepOriginalLabelBoolStr = argv[3]; if (KeepOriginalLabelBoolStr.compare("true") == 0) { NeighMajVotingFilter->SetKeepOriginalLabelBool(true); } else { NeighMajVotingFilter->SetKeepOriginalLabelBool(false); } if (argc >= 5) { rad[0] = atoi(argv[4]); rad[1] = atoi(argv[5]); if (argc >= 6) { NeighMajVotingFilter->SetLabelForNoDataPixels(atoi(argv[6])); if (argc >= 7) { NeighMajVotingFilter->SetLabelForUndecidedPixels(atoi(argv[7])); } } } else { rad[0] = 1; rad[1] = 1; } seBall.SetRadius(rad); seBall.CreateStructuringElement(); NeighMajVotingFilter->SetKernel(seBall); if(argc==9) { NeighMajVotingFilter->SetOnlyIsolatedPixels(static_cast(atoi(argv[8]))); } WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(NeighMajVotingFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbNeighborhoodMajorityVotingImageFilterIsolatedTest(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef unsigned char PixelType; // 8 bits const unsigned int Dimension = 2; typedef otb::Image ImageType; ImageType::Pointer image = ImageType::New(); ImageType::IndexType start; start[0] = 0; start[1] = 0; ImageType::SizeType size; size[0] = 100; size[1] = 100; ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); image->SetRegions(region); image->Allocate(); image->FillBuffer(itk::NumericTraits::Zero); // Neighborhood majority voting filter type typedef otb::NeighborhoodMajorityVotingImageFilter NeighborhoodMajorityVotingFilterType; // Binary ball Structuring Element type typedef NeighborhoodMajorityVotingFilterType::KernelType StructuringType; typedef StructuringType::RadiusType RadiusType; // Neighborhood majority voting filter NeighborhoodMajorityVotingFilterType::Pointer NeighMajVotingFilter; NeighMajVotingFilter = NeighborhoodMajorityVotingFilterType::New(); NeighMajVotingFilter->SetInput(image); StructuringType seBall; RadiusType rad; NeighMajVotingFilter->SetKeepOriginalLabelBool(true); rad[0] = 1; rad[1] = 1; NeighMajVotingFilter->SetLabelForNoDataPixels(10); NeighMajVotingFilter->SetLabelForUndecidedPixels(7); seBall.SetRadius(rad); seBall.CreateStructuringElement(); NeighMajVotingFilter->SetKernel(seBall); NeighMajVotingFilter->SetOnlyIsolatedPixels(true); PixelType value = 255; ImageType::IndexType coordinate; coordinate[0] = 10; coordinate[1] = 10; image->SetPixel(coordinate, value); image->Update(); NeighMajVotingFilter->SetIsolatedThreshold(1); NeighMajVotingFilter->Update(); PixelType result = NeighMajVotingFilter->GetOutput()->GetPixel(coordinate); //Should be filtered if(result == value) { std::cout << "one pixel\n"; return EXIT_FAILURE; } coordinate[0] = 10; coordinate[1] = 11; image->SetPixel(coordinate, value); image->Update(); NeighMajVotingFilter->Modified(); //needed for the filter to be updated NeighMajVotingFilter->Update(); result = NeighMajVotingFilter->GetOutput()->GetPixel(coordinate); // Should not be filtered if( result != value) { std::cout << "2 pixels thres = 1 result = " << int(result) << '\n'; return EXIT_FAILURE; } NeighMajVotingFilter->SetIsolatedThreshold(3); NeighMajVotingFilter->Update(); result = NeighMajVotingFilter->GetOutput()->GetPixel(coordinate); //Should be filtered if(result == value) { std::cout << "2 pixels thres = 2" << '\n'; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/PanSharpening/000077500000000000000000000000001301006202600210265ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/PanSharpening/CMakeLists.txt000066400000000000000000000000541301006202600235650ustar00rootroot00000000000000project(OTBPanSharpening) otb_module_impl() OTB-release-5.8/Modules/Fusion/PanSharpening/include/000077500000000000000000000000001301006202600224515ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/PanSharpening/include/otbBayesianFusionFilter.h000066400000000000000000000247031301006202600274220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This code is from a Julien Radoux contribution. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBayesianFusionFilter_h #define otbBayesianFusionFilter_h #include "itkImageToImageFilter.h" #include "otbVectorImage.h" #include "otbStreamingStatisticsVectorImageFilter.h" #include "otbFusionImageBase.h" #include "otbStreamingMatrixTransposeMatrixImageFilter.h" #include "otbImageToVectorImageCastFilter.h" namespace otb { namespace Functor { /** \class BayesianFunctor * \brief Functor for the bayesian fusion filter. Please refer to BayesianFusionFilter. * * * \ingroup OTBPanSharpening */ template class BayesianFunctor { public: BayesianFunctor() {} virtual ~BayesianFunctor() {} typedef typename TInputMultiSpectral::RealValueType RealType; typedef typename itk::VariableSizeMatrix MatrixType; void SetLambda(float lambda) { m_Lambda = lambda; } void SetS(float S) { m_S = S; } void SetAlpha(float alpha) { m_Alpha = alpha; } void SetBeta(MatrixType matrix) { m_Beta = matrix; } void SetCovarianceInvMatrix(MatrixType matrix) { m_CovarianceInvMatrix = matrix; } void SetVcondopt(MatrixType matrix) { m_Vcondopt = matrix; } float GetLambda() { return m_Lambda; } float GetAlpha() { return m_Alpha; } float GetS() { return m_S; } MatrixType GetBeta() { return m_Beta; } MatrixType GetCovarianceInvMatrix() { return m_CovarianceInvMatrix; } MatrixType GetVcondopt() { return m_Vcondopt; } inline TOutput operator ()(const TInputMultiSpectral& itkNotUsed(ms), const TInputMultiSpectralInterp& msi, const TInputPanchro& p) { TOutput obs; obs.SetSize(msi.GetSize()); MatrixType obsMat, msiVect; obsMat.SetSize(1, obs.GetSize()); msiVect.SetSize(1, msi.GetSize()); for (unsigned int i = 0; i < msi.GetSize(); ++i) { msiVect(0, i) = msi[i]; } obsMat = msiVect * m_CovarianceInvMatrix; obsMat *= 2 * (1 - m_Lambda); MatrixType PanVect; PanVect = m_Beta.GetTranspose(); PanVect *= (p - m_Alpha); PanVect /= m_S; PanVect *= 2 * m_Lambda; /** TODO * To modify using + method operator. If we use it now -> exceptionmacro (no GetClassName...) * obsMat += PanVect; **/ if ((obsMat.Cols() != PanVect.Cols()) || (obsMat.Rows() != PanVect.Rows())) { itkGenericExceptionMacro(<< "Matrix with size (" << obsMat.Rows() << "," << obsMat.Cols() << ") cannot be subtracted from matrix with size (" << PanVect.Rows() << "," << PanVect.Cols() << " )"); } for (unsigned int r = 0; r < obsMat.Rows(); ++r) { for (unsigned int c = 0; c < obsMat.Cols(); ++c) { obsMat(r, c) += PanVect(r, c); } } //**** END TODO ****/ obsMat *= m_Vcondopt; for (unsigned int i = 0; i < obs.GetSize(); ++i) { obs[i] = static_cast(obsMat(0U, i)); } return obs; } private: float m_Lambda; float m_S; float m_Alpha; MatrixType m_CovarianceInvMatrix; MatrixType m_Beta; MatrixType m_Vcondopt; }; } /***** TODO *** * Complete the description with J. Radoux text */ /***** END TODO ***/ /** \class BayesianFusionFilter * \brief Bayesian fusion filter. Contribution of Julien Radoux * * Please refer to D. Fasbender, J. Radoux and P. Bogaert, * Bayesian Data Fusion for Adaptable Image Pansharpening, * Transactions on Geoscience and Remote Sensing, * vol. 46, n. 6, 2007, pp 1847-1857 * * \sa FusionImageBase * \sa MatrixTransposeMatrix * \sa StreamingStatisticsVectorImageFilter * \ingroup Streamed * \ingroup Multithreaded * \ingroup MathematicalStatisticsImageFilters * * \ingroup Fusion * * * \example Fusion/BayesianFusionImageFilter.cxx * * * * \ingroup OTBPanSharpening */ template class ITK_EXPORT BayesianFusionFilter : public FusionImageBase > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputMultiSpectralImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputMultiSpectralImage InputMultiSpectralImageType; typedef TInputMultiSpectralInterpImage InputMultiSpectralInterpImageType; typedef TInputPanchroImage InputPanchroImageType; typedef TOutputImage OutputImageType; /** "typedef" for standard classes. */ typedef BayesianFusionFilter Self; typedef FusionImageBase > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(BayesianFusionFilter, FusionImageBase); /** Supported images definition. */ typedef typename InputMultiSpectralImageType::PixelType InputMultiSpectralPixelType; typedef typename InputMultiSpectralImageType::InternalPixelType InputMultiSpectralInternalPixelType; typedef typename InputMultiSpectralInterpImageType::PixelType InputMultiSpectralInterpPixelType; typedef typename InputMultiSpectralInterpImageType::InternalPixelType InputMultiSpectralInterpInternalPixelType; typedef typename InputPanchroImageType::PixelType InputPanchroPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; /** Real class typedef definition. */ typedef typename itk::NumericTraits::RealType InputPanchroRealType; typedef typename itk::NumericTraits::RealType InputMultiSpectralRealType; typedef typename InputMultiSpectralImageType::RegionType InputMultiSpectralImageRegionType; typedef typename itk::NumericTraits::RealType InputMultiSpectralInterpRealType; typedef typename InputMultiSpectralInterpImageType::RegionType InputMultiSpectralInterpImageRegionType; typedef typename InputPanchroImageType::RegionType InputPanchroImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Image size "typedef" definition. */ typedef typename InputMultiSpectralImageType::SizeType SizeType; /** Typedef for statistic computing. */ typedef StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef typename StreamingStatisticsVectorImageFilterType::MatrixType MatrixType; typedef StreamingMatrixTransposeMatrixImageFilter MSTransposeMSType; typedef ImageToVectorImageCastFilter CasterType; /** Set the ponderation value. */ itkSetMacro(Lambda, float); /** Give the ponderation value. */ itkGetConstReferenceMacro(Lambda, float); /** Set the Beta matrix. */ itkSetMacro(Beta, MatrixType); /** Give the Beta matrix. */ itkGetConstReferenceMacro(Beta, MatrixType); /** Set the Covariance matrix. */ itkSetMacro(CovarianceMatrix, MatrixType); /** Give the Covariance matrix. */ itkGetConstReferenceMacro(CovarianceMatrix, MatrixType); /** Set the Covariance inverse matrix. */ itkSetMacro(CovarianceInvMatrix, MatrixType); /** Give the Covariance inverse matrix. */ itkGetConstReferenceMacro(CovarianceInvMatrix, MatrixType); /** Set the Bayesian Data Fusion matrix. */ itkSetMacro(Vcondopt, MatrixType); /** Give the Bayesian Data Fusion matrix. */ itkGetConstReferenceMacro(Vcondopt, MatrixType); /** Set the S coefficient. */ itkSetMacro(S, float); /** Give the S coefficient. */ itkGetConstReferenceMacro(S, float); protected: BayesianFusionFilter(); ~BayesianFusionFilter() ITK_OVERRIDE; /** Check if internal statistics need to be computed, and do so */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Compute internal statistics required for fusion */ void ComputeInternalStatistics(void); /** Call the superclass implementation and set the StatisticsHaveBeenGenerated * flag to false */ void Modified(void) const ITK_OVERRIDE; private: /** Ponderation declaration*/ float m_Lambda; float m_S; /** Multispectral covariance matrix */ MatrixType m_CovarianceMatrix; /** Multispectral inverse covariance matrix */ MatrixType m_CovarianceInvMatrix; /** Regression coefficients matrix */ MatrixType m_Beta; /** Optimisation matrix */ MatrixType m_Vcondopt; /** True if internal statistics have been generated */ mutable bool m_StatisticsHaveBeenGenerated; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBayesianFusionFilter.txx" #endif #endif OTB-release-5.8/Modules/Fusion/PanSharpening/include/otbBayesianFusionFilter.txx000066400000000000000000000273131301006202600300160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBayesianFusionFilter_txx #define otbBayesianFusionFilter_txx #include "otbBayesianFusionFilter.h" namespace otb { template BayesianFusionFilter ::BayesianFusionFilter() { m_Lambda = 0.9999; m_S = 1; m_StatisticsHaveBeenGenerated = false; } template BayesianFusionFilter ::~BayesianFusionFilter() { } template void BayesianFusionFilter ::Modified() const { Superclass::Modified(); m_StatisticsHaveBeenGenerated = false; } template void BayesianFusionFilter ::BeforeThreadedGenerateData() { if (!m_StatisticsHaveBeenGenerated) { this->ComputeInternalStatistics(); m_StatisticsHaveBeenGenerated = true; } } template void BayesianFusionFilter ::ComputeInternalStatistics() { OutputImageRegionType msiRequestedRegion = this->GetMultiSpectInterp()->GetRequestedRegion(); OutputImageRegionType msRequestedRegion = this->GetMultiSpect()->GetRequestedRegion(); OutputImageRegionType panchroRequestedRegion = this->GetPanchro()->GetRequestedRegion(); // Allocate output typename OutputImageType::Pointer output = this->GetOutput(); typename InputMultiSpectralImageType::Pointer multiSpec = const_cast( this->GetMultiSpect()); typename InputMultiSpectralInterpImageType::Pointer multiSpecInterp = const_cast( this->GetMultiSpectInterp()); typename InputPanchroImageType::Pointer panchro = const_cast( this->GetPanchro()); /** Variable Initialisaton */ m_Beta.SetSize(multiSpecInterp->GetNumberOfComponentsPerPixel() + 1, 1); m_Beta.Fill(itk::NumericTraits::Zero); m_CovarianceMatrix.SetSize( multiSpecInterp->GetNumberOfComponentsPerPixel(), multiSpecInterp->GetNumberOfComponentsPerPixel()); m_CovarianceMatrix.Fill(itk::NumericTraits::Zero); m_CovarianceInvMatrix.SetSize( multiSpecInterp->GetNumberOfComponentsPerPixel(), multiSpecInterp->GetNumberOfComponentsPerPixel()); m_CovarianceInvMatrix.Fill(itk::NumericTraits::Zero); m_Vcondopt.SetSize(multiSpecInterp->GetNumberOfComponentsPerPixel(), multiSpecInterp->GetNumberOfComponentsPerPixel()); m_Vcondopt.Fill(itk::NumericTraits::Zero); /** Compute the inverse of the multispectral interpolated image covariance matrix */ typename StreamingStatisticsVectorImageFilterType::Pointer covComputefilter = StreamingStatisticsVectorImageFilterType::New(); covComputefilter->SetInput(multiSpecInterp); covComputefilter->Update(); m_CovarianceMatrix = covComputefilter->GetCovariance(); otbMsgDebugMacro(<< "Covariance: " << m_CovarianceMatrix); m_CovarianceInvMatrix = m_CovarianceMatrix.GetInverse(); /** Beta computation : Regression model coefficient */ // MatrixTransform only support vectorimage input typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(panchro); // caster->Update(); // Compute the transpose multispectral image multiplied by itself typename MSTransposeMSType::Pointer msTransposeMs = MSTransposeMSType::New(); // Compute the transpose multispectral image multiplied by the panchromatic one typename MSTransposeMSType::Pointer msTransposePan = MSTransposeMSType::New(); // Add a dimension filled with ones to the images msTransposeMs->SetUsePadFirstInput(true); msTransposeMs->SetUsePadSecondInput(true); msTransposePan->SetUsePadFirstInput(true); msTransposeMs->SetFirstInput(multiSpec); msTransposeMs->SetSecondInput(multiSpec); msTransposePan->SetFirstInput(multiSpec); msTransposePan->SetSecondInput(caster->GetOutput()); msTransposeMs->Update(); otbMsgDebugMacro(<< "MsTMs: " << msTransposeMs->GetResultOutput()->Get()); msTransposePan->Update(); otbMsgDebugMacro(<< "MsTPan: " << msTransposePan->GetResultOutput()->Get()); MatrixType temp; temp = msTransposeMs->GetResultOutput()->Get().GetInverse(); m_Beta = temp * msTransposePan->GetResultOutput()->Get(); // S computation : quadratique mean of the regression residue // Compute the transpose panchromatic image multiplied by itself typename MSTransposeMSType::Pointer panTransposePan = MSTransposeMSType::New(); panTransposePan->SetFirstInput(caster->GetOutput()); panTransposePan->SetSecondInput(caster->GetOutput()); panTransposePan->Update(); otbMsgDebugMacro(<< "PanTPan: " << msTransposePan->GetResultOutput()->Get()); MatrixType S, tempS, tempS2; S = panTransposePan->GetResultOutput()->Get(); tempS = msTransposePan->GetResultOutput()->Get().GetTranspose(); tempS = tempS * m_Beta; /** TODO * To modify using - method operator. If we use it now -> exceptionmacro (no GetClassName...) * S = S-tempS; **/ if ((S.Rows() != tempS.Rows()) || (S.Cols() != tempS.Cols())) { itkExceptionMacro(<< "Matrix with size (" << S.Rows() << "," << S.Cols() << ") cannot be subtracted from matrix with size (" << tempS.Rows() << "," << tempS.Cols() << " )"); } for (unsigned int r = 0; r < S.Rows(); ++r) { for (unsigned int c = 0; c < S.Cols(); ++c) { S(r, c) -= tempS(r, c); } } //**** END TODO ****/ tempS = m_Beta.GetTranspose(); tempS2 = msTransposePan->GetResultOutput()->Get(); tempS = tempS * tempS2; /** TODO * To modify using - method operator. If we use it now -> exceptionmacro (no GetClassName...) * S = S-tempS; **/ if ((S.Rows() != tempS.Rows()) || (S.Cols() != tempS.Cols())) { itkExceptionMacro(<< "Matrix with size (" << S.Rows() << "," << S.Cols() << ") cannot be subtracted from matrix with size (" << tempS.Rows() << "," << tempS.Cols() << " )"); } for (unsigned int r = 0; r < S.Rows(); ++r) { for (unsigned int c = 0; c < S.Cols(); ++c) { S(r, c) -= tempS(r, c); } } //**** END TODO ****/ MatrixType xxT, xxTb, xxTbT, xxTbTb; xxT = msTransposeMs->GetResultOutput()->Get().GetTranspose(); xxTb = xxT * m_Beta; xxTbT = xxTb.GetTranspose(); xxTbTb = xxTbT * m_Beta; /** TODO * To modify using - method operator. If we use it now -> exceptionmacro (no GetClassName...) * S = S-xxTbTb; **/ if ((S.Rows() != xxTbTb.Rows()) || (S.Cols() != xxTbTb.Cols())) { itkExceptionMacro(<< "Matrix with size (" << S.Rows() << "," << S.Cols() << ") cannot be subtracted from matrix with size (" << xxTbTb.Rows() << "," << xxTbTb.Cols() << " )"); } for (unsigned int r = 0; r < S.Rows(); ++r) { for (unsigned int c = 0; c < S.Cols(); ++c) { S(r, c) += xxTbTb(r, c); } } //**** END TODO ****/ unsigned int size1 = multiSpec->GetLargestPossibleRegion().GetSize()[0] * multiSpec->GetLargestPossibleRegion().GetSize()[1]; unsigned int size2 = multiSpec->GetNumberOfComponentsPerPixel() + 1; m_S = S(0, 0); m_S /= static_cast(size1 - size2); // cutBeta is the N-1 last m_Beta element matrix. // varPan contains transpose(cutBeta)*cutBeta/S MatrixType varPan, cutBeta; varPan.SetSize(multiSpecInterp->GetNumberOfComponentsPerPixel(), 1); varPan.Fill(itk::NumericTraits::Zero); cutBeta.SetSize(multiSpecInterp->GetNumberOfComponentsPerPixel(), 1); cutBeta.Fill(itk::NumericTraits::Zero); // Take the N-1 m_Beta last elements for (unsigned int r = 1; r < m_Beta.Rows(); ++r) { cutBeta(r - 1, 0) = m_Beta(r, 0); } varPan = cutBeta; MatrixType tempvarPan; tempvarPan = varPan.GetTranspose(); varPan *= tempvarPan; varPan /= m_S; // Compute the optimization matrix : m_Vcondopt // eye is the identical matrix which size is the number of components of the multispectral image MatrixType eye; eye.SetSize(multiSpecInterp->GetNumberOfComponentsPerPixel(), multiSpecInterp->GetNumberOfComponentsPerPixel()); eye.Fill(itk::NumericTraits::Zero); for (unsigned int r = 1; r < eye.Rows(); ++r) { eye(r, r) = vcl_pow(10., -12.); } /** TODO * To modify using + method operator. If we use it now -> exceptionmacro (no GetClassName...) * m_Vcondopt = 2 *m_Lambda*varPan+2*m_CovarianceInvMatrix*(1-m_Lambda)+eye; **/ if ((m_Vcondopt.Rows() != varPan.Rows()) || (m_Vcondopt.Cols() != varPan.Cols()) || (m_Vcondopt.Rows() != m_CovarianceInvMatrix.Rows()) || (m_Vcondopt.Cols() != m_CovarianceInvMatrix.Cols())) { itkExceptionMacro(<< "Matrix with size (" << m_Vcondopt.Rows() << "," << m_Vcondopt.Cols() << ") cannot be subtracted from matrix with size (" << varPan.Rows() << "," << varPan.Cols() << " ) or ( " << m_CovarianceInvMatrix.Rows() << "," << m_CovarianceInvMatrix.Cols() << ")"); } for (unsigned int r = 0; r < m_Vcondopt.Rows(); ++r) { for (unsigned int c = 0; c < m_Vcondopt.Cols(); ++c) { m_Vcondopt(r, c) = 2 *m_Lambda*varPan(r, c) + 2 * m_CovarianceInvMatrix(r, c) * (1 - m_Lambda) + eye(r, c); } } //**** END TODO ****/ m_Vcondopt = m_Vcondopt.GetInverse(); // Functor initialization this->GetFunctor().SetVcondopt(m_Vcondopt); this->GetFunctor().SetBeta(cutBeta); this->GetFunctor().SetAlpha(m_Beta(0, 0)); this->GetFunctor().SetCovarianceInvMatrix(m_CovarianceInvMatrix); this->GetFunctor().SetLambda(m_Lambda); this->GetFunctor().SetS(m_S); // Restore the previous buffered data multiSpecInterp->SetRequestedRegion(msiRequestedRegion); multiSpecInterp->PropagateRequestedRegion(); multiSpecInterp->UpdateOutputData(); multiSpec->SetRequestedRegion(msRequestedRegion); multiSpec->PropagateRequestedRegion(); multiSpec->UpdateOutputData(); panchro->SetRequestedRegion(panchroRequestedRegion); panchro->PropagateRequestedRegion(); panchro->UpdateOutputData(); } } // end namespace otb #endif OTB-release-5.8/Modules/Fusion/PanSharpening/include/otbFusionImageBase.h000066400000000000000000000112101301006202600263230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFusionImageBase_h #define otbFusionImageBase_h #include "itkTernaryFunctorImageFilter.h" #include "itkNumericTraits.h" namespace otb { /** \class FusionImageBase * Basic class for every Fusion classes. * \sa TernaryFunctorImageFilter * * \ingroup OTBPanSharpening */ template class ITK_EXPORT FusionImageBase : public itk::TernaryFunctorImageFilter { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputMultiSpectralImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputMultiSpectralImage InputMultiSpectralImageType; typedef TInputMultiSpectralInterpImage InputMultiSpectralInterpImageType; typedef TInputPanchroImage InputPanchroImageType; typedef TOutputImage OutputImageType; typedef TFunctor FunctorType; /** "typedef" for standard classes. */ typedef FusionImageBase Self; typedef itk::TernaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(FusionImageBase, TernaryFunctorImageFilter); /** Supported images definition. */ typedef typename InputMultiSpectralImageType::PixelType InputMultiSpectralPixelType; typedef typename InputMultiSpectralInterpImageType::PixelType InputMultiSpectralInterpPixelType; typedef typename InputPanchroImageType::PixelType InputPanchroPixelType; typedef typename OutputImageType::PixelType OutputPixelType; /** Real class typedef definition. */ typedef typename itk::NumericTraits::RealType InputMultiSpectralRealType; typedef typename itk::NumericTraits::RealType InputMultiSpectralInterpRealType; typedef typename itk::NumericTraits::RealType InputPanchroRealType; typedef typename InputMultiSpectralImageType::RegionType InputMultiSpectralImageRegionType; typedef typename InputMultiSpectralInterpImageType::RegionType InputMultiSpectralInterpImageRegionType; typedef typename InputPanchroImageType::RegionType InputPanchroImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Image size "typedef" definition. */ typedef typename InputMultiSpectralImageType::SizeType SizeType; void SetMultiSpect(const InputMultiSpectralImageType *multiSpect) { this->SetInput1(multiSpect); } void SetMultiSpectInterp(const InputMultiSpectralInterpImageType *multiSpectInterp) { this->SetInput2(multiSpectInterp); } void SetPanchro(const InputPanchroImageType *panchro) { this->SetInput3(panchro); } const InputMultiSpectralImageType* GetMultiSpect() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } else return (static_cast(this->itk::ProcessObject::GetInput(0))); } const InputMultiSpectralInterpImageType* GetMultiSpectInterp() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } else return (static_cast(this->itk::ProcessObject::GetInput(1))); } const InputPanchroImageType* GetPanchro() { if (this->GetNumberOfInputs() < 3) { return ITK_NULLPTR; } else return (static_cast(this->itk::ProcessObject::GetInput(2))); } }; } // end namespace otb #endif OTB-release-5.8/Modules/Fusion/PanSharpening/include/otbLmvmPanSharpeningFusionImageFilter.h000066400000000000000000000232161301006202600322210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLmvmPanSharpeningFusionImageFilter_h #define otbLmvmPanSharpeningFusionImageFilter_h #include "otbConvolutionImageFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkTernaryFunctorImageFilter.h" #include "otbPerBandVectorImageFilter.h" #include "itkNoiseImageFilter.h" #include "otbVectorImage.h" #include "itkProgressAccumulator.h" namespace otb { /** * \class LmvmPanSharpeningFusionImageFilter * \brief This class performs a Local Mean and Variance Matching (LMVM) Pan sharpening operation * * Given a Pan image and the corresponding Xs image (oversampled to have the * same number of pixels), this filter realizes an Local Mean and Variance * Matching Pan sharpening operation as described in: * * de Bethune, S. and Muller, F. and Donnay, J.P. 1998. Fusion of multispectral and panchromatic images * by local mean and variance matching filtering techniques. Fusion of Earth Data, 28-30 August 1998. * * \ingroup Streamed * \ingroup Multithreaded * \ingroup Fusion * * * * \ingroup OTBPanSharpening **/ template class ITK_EXPORT LmvmPanSharpeningFusionImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs */ typedef LmvmPanSharpeningFusionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Internal image type used as Pan smoothing and local standard deviation filter output */ typedef otb::Image InternalImageType; /** Single band Xs image type */ typedef typename TXsImageType::InternalPixelType XsPixelType; typedef otb::Image XsBandImageType; /** Internal image type used as Xs smoothing and local standard deviation filter output */ typedef otb::VectorImage InternalVectorImageType; /** Typedef for the radius of the smoothing and local standard deviation filter */ typedef typename itk::Array ArrayType; /** Method for creation through object factory */ itkNewMacro(Self); /** Run-time type information */ itkTypeMacro(LmvmPanSharpeningFusionImageFilter, itk::ImageToImageFilter); /** Define the radius type for the smoothing and local standard deviation operation */ typedef typename InternalImageType::SizeType RadiusType; /** Set the smoothing and local standard deviation filter radius */ itkGetMacro(Radius, RadiusType); itkSetMacro(Radius, RadiusType); /** Set the kernel used for the smoothing and local standard deviation filter */ itkSetMacro(Filter, ArrayType); itkGetConstReferenceMacro(Filter, ArrayType); virtual void SetPanInput(const TPanImageType * image); const TPanImageType * GetPanInput(void) const; virtual void SetXsInput(const TXsImageType * path); const TXsImageType * GetXsInput(void) const; protected: /** Constructor */ LmvmPanSharpeningFusionImageFilter(); /** Destructor */ ~LmvmPanSharpeningFusionImageFilter() ITK_OVERRIDE {}; /** Call to generate data, wiring composite internal minipipeline */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LmvmPanSharpeningFusionImageFilter(Self &); // intentionally not implemented void operator =(const Self&); // intentionally not implemented /** \class FusionFunctor1 * This functor applies the LMVM * operation. It is intended for internal use only. * * \ingroup OTBPanSharpening */ class FusionFunctor1 { public: // Implement the fusion as a six arguments operator typename TOutputImageType::PixelType operator()( const typename InternalVectorImageType::PixelType& stdXsPixel, const TInternalPrecision& smoothPanchroPixel, const typename TPanImageType::PixelType& sharpPanchroPixel) const { // Build output pixel typename TOutputImageType::PixelType output(stdXsPixel.Size()); // Perform fusion for each band with appropriate casting for(unsigned int i = 0; i < stdXsPixel.Size(); ++i) { output[i] = static_cast( ((sharpPanchroPixel - smoothPanchroPixel) * stdXsPixel[i])); } // Returns the output pixel return output; } }; class FusionFunctor2 { public: // Implement the fusion as a six arguments operator typename TOutputImageType::PixelType operator()(const typename TOutputImageType::PixelType& functor1Pixel, const typename InternalVectorImageType::PixelType& smoothXsPixel, const TInternalPrecision& stdPanchroPixel) const { // Build output pixel typename TOutputImageType::PixelType output(smoothXsPixel.Size()); TInternalPrecision scale = 1.; if(vcl_abs(stdPanchroPixel) > 1e-10) { scale = 1.0/stdPanchroPixel; } // Perform fusion for each band with appropriate casting for(unsigned int i = 0; i < smoothXsPixel.Size(); ++i) { output[i] = static_cast( ((functor1Pixel[i] * scale) + smoothXsPixel[i])); } // Returns the output pixel return output; } }; /** * Typedef of the TernaryFunctorImageFilter applying the fusion functor to * p, p_smooth, p_std, xs_smooth, xs_std and xs. */ typedef itk::TernaryFunctorImageFilter FusionStep1FilterType; /** Pointer to the fusion filter */ typename FusionStep1FilterType::Pointer m_FusionStep1Filter; typedef itk::TernaryFunctorImageFilter FusionStep2FilterType; /** Pointer to the fusion filter */ typename FusionStep2FilterType::Pointer m_FusionStep2Filter; /** Typedef of the convolution filter performing Pan smoothing */ typedef otb::ConvolutionImageFilter , TInternalPrecision> PanConvolutionFilterType; /** Pointer to the internal Pan convolution filter */ typename PanConvolutionFilterType::Pointer m_PanConvolutionFilter; /** Typedef of the convolution filter performing Xs smoothing */ typedef otb::ConvolutionImageFilter , TInternalPrecision> XsConvolutionFilterType; /** Pointer to the internal Xs convolution filter */ typename XsConvolutionFilterType::Pointer m_XsConvolutionFilter; /** Typedef of the Pan local standard deviation filter*/ typedef itk::NoiseImageFilter PanNoiseFilterType; /** Pointer to the Pan local standard deviation filter */ typename PanNoiseFilterType::Pointer m_PanNoiseFilter; /** Typedef of the Xs local standard deviation filter*/ typedef itk::NoiseImageFilter XsNoiseFilterType; /** Pointer to the Xs local standard deviation filter */ typename XsNoiseFilterType::Pointer m_XsNoiseFilter; /** Typedef of a helper filter to apply to a vector image*/ typedef otb::PerBandVectorImageFilter < TXsImageType, InternalVectorImageType, XsConvolutionFilterType> XsVectorConvolutionFilterType; /** Pointer to the helper vector image filter */ typename XsVectorConvolutionFilterType::Pointer m_XsVectorConvolutionFilter; /** Typedef of a helper filter to apply to a vector image*/ typedef otb::PerBandVectorImageFilter < TXsImageType, InternalVectorImageType, XsNoiseFilterType> XsVectorNoiseFilterType; /** Pointer to the helper vector image filter */ typename XsVectorNoiseFilterType::Pointer m_XsVectorNoiseFilter; /** Radius used for the smoothing filter */ RadiusType m_Radius; /** Kernel used for the smoothing filter */ ArrayType m_Filter; /** The internal progress accumulator */ typename itk::ProgressAccumulator::Pointer m_ProgressAccumulator; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLmvmPanSharpeningFusionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Fusion/PanSharpening/include/otbLmvmPanSharpeningFusionImageFilter.txx000066400000000000000000000150621301006202600326150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLmvmPanSharpeningFusionImageFilter_txx #define otbLmvmPanSharpeningFusionImageFilter_txx #include "otbLmvmPanSharpeningFusionImageFilter.h" namespace otb { template LmvmPanSharpeningFusionImageFilter ::LmvmPanSharpeningFusionImageFilter() { // Fix number of required inputs this->SetNumberOfRequiredInputs(2); // Instantiate convolution filters m_PanConvolutionFilter = PanConvolutionFilterType::New(); m_PanConvolutionFilter->NormalizeFilterOn(); m_XsConvolutionFilter = XsConvolutionFilterType::New(); m_XsConvolutionFilter->NormalizeFilterOn(); m_PanNoiseFilter = PanNoiseFilterType::New(); m_XsNoiseFilter = XsNoiseFilterType::New(); m_XsVectorConvolutionFilter = XsVectorConvolutionFilterType::New(); m_XsVectorNoiseFilter = XsVectorNoiseFilterType::New(); // Set-up default parameters m_Radius.Fill(3); m_Filter.SetSize(7 * 7); m_Filter.Fill(1); // Instantiate fusion filter m_FusionStep1Filter = FusionStep1FilterType::New(); m_FusionStep2Filter = FusionStep2FilterType::New(); // Set-up progress reporting m_ProgressAccumulator = itk::ProgressAccumulator::New(); m_ProgressAccumulator->SetMiniPipelineFilter(this); m_ProgressAccumulator->RegisterInternalFilter(m_PanConvolutionFilter, 0.2); m_ProgressAccumulator->RegisterInternalFilter(m_PanNoiseFilter, 0.2); m_ProgressAccumulator->RegisterInternalFilter(m_XsVectorConvolutionFilter, 0.2); m_ProgressAccumulator->RegisterInternalFilter(m_XsVectorNoiseFilter, 0.2); m_ProgressAccumulator->RegisterInternalFilter(m_FusionStep1Filter, 0.1); m_ProgressAccumulator->RegisterInternalFilter(m_FusionStep2Filter, 0.1); } template void LmvmPanSharpeningFusionImageFilter ::SetPanInput(const TPanImageType *image) { // We have 2 inputs: an image and a vector image // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast(image)); this->Modified(); } template const TPanImageType * LmvmPanSharpeningFusionImageFilter ::GetPanInput(void) const { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1)); } template void LmvmPanSharpeningFusionImageFilter ::SetXsInput(const TXsImageType *image) { // We have 2 inputs: an image and a vector image // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(image)); this->Modified(); } template const TXsImageType * LmvmPanSharpeningFusionImageFilter ::GetXsInput(void) const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template void LmvmPanSharpeningFusionImageFilter ::GenerateData() { //Check if size is correct typename TPanImageType::SizeType sizePan; typename TXsImageType::SizeType sizeXs; sizePan = this->GetPanInput()->GetLargestPossibleRegion().GetSize(); sizeXs = this->GetXsInput()->GetLargestPossibleRegion().GetSize(); if ((sizePan[0] != sizeXs[0]) || (sizePan[1] != sizeXs[1])) { itkExceptionMacro(<< "LmvmPanSharpeningFusionImageFilter: Wrong Pan/Xs size"); } //Process the fusion m_PanConvolutionFilter->SetInput(this->GetPanInput()); m_PanConvolutionFilter->SetRadius(this->m_Radius); m_PanConvolutionFilter->SetFilter(this->m_Filter); m_PanNoiseFilter->SetRadius(this->m_Radius); m_PanNoiseFilter->SetInput(this->GetPanInput()); m_XsConvolutionFilter->SetRadius(this->m_Radius); m_XsConvolutionFilter->SetFilter(this->m_Filter); m_XsVectorConvolutionFilter->SetInput(this->GetXsInput()); m_XsVectorConvolutionFilter->SetFilter(m_XsConvolutionFilter); m_XsNoiseFilter->SetRadius(this->m_Radius); m_XsVectorNoiseFilter->SetInput(this->GetXsInput()); m_XsVectorNoiseFilter->SetFilter(m_XsNoiseFilter); m_FusionStep1Filter->SetInput1(m_XsVectorNoiseFilter->GetOutput()); m_FusionStep1Filter->SetInput2(m_PanConvolutionFilter->GetOutput()); m_FusionStep1Filter->SetInput3(this->GetPanInput()); m_FusionStep2Filter->SetInput1(m_FusionStep1Filter->GetOutput()); m_FusionStep2Filter->SetInput3(m_PanNoiseFilter->GetOutput()); m_FusionStep2Filter->SetInput2(m_XsVectorConvolutionFilter->GetOutput()); m_FusionStep2Filter->UpdateOutputInformation(); // Wire composite filter m_FusionStep2Filter->GraftOutput(this->GetOutput()); m_FusionStep2Filter->Update(); this->GraftOutput(m_FusionStep2Filter->GetOutput()); } template void LmvmPanSharpeningFusionImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius:" << this->m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Fusion/PanSharpening/include/otbSimpleRcsPanSharpeningFusionImageFilter.h000066400000000000000000000137321301006202600332110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimpleRcsPanSharpeningFusionImageFilter_h #define otbSimpleRcsPanSharpeningFusionImageFilter_h #include "otbConvolutionImageFilter.h" #include "otbImage.h" #include "itkTernaryFunctorImageFilter.h" #include "itkProgressAccumulator.h" namespace otb { /** * \class SimpleRcsPanSharpeningFusionImageFilter * \brief This class performs a simple Pan sharpening operation * * Given a Pan image and the corresponding Xs image (oversampled to have the * same number of pixels), this filter realizes a simple Pan sharpening * operation: * * \f[ \frac{XS}{\mathrm{Filtered}(PAN)} PAN \f] * * This filter supports streaming and multithreading. * * \ingroup OTBPanSharpening * * \example Fusion/PanSharpeningExample.cxx * */ template class ITK_EXPORT SimpleRcsPanSharpeningFusionImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs */ typedef SimpleRcsPanSharpeningFusionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Internal image type used as the smoothing filter output */ typedef otb::Image InternalImageType; /** Typedef for the radius of the smoothing filter */ typedef typename itk::Array ArrayType; /** Method for creation through object factory */ itkNewMacro(Self); /** Run-time type information */ itkTypeMacro(SimpleRcsPanSharpeningFusionImageFilter, itk::ImageToImageFilter); /** Define the radius type for the smoothing operation */ typedef typename InternalImageType::SizeType RadiusType; /** Set the smoothing filter radius */ itkGetMacro(Radius, RadiusType); itkSetMacro(Radius, RadiusType); /** Set the kernel used for the smoothing filter */ itkSetMacro(Filter, ArrayType); itkGetConstReferenceMacro(Filter, ArrayType); virtual void SetPanInput(const TPanImageType * image); const TPanImageType * GetPanInput(void) const; virtual void SetXsInput(const TXsImageType * path); const TXsImageType * GetXsInput(void) const; protected: /** Constructor */ SimpleRcsPanSharpeningFusionImageFilter(); /** Destructor */ ~SimpleRcsPanSharpeningFusionImageFilter() ITK_OVERRIDE {}; /** Call to generate data, wiring composite internal minipipeline */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SimpleRcsPanSharpeningFusionImageFilter(Self &); // intentionally not implemented void operator =(const Self&); // intentionally not implemented /** \class FusionFunctor * This functor applies the * \f[ \frac{XS}{\mathrm{Filtered}(PAN)}PAN \f] * operation. It is intended for internal use only. * * \ingroup OTBPanSharpening */ class FusionFunctor { public: // Implement the fusion as a three arguments operator typename TOutputImageType::PixelType operator()(const typename TXsImageType::PixelType& xsPixel, const TInternalPrecision& smoothPanchroPixel, const typename TPanImageType::PixelType& sharpPanchroPixel) const { // Build output pixel typename TOutputImageType::PixelType output(xsPixel.Size()); TInternalPrecision scale = 1.; if(vcl_abs(smoothPanchroPixel) > 1e-10) { scale = sharpPanchroPixel/smoothPanchroPixel; } // Perform fusion for each band with appropriate casting for(unsigned int i = 0; i < xsPixel.Size(); ++i) { output[i] = static_cast( xsPixel[i] * scale); } // Returns the output pixel return output; } }; /** * Typedef of the TernaryFunctorImageFilter applying the fusion functor to * p, p_smooth and xs. */ typedef itk::TernaryFunctorImageFilter FusionFilterType; /** Typedef of the convolution filter performing smoothing */ typedef otb::ConvolutionImageFilter , TInternalPrecision> ConvolutionFilterType; /** Pointer to the internal convolution filter */ typename ConvolutionFilterType::Pointer m_ConvolutionFilter; /** Pointer to the fusion filter */ typename FusionFilterType::Pointer m_FusionFilter; /** Radius used for the smoothing filter */ RadiusType m_Radius; /** Kernel used for the smoothing filter */ ArrayType m_Filter; /** The internal progress accumulator */ typename itk::ProgressAccumulator::Pointer m_ProgressAccumulator; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSimpleRcsPanSharpeningFusionImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Fusion/PanSharpening/include/otbSimpleRcsPanSharpeningFusionImageFilter.txx000066400000000000000000000122041301006202600335760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimpleRcsPanSharpeningFusionImageFilter_txx #define otbSimpleRcsPanSharpeningFusionImageFilter_txx #include "otbSimpleRcsPanSharpeningFusionImageFilter.h" namespace otb { template SimpleRcsPanSharpeningFusionImageFilter ::SimpleRcsPanSharpeningFusionImageFilter() { // Fix number of required inputs this->SetNumberOfRequiredInputs(2); // Instantiate convolution filter m_ConvolutionFilter = ConvolutionFilterType::New(); m_ConvolutionFilter->NormalizeFilterOn(); // Set-up default parameters m_Radius.Fill(3); m_Filter.SetSize(7 * 7); m_Filter.Fill(1); // Instantiate fusion filter m_FusionFilter = FusionFilterType::New(); m_FusionFilter->SetInput2(m_ConvolutionFilter->GetOutput()); // Set-up progress reporting m_ProgressAccumulator = itk::ProgressAccumulator::New(); m_ProgressAccumulator->SetMiniPipelineFilter(this); m_ProgressAccumulator->RegisterInternalFilter(m_ConvolutionFilter, 0.9); m_ProgressAccumulator->RegisterInternalFilter(m_FusionFilter, 0.1); } template void SimpleRcsPanSharpeningFusionImageFilter ::SetPanInput(const TPanImageType *image) { // We have 2 inputs: an image and a vector image // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast(image)); this->Modified(); } template const TPanImageType * SimpleRcsPanSharpeningFusionImageFilter ::GetPanInput(void) const { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1)); } template void SimpleRcsPanSharpeningFusionImageFilter ::SetXsInput(const TXsImageType *image) { // We have 2 inputs: an image and a vector image // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(image)); this->Modified(); } template const TXsImageType * SimpleRcsPanSharpeningFusionImageFilter ::GetXsInput(void) const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template void SimpleRcsPanSharpeningFusionImageFilter ::GenerateData() { //Check if size is correct typename TPanImageType::SizeType sizePan; typename TXsImageType::SizeType sizeXs; sizePan = this->GetPanInput()->GetLargestPossibleRegion().GetSize(); sizeXs = this->GetXsInput()->GetLargestPossibleRegion().GetSize(); if ((sizePan[0] != sizeXs[0]) || (sizePan[1] != sizeXs[1])) { itkExceptionMacro(<< "SimpleRcsPanSharpeningFusionImageFilter: Wrong Pan/Xs size"); } //Process the fusion m_ConvolutionFilter->SetInput(this->GetPanInput()); m_ConvolutionFilter->SetRadius(this->m_Radius); m_ConvolutionFilter->SetFilter(this->m_Filter); m_FusionFilter->SetInput1(this->GetXsInput()); m_FusionFilter->SetInput3(this->GetPanInput()); // Wire composite filter m_FusionFilter->GraftOutput(this->GetOutput()); m_FusionFilter->Update(); this->GraftOutput(m_FusionFilter->GetOutput()); } template void SimpleRcsPanSharpeningFusionImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Radius:" << this->m_Radius << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Fusion/PanSharpening/otb-module.cmake000066400000000000000000000012071301006202600240770ustar00rootroot00000000000000set(DOCUMENTATION "Most of the fusion methods in the remote sensing community deal with the pansharpening technique. This fusion combines the image from the PANchromatic sensor of one satellite (high spatial resolution data) with the multispectral (XS) data (lower resolution in several spectral bands) to generate images with a high resolution and several spectral bands. This module provides classes related to this purpose.") otb_module(OTBPanSharpening DEPENDS OTBImageBase OTBStatistics OTBITK OTBConvolution OTBImageManipulation TEST_DEPENDS OTBTestKernel OTBImageIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Fusion/PanSharpening/test/000077500000000000000000000000001301006202600220055ustar00rootroot00000000000000OTB-release-5.8/Modules/Fusion/PanSharpening/test/CMakeLists.txt000066400000000000000000000042111301006202600245430ustar00rootroot00000000000000otb_module_test() set(OTBPanSharpeningTests otbPanSharpeningTestDriver.cxx otbSimpleRcsPanSharpeningFusionImageFilter.cxx otbLmvmPanSharpeningFusionImageFilterNew.cxx otbBayesianFusionFilterNew.cxx otbBayesianFusionFilter.cxx otbFusionImageBaseNew.cxx otbSimpleRcsPanSharpeningFusionImageFilterNew.cxx otbLmvmPanSharpeningFusionImageFilter.cxx ) add_executable(otbPanSharpeningTestDriver ${OTBPanSharpeningTests}) target_link_libraries(otbPanSharpeningTestDriver ${OTBPanSharpening-Test_LIBRARIES}) otb_module_target_label(otbPanSharpeningTestDriver) # Tests Declaration otb_add_test(NAME fuTvSimpleRcsPanSharpeningFusionImageFilter COMMAND otbPanSharpeningTestDriver --compare-image ${EPSILON_8} ${BASELINE}/fuTvRcsPanSharpeningFusion.tif ${TEMP}/fuTvRcsPanSharpeningFusion.tif otbSimpleRcsPanSharpeningFusionImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif ${TEMP}/fuTvRcsPanSharpeningFusion.tif ) otb_add_test(NAME fuTuLmvmPanSharpeningFusionImageFilterNew COMMAND otbPanSharpeningTestDriver otbLmvmPanSharpeningFusionImageFilterNew ) otb_add_test(NAME fuTuBayesianFusionFilterNew COMMAND otbPanSharpeningTestDriver otbBayesianFusionFilterNew ) otb_add_test(NAME fuTvBayesianFusionFilter COMMAND otbPanSharpeningTestDriver --compare-image ${NOTOL} ${BASELINE}/fuTvBayesianFusion.tif ${TEMP}/fuTvBayesianFusion.tif otbBayesianFusionFilter ${INPUTDATA}/multiSpect.tif ${INPUTDATA}/multiSpectInterp.tif ${INPUTDATA}/panchro.tif ${TEMP}/fuTvBayesianFusion.tif ) otb_add_test(NAME fuTuFusionImageBaseNew COMMAND otbPanSharpeningTestDriver otbFusionImageBaseNew ) otb_add_test(NAME fuTuSimpleRcsPanSharpeningFusionImageFilterNew COMMAND otbPanSharpeningTestDriver otbSimpleRcsPanSharpeningFusionImageFilterNew ) otb_add_test(NAME fuTvLmvmPanSharpeningFusionImageFilter COMMAND otbPanSharpeningTestDriver --compare-image ${EPSILON_8} ${BASELINE}/fuTvLmvmPanSharpeningFusion.tif ${TEMP}/fuTvLmvmPanSharpeningFusion.tif otbLmvmPanSharpeningFusionImageFilter ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif ${TEMP}/fuTvLmvmPanSharpeningFusion.tif ) OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbBayesianFusionFilter.cxx000066400000000000000000000043201301006202600273220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbBayesianFusionFilter.h" int otbBayesianFusionFilter(int itkNotUsed(argc), char * argv[]) { const char * multispect = argv[1]; const char * multispectinterp = argv[2]; const char * panchro = argv[3]; const char * output = argv[4]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image PanchroImageType; typedef otb::ImageFileReader VectorReaderType; typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileWriter VectorImageWriterType; typedef otb::BayesianFusionFilter FilterType; VectorReaderType::Pointer multiSpectReader = VectorReaderType::New(); VectorReaderType::Pointer multiSpectInterpReader = VectorReaderType::New(); ImageReaderType::Pointer panchroReader = ImageReaderType::New(); FilterType::Pointer filter = FilterType::New(); VectorImageWriterType::Pointer writer = VectorImageWriterType::New(); multiSpectReader->SetFileName(multispect); multiSpectInterpReader->SetFileName(multispectinterp); panchroReader->SetFileName(panchro); filter->SetMultiSpect(multiSpectReader->GetOutput()); filter->SetMultiSpectInterp(multiSpectInterpReader->GetOutput()); filter->SetPanchro(panchroReader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->SetFileName(output); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbBayesianFusionFilterNew.cxx000066400000000000000000000023121301006202600277730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbBayesianFusionFilter.h" int otbBayesianFusionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image PanchroImageType; typedef otb::BayesianFusionFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbFusionImageBaseNew.cxx000066400000000000000000000041461301006202600267160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbFusionImageBase.h" namespace Functor { template class NewFunctorTest { public: NewFunctorTest() {} ~NewFunctorTest() {} inline TOutput operator ()(const TInputMultiSpectral& A, const TInputMultiSpectralInterp& B, const TInputPanchro& C) { return (static_cast(A[0]) + static_cast(B[0]) + static_cast(C)); } }; } int otbFusionImageBaseNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputPanchroImageType; typedef otb::VectorImage InputMultiSpectralImageType; typedef otb::VectorImage InputMultiSpectralInterpImageType; typedef otb::Image OutputImageType; typedef otb::FusionImageBase > FusionImageBaseType; // Instantiation FusionImageBaseType::Pointer base = FusionImageBaseType::New(); std::cout << base << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbLmvmPanSharpeningFusionImageFilter.cxx000066400000000000000000000057141301006202600321330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbLmvmPanSharpeningFusionImageFilter.h" int otbLmvmPanSharpeningFusionImageFilter(int itkNotUsed(argc), char * argv[]) { const char * panchro = argv[1]; const char * multispect = argv[2]; const char * output = argv[3]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image PanchroImageType; typedef otb::ImageFileReader VectorReaderType; typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileWriter VectorImageWriterType; typedef otb::LmvmPanSharpeningFusionImageFilter FilterType; VectorReaderType::Pointer multiSpectReader = VectorReaderType::New(); ImageReaderType::Pointer panchroReader = ImageReaderType::New(); FilterType::Pointer filter = FilterType::New(); VectorImageWriterType::Pointer writer = VectorImageWriterType::New(); multiSpectReader->SetFileName(multispect); panchroReader->SetFileName(panchro); PanchroImageType::SizeType radius; radius[0] = 5; radius[1] = 5; itk::Array filterCoeffs; filterCoeffs.SetSize((2 * radius[0] + 1) * (2 * radius[1] + 1)); // double filterTmp[] = { // 0.00390625, 0.0078125, 0.0117188, 0.015625, 0.0117188, 0.0078125, 0.00390625, // 0.0078125, 0.015625, 0.0234375, 0.03125, 0.0234375, 0.015625, 0.0078125, // 0.0117188, 0.0234375, 0.0351562, 0.046875, 0.0351562, 0.0234375, 0.0117188, // 0.015625, 0.03125, 0.046875, 0.0625, 0.046875, 0.03125, 0.015625, // 0.0117188, 0.0234375, 0.0351562, 0.046875, 0.0351562, 0.0234375, 0.0117188, // 0.0078125, 0.015625, 0.0234375, 0.03125, 0.0234375, 0.015625, 0.0078125, // 0.00390625, 0.0078125, 0.0117188, 0.015625, 0.0117188, 0.0078125, 0.00390625 }; // // filterCoeffs.SetData(filterTmp); filterCoeffs.Fill(1); filter->SetXsInput(multiSpectReader->GetOutput()); filter->SetPanInput(panchroReader->GetOutput()); filter->SetRadius(radius); filter->SetFilter(filterCoeffs); writer->SetInput(filter->GetOutput()); writer->SetFileName(output); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbLmvmPanSharpeningFusionImageFilterNew.cxx000066400000000000000000000023341301006202600326000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbLmvmPanSharpeningFusionImageFilter.h" int otbLmvmPanSharpeningFusionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image PanchroImageType; typedef otb::LmvmPanSharpeningFusionImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbPanSharpeningTestDriver.cxx000066400000000000000000000006411301006202600300100ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbSimpleRcsPanSharpeningFusionImageFilter); REGISTER_TEST(otbLmvmPanSharpeningFusionImageFilterNew); REGISTER_TEST(otbBayesianFusionFilterNew); REGISTER_TEST(otbBayesianFusionFilter); REGISTER_TEST(otbFusionImageBaseNew); REGISTER_TEST(otbSimpleRcsPanSharpeningFusionImageFilterNew); REGISTER_TEST(otbLmvmPanSharpeningFusionImageFilter); } OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbSimpleRcsPanSharpeningFusionImageFilter.cxx000066400000000000000000000057411301006202600331210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbSimpleRcsPanSharpeningFusionImageFilter.h" int otbSimpleRcsPanSharpeningFusionImageFilter(int itkNotUsed(argc), char * argv[]) { const char * panchro = argv[1]; const char * multispect = argv[2]; const char * output = argv[3]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image PanchroImageType; typedef otb::ImageFileReader VectorReaderType; typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileWriter VectorImageWriterType; typedef otb::SimpleRcsPanSharpeningFusionImageFilter FilterType; VectorReaderType::Pointer multiSpectReader = VectorReaderType::New(); ImageReaderType::Pointer panchroReader = ImageReaderType::New(); FilterType::Pointer filter = FilterType::New(); VectorImageWriterType::Pointer writer = VectorImageWriterType::New(); multiSpectReader->SetFileName(multispect); panchroReader->SetFileName(panchro); PanchroImageType::SizeType radius; radius[0] = 3; radius[1] = 3; itk::Array filterCoeffs; filterCoeffs.SetSize((2 * radius[0] + 1) * (2 * radius[1] + 1)); // double filterTmp[] = { // 0.00390625, 0.0078125, 0.0117188, 0.015625, 0.0117188, 0.0078125, 0.00390625, // 0.0078125, 0.015625, 0.0234375, 0.03125, 0.0234375, 0.015625, 0.0078125, // 0.0117188, 0.0234375, 0.0351562, 0.046875, 0.0351562, 0.0234375, 0.0117188, // 0.015625, 0.03125, 0.046875, 0.0625, 0.046875, 0.03125, 0.015625, // 0.0117188, 0.0234375, 0.0351562, 0.046875, 0.0351562, 0.0234375, 0.0117188, // 0.0078125, 0.015625, 0.0234375, 0.03125, 0.0234375, 0.015625, 0.0078125, // 0.00390625, 0.0078125, 0.0117188, 0.015625, 0.0117188, 0.0078125, 0.00390625 }; // // filterCoeffs.SetData(filterTmp); filterCoeffs.Fill(1); filter->SetXsInput(multiSpectReader->GetOutput()); filter->SetPanInput(panchroReader->GetOutput()); filter->SetRadius(radius); filter->SetFilter(filterCoeffs); writer->SetInput(filter->GetOutput()); writer->SetFileName(output); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Fusion/PanSharpening/test/otbSimpleRcsPanSharpeningFusionImageFilterNew.cxx000066400000000000000000000023611301006202600335660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbSimpleRcsPanSharpeningFusionImageFilter.h" int otbSimpleRcsPanSharpeningFusionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image PanchroImageType; typedef otb::SimpleRcsPanSharpeningFusionImageFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/000077500000000000000000000000001301006202600176535ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/000077500000000000000000000000001301006202600231125ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/CMakeLists.txt000066400000000000000000000000571301006202600256540ustar00rootroot00000000000000project(OTBAnomalyDetection) otb_module_impl() OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/include/000077500000000000000000000000001301006202600245355ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/include/otbLocalRxDetectorFilter.h000066400000000000000000000107311301006202600316210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalRxDetectorFilter_h #define otbLocalRxDetectorFilter_h #include "itkImageToImageFilter.h" #include "itkConstShapedNeighborhoodIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkImageRegionIterator.h" #include "itkListSample.h" #include "itkCovarianceSampleFilter.h" #include "itkProgressReporter.h" namespace otb { /** \class otbLocalRxDetectorFilter * \brief Local-RX detector algorithm with multichannel VectorImage data as input * * * \ingroup ImageFilters * * \ingroup OTBAnomalyDetection */ template class ITK_EXPORT LocalRxDetectorFilter: public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef LocalRxDetectorFilter Self; typedef itk::ImageToImageFilter< TInputImage, TOutputImage > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(LocalRxDetectorFilter, ImageToImageFilter); /** typedef related to input and output images */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputPointerType; typedef typename InputImageType::ConstPointer InputConstPointerType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType InputSizeType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputPointerType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::OffsetType OutputOffsetType; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** typedef related to iterators */ typedef itk::ConstShapedNeighborhoodIterator ConstShapedNeighborhoodIteratorType; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator VectorFaceCalculatorType; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator FaceCalculatorType; typedef itk::ImageRegionIterator ImageRegionIteratorType; /** typedef related to statistics */ typedef typename InputImageType::PixelType VectorMeasurementType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::CovarianceSampleFilter CovarianceCalculatorType; typedef typename CovarianceCalculatorType::MeasurementVectorRealType MeasurementVectorRealType; typedef typename CovarianceCalculatorType::MatrixType MatrixType; /** Getter and Setter */ itkSetMacro(InternalRadius, int); itkGetMacro(InternalRadius, int); itkSetMacro(ExternalRadius, int); itkGetMacro(ExternalRadius, int); /** Main computation method */ void GenerateInputRequestedRegion() ITK_OVERRIDE; // virtual void GenerateData(); void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; protected: LocalRxDetectorFilter(); ~LocalRxDetectorFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LocalRxDetectorFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented int m_InternalRadius; int m_ExternalRadius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLocalRxDetectorFilter.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/include/otbLocalRxDetectorFilter.txx000066400000000000000000000157751301006202600322320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalRxDetectorFilter_txx #define otbLocalRxDetectorFilter_txx #include "otbLocalRxDetectorFilter.h" namespace otb { /** * */ template LocalRxDetectorFilter ::LocalRxDetectorFilter() : m_InternalRadius(1), m_ExternalRadius(2) { } /** * */ template void LocalRxDetectorFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Internal Radius: " << m_InternalRadius << std::endl; os << indent << "External Radius: " << m_ExternalRadius << std::endl; } /** * */ template void LocalRxDetectorFilter ::BeforeThreadedGenerateData() { // Get the input and output pointers OutputPointerType outputPtr = this->GetOutput(); // Fill the buffer with black pixels outputPtr->FillBuffer(0); } /** * */ template void LocalRxDetectorFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Get the input and output pointers InputConstPointerType inputPtr = this->GetInput(); OutputPointerType outputPtr = this->GetOutput(); // Support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Compute input region for thread typename TInputImage::RegionType inputRegionForThread; inputRegionForThread = outputRegionForThread; inputRegionForThread.PadByRadius(m_ExternalRadius); inputRegionForThread.Crop(inputPtr->GetLargestPossibleRegion()); // Iterator on input region typename ConstShapedNeighborhoodIteratorType::RadiusType radius; radius.Fill(m_ExternalRadius); VectorFaceCalculatorType vectorFaceCalculator; typename VectorFaceCalculatorType::FaceListType vectorFaceList; typename VectorFaceCalculatorType::FaceListType::iterator vectorFit; vectorFaceList = vectorFaceCalculator(inputPtr, inputRegionForThread, radius); vectorFit = vectorFaceList.begin(); // Only the first face is used ConstShapedNeighborhoodIteratorType inputIt(radius, inputPtr, *vectorFit); // Neighborhood Configuration typename ConstShapedNeighborhoodIteratorType::OffsetType off; for (int y = -m_ExternalRadius; y <= m_ExternalRadius; y++) { off[1] = y; for (int x = -m_ExternalRadius; x <= m_ExternalRadius; x++) { off[0] = x; if ((abs(x) > m_InternalRadius) || (abs(y) > m_InternalRadius)) { inputIt.ActivateOffset(off); } } } // iterator on output region FaceCalculatorType faceCalculator; typename FaceCalculatorType::FaceListType faceList; typename FaceCalculatorType::FaceListType::iterator fit; faceList = faceCalculator(outputPtr, inputRegionForThread, radius); fit = faceList.begin(); // Only the first face is used ImageRegionIteratorType outputIt(outputPtr, *fit); // Run Input Image for (inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt) { // Create ListSample typename ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(inputPtr->GetNumberOfComponentsPerPixel()); // Run neighborhood typename ConstShapedNeighborhoodIteratorType::ConstIterator ci; for (ci = inputIt.Begin(); !ci.IsAtEnd(); ++ci) { // Pushback element in listSample listSample->PushBack(ci.Get()); } // Compute mean & covariance matrix typename CovarianceCalculatorType::Pointer covarianceCalculator = CovarianceCalculatorType::New(); covarianceCalculator->SetInput(listSample); covarianceCalculator->Update(); MeasurementVectorRealType meanVector = covarianceCalculator->GetMean(); MatrixType covarianceMatrix = covarianceCalculator->GetCovarianceMatrix(); // Compute RX value typename MatrixType::InternalMatrixType invCovMat = covarianceMatrix.GetInverse(); VectorMeasurementType testPixVec; testPixVec = inputPtr->GetPixel(inputIt.GetIndex()); VectorMeasurementType meanVec(meanVector.GetNumberOfElements()); for(unsigned int i = 0; i < meanVector.GetNumberOfElements(); ++i) { meanVec.SetElement(i, meanVector.GetElement(i)); } typename MatrixType::InternalMatrixType centeredTestPixMat(meanVector.GetNumberOfElements(), 1); for (unsigned int i = 0; i < centeredTestPixMat.rows(); ++i) { centeredTestPixMat.put(i, 0, (testPixVec.GetElement(i) - meanVector.GetElement(i))); } typename MatrixType::InternalMatrixType rxValue = centeredTestPixMat.transpose() * invCovMat * centeredTestPixMat; outputIt.Set(rxValue.get(0, 0)); } } /** * */ template void LocalRxDetectorFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output InputPointerType inputPtr = const_cast< InputImageType * >( this->GetInput()); OutputPointerType outputPtr = this->GetOutput(); if ( !inputPtr || !outputPtr ) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius( m_ExternalRadius ); // crop the input requested region at the input's largest possible region if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) ) { inputPtr->SetRequestedRegion( inputRequestedRegion ); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion( inputRequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } } // end namespace otb #endif OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/include/otbLocalRxDetectorNonThreadFilter.h000066400000000000000000000106671301006202600334340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalRxDetectorNonThreadFilter_h #define otbLocalRxDetectorNonThreadFilter_h #include "itkImageToImageFilter.h" #include "itkConstShapedNeighborhoodIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkImageRegionIterator.h" #include "itkListSample.h" #include "itkCovarianceSampleFilter.h" namespace otb { /** \class otbLocalRxDetectorNonThreadFilter * \brief Local-RX detector algorithm with multichannel VectorImage data as input * * * \ingroup ImageFilters * * \ingroup OTBAnomalyDetection */ template class ITK_EXPORT LocalRxDetectorNonThreadFilter: public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef LocalRxDetectorNonThreadFilter Self; typedef itk::ImageToImageFilter< TInputImage, TOutputImage > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(LocalRxDetectorNonThreadFilter, ImageToImageFilter); /** typedef related to input and output images */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputPointerType; typedef typename InputImageType::ConstPointer InputConstPointerType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType InputSizeType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputPointerType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::OffsetType OutputOffsetType; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::RegionType OutputImageRegionType; /** typedef related to iterators */ typedef itk::ConstShapedNeighborhoodIterator ConstShapedNeighborhoodIteratorType; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator VectorFaceCalculatorType; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator FaceCalculatorType; typedef itk::ImageRegionIterator ImageRegionIteratorType; /** typedef related to statistics */ typedef typename InputImageType::PixelType VectorMeasurementType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::CovarianceSampleFilter CovarianceCalculatorType; typedef typename CovarianceCalculatorType::MeasurementVectorRealType MeasurementVectorRealType; typedef typename CovarianceCalculatorType::MatrixType MatrixType; /** Getter and Setter */ itkSetMacro(InternalRadius, int); itkGetMacro(InternalRadius, int); itkSetMacro(ExternalRadius, int); itkGetMacro(ExternalRadius, int); /** Main computation method */ void GenerateInputRequestedRegion() ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; // virtual void BeforeThreadedGenerateData(); // virtual void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId); protected: LocalRxDetectorNonThreadFilter(); ~LocalRxDetectorNonThreadFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LocalRxDetectorNonThreadFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented int m_InternalRadius; int m_ExternalRadius; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLocalRxDetectorNonThreadFilter.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/include/otbLocalRxDetectorNonThreadFilter.txx000066400000000000000000000153311301006202600340210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLocalRxDetectorNonThreadFilter_txx #define otbLocalRxDetectorNonThreadFilter_txx #include "otbLocalRxDetectorNonThreadFilter.h" namespace otb { /** * */ template LocalRxDetectorNonThreadFilter ::LocalRxDetectorNonThreadFilter() { this->m_ExternalRadius = 0; this->m_InternalRadius = 0; } /** * */ template void LocalRxDetectorNonThreadFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Internal Radius: " << m_InternalRadius << std::endl; os << indent << "External Radius: " << m_ExternalRadius << std::endl; } /** * */ template void LocalRxDetectorNonThreadFilter ::GenerateData() { this->AllocateOutputs(); // Get the input and output pointers InputPointerType inputPtr = const_cast< InputImageType * >( this->GetInput()); OutputPointerType outputPtr = this->GetOutput(); inputPtr->Update(); // Fill the output buffer with black pixels outputPtr->FillBuffer(0); // Iterator on input region typename ConstShapedNeighborhoodIteratorType::RadiusType radius; radius.Fill(m_ExternalRadius); VectorFaceCalculatorType vectorFaceCalculator; typename VectorFaceCalculatorType::FaceListType vectorFaceList; typename VectorFaceCalculatorType::FaceListType::iterator vectorFit; vectorFaceList = vectorFaceCalculator(inputPtr, inputPtr->GetRequestedRegion(), radius); vectorFit = vectorFaceList.begin(); // Only the first face is used ConstShapedNeighborhoodIteratorType inputIt(radius, inputPtr, *vectorFit); // Neighborhood Configuration typename ConstShapedNeighborhoodIteratorType::OffsetType off; for (int y = -m_ExternalRadius; y <= m_ExternalRadius; y++) { off[1] = y; for (int x = -m_ExternalRadius; x <= m_ExternalRadius; x++) { off[0] = x; if ((abs(x) > m_InternalRadius) || (abs(y) > m_InternalRadius)) { inputIt.ActivateOffset(off); } } } // Iterator on output region FaceCalculatorType faceCalculator; typename FaceCalculatorType::FaceListType faceList; typename FaceCalculatorType::FaceListType::iterator fit; faceList = faceCalculator(outputPtr, inputPtr->GetRequestedRegion(), radius); fit = faceList.begin(); // Only the first face is used ImageRegionIteratorType outputIt(outputPtr, *fit); //std::cout << "Region de la face list : " << *vectorFit << std::endl; //std::cout << "Region dans le buffer : " << inputPtr->GetBufferedRegion() << std::endl; // Run Input Image for (inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt) { // Create ListSample typename ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(inputPtr->GetNumberOfComponentsPerPixel()); // Run neighborhood typename ConstShapedNeighborhoodIteratorType::ConstIterator ci; for (ci = inputIt.Begin(); !ci.IsAtEnd(); ++ci) { // Pushback element in listSample //std::cout << "pixel of shaped iteror : " << ci.Get() << std::endl; listSample->PushBack(ci.Get()); } // Compute mean & covariance matrix typename CovarianceCalculatorType::Pointer covarianceCalculator = CovarianceCalculatorType::New(); covarianceCalculator->SetInput(listSample); covarianceCalculator->Update(); MeasurementVectorRealType meanVector = covarianceCalculator->GetMean(); MatrixType covarianceMatrix = covarianceCalculator->GetCovarianceMatrix(); // Compute RX value typename MatrixType::InternalMatrixType invCovMat = covarianceMatrix.GetInverse(); VectorMeasurementType testPixVec; testPixVec = inputPtr->GetPixel(inputIt.GetIndex()); VectorMeasurementType meanVec(meanVector.GetNumberOfElements()); for(unsigned int i = 0; i < meanVector.GetNumberOfElements(); ++i) { meanVec.SetElement(i, meanVector.GetElement(i)); } typename MatrixType::InternalMatrixType centeredTestPixMat(meanVector.GetNumberOfElements(), 1); for (unsigned int i = 0; i < centeredTestPixMat.rows(); ++i) { centeredTestPixMat.put(i, 0, (testPixVec.GetElement(i) - meanVector.GetElement(i))); } typename MatrixType::InternalMatrixType rxValue = centeredTestPixMat.transpose() * invCovMat * centeredTestPixMat; outputIt.Set(rxValue.get(0, 0)); } } /** * */ template void LocalRxDetectorNonThreadFilter ::GenerateInputRequestedRegion() { // Call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // Get pointers to the input and output InputPointerType inputPtr = const_cast< InputImageType * >( this->GetInput()); OutputPointerType outputPtr = this->GetOutput(); if ( !inputPtr || !outputPtr ) { return; } // Get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // Pad the input requested region by the operator radius inputRequestedRegion.PadByRadius( m_ExternalRadius ); // Crop the input requested region at the input's largest possible region if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) ) { inputPtr->SetRequestedRegion( inputRequestedRegion ); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // Store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion( inputRequestedRegion ); // Build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } } // end namespace otb #endif OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/otb-module.cmake000066400000000000000000000011221301006202600261570ustar00rootroot00000000000000set(DOCUMENTATION "Anomalies are composed of a set of isolated pixels with anomalous signatures (when compared to the image background) which represents a very small piece of the full image, and they only occur in the image with low probabilities. This module contains classes related to well-known approaches for anomaly detection which have shown success for multispectral and hyperspectral images (for example Local-RX detector).") otb_module(OTBAnomalyDetection DEPENDS OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/test/000077500000000000000000000000001301006202600240715ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/test/CMakeLists.txt000066400000000000000000000006001301006202600266250ustar00rootroot00000000000000otb_module_test() set(OTBAnomalyDetectionTests otbAnomalyDetectionTestDriver.cxx otbLocalRxDetectorRoiTest.cxx otbLocalRxDetectorTest.cxx ) add_executable(otbAnomalyDetectionTestDriver ${OTBAnomalyDetectionTests}) target_link_libraries(otbAnomalyDetectionTestDriver ${OTBAnomalyDetection-Test_LIBRARIES}) otb_module_target_label(otbAnomalyDetectionTestDriver) # Tests Declaration OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/test/otbAnomalyDetectionTestDriver.cxx000066400000000000000000000002521301006202600325740ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(LocalRXDetectorROITest); REGISTER_TEST(LocalRXDetectorNewTest); REGISTER_TEST(LocalRXDetectorTest); } OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/test/otbLocalRxDetectorRoiTest.cxx000066400000000000000000000054311301006202600316750ustar00rootroot00000000000000#include "otbImageFileReader.h" #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include "otbLocalRxDetectorNonThreadFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbExtractROI.h" int LocalRXDetectorROITest(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::LocalRxDetectorNonThreadFilter LocalRxDetectorFilterType; typedef otb::ImageFileReader ReaderType; typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; typedef otb::ExtractROI ExtractRoiType; //--------------- Parameters ------------------// const char * filename = argv[1]; const char * outputFilename = argv[2]; const unsigned int externalRadius = atoi(argv[3]); const unsigned int internalRadius = atoi(argv[4]); const unsigned int indexX = atoi(argv[5]); const unsigned int indexY = atoi(argv[6]); const unsigned int sizeX = atoi(argv[7]); const unsigned int sizeY = atoi(argv[8]); //--------------- Read hsi file -----------------// ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(filename); reader->UpdateOutputInformation(); //------------- Anomaly detection ---------------// LocalRxDetectorFilterType::Pointer rxDetector = LocalRxDetectorFilterType::New(); rxDetector->SetExternalRadius(externalRadius); rxDetector->SetInternalRadius(internalRadius); rxDetector->SetInput(reader->GetOutput()); //------------ Build extractRoiFilter -----------// ExtractRoiType::Pointer roiExtractor = ExtractRoiType::New(); roiExtractor->SetStartX(indexX); roiExtractor->SetStartY(indexY); roiExtractor->SetSizeX(sizeX); roiExtractor->SetSizeY(sizeY); roiExtractor->SetInput(rxDetector->GetOutput()); //------------ rescaling and writing ------------// RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(roiExtractor->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(roiExtractor->GetOutput()); //---------------- Launching pipeline ------------// writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/AnomalyDetection/test/otbLocalRxDetectorTest.cxx000066400000000000000000000044201301006202600312200ustar00rootroot00000000000000#include "otbImageFileReader.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include "otbLocalRxDetectorFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" int LocalRXDetectorNewTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::LocalRxDetectorFilter LocalRxDetectorFilterType; LocalRxDetectorFilterType::Pointer rxDetector = LocalRxDetectorFilterType::New(); return EXIT_SUCCESS; } int LocalRXDetectorTest(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::Image ImageType; typedef otb::LocalRxDetectorFilter LocalRxDetectorFilterType; typedef otb::ImageFileReader ReaderType; typedef unsigned char WritePixelType; typedef otb::Image WriteImageType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter RescalerType; /////////// PARAMETERS /////////// const char * filename = argv[1]; const char * outputFilename = argv[2]; const int externalRadius = atoi(argv[3]); const int internalRadius = atoi(argv[4]); //////// RX Filtering ///////// ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(filename); LocalRxDetectorFilterType::Pointer rxDetector = LocalRxDetectorFilterType::New(); rxDetector->SetExternalRadius(externalRadius); rxDetector->SetInternalRadius(internalRadius); rxDetector->SetInput(reader->GetOutput()); RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); rescaler->SetInput(rxDetector->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(rescaler->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/000077500000000000000000000000001301006202600237755ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/CMakeLists.txt000066400000000000000000000000631301006202600265340ustar00rootroot00000000000000project(OTBEndmembersExtraction) otb_module_impl() OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/include/000077500000000000000000000000001301006202600254205ustar00rootroot00000000000000otbEigenvalueLikelihoodMaximisation.h000066400000000000000000000070151301006202600346750ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEigenvalueLikelihoodMaximisation_h #define otbEigenvalueLikelihoodMaximisation_h #include "itkObjectFactory.h" #include "itkLightObject.h" #include "vnl/vnl_vector.h" #include "vnl/vnl_matrix.h" #include "vnl/algo/vnl_symmetric_eigensystem.h" namespace otb { /** \class EigenvalueLikelihoodMaximisation * \brief Estimates the number of endmembers in a hyperspectral image * * This filter applies the ELM (Eigenvalue Likelihood Maximisation) algorithm to a * hyperspectral image and outputs the number of endmember. * It takes as input the covariance and correlation matrices of the input data, * the number of observed pixel for thoses matrices estimations, * and outputs the number of endmembers, and the log-likelihood. * * References : * "Unsupervised Endmember Extraction of Martian Hyperspectral Images", * B.Luo, J. Chanussot, S. Dout\'e and X. Ceamanos, * IEEE Whispers 2009, Grenoble France, 2009 * * "Unsupervised classification of hyperspectral images by using linear unmixing algorithm", * Luo, B. and Chanussot, J., * IEEE Int. Conf. On Image Processing(ICIP) 2009, Cairo, Egypte, 2009 * * \ingroup Hyperspectral * * \ingroup OTBEndmembersExtraction */ template class ITK_EXPORT EigenvalueLikelihoodMaximisation : public itk::LightObject { public: /** Standard Self typedef */ typedef EigenvalueLikelihoodMaximisation Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(EigenvalueLikelihoodMaximisation, itk::LightObject); /** Types to use for computations. */ typedef TPrecision PrecisionType; typedef vnl_vector VectorType; typedef vnl_matrix MatrixType; void SetCovariance(const MatrixType& m) { m_Covariance = m; } void SetCorrelation(const MatrixType& m) { m_Correlation = m; } void SetNumberOfPixels(unsigned int n) { m_NumberOfPixels = n; } void Compute(); unsigned int GetNumberOfEndmembers() { return m_NumberOfEndmembers; } const VectorType& GetLikelihood() { return m_Likelihood; } protected: EigenvalueLikelihoodMaximisation(); ~EigenvalueLikelihoodMaximisation() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: EigenvalueLikelihoodMaximisation(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented MatrixType m_Covariance; MatrixType m_Correlation; unsigned int m_NumberOfPixels; unsigned int m_NumberOfEndmembers; VectorType m_Likelihood; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbEigenvalueLikelihoodMaximisation.txx" #endif #endif otbEigenvalueLikelihoodMaximisation.txx000066400000000000000000000062131301006202600352700ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbEigenvalueLikelihoodMaximisation_txx #define otbEigenvalueLikelihoodMaximisation_txx #include "otbEigenvalueLikelihoodMaximisation.h" #include namespace otb { template EigenvalueLikelihoodMaximisation ::EigenvalueLikelihoodMaximisation() : m_NumberOfPixels(0), m_NumberOfEndmembers(0) { } template void EigenvalueLikelihoodMaximisation ::Compute() { // TODO check size const unsigned int nbBands = m_Covariance.rows(); // Compute diagonalisation of covariance and correlation vnl_symmetric_eigensystem eigenK(m_Covariance); VectorType eigenCovariance = eigenK.D.diagonal(); vcl_sort(eigenCovariance.begin(), eigenCovariance.end()); eigenCovariance.flip(); vnl_symmetric_eigensystem eigenR(m_Correlation); VectorType eigenCorrelation = eigenR.D.diagonal(); vcl_sort(eigenCorrelation.begin(), eigenCorrelation.end()); eigenCorrelation.flip(); // Compute likelihood log m_Likelihood.set_size(nbBands); const double coef = 2.0/m_NumberOfPixels; for(unsigned int i=0; i < nbBands; ++i) { const unsigned int nl = nbBands - i; VectorType sigma(nl), t(nl); for (unsigned int j = 0; j < nl; ++j ) { PrecisionType r = eigenCorrelation[j + i]; PrecisionType k = eigenCovariance[j + i]; sigma[j] = coef * (r * r + k * k); //std::cout << "sigma[" << j << "]=" << sigma[j] << std::endl; t[j] = (r - k) * (r - k) / sigma[j]; //std::cout << "t[" << j <<"]=" << t[j] << std::endl; sigma[j] = vcl_log(sigma[j]); } m_Likelihood(i) = -0.5*t.sum() - 0.5*sigma.sum(); } // Extract first local maximum //double max = m_Likelihood[0]; unsigned int iMax = 0; for (unsigned int i = 1; i < m_Likelihood.size() - 1; ++i) { if ( (m_Likelihood[i] > m_Likelihood[i - 1]) && (m_Likelihood[i] > m_Likelihood[i + 1]) ) { //max = m_Likelihood[i]; iMax = i; break; } } m_NumberOfEndmembers = iMax; } template void EigenvalueLikelihoodMaximisation ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Covariance: " << m_Covariance << std::endl; os << indent << "Correlation: " << m_Correlation << std::endl; os << indent << "NumberOfEndmembers: " << m_NumberOfEndmembers << std::endl; os << indent << "Likelihood: " << m_Likelihood << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/include/otbVcaImageFilter.h000066400000000000000000000133421301006202600311230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVCAImageFilter_h #define otbVCAImageFilter_h #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkAbsImageFilter.h" #include "otbDotProductImageFilter.h" #include "otbProjectiveProjectionImageFilter.h" #include "otbVectorImageToMatrixImageFilter.h" #include "otbStreamingMinMaxImageFilter.h" #include "otbStreamingStatisticsImageFilter.h" #include "otbPCAImageFilter.h" #include "otbVectorImageToAmplitudeImageFilter.h" #include "otbConcatenateScalarValueImageFilter.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "vnl/algo/vnl_svd.h" namespace otb { /** \class VCAImageFilter * \brief Estimates the endmembers present in a hyperspectral image * * This filter applies the VCA (Vertex Component Analysis) algorithm to a * hyperspectral image and outputs the estimated endmembers. * The output image of this filter is a one-line VectorImage containing, * at each pixel location, one of the estimated endmember. * * This code is a C++ port of the Matlab implementation * available in the Matlab Hyperspectral Toolbox. * Most notably it supports streaming and is fully multi-threaded, * so it can be run seamlessly on full hyperspectral scenes. * * References : * "Vertex Component Analysis: A Fast Algorithm to Unmix Hyperspectral Data", * Jos\'e M. P. Nascimento, and Jos\'e M. Bioucas Dias, * IEEE Transactions on Geoscience and Remote Sensing, Vol. 43, No. 4, April 2005 * * \ingroup Hyperspectral * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBEndmembersExtraction */ template class ITK_EXPORT VCAImageFilter : public itk::ImageToImageFilter { public: typedef VCAImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TVectorImage VectorImageType; typedef typename VectorImageType::IndexType IndexType; typedef typename VectorImageType::SizeType SizeType; typedef typename VectorImageType::RegionType RegionType; typedef typename VectorImageType::PixelType PixelType; typedef typename VectorImageType::InternalPixelType InternalPixelType; typedef InternalPixelType PrecisionType; typedef otb::Image ImageType; typedef itk::AbsImageFilter AbsImageFilterType; typedef otb::ProjectiveProjectionImageFilter ProjectiveProjectionImageFilterType; typedef otb::DotProductImageFilter DotProductImageFilterType; typedef otb::MatrixImageFilter MatrixImageFilterType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; typedef otb::StreamingMinMaxImageFilter StreamingMinMaxImageFilterType; typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef otb::StreamingStatisticsImageFilter StreamingStatisticsImageFilterType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomVariateGeneratorType; typedef otb::PCAImageFilter< VectorImageType, VectorImageType, otb::Transform::FORWARD > ForwardPCAImageFilterType; typedef otb::PCAImageFilter< VectorImageType, VectorImageType, otb::Transform::INVERSE > InversePCAImageFilterType; typedef otb::VectorImageToAmplitudeImageFilter< VectorImageType, ImageType > VectorImageToAmplitudeImageFilterType; typedef otb::ConcatenateScalarValueImageFilter< VectorImageType, VectorImageType > ConcatenateScalarValueImageFilterType; // creation of SmartPointer itkNewMacro(Self); // runtime type information itkTypeMacro(VCAImageFilter, itk::ImageToImageFilter); itkGetMacro( NumberOfEndmembers, unsigned int ); itkSetMacro( NumberOfEndmembers, unsigned int ); void Update() ITK_OVERRIDE { this->GenerateData(); } void EnlargeOutputRequestedRegion(itk::DataObject *itkNotUsed(output)) ITK_OVERRIDE { this->GetOutput() ->SetRequestedRegion( this->GetOutput()->GetLargestPossibleRegion() ); } protected: VCAImageFilter(); ~VCAImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: VCAImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfEndmembers; }; } // end namesapce otb #include "otbVcaImageFilter.txx" #endif /* otbVCAImageFilter_h */ OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/include/otbVcaImageFilter.txx000066400000000000000000000301041301006202600315120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVCAImageFilter_txx #define otbVCAImageFilter_txx #include "otbVcaImageFilter.h" #include "otbStandardWriterWatcher.h" namespace otb { template VCAImageFilter::VCAImageFilter() : m_NumberOfEndmembers(0) { } template VCAImageFilter::~VCAImageFilter() { } template void VCAImageFilter::GenerateOutputInformation() { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointers to the input and output typename VectorImageType::ConstPointer inputPtr = this->GetInput(); typename VectorImageType::Pointer outputPtr = this->GetOutput(); if ( !inputPtr || !outputPtr ) { return; } const unsigned int numberOfBands = inputPtr->GetNumberOfComponentsPerPixel(); RegionType outputRegion; IndexType outputOrigin; SizeType outputSize; outputOrigin.Fill(0); outputSize[0] = m_NumberOfEndmembers; outputSize[1] = 1; outputRegion.SetIndex(outputOrigin); outputRegion.SetSize(outputSize); outputPtr->SetLargestPossibleRegion( outputRegion ); outputPtr->SetNumberOfComponentsPerPixel( numberOfBands ); } template void VCAImageFilter::GenerateData() { typedef typename ForwardPCAImageFilterType::NormalizeFilterType NormalizeFilterType; VectorImageType* input = const_cast(this->GetInput()); const unsigned int nbBands = this->GetInput()->GetNumberOfComponentsPerPixel(); otbMsgDevMacro( "Computing image stats" ) typename StreamingStatisticsVectorImageFilterType::Pointer statsInput = StreamingStatisticsVectorImageFilterType::New(); statsInput->SetInput(input); statsInput->SetEnableMinMax(false); statsInput->Update(); double SNR, SNRth; vnl_matrix Ud; // SNR computation { vnl_matrix R = statsInput->GetCorrelation().GetVnlMatrix(); vnl_svd svd(R); vnl_matrix U = svd.U(); Ud = U.get_n_columns(0, m_NumberOfEndmembers); vnl_matrix Udt = Ud.transpose(); // To remove the mean typename NormalizeFilterType::Pointer normalize = NormalizeFilterType::New(); normalize->SetInput(input); normalize->SetMean(statsInput->GetMean()); normalize->SetUseMean(true); normalize->SetUseStdDev(false); typename MatrixImageFilterType::Pointer mulUd = MatrixImageFilterType::New(); mulUd->MatrixByVectorOn(); mulUd->SetInput(normalize->GetOutput()); mulUd->SetMatrix(Udt); mulUd->UpdateOutputInformation(); typename StreamingStatisticsVectorImageFilterType::Pointer transformedStats = StreamingStatisticsVectorImageFilterType::New(); transformedStats->SetInput(mulUd->GetOutput()); transformedStats->SetEnableMinMax(false); transformedStats->Update(); double P_R = nbBands * statsInput->GetComponentCorrelation(); double P_Rp = m_NumberOfEndmembers * transformedStats->GetComponentCorrelation() + statsInput->GetMean().GetSquaredNorm(); //const double qL = static_cast(m_NumberOfEndmembers) / nbBands; SNR = vcl_abs(10*vcl_log10( (P_Rp - (m_NumberOfEndmembers/nbBands)*P_R) / (P_R - P_Rp) )); } SNRth = 15.0 + 10.0 * vcl_log( static_cast(m_NumberOfEndmembers) ) + 8.0; typename VectorImageType::Pointer Xd; typename VectorImageType::Pointer Y; std::vector refHolder; typename ForwardPCAImageFilterType::Pointer pca = ForwardPCAImageFilterType::New(); typename NormalizeFilterType::Pointer normalize = NormalizeFilterType::New(); if (SNR > SNRth) { otbMsgDevMacro( "Using projective projection for dimensionnality reduction" ) otbMsgDevMacro( "Computing SVD of correlation matrix" ) // Take the correlation matrix vnl_matrix R = statsInput->GetCorrelation().GetVnlMatrix(); // Apply SVD vnl_svd svd(R); vnl_matrix U = svd.U(); Ud = U.get_n_columns(0, m_NumberOfEndmembers); vnl_matrix UdT = Ud.transpose(); otbMsgDevMacro( "Apply dimensionality reduction" ) // Xd = Ud.'*M; typename MatrixImageFilterType::Pointer mulUd = MatrixImageFilterType::New(); mulUd->MatrixByVectorOn(); mulUd->SetInput(this->GetInput()); mulUd->SetMatrix(UdT); mulUd->UpdateOutputInformation(); refHolder.push_back(mulUd.GetPointer()); Xd = mulUd->GetOutput(); // Compute mean(Xd) otbMsgDevMacro( "Compute mean(Xd)" ) typename StreamingStatisticsVectorImageFilterType::Pointer statsXd = StreamingStatisticsVectorImageFilterType::New(); statsXd->SetEnableSecondOrderStats(false); statsXd->SetInput(Xd); // statsXd->GetStreamer()->SetNumberOfDivisionsStrippedStreaming(10); statsXd->Update(); typename VectorImageType::PixelType Xdmean = statsXd->GetMean(); otbMsgDevMacro( "mean(Xd) = " << Xdmean) // Projective projection // Xd ./ repmat( sum( Xd .* repmat(u, [1 N]) ) , [d 1]); otbMsgDevMacro( "Compute projective projection" ) typename ProjectiveProjectionImageFilterType::Pointer proj = ProjectiveProjectionImageFilterType::New(); proj->SetInput(Xd); proj->SetProjectionDirection(Xdmean); refHolder.push_back(proj.GetPointer()); Xd = proj->GetOutput(); Y = Xd; } else { otbMsgDevMacro( "Using PCA for dimensionnality reduction" ) normalize->SetInput(input); normalize->SetMean(statsInput->GetMean()); normalize->SetUseMean(true); normalize->SetUseStdDev(false); // Take the correlation matrix vnl_matrix R = statsInput->GetCovariance().GetVnlMatrix(); // Apply SVD vnl_svd svd(R); vnl_matrix U = svd.U(); Ud = U.get_n_columns(0, m_NumberOfEndmembers - 1); vnl_matrix UdT = Ud.transpose(); typename MatrixImageFilterType::Pointer mulUd = MatrixImageFilterType::New(); mulUd->MatrixByVectorOn(); mulUd->SetInput(normalize->GetOutput()); mulUd->SetMatrix(UdT); mulUd->UpdateOutputInformation(); refHolder.push_back(mulUd.GetPointer()); Xd = mulUd->GetOutput(); typename VectorImageToAmplitudeImageFilterType::Pointer normComputer = VectorImageToAmplitudeImageFilterType::New(); normComputer->SetInput(Xd); typename StreamingMinMaxImageFilterType::Pointer maxNormComputer = StreamingMinMaxImageFilterType::New(); maxNormComputer->SetInput(normComputer->GetOutput()); maxNormComputer->Update(); typename ImageType::PixelType maxNorm = maxNormComputer->GetMaximum(); otbMsgDevMacro( "maxNorm : " << maxNorm) typename ConcatenateScalarValueImageFilterType::Pointer concat = ConcatenateScalarValueImageFilterType::New(); concat->SetInput(Xd); concat->SetScalarValue(maxNorm); refHolder.push_back(concat.GetPointer()); Y = concat->GetOutput(); Y->UpdateOutputInformation(); } // E : result, will contain the endmembers vnl_matrix E(nbBands, m_NumberOfEndmembers); // A = zeros(q, q) // A(q, 1) = 1 vnl_matrix A(m_NumberOfEndmembers, m_NumberOfEndmembers); A.fill(0); A(m_NumberOfEndmembers - 1, 0) = 1; typename RandomVariateGeneratorType::Pointer randomGen = RandomVariateGeneratorType::New(); for (unsigned int i = 0; i < m_NumberOfEndmembers; ++i) { otbMsgDevMacro( "----------------------------------------" ) otbMsgDevMacro( "Iteration " << i ) // w = rand(q, 1) otbMsgDevMacro( "Random vector generation " ) vnl_vector w(m_NumberOfEndmembers); for (unsigned int j = 0; j < w.size(); ++j) { w(j) = randomGen->GetVariateWithOpenRange(); } // f = ((I - A*pinv(A))*w) / (norm(I - A*pinv(A))*w)) otbMsgDevMacro( "f = ((I - A*pinv(A))*w) /(norm(I - A*pinv(A))*w))" ) vnl_matrix tmpMat(m_NumberOfEndmembers, m_NumberOfEndmembers); tmpMat.set_identity(); otbMsgDevMacro( "A" << std::endl << A ) vnl_svd Asvd(A); tmpMat -= A * Asvd.inverse(); vnl_vector tmpNumerator = tmpMat * w; vnl_vector f = tmpNumerator / tmpNumerator.two_norm(); // v = f.'*Y otbMsgDevMacro( "f = " << f ); otbMsgDevMacro( "v = f.'*Y" ); typename DotProductImageFilterType::Pointer dotfY = DotProductImageFilterType::New(); dotfY->SetInput(Y); typename VectorImageType::PixelType fV(f.data_block(), f.size()); dotfY->SetVector(typename VectorImageType::PixelType(fV)); typename ImageType::Pointer v = dotfY->GetOutput(); // abs(v) otbMsgDevMacro( "abs(v)" ); typename AbsImageFilterType::Pointer absVFilter = AbsImageFilterType::New(); absVFilter->SetInput(v); // max(abs(v)) otbMsgDevMacro( "max(abs(v))" ); typename StreamingMinMaxImageFilterType::Pointer maxAbs = StreamingMinMaxImageFilterType::New(); maxAbs->SetInput(absVFilter->GetOutput()); maxAbs->Update(); // k = arg_max( max(abs(v)) ) otbMsgDevMacro( "k = arg_max( max(abs(v)) )" ) IndexType maxIdx = maxAbs->GetMaximumIndex(); otbMsgDevMacro( "max : " << maxAbs->GetMaximum() ) otbMsgDevMacro( "maxIdx : " << maxIdx ) // extract Y(:, k) otbMsgDevMacro( "Y(:, k)" ) RegionType region; region.SetIndex( maxIdx ); SizeType size; size.Fill(1); region.SetSize(size); Y->SetRequestedRegion(region); Y->Update(); // store new endmember in A // A(:, i) = Y(:, k) otbMsgDevMacro( "A(:, i) = Y(:, k)" ) typename VectorImageType::PixelType e = Y->GetPixel(maxIdx); otbMsgDevMacro( "e = " << e ) A.set_column(i, e.GetDataPointer()); otbMsgDevMacro( "A" << std::endl << A ) // reproject new endmember in original space vnl_vector u; if (SNR > SNRth) { // u = Ud * Xd(:, k) otbMsgDevMacro( "u = Ud * Xd(:, k)" ) Xd->SetRequestedRegion(region); Xd->Update(); typename VectorImageType::PixelType xd = Xd->GetPixel(maxIdx); vnl_vector xdV(xd.GetDataPointer(), xd.GetSize()); u = Ud * xdV; } else { // u = invPCA( Xd(:, k) ) otbMsgDevMacro( "u = Ud * Xd(:, k)" ) Xd->SetRequestedRegion(region); Xd->Update(); typename VectorImageType::PixelType xd = Xd->GetPixel(maxIdx); vnl_vector xdV(xd.GetDataPointer(), xd.GetSize()); //Ud = pca->GetTransformationMatrix().GetVnlMatrix().transpose(); vnl_vector mean(statsInput->GetMean().GetDataPointer(), statsInput->GetMean().GetSize()); u = Ud * xdV + mean; } // E(:, i) = u otbMsgDevMacro( "E(:, i) = u" ) otbMsgDevMacro( "u = " << u ) E.set_column(i, u); } typename VectorImageType::Pointer output = this->GetOutput(); output->SetRegions(output->GetLargestPossibleRegion()); //output->SetNumberOfComponentsPerPixel(input->GetNumberOfComponentsPerPixel()); output->Allocate(); itk::ImageRegionIteratorWithIndex it(output, output->GetLargestPossibleRegion()); unsigned int i; for (it.GoToBegin(), i = 0; !it.IsAtEnd(); ++it, ++i) { vnl_vector e = E.get_column(i); typename VectorImageType::PixelType pixel(input->GetNumberOfComponentsPerPixel()); for (unsigned int j = 0; j < e.size(); ++j) { pixel[j] = E(j, i); } it.Set(pixel); } } /** * Standard "PrintSelf" method */ template void VCAImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf( os, indent ); } } //end namespace otb #endif OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/include/otbVirtualDimensionality.h000066400000000000000000000072561301006202600326470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT2ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVirtualDimensionality_h #define otbVirtualDimensionality_h #include "itkObjectFactory.h" #include "itkLightObject.h" #include "vnl/vnl_vector.h" #include "vnl/vnl_matrix.h" #include "vnl/algo/vnl_symmetric_eigensystem.h" namespace otb { /** \class VirtualDimensionality * \brief Estimates the number of endmembers in a hyperspectral image * with the Virtual Dimensionality method * * This filter applies the VD (Virtual Dimensionality) algorithm to an * hyperspectral image and outputs the number of endmembers. * It takes as input the covariance and correlation matrices of the input data, * the number of observed pixel for thoses matrices estimations, * and outputs the number of endmembers, and the log-likelihood. * * References : * C.-I. Chang and Q. Du, "Estimation of number of spectrally distinct * signal sources in hyperspectral imagery", IEEE Transactions on * Geoscience and Remote Sensing, vol. 43, no. 3, mar 2004. * J. Wang and C.-I. Chang, "Applications of independent component * analysis in endmember extraction and abundance quantification for * hyperspectral imagery", IEEE Transactions on Geoscience and Remote * Sensing, vol. 44, no. 9, pp. 2601-1616, sep 2006. * * \ingroup Hyperspectral * * \ingroup OTBEndmembersExtraction */ template class ITK_EXPORT VirtualDimensionality : public itk::LightObject { public: /** Standard Self typedef */ typedef VirtualDimensionality Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(VirtualDimensionality, itk::LightObject); /** Types to use for computations. */ typedef TPrecision PrecisionType; typedef vnl_vector VectorType; typedef vnl_matrix MatrixType; void SetCovariance(const MatrixType& m) { m_Covariance = m; } void SetCorrelation(const MatrixType& m) { m_Correlation = m; } void SetNumberOfPixels(unsigned int n) { m_NumberOfPixels = n; } void SetFAR(double falseAlarmRate) { if (falseAlarmRate < 0) falseAlarmRate = 0; if (falseAlarmRate > 1) falseAlarmRate = 1; m_FAR = falseAlarmRate; } double GetFAR() { return m_FAR; } void Compute(); unsigned int GetNumberOfEndmembers() { return m_NumberOfEndmembers; } protected: VirtualDimensionality(); ~VirtualDimensionality() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: VirtualDimensionality(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented MatrixType m_Covariance; MatrixType m_Correlation; unsigned int m_NumberOfPixels; unsigned int m_NumberOfEndmembers; double m_FAR; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbVirtualDimensionality.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/include/otbVirtualDimensionality.txx000066400000000000000000000047661301006202600332460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVirtualDimensionality_txx #define otbVirtualDimensionality_txx #include "otbVirtualDimensionality.h" #include #include "otb_boost_math_normal_header.h" namespace otb { template VirtualDimensionality ::VirtualDimensionality() : m_NumberOfPixels(0), m_NumberOfEndmembers(0), m_FAR(1.0E-3) { } template void VirtualDimensionality ::Compute() { // TODO check size const unsigned int nbBands = m_Covariance.rows(); // Compute diagonalisation of sample covariance and correlation matrices vnl_symmetric_eigensystem eigenK(m_Covariance); VectorType eigenCovariance = eigenK.D.diagonal(); vcl_sort(eigenCovariance.begin(), eigenCovariance.end()); eigenCovariance.flip(); vnl_symmetric_eigensystem eigenR(m_Correlation); VectorType eigenCorrelation = eigenR.D.diagonal(); vcl_sort(eigenCorrelation.begin(), eigenCorrelation.end()); eigenCorrelation.flip(); m_NumberOfEndmembers = 0; for(unsigned int i = 0; i < nbBands; ++i) { double sigma = vcl_sqrt( 2.0 / m_NumberOfPixels * (eigenCovariance[i] + eigenCorrelation[i] + eigenCovariance[i] * eigenCorrelation[i]) ); boost::math::normal normalDist(0, sigma); double tau = -boost::math::quantile(normalDist, m_FAR); if (eigenCorrelation[i] - eigenCovariance[i] > tau ) m_NumberOfEndmembers++; } } template void VirtualDimensionality ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Covariance: " << m_Covariance << std::endl; os << indent << "Correlation: " << m_Correlation << std::endl; os << indent << "NumberOfEndmembers: " << m_NumberOfEndmembers << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/otb-module.cmake000066400000000000000000000006321301006202600270470ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes related to he extraction of end members (see also 'unmixing' module).") otb_module(OTBEndmembersExtraction DEPENDS OTBStatistics OTBITK OTBImageBase OTBDimensionalityReduction OTBImageManipulation OTBProjection OTBBoostAdapters OTBCommon TEST_DEPENDS OTBTestKernel OTBImageIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/test/000077500000000000000000000000001301006202600247545ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/test/CMakeLists.txt000066400000000000000000000037201301006202600275160ustar00rootroot00000000000000otb_module_test() set(OTBEndmembersExtractionTests otbEndmembersExtractionTestDriver.cxx otbEigenvalueLikelihoodMaximization.cxx otbVirtualDimensionality.cxx otbVCAImageFilter.cxx ) add_executable(otbEndmembersExtractionTestDriver ${OTBEndmembersExtractionTests}) target_link_libraries(otbEndmembersExtractionTestDriver ${OTBEndmembersExtraction-Test_LIBRARIES}) otb_module_target_label(otbEndmembersExtractionTestDriver) # Tests Declaration otb_add_test(NAME hyTvEigenvalueLikelihoodMaximizationTest COMMAND otbEndmembersExtractionTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/hyTvEigenvalueLikelihoodMaximizationTest.txt ${TEMP}/hyTvEigenvalueLikelihoodMaximizationTest.txt otbEigenvalueLikelihoodMaximizationTest ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${TEMP}/hyTvEigenvalueLikelihoodMaximizationTest.txt) otb_add_test(NAME hyTuEigenvalueLikelihoodMaximizationNew COMMAND otbEndmembersExtractionTestDriver otbEigenvalueLikelihoodMaximizationNewTest) otb_add_test(NAME hyTuVirtualDimensionalityNew COMMAND otbEndmembersExtractionTestDriver otbVirtualDimensionalityNewTest) otb_add_test(NAME hyTvVirtualDimensionalityTest COMMAND otbEndmembersExtractionTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/hyTvVirtualDimensionalityTest.txt ${TEMP}/hyTvVirtualDimensionalityTest.txt otbVirtualDimensionalityTest ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${TEMP}/hyTvVirtualDimensionalityTest.txt 1E-3) otb_add_test(NAME hyTvVCAImageFilterTest1 COMMAND otbEndmembersExtractionTestDriver --compare-image ${EPSILON_9} ${BASELINE}/TvHyVertexComponentAnalysisImage.tif ${TEMP}/hyTvVCAImageFilterTest.tif otbVCAImageFilterTestHighSNR ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${TEMP}/hyTvVCAImageFilterTest.tif 5 ) otb_add_test(NAME hyTuVCAImageFilterNew COMMAND otbEndmembersExtractionTestDriver otbVCAImageFilterNew ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${TEMP}/synthetic_vca_5.hdr 5 ) otbEigenvalueLikelihoodMaximization.cxx000066400000000000000000000044571301006202600346220ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbEigenvalueLikelihoodMaximisation.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbStreamingStatisticsVectorImageFilter.h" const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef otb::EigenvalueLikelihoodMaximisation ELMType; int otbEigenvalueLikelihoodMaximizationNewTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { ELMType::Pointer elm = ELMType::New(); std::cout << elm << std::endl; return EXIT_SUCCESS; } int otbEigenvalueLikelihoodMaximizationTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; StreamingStatisticsVectorImageFilterType::Pointer stats = StreamingStatisticsVectorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); stats->SetInput(reader->GetOutput()); stats->Update(); ELMType::Pointer elm = ELMType::New(); elm->SetCovariance(stats->GetCovariance().GetVnlMatrix()); elm->SetCorrelation(stats->GetCorrelation().GetVnlMatrix()); elm->SetNumberOfPixels(reader->GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels()); elm->Compute(); std::ofstream file; file.open(outfname); file.precision(5); file << "Number of Endmembers: " << elm->GetNumberOfEndmembers() << std::endl; file << "Likelihood: " << elm->GetLikelihood() << std::endl; file.close(); std::cout << "Number of Endmembers: " << elm->GetNumberOfEndmembers() << std::endl; std::cout << "Likelihood: " << elm->GetLikelihood() << std::endl; return EXIT_SUCCESS; } otbEndmembersExtractionTestDriver.cxx000066400000000000000000000005401301006202600342630ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/test#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbEigenvalueLikelihoodMaximizationNewTest); REGISTER_TEST(otbEigenvalueLikelihoodMaximizationTest); REGISTER_TEST(otbVirtualDimensionalityNewTest); REGISTER_TEST(otbVirtualDimensionalityTest); REGISTER_TEST(otbVCAImageFilterNew); REGISTER_TEST(otbVCAImageFilterTestHighSNR); } OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/test/otbVCAImageFilter.cxx000066400000000000000000000035051301006202600307320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVcaImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" const unsigned int Dimension = 2; typedef double PixelType; typedef double PrecisionType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::VCAImageFilter VCAFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; int otbVCAImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { VCAFilterType::Pointer vca = VCAFilterType::New(); std::cout << vca << std::endl; return EXIT_SUCCESS; } int otbVCAImageFilterTestHighSNR(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const char * outputImage = argv[2]; const unsigned int nbEndmembers = atoi(argv[3]); ReaderType::Pointer readerImage = ReaderType::New(); readerImage->SetFileName(inputImage); VCAFilterType::Pointer vca = VCAFilterType::New(); vca->SetNumberOfEndmembers(nbEndmembers); vca->SetInput(readerImage->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImage); writer->SetInput(vca->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/EndmembersExtraction/test/otbVirtualDimensionality.cxx000066400000000000000000000044761301006202600325570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVirtualDimensionality.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbStreamingStatisticsVectorImageFilter.h" const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingStatisticsVectorImageFilter StreamingStatisticsVectorImageFilterType; typedef otb::VirtualDimensionality VDType; int otbVirtualDimensionalityNewTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { VDType::Pointer vd = VDType::New(); std::cout << vd << std::endl; return EXIT_SUCCESS; } int otbVirtualDimensionalityTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; StreamingStatisticsVectorImageFilterType::Pointer stats = StreamingStatisticsVectorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); stats->SetInput(reader->GetOutput()); stats->Update(); VDType::Pointer vd = VDType::New(); vd->SetCovariance(stats->GetCovariance().GetVnlMatrix()); vd->SetCorrelation(stats->GetCorrelation().GetVnlMatrix()); vd->SetNumberOfPixels(reader->GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels()); std::ofstream file; file.open(outfname); file.precision(5); for (int i = 2; i < 10; ++i) { double falseAlarmRate = vcl_pow(static_cast(10), static_cast(-i)); vd->SetFAR(falseAlarmRate); vd->Compute(); std::cout << "FAR : 1E-" << i << " -> Nb Endmembers: " << vd->GetNumberOfEndmembers() << std::endl; file << "FAR : 1E-" << i << " -> Nb Endmembers: " << vd->GetNumberOfEndmembers() << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/Unmixing/000077500000000000000000000000001301006202600214515ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/Unmixing/CMakeLists.txt000066400000000000000000000000471301006202600242120ustar00rootroot00000000000000project(OTBUnmixing) otb_module_impl() OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/000077500000000000000000000000001301006202600230745ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbISRAUnmixingImageFilter.h000066400000000000000000000121301301006202600303350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbISRAUnmixingImageFilter_h #define otbISRAUnmixingImageFilter_h #include "itkNumericTraits.h" #include "otbUnaryFunctorImageFilter.h" #include "vnl/algo/vnl_svd.h" #include namespace otb { namespace Functor { /** \class ISRAUnmixingFunctor * * \brief TODO * * * \ingroup OTBUnmixing */ template class ISRAUnmixingFunctor { public: typedef ISRAUnmixingFunctor Self; typedef TInput InputType; typedef TOutput OutputType; typedef TPrecision PrecisionType; typedef vnl_vector VectorType; typedef vnl_matrix MatrixType; ISRAUnmixingFunctor(); virtual ~ISRAUnmixingFunctor(); unsigned int GetOutputSize() const; bool operator !=(const ISRAUnmixingFunctor& other) const; bool operator ==(const ISRAUnmixingFunctor& other) const; void SetEndmembersMatrix(const MatrixType& U); const MatrixType& GetEndmembersMatrix(void) const; void SetMaxIteration(unsigned int val) { m_MaxIteration = val; } unsigned int GetMaxIteration() const { return m_MaxIteration; } OutputType operator ()(const InputType& in) const; private: static bool IsNonNegative(PrecisionType val) { return val >= 0; } typedef vnl_svd SVDType; typedef boost::shared_ptr SVDPointerType; MatrixType m_U; SVDPointerType m_Svd; // SVD of U unsigned int m_OutputSize; unsigned int m_MaxIteration; }; } /** \class ISRAUnmixingImageFilter * * \brief Performs fully constrained least squares on each pixel of a VectorImage * * This filter takes as input a multiband image and a matrix. * If the matrix is called \f$A\f$, it solves, for each pixel \f$p\f$, the system * \f$A \cdot x = p\f$ in the least square sense, with additional constraints on the solution * \f$\hat{x}\f$ ensuring positivity (each component is positive) and additivity (the sum of * all components is 1). * * The main use of this filter is to unmix an hyperspectral dataset, * where \f$A\f$ is the mixing matrix, in which each row corresponds to an endmember signature. * * The number of rows in \f$A\f$ must match the input image number of bands. * The number of bands in the output image will be the number of columns of $A$ * * References * "Fully Constrained Least-Squares Based Linear Unmixing." Daniel Heinz, * Chein-I Chang, and Mark L.G. Althouse. IEEE. 1999. * * \ingroup Hyperspectral * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBUnmixing */ template class ITK_EXPORT ISRAUnmixingImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef ISRAUnmixingImageFilter Self; typedef otb::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Functor::ISRAUnmixingFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType, TPrecision> FunctorType; typedef typename FunctorType::MatrixType MatrixType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ISRAUnmixingImageFilter, otb::UnaryFunctorImageFilter); /** Pixel types. */ typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; void SetEndmembersMatrix(const MatrixType& m); const MatrixType& GetEndmembersMatrix() const; void SetMaxIteration( unsigned int val ) { this->GetFunctor().SetMaxIteration(val); this->Modified(); } unsigned int GetMaxIteration() const { return this->GetFunctor().GetMaxIteration(); } protected: ISRAUnmixingImageFilter(); ~ISRAUnmixingImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ISRAUnmixingImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbISRAUnmixingImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbISRAUnmixingImageFilter.txx000066400000000000000000000112461301006202600307400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbISRAUnmixingImageFilter_txx #define otbISRAUnmixingImageFilter_txx #include "otbISRAUnmixingImageFilter.h" #include namespace otb { namespace Functor { template ISRAUnmixingFunctor ::ISRAUnmixingFunctor() : m_OutputSize(0), m_MaxIteration(100) { } template ISRAUnmixingFunctor ::~ISRAUnmixingFunctor() { } template unsigned int ISRAUnmixingFunctor ::GetOutputSize() const { return m_OutputSize; } template bool ISRAUnmixingFunctor ::operator != (const Self& itkNotUsed(other)) const { return true; } template bool ISRAUnmixingFunctor ::operator == (const Self& itkNotUsed(other)) const { return false; } template void ISRAUnmixingFunctor ::SetEndmembersMatrix(const MatrixType& U) { m_U = U; m_OutputSize = m_U.cols(); m_Svd.reset( new SVDType(m_U) ); } template const typename ISRAUnmixingFunctor::MatrixType& ISRAUnmixingFunctor ::GetEndmembersMatrix() const { return m_U; } template typename ISRAUnmixingFunctor::OutputType ISRAUnmixingFunctor ::operator ()(const InputType& in) const { // TODO : support different types between input and output ? VectorType inVector(in.Size()); for (unsigned int i = 0; i < in.GetSize(); ++i ) { inVector[i] = in[i]; } // Initialize with Unconstrained Least Square solution VectorType outVector = m_Svd->solve(inVector); unsigned int nbEndmembers = m_OutputSize; unsigned int nbBands = in.Size(); // Apply ISRA iterations for (unsigned int i = 0; i < m_MaxIteration; ++i) { // Use a temporary storage since it is used // inside the iterations VectorType outVectorNew = outVector; for (unsigned int e = 0; e < nbEndmembers; ++e) { PrecisionType numerator = 0; PrecisionType denominator = 0; for (unsigned int b = 0; b < nbBands; ++b) { numerator += in[b] * m_U(b, e); PrecisionType dot = 0; for (unsigned int s = 0; s < nbEndmembers; ++s) { // Use outVector from previous iteration here dot += m_U(b, s) * outVector[s]; } denominator += dot * m_U(b, e); } outVectorNew[e] *= (numerator/denominator); } // Prepare for next iteration outVector = outVectorNew; } OutputType out(outVector.size()); for (unsigned int i = 0; i < out.GetSize(); ++i ) { out[i] = outVector[i]; } return out; } } template ISRAUnmixingImageFilter ::ISRAUnmixingImageFilter() { } template ISRAUnmixingImageFilter ::~ISRAUnmixingImageFilter() { } template void ISRAUnmixingImageFilter ::SetEndmembersMatrix(const MatrixType& m) { this->GetFunctor().SetEndmembersMatrix(m); this->Modified(); } template const typename ISRAUnmixingImageFilter::MatrixType& ISRAUnmixingImageFilter ::GetEndmembersMatrix() const { return this->GetFunctor().GetEndmembersMatrix(); } template void ISRAUnmixingImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbMDMDNMFImageFilter.h000066400000000000000000000254411301006202600271530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMDMDNMFImageFilter_h #define otbMDMDNMFImageFilter_h #include "itkImageToImageFilter.h" #include "otbVectorImageToMatrixImageFilter.h" #include "vnl/vnl_matrix.h" #include "vnl/vnl_vector.h" namespace otb { /** \class otbMDMDNMFImageFilter * \brief This filter implements unmixing based non negative matrix factorization (NMF) which * finds simultaneously the end members and abundances matrix which * product is the closer to the observed data, based on the following * works: * K. S. F.J. Theis and T. Tanaka, First results on uniqueness of sparse non-negative matrix factorisation. * M. G. A. Huck and J. Blanc-Talon, IEEE TGRS, vol. 48, no. 6, pp. 2590-2602, 2010. * A. Huck and M. Guillaume, in WHISPERS, 2010, Grenoble. * * Let \f$ \mathbf R \f$ be the matrix of the hyperspectral data, whose * \f$ I \f$ columns are the * spectral pixels and the \f$ L \f$ rows are the vectorial spectral band * images. The linear mixing model can be written as follow : * \f$ \begin{equation} * \mathbf R=\mathbf A \mathbf S + \mathbf N= \mathbf X + \mathbf N * \end{equation} \f$ * The \f$ I \f$ columns of \f$ \mathbf R \f$ contain the spectral pixels * and the \f$ I \f$ columns of \f$ \mathbf S \f$ hold their respective sets of abundance * fractions. The \f$ J \f$ rows of \f$ \mathbf S \f$ are the abundance maps * corresponding to the respective end-members. The \f$ J \f$ columns of * \f$ \mathbf A \f$ are the end members spectra, and \f$ \mathbf X \f$ is the signal * matrix. Both \f$ \mathbf A \f$ and \f$ \mathbf S \f$ are unknown. * * The basic NMF formulation is to find two matrices \f$ \hat{\mathbf A} \f$ and * \f$ \hat{ \mathbf S} \f$ such as: * \f$ \begin{equation} * \mathbf X\simeq \hat{\mathbf A} \hat{\mathbf S} * \end{equation} \f$ * NMF based algorithms consider the * properties of the dual spaces \f$ span^+(\mathbf A')\f$ and * \f$ span^+(\mathbf S) \f$, in * which \f$ span^+(\mathbf hbf m^1 ...\mathbf hbf m^d)=\{\mathbf hbf v=\sum_i \mathbf hbf * m^i\mathbf hbf a_i|\mathbf hbf a\in \mathbf R _+^d\} \f$. The * positiveness is then a fundamental assumption and is exploited to * restrict the admissible solutions set. * * A common used solution is to minimize the reconstruction quadratic * error : * \f$ RQE({\mathbf A}, {\mathbf S})=\|\mathbf R-{\mathbf A} {\mathbf S}\|^2_F \f$. In order to * satisfy the sum-to-one constraint for hyperspectral data, a * regularization term \f$ STU({\mathbf S}) \f$ can be added to the objective * function. * * A generic expression for the optimized function is \f$ * f(\mathbf A,\mathbf S)=\|\mathbf A \mathbf S-\mathbf R\|_{norm}+\sum_i \lambda_i * D_i(\mathbf A) + \sum_j \lambda_j D_j(\mathbf S) \f$ in which \f$ \|\mathbf A * \mathbf S-\mathbf R\|_{norm} \f$ is the connection-to-the-data term, and * \f$ \lambda_{\{i, j\}} \f$ are regularization parameters for end members and * abundances constraints \f$ D_{\{i, j\}} \f$. * Huck * propose an other regularization term, * \f$ D_A(\mathbf A)=Tr(\mathbf A^T\mathbf A)-\frac{1}{L}Tr\left ( \mathbf A^T \1_{LL}\mathbf A * \right) \f$, which ensures low spectral dispersion on endmembers. * The physical * motivation is based on the assuption that in most situations, the * whole set of pure materials do not appear in each pixel, but * selectively in multiple piece-wise convex sets. As a consequence, the mean value of the abundance, * \f$ \frac{1}{J} \f$, is the least likely one. The maximum abundance * dispersion condition is given by * \f$ D_s(\mathbf S)=-\|\mathbf S-\frac{1}{J}\1_{JI}\|^2_F \f$. MDMD-NMF algorithm * minimizes the following function \f$ f(\mathbf A,\mathbf S) =RQE(\mathbf A, * \mathbf S)+\delta.STU(\mathbf S)+\lambda_A D_A(\mathbf A)-\lambda_S D_S(\mathbf S) * \f$, * \f$ STU \f$ the sum-to-one constraint. * * In the literature, NMF based optimization algorithms are mainly based * on multiplicative rules, or else alternate gradient descent * iterations, or else on alternate least square methods. In MDMD-NMF, the update rules * at each iteration become : * \f$ \begin{tabular} * \mathbf S&\leftarrow &P\left [\mathbf S-\mu_S \left( \bar \mathbf A^T * (\bar\mathbf A\mathbf S-\bar\mathbf R)-\lambda_S(\mathbf S-\frac{1}{J}\1_{JI})\right)\right * ]\\ \nonumber \mathbf A &\leftarrow &P\left [\mathbf A-\mu_A \left( * (\mathbf A\mathbf S-\mathbf R)\mathbf S^T +\lambda_A(\mathbf A-\frac{1}{L}\ \mathbf hbf * 1_{LL}\mathbf A)\right)\right ] * \end{tabular} \f$ * where \f$ \mu_A\f$ and \f$\mu_S \f$ * are the step sizes. * Huck propose a * multiscale method to determine the coefficients \f$ \mu_A \f$ and * \f$ \mu_S \f$. The projection operator \f$ P \f$ at each step ensures the * positivity constraint for \f$ \mathbf A \f$ and \f$ \mathbf S \f$, and \f$ * \bar\mathbf R \f$ and * \f$ \bar\mathbf A \f$ include the sum-to-one constraint: * \f$ \bar\mathbf R=\left[ * \begin{array}{c} \mathbf R \\ * \delta\cdot\1_{1I}\end{array}\right],\enspace \bar\mathbf A=\left[ * \begin{array}{c} \mathbf A \\ * \delta\cdot\1_{1J}\end{array}\right]\enspace \f$. * * \ingroup ImageFilters * * \ingroup OTBUnmixing */ template class ITK_EXPORT MDMDNMFImageFilter: public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef MDMDNMFImageFilter Self; typedef itk::ImageToImageFilter< TInputImage, TOutputImage > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(MDMDNMFImageFilter, ImageToImageFilter); /** typedef related to input and output images */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputPointerType; typedef typename InputImageType::ConstPointer InputConstPointerType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputPointerType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::OffsetType OutputOffsetType; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; /* Matrix type */ typedef double PrecisionType; typedef vnl_matrix MatrixType; typedef typename otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; /* vector type */ typedef vnl_vector VectorType; MatrixType GetEndmembersMatrix() const { return m_Endmembers; } void SetEndmembersMatrix(const MatrixType& m) { m_Endmembers = m; } /** Setters / Getters */ itkSetMacro(MaxIter, unsigned int); itkGetMacro(MaxIter, unsigned int); itkSetMacro(CritStopValue, double); itkGetMacro(CritStopValue, double); itkSetMacro(Delt, double); itkGetMacro(Delt, double); itkSetMacro(LambdD, double); itkGetMacro(LambdD, double); itkSetMacro(LambdS, double); itkGetMacro(LambdS, double); protected: MDMDNMFImageFilter(); ~MDMDNMFImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; /** GenerateOutputInformation * Propagate vector length info and modify if needed */ void GenerateOutputInformation() ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; private: MDMDNMFImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented static void AddOneRowOfOnes(const MatrixType & m, MatrixType & M); static double Criterion(const MatrixType & X, const MatrixType & A, const MatrixType & S, const double &delt, const double &lambdS, const double &lambdD); static void EvalGradS(const MatrixType &X, const MatrixType &A, const MatrixType &S, const double &delt, const double &lambdS, MatrixType & gradS); static void EvalGradA(const MatrixType &X, const MatrixType &A, const MatrixType &S, const double &delt, const double &lambdD, MatrixType &gradA); static double Call(const MatrixType & variMat, const MatrixType & fixedMat, const MatrixType & X, const double & delt, const double & lambdS, const double & lambdD, const bool isDirectEvalDirection); static void ProjGradOneStep( const MatrixType & X, const MatrixType & fixedMat, const MatrixType & gradVariMat, const double & sig, const double & betinit, const double & delt, const double & lambdS, const double & lambdD, MatrixType & variMat, double & alph, const bool isDirectEvalDirection ); static void SetNegativeCoefficientsToZero(MatrixType & M); static MatrixType TermByTermMatrixProduct(const MatrixType & M1, const MatrixType & M2); static double SumMatrixElements(const MatrixType & M); static bool ArmijoTest(const double & sig, const MatrixType variMat, const MatrixType & newVariMat, const double & evalf, const double & newEvalf, const MatrixType & gradVariMat, const double & alph); // attributes MatrixType m_Endmembers; unsigned int m_MaxIter; double m_CritStopValue; // Optimized function parameters double m_Delt; double m_LambdD; double m_LambdS; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMDMDNMFImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbMDMDNMFImageFilter.txx000066400000000000000000000415651301006202600275540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMDMDNMFImageFilter_txx #define otbMDMDNMFImageFilter_txx #include "otbMDMDNMFImageFilter.h" namespace otb { template MDMDNMFImageFilter ::MDMDNMFImageFilter() { m_MaxIter = 100; m_CritStopValue = 00.5; m_Delt = 1.; m_LambdD = 0.01; m_LambdS = 0.01; } /** * */ template void MDMDNMFImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Input Endmembers Matrix: " << m_Endmembers << std::endl; } template void MDMDNMFImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); const unsigned int nbEndmembers = m_Endmembers.columns(); if ( nbEndmembers != 0 ) { this->GetOutput()->SetNumberOfComponentsPerPixel(m_Endmembers.columns()); } else { throw itk::ExceptionObject(__FILE__, __LINE__, "Endmembers matrix columns size required to know the output size", ITK_LOCATION); } } template void MDMDNMFImageFilter ::AddOneRowOfOnes(const MatrixType & m, MatrixType & M) { M.set_size(m.rows()+1, m.cols()); for (unsigned int i=0; i double MDMDNMFImageFilter ::Criterion(const MatrixType & X, const MatrixType & A, const MatrixType & S, const double &itkNotUsed(m_Delt), const double &m_LambdS, const double &m_LambdD) { // This function computes // f = ||Xsu-Asu.S||_2^2 - // m_LambdS * ||1/J*ones - S||_2^2 + // m_LambdD * (trace(transpose(A)*A)-1/L*trace(transpose(A).ones.A)); // // = ||E1||_2^2 - // m_LambdS * ||E2||_2^2 + // m_LambdD * (trace(A'*A)-1/L*trace(E3); // // where || ||_2 is the L2 frobenius_norm, // J is the number of endmembers and // L is the number of spectral bands const unsigned int nbEndmembers = A.cols(); const unsigned nbBands = A.rows(); MatrixType Xsu, Asu, ones, E1, E2; //, E3; double evalf, sumColsOfA, trE3; Xsu.set_size(X.rows()+1, X.cols()); Asu.set_size(A.rows()+1, A.cols()); AddOneRowOfOnes(A, Asu); AddOneRowOfOnes(X, Xsu); //------- Computing the function blocs E1, E2 and E3 -------// // Bloc 1 E1 = Xsu - Asu*S; // Bloc 2 E2 = S - 1./ ((double) nbEndmembers); // * ones - S; // Computing trace(transpose(A)*A) double trAtA = 0; for (unsigned int i=0; i (nbBands)) * trE3)); return evalf; } template void MDMDNMFImageFilter ::EvalGradS(const MatrixType &X, const MatrixType &A, const MatrixType &S, const double &itkNotUsed(m_Delt), const double &m_LambdS, MatrixType & gradS) { // Calculus of: gradS = 2 * Asu' * (Asu*S-Xsu) - lambd * 2 * (S - 1/J*ones(J, I)); MatrixType Xsu, Asu; Xsu.set_size(X.rows()+1, X.cols()); Asu.set_size(A.rows()+1, A.cols()); AddOneRowOfOnes(A, Asu); AddOneRowOfOnes(X, Xsu); gradS = 2. * Asu.transpose() * (Asu*S-Xsu) - m_LambdS * 2. * (S - (1./(static_cast( S.rows() )))); } template void MDMDNMFImageFilter ::EvalGradA(const MatrixType &X, const MatrixType &A, const MatrixType &S, const double &itkNotUsed(m_Delt), const double &m_LambdD, MatrixType &gradA) { // Compute gradA // = (A*S-X) * (transpose(S)) + m_LambdD*(A-1/nbBands*ones(L, L)*A) // = (A*S-X) * (transpose(S)) + m_LambdD*A- m_LambdD*/nbBands*ones(L, L)*A) VectorType sumColulmnsOfA; sumColulmnsOfA.set_size(A.cols()); unsigned int nbBands = A.rows(); // Computing ones*A : all rows are the same, // (ones*A)[i,j] = sum(k=0 to nbBands, A[k,j]) for (unsigned int j=0; j( nbBands ) ) ) ); } } template void MDMDNMFImageFilter ::ProjGradOneStep( const MatrixType & X, const MatrixType & fixedMat, const MatrixType & gradVariMat, const double & sig, const double & betinit, const double & m_Delt, const double & m_LambdS, const double & m_LambdD, MatrixType & variMat, double & alph, const bool isDirectEvalDirection ) { double evalf, newEvalf, bet; evalf = Call(variMat, fixedMat, X, m_Delt, m_LambdS, m_LambdD, isDirectEvalDirection); // compute evalf MatrixType newVariMat = variMat - alph*gradVariMat; SetNegativeCoefficientsToZero(newVariMat); newEvalf = Call(newVariMat, fixedMat, X, m_Delt, m_LambdS, m_LambdD, isDirectEvalDirection); // compute newEvalf bool bit = ArmijoTest(sig, variMat, newVariMat, evalf, newEvalf, gradVariMat, alph); int count = 1; if (bit == true) { while (bit == true) { bet = pow(betinit, count); alph = alph/bet; newVariMat = variMat - alph*gradVariMat; SetNegativeCoefficientsToZero(newVariMat); newEvalf = Call(newVariMat, fixedMat, X, m_Delt, m_LambdS, m_LambdD, isDirectEvalDirection); bit = ArmijoTest(sig, variMat, newVariMat, evalf, newEvalf, gradVariMat, alph); ++count; } alph = alph*bet; newVariMat = variMat - alph*gradVariMat; SetNegativeCoefficientsToZero(newVariMat); } else { while (bit == false) { bet = pow(betinit, count); alph = alph*bet; newVariMat = variMat - alph*gradVariMat; SetNegativeCoefficientsToZero(newVariMat); newEvalf = Call(newVariMat, fixedMat, X, m_Delt, m_LambdS, m_LambdD, isDirectEvalDirection); bit = ArmijoTest(sig, variMat, newVariMat, evalf, newEvalf, gradVariMat, alph); ++count; } } variMat = newVariMat; } template double MDMDNMFImageFilter ::Call(const MatrixType & variMat, const MatrixType & fixedMat, const MatrixType & X, const double & m_Delt, const double & m_LambdS, const double & m_LambdD, const bool isDirectEvalDirection) { double evalf; if ( isDirectEvalDirection ) { evalf = Criterion(X, variMat, fixedMat, m_Delt, m_LambdS, m_LambdD); } else { evalf = Criterion(X, fixedMat, variMat, m_Delt, m_LambdS, m_LambdD); } return evalf; } template void MDMDNMFImageFilter ::SetNegativeCoefficientsToZero(MatrixType & M) { for (unsigned int i=0; i typename MDMDNMFImageFilter ::MatrixType MDMDNMFImageFilter ::TermByTermMatrixProduct(const MatrixType & M1, const MatrixType & M2) { MatrixType M; M.set_size(M1.rows(), M1.cols()); for (unsigned int i=0; i double MDMDNMFImageFilter ::SumMatrixElements(const MatrixType & M) { double sum = 0; for (unsigned int i = 0; i bool MDMDNMFImageFilter ::ArmijoTest(const double & sig, const MatrixType variMat, const MatrixType & newVariMat, const double & evalf, const double & newEvalf, const MatrixType & gradVariMat, const double & alph) { bool bit; //const unsigned int I = variMat.rows(); //const unsigned int J = variMat.cols(); const MatrixType prod = TermByTermMatrixProduct(gradVariMat, newVariMat-variMat); double sumProd = SumMatrixElements(prod); if (newEvalf-evalf <= sig*alph*sumProd) bit = true; else bit = false; return bit; } /** * */ template void MDMDNMFImageFilter ::GenerateData() { this->AllocateOutputs(); // Get the input and output pointers InputPointerType inputPtr = const_cast< InputImageType * >( this->GetInput()); OutputPointerType outputPtr = this->GetOutput(); inputPtr->Update(); // Fill the output buffer with black pixels OutputPixelType zero = OutputPixelType(); itk::NumericTraits::SetLength(zero, outputPtr->GetNumberOfComponentsPerPixel()); outputPtr->FillBuffer(zero); //Adaptation of contribution from A. Huck //Convert input image into matrix typename VectorImageToMatrixImageFilterType::Pointer inputImage2Matrix = VectorImageToMatrixImageFilterType::New(); inputImage2Matrix->SetInput(inputPtr); inputImage2Matrix->Update(); //useful const variables const unsigned int nbEndmembers = m_Endmembers.columns(); const unsigned int nbComponentsPerPixel = inputPtr->GetNumberOfComponentsPerPixel(); const unsigned int nbPixels = inputPtr->GetLargestPossibleRegion().GetNumberOfPixels(); // otbGenericMsgDebugMacro( << "nbEndmembers " << nbEndmembers ); // otbGenericMsgDebugMacro( << "nbComponentsPerPixel " << nbComponentsPerPixel ); // otbGenericMsgDebugMacro( << "nbPixels " << nbPixels ); // Other declarations double critA, critS, crit = 1; const unsigned int divisorParam = 10; // Tunning the optimized function parameters //const double m_Delt = 1.; //const double m_LambdD = 0.01; m_LambdS *= nbEndmembers; // Tunning the projected gradient parameters double sig = 0.05; double bet = 0.99; double alphA = 1.; double alphS = 1.; MatrixType X = inputImage2Matrix->GetMatrix(); //otbGenericMsgDebugMacro( << "X " << X ); //------- A and S declaration and initialization --------// //---> These values fit with the ones chosen in the matlab //---"nmf_validationOtb.m" function to validate the OTB code. //A is the endmembers matrix? Output from VCA input of mdmd MatrixType A(this->m_Endmembers); MatrixType S; S.set_size(nbEndmembers, nbPixels); S.fill(1.); //otbGenericMsgDebugMacro( << "S " << S.cols() ); //----------- Declaration of useful variables -----------// MatrixType Sold, Sdiff; Sold.set_size(nbEndmembers, nbPixels); Sdiff.set_size(nbEndmembers, nbPixels); MatrixType Aold, Adiff; Aold.set_size(nbComponentsPerPixel, nbEndmembers); Adiff.set_size(nbComponentsPerPixel, nbEndmembers); MatrixType gradS; gradS.set_size(nbEndmembers, nbPixels); gradS.fill(0); MatrixType gradA; gradA.set_size(nbComponentsPerPixel, nbEndmembers); gradS.fill(0); //----------------- Optimization loop -------------------// //FA fA; //FS fS; otbGenericMsgDebugMacro( << "normX = " << X.fro_norm() ); unsigned int counter = 0; while ((crit > m_CritStopValue) && (counter < m_MaxIter)) { //---------------- Update S -----------------// Sold = S; //otbGenericMsgDebugMacro( << "gradS1 " << gradS ); this->EvalGradS(X, A, S, m_Delt, m_LambdS, gradS); // Compute gradS //otbGenericMsgDebugMacro( << "m_LambdS " << m_LambdS ); //otbGenericMsgDebugMacro( << "gradS " << gradS ); if (counter%divisorParam == 0) { otbGenericMsgDebugMacro( << "Iteration = " << counter ); otbGenericMsgDebugMacro( << "Criterion = " << Criterion(X, A, S, m_Delt, m_LambdS, m_LambdD) ); otbGenericMsgDebugMacro( << "statGradS = " << gradS.fro_norm() ); otbGenericMsgDebugMacro( << "gradS(0, 0) = " << gradS(0, 0) ); otbGenericMsgDebugMacro( << "alphS = " << alphS ); otbGenericMsgDebugMacro( << "normS = " << S.fro_norm() ); otbGenericMsgDebugMacro( << "S(0, 0) = " << S(0, 0) ); } ProjGradOneStep(X, A, gradS, sig, bet, m_Delt, m_LambdS, m_LambdD, S, alphS, false); if (counter%divisorParam == 0) { otbGenericMsgDebugMacro( << "alphS = " << alphS ); otbGenericMsgDebugMacro( << "normS = " << S.fro_norm() ); otbGenericMsgDebugMacro( << "S(0, 0) = " << S(0, 0) ); } //---------------- Update A -----------------// Aold = A; this->EvalGradA(X, A, S, m_Delt, m_LambdD, gradA); // Compute gradS if (counter%divisorParam == 0) { otbGenericMsgDebugMacro( << "gradA(0, 0) = " << gradA(0, 0) ); } if (counter%divisorParam == 0) { otbGenericMsgDebugMacro( << "alphA = " << alphA ); otbGenericMsgDebugMacro( << "normA = " << A.fro_norm() ); otbGenericMsgDebugMacro( << "A(0, 0) = " << A(0, 0) ); } ProjGradOneStep(X, S, gradA, sig, bet, m_Delt, m_LambdS, m_LambdD, A, alphA, true); if (counter%divisorParam == 0) { otbGenericMsgDebugMacro( << "alphA = " << alphA ); otbGenericMsgDebugMacro( << "normA = " << A.fro_norm() ); otbGenericMsgDebugMacro( << "A(0, 0) = " << A(0, 0) ); } //------------ crit evaluation --------------// Adiff = Aold-A; critA = Adiff.absolute_value_max(); Sdiff = Sold - S; critS = Sdiff.absolute_value_max(); crit = std::max(critA, critS); if (counter%divisorParam == 0) { otbGenericMsgDebugMacro( << "critA value: " << critA ); otbGenericMsgDebugMacro( << "critS value: " << critS ); otbGenericMsgDebugMacro( << "crit value: " << crit ); otbGenericMsgDebugMacro( << "criterion value: " << Criterion(X, A, S, m_Delt, m_LambdS, m_LambdD) ); } ++counter; } //--- Putting the rows of in the bands of the output vector image ---// //TODO // Could be improved choosing an imageList for the abundance maps // and a vector list for the endmember spectra (columns of A). itk::ImageRegionIterator outputIt(outputPtr, outputPtr->GetRequestedRegion()); typename OutputImageType::PixelType vectorPixel; vectorPixel.SetSize(outputPtr->GetNumberOfComponentsPerPixel()); unsigned int i = 0; outputIt.GoToBegin(); while ( !outputIt.IsAtEnd() ) { for (unsigned int j=0; j void MDMDNMFImageFilter ::GenerateInputRequestedRegion() { // Call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // Get pointers to the input and output InputPointerType inputPtr = const_cast< InputImageType * >( this->GetInput()); OutputPointerType outputPtr = this->GetOutput(); if ( !inputPtr || !outputPtr ) { return; } inputPtr->SetRequestedRegion( inputPtr->GetLargestPossibleRegion() ); } } // end namespace otb #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbNCLSUnmixingImageFilter.h000066400000000000000000000122401301006202600303400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNCLSUnmixingImageFilter_h #define otbNCLSUnmixingImageFilter_h #include "itkMacro.h" #include "itkNumericTraits.h" #include "otbUnaryFunctorImageFilter.h" #include "vnl/algo/vnl_svd.h" #include namespace otb { namespace Functor { /** \class NCLSUnmixingFunctor * * \brief TODO * * * \ingroup OTBUnmixing */ template class NCLSUnmixingFunctor { public: typedef NCLSUnmixingFunctor Self; typedef TInput InputType; typedef TOutput OutputType; typedef TPrecision PrecisionType; typedef vnl_vector VectorType; typedef vnl_matrix MatrixType; NCLSUnmixingFunctor(); virtual ~NCLSUnmixingFunctor(); unsigned int GetOutputSize() const; bool operator !=(const NCLSUnmixingFunctor& other) const; bool operator ==(const NCLSUnmixingFunctor& other) const; void SetEndmembersMatrix(const MatrixType& U); const MatrixType& GetEndmembersMatrix(void) const; void SetMaxIteration(unsigned int val) { m_MaxIteration = val; } unsigned int GetMaxIteration() const { return m_MaxIteration; } OutputType operator ()(const InputType& in) const; private: static bool IsNonNegative(PrecisionType val) { return val >= 0; } typedef vnl_svd SVDType; typedef boost::shared_ptr SVDPointerType; MatrixType m_U; MatrixType m_Ut; MatrixType m_UtUinv; SVDPointerType m_Svd; // SVD of U unsigned int m_OutputSize; unsigned int m_MaxIteration; }; } /** \class NCLSUnmixingImageFilter * * \brief Performs fully constrained least squares on each pixel of a VectorImage * * This filter takes as input a multiband image and a matrix. * If the matrix is called \f$A\f$, it solves, for each pixel \f$p\f$, the system * \f$A \cdot x = p\f$ in the least square sense, with additional constraints on the solution * \f$\hat{x}\f$ ensuring positivity (each component is positive) and additivity (the sum of * all components is 1). * * The main use of this filter is to unmix an hyperspectral dataset, * where \f$A\f$ is the mixing matrix, in which each row corresponds to an endmember signature. * * The number of rows in \f$A\f$ must match the input image number of bands. * The number of bands in the output image will be the number of columns of $A$ * * References * "Fully Constrained Least-Squares Based Linear Unmixing." Daniel Heinz, * Chein-I Chang, and Mark L.G. Althouse. IEEE. 1999. * * \ingroup Hyperspectral * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBUnmixing */ template class ITK_EXPORT NCLSUnmixingImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef NCLSUnmixingImageFilter Self; typedef otb::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Functor::NCLSUnmixingFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType, TPrecision> FunctorType; typedef typename FunctorType::MatrixType MatrixType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(NCLSUnmixingImageFilter, otb::UnaryFunctorImageFilter); /** Pixel types. */ typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; void SetEndmembersMatrix(const MatrixType& m); const MatrixType& GetEndmembersMatrix() const; void SetMaxIteration( unsigned int val ) { this->GetFunctor().SetMaxIteration(val); this->Modified(); } unsigned int GetMaxIteration() const { return this->GetFunctor().GetMaxIteration(); } protected: NCLSUnmixingImageFilter(); ~NCLSUnmixingImageFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: NCLSUnmixingImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNCLSUnmixingImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbNCLSUnmixingImageFilter.txx000066400000000000000000000104701301006202600307370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNCLSUnmixingImageFilter_txx #define otbNCLSUnmixingImageFilter_txx #include "otbNCLSUnmixingImageFilter.h" #include namespace otb { namespace Functor { template NCLSUnmixingFunctor ::NCLSUnmixingFunctor() : m_OutputSize(0), m_MaxIteration(100) { } template NCLSUnmixingFunctor ::~NCLSUnmixingFunctor() { } template unsigned int NCLSUnmixingFunctor ::GetOutputSize() const { return m_OutputSize; } template bool NCLSUnmixingFunctor ::operator != (const Self& itkNotUsed(other)) const { return true; } template bool NCLSUnmixingFunctor ::operator == (const Self& itkNotUsed(other)) const { return false; } template void NCLSUnmixingFunctor ::SetEndmembersMatrix(const MatrixType& U) { m_U = U; m_Ut = m_U.transpose(); m_UtUinv = SVDType(m_Ut * m_U).inverse(); m_OutputSize = m_U.cols(); m_Svd.reset( new SVDType(m_U) ); } template const typename NCLSUnmixingFunctor::MatrixType& NCLSUnmixingFunctor ::GetEndmembersMatrix() const { return m_U; } template typename NCLSUnmixingFunctor::OutputType NCLSUnmixingFunctor ::operator ()(const InputType& in) const { // TODO : support different types between input and output ? VectorType inVector(in.Size()); for (unsigned int i = 0; i < in.GetSize(); ++i ) { inVector[i] = in[i]; } // Initialize with Unconstrained Least Square solution VectorType uclsVector = m_Svd->solve(inVector); unsigned int nbEndmembers = m_OutputSize; // Apply NCLS iterations VectorType lambda(nbEndmembers); VectorType nclsVector = uclsVector; VectorType correction(uclsVector.size()); for (unsigned int i = 0; i < m_MaxIteration; ++i) { // Error in original paper : divergence // lambda = m_Ut * (inVector - m_U * nclsVector); lambda = m_Ut * (m_U * nclsVector - inVector); correction = m_UtUinv * lambda; nclsVector -= correction; } OutputType out(nclsVector.size()); for (unsigned int i = 0; i < out.GetSize(); ++i ) { out[i] = nclsVector[i]; } return out; } } template NCLSUnmixingImageFilter ::NCLSUnmixingImageFilter() { } template NCLSUnmixingImageFilter ::~NCLSUnmixingImageFilter() { } template void NCLSUnmixingImageFilter ::SetEndmembersMatrix(const MatrixType& m) { this->GetFunctor().SetEndmembersMatrix(m); this->Modified(); } template const typename NCLSUnmixingImageFilter::MatrixType& NCLSUnmixingImageFilter ::GetEndmembersMatrix() const { return this->GetFunctor().GetEndmembersMatrix(); } template void NCLSUnmixingImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbSparseUnmixingImageFilter.h000066400000000000000000000163301301006202600310420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSparseUnmixingImageFilter_h #define otbSparseUnmixingImageFilter_h #include "itkListSample.h" #include "itkHistogram.h" #include "otbMacro.h" #include "otbImage.h" #include "otbWaveletOperator.h" #include "otbWaveletFilterBank.h" #include "otbWaveletTransform.h" #include "otbSparseWvltToAngleMapperListFilter.h" #include "otbAngularProjectionSetImageFilter.h" namespace otb { /** \class SparseUnmixingImageFilter * \brief This class detects linear dependencies from N wavelet decompositions * * This class perform a linear unmixing from a sparse representation of N * signals (Through multiscale wavelet transforms) by means of line detection * in the scatterplot. * * It is implemented as a multi-filter that performs wavelet decomposition of the N * images, Sample list construction of the scatter plot sample, histogram estimation * of the phase and source detection... * * N is given in template value * * * \ingroup OTBUnmixing */ template < class TInputImage, class TOutputImage, unsigned int VNbInputImage, class TPrecision = double, Wavelet::Wavelet TMotherWaveletOperator = Wavelet::SYMLET8 > class ITK_EXPORT SparseUnmixingImageFilter : public ImageToImageListFilter { public: /** Standard typedefs */ typedef SparseUnmixingImageFilter Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SparseUnmixingImageFilter, ImageToImageListFilter); /** Dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); itkStaticConstMacro(NumberOfInputImages, unsigned int, VNbInputImage); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TPrecision PrecisionType; static const Wavelet::Wavelet MotherWaveletOperatorID = TMotherWaveletOperator; /** Filter types and related */ typedef Image< PrecisionType, InputImageDimension > InternalImageType; typedef WaveletOperator< MotherWaveletOperatorID, Wavelet::FORWARD, PrecisionType, InputImageDimension > WaveletOperatorType; typedef WaveletFilterBank< InternalImageType, InternalImageType, WaveletOperatorType, Wavelet::FORWARD > FilterBankType; typedef WaveletTransform< InternalImageType, InternalImageType, FilterBankType, Wavelet::FORWARD > WvltFilterType; typedef typename WvltFilterType::Pointer WvltFilterPointerType; typedef typename WvltFilterType::OutputImageListType InternalImageListType; typedef ObjectList< WvltFilterType > WvltFilterListType; typedef typename WvltFilterListType::Pointer WvltFilterListPointerType; // typedef itk::FixedArray< PrecisionType, NumberOfInputImages-1 > AngleType; typedef itk::Array< PrecisionType > AngleType; typedef itk::Statistics::ListSample< AngleType > AngleListType; typedef typename AngleListType::Pointer AngleListPointerType; typedef SparseWvltToAngleMapperListFilter< InternalImageListType, AngleListType, NumberOfInputImages > AngleListFilterType; typedef typename AngleListFilterType::Pointer AngleListFilterPointerType; typedef typename AngleListFilterType::OutputSampleListType InternalSampleListType; typedef typename itk::Statistics::Histogram< PrecisionType > HistogramType; typedef typename HistogramType::Pointer HistogramPointerType; typedef typename HistogramType::SizeType HistogramSizeType; typedef typename HistogramType::IndexType HistogramIndexType; typedef typename HistogramType::MeasurementVectorType MeasurementVectorType; typedef typename HistogramType::MeasurementType MeasurementType; typedef AngularProjectionSetImageFilter< InputImageType, OutputImageType, AngleListType, PrecisionType > TransformFilterType; typedef typename TransformFilterType::Pointer TransformFilterPointerType; typedef typename TransformFilterType::OutputImageListType OutputImageListType; typedef typename TransformFilterType::OutputImageListPointerType OutputImageListPointerType; typedef typename TransformFilterType::OutputImageIterator OutputImageIterator; using Superclass::SetInput; void SetInput ( unsigned int i, const InputImageType * ); const InputImageType * GetInput( unsigned int i ) const; void SetNumberOfDecomposition ( unsigned int nb ) { for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { m_WvltFilterList->GetNthElement(i)->SetNumberOfDecomposition( nb ); } this->Modified(); } unsigned int GetNumberOfDecomposition () const { return m_WvltFilterList->GetNthElement(0)->GetNumberOfDecomposition(); } void SetThresholdValue( PrecisionType th ) { m_AngleListFilter->SetThresholdValue( th ); this->Modified(); } PrecisionType GetThresholdValue () const { return m_AngleListFilter->GetThresholdValue(); } /** * This number of end-members is estimated from number of modes in the histogram. */ unsigned int GetNumberOfComponentsRequired () const { if ( m_NumberOfComponentsRequired == 0 ) GenerateNumberOfComponentsRequired(); return m_NumberOfComponentsRequired; } itkSetMacro(NumberOfComponentsRequired, unsigned int); itkSetMacro(NumberOfHistogramBins, unsigned int); itkGetMacro(NumberOfHistogramBins, unsigned int); itkGetConstMacro(AngleList, AngleListType*); itkGetConstMacro(WvltFilterList, WvltFilterListType*); itkGetConstMacro(AngleListFilter, AngleListFilterType*); itkGetConstMacro(Histogram, HistogramType*); itkGetConstMacro(Transformer, TransformFilterType*); protected: SparseUnmixingImageFilter(); ~SparseUnmixingImageFilter() ITK_OVERRIDE { } void GenerateData() ITK_OVERRIDE; virtual void GenerateNumberOfComponentsRequired (); private: SparseUnmixingImageFilter(const Self &); //purposely not implemented void operator=(const Self &); //purposely not implemented unsigned int m_NumberOfComponentsRequired; unsigned int m_NumberOfHistogramBins; AngleListPointerType m_AngleList; WvltFilterListPointerType m_WvltFilterList; AngleListFilterPointerType m_AngleListFilter; HistogramPointerType m_Histogram; TransformFilterPointerType m_Transformer; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSparseUnmixingImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbSparseUnmixingImageFilter.txx000066400000000000000000000164531301006202600314440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSparseUnmixingImageFilter_txx #define otbSparseUnmixingImageFilter_txx #include "otbSparseUnmixingImageFilter.h" #include "otbMath.h" #include "itkProcessObject.h" namespace otb { template < class TInputImage, class TOutputImage, unsigned int VNbInputImage, class TPrecision, Wavelet::Wavelet TMotherWaveletOperator > SparseUnmixingImageFilter< TInputImage, TOutputImage, VNbInputImage, TPrecision, TMotherWaveletOperator > ::SparseUnmixingImageFilter () { this->SetNumberOfRequiredInputs( NumberOfInputImages ); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, OutputImageListType::New()); m_NumberOfComponentsRequired = 0; m_NumberOfHistogramBins = 100; m_AngleList = AngleListType::New(); m_WvltFilterList = WvltFilterListType::New(); m_WvltFilterList->Resize( NumberOfInputImages ); for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { m_WvltFilterList->SetNthElement(i, WvltFilterType::New()); m_WvltFilterList->GetNthElement(i)->SetNumberOfDecompositions(2); m_WvltFilterList->GetNthElement(i)->SetSubsampleImageFactor(1); } m_AngleListFilter = AngleListFilterType::New(); m_AngleListFilter->SetThresholdValue( 10. ); m_Histogram = HistogramType::New(); m_Transformer = TransformFilterType::New(); } template < class TInputImage, class TOutputImage, unsigned int VNbInputImage, class TPrecision, Wavelet::Wavelet TMotherWaveletOperator > void SparseUnmixingImageFilter< TInputImage, TOutputImage, VNbInputImage, TPrecision, TMotherWaveletOperator > ::SetInput ( unsigned int i, const InputImageType * img ) { this->itk::ProcessObject::SetNthInput(i, const_cast< InputImageType * >( img ) ); } template < class TInputImage, class TOutputImage, unsigned int VNbInputImage, class TPrecision, Wavelet::Wavelet TMotherWaveletOperator > const TInputImage * SparseUnmixingImageFilter< TInputImage, TOutputImage, VNbInputImage, TPrecision, TMotherWaveletOperator > ::GetInput ( unsigned int i ) const { if ( i >= this->GetNumberOfInputs() ) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(i) ); } template < class TInputImage, class TOutputImage, unsigned int VNbInputImage, class TPrecision, Wavelet::Wavelet TMotherWaveletOperator > void SparseUnmixingImageFilter< TInputImage, TOutputImage, VNbInputImage, TPrecision, TMotherWaveletOperator > ::GenerateData() { itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) { m_WvltFilterList->GetNthElement(i)->SetInput( this->GetInput(i) ); progress->RegisterInternalFilter( m_WvltFilterList->GetNthElement(i), 0.5f/static_cast(NumberOfInputImages) ); m_WvltFilterList->GetNthElement(i)->Update(); m_AngleListFilter->SetInput( i, m_WvltFilterList->GetNthElement(i)->GetOutput() ); } progress->RegisterInternalFilter(m_AngleListFilter, 0.25f); m_AngleListFilter->Update(); GenerateNumberOfComponentsRequired(); otbMsgDebugMacro( << m_NumberOfComponentsRequired << " sources found\n" ); for ( unsigned int i = 0; i < NumberOfInputImages; ++i ) m_Transformer->SetInput( i, this->GetInput(i) ); m_Transformer->SetAngleList( m_AngleList ); progress->RegisterInternalFilter(m_Transformer, 0.25f); m_Transformer->Update(); this->GetOutput()->Resize( m_Transformer->GetOutput()->Size() ); for ( unsigned int i = 0; i < this->GetOutput()->Size(); ++i ) this->GetOutput()->SetNthElement( i, m_Transformer->GetOutput()->GetNthElement(i) ); } template < class TInputImage, class TOutputImage, unsigned int VNbInputImage, class TPrecision, Wavelet::Wavelet TMotherWaveletOperator > void SparseUnmixingImageFilter< TInputImage, TOutputImage, VNbInputImage, TPrecision, TMotherWaveletOperator > ::GenerateNumberOfComponentsRequired () { /** * The histogram is dedicated to angular value in [-PI, PI] * The histogram is smoothed with 100 bins (def. value) */ HistogramSizeType size; size.Fill( m_NumberOfHistogramBins ); MeasurementVectorType theMin (0.); theMin[NumberOfInputImages-2] = -otb::CONST_PI; MeasurementVectorType theMax (otb::CONST_PI); m_Histogram->Initialize( size, theMin, theMax ); typename InternalSampleListType::Iterator angleIter = m_AngleListFilter->GetOutputSampleList()->Begin(); if ( m_AngleListFilter->GetOutputSampleList()->Begin() == m_AngleListFilter->GetOutputSampleList()->End() ) { throw itk::ExceptionObject( __FILE__, __LINE__, "The value of threshold is too high so that there is no angle value to consider for unmixing", ITK_LOCATION); } while ( angleIter != m_AngleListFilter->GetOutputSampleList()->End() ) { if ( !m_Histogram->IncreaseFrequencyOfMeasurement( angleIter.GetMeasurementVector(), 1 ) ) std::cerr << "Data out of bounds\n"; ++angleIter; } #if 0 for ( unsigned int index = 0; index < m_Histogram->GetSize()[0]; ++index ) std::cerr << index << "\t" << m_Histogram->GetMeasurementVector( index )[0] << "\t" << m_Histogram->GetFrequency(index) << "\n"; #endif AngleListPointerType angles = AngleListType::New(); for ( unsigned int id = 0; id < m_Histogram->Size(); ++id ) { HistogramIndexType curIdx = m_Histogram->GetIndex(id); // Is this curIdx a local max ? bool isLocalMax = true; for ( unsigned int k = 0; k < m_Histogram->GetSize().Size(); ++k ) { HistogramIndexType prevIdx = curIdx; if ( prevIdx[k] == 0 ) prevIdx[k] = m_Histogram->GetSize(k)-1; else prevIdx[k] = curIdx[k]-1; HistogramIndexType nextIdx = curIdx; if ( static_cast( nextIdx[k] ) == m_Histogram->GetSize(k)-1 ) nextIdx[k] = 0; else nextIdx[k] = curIdx[k]+1; double freq_prev = m_Histogram->GetFrequency( prevIdx ); double freq_cur = m_Histogram->GetFrequency( curIdx ); double freq_next = m_Histogram->GetFrequency( nextIdx ); if ( !( freq_prev < freq_cur && freq_cur > freq_next ) ) { isLocalMax = false; break; } } if ( isLocalMax ) { angles->PushBack( m_Histogram->GetMeasurementVector( curIdx ) ); } } m_NumberOfComponentsRequired = angles->Size(); m_AngleList = angles; #if 1 std::cout << m_NumberOfComponentsRequired << " sources found\n"; for ( unsigned int i = 0; i < angles->Size(); i++ ) { std::cerr << "Source " << i << ":"; for ( unsigned int j = 0; j < m_Histogram->GetSize().Size(); ++j ) std::cout << "\t" << angles->GetMeasurementVector(i)[j]; std::cout << "\n"; } #endif } } // end of namespace otb #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbUnConstrainedLeastSquareImageFilter.h000066400000000000000000000122411301006202600330110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnConstrainedLeastSquareImageFilter_h #define otbUnConstrainedLeastSquareImageFilter_h #include "itkMacro.h" #include "otbUnaryFunctorImageFilter.h" #include "vnl/algo/vnl_svd.h" #include namespace otb { namespace Functor { /** \class UnConstrainedLeastSquareFunctor * * \brief TODO * * * \ingroup OTBUnmixing */ template class UnConstrainedLeastSquareFunctor { public: typedef TInput InputType; typedef TOutput OutputType; typedef TPrecision PrecisionType; typedef vnl_vector VectorType; typedef vnl_matrix MatrixType; UnConstrainedLeastSquareFunctor() : m_OutputSize(0) {} virtual ~UnConstrainedLeastSquareFunctor() {} unsigned int GetOutputSize() const { return m_OutputSize; } bool operator != (const UnConstrainedLeastSquareFunctor& itkNotUsed(other)) const { return true; } bool operator == (const UnConstrainedLeastSquareFunctor& other) const { return !(*this != other); } void SetMatrix(const MatrixType& m) { //std::cout << "m : " << m.rows() << " " << m.cols() << std::endl; m_Svd.reset( new SVDType(m) ); m_Inv = m_Svd->inverse(); m_OutputSize = m.cols(); } OutputType operator ()(const InputType& in) const { // TODO : support different types between input and output ? VectorType inVector(in.Size()); for (unsigned int i = 0; i < in.GetSize(); ++i ) { inVector[i] = in[i]; } VectorType outVector = m_Inv * inVector; OutputType out(outVector.size()); for (unsigned int i = 0; i < out.GetSize(); ++i ) { out[i] = outVector[i]; } return out; } private: typedef vnl_svd SVDType; typedef boost::shared_ptr SVDPointerType; unsigned int m_OutputSize; SVDPointerType m_Svd; MatrixType m_Inv; }; } /** \class UnConstrainedLeastSquareImageFilter * * \brief Solves a least square system for each pixel * * This filter takes as input a multiband image and a matrix. * If the matrix is called $A$, it solves, for each pixel $p$, the system * \f$A \cdot x = p\f$ in the least square sense, and saves the result \f$\hat{x}\f$ * in the output pixel. * * It can be used as a simple way to unmix an hyperspectral dataset, * where \f$A\f$ is the matrix in which each row corresponds to an endmember signature, * although better algorithms can be found for this particular task. * * The number of rows in \f$A\f$ must match the input image number of bands. * The number of bands in the output image will be the number of columns of \f$A\f$ * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBUnmixing */ template class ITK_EXPORT UnConstrainedLeastSquareImageFilter : public otb::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef UnConstrainedLeastSquareImageFilter Self; typedef otb::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Functor::UnConstrainedLeastSquareFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType, TPrecision> FunctorType; typedef typename FunctorType::MatrixType MatrixType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnConstrainedLeastSquareImageFilter, otb::UnaryFunctorImageFilter); /** Pixel types. */ typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; void SetMatrix(const MatrixType& m) { this->GetFunctor().SetMatrix(m); this->Modified(); } protected: UnConstrainedLeastSquareImageFilter(); ~UnConstrainedLeastSquareImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: UnConstrainedLeastSquareImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbUnConstrainedLeastSquareImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/include/otbUnConstrainedLeastSquareImageFilter.txx000066400000000000000000000022711301006202600334070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbUnConstrainedLeastSquareImageFilter_txx #define otbUnConstrainedLeastSquareImageFilter_txx #include "otbUnConstrainedLeastSquareImageFilter.h" namespace otb { /** * */ template UnConstrainedLeastSquareImageFilter ::UnConstrainedLeastSquareImageFilter() { } template void UnConstrainedLeastSquareImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace #endif OTB-release-5.8/Modules/Hyperspectral/Unmixing/otb-module.cmake000066400000000000000000000012461301006202600245250ustar00rootroot00000000000000set(DOCUMENTATION "In hyperspectral imagery one pixel typically consists of a mixture of the reflectance spectra of several materials, where the mixture coefficients correspond to the abundances of the constituting materials. The process of unmixing one of these 'mixed' pixels is called hyperspectral image unmixing or simply hyperspectral unmixing. This module contains classes useful in meeting that goal.") otb_module(OTBUnmixing DEPENDS OTBBoost OTBCommon OTBDimensionalityReduction OTBITK OTBImageBase OTBStatistics OTBWavelet TEST_DEPENDS OTBCommandLineParser OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/000077500000000000000000000000001301006202600224305ustar00rootroot00000000000000OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/CMakeLists.txt000066400000000000000000000054771301006202600252050ustar00rootroot00000000000000otb_module_test() set(OTBUnmixingTests otbUnmixingTestDriver.cxx otbMDMDNMFImageFilter.cxx otbNCLSUnmixingImageFilter.cxx otbISRAUnmixingImageFilter.cxx otbUnConstrainedLeastSquareImageFilter.cxx otbSparseUnmixingImageFilterNew.cxx otbSparseUnmixingImageFilter.cxx ) add_executable(otbUnmixingTestDriver ${OTBUnmixingTests}) target_link_libraries(otbUnmixingTestDriver ${OTBUnmixing-Test_LIBRARIES}) otb_module_target_label(otbUnmixingTestDriver) # Tests Declaration otb_add_test(NAME hyTvMDMDNMFImageFilterTest2 COMMAND otbUnmixingTestDriver otbMDMDNMFImageFilterTest2 ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${INPUTDATA}/Hyperspectral/synthetic/endmembers.tif ${TEMP}/hyTvMDMDNMFImageFilterTest2.tif 100) otb_add_test(NAME hyTvMDMDNMFImageFilterTest COMMAND otbUnmixingTestDriver --compare-image ${EPSILON_9} ${BASELINE}/hyTvMDMDNMFImageFilterTest.tif ${TEMP}/hyTvMDMDNMFImageFilterTest.tif otbMDMDNMFImageFilterTest ${INPUTDATA}/cupriteSubHsi.tif ${TEMP}/hyTvMDMDNMFImageFilterTest.tif 100) otb_add_test(NAME hyTuMDMDNMFImageFilterNew COMMAND otbUnmixingTestDriver otbMDMDNMFImageFilterNewTest) otb_add_test(NAME hyTvNCLSUnmixingImageFilterTest COMMAND otbUnmixingTestDriver --compare-image ${EPSILON_9} ${BASELINE_FILES}/hyTvNCLSImageFilterTest.tif ${TEMP}/hyTvNCLSImageFilterTest.tif otbNCLSUnmixingImageFilterTest ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${INPUTDATA}/Hyperspectral/synthetic/endmembers.tif ${TEMP}/hyTvNCLSImageFilterTest.tif 10) otb_add_test(NAME hyTuNCLSUnmixingImageFilterNew COMMAND otbUnmixingTestDriver otbNCLSUnmixingImageFilterNewTest) otb_add_test(NAME hyTvISRAUnmixingImageFilterTest COMMAND otbUnmixingTestDriver --compare-image ${EPSILON_9} ${BASELINE_FILES}/hyTvISRAUnmixingImageFilterTest.tif ${TEMP}/hyTvISRAUnmixingImageFilterTest.tif otbISRAUnmixingImageFilterTest ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${INPUTDATA}/Hyperspectral/synthetic/endmembers.tif ${TEMP}/hyTvISRAUnmixingImageFilterTest.tif 10) otb_add_test(NAME hyTuISRAUnmixingImageFilterNew COMMAND otbUnmixingTestDriver otbISRAUnmixingImageFilterNewTest) otb_add_test(NAME hyTuUnConstrainedLeastSquareImageFilterNew COMMAND otbUnmixingTestDriver otbUnConstrainedLeastSquareImageFilterNewTest) otb_add_test(NAME hyTvUnConstrainedLeastSquareImageFilterTest COMMAND otbUnmixingTestDriver --compare-image ${EPSILON_9} ${BASELINE_FILES}/hyTvUnConstrainedLeastSquareImageFilterTest.tif ${TEMP}/hyTvUnConstrainedLeastSquareImageFilterTest.tif otbUnConstrainedLeastSquareImageFilterTest ${INPUTDATA}/Hyperspectral/synthetic/hsi_cube.tif ${INPUTDATA}/Hyperspectral/synthetic/endmembers.tif ${TEMP}/hyTvUnConstrainedLeastSquareImageFilterTest.tif) otb_add_test(NAME hyTuSparseUnmixingImageFilterNew COMMAND otbUnmixingTestDriver otbSparseUnmixingImageFilterNew) OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/otbISRAUnmixingImageFilter.cxx000066400000000000000000000053601301006202600302530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbISRAUnmixingImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToMatrixImageFilter.h" #include "otbStandardWriterWatcher.h" const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ISRAUnmixingImageFilter UnmixingImageFilterType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; typedef otb::ImageFileWriter WriterType; int otbISRAUnmixingImageFilterNewTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { UnmixingImageFilterType::Pointer filter = UnmixingImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbISRAUnmixingImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const char * inputEndmembers = argv[2]; const char * outputImage = argv[3]; int maxIter = atoi(argv[4]); ReaderType::Pointer readerImage = ReaderType::New(); readerImage->SetFileName(inputImage); ReaderType::Pointer readerEndMembers = ReaderType::New(); readerEndMembers->SetFileName(inputEndmembers); VectorImageToMatrixImageFilterType::Pointer endMember2Matrix = VectorImageToMatrixImageFilterType::New(); endMember2Matrix->SetInput(readerEndMembers->GetOutput()); endMember2Matrix->Update(); typedef VectorImageToMatrixImageFilterType::MatrixType MatrixType; MatrixType endMembers = endMember2Matrix->GetMatrix(); MatrixType pinv = vnl_matrix_inverse(endMembers); UnmixingImageFilterType::Pointer unmixer = UnmixingImageFilterType::New(); unmixer->SetInput(readerImage->GetOutput()); unmixer->SetMaxIteration(maxIter); //unmixer->SetNumberOfThreads(1); unmixer->SetEndmembersMatrix(endMember2Matrix->GetMatrix()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImage); writer->SetInput(unmixer->GetOutput()); writer->SetNumberOfDivisionsStrippedStreaming(10); otb::StandardWriterWatcher w4(writer, unmixer,"ISRAUnmixingImageFilter"); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/otbMDMDNMFImageFilter.cxx000066400000000000000000000102011301006202600270460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include "otbMDMDNMFImageFilter.h" #include "otbStandardWriterWatcher.h" int otbMDMDNMFImageFilterNewTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::VectorImage VectorImageType; typedef otb::MDMDNMFImageFilter MDMDNMFImageFilterType; MDMDNMFImageFilterType::Pointer mdmd = MDMDNMFImageFilterType::New(); return EXIT_SUCCESS; } int otbMDMDNMFImageFilterTest(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::MDMDNMFImageFilter MDMDNMFImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; const char * inputImage = argv[1]; const char * outputImage = argv[2]; const unsigned int maxIter = atoi(argv[3]); ReaderType::Pointer readerImage = ReaderType::New(); readerImage->SetFileName(inputImage); readerImage->UpdateOutputInformation(); MDMDNMFImageFilterType::Pointer unmixer = MDMDNMFImageFilterType::New(); unmixer->SetInput(readerImage->GetOutput()); MDMDNMFImageFilterType::MatrixType A; A.set_size(readerImage->GetOutput()->GetNumberOfComponentsPerPixel(), 5); A.fill(100.); A.set_column(1, 200.); A.set_column(2, 300.); A.set_column(3, 400.); A.set_column(4, 500.); unmixer->SetEndmembersMatrix(A); unmixer->SetMaxIter(maxIter); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImage); writer->SetInput(unmixer->GetOutput()); otb::StandardWriterWatcher w4(writer, unmixer,"MDMDNMFImageFilter"); writer->Update(); return EXIT_SUCCESS; } int otbMDMDNMFImageFilterTest2(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::MDMDNMFImageFilter MDMDNMFImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; const char * inputImage = argv[1]; const char * inputEndmembers = argv[2]; const char * outputImage = argv[3]; const unsigned int maxIter = atoi(argv[4]); ReaderType::Pointer readerImage = ReaderType::New(); readerImage->SetFileName(inputImage); readerImage->UpdateOutputInformation(); ReaderType::Pointer readerEndMembers = ReaderType::New(); readerEndMembers->SetFileName(inputEndmembers); VectorImageToMatrixImageFilterType::Pointer endMember2Matrix = VectorImageToMatrixImageFilterType::New(); endMember2Matrix->SetInput(readerEndMembers->GetOutput()); endMember2Matrix->Update(); typedef VectorImageToMatrixImageFilterType::MatrixType MatrixType; MatrixType endMembers = endMember2Matrix->GetMatrix(); MDMDNMFImageFilterType::Pointer unmixer = MDMDNMFImageFilterType::New(); unmixer->SetInput(readerImage->GetOutput()); unmixer->SetEndmembersMatrix(endMember2Matrix->GetMatrix()); unmixer->SetMaxIter(maxIter); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImage); writer->SetInput(unmixer->GetOutput()); otb::StandardWriterWatcher w4(writer, unmixer,"MDMDNMFImageFilter"); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/otbNCLSUnmixingImageFilter.cxx000066400000000000000000000053601301006202600302540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbNCLSUnmixingImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToMatrixImageFilter.h" #include "otbStandardWriterWatcher.h" const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::NCLSUnmixingImageFilter UnmixingImageFilterType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; typedef otb::ImageFileWriter WriterType; int otbNCLSUnmixingImageFilterNewTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { UnmixingImageFilterType::Pointer filter = UnmixingImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbNCLSUnmixingImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const char * inputEndmembers = argv[2]; const char * outputImage = argv[3]; int maxIter = atoi(argv[4]); ReaderType::Pointer readerImage = ReaderType::New(); readerImage->SetFileName(inputImage); ReaderType::Pointer readerEndMembers = ReaderType::New(); readerEndMembers->SetFileName(inputEndmembers); VectorImageToMatrixImageFilterType::Pointer endMember2Matrix = VectorImageToMatrixImageFilterType::New(); endMember2Matrix->SetInput(readerEndMembers->GetOutput()); endMember2Matrix->Update(); typedef VectorImageToMatrixImageFilterType::MatrixType MatrixType; MatrixType endMembers = endMember2Matrix->GetMatrix(); MatrixType pinv = vnl_matrix_inverse(endMembers); UnmixingImageFilterType::Pointer unmixer = UnmixingImageFilterType::New(); unmixer->SetInput(readerImage->GetOutput()); unmixer->SetMaxIteration(maxIter); //unmixer->SetNumberOfThreads(1); unmixer->SetEndmembersMatrix(endMember2Matrix->GetMatrix()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImage); writer->SetInput(unmixer->GetOutput()); writer->SetNumberOfDivisionsStrippedStreaming(10); otb::StandardWriterWatcher w4(writer, unmixer,"NCLSUnmixingImageFilter"); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/otbSparseUnmixingImageFilter.cxx000066400000000000000000000102371301006202600307510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbSparseUnmixingImageFilter.h" int otbSparseUnmixingImageFilterTest ( int argc, char * argv[] ) { // number of images to consider const unsigned int nbInputImages = 2; typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption( "--InputImages", "Input Images", "-in", nbInputImages, true ); parser->AddOption( "--OutputImages", "Generic name for output Images (_#.hdr will be added)", "-out", 1, true ); parser->AddOption( "--Threshold", "Lower threshold for accounting the waBinaryFunctorImageListToSampleListFiltervelet coeffs (def. 10)", "-th", 1, false ); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine( argc, argv, parseResult ); } catch( itk::ExceptionObject & err ) { std::cerr << argv[0] << " performs Wvlt unmixing on " << nbInputImages << " images\n"; std::string descriptionException = err.GetDescription(); if ( descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos ) return EXIT_SUCCESS; if(descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos ) return EXIT_SUCCESS; return EXIT_FAILURE; } std::string inputImageName [ nbInputImages ]; for ( unsigned int i = 0; i < nbInputImages; i++ ) inputImageName[i] = parseResult->GetParameterString("--InputImages", i); std::string outputImageName = parseResult->GetParameterString("--OutputImages"); const double threshold = parseResult->IsOptionPresent("--Threshold") ? parseResult->GetParameterDouble("--Threshold") : 10.; // Main type definition const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image< PixelType, Dimension > ImageType; // Reading input images typedef otb::ImageFileReader ReaderType; typedef otb::ObjectList< ReaderType > ReaderListType; ReaderListType::Pointer reader = ReaderListType::New(); reader->Resize( nbInputImages ); for ( unsigned int i = 0; i < nbInputImages; i++ ) { reader->SetNthElement(i, ReaderType::New()); reader->GetNthElement(i)->SetFileName( inputImageName[i].c_str() ); reader->GetNthElement(i)->Update(); } // Image filtering typedef otb::SparseUnmixingImageFilter< ImageType, ImageType, nbInputImages > FilterType; FilterType::Pointer filter = FilterType::New(); for ( unsigned int i = 0; i < nbInputImages; i++ ) filter->SetInput( i, reader->GetNthElement(i)->GetOutput() ); filter->SetThresholdValue( threshold ); typedef otb::CommandProgressUpdate< FilterType > CommandType; CommandType::Pointer observer = CommandType::New(); filter->AddObserver( itk::ProgressEvent(), observer ); filter->Update(); typedef otb::ImageFileWriter< ImageType > WriterType; typedef otb::ObjectList< WriterType > WriterListType; WriterListType::Pointer writers = WriterListType::New(); writers->Resize( filter->GetOutput()->Size() ); for ( unsigned int i = 0; i < writers->Size(); i++ ) { std::ostringstream title; title << outputImageName << "_" << i << ".hdr"; writers->SetNthElement(i, WriterType::New()); WriterType::Pointer writer = writers->GetNthElement(i); std::string stitle = title.str(); writer->SetFileName( stitle.c_str() ); writer->SetInput( filter->GetOutput()->GetNthElement(i) ); writer->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/otbSparseUnmixingImageFilterNew.cxx000066400000000000000000000023151301006202600314210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbCommandProgressUpdate.h" #include "otbCommandLineArgumentParser.h" #include "otbSparseUnmixingImageFilter.h" int otbSparseUnmixingImageFilterNew ( int itkNotUsed(argc), char * itkNotUsed(argv)[]) { // number of images to consider const unsigned int nbInputImages = 2; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image< PixelType, Dimension > ImageType; typedef otb::SparseUnmixingImageFilter< ImageType, ImageType, nbInputImages > FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/otbUnConstrainedLeastSquareImageFilter.cxx000066400000000000000000000052031301006202600327200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbUnConstrainedLeastSquareImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToMatrixImageFilter.h" #include "otbStandardWriterWatcher.h" const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::UnConstrainedLeastSquareImageFilter UnConstrainedLeastSquareSolverType; typedef otb::VectorImageToMatrixImageFilter VectorImageToMatrixImageFilterType; typedef otb::ImageFileWriter WriterType; int otbUnConstrainedLeastSquareImageFilterNewTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { UnConstrainedLeastSquareSolverType::Pointer filter = UnConstrainedLeastSquareSolverType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbUnConstrainedLeastSquareImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const char * inputEndmembers = argv[2]; const char * outputImage = argv[3]; ReaderType::Pointer readerImage = ReaderType::New(); readerImage->SetFileName(inputImage); ReaderType::Pointer readerEndMembers = ReaderType::New(); readerEndMembers->SetFileName(inputEndmembers); VectorImageToMatrixImageFilterType::Pointer endMember2Matrix = VectorImageToMatrixImageFilterType::New(); endMember2Matrix->SetInput(readerEndMembers->GetOutput()); endMember2Matrix->Update(); typedef VectorImageToMatrixImageFilterType::MatrixType MatrixType; MatrixType endMembers = endMember2Matrix->GetMatrix(); UnConstrainedLeastSquareSolverType::Pointer unmixer = \ UnConstrainedLeastSquareSolverType::New(); unmixer->SetInput(readerImage->GetOutput()); unmixer->SetMatrix(endMember2Matrix->GetMatrix()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImage); writer->SetInput(unmixer->GetOutput()); otb::StandardWriterWatcher w4(writer, unmixer,"UnConstrainedLeastSquareImageFilter"); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Hyperspectral/Unmixing/test/otbUnmixingTestDriver.cxx000066400000000000000000000011461301006202600274750ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMDMDNMFImageFilterNewTest); REGISTER_TEST(otbMDMDNMFImageFilterTest); REGISTER_TEST(otbMDMDNMFImageFilterTest2); REGISTER_TEST(otbNCLSUnmixingImageFilterNewTest); REGISTER_TEST(otbNCLSUnmixingImageFilterTest); REGISTER_TEST(otbISRAUnmixingImageFilterNewTest); REGISTER_TEST(otbISRAUnmixingImageFilterTest); REGISTER_TEST(otbUnConstrainedLeastSquareImageFilterNewTest); REGISTER_TEST(otbUnConstrainedLeastSquareImageFilterTest); REGISTER_TEST(otbSparseUnmixingImageFilterNew); REGISTER_TEST(otbSparseUnmixingImageFilterTest); } OTB-release-5.8/Modules/IO/000077500000000000000000000000001301006202600153355ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/Carto/000077500000000000000000000000001301006202600164055ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/Carto/CMakeLists.txt000066400000000000000000000001061301006202600211420ustar00rootroot00000000000000project(OTBCarto) set(OTBCarto_LIBRARIES OTBCarto) otb_module_impl() OTB-release-5.8/Modules/IO/Carto/include/000077500000000000000000000000001301006202600200305ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/Carto/include/otbCoordinateToName.h000066400000000000000000000070361301006202600241070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCoordinateToName_h #define otbCoordinateToName_h #include "itkPoint.h" #include "itkMultiThreader.h" #include "otbCurlHelperInterface.h" #include "OTBCartoExport.h" namespace otb { /** * \class CoordinateToName * \brief Retrieve geographical information for longitude and latitude coordinates * * This class can work in asynchronous mode using \code MultithreadOn() \endcode. In this * case, the web request does not block the rest of the program. * * * \ingroup OTBCarto */ class OTBCarto_EXPORT CoordinateToName : public itk::Object { public: /** Standard class typedefs. */ typedef CoordinateToName Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Object Superclass; itkTypeMacro(CoordinateToName, itk::Object); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef itk::Point PointType; itkGetMacro(Lon, double); itkGetMacro(Lat, double); itkSetMacro(Lon, double); itkSetMacro(Lat, double); /** * Set the lon/lat only if they are far enough from the current point to * avoid triggering too many updates */ bool SetLonLat(PointType point) { if ((vcl_abs(point[0] - m_Lon) > m_UpdateDistance) || (vcl_abs(point[1] - m_Lat) > m_UpdateDistance)) { // std::cout << "Update lon/lat " << m_Lon << ", " << m_Lat << " -> " << point << std::endl; m_Lon = point[0]; m_Lat = point[1]; //TODO Check whether it is better to have something imprecise or nothing at all m_IsValid = false; return true; } else { // std::cout << "Keeping lon/lat" << std::endl; return false; } } std::string GetPlaceName() const { if (m_IsValid) { return m_PlaceName; } else { return ""; } } std::string GetCountryName() const { if (m_IsValid) { return m_CountryName; } else { return ""; } } itkGetMacro(Multithread, bool); itkSetMacro(Multithread, bool); itkBooleanMacro(Multithread); itkSetObjectMacro(Curl, CurlHelperInterface); virtual bool Evaluate(); protected: CoordinateToName(); ~CoordinateToName() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void ParseXMLGeonames(std::string& placeName, std::string& countryName) const; virtual void DoEvaluate(); static ITK_THREAD_RETURN_TYPE ThreadFunction(void*); private: CoordinateToName(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_Lon; double m_Lat; bool m_Multithread; bool m_IsValid; //Minimum distance to trigger an update of the coordinates //specified in degrees double m_UpdateDistance; std::string m_PlaceName; std::string m_CountryName; std::string m_CurlOutput; CurlHelperInterface::Pointer m_Curl; itk::MultiThreader::Pointer m_Threader; }; } // namespace otb #endif OTB-release-5.8/Modules/IO/Carto/include/otbImageToOSMVectorDataGenerator.h000066400000000000000000000057311301006202600264440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToOSMVectorDataGenerator_h #define otbImageToOSMVectorDataGenerator_h #include "otbOSMDataToVectorDataGenerator.h" namespace otb { /** \class ImageToOSMVectorDataGenerator * * \brief Helper class to compute the extent of the input image and * use it to fill the bbox for the OSM request. * * This class compute the extent of the input image. The extent is * then used to fill the bbox values. * The class OSMDataToVectorDataGenerator request the OSM server to get * the OSM XML file storing the datas within this input image bbox. * * \sa otb::OSMDataToVectorDataGenerator * * \ingroup OTBCarto */ template < class TImage> class ImageToOSMVectorDataGenerator : public OSMDataToVectorDataGenerator { public: /** Standard class typedefs */ typedef ImageToOSMVectorDataGenerator Self; typedef OSMDataToVectorDataGenerator Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ImageToOSMVectorDataGenerator, OSMDataToVectorDataGenerator); /** Method for creation through the object factory. */ itkNewMacro(Self); // Image typedef typedef TImage ImageType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::PointType PointType; // VectorData typedef Superclass::VectorDataType VectorDataType; // Struct to store the extent of the image struct ImageExtentType{ double minX; double maxX; double minY; double maxY; }; /** Method to set/get the input image */ using Superclass::SetInput; void SetInput( const ImageType * input); /** Returns the input image */ const ImageType* GetInput() const; protected: void GenerateData() ITK_OVERRIDE; // Method to compute the extent of the image void EstimateImageExtent(); ImageToOSMVectorDataGenerator(); ~ImageToOSMVectorDataGenerator() ITK_OVERRIDE {} private: ImageToOSMVectorDataGenerator(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented ImageExtentType m_ImageExtent; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToOSMVectorDataGenerator.txx" #endif #endif OTB-release-5.8/Modules/IO/Carto/include/otbImageToOSMVectorDataGenerator.txx000066400000000000000000000106461301006202600270410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToOSMVectorDataGenerator_txx #define otbImageToOSMVectorDataGenerator_txx #include "otbImageToOSMVectorDataGenerator.h" #include "otbGeoInformationConversion.h" #include "otbGenericRSTransform.h" namespace otb { // constructor template < class TImage > ImageToOSMVectorDataGenerator ::ImageToOSMVectorDataGenerator() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); m_ImageExtent.minX = 0; m_ImageExtent.maxX = 0; m_ImageExtent.minY = 0; m_ImageExtent.maxY = 0; } template < class TImage > void ImageToOSMVectorDataGenerator ::SetInput( const ImageType * input ) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast< ImageType* >( input ) ); } // Method to get the SampleList as DataObject template < class TImage> const typename ImageToOSMVectorDataGenerator ::ImageType * ImageToOSMVectorDataGenerator ::GetInput() const { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } template < class TImage> void ImageToOSMVectorDataGenerator ::GenerateData() { // Get the extent of the image this->EstimateImageExtent(); this->SetWest(m_ImageExtent.minX); this->SetSouth(m_ImageExtent.minY); this->SetEast(m_ImageExtent.maxX); this->SetNorth(m_ImageExtent.maxY); Superclass::GenerateData(); } template < class TImage> void ImageToOSMVectorDataGenerator ::EstimateImageExtent() { // Get the input image typename ImageType::ConstPointer input = this->GetInput(); // Local generic RS Transform to project the 4 corners to WGS84 typedef otb::GenericRSTransform<> TransformType; typename TransformType::Pointer transform = TransformType::New(); transform->SetInputKeywordList(input->GetImageKeywordlist()); transform->SetInputProjectionRef(input->GetProjectionRef()); transform->SetOutputProjectionRef(otb::GeoInformationConversion::ToWKT(4326)); transform->InstantiateTransform(); // Compute the 4 corners in the cartographic coordinate system std::vector< IndexType> vindex; std::vector voutput; IndexType index1, index2, index3, index4; SizeType size; // Image size size = input->GetLargestPossibleRegion().GetSize(); // project the 4 corners index1 = input->GetLargestPossibleRegion().GetIndex(); index2 = input->GetLargestPossibleRegion().GetIndex(); index3 = input->GetLargestPossibleRegion().GetIndex(); index4 = input->GetLargestPossibleRegion().GetIndex(); index2[0] += size[0] - 1; index3[0] += size[0] - 1; index3[1] += size[1] - 1; index4[1] += size[1] - 1; vindex.push_back(index1); vindex.push_back(index2); vindex.push_back(index3); vindex.push_back(index4); for (unsigned int i = 0; i < vindex.size(); ++i) { PointType physicalPoint; input->TransformIndexToPhysicalPoint(vindex[i], physicalPoint); otbMsgDevMacro( << " physical point "<< physicalPoint << " --> Transform " << transform->TransformPoint(physicalPoint)); voutput.push_back(transform->TransformPoint(physicalPoint)); } // Compute the boundaries double minX = voutput[0][0]; double maxX = voutput[0][0]; double minY = voutput[0][1]; double maxY = voutput[0][1]; for (unsigned int i = 0; i < voutput.size(); ++i) { // Origins if (minX > voutput[i][0]) minX = voutput[i][0]; if (minY > voutput[i][1]) minY = voutput[i][1]; // Sizes if (maxX < voutput[i][0]) maxX = voutput[i][0]; if (maxY < voutput[i][1]) maxY = voutput[i][1]; } // Edit the output image extent type m_ImageExtent.maxX = maxX; m_ImageExtent.minX = minX; m_ImageExtent.maxY = maxY; m_ImageExtent.minY = minY; } } // End namespace otb #endif OTB-release-5.8/Modules/IO/Carto/include/otbMapFileProductWriter.h000066400000000000000000000175631301006202600247750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMapFileProductWriter_h #define otbMapFileProductWriter_h #include #include "itkObjectFactory.h" // Image Tiling #include "otbMultiChannelExtractROI.h" #include "otbImageFileWriter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbGeoInformationConversion.h" #include "otbStreamingShrinkImageFilter.h" // sahpe index necessary includes #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" // projection filter #include "otbGenericRSResampleImageFilter.h" namespace otb { /** \class MapFileProductWriter * \brief This class produces Map file product ie a file .map, * the tiles to draw in a mapserver, and finally * a shapefile which describe the tiles and where to find them * on the disk. * * This filter begins by tiling the input image. An accessor * SetTileSize allows setting the size of each tile. For each tile * generated, an entry is added to the shapefile to store the location * where the file is saved on the disk. * The product generated are a mapfile which is the configuration file * for mapservers, a tile index and finally the tiles. * This class allow the user to specify the cgi-bin used (SetCGIPath) * and the directory where to store the index shapefile and the tiles * via SetShapeIndexPath method * * Note that this class reproject the input image in the projection * defined by the SRID (via SetSRID() method) set by the user. * * * \ingroup IO * * * \ingroup OTBCarto */ template class ITK_EXPORT MapFileProductWriter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef MapFileProductWriter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MapFileProductWriter, itk::ProcessObject); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::InternalPixelType InternalPixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef unsigned char OutputPixelType; typedef VectorImage OutputImageType; typedef VectorData VectorDataType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename PolygonType::VertexType VertexType; typedef VectorDataFileWriter VectorDataFileWriterType; /// Multi channels Extract ROI filter typedef MultiChannelExtractROI VectorImageExtractROIFilterType; // Writer typedef ImageFileWriter VectorWriterType; // Resampler typedef StreamingShrinkImageFilter StreamingShrinkImageFilterType; // Intensity Rescale typedef VectorRescaleIntensityImageFilter VectorRescaleIntensityImageFilterType; // Project filter typedef GenericRSResampleImageFilter GenericRSResamplerType; typedef typename GenericRSResamplerType::Pointer GenericRSResamplerPointerType; // Transformer typedef GenericRSTransform<> TransformType; typedef TransformType::InputPointType InputPointType; typedef TransformType::OutputPointType OutputPointType; /** Dimension of input image. */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); using Superclass::SetInput; virtual void SetInput( const InputImageType *image); virtual void SetInput( unsigned int, const TInputImage * image); const InputImageType * GetInput(void); const InputImageType * GetInput(unsigned int idx); /** Method to set the filename of the mapfile generated */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); /** Set/Get the size of each tile*/ itkSetMacro(TileSize, unsigned int); itkGetMacro(TileSize, unsigned int); /** Set CGI filename path */ itkSetStringMacro(CGIPath); itkGetStringMacro(CGIPath); /** Set SahpePATH: the directory where to store the shapefile */ itkSetStringMacro(ShapeIndexPath); itkGetStringMacro(ShapeIndexPath); /** Update Method : Call a porotected Write method */ void Update() ITK_OVERRIDE { this->Write(); } /** Macro to set the SRID we want to project Data in*/ itkSetMacro(SRID, int); protected: MapFileProductWriter(); ~MapFileProductWriter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /**Method for Tiling the input image*/ virtual void Tiling(); /** Method for writing */ virtual void Write(); private: MapFileProductWriter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Mehtod to initialize the variables*/ virtual void Initialize(); /**MapFile IndexTule build*/ virtual void AddBBoxToIndexTile(OutputPointType lowerLeftCorner, OutputPointType lowerRightCorner, OutputPointType upperRightCorner, OutputPointType upperLeftCorner, unsigned int x, unsigned int y); /** Method To Generate the mapFile*/ virtual void GenerateMapFile(); /** Add a layer to the mapfile*/ void AddLayer(); /** Initialize vd*/ void InitializeVectorData(); InputImagePointer m_VectorImage; InputImagePointer m_ResampleVectorImage; // Extract ROI typename VectorImageExtractROIFilterType::Pointer m_VectorImageExtractROIFilter; // Writer typename VectorWriterType::Pointer m_VectorWriter; // Resampler typename StreamingShrinkImageFilterType::Pointer m_StreamingShrinkImageFilter; // Rescale intensity typename VectorRescaleIntensityImageFilterType::Pointer m_VectorRescaleIntensityImageFilter; // Transformer typename TransformType::Pointer m_Transform; // VectorData Pointer Type for tileindex shapefile typename VectorDataType::Pointer m_VectorDataIndexTile; typename DataNodeType::Pointer m_Polygon; typename DataNodeType::Pointer m_Folder; // Projection Filter GenericRSResamplerPointerType m_GenericRSResampler; // Tile size unsigned int m_TileSize; unsigned int m_CurrentDepth; // File and path name std::string m_FileName; std::string m_IndexShapeFileName; std::string m_CGIPath; std::string m_ShapeIndexPath; std::ofstream m_File; int m_SRID; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMapFileProductWriter.txx" #endif #endif OTB-release-5.8/Modules/IO/Carto/include/otbMapFileProductWriter.txx000066400000000000000000000470411301006202600253630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMapFileProductWriter_txx #define otbMapFileProductWriter_txx #include "otbMapFileProductWriter.h" #include "itksys/SystemTools.hxx" namespace otb { /** * Constructor */ template MapFileProductWriter ::MapFileProductWriter() { m_GenericRSResampler = GenericRSResamplerType::New(); m_TileSize = 256; m_CurrentDepth = 0; m_SRID = 26918; // Modify superclass default values, can be overridden by subclasses this->SetNumberOfRequiredInputs(1); } /** * Desctructor */ template MapFileProductWriter ::~MapFileProductWriter() { } /** * */ template void MapFileProductWriter ::SetInput(const InputImageType *input) { // Process object is not const-correct so the const_cast is required here this->ProcessObject::SetNthInput(0, const_cast< InputImageType * >( input ) ); } template void MapFileProductWriter ::SetInput( unsigned int index, const TInputImage * image ) { // Process object is not const-correct so the const_cast is required here this->ProcessObject::SetNthInput(index, const_cast< TInputImage *>( image ) ); } /** * */ template const typename MapFileProductWriter::InputImageType * MapFileProductWriter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetInput(0) ); } /** * Get the idx input */ template const typename MapFileProductWriter::InputImageType * MapFileProductWriter ::GetInput(unsigned int idx) { return static_cast< const TInputImage * > (this->ProcessObject::GetInput(idx)); } /** * Write launch the tiling and the mapFile generation and write on the * disk the indexfile as a shapefile */ template void MapFileProductWriter ::Write() { // Get the input Image m_VectorImage = const_cast(this->GetInput()); m_VectorImage->UpdateOutputInformation(); if(m_VectorImage->GetProjectionRef().empty() && m_VectorImage->GetImageKeywordlist().GetSize() > 0) { otbMsgDevMacro( "Sensor Model detected : Reprojecting in the targer SRID" ); m_GenericRSResampler->SetInput(this->GetInput()); m_GenericRSResampler->SetOutputParametersFromMap(otb::GeoInformationConversion::ToWKT(m_SRID)); m_VectorImage = m_GenericRSResampler->GetOutput(); m_VectorImage->UpdateOutputInformation(); } // Initialize the filename, the vectordatas this->Initialize(); // Generate the mapFile this->GenerateMapFile(); // Do the tiling this->Tiling(); } /** * Initialize the path, the filename, the vectordata used to store * each bounding box of a tile as a feature */ template void MapFileProductWriter ::Initialize() { // check that the right extension is given : expected .map if (itksys::SystemTools::GetFilenameLastExtension(m_FileName) != ".map") { itkExceptionMacro(<InitializeVectorData(); } /** * Initialize the vectordata to write * */ template void MapFileProductWriter ::InitializeVectorData() { // Intitialize the vectordata to build the indexTile m_VectorDataIndexTile = VectorDataType::New(); m_VectorDataIndexTile->SetProjectionRef(otb::GeoInformationConversion::ToWKT(m_SRID)/*m_VectorImage->GetProjectionRef()*/); DataNodeType::Pointer root = m_VectorDataIndexTile->GetDataTree()->GetRoot()->Get(); DataNodeType::Pointer document = DataNodeType::New(); m_Folder = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); m_Folder->SetNodeType(otb::FOLDER); document->SetNodeId("DOCUMENT"); m_Folder->SetNodeId("FOLDER"); m_VectorDataIndexTile->GetDataTree()->Add(document, root); m_VectorDataIndexTile->GetDataTree()->Add(m_Folder, document); } /** * Do the tiling */ template void MapFileProductWriter ::Tiling() { unsigned int numberOfChannel = m_VectorImage->GetNumberOfComponentsPerPixel(); /** Image statistics*/ typename InputImageType::PixelType inMin(numberOfChannel), inMax(numberOfChannel), outMin(numberOfChannel), outMax(numberOfChannel); outMin.Fill(0); outMax.Fill(255); // Update image base information m_VectorImage->UpdateOutputInformation(); // Get the image size SizeType size; size = m_VectorImage->GetLargestPossibleRegion().GetSize(); unsigned int sizeX = size[0]; unsigned int sizeY = size[1]; // Compute max depth unsigned int maxDepth = static_cast(std::max(vcl_ceil(vcl_log(static_cast(sizeX) / static_cast(m_TileSize)) / vcl_log(2.0)), vcl_ceil(vcl_log(static_cast(sizeY) / static_cast(m_TileSize)) / vcl_log(2.0)))); // Extract size & index SizeType extractSize; IndexType extractIndex; for (unsigned int depth = 0; depth <= maxDepth; depth++) { // update the attribute value Current Depth m_CurrentDepth = depth; // Compose the name of the vectordata // the index shapefile filename std::ostringstream tempIndexShapeName; tempIndexShapeName << m_ShapeIndexPath<<"/"; tempIndexShapeName << itksys::SystemTools::GetFilenameWithoutExtension(m_FileName)<<"_"< 1) { m_StreamingShrinkImageFilter = StreamingShrinkImageFilterType::New(); m_StreamingShrinkImageFilter->SetShrinkFactor(sampleRatioValue); m_StreamingShrinkImageFilter->SetInput(m_VectorImage); m_StreamingShrinkImageFilter->GetStreamer()->SetAutomaticStrippedStreaming(0); m_StreamingShrinkImageFilter->Update(); m_VectorRescaleIntensityImageFilter = VectorRescaleIntensityImageFilterType::New(); m_VectorRescaleIntensityImageFilter->SetInput(m_StreamingShrinkImageFilter->GetOutput()); m_VectorRescaleIntensityImageFilter->SetOutputMinimum(outMin); m_VectorRescaleIntensityImageFilter->SetOutputMaximum(outMax); if (depth == 0) { m_VectorRescaleIntensityImageFilter->Update(); inMin = m_VectorRescaleIntensityImageFilter->GetInputMinimum(); inMax = m_VectorRescaleIntensityImageFilter->GetInputMaximum(); } else { m_VectorRescaleIntensityImageFilter->SetInputMinimum(inMin); m_VectorRescaleIntensityImageFilter->SetInputMaximum(inMax); m_VectorRescaleIntensityImageFilter->SetAutomaticInputMinMaxComputation(false); } // New resample vector image m_ResampleVectorImage = m_VectorRescaleIntensityImageFilter->GetOutput(); } else { m_VectorRescaleIntensityImageFilter = VectorRescaleIntensityImageFilterType::New(); m_VectorRescaleIntensityImageFilter->SetInput(m_VectorImage); m_VectorRescaleIntensityImageFilter->SetOutputMinimum(outMin); m_VectorRescaleIntensityImageFilter->SetOutputMaximum(outMax); m_VectorRescaleIntensityImageFilter->SetInputMinimum(inMin); m_VectorRescaleIntensityImageFilter->SetInputMaximum(inMax); m_VectorRescaleIntensityImageFilter->SetAutomaticInputMinMaxComputation(false); m_ResampleVectorImage = m_VectorRescaleIntensityImageFilter->GetOutput(); } m_ResampleVectorImage->UpdateOutputInformation(); // Get the image size size = m_ResampleVectorImage->GetLargestPossibleRegion().GetSize(); sizeX = size[0]; sizeY = size[1]; unsigned int x = 0; unsigned int y = 0; // Create directory where to store generated tiles // Do it once here outside of the loop std::ostringstream path; path << m_ShapeIndexPath<<"/tiles"; if (!itksys::SystemTools::MakeDirectory(path.str().c_str())) { itkExceptionMacro(<< "Error while creating cache directory" << path.str()); } // Tiling resample image for (unsigned int tx = 0; tx < sizeX; tx += m_TileSize) { for (unsigned int ty = 0; ty < sizeY; ty += m_TileSize) { if ((tx + m_TileSize) >= sizeX) { extractIndex[0] = tx; extractSize[0] = sizeX - tx; } else { extractIndex[0] = tx; extractSize[0] = m_TileSize; } if ((ty + m_TileSize) >= sizeY) { extractIndex[1] = ty; extractSize[1] = sizeY - ty; } else { extractIndex[1] = ty; extractSize[1] = m_TileSize; } // Generate Tile filename std::ostringstream ossFileName; ossFileName << path.str()<<"/"; ossFileName << "tile_"<SetStartX(extractIndex[0]); m_VectorImageExtractROIFilter->SetStartY(extractIndex[1]); m_VectorImageExtractROIFilter->SetSizeX(extractSize[0]); m_VectorImageExtractROIFilter->SetSizeY(extractSize[1]); // Set Channel to extract m_VectorImageExtractROIFilter->SetChannel(1); m_VectorImageExtractROIFilter->SetChannel(2); m_VectorImageExtractROIFilter->SetChannel(3); // Set extract roi input m_VectorImageExtractROIFilter->SetInput(m_ResampleVectorImage); // Configure writer m_VectorWriter = VectorWriterType::New(); m_VectorWriter->SetFileName(ossFileName.str().c_str()); m_VectorWriter->SetInput(m_VectorImageExtractROIFilter->GetOutput()); m_VectorWriter->Update(); /** TODO : Generate KML for this tile */ // Search Lat/Lon box // Initialize the transform to be used //typename TransformType::Pointer transform = //TransformType::New(); m_Transform = TransformType::New(); m_Transform->SetInputProjectionRef(m_GenericRSResampler->GetOutputProjectionRef()); m_Transform->SetOutputProjectionRef(otb::GeoInformationConversion::ToWKT(m_SRID)); m_Transform->InstantiateTransform(); InputPointType inputPoint; SizeType sizeTile; sizeTile = extractSize; /** GX LAT LON **/ // Compute upper left corner itk::ContinuousIndex indexTile(extractIndex); indexTile[0] += -0.5; indexTile[1] += -0.5; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); OutputPointType upperLeftCorner = m_Transform->TransformPoint(inputPoint); //std::cout <<"indexTile "<< indexTile <<" --> input Point "<< inputPoint << " upperLeftCorner "<< upperLeftCorner << std::endl; // Compute lower left corner indexTile[1] += static_cast(sizeTile[1]); m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); OutputPointType lowerLeftCorner = m_Transform->TransformPoint(inputPoint); //std::cout <<"indexTile "<< indexTile <<" --> input Point "<< inputPoint << " lowerLeftCorner "<< lowerLeftCorner << std::endl; // Compute lower right corner indexTile[0] += static_cast(sizeTile[0]); m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); OutputPointType lowerRightCorner = m_Transform->TransformPoint(inputPoint); //std::cout <<"indexTile "<< indexTile <<" --> input Point "<< inputPoint << " lowerRightCorner "<< lowerRightCorner << std::endl; // Compute upper right corner indexTile[1] -= static_cast(sizeTile[1]); m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); OutputPointType upperRightCorner = m_Transform->TransformPoint(inputPoint); //std::cout <<"indexTile "<< indexTile <<" --> input Point "<< inputPoint << " upperRightCorner "<< upperRightCorner << std::endl; // Build The indexTile this->AddBBoxToIndexTile(lowerLeftCorner, lowerRightCorner, upperRightCorner, upperLeftCorner, x, y); /** END GX LAT LON */ y++; } x++; y = 0; } // Add the layer in the mapfile this->AddLayer(); // Write the IndexTile typename VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(m_IndexShapeFileName); writer->SetInput(m_VectorDataIndexTile); writer->Update(); this->InitializeVectorData(); } // Close the file m_File <<"END" << std::endl; m_File.close(); } /** * Add the bounding box and the location of the generated tile as * field of the vectordata */ template void MapFileProductWriter ::AddBBoxToIndexTile(OutputPointType lowerLeftCorner, OutputPointType lowerRightCorner, OutputPointType upperRightCorner, OutputPointType upperLeftCorner, unsigned int x, unsigned int y) { // From PointType to VertexType VertexType pLL, pLR, pUR, pUL; pLL[0]=lowerLeftCorner[0]; pLL[1]=lowerLeftCorner[1]; pLR[0]=lowerRightCorner[0]; pLR[1]=lowerRightCorner[1]; pUR[0]=upperRightCorner[0]; pUR[1]=upperRightCorner[1]; pUL[0]=upperLeftCorner[0]; pUL[1]=upperLeftCorner[1]; // Form a polygon with the vertices PolygonType::Pointer poly = PolygonType::New(); poly->AddVertex(pLL); poly->AddVertex(pLR); poly->AddVertex(pUR); poly->AddVertex(pUL); // Add the polygon to the datanode m_Polygon = DataNodeType::New(); m_Polygon->SetNodeId("FEATURE_POLYGON"); m_Polygon->SetNodeType(otb::FEATURE_POLYGON); m_Polygon->SetPolygonExteriorRing(poly); std::ostringstream oss; oss << "tiles/tile_"; oss <SetFieldAsString("LOCATION", oss.str()); // Add the to vectordata m_VectorDataIndexTile->GetDataTree()->Add(m_Polygon, m_Folder); } /** * Write the mapFile on the disk */ template void MapFileProductWriter ::GenerateMapFile() { // create the directory where to store the filemap // if it does not exists std::ostringstream path; path << itksys::SystemTools::GetFilenamePath(m_FileName); if (!itksys::SystemTools::MakeDirectory(path.str().c_str())) { itkExceptionMacro(<< "Error while creating cache directory" << path.str()); } // Create a mapfile m_File.open(m_FileName.c_str()); m_File << std::fixed << std::setprecision(6); // Get the name of the layer std::ostringstream tempIndexShapeName; tempIndexShapeName << itksys::SystemTools::GetFilenameWithoutExtension(m_FileName); m_File <<"MAP" << std::endl; m_File <<"\tNAME "< void MapFileProductWriter ::AddLayer() { m_File <<"\tLAYER" << std::endl; m_File <<"\t\tNAME '"< void MapFileProductWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call the superclass implementation Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/IO/Carto/include/otbOSMDataToVectorDataGenerator.h000066400000000000000000000164541301006202600262770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOSMDataToVectorDataGenerator_h #define otbOSMDataToVectorDataGenerator_h // store the nodes (points) coordinates #include #include #include #include "OTBCartoExport.h" #include "otbVectorData.h" #include "otbVectorDataSource.h" #include "otbCurlHelper.h" namespace otb { /** \class OSMDataToVectorDataGenerator * * \brief Request OSM Server using the OSM API 0.6 to get the * xml file storing the vector elements available. * * This class request the OSM server using a bbox. The bbox * parameters can be set using the methods Set{North, South, East, * West}. Thus, only the vector elements that are within this bbox * are returned in the Xml file. * * The class parse the XML file for certain keys by default, the * class allow adding key to be searched in the XML file. Use * AddKey(const std::string& key) to add it to the search list. * Here is a link to the OSM wiki where all the keys are listed : * http://wiki.openstreetmap.org/wiki/Map_Features. * * Adding a field and its integer value is possible through the * methods SetClassKey(const std::string&) and SetClassKeyValue() * The field is retrieved by GetFieldAsInt(), thus must be int-compatible * * Getting output VectorData is possible via two methods : * * 1: Get all the features of key in a vector data via * GetVectorDataByName(const std::string& key) * For instance : GetVectorDataByName("highway") * * 2: Get only the features for a key that match a given value via * GetVectorDataByName(const std::string& key, const std::string& value) * For instance : GetVectorDataByName("highway", "motorway") * * * All the keys and their relative values are stored in a map. To get * this map use the method GetKeysMap(). * * Note that if one of the server limits are crossed * node/way/relation or area requested, an exception is raised. * * * \ingroup OTBCarto */ class OTBCarto_EXPORT OSMDataToVectorDataGenerator : public VectorDataSource< otb::VectorData<> > { public: /** Standard class typedefs */ typedef OSMDataToVectorDataGenerator Self; typedef VectorDataSource< otb::VectorData<> > Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; typedef Superclass::OutputVectorDataType VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::LineType LineType; typedef DataNodeType::PolygonType PolygonType; typedef LineType::VertexType VertexType; // typedefs for objects to store results typedef std::map ContainerType; // Vector to store typedef std::pair ElementPairType; // Coordinates of the nodes typedef std::vector PointTypeList; typedef std::pair VectorDataElementType; typedef std::vector VectorDataElementListType; // Map to store all the keys found and their relative types typedef std::vector StringVectorType; typedef std::map KeyMapType; /** Run-time type information (and related methods). */ itkTypeMacro(OSMDataToVectorDataGenerator, VectorDataSource); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Set/Get FileName */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); /** Macro to Set/GEt the extent */ itkSetMacro(North, double); itkSetMacro(South, double); itkSetMacro(East, double); itkSetMacro(West, double); itkGetMacro(North, double); itkGetMacro(South, double); itkGetMacro(East, double); itkGetMacro(West, double); /** Field name containing the class identifier */ itkGetConstMacro(ClassKey, std::string); itkSetMacro(ClassKey, std::string); /** Field name containing the class identifier */ itkGetConstMacro(ClassKeyValue, int); itkSetMacro(ClassKeyValue, int); /* flag to choose between requesting the url using curl or a file in the disk */ itkSetMacro(UseUrl, bool); /** Add a key to search into the list */ void AddKey(const std::string& key) { if(!this->IsKeyPresent(key)) m_KeyList.push_back(key); } /** Method to get the map where are stored the keys and their value * found when parsing the osm file. */ const KeyMapType GetKeysMap() const { return m_KeysMap; } /** Method to get a VectorData where are stored elements * corresponding the key */ const VectorDataType* GetVectorDataByName(const std::string& key); /** Method to get a VectorData where are stored elements * corresponding the key and the value */ const VectorDataType* GetVectorDataByName(const std::string& key, const std::string& value); protected: /** Generate Data method : launch the process */ void GenerateData() ITK_OVERRIDE; /** * Parse the xml file get from OSM to compose the requested vector * data */ void ParseXmlFile(); /** * Compose the vector data */ void ProcessVectorData(const std::string& key, const std::string& value); /** * internal convenient method to serach if a key was already added */ bool IsKeyPresent(const std::string& key); OSMDataToVectorDataGenerator(); ~OSMDataToVectorDataGenerator() ITK_OVERRIDE; private: OSMDataToVectorDataGenerator(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented // Private method to add the key, type to the map void AddKeyTypeToMap(const std::string& key, const std::string& value); // Extent of the region to get from OSM double m_North; double m_South; double m_East; double m_West; /** the url in OSM API format */ std::string m_Url; bool m_UseUrl; /** List to store keys to search */ std::vector m_KeyList; /** Variable used in to store the result of the parsing */ std::string m_FileName; ContainerType m_GeoPointContainer; VectorDataElementListType m_VectorDataElementList; /** Curl object to get the XML file */ CurlHelper::Pointer m_Curl; /** Output VectorData requested with the method GetVectorDataByName */ VectorDataType::Pointer m_OutputVectorData; /** container to store the keys and their types found */ KeyMapType m_KeysMap; /** Class key and its value */ std::string m_ClassKey; int m_ClassKeyValue; }; // end of class } // end of namespace otb #endif OTB-release-5.8/Modules/IO/Carto/include/otbPlaceNameToLonLat.h000066400000000000000000000043041301006202600241510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPlaceNameToLonLat_h #define otbPlaceNameToLonLat_h #include "otbCurlHelperInterface.h" #include "OTBCartoExport.h" namespace otb { /** * \class PlaceNameToLonLat * \brief Retrieve Longitude and Latitude coordinates from a place name * * * \ingroup OTBCarto */ class OTBCarto_EXPORT PlaceNameToLonLat : public itk::Object { public: /** Standard class typedefs. */ typedef PlaceNameToLonLat Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Object Superclass; itkTypeMacro(PlaceNameToLonLat, Object); /** Method for creation through the object factory. */ itkNewMacro(Self); itkGetMacro(Lon, double); itkGetMacro(Lat, double); itkGetMacro(PlaceName, std::string); itkSetMacro(PlaceName, std::string); typedef enum {ALL, GEONAMES, GOOGLE, YAHOO} SearchMethodEnum; //Not implemented yet TODO virtual bool Evaluate(); protected: PlaceNameToLonLat(); ~PlaceNameToLonLat() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void RetrieveXML(const std::ostringstream& urlStream); void ParseXMLYahoo(); void ParseXMLGoogle(); void ParseXMLGeonames(); private: PlaceNameToLonLat(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_Lon; double m_Lat; std::string m_PlaceName; SearchMethodEnum m_SearchMethod; //Not implemented yet TODO CurlHelperInterface::Pointer m_Curl; std::string m_CurlOutput; bool m_RequestSucceed; }; } // namespace otb #endif OTB-release-5.8/Modules/IO/Carto/include/otbWorldFile.h000066400000000000000000000056621301006202600226060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWorldFile_h #define otbWorldFile_h #include #include #include "itkObject.h" #include "itkObjectFactory.h" namespace otb { /** * \class WorldFile * \brief Handles the world file that associates geographic information to png, jpg * * The world file format is detailed at * http://en.wikipedia.org/wiki/World_file * * * \ingroup OTBCarto */ class ITK_EXPORT WorldFile : public itk::Object { public: typedef WorldFile Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); itkGetMacro(LonOrigin, double) itkSetMacro(LonOrigin, double) itkGetMacro(LatOrigin, double) itkSetMacro(LatOrigin, double) itkGetMacro(LonSpacing, double) itkSetMacro(LonSpacing, double) itkGetMacro(LatSpacing, double) itkSetMacro(LatSpacing, double) itkGetMacro(LonRotation, double) itkSetMacro(LonRotation, double) itkGetMacro(LatRotation, double) itkSetMacro(LatRotation, double) itkGetStringMacro(ImageFilename) itkSetStringMacro(ImageFilename) void Update() { if (m_ImageFilename.empty()) { itkExceptionMacro(<< "The image filename must be provided"); } std::string worldFilename; int i = m_ImageFilename.find_last_of('.'); worldFilename = m_ImageFilename.substr(0, i) + ".wld"; std::ofstream file; file.open(worldFilename.c_str()); file << std::setprecision(15); file << m_LonSpacing << std::endl; file << m_LatRotation << std::endl; //yes, in this order file << m_LonRotation << std::endl; file << m_LatSpacing << std::endl; file << m_LonOrigin << std::endl; file << m_LatOrigin << std::endl; file.close(); } protected: WorldFile() : m_LonOrigin(0.0), m_LatOrigin(0.0), m_LonSpacing(0.0), m_LatSpacing(0.0), m_LonRotation(0.0), m_LatRotation(0.0), m_ImageFilename("") {} ~WorldFile() ITK_OVERRIDE {} private: WorldFile(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_LonOrigin; double m_LatOrigin; double m_LonSpacing; double m_LatSpacing; double m_LonRotation; double m_LatRotation; std::string m_ImageFilename; }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/Carto/otb-module.cmake000066400000000000000000000015531301006202600214620ustar00rootroot00000000000000set(DOCUMENTATION "Cartography related module. For instance, users can retrieve geographical information for longitude and latitude coordinates. compute the extent of the input image and use it to fill the bbox for the OSM request. produce Map file product (ie a file .map, the tiles to draw in a mapserver, and finally a shapefile). request OSM Server using the OSM API 0.6 to get the xml file storing the vector elements available. retrieve Longitude and Latitude coordinates from a place name. And so on.") otb_module(OTBCarto ENABLE_SHARED DEPENDS OTBCommon OTBCurlAdapters OTBITK OTBImageBase OTBImageIO OTBImageManipulation OTBProjection OTBTinyXML OTBTransform OTBVectorDataBase OTBVectorDataIO TEST_DEPENDS OTBCommandLineParser OTBOpenThreadsAdapters OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/Carto/src/000077500000000000000000000000001301006202600171745ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/Carto/src/CMakeLists.txt000066400000000000000000000007761301006202600217460ustar00rootroot00000000000000set(OTBCarto_SRC otbCoordinateToName.cxx otbOSMDataToVectorDataGenerator.cxx otbPlaceNameToLonLat.cxx ) add_library(OTBCarto ${OTBCarto_SRC}) target_link_libraries(OTBCarto ${OTBVectorDataBase_LIBRARIES} ${OTBImageIO_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBTinyXML_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBCurlAdapters_LIBRARIES} ${OTBVectorDataIO_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ) otb_module_target(OTBCarto) OTB-release-5.8/Modules/IO/Carto/src/otbCoordinateToName.cxx000066400000000000000000000077711301006202600236340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbCoordinateToName.h" #include "otbMacro.h" #include "otbUtils.h" #include "otb_tinyxml.h" #include "otbCurlHelper.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { /** * Constructor */ CoordinateToName::CoordinateToName() : m_Lon(-1000.0), m_Lat(-1000.0), m_Multithread(false), m_IsValid(false), m_PlaceName(""), m_CountryName("") { /* //Avoid collision between different instance of the class typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGenType; RandomGenType::Pointer randomGen = RandomGenType::GetInstance(); randomGen->SetSeed(reinterpret_cast(this)); //make sure the seed is unique for this class unsigned int randomNum = randomGen->GetIntegerVariate(); std::stringstream filename; filename << "tmp-coordinateToName-SignayriUt1-"; filename << randomNum; filename << ".xml"; m_TempFileName = filename.str(); */ m_Curl = CurlHelper::New(); m_Threader = itk::MultiThreader::New(); m_UpdateDistance = 0.01; //about 1km at equator } /** * PrintSelf */ void CoordinateToName ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " m_Lon " << m_Lon << std::endl; os << indent << " m_Lat " << m_Lat << std::endl; os << indent << " m_PlaceName " << m_PlaceName << std::endl; } bool CoordinateToName::Evaluate() { if (m_Multithread) { m_Threader->SpawnThread(ThreadFunction, this); } else { DoEvaluate(); } return true; } ITK_THREAD_RETURN_TYPE CoordinateToName::ThreadFunction(void *arg) { struct itk::MultiThreader::ThreadInfoStruct * pInfo = (itk::MultiThreader::ThreadInfoStruct *) (arg); CoordinateToName::Pointer lThis = (CoordinateToName*) (pInfo->UserData); lThis->DoEvaluate(); return ITK_THREAD_RETURN_VALUE; } void CoordinateToName::DoEvaluate() { m_PlaceName = ""; m_CountryName = ""; m_IsValid = false; if (Utils::IsLonLatValid(m_Lon, m_Lat)) { std::ostringstream urlStream; urlStream << "http://api.geonames.org/findNearbyPlaceName?lat="; urlStream << m_Lat; urlStream << "&lng="; urlStream << m_Lon; urlStream << "&username=otbteam"; otbMsgDevMacro("CoordinateToName: retrieve url " << urlStream.str()); try { m_Curl->RetrieveUrlInMemory(urlStream.str(), m_CurlOutput); m_IsValid = true; } catch(itk::ExceptionObject) { m_IsValid = false; } if(m_IsValid) { std::string placeName = ""; std::string countryName = ""; ParseXMLGeonames(placeName, countryName); m_PlaceName = placeName; m_CountryName = countryName; } } } void CoordinateToName::ParseXMLGeonames(std::string& placeName, std::string& countryName) const { TiXmlDocument doc; doc.Parse(m_CurlOutput.c_str()); if (!doc.Error()) { TiXmlHandle docHandle(&doc); TiXmlElement* childName = docHandle.FirstChild("geonames").FirstChild("geoname"). FirstChild("name").Element(); if (childName) { placeName = childName->GetText(); } TiXmlElement* childCountryName = docHandle.FirstChild("geonames").FirstChild("geoname"). FirstChild("countryName").Element(); if (childCountryName) { countryName = childCountryName->GetText(); } otbMsgDevMacro(<< "Near " << placeName << " in " << countryName); } } } // namespace otb OTB-release-5.8/Modules/IO/Carto/src/otbOSMDataToVectorDataGenerator.cxx000066400000000000000000000306451301006202600260140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOSMDataToVectorDataGenerator.h" #include "otbGeoInformationConversion.h" #include "itksys/SystemTools.hxx" #include "itkDataObject.h" #include "itkMacro.h" #include "otb_tinyxml.h" namespace otb { OSMDataToVectorDataGenerator::OSMDataToVectorDataGenerator():m_North(43.62811), m_South(43.60185), m_East(1.59323), m_West(1.54911), m_UseUrl(true) { this->SetNumberOfRequiredOutputs(1); // Initialize the url m_Url = "http://www.openstreetmap.org/api/0.6/map?"; m_Curl = CurlHelper::New(); m_ClassKey = "Class"; m_ClassKeyValue = 1; // Add the key to search by default m_KeyList.push_back("highway"); m_KeyList.push_back("building"); m_KeyList.push_back("landuse"); m_KeyList.push_back("waterway"); m_KeyList.push_back("cycleway"); m_KeyList.push_back("public_transport"); m_KeyList.push_back("railway"); m_KeyList.push_back("natural"); } OSMDataToVectorDataGenerator::~OSMDataToVectorDataGenerator() { } void OSMDataToVectorDataGenerator::GenerateData() { // Priority to the URL, if not set check if the filename is // used if(m_UseUrl) { // Get the url std::ostringstream urlStream; urlStream<IsCurlReturnHttpError( urlStream.str())) { itkExceptionMacro(<<"The OSM Server returned an Error > =400," <<" it means that one of server limits are crossed : node/way/relation or area requested"); } // Use Curl to request the OSM Server // TODO use the RetrieveUrlInMemory m_Curl->RetrieveFile(urlStream.str(), m_FileName); } else { // Check if the filename is not empty if(m_FileName.empty()) itkExceptionMacro(<<"The XML output FileName is empty, please set the filename via the method SetFileName"); //Check that the right extension is given : expected .xml */ if (itksys::SystemTools::GetFilenameLastExtension(m_FileName) != ".xml" && itksys::SystemTools::GetFilenameLastExtension(m_FileName)!= ".osm" ) { itkExceptionMacro(<ParseXmlFile(); // Remove the osm temp file only if the url request is used if( m_UseUrl) if(std::remove(m_FileName.c_str()) != 0) { itkExceptionMacro(<< "Error while deleting the file" << m_FileName); } } void OSMDataToVectorDataGenerator::ParseXmlFile() { // Open the xml file TiXmlDocument doc(m_FileName.c_str()); if (!doc.LoadFile()) { itkExceptionMacro( <<"Cannot open the file "<Value(),"node")==0; node = node->NextSiblingElement() ) { int id = 0; double longitude = 0.; double latitude = 0.; if ( node->QueryIntAttribute("id", &id) == TIXML_SUCCESS && node->QueryDoubleAttribute("lat", &latitude) == TIXML_SUCCESS && node->QueryDoubleAttribute("lon", &longitude) == TIXML_SUCCESS ) { // current point VertexType geoPoint; geoPoint[0] = longitude; geoPoint[1] = latitude; // std::pair to add in the map std::pair newEntry; newEntry.first = id; newEntry.second = geoPoint; m_GeoPointContainer.insert(newEntry); } } //////////// //////////// //////////// //////////// //////////// /* Step 2 : Find the Key and the node ids of the key */ //////////// //////////// //////////// //////////// //////////// // Iterate through the tree to get all the fields ways with tag k=key for( TiXmlElement* currentLayer = root.FirstChildElement("way").ToElement(); currentLayer != ITK_NULLPTR && strcmp(currentLayer->Value(),"way") ==0; currentLayer = currentLayer->NextSiblingElement() ) { bool foundKey = false; // Is the element "way" have a child tag if(currentLayer->FirstChildElement("tag")) { ElementPairType elementPair; // Iterate through the node tag to find the "key" for( TiXmlElement* currentTag = currentLayer->FirstChild("tag")->ToElement(); currentTag != ITK_NULLPTR; currentTag = currentTag->NextSiblingElement() ) { std::string result = currentTag->Attribute("k"); if(this->IsKeyPresent(result)) { // Set the flag to true; foundKey = true; // Get the value of the key std::string resultValue = currentTag->Attribute("v"); // Fill the element information elementPair.first = result; elementPair.second = resultValue; // Add the key, value to map this->AddKeyTypeToMap(result, resultValue); break; } } if(foundKey) { VectorDataElementType vdelement; PointTypeList pointList; // put the current layer pointer to the beginning for( TiXmlElement* currentNode = currentLayer->FirstChildElement("nd"); currentNode != ITK_NULLPTR; currentNode = currentNode->NextSiblingElement() ) { int value=0; if(currentNode->QueryIntAttribute("ref", &value) == TIXML_SUCCESS) { // Add the current point to the list pointList.push_back((*m_GeoPointContainer.find(value)).second); } } // Form the VectorDataElement if(pointList.size() > 0) { vdelement.first = elementPair; vdelement.second = pointList; m_VectorDataElementList.push_back(vdelement); } } } // end if tag k exists } } void OSMDataToVectorDataGenerator::AddKeyTypeToMap(const std::string& key, const std::string& value) { // Is this key present in the map KeyMapType::iterator it = m_KeysMap.find(key); if( it != m_KeysMap.end()) { // vector containing the types relative to this key StringVectorType ¤tTypes = (*it).second; bool found = false; // Add the type if not present for(unsigned int i = 0; i < currentTypes.size(); ++i) { if(currentTypes[i].compare(value) == 0) found = true; } // if the value was not found add it the currentypes vector if(!found) { currentTypes.push_back(value); } } else { std::pair< std::string, StringVectorType > keytype; keytype.first = key; keytype.second.push_back(value); m_KeysMap.insert(keytype); } } void OSMDataToVectorDataGenerator::ProcessVectorData(const std::string& key, const std::string& value) { // the output m_OutputVectorData = VectorDataType::New(); // Intitialize the vectordata : EPSG 4326 is for WGS84 m_OutputVectorData->SetProjectionRef(otb::GeoInformationConversion::ToWKT(4326)); DataNodeType::Pointer root = m_OutputVectorData->GetDataTree()->GetRoot()->Get(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder->SetNodeType(otb::FOLDER); document->SetNodeId("DOCUMENT"); folder->SetNodeId("FOLDER"); m_OutputVectorData->GetDataTree()->Add(document, root); m_OutputVectorData->GetDataTree()->Add(folder, document); // Form the vector data with the values parsed for(unsigned int idx = 0; idx < m_VectorDataElementList.size(); ++idx) { // Instantiate a datanode DataNodeType::Pointer currentDataNode = DataNodeType::New(); // Get the current PointTypeList PointTypeList currentPointList = m_VectorDataElementList[idx].second; // Get the current ElementPairList ElementPairType elementPair = m_VectorDataElementList[idx].first; // Add it to the vector data only if the requested key matches to // elementPair key if(elementPair.first.compare(key) == 0) { // value is empty // or if it is not empty it has to match the requestd value if(value.empty() || elementPair.second.compare(value) == 0) { // If the first and the last vertex are the same = polygon else // line if(currentPointList[0].EuclideanDistanceTo(currentPointList[currentPointList.size()-1]) < 1e-10) // polygon { currentDataNode->SetNodeId("FEATURE_POLYGON"); currentDataNode->SetNodeType(otb::FEATURE_POLYGON); PolygonType::Pointer polygon = PolygonType::New(); for(unsigned int curVertexId = 0; curVertexId< currentPointList.size(); curVertexId++) { polygon->AddVertex(currentPointList[curVertexId]); } currentDataNode->SetPolygonExteriorRing(polygon); } else // line { LineType::Pointer currentLine = LineType::New(); for(unsigned int curVertexId = 0; curVertexId< currentPointList.size(); curVertexId++) { currentLine->AddVertex(currentPointList[curVertexId]); } currentDataNode->SetNodeId("FEATURE_LINE"); currentDataNode->SetNodeType(otb::FEATURE_LINE); currentDataNode->SetLine(currentLine); } // Add some fields (TODO : mapnik necessary fields for rendering ) currentDataNode->SetFieldAsString("Key", elementPair.first); currentDataNode->SetFieldAsString("type", elementPair.second); currentDataNode->SetFieldAsInt(m_ClassKey, m_ClassKeyValue); // Add the to vectordata m_OutputVectorData->GetDataTree()->Add(currentDataNode, folder); } } } } const OSMDataToVectorDataGenerator::VectorDataType* OSMDataToVectorDataGenerator::GetVectorDataByName(const std::string& key) { if(key.empty()) itkExceptionMacro(<<"Requested key is empty, please set a valid one"); // First thing to do is to add the key set as parameters in the // KeyList if(!this->IsKeyPresent(key)) { // TODO leave this functionality for AddKey ? m_KeyList.push_back(key); this->ParseXmlFile(); } // Build the output this->ProcessVectorData(key,""); // Get the output return m_OutputVectorData; } const OSMDataToVectorDataGenerator::VectorDataType* OSMDataToVectorDataGenerator::GetVectorDataByName(const std::string& key, const std::string& value) { if(key.empty()) itkExceptionMacro(<<"Requested key is empty, please set a valid one"); // Add the key set as parameters in the KeyList // TODO leave this functionality for AddKey ? if(!this->IsKeyPresent(key)) { m_KeyList.push_back(key); this->ParseXmlFile(); } // Build the output this->ProcessVectorData(key, value); // Get the output return m_OutputVectorData; } bool OSMDataToVectorDataGenerator::IsKeyPresent(const std::string& key) { for(unsigned int i = 0; i < m_KeyList.size(); ++i) if(m_KeyList[i].compare(key) == 0) return true; // Otherwise return false; return false; } } OTB-release-5.8/Modules/IO/Carto/src/otbPlaceNameToLonLat.cxx000066400000000000000000000112051301006202600236660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPlaceNameToLonLat.h" #include "otb_tinyxml.h" #include "otbCurlHelper.h" namespace otb { PlaceNameToLonLat::PlaceNameToLonLat() : m_Lon(-1000.0), m_Lat(-1000.0), m_PlaceName("Where everything started"), m_SearchMethod(PlaceNameToLonLat::ALL), m_RequestSucceed(false) { m_Curl = CurlHelper::New(); } void PlaceNameToLonLat ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << " m_Lon " << m_Lon << std::endl; os << indent << " m_Lat " << m_Lat << std::endl; os << indent << " m_PlaceName " << m_PlaceName << std::endl; } bool PlaceNameToLonLat::Evaluate() { std::string::size_type loc = m_PlaceName.find(" ", 0); while (loc != std::string::npos) { m_PlaceName.replace(loc, 1, "+"); loc = m_PlaceName.find(" ", loc); } // TODO : replace unsafe ASCII character with "%" followed by their hex equivalent // Geonames service if ((m_Lat == -1000.0) && (m_Lon == -1000.0)) { std::ostringstream urlStream; urlStream << "http://api.geonames.org/search?q="; urlStream << m_PlaceName; urlStream << "&maxRows=1&type=xml&orderby=relevance&username=otbteam"; RetrieveXML(urlStream); if ( m_RequestSucceed ) ParseXMLGeonames(); } // Google Maps service // if ((m_Lat == -1000.0) && (m_Lon == -1000.0)) // { // std::ostringstream urlStream; // urlStream << "http://maps.google.com/maps?q="; // urlStream << m_PlaceName; // urlStream << "&sll=38.9594,-95.2655&sspn=119.526,360&output=kml&ie=utf-8&v=2.2&cv=4.2.0180.1134&hl=en"; // RetrieveXML(urlStream); // if ( m_RequestSucceed ) // ParseXMLGoogle(); // } // Yahoo new PlaceFinder API need an application ID to be able // to use it // if ((m_Lat == -1000.0) && (m_Lon == -1000.0)) // { // std::ostringstream urlStream; // urlStream << "http://api.local.yahoo.com/MapsService/V1/geocode?appid=com.sun.blueprints.ui.geocoder&location="; // urlStream << m_PlaceName; // RetrieveXML(urlStream); // if ( m_RequestSucceed ) // ParseXMLYahoo(); // } if ((m_Lat == -1000.0) && (m_Lon == -1000.0)) { std::cout << "Search Error: fallback on the origin" << std::endl; m_Lat = 43.560204; m_Lon = 1.480736; return false; } return true; } void PlaceNameToLonLat::RetrieveXML(const std::ostringstream& urlStream) { try { m_RequestSucceed = true; m_Curl->RetrieveUrlInMemory(urlStream.str(), m_CurlOutput); } catch(itk::ExceptionObject) { m_RequestSucceed = false; } } void PlaceNameToLonLat::ParseXMLYahoo() { TiXmlDocument doc; doc.Parse(m_CurlOutput.c_str()); TiXmlHandle docHandle(&doc); TiXmlElement* childLat = docHandle.FirstChild("ResultSet").FirstChild("Result").FirstChild("Latitude").Element(); if (childLat) { m_Lat = atof(childLat->GetText()); } TiXmlElement* childLon = docHandle.FirstChild("ResultSet").FirstChild("Result").FirstChild("Longitude").Element(); if (childLon) { m_Lon = atof(childLon->GetText()); } } void PlaceNameToLonLat::ParseXMLGoogle() { TiXmlDocument doc; doc.Parse(m_CurlOutput.c_str()); TiXmlHandle docHandle(&doc); TiXmlElement* childLat = docHandle.FirstChild("kml").FirstChild("Placemark").FirstChild("LookAt").FirstChild( "latitude").Element(); if (childLat) { m_Lat = atof(childLat->GetText()); } TiXmlElement* childLon = docHandle.FirstChild("kml").FirstChild("Placemark").FirstChild("LookAt").FirstChild( "longitude").Element(); if (childLon) { m_Lon = atof(childLon->GetText()); } } void PlaceNameToLonLat::ParseXMLGeonames() { TiXmlDocument doc; doc.Parse(m_CurlOutput.c_str()); TiXmlHandle docHandle(&doc); TiXmlElement* childLat = docHandle.FirstChild("geonames").FirstChild("geoname").FirstChild("lat").Element(); if (childLat) { m_Lat = atof(childLat->GetText()); } TiXmlElement* childLon = docHandle.FirstChild("geonames").FirstChild("geoname").FirstChild("lng").Element(); if (childLon) { m_Lon = atof(childLon->GetText()); } } } // namespace otb OTB-release-5.8/Modules/IO/Carto/test/000077500000000000000000000000001301006202600173645ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/Carto/test/CMakeLists.txt000066400000000000000000000060101301006202600221210ustar00rootroot00000000000000otb_module_test() set(OTBCartoTests otbCartoTestDriver.cxx otbMapFileProductWriterNew.cxx otbImageToOSMVectorDataGenerator.cxx otbMapFileProductWriter.cxx otbOSMDataToVectorDataTests.cxx otbCoordinateToNameTest.cxx ) add_executable(otbCartoTestDriver ${OTBCartoTests}) target_link_libraries(otbCartoTestDriver ${OTBCarto-Test_LIBRARIES}) otb_module_target_label(otbCartoTestDriver) # Tests Declaration otb_add_test(NAME ioTuMapFileProductWriterNew COMMAND otbCartoTestDriver otbMapFileProductWriterNew ) otb_add_test(NAME ioTuImageToOSMVectorDataGeneratorNew COMMAND otbCartoTestDriver otbImageToOSMVectorDataGeneratorNew ) otb_add_test(NAME ioTvImageToOSMVectorDataGenerator COMMAND otbCartoTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvImageToOSMVectorDataGenerator_highway_motorway.shp ${TEMP}/ioTvImageToOSMVectorDataGenerator_highway_motorway.shp otbImageToOSMVectorDataGenerator -in ${EXAMPLEDATA}/qb_RoadExtract.tif -osm ${INPUTDATA}/qb_road.osm -out ${TEMP}/ioTvImageToOSMVectorDataGenerator_highway_motorway.shp -key highvay,motorway ) set_property(TEST ioTvImageToOSMVectorDataGenerator PROPERTY RESOURCE_LOCK web_access) otb_add_test(NAME ioTvMapFileProductWriter COMMAND otbCartoTestDriver otbMapFileProductWriter ${INPUTDATA}/ExtrZoneNuageuse.tif ${TEMP}/mapserver/toulouseExtract.map ${TEMP}/mapserver/result # Shape index path http://localhost/cgi-bin/mapserv # cgi executable path 256 ) set_property(TEST ioTvMapFileProductWriter PROPERTY RESOURCE_LOCK web_access) otb_add_test(NAME ioTuOSMToVectorDataGenerator COMMAND otbCartoTestDriver otbOSMToVectorDataGeneratorNew ) otb_add_test(NAME ioTvOSMToVectorDataGeneratorByName COMMAND otbCartoTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvOSMToVectorDataFilterByName_highway.shp ${TEMP}/ioTvOSMToVectorDataFilterByName_highway.shp otbOSMToVectorDataGeneratorByName -osm ${INPUTDATA}/qb_road.osm -vd ${TEMP}/ioTvOSMToVectorDataFilterByName_highway.shp ) set_property(TEST ioTvOSMToVectorDataGeneratorByName PROPERTY RESOURCE_LOCK web_access) otb_add_test(NAME ioTvOSMToVectorDataGeneratorTest COMMAND otbCartoTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvOSMToVectorDataFilterTest_highway.shp ${TEMP}/ioTvOSMToVectorDataFilterTest_highway.shp otbOSMToVectorDataGeneratorTest ${INPUTDATA}/qb_road.osm ${TEMP}/ioTvOSMToVectorDataFilterTest_highway.shp ) set_property(TEST ioTvOSMToVectorDataGeneratorTest PROPERTY RESOURCE_LOCK web_access) otb_add_test(NAME coTvCoordinateToNameTest COMMAND otbCartoTestDriver --compare-ascii ${NOTOL} ${BASELINE}/CoordinateToNameTest.txt ${TEMP}/CoordinateToNameTest.txt otbCoordinateToNameTest 103.78 1.29 ${TEMP}/CoordinateToNameTest.txt ) otb_add_test(NAME coTvCoordinateToNameMultithreadTest COMMAND otbCartoTestDriver --compare-ascii ${NOTOL} ${BASELINE}/CoordinateToNameTest.txt ${TEMP}/CoordinateToNameMultithreadTest.txt otbCoordinateToNameTest 103.78 1.29 ${TEMP}/CoordinateToNameMultithreadTest.txt 1 ) OTB-release-5.8/Modules/IO/Carto/test/otbCartoTestDriver.cxx000066400000000000000000000006631301006202600237060ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMapFileProductWriterNew); REGISTER_TEST(otbImageToOSMVectorDataGeneratorNew); REGISTER_TEST(otbImageToOSMVectorDataGenerator); REGISTER_TEST(otbMapFileProductWriter); REGISTER_TEST(otbOSMToVectorDataGeneratorNew); REGISTER_TEST(otbOSMToVectorDataGeneratorTest); REGISTER_TEST(otbOSMToVectorDataGeneratorByName); REGISTER_TEST(otbCoordinateToNameTest); } OTB-release-5.8/Modules/IO/Carto/test/otbCoordinateToNameTest.cxx000066400000000000000000000035211301006202600246510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbCoordinateToName.h" #include "otbCurlHelperStub.h" #include "otbThreads.h" int otbCoordinateToNameTest(int argc, char* argv[]) { if (argc < 4) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * outFileName = argv[3]; otb::CoordinateToName::Pointer conv = otb::CoordinateToName::New(); conv->SetLon(atof(argv[1])); conv->SetLat(atof(argv[2])); //only for testing (remove dependency to network conditions) otb::CurlHelperStub::Pointer curlStub = otb::CurlHelperStub::New(); conv->SetCurl(curlStub); if ((argc > 4) && atoi(argv[4]) == 1) { conv->MultithreadOn(); conv->Evaluate(); otb::Threads::Sleep(10000000); //Make sure that the web request has the time to complete } else { conv->MultithreadOff(); conv->Evaluate(); } std::string name = conv->GetPlaceName(); std::string country = conv->GetCountryName(); std::cout << "Nearby place: " << name << std::endl; std::cout << "Country: " << country << std::endl; std::ofstream file; file.open(outFileName); file << "Nearby place: " << name << std::endl; file << "Country: " << country << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/Carto/test/otbImageToOSMVectorDataGenerator.cxx000066400000000000000000000077671301006202600263660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbCommandLineArgumentParser.h" #include "otbImageToOSMVectorDataGenerator.h" #include "otbVectorDataFileWriter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" typedef otb::VectorImage ImageType; typedef otb::ImageToOSMVectorDataGenerator FilterType; typedef FilterType::VectorDataType VectorDataType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorDataFileWriter VectorDataFileWriterType; int otbImageToOSMVectorDataGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { FilterType::Pointer vdgenerator = FilterType::New(); return EXIT_SUCCESS; } int otbImageToOSMVectorDataGenerator(int argc, char * argv[]) { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddInputImage(); parser->AddOption("--OutputVectorData","Output VectorData","-out", true); parser->AddOption("--Key","Key to search in the XML OSM file","-key", 1, false); parser->AddOption("--OSM","OSM XML file to be parsed","-osm", 1, false); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); } catch ( itk::ExceptionObject ) { return EXIT_FAILURE; } // convenient typedefs to store keys and their value typedef std::pair KeyValueType; typedef std::vector KeyValueListType; // Instantiate the image reader ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(parseResult->GetInputImage()); reader->UpdateOutputInformation(); // VectorData generator instantiation FilterType::Pointer vdgenerator = FilterType::New(); vdgenerator->SetInput(reader->GetOutput()); if(parseResult->IsOptionPresent("--OSM")) { vdgenerator->SetUseUrl(false); vdgenerator->SetFileName(parseResult->GetParameterString("--OSM")); } vdgenerator->Update(); // Split the classes to get classes and values KeyValueListType keyvalueList; for (unsigned int idClass = 0; idClass < 1; idClass++) { std::string key; KeyValueType currentkeyvalue; std::string str = parseResult->GetParameterString("--Key"); // find the position of the separator , size_t pos = str.find(","); // split the string currentkeyvalue.first = str.substr (0, pos); if(pos != std::string::npos) currentkeyvalue.second = str.substr (pos+1); keyvalueList.push_back(currentkeyvalue); } std::cout <<"Searching for class "<SetFileName(parseResult->GetParameterString("--OutputVectorData")); if(parseResult->IsOptionPresent("--Key")) { const VectorDataType *vd = vdgenerator->GetVectorDataByName(keyvalueList[0].first, keyvalueList[0].second); writer->SetInput(vd); } else { const VectorDataType *vd = vdgenerator->GetVectorDataByName("highway"); writer->SetInput(vd); } // trigger the execution writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/Carto/test/otbMapFileProductWriter.cxx000066400000000000000000000031471301006202600246750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMapFileProductWriter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" int otbMapFileProductWriter(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * path = argv[2]; const char * shapepath = argv[3]; const char * cgipath = argv[4]; unsigned int tileSize = atoi(argv[5]); typedef otb::VectorImage ImageType; typedef otb::MapFileProductWriter MapFileProductWriterType; typedef otb::ImageFileReader ImageFileReaderType; MapFileProductWriterType::Pointer mapWriter = MapFileProductWriterType::New(); ImageFileReaderType::Pointer reader = ImageFileReaderType::New(); // Read the image reader->SetFileName(infname); reader->UpdateOutputInformation(); mapWriter->SetInput(reader->GetOutput()); mapWriter->SetFileName(path); mapWriter->SetShapeIndexPath(shapepath); mapWriter->SetCGIPath(cgipath); mapWriter->SetTileSize(tileSize); mapWriter->SetSRID(4326); mapWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/Carto/test/otbMapFileProductWriterNew.cxx000066400000000000000000000017421301006202600253460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMapFileProductWriter.h" #include "otbVectorImage.h" int otbMapFileProductWriterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorImage ImageType; typedef otb::MapFileProductWriter MapFileProductWriterType; MapFileProductWriterType::Pointer object = MapFileProductWriterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/Carto/test/otbOSMDataToVectorDataTests.cxx000066400000000000000000000066611301006202600253610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbCommandLineArgumentParser.h" #include "otbOSMDataToVectorDataGenerator.h" #include "otbVectorDataFileWriter.h" typedef otb::OSMDataToVectorDataGenerator FilterType; typedef otb::VectorDataFileWriter VectorDataFileWriterType; int otbOSMToVectorDataGeneratorNew (int itkNotUsed(argc), char * itkNotUsed(argv) []) { FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbOSMToVectorDataGeneratorTest (int itkNotUsed(argc), char * argv[]) { FilterType::Pointer filter = FilterType::New(); filter->SetFileName(argv[1]); filter->SetUseUrl(false); filter->SetNorth(43.62811); filter->SetSouth(43.60185); filter->SetWest(1.54911); filter->SetEast(1.59323); filter->Update(); // Write the IndexTile VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetInput(filter->GetVectorDataByName("building")); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } int otbOSMToVectorDataGeneratorByName (int argc, char * argv[]) { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->AddOption("--OSMFile","The osm file containig the points to extract", "-osm", 1, true); parser->AddOption("--OutputVectorData","The output vectordata", "-vd", 1, true); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); } catch ( itk::ExceptionObject ) { return EXIT_FAILURE; } FilterType::Pointer filter = FilterType::New(); filter->SetFileName(parseResult->GetParameterString("--OSMFile")); filter->SetUseUrl(false); // Set the extent of the request filter->SetNorth(43.62811); filter->SetSouth(43.60185); filter->SetWest(1.54911); filter->SetEast(1.59323); filter->Update(); const FilterType::VectorDataType* v1 = filter->GetVectorDataByName("waterway"); std::cout <<"Size of the vectordata v1 : "<< v1->Size() << std::endl; const FilterType::VectorDataType* v2 = filter->GetVectorDataByName("highway"); std::cout <<"Size of the vectordata v2 : "<< v2->Size() << std::endl; const FilterType::VectorDataType* v3 = filter->GetVectorDataByName("building"); std::cout <<"Size of the vectordata v3 : "<< v3->Size() << std::endl; const FilterType::VectorDataType* v4 = filter->GetVectorDataByName("highway","motorway_link"); std::cout <<"Size of the vectordata v4 : "<< v4->Size() << std::endl; // Write the VectorData VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(parseResult->GetParameterString("--OutputVectorData")); writer->SetInput(v4); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ExtendedFilename/000077500000000000000000000000001301006202600205365ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ExtendedFilename/CMakeLists.txt000066400000000000000000000001471301006202600233000ustar00rootroot00000000000000project(OTBExtendedFilename) set(OTBExtendedFilename_LIBRARIES OTBExtendedFilename) otb_module_impl() OTB-release-5.8/Modules/IO/ExtendedFilename/include/000077500000000000000000000000001301006202600221615ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ExtendedFilename/include/otbExtendedFilenameHelper.h000066400000000000000000000037041301006202600274040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtendedFilenameHelper_h #define otbExtendedFilenameHelper_h #include "itkObject.h" #include "itkObjectFactory.h" namespace otb { /** \class ExtendedFilenameHelper * \brief Helper to handle extended filenames. * * \sa ImageFileReader * * \ingroup OTBExtendedFilename */ class ITK_EXPORT ExtendedFilenameHelper : public itk::Object { public: /** Standard class typedefs. */ typedef ExtendedFilenameHelper Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Object Superclass; itkTypeMacro(ExtendedFilenameHelper, itk::Object); itkNewMacro(Self); typedef std::map< std::string, std::string > OptionMapType; virtual void SetExtendedFileName(const char * extFname); const OptionMapType & GetOptionMap(void) const; itkGetStringMacro(ExtendedFileName); itkGetStringMacro(SimpleFileName); protected: ExtendedFilenameHelper() {} ~ExtendedFilenameHelper() ITK_OVERRIDE {} private: ExtendedFilenameHelper(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented itkSetStringMacro(SimpleFileName); std::string m_ExtendedFileName; std::string m_SimpleFileName; OptionMapType m_OptionMap; }; } // end namespace otb #endif // otbExtendedFilenameHelper_h OTB-release-5.8/Modules/IO/ExtendedFilename/include/otbExtendedFilenameToReaderOptions.h000066400000000000000000000063251301006202600312500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtendedFilenameToReaderOptions_h #define otbExtendedFilenameToReaderOptions_h #include "otbExtendedFilenameHelper.h" namespace otb { /** \class ExtendedFilenameToReaderOptions * \brief Converts an extended filename to reader options. * * Available options for extended file name are: * - &geom : to specify an external geom file * - &sdataidx : sub-dataset index for composite files * - &resol : resolution factor for jpeg200 files * - &skipcarto : switch to skip the cartographic information * - &skipgeom : switch to skip the geometric information * * \sa ImageFileReader * * \ingroup OTBExtendedFilename */ class ITK_EXPORT ExtendedFilenameToReaderOptions : public ExtendedFilenameHelper { public: /** Standard class typedefs. */ typedef ExtendedFilenameToReaderOptions Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef ExtendedFilenameHelper Superclass; itkTypeMacro(ExtendedFilenameToReaderOptions, otb::ExtendedFilenameHelper); itkNewMacro(Self); typedef Superclass FNameHelperType; typedef FNameHelperType::OptionMapType MapType; typedef MapType::iterator MapIteratorType; /** The reader option structure. */ struct OptionType { std::pair< bool, std::string > simpleFileName; std::pair< bool, std::string > extGEOMFileName; std::pair< bool, unsigned int > subDatasetIndex; std::pair< bool, unsigned int > resolutionFactor; std::pair< bool, bool > skipCarto; std::pair< bool, bool > skipGeom; std::pair< bool, bool > skipRpcTag; std::vector optionList; }; /* Set Methods */ void SetExtendedFileName(const char * extFname) ITK_OVERRIDE; /* Get Methods */ bool SimpleFileNameIsSet () const; bool ExtGEOMFileNameIsSet () const; const char* GetExtGEOMFileName () const; bool SubDatasetIndexIsSet () const; unsigned int GetSubDatasetIndex () const; bool ResolutionFactorIsSet () const; unsigned int GetResolutionFactor () const; bool SkipCartoIsSet () const; bool GetSkipCarto () const; bool SkipGeomIsSet () const; bool GetSkipGeom () const; bool SkipRpcTagIsSet () const; bool GetSkipRpcTag () const; protected: ExtendedFilenameToReaderOptions(); ~ExtendedFilenameToReaderOptions() ITK_OVERRIDE {} private: ExtendedFilenameToReaderOptions(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OptionType m_Options; }; } // end namespace otb #endif // otbExtendedFilenameToReaderOptions_h OTB-release-5.8/Modules/IO/ExtendedFilename/include/otbExtendedFilenameToWriterOptions.h000066400000000000000000000070051301006202600313160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExtendedFilenameToWriterOptions_h #define otbExtendedFilenameToWriterOptions_h #include "otbExtendedFilenameHelper.h" #include "otbGDALImageIO.h" namespace otb { /** \class ExtendedFilenameToWriterOptions * \brief Converts an extended filename to writer options. * * Available options for extended file name are: * - &writegeom=ON : to activate the creation of an external geom file * - &gdal:co:= : the gdal creation option * - streaming modes * - box * See http://wiki.orfeo-toolbox.org/index.php/ExtendedFileName * * \sa ImageFileWriter * * \ingroup OTBExtendedFilename */ class ITK_EXPORT ExtendedFilenameToWriterOptions : public ExtendedFilenameHelper { public: /** Standard class typedefs. */ typedef ExtendedFilenameToWriterOptions Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef ExtendedFilenameHelper Superclass; itkTypeMacro(ExtendedFilenameToWriterOptions, otb::ExtendedFilenameHelper); itkNewMacro(Self); typedef Superclass FNameHelperType; typedef FNameHelperType::OptionMapType MapType; typedef MapType::iterator MapIteratorType; /** The writer option structure. */ typedef GDALImageIO::GDALCreationOptionsType GDALCOType; struct OptionType { std::pair< bool, std::string > simpleFileName; std::pair< bool, bool > writeGEOMFile; std::pair< bool, bool > writeRPCTags; std::pair< bool, GDALCOType > gdalCreationOptions; std::pair streamingType; std::pair streamingSizeMode; std::pair streamingSizeValue; std::pair box; std::vector optionList; }; /* Set Methods */ void SetExtendedFileName(const char * extFname) ITK_OVERRIDE; /* Get Methods */ bool SimpleFileNameIsSet () const; bool WriteGEOMFileIsSet () const; bool WriteRPCTagsIsSet() const; bool GetWriteGEOMFile () const; bool GetWriteRPCTags() const; bool gdalCreationOptionsIsSet () const; GDALCOType GetgdalCreationOptions () const; bool StreamingTypeIsSet () const; std::string GetStreamingType() const; bool StreamingSizeModeIsSet() const; std::string GetStreamingSizeMode() const; bool StreamingSizeValueIsSet() const; double GetStreamingSizeValue() const; bool BoxIsSet() const; std::string GetBox() const; protected: ExtendedFilenameToWriterOptions(); ~ExtendedFilenameToWriterOptions() ITK_OVERRIDE {} private: ExtendedFilenameToWriterOptions(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OptionType m_Options; }; } // end namespace otb #endif // otbExtendedFilenameToWriterOptions_h OTB-release-5.8/Modules/IO/ExtendedFilename/otb-module.cmake000066400000000000000000000011111301006202600236010ustar00rootroot00000000000000set(DOCUMENTATION "Extended filenames provide a way to influence how data are read and written by Orfeo ToolBox. They can be used to specify an external geom file for sensor modeling, tell that a TILED GeoTiff is to be written, read a different subdataset or resolution (for multi-resolution data), or manage ortho-ready product by skipping either geographic or sensor-model information.") otb_module(OTBExtendedFilename DEPENDS OTBIOGDAL OTBBoostAdapters OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/ExtendedFilename/src/000077500000000000000000000000001301006202600213255ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ExtendedFilename/src/CMakeLists.txt000066400000000000000000000005301301006202600240630ustar00rootroot00000000000000set(OTBExtendedFilename_SRC otbExtendedFilenameToReaderOptions.cxx otbExtendedFilenameHelper.cxx otbExtendedFilenameToWriterOptions.cxx ) add_library(OTBExtendedFilename ${OTBExtendedFilename_SRC}) target_link_libraries(OTBExtendedFilename ${OTBIOGDAL_LIBRARIES} ${OTBBoost_LIBRARIES} ) otb_module_target(OTBExtendedFilename) OTB-release-5.8/Modules/IO/ExtendedFilename/src/otbExtendedFilenameHelper.cxx000066400000000000000000000037671301006202600271340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbExtendedFilenameHelper.h" #include "otb_boost_string_header.h" namespace otb { void ExtendedFilenameHelper ::SetExtendedFileName(const char *extFname) { if (extFname == ITK_NULLPTR) { itkGenericExceptionMacro( << "Filename is NULL" ); } this->m_ExtendedFileName = extFname; this->m_OptionMap.clear(); std::vector tmp1; std::vector tmp2; if (!m_ExtendedFileName.empty()) { boost::split(tmp1, m_ExtendedFileName, boost::is_any_of("?"), boost::token_compress_on); this->SetSimpleFileName(tmp1[0]); if (tmp1.size()>1) { boost::split(tmp2, tmp1[1], boost::is_any_of("&"), boost::token_compress_on); for (unsigned int i=0; i0) { std::vector tmp; boost::split(tmp, tmp2[i], boost::is_any_of("="), boost::token_compress_on); if (tmp.size()>1) { if (tmp[1].length()>0) { if (m_OptionMap[tmp[0]].empty()) { m_OptionMap[tmp[0]]=tmp[1]; } else { itkWarningMacro("Duplicated option detected: " << tmp[0] << ". Using value " << tmp[1] << "."); } } else itkGenericExceptionMacro( << "Value for option '" << tmp[0] << "' is not set."); } } } } } const ExtendedFilenameHelper::OptionMapType & ExtendedFilenameHelper ::GetOptionMap(void) const { return this->m_OptionMap; } } // end namespace otb OTB-release-5.8/Modules/IO/ExtendedFilename/src/otbExtendedFilenameToReaderOptions.cxx000066400000000000000000000122261301006202600307640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbExtendedFilenameToReaderOptions.h" #include "otb_boost_string_header.h" namespace otb { ExtendedFilenameToReaderOptions ::ExtendedFilenameToReaderOptions() : ExtendedFilenameHelper() { m_Options.simpleFileName.first = false; m_Options.simpleFileName.second = ""; m_Options.extGEOMFileName.first = false; m_Options.extGEOMFileName.second = ""; m_Options.subDatasetIndex.first = false; m_Options.subDatasetIndex.second = 0; m_Options.resolutionFactor.first = false; m_Options.resolutionFactor.second = 0; m_Options.skipCarto.first = false; m_Options.skipCarto.second = false; m_Options.skipGeom.first = false; m_Options.skipGeom.second = false; m_Options.skipRpcTag.first = false; m_Options.skipRpcTag.second = false; m_Options.optionList.push_back("geom"); m_Options.optionList.push_back("sdataidx"); m_Options.optionList.push_back("resol"); m_Options.optionList.push_back("skipcarto"); m_Options.optionList.push_back("skipgeom"); m_Options.optionList.push_back("skiprpctag"); } void ExtendedFilenameToReaderOptions ::SetExtendedFileName(const char *extFname) { Superclass::SetExtendedFileName(extFname); MapType map = GetOptionMap(); m_Options.simpleFileName.first = true; m_Options.simpleFileName.second = this->GetSimpleFileName(); if (!map["geom"].empty()) { m_Options.extGEOMFileName.first = true; m_Options.extGEOMFileName.second = map["geom"]; } if (!map["sdataidx"].empty()) { m_Options.subDatasetIndex.first = true; m_Options.subDatasetIndex.second = atoi(map["sdataidx"].c_str()); } if (!map["resol"].empty()) { m_Options.resolutionFactor.first = true; m_Options.resolutionFactor.second = atoi(map["resol"].c_str()); } if (!map["skipcarto"].empty()) { m_Options.skipCarto.first = true; if ( map["skipcarto"] == "On" || map["skipcarto"] == "on" || map["skipcarto"] == "ON" || map["skipcarto"] == "true" || map["skipcarto"] == "True" || map["skipcarto"] == "1" ) { m_Options.skipCarto.second = true; } } if (!map["skipgeom"].empty()) { m_Options.skipGeom.first = true; if ( map["skipgeom"] == "On" || map["skipgeom"] == "on" || map["skipgeom"] == "ON" || map["skipgeom"] == "true" || map["skipgeom"] == "True" || map["skipgeom"] == "1" ) { m_Options.skipGeom.second = true; } } if (!map["skiprpctag"].empty()) { m_Options.skipRpcTag.first = true; if ( map["skiprpctag"] == "On" || map["skiprpctag"] == "on" || map["skiprpctag"] == "ON" || map["skiprpctag"] == "true" || map["skiprpctag"] == "True" || map["skiprpctag"] == "1" ) { m_Options.skipRpcTag.second = true; } } //Option Checking MapIteratorType it; for ( it=map.begin(); it != map.end(); it++ ) { bool isKnown=false; for (unsigned int i=0; ifirst) isKnown=true; } if(!isKnown) itkWarningMacro("Unknown option detected: " << it->first << "."); } } bool ExtendedFilenameToReaderOptions ::SimpleFileNameIsSet () const { return m_Options.simpleFileName.first; } bool ExtendedFilenameToReaderOptions ::ExtGEOMFileNameIsSet () const { return m_Options.extGEOMFileName.first; } const char* ExtendedFilenameToReaderOptions ::GetExtGEOMFileName () const { return m_Options.extGEOMFileName.second.c_str(); } bool ExtendedFilenameToReaderOptions ::SubDatasetIndexIsSet () const { return m_Options.subDatasetIndex.first; } unsigned int ExtendedFilenameToReaderOptions ::GetSubDatasetIndex () const { return m_Options.subDatasetIndex.second; } bool ExtendedFilenameToReaderOptions ::ResolutionFactorIsSet () const { return m_Options.resolutionFactor.first; } unsigned int ExtendedFilenameToReaderOptions ::GetResolutionFactor () const { return m_Options.resolutionFactor.second; } bool ExtendedFilenameToReaderOptions ::SkipCartoIsSet () const { return m_Options.skipCarto.first; } bool ExtendedFilenameToReaderOptions ::GetSkipCarto () const { return m_Options.skipCarto.second; } bool ExtendedFilenameToReaderOptions ::SkipGeomIsSet () const { return m_Options.skipGeom.first; } bool ExtendedFilenameToReaderOptions ::GetSkipGeom () const { return m_Options.skipGeom.second; } bool ExtendedFilenameToReaderOptions ::SkipRpcTagIsSet () const { return m_Options.skipRpcTag.first; } bool ExtendedFilenameToReaderOptions ::GetSkipRpcTag () const { return m_Options.skipRpcTag.second; } } // end namespace otb OTB-release-5.8/Modules/IO/ExtendedFilename/src/otbExtendedFilenameToWriterOptions.cxx000066400000000000000000000161401301006202600310350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbExtendedFilenameToWriterOptions.h" #include "otb_boost_string_header.h" #include #include "otb_boost_tokenizer_header.h" namespace otb { ExtendedFilenameToWriterOptions ::ExtendedFilenameToWriterOptions() : ExtendedFilenameHelper() { m_Options.simpleFileName.first = false; m_Options.simpleFileName.second = ""; m_Options.writeGEOMFile.first = false; m_Options.writeGEOMFile.second = true; m_Options.writeRPCTags.first = false; m_Options.writeRPCTags.second = false; m_Options.gdalCreationOptions.first = false; m_Options.streamingType.first = false; m_Options.streamingSizeMode.first = false; m_Options.streamingSizeValue.first = false; m_Options.optionList.push_back("writegeom"); m_Options.optionList.push_back("writerpctags"); m_Options.optionList.push_back("streaming:type"); m_Options.optionList.push_back("streaming:sizemode"); m_Options.optionList.push_back("streaming:sizevalue"); m_Options.optionList.push_back("box"); } void ExtendedFilenameToWriterOptions ::SetExtendedFileName(const char *extFname) { this->Superclass::SetExtendedFileName(extFname); // TODO: Rename map to a less confusing (with std::map) name MapType map = this->GetOptionMap(); m_Options.simpleFileName.first = true; m_Options.simpleFileName.second = this->GetSimpleFileName(); MapIteratorType it; for ( it=map.begin(); it != map.end(); it++ ) { std::vector tmp; boost::split(tmp, it->first, boost::is_any_of(":"), boost::token_compress_on); if (tmp.size()>2) if ((tmp[0]=="gdal") && (tmp[1]=="co")) { m_Options.gdalCreationOptions.first = true; m_Options.gdalCreationOptions.second.push_back(tmp[2] + "=" +it->second); } } if (!map["writegeom"].empty()) { m_Options.writeGEOMFile.first = true; if ( map["writegeom"] == "Off" || map["writegeom"] == "off" || map["writegeom"] == "OFF" || map["writegeom"] == "false" || map["writegeom"] == "False" || map["writegeom"] == "0" ) { m_Options.writeGEOMFile.second = false; } } if (!map["writerpctags"].empty()) { m_Options.writeRPCTags.first = true; if ( map["writerpctags"] == "On" || map["writerpctags"] == "on" || map["writerpctags"] == "ON" || map["writerpctags"] == "true" || map["writerpctags"] == "True" || map["writerpctags"] == "1" ) { m_Options.writeRPCTags.second = true; } } if(!map["streaming:type"].empty()) { if(map["streaming:type"] == "auto" || map["streaming:type"] == "tiled" || map["streaming:type"] == "stripped" || map["streaming:type"] == "none") { m_Options.streamingType.first=true; m_Options.streamingType.second = map["streaming:type"]; } else { itkWarningMacro("Unkwown value "< tmp; boost::split(tmp, it->first, boost::is_any_of(":"), boost::token_compress_on); if (tmp.size()>2) { if (!(tmp[0]=="gdal") || !(tmp[1]=="co")) { itkWarningMacro("Unknown option detected: " << it->first << "."); } } else { bool isKnown=false; for (unsigned int i=0; ifirst) isKnown=true; } if(!isKnown) itkWarningMacro("Unknown option detected: " << it->first << "."); } } } bool ExtendedFilenameToWriterOptions ::SimpleFileNameIsSet () const { return m_Options.simpleFileName.first; } bool ExtendedFilenameToWriterOptions ::WriteGEOMFileIsSet () const { return m_Options.writeGEOMFile.first; } bool ExtendedFilenameToWriterOptions ::WriteRPCTagsIsSet () const { return m_Options.writeRPCTags.first; } bool ExtendedFilenameToWriterOptions ::GetWriteGEOMFile () const { return m_Options.writeGEOMFile.second; } bool ExtendedFilenameToWriterOptions ::GetWriteRPCTags () const { return m_Options.writeRPCTags.second; } bool ExtendedFilenameToWriterOptions ::gdalCreationOptionsIsSet () const { return m_Options.gdalCreationOptions.first; } ExtendedFilenameToWriterOptions ::GDALCOType ExtendedFilenameToWriterOptions ::GetgdalCreationOptions () const { return m_Options.gdalCreationOptions.second; } bool ExtendedFilenameToWriterOptions ::StreamingTypeIsSet() const { return m_Options.streamingType.first; } bool ExtendedFilenameToWriterOptions ::StreamingSizeModeIsSet() const { return m_Options.streamingSizeMode.first; } bool ExtendedFilenameToWriterOptions ::StreamingSizeValueIsSet() const { return m_Options.streamingSizeValue.first; } std::string ExtendedFilenameToWriterOptions ::GetStreamingType() const { return m_Options.streamingType.second; } std::string ExtendedFilenameToWriterOptions ::GetStreamingSizeMode() const { return m_Options.streamingSizeMode.second; } double ExtendedFilenameToWriterOptions ::GetStreamingSizeValue() const { return m_Options.streamingSizeValue.second; } bool ExtendedFilenameToWriterOptions ::BoxIsSet() const { return m_Options.box.first; } std::string ExtendedFilenameToWriterOptions ::GetBox() const { return m_Options.box.second; } } // end namespace otb OTB-release-5.8/Modules/IO/ExtendedFilename/test/000077500000000000000000000000001301006202600215155ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ExtendedFilename/test/CMakeLists.txt000066400000000000000000000145571301006202600242710ustar00rootroot00000000000000otb_module_test() set(OTBExtendedFilenameTests otbExtendedFilenameTestDriver.cxx otbExtendedFilenameToReaderOptionsTest.cxx otbExtendedFilenameToWriterOptionsTest.cxx otbExtendedFilenameTest.cxx ) add_executable(otbExtendedFilenameTestDriver ${OTBExtendedFilenameTests}) target_link_libraries(otbExtendedFilenameTestDriver ${OTBExtendedFilename-Test_LIBRARIES}) otb_module_target_label(otbExtendedFilenameTestDriver) # Tests Declaration set(streaming_sizevalue_auto "8") set(streaming_sizevalue_nbsplits "10") set(streaming_sizevalue_height "100") foreach(streaming_type "Tiled" "Stripped") foreach(streaming_sizemode "Auto" "Nbsplits" "Height") string(TOLOWER ${streaming_type} type) string(TOLOWER ${streaming_sizemode} sizemode) set(test_name "ioTvImageFileWriterExtendedFileName_Streaming${streaming_type}${streaming_sizemode}") otb_add_test(NAME ${test_name} COMMAND otbExtendedFilenameTestDriver --compare-image ${NOTOL} ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/${test_name}.tif otbImageFileWriterWithExtendedFilename ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/${test_name}.tif?&streaming:type=${type}&streaming:sizemode=${sizemode}&streaming:sizevalue=${streaming_sizevalue_${sizemode}} ) endforeach() endforeach() otb_add_test(NAME ioTvExtendedFilenameToReaderOptions_FullOptions COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioTvExtendedFilenameToReaderOptions_FullOptions.txt ${TEMP}/ioTvExtendedFilenameToReaderOptions_FullOptions.txt otbExtendedFilenameToReaderOptions /home/data/filename.tif?&geom=/home/dev/custom.geom&sdataidx=2&resol=4&skipcarto=On ${TEMP}/ioTvExtendedFilenameToReaderOptions_FullOptions.txt ) otb_add_test(NAME ioTvExtendedFilenameToReaderOptions_NoOptions COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioTvExtendedFilenameToReaderOptions_NoOptions.txt ${TEMP}/ioTvExtendedFilenameToReaderOptions_NoOptions.txt otbExtendedFilenameToReaderOptions /home/data/filename.tif ${TEMP}/ioTvExtendedFilenameToReaderOptions_NoOptions.txt ) otb_add_test(NAME ioTvExtendedFilenameToWriterOptions_FullOptions COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioTvExtendedFilenameToWriterOptions_FullOptions.txt ${TEMP}/ioTvExtendedFilenameToWriterOptions_FullOptions.txt otbExtendedFilenameToWriterOptions /home/data/filename.tif?&writegeom=ON&gdal:co:QUALITY=75&gdal:co:TILED=YES&gdal:co:BLOCKYSIZE=1024 ${TEMP}/ioTvExtendedFilenameToWriterOptions_FullOptions.txt ) otb_add_test(NAME ioTvExtendedFilenameToWriterOptions_NoOptions COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioTvExtendedFilenameToWriterOptions_NoOptions.txt ${TEMP}/ioTvExtendedFilenameToWriterOptions_NoOptions.txt otbExtendedFilenameToWriterOptions /home/data/filename.tif ${TEMP}/ioTvExtendedFilenameToWriterOptions_NoOptions.txt ) otb_add_test(NAME ioTvImageFileWriterExtendedFileName_StreamingNone COMMAND otbExtendedFilenameTestDriver --compare-image ${NOTOL} ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioImageFileWriterExtendedFileName_streamingNone.tif otbImageFileWriterWithExtendedFilename ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioImageFileWriterExtendedFileName_streamingNone.tif?&streaming:type=none) otb_add_test(NAME ioTvImageFileReaderExtendedFileName_GEOM COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioImageFileReaderWithExternalGEOMFile.txt ${TEMP}/ioImageFileReaderWithExternalGEOMFile.txt otbImageFileReaderWithExtendedFilename ${INPUTDATA}/ToulouseExtract_WithGeom.tif?&geom=${INPUTDATA}/ToulouseExtract_ModifiedGeom.geom ${TEMP}/ioImageFileReaderWithExternalGEOMFile.txt ${TEMP}/ioImageFileReaderWithExternalGEOMFile_pr.txt ) otb_add_test(NAME ioTvImageFileWriterExtendedFileName_GEOM COMMAND otbExtendedFilenameTestDriver --ignore-order --compare-ascii ${NOTOL} ${INPUTDATA}/ToulouseExtract_WithGeom.geom ${TEMP}/ioImageFileWriterExtendedFileName_GEOM.geom --ignore-lines-with 2 ce90_absolute ce90_relative otbImageFileWriterWithExtendedFilename ${INPUTDATA}/ToulouseExtract_WithGeom.tif ${TEMP}/ioImageFileWriterExtendedFileName_GEOM.tif?&writegeom=ON ) otb_add_test(NAME ioTvImageFileWriterExtendedFileName_StreamingAuto COMMAND otbExtendedFilenameTestDriver --compare-image ${NOTOL} ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioImageFileWriterExtendedFileName_streamingAuto.tif otbImageFileWriterWithExtendedFilename ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioImageFileWriterExtendedFileName_streamingAuto.tif?&streaming:type=auto&streaming:sizevalue=${streaming_sizevalue_auto}) otb_add_test(NAME ioTvImageFileReaderExtendedFileName_mix1 COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioImageFileReaderExtendedFileName_mix1pr.txt ${TEMP}/ioImageFileReaderExtendedFileName_mix1pr.txt otbImageFileReaderWithExtendedFilename ${INPUTDATA}/bretagne.j2k?&skipcarto=true&resol=2 ${TEMP}/ioImageFileReaderExtendedFileName_mix1kwl.txt ${TEMP}/ioImageFileReaderExtendedFileName_mix1pr.txt ) otb_add_test(NAME ioTvImageFileWriterExtendedFileName_gdalco COMMAND otbExtendedFilenameTestDriver --compare-image ${NOTOL} ${BASELINE}/ioTvGDALImageIO_JPEG_20.jpg ${TEMP}/ioImageFileWriterExtendedFileName_gdalco.jpg otbImageFileWriterWithExtendedFilename ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioImageFileWriterExtendedFileName_gdalco.jpg?&gdal:co:QUALITY=20 ) otb_add_test(NAME ioTvImageFileReaderExtendedFileName_SkipGeom COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioImageFileReaderExtendedFileName_Skipgeom_pr.txt ${TEMP}/ioImageFileReaderExtendedFileName_Skipgeom_pr.txt otbImageFileReaderWithExtendedFilename ${INPUTDATA}/ToulouseExtract_WithGeom.tif?&skipgeom=true ${TEMP}/ioImageFileReaderExtendedFileName_Skipgeom_kwl.txt ${TEMP}/ioImageFileReaderExtendedFileName_Skipgeom_pr.txt ) otb_add_test(NAME ioTvImageFileReaderExtendedFileName_SkipPR COMMAND otbExtendedFilenameTestDriver --compare-ascii ${NOTOL} ${BASELINE}/ioImageFileReaderExtendedFileName_SkipPR.txt ${TEMP}/ioImageFileReaderExtendedFileName_SkipPR.txt otbImageFileReaderWithExtendedFilename ${INPUTDATA}/ToulouseExtract_WithGeom.tif?&skipcarto=true ${TEMP}/ioImageFileReaderExtendedFileName_SkipPR_kwl.txt ${TEMP}/ioImageFileReaderExtendedFileName_SkipPR.txt ) OTB-release-5.8/Modules/IO/ExtendedFilename/test/otbExtendedFilenameTest.cxx000066400000000000000000000046351301006202600270170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileReaderWithExtendedFilename(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename1 = argv[2]; const char * outputFilename2 = argv[3]; typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); std::ofstream file1; file1.open(outputFilename1); std::ofstream file2; file2.open(outputFilename2); reader->SetFileName(inputFilename); reader->Update(); file1 << reader->GetOutput()->GetImageKeywordlist(); file2 << "ProjRef: " << reader->GetOutput()->GetProjectionRef() << std::endl; file2 << "Origin: " << reader->GetOutput()->GetOrigin() << std::endl; file2 << "Spacing: " << reader->GetOutput()->GetSpacing() << std::endl; return EXIT_SUCCESS; } int otbImageFileWriterWithExtendedFilename(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetInput(reader->GetOutput()); writer->SetFileName(outputFilename); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ExtendedFilename/test/otbExtendedFilenameTestDriver.cxx000066400000000000000000000004161301006202600301640ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbExtendedFilenameToReaderOptions); REGISTER_TEST(otbExtendedFilenameToWriterOptions); REGISTER_TEST(otbImageFileReaderWithExtendedFilename); REGISTER_TEST(otbImageFileWriterWithExtendedFilename); } OTB-release-5.8/Modules/IO/ExtendedFilename/test/otbExtendedFilenameToReaderOptionsTest.cxx000066400000000000000000000032041301006202600320100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbExtendedFilenameToReaderOptions.h" #include #include typedef otb::ExtendedFilenameToReaderOptions FilenameHelperType; int otbExtendedFilenameToReaderOptions(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputExtendedFilename = argv[1]; const char * outputFilename = argv[2]; FilenameHelperType::Pointer helper = FilenameHelperType::New(); helper->SetExtendedFileName(inputExtendedFilename); std::ofstream file; file.open(outputFilename); file << helper->SimpleFileNameIsSet() << std::endl; file << helper->GetSimpleFileName() << std::endl; file << helper->ExtGEOMFileNameIsSet() << std::endl; file << helper->GetExtGEOMFileName() << std::endl; file << helper->SubDatasetIndexIsSet() << std::endl; file << helper->GetSubDatasetIndex() << std::endl; file << helper->ResolutionFactorIsSet() << std::endl; file << helper->GetResolutionFactor() << std::endl; file << helper->SkipCartoIsSet() << std::endl; file << helper->GetSkipCarto() << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ExtendedFilename/test/otbExtendedFilenameToWriterOptionsTest.cxx000066400000000000000000000030761301006202600320710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbExtendedFilenameToWriterOptions.h" #include #include typedef otb::ExtendedFilenameToWriterOptions FilenameHelperType; int otbExtendedFilenameToWriterOptions(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputExtendedFilename = argv[1]; const char * outputFilename = argv[2]; FilenameHelperType::Pointer helper = FilenameHelperType::New(); helper->SetExtendedFileName(inputExtendedFilename); std::ofstream file; file.open(outputFilename); file << helper->SimpleFileNameIsSet() << std::endl; file << helper->GetSimpleFileName() << std::endl; file << helper->WriteGEOMFileIsSet() << std::endl; file << helper->GetWriteGEOMFile() << std::endl; file << helper->gdalCreationOptionsIsSet() << std::endl; if (helper->gdalCreationOptionsIsSet()) for (unsigned int i=0; iGetgdalCreationOptions().size(); i++) { file << helper->GetgdalCreationOptions()[i] << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOBSQ/000077500000000000000000000000001301006202600162125ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOBSQ/CMakeLists.txt000066400000000000000000000001061301006202600207470ustar00rootroot00000000000000project(OTBIOBSQ) set(OTBIOBSQ_LIBRARIES OTBIOBSQ) otb_module_impl() OTB-release-5.8/Modules/IO/IOBSQ/include/000077500000000000000000000000001301006202600176355ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOBSQ/include/otbBSQImageIO.h000066400000000000000000000132321301006202600223340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSQImageIO_h #define otbBSQImageIO_h #include #include #include #include "otbImageIOBase.h" namespace otb { /** \class BSQImageIO * * \brief ImageIO object for reading (not writing) BSQ format images * * The streaming read is implemented. * * \ingroup IOFilters * * * \ingroup OTBIOBSQ */ class ITK_EXPORT BSQImageIO : public otb::ImageIOBase { public: /** Standard class typedefs. */ typedef BSQImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Byte order typedef */ typedef Superclass::ByteOrder ByteOrder; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BSQImageIO, otb::ImageIOBase); /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Reads 3D data from multiple files assuming one slice per file. */ virtual void ReadVolume(void* buffer); /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; // JULIEN: NOT USED, NOT IMPLEMENTED // void SampleImage(void* buffer, int XBegin, int YBegin, int SizeXRead, int SizeYRead, int XSample, int YSample); /** Get the number of overviews available into the file specified * This imageIO didn't support overviews */ unsigned int GetOverviewsCount() ITK_OVERRIDE { // MANTIS-1154: Source image is always considered as the best // resolution overview. return 1; } /** Get information about overviews available into the file specified * This imageIO didn't support overviews */ std::vector GetOverviewsInfo() ITK_OVERRIDE { std::vector desc; return desc; } /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} protected: /** Constructor.*/ BSQImageIO(); /** Destructor.*/ ~BSQImageIO() ITK_OVERRIDE; bool OpenOneraDataFileForReading(const char* filename); bool OpenOneraHeaderFileForReading(const char* filename); void InternalReadImageInformation(); bool OpenOneraDataFileForWriting(const char* filename); bool OpenOneraHeaderFileForWriting(const char* filename); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BSQImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Internal method to read header information */ bool InternalReadHeaderInformation(const std::string& file_name, std::fstream& file, const bool reportError); #define otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ { \ typedef itk::ByteSwapper InternalByteSwapperType; \ if (m_ByteOrder != m_FileByteOrder) \ { \ if (m_ByteOrder == LittleEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToBigEndian((StrongType *) buffer, buffer_size); \ } \ else if (m_ByteOrder == BigEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToLittleEndian((StrongType *) buffer, buffer_size); \ } \ } \ } #define otbSwappFileToSystemMacro(StrongType, WeakType, buffer, buffer_size) \ else if (this->GetComponentType() == WeakType) \ { \ otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ } #define otbSetTypeBsqMacro(WeakType, CAI_VALUE) \ else if (this->GetComponentType() == WeakType) \ { \ m_TypeBsq = CAI_VALUE; \ } bool m_FlagWriteImageInformation; otb::ImageIOBase::ByteOrder m_FileByteOrder; std::fstream m_HeaderFile; std::string m_TypeBsq; std::vector m_ChannelsFileName; std::fstream * m_ChannelsFile; }; } // end namespace otb #endif // otbBSQImageIO_h OTB-release-5.8/Modules/IO/IOBSQ/include/otbBSQImageIOFactory.h000066400000000000000000000040121301006202600236600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSQImageIOFactory_h #define otbBSQImageIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class BSQImageIOFactory * \brief Creation d'un instance d'un objet BSQImageIO utilisant les object factory. * * \ingroup OTBIOBSQ */ class ITK_EXPORT BSQImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef BSQImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static BSQImageIOFactory * FactoryNew() { return new BSQImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(BSQImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { BSQImageIOFactory::Pointer BSQFactory = BSQImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactoryInternal(BSQFactory); } protected: BSQImageIOFactory(); ~BSQImageIOFactory() ITK_OVERRIDE; private: BSQImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOBSQ/otb-module.cmake000066400000000000000000000003411301006202600212610ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read BSQ format images.") otb_module(OTBIOBSQ DEPENDS OTBImageBase OTBCommon OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOBSQ/src/000077500000000000000000000000001301006202600170015ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOBSQ/src/CMakeLists.txt000066400000000000000000000003421301006202600215400ustar00rootroot00000000000000set(OTBIOBSQ_SRC otbBSQImageIOFactory.cxx otbBSQImageIO.cxx ) add_library(OTBIOBSQ ${OTBIOBSQ_SRC}) target_link_libraries(OTBIOBSQ ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBIOBSQ) OTB-release-5.8/Modules/IO/IOBSQ/src/otbBSQImageIO.cxx000066400000000000000000000520261301006202600220570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbBSQImageIO.h" #include #include #include "itkByteSwapper.h" #include "otbSystem.h" #include "itksys/SystemTools.hxx" #include "otbMacro.h" namespace otb { BSQImageIO::BSQImageIO() { // By default set number of dimensions to two. this->SetNumberOfDimensions(2); m_PixelType = SCALAR; m_ComponentType = UCHAR; if (itk::ByteSwapper::SystemIsLittleEndian() == true) { m_ByteOrder = LittleEndian; } else { m_ByteOrder = BigEndian; } m_FileByteOrder = m_ByteOrder; m_TypeBsq = ""; // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to [0.5 , 0.5] // (consistency between ImageIO, see Mantis #942) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_ChannelsFile = ITK_NULLPTR; m_FlagWriteImageInformation = true; this->AddSupportedWriteExtension(".hd"); this->AddSupportedWriteExtension(".HD"); this->AddSupportedReadExtension(".hd"); this->AddSupportedReadExtension(".HD"); } BSQImageIO::~BSQImageIO() { if (m_HeaderFile.is_open()) { m_HeaderFile.close(); } if (m_ChannelsFile != ITK_NULLPTR) { for (unsigned int numComponent = 0; numComponent < this->GetNumberOfComponents(); numComponent++) { if (m_ChannelsFile[numComponent].is_open()) { m_ChannelsFile[numComponent].close(); } } delete[] m_ChannelsFile; } } bool BSQImageIO::CanReadFile(const char* filename) { std::fstream header_file; std::string lFileName(filename); std::string extension = itksys::SystemTools::GetFilenameLastExtension(filename); if ((extension != ".HD") && (extension != ".hd")) { return false; } if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } if (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(lFileName)) != ".hd") { return false; } header_file.open(lFileName.c_str(), std::ios::in); if (header_file.fail()) { otbMsgDevMacro(<< "BSQImageIO::CanReadFile() failed header open ! "); return false; } //Read header information bool lResult = InternalReadHeaderInformation(lFileName, header_file, false); header_file.close(); return (lResult); } // Used to print information about this object void BSQImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // Read a 3D image (or event more bands)... not implemented yet void BSQImageIO::ReadVolume(void*) { } // Read image void BSQImageIO::Read(void* buffer) { unsigned long step = this->GetNumberOfComponents(); char * p = static_cast(buffer); int lNbLines = this->GetIORegion().GetSize()[1]; int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] otbMsgDevMacro(<< " BSQImageIO::Read() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); std::streamoff headerLength(0); std::streamoff numberOfBytesPerLines = static_cast(this->GetComponentSize() * m_Dimensions[0]); std::streamoff offset; std::streamsize numberOfBytesToBeRead = this->GetComponentSize() * lNbColumns; std::streamsize numberOfBytesRead; unsigned long cpt = 0; // Update the step variable step = step * (unsigned long) (this->GetComponentSize()); char * value = new char[numberOfBytesToBeRead]; if (value == ITK_NULLPTR) { itkExceptionMacro(<< "BSQImageIO::Read(): Bad alloc"); return; } otbMsgDevMacro(<< " sizeof(streamsize) : " << sizeof(std::streamsize)); otbMsgDevMacro(<< " sizeof(streampos) : " << sizeof(std::streampos)); otbMsgDevMacro(<< " sizeof(streamoff) : " << sizeof(std::streamoff)); otbMsgDevMacro(<< " sizeof(std::ios::beg) : " << sizeof(std::ios::beg)); otbMsgDevMacro(<< " sizeof(size_t) : " << sizeof(size_t)); otbMsgDevMacro(<< " sizeof(unsigned long) : " << sizeof(unsigned long)); for (unsigned int nbComponents = 0; nbComponents < this->GetNumberOfComponents(); ++nbComponents) { cpt = (unsigned long) (nbComponents) * (unsigned long) (this->GetComponentSize()); //Read region of the channel for (int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(this->GetComponentSize() * lFirstColumn); m_ChannelsFile[nbComponents].seekg(offset, std::ios::beg); //Read a line m_ChannelsFile[nbComponents].read(static_cast(value), numberOfBytesToBeRead); numberOfBytesRead = m_ChannelsFile[nbComponents].gcount(); #ifdef __APPLE_CC__ // fail() is broken in the Mac. It returns true when reaches eof(). if (numberOfBytesRead != numberOfBytesToBeRead) #else if ((numberOfBytesRead != numberOfBytesToBeRead) || m_ChannelsFile[nbComponents].fail()) #endif { itkExceptionMacro(<< "BSQImageIO::Read() Can Read the specified Region"); // read failed } // cpt = (unsigned long )(nbComponents)* (unsigned long)(this->GetComponentSize()) + numberOfBytesToBeRead * this->GetNumberOfComponents() * LineNo; // cpt = (unsigned long )(nbComponents)* (unsigned long)(this->GetComponentSize()) + numberOfBytesToBeRead * this->GetNumberOfComponents(); for (std::streamsize i = 0; i < numberOfBytesToBeRead; i = i + static_cast(this->GetComponentSize())) { memcpy((void*) (&(p[cpt])), (const void*) (&(value[i])), (size_t) (this->GetComponentSize())); cpt += step; } } } unsigned long numberOfPixelsOfRegion = lNbLines * lNbColumns * this->GetNumberOfComponents(); delete[] value; // Swap bytes if necessary if (0) {} otbSwappFileToSystemMacro(unsigned short, USHORT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(short, SHORT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(char, CHAR, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(unsigned char, UCHAR, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(unsigned int, UINT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(int, INT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(long, LONG, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(unsigned long, ULONG, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(float, FLOAT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(double, DOUBLE, buffer, numberOfPixelsOfRegion) else { itkExceptionMacro(<< "BSQImageIO::Read() undefined component type! "); } } void BSQImageIO::ReadImageInformation() { if (m_HeaderFile.is_open()) { m_HeaderFile.close(); } m_HeaderFile.open(m_FileName.c_str(), std::ios::in); if (m_HeaderFile.fail()) { itkExceptionMacro(<< "BSQImageIO::ReadImageInformation() failed header open ! "); } //Read header information InternalReadHeaderInformation(m_FileName, m_HeaderFile, true); otbMsgDebugMacro(<< "Driver to read: BSQ"); otbMsgDebugMacro(<< " Read file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } bool BSQImageIO::InternalReadHeaderInformation(const std::string& file_name, std::fstream& file, const bool reportError) { std::string lString; std::string lStrCodePix; //Read TYPE information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if (lString != "TYPE") { if (reportError == true) { itkExceptionMacro(<< "BSQ : the first line of the header file must be contains 'TYPE' caracters."); } else { return false; } } file >> lStrCodePix; lStrCodePix = itksys::SystemTools::UpperCase(lStrCodePix); if (lStrCodePix == "OCT") { SetComponentType(CHAR); } else if (lStrCodePix == "UOCT") { SetComponentType(UCHAR); } else if (lStrCodePix == "I2") { SetComponentType(SHORT); } else if (lStrCodePix == "UI2") { SetComponentType(USHORT); } else if (lStrCodePix == "I4") { SetComponentType(INT); } else if (lStrCodePix == "UI4") { SetComponentType(UINT); } else if (lStrCodePix == "R4") { SetComponentType(FLOAT); } else if (lStrCodePix == "R8") { SetComponentType(DOUBLE); } else { if (reportError == true) { itkExceptionMacro( << "BSQ : the value type '" << lStrCodePix << "' (second line) set in the header file is not recognized as correct value."); } else { return false; } } //Read LABEL information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if (lString != "LABEL") { if (reportError == true) { itkExceptionMacro(<< "BSQ : the third line of the header file must be contains 'LABEL' caracters."); } else { return false; } } while ((lString != "CHANNELS") || (file.eof())) { file >> lString; lString = itksys::SystemTools::UpperCase(lString); } if (lString != "CHANNELS") { if (reportError == true) { itkExceptionMacro(<< "BSQ : 'CHANNELS' keyword is not find in the header file."); } else { return false; } } unsigned int lNbChannels; file >> lNbChannels; this->SetNumberOfComponents(lNbChannels); //Read LINES information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if (lString != "LINES") { if (reportError == true) { itkExceptionMacro(<< "BSQ : 'LINES' keyword is not find in the header file."); } else { return false; } } file >> m_Dimensions[1]; //Read COLUMNS information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if (lString != "COLUMNS") { if (reportError == true) { itkExceptionMacro(<< "BSQ : 'COLUMNS' keyword is not find in the header file."); } else { return false; } } file >> m_Dimensions[0]; //Read "BITS PER PIXEL" information file >> lString; std::string lStrBitsPerPixels(lString); file >> lString; lStrBitsPerPixels = lStrBitsPerPixels + " " + lString; file >> lString; lStrBitsPerPixels = lStrBitsPerPixels + " " + lString; lStrBitsPerPixels = itksys::SystemTools::UpperCase(lStrBitsPerPixels); if (lStrBitsPerPixels != "BITS PER PIXEL") { if (reportError == true) { itkExceptionMacro(<< "BSQ : 'BITS PER PIXEL' keyword is not find in the header file."); } else { return false; } } int lNbBitsPerPixels; file >> lNbBitsPerPixels; //Read "SENSCODAGE" information (optional) file >> lString; if (lString.empty() == false) { lString = itksys::SystemTools::UpperCase(lString); if (lString == "SENSCODAGE") { file >> lString; lString = itksys::SystemTools::UpperCase(lString); if (lString == "INTEL") { m_FileByteOrder = LittleEndian; } else if (lString == "IEEE") { m_FileByteOrder = BigEndian; } else { if (reportError == true) { itkExceptionMacro( << "BSQ : the value SENSCODAGE '" << lString << "' set in the header file is not recognized as correct value. Possible values are INTEL or IEEE"); } else { return false; } } } } file.close(); //Define channels file name std::string lRootName = System::GetRootName(file_name); m_ChannelsFileName.clear(); for (unsigned int i = 0; i < this->GetNumberOfComponents(); ++i) { std::ostringstream lStream; lStream << lRootName << ".c" << i + 1; m_ChannelsFileName.push_back(lStream.str()); } m_ChannelsFile = new std::fstream[this->GetNumberOfComponents()]; //Try to open channels file for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels) { m_ChannelsFile[channels].open(m_ChannelsFileName[channels].c_str(), std::ios::in | std::ios::binary); if (m_ChannelsFile[channels].fail()) { if (reportError == true) { itkExceptionMacro(<< "BSQ : impossible to find the file <" << m_ChannelsFileName[channels] << ">."); } else { return false; } } } this->SetFileTypeToBinary(); this->SetNumberOfDimensions(2); return (true); } bool BSQImageIO::CanWriteFile(const char* filename) { std::string lFileName(filename); std::string extension = itksys::SystemTools::GetFilenameLastExtension(filename); if ((extension != ".HD") && (extension != ".hd")) { return false; } if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } const std::string Extension = itksys::SystemTools::GetFilenameLastExtension(filename); if ((Extension == ".hd") || (Extension == ".HD")) { return true; } else { return false; } } void BSQImageIO::Write(const void* buffer) { if (m_FlagWriteImageInformation == true) { this->WriteImageInformation(); m_FlagWriteImageInformation = false; } unsigned long step = this->GetNumberOfComponents(); unsigned int lNbLines = this->GetIORegion().GetSize()[1]; unsigned int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] // Special case: check that the region to write is the same size as the entire // image. Start at offset 0 (when no streaming) if ((lNbLines == m_Dimensions[1]) && (lNbColumns == m_Dimensions[0])) { otbMsgDevMacro(<< "Forcing offset to [0, 0]"); lFirstLine = 0; lFirstColumn = 0; } otbMsgDevMacro(<< " BSQImageIO::Write() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); otbMsgDevMacro(<< " GetComponentSize : " << this->GetComponentSize()); std::streamoff headerLength(0); std::streamoff numberOfBytesPerLines = static_cast(this->GetComponentSize() * m_Dimensions[0]); std::streamsize numberOfBytesToBeWrite = static_cast(this->GetComponentSize() * lNbColumns); std::streamoff offset = 0; unsigned long cpt = 0; // Update the step variable step = step * (unsigned long) (this->GetComponentSize()); const char * p = static_cast(buffer); char* value = new char[numberOfBytesToBeWrite]; if (value == ITK_NULLPTR) { itkExceptionMacro(<< "Memory allocation error"); return; } for (unsigned int nbComponents = 0; nbComponents < this->GetNumberOfComponents(); ++nbComponents) { cpt = (unsigned long) (nbComponents) * (unsigned long) (this->GetComponentSize()); //Read region of the channel for (unsigned int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { for (std::streamsize i = 0; i < numberOfBytesToBeWrite; i = i + static_cast(this->GetComponentSize())) { memcpy((void*) (&(value[i])), (const void*) (&(p[cpt])), (size_t) (this->GetComponentSize())); cpt += step; } offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(this->GetComponentSize() * lFirstColumn); m_ChannelsFile[nbComponents].seekp(offset, std::ios::beg); //Write a line m_ChannelsFile[nbComponents].write(static_cast(value), numberOfBytesToBeWrite); } } delete[] value; } void BSQImageIO::WriteImageInformation() { if (m_FileName == "") { itkExceptionMacro(<< "A FileName must be specified."); } if (CanWriteFile(m_FileName.c_str()) == false) { itkExceptionMacro(<< "The file " << m_FileName.c_str() << " is not defined as a BSQ file"); } // Close file from any previous image if (m_HeaderFile.is_open()) { m_HeaderFile.close(); } // Open the new file for writing // Actually open the file m_HeaderFile.open(m_FileName.c_str(), std::ios::out | std::ios::trunc); if (m_HeaderFile.fail()) { itkExceptionMacro(<< "Cannot write requested file " << m_FileName.c_str() << "."); } if (0) {} otbSetTypeBsqMacro(CHAR, "OCT") otbSetTypeBsqMacro(UCHAR, "UOCT") otbSetTypeBsqMacro(SHORT, "I2") otbSetTypeBsqMacro(USHORT, "UI2") otbSetTypeBsqMacro(INT, "I4") otbSetTypeBsqMacro(UINT, "UI4") otbSetTypeBsqMacro(FLOAT, "R4") otbSetTypeBsqMacro(DOUBLE, "R8") else { itkExceptionMacro(<< "BSQ format doesn't recognized (TYPE)."); } std::string lString; //Write TYPE information m_HeaderFile << "TYPE" << std::endl; m_HeaderFile << m_TypeBsq << std::endl; //Write LABEL information m_HeaderFile << "LABEL" << std::endl; m_HeaderFile << m_TypeBsq << " - This BSQ image file was producted by OTB software." << std::endl; //Write CHANNELS information m_HeaderFile << "CHANNELS" << std::endl; m_HeaderFile << this->GetNumberOfComponents() << std::endl; //Write LINES information m_HeaderFile << "LINES" << std::endl; m_HeaderFile << m_Dimensions[1] << std::endl; //Write COLUMNS information m_HeaderFile << "COLUMNS" << std::endl; m_HeaderFile << m_Dimensions[0] << std::endl; //Write "BITS PER PIXEL" information m_HeaderFile << "BITS PER PIXEL" << std::endl; m_HeaderFile << this->GetComponentSize() * 8 << std::endl; //Write "SENSCODAGE" information m_HeaderFile << "SENSCODAGE" << std::endl; if (m_ByteOrder == LittleEndian) { m_HeaderFile << "INTEL" << std::endl; } else { m_HeaderFile << "IEEE" << std::endl; } m_HeaderFile.close(); //Create channels files //Define channels file name std::string lRootName = System::GetRootName(m_FileName); m_ChannelsFileName.clear(); for (unsigned int i = 0; i < this->GetNumberOfComponents(); ++i) { std::ostringstream lStream; lStream << lRootName << ".c" << i + 1; m_ChannelsFileName.push_back(lStream.str()); } //Allocate buffer of stream file m_ChannelsFile = new std::fstream[this->GetNumberOfComponents()]; //Try to open channels file for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels) { m_ChannelsFile[channels].open( m_ChannelsFileName[channels].c_str(), std::ios::out | std::ios::trunc | std::ios::binary); if (m_ChannelsFile[channels].fail()) { itkExceptionMacro(<< "BSQ : unable to find the file <" << m_ChannelsFileName[channels] << ">"); } } this->SetFileTypeToBinary(); this->SetNumberOfDimensions(2); unsigned long headerLength = this->GetComponentSize() * m_Dimensions[0]; char* value = new char[headerLength]; for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels) { m_ChannelsFile[channels].seekp(0, std::ios::beg); //Write Header line and all file (whitout information) for (unsigned int numLigne = 0; numLigne < (m_Dimensions[1]); numLigne++) { m_ChannelsFile[channels].write(value, headerLength); } } delete[] value; otbMsgDebugMacro(<< "Driver to write: BSQ"); otbMsgDebugMacro(<< " Write file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " Type Bsq : " << m_TypeBsq); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } } // end namespace otb OTB-release-5.8/Modules/IO/IOBSQ/src/otbBSQImageIOFactory.cxx000066400000000000000000000031421301006202600234020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbBSQImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbBSQImageIO.h" #include "itkVersion.h" namespace otb { BSQImageIOFactory::BSQImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbBSQImageIO", "BSQ Image IO", 1, itk::CreateObjectFunction::New()); } BSQImageIOFactory::~BSQImageIOFactory() { } const char* BSQImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* BSQImageIOFactory::GetDescription() const { return "BSQ ImageIO Factory, permettant le chargement d'image au format BSQ dans l'OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool BSQImageIOFactoryHasBeenRegistered; void BSQImageIOFactoryRegister__Private(void) { if( ! BSQImageIOFactoryHasBeenRegistered ) { BSQImageIOFactoryHasBeenRegistered = true; BSQImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOBSQ/test/000077500000000000000000000000001301006202600171715ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOBSQ/test/CMakeLists.txt000066400000000000000000000010421301006202600217260ustar00rootroot00000000000000otb_module_test() set(OTBIOBSQTests otbIOBSQTestDriver.cxx otbBSQImageIOTestCanRead.cxx otbBSQImageIOTestCanWrite.cxx ) add_executable(otbIOBSQTestDriver ${OTBIOBSQTests}) target_link_libraries(otbIOBSQTestDriver ${OTBIOBSQ-Test_LIBRARIES}) otb_module_target_label(otbIOBSQTestDriver) # Tests Declaration otb_add_test(NAME ioTuBSQImageIOCanRead COMMAND otbIOBSQTestDriver otbBSQImageIOTestCanRead ${INPUTDATA}/poupees.hd) otb_add_test(NAME ioTuBSQImageIOCanWrite COMMAND otbIOBSQTestDriver otbBSQImageIOTestCanWrite ${TEMP}/poupees.hd) OTB-release-5.8/Modules/IO/IOBSQ/test/otbBSQImageIOTestCanRead.cxx000066400000000000000000000020101301006202600243110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbBSQImageIO.h" #include "itkMacro.h" #include int otbBSQImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::BSQImageIO::Pointer lBSQImageIO = otb::BSQImageIO::New(); bool lCanRead = lBSQImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::BSQImageIO : impossible d'ouvrir l'image BSQ " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOBSQ/test/otbBSQImageIOTestCanWrite.cxx000066400000000000000000000017751301006202600245510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbBSQImageIO.h" #include "itkMacro.h" #include int otbBSQImageIOTestCanWrite(int itkNotUsed(argc), char* argv[]) { otb::BSQImageIO::Pointer lBSQImageIO = otb::BSQImageIO::New(); bool lCanRead = lBSQImageIO->CanWriteFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::L'image " << argv[1] << " n'est pas une image BSQ." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOBSQ/test/otbIOBSQTestDriver.cxx000066400000000000000000000002111301006202600233050ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbBSQImageIOTestCanRead); REGISTER_TEST(otbBSQImageIOTestCanWrite); } OTB-release-5.8/Modules/IO/IOGDAL/000077500000000000000000000000001301006202600162745ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOGDAL/CMakeLists.txt000066400000000000000000000001111301006202600210250ustar00rootroot00000000000000project(OTBIOGDAL) set(OTBIOGDAL_LIBRARIES OTBIOGDAL) otb_module_impl() OTB-release-5.8/Modules/IO/IOGDAL/include/000077500000000000000000000000001301006202600177175ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOGDAL/include/otbGDALDatasetWrapper.h000066400000000000000000000037441301006202600241630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGDALDatasetWrapper_h #define otbGDALDatasetWrapper_h #include "itkLightObject.h" #include "itkObjectFactory.h" #include "otbConfigure.h" class GDALDataset; namespace otb { // only two states : the Pointer is Null or GetDataSet() returns a // valid dataset class GDALDatasetWrapper : public itk::LightObject { friend class GDALDriverManagerWrapper; public: typedef GDALDatasetWrapper Self; typedef itk::LightObject Superclass; typedef itk::SmartPointer Pointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GDALImageIO, itk::LightObject); /** Easy access to the internal GDALDataset object. * Don't close it, it will be automatic */ const GDALDataset * GetDataSet() const; GDALDataset * GetDataSet(); /** Test if the dataset corresponds to a Jpeg2000 file format * Return true if the dataset exists and has a JPEG2000 driver * Return false in all other cases */ bool IsJPEG2000() const; /** */ int GetOverviewsCount() const; /** */ unsigned int GetWidth() const; /** */ unsigned int GetHeight() const; /** */ size_t GetPixelBytes() const; protected : GDALDatasetWrapper(); ~GDALDatasetWrapper() ITK_OVERRIDE; private: GDALDataset * m_Dataset; }; // end of GDALDatasetWrapper } // end namespace otb #endif // otbGDALDatasetWrapper_h OTB-release-5.8/Modules/IO/IOGDAL/include/otbGDALDriverManagerWrapper.h000066400000000000000000000054441301006202600253230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGDALDriverManagerWrapper_h #define otbGDALDriverManagerWrapper_h #include "itkLightObject.h" #include "itkProcessObject.h" #include "otbConfigure.h" class GDALDataset; class GDALDriver; /* GDAL Libraries */ #include "gdal.h" #include "gdaljp2metadata.h" #include "gdal_priv.h" #include "gdal_alg.h" #include "otbGDALDatasetWrapper.h" // otb::GDALOverviewsBuilder moved to self header & body files. // Including its header file here for compile time compatibility. #include "otbGDALOverviewsBuilder.h" namespace otb { /** \class GDALDriverManagerWrapper * * \brief Provide an unique instance of a GDALDataSet * * This class provides an unique instance of GDALDataSet which remain * available during all the program lifetime. This class automatically * allocate and destroy the available gdal drivers. * * \ingroup IOFilters * * * \ingroup OTBIOGDAL */ // Wraps the GdalDriverManager so that GDALAllRegister is called automatically class GDALDriverManagerWrapper { public: // GetInstance returns a reference to a GDALDriverManagerWrapper // This is the only entry point to interact with this class static GDALDriverManagerWrapper& GetInstance() { // Declare a static method variable of type GDALDriverManagerWrapper // so that it is constructed and initialized only on the first call // to GetInstance(), and so try to avoid static initialization order problems static GDALDriverManagerWrapper theUniqueInstance; return theUniqueInstance; } // Open the file for reading and returns a smart dataset pointer GDALDatasetWrapper::Pointer Open( std::string filename ) const; // Open the new file for writing and returns a smart dataset pointer GDALDatasetWrapper::Pointer Create( std::string driverShortName, std::string filename, int nXSize, int nYSize, int nBands, GDALDataType eType, char ** papszOptions ) const; GDALDriver* GetDriverByName( std::string driverShortName ) const; private : // private constructor so that this class is allocated only inside GetInstance GDALDriverManagerWrapper(); ~GDALDriverManagerWrapper(); }; // end of GDALDriverManagerWrapper } // end namespace otb #endif // otbGDALDriverManagerWrapper_h OTB-release-5.8/Modules/IO/IOGDAL/include/otbGDALImageIO.h000066400000000000000000000217221301006202600225030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGDALImageIO_h #define otbGDALImageIO_h /* C++ Libraries */ #include /* ITK Libraries */ #include "otbImageIOBase.h" #include "OTBIOGDALExport.h" namespace otb { class GDALDatasetWrapper; class GDALDataTypeWrapper; /** \class GDALImageIO * * \brief ImageIO object for reading and writing images with GDAL * * This ImageIO uses GDAL interface to read/write images. The * origin and spacing are translated from/to GDAL geotransform * matrix (even in the case of a sensor image). It means that * extracts from sensor images are well supported. Typical * sensor images in OTB have a spacing of [1,1] and an origin * at [0.5,0.5] (when there is no GDAL geotransform, GDAL * physical space is identical to GDAL index space). * * Note that the geotransform matrix supports any rotated physical * space whereas OTB doesn't. * * \em Warning : the index coordinate system used in GDAL is attached * to the corner of the top left pixel, whereas in OTB, the index * coordinate system is attached to the centre of the top-left * pixel. It means that the origin coefficients read from the * GDAL geotransform are the location of the top-left pixel * corner. This is why this location has to be shifted by * half a pixel to be used as an OTB origin. In a nutshell, * OTB images read/written by this ImageIO have the \em same * physical space as GDAL physical space : a given point of * image has the same physical location in OTB and in GDAL. * * The streaming read is implemented. * * \ingroup IOFilters * * * \ingroup OTBIOGDAL */ class OTBIOGDAL_EXPORT GDALImageIO : public otb::ImageIOBase { public: typedef unsigned char InputPixelType; /** Standard class typedefs. */ typedef GDALImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; typedef std::vector GDALCreationOptionsType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GDALImageIO, otb::ImageIOBase); /** Set/Get the level of compression for the output images. * 0-9; 0 = none, 9 = maximum. */ itkSetMacro(CompressionLevel, int); itkGetMacro(CompressionLevel, int); /** Set/Get whether the pixel type (otb side) is complex */ itkSetMacro(IsComplex, bool); itkGetMacro(IsComplex, bool); /** Set/Get whether the pixel type (otb side) is Vector or Scalar */ itkSetMacro(IsVectorImage, bool); itkGetMacro(IsVectorImage, bool); /** Set/get whether the driver will write RPC tags to TIFF */ itkSetMacro(WriteRPCTags,bool); itkGetMacro(WriteRPCTags,bool); /** Set/Get the options */ void SetOptions(const GDALCreationOptionsType& opts) { m_CreationOptions = opts; } GDALCreationOptionsType GetOptions(void) { return m_CreationOptions; } /** Provide hist about the output container to deal with complex pixel * type */ void SetOutputImagePixelType( bool isComplexInternalPixelType, bool isVectorImage) ITK_OVERRIDE { this->SetIsComplex(isComplexInternalPixelType); this->SetIsVectorImage(isVectorImage); } /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Reads 3D data from multiple files assuming one slice per file. */ virtual void ReadVolume(void* buffer); /** Get Info about all subDataset in hdf file */ bool GetSubDatasetInfo(std::vector& names, std::vector& desc); /** Get if the pixel type in the file is complex or not (GDAL side)*/ bool GDALPixelTypeIsComplex(); /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE; /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; /** Get all resolutions possible from the file dimensions */ bool GetAvailableResolutions(std::vector& res); /** Get Info about all resolution possible from the file dimensions */ bool GetResolutionInfo(std::vector& res, std::vector& desc); /** Get number of available overviews in the file * Return 0 if no overviews available * Currently this overview count is only based on the first band * If no pre-computed overviews are available we provide the overview * count based on size division by 2*/ unsigned int GetOverviewsCount() ITK_OVERRIDE; /** Get description about overviews available into the file specified */ std::vector GetOverviewsInfo() ITK_OVERRIDE; /** Returns gdal pixel type as string */ std::string GetGdalPixelTypeAsString() const; protected: /** * Constructor. * Spacing is set to [1,1] and origin to [0.5,0.5] as it would correspond * to an image without geotransform */ GDALImageIO(); /** Destructor.*/ ~GDALImageIO() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Read all information on the image*/ void InternalReadImageInformation(); /** Write all information on the image*/ void InternalWriteImageInformation(const void* buffer); /** Number of bands of the image*/ int m_NbBands; /** Buffer*/ //float **pafimas; /** Determines the level of compression for written files. * Range 0-9; 0 = none, 9 = maximum , default = 4 */ int m_CompressionLevel; bool m_IsIndexed; /** Dataset index to extract (starting at 0)*/ unsigned int m_DatasetNumber; private: GDALImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Determine real file name to write the image */ std::string GetGdalWriteImageFileName(const std::string& gdalDriverShortName, const std::string& filename) const; std::string FilenameToGdalDriverShortName(const std::string& name) const; /** Parse a GML box from a Jpeg2000 file and get the origin */ bool GetOriginFromGMLBox(std::vector &origin); /** Test whether m_CreationOptions has an option * \param partialOption The beginning of a creation option (for example "QUALITY=") */ bool CreationOptionContains(std::string partialOption) const; /** GDAL parameters. */ typedef itk::SmartPointer GDALDatasetWrapperPointer; GDALDatasetWrapperPointer m_Dataset; GDALDataTypeWrapper* m_PxType; /** Nombre d'octets par pixel */ int m_BytePerPixel; bool GDALInfoReportCorner(const char * corner_name, double x, double y, double& dfGeoX, double& dfGeoY) const; bool m_FlagWriteImageInformation; bool m_CanStreamWrite; /** Whether the pixel type (otb side, not gdal side) is complex * this information has to be provided by the reader */ bool m_IsComplex; /** Whether the pixel type (otb side, not gdal side) is Vector * this information has to be provided by the reader */ bool m_IsVectorImage; /** * Creation Options */ GDALCreationOptionsType m_CreationOptions; /** * Number of Overviews in the file */ unsigned int m_NumberOfOverviews; /** * Size of the different overviews of the file */ std::vector > m_OverviewsSize; /** Resolution factor */ unsigned int m_ResolutionFactor; /** * Original dimension of the input image */ std::vector m_OriginalDimensions; /** * True if RPC tags should be exported */ bool m_WriteRPCTags; }; } // end namespace otb #endif // otbGDALImageIO_h OTB-release-5.8/Modules/IO/IOGDAL/include/otbGDALImageIOFactory.h000066400000000000000000000040671301006202600240360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGDALImageIOFactory_h #define otbGDALImageIOFactory_h #include "itkObjectFactoryBase.h" #include "OTBIOGDALExport.h" namespace otb { /** \class GDALImageIOFactory * \brief Creation d'un instance d'un objet GDALImageIO utilisant les object factory. * * \ingroup OTBIOGDAL */ class OTBIOGDAL_EXPORT GDALImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef GDALImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static GDALImageIOFactory * FactoryNew() { return new GDALImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(GDALImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { GDALImageIOFactory::Pointer GDALFactory = GDALImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(GDALFactory); } protected: GDALImageIOFactory(); ~GDALImageIOFactory() ITK_OVERRIDE; private: GDALImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOGDAL/include/otbGDALOverviewsBuilder.h000066400000000000000000000076001301006202600245300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGDALOverviewsBuilder_h #define otbGDALOverviewsBuilder_h // #include "itkLightObject.h" #include "itkProcessObject.h" #include "itkSize.h" #include "otbGDALDatasetWrapper.h" #include "otbConfigure.h" #include "OTBIOGDALExport.h" namespace otb { /** */ enum GDALResampling { GDAL_RESAMPLING_NONE = 0, // GDAL_RESAMPLING_NEAREST, GDAL_RESAMPLING_GAUSS, GDAL_RESAMPLING_CUBIC, GDAL_RESAMPLING_AVERAGE, GDAL_RESAMPLING_MODE, GDAL_RESAMPLING_AVERAGE_MAGPHASE, // GDAL_RESAMPLING_COUNT }; // Compile-time compatibility alias. typedef GDALResampling GDALResamplingType; /** */ enum GDALCompression { GDAL_COMPRESSION_NONE = 0, // GDAL_COMPRESSION_JPEG, GDAL_COMPRESSION_LZW, GDAL_COMPRESSION_PACKBITS, GDAL_COMPRESSION_DEFLATE, // GDAL_COMPRESSION_COUNT, }; /** */ enum GDALFormat { GDAL_FORMAT_ERDAS, GDAL_FORMAT_GEOTIFF, // GDAL_FORMAT_COUNT, }; /** */ class OTBIOGDAL_EXPORT GDALOverviewsBuilder : public itk::ProcessObject { public: typedef GDALOverviewsBuilder Self; typedef ProcessObject Superclass; typedef itk::SmartPointer< Self> Pointer; typedef itk::SmartPointer< const Self > ConstPointer; typedef itk::Size< 2 > Size; typedef std::vector< Size > SizeVector; /** Method for creation through the object factory. */ itkNewMacro( Self ); /** */ static bool CanGenerateOverviews( const std::string & filename ); /** * \brief Count the number of resolution levels larger than * factor^n. */ unsigned int CountResolutions( unsigned int factor, unsigned int size ) const; unsigned int CountResolutions( unsigned int size ) const; unsigned int CountResolutions() const; void ListResolutions( SizeVector &, unsigned int factor, unsigned int count ); void ListResolutions( SizeVector & ); unsigned int GetOverviewsCount() const; size_t GetEstimatedSize() const; GDALResampling GetResamplingMethod() const; void SetResamplingMethod( GDALResampling ); void SetBypassEnabled( bool ); bool IsBypassEnabled() const; unsigned int GetWidth() const; unsigned int GetHeight() const; GDALCompression GetCompressionMethod() const; void SetCompressionMethod( GDALCompression ); GDALFormat GetFormat() const; void SetFormat( GDALFormat ); unsigned int GetNbResolutions() const; void SetNbResolutions( unsigned int ); unsigned int GetResolutionFactor() const; void SetResolutionFactor( unsigned int ); const std::string & GetInputFileName() const; void SetInputFileName( const std::string & str ); void Update() ITK_OVERRIDE; protected: GDALOverviewsBuilder(); ~GDALOverviewsBuilder() ITK_OVERRIDE {}; void PrintSelf( std::ostream & os, itk::Indent indent ) const ITK_OVERRIDE; private: GDALOverviewsBuilder( const Self & ); //purposely not implemented void operator = ( const Self & ); //purposely not implemented // void GetGDALResamplingMethod( std::string & resamplingMethod ); void OpenDataset( const std::string & filename ); GDALDatasetWrapper::Pointer m_GDALDataset; std::string m_InputFileName; unsigned int m_NbResolutions; unsigned int m_ResolutionFactor; GDALResampling m_ResamplingMethod; GDALCompression m_CompressionMethod; GDALFormat m_Format; bool m_IsBypassEnabled : 1; }; // end of GDALOverviewsBuilder } // end namespace otb #endif // otbGDALOverviewsBuilder_h OTB-release-5.8/Modules/IO/IOGDAL/include/otbOGRIOHelper.h000066400000000000000000000074051301006202600226220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRIOHelper_h #define otbOGRIOHelper_h #include #include "otbVectorData.h" #include "otbOGRVersionProxy.h" #include "OTBIOGDALExport.h" class GDALDataset; class OGRGeometryCollection; class OGRLayer; class OGRSpatialReference; class OGRGeometry; namespace otb { /** \class OGRIOHelper * \brief This class IO OGR * * * \ingroup OTBIOGDAL */ class OTBIOGDAL_EXPORT OGRIOHelper: public itk::Object { public: /** Standard class typedefs. */ typedef OGRIOHelper Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Template parameters typedefs */ /** Data typedef */ typedef VectorData<> VectorDataType; typedef VectorDataType::DataTreeType DataTreeType; typedef DataTreeType::TreeNodeType InternalTreeNodeType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::Pointer DataNodePointerType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(OGRIOHelper, itk::Object); /** Conversion tools */ void ConvertOGRLayerToDataTreeNode(OGRLayer * layer, InternalTreeNodeType * documentPtr) const; unsigned int ProcessNodeWrite(InternalTreeNodeType * source, ogr::version_proxy::GDALDatasetType * m_DataSource, OGRGeometryCollection * ogrCollection, OGRLayer * ogrCurrentLayer, OGRSpatialReference * oSRS); /** Return a list of OGRLayer * */ std::vector ConvertDataTreeNodeToOGRLayers(InternalTreeNodeType * source, ogr::version_proxy::GDALDatasetType * dummyDatasource, OGRLayer* ogrCurrentLayer, OGRSpatialReference * oSRS); void ConvertGeometryToPointNode(const OGRGeometry * ogrGeometry, DataNodePointerType node) const; void ConvertGeometryToLineNode(const OGRGeometry * ogrGeometry, DataNodePointerType node) const; void ConvertGeometryToPolygonNode(const OGRGeometry * ogrGeometry, DataNodePointerType node) const; protected: OGRIOHelper(); ~OGRIOHelper() ITK_OVERRIDE; private: OGRIOHelper(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typedef DataNodeType::PointType PointType; typedef DataNodeType::LineType LineType; typedef LineType::Pointer LinePointerType; typedef LineType::VertexListType VertexListType; typedef VertexListType::ConstPointer VertexListConstPointerType; typedef DataNodeType::PolygonType PolygonType; typedef PolygonType::Pointer PolygonPointerType; typedef DataNodeType::PolygonListType PolygonListType; typedef PolygonListType::Pointer PolygonListPointerType; }; // end class OGRIOHelper } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOGDAL/include/otbOGRVectorDataIO.h000066400000000000000000000105541301006202600234360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRVectorDataIO_h #define otbOGRVectorDataIO_h #include #include #include "otbVectorDataIOBase.h" #include "otbVectorData.h" #include "otbOGRVersionProxy.h" #include "OTBIOGDALExport.h" namespace otb { /** \class OGRVectorDataIO * * \brief ImageIO object for reading and writing OGR format vector data * * ImageIO object for reading and writing OGR format vector data: it can * handle Esri Shapefile (shp), MapInfo (map) and Geography Markup Language (GML) * and possibly other OGR formats. * * * \ingroup OTBIOGDAL */ class OTBIOGDAL_EXPORT OGRVectorDataIO : public VectorDataIOBase { public: /** Standard class typedefs. */ typedef OGRVectorDataIO Self; typedef VectorDataIOBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(OGRVectorDataIO, VectorDataIOBase); /** Byte order typedef */ typedef Superclass::ByteOrder ByteOrder; /** Data typedef */ typedef VectorData VectorDataType; typedef VectorDataType::DataTreeType DataTreeType; typedef DataTreeType::TreeNodeType InternalTreeNodeType; typedef InternalTreeNodeType::ChildrenListType ChildrenListType; typedef DataTreeType::Pointer DataTreePointerType; typedef DataTreeType::ConstPointer DataTreeConstPointerType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::Pointer DataNodePointerType; typedef DataNodeType::PointType PointType; typedef DataNodeType::LineType LineType; typedef LineType::VertexListType VertexListType; typedef VertexListType::ConstPointer VertexListConstPointerType; typedef LineType::Pointer LinePointerType; typedef DataNodeType::PolygonType PolygonType; typedef PolygonType::Pointer PolygonPointerType; typedef DataNodeType::PolygonListType PolygonListType; typedef PolygonListType::Pointer PolygonListPointerType; typedef VectorDataType::Pointer VectorDataPointerType; typedef VectorDataType::ConstPointer VectorDataConstPointerType; typedef Superclass::SpacingType SpacingType; typedef Superclass::PointType OriginType; /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this VectorDataIO can read the * file specified. */ bool CanReadFile(const char*) const ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(itk::DataObject* data) ITK_OVERRIDE; /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) const ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided */ void Write(const itk::DataObject* data, char ** papszOptions = ITK_NULLPTR) ITK_OVERRIDE; protected: /** Constructor.*/ OGRVectorDataIO(); /** Destructor.*/ ~OGRVectorDataIO() ITK_OVERRIDE; /* virtual void InternalReadVectorDataInformation(){}; */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: OGRVectorDataIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string GetOGRDriverName(std::string name) const; void CloseInternalDataSource(); ogr::version_proxy::GDALDatasetType * m_DataSource; }; } // end namespace otb #endif // otbOGRVectorDataIO_h OTB-release-5.8/Modules/IO/IOGDAL/include/otbOGRVectorDataIOFactory.h000066400000000000000000000037621301006202600247710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRVectorDataIOFactory_h #define otbOGRVectorDataIOFactory_h #include "itkObjectFactoryBase.h" #include "OTBIOGDALExport.h" namespace otb { /** \class OGRVectorDataIOFactory * \brief Create an instance of an OGRVectorDataIOFactory. * * \ingroup OTBIOGDAL */ class OTBIOGDAL_EXPORT OGRVectorDataIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef OGRVectorDataIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(OGRVectorDataIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { OGRVectorDataIOFactory::Pointer OGRFactory = OGRVectorDataIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(OGRFactory); } protected: OGRVectorDataIOFactory(); ~OGRVectorDataIOFactory() ITK_OVERRIDE; private: OGRVectorDataIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOGDAL/otb-module.cmake000066400000000000000000000005671301006202600213550ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read and write images with GDAL.") otb_module(OTBIOGDAL ENABLE_SHARED DEPENDS OTBVectorDataBase OTBGdalAdapters OTBITK OTBImageBase OTBCommon OTBTinyXML OTBGDAL OTBBoostAdapters OTBOSSIMAdapters TEST_DEPENDS OTBTestKernel OTBImageIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOGDAL/src/000077500000000000000000000000001301006202600170635ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOGDAL/src/CMakeLists.txt000066400000000000000000000010731301006202600216240ustar00rootroot00000000000000set(OTBIOGDAL_SRC otbGDALDatasetWrapper.cxx otbGDALDriverManagerWrapper.cxx otbGDALImageIO.cxx otbGDALImageIOFactory.cxx otbGDALOverviewsBuilder.cxx otbOGRIOHelper.cxx otbOGRVectorDataIO.cxx otbOGRVectorDataIOFactory.cxx ) add_library(OTBIOGDAL ${OTBIOGDAL_SRC}) target_link_libraries(OTBIOGDAL ${OTBVectorDataBase_LIBRARIES} ${OTBGdalAdapters_LIBRARIES} ${OTBTinyXML_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBGDAL_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ) otb_module_target(OTBIOGDAL) OTB-release-5.8/Modules/IO/IOGDAL/src/otbGDALDatasetWrapper.cxx000066400000000000000000000057731301006202600237060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGDALDriverManagerWrapper.h" #include #include "otb_boost_string_header.h" #include "otbSystem.h" namespace otb { GDALDatasetWrapper ::GDALDatasetWrapper(): m_Dataset(ITK_NULLPTR) { } GDALDatasetWrapper ::~GDALDatasetWrapper() { if( m_Dataset ) { GDALClose(m_Dataset); // GDALDataset * is statically cast from GDALDatasetH in // GDALDriverManagerWrapper::Open(). So, it should be destroyed by // GDALClose() (see // http://gdal.org/classGDALDataset.html#a4d110533d799bac7dcfad3c41d30c0e7). m_Dataset = ITK_NULLPTR; } } // GetDataSet const GDALDataset * GDALDatasetWrapper ::GetDataSet() const { return m_Dataset; } GDALDataset * GDALDatasetWrapper ::GetDataSet() { return m_Dataset; } // IsJPEG2000 bool GDALDatasetWrapper::IsJPEG2000() const { if (m_Dataset == ITK_NULLPTR) { return false; } std::string driverName(m_Dataset->GetDriver()->GetDescription()); if (driverName.compare("JP2OpenJPEG") == 0 || driverName.compare("JP2KAK") == 0 || driverName.compare("JP2ECW") == 0) { return true; } return false; } int GDALDatasetWrapper ::GetOverviewsCount() const { assert( m_Dataset!=NULL ); assert( m_Dataset->GetRasterCount()>0 ); assert( m_Dataset->GetRasterBand( 1 )!=NULL ); return m_Dataset->GetRasterBand( 1 )->GetOverviewCount(); } unsigned int GDALDatasetWrapper ::GetWidth() const { assert( m_Dataset!=NULL ); return m_Dataset->GetRasterXSize(); } unsigned int GDALDatasetWrapper ::GetHeight() const { assert( m_Dataset!=NULL ); return m_Dataset->GetRasterYSize(); } size_t GDALDatasetWrapper ::GetPixelBytes() const { assert( m_Dataset!=NULL ); size_t size = 0; int count = m_Dataset->GetRasterCount(); for( int i=1; i<=count; ++i ) { assert( m_Dataset->GetRasterBand( i )!=NULL ); switch( m_Dataset->GetRasterBand( i )->GetRasterDataType() ) { case GDT_Unknown: assert( false && "Unexpected GDALDataType GDT_Unknown value." ); break; case GDT_Byte: size += 1; break; case GDT_UInt16: case GDT_Int16 : case GDT_CInt16: size += 2; break; case GDT_UInt32: case GDT_Int32: case GDT_Float32: case GDT_CInt32: case GDT_CFloat32: size += 4; break; case GDT_Float64: case GDT_CFloat64: size += 8; break; default: assert( false && "Unhandled GDALDataType enum value." ); break; } } return size; } } // end namespace otb OTB-release-5.8/Modules/IO/IOGDAL/src/otbGDALDriverManagerWrapper.cxx000066400000000000000000000073471301006202600250460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGDALDriverManagerWrapper.h" #include #include "otb_boost_string_header.h" #include "otbSystem.h" namespace otb { // GDALDriverManagerWrapper method implementation GDALDriverManagerWrapper::GDALDriverManagerWrapper() { GDALAllRegister(); GDALDriver* driver = ITK_NULLPTR; // Ignore incompatible Jpeg2000 drivers (Jasper) driver = GetGDALDriverManager()->GetDriverByName( "JPEG2000" ); if (driver) GetGDALDriverManager()->DeregisterDriver( driver ); // #ifndef CHECK_HDF4OPEN_SYMBOL // // Get rid of the HDF4 driver when it is buggy // driver = GetGDALDriverManager()->GetDriverByName( "hdf4" ); // if (driver) // GetGDALDriverManager()->DeregisterDriver( driver ); // #endif } GDALDriverManagerWrapper::~GDALDriverManagerWrapper() { GDALDestroyDriverManager(); } // Open the file for reading and returns a smart dataset pointer GDALDatasetWrapper::Pointer GDALDriverManagerWrapper::Open( std::string filename ) const { GDALDatasetWrapper::Pointer datasetWrapper; if (boost::algorithm::starts_with(filename, "http://") || boost::algorithm::starts_with(filename, "https://") ) { // don't try to open it and exit return datasetWrapper; } // test if a driver can identify the dataset GDALDriverH identifyDriverH = GDALIdentifyDriver(filename.c_str(), ITK_NULLPTR); if(identifyDriverH == ITK_NULLPTR) { // don't try to open it and exit return datasetWrapper; } GDALDriver *identifyDriver = static_cast(identifyDriverH); // check if Jasper will be used if (strcmp(identifyDriver->GetDescription(),"JPEG2000") == 0) { itkGenericExceptionMacro(<< "Error : tried to open the file " << filename.c_str() << " with GDAL driver Jasper " "(which fails on OTB). Try setting the environment variable GDAL_SKIP" " in order to avoid this driver."); } GDALDatasetH dataset = GDALOpen(filename.c_str(), GA_ReadOnly); if (dataset != ITK_NULLPTR) { datasetWrapper = GDALDatasetWrapper::New(); datasetWrapper->m_Dataset = static_cast(dataset); } return datasetWrapper; } // Open the new file for writing and returns a smart dataset pointer GDALDatasetWrapper::Pointer GDALDriverManagerWrapper::Create( std::string driverShortName, std::string filename, int nXSize, int nYSize, int nBands, GDALDataType eType, char ** papszOptions ) const { GDALDatasetWrapper::Pointer datasetWrapper; GDALDriver* driver = GetDriverByName( driverShortName ); if(driver != ITK_NULLPTR) { GDALDataset* dataset = driver->Create(filename.c_str(), nXSize, nYSize, nBands, eType, papszOptions ); if (dataset != ITK_NULLPTR) { datasetWrapper = GDALDatasetWrapper::New(); datasetWrapper->m_Dataset = dataset; } } return datasetWrapper; } GDALDriver* GDALDriverManagerWrapper::GetDriverByName( std::string driverShortName ) const { return GetGDALDriverManager()->GetDriverByName(driverShortName.c_str()); } } // end namespace otb OTB-release-5.8/Modules/IO/IOGDAL/src/otbGDALImageIO.cxx000066400000000000000000002076641301006202600222350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbGDALImageIO.h" #include "otbMacro.h" #include "otbSystem.h" #include "itksys/SystemTools.hxx" #include "otbImage.h" #include "otb_tinyxml.h" #include "otbImageKeywordlist.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "itkRGBPixel.h" #include "itkRGBAPixel.h" #include "itkTimeProbe.h" #include "cpl_conv.h" #include "ogr_spatialref.h" #include "ogr_srs_api.h" #include "otbGDALDriverManagerWrapper.h" #include "otb_boost_string_header.h" #include "otbOGRHelpers.h" #include "stdint.h" //needed for uintptr_t inline unsigned int uint_ceildivpow2(unsigned int a, unsigned int b) { return (a + (1 << b) - 1) >> b; } namespace otb { class GDALDataTypeWrapper { public: GDALDataTypeWrapper() : pixType(GDT_Byte) {} ~GDALDataTypeWrapper() {} GDALDataTypeWrapper(const GDALDataTypeWrapper& w) { pixType = w.pixType; } GDALDataTypeWrapper& operator=(GDALDataTypeWrapper w) { pixType = w.pixType; return *this; } GDALDataType pixType; }; // end of GDALDataTypeWrapper /* template void printOutputData(InputType *pData, int nbBands, int nbPixelToRead) { for (unsigned int itPxl = 0; itPxl < (unsigned int) (nbPixelToRead * nbBands); itPxl++) { std::cout << "Buffer["<< itPxl << "] = " << *(pData + itPxl) << std::endl; } }; void printDataBuffer(unsigned char *pData, GDALDataType pxlType, int nbBands, int nbPixelToRead) { if (pxlType == GDT_Int16) { printOutputData( static_cast( static_cast(pData) ), nbBands, nbPixelToRead); } else if (pxlType == GDT_Int32) { printOutputData( static_cast( static_cast(pData) ), nbBands, nbPixelToRead); } else if (pxlType == GDT_Float32) { printOutputData( static_cast( static_cast(pData) ), nbBands, nbPixelToRead); } else if (pxlType == GDT_Float64) { printOutputData( static_cast( static_cast(pData) ), nbBands, nbPixelToRead); } else if (pxlType == GDT_CInt16) { printOutputData( static_cast*>( static_cast(pData) ), nbBands, nbPixelToRead); } else if (pxlType == GDT_CInt32) { printOutputData( static_cast*>( static_cast(pData) ), nbBands, nbPixelToRead); } else if (pxlType == GDT_CFloat32) { printOutputData( static_cast*>( static_cast(pData) ), nbBands, nbPixelToRead); } else if (pxlType == GDT_CFloat64) { printOutputData( static_cast*>( static_cast(pData) ), nbBands, nbPixelToRead); } else { std::cerr << "Pixel type unknown" << std::endl; } }; */ GDALImageIO::GDALImageIO() { // By default set number of dimensions to two. this->SetNumberOfDimensions(2); // By default set pixel type to scalar. m_PixelType = SCALAR; // By default set component type to unsigned char m_ComponentType = UCHAR; m_UseCompression = false; m_CompressionLevel = 4; // Range 0-9; 0 = no file compression, 9 = maximum file compression // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to half a pixel (centered pixel convention) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_IsIndexed = false; m_DatasetNumber = 0; //m_poBands = NULL; //m_hDriver = NULL; //m_poDataset = NULL; m_NbBands = 0; m_FlagWriteImageInformation = true; m_CanStreamWrite = false; m_IsComplex = false; m_IsVectorImage = false; m_PxType = new GDALDataTypeWrapper; m_NumberOfOverviews = 0; m_ResolutionFactor = 0; m_BytePerPixel = 0; m_WriteRPCTags = false; } GDALImageIO::~GDALImageIO() { delete m_PxType; } // Tell only if the file can be read with GDAL. bool GDALImageIO::CanReadFile(const char* file) { // First check the extension if (file == ITK_NULLPTR) { itkDebugMacro(<< "No filename specified."); return false; } m_Dataset = GDALDriverManagerWrapper::GetInstance().Open(file); return m_Dataset.IsNotNull(); } // Used to print information about this object void GDALImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Compression Level : " << m_CompressionLevel << "\n"; os << indent << "IsComplex (otb side) : " << m_IsComplex << "\n"; os << indent << "Byte per pixel : " << m_BytePerPixel << "\n"; } // Read a 3D image (or event more bands)... not implemented yet void GDALImageIO::ReadVolume(void*) { } // Read image with GDAL void GDALImageIO::Read(void* buffer) { // Convert buffer from void * to unsigned char * unsigned char *p = static_cast(buffer); // Check if conversion succeed if (p == ITK_NULLPTR) { itkExceptionMacro(<< "GDAL : Bad alloc"); return; } // Get the origin of the region to read int lFirstLineRegion = this->GetIORegion().GetIndex()[1]; int lFirstColumnRegion = this->GetIORegion().GetIndex()[0]; // Get nb. of lines and columns of the region to read int lNbLinesRegion = this->GetIORegion().GetSize()[1]; int lNbColumnsRegion = this->GetIORegion().GetSize()[0]; //std::cout << "OriginBuffer= " << lFirstLineRegion << " x " << lFirstColumnRegion << std::endl; //std::cout << "SizeBuffer= " << lNbLinesRegion << " x " << lNbColumnsRegion << std::endl; // Compute the origin of the image region to read at the initial resolution int lFirstLine = lFirstLineRegion * (1 << m_ResolutionFactor); int lFirstColumn = lFirstColumnRegion * (1 << m_ResolutionFactor); //std::cout << "OriginImage= " << lFirstLine << " x " << lFirstColumn << std::endl; // Compute the size of the image region to read at the initial resolution int lNbLines = lNbLinesRegion * (1 << m_ResolutionFactor); int lNbColumns = lNbColumnsRegion * (1 << m_ResolutionFactor); // Check if the image region is correct if (lFirstLine + lNbLines > static_cast(m_OriginalDimensions[1])) lNbLines = static_cast(m_OriginalDimensions[1]-lFirstLine); if (lFirstColumn + lNbColumns > static_cast(m_OriginalDimensions[0])) lNbColumns = static_cast(m_OriginalDimensions[0]-lFirstColumn); //std::cout << "SizeImage= " << lNbLines << " x " << lNbColumns << std::endl; GDALDataset* dataset = m_Dataset->GetDataSet(); // This special case is due to the fact the CINT/CLONG types // do not exists in ITK. In this case we only report the first band // TODO This should be fixed /*if (GDALDataTypeIsComplex(m_PxType->pixType) && (m_PxType->pixType != GDT_CFloat32) && (m_PxType->pixType != GDT_CFloat64)) { int pixelOffset = m_BytePerPixel * m_NbBands; int lineOffset = m_BytePerPixel * m_NbBands * lNbColumns; int bandOffset = m_BytePerPixel; int nbBands = m_NbBands; int nbPixelToRead = lNbColumns * lNbLines; std::streamoff nbBytes = static_cast(m_NbBands) * static_cast(nbPixelToRead) * static_cast(m_BytePerPixel); unsigned char *pBufferTemp = new unsigned char[static_cast(nbBytes)]; // keep it for the moment otbMsgDevMacro(<< "Parameters RasterIO (case CInt and CShort):" << "\n indX = " << lFirstColumn << "\n indY = " << lFirstLine << "\n sizeX = " << lNbColumns << "\n sizeY = " << lNbLines << "\n GDAL Data Type = " << GDALGetDataTypeName(m_PxType->pixType) << "\n pixelOffset = " << pixelOffset << "\n lineOffset = " << lineOffset << "\n bandOffset = " << bandOffset); CPLErr lCrGdal = m_Dataset->GetDataSet()->RasterIO(GF_Read, lFirstColumn, lFirstLine, lNbColumns, lNbLines, pBufferTemp, //p, // pData lNbColumns, lNbLines, m_PxType->pixType, nbBands, // We want to read all bands NULL, pixelOffset, lineOffset, bandOffset); // Check for gdal error if (lCrGdal == CE_Failure) { itkExceptionMacro(<< "Error while reading image (GDAL format) " << m_FileName ); delete[] pBufferTemp; return; } //std::cout << "RAW BUFFER:" <pixType, m_NbBands, lNbColumns*lNbLines); // Convert the buffer to GDT_Float64 type typedef std::complex RealType; typedef double ScalarRealType; if (m_PxType->pixType == GDT_CInt32) { //std::cout << "Convert input File from GDT_CInt32 to GDT_CFloat32" << std::endl; typedef std::complex ComplexIntType; for (unsigned int itPxl = 0; itPxl < (unsigned int) (nbPixelToRead * m_NbBands); itPxl++) { ComplexIntType pxlValue = *(static_cast( static_cast(pBufferTemp)) + itPxl ); RealType pxlValueReal( static_cast(pxlValue.real()), static_cast(pxlValue.imag()) ); memcpy((void*) (&(p[itPxl*sizeof(RealType)])), (const void*) (&(pxlValueReal)), (size_t) (sizeof(RealType))); } } else if (m_PxType->pixType == GDT_CInt16) { //std::cout << "Convert input File from GDT_CInt16 to GDT_CFloat32" << std::endl; typedef std::complex ComplexShortType; for (unsigned int itPxl = 0; itPxl < (unsigned int) (nbPixelToRead * m_NbBands); itPxl++) { ComplexShortType pxlValue = *(static_cast( static_cast(pBufferTemp)) + itPxl ); RealType pxlValueReal( static_cast(pxlValue.real()), static_cast(pxlValue.imag()) ); memcpy((void*) (&(p[itPxl*sizeof(RealType)])), (const void*) (&(pxlValueReal)), (size_t) (sizeof(RealType))); } } //std::cout << "CONVERTED BUFFER:" <(lNbColumnsRegion)) * (static_cast(lNbLinesRegion)); std::streamoff lBufferSize = static_cast(m_BytePerPixel) * lNbPixels; itk::VariableLengthVector value(lBufferSize); std::streamoff step = static_cast(this->GetNumberOfComponents()) * static_cast(m_BytePerPixel); CPLErr lCrGdal = dataset->GetRasterBand(1)->RasterIO(GF_Read, lFirstColumn, lFirstLine, lNbColumns, lNbLines, const_cast(value.GetDataPointer()), lNbColumnsRegion, lNbLinesRegion, m_PxType->pixType, 0, 0); if (lCrGdal == CE_Failure) { itkExceptionMacro(<< "Error while reading image (GDAL format) '" << m_FileName.c_str() << "' : " << CPLGetLastErrorMsg()); } // Interpret index as color std::streamoff cpt(0); GDALColorTable* colorTable = dataset->GetRasterBand(1)->GetColorTable(); for (std::streamoff i = 0; i < lBufferSize; i = i + static_cast(m_BytePerPixel)) { GDALColorEntry color; colorTable->GetColorEntryAsRGB(value[i], &color); p[cpt] = color.c1; p[cpt + 1] = color.c2; p[cpt + 2] = color.c3; p[cpt + 3] = color.c4; cpt += step; } } else { /******** Nominal case ***********/ int pixelOffset = m_BytePerPixel * m_NbBands; int lineOffset = m_BytePerPixel * m_NbBands * lNbColumnsRegion; int bandOffset = m_BytePerPixel; int nbBands = m_NbBands; // In some cases, we need to change some parameters for RasterIO if(!GDALDataTypeIsComplex(m_PxType->pixType) && m_IsComplex && m_IsVectorImage && (m_NbBands > 1)) { pixelOffset = m_BytePerPixel * 2; lineOffset = pixelOffset * lNbColumnsRegion; bandOffset = m_BytePerPixel; } // keep it for the moment //otbMsgDevMacro(<< "Number of bands inside input file: " << m_NbBands); otbMsgDevMacro(<< "Parameters RasterIO : \n" << " indX = " << lFirstColumn << "\n" << " indY = " << lFirstLine << "\n" << " sizeX = " << lNbColumns << "\n" << " sizeY = " << lNbLines << "\n" << " Buffer Size X = " << lNbColumnsRegion << "\n" << " Buffer Size Y = " << lNbLinesRegion << "\n" << " GDAL Data Type = " << GDALGetDataTypeName(m_PxType->pixType) << "\n" << " nbBands = " << nbBands << "\n" << " pixelOffset = " << pixelOffset << "\n" << " lineOffset = " << lineOffset << "\n" << " bandOffset = " << bandOffset ); itk::TimeProbe chrono; chrono.Start(); CPLErr lCrGdal = m_Dataset->GetDataSet()->RasterIO(GF_Read, lFirstColumn, lFirstLine, lNbColumns, lNbLines, p, lNbColumnsRegion, lNbLinesRegion, m_PxType->pixType, nbBands, // We want to read all bands ITK_NULLPTR, pixelOffset, lineOffset, bandOffset); chrono.Stop(); otbMsgDevMacro(<< "RasterIO Read took " << chrono.GetTotal() << " sec") // Check if gdal call succeed if (lCrGdal == CE_Failure) { itkExceptionMacro(<< "Error while reading image (GDAL format) '" << m_FileName.c_str() << "' : " << CPLGetLastErrorMsg()); return; } //printDataBuffer(p, m_PxType->pixType, m_NbBands, lNbColumnsRegion*lNbLinesRegion); } } bool GDALImageIO::GetSubDatasetInfo(std::vector &names, std::vector &desc) { // Note: we assume that the subdatasets are in order : SUBDATASET_ID_NAME, SUBDATASET_ID_DESC, SUBDATASET_ID+1_NAME, SUBDATASET_ID+1_DESC char** papszMetadata; papszMetadata = m_Dataset->GetDataSet()->GetMetadata("SUBDATASETS"); // Have we find some dataSet ? // This feature is supported only for hdf4 and hdf5 file (regards to the bug 270) if ( (CSLCount(papszMetadata) > 0) && ( (strcmp(m_Dataset->GetDataSet()->GetDriver()->GetDescription(),"HDF4") == 0) || (strcmp(m_Dataset->GetDataSet()->GetDriver()->GetDescription(),"HDF5") == 0) || (strcmp(m_Dataset->GetDataSet()->GetDriver()->GetDescription(),"SENTINEL2") == 0) ) ) { for (int cpt = 0; papszMetadata[cpt] != ITK_NULLPTR; ++cpt) { std::string key, name; if (System::ParseHdfSubsetName(papszMetadata[cpt], key, name)) { otbMsgDevMacro(<< "- key: " << key); otbMsgDevMacro(<< "- name: " << name); // check if this is a dataset name if (key.find("_NAME") != std::string::npos) names.push_back(name); // check if this is a dataset descriptor if (key.find("_DESC") != std::string::npos) desc.push_back(name); } } } else { return false; } if (names.empty() || desc.empty()) return false; if (names.size() != desc.size()) { names.clear(); desc.clear(); return false; } return true; } bool GDALImageIO::GDALPixelTypeIsComplex() { return GDALDataTypeIsComplex(m_PxType->pixType); } void GDALImageIO::ReadImageInformation() { //std::ifstream file; this->InternalReadImageInformation(); } unsigned int GDALImageIO::GetOverviewsCount() { GDALDataset* dataset = m_Dataset->GetDataSet(); // JPEG2000 case : use the number of overviews actually in the dataset if (m_Dataset->IsJPEG2000()) { // Include the full resolution in overviews count return dataset->GetRasterBand(1)->GetOverviewCount()+1; } if (dataset->GetRasterBand(1)->GetOverviewCount()) // Include the full resolution in overviews count return dataset->GetRasterBand(1)->GetOverviewCount()+1; // default case: compute overviews until one of the dimensions is 1 bool flagStop = false; unsigned int possibleOverviewCount = 0; while (!flagStop) { unsigned int tDimX = uint_ceildivpow2(dataset->GetRasterXSize(),possibleOverviewCount); unsigned int tDimY = uint_ceildivpow2(dataset->GetRasterYSize(),possibleOverviewCount); possibleOverviewCount++; if ( (tDimX == 1) || (tDimY == 1) ) { flagStop = true; } } return possibleOverviewCount; } std::vector GDALImageIO::GetOverviewsInfo() { std::vector desc; // This should never happen, according to implementation of GetOverviewCount() if (this->GetOverviewsCount() == 0) return desc; std::ostringstream oss; // If gdal exposes actual overviews unsigned int lOverviewsCount = m_Dataset->GetDataSet()->GetRasterBand(1)->GetOverviewCount(); if (lOverviewsCount) { unsigned int x = m_OriginalDimensions[0]; unsigned int y = m_OriginalDimensions[1]; oss.str(""); oss << "Resolution: 0 (Image [w x h]: " << x << "x" << y << ")"; desc.push_back(oss.str()); for( unsigned int iOverview = 0; iOverview < lOverviewsCount; iOverview++ ) { x = m_Dataset->GetDataSet()->GetRasterBand(1)->GetOverview(iOverview)->GetXSize(); y = m_Dataset->GetDataSet()->GetRasterBand(1)->GetOverview(iOverview)->GetYSize(); oss.str(""); oss << "Resolution: " << iOverview+1 << " (Image [w x h]: " << x << "x" << y << ")"; desc.push_back(oss.str()); } } else { // Fall back to gdal implicit overviews lOverviewsCount = this->GetOverviewsCount(); unsigned int originalWidth = m_OriginalDimensions[0]; unsigned int originalHeight = m_OriginalDimensions[1]; // Get the overview sizes for( unsigned int iOverview = 0; iOverview < lOverviewsCount; iOverview++ ) { // For each resolution we will compute the tile dim and image dim unsigned int w = uint_ceildivpow2( originalWidth, iOverview); unsigned int h = uint_ceildivpow2( originalHeight, iOverview); oss.str(""); oss << "Resolution: " << iOverview << " (Image [w x h]: " << w << "x" << h << ")"; desc.push_back(oss.str()); } } return desc; } void GDALImageIO::InternalReadImageInformation() { itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::ResolutionFactor, m_ResolutionFactor); itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::SubDatasetIndex, m_DatasetNumber); // Detecting if we are in the case of an image with subdatasets // example: hdf Modis data // in this situation, we are going to change the filename to the // supported gdal format using the m_DatasetNumber value // HDF4_SDS:UNKNOWN:"myfile.hdf":2 // and make m_Dataset point to it. if (m_Dataset->GetDataSet()->GetRasterCount() == 0) { // this happen in the case of a hdf file with SUBDATASETS // Note: we assume that the datasets are in order char** papszMetadata; papszMetadata = m_Dataset->GetDataSet()->GetMetadata("SUBDATASETS"); //TODO: we might want to keep the list of names somewhere, at least the number of datasets std::vector names; if( CSLCount(papszMetadata) > 0 ) { for( int cpt = 0; papszMetadata[cpt] != ITK_NULLPTR; ++cpt ) { std::string key, name; if (System::ParseHdfSubsetName(papszMetadata[cpt], key, name)) { otbMsgDevMacro(<< "- key: " << key); otbMsgDevMacro(<< "- name: " << name); // check if this is a dataset name if (key.find("_NAME") != std::string::npos) names.push_back(name); } } } if (m_DatasetNumber < names.size()) { otbMsgDevMacro(<< "Reading: " << names[m_DatasetNumber]); m_Dataset = GDALDriverManagerWrapper::GetInstance().Open(names[m_DatasetNumber]); } else { itkExceptionMacro(<< "Dataset requested does not exist (" << names.size() << " datasets)"); } } GDALDataset* dataset = m_Dataset->GetDataSet(); // Get image dimensions if ( dataset->GetRasterXSize() == 0 || dataset->GetRasterYSize() == 0 ) { itkExceptionMacro(<< "Dimension is undefined."); } // Set image dimensions into IO m_Dimensions[0] = uint_ceildivpow2(dataset->GetRasterXSize(),m_ResolutionFactor); m_Dimensions[1] = uint_ceildivpow2(dataset->GetRasterYSize(),m_ResolutionFactor); // Keep the original dimension of the image m_OriginalDimensions.push_back(dataset->GetRasterXSize()); m_OriginalDimensions.push_back(dataset->GetRasterYSize()); otbMsgDevMacro(<< "Original Dimensions of the input file: " << m_OriginalDimensions[0] << " x " << m_OriginalDimensions[1]); // Get Number of Bands m_NbBands = dataset->GetRasterCount(); // Get the number of overviews of the file (based on the first band) m_NumberOfOverviews = dataset->GetRasterBand(1)->GetOverviewCount(); // Get the overview sizes for( unsigned int iOverview = 0; iOverview < m_NumberOfOverviews; iOverview++ ) { std::pair tempSize; tempSize.first = GDALGetRasterBandXSize( dataset->GetRasterBand(1)->GetOverview(iOverview) ); tempSize.second = GDALGetRasterBandYSize( dataset->GetRasterBand(1)->GetOverview(iOverview) ); m_OverviewsSize.push_back(tempSize); /*std::cout << "Overviews size of input file" << m_FileName << ": " << m_OverviewsSize.back().first << " x " << m_OverviewsSize.back().second << std::endl; */ otbMsgDevMacro( << "Overviews size of input file" << m_FileName << ": " << m_OverviewsSize.back().first << " x " << m_OverviewsSize.back().second); } otbMsgDevMacro(<< "Number of Overviews inside input file: " << m_NumberOfOverviews); otbMsgDevMacro(<< "Input file dimension: " << m_Dimensions[0] << ", " << m_Dimensions[1]); otbMsgDevMacro(<< "Number of bands inside input file: " << m_NbBands); this->SetNumberOfComponents(m_NbBands); // Set the number of dimensions (verify for the dim ) this->SetNumberOfDimensions(2); otbMsgDevMacro(<< "Nb of Dimensions of the input file: " << m_NumberOfDimensions); // Automatically set the Type to Binary for GDAL data this->SetFileTypeToBinary(); // Get Data Type // Consider only the data type given by the first band // Maybe be could changed (to check) m_PxType->pixType = dataset->GetRasterBand(1)->GetRasterDataType(); otbMsgDevMacro(<< "PixelType inside input file: "<< GDALGetDataTypeName(m_PxType->pixType) ); if (m_PxType->pixType == GDT_Byte) { SetComponentType(UCHAR); } else if (m_PxType->pixType == GDT_UInt16) { SetComponentType(USHORT); } else if (m_PxType->pixType == GDT_Int16) { SetComponentType(SHORT); } else if (m_PxType->pixType == GDT_UInt32) { SetComponentType(UINT); } else if (m_PxType->pixType == GDT_Int32) { SetComponentType(INT); } else if (m_PxType->pixType == GDT_Float32) { SetComponentType(FLOAT); } else if (m_PxType->pixType == GDT_Float64) { SetComponentType(DOUBLE); } else if (m_PxType->pixType == GDT_CInt16) { SetComponentType(CSHORT); } else if (m_PxType->pixType == GDT_CInt32) { SetComponentType(CINT); } else if (m_PxType->pixType == GDT_CFloat32) { SetComponentType(CFLOAT); } else if (m_PxType->pixType == GDT_CFloat64) { SetComponentType(CDOUBLE); } else { itkExceptionMacro(<< "Pixel type unknown"); } if (this->GetComponentType() == CHAR) { m_BytePerPixel = 1; } else if (this->GetComponentType() == UCHAR) { m_BytePerPixel = 1; } else if (this->GetComponentType() == USHORT) { m_BytePerPixel = 2; } else if (this->GetComponentType() == SHORT) { m_BytePerPixel = 2; } else if (this->GetComponentType() == INT) { m_BytePerPixel = 4; } else if (this->GetComponentType() == UINT) { m_BytePerPixel = 4; } else if (this->GetComponentType() == LONG) { m_BytePerPixel = sizeof(long); } else if (this->GetComponentType() == ULONG) { m_BytePerPixel = sizeof(unsigned long); } else if (this->GetComponentType() == FLOAT) { m_BytePerPixel = 4; } else if (this->GetComponentType() == DOUBLE) { m_BytePerPixel = 8; } else if (this->GetComponentType() == CSHORT) { m_BytePerPixel = sizeof(std::complex); } else if (this->GetComponentType() == CINT) { m_BytePerPixel = sizeof(std::complex); } else if (this->GetComponentType() == CFLOAT) { /*if (m_PxType->pixType == GDT_CInt16) m_BytePerPixel = sizeof(std::complex); else if (m_PxType->pixType == GDT_CInt32) m_BytePerPixel = sizeof(std::complex); else*/ m_BytePerPixel = sizeof(std::complex); } else if (this->GetComponentType() == CDOUBLE) { m_BytePerPixel = sizeof(std::complex); } else { itkExceptionMacro(<< "Component type unknown"); } /******************************************************************/ // Set the pixel type with some special cases linked to the fact // we read some data with complex type. if ( GDALDataTypeIsComplex(m_PxType->pixType) ) // Try to read data with complex type with GDAL { if ( !m_IsComplex && m_IsVectorImage ) { // we are reading a complex data set into an image where the pixel // type is Vector: we have to double the number of component // for that to work otbMsgDevMacro( << "GDALtypeIO= Complex and IFReader::InternalPixelType= Scalar and IFReader::PixelType= Vector"); this->SetNumberOfComponents(m_NbBands*2); this->SetPixelType(VECTOR); } else { this->SetPixelType(COMPLEX); } } else // Try to read data with scalar type with GDAL { this->SetNumberOfComponents(m_NbBands); if (this->GetNumberOfComponents() == 1) { this->SetPixelType(SCALAR); } else { this->SetPixelType(VECTOR); } } /*** Parameters set by Internal Read function ***/ otbMsgDevMacro( << "Pixel Type IFReader = " << GetPixelTypeAsString(this->GetPixelType()) ) otbMsgDevMacro( << "Number of component IFReader = " << this->GetNumberOfComponents() ) otbMsgDevMacro( << "Byte per pixel set = " << m_BytePerPixel ) otbMsgDevMacro( << "Component Type set = " << GetComponentTypeAsString(this->GetComponentType()) ); /*----------------------------------------------------------------------*/ /*-------------------------- METADATA ----------------------------------*/ /*----------------------------------------------------------------------*/ // Now initialize the itk dictionary itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); // Report the typical block size if possible if (dataset->GetRasterCount() > 0) { int blockSizeX = 0; int blockSizeY = 0; dataset->GetRasterBand(1)->GetBlockSize(&blockSizeX, &blockSizeY); if(blockSizeX > 0 && blockSizeY > 0) { otbMsgDevMacro(<< "Original blockSize: "<< blockSizeX << " x " << blockSizeY ); blockSizeX = uint_ceildivpow2(blockSizeX,m_ResolutionFactor); if (m_Dataset->IsJPEG2000()) { // Jpeg2000 case : use the real block size Y blockSizeY = uint_ceildivpow2(blockSizeY,m_ResolutionFactor); } else { // Try to keep the GDAL block memory constant blockSizeY = blockSizeY * (1 << m_ResolutionFactor); } otbMsgDevMacro(<< "Decimated blockSize: "<< blockSizeX << " x " << blockSizeY ); itk::EncapsulateMetaData(dict, MetaDataKey::TileHintX, blockSizeX); itk::EncapsulateMetaData(dict, MetaDataKey::TileHintY, blockSizeY); } } /* -------------------------------------------------------------------- */ /* Get Spacing */ /* -------------------------------------------------------------------- */ // Default Spacing m_Spacing[0] = 1; m_Spacing[1] = 1; // Reset origin to GDAL convention default m_Origin[0] = 0.0; m_Origin[1] = 0.0; // flag to detect images in sensor geometry bool isSensor = false; if (m_NumberOfDimensions == 3) m_Spacing[2] = 1; char** papszMetadata = dataset->GetMetadata(ITK_NULLPTR); /* -------------------------------------------------------------------- */ /* Report general info. */ /* -------------------------------------------------------------------- */ GDALDriverH hDriver; hDriver = dataset->GetDriver(); std::string driverShortName = static_cast(GDALGetDriverShortName(hDriver)); std::string driverLongName = static_cast(GDALGetDriverLongName(hDriver)); itk::EncapsulateMetaData(dict, MetaDataKey::DriverShortNameKey, driverShortName); itk::EncapsulateMetaData(dict, MetaDataKey::DriverLongNameKey, driverLongName); if (m_Dataset->IsJPEG2000()) { // store the cache size used for Jpeg2000 files itk::EncapsulateMetaData(dict, MetaDataKey::CacheSizeInBytes , GDALGetCacheMax64()); } /* -------------------------------------------------------------------- */ /* Get the projection coordinate system of the image : ProjectionRef */ /* -------------------------------------------------------------------- */ if (dataset->GetProjectionRef() != ITK_NULLPTR && !std::string(dataset->GetProjectionRef()).empty()) { OGRSpatialReferenceH pSR = OSRNewSpatialReference(ITK_NULLPTR); const char * pszProjection = ITK_NULLPTR; pszProjection = dataset->GetProjectionRef(); if (OSRImportFromWkt(pSR, (char **) (&pszProjection)) == OGRERR_NONE) { char * pszPrettyWkt = ITK_NULLPTR; OSRExportToPrettyWkt(pSR, &pszPrettyWkt, FALSE); itk::EncapsulateMetaData (dict, MetaDataKey::ProjectionRefKey, static_cast(pszPrettyWkt)); CPLFree(pszPrettyWkt); } else { itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, static_cast(dataset->GetProjectionRef())); } if (pSR != ITK_NULLPTR) { OSRRelease(pSR); pSR = ITK_NULLPTR; } } else { otbMsgDevMacro( << "No projection => sensor model" ); // Special case for Jpeg2000 files : try to read the origin in the GML box if (m_Dataset->IsJPEG2000()) { isSensor = GetOriginFromGMLBox(m_Origin); } } /* -------------------------------------------------------------------- */ /* Get the GCP projection coordinates of the image : GCPProjection */ /* -------------------------------------------------------------------- */ unsigned int gcpCount = 0; gcpCount = dataset->GetGCPCount(); if (gcpCount > 0) { std::string gcpProjectionKey; { // Declare gcpProj in local scope. So, it won't be available outside. const char * gcpProj = dataset->GetGCPProjection(); // assert( gcpProj!=NULL ); if( gcpProj!=ITK_NULLPTR ) gcpProjectionKey = gcpProj; } itk::EncapsulateMetaData(dict, MetaDataKey::GCPProjectionKey, gcpProjectionKey); if (gcpProjectionKey.empty()) { gcpCount = 0; //fix for uninitialized gcpCount in gdal (when //reading Palsar image) } std::string key; itk::EncapsulateMetaData(dict, MetaDataKey::GCPCountKey, gcpCount); for (unsigned int cpt = 0; cpt < gcpCount; ++cpt) { const GDAL_GCP *psGCP; psGCP = dataset->GetGCPs() + cpt; OTB_GCP pOtbGCP; pOtbGCP.m_Id = std::string(psGCP->pszId); pOtbGCP.m_Info = std::string(psGCP->pszInfo); pOtbGCP.m_GCPRow = psGCP->dfGCPLine; pOtbGCP.m_GCPCol = psGCP->dfGCPPixel; pOtbGCP.m_GCPX = psGCP->dfGCPX; pOtbGCP.m_GCPY = psGCP->dfGCPY; pOtbGCP.m_GCPZ = psGCP->dfGCPZ; // Complete the key with the GCP number : GCP_i std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << cpt; key = lStream.str(); itk::EncapsulateMetaData(dict, key, pOtbGCP); } } /* -------------------------------------------------------------------- */ /* Get the six coefficients of affine geoTtransform */ /* -------------------------------------------------------------------- */ double adfGeoTransform[6]; MetaDataKey::VectorType VadfGeoTransform; if (dataset->GetGeoTransform(adfGeoTransform) == CE_None) { for (int cpt = 0; cpt < 6; ++cpt) VadfGeoTransform.push_back(adfGeoTransform[cpt]); itk::EncapsulateMetaData(dict, MetaDataKey::GeoTransformKey, VadfGeoTransform); if (!isSensor) { /// retrieve origin and spacing from the geo transform m_Spacing[0] = VadfGeoTransform[1]; m_Spacing[1] = VadfGeoTransform[5]; if ( m_Spacing[0]== 0 || m_Spacing[1] == 0) { // Manage case where axis are not standard if (VadfGeoTransform[2] != 0 && VadfGeoTransform[4] != 0 ) { m_Spacing[0] = VadfGeoTransform[2]; m_Spacing[1] = VadfGeoTransform[4]; } else { otbWarningMacro(<< "Incorrect geotransform (spacing = 0)!"); m_Spacing[0] = 1; m_Spacing[1] = 1; } } // Geotransforms with a non-null rotation are not supported // Beware : GDAL origin is at the corner of the top-left pixel // whereas OTB/ITK origin is at the centre of the top-left pixel // The origin computed here is in GDAL convention for now m_Origin[0] = VadfGeoTransform[0]; m_Origin[1] = VadfGeoTransform[3]; } } // Compute final spacing with the resolution factor m_Spacing[0] *= vcl_pow(2.0, static_cast(m_ResolutionFactor)); m_Spacing[1] *= vcl_pow(2.0, static_cast(m_ResolutionFactor)); // Now that the spacing is known, apply the half-pixel shift m_Origin[0] += 0.5*m_Spacing[0]; m_Origin[1] += 0.5*m_Spacing[1]; // Dataset info otbMsgDevMacro(<< "**** ReadImageInformation() DATASET INFO: ****" ); otbMsgDevMacro(<< "Projection Ref: "<< dataset->GetProjectionRef() ); double GT[6]; if (dataset->GetGeoTransform(GT) == CE_None) { otbMsgDevMacro( <<"Geo Transform: "<< GT[0] << ", " << GT[1] << ", " << GT[2] << ", " << GT[3] << ", " << GT[4] << ", " << GT[5] ); } else { otbMsgDevMacro( << "No Geo Transform: "); } otbMsgDevMacro(<< "GCP Projection Ref: "<< dataset->GetGCPProjection() ); otbMsgDevMacro(<< "GCP Count: " << dataset->GetGCPCount() ); /* -------------------------------------------------------------------- */ /* Report metadata. */ /* -------------------------------------------------------------------- */ papszMetadata = dataset->GetMetadata(ITK_NULLPTR); if (CSLCount(papszMetadata) > 0) { std::string key; for (int cpt = 0; papszMetadata[cpt] != ITK_NULLPTR; ++cpt) { std::ostringstream lStream; lStream << MetaDataKey::MetadataKey << cpt; key = lStream.str(); itk::EncapsulateMetaData(dict, key, static_cast(papszMetadata[cpt])); } } /* Special case for JPEG2000, also look in the GML boxes */ if (m_Dataset->IsJPEG2000()) { char **gmlMetadata = ITK_NULLPTR; GDALJP2Metadata jp2Metadata; if (jp2Metadata.ReadAndParse(m_FileName.c_str())) { gmlMetadata = jp2Metadata.papszGMLMetadata; } if(gmlMetadata) { if (CSLCount(gmlMetadata) > 0) { std::string key; int cptOffset = CSLCount(papszMetadata); for (int cpt = 0; gmlMetadata[cpt] != ITK_NULLPTR; ++cpt) { std::ostringstream lStream; lStream << MetaDataKey::MetadataKey << (cpt+cptOffset); key = lStream.str(); itk::EncapsulateMetaData(dict, key, static_cast(gmlMetadata[cpt])); } } } } /* -------------------------------------------------------------------- */ /* Report subdatasets. */ /* -------------------------------------------------------------------- */ papszMetadata = dataset->GetMetadata("SUBDATASETS"); if (CSLCount(papszMetadata) > 0) { std::string key; for (int cpt = 0; papszMetadata[cpt] != ITK_NULLPTR; ++cpt) { std::ostringstream lStream; lStream << MetaDataKey::SubMetadataKey << cpt; key = lStream.str(); itk::EncapsulateMetaData(dict, key, static_cast(papszMetadata[cpt])); } } /* -------------------------------------------------------------------- */ /* Report corners */ /* -------------------------------------------------------------------- */ double GeoX(0), GeoY(0); MetaDataKey::VectorType VGeo; GDALInfoReportCorner("Upper Left", 0.0, 0.0, GeoX, GeoY); VGeo.push_back(GeoX); VGeo.push_back(GeoY); itk::EncapsulateMetaData(dict, MetaDataKey::UpperLeftCornerKey, VGeo); VGeo.clear(); GDALInfoReportCorner("Upper Right", m_Dimensions[0], 0.0, GeoX, GeoY); VGeo.push_back(GeoX); VGeo.push_back(GeoY); itk::EncapsulateMetaData(dict, MetaDataKey::UpperRightCornerKey, VGeo); VGeo.clear(); GDALInfoReportCorner("Lower Left", 0.0, m_Dimensions[1], GeoX, GeoY); VGeo.push_back(GeoX); VGeo.push_back(GeoY); itk::EncapsulateMetaData(dict, MetaDataKey::LowerLeftCornerKey, VGeo); VGeo.clear(); GDALInfoReportCorner("Lower Right", m_Dimensions[0], m_Dimensions[1], GeoX, GeoY); VGeo.push_back(GeoX); VGeo.push_back(GeoY); itk::EncapsulateMetaData(dict, MetaDataKey::LowerRightCornerKey, VGeo); VGeo.clear(); /* -------------------------------------------------------------------- */ /* Color Table */ /* -------------------------------------------------------------------- */ for (int iBand = 0; iBand < dataset->GetRasterCount(); iBand++) { GDALColorTableH hTable; GDALRasterBandH hBand; hBand = GDALGetRasterBand(dataset, iBand + 1); if ((GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex) && (hTable = GDALGetRasterColorTable(hBand)) != ITK_NULLPTR) { m_IsIndexed = true; unsigned int ColorEntryCount = GDALGetColorEntryCount(hTable); itk::EncapsulateMetaData(dict, MetaDataKey::ColorTableNameKey, static_cast(GDALGetPaletteInterpretationName( GDALGetPaletteInterpretation(hTable)))); itk::EncapsulateMetaData(dict, MetaDataKey::ColorEntryCountKey, ColorEntryCount); for (int i = 0; i < GDALGetColorEntryCount(hTable); ++i) { GDALColorEntry sEntry; MetaDataKey::VectorType VColorEntry; GDALGetColorEntryAsRGB(hTable, i, &sEntry); VColorEntry.push_back(sEntry.c1); VColorEntry.push_back(sEntry.c2); VColorEntry.push_back(sEntry.c3); VColorEntry.push_back(sEntry.c4); itk::EncapsulateMetaData(dict, MetaDataKey::ColorEntryAsRGBKey, VColorEntry); } } } if (m_IsIndexed) { m_NbBands *= 4; this->SetNumberOfComponents(m_NbBands); this->SetPixelType(VECTOR); } // Read no data value if present std::vector isNoDataAvailable(dataset->GetRasterCount(),false); std::vector noDataValues(dataset->GetRasterCount(),0); bool noDataFound = false; for (int iBand = 0; iBand < dataset->GetRasterCount(); iBand++) { GDALRasterBandH hBand = GDALGetRasterBand(dataset, iBand + 1); int success; double ndv = GDALGetRasterNoDataValue(hBand,&success); if(success) { noDataFound = true; isNoDataAvailable[iBand]=true; noDataValues[iBand]=ndv; } } if(noDataFound) { itk::EncapsulateMetaData(dict, MetaDataKey::NoDataValueAvailable, isNoDataAvailable); itk::EncapsulateMetaData(dict,MetaDataKey::NoDataValue,noDataValues); } } bool GDALImageIO::CanWriteFile(const char* name) { // First check the filename if (name == ITK_NULLPTR) { itkDebugMacro(<< "No filename specified."); return false; } m_FileName = name; // Get the GDAL format ID from the name std::string gdalDriverShortName = FilenameToGdalDriverShortName(name); if (gdalDriverShortName == "NOT-FOUND") { return false; } // Check the driver for support of Create or at least CreateCopy GDALDriver* driver = GDALDriverManagerWrapper::GetInstance().GetDriverByName(gdalDriverShortName); if ( GDALGetMetadataItem( driver, GDAL_DCAP_CREATE, ITK_NULLPTR ) == ITK_NULLPTR && GDALGetMetadataItem( driver, GDAL_DCAP_CREATECOPY, ITK_NULLPTR ) == ITK_NULLPTR ) { itkDebugMacro(<< "The driver " << GDALGetDriverShortName(driver) << " does not support writing"); return false; } return true; } bool GDALImageIO::CanStreamWrite() { // Get the GDAL format ID from the name std::string gdalDriverShortName = FilenameToGdalDriverShortName(m_FileName); GDALDriver* driver = GDALDriverManagerWrapper::GetInstance().GetDriverByName(gdalDriverShortName); if (driver == ITK_NULLPTR) { itkDebugMacro(<< "Unable to instantiate driver " << gdalDriverShortName); m_CanStreamWrite = false; } if ( GDALGetMetadataItem( driver, GDAL_DCAP_CREATE, ITK_NULLPTR ) != ITK_NULLPTR ) { m_CanStreamWrite = true; } else { m_CanStreamWrite = false; } return m_CanStreamWrite; } void GDALImageIO::Write(const void* buffer) { // Check if we have to write the image information if (m_FlagWriteImageInformation == true) { this->InternalWriteImageInformation(buffer); m_FlagWriteImageInformation = false; } // Check if conversion succeed if (buffer == ITK_NULLPTR) { itkExceptionMacro(<< "GDAL : Bad alloc"); return; } // Compute offset and size unsigned int lNbLines = this->GetIORegion().GetSize()[1]; unsigned int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] // Particular case: checking that the written region is the same size // of the entire image // starting at offset 0 (when no streaming) if ((lNbLines == m_Dimensions[1]) && (lNbColumns == m_Dimensions[0])) { lFirstLine = 0; lFirstColumn = 0; } // Convert buffer from void * to unsigned char * //unsigned char *p = static_cast( const_cast(buffer)); //printDataBuffer(p, m_PxType->pixType, m_NbBands, 10*2); // Buffer incorrect // If driver supports streaming if (m_CanStreamWrite) { otbMsgDevMacro(<< "RasterIO Write requested region : " << this->GetIORegion() << "\n, lFirstColumn =" << lFirstColumn << "\n, lFirstLine =" << lFirstLine << "\n, lNbColumns =" << lNbColumns << "\n, lNbLines =" << lNbLines << "\n, m_PxType =" << GDALGetDataTypeName(m_PxType->pixType) << "\n, m_NbBands =" << m_NbBands << "\n, m_BytePerPixel ="<< m_BytePerPixel << "\n, Pixel offset =" << m_BytePerPixel * m_NbBands << // is nbComp * BytePerPixel "\n, Line offset =" << m_BytePerPixel * m_NbBands * lNbColumns << // is pixelOffset * nbColumns "\n, Band offset =" << m_BytePerPixel) // is BytePerPixel itk::TimeProbe chrono; chrono.Start(); CPLErr lCrGdal = m_Dataset->GetDataSet()->RasterIO(GF_Write, lFirstColumn, lFirstLine, lNbColumns, lNbLines, const_cast(buffer), lNbColumns, lNbLines, m_PxType->pixType, m_NbBands, // We want to write all bands ITK_NULLPTR, // Pixel offset // is nbComp * BytePerPixel m_BytePerPixel * m_NbBands, // Line offset // is pixelOffset * nbColumns m_BytePerPixel * m_NbBands * lNbColumns, // Band offset is BytePerPixel m_BytePerPixel); chrono.Stop(); otbMsgDevMacro(<< "RasterIO Write took " << chrono.GetTotal() << " sec") // Check if writing succeed if (lCrGdal == CE_Failure) { itkExceptionMacro(<< "Error while writing image (GDAL format) '" << m_FileName.c_str() << "' : " << CPLGetLastErrorMsg()); } // Flush dataset cache m_Dataset->GetDataSet()->FlushCache(); } else { // We only wrote data to the memory dataset // Now write it to the real file with CreateCopy() std::string gdalDriverShortName = FilenameToGdalDriverShortName(m_FileName); std::string realFileName = GetGdalWriteImageFileName(gdalDriverShortName, m_FileName); GDALDriver* driver = GDALDriverManagerWrapper::GetInstance().GetDriverByName(gdalDriverShortName); if (driver == ITK_NULLPTR) { itkExceptionMacro(<< "Unable to instantiate driver " << gdalDriverShortName << " to write " << m_FileName); } GDALCreationOptionsType creationOptions = m_CreationOptions; GDALDataset* hOutputDS = driver->CreateCopy( realFileName.c_str(), m_Dataset->GetDataSet(), FALSE, otb::ogr::StringListConverter(creationOptions).to_ogr(), ITK_NULLPTR, ITK_NULLPTR ); if(!hOutputDS) { itkExceptionMacro(<< "Error while writing image (GDAL format) '" << m_FileName.c_str() << "' : " << CPLGetLastErrorMsg()); } else { GDALClose(hOutputDS); } } if (lFirstLine + lNbLines == m_Dimensions[1] && lFirstColumn + lNbColumns == m_Dimensions[0]) { // Last pixel written // Reinitialize to close the file m_Dataset = GDALDatasetWrapperPointer(); } } /** TODO : Methode WriteImageInformation non implementee */ void GDALImageIO::WriteImageInformation() { } void GDALImageIO::InternalWriteImageInformation(const void* buffer) { //char ** papszOptions = NULL; std::string driverShortName; m_NbBands = this->GetNumberOfComponents(); if ((m_Dimensions[0] == 0) && (m_Dimensions[1] == 0)) { itkExceptionMacro(<< "Dimensions are not defined."); } if ((this->GetPixelType() == COMPLEX) /*&& (m_NbBands / 2 > 0)*/) { //m_NbBands /= 2; if (this->GetComponentType() == CSHORT) { m_BytePerPixel = 4; m_PxType->pixType = GDT_CInt16; } else if (this->GetComponentType() == CINT) { m_BytePerPixel = 8; m_PxType->pixType = GDT_CInt32; } else if (this->GetComponentType() == CFLOAT) { m_BytePerPixel = 8; m_PxType->pixType = GDT_CFloat32; } else if (this->GetComponentType() == CDOUBLE) { m_BytePerPixel = 16; m_PxType->pixType = GDT_CFloat64; } else { itkExceptionMacro(<< "This complex type is not defined :" << this->GetPixelTypeAsString(this->GetPixelType()) ); } } else { if (this->GetComponentType() == CHAR) { m_BytePerPixel = 1; m_PxType->pixType = GDT_Byte; } else if (this->GetComponentType() == UCHAR) { m_BytePerPixel = 1; m_PxType->pixType = GDT_Byte; } else if (this->GetComponentType() == USHORT) { m_BytePerPixel = 2; m_PxType->pixType = GDT_UInt16; } else if (this->GetComponentType() == SHORT) { m_BytePerPixel = 2; m_PxType->pixType = GDT_Int16; } else if (this->GetComponentType() == INT) { m_BytePerPixel = 4; m_PxType->pixType = GDT_Int32; } else if (this->GetComponentType() == UINT) { m_BytePerPixel = 4; m_PxType->pixType = GDT_UInt32; } else if (this->GetComponentType() == LONG) { m_BytePerPixel = sizeof(long); if( m_BytePerPixel == 8 ) { itkWarningMacro(<< "Cast a long (64 bits) image into an int (32 bits) one.") } m_PxType->pixType = GDT_Int32; } else if (this->GetComponentType() == ULONG) { m_BytePerPixel = sizeof(unsigned long); if( m_BytePerPixel == 8 ) { itkWarningMacro(<< "Cast an unsigned long (64 bits) image into an unsigned int (32 bits) one.") } m_PxType->pixType = GDT_UInt32; } else if (this->GetComponentType() == FLOAT) { m_BytePerPixel = 4; m_PxType->pixType = GDT_Float32; } else if (this->GetComponentType() == DOUBLE) { m_BytePerPixel = 8; m_PxType->pixType = GDT_Float64; } else { m_BytePerPixel = 1; m_PxType->pixType = GDT_Byte; } } // Automatically set the Type to Binary for GDAL data this->SetFileTypeToBinary(); driverShortName = FilenameToGdalDriverShortName(m_FileName); if (driverShortName == "NOT-FOUND") { itkExceptionMacro( << "GDAL Writing failed : the image file name '" << m_FileName.c_str() << "' is not recognized by GDAL."); } if (m_CanStreamWrite) { GDALCreationOptionsType creationOptions = m_CreationOptions; /* // Force tile mode for TIFF format if no creation option are given if( driverShortName == "GTiff" ) { if ( CreationOptionContains( "TILED=YES" ) ) { // User requested tiled TIFF explicitly // // Let GDAL set up the BLOCKXSIZE and BLOCKYSIZE // or suppose the user have set it also along with TILED=YES // This allows the user to have complete // control over the tiling scheme } else if ( CreationOptionContains( "BLOCKYSIZE=" ) ) { // User did not set "TILED=YES" but set "BLOCKYSIZE=" // -> He requested a stripped TIFF } else { // User did not specify "TILED=YES" nor "BLOCKYSIZE=?" // Switch to TILED mode automatically, and choose BLOCKXSIZE and BLOCKYSIZE for him otbMsgDevMacro(<< "Enabling TIFF Tiled mode") // Use a fixed tile size // Take as reference is a 256*256 short int 4 bands tile const unsigned int ReferenceTileSizeInBytes = 256 * 256 * 4 * 2; const unsigned int NbPixelPerTile = ReferenceTileSizeInBytes / m_BytePerPixel / m_NbBands; const unsigned int IdealTileDimension = static_cast( vcl_sqrt(static_cast(NbPixelPerTile)) ); // Set tileDimension to the nearest power of two and aligned to // 16 pixels (needed by TIFF spec) unsigned int tileDimension = 16; while(2*tileDimension < IdealTileDimension) { tileDimension*=2; } otbMsgDevMacro(<< "Tile dimension : " << tileDimension << " * " << tileDimension) std::ostringstream tileDimensionStr; tileDimensionStr << tileDimension; creationOptions.push_back( "TILED=YES" ); creationOptions.push_back( std::string("BLOCKXSIZE=") + tileDimensionStr.str() ); creationOptions.push_back( std::string("BLOCKYSIZE=") + tileDimensionStr.str() ); } } */ m_Dataset = GDALDriverManagerWrapper::GetInstance().Create( driverShortName, GetGdalWriteImageFileName(driverShortName, m_FileName), m_Dimensions[0], m_Dimensions[1], m_NbBands, m_PxType->pixType, otb::ogr::StringListConverter(creationOptions).to_ogr()); } else { // buffer casted in unsigned long cause under Win32 the address // doesn't begin with 0x, the address in not interpreted as // hexadecimal but alpha numeric value, then the conversion to // integer make us pointing to an non allowed memory block => Crash. //use intptr_t to cast void* to unsigned long. included stdint.h for // uintptr_t typedef. std::ostringstream stream; stream << "MEM:::" << "DATAPOINTER=" << (uintptr_t)(buffer) << "," << "PIXELS=" << m_Dimensions[0] << "," << "LINES=" << m_Dimensions[1] << "," << "BANDS=" << m_NbBands << "," << "DATATYPE=" << GDALGetDataTypeName(m_PxType->pixType) << "," << "PIXELOFFSET=" << m_BytePerPixel * m_NbBands << "," << "LINEOFFSET=" << m_BytePerPixel * m_NbBands * m_Dimensions[0] << "," << "BANDOFFSET=" << m_BytePerPixel; m_Dataset = GDALDriverManagerWrapper::GetInstance().Open(stream.str()); } if (m_Dataset.IsNull()) { itkExceptionMacro( << "GDAL Writing failed : Impossible to create the image file name '" << m_FileName << "' : " << CPLGetLastErrorMsg() ); } /*----------------------------------------------------------------------*/ /*-------------------------- METADATA ----------------------------------*/ /*----------------------------------------------------------------------*/ // Now initialize the itk dictionary itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); std::ostringstream oss; GDALDataset* dataset = m_Dataset->GetDataSet(); std::string projectionRef; itk::ExposeMetaData(dict, MetaDataKey::ProjectionRefKey, projectionRef); /* -------------------------------------------------------------------- */ /* Set the GCPs */ /* -------------------------------------------------------------------- */ const double Epsilon = 1E-10; if (projectionRef.empty() && (vcl_abs(m_Origin[0] - 0.5) > Epsilon || vcl_abs(m_Origin[1] - 0.5) > Epsilon || vcl_abs(m_Spacing[0] - 1.0) > Epsilon || vcl_abs(m_Spacing[1] - 1.0) > Epsilon) ) { // See issue #303 : // If there is no ProjectionRef, and the GeoTransform is not the identity, // then saving also GCPs is undefined behavior for GDAL, and a WGS84 projection crs // is assigned arbitrarily otbMsgDevMacro(<< "Skipping GCPs saving to prevent GDAL from assigning a WGS84 projection ref to the file") } else { unsigned int gcpCount = 0; itk::ExposeMetaData(dict, MetaDataKey::GCPCountKey, gcpCount); if (gcpCount > 0) { GDAL_GCP * gdalGcps = new GDAL_GCP[gcpCount]; for (unsigned int gcpIndex = 0; gcpIndex < gcpCount; ++gcpIndex) { //Build the GCP string in the form of GCP_n std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << gcpIndex; std::string key = lStream.str(); OTB_GCP gcp; itk::ExposeMetaData(dict, key, gcp); gdalGcps[gcpIndex].pszId = const_cast(gcp.m_Id.c_str()); gdalGcps[gcpIndex].pszInfo = const_cast(gcp.m_Info.c_str()); gdalGcps[gcpIndex].dfGCPPixel = gcp.m_GCPCol; gdalGcps[gcpIndex].dfGCPLine = gcp.m_GCPRow; gdalGcps[gcpIndex].dfGCPX = gcp.m_GCPX; gdalGcps[gcpIndex].dfGCPY = gcp.m_GCPY; gdalGcps[gcpIndex].dfGCPZ = gcp.m_GCPZ; } std::string gcpProjectionRef; itk::ExposeMetaData(dict, MetaDataKey::GCPProjectionKey, gcpProjectionRef); dataset->SetGCPs(gcpCount, gdalGcps, gcpProjectionRef.c_str()); delete[] gdalGcps; } } /* -------------------------------------------------------------------- */ /* Set the projection coordinate system of the image : ProjectionRef */ /* -------------------------------------------------------------------- */ if (!projectionRef.empty()) { dataset->SetProjection(projectionRef.c_str()); } else { /* -------------------------------------------------------------------- */ /* Set the RPC coeffs if no projection available (since GDAL 1.10.0) */ /* -------------------------------------------------------------------- */ #if GDAL_VERSION_NUM >= 1100000 ImageKeywordlist otb_kwl; itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, otb_kwl); if( m_WriteRPCTags && otb_kwl.GetSize() != 0 ) { GDALRPCInfo gdalRpcStruct; if ( otb_kwl.convertToGDALRPC(gdalRpcStruct) ) { char **rpcMetadata = RPCInfoToMD(&gdalRpcStruct); dataset->SetMetadata(rpcMetadata, "RPC"); CSLDestroy( rpcMetadata ); } } #endif } /* -------------------------------------------------------------------- */ /* Set the six coefficients of affine geoTransform */ /* -------------------------------------------------------------------- */ itk::VariableLengthVector geoTransform(6); /// Reporting origin and spacing // Beware : GDAL origin is at the corner of the top-left pixel // whereas OTB/ITK origin is at the centre of the top-left pixel geoTransform[0] = m_Origin[0] - 0.5*m_Spacing[0]; geoTransform[3] = m_Origin[1] - 0.5*m_Spacing[1]; geoTransform[1] = m_Spacing[0]; geoTransform[5] = m_Spacing[1]; // FIXME: Here component 1 and 4 should be replaced by the orientation parameters geoTransform[2] = 0.; geoTransform[4] = 0.; dataset->SetGeoTransform(const_cast(geoTransform.GetDataPointer())); /* -------------------------------------------------------------------- */ /* Report metadata. */ /* -------------------------------------------------------------------- */ std::string svalue = ""; std::vector keys = dict.GetKeys(); std::string const metadataKey = MetaDataKey::MetadataKey; for (unsigned int itkey = 0; itkey < keys.size(); ++itkey) { /// \todo Why not keys[itkey] == MetadataKey::MetadataKey ? if (keys[itkey].compare(0, metadataKey.length(), metadataKey) == 0) { itk::ExposeMetaData(dict, keys[itkey], svalue); unsigned int equalityPos = svalue.find_first_of('='); std::string tag = svalue.substr(0, equalityPos); std::string value = svalue.substr(equalityPos + 1); otbMsgDevMacro(<< "Metadata: " << tag << "=" << value); dataset->SetMetadataItem(tag.c_str(), value.c_str(), ITK_NULLPTR); } } // END // Dataset info otbMsgDevMacro( << "**** WriteImageInformation() DATASET INFO: ****" ); otbMsgDevMacro( << "Projection Ref: "<GetProjectionRef() ); double GT[6]; if (dataset->GetGeoTransform(GT) == CE_None) { otbMsgDevMacro( <<"Geo Transform: "<< GT[0] << ", " << GT[1] << ", " << GT[2] << ", " << GT[3] << ", " << GT[4] << ", " << GT[5] ); } else { otbMsgDevMacro( << "No Geo Transform: "); } otbMsgDevMacro( << "GCP Projection Ref: "<< dataset->GetGCPProjection() ); otbMsgDevMacro( << "GCP Count: " << dataset->GetGCPCount() ); // Write no-data flags std::vector noDataValueAvailable; bool ret = itk::ExposeMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); std::vector noDataValues; itk::ExposeMetaData >(dict,MetaDataKey::NoDataValue,noDataValues); if(ret) { for (int iBand = 0; iBand < dataset->GetRasterCount(); iBand++) { if(noDataValueAvailable[iBand]) { dataset->GetRasterBand(iBand+1)->SetNoDataValue(noDataValues[iBand]); } } } } std::string GDALImageIO::FilenameToGdalDriverShortName(const std::string& name) const { std::string extension; std::string gdalDriverShortName; // Get extension in lowercase extension = itksys::SystemTools::LowerCase( itksys::SystemTools::GetFilenameLastExtension(name) ); if ( extension == ".tif" || extension == ".tiff" ) gdalDriverShortName = "GTiff"; else if ( extension == ".hdr" ) gdalDriverShortName = "ENVI"; else if ( extension == ".img" ) gdalDriverShortName = "HFA"; else if ( extension == ".ntf" ) gdalDriverShortName = "NITF"; else if ( extension == ".png" ) gdalDriverShortName="PNG"; else if ( extension == ".jpg" || extension== ".jpeg" ) gdalDriverShortName="JPEG"; else if ( extension == ".pix" ) gdalDriverShortName="PCIDSK"; else if ( extension == ".lbl" || extension == ".pds" ) gdalDriverShortName="ISIS2"; else if ( extension == ".j2k" || extension == ".jp2" || extension == ".jpx") { // Try different JPEG2000 drivers GDALDriver *driver = ITK_NULLPTR; driver = GDALDriverManagerWrapper::GetInstance().GetDriverByName("JP2OpenJPEG"); if (driver) { gdalDriverShortName = "JP2OpenJPEG"; } if (!driver) { driver = GDALDriverManagerWrapper::GetInstance().GetDriverByName("JP2KAK"); if (driver) { gdalDriverShortName = "JP2KAK"; } } if (!driver) { driver = GDALDriverManagerWrapper::GetInstance().GetDriverByName("JP2ECW"); if (driver) { gdalDriverShortName = "JP2ECW"; } } if (!driver) { gdalDriverShortName = "NOT-FOUND"; } } else gdalDriverShortName = "NOT-FOUND"; return gdalDriverShortName; } bool GDALImageIO::GetOriginFromGMLBox(std::vector &origin) { GDALJP2Metadata jp2Metadata; if (!jp2Metadata.ReadAndParse(m_FileName.c_str())) { return false; } if (!jp2Metadata.papszGMLMetadata) { return false; } std::string gmlString = static_cast(jp2Metadata.papszGMLMetadata[0]); gmlString.erase(0,18); // We need to remove first part to create a true xml stream otbMsgDevMacro( << "XML extract from GML box: " << gmlString ); TiXmlDocument doc; doc.Parse(gmlString.c_str()); // Create xml doc from a string TiXmlHandle docHandle( &doc ); TiXmlElement* originTag = docHandle.FirstChild( "gml:FeatureCollection" ) .FirstChild( "gml:featureMember" ) .FirstChild( "gml:FeatureCollection" ) .FirstChild( "gml:featureMember" ) .FirstChild( "gml:GridCoverage" ) .FirstChild( "gml:gridDomain") .FirstChild( "gml:Grid" ) .FirstChild( "gml:limits" ) .FirstChild( "gml:GridEnvelope" ) .FirstChild( "gml:low").ToElement(); if(originTag) { otbMsgDevMacro( << "\t Origin (" << originTag->Value() <<" tag)= "<< originTag->GetText()); } else { otbMsgDevMacro( << "Didn't find the GML element which indicate the origin!" ); return false; } std::vector originValues; originValues = itksys::SystemTools::SplitString(originTag->GetText(),' ', false); // Compute origin in GDAL convention (the half-pixel shift is applied later) std::istringstream ss0 (originValues[0]); std::istringstream ss1 (originValues[1]); ss0 >> origin[1]; ss1 >> origin[0]; origin[0] += -1.0; origin[1] += -1.0; otbMsgDevMacro( << "\t Origin from GML box: " << origin[0] << ", " << origin[1] ); return true; } std::string GDALImageIO::GetGdalWriteImageFileName(const std::string& gdalDriverShortName, const std::string& filename) const { std::string gdalFileName; gdalFileName = filename; // Suppress hdr extension for ENVI format if (gdalDriverShortName == "ENVI") { gdalFileName = System::GetRootName(filename); } return gdalFileName; } bool GDALImageIO::GDALInfoReportCorner(const char * /*corner_name*/, double x, double y, double& GeoX, double& GeoY) const { double adfGeoTransform[6]; bool IsTrue; /* -------------------------------------------------------------------- */ /* Transform the point into georeferenced coordinates. */ /* -------------------------------------------------------------------- */ if (m_Dataset->GetDataSet()->GetGeoTransform(adfGeoTransform) == CE_None) { GeoX = adfGeoTransform[0] + adfGeoTransform[1] * x + adfGeoTransform[2] * y; GeoY = adfGeoTransform[3] + adfGeoTransform[4] * x + adfGeoTransform[5] * y; IsTrue = true; } else { GeoX = x; GeoY = y; IsTrue = false; } return IsTrue; } bool GDALImageIO::CreationOptionContains(std::string partialOption) const { size_t i; for (i = 0; i < m_CreationOptions.size(); ++i) { if (boost::algorithm::starts_with(m_CreationOptions[i], partialOption)) { break; } } return (i != m_CreationOptions.size()); } std::string GDALImageIO::GetGdalPixelTypeAsString() const { std::string name = GDALGetDataTypeName(m_PxType->pixType); return name; } } // end namespace otb OTB-release-5.8/Modules/IO/IOGDAL/src/otbGDALImageIOFactory.cxx000066400000000000000000000031341301006202600235470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGDALImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbGDALImageIO.h" #include "itkVersion.h" namespace otb { GDALImageIOFactory::GDALImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbGDALImageIO", "GDAL Image IO", 1, itk::CreateObjectFunction::New()); } GDALImageIOFactory::~GDALImageIOFactory() { } const char* GDALImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* GDALImageIOFactory::GetDescription() const { return "GDAL ImageIO Factory, enabling loading gdal images in OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool GDALImageIOFactoryHasBeenRegistered; void GDALImageIOFactoryRegister__Private(void) { if( ! GDALImageIOFactoryHasBeenRegistered ) { GDALImageIOFactoryHasBeenRegistered = true; GDALImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOGDAL/src/otbGDALOverviewsBuilder.cxx000066400000000000000000000305141301006202600242470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGDALOverviewsBuilder.h" #include #include "gdal.h" #include "otb_boost_string_header.h" #include "otbGDALDriverManagerWrapper.h" #include "otbGDALImageIO.h" #include "otbSystem.h" namespace otb { // Progress reporting functions compatible with GDAL C API extern "C" { static int CPL_STDCALL otb_UpdateGDALProgress( double dfComplete, const char * itkNotUsed( pszMessage ), void * pProgressArg ) { otb::GDALOverviewsBuilder* _this = (otb::GDALOverviewsBuilder*)pProgressArg; _this->UpdateProgress(dfComplete); return 1; } } char const * const GDAL_RESAMPLING_NAMES[ GDAL_RESAMPLING_COUNT ] = { "NONE", "NEAREST", "GAUSS", "CUBIC", "AVERAGE", "MODE", "AVERAGE_MAGPHASE" }; char const * const GDAL_COMPRESSION_NAMES[ GDAL_COMPRESSION_COUNT ] = { "", "JPEG", "LZW", "PACKBITS", "DEFLATE", }; /***************************************************************************/ std::string GetConfigOption( const char * key ) { const char * value = CPLGetConfigOption( key, ITK_NULLPTR ); return value==ITK_NULLPTR ? std::string() : std::string( value ); } /***************************************************************************/ bool GDALOverviewsBuilder ::CanGenerateOverviews( const std::string & filename ) { GDALImageIO::Pointer io( GDALImageIO::New() ); typedef std::vector< std::string > StringVector; StringVector names; StringVector descs; if( !io->CanReadFile( filename.c_str() ) ) return false; io->SetFileName( filename ); return !io->GetSubDatasetInfo( names, descs ); } /***************************************************************************/ GDALOverviewsBuilder ::GDALOverviewsBuilder() : m_GDALDataset(), m_InputFileName(), m_NbResolutions( 1 ), m_ResolutionFactor( 2 ), m_ResamplingMethod( GDAL_RESAMPLING_NEAREST ), m_CompressionMethod( GDAL_COMPRESSION_NONE ), m_Format( GDAL_FORMAT_GEOTIFF ), m_IsBypassEnabled( false ) { Superclass::SetNumberOfRequiredInputs(0); Superclass::SetNumberOfRequiredOutputs(0); } /***************************************************************************/ unsigned int GDALOverviewsBuilder ::CountResolutions( unsigned int factor, unsigned int minSize ) const { assert( factor>1 ); if( factor<=1 ) return 0; assert( minSize>0 ); if( minSize<=0 ) return 0; assert( !m_GDALDataset.IsNull() ); // unsigned int minSize = static_cast< unsigned int >( pow( factor, n ) ); unsigned int size = std::min( m_GDALDataset->GetWidth(), m_GDALDataset->GetHeight() ); if( size= minSize ) { ++ count; size /= factor; } return count; } /***************************************************************************/ unsigned int GDALOverviewsBuilder ::CountResolutions( unsigned int minSize ) const { return CountResolutions( m_ResolutionFactor, minSize ); } /***************************************************************************/ unsigned int GDALOverviewsBuilder ::CountResolutions() const { return CountResolutions( 1 ); } /***************************************************************************/ void GDALOverviewsBuilder ::ListResolutions( SizeVector & sizes ) { ListResolutions( sizes, m_ResolutionFactor, m_NbResolutions ); } /***************************************************************************/ void GDALOverviewsBuilder ::ListResolutions( SizeVector & sizes, unsigned int factor, unsigned int count ) { assert( factor>1 ); if( factor<=1 ) return; assert( !m_GDALDataset.IsNull() ); Size s; s[ 0 ] = m_GDALDataset->GetWidth(); s[ 1 ] = m_GDALDataset->GetHeight(); unsigned int n = std::min( count, CountResolutions( factor ) ); for( unsigned int i=0; iGetWidth(); } /***************************************************************************/ unsigned int GDALOverviewsBuilder ::GetHeight() const { assert( !m_GDALDataset.IsNull() ); return m_GDALDataset->GetHeight(); } /***************************************************************************/ unsigned int GDALOverviewsBuilder ::GetOverviewsCount() const { assert( !m_GDALDataset.IsNull() ); // Return only GDAL already generated overview count as opposed to // ImageIO::GetOverviewsCount() which include full image as one level. return m_GDALDataset->GetOverviewsCount(); } /***************************************************************************/ size_t GDALOverviewsBuilder ::GetEstimatedSize() const { if( m_IsBypassEnabled ) return 0; assert( !m_GDALDataset.IsNull() ); assert( m_ResolutionFactor>0 ); size_t bytes = m_GDALDataset->GetPixelBytes(); assert( bytes>0 ); size_t size = 0; unsigned int w = m_GDALDataset->GetWidth(); unsigned int h = m_GDALDataset->GetHeight(); for( unsigned int i=0; i GDALDatasetWrapperPointer; // GDALDatasetWrapperPointer wrappedDataset = // GDALDriverManagerWrapper::GetInstance().Open(m_InputFileName); // if (wrappedDataset.IsNull()) // { // itkExceptionMacro(<< "Error while opening the file "<< m_InputFileName.c_str() << "."); // } assert( !m_GDALDataset.IsNull() ); assert( m_NbResolutions>0 ); if( m_NbResolutions==0 ) { itkExceptionMacro( << "Wrong number of resolutions: " << m_NbResolutions ); } if( m_IsBypassEnabled ) return; // Build the overviews list from nb of resolution desired std::vector< int > ovwlist; unsigned int factor = 1; for( unsigned int i = 1; i < m_NbResolutions; i++ ) { factor*=m_ResolutionFactor; ovwlist.push_back(factor); } /*std::cout << "list of overviews level= "; for (unsigned int i = 0; i < ovwlist.size(); i++) { std::cout << ovwlist[i] << ","; } std::cout << std::endl; */ std::string erdas( GetConfigOption( "USE_RRD" ) ); CPLSetConfigOption( "USE_RRD", m_Format==GDAL_FORMAT_ERDAS ? "YES" : "NO" ); assert( m_CompressionMethod>=GDAL_COMPRESSION_NONE && m_CompressionMethod=GDAL_RESAMPLING_NONE && m_ResamplingMethodGetDataSet()->BuildOverviews( GDAL_RESAMPLING_NAMES[ m_ResamplingMethod ], static_cast< int >( m_NbResolutions - 1 ), &ovwlist.front(), 0, // All bands ITK_NULLPTR, // All bands ( GDALProgressFunc )otb_UpdateGDALProgress, this ); CPLSetConfigOption( "USE_RRD", erdas.c_str() ); CPLSetConfigOption( "COMPRESS_OVERVIEW", compression.c_str() ); if (lCrGdal == CE_Failure) { itkExceptionMacro(<< "Error while building the GDAL overviews from " << m_InputFileName.c_str() << "."); } } /***************************************************************************/ void GDALOverviewsBuilder ::OpenDataset( const std::string & filename ) { GDALDatasetWrapper::Pointer dataset( GDALDriverManagerWrapper::GetInstance().Open( filename ) ); if( dataset.IsNull() ) itkExceptionMacro( << "Error while opening file '" << filename.c_str() << "' as GDAL dataset." ); m_GDALDataset = dataset; } } // end namespace otb OTB-release-5.8/Modules/IO/IOGDAL/src/otbOGRIOHelper.cxx000066400000000000000000001351621301006202600223430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRIOHelper.h" #include "otbMacro.h" #include "ogrsf_frmts.h" #include "otbOGR.h" #include "itkTimeProbe.h" namespace otb { void OGRIOHelper ::ConvertGeometryToPointNode(const OGRGeometry * ogrGeometry, DataNodePointerType node) const { OGRPoint * ogrPoint = (OGRPoint *) ogrGeometry; if (ogrPoint == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Failed to convert OGRGeometry to OGRPoint"); } PointType otbPoint; otbPoint.Fill(0); otbPoint[0] = static_cast(ogrPoint->getX()); otbPoint[1] = static_cast(ogrPoint->getY()); if (DataNodeType::Dimension > 2) { if (PointType::PointDimension != 3) { itkGenericExceptionMacro(<< "OTB vector data can't contain the OGR information (2D instead of 2.5D)"); } otbPoint[2] = static_cast(ogrPoint->getZ()); } node->SetPoint(otbPoint); } void OGRIOHelper ::ConvertGeometryToLineNode(const OGRGeometry * ogrGeometry, DataNodePointerType node) const { OGRLineString * ogrLine = (OGRLineString *) ogrGeometry; if (ogrLine == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Failed to convert OGRGeometry to OGRLine"); } LinePointerType line = LineType::New(); OGRPoint * ogrTmpPoint = (OGRPoint *) OGRGeometryFactory::createGeometry(wkbPoint); for (int pIndex = 0; pIndex < ogrLine->getNumPoints(); ++pIndex) { ogrLine->getPoint(pIndex, ogrTmpPoint); LineType::VertexType vertex; vertex[0] = ogrTmpPoint->getX(); vertex[1] = ogrTmpPoint->getY(); if (DataNodeType::Dimension > 2) { if (LineType::VertexType::PointDimension != 3) { itkGenericExceptionMacro(<< "OTB vector data can't contain the OGR information (2D instead of 2.5D)"); } vertex[2] = ogrTmpPoint->getZ(); } line->AddVertex(vertex); } OGRGeometryFactory::destroyGeometry(ogrTmpPoint); node->SetLine(line); } inline void OGRIOHelper ::ConvertGeometryToPolygonNode(const OGRGeometry * ogrGeometry, DataNodePointerType node) const { OGRPolygon * ogrPolygon = (OGRPolygon *) ogrGeometry; if (ogrPolygon == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Failed to convert OGRGeometry to OGRPolygon"); } OGRPoint * ogrTmpPoint = (OGRPoint *) OGRGeometryFactory::createGeometry(wkbPoint); OGRLinearRing * ogrRing = ogrPolygon->getExteriorRing(); PolygonPointerType extRing = PolygonType::New(); for (int pIndex = 0; pIndex < ogrRing->getNumPoints(); ++pIndex) { ogrRing->getPoint(pIndex, ogrTmpPoint); PolygonType::VertexType vertex; vertex[0] = ogrTmpPoint->getX(); vertex[1] = ogrTmpPoint->getY(); if (DataNodeType::Dimension > 2) { if (PolygonType::VertexType::PointDimension != 3) { itkGenericExceptionMacro(<< "OTB vector data can't contain the OGR information (2D instead of 2.5D)"); } vertex[2] = ogrTmpPoint->getZ(); } extRing->AddVertex(vertex); } PolygonListPointerType intRings = PolygonListType::New(); for (int intRingIndex = 0; intRingIndex < ogrPolygon->getNumInteriorRings(); ++intRingIndex) { PolygonPointerType ring = PolygonType::New(); ogrRing = ogrPolygon->getInteriorRing(intRingIndex); for (int pIndex = 0; pIndex < ogrRing->getNumPoints(); ++pIndex) { ogrRing->getPoint(pIndex, ogrTmpPoint); PolygonType::VertexType vertex; vertex[0] = ogrTmpPoint->getX(); vertex[1] = ogrTmpPoint->getY(); if (DataNodeType::Dimension > 2) { if (PolygonType::VertexType::PointDimension != 3) { itkGenericExceptionMacro(<< "OTB vector data can't contain the OGR information (2D instead of 2.5D)"); } vertex[2] = ogrTmpPoint->getZ(); } ring->AddVertex(vertex); } intRings->PushBack(ring); } OGRGeometryFactory::destroyGeometry(ogrTmpPoint); node->SetPolygonExteriorRing(extRing); node->SetPolygonInteriorRings(intRings); } OGRIOHelper ::OGRIOHelper() { otb::ogr::Drivers::Init(); } OGRIOHelper ::~OGRIOHelper() {} void OGRIOHelper ::ConvertOGRLayerToDataTreeNode(OGRLayer * layer, InternalTreeNodeType * documentPtr) const { /** Temporary pointer to store the feature */ OGRFeature * feature; layer->ResetReading(); unsigned int counter = 0; itk::TimeProbe chrono; while ((feature = layer->GetNextFeature()) != ITK_NULLPTR) { chrono.Start(); // A pointer to the current multi-geometry InternalTreeNodeType::Pointer multiPtr; /** Temporary geometry container */ OGRGeometry * geometry = feature->GetGeometryRef(); if (geometry == ITK_NULLPTR) { OGRFeature::DestroyFeature(feature); chrono.Stop(); ++counter; continue; } otb::VectorDataKeywordlist kwl; for (int fieldNum = 0; fieldNum < feature->GetFieldCount(); ++fieldNum) { if (feature->IsFieldSet(fieldNum)) { kwl.AddField(feature->GetFieldDefnRef(fieldNum), feature->GetRawFieldRef(fieldNum)); } } switch (geometry->getGeometryType()) { case wkbPoint: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(geometry, dataNode); newNode->Set(dataNode); //Reach the DataNode inside the tree node itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); documentPtr->AddChild(newNode); break; } case wkbPoint25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(geometry, dataNode); newNode->Set(dataNode); //Reach the DataNode inside the tree node itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); documentPtr->AddChild(newNode); break; } case wkbLineString: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(geometry, dataNode); newNode->Set(dataNode); //Reach the DataNode inside the tree node itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); documentPtr->AddChild(newNode); break; } case wkbLineString25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(geometry, dataNode); newNode->Set(dataNode); //Reach the DataNode inside the tree node itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); documentPtr->AddChild(newNode); break; } case wkbPolygon: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(geometry, dataNode); newNode->Set(dataNode); //Reach the DataNode inside the tree node itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); documentPtr->AddChild(newNode); break; } case wkbPolygon25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(geometry, dataNode); newNode->Set(dataNode); //Reach the DataNode inside the tree node itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); documentPtr->AddChild(newNode); break; } case wkbMultiPoint: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_MULTIPOINT); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRMultiPoint * ogrMulti = (OGRMultiPoint *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); } break; } case wkbMultiPoint25D: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_MULTIPOINT); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRMultiPoint * ogrMulti = (OGRMultiPoint *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); } break; } case wkbMultiLineString: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_MULTILINE); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRMultiLineString * ogrMulti = (OGRMultiLineString *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); } break; } case wkbMultiLineString25D: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_MULTILINE); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRMultiLineString * ogrMulti = (OGRMultiLineString *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); } break; } case wkbMultiPolygon: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_MULTIPOLYGON); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRMultiPolygon * ogrMulti = (OGRMultiPolygon *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); } break; } case wkbMultiPolygon25D: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_MULTIPOLYGON); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRMultiPolygon * ogrMulti = (OGRMultiPolygon *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); } break; } case wkbGeometryCollection: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_COLLECTION); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRGeometryCollection * ogrMulti = (OGRGeometryCollection *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { switch (ogrMulti->getGeometryRef(geoIndex)->getGeometryType()) { case wkbPoint: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); break; } case wkbPoint25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); break; } case wkbLineString: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); break; } case wkbLineString25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); break; } case wkbPolygon: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); break; } case wkbPolygon25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); itk::MetaDataDictionary& dict = newNode->Get()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::VectorDataKeywordlistKey, kwl); multiPtr->AddChild(newNode); break; } default: { otbWarningMacro( << "Geometry type not found: " << ogrMulti->getGeometryRef(geoIndex)->getGeometryType()); break; } } } break; } case wkbGeometryCollection25D: { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_COLLECTION); multiPtr = InternalTreeNodeType::New(); multiPtr->Set(multi); documentPtr->AddChild(multiPtr); OGRGeometryCollection * ogrMulti = (OGRGeometryCollection *) geometry; for (int geoIndex = 0; geoIndex < ogrMulti->getNumGeometries(); ++geoIndex) { switch (ogrMulti->getGeometryRef(geoIndex)->getGeometryType()) { case wkbPoint: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); multiPtr->AddChild(newNode); break; } case wkbPoint25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPointNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); multiPtr->AddChild(newNode); break; } case wkbLineString: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); multiPtr->AddChild(newNode); break; } case wkbLineString25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToLineNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); multiPtr->AddChild(newNode); break; } case wkbPolygon: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); multiPtr->AddChild(newNode); break; } case wkbPolygon25D: { InternalTreeNodeType::Pointer newNode = InternalTreeNodeType::New(); DataNodePointerType dataNode = DataNodeType::New(); ConvertGeometryToPolygonNode(ogrMulti->getGeometryRef(geoIndex), dataNode); newNode->Set(dataNode); multiPtr->AddChild(newNode); break; } default: { otbWarningMacro( << "Geometry type not found: " << ogrMulti->getGeometryRef(geoIndex)->getGeometryType()); break; } } } break; } default: { otbWarningMacro("Geometry not handled: " << geometry->getGeometryName()); break; } } OGRFeature::DestroyFeature(feature); chrono.Stop(); ++counter; } //end While feature otbMsgDevMacro( << layer->GetFeatureCount() << " features read, average insertion time " << chrono.GetMean() << " s"); } unsigned int OGRIOHelper ::ProcessNodeWrite(InternalTreeNodeType * source, ogr::version_proxy::GDALDatasetType * m_DataSource, OGRGeometryCollection * ogrCollection, OGRLayer * ogrCurrentLayer, OGRSpatialReference * oSRS) { unsigned int kept = 0; bool fieldsAddedToOGRLayer = false; // Get the children list from the input node typedef InternalTreeNodeType::ChildrenListType ChildrenListType; ChildrenListType children = source->GetChildrenList(); // For each child for (ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { DataNodePointerType dataNode = (*it)->Get(); //otbMsgDevMacro(<< "Type of node " << dataNode->GetNodeType() << " id " << dataNode->GetNodeId()); ++kept; // Get the kwl otb::VectorDataKeywordlist kwl; itk::ExposeMetaData(dataNode->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); // Create the field once if (ogrCurrentLayer != ITK_NULLPTR && !fieldsAddedToOGRLayer) { // Take into account the fields stored in the // vectordatakeywordlist for (unsigned int fieldIdx = 0; fieldIdx < kwl.GetNumberOfFields(); fieldIdx++) { if ( std::string(kwl.GetNthField(fieldIdx).first->GetNameRef()) != "FID" ) { otbMsgDevMacro(<< " CreateField '" << kwl.GetNthField(fieldIdx).first->GetNameRef() << "'"); if (ogrCurrentLayer->CreateField(kwl.GetNthField(fieldIdx).first) != OGRERR_NONE ) { itkExceptionMacro(<< "Failed to create Field "<GetNameRef()); } } else { otbMsgDevMacro(<< "WARNING: Skipping OGR field 'FID'"); } } // While no feature are added to the layer (in case of multiple // folders added to the document) continue test for adding // fields to the ogrCurrentLayer if ( kwl.GetNumberOfFields() > 0 || ogrCurrentLayer->GetFeatureCount() > 0) { fieldsAddedToOGRLayer = true; } } switch (dataNode->GetNodeType()) { case ROOT: { break; } case DOCUMENT: { ogrCurrentLayer = m_DataSource->CreateLayer(dataNode->GetNodeId(), oSRS, wkbUnknown, ITK_NULLPTR); if (ogrCurrentLayer == ITK_NULLPTR) { //itkExceptionMacro(<<"Failed to create layer "<GetNodeId()); std::cout << "Failed to create layer " << dataNode->GetNodeId() << std::endl; } else { // New OGRLayer, set the flag to false fieldsAddedToOGRLayer = false; } ProcessNodeWrite(*it, m_DataSource, ogrCollection, ogrCurrentLayer, oSRS); break; } case FOLDER: { ProcessNodeWrite(*it, m_DataSource, ogrCollection, ogrCurrentLayer, oSRS); break; } case FEATURE_POINT: { //Build the ogrObject OGRPoint ogrPoint; ogrPoint.setX(dataNode->GetPoint()[0]); ogrPoint.setY(dataNode->GetPoint()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(dataNode->GetPoint()[2]); } //Save it in the structure if (ogrCollection == ITK_NULLPTR) { OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // Add the fields to the features for (unsigned int i = 0; i < kwl.GetNumberOfFields(); ++i) { // Get the key of the Nth OGRFieldRefn const char * key = kwl.GetNthField(i).first->GetNameRef(); if (std::string(key) != "FID") { // Edit the value of the field and add it to the current feature ogrFeature->SetField(ogrFeature->GetFieldIndex(key) , kwl.GetFieldAsString(key).c_str()); } } // ogrFeature->SetField("Name", dataNode->GetNodeId()); ogrFeature->SetGeometry(&ogrPoint); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); //std::cout << "Failed to create feature in shapefile." } OGRFeature::DestroyFeature(ogrFeature); } else { ogrCollection->addGeometry(&ogrPoint); } break; } case FEATURE_LINE: { //Build the ogrObject OGRLineString ogrLine; VertexListConstPointerType vertexList = dataNode->GetLine()->GetVertexList(); VertexListType::ConstIterator vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrLine.addPoint(&ogrPoint); ++vIt; } //Save it in the structure if (ogrCollection == ITK_NULLPTR) { OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // Add the fields to the features for (unsigned int i = 0; i < kwl.GetNumberOfFields(); ++i) { // Get the key of the Nth OGRFieldRefn const char * key = kwl.GetNthField(i).first->GetNameRef(); // Edit the value of the field and add it to the current feature ogrFeature->SetField(ogrFeature->GetFieldIndex(key) , kwl.GetFieldAsString(key).c_str()); } // ogrFeature->SetField("Name", dataNode->GetNodeId()); ogrFeature->SetGeometry(&ogrLine); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } OGRFeature::DestroyFeature(ogrFeature); } else { ogrCollection->addGeometry(&ogrLine); } break; } case FEATURE_POLYGON: { //Build the ogrObject OGRPolygon * ogrPolygon = (OGRPolygon *) OGRGeometryFactory::createGeometry(wkbPolygon); OGRLinearRing * ogrExternalRing = (OGRLinearRing *) OGRGeometryFactory::createGeometry(wkbLinearRing); VertexListConstPointerType vertexList = dataNode->GetPolygonExteriorRing()->GetVertexList(); VertexListType::ConstIterator vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrExternalRing->addPoint(&ogrPoint); ++vIt; } ogrPolygon->addRing(ogrExternalRing); // Close the polygon ogrPolygon->closeRings(); OGRGeometryFactory::destroyGeometry(ogrExternalRing); // Retrieving internal rings as well for (PolygonListType::Iterator pIt = dataNode->GetPolygonInteriorRings()->Begin(); pIt != dataNode->GetPolygonInteriorRings()->End(); ++pIt) { OGRLinearRing * ogrInternalRing = (OGRLinearRing *) OGRGeometryFactory::createGeometry(wkbLinearRing); vertexList = pIt.Get()->GetVertexList(); vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrInternalRing->addPoint(&ogrPoint); ++vIt; } ogrPolygon->addRing(ogrInternalRing); OGRGeometryFactory::destroyGeometry(ogrInternalRing); } //Save it in the structure if (ogrCollection == ITK_NULLPTR) { OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // Add the fields to the features for (unsigned int i = 0; i < kwl.GetNumberOfFields(); ++i) { // Get the key of the Nth OGRFieldRefn const char * key = kwl.GetNthField(i).first->GetNameRef(); // Edit the value of the field and add it to the current feature ogrFeature->SetField(ogrFeature->GetFieldIndex(key) , kwl.GetFieldAsString(key).c_str()); } ogrFeature->SetGeometry(ogrPolygon); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } OGRFeature::DestroyFeature(ogrFeature); } else { ogrCollection->addGeometry(ogrPolygon); } OGRGeometryFactory::destroyGeometry(ogrPolygon); break; } case FEATURE_MULTIPOINT: { if (ogrCollection != ITK_NULLPTR) { itkExceptionMacro(<< "Problem while creating multipoint."); } OGRMultiPoint* ogrMultiPoint = (OGRMultiPoint*) OGRGeometryFactory::createGeometry(wkbMultiPoint); OGRFeature * ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // ogrFeature->SetField("Name", dataNode->GetNodeId()); ogrFeature->GetDefnRef()->SetGeomType(wkbMultiPoint); ogrFeature->SetGeometry(ogrMultiPoint); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ProcessNodeWrite(*it, m_DataSource, ogrCollection, ogrCurrentLayer, oSRS); break; } case FEATURE_MULTILINE: { if (ogrCollection != ITK_NULLPTR) { itkExceptionMacro(<< "Problem while creating multiline."); } // Instantiate a new ogrMultiLineString feature OGRMultiLineString* ogrMultiLineString = (OGRMultiLineString*) OGRGeometryFactory::createGeometry( wkbMultiLineString); OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // ogrFeature->SetField("Name", dataNode->GetNodeId()); ogrFeature->GetDefnRef()->SetGeomType(wkbMultiLineString); ogrFeature->SetGeometry(ogrMultiLineString); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ProcessNodeWrite(*it, m_DataSource, ogrCollection, ogrCurrentLayer, oSRS); break; } case FEATURE_MULTIPOLYGON: { if (ogrCollection != ITK_NULLPTR) { itkExceptionMacro(<< "Problem while creating multipolygon."); } // Instantiate a new multipolygon feature OGRMultiPolygon* ogrMultiPolygon = (OGRMultiPolygon*) OGRGeometryFactory::createGeometry(wkbMultiPolygon); OGRFeature * ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // ogrFeature->SetField("Name", dataNode->GetNodeId()); ogrFeature->GetDefnRef()->SetGeomType(wkbMultiPolygon); ogrFeature->SetGeometry(ogrMultiPolygon); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ProcessNodeWrite(*it, m_DataSource, ogrCollection, ogrCurrentLayer, oSRS); break; } case FEATURE_COLLECTION: { if (ogrCollection != ITK_NULLPTR) { itkExceptionMacro(<< "Problem while creating collection."); } OGRGeometryCollection* ogrCollectionGeometry = (OGRGeometryCollection*) OGRGeometryFactory::createGeometry( wkbGeometryCollection); OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // ogrFeature->SetField("Name", dataNode->GetNodeId()); ogrFeature->GetDefnRef()->SetGeomType(wkbGeometryCollection); ogrFeature->SetGeometry(ogrCollectionGeometry); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ProcessNodeWrite(*it, m_DataSource, ogrCollection, ogrCurrentLayer, oSRS); break; } } } return kept; } /** * They may be several OGRLayers in this tree node. * Return a vector of OGRLayer **/ std::vector OGRIOHelper ::ConvertDataTreeNodeToOGRLayers(InternalTreeNodeType * source, ogr::version_proxy::GDALDatasetType * inMemoryDataSource, OGRLayer* ogrCurrentLayer, OGRSpatialReference * oSRS) { // Create the in memory datasource if NULL if (inMemoryDataSource == ITK_NULLPTR) { const char * driverName = "Memory"; ogr::version_proxy::GDALDriverType * ogrDriver = ogr::version_proxy::GetDriverByName(driverName); inMemoryDataSource = ogr::version_proxy::Create(ogrDriver,"tempDataSource"); } std::vector ogrLayerVector; //unsigned int kept = 0; bool fieldsAddedToOGRLayer = false; // Get the children list from the input node typedef InternalTreeNodeType::ChildrenListType ChildrenListType; ChildrenListType children = source->GetChildrenList(); // For each child for (ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { DataNodePointerType dataNode = (*it)->Get(); // Get the kwl otb::VectorDataKeywordlist kwl; itk::ExposeMetaData(dataNode->GetMetaDataDictionary(), MetaDataKey::VectorDataKeywordlistKey, kwl); // Create the field once if (ogrCurrentLayer != ITK_NULLPTR && !fieldsAddedToOGRLayer) { // Take into account the fields stored in the // vectordatakeywordlist for (unsigned int fieldIdx = 0; fieldIdx < kwl.GetNumberOfFields(); fieldIdx++) { if ( std::string(kwl.GetNthField(fieldIdx).first->GetNameRef()) != "FID" ) { otbMsgDevMacro(<< " CreateField '" << kwl.GetNthField(fieldIdx).first->GetNameRef() << "'"); if (ogrCurrentLayer->CreateField(kwl.GetNthField(fieldIdx).first) != OGRERR_NONE ) { itkExceptionMacro(<< "Failed to create Field "<GetNameRef()); } } else { otbMsgDevMacro(<< "WARNING: Skipping OGR field 'FID'"); } } fieldsAddedToOGRLayer = true; } switch (dataNode->GetNodeType()) { case ROOT: { break; } case DOCUMENT: { ogrCurrentLayer = inMemoryDataSource->CreateLayer(dataNode->GetNodeId(), oSRS, wkbUnknown, ITK_NULLPTR); if (ogrCurrentLayer == ITK_NULLPTR) { std::cout << "Failed to create layer " << dataNode->GetNodeId() << std::endl; } else { // New OGRLayer, set the flag to false fieldsAddedToOGRLayer = false; } ogrLayerVector.push_back(ogrCurrentLayer); ConvertDataTreeNodeToOGRLayers(*it, inMemoryDataSource, ogrCurrentLayer, oSRS); break; } case FOLDER: { ConvertDataTreeNodeToOGRLayers(*it, inMemoryDataSource, ogrCurrentLayer, oSRS); break; } case FEATURE_POINT: { //Build the ogrObject OGRPoint ogrPoint; ogrPoint.setX(dataNode->GetPoint()[0]); ogrPoint.setY(dataNode->GetPoint()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(dataNode->GetPoint()[2]); } //Save it in the structure OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // Add the fields to the features for (unsigned int i = 0; i < kwl.GetNumberOfFields(); ++i) { // Get the key of the Nth OGRFieldRefn const char * key = kwl.GetNthField(i).first->GetNameRef(); if (std::string(key) != "FID") { // Edit the value of the field and add it to the current feature ogrFeature->SetField(ogrFeature->GetFieldIndex(key) , kwl.GetFieldAsString(key).c_str()); } } ogrFeature->SetGeometry(&ogrPoint); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } OGRFeature::DestroyFeature(ogrFeature); break; } case FEATURE_LINE: { //Build the ogrObject OGRLineString ogrLine; VertexListConstPointerType vertexList = dataNode->GetLine()->GetVertexList(); VertexListType::ConstIterator vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrLine.addPoint(&ogrPoint); ++vIt; } //Save it in the structure OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // Add the fields to the features for (unsigned int i = 0; i < kwl.GetNumberOfFields(); ++i) { // Get the key of the Nth OGRFieldRefn const char * key = kwl.GetNthField(i).first->GetNameRef(); // Edit the value of the field and add it to the current feature ogrFeature->SetField(ogrFeature->GetFieldIndex(key) , kwl.GetFieldAsString(key).c_str()); } ogrFeature->SetGeometry(&ogrLine); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } OGRFeature::DestroyFeature(ogrFeature); break; } case FEATURE_POLYGON: { //Build the ogrObject OGRPolygon * ogrPolygon = (OGRPolygon *) OGRGeometryFactory::createGeometry(wkbPolygon); OGRLinearRing * ogrExternalRing = (OGRLinearRing *) OGRGeometryFactory::createGeometry(wkbLinearRing); VertexListConstPointerType vertexList = dataNode->GetPolygonExteriorRing()->GetVertexList(); VertexListType::ConstIterator vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrExternalRing->addPoint(&ogrPoint); ++vIt; } ogrPolygon->addRing(ogrExternalRing); // Close the polygon ogrPolygon->closeRings(); OGRGeometryFactory::destroyGeometry(ogrExternalRing); // Retrieving internal rings as well for (PolygonListType::Iterator pIt = dataNode->GetPolygonInteriorRings()->Begin(); pIt != dataNode->GetPolygonInteriorRings()->End(); ++pIt) { OGRLinearRing * ogrInternalRing = (OGRLinearRing *) OGRGeometryFactory::createGeometry(wkbLinearRing); vertexList = pIt.Get()->GetVertexList(); vIt = vertexList->Begin(); while (vIt != vertexList->End()) { OGRPoint ogrPoint; ogrPoint.setX(vIt.Value()[0]); ogrPoint.setY(vIt.Value()[1]); if (DataNodeType::Dimension > 2) { ogrPoint.setZ(vIt.Value()[2]); } ogrInternalRing->addPoint(&ogrPoint); ++vIt; } ogrPolygon->addRing(ogrInternalRing); OGRGeometryFactory::destroyGeometry(ogrInternalRing); } OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); // Add the fields to the features for (unsigned int i = 0; i < kwl.GetNumberOfFields(); ++i) { // Get the key of the Nth OGRFieldRefn const char * key = kwl.GetNthField(i).first->GetNameRef(); // Edit the value of the field and add it to the current feature ogrFeature->SetField(ogrFeature->GetFieldIndex(key) , kwl.GetFieldAsString(key).c_str()); } ogrFeature->SetGeometry(ogrPolygon); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } OGRFeature::DestroyFeature(ogrFeature); OGRGeometryFactory::destroyGeometry(ogrPolygon); break; } case FEATURE_MULTIPOINT: { OGRMultiPoint* ogrMultiPoint = (OGRMultiPoint*) OGRGeometryFactory::createGeometry(wkbMultiPoint); OGRFeature * ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); ogrFeature->GetDefnRef()->SetGeomType(wkbMultiPoint); ogrFeature->SetGeometry(ogrMultiPoint); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ConvertDataTreeNodeToOGRLayers(*it, inMemoryDataSource, ogrCurrentLayer, oSRS); break; } case FEATURE_MULTILINE: { // Instantiate a new ogrMultiLineString feature OGRMultiLineString* ogrMultiLineString = (OGRMultiLineString*) OGRGeometryFactory::createGeometry( wkbMultiLineString); OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); ogrFeature->GetDefnRef()->SetGeomType(wkbMultiLineString); ogrFeature->SetGeometry(ogrMultiLineString); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ConvertDataTreeNodeToOGRLayers(*it, inMemoryDataSource, ogrCurrentLayer, oSRS); break; } case FEATURE_MULTIPOLYGON: { // Instantiate a new multipolygon feature OGRMultiPolygon* ogrMultiPolygon = (OGRMultiPolygon*) OGRGeometryFactory::createGeometry(wkbMultiPolygon); OGRFeature * ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); ogrFeature->GetDefnRef()->SetGeomType(wkbMultiPolygon); ogrFeature->SetGeometry(ogrMultiPolygon); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ConvertDataTreeNodeToOGRLayers(*it, inMemoryDataSource, ogrCurrentLayer, oSRS); break; } case FEATURE_COLLECTION: { OGRGeometryCollection* ogrCollectionGeometry = (OGRGeometryCollection*) OGRGeometryFactory::createGeometry( wkbGeometryCollection); OGRFeature *ogrFeature; ogrFeature = OGRFeature::CreateFeature(ogrCurrentLayer->GetLayerDefn()); ogrFeature->GetDefnRef()->SetGeomType(wkbGeometryCollection); ogrFeature->SetGeometry(ogrCollectionGeometry); if (ogrCurrentLayer->CreateFeature(ogrFeature) != OGRERR_NONE) { itkExceptionMacro(<< "Failed to create feature in shapefile."); } ConvertDataTreeNodeToOGRLayers(*it, inMemoryDataSource, ogrCurrentLayer, oSRS); break; } } } return ogrLayerVector; } } // end namespace otb OTB-release-5.8/Modules/IO/IOGDAL/src/otbOGRVectorDataIO.cxx000066400000000000000000000231521301006202600231530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRVectorDataIO.h" #include "ogrsf_frmts.h" #include "otbSystem.h" #include "itksys/SystemTools.hxx" #include "itkByteSwapper.h" #include "otbMacro.h" #include "otbDataNode.h" #include "otbMetaDataKey.h" #include "itkTimeProbe.h" #include "otbOGRIOHelper.h" namespace otb { OGRVectorDataIO ::OGRVectorDataIO() : m_DataSource(ITK_NULLPTR) { // OGR factory registration OGRRegisterAll(); } OGRVectorDataIO::~OGRVectorDataIO() { if (m_DataSource != ITK_NULLPTR) { this->CloseInternalDataSource(); } } bool OGRVectorDataIO::CanReadFile(const char* filename) const { otb::ogr::version_proxy::GDALDatasetType * poDS = ogr::version_proxy::Open(filename, true); if (poDS == ITK_NULLPTR) { std::cerr<<"Can not read file "<GetDriver()->GetName() << std::endl; ogr::version_proxy::Close(poDS); return true; } // Used to print information about this object void OGRVectorDataIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // Read vector data void OGRVectorDataIO ::Read(itk::DataObject* datag) { VectorDataPointerType data = dynamic_cast(datag); // Destroy previous opened data source if(!data) { itkExceptionMacro(<<"Failed to dynamic cast to otb::VectorData (this should never happen)"); } if (m_DataSource != ITK_NULLPTR) { this->CloseInternalDataSource(); } m_DataSource = ogr::version_proxy::Open(this->m_FileName.c_str(),true); if (m_DataSource == ITK_NULLPTR) { itkExceptionMacro(<< "Failed to open data file " << this->m_FileName); } otbMsgDebugMacro(<< "Driver to read: OGR"); otbMsgDebugMacro(<< "Reading file: " << this->m_FileName); // Reading layers otbMsgDevMacro(<< "Number of layers: " << m_DataSource->GetLayerCount()); // Retrieving root node DataTreePointerType tree = data->GetDataTree(); DataNodePointerType root = tree->GetRoot()->Get(); OGRSpatialReference * oSRS = ITK_NULLPTR; //We take the assumption that the spatial reference is common to all layers oSRS = m_DataSource->GetLayer(0)->GetSpatialRef(); if (oSRS != ITK_NULLPTR) { char * projectionRefChar; oSRS->exportToWkt(&projectionRefChar); std::string projectionRef = projectionRefChar; CPLFree(projectionRefChar); itk::MetaDataDictionary& dict = data->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, projectionRef); } else { otbMsgDevMacro(<< "Can't retrieve the OGRSpatialReference from the shapefile"); } std::string projectionRefWkt = data->GetProjectionRef(); bool projectionInformationAvailable = !projectionRefWkt.empty(); if (projectionInformationAvailable) { otbMsgDevMacro(<< "Projection information : " << projectionRefWkt); } else { otbMsgDevMacro(<< "Projection information unavailable: assuming WGS84"); } // For each layer for (int layerIndex = 0; layerIndex < m_DataSource->GetLayerCount(); ++layerIndex) { /** retrieving layer and property */ OGRLayer * layer = m_DataSource->GetLayer(layerIndex); otbMsgDevMacro(<< "Number of features: " << layer->GetFeatureCount()); OGRFeatureDefn * dfn = layer->GetLayerDefn(); /** Create the document node */ DataNodePointerType document = DataNodeType::New(); document->SetNodeType(DOCUMENT); document->SetNodeId(dfn->GetName()); /** Retrieving the fields types */ // OGRFieldDefn * field; // for (int fieldIndex = 0; fieldIndexGetFieldCount(); ++fieldIndex) // { // field = dfn->GetFieldDefn(fieldIndex); // document->SetField(field->GetNameRef(), OGRFieldDefn::GetFieldTypeName(field->GetType())); // // std::cout<<"Document "<GetNodeId()<<": Adding field "<GetNameRef()<<" "<GetType())<Add(document, root); /// This is not good but we do not have the choice if we want to /// get a hook on the internal structure InternalTreeNodeType * documentPtr = const_cast(tree->GetNode(document)); /** IO class helper to convert ogr layer*/ OGRIOHelper::Pointer OGRConversion = OGRIOHelper::New(); OGRConversion->ConvertOGRLayerToDataTreeNode(layer, documentPtr); } // end For each layer this->CloseInternalDataSource(); } void OGRVectorDataIO::CloseInternalDataSource() { assert(m_DataSource != NULL && "m_DataSource cannot be NULL"); ogr::version_proxy::Close(m_DataSource); m_DataSource = ITK_NULLPTR; } bool OGRVectorDataIO::CanWriteFile(const char* filename) const { std::string lFileName(filename); if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } return (this->GetOGRDriverName(filename) != "NOT-FOUND"); } void OGRVectorDataIO::Write(const itk::DataObject* datag, char ** /** unused */) { itk::TimeProbe chrono; chrono.Start(); VectorDataConstPointerType data = dynamic_cast(datag); if(!data) { itkExceptionMacro(<<"Failed to dynamic cast to otb::VectorData (this should never happen)."); } //Find first the OGR driver ogr::version_proxy::GDALDriverType * ogrDriver = ogr::version_proxy::GetDriverByName(this->GetOGRDriverName(this->m_FileName).data()); if (ogrDriver == ITK_NULLPTR) { itkExceptionMacro(<< "No OGR driver found to write file " << this->m_FileName); } // free an existing previous data source, if any if (m_DataSource != ITK_NULLPTR) { ogr::version_proxy::Close(m_DataSource); } // Erase the dataSource if already exist ogr::version_proxy::Delete(this->m_FileName.c_str()); // m_DataSource = OGRSFDriverRegistrar::Open(this->m_FileName.c_str(), TRUE); m_DataSource = ogr::version_proxy::Create(ogrDriver,this->m_FileName.c_str()); // check the created data source if (m_DataSource == ITK_NULLPTR) { itkExceptionMacro( << "Failed to create OGR data source for file " << this->m_FileName << ". Since OGR can not overwrite existing file, be sure that this file does not already exist"); } // Retrieve data required for georeferencing std::string projectionRefWkt = data->GetProjectionRef(); bool projectionInformationAvailable = !projectionRefWkt.empty(); if (projectionInformationAvailable) { otbMsgDevMacro(<< "Projection information : " << projectionRefWkt); } else { otbMsgDevMacro(<< "Projection information unavailable"); } //TODO georeference here from OGRSpatialReference http://www.gdal.org/ogr/classOGRDataSource.html OGRSpatialReference * oSRS = ITK_NULLPTR; if (projectionInformationAvailable) { oSRS = static_cast(OSRNewSpatialReference(projectionRefWkt.c_str())); } // Retrieving root node DataTreeConstPointerType tree = data->GetDataTree(); if (tree->GetRoot() == ITK_NULLPTR) { itkExceptionMacro(<< "Data tree is empty: Root == NULL"); } DataNodePointerType root = tree->GetRoot()->Get(); unsigned int layerKept; OGRLayer * ogrCurrentLayer = ITK_NULLPTR; // OGRFeatureVectorType ogrFeatures; OGRGeometryCollection * ogrCollection = ITK_NULLPTR; // OGRGeometry * ogrCurrentGeometry = NULL; // Get the input tree root InternalTreeNodeType * inputRoot = const_cast(tree->GetRoot()); //Refactoring SHPIO Manuel OGRIOHelper::Pointer IOConversion = OGRIOHelper::New(); layerKept = IOConversion->ProcessNodeWrite(inputRoot, m_DataSource, ogrCollection, ogrCurrentLayer, oSRS); otbMsgDevMacro( << "layerKept " << layerKept ); (void)layerKept; // keep compiler happy otb::ogr::version_proxy::Close(m_DataSource); m_DataSource = ITK_NULLPTR; if (oSRS != ITK_NULLPTR) { OSRRelease(oSRS); } chrono.Stop(); otbMsgDevMacro( << "OGRVectorDataIO: file saved in " << chrono.GetMean() << " seconds. (" << layerKept << " elements)" ); otbMsgDevMacro(<< " OGRVectorDataIO::Write() "); } std::string OGRVectorDataIO::GetOGRDriverName(std::string name) const { std::string extension; std::string driverOGR; std::string upperName; upperName = name; std::transform(name.begin(), name.end(), upperName.begin(), (int (*)(int))toupper); //Test of PostGIS connection string if (upperName.substr(0, 3) == "PG:") { driverOGR = "PostgreSQL"; } else { extension = itksys::SystemTools::GetFilenameLastExtension(upperName); if (extension == ".SHP") driverOGR = "ESRI Shapefile"; else if ((extension == ".TAB")) driverOGR = "MapInfo File"; else if (extension == ".GML") driverOGR = "GML"; else if (extension == ".GPX") driverOGR = "GPX"; else if (extension == ".SQLITE") driverOGR = "SQLite"; else if (extension==".KML") driverOGR="KML"; else if (extension == ".GMT") driverOGR = "OGR_GMT"; else driverOGR = "NOT-FOUND"; } //std::cout << name << " " << driverOGR <<" "<RegisterOverride(classOverride.c_str(), subclass.c_str(), "OGR Vectordata IO", 1, itk::CreateObjectFunction::New()); } OGRVectorDataIOFactory::~OGRVectorDataIOFactory() {} const char* OGRVectorDataIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* OGRVectorDataIOFactory::GetDescription() const { return "OGR VectorDataIO Factory, allows the loading of ogr supported vector data into OTB"; } } // end namespace otb OTB-release-5.8/Modules/IO/IOGDAL/test/000077500000000000000000000000001301006202600172535ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOGDAL/test/CMakeLists.txt000066400000000000000000000223551301006202600220220ustar00rootroot00000000000000otb_module_test() set(OTBIOGDALTests otbIOGDALTestDriver.cxx otbGDALImageIOTest.cxx otbGDALImageIOTestWriteMetadata.cxx otbGDALOverviewsBuilder.cxx otbOGRVectorDataIONew.cxx otbGDALImageIOTestCanWrite.cxx otbOGRVectorDataIOCanWrite.cxx otbGDALReadPxlComplex.cxx otbGDALImageIOTestCanRead.cxx otbMultiDatasetReadingInfo.cxx otbOGRVectorDataIOCanRead.cxx ) add_executable(otbIOGDALTestDriver ${OTBIOGDALTests}) target_link_libraries(otbIOGDALTestDriver ${OTBIOGDAL-Test_LIBRARIES}) otb_module_target_label(otbIOGDALTestDriver) # Tests Declaration otb_add_test(NAME ioTvGDALImageIO_Tiff_JPEG_99 COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${BASELINE}/ioTvGDALImageIO_Tiff_JPEG_99.tif ${TEMP}/ioTvGDALImageIO_Tiff_JPEG_99.tif otbGDALImageIOTest_uint8 ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioTvGDALImageIO_Tiff_JPEG_99.tif "COMPRESS=JPEG" "JPEG_QUALITY=99" "PHOTOMETRIC=YCBCR" "TILED=YES" "BLOCKXSIZE=256" "BLOCKYSIZE=256" ) otb_add_test(NAME ioTvGDALImageIO_JPEG_99 COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${BASELINE}/ioTvGDALImageIO_JPEG_99.jpg ${TEMP}/ioTvGDALImageIO_JPEG_99.jpg otbGDALImageIOTest_uint8 ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioTvGDALImageIO_JPEG_99.jpg "QUALITY=99" ) otb_add_test(NAME ioTvGDALImageIO_Tiff_NoOption COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_NoOption.tif otbGDALImageIOTest_uint16 ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_NoOption.tif ) otb_add_test(NAME ioTvGDALImageIO_Tiff_JPEG_20 COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${BASELINE}/ioTvGDALImageIO_Tiff_JPEG_20.tif ${TEMP}/ioTvGDALImageIO_Tiff_JPEG_20.tif otbGDALImageIOTest_uint8 ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioTvGDALImageIO_Tiff_JPEG_20.tif "COMPRESS=JPEG" "JPEG_QUALITY=20" "PHOTOMETRIC=YCBCR" "TILED=YES" "BLOCKXSIZE=256" "BLOCKYSIZE=256" ) otb_add_test(NAME ioTvGDALImageIO_Tiff_Stripped COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_stripped.tif otbGDALImageIOTest_uint16 ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_stripped.tif "BLOCKYSIZE=10" ) otb_add_test(NAME ioTvGDALImageIO_Tiff_12bits COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_12bits.tif otbGDALImageIOTest_uint16 ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_12bits.tif "NBITS=12" ) otb_add_test(NAME ioTvGDALImageIO_Tiff_Tiled_16x16 COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_tiled_16x16.tif otbGDALImageIOTest_uint16 ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvGDALImageIO_Tiff_tiled_16x16.tif "TILED=YES" "BLOCKXSIZE=16" "BLOCKYSIZE=16" ) otb_add_test(NAME ioTvGDALImageIO_JPEG_20 COMMAND otbIOGDALTestDriver --compare-image ${NOTOL} ${BASELINE}/ioTvGDALImageIO_JPEG_20.jpg ${TEMP}/ioTvGDALImageIO_JPEG_20.jpg otbGDALImageIOTest_uint8 ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioTvGDALImageIO_JPEG_20.jpg "QUALITY=20" ) otb_add_test(NAME ioTvGDALImageIOWriteMetadata COMMAND otbIOGDALTestDriver otbGDALImageIOTestWriteMetadata ${TEMP}/ioTvGDALImageIOWriteMetadata.tif ${TEMP}/ioTvGDALImageIOWriteMetadata.hdr ${TEMP}/ioTvGDALImageIOWriteMetadata_Report.txt ) otb_add_test(NAME ioTuGDALOverviewsBuilder COMMAND otbIOGDALTestDriver otbGDALOverviewsBuilderNew) otb_add_test(NAME ioTvGDALOverviewsBuilder_TIFF COMMAND otbIOGDALTestDriver otbGDALOverviewsBuilder ${TEMP}/ioTvGDALImageIO_Tiff_NoOption.tif 4 ) set_property(TEST ioTvGDALOverviewsBuilder_TIFF PROPERTY DEPENDS ioTvGDALImageIO_Tiff_NoOption) otb_add_test(NAME ioTuOGRVectorDataIO COMMAND otbIOGDALTestDriver otbOGRVectorDataIONew ) otb_add_test(NAME ioTuGDALImageIOCanWrite_HFA COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanWrite ${INPUTDATA}/HFAGeoreferenced.img) otb_add_test(NAME ioTuGDALImageIOCanWrite_TIFF COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanWrite ${INPUTDATA}/testGDALWriter.tif) otb_add_test(NAME ioTuOGRVectorDataIOCanWriteMapInfo COMMAND otbIOGDALTestDriver otbOGRVectorDataIOCanWrite ${INPUTDATA}/LOCALITY_POLYGON.tab) otb_add_test(NAME ioTuOGRVectorDataIOCanWriteGML COMMAND otbIOGDALTestDriver otbOGRVectorDataIOCanWrite ${INPUTDATA}/addressPoint.gml) otb_add_test(NAME ioTuGDALImageIOCanRead_IKONOS_RED COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{IKONOS/PARIS/po_79039_red_0000000.tif}) otb_add_test(NAME ioTuGDALImageIOCanRead_SPOT4 COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{SPOT4/RIO_DE_JANEIRO/IMAG_01.DAT} ) otb_add_test(NAME ioTuGDALImageIOCanRead_WV2_MUL COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL/09DEC10103019-M2AS-052298844010_01_P001.TIF} ) otb_add_test(NAME ioTuGDALImageIOCanRead_WV2_PAN COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} ) otb_add_test(NAME ioTuGDALImageIOCanRead_ENVI COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead ${INPUTDATA}/poupees_1canal.c1 ) otb_add_test(NAME ioTuGDALImageIOCanRead_IKONOS_GRN COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{IKONOS/PARIS/po_79039_grn_0000000.tif}) otb_add_test(NAME ioTuGDALImageIOCanRead_IKONOS_BLU COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{IKONOS/PARIS/po_79039_blu_0000000.tif}) otb_add_test(NAME ioTuGDALImageIOCanRead_QUICK_PAN COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ) otb_add_test(NAME ioTuGDALImageIOCanRead_HFA COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead ${INPUTDATA}/HFAGeoreferenced.img) otb_add_test(NAME ioTuGDALImageIOCanRead_SPOT5TIF COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead ${INPUTDATA}/poupeesTIF/IMAGERY.TIF ) otb_add_test(NAME ioTuGDALImageIOCanRead_PCI COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead ${INPUTDATA}/QB_Toulouse_Ortho_PAN.pix) if (GDAL_HAS_HDF5) otb_add_test(NAME ioTuGDALImageIOCanRead_COSMOSKYMED2 COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{COSMOSKYMED/Toulouse_spotlight/CSKS3_SCS_B_S2_08_HH_RD_SF_20110418180325_20110418180332.h5}) otb_add_test(NAME ioTuGDALImageIOCanRead_COSMOSKYMED3 COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{COSMOSKYMED/Toulouse_spotlight/CSKS2_GTC_B_S2_08_HH_RD_SF_20110417180326_20110417180333.h5}) otb_add_test(NAME ioTuGDALImageIOCanRead_COSMOSKYMED COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{COSMOSKYMED/Toulouse_spotlight/CSKS3_GTC_B_S2_08_HH_RD_SF_20110418180325_20110418180332.h5}) endif() otb_add_test(NAME ioTuGDALImageIOCanRead_WV2_PSH COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_pansharpened_natural_color_8bit/052298834010_01_P001_PSH/09DEC10103019-S2AS-052298834010_01_P001.TIF} ) otb_add_test(NAME ioTuGDALImageIOCanRead_SAR_ERS2 COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{SAR_ERS2_SLCI_SCENE1/DAT_01.001} ) otb_add_test(NAME ioTuGDALImageIOCanRead_QUICK_XS COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ) otb_add_test(NAME ioTuGDALImageIOCanRead_IKONOS_NIR COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{IKONOS/PARIS/po_79039_nir_0000000.tif}) otb_add_test(NAME ioTuGDALImageIOCanRead_PDS COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead ${INPUTDATA}/pdsImage.img ) otb_add_test(NAME ioTuGDALImageIOCanRead_RADARSAT COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{RADARSAT1/GOMA/SCENE01/DAT_01.001} ) otb_add_test(NAME ioTuGDALImageIOCanRead_IKONOS_PAN COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{IKONOS/PARIS/po_79039_pan_0000000.tif}) otb_add_test(NAME ioTuGDALImageIOCanRead_FORMOSAT2 COMMAND otbIOGDALTestDriver otbGDALImageIOTestCanRead LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF}) if(GDAL_HAS_HDF4) otb_add_test(NAME ioTvMultiDatasetReadingInfo COMMAND otbIOGDALTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiDatasetReadingInfo.txt ${TEMP}/ioTvMultiDatasetReadingInfoOut.txt otbMultiDatasetReadingInfo ${INPUTDATA}/MOD09Q1G_EVI.A2006233.h07v03.005.2008338190308.hdf ${TEMP}/ioTvMultiDatasetReadingInfoOut.txt ) endif() otb_add_test(NAME ioTuOGRVectorDataIOTestCanReadGML COMMAND otbIOGDALTestDriver otbOGRVectorDataIOTestCanRead ${INPUTDATA}/addressPoint.gml) otb_add_test(NAME ioTuOGRVectorDataIOTestCanReadMapInfo COMMAND otbIOGDALTestDriver otbOGRVectorDataIOTestCanRead ${INPUTDATA}/LOCALITY_POLYGON.tab) # Tests with GDAL only to read complex data set(INPUTFILE_PIXELTYPES_LIST "Float" "Double") foreach(INPUTFILE_PIXELTYPE ${INPUTFILE_PIXELTYPES_LIST}) otb_add_test(NAME ioTvGDALReadPxlComplex${INPUTFILE_PIXELTYPE} COMMAND otbIOGDALTestDriver otbGDALReadPxlComplex${INPUTFILE_PIXELTYPE} ${INPUTDATA}/multibandComplex${INPUTFILE_PIXELTYPE}_3bands.tif 1 5 10 2) #old file hdr sans extensions endforeach() OTB-release-5.8/Modules/IO/IOGDAL/test/otbGDALImageIOTest.cxx000066400000000000000000000042711301006202600232520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbGDALImageIO.h" template int otbGenericGDALImageIOTest(int argc, char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; std::vector creationOptions; for (int curArg = 3; curArg < argc; curArg++) { creationOptions.push_back(argv[curArg]); std::cout << "Creation option : " << argv[curArg] << std::endl; } typedef PixelType InputPixelType; typedef PixelType OutputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); // Be sure to use GDALImageIO otb::GDALImageIO::Pointer io = otb::GDALImageIO::New(); io->SetOptions(creationOptions); writer->SetImageIO(io.GetPointer()); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbGDALImageIOTest_uint8(int argc, char* argv[]) { return otbGenericGDALImageIOTest(argc, argv); } int otbGDALImageIOTest_uint16(int argc, char* argv[]) { return otbGenericGDALImageIOTest(argc, argv); } OTB-release-5.8/Modules/IO/IOGDAL/test/otbGDALImageIOTestCanRead.cxx000066400000000000000000000020101301006202600244550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGDALImageIO.h" #include "itkMacro.h" #include int otbGDALImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::GDALImageIO::Pointer lGDALImageIO = otb::GDALImageIO::New(); bool lCanRead = lGDALImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Error otb::GDALImageIO : impossible to open the dataset: " << argv[1] << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOGDAL/test/otbGDALImageIOTestCanWrite.cxx000066400000000000000000000020201301006202600246750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGDALImageIO.h" #include "itkMacro.h" #include int otbGDALImageIOTestCanWrite(int itkNotUsed(argc), char* argv[]) { otb::GDALImageIO::Pointer lGDALImageIO = otb::GDALImageIO::New(); bool lCanWrite = lGDALImageIO->CanWriteFile(argv[1]); if (lCanWrite == false) { std::cerr << "Erreur otb::GDALImageIO : impossible d'ecrire l'image " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOGDAL/test/otbGDALImageIOTestWriteMetadata.cxx000066400000000000000000000447761301006202600257440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "gdal_priv.h" #include "cpl_string.h" #include "ogr_spatialref.h" #include "itkMacro.h" // Class to store ProjRef, GEOTransform and GCP info class DatasetInfoGDAL { public: std::string m_Name; std::string m_FileType; std::string m_ProjRef; CPLErr m_GeoTransfo; double m_GeoTransfoParam[6]; std::string m_GCPProjRef; int m_GCPCount; std::vector m_GCPs; DatasetInfoGDAL(){ this->Clear(); }; void Clear() { m_Name.clear(); m_FileType.clear(); m_ProjRef.clear(); m_GeoTransfo = CE_None; m_GeoTransfoParam[0] = 0; m_GeoTransfoParam[1] = 0; m_GeoTransfoParam[2] = 0; m_GeoTransfoParam[3] = 0; m_GeoTransfoParam[4] = 0; m_GeoTransfoParam[5] = 0; m_GCPProjRef.clear(); m_GCPCount = 0; m_GCPs.clear(); }; void addGCP(const GDAL_GCP* psGCP) { GDAL_GCP GCP; std::string strID = std::string(psGCP->pszId); GCP.pszId = new char [strID.size()+1]; strcpy (GCP.pszId, strID.c_str()); std::string strInfo = std::string(psGCP->pszInfo); GCP.pszInfo = new char [strInfo.size()+1]; strcpy (GCP.pszInfo, strInfo.c_str()); GCP.dfGCPLine = psGCP->dfGCPLine; GCP.dfGCPPixel = psGCP->dfGCPPixel; GCP.dfGCPX = psGCP->dfGCPX; GCP.dfGCPY = psGCP->dfGCPY; GCP.dfGCPZ = psGCP->dfGCPZ; m_GCPs.push_back(GCP); }; ~DatasetInfoGDAL(){ }; void Print(std::ostream& os) const { os << "------" << std::endl; os << "Name: " << m_Name << std::endl; os << "File type: " << m_FileType << std::endl; os << "Projection Ref: " << this->m_ProjRef <m_GeoTransfo == CE_None) { os << "GeoTransform: " << this->m_GeoTransfoParam[0] << ", " << this->m_GeoTransfoParam[1] << ", " << this->m_GeoTransfoParam[2] << ", " << this->m_GeoTransfoParam[3] << ", " << this->m_GeoTransfoParam[4] << ", " << this->m_GeoTransfoParam[5] << std::endl; } else { os << "No Geo Transform" << std::endl; } os << "GCP Projection Ref: " << this->m_GCPProjRef <m_GCPCount << std::endl; /* for (int it = 0; itm_GCPCount; ++it) { os << " GCP Id = " << this->m_GCPs[it].pszId << std::endl; os << " GCP Info = " << this->m_GCPs[it].pszInfo << std::endl; os << " GCP (Row, Col) = (" << this->m_GCPs[it].dfGCPPixel << "," << this->m_GCPs[it].dfGCPLine << ")" << std::endl; os << " GCP (X, Y, Z) = (" << this->m_GCPs[it].dfGCPX << "," << this->m_GCPs[it].dfGCPY << "," << this->m_GCPs[it].dfGCPZ << ")" << std::endl; }*/ }; }; bool writeReadDatasetMetadata(std::string filename, std::vector options, DatasetInfoGDAL *infoDatasetCreate, DatasetInfoGDAL *infoDatasetWR); int compareDatasetInfoGDAL(DatasetInfoGDAL *create, DatasetInfoGDAL *WR, std::ostream& os); void testWriteMetadata(std::string filenameTIFF, std::string filenameHDR, std::vector options, std::ostream& os); /////// // MAIN int otbGDALImageIOTestWriteMetadata(int itkNotUsed(argc), char * argv[]) { // Parameters std::string filenameTIFF = argv[1]; std::string filenameHDR = argv[2]; std::string filenameReport = argv[3]; // Object where store options about setProjRef, setGeoTransfo, setGCPs std::vector options; // Open file where save test result std::ofstream file; file.open(filenameReport.c_str()); // None testWriteMetadata(filenameTIFF, filenameHDR, options, file); // NoProjRef, NoGCP, GeoTransfo_ID options.push_back("-setGeoTransform_ID"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // NoProjRef, GCP, GeoTransfo_ID options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // NoProjRef, NoGCP, GeoTransfo options.clear(); options.push_back("-setGeoTransform"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // NoProjRef, GCP, GeoTransfo options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // NoProjRef, GCP, No GeoTransfo options.clear(); options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); file << "==================================================" << std::endl; ////////// // ProjRef, NoGCP, No GeoTransfo_ID options.clear(); options.push_back("-setProjectionRef"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRef, NoGCP, GeoTransfo_ID options.push_back("-setGeoTransform_ID"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRef, GCP, GeoTransfo_ID options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRef, NoGCP, GeoTransfo options.clear(); options.push_back("-setProjectionRef"); options.push_back("-setGeoTransform"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRef, GCP, GeoTransfo options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRef, GCP, No GeoTransfo options.clear(); options.push_back("-setProjectionRef"); options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); file << "==================================================" << std::endl; ////////// // ProjRefUTM, NoGCP, No GeoTransfo_ID options.clear(); options.push_back("-setProjectionRef_UTM"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRefUTM, NoGCP, GeoTransfo_ID options.push_back("-setGeoTransform_ID"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRefUTM, GCP, GeoTransfo_ID options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRefUTM, NoGCP, GeoTransfo options.clear(); options.push_back("-setProjectionRef_UTM"); options.push_back("-setGeoTransform"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRefUTM, GCP, GeoTransfo options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); // ProjRefUTM, GCP, No GeoTransfo options.clear(); options.push_back("-setProjectionRef_UTM"); options.push_back("-setGCP"); testWriteMetadata(filenameTIFF, filenameHDR, options, file); file.close(); return EXIT_SUCCESS; } int compareDatasetInfoGDAL(DatasetInfoGDAL *create, DatasetInfoGDAL *WR, std::ostream& os) { os << "*****COMPARE*****" << std::endl; int outputCode = 0; // Compare file type if (create->m_FileType.compare(WR->m_FileType) != 0) { os << "not the same filetype" <m_ProjRef.compare(WR->m_ProjRef) != 0) { os << "not the same ProjRef" << std::endl; outputCode = 1; } else if (create->m_ProjRef.empty() && WR->m_ProjRef.empty() ) { os << "Same ProjRef (No ProjRef)" <m_GeoTransfo == 0 ) && ( WR->m_GeoTransfo == 0) ) { if ( (create->m_GeoTransfoParam[0] == WR->m_GeoTransfoParam[0]) && (create->m_GeoTransfoParam[1] == WR->m_GeoTransfoParam[1]) && (create->m_GeoTransfoParam[2] == WR->m_GeoTransfoParam[2]) && (create->m_GeoTransfoParam[3] == WR->m_GeoTransfoParam[3]) && (create->m_GeoTransfoParam[4] == WR->m_GeoTransfoParam[4]) && ( (create->m_GeoTransfoParam[5] == WR->m_GeoTransfoParam[5]) || (create->m_GeoTransfoParam[5] == -WR->m_GeoTransfoParam[5]) ) ) { os << "Same GeoTransform" <m_GeoTransfo > 0 ) && ( WR->m_GeoTransfo > 0) ) { os << "Same GeoTransform (No GeoTransform)" <m_GeoTransfoParam[0] == 0) && (create->m_GeoTransfoParam[1] == 1) && (create->m_GeoTransfoParam[2] == 0) && (create->m_GeoTransfoParam[3] == 0) && (create->m_GeoTransfoParam[4] == 0) && (create->m_GeoTransfoParam[5] == 1) && WR->m_GeoTransfo > 0 ) { os << "Try to write a GeoTransfo = ID but the field is empty after write/read operation => \n" << "\t OTB consider this case as GeoTransfo = ID so not a problem" <m_GeoTransfoParam[0] == 0) && (WR->m_GeoTransfoParam[1] == 1) && (WR->m_GeoTransfoParam[2] == 0) && (WR->m_GeoTransfoParam[3] == 0) && (WR->m_GeoTransfoParam[4] == 0) && (WR->m_GeoTransfoParam[5] == -1) && create->m_GeoTransfo > 0 ) { os << "Try to write a No GeoTransfo but the field is set to ID empty after write/read operation => \n" << "\t we can consider this case as not a problem" <m_GCPProjRef.compare(WR->m_GCPProjRef) == 0) { os << "Same GCP ProjRef" << std::endl; } else { os << "Not the same GCP ProjRef" << std::endl; outputCode = 1000 + outputCode; } if (create->m_GCPCount == WR->m_GCPCount) { os << "Same GCP count" << std::endl; } else { os << "Not the same GCP count" << std::endl; outputCode = 10000 + outputCode; } return outputCode; } void testWriteMetadata(std::string filenameTIFF, std::string filenameHDR, std::vector options, std::ostream& os) { DatasetInfoGDAL* infoDatasetCreate_TIFF = new DatasetInfoGDAL(); DatasetInfoGDAL* infoDatasetWR_TIFF = new DatasetInfoGDAL(); DatasetInfoGDAL* infoDatasetCreate_HDR = new DatasetInfoGDAL(); DatasetInfoGDAL* infoDatasetWR_HDR = new DatasetInfoGDAL(); os << "\n+++++++++++++++++++++++++++" << std::endl; if (options.size() == 0) { os << "None" << std::endl; filenameTIFF.insert(filenameTIFF.size()-4,"-None"); filenameHDR.insert(filenameHDR.size()-4,"-None"); } else { for(size_t it = 0; it < options.size(); it ++) { os << options[it] << std::endl; filenameTIFF.insert(filenameTIFF.size()-4, options[it]); filenameHDR.insert(filenameHDR.size()-4, options[it]); } } os << "\nFormat: TIFF" < 0 ) { os << "output code: " << msg << std::endl; infoDatasetCreate_TIFF->Print(os); infoDatasetWR_TIFF->Print(os); } else { os << "=> No Diff" < 0 ) { os << "output code: " << msg << std::endl; infoDatasetCreate_HDR->Print(os); infoDatasetWR_HDR->Print(os); } else { os << "=> No Diff" < options, DatasetInfoGDAL *infoDatasetCreate, DatasetInfoGDAL *infoDatasetWR) { infoDatasetCreate->Clear(); infoDatasetWR->Clear(); // Detect format with the extension const char *pszFormat; if ( filename.compare(filename.size()-4, 4,".tif") == 0 ) { pszFormat = "GTiff"; infoDatasetCreate->m_FileType = "TIFF"; infoDatasetWR->m_FileType = "TIFF"; } else if (filename.compare(filename.size()-4, 4,".hdr") == 0 ) { pszFormat = "ENVI"; infoDatasetCreate->m_FileType = "HDR"; infoDatasetWR->m_FileType = "HDR"; filename.erase(filename.size()-4, 4); } else { std::cout << "Format not supported" <GetDriverByName(pszFormat); if( poDriver == ITK_NULLPTR ) { std::cout << "impossible to get the driver" <GetMetadata(); if( CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATE, FALSE ) ) { //std::cout << "Driver " << pszFormat << " supports Create() method." << std::endl; } else { std::cout << "Driver " << pszFormat << " does not support Create() method." << std::endl; return EXIT_FAILURE; } GDALDataset *poDstDS; char **papszOptions = ITK_NULLPTR; // Create dataset poDstDS = poDriver->Create( filename.c_str(), 128, 128, 1, GDT_Byte, papszOptions ); OGRSpatialReference oSRS_GCP; char *pszSRS_WKT_GCP = ITK_NULLPTR; oSRS_GCP.SetWellKnownGeogCS( "WGS84" ); oSRS_GCP.exportToWkt( &pszSRS_WKT_GCP ); // Set GCP if (setGCP) { unsigned int gcpCount = 1; GDAL_GCP * gdalGcps = new GDAL_GCP[gcpCount]; std::ostringstream strIndexGCP; strIndexGCP << 1; std::string sstrIndexGCP = strIndexGCP.str(); gdalGcps[0].pszId = new char[sstrIndexGCP.length()+1]; strcpy(gdalGcps[0].pszId,sstrIndexGCP.c_str()); gdalGcps[0].pszInfo = const_cast("GCP test"); gdalGcps[0].dfGCPPixel = 0.5; gdalGcps[0].dfGCPLine = 0.5; gdalGcps[0].dfGCPX = 1.35409622400109; gdalGcps[0].dfGCPY = 43.6544262050905; gdalGcps[0].dfGCPZ = 0; poDstDS->SetGCPs(gcpCount, gdalGcps, pszSRS_WKT_GCP); delete [] gdalGcps[0].pszId; delete[] gdalGcps; /*infoDatasetCreate->m_GCPProjRef = static_cast( pszSRS_WKT); infoDatasetCreate->m_GCPCount = gcpCount; */ } // Set ProjectionRef OGRSpatialReference oSRS_ProjRef; char *pszSRS_WKT_ProjRef = ITK_NULLPTR; if (setProjectionRef || setProjectionRef_UTM) { oSRS_ProjRef.SetWellKnownGeogCS( "WGS84" ); if (setProjectionRef_UTM) { oSRS_ProjRef.SetUTM( 31, TRUE ); } oSRS_ProjRef.exportToWkt( &pszSRS_WKT_ProjRef ); poDstDS->SetProjection( pszSRS_WKT_ProjRef ); } // Set GeoTransform if (setGeoTransform_ID || setGeoTransform) { double adfGeoTransform[6] = { 0, 1, 0, 0, 0, 1 }; if (setGeoTransform) { adfGeoTransform[0] = 64; adfGeoTransform[3] = 32; } poDstDS->SetGeoTransform( adfGeoTransform ); /*infoDatasetCreate->m_GeoTransfo = CE_None; infoDatasetCreate->m_GeoTransfoParam[0] = adfGeoTransform[0]; infoDatasetCreate->m_GeoTransfoParam[1] = adfGeoTransform[1]; infoDatasetCreate->m_GeoTransfoParam[3] = adfGeoTransform[3]; infoDatasetCreate->m_GeoTransfoParam[5] = adfGeoTransform[5]; */ } // Write data into dataset GDALRasterBand *poBand; GByte abyRaster[128*128]; for (unsigned int it=0; it < 128*128; ++it) { abyRaster[it] = 0; } poBand = poDstDS->GetRasterBand(1); const OGRErr errRasterIO = poBand->RasterIO( GF_Write, 0, 0, 128, 128, abyRaster, 128, 128, GDT_Byte, 0, 0 ); if (errRasterIO != OGRERR_NONE) { std::cerr << "Unable to write image data." << std::endl; return false; } // Get some information from dataset infoDatasetCreate->m_Name = "Create"; infoDatasetCreate->m_ProjRef = static_cast(poDstDS->GetProjectionRef()); infoDatasetCreate->m_GeoTransfo = poDstDS->GetGeoTransform(infoDatasetCreate->m_GeoTransfoParam); infoDatasetCreate->m_GCPProjRef = static_cast( poDstDS->GetGCPProjection()); infoDatasetCreate->m_GCPCount = poDstDS->GetGCPCount(); for (unsigned int gcpIndex = 0; gcpIndex < (unsigned int) poDstDS->GetGCPCount(); gcpIndex++) { const GDAL_GCP *psGCP; psGCP = poDstDS->GetGCPs() + gcpIndex; infoDatasetCreate->addGCP(psGCP); } // Once we're done, close properly the dataset GDALClose( (GDALDatasetH) poDstDS ); CPLFree( pszSRS_WKT_GCP ); CPLFree( pszSRS_WKT_ProjRef ); //************** // Open File GDALDataset *poDataset; poDataset = (GDALDataset *) GDALOpen( filename.c_str(), GA_ReadOnly ); if( poDataset == ITK_NULLPTR ) return false; // Get some information from file infoDatasetWR->m_Name = "WR"; infoDatasetWR->m_ProjRef = static_cast(poDataset->GetProjectionRef()); infoDatasetWR->m_GeoTransfo = poDataset->GetGeoTransform(infoDatasetWR->m_GeoTransfoParam); infoDatasetWR->m_GCPProjRef = static_cast( poDataset->GetGCPProjection()); infoDatasetWR->m_GCPCount = poDataset->GetGCPCount(); for (unsigned int gcpIndex = 0; gcpIndex < (unsigned int)poDataset->GetGCPCount(); gcpIndex++) { infoDatasetWR->addGCP( poDataset->GetGCPs() + gcpIndex); } GDALClose(poDataset); return true; } OTB-release-5.8/Modules/IO/IOGDAL/test/otbGDALOverviewsBuilder.cxx000066400000000000000000000041711301006202600244370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGDALDriverManagerWrapper.h" #include "otbGDALImageIO.h" #include "otbStandardOneLineFilterWatcher.h" using namespace otb; int otbGDALOverviewsBuilderNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::GDALOverviewsBuilder GDALOverviewsBuilderType; GDALOverviewsBuilderType::Pointer object = GDALOverviewsBuilderType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } int otbGDALOverviewsBuilder(int itkNotUsed(argc), char* argv[]) { const char * inputFilename = argv[1]; int nbResolution = atoi(argv[2]); std::string filename(inputFilename); typedef otb::GDALOverviewsBuilder FilterType; FilterType::Pointer filter = FilterType::New(); otb::GDALResamplingType resamp = GDAL_RESAMPLING_AVERAGE; filter->SetInputFileName(filename); filter->SetNbResolutions(nbResolution); filter->SetResamplingMethod(resamp); { StandardOneLineFilterWatcher watcher(filter,"Overviews creation"); filter->Update(); } otb::GDALImageIO::Pointer io = otb::GDALImageIO::New(); io->SetFileName(inputFilename); bool canRead = io->CanReadFile(inputFilename); if(!canRead) { std::cerr<<"Failed to read file "<< inputFilename <<" with GdalImageIO."<ReadImageInformation(); //std::cout << io->GetOverviewsCount() << std::endl; if (io->GetOverviewsCount() != static_cast(nbResolution) ) { std::cout << "Got "<GetOverviewsCount()<< " overviews, expected "<< nbResolution << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOGDAL/test/otbGDALReadPxlComplex.cxx000066400000000000000000000154261301006202600240330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "gdal_priv.h" #include "ogr_core.h" #include #include #include "itkMacro.h" // Do all comparison in double precision const double Epsilon = 1.E-6; template bool IsEqual(TPixel output, TPixel expected) { // avoid division by zero return ( (expected == output) || (abs(expected - output) / abs(expected) < Epsilon) ); } template int otbGDALReadPxlComplexGeneric(int argc, char * argv[]) { typedef std::complex ComplexType; // Get Input parameters if (argc != 6) { std::cout << "Invalid Parameters: " << argv[0] << " " << std::endl; return EXIT_FAILURE; } int posX = (int)atoi(argv[2]); int posY = (int)atoi(argv[3]); int sizeX = (int)atoi(argv[4]); int sizeY = (int)atoi(argv[5]); int nbPixelToRead = (sizeX)*(sizeY); // Open File GDALDataset *poDataset; GDALAllRegister(); poDataset = (GDALDataset *) GDALOpen( argv[1], GA_ReadOnly ); if( poDataset == ITK_NULLPTR ) return EXIT_FAILURE; // Get some information from file int nbBand = poDataset->GetRasterCount(); GDALDataType pxlTypeInFile = poDataset->GetRasterBand(1)->GetRasterDataType(); int bytePerPixel = sizeof(ComplexType); unsigned int sizeImgX = poDataset->GetRasterXSize(); unsigned int sizeImgY = poDataset->GetRasterYSize(); std::cout << "Dimensions of image are " << sizeImgX << ", "<< sizeImgY << ", "<< nbBand << std::endl; std::cout << "Type GDAL = " << GDALGetDataTypeName(poDataset->GetRasterBand(1)->GetRasterDataType()) << std::endl; //******************* // Method 1 : use RasterIO directly with the dataset std::cout << "**** METHOD 1 : Use RasterIO to read all selected data in file ****" << std::endl; std::streamoff nbBytes = static_cast(nbBand) * static_cast(nbPixelToRead) * static_cast(bytePerPixel); std::cout << "nbBytes of the buffer = " << nbBytes << " = " \ << nbBand << " x " << nbPixelToRead << " x " << bytePerPixel<< std::endl; char * loadBuffer = new char[static_cast(nbBytes)]; int pixelOffset = bytePerPixel * nbBand; int lineOffset = bytePerPixel * nbBand * sizeX; int bandOffset = bytePerPixel; CPLErr lCrGdal = poDataset->RasterIO(GF_Read, posX, posY, sizeX, sizeY, loadBuffer, // pData sizeX, sizeY, pxlTypeInFile, nbBand, ITK_NULLPTR, pixelOffset, lineOffset, bandOffset); // Check if gdal call succeed if (lCrGdal == CE_Failure) { std::cout << "Error while reading image buffer" << std::endl; } ComplexType *pxlValue = new ComplexType[nbPixelToRead * nbBand]; unsigned int count = 0; ComplexType expectedValue; for (unsigned int itPxl = 0; itPxl < (unsigned int) (nbPixelToRead * nbBand); itPxl++) { int indY = (int) ( (int)itPxl / ( sizeX * nbBand) ); int indX = (int) ( (int)itPxl / nbBand ) - indY*sizeX; int indB = (int)itPxl - (int)((int) (itPxl) / nbBand) * nbBand; count = 2*( sizeImgX*sizeImgY*indB + sizeImgX*(posY + indY) + (posX + indX)); pxlValue[itPxl] = *(static_cast( static_cast(loadBuffer)) + itPxl ); expectedValue = ComplexType(static_cast(count), static_cast(count+1)); std::cout << "loadBuffer["<< itPxl << "] or " \ << "pxlValue[" << posX + indX << "," << posY + indY << "," << indB << "]" \ << "= " << pxlValue[itPxl] \ << " -> expectedValue = " << expectedValue \ << std::endl; if (!IsEqual(pxlValue[itPxl], expectedValue)) { std::cerr << "ERROR at position " << "[" << posX + indX << "," << posY + indY << "," << indB << "]" \ << ". Got " << pxlValue[itPxl] << ", expected " << expectedValue << std::endl; return EXIT_FAILURE; } } delete [] loadBuffer; delete [] pxlValue; //******************* // Method 2 : Use RasterIO to read each band included in the file std::cout << "**** METHOD 2 : Use RasterIO to read each band included in the file****" << std::endl; GDALRasterBand *poBand; //ComplexType pPixelValue[nbBand][nbPixelToRead]; ComplexType* pPixelValue = new ComplexType[nbBand*nbPixelToRead]; for (unsigned int itBand = 0; itBand < (unsigned int) nbBand; itBand++) { poBand = poDataset->GetRasterBand( itBand +1 ); OGRErr errRasterIO = poBand->RasterIO( GF_Read, posX, posY, sizeX, sizeY, &(pPixelValue[itBand*nbPixelToRead]), sizeX, sizeY, poBand->GetRasterDataType(), 0, 0 ); if (errRasterIO != OGRERR_NONE) { std::cerr << "Unable to read image data." << std::endl; return EXIT_FAILURE; } for (unsigned int itPxl = 0; itPxl < (unsigned int) nbPixelToRead; itPxl++) { int indY = (int) ((int)itPxl/sizeX); int indX = itPxl - indY * sizeX; count = 2*( sizeImgX*sizeImgY*itBand + sizeImgX*(posY + indY) + (posX + indX)); expectedValue = ComplexType(static_cast(count), static_cast(count+1)); std::cout << "pixelValue [" << posX + indX << "," << posY + indY << "," << itBand << "] = " \ << pPixelValue[itBand*nbPixelToRead + indX + indY * sizeX] \ << " -> expectedValue = " << expectedValue \ << std::endl; if (!IsEqual(pPixelValue[itBand*nbPixelToRead + indX + indY * sizeX], expectedValue)) { std::cerr << "ERROR at position " << "[" << posX + indX << "," << posY + indY << "," << itBand << "]" \ << ". Got " << pPixelValue[itBand*nbPixelToRead + indX + indY * sizeX] << ", expected " << expectedValue << std::endl; return EXIT_FAILURE; } } } delete [] pPixelValue; GDALClose(poDataset); return EXIT_SUCCESS; } int otbGDALReadPxlComplexFloat(int argc, char * argv[]) { return otbGDALReadPxlComplexGeneric(argc, argv); } int otbGDALReadPxlComplexDouble(int argc, char * argv[]) { return otbGDALReadPxlComplexGeneric(argc, argv); } OTB-release-5.8/Modules/IO/IOGDAL/test/otbIOGDALTestDriver.cxx000066400000000000000000000011701301006202600234560ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbGDALImageIOTest_uint8); REGISTER_TEST(otbGDALImageIOTest_uint16); REGISTER_TEST(otbGDALImageIOTestWriteMetadata); REGISTER_TEST(otbGDALOverviewsBuilderNew); REGISTER_TEST(otbGDALOverviewsBuilder); REGISTER_TEST(otbOGRVectorDataIONew); REGISTER_TEST(otbGDALImageIOTestCanWrite); REGISTER_TEST(otbOGRVectorDataIOCanWrite); REGISTER_TEST(otbGDALReadPxlComplexFloat); REGISTER_TEST(otbGDALReadPxlComplexDouble); REGISTER_TEST(otbGDALImageIOTestCanRead); REGISTER_TEST(otbMultiDatasetReadingInfo); REGISTER_TEST(otbOGRVectorDataIOTestCanRead); } OTB-release-5.8/Modules/IO/IOGDAL/test/otbMultiDatasetReadingInfo.cxx000066400000000000000000000050221301006202600252110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "itksys/SystemTools.hxx" #include "otbGDALImageIO.h" int otbMultiDatasetReadingInfo(int argc, char* argv[]) { if (argc != 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputAsciiFilename = argv[2]; otb::GDALImageIO::Pointer readerGDAL = otb::GDALImageIO::New(); readerGDAL->SetFileName(inputFilename); if (readerGDAL->CanReadFile(inputFilename)) std::cout << "can read file OK" << std::endl; else { std::cout << "can read file K0" << std::endl; return EXIT_FAILURE; } std::vector names; std::vector desc; bool readingSubDatasetInfo = readerGDAL->GetSubDatasetInfo(names, desc); if (readingSubDatasetInfo == false ) return EXIT_FAILURE; // Parse all the names to delete the path of the filename for( unsigned int itSubDataset = 0; itSubDataset < (unsigned int)names.size(); itSubDataset++ ) { std::size_t posDeb = names[itSubDataset].find(":\""); if (posDeb==std::string::npos) return EXIT_FAILURE; std::size_t posEnd = names[itSubDataset].rfind("\":"); if (posEnd==std::string::npos) return EXIT_FAILURE; // Remove the path from the SubDataset_name metadata std::string strFilepath = names[itSubDataset].substr(posDeb+2, posEnd - posDeb - 2); std::string filename = itksys::SystemTools::GetFilenameName(strFilepath); names[itSubDataset].replace(posDeb+2, posEnd - posDeb - 2, filename.c_str() ); } std::ofstream file; file.open(outputAsciiFilename); for( unsigned int itSubDataset = 0; itSubDataset < (unsigned int)names.size(); itSubDataset++ ) { file << "NAME_" << itSubDataset+1 << " :" << names[itSubDataset] << std::endl; file << "DESC_" << itSubDataset+1 << " :" << desc[itSubDataset] << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOGDAL/test/otbOGRVectorDataIOCanRead.cxx000066400000000000000000000025201301006202600245550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRVectorDataIO.h" #include int otbOGRVectorDataIOTestCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } typedef otb::OGRVectorDataIO OGRVectorDataIOType; OGRVectorDataIOType::Pointer object = OGRVectorDataIOType::New(); bool lCanRead = object->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::OGRVectorDataIO : impossible to open the file " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOGDAL/test/otbOGRVectorDataIOCanWrite.cxx000066400000000000000000000020631301006202600247760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRVectorDataIO.h" #include int otbOGRVectorDataIOCanWrite(int itkNotUsed(argc), char* argv[]) { typedef otb::OGRVectorDataIO OGRVectorDataIOType; OGRVectorDataIOType::Pointer object = OGRVectorDataIOType::New(); bool lCanWrite = object->CanWriteFile(argv[1]); if (lCanWrite == false) { std::cerr << "Erreur otb::OGRVectorDataIO : impossible to create the file " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOGDAL/test/otbOGRVectorDataIONew.cxx000066400000000000000000000015351301006202600240160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRVectorDataIO.h" int otbOGRVectorDataIONew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::OGRVectorDataIO OGRVectorDataIOType; OGRVectorDataIOType::Pointer object = OGRVectorDataIOType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOJPEG2000/000077500000000000000000000000001301006202600166145ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOJPEG2000/CMakeLists.txt000066400000000000000000000001251301006202600213520ustar00rootroot00000000000000project(OTBIOJPEG2000) set(OTBIOJPEG2000_LIBRARIES OTBIOJPEG2000) otb_module_impl() OTB-release-5.8/Modules/IO/IOJPEG2000/include/000077500000000000000000000000001301006202600202375ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOJPEG2000/include/otbJPEG2000ImageIO.h000066400000000000000000000124501301006202600233410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbJPEG2000ImageIO_h #define otbJPEG2000ImageIO_h #include "otbImageIOBase.h" #include "itkMultiThreader.h" #include namespace otb { class JPEG2000InternalReader; class JPEG2000TileCache; /** \class JPEG2000ImageIO * * \brief ImageIO object for reading and writing JPEG2000 format images * * The streaming (read and write) is implemented. * * \ingroup IOFilters * * * \ingroup OTBIOJPEG2000 */ class ITK_EXPORT JPEG2000ImageIO : public otb::ImageIOBase { public: /** Standard class typedefs. */ typedef JPEG2000ImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(JPEG2000ImageIO, otb::ImageIOBase); /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Get description about overviews available into the file specified */ std::vector GetOverviewsInfo() ITK_OVERRIDE; /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} /** Get number of available overviews in the jpeg2000 file * ( if return = 0 => no overviews available because only one resolution * is encoded in the file) */ unsigned int GetOverviewsCount() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Reads 3D data from multiple files assuming one slice per file. */ virtual void ReadVolume(void* buffer); /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; /** Return the multithreader used by this class. */ itk::MultiThreader * GetMultiThreader() {return m_Threader; } itkSetMacro(ResolutionFactor, unsigned int); itkGetMacro(ResolutionFactor, unsigned int); itkSetMacro(CacheSizeInByte, unsigned int); itkGetMacro(CacheSizeInByte, unsigned int); protected: /** Constructor.*/ JPEG2000ImageIO(); /** Destructor.*/ ~JPEG2000ImageIO() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; typedef std::vector > ReaderVectorType; ReaderVectorType m_InternalReaders; boost::shared_ptr m_TileCache; private: JPEG2000ImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Compute the tile index list from the GetRegion*/ std::vector ComputeTileList(); /** pixel nb of octets */ unsigned int m_BytePerPixel; /** Resolution factor*/ unsigned int m_ResolutionFactor; /** Size of the cache used to reduce number of decoding operations*/ unsigned int m_CacheSizeInByte; /** Load data from a tile into the buffer. 2nd argument is a * pointer to opj_image_t, hidden in void * to avoid forward declaration. */ void LoadTileData(void * buffer, void * tile); /** Support processing data in multiple threads. Used by subclasses * (e.g., ImageSource). */ itk::MultiThreader::Pointer m_Threader; int m_NumberOfThreads; /** Static function used as a "callback" by the MultiThreader. The threading * library will call this routine for each thread, which will delegate the * control to ThreadedGenerateData(). */ static ITK_THREAD_RETURN_TYPE ThreaderCallback( void *arg ); /** Configure cache manager */ void ConfigureCache(); }; } // end namespace otb #endif // otbJPEG2000ImageIO_h OTB-release-5.8/Modules/IO/IOJPEG2000/include/otbJPEG2000ImageIOFactory.h000066400000000000000000000041071301006202600246710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbJPEG2000ImageIOFactory_h #define otbJPEG2000ImageIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class JPEG2000ImageIOFactory * \brief Create instances of JPEG2000ImageIO objects using an object factory. * * \ingroup OTBIOJPEG2000 */ class ITK_EXPORT JPEG2000ImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef JPEG2000ImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static JPEG2000ImageIOFactory * FactoryNew() { return new JPEG2000ImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(JPEG2000ImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { JPEG2000ImageIOFactory::Pointer JPEG2000Factory = JPEG2000ImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(JPEG2000Factory); } protected: JPEG2000ImageIOFactory(); ~JPEG2000ImageIOFactory() ITK_OVERRIDE; private: JPEG2000ImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOJPEG2000/otb-module.cmake000066400000000000000000000005521301006202600216670ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read and write JPEG2000 format images.") otb_module(OTBIOJPEG2000 DEPENDS OTBITK OTBImageBase OTBOSSIMAdapters OTBCommon OTBTinyXML OTBOpenJPEG OTBBoost OTBGDAL TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageManipulation DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOJPEG2000/src/000077500000000000000000000000001301006202600174035ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOJPEG2000/src/CMakeLists.txt000066400000000000000000000006111301006202600221410ustar00rootroot00000000000000set(OTBIOJPEG2000_SRC otbJPEG2000ImageIO.cxx otbJPEG2000ImageIOFactory.cxx ) add_library(OTBIOJPEG2000 ${OTBIOJPEG2000_SRC}) target_link_libraries(OTBIOJPEG2000 ${OTBTinyXML_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBOpenJPEG_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBGDAL_LIBRARIES} ) otb_module_target(OTBIOJPEG2000) OTB-release-5.8/Modules/IO/IOJPEG2000/src/otbJPEG2000ImageIO.cxx000066400000000000000000001547351301006202600230750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbJPEG2000ImageIO.h" #include #include #include "otbMacro.h" #include "itksys/SystemTools.hxx" #include "itkTimeProbe.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include #include "otb_openjpeg.h" #include "gdal.h" #include "gdaljp2metadata.h" #include "cpl_string.h" #include "ogr_spatialref.h" #include "ogr_srs_api.h" #include "itksys/SystemTools.hxx" #include "otb_tinyxml.h" #include "itkMutexLock.h" #include "itkMutexLockHolder.h" void OpjImageDestroy(opj_image_t * img) { if(img) { opj_image_destroy(img); } } void OpjCodestreamDestroy(opj_codestream_info_v2_t * cstr) { opj_destroy_cstr_info(&cstr); } #if defined(OTBOpenJPEG_VERSION_NUMBER) && OTBOpenJPEG_VERSION_NUMBER < 20100 void FileDestroy(FILE * file) { if(file) { fclose(file); } } #endif /** Divide an integer by a power of 2 and round upwards @return Returns a divided by 2^b */ inline int int_ceildivpow2(int a, int b) { return (a + (1 << b) - 1) >> b; } inline unsigned int uint_ceildivpow2(unsigned int a, unsigned int b) { return (a + (1 << b) - 1) >> b; } /** sample error debug callback expecting no client object */ void error_callback(const char *msg, void *client_data) { (void) msg; (void) client_data; otbMsgDevMacro(<< "OpenJPEG error: " << msg); } /** sample warning debug callback expecting no client object */ void warning_callback(const char *msg, void *client_data) { (void) msg; (void) client_data; otbMsgDevMacro(<< "OpenJPEG warning: " << msg); } /** sample debug callback expecting no client object */ void info_callback(const char *msg, void *client_data) { (void) msg; (void) client_data; otbMsgDevMacro(<< "OpenJPEG info: " << msg); } namespace otb { /** Compute offsets needed to read the data from the tile decoded and * offsets needed to write into the output buffer. * * Please note that this function uses a bare pointer instead of a * shared one because it is called within LoadTileData, which hides * the opj_image_t pointer between a void * for proper hiding of * openjpeg API. */ void ComputeOffsets(opj_image_t * tile, const itk::ImageIORegion & ioRegion, unsigned int &l_width_src, unsigned int &l_height_dest, unsigned int &l_width_dest, unsigned int &l_start_offset_dest, unsigned int &l_start_offset_src); /************************************************************************/ /* JPEG2000 metadata reader based on GDAL functionalities */ /************************************************************************/ class JPEG2000MetadataReader { public: JPEG2000MetadataReader(const char *filename ) { m_MetadataIsRead = false; if( m_JP2Metadata.ReadAndParse(filename) ) { m_MetadataIsRead = true; } }; ~JPEG2000MetadataReader(){}; /** Get the geoTransform from file*/ std::vector GetGeoTransform(){ std::vector geoTransform; for (unsigned int i = 0; i< 6; i++ ) geoTransform.push_back(m_JP2Metadata.adfGeoTransform[i]); return geoTransform; }; /** Check if image in the file have a geoTransform*/ bool HaveGeoTransform(){ return static_cast(m_JP2Metadata.bHaveGeoTransform); }; /** Get the nb of GCP from file*/ int GetGCPCount(){ return m_JP2Metadata.nGCPCount; }; /** Get the GCPs from file*/ std::vector GetGCPs(){ std::vector gcps; int nbGCP = m_JP2Metadata.nGCPCount; for (int i = 0; i< nbGCP; i++ ) gcps.push_back(m_JP2Metadata.pasGCPList[i]); return gcps; }; /** Get the projectionRef from file*/ const char* GetProjectionRef() { if (m_JP2Metadata.pszProjection) return m_JP2Metadata.pszProjection; else return ITK_NULLPTR; }; /** Get the GML box from file*/ char** GetGMLMetadata() { if (m_JP2Metadata.papszGMLMetadata) return m_JP2Metadata.papszGMLMetadata; else return ITK_NULLPTR; }; // Get the origin from GML box (use tinyxml to parse the GML box) bool GetOriginFromGMLBox (std::vector &origin); /** Check if the file has been correctly read*/ bool m_MetadataIsRead; private: /** GDAL structure where store metadata read from JP2 file*/ GDALJP2Metadata m_JP2Metadata; }; bool JPEG2000MetadataReader::GetOriginFromGMLBox (std::vector &origin) { if (!m_MetadataIsRead) return false; std::string gmlString = static_cast (m_JP2Metadata.papszGMLMetadata[0]); gmlString.erase(0,18); // We need to remove first part to create a true xml stream otbMsgDevMacro( << "XML extract from GML box: " << gmlString ); TiXmlDocument doc; doc.Parse(gmlString.c_str()); // Create xml doc from a string TiXmlHandle docHandle( &doc ); TiXmlElement* originTag = docHandle.FirstChild( "gml:FeatureCollection" ) .FirstChild( "gml:featureMember" ) .FirstChild( "gml:FeatureCollection" ) .FirstChild( "gml:featureMember" ) .FirstChild( "gml:GridCoverage" ) .FirstChild( "gml:gridDomain") .FirstChild( "gml:Grid" ) .FirstChild( "gml:limits" ) .FirstChild( "gml:GridEnvelope" ) .FirstChild( "gml:low").ToElement(); if(originTag) { otbMsgDevMacro( << "\t Origin (" << originTag->Value() <<" tag)= "<< originTag->GetText()); } else { otbMsgDevMacro( << "Didn't find the GML element which indicate the origin!" ); return false; } std::vector originValues; originValues = itksys::SystemTools::SplitString(originTag->GetText(),' ', false); // Compute origin in GDAL convention (half pixel shift is applied later) std::istringstream ss0 (originValues[0]); std::istringstream ss1 (originValues[1]); ss0 >> origin[1]; ss1 >> origin[0]; origin[0] += -1.0; origin[1] += -1.0; otbMsgDevMacro( << "\t Origin from GML box: " << origin[0] << ", " << origin[1] ); return true; } /************************************************************************/ /* JPEG2000 internal reader based on openjpeg */ /************************************************************************/ class JPEG2000InternalReader { public: JPEG2000InternalReader(); ~JPEG2000InternalReader() { this->Clean(); } boost::shared_ptr DecodeTile(unsigned int tileIndex); const std::vector & GetAvailableResolutions(){return this->m_AvailableResolutions; }; void Clean(); bool CanRead(); int Open(const char *filename, unsigned int resolution); bool m_IsOpen; OPJ_CODEC_FORMAT m_CodecFormat; unsigned int m_Width; unsigned int m_Height; unsigned int m_NbOfComponent; std::vector m_XResolution; std::vector m_YResolution; std::vector m_Precision; std::vector m_Signed; unsigned int m_TileWidth; unsigned int m_TileHeight; unsigned int m_XNbOfTile; unsigned int m_YNbOfTile; std::vector m_AvailableResolutions; unsigned int m_ResolutionFactor; private: std::string m_FileName; #if defined(OTBOpenJPEG_VERSION_NUMBER) && OTBOpenJPEG_VERSION_NUMBER < 20100 boost::shared_ptr m_File; #endif int Initialize(); }; int JPEG2000InternalReader::Open(const char *filename, unsigned int resolution) { this->Clean(); std::string str(filename); this->m_FileName = str; // Open the file if (this->m_FileName.empty()) { this->Clean(); return 0; } #if defined(OTBOpenJPEG_VERSION_NUMBER) && OTBOpenJPEG_VERSION_NUMBER < 20100 this->m_File = boost::shared_ptr(fopen(this->m_FileName.c_str(), "rb"),FileDestroy); if (!this->m_File) { this->Clean(); return 0; } #endif // Find the codec file format if (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(m_FileName)) == ".j2k") { this->m_CodecFormat = OPJ_CODEC_J2K; } else if (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(m_FileName)) == ".jp2" || itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(m_FileName)) == ".jpx") { this->m_CodecFormat = OPJ_CODEC_JP2; } else { this->Clean(); return 0; } this->m_ResolutionFactor = resolution; // Initialize the codec and the stream if (!this->Initialize()) { this->Clean(); return 0; } this->m_IsOpen = true; return 1; } void JPEG2000InternalReader::Clean() { this->m_FileName.clear(); #if defined(OTBOpenJPEG_VERSION_NUMBER) && OTBOpenJPEG_VERSION_NUMBER < 20100 this->m_File = boost::shared_ptr(); #endif this->m_XResolution.clear(); this->m_YResolution.clear(); this->m_Precision.clear(); this->m_Signed.clear(); m_AvailableResolutions.clear(); this->m_Width = 0; this->m_Height = 0; this->m_NbOfComponent = 0; this->m_TileWidth = 0; this->m_TileHeight = 0; this->m_XNbOfTile = 0; this->m_YNbOfTile = 0; this->m_IsOpen = false; this->m_CodecFormat = OPJ_CODEC_UNKNOWN; this->m_ResolutionFactor=0; } boost::shared_ptr JPEG2000InternalReader::DecodeTile(unsigned int tileIndex) { #if defined(OTBOpenJPEG_VERSION_NUMBER) && OTBOpenJPEG_VERSION_NUMBER < 20100 if (!this->m_File) { this->Clean(); return boost::shared_ptr(); } // Creating the file stream boost::shared_ptr stream = boost::shared_ptr(opj_stream_create_default_file_stream(this->m_File.get(), true),opj_stream_destroy); if (!stream) { this->Clean(); return boost::shared_ptr(); } #else if (this->m_FileName.empty()) { this->Clean(); return boost::shared_ptr(); } // Creating the file stream boost::shared_ptr stream = boost::shared_ptr(opj_stream_create_default_file_stream(this->m_FileName.c_str(), true),opj_stream_destroy); if (!stream) { this->Clean(); return boost::shared_ptr(); } #endif // Creating the codec boost::shared_ptr codec = boost::shared_ptr(opj_create_decompress(this->m_CodecFormat),opj_destroy_codec); if (!codec) { this->Clean(); return boost::shared_ptr(); } // Setting default parameters opj_dparameters_t parameters; opj_set_default_decoder_parameters(¶meters); parameters.cp_reduce = static_cast(this->m_ResolutionFactor); // Set default event mgr // catch events using our callbacks and give a local context opj_set_info_handler(codec.get(), info_callback,ITK_NULLPTR); opj_set_warning_handler(codec.get(), warning_callback,ITK_NULLPTR); opj_set_error_handler(codec.get(), error_callback,ITK_NULLPTR); // Setup the decoder decoding parameters using user parameters if (!opj_setup_decoder(codec.get(), ¶meters)) { this->Clean(); return boost::shared_ptr(); } // Read the main header of the codestream and if necessary the JP2 // boxes opj_image_t * unsafeOpjImgPtr = ITK_NULLPTR; if (!opj_read_header(stream.get(), codec.get(),&unsafeOpjImgPtr)) { boost::shared_ptr image = boost::shared_ptr(unsafeOpjImgPtr,OpjImageDestroy); this->Clean(); return boost::shared_ptr(); } boost::shared_ptr image = boost::shared_ptr(unsafeOpjImgPtr,OpjImageDestroy); if( opj_get_decoded_tile(codec.get(), stream.get(), image.get(), tileIndex)) { otbMsgDevMacro(<<"Tile "<Clean(); return boost::shared_ptr(); } } JPEG2000InternalReader::JPEG2000InternalReader() { this->Clean(); } int JPEG2000InternalReader::Initialize() { #if defined(OTBOpenJPEG_VERSION_NUMBER) && OTBOpenJPEG_VERSION_NUMBER < 20100 if (this->m_File) { // Creating the file stream boost::shared_ptr stream = boost::shared_ptr(opj_stream_create_default_file_stream(this->m_File.get(), true),opj_stream_destroy); if (!stream) { std::cerr << "ERROR file stream creation" << std::endl; this->Clean(); return 0; } #else if (!m_FileName.empty()) { // Creating the file stream boost::shared_ptr stream = boost::shared_ptr(opj_stream_create_default_file_stream(this->m_FileName.c_str(), true),opj_stream_destroy); if (!stream) { std::cerr << "ERROR file stream creation" << std::endl; this->Clean(); return 0; } #endif // Creating the codec boost::shared_ptr codec = boost::shared_ptr(opj_create_decompress(this->m_CodecFormat),opj_destroy_codec); if (!codec) { std::cerr << "ERROR codec creation" << std::endl ; this->Clean(); return 0; } // Setting default parameters opj_dparameters_t parameters; opj_set_default_decoder_parameters(¶meters); parameters.cp_reduce = static_cast(this->m_ResolutionFactor); // Set default event mgr // catch events using our callbacks and give a local context opj_set_info_handler(codec.get(), info_callback,ITK_NULLPTR); opj_set_warning_handler(codec.get(), warning_callback,ITK_NULLPTR); opj_set_error_handler(codec.get(), error_callback,ITK_NULLPTR); // Setup the decoder decoding parameters using user parameters if (!opj_setup_decoder(codec.get(), ¶meters)) { std::cerr << "ERROR setup decoder" << std::endl ; this->Clean(); return 0; } // Read the main header of the codestream and if necessary the JP2 // boxes opj_image_t * unsafeOpjImgPtr = ITK_NULLPTR; if (!opj_read_header(stream.get(), codec.get(),&unsafeOpjImgPtr)) { std::cerr << "ERROR read header" << std::endl; boost::shared_ptr image = boost::shared_ptr(unsafeOpjImgPtr,OpjImageDestroy); this->Clean(); return 0; } boost::shared_ptr image = boost::shared_ptr(unsafeOpjImgPtr,OpjImageDestroy); // Get the codestream information boost::shared_ptr cstrInfo = boost::shared_ptr(opj_get_cstr_info(codec.get()),OpjCodestreamDestroy); if (!cstrInfo) { std::cerr << "ERROR while get codestream info" << std::endl; this->Clean(); return 0; } // We can now retrieve the main information of the image and the codestream // (based on the first component and with no subsampling) this->m_Width = image->comps->w; this->m_Height = image->comps->h; otbMsgDevMacro(<< "JPEG2000InternalReader dimension (after reading header) = " << image->comps->w << " x " << image->comps->w << " x " << image->comps->h ); this->m_TileHeight = cstrInfo->tdy; this->m_TileWidth = cstrInfo->tdx; this->m_XNbOfTile = cstrInfo->tw; this->m_YNbOfTile = cstrInfo->th; this->m_NbOfComponent = image->numcomps; for (unsigned int itComp = 0; itComp < this->m_NbOfComponent; itComp++) { this->m_Precision.push_back( image->comps[itComp].prec); this->m_Signed.push_back( image->comps[itComp].sgnd); this->m_XResolution.push_back( image->comps[itComp].dx); this->m_YResolution.push_back( image->comps[itComp].dy); } // Warning: This value is based on the first component of the default tile parameters. unsigned int numResAvailable = cstrInfo->m_default_tile_info.tccp_info[0].numresolutions; m_AvailableResolutions.clear(); for (unsigned int itRes = 0; itRes < numResAvailable; itRes++) { m_AvailableResolutions.push_back(itRes); } } return 1; } bool JPEG2000InternalReader::CanRead() { if (Initialize() && ( this->m_Width > 0 ) && ( this->m_Height > 0 ) && ( this->m_TileWidth > 0 ) && ( this->m_TileHeight > 0 ) && ( this->m_XNbOfTile > 0 ) && ( this->m_YNbOfTile > 0 ) && ( this->m_NbOfComponent > 0 ) ) { // We manage only JPEG2000 file with characteristics which are equal between components for(unsigned int itComp = 0; itComp < this->m_NbOfComponent - 1; itComp++) { if ( (this->m_Precision[itComp] != this->m_Precision[itComp+1]) && (this->m_Signed[itComp] != this->m_Signed[itComp+1]) && (this->m_XResolution[itComp] != this->m_XResolution[itComp+1]) && (!this->m_XResolution[itComp]) && (this->m_YResolution[itComp] != this->m_YResolution[itComp+1]) && (!this->m_YResolution[itComp]) ) { return false; } } return true; } else { std::cerr << this->m_Width << ", " << this->m_Height << ", " << this->m_TileWidth << ", " << this->m_TileHeight << ", " << this->m_XNbOfTile << ", " << this->m_YNbOfTile<< ", " << this->m_NbOfComponent << std::endl ; std::cout << "HERE1" << std::endl; return false; } } /************************************************************************/ /* Class to manage JPEG2000 tile cache system */ /************************************************************************/ class JPEG2000TileCache { public: JPEG2000TileCache(); ~JPEG2000TileCache(); typedef std::pair > CachedTileType; typedef std::deque TileCacheType; /** Get a tile in cache, return null if cache does not contain the tile */ boost::shared_ptr GetTile(unsigned int tileIndex); /** Register a new tile in cache */ void AddTile(unsigned int tileIndex, boost::shared_ptr tileData); /** Remove the front tile */ void RemoveOneTile(); /** Clear the cache */ void Clear(); /** Initialize some parameters linked to the cache size in memory*/ void Initialize(unsigned int originalWidthTile, unsigned int originalHeightTile, unsigned int nbComponent, unsigned int precision, unsigned int resolution) { this->EstimateTileCacheSize(originalWidthTile, originalHeightTile, nbComponent, precision, resolution); m_CacheSizeInByte = m_CacheSizeInTiles * m_TileCacheSizeInByte; m_IsReady = true; }; /** Set the size of the cache with in terms of number of tiles */ void SetCacheSizeInTiles(unsigned int nbOfTiles) { if (nbOfTiles > 0 && m_IsReady) { m_CacheSizeInTiles = nbOfTiles; m_CacheSizeInByte = m_CacheSizeInTiles * m_TileCacheSizeInByte; } }; /** Get the size of the cache in terms of number of tiles */ unsigned int GetCacheSizeInTiles() {return m_CacheSizeInTiles; }; /** Set the size of the cache with in terms of Bytes */ void SetCacheSizeInByte(unsigned int sizeInByte) { if (sizeInByte > 0 && m_IsReady) { m_CacheSizeInByte = sizeInByte; if (m_TileCacheSizeInByte) m_CacheSizeInTiles = m_CacheSizeInByte / m_TileCacheSizeInByte; else m_CacheSizeInTiles = 0; } }; unsigned int GetCurrentNumberOfTileInCache() { return static_cast(m_Cache.size()); }; private: TileCacheType m_Cache; unsigned int m_CacheSizeInTiles; unsigned int m_CacheSizeInByte; unsigned int m_TileCacheSizeInByte; bool m_IsReady; itk::SimpleMutexLock m_Mutex; /** Estimate the size of a tile in memory*/ void EstimateTileCacheSize(unsigned int originalWidthTile, unsigned int originalHeightTile, unsigned int nbComponent, unsigned int precision, unsigned int resolution); }; JPEG2000TileCache::JPEG2000TileCache() : m_Cache(), m_CacheSizeInTiles(4), m_CacheSizeInByte(0), m_TileCacheSizeInByte(0), m_IsReady(false) {} JPEG2000TileCache::~JPEG2000TileCache() { this->Clear(); } void JPEG2000TileCache::EstimateTileCacheSize(unsigned int originalWidthTile, unsigned int originalHeightTile, unsigned int nbComponent, unsigned int itkNotUsed(precision), unsigned int resolution) { this->m_TileCacheSizeInByte = originalWidthTile * originalHeightTile * nbComponent * sizeof(OPJ_INT32) / vcl_pow(2, 2*static_cast(resolution) ); if (!this->m_TileCacheSizeInByte) { otbMsgDevMacro( << "TileCacheSizeInByte is estimated at " << m_TileCacheSizeInByte << " bytes so we don't used the cache"); } otbMsgDevMacro( << "m_TileCacheSizeInByte = " << m_TileCacheSizeInByte ); } void JPEG2000TileCache::Clear() { m_Cache.clear(); } boost::shared_ptr JPEG2000TileCache::GetTile(unsigned int tileIndex) { for(TileCacheType::iterator it = m_Cache.begin(); it != m_Cache.end(); ++it) { if(it->first == tileIndex) { otbMsgDevMacro(<<"Tile "<first<<" loaded from cache"); return it->second; } } return boost::shared_ptr(); } void JPEG2000TileCache::RemoveOneTile() { if(!m_Cache.empty()) { m_Cache.pop_front(); } } void JPEG2000TileCache::AddTile(unsigned int tileIndex, boost::shared_ptr tileData) { // This helper class makes sure the Mutex is unlocked // in the event an exception is thrown. itk::MutexLockHolder mutexHolder(m_Mutex); if(!m_IsReady) { std::cerr<<(this)<<" Cache is not configured !"<first == tileIndex) { return; } } if(m_Cache.size() >= m_CacheSizeInTiles) { this->RemoveOneTile(); } m_Cache.push_back(CachedTileType(tileIndex, tileData)); } /************************************************************************/ /* JPEG2000ImageIO */ /************************************************************************/ JPEG2000ImageIO::JPEG2000ImageIO() { // Initialize multi-threader m_Threader = itk::MultiThreader::New(); m_NumberOfThreads = m_Threader->GetNumberOfThreads(); for(int i = 0; i(new JPEG2000InternalReader)); } m_TileCache = boost::shared_ptr(new JPEG2000TileCache); // By default set number of dimensions to two. this->SetNumberOfDimensions(2); m_PixelType = SCALAR; m_ComponentType = UCHAR; // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to zero m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_BytePerPixel = 1; m_ResolutionFactor = 0; // Full resolution by default m_CacheSizeInByte = 0; // By default no cache } JPEG2000ImageIO::~JPEG2000ImageIO() {} bool JPEG2000ImageIO::CanReadFile(const char* filename) { if (filename == ITK_NULLPTR) { itkDebugMacro(<< "No filename specified."); return false; } bool success = true; for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { if ( !(*it)->Open(filename, m_ResolutionFactor) ) { success = false; } } // If one of the readers fails, clean everything if(!success) { for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { (*it)->Clean(); } } return success; } // Used to print information about this object void JPEG2000ImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Resolution Factor: " << m_ResolutionFactor << "\n"; } // Read a 3D image not implemented yet void JPEG2000ImageIO::ReadVolume(void*) { } /** Internal structure used for passing image data into the threading library */ struct ThreadStruct { std::vector > Readers; std::vector * Tiles; JPEG2000ImageIO::Pointer IO; boost::shared_ptr Cache; void * Buffer; }; std::vector JPEG2000ImageIO::GetOverviewsInfo() { std::vector desc; int originalWidth = m_InternalReaders[0]->m_Width; int originalHeight = m_InternalReaders[0]->m_Height; unsigned int lOverviewCount = this->GetOverviewsCount(); for (unsigned int i = 0; i < lOverviewCount; i++) { // For each resolution we will compute the tile dim and image dim std::ostringstream oss; int w = int_ceildivpow2( originalWidth, i); int h = int_ceildivpow2( originalHeight, i); int tw = int_ceildivpow2(m_InternalReaders[0]->m_TileWidth, i); int th = int_ceildivpow2(m_InternalReaders[0]->m_TileHeight, i); oss << "Resolution: " << i << " (Image [w x h]: " << w << "x" << h << ", Tile [w x h]: " << tw << "x" << th << ")"; desc.push_back(oss.str()); } return desc; } unsigned int JPEG2000ImageIO::GetOverviewsCount() { std::vector tempResList = this->m_InternalReaders[0]->GetAvailableResolutions(); if (tempResList.empty()) { itkExceptionMacro(<< "Available resolutions in JPEG2000 is empty"); } // count includes full resolution return tempResList.size(); } // Read image void JPEG2000ImageIO::Read(void* buffer) { itk::TimeProbe chrono; chrono.Start(); // Check if conversion succeed if (buffer == ITK_NULLPTR) { itkExceptionMacro(<< "JPEG2000ImageIO : Bad alloc"); return; } // Re-open the file if it was closed bool open = true; for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { open = (*it)->m_IsOpen && open; } if ( !open ) { if ( !this->CanReadFile( m_FileName.c_str() ) ) { itkExceptionMacro(<< "Cannot open file " << this->m_FileName << "!"); return; } } if (m_ResolutionFactor >= this->m_InternalReaders[0]->m_AvailableResolutions.size()) { itkExceptionMacro(<< "Resolution not available in the file!"); return; } std::vector tileList = this->ComputeTileList(); if (tileList.empty()) { for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { (*it)->Clean(); } itkExceptionMacro(<< " IORegion does not correspond to any tile!"); } // Here we sort between tiles from cache and tiles to read std::vector cachedTiles; std::vector toReadTiles; for (std::vector::iterator itTile = tileList.begin(); itTile < tileList.end(); ++itTile) { boost::shared_ptr currentImage(m_TileCache->GetTile(*itTile)); JPEG2000TileCache::CachedTileType currentTile = std::make_pair((*itTile), currentImage); if(!currentImage) { toReadTiles.push_back(currentTile); } else { cachedTiles.push_back(currentTile); } } // First, load tiles from cache for (std::vector::iterator itTile = cachedTiles.begin(); itTile < cachedTiles.end(); ++itTile) { this->LoadTileData(buffer, itTile->second.get()); } // If we will read more tiles than the cache size, clear it if(toReadTiles.size() > m_TileCache->GetCacheSizeInTiles()) { m_TileCache->Clear(); } // Else if there is not enough rooms from new tiles else if(toReadTiles.size() > (m_TileCache->GetCacheSizeInTiles() - m_TileCache->GetCurrentNumberOfTileInCache())) { int nbTileToRemove = toReadTiles.size() - (m_TileCache->GetCacheSizeInTiles() - m_TileCache->GetCurrentNumberOfTileInCache()); // Remove from cache as many tiles that will be read in this step for (int itTileR = 0; itTileR < nbTileToRemove; ++itTileR) { m_TileCache->RemoveOneTile(); } } // Decode all tiles not in cache in parallel if(!toReadTiles.empty()) { unsigned int nbThreads = itk::MultiThreader::GetGlobalDefaultNumberOfThreads(); if (nbThreads > toReadTiles.size()) { nbThreads = toReadTiles.size(); } this->GetMultiThreader()->SetNumberOfThreads(nbThreads); // Set up the multithreaded processing ThreadStruct str; str.Readers = m_InternalReaders; str.Tiles = &toReadTiles; str.IO = this; str.Cache = m_TileCache; str.Buffer = buffer; // Set-up multi-threader this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str); // multithread the execution this->GetMultiThreader()->SingleMethodExecute(); } chrono.Stop(); otbMsgDevMacro( << "JPEG2000ImageIO::Read took " << chrono.GetTotal() << " sec"); for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { (*it)->Clean(); } } // The void * interface prevent us to propagate shared_ptr here void JPEG2000ImageIO::LoadTileData(void * buffer, void * currentTile) { opj_image_t * tile = static_cast(currentTile); if(!tile) { itkExceptionMacro(<<"Tile needed but not loaded."); } // Get nb. of lines and columns of the region to read /* -Wunused-variable int lNbLines = this->GetIORegion().GetSize()[1]; */ int lNbColumns = this->GetIORegion().GetSize()[0]; /* -Wunused-variable int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] */ unsigned int lWidthSrc; // Width of the input pixel in nb of pixel unsigned int lHeightDest; // Height of the area where write in nb of pixel unsigned int lWidthDest; // Width of the area where write in nb of pixel unsigned int lStartOffsetPxlDest; // Offset where begin to write the area in the otb buffer in nb of pixel unsigned int lStartOffsetPxlSrc; // Offset where begin to write the area in the otb buffer in nb of pixel ComputeOffsets(tile, this->GetIORegion(), lWidthSrc, lHeightDest, lWidthDest, lStartOffsetPxlDest, lStartOffsetPxlSrc); switch (this->GetComponentType()) { case CHAR: { char *p = static_cast (buffer); for (unsigned int j = 0; j < lHeightDest; ++j) { char* current_dst_line = p + (lStartOffsetPxlDest + j * lNbColumns) * this->m_NumberOfComponents; for (unsigned int k = 0; k < lWidthDest; ++k) { for (unsigned int itComp = 0; itComp < this->m_NumberOfComponents; itComp++) { OPJ_INT32* data = tile->comps[itComp].data; *(current_dst_line++) = static_cast (data[lStartOffsetPxlSrc + k + j * lWidthSrc]); } } } } break; case UCHAR: { unsigned char *p = static_cast (buffer); for (unsigned int j = 0; j < lHeightDest; ++j) { unsigned char* current_dst_line = p + (lStartOffsetPxlDest + j * lNbColumns) * this->m_NumberOfComponents; for (unsigned int k = 0; k < lWidthDest; ++k) { for (unsigned int itComp = 0; itComp < this->m_NumberOfComponents; itComp++) { OPJ_INT32* data = tile->comps[itComp].data; unsigned char component_val = data[lStartOffsetPxlSrc + k + j * lWidthSrc] & 0xff; *(current_dst_line++) = static_cast (component_val); } } } } break; case SHORT: { short *p = static_cast (buffer); for (unsigned int j = 0; j < lHeightDest; ++j) { short* current_dst_line = p + (lStartOffsetPxlDest + j * lNbColumns) * this->m_NumberOfComponents; for (unsigned int k = 0; k < lWidthDest; ++k) { for (unsigned int itComp = 0; itComp < this->m_NumberOfComponents; itComp++) { OPJ_INT32* data = tile->comps[itComp].data; *(current_dst_line++) = static_cast (data[lStartOffsetPxlSrc + k + j * lWidthSrc]); } } } } break; case USHORT: { unsigned short *p = static_cast (buffer); for (unsigned int j = 0; j < lHeightDest; ++j) { unsigned short* current_dst_line = p + (lStartOffsetPxlDest + j * lNbColumns) * this->m_NumberOfComponents; for (unsigned int k = 0; k < lWidthDest; ++k) { for (unsigned int itComp = 0; itComp < this->m_NumberOfComponents; itComp++) { OPJ_INT32* data = tile->comps[itComp].data; *(current_dst_line++) = static_cast (data[lStartOffsetPxlSrc + k + j * lWidthSrc] & 0xffff); } } } } break; case INT: case UINT: default: itkGenericExceptionMacro(<< "This data type is not handled"); break; } } ITK_THREAD_RETURN_TYPE JPEG2000ImageIO::ThreaderCallback( void *arg ) { ThreadStruct *str; unsigned int total, threadCount; itk::ThreadIdType threadId; threadId = ((itk::MultiThreader::ThreadInfoStruct *)(arg))->ThreadID; threadCount = ((itk::MultiThreader::ThreadInfoStruct *)(arg))->NumberOfThreads; str = (ThreadStruct *)(((itk::MultiThreader::ThreadInfoStruct *)(arg))->UserData); // Retrieve data std::vector > readers = str->Readers; std::vector * tiles = str->Tiles; JPEG2000ImageIO::Pointer io = str->IO; boost::shared_ptr cache = str->Cache; void * buffer = str->Buffer; total = std::min((unsigned int)tiles->size(), threadCount); if(total == 0) { return ITK_THREAD_RETURN_VALUE; } unsigned int tilesPerThread = tiles->size()/total; if(tilesPerThread == 0) { tilesPerThread = 1; } for(unsigned int i = threadId * tilesPerThread; i < tilesPerThread * (threadId+1); ++i) { boost::shared_ptr currentTile = readers.at(threadId)->DecodeTile(tiles->at(i).first); // Check if tile is valid if(!currentTile) { readers.at(threadId)->Clean(); itkGenericExceptionMacro(" otbopenjpeg failed to decode the desired tile "<at(i).first << "!"); } otbMsgDevMacro(<< " Tile " << tiles->at(i).first << " decoded by thread "<LoadTileData(buffer, currentTile.get()); if (cache->GetCacheSizeInTiles() != 0) { cache->AddTile(tiles->at(i).first, currentTile); } } unsigned int lastTile = threadCount*tilesPerThread + threadId; // TODO: check this last part if(lastTile < tiles->size()) { boost::shared_ptr currentTile = readers.at(threadId)->DecodeTile(tiles->at(lastTile).first); // Check if tile is valid if(!currentTile) { readers.at(threadId)->Clean(); itkGenericExceptionMacro(" otbopenjpeg failed to decode the desired tile "<at(lastTile).first << "!"); } otbMsgDevMacro(<< " Tile " <at(lastTile).first << " decoded by thread "<LoadTileData(buffer, currentTile.get()); if (cache->GetCacheSizeInTiles() != 0) { cache->AddTile(tiles->at(lastTile).first, currentTile); } } return ITK_THREAD_RETURN_VALUE; } void JPEG2000ImageIO::ConfigureCache() { itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::CacheSizeInBytes, m_CacheSizeInByte); // Initialize some parameters of the tile cache this->m_TileCache->Initialize(m_InternalReaders.front()->m_TileWidth, m_InternalReaders.front()->m_TileHeight, m_InternalReaders.front()->m_NbOfComponent, m_BytePerPixel, m_ResolutionFactor); // If available set the size of the cache if (this->m_CacheSizeInByte) this->m_TileCache->SetCacheSizeInByte(this->m_CacheSizeInByte); } void JPEG2000ImageIO::ReadImageInformation() { // Extract metadata // In case the metadata are not set, the function silently returns, doing nothing itk::ExposeMetaData(this->GetMetaDataDictionary(), MetaDataKey::ResolutionFactor, m_ResolutionFactor); // Now initialize the itk dictionary itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); JPEG2000MetadataReader lJP2MetadataReader(m_FileName.c_str()); if (lJP2MetadataReader.m_MetadataIsRead) { otbMsgDevMacro(<<"JPEG2000 file has metadata available!"); // reset the origin to [0,0] as in GDAL convention m_Origin[0] = 0.0; m_Origin[1] = 0.0; /* GEOTRANSFORM */ if (lJP2MetadataReader.HaveGeoTransform()) { otbMsgDevMacro(<< "JPEG2000 file has a geotransform!"); std::vector geoTransform = lJP2MetadataReader.GetGeoTransform(); itk::EncapsulateMetaData(dict, MetaDataKey::GeoTransformKey, geoTransform); /*std::cout << "from gml box, geotransform: "; for (int i = 0; i < 6; i++) { std::cout << geoTransform[i] << ", "; } std::cout << std::endl; */ // Retrieve origin and spacing from the geo transform m_Spacing[0] = geoTransform[1]; m_Spacing[1] = geoTransform[5]; if ( m_Spacing[0]== 0 || m_Spacing[1] == 0) { // Manage case where axis are not standard if (geoTransform[2] != 0 && geoTransform[4] != 0 ) { m_Spacing[0] = geoTransform[2]; m_Spacing[1] = geoTransform[4]; } else { otbWarningMacro(<< "JPEG2000 file has an incorrect geotransform (spacing = 0)!"); m_Spacing[0] = 1; m_Spacing[1] = 1; } } // Geotransforms with a non-null rotation are not supported // Beware : GDAL origin is at the corner of the top-left pixel // whereas OTB/ITK origin is at the centre of the top-left pixel // The origin is first stored in GDAL convention. The halft pixel // shift is applied later (when the final spacing is known) m_Origin[0] = geoTransform[0]; m_Origin[1] = geoTransform[3]; } /* GCPs */ if (lJP2MetadataReader.GetGCPCount() > 0) { // No GCPprojRef return by GDALJP2metadata std::string gcpProjectionKey = "UNKNOWN"; itk::EncapsulateMetaData(dict, MetaDataKey::GCPProjectionKey, gcpProjectionKey); int nbGCPs = lJP2MetadataReader.GetGCPCount(); otbMsgDevMacro(<< "JPEG2000 file has "<< nbGCPs << " GCPs!"); itk::EncapsulateMetaData(dict, MetaDataKey::GCPCountKey, nbGCPs); std::vector gcps = lJP2MetadataReader.GetGCPs(); std::string key; for (int cpt = 0; cpt < nbGCPs; ++cpt) { GDAL_GCP currentGCP = gcps[cpt]; OTB_GCP pOtbGCP; pOtbGCP.m_Id = std::string(currentGCP.pszId); pOtbGCP.m_Info = std::string(currentGCP.pszInfo); pOtbGCP.m_GCPRow = currentGCP.dfGCPLine; pOtbGCP.m_GCPCol = currentGCP.dfGCPPixel; pOtbGCP.m_GCPX = currentGCP.dfGCPX; pOtbGCP.m_GCPY = currentGCP.dfGCPY; pOtbGCP.m_GCPZ = currentGCP.dfGCPZ; // Complete the key with the GCP number : GCP_i std::ostringstream lStream; lStream << MetaDataKey::GCPParametersKey << cpt; key = lStream.str(); itk::EncapsulateMetaData(dict, key, pOtbGCP); } } /* GMLMetadata*/ char** papszGMLMetadata; papszGMLMetadata = lJP2MetadataReader.GetGMLMetadata(); if (CSLCount(papszGMLMetadata) > 0) { otbMsgDevMacro(<< "JPEG2000 file has GMLMetadata!"); std::string key; for (int cpt = 0; papszGMLMetadata[cpt] != ITK_NULLPTR; ++cpt) { std::ostringstream lStream; lStream << MetaDataKey::MetadataKey << cpt; key = lStream.str(); itk::EncapsulateMetaData(dict, key, static_cast (papszGMLMetadata[cpt])); otbMsgDevMacro( << static_cast(papszGMLMetadata[cpt])); } } /* ProjectionRef*/ if (lJP2MetadataReader.GetProjectionRef() && !std::string(lJP2MetadataReader.GetProjectionRef()).empty() ) { OGRSpatialReferenceH pSR = OSRNewSpatialReference(ITK_NULLPTR); const char * pszProjection = ITK_NULLPTR; pszProjection = lJP2MetadataReader.GetProjectionRef(); if (OSRImportFromWkt(pSR, (char **) (&pszProjection)) == OGRERR_NONE) { char * pszPrettyWkt = ITK_NULLPTR; OSRExportToPrettyWkt(pSR, &pszPrettyWkt, FALSE); itk::EncapsulateMetaData (dict, MetaDataKey::ProjectionRefKey, static_cast(pszPrettyWkt)); CPLFree(pszPrettyWkt); } else { itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, static_cast(lJP2MetadataReader.GetProjectionRef())); } if (pSR != ITK_NULLPTR) { OSRRelease(pSR); pSR = ITK_NULLPTR; } } else { otbMsgDevMacro( << "NO PROJECTION IN GML BOX => SENSOR MODEL " ); m_Origin[0] = 0.0; m_Origin[1] = 0.0; m_Spacing[0] = 1; m_Spacing[1] = 1; lJP2MetadataReader.GetOriginFromGMLBox(m_Origin); } otbMsgDevMacro(<< "FROM GML box: " << "Origin: " << m_Origin[0] << ", " << m_Origin[1] << " | Spacing: " << m_Spacing[0] << ", " << m_Spacing[1] ); } else { otbMsgDevMacro( << "JPEG2000 file has NO metadata available!"); m_Origin[0] = 0.0; m_Origin[1] = 0.0; m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; } // Compute final spacing using the resolution factor m_Spacing[0] *= vcl_pow(2.0, static_cast(m_ResolutionFactor)); m_Spacing[1] *= vcl_pow(2.0, static_cast(m_ResolutionFactor)); // Now that the spacing is known, apply the half-pixel shift m_Origin[0] += 0.5*m_Spacing[0]; m_Origin[1] += 0.5*m_Spacing[1]; // If the internal image was not open we open it. // This is usually done when the user sets the ImageIO manually if ( !m_InternalReaders.front()->m_IsOpen ) { if ( !this->CanReadFile( m_FileName.c_str() ) ) { itkExceptionMacro(<< "Cannot open file " << this->m_FileName << "!"); return; } } // Check some internal parameters of the JPEG2000 file if ( !this->m_InternalReaders.front()->CanRead()) { this->m_InternalReaders.front()->Clean(); itkExceptionMacro(<< "Cannot read this file because some JPEG2000 parameters are not supported!"); } // If one of the readers fails, clean everything if(this->m_ResolutionFactor != 0) { for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { (*it)->Clean(); } bool success = true; for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { if ( !(*it)->Open( m_FileName.c_str(), this->m_ResolutionFactor ) ) { success = false; } (*it)->m_IsOpen = true; } // If one of the readers fails, clean everything if(!success) { for(ReaderVectorType::iterator it = m_InternalReaders.begin(); it != m_InternalReaders.end(); ++it) { (*it)->Clean(); } itkExceptionMacro(<< "Cannot open this file with this resolution!"); return; } } // Encapsulate tile hints for streaming unsigned int tileHintX = m_InternalReaders.front()->m_TileWidth / static_cast(vcl_pow(2.0, static_cast(m_ResolutionFactor) )); unsigned int tileHintY = m_InternalReaders.front()->m_TileHeight / static_cast(vcl_pow(2.0, static_cast(m_ResolutionFactor) )); itk::EncapsulateMetaData(dict, MetaDataKey::TileHintX, tileHintX); itk::EncapsulateMetaData(dict, MetaDataKey::TileHintY, tileHintY); // If we have some spacing information we use it // could be needed for other j2k image but not for pleiades // if ( (m_InternalReaders.front()->m_XResolution.front() > 0) && (m_InternalReaders.front()->m_YResolution.front() > 0) ) // { // // We check previously that the X and Y resolution is equal between the components // m_Spacing[0] *= m_InternalReaders.front()->m_XResolution[0]; // m_Spacing[1] *= m_InternalReaders.front()->m_YResolution[0]; // } m_Dimensions[0] = m_InternalReaders.front()->m_Width; m_Dimensions[1] = m_InternalReaders.front()->m_Height; this->SetNumberOfDimensions(2); if (m_Dimensions[0] == 0 || m_Dimensions[1] == 0) { itkExceptionMacro(<< "Image size is null."); } this->SetNumberOfComponents(m_InternalReaders.front()->m_NbOfComponent); // Automatically set the Type to Binary for JPEG2000 data this->SetFileTypeToBinary(); // We check previously that these values are equal between all components unsigned int precision = m_InternalReaders.front()->m_Precision[0]; int isSigned = m_InternalReaders.front()->m_Signed[0]; if (precision <= 8) { m_BytePerPixel = 1; if (isSigned) { SetComponentType(CHAR); } else { SetComponentType(UCHAR); } } else if (precision <= 16) { m_BytePerPixel = 2; if (isSigned) { SetComponentType(SHORT); } else { SetComponentType(USHORT); } } else { m_BytePerPixel = 4; if (isSigned) { SetComponentType(INT); } else { SetComponentType(UINT); } } if (this->GetNumberOfComponents() == 1) { this->SetPixelType(SCALAR); } else { this->SetPixelType(VECTOR); } this->ConfigureCache(); otbMsgDebugMacro(<< "=========================="); otbMsgDebugMacro(<< "ReadImageInformation: "); otbMsgDebugMacro(<< "Tile size (WxH): " << m_InternalReaders.front()->m_TileWidth << " x " << m_InternalReaders.front()->m_TileHeight); otbMsgDebugMacro(<< "Number of tiles (Xdim x Ydim) : " << m_InternalReaders.front()->m_XNbOfTile << " x " << m_InternalReaders.front()->m_YNbOfTile); otbMsgDebugMacro(<< "Precision: " << precision); otbMsgDebugMacro(<< "Signed: " << isSigned); otbMsgDebugMacro(<< "Number of octet per value: " << m_BytePerPixel); otbMsgDebugMacro(<< "=========================="); otbMsgDebugMacro(<< "Driver to read: JPEG2000"); otbMsgDebugMacro(<< " Read file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } // Compute the tile index list from the GetRegion std::vector JPEG2000ImageIO::ComputeTileList() { std::vector tileVector; // Get nb. of lines and columns of the region to decode unsigned int startX = this->GetIORegion().GetIndex()[0]; unsigned int endX = this->GetIORegion().GetIndex()[0] + this->GetIORegion().GetSize()[0]; unsigned int startY = this->GetIORegion().GetIndex()[1]; unsigned int endY = this->GetIORegion().GetIndex()[1] + this->GetIORegion().GetSize()[1]; // Compute index of tile recover by the decoded area unsigned int tile_size_x = m_InternalReaders.front()->m_TileWidth; unsigned int tile_size_y = m_InternalReaders.front()->m_TileHeight; unsigned int width = m_Dimensions[0]; unsigned int height = m_Dimensions[1]; unsigned int nbOfTileX = m_InternalReaders.front()->m_XNbOfTile; unsigned int nbOfTileY = m_InternalReaders.front()->m_YNbOfTile; unsigned int tilePosX0, tilePosX1; unsigned int tilePosY0, tilePosY1; for (unsigned int itTileY = 0; itTileY < nbOfTileY; itTileY++) { tilePosY0 = uint_ceildivpow2( itTileY*tile_size_y, m_ResolutionFactor ); tilePosY1 = std::min( uint_ceildivpow2( (itTileY+1)*tile_size_y, m_ResolutionFactor ), height ); for (unsigned int itTileX = 0; itTileX < nbOfTileX; itTileX++) { tilePosX0 = uint_ceildivpow2( itTileX*tile_size_x, m_ResolutionFactor ); tilePosX1 = std::min( uint_ceildivpow2( (itTileX+1)*tile_size_x, m_ResolutionFactor ), width); if ( (tilePosX1 - tilePosX0) && (tilePosY1 - tilePosY0) && (tilePosX1 > startX) && (tilePosX0 < endX ) && (tilePosY1 > startY) && (tilePosY0 < endY ) ) tileVector.push_back(itTileX + itTileY * nbOfTileX); } } return tileVector; } /** Compute the offsets in Pixel to move the input buffer from openjpeg * to the corresponding area of the otb output buffer * */ void ComputeOffsets( opj_image_t * currentTile, const itk::ImageIORegion & ioRegion, unsigned int &l_width_src, // Width of the input pixel in nb of pixel unsigned int &l_height_dest, // Height of the area where write in nb of pixel unsigned int &l_width_dest, // Width of the area where write in nb of pixel unsigned int &l_start_offset_dest, // Offset where begin to write the area in the otb buffer in nb of pixel unsigned int &l_start_offset_src // Offset where begin to read the data in the openjpeg decoded data in nb of pixel ) { // Characteristics of the input buffer from openpjeg unsigned int l_x0_src = int_ceildivpow2(currentTile->x0, currentTile->comps->factor); unsigned int l_y0_src = int_ceildivpow2(currentTile->y0, currentTile->comps->factor); unsigned int l_x1_src = int_ceildivpow2(currentTile->x1, currentTile->comps->factor); unsigned int l_y1_src = int_ceildivpow2(currentTile->y1, currentTile->comps->factor); // Size of input buffer from openjpeg l_width_src = l_x1_src - l_x0_src; unsigned int l_height_src = l_y1_src - l_y0_src; // Characteristics of the otb region unsigned int l_x0_dest = ioRegion.GetIndex()[0]; unsigned int l_x1_dest = ioRegion.GetIndex()[0] + ioRegion.GetSize()[0]; unsigned int l_y0_dest = ioRegion.GetIndex()[1]; unsigned int l_y1_dest = ioRegion.GetIndex()[1] + ioRegion.GetSize()[1]; unsigned int l_start_x_dest, l_start_y_dest; unsigned int l_offset_x0_src, l_offset_y0_src; /*-----*/ /* Compute the origin (l_offset_x0_src, l_offset_y0_src ) * of the input buffer (decoded tile) which will be move * in the output buffer. * Compute the area of the output buffer (l_start_x_dest, * l_start_y_dest, l_width_dest, l_height_dest) which will be modified * by this input area. */ if (l_x0_dest < l_x0_src) { l_start_x_dest = l_x0_src - l_x0_dest; l_offset_x0_src = 0; if (l_x1_dest >= l_x1_src) { l_width_dest = l_width_src; } else { l_width_dest = l_x1_dest - l_x0_src; } } else { l_start_x_dest = 0; l_offset_x0_src = l_x0_dest - l_x0_src; if (l_x1_dest >= l_x1_src) { l_width_dest = l_width_src - l_offset_x0_src; } else { l_width_dest = l_x1_dest - l_x0_dest; } } if (l_y0_dest < l_y0_src) { l_start_y_dest = l_y0_src - l_y0_dest; l_offset_y0_src = 0; if (l_y1_dest >= l_y1_src) { l_height_dest = l_height_src; } else { l_height_dest = l_y1_dest - l_y0_src; } } else { l_start_y_dest = 0; l_offset_y0_src = l_y0_dest - l_y0_src; if (l_y1_dest >= l_y1_src) { l_height_dest = l_height_src - l_offset_y0_src; } else { l_height_dest = l_y1_dest - l_y0_dest; } } /*-----*/ /* Compute the input buffer offset */ l_start_offset_src = l_offset_x0_src + l_offset_y0_src * l_width_src; /* Compute the output buffer offset */ l_start_offset_dest = l_start_x_dest + l_start_y_dest * (l_x1_dest - l_x0_dest); /* std::cout << "SRC coordinates: l_start_x_src= " << l_x0_src << ", l_start_y_src= " << l_y0_src << ", l_width_src= " << l_width_src << ", l_height_src= " << l_height_src << std::endl; std::cout << "SRC tile offset: " << l_offset_x0_src << ", " << l_offset_y0_src << std::endl; std::cout << "SRC buffer offset: " << l_start_offset_src << std::endl; std::cout << "DEST coordinates: l_start_x_dest= " << l_start_x_dest << ", l_start_y_dest= " << l_start_y_dest << ", l_width_dest= " << l_width_dest << ", l_height_dest= " << l_height_dest << std::endl; std::cout << "DEST start offset: " << l_start_offset_dest << std::endl; */ } // Not yet implemented bool JPEG2000ImageIO::CanWriteFile(const char* /*filename*/) { return false; } // Not yet implemented void JPEG2000ImageIO::Write(const void* /*buffer*/) { } void JPEG2000ImageIO::WriteImageInformation() { if (m_FileName == "") { itkExceptionMacro(<< "A FileName must be specified."); } if (CanWriteFile(m_FileName.c_str()) == false) { itkExceptionMacro(<< "The file " << m_FileName.c_str() << " is not defined as a JPEG2000 file"); } otbMsgDebugMacro(<< "Driver to write: JPEG2000"); otbMsgDebugMacro(<< " Write file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } } // end namespace otb OTB-release-5.8/Modules/IO/IOJPEG2000/src/otbJPEG2000ImageIOFactory.cxx000066400000000000000000000032571301006202600244150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbJPEG2000ImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbJPEG2000ImageIO.h" #include "itkVersion.h" namespace otb { JPEG2000ImageIOFactory::JPEG2000ImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbJPEG2000ImageIO", "JPEG2000 Image IO", 1, itk::CreateObjectFunction::New()); } JPEG2000ImageIOFactory::~JPEG2000ImageIOFactory() { } const char* JPEG2000ImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* JPEG2000ImageIOFactory::GetDescription() const { return "JPEG2000 ImageIO Factory, allows the loading of JPEG2000 images into insight"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool JPEG2000ImageIOFactoryHasBeenRegistered; void JPEG2000ImageIOFactoryRegister__Private(void) { if( ! JPEG2000ImageIOFactoryHasBeenRegistered ) { JPEG2000ImageIOFactoryHasBeenRegistered = true; JPEG2000ImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOJPEG2000/test/000077500000000000000000000000001301006202600175735ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOJPEG2000/test/CMakeLists.txt000066400000000000000000000050161301006202600223350ustar00rootroot00000000000000otb_module_test() set(OTBIOJPEG2000Tests otbIOJPEG2000TestDriver.cxx otbJPEG2000ImageIOTestCanWrite.cxx otbJPEG2000ImageIOTestCanRead.cxx otbGenerateClassicalQLWithJPEG2000.cxx ) add_executable(otbIOJPEG2000TestDriver ${OTBIOJPEG2000Tests}) target_link_libraries(otbIOJPEG2000TestDriver ${OTBIOJPEG2000-Test_LIBRARIES}) otb_module_target_label(otbIOJPEG2000TestDriver) # Tests Declaration otb_add_test(NAME ioTuJP2ImageIOCanRead COMMAND otbIOJPEG2000TestDriver otbJPEG2000ImageIOTestCanRead LARGEINPUT{JPEG2000/QB_multicomp.jpx} ) otb_add_test(NAME ioTuJ2KImageIOCanRead COMMAND otbIOJPEG2000TestDriver otbJPEG2000ImageIOTestCanRead ${INPUTDATA}/bretagne.j2k ) otb_add_test(NAME ioTvJPEG2000ImageIO_CacheSize_500 COMMAND otbIOJPEG2000TestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioClassicalQLJPEG2K_bretagne.tif ${TEMP}/ioClassicalQLJPEG2K_bretagne_500.tif otbGenerateClassicalQLWithJPEG2000 ${INPUTDATA}/bretagne.j2k ${TEMP}/ioClassicalQLJPEG2K_bretagne_500.tif 500) otb_add_test(NAME ioTvJPEG2000ImageIO_CacheSize_5000 COMMAND otbIOJPEG2000TestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioClassicalQLJPEG2K_bretagne.tif ${TEMP}/ioClassicalQLJPEG2K_bretagne_5000.tif otbGenerateClassicalQLWithJPEG2000 ${INPUTDATA}/bretagne.j2k ${TEMP}/ioClassicalQLJPEG2K_bretagne_5000.tif 5000) otb_add_test(NAME ioTvJPEG2000ImageIO_CacheSize_1000 COMMAND otbIOJPEG2000TestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioClassicalQLJPEG2K_bretagne.tif ${TEMP}/ioClassicalQLJPEG2K_bretagne_1000.tif otbGenerateClassicalQLWithJPEG2000 ${INPUTDATA}/bretagne.j2k ${TEMP}/ioClassicalQLJPEG2K_bretagne_1000.tif 1000) otb_add_test(NAME ioTvJPEG2000ImageIO_CacheSize_25000 COMMAND otbIOJPEG2000TestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioClassicalQLJPEG2K_bretagne.tif ${TEMP}/ioClassicalQLJPEG2K_bretagne_OUT.tif otbGenerateClassicalQLWithJPEG2000 ${INPUTDATA}/bretagne.j2k ${TEMP}/ioClassicalQLJPEG2K_bretagne_OUT.tif) if(OTB_DATA_USE_LARGEINPUT) set( GenericTestPHR_TESTNB 0) foreach( current_file ${GenericTestPHR_DATA_INPUTS} ) list(GET GenericTestPHR_DATA_TYPES ${GenericTestPHR_TESTNB} current_type ) math(EXPR GenericTestPHR_TESTNB "${GenericTestPHR_TESTNB} + 1") string(REGEX MATCH "TIFF" PHR_TIFF_FILE ${current_type}) if(NOT PHR_TIFF_FILE) # CanRead otb_add_test(NAME ioTuJ2KImageIOCanRead_${current_type} COMMAND otbIOJPEG2000TestDriver otbJPEG2000ImageIOTestCanRead ${current_file} ) endif() endforeach() endif() OTB-release-5.8/Modules/IO/IOJPEG2000/test/otbGenerateClassicalQLWithJPEG2000.cxx000066400000000000000000000037171301006202600264460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbStreamingShrinkImageFilter.h" #include "otbJPEG2000ImageIO.h" int otbGenerateClassicalQLWithJPEG2000(int argc, char * argv[]) { char * inputFilename = argv[1]; char * outputFilename = argv[2]; unsigned int cacheSize = 0; if (argc == 4) cacheSize = atoi(argv[3]) * 1000; const unsigned int Dimension = 2; typedef unsigned int PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::StreamingShrinkImageFilter ShrinkType; ReaderType::Pointer reader = ReaderType::New(); ShrinkType::Pointer shrink = ShrinkType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); otb::JPEG2000ImageIO::Pointer imageIO = otb::JPEG2000ImageIO::New(); reader->SetImageIO(imageIO); imageIO->SetCacheSizeInByte(cacheSize); reader->GenerateOutputInformation(); writer->SetFileName(outputFilename); shrink->SetShrinkFactor(10); shrink->SetInput(reader->GetOutput()); shrink->Update(); writer->SetInput(shrink->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOJPEG2000/test/otbIOJPEG2000TestDriver.cxx000066400000000000000000000003101301006202600243110ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbJPEG2000ImageIOTestCanWrite); REGISTER_TEST(otbJPEG2000ImageIOTestCanRead); REGISTER_TEST(otbGenerateClassicalQLWithJPEG2000); } OTB-release-5.8/Modules/IO/IOJPEG2000/test/otbJPEG2000ImageIOTestCanRead.cxx000066400000000000000000000020761301006202600253310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbJPEG2000ImageIO.h" #include "itkMacro.h" #include int otbJPEG2000ImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::JPEG2000ImageIO::Pointer lJPEG2000ImageIO = otb::JPEG2000ImageIO::New(); bool lCanRead = lJPEG2000ImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::JPEG2000ImageIO : impossible to open the image file JPEG2000 " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOJPEG2000/test/otbJPEG2000ImageIOTestCanWrite.cxx000066400000000000000000000021051301006202600255410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbJPEG2000ImageIO.h" #include "itkMacro.h" #include int otbJPEG2000ImageIOTestCanWrite(int itkNotUsed(argc), char* argv[]) { otb::JPEG2000ImageIO::Pointer lJPEG2000ImageIO = otb::JPEG2000ImageIO::New(); bool lCanWrite = lJPEG2000ImageIO->CanWriteFile(argv[1]); if (lCanWrite == false) { std::cerr << "Erreur otb::JPEG2000ImageIO : impossible to create the image file JPEG2000 " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOKML/000077500000000000000000000000001301006202600162105ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOKML/CMakeLists.txt000066400000000000000000000001061301006202600207450ustar00rootroot00000000000000project(OTBIOKML) set(OTBIOKML_LIBRARIES OTBIOKML) otb_module_impl() OTB-release-5.8/Modules/IO/IOKML/include/000077500000000000000000000000001301006202600176335ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOKML/include/otbKMLVectorDataIO.h000066400000000000000000000123441301006202600233450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKMLVectorDataIO_h #define otbKMLVectorDataIO_h #include #include "otbVectorDataIOBase.h" #include "otbVectorData.h" #include "kml/dom/kml_ptr.h" #include "otbVectorDataProjectionFilter.h" namespace kmldom { class KmlFactory; } namespace otb { /** \class KMLVectorDataIO * * \brief ImageIO object for reading/writing KML format vector data * * * \ingroup OTBIOKML */ class ITK_EXPORT KMLVectorDataIO : public VectorDataIOBase { public: /** Standard class typedefs. */ typedef KMLVectorDataIO Self; typedef VectorDataIOBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(KMLVectorDataIO, VectorDataIOBase); /** Byte order typedef */ typedef Superclass::ByteOrder ByteOrder; /** Data typedef */ typedef VectorData VectorDataType; typedef VectorDataType::DataTreeType DataTreeType; typedef DataTreeType::TreeNodeType InternalTreeNodeType; typedef InternalTreeNodeType::ChildrenListType ChildrenListType; typedef DataTreeType::Pointer DataTreePointerType; typedef DataTreeType::ConstPointer DataTreeConstPointerType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::Pointer DataNodePointerType; typedef DataNodeType::PointType PointType; typedef DataNodeType::LineType LineType; typedef LineType::VertexListType VertexListType; typedef VertexListType::ConstPointer VertexListConstPointerType; typedef LineType::Pointer LinePointerType; typedef LineType::VertexType VertexType; typedef DataNodeType::PolygonType PolygonType; typedef PolygonType::Pointer PolygonPointerType; typedef DataNodeType::PolygonListType PolygonListType; typedef PolygonListType::Pointer PolygonListPointerType; typedef VectorDataType::Pointer VectorDataPointerType; typedef VectorDataType::ConstPointer VectorDataConstPointerType; typedef VectorDataProjectionFilter ProjectionFilterType; /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this VectorDataIO can read the * file specified. */ bool CanReadFile(const char*) const ITK_OVERRIDE; /** Reads the data from disk into the data structure provided. */ void Read(itk::DataObject* data) ITK_OVERRIDE; /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this VectorDataIO can read the * file specified. */ bool CanWriteFile(const char*) const ITK_OVERRIDE; /** Writes the data to disk from the data structure provided */ void Write(const itk::DataObject* data, char ** papszOptions = ITK_NULLPTR) ITK_OVERRIDE; protected: /** Constructor.*/ KMLVectorDataIO(); /** Destructor.*/ ~KMLVectorDataIO() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; static const kmldom::FeaturePtr GetRootFeature(const kmldom::ElementPtr& root); static void PrintIndented(const std::string& item, int depth); static void PrintFeature(const kmldom::FeaturePtr& feature, int depth); void WalkGeometry(const kmldom::GeometryPtr& geometry, DataNodePointerType father); void WalkFeature(const kmldom::FeaturePtr& feature, DataNodePointerType father); void WalkContainer(const kmldom::ContainerPtr& container, DataNodePointerType father); /** Conversion tools */ DataNodePointerType ConvertGeometryToPointNode(const kmldom::GeometryPtr& geometry); DataNodePointerType ConvertGeometryToLineStringNode(const kmldom::GeometryPtr& geometry); DataNodePointerType ConvertGeometryToLinearRingNode(const kmldom::GeometryPtr& geometry); DataNodePointerType ConvertGeometryToPolygonNode(const kmldom::GeometryPtr& geometry); /** end conversion tools */ void ProcessNodeWrite(InternalTreeNodeType * source, kmldom::KmlFactory* factory, kmldom::KmlPtr kml, kmldom::DocumentPtr currentDocument, kmldom::FolderPtr currentFolder, kmldom::MultiGeometryPtr currentMultiGeometry); private: KMLVectorDataIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented DataTreePointerType m_Tree; unsigned int m_Kept; }; } // end namespace otb #endif // otbKMLVectorDataIO_h OTB-release-5.8/Modules/IO/IOKML/include/otbKMLVectorDataIOFactory.h000066400000000000000000000037461301006202600247030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKMLVectorDataIOFactory_h #define otbKMLVectorDataIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class KMLVectorDataIOFactory * \brief Creating an instance of a VectorDataImageIO object using object factory. * * \ingroup OTBIOKML */ class ITK_EXPORT KMLVectorDataIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef KMLVectorDataIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(KMLVectorDataIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { KMLVectorDataIOFactory::Pointer KMLFactory = KMLVectorDataIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(KMLFactory); } protected: KMLVectorDataIOFactory(); ~KMLVectorDataIOFactory() ITK_OVERRIDE; private: KMLVectorDataIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOKML/otb-module.cmake000066400000000000000000000004661301006202600212670ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read and write KML format vector data.") otb_module(OTBIOKML DEPENDS OTBVectorDataBase OTBProjection OTBlibkml OTBGDAL OTBCommon OTBOSSIMAdapters OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOKML/src/000077500000000000000000000000001301006202600167775ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOKML/src/CMakeLists.txt000066400000000000000000000005361301006202600215430ustar00rootroot00000000000000set(OTBIOKML_SRC otbKMLVectorDataIO.cxx otbKMLVectorDataIOFactory.cxx ) add_library(OTBIOKML ${OTBIOKML_SRC}) target_link_libraries(OTBIOKML ${OTBVectorDataBase_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBlibkml_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBGDAL_LIBRARIES} ) otb_module_target(OTBIOKML) OTB-release-5.8/Modules/IO/IOKML/src/otbKMLVectorDataIO.cxx000066400000000000000000000641711301006202600230710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMLVectorDataIO.h" #include #include "kml/dom.h" #include "kml/dom/kml22.h" #include "kml/base/file.h" #include "kml/dom/kml_cast.h" #include "kml/engine/kml_file.h" #include "ogrsf_frmts.h" #include "otbMacro.h" #include "otbSystem.h" #include "itksys/SystemTools.hxx" #include "otbDataNode.h" #include "itkPreOrderTreeIterator.h" #include "otbMetaDataKey.h" #include "itkTimeProbe.h" namespace otb { KMLVectorDataIO ::KMLVectorDataIO() : m_Tree(), m_Kept(0) {} KMLVectorDataIO::~KMLVectorDataIO() {} bool KMLVectorDataIO::CanReadFile(const char* filename) const { std::string lFileName(filename); if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } if (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(lFileName)) != ".kml") { return false; } if (kmlbase::File::Exists(lFileName) == false) { return false; } std::string kml; return (kmlbase::File::ReadFileToString(lFileName, &kml)); } // Get the features of the kml file, read into the root const kmldom::FeaturePtr KMLVectorDataIO::GetRootFeature(const kmldom::ElementPtr& root) { const kmldom::KmlPtr kml = kmldom::AsKml(root); if (kml && kml->has_feature()) { return kml->get_feature(); } return kmldom::AsFeature(root); } // Print the selected feature void KMLVectorDataIO::PrintIndented(const std::string& item, int depth) { while (depth--) { std::cout << " "; } std::cout << item << std::endl; } void KMLVectorDataIO::WalkFeature(const kmldom::FeaturePtr& feature, DataNodePointerType father) { DataNodePointerType node = ITK_NULLPTR; if (!feature) return; if (const kmldom::ContainerPtr container = kmldom::AsContainer(feature)) { WalkContainer(container, father); } else if (const kmldom::PlacemarkPtr placemark = kmldom::AsPlacemark(feature)) { WalkGeometry(placemark->get_geometry(), father); } // The Read() method is not exhaustive it is possible to add the read of the "link", // the style (iconStyle, LineStyle...). Then into the containers we also can find the fields : // ... cf. code.google.com/apis/kml/documentation/kmlelementssinmaps.html return; } void KMLVectorDataIO::WalkContainer(const kmldom::ContainerPtr& container, DataNodePointerType father) { DataNodePointerType node = ITK_NULLPTR; for (size_t i = 0; i < container->get_feature_array_size(); ++i) { kmldom::FeaturePtr feature = container->get_feature_array_at(i); switch (feature->Type()) { case kmldom::Type_Document: { DataNodePointerType document = DataNodeType::New(); document->SetNodeType(DOCUMENT); document->SetNodeId(feature->get_id()); if (feature->has_name()) { document->SetFieldAsString("name", feature->get_name()); } m_Tree->Add(document, father); WalkFeature(feature, document); break; } case kmldom::Type_Folder: { DataNodePointerType folder = DataNodeType::New(); folder->SetNodeType(FOLDER); folder->SetNodeId(feature->get_id()); if (feature->has_name()) { folder->SetFieldAsString("name", feature->get_name()); } m_Tree->Add(folder, father); WalkFeature(feature, folder); break; } case kmldom::Type_GroundOverlay: { WalkFeature(feature, father); break; } case kmldom::Type_NetworkLink: { WalkFeature(feature, father); break; } case kmldom::Type_PhotoOverlay: { WalkFeature(feature, father); break; } case kmldom::Type_Placemark: { // We just ignore placemarks WalkFeature(feature, father); break; } case kmldom::Type_ScreenOverlay: { WalkFeature(feature, father); break; } default: break; } } return; } // Walk through a geometry and create a GeometryNode void KMLVectorDataIO::WalkGeometry(const kmldom::GeometryPtr& geometry, DataNodePointerType father) { // Creation of a node DataNodePointerType node = ITK_NULLPTR; if (!geometry) { return; } // Create a Node with the Geometry type. switch (geometry->Type()) { case kmldom::Type_Point: { node = ConvertGeometryToPointNode(geometry); m_Tree->Add(node, father); break; } case kmldom::Type_LineString: { node = ConvertGeometryToLineStringNode(geometry); m_Tree->Add(node, father); break; } case kmldom::Type_LinearRing: { node = ConvertGeometryToLinearRingNode(geometry); m_Tree->Add(node, father); break; } case kmldom::Type_Polygon: { node = ConvertGeometryToPolygonNode(geometry); m_Tree->Add(node, father); break; } case kmldom::Type_MultiGeometry: { // this case is treated downer break; } case kmldom::Type_Model: { break; } default: // KML has 6 types of Geometry. break; } // Recurse into . if (const kmldom::MultiGeometryPtr multigeometry = kmldom::AsMultiGeometry(geometry)) { DataNodePointerType multi = DataNodeType::New(); multi->SetNodeType(FEATURE_COLLECTION); m_Tree->Add(multi, father); for (size_t i = 0; i < multigeometry->get_geometry_array_size(); ++i) { WalkGeometry(multigeometry->get_geometry_array_at(i), multi); } } return; } KMLVectorDataIO ::DataNodePointerType KMLVectorDataIO ::ConvertGeometryToPointNode(const kmldom::GeometryPtr& geometry) { if (geometry == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Failed to convert kmldom::GeometryPtr to PointNode"); } const kmldom::PointPtr pt = kmldom::AsPoint(geometry); PointType otbPoint; otbPoint.Fill(0); otbPoint[0] = static_cast(pt->get_coordinates()->get_coordinates_array_at( 0).get_longitude()); otbPoint[1] = static_cast(pt->get_coordinates()->get_coordinates_array_at( 0).get_latitude()); if (DataNodeType::Dimension > 2) { otbPoint[2] = static_cast(pt->get_coordinates()->get_coordinates_array_at( 0).get_altitude()); } DataNodePointerType node = DataNodeType::New(); node->SetPoint(otbPoint); return node; } KMLVectorDataIO ::DataNodePointerType KMLVectorDataIO ::ConvertGeometryToLineStringNode(const kmldom::GeometryPtr& geometry) { if (geometry == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Failed to convert kmldom::GeometryPtr to LineNode"); } const kmldom::LineStringPtr ls = kmldom::AsLineString(geometry); const kmldom::CoordinatesPtr coords = ls->get_coordinates(); int array_size = coords->get_coordinates_array_size(); LinePointerType line = LineType::New(); for (int i = 0; i < array_size; ++i) { LineType::VertexType vertex; vertex[0] = coords->get_coordinates_array_at(i).get_longitude(); vertex[1] = coords->get_coordinates_array_at(i).get_latitude(); if (DataNodeType::Dimension > 2) { vertex[2] = coords->get_coordinates_array_at(i).get_altitude(); } line->AddVertex(vertex); } DataNodePointerType node = DataNodeType::New(); node->SetLine(line); return node; } KMLVectorDataIO ::DataNodePointerType KMLVectorDataIO ::ConvertGeometryToLinearRingNode(const kmldom::GeometryPtr& geometry) { if (geometry == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Failed to convert kmldom::GeometryPtr to LineNode"); } const kmldom::LinearRingPtr lr = kmldom::AsLinearRing(geometry); const kmldom::CoordinatesPtr coords = lr->get_coordinates(); int array_size = coords->get_coordinates_array_size(); LinePointerType line = LineType::New(); for (int i = 0; i < array_size; ++i) { LineType::VertexType vertex; vertex[0] = coords->get_coordinates_array_at(i).get_longitude(); vertex[1] = coords->get_coordinates_array_at(i).get_latitude(); if (DataNodeType::Dimension > 2) { vertex[2] = coords->get_coordinates_array_at(i).get_altitude(); } line->AddVertex(vertex); } DataNodePointerType node = DataNodeType::New(); node->SetLine(line); return node; } KMLVectorDataIO ::DataNodePointerType KMLVectorDataIO ::ConvertGeometryToPolygonNode(const kmldom::GeometryPtr& geometry) { if (geometry == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Failed to convert kmldom::GeometryPtr to LineNode"); } // Get the polygon const kmldom::PolygonPtr polygonKml = kmldom::AsPolygon(geometry); PolygonPointerType extRing = PolygonType::New(); PolygonListPointerType intRings = PolygonListType::New(); // Read the outerboundaryis of the polygon if (polygonKml->has_outerboundaryis()) { const kmldom::OuterBoundaryIsPtr outerboundaryis = polygonKml->get_outerboundaryis(); if (outerboundaryis->has_linearring()) { const kmldom::LinearRingPtr lr = outerboundaryis->get_linearring(); const kmldom::CoordinatesPtr coords = lr->get_coordinates(); int array_size = coords->get_coordinates_array_size(); for (int i = 0; i < array_size; ++i) { PolygonType::VertexType vertex; vertex[0] = coords->get_coordinates_array_at(i).get_longitude(); vertex[1] = coords->get_coordinates_array_at(i).get_latitude(); if (DataNodeType::Dimension > 2) { vertex[2] = coords->get_coordinates_array_at(i).get_altitude(); } extRing->AddVertex(vertex); } } } // Read the innerboundaryis of the polygon for (unsigned int intRingIndex = 0; intRingIndex < polygonKml->get_innerboundaryis_array_size(); ++intRingIndex) { const kmldom::InnerBoundaryIsPtr innerboundaryis = polygonKml->get_innerboundaryis_array_at(intRingIndex); if (innerboundaryis->has_linearring()) { const kmldom::LinearRingPtr lr = innerboundaryis->get_linearring(); const kmldom::CoordinatesPtr coords = lr->get_coordinates(); int array_size = coords->get_coordinates_array_size(); PolygonPointerType ring = PolygonType::New(); for (int pIndex = 0; pIndex < array_size; ++pIndex) { PolygonType::VertexType vertex; vertex[0] = coords->get_coordinates_array_at(pIndex).get_longitude(); vertex[1] = coords->get_coordinates_array_at(pIndex).get_latitude(); if (DataNodeType::Dimension > 2) { vertex[2] = coords->get_coordinates_array_at(pIndex).get_altitude(); } ring->AddVertex(vertex); } intRings->PushBack(ring); } } DataNodePointerType node = DataNodeType::New(); node->SetPolygonExteriorRing(extRing); node->SetPolygonInteriorRings(intRings); return node; } // Used to print information about this object void KMLVectorDataIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // Read vector data void KMLVectorDataIO ::Read(itk::DataObject* datag) { VectorDataPointerType data = dynamic_cast(datag); if(!data) { itkExceptionMacro(<< "Dynamic cast error: data to write is not of type otb::VectorData (this should never happen)."); } std::string kml; bool status = kmlbase::File::ReadFileToString(this->m_FileName, &kml); if (status == false) { itkExceptionMacro(<< "Failed to open KML data file " << this->m_FileName); } otbMsgDevMacro(<< "Driver to read: KML"); otbMsgDevMacro(<< "Reading file: " << this->m_FileName); // Parse the file. std::string errors; kmldom::ElementPtr root = kmldom::Parse(kml, &errors); if (!root) itkExceptionMacro(<< "Failed to open KML data file " << errors); //Fill up projection information //for KML files, this is geographic coordinates std::string projectionRef = "GEOGCS[\"GCS_WGS_1984\", DATUM[\"WGS_1984\", SPHEROID[\"WGS_1984\", 6378137, 298.257223563]], PRIMEM[\"Greenwich\", 0], UNIT[\"Degree\", 0.017453292519943295]]"; itk::MetaDataDictionary& dict = data->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, projectionRef); const kmldom::FeaturePtr feature = GetRootFeature(root); if (!feature) itkExceptionMacro(<< "No root feature"); // Retrieving root node m_Tree = data->GetDataTree(); DataNodePointerType rootNode = m_Tree->GetRoot()->Get(); DataNodePointerType document = DataNodeType::New(); document->SetNodeType(DOCUMENT); m_Tree->Add(document, rootNode); // Walk Feature (get the Placemarks... and walk into them) //ENGLISH ?? WalkFeature(feature, document); // std::cout<< m_Tree <(datag); VectorDataConstPointerType data = data_in; if(!data) { itkExceptionMacro(<< "Dynamic cast error: data to write is not of type otb::VectorData (this should never happen)."); } std::string projectionRefWkt = data->GetProjectionRef(); OGRSpatialReferenceH oSRS = OSRNewSpatialReference(projectionRefWkt.c_str()); if (!OSRIsGeographic(oSRS)) { itkWarningMacro(<< "Vector data should be reprojected in geographic coordinates" << " before saving to KML. You may use the otbVectorDataProjectionFilter. " << " The projection information is currently: " << projectionRefWkt << "\n We will do the projection for you in WGS84 coordinates."); ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New(); projectionFilter->SetInput(data_in); projectionFilter->Update(); data = projectionFilter->GetOutput(); } OSRRelease(oSRS); m_Kept = 0; //Create the factory kmldom::KmlFactory* factory = kmldom::KmlFactory::GetFactory(); if (factory == ITK_NULLPTR) { itkExceptionMacro(<< "Impossible to create the KML Factory to write file " << this->m_FileName); } kmldom::KmlPtr kml = factory->CreateKml(); // Retrieving root node DataTreeConstPointerType tree = data->GetDataTree(); DataNodePointerType root = tree->GetRoot()->Get(); typedef itk::PreOrderTreeIterator TreeIteratorType; TreeIteratorType it(tree); it.GoToBegin(); kmldom::DocumentPtr currentDocument = ITK_NULLPTR; kmldom::FolderPtr currentFolder = ITK_NULLPTR; kmldom::MultiGeometryPtr currentMultiGeometry = ITK_NULLPTR; InternalTreeNodeType * inputRoot = const_cast(tree->GetRoot()); ProcessNodeWrite(inputRoot, factory, kml, currentDocument, currentFolder, currentMultiGeometry); // Serialize to XML std::string xml = kmldom::SerializePretty(kml); // Write it // kmlbase::File::WriteStringToFile(xml, this->m_FileName); kmlengine::KmlFilePtr kml_file = kmlengine::KmlFile::CreateFromString(xml); std::string output; kml_file->SerializeToString(&output); std::ofstream fout; fout.open(this->m_FileName.c_str()); fout << output; fout.close(); // Eventually print it //std::cout << xml; chrono.Stop(); otbMsgDevMacro(<< "KMLVectorDataIO: file saved in " << chrono.GetMean() << " seconds. (" << m_Kept << " elements)" ); otbMsgDevMacro(<< " KMLVectorDataIO::Write() "); } void KMLVectorDataIO::ProcessNodeWrite(InternalTreeNodeType * source, kmldom::KmlFactory* factory, kmldom::KmlPtr kml, kmldom::DocumentPtr currentDocument, kmldom::FolderPtr currentFolder, kmldom::MultiGeometryPtr currentMultiGeometry) { // Note that we force a precise structure when we write a kml file. // We will necessary have a that will contain a . // And in a folder there automatically will be one or several . // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // std::cout << "Found " << children.size() << " children" << std::endl; // For each child for (ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { DataNodePointerType dataNode = (*it)->Get(); // std::cout << "Processing " << dataNode->GetNodeType() << " with Id: " << dataNode->GetNodeId() << std::endl; ++m_Kept; switch (dataNode->GetNodeType()) { case ROOT: { break; } case DOCUMENT: { kmldom::DocumentPtr document = factory->CreateDocument(); if (dataNode->HasField("name")) { std::string fieldname = dataNode->GetFieldAsString("name"); document->set_name(fieldname); } kml->set_feature(document); currentDocument = document; ProcessNodeWrite(*it, factory, kml, currentDocument, currentFolder, currentMultiGeometry); break; } case FOLDER: { kmldom::FolderPtr folder = factory->CreateFolder(); std::string fieldname = dataNode->GetFieldAsString("name"); folder->set_name(fieldname); currentDocument->add_feature(folder); currentFolder = folder; ProcessNodeWrite(*it, factory, kml, currentDocument, currentFolder, currentMultiGeometry); break; } case FEATURE_POINT: { // Create kmldom::CoordinatesPtr coordinates = factory->CreateCoordinates(); PointType pointCoord = dataNode->GetPoint(); if (DataNodeType::Dimension > 2) { coordinates->add_latlngalt(pointCoord[1], pointCoord[0], pointCoord[2]); } else { coordinates->add_latlng(pointCoord[1], pointCoord[0]); } // Create and give it . kmldom::PointPtr point = factory->CreatePoint(); point->set_coordinates(coordinates); if (currentMultiGeometry != ITK_NULLPTR) { currentMultiGeometry->add_geometry(point); } else { kmldom::PlacemarkPtr placemark = factory->CreatePlacemark(); placemark->set_geometry(point); if (currentFolder != ITK_NULLPTR) { currentFolder->add_feature(placemark); } else { currentDocument->add_feature(placemark); } } break; } case FEATURE_LINE: { VertexListConstPointerType vertexList = dataNode->GetLine()->GetVertexList(); // Create kmldom::CoordinatesPtr coordinates = factory->CreateCoordinates(); kmldom::LineStringPtr line = factory->CreateLineString(); VertexListType::ConstIterator vIt = vertexList->Begin(); while (vIt != vertexList->End()) { VertexType pointCoord = vIt.Value(); if (DataNodeType::Dimension > 2) { coordinates->add_latlngalt(pointCoord[1], pointCoord[0], pointCoord[2]); } else { coordinates->add_latlng(pointCoord[1], pointCoord[0]); } line->set_coordinates(coordinates); ++vIt; } if (currentMultiGeometry != ITK_NULLPTR) { currentMultiGeometry->add_geometry(line); } else { kmldom::PlacemarkPtr placemark = factory->CreatePlacemark(); placemark->set_geometry(line); if (currentFolder != ITK_NULLPTR) { currentFolder->add_feature(placemark); } else { currentDocument->add_feature(placemark); } } break; } case FEATURE_POLYGON: { //TODO refine the solution of drawing the polygon 1m above the ground // In a polygon we just can find any LinearRings kmldom::LinearRingPtr line = factory->CreateLinearRing(); kmldom::PolygonPtr polygon = factory->CreatePolygon(); polygon->set_extrude(true); polygon->set_altitudemode(1); //ALTITUDEMODE_RELATIVETOGROUND kmldom::CoordinatesPtr coordinates = factory->CreateCoordinates(); kmldom::OuterBoundaryIsPtr outerboundaryis = factory->CreateOuterBoundaryIs(); kmldom::InnerBoundaryIsPtr innerboundaryis = factory->CreateInnerBoundaryIs(); VertexListConstPointerType vertexList = dataNode->GetPolygonExteriorRing()->GetVertexList(); VertexListType::ConstIterator vIt = vertexList->Begin(); if (vIt == vertexList->End()) { itkExceptionMacro(<< "Polygon is empty"); } while (vIt != vertexList->End()) { VertexType pointCoord1 = vIt.Value(); if (DataNodeType::Dimension > 2) { coordinates->add_latlngalt(pointCoord1[1], pointCoord1[0], pointCoord1[2] + 1); //Drawing polygon 1m above ground to avoid z-buffer issues } else { coordinates->add_latlngalt(pointCoord1[1], pointCoord1[0], 1); //Drawing polygon 1m above ground to avoid z-buffer issues } line->set_coordinates(coordinates); ++vIt; } //Adding the first point again to close the polygon vIt = vertexList->Begin(); VertexType pointCoord2 = vIt.Value(); if (DataNodeType::Dimension > 2) { coordinates->add_latlngalt(pointCoord2[1], pointCoord2[0], pointCoord2[2] + 1); //Drawing polygon 1m above ground to avoid z-buffer issues } else { coordinates->add_latlngalt(pointCoord2[1], pointCoord2[0], 1); //Drawing polygon 1m above ground to avoid z-buffer issues } line->set_coordinates(coordinates); outerboundaryis->set_linearring(line); polygon->set_outerboundaryis(outerboundaryis); // Retrieving internal rings as well for (PolygonListType::Iterator pIt = dataNode->GetPolygonInteriorRings()->Begin(); pIt != dataNode->GetPolygonInteriorRings()->End(); ++pIt) { vertexList = pIt.Get()->GetVertexList(); vIt = vertexList->Begin(); while (vIt != vertexList->End()) { vIt = vertexList->Begin(); VertexType pointCoord3 = vIt.Value(); if (DataNodeType::Dimension > 2) { coordinates->add_latlngalt(pointCoord3[1], pointCoord3[0], pointCoord3[2] + 1); //Drawing polygon 1m above ground to avoid z-buffer issues } else { coordinates->add_latlngalt(pointCoord3[1], pointCoord3[0], 1); //Drawing polygon 1m above ground to avoid z-buffer issues } line->set_coordinates(coordinates); ++vIt; } //Adding the first point again to close the polygon vIt = vertexList->Begin(); VertexType pointCoord4 = vIt.Value(); if (DataNodeType::Dimension > 2) { coordinates->add_latlngalt(pointCoord4[1], pointCoord4[0], pointCoord4[2] + 1); //Drawing polygon 1m above ground to avoid z-buffer issues } else { coordinates->add_latlngalt(pointCoord4[1], pointCoord4[0], 1); //Drawing polygon 1m above ground to avoid z-buffer issues } line->set_coordinates(coordinates); ++vIt; innerboundaryis->set_linearring(line); polygon->add_innerboundaryis(innerboundaryis); innerboundaryis->clear_linearring(); } if (currentMultiGeometry != ITK_NULLPTR) { currentMultiGeometry->add_geometry(polygon); } else { kmldom::PlacemarkPtr placemark = factory->CreatePlacemark(); placemark->set_geometry(polygon); if (currentFolder != ITK_NULLPTR) { currentFolder->add_feature(placemark); } else { currentDocument->add_feature(placemark); } } break; } // MultiGeometry case FEATURE_COLLECTION: { kmldom::MultiGeometryPtr multi = factory->CreateMultiGeometry(); currentMultiGeometry = multi; kmldom::PlacemarkPtr placemark = factory->CreatePlacemark(); placemark->set_geometry(multi); if (currentFolder != ITK_NULLPTR) { currentFolder->add_feature(placemark); } else { currentDocument->add_feature(placemark); } ProcessNodeWrite(*it, factory, kml, currentDocument, currentFolder, currentMultiGeometry); break; } default: break; } // end switch } // end for } } // end namespace otb OTB-release-5.8/Modules/IO/IOKML/src/otbKMLVectorDataIOFactory.cxx000066400000000000000000000027141301006202600244140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMLVectorDataIOFactory.h" #include "itkCreateObjectFunction.h" #include "itkVersion.h" #include "otbKMLVectorDataIO.h" namespace otb { KMLVectorDataIOFactory::KMLVectorDataIOFactory() { static std::string classOverride = std::string("otbVectorDataIOBase"); static std::string subclass = std::string("otbKMLVectorDataIO"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "KML Vectordata IO", 1, itk::CreateObjectFunction::New()); } KMLVectorDataIOFactory::~KMLVectorDataIOFactory() {} const char* KMLVectorDataIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* KMLVectorDataIOFactory::GetDescription() const { return "KML VectorDataIO Factory, allows the loading of KML vector data into OTB"; } } // end namespace otb OTB-release-5.8/Modules/IO/IOKML/test/000077500000000000000000000000001301006202600171675ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOKML/test/CMakeLists.txt000066400000000000000000000024211301006202600217260ustar00rootroot00000000000000otb_module_test() set(OTBIOKMLTests otbIOKMLTestDriver.cxx otbKMLVectorDataIONew.cxx otbKMLVectorDataIOTestFileReader.cxx otbKMLVectorDataIOTestCanWrite.cxx otbKMLVectorDataIOTestCanRead.cxx ) add_executable(otbIOKMLTestDriver ${OTBIOKMLTests}) target_link_libraries(otbIOKMLTestDriver ${OTBIOKML-Test_LIBRARIES}) otb_module_target_label(otbIOKMLTestDriver) # Tests Declaration otb_add_test(NAME ioTuKMLVectorDataIO COMMAND otbIOKMLTestDriver otbKMLVectorDataIONew ) otb_add_test(NAME ioTvKMLVectorDataIOFileReaderExample COMMAND otbIOKMLTestDriver otbKMLVectorDataIOTestFileReader ${INPUTDATA}/MODIS20040214212340.kml ${TEMP}/MODIS20040214212340.kml) otb_add_test(NAME ioTvKMLVectorDataIOFileReaderMultiGeom COMMAND otbIOKMLTestDriver otbKMLVectorDataIOTestFileReader ${INPUTDATA}/multigeometry.kml ${TEMP}/multigeometry.kml) otb_add_test(NAME ioTvKMLVectorDataIOFileReaderLines COMMAND otbIOKMLTestDriver otbKMLVectorDataIOTestFileReader ${INPUTDATA}/lines.kml ${TEMP}/lines.kml) otb_add_test(NAME ioTuKMLVectorDataIOCanWrite COMMAND otbIOKMLTestDriver otbKMLVectorDataIOTestCanWrite ${TEMP}/MODIS20040214212340.kml) otb_add_test(NAME ioTuKMLVectorDataIOCanRead COMMAND otbIOKMLTestDriver otbKMLVectorDataIOTestCanRead ${INPUTDATA}/MODIS20040214212340.kml) OTB-release-5.8/Modules/IO/IOKML/test/otbIOKMLTestDriver.cxx000066400000000000000000000003561301006202600233130ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbKMLVectorDataIONew); REGISTER_TEST(otbKMLVectorDataIOTestFileReader); REGISTER_TEST(otbKMLVectorDataIOTestCanWrite); REGISTER_TEST(otbKMLVectorDataIOTestCanRead); } OTB-release-5.8/Modules/IO/IOKML/test/otbKMLVectorDataIONew.cxx000066400000000000000000000015351301006202600237260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMLVectorDataIO.h" int otbKMLVectorDataIONew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::KMLVectorDataIO KMLVectorDataIOType; KMLVectorDataIOType::Pointer object = KMLVectorDataIOType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOKML/test/otbKMLVectorDataIOTestCanRead.cxx000066400000000000000000000020611301006202600253250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMLVectorDataIO.h" #include int otbKMLVectorDataIOTestCanRead(int itkNotUsed(argc), char* argv[]) { typedef otb::KMLVectorDataIO KMLVectorDataIOType; KMLVectorDataIOType::Pointer object = KMLVectorDataIOType::New(); bool lCanRead = object->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::KMLVectorDataIO : impossible to open the file " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOKML/test/otbKMLVectorDataIOTestCanWrite.cxx000066400000000000000000000020671301006202600255520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMLVectorDataIO.h" #include int otbKMLVectorDataIOTestCanWrite(int itkNotUsed(argc), char* argv[]) { typedef otb::KMLVectorDataIO KMLVectorDataIOType; KMLVectorDataIOType::Pointer object = KMLVectorDataIOType::New(); bool lCanWrite = object->CanWriteFile(argv[1]); if (lCanWrite == false) { std::cerr << "Erreur otb::KMLVectorDataIO : impossible to create the file " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOKML/test/otbKMLVectorDataIOTestFileReader.cxx000066400000000000000000000026701301006202600260400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMLVectorDataIO.h" #include int otbKMLVectorDataIOTestFileReader(int argc, char* argv[]) { typedef otb::VectorData<> VectorDataType; typedef otb::KMLVectorDataIO KMLVectorDataIOType; typedef VectorDataType::Pointer VectorDataPointerType; KMLVectorDataIOType::Pointer object = KMLVectorDataIOType::New(); VectorDataPointerType data = VectorDataType::New(); bool lCanRead = object->CanReadFile(argv[1]); if (lCanRead == false) { return EXIT_FAILURE; } object->SetFileName(argv[1]); object->Read(data); VectorDataType::ConstPointer constData = static_cast(data); if (argc > 2) { bool lCanWrite = object->CanWriteFile(argv[2]); if (lCanWrite == false) { return EXIT_FAILURE; } object->SetFileName(argv[2]); object->Write(constData); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOLUM/000077500000000000000000000000001301006202600162225ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOLUM/CMakeLists.txt000066400000000000000000000001061301006202600207570ustar00rootroot00000000000000project(OTBIOLUM) set(OTBIOLUM_LIBRARIES OTBIOLUM) otb_module_impl() OTB-release-5.8/Modules/IO/IOLUM/include/000077500000000000000000000000001301006202600176455ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOLUM/include/otbLUMImageIO.h000066400000000000000000000137521301006202600223630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLUMImageIO_h #define otbLUMImageIO_h #include "otbImageIOBase.h" #include #include #include namespace otb { /** \class LUMImageIO * * \brief ImageIO object for reading (not writing) LUM format images * * The streaming read is implemented. * * \ingroup IOFilters * * * \ingroup OTBIOLUM */ class ITK_EXPORT LUMImageIO : public otb::ImageIOBase { public: /** Standard class typedefs. */ typedef LUMImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Byte order typedef */ typedef Superclass::ByteOrder ByteOrder; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LUMImageIO, otb::ImageIOBase); /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Reads 3D data from multiple files assuming one slice per file. */ virtual void ReadVolume(void* buffer); /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; // JULIEN: NOT USED, NOT IMPLEMENTED //void SampleImage(void* buffer, int XBegin, int YBegin, int SizeXRead, int SizeYRead, int XSample, int YSample); /** Get the number of overviews available into the file specified * This imageIO didn't support overviews */ unsigned int GetOverviewsCount() ITK_OVERRIDE { // MANTIS-1154: Source image is always considered as the best // resolution overview. return 1; } /** Get information about overviews available into the file specified * This imageIO didn't support overviews */ std::vector GetOverviewsInfo() ITK_OVERRIDE { std::vector desc; return desc; } /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} protected: /** Constructor.*/ LUMImageIO(); /** Destructor.*/ ~LUMImageIO() ITK_OVERRIDE; bool OpenOneraDataFileForReading(const char* filename); bool OpenOneraHeaderFileForReading(const char* filename); void InternalReadImageInformation(); bool OpenOneraDataFileForWriting(const char* filename); bool OpenOneraHeaderFileForWriting(const char* filename); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LUMImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Internal method to read header information */ bool InternalReadHeaderInformation(std::fstream& file, const bool reportError); /** This method get the LUM type */ int CaiGetTypeLum(const char * type_code, std::string& str_sens_code, int& inbbits, std::string& str_cod_pix); #define otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ { \ typedef itk::ByteSwapper InternalByteSwapperType; \ if (m_ByteOrder != m_FileByteOrder) \ { \ if (m_ByteOrder == LittleEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToBigEndian((StrongType *) buffer, buffer_size); \ } \ else if (m_ByteOrder == BigEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToLittleEndian((StrongType *) buffer, buffer_size); \ } \ } \ } #define otbSwappFileToSystemMacro(StrongType, WeakType, buffer, buffer_size) \ else if (this->GetComponentType() == WeakType) \ { \ otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ } #define otbSetTypeLumMacro(WeakType, CAI_VALUE_BE, CAI_VALUE_LE) \ else if (this->GetComponentType() == WeakType) \ { \ if (m_ByteOrder == LittleEndian) \ { \ m_TypeLum = CAI_VALUE_LE; \ } \ else \ { \ m_TypeLum = CAI_VALUE_BE; \ } \ } bool m_FlagWriteImageInformation; std::vector m_CaiLumTyp; //used for read std::string m_TypeLum; //used for write otb::ImageIOBase::ByteOrder m_FileByteOrder; std::fstream m_File; }; } // end namespace otb #endif // otbLUMImageIO_h OTB-release-5.8/Modules/IO/IOLUM/include/otbLUMImageIOFactory.h000066400000000000000000000040021301006202600236770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLUMImageIOFactory_h #define otbLUMImageIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class LUMImageIOFactory * \brief Creation d'un instance d'un objet LUMImageIO utilisant les object factory. * * \ingroup OTBIOLUM */ class ITK_EXPORT LUMImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef LUMImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static LUMImageIOFactory * FactoryNew() { return new LUMImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(LUMImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { LUMImageIOFactory::Pointer LUMFactory = LUMImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(LUMFactory); } protected: LUMImageIOFactory(); ~LUMImageIOFactory() ITK_OVERRIDE; private: LUMImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOLUM/otb-module.cmake000066400000000000000000000003411301006202600212710ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read LUM format images.") otb_module(OTBIOLUM DEPENDS OTBImageBase OTBCommon OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOLUM/src/000077500000000000000000000000001301006202600170115ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOLUM/src/CMakeLists.txt000066400000000000000000000003421301006202600215500ustar00rootroot00000000000000set(OTBIOLUM_SRC otbLUMImageIOFactory.cxx otbLUMImageIO.cxx ) add_library(OTBIOLUM ${OTBIOLUM_SRC}) target_link_libraries(OTBIOLUM ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBIOLUM) OTB-release-5.8/Modules/IO/IOLUM/src/otbLUMImageIO.cxx000066400000000000000000000370421301006202600221000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLUMImageIO.h" #include "itkByteSwapper.h" #include "otbSystem.h" #include "itksys/SystemTools.hxx" #include "otbMacro.h" namespace otb { LUMImageIO::LUMImageIO() { // By default set number of dimensions to two. this->SetNumberOfDimensions(2); m_PixelType = SCALAR; m_ComponentType = UCHAR; if (itk::ByteSwapper::SystemIsLittleEndian() == true) { m_ByteOrder = LittleEndian; } else { m_ByteOrder = BigEndian; } m_FileByteOrder = BigEndian; // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to [0.5 , 0.5] // (consistency between ImageIO, see Mantis #942) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_FlagWriteImageInformation = true; //Definition of CAI image type m_CaiLumTyp.clear(); m_CaiLumTyp.push_back("BI"); m_CaiLumTyp.push_back("LI"); m_CaiLumTyp.push_back("BU"); m_CaiLumTyp.push_back("LU"); m_CaiLumTyp.push_back("FLOA"); m_CaiLumTyp.push_back("FLOL"); m_CaiLumTyp.push_back("R8B"); m_CaiLumTyp.push_back("R8L"); this->AddSupportedWriteExtension(".lum"); this->AddSupportedWriteExtension(".LUM"); this->AddSupportedReadExtension(".lum"); this->AddSupportedReadExtension(".LUM"); } LUMImageIO::~LUMImageIO() { if (m_File.is_open()) { m_File.close(); } } bool LUMImageIO::CanReadFile(const char* filename) { std::string lFileName(filename); // Test the extension std::string extension = itksys::SystemTools::GetFilenameLastExtension(filename); if ((extension != ".LUM") && (extension != ".lum")) { return false; } if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } if (m_File.is_open()) { m_File.close(); } std::fstream header_file; header_file.open(filename, std::ios::in | std::ios::binary); if (header_file.fail()) { otbMsgDevMacro(<< "LUMImageIO::CanReadFile() failed header open ! "); return false; } //Read header information bool lResult = InternalReadHeaderInformation(header_file, false); header_file.close(); return (lResult); } // Used to print information about this object void LUMImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // Read a 3D image (or event more bands)... not implemented yet void LUMImageIO::ReadVolume(void*) { } // Read image void LUMImageIO::Read(void* buffer) { char * p = static_cast(buffer); int lNbLines = this->GetIORegion().GetSize()[1]; int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] otbMsgDevMacro(<< " LUMImageIO::Read() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); std::streamoff headerLength = static_cast(this->GetComponentSize() * m_Dimensions[0]); std::streamoff numberOfBytesPerLines = headerLength; std::streamoff offset; std::streamsize numberOfBytesToBeRead = static_cast(this->GetComponentSize() * lNbColumns); std::streamsize numberOfBytesRead; std::streamsize cpt = 0; for (int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(this->GetComponentSize() * lFirstColumn); m_File.seekg(offset, std::ios::beg); m_File.read(static_cast(p + cpt), numberOfBytesToBeRead); numberOfBytesRead = m_File.gcount(); #ifdef __APPLE_CC__ // fail() is broken in the Mac. It returns true when reaches eof(). if (numberOfBytesRead != numberOfBytesToBeRead) #else if ((numberOfBytesRead != numberOfBytesToBeRead) || m_File.fail()) #endif { itkExceptionMacro(<< "LUMImageIO::Read() Can Read the specified Region"); // read failed } cpt += numberOfBytesToBeRead; } unsigned long numberOfPixelsPerLines = lNbLines * lNbColumns; // Swap bytes if necessary if (0) {} otbSwappFileToSystemMacro(unsigned short, USHORT, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(short, SHORT, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(char, CHAR, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(unsigned char, UCHAR, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(unsigned int, UINT, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(int, INT, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(long, LONG, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(unsigned long, ULONG, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(float, FLOAT, buffer, numberOfPixelsPerLines) otbSwappFileToSystemMacro(double, DOUBLE, buffer, numberOfPixelsPerLines) else { itkExceptionMacro(<< "LUMImageIO::Read() undefined component type! "); } } void LUMImageIO::ReadImageInformation() { if (m_File.is_open()) { m_File.close(); } m_File.open(m_FileName.c_str(), std::ios::in | std::ios::binary); if (m_File.fail()) { itkExceptionMacro(<< "LUMImageIO::ReadImageInformation() failed header open ! "); } //Read header information InternalReadHeaderInformation(m_File, true); otbMsgDebugMacro(<< "Driver to read: LUM"); otbMsgDebugMacro(<< " Read file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } bool LUMImageIO::InternalReadHeaderInformation(std::fstream& file, const bool reportError) { std::string lStrTypeImage; std::string lStrCodePix; std::string lStrTypeMachine; int lNbBits(-1); char TypeCode[5]; file.seekg(8, std::ios::beg); file.read((char*) (TypeCode), 4); TypeCode[4] = '\0'; int lTaille = CaiGetTypeLum(TypeCode, lStrTypeImage, lNbBits, lStrCodePix); if (lTaille == -1) { if (reportError == true) { itkExceptionMacro(<< "LUM : bad read of header information"); } else { return false; } } //Set file byte order if (lStrTypeImage == "BE") { m_FileByteOrder = BigEndian; } else { m_FileByteOrder = LittleEndian; } if (lStrCodePix == "OCT") { SetComponentType(CHAR); } else if (lStrCodePix == "UOCT") { SetComponentType(UCHAR); } else if (lStrCodePix == "I2") { SetComponentType(SHORT); } else if (lStrCodePix == "UI2") { SetComponentType(USHORT); } else if (lStrCodePix == "I4") { SetComponentType(INT); } else if (lStrCodePix == "UI4") { SetComponentType(UINT); } else if (lStrCodePix == "R4") { SetComponentType(FLOAT); } else if (lStrCodePix == "R8") { SetComponentType(DOUBLE); } else { if (reportError == true) { itkExceptionMacro(<< "LUM : impossible to determine CodePix information of the image"); } else { return false; } } int NbCol(-1); int NbLig(-1); //Read image dimensions file.seekg(0, std::ios::beg); file.read((char*) (&NbCol), 4); file.read((char*) (&NbLig), 4); //Swapp if necessary otbSwappFileOrderToSystemOrderMacro(int, &NbCol, 1); otbSwappFileOrderToSystemOrderMacro(int, &NbLig, 1); //Initialization of image information m_Dimensions[0] = NbCol; m_Dimensions[1] = NbLig; this->SetNumberOfComponents(1); this->SetFileTypeToBinary(); this->SetNumberOfDimensions(2); return (true); } bool LUMImageIO::CanWriteFile(const char* filename) { std::string lFileName(filename); std::string extension = itksys::SystemTools::GetFilenameLastExtension(filename); if ((extension != ".LUM") && (extension != ".lum")) { return false; } if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } const std::string Extension = itksys::SystemTools::GetFilenameLastExtension(filename); if ((Extension == ".lum") || (Extension == ".LUM")) { return true; } else { return false; } } void LUMImageIO::Write(const void* buffer) { if (m_FlagWriteImageInformation == true) { this->WriteImageInformation(); m_FlagWriteImageInformation = false; } unsigned long lNbLines = this->GetIORegion().GetSize()[1]; unsigned long lNbColumns = this->GetIORegion().GetSize()[0]; unsigned long lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] if ((lNbLines == m_Dimensions[1]) && (lNbColumns == m_Dimensions[0])) { otbMsgDevMacro(<< "Forcing offset to [0, 0]"); lFirstLine = 0; lFirstColumn = 0; } otbMsgDevMacro(<< " LUMImageIO::Write() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); otbMsgDevMacro(<< " GetComponentSize : " << this->GetComponentSize()); std::streamoff numberOfBytesPerLines = this->GetComponentSize() * m_Dimensions[0]; std::streamoff headerLength = numberOfBytesPerLines; std::streamoff offset; std::streamsize numberOfBytesToBeWrite = this->GetComponentSize() * lNbColumns; std::streamsize cpt = 0; const char * p = static_cast(buffer); for (unsigned long LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(this->GetComponentSize() * lFirstColumn); m_File.seekp(offset, std::ios::beg); m_File.write(static_cast(p + cpt), numberOfBytesToBeWrite); cpt += numberOfBytesToBeWrite; } } void LUMImageIO::WriteImageInformation() { if (m_FileName == "") { itkExceptionMacro(<< "A FileName must be specified."); } if (CanWriteFile(m_FileName.c_str()) == false) { itkExceptionMacro(<< "The file " << m_FileName.c_str() << " is not defined as a LUM file"); } // Close file from any previous image if (m_File.is_open()) { m_File.close(); } // Open the new file for writing // Actually open the file m_File.open(m_FileName.c_str(), std::ios::out | std::ios::trunc | std::ios::binary); if (m_File.fail()) { itkExceptionMacro(<< "Cannot write requested file " << m_FileName.c_str() << "."); } //Writing header information std::streamsize headerLength = static_cast(this->GetComponentSize() * m_Dimensions[0]); m_File.seekp(0, std::ios::beg); char* value = new char[headerLength]; //Write Header line and all file (whitout information) for (unsigned int numLigne = 0; numLigne < (m_Dimensions[1] + 1); numLigne++) { m_File.write(value, headerLength); } delete[] value; value = ITK_NULLPTR; //Set m_TypeLum if (0) {} otbSetTypeLumMacro(CHAR, "08BI", "08LI") otbSetTypeLumMacro(UCHAR, "08BU", "08LU") otbSetTypeLumMacro(SHORT, "16BI", "16LI") otbSetTypeLumMacro(USHORT, "16BU", "16LU") otbSetTypeLumMacro(INT, "32BI", "32LI") otbSetTypeLumMacro(UINT, "32BU", "32LU") otbSetTypeLumMacro(FLOAT, "FLOA", "FLOL") otbSetTypeLumMacro(DOUBLE, "R8B ", "R8L ") if ((this->GetComponentType() == LONG) || (this->GetComponentType() == ULONG)) { itkExceptionMacro(<< "LUM format doesn't accept LONG or ULONG data type"); } m_File.seekp(0, std::ios::beg); //Write image size m_File.write((char*) (&(m_Dimensions[0])), 4); m_File.write((char*) (&(m_Dimensions[1])), 4); m_File.write((char*) (m_TypeLum.data()), 4); otbMsgDebugMacro(<< "Driver to write: LUM"); otbMsgDebugMacro(<< " Write file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " Type Lum : " << m_TypeLum); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } int LUMImageIO::CaiGetTypeLum(const char * type_code, std::string& str_sens_code, int& inbbits, std::string& str_cod_pix) { unsigned int ind; /* indice de boucle sur les types reconnus */ int trouve, icr, taille; /* indice pour la recherche */ int mod2; /* modulo2 */ char* pch0; char sens_code[3]; /* type code+ordre rangement octets dans entete*/ char cod_pix[5]; sens_code[0] = '\0'; cod_pix[0] = '\0'; /* Initializations diverses */ trouve = -1; taille = -1; int nbbits = -1; ind = 0; pch0 = ITK_NULLPTR; std::string str_type_code(type_code); while ((trouve == -1) && (ind < m_CaiLumTyp.size())) { if ( str_type_code.find(m_CaiLumTyp[ind]) != std::string::npos ) { trouve = ind; } else { ind = ind + 1; } } //CAI source code if (trouve != -1) { mod2 = ind % 2; if (mod2 == 0) sprintf(sens_code, "BE"); else sprintf(sens_code, "LE"); if (ind < 4) { icr = sscanf(type_code, "%d", &nbbits); if (icr == 0) nbbits = -1; else { trouve = (int) (nbbits / 8); if ((nbbits % 8) != 0) taille = trouve + 1; else taille = trouve; } pch0 = const_cast(strstr(type_code, "U")); if (taille == 1) { if (pch0 == ITK_NULLPTR) sprintf(cod_pix, "OCT"); else sprintf(cod_pix, "UOCT"); } else if (taille == 2) { if (pch0 == ITK_NULLPTR) sprintf(cod_pix, "I2"); else sprintf(cod_pix, "UI2"); } else if (taille == 4) { if (pch0 == ITK_NULLPTR) sprintf(cod_pix, "I4"); else sprintf(cod_pix, "UI4"); } else taille = -1; } else if ((ind == 4) || (ind == 5)) { taille = 4; nbbits = 32; sprintf(cod_pix, "R4"); } else if ((ind == 6) || (ind == 7)) { taille = 8; nbbits = 64; sprintf(cod_pix, "R8"); } } str_cod_pix = std::string(cod_pix); str_sens_code = std::string(sens_code); inbbits = nbbits; return (taille); } } // end namespace otb OTB-release-5.8/Modules/IO/IOLUM/src/otbLUMImageIOFactory.cxx000066400000000000000000000031411301006202600234210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLUMImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbLUMImageIO.h" #include "itkVersion.h" namespace otb { LUMImageIOFactory::LUMImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbLUMImageIO", "LUM Image IO", 1, itk::CreateObjectFunction::New()); } LUMImageIOFactory::~LUMImageIOFactory() { } const char* LUMImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* LUMImageIOFactory::GetDescription() const { return "LUM ImageIO Factory, permettant le chargement d'image au format LUM dans l'OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool LUMImageIOFactoryHasBeenRegistered; void LUMImageIOFactoryRegister__Private(void) { if( ! LUMImageIOFactoryHasBeenRegistered ) { LUMImageIOFactoryHasBeenRegistered = true; LUMImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOLUM/test/000077500000000000000000000000001301006202600172015ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOLUM/test/CMakeLists.txt000066400000000000000000000010441301006202600217400ustar00rootroot00000000000000otb_module_test() set(OTBIOLUMTests otbIOLUMTestDriver.cxx otbLUMImageIOTestCanWrite.cxx otbLUMImageIOTestCanRead.cxx ) add_executable(otbIOLUMTestDriver ${OTBIOLUMTests}) target_link_libraries(otbIOLUMTestDriver ${OTBIOLUM-Test_LIBRARIES}) otb_module_target_label(otbIOLUMTestDriver) # Tests Declaration otb_add_test(NAME ioTuLUMImageIOCanWrite COMMAND otbIOLUMTestDriver otbLUMImageIOTestCanWrite ${TEMP}/poupees.lum) otb_add_test(NAME ioTuLUMImageIOCanRead COMMAND otbIOLUMTestDriver otbLUMImageIOTestCanRead ${INPUTDATA}/poupees.lum) OTB-release-5.8/Modules/IO/IOLUM/test/otbIOLUMTestDriver.cxx000066400000000000000000000002111301006202600233250ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbLUMImageIOTestCanWrite); REGISTER_TEST(otbLUMImageIOTestCanRead); } OTB-release-5.8/Modules/IO/IOLUM/test/otbLUMImageIOTestCanRead.cxx000066400000000000000000000020211301006202600243330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLUMImageIO.h" #include "itkMacro.h" #include int otbLUMImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::LUMImageIO::Pointer lLUMImageIO = otb::LUMImageIO::New(); bool lCanRead = lLUMImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::LUMImageIO : impossible d'ouvrir l'image LUM " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOLUM/test/otbLUMImageIOTestCanWrite.cxx000066400000000000000000000020061301006202600245550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLUMImageIO.h" #include "itkMacro.h" #include int otbLUMImageIOTestCanWrite(int itkNotUsed(argc), char* argv[]) { otb::LUMImageIO::Pointer lLUMImageIO = otb::LUMImageIO::New(); bool lCanRead = lLUMImageIO->CanWriteFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::L'image " << argv[1] << " n'est pas une image LUM." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOMSTAR/000077500000000000000000000000001301006202600164535ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMSTAR/CMakeLists.txt000066400000000000000000000001141301006202600212070ustar00rootroot00000000000000project(OTBIOMSTAR) set(OTBIOMSTAR_LIBRARIES OTBIOMSTAR) otb_module_impl() OTB-release-5.8/Modules/IO/IOMSTAR/include/000077500000000000000000000000001301006202600200765ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMSTAR/include/otbMSTARImageIO.h000066400000000000000000000120161301006202600230350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMSTARImageIO_h #define otbMSTARImageIO_h #include "otbImageIOBase.h" namespace otb { /** \class MSTARImageIO * * \brief ImageIO object for reading and writing MSTAR images * * The streaming read/write are implemented. * * \ingroup IOFilters * * * \ingroup OTBIOMSTAR */ class ITK_EXPORT MSTARImageIO : public otb::ImageIOBase { public: /** Standard class typedefs. */ typedef MSTARImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MSTARImageIO, Superclass); /*-------- This part of the interfaces deals with reading data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can write the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegions has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; MSTARImageIO(); ~MSTARImageIO() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Get the number of overviews available into the file specified * This imageIO didn't support overviews */ unsigned int GetOverviewsCount() ITK_OVERRIDE { // MANTIS-1154: Source image is always considered as the best // resolution overview. return 1; } /** Get information about overviews available into the file specified * This imageIO didn't support overviews */ std::vector GetOverviewsInfo() ITK_OVERRIDE { std::vector desc; return desc; } /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} private: MSTARImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Methode permettant de recuperer le format et le nom de l'image a partir du nom d'un fichier image. */ float byteswap_SR_IR(unsigned char *pointer); unsigned short byteswap_SUS_IUS(unsigned char *pointer); int CheckByteOrder(void); FILE *MSTARfp; /* Input FILE ptr to MSTAR image file */ FILE *RAWfp; /* Output FILE ptr to MSTAR RAW data file */ FILE *HDRfp; /* Output FILE ptr to MSTAR header file */ int i, j, rv, n, numrows, numcols, numgot; const char *MSTARname; /* Input MSTAR filename */ char RAWname[80]; /* Output MSTAR RAW filename */ char HDRname[80]; /* Phoenix header filename buffer */ int outOpt; /* ALL data, or MAG ONLY... */ int phlen, nhlen, mstartype; long magloc, bytesPerImage, nchunks, totchunks; char *tptr; /* Temp buffer ptr */ char *phdr; /* Ptr to buffer to hold Phoenix header */ char tbuff[1024]; unsigned short *FSCENEdata; /* Ptr to Fullscene data buffer */ float * CHIPdata; /* Ptr to CHIp data buffer */ /* Byte Order Variables */ int byteorder; unsigned char bigfloatbuf[4]; /* BigEndian float buffer... */ float littlefloatval; /* LittleEndian float value */ unsigned char bigushortbuf[2]; /* BigEndian ushort buffer...*/ unsigned short littleushortval; /* LittleEndian ushort value.*/ int m_BytePerPixel; }; } // end namespace otb #endif // otbMSTARImageIO_h OTB-release-5.8/Modules/IO/IOMSTAR/include/otbMSTARImageIOFactory.h000066400000000000000000000040421301006202600243650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMSTARImageIOFactory_h #define otbMSTARImageIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class MSTARImageIOFactory * \brief Creation d'un instance d'un objet MSTARImageIO utilisant les object factory. * * \ingroup OTBIOMSTAR */ class ITK_EXPORT MSTARImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef MSTARImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static MSTARImageIOFactory * FactoryNew() { return new MSTARImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(MSTARImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { MSTARImageIOFactory::Pointer MSTARFactory = MSTARImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(MSTARFactory); } protected: MSTARImageIOFactory(); ~MSTARImageIOFactory() ITK_OVERRIDE; private: MSTARImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOMSTAR/otb-module.cmake000066400000000000000000000003571301006202600215310ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read and write MSTAR format images.") otb_module(OTBIOMSTAR DEPENDS OTBImageBase OTBCommon OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOMSTAR/src/000077500000000000000000000000001301006202600172425ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMSTAR/src/CMakeLists.txt000066400000000000000000000003601301006202600220010ustar00rootroot00000000000000set(OTBIOMSTAR_SRC otbMSTARImageIOFactory.cxx otbMSTARImageIO.cxx ) add_library(OTBIOMSTAR ${OTBIOMSTAR_SRC}) target_link_libraries(OTBIOMSTAR ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBIOMSTAR) OTB-release-5.8/Modules/IO/IOMSTAR/src/otbMSTARImageIO.cxx000066400000000000000000000507141301006202600225630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMSTARImageIO.h" //For MSTAR #define MAIN /* Define MSTAR image type */ #define CHIP_IMAGE 0 #define FSCENE_IMAGE 1 #define ALL_DATA 0 #define MAG_DATA 1 #define SUCCESS 0 #define FAILURE -1 #define LSB_FIRST 0 /* Implies little-endian CPU... */ #define MSB_FIRST 1 /* Implies big-endian CPU... */ #include #include #include #include #include "otbMacro.h" namespace otb { /** Constructor */ MSTARImageIO::MSTARImageIO() { m_ByteOrder = BigEndian; this->SetNumberOfDimensions(2); m_PixelType = SCALAR; m_ComponentType = UCHAR; m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to [0.5 , 0.5] // (consistency between ImageIO, see Mantis #942) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_BytePerPixel = 0; MSTARfp = ITK_NULLPTR; /* Input FILE ptr to MSTAR image file */ HDRfp = ITK_NULLPTR; /* Output FILE ptr to MSTAR header file */ RAWfp = ITK_NULLPTR; i = 0; j = 0; rv = 0; n = 0; numrows = 0; numcols = 0; numgot = 0; outOpt = 0; phlen = 0; nhlen = 0; mstartype = 0; magloc = 0; bytesPerImage = 0; nchunks = 0; totchunks = 0; byteorder = 0; littleushortval = 0; littlefloatval = 0.; MSTARname = ITK_NULLPTR; /* Input MSTAR filename */ tptr = ITK_NULLPTR; /* Temp buffer ptr */ phdr = ITK_NULLPTR; /* Ptr to buffer to hold Phoenix header */ FSCENEdata = ITK_NULLPTR; /* Ptr to Fullscene data buffer */ CHIPdata = ITK_NULLPTR; /* Ptr to CHIp data buffer */ } /** Destructor */ MSTARImageIO::~MSTARImageIO() { if (phdr != ITK_NULLPTR) { free(phdr); phdr = ITK_NULLPTR; } } bool MSTARImageIO::CanReadFile(const char* filename) { // First check the filename extension std::string fname = filename; if (fname == "") { itkDebugMacro(<< "Fichier image non specifie."); } MSTARname = filename; MSTARfp = fopen(MSTARname, "rb"); if (MSTARfp == ITK_NULLPTR) { otbMsgDevMacro(<< "\nError: Unable to open [" << MSTARname << "] for reading!\n"); return false; } /**************************************************** * Read first 512 bytes to figure out some header * * parameters.... * ****************************************************/ int returnVal = fread(tbuff, sizeof(char), 1024, MSTARfp); if (returnVal != 1024) { otbMsgDevMacro(<< "\nError: Unable in reading [" << MSTARname << "] header... Only read ["<< returnVal <<" of 1024 bytes !\n"); fclose(MSTARfp); MSTARfp = ITK_NULLPTR; return false; } rewind(MSTARfp); /* Extract Phoenix Summary header length */ tptr = (char *) strstr(tbuff, "PhoenixHeaderLength= "); if (tptr == (char *) ITK_NULLPTR) { // fprintf(stderr,"Can not determine Phoenix header length!\n"); fclose(MSTARfp); MSTARfp = ITK_NULLPTR; return false; } else { sscanf((tptr + 20), "%d", &phlen); } /* Check for and extract native header length */ tptr = (char *) strstr(tbuff, "native_header_length= "); if (tptr == (char *) ITK_NULLPTR) { // fprintf(stderr,"Can not determine native header length!\n"); fclose(MSTARfp); MSTARfp = ITK_NULLPTR; return false; } else { sscanf((tptr + 21), "%d", &nhlen); } /* Extract MSTAR column width */ tptr = (char *) strstr(tbuff, "NumberOfColumns= "); if (tptr == (char *) ITK_NULLPTR) { otbMsgDevMacro(<< "Error: Can not determine MSTAR image width"); fclose(MSTARfp); return false; } else { sscanf((tptr + 16), "%d", &numcols); //NbColonnes = static_cast(numcols); // Unused } /* Extract MSTAR row height */ tptr = (char *) strstr(tbuff, "NumberOfRows= "); if (tptr == (char *) ITK_NULLPTR) { otbMsgDevMacro(<< "Error: Can not determine MSTAR image height!"); fclose(MSTARfp); MSTARfp = ITK_NULLPTR; return false; } else { sscanf((tptr + 13), "%d", &numrows); //NbLignes = static_cast(numrows); // Unused } /* Set MSTAR image type */ if (nhlen == 0) { /* Implies FLOAT MSTAR chip image */ mstartype = CHIP_IMAGE; } else { mstartype = FSCENE_IMAGE; /* UnShort Fullscene */ } /******************************************************* * Allocate memory to header buffer, read Phoenix hdr, * * and write out to output file... * *******************************************************/ // /* Allocate memory to Phoenix header buffer */ // phdr = (char *) malloc(phlen+1); // if (phdr == (char *) NULL) // { // fprintf(stderr, // "Error: unable to allocate Phoenix header memory!\n"); // fclose(MSTARfp); // return 0; // } // /* Read Phoenix header into buffer */ // n = fread(phdr, sizeof(char), phlen, MSTARfp); // if (n != phlen) // { // fprintf(stderr, // "Error: in reading Phoenix header..only read [%d of %d] bytes\n", // n, phlen); // free(phdr); // fclose(MSTARfp); // return 0; // } // /* Write Phoenix header to output header file */ // free(phdr); fclose(MSTARfp); MSTARfp = ITK_NULLPTR; otbMsgDevMacro(<< "Can read MSTAR"); return bool(true); } bool MSTARImageIO::CanWriteFile(const char * filename) { bool formatFound = false; std::string fname = filename; if (fname == "") { itkDebugMacro(<< "Fichier image non specifie."); } if (formatFound == false) { std::string identificationErreur; identificationErreur = "Format MSTAR non detecte dans l'extension du fichier."; itkDebugMacro(<< identificationErreur.c_str()); } return formatFound; } void MSTARImageIO::Read(void* buffer) { MSTARfp = fopen(MSTARname, "rb"); if (MSTARfp == ITK_NULLPTR) { itkExceptionMacro(<< "Error: Unable to open file for reading!\n\n " << m_FileName.c_str() << ")."); } /**************************************************** * Read first 512 bytes to figure out some header * * parameters.... * ****************************************************/ int returnVal = fread(tbuff, sizeof(char), 1024, MSTARfp); if (returnVal != 1024) { fclose(MSTARfp); itkExceptionMacro(<< "\nError: Unable in reading [" << MSTARname << "] header... Only read ["<< returnVal <<" of 1024 bytes !\n"); } rewind(MSTARfp); /* Extract Phoenix Summary header length */ tptr = (char *) strstr(tbuff, "PhoenixHeaderLength= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Error: Can not determine Phoenix header length!"); } else { sscanf((tptr + 20), "%d", &phlen); } /* Check for and extract native header length */ tptr = (char *) strstr(tbuff, "native_header_length= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Can not determine native header length!\n"); } else { sscanf((tptr + 21), "%d", &nhlen); } /* Extract MSTAR column width */ tptr = (char *) strstr(tbuff, "NumberOfColumns= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Error: Can not determine MSTAR image width"); } else { sscanf((tptr + 16), "%d", &numcols); m_Dimensions[0] = static_cast(numcols); } /* Extract MSTAR row height */ tptr = (char *) strstr(tbuff, "NumberOfRows= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Error: Can not determine MSTAR image height!"); } else { sscanf((tptr + 13), "%d", &numrows); m_Dimensions[1] = static_cast(numrows); } /* Set MSTAR image type */ if (nhlen == 0) { /* Implies FLOAT MSTAR chip image */ mstartype = CHIP_IMAGE; otbMsgDevMacro(<< " Chip type "); } else { mstartype = FSCENE_IMAGE; /* UnShort Fullscene */ otbMsgDevMacro(<< " Scene type "); } unsigned long step = this->GetNumberOfComponents() * (unsigned long) (m_BytePerPixel); float * p = static_cast(buffer); int lNbLines = this->GetIORegion().GetSize()[1]; int lNbColumns = this->GetIORegion().GetSize()[0]; unsigned long lNbPixels = (unsigned long) (lNbColumns * lNbLines); unsigned long lTailleBuffer = (unsigned long) (m_BytePerPixel) * lNbPixels; unsigned char* value = new unsigned char[lTailleBuffer]; otbMsgDevMacro( << "MSTARImageIO::Read() IORegion Start[" << this->GetIORegion().GetIndex()[0] << "," << this->GetIORegion().GetIndex()[1] << "] Size [" << this->GetIORegion().GetSize()[0] << "," << this->GetIORegion().GetSize()[1] << "] on Image size [" << m_Dimensions[0] << "," << m_Dimensions[1] << "]"); /****************************************************** * Set up location to point to MSTAR magnitude data.. * ******************************************************/ switch (mstartype) { case CHIP_IMAGE: magloc = phlen; if(fseek(MSTARfp, magloc, 0)) { itkExceptionMacro(<<" Problem while reading file "< Little-Endian CPU detected: Will byteswap before scaling data!\n"); break; case MSB_FIRST: printf("==> Big-Endian CPU detected: No byteswap needed!\n"); break; } /****************************************************** * Allocate memory, read data, & write out based on * * type of MSTAR image...and which data to write out * * * * NOTE: For Chip data, I allocate all of the memory * * needed (magnitude+phase), read and then write* * all of it out... * * * * For fullscene data, because of the size of * * memory needed, I allocate only enough to * * grab the magnitude or the phase. I then * * process first the magnitude and then the * * phase using the same buffer pointer.... * * * * The code will read & write out ONLY the MAG * * image data if so specified by the user... * ******************************************************/ /* Open output file for writing... */ switch (mstartype) { case CHIP_IMAGE: otbMsgDevMacro(<< " Chip and all "); totchunks = nchunks * 2; bytesPerImage = totchunks * sizeof(float); CHIPdata = (float *) malloc(bytesPerImage); if (CHIPdata == (float *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro("Error: Unable to malloc CHIP memory!\n"); } switch (byteorder) { case LSB_FIRST: /* Little-endian..do byteswap */ otbMsgDevMacro(<< "Performing auto-byteswap...\n"); for (i = 0; i < totchunks; ++i) { returnVal = fread(bigfloatbuf, sizeof(char), 4, MSTARfp); if (!returnVal) itkExceptionMacro("Read failure"); littlefloatval = byteswap_SR_IR(bigfloatbuf); CHIPdata[i] = littlefloatval; } break; case MSB_FIRST: /* Big-endian..no swap */ numgot = fread(CHIPdata, sizeof(float), totchunks, MSTARfp); break; } /* Writes ALL data or MAG only data based on totchunks */ //n = fwrite(CHIPdata, sizeof(float), totchunks, RAWfp); // Recopie dans le buffer for (int ci = 0; ci < nchunks; ++ci) { p[ci * 2] = CHIPdata[ci]; //magnitude p[ci * 2 + 1] = CHIPdata[nchunks + ci]; //phase } /* Cleanup: Close file..free memory */ free(CHIPdata); break; /* End of CHIP_IMAGE case */ case FSCENE_IMAGE: bytesPerImage = nchunks * sizeof(short); FSCENEdata = (unsigned short *) malloc(bytesPerImage); if (FSCENEdata == (unsigned short *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Error: Unable to malloc fullscene memory!\n"); } otbMsgDevMacro(<< "Reading MSTAR fullscene magnitude data from [" << MSTARname << "]."); switch (byteorder) { case LSB_FIRST: /* Little-endian..do byteswap */ otbMsgDevMacro(<< "Performing auto-byteswap..."); for (i = 0; i < nchunks; ++i) { returnVal = fread(bigushortbuf, sizeof(char), 2, MSTARfp); if (!returnVal) itkExceptionMacro("Read failure"); littleushortval = byteswap_SUS_IUS(bigushortbuf); FSCENEdata[i] = littleushortval; } break; case MSB_FIRST: /* Big-endian..no swap */ numgot = fread(FSCENEdata, sizeof(short), nchunks, MSTARfp); break; } otbMsgDevMacro(<< "Writing MSTAR fullscene magnitude data to [" << RAWname << "]."); //n = fwrite(FSCENEdata, sizeof(short), nchunks, RAWfp); for (int nbComponents = 0; nbComponents < 1; ++nbComponents) { // Recopie dans le buffer unsigned long cpt(0); cpt = (unsigned long) (nbComponents) * (unsigned long) (m_BytePerPixel); for (unsigned long k = 0; k < lTailleBuffer; k = k + m_BytePerPixel) { memcpy((void*) (&(p[cpt])), (const void*) (&(FSCENEdata[i])), (size_t) (m_BytePerPixel)); cpt += step; } } if (n != nchunks) { fclose(MSTARfp); itkExceptionMacro(<< "Error: in writing MSTAR Fullscene data!"); } otbMsgDevMacro(<< "Reading MSTAR fullscene phase data from [" << MSTARname << "]."); switch (byteorder) { case LSB_FIRST: /* Little-endian..do byteswap */ otbMsgDevMacro(<< "Performing auto-byteswap..."); for (i = 0; i < nchunks; ++i) { returnVal = fread(bigushortbuf, sizeof(char), 2, MSTARfp); if (!returnVal) itkExceptionMacro("Read failure"); littleushortval = byteswap_SUS_IUS(bigushortbuf); FSCENEdata[i] = littleushortval; } break; case MSB_FIRST: /* Big-endian..no swap */ numgot = fread(FSCENEdata, sizeof(short), nchunks, MSTARfp); break; } otbMsgDevMacro(<< "Writing MSTAR fullscene phase data to [" << RAWname << "]."); // n = fwrite(FSCENEdata, sizeof(short), nchunks, RAWfp); for (unsigned int nbComponents = 1; nbComponents < this->GetNumberOfComponents(); ++nbComponents) { // Recopie dans le buffer unsigned long cpt(0); cpt = (unsigned long) (nbComponents) * (unsigned long) (m_BytePerPixel); for (unsigned long k = 0; k < lTailleBuffer; k = k + m_BytePerPixel) { memcpy((void*) (&(p[cpt])), (const void*) (&(CHIPdata[i])), (size_t) (m_BytePerPixel)); cpt += step; } } if (n != nchunks) { fclose(MSTARfp); itkExceptionMacro(<< "Error: in writing MSTAR Fullscene Phase data!"); } /* Cleanup: free memory */ free(FSCENEdata); break; /* End of FSCENE_IMAGE case */ } /* End of 'mstartype' switch */ /* Cleanup: close files */ fclose(MSTARfp); delete[] value; } void MSTARImageIO::ReadImageInformation() { int NbLignes; /* Nombre de lignes de l'image */ int NbColonnes; /* Nombre de colonnes de l'image */ int BytePerPixel = sizeof(float); /* Nombre octets/pixel l'image */ MSTARname = m_FileName.c_str(); MSTARfp = fopen(MSTARname, "rb"); if (MSTARfp == ITK_NULLPTR) { itkExceptionMacro(<< "Error: Unable to open file for reading!\n\n " << m_FileName.c_str()); } /**************************************************** * Read first 512 bytes to figure out some header * * parameters.... * ****************************************************/ int returnVal = fread(tbuff, sizeof(char), 1024, MSTARfp); if (returnVal != 1024) { fclose(MSTARfp); itkExceptionMacro(<< "\nError: Unable in reading [" << MSTARname << "] header... Only read ["<< returnVal <<" of 1024 bytes !\n"); } rewind(MSTARfp); /* Extract Phoenix Summary header length */ tptr = (char *) strstr(tbuff, "PhoenixHeaderLength= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Error: Can not determine Phoenix header length!"); } else { sscanf((tptr + 20), "%d", &phlen); } /* Check for and extract native header length */ tptr = (char *) strstr(tbuff, "native_header_length= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Can not determine native header length!\n"); } else { sscanf((tptr + 21), "%d", &nhlen); } /* Extract MSTAR column width */ tptr = (char *) strstr(tbuff, "NumberOfColumns= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Error: Can not determine MSTAR image width"); } else { sscanf((tptr + 16), "%d", &numcols); NbColonnes = static_cast(numcols); } /* Extract MSTAR row height */ tptr = (char *) strstr(tbuff, "NumberOfRows= "); if (tptr == (char *) ITK_NULLPTR) { fclose(MSTARfp); itkExceptionMacro(<< "Error: Can not determine MSTAR image height!"); } else { sscanf((tptr + 13), "%d", &numrows); NbLignes = static_cast(numrows); } /* Set MSTAR image type */ if (nhlen == 0) { /* Implies FLOAT MSTAR chip image */ mstartype = CHIP_IMAGE; } else { mstartype = FSCENE_IMAGE; /* UnShort Fullscene */ } otbMsgDebugMacro(<< "Driver: MSTAR - "); this->SetNumberOfComponents(2); this->SetNumberOfDimensions(2); m_Dimensions[0] = NbColonnes; m_Dimensions[1] = NbLignes; m_BytePerPixel = BytePerPixel; otbMsgDebugMacro(<< "Image size cree : " << m_Dimensions[0] << "," << m_Dimensions[1]); m_PixelType = VECTOR; /* Cleanup: close files */ fclose(MSTARfp); this->SetComponentType(FLOAT); } /** The write function is not implemented */ void MSTARImageIO::WriteImageInformation(void) { itkExceptionMacro(<< "Error: The MSTARImageIO::WriteImageInformation is not implemented!"); } /** The write function is not implemented */ void MSTARImageIO::Write(const void* /* *buffer*/) { itkExceptionMacro(<< "Error: The MSTARImageIO::Write is not implemented!"); } /** Print Self Method */ void MSTARImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } float MSTARImageIO::byteswap_SR_IR(unsigned char *pointer) { float * temp; unsigned char iarray[4]; void *vptr; iarray[0] = *(pointer + 3); iarray[1] = *(pointer + 2); iarray[2] = *(pointer + 1); iarray[3] = *(pointer); vptr = static_cast(iarray); temp = static_cast(vptr); return *(temp); } unsigned short MSTARImageIO::byteswap_SUS_IUS(unsigned char *pointer) { unsigned short *temp; unsigned char iarray[2]; void *vptr; iarray[0] = *(pointer + 1); iarray[1] = *(pointer); vptr = static_cast(iarray); temp = static_cast(vptr); return *(temp); } int MSTARImageIO::CheckByteOrder(void) { short w = 0x0001; char *b = (char *) &w; return (b[0] ? LSB_FIRST : MSB_FIRST); } } // end namespace otb OTB-release-5.8/Modules/IO/IOMSTAR/src/otbMSTARImageIOFactory.cxx000066400000000000000000000031721301006202600241070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMSTARImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbMSTARImageIO.h" #include "itkVersion.h" namespace otb { MSTARImageIOFactory::MSTARImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbMSTARImageIO", "MSTAR Image IO", 1, itk::CreateObjectFunction::New()); } MSTARImageIOFactory::~MSTARImageIOFactory() { } const char* MSTARImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* MSTARImageIOFactory::GetDescription() const { return "MSTAR ImageIO Factory, permettant le chargement d'image MSTAR dans l'OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool MSTARImageIOFactoryHasBeenRegistered; void MSTARImageIOFactoryRegister__Private(void) { if( ! MSTARImageIOFactoryHasBeenRegistered ) { MSTARImageIOFactoryHasBeenRegistered = true; MSTARImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOMSTAR/test/000077500000000000000000000000001301006202600174325ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMSTAR/test/CMakeLists.txt000066400000000000000000000010631301006202600221720ustar00rootroot00000000000000otb_module_test() set(OTBIOMSTARTests otbIOMSTARTestDriver.cxx otbMSTARImageIOTestCanRead.cxx ) add_executable(otbIOMSTARTestDriver ${OTBIOMSTARTests}) target_link_libraries(otbIOMSTARTestDriver ${OTBIOMSTAR-Test_LIBRARIES}) otb_module_target_label(otbIOMSTARTestDriver) # Tests Declaration otb_add_test(NAME ioTuMSTARImageIOCanRead2 COMMAND otbIOMSTARTestDriver otbMSTARImageIOTestCanRead ${INPUTDATA}/MSTAR/HB20010.000) otb_add_test(NAME ioTuMSTARImageIOCanRead1 COMMAND otbIOMSTARTestDriver otbMSTARImageIOTestCanRead ${INPUTDATA}/MSTAR/HB19896.016) OTB-release-5.8/Modules/IO/IOMSTAR/test/otbIOMSTARTestDriver.cxx000066400000000000000000000001371301006202600240160ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMSTARImageIOTestCanRead); } OTB-release-5.8/Modules/IO/IOMSTAR/test/otbMSTARImageIOTestCanRead.cxx000066400000000000000000000020431301006202600250210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMSTARImageIO.h" #include "itkMacro.h" #include int otbMSTARImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::MSTARImageIO::Pointer lMSTARImageIO = otb::MSTARImageIO::New(); bool lCanRead = lMSTARImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::MSTARImageIO : impossible d'ouvrir l'image MSTAR " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOMW/000077500000000000000000000000001301006202600161105ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMW/CMakeLists.txt000066400000000000000000000001031301006202600206420ustar00rootroot00000000000000project(OTBIOMW) set(OTBIOMW_LIBRARIES OTBIOMW) otb_module_impl() OTB-release-5.8/Modules/IO/IOMW/include/000077500000000000000000000000001301006202600175335ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMW/include/otbMWImageIO.h000066400000000000000000000133141301006202600221310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMWImageIO_h #define otbMWImageIO_h #include "otbImageIOBase.h" #include #include #include namespace otb { /** \class MWImageIO * * \brief ImageIO object for reading (not writing) MW format images * * The streaming read is implemented. * * \ingroup IOFilters * * * \ingroup OTBIOMW */ class ITK_EXPORT MWImageIO : public otb::ImageIOBase { public: /** Standard class typedefs. */ typedef MWImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Byte order typedef */ typedef Superclass::ByteOrder ByteOrder; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MWImageIO, otb::ImageIOBase); /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Reads 3D data from multiple files assuming one slice per file. */ virtual void ReadVolume(void* buffer); /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; // JULIEN: NOT USED, NOT IMPLEMENTED //void SampleImage(void* buffer, int XBegin, int YBegin, int SizeXRead, int SizeYRead, int XSample, int YSample); /** Get the number of overviews available into the file specified * This imageIO didn't support overviews */ unsigned int GetOverviewsCount() ITK_OVERRIDE { // MANTIS-1154: Source image is always considered as the best // resolution overview. return 1; } /** Get information about overviews available into the file specified * This imageIO didn't support overviews */ std::vector GetOverviewsInfo() ITK_OVERRIDE { std::vector desc; return desc; } /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} protected: /** Constructor.*/ MWImageIO(); /** Destructor.*/ ~MWImageIO() ITK_OVERRIDE; bool OpenOneraDataFileForReading(const char* filename); bool OpenOneraHeaderFileForReading(const char* filename); void InternalReadImageInformation(); bool OpenOneraDataFileForWriting(const char* filename); bool OpenOneraHeaderFileForWriting(const char* filename); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: MWImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Internal method to read filename extension */ std::string GetExtension(const std::string& filename); /** Internal method to read header information */ bool InternalReadHeaderInformation(std::fstream& file, const bool reportError); inline void ByteSplitting(unsigned short a, unsigned short& low, unsigned short& high) { unsigned short b = 255; low = a & b; high = (a >> 8) & b; } #define otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ { \ typedef itk::ByteSwapper InternalByteSwapperType; \ if (m_ByteOrder != m_FileByteOrder) \ { \ if (m_ByteOrder == LittleEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToBigEndian((StrongType *) buffer, buffer_size); \ } \ else if (m_ByteOrder == BigEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToLittleEndian((StrongType *) buffer, buffer_size); \ } \ } \ } #define otbSwappFileToSystemMacro(StrongType, WeakType, buffer, buffer_size) \ else if (this->GetComponentType() == WeakType) \ { \ otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ } bool m_FlagWriteImageInformation; std::string m_TypeMW; //used for write otb::ImageIOBase::ByteOrder m_FileByteOrder; std::fstream m_File; unsigned int m_Ncom; }; } // end namespace otb #endif // otbMWImageIO_h OTB-release-5.8/Modules/IO/IOMW/include/otbMWImageIOFactory.h000066400000000000000000000037631301006202600234700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMWImageIOFactory_h #define otbMWImageIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class MWImageIOFactory * \brief Creation d'un instance d'un objet LUMImageIO utilisant les object factory. * * \ingroup OTBIOMW */ class ITK_EXPORT MWImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef MWImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static MWImageIOFactory * FactoryNew() { return new MWImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(MWImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { MWImageIOFactory::Pointer MWFactory = MWImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(MWFactory); } protected: MWImageIOFactory(); ~MWImageIOFactory() ITK_OVERRIDE; private: MWImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOMW/otb-module.cmake000066400000000000000000000003371301006202600211640ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read MW format images.") otb_module(OTBIOMW DEPENDS OTBImageBase OTBCommon OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOMW/src/000077500000000000000000000000001301006202600166775ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMW/src/CMakeLists.txt000066400000000000000000000003331301006202600214360ustar00rootroot00000000000000set(OTBIOMW_SRC otbMWImageIOFactory.cxx otbMWImageIO.cxx ) add_library(OTBIOMW ${OTBIOMW_SRC}) target_link_libraries(OTBIOMW ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBIOMW) OTB-release-5.8/Modules/IO/IOMW/src/otbMWImageIO.cxx000066400000000000000000000343451301006202600216570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMWImageIO.h" #include "itkByteSwapper.h" #include "otbSystem.h" #include "itksys/SystemTools.hxx" #include "otbMacro.h" namespace otb { MWImageIO::MWImageIO() { // By default set number of dimensions to two. this->SetNumberOfDimensions(2); m_PixelType = SCALAR; m_ComponentType = UCHAR; if (itk::ByteSwapper::SystemIsLittleEndian() == true) { m_ByteOrder = LittleEndian; } else { m_ByteOrder = BigEndian; } m_FileByteOrder = BigEndian; // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to [0.5 , 0.5] // (consistency between ImageIO, see Mantis #942) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_FlagWriteImageInformation = true; m_Ncom = 0; this->AddSupportedWriteExtension(".img"); this->AddSupportedWriteExtension(".IMG"); this->AddSupportedWriteExtension(".mw"); this->AddSupportedWriteExtension(".MW"); this->AddSupportedReadExtension(".img"); this->AddSupportedReadExtension(".IMG"); this->AddSupportedReadExtension(".mw"); this->AddSupportedReadExtension(".MW"); } MWImageIO::~MWImageIO() { if (m_File.is_open()) { m_File.close(); } } bool MWImageIO::CanReadFile(const char* filename) { std::string lFileName(filename); // Test the extension std::string extension = GetExtension(filename); if ((extension != "img") && (extension != "") && (extension != "mw")) return false; if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) return false; if (m_File.is_open()) m_File.close(); std::fstream header_file; header_file.open(filename, std::ios::in | std::ios::binary); if (header_file.fail()) { otbMsgDevMacro(<< "MWImageIO::CanReadFile() failed header open ! "); return false; } //Read header information bool lResult = InternalReadHeaderInformation(header_file, false); header_file.close(); return (lResult); } // Used to print information about this object void MWImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // Read a 3D image (or event more bands)... not implemented yet void MWImageIO::ReadVolume(void*) { } // Read image void MWImageIO::Read(void* buffer) { char * p = static_cast(buffer); int lNbLignes = this->GetIORegion().GetSize()[1]; int lNbColonnes = this->GetIORegion().GetSize()[0]; int lPremiereLigne = this->GetIORegion().GetIndex()[1]; // [1... ] int lPremiereColonne = this->GetIORegion().GetIndex()[0]; // [1... ] otbMsgDevMacro(<< " MWImageIO::Read() "); otbMsgDevMacro(<< " Dimensions de l'image : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region lue (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); std::streamoff headerLength = static_cast (64 * sizeof(char)) + static_cast (m_Ncom * sizeof(char)); std::streamoff numberOfBytesPerLines = static_cast(this->GetComponentSize() * m_Dimensions[0]); std::streamoff offset; std::streamsize numberOfBytesToBeRead = static_cast(this->GetComponentSize() * lNbColonnes); std::streamsize numberOfBytesRead; std::streamsize cpt = 0; for (int LineNo = lPremiereLigne; LineNo < lPremiereLigne + lNbLignes; LineNo++) { offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(this->GetComponentSize() * lPremiereColonne); m_File.seekg(offset, std::ios::beg); m_File.read(static_cast(p + cpt), numberOfBytesToBeRead); numberOfBytesRead = m_File.gcount(); #ifdef __APPLE_CC__ // fail() is broken in the Mac. It returns true when reaches eof(). if (numberOfBytesRead != numberOfBytesToBeRead) #else if ((numberOfBytesRead != numberOfBytesToBeRead) || m_File.fail()) #endif { itkExceptionMacro(<< "MWImageIO::Read() Can Read the specified Region"); // read failed } cpt += numberOfBytesToBeRead; } unsigned long numberOfPixelsPerLines = lNbLignes * lNbColonnes; // Swap bytes if necessary if (0) {} otbSwappFileToSystemMacro(float, FLOAT, buffer, numberOfPixelsPerLines) else { itkExceptionMacro(<< "MWImageIO::Read() undefined component type! "); } } void MWImageIO::ReadImageInformation() { if (m_File.is_open()) { m_File.close(); } m_File.open(m_FileName.c_str(), std::ios::in | std::ios::binary); if (m_File.fail()) { itkExceptionMacro(<< "MWImageIO::ReadImageInformation() failed header open ! "); } //Read header information InternalReadHeaderInformation(m_File, true); otbMsgDebugMacro(<< "Driver to read: MW"); otbMsgDebugMacro(<< " Read file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } bool MWImageIO::InternalReadHeaderInformation(std::fstream& file, const bool reportError) { char * headerInformation = new char[64]; file.seekg(0, std::ios::beg); file.read(headerInformation, 64); unsigned short NbCol(0); unsigned short NbLig(0); unsigned short Nbcom(0); //Set file byte order if (headerInformation[0] == *("R") || headerInformation[1] == *("I")) { m_FileByteOrder = BigEndian; //Read image dimensions Nbcom = (static_cast(headerInformation[3]) << 8) + static_cast (headerInformation[2]); m_Ncom = Nbcom; NbCol = (static_cast(headerInformation[5]) << 8) + static_cast (headerInformation[4]); NbLig = (static_cast(headerInformation[7]) << 8) + static_cast (headerInformation[6]); } else if (headerInformation[0] == *("I") || headerInformation[1] == *("R")) { m_FileByteOrder = LittleEndian; //Read image dimensions Nbcom = ((static_cast(headerInformation[2])) << 8) + static_cast (headerInformation[3]); m_Ncom = Nbcom; NbCol = ((static_cast(headerInformation[4])) << 8) + static_cast (headerInformation[5]); NbLig = ((static_cast(headerInformation[6])) << 8) + static_cast (headerInformation[7]); } else { delete [] headerInformation; if (reportError == true) { itkExceptionMacro(<< "MW : impossible to determine CodePix information of the image"); } return false; } SetComponentType(FLOAT); //Initialization of image information m_Dimensions[0] = NbCol; m_Dimensions[1] = NbLig; this->SetNumberOfComponents(1); this->SetFileTypeToBinary(); this->SetNumberOfDimensions(2); delete[] headerInformation; return (true); } bool MWImageIO::CanWriteFile(const char* filename) { std::string lFileName(filename); std::string extension = GetExtension(filename); if (extension != "mw") return false; if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) return false; return true; } void MWImageIO::Write(const void* buffer) { if (m_FlagWriteImageInformation == true) { this->WriteImageInformation(); m_FlagWriteImageInformation = false; } unsigned long lNbLignes = this->GetIORegion().GetSize()[1]; unsigned long lNbColonnes = this->GetIORegion().GetSize()[0]; unsigned long lPremiereLigne = this->GetIORegion().GetIndex()[1]; // [1... ] int lPremiereColonne = this->GetIORegion().GetIndex()[0]; // [1... ] if ((lNbLignes == m_Dimensions[1]) && (lNbColonnes == m_Dimensions[0])) { otbMsgDevMacro(<< "Forcing offset to [0, 0]"); lPremiereLigne = 0; lPremiereColonne = 0; } otbMsgDevMacro(<< " MWImageIO::Write() "); otbMsgDevMacro(<< " Dimensions de l'image : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region lue (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); otbMsgDevMacro(<< " GetComponentSize : " << this->GetComponentSize()); std::streamoff numberOfBytesPerLines = this->GetComponentSize() * m_Dimensions[0]; std::streamoff headerLength = static_cast (64 * sizeof(char)) + static_cast (m_Ncom * sizeof(char)); std::streamoff offset; std::streamsize numberOfBytesToBeWrite = this->GetComponentSize() * lNbColonnes; // std::streamsize numberOfBytesToBeWriteFloat = sizeof(float) * lNbColonnes; std::streamsize cpt = 0; const char * p = static_cast(buffer); // const float * p = dynamic_cast(buffer); // float floatImage[m_Dimensions[0]*m_Dimensions[1]]; // std::streamsize counter = 0; // std::cout << "begin conversion" << std::endl; // for (unsigned int i=0; i ( *(p+counter) ); // std::cout << "float " << floatImage[i] << std::endl; // counter+=sizeof(char); // } for (unsigned long LineNo = lPremiereLigne; LineNo < lPremiereLigne + lNbLignes; LineNo++) { offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(this->GetComponentSize() * lPremiereColonne); m_File.seekp(offset, std::ios::beg); m_File.write(static_cast(p + cpt), numberOfBytesToBeWrite); // m_File.write( (char *)( floatImage + cpt ), numberOfBytesToBeWriteFloat ); cpt += numberOfBytesToBeWrite; } } void MWImageIO::WriteImageInformation() { if (m_FileName == "") { itkExceptionMacro(<< "A FileName must be specified."); } if (CanWriteFile(m_FileName.c_str()) == false) { itkExceptionMacro(<< "The file " << m_FileName.c_str() << " is not defined as a MW file"); } // Close file from any previous image if (m_File.is_open()) { m_File.close(); } // Open the new file for writing // Actually open the file m_File.open(m_FileName.c_str(), std::ios::out | std::ios::trunc | std::ios::binary); if (m_File.fail()) { itkExceptionMacro(<< "Cannot write requested file " << m_FileName.c_str() << "."); } //Comment by MG to review write process //Writing header information // if ( 0 ) {} // if ( (this->GetComponentType() != FLOAT) ) // { // itkExceptionMacro(<< "MegaWave fimage format only accepts FLOAT32 data type"); // } m_ComponentType = FLOAT; m_File.seekp(0, std::ios::beg); char header[64]; std::string comments("Image written with otb mw_IO_factory"); m_Ncom = comments.length(); //Initialization to 0 for (unsigned int i = 0; i < 64; ++i) header[i] = static_cast(0); //Write image size and other information unsigned short lNbComments = m_Ncom; unsigned short lNbLignes = static_cast(this->GetIORegion().GetSize()[1]); unsigned short lNbColonnes = static_cast(this->GetIORegion().GetSize()[0]); unsigned short low, high; if (m_ByteOrder == BigEndian) { header[0] = *("R"); header[1] = *("I"); ByteSplitting(lNbComments, low, high); header[2] = static_cast(low); header[3] = static_cast(high); ByteSplitting(lNbColonnes, low, high); header[4] = static_cast(low); header[5] = static_cast(high); ByteSplitting(lNbLignes, low, high); header[6] = static_cast(low); header[7] = static_cast(high); } else if (m_ByteOrder == LittleEndian) { header[0] = *("I"); header[1] = *("R"); ByteSplitting(lNbComments, low, high); header[3] = static_cast(low); header[2] = static_cast(high); ByteSplitting(lNbColonnes, low, high); header[5] = static_cast(low); header[4] = static_cast(high); ByteSplitting(lNbLignes, low, high); header[7] = static_cast(low); header[6] = static_cast(high); } else { itkExceptionMacro(<< "Unknown Byte order"); } m_File.write(header, 64); m_File.write(comments.data(), 36); otbMsgDebugMacro(<< "Driver to write: MW"); otbMsgDebugMacro(<< " Write file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " Type Mw : " << m_TypeMW); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } std::string MWImageIO::GetExtension(const std::string& filename) { // This assumes that the final '.' in a file name is the delimiter // for the file's extension type const std::string::size_type it = filename.find_last_of("."); // This determines the file's type by creating a new string // who's value is the extension of the input filename // eg. "myimage.gif" has an extension of "gif" std::string fileExt(filename, it + 1, filename.length()); //If the extension has a "/" in it then this is not an extension and there are no extension. std::string::size_type it2 = fileExt.find_last_of("/"); if (it2 != std::string::npos) { std::string fileExt3(""); return (fileExt3); } return (fileExt); } } // end namespace otb OTB-release-5.8/Modules/IO/IOMW/src/otbMWImageIOFactory.cxx000066400000000000000000000031251301006202600231770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMWImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbMWImageIO.h" #include "itkVersion.h" namespace otb { MWImageIOFactory::MWImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbMWImageIO", "MW Image IO", 1, itk::CreateObjectFunction::New()); } MWImageIOFactory::~MWImageIOFactory() { } const char* MWImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* MWImageIOFactory::GetDescription() const { return "MegaWave ImageIO Factory, permettant le chargement d'image au format MW dans l'OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool MWImageIOFactoryHasBeenRegistered; void MWImageIOFactoryRegister__Private(void) { if( ! MWImageIOFactoryHasBeenRegistered ) { MWImageIOFactoryHasBeenRegistered = true; MWImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOMW/test/000077500000000000000000000000001301006202600170675ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOMW/test/CMakeLists.txt000066400000000000000000000016001301006202600216240ustar00rootroot00000000000000otb_module_test() set(OTBIOMWTests otbIOMWTestDriver.cxx otbMWImageIOTestCanRead.cxx otbMWImageIOTestCanWrite.cxx ) add_executable(otbIOMWTestDriver ${OTBIOMWTests}) target_link_libraries(otbIOMWTestDriver ${OTBIOMW-Test_LIBRARIES}) otb_module_target_label(otbIOMWTestDriver) # Tests Declaration otb_add_test(NAME ioTuMWImageIOCanReadIMG COMMAND otbIOMWTestDriver otbMWImageIOTestCanRead ${BASELINE}/QB_Toulouse_Ortho_PAN.img) otb_add_test(NAME ioTuMWImageIOCanReadMW COMMAND otbIOMWTestDriver otbMWImageIOTestCanRead ${BASELINE}/QB_Toulouse_Ortho_PAN.mw) otb_add_test(NAME ioTuMWImageIOCanWriteIMG COMMAND otbIOMWTestDriver otbMWImageIOTestCanWrite ${TEMP}/QB_Toulouse_Ortho_PAN.img) set_property(TEST ioTuMWImageIOCanWriteIMG PROPERTY WILL_FAIL true) otb_add_test(NAME ioTuMWImageIOCanWriteMW COMMAND otbIOMWTestDriver otbMWImageIOTestCanWrite ${TEMP}/QB_Toulouse_Ortho_PAN.mw) OTB-release-5.8/Modules/IO/IOMW/test/otbIOMWTestDriver.cxx000066400000000000000000000002071301006202600231060ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMWImageIOTestCanRead); REGISTER_TEST(otbMWImageIOTestCanWrite); } OTB-release-5.8/Modules/IO/IOMW/test/otbMWImageIOTestCanRead.cxx000066400000000000000000000020041301006202600241100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMWImageIO.h" #include "itkMacro.h" #include int otbMWImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::MWImageIO::Pointer lMWImageIO = otb::MWImageIO::New(); bool lCanRead = lMWImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Error otb::MWImageIO : impossible to read MW image " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOMW/test/otbMWImageIOTestCanWrite.cxx000066400000000000000000000017621301006202600243410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMWImageIO.h" #include "itkMacro.h" #include int otbMWImageIOTestCanWrite(int itkNotUsed(argc), char* argv[]) { otb::MWImageIO::Pointer lMWImageIO = otb::MWImageIO::New(); bool lCanRead = lMWImageIO->CanWriteFile(argv[1]); if (lCanRead == false) { std::cerr << "Error image " << argv[1] << " is not a MW image." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOONERA/000077500000000000000000000000001301006202600164315ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOONERA/CMakeLists.txt000066400000000000000000000001141301006202600211650ustar00rootroot00000000000000project(OTBIOONERA) set(OTBIOONERA_LIBRARIES OTBIOONERA) otb_module_impl() OTB-release-5.8/Modules/IO/IOONERA/include/000077500000000000000000000000001301006202600200545ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOONERA/include/otbONERAImageIO.h000066400000000000000000000134261301006202600227770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbONERAImageIO_h #define otbONERAImageIO_h #include "itkByteSwapper.h" #include "otbImageIOBase.h" #include namespace otb { /** \class ONERAImageIO * * \brief ImageIO object for reading (not writing) ONERA format images * * The streaming read is implemented. * * \ingroup IOFilters * * * \ingroup OTBIOONERA */ class ITK_EXPORT ONERAImageIO : public otb::ImageIOBase { public: typedef unsigned char InputPixelType; /** Standard class typedefs. */ typedef ONERAImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ONERAImageIO, otb::ImageIOBase); /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Reads 3D data from multiple files assuming one slice per file. */ virtual void ReadVolume(void* buffer); /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; // JULIEN: NOT USED, NOT IMPLEMENTED //void SampleImage(void* buffer, int XBegin, int YBegin, int SizeXRead, int SizeYRead, int XSample, int YSample); /** Get the number of overviews available into the file specified * This imageIO didn't support overviews */ unsigned int GetOverviewsCount() ITK_OVERRIDE { // MANTIS-1154: Source image is always considered as the best // resolution overview. return 1; } /** Get information about overviews available into the file specified * This imageIO didn't support overviews */ std::vector GetOverviewsInfo() ITK_OVERRIDE { std::vector desc; return desc; } /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} protected: /** Constructor.*/ ONERAImageIO(); /** Destructor.*/ ~ONERAImageIO() ITK_OVERRIDE; bool OpenOneraDataFileForReading(const char* filename); bool OpenOneraHeaderFileForReading(const char* filename); void InternalReadImageInformation(); void InternalWriteImageInformation(); bool OpenOneraDataFileForWriting(const char* filename); bool OpenOneraHeaderFileForWriting(const char* filename); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Dimension along Ox of the image*/ int m_width; /** Dimension along Oy of the image*/ int m_height; /** Number of bands of the image*/ int m_NbBands; /** Buffer*/ //float **pafimas; std::fstream m_Datafile; std::fstream m_Headerfile; private: ONERAImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Analyze the input file name : if it's a directory, check * that a header file exists (ENT...) and set OneraFileName to it * else OneraFileName is set to filename */ void GetOneraImageFileName(const char * filename, std::string& OneraFileName); #define otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ { \ typedef itk::ByteSwapper InternalByteSwapperType; \ if (m_ByteOrder != m_FileByteOrder) \ { \ if (m_ByteOrder == LittleEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToBigEndian((StrongType *) buffer, buffer_size); \ } \ else if (m_ByteOrder == BigEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToLittleEndian((StrongType *) buffer, buffer_size); \ } \ } \ } #define otbSwappFileToSystemMacro(StrongType, WeakType, buffer, buffer_size) \ else if (this->GetComponentType() == WeakType) \ { \ otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ } /** Nombre d'octets par pixel */ int m_BytePerPixel; bool m_FlagWriteImageInformation; /** File byte order */ otb::ImageIOBase::ByteOrder m_FileByteOrder; }; } // end namespace otb #endif // otbONERAImageIO_h OTB-release-5.8/Modules/IO/IOONERA/include/otbONERAImageIOFactory.h000066400000000000000000000040421301006202600243210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbONERAImageIOFactory_h #define otbONERAImageIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class ONERAImageIOFactory * \brief Creation d'un instance d'un objet ONERAImageIO utilisant les object factory. * * \ingroup OTBIOONERA */ class ITK_EXPORT ONERAImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef ONERAImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static ONERAImageIOFactory * FactoryNew() { return new ONERAImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(ONERAImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { ONERAImageIOFactory::Pointer ONERAFactory = ONERAImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(ONERAFactory); } protected: ONERAImageIOFactory(); ~ONERAImageIOFactory() ITK_OVERRIDE; private: ONERAImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOONERA/otb-module.cmake000066400000000000000000000003451301006202600215040ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read ONERA format images.") otb_module(OTBIOONERA DEPENDS OTBImageBase OTBCommon OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOONERA/src/000077500000000000000000000000001301006202600172205ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOONERA/src/CMakeLists.txt000066400000000000000000000003601301006202600217570ustar00rootroot00000000000000set(OTBIOONERA_SRC otbONERAImageIOFactory.cxx otbONERAImageIO.cxx ) add_library(OTBIOONERA ${OTBIOONERA_SRC}) target_link_libraries(OTBIOONERA ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBIOONERA) OTB-release-5.8/Modules/IO/IOONERA/src/otbONERAImageIO.cxx000066400000000000000000000430641301006202600225170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbONERAImageIO.h" #include "itksys/SystemTools.hxx" #include "otbMacro.h" #include "otbSystem.h" #define ONERA_MAGIC_NUMBER 33554433 #define ONERA_HEADER_LENGTH 4 #define ONERA_FILE_ID_OFFSET 0 namespace otb { ONERAImageIO::ONERAImageIO() { // By default set number of dimensions to two. this->SetNumberOfDimensions(2); m_PixelType = COMPLEX; m_ComponentType = FLOAT; m_BytePerPixel = 4; // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to [0.5 , 0.5] // (consistency between ImageIO, see Mantis #942) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_FlagWriteImageInformation = true; if (itk::ByteSwapper::SystemIsLittleEndian() == true) { m_ByteOrder = LittleEndian; } else { m_ByteOrder = BigEndian; } m_FileByteOrder = BigEndian; m_width = 0; m_height = 0; m_NbBands = 0; } ONERAImageIO::~ONERAImageIO() { if (m_Datafile.is_open()) { m_Datafile.close(); } if (m_Headerfile.is_open()) { m_Headerfile.close(); } } bool ONERAImageIO::CanReadFile(const char* FileNameToRead) { std::string filename(FileNameToRead); std::string ext; if (m_Datafile.is_open()) { m_Datafile.close(); } if (m_Headerfile.is_open()) { m_Headerfile.close(); } if (itksys::SystemTools::FileIsDirectory(filename.c_str()) == true) { return false; } const std::string HeaderFileName = System::GetRootName(filename) + ".ent"; const std::string DataFileName = System::GetRootName(filename) + ".dat"; m_Headerfile.open(HeaderFileName.c_str(), std::ios::in); if (m_Headerfile.fail()) { otbMsgDevMacro(<< "ONERAImageIO::CanReadFile() failed header open ! "); return false; } m_Datafile.open(DataFileName.c_str(), std::ios::in); if (m_Datafile.fail()) { otbMsgDevMacro(<< "ONERAImageIO::CanReadFile() failed data open ! "); return false; } // Check magic_number int magicNumber; m_Datafile.seekg(0, std::ios::beg); m_Datafile.read((char*) (&magicNumber), 4); if (magicNumber == ONERA_MAGIC_NUMBER) { m_FileByteOrder = m_ByteOrder; } else { if (m_ByteOrder == LittleEndian) { m_FileByteOrder = BigEndian; } else if (m_ByteOrder == BigEndian) { m_FileByteOrder = LittleEndian; } } // Swap if necessary otbSwappFileOrderToSystemOrderMacro(int, &magicNumber, 1); m_Headerfile.close(); m_Datafile.close(); if (magicNumber == ONERA_MAGIC_NUMBER) { return true; } else { return false; } } // Used to print information about this object void ONERAImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // Read a 3D image (or event more bands)... not implemented yet void ONERAImageIO::ReadVolume(void*) { } // Read image void ONERAImageIO::Read(void* buffer) { unsigned int dim; const unsigned int dimensions = this->GetNumberOfDimensions(); unsigned long numberOfPixels = 1; for (dim = 0; dim < dimensions; ++dim) { numberOfPixels *= m_Dimensions[dim]; } unsigned char * p = static_cast(buffer); int lNbLines = this->GetIORegion().GetSize()[1]; int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] otbMsgDevMacro(<< " ONERAImageIO::Read() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); //read header information file: if (!this->OpenOneraDataFileForReading(m_FileName.c_str())) { itkExceptionMacro(<< "Cannot read requested file"); } std::streamoff numberOfBytesPerLines = static_cast(2 * m_width * m_BytePerPixel); std::streamoff headerLength = ONERA_HEADER_LENGTH + numberOfBytesPerLines; std::streamoff offset; std::streamsize numberOfBytesToBeRead = 2 * m_BytePerPixel * lNbColumns; std::streamsize numberOfBytesRead; char* value = new char[numberOfBytesToBeRead]; std::streamsize cpt = 0; for (int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(m_BytePerPixel * lFirstColumn); m_Datafile.seekg(offset, std::ios::beg); m_Datafile.read(static_cast(value), numberOfBytesToBeRead); numberOfBytesRead = m_Datafile.gcount(); #ifdef __APPLE_CC__ // fail() is broken in the Mac. It returns true when reaches eof(). if (numberOfBytesRead != numberOfBytesToBeRead) #else if ((numberOfBytesRead != numberOfBytesToBeRead) || m_Datafile.fail()) #endif { itkExceptionMacro(<< "ONERAImageIO::Read() Can Read the specified Region"); // read failed } memcpy((void*) (&(p[cpt])), (const void*) (value), (size_t) (numberOfBytesToBeRead)); cpt += numberOfBytesToBeRead; } //byte swapping depending on pixel type: unsigned long numberOfPixelsPerRegion = lNbLines * lNbColumns * 2; // Swap bytes if necessary if (0) {} otbSwappFileToSystemMacro(float, FLOAT, buffer, numberOfPixelsPerRegion) otbSwappFileToSystemMacro(double, DOUBLE, buffer, numberOfPixelsPerRegion) else { itkExceptionMacro(<< "ONERAImageIO::Read() undefined component type! "); } delete[] value; value = ITK_NULLPTR; } bool ONERAImageIO::OpenOneraDataFileForReading(const char* filename) { // Make sure that we have a file to std::string lFileName(filename); if (lFileName.empty()) { itkExceptionMacro(<< "A FileName must be specified."); return false; } // Close file from any previous image if (m_Datafile.is_open()) { m_Datafile.close(); } const std::string DataFileName = System::GetRootName(filename) + ".dat"; // Open the new file for reading m_Datafile.open(DataFileName.c_str(), std::ios::in | std::ios::binary); if (m_Datafile.fail()) { otbMsgDebugMacro(<< "ONERAImageIO::CanReadFile() failed data open ! "); return false; } return true; } bool ONERAImageIO::OpenOneraHeaderFileForReading(const char* filename) { // Make sure that we have a file to std::string lFileName(filename); if (lFileName.empty()) { itkExceptionMacro(<< "A FileName must be specified."); return false; } // Close file from any previous image if (m_Headerfile.is_open()) { m_Headerfile.close(); } const std::string HeaderFileName = System::GetRootName(filename) + ".ent"; // Open the new file for reading // Actually open the file m_Headerfile.open(HeaderFileName.c_str(), std::ios::in); if (m_Headerfile.fail()) { otbMsgDebugMacro(<< "ONERAImageIO::CanReadFile() failed header open ! "); return false; } return true; } void ONERAImageIO::ReadImageInformation() { this->InternalReadImageInformation(); } void ONERAImageIO::InternalReadImageInformation() { if (!this->OpenOneraDataFileForReading(m_FileName.c_str())) { itkExceptionMacro(<< "Cannot read ONERA data file " << m_FileName); } if (!this->OpenOneraHeaderFileForReading(m_FileName.c_str())) { itkExceptionMacro(<< "Cannot read ONERA header file " << m_FileName); } // check "Format_valeurs_look" char* sHeader = new char[1024]; // skip 2 lines m_Headerfile.getline(sHeader, 1024); m_Headerfile.getline(sHeader, 1024); m_Headerfile.getline(sHeader, 1024); std::string sPixelType(sHeader); if (sPixelType.compare("cmplx_real_4")) { m_NbBands = 1; this->SetFileTypeToBinary(); this->SetNumberOfComponents(2); this->SetPixelType(COMPLEX); m_ComponentType = FLOAT; m_BytePerPixel = 4; } else { itkExceptionMacro(<< "data format not supported by OTB (only 'complex_real_4' is available)"); } // Check magic_number int magicNumber; m_Datafile.seekg(0, std::ios::beg); m_Datafile.read((char*) (&magicNumber), 4); if (magicNumber == ONERA_MAGIC_NUMBER) { m_FileByteOrder = m_ByteOrder; } else { if (m_ByteOrder == LittleEndian) { m_FileByteOrder = BigEndian; } else if (m_ByteOrder == BigEndian) { m_FileByteOrder = LittleEndian; } } otbSwappFileOrderToSystemOrderMacro(int, &magicNumber, 1); // Find info.. : Number of Row , Nb of Columns short NbCol; m_Datafile.seekg(ONERA_HEADER_LENGTH + 2, std::ios::beg); m_Datafile.read((char*) (&NbCol), 2); otbSwappFileOrderToSystemOrderMacro(short, &NbCol, 1); m_Datafile.seekg(0, std::ios::end); long gcountHead = static_cast(ONERA_HEADER_LENGTH + 2 * 4 * NbCol); long gcount = static_cast(m_Datafile.tellg()); // Defining the image size: m_width = static_cast (NbCol); m_height = static_cast ((gcount - gcountHead) / (4 * 2 * NbCol)); if ((m_width == 0) || (m_height == 0)) { itkExceptionMacro(<< "Unknown image dimension"); } else { // Set image dimensions into IO m_Dimensions[0] = m_width; m_Dimensions[1] = m_height; } this->SetNumberOfDimensions(2); otbMsgDebugMacro(<< "Driver to read: ONERA"); otbMsgDebugMacro(<< " Read file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " PixelType : " << this->GetPixelTypeAsString(this->GetPixelType())); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentTypeAsString(this->GetComponentType())); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " BytePerPixel : " << m_BytePerPixel); otbMsgDebugMacro(<< " Host byte order : " << this->GetByteOrderAsString(m_ByteOrder)); otbMsgDebugMacro(<< " File byte order : " << this->GetByteOrderAsString(m_FileByteOrder)); delete [] sHeader; } bool ONERAImageIO::OpenOneraDataFileForWriting(const char* filename) { // Make sure that we have a file to std::string lFileName(filename); if (lFileName.empty()) { itkExceptionMacro(<< "A FileName must be specified."); return false; } // Close file from any previous image if (m_Datafile.is_open()) { m_Datafile.close(); } const std::string DataFileName = System::GetRootName(filename) + ".dat"; // Open the new file for reading // Actually open the file m_Datafile.open(DataFileName.c_str(), std::ios::out | std::ios::trunc | std::ios::binary); if (m_Datafile.fail()) { otbMsgDebugMacro(<< "ONERAImageIO::OpenOneraDataFileForWriting() failed data open ! "); return false; } return true; } bool ONERAImageIO::OpenOneraHeaderFileForWriting(const char* filename) { // Make sure that we have a file to std::string lFileName(filename); if (lFileName.empty()) { itkExceptionMacro(<< "A FileName must be specified."); return false; } // Close file from any previous image if (m_Headerfile.is_open()) { m_Headerfile.close(); } const std::string HeaderFileName = System::GetRootName(filename) + ".ent"; // Open the new file for reading // Actually open the file m_Headerfile.open(HeaderFileName.c_str(), std::ios::out | std::ios::trunc | std::ios::binary); if (m_Headerfile.fail()) { otbMsgDebugMacro(<< "ONERAImageIO::OpenOneraHeaderFileForWriting() failed header open ! "); return false; } return true; } bool ONERAImageIO::CanWriteFile(const char* FileNameToWrite) { std::string filename(FileNameToWrite); const std::string HeaderFileName = System::GetRootName(filename) + ".ent"; const std::string DataFileName = System::GetRootName(filename) + ".dat"; if (filename == HeaderFileName) { return true; } else { return false; } } void ONERAImageIO::Write(const void* buffer) { if (m_FlagWriteImageInformation == true) { this->InternalWriteImageInformation(); m_FlagWriteImageInformation = false; } unsigned long step = this->GetNumberOfComponents() * 2; unsigned int lNbLines = this->GetIORegion().GetSize()[1]; unsigned int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] otbMsgDevMacro(<< " ONERAImageIO::Write() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); // Special case: we check if the region to write is the same as the whole image // We begin with a zero offset when we are not in streaming if ((lNbLines == m_Dimensions[1]) && (lNbColumns == m_Dimensions[0])) { otbMsgDevMacro(<< "Force l'offset de l'IORegion a 0"); lFirstLine = 0; lFirstColumn = 0; } std::streamsize numberOfBytesPerLines = step * lNbColumns * m_BytePerPixel; std::streamoff headerLength = ONERA_HEADER_LENGTH + numberOfBytesPerLines; std::streamoff offset; unsigned long numberOfBytesRegion = step * m_BytePerPixel * lNbColumns * lNbLines; char *tempmemory = new char[numberOfBytesRegion]; memcpy(tempmemory, buffer, numberOfBytesRegion); for (unsigned int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { char* value = tempmemory + numberOfBytesPerLines * (LineNo - lFirstLine); offset = headerLength + static_cast(numberOfBytesPerLines) * static_cast(LineNo); offset += static_cast(m_BytePerPixel * lFirstColumn); m_Datafile.seekp(offset, std::ios::beg); m_Datafile.write(static_cast(value), numberOfBytesPerLines); } delete[] tempmemory; tempmemory = ITK_NULLPTR; } // To be consistent with the behavior of GDALImageIO void ONERAImageIO::WriteImageInformation() { } void ONERAImageIO::InternalWriteImageInformation() { if (!this->OpenOneraHeaderFileForWriting(m_FileName.c_str())) { itkExceptionMacro(<< "Cannot read requested file"); } if (!this->OpenOneraDataFileForWriting(m_FileName.c_str())) { itkExceptionMacro(<< "Cannot read requested file"); } /*-------- This part deals with writing header information ------ */ const std::string DataFileName = System::GetRootName(m_FileName.c_str()) + ".dat"; m_Headerfile << "# [fichier en-tete produit par les routines de otb (Orfeo ToolBox) ]" << std::endl; m_Headerfile << "# Nom du look :" << std::endl; m_Headerfile << "Look.dat= \t" << DataFileName.c_str() << std::endl; m_Headerfile << std::endl; m_Headerfile << "# Structure du fichier et codage des pixels :" << std::endl; m_Headerfile << "# 4 octets precedent la premiere ligne : ils correspondent a un nombre magique [I4= 33554433] " << std::endl; m_Headerfile << "# [dans ordre LSBfirst = big-endian]" << std::endl; std::string sPixelType("cmplx_real_4"); if ((m_PixelType == COMPLEX) && (m_ComponentType == CFLOAT)) { sPixelType = "cmplx_real_4"; } else { itkExceptionMacro(<< "data format not supported by OTB (only 'complex_real_4' is available) : "); } m_Headerfile << "Format_valeurs_look= \t" << sPixelType << std::endl; m_Headerfile << "Nb_case_par_ligne_look= \t" << m_Dimensions[0] << std::endl; m_Headerfile << "Nb_ligne_look= \t" << m_Dimensions[1] << " + 1 ligne en-tete en binaire (entiers 16 bit) " << std::endl; // write magic_number int magicNumber = ONERA_MAGIC_NUMBER; short NbCol = static_cast(m_Dimensions[0]); short NbRow = static_cast(m_Dimensions[1]); int ByteSizeCol = NbCol * 4 * 2; // itk::ByteSwapper< int>::SwapFromSystemToLittleEndian(&magicNumber); m_Datafile.seekp(0, std::ios::beg); m_Datafile.write((char*) (&magicNumber), 4); char * tab = new char[ByteSizeCol]; for (int i = 0; i < (NbRow + 1); ++i) { m_Datafile.write((char*) (tab), ByteSizeCol); } delete[] tab; // write number of columns // itk::ByteSwapper::SwapFromSystemToLittleEndian(&NbCol); m_Datafile.seekp(ONERA_HEADER_LENGTH + 2, std::ios::beg); m_Datafile.write((char*) (&NbCol), 2); otbMsgDebugMacro(<< "Driver to write: ONERA"); otbMsgDebugMacro(<< " Write file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " BytePerPixel : " << m_BytePerPixel); otbMsgDebugMacro(<< " Host byte order : " << this->GetByteOrderAsString(m_ByteOrder)); } } // end namespace otb OTB-release-5.8/Modules/IO/IOONERA/src/otbONERAImageIOFactory.cxx000066400000000000000000000032061301006202600240410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbONERAImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbONERAImageIO.h" #include "itkVersion.h" namespace otb { ONERAImageIOFactory::ONERAImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbONERAImageIO", "ONERA Image IO", 1, itk::CreateObjectFunction::New()); } ONERAImageIOFactory::~ONERAImageIOFactory() { } const char* ONERAImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* ONERAImageIOFactory::GetDescription() const { return "ONERA ImageIO Factory, permettant le chargement d'image au format ONERA dans l'OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool ONERAImageIOFactoryHasBeenRegistered; void ONERAImageIOFactoryRegister__Private(void) { if( ! ONERAImageIOFactoryHasBeenRegistered ) { ONERAImageIOFactoryHasBeenRegistered = true; ONERAImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOONERA/test/000077500000000000000000000000001301006202600174105ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOONERA/test/CMakeLists.txt000066400000000000000000000006611301006202600221530ustar00rootroot00000000000000otb_module_test() set(OTBIOONERATests otbIOONERATestDriver.cxx otbONERAImageIOTestCanRead.cxx ) add_executable(otbIOONERATestDriver ${OTBIOONERATests}) target_link_libraries(otbIOONERATestDriver ${OTBIOONERA-Test_LIBRARIES}) otb_module_target_label(otbIOONERATestDriver) # Tests Declaration otb_add_test(NAME ioTuONERAImageIOCanRead COMMAND otbIOONERATestDriver otbONERAImageIOTestCanRead LARGEINPUT{ONERA/spa3_0215_rad.ent}) OTB-release-5.8/Modules/IO/IOONERA/test/otbIOONERATestDriver.cxx000066400000000000000000000001371301006202600237520ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbONERAImageIOTestCanRead); } OTB-release-5.8/Modules/IO/IOONERA/test/otbONERAImageIOTestCanRead.cxx000066400000000000000000000020351301006202600247560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbONERAImageIO.h" #include "itkMacro.h" #include int otbONERAImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::ONERAImageIO::Pointer lONERAImageIO = otb::ONERAImageIO::New(); bool lCanRead = lONERAImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::ONERAImageIO : impossible d'ouvrir l'image " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IORAD/000077500000000000000000000000001301006202600161735ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IORAD/CMakeLists.txt000066400000000000000000000001061301006202600207300ustar00rootroot00000000000000project(OTBIORAD) set(OTBIORAD_LIBRARIES OTBIORAD) otb_module_impl() OTB-release-5.8/Modules/IO/IORAD/include/000077500000000000000000000000001301006202600176165ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IORAD/include/otbRADImageIO.h000066400000000000000000000134031301006202600222760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRADImageIO_h #define otbRADImageIO_h #include "otbImageIOBase.h" #include #include #include namespace otb { /** \class RADImageIO * * \brief ImageIO object for reading (not writing) RAD format images * * The streaming read is implemented. * * \ingroup IOFilters * * * \ingroup OTBIORAD */ class ITK_EXPORT RADImageIO : public otb::ImageIOBase { public: /** Standard class typedefs. */ typedef RADImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Byte order typedef */ typedef Superclass::ByteOrder ByteOrder; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RADImageIO, otb::ImageIOBase); /*-------- This part of the interface deals with reading data. ------ */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Reads 3D data from multiple files assuming one slice per file. */ virtual void ReadVolume(void* buffer); /*-------- This part of the interfaces deals with writing data. ----- */ /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; // JULIEN: NOT USED, NOT IMPLEMENTED // void SampleImage(void* buffer, int XBegin, int YBegin, int SizeXRead, int SizeYRead, int XSample, int YSample); /** Get the number of overviews available into the file specified * This imageIO didn't support overviews */ unsigned int GetOverviewsCount() ITK_OVERRIDE { // MANTIS-1154: Source image is always considered as the best // resolution overview. return 1; } /** Get information about overviews available into the file specified * This imageIO didn't support overviews */ std::vector GetOverviewsInfo() ITK_OVERRIDE { std::vector desc; return desc; } /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} protected: /** Constructor.*/ RADImageIO(); /** Destructor.*/ ~RADImageIO() ITK_OVERRIDE; bool OpenOneraDataFileForReading(const char* filename); bool OpenOneraHeaderFileForReading(const char* filename); void InternalReadImageInformation(); bool OpenOneraDataFileForWriting(const char* filename); bool OpenOneraHeaderFileForWriting(const char* filename); void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RADImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Internal method to read header information */ bool InternalReadHeaderInformation(const std::string& file_name, std::fstream& file, const bool reportError); #define otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ { \ typedef itk::ByteSwapper InternalByteSwapperType; \ if (m_ByteOrder != m_FileByteOrder) \ { \ if (m_ByteOrder == LittleEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToBigEndian((StrongType *) buffer, buffer_size); \ } \ else if (m_ByteOrder == BigEndian) \ { \ InternalByteSwapperType::SwapRangeFromSystemToLittleEndian((StrongType *) buffer, buffer_size); \ } \ } \ } #define otbSwappFileToSystemMacro(StrongType, WeakType, buffer, buffer_size) \ else if (this->GetComponentType() == WeakType) \ { \ otbSwappFileOrderToSystemOrderMacro(StrongType, buffer, buffer_size) \ } #define otbSetTypeRADMacro(WeakType, CAI_VALUE) \ else if (this->GetComponentType() == WeakType) \ { \ m_TypeRAD = CAI_VALUE; \ } bool m_FlagWriteImageInformation; otb::ImageIOBase::ByteOrder m_FileByteOrder; std::fstream m_HeaderFile; std::string m_TypeRAD; std::vector m_ChannelsFileName; std::fstream * m_ChannelsFile; unsigned int m_NbOfChannels; int m_BytePerPixel; }; } // end namespace otb #endif // otbRADImageIO_h OTB-release-5.8/Modules/IO/IORAD/include/otbRADImageIOFactory.h000066400000000000000000000040021301006202600236210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRADImageIOFactory_h #define otbRADImageIOFactory_h #include "itkObjectFactoryBase.h" namespace otb { /** \class RADImageIOFactory * \brief Creation d'un instance d'un objet RADImageIO utilisant les object factory. * * \ingroup OTBIORAD */ class ITK_EXPORT RADImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef RADImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static RADImageIOFactory * FactoryNew() { return new RADImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(RADImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { RADImageIOFactory::Pointer RADFactory = RADImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(RADFactory); } protected: RADImageIOFactory(); ~RADImageIOFactory() ITK_OVERRIDE; private: RADImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IORAD/otb-module.cmake000066400000000000000000000003411301006202600212420ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read RAD format images.") otb_module(OTBIORAD DEPENDS OTBImageBase OTBCommon OTBITK TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IORAD/src/000077500000000000000000000000001301006202600167625ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IORAD/src/CMakeLists.txt000066400000000000000000000003421301006202600215210ustar00rootroot00000000000000set(OTBIORAD_SRC otbRADImageIOFactory.cxx otbRADImageIO.cxx ) add_library(OTBIORAD ${OTBIORAD_SRC}) target_link_libraries(OTBIORAD ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBIORAD) OTB-release-5.8/Modules/IO/IORAD/src/otbRADImageIO.cxx000066400000000000000000000543211301006202600220210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRADImageIO.h" #include #include #include "itkByteSwapper.h" #include "otbSystem.h" #include "itksys/SystemTools.hxx" #include "otbMacro.h" namespace otb { RADImageIO::RADImageIO() { // By default set number of dimensions to two. this->SetNumberOfDimensions(2); // By default the type to CI2 m_TypeRAD = "CR4"; m_BytePerPixel = 8; m_NbOfChannels = 1; this->SetNumberOfComponents(2); m_PixelType = COMPLEX; m_ComponentType = FLOAT; if (itk::ByteSwapper::SystemIsLittleEndian() == true) { m_ByteOrder = LittleEndian; } else { m_ByteOrder = BigEndian; } m_FileByteOrder = m_ByteOrder; // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to [0.5 , 0.5] // (consistency between ImageIO, see Mantis #942) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_ChannelsFile = ITK_NULLPTR; m_FlagWriteImageInformation = true; this->AddSupportedWriteExtension(".rad"); this->AddSupportedWriteExtension(".RAD"); this->AddSupportedReadExtension(".rad"); this->AddSupportedReadExtension(".RAD"); } RADImageIO::~RADImageIO() { if (m_HeaderFile.is_open()) { m_HeaderFile.close(); } if (m_ChannelsFile != ITK_NULLPTR) { for (unsigned int numChannel = 0; numChannel < m_NbOfChannels; ++numChannel) { if (m_ChannelsFile[numChannel].is_open()) { m_ChannelsFile[numChannel].close(); } } delete[] m_ChannelsFile; } } bool RADImageIO::CanReadFile(const char* filename) { std::fstream header_file; std::string lFileName(filename); if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } if (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(lFileName)) != ".rad") { return false; } header_file.open(lFileName.c_str(), std::ios::in); if (header_file.fail()) { otbMsgDevMacro(<< "RADImageIO::CanReadFile() failed header open ! "); return false; } //Read header information bool lResult = InternalReadHeaderInformation(lFileName, header_file, true); header_file.close(); return (lResult); } // Used to print information about this object void RADImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // Read a 3D image (or event more bands)... not implemented yet void RADImageIO::ReadVolume(void*) { } // Read image void RADImageIO::Read(void* buffer) { unsigned long step = this->GetNumberOfComponents(); char * p = static_cast(buffer); int lNbLines = this->GetIORegion().GetSize()[1]; int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] otbMsgDevMacro(<< " RADImageIO::Read() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); otbMsgDevMacro(<< " Size Of Components : " << this->GetComponentSize()); otbMsgDevMacro(<< " Nb Of Channels : " << m_NbOfChannels); std::streamoff headerLength(0); std::streamoff offset; std::streamoff numberOfBytesPerLines = static_cast(m_BytePerPixel * m_Dimensions[0]); std::streamsize numberOfBytesToBeRead = m_BytePerPixel * lNbColumns; std::streamsize numberOfBytesRead; unsigned long cpt = 0; // Update the step variable step = step * (unsigned long) (this->GetComponentSize()); char * value = new char[numberOfBytesToBeRead]; if (value == ITK_NULLPTR) { itkExceptionMacro(<< "RADImageIO::Read(): Bad alloc"); return; } otbMsgDevMacro(<< " sizeof(streamsize) : " << sizeof(std::streamsize)); otbMsgDevMacro(<< " sizeof(streampos) : " << sizeof(std::streampos)); otbMsgDevMacro(<< " sizeof(streamoff) : " << sizeof(std::streamoff)); otbMsgDevMacro(<< " sizeof(std::ios::beg) : " << sizeof(std::ios::beg)); otbMsgDevMacro(<< " sizeof(size_t) : " << sizeof(size_t)); otbMsgDevMacro(<< " sizeof(unsigned long) : " << sizeof(unsigned long)); for (unsigned int numChannel = 0; numChannel < m_NbOfChannels; ++numChannel) { cpt = (unsigned long) (numChannel) * (unsigned long) (m_BytePerPixel); //Read region of the channel for (int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(m_BytePerPixel * lFirstColumn); m_ChannelsFile[numChannel].seekg(offset, std::ios::beg); //Read a line m_ChannelsFile[numChannel].read(static_cast(value), numberOfBytesToBeRead); numberOfBytesRead = m_ChannelsFile[numChannel].gcount(); #ifdef __APPLE_CC__ // fail() is broken in the Mac. It returns true when reaches eof(). if (numberOfBytesRead != numberOfBytesToBeRead) #else if ((numberOfBytesRead != numberOfBytesToBeRead) || m_ChannelsFile[numChannel].fail()) #endif { itkExceptionMacro(<< "RADImageIO::Read() Can Read the specified Region"); // read failed } for (std::streamsize i = 0; i < numberOfBytesToBeRead; i = i + static_cast(m_BytePerPixel)) { memcpy((void*) (&(p[cpt])), (const void*) (&(value[i])), (size_t) (m_BytePerPixel)); cpt += step; } } } unsigned long numberOfPixelsOfRegion = lNbLines * lNbColumns * this->GetNumberOfComponents(); // Swap bytes if necessary if (0) {} otbSwappFileToSystemMacro(unsigned short, USHORT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(short, SHORT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(char, CHAR, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(unsigned char, UCHAR, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(unsigned int, UINT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(int, INT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(long, LONG, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(unsigned long, ULONG, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(float, FLOAT, buffer, numberOfPixelsOfRegion) otbSwappFileToSystemMacro(double, DOUBLE, buffer, numberOfPixelsOfRegion) else { itkExceptionMacro(<< "RADImageIO::Read() undefined component type! "); } delete[] value; value = ITK_NULLPTR; } void RADImageIO::ReadImageInformation() { if (m_HeaderFile.is_open()) { m_HeaderFile.close(); } m_HeaderFile.open(m_FileName.c_str(), std::ios::in); if (m_HeaderFile.fail()) { itkExceptionMacro(<< "RADImageIO::ReadImageInformation() failed header open ! "); } //Read header information InternalReadHeaderInformation(m_FileName, m_HeaderFile, true); otbMsgDebugMacro(<< "Driver to read: RAD"); otbMsgDebugMacro(<< " Read file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } bool RADImageIO::InternalReadHeaderInformation(const std::string& file_name, std::fstream& file, const bool reportError) { std::string lString; std::string lStrCodePix; // Read NBCOLONNES information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if ((lString != "NBCOLONNES") && (lString != "NBCOLUMNS")) { if (reportError == true) { itkExceptionMacro(<< "RAD : 'NBCOLONNES' keyword is not find in the header file."); } else { return false; } } file >> m_Dimensions[0]; // Read NBLIGNES information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if ((lString != "NBLIGNES") && (lString != "NBLINES")) { if (reportError == true) { itkExceptionMacro(<< "RAD : 'NBLIGNES' keyword is not find in the header file."); } else { return false; } } file >> m_Dimensions[1]; // Read NBPLANS information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if ((lString != "NBPLANS") && (lString != "NBBANDS")) { if (reportError == true) { itkExceptionMacro(<< "RAD : 'NBPLANS' keyword is not find in the header file."); } else { return false; } } file >> m_NbOfChannels; // Because we read complex : *2 this->SetNumberOfComponents(2 * m_NbOfChannels); // Read TYPECODAGE information file >> lString; lString = itksys::SystemTools::UpperCase(lString); if ((lString != "TYPECODAGE") && (lString != "TYPE")) { if (reportError == true) { itkExceptionMacro(<< "RAD : the first line of the header file must be contains 'TYPECODAGE' caracters."); } else { return false; } } file >> lStrCodePix; lStrCodePix = itksys::SystemTools::UpperCase(lStrCodePix); if (lStrCodePix == "OCT") { m_PixelType = SCALAR; SetComponentType(UCHAR); m_BytePerPixel = 1; } if (lStrCodePix == "PHA") { m_PixelType = SCALAR; SetComponentType(CHAR); m_BytePerPixel = 1; } if (lStrCodePix == "I2") { m_PixelType = SCALAR; SetComponentType(SHORT); m_BytePerPixel = 2; } if (lStrCodePix == "I4") { m_PixelType = SCALAR; SetComponentType(INT); m_BytePerPixel = 4; } if (lStrCodePix == "R4") { m_PixelType = SCALAR; SetComponentType(FLOAT); m_BytePerPixel = 4; } else if (lStrCodePix == "CI2") { m_PixelType = COMPLEX; SetComponentType(SHORT); m_BytePerPixel = 4; } else if (lStrCodePix == "CR4") { m_PixelType = COMPLEX; SetComponentType(FLOAT); m_BytePerPixel = 8; } else if (lStrCodePix == "COCT") { m_PixelType = COMPLEX; SetComponentType(UCHAR); m_BytePerPixel = 2; } /* else if(lStrCodePix == "C3B") { m_PixelType = COMPLEX; SetComponentType(FLOAT); m_BytePerPixel=2; } else if(lStrCodePix == "C5B") { m_PixelType = COMPLEX; SetComponentType(FLOAT); m_BytePerPixel=2; } else if(lStrCodePix == "C7B") { m_PixelType = COMPLEX; SetComponentType(FLOAT); m_BytePerPixel=2; } */ else if (lStrCodePix == "CI4") { m_PixelType = COMPLEX; SetComponentType(INT); m_BytePerPixel = 8; } else if (lStrCodePix == "CR8") { m_PixelType = COMPLEX; SetComponentType(DOUBLE); m_BytePerPixel = 16; } else { if (reportError == true) { itkExceptionMacro( << "RAD : the value type '" << lStrCodePix << "' (second line) set in the header file is not recognized as correct value."); } else { return false; } } // Read "SENSCODAGE" information (optional) file >> lString; if (lString.empty() == false) { lString = itksys::SystemTools::UpperCase(lString); if ((lString == "SENSCODAGE") || (lString == "ORDER")) { file >> lString; lString = itksys::SystemTools::UpperCase(lString); if (lString == "INTEL") { m_FileByteOrder = LittleEndian; } else if (lString == "IEEE") { m_FileByteOrder = BigEndian; } else { if (reportError == true) { itkExceptionMacro( << "RAD : the value SENSCODAGE '" << lString << "' set in the header file is not recognized as correct value. Possible values are INTEL or IEEE"); } else { return false; } } } } // Read FileName information std::string lPathName = itksys::SystemTools::GetFilenamePath(file_name); m_ChannelsFileName.clear(); for (unsigned int i = 0; i < m_NbOfChannels; ++i) { file >> lString; std::ostringstream lStream; lStream << lPathName << "/" << lString; m_ChannelsFileName.push_back(lStream.str()); } file.close(); m_ChannelsFile = new std::fstream[m_NbOfChannels]; // Try to open channels file for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels) { m_ChannelsFile[channels].open(m_ChannelsFileName[channels].c_str(), std::ios::in | std::ios::binary); if (m_ChannelsFile[channels].fail()) { if (reportError == true) { itkExceptionMacro(<< "RAD : impossible to find the file <" << m_ChannelsFileName[channels] << ">."); } else { return false; } } } this->SetFileTypeToBinary(); this->SetNumberOfDimensions(2); return (true); } bool RADImageIO::CanWriteFile(const char* filename) { std::string lFileName(filename); if (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(lFileName)) != ".rad") { return false; } if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true) { return false; } return true; } void RADImageIO::Write(const void* buffer) { if (m_FlagWriteImageInformation == true) { this->WriteImageInformation(); m_FlagWriteImageInformation = false; } unsigned long step = this->GetNumberOfComponents(); unsigned int lNbLines = this->GetIORegion().GetSize()[1]; unsigned int lNbColumns = this->GetIORegion().GetSize()[0]; int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ] int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ] // Special case : we control that if the region to write has the same dimension that the entire picture, // we start to the offset to 0 ( when ze4re not in "Streaming") if ((lNbLines == m_Dimensions[1]) && (lNbColumns == m_Dimensions[0])) { otbMsgDevMacro(<< "Force the IORegion offset to 0"); lFirstLine = 0; lFirstColumn = 0; } otbMsgDevMacro(<< " RADImageIO::Write() "); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); otbMsgDevMacro(<< " GetComponentSize : " << this->GetComponentSize()); std::streamoff headerLength(0); std::streamoff numberOfBytesPerLines = static_cast(m_BytePerPixel * m_Dimensions[0]); std::streamsize numberOfBytesToBeWrite = static_cast(m_BytePerPixel * lNbColumns); std::streamoff offset = 0; unsigned long cpt = 0; // Update the step variable step = m_BytePerPixel; const char * p = static_cast(buffer); char* value = new char[numberOfBytesToBeWrite]; if (value == ITK_NULLPTR) { itkExceptionMacro(<< "RADImageIO::Write : Bad Alloc"); return; } for (unsigned int numChannel = 0; numChannel < m_NbOfChannels; ++numChannel) { cpt = (unsigned long) (numChannel) * (unsigned long) (m_BytePerPixel); //Read region of the channel for (unsigned int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++) { for (std::streamsize i = 0; i < numberOfBytesToBeWrite; i = i + static_cast(m_BytePerPixel)) { memcpy((void*) (&(value[i])), (const void*) (&(p[cpt])), (size_t) (m_BytePerPixel)); cpt += step; } offset = headerLength + numberOfBytesPerLines * static_cast(LineNo); offset += static_cast(m_BytePerPixel * lFirstColumn); m_ChannelsFile[numChannel].seekp(offset, std::ios::beg); //Write a line m_ChannelsFile[numChannel].write(static_cast(value), numberOfBytesToBeWrite); } } delete[] value; } void RADImageIO::WriteImageInformation() { if (m_FileName == "") { itkExceptionMacro(<< "A FileName must be specified."); } if (CanWriteFile(m_FileName.c_str()) == false) { itkExceptionMacro(<< "The file " << m_FileName.c_str() << " is not defined as a RAD file"); } // Close file from any previous image if (m_HeaderFile.is_open()) { m_HeaderFile.close(); } // Open the new file for writing // Actually open the file m_HeaderFile.open(m_FileName.c_str(), std::ios::out | std::ios::trunc); if (m_HeaderFile.fail()) { itkExceptionMacro(<< "Cannot write requested file " << m_FileName.c_str() << "."); } //Write COLUMNS information m_HeaderFile << "NBCOLUMNS "; m_HeaderFile << m_Dimensions[0] << std::endl; //Write LINES information m_HeaderFile << "NBLINES "; m_HeaderFile << m_Dimensions[1] << std::endl; //Write CHANNELS information m_HeaderFile << "NBBANDS "; m_HeaderFile << m_NbOfChannels << std::endl; std::string lString; //Write TYPE information m_HeaderFile << "TYPECODAGE "; std::string lExtension; std::string lStringPixelType = itksys::SystemTools::UpperCase(this->GetPixelTypeAsString(m_PixelType)); std::string lStringComponentType = itksys::SystemTools::UpperCase(this->GetComponentTypeAsString(this->GetComponentType())); if (lStringPixelType == "SCALAR") { if (lStringComponentType == "UCHAR") { m_BytePerPixel = 1; m_TypeRAD = "OCT"; lExtension = ".oct"; } else if (lStringComponentType == "CHAR") { m_BytePerPixel = 1; m_TypeRAD = "PHA"; lExtension = ".pha"; } else if (lStringComponentType == "SHORT") { m_BytePerPixel = 2; m_TypeRAD = "I2"; lExtension = ".i2"; } else if (lStringComponentType == "INT") { m_BytePerPixel = 4; m_TypeRAD = "I4"; lExtension = ".i4"; } else if (lStringComponentType == "FLOAT") { m_BytePerPixel = 4; m_TypeRAD = "R4"; lExtension = ".r4"; } } else if (lStringPixelType == "COMPLEX") { if (lStringComponentType == "SHORT") { m_BytePerPixel = 4; m_TypeRAD = "CI2"; lExtension = ".ci2"; } else if (lStringComponentType == "FLOAT") { m_BytePerPixel = 8; m_TypeRAD = "CR4"; lExtension = ".cr4"; } if (lStringComponentType == "CHAR") { m_BytePerPixel = 2; m_TypeRAD = "COCT"; lExtension = ".coct"; } /* if( this->GetComponentType()=="FLOAT") { m_BytePerPixel=2; m_TypeRAD = "C3B" } if( this->GetComponentType()==FLOAT) { m_BytePerPixel=2; m_TypeRAD = "C5B" } if( this->GetComponentType()==FLOAT) { m_BytePerPixel=2; m_TypeRAD = "C7B" } */ else if (lStringComponentType == "INT") { m_BytePerPixel = 8; m_TypeRAD = "CI4"; lExtension = ".ci4"; } else if (lStringComponentType == "DOUBLE") { m_BytePerPixel = 16; m_TypeRAD = "CR8"; lExtension = ".cr8"; } } m_HeaderFile << m_TypeRAD << std::endl; //Write "SENSCODAGE" information m_HeaderFile << "SENSCODAGE "; // << std::endl; if (m_ByteOrder == LittleEndian) { m_HeaderFile << "INTEL" << std::endl; } else { m_HeaderFile << "IEEE" << std::endl; } //Define channels file name std::string lRootName = System::GetRootName(m_FileName); m_ChannelsFileName.clear(); for (unsigned int i = 0; i < m_NbOfChannels; ++i) { std::ostringstream lStream; lStream << lRootName << "_" << i + 1 << lExtension; m_ChannelsFileName.push_back(lStream.str()); } for (unsigned int i = 0; i < m_NbOfChannels; ++i) { m_HeaderFile << itksys::SystemTools::GetFilenameName(this->m_ChannelsFileName[i].c_str()) << std::endl; } m_HeaderFile.close(); //Allocate buffer of stream file m_ChannelsFile = new std::fstream[m_NbOfChannels]; //Try to open channels file for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels) { m_ChannelsFile[channels].open( m_ChannelsFileName[channels].c_str(), std::ios::out | std::ios::trunc | std::ios::binary); if (m_ChannelsFile[channels].fail()) { itkExceptionMacro(<< "RAD : impossible to find the file <" << m_ChannelsFileName[channels] << ">."); } } this->SetFileTypeToBinary(); this->SetNumberOfDimensions(2); this->SetNumberOfComponents(2 * m_NbOfChannels); unsigned long numberOfBytesPerLines = m_BytePerPixel * m_Dimensions[0]; char* value = new char[numberOfBytesPerLines]; for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels) { m_ChannelsFile[channels].seekp(0, std::ios::beg); //Write Header line and all file (whitout information) for (unsigned int numLigne = 0; numLigne < (m_Dimensions[1]); numLigne++) { m_ChannelsFile[channels].write(value, numberOfBytesPerLines); } } delete[] value; otbMsgDebugMacro(<< "Driver to write: RAD"); otbMsgDebugMacro(<< " Write file : " << m_FileName); otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDebugMacro(<< " Type Rad : " << m_TypeRAD); otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType()); otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents()); otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize()); otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize()); } } // end namespace otb OTB-release-5.8/Modules/IO/IORAD/src/otbRADImageIOFactory.cxx000066400000000000000000000031411301006202600233430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRADImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbRADImageIO.h" #include "itkVersion.h" namespace otb { RADImageIOFactory::RADImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbRADImageIO", "RAD Image IO", 1, itk::CreateObjectFunction::New()); } RADImageIOFactory::~RADImageIOFactory() { } const char* RADImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* RADImageIOFactory::GetDescription() const { return "RAD ImageIO Factory, permettant le chargement d'image au format RAD dans l'OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool RADImageIOFactoryHasBeenRegistered; void RADImageIOFactoryRegister__Private(void) { if( ! RADImageIOFactoryHasBeenRegistered ) { RADImageIOFactoryHasBeenRegistered = true; RADImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IORAD/test/000077500000000000000000000000001301006202600171525ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IORAD/test/CMakeLists.txt000066400000000000000000000012741301006202600217160ustar00rootroot00000000000000otb_module_test() set(OTBIORADTests otbIORADTestDriver.cxx otbRADImageIOTestCanRead.cxx ) add_executable(otbIORADTestDriver ${OTBIORADTests}) target_link_libraries(otbIORADTestDriver ${OTBIORAD-Test_LIBRARIES}) otb_module_target_label(otbIORADTestDriver) # Tests Declaration otb_add_test(NAME ioTuRADImageIOCanRead_RADCR4sngl COMMAND otbIORADTestDriver otbRADImageIOTestCanRead ${INPUTDATA}/RADCR4_image.rad ) otb_add_test(NAME ioTuRADImageIOCanRead_RADCR4mult COMMAND otbIORADTestDriver otbRADImageIOTestCanRead ${INPUTDATA}/RADCR4_multimage.rad ) otb_add_test(NAME ioTuRADImageIOCanRead_RADCI2 COMMAND otbIORADTestDriver otbRADImageIOTestCanRead LARGEINPUT{RAD_CI2/3017_HH.rad}) OTB-release-5.8/Modules/IO/IORAD/test/otbIORADTestDriver.cxx000066400000000000000000000001351301006202600232540ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbRADImageIOTestCanRead); } OTB-release-5.8/Modules/IO/IORAD/test/otbRADImageIOTestCanRead.cxx000066400000000000000000000020011301006202600242530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRADImageIO.h" #include "itkMacro.h" #include int otbRADImageIOTestCanRead(int itkNotUsed(argc), char* argv[]) { otb::RADImageIO::Pointer lRADImageIO = otb::RADImageIO::New(); bool lCanRead = lRADImageIO->CanReadFile(argv[1]); if (lCanRead == false) { std::cerr << "Erreur otb::RADImageIO : impossible to read file: " << argv[1] << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOTileMap/000077500000000000000000000000001301006202600171205ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOTileMap/CMakeLists.txt000066400000000000000000000001221301006202600216530ustar00rootroot00000000000000project(OTBIOTileMap) set(OTBIOTileMap_LIBRARIES OTBIOTileMap) otb_module_impl() OTB-release-5.8/Modules/IO/IOTileMap/include/000077500000000000000000000000001301006202600205435ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOTileMap/include/otbTileMapImageIO.h000066400000000000000000000160571301006202600241600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileMapImageIO_h #define otbTileMapImageIO_h /* C++ Libraries */ #include #include //#include "stdlib.h" /* ITK Libraries */ #include "otbImageIOBase.h" #include "otbImageRegionTileMapSplitter.h" #include "otbCurlHelperInterface.h" #include "OTBIOTileMapExport.h" namespace otb { namespace TileMapAddressingStyle { enum TileMapAddressingStyle {GM = 0, OSM = 1, NEARMAP = 2, LOCAL = 3}; } /** \class TileMapImageIO * * \brief ImageIO object for reading and writing TileMap images * * * * \ingroup OTBIOTileMap */ class OTBIOTileMap_EXPORT TileMapImageIO : public otb::ImageIOBase { public: typedef unsigned char InputPixelType; /** Standard class typedefs. */ typedef TileMapImageIO Self; typedef otb::ImageIOBase Superclass; typedef itk::SmartPointer Pointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TileMapImageIO, otb::ImageIOBase); typedef itk::ImageIORegion ImageIORegion; /** Set/Get the level of compression for the output images. * 0-9; 0 = none, 9 = maximum. */ itkSetMacro(CompressionLevel, int); itkGetMacro(CompressionLevel, int); /** Set/Get the maximum number of connections */ itkSetMacro(MaxConnect, int); itkGetMacro(MaxConnect, int); virtual void SetCacheDirectory(const char* _arg); virtual void SetCacheDirectory(const std::string& _arg); itkGetStringMacro(CacheDirectory); itkSetMacro(Depth, int); itkGetMacro(Depth, int); itkGetStringMacro(FileSuffix); itkSetStringMacro(FileSuffix); /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanReadFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream read the specified file */ bool CanStreamRead() ITK_OVERRIDE { return true; } /** Set the spacing and dimension information for the set filename. */ void ReadImageInformation() ITK_OVERRIDE; /** Reads the data from disk into the memory buffer provided. */ void Read(void* buffer) ITK_OVERRIDE; /** Determine the file type. Returns true if this ImageIO can read the * file specified. */ bool CanWriteFile(const char*) ITK_OVERRIDE; /** Determine the file type. Returns true if the ImageIO can stream write the specified file */ bool CanStreamWrite() ITK_OVERRIDE { return true; } /** Writes the spacing and dimensions of the image. * Assumes SetFileName has been called with a valid file name. */ void WriteImageInformation() ITK_OVERRIDE; /** Writes the data to disk from the memory buffer provided. Make sure * that the IORegion has been set properly. */ void Write(const void* buffer) ITK_OVERRIDE; /** Get the number of overviews available into the file specified * This imageIO didn't support overviews */ unsigned int GetOverviewsCount() ITK_OVERRIDE { // MANTIS-1154: Source image is always considered as the best // resolution overview. return 1; } /** Get information about overviews available into the file specified * This imageIO didn't support overviews */ std::vector GetOverviewsInfo() ITK_OVERRIDE { std::vector desc; return desc; } /** Provide hist about the output container to deal with complex pixel * type (Not used here) */ void SetOutputImagePixelType( bool itkNotUsed(isComplexInternalPixelType), bool itkNotUsed(isVectorImage)) ITK_OVERRIDE{} protected: /** Constructor.*/ TileMapImageIO(); /** Destructor.*/ ~TileMapImageIO() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Read all information on the image*/ void InternalReadImageInformation(); /** Write all information on the image*/ void InternalWriteImageInformation(); unsigned int GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int numberOfRequestedSplits, const ImageIORegion& pasteRegion) const ITK_OVERRIDE; ImageIORegion GetSplitRegionForWritingCanStreamWrite(unsigned int ithPiece, unsigned int numberOfActualSplits, const ImageIORegion& pasteRegion) const ITK_OVERRIDE; /** Number of bands of the image*/ int m_NbBands; /** Determines the level of compression for written files. * Range 0-9; 0 = none, 9 = maximum , default = 4 */ int m_CompressionLevel; private: /** Struct to save filename & tile associates */ typedef struct { int numTileX; int numTileY; double x; double y; std::string filename; } TileNameAndCoordType; TileMapImageIO(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void InternalWrite(double x, double y, const void* buffer); void BuildFileName(const std::ostringstream& quad, std::ostringstream& filename, bool inCache = true) const; void FillCacheFaults(void* buffer) const; int XYToQuadTree(double x, double y, std::ostringstream& quad) const; int XYToQuadTree2(double x, double y, std::ostringstream& quad) const; /** CURL Multi */ void GenerateTileInfo(double x, double y, int numTileX, int numTileY); bool CanReadFromCache(const std::string& filename); void GenerateURL(double x, double y); void GenerateBuffer(unsigned char * p); void ReadTile(const std::string& filename, void * buffer); std::vector m_ListFilename; std::vector m_ListURLs; std::vector m_ListTiles; int m_MaxConnect; CurlHelperInterface::Pointer m_Curl; /** Byte per pixel pixel */ int m_BytePerPixel; /** Tile size (heavily tested for the default 256 only) */ int m_TileSize; /** Resolution depth*/ int m_Depth; bool m_UseCache; std::string m_CacheDirectory; std::string m_ServerName; std::string m_FileSuffix; TileMapAddressingStyle::TileMapAddressingStyle m_AddressMode; bool m_FlagWriteImageInformation; bool m_FileNameIsServerName; typedef otb::ImageRegionTileMapSplitter<2> SplitterType; SplitterType::Pointer m_TileMapSplitter; }; } // end namespace otb #endif // otbTileMapImageIO_h OTB-release-5.8/Modules/IO/IOTileMap/include/otbTileMapImageIOFactory.h000066400000000000000000000041271301006202600255030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileMapImageIOFactory_h #define otbTileMapImageIOFactory_h #include "itkObjectFactoryBase.h" #include "OTBIOTileMapExport.h" namespace otb { /** \class TileMapImageIOFactory * \brief Creation of a TileMapImageIO object using object factory. * * \ingroup OTBIOTileMap */ class OTBIOTileMap_EXPORT TileMapImageIOFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef TileMapImageIOFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); static TileMapImageIOFactory * FactoryNew() { return new TileMapImageIOFactory; } /** Run-time type information (and related methods). */ itkTypeMacro(TileMapImageIOFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { TileMapImageIOFactory::Pointer TileMapFactory = TileMapImageIOFactory::New(); itk::ObjectFactoryBase::RegisterFactory(TileMapFactory); } protected: TileMapImageIOFactory(); ~TileMapImageIOFactory() ITK_OVERRIDE; private: TileMapImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOTileMap/include/otbTileMapImageIOHelper.h000066400000000000000000000033041301006202600253070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTileMapImageIOHelper_h #define otbTileMapImageIOHelper_h #include "itkObject.h" #include "itkObjectFactory.h" #include #include #include #include "OTBIOTileMapExport.h" namespace otb { /** \class TileMapImageIOHelper * \brief This class IO TileMapImage * * * \ingroup OTBIOTileMap */ class OTBIOTileMap_EXPORT TileMapImageIOHelper: public itk::Object { public: /** Standard class typedefs. */ typedef TileMapImageIOHelper Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Object Superclass; itkTypeMacro(TileMapImageIOHelper, itk::Object); itkNewMacro(Self); /** Correspondence between depth and scale for the quad tree paradigm*/ const std::string ConvertDepthToScale(const unsigned int depth) const; protected: TileMapImageIOHelper() {} ~TileMapImageIOHelper() ITK_OVERRIDE {} private: TileMapImageIOHelper(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // end class TileMapImageIOHelper } // end namespace otb #endif OTB-release-5.8/Modules/IO/IOTileMap/otb-module.cmake000066400000000000000000000006031301006202600221700ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read and write TileMap format images.") otb_module(OTBIOTileMap ENABLE_SHARED DEPENDS OTBITK OTBImageBase OTBIOGDAL OTBCommon OTBCurlAdapters OTBOSSIMAdapters TEST_DEPENDS OTBTestKernel OTBProjection OTBImageIO OTBTransform OTBImageManipulation DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOTileMap/src/000077500000000000000000000000001301006202600177075ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOTileMap/src/CMakeLists.txt000066400000000000000000000005241301006202600224500ustar00rootroot00000000000000set(OTBIOTileMap_SRC otbTileMapImageIOFactory.cxx otbTileMapImageIOHelper.cxx otbTileMapImageIO.cxx ) add_library(OTBIOTileMap ${OTBIOTileMap_SRC}) target_link_libraries(OTBIOTileMap ${OTBIOGDAL_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBCurlAdapters_LIBRARIES} ) otb_module_target(OTBIOTileMap) OTB-release-5.8/Modules/IO/IOTileMap/src/otbLogo.inc000066400000000000000000001421271301006202600220160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ namespace otb { static const char * kLogoOtb = "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337fedZZXZZXZZX\333\332\326" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\5\5\5T\4\6=" "\3\4\4\4\4\340\337\333\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\330\327\323KKJ<" "<:<<;\261\260\255\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\336\335\331\1\1\1\253\10\14n\6\10" "\"\"!\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\266\265\262\36\36\36" "\261\261\261UUUmmk\341\340\334\322\321\316\312\312\306\312\312\306\312\312" "\306\312\312\306\324\323\317\343\342\336\326\325\321\0\0\0\253\11\14Z\5\6" "FFE\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\264\263\260+++\377\377\377" "zzz\7\7\6\5\5\5\4\4\4\21\21\21\23\23\23\23\23\23\20\20\20\3\3\3\7\7\7\33" "\33\32\0\0\0\257\11\15""3\3\4jig\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\250\250\245PPN\13" "\13\13;;;\377\377\377\311\311\311\300\300\300\343\343\343\372\372\372\377" "\377\377\377\377\377\377\377\377\377\377\377\370\370\370\337\337\337a``\0" "\0\0\266\12\16\15\1\1\216\216\213\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\250\247\244++*\20\20\20lll\310\310\310\375" "\375\375\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377" "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377hhh\0" "\0\0\244\11\14\0\0\0\262\261\256\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\334\333\330\\[Z\14\14\14\202\202\202\361\361\361\371\371\371\273" "\273\274\246\246\247\377\377\377\277\277\277\206\206\206\257\257\257\351" "\352\351\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377" "\377\377POO\1\0\0\200\7\12\0\0\0\326\325\321\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\324\323\320211777\333\333\333\324\324\324bbb\15\15\15\0\0\0...\377" "\377\377\214\214\214\2\2\3\2\2\3\2\2\2>>>\254\254\254\375\375\375\377\377" "\377\377\377\377\377\377\377766\5\0\0P\4\6\26\26\26\344\343\337\344\343\337" "\343\342\336\330\327\323\334\333\330\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\327\326\323--,VVV\360\360\360mmm\2\2\2\24\37-2Lo1Jm...\377\377" "\377\244\244\244\6\11\14Df\2241Kl\26!.\1\1\1""222\322\322\322\377\377\377" "\377\377\377\35\35\35\0\0\0\0\0\0\12\12\11--,\20\20\17\1\1\1\2\1\1\1\1\1" "\4\4\4\34\34\34""443llj\314\313\307\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\342\336EEDHHH\342\342\342111\12\17\26""6RxFj\233Fj\2334Nr.." ".\377\377\377\310\310\310\0\0\0Ab\216Fj\233Fj\233:X\177\20\30\"\11\11\11" "nnn211\0\0\0\0\0\0\0\0\0\16\2\3j\13\15\250\15\20\275\15\20\306\14\20\303" "\14\20\266\15\20\237\14\17~\13\15""5\7\10\14\13\13\230\227\224\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\230\230\225\25\25\25\331\331\331&&&\25\40.Be\223" "Fj\233Fj\233Fj\2334Nr...\377\377\377\364\364\364\4\4\4""0IiFj\233Fj\233B" "c\220\"2F\2\2\1\0\0\0\0\0\0\0\0\0\12\20\11\36""2\33\16\26\15\0\0\0\24\3\4" "d\11\13\272\15\21\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\206\14" "\17\11\5\5\253\252\247\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\33700/\212\212\212IIJ\17\27!Dg\227" "Fj\233Fj\233Fj\233Fj\2334Nr...\377\377\377\377\377\377BBB\25\37,Fj\2330E" "c\7\11\14\7\12\16!1F+@]\4\5\10\0\0\0""2V0p\312op\312ob\255`:b7\13\17\11\21" "\3\3\225\14\17\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20i\12\14$" "$$\342\341\335\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\323\322\317\2\2\2\223\223\223\3\5\7>^\212Fj\233Fj\233Fj\233" "Fj\233Fj\2334Nr...\377\377\377\377\377\377\270\271\271\1\1\1\26\37+\5\7\12" "(" "f:p\310np\312op\312oo\307nDr@\2\1\1\213\13\15\313\14\20\313\14\20\313\14" "\20\254\14\17\4\4\4\323\322\316\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\232\231\227#4MFj\233Fj\233Fj\233Fj\233Fj\233" "Fj\233Fj\233Fj\233Fj\2335Pv\6\5\6\312\312\312\377\377\377\377\377\377\377" "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377IHH`" "\7\11\313\14\20\177\14\16\4\1\1\26\"\24""5Y2.M,\17\26\15\3\1\1p\12\14\313" "\14\20\313\14\20\313\14\20\313\14\20V\10\12DDC\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\315\314\310\23\33" "'Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233\36.D\37\37" "\37\345\345\346\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377" "\377\377\377\377\377\377433p\10\12\313\14\20\313\14\20\250\15\20Y\10\12C" "\7\10F\7\10h\11\13\260\15\20\313\14\20\313\14\20\313\14\20\313\14\20\261" "\15\20\7\1\1\256\255\252\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337:::=\\\207Fj\233Fj\233Fj" "\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Eh\230\26!1\40\40\40\304\304\304" "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377" "\40\37\37\200\11\13\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\313" "\14\20\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\312\14\20""8\7\10" "NML\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\226\226\223\34+>Fj\233Fj\233Fj\233F" "j\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Dh\230\37/D\2\2\3QQQ\256\256\256" "\344\344\344\361\361\361\335\335\335\247\247\247\11\10\10r\7\11\313\14\20" "\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\313" "\14\20\313\14\20\313\14\20j\13\15\32\32\31\323\322\316\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\342\341\3359982LpFj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj" "\233Fj\233Fj\233Fj\233Fj\2339V}\33)<\7\13\20\0\0\1\0\0\0\1\1\2\11\15\23\16" "\25\36*\4\5\312\14\20\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\313" "\14\20\313\14\20\313\14\20\313\14\20s\14\16\17\16\16\265\264\261\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343" "\337\344\343\337\344\343\337\344\343\337\344\343\337\312\311\306\31\34\37" ";Z\203Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233" "Fj\233Fj\233Dg\227Dg\227Eh\230Ei\232\"-;\4\4\3w\14\16\313\14\20\313\14\20" "\313\14\20\313\14\20\313\14\20\313\14\20\313\14\20\271\15\21E\11\12\22\22" "\21\263\262\257\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337" "\344\343\337\344\343\337\263\262\257\24\30\36""8U}Fj\233Fj\233Fj\233Fj\233" "Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Fj\233Dg\226\30$4g" "fd\250\247\244\13\12\12Y\11\13\266\16\21\313\14\20\313\14\20\313\14\20\262" "\16\21d\12\14\15\3\3>=<\314\313\307\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344" "\343\337\344\343\337\344\343\337\344\343\337\344\343\337\344\343\337\274" "\273\270$%&( #include #include #include #include "itksys/SystemTools.hxx" #include "otbSystem.h" #include "otbMacro.h" #include "otbGDALImageIO.h" #include "itkTimeProbe.h" #include "otbCurlHelper.h" #include "otbImageKeywordlist.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "otbLogo.inc" namespace otb { TileMapImageIO::TileMapImageIO() { // By default set number of dimensions to two. this->SetNumberOfDimensions(2); // By default set pixel type to scalar. m_PixelType = SCALAR; // By default set component type to unsigned char m_ComponentType = UCHAR; m_UseCompression = false; m_CompressionLevel = 4; // Range 0-9; 0 = no file compression, 9 = maximum file compression // Set default spacing to one m_Spacing[0] = 1.0; m_Spacing[1] = 1.0; // Set default origin to [0.5 , 0.5] // (consistency between ImageIO, see Mantis #942) m_Origin[0] = 0.5; m_Origin[1] = 0.5; m_NbBands = 3; m_FlagWriteImageInformation = true; //Resolution depth m_Depth = 8; m_BytePerPixel = 1; m_TileSize = 256; m_UseCache = false; m_ServerName = ""; m_CacheDirectory = "."; m_FileSuffix = "png"; m_AddressMode = TileMapAddressingStyle::OSM; m_FileNameIsServerName = false; // Set maximum of connections to 10 m_MaxConnect = 10; m_Curl = CurlHelper::New(); this->AddSupportedWriteExtension(".otb"); this->AddSupportedWriteExtension(".OTB"); this->AddSupportedReadExtension(".otb"); this->AddSupportedReadExtension(".OTB"); m_TileMapSplitter = SplitterType::New(); this->UseStreamedWritingOn(); this->UseStreamedReadingOn(); } TileMapImageIO::~TileMapImageIO() { } // Tell only if the file can be read with TileMap. bool TileMapImageIO::CanReadFile(const char* file) { // First check the extension if (file == ITK_NULLPTR) { itkDebugMacro(<< "No filename specified."); return false; } std::string filename = file; std::string::size_type gmPos = filename.rfind(".otb"); if ((gmPos != std::string::npos) && (gmPos == filename.length() - 4)) { m_FileNameIsServerName = false; return true; } // Filename is http server else if (filename.find("http://") == 0 || filename.find("https://") == 0) { m_FileNameIsServerName = true; // If the url is available if (m_Curl->TestUrlAvailability(filename)) { return true; } itkDebugMacro(<< "Url is unavailable."); } return false; } // Used to print information about this object void TileMapImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Compression Level : " << m_CompressionLevel << "\n"; } // Read image with TileMap void TileMapImageIO::Read(void* buffer) { unsigned char * p = static_cast(buffer); if (p == ITK_NULLPTR) { itkExceptionMacro(<< "Memory allocation error"); return; } int totLines = this->GetIORegion().GetSize()[1]; int totSamples = this->GetIORegion().GetSize()[0]; int firstLine = this->GetIORegion().GetIndex()[1]; int firstSample = this->GetIORegion().GetIndex()[0]; int nTilesX = (int) ceil(totSamples / static_cast(m_TileSize)) + 1; int nTilesY = (int) ceil(totLines / static_cast(m_TileSize)) + 1; // Clear vectors m_ListFilename.clear(); m_ListURLs.clear(); m_ListTiles.clear(); //Read all the required tiles for (int numTileY = 0; numTileY < nTilesY; numTileY++) { for (int numTileX = 0; numTileX < nTilesX; numTileX++) { double xTile = (firstSample + m_TileSize * numTileX) / ((1 << m_Depth) * static_cast(m_TileSize)); double yTile = (firstLine + m_TileSize * numTileY) / ((1 << m_Depth) * static_cast(m_TileSize)); std::string lFilename; // Generate Tile filename this->GenerateTileInfo(xTile, yTile, numTileX, numTileY); // Try to read tile from cache if (!this->CanReadFromCache(m_ListTiles.back().filename)) { this->GenerateURL(m_ListTiles.back().x, m_ListTiles.back().y); m_ListFilename.push_back(m_ListTiles.back().filename); } } } m_Curl->RetrieveFileMulti(m_ListURLs, m_ListFilename, m_MaxConnect); m_ListURLs.clear(); // Generate buffer this->GenerateBuffer(p); otbMsgDevMacro(<< "TileMapImageIO::Read() completed"); } /* * This method build tile filename */ void TileMapImageIO::GenerateTileInfo(double x, double y, int numTileX, int numTileY) { std::ostringstream quad2; XYToQuadTree2(x, y, quad2); std::ostringstream filename; BuildFileName(quad2, filename); // Build tile information TileNameAndCoordType lTileInfos; lTileInfos.numTileX = numTileX; lTileInfos.numTileY = numTileY; lTileInfos.x = x; lTileInfos.y = y; lTileInfos.filename = filename.str(); // Add to vector m_ListTiles.push_back(lTileInfos); } /* * This method try to read tile from cache */ bool TileMapImageIO::CanReadFromCache(const std::string& filename) { // Verify that the file exists and is not a directory bool fileExists = itksys::SystemTools::FileExists(filename.c_str(), true); if (!fileExists) { return false; } otb::ImageIOBase::Pointer imageIO; imageIO = otb::GDALImageIO::New(); return imageIO->CanReadFile(filename.c_str()); } /* * This method generate URLs */ void TileMapImageIO::GenerateURL(double x, double y) { std::ostringstream urlStream; // Google Map if (m_AddressMode == TileMapAddressingStyle::GM) { std::ostringstream quad; XYToQuadTree(x, y, quad); urlStream << m_ServerName; urlStream << quad.str(); } // Open Street Map else if (m_AddressMode == TileMapAddressingStyle::OSM) { urlStream << m_ServerName; urlStream << m_Depth; urlStream << "/"; urlStream << (long int) (((double) x * (1 << m_Depth))); urlStream << "/"; urlStream << (long int) (((double) y * (1 << m_Depth))); urlStream << "." << m_FileSuffix; } // Near Map else if (m_AddressMode == TileMapAddressingStyle::NEARMAP) { urlStream << m_ServerName; urlStream << "hl=en&x="; urlStream << vcl_floor(x * (1 << m_Depth)); urlStream << "&y="; urlStream << vcl_floor(y * (1 << m_Depth)); urlStream << "&z="; urlStream << m_Depth; urlStream << "&nml=Vert&s=Ga"; } // Local addressing else if (m_AddressMode == TileMapAddressingStyle::LOCAL) { std::ostringstream quad, filename; XYToQuadTree2(x, y, quad); BuildFileName(quad, filename, false); urlStream << m_ServerName; urlStream << filename.str(); } else { itkExceptionMacro(<< "TileMapImageIO : Bad addressing Style"); } // Add url to vector m_ListURLs.push_back(urlStream.str()); } /* * This method generate the output buffer */ void TileMapImageIO::GenerateBuffer(unsigned char *p) { int totLines = this->GetIORegion().GetSize()[1]; int totSamples = this->GetIORegion().GetSize()[0]; int firstLine = this->GetIORegion().GetIndex()[1]; int firstSample = this->GetIORegion().GetIndex()[0]; int nComponents = this->GetNumberOfComponents(); unsigned char * bufferTile = new unsigned char[m_TileSize * m_TileSize * nComponents]; for (unsigned int currentTile = 0; currentTile < m_ListTiles.size(); currentTile++) { // Read tile from cache this->ReadTile(m_ListTiles[currentTile].filename, bufferTile); int numTileX = m_ListTiles[currentTile].numTileX; int numTileY = m_ListTiles[currentTile].numTileY; for (int tileJ = 0; tileJ < m_TileSize; tileJ++) { long int yImageOffset = (long int) (m_TileSize * floor(firstLine / static_cast(m_TileSize)) + m_TileSize * numTileY - firstLine + tileJ); if ((yImageOffset >= 0) && (yImageOffset < totLines)) { long int xImageOffset = (long int) (m_TileSize * floor(firstSample / static_cast(m_TileSize)) + m_TileSize * numTileX - firstSample); unsigned char * dst = p + nComponents * (xImageOffset + totSamples * yImageOffset); unsigned char * src = bufferTile + nComponents * m_TileSize * tileJ; int size = nComponents * m_TileSize; if (xImageOffset < 0) { dst -= nComponents * xImageOffset; src -= nComponents * xImageOffset; size += nComponents * xImageOffset; } if (xImageOffset + m_TileSize > totSamples) { size += nComponents * (totSamples - xImageOffset - m_TileSize); } if (size > 0) { memcpy(dst, src, size); } } } //end of tile copy } //end of full image copy delete[] bufferTile; } /* * This method read tile in the cache */ void TileMapImageIO::ReadTile(const std::string& filename, void * buffer) { otbMsgDevMacro(<< "Retrieving " << filename); unsigned char * bufferCacheFault = ITK_NULLPTR; otb::ImageIOBase::Pointer imageIO; imageIO = otb::GDALImageIO::New(); bool lCanRead = imageIO->CanReadFile(filename.c_str()); if (lCanRead == true) { imageIO->SetFileName(filename.c_str()); imageIO->ReadImageInformation(); itk::ImageIORegion ioRegion(2); ioRegion.SetIndex(0, 0); ioRegion.SetIndex(1, 0); ioRegion.SetSize(0, m_TileSize); ioRegion.SetSize(1, m_TileSize); imageIO->SetIORegion(ioRegion); imageIO->Read(buffer); } else { bufferCacheFault = new unsigned char[m_TileSize * m_TileSize * 3]; FillCacheFaults(bufferCacheFault); memcpy(buffer, bufferCacheFault, m_TileSize * m_TileSize * 3); delete [] bufferCacheFault; } } void TileMapImageIO::BuildFileName(const std::ostringstream& quad, std::ostringstream& filename, bool inCache) const { int quadsize = quad.str().size(); std::ostringstream directory; if (inCache) { directory << m_CacheDirectory; } //build directory name int i = 0; while ((i < 8) && (i < quadsize)) { directory << "/"; directory << (quad.str().c_str())[i]; ++i; } itksys::SystemTools::MakeDirectory(directory.str().c_str()); filename << directory.str(); filename << "/"; filename << "otb-"; filename << quad.str(); filename << "." << m_FileSuffix; } /* Fill up dhe image information reading the ascii configuration file */ void TileMapImageIO::ReadImageInformation() { m_Dimensions[0] = (1 << m_Depth) * m_TileSize; m_Dimensions[1] = (1 << m_Depth) * m_TileSize; otbMsgDevMacro(<< "Get Dimensions : x=" << m_Dimensions[0] << " & y=" << m_Dimensions[1]); // Default Spacing m_Spacing[0] = 1; m_Spacing[1] = 1; m_Origin[0] = 0.5; m_Origin[1] = 0.5; if (m_FileName.empty() == true) { itkExceptionMacro(<< "TileMap read : empty image file name file."); } if (m_FileName.find("http://") == 0) { m_FileNameIsServerName = true; } if (!m_FileNameIsServerName) { std::ifstream file(m_FileName.c_str(), std::ifstream::in); std::getline(file, m_ServerName); if (m_ServerName.find("http://") != 0) { itkExceptionMacro(<< "Can't read server name from file"); } std::getline(file, m_FileSuffix); std::string mode; std::getline(file, mode); switch (atoi(mode.c_str())) { case 0: m_AddressMode = TileMapAddressingStyle::GM; break; case 1: m_AddressMode = TileMapAddressingStyle::OSM; break; case 2: m_AddressMode = TileMapAddressingStyle::NEARMAP; break; case 3: m_AddressMode = TileMapAddressingStyle::LOCAL; break; default: itkExceptionMacro(<< "Addressing style unknown"); } otbMsgDevMacro(<< "File parameters: " << m_ServerName << " " << m_FileSuffix << " " << m_AddressMode); } else { m_ServerName = m_FileName; if (m_ServerName.find("http://") != 0) { itkExceptionMacro(<< "Can't read server name from file"); } std::string osmServer = "http://tile.openstreetmap.org/"; std::string nmServer = "http://www.nearmap.com/maps/"; std::string otbServer1 = "http://tile.orfeo-toolbox.org/hillShade/"; if (m_ServerName == osmServer) { m_FileSuffix = "png"; m_AddressMode = TileMapAddressingStyle::OSM; } else if (m_ServerName == nmServer) { m_FileSuffix = "jpg"; m_AddressMode = TileMapAddressingStyle::NEARMAP; } else if (m_ServerName == otbServer1) { m_FileSuffix = "jpg"; m_AddressMode = TileMapAddressingStyle::LOCAL; } else { m_FileSuffix = "jpg"; m_AddressMode = TileMapAddressingStyle::GM; } // File suffix and address mode must be set with accessors otbMsgDevMacro(<< "File parameters: " << m_ServerName << " " << m_FileSuffix << " " << m_AddressMode); } // The OSM tiles are 4 bands png, while HillShade & NearMap are 3 bands jpeg if (m_AddressMode == TileMapAddressingStyle::OSM) this->SetNumberOfComponents(4); else this->SetNumberOfComponents(3); this->SetNumberOfDimensions(2); this->SetFileTypeToBinary(); this->SetComponentType(UCHAR); ImageKeywordlist otb_kwl; itk::MetaDataDictionary& dict = this->GetMetaDataDictionary(); itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, otb_kwl); if( otb_kwl.GetSize() != 0 ) { std::ostringstream depth; depth << this->GetDepth(); otb_kwl.AddKey("depth", depth.str()); } } bool TileMapImageIO::CanWriteFile(const char* name) { // First if filename is provided if (name == ITK_NULLPTR) { itkDebugMacro(<< "No filename specified."); return false; } // Check for file extension std::string filename = name; std::string::size_type gmPos = filename.rfind(".otb"); if ((gmPos != std::string::npos) && (gmPos == filename.length() - 3)) { return true; } return false; } void TileMapImageIO::WriteImageInformation(void) { } void TileMapImageIO::Write(const void* buffer) { const unsigned char * p = static_cast(buffer); if (p == ITK_NULLPTR) { itkExceptionMacro(<< "Memory allocation error"); return; } if (m_FlagWriteImageInformation == true) { this->WriteImageInformation(); m_FlagWriteImageInformation = false; } int totLines = this->GetIORegion().GetSize()[1]; int totSamples = this->GetIORegion().GetSize()[0]; int firstLine = this->GetIORegion().GetIndex()[1]; int firstSample = this->GetIORegion().GetIndex()[0]; int originLine = (int) this->GetOrigin(1); int originSample = (int) this->GetOrigin(0); int nComponents = this->GetNumberOfComponents(); otbMsgDevMacro(<< "TileMapImageIO::Write: Size " << totLines << ", " << totSamples); otbMsgDevMacro(<< "TileMapImageIO::Write: Index " << firstLine << ", " << firstSample); otbMsgDevMacro(<< "TileMapImageIO::Write: Origin " << originLine << ", " << originSample); otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]); otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion()); otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents()); otbMsgDevMacro(<< " sizeof(streamsize) : " << sizeof(std::streamsize)); otbMsgDevMacro(<< " sizeof(streampos) : " << sizeof(std::streampos)); otbMsgDevMacro(<< " sizeof(streamoff) : " << sizeof(std::streamoff)); otbMsgDevMacro(<< " sizeof(std::ios::beg) : " << sizeof(std::ios::beg)); otbMsgDevMacro(<< " sizeof(size_t) : " << sizeof(size_t)); otbMsgDevMacro(<< " sizeof(unsigned long) : " << sizeof(unsigned long)); //Using integer division: int nTilesX = (originSample + totSamples - 1) / m_TileSize - originSample / m_TileSize + 1; int nTilesY = (originLine + totLines - 1) / m_TileSize - originLine / m_TileSize + 1; otbMsgDevMacro(<< "Number of tile to process " << nTilesX << "x" << nTilesY); unsigned char * bufferTile = new unsigned char[m_TileSize * m_TileSize * nComponents]; //Read all the required tiles for (int numTileY = 0; numTileY < nTilesY; numTileY++) { for (int numTileX = 0; numTileX < nTilesX; numTileX++) { //Set tile buffer to 0 for (int iInit = 0; iInit < m_TileSize * m_TileSize * nComponents; iInit++) { bufferTile[iInit] = 0; } for (int tileJ = 0; tileJ < m_TileSize; tileJ++) { long int yImageOffset = (long int) (m_TileSize * floor((originLine + firstLine) / static_cast(m_TileSize)) + m_TileSize * numTileY - (originLine + firstLine) + tileJ); if ((yImageOffset >= 0) && (yImageOffset < totLines)) { long int xImageOffset = (long int) (m_TileSize * floor((originSample + firstSample) / static_cast(m_TileSize)) + m_TileSize * numTileX - (originSample + firstSample)); unsigned char * dst = bufferTile + nComponents * m_TileSize * tileJ; const unsigned char * src = p + nComponents * (xImageOffset + totSamples * yImageOffset); int size = nComponents * m_TileSize; if (xImageOffset < 0) { src -= nComponents * xImageOffset; dst -= nComponents * xImageOffset; size += nComponents * xImageOffset; } if (xImageOffset + m_TileSize > totSamples) { size += nComponents * (totSamples - xImageOffset - m_TileSize); } if (size > 0) { memcpy(dst, src, size); } } } //end of tile copy double xTile = (originSample + firstSample + m_TileSize * numTileX) / ((1 << m_Depth) * static_cast(m_TileSize)); double yTile = (originLine + firstLine + m_TileSize * numTileY) / ((1 << m_Depth) * static_cast(m_TileSize)); //Write the tile InternalWrite(xTile, yTile, bufferTile); } } //end of full image copy delete[] bufferTile; otbMsgDevMacro(<< "TileMapImageIO::Write() completed"); } void TileMapImageIO::InternalWrite(double x, double y, const void* buffer) { std::ostringstream quad; otbMsgDevMacro(<< x << ", " << y); XYToQuadTree2(x, y, quad); std::ostringstream filename; BuildFileName(quad, filename); otb::ImageIOBase::Pointer imageIO; imageIO = otb::GDALImageIO::New(); bool lCanWrite = imageIO->CanWriteFile(filename.str().c_str()); if (lCanWrite) { itksys::SystemTools::RemoveFile(filename.str().c_str()); imageIO->CanStreamWrite(); imageIO->SetNumberOfDimensions(2); imageIO->SetDimensions(0, m_TileSize); imageIO->SetDimensions(1, m_TileSize); imageIO->SetSpacing(0, 1); imageIO->SetSpacing(1, 1); imageIO->SetOrigin(0, 0.5); imageIO->SetOrigin(1, 0.5); imageIO->SetNumberOfComponents(3); vnl_vector axisDirection(2); axisDirection[0] = 1; axisDirection[1] = 0; imageIO->SetDirection(0, axisDirection); axisDirection[0] = 0; axisDirection[1] = 1; imageIO->SetDirection(1, axisDirection); imageIO->SetUseCompression(1); imageIO->SetFileName(filename.str().c_str()); imageIO->WriteImageInformation(); itk::ImageIORegion ioRegion(2); for (unsigned int i = 0; i < 2; ++i) { ioRegion.SetSize(i, m_TileSize); ioRegion.SetIndex(i, 0); } imageIO->SetIORegion(ioRegion); imageIO->Write(buffer); } else { itkExceptionMacro(<< "TileMap write : bad file name."); } } /** Generate the quadtree address in qrts style */ int TileMapImageIO::XYToQuadTree(double x, double y, std::ostringstream& quad) const { int lDepth = m_Depth; while (lDepth--) // (post-decrement) { // make sure we only look at fractional part x -= floor(x); y -= floor(y); int quad_index = ((x >= 0.5 ? 1 : 0) + (y >= 0.5 ? 2 : 0)); switch (quad_index) { case 0: quad << "q"; break; case 1: quad << "r"; break; case 2: quad << "t"; break; case 3: quad << "s"; break; } // level down x *= 2; y *= 2; } return 0; } /** Generate the quadtree address in 0123 style */ int TileMapImageIO::XYToQuadTree2(double x, double y, std::ostringstream& quad) const { int lDepth = m_Depth; while (lDepth--) // (post-decrement) { // make sure we only look at fractional part x -= floor(x); y -= floor(y); int quad_index = ((x >= 0.5 ? 1 : 0) + (y >= 0.5 ? 2 : 0)); switch (quad_index) { case 0: quad << "0"; break; case 1: quad << "1"; break; case 2: quad << "2"; break; case 3: quad << "3"; break; } // level down x *= 2; y *= 2; } return 0; } unsigned int TileMapImageIO::GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int numberOfRequestedSplits, const ImageIORegion& pasteRegion) const { typedef itk::ImageRegion<2> RegionType; RegionType tileMapRegion; RegionType::IndexType index; index[0] = this->GetOrigin(0); index[1] = this->GetOrigin(1); itk::ImageIORegionAdaptor<2>::Convert(pasteRegion, tileMapRegion, index); return m_TileMapSplitter->GetNumberOfSplits(tileMapRegion, numberOfRequestedSplits); } itk::ImageIORegion TileMapImageIO::GetSplitRegionForWritingCanStreamWrite(unsigned int ithPiece, unsigned int numberOfActualSplits, const ImageIORegion& pasteRegion) const { typedef itk::ImageRegion<2> RegionType; RegionType tileMapRegion; RegionType::IndexType index; index[0] = this->GetOrigin(0); index[1] = this->GetOrigin(1); itk::ImageIORegionAdaptor<2>::Convert(pasteRegion, tileMapRegion, index); ImageIORegion returnRegion; itk::ImageIORegionAdaptor<2>::Convert(m_TileMapSplitter->GetSplit(ithPiece, numberOfActualSplits, tileMapRegion), returnRegion, index); return returnRegion; } /** RGB buffer filling when the tile is not found */ void TileMapImageIO::FillCacheFaults(void* buffer) const { //replicate to make 256x256x3 pixels for (int line = 0; line < m_TileSize; line++) { for (int col = 0; col < m_TileSize/64; col++) { memcpy(((unsigned char *) buffer) + line * m_TileSize * 3 + 64 * 3 * col, kLogoOtb + (line % 64) * 64 * 3, 64 * 3); } } } void TileMapImageIO::SetCacheDirectory(const char* _arg) { if (_arg && (_arg == this->m_CacheDirectory)) { return; } if (_arg) { // if existing dir, check writable if ( itksys::SystemTools::FileIsDirectory( _arg ) ) { std::ostringstream oss; oss<<_arg<<"/foo"; if( itksys::SystemTools::Touch( oss.str().c_str(), true ) == false ) { itkExceptionMacro( "Error, no write permission in given CacheDirectory "<<_arg<<"."); } else { itksys::SystemTools::RemoveFile( oss.str().c_str() ); } } // if existing file else if( itksys::SystemTools::FileExists(_arg) == true ) { itkExceptionMacro( "Error, given CacheDirectory "<<_arg<<" is an existing file."); } // doesn't exist, try to create it else if( itksys::SystemTools::MakeDirectory( _arg ) == false ) { itkExceptionMacro( "Error, no permission to create the given CacheDirectory "<<_arg<<"."); } else { itksys::SystemTools::RemoveADirectory( _arg ); } this->m_CacheDirectory = _arg; this->m_UseCache = true; } else { this->m_CacheDirectory = ""; this->m_UseCache = false; } this->Modified(); } void TileMapImageIO::SetCacheDirectory(const std::string& _arg) { this->SetCacheDirectory(_arg.c_str()); } } // end namespace otb OTB-release-5.8/Modules/IO/IOTileMap/src/otbTileMapImageIOFactory.cxx000066400000000000000000000032311301006202600252150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTileMapImageIOFactory.h" #include "itkCreateObjectFunction.h" #include "otbTileMapImageIO.h" #include "itkVersion.h" namespace otb { TileMapImageIOFactory::TileMapImageIOFactory() { this->RegisterOverride("otbImageIOBase", "otbTileMapImageIO", "TileMap Image IO", 1, itk::CreateObjectFunction::New()); } TileMapImageIOFactory::~TileMapImageIOFactory() { } const char* TileMapImageIOFactory::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } const char* TileMapImageIOFactory::GetDescription() const { return "TileMap ImageIO Factory, enabling TileMap image format loading in OTB"; } // Undocumented API used to register during static initialization. // DO NOT CALL DIRECTLY. static bool TileMapImageIOFactoryHasBeenRegistered; void TileMapImageIOFactoryRegister__Private(void) { if( ! TileMapImageIOFactoryHasBeenRegistered ) { TileMapImageIOFactoryHasBeenRegistered = true; TileMapImageIOFactory::RegisterOneFactory(); } } } // end namespace otb OTB-release-5.8/Modules/IO/IOTileMap/src/otbTileMapImageIOHelper.cxx000066400000000000000000000036011301006202600250260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTileMapImageIOHelper.h" namespace otb { /** get scale from depth */ const std::string TileMapImageIOHelper::ConvertDepthToScale(const unsigned int depth) const { std::string res; res += "level "; std::stringstream out; out << depth; res += out.str(); res += " (around 1 : "; switch (depth) { case 1: res += "222 million)"; break; case 2: res += "111 million)"; break; case 3: res += "55 million)"; break; case 4: res += "28 million"; break; case 5: res += "14 million"; break; case 6: res += "7 million)"; break; case 7: res += "3 million)"; break; case 8: res += "2 million)"; break; case 9: res += "867, 000)"; break; case 10: res += "433, 000)"; break; case 11: res += "217, 000)"; break; case 12: res += "108, 000)"; break; case 13: res += "54, 000)"; break; case 14: res += "27, 000)"; break; case 15: res += "14, 000)"; break; case 16: res += "6, 771)"; break; case 17: res += "3, 385)"; break; case 18: res += "1, 693)"; break; default: res += "222 million)"; break; } return res; } } // end namespace otb OTB-release-5.8/Modules/IO/IOTileMap/test/000077500000000000000000000000001301006202600200775ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOTileMap/test/CMakeLists.txt000066400000000000000000000031321301006202600226360ustar00rootroot00000000000000otb_module_test() set(OTBIOTileMapTests otbIOTileMapTestDriver.cxx otbTileMapImageIOHelperTest.cxx otbTileMapImageIOTest.cxx otbTileMapWriter.cxx ) add_executable(otbIOTileMapTestDriver ${OTBIOTileMapTests}) target_link_libraries(otbIOTileMapTestDriver ${OTBIOTileMap-Test_LIBRARIES}) otb_module_target_label(otbIOTileMapTestDriver) # Tests Declaration otb_add_test(NAME ioTuTileMapImageIOHelperNew COMMAND otbIOTileMapTestDriver otbTileMapImageIOHelperNew ) otb_add_test(NAME ioTvTileMapImageIOHelperTest COMMAND otbIOTileMapTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvTileMapImageIOHelperTest.txt ${TEMP}/ioTvTileMapImageIOHelperTest.txt otbTileMapImageIOHelperTest ${TEMP}/ioTvTileMapImageIOHelperTest.txt ) otb_add_test(NAME ioTvTileMapImageIOWeb COMMAND otbIOTileMapTestDriver otbTileMapImageIOTest http://tile.openstreetmap.org/ ${TEMP}/ioTvTileMapImageIOWebOutput.png ${TEMP} 1.4835345 43.55968261 13 ) set_property(TEST ioTvTileMapImageIOWeb PROPERTY RESOURCE_LOCK web_access) otb_add_test(NAME ioTvTileMapImageIOFile COMMAND otbIOTileMapTestDriver otbTileMapImageIOTest ${OTB_DATA_ROOT}/Examples/osmfile.otb ${TEMP}/ioTvTileMapImageIOFileOutput.png ${TEMP} 1.4835345 43.55968261 13 ) set_property(TEST ioTvTileMapImageIOFile PROPERTY RESOURCE_LOCK web_access) #otb_add_test(NAME ioTvTileMapWriter COMMAND otbIOTileMapTestDriver #otbTileMapWriter #LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} #${OTB_DATA_ROOT}/Input/DEM/srtm_directory #${TEMP} #500 # extract index[0] #500 # extract index[1] #200 # extract size[0] #200 # extract size[1] #) OTB-release-5.8/Modules/IO/IOTileMap/test/otbIOTileMapTestDriver.cxx000066400000000000000000000003301301006202600251230ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbTileMapImageIOHelperNew); REGISTER_TEST(otbTileMapImageIOHelperTest); REGISTER_TEST(otbTileMapImageIOTest); REGISTER_TEST(otbTileMapWriter); } OTB-release-5.8/Modules/IO/IOTileMap/test/otbTileMapImageIOHelperTest.cxx000066400000000000000000000024511301006202600260600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbTileMapImageIOHelper.h" int otbTileMapImageIOHelperNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::TileMapImageIOHelper::Pointer myTileMapImageIOHelper; myTileMapImageIOHelper = otb::TileMapImageIOHelper::New(); return EXIT_SUCCESS; } int otbTileMapImageIOHelperTest(int itkNotUsed(argc), char * argv[]) { otb::TileMapImageIOHelper::Pointer myTileMapImageIOHelper; myTileMapImageIOHelper = otb::TileMapImageIOHelper::New(); char * filename = argv[1]; std::ofstream file; file.open(filename); for (unsigned int i=0; i < 22; ++i) { file << i << ": " << myTileMapImageIOHelper->ConvertDepthToScale(i) << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOTileMap/test/otbTileMapImageIOTest.cxx000066400000000000000000000057431301006202600247270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkRGBPixel.h" #include "otbImageFileReader.h" #include "otbTileMapImageIO.h" #include "otbTileMapTransform.h" #include "otbInverseSensorModel.h" #include "otbExtractROI.h" #include "otbImageFileWriter.h" int otbTileMapImageIOTest(int argc, char* argv[]) { if (argc != 7) { std::cout << argv[0] << " " << " " << std::endl; return EXIT_FAILURE; } char * inputFilename = argv[1]; char * outputFilename = argv[2]; char * cacheDirectory = argv[3]; double lon = atof(argv[4]); double lat = atof(argv[5]); int depth = atoi(argv[6]); typedef itk::RGBPixel RGBPixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::TileMapImageIO ImageIOType; ImageIOType::Pointer tileIO = ImageIOType::New(); ReaderType::Pointer readerTile = ReaderType::New(); tileIO->SetDepth(depth); tileIO->SetCacheDirectory(cacheDirectory); readerTile->SetImageIO(tileIO); readerTile->SetFileName(inputFilename); readerTile->UpdateOutputInformation(); typedef otb::TileMapTransform TransformType; TransformType::Pointer transform = TransformType::New(); transform->SetDepth(depth); typedef itk::Point PointType; PointType lonLatPoint; lonLatPoint[0] = lon; lonLatPoint[1] = lat; PointType tilePoint; tilePoint = transform->TransformPoint(lonLatPoint); long int startX = static_cast(tilePoint[0]); long int startY = static_cast(tilePoint[1]); long int sizeX = 500; long int sizeY = 500; std::cerr << startX << ", " << startY << std::endl; std::cerr << sizeX << ", " << sizeY << std::endl; typedef otb::ExtractROI ExtractROIFilterType; ExtractROIFilterType::Pointer extractROIOsmFilter = ExtractROIFilterType::New(); extractROIOsmFilter->SetStartX(startX - sizeX / 2); extractROIOsmFilter->SetStartY(startY - sizeY / 2); extractROIOsmFilter->SetSizeX(sizeX); extractROIOsmFilter->SetSizeY(sizeY); extractROIOsmFilter->SetInput(readerTile->GetOutput()); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(extractROIOsmFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOTileMap/test/otbTileMapWriter.cxx000066400000000000000000000126421301006202600240650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkRGBPixel.h" #include "otbTileMapTransform.h" #include "otbOrthoRectificationFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkPoint.h" #include "otbTileMapImageIO.h" #include "itkRescaleIntensityImageFilter.h" #include "otbPerBandVectorImageFilter.h" #include "otbPrintableImageFilter.h" int otbTileMapWriter(int argc, char *argv[]) { if (argc != 4 && argc != 8) { std::cerr << "Usage: " << argv[0] << " " << std::endl; return EXIT_FAILURE; } int depth = 14; typedef otb::Image ImageType; typedef otb::Image DoubleImageType; typedef otb::VectorImage VectorImageType; typedef otb::VectorImage CharVectorImageType; typedef otb::VectorImage DoubleVectorImageType; typedef otb::ImageFileReader VectorReaderType; VectorReaderType::Pointer readerXS = VectorReaderType::New(); readerXS->SetFileName(argv[1]); typedef otb::TileMapTransform MapProjectionType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; typedef otb::ImageFileWriter WriterType; otb::DEMHandler::Instance()->OpenDEMDirectory(argv[2]); MapProjectionType::Pointer mapProjection = MapProjectionType::New(); mapProjection->SetLevel(depth); ImageType::IndexType start; start[0] = 0; start[1] = 0; ImageType::SizeType size; size[0] = 2000; size[1] = 2000; ImageType::SpacingType spacing; spacing[0] = 1; spacing[1] = 1; typedef itk::Point PointType; PointType lonLatUL; // lonLatUL[0] = 103.843; //Sentosa // lonLatUL[1] = 1.23037; // lonLatUL[1] = 1.30164; //Tests pour matching google (Orchard Road) // lonLatUL[0] = 103.838; // lonLatUL[1] = 1.35610168284995; //Tests streaming (coin UL) // lonLatUL[0] = 103.760262770741; // lonLatUL[1] = 43.5596826111; //Tests Toulouse // lonLatUL[0] = 1.4835345; // lonLatUL[0] = -68.1; //Tests LaPaz // lonLatUL[1] = -16.5; lonLatUL[0] = 51.15; //Tests Iran spot5 lonLatUL[1] = 35.9; typedef otb::TileMapTransform MapProjectionForwardType; MapProjectionForwardType::Pointer mapProjectionForward = MapProjectionForwardType::New(); mapProjectionForward->SetLevel(depth); PointType pointULexact; pointULexact = mapProjectionForward->TransformPoint(lonLatUL); PointType pointLRexact; pointLRexact[0] = pointULexact[0] + size[0] * spacing[0]; pointLRexact[1] = pointULexact[1] + size[1] * spacing[1]; PointType lonLatLR; lonLatLR = mapProjection->TransformPoint(pointLRexact); typedef otb::PerBandVectorImageFilter VectorOrthoRectifFilterType; OrthoRectifFilterType::Pointer orthoRectifXS = OrthoRectifFilterType::New(); VectorOrthoRectifFilterType::Pointer orthoRectifXSVector = VectorOrthoRectifFilterType::New(); orthoRectifXSVector->SetFilter(orthoRectifXS); orthoRectifXS->SetMapProjection(mapProjection); orthoRectifXSVector->SetInput(readerXS->GetOutput()); orthoRectifXS->SetOutputStartIndex(start); orthoRectifXS->SetOutputSize(size); orthoRectifXS->SetOutputSpacing(spacing); orthoRectifXS->SetOutputOrigin(pointULexact); typedef otb::MultiChannelExtractROI ExtractorType; ExtractorType::Pointer extractor = ExtractorType::New(); typedef otb::PrintableImageFilter PrintableImageFilterType; PrintableImageFilterType::Pointer printable = PrintableImageFilterType::New(); printable->SetChannel(1); printable->SetChannel(2); printable->SetChannel(3); if(argc==8) { extractor->SetStartX(atoi(argv[4])); extractor->SetStartY(atoi(argv[5])); extractor->SetSizeX(atoi(argv[6])); extractor->SetSizeY(atoi(argv[7])); extractor->SetInput(orthoRectifXSVector->GetOutput()); printable->SetInput(extractor->GetOutput()); } else { printable->SetInput(orthoRectifXSVector->GetOutput()); } typedef otb::ImageRegionTileMapSplitter<2> SplitterType; SplitterType::Pointer splitter = SplitterType::New(); typedef otb::TileMapImageIO ImageIOType; ImageIOType::Pointer tileMapIO = ImageIOType::New(); tileMapIO->SetDepth(depth); tileMapIO->SetCacheDirectory(argv[3]); tileMapIO->SetFileSuffix("jpg"); WriterType::Pointer writer = WriterType::New(); writer->SetFileName("test.otb"); writer->SetImageIO(tileMapIO); writer->SetNumberOfThreads(1); writer->SetInput(printable->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/IOXML/000077500000000000000000000000001301006202600162255ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOXML/CMakeLists.txt000066400000000000000000000000441301006202600207630ustar00rootroot00000000000000project(OTBIOXML) otb_module_impl() OTB-release-5.8/Modules/IO/IOXML/include/000077500000000000000000000000001301006202600176505ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOXML/include/otbStatisticsXMLFileReader.h000066400000000000000000000067511301006202600251750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStatisticsXMLFileReader_h #define otbStatisticsXMLFileReader_h #include "itkProcessObject.h" namespace otb { /** \class StatisticsXMLFileReader * \brief Read a xml file where are stored several statistics * * To get a specific statistic Measurement vector, use the method * GetStatisticVectorByName(name) which allow you to get the * Measurement vector for the statistic set as parameter. * * * * \ingroup OTBIOXML */ template < class TMeasurementVector> class StatisticsXMLFileReader : public itk::Object { public: /** Standard class typedefs */ typedef StatisticsXMLFileReader Self; typedef itk::Object Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(StatisticsXMLFileReader, itk::Object); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputSampleList typedefs */ typedef TMeasurementVector MeasurementVectorType; typedef typename MeasurementVectorType::ValueType InputValueType; /** Convenient typedef */ typedef std::pair InputDataType; typedef std::vector< InputDataType > MeasurementVectorContainer; typedef std::map GenericMapType; typedef std::map GenericMapContainer; void Modified() const ITK_OVERRIDE { m_IsUpdated = false; } /** Set the output filename */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); /** Get the number of Outputs*/ unsigned int GetNumberOfOutputs(); /** Get the list of vector statistics names */ std::vector GetStatisticVectorNames(); /** Get the list of map statistics names */ std::vector GetStatisticMapNames(); /** Method to get the MeasurementVector by name */ MeasurementVectorType GetStatisticVectorByName(const char * statisticName); /** Method to get a statistics map by name */ template MapType GetStatisticMapByName(const char * statisticName); protected: /** Read into the file and extract information in vector and map containers */ virtual void Read(); StatisticsXMLFileReader(); ~StatisticsXMLFileReader() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: StatisticsXMLFileReader(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented std::string m_FileName; MeasurementVectorContainer m_MeasurementVectorContainer; mutable bool m_IsUpdated; GenericMapContainer m_GenericMapContainer; }; // end of class StatisticsXMLFileReader } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStatisticsXMLFileReader.txx" #endif #endif OTB-release-5.8/Modules/IO/IOXML/include/otbStatisticsXMLFileReader.txx000066400000000000000000000203531301006202600255630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStatisticsXMLFileReader_txx #define otbStatisticsXMLFileReader_txx #include "otbStatisticsXMLFileReader.h" #include "itkMacro.h" #include "itksys/SystemTools.hxx" #include "otb_tinyxml.h" #include "otbStringUtils.h" namespace otb { template < class TMeasurementVector > StatisticsXMLFileReader ::StatisticsXMLFileReader(): m_FileName(""), m_IsUpdated(false) {} template < class TMeasurementVector > unsigned int StatisticsXMLFileReader ::GetNumberOfOutputs() { return m_MeasurementVectorContainer.size() + m_GenericMapContainer.size(); } template < class TMeasurementVector > std::vector StatisticsXMLFileReader ::GetStatisticVectorNames() { // Read the xml file once if(!m_IsUpdated) { this->Read(); } std::vector output; for (unsigned int i=0 ; i < m_MeasurementVectorContainer.size() ; ++i ) { output.push_back(m_MeasurementVectorContainer[i].first); } return output; } template < class TMeasurementVector > std::vector StatisticsXMLFileReader ::GetStatisticMapNames() { // Read the xml file once if(!m_IsUpdated) { this->Read(); } std::vector output; for ( GenericMapContainer::iterator it = m_GenericMapContainer.begin() ; it != m_GenericMapContainer.end() ; ++it) { output.push_back(it->first); } return output; } template < class TMeasurementVector > typename StatisticsXMLFileReader ::MeasurementVectorType StatisticsXMLFileReader ::GetStatisticVectorByName(const char * statisticName) { // Read the xml file once if(!m_IsUpdated) { this->Read(); } // Check if the name of the Statistic is present bool found = false; unsigned int index = 0; for(unsigned int idx = 0; idx < m_MeasurementVectorContainer.size() ; ++idx) { if(strcmp(m_MeasurementVectorContainer[idx].first.c_str(), statisticName) == 0 ) { found = true; index = idx; } } // if token not found throw an axception if(!found) itkExceptionMacro(<<"No entry corresponding to the token selected ("< template MapType StatisticsXMLFileReader ::GetStatisticMapByName(const char * statisticName) { // Read the xml file once if(!m_IsUpdated) { this->Read(); } // Check if the name of the Statistic is present std::string statName(statisticName); if (m_GenericMapContainer.count(statName) == 0) { itkExceptionMacro(<<"No entry corresponding to the token selected ("<(it->first); tmpVal = boost::lexical_cast(it->second); outputMap[tmpKey] = tmpVal; } return outputMap; } template < class TMeasurementVector > void StatisticsXMLFileReader ::Read() { // Check if the filename is not empty if(m_FileName.empty()) itkExceptionMacro(<<"The XML output FileName is empty, please set the filename via the method SetFileName"); // Check that the right extension is given : expected .xml */ std::string extension = itksys::SystemTools::GetFilenameLastExtension(m_FileName); if (itksys::SystemTools::LowerCase(extension) != ".xml") { itkExceptionMacro(<FirstChildElement(); currentStat != ITK_NULLPTR; currentStat = currentStat->NextSiblingElement() ) { InputDataType currentStatisticVector; // Store the stat type name currentStatisticVector.first = currentStat->Attribute("name"); // The size is not stored in the XML file // Store the value in a std::vector, get the size and then // build a measurement vector std::vector tempMeasurementVector; for( TiXmlElement* sample = currentStat->FirstChildElement("StatisticVector"); sample != ITK_NULLPTR; sample = sample->NextSiblingElement() ) { // Get the current value of the statistic vector double value; sample->QueryDoubleAttribute("value", &value); // Store the value tempMeasurementVector.push_back(value); } // resize the Measurement Vector currentStatisticVector.second.SetSize(tempMeasurementVector.size()); for(unsigned int i = 0; i < tempMeasurementVector.size(); ++i) currentStatisticVector.second.SetElement(i, (static_cast(tempMeasurementVector[i]))); m_MeasurementVectorContainer.push_back(currentStatisticVector); } } // Parse Map statistics std::string key; std::string value; root = hDoc.FirstChildElement("GeneralStatistics").ToElement(); if (root) { // Iterate through the tree to get all the stats for( TiXmlElement* currentStat = root->FirstChildElement(); currentStat != ITK_NULLPTR; currentStat = currentStat->NextSiblingElement() ) { GenericMapType currentMap; std::string currentName(currentStat->Attribute("name")); for( TiXmlElement* sample = currentStat->FirstChildElement("StatisticMap"); sample != ITK_NULLPTR; sample = sample->NextSiblingElement() ) { // Get the current pair of the statistic map const char *c_key = sample->Attribute("key"); const char *c_value = sample->Attribute("value"); if (c_key == ITK_NULLPTR) { itkExceptionMacro("'key' attribute not found in StatisticMap !"); } if (c_value == ITK_NULLPTR) { itkExceptionMacro("'value' attribute not found in StatisticMap !"); } key = std::string(c_key); value = std::string(c_value); // Store the pair currentMap[key] = value; } m_GenericMapContainer[currentName] = currentMap; } } // Reader is up-to-date m_IsUpdated = true; } template < class TMeasurementVector > void StatisticsXMLFileReader ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); // Print info about statistics os << indent << "Input FileName: "<< m_FileName << std::endl; os << indent << "Vector statistics: "; for (unsigned int i=0 ; i < m_MeasurementVectorContainer.size() ; ++i) { if (i>0) os <<", "; os << m_MeasurementVectorContainer[i].first; } os << std::endl; os << indent << "Map statistics: "; for (GenericMapContainer::const_iterator it = m_GenericMapContainer.begin() ; it != m_GenericMapContainer.end() ; ++it) { if (it != m_GenericMapContainer.begin()) os <<", "; os << it->first; } os << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/IO/IOXML/include/otbStatisticsXMLFileWriter.h000066400000000000000000000064661301006202600252520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStatisticsXMLFileWriter_h #define otbStatisticsXMLFileWriter_h #include "itkProcessObject.h" #include #include namespace otb { /** \class StatisticsXMLFileWriter * \brief Write in a xml file the values stored in a MeasurementVector set as * input * * The vector can be set as input via AddInput(name, vector) where name * is the name of the statistic, and vector the values. * Supported vector types are those implementing the method GetElement(idx) * and defining the type ValueType. * * * \ingroup OTBIOXML */ template < class TMeasurementVector> class StatisticsXMLFileWriter : public itk::Object { public: /** Standard class typedefs */ typedef StatisticsXMLFileWriter Self; typedef itk::Object Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(StatisticsXMLFileWriter, itk::Object); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputSampleList typedefs */ typedef TMeasurementVector MeasurementVectorType; typedef typename MeasurementVectorType::ValueType InputValueType; /** Convenient typedef */ typedef std::pair InputDataType; typedef std::vector< InputDataType > MeasurementVectorContainer; typedef std::map GenericMapType; typedef std::map GenericMapContainer; /** Method to set/get the input list sample */ void AddInput(const char * name, const MeasurementVectorType& inputVector ); /** Method to add a map statistic with a given type */ template void AddInputMap(const char * name, const MapType& map ); /** Remove previously added inputs (vectors and maps) */ void CleanInputs(); /** Trigger the processing */ void Update() { this->GenerateData(); } /** Set the output filename */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); protected: virtual void GenerateData(); StatisticsXMLFileWriter(); ~StatisticsXMLFileWriter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: StatisticsXMLFileWriter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented std::string m_FileName; MeasurementVectorContainer m_MeasurementVectorContainer; GenericMapContainer m_GenericMapContainer; }; // end of class StatisticsXMLFileWriter } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStatisticsXMLFileWriter.txx" #endif #endif OTB-release-5.8/Modules/IO/IOXML/include/otbStatisticsXMLFileWriter.txx000066400000000000000000000153371301006202600256430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStatisticsXMLFileWriter_txx #define otbStatisticsXMLFileWriter_txx #include "otbStatisticsXMLFileWriter.h" #include "itkMacro.h" #include "itksys/SystemTools.hxx" #include "otb_tinyxml.h" #include "otbStringUtils.h" namespace otb { template < class TMeasurementVector > StatisticsXMLFileWriter ::StatisticsXMLFileWriter(): m_FileName("") {} template < class TMeasurementVector > void StatisticsXMLFileWriter ::AddInput(const char * name, const MeasurementVectorType& inputVector ) { InputDataType inputData; inputData.first = name; // Check if the statistic name is already added for(unsigned int idx= 0; idx< m_MeasurementVectorContainer.size(); ++idx) { if(strcmp(m_MeasurementVectorContainer[idx].first.c_str(), name) == 0 ) { itkExceptionMacro(<<"Token selected (" < void StatisticsXMLFileWriter ::GenerateData() { // Check if the input are not null if(m_MeasurementVectorContainer.size() == 0 && m_GenericMapContainer.size() == 0) itkExceptionMacro(<<"At least one input is required, please set input using the methods AddInput or AddInputMap"); // Check if the filename is not empty if(m_FileName.empty()) itkExceptionMacro(<<"The XML output FileName is empty, please set the filename via the method SetFileName"); // Check that the right extension is given : expected .xml */ std::string extension = itksys::SystemTools::GetFilenameLastExtension(m_FileName); if (itksys::SystemTools::LowerCase(extension) != ".xml") { itkExceptionMacro(<SetAttribute("name", featureName.c_str()); root->LinkEndChild( feature ); // Store the value for this statistic for(unsigned int cindex = 0; cindex < currentMeasurementVector.Size(); ++cindex) { // For each value in Measurementvector TiXmlElement * curStatisticVector = new TiXmlElement("StatisticVector"); curStatisticVector->SetDoubleAttribute("value", currentMeasurementVector.GetElement(cindex)); feature->LinkEndChild(curStatisticVector); } } // Iterate on map containers TiXmlElement * mapRoot = ITK_NULLPTR; if (m_GenericMapContainer.size()) { mapRoot = new TiXmlElement( "GeneralStatistics"); doc.LinkEndChild( mapRoot ); } GenericMapContainer::const_iterator containerIt; for ( containerIt = m_GenericMapContainer.begin() ; containerIt != m_GenericMapContainer.end() ; ++containerIt) { std::string mapName = containerIt->first; GenericMapType::const_iterator mapIter; // The current statistic TiXmlElement * feature = new TiXmlElement("Statistic"); feature->SetAttribute("name", mapName.c_str()); mapRoot->LinkEndChild( feature ); // Store the value for this statistic for( mapIter = containerIt->second.begin() ; mapIter != containerIt->second.end() ; ++mapIter ) { // For each value in Measurementvector TiXmlElement * curStatisticMap = new TiXmlElement("StatisticMap"); curStatisticMap->SetAttribute("key" , mapIter->first.c_str()); curStatisticMap->SetAttribute("value", mapIter->second.c_str()); feature->LinkEndChild(curStatisticMap); } } // Finally, write the file if (! doc.SaveFile( m_FileName.c_str() ) ) { itkExceptionMacro(<<"Unable to write the XML file in " << itksys::SystemTools::GetFilenamePath(m_FileName) << " (permission issue? Directory does not exist?)." ); } } template < class TMeasurementVector > template void StatisticsXMLFileWriter ::AddInputMap(const char * name, const MapType& map ) { std::string token(name); if(m_GenericMapContainer.count(token) > 0) { itkExceptionMacro(<<"Token selected (" <(it->first); tmpVal = boost::lexical_cast(it->second); insideMap[tmpKey] = tmpVal; } m_GenericMapContainer[token] = insideMap; } template < class TMeasurementVector > void StatisticsXMLFileWriter ::CleanInputs() { // clear both containers m_MeasurementVectorContainer.clear(); m_GenericMapContainer.clear(); } template < class TMeasurementVector > void StatisticsXMLFileWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); // Print Writer state os << indent << "Input FileName: "<< m_FileName << std::endl; os << indent << "Vector statistics: "; for (unsigned int i=0 ; i < m_MeasurementVectorContainer.size() ; ++i) { if (i>0) os <<", "; os << m_MeasurementVectorContainer[i].first; } os << std::endl; os << indent << "Map statistics: "; for (GenericMapContainer::const_iterator it = m_GenericMapContainer.begin() ; it != m_GenericMapContainer.end() ; ++it) { if (it != m_GenericMapContainer.begin()) os <<", "; os << it->first; } os << std::endl; } } // End namespace otb #endif OTB-release-5.8/Modules/IO/IOXML/otb-module.cmake000066400000000000000000000003621301006202600212770ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to read and write Read a xml files.") otb_module(OTBIOXML DEPENDS OTBBoostAdapters OTBITK OTBTinyXML TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/IOXML/test/000077500000000000000000000000001301006202600172045ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/IOXML/test/CMakeLists.txt000066400000000000000000000012471301006202600217500ustar00rootroot00000000000000otb_module_test() set(OTBIOXMLTests otbIOXMLTestDriver.cxx otbStatisticsXMLFileWriteAndRead.cxx ) add_executable(otbIOXMLTestDriver ${OTBIOXMLTests}) target_link_libraries(otbIOXMLTestDriver ${OTBIOXML-Test_LIBRARIES}) otb_module_target_label(otbIOXMLTestDriver) # Tests Declaration otb_add_test(NAME ioTvStatisticsXMLReaderWriter COMMAND otbIOXMLTestDriver --compare-ascii ${EPSILON_5} ${BASELINE_FILES}/ioTvStatisticsXMLReaderWriterOut3.xml ${TEMP}/ioTvStatisticsXMLReaderWriterOut3.xml otbStatisticsXMLFileWriteAndRead ${TEMP}/ioTvStatisticsXMLReaderWriterOut1.xml ${TEMP}/ioTvStatisticsXMLReaderWriterOut2.XML ${TEMP}/ioTvStatisticsXMLReaderWriterOut3.xml) OTB-release-5.8/Modules/IO/IOXML/test/otbIOXMLTestDriver.cxx000066400000000000000000000001451301006202600233410ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbStatisticsXMLFileWriteAndRead); } OTB-release-5.8/Modules/IO/IOXML/test/otbStatisticsXMLFileWriteAndRead.cxx000066400000000000000000000146731301006202600262150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStatisticsXMLFileWriter.h" #include "otbStatisticsXMLFileReader.h" #include "itkVariableLengthVector.h" #include template void printMap(const MapT &map) { for (typename MapT::const_iterator it = map.begin() ; it != map.end() ; ++it) { std::cout << " * "<first << " -> " << it->second << std::endl; } } int otbStatisticsXMLFileWriteAndRead(int argc, char* argv []) { typedef itk::VariableLengthVector MeasurementType; typedef otb::StatisticsXMLFileReader ReaderType; typedef otb::StatisticsXMLFileWriter WriterType; typedef std::map NumericMapType; typedef std::map StrMapType; if (argc < 4) { std::cout << "Usage : "<< argv[0] << " vectors.xml maps.xml vectorsAndMaps.xml" << std::endl; return EXIT_FAILURE; } bool errorsFlag = false; // Output files std::string outPath1(argv[1]); std::string outPath2(argv[2]); std::string outPath3(argv[3]); // Test vectors and maps MeasurementType testVector1; testVector1.SetSize(4); testVector1[0] = 531.4; testVector1[1] = 0.151; testVector1[2] = -43.9; testVector1[3] = 1.5e-4; MeasurementType testVector2; testVector2.SetSize(3); testVector2[0] = -5; testVector2[1] = 67.3; testVector2[2] = -35e3; NumericMapType testMap1; testMap1[98315] = 64.7; testMap1[126] = -4.6; testMap1[5567] = 46e7; StrMapType testMap2; testMap2[std::string("water")] = 4986; testMap2[std::string("soil")] = 7856126; testMap2[std::string("forest")] = 32896; // Storage names std::string vectorName1("meanTest"); std::string vectorName2("meanTestBis"); std::string mapName1("polygonSize"); std::string mapName2("classCounts"); // Filters WriterType::Pointer writer = WriterType::New(); ReaderType::Pointer reader = ReaderType::New(); // Test 1 : write vectors only writer->SetFileName(outPath1); writer->AddInput("meanTest",testVector1); writer->AddInput("meanTestBis",testVector2); writer->Update(); reader->SetFileName(outPath1); MeasurementType vec1 = reader->GetStatisticVectorByName("meanTest"); MeasurementType vec2 = reader->GetStatisticVectorByName("meanTestBis"); if (testVector1 != vec1) { std::cout << "Measurement vectors have changed !" << std::endl; std::cout << "Before : "<< testVector1 << std::endl; std::cout << "After : "<< vec1 << std::endl; errorsFlag = true; } if (testVector2 != vec2) { std::cout << "Measurement vectors have changed !" << std::endl; std::cout << "Before : "<< testVector2 << std::endl; std::cout << "After : "<< vec2 << std::endl; errorsFlag = true; } // Test 2 : write maps only writer->CleanInputs(); writer->SetFileName(outPath2); writer->AddInputMap("polygonSize",testMap1); writer->AddInputMap("classCounts",testMap2); writer->Update(); reader->SetFileName(outPath2); NumericMapType map1 = reader->GetStatisticMapByName("polygonSize"); StrMapType map2 = reader->GetStatisticMapByName("classCounts"); if (testMap1 != map1) { std::cout << "Statistic maps have changed !" << std::endl; std::cout << "Before : " << std::endl; printMap(testMap1); std::cout << "After : " << std::endl; printMap(map1); errorsFlag = true; } if (testMap2 != map2) { std::cout << "Statistic maps have changed !" << std::endl; std::cout << "Before : " << std::endl; printMap(testMap2); std::cout << "After : " << std::endl; printMap(map2); errorsFlag = true; } // Test 3 : write both vectors and maps writer->CleanInputs(); writer->SetFileName(outPath3); writer->AddInput("meanTest",testVector1); writer->AddInput("meanTestBis",testVector2); writer->AddInputMap("polygonSize",testMap1); writer->AddInputMap("classCounts",testMap2); writer->Update(); reader->SetFileName(outPath3); // print available names std::vector vectorList = reader->GetStatisticVectorNames(); std::vector mapList = reader->GetStatisticMapNames(); std::cout << "Available vectors :"; for (unsigned int i=0; iGetStatisticVectorByName("meanTest"); vec2 = reader->GetStatisticVectorByName("meanTestBis"); map1 = reader->GetStatisticMapByName("polygonSize"); map2 = reader->GetStatisticMapByName("classCounts"); if (testVector1 != vec1) { std::cout << "Measurement vectors have changed !" << std::endl; std::cout << "Before : "<< testVector1 << std::endl; std::cout << "After : "<< vec1 << std::endl; errorsFlag = true; } if (testVector2 != vec2) { std::cout << "Measurement vectors have changed !" << std::endl; std::cout << "Before : "<< testVector2 << std::endl; std::cout << "After : "<< vec2 << std::endl; errorsFlag = true; } if (testMap1 != map1) { std::cout << "Statistic maps have changed !" << std::endl; std::cout << "Before : " << std::endl; printMap(testMap1); std::cout << "After : " << std::endl; printMap(map1); errorsFlag = true; } if (testMap2 != map2) { std::cout << "Statistic maps have changed !" << std::endl; std::cout << "Before : " << std::endl; printMap(testMap2); std::cout << "After : " << std::endl; printMap(map2); errorsFlag = true; } std::cout << writer << std::endl; std::cout << reader << std::endl; if (errorsFlag) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/000077500000000000000000000000001301006202600166075ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ImageIO/CMakeLists.txt000066400000000000000000000001141301006202600213430ustar00rootroot00000000000000project(OTBImageIO) set(OTBImageIO_LIBRARIES OTBImageIO) otb_module_impl() OTB-release-5.8/Modules/IO/ImageIO/include/000077500000000000000000000000001301006202600202325ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ImageIO/include/otbImageFileReader.h000066400000000000000000000161641301006202600240650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFileReader_h #define otbImageFileReader_h #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include "itkImageSource.h" #pragma GCC diagnostic pop #else #include "itkImageSource.h" #endif #include "otbImageIOBase.h" #include "itkExceptionObject.h" #include "itkImageRegion.h" #include "otbDefaultConvertPixelTraits.h" #include "otbImageKeywordlist.h" #include "otbExtendedFilenameToReaderOptions.h" namespace otb { /** \class ImageFileReaderException * * \brief Base exception class for IO conflicts. * * \ingroup OTBImageIO */ class ImageFileReaderException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro( ImageFileReaderException, ExceptionObject ); /** Constructor. */ ImageFileReaderException(const char *file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) { } /** Constructor. */ ImageFileReaderException(const std::string &file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) { } }; /** \class ImageFileReader * \brief Reads image data. * * ImageFileReader reads its output data from a single output file. * It interfaces with an ImageIO class to read in the data and * supports streaming (partial reading) if the source dataset does so. * * ImageFileReader supports extended filenames, which allow controlling * how the source dataset is read. See * http://wiki.orfeo-toolbox.org/index.php/ExtendedFileName for more * information. * * \sa ExtendedFilenameToReaderOptions * \sa ImageSeriesReader * \sa ImageIOBase * * \ingroup IOFilters * * * \ingroup OTBImageIO */ template > class ITK_EXPORT ImageFileReader : public itk::ImageSource { public: /** Standard class typedefs. */ typedef ImageFileReader Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageFileReader, ImageSource); /** The size of the output image. */ typedef typename TOutputImage::SizeType SizeType; /** The size of the output image. */ typedef typename TOutputImage::IndexType IndexType; /** The region of the output image. */ typedef typename TOutputImage::RegionType ImageRegionType; /** The pixel type of the output image. */ typedef typename TOutputImage::InternalPixelType OutputImagePixelType; /** The Filename Helper. */ typedef ExtendedFilenameToReaderOptions FNameHelperType; /** Prepare image allocation at the first call of the pipeline processing */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Does the real work. */ void GenerateData() ITK_OVERRIDE; /** Give the reader a chance to indicate that it will produce more * output than it was requested to produce. ImageFileReader cannot * currently read a portion of an image (since the ImageIO objects * cannot read a portion of an image), so the ImageFileReader must * enlarge the RequestedRegion to the size of the image on disk. */ void EnlargeOutputRequestedRegion(itk::DataObject *output) ITK_OVERRIDE; /** Set/Get the ImageIO helper class. Often this is created via the object * factory mechanism that determines whether a particular ImageIO can * read a certain file. This method provides a way to get the ImageIO * instance that is created. Or you can directly specify the ImageIO * to use to read a particular file in case the factory mechanism will * not work properly (e.g., unknown or unusual extension). */ void SetImageIO( otb::ImageIOBase * imageIO ); itkGetObjectMacro(ImageIO,otb::ImageIOBase); virtual void SetFileName(const char* extendedFileName); virtual void SetFileName(std::string extendedFileName); virtual const char* GetFileName () const; /** Get the resolution information from the file */ bool GetResolutionsInfo( std::vector& res, std::vector& desc); /** Get the number of overviews available into the file specified * Returns: overview count, zero if none. */ unsigned int GetOverviewsCount(); /** Get description about overviews available into the file specified * Returns: overview info, empty if none.*/ std::vector GetOverviewsInfo(); protected: ImageFileReader(); ~ImageFileReader() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Convert a block of pixels from one type to another. */ void DoConvertBuffer(void* buffer, size_t numberOfPixels); private: /** Test whether the given filename exist and it is readable, this is intended to be called before attempting to use ImageIO classes for actually reading the file. If the file doesn't exist or it is not readable, and exception with an appropriate message will be thrown. */ void TestFileExistenceAndReadability(); /** Generate the filename (for GDALImageI for example). If filename is a directory, look if is a * CEOS product (file "DAT...") In this case, the GdalFileName contain the open image file. */ bool GetGdalReadImageFileName(const std::string& filename, std::string& GdalFileName); // Retrieve the real source file name if derived dataset */ std::string GetDerivedDatasetSourceFileName(const std::string& filename) const; ImageFileReader(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented otb::ImageIOBase::Pointer m_ImageIO; bool m_UserSpecifiedImageIO; // keep track whether the // ImageIO is user specified std::string m_FileName; // The file to be read bool m_UseStreaming; std::string m_ExceptionMessage; // The region that the ImageIO class will return when we ask to // produce the requested region. itk::ImageIORegion m_ActualIORegion; FNameHelperType::Pointer m_FilenameHelper; unsigned int m_AdditionalNumber; bool m_KeywordListUpToDate; }; } //namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageFileReader.txx" #endif #endif // otbImageFileReader_h OTB-release-5.8/Modules/IO/ImageIO/include/otbImageFileReader.txx000066400000000000000000000751401301006202600244600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFileReader_txx #define otbImageFileReader_txx #include "otbImageFileReader.h" #include "otbConfigure.h" #include "otbSystem.h" #include #include #include #include "itkImageIOFactory.h" #include "itkPixelTraits.h" #include "itkVectorImage.h" #include "itkMetaDataObject.h" #include "otbConvertPixelBuffer.h" #include "otbImageIOFactory.h" #include "otbMetaDataKey.h" #include "otbMacro.h" namespace otb { static const char DerivedSubdatasetPrefix[] = "DERIVED_SUBDATASET:"; static const size_t DerivedSubdatasetPrefixLength = sizeof(DerivedSubdatasetPrefix); template bool PixelIsComplex(const std::complex& /*dummy*/) { return true; } template bool PixelIsComplex(const T& /*dummy*/) { return false; } template ImageFileReader ::ImageFileReader() : m_ImageIO(), m_UserSpecifiedImageIO(false), m_FileName(""), m_UseStreaming(true), m_ExceptionMessage(""), m_ActualIORegion(), m_FilenameHelper(FNameHelperType::New()), m_AdditionalNumber(0), m_KeywordListUpToDate(false) { } template ImageFileReader ::~ImageFileReader() { } template void ImageFileReader ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); if (this->m_ImageIO) { os << indent << "ImageIO: \n"; this->m_ImageIO->Print(os, indent.GetNextIndent()); } else { os << indent << "ImageIO: (null)" << "\n"; } os << indent << "UserSpecifiedImageIO flag: " << this->m_UserSpecifiedImageIO << "\n"; os << indent << "m_FileName: " << this->m_FileName << "\n"; os << indent << "m_UseStreaming flag: " << this->m_UseStreaming << "\n"; os << indent << "m_ActualIORegion: " << this->m_ActualIORegion << "\n"; os << indent << "m_AdditionalNumber: " << this->m_AdditionalNumber << "\n"; } template void ImageFileReader ::SetImageIO( otb::ImageIOBase * imageIO) { itkDebugMacro("setting ImageIO to " << imageIO ); if (this->m_ImageIO != imageIO ) { this->m_ImageIO = imageIO; this->Modified(); } m_UserSpecifiedImageIO = true; } template void ImageFileReader ::GenerateData() { typename TOutputImage::Pointer output = this->GetOutput(); // allocate the output buffer output->SetBufferedRegion(output->GetRequestedRegion()); output->Allocate(); // Test if the file exist and if it can be open. // An exception will be thrown otherwise. this->TestFileExistenceAndReadability(); // Tell the ImageIO to read the file OutputImagePixelType *buffer = output->GetPixelContainer()->GetBufferPointer(); this->m_ImageIO->SetFileName(this->m_FileName.c_str()); itk::ImageIORegion ioRegion(TOutputImage::ImageDimension); itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize(); itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex(); /* Init IORegion with size or streaming size */ SizeType dimSize; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { if (i < this->m_ImageIO->GetNumberOfDimensions()) { if (!this->m_ImageIO->CanStreamRead()) dimSize[i] = this->m_ImageIO->GetDimensions(i); else dimSize[i] = output->GetRequestedRegion().GetSize()[i]; } else { // Number of dimensions in the output is more than number of dimensions // in the ImageIO object (the file). Use default values for the size, // spacing, and origin for the final (degenerate) dimensions. dimSize[i] = 1; } } for (unsigned int i = 0; i < dimSize.GetSizeDimension(); ++i) { ioSize[i] = dimSize[i]; } typedef typename TOutputImage::IndexType IndexType; IndexType start; if (!this->m_ImageIO->CanStreamRead()) start.Fill(0); else start = output->GetRequestedRegion().GetIndex(); for (unsigned int i = 0; i < start.GetIndexDimension(); ++i) { ioStart[i] = start[i]; } ioRegion.SetSize(ioSize); ioRegion.SetIndex(ioStart); this->m_ImageIO->SetIORegion(ioRegion); typedef otb::DefaultConvertPixelTraits ConvertIOPixelTraits; typedef otb::DefaultConvertPixelTraits ConvertOutputPixelTraits; if (this->m_ImageIO->GetComponentTypeInfo() == typeid(typename ConvertOutputPixelTraits::ComponentType) && (this->m_ImageIO->GetNumberOfComponents() == ConvertIOPixelTraits::GetNumberOfComponents())) { // Have the ImageIO read directly into the allocated buffer this->m_ImageIO->Read(buffer); return; } else // a type conversion is necessary { // note: char is used here because the buffer is read in bytes // regardless of the actual type of the pixels. ImageRegionType region = output->GetBufferedRegion(); // Adapt the image size with the region std::streamoff nbBytes = (this->m_ImageIO->GetComponentSize() * this->m_ImageIO->GetNumberOfComponents()) * static_cast(region.GetNumberOfPixels()); char * loadBuffer = new char[nbBytes]; otbMsgDevMacro(<< "size of Buffer to GDALImageIO::read = " << nbBytes << " = \n" << "ComponentSize ("<< this->m_ImageIO->GetComponentSize() << ") x " \ << "Nb of Component (" << this->m_ImageIO->GetNumberOfComponents() << ") x " \ << "Nb of Pixel to read (" << region.GetNumberOfPixels() << ")" ); this->m_ImageIO->Read(loadBuffer); this->DoConvertBuffer(loadBuffer, region.GetNumberOfPixels()); delete[] loadBuffer; } } template void ImageFileReader ::EnlargeOutputRequestedRegion(itk::DataObject *output) { typename TOutputImage::Pointer out = dynamic_cast(output); // If the ImageIO object cannot stream, then set the RequestedRegion to the // LargestPossibleRegion if (!this->m_ImageIO->CanStreamRead()) { if (out) { out->SetRequestedRegion(out->GetLargestPossibleRegion()); } else { throw otb::ImageFileReaderException(__FILE__, __LINE__, "Invalid output object type"); } } } template void ImageFileReader ::GenerateOutputInformation(void) { typename TOutputImage::Pointer output = this->GetOutput(); itkDebugMacro(<< "Reading file for GenerateOutputInformation()" << this->m_FileName); // Check to see if we can read the file given the name or prefix // if (this->m_FileName == "") { throw otb::ImageFileReaderException(__FILE__, __LINE__, "FileName must be specified"); } // Find real image file name // !!!! Update FileName std::string lFileName; bool found = GetGdalReadImageFileName(this->m_FileName, lFileName); if (found == false) { otbMsgDebugMacro(<< "Filename was NOT unknown. May be recognized by a Image factory ! "); } // Update FileName this->m_FileName = lFileName; // Test if the file exists and if it can be opened. // An exception will be thrown otherwise. // We catch the exception because some ImageIO's may not actually // open a file. Still reports file error if no ImageIO is loaded. try { m_ExceptionMessage = ""; this->TestFileExistenceAndReadability(); } catch (itk::ExceptionObject & err) { m_ExceptionMessage = err.GetDescription(); } if (this->m_UserSpecifiedImageIO == false) //try creating via factory { this->m_ImageIO = ImageIOFactory::CreateImageIO(this->m_FileName.c_str(), otb::ImageIOFactory::ReadMode); } if (this->m_ImageIO.IsNull()) { //this->Print(std::cerr); otb::ImageFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << " Could not create IO object for file " << this->m_FileName.c_str() << std::endl; msg << " Tried to create one of the following:" << std::endl; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("otbImageIOBase"); for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { otb::ImageIOBase* io = dynamic_cast(i->GetPointer()); // IO should never be null, but we would better check for it if(io) msg << " " << io->GetNameOfClass() << std::endl; } msg << " You probably failed to set a file suffix, or" << std::endl; msg << " set the suffix to an unsupported type." << std::endl; e.SetDescription(msg.str().c_str()); throw e; return; } // Get the ImageIO MetaData Dictionary itk::MetaDataDictionary& dict = this->m_ImageIO->GetMetaDataDictionary(); // Hint the IO whether the OTB image type takes complex pixels // this will determine the strategy to fill up a vector image OutputImagePixelType dummy; bool lVectorImage = false; if (strcmp(output->GetNameOfClass(), "VectorImage") == 0) lVectorImage= true; this->m_ImageIO->SetOutputImagePixelType(PixelIsComplex(dummy),lVectorImage); // Pass the dataset number (used for hdf files for example) if (m_FilenameHelper->SubDatasetIndexIsSet()) { itk::EncapsulateMetaData(dict, MetaDataKey::SubDatasetIndex, m_FilenameHelper->GetSubDatasetIndex()); } else { itk::EncapsulateMetaData(dict, MetaDataKey::SubDatasetIndex, m_AdditionalNumber); } if (m_FilenameHelper->ResolutionFactorIsSet()) { itk::EncapsulateMetaData(dict, MetaDataKey::ResolutionFactor, m_FilenameHelper->GetResolutionFactor()); } else { itk::EncapsulateMetaData(dict, MetaDataKey::ResolutionFactor, m_AdditionalNumber); } // This value is used by JPEG2000ImageIO and not by the others ImageIO itk::EncapsulateMetaData(dict, MetaDataKey::CacheSizeInBytes, 135000000); // Got to allocate space for the image. Determine the characteristics of // the image. // this->m_ImageIO->SetFileName(this->m_FileName.c_str()); this->m_ImageIO->ReadImageInformation(); // Initialization du nombre de Composante par pixel // THOMAS ceci n'est pas dans ITK !! // output->SetNumberOfComponentsPerPixel(this->m_ImageIO->GetNumberOfComponents()); SizeType dimSize; double spacing[TOutputImage::ImageDimension]; double origin[TOutputImage::ImageDimension]; typename TOutputImage::DirectionType direction; std::vector axis; for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { if (i < this->m_ImageIO->GetNumberOfDimensions()) { dimSize[i] = this->m_ImageIO->GetDimensions(i); spacing[i] = this->m_ImageIO->GetSpacing(i); origin[i] = this->m_ImageIO->GetOrigin(i); // Please note: direction cosines are stored as columns of the // direction matrix axis = this->m_ImageIO->GetDirection(i); for (unsigned j = 0; j < TOutputImage::ImageDimension; ++j) { if (j < this->m_ImageIO->GetNumberOfDimensions()) { direction[j][i] = axis[j]; } else { direction[j][i] = 0.0; } } } else { // Number of dimensions in the output is more than number of dimensions // in the ImageIO object (the file). Use default values for the size, // spacing, origin and direction for the final (degenerate) dimensions. dimSize[i] = 1; spacing[i] = 1.0; origin[i] = 0.5; for (unsigned j = 0; j < TOutputImage::ImageDimension; ++j) { if (i == j) { direction[j][i] = 1.0; } else { direction[j][i] = 0.0; } } } } if (m_FilenameHelper->GetSkipCarto()) { for (unsigned int i = 0; i < TOutputImage::ImageDimension; ++i) { if ( m_FilenameHelper->GetResolutionFactor() != 0 ) { spacing[i] = 1.0*vcl_pow((double)2, (double)m_FilenameHelper->GetResolutionFactor()); } else { spacing[i] = 1.0; } origin[i] = 0.5*spacing[i]; } } output->SetSpacing(spacing); // Set the image spacing output->SetOrigin(origin); // Set the image origin output->SetDirection(direction); // Set the image direction cosines if(!m_KeywordListUpToDate && !m_FilenameHelper->GetSkipGeom()) { std::string lFileNameOssimKeywordlist = GetDerivedDatasetSourceFileName(m_FileName); // Update otb Keywordlist ImageKeywordlist otb_kwl; if (!m_FilenameHelper->ExtGEOMFileNameIsSet()) { otb_kwl = ReadGeometryFromImage(lFileNameOssimKeywordlist,!m_FilenameHelper->GetSkipRpcTag()); otbMsgDevMacro(<< "Loading internal kwl"); } else { otb_kwl = ReadGeometryFromGEOMFile(m_FilenameHelper->GetExtGEOMFileName()); otbMsgDevMacro(<< "Loading external kwl"); } // Don't add an empty ossim keyword list if(!otb_kwl.Empty()) { itk::EncapsulateMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, otb_kwl); } /*else { // // For image with world file, we have a non-null GeoTransform, an empty kwl, but no projection ref. // Decision made here : if the keywordlist is empty, and the geotransform is not the identity, // then assume the file is in WGS84 // std::string projRef; itk::ExposeMetaData(dict, MetaDataKey::ProjectionRefKey, projRef); // Compute spacing for an identity geotransform at current resolution unsigned int resolution = 0; itk::ExposeMetaData(dict, MetaDataKey::ResolutionFactor, resolution); double idSpacing = 1.0; if (resolution != 0) idSpacing = 1.0 * vcl_pow((double)2.0, (double)resolution); std::cout << "?" << std::endl; std::cout << vcl_abs(origin[0] - 0.5 * spacing[0]) << std::endl; std::cout << vcl_abs(origin[1] - 0.5 * spacing[1]) << std::endl; std::cout << vcl_abs(spacing[0] - idSpacing) << std::endl; std::cout << vcl_abs(spacing[1] - idSpacing) << std::endl; const double epsilon = 1.0E-12; if ( projRef.empty() && vcl_abs(origin[0] - 0.5 * spacing[0]) > epsilon && vcl_abs(origin[1] - 0.5 * spacing[1]) > epsilon && (vcl_abs(spacing[0] - idSpacing) > epsilon && vcl_abs(spacing[1] - idSpacing) > epsilon)) { std::cout << "Force the projection ref" << std::endl; std::string wgs84ProjRef = "GEOGCS[\"GCS_WGS_1984\", DATUM[\"D_WGS_1984\", SPHEROID[\"WGS_1984\", 6378137, 298.257223563]]," "PRIMEM[\"Greenwich\", 0], UNIT[\"Degree\", 0.017453292519943295]]"; itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, wgs84ProjRef); } }*/ m_KeywordListUpToDate = true; } else { // Read back from existing dictionary ImageKeywordlist otb_kwl; itk::ExposeMetaData(this->GetOutput()->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey,otb_kwl); // And add to new one itk::EncapsulateMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, otb_kwl); } // If Skip ProjectionRef is activated, remove ProjRef from dict if (m_FilenameHelper->GetSkipCarto()) { itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, ""); } //Copy MetaDataDictionary from instantiated reader to output image. if (!m_FilenameHelper->GetSkipGeom()) { output->SetMetaDataDictionary(this->m_ImageIO->GetMetaDataDictionary()); this->SetMetaDataDictionary(this->m_ImageIO->GetMetaDataDictionary()); } else { itk::MetaDataDictionary dictLight; std::string projRef; itk::ExposeMetaData(dict, MetaDataKey::ProjectionRefKey, projRef); itk::EncapsulateMetaData(dictLight, MetaDataKey::ProjectionRefKey, projRef); output->SetMetaDataDictionary(dictLight); this->SetMetaDataDictionary(dictLight); } typedef typename TOutputImage::IndexType IndexType; IndexType start; start.Fill(0); ImageRegionType region; region.SetSize(dimSize); region.SetIndex(start); // THOMAS : ajout // If a VectorImage, this requires us to set the // VectorLength before allocate if (strcmp(output->GetNameOfClass(), "VectorImage") == 0) { typedef typename TOutputImage::AccessorFunctorType AccessorFunctorType; AccessorFunctorType::SetVectorLength(output, this->m_ImageIO->GetNumberOfComponents()); } output->SetLargestPossibleRegion(region); } template std::string ImageFileReader ::GetDerivedDatasetSourceFileName(const std::string & filename) const { const size_t dsds_pos = filename.find(DerivedSubdatasetPrefix); if(dsds_pos != std::string::npos) { // Derived subdataset from gdal const size_t alg_pos = filename.find(":",dsds_pos+DerivedSubdatasetPrefixLength); if (alg_pos != std::string::npos) { std::string sourceFilename = filename.substr(alg_pos+1,filename.size() - alg_pos); return sourceFilename; } } return filename; } template void ImageFileReader ::TestFileExistenceAndReadability() { // Test if the file a server name : if so the test is skipped if (this->m_FileName.find(std::string("http://")) == 0 || this->m_FileName.find(std::string("https://")) == 0) { return; } std::string fileToCheck = GetDerivedDatasetSourceFileName(m_FileName); // Test if the file exists. if (!itksys::SystemTools::FileExists(fileToCheck.c_str())) { otb::ImageFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << "The file doesn't exist. " << std::endl << "Filename = " << fileToCheck << std::endl; e.SetDescription(msg.str().c_str()); throw e; return; } // Test if the file can be open for reading access. //Only if m_FileName specify a filename (not a dirname) if (itksys::SystemTools::FileExists(fileToCheck.c_str(), true)) { std::ifstream readTester; readTester.open(fileToCheck.c_str()); if (readTester.fail()) { readTester.close(); std::ostringstream msg; msg << "The file couldn't be opened for reading. " << std::endl << "Filename: " << fileToCheck << std::endl; otb::ImageFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } readTester.close(); } } template bool ImageFileReader ::GetGdalReadImageFileName(const std::string& filename, std::string& GdalFileName) { std::vector listFileSearch; listFileSearch.push_back("DAT_01.001"); listFileSearch.push_back("dat_01.001"); // RADARSAT or SAR_ERS2 listFileSearch.push_back("IMAGERY.TIF"); listFileSearch.push_back("imagery.tif"); //For format SPOT5TIF // Not recognized as a supported file format by GDAL. // listFileSearch.push_back("IMAGERY.BIL"); listFileSearch.push_back("imagery.bil"); //For format SPOT5BIL listFileSearch.push_back("IMAG_01.DAT"); listFileSearch.push_back("imag_01.dat"); //For format SPOT4 std::string str_FileName; bool fic_trouve(false); // Si c'est un repertoire, on regarde le contenu pour voir si c'est pas du RADARSAT, ERS std::vector listFileFind; listFileFind = System::Readdir(filename); if (listFileFind.empty() == false) { unsigned int cpt(0); while ((cpt < listFileFind.size()) && (fic_trouve == false)) { str_FileName = std::string(listFileFind[cpt]); for (unsigned int i = 0; i < listFileSearch.size(); ++i) { if (str_FileName.compare(listFileSearch[i]) == 0) { GdalFileName = std::string(filename) + str_FileName; //listFileSearch[i]; fic_trouve = true; } } ++cpt; } } else { std::string strFileName(filename); std::string extension = itksys::SystemTools::GetFilenameLastExtension(strFileName); if ((extension == ".HDR") || (extension == ".hdr")) { //Supprime l'extension GdalFileName = System::GetRootName(strFileName); } else { // Sinon le filename est le nom du fichier a ouvrir GdalFileName = std::string(filename); } fic_trouve = true; } otbMsgDevMacro(<< "lFileNameGdal : " << GdalFileName.c_str()); otbMsgDevMacro(<< "fic_trouve : " << fic_trouve); return (fic_trouve); } template void ImageFileReader ::SetFileName(std::string extendedFileName) { this->SetFileName(extendedFileName.c_str()); } template void ImageFileReader ::SetFileName(const char* in) { const std::string skip_geom_key = "skipgeom"; const std::string geom_key = "geom"; if (in) { // First, see if the simple filename has changed typename FNameHelperType::Pointer helper = FNameHelperType::New(); helper->SetExtendedFileName(in); std::string simpleFileName = helper->GetSimpleFileName(); if(simpleFileName == this->m_FileName) { // Then, see if the option map changed const typename ExtendedFilenameHelper::OptionMapType & newMap = helper->GetOptionMap(); const typename ExtendedFilenameHelper::OptionMapType & oldMap = m_FilenameHelper->GetOptionMap(); // Both maps are not completely the same if(oldMap.size() != newMap.size() || !std::equal(oldMap.begin(),oldMap.end(),newMap.begin())) { this->Modified(); // Now check if keywordlist needs to be generated again // Condition is: one of the old or new map has the skip_geom // key and the other does not // OR // one of the old or new map has the geom key and the other // does not // OR // both have the geom key but the geom value is different if((oldMap.count(skip_geom_key) != newMap.count(skip_geom_key)) || (oldMap.count(geom_key) != newMap.count(geom_key)) || ((oldMap.count(geom_key) && newMap.count(geom_key)) && oldMap.find(geom_key)->second != newMap.find(geom_key)->second)) { m_KeywordListUpToDate = false; } } } else { this->m_FileName = simpleFileName; m_KeywordListUpToDate = false; this->Modified(); } m_FilenameHelper = helper; } } template const char* ImageFileReader ::GetFileName () const { return this->m_FilenameHelper->GetSimpleFileName(); } template unsigned int ImageFileReader ::GetOverviewsCount() { this->UpdateOutputInformation(); return this->m_ImageIO->GetOverviewsCount(); } template std::vector ImageFileReader ::GetOverviewsInfo() { this->UpdateOutputInformation(); return this->m_ImageIO->GetOverviewsInfo(); } template void ImageFileReader ::DoConvertBuffer(void* inputData, size_t numberOfPixels) { // get the pointer to the destination buffer OutputImagePixelType *outputData = this->GetOutput()->GetPixelContainer()->GetBufferPointer(); // TODO: // Pass down the PixelType (RGB, VECTOR, etc.) so that any vector to // scalar conversion be type specific. i.e. RGB to scalar would use // a formula to convert to luminance, VECTOR to scalar would use // vector magnitude. // Create a macro as this code is a bit lengthy and repetitive // if the ImageIO pixel type is typeid(type) then use the ConvertPixelBuffer // class to convert the data block to TOutputImage's pixel type // see DefaultConvertPixelTraits and ConvertPixelBuffer // The first else if block applies only to images of type itk::VectorImage // VectorImage needs to copy out the buffer differently.. The buffer is of // type InternalPixelType, but each pixel is really 'k' consecutive pixels. #define OTB_CONVERT_BUFFER_IF_BLOCK(type) \ else if( m_ImageIO->GetComponentTypeInfo() == typeid(type) ) \ { \ if( strcmp( this->GetOutput()->GetNameOfClass(), "VectorImage" ) == 0 ) \ { \ ConvertPixelBuffer< \ type, \ OutputImagePixelType, \ ConvertPixelTraits \ > \ ::ConvertVectorImage( \ static_cast(inputData), \ m_ImageIO->GetNumberOfComponents(), \ outputData, \ numberOfPixels); \ } \ else \ { \ ConvertPixelBuffer< \ type, \ OutputImagePixelType, \ ConvertPixelTraits \ > \ ::Convert( \ static_cast(inputData), \ m_ImageIO->GetNumberOfComponents(), \ outputData, \ numberOfPixels); \ } \ } #define OTB_CONVERT_CBUFFER_IF_BLOCK(type) \ else if( m_ImageIO->GetComponentTypeInfo() == typeid(type) ) \ { \ if( strcmp( this->GetOutput()->GetNameOfClass(), "VectorImage" ) == 0 ) \ { \ if( (typeid(OutputImagePixelType) == typeid(std::complex)) \ || (typeid(OutputImagePixelType) == typeid(std::complex)) \ || (typeid(OutputImagePixelType) == typeid(std::complex)) \ || (typeid(OutputImagePixelType) == typeid(std::complex)) ) \ {\ ConvertPixelBuffer< \ type::value_type, \ OutputImagePixelType, \ ConvertPixelTraits \ > \ ::ConvertComplexVectorImageToVectorImageComplex( \ static_cast(inputData), \ m_ImageIO->GetNumberOfComponents(), \ outputData, \ numberOfPixels); \ }\ else\ {\ ConvertPixelBuffer< \ type::value_type, \ OutputImagePixelType, \ ConvertPixelTraits \ > \ ::ConvertComplexVectorImageToVectorImage( \ static_cast(inputData), \ m_ImageIO->GetNumberOfComponents(), \ outputData, \ numberOfPixels); \ }\ } \ else \ { \ ConvertPixelBuffer< \ type::value_type, \ OutputImagePixelType, \ ConvertPixelTraits \ > \ ::ConvertComplexToGray( \ static_cast(inputData), \ m_ImageIO->GetNumberOfComponents(), \ outputData, \ numberOfPixels); \ } \ } if(0) { } OTB_CONVERT_BUFFER_IF_BLOCK(unsigned char) OTB_CONVERT_BUFFER_IF_BLOCK(char) OTB_CONVERT_BUFFER_IF_BLOCK(unsigned short) OTB_CONVERT_BUFFER_IF_BLOCK(short) OTB_CONVERT_BUFFER_IF_BLOCK(unsigned int) OTB_CONVERT_BUFFER_IF_BLOCK(int) OTB_CONVERT_BUFFER_IF_BLOCK(unsigned long) OTB_CONVERT_BUFFER_IF_BLOCK(long) OTB_CONVERT_BUFFER_IF_BLOCK(float) OTB_CONVERT_BUFFER_IF_BLOCK(double) OTB_CONVERT_CBUFFER_IF_BLOCK(std::complex) OTB_CONVERT_CBUFFER_IF_BLOCK(std::complex) OTB_CONVERT_CBUFFER_IF_BLOCK(std::complex) OTB_CONVERT_CBUFFER_IF_BLOCK(std::complex) else { otb::ImageFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg <<"Couldn't convert component type: " << std::endl << " " << m_ImageIO->GetComponentTypeAsString(m_ImageIO->GetComponentType()) << std::endl << "to one of: " << std::endl << " " << typeid(unsigned char).name() << std::endl << " " << typeid(char).name() << std::endl << " " << typeid(unsigned short).name() << std::endl << " " << typeid(short).name() << std::endl << " " << typeid(unsigned int).name() << std::endl << " " << typeid(int).name() << std::endl << " " << typeid(unsigned long).name() << std::endl << " " << typeid(long).name() << std::endl << " " << typeid(float).name() << std::endl << " " << typeid(double).name() << std::endl; e.SetDescription(msg.str().c_str()); e.SetLocation(ITK_LOCATION); throw e; return; } #undef OTB_CONVERT_BUFFER_IF_BLOCK #undef OTB_CONVERT_CBUFFER_IF_BLOCK } } //namespace otb #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbImageFileWriter.h000066400000000000000000000246321301006202600241360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFileWriter_h #define otbImageFileWriter_h #include "otbImageIOBase.h" #include "itkProcessObject.h" #include "otbStreamingManager.h" #include "otbExtendedFilenameToWriterOptions.h" namespace otb { /** \class ImageFileWriter * \brief Writes image data to a single file with streaming process. * * ImageFileWriter writes its input data to a single output file. * ImageFileWriter interfaces with an ImageIO class to write out the * data with streaming process. * * ImageFileWriter will divide the output into several pieces * (controlled by SetNumberOfDivisionsStrippedStreaming, SetNumberOfLinesStrippedStreaming, * SetAutomaticStrippedStreaming, SetTileDimensionTiledStreaming or SetAutomaticTiledStreaming), * and call the upstream pipeline for each piece, tiling the individual outputs into one large * output. This reduces the memory footprint for the application since * each filter does not have to process the entire dataset at once. * * ImageFileWriter will write directly the streaming buffer in the image file, so * that the output image never needs to be completely allocated * * ImageFileWriter supports extended filenames, which allow controlling * some properties of the output file. See * http://wiki.orfeo-toolbox.org/index.php/ExtendedFileName for more * information. * * \sa ImageFileReader * \sa ImageSeriesReader * \sa ImageIOBase * \sa ExtendedFilenameToReaderOptions * * \ingroup OTBImageIO */ template class ITK_EXPORT ImageFileWriter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef ImageFileWriter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageFileWriter, itk::ProcessObject); /** Some typedefs for the input and output. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::IndexType InputIndexType; typedef TInputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename Superclass::DataObjectPointer DataObjectPointer; /** The Filename Helper. */ typedef ExtendedFilenameToWriterOptions FNameHelperType; /** Dimension of input image. */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); /** Streaming manager base class pointer */ typedef StreamingManager StreamingManagerType; typedef typename StreamingManagerType::Pointer StreamingManagerPointerType; /** Return the StreamingManager object responsible for dividing * the region to write */ StreamingManagerType* GetStreamingManager(void) { return m_StreamingManager; } /** Set a user-specified implementation of StreamingManager * used to divide the largest possible region in several divisions */ void SetStreamingManager(StreamingManagerType* streamingManager) { m_StreamingManager = streamingManager; } /** Set the streaming mode to 'stripped' and configure the number of strips * which will be used to stream the image */ void SetNumberOfDivisionsStrippedStreaming(unsigned int nbDivisions); /** Set the streaming mode to 'tiled' and configure the number of tiles * which will be used to stream the image */ void SetNumberOfDivisionsTiledStreaming(unsigned int nbDivisions); /** Set the streaming mode to 'stripped' and configure the number of strips * which will be used to stream the image with respect to a number of line * per strip */ void SetNumberOfLinesStrippedStreaming(unsigned int nbLinesPerStrip); /** Set the streaming mode to 'stripped' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option. * The bias parameter is a multiplier applied on the estimated memory size * of the pipeline and can be used to fine tune the potential gap between * estimated memory and actual memory used, which can happen because of * composite filters for example */ void SetAutomaticStrippedStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the streaming mode to 'tiled' and configure the dimension of the tiles * in pixels for each dimension (square tiles will be generated) */ void SetTileDimensionTiledStreaming(unsigned int tileDimension); /** Set the streaming mode to 'tiled' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Tiles will be square. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option * The bias parameter is a multiplier applied on the estimated memory size * of the pipeline and can be used to fine tune the potential gap between * estimated memory and actual memory used, which can happen because of * composite filters for example */ void SetAutomaticTiledStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the streaming mode to 'adaptative' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Tiles will try to match the input file tile scheme. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option */ void SetAutomaticAdaptativeStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the only input of the writer */ using Superclass::SetInput; virtual void SetInput(const InputImageType *input); /** Get writer only input */ const InputImageType* GetInput(); /** Override Update() from ProcessObject because this filter * has no output. */ void Update() ITK_OVERRIDE; /** ImageFileWriter Methods */ virtual void SetFileName(const char* extendedFileName); virtual void SetFileName(std::string extendedFileName); virtual const char* GetFileName () const; /** Specify the region to write. If left NULL, then the whole image * is written. */ void SetIORegion(const itk::ImageIORegion& region); itkGetConstReferenceMacro(IORegion, itk::ImageIORegion); /** Set the compression On or Off */ itkSetMacro(UseCompression, bool); itkGetConstReferenceMacro(UseCompression, bool); itkBooleanMacro(UseCompression); /** By default the MetaDataDictionary is taken from the input image and * passed to the ImageIO. In some cases, however, a user may prefer to * introduce her/his own MetaDataDictionary. This is often the case of * the ImageSeriesWriter. This flag defined whether the MetaDataDictionary * to use will be the one from the input image or the one already set in * the ImageIO object. */ itkSetMacro(UseInputMetaDataDictionary, bool); itkGetConstReferenceMacro(UseInputMetaDataDictionary, bool); itkBooleanMacro(UseInputMetaDataDictionary); itkSetObjectMacro(ImageIO, otb::ImageIOBase); itkGetObjectMacro(ImageIO, otb::ImageIOBase); itkGetConstObjectMacro(ImageIO, otb::ImageIOBase); protected: ImageFileWriter(); ~ImageFileWriter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Does the real work. */ void GenerateData(void) ITK_OVERRIDE; private: ImageFileWriter(const ImageFileWriter &); //purposely not implemented void operator =(const ImageFileWriter&); //purposely not implemented void ObserveSourceFilterProgress(itk::Object* object, const itk::EventObject & event ) { if (typeid(event) != typeid(itk::ProgressEvent)) { return; } itk::ProcessObject* processObject = dynamic_cast(object); if (processObject) { m_DivisionProgress = processObject->GetProgress(); } this->UpdateFilterProgress(); } void UpdateFilterProgress() { this->UpdateProgress( (m_DivisionProgress + m_CurrentDivision) / m_NumberOfDivisions ); } unsigned int m_NumberOfDivisions; unsigned int m_CurrentDivision; float m_DivisionProgress; /** ImageFileWriter Parameters */ std::string m_FileName; otb::ImageIOBase::Pointer m_ImageIO; bool m_UserSpecifiedImageIO; //track whether the ImageIO is user specified itk::ImageIORegion m_IORegion; bool m_UserSpecifiedIORegion; // track whether the region is user specified bool m_FactorySpecifiedImageIO; //track whether the factory mechanism set the ImageIO bool m_UseCompression; bool m_UseInputMetaDataDictionary; // whether to use the // MetaDataDictionary from the // input or not. bool m_WriteGeomFile; // Write a geom file to store the // kwl FNameHelperType::Pointer m_FilenameHelper; StreamingManagerPointerType m_StreamingManager; bool m_IsObserving; unsigned long m_ObserverID; InputIndexType m_ShiftOutputIndex; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageFileWriter.txx" #endif #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbImageFileWriter.txx000066400000000000000000000621101301006202600245230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageFileWriter_txx #define otbImageFileWriter_txx #include "otbImageFileWriter.h" #include "itkImageFileWriter.h" #include "itkObjectFactoryBase.h" #include "itkImageRegionMultidimensionalSplitter.h" #include "otbImageIOFactory.h" #include "itkImageRegionIterator.h" #include "itkMetaDataObject.h" #include "otbImageKeywordlist.h" #include "otbMetaDataKey.h" #include "otbConfigure.h" #include "otbNumberOfDivisionsStrippedStreamingManager.h" #include "otbNumberOfDivisionsTiledStreamingManager.h" #include "otbNumberOfLinesStrippedStreamingManager.h" #include "otbRAMDrivenStrippedStreamingManager.h" #include "otbTileDimensionTiledStreamingManager.h" #include "otbRAMDrivenTiledStreamingManager.h" #include "otbRAMDrivenAdaptativeStreamingManager.h" #include "otb_boost_tokenizer_header.h" #include "otbStringUtils.h" namespace otb { /** * */ template ImageFileWriter ::ImageFileWriter() : m_NumberOfDivisions(0), m_CurrentDivision(0), m_DivisionProgress(0.0), m_UserSpecifiedImageIO(true), m_UserSpecifiedIORegion(false), m_FactorySpecifiedImageIO(false), m_UseCompression(false), m_UseInputMetaDataDictionary(false), m_WriteGeomFile(false), m_FilenameHelper(), m_IsObserving(true), m_ObserverID(0) { //Init output index shift m_ShiftOutputIndex.Fill(0); // By default, we use tiled streaming, with automatic tile size // We don't set any parameter, so the memory size is retrieved from the OTB configuration options this->SetAutomaticAdaptativeStreaming(); m_FilenameHelper = FNameHelperType::New(); } /** * */ template ImageFileWriter ::~ImageFileWriter() { } template void ImageFileWriter ::SetNumberOfDivisionsStrippedStreaming(unsigned int nbDivisions) { typedef NumberOfDivisionsStrippedStreamingManager NumberOfDivisionsStrippedStreamingManagerType; typename NumberOfDivisionsStrippedStreamingManagerType::Pointer streamingManager = NumberOfDivisionsStrippedStreamingManagerType::New(); streamingManager->SetNumberOfDivisions(nbDivisions); m_StreamingManager = streamingManager; } template void ImageFileWriter ::SetNumberOfDivisionsTiledStreaming(unsigned int nbDivisions) { typedef NumberOfDivisionsTiledStreamingManager NumberOfDivisionsTiledStreamingManagerType; typename NumberOfDivisionsTiledStreamingManagerType::Pointer streamingManager = NumberOfDivisionsTiledStreamingManagerType::New(); streamingManager->SetNumberOfDivisions(nbDivisions); m_StreamingManager = streamingManager; } template void ImageFileWriter ::SetNumberOfLinesStrippedStreaming(unsigned int nbLinesPerStrip) { typedef NumberOfLinesStrippedStreamingManager NumberOfLinesStrippedStreamingManagerType; typename NumberOfLinesStrippedStreamingManagerType::Pointer streamingManager = NumberOfLinesStrippedStreamingManagerType::New(); streamingManager->SetNumberOfLinesPerStrip(nbLinesPerStrip); m_StreamingManager = streamingManager; } template void ImageFileWriter ::SetAutomaticStrippedStreaming(unsigned int availableRAM, double bias) { typedef RAMDrivenStrippedStreamingManager RAMDrivenStrippedStreamingManagerType; typename RAMDrivenStrippedStreamingManagerType::Pointer streamingManager = RAMDrivenStrippedStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } template void ImageFileWriter ::SetTileDimensionTiledStreaming(unsigned int tileDimension) { typedef TileDimensionTiledStreamingManager TileDimensionTiledStreamingManagerType; typename TileDimensionTiledStreamingManagerType::Pointer streamingManager = TileDimensionTiledStreamingManagerType::New(); streamingManager->SetTileDimension(tileDimension); m_StreamingManager = streamingManager; } template void ImageFileWriter ::SetAutomaticTiledStreaming(unsigned int availableRAM, double bias) { typedef RAMDrivenTiledStreamingManager RAMDrivenTiledStreamingManagerType; typename RAMDrivenTiledStreamingManagerType::Pointer streamingManager = RAMDrivenTiledStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } template void ImageFileWriter ::SetAutomaticAdaptativeStreaming(unsigned int availableRAM, double bias) { typedef RAMDrivenAdaptativeStreamingManager RAMDrivenAdaptativeStreamingManagerType; typename RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } #ifndef ITK_LEGACY_REMOVE #endif // ITK_LEGACY_REMOVE /** * */ template void ImageFileWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "File Name: " << (m_FileName.data() ? m_FileName.data() : "(none)") << std::endl; os << indent << "Image IO: "; if (m_ImageIO.IsNull()) { os << "(none)\n"; } else { os << m_ImageIO << "\n"; } os << indent << "IO Region: " << m_IORegion << "\n"; if (m_UseCompression) { os << indent << "Compression: On\n"; } else { os << indent << "Compression: Off\n"; } if (m_UseInputMetaDataDictionary) { os << indent << "UseInputMetaDataDictionary: On\n"; } else { os << indent << "UseInputMetaDataDictionary: Off\n"; } if (m_FactorySpecifiedImageIO) { os << indent << "FactorySpecifiedmageIO: On\n"; } else { os << indent << "FactorySpecifiedmageIO: Off\n"; } } //--------------------------------------------------------- template void ImageFileWriter ::SetIORegion(const itk::ImageIORegion& region) { itkDebugMacro("setting IORegion to " << region); if (m_IORegion != region) { m_IORegion = region; this->Modified(); m_UserSpecifiedIORegion = true; } } template void ImageFileWriter ::SetInput(const InputImageType* input) { this->ProcessObject::SetNthInput(0,const_cast(input)); } template const TInputImage* ImageFileWriter ::GetInput() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->ProcessObject::GetInput(0)); } /** * Update method : update output information of input and write to file */ template void ImageFileWriter ::Update() { // Update output information on input image InputImagePointer inputPtr = const_cast(this->GetInput()); // Make sure input is available if ( inputPtr.IsNull() ) { itkExceptionMacro(<< "No input to writer"); } /** Parse streaming modes */ if(m_FilenameHelper->StreamingTypeIsSet()) { itkWarningMacro(<<"Streaming configuration through extended filename is used. Any previous streaming configuration (ram value, streaming mode ...) will be ignored."); std::string type = m_FilenameHelper->GetStreamingType(); std::string sizemode = "auto"; if(m_FilenameHelper->StreamingSizeModeIsSet()) { sizemode = m_FilenameHelper->GetStreamingSizeMode(); } double sizevalue = 0.; if(m_FilenameHelper->StreamingSizeValueIsSet()) { sizevalue = m_FilenameHelper->GetStreamingSizeValue(); } if(type == "auto") { if(sizemode != "auto") { itkWarningMacro(<<"In auto streaming type, the sizemode option will be ignored."); } if(sizevalue == 0.) { itkWarningMacro("sizemode is auto but sizevalue is 0. Value will be fetched from the OTB_MAX_RAM_HINT environment variable if set, or else use the default value"); } this->SetAutomaticAdaptativeStreaming(sizevalue); } else if(type == "tiled") { if(sizemode == "auto") { if(sizevalue == 0.) { itkWarningMacro("sizemode is auto but sizevalue is 0. Value will be fetched from the OTB_MAX_RAM_HINT environment variable if set, or else use the default value"); } this->SetAutomaticTiledStreaming(sizevalue); } else if(sizemode == "nbsplits") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to nbsplits but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetNumberOfDivisionsTiledStreaming(static_cast(sizevalue)); } else if(sizemode == "height") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to height but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetTileDimensionTiledStreaming(static_cast(sizevalue)); } } else if(type == "stripped") { if(sizemode == "auto") { if(sizevalue == 0.) { itkWarningMacro("sizemode is auto but sizevalue is 0. Value will be fetched from configuration file if any, or from cmake configuration otherwise."); } this->SetAutomaticStrippedStreaming(sizevalue); } else if(sizemode == "nbsplits") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to nbsplits but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetNumberOfDivisionsStrippedStreaming(static_cast(sizevalue)); } else if(sizemode == "height") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to height but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetNumberOfLinesStrippedStreaming(static_cast(sizevalue)); } } else if (type == "none") { if(sizemode!="" || sizevalue!=0.) { itkWarningMacro("Streaming is explicitly disabled, sizemode and sizevalue will be ignored."); } this->SetNumberOfDivisionsTiledStreaming(0); } } else { if(m_FilenameHelper->StreamingSizeValueIsSet() || m_FilenameHelper->StreamingSizeModeIsSet()) { itkWarningMacro(<<"No streaming type is set, streaming sizemode and sizevalue will be ignored."); } } this->SetAbortGenerateData(0); this->SetProgress(0.0); /** * Tell all Observers that the filter is starting */ this->InvokeEvent(itk::StartEvent()); /** Prepare ImageIO : create ImageFactory */ if (m_FileName == "") { // Make sure that we can write the file given the name itkExceptionMacro(<< "No filename was specified"); } // Make sure CanWriteFile is called // either from ImageIOFactory::CreateImageIO or directly in this file // GDALImageIO uses it to store the filename // and later answer to CanStreamWrite() // This is a needed workaround to a defect in the itk::ImageIO interface if (m_ImageIO.IsNull()) //try creating via factory { itkDebugMacro(<< "Attempting factory creation of ImageIO for file: " << m_FileName); this->SetImageIO(ImageIOFactory::CreateImageIO(m_FileName.c_str(), otb::ImageIOFactory::WriteMode)); m_FactorySpecifiedImageIO = true; } else { if (!m_ImageIO->CanWriteFile(m_FileName.c_str())) { itkDebugMacro(<< "ImageIO exists but doesn't know how to write file:" << m_FileName); if (m_FactorySpecifiedImageIO) { itkDebugMacro(<< "Attempting creation of ImageIO with a factory for file:" << m_FileName); m_ImageIO = ImageIOFactory::CreateImageIO(m_FileName.c_str(), otb::ImageIOFactory::WriteMode); m_FactorySpecifiedImageIO = true; } } } if (m_ImageIO.IsNull()) { itk::ImageFileWriterException e(__FILE__, __LINE__); std::ostringstream msg; msg << " Could not create IO object for file " << m_FileName.c_str() << std::endl; msg << " Tried to create one of the following:" << std::endl; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("otbImageIOBase"); for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { otb::ImageIOBase* io = dynamic_cast(i->GetPointer()); if(io) msg << " " << io->GetNameOfClass() << std::endl; } msg << " You probably failed to set a file suffix, or" << std::endl; msg << " set the suffix to an unsupported type." << std::endl; e.SetDescription(msg.str().c_str()); e.SetLocation(ITK_LOCATION); throw e; } // Manage extended filename if ((strcmp(m_ImageIO->GetNameOfClass(), "GDALImageIO") == 0) && (m_FilenameHelper->gdalCreationOptionsIsSet() || m_FilenameHelper->WriteRPCTagsIsSet()) ) { typename GDALImageIO::Pointer imageIO = dynamic_cast(m_ImageIO.GetPointer()); if(imageIO.IsNull()) { itk::ImageFileWriterException e(__FILE__, __LINE__); std::ostringstream msg; msg << " ImageIO is of kind GDALImageIO, but fails to dynamic_cast (this should never happen)."<< std::endl; e.SetDescription(msg.str().c_str()); throw e; } imageIO->SetOptions(m_FilenameHelper->GetgdalCreationOptions()); imageIO->SetWriteRPCTags(m_FilenameHelper->GetWriteRPCTags()); } /** End of Prepare ImageIO : create ImageFactory */ /** * Grab the input */ inputPtr->UpdateOutputInformation(); InputImageRegionType inputRegion = inputPtr->GetLargestPossibleRegion(); /** Parse region size modes */ if(m_FilenameHelper->BoxIsSet()) { std::vector boxVector; Utils::ConvertStringToVector( m_FilenameHelper->GetBox(), boxVector, "ExtendedFileName:box", ":"); typename InputImageRegionType::IndexType start; typename InputImageRegionType::SizeType size; start[0] = boxVector[0]; // first index on X start[1] = boxVector[1]; // first index on Y size[0] = boxVector[2]; // size along X size[1] = boxVector[3]; // size along Y inputRegion.SetSize(size); m_ShiftOutputIndex = start; inputRegion.SetIndex(m_ShiftOutputIndex); if (!inputRegion.Crop(inputPtr->GetLargestPossibleRegion())) { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested box region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } otbMsgDevMacro(<< "inputRegion " << inputRegion); } /** * Determine of number of pieces to divide the input. This will be the * minimum of what the user specified via SetNumberOfDivisionsStrippedStreaming() * and what the Splitter thinks is a reasonable value. */ /** Control if the ImageIO is CanStreamWrite */ if (m_ImageIO->CanStreamWrite() == false) { otbWarningMacro( << "The ImageFactory selected for the image file <" << m_FileName.c_str() << "> does not support streaming."); this->SetNumberOfDivisionsStrippedStreaming(1); } /** Compare the buffered region with the inputRegion which is the largest * possible region or a user defined region through extended filename * Not sure that if this modification is needed */ else if (inputPtr->GetBufferedRegion() == inputRegion) { otbMsgDevMacro(<< "Buffered region is the largest possible region, there is no need for streaming."); this->SetNumberOfDivisionsStrippedStreaming(1); } m_StreamingManager->PrepareStreaming(inputPtr, inputRegion); m_NumberOfDivisions = m_StreamingManager->GetNumberOfSplits(); otbMsgDebugMacro(<< "Number Of Stream Divisions : " << m_NumberOfDivisions); /** * Loop over the number of pieces, execute the upstream pipeline on each * piece, and copy the results into the output image. */ InputImageRegionType streamRegion; // // Setup the ImageIO with information from inputPtr // m_ImageIO->SetNumberOfDimensions(TInputImage::ImageDimension); const typename TInputImage::SpacingType& spacing = inputPtr->GetSpacing(); const typename TInputImage::PointType& origin = inputPtr->GetOrigin(); const typename TInputImage::DirectionType& direction = inputPtr->GetDirection(); for (unsigned int i = 0; i < TInputImage::ImageDimension; ++i) { // Final image size m_ImageIO->SetDimensions(i, inputRegion.GetSize(i)); m_ImageIO->SetSpacing(i, spacing[i]); m_ImageIO->SetOrigin(i, origin[i] + static_cast(inputRegion.GetIndex()[i]) * spacing[i]); vnl_vector axisDirection(TInputImage::ImageDimension); // Please note: direction cosines are stored as columns of the // direction matrix for (unsigned int j = 0; j < TInputImage::ImageDimension; ++j) { axisDirection[j] = direction[j][i]; } m_ImageIO->SetDirection(i, axisDirection); } m_ImageIO->SetUseCompression(m_UseCompression); m_ImageIO->SetMetaDataDictionary(inputPtr->GetMetaDataDictionary()); /** Create Image file */ // Setup the image IO for writing. // m_ImageIO->SetFileName(m_FileName.c_str()); m_ImageIO->WriteImageInformation(); this->UpdateProgress(0); m_CurrentDivision = 0; m_DivisionProgress = 0; // Get the source process object itk::ProcessObject* source = inputPtr->GetSource(); m_IsObserving = false; m_ObserverID = 0; // Check if source exists if(source) { typedef itk::MemberCommand CommandType; typedef typename CommandType::Pointer CommandPointerType; CommandPointerType command = CommandType::New(); command->SetCallbackFunction(this, &Self::ObserveSourceFilterProgress); m_ObserverID = source->AddObserver(itk::ProgressEvent(), command); m_IsObserving = true; } else { itkWarningMacro(<< "Could not get the source process object. Progress report might be buggy"); } for (m_CurrentDivision = 0; m_CurrentDivision < m_NumberOfDivisions && !this->GetAbortGenerateData(); m_CurrentDivision++, m_DivisionProgress = 0, this->UpdateFilterProgress()) { streamRegion = m_StreamingManager->GetSplit(m_CurrentDivision); inputPtr->SetRequestedRegion(streamRegion); inputPtr->PropagateRequestedRegion(); inputPtr->UpdateOutputData(); // Write the whole image itk::ImageIORegion ioRegion(TInputImage::ImageDimension); for (unsigned int i = 0; i < TInputImage::ImageDimension; ++i) { ioRegion.SetSize(i, streamRegion.GetSize(i)); ioRegion.SetIndex(i, streamRegion.GetIndex(i)); //Set the ioRegion index using the shifted index ( (0,0 without box parameter)) ioRegion.SetIndex(i, streamRegion.GetIndex(i) - m_ShiftOutputIndex[i]); } this->SetIORegion(ioRegion); m_ImageIO->SetIORegion(m_IORegion); // Start writing stream region in the image file this->GenerateData(); } /** * If we ended due to aborting, push the progress up to 1.0 (since * it probably didn't end there) */ if (!this->GetAbortGenerateData()) { this->UpdateProgress(1.0); } // Notify end event observers this->InvokeEvent(itk::EndEvent()); if (m_IsObserving) { m_IsObserving = false; source->RemoveObserver(m_ObserverID); } // Write the image keyword list if any // ossimKeywordlist geom_kwl; // ImageKeywordlist otb_kwl; // itk::MetaDataDictionary dict = this->GetInput()->GetMetaDataDictionary(); // itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, otb_kwl); // otb_kwl.convertToOSSIMKeywordlist(geom_kwl); //FIXME: why nothing is done with otb_kwl in that case??? // If required, put a call to WriteGeometry() here /** * Release any inputs if marked for release */ this->ReleaseInputs(); //Reset global shift on input region (box parameter) //It allows calling multiple update over the writer m_ShiftOutputIndex.Fill(0); } /** * */ template void ImageFileWriter ::GenerateData(void) { const InputImageType * input = this->GetInput(); InputImagePointer cacheImage; // Make sure that the image is the right type and no more than // four components. typedef typename InputImageType::PixelType ImagePixelType; if (strcmp(input->GetNameOfClass(), "VectorImage") == 0) { typedef typename InputImageType::InternalPixelType VectorImagePixelType; m_ImageIO->SetPixelTypeInfo(typeid(VectorImagePixelType)); typedef typename InputImageType::AccessorFunctorType AccessorFunctorType; m_ImageIO->SetNumberOfComponents(AccessorFunctorType::GetVectorLength(input)); } else { // Set the pixel and component type; the number of components. m_ImageIO->SetPixelTypeInfo(typeid(ImagePixelType)); } // Setup the image IO for writing. // //okay, now extract the data as a raw buffer pointer const void* dataPtr = (const void*) input->GetBufferPointer(); // check that the image's buffered region is the same as // ImageIO is expecting and we requested InputImageRegionType ioRegion; // No shift of the ioRegion from the buffered region is expected typename InputImageRegionType::IndexType tmpIndex; tmpIndex.Fill(0); itk::ImageIORegionAdaptor:: //Convert(m_ImageIO->GetIORegion(), ioRegion, tmpIndex); Convert(m_ImageIO->GetIORegion(), ioRegion, m_ShiftOutputIndex); InputImageRegionType bufferedRegion = input->GetBufferedRegion(); // before this test, bad stuff would happened when they don't match if (bufferedRegion != ioRegion) { if ( m_NumberOfDivisions > 1 || m_UserSpecifiedIORegion) { itkDebugMacro("Requested stream region does not match generated output"); itkDebugMacro("input filter may not support streaming well"); cacheImage = InputImageType::New(); cacheImage->CopyInformation(input); cacheImage->SetBufferedRegion(ioRegion); cacheImage->Allocate(); typedef itk::ImageRegionConstIterator ConstIteratorType; typedef itk::ImageRegionIterator IteratorType; ConstIteratorType in(input, ioRegion); IteratorType out(cacheImage, ioRegion); // copy the data into a buffer to match the ioregion for (in.GoToBegin(), out.GoToBegin(); !in.IsAtEnd(); ++in, ++out) { out.Set(in.Get()); } dataPtr = (const void*) cacheImage->GetBufferPointer(); } else { itk::ImageFileWriterException e(__FILE__, __LINE__); std::ostringstream msg; msg << "Did not get requested region!" << std::endl; msg << "Requested:" << std::endl; msg << ioRegion; msg << "Actual:" << std::endl; msg << bufferedRegion; e.SetDescription(msg.str().c_str()); e.SetLocation(ITK_LOCATION); throw e; } } m_ImageIO->Write(dataPtr); if (m_WriteGeomFile || m_FilenameHelper->GetWriteGEOMFile()) { ImageKeywordlist otb_kwl; itk::MetaDataDictionary dict = this->GetInput()->GetMetaDataDictionary(); itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, otb_kwl); WriteGeometry(otb_kwl, this->GetFileName()); } } template void ImageFileWriter ::SetFileName(std::string extendedFileName) { this->SetFileName(extendedFileName.c_str()); } template void ImageFileWriter ::SetFileName(const char* extendedFileName) { this->m_FilenameHelper->SetExtendedFileName(extendedFileName); m_FileName = this->m_FilenameHelper->GetSimpleFileName(); m_ImageIO = ITK_NULLPTR; this->Modified(); } template const char* ImageFileWriter ::GetFileName () const { return this->m_FilenameHelper->GetSimpleFileName(); } } // end namespace otb #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbImageIOFactory.h000066400000000000000000000036431301006202600237200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageIOFactory_h #define otbImageIOFactory_h #include "itkObject.h" #include "otbImageIOBase.h" namespace otb { /** \class ImageIOFactory * \brief Creation of object instance using object factory. * * \ingroup OTBImageIO */ class ITK_EXPORT ImageIOFactory : public itk::Object { public: /** Standard class typedefs. */ typedef ImageIOFactory Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class Methods used to interface with the registered factories */ /** Run-time type information (and related methods). */ itkTypeMacro(ImageIOFactory, itk::Object); /** Convenient typedefs. */ typedef ::otb::ImageIOBase::Pointer ImageIOBasePointer; /** Mode in which the files is intended to be used */ typedef enum { ReadMode, WriteMode } FileModeType; /** Create the appropriate ImageIO depending on the particulars of the file. */ static ImageIOBasePointer CreateImageIO(const char* path, FileModeType mode); /** Register Built-in factories */ static void RegisterBuiltInFactories(); protected: ImageIOFactory(); ~ImageIOFactory() ITK_OVERRIDE; private: ImageIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbImageSeriesFileReader.h000066400000000000000000000466261301006202600252460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSeriesFileReader_h #define otbImageSeriesFileReader_h #include "otbImageSeriesFileReaderBase.h" #include "otbObjectList.h" #include "otbExtractROI.h" #include "otbMultiChannelExtractROI.h" #include "otbMultiToMonoChannelExtractROI.h" namespace otb { /** * \class ImageSeriesFileReader * \brief Reader class dedicated to image series reading * * Actually, this class is mostly dedicated to read ENVI META FILE. Specializations * of the template are given relatively to the king of image (or vector image) used * in input and/or output. * * * \see ImageFileReader * * \ingroup OTBImageIO */ template class ITK_EXPORT ImageSeriesFileReader : public ImageSeriesFileReaderBase { public: /** Standard typedefs */ typedef ImageSeriesFileReader Self; typedef ImageSeriesFileReaderBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(ImageSeriesFileReader, ImageSeriesFileReaderBase); typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RegionType RegionType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImageListPointerType OutputImageListPointerType; typedef typename Superclass::OutputImageListConstPointerType OutputImageListConstPointerType; typedef typename Superclass::InternalImageType InternalImageType; typedef typename Superclass::InternalImagePointerType InternalImagePointerType; typedef typename Superclass::InternalPixelType InternalPixelType; typedef typename Superclass::InternalValueType InternalValueType; typedef typename Superclass::InternalIndexType InternalIndexType; typedef typename Superclass::InternalSizeType InternalSizeType; typedef typename Superclass::InternalRegionType InternalRegionType; typedef typename Superclass::ReaderType ReaderType; typedef typename Superclass::ReaderType ReaderPointerType; typedef typename Superclass::ReaderListType ReaderListType; typedef typename Superclass::ReaderListPointerType ReaderListPointerType; /** This is a generic template definition of the ROI extraction procedure. * In fact, it will be specialised with: * - MultiChannelExtractROI if TImage is a VectorImage * - MultiToMonoChannelExtractROI if TImage is an Image and TInteranalImage is a VectorImage * - ExtractROI if TImage and TInternalImage are of Image type. */ // typedef MultiChannelExtractROI< InternalPixelType, PixelType > ExtractSelectionType; // typedef MultiToMonoChannelExtractROI< InternalPixelType, PixelType > ExtractSelectionType; // typedef ExtractROI< InternalPixelType, PixelType > ExtractSelectionType; typedef itk::ImageToImageFilter ExtractSelectionType; typedef typename ExtractSelectionType::Pointer ExtractSelectionPointerType; typedef ObjectList ExtractSelectionListType; typedef typename ExtractSelectionListType::Pointer ExtractSelectionListPointerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; protected: ImageSeriesFileReader(); virtual ~ImageSeriesFileReader () {} /** TestBandSelection * Tests the coherency of the Meta File (especifically band selection) with the image types */ virtual void TestBandSelection(std::vector& itkNotUsed(bands)) {} /** GenerateData * This method will be specialised if template definitions follow: * - TImage is a VectorImage * - TImage is an Image and TInteranalImage is a VectorImage * - TImage and TInternalImage are of Image type. */ virtual void GenerateData(DataObjectPointerArraySizeType idx); using Superclass::GenerateData; /** AllocateListOfComponents * Once MetaFile is read, allocation of lists are performed in SetFileName. * This allows specific (or global) initialization in the GenerateData methods, * that the user may invoke through GenerateOutput() or GenerateOutput( idx ). */ virtual void AllocateListOfComponents(void); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const { return Superclass::PrintSelf(os, indent); } /** * Type of extractor to use */ ExtractSelectionListPointerType m_ExtractorList; private: ImageSeriesFileReader (const Self &); void operator =(const Self&); }; // end of class /** * \class ImageSeriesFileReader * \brief Specific definition for template Images * * In the case where TImage and TInternalImage stand for otb::Image, the * TExtractSelection must be of type ExtractROI. * * GenerateData and TestBandSelection methods are specialised. * * \see ImageSeriesFileReader * * \ingroup OTBImageIO */ template class ITK_EXPORT ImageSeriesFileReader, Image > : public ImageSeriesFileReaderBase, Image > { public: /** Standard typedefs */ typedef ImageSeriesFileReader Self; typedef ImageSeriesFileReaderBase, Image > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(ImageSeriesFileReader, ImageSeriesFileReaderBase); typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RegionType RegionType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImageListPointerType OutputImageListPointerType; typedef typename Superclass::OutputImageListConstPointerType OutputImageListConstPointerType; typedef typename Superclass::InternalImageType InternalImageType; typedef typename Superclass::InternalImagePointerType InternalImagePointerType; typedef typename Superclass::InternalPixelType InternalPixelType; typedef typename Superclass::InternalValueType InternalValueType; typedef typename Superclass::InternalIndexType InternalIndexType; typedef typename Superclass::InternalSizeType InternalSizeType; typedef typename Superclass::InternalRegionType InternalRegionType; typedef typename Superclass::ReaderType ReaderType; typedef typename Superclass::ReaderType ReaderPointerType; typedef typename Superclass::ReaderListType ReaderListType; typedef typename Superclass::ReaderListPointerType ReaderListPointerType; /** This is a specialised template definition of the ROI extraction procedure. * Here TExtractSelection is a ExtractROI class since TImage and TInternalImage are of Image type. */ typedef ExtractROI ExtractSelectionType; typedef typename ExtractSelectionType::Pointer ExtractSelectionPointerType; typedef ObjectList ExtractSelectionListType; typedef typename ExtractSelectionListType::Pointer ExtractSelectionListPointerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; protected: ImageSeriesFileReader(); virtual ~ImageSeriesFileReader () {} /** TestBandSelection * Tests the coherency of the Meta File (especifically band selection) with the image types */ virtual void TestBandSelection(std::vector& bands); /** GenerateData * This method will be specialised if template definitions follow: * - TImage is a VectorImage * - TImage is an Image and TInteranalImage is a VectorImage * - TImage and TInternalImage are of Image type. */ virtual void GenerateData(DataObjectPointerArraySizeType idx); using Superclass::GenerateData; /** * Once MetaFile is read, allocation of lists are performed in SetFileName. * This allows specific (or global) initialization in the GenerateData methods, * that the user may invoke through GenerateOutput() or GenerateOutput( idx ). */ virtual void AllocateListOfComponents(void); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const { return Superclass::PrintSelf(os, indent); } /** * Type of extractor to use */ ExtractSelectionListPointerType m_ExtractorList; private: ImageSeriesFileReader (const Self &); void operator =(const Self&); }; // end of class specialized for image /** \class ImageSeriesFileReader * \brief Specific definition for VectorImage in reading and Image type for output * * In the case where TImage stands for an otb::Image while TInternalImage stands for otb::VectorImage, the * TExtractSelection must be of type MultiToMonoChannelExtractROI. * * GenerateData and TestBandSelection methods are specialised. * * \see ImageSeriesFileReader * * \ingroup OTBImageIO */ template class ITK_EXPORT ImageSeriesFileReader, VectorImage > : public ImageSeriesFileReaderBase, VectorImage > { public: /** Standard typedefs */ typedef ImageSeriesFileReader Self; typedef ImageSeriesFileReaderBase, VectorImage > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(ImageSeriesFileReader, ImageSeriesFileReaderBase); typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RegionType RegionType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImageListPointerType OutputImageListPointerType; typedef typename Superclass::OutputImageListConstPointerType OutputImageListConstPointerType; typedef typename Superclass::InternalImageType InternalImageType; typedef typename Superclass::InternalImagePointerType InternalImagePointerType; typedef typename Superclass::InternalPixelType InternalPixelType; typedef typename Superclass::InternalValueType InternalValueType; typedef typename Superclass::InternalIndexType InternalIndexType; typedef typename Superclass::InternalSizeType InternalSizeType; typedef typename Superclass::InternalRegionType InternalRegionType; typedef typename Superclass::ReaderType ReaderType; typedef typename Superclass::ReaderType ReaderPointerType; typedef typename Superclass::ReaderListType ReaderListType; typedef typename Superclass::ReaderListPointerType ReaderListPointerType; /** This is a specific template definition of the ROI extraction procedure. * MultiToMonoChannelExtractROI since TImage is an Image and TInteranalImage is a VectorImage */ typedef MultiToMonoChannelExtractROI ExtractSelectionType; typedef typename ExtractSelectionType::Pointer ExtractSelectionPointerType; typedef ObjectList ExtractSelectionListType; typedef typename ExtractSelectionListType::Pointer ExtractSelectionListPointerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; protected: ImageSeriesFileReader(); virtual ~ImageSeriesFileReader () {} /** * Tests the coherency of the Meta File (especifically band selection) with the image types */ virtual void TestBandSelection(std::vector& bands); /** GenerateData * This method will be specialised if template definitions follow: * - TImage is a VectorImage * - TImage is an Image and TInteranalImage is a VectorImage * - TImage and TInternalImage are of Image type. */ virtual void GenerateData(DataObjectPointerArraySizeType idx); using Superclass::GenerateData; /** * Once MetaFile is read, allocation of lists are performed in SetFileName. * This allows specific (or global) initialization in the GenerateData methods, * that the user may invoke through GenerateOutput() or GenerateOutput( idx ). */ virtual void AllocateListOfComponents(void); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const { return Superclass::PrintSelf(os, indent); } /** * Type of extractor to use */ ExtractSelectionListPointerType m_ExtractorList; private: ImageSeriesFileReader (const Self &); void operator =(const Self&); }; // end of class specialized for Image and VectorImage /** \class ImageSeriesFileReader * \brief Specific definition for VectorImage in reading and output * * In the case where TImage stands for an otb::VectorImage as well as TInternalImage, the * TExtractSelection must be of type MultiChannelExtractROI. * * GenerateData method is specialised. * * \see ImageSeriesFileReader * * \ingroup OTBImageIO */ template class ITK_EXPORT ImageSeriesFileReader, VectorImage > : public ImageSeriesFileReaderBase, VectorImage > { public: /** Standard typedefs */ typedef ImageSeriesFileReader Self; typedef ImageSeriesFileReaderBase, VectorImage > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(ImageSeriesFileReader, ImageSeriesFileReaderBase); typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::RegionType RegionType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImageListPointerType OutputImageListPointerType; typedef typename Superclass::OutputImageListConstPointerType OutputImageListConstPointerType; typedef typename Superclass::InternalImageType InternalImageType; typedef typename Superclass::InternalImagePointerType InternalImagePointerType; typedef typename Superclass::InternalPixelType InternalPixelType; typedef typename Superclass::InternalValueType InternalValueType; typedef typename Superclass::InternalIndexType InternalIndexType; typedef typename Superclass::InternalSizeType InternalSizeType; typedef typename Superclass::InternalRegionType InternalRegionType; typedef typename Superclass::ReaderType ReaderType; typedef typename Superclass::ReaderType ReaderPointerType; typedef typename Superclass::ReaderListType ReaderListType; typedef typename Superclass::ReaderListPointerType ReaderListPointerType; /** This is a specific template definition of the ROI extraction procedure. * Here, it will be specialised with: * MultiChannelExtractROI if TImage is a VectorImage */ typedef MultiChannelExtractROI ExtractSelectionType; typedef typename ExtractSelectionType::Pointer ExtractSelectionPointerType; typedef ObjectList ExtractSelectionListType; typedef typename ExtractSelectionListType::Pointer ExtractSelectionListPointerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; protected: ImageSeriesFileReader(); ~ImageSeriesFileReader () ITK_OVERRIDE {} /** * Tests the coherency of the Meta File (especifically band selection) with the image types */ void TestBandSelection(std::vector& itkNotUsed(bands)) ITK_OVERRIDE{} /** GenerateData * This method will be specialised if template definitions follow: * - TImage is a VectorImage * - TImage is an Image and TInteranalImage is a VectorImage * - TImage and TInternalImage are of Image type. */ void GenerateData(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::GenerateData; /** * Once MetaFile is read, allocation of lists are performed in SetFileName. * This allows specific (or global) initialization in the GenerateData methods, * that the user may invoke through GenerateOutput() or GenerateOutput( idx ). */ void AllocateListOfComponents(void) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { return Superclass::PrintSelf(os, indent); } /** * Type of extractor to use */ ExtractSelectionListPointerType m_ExtractorList; private: ImageSeriesFileReader (const Self &); void operator =(const Self&); }; // end of class specialized for VectorImage } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageSeriesFileReader.txx" #endif #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbImageSeriesFileReader.txx000066400000000000000000000223171301006202600256310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSeriesFileReader_txx #define otbImageSeriesFileReader_txx #include "otbImageSeriesFileReader.h" namespace otb { template ImageSeriesFileReader ::ImageSeriesFileReader () { m_ExtractorList = ExtractSelectionListType::New(); } template void ImageSeriesFileReader ::AllocateListOfComponents() { for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { this->m_ImageFileReaderList->PushBack(ReaderType::New()); this->m_OutputList->PushBack(OutputImageType::New()); m_ExtractorList->PushBack(ExtractSelectionListType::New()); } } template void ImageSeriesFileReader ::GenerateData(DataObjectPointerArraySizeType itkNotUsed(idx)) { std::ostringstream msg; msg << "Something wrong... Check the template definition of this class in the program...\n"; msg << "\"ENVI META FILE\" FileName: " << this->m_FileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; } /* ********************************************************** * Methods that are specific to instantiation with Image type * ********************************************************** */ template ImageSeriesFileReader, Image > ::ImageSeriesFileReader () { m_ExtractorList = ExtractSelectionListType::New(); } /** * Allocation of the component... Here, based on ExtractROI */ template void ImageSeriesFileReader, Image > ::AllocateListOfComponents() { for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { this->m_ImageFileReaderList->PushBack(ReaderType::New()); this->m_OutputList->PushBack(OutputImageType::New()); m_ExtractorList->PushBack(ExtractSelectionType::New()); } } /** * TestBandSelection tests if the templated Image type is compatible * with the bande selection provided in the Meta File */ template void ImageSeriesFileReader, Image > ::TestBandSelection(std::vector& bands) { if (bands.size() != 1) { std::ostringstream msg; msg << "Unable to handle multicomponent file from Image<> class\n"; msg << "\"ENVI META FILE\" FileName: " << this->m_FileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; } if (bands[0] != 1) { std::ostringstream msg; msg << "Unable to handle given band reading from multicomponent file with Image<> class\n"; msg << "\"ENVI META FILE\" FileName: " << this->m_FileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; } return; } /** * GenerateData for Image type */ template void ImageSeriesFileReader, Image > ::GenerateData(DataObjectPointerArraySizeType idx) { otbMsgDebugMacro(<< "Reading " << idx << "th image: " << this->m_ListOfFileNames[idx]); ReaderType * reader = static_cast(this->m_ImageFileReaderList->GetNthElement(idx)); reader->SetFileName(this->m_ListOfFileNames[idx]); ExtractSelectionType * selection = static_cast(m_ExtractorList->GetNthElement(idx)); selection->SetExtractionRegion(this->m_ListOfRegionSelection[idx]); selection->SetInput(reader->GetOutput()); selection->GraftOutput(this->m_OutputList->GetNthElement(idx)); selection->Update(); this->m_OutputList->GetNthElement(idx)->Graft(selection->GetOutput()); } /* ********************************************************************* * Methods that are specific to instantiation with Image type for TImage * and VectorImage as TInternalImage * ********************************************************************* */ /** * Constructor */ template ImageSeriesFileReader, VectorImage > ::ImageSeriesFileReader () { //this->m_OutputList = OutputImageListType::New(); //this->m_ImageFileReaderList = ReaderListType::New(); m_ExtractorList = ExtractSelectionListType::New(); } /** * Allocation of the component... Here, based on MultiToMonoChannelExtractROI */ template void ImageSeriesFileReader, VectorImage > ::AllocateListOfComponents() { for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { this->m_ImageFileReaderList->PushBack(ReaderType::New()); this->m_OutputList->PushBack(OutputImageType::New()); m_ExtractorList->PushBack(ExtractSelectionType::New()); } } /** * TestBandSelection tests if the templated Image type is compatible * with the bande selection provided in the Meta File */ template void ImageSeriesFileReader, VectorImage > ::TestBandSelection(std::vector& bands) { if (bands.size() != 1) { std::ostringstream msg; msg << "Unable to handle multicomponent file from Image<> class as output\n"; msg << "\"ENVI META FILE\" FileName: " << this->m_FileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; } return; } /** * GenerateData for Image type as output and VectorImage type for reading */ template void ImageSeriesFileReader, VectorImage > ::GenerateData(DataObjectPointerArraySizeType idx) { otbMsgDebugMacro(<< "Reading " << idx << "th image: " << this->m_ListOfFileNames[idx]); ReaderType * reader = static_cast(this->m_ImageFileReaderList->GetNthElement(idx)); reader->SetFileName(this->m_ListOfFileNames[idx]); ExtractSelectionType * selection = static_cast(this->m_ExtractorList->GetNthElement(idx)); selection->SetExtractionRegion(this->m_ListOfRegionSelection[idx]); selection->SetChannel(this->m_ListOfBandSelection[idx][0]); selection->SetInput(reader->GetOutput()); selection->GraftOutput(this->m_OutputList->GetNthElement(idx)); selection->Update(); this->m_OutputList->GetNthElement(idx)->Graft(selection->GetOutput()); } /* ****************************************************************** * Methods that are specific to instantiation with VectorImage types * ****************************************************************** */ /** * Constructor */ template ImageSeriesFileReader, VectorImage > ::ImageSeriesFileReader () { //this->m_OutputList = OutputImageListType::New(); //this->m_ImageFileReaderList = ReaderListType::New(); m_ExtractorList = ExtractSelectionListType::New(); } /** * Allocation of the component... Here, based on MultiChannelExtractROI */ template void ImageSeriesFileReader, VectorImage > ::AllocateListOfComponents() { for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i) { this->m_ImageFileReaderList->PushBack(ReaderType::New()); this->m_OutputList->PushBack(OutputImageType::New()); m_ExtractorList->PushBack(ExtractSelectionType::New()); } } /** * GenerateData specialised for VectorImages */ template void ImageSeriesFileReader, VectorImage > ::GenerateData(DataObjectPointerArraySizeType idx) { otbMsgDebugMacro(<< "Reading " << idx << "th image: " << this->m_ListOfFileNames[idx]); ReaderType * reader = static_cast(this->m_ImageFileReaderList->GetNthElement(idx)); reader->SetFileName(this->m_ListOfFileNames[idx]); ExtractSelectionType * selection = static_cast(this->m_ExtractorList->GetNthElement(idx)); selection->SetExtractionRegion(this->m_ListOfRegionSelection[idx]); for (std::vector::iterator band = this->m_ListOfBandSelection[idx].begin(); band != this->m_ListOfBandSelection[idx].end(); ++band) { selection->SetChannel(*band); } selection->SetInput(reader->GetOutput()); selection->GraftOutput(this->m_OutputList->GetNthElement(idx)); selection->Update(); this->m_OutputList->GetNthElement(idx)->Graft(selection->GetOutput()); } } // end of namespace otb #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbImageSeriesFileReaderBase.h000066400000000000000000000155431301006202600260330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSeriesFileReaderBase_h #define otbImageSeriesFileReaderBase_h #include #include #include #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageListSource.h" #include "otbImageFileReader.h" namespace otb { class ImageSeriesFileReaderException : public itk::ExceptionObject { public: itkTypeMacro(ImageSeriesFileReaderException, ExceptionObject); ImageSeriesFileReaderException(const char *file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : itk::ExceptionObject(file, line, message, loc) {} ImageSeriesFileReaderException(const std::string& file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : itk::ExceptionObject(file, line, message, loc) {} }; /** \class ImageSeriesFileReaderBase * \brief * \sa ImageSeriesFileReader * * \ingroup OTBImageIO */ template class ITK_EXPORT ImageSeriesFileReaderBase : public ImageListSource { public: /** Standard typedefs */ typedef ImageSeriesFileReaderBase Self; typedef ImageListSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(ImageSeriesFileReaderBase, ImageListSource); typedef TImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::InternalPixelType PixelType; typedef typename OutputImageType::ValueType ValueType; typedef typename OutputImageType::IndexType IndexType; typedef typename OutputImageType::SizeType SizeType; typedef typename OutputImageType::RegionType RegionType; typedef ImageList OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::ConstPointer OutputImageListConstPointerType; typedef TInternalImage InternalImageType; typedef typename InternalImageType::Pointer InternalImagePointerType; typedef typename InternalImageType::InternalPixelType InternalPixelType; typedef typename InternalImageType::ValueType InternalValueType; typedef typename InternalImageType::IndexType InternalIndexType; typedef typename InternalImageType::SizeType InternalSizeType; typedef typename InternalImageType::RegionType InternalRegionType; typedef ImageFileReader ReaderType; typedef typename ReaderType::Pointer ReaderPointerType; typedef ObjectList ReaderListType; typedef typename ReaderListType::Pointer ReaderListPointerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Get the file to be read */ itkGetStringMacro(FileName); /** * Set the file to be read. Once the Filename is set, ReadMeatFile is called in order to get * the number of image files to be read, the images file names, the band and region * selection */ virtual void SetFileName(const std::string& file); virtual void SetFileName(const char * file); /** get the Filenames */ std::string GetFileName(unsigned int i) const { return this->m_ListOfFileNames.at(i); } /** Get the readers */ itkGetObjectMacro(ImageFileReaderList, ReaderListType); ReaderType * GetImageFileReader(unsigned int i) const { return this->m_ImageFileReaderList->GetNthElement(i); } /** Get the output list */ virtual unsigned int GetNumberOfOutputs() const { return m_ListOfFileNames.size(); } OutputImageListType * GetOutput(void) ITK_OVERRIDE; virtual OutputImageType * GetOutput(DataObjectPointerArraySizeType idx); /** Performs selective file extraction */ virtual OutputImageListType * GenerateOutput(void); virtual OutputImageType * GenerateOutput(DataObjectPointerArraySizeType idx); /** Synchronization */ void Update() ITK_OVERRIDE { this->GenerateData(); } protected: ImageSeriesFileReaderBase(); ~ImageSeriesFileReaderBase () ITK_OVERRIDE {} enum FileType { kFileName = 0, kImageFileName, kAnyFileName }; /** * Test files. * If the filename to test is an imageFileName, the file name may be modified in * order to add the appropriated path */ virtual void TestFileExistenceAndReadability(std::string& file, FileType fileType); virtual void TestBandSelection(std::vector& itkNotUsed(bands)) {} void GenerateData(void) ITK_OVERRIDE; /** GenerateData * This method will be specialised if template definitions follow: * - TImage is a VectorImage * - TImage is an Image and TInteranalImage is a VectorImage * - TImage and TInternalImage are of Image type. */ virtual void GenerateData(DataObjectPointerArraySizeType idx); /** * Read the MetaFile and test its effectiveness once inputFileName is set. */ virtual void ReadMetaFile(); /** * Once MetaFile is read, allocation of lists are performed in SetFileName. * This allows specific (or global) initialization in the GenerateData methods, * that the user may invoke through GenerateOutput() or GenerateOutput( idx ). */ virtual void AllocateListOfComponents(void); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; std::string m_FileName; OutputImageListPointerType m_OutputList; std::vector m_ListOfFileNames; std::vector > m_ListOfBandSelection; std::vector m_ListOfRegionSelection; ReaderListPointerType m_ImageFileReaderList; private: ImageSeriesFileReaderBase (const Self &); void operator =(const Self&); }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageSeriesFileReaderBase.txx" #endif #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbImageSeriesFileReaderBase.txx000066400000000000000000000324121301006202600264210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSeriesFileReaderBase_txx #define otbImageSeriesFileReaderBase_txx #include "otbImageSeriesFileReaderBase.h" namespace otb { template ImageSeriesFileReaderBase ::ImageSeriesFileReaderBase () { m_OutputList = OutputImageListType::New(); m_ImageFileReaderList = ReaderListType::New(); m_FileName = ""; m_ListOfFileNames.clear(); m_ListOfBandSelection.clear(); m_ListOfRegionSelection.clear(); } template void ImageSeriesFileReaderBase ::SetFileName(const std::string& file) { return SetFileName(file.c_str()); } template void ImageSeriesFileReaderBase ::SetFileName(const char * file) { if (file && (file == m_FileName)) return; if (file) { this->m_FileName = file; ReadMetaFile(); AllocateListOfComponents(); } else this->m_FileName = ""; this->Modified(); } template typename ImageSeriesFileReaderBase::OutputImageListType * ImageSeriesFileReaderBase ::GetOutput() { if (this->GetNumberOfOutputs() < 1) throw ImageSeriesFileReaderException(__FILE__, __LINE__, "No data to output", ITK_LOCATION); return static_cast(this->m_OutputList); } template typename ImageSeriesFileReaderBase::OutputImageType * ImageSeriesFileReaderBase ::GetOutput(DataObjectPointerArraySizeType idx) { if (this->GetNumberOfOutputs() < 1) throw ImageSeriesFileReaderException(__FILE__, __LINE__, "No data to output", ITK_LOCATION); if (idx >= m_OutputList->Size()) throw ImageSeriesFileReaderException(__FILE__, __LINE__, "Index out of bounds", ITK_LOCATION); return static_cast(this->m_OutputList->GetNthElement(idx)); } template void ImageSeriesFileReaderBase ::ReadMetaFile() { m_ListOfFileNames.clear(); m_ListOfBandSelection.clear(); m_ListOfRegionSelection.clear(); this->TestFileExistenceAndReadability(m_FileName, kFileName); std::string aLine; std::ifstream inputFile(m_FileName.c_str(), std::ios_base::in); inputFile >> aLine; if (aLine != "ENVI") { inputFile.close(); std::ostringstream msg; msg << "The file " << m_FileName << " is not a \"ENVI META FILE\" format\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } inputFile >> aLine; if (aLine != "META") { inputFile.close(); std::ostringstream msg; msg << "The file " << m_FileName << " is not a \"ENVI META FILE\" format\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } inputFile >> aLine; if (aLine != "FILE") { inputFile.close(); std::ostringstream msg; msg << "The file " << m_FileName << " is not a \"ENVI META FILE\" format\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } while (1) { /* * Reading the filenames */ do { inputFile >> aLine; //std::cerr << "-> '" << aLine << "'\n"; } while (aLine != "File" && inputFile.good()); if (inputFile.good()) { do { inputFile >> aLine; //std::cerr << "--> '" << aLine << "'\n"; } while (aLine != ":" && inputFile.good()); if (!inputFile.good()) { inputFile.close(); std::ostringstream msg; msg << "Unable to read image files in the \"ENVI META FILE\" file \n"; msg << "FileName: " << m_FileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } } else return; // normal exit inputFile >> aLine; std::cerr << "-> " << aLine << "\n"; // Get the Image fileName // The test may modify image file name to add the path // Or throw an exception when not found nor readable TestFileExistenceAndReadability(aLine, kImageFileName); m_ListOfFileNames.push_back(aLine); std::string imageFileName = aLine; /* * Reading the Band number */ do { inputFile >> aLine; //std::cerr << "-> '" << aLine << "'\n"; } while (aLine != "Bands:" && inputFile.good()); if (!inputFile.good()) { inputFile.close(); std::ostringstream msg; msg << "Unable to read the number of bands in the images in the \"ENVI META FILE\" file \n"; msg << "FileName: " << m_FileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } std::vector bands; int aBand, oldBand = -1; char sep; while (1) { inputFile >> aBand; if (oldBand != -1) { for (int i = oldBand; i <= aBand; ++i) bands.push_back(i); oldBand = -1; } else bands.push_back(aBand); int posRef = inputFile.tellg(); inputFile >> sep; if (sep == '-') { oldBand = aBand + 1; } else if (sep != ',') { inputFile.seekg(posRef, std::ios_base::beg); break; } } // Storing band selection try { TestBandSelection(bands); } catch (ImageSeriesFileReaderException & e) { std::ostringstream msg; msg << e.GetDescription(); msg << "Image FileName : " << imageFileName << "\n"; e.SetDescription(msg.str().c_str()); throw e; } m_ListOfBandSelection.push_back(bands); /* * Reading the Region selection */ do { inputFile >> aLine; //std::cerr << "-> '" << aLine << "'\n"; } while (aLine != "Dims" && inputFile.good()); if (inputFile.good()) { do { inputFile >> aLine; //std::cerr << "--> '" << aLine << "'\n"; } while (aLine != ":" && inputFile.good()); if (!inputFile.good()) { inputFile.close(); std::ostringstream msg; msg << "Unable to read image region in the \"ENVI META FILE\" file \n"; msg << "FileName : " << m_FileName << "\n"; msg << "ImageName: " << imageFileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } } int beg_line, end_line, beg_col, end_col; char sep1, sep2, sep3; inputFile >> beg_col >> sep1 >> end_col >> sep2 >> beg_line >> sep3 >> end_line; if (!inputFile.good()) { inputFile.close(); std::ostringstream msg; msg << "Unable to read image region selection in the \"ENVI META FILE\" file \n"; msg << "FileName : " << m_FileName << "\n"; msg << "ImageName: " << imageFileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } IndexType index; index[0] = beg_col - 1; index[1] = beg_line - 1; SizeType size; size[0] = end_col - beg_col + 1; size[1] = end_line - beg_line + 1; RegionType region; region.SetSize(size); region.SetIndex(index); m_ListOfRegionSelection.push_back(region); } } template void ImageSeriesFileReaderBase ::AllocateListOfComponents() { for (unsigned int i = 0; i < GetNumberOfOutputs(); ++i) { m_ImageFileReaderList->PushBack(ReaderType::New()); m_OutputList->PushBack(OutputImageType::New()); } } /** * GenerateData */ template void ImageSeriesFileReaderBase ::GenerateData(DataObjectPointerArraySizeType itkNotUsed(idx)) { std::ostringstream msg; msg << "Something wrong... Check the template definition of this class in the program...\n"; msg << "\"ENVI META FILE\" FileName: " << m_FileName << "\n"; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; } template void ImageSeriesFileReaderBase ::GenerateData() { for (unsigned int i = 0; i < GetNumberOfOutputs(); ++i) GenerateData(i); } /** * GenerateOutput */ template typename ImageSeriesFileReaderBase::OutputImageListType * ImageSeriesFileReaderBase ::GenerateOutput() { this->Update(); return this->GetOutput(); } template typename ImageSeriesFileReaderBase::OutputImageType * ImageSeriesFileReaderBase ::GenerateOutput(DataObjectPointerArraySizeType idx) { this->GenerateData(idx); return this->GetOutput(idx); } template void ImageSeriesFileReaderBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "File to be read : " << m_FileName << "\n"; if (m_ListOfFileNames.size() > 0) { std::vector >::const_iterator bandSelection = m_ListOfBandSelection.begin(); os << indent << "Image File(s) to be read\n"; for (unsigned int i = 0; i < GetNumberOfOutputs(); ++i) { os << indent << " " << "Filename : " << m_ListOfFileNames[i] << "\n"; os << indent << " " << "RegionSelection: Index( " << m_ListOfRegionSelection[i].GetIndex()[0] << ", " << m_ListOfRegionSelection[i].GetIndex()[1] << ") Size( " << m_ListOfRegionSelection[i].GetSize()[0] << ", " << m_ListOfRegionSelection[i].GetSize()[1] << ")\n"; os << indent << " " << "BandSelection : "; for (std::vector::const_iterator bd = (*bandSelection).begin(); bd != (*bandSelection).end(); ++bd) { os << *bd << " "; } os << "\n"; ++bandSelection; } } } template void ImageSeriesFileReaderBase ::TestFileExistenceAndReadability(std::string& file, FileType fileType) { // Test if the file exists. if (!itksys::SystemTools::FileExists(file.c_str())) { if (fileType != kImageFileName) { ImageSeriesFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << "The file doesn't exist. \n"; if (fileType == kFileName) msg << "Filename = " << file << "\n"; else msg << "File = " << file << "\n"; e.SetDescription(msg.str().c_str()); throw e; return; } else { std::vector fullPath; fullPath.push_back(itksys::SystemTools::GetFilenamePath(m_FileName)); fullPath.push_back("/"); fullPath.push_back(file); std::string fullFileName = itksys::SystemTools::JoinPath(fullPath); if (!itksys::SystemTools::FileExists(fullFileName.c_str())) { ImageSeriesFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << "The image file doesn't exist. \n"; msg << "ImageFileName = " << file << "\n"; msg << "tested path = " << itksys::SystemTools::GetFilenamePath(m_FileName) << "\n"; msg << "Other Tested File = " << fullFileName << "\n"; e.SetDescription(msg.str().c_str()); throw e; return; } else { // At this step, image file name is modified to add its path file = fullFileName; } } } // Test if the file can be open for reading access. std::ifstream readTester; readTester.open(file.c_str()); if (readTester.fail()) { readTester.close(); std::ostringstream msg; msg << "The file couldn't be opened for reading. " << std::endl << "Filename: " << file << std::endl; ImageSeriesFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } readTester.close(); } } // end of namespace otb #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbScalarBufferToImageFileWriter.h000066400000000000000000000071241301006202600267160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarBufferToImageFileWriter_h #define otbScalarBufferToImageFileWriter_h #include "otbVectorImage.h" #include "otbImageFileWriter.h" namespace otb { /** \class ScalarBufferToImageFileWriter * * \brief Record an image stored in a buffer. * * TBufferType is the scalar buffer type, TOutputPixelType is the type in which the image will be recorded. * User have to precise the image size, the number of channel will be computed automatically. * The SetFilename method precises the image name. * * \ingroup OTBImageIO */ template class ITK_EXPORT ScalarBufferToImageFileWriter : public itk::ProcessObject { public: typedef ScalarBufferToImageFileWriter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ScalarBufferToImageFileWriter, itk::ProcessObject); /** INput typedefs */ typedef TBufferType BufferType; typedef TOutputPixelType OutputPixelType; /** Output image type */ typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; /** Writer Type*/ typedef otb::ImageFileWriter WriterType; typedef typename WriterType::Pointer WriterPointer; /** Filename accessor */ otbGetObjectMemberMacro(Writer, FileName, std::string); otbSetObjectMemberMacro(Writer, FileName, std::string); /** Size accessors */ itkGetMacro(ImageSize, SizeType); itkSetMacro(ImageSize, SizeType); /** Number of channels */ itkGetMacro(NumberOfChannels, unsigned int); itkSetMacro(NumberOfChannels, unsigned int); /** Inverse X spacing accessors. */ itkGetMacro(InverseXSpacing, bool); itkSetMacro(InverseXSpacing, bool); /** Buffer accessors */ void SetBuffer( BufferType * pBuff ) { m_Buffer = pBuff; } void GenerateData() ITK_OVERRIDE; void Update() ITK_OVERRIDE { this->GenerateData(); } protected: ScalarBufferToImageFileWriter(); ~ScalarBufferToImageFileWriter() ITK_OVERRIDE { /* don't call ClearBuffer, user's care */} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ScalarBufferToImageFileWriter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Writer */ WriterPointer m_Writer; /** Scalar tab buffer to writer */ BufferType * m_Buffer; /**Output image number of channels */ unsigned int m_NumberOfChannels; /** Output image size */ SizeType m_ImageSize; /** Inverse biffer among X */ bool m_InverseXSpacing; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbScalarBufferToImageFileWriter.txx" #endif #endif OTB-release-5.8/Modules/IO/ImageIO/include/otbScalarBufferToImageFileWriter.txx000066400000000000000000000067421301006202600273170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbScalarBufferToImageFileWriter_txx #define otbScalarBufferToImageFileWriter_txx #include "otbMacro.h" #include "otbScalarBufferToImageFileWriter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionIteratorWithIndex.h" namespace otb { template ScalarBufferToImageFileWriter ::ScalarBufferToImageFileWriter() : m_Buffer(ITK_NULLPTR), m_NumberOfChannels(0), m_InverseXSpacing(false) { m_Writer = WriterType::New(); m_ImageSize.Fill(0); } template void ScalarBufferToImageFileWriter::GenerateData() { // Check image parameters if( (m_ImageSize[0]==0) || (m_ImageSize[0]==0) ) { itkExceptionMacro("Invalid output image size, Size can't be null."); } if( m_NumberOfChannels==0 ) { itkExceptionMacro("Invalid output image number of channels."); } RegionType lRegion; IndexType lId; lId.Fill(0); lRegion.SetIndex(lId); lRegion.SetSize(m_ImageSize); typename ImageType::Pointer lImage = ImageType::New(); lImage->SetRegions( lRegion ); lImage->SetNumberOfComponentsPerPixel(m_NumberOfChannels); lImage->Allocate(); PixelType lPix; lPix.SetSize(m_NumberOfChannels); lPix.Fill( itk::NumericTraits::Zero ); lImage->FillBuffer(lPix); // 1 specific loop for each case to save time processing if(m_InverseXSpacing == false) { itk::ImageRegionIterator it(lImage, lRegion); it.GoToBegin(); unsigned int cpt(0); while( it.IsAtEnd()==false ) { for(unsigned int i=0; i(m_Buffer[cpt]); ++cpt; } it.Set( lPix ); ++it; } } else { itk::ImageRegionIteratorWithIndex it(lImage, lRegion); it.GoToBegin(); // cpt is the first component of the last pixel unsigned int cpt(0); while( it.IsAtEnd()==false ) { IndexType index = it.GetIndex(); cpt = (m_ImageSize[1] - 1 - index[1]) * m_NumberOfChannels * m_ImageSize[0] + m_NumberOfChannels * index[0]; for(unsigned int i=0; i(m_Buffer[cpt+i]); } it.Set( lPix ); ++it; } } m_Writer->SetInput( lImage ); m_Writer->Update(); } template void ScalarBufferToImageFileWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "FileName" << m_Writer->GetFileName() << std::endl; os << indent << "Size" << m_ImageSize << std::endl; os << indent << "NumberOfChannels" << m_NumberOfChannels << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/IO/ImageIO/otb-module.cmake000066400000000000000000000010251301006202600216560ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes related to the reading and the writing of remote sensing images.") otb_module(OTBImageIO DEPENDS OTBBoostAdapters OTBCommon OTBExtendedFilename OTBIOBSQ OTBIOGDAL OTBIOLUM OTBIOMSTAR OTBIOMW OTBIOONERA OTBIORAD OTBIOTileMap OTBITK OTBImageBase OTBOSSIMAdapters OTBObjectList OTBStreaming OPTIONAL_DEPENDS OTBIOJPEG2000 TEST_DEPENDS OTBStatistics OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/ImageIO/src/000077500000000000000000000000001301006202600173765ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ImageIO/src/CMakeLists.txt000066400000000000000000000010611301006202600221340ustar00rootroot00000000000000set(OTBImageIO_SRC otbImageIOFactory.cxx ) add_library(OTBImageIO ${OTBImageIO_SRC}) target_link_libraries(OTBImageIO ${OTBIORAD_LIBRARIES} ${OTBIOONERA_LIBRARIES} ${OTBIOJPEG2000_LIBRARIES} ${OTBIOLUM_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBIOMW_LIBRARIES} ${OTBIOMSTAR_LIBRARIES} ${OTBIOBSQ_LIBRARIES} ${OTBIOGDAL_LIBRARIES} ${OTBStreaming_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBIOTileMap_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBExtendedFilename_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ) otb_module_target(OTBImageIO) OTB-release-5.8/Modules/IO/ImageIO/src/otbImageIOFactory.cxx000066400000000000000000000063151301006202600234360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMutexLock.h" #include "itkMutexLockHolder.h" #include "otbImageIOFactory.h" #include "otbConfigure.h" #include "otbONERAImageIOFactory.h" #include "otbMSTARImageIOFactory.h" #include "otbGDALImageIOFactory.h" #include "otbLUMImageIOFactory.h" #include "otbBSQImageIOFactory.h" #include "otbRADImageIOFactory.h" #include "otbMWImageIOFactory.h" #ifdef OTB_USE_OPENJPEG #include "otbJPEG2000ImageIOFactory.h" #endif #include "otbTileMapImageIOFactory.h" namespace otb { otb::ImageIOBase::Pointer ImageIOFactory::CreateImageIO(const char* path, FileModeType mode) { RegisterBuiltInFactories(); std::list possibleImageIO; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("otbImageIOBase"); for(std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { otb::ImageIOBase* io = dynamic_cast(i->GetPointer()); if(io) { possibleImageIO.push_back(io); } else { std::cerr << "Error ImageIO factory did not return an ImageIOBase: " << (*i)->GetNameOfClass() << std::endl; } } for(std::list::iterator k = possibleImageIO.begin(); k != possibleImageIO.end(); ++k) { if( mode == ReadMode ) { if((*k)->CanReadFile(path)) { return *k; } } else if( mode == WriteMode ) { if((*k)->CanWriteFile(path)) { return *k; } } } return ITK_NULLPTR; } void ImageIOFactory::RegisterBuiltInFactories() { static bool firstTime = true; static itk::SimpleMutexLock mutex; { // This helper class makes sure the Mutex is unlocked // in the event an exception is thrown. itk::MutexLockHolder mutexHolder(mutex); if (firstTime) { itk::ObjectFactoryBase::RegisterFactory(RADImageIOFactory::New()); itk::ObjectFactoryBase::RegisterFactory(BSQImageIOFactory::New()); itk::ObjectFactoryBase::RegisterFactory(LUMImageIOFactory::New()); #ifdef OTB_USE_OPENJPEG itk::ObjectFactoryBase::RegisterFactory(JPEG2000ImageIOFactory::New()); #endif itk::ObjectFactoryBase::RegisterFactory(TileMapImageIOFactory::New()); itk::ObjectFactoryBase::RegisterFactory(GDALImageIOFactory::New()); itk::ObjectFactoryBase::RegisterFactory(MWImageIOFactory::New()); itk::ObjectFactoryBase::RegisterFactory(ONERAImageIOFactory::New()); itk::ObjectFactoryBase::RegisterFactory(MSTARImageIOFactory::New()); firstTime = false; } } } } // end namespace otb OTB-release-5.8/Modules/IO/ImageIO/test/000077500000000000000000000000001301006202600175665ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ImageIO/test/0000437-WriteImageCentOS.cxx000066400000000000000000000032551301006202600242430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkCastImageFilter.h" /** * This test reproduces a problem encountered with CentOS5.5 using 3.8.2 libTIFF version * Issue number 0000437 */ int main(int argc, char* argv[]) { if (argc != 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::CastImageFilter CastFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->Update(); CastFilterType::Pointer caster = CastFilterType::New(); caster->SetInput( reader->GetOutput() ); caster->InPlaceOn(); WriterType::Pointer writer = WriterType::New(); writer->SetInput(caster->GetOutput()); writer->SetFileName(argv[2]); //writer->SetAutomaticTiledStreaming(1024); writer->SetTileDimensionTiledStreaming(256); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/0000479-WriteInt8Image.cxx000066400000000000000000000046551301006202600237450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbImage.h" #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "itkImageRegionIterator.h" int main(int itkNotUsed(argc), char* argv[]) { typedef char PixelType; const char * out = argv[1]; const PixelType value = static_cast(atof(argv[2] )); typedef otb::Image ImageType; typedef otb::ImageFileWriter WriterType; typedef itk::ImageRegionIterator IterType; ImageType::IndexType id; ImageType::SizeType size; ImageType::RegionType region; id.Fill(0); size.Fill(10); region.SetSize( size ); region.SetIndex( id ); ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->Allocate(); image->FillBuffer(value); IterType it1( image, region ); it1.GoToBegin(); it1.GoToBegin(); while( !it1.IsAtEnd() ) { if( value != it1.Get() ) { std::cout<<"Allocated image pixel value "<SetInput(image); writer->SetFileName(out); writer->Update(); typedef otb::Image ReaderImageType; typedef otb::ImageFileReader ReaderType; typedef itk::ImageRegionIterator ReaderIterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(out); reader->Update(); ReaderIterType it2( reader->GetOutput(), region ); it2.GoToBegin(); while( !it2.IsAtEnd() ) { if( value != it2.Get() ) { std::cout<<"Read image pixel value "< " << std::endl; return EXIT_FAILURE; } typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::CastImageFilter CastFilterType; bool hasObserver = false; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); CastFilterType::Pointer cast = CastFilterType::New(); cast->SetInput(reader->GetOutput()); hasObserver = cast->HasObserver( itk::ProgressEvent() ); std::cout << "Before Scope : hasObserver = " << (hasObserver ? "true" : "false") << std::endl; itkAssertOrThrowMacro( hasObserver == false, "No observer should be registered at this point" ); { WriterType::Pointer scopedWriter = WriterType::New(); scopedWriter->SetInput(cast->GetOutput()); scopedWriter->SetFileName(argv[2]); // Ensure that streaming is enabled to have progress reporting scopedWriter->SetNumberOfLinesStrippedStreaming(10); hasObserver = cast->HasObserver( itk::ProgressEvent() ); std::cout << "Before Update : hasObserver = " << (hasObserver ? "true" : "false") << std::endl; itkAssertOrThrowMacro( hasObserver == false, "No observer should be registered at this point" ); // Write the output : this connect the writer to its source filter // for progress reporting scopedWriter->Update(); hasObserver = cast->HasObserver( itk::ProgressEvent() ); std::cout << "After Update : hasObserver = " << (hasObserver ? "true" : "false") << std::endl; itkAssertOrThrowMacro( hasObserver == false, "The previously registered observer should have been unregistered at this point" ); // Get out of scope : this deletes the scopedWriter object } hasObserver = cast->HasObserver( itk::ProgressEvent() ); std::cout << "After Scope : hasObserver = " << (hasObserver ? "true" : "false") << std::endl; itkAssertOrThrowMacro( hasObserver == false, "The previously registered observer should have been unregistered at this point" ); // Make a new writer, just to exercise streaming in the reader WriterType::Pointer writer = WriterType::New(); writer->SetInput(cast->GetOutput()); writer->SetFileName(argv[3]); writer->SetNumberOfLinesStrippedStreaming(10); // Execute the pipeline // The reader object writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/CMakeLists.txt000066400000000000000000001537761301006202600223510ustar00rootroot00000000000000otb_module_test() set(OTBImageIOTests otbImageIOTestDriver.cxx otbImageFileWriterWithExtendedOptionBox.cxx otbImageFileReaderONERAComplex.cxx otbImageFileReaderRADComplexFloat.cxx otbShortRGBImageIOTest.cxx otbPipelineMetadataHandlingWithUFFilterTest.cxx otbImageMetadataFileWriterTest.cxx otbImageFileWriterTestWithoutInput.cxx otbVectorImageStreamingFileWriterTestWithoutInput.cxx otbReadingComplexDataIntoComplexImageTest.cxx otbStreamingImageFileWriterTest.cxx otbImageFileReaderRADInt.cxx otbImageFileReaderRGBTest.cxx otbImageMetadataStreamingFileWriterTest.cxx otbFloatImageIOTest.cxx otbImageFileReaderMSTAR.cxx otbGDALDriverDoubleWritingTest.cxx otbDoubleImageIOTest.cxx otbStreamingImageFileWriterTestCalculateNumberOfDivisions.cxx otbImageFileReaderRADComplexFloatExtract.cxx otbImageFileReaderRADComplexInt.cxx otbImageStreamingFileWriterTestWithoutInput.cxx otbScalarBufferToImageFileWriterTest.cxx otbImageFileWriterONERAComplex.cxx otbPipelineMetadataHandlingTest.cxx otbMultiResolutionReadingInfo.cxx otbImageFileReaderTestFloat.cxx otbComplexImageTests.cxx otbImageFileReaderRADChar.cxx otbScalarBufferToImageFileWriterNew.cxx otbShortImageIOTest.cxx otbImageSeriesFileReader.cxx otbStreamingShortImageFileWriterTest.cxx otbImageFileWriterStreamingONERAComplex.cxx otbImageFileReaderWithComplexPixel.cxx otbImageFileReaderRADFloat.cxx otbVectorImageFileReaderWriterTest.cxx otbIntImageIOTest.cxx otbImageFileReaderONERA.cxx otbImageFileReaderServerName.cxx otbPNGIndexedNbBandsTest.cxx otbImageFileReaderTest.cxx otbVectorImageFileWriterTestWithoutInput.cxx otbWritingComplexDataWithComplexImageTest.cxx otbStreamingImageFileWriterWithFilterTest.cxx otbImageFileReaderRADComplexDouble.cxx otbPipeline.cxx otbStreamingImageFilterTest.cxx otbImageFileWriterRGBTest.cxx otbComplexImageManipulationTest.cxx otbImageFileWriterTest.cxx otbImageIOFactoryNew.cxx otbCompareWritingComplexImage.cxx ) add_executable(otbImageIOTestDriver ${OTBImageIOTests}) target_link_libraries(otbImageIOTestDriver ${OTBImageIO-Test_LIBRARIES}) otb_module_target_label(otbImageIOTestDriver) # Tests Declaration otb_add_test(NAME ioTvImageFileWriterExtendedFileName_Box COMMAND otbImageIOTestDriver otbImageFileWriterWithExtendedOptionBox ${INPUTDATA}/maur_rgb_24bpp.tif ${TEMP}/ioImageFileWriterExtendedFileName_box.tif 2 2 200 200 10 ) otb_add_test(NAME ioTvONERAImageFileReaderComplex COMMAND otbImageIOTestDriver --compare-n-images ${EPSILON_9} 2 ${BASELINE}/ioImageFileReaderONERAComplexReal.hdr ${TEMP}/ioImageFileReaderONERAComplexReal.hdr ${BASELINE}/ioImageFileReaderONERAComplexImag.hdr ${TEMP}/ioImageFileReaderONERAComplexImag.hdr otbImageFileReaderONERAComplex LARGEINPUT{ONERA/spa3_0215_rad.ent} ${TEMP}/ioImageFileReaderONERAComplexReal.hdr ${TEMP}/ioImageFileReaderONERAComplexImag.hdr ) otb_add_test(NAME ioTvImageFileReaderRADCR42TIF COMMAND otbImageIOTestDriver otbImageFileReaderRADComplexFloat ${INPUTDATA}/RADCR4_image.rad ${TEMP}/ioImageFileReaderRAD2TIF.tif ) otb_add_test(NAME ioTvImageFileReaderCI42CR4 COMMAND otbImageIOTestDriver otbImageFileReaderRADComplexFloat ${INPUTDATA}/RADCI4_image.rad ${TEMP}/ioImageFileReaderCI42CR4.rad ) otb_add_test(NAME ioTvImageFileReaderShortRGB_BSQ2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I2.hd ${TEMP}/ioImageFileReaderI2_BSQ2HDR.hdr otbShortRGBImageIOTest ${INPUTDATA}/poupees_I2.hd ${TEMP}/ioImageFileReaderI2_BSQ2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderShortHDR2BSQ COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I2.hd ${TEMP}/ioImageFileReaderI2_HDR2BSQ.hd otbShortRGBImageIOTest ${TEMP}/ioImageFileReaderI2_BSQ2HDR.hdr ${TEMP}/ioImageFileReaderI2_HDR2BSQ.hd ) set_property(TEST ioTvImageFileReaderShortHDR2BSQ PROPERTY DEPENDS ioTvImageFileReaderShortRGB_BSQ2HDR) otb_add_test(NAME ioTvPipelineMetadataHandlingWithUFFilterTest COMMAND otbImageIOTestDriver --compare-metadata ${EPSILON_9} ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvPipelineMetadataHandlingWithUFFilterTest.img otbPipelineMetadataHandlingWithUFFilterTest ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvPipelineMetadataHandlingWithUFFilterTest.img ) otb_add_test(NAME ioTvImageMetadataWriterTest_HFA COMMAND otbImageIOTestDriver --compare-metadata ${EPSILON_9} ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvImageMetadataWriterHFA.img otbImageMetadataFileWriterTest ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvImageMetadataWriterHFA.img ) otb_add_test(NAME ioTvImageMetadataWriterTest_TIF COMMAND otbImageIOTestDriver --compare-metadata ${EPSILON_9} ${INPUTDATA}/spot5SubWithGcps.tif ${TEMP}/ioTvImageMetadataWriterTIF.tif otbImageMetadataFileWriterTest ${INPUTDATA}/spot5SubWithGcps.tif ${TEMP}/ioTvImageMetadataWriterTIF.tif ) otb_add_test(NAME ioTvImageFileReaderRGB_BSQ2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees.hdr ${TEMP}/ioImageFileReaderRGB_BSQ2PNG_poupees.png otbImageFileReaderRGBTest ${INPUTDATA}/poupees.hdr ${TEMP}/ioImageFileReaderRGB_BSQ2PNG_poupees.png ) otb_add_test(NAME ioTvImageFileReaderRGB_Gdal_SPOT5TIF2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderRGB_SPOT5TIF2PNG_poupeesTIF.png ${TEMP}/ioImageFileReaderRGB_Gdal_SPOT5TIF2PNG_poupeesTIF.png otbImageFileReaderRGBTest ${INPUTDATA}/poupeesTIF/IMAGERY.TIF ${TEMP}/ioImageFileReaderRGB_Gdal_SPOT5TIF2PNG_poupeesTIF.png ) otb_add_test(NAME ioTvImageReaderWriterRgbPNG2ENVI COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees.png ${TEMP}/ioImageReaderWriterRgbPNG2ENVI_poupees otbImageFileReaderRGBTest ${INPUTDATA}/poupees.png ${TEMP}/ioImageReaderWriterRgbPNG2ENVI_poupees.hdr ) otb_add_test(NAME ioTvImageReaderWriterRgbPNG2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees.png ${TEMP}/ioImageReaderWriterRgbPNG2PNG_poupees.png otbImageFileReaderRGBTest ${INPUTDATA}/poupees.png ${TEMP}/ioImageReaderWriterRgbPNG2PNG_poupees.png ) otb_add_test(NAME ioTvImageReaderWriterRgbPNG2PNGBox COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${BASELINE}/coTvExtractROI_QB.png ${TEMP}/coTvExtractROI_QB_Box.png otbImageFileReaderRGBTest ${INPUTDATA}/QB_Suburb.png ${TEMP}/coTvExtractROI_QB_Box.png?&box=0:0:70:70 ) otb_add_test(NAME ioTvImageReaderWriterRgbENVI2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees ${TEMP}/ioImageReaderWriterRgbENVI2PNG_poupees.png otbImageFileReaderRGBTest ${INPUTDATA}/poupees ${TEMP}/ioImageReaderWriterRgbENVI2PNG_poupees.png ) otb_add_test(NAME ioTvImageFileReaderRGB_Cai_SPOT5TIF2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderRGB_SPOT5TIF2PNG_poupeesTIF.png ${TEMP}/ioImageFileReaderRGB_Cai_SPOT5TIF2PNG_poupeesTIF.png otbImageFileReaderRGBTest ${INPUTDATA}/poupeesTIF/ ${TEMP}/ioImageFileReaderRGB_Cai_SPOT5TIF2PNG_poupeesTIF.png ) otb_add_test(NAME ioTvImageFileReaderRGB_PNG2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2PNG.png otbImageFileReaderRGBTest ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2PNG.png ) otb_add_test(NAME ioTvImageReaderWriterRgbJPEG2TIF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/couleurs.jpg ${TEMP}/ioImageReaderWriterRgbJPEG2TIF_couleurs.tif otbImageFileReaderRGBTest ${INPUTDATA}/couleurs.jpg ${TEMP}/ioImageReaderWriterRgbJPEG2TIF_couleurs.tif ) otb_add_test(NAME ioTvImageReaderWriterRgbPNG2TIF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees.png ${TEMP}/ioImageReaderWriterRgbPNG2TIF_poupees.tif otbImageFileReaderRGBTest ${INPUTDATA}/poupees.png ${TEMP}/ioImageReaderWriterRgbPNG2TIF_poupees.tif ) otb_add_test(NAME ioTvImageFileReaderRGB_BSQ2PNG_2 COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2BSQ_2.png otbImageFileReaderRGBTest ${TEMP}/ioImageFileWriterRGB_PNG2BSQ.hdr ${TEMP}/ioImageFileReaderRGB_PNG2BSQ_2.png ) set_property(TEST ioTvImageFileReaderRGB_BSQ2PNG_2 PROPERTY DEPENDS ioTvImageFileWriterRGB_PNG2BSQ) otb_add_test(NAME ioTvImageFileReaderRGB_PNG2TIFF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderRGB_PNG2TIFF.tiff ${TEMP}/ioImageFileReaderRGB_PNG2TIFF.tiff otbImageFileReaderRGBTest ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2TIFF.tiff ) otb_add_test(NAME ioTvImageReaderWriterRgbJPEG2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/couleurs.jpg ${TEMP}/ioImageReaderWriterRgbJPEG2PNG_couleurs.png otbImageFileReaderRGBTest ${INPUTDATA}/couleurs.jpg ${TEMP}/ioImageReaderWriterRgbJPEG2PNG_couleurs.png ) otb_add_test(NAME ioTvImageFileReaderRGB_BSQ2TIFF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees.hdr ${TEMP}/ioImageFileReaderRGB_BSQ2TIFF_poupees.tiff otbImageFileReaderRGBTest ${INPUTDATA}/poupees.hdr ${TEMP}/ioImageFileReaderRGB_BSQ2TIFF_poupees.tiff ) otb_add_test(NAME ioTvImageReaderWriterRgbPNG2JPEG COMMAND otbImageIOTestDriver otbImageFileReaderRGBTest ${INPUTDATA}/poupees.png ${TEMP}/ioImageReaderWriterRgbPNG2JPEG_poupees.jpg ) otb_add_test(NAME ioTvImageReaderWriterRgbTIF2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees.tif ${TEMP}/ioImageReaderWriterRgbTIF2PNG_poupees.png otbImageFileReaderRGBTest ${INPUTDATA}/poupees.tif ${TEMP}/ioImageReaderWriterRgbTIF2PNG_poupees.png ) otb_add_test(NAME ioTvStreamingIFWriterLUMWithoutStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingImageFileWriterLUM2LUMWithoutStreaming.lum otbStreamingImageFileWriterTest ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingImageFileWriterLUM2LUMWithoutStreaming.lum 0 # NumberOfStreamDivisions ) set_property(TEST ioTvStreamingIFWriterLUMWithoutStreaming PROPERTY DEPENDS ioTvImageFileReaderPNG2LUM) otb_add_test(NAME ioTvStreamingIFWriterBSQWithoutStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioStreamingImageFileWriterBSQWithoutStreaming.hdr otbStreamingImageFileWriterTest ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioStreamingImageFileWriterBSQWithoutStreaming.hdr 0 ) set_property(TEST ioTvStreamingIFWriterBSQWithoutStreaming PROPERTY DEPENDS ioTvImageFileReaderPNG2BSQ) otb_add_test(NAME ioTvStreamingWithIFWriterLUMWithStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingWithImageFileWriterLUM2LUMWithStreaming_10.lum otbStreamingImageFileWriterTest ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingWithImageFileWriterLUM2LUMWithStreaming_10.lum 10 # NumberOfStreamDivisions ) set_property(TEST ioTvStreamingWithIFWriterLUMWithStreaming PROPERTY DEPENDS ioTvImageFileReaderPNG2LUM) otb_add_test(NAME ioTvStreamingWithIFWriterBSQWithStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderPNG2BSQ.hd ${TEMP}/ioStreamingWithImageFileWriterBSQ2BSQWithStreaming_10.hd otbStreamingImageFileWriterTest ${TEMP}/ioImageFileReaderPNG2BSQ.hd ${TEMP}/ioStreamingWithImageFileWriterBSQ2BSQWithStreaming_10.hd 10 # NumberOfStreamDivisions ) set_property(TEST ioTvStreamingWithIFWriterBSQWithStreaming PROPERTY DEPENDS ioTvImageFileReaderPNG2BSQ) otb_add_test(NAME ioTvStreamingIFWriterBSQWithStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioStreamingImageFileWriterBSQWithStreaming_100.hdr otbStreamingImageFileWriterTest ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioStreamingImageFileWriterBSQWithStreaming_100.hdr 100 ) set_property(TEST ioTvStreamingIFWriterBSQWithStreaming PROPERTY DEPENDS ioTvImageFileReaderPNG2BSQ) otb_add_test(NAME ioTvStreamingIFWriterLUMWithStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingImageFileWriterLUM2LUMWithStreaming_10.lum otbStreamingImageFileWriterTest ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingImageFileWriterLUM2LUMWithStreaming_10.lum 10 # NumberOfStreamDivisions ) set_property(TEST ioTvStreamingIFWriterLUMWithStreaming PROPERTY DEPENDS ioTvImageFileReaderPNG2LUM) otb_add_test(NAME ioTvReadingComplexDataIntoComplexImage COMMAND otbImageIOTestDriver otbReadingComplexDataIntoComplexImageTest LARGEINPUT{RADARSAT1/GOMA2/SCENE01/DAT_01.001} 1000 1000 ) otb_add_test(NAME ioTvStreamingImageFilterBSQ2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderPNG2BSQ.hd ${TEMP}/ioStreamingImageFilterTestBSQ.png otbStreamingImageFilterTest ${TEMP}/ioImageFileReaderPNG2BSQ.hd ${TEMP}/ioStreamingImageFilterTestBSQ.png ) set_tests_properties(ioTvStreamingImageFilterBSQ2PNG PROPERTIES DEPENDS ioTvImageFileReaderPNG2BSQ) otb_add_test(NAME ioTvStreamingImageFilterLUM2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingImageFilterTestLUM.png otbStreamingImageFilterTest ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioStreamingImageFilterTestLUM.png ) set_tests_properties(ioTvStreamingImageFilterLUM2PNG PROPERTIES DEPENDS ioTvImageFileReaderPNG2LUM) otb_add_test(NAME ioTvImageFileWriterRGB_PNG2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileWriterRGB_PNG2PNG.png ${TEMP}/ioImageFileWriterRGB_PNG2PNG.png otbImageFileWriterRGBTest ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileWriterRGB_PNG2PNG.png ) otb_add_test(NAME ioTvGDALImageFileWriterTIF2TIF COMMAND otbImageIOTestDriver otbImageFileWriterRGBTest ${INPUTDATA}/poupeesTIF/IMAGERY.TIF ${TEMP}/poupees.tiff ) otb_add_test(NAME ioTvImageFileWriterRGB_PNG2BSQ COMMAND otbImageIOTestDriver otbImageFileWriterRGBTest ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileWriterRGB_PNG2BSQ.hdr ) otb_add_test(NAME ioTvImageMetadataStreamingWriterTest_HFA COMMAND otbImageIOTestDriver --compare-metadata ${EPSILON_9} ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvImageMetadataStreamingWriterHFA.img otbImageMetadataStreamingFileWriterTest ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvImageMetadataStreamingWriterHFA.img ) otb_add_test(NAME ioTvImageMetadataStreamingWriterTest_TIF COMMAND otbImageIOTestDriver --compare-metadata ${EPSILON_9} ${INPUTDATA}/spot5SubWithGcps.tif ${TEMP}/ioTvImageMetadataStreamingWriterTIF.tif otbImageMetadataStreamingFileWriterTest ${INPUTDATA}/spot5SubWithGcps.tif ${TEMP}/ioTvImageMetadataStreamingWriterTIF.tif ) otb_add_test(NAME ioTvImageFileReaderMSTAR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderMSTAR_rescal_chanel1.png ${TEMP}/ioImageFileReaderMSTAR_rescal_chanel1.png otbImageFileReaderMSTAR ${INPUTDATA}/MSTAR/HB19896.016 ${TEMP}/ioImageFileReaderMSTAR_rescal_chanel1.png ) otb_add_test(NAME ioTvGDALDriverDoubleWritingTest COMMAND otbImageIOTestDriver --compare-n-images ${EPSILON_9} 4 ${INPUTDATA}/poupees.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage1.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage2.tif ${INPUTDATA}/poupees.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage3.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage4.tif otbGDALDriverDoubleWritingTest ${INPUTDATA}/poupees.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage1.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage2.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage3.tif ${TEMP}/ioGdalDriverDoubleWritingTestImage4.tif ) otb_add_test(NAME ioTvStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfDivisionsStrippedStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfDivisionsStrippedStreaming.tif otbImageFileWriterTestCalculateNumberOfDivisions ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfDivisionsStrippedStreaming.tif SetNumberOfDivisionsStrippedStreaming 10 ) otb_add_test(NAME ioTvStreamingImageFileWriterCalculateNumberOfDivisions_SetAutomaticTiledStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetAutomaticTiledStreaming.tif otbImageFileWriterTestCalculateNumberOfDivisions ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetAutomaticTiledStreaming.tif SetAutomaticTiledStreaming 10 ) otb_add_test(NAME ioTvStreamingImageFileWriterCalculateNumberOfDivisions_DEFAULT COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_DEFAULT.tif otbImageFileWriterTestCalculateNumberOfDivisions ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_DEFAULT.tif DEFAULT ) otb_add_test(NAME ioTvStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfLinesStrippedStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfLinesStrippedStreaming.tif otbImageFileWriterTestCalculateNumberOfDivisions ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfLinesStrippedStreaming.tif SetNumberOfLinesStrippedStreaming 5 ) otb_add_test(NAME ioTvStreamingImageFileWriterCalculateNumberOfDivisions_SetTileDimensionTiledStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetTileDimensionTiledStreaming.tif otbImageFileWriterTestCalculateNumberOfDivisions ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetTileDimensionTiledStreaming.tif SetTileDimensionTiledStreaming 32 ) otb_add_test(NAME ioTvStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfDivisionsTiledStreamingS COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfDivisionsTiledStreaming.tif otbImageFileWriterTestCalculateNumberOfDivisions ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetNumberOfDivisionsTiledStreaming.tif SetNumberOfDivisionsTiledStreaming 10 ) otb_add_test(NAME ioTvStreamingImageFileWriterCalculateNumberOfDivisions_SetAutomaticStrippedStreaming COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetAutomaticStrippedStreaming.tif otbImageFileWriterTestCalculateNumberOfDivisions ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/ioStreamingImageFileWriterCalculateNumberOfDivisions_SetAutomaticStrippedStreaming.tif SetAutomaticStrippedStreaming 10 ) otb_add_test(NAME ioTvImageFileReaderRADCI22ENVI COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderRADCI22ENVI.hdr ${TEMP}/ioImageFileReaderRADCI22ENVI.hdr otbImageFileReaderRADComplexFloatExtract LARGEINPUT{RAD_CI2/3017_HH.rad} ${TEMP}/ioImageFileReaderRADCI22ENVI.hdr ) otb_add_test(NAME ioTvImageFileReaderTIF2RADCI4 COMMAND otbImageIOTestDriver otbImageFileReaderRADComplexInt ${INPUTDATA}/RSAT_imagery_VH.tif ${TEMP}/ioImageFileReaderTIF2RADCI4.rad ) otb_add_test(NAME ioTvScalarBufferToImageFileWriterTest COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${BASELINE}/ioTvScalarBufferToImageFileWriterTest.tif ${TEMP}/ioTvScalarBufferToImageFileWriterTest.tif otbScalarBufferToImageFileWriterTest 4 50 75 ${TEMP}/ioTvScalarBufferToImageFileWriterTest.tif ) otb_add_test(NAME ioTvONERAImageFileWriterComplex COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderONERAComplexWrite.ent ${TEMP}/ioImageFileReaderONERAComplexWrite.ent otbImageFileWriterONERAComplex LARGEINPUT{ONERA/spa3_0215_rad.ent} ${TEMP}/ioImageFileReaderONERAComplexWrite.ent ) otb_add_test(NAME ioTvImageFileReaderServerNameOTBTest COMMAND otbImageIOTestDriver otbImageFileReaderServerName ${OTB_DATA_ROOT}/Examples/osmfile.otb) set_property(TEST ioTvImageFileReaderServerNameOTBTest PROPERTY RESOURCE_LOCK web_access) #dashboard_hell # otb_add_test(NAME ioTvImageFileReaderServerNameHTTPTest COMMAND otbImageIOTestDriver # otbImageFileReaderServerName # http://tile.openstreetmap.org/) # set_property(TEST ioTvImageFileReaderServerNameHTTPTest PROPERTY RESOURCE_LOCK web_access) otb_add_test(NAME ioTvPipelineMetadataHandlingTest COMMAND otbImageIOTestDriver --compare-metadata ${EPSILON_9} ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvPipelineMetadataHandling.img otbPipelineMetadataHandlingTest ${INPUTDATA}/HFAGeoreferenced.img ${TEMP}/ioTvPipelineMetadataHandling.img ) otb_add_test(NAME ioTvMultiResolutionReadingInfo_TIFF COMMAND otbImageIOTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiResolutionReadingInfoOut_tiff.txt ${TEMP}/ioTvMultiResolutionReadingInfoOut_tiff.txt otbMultiResolutionReadingInfo ${INPUTDATA}/maur_rgb.tif ${TEMP}/ioTvMultiResolutionReadingInfoOut_tiff.txt ) otb_add_test(NAME ioTvMultiResolutionReadingInfo_TIFF2 COMMAND otbImageIOTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiResolutionReadingInfoOut_tiff2.txt ${TEMP}/ioTvMultiResolutionReadingInfoOut_tiff2.txt otbMultiResolutionReadingInfo LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TEMP}/ioTvMultiResolutionReadingInfoOut_tiff2.txt ) otb_add_test(NAME ioTvMultiResolutionReadingInfo COMMAND otbImageIOTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/ioTvMultiResolutionReadingInfoOut.txt ${TEMP}/ioTvMultiResolutionReadingInfoOut.txt otbMultiResolutionReadingInfo ${INPUTDATA}/bretagne.j2k ${TEMP}/ioTvMultiResolutionReadingInfoOut.txt ) otb_add_test(NAME ioTvImageFileReaderMW2TIFMW COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/QB_Toulouse_Ortho_PAN.mw ${TEMP}/ioImageFileReaderMW2TIFMW.tif otbImageFileReaderTestFloat ${INPUTDATA}/QB_Toulouse_Ortho_PAN.mw ${TEMP}/ioImageFileReaderMW2TIFMW.tif ) otb_add_test(NAME ioTvImageFileReaderPCI2TIF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/ioImageFileReaderPCI2TIF.tif otbImageFileReaderTestFloat ${INPUTDATA}/QB_Toulouse_Ortho_PAN.pix ${TEMP}/ioImageFileReaderPCI2TIF.tif ) otb_add_test(NAME ioTvImageFileReaderTIF2MW COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/QB_Toulouse_Ortho_PAN.mw ${TEMP}/ioImageFileReaderTIF2MW.mw otbImageFileReaderTestFloat ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/ioImageFileReaderTIF2MW.mw ) otb_add_test(NAME ioTvImageFileReaderMW2TIFIMG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/QB_Toulouse_Ortho_PAN_nogeoinfo.tif ${TEMP}/ioImageFileReaderMW2TIFIMG.tif otbImageFileReaderTestFloat ${INPUTDATA}/QB_Toulouse_Ortho_PAN.mw ${TEMP}/ioImageFileReaderMW2TIFIMG.tif ) otb_add_test(NAME ioTvImageFileReaderTIF2PCI COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/ioImageFileReaderTIF2PCI.pix otbImageFileReaderTestFloat ${INPUTDATA}/QB_Toulouse_Ortho_PAN.tif ${TEMP}/ioImageFileReaderTIF2PCI.pix ) otb_add_test(NAME ioTvVectorImageComplexIntoRealDoubleTest COMMAND otbImageIOTestDriver otbVectorImageComplexIntoRealDoubleTest ${INPUTDATA}/multibandComplexDouble_2bands.hdr ) otb_add_test(NAME ioTvVectorImageComplexDoubleTest COMMAND otbImageIOTestDriver otbVectorImageComplexDoubleTest ${INPUTDATA}/multibandComplexDouble_2bands.hdr ) otb_add_test(NAME ioTvVectorImageComplexFloatTest COMMAND otbImageIOTestDriver otbVectorImageComplexFloatTest ${INPUTDATA}/multibandComplexFloat_2bands.hdr ) otb_add_test(NAME ioTvVectorImageComplexIntoRealFloatTest COMMAND otbImageIOTestDriver otbVectorImageComplexIntoRealFloatTest ${INPUTDATA}/multibandComplexFloat_2bands.hdr ) otb_add_test(NAME ioTvImageComplexFloatTest COMMAND otbImageIOTestDriver otbImageComplexFloatTest ${INPUTDATA}/multibandComplexFloat_2bands.hdr ) otb_add_test(NAME ioTuVectorImageComplexNew COMMAND otbImageIOTestDriver otbVectorImageComplexNew) otb_add_test(NAME ioTvImageComplexDoubleTest COMMAND otbImageIOTestDriver otbImageComplexDoubleTest ${INPUTDATA}/multibandComplexDouble_2bands.hdr ) otb_add_test(NAME ioTuScalarBufferToImageFileWriter COMMAND otbImageIOTestDriver otbScalarBufferToImageFileWriterNew ) otb_add_test(NAME ioTvImageFileReaderShortLUM2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I2.lum ${TEMP}/ioImageFileReaderI2_LUM2LUM.lum otbShortImageIOTest ${INPUTDATA}/poupees_I2.lum ${TEMP}/ioImageFileReaderI2_LUM2LUM.lum ) otb_add_test(NAME ioTvImageFileReaderShortLUM2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I2.lum ${TEMP}/ioImageFileReaderI2_LUM2HDR.hdr otbShortImageIOTest ${INPUTDATA}/poupees_I2.lum ${TEMP}/ioImageFileReaderI2_LUM2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderShortHDR2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I2.lum ${TEMP}/ioImageFileReaderI2_HDR2LUM.lum otbShortImageIOTest ${TEMP}/ioImageFileReaderI2_LUM2HDR.hdr ${TEMP}/ioImageFileReaderI2_HDR2LUM.lum ) set_property(TEST ioTvImageFileReaderShortHDR2LUM PROPERTY DEPENDS ioTvImageFileReaderShortLUM2HDR) otb_add_test(NAME ioTvImageSeriesFileReader COMMAND otbImageIOTestDriver --compare-n-images ${EPSILON_9} 2 ${BASELINE}/ioTvImageSeries-0.png ${TEMP}/ioTvImageSeries-0.png ${BASELINE}/ioTvImageSeries-1.png ${TEMP}/ioTvImageSeries-1.png otbImageSeriesFileReader ${EXAMPLEDATA}/GomaAvantApres ${TEMP}/ioTvImageSeries.png ) if(OTB_DATA_USE_LARGEINPUT) # This test depends on the output of another test, which depends on large inputs. This situation should not happen. otb_add_test(NAME ioTvONERAImageStreamWriter COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderONERAComplexWrite.ent ${TEMP}/ioImageFileReaderONERAStreamWrite.ent otbImageFileWriterStreamingONERAComplex ${TEMP}/ioImageFileReaderONERAComplexWrite.ent ${TEMP}/ioImageFileReaderONERAStreamWrite.ent ) set_property(TEST ioTvONERAImageStreamWriter PROPERTY DEPENDS ioTvONERAImageFileWriterComplex) endif() otb_add_test(NAME ioTvImageFileReaderWithComplexPixel_PALSAR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderWithComplexPixel_PALSAR_l1.1.tif ${TEMP}/ioImageFileReaderWithComplexPixel_PALSAR_l1.1.tif otbImageFileReaderWithComplexPixelTest LARGEINPUT{PALSAR/200801280007/l1data/VOL-ALPSRP037120700-H1.1__A} ${TEMP}/ioImageFileReaderWithComplexPixel_PALSAR_l1.1.tif 0 0 100 100) otb_add_test(NAME ioTvImageFileReaderWithComplexPixel_ERS COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderWithComplexPixel_ERS_SLCI.tif ${TEMP}/ioImageFileReaderWithComplexPixel_ERS_SLCI.tif otbImageFileReaderWithComplexPixelTest LARGEINPUT{SAR_ERS2_SLCI_SCENE1/} ${TEMP}/ioImageFileReaderWithComplexPixel_ERS_SLCI.tif 0 0 100 100) otb_add_test(NAME ioTvImageFileReaderWithComplexPixel_RADARSAT COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderWithComplexPixel_RADARSAT.tif ${TEMP}/ioImageFileReaderWithComplexPixel_RADARSAT.tif otbImageFileReaderWithComplexPixelTest LARGEINPUT{RADARSAT1/GOMA/SCENE01/} ${TEMP}/ioImageFileReaderWithComplexPixel_RADARSAT.tif 0 0 100 100) otb_add_test(NAME ioTvVectorImageFileReaderWithComplexPixel_RADARSAT2 COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderWithComplexPixel_RADARSAT2.tif ${TEMP}/ioImageFileReaderWithComplexPixel_RADARSAT2.tif otbVectorImageFileReaderWithComplexPixelTest LARGEINPUT{RADARSAT2/ALTONA/Fine_Quad-Pol_Dataset/PK6621_DK406_FQ9_20080405_124900_HH_VV_HV_VH_SLC_Altona/product.xml} ${TEMP}/ioImageFileReaderWithComplexPixel_RADARSAT2.tif 0 0 100 100) otb_add_test(NAME ioTvVImageFileReader_RESOLUTION_0 COMMAND otbImageIOTestDriver otbVectorImageFileReaderWriterTest ${INPUTDATA}/maur_rgb.tif?&resol=0 ${TEMP}/ioImageFileReader_RESOLUTION_0.tif ) otb_add_test(NAME ioTvVImageFileReader_RESOLUTION_3 COMMAND otbImageIOTestDriver otbVectorImageFileReaderWriterTest ${INPUTDATA}/maur_rgb.tif?&resol=3 ${TEMP}/ioImageFileReader_RESOLUTION_3.tif ) otb_add_test(NAME ioTvVectorImageFileReaderWriterTest COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/qb_RoadExtract.img.hdr ${TEMP}/ioTvVectorImageFileReaderWriterTest.hdr otbVectorImageFileReaderWriterTest ${INPUTDATA}/qb_RoadExtract.img.hdr ${TEMP}/ioTvVectorImageFileReaderWriterTest.hdr ) otb_add_test(NAME ioTvVImageFileReader_RESOLUTION_4 COMMAND otbImageIOTestDriver otbVectorImageFileReaderWriterTest LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF?&resol=4} ${TEMP}/ioImageFileReader_RESOLUTION_4.tif ) otb_add_test(NAME ioTvVectorImageFileReaderWriterJP22TIF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioTvVectorImageFileReaderWriterJP22TIFOutput ${TEMP}/ioTvVectorImageFileReaderWriterJP22TIFOutput.tif otbVectorImageFileReaderWriterTest LARGEINPUT{JPEG2000/QB_multicomp_small.jpx} ${TEMP}/ioTvVectorImageFileReaderWriterJP22TIFOutput.tif ) otb_add_test(NAME ioTvImageFileReaderIntBSQ2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I4.hd ${TEMP}/ioImageFileReaderI4_BSQ2HDR.hdr otbIntImageIOTest ${INPUTDATA}/poupees_I4.hd ${TEMP}/ioImageFileReaderI4_BSQ2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderIntHDR2BSQ COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I4.hd ${TEMP}/ioImageFileReaderI4_HDR2BSQ.hd otbIntImageIOTest ${TEMP}/ioImageFileReaderI4_BSQ2HDR.hdr ${TEMP}/ioImageFileReaderI4_HDR2BSQ.hd ) set_property(TEST ioTvImageFileReaderIntHDR2BSQ PROPERTY DEPENDS ioTvImageFileReaderIntBSQ2HDR) otb_add_test(NAME ioTvONERAImageFileReader COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderONERA.hdr ${TEMP}/ioImageFileReaderONERA.hdr otbImageFileReaderONERATest LARGEINPUT{ONERA/spa3_0215_rad.ent} ${TEMP}/ioImageFileReaderONERA.hdr 10 10 100 100 ) otb_add_test(NAME ioTvImageFileReaderFloatHDR2BSQ COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R4.hd ${TEMP}/ioImageFileReaderR4_HDR2BSQ.hd otbFloatImageIOTest ${TEMP}/ioImageFileReaderR4_BSQ2HDR.hdr ${TEMP}/ioImageFileReaderR4_HDR2BSQ.hd ) set_property(TEST ioTvImageFileReaderFloatHDR2BSQ PROPERTY DEPENDS ioTvImageFileReaderFloatBSQ2HDR) otb_add_test(NAME ioTvImageFileReaderFloatLUM2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R4.lum ${TEMP}/ioImageFileReaderR4_LUM2HDR.hdr otbFloatImageIOTest ${INPUTDATA}/poupees_R4.lum ${TEMP}/ioImageFileReaderR4_LUM2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderFloatBSQ2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R4.hd ${TEMP}/ioImageFileReaderR4_BSQ2HDR.hdr otbFloatImageIOTest ${INPUTDATA}/poupees_R4.hd ${TEMP}/ioImageFileReaderR4_BSQ2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderFloatPNG2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderFloatPNG2LUM.lum otbFloatImageIOTest ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderFloatPNG2LUM.lum ) otb_add_test(NAME ioTvImageFileReaderFloatHDR2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R4.lum ${TEMP}/ioImageFileReaderR4_HDR2LUM.lum otbFloatImageIOTest ${TEMP}/ioImageFileReaderR4_LUM2HDR.hdr ${TEMP}/ioImageFileReaderR4_HDR2LUM.lum ) set_property(TEST ioTvImageFileReaderFloatHDR2LUM PROPERTY DEPENDS ioTvImageFileReaderFloatLUM2HDR) otb_add_test(NAME ioTvCheckNbBandsPNGIndexee COMMAND otbImageIOTestDriver otbPNGIndexedNbBandsTest ${INPUTDATA}/sbuv_indexee.png 4 ) otb_add_test(NAME ioTvImageFileReaderENVI2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileWriterPNG2BSQ_cthead1_2.png otbImageFileReaderTest ${TEMP}/ioImageFileWriterPNG2BSQ_cthead1.hdr ${TEMP}/ioImageFileWriterPNG2BSQ_cthead1_2.png ) set_property(TEST ioTvImageFileReaderENVI2PNG PROPERTY DEPENDS ioTvImageFileWriterPNG2BSQ) otb_add_test(NAME ioTvImageFileReaderPNG2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderPNG2PNG_cthead1.png ${TEMP}/ioImageFileReaderPNG2PNG_cthead1.png otbImageFileReaderTest ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderPNG2PNG_cthead1.png ) otb_add_test(NAME ioTvImageFileReaderPDS2TIFF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/pdsImage.img ${TEMP}/ioTvImageFileReaderPDS2TIFF.tif otbImageFileReaderTest ${INPUTDATA}/pdsImage.img ${TEMP}/ioTvImageFileReaderPDS2TIFF.tif) otb_add_test(NAME ioTvImageFileReaderPNG2BSQ COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderPNG2BSQ.hd otbImageFileReaderTest ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderPNG2BSQ.hd ) otb_add_test(NAME ioTvWritingComplexDataWithComplexImage COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioWritingComplexDataWithComplexImageOutput.tif ${TEMP}/ioWritingComplexDataWithComplexImageOutput.tif otbWritingComplexDataWithComplexImageTest LARGEINPUT{RADARSAT1/GOMA2/SCENE01/DAT_01.001} ${TEMP}/ioWritingComplexDataWithComplexImageOutput.tif 1000 1000 500 500 ) otb_add_test(NAME ioTvImageFileReaderCR42CR8 COMMAND otbImageIOTestDriver otbImageFileReaderRADComplexDouble ${INPUTDATA}/RADCR4_image.rad ${TEMP}/ioImageFileReaderCR42CR8.rad ) otb_add_test(NAME ioTvStreamingPipeline_TIF2PNG COMMAND otbImageIOTestDriver otbPipeline ${INPUTDATA}/cthead1.png #ROI_IKO_PAN_LesHalles.tif ${TEMP}/ioPipeline.png ) otb_add_test(NAME ioTvStreamingImageFilterGDAL_TIFF COMMAND otbImageIOTestDriver otbStreamingImageFilterTest ${INPUTDATA}/poupeesTIF/IMAGERY.TIF ${TEMP}/ioStreamingImageFilterTestGDAL_PoupeesTif.png ) otb_add_test(NAME ioTvStreamingImageFilterGDAL_ENVI COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioStreamingImageFilterTestCDAL_ENVI.png otbStreamingImageFilterTest ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioStreamingImageFilterTestCDAL_ENVI.png ) otb_add_test(NAME ioTvStreamingShortImageFileWriterStreamedTest COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_sub.png ${TEMP}/ioTvStreamingShortImageFileWriterStreamedTest.png otbStreamingShortImageFileWriterTest ${INPUTDATA}/poupees_sub.png ${TEMP}/ioTvStreamingShortImageFileWriterStreamedTest.png 1 4 ) otb_add_test(NAME ioTvStreamingShortImageFileWriterTest COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_sub.png ${TEMP}/ioTvStreamingShortImageFileWriterTest.png otbStreamingShortImageFileWriterTest ${INPUTDATA}/poupees_sub.png ${TEMP}/ioTvStreamingShortImageFileWriterTest.png 0 ) otb_add_test(NAME ioTvImageFileReaderDoubleBSQ2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R8.hd ${TEMP}/ioImageFileReaderR8_BSQ2HDR.hdr otbDoubleImageIOTest ${INPUTDATA}/poupees_R8.hd ${TEMP}/ioImageFileReaderR8_BSQ2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderDoubleHDR2BSQ COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R8.hd ${TEMP}/ioImageFileReaderR8_HDR2BSQ.hd otbDoubleImageIOTest ${TEMP}/ioImageFileReaderR8_BSQ2HDR.hdr ${TEMP}/ioImageFileReaderR8_HDR2BSQ.hd ) set_property(TEST ioTvImageFileReaderDoubleHDR2BSQ PROPERTY DEPENDS ioTvImageFileReaderDoubleBSQ2HDR) otb_add_test(NAME ioTvImageFileReaderDoubleLUM2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R8.lum ${TEMP}/ioImageFileReaderR8_LUM2HDR.hdr otbDoubleImageIOTest ${INPUTDATA}/poupees_R8.lum ${TEMP}/ioImageFileReaderR8_LUM2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderWriterJP22TIF COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioTvImageFileReaderWriterJP22TIFOutput.tif ${TEMP}/ioTvImageFileReaderWriterJP22TIFOutput.tif otbDoubleImageIOTest LARGEINPUT{JPEG2000/QB_multicomp_small.jpx} ${TEMP}/ioTvImageFileReaderWriterJP22TIFOutput.tif ) otb_add_test(NAME ioTvImageFileReaderDoubleHDR2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_R8.lum ${TEMP}/ioImageFileReaderR8_HDR2LUM.lum otbDoubleImageIOTest ${TEMP}/ioImageFileReaderR8_LUM2HDR.hdr ${TEMP}/ioImageFileReaderR8_HDR2LUM.lum ) set_property(TEST ioTvImageFileReaderDoubleHDR2LUM PROPERTY DEPENDS ioTvImageFileReaderDoubleLUM2HDR) otb_add_test(NAME ioTvImageFileWriterPNG2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileWriterPNG2PNG_cthead1.png otbImageFileWriterTest ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileWriterPNG2PNG_cthead1.png ) otb_add_test(NAME ioTvImageFileWriterPNG2BSQ COMMAND otbImageIOTestDriver otbImageFileWriterTest ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileWriterPNG2BSQ_cthead1.hdr ) otb_add_test(NAME ioTuImageIOFactoryNew COMMAND otbImageIOTestDriver otbImageIOFactoryNew ) otb_add_test(NAME ioTvCompareWritingComplexImage_TIF COMMAND otbImageIOTestDriver otbCompareWritingComplexImageTest LARGEINPUT{PALSAR/200801280007/l1data/VOL-ALPSRP037120700-H1.1__A} ${TEMP}/ioTvImageFileReaderCompareComplexPixelWithFloatPixel_PALSAR.tif 0 0 100 100) otb_add_test(NAME ioTvCompareWritingComplexImage_HDR COMMAND otbImageIOTestDriver otbCompareWritingComplexImageTest LARGEINPUT{PALSAR/200801280007/l1data/VOL-ALPSRP037120700-H1.1__A} ${TEMP}/ioTvImageFileReaderCompareComplexPixelWithFloatPixel_PALSAR.hdr 0 0 100 100) if(OTB_DATA_USE_LARGEINPUT) set( GenericTestPHR_TESTNB 0) foreach( current_file ${GenericTestPHR_DATA_INPUTS} ) list(GET GenericTestPHR_DATA_TYPES ${GenericTestPHR_TESTNB} current_type ) math(EXPR GenericTestPHR_TESTNB "${GenericTestPHR_TESTNB} + 1") string(REGEX MATCH "TIFF" PHR_TIFF_FILE ${current_type}) if(NOT PHR_TIFF_FILE) # Extract resolution of input file otb_add_test(NAME ioTvMultiResolutionReadingInfo_${current_type} COMMAND otbImageIOTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvMultiResolutionReadingInfo_${current_type}.txt ${TEMP}/ioTvMultiResolutionReadingInfo_${current_type}_OUT.txt --ignore-lines-with 1 SubDatasetIndex otbMultiResolutionReadingInfo ${current_file} ${TEMP}/ioTvMultiResolutionReadingInfo_${current_type}_OUT.txt ) endif() endforeach() endif() # Tests about complex reading set(INPUTFILE_PIXELTYPES_LIST "Int" "Short" "Float" "Double") set(READING_PIXELTYPES_LIST "Int" "Short" "Float" "Double") set(NBBANDS_LIST "2" "3" "4") foreach(INPUTFILE_PIXELTYPE ${INPUTFILE_PIXELTYPES_LIST}) foreach(READING_PIXELTYPE ${READING_PIXELTYPES_LIST}) otb_add_test(NAME ioTvMonobandScalar${INPUTFILE_PIXELTYPE}ToImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMonobandScalarToImageComplex${READING_PIXELTYPE} ${INPUTDATA}/monoband${INPUTFILE_PIXELTYPE}.tif) otb_add_test(NAME ioTvMonobandScalar${INPUTFILE_PIXELTYPE}ToVectorImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMonobandScalarToVectorImageComplex${READING_PIXELTYPE} ${INPUTDATA}/monoband${INPUTFILE_PIXELTYPE}.tif) otb_add_test(NAME ioTvMonobandComplex${INPUTFILE_PIXELTYPE}ToImageScalar${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMonobandComplexToImageScalar${READING_PIXELTYPE} ${INPUTDATA}/monobandComplex${INPUTFILE_PIXELTYPE}.tif) #hdr) otb_add_test(NAME ioTvMonobandComplex${INPUTFILE_PIXELTYPE}ToImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMonobandComplexToImageComplex${READING_PIXELTYPE} ${INPUTDATA}/monobandComplex${INPUTFILE_PIXELTYPE}.tif) #hdr) otb_add_test(NAME ioTvMonobandComplex${INPUTFILE_PIXELTYPE}ToVectorImageScalar${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMonobandComplexToVectorImageScalar${READING_PIXELTYPE} ${INPUTDATA}/monobandComplex${INPUTFILE_PIXELTYPE}.tif) #hdr) otb_add_test(NAME ioTvMonobandComplex${INPUTFILE_PIXELTYPE}ToVectorImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMonobandComplexToVectorImageComplex${READING_PIXELTYPE} ${INPUTDATA}/monobandComplex${INPUTFILE_PIXELTYPE}.tif) #hdr) # Weird case : only the first 2 bands used otb_add_test(NAME ioTvMultibandScalar${INPUTFILE_PIXELTYPE}ToImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMultibandScalarToImageComplex${READING_PIXELTYPE} ${INPUTDATA}/multiband${INPUTFILE_PIXELTYPE}.tif) # Weird case : one scalar band -> one complex band with imag=0 # but interleaving real and imaginary parts can only work for an even nb of bands otb_add_test(NAME ioTvMultibandScalar${INPUTFILE_PIXELTYPE}ToVectorImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMultibandScalarToVectorImageComplex${READING_PIXELTYPE} ${INPUTDATA}/multiband${INPUTFILE_PIXELTYPE}.tif) foreach(NBBANDS ${NBBANDS_LIST}) # Weird case : need specifications to write the test # otb_add_test(NAME ioTvMultibandComplex${INPUTFILE_PIXELTYPE}${NBBANDS}BandsToImageScalar${READING_PIXELTYPE} # COMMAND otbImageIOTestDriver # otbMultibandComplexToImageScalar${READING_PIXELTYPE} # ${INPUTDATA}/multibandComplex${INPUTFILE_PIXELTYPE}_${NBBANDS}bands.tif) #hdr) # Size: 100x100 is to large to store pixel values coded as short. if( NOT ${INPUTFILE_PIXELTYPE} MATCHES "Short" ) otb_add_test(NAME ioTvMultibandComplex${INPUTFILE_PIXELTYPE}${NBBANDS}BandsToVectorImageScalar${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMultibandComplexToVectorImageScalar${READING_PIXELTYPE} ${INPUTDATA}/multibandComplex${INPUTFILE_PIXELTYPE}_${NBBANDS}bands.tif) #hdr) else() otb_add_test(NAME ioTvMultibandComplex${INPUTFILE_PIXELTYPE}${NBBANDS}BandsToVectorImageScalar${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMultibandComplexToVectorImageScalar${READING_PIXELTYPE} ${INPUTDATA}/multibandComplex${INPUTFILE_PIXELTYPE}_${NBBANDS}bands_50x50.tif) #hdr) endif() # Weird case : need specifications to write the test # [missing impl] # otb_add_test(NAME ioTvMultibandComplex${INPUTFILE_PIXELTYPE}${NBBANDS}BandsToImageComplex${READING_PIXELTYPE}) # Size: 100x100 is to large to store pixel values coded as short. if( NOT ${INPUTFILE_PIXELTYPE} MATCHES "Short" ) otb_add_test(NAME ioTvMultibandComplex${INPUTFILE_PIXELTYPE}${NBBANDS}BandsToVectorImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMultibandComplexToVectorImageComplex${READING_PIXELTYPE} ${INPUTDATA}/multibandComplex${INPUTFILE_PIXELTYPE}_${NBBANDS}bands.tif) #hdr) else() otb_add_test(NAME ioTvMultibandComplex${INPUTFILE_PIXELTYPE}${NBBANDS}BandsToVectorImageComplex${READING_PIXELTYPE} COMMAND otbImageIOTestDriver otbMultibandComplexToVectorImageComplex${READING_PIXELTYPE} ${INPUTDATA}/multibandComplex${INPUTFILE_PIXELTYPE}_${NBBANDS}bands_50x50.tif) #hdr) endif() endforeach() endforeach() endforeach() # Tests about writing Scalar / Complex data set(DATA_PIXELTYPES_LIST "Int" "Short" "Float" "Double") set(WRITING_PIXELTYPES_LIST "Int" "Short" "Float" "Double") foreach(DATA_PIXELTYPE ${DATA_PIXELTYPES_LIST}) otb_add_test(NAME ioTvWriteImageScalar${DATA_PIXELTYPE} COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/monoband${DATA_PIXELTYPE}.tif ${TEMP}/monobandOut${DATA_PIXELTYPE}.tif otbImageScalarFileWriterTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/monobandOut${DATA_PIXELTYPE}.tif 100 ) otb_add_test(NAME ioTvWriteImageComplex${DATA_PIXELTYPE} COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/monobandComplex${DATA_PIXELTYPE}.tif ${TEMP}/monobandComplexOut${DATA_PIXELTYPE}.tif otbImageComplexFileWriterTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/monobandComplexOut${DATA_PIXELTYPE}.tif 100 ) foreach(NBBANDS ${NBBANDS_LIST}) if( NOT ${DATA_PIXELTYPE} MATCHES "Short" ) otb_add_test(NAME ioTvWriteVectorImageScalar${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multiband${DATA_PIXELTYPE}_${NBBANDS}bands.tif ${TEMP}/multibandOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif otbVectorImageFileWriterScalarTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif 100 ${NBBANDS} ) otb_add_test(NAME ioTvWriteVectorImageComplex${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multibandComplex${DATA_PIXELTYPE}_${NBBANDS}bands.tif ${TEMP}/multibandComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif otbVectorImageFileWriterComplexTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif 100 ${NBBANDS} ) else() otb_add_test(NAME ioTvWriteVectorImageScalar${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multiband${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif ${TEMP}/multibandOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif otbVectorImageFileWriterScalarTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif 50 ${NBBANDS} ) otb_add_test(NAME ioTvWriteVectorImageComplex${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multibandComplex${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif ${TEMP}/multibandComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif otbVectorImageFileWriterComplexTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif 50 ${NBBANDS} ) endif() endforeach() ############ # Tests about Streaming writing Scalar / Complex data otb_add_test(NAME ioTvStreamingWriteImageScalar${DATA_PIXELTYPE} COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/monoband${DATA_PIXELTYPE}.tif ${TEMP}/monobandStrOut${DATA_PIXELTYPE}.tif otbImageScalarStreamingFileWriterTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/monobandStrOut${DATA_PIXELTYPE}.tif 100 ) otb_add_test(NAME ioTvStreamingWriteImageComplex${DATA_PIXELTYPE} COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/monobandComplex${DATA_PIXELTYPE}.tif ${TEMP}/monobandStrComplexOut${DATA_PIXELTYPE}.tif otbImageComplexStreamingFileWriterTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/monobandStrComplexOut${DATA_PIXELTYPE}.tif 100 ) foreach(NBBANDS ${NBBANDS_LIST}) if( NOT ${DATA_PIXELTYPE} MATCHES "Short" ) otb_add_test(NAME ioTvStreamingWriteVectorImageScalar${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multiband${DATA_PIXELTYPE}_${NBBANDS}bands.tif ${TEMP}/multibandStrOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif otbVectorImageStreamingFileWriterScalarTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandStrOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif 100 ${NBBANDS} ) otb_add_test(NAME ioTvStreamingWriteVectorImageComplex${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multibandComplex${DATA_PIXELTYPE}_${NBBANDS}bands.tif ${TEMP}/multibandStrComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif otbVectorImageStreamingFileWriterComplexTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandStrComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands.tif 100 ${NBBANDS} ) else() otb_add_test(NAME ioTvStreamingWriteVectorImageScalar${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multiband${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif ${TEMP}/multibandStrOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif otbVectorImageStreamingFileWriterScalarTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandStrOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif 50 ${NBBANDS} ) otb_add_test(NAME ioTvStreamingWriteVectorImageComplex${DATA_PIXELTYPE}${NBBANDS}Bands COMMAND otbImageIOTestDriver --compare-image ${NOTOL} ${INPUTDATA}/multibandComplex${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif ${TEMP}/multibandStrComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif otbVectorImageStreamingFileWriterComplexTestWithoutInput${DATA_PIXELTYPE} ${TEMP}/multibandStrComplexOut${DATA_PIXELTYPE}_${NBBANDS}bands_50x50.tif 50 ${NBBANDS} ) endif() endforeach() endforeach() otb_add_test(NAME ioTvImageFileReaderHDR2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioImageFileReaderHDR2LUM.lum otbImageFileReaderTest ${INPUTDATA}/poupees_1canal.c1.hdr ${TEMP}/ioImageFileReaderHDR2LUM.lum ) otb_add_test(NAME ioTvImageFileReaderPNG2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderPNG2LUM.lum otbImageFileReaderTest ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderPNG2LUM.lum ) otb_add_test(NAME ioTvImageFileReaderLUM2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioImageFileReaderLUM2LUM.lum otbImageFileReaderTest ${TEMP}/ioImageFileReaderPNG2LUM.lum ${TEMP}/ioImageFileReaderLUM2LUM.lum ) set_tests_properties(ioTvImageFileReaderLUM2LUM PROPERTIES DEPENDS ioTvImageFileReaderPNG2LUM) otb_add_test(NAME ioTvImageFileWriterLUM2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderLUM2HDR.hdr otbImageFileReaderTest ${TEMP}/ioImageFileReaderLUM2LUM.lum ${TEMP}/ioImageFileReaderLUM2HDR.hdr ) set_tests_properties(ioTvImageFileWriterLUM2HDR PROPERTIES DEPENDS ioTvImageFileReaderLUM2LUM) otb_add_test(NAME ioTvImageFileReaderBSQ2PNG COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_1canal.hd ${TEMP}/ioImageFileReaderBSQ2PNG.png otbImageFileReaderTest ${INPUTDATA}/poupees_1canal.hd ${TEMP}/ioImageFileReaderBSQ2PNG.png ) otb_add_test(NAME ioTvImageFileReaderRGB_PNG2BSQ COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2BSQ.hd otbImageFileReaderRGBTest ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2BSQ.hd ) otb_add_test(NAME ioTvImageFileReaderRGB_PNG2ENVI COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2ENVI.hdr otbImageFileReaderRGBTest ${INPUTDATA}/couleurs_extrait.png ${TEMP}/ioImageFileReaderRGB_PNG2ENVI.hdr ) otb_add_test(NAME ioTvImageFileReaderIntLUM2HDR COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I4.lum ${TEMP}/ioImageFileReaderI4_LUM2HDR.hdr otbIntImageIOTest ${INPUTDATA}/poupees_I4.lum ${TEMP}/ioImageFileReaderI4_LUM2HDR.hdr ) otb_add_test(NAME ioTvImageFileReaderIntHDR2LUM COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${INPUTDATA}/poupees_I4.lum ${TEMP}/ioImageFileReaderI4_HDR2LUM.lum otbIntImageIOTest ${TEMP}/ioImageFileReaderI4_LUM2HDR.hdr ${TEMP}/ioImageFileReaderI4_HDR2LUM.lum ) set_tests_properties(ioTvImageFileReaderIntHDR2LUM PROPERTIES DEPENDS ioTvImageFileReaderIntLUM2HDR) otb_add_test(NAME ioTvImageFileReaderPNG2ENVI COMMAND otbImageIOTestDriver --compare-image ${EPSILON_9} ${BASELINE}/ioImageFileReaderPNG2ENVI.hdr ${TEMP}/ioImageFileReaderPNG2ENVI.hdr otbImageFileReaderTest ${INPUTDATA}/cthead1.png ${TEMP}/ioImageFileReaderPNG2ENVI.hdr ) OTB-release-5.8/Modules/IO/ImageIO/test/WriteUnsignedLong.cxx000066400000000000000000000042431301006202600237240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" //TODO change the bug tracker url //http://bugs.orfeo-toolbox.org/view.php?id=406 int main(int itkNotUsed(argc), char *argv[]) { char * filename = argv[1]; typedef unsigned long PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // check for input images ImageType::Pointer image = ImageType::New(); WriterType::Pointer writer = WriterType::New(); ReaderType::Pointer reader = ReaderType::New(); ImageType::IndexType start; start[0] = 0; // first index on X start[1] = 0; // first index on Y ImageType::SizeType size; size[0] = 10; // size along X size[1] = 10; ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); image->SetRegions(region); image->Allocate(); ImageType::PixelType initialValue = 0; image->FillBuffer(initialValue); ImageType::IndexType pixelIndex; pixelIndex[0] = 1; // x position pixelIndex[1] = 1; image->SetPixel(pixelIndex, initialValue + 1); writer->SetInput(image); writer->SetFileName(filename); writer->Update(); reader->SetFileName(filename); reader->Update(); ImageType::RegionType outputRegion; outputRegion = reader->GetOutput()->GetLargestPossibleRegion(); ImageType::SizeType outputSize; outputSize = outputRegion.GetSize(); if (reader->GetOutput()->GetPixel(pixelIndex) != initialValue + 1 ) { return EXIT_FAILURE; } else { return EXIT_SUCCESS; } } OTB-release-5.8/Modules/IO/ImageIO/test/otbCompareWritingComplexImage.cxx000066400000000000000000000107171301006202600262520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "otbComplexToIntensityImageFilter.h" #include "itkComplexToRealImageFilter.h" #include "itkComplexToImaginaryImageFilter.h" #include "otbStreamingCompareImageFilter.h" #include "itkComplexToRealImageFilter.h" #include "itkComplexToImaginaryImageFilter.h" int otbCompareWritingComplexImageTest(int argc, char* argv[]) { if (argc < 7) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int startX = (unsigned int)(::atoi(argv[3])); unsigned int startY = (unsigned int)(::atoi(argv[4])); unsigned int sizeX = (unsigned int)(::atoi(argv[5])); unsigned int sizeY = (unsigned int)(::atoi(argv[6])); typedef std::complex ComplexPixelType; typedef float PixelType; const unsigned int Dimension = 2; typedef otb::Image ComplexImageType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ExtractROI ExtractROIFilterType; typedef otb::StreamingCompareImageFilter CompareFilterType; typedef itk::ComplexToRealImageFilter RealExtractorType; typedef itk::ComplexToImaginaryImageFilter ImaginaryExtractorType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); extractROIFilter->SetStartX(startX); extractROIFilter->SetStartY(startY); extractROIFilter->SetSizeX(sizeX); extractROIFilter->SetSizeY(sizeY); extractROIFilter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(extractROIFilter->GetOutput()); writer->Update(); std::cout << "Write " << std::endl; ReaderType::Pointer readerAfterWrite = ReaderType::New(); readerAfterWrite->SetFileName(outputFilename); readerAfterWrite->Update(); /* Compare Real Part */ RealExtractorType::Pointer realExtractor = RealExtractorType::New(); RealExtractorType::Pointer realExtractorAfterWrite = RealExtractorType::New(); realExtractor->SetInput(extractROIFilter->GetOutput()); realExtractorAfterWrite->SetInput(readerAfterWrite->GetOutput()); CompareFilterType::Pointer compareRealPartFilter = CompareFilterType::New(); compareRealPartFilter->SetInput1(realExtractor->GetOutput()); compareRealPartFilter->SetInput2(realExtractorAfterWrite->GetOutput()); compareRealPartFilter->Update(); /* Compare Imaginary Part */ ImaginaryExtractorType::Pointer imagExtractor = ImaginaryExtractorType::New(); ImaginaryExtractorType::Pointer imagExtractorAfterWrite = ImaginaryExtractorType::New(); imagExtractor->SetInput(extractROIFilter->GetOutput()); imagExtractorAfterWrite->SetInput(readerAfterWrite->GetOutput()); CompareFilterType::Pointer compareImagPartFilter = CompareFilterType::New(); compareImagPartFilter->SetInput1(imagExtractor->GetOutput()); compareImagPartFilter->SetInput2(imagExtractorAfterWrite->GetOutput()); compareImagPartFilter->Update(); std::cout << " Real Part comparison : " << compareRealPartFilter->GetMSE()<< std::endl; std::cout << " Imaginary Part comparison : " << compareImagPartFilter->GetMSE()<< std::endl; if( compareRealPartFilter->GetMSE() > 0.0 ) { std::cout << " Real part not the same " << std::endl; return EXIT_FAILURE; } if( compareImagPartFilter->GetMSE() > 0.0 ) { std::cout << " Imaginary part not the same" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbComplexImageManipulationTest.cxx000066400000000000000000000535721301006202600266260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbMacro.h" #include "itkImageRegionIteratorWithIndex.h" // Do all comparison in double precision const double Epsilon = 1.E-6; template bool IsEqual(TPixel output, TPixel expected) { typedef typename itk::NumericTraits::RealType RealType; RealType outputReal = static_cast(output); RealType expectedReal = static_cast(expected); // avoid division by zero return outputReal == expectedReal || (vcl_abs(expectedReal - outputReal) / vcl_abs(expectedReal) < Epsilon); } template bool IsEqual(std::complex output, std::complex expected) { typedef typename itk::NumericTraits >::RealType RealType; typedef typename itk::NumericTraits >::ScalarRealType ScalarRealType; RealType outputReal ( static_cast(output.real()) , static_cast(output.imag()) ); RealType expectedReal( static_cast(expected.real()), static_cast(expected.imag()) ); // avoid division by zero return outputReal == expectedReal || (vcl_abs(expectedReal - outputReal) / vcl_abs(expectedReal) < Epsilon); } template bool IsEqual(itk::VariableLengthVector output, itk::VariableLengthVector expected) { bool result = true; for(unsigned int i = 0; i < output.Size(); ++i) { result = result && IsEqual(output[i], expected[i]); } return result; } template bool TestCompare(TIndex idx, TPixel output, TPixel expected) { std::cout << "PIXEL " << idx << " --> " << "OUTPUT = " << output << " || " << "EXPECTED = " << expected << std::endl; if (!IsEqual(output, expected)) { std::cerr << "ERROR at position " << idx << ". Got " << output << ", expected " << expected << std::endl; return false; } return true; } template itk::ImageRegionIteratorWithIndex ReadRegion(const char* filename, TImagePointerType& image, unsigned int w, unsigned int h) { typedef TImagePointerType ImagePointerType; typedef typename ImagePointerType::ObjectType ImageType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::SizeType SizeType; IndexType idx; idx.Fill(0); SizeType size; size[0] = w; size[1] = h; RegionType region; region.SetSize(size); region.SetIndex(idx); typedef otb::ImageFileReader ReaderType; typename ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(filename); reader->GetOutput()->SetRequestedRegion(region); reader->Update(); image = reader->GetOutput(); return itk::ImageRegionIteratorWithIndex(image, region); } /*********** * 1. * Read Monoband Scalar as Image * out : real = in, imag = 0 ***********/ template int otbMonobandScalarToImageComplexGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef std::complex ComplexType; typedef ComplexType PixelType; typedef otb::Image ImageType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]; if ( !TestCompare(it.GetIndex(), it.Get(), ComplexType(count, 0)) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMonobandScalarToImageComplexFloat(int argc, char * argv[]) { return otbMonobandScalarToImageComplexGeneric(argc, argv); } int otbMonobandScalarToImageComplexDouble(int argc, char * argv[]) { return otbMonobandScalarToImageComplexGeneric(argc, argv); } int otbMonobandScalarToImageComplexInt(int argc, char * argv[]) { return otbMonobandScalarToImageComplexGeneric(argc, argv); } int otbMonobandScalarToImageComplexShort(int argc, char * argv[]) { return otbMonobandScalarToImageComplexGeneric(argc, argv); } /*********** * 2. * Read MonobandComplex as Image * out : norm(in) ***********/ template int otbMonobandComplexToImageScalarGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType InputType; typedef std::complex ComplexType; typedef typename itk::NumericTraits::RealType RealType; typedef typename itk::NumericTraits::ScalarRealType ScalarRealType; typedef InputType PixelType; typedef otb::Image ImageType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = 2 * (it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]); ComplexType expected = ComplexType(count, count+1); RealType expectedReal( static_cast(expected.real()), static_cast(expected.imag()) ); if ( !TestCompare(it.GetIndex(), it.Get(), static_cast(vcl_abs(expectedReal)) ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMonobandComplexToImageScalarFloat(int argc, char * argv[]) { return otbMonobandComplexToImageScalarGeneric(argc, argv); } int otbMonobandComplexToImageScalarDouble(int argc, char * argv[]) { return otbMonobandComplexToImageScalarGeneric(argc, argv); } int otbMonobandComplexToImageScalarInt(int argc, char * argv[]) { return otbMonobandComplexToImageScalarGeneric(argc, argv); } int otbMonobandComplexToImageScalarShort(int argc, char * argv[]) { return otbMonobandComplexToImageScalarGeneric(argc, argv); } /*********** * 3. * Read Monoband Complex as Image * out : in ***********/ template int otbMonobandComplexToImageComplexGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef std::complex ComplexType; typedef ComplexType PixelType; typedef otb::Image ImageType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = 2 * (it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]); if ( !TestCompare(it.GetIndex(), it.Get(), ComplexType(count, count+1) ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMonobandComplexToImageComplexFloat(int argc, char * argv[]) { return otbMonobandComplexToImageComplexGeneric(argc, argv); } int otbMonobandComplexToImageComplexDouble(int argc, char * argv[]) { return otbMonobandComplexToImageComplexGeneric(argc, argv); } int otbMonobandComplexToImageComplexInt(int argc, char * argv[]) { return otbMonobandComplexToImageComplexGeneric(argc, argv); } int otbMonobandComplexToImageComplexShort(int argc, char * argv[]) { return otbMonobandComplexToImageComplexGeneric(argc, argv); } /*********** * 4. * Read Monoband Complex as VectorImage * out : [0]=in.real(), [1]=in.imag() ***********/ template int otbMonobandComplexToVectorImageScalarGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType PixelType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = 2 * (it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]); PixelType expected(2); expected[0] = count; expected[1] = count + 1; if ( !TestCompare( it.GetIndex(), it.Get(), expected ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMonobandComplexToVectorImageScalarFloat(int argc, char * argv[]) { return otbMonobandComplexToVectorImageScalarGeneric(argc, argv); } int otbMonobandComplexToVectorImageScalarDouble(int argc, char * argv[]) { return otbMonobandComplexToVectorImageScalarGeneric(argc, argv); } int otbMonobandComplexToVectorImageScalarInt(int argc, char * argv[]) { return otbMonobandComplexToVectorImageScalarGeneric(argc, argv); } int otbMonobandComplexToVectorImageScalarShort(int argc, char * argv[]) { return otbMonobandComplexToVectorImageScalarGeneric(argc, argv); } /*********** * 5. * Read Monoband Complex as VectorImage * out : [0]=in ***********/ template int otbMonobandComplexToVectorImageComplexGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef std::complex ComplexType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType PixelType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = 2 * (it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]); PixelType expected(1); expected[0] = ComplexType(count, count + 1); if ( !TestCompare( it.GetIndex(), it.Get(), expected ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMonobandComplexToVectorImageComplexFloat(int argc, char * argv[]) { return otbMonobandComplexToVectorImageComplexGeneric(argc, argv); } int otbMonobandComplexToVectorImageComplexDouble(int argc, char * argv[]) { return otbMonobandComplexToVectorImageComplexGeneric(argc, argv); } int otbMonobandComplexToVectorImageComplexInt(int argc, char * argv[]) { return otbMonobandComplexToVectorImageComplexGeneric(argc, argv); } int otbMonobandComplexToVectorImageComplexShort(int argc, char * argv[]) { return otbMonobandComplexToVectorImageComplexGeneric(argc, argv); } /*********** * 6. * Read Multiband Scalar as Image * out : out.real=in[0], out.imag=in[1] ***********/ template int otbMultibandScalarToImageComplexGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef std::complex ComplexType; typedef otb::Image ImageType; typedef typename ImageType::PixelType PixelType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]; PixelType expected(count, count + largestRegion[0] * largestRegion[1] ); if ( !TestCompare( it.GetIndex(), it.Get(), expected ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMultibandScalarToImageComplexFloat(int argc, char * argv[]) { return otbMultibandScalarToImageComplexGeneric(argc, argv); } int otbMultibandScalarToImageComplexDouble(int argc, char * argv[]) { return otbMultibandScalarToImageComplexGeneric(argc, argv); } int otbMultibandScalarToImageComplexInt(int argc, char * argv[]) { return otbMultibandScalarToImageComplexGeneric(argc, argv); } int otbMultibandScalarToImageComplexShort(int argc, char * argv[]) { return otbMultibandScalarToImageComplexGeneric(argc, argv); } /*********** * 7. * Read Multiband Scalar as VectorImage * out : (out[0].real=in[0], out[0].imag=0), (out[1].real=in[1], out[1].imag=0), ... ***********/ template int otbMultibandScalarToVectorImageComplexGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef std::complex ComplexType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType PixelType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]; PixelType expected(2); expected[0] = ComplexType(count, 0); expected[1] = ComplexType(count + largestRegion[0] * largestRegion[1], 0); if ( !TestCompare( it.GetIndex(), it.Get(), expected ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMultibandScalarToVectorImageComplexFloat(int argc, char * argv[]) { return otbMultibandScalarToVectorImageComplexGeneric(argc, argv); } int otbMultibandScalarToVectorImageComplexDouble(int argc, char * argv[]) { return otbMultibandScalarToVectorImageComplexGeneric(argc, argv); } int otbMultibandScalarToVectorImageComplexInt(int argc, char * argv[]) { return otbMultibandScalarToVectorImageComplexGeneric(argc, argv); } int otbMultibandScalarToVectorImageComplexShort(int argc, char * argv[]) { return otbMultibandScalarToVectorImageComplexGeneric(argc, argv); } /*********** * 8. * Read Multiband Complex as VectorImage * out : out[0]=in[0].real, out[1]=in[0].imag, out[2]=in[0].real, out[3]=in[0].imag, ... ***********/ template int otbMultibandComplexToVectorImageScalarGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType PixelType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); const unsigned int nbbands = image->GetNumberOfComponentsPerPixel(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = 2 * (it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]); PixelType expected(nbbands); for (unsigned int band = 0; band < nbbands; band += 2 ) { expected[band] = count + band * largestRegion[0] * largestRegion[1]; expected[band + 1] = count + 1 + band * largestRegion[0] * largestRegion[1]; } if ( !TestCompare( it.GetIndex(), it.Get(), expected ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMultibandComplexToVectorImageScalarFloat(int argc, char * argv[]) { return otbMultibandComplexToVectorImageScalarGeneric(argc, argv); } int otbMultibandComplexToVectorImageScalarDouble(int argc, char * argv[]) { return otbMultibandComplexToVectorImageScalarGeneric(argc, argv); } int otbMultibandComplexToVectorImageScalarInt(int argc, char * argv[]) { return otbMultibandComplexToVectorImageScalarGeneric(argc, argv); } int otbMultibandComplexToVectorImageScalarShort(int argc, char * argv[]) { return otbMultibandComplexToVectorImageScalarGeneric(argc, argv); } /*********** * 9. * Read Multiband Complex as VectorImage * out : out[0]=in[0], out[1]=in[1], ... ***********/ template int otbMultibandComplexToVectorImageComplexGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef std::complex ComplexType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType PixelType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); const unsigned int nbbands = image->GetNumberOfComponentsPerPixel(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = 2 * (it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]); PixelType expected(nbbands); for (unsigned int band = 0; band < nbbands; ++band ) { expected[band] = ComplexType(count + band * 2 * largestRegion[0] * largestRegion[1], count + 1 + band * 2 * largestRegion[0] * largestRegion[1]); } if ( !TestCompare( it.GetIndex(), it.Get(), expected ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMultibandComplexToVectorImageComplexFloat(int argc, char * argv[]) { return otbMultibandComplexToVectorImageComplexGeneric(argc, argv); } int otbMultibandComplexToVectorImageComplexDouble(int argc, char * argv[]) { return otbMultibandComplexToVectorImageComplexGeneric(argc, argv); } int otbMultibandComplexToVectorImageComplexShort(int argc, char * argv[]) { return otbMultibandComplexToVectorImageComplexGeneric(argc, argv); } int otbMultibandComplexToVectorImageComplexInt(int argc, char * argv[]) { return otbMultibandComplexToVectorImageComplexGeneric(argc, argv); } /*********** * 10. * Read Monoband Scalar as VectorImage * out : out[0].real=in, out[0].imag=0 ***********/ template int otbMonobandScalarToVectorImageComplexGeneric(int itkNotUsed(argc), char * argv[]) { typedef InternalType RealType; typedef std::complex ComplexType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType PixelType; const unsigned int w = 10; const unsigned int h = 2; typename ImageType::Pointer image; itk::ImageRegionIteratorWithIndex it = ReadRegion(argv[1], image, w, h); typename ImageType::SizeType largestRegion; largestRegion = image->GetLargestPossibleRegion().GetSize(); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd(); ++it) { count = it.GetIndex()[1] * largestRegion[0] + it.GetIndex()[0]; PixelType expected(1); expected[0] = ComplexType(count, 0); if ( !TestCompare( it.GetIndex(), it.Get(), expected ) ) return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbMonobandScalarToVectorImageComplexFloat(int argc, char * argv[]) { return otbMonobandScalarToVectorImageComplexGeneric(argc, argv); } int otbMonobandScalarToVectorImageComplexDouble(int argc, char * argv[]) { return otbMonobandScalarToVectorImageComplexGeneric(argc, argv); } int otbMonobandScalarToVectorImageComplexShort(int argc, char * argv[]) { return otbMonobandScalarToVectorImageComplexGeneric(argc, argv); } int otbMonobandScalarToVectorImageComplexInt(int argc, char * argv[]) { return otbMonobandScalarToVectorImageComplexGeneric(argc, argv); } /*********** * 11. * Read MultibandComplex as Image * out : ??? ***********/ template int otbMultibandComplexToImageScalarGeneric(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // This case is not handled yet. // We need more time to decide what we want to do with this case. ( perhaps return exception ???) std::cout << "This case is not handled yet." \ << "Need specification : throw exception ?" \ << std::endl; return EXIT_FAILURE; } int otbMultibandComplexToImageScalarFloat(int argc, char * argv[]) { return otbMultibandComplexToImageScalarGeneric(argc, argv); } int otbMultibandComplexToImageScalarDouble(int argc, char * argv[]) { return otbMultibandComplexToImageScalarGeneric(argc, argv); } int otbMultibandComplexToImageScalarShort(int argc, char * argv[]) { return otbMultibandComplexToImageScalarGeneric(argc, argv); } int otbMultibandComplexToImageScalarInt(int argc, char * argv[]) { return otbMultibandComplexToImageScalarGeneric(argc, argv); } OTB-release-5.8/Modules/IO/ImageIO/test/otbComplexImageTests.cxx000066400000000000000000000127311301006202600244200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" int otbVectorImageComplexNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef std::complex PixelType; typedef otb::VectorImage ImageType; ImageType::Pointer image = ImageType::New(); image->Initialize(); return EXIT_SUCCESS; } template int otbVectorImageComplexGenericTest(int itkNotUsed(argc), char* argv[]) { typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typename ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); std::cout << reader->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; otb::ImageIOBase::Pointer io = reader->GetImageIO(); std::cout << io << std::endl; reader->Update(); typename ImageType::IndexType index; index[0]=0; index[1]=0; typename ImageType::PixelType pixel = reader->GetOutput()->GetPixel(index); std::cout << pixel << std::endl; //Test value if ((pixel[0] != PixelType(0, 1)) || (pixel[1] != PixelType(20000, 20001))) { std::cout << "Found " << pixel[0] << " should be " << PixelType(0, 1) << std::endl; std::cout << "Found " << pixel[1] << " should be " << PixelType(20000, 20001) << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbVectorImageComplexFloatTest(int argc, char* argv[]) { return otbVectorImageComplexGenericTest(argc, argv); } int otbVectorImageComplexDoubleTest(int argc, char* argv[]) { return otbVectorImageComplexGenericTest(argc, argv); } template int otbImageComplexGenericTest(int itkNotUsed(argc), char* argv[]) { typedef std::complex PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typename ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); std::cout << reader->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; otb::ImageIOBase::Pointer io = reader->GetImageIO(); std::cout << io << std::endl; reader->Update(); typename ImageType::IndexType index; index[0]=0; index[1]=0; typename ImageType::PixelType pixel = reader->GetOutput()->GetPixel(index); std::cout << pixel << std::endl; //Test value if (pixel != PixelType(0, 1)) { std::cout << "Found " << pixel << " should be " << PixelType(0, 1) << std::endl; return EXIT_FAILURE; } //Test other pixel index[0]=10; index[1]=10; pixel = reader->GetOutput()->GetPixel(index); std::cout << pixel << std::endl; if (pixel != PixelType(1010, 1011)) { std::cout << "Found " << pixel << " should be " << PixelType(1010, 1011) << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbImageComplexFloatTest(int argc, char* argv[]) { return otbImageComplexGenericTest(argc, argv); } int otbImageComplexDoubleTest(int argc, char* argv[]) { return otbImageComplexGenericTest(argc, argv); } template int otbVectorImageComplexIntoRealGenericTest(int itkNotUsed(argc), char* argv[]) { typedef InternalType PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typename ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); std::cout << reader->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl; otb::ImageIOBase::Pointer io = reader->GetImageIO(); std::cout << io << std::endl; reader->Update(); typename ImageType::IndexType index; index[0]=0; index[1]=0; typename ImageType::PixelType pixel = reader->GetOutput()->GetPixel(index); std::cout << pixel << std::endl; //Test value if (reader->GetOutput()->GetNumberOfComponentsPerPixel() != 4) { std::cout << reader->GetOutput()->GetNumberOfComponentsPerPixel() << " bands instead of 4" << std::endl; return EXIT_FAILURE; } if ((pixel[0] != 0) || (pixel[1] != 1) || (pixel[2] != 20000) || (pixel[3] != 20001)) { std::cout << "Found " << pixel[0] << " should be " << 0 << std::endl; std::cout << "Found " << pixel[1] << " should be " << 1 << std::endl; std::cout << "Found " << pixel[2] << " should be " << 20000 << std::endl; std::cout << "Found " << pixel[3] << " should be " << 20001 << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbVectorImageComplexIntoRealFloatTest(int argc, char* argv[]) { return otbVectorImageComplexIntoRealGenericTest(argc, argv); } int otbVectorImageComplexIntoRealDoubleTest(int argc, char* argv[]) { return otbVectorImageComplexIntoRealGenericTest(argc, argv); } OTB-release-5.8/Modules/IO/ImageIO/test/otbDoubleImageIOTest.cxx000066400000000000000000000027541301006202600242740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbDoubleImageIOTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbFloatImageIOTest.cxx000066400000000000000000000027511301006202600241240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbFloatImageIOTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef float InputPixelType; typedef float OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbGDALDriverDoubleWritingTest.cxx000066400000000000000000000036751301006202600262540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" int otbGDALDriverDoubleWritingTest(int itkNotUsed(argc), char * argv[]) { const char * infname1 = argv[1]; const char * infname2 = argv[2]; const char * outfname1 = argv[3]; const char * outfname2 = argv[4]; const char * outfname3 = argv[5]; const char * outfname4 = argv[6]; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter StreamingWriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); StreamingWriterType::Pointer streamingWriter = StreamingWriterType::New(); reader->SetFileName(infname1); writer->SetFileName(outfname1); writer->SetInput(reader->GetOutput()); writer->Update(); reader->SetFileName(infname2); writer->SetFileName(outfname2); writer->Update(); reader->SetFileName(infname1); streamingWriter->SetFileName(outfname3); streamingWriter->SetInput(reader->GetOutput()); streamingWriter->Update(); reader->SetFileName(infname2); streamingWriter->SetFileName(outfname4); streamingWriter->SetInput(reader->GetOutput()); streamingWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderMSTAR.cxx000066400000000000000000000071531301006202600246010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkImageRegionIterator.h" #include "itkRescaleIntensityImageFilter.h" int otbImageFileReaderMSTAR(int itkNotUsed(argc), char* argv[]) { typedef float InputPixelType; typedef unsigned char OutputPixelType; const unsigned int InputDimension = 2; typedef otb::Image, InputDimension> InputImageType; typedef otb::Image InternalImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->Update(); typedef itk::ImageRegionConstIterator ConstIteratorType; typedef itk::ImageRegionIterator IteratorType; InputImageType::RegionType inputRegion; InputImageType::RegionType::IndexType inputStart; InputImageType::RegionType::SizeType size; inputStart[0] = 0; inputStart[1] = 0; size[0] = reader->GetOutput()->GetLargestPossibleRegion().GetSize()[0]; size[1] = reader->GetOutput()->GetLargestPossibleRegion().GetSize()[1]; inputRegion.SetSize(size); inputRegion.SetIndex(inputStart); InternalImageType::RegionType outputRegion; InternalImageType::RegionType::IndexType outputStart; outputStart[0] = 0; outputStart[1] = 0; outputRegion.SetSize(size); outputRegion.SetIndex(outputStart); InternalImageType::Pointer magnitude = InternalImageType::New(); magnitude->SetRegions(inputRegion); const InternalImageType::SpacingType& spacing = reader->GetOutput()->GetSpacing(); const InternalImageType::PointType& inputOrigin = reader->GetOutput()->GetOrigin(); double outputOrigin[InputDimension]; for (unsigned int i = 0; i < InputDimension; ++i) { outputOrigin[i] = inputOrigin[i] + spacing[i] * inputStart[i]; } magnitude->SetSpacing(spacing); magnitude->SetOrigin(outputOrigin); magnitude->Allocate(); ConstIteratorType inputIt(reader->GetOutput(), inputRegion); IteratorType outputIt(magnitude, outputRegion); for (inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt) { outputIt.Set(inputIt.Get()[0]); // std::cout << inputIt.Get()[0] << " - " << inputIt.Get()[1] << std::endl; } typedef itk::RescaleIntensityImageFilter RescalerType; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(itk::NumericTraits::min()); rescaler->SetOutputMaximum(itk::NumericTraits::max()); rescaler->SetInput(magnitude); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(rescaler->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderONERA.cxx000066400000000000000000000037041301006202600245550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" int otbImageFileReaderONERATest(int argc, char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef float InputPixelType; typedef float OutputPixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelExtractROI ExtractROIFilterType; ReaderType::Pointer reader = ReaderType::New(); ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); if (argc == 7) { extractROIFilter->SetStartX(atoi(argv[3])); extractROIFilter->SetStartY(atoi(argv[4])); extractROIFilter->SetSizeX(atoi(argv[5])); extractROIFilter->SetSizeY(atoi(argv[6])); extractROIFilter->SetInput(reader->GetOutput()); writer->SetInput(extractROIFilter->GetOutput()); } else if (argc == 3) { writer->SetInput(reader->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderONERAComplex.cxx000066400000000000000000000051321301006202600261020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkUnaryFunctorImageFilter.h" #include "itkComplexToRealImageFilter.h" #include "itkComplexToImaginaryImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbImageFileReaderONERAComplex(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputRealFilename = argv[2]; const char * outputImagFilename = argv[3]; typedef std::complex InputPixelType; typedef float OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer Reader = ReaderType::New(); Reader->SetFileName(inputFilename); typedef otb::ExtractROI ExtractROIFilterType; ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); extractROIFilter->SetStartX(10); extractROIFilter->SetStartY(10); extractROIFilter->SetSizeX(100); extractROIFilter->SetSizeY(100); extractROIFilter->SetInput(Reader->GetOutput()); typedef itk::ComplexToRealImageFilter< InputImageType, OutputImageType> RealFilterType; typedef itk::ComplexToImaginaryImageFilter< InputImageType, OutputImageType> ImagFilterType; RealFilterType::Pointer realFilter = RealFilterType::New(); realFilter->SetInput(extractROIFilter->GetOutput()); ImagFilterType::Pointer imagFilter = ImagFilterType::New(); imagFilter->SetInput(extractROIFilter->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputRealFilename); writer->SetInput(realFilter->GetOutput()); writer->Update(); writer = WriterType::New(); writer->SetFileName(outputImagFilename); writer->SetInput(imagFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRADChar.cxx000066400000000000000000000032041301006202600251100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbImageFileReaderRADChar(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef char InputPixelType; typedef char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; /* typedef otb::VectorImage< InputPixelType, Dimension > InputImageType; typedef otb::VectorImage< OutputPixelType, Dimension > OutputImageType; */ ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRADComplexDouble.cxx000066400000000000000000000030041301006202600267730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbImageFileReaderRADComplexDouble(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRADComplexFloat.cxx000066400000000000000000000030011301006202600266230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbImageFileReaderRADComplexFloat(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRADComplexFloatExtract.cxx000066400000000000000000000043311301006202600301650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "otbComplexToVectorImageCastFilter.h" int otbImageFileReaderRADComplexFloatExtract(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputCplxImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ComplexToVectorImageCastFilter CasterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); CasterType::Pointer caster = CasterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); typedef otb::ExtractROI ExtractROIFilterType; ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); extractROIFilter->SetInput(reader->GetOutput()); extractROIFilter->SetStartX(10); extractROIFilter->SetStartY(10); extractROIFilter->SetSizeX(100); extractROIFilter->SetSizeY(100); caster->SetInput(extractROIFilter->GetOutput()); writer->SetInput(caster->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRADComplexInt.cxx000066400000000000000000000027731301006202600263270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbImageFileReaderRADComplexInt(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef std::complex InputPixelType; typedef std::complex OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRADFloat.cxx000066400000000000000000000027601301006202600253060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileReaderRADFloat(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef float InputPixelType; typedef float OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRADInt.cxx000066400000000000000000000027301301006202600247700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbImageFileReaderRADInt(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef int InputPixelType; typedef int OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderRGBTest.cxx000066400000000000000000000030651301006202600251630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "itkRGBPixel.h" #include "itkMacro.h" #include int otbImageFileReaderRGBTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef itk::RGBPixel InputPixelType; typedef itk::RGBPixel OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderServerName.cxx000066400000000000000000000025111301006202600257530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" int otbImageFileReaderServerName(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; typedef unsigned char InputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->GenerateOutputInformation(); if (reader->GetOutput()->GetImageKeywordlist().GetSize() == 0) { std::cerr << "Error: Keyword list is empty " << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderTest.cxx000066400000000000000000000027711301006202600246330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileReaderTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderTestFloat.cxx000066400000000000000000000027611301006202600256200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileReaderTestFloat(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef float InputPixelType; typedef float OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileReaderWithComplexPixel.cxx000066400000000000000000000072311301006202600271550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "otbMultiChannelExtractROI.h" int otbImageFileReaderWithComplexPixelTest(int argc, char* argv[]) { if (argc < 7) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int startX = (unsigned int)(::atoi(argv[3])); unsigned int startY = (unsigned int)(::atoi(argv[4])); unsigned int sizeX = (unsigned int)(::atoi(argv[5])); unsigned int sizeY = (unsigned int)(::atoi(argv[6])); typedef std::complex PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer complexReader = ReaderType::New(); complexReader->SetFileName(inputFilename); typedef otb::ExtractROI ExtractROIFilterType; ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); extractROIFilter->SetStartX(startX); extractROIFilter->SetStartY(startY); extractROIFilter->SetSizeX(sizeX); extractROIFilter->SetSizeY(sizeY); extractROIFilter->SetInput(complexReader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(extractROIFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbVectorImageFileReaderWithComplexPixelTest(int argc, char* argv[]) { if (argc < 7) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int startX = (unsigned int)(::atoi(argv[3])); unsigned int startY = (unsigned int)(::atoi(argv[4])); unsigned int sizeX = (unsigned int)(::atoi(argv[5])); unsigned int sizeY = (unsigned int)(::atoi(argv[6])); typedef std::complex PixelType; const unsigned int Dimension = 2; typedef otb::VectorImage CplVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelExtractROI ExtractROIFilterType; ReaderType::Pointer complexReader = ReaderType::New(); complexReader->SetFileName(inputFilename); ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); extractROIFilter->SetStartX(startX); extractROIFilter->SetStartY(startY); extractROIFilter->SetSizeX(sizeX); extractROIFilter->SetSizeY(sizeY); extractROIFilter->SetInput(complexReader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(extractROIFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileWriterONERAComplex.cxx000066400000000000000000000036311301006202600261560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" int otbImageFileWriterONERAComplex(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef std::complex PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ExtractROI ExtractROIFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer complexReader = ReaderType::New(); ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); WriterType::Pointer complexWriter = WriterType::New(); // Reader Parameters complexReader->SetFileName(inputFilename); // Extract ROI Parameters extractROIFilter->SetStartX(20); extractROIFilter->SetStartY(20); extractROIFilter->SetSizeX(100); extractROIFilter->SetSizeY(100); extractROIFilter->SetInput(complexReader->GetOutput()); extractROIFilter->Update(); // Writer Parameters complexWriter->SetFileName(outputFilename); complexWriter->SetInput(extractROIFilter->GetOutput()); // Update the pipeline and Write the data complexWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileWriterRGBTest.cxx000066400000000000000000000030661301006202600252360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkRGBPixel.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileWriterRGBTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef itk::RGBPixel InputPixelType; typedef itk::RGBPixel OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileWriterStreamingONERAComplex.cxx000066400000000000000000000031751301006202600300330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "itkUnaryFunctorImageFilter.h" #include "itkComplexToModulusImageFilter.h" #include "itkStreamingImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileWriterStreamingONERAComplex(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef std::complex PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer complexReader = ReaderType::New(); WriterType::Pointer complexWriter = WriterType::New(); complexReader->SetFileName(inputFilename); complexWriter->SetNumberOfDivisionsStrippedStreaming(100); complexWriter->SetFileName(outputFilename); complexWriter->SetInput(complexReader->GetOutput()); complexWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileWriterTest.cxx000066400000000000000000000027741301006202600247100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileWriterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageFileWriterTestWithoutInput.cxx000066400000000000000000000131511301006202600273030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkMacro.h" #include "itkImageRegionIterator.h" /*********** * 1. * Write Image with an ImageFileWriter ***********/ template int otbImageScalarFileWriterTestWithoutInputGeneric(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * outputFilename = argv[1]; typedef InternalType PixelType; typedef otb::Image ImageType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; typename ImageType::Pointer image = ImageType::New(); typename WriterType::Pointer writer = WriterType::New(); SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); RegionType region; region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->Allocate(); // Fill to zero values image->FillBuffer(static_cast(0)); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { it.Set(static_cast (size[0] * it.GetIndex()[1] + it.GetIndex()[0])); ++it; } writer->SetFileName(outputFilename); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } int otbImageScalarFileWriterTestWithoutInputShort(int argc, char * argv[]) { return otbImageScalarFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageScalarFileWriterTestWithoutInputInt(int argc, char * argv[]) { return otbImageScalarFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageScalarFileWriterTestWithoutInputFloat(int argc, char * argv[]) { return otbImageScalarFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageScalarFileWriterTestWithoutInputDouble(int argc, char * argv[]) { return otbImageScalarFileWriterTestWithoutInputGeneric(argc, argv); } /*********** * 1. * Write Image with an ImageFileWriter ***********/ template int otbImageComplexFileWriterTestWithoutInputGeneric(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * outputFilename = argv[1]; typedef std::complex PixelType; typedef otb::Image ImageType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; typename ImageType::Pointer image = ImageType::New(); typename WriterType::Pointer writer = WriterType::New(); SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); RegionType region; region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->Allocate(); // Fill to zero values image->FillBuffer(static_cast(0)); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); typedef typename itk::NumericTraits::ScalarRealType ScalarRealType; while (!it.IsAtEnd()) { ScalarRealType realPart = 2*(size[0] * it.GetIndex()[1] + it.GetIndex()[0]); ScalarRealType imagPart = 2*(size[0] * it.GetIndex()[1] + it.GetIndex()[0]) +1; PixelType pixelVal (realPart, imagPart); //std::cout << "pixelVal = " << pixelVal < InputImageType; typedef otb::MultiChannelExtractROI ExtractROIFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::ImageRegionConstIterator< InputImageType > ConstIteratorType; ReaderType::Pointer reader = ReaderType::New(); ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); //Build output filename with extended box std::ostringstream outputFilenameExtended; outputFilenameExtended << outputFilename << "?&box=" << startx << separator << starty << separator << sizex << separator << sizey ; std::cout << "Output image with user defined path " << outputFilenameExtended.str() << std::endl; writer->SetFileName(outputFilenameExtended.str()); writer->SetInput(reader->GetOutput()); writer->SetAutomaticAdaptativeStreaming(ram); extractROIFilter->SetStartX(startx); extractROIFilter->SetStartY(starty); extractROIFilter->SetSizeX(sizex); extractROIFilter->SetSizeY(sizey); extractROIFilter->SetInput(reader->GetOutput()); writer->Update(); extractROIFilter->Update(); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(outputFilename); reader2->Update(); InputImageType::ConstPointer readImage = reader2->GetOutput(); InputImageType::ConstPointer extractImage = extractROIFilter->GetOutput(); ConstIteratorType ritr( readImage, readImage->GetLargestPossibleRegion() ); ConstIteratorType extractitr( extractImage, extractImage->GetLargestPossibleRegion() ); ritr.GoToBegin(); extractitr.GoToBegin(); std::cout << "Comparing the pixel values.. :" << std::endl; while( !ritr.IsAtEnd() && !extractitr.IsAtEnd() ) { if( ritr.Get() != extractitr.Get() ) { std::cerr << "Pixel comparison failed at index = " << ritr.GetIndex() << std::endl; std::cerr << "Expected pixel value " << extractitr.Get() << std::endl; std::cerr << "Read Image pixel value " << ritr.Get() << std::endl; return EXIT_FAILURE; } ++extractitr; ++ritr; } std::cout << std::endl; std::cout << "Test PASSED !" << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageIOFactoryNew.cxx000066400000000000000000000015361301006202600243000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageIOFactory.h" #include "itkMacro.h" #include int otbImageIOFactoryNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::ImageIOFactory *lImageIOFactory; lImageIOFactory = ITK_NULLPTR; return lImageIOFactory != ITK_NULLPTR; //to avoid unused variable warning } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageIOTestDriver.cxx000066400000000000000000000166241301006202600243160ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbImageFileWriterWithExtendedOptionBox); REGISTER_TEST(otbImageFileReaderONERAComplex); REGISTER_TEST(otbImageFileReaderRADComplexFloat); REGISTER_TEST(otbShortRGBImageIOTest); REGISTER_TEST(otbPipelineMetadataHandlingWithUFFilterTest); REGISTER_TEST(otbImageMetadataFileWriterTest); REGISTER_TEST(otbImageScalarFileWriterTestWithoutInputShort); REGISTER_TEST(otbImageScalarFileWriterTestWithoutInputInt); REGISTER_TEST(otbImageScalarFileWriterTestWithoutInputFloat); REGISTER_TEST(otbImageScalarFileWriterTestWithoutInputDouble); REGISTER_TEST(otbImageComplexFileWriterTestWithoutInputShort); REGISTER_TEST(otbImageComplexFileWriterTestWithoutInputInt); REGISTER_TEST(otbImageComplexFileWriterTestWithoutInputFloat); REGISTER_TEST(otbImageComplexFileWriterTestWithoutInputDouble); REGISTER_TEST(otbVectorImageStreamingFileWriterScalarTestWithoutInputShort); REGISTER_TEST(otbVectorImageStreamingFileWriterScalarTestWithoutInputInt); REGISTER_TEST(otbVectorImageStreamingFileWriterScalarTestWithoutInputFloat); REGISTER_TEST(otbVectorImageStreamingFileWriterScalarTestWithoutInputDouble); REGISTER_TEST(otbVectorImageStreamingFileWriterComplexTestWithoutInputShort); REGISTER_TEST(otbVectorImageStreamingFileWriterComplexTestWithoutInputInt); REGISTER_TEST(otbVectorImageStreamingFileWriterComplexTestWithoutInputFloat); REGISTER_TEST(otbVectorImageStreamingFileWriterComplexTestWithoutInputDouble); REGISTER_TEST(otbReadingComplexDataIntoComplexImageTest); REGISTER_TEST(otbImageFileReaderRADInt); REGISTER_TEST(otbImageFileReaderRGBTest); REGISTER_TEST(otbImageMetadataStreamingFileWriterTest); REGISTER_TEST(otbFloatImageIOTest); REGISTER_TEST(otbImageFileReaderMSTAR); REGISTER_TEST(otbGDALDriverDoubleWritingTest); REGISTER_TEST(otbDoubleImageIOTest); REGISTER_TEST(otbImageFileWriterTestCalculateNumberOfDivisions); REGISTER_TEST(otbImageFileReaderRADComplexFloatExtract); REGISTER_TEST(otbImageFileReaderRADComplexInt); REGISTER_TEST(otbImageScalarStreamingFileWriterTestWithoutInputShort); REGISTER_TEST(otbImageScalarStreamingFileWriterTestWithoutInputInt); REGISTER_TEST(otbImageScalarStreamingFileWriterTestWithoutInputFloat); REGISTER_TEST(otbImageScalarStreamingFileWriterTestWithoutInputDouble); REGISTER_TEST(otbImageComplexStreamingFileWriterTestWithoutInputShort); REGISTER_TEST(otbImageComplexStreamingFileWriterTestWithoutInputInt); REGISTER_TEST(otbImageComplexStreamingFileWriterTestWithoutInputFloat); REGISTER_TEST(otbImageComplexStreamingFileWriterTestWithoutInputDouble); REGISTER_TEST(otbScalarBufferToImageFileWriterTest); REGISTER_TEST(otbImageFileWriterONERAComplex); REGISTER_TEST(otbPipelineMetadataHandlingTest); REGISTER_TEST(otbMultiResolutionReadingInfo); REGISTER_TEST(otbImageFileReaderTestFloat); REGISTER_TEST(otbVectorImageComplexNew); REGISTER_TEST(otbVectorImageComplexFloatTest); REGISTER_TEST(otbVectorImageComplexDoubleTest); REGISTER_TEST(otbImageComplexFloatTest); REGISTER_TEST(otbImageComplexDoubleTest); REGISTER_TEST(otbVectorImageComplexIntoRealFloatTest); REGISTER_TEST(otbVectorImageComplexIntoRealDoubleTest); REGISTER_TEST(otbImageFileReaderRADChar); REGISTER_TEST(otbScalarBufferToImageFileWriterNew); REGISTER_TEST(otbShortImageIOTest); REGISTER_TEST(otbImageSeriesFileReader); REGISTER_TEST(otbStreamingShortImageFileWriterTest); REGISTER_TEST(otbImageFileWriterStreamingONERAComplex); REGISTER_TEST(otbImageFileReaderWithComplexPixelTest); REGISTER_TEST(otbVectorImageFileReaderWithComplexPixelTest); REGISTER_TEST(otbImageFileReaderRADFloat); REGISTER_TEST(otbVectorImageFileReaderWriterTest); REGISTER_TEST(otbIntImageIOTest); REGISTER_TEST(otbImageFileReaderONERATest); REGISTER_TEST(otbImageFileReaderServerName); REGISTER_TEST(otbPNGIndexedNbBandsTest); REGISTER_TEST(otbImageFileReaderTest); REGISTER_TEST(otbVectorImageFileWriterScalarTestWithoutInputShort); REGISTER_TEST(otbVectorImageFileWriterScalarTestWithoutInputInt); REGISTER_TEST(otbVectorImageFileWriterScalarTestWithoutInputFloat); REGISTER_TEST(otbVectorImageFileWriterScalarTestWithoutInputDouble); REGISTER_TEST(otbVectorImageFileWriterComplexTestWithoutInputShort); REGISTER_TEST(otbVectorImageFileWriterComplexTestWithoutInputInt); REGISTER_TEST(otbVectorImageFileWriterComplexTestWithoutInputFloat); REGISTER_TEST(otbVectorImageFileWriterComplexTestWithoutInputDouble); REGISTER_TEST(otbWritingComplexDataWithComplexImageTest); REGISTER_TEST(otbImageFileWriterWithFilterTest); REGISTER_TEST(otbImageFileReaderRADComplexDouble); REGISTER_TEST(otbPipeline); REGISTER_TEST(otbStreamingImageFilterTest); REGISTER_TEST(otbStreamingImageFileWriterTest); REGISTER_TEST(otbImageFileWriterRGBTest); REGISTER_TEST(otbMonobandScalarToImageComplexFloat); REGISTER_TEST(otbMonobandScalarToImageComplexDouble); REGISTER_TEST(otbMonobandScalarToImageComplexInt); REGISTER_TEST(otbMonobandScalarToImageComplexShort); REGISTER_TEST(otbMonobandComplexToImageScalarFloat); REGISTER_TEST(otbMonobandComplexToImageScalarDouble); REGISTER_TEST(otbMonobandComplexToImageScalarInt); REGISTER_TEST(otbMonobandComplexToImageScalarShort); REGISTER_TEST(otbMonobandComplexToImageComplexFloat); REGISTER_TEST(otbMonobandComplexToImageComplexDouble); REGISTER_TEST(otbMonobandComplexToImageComplexInt); REGISTER_TEST(otbMonobandComplexToImageComplexShort); REGISTER_TEST(otbMonobandComplexToVectorImageScalarFloat); REGISTER_TEST(otbMonobandComplexToVectorImageScalarDouble); REGISTER_TEST(otbMonobandComplexToVectorImageScalarInt); REGISTER_TEST(otbMonobandComplexToVectorImageScalarShort); REGISTER_TEST(otbMonobandComplexToVectorImageComplexFloat); REGISTER_TEST(otbMonobandComplexToVectorImageComplexDouble); REGISTER_TEST(otbMonobandComplexToVectorImageComplexInt); REGISTER_TEST(otbMonobandComplexToVectorImageComplexShort); REGISTER_TEST(otbMultibandScalarToImageComplexFloat); REGISTER_TEST(otbMultibandScalarToImageComplexDouble); REGISTER_TEST(otbMultibandScalarToImageComplexInt); REGISTER_TEST(otbMultibandScalarToImageComplexShort); REGISTER_TEST(otbMultibandScalarToVectorImageComplexFloat); REGISTER_TEST(otbMultibandScalarToVectorImageComplexDouble); REGISTER_TEST(otbMultibandScalarToVectorImageComplexInt); REGISTER_TEST(otbMultibandScalarToVectorImageComplexShort); REGISTER_TEST(otbMultibandComplexToVectorImageScalarFloat); REGISTER_TEST(otbMultibandComplexToVectorImageScalarDouble); REGISTER_TEST(otbMultibandComplexToVectorImageScalarInt); REGISTER_TEST(otbMultibandComplexToVectorImageScalarShort); REGISTER_TEST(otbMultibandComplexToVectorImageComplexFloat); REGISTER_TEST(otbMultibandComplexToVectorImageComplexDouble); REGISTER_TEST(otbMultibandComplexToVectorImageComplexShort); REGISTER_TEST(otbMultibandComplexToVectorImageComplexInt); REGISTER_TEST(otbMonobandScalarToVectorImageComplexFloat); REGISTER_TEST(otbMonobandScalarToVectorImageComplexDouble); REGISTER_TEST(otbMonobandScalarToVectorImageComplexShort); REGISTER_TEST(otbMonobandScalarToVectorImageComplexInt); REGISTER_TEST(otbMultibandComplexToImageScalarFloat); REGISTER_TEST(otbMultibandComplexToImageScalarDouble); REGISTER_TEST(otbMultibandComplexToImageScalarShort); REGISTER_TEST(otbMultibandComplexToImageScalarInt); REGISTER_TEST(otbImageFileWriterTest); REGISTER_TEST(otbImageIOFactoryNew); REGISTER_TEST(otbCompareWritingComplexImageTest); } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageMetadataFileWriterTest.cxx000066400000000000000000000030261301006202600263400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageMetadataFileWriterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageMetadataStreamingFileWriterTest.cxx000066400000000000000000000030501301006202600302070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageMetadataStreamingFileWriterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageSeriesFileReader.cxx000066400000000000000000000044321301006202600251420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Mines-Telecom. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageList.h" #include "otbImageSeriesFileReader.h" #include "otbImageFileWriter.h" #include "itksys/SystemTools.hxx" int otbImageSeriesFileReader(int itkNotUsed(argc), char* argv[]) { const char * enviMetaFile = argv[1]; const char * outputFile = argv[2]; const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageList ImageListType; typedef otb::ImageSeriesFileReader ImageReader; ImageReader::Pointer reader = ImageReader::New(); reader->SetFileName(enviMetaFile); reader->Update(); std::cout << reader << std::endl; ImageListType * imageList = reader->GetOutput(); typedef otb::ImageFileWriter WriterType; for (unsigned int i = 0; i < imageList->Size(); ++i) { std::cout << "Image no " << i << "\n"; std::string path = itksys::SystemTools::GetFilenamePath(outputFile); std::string name = itksys::SystemTools::GetFilenameWithoutExtension(outputFile); std::string ext = itksys::SystemTools::GetFilenameExtension(outputFile); std::stringstream outputFilenameStream; outputFilenameStream << path << "/" << name << "-" << i << ext; std::string outputFilename = itksys::SystemTools::ConvertToOutputPath( outputFilenameStream.str().c_str()); std::cout << "saved in " << outputFilename << "\n"; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput(i)); writer->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbImageStreamingFileWriterTestWithoutInput.cxx000066400000000000000000000136171301006202600311640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "itkMacro.h" #include "itkImageRegionIterator.h" /*********** * 1. * Write Image with an ImageFileWriter ***********/ template int otbImageScalarStreamingFileWriterTestWithoutInputGeneric(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * outputFilename = argv[1]; typedef InternalType PixelType; typedef otb::Image ImageType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; typename ImageType::Pointer image = ImageType::New(); typename WriterType::Pointer writer = WriterType::New(); SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); RegionType region; region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->Allocate(); // Fill to zero values image->FillBuffer(static_cast(0)); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { it.Set(static_cast (size[0] * it.GetIndex()[1] + it.GetIndex()[0])); ++it; } writer->SetFileName(outputFilename); writer->SetNumberOfDivisionsStrippedStreaming(10); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } int otbImageScalarStreamingFileWriterTestWithoutInputShort(int argc, char * argv[]) { return otbImageScalarStreamingFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageScalarStreamingFileWriterTestWithoutInputInt(int argc, char * argv[]) { return otbImageScalarStreamingFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageScalarStreamingFileWriterTestWithoutInputFloat(int argc, char * argv[]) { return otbImageScalarStreamingFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageScalarStreamingFileWriterTestWithoutInputDouble(int argc, char * argv[]) { return otbImageScalarStreamingFileWriterTestWithoutInputGeneric(argc, argv); } /*********** * 1. * Write Image with an ImageFileWriter ***********/ template int otbImageComplexStreamingFileWriterTestWithoutInputGeneric(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * outputFilename = argv[1]; typedef std::complex PixelType; typedef otb::Image ImageType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; typename ImageType::Pointer image = ImageType::New(); typename WriterType::Pointer writer = WriterType::New(); SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); RegionType region; region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->Allocate(); // Fill to zero values image->FillBuffer(static_cast(0)); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); typedef typename itk::NumericTraits::ScalarRealType ScalarRealType; while (!it.IsAtEnd()) { ScalarRealType realPart = 2*(size[0] * it.GetIndex()[1] + it.GetIndex()[0]); ScalarRealType imagPart = 2*(size[0] * it.GetIndex()[1] + it.GetIndex()[0]) +1; PixelType pixelVal (realPart, imagPart); it.Set(pixelVal); ++it; } writer->SetFileName(outputFilename); writer->SetNumberOfDivisionsStrippedStreaming(10); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } int otbImageComplexStreamingFileWriterTestWithoutInputShort(int argc, char * argv[]) { return otbImageComplexStreamingFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageComplexStreamingFileWriterTestWithoutInputInt(int argc, char * argv[]) { return otbImageComplexStreamingFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageComplexStreamingFileWriterTestWithoutInputFloat(int argc, char * argv[]) { return otbImageComplexStreamingFileWriterTestWithoutInputGeneric(argc, argv); } int otbImageComplexStreamingFileWriterTestWithoutInputDouble(int argc, char * argv[]) { return otbImageComplexStreamingFileWriterTestWithoutInputGeneric(argc, argv); } OTB-release-5.8/Modules/IO/ImageIO/test/otbIntImageIOTest.cxx000066400000000000000000000027431301006202600236120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbIntImageIOTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef int InputPixelType; typedef int OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbMultiResolutionReadingInfo.cxx000066400000000000000000000033471301006202600263120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "itksys/SystemTools.hxx" #include "otbImageFileReader.h" #include "otbVectorImage.h" int otbMultiResolutionReadingInfo(int argc, char* argv[]) { if (argc != 3) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } const char * inputFilename = argv[1]; const char * outputAsciiFilename = argv[2]; typedef double PixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); std::vector desc = reader->GetOverviewsInfo(); if (desc.empty()) return EXIT_FAILURE; std::ofstream file; file.open(outputAsciiFilename); // Parse all the names to delete the path of the filename for( unsigned int itRes = 0; itRes < reader->GetOverviewsCount(); itRes++ ) { file << "RESOLUTION: " << itRes << "; " << "DESC: " << desc[itRes] << std::endl; } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbPNGIndexedNbBandsTest.cxx000066400000000000000000000030361301006202600250360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbVectorImage.h" #include "itkRGBPixel.h" #include "itkMacro.h" #include int otbPNGIndexedNbBandsTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const unsigned int nbBands = atoi(argv[2]); typedef itk::RGBPixel InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); if (reader->GetOutput()->GetNumberOfComponentsPerPixel() == nbBands) { return EXIT_SUCCESS; } else { std::cout << "Read " << reader->GetOutput()->GetNumberOfComponentsPerPixel() << " but the real number of bands is " << nbBands << std::endl; return EXIT_FAILURE; } } OTB-release-5.8/Modules/IO/ImageIO/test/otbPipeline.cxx000066400000000000000000000021411301006202600225620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbPipeline(int itkNotUsed(argc), char * argv[]) { typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbPipelineMetadataHandlingTest.cxx000066400000000000000000000034261301006202600265370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "itkDiscreteGaussianImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbPipelineMetadataHandlingTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::DiscreteGaussianImageFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbPipelineMetadataHandlingWithUFFilterTest.cxx000066400000000000000000000035121301006202600307700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbPipelineMetadataHandlingWithUFFilterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::RescaleIntensityImageFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbReadingComplexDataIntoComplexImageTest.cxx000066400000000000000000000053341301006202600305040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbMacro.h" int otbReadingComplexDataIntoComplexImageTest(int itkNotUsed(argc), char * argv[]) { typedef double RealType; typedef std::complex PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader Reader1Type; typedef otb::ImageFileReader Reader2Type; ImageType::IndexType index; index[0] = atoi(argv[2]); index[1] = atoi(argv[3]); ImageType::SizeType size; size[0] = 1; size[1] = 1; ImageType::RegionType region; region.SetSize(size); region.SetIndex(index); Reader1Type::Pointer reader1 = Reader1Type::New(); reader1->SetFileName(argv[1]); reader1->GetOutput()->UpdateOutputInformation(); reader1->GetOutput()->SetRequestedRegion(region); reader1->GetOutput()->PropagateRequestedRegion(); reader1->GetOutput()->UpdateOutputData(); PixelType complexValue = reader1->GetOutput()->GetPixel(index); Reader2Type::Pointer reader2 = Reader2Type::New(); reader2->SetFileName(argv[1]); reader2->GetOutput()->UpdateOutputInformation(); reader2->GetOutput()->SetRequestedRegion(region); reader2->GetOutput()->PropagateRequestedRegion(); reader2->GetOutput()->UpdateOutputData(); VectorImageType::PixelType vectorValue = reader2->GetOutput()->GetPixel(index); std::cout << "Image value (complex): " << complexValue << std::endl; std::cout << "Image value (vector ): " << vectorValue << std::endl; otbControlConditionTestMacro(vectorValue.Size() < 2, "VectorImage has less than 2 components. No input complex data."); otbControlConditionTestMacro( complexValue.real() != vectorValue[0], "The real part is not read properly. Have a look at the file itk::ConvertPixelBuffer, the problem might be there."); otbControlConditionTestMacro( complexValue.imag() != vectorValue[1], "The imaginary part is not read properly. Have a look at the file itk::ConvertPixelBuffer, the problem might be there."); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbScalarBufferToImageFileWriterNew.cxx000066400000000000000000000015161301006202600272760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbScalarBufferToImageFileWriter.h" int otbScalarBufferToImageFileWriterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::ScalarBufferToImageFileWriter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbScalarBufferToImageFileWriterTest.cxx000066400000000000000000000031771301006202600274710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbScalarBufferToImageFileWriter.h" int otbScalarBufferToImageFileWriterTest(int itkNotUsed(argc), char* argv[]) { unsigned int nbCh = atoi(argv[1]); unsigned int sizeX = atoi(argv[2]); unsigned int sizeY = atoi(argv[3]); typedef otb::ScalarBufferToImageFileWriter FilterType; FilterType::Pointer filter = FilterType::New(); float * tab = new float[nbCh*sizeX*sizeY]; int cpt=0; double val = 0.; for(unsigned int sx=0; sxSetImageSize(size); filter->SetNumberOfChannels(nbCh); filter->SetBuffer(tab); filter->SetFileName(argv[4]); filter->SetInverseXSpacing(true); filter->Update(); delete[] tab; tab = ITK_NULLPTR; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbShortImageIOTest.cxx000066400000000000000000000027621301006202600241600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbShortImageIOTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef short InputPixelType; typedef short OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbShortRGBImageIOTest.cxx000066400000000000000000000030531301006202600245050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "itkRGBPixel.h" #include "itkMacro.h" #include int otbShortRGBImageIOTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef itk::RGBPixel InputPixelType; typedef itk::RGBPixel OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbStreamingImageFileWriterTest.cxx000066400000000000000000000036701301006202600265560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbStreamingImageFileWriterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; int NumberOfStreamDivisions(::atoi(argv[3])); typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); std::cout << "Writing test" << std::endl; WriterType::Pointer writer = WriterType::New(); if (NumberOfStreamDivisions > 1) { std::cout << "Streaming testing of otb::ImageFileWriter " << std::endl; std::cout << "NumberOfStreamDivisions: " << NumberOfStreamDivisions << std::endl; writer->SetNumberOfDivisionsStrippedStreaming(NumberOfStreamDivisions); } writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbStreamingImageFileWriterTestCalculateNumberOfDivisions.cxx000066400000000000000000000052421301006202600336400ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/ImageIO/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageFileWriterTestCalculateNumberOfDivisions(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; std::string MethodCalculateNumberOfStreamDivision(argv[3]); typedef unsigned int PixelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter StreamingWriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); std::cout << "Streaming writing test" << std::endl; StreamingWriterType::Pointer writer = StreamingWriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); if (MethodCalculateNumberOfStreamDivision == "SetNumberOfDivisionsStrippedStreaming") { writer->SetNumberOfDivisionsStrippedStreaming(::atoi(argv[4])); } else if (MethodCalculateNumberOfStreamDivision == "SetNumberOfDivisionsTiledStreaming") { writer->SetNumberOfDivisionsTiledStreaming(::atoi(argv[4])); } else if (MethodCalculateNumberOfStreamDivision == "SetNumberOfLinesStrippedStreaming") { writer->SetNumberOfLinesStrippedStreaming(::atoi(argv[4])); } else if (MethodCalculateNumberOfStreamDivision == "SetAutomaticStrippedStreaming") { writer->SetAutomaticStrippedStreaming(::atoi(argv[4])); } else if (MethodCalculateNumberOfStreamDivision == "SetTileDimensionTiledStreaming") { writer->SetTileDimensionTiledStreaming(::atoi(argv[4])); } else if (MethodCalculateNumberOfStreamDivision == "SetAutomaticTiledStreaming") { writer->SetAutomaticTiledStreaming(::atoi(argv[4])); } else if (MethodCalculateNumberOfStreamDivision == "DEFAULT") { } else { itkGenericExceptionMacro(<< "Parameter value not authorized !!!"); } writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbStreamingImageFileWriterWithFilterTest.cxx000066400000000000000000000051751301006202600305620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkMeanImageFilter.h" int otbImageFileWriterWithFilterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int radius = atoi(argv[3]); int iStreaming(::atoi(argv[4])); bool streaming = (bool) (iStreaming); int NumberOfStreamDivisions(10); if (streaming == true) { NumberOfStreamDivisions = ::atoi(argv[5]); } typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter StreamingWriterType; typedef otb::ImageFileWriter WriterType; typedef itk::MeanImageFilter FilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); InputImageType::SizeType rad; rad.Fill(radius); filter->SetRadius(rad); if (streaming == true) { std::cout << "Streaming writing test" << std::endl; StreamingWriterType::Pointer writer = StreamingWriterType::New(); writer->SetFileName(outputFilename); writer->SetNumberOfDivisionsStrippedStreaming(NumberOfStreamDivisions); writer->SetInput(filter->GetOutput()); writer->Update(); } else { std::cout << "Writing test" << std::endl; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbStreamingImageFilterTest.cxx000066400000000000000000000035121301006202600257220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbImage.h" #include "itkStreamingImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbStreamingImageFilterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::StreamingImageFilter StreamingImageFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); StreamingImageFilterType::Pointer streamer = StreamingImageFilterType::New(); streamer->SetInput(reader->GetOutput()); streamer->SetNumberOfStreamDivisions(10); streamer->Update(); writer->SetInput(streamer->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbStreamingShortImageFileWriterTest.cxx000066400000000000000000000044251301006202600275750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageFileWriter.h" int otbStreamingShortImageFileWriterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; int iStreaming(::atoi(argv[3])); bool streaming = (bool) (iStreaming); int NumberOfStreamDivisions(10); if (streaming == true) { NumberOfStreamDivisions = ::atoi(argv[4]); } typedef unsigned short InputPixelType; typedef unsigned short OutputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter StreamingWriterType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); if (streaming == true) { std::cout << "Streaming writing test" << std::endl; StreamingWriterType::Pointer writer = StreamingWriterType::New(); writer->SetFileName(outputFilename); writer->SetNumberOfDivisionsStrippedStreaming(NumberOfStreamDivisions); writer->SetInput(reader->GetOutput()); writer->Update(); } else { std::cout << "Writing test" << std::endl; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbVectorImageFileReaderWriterTest.cxx000066400000000000000000000030261301006202600272050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkMacro.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbVectorImageFileReaderWriterTest(int itkNotUsed(argc), char* argv[]) { // Verify the number of parameters in the command line const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef double InputPixelType; typedef double OutputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/ImageIO/test/otbVectorImageFileWriterTestWithoutInput.cxx000066400000000000000000000157301301006202600304730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkMacro.h" #include "itkImageRegionIterator.h" /*********** * 1. * Write VectorImage with an VectorImageFileWriter ***********/ template int otbVectorImageFileWriterScalarTestWithoutInputGeneric(int argc, char* argv[]) { if (argc != 4) { std::cout << "Invalid arguments" << std::endl; std::cout << "1:Output File Name" << std::endl; std::cout << "2:Image Size" << std::endl; std::cout << "3:Nb of Channels" << std::endl; return 1; } // TYPEDEFS typedef InternalType PixelType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType ImagePixelType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; // INSTANTIATIONS typename WriterType::Pointer writer = WriterType::New(); typename ImageType::Pointer image = ImageType::New(); RegionType region; SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(atoi(argv[3])); image->Allocate(); ImagePixelType pix0; pix0.SetSize(atoi(argv[3])); for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { pix0[i] = static_cast (0); } image->FillBuffer(pix0); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); ImagePixelType pixVal; pixVal.SetSize(atoi(argv[3])); while (!it.IsAtEnd()) { for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { pixVal[i] = static_cast (i * size[0] * size[1] + size[0] * it.GetIndex()[1] + it.GetIndex()[0]); } it.Set(pixVal); ++it; } writer->SetFileName(argv[1]); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } int otbVectorImageFileWriterScalarTestWithoutInputShort(int argc, char * argv[]) { return otbVectorImageFileWriterScalarTestWithoutInputGeneric(argc, argv); } int otbVectorImageFileWriterScalarTestWithoutInputInt(int argc, char * argv[]) { return otbVectorImageFileWriterScalarTestWithoutInputGeneric(argc, argv); } int otbVectorImageFileWriterScalarTestWithoutInputFloat(int argc, char * argv[]) { return otbVectorImageFileWriterScalarTestWithoutInputGeneric(argc, argv); } int otbVectorImageFileWriterScalarTestWithoutInputDouble(int argc, char * argv[]) { return otbVectorImageFileWriterScalarTestWithoutInputGeneric(argc, argv); } /*********** * 2. * Write VectorImage with an VectorImageFileWriter ***********/ template int otbVectorImageFileWriterComplexTestWithoutInputGeneric(int argc, char* argv[]) { if (argc != 4) { std::cout << "Invalid arguments" << std::endl; std::cout << "1:Output File Name" << std::endl; std::cout << "2:Image Size" << std::endl; std::cout << "3:Nb of Channels" << std::endl; return 1; } // TYPEDEFS typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType ImagePixelType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; // INSTANTIATIONS typename WriterType::Pointer writer = WriterType::New(); typename ImageType::Pointer image = ImageType::New(); RegionType region; SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(atoi(argv[3])); image->Allocate(); ImagePixelType pix0; pix0.SetSize(atoi(argv[3])); for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { pix0[i] = static_cast (0); } image->FillBuffer(pix0); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); ImagePixelType pixVal; pixVal.SetSize(atoi(argv[3])); typedef typename itk::NumericTraits::ScalarRealType ScalarRealType; while (!it.IsAtEnd()) { for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { ScalarRealType realPart = 2 * (i *size[0]*size[1] + size[0] * it.GetIndex()[1] + it.GetIndex()[0]); ScalarRealType imagPart = 2 * (i *size[0]*size[1] + size[0] * it.GetIndex()[1] + it.GetIndex()[0]) + 1; PixelType internalPixelVal (realPart, imagPart); //std::cout << "internalPixelVal = " << internalPixelVal <SetFileName(argv[1]); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } int otbVectorImageFileWriterComplexTestWithoutInputShort(int argc, char * argv[]) { return otbVectorImageFileWriterComplexTestWithoutInputGeneric(argc, argv); } int otbVectorImageFileWriterComplexTestWithoutInputInt(int argc, char * argv[]) { return otbVectorImageFileWriterComplexTestWithoutInputGeneric(argc, argv); } int otbVectorImageFileWriterComplexTestWithoutInputFloat(int argc, char * argv[]) { return otbVectorImageFileWriterComplexTestWithoutInputGeneric(argc, argv); } int otbVectorImageFileWriterComplexTestWithoutInputDouble(int argc, char * argv[]) { return otbVectorImageFileWriterComplexTestWithoutInputGeneric(argc, argv); } OTB-release-5.8/Modules/IO/ImageIO/test/otbVectorImageStreamingFileWriterTestWithoutInput.cxx000066400000000000000000000165411301006202600323460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkMacro.h" #include "itkImageRegionIterator.h" /*********** * 1. * Write VectorImage with an VectorImageFileWriter ***********/ template int otbVectorImageStreamingFileWriterScalarTestWithoutInputGeneric(int argc, char* argv[]) { if (argc != 4) { std::cout << "Invalid arguments" << std::endl; std::cout << "1:Output File Name" << std::endl; std::cout << "2:Image Size" << std::endl; std::cout << "3:Nb of Channels" << std::endl; return 1; } // TYPEDEFS typedef InternalType PixelType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType ImagePixelType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; // INSTANTIATIONS typename WriterType::Pointer writer = WriterType::New(); typename ImageType::Pointer image = ImageType::New(); RegionType region; SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(atoi(argv[3])); image->Allocate(); ImagePixelType pix0; pix0.SetSize(atoi(argv[3])); for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { pix0[i] = static_cast (0); } image->FillBuffer(pix0); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); ImagePixelType pixVal; pixVal.SetSize(atoi(argv[3])); while (!it.IsAtEnd()) { for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { pixVal[i] = static_cast (i * size[0] * size[1] + size[0] * it.GetIndex()[1] + it.GetIndex()[0]); } it.Set(pixVal); ++it; } writer->SetFileName(argv[1]); writer->SetNumberOfDivisionsStrippedStreaming(10); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } int otbVectorImageStreamingFileWriterScalarTestWithoutInputShort(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterScalarTestWithoutInputGeneric(argc, argv); } int otbVectorImageStreamingFileWriterScalarTestWithoutInputInt(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterScalarTestWithoutInputGeneric(argc, argv); } int otbVectorImageStreamingFileWriterScalarTestWithoutInputFloat(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterScalarTestWithoutInputGeneric(argc, argv); } int otbVectorImageStreamingFileWriterScalarTestWithoutInputDouble(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterScalarTestWithoutInputGeneric(argc, argv); } /*********** * 2. * Write VectorImage with an VectorImageFileWriter ***********/ template int otbVectorImageStreamingFileWriterComplexTestWithoutInputGeneric(int argc, char* argv[]) { if (argc != 4) { std::cout << "Invalid arguments" << std::endl; std::cout << "1:Output File Name" << std::endl; std::cout << "2:Image Size" << std::endl; std::cout << "3:Nb of Channels" << std::endl; return 1; } // TYPEDEFS typedef std::complex PixelType; typedef otb::VectorImage ImageType; typedef typename ImageType::PixelType ImagePixelType; typedef typename ImageType::RegionType RegionType; typedef typename ImageType::SizeType SizeType; typedef typename ImageType::IndexType IndexType; typedef itk::ImageRegionIterator IteratorType; typedef otb::ImageFileWriter WriterType; // INSTANTIATIONS typename WriterType::Pointer writer = WriterType::New(); typename ImageType::Pointer image = ImageType::New(); RegionType region; SizeType size; size.Fill(atoi(argv[2])); IndexType orig; orig.Fill(0); region.SetSize(size); region.SetIndex(orig); typedef typename ImageType::PointType PointType; typedef typename ImageType::SpacingType SpacingType; PointType origin; origin.Fill(0.5); SpacingType spacing; spacing.Fill(1.0); image->SetOrigin(origin); image->SetSpacing(spacing); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(atoi(argv[3])); image->Allocate(); ImagePixelType pix0; pix0.SetSize(atoi(argv[3])); for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { pix0[i] = static_cast (0); } image->FillBuffer(pix0); IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); ImagePixelType pixVal; pixVal.SetSize(atoi(argv[3])); typedef typename itk::NumericTraits::ScalarRealType ScalarRealType; while (!it.IsAtEnd()) { for (unsigned int i = 0; i < static_cast (atoi(argv[3])); ++i) { ScalarRealType realPart = 2 * (i *size[0]*size[1] + size[0] * it.GetIndex()[1] + it.GetIndex()[0]); ScalarRealType imagPart = 2 * (i *size[0]*size[1] + size[0] * it.GetIndex()[1] + it.GetIndex()[0]) + 1; PixelType internalPixelVal (realPart, imagPart); //std::cout << "internalPixelVal = " << internalPixelVal <SetFileName(argv[1]); writer->SetNumberOfDivisionsStrippedStreaming(10); writer->SetInput(image); writer->Update(); return EXIT_SUCCESS; } int otbVectorImageStreamingFileWriterComplexTestWithoutInputShort(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterComplexTestWithoutInputGeneric(argc, argv); } int otbVectorImageStreamingFileWriterComplexTestWithoutInputInt(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterComplexTestWithoutInputGeneric(argc, argv); } int otbVectorImageStreamingFileWriterComplexTestWithoutInputFloat(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterComplexTestWithoutInputGeneric(argc, argv); } int otbVectorImageStreamingFileWriterComplexTestWithoutInputDouble(int argc, char * argv[]) { return otbVectorImageStreamingFileWriterComplexTestWithoutInputGeneric(argc, argv); } OTB-release-5.8/Modules/IO/ImageIO/test/otbWritingComplexDataWithComplexImageTest.cxx000066400000000000000000000032011301006202600305470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "otbMacro.h" int otbWritingComplexDataWithComplexImageTest(int itkNotUsed(argc), char * argv[]) { typedef double RealType; typedef std::complex PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ExtractROI ExtractROIFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); ExtractROIFilterType::Pointer extract = ExtractROIFilterType::New(); extract->SetInput(reader->GetOutput()); extract->SetStartX(atoi(argv[3])); extract->SetStartY(atoi(argv[4])); extract->SetSizeX(atoi(argv[5])); extract->SetSizeY(atoi(argv[6])); WriterType::Pointer writer = WriterType::New(); writer->SetInput(extract->GetOutput()); writer->SetFileName(argv[2]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/KMZWriter/000077500000000000000000000000001301006202600171735ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/KMZWriter/CMakeLists.txt000066400000000000000000000000501301006202600217260ustar00rootroot00000000000000project(OTBKMZWriter) otb_module_impl() OTB-release-5.8/Modules/IO/KMZWriter/include/000077500000000000000000000000001301006202600206165ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/KMZWriter/include/otbKmzProductWriter.h000066400000000000000000000253221301006202600247770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKmzProductWriter_h #define otbKmzProductWriter_h #include #include "itkObjectFactory.h" //kmz creation #include "kml/engine/kmz_file.h" #include "kml/base/file.h" // Image Tiling #include "otbMultiChannelExtractROI.h" #include "otbImageFileWriter.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbGenericRSTransform.h" #include "otbStreamingShrinkImageFilter.h" #include "itkCastImageFilter.h" // Possibility to includes vectordatas necessary includes #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" namespace otb { /** \class KmzProductWriter * \brief This class generate a Kmz from one or several input * images. The inputs must have a non empty metadata information. * * This class writes kmz files, supported by Google Earth. The input * must have metadata (a non empty keywordlist) * * The size of the tiles can be set via the method * SetTileSize(unsigned int), the user can also specify the name of * the output Kmz filename via SetPath(). * * * * \ingroup IO * * * \ingroup OTBKMZWriter */ template class ITK_EXPORT KmzProductWriter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef KmzProductWriter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(KmzProductWriter, itk::ProcessObject); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::InternalPixelType InternalPixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::RegionType RegionType; typedef unsigned char OutputPixelType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::PixelType InputImagePixelType; typedef VectorData VectorDataType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename PolygonType::VertexType VertexType; typedef VectorDataFileWriter VectorDataFileWriterType; // Multi channels Extract ROI filter typedef MultiChannelExtractROI VectorImageExtractROIFilterType; // Writer typedef ImageFileWriter< VectorImage > VectorWriterType; // Resampler typedef StreamingShrinkImageFilter StreamingShrinkImageFilterType; // Intensity Rescale typedef VectorRescaleIntensityImageFilter VectorRescaleIntensityImageFilterType; // Transformer typedef GenericRSTransform<> TransformType; typedef TransformType::InputPointType InputPointType; typedef TransformType::OutputPointType OutputPointType; // Cast Image Filter typedef itk::CastImageFilter > CastFilterType; // std::pair description <-> legend (image) typedef std::pair LegendPairType; typedef std::vector LegendVectorType; /** Dimension of input image. */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); using Superclass::SetInput; virtual void SetInput( const InputImageType *image); virtual void SetInput( unsigned int, const TInputImage * image); const InputImageType * GetInput(void); const InputImageType * GetInput(unsigned int idx); itkSetStringMacro(Path); /** Update Method */ void Update() ITK_OVERRIDE { this->Write(); } /* Method to Add Logo */ itkSetMacro(Logo, InputImagePointer); /** Method to store the legend and their description in the * legendVector */ void AddLegend(const std::string& description, const InputImagePointer legend) { LegendPairType legendPair; legendPair.first = description; legendPair.second = legend; m_LegendVector.push_back(legendPair); } /** Method to add legend with empty description */ void AddLegend(const InputImagePointer legend) { std::string emptyString =""; this->AddLegend(emptyString, legend); } /** Set the size of the tiles to produce */ void SetTileSize(unsigned int tileSize); protected: KmzProductWriter(); ~KmzProductWriter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /**Method for Tiling the input image*/ virtual void Tiling(); /** Method for writing */ virtual void Write(); private: KmzProductWriter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Mehtod to initialize the variables*/ virtual void Initialize(); /** * Close the root kml by adding the last flags and close the * std::ofstream */ void CloseRootKML(); /** method to generate the bounding box kml*/ void BoundingBoxKmlProcess(double north, double south, double east, double west); /** Method to generate the root kml*/ void RootKmlProcess(double north, double south, double east, double west); /** Add Roi to kmz*/ // void RegionOfInterestProcess(); // Add Legends to the root kml void AddLegendToRootKml(double north, double south, double east, double west); /** KML root generate */ void GenerateKMLRoot(const std::string& title, double north, double south, double east, double west, bool extended); /** KML generate Filename - PathName - tile number - North - South - East - West */ void GenerateKML(const std::string& pathname, int depth, int x, int y, double north, double south, double east, double west); void GenerateKMLExtended(const std::string& pathname, int depth, int x, int y, OutputPointType lowerLeft, OutputPointType lowerRight, OutputPointType upperRight, OutputPointType upperLeft); /** KML with link generate */ void GenerateKMLWithLink(const std::string& pathname, int depth, int x, int y, int tileStartX, int tileStartY, double north, double south, double east, double west, double centerLong, double centerLat); void GenerateKMLExtendedWithLink(const std::string& pathname, int depth, int x, int y, int tileStartX, int tileStartY, OutputPointType lowerLeft, OutputPointType lowerRight, OutputPointType upperRight, OutputPointType upperLeft, double centerLong, double centerLat); /** Method to create the bounding kml of the "iteration" th product */ void GenerateBoundingKML(double north, double south, double east, double west); /** * Add a networkLink .... * to root kml (used to handle several image in the same kmz) */ void AddNetworkLinkToRootKML(double north, double south, double east, double west, const std::string& directory, bool addRegion, unsigned int pos); /** * Add file to KMZ : return the number of error when writing the * file in the kmz */ virtual int AddFileToKMZ(const std::ostringstream& absolutePath, const std::ostringstream& kmz_in_path); /**Cut the image file name to built the directory name*/ std::string GetCuttenFileName(const std::string& description, unsigned int idx); /** Method to add logo if any */ void AddLogo(); /** Method to add Legend if any */ void ProcessLegends(); std::string m_Path; bool m_UseExtendMode; InputImagePointer m_VectorImage; InputImagePointer m_ResampleVectorImage; // Extract ROI typename VectorImageExtractROIFilterType::Pointer m_VectorImageExtractROIFilter; // Writer typename VectorWriterType::Pointer m_VectorWriter; // Resampler typename StreamingShrinkImageFilterType::Pointer m_StreamingShrinkImageFilter; // Rescale intensity typename VectorRescaleIntensityImageFilterType::Pointer m_VectorRescaleIntensityImageFilter; // Transformer typename TransformType::Pointer m_Transform; // VectorData Pointer Type for tileindex shapefile typename VectorDataType::Pointer m_VectorDataIndexTile; typename DataNodeType::Pointer m_Polygon; typename DataNodeType::Pointer m_MultiPolygon; typename DataNodeType::Pointer m_Folder; // Tile size unsigned int m_TileSize; int m_MaxDepth; int m_CurrentDepth; unsigned int m_CurIdx; // KMZ file kmlengine::KmzFilePtr m_KmzFile; // KMZ file name std::ostringstream m_KmzFileName; // the kml root ofstream std::ofstream m_RootKmlFile; std::ofstream m_TempRootKmlFile; // File and path name std::string m_FileName; std::string m_CurrentImageName; // Convenience string std::string m_KmzExtension; std::string m_KmlExtension; // Logo InputImagePointer m_Logo; // Vector used to store legend and description LegendVectorType m_LegendVector; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKmzProductWriter.txx" #endif #endif OTB-release-5.8/Modules/IO/KMZWriter/include/otbKmzProductWriter.txx000066400000000000000000001546651301006202600254100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKmzProductWriter_txx #define otbKmzProductWriter_txx #include #include "otbKmzProductWriter.h" #include "itksys/SystemTools.hxx" #include "otbMetaDataKey.h" #include "otbVectorDataKeywordlist.h" namespace otb { template KmzProductWriter ::KmzProductWriter(): m_UseExtendMode(true), m_TileSize(512), m_MaxDepth(0), m_CurrentDepth(0), m_CurIdx(0) { // Modify superclass default values, can be overridden by subclasses this->SetNumberOfRequiredInputs(1); } template KmzProductWriter ::~KmzProductWriter() { // Reset the boost::intrusive_ptr : // TODO : when upgrading boost > 1.42 use method release(). m_KmzFile = ITK_NULLPTR; } /** * */ template void KmzProductWriter ::SetInput(const InputImageType *input) { // Process object is not const-correct so the const_cast is required here this->ProcessObject::SetNthInput(0, const_cast< InputImageType * >( input ) ); } template void KmzProductWriter ::SetInput( unsigned int index, const TInputImage * image ) { // Process object is not const-correct so the const_cast is required here this->ProcessObject::SetNthInput(index, const_cast< TInputImage *>( image ) ); } /** * */ template const typename KmzProductWriter::InputImageType * KmzProductWriter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetInput(0) ); } /** * */ template const typename KmzProductWriter::InputImageType * KmzProductWriter ::GetInput(unsigned int idx) { return static_cast< const TInputImage * > (this->ProcessObject::GetInput(idx)); } template void KmzProductWriter ::Write() { m_VectorImage = const_cast(this->GetInput()); // Do some checks, If no metadata nor projection ref available, // input is not usable. bool emptyProjRef = m_VectorImage->GetProjectionRef().empty(); bool emptyKWL = m_VectorImage->GetImageKeywordlist().GetSize() == 0 ? true : false; if(emptyProjRef && emptyKWL) { itkExceptionMacro(<<"The input image have empty keyword list, please use an image with metadata information"); } // Continue processing this->Initialize(); this->AddLogo(); this->Tiling(); } template void KmzProductWriter ::Initialize() { // Check if the path is not empty if (m_Path.empty()) { itkExceptionMacro(<<" Output path is empty !"); } // Check that the right extension is given : expected .kmz */ if (itksys::SystemTools::GetFilenameLastExtension(m_Path) != ".kmz") { itkExceptionMacro(<GetCuttenFileName(m_FileName, 0); // Create the extension following the user choice if (m_UseExtendMode) { m_KmzExtension = "xt.kmz"; m_KmlExtension = "xt.kml"; } else { m_KmzExtension = ".kmz"; m_KmlExtension = ".kml"; } // Create a kmz file m_KmzFileName << m_Path << "/" << m_FileName << m_KmzExtension; m_KmzFile = kmlengine::KmzFile::Create(m_KmzFileName.str().c_str()); } /** * Add Logo if any * */ template void KmzProductWriter ::AddLogo() { // Logo if(m_Logo.IsNull()) return; std::ostringstream logoFilename; logoFilename << m_Path; logoFilename << "/logo.jpeg"; if (!itksys::SystemTools::MakeDirectory(m_Path.c_str())) { itkExceptionMacro(<< "Error while creating cache directory" << m_Path); } typename CastFilterType::Pointer castFiler = CastFilterType::New(); castFiler->SetInput(m_Logo); m_VectorWriter = VectorWriterType::New(); m_VectorWriter->SetFileName(logoFilename.str()); m_VectorWriter->SetInput(castFiler->GetOutput()); m_VectorWriter->Update(); // Add the logo to the kmz std::ostringstream logo_root_path_in_kmz; logo_root_path_in_kmz << "logo.jpeg"; std::ostringstream logo_absolut_path; logo_absolut_path << logoFilename.str(); this->AddFileToKMZ(logo_absolut_path, logo_root_path_in_kmz); // Remove the logo file with stdio method :remove if (remove(logo_absolut_path.str().c_str()) != 0) { itkExceptionMacro(<< "Error while deleting the file" << logo_absolut_path.str()); } } /** * Add legend if any */ template void KmzProductWriter ::ProcessLegends() { for (unsigned int idx = 0; idx < m_LegendVector.size(); ++idx) { std::ostringstream legendName; legendName << m_Path; legendName << "/legend_" << idx <<".jpeg"; InputImagePointer legend = m_LegendVector[idx].second; typename CastFilterType::Pointer castFiler = CastFilterType::New(); castFiler->SetInput(legend); m_VectorWriter = VectorWriterType::New(); m_VectorWriter->SetFileName(legendName.str().c_str()); m_VectorWriter->SetInput(castFiler->GetOutput()); m_VectorWriter->Update(); // Add the legend to the kmz std::ostringstream legend_root_path_in_kmz; legend_root_path_in_kmz << "legends/legend_" << idx << ".jpeg"; std::ostringstream legend_absolut_path; legend_absolut_path << legendName.str(); this->AddFileToKMZ(legend_absolut_path, legend_root_path_in_kmz); // Remove the legend file with stdio method :remove if (remove(legend_absolut_path.str().c_str()) != 0) { itkExceptionMacro(<< "Error while deleting the file" << legend_absolut_path.str()); } } } template void KmzProductWriter ::Tiling() { unsigned int numberOfChannel = m_VectorImage->GetNumberOfComponentsPerPixel(); unsigned int curIdx = 0; /** Image statistics*/ typename InputImageType::PixelType inMin(numberOfChannel), inMax(numberOfChannel), outMin(numberOfChannel), outMax(numberOfChannel); outMin.Fill(0); outMax.Fill(255); // Build wgs ref to compute long/lat OGRSpatialReference oSRS; oSRS.SetWellKnownGeogCS("WGS84"); char * wgsRef = ITK_NULLPTR; oSRS.exportToWkt(&wgsRef); // Update image base information m_VectorImage->UpdateOutputInformation(); // Get the image size SizeType size; size = m_VectorImage->GetLargestPossibleRegion().GetSize(); unsigned int sizeX = size[0]; unsigned int sizeY = size[1]; // Compute max depth unsigned int maxDepth = static_cast(std::max(vcl_ceil(vcl_log(static_cast(sizeX) / static_cast(m_TileSize)) / vcl_log(2.0)), vcl_ceil(vcl_log(static_cast(sizeY) / static_cast(m_TileSize)) / vcl_log(2.0)))); m_MaxDepth = maxDepth; m_CurIdx = 0; // Compute nbTile int nbTile = 0; for (unsigned int i = 0; i <= maxDepth; ++i) { unsigned int ratio = static_cast(vcl_pow(2.,static_cast((static_cast(maxDepth) - i)))); nbTile += (((sizeX / ratio) / m_TileSize) + 1) * (((sizeY / ratio) / m_TileSize) + 1); } // Extract size & index SizeType extractSize; IndexType extractIndex; for (unsigned int depth = 0; depth <= maxDepth; depth++) { // update the attribute value Current Depth m_CurrentDepth = depth; // Resample image to the max Depth int sampleRatioValue = (1 << (maxDepth - depth)); if (sampleRatioValue > 1) { m_StreamingShrinkImageFilter = StreamingShrinkImageFilterType::New(); m_StreamingShrinkImageFilter->SetShrinkFactor(sampleRatioValue); m_StreamingShrinkImageFilter->SetInput(m_VectorImage); m_StreamingShrinkImageFilter->GetStreamer()->SetAutomaticStrippedStreaming(0); m_StreamingShrinkImageFilter->Update(); m_VectorRescaleIntensityImageFilter = VectorRescaleIntensityImageFilterType::New(); m_VectorRescaleIntensityImageFilter->SetInput(m_StreamingShrinkImageFilter->GetOutput()); m_VectorRescaleIntensityImageFilter->SetOutputMinimum(outMin); m_VectorRescaleIntensityImageFilter->SetOutputMaximum(outMax); if (depth == 0) { m_VectorRescaleIntensityImageFilter->Update(); inMin = m_VectorRescaleIntensityImageFilter->GetInputMinimum(); inMax = m_VectorRescaleIntensityImageFilter->GetInputMaximum(); } else { m_VectorRescaleIntensityImageFilter->SetInputMinimum(inMin); m_VectorRescaleIntensityImageFilter->SetInputMaximum(inMax); m_VectorRescaleIntensityImageFilter->SetAutomaticInputMinMaxComputation(false); } // New resample vector image m_ResampleVectorImage = m_VectorRescaleIntensityImageFilter->GetOutput(); } else { m_VectorRescaleIntensityImageFilter = VectorRescaleIntensityImageFilterType::New(); m_VectorRescaleIntensityImageFilter->SetInput(m_VectorImage); m_VectorRescaleIntensityImageFilter->SetOutputMinimum(outMin); m_VectorRescaleIntensityImageFilter->SetOutputMaximum(outMax); // Case of input image with size lower than the tileSize // this case is illustrated with depth==0 and // sampleRatioValue==1 if(depth==0 && sampleRatioValue == 1) { m_VectorRescaleIntensityImageFilter->SetAutomaticInputMinMaxComputation(true); } else { m_VectorRescaleIntensityImageFilter->SetInputMinimum(inMin); m_VectorRescaleIntensityImageFilter->SetInputMaximum(inMax); m_VectorRescaleIntensityImageFilter->SetAutomaticInputMinMaxComputation(false); } m_ResampleVectorImage = m_VectorRescaleIntensityImageFilter->GetOutput(); } m_ResampleVectorImage->UpdateOutputInformation(); // Get the image size size = m_ResampleVectorImage->GetLargestPossibleRegion().GetSize(); sizeX = size[0]; sizeY = size[1]; // Tiling resample image for (unsigned int tx = 0, x = 0; tx < sizeX; tx += m_TileSize, ++x) { for (unsigned int ty = 0, y = 0; ty < sizeY; ty += m_TileSize, ++y) { if ((tx + m_TileSize) >= sizeX) { extractIndex[0] = tx; extractSize[0] = sizeX - tx; } else { extractIndex[0] = tx; extractSize[0] = m_TileSize; } if ((ty + m_TileSize) >= sizeY) { extractIndex[1] = ty; extractSize[1] = sizeY - ty; } else { extractIndex[1] = ty; extractSize[1] = m_TileSize; } // Generate pathname if (!itksys::SystemTools::MakeDirectory(m_Path.c_str())) { itkExceptionMacro(<< "Error while creating cache directory" << m_Path); } std::ostringstream path; path << m_Path; // Generate Tile filename std::ostringstream ossFileName; ossFileName << m_Path; ossFileName << "/"; ossFileName << y; ossFileName << ".jpg"; // Extract ROI m_VectorImageExtractROIFilter = VectorImageExtractROIFilterType::New(); // Set extract roi parameters m_VectorImageExtractROIFilter->SetStartX(extractIndex[0]); m_VectorImageExtractROIFilter->SetStartY(extractIndex[1]); m_VectorImageExtractROIFilter->SetSizeX(extractSize[0]); m_VectorImageExtractROIFilter->SetSizeY(extractSize[1]); // Set Channel to extract if(m_VectorImage->GetNumberOfComponentsPerPixel()>3) { m_VectorImageExtractROIFilter->SetChannel(1); //m_ProductVector[m_CurrentProduct].m_Composition[0] + 1); m_VectorImageExtractROIFilter->SetChannel(2); //m_ProductVector[m_CurrentProduct].m_Composition[1] + 1); m_VectorImageExtractROIFilter->SetChannel(3); //m_ProductVector[m_CurrentProduct].m_Composition[2] + 1); } // Set extract roi input m_VectorImageExtractROIFilter->SetInput(m_ResampleVectorImage); // Configure writer m_VectorWriter = VectorWriterType::New(); m_VectorWriter->SetFileName(ossFileName.str().c_str()); m_VectorWriter->SetInput(m_VectorImageExtractROIFilter->GetOutput()); m_VectorWriter->Update(); /** TODO : Generate KML for this tile */ // Search Lat/Lon box m_Transform = TransformType::New(); m_Transform->SetInputKeywordList(m_ResampleVectorImage->GetImageKeywordlist()); m_Transform->SetInputProjectionRef(m_VectorImage->GetProjectionRef()); m_Transform->SetOutputProjectionRef(wgsRef); m_Transform->InstantiateTransform(); InputPointType inputPoint; OutputPointType outputPoint; double sizeTile[2]; double halfSizeTile[2]; sizeTile[0] = static_cast(extractSize[0]); sizeTile[1] = static_cast(extractSize[1]); halfSizeTile[0] = sizeTile[0] / 2.0; halfSizeTile[1] = sizeTile[1] / 2.0; itk::ContinuousIndex indexRef(extractIndex); indexRef[0] += -0.5; indexRef[1] += -0.5; itk::ContinuousIndex indexTile(indexRef); // Compute North value indexTile[0] += halfSizeTile[0]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); double north = outputPoint[1]; // Compute South value indexTile[1] += sizeTile[1]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); double south = outputPoint[1]; // Compute West value indexTile = indexRef; indexTile[1] += halfSizeTile[1]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); double west = outputPoint[0]; // Compute East value indexTile[0] += sizeTile[0]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); double east = outputPoint[0]; // Compute center value (lat / long) indexTile = indexRef; indexTile[0] += halfSizeTile[0]; indexTile[1] += halfSizeTile[1]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); double centerLat = outputPoint[1]; double centerLong = outputPoint[0]; /** GX LAT LON **/ // Compute upper left corner indexTile = indexRef; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); OutputPointType upperLeftCorner = outputPoint; // Compute lower left corner indexTile[1] += sizeTile[1]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); OutputPointType lowerLeftCorner = outputPoint; // Compute lower right corner indexTile[0] += sizeTile[0]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); OutputPointType lowerRightCorner = outputPoint; // Compute upper right corner indexTile[1] -= sizeTile[1]; m_ResampleVectorImage->TransformContinuousIndexToPhysicalPoint(indexTile, inputPoint); outputPoint = m_Transform->TransformPoint(inputPoint); OutputPointType upperRightCorner = outputPoint; /** END GX LAT LON */ // Create KML - Filename - PathName - tile number - North - South - East - West if (sampleRatioValue == 1) { if (!m_UseExtendMode) // Extended format { this->GenerateKML(path.str(), depth, x, y, north, south, east, west); } else { this->GenerateKMLExtended(path.str(), depth, x, y, lowerLeftCorner, lowerRightCorner, upperRightCorner, upperLeftCorner); } } else { // Search tiles to link int tileXStart = extractIndex[0] / (m_TileSize / 2); int tileYStart = extractIndex[1] / (m_TileSize / 2); // Create KML with link if (!m_UseExtendMode) { this->GenerateKMLWithLink(path.str(), depth, x, y, tileXStart, tileYStart, north, south, east, west, centerLong, centerLat); } else { this->GenerateKMLExtendedWithLink( path.str(), depth, x, y, tileXStart, tileYStart, lowerLeftCorner, lowerRightCorner, upperRightCorner, upperLeftCorner, centerLong, centerLat); } } if (depth == 0) { // Add the headers and the basic stuffs in the kml only once. if (curIdx == 0) { this->RootKmlProcess(north, south, east, west); } // Add the bounding box kml this->BoundingBoxKmlProcess(north, south, east, west); } // Add the files to the kmz file // Relative path to the root directory in the kmz file std::ostringstream jpg_in_kmz, kml_in_kmz; jpg_in_kmz << m_CurrentImageName << "/" << depth << "/" << x << "/" << y << ".jpg"; kml_in_kmz << m_CurrentImageName << "/" << depth << "/" << x << "/" << y << m_KmlExtension; // Absolute path where are stored the files std::ostringstream jpg_absolute_path, kml_absolute_path; jpg_absolute_path << m_Path << "/" << y << ".jpg"; kml_absolute_path << m_Path << "/" << y << m_KmlExtension; //Add the files to the kmz this->AddFileToKMZ(jpg_absolute_path, jpg_in_kmz); this->AddFileToKMZ(kml_absolute_path, kml_in_kmz); // Remove the unnecessary files with stdio method :remove if (remove(kml_absolute_path.str().c_str()) || remove(jpg_absolute_path.str().c_str())) { itkExceptionMacro( << "Error while deleting the file" << kml_absolute_path.str() << "or file " << jpg_absolute_path.str()); } } } } } /** * */ template int KmzProductWriter ::AddFileToKMZ(const std::ostringstream& absolutePath, const std::ostringstream& kmz_in_path) { std::string absolute = absolutePath.str(); std::string relative = kmz_in_path.str(); std::string file_data; int errs = 0; if (!kmlbase::File::ReadFileToString(absolute, &file_data)) { itkExceptionMacro(<< "Error while reading file " << absolute); } else { m_KmzFile->AddFile(file_data, relative); } return errs; } /** * Actually the root kml is not fully generated : * It generates only the part till the network link * In case of multiple inputs, other network liks are * needed. See the method Add NetworkLinkToRootKML. */ template void KmzProductWriter ::GenerateKMLRoot(const std::string& title, double north, double south, double east, double west, bool itkNotUsed(extended)) { // Give a name to the root file std::ostringstream kmlname; kmlname << m_Path; kmlname << "/"; kmlname << m_FileName; kmlname << m_KmlExtension; m_RootKmlFile.open(kmlname.str().c_str()); m_RootKmlFile << std::fixed << std::setprecision(6); m_RootKmlFile << "" << std::endl; m_RootKmlFile << "" << std::endl; m_RootKmlFile << "\t" << std::endl; m_RootKmlFile << "\t\t" << title << "" << std::endl; m_RootKmlFile << "\t\t" << std::endl; m_RootKmlFile << "\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << (east + west) / 2. << "" << std::endl; m_RootKmlFile << "\t\t\t" << (south + north) / 2. << "" << std::endl; m_RootKmlFile << "\t\t\t35000" << std::endl; m_RootKmlFile << "\t\t\t35000" << std::endl; m_RootKmlFile << "\t\t" << std::endl; } /** */ template void KmzProductWriter ::RootKmlProcess(double north, double south, double east, double west) { bool extended = m_UseExtendMode; this->GenerateKMLRoot(m_FileName, north, south, east, west, extended); // Add the legend for this product if any this->ProcessLegends(); // Add the flag netwotk link for each input image this->AddNetworkLinkToRootKML(north, south, east, west, m_CurrentImageName, true, 0); // Last thing to do is to close the root kml this->CloseRootKML(); // Add the root kml in the kmz std::ostringstream root_in_kmz; root_in_kmz << m_FileName << m_KmlExtension; std::ostringstream root_absolute_path; root_absolute_path << m_Path << "/" << root_in_kmz.str(); // Add the root file in the kmz this->AddFileToKMZ(root_absolute_path, root_in_kmz); // Remove the root files with stdio method :remove if (remove(root_absolute_path.str().c_str()) != 0) { itkExceptionMacro(<< "Error while deleting the file" << root_absolute_path.str()); } } /** * Close the root kml */ template void KmzProductWriter ::CloseRootKML() { if (!m_Logo.IsNull()) { RegionType logoReg = m_Logo->GetLargestPossibleRegion(); SizeType logoSize = logoReg.GetSize(); double lx = static_cast(logoSize[0]); double ly = static_cast(logoSize[1]); int sizey = 150/4; int sizex = static_cast((lx / ly * sizey)); /** LOGO **/ m_RootKmlFile << "\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\tlogo.jpeg" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\tLogo" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t " << std::endl; m_RootKmlFile << "\t\t" << std::endl; /** LOGO **/ } m_RootKmlFile << "\t" << std::endl; m_RootKmlFile << "" << std::endl; m_RootKmlFile.close(); } /** * Add A networkLink to the root kml * */ template void KmzProductWriter ::AddNetworkLinkToRootKML(double north, double south, double east, double west, const std::string& directory, bool addRegion, unsigned int pos) { m_RootKmlFile << "\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << m_FileName<< "" << std::endl; //m_RootKmlFile << "\t\t\t" << m_ProductVector[pos].m_Description << "" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << (east + west) / 2. << "" << std::endl; m_RootKmlFile << "\t\t\t\t" << (south + north) / 2. << "" << std::endl; m_RootKmlFile << "\t\t\t\t35000" << std::endl; m_RootKmlFile << "\t\t\t\t35000" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << m_FileName<< "" << std::endl; m_RootKmlFile << "\t\t\t\t1" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; if (addRegion) { m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; /** If the last depth, put level of detail LOD to infinite (ie -1)*/ if (m_CurrentDepth == m_MaxDepth) m_RootKmlFile << "\t\t\t\t\t\t-1" << std::endl; else m_RootKmlFile << "\t\t\t\t\t\t" << m_TileSize * 4 << "" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t" << north << "" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t" << south << "" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t" << east << "" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t" << west << "" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; } m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << directory << "/0/0/0" << m_KmlExtension << "" << std::endl; m_RootKmlFile << "\t\t\t\t\tonRegion" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\tThe bounding box " << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t-1" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\tbounds/bound_" << pos << m_KmlExtension << "" << std::endl; m_RootKmlFile << "\t\t\t\t\tonRegion" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t" << std::endl; // Add a placemark with the images used as legend // If any this->AddLegendToRootKml(north, south, east, west); m_RootKmlFile << "\t\t" << std::endl; } /** * Add the bounding box kml */ template void KmzProductWriter ::BoundingBoxKmlProcess(double north, double south, double east, double west) { // Create the bounding kml this->GenerateBoundingKML(north, south, east, west); // Add the root kml in the kmz std::ostringstream bound_in_kmz; bound_in_kmz << "bounds/bound_0"<< m_KmlExtension; std::ostringstream bound_absolute_path; bound_absolute_path << m_Path << "/bound_0"<< m_KmlExtension; // Add the root file in the kmz this->AddFileToKMZ(bound_absolute_path, bound_in_kmz); // Remove the bounding files with stdio method :remove if (remove(bound_absolute_path.str().c_str()) != 0) { itkExceptionMacro(<< "Error while deleting the file" << bound_absolute_path.str()); } } /** * Add the legends available * */ template void KmzProductWriter ::AddLegendToRootKml(double north, double south, double east, double west) { double lat = (north + south) / 2.; double lon = (east + west) / 2.; if (m_LegendVector.size() > 0) { m_RootKmlFile << "\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\tLegend" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t"; m_RootKmlFile << "\t\t\t\t\t\t ]]>" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t\t\t" << lon << "," << lat << "" << std::endl; m_RootKmlFile << "\t\t\t\t\t" << std::endl; m_RootKmlFile << "\t\t\t\t" << std::endl; } } template void KmzProductWriter ::GenerateKMLExtended(const std::string& pathname, int depth, int itkNotUsed(x), int y, OutputPointType lowerLeft, OutputPointType lowerRight, OutputPointType upperRight, OutputPointType upperLeft) { std::ostringstream kmlname; kmlname << pathname; kmlname << "/"; kmlname << y << "xt.kml"; std::ofstream fileTest(kmlname.str().c_str()); fileTest << std::fixed << std::setprecision(6); fileTest << "" << std::endl; fileTest << "" << std::endl; fileTest << "\t" << std::endl; fileTest << "\t\t" << y << "xt.kml" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << m_TileSize / 2 << "" << std::endl; fileTest << "\t\t\t\t-1" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << lowerLeft[0] << "," << lowerLeft[1]; fileTest << " " << lowerRight[0] << "," << lowerRight[1]; fileTest << " " << upperRight[0] << "," << upperRight[1]; fileTest << " " << upperLeft[0] << "," << upperLeft[1] << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << depth + (m_CurIdx * m_MaxDepth) << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << y << ".jpg" << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << lowerLeft[0] << "," << lowerLeft[1]; fileTest << " " << lowerRight[0] << "," << lowerRight[1]; fileTest << " " << upperRight[0] << "," << upperRight[1]; fileTest << " " << upperLeft[0] << "," << upperLeft[1] << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t" << std::endl; fileTest << "" << std::endl; fileTest.close(); } template void KmzProductWriter ::GenerateKML(const std::string& pathname, int depth, int itkNotUsed(x), int y, double north, double south, double east, double west) { std::ostringstream kmlname; kmlname << pathname; kmlname << "/"; kmlname << y << ".kml"; std::ofstream fileTest(kmlname.str().c_str()); fileTest << std::fixed << std::setprecision(6); fileTest << "" << std::endl; fileTest << "" << std::endl; fileTest << "\t" << std::endl; fileTest << "\t\t" << y << ".kml" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << m_TileSize / 2 << "" << std::endl; if (m_CurrentDepth == m_MaxDepth) fileTest << "\t\t\t\t-1" << std::endl; else fileTest << "\t\t\t\t" << m_TileSize * 4 << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << north << "" << std::endl; fileTest << "\t\t\t\t" << south << "" << std::endl; fileTest << "\t\t\t\t" << east << "" << std::endl; fileTest << "\t\t\t\t" << west << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << depth + (m_CurIdx * m_MaxDepth) << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << y << ".jpg" << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << north << "" << std::endl; fileTest << "\t\t\t\t" << south << "" << std::endl; fileTest << "\t\t\t\t" << east << "" << std::endl; fileTest << "\t\t\t\t" << west << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t" << std::endl; fileTest << "" << std::endl; fileTest.close(); } template void KmzProductWriter ::GenerateKMLExtendedWithLink(const std::string& pathname, int depth, int itkNotUsed(x), int y, int tileStartX, int tileStartY, OutputPointType lowerLeft, OutputPointType lowerRight, OutputPointType upperRight, OutputPointType upperLeft, double centerLong, double centerLat) { std::ostringstream kmlname; kmlname << pathname; kmlname << "/"; kmlname << y << "xt.kml"; std::ofstream fileTest(kmlname.str().c_str()); fileTest << std::fixed << std::setprecision(6); fileTest << "" << std::endl; fileTest << "" << std::endl; fileTest << "\t" << std::endl; fileTest << "\t\t" << y << "xt.kml" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << m_TileSize / 2 << "" << std::endl; fileTest << "\t\t\t\t-1" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << lowerLeft[0] << "," << lowerLeft[1]; fileTest << " " << lowerRight[0] << "," << lowerRight[1]; fileTest << " " << upperRight[0] << "," << upperRight[1]; fileTest << " " << upperLeft[0] << "," << upperLeft[1] << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << depth + (m_CurIdx * m_MaxDepth) << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << y << ".jpg" << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << lowerLeft[0] << "," << lowerLeft[1]; fileTest << " " << lowerRight[0] << "," << lowerRight[1]; fileTest << " " << upperRight[0] << "," << upperRight[1]; fileTest << " " << upperLeft[0] << "," << upperLeft[1] << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 1 */ std::ostringstream fileTile1; fileTile1 << "../../"; fileTile1 << depth + 1; fileTile1 << "/"; fileTile1 << tileStartX; fileTile1 << "/"; fileTile1 << tileStartY; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile1.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; fileTest << "\t\t\t\t\t-1" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t\t" << lowerLeft[0] << "," << centerLat; fileTest << " " << centerLong << "," << centerLat; fileTest << " " << centerLong << "," << upperLeft[1]; fileTest << " " << upperLeft[0] << "," << upperLeft[1] << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile1.str() << "xt.kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 2 */ std::ostringstream fileTile2; fileTile2 << "../../"; fileTile2 << depth + 1; fileTile2 << "/"; fileTile2 << tileStartX + 1; fileTile2 << "/"; fileTile2 << tileStartY; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile2.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << m_TileSize / 2 << "" << std::endl; fileTest << "\t\t\t\t-1" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t\t" << centerLong << "," << centerLat; fileTest << " " << lowerRight[0] << "," << centerLat; fileTest << " " << upperRight[0] << "," << upperRight[1]; fileTest << " " << centerLong << "," << upperLeft[1] << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile2.str() << "xt.kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 3 */ std::ostringstream fileTile3; fileTile3 << "../../"; fileTile3 << depth + 1; fileTile3 << "/"; fileTile3 << tileStartX + 1; fileTile3 << "/"; fileTile3 << tileStartY + 1; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile3.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; fileTest << "\t\t\t\t\t-1" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t\t" << centerLong << "," << lowerLeft[1]; fileTest << " " << lowerRight[0] << "," << lowerRight[1]; fileTest << " " << upperRight[0] << "," << centerLat; fileTest << " " << centerLong << "," << centerLat << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile3.str() << "xt.kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 4 */ std::ostringstream fileTile4; fileTile4 << "../../"; fileTile4 << depth + 1; fileTile4 << "/"; fileTile4 << tileStartX; fileTile4 << "/"; fileTile4 << tileStartY + 1; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile4.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; fileTest << "\t\t\t\t\t-1" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t\t" << lowerLeft[0] << "," << lowerLeft[1]; fileTest << "\t\t\t\t\t\t" << centerLong << "," << lowerRight[1]; fileTest << "\t\t\t\t\t\t" << centerLong << "," << centerLat; fileTest << "\t\t\t\t\t\t" << upperLeft[0] << "," << centerLat << std::endl; fileTest << "\t\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile4.str() << "xt.kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t" << std::endl; fileTest << "" << std::endl; fileTest.close(); } template void KmzProductWriter ::GenerateKMLWithLink(const std::string& pathname, int depth, int itkNotUsed(x), int y, int tileStartX, int tileStartY, double north, double south, double east, double west, double centerLong, double centerLat) { std::ostringstream kmlname; kmlname << pathname; kmlname << "/"; kmlname << y << ".kml"; std::ofstream fileTest(kmlname.str().c_str()); fileTest << std::fixed << std::setprecision(6); fileTest << "" << std::endl; fileTest << "" << std::endl; fileTest << "\t" << std::endl; fileTest << "\t\t" << y << ".kml" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << m_TileSize / 2 << "" << std::endl; if (m_CurrentDepth == m_MaxDepth) fileTest << "\t\t\t\t-1" << std::endl; else fileTest << "\t\t\t\t" << m_TileSize * 2 << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << north << "" << std::endl; fileTest << "\t\t\t\t" << south << "" << std::endl; fileTest << "\t\t\t\t" << east << "" << std::endl; fileTest << "\t\t\t\t" << west << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << depth + (m_CurIdx * m_MaxDepth) << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << y << ".jpg" << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << north << "" << std::endl; fileTest << "\t\t\t\t" << south << "" << std::endl; fileTest << "\t\t\t\t" << east << "" << std::endl; fileTest << "\t\t\t\t" << west << "" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 1 */ std::ostringstream fileTile1; fileTile1 << "../../"; fileTile1 << depth + 1; fileTile1 << "/"; fileTile1 << tileStartX; fileTile1 << "/"; fileTile1 << tileStartY; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile1.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; if (m_CurrentDepth == m_MaxDepth) fileTest << "\t\t\t\t-1" << std::endl; else fileTest << "\t\t\t\t" << m_TileSize * 2 << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << north << "" << std::endl; fileTest << "\t\t\t\t\t" << centerLat << "" << std::endl; fileTest << "\t\t\t\t\t" << centerLong << "" << std::endl; fileTest << "\t\t\t\t\t" << west << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile1.str() << ".kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 2 */ std::ostringstream fileTile2; fileTile2 << "../../"; fileTile2 << depth + 1; fileTile2 << "/"; fileTile2 << tileStartX + 1; fileTile2 << "/"; fileTile2 << tileStartY; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile2.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; if (m_CurrentDepth == m_MaxDepth) fileTest << "\t\t\t\t-1" << std::endl; else fileTest << "\t\t\t\t" << m_TileSize * 4 << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << north << "" << std::endl; fileTest << "\t\t\t\t\t" << centerLat << "" << std::endl; fileTest << "\t\t\t\t\t" << east << "" << std::endl; fileTest << "\t\t\t\t\t" << centerLong << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile2.str() << ".kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 3 */ std::ostringstream fileTile3; fileTile3 << "../../"; fileTile3 << depth + 1; fileTile3 << "/"; fileTile3 << tileStartX + 1; fileTile3 << "/"; fileTile3 << tileStartY + 1; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile3.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; if (m_CurrentDepth == m_MaxDepth) fileTest << "\t\t\t\t-1" << std::endl; else fileTest << "\t\t\t\t" << m_TileSize * 4 << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << centerLat << "" << std::endl; fileTest << "\t\t\t\t\t" << south << "" << std::endl; fileTest << "\t\t\t\t\t" << east << "" << std::endl; fileTest << "\t\t\t\t\t" << centerLong << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile3.str() << ".kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; /* Sous tuile 4 */ std::ostringstream fileTile4; fileTile4 << "../../"; fileTile4 << depth + 1; fileTile4 << "/"; fileTile4 << tileStartX; fileTile4 << "/"; fileTile4 << tileStartY + 1; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t" << fileTile4.str() << ".jpg" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << m_TileSize / 2 << "" << std::endl; if (m_CurrentDepth == m_MaxDepth) fileTest << "\t\t\t\t-1" << std::endl; else fileTest << "\t\t\t\t" << m_TileSize * 4 << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << centerLat << "" << std::endl; fileTest << "\t\t\t\t\t" << south << "" << std::endl; fileTest << "\t\t\t\t\t" << centerLong << "" << std::endl; fileTest << "\t\t\t\t\t" << west << "" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t" << fileTile4.str() << ".kml" << std::endl; fileTest << "\t\t\t\tonRegion" << std::endl; fileTest << "\t\t\t\t" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t" << std::endl; fileTest << "" << std::endl; fileTest.close(); } template void KmzProductWriter ::GenerateBoundingKML(double north, double south, double east, double west) { std::ostringstream kmlname; kmlname << m_Path; kmlname << "/"; kmlname << "bound_0" << m_KmlExtension; std::ofstream fileTest(kmlname.str().c_str()); fileTest << std::fixed << std::setprecision(6); fileTest << "" << std::endl; fileTest << "" << std::endl; fileTest << "\t" << std::endl; fileTest << "\t\t Bounding box of the product " << m_FileName<< "" << std::endl; fileTest << "\t\t1" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\tThe bounding Box of the image" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t\t0" << std::endl; fileTest << "\t\t\t1" << std::endl; fileTest << "\t\t\tclampedToGround" << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t\t\t\t" << west << "," << north << std::endl; fileTest << "\t\t\t\t\t" << east << "," << north << std::endl; fileTest << "\t\t\t\t\t" << east << "," << south << std::endl; fileTest << "\t\t\t\t\t" << west << "," << south << std::endl; fileTest << "\t\t\t\t\t" << west << "," << north << std::endl; fileTest << "\t\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t\t" << std::endl; fileTest << "\t" << std::endl; fileTest << "" << std::endl; fileTest.close(); } /** */ template std::string KmzProductWriter ::GetCuttenFileName(const std::string& itkNotUsed(description), unsigned int idx) { std::string currentImageName; std::string tempName; std::ostringstream oss; oss << "tiles_" << idx; tempName = oss.str(); // Replace all the blanks in the string unsigned int i = 0; while (i < tempName.length()) { if (tempName[i] != ' ') currentImageName += tempName[i]; ++i; } return currentImageName; } template void KmzProductWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call the superclass implementation Superclass::PrintSelf(os, indent); } template void KmzProductWriter :: SetTileSize(unsigned int tileSize) { if (tileSize >1 ) m_TileSize = tileSize; else itkExceptionMacro(<< "Tile size is incorrect, it should be superior to 1"); } } #endif OTB-release-5.8/Modules/IO/KMZWriter/otb-module.cmake000066400000000000000000000006351301006202600222500ustar00rootroot00000000000000set(DOCUMENTATION "This module contains features to write kmz files (supported by Google Earth).") otb_module(OTBKMZWriter DEPENDS OTBITK OTBImageBase OTBImageIO OTBImageManipulation OTBOSSIMAdapters OTBTransform OTBVectorDataBase OTBVectorDataIO OTBlibkml TEST_DEPENDS OTBCommandLineParser OTBProjection OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/KMZWriter/test/000077500000000000000000000000001301006202600201525ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/KMZWriter/test/CMakeLists.txt000066400000000000000000000073441301006202600227220ustar00rootroot00000000000000otb_module_test() set(OTBKMZWriterTests otbKMZWriterTestDriver.cxx otbKmzProductWriter.cxx ) add_executable(otbKMZWriterTestDriver ${OTBKMZWriterTests}) target_link_libraries(otbKMZWriterTestDriver ${OTBKMZWriter-Test_LIBRARIES}) otb_module_target_label(otbKMZWriterTestDriver) # Tests Declaration otb_add_test(NAME ioTvKmzProductWriterWithGCP COMMAND otbKMZWriterTestDriver otbKmzProductWriter ${INPUTDATA}/Haiti1.jpeg ${INPUTDATA}/DEM/srtm_directory ${TEMP}/ioTuHaitiKmzProduct.kmz 1980.000000 1986.000000 -72.351257 18.555075 0.000000 1963.000000 1944.000000 -72.352051 18.556946 0.000000 2078.000000 1566.000000 -72.346130 18.574358 0.000000 2154.000000 1430.000000 -72.342377 18.580441 0.000000 2432.000000 1408.000000 -72.328964 18.581335 0.000000 2558.000000 934.000000 -72.322571 18.602974 0.000000 3492.000000 1397.000000 -72.278343 18.580887 0.000000 2890.000000 1439.000000 -72.306908 18.579464 0.000000 2098.000000 2469.000000 -72.345741 18.532839 0.000000 1941.000000 2473.000000 -72.353317 18.532595 0.00000 1644.000000 2409.000000 -72.367691 18.535810 0.000000 1440.000000 2448.000000 -72.377457 18.534243 0.000000 687.000000 2005.000000 -72.413315 18.554974 0.000000 741.000000 2366.000000 -72.410934 18.538496 0.000000 855.000000 2802.000000 -72.405739 18.518456 0.000000 1936.000000 2855.000000 -72.353920 18.515240 0.000000 3338.000000 2824.000000 -72.286240 18.515160 0.000000 3715.000000 1772.000000 -72.267570 18.563681 0.000000 3676.000000 1580.000000 -72.269203 18.572529 0.000000 3395.000000 931.000000 -72.282402 18.602425 0.000000 3426.000000 856.000000 -72.280792 18.605862 0.000000 2822.000000 707.000000 -72.309692 18.613203 0.000000 1891.000000 360.000000 -72.354301 18.629776 0.000000 3989.000000 2639.000000 -72.255020 18.523664 0.000000 417.000000 2317.000000 -72.426552 18.540876 0.000000 ) otb_add_test(NAME ioTuKmzProductWriterNew COMMAND otbKMZWriterTestDriver otbKmzProductWriterNew ) otb_add_test(NAME ioTvKmzProductWriterWithGCP_Logo_Legend COMMAND otbKMZWriterTestDriver otbKmzProductWriterWithLogoAndLegend -in ${INPUTDATA}/Haiti1.jpeg -lo ${INPUTDATA}/cnes.png -le ${INPUTDATA}/otb_big.png -dem ${INPUTDATA}/DEM/srtm_directory -kmz ${TEMP}/ioTuHaitiKmzProductWithLogoAndLegend.kmz -gcp 1980.000000 1986.000000 -72.351257 18.555075 0.000000 1963.000000 1944.000000 -72.352051 18.556946 0.000000 2078.000000 1566.000000 -72.346130 18.574358 0.000000 2154.000000 1430.000000 -72.342377 18.580441 0.000000 2432.000000 1408.000000 -72.328964 18.581335 0.000000 2558.000000 934.000000 -72.322571 18.602974 0.000000 3492.000000 1397.000000 -72.278343 18.580887 0.000000 2890.000000 1439.000000 -72.306908 18.579464 0.000000 2098.000000 2469.000000 -72.345741 18.532839 0.000000 1941.000000 2473.000000 -72.353317 18.532595 0.00000 1644.000000 2409.000000 -72.367691 18.535810 0.000000 1440.000000 2448.000000 -72.377457 18.534243 0.000000 687.000000 2005.000000 -72.413315 18.554974 0.000000 741.000000 2366.000000 -72.410934 18.538496 0.000000 855.000000 2802.000000 -72.405739 18.518456 0.000000 1936.000000 2855.000000 -72.353920 18.515240 0.000000 3338.000000 2824.000000 -72.286240 18.515160 0.000000 3715.000000 1772.000000 -72.267570 18.563681 0.000000 3676.000000 1580.000000 -72.269203 18.572529 0.000000 3395.000000 931.000000 -72.282402 18.602425 0.000000 3426.000000 856.000000 -72.280792 18.605862 0.000000 2822.000000 707.000000 -72.309692 18.613203 0.000000 1891.000000 360.000000 -72.354301 18.629776 0.000000 3989.000000 2639.000000 -72.255020 18.523664 0.000000 417.000000 2317.000000 -72.426552 18.540876 0.000000 ) set_property(TEST ioTvKmzProductWriterWithGCP_Logo_Legend PROPERTY DEPENDS ioTvKmzProductWriterWithGCP) OTB-release-5.8/Modules/IO/KMZWriter/test/otbKMZWriterTestDriver.cxx000066400000000000000000000002701301006202600252540ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbKmzProductWriterNew); REGISTER_TEST(otbKmzProductWriter); REGISTER_TEST(otbKmzProductWriterWithLogoAndLegend); } OTB-release-5.8/Modules/IO/KMZWriter/test/otbKmzProductWriter.cxx000066400000000000000000000166361301006202600247160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbKmzProductWriter.h" #include "otbGCPsToRPCSensorModelImageFilter.h" #include "otbCommandLineArgumentParser.h" typedef otb::VectorImage ImageType; typedef otb::KmzProductWriter KmzProductWriterType; typedef otb::ImageFileReader ReaderType; typedef otb::GCPsToRPCSensorModelImageFilter GCPsToSensorModelFilterType; typedef GCPsToSensorModelFilterType::Point2DType Point2DType; typedef GCPsToSensorModelFilterType::Point3DType Point3DType; int otbKmzProductWriterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { KmzProductWriterType::Pointer kmzWriter = KmzProductWriterType::New(); return EXIT_SUCCESS; } int otbKmzProductWriter(int argc, char* argv[]) { if (argc < 3) { std::cerr << "Usage: " << argv[0] << " infname demPath kmzFileName " <<"a1x a1y b1x b1y b1z ... aNx aNy aNz bNx bNy bNz" << std::endl; return EXIT_FAILURE; } else if ((argc - 4) % 5 != 0) { std::cout <<"argc " << argc << std::endl; std::cerr << "Inconsistent GCPs description!" << std::endl; return EXIT_FAILURE; } // Get the cli arguments const char * infname = argv[1]; const char * demPath = argv[2]; const char * kmzFileName = argv[3]; // Instantiate reader ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); otb::DEMHandler::Instance()->OpenDEMDirectory(demPath); GCPsToSensorModelFilterType::Pointer rpcEstimator = GCPsToSensorModelFilterType::New(); rpcEstimator->SetInput(reader->GetOutput()); unsigned int nbGCPs = (argc - 4) / 5; std::cout << "Receiving " << nbGCPs << " from command line." << std::endl; for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { Point2DType sensorPoint; sensorPoint[0] = atof(argv[4 + gcpId * 5]); sensorPoint[1] = atof(argv[5 + gcpId * 5]); Point3DType geoPoint; geoPoint[0] = atof(argv[6 + 5 * gcpId]); geoPoint[1] = atof(argv[7 + 5 * gcpId]); geoPoint[2] = atof(argv[8 + 5 * gcpId]); std::cout << "Adding GCP sensor: " << sensorPoint << " <-> geo: " << geoPoint << std::endl; rpcEstimator->AddGCP(sensorPoint, geoPoint); } rpcEstimator->GetOutput()->UpdateOutputInformation(); std::cout << "Residual ground error: " << rpcEstimator->GetRMSGroundError() << std::endl; // Second part : Image To Kmz KmzProductWriterType::Pointer kmzWriter = KmzProductWriterType::New(); kmzWriter->SetInput(rpcEstimator->GetOutput()); kmzWriter->SetPath(kmzFileName); kmzWriter->Update(); return EXIT_SUCCESS; } int otbKmzProductWriterWithLogoAndLegend(int argc, char* argv[]) { // Parse command line parameters typedef otb::CommandLineArgumentParser ParserType; ParserType::Pointer parser = ParserType::New(); parser->SetProgramDescription("Chain that Estimate a sensor model in order to export the input image to Google Earth understandable format Kmz"); parser->AddInputImage(); parser->AddOption("--OutputProductName", "Output Kmz product ", "-kmz", 1, true); parser->AddOption("--LogoImage", "Output Kmz product ", "-lo", 1, false); parser->AddOption("--LegendImage", "Output Kmz product ", "-le", 1, false); parser->AddOption("--DEMDirectory", "Path to the DEM directory ", "-dem", 1, true); parser->AddOptionNParams("--GroudControlPoints", "Ground Control Points to estimate sensor model a1x a1y b1x b1y b1z ... aNx aNy aNz bNx bNy bNz", "-gcp", true); typedef otb::CommandLineArgumentParseResult ParserResultType; ParserResultType::Pointer parseResult = ParserResultType::New(); try { parser->ParseCommandLine(argc, argv, parseResult); } catch ( itk::ExceptionObject & err ) { std::string descriptionException = err.GetDescription(); if (descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos) { return EXIT_SUCCESS; } if (descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos) { return EXIT_SUCCESS; } return EXIT_FAILURE; } // Check if the number of gcp pairs point is consistent unsigned int nbPoints = parseResult->GetNumberOfParameters("--GroudControlPoints"); if (nbPoints % 5 != 0) { std::cout <<"argc " << argc << std::endl; std::cerr << "Inconsistent GCPs description!" << std::endl; return EXIT_FAILURE; } // Instantiate reader ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(parseResult->GetInputImage()); GCPsToSensorModelFilterType::Pointer rpcEstimator = GCPsToSensorModelFilterType::New(); rpcEstimator->SetInput(reader->GetOutput()); std::cout << "Receiving " << nbPoints << " from command line." << std::endl; unsigned int nbGCPs = nbPoints/5; for (unsigned int gcpId = 0; gcpId < nbGCPs; ++gcpId) { Point2DType sensorPoint; sensorPoint[0] = parseResult->GetParameterFloat("--GroudControlPoints", gcpId * 5); sensorPoint[1] = parseResult->GetParameterFloat("--GroudControlPoints", 1 + gcpId * 5); Point3DType geoPoint; geoPoint[0] = parseResult->GetParameterFloat("--GroudControlPoints", 2 + gcpId * 5); geoPoint[1] = parseResult->GetParameterFloat("--GroudControlPoints", 3 + gcpId * 5); geoPoint[2] = parseResult->GetParameterFloat("--GroudControlPoints", 4 + gcpId * 5); std::cout << "Adding GCP sensor: " << sensorPoint << " <-> geo: " << geoPoint << std::endl; rpcEstimator->AddGCP(sensorPoint, geoPoint); } rpcEstimator->GetOutput()->UpdateOutputInformation(); std::cout << "Residual ground error: " << rpcEstimator->GetRMSGroundError() << std::endl; // Second part : Image To Kmz KmzProductWriterType::Pointer kmzWriter = KmzProductWriterType::New(); kmzWriter->SetInput(rpcEstimator->GetOutput()); kmzWriter->SetPath(parseResult->GetParameterString("--OutputProductName")); // Read the logo if any if(parseResult->IsOptionPresent("--LogoImage")) { ReaderType::Pointer logoReader = ReaderType::New(); logoReader->SetFileName(parseResult->GetParameterString("--LogoImage")); logoReader->Update(); kmzWriter->SetLogo(logoReader->GetOutput()); } // Read the legend if any if(parseResult->IsOptionPresent("--LegendImage")) { ReaderType::Pointer legendReader = ReaderType::New(); legendReader->SetFileName(parseResult->GetParameterString("--LegendImage")); legendReader->Update(); kmzWriter->AddLegend("Input Legend", legendReader->GetOutput()); kmzWriter->AddLegend(legendReader->GetOutput()); } // Set the DEM Directory if any if(parseResult->IsOptionPresent("--DEMDirectory")) { otb::DEMHandler::Instance()->OpenDEMDirectory(parseResult->GetParameterString("--DEMDirectory")); } // trigger the writing kmzWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/000077500000000000000000000000001301006202600174155ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/TestKernel/CMakeLists.txt000066400000000000000000000001251301006202600221530ustar00rootroot00000000000000project(OTBTestKernel) set(OTBTestKernel_LIBRARIES OTBTestKernel) otb_module_impl() OTB-release-5.8/Modules/IO/TestKernel/include/000077500000000000000000000000001301006202600210405ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/TestKernel/include/otbDifferenceImageFilter.h000066400000000000000000000105161301006202600260640ustar00rootroot00000000000000#ifndef otbDifferenceImageFilter_h #define otbDifferenceImageFilter_h #include "itkImageToImageFilter.h" #include "itkNumericTraits.h" #include "itkArray.h" namespace otb { /** \class DifferenceImageFilter * \brief Implements comparison between two images. * * This filter is used by the testing system to compute the difference between * a valid image and an image produced by the test. The comparison value is * computed by visiting all the pixels in the baseline images and comparing * their values with the pixel values in the neighborhood of the homologous * pixel in the other image. * * \ingroup IntensityImageFilters Multithreaded * * \ingroup OTBTestKernel */ template class ITK_EXPORT DifferenceImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef DifferenceImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DifferenceImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename itk::NumericTraits::RealType RealType; typedef typename itk::NumericTraits::AccumulateType AccumulateType; typedef typename itk::NumericTraits ::ScalarRealType ScalarRealType; /** Set the valid image input. This will be input 0. */ virtual void SetValidInput(const InputImageType* validImage); /** Set the test image input. This will be input 1. */ virtual void SetTestInput(const InputImageType* testImage); /** Set/Get the maximum distance away to look for a matching pixel. Default is 0. */ itkSetMacro(ToleranceRadius, int); itkGetMacro(ToleranceRadius, int); /** Set/Get the minimum threshold for pixels to be different (relative). Default is 0. */ itkSetMacro(DifferenceThreshold, ScalarRealType); itkGetMacro(DifferenceThreshold, ScalarRealType); /** Get parameters of the difference image after execution. */ itkGetMacro(MeanDifference, RealType); itkGetMacro(TotalDifference, AccumulateType); itkGetMacro(NumberOfPixelsWithDifferences, unsigned long); protected: DifferenceImageFilter(); ~DifferenceImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** DifferenceImageFilter can be implemented as a multithreaded * filter. Therefore, this implementation provides a * ThreadedGenerateData() routine which is called for each * processing thread. The output image data is allocated * automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to * the portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType& threadRegion, itk::ThreadIdType threadId) ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void AfterThreadedGenerateData() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; ScalarRealType m_DifferenceThreshold; RealType m_MeanDifference; AccumulateType m_TotalDifference; unsigned long m_NumberOfPixelsWithDifferences; int m_ToleranceRadius; std::vector m_ThreadDifferenceSum; itk::Array m_ThreadNumberOfPixels; private: DifferenceImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDifferenceImageFilter.txx" #endif #endif OTB-release-5.8/Modules/IO/TestKernel/include/otbDifferenceImageFilter.txx000066400000000000000000000253371301006202600264670ustar00rootroot00000000000000#ifndef otbDifferenceImageFilter_txx #define otbDifferenceImageFilter_txx #include "otbDifferenceImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" #include "itkDefaultConvertPixelTraits.h" namespace otb { //---------------------------------------------------------------------------- template DifferenceImageFilter ::DifferenceImageFilter() { // We require two inputs to execute. this->SetNumberOfRequiredInputs(2); // Set the default DifferenceThreshold. m_DifferenceThreshold = itk::NumericTraits::Zero; // Set the default ToleranceRadius. m_ToleranceRadius = 0; // Initialize statistics about difference image. itk::NumericTraits::SetLength( m_MeanDifference, itk::DefaultConvertPixelTraits::GetNumberOfComponents()); itk::NumericTraits::SetLength( m_TotalDifference, itk::DefaultConvertPixelTraits::GetNumberOfComponents()); m_MeanDifference = itk::NumericTraits::ZeroValue(m_MeanDifference); m_TotalDifference = itk::NumericTraits::ZeroValue(m_TotalDifference); m_NumberOfPixelsWithDifferences = 0; } //---------------------------------------------------------------------------- template void DifferenceImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "ToleranceRadius: " << m_ToleranceRadius << "\n"; os << indent << "DifferenceThreshold: " << m_DifferenceThreshold << "\n"; os << indent << "MeanDifference: " << m_MeanDifference << "\n"; os << indent << "TotalDifference: " << m_TotalDifference << "\n"; os << indent << "NumberOfPixelsWithDifferences: " << m_NumberOfPixelsWithDifferences << "\n"; } //---------------------------------------------------------------------------- template void DifferenceImageFilter ::SetValidInput(const InputImageType* validImage) { // The valid image should be input 0. this->SetInput(0, validImage); } //---------------------------------------------------------------------------- template void DifferenceImageFilter ::SetTestInput(const InputImageType* testImage) { // The test image should be input 1. this->SetInput(1, testImage); } template void DifferenceImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput(0)->GetNumberOfComponentsPerPixel() != this->GetInput(1)->GetNumberOfComponentsPerPixel()) { itkExceptionMacro(<< "Image 1 has " << this->GetInput( 0)->GetNumberOfComponentsPerPixel() << " bands, whereas image 2 has " << this->GetInput( 1)->GetNumberOfComponentsPerPixel()); } this->GetOutput()->SetNumberOfComponentsPerPixel(this->GetInput(0)->GetNumberOfComponentsPerPixel()); } //---------------------------------------------------------------------------- template void DifferenceImageFilter ::BeforeThreadedGenerateData() { int numberOfThreads = this->GetNumberOfThreads(); itk::NumericTraits::SetLength( m_MeanDifference, this->GetInput(0)->GetNumberOfComponentsPerPixel()); itk::NumericTraits::SetLength( m_TotalDifference, this->GetInput(0)->GetNumberOfComponentsPerPixel()); // Initialize statistics about difference image. m_MeanDifference = itk::NumericTraits::ZeroValue(m_MeanDifference); m_TotalDifference = itk::NumericTraits::ZeroValue(m_TotalDifference); m_NumberOfPixelsWithDifferences = 0; // Resize the thread temporaries m_ThreadDifferenceSum.reserve(numberOfThreads); m_ThreadNumberOfPixels.SetSize(numberOfThreads); // Initialize the temporaries for (int i = 0; i < numberOfThreads; ++i) { m_ThreadDifferenceSum.push_back(m_TotalDifference); } m_ThreadNumberOfPixels.Fill(0); } //---------------------------------------------------------------------------- template void DifferenceImageFilter ::ThreadedGenerateData(const OutputImageRegionType& threadRegion, itk::ThreadIdType threadId) { typedef itk::ConstNeighborhoodIterator SmartIterator; typedef itk::ImageRegionConstIterator InputIterator; typedef itk::ImageRegionIterator OutputIterator; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator FacesCalculator; typedef typename FacesCalculator::RadiusType RadiusType; typedef typename FacesCalculator::FaceListType FaceListType; typedef typename FaceListType::iterator FaceListIterator; typedef typename InputImageType::PixelType InputPixelType; // Prepare standard boundary condition. itk::ZeroFluxNeumannBoundaryCondition nbc; // Get a pointer to each image. const InputImageType* validImage = this->GetInput(0); const InputImageType* testImage = this->GetInput(1); OutputImageType* outputPtr = this->GetOutput(); // Create a radius of pixels. RadiusType radius; if (m_ToleranceRadius > 0) { radius.Fill(m_ToleranceRadius); } else { radius.Fill(0); } // Find the data-set boundary faces. FacesCalculator boundaryCalculator; FaceListType faceList = boundaryCalculator(testImage, threadRegion, radius); // Support progress methods/callbacks. itk::ProgressReporter progress(this, threadId, threadRegion.GetNumberOfPixels()); // Process the internal face and each of the boundary faces. for (FaceListIterator face = faceList.begin(); face != faceList.end(); ++face) { SmartIterator test(radius, testImage, *face); // Iterate over test image. InputIterator valid(validImage, *face); // Iterate over valid image. OutputIterator out(outputPtr, *face); // Iterate over output image. test.OverrideBoundaryCondition(&nbc); for (valid.GoToBegin(), test.GoToBegin(), out.GoToBegin(); !valid.IsAtEnd(); ++valid, ++test, ++out) { // Get the current valid pixel. InputPixelType t = valid.Get(); // Find the closest-valued pixel in the neighborhood of the test // image. OutputPixelType minimumDifference = itk::NumericTraits::max(t); unsigned int neighborhoodSize = test.Size(); for (unsigned int i = 0; i < neighborhoodSize; ++i) { // Use the RealType for the difference to make sure we get the // sign. RealType difference = static_cast(t) - static_cast(test.GetPixel(i)); for (unsigned int j = 0; j < itk::NumericTraits::GetLength(difference) ; ++j) { ScalarRealType d = static_cast( itk::DefaultConvertPixelTraits::GetNthComponent(j,difference)); if (d < 0) { d *= -1; } ScalarRealType m = static_cast( itk::DefaultConvertPixelTraits::GetNthComponent(j,minimumDifference)); if (d < m) { itk::DefaultConvertPixelTraits::SetNthComponent( j, minimumDifference, d); // std::cout << std::setprecision(16) << minimumDifference[j] << std::endl; // std::cout << std::setprecision(16) << t << std::endl; // std::cout << std::setprecision(16) << test.GetPixel(i) << std::endl; // std::cout << "----------------------" << std::endl; } } } //for complex and vector type. FIXME: module might be better // ScalarRealType tMax=vcl_abs(t[0]); ScalarRealType tMax = 0.01; //Avoiding the 0 case for neighborhood computing // NB: still more restrictive than before for small values. for (unsigned int j = 0; j < itk::NumericTraits::GetLength(t); ++j) { ScalarRealType tc = static_cast( itk::DefaultConvertPixelTraits::GetNthComponent(j,t)); if (vcl_abs(tc) > tMax) tMax = vcl_abs(tc); } // Check if difference is above threshold // the threshold is interpreted as relative to the value bool isDifferent = false; for (unsigned int j = 0; j < itk::NumericTraits::GetLength(minimumDifference); ++j) { ScalarRealType m = static_cast( itk::DefaultConvertPixelTraits::GetNthComponent(j,minimumDifference)); if (m > m_DifferenceThreshold * tMax) { // std::cout << std::setprecision(16) << minimumDifference[j] << std::endl; isDifferent = true; } } if (isDifferent) { // Store the minimum difference value in the output image. out.Set(minimumDifference); // Update difference image statistics. m_ThreadDifferenceSum[threadId] += minimumDifference; m_ThreadNumberOfPixels[threadId]++; } else { // Difference is below threshold. out.Set(itk::NumericTraits::ZeroValue(minimumDifference)); } // Update progress. progress.CompletedPixel(); } } } //---------------------------------------------------------------------------- template void DifferenceImageFilter ::AfterThreadedGenerateData() { // Set statistics about difference image. int numberOfThreads = this->GetNumberOfThreads(); for (int i = 0; i < numberOfThreads; ++i) { m_TotalDifference += m_ThreadDifferenceSum[i]; m_NumberOfPixelsWithDifferences += m_ThreadNumberOfPixels[i]; } // Get the total number of pixels processed in the region. // This is different from the m_TotalNumberOfPixels which // is the number of pixels that actually have differences // above the intensity threshold. OutputImageRegionType region = this->GetOutput()->GetRequestedRegion(); unsigned int numberOfPixels = region.GetNumberOfPixels(); // Calculate the mean difference. m_MeanDifference = m_TotalDifference / numberOfPixels; } } // end namespace otb #endif OTB-release-5.8/Modules/IO/TestKernel/include/otbTestHelper.h000066400000000000000000000147431301006202600240060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTestHelper_h #define otbTestHelper_h #include #include #include #include "itkObject.h" #include "itkObjectFactory.h" #include "otbStringUtils.h" #include "otbMetaDataKey.h" class OGRFeature; class OGRGeometry; class OGRLayer; namespace otb { /** * \class TestHelper * \brief Helper class to perform the baseline comparisons during the tests * * \ingroup OTBTestKernel */ class ITK_ABI_EXPORT TestHelper : public itk::Object { public: /** Standard class typedefs. */ typedef TestHelper Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Object Superclass; itkTypeMacro(TestHelper, itk::Object); itkNewMacro(Self); typedef std::vector StringList; typedef StringList::const_iterator StringListIt; TestHelper() : m_ToleranceDiffValue(0), m_Epsilon(0), m_EpsilonBoundaryChecking(1.0e-30), m_ReportErrors(false), m_IgnoreLineOrder(false), m_MaxArea(1024*1024) { m_SpecialTokens.push_back(std::pair( std::string("Integer"),std::string("Integer64"))); } ~TestHelper() ITK_OVERRIDE{} int RegressionTestAllImages(const StringList& baselineFilenamesImage, const StringList& testFilenamesImage); int RegressionTestAllMetaData(const StringList& baselineFilenamesMetaData, const StringList& testFilenamesMetaData); int RegressionTestAllAscii(const StringList& baselineFilenamesAscii, const StringList& testFilenamesAscii, const StringList& ignoredLines); int RegressionTestAllDiff(const StringList& baselineFilenamesAscii, const StringList& testFilenamesAscii, const StringList& ignoredLines); int RegressionTestAllBinary(const StringList& baselineFilenamesBinary, const StringList& testFilenamesBinary); int RegressionTestAllOgr(const StringList& baselineFilenamesOgr, const StringList& testFilenamesOgr); itkSetMacro(ReportErrors, bool); itkBooleanMacro(ReportErrors); itkSetMacro(IgnoreLineOrder, bool); itkBooleanMacro(IgnoreLineOrder); itkSetMacro(ToleranceDiffValue, double); itkSetMacro(Epsilon, double); itkSetMacro(EpsilonBoundaryChecking, double); private: std::map RegressionTestBaselines(char *baselineFilename) const; int RegressionTestImage(int cpt, const char *testImageFilename, const char *baselineImageFilename, const double toleranceDiffPixelImage) const; int RegressionTestOgrFile(const char *testOgrFilename, const char *baselineOgrFilename, const double toleranceDiffValue) const; int RegressionTestBinaryFile(const char * testBinaryFileName, const char * baselineBinaryFileName) const; int RegressionTestAsciiFile(const char * testAsciiFileName, const char * baselineAsciiFileName, const double epsilon, std::vector ignoredLines) const; int RegressionTestDiffFile(const char * testAsciiFileName, const char * baselineAsciiFileName, const double epsilon, std::vector ignoredLines) const; int RegressionTestMetaData(const char *testImageFilename, const char *baselineImageFilename, const double toleranceDiffPixelImage) const; bool isNumber(int i) const; bool isHexaNumber(int i) const; bool isPoint(int i) const; bool isMinusSign(int i) const; bool isAlphaNum(int i) const; bool isNumeric(const std::string& str) const; bool isScientificNumeric(const std::string& str) const; bool isHexaPointerAddress(const std::string& str) const; bool isHexaPointerAddress(const std::string& str, size_t pos, size_t size) const; bool isToBeIgnoredForAnyComparison(const std::string& str) const; std::string VectorToString(const otb::MetaDataKey::VectorType& vector) const; int TokenizeLine(const std::string &line, StringList &tokens) const; static bool IsTokenEmpty(boost::iterator_range &token); // TODO : maybe merge this function with isToBeIgnoredForAnyComparison bool IsLineValid(const std::string& str, const StringList &ignoredLines) const; //FIXME parameters have to be cleaned up later (this is the first step of refactoring) bool CompareLines(const std::string& strfileref, const std::string& strfiletest, int& nbdiff, std::ofstream& fluxfilediff, int& numLine, std::vector& listStrDiffLineFileRef, std::vector& listStrDiffLineFileTest, double epsilon) const; void ogrReportOnLayer(OGRLayer * ref_poLayer, const char *ref_pszWHERE, OGRGeometry *ref_poSpatialFilter, OGRLayer * test_poLayer, const char *test_pszWHERE, OGRGeometry *test_poSpatialFilter, int& nbdiff) const; static void DumpOGRFeature(FILE* fileid, OGRFeature* feature, char** papszOptions = ITK_NULLPTR); static void DumpOGRGeometry(FILE* fileid, OGRGeometry* geometry, const char * pszPrefix, char** papszOptions = ITK_NULLPTR); double m_ToleranceDiffValue; double m_Epsilon; double m_EpsilonBoundaryChecking; bool m_ReportErrors; bool m_IgnoreLineOrder; const unsigned int m_MaxArea; void AddWhiteSpace(const std::string& strIn, std::string &strOut) const; std::vector > m_SpecialTokens; }; } #endif OTB-release-5.8/Modules/IO/TestKernel/include/otbTestMain.h000066400000000000000000000327651301006202600234570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTestMain_h #define otbTestMain_h #include "otbConfigure.h" #include #include #include #include "itkMultiThreader.h" #include "itkMacro.h" #include "otbOGRDriversInit.h" #include "otbTestHelper.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #ifdef OTB_USE_MPI #include "otbMPIConfig.h" #endif typedef int (*MainFuncPointer)(int, char*[]); std::map StringToTestFunctionMap; #define REGISTER_TEST(test) \ extern int test(int, char*[]); \ StringToTestFunctionMap[# test] = test void RegisterTests(); void PrintAvailableTests() { std::cout << "Tests available:\n"; std::map::iterator j = StringToTestFunctionMap.begin(); int i = 0; while (j != StringToTestFunctionMap.end()) { std::cout << i << ". " << j->first << "\n"; ++i; ++j; } } //apply dedicated treatment to test void LoadTestEnv() { //Set seed for rand and itk mersenne twister srand(1); itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->SetSeed(121212); } int main(int ac, char* av[]) { #ifdef OTB_USE_MPI otb::MPIConfig::Instance()->Init(ac,av); #endif bool lFlagRegression(false); double lToleranceDiffValue(0); double lEpsilon(0); bool lIgnoreOrder(false); double epsilonBoundary(0.0); typedef otb::TestHelper::StringList StringList; StringList baselineFilenamesBinary; StringList testFilenamesBinary; StringList baselineFilenamesMetaData; StringList testFilenamesMetaData; StringList baselineFilenamesOgr; StringList testFilenamesOgr; StringList baselineFilenamesImage; StringList testFilenamesImage; StringList baselineFilenamesAscii; StringList testFilenamesAscii; StringList ignoredLines; ignoredLines.clear(); otb::ogr::Drivers::Init(); otb::TestHelper::Pointer testHelper = otb::TestHelper::New(); RegisterTests(); LoadTestEnv(); // load specific treatments for testing std::string testToRun; if (ac < 2) { PrintAvailableTests(); std::cout << "To launch a test, enter its number: "; int testNum = 0; std::cin >> testNum; std::map::iterator j = StringToTestFunctionMap.begin(); int i = 0; while (j != StringToTestFunctionMap.end() && i < testNum) { ++i; ++j; } if (j == StringToTestFunctionMap.end()) { std::cerr << testNum << " is not a valid test number\n"; return -1; } testToRun = j->first; } else { if (strcmp(av[1], "--with-threads") == 0) { int numThreads = atoi(av[2]); itk::MultiThreader::SetGlobalDefaultNumberOfThreads(numThreads); av += 2; ac -= 2; } else if (strcmp(av[1], "--without-threads") == 0) { itk::MultiThreader::SetGlobalDefaultNumberOfThreads(1); av += 1; ac -= 1; } if (strcmp(av[1], "--ignore-order") == 0) { lIgnoreOrder = true; av += 1; ac -= 1; } if (strcmp(av[1], "--epsilon-boundary") == 0) { epsilonBoundary = atof(av[2]); av += 2; ac -= 2; } if (strcmp(av[1], "--compare-image") == 0) { lFlagRegression = true; lToleranceDiffValue = (double) (::atof(av[2])); baselineFilenamesImage.reserve(1); testFilenamesImage.reserve(1); baselineFilenamesImage.push_back(av[3]); testFilenamesImage.push_back(av[4]); av += 4; ac -= 4; } else if (strcmp(av[1], "--compare-n-images") == 0) { lFlagRegression = true; lToleranceDiffValue = (double) (::atof(av[2])); // Number of comparisons to do unsigned int nbComparisons = (unsigned int) (::atoi(av[3])); baselineFilenamesImage.reserve(nbComparisons); testFilenamesImage.reserve(nbComparisons); // Retrieve all the file names for (unsigned int i = 0; i < nbComparisons; ++i) { baselineFilenamesImage.push_back(av[4 + 2 * i]); testFilenamesImage.push_back(av[5 + 2 * i]); } av += 3 + 2 * nbComparisons; ac -= 3 + 2 * nbComparisons; } else if (strcmp(av[1], "--compare-binary") == 0) { lFlagRegression = true; baselineFilenamesBinary.reserve(1); testFilenamesBinary.reserve(1); baselineFilenamesBinary.push_back(av[2]); testFilenamesBinary.push_back(av[3]); av += 3; ac -= 3; } else if (strcmp(av[1], "--compare-n-binary") == 0) { lFlagRegression = true; unsigned int nbComparisons = (unsigned int) (::atoi(av[2])); baselineFilenamesBinary.reserve(nbComparisons); testFilenamesBinary.reserve(nbComparisons); // Retrieve all the file names for (unsigned int i = 0; i < nbComparisons; ++i) { baselineFilenamesBinary.push_back(av[3 + 2 * i]); testFilenamesBinary.push_back(av[4 + 2 * i]); } av += 2 + 2 * nbComparisons; ac -= 2 + 2 * nbComparisons; } /************************************************************************/ // COMPARE ASCII else if (strcmp(av[1], "--compare-ascii") == 0) { lFlagRegression = true; lEpsilon = (double) (::atof(av[2])); baselineFilenamesAscii.reserve(1); testFilenamesAscii.reserve(1); baselineFilenamesAscii.push_back(av[3]); testFilenamesAscii.push_back(av[4]); av += 4; ac -= 4; if (ac > 1) { if (strcmp(av[1], "--ignore-lines-with") == 0) { unsigned int nbIgnoredLines = (unsigned int) (::atoi(av[2])); for (unsigned int i = 0; i < nbIgnoredLines; ++i) { ignoredLines.push_back(av[3 + i]); } av += 2 + nbIgnoredLines; ac -= 2 + nbIgnoredLines; } } } /************************************************************************/ else if (strcmp(av[1], "--compare-n-ascii") == 0) { lFlagRegression = true; lEpsilon = (double) (::atof(av[2])); // Number of comparisons to do unsigned int nbComparisons = (unsigned int) (::atoi(av[3])); baselineFilenamesAscii.reserve(nbComparisons); testFilenamesAscii.reserve(nbComparisons); // Retrieve all the file names for (unsigned int i = 0; i < nbComparisons; ++i) { baselineFilenamesAscii.push_back(av[4 + 2 * i]); testFilenamesAscii.push_back(av[5 + 2 * i]); } av += 3 + 2 * nbComparisons; ac -= 3 + 2 * nbComparisons; if (ac > 1) { if (strcmp(av[1], "--ignore-lines-with") == 0) { unsigned int nbIgnoredLines = (unsigned int) (::atoi(av[2])); for (unsigned int i = 0; i < nbIgnoredLines; ++i) { ignoredLines.push_back(av[3 + i]); } av += 2 + nbIgnoredLines; ac -= 2 + nbIgnoredLines; } } } else if (strcmp(av[1], "--compare-metadata") == 0) { lFlagRegression = true; lToleranceDiffValue = (double) (::atof(av[2])); baselineFilenamesMetaData.reserve(1); testFilenamesMetaData.reserve(1); baselineFilenamesMetaData.push_back(av[3]); testFilenamesMetaData.push_back(av[4]); av += 4; ac -= 4; } else if (strcmp(av[1], "--compare-ogr") == 0) { lFlagRegression = true; lToleranceDiffValue = (double) (::atof(av[2])); baselineFilenamesOgr.reserve(1); testFilenamesOgr.reserve(1); baselineFilenamesOgr.push_back(av[3]); testFilenamesOgr.push_back(av[4]); av += 4; ac -= 4; } testToRun = av[1]; } std::map::iterator j = StringToTestFunctionMap.find(testToRun); // If the test doesn't exists if ( j == StringToTestFunctionMap.end() ) { PrintAvailableTests(); std::cerr << "Failure: " << testToRun << ": no test identified " << testToRun << "\n"; return -1; } else { MainFuncPointer f = j->second; int result; try { // Invoke the test's "main" function. result = (*f)(ac - 1, av + 1); if (result != EXIT_SUCCESS ) { std::cout << "-> Test EXIT FAILURE (" << result << ")." << std::endl; itkGenericExceptionMacro(<< "Function returns EXIT_FAILURE (not from regression, failure inside the test)"); } } catch (itk::ExceptionObject& e) { std::cerr << "otbTestMain '" << testToRun << "': ITK Exception thrown:" << std::endl; std::cerr << e.GetFile() << ":" << e.GetLine() << ":" << std::endl; std::cerr << e.GetDescription() << std::endl; result = EXIT_FAILURE; } catch (std::bad_alloc& err) { std::cerr << "otbTestMain '" << testToRun << "': Exception bad_alloc thrown: " << std::endl; std::cerr << (char*) err.what() << std::endl; result = EXIT_FAILURE; } catch (const std::exception& e) { std::cerr << "otbTestMain '" << testToRun << "': std::exception thrown:" << std::endl; std::cerr << e.what() << std::endl; result = EXIT_FAILURE; } catch (...) { std::cerr << "otbTestMain '" << testToRun << "': Unknown exception thrown !" << std::endl; result = EXIT_FAILURE; } if (result != EXIT_SUCCESS ) { return -1; } result = EXIT_SUCCESS; #ifdef OTB_USE_MPI otb::MPIConfig::Pointer mpiConfig = otb::MPIConfig::Instance(); if (mpiConfig->GetMyRank() == 0) { #endif std::cout << " -> Test EXIT SUCCESS." << std::endl; if (lFlagRegression == false) { std::cout << "------------- No control baseline tests -------------" << std::endl; return result; } try { std::cout << "------------- Start control baseline tests -------------" << std::endl; // Make a list of possible baselines testHelper->SetIgnoreLineOrder(lIgnoreOrder); testHelper->SetToleranceDiffValue(lToleranceDiffValue); // What's the difference testHelper->SetEpsilon(lEpsilon); // maybe we should consolidate... if (epsilonBoundary != 0.0) { testHelper->SetEpsilonBoundaryChecking(epsilonBoundary); } /***********************************************************************************/ // Non regression test for images if ((baselineFilenamesImage.size() > 0) && (testFilenamesImage.size() > 0)) { result += testHelper->RegressionTestAllImages(baselineFilenamesImage, testFilenamesImage); } /***********************************************************************************/ // Non-regression test for metadata. if ((baselineFilenamesMetaData.size() > 0) && (testFilenamesMetaData.size() > 0)) { result += testHelper->RegressionTestAllMetaData(baselineFilenamesMetaData, testFilenamesMetaData); } /***********************************************************************************/ // Non regression test for ascii files if ((baselineFilenamesAscii.size() > 0) && (testFilenamesAscii.size() > 0)) { //result += testHelper->RegressionTestAllAscii(baselineFilenamesAscii, testFilenamesAscii, ignoredLines); result += testHelper->RegressionTestAllDiff(baselineFilenamesAscii, testFilenamesAscii, ignoredLines); } /******************************************************************************/ // Non regression test for binary files if ((baselineFilenamesBinary.size() > 0) && (testFilenamesBinary.size() > 0)) { result += testHelper->RegressionTestAllBinary(baselineFilenamesBinary, testFilenamesBinary); } /******************************************************************************/ // Non regression test for OGR files if ((baselineFilenamesOgr.size() > 0) && (testFilenamesOgr.size() > 0)) { result += testHelper->RegressionTestAllOgr(baselineFilenamesOgr, testFilenamesOgr); } } catch (itk::ExceptionObject& e) { std::cerr << "otbTestMain 'control baseline test': ITK Exception thrown:" << std::endl; std::cerr << e.GetFile() << ":" << e.GetLine() << ":" << std::endl; std::cerr << e.GetDescription() << std::endl; return -1; } catch (std::bad_alloc& err) { std::cerr << "otbTestMain 'control baseline test': Exception bad_alloc thrown: " << std::endl; std::cerr << (char*) err.what() << std::endl; return -1; } catch (const std::exception& e) { std::cerr << "otbTestMain 'control baseline test': std::exception thrown:" << std::endl; std::cerr << e.what() << std::endl; return -1; } catch (...) { std::cerr << "otbTestMain 'control baseline test': Unknown exception thrown !" << std::endl; return -1; } std::cout << "------------- End control baseline tests -------------" << std::endl; #ifdef OTB_USE_MPI } #endif return result; } } #endif OTB-release-5.8/Modules/IO/TestKernel/otb-module.cmake000066400000000000000000000011321301006202600224630ustar00rootroot00000000000000set(DOCUMENTATION "This module is concerned with running the tests and submitting them to the dashboard. For each class, at minimum there is a test which tries to instantiate it and another one which uses the class. The output of each test (image, text file, binary file) is controlled against a baseline to make sure that the result hasn't changed.") otb_module(OTBTestKernel DEPENDS OTBGdalAdapters OTBImageIO OTBITK OTBImageBase OTBCommon OTBGDAL OTBOSSIMAdapters OTBImageManipulation OPTIONAL_DEPENDS OTBMPIConfig DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/TestKernel/src/000077500000000000000000000000001301006202600202045ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/TestKernel/src/CMakeLists.txt000066400000000000000000000007411301006202600227460ustar00rootroot00000000000000add_library(OTBTestKernel otbTestHelper.cxx) target_link_libraries(OTBTestKernel ${OTBGdalAdapters_LIBRARIES} ${OTBImageIO_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBGDAL_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBMPIConfig_LIBRARIES} ) otb_module_target(OTBTestKernel) add_executable(otbTestDriver otbTestDriver.cxx) target_link_libraries(otbTestDriver OTBTestKernel) otb_module_target(otbTestDriver) OTB-release-5.8/Modules/IO/TestKernel/src/otbTestDriver.cxx000066400000000000000000000144361301006202600235400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // define some itksys* things to make ShareForward.h happy #define itksys_SHARED_FORWARD_DIR_BUILD "" #define itksys_SHARED_FORWARD_PATH_BUILD "" #define itksys_SHARED_FORWARD_PATH_INSTALL "" #define itksys_SHARED_FORWARD_EXE_BUILD "" #define itksys_SHARED_FORWARD_EXE_INSTALL "" #include #include #include #include #include "itksys/SystemTools.hxx" #include "itkMacro.h" // include SharedForward to avoid duplicating the code which find the library path variable // name and the path separator #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-function" #include "itksys/SharedForward.h" #pragma GCC diagnostic pop #else #include "itksys/SharedForward.h" #endif #include "itksys/Process.h" // Temporary definition of otbTestMain int otbTestMain(int arc, char * arv[]); /** Display usage */ void usage() { std::cerr << "usage: otbTestDriver [global_options] [non_regression_commands] Execute prg [args]" << std::endl; std::cerr << std::endl; std::cerr << "otbTestDriver alter the environment, run a test program and does regression testing based on capabilities provided by otbTestMain.h" << std::endl; std::cerr << std::endl; std::cerr << "Global options:" << std::endl; std::cerr << " --add-before-libpath PATH" << std::endl; std::cerr << " Add a path to the library path environment. This option take care of" << std::endl; std::cerr << " choosing the right environment variable for your system." << std::endl; std::cerr << " This option can be used several times." << std::endl; std::cerr << std::endl; std::cerr << " --add-before-env NAME VALUE" << std::endl; std::cerr << " Add a VALUE to the variable name in the environment." << std::endl; std::cerr << " This option can be used several times." << std::endl; std::cerr << std::endl; std::cerr << " --help" << std::endl; std::cerr << " Display this message and exit." << std::endl; std::cerr << std::endl; } /** This function parses the command line and process everything * related to the --add-before-libpath, --add-before-env and --help. * Every other args are added to the remainingArgs vector */ int parseCommandLine(int ac, char * av[], std::vector& remainingArgs) { // parse the command line int i = 1; bool skip = false; while (i < ac) { if (!skip && strcmp(av[i], "--add-before-libpath") == 0) { if (i + 1 >= ac) { usage(); return 1; } std::string libpath = KWSYS_SHARED_FORWARD_LDPATH; libpath += "="; libpath += av[i + 1]; char * oldenv = getenv(KWSYS_SHARED_FORWARD_LDPATH); if (oldenv) { libpath += KWSYS_SHARED_FORWARD_PATH_SEP; libpath += oldenv; } itksys::SystemTools::PutEnv(libpath.c_str()); // on some 64 bit systems, LD_LIBRARY_PATH_64 is used before // LD_LIBRARY_PATH if it is set. It can lead the test to load // the system library instead of the expected one, so this // var must also be set if (std::string(KWSYS_SHARED_FORWARD_LDPATH) == "LD_LIBRARY_PATH") { std::string libpath64 = "LD_LIBRARY_PATH_64"; libpath64 += "="; libpath64 += av[i + 1]; char * oldenv2 = getenv("LD_LIBRARY_PATH_64"); if (oldenv2) { libpath64 += KWSYS_SHARED_FORWARD_PATH_SEP; libpath64 += oldenv; } itksys::SystemTools::PutEnv(libpath64.c_str()); } i += 2; } else if (!skip && strcmp(av[i], "--add-before-env") == 0) { if (i + 2 >= ac) { usage(); return 1; } std::string env = av[i + 1]; env += "="; env += av[i + 2]; char * oldenv = getenv(av[i + 1]); if (oldenv) { env += KWSYS_SHARED_FORWARD_PATH_SEP; env += oldenv; } itksys::SystemTools::PutEnv(env.c_str()); i += 3; } else if (!skip && strcmp(av[i], "--help") == 0) { usage(); return 0; } else { remainingArgs.push_back(av[i]); i += 1; } } return 0; } int main(int ac, char* av[]) { // A vector to store remaining args std::vector remainingArgs; // First parse the command line for system wide options int ret = parseCommandLine(ac, av, remainingArgs); // Check for the return code if (ret) { std::cerr << "Error while parsing arguments, exiting ..." << std::endl; return 1; } // Check if there are remaining args if (remainingArgs.empty()) { usage(); return 1; } // a NULL is required at the end of the table char** argv = new char*[remainingArgs.size() + 2]; for (int i = 0; i < static_cast(remainingArgs.size()); ++i) { argv[i + 1] = remainingArgs[i]; } argv[remainingArgs.size() + 1] = ITK_NULLPTR; /** Call to the otbTestMain */ return otbTestMain(static_cast(remainingArgs.size()), argv); } // This is a dummy main to be registered as a test for the otbTestMain int Execute(int argc, char * argv[]) { argc -= 1; argv += 1; // Create the appropriate itk process itksysProcess * process = itksysProcess_New(); itksysProcess_SetCommand(process, argv); itksysProcess_SetPipeShared(process, itksysProcess_Pipe_STDOUT, true); itksysProcess_SetPipeShared(process, itksysProcess_Pipe_STDERR, true); itksysProcess_Execute(process); itksysProcess_WaitForExit(process, ITK_NULLPTR); int retCode = itksysProcess_GetExitValue(process); return retCode; } // Include otbTestMain and switch otbTestMain with main definition in otbTestMain.h #undef otbTestMain #undef main #define main otbTestMain #include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(Execute); } OTB-release-5.8/Modules/IO/TestKernel/src/otbTestHelper.cxx000066400000000000000000002647761301006202600235420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbTestHelper.h" #include "otbMacro.h" #include "otbStringUtils.h" #include #include #include #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #include "ogrsf_frmts.h" #pragma GCC diagnostic pop #else #include "ogrsf_frmts.h" #endif #include "itksys/SystemTools.hxx" #include "itksys/Directory.hxx" #include "itksys/RegularExpression.hxx" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbDifferenceImageFilter.h" #include "otbPrintableImageFilter.h" #include "otbStreamingShrinkImageFilter.h" #include "otbOGRVersionProxy.h" #include "otbConfigure.h" #define ITK_TEST_DIMENSION_MAX 6 // OGR Headers files #include "cpl_conv.h" #include "cpl_string.h" #include "cpl_multiproc.h" #define otbPrintDiff(comment, refStr, testStr) \ std::cout << " ---- '" << comment << "' checking ---------------------------" << std::endl; \ std::cout << " Base << " << refStr << std::endl; \ std::cout << " Test >> " << testStr << std::endl; #define otbCheckStringValue(Comment, RefStr, TestStr, count, report) \ { \ std::string strRefStr(""); if (RefStr != NULL) strRefStr = RefStr; \ std::string strTestStr(""); if (TestStr != NULL) strTestStr = TestStr; \ if (strRefStr != strTestStr) \ { \ count++; \ if (report) \ { \ otbPrintDiff(Comment, strRefStr, strTestStr); \ } \ } \ } #define otbCheckValue(Comment, Ref, Test, count, report) \ { \ if (Ref != Test) \ { \ count++; \ if (report) \ { \ otbPrintDiff(Comment, Ref, Test); \ } \ } \ } namespace otb { int TestHelper::RegressionTestAllImages(const StringList& baselineFilenamesImage, const StringList& testFilenamesImage) { int result = 0; StringListIt itbaselineFilenames = baselineFilenamesImage.begin(); StringListIt itTestFilenames = testFilenamesImage.begin(); int cpt(1); // For each couple of baseline and test file, do the comparison for (; (itbaselineFilenames != baselineFilenamesImage.end()) && (itTestFilenames != testFilenamesImage.end()); ++itbaselineFilenames, ++itTestFilenames) { std::string baselineFilenameImage = (*itbaselineFilenames); std::string testFilenameImage = (*itTestFilenames); std::map baselines = this->RegressionTestBaselines(const_cast(baselineFilenameImage.c_str())); std::map::reverse_iterator baseline = baselines.rbegin(); int multiResult = 1; std::cout << "Number of baseline images: " << baselines.size() << std::endl; while (baseline != baselines.rend() && (multiResult != 0)) { std::cout << "Testing non-regression on image: " << (baseline->first).c_str() << std::endl; this->ReportErrorsOff(); baseline->second = this->RegressionTestImage(cpt, testFilenameImage.c_str(), (baseline->first).c_str(), m_ToleranceDiffValue); multiResult = baseline->second; ++baseline; } if (multiResult != 0) { baseline = baselines.rbegin(); this->ReportErrorsOn(); baseline->second = this->RegressionTestImage(cpt, testFilenameImage.c_str(), (baseline->first).c_str(), m_ToleranceDiffValue); } ++cpt; result += multiResult; } return result; } int TestHelper::RegressionTestAllMetaData(const StringList& baselineFilenamesMetaData, const StringList& testFilenamesMetaData) { int result = 0; // Creates iterators on baseline filenames vector and test filenames vector StringListIt itbaselineFilenames = baselineFilenamesMetaData.begin(); StringListIt itTestFilenames = testFilenamesMetaData.begin(); // For each couple of baseline and test file, do the comparison for (; (itbaselineFilenames != baselineFilenamesMetaData.end()) && (itTestFilenames != testFilenamesMetaData.end()); ++itbaselineFilenames, ++itTestFilenames) { std::string baselineFilenameImage = (*itbaselineFilenames); std::string testFilenameImage = (*itTestFilenames); std::map baselines = this->RegressionTestBaselines(const_cast(baselineFilenameImage.c_str())); std::map::reverse_iterator baseline = baselines.rbegin(); int multiResult = 1; std::cout << "Number of baseline images: " << baselines.size() << std::endl; while (baseline != baselines.rend() && (multiResult != 0)) { std::cout << "Testing non-regression on image: " << (baseline->first).c_str() << std::endl; this->ReportErrorsOff(); baseline->second = this->RegressionTestMetaData(testFilenameImage.c_str(), (baseline->first).c_str(), m_ToleranceDiffValue); multiResult = baseline->second; ++baseline; } if (multiResult != 0) { baseline = baselines.rbegin(); this->ReportErrorsOn(); baseline->second = this->RegressionTestMetaData(testFilenameImage.c_str(), (baseline->first).c_str(), m_ToleranceDiffValue); } result += multiResult; } return result; } int TestHelper::RegressionTestAllAscii(const StringList& baselineFilenamesAscii, const StringList& testFilenamesAscii, const StringList& ignoredLines) { int result = 0; // Creates iterators on baseline filenames vector and test filenames vector StringListIt itbaselineFilenames = baselineFilenamesAscii.begin(); StringListIt itTestFilenames = testFilenamesAscii.begin(); StringListIt itIgnoredLines = ignoredLines.begin(); // Warning message if (ignoredLines.size() > 0) { std::cout << "The lines containing the expressions "; for (; itIgnoredLines != ignoredLines.end(); ++itIgnoredLines) { std::cout << (*itIgnoredLines) << " "; } std::cout << "are not considered" << std::endl; } // For each couple of baseline and test file, do the comparison for (; (itbaselineFilenames != baselineFilenamesAscii.end()) && (itTestFilenames != testFilenamesAscii.end()); ++itbaselineFilenames, ++itTestFilenames) { std::string baselineFilenameAscii = (*itbaselineFilenames); std::string testFilenameAscii = (*itTestFilenames); std::map baselines = this->RegressionTestBaselines(const_cast(baselineFilenameAscii.c_str())); std::map::reverse_iterator baseline = baselines.rbegin(); int multiResult = 1; std::cout << "Number of baseline files: " << baselines.size() << std::endl; while (baseline != baselines.rend() && (multiResult != 0)) { std::cout << "Testing non-regression on file: " << (baseline->first).c_str() << std::endl; this->ReportErrorsOff(); baseline->second = this->RegressionTestAsciiFile(testFilenameAscii.c_str(), (baseline->first).c_str(), m_Epsilon, ignoredLines); multiResult = baseline->second; ++baseline; } if (multiResult != 0) { baseline = baselines.rbegin(); this->ReportErrorsOn(); baseline->second = this->RegressionTestAsciiFile(testFilenameAscii.c_str(), (baseline->first).c_str(), m_Epsilon, ignoredLines); } result += multiResult; } return result; } int TestHelper::RegressionTestAllDiff(const StringList& baselineFilenamesAscii, const StringList& testFilenamesAscii, const StringList& ignoredLines) { int result = 0; // Creates iterators on baseline filenames vector and test filenames vector StringListIt itbaselineFilenames = baselineFilenamesAscii.begin(); StringListIt itTestFilenames = testFilenamesAscii.begin(); StringListIt itIgnoredLines = ignoredLines.begin(); // Warning message if (ignoredLines.size() > 0) { std::cout << "The lines containing the expressions "; for (; itIgnoredLines != ignoredLines.end(); ++itIgnoredLines) { std::cout << (*itIgnoredLines) << " "; } std::cout << "are not considered" << std::endl; } // For each couple of baseline and test file, do the comparison for (; (itbaselineFilenames != baselineFilenamesAscii.end()) && (itTestFilenames != testFilenamesAscii.end()); ++itbaselineFilenames, ++itTestFilenames) { std::string baselineFilenameAscii = (*itbaselineFilenames); std::string testFilenameAscii = (*itTestFilenames); std::map baselines = this->RegressionTestBaselines(const_cast(baselineFilenameAscii.c_str())); std::map::reverse_iterator baseline = baselines.rbegin(); int multiResult = 1; std::cout << "Number of baseline files: " << baselines.size() << std::endl; while (baseline != baselines.rend() && (multiResult != 0)) { std::cout << "Testing non-regression on file: " << (baseline->first).c_str() << std::endl; this->ReportErrorsOff(); baseline->second = this->RegressionTestDiffFile(testFilenameAscii.c_str(), (baseline->first).c_str(), m_Epsilon, ignoredLines); multiResult = baseline->second; ++baseline; } if (multiResult != 0) { baseline = baselines.rbegin(); this->ReportErrorsOn(); baseline->second = this->RegressionTestDiffFile(testFilenameAscii.c_str(), (baseline->first).c_str(), m_Epsilon, ignoredLines); } result += multiResult; } return result; } int TestHelper::RegressionTestAllBinary(const StringList& baselineFilenamesBinary, const StringList& testFilenamesBinary) { int result = 0; // Creates iterators on baseline filenames vector and test filenames vector StringListIt itbaselineFilenames = baselineFilenamesBinary.begin(); StringListIt itTestFilenames = testFilenamesBinary.begin(); // For each couple of baseline and test file, do the comparison for (; (itbaselineFilenames != baselineFilenamesBinary.end()) && (itTestFilenames != testFilenamesBinary.end()); ++itbaselineFilenames, ++itTestFilenames) { std::string baselineFilenameBinary = (*itbaselineFilenames); std::string testFilenameBinary = (*itTestFilenames); std::map baselines = this->RegressionTestBaselines(const_cast(baselineFilenameBinary.c_str())); std::map::reverse_iterator baseline = baselines.rbegin(); int multiResult = 1; std::cout << "Number of baseline files: " << baselines.size() << std::endl; while (baseline != baselines.rend() && (multiResult != 0)) { std::cout << "Testing non-regression on file: " << (baseline->first).c_str() << std::endl; this->ReportErrorsOff(); baseline->second = this->RegressionTestBinaryFile(testFilenameBinary.c_str(), (baseline->first).c_str()); multiResult = baseline->second; ++baseline; } if (multiResult != 0) { baseline = baselines.rbegin(); this->ReportErrorsOn(); baseline->second = this->RegressionTestBinaryFile(testFilenameBinary.c_str(), (baseline->first).c_str()); } result += multiResult; } return result; } int TestHelper::RegressionTestAllOgr(const StringList& baselineFilenamesOgr, const StringList& testFilenamesOgr) { int result = 0; // Creates iterators on baseline filenames vector and test filenames vector StringListIt itbaselineFilenames = baselineFilenamesOgr.begin(); StringListIt itTestFilenames = testFilenamesOgr.begin(); // For each couple of baseline and test file, do the comparison for (; (itbaselineFilenames != baselineFilenamesOgr.end()) && (itTestFilenames != testFilenamesOgr.end()); ++itbaselineFilenames, ++itTestFilenames) { std::string baselineFilenameOgr = (*itbaselineFilenames); std::string testFilenameOgr = (*itTestFilenames); std::map baselines = this->RegressionTestBaselines(const_cast(baselineFilenameOgr.c_str())); std::map::reverse_iterator baseline = baselines.rbegin(); int multiResult = 1; std::cout << "Number of baseline OGR files: " << baselines.size() << std::endl; while (baseline != baselines.rend() && (multiResult != 0)) { std::cout << "Testing non-regression on OGR file: " << (baseline->first).c_str() << std::endl; this->ReportErrorsOff(); baseline->second = this->RegressionTestOgrFile(testFilenameOgr.c_str(), (baseline->first).c_str(), m_ToleranceDiffValue); multiResult = baseline->second; ++baseline; } if (multiResult != 0) { baseline = baselines.rbegin(); this->ReportErrorsOn(); baseline->second = this->RegressionTestOgrFile(testFilenameOgr.c_str(), (baseline->first).c_str(), m_ToleranceDiffValue); } result += multiResult; } return result; } int TestHelper::RegressionTestAsciiFile(const char * testAsciiFileName, const char * baselineAsciiFileName, const double epsilon, std::vector ignoredLines) const { std::ifstream fluxfiletest(testAsciiFileName); std::ifstream fluxfileref(baselineAsciiFileName); std::string diffAsciiFileName(testAsciiFileName); diffAsciiFileName += ".diff.txt"; std::ofstream fluxfilediff; if (m_ReportErrors) { fluxfilediff.open(diffAsciiFileName.c_str()); } std::string strfiletest; std::string strfileref; int nbdiff(0); int numLine(1); if (!fluxfiletest) { itkGenericExceptionMacro(<< "Impossible to open the test ASCII file <" << testAsciiFileName << ">."); } if (!fluxfileref) { itkGenericExceptionMacro(<< "Impossible to open the baseline ASCII file <" << baselineAsciiFileName << ">."); } //fill up a vector of string, in which each element is one line of the file std::vector listLineFileRef; std::vector listLineFileTest; while (std::getline(fluxfileref, strfileref)) { listLineFileRef.push_back(strfileref); } fluxfileref.close(); while (std::getline(fluxfiletest, strfiletest)) { listLineFileTest.push_back(strfiletest); } fluxfiletest.close(); if (m_IgnoreLineOrder) { std::sort(listLineFileRef.begin(), listLineFileRef.end()); std::sort(listLineFileTest.begin(), listLineFileTest.end()); } //These are to save up the differences std::vector listStrDiffLineFileRef; std::vector listStrDiffLineFileTest; std::vector::iterator itRef = listLineFileRef.begin(); std::vector::iterator itTest = listLineFileTest.begin(); // while (std::getline(fluxfileref, strfileref) != 0) while ((itRef != listLineFileRef.end()) && (itTest != listLineFileTest.end())) { strfileref = *itRef; strfiletest = *itTest; //otbMsgDevMacro(<< "Comparing " << strfileref << " -with- " << strfiletest); //Check is the current line should be ignored bool ignoreCurrentLineRef = false; bool ignoreCurrentLineTest = false; if (ignoredLines.size() > 0) { for (std::vector::iterator itIgnoredLines = ignoredLines.begin(); itIgnoredLines != ignoredLines.end(); ++itIgnoredLines) { std::string ignoredLinesAscii = (*itIgnoredLines); std::string::size_type loc = strfileref.find(ignoredLinesAscii); if (loc != std::string::npos) { ignoreCurrentLineRef = true; } loc = strfiletest.find(ignoredLinesAscii); if (loc != std::string::npos) { ignoreCurrentLineTest = true; } } } // Ignore lines with "RTTI" and "Modified Time" inside by default : to avoid multibaseline // between Linux and Win32 plateforms if ((!ignoreCurrentLineRef) && (!ignoreCurrentLineTest)) { if(isToBeIgnoredForAnyComparison(strfileref)) ignoreCurrentLineRef = true; if(isToBeIgnoredForAnyComparison(strfiletest)) ignoreCurrentLineTest = true; } //Compare the lines only if none is supposed to be ignored //Note: the iterator increment will take care of moving only the //ignored one if the order does not matter bool differenceFoundInCurrentLine = false; // if (ignoreCurrentLineRef || ignoreCurrentLineTest) // { // otbMsgDevMacro( << "* ignoring"); // } if ((!ignoreCurrentLineRef) && (!ignoreCurrentLineTest)) { differenceFoundInCurrentLine = CompareLines(strfileref, strfiletest, nbdiff, fluxfilediff, numLine, listStrDiffLineFileRef, listStrDiffLineFileTest, epsilon); // if (!differenceFoundInCurrentLine) // { // otbMsgDevMacro( << "* no difference found"); // } } if (ignoreCurrentLineRef) ++itRef; if (ignoreCurrentLineTest) ++itTest; if (m_IgnoreLineOrder) { if ((!ignoreCurrentLineRef) && (!ignoreCurrentLineTest)) { if (differenceFoundInCurrentLine) { if (*itRef > *itTest) { fluxfilediff << "Additional line in test file: " << " : " << *itTest << std::endl; ++itTest; } else { fluxfilediff << "Additional line in ref file: " << " : " << *itTest << std::endl; ++itRef; } } else { ++itRef; ++itTest; } } } else { if ((!ignoreCurrentLineRef) && (!ignoreCurrentLineTest)) { ++itRef; ++itTest; } } } //Here, the line by line comparison is finished and at least one (ref or test) is at the end //we simply output the content of the other one while (itRef != listLineFileRef.end()) { strfileref = *itRef; std::stringstream buffstreamRef; std::string strRef = ""; buffstreamRef << strfileref; buffstreamRef >> strRef; fluxfilediff << "Additional line in ref file: " << numLine << " : " << strRef << std::endl; nbdiff++; if (m_ReportErrors) { listStrDiffLineFileRef.push_back(strfileref); } ++itRef; } while (itTest != listLineFileTest.end()) { strfiletest = *itTest; std::stringstream buffstreamTest; std::string strTest = ""; buffstreamTest << strfiletest; buffstreamTest >> strTest; fluxfilediff << "Additional line in test file: " << numLine << " : " << strTest << std::endl; nbdiff++; if (m_ReportErrors) { listStrDiffLineFileTest.push_back(strfiletest); } ++itTest; } if (m_ReportErrors) { fluxfilediff.close(); } if (nbdiff != 0 && m_ReportErrors) { std::cout << ""; std::cout << nbdiff; std::cout << "" << std::endl; std::cout << "================================================================" << std::endl; std::cout << "baseline ASCII File : " << baselineAsciiFileName << std::endl; std::cout << "Test ASCII File : " << testAsciiFileName << std::endl; std::cout << "Diff ASCII File : " << diffAsciiFileName << std::endl; std::cout << "Tolerance value : " << epsilon << std::endl; std::cout << "Tolerance max check : " << m_EpsilonBoundaryChecking << std::endl; //FIXME won't be intuitive for the non order case unsigned int numLineDiff = std::min(listStrDiffLineFileRef.size(), listStrDiffLineFileTest.size()); std::cout << "Nb lines different : " << numLineDiff << std::endl; for (unsigned int i = 0; i < numLineDiff; ++i) { std::cout << " -------------------------------" << std::endl; std::cout << " Base << " << listStrDiffLineFileRef[i] << std::endl; std::cout << " Test >> " << listStrDiffLineFileTest[i] << std::endl; } for (unsigned int i = numLineDiff; i < listStrDiffLineFileRef.size(); ++i) { std::cout << " -------------------------------" << std::endl; std::cout << " Base << " << listStrDiffLineFileRef[i] << std::endl; } for (unsigned int i = numLineDiff; i < listStrDiffLineFileTest.size(); ++i) { std::cout << " -------------------------------" << std::endl; std::cout << " Test >> " << listStrDiffLineFileTest[i] << std::endl; } } return (nbdiff != 0) ? 1 : 0; } int TestHelper::RegressionTestDiffFile(const char * testAsciiFileName, const char * baselineAsciiFileName, const double epsilon, StringList ignoredLines) const { typedef std::vector > TokenListType; std::ifstream fluxfiletest(testAsciiFileName); std::ifstream fluxfileref(baselineAsciiFileName); std::string diffAsciiFileName(testAsciiFileName); diffAsciiFileName += ".diff.txt"; std::ofstream fluxfilediff; if (m_ReportErrors) { fluxfilediff.open(diffAsciiFileName.c_str()); } std::string strfiletest; std::string strfileref; int nbdiff(0); if (!fluxfiletest) { itkGenericExceptionMacro(<< "Impossible to open the test ASCII file <" << testAsciiFileName << ">."); } if (!fluxfileref) { itkGenericExceptionMacro(<< "Impossible to open the baseline ASCII file <" << baselineAsciiFileName << ">."); } //fill up a vector of string, in which each element is one line of the file StringList listLineFileRef; StringList listLineFileTest; while (std::getline(fluxfileref, strfileref)) { listLineFileRef.push_back(strfileref); } fluxfileref.close(); while (std::getline(fluxfiletest, strfiletest)) { listLineFileTest.push_back(strfiletest); } fluxfiletest.close(); if (m_IgnoreLineOrder) { std::sort(listLineFileRef.begin(), listLineFileRef.end()); std::sort(listLineFileTest.begin(), listLineFileTest.end()); } //These are to save up the differences StringList listStrDiffLineFile; // filter ignored lines // TODO // filter lines with hexa address (isHexaPointerAddress) // use isToBeIgnoredForAnyComparison() // Iterate over the baseline lines unsigned int posTest = 0; unsigned int posRef = 0; unsigned int curPosTest; TokenListType tokenRef; TokenListType tokenTest; TokenListType tokenTestSelected; std::string separators(" \t,;:=[]{}()<>"); std::string emptyStr(""); unsigned int nbTokenRef = 0; unsigned int nbTokenTest = 0; unsigned int nbTokenTestSelected = 0; bool isFirstMissingRefLine = true; for (posRef=0 ; posRef validTestLines; std::vector skippedTestLines; std::vector differencesPosSelected; for (curPosTest = posTest ; curPosTest < listLineFileTest.size() ; curPosTest++) { // stop searching after 30 lines tested if (curPosTest > posTest + 30) { break; } std::string &curLineTest = listLineFileTest[curPosTest]; if (!IsLineValid(curLineTest,ignoredLines)) { continue; } boost::split(tokenTest, curLineTest, boost::is_any_of(separators)); // remove empty tokens TokenListType::iterator testEndFiltered = std::remove_if(tokenTest.begin(), tokenTest.end(), IsTokenEmpty); tokenTest.resize(testEndFiltered-tokenTest.begin()); nbTokenTest = tokenTest.size(); if (nbTokenTest == 0) { // ignore lines without tokens continue; } //if (curPosTest == posTest) // { // tokenTestSelected = tokenTest; // } // from this point : the test line is considered valid validTestLines.push_back(curPosTest); // get number of equivalent separators and tokens to find the best match int commonTokens = 0; int firstCommonTokens = 0; int firstNumericToken = -1; unsigned int commonSeparators = 0; std::vector differencesPos; for (unsigned int i = 0 ; i < std::min(nbTokenRef,nbTokenTest) ; i++) { //------ comparing previous separator ------ std::string sepRef(""); std::string sepTest(""); unsigned int endSepRef; unsigned int endSepTest; unsigned int startSepRef; unsigned int startSepTest; if (i) { startSepRef = tokenRef[i-1].end() - curLineRef.begin(); startSepTest = tokenTest[i-1].end() - curLineTest.begin(); endSepRef = tokenRef[i].begin() - curLineRef.begin(); endSepTest = tokenTest[i].begin() - curLineTest.begin(); } else { startSepRef = 0; startSepTest = 0; endSepRef = tokenRef[0].begin() - curLineRef.begin(); endSepTest = tokenTest[0].begin() - curLineTest.begin(); } for (unsigned int iRef=startSepRef ; iRef < endSepRef ; iRef++ ) { if (curLineRef[iRef] != ' ' && curLineRef[iRef] != '\t') sepRef += curLineRef[iRef]; } for (unsigned int iTest=startSepTest ; iTest < endSepTest ; iTest++ ) { if (curLineTest[iTest] != ' ' && curLineTest[iTest] != '\t') sepTest += curLineTest[iTest]; } if (sepRef.compare(sepTest) == 0) { commonSeparators++; } else { break; } // ----------- comparing current token -------------------- bool areTokensEquivalent = false; // first : try direct string comparison if (curLineRef.compare( tokenRef[i].begin() - curLineRef.begin(), tokenRef[i].size(), curLineTest, tokenTest[i].begin() - curLineTest.begin(), tokenTest[i].size()) == 0) { areTokensEquivalent = true; } else { // examine other cases : // test if hexadecimal address bool isRefTokenHexa = isHexaPointerAddress( curLineRef, tokenRef[i].begin()-curLineRef.begin(), tokenRef[i].size()); bool isTestTokenHexa = isHexaPointerAddress( curLineTest, tokenTest[i].begin()-curLineTest.begin(), tokenTest[i].size()); if (isRefTokenHexa && isTestTokenHexa) { // these tokens are equivalent (we don't compare pointer address) areTokensEquivalent = true; } else { double vTest=0.; double vRef=0.; double vNorm=0.; // cast ref token bool isRefTokenNum = true; try { vRef = boost::lexical_cast(tokenRef[i]); // record the first numeric token position if (firstNumericToken<0) { firstNumericToken = static_cast(i); } } catch (boost::bad_lexical_cast &) { isRefTokenNum = false; } // cast test token bool isTestTokenNum = true; try { vTest = boost::lexical_cast(tokenTest[i]); } catch (boost::bad_lexical_cast &) { isTestTokenNum = false; } if (isRefTokenNum && isTestTokenNum) { // test difference against epsilon vNorm = (vcl_abs(vRef) + vcl_abs(vTest)) * 0.5; if ((vNorm <= m_EpsilonBoundaryChecking) //make sure that either the test of the ref are non 0 || (vcl_abs(vRef-vTest) <= epsilon * vNorm)) //epsilon as relative error { // these tokens are equivalent areTokensEquivalent = true; } } else { // test for special tokens for (unsigned int j=0 ; j(tokenRef[i]); // record the first numeric token position if (firstNumericToken<0) { firstNumericToken = static_cast(i); } } catch (boost::bad_lexical_cast &) { } } if (commonSeparators < std::min(nbTokenRef,nbTokenTest)) { // All the separators are not equivalent : reject line continue; } if (firstNumericToken > firstCommonTokens) { // if there are non-numeric tokens before a numeric one, all non-numeric // tokens must match (we make sure to compare the same field name) continue; } if (firstCommonTokens > bestCommonTokens) { bestCommonTokens = firstCommonTokens; bestLinePos = curPosTest; tokenTestSelected = tokenTest; nbTokenTestSelected = nbTokenTest; differencesPosSelected = differencesPos; skippedTestLines.clear(); unsigned int k=0; while (validTestLines[k] < curPosTest) { skippedTestLines.push_back(validTestLines[k]); k++; } } // test if lines are identic if (static_cast(firstCommonTokens) == std::max(nbTokenRef,nbTokenTest)) { break; } } // depending on the best number of common tokens ... if (bestCommonTokens <= 0) { // line not found in test if (isFirstMissingRefLine) { listStrDiffLineFile.push_back(" -------------------------------"); isFirstMissingRefLine = false; } listStrDiffLineFile.push_back(std::string(" Base << ")+curLineRef); if (m_ReportErrors) { fluxfilediff << "In baseline l."<> ")+listLineFileTest[skippedTestLines[k]]); if (m_ReportErrors) { fluxfilediff << "In test l."<(std::max(nbTokenRef,nbTokenTestSelected))) { nbdiff++; std::string &lineTestSelected = listLineFileTest[bestLinePos]; // record the diff std::ostringstream ossBase; std::ostringstream ossTest; for (unsigned int k=0 ; k < std::min(nbTokenRef,nbTokenTestSelected) ; k++) { // record the separator unsigned int sizeSepRef; unsigned int startSepRef; if (k) { startSepRef = tokenRef[k-1].end()-curLineRef.begin(); sizeSepRef = tokenRef[k].begin()-tokenRef[k-1].end(); } else { startSepRef = 0; sizeSepRef = tokenRef[0].begin()-curLineRef.begin(); } ossBase << curLineRef.substr(startSepRef, sizeSepRef); for (unsigned int j=0 ; j= nbTokenTestSelected) { ossBase << curLineRef.substr(tokenRef[nbTokenTestSelected-1].end()-curLineRef.begin()); if (nbTokenRef > nbTokenTestSelected) ossTest << "|"; } else if (nbTokenRef < nbTokenTestSelected) { ossBase << "|"; ossTest << lineTestSelected.substr(tokenTestSelected[nbTokenRef-1].end()-lineTestSelected.begin()); } listStrDiffLineFile.push_back(" -------------------------------"); listStrDiffLineFile.push_back(std::string(" Base << ")+ossBase.str()); listStrDiffLineFile.push_back(std::string(" Test >> ")+ossTest.str()); if (m_ReportErrors) { fluxfilediff << "In baseline l."<< posRef+1 <<" : "<< ossBase.str() << std::endl; fluxfilediff << "In test l."<< bestLinePos+1 << " : "<> ")+curLineTest); if (m_ReportErrors) { fluxfilediff << "In test l."<"; std::cout << nbdiff; std::cout << "" << std::endl; std::cout << "================================================================" << std::endl; std::cout << "baseline ASCII File : " << baselineAsciiFileName << std::endl; std::cout << "Test ASCII File : " << testAsciiFileName << std::endl; std::cout << "Diff ASCII File : " << diffAsciiFileName << std::endl; std::cout << "Tolerance value : " << epsilon << std::endl; std::cout << "Tolerance max check : " << m_EpsilonBoundaryChecking << std::endl; std::cout << "Nb lines different : " << nbdiff << std::endl; for (unsigned int i=0 ; i &token) { return token.empty(); } int TestHelper::TokenizeLine(const std::string &line, StringList &tokens) const { std::string::size_type pos; tokens.clear(); std::string::size_type counter = 0; bool isSeparator; bool isToken = false; int curChar; for (pos = 0 ; pos < line.size() ; pos++) { isSeparator = true; curChar = (int)(line[pos]); // test if alphanumeric or '.' or '-' or '^' or '_' or '/' if (isAlphaNum(curChar) || isPoint(curChar) || isMinusSign(curChar) || curChar == 94 || curChar == 95 || curChar == 47) { isSeparator = false; } if (isToken) { // already in a token if (isSeparator) { // end of the token : record it tokens.push_back(line.substr(pos-counter, counter)); isToken = false; counter = 0;tokens.push_back(line.substr(pos-counter, counter)); } else { // still in a token counter++; } } else { // not in a token if (isSeparator) { // do nothing } else { // start of a token isToken = true; counter++; } } } // handle final token if (isToken) { tokens.push_back(line.substr(line.size()-counter, counter)); } return tokens.size(); } bool TestHelper::IsLineValid(const std::string& str, const StringList &ignoredLines) const { bool ret = true; if (isToBeIgnoredForAnyComparison(str)) { ret = false; } else { for (unsigned int i=0 ; i."); } if (!fluxfileref) { itkGenericExceptionMacro(<< "Impossible to open the baseline binary file <" << baselineBinaryFileName << ">."); } while (fluxfiletest.good() && fluxfileref.good()) { if (fluxfiletest.get() != fluxfileref.get()) { nbdiff++; } } fluxfiletest.close(); fluxfileref.close(); if (nbdiff != 0 && m_ReportErrors) { std::cout << ""; std::cout << nbdiff; std::cout << "" << std::endl; } return (nbdiff != 0) ? 1 : 0; } int TestHelper::RegressionTestImage(int cpt, const char *testImageFilename, const char *baselineImageFilename, const double toleranceDiffPixelImage) const { // Use the factory mechanism to read the test and baseline files and convert them to double typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; // Read the baseline file ReaderType::Pointer baselineReader = ReaderType::New(); baselineReader->SetFileName(baselineImageFilename); try { baselineReader->UpdateLargestPossibleRegion(); } catch (itk::ExceptionObject& e) { itkGenericExceptionMacro(<< "Exception detected while reading " << baselineImageFilename << " : " << e.GetDescription()); return 1000; } // Read the file generated by the test ReaderType::Pointer testReader = ReaderType::New(); testReader->SetFileName(testImageFilename); try { testReader->UpdateLargestPossibleRegion(); } catch (itk::ExceptionObject& e) { itkGenericExceptionMacro(<< "Exception detected while reading " << testImageFilename << " : " << e.GetDescription()); return 1000; } // The sizes of the baseline and test image must match ImageType::SizeType baselineSize; baselineSize = baselineReader->GetOutput()->GetLargestPossibleRegion().GetSize(); ImageType::SizeType testSize; testSize = testReader->GetOutput()->GetLargestPossibleRegion().GetSize(); if (baselineSize != testSize) { std::cerr << "The size of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has size " << baselineSize << std::endl; std::cerr << "Test image: " << testImageFilename << " has size " << testSize << std::endl; return 1; } // Now compare the two images typedef otb::DifferenceImageFilter DiffType; DiffType::Pointer diff = DiffType::New(); diff->SetValidInput(baselineReader->GetOutput()); diff->SetTestInput(testReader->GetOutput()); diff->SetDifferenceThreshold(toleranceDiffPixelImage); diff->UpdateLargestPossibleRegion(); ImageType::PixelType status = diff->GetTotalDifference(); unsigned long numberOfPixelsWithDifferences = diff->GetNumberOfPixelsWithDifferences(); //Write only one this message if (m_ReportErrors == 0) { otbGenericMsgDebugMacro(<< "RegressionTestImage DifferenceThreshold: " << toleranceDiffPixelImage); otbGenericMsgDebugMacro(<< "Status diff->GetTotalDifference: " << status << " for " << numberOfPixelsWithDifferences << " pixel(s)."); } // if there are discrepencies, create an diff image if (status.GetSquaredNorm() > 0 && m_ReportErrors) { typedef otb::PrintableImageFilter RescaleType; typedef otb::ImageFileWriter WriterType; RescaleType::Pointer rescale = RescaleType::New(); WriterType::Pointer writer = WriterType::New(); writer->SetInput(rescale->GetOutput()); std::cout << ""; std::cout << status; std::cout << "" << std::endl; std::cout << ""; std::cout << numberOfPixelsWithDifferences; std::cout << "" << std::endl; std::cout << ""; std::cout << toleranceDiffPixelImage; std::cout << "" << std::endl; diff->UpdateOutputInformation(); ImageType::SizeType size = diff->GetOutput()->GetLargestPossibleRegion().GetSize(); if( size[0]*size[1] <= m_MaxArea) { std::ostringstream diffName; diffName << testImageFilename << ".diff.png"; try { rescale->SetInput(diff->GetOutput()); for (unsigned int i = 1; i <= std::min(diff->GetOutput()->GetNumberOfComponentsPerPixel(), 3U); ++i) { rescale->SetChannel(i); } rescale->Update(); } catch (...) { itkGenericExceptionMacro(<< "Error during rescale of " << diffName.str()); } writer->SetFileName(diffName.str().c_str()); try { writer->Update(); } catch (...) { itkGenericExceptionMacro(<< "Error during write of " << diffName.str()); } std::cout << ""; std::cout << diffName.str(); std::cout << "" << std::endl; } else { std::cout << ""; std::cout << "*************************************************************\n"; std::cout << "********** DIFFERENCE IMAGE TOO BIG TO BE SUBMITTED *********\n"; std::cout << "*************************************************************"; std::cout << "" << std::endl; } baselineReader->UpdateOutputInformation(); size = baselineReader->GetOutput()->GetLargestPossibleRegion().GetSize(); if( size[0]*size[1] <= m_MaxArea) { std::ostringstream baseName; baseName << testImageFilename << ".base.png"; try { rescale->SetInput(baselineReader->GetOutput()); rescale->Update(); } catch (...) { itkGenericExceptionMacro(<< "Error during rescale of " << baseName.str()); } try { writer->SetFileName(baseName.str().c_str()); writer->Update(); } catch (...) { itkGenericExceptionMacro(<< "Error during write of " << baseName.str()); } std::cout << ""; std::cout << baseName.str(); std::cout << "" << std::endl; } else { std::cout << ""; std::cout << "*************************************************************\n"; std::cout << "*********** BASELINE IMAGE TOO BIG TO BE SUBMITTED **********\n"; std::cout << "*************************************************************"; std::cout << "" << std::endl; } testReader->UpdateOutputInformation(); size = testReader->GetOutput()->GetLargestPossibleRegion().GetSize(); if( size[0]*size[1] <= m_MaxArea) { std::ostringstream testName; testName << testImageFilename << ".test.png"; try { rescale->SetInput(testReader->GetOutput()); rescale->Update(); } catch (...) { itkGenericExceptionMacro(<< "Error during rescale of " << testName.str()); } try { writer->SetFileName(testName.str().c_str()); writer->Update(); } catch (...) { itkGenericExceptionMacro(<< "Error during write of " << testName.str()); } std::cout << ""; std::cout << testName.str(); std::cout << "" << std::endl; } else { std::cout << ""; std::cout << "*************************************************************\n"; std::cout << "************* TEST IMAGE TOO BIG TO BE SUBMITTED ************\n"; std::cout << "*************************************************************"; std::cout << "" << std::endl; } } return (status.GetSquaredNorm() > 0) ? 1 : 0; } int TestHelper::RegressionTestMetaData(const char *testImageFilename, const char *baselineImageFilename, const double /*toleranceDiffPixelImage*/) const { // Use the factory mechanism to read the test and baseline files and convert them to double typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; // Read the baseline file ReaderType::Pointer baselineReader = ReaderType::New(); baselineReader->SetFileName(baselineImageFilename); try { baselineReader->GenerateOutputInformation(); } catch (itk::ExceptionObject& e) { itkGenericExceptionMacro(<< "Exception detected while reading " << baselineImageFilename << " : " << e.GetDescription()); } // Read the baseline file ReaderType::Pointer testReader = ReaderType::New(); testReader->SetFileName(testImageFilename); try { testReader->GenerateOutputInformation(); } catch (itk::ExceptionObject& e) { itkGenericExceptionMacro(<< "Exception detected while reading " << baselineImageFilename << " : " << e.GetDescription()); } unsigned int errcount = 0; // The sizes of the baseline and test image must match ImageType::SizeType baselineSize; baselineSize = baselineReader->GetOutput()->GetLargestPossibleRegion().GetSize(); ImageType::SizeType testSize; testSize = testReader->GetOutput()->GetLargestPossibleRegion().GetSize(); if (baselineSize != testSize) { std::cerr << "The size of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has size " << baselineSize << std::endl; std::cerr << "Test image: " << testImageFilename << " has size " << testSize << std::endl; errcount++; } ImageType::Pointer blImPtr = baselineReader->GetOutput(); ImageType::Pointer testImPtr = testReader->GetOutput(); // test origin if (blImPtr->GetOrigin() != testImPtr->GetOrigin()) { std::cerr << "The origin of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has origin " << blImPtr->GetOrigin() << std::endl; std::cerr << "Test image: " << testImageFilename << " has origin " << testImPtr->GetOrigin() << std::endl; errcount++; } // test spacing if (blImPtr->GetSpacing() != testImPtr->GetSpacing()) { std::cerr << "The spacing of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has spacing " << blImPtr->GetSpacing() << std::endl; std::cerr << "Test image: " << testImageFilename << " has spacing " << testImPtr->GetSpacing() << std::endl; errcount++; } // test projection reference if (blImPtr->GetProjectionRef().compare(testImPtr->GetProjectionRef()) != 0) { std::cerr << "The projection reference of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has projection reference " << blImPtr->GetProjectionRef() << std::endl; std::cerr << "Test image: " << testImageFilename << " has projection reference " << testImPtr->GetProjectionRef() << std::endl; errcount++; } // test Geographic transform if (blImPtr->GetGeoTransform() != testImPtr->GetGeoTransform()) { std::cerr << "The geographic transform of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has geographic transform " << VectorToString( blImPtr->GetGeoTransform()) << std::endl; std::cerr << "Test image: " << testImageFilename << " has geographic transform " << VectorToString( testImPtr->GetGeoTransform()) << std::endl; errcount++; } // test upper left corner if (blImPtr->GetUpperLeftCorner() != testImPtr->GetUpperLeftCorner()) { std::cerr << "The upper left corner of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has upper left corner " << VectorToString( blImPtr->GetUpperLeftCorner()) << std::endl; std::cerr << "Test image: " << testImageFilename << " has upper left corner " << VectorToString( testImPtr->GetUpperLeftCorner()) << std::endl; errcount++; } // test upper right corner if (blImPtr->GetUpperRightCorner() != testImPtr->GetUpperRightCorner()) { std::cerr << "The upper right corner of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has upper right corner " << VectorToString( blImPtr->GetUpperRightCorner()) << std::endl; std::cerr << "Test image: " << testImageFilename << " has upper right corner " << VectorToString( testImPtr->GetUpperRightCorner()) << std::endl; errcount++; } // test lower left corner if (blImPtr->GetLowerLeftCorner() != testImPtr->GetLowerLeftCorner()) { std::cerr << "The lower left corner of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has lower left corner " << VectorToString( blImPtr->GetLowerLeftCorner()) << std::endl; std::cerr << "Test image: " << testImageFilename << " has lower left corner " << VectorToString( testImPtr->GetLowerLeftCorner()) << std::endl; errcount++; } // test lower right corner if (blImPtr->GetLowerRightCorner() != testImPtr->GetLowerRightCorner()) { std::cerr << "The lower right of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has lower right corner " << VectorToString( blImPtr->GetLowerRightCorner()) << std::endl; std::cerr << "Test image: " << testImageFilename << " has lower right corner " << VectorToString( testImPtr->GetLowerRightCorner()) << std::endl; errcount++; } // test gcp projection if (blImPtr->GetGCPProjection().compare(testImPtr->GetGCPProjection()) != 0) { std::cerr << "The gcp projection of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has gcp projection " << blImPtr->GetGCPProjection() << std::endl; std::cerr << "Test image: " << testImageFilename << " has gcp projection " << testImPtr->GetGCPProjection() << std::endl; errcount++; } // test gcp count if (blImPtr->GetGCPCount() != testImPtr->GetGCPCount()) { std::cerr << "The gcp count of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has gcp count " << blImPtr->GetGCPCount() << std::endl; std::cerr << "Test image: " << testImageFilename << " has gcp count " << testImPtr->GetGCPCount() << std::endl; errcount++; } else { for (unsigned int i = 0; i < blImPtr->GetGCPCount(); ++i) { if ((blImPtr->GetGCPId(i).compare(testImPtr->GetGCPId(i)) != 0) || (blImPtr->GetGCPInfo(i).compare( testImPtr->GetGCPInfo(i)) != 0) || (blImPtr->GetGCPRow(i) != testImPtr->GetGCPRow(i)) || (blImPtr->GetGCPCol( i) != testImPtr->GetGCPCol(i)) || (blImPtr->GetGCPX(i) != testImPtr->GetGCPX(i)) || (blImPtr->GetGCPY(i) != testImPtr ->GetGCPY(i)) || (blImPtr->GetGCPZ(i) != testImPtr->GetGCPZ(i))) { std::cerr << "The GCP number " << i << " of the baseline image and Test image do not match!" << std::endl; std::cerr << "baseline image: " << baselineImageFilename << " has gcp number " << i << " (" << "id: " << blImPtr->GetGCPId(i) << ", " << "info: " << blImPtr->GetGCPInfo(i) << ", " << "row: " << blImPtr->GetGCPRow(i) << ", " << "col: " << blImPtr->GetGCPCol(i) << ", " << "X: " << blImPtr->GetGCPX(i) << ", " << "Y: " << blImPtr->GetGCPY(i) << ", " << "Z: " << blImPtr->GetGCPZ(i) << ")" << std::endl; std::cerr << "Test image: " << testImageFilename << " has gcp number " << i << " (" << "id: " << testImPtr->GetGCPId(i) << ", " << "info: " << testImPtr->GetGCPInfo(i) << ", " << "row: " << testImPtr->GetGCPRow(i) << ", " << "col: " << testImPtr->GetGCPCol(i) << ", " << "X: " << testImPtr->GetGCPX(i) << ", " << "Y: " << testImPtr->GetGCPY(i) << ", " << "Z: " << testImPtr->GetGCPZ(i) << ")" << std::endl; errcount++; } } } if (errcount > 0) { std::cout << ""; std::cout << errcount; std::cout << "" << std::endl; } return errcount; } // // Generate all of the possible baselines // The possible baselines are generated fromn the baselineFilename using the following algorithm: // 1) strip the suffix // 2) append a digit _x // 3) append the original suffix. // It the file exists, increment x and continue // std::map TestHelper::RegressionTestBaselines(char *baselineFilename) const { std::map baselines; baselines[std::string(baselineFilename)] = 0; std::string myPath = itksys::SystemTools::GetFilenamePath(baselineFilename); itksys::Directory myDir; myDir.Load(myPath.c_str()); const unsigned int nbFiles = myDir.GetNumberOfFiles(); const std::string originalBaseline = itksys::SystemTools::GetFilenameWithoutLastExtension(baselineFilename); const unsigned int sizeRef = originalBaseline.size(); const bool HasExtension = (sizeRef != itksys::SystemTools::GetFilenameName(baselineFilename).size()); const std::string blFileExtension = itksys::SystemTools::GetFilenameLastExtension(baselineFilename); myPath.append("/"); itksys::RegularExpression reg; reg.compile("^\\.[0-9]"); for (unsigned int i = 0; i < nbFiles; i++) { std::string curFilename; const std::string curFileExtension = itksys::SystemTools::GetFilenameLastExtension(myDir.GetFile(i)); if (HasExtension) { curFilename = itksys::SystemTools::GetFilenameWithoutLastExtension(myDir.GetFile(i)); } else { curFilename = itksys::SystemTools::GetFilenameName(myDir.GetFile(i)); } if ((curFilename.substr(0, sizeRef) == originalBaseline) && reg.find(curFilename.substr(sizeRef, curFilename.size())) && (curFileExtension.compare(blFileExtension) == 0)) { std::string myFile = myPath; baselines[myFile.append(myDir.GetFile(i))] = 0; } } return baselines; } int TestHelper::RegressionTestOgrFile(const char *testOgrFilename, const char *baselineOgrFilename, const double toleranceDiffValue) const { const char *ref_pszDataSource = baselineOgrFilename; const char *test_pszDataSource = testOgrFilename; //const char *ref_pszWHERE = NULL; //const char *test_pszWHERE = NULL; int bReadOnly = FALSE; int nbdiff(0); /* -------------------------------------------------------------------- */ /* Open data source. */ /* -------------------------------------------------------------------- */ otb::ogr::version_proxy::GDALDatasetType *ref_poDS = ITK_NULLPTR; otb::ogr::version_proxy::GDALDriverType * ref_poDriver = ITK_NULLPTR; //OGRGeometry * ref_poSpatialFilter = NULL; otb::ogr::version_proxy::GDALDatasetType *test_poDS = ITK_NULLPTR; otb::ogr::version_proxy::GDALDriverType * test_poDriver = ITK_NULLPTR; //OGRGeometry * test_poSpatialFilter = NULL; ref_poDS = otb::ogr::version_proxy::Open(ref_pszDataSource, false); if (ref_poDS == ITK_NULLPTR && !bReadOnly) { ref_poDS = otb::ogr::version_proxy::Open(ref_pszDataSource, true); bReadOnly = TRUE; if (ref_poDS != ITK_NULLPTR && m_ReportErrors) { std::cout << "Had to open REF data source read-only."< drivers = ogr::version_proxy::GetAvailableDriversAsStringVector(); for (std::vector::const_iterator it = drivers.begin();it!=drivers.end();++it) { std::cout << " -> " << *it << std::endl; } } return (1); } ref_poDriver = ref_poDS->GetDriver(); CPLAssert(ref_poDriver != NULL); if (test_poDS == ITK_NULLPTR) { if (m_ReportErrors) { std::cout << "FAILURE:\n""Unable to open TEST datasource `" << test_pszDataSource << "' with the following drivers." << std::endl; std::vector drivers = ogr::version_proxy::GetAvailableDriversAsStringVector(); for (std::vector::const_iterator it = drivers.begin();it!=drivers.end();++it) { std::cout << " -> " << *it << std::endl; } } return (1); } test_poDriver = test_poDS->GetDriver(); CPLAssert(test_poDriver != NULL); /* -------------------------------------------------------------------- */ /* Some information messages. */ /* -------------------------------------------------------------------- */ otbCheckStringValue("INFO: using driver", GDALGetDriverShortName(ref_poDriver), GDALGetDriverShortName(test_poDriver), nbdiff, m_ReportErrors); // TODO: Improve this check as it will stop as soon as one of the // list ends (i.e. it does not guarantee that all files are present) std::vector refFileList = otb::ogr::version_proxy::GetFileListAsStringVector(ref_poDS); std::vector testFileList = otb::ogr::version_proxy::GetFileListAsStringVector(test_poDS); unsigned int fileId = 0; while (fileId < refFileList.size() && fileId < testFileList.size()) { std::string strRefName(refFileList[fileId]); std::string strTestName(testFileList[fileId]); if (strRefName != strTestName) { if (!m_ReportErrors) { otbPrintDiff("WARNING: INFO: Internal data source files were different", strRefName, strTestName); } } ++fileId; } /* -------------------------------------------------------------------- */ /* Process each data source layer. */ /* -------------------------------------------------------------------- */ otbCheckValue("GetLayerCount()", ref_poDS->GetLayerCount(), test_poDS->GetLayerCount(), nbdiff, m_ReportErrors); for (int iLayer = 0; iLayer < ref_poDS->GetLayerCount(); ++iLayer) { OGRLayer *ref_poLayer = ref_poDS->GetLayer(iLayer); OGRLayer *test_poLayer = test_poDS->GetLayer(iLayer); if (ref_poLayer == ITK_NULLPTR) { if (m_ReportErrors) std::cout << "FAILURE: Couldn't fetch advertised layer " << iLayer << " for REF data source" << std::endl; return (1); } if (test_poLayer == ITK_NULLPTR) { if (m_ReportErrors) std::cout << "FAILURE: Couldn't fetch advertised layer " << iLayer << " for REF data source" << std::endl; return (1); } //Check Layer inforamtion ogrReportOnLayer(ref_poLayer, ITK_NULLPTR, ITK_NULLPTR, test_poLayer, ITK_NULLPTR, ITK_NULLPTR, nbdiff); //If no difference, check the feature if (nbdiff == 0) { OGRFeature * ref_poFeature = ITK_NULLPTR; OGRFeature * test_poFeature = ITK_NULLPTR; std::string basefilename(test_pszDataSource); int nbFeature(0); std::stringstream oss2; oss2.str(""); oss2 << iLayer; while ((ref_poFeature = ref_poLayer->GetNextFeature()) != ITK_NULLPTR) { test_poFeature = test_poLayer->GetNextFeature(); std::stringstream oss; oss.str(""); oss << nbFeature; std::string ref_filename = basefilename + "_temporary_layer_" + oss2.str() + "_feature_" + oss.str() + "_ref.txt"; std::string test_filename = basefilename + "_temporary_layer_" + oss2.str() + "_feature_" + oss.str() + "_test.txt"; FILE *ref_f(ITK_NULLPTR); ref_f = fopen(ref_filename.c_str(), "w"); if (ref_f == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Impossible to create ASCII file <" << ref_filename << ">."); } DumpOGRFeature(ref_f, ref_poFeature); OGRFeature::DestroyFeature( ref_poFeature ); fclose(ref_f); FILE *test_f(ITK_NULLPTR); test_f = fopen(test_filename.c_str(), "w"); if (test_f == ITK_NULLPTR) { itkGenericExceptionMacro(<< "Impossible to create ASCII file <" << test_filename << ">."); } DumpOGRFeature(test_f, test_poFeature); OGRFeature::DestroyFeature( test_poFeature ); fclose(test_f); //Check ASCII comparison std::vector ignoredLines; ignoredLines.clear(); nbdiff = RegressionTestAsciiFile(test_filename.c_str(), ref_filename.c_str(), toleranceDiffValue, ignoredLines); nbFeature++; } // If no verbose and an diff was found, exit checking. The full checking will be executed in verbose mode if ((!m_ReportErrors) && (nbdiff != 0)) return (1); } //if(nbdiff == 0) } /* -------------------------------------------------------------------- */ /* Close down. */ /* -------------------------------------------------------------------- */ GDALClose( ref_poDS ); GDALClose( test_poDS ); return (nbdiff != 0) ? 1 : 0; } void TestHelper::DumpOGRFeature(FILE* fpOut, OGRFeature* feature, char** papszOptions) { if (fpOut == ITK_NULLPTR) fpOut = stdout; if(!feature) { fprintf(fpOut, "NULL feature encountered\n"); return; } fprintf(fpOut, "OGRFeature:%lld\n", (GIntBig) feature->GetFID()); const char* pszDisplayFields = CSLFetchNameValue(papszOptions, "DISPLAY_FIELDS"); if (pszDisplayFields == ITK_NULLPTR || CSLTestBoolean(pszDisplayFields)) { for (int iField = 0; iField < feature->GetFieldCount(); iField++) { OGRFieldDefn *poFDefn = feature->GetDefnRef()->GetFieldDefn(iField); fprintf(fpOut, " %s (%s) = ", poFDefn->GetNameRef(), OGRFieldDefn::GetFieldTypeName(poFDefn->GetType())); if (feature->IsFieldSet(iField)) fprintf(fpOut, "%s\n", feature->GetFieldAsString(iField)); else fprintf(fpOut, "(null)\n"); } } if (feature->GetStyleString() != ITK_NULLPTR) { const char* pszDisplayStyle = CSLFetchNameValue(papszOptions, "DISPLAY_STYLE"); if (pszDisplayStyle == ITK_NULLPTR || CSLTestBoolean(pszDisplayStyle)) { fprintf(fpOut, " Style = %s\n", feature->GetStyleString()); } } if (feature->GetGeometryRef() != ITK_NULLPTR) { const char* pszDisplayGeometry = CSLFetchNameValue(papszOptions, "DISPLAY_GEOMETRY"); if (!(pszDisplayGeometry != ITK_NULLPTR && EQUAL(pszDisplayGeometry, "NO"))) { DumpOGRGeometry(fpOut, feature->GetGeometryRef(), " ", papszOptions); } } fprintf(fpOut, "\n"); } void TestHelper::DumpOGRGeometry(FILE* fp, OGRGeometry* geometry, const char * pszPrefix, char** papszOptions) { char *pszWkt = ITK_NULLPTR; if (pszPrefix == ITK_NULLPTR) pszPrefix = ""; if (fp == ITK_NULLPTR) fp = stdout; const char* pszDisplayGeometry = CSLFetchNameValue(papszOptions, "DISPLAY_GEOMETRY"); if (pszDisplayGeometry != ITK_NULLPTR && EQUAL(pszDisplayGeometry, "SUMMARY")) { OGRLineString * poLine; OGRPolygon * poPoly; OGRLinearRing * poRing; OGRGeometryCollection *poColl; fprintf(fp, "%s%s : ", pszPrefix, geometry->getGeometryName()); switch (geometry->getGeometryType()) { case wkbUnknown: case wkbNone: break; case wkbPoint: case wkbPoint25D: break; case wkbLineString: case wkbLineString25D: poLine = (OGRLineString*) geometry; fprintf(fp, "%d points\n", poLine->getNumPoints()); break; case wkbPolygon: case wkbPolygon25D: { int ir; int nRings; poPoly = (OGRPolygon*) geometry; poRing = poPoly->getExteriorRing(); nRings = poPoly->getNumInteriorRings(); fprintf(fp, "%d points", poRing->getNumPoints()); if (nRings) { fprintf(fp, ", %d inner rings (", nRings); for (ir = 0; ir < nRings; ir++) { if (ir) fprintf(fp, ", "); fprintf(fp, "%d points", poPoly->getInteriorRing(ir)->getNumPoints()); } fprintf(fp, ")"); } fprintf(fp, "\n"); break; } case wkbMultiPoint: case wkbMultiPoint25D: case wkbMultiLineString: case wkbMultiLineString25D: case wkbMultiPolygon: case wkbMultiPolygon25D: case wkbGeometryCollection: case wkbGeometryCollection25D: { int ig; poColl = (OGRGeometryCollection*) geometry; fprintf(fp, "%d geometries:\n", poColl->getNumGeometries()); for (ig = 0; ig < poColl->getNumGeometries(); ig++) { OGRGeometry * poChild = (OGRGeometry*) poColl->getGeometryRef(ig); fprintf(fp, "%s", pszPrefix); DumpOGRGeometry(fp, poChild, pszPrefix, papszOptions); } break; } case wkbLinearRing: break; default: break; } } else if (pszDisplayGeometry == ITK_NULLPTR || CSLTestBoolean(pszDisplayGeometry) || EQUAL(pszDisplayGeometry, "WKT")) { if (geometry->exportToWkt(&pszWkt) == OGRERR_NONE) { fprintf(fp, "%s%s\n", pszPrefix, pszWkt); CPLFree(pszWkt); } } } // Regression Testing Code bool TestHelper::isNumber(int i) const { return ((i > 47) && (i < 58)); } bool TestHelper::isHexaNumber(int i) const { return (((i > 47) && (i < 58)) || ((i > 96) && (i < 103)) || ((i > 64) && (i < 71))); } bool TestHelper::isPoint(int i) const { return (i == 46); } bool TestHelper::isMinusSign(int i) const { return (i == 45); } bool TestHelper::isAlphaNum(int i) const { return isNumber(i) || ((i > 64) && (i < 91)) || ((i > 96) && (i < 123)); } bool TestHelper::isNumeric(const std::string& str) const { int nbOfPoints = 0; int nbOfNumbers = 0; int number; unsigned int i = 0; bool result = true; while ((i < str.size()) && (result == true)) { number = str[i]; if (isPoint(number)) ++nbOfPoints; if (isNumber(number)) ++nbOfNumbers; if ((!isNumber(number) && !isPoint(number) && !isMinusSign(number)) || (isMinusSign(number) && (i != 0))) result = false; ++i; } if ((str.size() == 0) || (nbOfPoints > 1) /*||(nbOfNumbers==0)*/) result = false; return result; } bool TestHelper::isScientificNumeric(const std::string& str) const { if(str.size() == 0) { return false; } int number(0); number = str[0]; bool pointDetected(false); bool eDetected(false); bool signDetected(false); // Analyse first character (+, -, 0...9) unsigned int cpt(0); if ((str[0] != '+') && (str[0] != '-') && (!isNumber(number))) return false; if ((str[0] == '+') || (str[0] == '-')) { ++cpt; signDetected = true; } while (cpt < str.size()) { if (str[cpt] == '.') { // Exit false if two points or if e already detected if ((pointDetected == true) || (eDetected == true)) return false; pointDetected = true; } else if ((str[cpt] == 'e') || (str[cpt] == 'E')) { // Exit false if two e if (eDetected == true) return false; eDetected = true; } else if ((str[cpt] == '-') || (str[cpt] == '+')) { // Exit false if already sign with no E detected if ((signDetected == true) && (eDetected == false)) return false; signDetected = true; } else { number = str[cpt]; if (!isNumber(number)) return false; } ++cpt; } return true; } bool TestHelper::isToBeIgnoredForAnyComparison(const std::string& str) const { if (str.find("RTTI") != std::string::npos) return true; if (str.find("Modified Time") != std::string::npos) return true; if (str.find("PipelineMTime:") != std::string::npos) return true; return false; } bool TestHelper::isHexaPointerAddress(const std::string& str) const { unsigned int size(0); bool result(false); unsigned int start(0); if( str.size() < 2 ) { return false; } //If (0xadresss) if ((str[0] == 40) && (str[str.size() - 1] == 41) && (str[1] == 48) && (str[2] == 120)) { result = true; start = 3; size = str.size() - 1; } //If 0xadresss else if ((str[0] == 48) && (str[1] == 120)) { result = true; start = 2; size = str.size(); } // if 01adress else if ((str[0] == 48) && (str[1] == 49)) { result = true; start = 2; size = str.size(); } unsigned int i(start); while (result && (i < size)) { result = result && isHexaNumber(str[i]); ++i; } return result; } bool TestHelper::isHexaPointerAddress(const std::string& str, size_t pos, size_t size) const { if (size < 3) { return false; } // pointer address has to begin with '0x' // it may also start with '00' with a size of 16 (64bit address) // or start with '0' with a size of 8 (32bit address) // Note: the last pattern seems a bit weak but cases like '00B5FA18' or // '01C46D80' both are valid hexadecimal addresses on windows if (str[pos] != 48) { return false; } if (!(str[pos+1] == 120 || (str[pos+1] == 48 && size == 16) || (size == 8))) { return false; } // check all other characters are in [A-Fa-f0-9] for (unsigned int i=2 ; i keys; keys.push_back("["); keys.push_back("]"); keys.push_back("("); keys.push_back(")"); keys.push_back(","); keys.push_back("="); keys.push_back(":"); keys.push_back(";"); keys.push_back(""); std::vector keysOut; keysOut.push_back("[ "); keysOut.push_back(" ]"); keysOut.push_back("( "); keysOut.push_back(" )"); keysOut.push_back(" , "); keysOut.push_back(" = "); keysOut.push_back(" : "); keysOut.push_back(" , "); keysOut.push_back(" "); for (unsigned int it = 0; it < keys.size(); ++it) { size_t found; found=strLine.find(keys[it]); while (found!=std::string::npos) { strLine.replace(found, 1, keysOut[it]); found=strLine.find(keys[it], found + keysOut[it].size()); } } strOut = strLine; } bool TestHelper::CompareLines(const std::string& strfileref, const std::string& strfiletest, int& nbdiff, std::ofstream& fluxfilediff, int& numLine, std::vector& listStrDiffLineFileRef, std::vector& listStrDiffLineFileTest, double epsilon) const { // add white spaces std::string strLineRef; std::string strLineTest; AddWhiteSpace(strfileref, strLineRef); AddWhiteSpace(strfiletest, strLineTest); //otbMsgDevMacro(<<"Comparing (after replace) : " << strLineRef << " vs " << strLineTest); std::stringstream buffstreamRef, buffstreamTest; buffstreamRef << strLineRef; buffstreamTest << strLineTest; //Number of differences in the current line bool differenceFoundInCurrentLine = false; enum TypeEtat { ETAT_NUM, ETAT_CHAR }; TypeEtat etatPrec(ETAT_NUM), etatCour(ETAT_NUM); while (buffstreamRef.peek() != EOF) { std::string strRef = ""; std::string strTest = ""; std::string strNumRef = ""; std::string strCharRef = ""; std::string strNumTest = ""; std::string strCharTest = ""; buffstreamRef >> strRef; buffstreamTest >> strTest; //otbMsgDevMacro(<< "sub comparison of the line, strRef: " << strRef << " || strTest: " << strTest); std::string charTmpRef = ""; std::string charTmpTest = ""; if (!isHexaPointerAddress(strRef)) { //Analyse if strRef contains scientific value (ex: "-142.124e-012") if (isScientificNumeric(strRef)) { if (!isScientificNumeric(strTest)) { if (m_ReportErrors) { fluxfilediff << "Diff at line " << numLine << " : compare numeric value with no numeric value (" << strRef << strRef << " != " << strTest << ")" << std::endl; differenceFoundInCurrentLine = true; } nbdiff++; } else { float vRef = atof(strRef.c_str()); float vTest = atof(strTest.c_str()); float vNorm = (vcl_abs(vRef) + vcl_abs(vTest))/2; //otbMsgDevMacro(<< "numerical comparison: " < " // << "vNorm= " << vNorm << ", " << vcl_abs(vRef-vTest) << " > "<< epsilon * vNorm // << "? -> " << (vcl_abs(vRef-vTest) > epsilon * vNorm )); if ((vNorm > m_EpsilonBoundaryChecking) //make sure that either the test of the ref are non 0 && (vcl_abs(vRef-vTest) > epsilon * vNorm)) //epsilon as relative error { if (m_ReportErrors) { fluxfilediff << "Diff at line " << numLine << " : vcl_abs ( (" << strRef << ") - (" << strTest << ") ) > " << epsilon << std::endl; differenceFoundInCurrentLine = true; } nbdiff++; } } } else { unsigned int i = 0; while (i < strRef.size()) { charTmpRef = strRef[i]; if (i < strTest.size()) { charTmpTest = strTest[i]; } //otbMsgDevMacro(<< "characterRef: " << charTmpRef << " || characterTest: " << charTmpTest ); if (isNumeric(charTmpRef)) etatCour = ETAT_NUM; else etatCour = ETAT_CHAR; // "reference" state initialization. if (i == 0) etatPrec = etatCour; // Case where there's a number after characteres. if ((etatCour == ETAT_NUM) && (etatPrec == ETAT_CHAR)) { if (strCharRef != strCharTest) { if (m_ReportErrors) { fluxfilediff << "Diff at line " << numLine << " : " << strCharRef << " != " << strCharTest << std::endl; differenceFoundInCurrentLine = true; } nbdiff++; } strCharRef = ""; strCharTest = ""; strNumRef = charTmpRef; strNumTest = charTmpTest; } // Case where there's a character after numbers. else if ((etatCour == ETAT_CHAR) && (etatPrec == ETAT_NUM)) { if ((strNumRef != strNumTest) && (vcl_abs(atof(strNumRef.c_str())) > m_EpsilonBoundaryChecking) && (vcl_abs(atof(strNumRef.c_str()) - atof(strNumTest.c_str())) > epsilon * vcl_abs(atof(strNumRef.c_str())))) //epsilon as relative error { if (m_ReportErrors) { fluxfilediff << "Diff at line " << numLine << " : vcl_abs ( (" << strNumRef << ") - (" << strNumTest << ") ) > " << epsilon << std::endl; differenceFoundInCurrentLine = true; } nbdiff++; } strNumRef = ""; strNumTest = ""; strCharRef = charTmpRef; strCharTest = charTmpTest; } else if (etatCour == etatPrec) { if (etatCour == ETAT_CHAR) { strCharRef += charTmpRef; strCharTest += charTmpTest; } else { strNumRef += charTmpRef; strNumTest += charTmpTest; } } etatPrec = etatCour; ++i; } // test last part if (etatCour == ETAT_CHAR) { if (strCharRef != strCharTest) { if (m_ReportErrors) { fluxfilediff << "Diff at line " << numLine << " : " << strCharRef << " != " << strCharTest << std::endl; differenceFoundInCurrentLine = true; } nbdiff++; } } else { if ((strNumRef != strNumTest) && (vcl_abs(atof(strNumRef.c_str())) > m_EpsilonBoundaryChecking) && (vcl_abs(atof(strNumRef.c_str()) - atof(strNumTest.c_str())) > epsilon * vcl_abs(atof(strNumRef.c_str())))) //epsilon as relative error { if (m_ReportErrors) { fluxfilediff << "Diff at line " << numLine << " : vcl_abs( (" << strNumRef << ") - (" << strNumTest << ") ) > " << epsilon << std::endl; differenceFoundInCurrentLine = true; } nbdiff++; } } } // else } // if(!isHexaPointerAddress(strRef)) else { if (m_ReportErrors) { fluxfilediff << "Pointer address found at line " << numLine << " : " << strRef << " -> comparison skipped." << std::endl; } } } numLine++; //Store alls differences lines if (differenceFoundInCurrentLine && m_ReportErrors) { listStrDiffLineFileRef.push_back(strfileref); listStrDiffLineFileTest.push_back(strfiletest); } return differenceFoundInCurrentLine; } std::string TestHelper::VectorToString(const otb::MetaDataKey::VectorType& vector) const { std::stringstream oss; oss.str(""); otb::MetaDataKey::VectorType::const_iterator it = vector.begin(); oss << "["; while (it != vector.end()) { oss << (*it); ++it; if (it == vector.end()) { oss << "]"; break; } else { oss << ", "; } } return oss.str(); } /************************************************************************/ /* ReportOnLayer() */ /************************************************************************/ void TestHelper::ogrReportOnLayer(OGRLayer * ref_poLayer, const char *ref_pszWHERE, OGRGeometry *ref_poSpatialFilter, OGRLayer * test_poLayer, const char *test_pszWHERE, OGRGeometry *test_poSpatialFilter, int& nbdiff) const { OGRFeatureDefn *ref_poDefn = ref_poLayer->GetLayerDefn(); OGRFeatureDefn *test_poDefn = test_poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Set filters if provided. */ /* -------------------------------------------------------------------- */ otbCheckStringValue("pszWHERE", ref_pszWHERE, test_pszWHERE, nbdiff, m_ReportErrors); if (ref_pszWHERE != ITK_NULLPTR) ref_poLayer->SetAttributeFilter(ref_pszWHERE); if (ref_poSpatialFilter != ITK_NULLPTR) ref_poLayer->SetSpatialFilter(ref_poSpatialFilter); if (test_pszWHERE != ITK_NULLPTR) test_poLayer->SetAttributeFilter(test_pszWHERE); if (test_poSpatialFilter != ITK_NULLPTR) test_poLayer->SetSpatialFilter(test_poSpatialFilter); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf("\n"); otbCheckStringValue("Geometry", OGRGeometryTypeToName(ref_poDefn->GetGeomType()), OGRGeometryTypeToName(test_poDefn->GetGeomType()), nbdiff, m_ReportErrors); otbCheckValue("Feature Count", ref_poLayer->GetFeatureCount(), test_poLayer->GetFeatureCount(), nbdiff, m_ReportErrors); OGREnvelope ref_oExt; OGREnvelope test_oExt; otbCheckValue("GetExtent", ref_poLayer->GetExtent(&ref_oExt, TRUE), test_poLayer->GetExtent(&test_oExt, TRUE), nbdiff, m_ReportErrors); if (ref_poLayer->GetExtent(&ref_oExt, TRUE) == OGRERR_NONE) { otbCheckValue("Extent: MinX", ref_oExt.MinX, test_oExt.MinX, nbdiff, m_ReportErrors); otbCheckValue("Extent: MinY", ref_oExt.MinY, test_oExt.MinY, nbdiff, m_ReportErrors); otbCheckValue("Extent: MaxX", ref_oExt.MaxX, test_oExt.MaxX, nbdiff, m_ReportErrors); otbCheckValue("Extent: MaxY", ref_oExt.MaxY, test_oExt.MaxY, nbdiff, m_ReportErrors); } char *ref_pszWKT; char *test_pszWKT; if (ref_poLayer->GetSpatialRef() == ITK_NULLPTR) ref_pszWKT = CPLStrdup("(unknown)"); else { ref_poLayer->GetSpatialRef()->exportToPrettyWkt(&ref_pszWKT); } if (test_poLayer->GetSpatialRef() == ITK_NULLPTR) test_pszWKT = CPLStrdup("(unknown)"); else { test_poLayer->GetSpatialRef()->exportToPrettyWkt(&test_pszWKT); } otbCheckStringValue("Layer SRS WKT", ref_pszWKT, test_pszWKT, nbdiff, m_ReportErrors); CPLFree(ref_pszWKT); CPLFree(test_pszWKT); otbCheckStringValue("FID Column", ref_poLayer->GetFIDColumn(), test_poLayer->GetFIDColumn(), nbdiff, m_ReportErrors); otbCheckStringValue("Geometry Column", ref_poLayer->GetGeometryColumn(), test_poLayer->GetGeometryColumn(), nbdiff, m_ReportErrors); otbCheckValue("GetFieldCount", ref_poDefn->GetFieldCount(), test_poDefn->GetFieldCount(), nbdiff, m_ReportErrors); if (ref_poDefn->GetFieldCount() == test_poDefn->GetFieldCount()) { for (int iAttr = 0; iAttr < ref_poDefn->GetFieldCount(); ++iAttr) { OGRFieldDefn *ref_poField = ref_poDefn->GetFieldDefn(iAttr); OGRFieldDefn *test_poField = test_poDefn->GetFieldDefn(iAttr); otbCheckStringValue("Field GetName", ref_poField->GetNameRef(), test_poField->GetNameRef(), nbdiff, m_ReportErrors); otbCheckStringValue("Field GetFieldTypeName", ref_poField->GetFieldTypeName( ref_poField->GetType()), test_poField->GetFieldTypeName( test_poField->GetType()), nbdiff, m_ReportErrors); otbCheckValue("Field GetWidth", ref_poField->GetWidth(), test_poField->GetWidth(), nbdiff, m_ReportErrors); otbCheckValue("Field GetPrecision", ref_poField->GetPrecision(), test_poField->GetPrecision(), nbdiff, m_ReportErrors); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ //Check the feature contains only if no differences found } } OTB-release-5.8/Modules/IO/TestKernel/test/000077500000000000000000000000001301006202600203745ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/TestKernel/test/CMakeLists.txt000066400000000000000000000113451301006202600231400ustar00rootroot00000000000000otb_module_test() set(OTBTestKernelTests otbCompareAsciiTests2.cxx otbCompareAsciiTests3.cxx otbCompareAsciiTests4.cxx otbCompareAsciiTests5.cxx otbCompareAsciiTests6.cxx otbCompareAsciiTestScientificNotation.cxx otbCompareAsciiTests.cxx otbCompareAsciiTestsEpsilon3_WhiteSpace.cxx otbTestKernelTestDriver.cxx ) add_executable(otbTestKernelTestDriver ${OTBTestKernelTests}) target_link_libraries(otbTestKernelTestDriver ${OTBTestKernel-Test_LIBRARIES}) otb_module_target_label(otbTestKernelTestDriver) otb_add_test(NAME tsTvCompareAscii2 COMMAND otbTestKernelTestDriver --compare-ascii ${NOTOL} ${TEMP}/tsTvCompareAsciiRef2.txt ${TEMP}/tsTvCompareAsciiTest2.txt otbCompareAsciiTests2 ${TEMP}/tsTvCompareAsciiRef2.txt ${TEMP}/tsTvCompareAsciiTest2.txt ) set_property(TEST tsTvCompareAscii2 PROPERTY WILL_FAIL true) otb_add_test(NAME tsTvCompareAscii2reverse COMMAND otbTestKernelTestDriver --compare-ascii ${NOTOL} ${TEMP}/tsTvCompareAsciiRef2reverse.txt ${TEMP}/tsTvCompareAsciiTest2reverse.txt otbCompareAsciiTests2 ${TEMP}/tsTvCompareAsciiTest2reverse.txt ${TEMP}/tsTvCompareAsciiRef2reverse.txt ) set_property(TEST tsTvCompareAscii2reverse PROPERTY WILL_FAIL true) otb_add_test(NAME tsTvCompareAscii3order COMMAND otbTestKernelTestDriver --compare-ascii ${NOTOL} ${TEMP}/tsTvCompareAsciiRef3order.txt ${TEMP}/tsTvCompareAsciiTest3order.txt otbCompareAsciiTests3 ${TEMP}/tsTvCompareAsciiRef3order.txt ${TEMP}/tsTvCompareAsciiTest3order.txt ) set_property(TEST tsTvCompareAscii3order PROPERTY WILL_FAIL true) otb_add_test(NAME tsTvCompareAscii3 COMMAND otbTestKernelTestDriver --ignore-order --compare-ascii ${NOTOL} ${TEMP}/tsTvCompareAsciiRef3.txt ${TEMP}/tsTvCompareAsciiTest3.txt otbCompareAsciiTests3 ${TEMP}/tsTvCompareAsciiRef3.txt ${TEMP}/tsTvCompareAsciiTest3.txt ) otb_add_test(NAME tsTvCompareAscii4 COMMAND otbTestKernelTestDriver --compare-ascii ${NOTOL} ${TEMP}/tsTvCompareAsciiRef4.txt ${TEMP}/tsTvCompareAsciiTest4.txt otbCompareAsciiTests4 ${TEMP}/tsTvCompareAsciiRef4.txt ${TEMP}/tsTvCompareAsciiTest4.txt ) set_property(TEST tsTvCompareAscii4 PROPERTY WILL_FAIL true) otb_add_test(NAME tsTvCompareAscii4epsilon2 COMMAND otbTestKernelTestDriver --compare-ascii ${EPSILON_2} ${TEMP}/tsTvCompareAsciiRef4epsilon2.txt ${TEMP}/tsTvCompareAsciiTest4epsilon2.txt otbCompareAsciiTests4 ${TEMP}/tsTvCompareAsciiRef4epsilon2.txt ${TEMP}/tsTvCompareAsciiTest4epsilon2.txt ) otb_add_test(NAME tsTvCompareAscii4epsilon3 COMMAND otbTestKernelTestDriver --compare-ascii ${EPSILON_3} ${TEMP}/tsTvCompareAsciiRef4epsilon3.txt ${TEMP}/tsTvCompareAsciiTest4epsilon3.txt otbCompareAsciiTests4 ${TEMP}/tsTvCompareAsciiRef4epsilon3.txt ${TEMP}/tsTvCompareAsciiTest4epsilon3.txt ) set_property(TEST tsTvCompareAscii4epsilon3 PROPERTY WILL_FAIL true) otb_add_test(NAME tsTvCompareAscii5epsilon2 COMMAND otbTestKernelTestDriver --ignore-order --compare-ascii ${EPSILON_2} ${TEMP}/tsTvCompareAsciiRef5epsilon2.txt ${TEMP}/tsTvCompareAsciiTest5epsilon2.txt otbCompareAsciiTests5 ${TEMP}/tsTvCompareAsciiRef5epsilon2.txt ${TEMP}/tsTvCompareAsciiTest5epsilon2.txt ) otb_add_test(NAME tsTvCompareAsciiScientificNotation COMMAND otbTestKernelTestDriver --compare-ascii ${EPSILON_2} ${TEMP}/tsTvCompareAsciiRef_SN.txt ${TEMP}/tsTvCompareAsciiTest_SN.txt otbCompareAsciiTestScientificNotation ${TEMP}/tsTvCompareAsciiRef_SN.txt ${TEMP}/tsTvCompareAsciiTest_SN.txt ) otb_add_test(NAME tsTvCompareAscii COMMAND otbTestKernelTestDriver --compare-ascii ${NOTOL} ${TEMP}/tsTvCompareAsciiRef.txt ${TEMP}/tsTvCompareAsciiTest.txt otbCompareAsciiTests ${TEMP}/tsTvCompareAsciiRef.txt ${TEMP}/tsTvCompareAsciiTest.txt ) otb_add_test(NAME tsTvCompareAsciiepsilon3_WhiteSpaceOK COMMAND otbTestKernelTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/tsTvCompareAsciiEpsilon3_Base.txt ${TEMP}/tsTvCompareAsciiEpsilon3_TestOK.txt otbCompareAsciiTestsEpsilon3_WhiteSpace ${INPUTDATA}/tsTvCompareAsciiEpsilon3_TestOK.txt ${TEMP}/tsTvCompareAsciiEpsilon3_TestOK.txt ) otb_add_test(NAME tsTvCompareAsciiepsilon3_WhiteSpaceKO COMMAND otbTestKernelTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/tsTvCompareAsciiEpsilon3_Base.txt ${TEMP}/tsTvCompareAsciiEpsilon3_TestKO.txt otbCompareAsciiTestsEpsilon3_WhiteSpace ${INPUTDATA}/tsTvCompareAsciiEpsilon3_TestKO.txt ${TEMP}/tsTvCompareAsciiEpsilon3_TestKO.txt ) set_property(TEST tsTvCompareAsciiepsilon3_WhiteSpaceKO PROPERTY WILL_FAIL true) otb_add_test(NAME tsTvCompareAscii6 COMMAND otbTestKernelTestDriver --compare-ascii ${EPSILON_3} ${TEMP}/tsTvCompareAscii6_ref.txt ${TEMP}/tsTvCompareAscii6_test.txt otbCompareAsciiTests6 ${TEMP}/tsTvCompareAscii6_ref.txt ${TEMP}/tsTvCompareAscii6_test.txt ) OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTestScientificNotation.cxx000066400000000000000000000034611301006202600305450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" int otbCompareAsciiTestScientificNotation(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " referenceFile testFile" << std::endl; return EXIT_FAILURE; } std::ofstream fileRef; fileRef.open(argv[1]); fileRef << "1e15\n"; fileRef << "2e15\n"; fileRef << "3e15\n"; fileRef << "4e15\n"; fileRef << "5e-3\n"; fileRef << "6e-3\n"; fileRef << "7e-3\n"; fileRef << "8e-3\n"; fileRef << "A = 1e15\n"; fileRef << "A = 2e15\n"; fileRef << "A = 3e15\n"; fileRef << "A = 4e15\n"; fileRef << "A = 5e-3\n"; fileRef << "A = 6e-3\n"; fileRef << "A = 7e-3\n"; fileRef << "A = 8e-3\n"; fileRef.close(); std::ofstream fileTest; fileTest.open(argv[2]); fileTest << "1e15\n"; fileTest << "2E15\n"; fileTest << "3e015\n"; fileTest << "4E015\n"; fileTest << "5e-3\n"; fileTest << "6E-3\n"; fileTest << "7e-03\n"; fileTest << "8E-03\n"; fileTest << "A = 1e15\n"; fileTest << "A = 2E15\n"; fileTest << "A = 3e015\n"; fileTest << "A = 4E015\n"; fileTest << "A = 5e-3\n"; fileTest << "A = 6E-3\n"; fileTest << "A = 7e-03\n"; fileTest << "A = 8E-03\n"; fileTest.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTests.cxx000066400000000000000000000021441301006202600252100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" int otbCompareAsciiTests(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " referenceFile testFile" << std::endl; return EXIT_FAILURE; } std::ofstream fileRef; fileRef.open(argv[1]); fileRef << "1\n"; fileRef << "2\n"; fileRef << "3\n"; fileRef.close(); std::ofstream fileTest; fileTest.open(argv[2]); fileTest << "1\n"; fileTest << "2\n"; fileTest << "3\n"; fileTest.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTests2.cxx000066400000000000000000000021211301006202600252650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" int otbCompareAsciiTests2(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " referenceFile testFile" << std::endl; return EXIT_FAILURE; } std::ofstream fileRef; fileRef.open(argv[1]); fileRef << "1\n"; fileRef << "2\n"; fileRef.close(); std::ofstream fileTest; fileTest.open(argv[2]); fileTest << "1\n"; fileTest << "2\n"; fileTest << "3\n"; fileTest.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTests3.cxx000066400000000000000000000022161301006202600252730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" int otbCompareAsciiTests3(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " referenceFile testFile" << std::endl; return EXIT_FAILURE; } std::ofstream fileRef; fileRef.open(argv[1]); fileRef << "1\n"; fileRef << "2\n"; fileRef << "3\n"; fileRef << "2\n"; fileRef.close(); std::ofstream fileTest; fileTest.open(argv[2]); fileTest << "2\n"; fileTest << "2\n"; fileTest << "3\n"; fileTest << "1\n"; fileTest.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTests4.cxx000066400000000000000000000021611301006202600252730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" int otbCompareAsciiTests4(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " referenceFile testFile" << std::endl; return EXIT_FAILURE; } std::ofstream fileRef; fileRef.open(argv[1]); fileRef << "1\n"; fileRef << "2\n"; fileRef << "3\n"; fileRef.close(); std::ofstream fileTest; fileTest.open(argv[2]); fileTest << "1.001\n"; fileTest << "1.999\n"; fileTest << "3.010\n"; fileTest.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTests5.cxx000066400000000000000000000022721301006202600252770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" int otbCompareAsciiTests5(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " referenceFile testFile" << std::endl; return EXIT_FAILURE; } std::ofstream fileRef; fileRef.open(argv[1]); fileRef << "[ 1 1 1 ]\n"; fileRef << "[ 2 2 2 ]\n"; fileRef << "[ 3 3 3 ]\n"; fileRef.close(); std::ofstream fileTest; fileTest.open(argv[2]); fileTest << "[ 3.010 2.999 3.000 ]\n"; fileTest << "[ 1.999 2.000 2.001 ]\n"; fileTest << "[ 1.001 0.999 1.0005 ]\n"; fileTest.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTests6.cxx000066400000000000000000000023131301006202600252740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbMacro.h" int otbCompareAsciiTests6(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " referenceFile testFile" << std::endl; return EXIT_FAILURE; } std::ofstream fileRef; fileRef.open(argv[1]); fileRef << "ImageRegion (0x7fff1639a860)\n"; fileRef << "0x7fff1639a860\n"; fileRef << "0.142355\t:230\n"; fileRef.close(); std::ofstream fileTest; fileTest.open(argv[2]); fileTest << "ImageRegion (00C3F798)\n"; fileTest << "000000001AF56D20\n"; fileTest << "0.142356\t:230\n"; fileTest.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbCompareAsciiTestsEpsilon3_WhiteSpace.cxx000066400000000000000000000027231301006202600307440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "otbMacro.h" int otbCompareAsciiTestsEpsilon3_WhiteSpace(int itkNotUsed(argc), char * argv[]) { std::cout << "ASCII COMPARISON TEST: it will use directly the baseline and input files in OTB-Data " "to avoid problem with otb-bot." << std::endl; // Open input file std::ifstream fileTestInput; fileTestInput.open(argv[1]); // Transfer to temporary object std::string strFileTest; std::vector listLineFileTest; while (std::getline(fileTestInput, strFileTest)) { listLineFileTest.push_back(strFileTest); } fileTestInput.close(); // Write temporary object without modification std::ofstream fileTestOutput; fileTestOutput.open(argv[2]); for (unsigned int i=0; i < listLineFileTest.size(); ++i) { fileTestOutput << listLineFileTest[i]; } fileTestOutput.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/TestKernel/test/otbTestKernelTestDriver.cxx000066400000000000000000000006231301006202600257220ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbCompareAsciiTests2); REGISTER_TEST(otbCompareAsciiTests3); REGISTER_TEST(otbCompareAsciiTests4); REGISTER_TEST(otbCompareAsciiTests5); REGISTER_TEST(otbCompareAsciiTests6); REGISTER_TEST(otbCompareAsciiTestScientificNotation); REGISTER_TEST(otbCompareAsciiTests); REGISTER_TEST(otbCompareAsciiTestsEpsilon3_WhiteSpace); } OTB-release-5.8/Modules/IO/VectorDataIO/000077500000000000000000000000001301006202600176215ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/VectorDataIO/CMakeLists.txt000066400000000000000000000001331301006202600223560ustar00rootroot00000000000000project(OTBVectorDataIO) set(OTBVectorDataIO_LIBRARIES OTBVectorDataIO) otb_module_impl() OTB-release-5.8/Modules/IO/VectorDataIO/include/000077500000000000000000000000001301006202600212445ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/VectorDataIO/include/otbVectorDataFileReader.h000066400000000000000000000126441301006202600261100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataFileReader_h #define otbVectorDataFileReader_h #include "otbVectorDataSource.h" #include "otbVectorDataIOBase.h" namespace otb { /** \class VectorDataFileReaderException * * \brief Base exception class for IO conflicts. * * \ingroup OTBVectorDataIO */ class VectorDataFileReaderException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(VectorDataFileReaderException, itk::ExceptionObject); /** Constructor. */ VectorDataFileReaderException(const char *file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : itk::ExceptionObject(file, line, message, loc) { } /** Constructor. */ VectorDataFileReaderException(const std::string& file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : itk::ExceptionObject(file, line, message, loc) { } }; /** \brief Data source that reads vector data from a single file. * * This source object is a general filter to read data from * a variety of vector data file formats. It works with a VectorDataIOBase subclass * to actually do the reading of the data. Object factory machinery * can be used to automatically create the VectorDataIOBase, or the * VectorDataIOBase can be manually created and set. Note that this * class reads data from a single file. * * TOutputVectorData is the type expected by the external users of the * filter. If data stored in the file is stored in a different format * then specified by TOutputVectorData, than this filter converts data * between the file type and the external expected type. * * A Pluggable factory pattern is used this allows different kinds of readers * to be registered (even at run time) without having to modify the * code in this class. Normally just setting the FileName with the * appropriate suffix is enough to get the reader to instantiate the * correct VectorDataIO and read the file properly. However, some files (like * raw binary format) have no accepted suffix, so you will have to * manually create the VectorDataIO instance of the write type. * * \sa VectorDataIOBase * */ template class ITK_EXPORT VectorDataFileReader : public VectorDataSource { public: /** Standard class typedefs. */ typedef VectorDataFileReader Self; typedef VectorDataSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataFileReader, VectorDataSource); typedef TOutputVectorData OutputVectorType; typedef VectorDataIOBase VectorDataIOBaseType; itkStaticConstMacro(VDimension, unsigned int, OutputVectorType::DataNodeType::Dimension); typedef itk::Vector SpacingType; typedef itk::Point PointType; /** Specify the file to read */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); /** Set/Get the VectorDataIO helper class. Often this is created via the object * factory mechanism that determines whether a particular VectorDataIO can * read a certain file. This method provides a way to get the VectorDataIO * instance that is created. Or you can directly specify the VectorDataIO * to use to read a particular file in case the factory mechanism will * not work properly (e.g., unknown or unusual extension). */ void SetVectorDataIO(VectorDataIOBaseType * vectorDataIO); itkGetObjectMacro(VectorDataIO, VectorDataIOBaseType); /** Prepare the allocation of the output vector data during the first back * propagation of the pipeline. */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Does the real work. */ void GenerateData() ITK_OVERRIDE; protected: VectorDataFileReader(); ~VectorDataFileReader() ITK_OVERRIDE; std::string m_ExceptionMessage; typename VectorDataIOBaseType::Pointer m_VectorDataIO; bool m_UserSpecifiedVectorDataIO; // keep track whether the void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; std::string m_FileName; // The file to be read private: VectorDataFileReader(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Test whether the given filename exist and it is readable. If the file doesn't exist or it is not readable, and exception with an appropriate message will be thrown. */ void TestFileExistenceAndReadability(); }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataFileReader.txx" #endif #endif // otbVectorDataFileReader_h OTB-release-5.8/Modules/IO/VectorDataIO/include/otbVectorDataFileReader.txx000066400000000000000000000155621301006202600265060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataFileReader_txx #define otbVectorDataFileReader_txx #include #include "otbMacro.h" #include "otbSystem.h" #include "otbVectorDataIOFactory.h" #include "otbVectorDataFileReader.h" #include "itksys/SystemTools.hxx" #include "otbVectorDataAdapter.h" #include "otbVectorData.h" namespace otb { /** * Constructor */ template VectorDataFileReader ::VectorDataFileReader() : m_VectorDataIO(ITK_NULLPTR), m_UserSpecifiedVectorDataIO(false), m_FileName("") { } /** * Destructor */ template VectorDataFileReader ::~VectorDataFileReader() { } /** Test whether the given filename exist and it is readable, this is intended to be called before attempting to use VectorDataIO classes for actually reading the file. If the file doesn't exist or it is not readable, and exception with an appropriate message will be thrown. */ template void VectorDataFileReader ::TestFileExistenceAndReadability() { // Test if the file exists. if (!itksys::SystemTools::FileExists(this->m_FileName.c_str())) { VectorDataFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << "The file doesn't exist. " << std::endl << "Filename = " << this->m_FileName << std::endl; e.SetDescription(msg.str().c_str()); throw e; return; } // Test if the file can be open for reading access. //Only if m_FileName speciy a filename (not a dirname) // FIXME shapefile should be able to open a directory and load the // individual shapefiles as layers if (itksys::SystemTools::FileExists(this->m_FileName.c_str(), true) == true) { std::ifstream readTester; readTester.open(this->m_FileName.c_str()); if (readTester.fail()) { readTester.close(); std::ostringstream msg; msg << "The file couldn't be opened for reading. " << std::endl << "Filename: " << this->m_FileName << std::endl; VectorDataFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } readTester.close(); } } template void VectorDataFileReader ::SetVectorDataIO(VectorDataIOBaseType * vectorDataIO) { itkDebugMacro("setting VectorDataIO to " << vectorDataIO); if (this->m_VectorDataIO != vectorDataIO) { this->m_VectorDataIO = vectorDataIO; this->Modified(); } m_UserSpecifiedVectorDataIO = true; } template void VectorDataFileReader ::GenerateOutputInformation(void) { typename TOutputVectorData::Pointer output = this->GetOutput(); itkDebugMacro(<< "Reading file for GenerateOutputInformation()" << m_FileName); // Check to see if we can read the file given the name or prefix // if (m_FileName == "") { throw VectorDataFileReaderException(__FILE__, __LINE__, "FileName must be specified", ITK_LOCATION); } // Test if the file exist and if it can be open. // and exception will be thrown otherwise. // try { m_ExceptionMessage = ""; this->TestFileExistenceAndReadability(); } catch (itk::ExceptionObject & err) { m_ExceptionMessage = err.GetDescription(); } if (m_UserSpecifiedVectorDataIO == false) //try creating via factory { m_VectorDataIO = VectorDataIOFactory::CreateVectorDataIO( m_FileName.c_str(), VectorDataIOFactory::ReadMode); } if (m_VectorDataIO.IsNull()) { std::ostringstream msg; msg << " Could not create IO object for file " << m_FileName.c_str() << std::endl; if (m_ExceptionMessage.size()) { msg << m_ExceptionMessage; } else { msg << " Tried to create one of the following:" << std::endl; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("otbVectorDataIOBase"); for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { VectorDataIOBase* io = dynamic_cast(i->GetPointer()); msg << " " << io->GetNameOfClass() << std::endl; } msg << " You probably failed to set a file suffix, or" << std::endl; msg << " set the suffix to an unsupported type." << std::endl; } VectorDataFileReaderException e(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); throw e; return; } m_VectorDataIO->SetFileName(m_FileName.c_str()); //Copy MetaDataDictionary from instantiated reader to output VectorData. output->SetMetaDataDictionary(m_VectorDataIO->GetMetaDataDictionary()); this->SetMetaDataDictionary(m_VectorDataIO->GetMetaDataDictionary()); } template void VectorDataFileReader ::GenerateData() { typename TOutputVectorData::Pointer output = this->GetOutput(); itkDebugMacro (<< "VectorDataFileReader::GenerateData() \n"); // Test if the file exist and if it can be open. // and exception will be thrown otherwise. try { m_ExceptionMessage = ""; this->TestFileExistenceAndReadability(); } catch (itk::ExceptionObject & err) { m_ExceptionMessage = err.GetDescription(); } m_VectorDataIO->SetFileName(m_FileName.c_str()); // Tell the VectorDataIO to read the file // typedef VectorDataAdapter, TOutputVectorData> AdapterType; typename AdapterType::InputVectorDataType::Pointer input = AdapterType::InputVectorDataType::New(); m_VectorDataIO->Read(input); typename AdapterType::Pointer adapter = AdapterType::New(); adapter->SetInput(input); adapter->GraftOutput(output); adapter->Update(); this->GraftOutput(adapter->GetOutput()); return; } template void VectorDataFileReader ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); if (m_VectorDataIO) { os << indent << "VectorDataIO: \n"; m_VectorDataIO->Print(os, indent.GetNextIndent()); } else { os << indent << "m_VectorDataIO: (null)" << "\n"; } os << indent << "UserSpecifiedVectorDataIO flag: " << m_UserSpecifiedVectorDataIO << "\n"; os << indent << "m_FileName: " << m_FileName << "\n"; } } //namespace otb #endif OTB-release-5.8/Modules/IO/VectorDataIO/include/otbVectorDataFileWriter.h000066400000000000000000000067631301006202600261670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataFileWriter_h #define otbVectorDataFileWriter_h #include "itkProcessObject.h" #include "itkMacro.h" #include "otbVectorDataIOBase.h" namespace otb { /** \brief Base exception class for IO problems during writing. * * \class ImageFileWriterException * * \ingroup OTBVectorDataIO */ class VectorDataFileWriterException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(VectorDataFileWriterException, ExceptionObject); /** Constructor. */ VectorDataFileWriterException(const char *file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) { } /** Constructor. */ VectorDataFileWriterException(const std::string& file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) { } }; /** \class VectorDataFileWriter * \brief This class writes vector data file format (shapefile and KML) * * \ingroup IO * * \ingroup OTBVectorDataIO */ template class ITK_EXPORT VectorDataFileWriter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef VectorDataFileWriter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataFileWriter, itk::ProcessObject); typedef TInputVectorData InputVectorDataType; typedef VectorDataIOBase VectorDataIOBaseType; /** Set/Get the image input of this writer. */ using Superclass::SetInput; void SetInput(const InputVectorDataType *input); const InputVectorDataType * GetInput(void); const InputVectorDataType * GetInput(unsigned int idx); /** Does the real work. */ virtual void Write(); void GenerateData() ITK_OVERRIDE; void Update() ITK_OVERRIDE { this->Write(); } /** Specify the name of the output shapefile to write. */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); protected: VectorDataFileWriter(); ~VectorDataFileWriter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; std::string m_FileName; // The file to be read typename VectorDataIOBaseType::Pointer m_VectorDataIO; bool m_UserSpecifiedVectorDataIO; // track whether the VectorDataIO bool m_FactorySpecifiedVectorDataIO; private: VectorDataFileWriter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataFileWriter.txx" #endif #endif // otbVectorDataFileWriter_h OTB-release-5.8/Modules/IO/VectorDataIO/include/otbVectorDataFileWriter.txx000066400000000000000000000140261301006202600265520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataFileWriter_txx #define otbVectorDataFileWriter_txx #include "otbMacro.h" #include "otbVectorDataFileWriter.h" #include "otbVectorDataIOFactory.h" #include "otbVectorDataAdapter.h" #include "otbVectorData.h" namespace otb { /** * Constructor */ template VectorDataFileWriter ::VectorDataFileWriter() : m_FileName(""), m_VectorDataIO(ITK_NULLPTR), m_UserSpecifiedVectorDataIO(false), m_FactorySpecifiedVectorDataIO(false) { } /** * Destructor */ template VectorDataFileWriter ::~VectorDataFileWriter() { } //--------------------------------------------------------- template void VectorDataFileWriter ::SetInput(const InputVectorDataType *input) { // ProcessObject is not const_correct so this cast is required here. this->ProcessObject::SetNthInput(0, const_cast(input)); } //--------------------------------------------------------- template const typename VectorDataFileWriter::InputVectorDataType * VectorDataFileWriter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetInput(0)); } //--------------------------------------------------------- template const typename VectorDataFileWriter::InputVectorDataType * VectorDataFileWriter ::GetInput(unsigned int idx) { return static_cast (this->ProcessObject::GetInput(idx)); } //--------------------------------------------------------- template void VectorDataFileWriter ::Write() { const InputVectorDataType * input = this->GetInput(); itkDebugMacro(<< "Writing a vector data file"); // Make sure input is available if (input == ITK_NULLPTR) { itkExceptionMacro(<< "No input to writer!"); } // Make sure that we can write the file given the name // if (m_FileName == "") { itkExceptionMacro(<< "No filename was specified"); } if (m_VectorDataIO.IsNull()) //try creating via factory { itkDebugMacro(<< "Attempting factory creation of VectorDataIO for file: " << m_FileName); m_VectorDataIO = VectorDataIOFactory::CreateVectorDataIO( m_FileName.c_str(), VectorDataIOFactory::WriteMode); m_FactorySpecifiedVectorDataIO = true; } else { if (m_FactorySpecifiedVectorDataIO && !m_VectorDataIO->CanWriteFile(m_FileName.c_str())) { itkDebugMacro(<< "VectorDataIO exists but doesn't know how to write file:" << m_FileName); itkDebugMacro(<< "Attempting creation of VectorDataIO with a factory for file:" << m_FileName); m_VectorDataIO = VectorDataIOFactory::CreateVectorDataIO( m_FileName.c_str(), VectorDataIOFactory::WriteMode); m_FactorySpecifiedVectorDataIO = true; } } if (m_VectorDataIO.IsNull()) { VectorDataFileWriterException e(__FILE__, __LINE__); std::ostringstream msg; msg << " Could not create IO object for file " << m_FileName.c_str() << std::endl; msg << " Tried to create one of the following:" << std::endl; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("otbVectorDataIOBase"); for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { VectorDataIOBase* io = dynamic_cast(i->GetPointer()); if(io) msg << " " << io->GetNameOfClass() << std::endl; } msg << " You probably failed to set a file suffix, or" << std::endl; msg << " set the suffix to an unsupported type." << std::endl; e.SetDescription(msg.str().c_str()); e.SetLocation(ITK_LOCATION); throw e; } // NOTE: this const_cast<> is due to the lack of const-correctness // of the ProcessObject. InputVectorDataType * nonConstVectorData = const_cast(input); // Make sure the data is up-to-date. if (nonConstVectorData->GetSource()) { nonConstVectorData->GetSource()->Update(); } // Notify start event observers this->InvokeEvent(itk::StartEvent()); // Actually do something this->GenerateData(); // Notify end event observers this->InvokeEvent(itk::EndEvent()); // Release upstream data if requested if (input->ShouldIReleaseData()) { nonConstVectorData->ReleaseData(); } } //--------------------------------------------------------- template void VectorDataFileWriter ::GenerateData(void) { const InputVectorDataType * input = this->GetInput(); itkDebugMacro(<< "Writing file: " << m_FileName); // Setup the vector data IO for writing. // m_VectorDataIO->SetFileName(m_FileName.c_str()); typedef VectorDataAdapter > AdapterType; typename AdapterType::Pointer adapter = AdapterType::New(); adapter->SetInput(input); adapter->Update(); m_VectorDataIO->Write(adapter->GetOutput()); } template void VectorDataFileWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "VectorDataFileWriter" << std::endl; } } //namespace otb #endif OTB-release-5.8/Modules/IO/VectorDataIO/include/otbVectorDataIOFactory.h000066400000000000000000000041721301006202600257420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataIOFactory_h #define otbVectorDataIOFactory_h #include "itkObject.h" #include "otbVectorDataIOBase.h" namespace otb { /** \class VectorDataIOFactory * \brief Create instances of VectorDataIO objects using an object factory. * * \ingroup OTBVectorDataIO */ class ITK_EXPORT VectorDataIOFactory : public itk::Object { public: /** Standard class typedefs. */ typedef VectorDataIOFactory Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef VectorDataIOBase VectorDataIOBaseType; typedef VectorDataIOBaseType::Pointer VectorDataIOBasePointerType; /** Class Methods used to interface with the registered factories */ /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataIOFactory, Object); /** Convenient typedefs. */ typedef VectorDataIOBase::Pointer VectorDataIOBasePointer; /** Mode in which the files is intended to be used */ typedef enum { ReadMode, WriteMode } FileModeType; /** Create the appropriate VectorDataIO depending on the particulars of the file. */ static VectorDataIOBasePointerType CreateVectorDataIO(const char* path, FileModeType mode); /** Register Built-in factories */ static void RegisterBuiltInFactories(); protected: VectorDataIOFactory(); ~VectorDataIOFactory() ITK_OVERRIDE; private: VectorDataIOFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/IO/VectorDataIO/otb-module.cmake000066400000000000000000000006471301006202600227010ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes related to the reading and the writing of vector data (see also VectorDataBase and VectorDataManipulation modules).") otb_module(OTBVectorDataIO DEPENDS OTBVectorDataBase OTBIOGDAL OTBITK OTBVectorDataManipulation OTBCommon OPTIONAL_DEPENDS OTBIOKML TEST_DEPENDS OTBTestKernel OTBOSSIMAdapters DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/IO/VectorDataIO/src/000077500000000000000000000000001301006202600204105ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/VectorDataIO/src/CMakeLists.txt000066400000000000000000000004511301006202600231500ustar00rootroot00000000000000set(OTBVectorDataIO_SRC otbVectorDataIOFactory.cxx ) add_library(OTBVectorDataIO ${OTBVectorDataIO_SRC}) target_link_libraries(OTBVectorDataIO ${OTBVectorDataBase_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBIOGDAL_LIBRARIES} ${OTBIOKML_LIBRARIES} ) otb_module_target(OTBVectorDataIO) OTB-release-5.8/Modules/IO/VectorDataIO/src/otbVectorDataIOFactory.cxx000066400000000000000000000052141301006202600254570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataIOFactory.h" #include "otbOGRVectorDataIOFactory.h" #ifdef OTB_USE_LIBKML #include "otbKMLVectorDataIOFactory.h" #endif #include "itkObjectFactoryBase.h" #include "itkMutexLock.h" #include "itkMutexLockHolder.h" namespace otb { VectorDataIOFactory ::VectorDataIOBasePointerType VectorDataIOFactory ::CreateVectorDataIO(const char* path, FileModeType mode) { RegisterBuiltInFactories(); std::string baseclassID = std::string("otbVectorDataIOBase"); std::list possibleVectorDataIO; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance(baseclassID.c_str()); for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { VectorDataIOBaseType * io = dynamic_cast(i->GetPointer()); if (io) { possibleVectorDataIO.push_back(io); } else { itkGenericExceptionMacro(<< "Error VectorDataIO factory did not return an VectorDataIOBase: " << (*i)->GetNameOfClass()); } } for (std::list::iterator k = possibleVectorDataIO.begin(); k != possibleVectorDataIO.end(); ++k) { if (mode == ReadMode) { if ((*k)->CanReadFile(path)) { return *k; } } else if (mode == WriteMode) { if ((*k)->CanWriteFile(path)) { return *k; } } } return ITK_NULLPTR; } void VectorDataIOFactory ::RegisterBuiltInFactories() { static bool firstTime = true; static itk::SimpleMutexLock mutex; { // This helper class makes sure the Mutex is unlocked // in the event an exception is thrown. itk::MutexLockHolder mutexHolder(mutex); if (firstTime) { itk::ObjectFactoryBase::RegisterFactory(OGRVectorDataIOFactory::New()); #ifdef OTB_USE_LIBKML itk::ObjectFactoryBase::RegisterFactory(KMLVectorDataIOFactory::New()); #endif firstTime = false; } } } } // end namespace otb OTB-release-5.8/Modules/IO/VectorDataIO/test/000077500000000000000000000000001301006202600206005ustar00rootroot00000000000000OTB-release-5.8/Modules/IO/VectorDataIO/test/CMakeLists.txt000066400000000000000000000130221301006202600233360ustar00rootroot00000000000000otb_module_test() set(OTBVectorDataIOTests otbVectorDataIOTestDriver.cxx otbVectorDataFileReaderWriter.cxx otbVectorDataFileWriterPolygons.cxx otbVectorDataFileReaderNew.cxx otbVectorDataIOFactory.cxx otbVectorDataFileWriterMultiPolygons.cxx otbVectorDataFileReader.cxx otbVectorDataFileGeoReaderWriter.cxx otbVectorDataFileWriterNew.cxx otbVectorDataFileWriter.cxx ) add_executable(otbVectorDataIOTestDriver ${OTBVectorDataIOTests}) target_link_libraries(otbVectorDataIOTestDriver ${OTBVectorDataIO-Test_LIBRARIES}) otb_module_target_label(otbVectorDataIOTestDriver) # Tests Declaration otb_add_test(NAME ioTvVectorDataFileReaderWriter COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvVectorDataFileReaderWriterOutput.shp ${TEMP}/ioTvVectorDataFileReaderWriterOutput.shp otbVectorDataFileReaderWriter LARGEINPUT{QUICKBIRD/TOULOUSE/GIS_FILES/000000128955_01_ORDER_SHAPE.shp} ${TEMP}/ioTvVectorDataFileReaderWriterOutput.shp ) otb_add_test(NAME ioTvVectorDataFileWriterPolygons COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvVectorDataFileWriterPolygonsOutput.shp ${TEMP}/ioTvVectorDataFileWriterPolygonsOutput.shp otbVectorDataFileWriterPolygons ${TEMP}/ioTvVectorDataFileWriterPolygonsOutput.shp ) otb_add_test(NAME ioTuVectorDataFileReaderNew COMMAND otbVectorDataIOTestDriver otbVectorDataFileReaderNew ) otb_add_test(NAME ioTuVectorDataIOFactory COMMAND otbVectorDataIOTestDriver otbVectorDataIOFactory ${INPUTDATA}/ToulouseRoad-examples.shp ) otb_add_test(NAME ioTvVectorDataFileWriterMultiPolygons COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvVectorDataFileWriterMultiPolygonsOutput.shp ${TEMP}/ioTvVectorDataFileWriterMultiPolygonsOutput.shp otbVectorDataFileWriterMultiPolygons ${TEMP}/ioTvVectorDataFileWriterMultiPolygonsOutput.shp ) otb_add_test(NAME ioTvSHPVectorDataFileReader COMMAND otbVectorDataIOTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioSHPVectorDataFileReader.txt ${TEMP}/ioSHPVectorDataFileReader.txt otbVectorDataFileReader LARGEINPUT{QUICKBIRD/TOULOUSE/GIS_FILES/000000128955_01_ORDER_SHAPE.shp} ${TEMP}/ioSHPVectorDataFileReader.txt ) otb_add_test(NAME ioTvKMLVectorDataFileReader COMMAND otbVectorDataIOTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvKMLVectorDataFileReader.txt ${TEMP}/ioTvKMLVectorDataFileReader.txt otbVectorDataFileReader ${INPUTDATA}/lines.kml ${TEMP}/ioTvKMLVectorDataFileReader.txt ) otb_add_test(NAME ioTvKMLVectorDataFileReader2 COMMAND otbVectorDataIOTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioTvKMLVectorDataFileReader2.txt ${TEMP}/ioTvKMLVectorDataFileReader2.txt otbVectorDataFileReader ${INPUTDATA}/multigeometry.kml ${TEMP}/ioTvKMLVectorDataFileReader2.txt ) otb_add_test(NAME ioTvSHPVectorDataFileReader3 COMMAND otbVectorDataIOTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioSHPVectorDataFileReader3.txt ${TEMP}/ioSHPVectorDataFileReader3.txt otbVectorDataFileReader LARGEINPUT{VECTOR/MidiPyrenees/roads.shp} ${TEMP}/ioSHPVectorDataFileReader3.txt ) otb_add_test(NAME ioTvSHPVectorDataFileReader2 COMMAND otbVectorDataIOTestDriver --compare-ascii ${EPSILON_9} ${BASELINE_FILES}/ioSHPVectorDataFileReader2.txt ${TEMP}/ioSHPVectorDataFileReader2.txt otbVectorDataFileReader ${INPUTDATA}/ToulouseRoad-examples.shp ${TEMP}/ioSHPVectorDataFileReader2.txt ) otb_add_test(NAME ioTvKMLVectorDataFileGeoReaderWriter COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvKMLVectorDataFileGeoReaderWriterOutput.kml ${TEMP}/ioTvKMLVectorDataFileGeoReaderWriterOutput.kml otbVectorDataFileGeoReaderWriter ${INPUTDATA}/ToulouseRoad-examples.shp ${TEMP}/ioTvKMLVectorDataFileGeoReaderWriterOutput.kml ) otb_add_test(NAME ioTvKMLVectorDataFileGeoReaderWriter2 COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvKMLVectorDataFileGeoReaderWriterOutput2.kml ${TEMP}/ioTvKMLVectorDataFileGeoReaderWriterOutput2.kml otbVectorDataFileGeoReaderWriter ${INPUTDATA}/Capitole-Shadows.kml ${TEMP}/ioTvKMLVectorDataFileGeoReaderWriterOutput2.kml ) otb_add_test(NAME ioTvVectorDataFileGeoReaderWriter2 COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvVectorDataFileGeoReaderWriterOutput2.shp ${TEMP}/ioTvVectorDataFileGeoReaderWriterOutput2.shp otbVectorDataFileGeoReaderWriter ${INPUTDATA}/Capitole-Shadows.sqlite ${TEMP}/ioTvVectorDataFileGeoReaderWriterOutput2.shp ) otb_add_test(NAME ioTvVectorDataFileGeoReaderWriter COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvVectorDataFileGeoReaderWriterOutput.shp ${TEMP}/ioTvVectorDataFileGeoReaderWriterOutput.shp otbVectorDataFileGeoReaderWriter ${INPUTDATA}/ToulouseRoad-examples.shp ${TEMP}/ioTvVectorDataFileGeoReaderWriterOutput.shp ) otb_add_test(NAME ioTuVectorDataFileWriterNew COMMAND otbVectorDataIOTestDriver otbVectorDataFileWriterNew ) otb_add_test(NAME ioTvVectorDataFileWriter COMMAND otbVectorDataIOTestDriver --compare-ogr ${EPSILON_9} ${BASELINE_FILES}/ioTvVectorDataFileWriterOutput.shp ${TEMP}/ioTvVectorDataFileWriterOutput.shp otbVectorDataFileWriter ${TEMP}/ioTvVectorDataFileWriterOutput.shp ) otb_add_test(NAME ioTvVectorDataFileWriterTwice COMMAND otbVectorDataIOTestDriver otbVectorDataFileWriter ${TEMP}/ioTvVectorDataFileWriterOutput.shp ) set_property(TEST ioTvVectorDataFileWriterTwice PROPERTY DEPENDS ioTvVectorDataFileWriter) OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileGeoReaderWriter.cxx000066400000000000000000000035521301006202600276450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" #include "otbVectorDataFileReader.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" int otbVectorDataFileGeoReaderWriter(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; //Instantiation VectorDataReaderType::Pointer vectorDataReader = VectorDataReaderType::New(); VectorDataWriterType::Pointer vectorDataWriter = VectorDataWriterType::New(); VectorDataType::Pointer data = VectorDataType::New(); vectorDataReader->SetFileName(argv[1]); // vectorData->SetOrigin(m_Reader->GetOutput()->GetOrigin()); // vectorData->SetSpacing(m_Reader->GetOutput()->GetSpacing()); std::string projectionRef; itk::ExposeMetaData( vectorDataReader->GetOutput()->GetMetaDataDictionary(), otb::MetaDataKey::ProjectionRefKey, projectionRef); // vectorData->SetProjectionRef(projectionRef); std::cout << projectionRef << std::endl; vectorDataWriter->SetFileName(argv[2]); vectorDataWriter->SetInput(vectorDataReader->GetOutput()); vectorDataWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileReader.cxx000066400000000000000000000035371301006202600260200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbVectorData.h" #include int otbVectorDataFileReader(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); typedef otb::DataNode DataNodeType; typedef DataNodeType::Pointer DataNodePointerType; typedef itk::TreeContainer DataTreeType; itk::Indent indent; reader->SetFileName(argv[1]); reader->Update(); VectorDataType::Pointer data = reader->GetOutput(); DataTreeType::Pointer dataTree = DataTreeType::New(); dataTree = data->GetDataTree(); std::ofstream fout (argv[2]); itk::PreOrderTreeIterator it(dataTree); it.GoToBegin(); while (!it.IsAtEnd()) { itk::PreOrderTreeIterator itParent = it; bool goesOn = true; while (itParent.HasParent() && goesOn) { fout << indent; goesOn = itParent.GoToParent(); } fout << "+" << it.Get()->GetNodeTypeAsString() << std::endl; ++it; } /*added PrintSelf*/ fout.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileReaderNew.cxx000066400000000000000000000017521301006202600264670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileReader.h" #include "otbVectorData.h" int otbVectorDataFileReaderNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorData<> VectorDataType; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataFileReaderType::Pointer object = VectorDataFileReaderType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileReaderWriter.cxx000066400000000000000000000024221301006202600272050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" #include "otbVectorDataFileReader.h" int otbVectorDataFileReaderWriter(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileReader ReaderType; typedef otb::VectorDataFileWriter WriterType; //Instantiation ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); VectorDataType::Pointer data = VectorDataType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); writer->SetInput(reader->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileWriter.cxx000066400000000000000000000046201301006202600260640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" int otbVectorDataFileWriter(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileWriter WriterType; typedef DataNodeType::LineType LineType; typedef LineType::VertexType VertexType; //Instantiation WriterType::Pointer writer = WriterType::New(); VectorDataType::Pointer data = VectorDataType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder1 = DataNodeType::New(); DataNodeType::Pointer folder2 = DataNodeType::New(); DataNodeType::Pointer folder3 = DataNodeType::New(); DataNodeType::Pointer line = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder1->SetNodeType(otb::FOLDER); folder2->SetNodeType(otb::FOLDER); folder3->SetNodeType(otb::FOLDER); line->SetNodeType(otb::FEATURE_LINE); document->SetNodeId("DOCUMENT"); folder1->SetNodeId("FOLDER1"); folder2->SetNodeId("FOLDER2"); folder3->SetNodeId("FOLDER3"); line->SetNodeId("FEATURE_LINE"); VertexType p1; p1.Fill(5); VertexType p3; p3.Fill(0); VertexType p2; p2[0] = 0; p2[1] = 10; LineType::Pointer l = LineType::New(); l->AddVertex(p1); l->AddVertex(p2); l->AddVertex(p3); line->SetLine(l); DataNodeType::Pointer root = data->GetDataTree()->GetRoot()->Get(); data->GetDataTree()->Add(document, root); data->GetDataTree()->Add(folder1, document); data->GetDataTree()->Add(folder2, document); data->GetDataTree()->Add(folder3, document); data->GetDataTree()->Add(line, folder2); writer->SetFileName(argv[1]); writer->SetInput(data); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileWriterMultiPolygons.cxx000066400000000000000000000057561301006202600306450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" int otbVectorDataFileWriterMultiPolygons(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileWriter WriterType; typedef DataNodeType::LineType LineType; typedef DataNodeType::PolygonType PolygonType; typedef LineType::VertexType VertexType; //Instantiation WriterType::Pointer writer = WriterType::New(); VectorDataType::Pointer data = VectorDataType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder = DataNodeType::New(); DataNodeType::Pointer polygon1 = DataNodeType::New(); DataNodeType::Pointer polygon2 = DataNodeType::New(); DataNodeType::Pointer polygon3 = DataNodeType::New(); DataNodeType::Pointer polygon4 = DataNodeType::New(); DataNodeType::Pointer polygon5 = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder->SetNodeType(otb::FOLDER); polygon1->SetNodeType(otb::FEATURE_POLYGON); polygon2->SetNodeType(otb::FEATURE_POLYGON); polygon5->SetNodeType(otb::FEATURE_MULTIPOLYGON); document->SetNodeId("DOCUMENT"); folder->SetNodeId("FOLDER"); polygon5->SetNodeId("FEATURE_MULTIPOLYGON"); polygon1->SetNodeId("FEATURE_POLYGON"); polygon2->SetNodeId("FEATURE_POLYGON"); VertexType p1; p1.Fill(5); VertexType p3; p3.Fill(0); VertexType p2; p2[0] = 0; p2[1] = 10; VertexType p4; p4[0] = 1; p4[1] = 15; PolygonType::Pointer poly = PolygonType::New(); poly->AddVertex(p1); poly->AddVertex(p2); poly->AddVertex(p3); polygon1->SetPolygonExteriorRing(poly); PolygonType::Pointer poly1 = PolygonType::New(); poly1->AddVertex(p1); poly1->AddVertex(p4); poly1->AddVertex(p2); polygon2->SetPolygonExteriorRing(poly1); polygon3 = polygon1; polygon4 = polygon2; DataNodeType::Pointer root = data->GetDataTree()->GetRoot()->Get(); data->GetDataTree()->Add(document, root); data->GetDataTree()->Add(folder, document); data->GetDataTree()->Add(polygon5, folder); data->GetDataTree()->Add(polygon1, polygon5); data->GetDataTree()->Add(polygon2, polygon5); data->GetDataTree()->Add(polygon3, polygon5); writer->SetFileName(argv[1]); writer->SetInput(data); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileWriterNew.cxx000066400000000000000000000017231301006202600265370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataFileWriter.h" #include "otbVectorData.h" int otbVectorDataFileWriterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileWriter WriterType; //Instantiation WriterType::Pointer writer = WriterType::New(); std::cout << writer << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataFileWriterPolygons.cxx000066400000000000000000000052441301006202600276220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" int otbVectorDataFileWriterPolygons(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileWriter WriterType; typedef DataNodeType::LineType LineType; typedef DataNodeType::PolygonType PolygonType; typedef LineType::VertexType VertexType; //Instantiation WriterType::Pointer writer = WriterType::New(); VectorDataType::Pointer data = VectorDataType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder = DataNodeType::New(); DataNodeType::Pointer polygon1 = DataNodeType::New(); DataNodeType::Pointer polygon2 = DataNodeType::New(); DataNodeType::Pointer polygon3 = DataNodeType::New(); DataNodeType::Pointer polygon4 = DataNodeType::New(); DataNodeType::Pointer polygon5 = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder->SetNodeType(otb::FOLDER); polygon1->SetNodeType(otb::FEATURE_POLYGON); document->SetNodeId("DOCUMENT"); folder->SetNodeId("THE_FOLDER"); polygon1->SetNodeId("FEATURE_POLYGON"); VertexType p1; p1.Fill(5); VertexType p3; p3.Fill(0); VertexType p2; p2[0] = 0; p2[1] = 10; PolygonType::Pointer poly = PolygonType::New(); poly->AddVertex(p1); poly->AddVertex(p2); poly->AddVertex(p3); polygon1->SetLine(poly); polygon2 = polygon1; polygon3 = polygon1; polygon4 = polygon1; polygon5 = polygon1; DataNodeType::Pointer root = data->GetDataTree()->GetRoot()->Get(); data->GetDataTree()->Add(document, root); data->GetDataTree()->Add(folder, document); data->GetDataTree()->Add(polygon1, folder); data->GetDataTree()->Add(polygon2, folder); data->GetDataTree()->Add(polygon3, folder); data->GetDataTree()->Add(polygon4, folder); data->GetDataTree()->Add(polygon5, folder); writer->SetFileName(argv[1]); writer->SetInput(data); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataIOFactory.cxx000066400000000000000000000020201301006202600256370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorDataIOFactory.h" #include "otbVectorData.h" int otbVectorDataIOFactory(int itkNotUsed(argc), char * argv[]) { typedef otb::VectorDataIOFactory VectorData1IOFactoryType; typedef VectorData1IOFactoryType::VectorDataIOBasePointerType VectorData1IOBasePointerType; VectorData1IOBasePointerType io1 = VectorData1IOFactoryType::CreateVectorDataIO(argv[1], VectorData1IOFactoryType::ReadMode); std::cout << io1 << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/IO/VectorDataIO/test/otbVectorDataIOTestDriver.cxx000066400000000000000000000007251301006202600263350ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbVectorDataFileReaderWriter); REGISTER_TEST(otbVectorDataFileWriterPolygons); REGISTER_TEST(otbVectorDataFileReaderNew); REGISTER_TEST(otbVectorDataIOFactory); REGISTER_TEST(otbVectorDataFileWriterMultiPolygons); REGISTER_TEST(otbVectorDataFileReader); REGISTER_TEST(otbVectorDataFileGeoReaderWriter); REGISTER_TEST(otbVectorDataFileWriterNew); REGISTER_TEST(otbVectorDataFileWriter); } OTB-release-5.8/Modules/Learning/000077500000000000000000000000001301006202600165655ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/DempsterShafer/000077500000000000000000000000001301006202600215015ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/DempsterShafer/CMakeLists.txt000066400000000000000000000000551301006202600242410ustar00rootroot00000000000000project(OTBDempsterShafer) otb_module_impl() OTB-release-5.8/Modules/Learning/DempsterShafer/include/000077500000000000000000000000001301006202600231245ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbConfusionMatrixToMassOfBelief.h000066400000000000000000000127621301006202600316650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConfusionMatrixToMassOfBelief_h #define otbConfusionMatrixToMassOfBelief_h // First make sure that the configuration is available. // This line can be removed once the optimized versions // gets integrated into the main directories. #include "itkConfigure.h" #include "itkProcessObject.h" #include "otbConfusionMatrixMeasurements.h" namespace otb { /** \class ConfusionMatrixToMassOfBelief * \brief This class converts a confusion matrix into masses of belief for each label * * This class converts a confusion matrix into a std::map with MassType being * the type of the Mass of Belief of each label to be used in the Dempster-Shafer theory. * * TConfusionMatrix is the type of the confusion matrix from which the measurements will be computed. * N.B.: The confusion matrix indices are expected to be organized the following way: * confusionMatrix[itReference][itClassified], with itClassified the indice * over the columns representing the classified labels compared to the reference * labels (i.e. the reference truth) organized over the lines of the confusion matrix. * * The MassOfBeliefDefinitionMethod indicates which parameter of the confusion matrix will * stand for the mass of belief of each label (PRECISION, RECALL, ACCURACY, KAPPA). * * * \ingroup OTBDempsterShafer */ template , class TLabel = int > class ITK_EXPORT ConfusionMatrixToMassOfBelief : public itk::ProcessObject { public: /** Standard class typedefs */ typedef ConfusionMatrixToMassOfBelief Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ConfusionMatrixToMassOfBelief, itk::ProcessObject); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Type for the confusion matrix */ typedef TConfusionMatrix ConfusionMatrixType; /** Type for the labels */ typedef TLabel ClassLabelType; /** Type for the confusion matrix measurements calculator*/ typedef otb::ConfusionMatrixMeasurements ConfusionMatrixMeasurementsType; typedef typename ConfusionMatrixMeasurementsType::MapOfClassesType MapOfClassesType; typedef typename ConfusionMatrixMeasurementsType::MapOfIndicesType MapOfIndicesType; typedef double MassType; typedef std::map LabelMassMapType; enum MassOfBeliefDefinitionMethod {PRECISION, RECALL, ACCURACY, KAPPA}; void Update() ITK_OVERRIDE; /** Accessors */ itkSetMacro(ConfusionMatrix, ConfusionMatrixType); itkSetMacro(DefinitionMethod, MassOfBeliefDefinitionMethod); /* Gives the correspondence between a class label * and its index in the confusion matrix */ virtual void SetMapOfClasses(const MapOfClassesType _arg) { m_MapOfClasses = _arg; typename MapOfClassesType::iterator itMapOfClasses; m_MapOfIndices.clear(); for (itMapOfClasses = m_MapOfClasses.begin(); itMapOfClasses != m_MapOfClasses.end(); ++itMapOfClasses) { m_MapOfIndices[itMapOfClasses->second] = itMapOfClasses->first; } } MapOfClassesType GetMapOfClasses() const { return m_MapOfClasses; } /* Gives the correspondence between an index in the * confusion matrix and the class label */ virtual void SetMapOfIndices(const MapOfIndicesType _arg) { m_MapOfIndices = _arg; typename MapOfIndicesType::iterator itMapOfIndices; m_MapOfClasses.clear(); for (itMapOfIndices = m_MapOfIndices.begin(); itMapOfIndices != m_MapOfIndices.end(); ++itMapOfIndices) { m_MapOfClasses[itMapOfIndices->second] = itMapOfIndices->first; } } MapOfIndicesType GetMapOfIndices() const { return m_MapOfIndices; } LabelMassMapType GetMapMassOfBelief() const { return m_MapMassOfBelief; } protected: /** Constructor */ ConfusionMatrixToMassOfBelief(); /** Destructor */ ~ConfusionMatrixToMassOfBelief() ITK_OVERRIDE {}; /** Triggers the computation of the confusion matrix */ void GenerateData(void) ITK_OVERRIDE; private: ConfusionMatrixToMassOfBelief(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented ConfusionMatrixType m_ConfusionMatrix; typename ConfusionMatrixMeasurementsType::Pointer m_ConfMatMeasurements; MapOfClassesType m_MapOfClasses; MapOfIndicesType m_MapOfIndices; MassOfBeliefDefinitionMethod m_DefinitionMethod; LabelMassMapType m_MapMassOfBelief; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConfusionMatrixToMassOfBelief.txx" #endif #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbConfusionMatrixToMassOfBelief.txx000066400000000000000000000053421301006202600322550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConfusionMatrixToMassOfBelief_txx #define otbConfusionMatrixToMassOfBelief_txx #include "otbConfusionMatrixToMassOfBelief.h" namespace otb { template ConfusionMatrixToMassOfBelief ::ConfusionMatrixToMassOfBelief() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(1); this->m_ConfMatMeasurements = ConfusionMatrixMeasurementsType::New(); this->m_DefinitionMethod = this->PRECISION; } template void ConfusionMatrixToMassOfBelief ::Update() { this->GenerateData(); } template void ConfusionMatrixToMassOfBelief ::GenerateData() { this->m_ConfMatMeasurements->SetConfusionMatrix(m_ConfusionMatrix); this->m_ConfMatMeasurements->Compute(); typename MapOfIndicesType::iterator itMapOfIndices; MassType currentMass = 0.; this->m_MapMassOfBelief.clear(); for (itMapOfIndices = m_MapOfIndices.begin(); itMapOfIndices != m_MapOfIndices.end(); ++itMapOfIndices) { switch (m_DefinitionMethod) { case PRECISION: // Masses of Belief = Precision Rate of each label (TP / [TP + FP]) currentMass = m_ConfMatMeasurements->GetPrecisions()[itMapOfIndices->first]; break; case RECALL: // Masses of Belief = Recall Rate of each label (TP / [TP + FN]) currentMass = m_ConfMatMeasurements->GetRecalls()[itMapOfIndices->first]; break; case ACCURACY: // Masses of Belief = Overall Accuracy of the confusion matrix (SUM[TP] / nbSamples) currentMass = m_ConfMatMeasurements->GetOverallAccuracy(); break; case KAPPA: // Masses of Belief = Kappa Index of the confusion matrix currentMass = m_ConfMatMeasurements->GetKappaIndex(); break; default: // Masses of Belief = Precision Rate of each label (TP / [TP + FP] currentMass = m_ConfMatMeasurements->GetPrecisions()[itMapOfIndices->first]; break; }// END switch (m_DefinitionMethod) this->m_MapMassOfBelief[itMapOfIndices->second] = currentMass; } } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbDSFusionOfClassifiersImageFilter.h000066400000000000000000000157541301006202600322760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDSFusionOfClassifiersImageFilter_h #define otbDSFusionOfClassifiersImageFilter_h #include "itkImageToImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" namespace otb { /** \class DSFusionOfClassifiersImageFilter * \brief Performs a fusion of n classification maps using the Dempster Shafer (noted DS) rule of combination. * * This filter performs a fusion of n classification maps using the Dempster Shafer rule of combination from * an otbVectorImage with n channels, each one corresponding to an input classification map to be fused. This * otbVectorImage can be obtained with the help of a preliminary use of the otbImageListToVectorImageFilter. * * Moreover, the otbDSFusionOfClassifiersImageFilter needs as additional input a std::vector containing the * n std::maps of Masses Of Belief (noted MOB). Each std::map in this input std::vector is related * to one classifier and links each label to its mass of belief in this classifier. * * The output label image resulting from the DS fusion of classification maps only has one channel (monoband image). * * The recursive optimized Dempster Shafer combination of masses of belief is performed in 2 steps for each channel * component of each pixel of the input otbVectorImage within the input mask, and is based on: * * [1] L. Xu, A. Krzyzak, and C.Y. Suen, * "Methods of combining multiple classifiers and their applications to handwriting recognition," * Systems, Man and Cybernetics, IEEE Transactions on vol. 22, no.3, pp. 418-435, * May/Jun 1992. * * [2] D. Ruta and B. Gabrys, * "An Overview of Classifier Fusion Methods," * Computing and Information Systems, vol. 7 pp.1-10, * University of Paisley, 2000. * * [3] C.R. Parikh, M.J. Pont, and N.B. Jones, * "Application of Dempster-Shafer theory in condition monitoring systems: A case study," * Pattern Recognition Letters, vol. 22 (6-7): pp. 777-785, * 2001. * * * \sa MassOfBelief * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBDempsterShafer */ template class ITK_EXPORT DSFusionOfClassifiersImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef DSFusionOfClassifiersImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(DSFusionOfClassifiersImageFilter, ImageToImageFilter); // TInputImage is expected to be a vector image typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::InternalPixelType ValueType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType InternalPixelType; // TMaskImage is expected to be a mono band image typedef TMaskImage MaskImageType; typedef typename MaskImageType::ConstPointer MaskImageConstPointerType; typedef typename MaskImageType::Pointer MaskImagePointerType; // TOutputImage is expected to be a mono band image typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType LabelType; typedef double MassType; typedef typename std::map LabelMassMapType; typedef typename std::map ClassifierHistogramType; typedef typename std::vector VectorOfMapOfMassesOfBeliefType; /** Set/Get the m_LabelForNoDataPixels */ itkSetMacro(LabelForNoDataPixels, LabelType); itkGetMacro(LabelForNoDataPixels, LabelType); /** Set/Get the LabelForUndecidedPixels */ itkSetMacro(LabelForUndecidedPixels, LabelType); itkGetMacro(LabelForUndecidedPixels, LabelType); /** * If set, only pixels within the mask (i.e. pixels different from 0 in the InputMask) will be fused. * The pixels out of the mask (i.e. pixels equal to 0 in the InputMask) will be set to m_LabelForNoDataPixels * in the Output fused image. * \param mask The input mask. */ void SetInputMask(const MaskImageType * mask); void SetInputMapsOfMassesOfBelief(const VectorOfMapOfMassesOfBeliefType * ptrVectorOfMapOfMassesOfBelief); /** * Get the input mask. * \return The mask. */ const MaskImageType * GetInputMask(void); const VectorOfMapOfMassesOfBeliefType * GetInputMapsOfMassesOfBelief(void); const LabelType OptimizedDSMassCombination(PixelType vectorPixelValue); protected: /** Constructor */ DSFusionOfClassifiersImageFilter(); /** Destructor */ ~DSFusionOfClassifiersImageFilter() ITK_OVERRIDE {} /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: DSFusionOfClassifiersImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfClassifiers; ClassifierHistogramType m_Universe; unsigned int m_NumberOfClassesInUniverse; VectorOfMapOfMassesOfBeliefType m_VectorOfMapMOBs; std::vector m_VectorOfUniverseMOBs; /** No Data label for invalid pixels (when using a mask) */ LabelType m_LabelForNoDataPixels; /** Undecided label for pixels with NOT unique DS voting */ LabelType m_LabelForUndecidedPixels; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDSFusionOfClassifiersImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbDSFusionOfClassifiersImageFilter.txx000066400000000000000000000531541301006202600326660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDSFusionOfClassifiersImageFilter_txx #define otbDSFusionOfClassifiersImageFilter_txx #include "otbDSFusionOfClassifiersImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" namespace otb { /** * Constructor */ template DSFusionOfClassifiersImageFilter ::DSFusionOfClassifiersImageFilter() { this->SetNumberOfIndexedInputs(2); this->SetNumberOfRequiredInputs(1); this->m_Universe.clear(); this->m_LabelForNoDataPixels = itk::NumericTraits::ZeroValue(); this->m_LabelForUndecidedPixels = itk::NumericTraits::ZeroValue(); } /* ************************************************************************************************************** */ template void DSFusionOfClassifiersImageFilter ::SetInputMask(const MaskImageType * mask) { this->itk::ProcessObject::SetNthInput(1, const_cast(mask)); } template const typename DSFusionOfClassifiersImageFilter ::MaskImageType * DSFusionOfClassifiersImageFilter ::GetInputMask() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } /* ************************************************************************************************************** */ template void DSFusionOfClassifiersImageFilter ::SetInputMapsOfMassesOfBelief(const VectorOfMapOfMassesOfBeliefType * ptrVectorOfMapOfMassesOfBelief) { this->m_VectorOfMapMOBs = *ptrVectorOfMapOfMassesOfBelief; } template const typename DSFusionOfClassifiersImageFilter ::VectorOfMapOfMassesOfBeliefType * DSFusionOfClassifiersImageFilter ::GetInputMapsOfMassesOfBelief() { if (this->GetNumberOfInputs() < 2) { return 0; } return &this->m_VectorOfMapMOBs; } /* ************************************************************************************************************** */ template void DSFusionOfClassifiersImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // Set the NoData value std::vector noDataValueAvailable; noDataValueAvailable.push_back(true); std::vector noDataValue; noDataValue.push_back(m_LabelForNoDataPixels); itk::MetaDataDictionary& dict = this->GetOutput()->GetMetaDataDictionary(); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); } /* ************************************************************************************************************** */ template void DSFusionOfClassifiersImageFilter ::BeforeThreadedGenerateData() { // ********************************************** // PREPROCESSING // ********************************************** m_NumberOfClassifiers = m_VectorOfMapMOBs.size(); // ***************************************************************************************************** // For each classifier: Definition of the UNIVERSE // ***************************************************************************************************** m_VectorOfUniverseMOBs.clear(); m_Universe.clear(); for (unsigned int itClk = 0; itClk < m_NumberOfClassifiers; ++itClk) { // Map of masses of belief of the itClk^th classifier LabelMassMapType mapMOBsClk = m_VectorOfMapMOBs[itClk]; // mobUniverseClk is set to ZERO in order to assure the correct estimation of the Belief Functions of the // complementary sets bel({Ai_}) in the optimized DS combination MassType mobUniverseClk = 0.; // Vector containing the Mass of Belief of the UNIVERSE for each classifier m_VectorOfUniverseMOBs.push_back(mobUniverseClk); // Each label present in the itClk^th classifier is pushed in the UNIVERSE if NOT present in it yet // thus, this->m_Universe = std::map is calculated typename LabelMassMapType::iterator itMapMOBClk; for (itMapMOBClk = mapMOBsClk.begin(); itMapMOBClk != mapMOBsClk.end(); ++itMapMOBClk) { LabelType classLabel = itMapMOBClk->first; // If the current classLabel has already been pushed in the UNIVERSE if (m_Universe.count(classLabel) > 0) { m_Universe[classLabel]++; } else { m_Universe[classLabel] = 1; } } } m_NumberOfClassesInUniverse = m_Universe.size(); } template const typename DSFusionOfClassifiersImageFilter ::LabelType DSFusionOfClassifiersImageFilter ::OptimizedDSMassCombination(PixelType vectorPixelValue) { LabelType outFusedLabelOut = itk::NumericTraits::ZeroValue(); /* ************************************************************************************************ */ /* ******************************* DS FUSION STEP #1: RECURSIVE METHOD **************************** */ /* ************************************************************************************************ */ LabelType classLabelk; MassType mLabelSetClk, mLabelSetClk_, mUniverseClk; MassType mLabelSetClkprev, mLabelSetClkprev_, mUniverseClkprev; MassType KClk, mLabelSetClkNew, mLabelSetClkNew_, mUniverseClkNew; LabelMassMapType mapJointMassesStepI, mapJointMassesStepI_, mapJointMassesUniverseStepI; LabelMassMapType mapOfLabelsWithMassOne, mapOfLabelsWithMassZero; // Extracting the masses m(Ai), m(Ai_) and m(OMEGA) for each of the K (= m_NumberOfClassifiers) classifiers // and grouping them according to the {Ai} singletons // (ex: mg(A), mg(B), mg(C),..., with mg(Ai) the joint mass of the masses of classifiers with result Ai for // the pixel vectorPixelValue) for (unsigned int itClk = 0; itClk < m_NumberOfClassifiers; ++itClk) { // Value of the itClk^th classifier {Ai} in the vectorPixelValue classLabelk = vectorPixelValue[itClk]; // label {Ai} if (classLabelk != m_LabelForNoDataPixels) { // Extracting the masses of belief of the three focal elements {Ai}, {Ai_} and OMEGA = {Ai U Ai_} = UNIVERSE // of the k^th classifier itClk mUniverseClk = m_VectorOfUniverseMOBs[itClk]; // MOB_Clk(OMEGA) mLabelSetClk = m_VectorOfMapMOBs[itClk][classLabelk]; // MOB_Clk({Ai}) mLabelSetClk_ = 1 - mLabelSetClk - mUniverseClk; // MOB_Clk({Ai_}) /*std::cout << "vectorPixelValue[" << itClk << "] = " << classLabelk; std::cout << "; MassOfBelief_Cl_" << itClk << "[" << classLabelk << "] = " << mLabelSetClk; std::cout << std::endl; */ if ((mLabelSetClk > 0) && (mLabelSetClk < 1.0)) { if (mapJointMassesStepI.count(classLabelk) == 0) { // If the label {Ai} is NOT present in vectorPixelValue yet: initializations of the three DS combined MOBs mLabelSetClkNew = mLabelSetClk; mLabelSetClkNew_ = mLabelSetClk_; mUniverseClkNew = mUniverseClk; } else { // If the label {Ai} is already present in vectorPixelValue: recursive DS combination of the three MOBs mLabelSetClkprev = mapJointMassesStepI[classLabelk]; mLabelSetClkprev_ = mapJointMassesStepI_[classLabelk]; mUniverseClkprev = mapJointMassesUniverseStepI[classLabelk]; KClk = 1.0 / (1 - mLabelSetClkprev * mLabelSetClk_ - mLabelSetClkprev_ * mLabelSetClk); mLabelSetClkNew = KClk * (mLabelSetClkprev * (mLabelSetClk + mUniverseClk) + mUniverseClkprev * mLabelSetClk); mLabelSetClkNew_ = KClk * (mLabelSetClkprev_ * (mLabelSetClk_ + mUniverseClk) + mUniverseClkprev * mLabelSetClk_); mUniverseClkNew = KClk * mUniverseClkprev * mUniverseClk; } mapJointMassesStepI[classLabelk] = mLabelSetClkNew; mapJointMassesStepI_[classLabelk] = mLabelSetClkNew_; mapJointMassesUniverseStepI[classLabelk] = mUniverseClkNew; }// END if ((mLabelSetClk > 0) && (mLabelSetClk < 1.0)) else { if (mLabelSetClk == 1.0) { mapOfLabelsWithMassOne[classLabelk] = mLabelSetClk; } else { if (mLabelSetClk == 0) { mapOfLabelsWithMassZero[classLabelk] = 1.0; } } } // END if ((mLabelSetClk == 0) || (mLabelSetClk == 1.0)) } // END if (classLabelk != m_LabelForNoDataPixels) } /* ************************************************************************************************ */ /* ************************************************************************************************ */ // If ALL the classifiers give the same result, then there is no need to process the DS combination typename LabelMassMapType::iterator itMapMOBClk; if (mapJointMassesStepI.size() == 1) { itMapMOBClk = mapJointMassesStepI.begin(); classLabelk = itMapMOBClk->first; return classLabelk; } /* ************************************************************************************************ */ /* ************************************************************************************************ */ // If at least one classifier returns a label with a mass of belief equal to 1.0, then 2 cases // should be considered: // // -If this label is unique, then this label is considered as the truth, and the output pixel is set // to this label value // // -If this label is NOT unique, then the corresponding classifiers are in conflict and the output // pixel is set to the m_LabelForUndecidedPixels value if (mapOfLabelsWithMassOne.size() > 0) { if (mapOfLabelsWithMassOne.size() == 1) { itMapMOBClk = mapOfLabelsWithMassOne.begin(); classLabelk = itMapMOBClk->first; return classLabelk; } else { return m_LabelForUndecidedPixels; } } /* ************************************************************************************************ */ /* ************************************************************************************************ */ // If ALL the K (= m_NumberOfClassifiers) classifiers of the pixel vectorPixelValue have // masses of belief equal to 0, then the output pixel is set to the m_LabelForUndecidedPixels value if (mapOfLabelsWithMassZero.size() == m_NumberOfClassifiers) { return m_LabelForUndecidedPixels; } /* ************************************************************************************************ */ /* ************************************************************************************************ */ // If ALL the K (= m_NumberOfClassifiers) classifiers of the pixel vectorPixelValue are // equal to m_LabelForNoDataPixels, then the output pixel is set to the m_LabelForNoDataPixels value if (mapJointMassesStepI.size() == 0) { return m_LabelForNoDataPixels; } /* ************************************************************************************************ */ /* ************************************************************************************************ */ //std::cout << "*******************************************************************************" << std::endl; //std::cout << std::endl; /* ************************************************************************************************ */ /* ******************************* DS FUSION STEP #2: OPTIMIZED METHOD **************************** */ /* ************************************************************************************************ */ // Calculation of the four constants A, B, C and K MassType A = 0, B = 1, C = 1, K; K = 0; //suppress warning. not sure about default value ?? for (itMapMOBClk = mapJointMassesStepI.begin(); itMapMOBClk != mapJointMassesStepI.end(); ++itMapMOBClk) { classLabelk = itMapMOBClk->first; mLabelSetClk = mapJointMassesStepI[classLabelk]; mLabelSetClk_ = mapJointMassesStepI_[classLabelk]; mUniverseClk = mapJointMassesUniverseStepI[classLabelk]; A += (mLabelSetClk / (1 - mLabelSetClk)); B *= (1 - mLabelSetClk); C *= mLabelSetClk_; /*std::cout << "****************************************" << std::endl; std::cout << "mapJointMassesStepI[" << classLabelk << "] = " << mLabelSetClk << std::endl; std::cout << "mapJointMassesStepI_[" << classLabelk << "] = " << mLabelSetClk_ << std::endl; std::cout << "mapJointMassesUniverseStepI[" << classLabelk << "] = " << mUniverseClk << std::endl; */ } unsigned int nbClkGroupsStepI = mapJointMassesStepI.size(); if (nbClkGroupsStepI == m_NumberOfClassesInUniverse) { K = 1.0 / ((1 + A) * B - C); } else { if (nbClkGroupsStepI < m_NumberOfClassesInUniverse) { K = 1.0 / ((1 + A) * B); } } /* std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "m_NumberOfClassesInUniverse = " << m_NumberOfClassesInUniverse << std::endl; std::cout << "m_NumberOfClassifiers = " << m_NumberOfClassifiers << std::endl; std::cout << "nbClkGroupsStepI = " << nbClkGroupsStepI << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; */ // Calculation of the Belief functions Bel({Ai}) and Bel({Ai_}) of the singletons {Ai} and {Ai_} LabelMassMapType mapBelStepII, mapBelStepII_; MassType belLabelSetClk, belLabelSetClk_, addBelLabelSetClk = 0.; for (itMapMOBClk = mapJointMassesStepI.begin(); itMapMOBClk != mapJointMassesStepI.end(); ++itMapMOBClk) { classLabelk = itMapMOBClk->first; // Joint Masses of Belief AFTER STEP I (one MOB per singleton class {Ai} in the UNIVERSE) mLabelSetClk = mapJointMassesStepI[classLabelk]; // Joint_MOB_Step_I({Ai}) mLabelSetClk_ = mapJointMassesStepI_[classLabelk]; // Joint_MOB_Step_I({Ai_}) mUniverseClk = mapJointMassesUniverseStepI[classLabelk]; // Joint_MOB_Step_I(OMEGA) // Bel({Ai}) if ((nbClkGroupsStepI == m_NumberOfClassesInUniverse) || ((nbClkGroupsStepI == (m_NumberOfClassesInUniverse - 1)) && (K == m_NumberOfClassesInUniverse))) { belLabelSetClk = K * ((mLabelSetClk / (1 - mLabelSetClk)) * B + (mUniverseClk * C / mLabelSetClk_)); } else { belLabelSetClk = K * (mLabelSetClk / (1 - mLabelSetClk)) * B; } // Bel({Ai_}) belLabelSetClk_ = 1 - belLabelSetClk; /*if (nbClkGroupsStepI == m_NumberOfClassesInUniverse) { belLabelSetClk_ = K * ((A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B - C); } else { if ((nbClkGroupsStepI < m_NumberOfClassesInUniverse) && (K <= nbClkGroupsStepI)) { belLabelSetClk_ = K * (A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B; } else { belLabelSetClk_ = K * (A - (mLabelSetClk / (1 - mLabelSetClk))) * B; } }*/ mapBelStepII[classLabelk] = belLabelSetClk; mapBelStepII_[classLabelk] = belLabelSetClk_; addBelLabelSetClk += belLabelSetClk; } // END Calculation of the Belief functions Bel({Ai}) and Bel({Ai_}) of the singletons {Ai} and {Ai_} // ADJUSTMENT in order to handle the residual MOB = (1 - addBelLabelSetClk) of the other singleton classes {Ai} // of the UNIVERSE which are NOT present in vectorPixelValue. // /!\ N.B.: This adjustment is correct ONLY if ALL the K (= m_NumberOfClassifiers) classifiers have mUniverseClk = 0 typename ClassifierHistogramType::iterator itUniverse; for (itUniverse = m_Universe.begin(); itUniverse != m_Universe.end(); ++itUniverse) { classLabelk = itUniverse->first; // For the other singleton classes {Ai} of the UNIVERSE which are NOT present in vectorPixelValue, // Bel({Ai_}) = SUM(m_stepII({Aj})) = SUM(Bel({Aj})) here; with {Aj} ALL the labels present in vectorPixelValue if (mapBelStepII[classLabelk] == 0) { mapBelStepII_[classLabelk] = addBelLabelSetClk; } /* else { // Adjustment: Bel({Ai_}) = m_stepII({Ai_}) + 1 - SUM(m_stepII({Aj})) here; // with {Aj} ALL the labels present in vectorPixelValue mapBelStepII_[classLabelk] += (1 - addBelLabelSetClk); } */ /*std::cout << "Bel(" << classLabelk << ") = " << mapBelStepII[classLabelk] << std::endl; std::cout << "Bel(NOT_" << classLabelk << ") = " << mapBelStepII_[classLabelk] << std::endl; std::cout << std::endl; */ } //std::cout << "****************************************************************************" << std::endl; /* ***************************************************************************************** */ /* ************************************ DECISION PROCESS *********************************** */ /* ***************************************************************************************** */ // The decision for the DS Fusion is made with the MAXIMAL Belief function: // {Ai} is chosen if Bel({Ai}) = MAX(Bel({Aj})) MassType fusedDSBelLabelSetClk = 0.; // Here the MAX of Bel({Aj} for (itUniverse = m_Universe.begin(); itUniverse != m_Universe.end(); ++itUniverse) { classLabelk = itUniverse->first; if (itUniverse == m_Universe.begin()) { outFusedLabelOut = classLabelk; fusedDSBelLabelSetClk = mapBelStepII[classLabelk]; } else { if (mapBelStepII[classLabelk] >= fusedDSBelLabelSetClk) { outFusedLabelOut = classLabelk; fusedDSBelLabelSetClk = mapBelStepII[classLabelk]; } } } // If the DS VOTED LABEL is NOT unique, the result of the DS Fusion is this->m_LabelForUndecidedPixels for (itUniverse = m_Universe.begin(); itUniverse != m_Universe.end(); ++itUniverse) { classLabelk = itUniverse->first; if ((mapBelStepII[classLabelk] == fusedDSBelLabelSetClk) && (classLabelk != outFusedLabelOut)) { outFusedLabelOut = m_LabelForUndecidedPixels; break; } } /*std::cout << "****************************************************************************" << std::endl; std::cout << "outFusedLabelOut = " << outFusedLabelOut << std::endl; std::cout << "Bel(" << outFusedLabelOut << ") = " << fusedDSBelLabelSetClk << std::endl; */ return outFusedLabelOut; } template void DSFusionOfClassifiersImageFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Get the input pointers InputImageConstPointerType inputPtr = this->GetInput(); MaskImageConstPointerType inputMaskPtr = this->GetInputMask(); OutputImagePointerType outputPtr = this->GetOutput(); // Progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define iterators typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator MaskIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; InputIteratorType inIt(inputPtr, outputRegionForThread); OutputIteratorType outIt(outputPtr, outputRegionForThread); // Eventually iterate on masks MaskIteratorType maskIt; if (inputMaskPtr) { maskIt = MaskIteratorType(inputMaskPtr, outputRegionForThread); maskIt.GoToBegin(); } bool validPoint = true; // Walk the part of the image for (inIt.GoToBegin(), outIt.GoToBegin(); !inIt.IsAtEnd() && !outIt.IsAtEnd(); ++inIt, ++outIt) { // Check pixel validity if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } // If point is valid if (validPoint) { // Over ALL the i components inIt.Get()[i] of the input vector pixel (with i between 0 and m_NumberOfClassifiers) outIt.Set(this->OptimizedDSMassCombination(inIt.Get())); } else { // else, outIt is set to the m_LabelForNoDataPixels value outIt.Set(m_LabelForNoDataPixels); } progress.CompletedPixel(); } } /** * PrintSelf Method */ template void DSFusionOfClassifiersImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbJointMassOfBeliefFilter.h000066400000000000000000000065271301006202600304650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbJointMassOfBeliefFilter_h #define otbJointMassOfBeliefFilter_h #include "itkProcessObject.h" namespace otb { /** \class JointMassOfBeliefFilter * \brief Performs Dempster-Shafer combination of n masses function. * * This filter computes the joint mass of n input masses using * Dempster-Shafer rule of combination. * * Input masses can be added by using the PushBackInput() method. * * \sa MassOfBelief * * \ingroup OTBDempsterShafer */ template class ITK_EXPORT JointMassOfBeliefFilter : public itk::ProcessObject { public: /** Standard class typedefs */ typedef JointMassOfBeliefFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(JointMassOfBeliefFilter, ProcessObject); /** Standard class typedefs */ typedef TMassFunction MassFunctionType; typedef typename MassFunctionType::Pointer MassFunctionPointerType; typedef typename MassFunctionType::LabelType LabelType; typedef typename MassFunctionType::MassType MassType; typedef typename MassFunctionType::LabelSetType LabelSetType; typedef typename MassFunctionType::LabelSetOfSetType LabelSetOfSetType; /** Add an input to the end */ using Superclass::PushBackInput; virtual void PushBackInput(const MassFunctionType * input); /** Add an input to the front */ using Superclass::PushFrontInput; virtual void PushFrontInput(const MassFunctionType * input); /** Remove the last input */ using Superclass::PopBackInput; void PopBackInput() ITK_OVERRIDE; /** Remove the first input */ using Superclass::PopFrontInput; void PopFrontInput() ITK_OVERRIDE; /** Get the idx th input */ const MassFunctionType * GetInput(unsigned int idx); /** Get the output joint mass */ MassFunctionType * GetOutput(); protected: /** Constructor */ JointMassOfBeliefFilter(); /** Destructor */ ~JointMassOfBeliefFilter() ITK_OVERRIDE {} /** GenerateData */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: JointMassOfBeliefFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Combine masses from input and output into output */ void CombineMasses(const MassFunctionType * input, MassFunctionType * output); }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbJointMassOfBeliefFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbJointMassOfBeliefFilter.txx000066400000000000000000000133751301006202600310600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbJointMassOfBeliefFilter_txx #define otbJointMassOfBeliefFilter_txx #include "otbJointMassOfBeliefFilter.h" namespace otb { template JointMassOfBeliefFilter ::JointMassOfBeliefFilter() { // Set the number of outputs this->SetNumberOfRequiredOutputs(1); // Build the output typename MassFunctionType::Pointer outputPtr = MassFunctionType::New(); this->SetNthOutput(0, outputPtr.GetPointer()); } template void JointMassOfBeliefFilter ::PushBackInput(const MassFunctionType * input) { this->itk::ProcessObject::PushBackInput(input); } template void JointMassOfBeliefFilter ::PushFrontInput(const MassFunctionType * input) { this->itk::ProcessObject::PushFrontInput(input); } template void JointMassOfBeliefFilter ::PopBackInput() { this->itk::ProcessObject::PopBackInput(); } template void JointMassOfBeliefFilter ::PopFrontInput() { this->itk::ProcessObject::PopFrontInput(); } template const typename JointMassOfBeliefFilter ::MassFunctionType * JointMassOfBeliefFilter ::GetInput(unsigned int idx) { return static_cast(this->itk::ProcessObject::GetInput(idx)); } template typename JointMassOfBeliefFilter ::MassFunctionType * JointMassOfBeliefFilter ::GetOutput() { if(this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template void JointMassOfBeliefFilter ::GenerateData() { // Retrieve the output pointer typename MassFunctionType::Pointer outputPtr = this->GetOutput(); // Walk the inputs for(unsigned int i = 0; i < this->GetNumberOfInputs(); ++i) { // Retrieve the ith input mass function typename MassFunctionType::ConstPointer inputPtr = this->GetInput(i); // Combine it with the current joint mass this->CombineMasses(inputPtr, outputPtr); } } template void JointMassOfBeliefFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); } template void JointMassOfBeliefFilter ::CombineMasses(const MassFunctionType * input, MassFunctionType * output) { // Handle case where output is empty if(output->IsEmpty()) { // In this case, copy the input mass function output->Copy(input); // And return return; } // Define a temporary mass function typename MassFunctionType::Pointer newJointMass = MassFunctionType::New(); // Conflict sum will be used to wheight the final masses MassType conflict = itk::NumericTraits::Zero; // Store joint mass support set so as to avoid computing it again // when normalizing by conflict LabelSetOfSetType jointSupport; // First, retrieve the support set of input and currentJointMap LabelSetOfSetType inputSupportSet = input->GetSupport(); LabelSetOfSetType currentSupportSet = output->GetSupport(); // Then, Walk the two sets for(typename LabelSetOfSetType::const_iterator inputIt = inputSupportSet.begin(); inputIt != inputSupportSet.end(); ++inputIt) { for(typename LabelSetOfSetType::const_iterator currentIt = currentSupportSet.begin(); currentIt != currentSupportSet.end(); ++currentIt) { // Compute intersection LabelSetType intersectionSet; std::insert_iterator interIt(intersectionSet, intersectionSet.begin()); // Perform set intersection std::set_intersection(inputIt->begin(), inputIt->end(), currentIt->begin(), currentIt->end(), interIt); // Compute mass product MassType massProduct = input->GetMass((*inputIt))*output->GetMass((*currentIt)); // If intersection is null, update conflict if(intersectionSet.empty()) { conflict+= massProduct; } // Else, update output mass else { // Retrieve current mass for this intersection set MassType intersectionMass = newJointMass->GetMass(intersectionSet); // Cumulate with product of masses intersectionMass+=massProduct; // Update new joint mass newJointMass->SetMass(intersectionSet, intersectionMass); // Store in joint support jointSupport.insert(intersectionSet); } } } // Normalize new joint mass with conflict MassType conflictCoefficient = 1/(1-conflict); // Retrieve support of joint mass for(typename LabelSetOfSetType::const_iterator it = jointSupport.begin(); it!=jointSupport.end(); ++it) { // Retrieve joint mass MassType jointMass = newJointMass->GetMass((*it)); // Normalize by conflict jointMass*=conflictCoefficient; // Update joint mass newJointMass->SetMass((*it), jointMass); } // Finally, swap output and newJointMass function output->Copy(newJointMass); } } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbJointMassOfBeliefFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbMassOfBelief.h000066400000000000000000000154711301006202600263110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMassOfBelief_h #define otbMassOfBelief_h #include "itkDataObject.h" #include "itkObjectFactory.h" #include "itkNumericTraits.h" #include #include #include namespace otb { /** \class MassOfBelief * \brief This class represent a mass of belief function * * This class represent a Mass of Belief function to be used in * Dempster-Shafer theory. * * Template parameter TLabel is the type of the elements in the * universe set, while TMass is the type of the mass. TLabel can be * any type implementing ordering operator, while TMass should be a * floating point type. * * An element of the power-set is represented by the sub-type * LabelSetType, which is a std::set. * * A mass can be associated with a given element from the power set * by calling the SetMass method. It is not necessary to associate * masses with each element of the power set: mass is supposed to be * null otherwise declared. * * A mass associated with an element from the power-set can be * removed using the RemoveMass method, and all masses can be cleared * using the Clear() function. * * The mass associated with a given element from the power-set can be * retrieved using the GetMass method. If no mass has been associated * with this element, null is returned. * * The Normalize() method allows normalizing all masses so that they * sum to 1. The EstimateUncertainty() method allows associating to * the uncertain set (i.e. the universe set) a mass so that all * masses sum to 1. * * The GetUniverse() method allows retrieving the set of all symbols * (i.e. the universal set), while the GetSupport() method allows * retrieving the set of all elements of the power-set for which a mass * has been associated. This method returns a LabelSetOfSetType, * which is a std::set >. * * The mass function can be optionnaly initialized from a given * universe set by building the power-set and associating a null mass * with every elements of this power-set. This allows ensuring that * two mass functions will share the exact same universe and * power-set, but is not mandatory, since mass is supposed to be null * for any set if not stated otherwise. * * Once masses are set, the GetPlausibility() and GetBelief() * function allow computing the belief and plausibility for an * element of the power-set, or directly for a set of elements of the * power-set intersecting (resp. contained in) a given hypothesis. * * * \ingroup OTBDempsterShafer */ template class ITK_EXPORT MassOfBelief : public itk::DataObject { public: /** Standard class typedefs */ typedef MassOfBelief Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MassOfBelief, DataObject); typedef TLabel LabelType; typedef TMass MassType; typedef std::set LabelSetType; typedef std::map MassMapType; typedef std::set LabelSetOfSetType; /** Register a mass associated with an element of the power-set */ void SetMass(const LabelSetType & labelSet, const MassType & mass); /** Retrieve the mass associated with the given element of the power * set */ MassType GetMass(const LabelSetType & labelSet) const; /** Remove mass from the support */ void RemoveMass(const LabelSetType & labelSet); /** Retrieve the support of the mass of belief (i.e. a vector of * element of the power set for which the mass of belief is not * null) */ LabelSetOfSetType GetSupport() const; /** Get the set of universe symbols for this mass function */ LabelSetType GetUniverse() const; /** Normalize mass set sot that the sum of masses equals 1 */ void Normalize(); /** Associate to uncertainty a mass such that the sum of masses * equals 1 */ void EstimateUncertainty(); /** Clear all masses */ void Clear(); /** Initialize with all elements from the power set with null * masses. Please note that this is not mandatory and only allows * to ensure that two mass functions share the same universe, even * if most of masses are null. */ void InitializePowerSetMasses(const LabelSetType & universe); /** Get the belief of a given element of the power-set */ MassType GetBelief(const LabelSetType & labelSet) const; /** Get the plausibility of a given element of the power-set */ MassType GetPlausibility(const LabelSetType & labelSet) const; /** Get the belief for an hypothesis containing a given set of * elements from the power-set */ MassType GetBelief(const LabelSetOfSetType & containedLabelSet) const; /** Get the belief for an hypothesis intersecting a given set of * elements from the power set.*/ MassType GetPlausibility(const LabelSetOfSetType & intersectedLabelSet) const; /** Copy masses of two mass functions */ void Copy(const Self * massOfBelief); /** Return true if the support set is null */ bool IsEmpty() const; /** Define a Print static method for label sets * Do not overload << for std::set since it causes * namespace issues. */ static std::ostream & PrintLabelSet(std::ostream & out, const LabelSetType & labelSet); /** Define a Print static method for label sets * Do not overload << for std::set since it causes * namespace issues. */ static std::ostream & PrintLabelSetOfSet(std::ostream & out, const LabelSetOfSetType & labelSet); protected: /** Constructor */ MassOfBelief() {} /** Desctructor */ ~MassOfBelief() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: MassOfBelief(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** The masses map */ MassMapType m_MassesMap; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMassOfBelief.txx" #endif #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbMassOfBelief.txx000066400000000000000000000254401301006202600267020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMassOfBelief_txx #define otbMassOfBelief_txx #include "otbMassOfBelief.h" #include #include #include "otbMath.h" namespace otb { template void MassOfBelief ::SetMass(const LabelSetType & labelSet, const MassType & mass) { // Insert into the mass map m_MassesMap[labelSet] = mass; // Call modified this->Modified(); } template void MassOfBelief ::RemoveMass(const LabelSetType & labelSet) { // Insert into the mass map m_MassesMap.erase(labelSet); // Call modified this->Modified(); } template typename MassOfBelief ::MassType MassOfBelief ::GetMass(const LabelSetType & labelSet) const { // Look for mass in the table typename MassMapType::const_iterator it = m_MassesMap.find(labelSet); if(it!=m_MassesMap.end()) { return it->second; } else { return itk::NumericTraits::Zero; } } template typename MassOfBelief ::LabelSetOfSetType MassOfBelief ::GetSupport() const { // Build the output LabelSetOfSetType output; // Define an iterator on the mass map typename MassMapType::const_iterator it = m_MassesMap.begin(); // Walk the mass map, gathering the element of the power set while(it != m_MassesMap.end()) { output.insert(it->first); ++it; } // Return return output; } template typename MassOfBelief ::LabelSetType MassOfBelief ::GetUniverse() const { // Build the output LabelSetType output; // Retrieve support set LabelSetOfSetType support = this->GetSupport(); // Walk the support and perform union for(typename LabelSetOfSetType::iterator it = support.begin(); it != support.end(); ++it) { // Temporary set LabelSetType tempSet; std::insert_iterator tmpIt(tempSet, tempSet.begin()); // Perform set union std::set_union(output.begin(), output.end(), it->begin(), it->end(), tmpIt); // swap output and tempSet output.swap(tempSet); } // Return return output; } template void MassOfBelief ::Normalize() { // Sum of masses MassType sum = itk::NumericTraits::Zero; // Compute normalization factor for(typename MassMapType::const_iterator it = m_MassesMap.begin(); it != m_MassesMap.end(); ++it) { sum+=it->second; } // check if sum is not null (maybe use and 1e-xxx) if(sum > 0.0) { // Apply normalization factor for(typename MassMapType::iterator it = m_MassesMap.begin(); it != m_MassesMap.end(); ++it) { it->second/=sum; } // Call modified this->Modified(); } } template void MassOfBelief ::EstimateUncertainty() { // Retrieve the universe of the mass of belief LabelSetType universe = this->GetUniverse(); // Compute the sum of available masses MassType sum = itk::NumericTraits::Zero; // Compute normalization factor for(typename MassMapType::const_iterator it = m_MassesMap.begin(); it != m_MassesMap.end(); ++it) { sum+=it->second; } // Compute uncertainty mass MassType uncertaintyMass = 1 - sum; // Check if uncertainty mass is not negative if(uncertaintyMass > 0) { // Associate uncertainty mass this->SetMass(universe, uncertaintyMass); // Call modified this->Modified(); } } template void MassOfBelief ::Clear() { m_MassesMap.clear(); } template void MassOfBelief ::InitializePowerSetMasses(const LabelSetType & universe) { // Clear any previous mass this->Clear(); // Compute number of elements unsigned long nbElements = 1 << universe.size(); // 2^universe.size() // Build each element for(unsigned long elementId = 1; elementId <= nbElements; ++elementId) { // Instantiate a new element LabelSetType newElement; unsigned long residu = elementId; // Walk the universe set for(typename LabelSetType::const_iterator it = universe.begin(); residu >0 && it!=universe.end(); ++it) { // Retrieve the current bit unsigned long bit = residu%2; // If bit is 1, add the current element from universe to the new set if(bit) { newElement.insert(*it); } // Compute residu residu/=2; } this->SetMass(newElement, itk::NumericTraits::Zero); } } template typename MassOfBelief ::MassType MassOfBelief ::GetBelief(const LabelSetType & labelSet) const { // Retrieve support of mass function LabelSetOfSetType support = this->GetSupport(); // Define an empty set which will contain contained elements of the power-set LabelSetOfSetType containedSet; // Look for elements in the support which are contained in labelSet for(typename LabelSetOfSetType::const_iterator it = support.begin(); it!=support.end(); ++it) { // Temporary set containing intersection LabelSetType intersectionSet; std::insert_iterator interIt(intersectionSet, intersectionSet.begin()); // Perform set union std::set_intersection(labelSet.begin(), labelSet.end(), it->begin(), it->end(), interIt); // If labelSet inter (*it) == (*it), then (*it) is contained // inside labelSet if(intersectionSet == (*it)) { containedSet.insert((*it)); } } // Call the generic implementation return this->GetBelief(containedSet); } template typename MassOfBelief ::MassType MassOfBelief ::GetPlausibility(const LabelSetType & labelSet) const { // Retrieve support of mass function LabelSetOfSetType support = this->GetSupport(); // Define an empty set which will contain contained elements of the power-set LabelSetOfSetType intersectedSet; // Look for elements in the support which are contained in labelSet for(typename LabelSetOfSetType::const_iterator it = support.begin(); it!=support.end(); ++it) { // Temporary set containing intersection LabelSetType intersectionSet; std::insert_iterator interIt(intersectionSet, intersectionSet.begin()); // Perform set intersection std::set_intersection(labelSet.begin(), labelSet.end(), it->begin(), it->end(), interIt); // If labelSet inter (*it) != {}, then (*it) intersects labelSet if(!intersectionSet.empty()) { intersectedSet.insert((*it)); } } // Call the generic implementation return this->GetPlausibility(intersectedSet); } template typename MassOfBelief ::MassType MassOfBelief ::GetBelief(const LabelSetOfSetType & containedLabelSet) const { // Define output MassType belief = itk::NumericTraits::Zero; // Sum masses of contained set for(typename LabelSetOfSetType::const_iterator it = containedLabelSet.begin(); it!=containedLabelSet.end(); ++it) { belief+=this->GetMass((*it)); } // return belief return belief; } template typename MassOfBelief ::MassType MassOfBelief ::GetPlausibility(const LabelSetOfSetType & intersectedLabelSet) const { // Define output MassType plausibility = itk::NumericTraits::Zero; // Sum masses of contained set for(typename LabelSetOfSetType::const_iterator it = intersectedLabelSet.begin(); it!=intersectedLabelSet.end(); ++it) { plausibility+=this->GetMass((*it)); } // return belief return plausibility; } template void MassOfBelief ::Copy(const Self * massOfBelief) { // Swap content of masses maps m_MassesMap = massOfBelief->m_MassesMap; // Call to Modified() this->Modified(); } template bool MassOfBelief ::IsEmpty() const { return m_MassesMap.empty(); } template void MassOfBelief ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); // Display mass of belief universe os << indent << "Mass of belief universe: "; PrintLabelSet(os, this->GetUniverse()); os << std::endl; // Display mass of belief support os << indent << "Mass of belief support: "; PrintLabelSetOfSet(os, this->GetSupport()); os << std::endl; // Display individual masses for(typename MassMapType::const_iterator it = m_MassesMap.begin(); it!=m_MassesMap.end(); ++it) { os<< indent; PrintLabelSet(os, it->first); os << " has mass " << (it->second) << std::endl; } os << indent << "Other masses are null" << std::endl; } template std::ostream & MassOfBelief ::PrintLabelSet(std::ostream & out, const LabelSetType & labelSet) { // Define an iterator on the label set typename LabelSetType::const_iterator it = labelSet.begin(); // Open the set out<<"{"; // Append the set elements while(it != labelSet.end()) { out<<(*it); ++it; if(it != labelSet.end()) out<<", "; } // close the set out<<"}"; // Return return out; } template std::ostream & MassOfBelief ::PrintLabelSetOfSet(std::ostream & out, const LabelSetOfSetType & labelSet) { // Define an iterator on the label set typename LabelSetOfSetType::const_iterator it = labelSet.begin(); // Open the set out<<"{"; // Append the set elements while(it != labelSet.end()) { PrintLabelSet(out, *it); ++it; if(it != labelSet.end()) out<<", "; } // close the set out<<"}"; // Return return out; } } // end namespace otb /** Define the << operator for label sets */ /* template std::ostream & operator<<(std::ostream & out, const std::set & labelSet)*/ #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbStandardDSCostFunction.h000066400000000000000000000141201301006202600303260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStandardDSCostFunction_h #define otbStandardDSCostFunction_h #include "itkSingleValuedCostFunction.h" #include "otbVectorDataToDSValidatedVectorDataFilter.h" namespace otb { /** \class StandardDSCostFunction * \brief Standard Cost Function used to estimate the fuzzy model parameters * in the Dempster-Shafer framework * * This class has been developed to estimate, with the help of the Amoeba * optimizer, the fuzzy model parameters to be used in the class * otb::VectorDataToDSValidatedVectorDataFilter. The cost value compute the * cost according to: * - an enriched ground truth vector data (using VectorDataToRoadDescription) * - an enriched negative sample VectorData or at least random samples * - an hypothesis (the same as the considered DSValidationFilter) * (by default (NONDVI, ROADSA, NOBUIL)) * - a weight between 0 and 1 (0.5 by default) corresponding to the situation * policy regarding under detection/false detection (1 no under detection * 0 no false detection) * For now the cost function use the NONDVI Feature, ROADSA Feature and and * the NOBUIL Feature. * For each evolution of the VectorDataToDSValidatedVectorDataFilter, * this cost function must be adapted. * * \ingroup CostFunction * \sa VectorDataToDSValidatedVectorDataFilter * \sa AmoebaOptimizer * * \ingroup OTBDempsterShafer */ template class ITK_EXPORT StandardDSCostFunction : public itk::SingleValuedCostFunction { public: /** Standard class typedefs. */ typedef StandardDSCostFunction Self; typedef itk::SingleValuedCostFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(StandardDSCostFunction, itk::SingleValuedCostFunction); typedef Superclass::MeasureType MeasureType; //double typedef Superclass::DerivativeType DerivativeType; //Array typedef Superclass::ParametersType ParametersType; //Array typedef TDSValidationFilter DSValidationFilterType; typedef typename DSValidationFilterType::VectorDataType VectorDataType; typedef typename DSValidationFilterType::TreeIteratorType TreeIteratorType; typedef typename DSValidationFilterType::LabelSetType LabelSetType; typedef FuzzyDescriptorsModelManager FuzzyDescriptorsModelManagerType; typedef FuzzyDescriptorsModelManager::DescriptorListType DescriptorListType; typedef FuzzyDescriptorsModelManager::DescriptorsModelType DescriptorsModelType; typedef FuzzyDescriptorsModelManager::PairType PairType; typedef Parser ParserType; /** This method returns the value of the cost function corresponding * to the specified parameters. */ MeasureType GetValue( const ParametersType & parameters ) const ITK_OVERRIDE; /** This method returns the derivative of the cost function corresponding * to the specified parameters. */ void GetDerivative( const ParametersType & parameters, DerivativeType & derivative ) const ITK_OVERRIDE; unsigned int GetNumberOfParameters(void) const ITK_OVERRIDE; itkSetMacro(Weight, double); itkGetConstMacro(Weight, double); itkSetMacro(CriterionFormula, std::string); itkGetConstMacro(CriterionFormula, std::string); void SetDescriptorList(DescriptorListType list) { m_DescriptorList = list; } DescriptorListType GetDescriptorList() { return m_DescriptorList; } itkSetObjectMacro(GTVectorData, VectorDataType); itkGetConstObjectMacro(GTVectorData, VectorDataType); itkSetObjectMacro(NSVectorData, VectorDataType); itkGetConstObjectMacro(NSVectorData, VectorDataType); LabelSetType GetBeliefHypothesis() { return m_BeliefHypothesis; } void SetBeliefHypothesis(LabelSetType hypothesis) { m_BeliefHypothesis = hypothesis; } LabelSetType GetPlausibilityHypothesis() { return m_PlausibilityHypothesis; } void SetPlausibilityHypothesis(LabelSetType hypothesis) { m_PlausibilityHypothesis = hypothesis; } protected: /** Constructor */ StandardDSCostFunction(); /** Destructor */ ~StandardDSCostFunction() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: StandardDSCostFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename VectorDataType::Pointer m_GTVectorData; //Ground Truth typename VectorDataType::Pointer m_NSVectorData; //Negative Samples typename ParserType::Pointer m_Parser; std::string m_CriterionFormula; double m_Weight; //range ]0; 1[ LabelSetType m_BeliefHypothesis; LabelSetType m_PlausibilityHypothesis; DescriptorListType m_DescriptorList; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStandardDSCostFunction.txx" #endif #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbStandardDSCostFunction.txx000066400000000000000000000113731301006202600307310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStandardDSCostFunction_txx #define otbStandardDSCostFunction_txx #include "otbStandardDSCostFunction.h" namespace otb { // Constructor template StandardDSCostFunction ::StandardDSCostFunction() : m_CriterionFormula("((Belief + Plausibility)/2.)"), m_Weight(0.5) { m_GTVectorData = VectorDataType::New(); m_NSVectorData = VectorDataType::New(); m_Parser = ParserType::New(); } template unsigned int StandardDSCostFunction ::GetNumberOfParameters() const { return m_DescriptorList.size()*4; } template typename StandardDSCostFunction ::MeasureType StandardDSCostFunction ::GetValue(const ParametersType & parameters) const { if (parameters.size() != m_DescriptorList.size()*4) { itkExceptionMacro(<< "Wrong model!" ) } //Initialize parser m_Parser->SetExpr(m_CriterionFormula); DescriptorsModelType descModel; for (unsigned int i = 0; i < m_DescriptorList.size(); ++i) { std::vector tmp; for (unsigned int j = 0; j < 4; ++j) { tmp.push_back(parameters[4*i+j]); } PairType pair( m_DescriptorList[i], tmp); descModel.push_back(pair); } typename DSValidationFilterType::Pointer internalFunctionGT = DSValidationFilterType::New(); internalFunctionGT->SetCriterionFormula("1"); internalFunctionGT->SetInput(m_GTVectorData); internalFunctionGT->SetBeliefHypothesis(m_BeliefHypothesis); internalFunctionGT->SetPlausibilityHypothesis(m_PlausibilityHypothesis); try { internalFunctionGT->SetDescriptorModels(descModel); } catch (itk::ExceptionObject /*& err*/) { return 1; } internalFunctionGT->Update(); typename DSValidationFilterType::Pointer internalFunctionNS = DSValidationFilterType::New(); internalFunctionNS->SetCriterionFormula("1"); internalFunctionNS->SetInput(m_NSVectorData); internalFunctionNS->SetBeliefHypothesis(m_BeliefHypothesis); internalFunctionNS->SetBeliefHypothesis(m_PlausibilityHypothesis); try { internalFunctionNS->SetDescriptorModels(descModel); } catch (itk::ExceptionObject &) { return 1; } internalFunctionNS->Update(); double accGT = 0.0; double accNS = 0.0; double nGT = 0.0; double nNS = 0.0; TreeIteratorType itVectorGT(internalFunctionGT->GetOutput()->GetDataTree()); itVectorGT.GoToBegin(); while (!itVectorGT.IsAtEnd()) { if (!itVectorGT.Get()->IsRoot() && !itVectorGT.Get()->IsDocument() && !itVectorGT.Get()->IsFolder()) { double belief = itVectorGT.Get()->GetFieldAsDouble("Belief"); double plausibility = itVectorGT.Get()->GetFieldAsDouble("Plausi"); m_Parser->DefineVar("Belief", &belief); m_Parser->DefineVar("Plausibility", &plausibility); accGT += ((1 - m_Parser->Eval()) * (1 - m_Parser->Eval())); nGT += 1.0; m_Parser->ClearVar(); } itVectorGT++; } TreeIteratorType itVectorNS(internalFunctionNS->GetOutput()->GetDataTree()); itVectorNS.GoToBegin(); while (!itVectorNS.IsAtEnd()) { if (!itVectorNS.Get()->IsRoot() && !itVectorNS.Get()->IsDocument() && !itVectorNS.Get()->IsFolder()) { double belief = itVectorNS.Get()->GetFieldAsDouble("Belief"); double plausibility = itVectorNS.Get()->GetFieldAsDouble("Plausi"); m_Parser->DefineVar("Belief", &belief); m_Parser->DefineVar("Plausibility", &plausibility); accNS += (m_Parser->Eval() * m_Parser->Eval()); nNS += 1.0; m_Parser->ClearVar(); } itVectorNS++; } return (m_Weight * accGT / nGT + (1 - m_Weight) * accNS / nNS); } template void StandardDSCostFunction ::GetDerivative(const ParametersType & itkNotUsed(parameters), DerivativeType & itkNotUsed(derivative)) const { //Not necessary for Amoeba Optimizer itkExceptionMacro(<< "Not Supposed to be used when using Amoeba Optimizer!") } // PrintSelf Method template void StandardDSCostFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } }// end namespace otb #endif OTB-release-5.8/Modules/Learning/DempsterShafer/include/otbVectorDataToDSValidatedVectorDataFilter.h000066400000000000000000000154031301006202600335340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToDSValidatedVectorDataFilter_h #define otbVectorDataToDSValidatedVectorDataFilter_h #include "otbMassOfBelief.h" #include "otbVectorDataToVectorDataFilter.h" #include "itkPreOrderTreeIterator.h" #include "otbVectorData.h" #include "otbFuzzyDescriptorsModelManager.h" #include "otbFuzzyVariable.h" #include "otbJointMassOfBeliefFilter.h" #include "otbParser.h" namespace otb { /** \class VectorDataToDSValidatedVectorDataFilter * \brief VectorData filter validating data nodes using * Dempster-Shafer theory. * * This filter takes as input a vector data containing * features score and validate (or not) each data node * according to these features score, a fuzzy model corresponding * to each feature and a criterion according to the Dempster-Shafer * theory. By default the filter is (for now) parametrized to process * VectorDatas providing by the VectorDataToRoadDescriptionFilter. * The hypothesis must be set using the SetHypothesis method. * The convention is for each feature Fe, a mass of Belief is defined * with two variables named Fe and Fe_. Thus, an hypothesis must declared: * VectorDataToVectorDataFilter::LabelSetType hyp; * hyp.insert("Fe(i)"); * hyp.insert("Fe(j)_"); * hyp.insert("Fe(k)_"); * * Fe(i), Fe(j) and Fe(k) being descriptors. * * The criterion can be set through SetCriterionFormula() as a * string referring to "Belief" and "Plausibility" from the * Dempster-Shafer theory. By default the criterion is: * "((Belief + Plausibility)/2) >= 0.5" * * The considered features will be the intersection between * the features embedded in this filter and the features embedded * in the input vector data. For now, the filter uses "NONDVI" and * "ROADSA" features. * * * \ingroup VectorDataFilter * \sa VectorDataToRoadDescriptionFilter * \sa VectorDataToBuildingDescriptionFilter * * \ingroup OTBDempsterShafer */ template class ITK_EXPORT VectorDataToDSValidatedVectorDataFilter : public otb::VectorDataToVectorDataFilter { public: /** Standard class typedefs. */ typedef VectorDataToDSValidatedVectorDataFilter Self; typedef VectorDataToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToDSValidatedVectorDataFilter, VectorDataToVectorDataFilter); /** Some typedefs. */ typedef TVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointer; typedef typename VectorDataType::DataNodeType DataNodeType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef TPrecision PrecisionType; typedef MassOfBelief MassOfBeliefFunctionType; typedef typename MassOfBeliefFunctionType::LabelSetType LabelSetType; typedef JointMassOfBeliefFilter JointMassOfBeliefFilterType; typedef Parser ParserType; typedef itk::DataObject::Pointer DataObjectPointer; typedef itk::DataObject DataObject; typedef FuzzyVariable FuzzyVarType; typedef FuzzyDescriptorsModelManager::PairType PairType; typedef FuzzyDescriptorsModelManager::DescriptorsModelType DescriptorModelsType; /** Descriptor model accessors. */ virtual void AddDescriptor(const std::string& key, std::vector model); virtual void ClearDescriptors(); void SetDescriptorModels( DescriptorModelsType model ); DescriptorModelsType GetDescriptorModels() { return m_DescriptorModels; } /** Parameter accessors. */ itkGetConstMacro(CriterionFormula, std::string); itkSetMacro(CriterionFormula, std::string); itkGetMacro(CriterionThreshold, double); itkSetMacro(CriterionThreshold, double); LabelSetType GetBeliefHypothesis() { return m_BeliefHypothesis; } void SetBeliefHypothesis(LabelSetType hypothesis) { m_BeliefHypothesis = hypothesis; } LabelSetType GetPlausibilityHypothesis() { return m_PlausibilityHypothesis; } void SetPlausibilityHypothesis(LabelSetType hypothesis) { m_PlausibilityHypothesis = hypothesis; } unsigned int GetNumberOfParameters() { return (m_DescriptorModels.size() * 4); } protected: /** Triggers the Computation */ void GenerateData(void) ITK_OVERRIDE; /** Constructor */ VectorDataToDSValidatedVectorDataFilter(); /** Destructor */ ~VectorDataToDSValidatedVectorDataFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; std::string GetNextID() { std::ostringstream oss; oss << m_CurrentID++; return oss.str(); } private: VectorDataToDSValidatedVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Descriptor bench DescriptorModelsType m_DescriptorModels; std::vector< typename FuzzyVarType::Pointer > m_FuzzyVars; LabelSetType m_Universe, m_BeliefHypothesis, m_PlausibilityHypothesis; double m_Bel, m_Plau; typename ParserType::Pointer m_Parser; std::string m_CriterionFormula; double m_CriterionThreshold; unsigned int m_CurrentID; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToDSValidatedVectorDataFilter.txx" #endif #endif otbVectorDataToDSValidatedVectorDataFilter.txx000066400000000000000000000155031301006202600340520ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/DempsterShafer/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToDSValidatedVectorDataFilter_txx #define otbVectorDataToDSValidatedVectorDataFilter_txx #include "otbVectorDataToDSValidatedVectorDataFilter.h" #include namespace otb { // Constructor template VectorDataToDSValidatedVectorDataFilter ::VectorDataToDSValidatedVectorDataFilter() : m_Bel(0.0), m_Plau(0.0), m_CriterionFormula("((Belief + Plausibility)/2.)"), m_CriterionThreshold(0.5), m_CurrentID(0) { this->SetNumberOfRequiredInputs(1); m_Parser = ParserType::New(); } template void VectorDataToDSValidatedVectorDataFilter ::AddDescriptor(const std::string& key, std::vector model) { bool alreadyExist = false; if (model.size() != 4) { itkExceptionMacro(<< "Wrong model! Size(=" << model.size() << ") > 4" ) } else if (model[0]<0 || model[1]1) { itkExceptionMacro(<< "Wrong model! Values have to be 0<=v1<=v2<=v3<=1" ) } else if (model[3]<.75 || model[3]>1.0) { itkExceptionMacro(<< "Wrong model! Values have to be 0.75<=v4<=1" ) } else { for (unsigned int i=0; i >(key, model)); } } this->Modified(); } template void VectorDataToDSValidatedVectorDataFilter ::ClearDescriptors() { m_DescriptorModels.clear(); } template void VectorDataToDSValidatedVectorDataFilter ::SetDescriptorModels(DescriptorModelsType model) { for (unsigned int i=0; iAddDescriptor(model[i].first, model[i].second); } } template void VectorDataToDSValidatedVectorDataFilter ::GenerateData() { //Initialize Dempster Shafer tools if( m_DescriptorModels.size() == 0 ) { itkExceptionMacro(<< "No defined Descriptor. Please add a descriptor model."); } for (unsigned int i=0; iSetMembership(fuzName, 0.0, 0.0, m_DescriptorModels[i].second[0], m_DescriptorModels[i].second[1], 0.0, m_DescriptorModels[i].second[3]); fuz->SetMembership(fuzName_, m_DescriptorModels[i].second[1], m_DescriptorModels[i].second[2], 1.0, 1.0, 0.0, m_DescriptorModels[i].second[3]); m_FuzzyVars.push_back(fuz); m_Universe.insert(fuzName); m_Universe.insert(fuzName_); } //Initialize parser m_Parser->SetExpr(m_CriterionFormula); m_Parser->DefineVar("Belief", &m_Bel); m_Parser->DefineVar("Plausibility", &m_Plau); // Output this->GetOutput(0)->SetMetaDataDictionary(this->GetInput()->GetMetaDataDictionary()); // Retrieving root node typename DataNodeType::Pointer root = this->GetOutput(0)->GetDataTree()->GetRoot()->Get(); // Create the document node typename DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(document, root); // Create the folder node typename DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree this->GetOutput(0)->GetDataTree()->Add(folder, document); this->GetOutput(0)->SetProjectionRef(this->GetInput()->GetProjectionRef()); TreeIteratorType itVector(this->GetInput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (!itVector.Get()->IsRoot() && !itVector.Get()->IsDocument() && !itVector.Get()->IsFolder()) { typename DataNodeType::Pointer currentGeometry = itVector.Get(); typename JointMassOfBeliefFilterType::Pointer jointMassFilter = JointMassOfBeliefFilterType::New(); for (unsigned int i=0; iHasField(m_DescriptorModels[i].first)) { LabelSetType H, H_; std::string fuzName, fuzName_; fuzName = m_DescriptorModels[i].first; fuzName_ = m_DescriptorModels[i].first + "_"; typename MassOfBeliefFunctionType::Pointer mass = MassOfBeliefFunctionType::New(); mass->InitializePowerSetMasses(m_Universe); H.insert(fuzName); H_.insert(fuzName_); mass->SetMass(H, m_FuzzyVars[i]->GetMembership(fuzName, currentGeometry->GetFieldAsDouble(fuzName))); mass->SetMass(H_, m_FuzzyVars[i]->GetMembership(fuzName_, currentGeometry->GetFieldAsDouble(fuzName))); mass->EstimateUncertainty(); jointMassFilter->PushBackInput(mass); } } jointMassFilter->Update(); m_Bel = jointMassFilter->GetOutput()->GetBelief(m_BeliefHypothesis); m_Plau = jointMassFilter->GetOutput()->GetPlausibility(m_PlausibilityHypothesis); if (m_Parser->Eval() >= m_CriterionThreshold) { currentGeometry->SetNodeId(this->GetNextID()); currentGeometry->SetFieldAsDouble("Belief", m_Bel); currentGeometry->SetFieldAsDouble("Plausi", m_Plau); this->GetOutput(0)->GetDataTree()->Add(currentGeometry, folder); } } ++itVector; } } // PrintSelf Method template void VectorDataToDSValidatedVectorDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/DempsterShafer/otb-module.cmake000066400000000000000000000012311301006202600245470ustar00rootroot00000000000000set(DOCUMENTATION "Data fusion needs a common theoretical framework to manipulate and combine data sources having different natures. The mathematical theory of dempster-Shafer, which is based on belief function and plausible reasoning, can be used for this purpose. This module contains classes related to this theory (see also majority voting module).") otb_module(OTBDempsterShafer DEPENDS OTBVectorDataBase OTBITK OTBImageBase OTBVectorDataManipulation OTBSupervised OTBCommon OTBFuzzy OTBMathParser TEST_DEPENDS OTBVectorDataIO OTBTestKernel OTBImageIO OTBObjectList DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Learning/DempsterShafer/test/000077500000000000000000000000001301006202600224605ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/DempsterShafer/test/CMakeLists.txt000066400000000000000000000332161301006202600252250ustar00rootroot00000000000000otb_module_test() set(OTBDempsterShaferTests otbDempsterShaferTestDriver.cxx otbMassOfBeliefDSApplied.cxx otbConfusionMatrixToMassOfBeliefTest.cxx otbVectorDataToDSValidatedVectorDataFilter.cxx otbDempsterShaferFusionTests.cxx otbDSFusionOfClassifiersImageFilterTest.cxx otbJointMassOfBeliefFilter.cxx otbMassOfBelief.cxx otbStandardDSCostFunction.cxx ) add_executable(otbDempsterShaferTestDriver ${OTBDempsterShaferTests}) target_link_libraries(otbDempsterShaferTestDriver ${OTBDempsterShafer-Test_LIBRARIES}) otb_module_target_label(otbDempsterShaferTestDriver) # Tests Declaration otb_add_test(NAME fzTvMassOfBeliefDSApplied-H1_H2_ COMMAND otbDempsterShaferTestDriver otbMassOfBeliefDSApplied "H1_" "H2_" # here the hypothesis is {H1_, H2_} 0.9 0.9 ) otb_add_test(NAME fzTvMassOfBeliefDSApplied-H1_H2 COMMAND otbDempsterShaferTestDriver otbMassOfBeliefDSApplied "H1_" "H2" # here the hypothesis is {H1_, H2} 0.9 0.9 ) otb_add_test(NAME fzTvMassOfBeliefDSApplied-H1H2 COMMAND otbDempsterShaferTestDriver otbMassOfBeliefDSApplied "H1" # describe the hypothesis "H2" # here the hypothesis is {H1, H2} 0.9 0.9 ) otb_add_test(NAME fzTvMassOfBeliefDSApplied-H1H2_ COMMAND otbDempsterShaferTestDriver otbMassOfBeliefDSApplied "H1" "H2_" # here the hypothesis is {H1, H2_} 0.9 0.9 ) otb_add_test(NAME fzTvConfusionMatrixToMassOfBeliefTestAccuracy COMMAND otbDempsterShaferTestDriver otbConfusionMatrixToMassOfBeliefTest ACCURACY) otb_add_test(NAME fzTuConfusionMatrixToMassOfBeliefNew COMMAND otbDempsterShaferTestDriver otbConfusionMatrixToMassOfBeliefNew) otb_add_test(NAME fzTvConfusionMatrixToMassOfBeliefTestPrecision COMMAND otbDempsterShaferTestDriver otbConfusionMatrixToMassOfBeliefTest PRECISION) otb_add_test(NAME fzTvConfusionMatrixToMassOfBeliefTestKappa COMMAND otbDempsterShaferTestDriver otbConfusionMatrixToMassOfBeliefTest KAPPA) otb_add_test(NAME fzTvConfusionMatrixToMassOfBeliefTestRecall COMMAND otbDempsterShaferTestDriver otbConfusionMatrixToMassOfBeliefTest RECALL) otb_add_test(NAME fzTvVectorDataToDSValidatedVectorDataFilter COMMAND otbDempsterShaferTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/fzTvDSValidatedRoadVectorDataOutput.shp ${TEMP}/fzTvDSValidatedRoadVectorDataOutput.shp otbVectorDataToDSValidatedVectorDataFilter ${TEMP}/fzTvVectorDataToRoadDescriptionFilterOutput.shp ${TEMP}/fzTvDSValidatedRoadVectorDataOutput.shp ) set_property(TEST fzTvVectorDataToDSValidatedVectorDataFilter PROPERTY DEPENDS fzTvVectorDataToRoadDescriptionFilter) otb_add_test(NAME fzTuVectorDataToDSValidatedVectorDataFilterNew COMMAND otbDempsterShaferTestDriver otbVectorDataToDSValidatedVectorDataFilterNew) otb_add_test(NAME fzDSFusionTestConfMatFileVCMTestPrecision COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionConfMatFileTest ${INPUTDATA}/Classification/QB_1_ortho_C1_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C2_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C3_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C4_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C5_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C6_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C7_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C8_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C9_V.csv PRECISION ) otb_add_test(NAME fzDSFusionOptRecTestConfMatFileRCMTestPrecision COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecConfMatFileTest ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv ${INPUTDATA}/Classification/QB_1_ortho_C7.csv ${INPUTDATA}/Classification/QB_1_ortho_C8.csv ${INPUTDATA}/Classification/QB_1_ortho_C9.csv PRECISION) otb_add_test(NAME fzDSFusionTestConfMatFileRCMTestPrecision COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionConfMatFileTest ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv ${INPUTDATA}/Classification/QB_1_ortho_C7.csv ${INPUTDATA}/Classification/QB_1_ortho_C8.csv ${INPUTDATA}/Classification/QB_1_ortho_C9.csv PRECISION ) otb_add_test(NAME fzDSFusionOptRecTestConfMatTestAccuracy COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecConfMatTest ACCURACY) otb_add_test(NAME fzDSFusionTestWithExtraLabels COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionTest a b c d e ) otb_add_test(NAME fzDSFusionOptRecTestConfMatFileVCMTestPrecision COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecConfMatFileTest ${INPUTDATA}/Classification/QB_1_ortho_C1_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C2_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C3_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C4_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C5_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C6_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C7_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C8_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C9_V.csv PRECISION) otb_add_test(NAME fzDSFusionOptRecTestConfMatTestKappa COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecConfMatTest KAPPA) otb_add_test(NAME fzDSFusionOptRecTestConfMatTestPrecision COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecConfMatTest PRECISION) otb_add_test(NAME fzDSFusionOptTestWithExtraLabels COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptTest a b c d e ) otb_add_test(NAME fzDSFusionOptRecTestConfMatTestRecall COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecConfMatTest RECALL) otb_add_test(NAME fzDSFusionOptRecTestSimple COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecTest a b c ) otb_add_test(NAME fzDSFusionOptRecTestWithExtraLabelsBig COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecTest a b c d e f g h i j k l m n o p q r s t u v w x y z ) otb_add_test(NAME fzDSFusionOptTestSimple COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptTest a b c ) otb_add_test(NAME fzDSFusionTestSimple COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionTest a b c ) otb_add_test(NAME fzDSFusionOptRecTestWithExtraLabelsSmall COMMAND otbDempsterShaferTestDriver otbDempsterShaferFusionOptRecTest a b c d e ) otb_add_test(NAME fzTvDSFusionOfClassifiersImageFilter9ClkVCMPrecision COMMAND otbDempsterShaferTestDriver --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_9_Clk_VCM_PRECISION.tif ${TEMP}/QB_1_ortho_DS_FUSED_9_Clk_VCM_PRECISION.tif otbDSFusionOfClassifiersImageFilterTest ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif ${INPUTDATA}/Classification/QB_1_ortho_C7.tif ${INPUTDATA}/Classification/QB_1_ortho_C8.tif ${INPUTDATA}/Classification/QB_1_ortho_C9.tif ${INPUTDATA}/Classification/QB_1_ortho_C1_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C2_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C3_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C4_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C5_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C6_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C7_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C8_V.csv ${INPUTDATA}/Classification/QB_1_ortho_C9_V.csv PRECISION # Method to estimate the Masses of Belief of each label 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels ${TEMP}/QB_1_ortho_DS_FUSED_9_Clk_VCM_PRECISION.tif ) otb_add_test(NAME fzTvDSFusionOfClassifiersImageFilterPrecision COMMAND otbDempsterShaferTestDriver --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_PRECISION.tif ${TEMP}/QB_1_ortho_DS_FUSED_PRECISION.tif otbDSFusionOfClassifiersImageFilterTest ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv PRECISION # Method to estimate the Masses of Belief of each label 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels ${TEMP}/QB_1_ortho_DS_FUSED_PRECISION.tif ) otb_add_test(NAME fzTvDSFusionOfClassifiersImageFilterKappa COMMAND otbDempsterShaferTestDriver --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_KAPPA.tif ${TEMP}/QB_1_ortho_DS_FUSED_KAPPA.tif otbDSFusionOfClassifiersImageFilterTest ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv KAPPA # Method to estimate the Masses of Belief of each label 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels ${TEMP}/QB_1_ortho_DS_FUSED_KAPPA.tif ) otb_add_test(NAME fzTvDSFusionOfClassifiersImageFilter9ClkRCMPrecision COMMAND otbDempsterShaferTestDriver --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_9_Clk_RCM_PRECISION.tif ${TEMP}/QB_1_ortho_DS_FUSED_9_Clk_RCM_PRECISION.tif otbDSFusionOfClassifiersImageFilterTest ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif ${INPUTDATA}/Classification/QB_1_ortho_C7.tif ${INPUTDATA}/Classification/QB_1_ortho_C8.tif ${INPUTDATA}/Classification/QB_1_ortho_C9.tif ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv ${INPUTDATA}/Classification/QB_1_ortho_C7.csv ${INPUTDATA}/Classification/QB_1_ortho_C8.csv ${INPUTDATA}/Classification/QB_1_ortho_C9.csv PRECISION # Method to estimate the Masses of Belief of each label 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels ${TEMP}/QB_1_ortho_DS_FUSED_9_Clk_RCM_PRECISION.tif ) otb_add_test(NAME fzTvDSFusionOfClassifiersImageFilterRecall COMMAND otbDempsterShaferTestDriver --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_RECALL.tif ${TEMP}/QB_1_ortho_DS_FUSED_RECALL.tif otbDSFusionOfClassifiersImageFilterTest ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv RECALL # Method to estimate the Masses of Belief of each label 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels ${TEMP}/QB_1_ortho_DS_FUSED_RECALL.tif ) otb_add_test(NAME fzTuDSFusionOfClassifiersImageFilterNew COMMAND otbDempsterShaferTestDriver otbDSFusionOfClassifiersImageFilterNew) otb_add_test(NAME fzTvDSFusionOfClassifiersImageFilterAccuracy COMMAND otbDempsterShaferTestDriver --compare-image ${NOTOL} ${BASELINE}/QB_1_ortho_DS_FUSED_ACCURACY.tif ${TEMP}/QB_1_ortho_DS_FUSED_ACCURACY.tif otbDSFusionOfClassifiersImageFilterTest ${INPUTDATA}/Classification/QB_1_ortho_C1.tif ${INPUTDATA}/Classification/QB_1_ortho_C2.tif ${INPUTDATA}/Classification/QB_1_ortho_C3.tif ${INPUTDATA}/Classification/QB_1_ortho_C4.tif ${INPUTDATA}/Classification/QB_1_ortho_C5.tif ${INPUTDATA}/Classification/QB_1_ortho_C6.tif ${INPUTDATA}/Classification/QB_1_ortho_C1.csv ${INPUTDATA}/Classification/QB_1_ortho_C2.csv ${INPUTDATA}/Classification/QB_1_ortho_C3.csv ${INPUTDATA}/Classification/QB_1_ortho_C4.csv ${INPUTDATA}/Classification/QB_1_ortho_C5.csv ${INPUTDATA}/Classification/QB_1_ortho_C6.csv ACCURACY # Method to estimate the Masses of Belief of each label 10 #LabelForNoDataPixels 7 #LabelForUndecidedPixels ${TEMP}/QB_1_ortho_DS_FUSED_ACCURACY.tif ) otb_add_test(NAME fzTvJointMassOfBeliefFilterLimit COMMAND otbDempsterShaferTestDriver otbJointMassOfBeliefFilterLimit) otb_add_test(NAME fzTvJointMassOfBeliefFilter COMMAND otbDempsterShaferTestDriver otbJointMassOfBeliefFilter) otb_add_test(NAME fzTvMassOfBelief COMMAND otbDempsterShaferTestDriver otbMassOfBelief) otb_add_test(NAME fzTuStandardDSCostFunctionNew COMMAND otbDempsterShaferTestDriver otbStandardDSCostFunctionNew) OTB-release-5.8/Modules/Learning/DempsterShafer/test/otbConfusionMatrixToMassOfBeliefTest.cxx000066400000000000000000000201471301006202600324300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbConfusionMatrixToMassOfBelief.h" int otbConfusionMatrixToMassOfBeliefNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef int LabelType; // filter types typedef otb::ConfusionMatrixToMassOfBelief ConfusionMatrixToMassOfBelief2TemplatesType; typedef otb::ConfusionMatrixToMassOfBelief ConfusionMatrixToMassOfBelief1TemplateType; typedef otb::ConfusionMatrixToMassOfBelief<> ConfusionMatrixToMassOfBelief0TemplateType; // filters ConfusionMatrixToMassOfBelief2TemplatesType::Pointer confusionMatrixToMassOfBelief2Templates = ConfusionMatrixToMassOfBelief2TemplatesType::New(); ConfusionMatrixToMassOfBelief1TemplateType::Pointer confusionMatrixToMassOfBelief1Template = ConfusionMatrixToMassOfBelief1TemplateType::New(); ConfusionMatrixToMassOfBelief0TemplateType::Pointer confusionMatrixToMassOfBelief0Template = ConfusionMatrixToMassOfBelief0TemplateType::New(); std::cout << confusionMatrixToMassOfBelief2Templates << std::endl; std::cout << std::endl; std::cout << confusionMatrixToMassOfBelief1Template << std::endl; std::cout << std::endl; std::cout << confusionMatrixToMassOfBelief0Template << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } int otbConfusionMatrixToMassOfBeliefTest(int itkNotUsed(argc), char* argv[]) { typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef int LabelType; // filter type typedef otb::ConfusionMatrixToMassOfBelief ConfusionMatrixToMassOfBeliefType; typedef ConfusionMatrixToMassOfBeliefType::MapOfClassesType MapOfClassesType; typedef ConfusionMatrixToMassOfBeliefType::MassOfBeliefDefinitionMethod MassOfBeliefDefinitionMethod; typedef ConfusionMatrixToMassOfBeliefType::LabelMassMapType SingleClassLabelMassMapType; // mapOfClasses[label] = index in the rows/columns of the confusion matrix MapOfClassesType mapOfClasses; mapOfClasses[1] = 0; mapOfClasses[2] = 1; mapOfClasses[3] = 2; mapOfClasses[4] = 3; unsigned int nbClasses = mapOfClasses.size(); ConfusionMatrixType confMat = ConfusionMatrixType(nbClasses, nbClasses); confMat(0, 0) = 1, confMat(0, 1) = 0, confMat(0, 2) = 0, confMat(0, 3) = 2; confMat(1, 0) = 0, confMat(1, 1) = 1, confMat(1, 2) = 1, confMat(1, 3) = 1; confMat(2, 0) = 0, confMat(2, 1) = 0, confMat(2, 2) = 2, confMat(2, 3) = 1; confMat(3, 0) = 0, confMat(3, 1) = 0, confMat(3, 2) = 1, confMat(3, 3) = 2; std::cout << "confusion matrix = " << std::endl << confMat << std::endl; // Converting the Confusion Matrix into a std::map of Masses of Belief for each label ConfusionMatrixToMassOfBeliefType::Pointer confMatToMass = ConfusionMatrixToMassOfBeliefType::New(); MassOfBeliefDefinitionMethod massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; std::string massOfBeliefDefMethodStr = argv[1]; if (massOfBeliefDefMethodStr.compare("PRECISION") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; } else { if (massOfBeliefDefMethodStr.compare("RECALL") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::RECALL; } else { if (massOfBeliefDefMethodStr.compare("ACCURACY") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::ACCURACY; } else { if (massOfBeliefDefMethodStr.compare("KAPPA") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::KAPPA; } } } } confMatToMass->SetConfusionMatrix(confMat); confMatToMass->SetMapOfClasses(mapOfClasses); confMatToMass->SetDefinitionMethod(massOfBeliefDefMethod); confMatToMass->Update(); SingleClassLabelMassMapType mapMOB = confMatToMass->GetMapMassOfBelief(); SingleClassLabelMassMapType::iterator itMapMOB; for (itMapMOB = mapMOB.begin(); itMapMOB != mapMOB.end(); ++itMapMOB) { std::cout << "mapMOB[" << itMapMOB->first << "] = " << itMapMOB->second << std::endl; } //****************************************** // Baselines for the different measurements //****************************************** SingleClassLabelMassMapType mapMOBBLPrecision, mapMOBBLRecall, mapMOBBLAccuracy, mapMOBBLKappa; SingleClassLabelMassMapType::iterator itMapMOBBL; mapMOBBLPrecision[1] = 1; mapMOBBLPrecision[2] = 1; mapMOBBLPrecision[3] = 1.0 / 2.0; mapMOBBLPrecision[4] = 1.0 / 3.0; mapMOBBLRecall[1] = 1.0 / 3.0; mapMOBBLRecall[2] = 1.0 / 3.0; mapMOBBLRecall[3] = 2.0 / 3.0; mapMOBBLRecall[4] = 2.0 / 3.0; mapMOBBLAccuracy[1] = 1.0 / 2.0; mapMOBBLAccuracy[2] = 1.0 / 2.0; mapMOBBLAccuracy[3] = 1.0 / 2.0; mapMOBBLAccuracy[4] = 1.0 / 2.0; mapMOBBLKappa[1] = 1.0 / 3.0; mapMOBBLKappa[2] = 1.0 / 3.0; mapMOBBLKappa[3] = 1.0 / 3.0; mapMOBBLKappa[4] = 1.0 / 3.0; if ((mapMOB != mapMOBBLPrecision) && (massOfBeliefDefMethodStr.compare("PRECISION") == 0)) { std::cout << std::endl; std::cout << "ERROR in Map Mass of Belief Precision" << std::endl; for (itMapMOBBL = mapMOBBLPrecision.begin(), itMapMOB = mapMOB.begin(); itMapMOBBL != mapMOBBLPrecision.end(); ++itMapMOBBL, ++itMapMOB) { std::cout << "mapMOBBLPrecision[" << itMapMOBBL->first << "] = " << itMapMOBBL->second << "; "; std::cout << "mapMOB[" << itMapMOB->first << "] = " << itMapMOB->second << std::endl; } return EXIT_FAILURE; } if ((mapMOB != mapMOBBLRecall) && (massOfBeliefDefMethodStr.compare("RECALL") == 0)) { std::cout << std::endl; std::cout << "ERROR in Map Mass of Belief Recall" << std::endl; for (itMapMOBBL = mapMOBBLRecall.begin(), itMapMOB = mapMOB.begin(); itMapMOBBL != mapMOBBLRecall.end(); ++itMapMOBBL, ++itMapMOB) { std::cout << "mapMOBBLRecall[" << itMapMOBBL->first << "] = " << itMapMOBBL->second << "; "; std::cout << "mapMOB[" << itMapMOB->first << "] = " << itMapMOB->second << std::endl; } return EXIT_FAILURE; } if ((mapMOB != mapMOBBLAccuracy) && (massOfBeliefDefMethodStr.compare("ACCURACY") == 0)) { std::cout << std::endl; std::cout << "ERROR in Map Mass of Belief Accuracy" << std::endl; for (itMapMOBBL = mapMOBBLAccuracy.begin(), itMapMOB = mapMOB.begin(); itMapMOBBL != mapMOBBLAccuracy.end(); ++itMapMOBBL, ++itMapMOB) { std::cout << "mapMOBBLAccuracy[" << itMapMOBBL->first << "] = " << itMapMOBBL->second << "; "; std::cout << "mapMOB[" << itMapMOB->first << "] = " << itMapMOB->second << std::endl; } return EXIT_FAILURE; } if ((mapMOB != mapMOBBLKappa) && (massOfBeliefDefMethodStr.compare("KAPPA") == 0)) { std::cout << std::endl; std::cout << "ERROR in Map Mass of Belief Kappa" << std::endl; for (itMapMOBBL = mapMOBBLKappa.begin(), itMapMOB = mapMOB.begin(); itMapMOBBL != mapMOBBLKappa.end(); ++itMapMOBBL, ++itMapMOB) { std::cout << "mapMOBBLKappa[" << itMapMOBBL->first << "] = " << itMapMOBBL->second << "; "; std::cout << "mapMOB[" << itMapMOB->first << "] = " << itMapMOB->second << std::endl; } return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/DempsterShafer/test/otbDSFusionOfClassifiersImageFilterTest.cxx000066400000000000000000000276411301006202600330430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDSFusionOfClassifiersImageFilter.h" #include "otbImageListToVectorImageFilter.h" #include "otbConfusionMatrixToMassOfBelief.h" #include "otbImageList.h" #include #include "otbImageFileWriter.h" #include typedef unsigned char PixelType; typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef otb::ConfusionMatrixToMassOfBelief ConfusionMatrixToMassOfBeliefType; typedef ConfusionMatrixToMassOfBeliefType::MapOfClassesType MapOfClassesType; int CSVConfusionMatrixFileReader(const std::string fileName, MapOfClassesType &mapOfClassesRefClX, ConfusionMatrixType &confusionMatrixClX) { std::ifstream inFile; inFile.open(fileName.c_str()); if (!inFile) { std::cerr << "Confusion Matrix File opening problem with file:" << std::endl; std::cerr << fileName.c_str() << std::endl; return EXIT_FAILURE; } else { PixelType labelRef = 0, labelProd = 0; std::string currentLine, refLabelsLine, prodLabelsLine, currentValue; const char endCommentChar = ':'; const char separatorChar = ','; const char eolChar = '\n'; std::getline(inFile, refLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, refLabelsLine, eolChar); // Gets the first line after the comment char until the End Of Line char std::getline(inFile, prodLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, prodLabelsLine, eolChar); // Gets the second line after the comment char until the End Of Line char std::istringstream issRefLabelsLine(refLabelsLine); std::istringstream issProdLabelsLine(prodLabelsLine); MapOfClassesType mapOfClassesProdClX; mapOfClassesRefClX.clear(); mapOfClassesProdClX.clear(); int itLab = 0; while (issRefLabelsLine.good()) { std::getline(issRefLabelsLine, currentValue, separatorChar); labelRef = static_cast (std::atoi(currentValue.c_str())); mapOfClassesRefClX[labelRef] = itLab; ++itLab; } itLab = 0; while (issProdLabelsLine.good()) { std::getline(issProdLabelsLine, currentValue, separatorChar); labelProd = static_cast (std::atoi(currentValue.c_str())); mapOfClassesProdClX[labelProd] = itLab; ++itLab; } unsigned int nbRefLabelsClk = mapOfClassesRefClX.size(); unsigned int nbProdLabelsClk = mapOfClassesProdClX.size(); ConfusionMatrixType confusionMatrixClXTemp; confusionMatrixClXTemp = ConfusionMatrixType(nbRefLabelsClk, nbProdLabelsClk); confusionMatrixClXTemp.Fill(0); // Reading the confusion matrix confusionMatrixClXTemp from the file for (unsigned int itRow = 0; itRow < nbRefLabelsClk; ++itRow) { //Gets the itRow^th line after the header lines with the labels std::getline(inFile, currentLine, eolChar); std::istringstream issCurrentLine(currentLine); unsigned int itCol = 0; while (issCurrentLine.good()) { std::getline(issCurrentLine, currentValue, separatorChar); confusionMatrixClXTemp(itRow, itCol) = static_cast (std::atoi(currentValue.c_str())); ++itCol; } } MapOfClassesType::iterator itMapOfClassesRef, itMapOfClassesProd; /*for (itMapOfClassesRef = mapOfClassesRefClX.begin(); itMapOfClassesRef != mapOfClassesRefClX.end(); ++itMapOfClassesRef) { std::cout << "mapOfClassesRefClX[" << itMapOfClassesRef->first << "] = " << itMapOfClassesRef->second << std::endl; } std::cout << std::endl; for (itMapOfClassesProd = mapOfClassesProdClX.begin(); itMapOfClassesProd != mapOfClassesProdClX.end(); ++itMapOfClassesProd) { std::cout << "mapOfClassesProdClX[" << itMapOfClassesProd->first << "] = " << itMapOfClassesProd->second << std::endl; }*/ // Formatting confusionMatrixClX from confusionMatrixClXTemp in order to make confusionMatrixClX a square matrix // from the reference labels in mapOfClassesRefClX int indiceLabelRef = 0, indiceLabelProd = 0; int indiceLabelRefTemp = 0, indiceLabelProdTemp = 0; // Initialization of confusionMatrixClX confusionMatrixClX = ConfusionMatrixType(nbRefLabelsClk, nbRefLabelsClk); confusionMatrixClX.Fill(0); for (itMapOfClassesRef = mapOfClassesRefClX.begin(); itMapOfClassesRef != mapOfClassesRefClX.end(); ++itMapOfClassesRef) { // labels labelRef of mapOfClassesRefClX are already sorted labelRef = itMapOfClassesRef->first; indiceLabelRefTemp = itMapOfClassesRef->second; for (itMapOfClassesProd = mapOfClassesProdClX.begin(); itMapOfClassesProd != mapOfClassesProdClX.end(); ++itMapOfClassesProd) { // labels labelProd of mapOfClassesProdClX are already sorted labelProd = itMapOfClassesProd->first; indiceLabelProdTemp = itMapOfClassesProd->second; // If labelProd is present in mapOfClassesRefClX if (mapOfClassesRefClX.count(labelProd) != 0) { // Indice of labelProd in mapOfClassesRefClX; itMapOfClassesRef->second elements are already SORTED indiceLabelProd = mapOfClassesRefClX[labelProd]; confusionMatrixClX(indiceLabelRef, indiceLabelProd) = confusionMatrixClXTemp(indiceLabelRefTemp, indiceLabelProdTemp); } } ++indiceLabelRef; } //std::cout << "confusionMatrixClXTemp:" << std::endl << confusionMatrixClXTemp << std::endl << std::endl; //std::cout << "confusionMatrixClX:" << std::endl << confusionMatrixClX << std::endl; } inFile.close(); return EXIT_SUCCESS; } int otbDSFusionOfClassifiersImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef otb::VectorImage VectorImageType; typedef otb::Image OutputImageType; typedef otb::Image MaskType; // filter types typedef otb::DSFusionOfClassifiersImageFilter DSFusionOfClassifiersImageFilter3TemplatesType; typedef otb::DSFusionOfClassifiersImageFilter DSFusionOfClassifiersImageFilter2TemplatesType; // filters DSFusionOfClassifiersImageFilter3TemplatesType::Pointer dsFusionOfClassifiersImageFilter3Templates = DSFusionOfClassifiersImageFilter3TemplatesType::New(); DSFusionOfClassifiersImageFilter2TemplatesType::Pointer dsFusionOfClassifiersImageFilter2Templates = DSFusionOfClassifiersImageFilter2TemplatesType::New(); std::cout << dsFusionOfClassifiersImageFilter3Templates << std::endl; std::cout << std::endl; std::cout << dsFusionOfClassifiersImageFilter2Templates << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } int otbDSFusionOfClassifiersImageFilterTest(int argc, char* argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage VectorImageType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageList ImageListType; ImageListType::Pointer imageList = ImageListType::New(); typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader; typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); typedef ConfusionMatrixToMassOfBeliefType::MassOfBeliefDefinitionMethod MassOfBeliefDefinitionMethod; typedef otb::DSFusionOfClassifiersImageFilter DSFusionOfClassifiersImageFilterType; typedef DSFusionOfClassifiersImageFilterType::VectorOfMapOfMassesOfBeliefType VectorOfMapOfMassesOfBeliefType; DSFusionOfClassifiersImageFilterType::Pointer dsFusionOfClassifiersImageFilter = DSFusionOfClassifiersImageFilterType::New(); unsigned int nbParameters = 4; unsigned int nbClassifiers = (argc - 1 - nbParameters) / 2; std::string massOfBeliefDefMethodStr = argv[argc - 4]; MassOfBeliefDefinitionMethod massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; if (massOfBeliefDefMethodStr.compare("PRECISION") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; } else { if (massOfBeliefDefMethodStr.compare("RECALL") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::RECALL; } else { if (massOfBeliefDefMethodStr.compare("ACCURACY") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::ACCURACY; } else { if (massOfBeliefDefMethodStr.compare("KAPPA") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::KAPPA; } } } } ConfusionMatrixToMassOfBeliefType::Pointer confusionMatrixToMassOfBeliefFilter = ConfusionMatrixToMassOfBeliefType::New(); VectorOfMapOfMassesOfBeliefType vectorOfMapOfMassesOfBelief; for (unsigned int itCM = 0; itCM < nbClassifiers; ++itCM) { std::string fileNameClassifiedImage = argv[itCM + 1]; std::string fileNameConfMat = argv[itCM + 1 + nbClassifiers]; reader = ReaderType::New(); reader->SetFileName(fileNameClassifiedImage); reader->Update(); imageList->PushBack(reader->GetOutput()); MapOfClassesType mapOfClassesClk; ConfusionMatrixType confusionMatrixClk; CSVConfusionMatrixFileReader(fileNameConfMat, mapOfClassesClk, confusionMatrixClk); confusionMatrixToMassOfBeliefFilter->SetMapOfClasses(mapOfClassesClk); confusionMatrixToMassOfBeliefFilter->SetConfusionMatrix(confusionMatrixClk); confusionMatrixToMassOfBeliefFilter->SetDefinitionMethod(massOfBeliefDefMethod); confusionMatrixToMassOfBeliefFilter->Update(); // Vector containing ALL the K (= nbClassifiers) std::map of Masses of Belief vectorOfMapOfMassesOfBelief.push_back(confusionMatrixToMassOfBeliefFilter->GetMapMassOfBelief()); } // ********************************************** // Image List To VectorImage // ********************************************** ImageListToVectorImageFilterType::Pointer imageListToVectorImageFilter = ImageListToVectorImageFilterType::New(); imageListToVectorImageFilter->SetInput(imageList); //imageListToVectorImageFilter->Update(); // DSFusionOfClassifiersImageFilter Inputs dsFusionOfClassifiersImageFilter->SetInput(imageListToVectorImageFilter->GetOutput()); dsFusionOfClassifiersImageFilter->SetInputMapsOfMassesOfBelief(&vectorOfMapOfMassesOfBelief); dsFusionOfClassifiersImageFilter->SetLabelForNoDataPixels(atoi(argv[argc - 3])); dsFusionOfClassifiersImageFilter->SetLabelForUndecidedPixels(atoi(argv[argc - 2])); //dsFusionOfClassifiersImageFilter->Update(); std::string fileNameFusedImage = argv[argc - 1]; writer->SetFileName(fileNameFusedImage); writer->SetInput(dsFusionOfClassifiersImageFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/DempsterShafer/test/otbDempsterShaferFusionTests.cxx000066400000000000000000002700431301006202600310420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMassOfBelief.h" #include "otbJointMassOfBeliefFilter.h" #include "otbConfusionMatrixToMassOfBelief.h" #include // STRING LABELS typedef std::string LabelPixelType; typedef otb::MassOfBelief MassOfBeliefFunctionType; typedef MassOfBeliefFunctionType::MassMapType MassMapType; typedef otb::JointMassOfBeliefFilter JointMassOfBeliefFilterType; // INT LABELS typedef int IntLabelPixelType; typedef otb::MassOfBelief IntMassOfBeliefFunctionType; typedef IntMassOfBeliefFunctionType::MassMapType IntMassMapType; typedef otb::JointMassOfBeliefFilter IntJointMassOfBeliefFilterType; typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef otb::ConfusionMatrixToMassOfBelief ConfusionMatrixToMassOfBeliefType; typedef ConfusionMatrixToMassOfBeliefType::MapOfClassesType MapOfClassesType; typedef ConfusionMatrixToMassOfBeliefType::MapOfIndicesType MapOfIndicesType; typedef ConfusionMatrixToMassOfBeliefType::MassOfBeliefDefinitionMethod MassOfBeliefDefinitionMethod; typedef ConfusionMatrixToMassOfBeliefType::MassType MassType; //double by default typedef ConfusionMatrixToMassOfBeliefType::LabelMassMapType SingleClassLabelMassMapType; typedef std::map ClassifierHistogramType; //Function to display MassOfBeliefFunctionType::LabelSetType instances with the "<<" operator std::ostream& operator <<(std::ostream& os, const MassOfBeliefFunctionType::LabelSetType& l) { MassOfBeliefFunctionType::PrintLabelSet(os, l); return os; } //Function to display IntMassOfBeliefFunctionType::LabelSetType instances with the "<<" operator std::ostream& operator <<(std::ostream& os, const IntMassOfBeliefFunctionType::LabelSetType& l) { IntMassOfBeliefFunctionType::PrintLabelSet(os, l); return os; } int CSVConfusionMatrixFileReader(const std::string fileName, MapOfClassesType &mapOfClassesRefClX, ConfusionMatrixType &confusionMatrixClX) { std::ifstream inFile; inFile.open(fileName.c_str()); if (!inFile) { std::cerr << "Confusion Matrix File opening problem with file:" << std::endl; std::cerr << fileName.c_str() << std::endl; return EXIT_FAILURE; } else { IntLabelPixelType labelRef = 0, labelProd = 0; std::string currentLine, refLabelsLine, prodLabelsLine, currentValue; const char endCommentChar = ':'; const char separatorChar = ','; const char eolChar = '\n'; std::getline(inFile, refLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, refLabelsLine, eolChar); // Gets the first line after the comment char until the End Of Line char std::getline(inFile, prodLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, prodLabelsLine, eolChar); // Gets the second line after the comment char until the End Of Line char std::istringstream issRefLabelsLine(refLabelsLine); std::istringstream issProdLabelsLine(prodLabelsLine); MapOfClassesType mapOfClassesProdClX; mapOfClassesRefClX.clear(); mapOfClassesProdClX.clear(); int itLab = 0; while (issRefLabelsLine.good()) { std::getline(issRefLabelsLine, currentValue, separatorChar); labelRef = static_cast (std::atoi(currentValue.c_str())); mapOfClassesRefClX[labelRef] = itLab; ++itLab; } itLab = 0; while (issProdLabelsLine.good()) { std::getline(issProdLabelsLine, currentValue, separatorChar); labelProd = static_cast (std::atoi(currentValue.c_str())); mapOfClassesProdClX[labelProd] = itLab; ++itLab; } unsigned int nbRefLabelsClk = mapOfClassesRefClX.size(); unsigned int nbProdLabelsClk = mapOfClassesProdClX.size(); ConfusionMatrixType confusionMatrixClXTemp; confusionMatrixClXTemp = ConfusionMatrixType(nbRefLabelsClk, nbProdLabelsClk); confusionMatrixClXTemp.Fill(0); // Reading the confusion matrix confusionMatrixClXTemp from the file for (unsigned int itRow = 0; itRow < nbRefLabelsClk; ++itRow) { //Gets the itRow^th line after the header lines with the labels std::getline(inFile, currentLine, eolChar); std::istringstream issCurrentLine(currentLine); unsigned int itCol = 0; while (issCurrentLine.good()) { std::getline(issCurrentLine, currentValue, separatorChar); confusionMatrixClXTemp(itRow, itCol) = static_cast (std::atoi(currentValue.c_str())); ++itCol; } } MapOfClassesType::iterator itMapOfClassesRef, itMapOfClassesProd; /*for (itMapOfClassesRef = mapOfClassesRefClX.begin(); itMapOfClassesRef != mapOfClassesRefClX.end(); ++itMapOfClassesRef) { std::cout << "mapOfClassesRefClX[" << itMapOfClassesRef->first << "] = " << itMapOfClassesRef->second << std::endl; } std::cout << std::endl; for (itMapOfClassesProd = mapOfClassesProdClX.begin(); itMapOfClassesProd != mapOfClassesProdClX.end(); ++itMapOfClassesProd) { std::cout << "mapOfClassesProdClX[" << itMapOfClassesProd->first << "] = " << itMapOfClassesProd->second << std::endl; }*/ // Formatting confusionMatrixClX from confusionMatrixClXTemp in order to make confusionMatrixClX a square matrix // from the reference labels in mapOfClassesRefClX int indiceLabelRef = 0, indiceLabelProd = 0; int indiceLabelRefTemp = 0, indiceLabelProdTemp = 0; // Initialization of confusionMatrixClX confusionMatrixClX = ConfusionMatrixType(nbRefLabelsClk, nbRefLabelsClk); confusionMatrixClX.Fill(0); for (itMapOfClassesRef = mapOfClassesRefClX.begin(); itMapOfClassesRef != mapOfClassesRefClX.end(); ++itMapOfClassesRef) { // labels labelRef of mapOfClassesRefClX are already sorted labelRef = itMapOfClassesRef->first; indiceLabelRefTemp = itMapOfClassesRef->second; for (itMapOfClassesProd = mapOfClassesProdClX.begin(); itMapOfClassesProd != mapOfClassesProdClX.end(); ++itMapOfClassesProd) { // labels labelProd of mapOfClassesProdClX are already sorted labelProd = itMapOfClassesProd->first; indiceLabelProdTemp = itMapOfClassesProd->second; // If labelProd is present in mapOfClassesRefClX if (mapOfClassesRefClX.count(labelProd) != 0) { // Indice of labelProd in mapOfClassesRefClX; itMapOfClassesRef->second elements are already SORTED indiceLabelProd = mapOfClassesRefClX[labelProd]; confusionMatrixClX(indiceLabelRef, indiceLabelProd) = confusionMatrixClXTemp(indiceLabelRefTemp, indiceLabelProdTemp); } } ++indiceLabelRef; } //std::cout << "confusionMatrixClXTemp:" << std::endl << confusionMatrixClXTemp << std::endl << std::endl; //std::cout << "confusionMatrixClX:" << std::endl << confusionMatrixClX << std::endl; } inFile.close(); return EXIT_SUCCESS; } // OPTIMIZED RECURSIVE DS FUSION WITH CONFUSION MATRICES int otbDempsterShaferFusionOptRecConfMatTest(int itkNotUsed(argc), char * argv[]) { unsigned int nbClassifiers = 6; IntLabelPixelType undefinedValue = 0; // mapOfClasses[label] = index in the rows/columns of the confusion matrix MapOfIndicesType mapOfIndicesCl0, mapOfIndicesCl1, mapOfIndicesCl2, mapOfIndicesCl3, mapOfIndicesCl4, mapOfIndicesCl5; /* ***************************************************************************************** */ /* ***************** Expected to be read from input confusion matrix files ***************** */ /* ***************************************************************************************** */ ConfusionMatrixType confMatCl0 = ConfusionMatrixType(4, 4); ConfusionMatrixType confMatCl1 = ConfusionMatrixType(3, 3); ConfusionMatrixType confMatCl2 = ConfusionMatrixType(4, 4); ConfusionMatrixType confMatCl3 = ConfusionMatrixType(5, 5); ConfusionMatrixType confMatCl4 = ConfusionMatrixType(4, 4); ConfusionMatrixType confMatCl5 = ConfusionMatrixType(2, 2); mapOfIndicesCl0[0] = 1, mapOfIndicesCl0[1] = 2, mapOfIndicesCl0[2] = 3, mapOfIndicesCl0[3] = 4; confMatCl0(0, 0) = 100, confMatCl0(0, 1) = 0, confMatCl0(0, 2) = 12, confMatCl0(0, 3) = 200; confMatCl0(1, 0) = 0, confMatCl0(1, 1) = 100, confMatCl0(1, 2) = 100, confMatCl0(1, 3) = 100; confMatCl0(2, 0) = 452, confMatCl0(2, 1) = 20, confMatCl0(2, 2) = 200, confMatCl0(2, 3) = 100; confMatCl0(3, 0) = 0, confMatCl0(3, 1) = 0, confMatCl0(3, 2) = 100, confMatCl0(3, 3) = 200; ; mapOfIndicesCl1[0] = 3, mapOfIndicesCl1[1] = 4, mapOfIndicesCl1[2] = 5; confMatCl1(0, 0) = 128, confMatCl1(0, 1) = 256, confMatCl1(0, 2) = 0; confMatCl1(1, 0) = 42, confMatCl1(1, 1) = 1500, confMatCl1(1, 2) = 1; confMatCl1(2, 0) = 0, confMatCl1(2, 1) = 15, confMatCl1(2, 2) = 1200; mapOfIndicesCl2[0] = 1, mapOfIndicesCl2[1] = 2, mapOfIndicesCl2[2] = 3, mapOfIndicesCl2[3] = 4; confMatCl2(0, 0) = 1000, confMatCl2(0, 1) = 0, confMatCl2(0, 2) = 51, confMatCl2(0, 3) = 22; confMatCl2(1, 0) = 0, confMatCl2(1, 1) = 2000, confMatCl2(1, 2) = 1, confMatCl2(1, 3) = 11; confMatCl2(2, 0) = 0, confMatCl2(2, 1) = 0, confMatCl2(2, 2) = 3000, confMatCl2(2, 3) = 154; confMatCl2(3, 0) = 14, confMatCl2(3, 1) = 125, confMatCl2(3, 2) = 0, confMatCl2(3, 3) = 4000; mapOfIndicesCl3[0] = 2, mapOfIndicesCl3[1] = 10, mapOfIndicesCl3[2] = 15, mapOfIndicesCl3[3] = 20, mapOfIndicesCl3[4] = 4; confMatCl3(0, 0) = 18500, confMatCl3(0, 1) = 15, confMatCl3(0, 2) = 20, confMatCl3(0, 3) = 126, confMatCl3(0, 4) = 40; confMatCl3(1, 0) = 0, confMatCl3(1, 1) = 15464, confMatCl3(1, 2) = 0, confMatCl3(1, 3) = 15, confMatCl3(1, 4) = 0; confMatCl3(2, 0) = 0, confMatCl3(2, 1) = 0, confMatCl3(2, 2) = 20000, confMatCl3(2, 3) = 0, confMatCl3(2, 4) = 32; confMatCl3(3, 0) = 23, confMatCl3(3, 1) = 0, confMatCl3(3, 2) = 14, confMatCl3(3, 3) = 2565, confMatCl3(3, 4) = 123; confMatCl3(4, 0) = 23, confMatCl3(4, 1) = 0, confMatCl3(4, 2) = 14, confMatCl3(4, 3) = 2565, confMatCl3(4, 4) = 87462; mapOfIndicesCl4[0] = 1, mapOfIndicesCl4[1] = 7, mapOfIndicesCl4[2] = 4, mapOfIndicesCl4[3] = 2; confMatCl4(0, 0) = 5054, confMatCl4(0, 1) = 2, confMatCl4(0, 2) = 0, confMatCl4(0, 3) = 20; confMatCl4(1, 0) = 0, confMatCl4(1, 1) = 1235, confMatCl4(1, 2) = 1, confMatCl4(1, 3) = 0; confMatCl4(2, 0) = 456, confMatCl4(2, 1) = 123, confMatCl4(2, 2) = 64984, confMatCl4(2, 3) = 0; confMatCl4(3, 0) = 0, confMatCl4(3, 1) = 0, confMatCl4(3, 2) = 45, confMatCl4(3, 3) = 3230; mapOfIndicesCl5[0] = 2, mapOfIndicesCl5[1] = 4; confMatCl5(0, 0) = 8458, confMatCl5(0, 1) = 45; confMatCl5(1, 0) = 564, confMatCl5(1, 1) = 32121; /* ***************************************************************************************** */ /* ***************************************************************************************** */ /* ***************************************************************************************** */ // Manipulating the Confusion Matrices and Maps Of Indices for each classifier Clk std::vector vectorOfMapOfIndices; vectorOfMapOfIndices.push_back(mapOfIndicesCl0), vectorOfMapOfIndices.push_back(mapOfIndicesCl1); vectorOfMapOfIndices.push_back(mapOfIndicesCl2), vectorOfMapOfIndices.push_back(mapOfIndicesCl3); vectorOfMapOfIndices.push_back(mapOfIndicesCl4), vectorOfMapOfIndices.push_back(mapOfIndicesCl5); std::vector vectorOfConfMatrices; vectorOfConfMatrices.push_back(confMatCl0), vectorOfConfMatrices.push_back(confMatCl1); vectorOfConfMatrices.push_back(confMatCl2), vectorOfConfMatrices.push_back(confMatCl3); vectorOfConfMatrices.push_back(confMatCl4), vectorOfConfMatrices.push_back(confMatCl5); /* ***************************************************************************************** */ /* ***************************************************************************************** */ // Converting the Confusion Matrix into a std::map of Masses of Belief for each label ConfusionMatrixToMassOfBeliefType::Pointer confMatToMass = ConfusionMatrixToMassOfBeliefType::New(); MassOfBeliefDefinitionMethod massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; std::string massOfBeliefDefMethodStr = argv[1]; if (massOfBeliefDefMethodStr.compare("PRECISION") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; } else { if (massOfBeliefDefMethodStr.compare("RECALL") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::RECALL; } else { if (massOfBeliefDefMethodStr.compare("ACCURACY") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::ACCURACY; } else { if (massOfBeliefDefMethodStr.compare("KAPPA") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::KAPPA; } } } } confMatToMass->SetDefinitionMethod(massOfBeliefDefMethod); /* ***************************************************************************************** */ /* *** Extraction of the K maps of Masses of Belief (one map of MOBs for each classifier) ** */ /* ***************************************************************************************** */ // Masses of the singleton sets {Ai} for each classifier. // These masses represent the degree of belief of each classifier that the output class of the pixel X // is {Ai} when the input pixel X actually belongs to the class {Ai} unsigned int nbClassesClk; MapOfIndicesType mapOfIndicesClk; ConfusionMatrixType confMatClk; MassType mobUniverseClk; SingleClassLabelMassMapType mapMOBClk; SingleClassLabelMassMapType::iterator itMapMOBClk; ClassifierHistogramType universe; ClassifierHistogramType::iterator itUniverse; std::vector vectorMapMOBs; std::vector vectorUniverseMOBs; for (unsigned int itClk = 0; itClk < nbClassifiers; ++itClk) { // Classifier Cl_k: mapOfIndicesClk = vectorOfMapOfIndices[itClk]; confMatClk = vectorOfConfMatrices[itClk]; nbClassesClk = mapOfIndicesClk.size(); // mobUniverseClk is set to zero in order to assure the correct estimation of the Belief Functions of the // complementary sets bel({Ai_}) in the optimized DS combination mobUniverseClk = 0.; confMatToMass->SetMapOfIndices(mapOfIndicesClk); confMatToMass->SetConfusionMatrix(confMatClk); confMatToMass->Update(); mapMOBClk.clear(); mapMOBClk = confMatToMass->GetMapMassOfBelief(); // Vector containing ALL the K std::maps of Mass of Belief vectorMapMOBs.push_back(mapMOBClk); // Vector containing the Mass of Belief of the universe for each classifier vectorUniverseMOBs.push_back(mobUniverseClk); std::cout << "confusion matrix[Cl_" << itClk << "] = " << std::endl; for (unsigned int itLabel = 0; itLabel < nbClassesClk; ++itLabel) { IntLabelPixelType classLabel = mapOfIndicesClk[itLabel]; std::cout << "[" << classLabel << "] "; // If the current classLabel has already been added to the universe if (universe.count(classLabel) > 0) { universe[classLabel]++; } else { universe[classLabel] = 1; } } std::cout << std::endl << confMatClk << std::endl; std::cout << std::endl; for (itMapMOBClk = mapMOBClk.begin(); itMapMOBClk != mapMOBClk.end(); ++itMapMOBClk) { std::cout << "mapMOBCl_" << itClk << "[" << itMapMOBClk->first << "] = " << itMapMOBClk->second << std::endl; } std::cout << "*******************************************************************************" << std::endl; } // Number of classes in the universe unsigned int nbClasses = universe.size(); std::cout << "universe:" << std::endl; for (itUniverse = universe.begin(); itUniverse != universe.end(); ++itUniverse) { std::cout << "Class Label " << itUniverse->first; std::cout << " present in " << itUniverse->second << " classifier(s)" << std::endl; } std::cout << std::endl; /* ***************************************************************************************** */ /* ************************ RESULTS OF THE CLASSIFICATION OF PIXEL X *********************** */ /* ***************************************************************************************** */ // Values (as IntLabelPixelType) of the K CLASSIFICATION MAPS for the pixel X std::vector classifiedPixelX; classifiedPixelX.push_back(2); classifiedPixelX.push_back(4); classifiedPixelX.push_back(4); classifiedPixelX.push_back(15); classifiedPixelX.push_back(7); classifiedPixelX.push_back(2); /* ***************************************************************************************** */ /* *************************************** DS STEP #1 ************************************** */ /* ***************************************************************************************** */ IntLabelPixelType classLabelk; MassType mLabelSetClk, mLabelSetClk_, mUniverseClk; MassType mLabelSetClkprev, mLabelSetClkprev_, mUniverseClkprev; MassType KClk, mLabelSetClkNew, mLabelSetClkNew_, mUniverseClkNew; SingleClassLabelMassMapType mapJointMassesStepI, mapJointMassesStepI_, mapJointMassesUniverseStepI; // Extracting the masses m(Ai), m(Ai_) and m(OMEGA) for each of the K = 6 classifiers // and grouping them according to the {Ai} singletons // (ex: mg(A), mg(B), mg(C),..., with mg(Ai) the joint mass of the masses of classifiers with result Ai for pixel X) for (unsigned int itClk = 0; itClk < nbClassifiers; ++itClk) { classLabelk = classifiedPixelX[itClk]; // Setting the masses of the three focal elements {Ai}, {Ai_} and OMEGA = {Ai U Ai_} // Extraction of mk({Ai}) = mLabelClk of the classifier k for the labelSetClk = {Ai} mUniverseClk = vectorUniverseMOBs[itClk]; mLabelSetClk = vectorMapMOBs[itClk][classLabelk]; mLabelSetClk_ = 1 - mLabelSetClk - mUniverseClk; std::cout << "classifiedPixelX[" << itClk << "] = " << classLabelk; std::cout << "; MassOfBelief_Cl_" << itClk << "[" << classLabelk << "] = " << mLabelSetClk; std::cout << std::endl; // The first time the label {Ai} is found in classifiedPixelX if (mapJointMassesStepI.count(classLabelk) == 0) { mLabelSetClkNew = mLabelSetClk; mLabelSetClkNew_ = mLabelSetClk_; mUniverseClkNew = mUniverseClk; } else { mLabelSetClkprev = mapJointMassesStepI[classLabelk]; mLabelSetClkprev_ = mapJointMassesStepI_[classLabelk]; mUniverseClkprev = mapJointMassesUniverseStepI[classLabelk]; KClk = 1 / (1 - mLabelSetClkprev * mLabelSetClk_ - mLabelSetClkprev_ * mLabelSetClk); mLabelSetClkNew = KClk * (mLabelSetClkprev * (mLabelSetClk + mUniverseClk) + mUniverseClkprev * mLabelSetClk); mLabelSetClkNew_ = KClk * (mLabelSetClkprev_ * (mLabelSetClk_ + mUniverseClk) + mUniverseClkprev * mLabelSetClk_); mUniverseClkNew = KClk * mUniverseClkprev * mUniverseClk; } mapJointMassesStepI[classLabelk] = mLabelSetClkNew; mapJointMassesStepI_[classLabelk] = mLabelSetClkNew_; mapJointMassesUniverseStepI[classLabelk] = mUniverseClkNew; } std::cout << "*******************************************************************************" << std::endl; std::cout << std::endl; /* ***************************************************************************************** */ /* *************************************** DS STEP #2 ************************************** */ /* ***************************************************************************************** */ // Calculation of the four A, B, C and K constants MassType A = 0, B = 1, C = 1, K = 0; for (itMapMOBClk = mapJointMassesStepI.begin(); itMapMOBClk != mapJointMassesStepI.end(); ++itMapMOBClk) { classLabelk = itMapMOBClk->first; mLabelSetClk = mapJointMassesStepI[classLabelk]; mLabelSetClk_ = mapJointMassesStepI_[classLabelk]; mUniverseClk = mapJointMassesUniverseStepI[classLabelk]; A = A + (mLabelSetClk / (1 - mLabelSetClk)); B = B * (1 - mLabelSetClk); C = C * mLabelSetClk_; std::cout << "****************************************" << std::endl; std::cout << "mapJointMassesStepI[" << classLabelk << "] = " << mLabelSetClk << std::endl; std::cout << "mapJointMassesStepI_[" << classLabelk << "] = " << mLabelSetClk_ << std::endl; std::cout << "mapJointMassesUniverseStepI[" << classLabelk << "] = " << mUniverseClk << std::endl; } unsigned int nbClkGroupsStepI = mapJointMassesStepI.size(); if (nbClkGroupsStepI == nbClasses) { K = 1 / ((1 + A) * B - C); } else { if (nbClkGroupsStepI < nbClasses) { K = 1 / ((1 + A) * B); } } std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "nbClasses = " << nbClasses << std::endl; std::cout << "nbClassifiers = " << nbClassifiers << std::endl; std::cout << "nbClkGroupsStepI = " << nbClkGroupsStepI << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; // Calculation of the Belief function of each singleton {Ai} and {Ai_} SingleClassLabelMassMapType mapBelStepII, mapBelStepII_; MassType belLabelSetClk, belLabelSetClk_, addBelLabelSetClk = 0.; for (itMapMOBClk = mapJointMassesStepI.begin(); itMapMOBClk != mapJointMassesStepI.end(); ++itMapMOBClk) { classLabelk = itMapMOBClk->first; // Joint Masses AFTER STEP I (one mass per singleton {Ai}) mLabelSetClk = mapJointMassesStepI[classLabelk]; mLabelSetClk_ = mapJointMassesStepI_[classLabelk]; mUniverseClk = mapJointMassesUniverseStepI[classLabelk]; // Bel(Ai) if ((nbClkGroupsStepI == nbClasses) || ((nbClkGroupsStepI == (nbClasses - 1)) && (K == nbClasses))) { belLabelSetClk = K * ((mLabelSetClk / (1 - mLabelSetClk)) * B + (mUniverseClk * C / mLabelSetClk_)); } else { belLabelSetClk = K * (mLabelSetClk / (1 - mLabelSetClk)) * B; } // Bel(Ai_) belLabelSetClk_ = 1 - belLabelSetClk; /*if (nbClkGroupsStepI == nbClasses) { belLabelSetClk_ = K * ((A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B - C); } else { if ((nbClkGroupsStepI < nbClasses) && (K <= nbClkGroupsStepI)) { belLabelSetClk_ = K * (A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B; } else { belLabelSetClk_ = K * (A - (mLabelSetClk / (1 - mLabelSetClk))) * B; } }*/ mapBelStepII[classLabelk] = belLabelSetClk; mapBelStepII_[classLabelk] = belLabelSetClk_; addBelLabelSetClk += belLabelSetClk; } std::cout << "****************************************************************************" << std::endl; /* ***************************************************************************************** */ /* ************************************ DECISION PROCESS *********************************** */ /* ***************************************************************************************** */ // The decision for the DS Fusion is made with the MAXIMAL Belief function: // {Ai} is chosen if Bel({Ai}) = MAX(Bel({Aj})) IntLabelPixelType fusedDSLabelSet = 0; MassType fusedDSBelLabelSetClk = 0.; //Here the MAX of Bel(Ai) for (itUniverse = universe.begin(); itUniverse != universe.end(); ++itUniverse) { classLabelk = itUniverse->first; /* // In order to handle the other sets {Aj} of the universe which are NOT present in classifiedPixelX // ONLY correct if ALL the K classifiers have m(universe) = mUniverseClk = 0 mapBelStepII_[classLabelk] += (1 - addBelLabelSetClk); */ if (itUniverse == universe.begin()) { fusedDSLabelSet = classLabelk; fusedDSBelLabelSetClk = mapBelStepII[classLabelk]; } else { if (mapBelStepII[classLabelk] >= fusedDSBelLabelSetClk) { fusedDSLabelSet = classLabelk; fusedDSBelLabelSetClk = mapBelStepII[classLabelk]; } } // For labels {Ai} of the universe which are NOT present in classifiedPixelX, // the Bel({Ai_}) = SUM(m_stepII({Aj})) = SUM(Bel({Aj})) here; with {Aj} ALL labels present in classifiedPixelX if (mapBelStepII[classLabelk] == 0) { mapBelStepII_[classLabelk] = addBelLabelSetClk; } std::cout << "Bel(" << classLabelk << ") = " << mapBelStepII[classLabelk] << std::endl; std::cout << "Bel(NOT_" << classLabelk << ") = " << mapBelStepII_[classLabelk] << std::endl; std::cout << std::endl; } // If the DS VOTED LABEL is NOT unique, the result of the DS Fusion is undefinedValue for (itUniverse = universe.begin(); itUniverse != universe.end(); ++itUniverse) { classLabelk = itUniverse->first; if ((mapBelStepII[classLabelk] == fusedDSBelLabelSetClk) && (classLabelk != fusedDSLabelSet)) { fusedDSLabelSet = undefinedValue; } } std::cout << "****************************************************************************" << std::endl; std::cout << "fusedDSLabelSet = " << fusedDSLabelSet << std::endl; std::cout << "fusedDSBelLabelSetClk = " << fusedDSBelLabelSetClk << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // OPTIMIZED RECURSIVE DS FUSION int otbDempsterShaferFusionOptRecTest(int argc, char * argv[]) { //***************************** // For DEBUG PURPOSE ONLY unsigned int nbClassesMax = 6; //***************************** std::vector vectorAllLabels; unsigned int nbArgs = static_cast (argc); for (unsigned int it = 1; it < nbArgs; ++it) { vectorAllLabels.push_back(argv[it]); } unsigned int nbClasses = vectorAllLabels.size(); MassOfBeliefFunctionType::LabelSetType universe, labelSet; typedef std::map LabelSetMapType; LabelSetMapType mapLabelSets; LabelSetMapType::iterator itMapLabelSets; for (unsigned int it = 0; it < vectorAllLabels.size(); ++it) { //The universe LabelSet is filled with ALL the possible labels of vectorAllLabels universe.insert(vectorAllLabels[it]); labelSet.clear(); labelSet.insert(vectorAllLabels[it]); mapLabelSets[vectorAllLabels[it]] = labelSet; } std::cout << "universe = " << universe << std::endl; //********************************************************************** //************** RESULTS OF THE CLASSIFICATION OF PIXEL X ************** //********************************************************************** // Values (as MassOfBeliefFunctionType::LabelSetType) of the K CLASSIFICATION MAPS for the pixel X typedef std::vector LabelSetOfVectorType; LabelSetOfVectorType classifiedPixelX; classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[1]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[1]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[2]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); if ((nbArgs - 1) > nbClassesMax) //For tests with more than 4 labels in the universe TO TEST PROCESSING SPEED { classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[3]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[4]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[5]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[6]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[7]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[8]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[9]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[10]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[11]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[12]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[13]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[14]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[15]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[16]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[17]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[18]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[19]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[20]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[21]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[22]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[2]]); // NOT used labels of the universe /* classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[23]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[24]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[25]]); */ } for (unsigned int it = 0; it < classifiedPixelX.size(); ++it) { std::cout << "classifiedPixelX[" << it << "] = " << classifiedPixelX[it] << std::endl; } //********************************************************************** //********************************************************************** //********************************************************************** // Masses of the singleton sets {Ai} for each classifier. Expected to be automatically filled with the // CONFUSION MATRICES (ex: with the recognition rates of each class {Ai}). // These masses represent the degree of belief of each classifier that the output class of the pixel X // is {Ai} when the input pixel X actually belongs to the class {Ai} //typedef MassOfBeliefFunctionType::MassMapType MassMapType; MassMapType::iterator itMapMasses; MassMapType mCl0, mCl1, mCl2, mCl3, mCl4, mCl5; mCl0[mapLabelSets[vectorAllLabels[0]]] = 0.9; mCl0[mapLabelSets[vectorAllLabels[1]]] = 0.7; mCl0[mapLabelSets[vectorAllLabels[2]]] = 0.8; //mCl0[mapLabelSets[vectorAllLabels[3]]] = 0.05; //mCl0[universe] = 0.2; mCl1[mapLabelSets[vectorAllLabels[0]]] = 0.8; mCl1[mapLabelSets[vectorAllLabels[1]]] = 0; mCl1[mapLabelSets[vectorAllLabels[2]]] = 0.5; //mCl1[mapLabelSets[vectorAllLabels[3]]] = 0.15; //mCl1[universe] = 0; mCl2[mapLabelSets[vectorAllLabels[0]]] = 0.5; mCl2[mapLabelSets[vectorAllLabels[1]]] = 0.65; mCl2[mapLabelSets[vectorAllLabels[2]]] = 0.3; //mCl2[mapLabelSets[vectorAllLabels[3]]] = 0.1; //mCl2[universe] = 0.1; mCl3[mapLabelSets[vectorAllLabels[0]]] = 0.5; mCl3[mapLabelSets[vectorAllLabels[1]]] = 0.25; mCl3[mapLabelSets[vectorAllLabels[2]]] = 0.6; //mCl3[mapLabelSets[vectorAllLabels[3]]] = 0.2; //mCl3[universe] = 0; mCl4[mapLabelSets[vectorAllLabels[0]]] = 0.75; mCl4[mapLabelSets[vectorAllLabels[1]]] = 0.3; mCl4[mapLabelSets[vectorAllLabels[2]]] = 0.6; //mCl4[mapLabelSets[vectorAllLabels[3]]] = 0.5; //mCl4[universe] = 0; mCl5[mapLabelSets[vectorAllLabels[0]]] = 0.9; mCl5[mapLabelSets[vectorAllLabels[1]]] = 0.5; mCl5[mapLabelSets[vectorAllLabels[2]]] = 0.3; //mCl5[mapLabelSets[vectorAllLabels[3]]] = 0.2; //mCl5[universe] = 0; // Vector containing the std::maps of masses of ALL the singleton sets for each classifier k = 0,...,27 here std::vector mClVector; mClVector.push_back(mCl0); mClVector.push_back(mCl1); mClVector.push_back(mCl2); mClVector.push_back(mCl3); mClVector.push_back(mCl4); mClVector.push_back(mCl5); if ((nbArgs - 1) > nbClassesMax) //For tests with more than 4 labels in the universe TO TEST PROCESSING SPEED { //********************************************************************** // OTHER MASSES TO TEST PROCESSING SPEED MassMapType mCl6, mCl7, mCl8, mCl9, mCl10, mCl11, mCl12, mCl13, mCl14, mCl15, mCl16, mCl17, mCl18, mCl19, mCl20, mCl21, mCl22, mCl23, mCl24, mCl25, mCl26, mCl27, mCl28, mCl29, mCl30; // The other masses of each of the classifiers below (mCl6,...,mCl30) are assumed to be equal to zero, // that is why they are not initialized mCl6[mapLabelSets[vectorAllLabels[3]]] = 0.6; mCl7[mapLabelSets[vectorAllLabels[4]]] = 0.6; mCl8[mapLabelSets[vectorAllLabels[5]]] = 0.6; mCl9[mapLabelSets[vectorAllLabels[6]]] = 0.6; mCl10[mapLabelSets[vectorAllLabels[7]]] = 0.6; mCl11[mapLabelSets[vectorAllLabels[8]]] = 0.6; mCl12[mapLabelSets[vectorAllLabels[9]]] = 0.6; mCl13[mapLabelSets[vectorAllLabels[10]]] = 0.6; mCl14[mapLabelSets[vectorAllLabels[11]]] = 0.6; mCl15[mapLabelSets[vectorAllLabels[12]]] = 0.6; mCl16[mapLabelSets[vectorAllLabels[13]]] = 0.6; mCl17[mapLabelSets[vectorAllLabels[14]]] = 0.6; mCl18[mapLabelSets[vectorAllLabels[15]]] = 0.6; mCl19[mapLabelSets[vectorAllLabels[16]]] = 0.6; mCl20[mapLabelSets[vectorAllLabels[17]]] = 0.6; mCl21[mapLabelSets[vectorAllLabels[18]]] = 0.6; mCl22[mapLabelSets[vectorAllLabels[19]]] = 0.6; mCl23[mapLabelSets[vectorAllLabels[20]]] = 0.6; mCl24[mapLabelSets[vectorAllLabels[21]]] = 0.6; mCl25[mapLabelSets[vectorAllLabels[22]]] = 0.6; mCl26[mapLabelSets[vectorAllLabels[0]]] = 0.65; mCl27[mapLabelSets[vectorAllLabels[2]]] = 0.65; mCl28[mapLabelSets[vectorAllLabels[23]]] = 0.6; // NOT used here mCl29[mapLabelSets[vectorAllLabels[24]]] = 0.6; // NOT used here mCl30[mapLabelSets[vectorAllLabels[25]]] = 0.6; // NOT used here mClVector.push_back(mCl6); mClVector.push_back(mCl7); mClVector.push_back(mCl8); mClVector.push_back(mCl9); mClVector.push_back(mCl10); mClVector.push_back(mCl11); mClVector.push_back(mCl12); mClVector.push_back(mCl13); mClVector.push_back(mCl14); mClVector.push_back(mCl15); mClVector.push_back(mCl16); mClVector.push_back(mCl17); mClVector.push_back(mCl18); mClVector.push_back(mCl19); mClVector.push_back(mCl20); mClVector.push_back(mCl21); mClVector.push_back(mCl22); mClVector.push_back(mCl23); mClVector.push_back(mCl24); mClVector.push_back(mCl25); mClVector.push_back(mCl26); mClVector.push_back(mCl27); mClVector.push_back(mCl28); // NOT used here mClVector.push_back(mCl29); // NOT used here mClVector.push_back(mCl30); // NOT used here } //********************************************************************** //********************************************************************** //***************************** DS STEP #1 ***************************** //********************************************************************** MassOfBeliefFunctionType::LabelSetType labelSetClk; MassType mLabelSetClk, mLabelSetClk_, mUniverseClk; MassType mLabelSetClkprev, mLabelSetClkprev_, mUniverseClkprev; MassType KClk, mLabelSetClkNew, mLabelSetClkNew_, mUniverseClkNew; MassMapType mapJointMassesStepI, mapJointMassesStepI_, mapJointMassesUniverseStepI; // Extracting the masses m(Ai), m(Ai_) and m(OMEGA) for each of the K = 6 classifiers // and grouping them according to the {Ai} singletons // (ex: mg(A), mg(B), mg(C),..., with mg(Ai) the joint mass of the masses of classifiers with result Ai for pixel X) for (unsigned int itk = 0; itk < classifiedPixelX.size(); ++itk) { labelSetClk = classifiedPixelX[itk]; // Label of the classified pixel X: {a}, {b} or {c} here // Setting the masses of the three focal elements {Ai}, {Ai_} and OMEGA = {Ai U Ai_} // Extraction of mk({Ai}) = mLabelClk of the classifier k for the labelSetClk = {Ai} mUniverseClk = mClVector[itk][universe]; mLabelSetClk = mClVector[itk][labelSetClk]; mLabelSetClk_ = 1 - mLabelSetClk - mUniverseClk; // The first time the label {Ai} is found in classifiedPixelX if (mapJointMassesStepI.count(labelSetClk) == 0) { mLabelSetClkNew = mLabelSetClk; mLabelSetClkNew_ = mLabelSetClk_; mUniverseClkNew = mUniverseClk; } else { mLabelSetClkprev = mapJointMassesStepI[labelSetClk]; mLabelSetClkprev_ = mapJointMassesStepI_[labelSetClk]; mUniverseClkprev = mapJointMassesUniverseStepI[labelSetClk]; KClk = 1 / (1 - mLabelSetClkprev * mLabelSetClk_ - mLabelSetClkprev_ * mLabelSetClk); mLabelSetClkNew = KClk * (mLabelSetClkprev * (mLabelSetClk + mUniverseClk) + mUniverseClkprev * mLabelSetClk); mLabelSetClkNew_ = KClk * (mLabelSetClkprev_ * (mLabelSetClk_ + mUniverseClk) + mUniverseClkprev * mLabelSetClk_); mUniverseClkNew = KClk * mUniverseClkprev * mUniverseClk; } mapJointMassesStepI[labelSetClk] = mLabelSetClkNew; mapJointMassesStepI_[labelSetClk] = mLabelSetClkNew_; mapJointMassesUniverseStepI[labelSetClk] = mUniverseClkNew; } //********************************************************************** //***************************** DS STEP #2 ***************************** //********************************************************************** // Calculation of the four A, B, C and K constants MassType A = 0, B = 1, C = 1, K = 0; for (itMapMasses = mapJointMassesStepI.begin(); itMapMasses != mapJointMassesStepI.end(); ++itMapMasses) { labelSetClk = itMapMasses->first; mLabelSetClk = mapJointMassesStepI[labelSetClk]; mLabelSetClk_ = mapJointMassesStepI_[labelSetClk]; A = A + (mLabelSetClk / (1 - mLabelSetClk)); B = B * (1 - mLabelSetClk); C = C * mLabelSetClk_; std::cout << "****************************************" << std::endl; std::cout << "mapJointMassesStepI[" << labelSetClk << "] = " << mLabelSetClk << std::endl; std::cout << "mapJointMassesStepI_[" << labelSetClk << "] = " << mLabelSetClk_ << std::endl; std::cout << "mapJointMassesUniverseStepI[" << labelSetClk << "] = " << mapJointMassesUniverseStepI[labelSetClk] << std::endl; } unsigned int nbClkGroupsStepI = mapJointMassesStepI.size(); if (nbClkGroupsStepI == nbClasses) { K = 1 / ((1 + A) * B - C); } else { if (nbClkGroupsStepI < nbClasses) { K = 1 / ((1 + A) * B); } } std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "nbClasses = " << nbClasses << std::endl; std::cout << "nbClassifiers = " << classifiedPixelX .size() << std::endl; std::cout << "nbClkGroupsStepI = " << nbClkGroupsStepI << std::endl; // Calculation of the Belief function of each singleton {Ai} and {Ai_} MassMapType mapBelStepII, mapBelStepII_; MassType belLabelSetClk, belLabelSetClk_, addBelLabelSetClk = 0; for (itMapMasses = mapJointMassesStepI.begin(); itMapMasses != mapJointMassesStepI.end(); ++itMapMasses) { labelSetClk = itMapMasses->first; // Joint Masses AFTER STEP I (one mass per singleton {Ai}) mLabelSetClk = mapJointMassesStepI[labelSetClk]; mLabelSetClk_ = mapJointMassesStepI_[labelSetClk]; mUniverseClk = mapJointMassesUniverseStepI[labelSetClk]; // Bel(Ai) if ((nbClkGroupsStepI == nbClasses) || ((nbClkGroupsStepI == (nbClasses - 1)) && (K == nbClasses))) { belLabelSetClk = K * ((mLabelSetClk / (1 - mLabelSetClk)) * B + (mUniverseClk * C / mLabelSetClk_)); } else { belLabelSetClk = K * (mLabelSetClk / (1 - mLabelSetClk)) * B; } // Bel(Ai_) belLabelSetClk_ = 1 - belLabelSetClk; /*if (nbClkGroupsStepI == nbClasses) { belLabelSetClk_ = K * ((A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B - C); } else { if ((nbClkGroupsStepI < nbClasses) && (K <= nbClkGroupsStepI)) { belLabelSetClk_ = K * (A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B; } else { belLabelSetClk_ = K * (A - (mLabelSetClk / (1 - mLabelSetClk))) * B; } }*/ mapBelStepII[labelSetClk] = belLabelSetClk; mapBelStepII_[labelSetClk] = belLabelSetClk_; addBelLabelSetClk = addBelLabelSetClk + belLabelSetClk; } std::cout << "****************************************************************************" << std::endl; // The decision for the DS Fusion is made with the MAXIMAL Belief function: // {Ai} is chosen if Bel({Ai}) = MAX(Bel({Aj})) MassOfBeliefFunctionType::LabelSetType fusedDSLabelSet; MassType fusedDSBelLabelSetClk = 0; //Here the MAX of Bel(Ai) for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; /* // In order to handle the other sets {Aj} of the universe which are NOT present in classifiedPixelX // ONLY correct if ALL the K classifiers have m(universe) = mUniverseClk = 0 mapBelStepII_[labelSetClk] = mapBelStepII_[labelSetClk] + (1 - addBelLabelSetClk); */ if (itMapLabelSets == mapLabelSets.begin()) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = mapBelStepII[labelSetClk]; } else { if (mapBelStepII[labelSetClk] >= fusedDSBelLabelSetClk) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = mapBelStepII[labelSetClk]; } } // For labels {Ai} of the universe which are NOT present in classifiedPixelX, // the Bel({Ai_}) = SUM(m_stepII({Aj})) = SUM(Bel({Aj})) here; with {Aj} ALL labels present in classifiedPixelX if (mapBelStepII[labelSetClk] == 0) { mapBelStepII_[labelSetClk] = addBelLabelSetClk; } std::cout << "Bel(" << labelSetClk << ") = " << mapBelStepII[labelSetClk] << std::endl; std::cout << "Bel(NOT_" << labelSetClk << ") = " << mapBelStepII_[labelSetClk] << std::endl; std::cout << std::endl; } // If the DS VOTED LABEL is NOT unique, the result of the DS Fusion is the UNION of all the candidates {Ai} // with Bel({Ai}) = MAX(Bel({Aj})) for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; if ((mapBelStepII[labelSetClk] == fusedDSBelLabelSetClk) && (labelSetClk != fusedDSLabelSet)) { fusedDSLabelSet.insert(itMapLabelSets->first); } } std::cout << "****************************************************************************" << std::endl; std::cout << "fusedDSLabelSet = " << fusedDSLabelSet << std::endl; std::cout << "fusedDSBelLabelSetClk = " << fusedDSBelLabelSetClk << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // OPTIMIZED DS FUSION int otbDempsterShaferFusionOptTest(int argc, char * argv[]) { std::vector vectorAllLabels; unsigned int nbArgs = static_cast (argc); for (unsigned int it = 1; it < nbArgs; ++it) { vectorAllLabels.push_back(argv[it]); } unsigned int nbClasses = vectorAllLabels.size(); MassOfBeliefFunctionType::LabelSetType universe, labelSet; typedef std::map LabelSetMapType; LabelSetMapType mapLabelSets; LabelSetMapType::iterator itMapLabelSets; for (unsigned int it = 0; it < vectorAllLabels.size(); ++it) { //The universe LabelSet is filled with ALL the possible labels of vectorAllLabels universe.insert(vectorAllLabels[it]); labelSet.clear(); labelSet.insert(vectorAllLabels[it]); mapLabelSets[vectorAllLabels[it]] = labelSet; } std::cout << "universe = " << universe << std::endl; //********************************************************************** //************** RESULTS OF THE CLASSIFICATION OF PIXEL X ************** //********************************************************************** // Values (as MassOfBeliefFunctionType::LabelSetType) of the K CLASSIFICATION MAPS for the pixel X typedef std::vector LabelSetOfVectorType; LabelSetOfVectorType classifiedPixelX; classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[1]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[1]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[2]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); for (unsigned int it = 0; it < classifiedPixelX.size(); ++it) { std::cout << "classifiedPixelX[" << it << "] = " << classifiedPixelX[it] << std::endl; } //********************************************************************** //********************************************************************** //********************************************************************** // Masses of the singleton sets {Ai} for each classifier. Expected to be automatically filled with the // CONFUSION MATRICES (ex: with the recognition rates of each class {Ai}). // These masses represent the degree of belief of each classifier that the output class of the pixel X // is {Ai} when the input pixel X actually belongs to the class {Ai} //typedef MassOfBeliefFunctionType::MassMapType MassMapType; MassMapType::iterator itMapMasses; MassMapType mCl0, mCl1, mCl2, mCl3, mCl4, mCl5; mCl0[mapLabelSets[vectorAllLabels[0]]] = 0.9; mCl0[mapLabelSets[vectorAllLabels[1]]] = 0.7; mCl0[mapLabelSets[vectorAllLabels[2]]] = 0.8; //mCl0[mapLabelSets[vectorAllLabels[3]]] = 0.05; //mCl0[universe] = 0.2; mCl1[mapLabelSets[vectorAllLabels[0]]] = 0.8; mCl1[mapLabelSets[vectorAllLabels[1]]] = 0; mCl1[mapLabelSets[vectorAllLabels[2]]] = 0.5; //mCl1[mapLabelSets[vectorAllLabels[3]]] = 0.15; //mCl1[universe] = 0; mCl2[mapLabelSets[vectorAllLabels[0]]] = 0.5; mCl2[mapLabelSets[vectorAllLabels[1]]] = 0.65; mCl2[mapLabelSets[vectorAllLabels[2]]] = 0.3; //mCl2[mapLabelSets[vectorAllLabels[3]]] = 0.1; //mCl2[universe] = 0.1; mCl3[mapLabelSets[vectorAllLabels[0]]] = 0.5; mCl3[mapLabelSets[vectorAllLabels[1]]] = 0.25; mCl3[mapLabelSets[vectorAllLabels[2]]] = 0.6; //mCl3[mapLabelSets[vectorAllLabels[3]]] = 0.2; //mCl3[universe] = 0; mCl4[mapLabelSets[vectorAllLabels[0]]] = 0.75; mCl4[mapLabelSets[vectorAllLabels[1]]] = 0.3; mCl4[mapLabelSets[vectorAllLabels[2]]] = 0.6; //mCl4[mapLabelSets[vectorAllLabels[3]]] = 0.5; //mCl4[universe] = 0; mCl5[mapLabelSets[vectorAllLabels[0]]] = 0.9; mCl5[mapLabelSets[vectorAllLabels[1]]] = 0.5; mCl5[mapLabelSets[vectorAllLabels[2]]] = 0.3; //mCl5[mapLabelSets[vectorAllLabels[3]]] = 0.2; //mCl5[universe] = 0; // Vector containing the std::maps of masses of ALL the singleton sets for each classifier k = 0,...,5 here std::vector mClVector; mClVector.push_back(mCl0); mClVector.push_back(mCl1); mClVector.push_back(mCl2); mClVector.push_back(mCl3); mClVector.push_back(mCl4); mClVector.push_back(mCl5); //********************************************************************** //***************************** DS STEP #1 ***************************** //********************************************************************** MassOfBeliefFunctionType::LabelSetType labelSetClk, labelSetClk_; MassType mLabelSetClk, mLabelSetClk_, mUniverseClk; MassOfBeliefFunctionType::Pointer mOBFClk; JointMassOfBeliefFilterType::Pointer jointMassClkFilter; typedef std::map mapJointMassOfBeliefFilterType; mapJointMassOfBeliefFilterType mapJointMassFilters; mapJointMassOfBeliefFilterType::iterator itMapJMOBFilters; // Extracting the masses m(Ai), m(Ai_) and m(OMEGA) for each of the K = 6 classifiers // and grouping them according to the {Ai} singletons // (ex: mg(A), mg(B), mg(C),..., with mg(Ai) the joint mass of the masses of classifiers with result Ai for pixel X) for (unsigned int itk = 0; itk < classifiedPixelX.size(); ++itk) { // Allocation of a new MassOfBeliefFunctionType::Pointer object pointing at a new memory address mOBFClk = MassOfBeliefFunctionType::New(); labelSetClk = classifiedPixelX[itk]; // Label of the classified pixel X: {a}, {b} or {c} here // Defining the complementary singleton set {Ai_} labelSetClk_ = universe; labelSetClk_.erase(*labelSetClk.begin()); // Setting the masses of the three focal elements {Ai}, {Ai_} and OMEGA = {Ai U Ai_} // Extraction of mk({Ai}) = mLabelClk of the classifier k for the labelSetClk = {Ai} mUniverseClk = mClVector[itk][universe]; mLabelSetClk = mClVector[itk][labelSetClk]; mLabelSetClk_ = 1 - mLabelSetClk - mUniverseClk; // Defining the MassOfBeliefFunctionType::Pointer object mOBFClk for the classifier k mOBFClk->InitializePowerSetMasses(universe); mOBFClk->SetMass(labelSetClk, mLabelSetClk); mOBFClk->SetMass(labelSetClk_, mLabelSetClk_); mOBFClk->EstimateUncertainty(); if (mapJointMassFilters.count(labelSetClk) == 0) { // Allocation of a new JointMassOfBeliefFilterType::Pointer object pointing at a new memory address jointMassClkFilter = JointMassOfBeliefFilterType::New(); mapJointMassFilters[labelSetClk] = jointMassClkFilter; } mapJointMassFilters[labelSetClk]->PushBackInput(mOBFClk); } typedef std::map mapMassesOfBeliefFunctionType; mapMassesOfBeliefFunctionType mapJMOBFStepI; mapMassesOfBeliefFunctionType::iterator itMapJMOBFStepI; for (itMapJMOBFilters = mapJointMassFilters.begin(); itMapJMOBFilters != mapJointMassFilters.end(); ++itMapJMOBFilters) { // JointMassOfBeliefFilterType filters are executed, and the resulting joint masses are inserted in mapJMOBFStepI itMapJMOBFilters->second->Update(); mapJMOBFStepI[itMapJMOBFilters->first] = itMapJMOBFilters->second->GetOutput(); std::cout << "****************************************************************************" << std::endl; std::cout << "jointMassClkFilterStepI[" << itMapJMOBFilters->first << "] = " << itMapJMOBFilters->second << std::endl; } std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; //********************************************************************** //***************************** DS STEP #2 ***************************** //********************************************************************** // Calculation of the four A, B, C and K constants MassType A = 0, B = 1, C = 1, K = 0; mapMassesOfBeliefFunctionType::iterator itMapJMOBF; for (itMapJMOBF = mapJMOBFStepI.begin(); itMapJMOBF != mapJMOBFStepI.end(); ++itMapJMOBF) { labelSetClk = itMapJMOBF->first; labelSetClk_ = universe; labelSetClk_.erase(*labelSetClk.begin()); mLabelSetClk = itMapJMOBF->second->GetMass(labelSetClk); mLabelSetClk_ = itMapJMOBF->second->GetMass(labelSetClk_); A = A + (mLabelSetClk / (1 - mLabelSetClk)); B = B * (1 - mLabelSetClk); C = C * mLabelSetClk_; std::cout << "****************************************************************************" << std::endl; std::cout << "jointMassOfBeliefStepI[" << itMapJMOBF->first << "] = " << itMapJMOBF->second << std::endl; } unsigned int nbClkGroupsStepI = mapJMOBFStepI.size(); if (nbClkGroupsStepI == nbClasses) { K = 1 / ((1 + A) * B - C); } else { if (nbClkGroupsStepI < nbClasses) { K = 1 / ((1 + A) * B); } } // Calculation of the Belief function of each singleton {Ai} and {Ai_} MassMapType mapBelStepII; MassMapType::iterator itMapBelStepII; MassType belLabelSetClk, belLabelSetClk_, addBelLabelSetClk = 0; for (itMapJMOBF = mapJMOBFStepI.begin(); itMapJMOBF != mapJMOBFStepI.end(); ++itMapJMOBF) { labelSetClk = itMapJMOBF->first; labelSetClk_ = universe; labelSetClk_.erase(*labelSetClk.begin()); mUniverseClk = itMapJMOBF->second->GetMass(universe); mLabelSetClk = itMapJMOBF->second->GetMass(labelSetClk); mLabelSetClk_ = itMapJMOBF->second->GetMass(labelSetClk_); // Bel(Ai) if ((nbClkGroupsStepI == nbClasses) || ((nbClkGroupsStepI == (nbClasses - 1)) && (K == nbClasses))) { belLabelSetClk = K * ((mLabelSetClk / (1 - mLabelSetClk)) * B + (mUniverseClk * C / mLabelSetClk_)); } else { belLabelSetClk = K * (mLabelSetClk / (1 - mLabelSetClk)) * B; } // Bel(Ai_) belLabelSetClk_ = 1 - belLabelSetClk; /*if (nbClkGroupsStepI == nbClasses) { belLabelSetClk_ = K * ((A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B - C); } else { if ((nbClkGroupsStepI < nbClasses) && (K <= nbClkGroupsStepI)) { belLabelSetClk_ = K * (A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B; } else { belLabelSetClk_ = K * (A - (mLabelSetClk / (1 - mLabelSetClk))) * B; } }*/ mapBelStepII[labelSetClk] = belLabelSetClk; mapBelStepII[labelSetClk_] = belLabelSetClk_; addBelLabelSetClk = addBelLabelSetClk + belLabelSetClk; } std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; // The decision for the DS Fusion is made with the MAXIMAL Belief function: // {Ai} is chosen if Bel({Ai}) = MAX(Bel({Aj})) MassOfBeliefFunctionType::LabelSetType fusedDSLabelSet; MassType fusedDSBelLabelSetClk = 0; //Here the MAX of Bel(Ai) for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; labelSetClk_ = universe; labelSetClk_.erase(*labelSetClk.begin()); /* // In order to handle the other sets {Aj} of the universe which are NOT present in classifiedPixelX // ONLY correct if ALL the K classifiers have m(universe) = mUniverseClk = 0 mapBelStepII[labelSetClk_] = mapBelStepII[labelSetClk_] + (1 - addBelLabelSetClk); */ if (itMapLabelSets == mapLabelSets.begin()) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = mapBelStepII[labelSetClk]; } else { if (mapBelStepII[labelSetClk] >= fusedDSBelLabelSetClk) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = mapBelStepII[labelSetClk]; } } // For labels {Ai} of the universe which are NOT present in classifiedPixelX, // the Bel({Ai_}) = SUM(m_stepII({Aj})) = SUM(Bel({Aj})) here; with {Aj} ALL labels present in classifiedPixelX if (mapBelStepII[labelSetClk] == 0) { mapBelStepII[labelSetClk_] = addBelLabelSetClk; } std::cout << "Bel(" << labelSetClk << ") = " << mapBelStepII[labelSetClk] << std::endl; std::cout << "Bel(NOT_" << labelSetClk << ") = Bel(" << labelSetClk_ << ") = " << mapBelStepII[labelSetClk_] << std::endl; std::cout << std::endl; } // If the DS VOTED LABEL is NOT unique, the result of the DS Fusion is the UNION of all the candidates {Ai} // with Bel({Ai}) = MAX(Bel({Aj})) for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; if ((mapBelStepII[labelSetClk] == fusedDSBelLabelSetClk) && (labelSetClk != fusedDSLabelSet)) { fusedDSLabelSet.insert(itMapLabelSets->first); } } std::cout << "****************************************************************************" << std::endl; std::cout << "fusedDSLabelSet = " << fusedDSLabelSet << std::endl; std::cout << "fusedDSBelLabelSetClk = " << fusedDSBelLabelSetClk << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // NOT OPTIMIZED DS FUSION int otbDempsterShaferFusionTest(int argc, char * argv[]) { std::vector vectorAllLabels; unsigned int nbArgs = static_cast (argc); for (unsigned int it = 1; it < nbArgs; ++it) { vectorAllLabels.push_back(argv[it]); } // unsigned int nbClasses = vectorAllLabels.size(); MassOfBeliefFunctionType::LabelSetType universe, labelSet; typedef std::map LabelSetMapType; LabelSetMapType mapLabelSets; LabelSetMapType::iterator itMapLabelSets; for (unsigned int it = 0; it < vectorAllLabels.size(); ++it) { //The universe LabelSet is filled with ALL the possible labels of vectorAllLabels universe.insert(vectorAllLabels[it]); labelSet.clear(); labelSet.insert(vectorAllLabels[it]); mapLabelSets[vectorAllLabels[it]] = labelSet; } std::cout << "universe = " << universe << std::endl; //********************************************************************** //************** RESULTS OF THE CLASSIFICATION OF PIXEL X ************** //********************************************************************** // Values (as MassOfBeliefFunctionType::LabelSetType) of the K CLASSIFICATION MAPS for the pixel X typedef std::vector LabelSetOfVectorType; LabelSetOfVectorType classifiedPixelX; classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[1]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[1]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[2]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); classifiedPixelX.push_back(mapLabelSets[vectorAllLabels[0]]); for (unsigned int it = 0; it < classifiedPixelX.size(); ++it) { std::cout << "classifiedPixelX[" << it << "] = " << classifiedPixelX[it] << std::endl; } //********************************************************************** //********************************************************************** //********************************************************************** // Masses of the singleton sets {Ai} for each classifier. Expected to be automatically filled with the // CONFUSION MATRICES (ex: with the recognition rates of each class {Ai}). // These masses represent the degree of belief of each classifier that the output class of the pixel X // is {Ai} when the input pixel X actually belongs to the class {Ai} //typedef MassOfBeliefFunctionType::MassMapType MassMapType; MassMapType::iterator itMapMasses; MassMapType mCl0, mCl1, mCl2, mCl3, mCl4, mCl5; mCl0[mapLabelSets[vectorAllLabels[0]]] = 0.9; mCl0[mapLabelSets[vectorAllLabels[1]]] = 0.7; mCl0[mapLabelSets[vectorAllLabels[2]]] = 0.8; //mCl0[mapLabelSets[vectorAllLabels[3]]] = 0.05; //mCl0[universe] = 0.2; mCl1[mapLabelSets[vectorAllLabels[0]]] = 0.8; mCl1[mapLabelSets[vectorAllLabels[1]]] = 0; mCl1[mapLabelSets[vectorAllLabels[2]]] = 0.5; //mCl1[mapLabelSets[vectorAllLabels[3]]] = 0.15; //mCl1[universe] = 0; mCl2[mapLabelSets[vectorAllLabels[0]]] = 0.5; mCl2[mapLabelSets[vectorAllLabels[1]]] = 0.65; mCl2[mapLabelSets[vectorAllLabels[2]]] = 0.3; //mCl2[mapLabelSets[vectorAllLabels[3]]] = 0.1; //mCl2[universe] = 0.1; mCl3[mapLabelSets[vectorAllLabels[0]]] = 0.5; mCl3[mapLabelSets[vectorAllLabels[1]]] = 0.25; mCl3[mapLabelSets[vectorAllLabels[2]]] = 0.6; //mCl3[mapLabelSets[vectorAllLabels[3]]] = 0.2; //mCl3[universe] = 0; mCl4[mapLabelSets[vectorAllLabels[0]]] = 0.75; mCl4[mapLabelSets[vectorAllLabels[1]]] = 0.3; mCl4[mapLabelSets[vectorAllLabels[2]]] = 0.6; //mCl4[mapLabelSets[vectorAllLabels[3]]] = 0.5; //mCl4[universe] = 0; mCl5[mapLabelSets[vectorAllLabels[0]]] = 0.9; mCl5[mapLabelSets[vectorAllLabels[1]]] = 0.5; mCl5[mapLabelSets[vectorAllLabels[2]]] = 0.3; //mCl5[mapLabelSets[vectorAllLabels[3]]] = 0.2; //mCl5[universe] = 0; // Vector containing the std::maps of masses of ALL the singleton sets for each classifier k = 0,...,5 here std::vector mClVector; mClVector.push_back(mCl0); mClVector.push_back(mCl1); mClVector.push_back(mCl2); mClVector.push_back(mCl3); mClVector.push_back(mCl4); mClVector.push_back(mCl5); //********************************************************************** //***************************** DS FUSION ****************************** //********************************************************************** MassOfBeliefFunctionType::LabelSetType labelSetClk, labelSetClk_; MassType mLabelSetClk, mLabelSetClk_, mUniverseClk; MassOfBeliefFunctionType::Pointer mOBFClk; JointMassOfBeliefFilterType::Pointer jointMassClkFilter; jointMassClkFilter = JointMassOfBeliefFilterType::New(); for (unsigned int itk = 0; itk < classifiedPixelX.size(); ++itk) { // Allocation of a new MassOfBeliefFunctionType::Pointer object pointing at a new memory address mOBFClk = MassOfBeliefFunctionType::New(); labelSetClk = classifiedPixelX[itk]; // Label of the classified pixel X: {a}, {b} or {c} here // Defining the complementary singleton set {Ai_} labelSetClk_ = universe; labelSetClk_.erase(*labelSetClk.begin()); // Setting the masses of the three focal elements {Ai}, {Ai_} and OMEGA = {Ai U Ai_} // Extraction of mk({Ai}) = mLabelClk of the classifier k for the labelSetClk = {Ai} mUniverseClk = mClVector[itk][universe]; mLabelSetClk = mClVector[itk][labelSetClk]; mLabelSetClk_ = 1 - mLabelSetClk - mUniverseClk; // Defining the MassOfBeliefFunctionType::Pointer object mOBFClk for the classifier k mOBFClk->InitializePowerSetMasses(universe); mOBFClk->SetMass(labelSetClk, mLabelSetClk); mOBFClk->SetMass(labelSetClk_, mLabelSetClk_); mOBFClk->EstimateUncertainty(); jointMassClkFilter->PushBackInput(mOBFClk); } jointMassClkFilter->Update(); MassOfBeliefFunctionType::Pointer jointMass = jointMassClkFilter->GetOutput(); std::cout << "****************************************************************************" << std::endl; std::cout << "jointMassClkFilter = " << jointMassClkFilter << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "jointMassOfBelief = " << jointMass << std::endl; std::cout << "****************************************************************************" << std::endl; // The decision for the DS Fusion is made with the MAXIMAL Belief function: // {Ai} is chosen if Bel({Ai}) = MAX(Bel({Aj})) MassOfBeliefFunctionType::LabelSetType fusedDSLabelSet; MassType fusedDSBelLabelSetClk = 0; //Here the MAX of Bel(Ai) for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; labelSetClk_ = universe; labelSetClk_.erase(*labelSetClk.begin()); if (itMapLabelSets == mapLabelSets.begin()) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = jointMass->GetBelief(labelSetClk); } else { if (jointMass->GetBelief(labelSetClk) >= fusedDSBelLabelSetClk) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = jointMass->GetBelief(labelSetClk); } } std::cout << "Bel(" << labelSetClk << ") = " << jointMass->GetBelief(labelSetClk) << std::endl; std::cout << "Bel(NOT_" << labelSetClk << ") = Bel(" << labelSetClk_ << ") = " << jointMass->GetBelief(labelSetClk_) << std::endl; std::cout << std::endl; } //If the DS VOTED LABEL is NOT unique for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; if ((jointMass->GetBelief(labelSetClk) == fusedDSBelLabelSetClk) && (labelSetClk != fusedDSLabelSet)) { fusedDSLabelSet.insert(itMapLabelSets->first); } } std::cout << "****************************************************************************" << std::endl; std::cout << "fusedDSLabelSet = " << fusedDSLabelSet << std::endl; std::cout << "fusedDSBelLabelSetClk = " << fusedDSBelLabelSetClk << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // OPTIMIZED RECURSIVE DS FUSION FROM CONFUSION MATRIX FILES int otbDempsterShaferFusionOptRecConfMatFileTest(int argc, char * argv[]) { unsigned int nbParameters = 1; unsigned int nbClassifiers = (argc - 1 - nbParameters); IntLabelPixelType undefinedValue = 0; std::string massOfBeliefDefMethodStr = argv[argc - 4]; MassOfBeliefDefinitionMethod massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; if (massOfBeliefDefMethodStr.compare("PRECISION") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; } else { if (massOfBeliefDefMethodStr.compare("RECALL") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::RECALL; } else { if (massOfBeliefDefMethodStr.compare("ACCURACY") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::ACCURACY; } else { if (massOfBeliefDefMethodStr.compare("KAPPA") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::KAPPA; } } } } std::vector vectorOfMapOfClasses; std::vector vectorOfConfMatrices; for (unsigned int itCM = 0; itCM < nbClassifiers; ++itCM) { std::string fileNameConfMat = argv[itCM + 1]; MapOfClassesType mapOfClassesClk; ConfusionMatrixType confusionMatrixClk; CSVConfusionMatrixFileReader(fileNameConfMat, mapOfClassesClk, confusionMatrixClk); vectorOfMapOfClasses.push_back(mapOfClassesClk); vectorOfConfMatrices.push_back(confusionMatrixClk); } /* ***************************************************************************************** */ /* *** Extraction of the K maps of Masses of Belief (one map of MOBs for each classifier) ** */ /* ***************************************************************************************** */ // Masses of the singleton sets {Ai} for each classifier. // These masses represent the degree of belief of each classifier that the output class of the pixel X // is {Ai} when the input pixel X actually belongs to the class {Ai} MapOfClassesType mapOfClassesClk; MapOfClassesType::iterator itMapOfClassesClk; ConfusionMatrixType confMatClk; MassType mobUniverseClk; SingleClassLabelMassMapType mapMOBClk; SingleClassLabelMassMapType::iterator itMapMOBClk; ClassifierHistogramType universe; ClassifierHistogramType::iterator itUniverse; std::vector vectorMapMOBs; std::vector vectorUniverseMOBs; ConfusionMatrixToMassOfBeliefType::Pointer confMatToMass = ConfusionMatrixToMassOfBeliefType::New(); for (unsigned int itClk = 0; itClk < nbClassifiers; ++itClk) { // Classifier Cl_k: mapOfClassesClk = vectorOfMapOfClasses[itClk]; confMatClk = vectorOfConfMatrices[itClk]; // mobUniverseClk is set to zero in order to assure the correct estimation of the Belief Functions of the // complementary sets bel({Ai_}) in the optimized DS combination mobUniverseClk = 0.; confMatToMass->SetMapOfClasses(mapOfClassesClk); confMatToMass->SetConfusionMatrix(confMatClk); confMatToMass->SetDefinitionMethod(massOfBeliefDefMethod); confMatToMass->Update(); mapMOBClk.clear(); mapMOBClk = confMatToMass->GetMapMassOfBelief(); // Vector containing ALL the K std::maps of Mass of Belief vectorMapMOBs.push_back(mapMOBClk); // Vector containing the Mass of Belief of the universe for each classifier vectorUniverseMOBs.push_back(mobUniverseClk); std::cout << "confusion matrix[Cl_" << itClk << "] = " << std::endl; for (itMapOfClassesClk = mapOfClassesClk.begin(); itMapOfClassesClk != mapOfClassesClk.end(); ++itMapOfClassesClk) { IntLabelPixelType classLabel = itMapOfClassesClk->first; std::cout << "[" << classLabel << "] "; // If the current classLabel has already been added to the universe if (universe.count(classLabel) > 0) { universe[classLabel]++; } else { universe[classLabel] = 1; } } std::cout << std::endl << confMatClk << std::endl; std::cout << std::endl; for (itMapMOBClk = mapMOBClk.begin(); itMapMOBClk != mapMOBClk.end(); ++itMapMOBClk) { std::cout << "mapMOBCl_" << itClk << "[" << itMapMOBClk->first << "] = " << itMapMOBClk->second << std::endl; } std::cout << "*******************************************************************************" << std::endl; } // Number of classes in the universe unsigned int nbClasses = universe.size(); std::cout << "universe:" << std::endl; for (itUniverse = universe.begin(); itUniverse != universe.end(); ++itUniverse) { std::cout << "Class Label " << itUniverse->first; std::cout << " present in " << itUniverse->second << " classifier(s)" << std::endl; } std::cout << std::endl; /* ***************************************************************************************** */ /* ************************ RESULTS OF THE CLASSIFICATION OF PIXEL X *********************** */ /* ***************************************************************************************** */ // Values (as IntLabelPixelType) of the K CLASSIFICATION MAPS for the pixel X std::vector classifiedPixelX; classifiedPixelX.push_back(2); classifiedPixelX.push_back(2); classifiedPixelX.push_back(2); classifiedPixelX.push_back(2); classifiedPixelX.push_back(2); classifiedPixelX.push_back(2); // With merged classes classifiedPixelX.push_back(4); classifiedPixelX.push_back(2); classifiedPixelX.push_back(3); /* ***************************************************************************************** */ /* *************************************** DS STEP #1 ************************************** */ /* ***************************************************************************************** */ IntLabelPixelType classLabelk; MassType mLabelSetClk, mLabelSetClk_, mUniverseClk; MassType mLabelSetClkprev, mLabelSetClkprev_, mUniverseClkprev; MassType KClk, mLabelSetClkNew, mLabelSetClkNew_, mUniverseClkNew; SingleClassLabelMassMapType mapJointMassesStepI, mapJointMassesStepI_, mapJointMassesUniverseStepI; // Extracting the masses m(Ai), m(Ai_) and m(OMEGA) for each of the K = 6 classifiers // and grouping them according to the {Ai} singletons // (ex: mg(A), mg(B), mg(C),..., with mg(Ai) the joint mass of the masses of classifiers with result Ai for pixel X) for (unsigned int itClk = 0; itClk < nbClassifiers; ++itClk) { classLabelk = classifiedPixelX[itClk]; // Setting the masses of the three focal elements {Ai}, {Ai_} and OMEGA = {Ai U Ai_} // Extraction of mk({Ai}) = mLabelClk of the classifier k for the labelSetClk = {Ai} mUniverseClk = vectorUniverseMOBs[itClk]; mLabelSetClk = vectorMapMOBs[itClk][classLabelk]; mLabelSetClk_ = 1 - mLabelSetClk - mUniverseClk; std::cout << "classifiedPixelX[" << itClk << "] = " << classLabelk; std::cout << "; MassOfBelief_Cl_" << itClk << "[" << classLabelk << "] = " << mLabelSetClk; std::cout << std::endl; // The first time the label {Ai} is found in classifiedPixelX if (mapJointMassesStepI.count(classLabelk) == 0) { mLabelSetClkNew = mLabelSetClk; mLabelSetClkNew_ = mLabelSetClk_; mUniverseClkNew = mUniverseClk; } else { mLabelSetClkprev = mapJointMassesStepI[classLabelk]; mLabelSetClkprev_ = mapJointMassesStepI_[classLabelk]; mUniverseClkprev = mapJointMassesUniverseStepI[classLabelk]; KClk = 1 / (1 - mLabelSetClkprev * mLabelSetClk_ - mLabelSetClkprev_ * mLabelSetClk); mLabelSetClkNew = KClk * (mLabelSetClkprev * (mLabelSetClk + mUniverseClk) + mUniverseClkprev * mLabelSetClk); mLabelSetClkNew_ = KClk * (mLabelSetClkprev_ * (mLabelSetClk_ + mUniverseClk) + mUniverseClkprev * mLabelSetClk_); mUniverseClkNew = KClk * mUniverseClkprev * mUniverseClk; } mapJointMassesStepI[classLabelk] = mLabelSetClkNew; mapJointMassesStepI_[classLabelk] = mLabelSetClkNew_; mapJointMassesUniverseStepI[classLabelk] = mUniverseClkNew; } std::cout << "*******************************************************************************" << std::endl; std::cout << std::endl; /* ***************************************************************************************** */ /* *************************************** DS STEP #2 ************************************** */ /* ***************************************************************************************** */ // Calculation of the four A, B, C and K constants MassType A = 0, B = 1, C = 1, K = 0; for (itMapMOBClk = mapJointMassesStepI.begin(); itMapMOBClk != mapJointMassesStepI.end(); ++itMapMOBClk) { classLabelk = itMapMOBClk->first; mLabelSetClk = mapJointMassesStepI[classLabelk]; mLabelSetClk_ = mapJointMassesStepI_[classLabelk]; mUniverseClk = mapJointMassesUniverseStepI[classLabelk]; A = A + (mLabelSetClk / (1 - mLabelSetClk)); B = B * (1 - mLabelSetClk); C = C * mLabelSetClk_; std::cout << "****************************************" << std::endl; std::cout << "mapJointMassesStepI[" << classLabelk << "] = " << mLabelSetClk << std::endl; std::cout << "mapJointMassesStepI_[" << classLabelk << "] = " << mLabelSetClk_ << std::endl; std::cout << "mapJointMassesUniverseStepI[" << classLabelk << "] = " << mUniverseClk << std::endl; } unsigned int nbClkGroupsStepI = mapJointMassesStepI.size(); if (nbClkGroupsStepI == nbClasses) { K = 1 / ((1 + A) * B - C); } else { if (nbClkGroupsStepI < nbClasses) { K = 1 / ((1 + A) * B); } } std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "nbClasses = " << nbClasses << std::endl; std::cout << "nbClassifiers = " << nbClassifiers << std::endl; std::cout << "nbClkGroupsStepI = " << nbClkGroupsStepI << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "****************************************************************************" << std::endl; // Calculation of the Belief function of each singleton {Ai} and {Ai_} SingleClassLabelMassMapType mapBelStepII, mapBelStepII_; MassType belLabelSetClk, belLabelSetClk_, addBelLabelSetClk = 0.; for (itMapMOBClk = mapJointMassesStepI.begin(); itMapMOBClk != mapJointMassesStepI.end(); ++itMapMOBClk) { classLabelk = itMapMOBClk->first; // Joint Masses AFTER STEP I (one mass per singleton {Ai}) mLabelSetClk = mapJointMassesStepI[classLabelk]; mLabelSetClk_ = mapJointMassesStepI_[classLabelk]; mUniverseClk = mapJointMassesUniverseStepI[classLabelk]; // Bel(Ai) if ((nbClkGroupsStepI == nbClasses) || ((nbClkGroupsStepI == (nbClasses - 1)) && (K == nbClasses))) { belLabelSetClk = K * ((mLabelSetClk / (1 - mLabelSetClk)) * B + (mUniverseClk * C / mLabelSetClk_)); } else { belLabelSetClk = K * (mLabelSetClk / (1 - mLabelSetClk)) * B; } // Bel(Ai_) belLabelSetClk_ = 1 - belLabelSetClk; /*if (nbClkGroupsStepI == nbClasses) { belLabelSetClk_ = K * ((A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B - C); } else { if ((nbClkGroupsStepI < nbClasses) && (K <= nbClkGroupsStepI)) { belLabelSetClk_ = K * (A - ((mLabelSetClk - mLabelSetClk_) / (1 - mLabelSetClk))) * B; } else { belLabelSetClk_ = K * (A - (mLabelSetClk / (1 - mLabelSetClk))) * B; } }*/ mapBelStepII[classLabelk] = belLabelSetClk; mapBelStepII_[classLabelk] = belLabelSetClk_; addBelLabelSetClk += belLabelSetClk; } std::cout << "****************************************************************************" << std::endl; /* ***************************************************************************************** */ /* ************************************ DECISION PROCESS *********************************** */ /* ***************************************************************************************** */ // The decision for the DS Fusion is made with the MAXIMAL Belief function: // {Ai} is chosen if Bel({Ai}) = MAX(Bel({Aj})) IntLabelPixelType fusedDSLabelSet = 0; MassType fusedDSBelLabelSetClk = 0.; //Here the MAX of Bel(Ai) for (itUniverse = universe.begin(); itUniverse != universe.end(); ++itUniverse) { classLabelk = itUniverse->first; /* // In order to handle the other sets {Aj} of the universe which are NOT present in classifiedPixelX // ONLY correct if ALL the K classifiers have m(universe) = mUniverseClk = 0 mapBelStepII_[classLabelk] += (1 - addBelLabelSetClk); */ if (itUniverse == universe.begin()) { fusedDSLabelSet = classLabelk; fusedDSBelLabelSetClk = mapBelStepII[classLabelk]; } else { if (mapBelStepII[classLabelk] >= fusedDSBelLabelSetClk) { fusedDSLabelSet = classLabelk; fusedDSBelLabelSetClk = mapBelStepII[classLabelk]; } } // For labels {Ai} of the universe which are NOT present in classifiedPixelX, // the Bel({Ai_}) = SUM(m_stepII({Aj})) = SUM(Bel({Aj})) here; with {Aj} ALL labels present in classifiedPixelX if (mapBelStepII[classLabelk] == 0) { mapBelStepII_[classLabelk] = addBelLabelSetClk; } std::cout << "Bel(" << classLabelk << ") = " << mapBelStepII[classLabelk] << std::endl; std::cout << "Bel(NOT_" << classLabelk << ") = " << mapBelStepII_[classLabelk] << std::endl; std::cout << std::endl; } // If the DS VOTED LABEL is NOT unique, the result of the DS Fusion is undefinedValue for (itUniverse = universe.begin(); itUniverse != universe.end(); ++itUniverse) { classLabelk = itUniverse->first; if ((mapBelStepII[classLabelk] == fusedDSBelLabelSetClk) && (classLabelk != fusedDSLabelSet)) { fusedDSLabelSet = undefinedValue; } } std::cout << "****************************************************************************" << std::endl; std::cout << "fusedDSLabelSet = " << fusedDSLabelSet << std::endl; std::cout << "fusedDSBelLabelSetClk = " << fusedDSBelLabelSetClk << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } // ******************************************************************************************************** // ******************************************************************************************************** // ******************************************************************************************************** // NOT OPTIMIZED DS FUSION FROM CONFUSION MATRIX FILES int otbDempsterShaferFusionConfMatFileTest(int argc, char * argv[]) { unsigned int nbParameters = 1; unsigned int nbClassifiers = (argc - 1 - nbParameters); // IntLabelPixelType undefinedValue = 0; std::string massOfBeliefDefMethodStr = argv[argc - 4]; MassOfBeliefDefinitionMethod massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; if (massOfBeliefDefMethodStr.compare("PRECISION") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::PRECISION; } else { if (massOfBeliefDefMethodStr.compare("RECALL") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::RECALL; } else { if (massOfBeliefDefMethodStr.compare("ACCURACY") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::ACCURACY; } else { if (massOfBeliefDefMethodStr.compare("KAPPA") == 0) { massOfBeliefDefMethod = ConfusionMatrixToMassOfBeliefType::KAPPA; } } } } std::vector vectorOfMapOfClasses; std::vector vectorOfConfMatrices; for (unsigned int itCM = 0; itCM < nbClassifiers; ++itCM) { std::string fileNameConfMat = argv[itCM + 1]; MapOfClassesType mapOfClassesClk; ConfusionMatrixType confusionMatrixClk; CSVConfusionMatrixFileReader(fileNameConfMat, mapOfClassesClk, confusionMatrixClk); vectorOfMapOfClasses.push_back(mapOfClassesClk); vectorOfConfMatrices.push_back(confusionMatrixClk); } /* ***************************************************************************************** */ /* *** Extraction of the K maps of Masses of Belief (one map of MOBs for each classifier) ** */ /* ***************************************************************************************** */ // Masses of the singleton sets {Ai} for each classifier. // These masses represent the degree of belief of each classifier that the output class of the pixel X // is {Ai} when the input pixel X actually belongs to the class {Ai} MapOfClassesType mapOfClassesClk; MapOfClassesType::iterator itMapOfClassesClk; ConfusionMatrixType confMatClk; MassType mobUniverseClk; SingleClassLabelMassMapType mapMOBClk; SingleClassLabelMassMapType::iterator itMapMOBClk; ClassifierHistogramType universe; ClassifierHistogramType::iterator itUniverse; std::vector vectorMapMOBs; std::vector vectorUniverseMOBs; ConfusionMatrixToMassOfBeliefType::Pointer confMatToMass = ConfusionMatrixToMassOfBeliefType::New(); for (unsigned int itClk = 0; itClk < nbClassifiers; ++itClk) { // Classifier Cl_k: mapOfClassesClk = vectorOfMapOfClasses[itClk]; confMatClk = vectorOfConfMatrices[itClk]; // mobUniverseClk is set to zero in order to assure the correct estimation of the Belief Functions of the // complementary sets bel({Ai_}) in the optimized DS combination mobUniverseClk = 0.; confMatToMass->SetMapOfClasses(mapOfClassesClk); confMatToMass->SetConfusionMatrix(confMatClk); confMatToMass->SetDefinitionMethod(massOfBeliefDefMethod); confMatToMass->Update(); mapMOBClk.clear(); mapMOBClk = confMatToMass->GetMapMassOfBelief(); // Vector containing ALL the K std::maps of Mass of Belief vectorMapMOBs.push_back(mapMOBClk); // Vector containing the Mass of Belief of the universe for each classifier vectorUniverseMOBs.push_back(mobUniverseClk); std::cout << "confusion matrix[Cl_" << itClk << "] = " << std::endl; for (itMapOfClassesClk = mapOfClassesClk.begin(); itMapOfClassesClk != mapOfClassesClk.end(); ++itMapOfClassesClk) { IntLabelPixelType classLabel = itMapOfClassesClk->first; std::cout << "[" << classLabel << "] "; // If the current classLabel has already been added to the universe if (universe.count(classLabel) > 0) { universe[classLabel]++; } else { universe[classLabel] = 1; } } std::cout << std::endl << confMatClk << std::endl; std::cout << std::endl; for (itMapMOBClk = mapMOBClk.begin(); itMapMOBClk != mapMOBClk.end(); ++itMapMOBClk) { std::cout << "mapMOBCl_" << itClk << "[" << itMapMOBClk->first << "] = " << itMapMOBClk->second << std::endl; } std::cout << "*******************************************************************************" << std::endl; } // Number of classes in the universe // unsigned int nbClasses = universe.size(); IntMassOfBeliefFunctionType::LabelSetType universeSet, labelSet; typedef std::map IntLabelSetMapType; IntLabelSetMapType mapLabelSets; IntLabelSetMapType::iterator itMapLabelSets; std::cout << "universe:" << std::endl; for (itUniverse = universe.begin(); itUniverse != universe.end(); ++itUniverse) { std::cout << "Class Label " << itUniverse->first; std::cout << " present in " << itUniverse->second << " classifier(s)" << std::endl; universeSet.insert(itUniverse->first); labelSet.clear(); labelSet.insert(itUniverse->first); mapLabelSets[itUniverse->first] = labelSet; } std::cout << std::endl; // Vector containing the std::maps of masses of ALL the singleton sets for each classifier k IntMassMapType mClk; std::vector mClVector; for (unsigned int itClk = 0; itClk < nbClassifiers; ++itClk) { mapMOBClk = vectorMapMOBs[itClk]; mClk.clear(); for (itMapMOBClk = mapMOBClk.begin(); itMapMOBClk != mapMOBClk.end(); ++itMapMOBClk) { labelSet = mapLabelSets[itMapMOBClk->first]; mClk[labelSet] = itMapMOBClk->second; } mClVector.push_back(mClk); } /* ***************************************************************************************** */ /* ************************ RESULTS OF THE CLASSIFICATION OF PIXEL X *********************** */ /* ***************************************************************************************** */ // Values (as IntLabelPixelType) of the K CLASSIFICATION MAPS for the pixel X typedef std::vector IntLabelSetOfVectorType; IntLabelSetOfVectorType classifiedPixelX; classifiedPixelX.push_back(mapLabelSets[2]); classifiedPixelX.push_back(mapLabelSets[2]); classifiedPixelX.push_back(mapLabelSets[2]); classifiedPixelX.push_back(mapLabelSets[2]); classifiedPixelX.push_back(mapLabelSets[2]); classifiedPixelX.push_back(mapLabelSets[2]); // With merged classes classifiedPixelX.push_back(mapLabelSets[4]); classifiedPixelX.push_back(mapLabelSets[2]); classifiedPixelX.push_back(mapLabelSets[3]); //********************************************************************** //***************************** DS FUSION ****************************** //********************************************************************** IntMassOfBeliefFunctionType::LabelSetType labelSetClk, labelSetClk_; MassType mLabelSetClk, mLabelSetClk_, mUniverseClk; IntMassOfBeliefFunctionType::Pointer mOBFClk; IntJointMassOfBeliefFilterType::Pointer jointMassClkFilter; jointMassClkFilter = IntJointMassOfBeliefFilterType::New(); for (unsigned int itk = 0; itk < classifiedPixelX.size(); ++itk) { // Allocation of a new MassOfBeliefFunctionType::Pointer object pointing at a new memory address mOBFClk = IntMassOfBeliefFunctionType::New(); labelSetClk = classifiedPixelX[itk]; // Label of the classified pixel X: {a}, {b} or {c} here // Defining the complementary singleton set {Ai_} labelSetClk_ = universeSet; labelSetClk_.erase(*labelSetClk.begin()); // Setting the masses of the three focal elements {Ai}, {Ai_} and OMEGA = {Ai U Ai_} // Extraction of mk({Ai}) = mLabelClk of the classifier k for the labelSetClk = {Ai} mUniverseClk = mClVector[itk][universeSet]; mLabelSetClk = mClVector[itk][labelSetClk]; mLabelSetClk_ = 1 - mLabelSetClk - mUniverseClk; // Defining the MassOfBeliefFunctionType::Pointer object mOBFClk for the classifier k mOBFClk->InitializePowerSetMasses(universeSet); mOBFClk->SetMass(labelSetClk, mLabelSetClk); mOBFClk->SetMass(labelSetClk_, mLabelSetClk_); mOBFClk->EstimateUncertainty(); jointMassClkFilter->PushBackInput(mOBFClk); } jointMassClkFilter->Update(); IntMassOfBeliefFunctionType::Pointer jointMass = jointMassClkFilter->GetOutput(); std::cout << "****************************************************************************" << std::endl; std::cout << "jointMassClkFilter = " << jointMassClkFilter << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << std::endl; std::cout << "****************************************************************************" << std::endl; std::cout << "jointMassOfBelief = " << jointMass << std::endl; std::cout << "****************************************************************************" << std::endl; // The decision for the DS Fusion is made with the MAXIMAL Belief function: // {Ai} is chosen if Bel({Ai}) = MAX(Bel({Aj})) IntMassOfBeliefFunctionType::LabelSetType fusedDSLabelSet; MassType fusedDSBelLabelSetClk = 0; //Here the MAX of Bel(Ai) for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; labelSetClk_ = universeSet; labelSetClk_.erase(*labelSetClk.begin()); if (itMapLabelSets == mapLabelSets.begin()) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = jointMass->GetBelief(labelSetClk); } else { if (jointMass->GetBelief(labelSetClk) >= fusedDSBelLabelSetClk) { fusedDSLabelSet = labelSetClk; fusedDSBelLabelSetClk = jointMass->GetBelief(labelSetClk); } } std::cout << "Bel(" << labelSetClk << ") = " << jointMass->GetBelief(labelSetClk) << std::endl; std::cout << "Bel(NOT_" << labelSetClk << ") = Bel(" << labelSetClk_ << ") = " << jointMass->GetBelief(labelSetClk_) << std::endl; std::cout << std::endl; } //If the DS VOTED LABEL is NOT unique for (itMapLabelSets = mapLabelSets.begin(); itMapLabelSets != mapLabelSets.end(); ++itMapLabelSets) { labelSetClk = itMapLabelSets->second; if ((jointMass->GetBelief(labelSetClk) == fusedDSBelLabelSetClk) && (labelSetClk != fusedDSLabelSet)) { fusedDSLabelSet.insert(itMapLabelSets->first); } } std::cout << "****************************************************************************" << std::endl; std::cout << "fusedDSLabelSet = " << fusedDSLabelSet << std::endl; std::cout << "fusedDSBelLabelSetClk = " << fusedDSBelLabelSetClk << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/DempsterShafer/test/otbDempsterShaferTestDriver.cxx000066400000000000000000000016601301006202600306440ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMassOfBeliefDSApplied); REGISTER_TEST(otbConfusionMatrixToMassOfBeliefNew); REGISTER_TEST(otbConfusionMatrixToMassOfBeliefTest); REGISTER_TEST(otbVectorDataToDSValidatedVectorDataFilterNew); REGISTER_TEST(otbVectorDataToDSValidatedVectorDataFilter); REGISTER_TEST(otbDempsterShaferFusionOptRecConfMatTest); REGISTER_TEST(otbDempsterShaferFusionOptRecTest); REGISTER_TEST(otbDempsterShaferFusionOptTest); REGISTER_TEST(otbDempsterShaferFusionTest); REGISTER_TEST(otbDempsterShaferFusionOptRecConfMatFileTest); REGISTER_TEST(otbDempsterShaferFusionConfMatFileTest); REGISTER_TEST(otbDSFusionOfClassifiersImageFilterNew); REGISTER_TEST(otbDSFusionOfClassifiersImageFilterTest); REGISTER_TEST(otbJointMassOfBeliefFilter); REGISTER_TEST(otbJointMassOfBeliefFilterLimit); REGISTER_TEST(otbMassOfBelief); REGISTER_TEST(otbStandardDSCostFunctionNew); } OTB-release-5.8/Modules/Learning/DempsterShafer/test/otbJointMassOfBeliefFilter.cxx000066400000000000000000000111431301006202600303620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMassOfBelief.h" #include "otbJointMassOfBeliefFilter.h" #include "otbMath.h" int otbJointMassOfBeliefFilter(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef otb::MassOfBelief MassOfBeliefFunctionType; typedef otb::JointMassOfBeliefFilter JointMassOfBeliefFilterType; std::vector baseline, results; baseline.push_back(0.); baseline.push_back(0.130725); baseline.push_back(0.346374); baseline.push_back(0.477099); baseline.push_back(0.522901); baseline.push_back(0.653626); baseline.push_back(0.869275); baseline.push_back(1.); MassOfBeliefFunctionType::Pointer mass1 = MassOfBeliefFunctionType::New(); MassOfBeliefFunctionType::Pointer mass2 = MassOfBeliefFunctionType::New(); JointMassOfBeliefFilterType::Pointer jointMassFilter = JointMassOfBeliefFilterType::New(); MassOfBeliefFunctionType::LabelSetType universe; universe.insert("a"); universe.insert("b"); universe.insert("c"); universe.insert("d"); mass1->InitializePowerSetMasses(universe); mass2->InitializePowerSetMasses(universe); MassOfBeliefFunctionType::LabelSetType a, b, c, d, hyp; a.insert("a"); b.insert("b"); c.insert("c"); d.insert("d"); mass1->SetMass(a, 0.); mass1->SetMass(b, 0.8); mass1->EstimateUncertainty(); mass2->SetMass(c, 0.); mass2->SetMass(d, 0.726); mass2->EstimateUncertainty(); // Compute joint mass jointMassFilter->PushBackInput(mass1); jointMassFilter->PushBackInput(mass2); jointMassFilter->Update(); MassOfBeliefFunctionType::Pointer jointMass = jointMassFilter->GetOutput(); hyp.clear(); hyp.insert("a"); hyp.insert("c"); results.push_back(jointMass->GetBelief(hyp)); results.push_back(jointMass->GetPlausibility(hyp)); hyp.clear(); hyp.insert("a"); hyp.insert("d"); results.push_back(jointMass->GetBelief(hyp)); results.push_back(jointMass->GetPlausibility(hyp)); hyp.clear(); hyp.insert("b"); hyp.insert("c"); results.push_back(jointMass->GetBelief(hyp)); results.push_back(jointMass->GetPlausibility(hyp)); hyp.clear(); hyp.insert("b"); hyp.insert("d"); results.push_back(jointMass->GetBelief(hyp)); results.push_back(jointMass->GetPlausibility(hyp)); for (unsigned int i=0; i= .000001) { std::cout << "Non-regression test [" << i << "] failed: " << "baseline[i](" << baseline[i] << ") != results[i](" << results[i] << std::endl; return EXIT_FAILURE; } } return EXIT_SUCCESS; } int otbJointMassOfBeliefFilterLimit(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef otb::MassOfBelief MassOfBeliefFunctionType; typedef otb::JointMassOfBeliefFilter JointMassOfBeliefFilterType; MassOfBeliefFunctionType::Pointer mass1 = MassOfBeliefFunctionType::New(); MassOfBeliefFunctionType::Pointer mass2 = MassOfBeliefFunctionType::New(); JointMassOfBeliefFilterType::Pointer jointMassFilter = JointMassOfBeliefFilterType::New(); // Example from // http://www.sandia.gov/epistemic/Reports/SAND2002-0835.pdf // page 27 MassOfBeliefFunctionType::LabelSetType universe; universe.insert("a"); universe.insert("b"); universe.insert("c"); mass1->InitializePowerSetMasses(universe); mass2->InitializePowerSetMasses(universe); MassOfBeliefFunctionType::LabelSetType a, b, c; a.insert("a"); b.insert("b"); c.insert("c"); // Mass1 is first expert mass1->SetMass(a, 0.99); mass1->SetMass(b, 0.01); // Mass2 is second expert mass2->SetMass(b, 0.01); mass2->SetMass(c, 0.99); // Compute joint mass jointMassFilter->PushBackInput(mass1); jointMassFilter->PushBackInput(mass2); jointMassFilter->Update(); MassOfBeliefFunctionType::Pointer jointMass = jointMassFilter->GetOutput(); std::cout<<"Mass 1: "< MassOfBeliefFunctionType; int otbMassOfBelief(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { // Instantiate function MassOfBeliefFunctionType::Pointer massFunction = MassOfBeliefFunctionType::New(); MassOfBeliefFunctionType::LabelSetType set1, set2, set3, set4; set1.insert("white"); set1.insert("blue"); set2.insert("white"); set2.insert("green"); set3.insert("red"); set3.insert("green"); set4.insert("white"); set4.insert("green"); set4.insert("red"); massFunction->SetMass(set1, 0.25); massFunction->SetMass(set2, 0.3); massFunction->SetMass(set4, 0.1); std::cout<RemoveMass(set4); std::cout<EstimateUncertainty(); std::cout<RemoveMass(set2); massFunction->SetMass(set3, 0.6); std::cout<Normalize(); std::cout<GetBelief(set3)<GetPlausibility(set3)<InitializePowerSetMasses(otherSet); std::cout< FuzzyVarType; typedef otb::MassOfBelief MassOfBeliefFunctionType; typedef otb::JointMassOfBeliefFilter JointMassOfBeliefFilterType; int otbMassOfBeliefDSApplied(int itkNotUsed(argc), char* argv[]) { const char * hyp_1 = argv[1]; const char * hyp_2 = argv[2]; double desc1Val = atof(argv[3]); double desc2Val = atof(argv[4]); // Descriptors and associated fuzzy variables FuzzyVarType::Pointer desc1 = FuzzyVarType::New(); FuzzyVarType::Pointer desc2 = FuzzyVarType::New(); desc1->SetMembership("H1", 0, 0, 0.1, 0.5, 0, 0.8); desc1->SetMembership("H1_", 0.5, 0.8, 1.0, 1.0, 0, 0.8); desc2->SetMembership("H2", 0, 0, 0.58, 0.68, 0, 0.99); desc2->SetMembership("H2_", 0.68, 0.98, 1.0, 1.0, 0, 0.99); // Corresponding masses MassOfBeliefFunctionType::Pointer mass1 = MassOfBeliefFunctionType::New(); MassOfBeliefFunctionType::Pointer mass2 = MassOfBeliefFunctionType::New(); MassOfBeliefFunctionType::Pointer jointMass = MassOfBeliefFunctionType::New(); MassOfBeliefFunctionType::LabelSetType H1, H1_, H2, H2_, universe, Hyp; // Defining universe universe.insert("H1"); universe.insert("H1_"); universe.insert("H2"); universe.insert("H2_"); // Studied hypothesis Hyp.insert(hyp_1); Hyp.insert(hyp_2); // Initialize masses mass1->InitializePowerSetMasses(universe); mass2->InitializePowerSetMasses(universe); H1.insert("H1"); H1_.insert("H1_"); mass1->SetMass(H1, desc1->GetMembership("H1", desc1Val)); mass1->SetMass(H1_, desc1->GetMembership("H1_", desc1Val)); mass1->EstimateUncertainty(); H2.insert("H2"); H2_.insert("H2_"); mass2->SetMass(H2, desc2->GetMembership("H2", desc2Val)); mass2->SetMass(H2_, desc2->GetMembership("H2_", desc2Val)); mass2->EstimateUncertainty(); JointMassOfBeliefFilterType::Pointer jointMassFilter = JointMassOfBeliefFilterType::New(); // Compute joint mass jointMassFilter->PushBackInput(mass1); jointMassFilter->PushBackInput(mass2); jointMassFilter->Update(); jointMass = jointMassFilter->GetOutput(); std::cout<GetBelief(Hyp) << " - Plausibility(Hyp) : " << jointMass->GetPlausibility(Hyp) << " - Score(Hyp) : " << (jointMass->GetBelief(Hyp) + jointMass->GetPlausibility(Hyp))/2.0 << std::endl; if (jointMass->GetBelief(Hyp) > jointMass->GetPlausibility(Hyp)) { std::cout << "Belief > Plausibility" << std::endl; return EXIT_FAILURE; } else { return EXIT_SUCCESS; } } OTB-release-5.8/Modules/Learning/DempsterShafer/test/otbStandardDSCostFunction.cxx000066400000000000000000000023071301006202600302410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbStandardDSCostFunction.h" int otbStandardDSCostFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PrecisionType; typedef otb::VectorData VectorDataType; typedef otb::VectorDataToDSValidatedVectorDataFilter VectorDataValidationFilterType; typedef otb::StandardDSCostFunction CostFunctionType; CostFunctionType::Pointer costFunction = CostFunctionType::New(); std::cout< VectorDataType; typedef otb::VectorDataToDSValidatedVectorDataFilter VectorDataValidationFilterType; VectorDataValidationFilterType::Pointer filter = VectorDataValidationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbVectorDataToDSValidatedVectorDataFilter(int itkNotUsed(argc), char* argv[]) { const char * inputVD = argv[1]; const char * outputVD = argv[2]; typedef float PrecisionType; typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef otb::VectorDataToDSValidatedVectorDataFilter VectorDataValidationFilterType; typedef VectorDataValidationFilterType::LabelSetType LabelSetType; typedef otb::FuzzyDescriptorsModelManager FuzzyManagerType; VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); VectorDataValidationFilterType::Pointer filter = VectorDataValidationFilterType::New(); vdReader->SetFileName(inputVD); vdReader->Update(); filter->SetInput(vdReader->GetOutput()); //filter->GetDescriptorModels(); FuzzyManagerType::Print(filter->GetDescriptorModels()); LabelSetType plau, bel; plau.insert("NONDVI"); plau.insert("ROADSA"); plau.insert("NOBUIL"); filter->SetPlausibilityHypothesis(plau); bel.insert("ROADSA"); bel.insert("NONDVI"); bel.insert("NOBUIL"); filter->SetBeliefHypothesis(bel); std::vector stdModel; stdModel.push_back(0.25); stdModel.push_back(0.50); stdModel.push_back(0.75); stdModel.push_back(0.90); filter->AddDescriptor("NONDVI", stdModel); filter->AddDescriptor("ROADSA", stdModel); filter->AddDescriptor("NOBUIL", stdModel); FuzzyManagerType::Print(filter->GetDescriptorModels()); vdWriter->SetFileName(outputVD); vdWriter->SetInput(filter->GetOutput()); vdWriter->Update(); std::cout << "Input VectorData Size : " << vdReader->GetOutput()->Size() << std::endl << "CriterionFormula : " << filter->GetCriterionFormula() << std::endl << "Output VecttorData Size : " << filter->GetOutput()->Size() << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/LearningBase/000077500000000000000000000000001301006202600211175ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/LearningBase/CMakeLists.txt000066400000000000000000000000541301006202600236560ustar00rootroot00000000000000project(OTBLearningBase) otb_module_impl() OTB-release-5.8/Modules/Learning/LearningBase/include/000077500000000000000000000000001301006202600225425ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/LearningBase/include/otbDecisionTree.h000066400000000000000000000101531301006202600257750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecisionTree_h #define otbDecisionTree_h #include #include "itkObjectFactory.h" #include "itkDataObject.h" namespace otb { /** * \class DecisionTree * \brief Models a decision tree * * A decision tree holds an attribute that is being tested and 2 * maps (STL): one for subtrees and anoter for labels (for the case * where there are no subtrees). These maps as keys a pair (STL) which * holds the value of the attribute being tested as well as the type * of test (LT, LE, EQ, GE, GT). * * In order to build a tree, one uses the method AddBranch. There are * 2 versions of this method: one for adding a subtree, and another * for adding labels in the case of leaf nodes. Each of these versions * has a syntactic sugar version for the case of EQ test. * * This implementation does not use different classes for terminal and * non terminal nodes for simplicity and follows the implementation * suggested by P. Norvig in the python version of the AIMA code which * is available at * http://aima-python.googlecode.com/svn/trunk/learning.py * * In the case of several terminal nodes being eligible, the first is returned. * * \sa DecisionTreeClassifier * \sa DecisionTreeEstimator * * \ingroup OTBLearningBase */ template class ITK_EXPORT DecisionTree : public itk::DataObject { public: enum DecisionTreeTestType { MIN, LT=MIN, LE, EQ, GE, GT, MAX=GT}; /** Standard typedefs */ typedef DecisionTree Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(DecisionTree, DataObject); typedef typename std::pair< AttributeValueType, DecisionTreeTestType > KeyType; typedef typename std::map< KeyType, Pointer > TreeMapType; typedef typename std::map< KeyType, LabelType > LabelMapType; typedef std::vector ExampleType; itkSetMacro(Attribute, unsigned int); itkGetMacro(Attribute, unsigned int); /** Add a subtree on the tested attribute*/ void AddBranch(AttributeValueType attr, DecisionTreeTestType testType, Pointer branch); /** Add a subtree on the tested attribute - syntactic sugar for the EQ case*/ void AddBranch(AttributeValueType attr, Pointer branch); /** Add a leaf node on the tested attribute*/ void AddBranch(AttributeValueType attr, DecisionTreeTestType testType, LabelType label); /** Add a leaf node on the tested attribute - syntactic sugar for the EQ case*/ void AddBranch(AttributeValueType attr, LabelType label); LabelType Decide(const ExampleType example); protected: /** Constructor */ DecisionTree(); /** Destructor */ ~DecisionTree() ITK_OVERRIDE; /** Output information redefinition */ /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: DecisionTree(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** Map holding the subtrees */ TreeMapType* m_TreeMap; /** Map holding the labels if final node */ LabelMapType m_LabelMap; /** The attribute number (in the vector) being tested */ unsigned int m_Attribute; /** Is the tree a final node? */ bool m_IsFinal; LabelType m_Label; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDecisionTree.txx" #endif #endif OTB-release-5.8/Modules/Learning/LearningBase/include/otbDecisionTree.txx000066400000000000000000000133341301006202600263750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecisionTree_txx #define otbDecisionTree_txx #include "otbDecisionTree.h" #include "otbMacro.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template DecisionTree ::DecisionTree() { m_TreeMap = new TreeMapType; m_IsFinal = true; m_Label = static_cast(0); } /** * Destructor */ template DecisionTree ::~DecisionTree() { delete m_TreeMap; } template void DecisionTree ::AddBranch(AttributeValueType attr, DecisionTreeTestType testType, Pointer branch) { m_IsFinal = false; KeyType key = KeyType(attr, testType); (*m_TreeMap)[key] = branch; } template void DecisionTree ::AddBranch(AttributeValueType attr, Pointer branch) { m_IsFinal = false; KeyType key = KeyType(attr, EQ); (*m_TreeMap)[key] = branch; } template void DecisionTree ::AddBranch(AttributeValueType attr, DecisionTreeTestType testType, LabelType label) { m_IsFinal = true; KeyType key = KeyType(attr, testType); m_LabelMap[key] = label; } template void DecisionTree ::AddBranch(AttributeValueType attr, LabelType label) { m_IsFinal = true; KeyType key = KeyType(attr, EQ); m_LabelMap[key] = label; } template LabelType DecisionTree ::Decide(const ExampleType example) { AttributeValueType attrValue = example[m_Attribute]; otbMsgDevMacro( << "Trying to match attribute " << m_Attribute << " with value " << attrValue ); bool found = false; KeyType key; if( m_IsFinal ) { typename LabelMapType::const_iterator lmIt = m_LabelMap.begin(); while( lmIt != m_LabelMap.end() ) { KeyType theKey = lmIt->first; DecisionTreeTestType theTest = theKey.second; AttributeValueType theValue = theKey.first; switch( theTest ) { case LT: if( attrValue < theValue ) return lmIt->second; break; case LE: if( attrValue <= theValue ) return lmIt->second; break; case EQ: if( attrValue == theValue ) return lmIt->second; break; case GE: if( attrValue >= theValue ) return lmIt->second; break; case GT: if( attrValue > theValue ) return lmIt->second; break; } ++lmIt; } // if we get here it means that a verified test was not found itkGenericExceptionMacro(<< "Example could not be handled by decision tree."); } else { found = false; // Look for branches matching the test on the attribute std::vector< KeyType > candidateKeys; typename TreeMapType::const_iterator tmIt = m_TreeMap->begin(); while( tmIt != m_TreeMap->end() ) { KeyType theKey = tmIt->first; DecisionTreeTestType theTest = theKey.second; AttributeValueType theValue = theKey.first; switch( theTest ) { case LT: if( attrValue < theValue ) { candidateKeys.push_back( theKey ); found = true; } break; case LE: if( attrValue <= theValue ) { candidateKeys.push_back( theKey ); found = true; } break; case EQ: if( attrValue == theValue ) { candidateKeys.push_back( theKey ); found = true; } break; case GE: if( attrValue >= theValue ) { candidateKeys.push_back( theKey ); found = true; } break; case GT: if( attrValue > theValue ) { candidateKeys.push_back( theKey ); found = true; } break; } ++tmIt; } if( ! found ) // attribute // not found // in the map { itkGenericExceptionMacro(<< "Example could not be handled by decision tree."); } else { // If we found one or several matching tests typename std::vector< KeyType >::const_iterator ckIt = candidateKeys.begin(); while ( ckIt != candidateKeys.end() ) { otbMsgDevMacro(<< (*ckIt).first << " " << (*ckIt).second); Pointer child = (*m_TreeMap)[(*ckIt)]; return child->Decide(example); } } } //added return statement to suppress warning, but if/then/else //conditions make sure it is never reached return static_cast(0); } /** *PrintSelf method */ template void DecisionTree ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/LearningBase/include/otbGaussianModelComponent.h000066400000000000000000000072771301006202600300530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGaussianModelComponent_h #define otbGaussianModelComponent_h #include "itkCovarianceSampleFilter.h" #include "itkGaussianMembershipFunction.h" #include "otbModelComponentBase.h" namespace otb { namespace Statistics { /** \class GaussianModelComponent * \brief is a component (derived from ModelComponentBase) for * Gaussian class. This class is used in SEMClassifier * * Recent API changes: * N/A * * \sa ModelComponentBase, SEMClassifier * * \ingroup OTBLearningBase */ template class ITK_EXPORT GaussianModelComponent : public ModelComponentBase { public: /**Standard class typedefs. */ typedef GaussianModelComponent Self; typedef ModelComponentBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /**Standard Macros */ itkNewMacro(Self); itkTypeMacro(GaussianModelComponent, ModelComponentBase); /** Typedefs from the superclass */ typedef typename Superclass::MeasurementVectorType MeasurementVectorType; typedef typename Superclass::MeasurementVectorSizeType MeasurementVectorSizeType; typedef typename Superclass::MembershipFunctionType MembershipFunctionType; typedef typename Superclass::ParametersType ParametersType; /** Type of the membership function. Gaussian density function */ typedef itk::Statistics::GaussianMembershipFunction NativeMembershipFunctionType; typedef typename NativeMembershipFunctionType::MeanVectorType MeanVectorType; /** Types of the mean and the covariance calculator that will update * this component's distribution parameters */ typedef itk::Statistics::CovarianceSampleFilter CovarianceEstimatorType; /** types of the covariance to be used by the * NativeMembershipFunctionType */ typedef typename CovarianceEstimatorType::MatrixType CovarianceType; /** Sets the input sample */ void SetSample(const TSample* sample) ITK_OVERRIDE; /** Sets the component's distribution parameters. * e.g. Then user can call directly Pdf( MeasurementVectorType & ) */ void SetParameters(const ParametersType& parameters); /** Show the parameters in a minimal form in comparison to PrintSelf */ void ShowParameters(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; protected: GaussianModelComponent(); ~GaussianModelComponent() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: GaussianModelComponent(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename NativeMembershipFunctionType::Pointer m_GaussianMembershipFunction; // TODO ajouter un m_GaussianCumulativeFunction typename CovarianceEstimatorType::Pointer m_CovarianceEstimator; MeanVectorType m_Mean; CovarianceType m_Covariance; }; // end of class } // end of namespace Statistics } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGaussianModelComponent.txx" #endif #endif OTB-release-5.8/Modules/Learning/LearningBase/include/otbGaussianModelComponent.txx000066400000000000000000000122401301006202600304310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGaussianModelComponent_txx #define otbGaussianModelComponent_txx #include #include "itkNumericTraits.h" #include "otbMacro.h" #include "otbGaussianModelComponent.h" namespace otb { namespace Statistics { template GaussianModelComponent ::GaussianModelComponent() { m_CovarianceEstimator = ITK_NULLPTR; m_GaussianMembershipFunction = ITK_NULLPTR; } template void GaussianModelComponent ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Mean Estimator: " << m_CovarianceEstimator << std::endl; os << indent << "Covariance Estimator: " << m_CovarianceEstimator << std::endl; os << indent << "GaussianMembershipFunction: " << m_GaussianMembershipFunction << std::endl; } template void GaussianModelComponent ::ShowParameters(std::ostream& os, itk::Indent indent) const { unsigned int i, j; os << indent << "Gaussian model component : \n"; os << indent << "Mean : "; for (i = 0; i < m_Mean.Size(); ++i) os << m_Mean[i] << "\t"; os << "\n" << indent << "Covariance : "; for (i = 0; i < m_Mean.Size(); ++i) { for (j = 0; j < m_Mean.Size(); ++j) os << m_Covariance(i, j) << "\t"; os << "\n" << indent << " "; } os << "\n"; } template void GaussianModelComponent ::SetSample(const TSample* sample) { Superclass::SetSample(sample); const MeasurementVectorSizeType measurementVectorLength = sample->GetMeasurementVectorSize(); this->m_Parameters.SetSize(measurementVectorLength * (1 + measurementVectorLength)); // Set the size of the mean vector m_Mean.SetSize(measurementVectorLength); // Set the parameters of the mean (internally) and the covariance estimator m_Covariance.SetSize(measurementVectorLength, measurementVectorLength); m_CovarianceEstimator = CovarianceEstimatorType::New(); m_CovarianceEstimator->SetInput(sample); m_CovarianceEstimator->Update(); m_GaussianMembershipFunction = NativeMembershipFunctionType::New(); this->m_PdfFunction = (MembershipFunctionType *) m_GaussianMembershipFunction; m_GaussianMembershipFunction->SetMeasurementVectorSize( measurementVectorLength); this->SetPdfMembershipFunction((MembershipFunctionType *) m_GaussianMembershipFunction.GetPointer()); } template void GaussianModelComponent ::SetParameters(const ParametersType& parameters) { Superclass::SetParameters(parameters); unsigned int paramIndex = 0; unsigned int i, j; MeasurementVectorSizeType measurementVectorSize = this->GetSample()->GetMeasurementVectorSize(); m_Mean.SetSize (measurementVectorSize); for (i = 0; i < measurementVectorSize; i++) { m_Mean[i] = parameters[paramIndex]; paramIndex++; } m_Covariance.SetSize(measurementVectorSize, measurementVectorSize); for (i = 0; i < measurementVectorSize; i++) for (j = 0; j < measurementVectorSize; j++) { m_Covariance(i, j) = parameters[paramIndex]; paramIndex++; } this->m_GaussianMembershipFunction->SetMean(m_Mean); this->m_GaussianMembershipFunction->SetCovariance(&m_Covariance); } template void GaussianModelComponent ::GenerateData() { if (this->IsSampleModified() == 0) return; MeasurementVectorSizeType measurementVectorSize = this->GetSample()->GetMeasurementVectorSize(); unsigned int i, j; int paramIndex = 0; // Get the mean using the convariance estimator (computed internally) typename CovarianceEstimatorType::MeasurementVectorType meanOutput = m_CovarianceEstimator->GetMean(); for (i = 0; i < measurementVectorSize; i++) { m_Mean.SetElement(i,meanOutput.GetElement(i)); this->m_Parameters[paramIndex] = meanOutput.GetElement(i); ++paramIndex; } // Get the covariance matrix and fill the parameters vector const typename CovarianceEstimatorType::MatrixType covariance = m_CovarianceEstimator->GetCovarianceMatrix(); for (i = 0; i < measurementVectorSize; i++) for (j = 0; j < measurementVectorSize; j++) { this->m_Parameters[paramIndex] = covariance.GetVnlMatrix().get(i, j); m_Covariance(i, j) = covariance.GetVnlMatrix().get(i, j); paramIndex++; } this->m_GaussianMembershipFunction->SetMean(meanOutput); this->m_GaussianMembershipFunction->SetCovariance(m_Covariance); Superclass::GenerateData(); } } // end of namespace Statistics } // end of namesapce otb #endif OTB-release-5.8/Modules/Learning/LearningBase/include/otbKMeansImageClassificationFilter.h000066400000000000000000000114401301006202600315630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKMeansImageClassificationFilter_h #define otbKMeansImageClassificationFilter_h #include "itkInPlaceImageFilter.h" #include "itkListSample.h" #include "itkEuclideanDistanceMetric.h" namespace otb { /** \class KMeansImageClassificationFilter * \brief This filter performs the classification of a VectorImage using a KMeans estimation result. * * This filter is streamed and threaded, allowing to classify huge images. Because the * internal sample type has to be an itk::FixedArray, one must specify at compilation time * the maximum sample dimension. It is up to the user to specify a MaxSampleDimension sufficiently * high to integrate all its features. This filter internally use one SVMClassifier per thread. * * \sa SVMClassifier * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBLearningBase */ template class ITK_EXPORT KMeansImageClassificationFilter : public itk::InPlaceImageFilter { public: /** Standard typedefs */ typedef KMeansImageClassificationFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(KMeansImageClassificationFilter, InPlaceImageFilter); /** The max dimension of the sample to classify. * This filter internally uses itk::FixedArray as input for the classifier, * so the max sample size has to be fixed at compilation time. */ itkStaticConstMacro(MaxSampleDimension, unsigned int, VMaxSampleDimension); typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::InternalPixelType ValueType; typedef TMaskImage MaskImageType; typedef typename MaskImageType::ConstPointer MaskImageConstPointerType; typedef typename MaskImageType::Pointer MaskImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType LabelType; typedef itk::FixedArray SampleType; typedef itk::Array KMeansParametersType; typedef std::map CentroidsMapType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; /** Set/Get the centroids */ itkSetMacro(Centroids, KMeansParametersType); itkGetConstReferenceMacro(Centroids, KMeansParametersType); /** Set/Get the default label */ itkSetMacro(DefaultLabel, LabelType); itkGetMacro(DefaultLabel, LabelType); /** * If set, only pixels within the mask will be classified. * \param mask The input mask. */ void SetInputMask(const MaskImageType * mask); /** * Get the input mask. * \return The mask. */ const MaskImageType * GetInputMask(void); protected: /** Constructor */ KMeansImageClassificationFilter(); /** Destructor */ ~KMeansImageClassificationFilter() ITK_OVERRIDE {} /** Threaded generate data */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: KMeansImageClassificationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Centroids used for classification */ KMeansParametersType m_Centroids; /** Default label for invalid pixels (when using a mask) */ LabelType m_DefaultLabel; /** Centroids - labels map */ CentroidsMapType m_CentroidsMap; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKMeansImageClassificationFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/LearningBase/include/otbKMeansImageClassificationFilter.txx000066400000000000000000000124311301006202600321600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKMeansImageClassificationFilter_txx #define otbKMeansImageClassificationFilter_txx #include "otbKMeansImageClassificationFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template KMeansImageClassificationFilter ::KMeansImageClassificationFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(1); m_DefaultLabel = itk::NumericTraits::ZeroValue(); } template void KMeansImageClassificationFilter ::SetInputMask(const MaskImageType * mask) { this->itk::ProcessObject::SetNthInput(1, const_cast(mask)); } template const typename KMeansImageClassificationFilter ::MaskImageType * KMeansImageClassificationFilter ::GetInputMask() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void KMeansImageClassificationFilter ::BeforeThreadedGenerateData() { unsigned int sample_size = MaxSampleDimension; unsigned int nb_classes = m_Centroids.Size() / sample_size; for (LabelType label = 1; label <= static_cast(nb_classes); ++label) { SampleType new_centroid; new_centroid.Fill(0); m_CentroidsMap[label] = new_centroid; for (unsigned int i = 0; i < MaxSampleDimension; ++i) { m_CentroidsMap[label][i] = static_cast(m_Centroids[MaxSampleDimension * (static_cast < unsigned int > (label) - 1) + i]); } } } template void KMeansImageClassificationFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { InputImageConstPointerType inputPtr = this->GetInput(); MaskImageConstPointerType inputMaskPtr = this->GetInputMask(); OutputImagePointerType outputPtr = this->GetOutput(); typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator MaskIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; InputIteratorType inIt(inputPtr, outputRegionForThread); OutputIteratorType outIt(outputPtr, outputRegionForThread); MaskIteratorType maskIt; if (inputMaskPtr) { maskIt = MaskIteratorType(inputMaskPtr, outputRegionForThread); maskIt.GoToBegin(); } unsigned int maxDimension = SampleType::Dimension; unsigned int sampleSize = std::min(inputPtr->GetNumberOfComponentsPerPixel(), maxDimension); bool validPoint = true; while (!outIt.IsAtEnd()) { outIt.Set(m_DefaultLabel); ++outIt; } outIt.GoToBegin(); validPoint = true; typename DistanceType::Pointer distance = DistanceType::New(); while (!outIt.IsAtEnd() && (!inIt.IsAtEnd())) { if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } if (validPoint) { LabelType label = 1; LabelType current_label = 1; SampleType pixel; pixel.Fill(0); for (unsigned int i = 0; i < sampleSize; ++i) { pixel[i] = inIt.Get()[i]; } double current_distance = distance->Evaluate(pixel, m_CentroidsMap[label]); for (label = 2; label <= static_cast(m_CentroidsMap.size()); ++label) { double tmp_dist = distance->Evaluate(pixel, m_CentroidsMap[label]); if (tmp_dist < current_distance) { current_label = label; current_distance = tmp_dist; } } outIt.Set(current_label); } ++outIt; ++inIt; } } /** * PrintSelf Method */ template void KMeansImageClassificationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Learning/LearningBase/include/otbSEMClassifier.h000066400000000000000000000204071301006202600260540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSEMClassifier_h #define otbSEMClassifier_h #include "itkListSample.h" #include "itkSampleClassifierFilter.h" #include "otbGaussianModelComponent.h" namespace otb { /** \class SEMClassifier * \brief This class implements the Stochastic Expectation * Maximization algorithm to perform an estimation of a mixture model. * * The first template argument is the type of the target sample * data. This estimator expects one or more model component objects * of the classes derived from the ModelComponentBase. The actual * component (or module) parameters are updated by each component. * Users can think this class as a strategy or a integration point * for the SEM procedure. * * The number of classes (SetNumberOfClasses), the initial * proportion (SetInitialProportions), the input sample (SetSample), * the model components (AddComponent), and the maximum iteration * (SetMaximumIteration) are required. The SEM procedure terminates * when the current iteration reaches the maximum iteration or the model * parameters converge. * * The difference from ExpectationMaximizationMixtureModelEstimator is * that SEMClassifier include the maximum a posteriori decision on each * sample. The class is to be seen as a classification and not an estimator. * * Recent API changes: * N/A * * \sa ModelComponentBase, GaussianModelComponent * * \ingroup OTBLearningBase */ template class ITK_EXPORT SEMClassifier : public itk::Statistics::SampleClassifierFilter< typename itk::Statistics::ListSample > { public: /** Standard class typedef*/ typedef SEMClassifier Self; typedef itk::Statistics::SampleClassifierFilter< typename itk::Statistics::ListSample > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkTypeMacro(SEMClassifier, itk::Object); itkNewMacro(Self); /** TSample template argument related typedefs */ typedef typename itk::Statistics::ListSample SampleType; typedef typename itk::Statistics::Subsample ClassSampleType; typedef typename SampleType::MeasurementType MeasurementType; typedef typename SampleType::MeasurementVectorType MeasurementVectorType; /** Type of the segmentation vector */ typedef unsigned int ClassLabelType; typedef std::vector ClassLabelVectorType; /** Output type for GetClassSample method */ typedef itk::Statistics::MembershipSample OutputType; /** Type of the mixture model component base class. * Due to the stochastic purpose, the initial list of sample (from TInputImage) * is duplicated as many times as the number of classes (into SampleLists). */ typedef otb::Statistics::ModelComponentBase ComponentType; typedef typename ComponentType::Pointer ComponentPointerType; /** Type of the component pointer storage, one component per class */ typedef std::vector ComponentVectorType; /** type of the parameters needed for the component vectors */ typedef itk::Array ParameterType; /** Type of the parameter pointer storage, one parameter set per class */ typedef std::vector ParameterVectorType; /** Type of the vector of the probability values for each sample */ typedef std::vector ProportionVectorType; typedef std::vector ProbaVectorType; /** Type of the probability values of each sample per class */ typedef std::vector ProbaByClassVectorType; /** Sets the target data that will be classified by this */ void SetSample(const TInputImage * sample); /** Returns the target data */ const TInputImage* GetSample() const; SampleType * GetSampleList() const; /** Set/Gets the initial proportion values. The size of proportion * vector should be same as the number of component (or classes). * Choose between SetInitialProportions, SetClassLabels or * SetNumberOfComponents */ void SetInitialProportions(ProportionVectorType& propotion); ProportionVectorType* GetInitialProportions(); /** Gets the result proportion values */ ProportionVectorType* GetProportions(); /** Set/Gets the initial segmentation. the size of the vector should be * the same as the number of samples (length of MeasurementVector) */ void SetClassLabels(OutputType * labels); void SetClassLabels(TOutputImage * imgLabels); ClassLabelVectorType& GetClassLabels(); /** Set/Gets the maximum number of iterations. When the optimization * process reaches the maximum number of interations, even if the * class parameters aren't converged, the optimization process * stops. */ itkSetMacro(MaximumIteration, int); itkGetMacro(MaximumIteration, int); /** Set/Gets the neighborhood to take into consideration * in the contextual decision rule. Should be odd (def. 3). */ void SetNeighborhood(int neighborhood); int GetNeighborhood(); /** Gets the current iteration. */ int GetCurrentIteration(); /** Adds a new component (or class). Has to be called after SetNumberOfClasses */ int AddComponent(int id, ComponentType* component); /** Runs the optimization process. */ void Update() ITK_OVERRIDE; /** Termination status after running optimization */ typedef enum { CONVERGED = 0, NOT_CONVERGED = 1 } TerminationCodeType; /** Set/Get the termination threshold (ratio of the number of sample that * change affected class during interation over the total number of * samples (def is 1E-5) */ itkSetMacro(TerminationThreshold, double); itkGetMacro(TerminationThreshold, double); /** Gets the termination status */ itkGetMacro(TerminationCode, TerminationCodeType); /* Return the classification result (as a standard classification result) */ OutputType * GetOutput(); /* Return the classification result (as an image) */ TOutputImage * GetOutputImage(); void Modified() const ITK_OVERRIDE; protected: SEMClassifier(); ~SEMClassifier() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Initialize the first segmentation, either randomly or by using * a ClassLabelVectorType given in SetClassLabels. */ void InitParameters(); /** Stochastic part of the SEM */ void PerformStochasticProcess(); /** Estimation part of the SEM */ void PerformExpectationProcess(); /** Maximization part of the SEM. * This method should be upgraded this a contextual point of view... * It required to a Neighborhood knowledge into the TSample type... */ void PerformMaximizationProcess(); /** Make Decision through a Maximum a posteriori */ void GetMaximumAposterioriLabels(); private: /** Target data sample pointer*/ const TInputImage* m_Sample; int m_NbSamples; typename SampleType::Pointer m_SampleList; int m_MaximumIteration; int m_CurrentIteration; int m_NbChange; double m_TerminationThreshold; int m_Neighborhood; TerminationCodeType m_TerminationCode; mutable ComponentVectorType m_ComponentVector; ProportionVectorType m_InitialProportions; ProportionVectorType m_Proportions; ProbaByClassVectorType m_Proba; ClassLabelVectorType m_ClassLabels; int m_ExternalLabels; mutable int m_ComponentDeclared; typename TOutputImage::Pointer m_OutputImage; typename OutputType::Pointer m_Output; }; // end of class } // end of namespace #ifndef OTB_MANUAL_INSTANTIATION #include "otbSEMClassifier.txx" #endif #endif OTB-release-5.8/Modules/Learning/LearningBase/include/otbSEMClassifier.txx000066400000000000000000000500221301006202600264440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are covered by the IMT copyright. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSEMClassifier_txx #define otbSEMClassifier_txx #include #include #include "itkNumericTraits.h" #include "itkImageIterator.h" #include "itkImageRegionIterator.h" #include "otbMacro.h" // default mixture model #include "otbSEMClassifier.h" namespace otb { template SEMClassifier ::SEMClassifier() { m_TerminationCode = NOT_CONVERGED; m_ExternalLabels = 0; m_ComponentDeclared = 0; m_Sample = ITK_NULLPTR; m_NbSamples = 0; m_SampleList = ITK_NULLPTR; m_NbChange = 0; m_TerminationThreshold = 1E-5; m_Neighborhood = 1; m_OutputImage = ITK_NULLPTR; m_Output = ITK_NULLPTR; } template void SEMClassifier ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); const unsigned int nbClasses = this->GetNumberOfClasses(); for (unsigned int componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { os << indent << "Component num " << componentIndex; os << " (prop " << m_Proportions[componentIndex] << ") "; m_ComponentVector[componentIndex]->ShowParameters(os, indent); } } template void SEMClassifier ::SetNeighborhood(int neighborhood) { m_Neighborhood = 2 * (neighborhood / 2) + 1; if (m_Neighborhood < 1) m_Neighborhood = 1; } template int SEMClassifier ::GetNeighborhood() { return m_Neighborhood; } template void SEMClassifier ::SetInitialProportions(ProportionVectorType& proportions) { m_InitialProportions = proportions; m_ExternalLabels = 0; } template typename SEMClassifier::ProportionVectorType* SEMClassifier ::GetInitialProportions() { return m_InitialProportions; } template void SEMClassifier ::SetClassLabels(OutputType * labels) { if (m_Sample == NULL) { m_ClassLabels.resize(labels->Size()); ClassLabelVectorType::iterator iterClassLabel = m_ClassLabels.begin(); typename OutputType::ConstIterator iterLabels = labels->Begin(); typename OutputType::InstanceIdentifier id = 0; do { *iterClassLabel = iterLabels->GetClassLabel(id); ++iterLabels; ++iterClassLabel; id++; } while (iterLabels != labels->End()); m_ExternalLabels = 1; } else if (m_ClassLabels.size() == m_NbSamples) //FIXME check if this //is really the right condition { m_ClassLabels.resize(labels->Size()); ClassLabelVectorType::iterator iterClassLabel = m_ClassLabels.begin(); typename OutputType::iterator iterLabels = labels->Begin(); typename OutputType::InstanceIdentifier id = 0; do { *iterClassLabel = iterLabels->GetClassLabel(id); ++iterLabels; ++iterClassLabel; id++; } while (iterLabels != labels->End()); m_ExternalLabels = 1; } else { otbMsgDebugMacro(<< "m_ClassLabels size = " << GetClassLabels().size() << " / m_Sample size = " << m_NbSamples); throw itk::ExceptionObject(__FILE__, __LINE__, "Vector size mismatch", ITK_LOCATION); } } template void SEMClassifier ::SetClassLabels(TOutputImage * imgLabels) { otbMsgDebugMacro(<< "Initializing segmentation from an external image"); typename TInputImage::SizeType size = imgLabels->GetBufferedRegion().GetSize(); int theSize = (int) size[0] * size[1]; if (m_Sample == ITK_NULLPTR) { m_ClassLabels.resize(theSize); typename itk::ImageRegionIterator imgLabelIter(imgLabels, imgLabels->GetBufferedRegion()); imgLabelIter.GoToBegin(); typename itk::ImageRegionIterator imgLabelIterEnd(imgLabels, imgLabels->GetBufferedRegion()); imgLabelIterEnd.GoToEnd(); ClassLabelVectorType::iterator iterClassLabel = m_ClassLabels.begin(); do { *iterClassLabel = imgLabelIter.Get(); ++imgLabelIter; ++iterClassLabel; } while (imgLabelIter != imgLabelIterEnd); m_ExternalLabels = 1; } else if (theSize == m_NbSamples) { m_ClassLabels.resize(theSize); typename itk::ImageRegionIterator imgLabelIter(imgLabels, imgLabels->GetBufferedRegion()); imgLabelIter.GoToBegin(); typename itk::ImageRegionIterator imgLabelIterEnd(imgLabels, imgLabels->GetBufferedRegion()); imgLabelIterEnd.GoToEnd(); ClassLabelVectorType::iterator iterClassLabel = m_ClassLabels.begin(); do { *iterClassLabel = imgLabelIter.Get(); ++imgLabelIter; ++iterClassLabel; } while (imgLabelIter != imgLabelIterEnd); m_ExternalLabels = 1; } else { otbMsgDebugMacro( << "m_ClassLabels size = " << GetClassLabels().size() << " size of the image = " << theSize << " / m_Sample size = " << m_NbSamples); throw itk::ExceptionObject(__FILE__, __LINE__, "Vector size mismatch", ITK_LOCATION); } } template typename SEMClassifier::ClassLabelVectorType& SEMClassifier ::GetClassLabels() { return m_ClassLabels; } template typename SEMClassifier::ProportionVectorType* SEMClassifier ::GetProportions() { return &m_Proportions; } template void SEMClassifier ::SetSample(const TInputImage* sample) { m_Sample = sample; m_NbSamples = 0; m_SampleList = SampleType::New(); m_SampleList->SetMeasurementVectorSize(m_Sample->GetVectorLength()); itk::ImageRegionIterator imgIter((TInputImage *) m_Sample, m_Sample->GetBufferedRegion()); imgIter.GoToBegin(); itk::ImageRegionIterator imgIterEnd((TInputImage *) m_Sample, m_Sample->GetBufferedRegion()); imgIterEnd.GoToEnd(); do { m_SampleList->PushBack(imgIter.Get()); ++m_NbSamples; ++imgIter; } while (imgIter != imgIterEnd); if (m_ExternalLabels) { typename TInputImage::SizeType size = m_Sample->GetBufferedRegion().GetSize(); if ((size[0] * size[1]) != m_ClassLabels.size()) throw itk::ExceptionObject(__FILE__, __LINE__, "Vector size mismatch", ITK_LOCATION); } } template const TInputImage * SEMClassifier ::GetSample() const { return m_Sample; } template typename SEMClassifier::SampleType * SEMClassifier ::GetSampleList() const { return m_SampleList; } template int SEMClassifier ::GetCurrentIteration() { return m_CurrentIteration; } template int SEMClassifier ::AddComponent(int id, ComponentType * component) { m_ComponentVector[id] = component; m_ComponentDeclared = 1; return static_cast(m_ComponentVector.size()); } template void SEMClassifier ::Modified() const { Superclass::Modified(); if (m_ComponentDeclared == 1) otbMsgDebugMacro( << "Previous component declarations will be lost since called before SetNumberOfClasses"); m_ComponentVector.clear(); m_ComponentVector.resize(this->GetNumberOfClasses()); m_ComponentDeclared = 0; } template TOutputImage * SEMClassifier ::GetOutputImage() { return m_OutputImage; } template typename SEMClassifier::OutputType * SEMClassifier ::GetOutput() { return m_Output; } template void SEMClassifier ::InitParameters() { unsigned int nbClasses = this->GetNumberOfClasses(); if (!m_ExternalLabels) { m_ClassLabels.resize(m_NbSamples); if (static_cast(m_InitialProportions.size()) != nbClasses) { unsigned int label; for (typename ClassLabelVectorType::iterator labelIter = m_ClassLabels.begin(); labelIter != m_ClassLabels.end(); ++labelIter) { //label = (int) floor( 0.5 + nbClassesDbl * ran / double(RAND_MAX+1) ); label = rand() % nbClasses; if (label >= nbClasses) { label = nbClasses - 1; } *labelIter = label; } } else { // Be sure, the sum of initial proportion remains to 1 double sumProportion = 0.0; typename ProportionVectorType::iterator iterProportion = m_InitialProportions.begin(); do { sumProportion += *iterProportion; } while (++iterProportion != m_InitialProportions.end()); if (sumProportion != 1.0) { for (iterProportion = m_InitialProportions.begin(); iterProportion != m_InitialProportions.end(); ++iterProportion) *iterProportion /= sumProportion; } // non uniform random sampling according to m_InitialProportions double sample; double cumulativeProportion; for (typename ClassLabelVectorType::iterator labelIter = m_ClassLabels.begin(); labelIter != m_ClassLabels.end(); ++labelIter) { cumulativeProportion = 0.0; sample = double(rand()) / (double(RAND_MAX) + 1.0); *labelIter = nbClasses - 1; for (unsigned int componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { if (cumulativeProportion <= sample && sample < cumulativeProportion + m_InitialProportions[componentIndex]) { *labelIter = componentIndex; break; } else cumulativeProportion += m_InitialProportions[componentIndex]; } } } } m_Proportions.resize(nbClasses); m_Proba.resize(nbClasses); for (unsigned int i = 0; i < nbClasses; ++i) m_Proba[i].resize(m_NbSamples); if (!m_ComponentDeclared) { otbMsgDebugMacro(<< "default mixture initialization with " << nbClasses << " Gaussian components"); typedef otb::Statistics::GaussianModelComponent GaussianType; for (unsigned int componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { typename GaussianType::Pointer comp = GaussianType::New(); AddComponent(componentIndex, comp); } } otbMsgDevMacro(<< "num class : " << nbClasses); otbMsgDevMacro(<< "num sample : " << GetSampleList()->Size()); otbMsgDevMacro(<< "num labels : " << GetClassLabels().size()); otbMsgDevMacro(<< "contextual neighborhood : " << m_Neighborhood); otbMsgDevMacro(<< "terminationThreshold : " << m_TerminationThreshold); } template void SEMClassifier ::PerformStochasticProcess() { unsigned int nbClasses = this->GetNumberOfClasses(); double x, y, z; m_NbChange = 0; int posSample = 0; for (typename ClassLabelVectorType::iterator iter = m_ClassLabels.begin(); iter != m_ClassLabels.end(); ++iter) { x = double(rand()) / (double(RAND_MAX) + 1.0); z = 0.0; for (unsigned int componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { y = z; z += m_Proba[componentIndex][posSample]; if ((y < x) && (x <= z)) { if (static_cast(componentIndex) != *iter) m_NbChange++; *iter = componentIndex; break; } } posSample++; } switch (GetCurrentIteration()) { case 0: case 1: otbMsgDebugMacro(<< "Doing iteration " << GetCurrentIteration()); break; default: otbMsgDebugMacro(<< m_NbChange << " sample change at iteration " << GetCurrentIteration()); } } template void SEMClassifier ::PerformExpectationProcess() { unsigned int nbClasses = this->GetNumberOfClasses(); unsigned int componentIndex; for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) m_Proportions[componentIndex] = 0.0; std::vector coeffByClass; for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { coeffByClass.push_back(ClassSampleType::New()); coeffByClass[componentIndex]->SetMeasurementVectorSize( m_SampleList->GetMeasurementVectorSize()); coeffByClass[componentIndex]->SetSample(m_SampleList); } typename SampleType::ConstIterator iterSample = m_SampleList->Begin(); typename SampleType::ConstIterator lastSample = m_SampleList->End(); ClassLabelVectorType::iterator iterLabel = m_ClassLabels.begin(); ClassLabelVectorType::iterator lastLabel = m_ClassLabels.end(); typename SampleType::InstanceIdentifier id = 0; do { coeffByClass[*iterLabel]->AddInstance(id); m_Proportions[*iterLabel] += 1.0; id++; } while (++iterSample != lastSample && ++iterLabel != lastLabel); for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { if (m_Proportions[componentIndex] == 0.0) { std::cerr << "No sample on class " << componentIndex; // std::cerr << " in " << __PRETTY_FUNCTION__ << std::endl; std::cerr << " in " << ITK_LOCATION << std::endl; continue; } m_ComponentVector[componentIndex]->SetSample(coeffByClass[componentIndex]); m_ComponentVector[componentIndex]->Update(); } for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) m_Proportions[componentIndex] /= static_cast (m_NbSamples); } template void SEMClassifier ::PerformMaximizationProcess() { unsigned int nbClasses = this->GetNumberOfClasses(); int i, j, a, b; int voisinage = m_Neighborhood / 2; unsigned int componentIndex; double sumPdf, aPdf; double neighborhoodWeight = (double) m_Neighborhood * m_Neighborhood; int line, cols; typename TInputImage::SizeType size = m_Sample->GetBufferedRegion().GetSize(); cols = (int) size[0]; line = (int) size[1]; std::vector pdf(nbClasses); std::vector localWeight(nbClasses); std::vector localCount(nbClasses); typename SampleType::ConstIterator iterSample = m_SampleList->Begin(); typename SampleType::ConstIterator lastSample = m_SampleList->End(); MeasurementVectorType measurementVector; typename SampleType::InstanceIdentifier id = 0; do { id = iterSample.GetInstanceIdentifier(); for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) localCount[componentIndex] = 0.0; i = id / cols; j = id % cols; for (a = (i - voisinage); a <= (i + voisinage); a++) for (b = (j - voisinage); b <= (j + voisinage); b++) { if (a < 0 || a >= line) continue; if (b < 0 || b >= cols) continue; localCount[m_ClassLabels[a * cols + b]] += 1.0; } for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) localWeight[componentIndex] = localCount[componentIndex] / neighborhoodWeight; sumPdf = 0.0; for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { measurementVector = iterSample.GetMeasurementVector(); aPdf = localWeight[componentIndex] * m_ComponentVector[componentIndex]->Pdf(measurementVector); sumPdf += aPdf; pdf[componentIndex] = aPdf; } for (componentIndex = 0; componentIndex < nbClasses; ++componentIndex) { if (sumPdf == 0.0) m_Proba[componentIndex][iterSample.GetInstanceIdentifier()] = 0.0; else m_Proba[componentIndex][iterSample.GetInstanceIdentifier()] = pdf[componentIndex] / sumPdf; } } while (++iterSample != lastSample); } template void SEMClassifier ::GetMaximumAposterioriLabels() { unsigned int nbClasses = this->GetNumberOfClasses(); // Class results initialization m_Output = OutputType::New(); m_Output->SetSample(this->GetSampleList()); // m_Output->Resize(this->GetSampleList()->Size()); //FIXME check if // still necessary m_Output->SetNumberOfClasses(nbClasses); // Image results classification m_OutputImage = TOutputImage::New(); m_OutputImage->SetRegions(GetSample()->GetBufferedRegion()); m_OutputImage->Allocate(); int cluster; unsigned int componentIndex; typename SampleType::ConstIterator sampleIter = this->GetSampleList()->Begin(); typename SampleType::ConstIterator sampleIterEnd = this->GetSampleList()->End(); typename OutputType::ConstIterator outputIter = m_Output->Begin(); typename OutputType::ConstIterator outputIterEnd = m_Output->End(); typename itk::ImageRegionIterator imgOutputIter(m_OutputImage, m_OutputImage->GetBufferedRegion()); imgOutputIter.GoToBegin(); typename itk::ImageRegionIterator imgOutputIterEnd(m_OutputImage, m_OutputImage->GetBufferedRegion()); imgOutputIterEnd.GoToEnd(); do { cluster = 0; for (componentIndex = 1; componentIndex < nbClasses; ++componentIndex) { if (m_Proba[componentIndex][sampleIter.GetInstanceIdentifier()] > m_Proba[cluster][sampleIter.GetInstanceIdentifier()]) cluster = componentIndex; } m_Output->AddInstance(cluster, sampleIter.GetInstanceIdentifier()); imgOutputIter.Set(cluster); } while (++sampleIter != sampleIterEnd && ++outputIter != outputIterEnd && ++imgOutputIter != imgOutputIterEnd); } template void SEMClassifier ::Update() { InitParameters(); m_CurrentIteration = 0; m_TerminationCode = NOT_CONVERGED; int oldNbChange = 0; double step; do { oldNbChange = m_NbChange; PerformStochasticProcess(); PerformExpectationProcess(); PerformMaximizationProcess(); step = static_cast(oldNbChange - m_NbChange); if (step >= 0.0) { if ((step / static_cast(m_NbSamples)) < GetTerminationThreshold()) { m_TerminationCode = CONVERGED; if (oldNbChange != 0) break; } } } while (++m_CurrentIteration < m_MaximumIteration); GetMaximumAposterioriLabels(); } } // end of namesapce otb #endif OTB-release-5.8/Modules/Learning/LearningBase/otb-module.cmake000066400000000000000000000004221301006202600241660ustar00rootroot00000000000000set(DOCUMENTATION "This module contains OTB generic Machine Learning framework mainly based on OpenCV.") otb_module(OTBLearningBase DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Learning/LearningBase/test/000077500000000000000000000000001301006202600220765ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/LearningBase/test/CMakeLists.txt000066400000000000000000000030261301006202600246370ustar00rootroot00000000000000otb_module_test() set(OTBLearningBaseTests otbLearningBaseTestDriver.cxx otbDecisionTreeBuild.cxx otbGaussianModelComponent.cxx otbKMeansImageClassificationFilter.cxx otbDecisionTreeWithRealValues.cxx otbSEMClassifierNew.cxx otbDecisionTreeNew.cxx otbKMeansImageClassificationFilterNew.cxx ) add_executable(otbLearningBaseTestDriver ${OTBLearningBaseTests}) target_link_libraries(otbLearningBaseTestDriver ${OTBLearningBase-Test_LIBRARIES}) otb_module_target_label(otbLearningBaseTestDriver) # Tests Declaration otb_add_test(NAME leTvDecisionTreeBuild COMMAND otbLearningBaseTestDriver otbDecisionTreeBuild) otb_add_test(NAME leTuGaussianModelComponentNew COMMAND otbLearningBaseTestDriver otbGaussianModelComponentNew) otb_add_test(NAME leTvDecisionTreeWithRealValues COMMAND otbLearningBaseTestDriver otbDecisionTreeWithRealValues) otb_add_test(NAME leTvKMeansImageClassificationFilter COMMAND otbLearningBaseTestDriver --compare-image ${NOTOL} ${BASELINE}/leKMeansImageClassificationFilterOutput.hdr ${TEMP}/leKMeansImageClassificationFilterOutput.hdr otbKMeansImageClassificationFilter ${INPUTDATA}/poupees_sub.png ${TEMP}/leKMeansImageClassificationFilterOutput.hdr 2 0 0 0 0 255 255 255 255 ) otb_add_test(NAME leTuSEMClassifierNew COMMAND otbLearningBaseTestDriver otbSEMClassifierNew) otb_add_test(NAME leTuDecisionTreeNew COMMAND otbLearningBaseTestDriver otbDecisionTreeNew) otb_add_test(NAME leTuKMeansImageClassificationFilterNew COMMAND otbLearningBaseTestDriver otbKMeansImageClassificationFilterNew) OTB-release-5.8/Modules/Learning/LearningBase/test/otbDecisionTreeBuild.cxx000066400000000000000000000066121301006202600266710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDecisionTree.h" enum WheatTypes { WinterWheat, SummerWheat }; int otbDecisionTreeBuild(int itkNotUsed(argc), char* itkNotUsed(argv) []) { /** We build the following decision tree ------------- ( DOY LT 100 ) ------------- Yes -/ -- No --/ \-- ------------- ------------- ( NDVI GT 0.7 ) ( NDVI GT 0.7 ) ------------- ------------- / -- /\ Yes -/ \- No Yes-/ \- No -/ \ -/ \- WW SW SW WW */ typedef bool AttributeValueType; typedef otb::DecisionTree< AttributeValueType, WheatTypes > DecisionTreeType; DecisionTreeType::Pointer decisionTree = DecisionTreeType::New(); DecisionTreeType::Pointer doyLT100Tree = DecisionTreeType::New(); DecisionTreeType::Pointer doyGT100Tree = DecisionTreeType::New(); decisionTree->SetAttribute( 0 ); decisionTree->AddBranch( false, doyGT100Tree ); decisionTree->AddBranch( true, doyLT100Tree ); doyLT100Tree->SetAttribute( 1 ); doyLT100Tree->AddBranch( false, SummerWheat ); doyLT100Tree->AddBranch( true, WinterWheat ); doyGT100Tree->SetAttribute( 1 ); doyGT100Tree->AddBranch( false, WinterWheat ); doyGT100Tree->AddBranch( true, SummerWheat ); // Build some examples for testing DecisionTreeType::ExampleType ww_in_summer; //(DoY<100), (NDVI>0.7) ww_in_summer.push_back(false); ww_in_summer.push_back(false); DecisionTreeType::ExampleType ww_in_winter; ww_in_winter.push_back(true); ww_in_winter.push_back(true); DecisionTreeType::ExampleType sw_in_winter; sw_in_winter.push_back(true); sw_in_winter.push_back(false); DecisionTreeType::ExampleType sw_in_summer; sw_in_summer.push_back(false); sw_in_summer.push_back(true); std::cout << "ww_in_summer" << std::endl; if( decisionTree->Decide( ww_in_summer ) != WinterWheat ) { std::cerr << "ww_in_summer yields " << decisionTree->Decide( ww_in_summer ) << std::endl; return EXIT_FAILURE; } std::cout << "sw_in_winter" << std::endl; if( decisionTree->Decide( sw_in_winter ) != SummerWheat ) { std::cerr << "sw_in_winter yields " << decisionTree->Decide( sw_in_winter ) << std::endl; return EXIT_FAILURE; } std::cout << "sw_in_summer" << std::endl; if( decisionTree->Decide( sw_in_summer ) != SummerWheat ) { std::cerr << "sw_in_summer yields " << decisionTree->Decide( sw_in_summer ) << std::endl; return EXIT_FAILURE; } std::cout << "ww_in_winter" << std::endl; if( decisionTree->Decide( ww_in_winter ) != WinterWheat ) { std::cerr << "ww_in_winter yields " << decisionTree->Decide( ww_in_winter ) << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/LearningBase/test/otbDecisionTreeNew.cxx000066400000000000000000000016701301006202600263620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDecisionTree.h" enum WheatTypes { WinterWheat, SummerWheat }; int otbDecisionTreeNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef bool AttributeValueType; typedef otb::DecisionTree< AttributeValueType, WheatTypes > DecisionTreeType; DecisionTreeType::Pointer decisionTree = DecisionTreeType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/LearningBase/test/otbDecisionTreeWithRealValues.cxx000066400000000000000000000067731301006202600305410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbDecisionTree.h" enum WheatTypes { WinterWheat, SummerWheat }; int otbDecisionTreeWithRealValues(int itkNotUsed(argc), char* itkNotUsed(argv) []) { /** We build the following decision tree ------------- ( DOY LE 100 ) ------------- Yes -/ -- No --/ \-- ------------- ------------- ( NDVI GT 0.7 ) ( NDVI GT 0.7 ) ------------- ------------- / -- /\ Yes -/ \- No Yes-/ \- No -/ \ -/ \- WW SW SW WW */ typedef double AttributeValueType; typedef otb::DecisionTree< AttributeValueType, WheatTypes > DecisionTreeType; DecisionTreeType::Pointer decisionTree = DecisionTreeType::New(); DecisionTreeType::Pointer doyLE100Tree = DecisionTreeType::New(); DecisionTreeType::Pointer doyGT100Tree = DecisionTreeType::New(); decisionTree->SetAttribute( 0 ); decisionTree->AddBranch( 100, DecisionTreeType::GT, doyGT100Tree ); decisionTree->AddBranch( 100, DecisionTreeType::LE, doyLE100Tree ); doyLE100Tree->SetAttribute( 1 ); doyLE100Tree->AddBranch( 0.7, DecisionTreeType::LT, SummerWheat ); doyLE100Tree->AddBranch( 0.7, DecisionTreeType::GE, WinterWheat ); doyGT100Tree->SetAttribute( 1 ); doyGT100Tree->AddBranch( 0.7, DecisionTreeType::LE, WinterWheat ); doyGT100Tree->AddBranch( 0.7, DecisionTreeType::GT, SummerWheat ); // Build some examples for testing DecisionTreeType::ExampleType ww_in_summer; //(DoY), (NDVI) ww_in_summer.push_back(200); ww_in_summer.push_back(0.2); DecisionTreeType::ExampleType ww_in_winter; ww_in_winter.push_back(70); ww_in_winter.push_back(0.9); DecisionTreeType::ExampleType sw_in_winter; sw_in_winter.push_back(60); sw_in_winter.push_back(0.1); DecisionTreeType::ExampleType sw_in_summer; sw_in_summer.push_back(220); sw_in_summer.push_back(0.76); std::cout << "ww_in_summer" << std::endl; if( decisionTree->Decide( ww_in_summer ) != WinterWheat ) { std::cerr << "ww_in_summer yields " << decisionTree->Decide( ww_in_summer ) << std::endl; return EXIT_FAILURE; } std::cout << "sw_in_winter" << std::endl; if( decisionTree->Decide( sw_in_winter ) != SummerWheat ) { std::cerr << "sw_in_winter yields " << decisionTree->Decide( sw_in_winter ) << std::endl; return EXIT_FAILURE; } std::cout << "sw_in_summer" << std::endl; if( decisionTree->Decide( sw_in_summer ) != SummerWheat ) { std::cerr << "sw_in_summer yields " << decisionTree->Decide( sw_in_summer ) << std::endl; return EXIT_FAILURE; } std::cout << "ww_in_winter" << std::endl; if( decisionTree->Decide( ww_in_winter ) != WinterWheat ) { std::cerr << "ww_in_winter yields " << decisionTree->Decide( ww_in_winter ) << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/LearningBase/test/otbGaussianModelComponent.cxx000066400000000000000000000021601301006202600277440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "itkSubsample.h" #include "otbGaussianModelComponent.h" #include "itkVariableLengthVector.h" int otbGaussianModelComponentNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef itk::Statistics::ListSample > SampleType; typedef itk::Statistics::Subsample< SampleType > ClassSampleType; typedef otb::Statistics::GaussianModelComponent GaussianModelType; GaussianModelType::Pointer filter = GaussianModelType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/LearningBase/test/otbKMeansImageClassificationFilter.cxx000066400000000000000000000051461301006202600315000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMeansImageClassificationFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbKMeansImageClassificationFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int nbClasses = atoi(argv[3]); const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::KMeansImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::KMeansParametersType KMeansParametersType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); reader->GenerateOutputInformation(); const unsigned int sampleSize = ClassificationFilterType::MaxSampleDimension; const unsigned int parameterSize = nbClasses * sampleSize; KMeansParametersType parameters; parameters.SetSize(parameterSize); parameters.Fill(0); for (unsigned int i = 0; i < nbClasses; ++i) { for (unsigned int j = 0; j < reader->GetOutput()->GetNumberOfComponentsPerPixel(); ++j) { parameters[i * sampleSize + j] = atof(argv[4 + i * reader->GetOutput()->GetNumberOfComponentsPerPixel() + j]); } } std::cout << "Parameters: " << parameters << std::endl; filter->SetCentroids(parameters); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/LearningBase/test/otbKMeansImageClassificationFilterNew.cxx000066400000000000000000000023731301006202600321510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbKMeansImageClassificationFilter.h" #include "otbVectorImage.h" #include "otbImage.h" int otbKMeansImageClassificationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::KMeansImageClassificationFilter ClassificationFilterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/LearningBase/test/otbLearningBaseTestDriver.cxx000066400000000000000000000005601301006202600276760ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbDecisionTreeBuild); REGISTER_TEST(otbGaussianModelComponentNew); REGISTER_TEST(otbKMeansImageClassificationFilter); REGISTER_TEST(otbDecisionTreeWithRealValues); REGISTER_TEST(otbSEMClassifierNew); REGISTER_TEST(otbDecisionTreeNew); REGISTER_TEST(otbKMeansImageClassificationFilterNew); } OTB-release-5.8/Modules/Learning/LearningBase/test/otbSEMClassifierNew.cxx000066400000000000000000000027021301006202600264330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbSEMClassifier.h" #include int otbSEMClassifierNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::Image OutputImageType; typedef otb::SEMClassifier ClassifType; typedef itk::Statistics::ListSample SampleType; typedef itk::Statistics::Subsample ClassSampleType; typedef otb::Statistics::ModelComponentBase ComponentType; ClassifType::Pointer classifier = ClassifType::New(); ComponentType::Pointer component = ComponentType::New(); std::cout << classifier << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/000077500000000000000000000000001301006202600200245ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Markov/CMakeLists.txt000066400000000000000000000000451301006202600225630ustar00rootroot00000000000000project(OTBMarkov) otb_module_impl() OTB-release-5.8/Modules/Learning/Markov/include/000077500000000000000000000000001301006202600214475ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Markov/include/otbMRFEnergy.h000066400000000000000000000154751301006202600241370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFEnergy_h #define otbMRFEnergy_h #include "itkConstNeighborhoodIterator.h" #include "itkObject.h" #include "itkArray.h" namespace otb { /** * \class MRFEnergy * \brief This is the base class for energy function used in the MRF framework * * Derived class must reimplement the GetSingleValue() method. * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFEnergy : public itk::Object { public: typedef MRFEnergy Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInput1 InputImageType; typedef TInput2 LabelledImageType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename LabelledImageType::PixelType LabelledImagePixelType; typedef itk::ConstNeighborhoodIterator LabelledNeighborhoodIterator; typedef itk::ConstNeighborhoodIterator InputNeighborhoodIterator; typedef itk::Array ParametersType; itkNewMacro(Self); itkTypeMacro(MRFEnergy, itk::Object); itkSetMacro(NumberOfParameters, unsigned int); itkGetConstMacro(NumberOfParameters, unsigned int); // Get the parameters const ParametersType& GetParameters(void) const { return this->m_Parameters; } void SetParameters(const ParametersType& parameters) { if (parameters.Size() != m_NumberOfParameters) { itkExceptionMacro(<< "Invalid number of parameters"); } m_Parameters = parameters; this->Modified(); } virtual double GetSingleValue(const InputImagePixelType& itkNotUsed(value1), const LabelledImagePixelType& itkNotUsed(value2)) { itkExceptionMacro(<< "GetSingleValue() has to be declared in child classes."); } virtual double GetValue(const InputImagePixelType& value1, const LabelledImagePixelType& value2) { return GetSingleValue(value1, value2); } virtual double GetValue(const LabelledNeighborhoodIterator& it, const LabelledImagePixelType& value2) { double result = 0.0; unsigned int centerIndex = it.GetCenterNeighborhoodIndex(); InputImagePixelType value1; //TODO put also the other neighborhood ? bool isInside = false; unsigned int insideNeighbors = 0; for (unsigned long pos = 0; pos < it.Size(); ++pos) { if (pos != centerIndex) //TODO put outside loop for faster access ? { value1 = it.GetPixel(pos, isInside); if (isInside) { result += GetSingleValue(value1, value2); ++insideNeighbors; } } } return result / insideNeighbors; } virtual double GetValue(const InputNeighborhoodIterator& it, const LabelledImagePixelType& value2) { double result = 0.0; unsigned int centerIndex = it.GetCenterNeighborhoodIndex(); InputImagePixelType value1; //TODO put also the other neighborhood ? bool isInside = false; unsigned int insideNeighbors = 0; for (unsigned long pos = 0; pos < it.Size(); ++pos) { if (pos != centerIndex) //TODO put outside loop for faster access ? { value1 = it.GetPixel(pos, isInside); if (isInside) { result += GetSingleValue(value1, value2); ++insideNeighbors; } } } return result / insideNeighbors; } protected: // The constructor and destructor. MRFEnergy() : m_NumberOfParameters(1), m_Parameters(0) {}; ~MRFEnergy() ITK_OVERRIDE {} unsigned int m_NumberOfParameters; ParametersType m_Parameters; }; template class ITK_EXPORT MRFEnergy : public itk::Object { public: typedef MRFEnergy Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInput2 LabelledImageType; typedef typename LabelledImageType::PixelType LabelledImagePixelType; typedef itk::ConstNeighborhoodIterator LabelledNeighborhoodIterator; typedef itk::Array ParametersType; itkNewMacro(Self); itkTypeMacro(MRFEnergy, itk::Object); itkSetMacro(NumberOfParameters, unsigned int); itkGetConstMacro(NumberOfParameters, unsigned int); // Get the parameters const ParametersType& GetParameters(void) const { return this->m_Parameters; } void SetParameters(const ParametersType& parameters) { if (parameters.Size() != m_NumberOfParameters) { itkExceptionMacro(<< "Invalid number of parameters"); } m_Parameters = parameters; this->Modified(); } virtual double GetSingleValue(const LabelledImagePixelType& itkNotUsed(value1), const LabelledImagePixelType& itkNotUsed(value2)) { itkExceptionMacro(<< "GetSingleValue() has to be declared in child classes."); } virtual double GetValue(const LabelledImagePixelType& value1, const LabelledImagePixelType& value2) { return GetSingleValue(value1, value2); } virtual double GetValue(const LabelledNeighborhoodIterator& it, const LabelledImagePixelType& value2) { double result = 0.0; unsigned int centerIndex = it.GetCenterNeighborhoodIndex(); LabelledImagePixelType value1; //TODO put also the other neighborhood ? bool isInside = false; unsigned int insideNeighbors = 0; for (unsigned long pos = 0; pos < it.Size(); ++pos) { if (pos != centerIndex) //TODO put outside loop for faster access ? { value1 = it.GetPixel(pos, isInside); if (isInside) { result += GetSingleValue(value1, value2); ++insideNeighbors; } } } return result / insideNeighbors; } protected: // The constructor and destructor. MRFEnergy() : m_NumberOfParameters(1), m_Parameters(0) {}; ~MRFEnergy() ITK_OVERRIDE {} unsigned int m_NumberOfParameters; ParametersType m_Parameters; }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFEnergyEdgeFidelity.h000066400000000000000000000045071301006202600264100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFEnergyEdgeFidelity_h #define otbMRFEnergyEdgeFidelity_h #include "otbMRFEnergy.h" namespace otb { /** * \class MRFEnergyEdgeFidelity * \brief This is the implementation of an edge preserving model for Markov denoising. * * This is the implementation of an edge fidelity model for Markov denoising, to be used for * regularization. Energy is: * \f[ \sum_{t \in \mathcal{V}_s} U(x_s, x_t) = \Phi(x_s-x_t) \f] * with * - \f$ x_s \f$ the label on site s * - \f$ x_t \f$ the label on site t, a neighbor of s * - \f$ \Phi \f$ an edge preserving function: * \f[ \Phi(u) = \frac{u^2}{1+u^2} \f] * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFEnergyEdgeFidelity : public MRFEnergy { public: typedef MRFEnergyEdgeFidelity Self; typedef MRFEnergy Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ConstNeighborhoodIterator NeighborhoodIterator; typedef typename TInput1::PixelType InputImagePixelType; typedef typename TInput2::PixelType LabelledImagePixelType; itkNewMacro(Self); itkTypeMacro(MRFEnergyEdgeFidelity, MRFEnergy); double GetSingleValue(const InputImagePixelType& value1, const LabelledImagePixelType& value2) ITK_OVERRIDE { double val1 = static_cast(value1); double val2 = static_cast(value2); return vnl_math_sqr((val1 - val2)) / (1 + vnl_math_sqr(val1 - val2)); } protected: // The constructor and destructor. MRFEnergyEdgeFidelity() {}; ~MRFEnergyEdgeFidelity() ITK_OVERRIDE {} }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFEnergyFisherClassification.h000066400000000000000000000061151301006202600301430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This code is from a Jan Wegner contribution. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFEnergyFisherClassification_h #define otbMRFEnergyFisherClassification_h #include "otbMRFEnergy.h" #include "otbMath.h" #include "otb_boost_math_gamma_header.h" namespace otb { /** * \class MRFEnergyFisherClassification * \brief Fisher model for Markov classification * * This is the implementation of the Fisher model for Markov classification * to be used for the fidelity (likelihood) term for the classification. * * This class is meant to be used in the MRF framework with the * otb::MarkovRandomFieldFilter * * * \ingroup OTBMarkov */ template< class TInput1, class TInput2> class ITK_EXPORT MRFEnergyFisherClassification: public MRFEnergy< TInput1, TInput2> { public: typedef MRFEnergyFisherClassification Self; typedef MRFEnergy< TInput1, TInput2> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInput1 InputImageType; typedef TInput2 LabelledImageType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename LabelledImageType::PixelType LabelledImagePixelType; typedef itk::Array < double > ParametersType; itkNewMacro(Self); itkTypeMacro(MRFEnergyFisherClassification, MRFEnergy); void SetNumberOfParameters(const unsigned int nParameters) ITK_OVERRIDE { Superclass::SetNumberOfParameters(nParameters); this->m_Parameters.SetSize(nParameters); this->Modified(); } double GetSingleValue(const InputImagePixelType & value1, const LabelledImagePixelType & value2) ITK_OVERRIDE { if ((unsigned int)value2 >= this->GetNumberOfParameters()/3) { itkExceptionMacro(<<"Number of parameters does not correspond to number of classes" ); } double val1 = static_cast(value1); double mu = this->m_Parameters[3*value2]; double l = this->m_Parameters[3*value2+1]; double m = this->m_Parameters[3*value2+2]; double result = -vcl_log((boost::math::tgamma(l+m)/(boost::math::tgamma(l)*boost::math::tgamma(m))) * (2/(mu)) * (vcl_sqrt(l/m)) * ((vcl_pow((vcl_sqrt(l/m)*(val1/mu)), ((2*l)-1))) / (vcl_pow(1+(vcl_sqrt(l/m)*(val1/mu)*vcl_sqrt(l/m)*(val1/mu)), (l+m))))); return result; } protected: // The constructor and destructor. MRFEnergyFisherClassification() {}; ~MRFEnergyFisherClassification() ITK_OVERRIDE {}; }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFEnergyGaussian.h000066400000000000000000000045461301006202600256270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFEnergyGaussian_h #define otbMRFEnergyGaussian_h #include "otbMRFEnergy.h" #include "otbMath.h" namespace otb { /** * \class MRFEnergyGaussian * \brief This is the implementation of the Gaussian model for Markov classification. * * This is the implementation of the Gaussian model for Markov classification, * to be used for data fidelity. Energy is: * * \f[ U(x_s, x_t) = (x_s-x_t)^2 \f] * * with * - \f$ x_s \f$ the label on site s * - \f$ y_s \f$ the value on the reference image * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFEnergyGaussian : public MRFEnergy { public: typedef MRFEnergyGaussian Self; typedef MRFEnergy Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInput1 InputImageType; typedef TInput2 LabelledImageType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename LabelledImageType::PixelType LabelledImagePixelType; typedef itk::Array ParametersType; itkTypeMacro(MRFEnergyGaussian, MRFEnergy); itkNewMacro(Self); double GetSingleValue(const InputImagePixelType& value1, const LabelledImagePixelType& value2) ITK_OVERRIDE { return vnl_math_sqr((static_cast(value1)) - (static_cast(value2))); } protected: // The constructor and destructor. MRFEnergyGaussian() { this->m_NumberOfParameters = 0; this->m_Parameters.SetSize(this->m_NumberOfParameters); }; ~MRFEnergyGaussian() ITK_OVERRIDE {} }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFEnergyGaussianClassification.h000066400000000000000000000062621301006202600305000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFEnergyGaussianClassification_h #define otbMRFEnergyGaussianClassification_h #include "otbMRFEnergy.h" #include "otbMath.h" namespace otb { /** * \class MRFEnergyGaussianClassification * \brief This is the implementation of the Gaussian model for Markov classification. * * This is the implementation of the Gaussian Energy model for Markov classification, to be used for * the fidelity term for classification. Energy is: * \f[ U(x_s / y_s) = \frac{(y_s+\mu_{x_s})^2}{2\sigma^2_{x_s}}+\log{\sqrt{2\pi}\sigma_{x_s}} \f] * with * - \f$ x_s \f$ the label on site s * - \f$ y_s \f$ the value on the reference image * - \f$ \mu_{x_s} \f$ and \f$ \sigma^2_{x_s} \f$ the mean and variance of label \f$ x_s \f$ * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFEnergyGaussianClassification : public MRFEnergy { public: typedef MRFEnergyGaussianClassification Self; typedef MRFEnergy Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInput1 InputImageType; typedef TInput2 LabelledImageType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename LabelledImageType::PixelType LabelledImagePixelType; typedef itk::Array ParametersType; itkNewMacro(Self); itkTypeMacro(MRFEnergyGaussianClassification, MRFEnergy); void SetNumberOfParameters(const unsigned int nParameters) ITK_OVERRIDE { Superclass::SetNumberOfParameters(nParameters); this->m_Parameters.SetSize(nParameters); this->Modified(); } double GetSingleValue(const InputImagePixelType& value1, const LabelledImagePixelType& value2) ITK_OVERRIDE { if ((unsigned int) value2 >= this->GetNumberOfParameters() / 2) { itkExceptionMacro(<< "Number of parameters does not correspond to number of classes"); } double val1 = static_cast(value1); double result = vnl_math_sqr(val1 - this->m_Parameters[2 * static_cast(value2)]) / (2 * vnl_math_sqr(this->m_Parameters[2 * static_cast(value2) + 1])) + vcl_log(vcl_sqrt(CONST_2PI) * this->m_Parameters[2 * static_cast(value2) + 1]); return static_cast(result); } protected: // The constructor and destructor. MRFEnergyGaussianClassification() {}; ~MRFEnergyGaussianClassification() ITK_OVERRIDE {} }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFEnergyPotts.h000066400000000000000000000047531301006202600251660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFEnergyPotts_h #define otbMRFEnergyPotts_h #include "otbMRFEnergy.h" namespace otb { /** * \class MRFEnergyPotts * \brief This is the implementation of the Potts model for Markov classification. * * This is the implementation of the Potts model for Markov classification, to be used for * regularization. Energy is: * \f[ U(x_s, x_t) = -\beta \textrm{ if } x_s = x_t \f] * \f[ U(x_s, x_t) = +\beta \textrm{ if } x_s \neq x_t \f] * with * - \f$ x_s \f$ the label on site s * - \f$ y_s \f$ the value on the reference image * - \f$ \sigma^2_{x_s} \f$ the noise variance * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFEnergyPotts : public MRFEnergy { public: typedef MRFEnergyPotts Self; typedef MRFEnergy Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInput1 InputImageType; typedef TInput2 LabelledImageType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename LabelledImageType::PixelType LabelledImagePixelType; typedef itk::Array ParametersType; itkTypeMacro(MRFEnergyPotts, MRFEnergy); itkNewMacro(Self); double GetSingleValue(const InputImagePixelType& value1, const LabelledImagePixelType& value2) ITK_OVERRIDE { if (value1 != value2) { return this->m_Parameters[0]; } else { return -this->m_Parameters[0]; } } protected: // The constructor and destructor. MRFEnergyPotts() { this->m_NumberOfParameters = 1; this->m_Parameters.SetSize(this->m_NumberOfParameters); this->m_Parameters[0] = 1.0; }; ~MRFEnergyPotts() ITK_OVERRIDE {} }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFOptimizer.h000066400000000000000000000041161301006202600246560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFOptimizer_h #define otbMRFOptimizer_h #include "itkObject.h" #include "itkObjectFactory.h" #include "itkArray.h" namespace otb { /** * \class MRFOptimizer * \brief This is the base class for optimizer used in the MRF framework. * * Derived class must reimplement Compute() method. * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ class ITK_EXPORT MRFOptimizer : public itk::Object { public: typedef MRFOptimizer Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Array ParametersType; itkTypeMacro(MRFOptimizer, itk::Object); itkGetConstMacro(NumberOfParameters, unsigned int); // Get the parameters const ParametersType& GetParameters(void) const { return this->m_Parameters; } virtual void SetParameters(const ParametersType& parameters) { if (parameters.GetSize() != m_NumberOfParameters) { itkExceptionMacro( << "Invalid number of parameters (" << parameters.GetSize() << " , " << m_NumberOfParameters << ")"); } m_Parameters = parameters; this->Modified(); } virtual bool Compute(double deltaEnergy) = 0; protected: MRFOptimizer() : m_NumberOfParameters(1), m_Parameters(1) {} ~MRFOptimizer() ITK_OVERRIDE {} unsigned int m_NumberOfParameters; ParametersType m_Parameters; }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFOptimizerICM.h000066400000000000000000000032141301006202600252050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFOptimizerICM_h #define otbMRFOptimizerICM_h #include "otbMRFOptimizer.h" namespace otb { /** * \class MRFOptimizerICM * \brief This is the optimizer class implementing the ICM algorithm * * This is one optimizer to be used in the MRF framework. This optimizer * follows the ICM algorithm to accept of reject the value proposed by the sampler * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ class ITK_EXPORT MRFOptimizerICM : public MRFOptimizer { public: typedef MRFOptimizerICM Self; typedef MRFOptimizer Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(MRFOptimizerICM, MRFOptimizer); inline bool Compute(double deltaEnergy) ITK_OVERRIDE { if (deltaEnergy < 0) { return true; } else { return false; } } protected: MRFOptimizerICM() {} ~MRFOptimizerICM() ITK_OVERRIDE {} }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFOptimizerMetropolis.h000066400000000000000000000060031301006202600267310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFOptimizerMetropolis_h #define otbMRFOptimizerMetropolis_h #include "otbMRFOptimizer.h" #include "otbMath.h" #include "itkNumericTraits.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { /** * \class MRFOptimizerMetropolis * \brief This is the optimizer class implementing the Metropolis algorithm * * This is one optimizer to be used in the MRF framework. This optimizer * follows the metropolis algorithm to accept of reject the value proposed by the sampler. * * The MRFOptimizerMetropolis has one parameter corresponding to the temperature T used * to accept or reject proposed values. The proposed value is accepted with a probability: * * \f[ e^{\frac{-\Delta E}{T}} \f] * * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ class ITK_EXPORT MRFOptimizerMetropolis : public MRFOptimizer { public: typedef MRFOptimizerMetropolis Self; typedef MRFOptimizer Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Superclass::ParametersType ParametersType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; itkNewMacro(Self); itkTypeMacro(MRFOptimizerMetropolis, MRFOptimizer); /** Set parameter to a one array filled with paramVal.*/ void SetSingleParameter(double parameterVal) { this->m_Parameters.SetSize(1); this->m_Parameters.Fill(parameterVal); this->Modified(); } inline bool Compute(double deltaEnergy) ITK_OVERRIDE { if (deltaEnergy < 0) { return true; } if (deltaEnergy == 0) { return false; } else { double proba = vcl_exp(-(deltaEnergy) / this->m_Parameters[0]); if ((m_Generator->GetIntegerVariate() % 10000) < proba * 10000) { return true; } } return false; } /** Methods to cancel random effects.*/ void InitializeSeed(int seed) { m_Generator->SetSeed(seed); } void InitializeSeed() { m_Generator->SetSeed(); } protected: MRFOptimizerMetropolis() { this->m_NumberOfParameters = 1; this->m_Parameters.SetSize(1); this->m_Parameters[0] = 1.0; m_Generator = RandomGeneratorType::GetInstance(); m_Generator->SetSeed(); } ~MRFOptimizerMetropolis() ITK_OVERRIDE {} RandomGeneratorType::Pointer m_Generator; }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFSampler.h000066400000000000000000000064401301006202600243010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFSampler_h #define otbMRFSampler_h #include "otbMRFEnergy.h" #include "itkNeighborhoodIterator.h" namespace otb { /** * \class MRFSampler * \brief This is the base class for sampler methods used in the MRF framework. * * Derived class must reimplement Compute() method. * * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFSampler : public itk::Object { public: typedef MRFSampler Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ConstNeighborhoodIterator InputImageNeighborhoodIterator; typedef typename TInput1::PixelType InputImagePixelType; typedef itk::NeighborhoodIterator LabelledImageNeighborhoodIterator; typedef typename TInput2::PixelType LabelledImagePixelType; typedef MRFEnergy EnergyFidelityType; typedef MRFEnergy EnergyRegularizationType; typedef typename EnergyFidelityType::Pointer EnergyFidelityPointer; typedef typename EnergyRegularizationType::Pointer EnergyRegularizationPointer; itkTypeMacro(MRFSampler, Object); itkSetMacro(NumberOfClasses, unsigned int); itkGetMacro(NumberOfClasses, unsigned int); itkSetMacro(Lambda, double); itkGetMacro(Lambda, double); itkGetMacro(DeltaEnergy, double); itkGetMacro(Value, LabelledImagePixelType); // Accessor for validation tests pour les tests itkGetConstMacro(EnergyBefore, double); itkGetConstMacro(EnergyAfter, double); itkSetObjectMacro(EnergyRegularization, EnergyRegularizationType); itkSetObjectMacro(EnergyFidelity, EnergyFidelityType); virtual int Compute(const InputImageNeighborhoodIterator& itData, const LabelledImageNeighborhoodIterator& itRegul) = 0; protected: unsigned int m_NumberOfClasses; double m_EnergyBefore; double m_EnergyAfter; double m_DeltaEnergy; double m_EnergyCurrent; double m_Lambda; LabelledImagePixelType m_Value; EnergyRegularizationPointer m_EnergyRegularization; EnergyFidelityPointer m_EnergyFidelity; LabelledImagePixelType m_ValueCurrent; protected: // The constructor and destructor. MRFSampler() : m_NumberOfClasses(1), m_EnergyBefore(1.0), m_EnergyAfter(1.0), m_DeltaEnergy(1.0), m_EnergyCurrent(1.0), m_Lambda(1.0) { m_EnergyRegularization = EnergyRegularizationType::New(); m_EnergyFidelity = EnergyFidelityType::New(); }; ~MRFSampler() ITK_OVERRIDE {} }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFSamplerMAP.h000066400000000000000000000073011301006202600246340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFSamplerMAP_h #define otbMRFSamplerMAP_h #include "otbMRFSampler.h" namespace otb { /** * \class MRFSamplerMAP * \brief This is the base class for sampler methods used in the MRF framework. * * This is one sampler to be used int he MRF framework. This sampler select the * value which maximizes the apriori probability (minimum energy). * * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFSamplerMAP : public MRFSampler { public: typedef MRFSamplerMAP Self; typedef MRFSampler Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputImageNeighborhoodIterator InputImageNeighborhoodIterator; typedef typename Superclass::LabelledImageNeighborhoodIterator LabelledImageNeighborhoodIterator; typedef typename Superclass::LabelledImagePixelType LabelledImagePixelType; typedef typename Superclass::InputImagePixelType InputImagePixelType; typedef typename Superclass::EnergyFidelityType EnergyFidelityType; typedef typename Superclass::EnergyRegularizationType EnergyRegularizationType; typedef typename Superclass::EnergyFidelityPointer EnergyFidelityPointer; typedef typename Superclass::EnergyRegularizationPointer EnergyRegularizationPointer; itkNewMacro(Self); itkTypeMacro(MRFSamplerMAP, MRFSampler); inline int Compute(const InputImageNeighborhoodIterator& itData, const LabelledImageNeighborhoodIterator& itRegul) ITK_OVERRIDE { if (this->m_NumberOfClasses == 0) { itkExceptionMacro(<< "NumberOfClasse has to be greater than 0."); } this->m_EnergyBefore = this->m_EnergyFidelity->GetValue(itData, itRegul.GetCenterPixel()); this->m_EnergyBefore += this->m_Lambda * this->m_EnergyRegularization->GetValue(itRegul, itRegul.GetCenterPixel()); //Try all possible value (how to be generic ?) this->m_EnergyAfter = this->m_EnergyBefore; //default values to current one this->m_Value = itRegul.GetCenterPixel(); LabelledImagePixelType valueCurrent = 0; while (valueCurrent < static_cast(this->GetNumberOfClasses()) && valueCurrent != itk::NumericTraits::max()) { this->m_EnergyCurrent = this->m_EnergyFidelity->GetValue(itData, valueCurrent); this->m_EnergyCurrent += this->m_Lambda * this->m_EnergyRegularization->GetValue(itRegul, valueCurrent); if (this->m_EnergyCurrent < this->m_EnergyAfter) { this->m_EnergyAfter = this->m_EnergyCurrent; this->m_Value = valueCurrent; } valueCurrent++; } this->m_DeltaEnergy = this->m_EnergyAfter - this->m_EnergyBefore; return 0; } protected: // The constructor and destructor. MRFSamplerMAP() {}; ~MRFSamplerMAP() ITK_OVERRIDE {} }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFSamplerRandom.h000066400000000000000000000070451301006202600254440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFSamplerRandom_h #define otbMRFSamplerRandom_h #include "otbMRFSampler.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "itkNumericTraits.h" namespace otb { /** * \class MRFSamplerRandom * \brief This is the base class for sampler methods used in the MRF framework. * * This is one sampler to be used int he MRF framework. This sampler select the * value randomly according to a uniform probability. * * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFSamplerRandom : public MRFSampler { public: typedef MRFSamplerRandom Self; typedef otb::MRFSampler Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputImageNeighborhoodIterator InputImageNeighborhoodIterator; typedef typename Superclass::LabelledImageNeighborhoodIterator LabelledImageNeighborhoodIterator; typedef typename Superclass::LabelledImagePixelType LabelledImagePixelType; typedef typename Superclass::InputImagePixelType InputImagePixelType; typedef typename Superclass::EnergyFidelityType EnergyFidelityType; typedef typename Superclass::EnergyRegularizationType EnergyRegularizationType; typedef typename Superclass::EnergyFidelityPointer EnergyFidelityPointer; typedef typename Superclass::EnergyRegularizationPointer EnergyRegularizationPointer; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; itkNewMacro(Self); itkTypeMacro(MRFSamplerRandom, MRFSampler); inline int Compute(const InputImageNeighborhoodIterator& itData, const LabelledImageNeighborhoodIterator& itRegul) ITK_OVERRIDE { this->m_EnergyBefore = this->m_EnergyFidelity->GetValue(itData, itRegul.GetCenterPixel()); this->m_EnergyBefore += this->m_Lambda * this->m_EnergyRegularization->GetValue(itRegul, itRegul.GetCenterPixel()); this->m_Value = static_cast(m_Generator->GetIntegerVariate() % this->m_NumberOfClasses); this->m_EnergyAfter = this->m_EnergyFidelity->GetValue(itData, this->m_Value); this->m_EnergyAfter += this->m_Lambda * this->m_EnergyRegularization->GetValue(itRegul, this->m_Value); this->m_DeltaEnergy = this->m_EnergyAfter - this->m_EnergyBefore; return 0; } /** Methods to cancel random effects.*/ void InitializeSeed(int seed) { m_Generator->SetSeed(seed); } void InitializeSeed() { m_Generator->SetSeed(); } protected: // The constructor and destructor. MRFSamplerRandom() { m_Generator = RandomGeneratorType::GetInstance(); m_Generator->SetSeed(); } ~MRFSamplerRandom() ITK_OVERRIDE {} private: RandomGeneratorType::Pointer m_Generator; }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMRFSamplerRandomMAP.h000066400000000000000000000143571301006202600260060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMRFSamplerRandomMAP_h #define otbMRFSamplerRandomMAP_h #include "itkMersenneTwisterRandomVariateGenerator.h" #include "otbMRFSampler.h" namespace otb { /** * \class MRFSamplerRandomMAP * \brief This is the base class for sampler methods used in the MRF framework. * * This is one sampler to be used int he MRF framework. This sampler select the * value randomly according to the apriori probability. * * The probability is defined from the energy as: * * \f[ P(X=x)= \frac{1}{Z} \exp^{-U(x)} \f] * * where \f$ Z = \sum_x \exp^{-U(x)}\f$ * * * This class is meant to be used in the MRF framework with the otb::MarkovRandomFieldFilter * * \ingroup Markov * * \ingroup OTBMarkov */ template class ITK_EXPORT MRFSamplerRandomMAP : public MRFSampler { public: typedef MRFSamplerRandomMAP Self; typedef otb::MRFSampler Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputImageNeighborhoodIterator InputImageNeighborhoodIterator; typedef typename Superclass::LabelledImageNeighborhoodIterator LabelledImageNeighborhoodIterator; typedef typename Superclass::LabelledImagePixelType LabelledImagePixelType; typedef typename Superclass::InputImagePixelType InputImagePixelType; typedef typename Superclass::EnergyFidelityType EnergyFidelityType; typedef typename Superclass::EnergyRegularizationType EnergyRegularizationType; typedef typename Superclass::EnergyFidelityPointer EnergyFidelityPointer; typedef typename Superclass::EnergyRegularizationPointer EnergyRegularizationPointer; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; itkNewMacro(Self); itkTypeMacro(MRFSamplerRandomMAP, MRFSampler); void SetNumberOfClasses(const unsigned int nClasses) ITK_OVERRIDE { if ((nClasses != this->m_NumberOfClasses) || (m_EnergiesInvalid == true)) { this->m_NumberOfClasses = nClasses; if (m_Energy != ITK_NULLPTR) free(m_Energy); if (m_RepartitionFunction != ITK_NULLPTR) free(m_RepartitionFunction); m_Energy = (double *) calloc(this->m_NumberOfClasses, sizeof(double)); m_RepartitionFunction = (double *) calloc(this->m_NumberOfClasses, sizeof(double)); this->Modified(); } } inline int Compute(const InputImageNeighborhoodIterator& itData, const LabelledImageNeighborhoodIterator& itRegul) ITK_OVERRIDE { if (this->m_NumberOfClasses == 0) { itkExceptionMacro(<< "NumberOfClasse has to be greater than 0."); } this->m_EnergyBefore = this->m_EnergyFidelity->GetValue(itData, itRegul.GetCenterPixel()); this->m_EnergyBefore += this->m_Lambda * this->m_EnergyRegularization->GetValue(itRegul, itRegul.GetCenterPixel()); //Try all possible value (how to be generic ?) this->m_EnergyAfter = this->m_EnergyBefore; //default values to current one this->m_Value = itRegul.GetCenterPixel(); //Compute probability for each possibility double totalProba = 0.0; unsigned int valueCurrent = 0; for (valueCurrent = 0; valueCurrent < this->m_NumberOfClasses; ++valueCurrent) { this->m_EnergyCurrent = this->m_EnergyFidelity->GetValue(itData, static_cast(valueCurrent)); this->m_EnergyCurrent += this->m_Lambda * this->m_EnergyRegularization->GetValue(itRegul, static_cast( valueCurrent)); m_Energy[valueCurrent] = this->m_EnergyCurrent; m_RepartitionFunction[valueCurrent] = vcl_exp(-this->m_EnergyCurrent) + totalProba; totalProba = m_RepartitionFunction[valueCurrent]; } //Pick a value according to probability //double select = (m_Generator->GetIntegerVariate()/(double(RAND_MAX)+1) * totalProba); double select = (m_Generator->GetIntegerVariate() / (double(itk::NumericTraits::max()) + 1) * totalProba); valueCurrent = 0; while ((valueCurrent < this->GetNumberOfClasses()) && (m_RepartitionFunction[valueCurrent] <= select)) { valueCurrent++; } if (valueCurrent == this->GetNumberOfClasses()) { valueCurrent = this->GetNumberOfClasses() - 1; } if (this->m_Value != static_cast(valueCurrent)) { this->m_Value = static_cast(valueCurrent); this->m_EnergyAfter = m_Energy[static_cast(valueCurrent)]; } this->m_DeltaEnergy = this->m_EnergyAfter - this->m_EnergyBefore; return 0; } /** Methods to cancel random effects.*/ void InitializeSeed(int seed) { m_Generator->SetSeed(seed); } void InitializeSeed() { m_Generator->SetSeed(); } protected: // The constructor and destructor. MRFSamplerRandomMAP() : m_RepartitionFunction(ITK_NULLPTR), m_Energy(ITK_NULLPTR), m_EnergiesInvalid(true) { m_Generator = RandomGeneratorType::GetInstance(); m_Generator->SetSeed(); } ~MRFSamplerRandomMAP() ITK_OVERRIDE { if (m_Energy != ITK_NULLPTR) free(m_Energy); if (m_RepartitionFunction != ITK_NULLPTR) free(m_RepartitionFunction); } private: double * m_RepartitionFunction; double * m_Energy; bool m_EnergiesInvalid; RandomGeneratorType::Pointer m_Generator; }; } #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMarkovRandomFieldFilter.h000066400000000000000000000326221301006202600270440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMarkovRandomFieldFilter_h #define otbMarkovRandomFieldFilter_h #include "otbMacro.h" #include "vnl/vnl_vector.h" #include "vnl/vnl_matrix.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "itkImageToImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkNeighborhood.h" #include "itkSize.h" #include "otbMRFOptimizer.h" #include "otbMRFSampler.h" namespace otb { /** * \class MarkovRandomFieldFilter * \brief This is the class to use the Markov Random Field framework in OTB. * * This filter apply a Markov Random Field to an input image. Several * components need to be specify: * * - Fidelity energy (class derived from otb::MRFEnergy): the energy to make * sure that the output image is close enough to the reference. * - Regularization energy (class derived from otb::MRFEnergy): the energy to * make sure that neighborhood pixels have similar values. * - Sampler (class derived from otb::MRFSampler): the strategy to propose * variations for each pixel. * - Optimizer (class derived from otb::MRFOptimizer): the strategy to accept * or reject the proposed modification. * * An example of usage for this filter is: * * \code * markovFilter->SetNumberOfClasses(4); * markovFilter->SetMaximumNumberOfIterations(30); * markovFilter->SetErrorTolerance(0.0); * markovFilter->SetLambda(1.0); * markovFilter->SetNeighborhoodRadius(1); * * markovFilter->SetEnergyRegularization(energyRegularization); * markovFilter->SetEnergyFidelity(energyFidelity); * markovFilter->SetOptimizer(optimizer); * markovFilter->SetSampler(sampler); * \endcode * * * \ingroup Markov * * \example Markov/MarkovClassification1Example.cxx * \example Markov/MarkovClassification2Example.cxx * \example Markov/MarkovRegularizationExample.cxx * \example Markov/MarkovRestorationExample.cxx * * * \ingroup OTBMarkov */ template class ITK_EXPORT MarkovRandomFieldFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef MarkovRandomFieldFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::OutputImagePointer OutputImagePointer; /** Run-time type information (and related methods). */ itkTypeMacro(MarkovRandomFieldFilter, itk::ImageToImageFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); /** Type definition for the input image. */ typedef TInputImage InputImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::ConstPointer InputImageConstPointer; /** Type definition for the input image pixel type. */ typedef typename TInputImage::PixelType InputImagePixelType; /** Type definition for the input image region type. */ typedef typename TInputImage::RegionType InputImageRegionType; /** Type definition for the input image region iterator */ typedef itk::ImageRegionIterator InputImageRegionIterator; typedef itk::ImageRegionConstIterator InputImageRegionConstIterator; /** Image dimension */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Type definitions for the training image. */ typedef TClassifiedImage TrainingImageType; typedef typename TClassifiedImage::Pointer TrainingImagePointer; /** Type definitions for the training image pixel type. */ typedef typename TClassifiedImage::PixelType TrainingImagePixelType; /** Type definitions for the labelled image. * It is derived from the training image. */ typedef TClassifiedImage LabelledImageType; typedef typename TClassifiedImage::Pointer LabelledImagePointer; /** Type definitions for the classified image pixel type. * It has to be the same type as the training image. */ typedef typename TClassifiedImage::PixelType LabelledImagePixelType; /** Type definitions for the classified image pixel type. * It has to be the same type as the training image. */ typedef typename TClassifiedImage::RegionType LabelledImageRegionType; /** Type definition for the classified image index type. */ typedef typename TClassifiedImage::IndexType LabelledImageIndexType; typedef typename LabelledImageIndexType::IndexValueType IndexValueType; /** Type definition for the classified image offset type. */ typedef typename TClassifiedImage::OffsetType LabelledImageOffsetType; /** Type definition for the input image region iterator */ typedef itk::ImageRegionIterator LabelledImageRegionIterator; typedef itk::ImageRegionConstIterator LabelledImageRegionConstIterator; /** Labelled Image dimension */ itkStaticConstMacro(ClassifiedImageDimension, unsigned int, TClassifiedImage::ImageDimension); /** Size and value typedef support. */ typedef typename TInputImage::SizeType SizeType; /** Radius typedef support. */ typedef typename TInputImage::SizeType NeighborhoodRadiusType; /** Input image neighborhood iterator and kernel size typedef */ typedef itk::ConstNeighborhoodIterator InputImageNeighborhoodIterator; typedef typename InputImageNeighborhoodIterator::RadiusType InputImageNeighborhoodRadiusType; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator InputImageFacesCalculator; typedef typename InputImageFacesCalculator::FaceListType InputImageFaceListType; typedef typename InputImageFaceListType::iterator InputImageFaceListIterator; /** Labelled image neighborhood iterator typedef */ typedef itk::NeighborhoodIterator LabelledImageNeighborhoodIterator; typedef typename LabelledImageNeighborhoodIterator::RadiusType LabelledImageNeighborhoodRadiusType; typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator LabelledImageFacesCalculator; typedef typename LabelledImageFacesCalculator::FaceListType LabelledImageFaceListType; typedef typename LabelledImageFaceListType::iterator LabelledImageFaceListIterator; /** Typedef for random values. */ typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; /** Set pipeline elements */ typedef MRFEnergy EnergyRegularizationType; typedef MRFEnergy EnergyFidelityType; typedef typename EnergyRegularizationType::Pointer EnergyRegularizationPointer; typedef typename EnergyFidelityType::Pointer EnergyFidelityPointer; typedef MRFSampler SamplerType; typedef typename SamplerType::Pointer SamplerPointer; typedef MRFOptimizer OptimizerType; typedef typename OptimizerType::Pointer OptimizerPointer; /** ************ ACCESSORS ************ */ itkSetObjectMacro(EnergyRegularization, EnergyRegularizationType); itkGetObjectMacro(EnergyRegularization, EnergyRegularizationType); itkSetObjectMacro(EnergyFidelity, EnergyFidelityType); itkGetObjectMacro(EnergyFidelity, EnergyFidelityType); itkSetObjectMacro(Sampler, SamplerType); itkGetObjectMacro(Sampler, SamplerType); itkSetObjectMacro(Optimizer, OptimizerType); itkGetObjectMacro(Optimizer, OptimizerType); /** Set/Get the number of classes. */ itkSetMacro(NumberOfClasses, unsigned int); itkGetMacro(NumberOfClasses, unsigned int); /** Set/Get the number of iteration of the Iterated Conditional Mode * (ICM) algorithm. A default value is set at 50 iterations. */ itkSetMacro(MaximumNumberOfIterations, unsigned int); itkGetMacro(MaximumNumberOfIterations, unsigned int); /** Set/Get the error tollerance level which is used as a threshold * to quit the iterations */ itkSetMacro(ErrorTolerance, double); itkGetMacro(ErrorTolerance, double); /** Set/Get the degree of smoothing desired * */ itkSetMacro(SmoothingFactor, double); itkGetMacro(SmoothingFactor, double); /** Set/Get the regularization coefficient * */ itkSetMacro(Lambda, double); itkGetMacro(Lambda, double); /** Set the neighborhood radius */ void SetNeighborhoodRadius(const NeighborhoodRadiusType&); /** Sets the radius for the neighborhood, calculates size from the * radius, and allocates storage. */ void SetNeighborhoodRadius(const unsigned long); void SetNeighborhoodRadius(const unsigned long *radiusArray); /** Get the neighborhood radius */ const NeighborhoodRadiusType GetNeighborhoodRadius() const { NeighborhoodRadiusType neighborhoodRadius; for (int i = 0; i < InputImageDimension; ++i) neighborhoodRadius[i] = m_InputImageNeighborhoodRadius[i]; return neighborhoodRadius; } /** Set training image for the starting point. This is not compulsory: * if the starting image is not specified, a random image will be used * instead. * One important restriction: in the case of classification, the training * image should contain values corresponding to the class number (consecutive * integers). */ virtual void SetTrainingInput(const TrainingImageType * trainingImage); const TrainingImageType* GetTrainingInput(void); //Enum to get the stopping condition of the MRF filter typedef enum { MaximumNumberOfIterations = 1, ErrorTolerance } StopConditionType; /** Get condition that stops the MRF filter (Number of Iterations * / Error tolerance ) */ itkGetConstReferenceMacro(StopCondition, StopConditionType); /** Get macro for number of iterations */ itkGetConstReferenceMacro(NumberOfIterations, unsigned int); #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(UnsignedIntConvertibleToClassifiedCheck, (itk::Concept::Convertible)); itkConceptMacro(ClassifiedConvertibleToUnsignedIntCheck, (itk::Concept::Convertible )); itkConceptMacro(ClassifiedConvertibleToIntCheck, (itk::Concept::Convertible )); itkConceptMacro(IntConvertibleToClassifiedCheck, (itk::Concept::Convertible)); itkConceptMacro(SameDimensionCheck, (itk::Concept::SameDimension)); /** End concept checking */ #endif /** Methods to cancel random effects.*/ void InitializeSeed(int seed) { m_Generator->SetSeed(seed); } void InitializeSeed() { m_Generator->SetSeed(); } protected: MarkovRandomFieldFilter(); ~MarkovRandomFieldFilter() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Allocate memory for labelled images. This is automatically called * in GenerateData(). */ void Allocate(); /** Connect the pipeline and propagate the required parameters. This * is automatically called in GenerateData(). */ void Initialize() throw (itk::ExceptionObject); virtual void ApplyMarkovRandomFieldFilter(); void GenerateData() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void EnlargeOutputRequestedRegion(itk::DataObject *) ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; MarkovRandomFieldFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typedef typename TInputImage::SizeType InputImageSizeType; InputImageNeighborhoodRadiusType m_InputImageNeighborhoodRadius; LabelledImageNeighborhoodRadiusType m_LabelledImageNeighborhoodRadius; unsigned int m_NumberOfClasses; unsigned int m_MaximumNumberOfIterations; int m_ErrorCounter; double m_ImageDeltaEnergy; int m_NeighborhoodRadius; int m_TotalNumberOfValidPixelsInOutputImage; int m_TotalNumberOfPixelsInInputImage; double m_ErrorTolerance; double m_SmoothingFactor; unsigned int m_NumberOfIterations; double m_Lambda; bool m_ExternalClassificationSet; StopConditionType m_StopCondition; TrainingImagePointer m_TrainingImage; std::vector m_MRFNeighborhoodWeight; std::vector m_NeighborInfluence; std::vector m_DummyVector; RandomGeneratorType::Pointer m_Generator; /** Pointer to different elements */ EnergyRegularizationPointer m_EnergyRegularization; EnergyFidelityPointer m_EnergyFidelity; OptimizerPointer m_Optimizer; SamplerPointer m_Sampler; virtual void MinimizeOnce(); private: }; // class MarkovRandomFieldFilter } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMarkovRandomFieldFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/Markov/include/otbMarkovRandomFieldFilter.txx000066400000000000000000000306321301006202600274370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMarkovRandomFieldFilter_txx #define otbMarkovRandomFieldFilter_txx #include "otbMarkovRandomFieldFilter.h" namespace otb { template MarkovRandomFieldFilter ::MarkovRandomFieldFilter(void) : m_NumberOfClasses(0), m_MaximumNumberOfIterations(50), m_ErrorCounter(0), m_ImageDeltaEnergy(0.0), m_NeighborhoodRadius(1), m_TotalNumberOfValidPixelsInOutputImage(1), m_TotalNumberOfPixelsInInputImage(1), m_ErrorTolerance(0.0), m_SmoothingFactor(1.0), m_NumberOfIterations(0), m_Lambda(1.0), m_ExternalClassificationSet(false), m_StopCondition(MaximumNumberOfIterations) { m_Generator = RandomGeneratorType::GetInstance(); m_Generator->SetSeed(); this->SetNumberOfRequiredInputs(1); if ((int) InputImageDimension != (int) ClassifiedImageDimension) { std::ostringstream msg; msg << "Input image dimension: " << InputImageDimension << " != output image dimension: " << ClassifiedImageDimension; throw itk::ExceptionObject(__FILE__, __LINE__, msg.str().c_str(), ITK_LOCATION); } m_InputImageNeighborhoodRadius.Fill(m_NeighborhoodRadius); // m_MRFNeighborhoodWeight.resize(0); // m_NeighborInfluence.resize(0); // m_DummyVector.resize(0); // this->SetMRFNeighborhoodWeight( m_DummyVector ); // this->SetDefaultMRFNeighborhoodWeight(); //srand((unsigned)time(0)); } template void MarkovRandomFieldFilter ::SetTrainingInput(const TrainingImageType * trainingImage) { m_ExternalClassificationSet = true; // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast(trainingImage)); this->Modified(); } template const typename MarkovRandomFieldFilter::TrainingImageType* MarkovRandomFieldFilter ::GetTrainingInput(void) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1)); } template void MarkovRandomFieldFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << " MRF Image filter object " << std::endl; os << indent << " Number of classes: " << m_NumberOfClasses << std::endl; os << indent << " Maximum number of iterations: " << m_MaximumNumberOfIterations << std::endl; os << indent << " Error tolerance for convergence: " << m_ErrorTolerance << std::endl; os << indent << " Size of the MRF neighborhood radius:" << m_InputImageNeighborhoodRadius << std::endl; os << indent << "StopCondition: " << m_StopCondition << std::endl; os << indent << " Number of iterations: " << m_NumberOfIterations << std::endl; os << indent << " Lambda: " << m_Lambda << std::endl; } // end PrintSelf /** * GenerateInputRequestedRegion method. */ template void MarkovRandomFieldFilter ::GenerateInputRequestedRegion() { // this filter requires the all of the input images // to be at the size of the output requested region InputImagePointer inputPtr = const_cast(this->GetInput()); OutputImagePointer outputPtr = this->GetOutput(); inputPtr->SetRequestedRegion(outputPtr->GetRequestedRegion()); } /** * EnlargeOutputRequestedRegion method. */ template void MarkovRandomFieldFilter ::EnlargeOutputRequestedRegion(itk::DataObject *output) { // this filter requires the all of the output image to be in // the buffer TClassifiedImage *imgData; imgData = dynamic_cast(output); imgData->SetRequestedRegionToLargestPossibleRegion(); } /** * GenerateOutputInformation method. */ template void MarkovRandomFieldFilter ::GenerateOutputInformation() { typename TInputImage::ConstPointer input = this->GetInput(); typename TClassifiedImage::Pointer output = this->GetOutput(); output->SetLargestPossibleRegion(input->GetLargestPossibleRegion()); } template void MarkovRandomFieldFilter ::GenerateData() { // InputImageConstPointer inputImage = this->GetInput(); //Allocate memory for the labelled images this->Allocate(); //Branch the pipeline this->Initialize(); //Run the Markov random field this->ApplyMarkovRandomFieldFilter(); } // end GenerateData /** * Set the neighborhood radius from a single value */ template void MarkovRandomFieldFilter ::SetNeighborhoodRadius(const unsigned long radiusValue) { //Set up the neighbor hood NeighborhoodRadiusType radius; for (unsigned int i = 0; i < InputImageDimension; ++i) { radius[i] = radiusValue; } this->SetNeighborhoodRadius(radius); } // end SetNeighborhoodRadius /** * Set the neighborhood radius from an array */ template void MarkovRandomFieldFilter ::SetNeighborhoodRadius(const unsigned long *radiusArray) { NeighborhoodRadiusType radius; for (unsigned int i = 0; i < InputImageDimension; ++i) { radius[i] = radiusArray[i]; } //Set up the neighbor hood this->SetNeighborhoodRadius(radius); } // end SetNeighborhoodRadius /** * Set the neighborhood radius from a radius object */ template void MarkovRandomFieldFilter ::SetNeighborhoodRadius(const NeighborhoodRadiusType& radius) { //Set up the neighbor hood for (unsigned int i = 0; i < InputImageDimension; ++i) { m_InputImageNeighborhoodRadius[i] = radius[i]; m_LabelledImageNeighborhoodRadius[i] = radius[i]; } } // end SetNeighborhoodRadius //------------------------------------------------------- /** * Allocate algorithm specific resources */ template void MarkovRandomFieldFilter ::Allocate() { if (m_NumberOfClasses <= 0) { throw itk::ExceptionObject(__FILE__, __LINE__, "NumberOfClasses <= 0.", ITK_LOCATION); } //Set the output labelled and allocate the memory LabelledImagePointer outputPtr = this->GetOutput(); //Allocate the output buffer memory outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); //Copy input data in the output buffer memory or //initialize to random values if not set LabelledImageRegionIterator outImageIt(outputPtr, outputPtr->GetRequestedRegion()); if (m_ExternalClassificationSet) { typename TrainingImageType::ConstPointer trainingImage = this->GetTrainingInput(); LabelledImageRegionConstIterator trainingImageIt(trainingImage, outputPtr->GetRequestedRegion()); while (!outImageIt.IsAtEnd()) { LabelledImagePixelType labelvalue = static_cast (trainingImageIt.Get()); outImageIt.Set(labelvalue); ++trainingImageIt; ++outImageIt; } // end while } else //set to random value { // srand((unsigned)time(0)); while (!outImageIt.IsAtEnd()) { LabelledImagePixelType randomvalue = static_cast( m_Generator->GetIntegerVariate() % static_cast(m_NumberOfClasses) ); outImageIt.Set(randomvalue); ++outImageIt; } // end while } } // Allocate /** * Initialize pipeline and values */ template void MarkovRandomFieldFilter ::Initialize() throw (itk::ExceptionObject) { m_ImageDeltaEnergy = 0.0; InputImageSizeType inputImageSize = this->GetInput()->GetBufferedRegion().GetSize(); //--------------------------------------------------------------------- //Get the number of valid pixels in the output MRF image //--------------------------------------------------------------------- m_TotalNumberOfPixelsInInputImage = 1; m_TotalNumberOfValidPixelsInOutputImage = 1; for (unsigned int i = 0; i < InputImageDimension; ++i) { m_TotalNumberOfPixelsInInputImage *= static_cast(inputImageSize[i]); m_TotalNumberOfValidPixelsInOutputImage *= (static_cast(inputImageSize[i]) - 2 * m_InputImageNeighborhoodRadius[i]); } srand((unsigned) time(ITK_NULLPTR)); if (!m_EnergyRegularization) { itkExceptionMacro(<< "EnergyRegularization is not present"); } if (!m_EnergyFidelity) { itkExceptionMacro(<< "EnergyFidelity is not present"); } if (!m_Optimizer) { itkExceptionMacro(<< "Optimizer is not present"); } if (!m_Sampler) { itkExceptionMacro(<< "Sampler is not present"); } m_Sampler->SetLambda(m_Lambda); m_Sampler->SetEnergyRegularization(m_EnergyRegularization); m_Sampler->SetEnergyFidelity(m_EnergyFidelity); m_Sampler->SetNumberOfClasses(m_NumberOfClasses); } /** *Apply the MRF image filter */ template void MarkovRandomFieldFilter ::ApplyMarkovRandomFieldFilter() { //Note: error should be defined according to the number of valid pixel in the output int maxNumPixelError = itk::Math::Round (m_ErrorTolerance * m_TotalNumberOfPixelsInInputImage); m_NumberOfIterations = 0; m_ErrorCounter = m_TotalNumberOfValidPixelsInOutputImage; while ((m_NumberOfIterations < m_MaximumNumberOfIterations) && (m_ErrorCounter >= maxNumPixelError)) { otbMsgDevMacro(<< "Iteration No." << m_NumberOfIterations); this->MinimizeOnce(); otbMsgDevMacro(<< "m_ErrorCounter/m_TotalNumberOfPixelsInInputImage: " << m_ErrorCounter / ((double) (m_TotalNumberOfPixelsInInputImage))); otbMsgDevMacro(<< "m_ImageDeltaEnergy: " << m_ImageDeltaEnergy); ++m_NumberOfIterations; } otbMsgDevMacro(<< "m_NumberOfIterations: " << m_NumberOfIterations); otbMsgDevMacro(<< "m_MaximumNumberOfIterations: " << m_MaximumNumberOfIterations); otbMsgDevMacro(<< "m_ErrorCounter: " << m_ErrorCounter); otbMsgDevMacro(<< "maxNumPixelError: " << maxNumPixelError); //Determine stop condition if (m_NumberOfIterations >= m_MaximumNumberOfIterations) { m_StopCondition = MaximumNumberOfIterations; } else if (m_ErrorCounter <= maxNumPixelError) { m_StopCondition = ErrorTolerance; } } // ApplyMarkovRandomFieldFilter /** *Apply the MRF image filter on the whole image once */ template void MarkovRandomFieldFilter ::MinimizeOnce() { LabelledImageNeighborhoodIterator labelledIterator(m_LabelledImageNeighborhoodRadius, this->GetOutput(), this->GetOutput()->GetLargestPossibleRegion()); InputImageNeighborhoodIterator dataIterator(m_InputImageNeighborhoodRadius, this->GetInput(), this->GetInput()->GetLargestPossibleRegion()); m_ErrorCounter = 0; for (labelledIterator.GoToBegin(), dataIterator.GoToBegin(); !labelledIterator.IsAtEnd(); ++labelledIterator, ++dataIterator) { LabelledImagePixelType value; bool changeValueBool; m_Sampler->Compute(dataIterator, labelledIterator); value = m_Sampler->GetValue(); changeValueBool = m_Optimizer->Compute(m_Sampler->GetDeltaEnergy()); if (changeValueBool) { labelledIterator.SetCenterPixel(value); ++m_ErrorCounter; m_ImageDeltaEnergy += m_Sampler->GetDeltaEnergy(); } } } } // namespace otb #endif OTB-release-5.8/Modules/Learning/Markov/otb-module.cmake000066400000000000000000000006741301006202600231040ustar00rootroot00000000000000set(DOCUMENTATION "Markov Random Fields are probabilistic models that use the statistical dependency between pixels in a neighborhood to infeer the value of a given pixel. This module contains the OTB framework, considered as more flexible than the ITK one.") otb_module(OTBMarkov DEPENDS OTBBoostAdapters OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Learning/Markov/test/000077500000000000000000000000001301006202600210035ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Markov/test/CMakeLists.txt000066400000000000000000000113211301006202600235410ustar00rootroot00000000000000otb_module_test() set(OTBMarkovTests otbMarkovTestDriver.cxx otbMRFEnergyFisherClassification.cxx otbMRFSamplerRandom.cxx otbMRFEnergyPottsNew.cxx otbMRFSamplerMAPNew.cxx otbMarkovRandomFieldFilter.cxx otbMRFSamplerRandomMAPNew.cxx otbMRFSamplerRandomNew.cxx otbMRFEnergyGaussianNew.cxx otbMRFOptimizerMetropolisNew.cxx otbMRFSamplerMAP.cxx otbMRFEnergyGaussian.cxx otbMarkovRandomFieldFilterNew.cxx otbMRFOptimizerMetropolis.cxx otbMRFEnergyPotts.cxx otbMRFEnergyEdgeFidelity.cxx otbMRFSamplerRandomMAP.cxx otbMRFEnergyEdgeFidelityNew.cxx otbMRFOptimizerICM.cxx otbMRFEnergyGaussianClassification.cxx otbMRFOptimizerICMNew.cxx otbMRFEnergyGaussianClassificationNew.cxx ) add_executable(otbMarkovTestDriver ${OTBMarkovTests}) target_link_libraries(otbMarkovTestDriver ${OTBMarkov-Test_LIBRARIES}) otb_module_target_label(otbMarkovTestDriver) # Tests Declaration otb_add_test(NAME maTvMRFEnergyFisherClassification COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFEnergyFisherClassification.txt ${TEMP}/maTvMRFEnergyFisherClassification.txt otbMRFEnergyFisherClassification ${TEMP}/maTvMRFEnergyFisherClassification.txt ) otb_add_test(NAME maTuMRFEnergyFisherClassificationNew COMMAND otbMarkovTestDriver otbMRFEnergyFisherClassificationNew ) otb_add_test(NAME maTvMRFSamplerRandom COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFSamplerRandom.txt ${TEMP}/maTvMRFSamplerRandom.txt otbMRFSamplerRandom ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${TEMP}/maTvMRFSamplerRandom.txt ) otb_add_test(NAME maTuMRFEnergyPottsNew COMMAND otbMarkovTestDriver otbMRFEnergyPottsNew ) otb_add_test(NAME maTuMRFSamplerMAPNew COMMAND otbMarkovTestDriver otbMRFSamplerMAPNew ) otb_add_test(NAME maTvMarkovRandomFieldFilter COMMAND otbMarkovTestDriver --compare-image ${NOTOL} ${BASELINE}/maTvMarkovRandomField.png ${TEMP}/maTvMarkovRandomField.png otbMarkovRandomFieldFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/maTvMarkovRandomField.png 1.0 30 1.0 ) otb_add_test(NAME maTuMRFSamplerRandomMAPNew COMMAND otbMarkovTestDriver otbMRFSamplerRandomMAPNew ) otb_add_test(NAME maTuMRFSamplerRandomNew COMMAND otbMarkovTestDriver otbMRFSamplerRandomNew ) otb_add_test(NAME maTuMRFEnergyGaussianNew COMMAND otbMarkovTestDriver otbMRFEnergyGaussianNew ) otb_add_test(NAME maTuMRFOptimizerMetropolisNew COMMAND otbMarkovTestDriver otbMRFOptimizerMetropolisNew ) otb_add_test(NAME maTvMRFSamplerMAP COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFSamplerMAP.txt ${TEMP}/maTvMRFSamplerMAP.txt otbMRFSamplerMAP ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${TEMP}/maTvMRFSamplerMAP.txt ) otb_add_test(NAME maTvMRFEnergyGaussian COMMAND otbMarkovTestDriver otbMRFEnergyGaussian ) otb_add_test(NAME maTuMarkovRandomFieldFilterNew COMMAND otbMarkovTestDriver otbMarkovRandomFieldFilterNew ) otb_add_test(NAME maTvMRFOptimizerMetropolis COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFOptimizerMetropolis.txt ${TEMP}/maTvMRFOptimizerMetropolis.txt otbMRFOptimizerMetropolis ${TEMP}/maTvMRFOptimizerMetropolis.txt ) otb_add_test(NAME maTvMRFEnergyPotts COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFEnergyPotts.txt ${TEMP}/maTvMRFEnergyPotts.txt otbMRFEnergyPotts ${TEMP}/maTvMRFEnergyPotts.txt ) otb_add_test(NAME maTvMRFEnergyEdgeFidelity COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFEnergyEdgeFidelity.txt ${TEMP}/maTvMRFEnergyEdgeFidelity.txt otbMRFEnergyEdgeFidelity ${TEMP}/maTvMRFEnergyEdgeFidelity.txt ) otb_add_test(NAME maTvMRFSamplerRandomMAP COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFSamplerRandomMAP.txt ${TEMP}/maTvMRFSamplerRandomMAP.txt otbMRFSamplerRandomMAP ${INPUTDATA}/poupees_sub_c1.png ${INPUTDATA}/poupees_sub_c2.png ${TEMP}/maTvMRFSamplerRandomMAP.txt ) otb_add_test(NAME maTuMRFEnergyEdgeFidelityNew COMMAND otbMarkovTestDriver otbMRFEnergyEdgeFidelityNew ) otb_add_test(NAME maTuMRFOptimizerICM COMMAND otbMarkovTestDriver otbMRFOptimizerICM ${TEMP}/maTuMRFOptimizerICM.txt ) otb_add_test(NAME maTvMRFEnergyGaussianClassification COMMAND otbMarkovTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/maTvMRFEnergyGaussianClassification.txt ${TEMP}/maTvMRFEnergyGaussianClassification.txt otbMRFEnergyGaussianClassification ${TEMP}/maTvMRFEnergyGaussianClassification.txt ) otb_add_test(NAME maTuMRFOptimizerICMNew COMMAND otbMarkovTestDriver otbMRFOptimizerICMNew ) otb_add_test(NAME maTuMRFEnergyGaussianClassificationNew COMMAND otbMarkovTestDriver otbMRFEnergyGaussianClassificationNew ) OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyEdgeFidelity.cxx000066400000000000000000000025111301006202600263100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyEdgeFidelity.h" #include "otbImage.h" #include int otbMRFEnergyEdgeFidelity(int itkNotUsed(argc), char * argv[]) { const char * outputFile = argv[1]; typedef double PixelTypeInput; typedef int PixelTypeLabel; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::MRFEnergyEdgeFidelity MRFEnergyType; MRFEnergyType::Pointer object = MRFEnergyType::New(); std::ofstream file; file.open(outputFile); file << "GetSimngleValue(10, 50): " << object->GetSingleValue(10, 50) << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyEdgeFidelityNew.cxx000066400000000000000000000017551301006202600267730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyEdgeFidelity.h" #include "otbImage.h" int otbMRFEnergyEdgeFidelityNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MRFEnergyEdgeFidelity MRFEnergyType; MRFEnergyType::Pointer object = MRFEnergyType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyFisherClassification.cxx000066400000000000000000000041751301006202600300560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This code is from a Jan Wegner contribution. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyFisherClassification.h" #include "otbImage.h" #include int otbMRFEnergyFisherClassificationNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelTypeInput; typedef int PixelTypeLabel; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::MRFEnergyFisherClassification MRFFisherType; MRFFisherType::Pointer classif = MRFFisherType::New(); std::cout << classif << std::endl; return EXIT_SUCCESS; } int otbMRFEnergyFisherClassification(int itkNotUsed(argc), char * argv[]) { const char * outputFile = argv[1]; typedef double PixelTypeInput; typedef int PixelTypeLabel; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::MRFEnergyFisherClassification MRFFisherType; MRFFisherType::Pointer classif = MRFFisherType::New(); classif->SetNumberOfParameters(6); MRFFisherType::ParametersType param(6); param[0] = 0; param[1] = 1; param[2] = 2; param[3] = 3; param[4] = 4; param[5] = 5; classif->SetParameters(param); std::ofstream file; file.open(outputFile); file << std::endl; file << "Number of parameters: " << classif->GetNumberOfParameters() << std::endl; file << "GetSingleValue(10, 1): " << classif->GetSingleValue(10, 1) << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyGaussian.cxx000066400000000000000000000031461301006202600255310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyGaussian.h" #include "otbImage.h" #include int otbMRFEnergyGaussian(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef int PixelType2; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::MRFEnergyGaussian MRFEnergyGaussianType; typedef MRFEnergyGaussianType::InputImagePixelType InputImagePixelType; typedef MRFEnergyGaussianType::LabelledImagePixelType LabelledImagePixelType; MRFEnergyGaussianType::Pointer object = MRFEnergyGaussianType::New(); InputImagePixelType inPix = 10; LabelledImagePixelType inLab = 5; if (object->GetSingleValue(inPix, inLab) != 25) { return EXIT_FAILURE; } inPix = 5; inLab = 10; if (object->GetSingleValue(inPix, inLab) != 25) { return EXIT_FAILURE; } inPix = 0; inLab = 0; if (object->GetSingleValue(inPix, inLab) != 0) { return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyGaussianClassification.cxx000066400000000000000000000031351301006202600304030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyGaussianClassification.h" #include "otbImage.h" #include int otbMRFEnergyGaussianClassification(int itkNotUsed(argc), char * argv[]) { const char * outputFile = argv[1]; typedef double PixelTypeInput; typedef int PixelTypeLabel; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::MRFEnergyGaussianClassification MRFGaussianType; MRFGaussianType::Pointer classif = MRFGaussianType::New(); classif->SetNumberOfParameters(6); MRFGaussianType::ParametersType param(6); param[0] = 0; param[1] = 1; param[2] = 2; param[3] = 3; param[4] = 4; param[5] = 5; classif->SetParameters(param); std::ofstream file; file.open(outputFile); file << std::endl; file << "Number of parameters: " << classif->GetNumberOfParameters() << std::endl; file << "GetSingleValue(10, 1): " << classif->GetSingleValue(10, 2) << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyGaussianClassificationNew.cxx000066400000000000000000000021161301006202600310530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyGaussianClassification.h" #include "otbImage.h" int otbMRFEnergyGaussianClassificationNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MRFEnergyGaussianClassification MRFGaussianType; MRFGaussianType::Pointer object = MRFGaussianType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyGaussianNew.cxx000066400000000000000000000020321301006202600261740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyGaussian.h" #include "otbImage.h" int otbMRFEnergyGaussianNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MRFEnergyGaussian MRFEnergyGaussianType; MRFEnergyGaussianType::Pointer object = MRFEnergyGaussianType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyPotts.cxx000066400000000000000000000035531301006202600250720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyPotts.h" #include "otbImage.h" #include int otbMRFEnergyPotts(int itkNotUsed(argc), char * argv[]) { const char * outputFile = argv[1]; typedef double PixelType; typedef int PixelType2; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::MRFEnergyPotts MRFEnergyPottsType; typedef MRFEnergyPottsType::InputImagePixelType InputImagePixelType; typedef MRFEnergyPottsType::LabelledImagePixelType LabelledImagePixelType; MRFEnergyPottsType::Pointer object = MRFEnergyPottsType::New(); InputImagePixelType inPix = 10; LabelledImagePixelType inLab = 5; std::ofstream file; file.open(outputFile); file << "GetValue(const InputImagePixelType = 10, const LabelledImagePixelType = 5): " << object->GetValue(inPix, inLab) << std::endl; inPix = 5; file << "GetValue(const InputImagePixelType = 5, const LabelledImagePixelType = 5) : " << object->GetValue(inPix, inLab) << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFEnergyPottsNew.cxx000066400000000000000000000020021301006202600255300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFEnergyPotts.h" #include "otbImage.h" int otbMRFEnergyPottsNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MRFEnergyPotts MRFEnergyPottsType; MRFEnergyPottsType::Pointer object = MRFEnergyPottsType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFOptimizerICM.cxx000066400000000000000000000016611301006202600251200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFOptimizerICM.h" #include int otbMRFOptimizerICM(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::MRFOptimizerICM MRFOptimizerICMType; MRFOptimizerICMType::Pointer object = MRFOptimizerICMType::New(); if (object->Compute(-1) != true || object->Compute(1) != false) { return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFOptimizerICMNew.cxx000066400000000000000000000015501301006202600255670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFOptimizerICM.h" #include int otbMRFOptimizerICMNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::MRFOptimizerICM MRFOptimizerType; MRFOptimizerType::Pointer object = MRFOptimizerType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFOptimizerMetropolis.cxx000066400000000000000000000024641301006202600266470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFOptimizerMetropolis.h" #include #include int otbMRFOptimizerMetropolis(int itkNotUsed(argc), char * argv[]) { const char * outputFile = argv[1]; typedef otb::MRFOptimizerMetropolis MRFOptimizerType; MRFOptimizerType::Pointer object = MRFOptimizerType::New(); MRFOptimizerType::ParametersType param(1); param.Fill(10.); object->SetParameters(param); object->InitializeSeed(0); // USED TO OVERPASS RANDOM CALCULATION std::ofstream file; file.open(outputFile); file << "Compute(0) : " << object->Compute(0.) << std::endl; file << "Compute(-1.) : " << object->Compute(-1.) << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFOptimizerMetropolisNew.cxx000066400000000000000000000015751301006202600273230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFOptimizerMetropolis.h" #include int otbMRFOptimizerMetropolisNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::MRFOptimizerMetropolis MRFOptimizerType; MRFOptimizerType::Pointer object = MRFOptimizerType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFSamplerMAP.cxx000066400000000000000000000100431301006202600245400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFSamplerMAP.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "otbMRFEnergyPotts.h" #include int otbMRFSamplerMAP(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const char * labelImage = argv[2]; const char * outputFile = argv[3]; typedef double PixelTypeInput; typedef int PixelTypeLabel; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::ImageFileReader ReaderInputType; typedef otb::ImageFileReader ReaderLabelType; typedef otb::MRFSamplerMAP MRFSamplerMAPType; typedef MRFSamplerMAPType::LabelledImageNeighborhoodIterator LabelledNeighborhoodIterator; typedef MRFSamplerMAPType::InputImageNeighborhoodIterator InputNeighborhoodIterator; typedef otb::MRFEnergyPotts EnergyFidelityType; typedef otb::MRFEnergyPotts EnergyRegularizationType; MRFSamplerMAPType::Pointer object = MRFSamplerMAPType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); ReaderInputType::Pointer readerIn = ReaderInputType::New(); ReaderLabelType::Pointer readerLab = ReaderLabelType::New(); object->SetEnergyFidelity(energyFidelity); object->SetEnergyRegularization(energyRegularization); readerIn->SetFileName(inputImage); readerLab->SetFileName(labelImage); readerIn->Update(); readerLab->Update(); ImageType::IndexType idIn; LabelType::IndexType idLab; idIn[0] = 50; idIn[1] = 50; idLab[0] = 70; idLab[1] = 70; ImageType::PixelType inPix = readerIn->GetOutput()->GetPixel(idIn); LabelType::PixelType inLab = readerLab->GetOutput()->GetPixel(idLab); InputNeighborhoodIterator::RadiusType radIn; LabelledNeighborhoodIterator::RadiusType radLab; radIn.Fill(3); radLab.Fill(3); InputNeighborhoodIterator iterIn = InputNeighborhoodIterator(radIn, readerIn->GetOutput(), readerIn->GetOutput()->GetLargestPossibleRegion()); LabelledNeighborhoodIterator iterLab = LabelledNeighborhoodIterator(radLab, readerLab->GetOutput(), readerLab->GetOutput()->GetLargestPossibleRegion()); std::ofstream file; file.open(outputFile); file << "Used pixels: (50, 50) -> " << inPix << " , (70, 70) -> " << inLab << std::endl; file << std::endl; file << "Compute(const InputNeighborhoodIterator, const LabelledNeighborhoodIterator) " << object->Compute(iterIn, iterLab) << std::endl; // All values (except m_Value) are null : SingleValue return 0... file << "m_EnergyBefore: " << object->GetEnergyBefore() << std::endl; file << "m_EnergyAfter : " << object->GetEnergyAfter() << std::endl; file << "m_Value : " << object->GetValue() << std::endl; file << "m_DeltaEnergy : " << object->GetDeltaEnergy() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFSamplerMAPNew.cxx000066400000000000000000000020101301006202600252050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMRFSamplerMAP.h" #include "otbImage.h" int otbMRFSamplerMAPNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MRFSamplerMAP MRFSamplerType; MRFSamplerType::Pointer object = MRFSamplerType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFSamplerRandom.cxx000066400000000000000000000102161301006202600253450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFSamplerRandom.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "otbMRFEnergyPotts.h" #include int otbMRFSamplerRandom(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const char * labelImage = argv[2]; const char * outputFile = argv[3]; typedef double PixelTypeInput; typedef int PixelTypeLabel; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::ImageFileReader ReaderInputType; typedef otb::ImageFileReader ReaderLabelType; typedef otb::MRFSamplerRandom MRFSamplerRandomType; typedef MRFSamplerRandomType::LabelledImageNeighborhoodIterator LabelledNeighborhoodIterator; typedef MRFSamplerRandomType::InputImageNeighborhoodIterator InputNeighborhoodIterator; typedef otb::MRFEnergyPotts EnergyFidelityType; typedef otb::MRFEnergyPotts EnergyRegularizationType; MRFSamplerRandomType::Pointer object = MRFSamplerRandomType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); ReaderInputType::Pointer readerIn = ReaderInputType::New(); ReaderLabelType::Pointer readerLab = ReaderLabelType::New(); object->SetEnergyFidelity(energyFidelity); object->SetEnergyRegularization(energyRegularization); object->InitializeSeed(0); // USED TO OVERPASS RANDOM CALCULATION readerIn->SetFileName(inputImage); readerLab->SetFileName(labelImage); readerIn->Update(); readerLab->Update(); ImageType::IndexType idIn; LabelType::IndexType idLab; idIn[0] = 50; idIn[1] = 50; idLab[0] = 70; idLab[1] = 70; ImageType::PixelType inPix = readerIn->GetOutput()->GetPixel(idIn); LabelType::PixelType inLab = readerLab->GetOutput()->GetPixel(idLab); InputNeighborhoodIterator::RadiusType radIn; LabelledNeighborhoodIterator::RadiusType radLab; radIn.Fill(3); radLab.Fill(3); InputNeighborhoodIterator iterIn = InputNeighborhoodIterator(radIn, readerIn->GetOutput(), readerIn->GetOutput()->GetLargestPossibleRegion()); LabelledNeighborhoodIterator iterLab = LabelledNeighborhoodIterator(radLab, readerLab->GetOutput(), readerLab->GetOutput()->GetLargestPossibleRegion()); std::ofstream file; file.open(outputFile); file << "Used pixels: (50, 50) -> " << inPix << " , (70, 70) -> " << inLab << std::endl; file << std::endl; file << "Compute(const InputNeighborhoodIterator, const LabelledNeighborhoodIterator) " << object->Compute(iterIn, iterLab) << std::endl; // All values (except m_Value) are null : SingleValue return 0... file << "m_EnergyBefore: " << object->GetEnergyBefore() << std::endl; file << "m_EnergyAfter : " << object->GetEnergyAfter() << std::endl; file << "m_Value : " << object->GetValue() << std::endl; file << "m_DeltaEnergy : " << object->GetDeltaEnergy() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFSamplerRandomMAP.cxx000066400000000000000000000100351301006202600257020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFSamplerRandomMAP.h" #include "otbImageFileReader.h" #include "otbImage.h" #include "otbMRFEnergyPotts.h" #include int otbMRFSamplerRandomMAP(int itkNotUsed(argc), char * argv[]) { const char * inputImage = argv[1]; const char * labelImage = argv[2]; const char * outputFile = argv[3]; typedef double PixelTypeInput; typedef int PixelTypeLabel; typedef otb::Image ImageType; typedef otb::Image LabelType; typedef otb::ImageFileReader ReaderInputType; typedef otb::ImageFileReader ReaderLabelType; typedef otb::MRFSamplerRandomMAP MRFSamplerRandomMAPType; typedef otb::MRFEnergyPotts EnergyFidelityType; typedef otb::MRFEnergyPotts EnergyRegularizationType; typedef MRFSamplerRandomMAPType::LabelledImageNeighborhoodIterator LabelledNeighborhoodIterator; typedef MRFSamplerRandomMAPType::InputImageNeighborhoodIterator InputNeighborhoodIterator; MRFSamplerRandomMAPType::Pointer object = MRFSamplerRandomMAPType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); ReaderInputType::Pointer readerIn = ReaderInputType::New(); ReaderLabelType::Pointer readerLab = ReaderLabelType::New(); readerIn->SetFileName(inputImage); readerLab->SetFileName(labelImage); readerIn->Update(); readerLab->Update(); object->SetNumberOfClasses(1); object->SetEnergyFidelity(energyFidelity); object->SetEnergyRegularization(energyRegularization); object->InitializeSeed(0); // USED TO OVERPASS RANDOM CALCULATION ImageType::IndexType idIn; LabelType::IndexType idLab; idIn[0] = 50; idIn[1] = 50; idLab[0] = 70; idLab[1] = 70; ImageType::PixelType inPix = readerIn->GetOutput()->GetPixel(idIn); LabelType::PixelType inLab = readerLab->GetOutput()->GetPixel(idLab); InputNeighborhoodIterator::RadiusType radIn; LabelledNeighborhoodIterator::RadiusType radLab; radIn.Fill(3); radLab.Fill(3); InputNeighborhoodIterator iterIn = InputNeighborhoodIterator(radIn, readerIn->GetOutput(), readerIn->GetOutput()->GetLargestPossibleRegion()); LabelledNeighborhoodIterator iterLab = LabelledNeighborhoodIterator(radLab, readerLab->GetOutput(), readerLab->GetOutput()->GetLargestPossibleRegion()); std::ofstream file; file.open(outputFile); file << "Used pixels: (50, 50) -> " << inPix << " , (70, 70) -> " << inLab << std::endl; file << std::endl; file << "Compute( Compute( const InputImageNeighborhoodIterator, const LabelledImageNeighborhoodIterator) " << object->Compute(iterIn, iterLab) << std::endl; // All values (except m_Value) are null : SingleValue return 0... file << "m_EnergyBefore: " << object->GetEnergyBefore() << std::endl; file << "m_EnergyAfter: " << object->GetEnergyAfter() << std::endl; file << "m_Value: " << object->GetValue() << std::endl; file << "m_DeltaEnergy: " << object->GetDeltaEnergy() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFSamplerRandomMAPNew.cxx000066400000000000000000000020411301006202600263520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFSamplerRandomMAP.h" #include "otbImage.h" int otbMRFSamplerRandomMAPNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MRFSamplerRandomMAP MRFSamplerRandomType; MRFSamplerRandomType::Pointer object = MRFSamplerRandomType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMRFSamplerRandomNew.cxx000066400000000000000000000020221301006202600260130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMRFSamplerRandom.h" #include "otbImage.h" int otbMRFSamplerRandomNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MRFSamplerRandom MRFSamplerRandomType; MRFSamplerRandomType::Pointer object = MRFSamplerRandomType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMarkovRandomFieldFilter.cxx000066400000000000000000000102611301006202600267460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "otbMarkovRandomFieldFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkRescaleIntensityImageFilter.h" #include "otbMRFEnergyPotts.h" #include "otbMRFEnergyGaussianClassification.h" #include "otbMRFOptimizerMetropolis.h" #include "otbMRFSamplerRandom.h" int otbMarkovRandomFieldFilter(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; typedef double InternalPixelType; typedef unsigned char LabelledPixelType; typedef otb::Image InputImageType; typedef otb::Image LabelledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); typedef otb::MarkovRandomFieldFilter MarkovRandomFieldFilterType; typedef otb::MRFSamplerRandom SamplerType; typedef otb::MRFOptimizerMetropolis OptimizerType; typedef otb::MRFEnergyPotts EnergyRegularizationType; typedef otb::MRFEnergyGaussianClassification EnergyFidelityType; MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); EnergyFidelityType::Pointer energyFidelity = EnergyFidelityType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); SamplerType::Pointer sampler = SamplerType::New(); // Overpass random calculation(for test only): sampler->InitializeSeed(0); optimizer->InitializeSeed(1); markovFilter->InitializeSeed(2); unsigned int nClass = 4; energyFidelity->SetNumberOfParameters(2 * nClass); EnergyFidelityType::ParametersType parameters; parameters.SetSize(energyFidelity->GetNumberOfParameters()); parameters[0] = 10.0; //Class 0 mean parameters[1] = 10.0; //Class 0 stdev parameters[2] = 80.0; //Class 1 mean parameters[3] = 10.0; //Class 1 stdev parameters[4] = 150.0; //Class 2 mean parameters[5] = 10.0; //Class 2 stdev parameters[6] = 220.0; //Class 3 mean parameters[7] = 10.0; //Class 3 stde energyFidelity->SetParameters(parameters); optimizer->SetSingleParameter(atof(argv[5])); markovFilter->SetNumberOfClasses(nClass); markovFilter->SetMaximumNumberOfIterations(atoi(argv[4])); markovFilter->SetErrorTolerance(0.0); markovFilter->SetLambda(atof(argv[3])); markovFilter->SetNeighborhoodRadius(1); markovFilter->SetEnergyRegularization(energyRegularization); markovFilter->SetEnergyFidelity(energyFidelity); markovFilter->SetOptimizer(optimizer); markovFilter->SetSampler(sampler); markovFilter->SetInput(reader->GetOutput()); typedef itk::RescaleIntensityImageFilter RescaleType; RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); rescaleFilter->SetInput(markovFilter->GetOutput()); writer->SetInput(rescaleFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMarkovRandomFieldFilterNew.cxx000066400000000000000000000021121301006202600274140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMarkovRandomFieldFilter.h" #include "otbImage.h" int otbMarkovRandomFieldFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double PixelType; typedef otb::Image ImageType; typedef otb::MarkovRandomFieldFilter MarkovRandomFieldFilterType; MarkovRandomFieldFilterType::Pointer object = MarkovRandomFieldFilterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Markov/test/otbMarkovTestDriver.cxx000066400000000000000000000017571301006202600255210ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMRFEnergyFisherClassificationNew); REGISTER_TEST(otbMRFEnergyFisherClassification); REGISTER_TEST(otbMRFSamplerRandom); REGISTER_TEST(otbMRFEnergyPottsNew); REGISTER_TEST(otbMRFSamplerMAPNew); REGISTER_TEST(otbMarkovRandomFieldFilter); REGISTER_TEST(otbMRFSamplerRandomMAPNew); REGISTER_TEST(otbMRFSamplerRandomNew); REGISTER_TEST(otbMRFEnergyGaussianNew); REGISTER_TEST(otbMRFOptimizerMetropolisNew); REGISTER_TEST(otbMRFSamplerMAP); REGISTER_TEST(otbMRFEnergyGaussian); REGISTER_TEST(otbMarkovRandomFieldFilterNew); REGISTER_TEST(otbMRFOptimizerMetropolis); REGISTER_TEST(otbMRFEnergyPotts); REGISTER_TEST(otbMRFEnergyEdgeFidelity); REGISTER_TEST(otbMRFSamplerRandomMAP); REGISTER_TEST(otbMRFEnergyEdgeFidelityNew); REGISTER_TEST(otbMRFOptimizerICM); REGISTER_TEST(otbMRFEnergyGaussianClassification); REGISTER_TEST(otbMRFOptimizerICMNew); REGISTER_TEST(otbMRFEnergyGaussianClassificationNew); } OTB-release-5.8/Modules/Learning/SOM/000077500000000000000000000000001301006202600172235ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/SOM/CMakeLists.txt000066400000000000000000000000421301006202600217570ustar00rootroot00000000000000project(OTBSOM) otb_module_impl() OTB-release-5.8/Modules/Learning/SOM/include/000077500000000000000000000000001301006202600206465ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/SOM/include/otbCzihoSOMLearningBehaviorFunctor.h000066400000000000000000000072551301006202600276710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCzihoSOMLearningBehaviorFunctor_h #define otbCzihoSOMLearningBehaviorFunctor_h #include "itkSize.h" #include "otbMath.h" namespace otb { namespace Functor { /** \class CzihoSOMLearningBehaviorFunctor * \brief Beta behavior over SOM training phase * * This class implements an evolution of the \f$ \beta \f$ weightening * coefficient over the SOM training. It is issued from A. Cziho's PhD: * "Compression d'images et analyse de contenu par quantification vectorielle" * PhD dissertation, University of Rennes I, Rennes, France. May 5th, 1999. * * Its behavior is decomposed into two steps depending on the number of iterations: * \f[ \beta = \begin{cases} \beta_0 \left( 1 - \frac{t}{t_0} \right) & \textrm{ if } t < t_0 \\ \beta_{\textrm{end}} \left( 1- \frac{t-t_O}{t_{\textrm{end}}-t_0} \right) & \textrm{ if } t_0 \leqslant t < t_{\textrm{end}} \end{cases} \f] * where \f$ t_0 \f$ stands for IterationThreshold. * * CzihoSOMLearningBehaviorFunctor uses some parameters of the SOM class such as: * BetaInit, BetaEnd, NumberOfIterations, but also NeighborhoodSizeInit which may be * (surprisingly) required for the IterationThreshold. * * The functor function uses \code NumberOfIterations \endcode, \code BetaInit \endcode, \code BetaEnd \endcode parameters, that is * why it is necessary to call a specific method for \code IterationThreshold \endcode initialization. * * \sa SOM * * \ingroup OTBSOM */ class CzihoSOMLearningBehaviorFunctor { public: /** Empty constructor / descructor */ CzihoSOMLearningBehaviorFunctor () { m_IterationThreshold = 0; } virtual ~CzihoSOMLearningBehaviorFunctor() {} /** Accessors */ unsigned int GetIterationThreshold() { return this->m_IterationThreshold; } template void SetIterationThreshold(const itk::Size& sizeInit, unsigned int iterMax) { double V0 = static_cast(sizeInit[0]); for (unsigned int i = 1; i < VDimension; ++i) { if (V0 < static_cast(sizeInit[i])) V0 = static_cast(sizeInit[i]); } m_IterationThreshold = static_cast( static_cast(iterMax) * (1.0 - 1.0 / ::vcl_sqrt(V0))); } /** Functor */ virtual double operator ()(unsigned int currentIteration, unsigned int numberOfIterations, double betaInit, double betaEnd) const { if (currentIteration < m_IterationThreshold) { return betaInit * (1.0 - static_cast(currentIteration) / static_cast(numberOfIterations)); } else { return betaEnd * (1.0 - static_cast(currentIteration - m_IterationThreshold) / static_cast(numberOfIterations - m_IterationThreshold)); } } private: unsigned int m_IterationThreshold; }; // end of class CzihoSOMLearningBehaviorFunctor } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbCzihoSOMNeighborhoodBehaviorFunctor.h000066400000000000000000000055241301006202600305360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCzihoSOMNeighborhoodBehaviorFunctor_h #define otbCzihoSOMNeighborhoodBehaviorFunctor_h #include "itkSize.h" #include "itkMath.h" namespace otb { namespace Functor { /** \class CzihoSOMNeighborhoodBehaviorFunctor * \brief Neighborhood size behavior over SOM training phase * * This class implements an evolution of the neighborhood size * over the SOM training. It is issued from A. Cziho's PhD: * "Compression d'images et analyse de contenu par quantification vectorielle" * PhD dissertation, University of Rennes I, Rennes, France. May 5th, 1999. * * The behavior of the radius r (\em ie. \code SizeType \endcode component 0, 1, ...) is given by: * \f$ r = r_{\textrm{init}} \left( 1 - \frac{t}{t_{\textrm{end}}} \right)^2 \f$ * * CzihoSOMNeighborhoodBehaviorFunctor uses some parameters of the SOM class such as: * \code NeighborhoodSizeInit \endcode, \code NumberOfIterations \endcode which are parameters of the functor function. * \code operator() \endcode is templated with the dimension of the neighborhoodSize. * * \sa SOM * * \ingroup OTBSOM */ class CzihoSOMNeighborhoodBehaviorFunctor { public: /** Empty constructor / descructor */ CzihoSOMNeighborhoodBehaviorFunctor () {} virtual ~CzihoSOMNeighborhoodBehaviorFunctor() {} /** Functor */ template itk::Size operator ()(unsigned int currentIteration, unsigned int numberOfIterations, const itk::Size& sizeInit) const { itk::Size theSize; double weightening = ::vcl_pow(1.0 - static_cast(currentIteration) / static_cast(numberOfIterations), 2.0); for (unsigned int i = 0; i < VDimension; ++i) { theSize[i] = static_cast::SizeValueType> ( static_cast(sizeInit[i]) * weightening); } return theSize; } }; // end of class CzihoSOMNeighborhoodBehaviorFunctor } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbPeriodicSOM.h000066400000000000000000000107641301006202600236510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPeriodicSOM_h #define otbPeriodicSOM_h #include "otbSOM.h" namespace otb { /** * \class PeriodicSOM * \brief This class is responsible for the learning of a self organizing * map when considered as a torus. * * This class extends the SOM object which implements the Self * Organizing Map (or Kohonen map) learning. * * The learning process iteratively select the best-response neuron for each input vector, * enhancing its response and the response of its neighbors with respect to a certain radius, * computed from an initial radius, and to a certain learning factor, decreasing at each iteration. * * The behavior of the neighborhood is given by a functor (templated) which parameter is the current * iteration. It returns a neighborhood of type \code SizeType \endcode. * * The behavior of the learning factor (hold by a beta variable) is given by an other functor * which parameter is the current iteration. It returns a beta value of type \code double \endcode. * * The SOMMap produced as output can be either initialized with a constant custom value or randomly * generated following a normal law. The seed for the random initialization can be modified. * * \sa SOMMap * \sa SOMActivationBuilder * \sa CzihoSOMLearningBehaviorFunctor * \sa CzihoSOMNeighborhoodBehaviorFunctor * * \ingroup OTBSOM */ template class ITK_EXPORT PeriodicSOM : public SOM { public: /** Standard typedefs */ typedef PeriodicSOM Self; typedef SOM Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(PeriodicSOM, SOM); typedef TListSample ListSampleType; typedef typename ListSampleType::Pointer ListSamplePointerType; typedef TMap MapType; typedef typename MapType::PixelType NeuronType; typedef typename NeuronType::ValueType ValueType; typedef typename MapType::IndexType IndexType; typedef typename MapType::SizeType SizeType; typedef typename MapType::RegionType RegionType; typedef typename MapType::Pointer MapPointerType; protected: /** Constructor */ PeriodicSOM() {} /** Destructor */ ~PeriodicSOM() ITK_OVERRIDE {} /** Output information redefinition */ void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation (); } /** Output allocation redefinition */ void AllocateOutputs() ITK_OVERRIDE { Superclass::AllocateOutputs(); } /** Main computation method */ void GenerateData(void) ITK_OVERRIDE { Superclass::GenerateData(); } /** * Update the output map with a new sample. * \param sample The new sample to learn, * \param beta The learning coefficient, * \param radius The radius of the nieghbourhood. */ void UpdateMap(const NeuronType& sample, double beta, SizeType& radius) ITK_OVERRIDE; /** * Step one iteration. */ void Step(unsigned int currentIteration) ITK_OVERRIDE { Superclass::Step(currentIteration); } /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: PeriodicSOM(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPeriodicSOM.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbPeriodicSOM.txx000066400000000000000000000064741301006202600242500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPeriodicSOM_txx #define otbPeriodicSOM_txx #include "itkNumericTraits.h" #include "itkNeighborhoodIterator.h" #include "otbPeriodicSOM.h" namespace otb { /** * Update the output map with a new sample. * \param sample The new sample to learn, * \param beta The learning coefficient, * \param radius The radius of the neighbourhood. */ template void PeriodicSOM ::UpdateMap(const NeuronType& sample, double beta, SizeType& radius) { unsigned int i, j; // output map pointer MapPointerType map = this->GetOutput(0); // winner index in the map IndexType position = map->GetWinner(sample); NeuronType winner = map->GetPixel(position); // Local neighborhood definition typedef typename MapType::Superclass ImageMapType; typedef itk::NeighborhoodIterator NeighborhoodIteratorType; typename MapType::RegionType mapRegion = map->GetLargestPossibleRegion(); NeighborhoodIteratorType it(radius, map, mapRegion); // Here, the periodic update is achieved 'by hand' since // PeriodicBoundaryCondition does not allow modifying // VectorImage contents SizeType mapSize = mapRegion.GetSize(); IndexType positionToUpdate; // Iterate over the neighborhood ot the winner neuron it.SetLocation(position); for (i = 0; i < it.Size(); ++i) { typename NeighborhoodIteratorType::OffsetType offset = it.GetOffset(i); // The neighborhood is of elliptic shape double theDistance = itk::NumericTraits::Zero; for (j = 0; j < MapType::ImageDimension; ++j) theDistance += pow(static_cast(offset[j]), 2.0) / pow(static_cast(radius[j]), 2.0); if (theDistance <= 1.0) { for (j = 0; j < MapType::ImageDimension; ++j) { int pos = offset[j] + position[j]; positionToUpdate[j] = (pos >= 0) ? pos % mapSize[j] : (mapSize[j] - ((-pos) % mapSize[j])) % mapSize[j]; } NeuronType tempNeuron = it.GetPixel(i); // NeuronType newNeuron ( tempNeuron.Size() ); // newNeuron.Fill( 0.0 ); // FIXME NeuronType newNeuron(tempNeuron); double tempBeta = beta / (1.0 + theDistance); for (j = 0; j < newNeuron.Size(); ++j) { newNeuron[j] += static_cast( (sample[j] - tempNeuron[j]) * tempBeta); } map->SetPixel(positionToUpdate, newNeuron); } } } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOM.h000066400000000000000000000144041301006202600221650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOM_h #define otbSOM_h #include "itkImageToImageFilter.h" #include "itkEuclideanDistanceMetric.h" #include "otbCzihoSOMLearningBehaviorFunctor.h" #include "otbCzihoSOMNeighborhoodBehaviorFunctor.h" namespace otb { /** * \class SOM * \brief This class is responsible for the learning of a self organizing map from a * set of vector represented by the input image (each vector is a pixel of the image). * * The learning process iteratively select the best-response neuron for each input vector, * enhancing its response and the response of its neighbors with respect to a certain radius, * computed from an initial radius, and to a certain learning factor, decreasing at each iteration. * * The behavior of the neighborhood is given by a functor (templated) which parameter is the current * iteration. It returns a neighborhood of type \code SizeType \endcode. * * The behavior of the learning factor (hold by a beta variable) is given by an other functor * which parameter is the current iteration. It returns a beta value of type double. * * The SOMMap produced as output can be either initialized with a constant custom value or randomly * generated following a normal law. The seed for the random initialization can be modified. * * \sa SOMMap * \sa SOMActivationBuilder * \sa CzihoSOMLearningBehaviorFunctor * \sa CzihoSOMNeighborhoodBehaviorFunctor * * \ingroup OTBSOM */ template class ITK_EXPORT SOM : public itk::ImageSource { public: /** Standard typedefs */ typedef SOM Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(SOM, ImageSource); typedef TListSample ListSampleType; typedef typename ListSampleType::Pointer ListSamplePointerType; typedef TMap MapType; typedef typename MapType::PixelType NeuronType; typedef typename NeuronType::ValueType ValueType; typedef typename MapType::IndexType IndexType; typedef typename MapType::SizeType SizeType; typedef typename MapType::RegionType RegionType; typedef typename MapType::Pointer MapPointerType; typedef TSOMLearningBehaviorFunctor SOMLearningBehaviorFunctorType; typedef TSOMNeighborhoodBehaviorFunctor SOMNeighborhoodBehaviorFunctorType; /** Map dimension */ itkStaticConstMacro(MapDimension, unsigned int, MapType::ImageDimension); /** Accessors */ itkSetMacro(NumberOfIterations, unsigned int); itkGetMacro(NumberOfIterations, unsigned int); itkSetMacro(BetaInit, double); itkGetMacro(BetaInit, double); itkSetMacro(BetaEnd, double); itkGetMacro(BetaEnd, double); itkSetMacro(MinWeight, ValueType); itkGetMacro(MinWeight, ValueType); itkSetMacro(MaxWeight, ValueType); itkGetMacro(MaxWeight, ValueType); itkSetMacro(MapSize, SizeType); itkGetMacro(MapSize, SizeType); itkSetMacro(NeighborhoodSizeInit, SizeType); itkGetMacro(NeighborhoodSizeInit, SizeType); itkSetMacro(RandomInit, bool); itkGetMacro(RandomInit, bool); itkSetMacro(Seed, unsigned int); itkGetMacro(Seed, unsigned int); itkGetObjectMacro(ListSample, ListSampleType); itkSetObjectMacro(ListSample, ListSampleType); void SetBetaFunctor(const SOMLearningBehaviorFunctorType& functor) { m_BetaFunctor = functor; } void SetNeighborhoodSizeFunctor(const SOMNeighborhoodBehaviorFunctorType& functor) { m_NeighborhoodSizeFunctor = functor; } protected: /** Constructor */ SOM(); /** Destructor */ ~SOM() ITK_OVERRIDE; /** Output information redefinition */ void GenerateOutputInformation() ITK_OVERRIDE; /** Output allocation redefinition */ void AllocateOutputs() ITK_OVERRIDE; /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** * Update the output map with a new sample. * \param sample The new sample to learn, * \param beta The learning coefficient, * \param radius The radius of the nieghbourhood. */ virtual void UpdateMap(const NeuronType& sample, double beta, SizeType& radius); /** * Step one iteration. */ virtual void Step(unsigned int currentIteration); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SOM(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** Size of the neurons map */ SizeType m_MapSize; /** Number of iterations */ unsigned int m_NumberOfIterations; /** Initial learning coefficient */ double m_BetaInit; /** Final learning coefficient */ double m_BetaEnd; /** Initial neighborhood size */ SizeType m_NeighborhoodSizeInit; /** Minimum initial neuron weights */ ValueType m_MinWeight; /** Maximum initial neuron weights */ ValueType m_MaxWeight; /** Random initialization bool */ bool m_RandomInit; /** Seed for random initialization */ unsigned int m_Seed; /** The input list sample */ ListSamplePointerType m_ListSample; /** Behavior of the Learning weightening (link to the beta coefficient) */ SOMLearningBehaviorFunctorType m_BetaFunctor; /** Behavior of the Neighborhood extent */ SOMNeighborhoodBehaviorFunctorType m_NeighborhoodSizeFunctor; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSOM.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOM.txx000066400000000000000000000174301301006202600225630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOM_txx #define otbSOM_txx #include "otbSOM.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkFixedArray.h" #include "otbMacro.h" #include "itkImageRegionIterator.h" #include "itkMersenneTwisterRandomVariateGenerator.h" namespace otb { /** * Constructor */ template SOM ::SOM() { this->SetNumberOfRequiredInputs(0); this->SetNumberOfRequiredOutputs(1); m_MapSize.Fill(10); m_NumberOfIterations = 10; m_BetaInit = 1.0; m_BetaEnd = 0.2; m_NeighborhoodSizeInit.Fill(3); m_MinWeight = static_cast(0.0); m_MaxWeight = static_cast(128.0); m_RandomInit = false; m_Seed = 123574651; } /** * Destructor */ template SOM ::~SOM() { } /** * Update the output map with a new sample. * \param sample The new sample to learn, * \param beta The learning coefficient, * \param radius The radius of the nieghbourhood. */ template void SOM ::UpdateMap(const NeuronType& sample, double beta, SizeType& radius) { // output map pointer MapPointerType map = this->GetOutput(0); // typedefs typedef itk::ImageRegionIteratorWithIndex IteratorType; typedef itk::FixedArray FixedArrayIndexType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typename DistanceType::Pointer distance = DistanceType::New(); // winner index in the map IndexType position = map->GetWinner(sample); NeuronType winner = map->GetPixel(position); // Local neighborhood definition RegionType localRegion; IndexType localIndex = position - radius; SizeType localSize; for (unsigned int i = 0; i < MapType::ImageDimension; ++i) { localSize[i] = 2 * radius[i] + 1; } localRegion.SetIndex(localIndex); localRegion.SetSize(localSize); localRegion.Crop(map->GetLargestPossibleRegion()); IteratorType it(map, localRegion); // Walk through the map, and evolve each neuron depending on its // distance to the winner. for (it.GoToBegin(); !it.IsAtEnd(); ++it) { NeuronType tempNeuron = it.Get(); NeuronType newNeuron(tempNeuron.Size()); FixedArrayIndexType positionFA,indexFA; positionFA[0] = position[0]; positionFA[1] = position[1]; indexFA[0] = it.GetIndex()[0]; indexFA[1] = it.GetIndex()[1]; double tempBeta = beta / (1 + distance->Evaluate(positionFA, indexFA)); for (unsigned int i = 0; i < newNeuron.Size(); ++i) { newNeuron[i] = tempNeuron[i] + static_cast( (sample[i] - tempNeuron[i]) * tempBeta); } it.Set(newNeuron); } } /** * Step one iteration. */ template void SOM ::Step(unsigned int currentIteration) { // Compute the new learning coefficient double newBeta = m_BetaFunctor( currentIteration, m_NumberOfIterations, m_BetaInit, m_BetaEnd); // Compute the new neighborhood size SizeType newSize = m_NeighborhoodSizeFunctor( currentIteration, m_NumberOfIterations, m_NeighborhoodSizeInit); // update the neurons map with each example of the training set. otbMsgDebugMacro(<< "Beta: " << newBeta << ", radius: " << newSize); for (typename ListSampleType::Iterator it = m_ListSample->Begin(); it != m_ListSample->End(); ++it) { UpdateMap(it.GetMeasurementVector(), newBeta, newSize); } } /** * Output information redefinition */ template void SOM ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel( m_ListSample->GetMeasurementVectorSize()); IndexType index; index.Fill(0); RegionType region; region.SetIndex(index); region.SetSize(this->GetMapSize()); this->GetOutput()->SetRegions(region); } /** * Output redefinition */ template void SOM ::AllocateOutputs() { if (this->GetNumberOfOutputs() != 1) itkExceptionMacro(<< "Number of output image should be 1"); // output neuron map fill MapPointerType map = this->GetOutput(0); map->Allocate(); } /** * Main computation method */ template void SOM ::GenerateData(void) { this->AllocateOutputs(); this->BeforeThreadedGenerateData(); MapPointerType map = this->GetOutput(0); if (m_RandomInit) { typedef itk::Statistics::MersenneTwisterRandomVariateGenerator GeneratorType; typedef itk::ImageRegionIterator IteratorType; GeneratorType::Pointer generator = GeneratorType::New(); generator->Initialize(m_Seed); NeuronType neuronInit(m_ListSample->GetMeasurementVectorSize()); IteratorType it(map, map->GetLargestPossibleRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { for (unsigned int i = 0; i < neuronInit.Size(); ++i) { neuronInit[i] = static_cast( generator->GetUniformVariate(static_cast(m_MinWeight), static_cast(m_MaxWeight))); } it.Set(neuronInit); } } else { NeuronType neuronInit(m_ListSample->GetMeasurementVectorSize()); neuronInit.Fill(m_MaxWeight); map->FillBuffer(neuronInit); } // Step through the iterations for (unsigned int i = 0; i < m_NumberOfIterations; ++i) { //otbMsgDebugMacro(<<"Step "<AfterThreadedGenerateData(); } /** *PrintSelf method */ template void SOM ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMActivationBuilder.h000066400000000000000000000054701301006202600255210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMActivationBuilder_h #define otbSOMActivationBuilder_h #include "itkImageToImageFilter.h" namespace otb { /** \class SOMActivationBuilder * \brief This class takes a self organizing map and an input vector image, and * produce a map counting the number of activation for each vector in the SOM map. * * SOM map can be set via the SetInput method, and vector image via the SetVectorSet * method. * * \sa SOMMap * \sa SOM * * \ingroup OTBSOM */ template class ITK_EXPORT SOMActivationBuilder : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef SOMActivationBuilder Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(SOMActivationBuilder, ImageToImageFilter); /** Template related typedefs */ typedef TListSample ListSampleType; typedef TOutputImage OutputImageType; typedef TInputMap InputMapType; typedef typename ListSampleType::Pointer ListSamplePointerType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename InputMapType::Pointer InputMapPointerType; /** Image Dimension */ itkStaticConstMacro(ImageDimension, unsigned int, InputMapType::ImageDimension); /** ListSample accessor */ itkSetObjectMacro(ListSample, ListSampleType); itkGetObjectMacro(ListSample, ListSampleType); protected: /** Constructor */ SOMActivationBuilder(); /** Destructor */ ~SOMActivationBuilder() ITK_OVERRIDE; /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SOMActivationBuilder(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented /** ListSample object */ ListSamplePointerType m_ListSample; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSOMActivationBuilder.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMActivationBuilder.txx000066400000000000000000000050251301006202600261110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMActivationBuilder_txx #define otbSOMActivationBuilder_txx #include "otbSOMActivationBuilder.h" #include "itkImageRegionIterator.h" namespace otb { /** * Constructor. */ template SOMActivationBuilder ::SOMActivationBuilder() { this->SetNumberOfRequiredInputs(1); this->SetNthOutput(0, OutputImageType::New()); } /** * Destructor. */ template SOMActivationBuilder ::~SOMActivationBuilder() {} /** * Main computation method */ template void SOMActivationBuilder ::GenerateData(void) { // Retrieve the inputs and output pointers InputMapType * map = const_cast(this->GetInput()); OutputImagePointerType output = this->GetOutput(); // output initialization output->SetRegions(map->GetLargestPossibleRegion()); output->Allocate(); output->FillBuffer(static_cast(0)); // Iterator typedef typedef itk::ImageRegionIterator OutputIteratorType; typename InputMapType::IndexType index; // Iterators instantiation OutputIteratorType outIt(output, output->GetLargestPossibleRegion()); // For each vector in the set for (typename ListSampleType::Iterator it = m_ListSample->Begin(); it != m_ListSample->End(); ++it) { // Retrieve the index of the winner index = map->GetWinner(it.GetMeasurementVector()); // increment the activation map outIt.SetIndex(index); outIt.Set(outIt.Get() + 1); } } /** *PrintSelf method */ template void SOMActivationBuilder ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMClassifier.h000066400000000000000000000061251301006202600241730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMClassifier_h #define otbSOMClassifier_h #include "itkProcessObject.h" #include "itkMembershipSample.h" namespace otb { /** \class SOMClassifier * \brief This class implements a SOM-Based classifier. * * The classifier iterates on the input list sample, feeding * the output membership sample with the one-dimensionnal index * of the winner neuron. * * Since this classifier differs from the base framework of itk in that it * does not use DecisionRule and Memberships function, it derives from itk::ProcessObject * instead of itk::SampleClassifierBase. * * \sa SOM, SOMMap, SOMActivationBuilder. * * \ingroup OTBSOM */ template class ITK_EXPORT SOMClassifier : public itk::ProcessObject { public: /** Standard class typedef*/ typedef SOMClassifier Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkTypeMacro(SOMClassifier, itk::ProcessObject); itkNewMacro(Self); /** typedefs from TSample object */ typedef TSample SampleType; typedef typename SampleType::Pointer SamplePointerType; typedef typename SampleType::MeasurementType MeasurementType; typedef typename SampleType::MeasurementVectorType MeasurementVectorType; typedef typename SampleType::MeasurementVectorType::ValueType InputPixelType; /** SOM Map typedefs */ typedef TSOMMap SOMMapType; typedef typename SOMMapType::Pointer SOMMapPointerType; /** Output typedefs */ typedef itk::Statistics::MembershipSample OutputType; typedef typename OutputType::Pointer OutputPointerType; /** Label type typedef */ typedef TLabel ClassLabelType; /// Accessors void SetMap(SOMMapType * sommap); SOMMapType * GetMap(void); itkSetObjectMacro(Sample, SampleType); itkGetObjectMacro(Sample, SampleType); OutputType * GetOutput(); protected: /** Constructor */ SOMClassifier(); /** Destructor */ ~SOMClassifier() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Starts the classification process */ void GenerateData() ITK_OVERRIDE; private: /// The input sample SamplePointerType m_Sample; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSOMClassifier.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMClassifier.txx000066400000000000000000000067461301006202600246000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMClassifier_txx #define otbSOMClassifier_txx #include "otbSOMClassifier.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template SOMClassifier ::SOMClassifier() { this->SetNumberOfRequiredInputs(1); SOMMapPointerType sommap = SOMMapType::New(); this->SetNthInput(0, sommap.GetPointer()); m_Sample = SampleType::New(); OutputPointerType outputPtr = OutputType::New(); this->SetNthOutput(0, outputPtr.GetPointer()); } template typename SOMClassifier ::OutputType * SOMClassifier ::GetOutput() { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } /** * SOMMap getter. */ template typename SOMClassifier ::SOMMapType * SOMClassifier ::GetMap(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(0)); } /** * SOMMap Setter. */ template void SOMClassifier ::SetMap(SOMMapType * sommap) { this->itk::ProcessObject::SetNthInput(0, const_cast(sommap)); } /** * PrintSelf method */ template void SOMClassifier ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } /** * Main computation class. */ template void SOMClassifier ::GenerateData() { typename OutputType::Pointer outputPtr = this->GetOutput(); outputPtr->SetSample(this->GetSample()); // outputPtr->Resize(this->GetSample()->Size()); //FIXME Check if still required typename SOMMapType::SizeType size = this->GetMap()->GetLargestPossibleRegion().GetSize(); unsigned int numberOfClasses = 1; for (unsigned int i = 0; i < SOMMapType::ImageDimension; ++i) { numberOfClasses *= size[i]; } outputPtr->SetNumberOfClasses(numberOfClasses); typename TSample::Iterator iter = this->GetSample()->Begin(); typename TSample::Iterator end = this->GetSample()->End(); typename OutputType::ConstIterator iterO = outputPtr->Begin(); typename OutputType::ConstIterator endO = outputPtr->End(); typename TSample::MeasurementVectorType measurements; typename SOMMapType::IndexType index; SOMMapPointerType somMap = this->GetMap(); otbMsgDebugMacro(<< "Starting iterations "); while (iter != end && iterO != endO) { measurements = iter.GetMeasurementVector(); index = somMap->GetWinner(measurements); ClassLabelType classLabel = static_cast((index[1] * size[1]) + index[0]); outputPtr->AddInstance(classLabel, iterO.GetInstanceIdentifier()); ++iter; ++iterO; } } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMImageClassificationFilter.h000066400000000000000000000110461301006202600271510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMImageClassificationFilter_h #define otbSOMImageClassificationFilter_h #include "otbSOMClassifier.h" #include "itkInPlaceImageFilter.h" #include "itkListSample.h" namespace otb { /** \class SOMImageClassificationFilter * \brief This filter performs the classification of a VectorImage using a given SOM map. * * This filter is streamed and threaded, allowing to classify huge images. Because the * internal sample type has to be an itk::FixedArray, one must specify at compilation time * the maximum sample dimension. It is up to the user to specify a MaxSampleDimension sufficiently * high to integrate all its features. This filter internally use one SVMClassifier per thread. * * \sa SVMClassifier * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBSOM */ template class ITK_EXPORT SOMImageClassificationFilter : public itk::InPlaceImageFilter { public: /** Standard typedefs */ typedef SOMImageClassificationFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SOMImageClassificationFilter, InPlaceImageFilter); typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::InternalPixelType ValueType; typedef TMaskImage MaskImageType; typedef typename MaskImageType::ConstPointer MaskImageConstPointerType; typedef typename MaskImageType::Pointer MaskImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType LabelType; typedef TSOMMap SOMMapType; typedef typename SOMMapType::Pointer SOMMapPointerType; typedef typename SOMMapType::PixelType SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef typename ListSampleType::Pointer ListSamplePointerType; typedef otb::SOMClassifier ClassifierType; typedef typename ClassifierType::Pointer ClassifierPointerType; /** Set/Get the svm model */ itkSetObjectMacro(Map, SOMMapType); itkGetObjectMacro(Map, SOMMapType); /** Set/Get the default label */ itkSetMacro(DefaultLabel, LabelType); itkGetMacro(DefaultLabel, LabelType); /** * If set, only pixels within the mask will be classified. * \param mask The input mask. */ void SetInputMask(const MaskImageType * mask); /** * Get the input mask. * \return The mask. */ const MaskImageType * GetInputMask(void); protected: /** Constructor */ SOMImageClassificationFilter(); /** Destructor */ ~SOMImageClassificationFilter() ITK_OVERRIDE {} /** Threaded generate data */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SOMImageClassificationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The SOM model used for classification */ SOMMapPointerType m_Map; /** Default label for invalid pixels (when using a mask) */ LabelType m_DefaultLabel; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSOMImageClassificationFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMImageClassificationFilter.txx000066400000000000000000000121641301006202600275470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMImageClassificationFilter_txx #define otbSOMImageClassificationFilter_txx #include "otbSOMImageClassificationFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template SOMImageClassificationFilter ::SOMImageClassificationFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(1); m_DefaultLabel = itk::NumericTraits::ZeroValue(); } template void SOMImageClassificationFilter ::SetInputMask(const MaskImageType * mask) { this->itk::ProcessObject::SetNthInput(1, const_cast(mask)); } template const typename SOMImageClassificationFilter ::MaskImageType * SOMImageClassificationFilter ::GetInputMask() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void SOMImageClassificationFilter ::BeforeThreadedGenerateData() { if (!m_Map) { itkGenericExceptionMacro(<< "No model for classification"); } } template void SOMImageClassificationFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { InputImageConstPointerType inputPtr = this->GetInput(); MaskImageConstPointerType inputMaskPtr = this->GetInputMask(); OutputImagePointerType outputPtr = this->GetOutput(); typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator MaskIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; ListSamplePointerType listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(inputPtr->GetNumberOfComponentsPerPixel()); InputIteratorType inIt(inputPtr, outputRegionForThread); MaskIteratorType maskIt; if (inputMaskPtr) { maskIt = MaskIteratorType(inputMaskPtr, outputRegionForThread); maskIt.GoToBegin(); } unsigned int maxDimension = m_Map->GetNumberOfComponentsPerPixel(); unsigned int sampleSize = std::min(inputPtr->GetNumberOfComponentsPerPixel(), maxDimension); bool validPoint = true; for (inIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt) { if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } if (validPoint) { SampleType sample; sample.SetSize(sampleSize); sample.Fill(itk::NumericTraits::ZeroValue()); for (unsigned int i = 0; i < sampleSize; ++i) { sample[i] = inIt.Get()[i]; } listSample->PushBack(sample); } } ClassifierPointerType classifier = ClassifierType::New(); classifier->SetMap(m_Map); classifier->SetSample(listSample); classifier->Update(); typename ClassifierType::OutputType::Pointer membershipSample = classifier->GetOutput(); typename ClassifierType::OutputType::ConstIterator sampleIter = membershipSample->Begin(); typename ClassifierType::OutputType::ConstIterator sampleLast = membershipSample->End(); OutputIteratorType outIt(outputPtr, outputRegionForThread); outIt.GoToBegin(); while (!outIt.IsAtEnd() && (sampleIter != sampleLast)) { outIt.Set(m_DefaultLabel); ++outIt; } outIt.GoToBegin(); if (inputMaskPtr) { maskIt.GoToBegin(); } validPoint = true; while (!outIt.IsAtEnd() && (sampleIter != sampleLast)) { if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } if (validPoint) { outIt.Set(sampleIter.GetClassLabel()); ++sampleIter; } ++outIt; } } /** * PrintSelf Method */ template void SOMImageClassificationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMLearningBehaviorFunctor.h000066400000000000000000000034001301006202600266600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMLearningBehaviorFunctor_h #define otbSOMLearningBehaviorFunctor_h namespace otb { namespace Functor { /** \class SOMLearningBehaviorFunctor * \brief Classical Beta behavior over SOM training phase * * This class implements an standard evolution of the \f$ \beta \f$ weightening * coefficient over the SOM training. * * \f[ \beta = \beta_0 + \left( \beta_{\textrm{end}} - \beta_0 \right) \frac{t}{t_{\textrm{end}}} \f] * * \sa SOM * * \ingroup OTBSOM */ class SOMLearningBehaviorFunctor { public: /** Empty constructor / descructor */ SOMLearningBehaviorFunctor () {} virtual ~SOMLearningBehaviorFunctor() {} /** Functor */ virtual double operator ()(unsigned int currentIteration, unsigned int numberOfIterations, double betaInit, double betaEnd) const { return betaInit + (betaEnd - betaInit) * static_cast(currentIteration) / static_cast(numberOfIterations); } }; // end of class SOMLearningBehaviorFunctor } // end namespace Functor } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMMap.h000066400000000000000000000071571301006202600226320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All right reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMMap_h #define otbSOMMap_h #include "itkVariableLengthVector.h" #include "itkEuclideanDistanceMetric.h" #include "otbVectorImage.h" namespace otb { /** * \class SOMMap * \brief This class represent a Self Organizing Map. * * The Self organizing map (or Kohonen map) is a type of neural networks. It is based on an analogy with * the visual cortex, where similar inputs activate neighbor neurons. * * This class extends the Image object, where each pixel represents a neuron in the map. * It is templated with a distance parameter used to compute the neuron response to an input. * Thanks to the extension of the Image object, reading and writing is supported through standard image * readers and writers. * * The training is done via the SOM class, and the activation map can be produced with the SOMActivationBuilder * class. * * \sa SOM * \sa SOMActivationBuilder * * \ingroup OTBSOM */ template , class TDistance = itk::Statistics::EuclideanDistanceMetric, unsigned int VMapDimension = 2> class ITK_EXPORT SOMMap : public otb::VectorImage { public: /** Standard typedefs */ typedef SOMMap Self; typedef otb::VectorImage Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** * There is no runtime information macro since * this class has to be considered to as a simple VectorImage * // itkTypeMacro(SOMMap, VectorImage); * */ /** Template parameters related typedefs */ typedef TNeuron NeuronType; typedef TDistance DistanceType; typedef typename DistanceType::Pointer DistancePointerType; /** Superclass related typedefs */ typedef typename Superclass::IndexType IndexType; typedef typename Superclass::SizeType SizeType; typedef typename Superclass::DirectionType DirectionType; typedef typename Superclass::RegionType RegionType; typedef typename Superclass::SpacingType SpacingType; typedef typename Superclass::PointType PointType; /** * Get The index of the winning neuron for a sample. * \param sample the sample. * \return The index of the winning neuron. */ IndexType GetWinner(const NeuronType& sample); protected: /** Constructor */ SOMMap(); /** Destructor */ ~SOMMap() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SOMMap(const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSOMMap.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMMap.txx000066400000000000000000000047421301006202600232230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom Bretagne. All right reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMMap_txx #define otbSOMMap_txx #include "otbSOMMap.h" #include "itkImageRegionIteratorWithIndex.h" namespace otb { /** * Constructor */ template SOMMap ::SOMMap() {} /** * Destructor */ template SOMMap ::~SOMMap() {} /** * Get The index of the winning neuron for a sample. * \param sample The sample * \return The index of the winning neuron. */ template typename SOMMap ::IndexType SOMMap ::GetWinner(const NeuronType& sample) { // Some typedefs typedef itk::ImageRegionIteratorWithIndex IteratorType; // Define the euclidean distance used to compute the neural response DistancePointerType activation = DistanceType::New(); // Define the iterator used to walk through the map IteratorType it(this, this->GetLargestPossibleRegion()); it.GoToBegin(); // Define the minimum distance and position IndexType minPos = it.GetIndex(); double minDistance = activation->Evaluate(sample, it.Get()); // Iterate through the map to get the minimum distance position for (; !it.IsAtEnd(); ++it) { double tempDistance = activation->Evaluate(sample, it.Get()); if (tempDistance <= minDistance) { minDistance = tempDistance; minPos = it.GetIndex(); } } // Return the index of the winner return minPos; } template void SOMMap ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMWithMissingValue.h000066400000000000000000000077761301006202600253660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMWithMissingValue_h #define otbSOMWithMissingValue_h #include "otbPeriodicSOM.h" namespace otb { /** * \class SOMWithMissingValue * \brief This class implements SOM training with missing value * * The distance between vectors that may have missing components is holded * by the EuclideanDistanceMetricWithMissingValue class in the SOMMap distance * template. Nevertheless, this class re-implements the UpdateMap method to * adapt the evaluation of each component of the 'newNeuron' when dealing * with missing values. * * TMap has to be templeted with EuclideanDistanceMetricWithMissingValuePow2 * * \sa SOMMap * \sa PeriodicSOM * \sa EuclideanDistanceMetricWithMissingValue * * \ingroup OTBSOM */ template class ITK_EXPORT SOMWithMissingValue : public PeriodicSOM { public: /** Standard typedefs */ typedef SOMWithMissingValue Self; typedef PeriodicSOM Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TListSample ListSampleType; typedef typename ListSampleType::Pointer ListSamplePointerType; typedef TMap MapType; typedef typename MapType::PixelType NeuronType; typedef typename NeuronType::ValueType ValueType; typedef typename MapType::IndexType IndexType; typedef typename MapType::SizeType SizeType; typedef typename MapType::RegionType RegionType; typedef typename MapType::Pointer MapPointerType; typedef typename MapType::DistanceType DistanceType; typedef typename MapType::DistancePointerType DistancePointerType; /** Creation through object factory macro */ itkNewMacro(Self); /** Runtime information macro */ itkTypeMacro(SOMWithMissingValue, PeriodicSOM); protected: /** Constructor */ SOMWithMissingValue (); /** Destructor */ ~SOMWithMissingValue() ITK_OVERRIDE; /** Output information redefinition */ void GenerateOutputInformation() ITK_OVERRIDE { Superclass::GenerateOutputInformation (); } /** Output allocation redefinition */ void AllocateOutputs() ITK_OVERRIDE { Superclass::AllocateOutputs(); } /** Main computation method */ void GenerateData(void) ITK_OVERRIDE { Superclass::GenerateData(); } /** * Update the output map with a new sample, depending on the availability of the data */ void UpdateMap(const NeuronType& sample, double beta, SizeType& radius) ITK_OVERRIDE; /** Step one iteration. */ void Step(unsigned int currentIteration) ITK_OVERRIDE { Superclass::Step(currentIteration); } /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SOMWithMissingValue (const Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSOMWithMissingValue.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMWithMissingValue.txx000066400000000000000000000104261301006202600257440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMWithMissingValue_txx #define otbSOMWithMissingValue_txx #include "otbSOMWithMissingValue.h" #include "itkNumericTraits.h" #include "itkNeighborhoodIterator.h" #include "otbMacro.h" namespace otb { template SOMWithMissingValue ::SOMWithMissingValue(void) {} template SOMWithMissingValue ::~SOMWithMissingValue(void) {} /** * Update the output map with a new sample by including the case when some * components of this new sample may be missing. * \param sample The new sample to learn, * \param beta The learning coefficient, * \param radius The radius of the nieghbourhood. */ template void SOMWithMissingValue ::UpdateMap(const NeuronType& sample, double beta, SizeType& radius) { // output map pointer MapPointerType map = this->GetOutput(0); // winner index in the map IndexType position = map->GetWinner(sample); NeuronType winner = map->GetPixel(position); // Local neighborhood definition typedef typename MapType::Superclass ImageMapType; typedef itk::NeighborhoodIterator NeighborhoodIteratorType; typename MapType::RegionType mapRegion = map->GetLargestPossibleRegion(); NeighborhoodIteratorType it(radius, map, mapRegion); // Here, the periodic update is achieved 'by hand' since // PeriodicBoundaryCondition does not allow modifying // VectorImage contents SizeType mapSize = mapRegion.GetSize(); IndexType positionToUpdate; // Iterate over the neighborhood ot the winner neuron it.SetLocation(position); for (unsigned int i = 0; i < it.Size(); ++i) { typename NeighborhoodIteratorType::OffsetType offset = it.GetOffset(i); // The neighborhood is of elliptic shape double theDistance = itk::NumericTraits::Zero; for (unsigned int j = 0; j < MapType::ImageDimension; ++j) theDistance += pow(static_cast(offset[j]), 2.0) / pow(static_cast(radius[j]), 2.0); if (theDistance <= 1.0) { for (unsigned int j = 0; j < MapType::ImageDimension; ++j) { int pos = offset[j] + position[j]; positionToUpdate[j] = (pos >= 0) ? pos % mapSize[j] : (mapSize[j] - ((-pos) % mapSize[j])) % mapSize[j]; } NeuronType tempNeuron = it.GetPixel(i); NeuronType newNeuron(tempNeuron); double tempBeta = beta / (1.0 + theDistance); for (unsigned int j = 0; j < newNeuron.Size(); ++j) { if (!DistanceType::IsMissingValue(sample[j])) newNeuron[j] += static_cast( (sample[j] - tempNeuron[j]) * tempBeta); } map->SetPixel(positionToUpdate, newNeuron); } } } template void SOMWithMissingValue ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // end PrintSelf } // end iof namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMbasedImageFilter.h000066400000000000000000000123211301006202600252710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMbasedImageFilter_h #define otbSOMbasedImageFilter_h #include "itkMacro.h" #include "itkUnaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class SOMbasedImageFilterFunctor * \brief This class implements the functor that perform substitution between * input image pixels and the corresponding winning neurons of a Kohonen map. * * On the contrary to SOMClassifier, it does not yield labels but the * value of the winning neurons. Also, it is threaded... * * \ingroup OTBSOM */ template class ITK_EXPORT SOMbasedImageFilterFunctor { public: /** Standard typedefs */ typedef SOMbasedImageFilterFunctor Self; typedef TMap MapType; typedef typename MapType::Pointer MapPointerType; typedef typename MapType::IndexType IndexType; typedef typename MapType::PixelType NeuronType; typedef TDistanceMetric DistanceType; typedef typename DistanceType::Pointer DistancePointerType; /** Standard Constructor */ SOMbasedImageFilterFunctor () {} virtual ~SOMbasedImageFilterFunctor () {} /** Functor */ TOutput operator ()(const TInput& input); /** Get/Set the Map */ MapType * GetMap() const { return this->m_Map; } void SetMap(const MapType * theMap); /** Get the DistanceMetric */ DistanceType * GetDistance() { return this->m_Distance; } protected: /** GetWinner redefinition by using its own TDistanceMetric that * could be different from the one of the SOM map */ IndexType GetWinner(const NeuronType& sample); MapPointerType m_Map; DistancePointerType m_Distance; private: SOMbasedImageFilterFunctor (const Self &); // not implemented void operator =(const Self&); // not implemented }; } // end of namespace Functor /** \class SOMbasedImageFilter * \brief This class perform the substitution between initial input image * pixels and the winning neurons of a SOM. * * It performs the projection of the SOM onto the data. On the contrary to * otb::SOMClassifier, it does not yield labels but an image which * corresponds to the quantized version of the initial image when considering * SOMmap as a codebook of a vector quantization. * * SOMbasedImageFilter is templated over a TDistanceMetric since it could be * different from the initial DistanceMetric used for the SOM training. Moreover * TMap is a template for the SOM that can be a simple VectorImage. * * \ingroup Streamed * \sa EuclideanDistanceMetricWithMissingValue * * \ingroup OTBSOM */ template class ITK_EXPORT SOMbasedImageFilter : public itk::UnaryFunctorImageFilter > { public: /** Standard class typedefs. */ typedef SOMbasedImageFilter Self; typedef typename itk::UnaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SOMbasedImageFilter, UnaryFunctorImageFilter); /** Some convenient typedefs. */ typedef TDistanceMetric DistanceMetricType; typedef typename DistanceMetricType::Pointer DistanceMetricPointerType; typedef TMap MapType; typedef typename MapType::Pointer MapPointerType; typedef Functor::SOMbasedImageFilterFunctor< typename TInputImage::PixelType, typename TOutputImage::PixelType, TDistanceMetric, TMap> FunctorType; /** Vectors that hold the training area */ typedef typename TInputImage::PixelType MeasurementType; /** Set the SOM map (or VectorImage) */ void SetMap(const MapType * theMap); protected: // throw the Map to the functor void BeforeThreadedGenerateData(void) ITK_OVERRIDE; SOMbasedImageFilter (); ~SOMbasedImageFilter () ITK_OVERRIDE {} private: SOMbasedImageFilter (const Self &); void operator =(const Self&); //purposely not implemented MapPointerType m_Map; }; // end of class SOMbasedImageFilter } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSOMbasedImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/SOM/include/otbSOMbasedImageFilter.txx000066400000000000000000000057251301006202600256770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSOMbasedImageFilter_txx #define otbSOMbasedImageFilter_txx #include "otbSOMbasedImageFilter.h" namespace otb { namespace Functor { template TOutput SOMbasedImageFilterFunctor ::operator() (const TInput &input) { return static_cast(GetMap()->GetPixel(this->GetWinner(input))); } template void SOMbasedImageFilterFunctor ::SetMap(const MapType * theMap) { m_Map = const_cast(theMap); m_Distance = DistanceType::New(); } template typename SOMbasedImageFilterFunctor::IndexType SOMbasedImageFilterFunctor ::GetWinner(const NeuronType& sample) { typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it(GetMap(), GetMap()->GetLargestPossibleRegion()); it.GoToBegin(); IndexType minPos = it.GetIndex(); double tempDistance, minDistance = GetDistance()->Evaluate(sample, it.Get()); ++it; while (!it.IsAtEnd()) { tempDistance = GetDistance()->Evaluate(sample, it.Get()); if (tempDistance < minDistance) { minDistance = tempDistance; minPos = it.GetIndex(); } ++it; } return minPos; } } // end of namespace Functor /* * Implementation of the class SOMbasedImageFilter */ template SOMbasedImageFilter ::SOMbasedImageFilter () { this->SetNumberOfRequiredInputs(1); this->InPlaceOff(); } template void SOMbasedImageFilter ::SetMap(const MapType * theMap) { m_Map = const_cast(theMap); this->Modified(); } template void SOMbasedImageFilter ::BeforeThreadedGenerateData() { m_Map->Update(); this->GetFunctor().SetMap(m_Map); } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/SOM/otb-module.cmake000066400000000000000000000010331301006202600222710ustar00rootroot00000000000000set(DOCUMENTATION "The Self Organizing Map, SOM, introduced by Kohonen is a non-supervised neural learning algorithm. The map is composed of neighboring cells which are in competition by means of mutual interactions and they adapt in order to match characteristic patterns of the examples given during the learning. The SOM is usually on a plane (2D).") otb_module(OTBSOM DEPENDS OTBCommon OTBITK OTBImageBase TEST_DEPENDS OTBImageIO OTBImageManipulation OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Learning/SOM/test/000077500000000000000000000000001301006202600202025ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/SOM/test/CMakeLists.txt000066400000000000000000000071401301006202600227440ustar00rootroot00000000000000otb_module_test() set(OTBSOMTests otbSOMTestDriver.cxx otbSOMbasedImageFilterNew.cxx otbSOM.cxx otbSOMImageClassificationFilter.cxx otbSOMActivationBuilder.cxx otbSOMActivationBuilderNew.cxx otbSOMClassifierNew.cxx otbSOMImageClassificationFilterNew.cxx otbSOMWithMissingValue.cxx otbSOMNew.cxx otbSOMMap.cxx otbSOMWithMissingValueNew.cxx otbSOMMapNew.cxx otbPeriodicSOM.cxx otbPeriodicSOMNew.cxx otbSOMClassifier.cxx otbSOMbasedImageFilter.cxx ) add_executable(otbSOMTestDriver ${OTBSOMTests}) target_link_libraries(otbSOMTestDriver ${OTBSOM-Test_LIBRARIES}) otb_module_target_label(otbSOMTestDriver) # Tests Declaration otb_add_test(NAME leTuSOMbasedImageFilterNew COMMAND otbSOMTestDriver otbSOMbasedImageFilterNew ) otb_add_test(NAME leTvSOM COMMAND otbSOMTestDriver --compare-image ${EPSILON_10} ${BASELINE}/leSOMPoupeesSubOutputMap1.hdr ${TEMP}/leSOMPoupeesSubOutputMap1.hdr otbSOM ${INPUTDATA}/poupees_sub.png ${TEMP}/leSOMPoupeesSubOutputMap1.hdr 32 32 10 10 5 1.0 0.1 0) otb_add_test(NAME leTvSOMImageClassificationFilter COMMAND otbSOMTestDriver --compare-image ${NOTOL} ${BASELINE}/leSOMPoupeesClassified.hdr ${TEMP}/leSOMImageClassificationFilterOutput.hdr otbSOMImageClassificationFilter ${INPUTDATA}/poupees_sub.png ${BASELINE}/leSOMPoupeesSubOutputMap1.hdr ${TEMP}/leSOMImageClassificationFilterOutput.hdr ) otb_add_test(NAME leTvSOMActivationBuilder COMMAND otbSOMTestDriver --compare-image ${NOTOL} ${BASELINE}/leSOMPoupeesSubActivationMap1.hdr ${TEMP}/leSOMPoupeesSubActivationMap1.tif otbSOMActivationBuilder ${INPUTDATA}/poupees_sub.png ${BASELINE}/leSOMPoupeesSubOutputMap1.hdr ${TEMP}/leSOMPoupeesSubActivationMap1.tif 32 32 10 10 5 1.0 0.1 128) otb_add_test(NAME leTuSOMActivationBuilderNew COMMAND otbSOMTestDriver otbSOMActivationBuilderNew) otb_add_test(NAME leTuSOMClassifierNew COMMAND otbSOMTestDriver otbSOMClassifierNew) otb_add_test(NAME leTuSOMImageClassificationFilterNew COMMAND otbSOMTestDriver otbSOMImageClassificationFilterNew) otb_add_test(NAME leTvSOMWithMissingValue COMMAND otbSOMTestDriver --compare-image ${EPSILON_10} ${BASELINE}/leSOMWithMissingValue.hdr ${TEMP}/leSOMWithMissingValue.hdr otbSOMWithMissingValueTest ${INPUTDATA}/poupees_sub.png ${TEMP}/leSOMWithMissingValue.hdr 32 32 10 10 5 1.0 0.1 0) otb_add_test(NAME leTuSOMNew COMMAND otbSOMTestDriver otbSOMNew) otb_add_test(NAME leTvSOMMap COMMAND otbSOMTestDriver otbSOMMap) otb_add_test(NAME leTuSOMWithMissingValueNew COMMAND otbSOMTestDriver otbSOMWithMissingValueNew ) otb_add_test(NAME leTuSOMMapNew COMMAND otbSOMTestDriver otbSOMMapNew) otb_add_test(NAME leTvPeriodicSOM COMMAND otbSOMTestDriver --compare-image ${EPSILON_10} ${BASELINE}/lePeriodicSOMPoupeesSubOutputMap1.hdr ${TEMP}/lePeriodicSOMPoupeesSubOutputMap1.hdr otbPeriodicSOMTest ${INPUTDATA}/poupees_sub.png ${TEMP}/lePeriodicSOMPoupeesSubOutputMap1.hdr 32 32 10 10 5 1.0 0.1 0) otb_add_test(NAME leTuPeriodicSOMNew COMMAND otbSOMTestDriver otbPeriodicSOMNew) otb_add_test(NAME leTvSOMClassifier COMMAND otbSOMTestDriver --compare-image ${NOTOL} ${BASELINE}/leSOMPoupeesClassified.hdr ${TEMP}/leSOMPoupeesClassified.hdr otbSOMClassifier ${INPUTDATA}/poupees_sub.png ${BASELINE}/leSOMPoupeesSubOutputMap1.hdr ${TEMP}/leSOMPoupeesClassified.hdr ) otb_add_test(NAME leTvSOMbasedImageFilter COMMAND otbSOMTestDriver --compare-image ${NOTOL} ${BASELINE}/leSOMbasedImageFilterOutput.hdr ${TEMP}/leSOMbasedImageFilterOutput.hdr otbSOMbasedImageFilterTest ${INPUTDATA}/poupees_sub.png ${BASELINE}/leSOMPoupeesSubOutputMap1.hdr ${TEMP}/leSOMbasedImageFilterOutput.hdr ) OTB-release-5.8/Modules/Learning/SOM/test/MapActivation.cxx000066400000000000000000000146131301006202600234720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include #include #include "otbSOMMap.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkImageRegionIterator.h" #include "otbImage.h" #include "otbSOMMap.h" #include "otbSOM.h" #include "otbSOMActivationBuilder.h" #include "itkVectorExpandImageFilter.h" #include "itkVectorNearestNeighborInterpolateImageFunction.h" #include "itkExpandImageFilter.h" #include "itkNearestNeighborInterpolateImageFunction.h" #include "itkListSample.h" #include "otbSOMClassifier.h" int main(int argc, char* argv[]) { if (argc < 12) { std::cout << "Usage : " << argv[0] << " inputTabImage size radius NumberOfIterations BetaInit BetaEnd MaxWeight MinWeight som actMap som" << std::endl; return EXIT_FAILURE; } typedef otb::Image ListImageType; typedef otb::ImageFileReader TabReaderType; TabReaderType::Pointer Tabreader = TabReaderType::New(); Tabreader->SetFileName(argv[1]); Tabreader->Update(); ListImageType::Pointer tabreadImage = Tabreader->GetOutput(); typedef itk::ImageRegionIterator IteratorType; IteratorType It1(tabreadImage, tabreadImage->GetLargestPossibleRegion()); const int nblines = 591; //const int)(tabreadImage->GetLargestPossibleRegion().GetSize()[1]); const int nbcolonnes = 9; //(const int)tabreadImage->GetLargestPossibleRegion().GetSize()[0]; double vectTab[nblines][nbcolonnes]; std::cout << "lignes = " << nblines << " colonnes = " << nbcolonnes << std::endl; for (It1.GoToBegin(); !It1.IsAtEnd(); ++It1) { vectTab[It1.GetIndex()[1]][It1.GetIndex()[0]] = It1.Get(); } typedef itk::VariableLengthVector MeasurementVectorType; typedef itk::Statistics::ListSample SampleType; SampleType::Pointer liste = SampleType::New(); liste->SetMeasurementVectorSize(nbcolonnes); for (int j = 0; j < nblines; ++j) { MeasurementVectorType tab; tab.SetSize(nbcolonnes); for (int i = 0; i < nbcolonnes; ++i) { tab[i] = vectTab[j][i]; } liste->PushBack(tab); } // std::cout<<"liste: "<GetMeasurementVectorSize()<< " " << liste->GetMeasurementVector(1) // <<" " <GetMeasurementVector(2)<< " " <GetMeasurementVector(3)< DistanceType; typedef otb::SOMMap MapType; typedef otb::SOM SOMType; SOMType::Pointer som = SOMType::New(); som->SetListSample(liste); SOMType::SizeType som_size; som_size[0] = atoi(argv[2]); som_size[1] = atoi(argv[2]); som->SetMapSize(som_size); SOMType::SizeType radius; radius[0] = atoi(argv[3]); radius[1] = atoi(argv[3]); som->SetNeighborhoodSizeInit(radius); som->SetNumberOfIterations(atoi(argv[4])); som->SetBetaInit(atoi(argv[5])); som->SetBetaEnd(atoi(argv[6])); som->SetMaxWeight(atoi(argv[7])); som->SetMinWeight(atoi(argv[8])); som->Update(); typedef otb::ImageFileWriter SomWriterType; SomWriterType::Pointer somwriter = SomWriterType::New(); somwriter->SetFileName(argv[9] /*"som.hd"*/); somwriter->SetInput(som->GetOutput()); somwriter->Update(); typedef unsigned char OutputPixelType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter ActivationWriterType; typedef otb::SOMActivationBuilder SOMActivationBuilderType; SOMActivationBuilderType::Pointer somAct = SOMActivationBuilderType::New(); somAct->SetInput(som->GetOutput()); somAct->SetListSample(liste); ActivationWriterType::Pointer actWriter = ActivationWriterType::New(); actWriter->SetFileName(argv[10] /*"actMap.png"*/); actWriter->SetInput(somAct->GetOutput()); actWriter->Update(); //Classifier : typedef otb::ImageFileReader SOMReaderType; typedef otb::SOMClassifier ClassifierType; SOMReaderType::Pointer somreader = SOMReaderType::New(); somreader->SetFileName(argv[11] /*"som.mhd"*/); somreader->Update(); ClassifierType::Pointer classifier = ClassifierType::New(); classifier->SetSample(liste); classifier->SetMap(somreader->GetOutput()); classifier->Update(); ClassifierType::OutputType* membershipSample = classifier->GetOutput(); // std::cout<<"liste: "<GetMeasurementVectorSize()<< " " << membershipSample->GetMeasurementVector(1)<Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); /*int count[16]; for(int i=0; i<16; ++i) { count[i]=0; } */ while (m_iter != m_last) { // std::cout<<" classlabel : "<GetClassSample(m_iter.GetClassLabel())<< // std::endl; //count[m_iter.GetClassLabel()]++; ++m_iter; } /*for(int i=0; i<16; ++i) { std::cout<<" classe: "<< i <<" nb elements= "<GetNumberOfClasses(); std::cout << " nb of classes= " << nbclass << std::endl; //FIXME methods not available in the new stat framework API /* for (int i = 0; i < nbclass; i++) { if (membershipSample->GetInternalClassLabel(i) != -1) { std::cout << "classlabel= " << i << " classSize= " << membershipSample->GetClassSampleSize(i) << std::endl; } } */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbPeriodicSOM.cxx000066400000000000000000000062031301006202600235510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "otbPeriodicSOM.h" #include "itkRGBPixel.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkListSample.h" #include "itkImageRegionIterator.h" int otbPeriodicSOMTest(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; char * inputFileName = argv[1]; char * outputFileName = argv[2]; unsigned int sizeX = atoi(argv[3]); unsigned int sizeY = atoi(argv[4]); unsigned int neighInitX = atoi(argv[5]); unsigned int neighInitY = atoi(argv[6]); unsigned int nbIterations = atoi(argv[7]); double betaInit = atof(argv[8]); double betaEnd = atof(argv[9]); double initValue = atof(argv[10]); typedef double ComponentType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap MapType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::PeriodicSOM SOMType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); reader->Update(); ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); itk::ImageRegionIterator it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { listSample->PushBack(it.Get()); ++it; } std::cout << "LIST SAMPLE SIZE: " << listSample->GetMeasurementVectorSize() << std::endl; // Instantiation SOMType::Pointer som = SOMType::New(); som->SetListSample(listSample); SOMType::SizeType size; size[0] = sizeX; size[1] = sizeY; som->SetMapSize(size); SOMType::SizeType radius; radius[0] = neighInitX; radius[1] = neighInitY; som->SetNeighborhoodSizeInit(radius); som->SetNumberOfIterations(nbIterations); som->SetBetaInit(betaInit); som->SetBetaEnd(betaEnd); som->SetMaxWeight(initValue); som->SetRandomInit(false); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(som->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbPeriodicSOMNew.cxx000066400000000000000000000026221301006202600242240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "otbPeriodicSOM.h" #include "itkRGBPixel.h" #include "itkListSample.h" int otbPeriodicSOMNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float ComponentType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; // typedef itk::Statistics::ImageToListAdaptor AdaptorType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::PeriodicSOM SOMType; // Instantiation SOMType::Pointer som = SOMType::New(); std::cout << som << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOM.cxx000066400000000000000000000061371301006202600221000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "otbSOM.h" #include "itkRGBPixel.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkListSample.h" #include "itkImageRegionIterator.h" int otbSOM(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; char * inputFileName = argv[1]; char * outputFileName = argv[2]; unsigned int sizeX = atoi(argv[3]); unsigned int sizeY = atoi(argv[4]); unsigned int neighInitX = atoi(argv[5]); unsigned int neighInitY = atoi(argv[6]); unsigned int nbIterations = atoi(argv[7]); double betaInit = atof(argv[8]); double betaEnd = atof(argv[9]); double initValue = atof(argv[10]); typedef double ComponentType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap MapType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::SOM SOMType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); reader->Update(); ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); itk::ImageRegionIterator it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { listSample->PushBack(it.Get()); ++it; } std::cout << "LIST SAMPLE SIZE: " << listSample->GetMeasurementVectorSize() << std::endl; // Instantiation SOMType::Pointer som = SOMType::New(); som->SetListSample(listSample); SOMType::SizeType size; size[0] = sizeX; size[1] = sizeY; som->SetMapSize(size); SOMType::SizeType radius; radius[0] = neighInitX; radius[1] = neighInitY; som->SetNeighborhoodSizeInit(radius); som->SetNumberOfIterations(nbIterations); som->SetBetaInit(betaInit); som->SetBetaEnd(betaEnd); som->SetMaxWeight(initValue); som->SetRandomInit(false); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(som->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMActivationBuilder.cxx000066400000000000000000000054211301006202600254240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbSOMMap.h" #include "otbSOMActivationBuilder.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkListSample.h" #include "itkImageRegionIterator.h" int otbSOMActivationBuilder(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; char * vectorSetFileName = argv[1]; char * mapFileName = argv[2]; char * outputFileName = argv[3]; typedef float ComponentType; typedef unsigned char OutputPixelType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap MapType; typedef otb::ImageFileReader MapReaderType; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; typedef otb::SOMActivationBuilder SOMActivationBuilderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(vectorSetFileName); reader->Update(); ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); itk::ImageRegionIterator it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { listSample->PushBack(it.Get()); ++it; } MapReaderType::Pointer mapReader = MapReaderType::New(); mapReader->SetFileName(mapFileName); SOMActivationBuilderType::Pointer somAct = SOMActivationBuilderType::New(); somAct->SetInput(mapReader->GetOutput()); somAct->SetListSample(listSample); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(somAct->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMActivationBuilderNew.cxx000066400000000000000000000032031301006202600260720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "otbSOM.h" #include "otbSOMActivationBuilder.h" #include "itkListSample.h" #include "otbImage.h" int otbSOMActivationBuilderNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float ComponentType; typedef unsigned char OutputPixelType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap MapType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::Image OutputImageType; typedef otb::SOMActivationBuilder SOMActivationBuilderType; // Instantiation SOMActivationBuilderType::Pointer somAct = SOMActivationBuilderType::New(); std::cout << somAct << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMClassifier.cxx000066400000000000000000000075621301006202600241100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbSOMMap.h" #include "otbSOMClassifier.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkImageRegionIterator.h" #include "itkListSample.h" int otbSOMClassifier(int argc, char* argv[]) { if (argc != 4) { std::cout << "Usage : " << argv[0] << " inputImage modelFile outputImage" << std::endl; return EXIT_FAILURE; } const char * imageFilename = argv[1]; const char * mapFilename = argv[2]; const char * outputFilename = argv[3]; typedef double InputPixelType; typedef int LabelPixelType; const unsigned int Dimension = 2; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; typedef otb::VectorImage InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader SOMReaderType; typedef itk::Statistics::ListSample SampleType; typedef otb::SOMClassifier ClassifierType; typedef otb::Image OutputImageType; typedef itk::ImageRegionIterator OutputIteratorType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFilename); reader->Update(); std::cout << "Image read" << std::endl; SOMReaderType::Pointer somreader = SOMReaderType::New(); somreader->SetFileName(mapFilename); somreader->Update(); std::cout << "SOM map read" << std::endl; SampleType::Pointer listSample = SampleType::New(); listSample->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); itk::ImageRegionIterator it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { listSample->PushBack(it.Get()); ++it; } ClassifierType::Pointer classifier = ClassifierType::New(); classifier->SetSample(listSample.GetPointer()); classifier->SetMap(somreader->GetOutput()); classifier->Update(); OutputImageType::Pointer outputImage = OutputImageType::New(); outputImage->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); outputImage->SetOrigin(reader->GetOutput()->GetOrigin()); outputImage->SetSpacing(reader->GetOutput()->GetSpacing()); outputImage->Allocate(); ClassifierType::OutputType* membershipSample = classifier->GetOutput(); ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); OutputIteratorType outIt(outputImage, outputImage->GetLargestPossibleRegion()); outIt.GoToBegin(); while (m_iter != m_last && !outIt.IsAtEnd()) { outIt.Set(m_iter.GetClassLabel()); ++m_iter; ++outIt; } WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(outputImage); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMClassifierNew.cxx000066400000000000000000000025621301006202600245550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbSOMMap.h" #include "otbSOMClassifier.h" #include "itkListSample.h" int otbSOMClassifierNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef int LabelPixelType; const unsigned int Dimension = 2; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; typedef itk::Statistics::ListSample SampleType; typedef otb::SOMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); std::cout << classifier << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMImageClassificationFilter.cxx000066400000000000000000000043371301006202600270650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSOMImageClassificationFilter.h" #include "otbImage.h" #include "otbSOMMap.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbSOMImageClassificationFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * somfname = argv[2]; const char * outfname = argv[3]; const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::SOMMap SOMMapType; typedef otb::SOMImageClassificationFilter ClassificationFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader SOMReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); SOMReaderType::Pointer somreader = SOMReaderType::New(); somreader->SetFileName(somfname); somreader->Update(); filter->SetMap(somreader->GetOutput()); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMImageClassificationFilterNew.cxx000066400000000000000000000026371301006202600275400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSOMImageClassificationFilter.h" #include "otbImage.h" #include "otbSOMMap.h" int otbSOMImageClassificationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::SOMMap SOMMapType; typedef otb::SOMImageClassificationFilter ClassificationFilterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMMap.cxx000066400000000000000000000036321301006202600225330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "itkRGBPixel.h" int otbSOMMap(int itkNotUsed(argc), char* itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float InternalPixelType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; // Instantiation SOMMapType::Pointer somMap = SOMMapType::New(); // Allocation of the som map SOMMapType::RegionType region; SOMMapType::IndexType index; SOMMapType::SizeType size; index.Fill(0); size.Fill(64); region.SetIndex(index); region.SetSize(size); somMap->SetRegions(region); somMap->SetNumberOfComponentsPerPixel(3); somMap->Allocate(); // Filling with null pixels PixelType nullPixel; nullPixel.SetSize(3); nullPixel.Fill(0); somMap->FillBuffer(nullPixel); // Definition of a non-null pixel PixelType winner; winner.SetSize(3); winner.Fill(1); index.Fill(32); somMap->SetPixel(index, winner); // Test of the GetWinner method SOMMapType::IndexType winnerIndex = somMap->GetWinner(winner); if (winnerIndex != index) { std::cout << "Bad GetWinner function return." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMMapNew.cxx000066400000000000000000000022151301006202600232010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "itkRGBPixel.h" int otbSOMMapNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float ComponentType; typedef itk::RGBPixel PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; // Instantiation SOMMapType::Pointer somMap = SOMMapType::New(); std::cout << somMap << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMNew.cxx000066400000000000000000000025661301006202600225540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "otbSOM.h" #include "itkRGBPixel.h" #include "itkListSample.h" int otbSOMNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef float ComponentType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::SOMMap SOMMapType; // typedef itk::Statistics::ImageToListAdaptor AdaptorType; typedef itk::Statistics::ListSample ListSampleType; typedef otb::SOM SOMType; // Instantiation SOMType::Pointer som = SOMType::New(); std::cout << som << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMTestDriver.cxx000066400000000000000000000012441301006202600241060ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbSOMbasedImageFilterNew); REGISTER_TEST(otbSOM); REGISTER_TEST(otbSOMImageClassificationFilter); REGISTER_TEST(otbSOMActivationBuilder); REGISTER_TEST(otbSOMActivationBuilderNew); REGISTER_TEST(otbSOMClassifierNew); REGISTER_TEST(otbSOMImageClassificationFilterNew); REGISTER_TEST(otbSOMWithMissingValueTest); REGISTER_TEST(otbSOMNew); REGISTER_TEST(otbSOMMap); REGISTER_TEST(otbSOMWithMissingValueNew); REGISTER_TEST(otbSOMMapNew); REGISTER_TEST(otbPeriodicSOMTest); REGISTER_TEST(otbPeriodicSOMNew); REGISTER_TEST(otbSOMClassifier); REGISTER_TEST(otbSOMbasedImageFilterTest); } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMWithMissingValue.cxx000066400000000000000000000066771301006202600252740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSOMMap.h" #include "itkRGBPixel.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkListSample.h" #include "itkImageRegionIterator.h" #include "otbSOMWithMissingValue.h" #include "otbFlexibleDistanceWithMissingValue.h" int otbSOMWithMissingValueTest(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; char * inputFileName = argv[1]; char * outputFileName = argv[2]; unsigned int sizeX = atoi(argv[3]); unsigned int sizeY = atoi(argv[4]); unsigned int neighInitX = atoi(argv[5]); unsigned int neighInitY = atoi(argv[6]); unsigned int nbIterations = atoi(argv[7]); double betaInit = atof(argv[8]); double betaEnd = atof(argv[9]); double initValue = atof(argv[10]); typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PixelType VectorType; typedef otb::Statistics::FlexibleDistanceWithMissingValue DistanceType; typedef otb::SOMMap MapType; typedef itk::Statistics::ListSample SampleListType; typedef otb::Functor::CzihoSOMLearningBehaviorFunctor LearningBehaviorFunctorType; typedef otb::Functor::CzihoSOMNeighborhoodBehaviorFunctor NeighborhoodBehaviorFunctorType; typedef otb::SOMWithMissingValue SOMType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); reader->Update(); SampleListType::Pointer listSample = SampleListType::New(); listSample->SetMeasurementVectorSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); itk::ImageRegionIterator it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { listSample->PushBack(it.Get()); ++it; } std::cout << "LIST SAMPLE SIZE: " << listSample->GetMeasurementVectorSize() << std::endl; // Instantiation SOMType::Pointer som = SOMType::New(); som->SetListSample(listSample); SOMType::SizeType size; size[0] = sizeX; size[1] = sizeY; som->SetMapSize(size); SOMType::SizeType radius; radius[0] = neighInitX; radius[1] = neighInitY; som->SetNeighborhoodSizeInit(radius); som->SetNumberOfIterations(nbIterations); som->SetBetaInit(betaInit); som->SetBetaEnd(betaEnd); som->SetMaxWeight(initValue); som->SetRandomInit(false); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFileName); writer->SetInput(som->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMWithMissingValueNew.cxx000066400000000000000000000034061301006202600257310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkListSample.h" #include "otbSOMMap.h" //#include "otbPeriodicSOM.h" #include "otbSOMWithMissingValue.h" #include "otbFlexibleDistanceWithMissingValue.h" int otbSOMWithMissingValueNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PixelType VectorType; typedef otb::Statistics::FlexibleDistanceWithMissingValue DistanceType; typedef otb::SOMMap MapType; typedef itk::Statistics::ListSample SampleListType; typedef otb::Functor::CzihoSOMLearningBehaviorFunctor LearningBehaviorFunctorType; typedef otb::Functor::CzihoSOMNeighborhoodBehaviorFunctor NeighborhoodBehaviorFunctorType; typedef otb::SOMWithMissingValue SOMType; SOMType::Pointer som = SOMType::New(); std::cout << som << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMbasedImageFilter.cxx000066400000000000000000000044531301006202600252070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSOMbasedImageFilter.h" #include "otbImage.h" #include "otbSOMMap.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbSOMbasedImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * somfname = argv[2]; const char * outfname = argv[3]; const unsigned int Dimension = 2; typedef double ComponentType; typedef itk::VariableLengthVector PixelType; typedef itk::Statistics::EuclideanDistanceMetric DistanceType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::SOMMap SOMMapType; typedef otb::SOMbasedImageFilter SOMbasedImageFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader SOMReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object SOMbasedImageFilterType::Pointer filter = SOMbasedImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); SOMReaderType::Pointer somreader = SOMReaderType::New(); somreader->SetFileName(somfname); somreader->Update(); filter->SetMap(somreader->GetOutput()); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SOM/test/otbSOMbasedImageFilterNew.cxx000066400000000000000000000026271301006202600256620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "itkVariableLengthVector.h" #include "otbFlexibleDistanceWithMissingValue.h" #include "otbSOMbasedImageFilter.h" int otbSOMbasedImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PixelType VectorType; typedef otb::Statistics::FlexibleDistanceWithMissingValue DistanceType; typedef otb::SOMbasedImageFilter FilterType; FilterType::Pointer somFilter = FilterType::New(); std::cout << somFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/000077500000000000000000000000001301006202600207125ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/SVMLearning/CMakeLists.txt000066400000000000000000000001301301006202600234440ustar00rootroot00000000000000project(OTBSVMLearning) set(OTBSVMLearning_LIBRARIES OTBSVMLearning) otb_module_impl() OTB-release-5.8/Modules/Learning/SVMLearning/include/000077500000000000000000000000001301006202600223355ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/SVMLearning/include/otbExhaustiveExponentialOptimizer.h000066400000000000000000000076011301006202600314560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbExhaustiveExponentialOptimizer_h #define otbExhaustiveExponentialOptimizer_h #include "itkSingleValuedNonLinearOptimizer.h" namespace otb { /** \class ExhaustiveExponentialOptimizer * \brief This optimizer performs an exhaustive search on an exponential scale. * * This optimizer is equivalent to an exhaustive search in a discrete grid * defined over the parametric space. The grid is centered on the initial * position. The subdivisions of the grid along each one of the dimensions * of the parametric space is defined by a exponential progression with * scale factor m_ScaleFactor, with the exponant following an * arithmetic progression from 0 to m_NumberOfSteps * m_StepLength in * both positive and negative direction. * * This optimizer can be use to perform a preliminary coarse search on * the search space. * * \ingroup Numerics Optimizers * * \ingroup OTBSVMLearning */ class ITK_EXPORT ExhaustiveExponentialOptimizer : public itk::SingleValuedNonLinearOptimizer { public: /** Standard "Self" typedef. */ typedef ExhaustiveExponentialOptimizer Self; typedef itk::SingleValuedNonLinearOptimizer Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Array StepsType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ExhaustiveExponentialOptimizer, SingleValuedNonLinearOptimizer); void StartOptimization(void) ITK_OVERRIDE; void StartWalking(void); void ResumeWalking(void); void StopWalking(void); itkSetMacro(GeometricProgression, double); itkSetMacro(NumberOfSteps, StepsType); itkSetMacro(StepLength, double); itkGetConstReferenceMacro(GeometricProgression, double); itkGetConstReferenceMacro(NumberOfSteps, StepsType); itkGetConstReferenceMacro(StepLength, double); itkGetConstReferenceMacro(CurrentValue, MeasureType); itkGetConstReferenceMacro(MaximumMetricValue, MeasureType); itkGetConstReferenceMacro(MinimumMetricValue, MeasureType); itkGetConstReferenceMacro(MinimumMetricValuePosition, ParametersType); itkGetConstReferenceMacro(MaximumMetricValuePosition, ParametersType); itkGetConstReferenceMacro(CurrentIndex, ParametersType); itkGetConstReferenceMacro(MaximumNumberOfIterations, unsigned long); protected: ExhaustiveExponentialOptimizer(); ~ExhaustiveExponentialOptimizer() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Advance to the next grid position. */ void AdvanceOneStep(void); void IncrementIndex(ParametersType& param); protected: MeasureType m_CurrentValue; StepsType m_NumberOfSteps; double m_StepLength; unsigned long m_CurrentIteration; bool m_Stop; unsigned int m_CurrentParameter; double m_GeometricProgression; ParametersType m_CurrentIndex; unsigned long m_MaximumNumberOfIterations; MeasureType m_MaximumMetricValue; MeasureType m_MinimumMetricValue; ParametersType m_MinimumMetricValuePosition; ParametersType m_MaximumMetricValuePosition; private: ExhaustiveExponentialOptimizer(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbLabelMapSVMClassifier.h000066400000000000000000000066621301006202600272750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapSVMClassifier_h #define otbLabelMapSVMClassifier_h #include "itkInPlaceLabelMapFilter.h" #include "otbSVMModel.h" #include "itkListSample.h" #include "otbAttributesMapLabelObject.h" namespace otb { /** \class LabelMapSVMClassifier * \brief Classify each LabelObject of the input LabelMap in place * * \sa otb::AttributesMapLabelObject * \sa otb::SVMModel * \sa itk::InPlaceLabelMapFilter * * \ingroup OTBSVMLearning */ template class ITK_EXPORT LabelMapSVMClassifier : public itk::InPlaceLabelMapFilter { public: /** Standard class typedefs. */ typedef LabelMapSVMClassifier Self; typedef itk::InPlaceLabelMapFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputLabelMap LabelMapType; typedef typename LabelMapType::Pointer LabelMapPointer; typedef typename LabelMapType::ConstPointer LabelMaponstPointer; typedef typename LabelMapType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::AttributesValueType AttributesValueType; typedef typename LabelObjectType::ClassLabelType ClassLabelType; typedef std::vector MeasurementVectorType; typedef Functor::AttributesMapMeasurementFunctor MeasurementFunctorType; /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputLabelMap::ImageDimension); /** Type definitions for the SVM Model. */ typedef SVMModel SVMModelType; typedef typename SVMModelType::Pointer SVMModelPointer; /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(LabelMapSVMClassifier, itk::InPlaceLabelMapFilter); itkSetObjectMacro(Model, SVMModelType); void SetMeasurementFunctor(const MeasurementFunctorType& functor) { m_MeasurementFunctor = functor; } MeasurementFunctorType & GetMeasurementFunctor() { return m_MeasurementFunctor; } protected: LabelMapSVMClassifier(); ~LabelMapSVMClassifier() ITK_OVERRIDE {}; void ThreadedProcessLabelObject( LabelObjectType * labelObject ) ITK_OVERRIDE; void ReleaseInputs() ITK_OVERRIDE; private: LabelMapSVMClassifier(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** The SVM model used for classification */ SVMModelPointer m_Model; /** The functor used to build the measurement vector */ MeasurementFunctorType m_MeasurementFunctor; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapSVMClassifier.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbLabelMapSVMClassifier.txx000066400000000000000000000030171301006202600276600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapSVMClassifier_txx #define otbLabelMapSVMClassifier_txx #include "otbLabelMapSVMClassifier.h" namespace otb { template LabelMapSVMClassifier ::LabelMapSVMClassifier() { // Force to single-threaded (SVMModel is not thread-safe) // This way, we benefit of the LabelMapFilter design and only need // to implement ThreadedProcessLabelObject this->SetNumberOfThreads(1); } template void LabelMapSVMClassifier ::ReleaseInputs( ) { // by pass itk::InPlaceLabelMapFilter::ReleaseInputs() implementation, // which caused memory issue when ran inplace this->itk::LabelMapFilter::ReleaseInputs(); } template void LabelMapSVMClassifier ::ThreadedProcessLabelObject( LabelObjectType * labelObject ) { ClassLabelType classLabel = m_Model->EvaluateLabel(m_MeasurementFunctor(labelObject)); labelObject->SetClassLabel(classLabel); } }// end namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbObjectDetectionClassifier.h000066400000000000000000000347171301006202600303010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectDetectionClassifier_h #define otbObjectDetectionClassifier_h #include #include "itkImageRegion.h" #include "itkFixedArray.h" #include "itkVariableLengthVector.h" #include "itkListSample.h" #include "itkDataObjectDecorator.h" #include "itkSimpleDataObjectDecorator.h" #include "itkFunctionBase.h" #include "otbVectorData.h" #include "otbSVMModel.h" #include "otbPersistentImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" namespace otb { template class DefaultDescriptorType { public: typedef itk::VariableLengthVector Type; }; /** \class PersistentObjectDetectionClassifier * \brief [internal] Helper class for the implementation of ObjectDetectionClassifier * with streaming capabilities * * This class inherits PersistentImageFilter and provides the Reset/Synthesize functions, * plus the ThreadedGenerateData function implementing the image function evaluation * * * \ingroup OTBSVMLearning */ template class ITK_EXPORT PersistentObjectDetectionClassifier : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentObjectDetectionClassifier Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentObjectDetectionClassifier, PersistentImageFilter); /** Image related typedefs. */ typedef TInputImage InputImageType; typedef typename TInputImage::Pointer InputImagePointer; typedef typename TInputImage::RegionType RegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::PixelType PixelType; itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Image related typedefs. */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Input VectorData */ typedef TOutputVectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataObjectType; typedef typename VectorDataType::DataNodeType VectorDataNodeType; typedef typename VectorDataType::DataNodePointerType VectorDataNodePointerType; typedef typename VectorDataType::DataTreeType VectorDataTreeType; typedef typename VectorDataType::DataTreePointerType VectorDataTreePointerType; typedef typename VectorDataNodeType::PointType VectorDataPointType; typedef typename VectorDataNodeType::LineType VectorDataLineType; typedef typename VectorDataNodeType::PolygonType VectorDataPolygonType; typedef itk::PreOrderTreeIterator VectorDataTreeIteratorType; /** Function type for descriptors extraction */ typedef TFunctionType DescriptorsFunctionType; typedef typename DescriptorsFunctionType::Pointer DescriptorsFunctionPointerType; typedef typename DescriptorsFunctionType::InputType DescriptorsFunctionPointType; typedef typename DescriptorsFunctionType::OutputType DescriptorType; typedef typename DescriptorType::ValueType DescriptorPrecision; typedef itk::ContinuousIndex ContinuousIndexType; /** TLabel output */ typedef TLabel LabelType; typedef SVMModel SVMModelType; typedef typename SVMModelType::Pointer SVMModelPointerType; typedef typename SVMModelType::MeasurementType SVMModelMeasurementType; typedef itk::Statistics::ListSample ListSampleType; void AddInput(itk::DataObject * dataObject) ITK_OVERRIDE { this->Superclass::AddInput(dataObject); } /** SVM model used for classification */ void SetSVMModel(SVMModelType * model); VectorDataType* GetOutputVectorData(void); /** The function to evaluate */ itkSetObjectMacro(DescriptorsFunction, DescriptorsFunctionType); itkGetObjectMacro(DescriptorsFunction, DescriptorsFunctionType); itkGetConstObjectMacro(DescriptorsFunction, DescriptorsFunctionType); itkSetMacro( NeighborhoodRadius, unsigned int ); itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int ); itkGetConstMacro(ClassKey, std::string); itkSetMacro(ClassKey, std::string); itkGetMacro(NoClassLabel, LabelType); itkSetMacro(NoClassLabel, LabelType); /** Set/Get the Shifts for this sample list */ itkGetMacro(Shifts, DescriptorType); itkSetMacro(Shifts, DescriptorType); itkGetMacro(Scales, DescriptorType); itkSetMacro(Scales, DescriptorType); /** Set/Get the grid step for detection */ itkSetMacro(GridStep, unsigned int); itkGetMacro(GridStep, unsigned int); /** Make a DataObject of the correct type to be used as the specified * output. */ itk::DataObject::Pointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; void AllocateOutputs() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; protected: PersistentObjectDetectionClassifier(); ~PersistentObjectDetectionClassifier() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Multi-thread version GenerateData. */ void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PersistentObjectDetectionClassifier(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented template bool IsInsideWithNeighborhoodRadius(const RegionType& region, const ContinuousIndexType &index) const { typedef typename RegionType::IndexType IndexType; typedef typename IndexType::IndexValueType IndexValueType; for(unsigned int i=0; i(index[i]) < static_cast( region.GetIndex(i) ) + m_NeighborhoodRadius + 1 ) //Comment this instruction after itkv4 migration (correct //usage of centered-pixel coordinates) //if( index[i] < static_cast( region.GetIndex(i) ) + m_NeighborhoodRadius ) { return false; } // bound is the last valid pixel location const TCoordRepType bound = static_cast( region.GetIndex(i) + region.GetSize(i) - 0.5); //Comment this instruction after itkv4 migration (correct //usage of centered-pixel coordinates) //const TCoordRepType bound = static_cast( // region.GetIndex(i) + static_cast(region.GetSize(i)) - 1); if( index[i] > bound - m_NeighborhoodRadius - 1 ) { return false; } } return true; } typedef std::pair DetectedPoint; typedef std::vector PointArray; typedef std::vector PointArrayContainer; PointArrayContainer m_ThreadPointArray; DescriptorsFunctionPointerType m_DescriptorsFunction; unsigned int m_NeighborhoodRadius; std::string m_ClassKey; LabelType m_NoClassLabel; DescriptorType m_Shifts; DescriptorType m_Scales; DescriptorType m_InvertedScales; /** Step of the detection grid */ unsigned int m_GridStep; }; /** \class ObjectDetectionClassifier * \brief This class detects object in an image, given a SVM model and a local descriptors function * * Given an image (by SetInputImage()), a SVM model (by SetSVMModel) and an local descriptors ImageFunction * (set by SetDescriptorsFunction()), this class computes the local descriptors on a regular grid * over the image, and evaluates the class label of the corresponding sample. * It outputs a vector data with the points for which the descriptors are not classified as "negative", * the negative class label being given by SetNoClassLabel() * * This class is streaming capable and multithreaded * * \ingroup OTBSVMLearning */ template class ITK_EXPORT ObjectDetectionClassifier : public PersistentFilterStreamingDecorator< PersistentObjectDetectionClassifier< TInputImage, TOutputVectorData, TLabel, itk::FunctionBase< itk::Point, typename DefaultDescriptorType::Type> > > { public: /** Standard Self typedef */ typedef ObjectDetectionClassifier Self; typedef PersistentFilterStreamingDecorator < PersistentObjectDetectionClassifier , typename DefaultDescriptorType::Type> > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ObjectDetectionClassifier, PersistentFilterStreamingDecorator); typedef TInputImage InputImageType; typedef TOutputVectorData OutputVectorDataType; typedef TLabel LabelType; typedef TCoordRep CoordRepType; typedef TFunctionPrecision FunctionPrecision; /** The coordinates used when evaluating function */ typedef itk::Point PointType; /** The return value of the function */ typedef typename DefaultDescriptorType::Type DescriptorType; /** The function evaluated on the input image at locations specified by the vector data */ typedef itk::FunctionBase DescriptorsFunctionType; typedef typename DescriptorsFunctionType::Pointer DescriptorsFunctionPointerType; typedef typename Superclass::FilterType PersistentFilterType; typedef typename PersistentFilterType::SVMModelType SVMModelType; typedef typename PersistentFilterType::SVMModelPointerType SVMModelPointerType; /** Input image to extract feature */ void SetInputImage(InputImageType* input) { this->GetFilter()->SetInput(input); } /** Sample locations as a VectorData of points. The label is in the ClassKey feature */ OutputVectorDataType* GetOutputVectorData() { return this->GetFilter()->GetOutputVectorData(); } void AddInput(itk::DataObject * dataObject) ITK_OVERRIDE { this->GetFilter()->AddInput(dataObject); } /** The function to evaluate */ void SetDescriptorsFunction(DescriptorsFunctionType * input) { this->GetFilter()->SetDescriptorsFunction(input); } /** The function to evaluate */ DescriptorsFunctionType * GetDescriptorsFunction() { return this->GetFilter()->GetDescriptorsFunction(); } /** The function to evaluate */ void SetSVMModel(SVMModelType* model) { this->GetFilter()->SetSVMModel(model); } /** The function to evaluate */ SVMModelType* GetSVMModel() { return this->GetFilter()->GetSVMModel(); } otbSetObjectMemberMacro(Filter, NeighborhoodRadius, unsigned int); otbGetObjectMemberMacro(Filter, NeighborhoodRadius, unsigned int); /** Set/Get the name of the field containing the class information */ otbGetObjectMemberMacro(Filter, ClassKey, std::string); otbSetObjectMemberMacro(Filter, ClassKey, std::string); /** Set/Get the label of the negative samples */ otbGetObjectMemberMacro(Filter, NoClassLabel, LabelType); otbSetObjectMemberMacro(Filter, NoClassLabel, LabelType); /** Set/Get the Shifts for this sample list */ otbGetObjectMemberMacro(Filter, Shifts, DescriptorType); otbSetObjectMemberMacro(Filter, Shifts, DescriptorType); /** Set/Get the Scales for this sample list */ otbGetObjectMemberMacro(Filter, Scales, DescriptorType); otbSetObjectMemberMacro(Filter, Scales, DescriptorType); /** Set/Get the grid step for detection */ otbSetObjectMemberMacro(Filter, GridStep, unsigned int); otbGetObjectMemberMacro(Filter, GridStep, unsigned int); protected: /** Constructor */ ObjectDetectionClassifier(); /** Destructor */ ~ObjectDetectionClassifier() ITK_OVERRIDE; private: ObjectDetectionClassifier(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbObjectDetectionClassifier.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbObjectDetectionClassifier.txx000066400000000000000000000244211301006202600306640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbObjectDetectionClassifier_txx #define otbObjectDetectionClassifier_txx #include "otbObjectDetectionClassifier.h" #include "itkContinuousIndex.h" namespace otb { template PersistentObjectDetectionClassifier ::PersistentObjectDetectionClassifier() : m_NeighborhoodRadius(0), m_ClassKey("Class"), m_NoClassLabel(0), m_GridStep(10) { // Need 2 inputs : a vector image, and a SVMModel this->SetNumberOfRequiredInputs(2); // Have 2 outputs : the image created by Superclass, a vector data with points this->SetNumberOfRequiredOutputs(3); this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(2, this->MakeOutput(2).GetPointer()); } template PersistentObjectDetectionClassifier ::~PersistentObjectDetectionClassifier() { } template void PersistentObjectDetectionClassifier ::AllocateOutputs() { // This is commented to prevent the streaming of the whole image for the first stream strip // It shall not cause any problem because the output image of this filter is not intended to be used. //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() ); //this->GraftOutput( image ); // Nothing that needs to be allocated for the remaining outputs } template void PersistentObjectDetectionClassifier ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetInput()) { this->GetOutput()->CopyInformation(this->GetInput()); this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion()); if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0) { this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion()); } } } template void PersistentObjectDetectionClassifier ::SetSVMModel(SVMModelType* model) { this->SetNthInput(1, model); } template typename PersistentObjectDetectionClassifier::VectorDataType* PersistentObjectDetectionClassifier ::GetOutputVectorData() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template itk::DataObject::Pointer PersistentObjectDetectionClassifier ::MakeOutput(DataObjectPointerArraySizeType idx) { itk::DataObject::Pointer output; switch (idx) { case 0: output = static_cast(InputImageType::New().GetPointer()); break; case 1: { output = static_cast(VectorDataType::New().GetPointer()); break; } default: output = static_cast(InputImageType::New().GetPointer()); break; } return output; } template void PersistentObjectDetectionClassifier ::Reset() { m_ThreadPointArray = PointArrayContainer(this->GetNumberOfThreads()); } template void PersistentObjectDetectionClassifier ::Synthetize() { // merge all points in a single vector data //std::copy(m_ThreadPointArray[0].begin(), m_ThreadPointArray[0].end(), //std::ostream_iterator(std::cout, "\n") ); VectorDataType* vdata = this->GetOutputVectorData(); // Retrieving root node VectorDataNodePointerType root = vdata->GetDataTree()->GetRoot()->Get(); // Create the document node VectorDataNodePointerType document = VectorDataNodeType::New(); document->SetNodeType(otb::DOCUMENT); VectorDataNodePointerType folder = VectorDataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree vdata->GetDataTree()->Add(document, root); vdata->GetDataTree()->Add(folder, document); for (itk::ThreadIdType threadId = 0; threadId < m_ThreadPointArray.size(); ++threadId) { PointArray& pointArray = m_ThreadPointArray[threadId]; typename PointArray::const_iterator it = pointArray.begin(); typename PointArray::const_iterator end = pointArray.end(); for (; it != end; ++it) { VectorDataNodePointerType currentGeometry = VectorDataNodeType::New(); currentGeometry->SetNodeId("FEATURE_POINT"); currentGeometry->SetNodeType(otb::FEATURE_POINT); VectorDataPointType p; p[0] = it->first[0]; p[1] = it->first[1]; currentGeometry->SetPoint(p); currentGeometry->SetFieldAsInt(m_ClassKey, it->second); vdata->GetDataTree()->Add(currentGeometry, folder); } } } template void PersistentObjectDetectionClassifier ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void PersistentObjectDetectionClassifier ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast< TInputImage * >( this->GetInput() ); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); if ( !inputPtr || !outputPtr ) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius( m_NeighborhoodRadius + 1 ); // crop the input requested region at the input's largest possible region if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) ) { inputPtr->SetRequestedRegion( inputRequestedRegion ); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion( inputRequestedRegion ); } } template void PersistentObjectDetectionClassifier ::BeforeThreadedGenerateData() { // Compute the 1/(sigma) vector m_InvertedScales = m_Scales; for(unsigned int idx = 0; idx < m_Scales.Size(); ++idx) { if(m_Scales[idx]-1e-10 < 0.) m_InvertedScales[idx] = 0.; else m_InvertedScales[idx] = 1 / m_Scales[idx]; } } template void PersistentObjectDetectionClassifier ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { InputImageType* input = static_cast(this->itk::ProcessObject::GetInput(0)); SVMModelType* model = static_cast(this->itk::ProcessObject::GetInput(1)); typedef typename RegionType::IndexType IndexType; IndexType begin = outputRegionForThread.GetIndex(); IndexType end = begin; end[0] += outputRegionForThread.GetSize(0); end[1] += outputRegionForThread.GetSize(1); IndexType current = begin; for (; current[1] != end[1]; current[1]++) { if (current[1] % m_GridStep == 0) { for(current[0] = begin[0]; current[0] != end[0]; current[0]++) { if (current[0] % m_GridStep == 0) { DescriptorsFunctionPointType point; input->TransformIndexToPhysicalPoint(current, point); DescriptorType descriptor = m_DescriptorsFunction->Evaluate(point); SVMModelMeasurementType modelMeasurement(descriptor.GetSize()); for (unsigned int i = 0; i < descriptor.GetSize(); ++i) { modelMeasurement[i] = (descriptor[i] - m_Shifts[i]) * m_InvertedScales[i]; } LabelType label = model->EvaluateLabel(modelMeasurement); if (label != m_NoClassLabel) { m_ThreadPointArray[threadId].push_back(std::make_pair(point, label)); } } } } } } template ObjectDetectionClassifier ::ObjectDetectionClassifier() { } template ObjectDetectionClassifier ::~ObjectDetectionClassifier() { } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMClassifier.h000066400000000000000000000102611301006202600256650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMClassifier_h #define otbSVMClassifier_h #include "vcl_deprecated_header.h" #include "itkSampleClassifierFilter.h" #include "otbSVMModel.h" #include "itkVectorImage.h" #include "itkListSample.h" namespace otb { /** \class SVMClassifier * \brief SVM-based classifier * * The first template argument is the type of the target sample data * that this classifier will assign a class label for each measurement * vector. The second one is the pixel type of the labels to be * produced by the classifier. * * Before you call the GenerateData method to start the classification * process, you should plug in all necessary parts ( a SVM model and a * target sample data). * * The classification result is stored in a vector of Subsample object. * Each class has its own class sample (Subsample object) that has * InstanceIdentifiers for all measurement vectors belong to the class. * The InstanceIdentifiers come from the target sample data. Therefore, * the Subsample objects act as separate class masks. * * \deprecated * * \sa MachineLearningModel * \sa LibSVMMachineLearningModel * \sa ImageClassificationFilter * * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMClassifier : public itk::Statistics::SampleClassifierFilter { public: /** Standard class typedef*/ typedef SVMClassifier Self; typedef itk::Statistics::SampleClassifierFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkTypeMacro(SVMClassifier, itk::Statistics::SampleClassifier); itkNewMacro(Self); /** Output type for GetClassSample method */ typedef itk::Statistics::MembershipSample OutputType; typedef itk::VariableLengthVector HyperplanesDistancesType; typedef itk::Statistics::ListSample HyperplanesDistancesListSampleType; /** typedefs from TSample object */ typedef typename TSample::MeasurementType MeasurementType; typedef typename TSample::MeasurementVectorType MeasurementVectorType; /** typedefs from Superclass */ typedef typename Superclass::MembershipFunctionVectorObjectPointer MembershipFunctionPointerVector; //FIXME adopt new naming convention /** typedef for label type */ typedef TLabel ClassLabelType; /** Returns the classification result */ OutputType* GetOutput(); void SetOutput(OutputType* output); using Superclass::SetOutput; /** Returns the hyperplanes distances */ HyperplanesDistancesListSampleType * GetHyperplanesDistancesOutput(); /** Type definitions for the SVM Model. */ typedef SVMModel SVMModelType; typedef typename SVMModelType::Pointer SVMModelPointer; /** Set the model */ itkSetObjectMacro(Model, SVMModelType); /** Get the number of classes. */ itkGetObjectMacro(Model, SVMModelType); void Update() ITK_OVERRIDE; protected: SVMClassifier(); ~SVMClassifier() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Starts the classification process */ void GenerateData() ITK_OVERRIDE; virtual void DoClassification(); private: /** Output pointer (MembershipSample) */ typename OutputType::Pointer m_Output; /** Hyperplanes distances output */ typename HyperplanesDistancesListSampleType::Pointer m_HyperplanesDistancesOutput; SVMModelPointer m_Model; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMClassifier.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMClassifier.txx000066400000000000000000000100631301006202600262610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMClassifier_txx #define otbSVMClassifier_txx #include "otbSVMClassifier.h" #include "otbMacro.h" namespace otb { template SVMClassifier ::SVMClassifier() { m_Output = OutputType::New(); m_HyperplanesDistancesOutput = HyperplanesDistancesListSampleType::New(); } template void SVMClassifier ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void SVMClassifier ::Update() { this->GenerateData(); } template void SVMClassifier ::GenerateData() { if (!m_Model) { itkExceptionMacro("No model, can not do classification."); } if (m_Model->GetNumberOfSupportVectors() == 0) { itkExceptionMacro(<< "SVM model does not contain any support vector, can not perform classification."); } m_Output->SetSample(this->GetInput()); // m_Output->Resize(this->GetSample()->Size()); //FIXME check if this is necessary (work at the decision rule //Evaluate() level?) unsigned int numberOfClasses = this->GetNumberOfClasses(); m_Output->SetNumberOfClasses(numberOfClasses); this->DoClassification(); } template typename SVMClassifier::OutputType* SVMClassifier ::GetOutput() { return m_Output; } template void SVMClassifier ::SetOutput(OutputType * output) { m_Output = output; } template typename SVMClassifier::HyperplanesDistancesListSampleType * SVMClassifier ::GetHyperplanesDistancesOutput() { return m_HyperplanesDistancesOutput; } template void SVMClassifier ::DoClassification() { itk::TimeProbe probe; typename TSample::ConstIterator iter = this->GetInput()->Begin(); typename TSample::ConstIterator end = this->GetInput()->End(); typename OutputType::ConstIterator iterO = m_Output->Begin(); typename OutputType::ConstIterator endO = m_Output->End(); typename TSample::MeasurementVectorType measurements; // sample Measurement vector size int numberOfComponentsPerSample = iter.GetMeasurementVector().Size(); // The size of the hyperplane distance vector is the number of hyperplanes m_HyperplanesDistancesOutput->SetMeasurementVectorSize(m_Model->GetNumberOfHyperplane()); otbMsgDevMacro(<< "Starting iterations "); while (iter != end && iterO != endO) { int i = 0; typename SVMModelType::MeasurementType modelMeasurement; measurements = iter.GetMeasurementVector(); // otbMsgDevMacro( << "Loop on components " << svm_type ); for (i = 0; i < numberOfComponentsPerSample; ++i) { modelMeasurement.push_back(measurements[i]); } ClassLabelType classLabel = m_Model->EvaluateLabel(modelMeasurement); typename SVMModelType::DistancesVectorType hdistances = m_Model->EvaluateHyperplanesDistances(modelMeasurement); HyperplanesDistancesType distances = hdistances; m_HyperplanesDistancesOutput->PushBack(distances); // Julien: Event if we support larger type for class labels, // the AddInstance method wait for an unsigned int, so we cast it here. m_Output->AddInstance(static_cast(classLabel), iterO.GetInstanceIdentifier()); ++iter; ++iterO; } } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMCrossValidationCostFunction.h000066400000000000000000000100431301006202600312420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMCrossValidationCostFunction_h #define otbSVMCrossValidationCostFunction_h #include "otbSVMModel.h" #include "itkSingleValuedCostFunction.h" namespace otb { /** \class SVMCrossValidationCostFunction * \brief This function returns the cross validation accuracy of a SVM model. * * It allows performing parameters selection to maximize the * accuracy using ITK optimizers. * * Given an input SVM model, the number of parameters depends on the * type of kernel: * - Linear kernel : C * - Polynomial kernel : C, gamma, coef0 * - RBF kernel : C, Gamma * - Gaussian kernel : C, Gamma, coef0 * - Other kernels : C * * Please note that this function is only defined on \f$ R_{+}^{*} \f$. * * The GetDerivative() uses the GetValue() function to * compute the partial derivatives. as such, it can be quite intensive. * * \ingroup ClassificationFilters * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMCrossValidationCostFunction : public itk::SingleValuedCostFunction { public: /** Standard class typedefs. */ typedef SVMCrossValidationCostFunction Self; typedef itk::SingleValuedCostFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Type definitions for the SVM Model. */ typedef TModel SVMModelType; typedef typename SVMModelType::Pointer SVMModelPointer; /** Superclass typedefs */ typedef typename Superclass::MeasureType MeasurementType; typedef typename Superclass::ParametersType ParametersType; typedef typename Superclass::ParametersValueType ParametersValueType; typedef typename Superclass::DerivativeType DerivativeType; /** Set the model */ itkSetObjectMacro(Model, SVMModelType); itkGetObjectMacro(Model, SVMModelType); /** Set/Get the number of cross validation folders */ itkSetMacro(NumberOfCrossValidationFolders, unsigned int); itkGetMacro(NumberOfCrossValidationFolders, unsigned int); /** Set/Get the derivative step */ itkSetMacro(DerivativeStep, ParametersValueType); itkGetMacro(DerivativeStep, ParametersValueType); /** \return The accuracy value corresponding the parameters */ MeasureType GetValue(const ParametersType& parameters) const ITK_OVERRIDE; /** \return The accuracy derivative corresponding to the parameters */ void GetDerivative(const ParametersType& parameters, DerivativeType& derivative) const ITK_OVERRIDE; /** \return the number of parameters to optimize */ unsigned int GetNumberOfParameters(void) const ITK_OVERRIDE; protected: /// Constructor SVMCrossValidationCostFunction(); /// Destructor ~SVMCrossValidationCostFunction() ITK_OVERRIDE; /** Update svm parameters struct according to the input parameters */ virtual void UpdateParameters(struct svm_parameter& svm_parameters, const ParametersType& parameters) const; private: SVMCrossValidationCostFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /**Pointer to the SVM model to optimize */ SVMModelPointer m_Model; /** Number of cross validation folders */ unsigned int m_NumberOfCrossValidationFolders; /** Step used to compute the derivatives */ ParametersValueType m_DerivativeStep; }; // class SVMCrossValidationCostFunction } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMCrossValidationCostFunction.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMCrossValidationCostFunction.txx000066400000000000000000000074701301006202600316500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMCrossValidationCostFunction_txx #define otbSVMCrossValidationCostFunction_txx #include "otbSVMCrossValidationCostFunction.h" namespace otb { template SVMCrossValidationCostFunction ::SVMCrossValidationCostFunction() : m_Model(), m_NumberOfCrossValidationFolders(10), m_DerivativeStep(0.001) {} template SVMCrossValidationCostFunction ::~SVMCrossValidationCostFunction() {} template typename SVMCrossValidationCostFunction ::MeasureType SVMCrossValidationCostFunction ::GetValue(const ParametersType& parameters) const { // Check the input model if (!m_Model) { itkExceptionMacro(<< "Model is null, can not evaluate accuracy."); } // Check for a positive and non-null C if (parameters[0] <= 0) { return 0; } // Updates vm_parameters according to current parameters this->UpdateParameters(m_Model->GetParameters(), parameters); return m_Model->CrossValidation(m_NumberOfCrossValidationFolders); } template void SVMCrossValidationCostFunction ::GetDerivative(const ParametersType& parameters, DerivativeType& derivative) const { // Set derivative size derivative.SetSize(parameters.Size()); derivative.Fill(itk::NumericTraits::Zero); for (unsigned int i = 0; i < parameters.Size(); ++i) { MeasureType y1, y2; ParametersType x1, x2; x1 = parameters; x1[i] -= m_DerivativeStep; y1 = this->GetValue(x1); x2 = parameters; x2[i] += m_DerivativeStep; y2 = this->GetValue(x2); derivative[i] = (y2 - y1) / (2 * m_DerivativeStep); otbMsgDevMacro( << "x1= " << x1 << " x2= " << x2 << ", y1= " << y1 << ", y2= " << y2 ); } otbMsgDevMacro( "Position: " << parameters << ", Value: " << this->GetValue(parameters) << ", Derivatives: " << derivative ); } template unsigned int SVMCrossValidationCostFunction ::GetNumberOfParameters(void) const { if (!m_Model) { itkExceptionMacro(<< "Model is null, can not evaluate number of parameters."); } switch (m_Model->GetKernelType()) { case LINEAR: // C return 1; case POLY: // C, gamma and coef0 return 3; case RBF: // C and gamma return 2; case SIGMOID: // C, gamma and coef0 return 3; default: // C return 1; } } template void SVMCrossValidationCostFunction ::UpdateParameters(struct svm_parameter& svm_parameters, const ParametersType& parameters) const { switch (m_Model->GetKernelType()) { case LINEAR: // C svm_parameters.C = parameters[0]; break; case POLY: // C, gamma and coef0 svm_parameters.C = parameters[0]; svm_parameters.gamma = parameters[1]; svm_parameters.coef0 = parameters[2]; break; case RBF: // C and gamma svm_parameters.C = parameters[0]; svm_parameters.gamma = parameters[1]; break; case SIGMOID: // C, gamma and coef0 svm_parameters.C = parameters[0]; svm_parameters.gamma = parameters[1]; svm_parameters.coef0 = parameters[2]; break; default: svm_parameters.C = parameters[0]; break; } } } // namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMImageClassificationFilter.h000066400000000000000000000102541301006202600306470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMImageClassificationFilter_h #define otbSVMImageClassificationFilter_h #include "vcl_deprecated_header.h" #include "itkInPlaceImageFilter.h" #include "otbSVMModel.h" namespace otb { /** \class SVMImageClassificationFilter * \brief This filter performs the classification of a VectorImage using a SVM Model. * * This filter is streamed and threaded, allowing to classify huge images * while fully using several core. * * \deprecated * * \sa MachineLearningModel * \sa LibSVMMachineLearningModel * \sa ImageClassificationFilter * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMImageClassificationFilter : public itk::InPlaceImageFilter { public: /** Standard typedefs */ typedef SVMImageClassificationFilter Self; typedef itk::InPlaceImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SVMImageClassificationFilter, InPlaceImageFilter); /** The max dimension of the sample to classify. * This filter internally uses itk::FixedArray as input for the classifier, * so the max sample size has to be fixed at compilation time. */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::InternalPixelType ValueType; typedef TMaskImage MaskImageType; typedef typename MaskImageType::ConstPointer MaskImageConstPointerType; typedef typename MaskImageType::Pointer MaskImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType LabelType; typedef SVMModel ModelType; typedef typename ModelType::Pointer ModelPointerType; /** Set/Get the svm model */ itkSetObjectMacro(Model, ModelType); itkGetObjectMacro(Model, ModelType); /** Set/Get the default label */ itkSetMacro(DefaultLabel, LabelType); itkGetMacro(DefaultLabel, LabelType); /** * If set, only pixels within the mask will be classified. * \param mask The input mask. */ void SetInputMask(const MaskImageType * mask); /** * Get the input mask. * \return The mask. */ const MaskImageType * GetInputMask(void); protected: /** Constructor */ SVMImageClassificationFilter(); /** Destructor */ ~SVMImageClassificationFilter() ITK_OVERRIDE {} /** Threaded generate data */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SVMImageClassificationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The SVM model used for classification */ ModelPointerType m_Model; /** Default label for invalid pixels (when using a mask) */ LabelType m_DefaultLabel; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMImageClassificationFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMImageClassificationFilter.txx000066400000000000000000000101751301006202600312450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMImageClassificationFilter_txx #define otbSVMImageClassificationFilter_txx #include "otbSVMImageClassificationFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template SVMImageClassificationFilter ::SVMImageClassificationFilter() { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(1); m_DefaultLabel = itk::NumericTraits::ZeroValue(); } template void SVMImageClassificationFilter ::SetInputMask(const MaskImageType * mask) { this->itk::ProcessObject::SetNthInput(1, const_cast(mask)); } template const typename SVMImageClassificationFilter ::MaskImageType * SVMImageClassificationFilter ::GetInputMask() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void SVMImageClassificationFilter ::BeforeThreadedGenerateData() { if (!m_Model) { itkGenericExceptionMacro(<< "No model for classification"); } } template void SVMImageClassificationFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Get the input pointers InputImageConstPointerType inputPtr = this->GetInput(); MaskImageConstPointerType inputMaskPtr = this->GetInputMask(); OutputImagePointerType outputPtr = this->GetOutput(); // Progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define iterators typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator MaskIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; InputIteratorType inIt(inputPtr, outputRegionForThread); OutputIteratorType outIt(outputPtr, outputRegionForThread); // Eventually iterate on masks MaskIteratorType maskIt; if (inputMaskPtr) { maskIt = MaskIteratorType(inputMaskPtr, outputRegionForThread); maskIt.GoToBegin(); } bool validPoint = true; // Walk the part of the image for (inIt.GoToBegin(), outIt.GoToBegin(); !inIt.IsAtEnd() && !outIt.IsAtEnd(); ++inIt, ++outIt) { // Check pixel validity if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } // If point is valid if (validPoint) { // Classifify typename ModelType::MeasurementType measure; for (unsigned int i = 0; i < inIt.Get().Size(); ++i) { measure.push_back(inIt.Get()[i]); } outIt.Set(m_Model->EvaluateLabel(measure)); } else { // else, set default value outIt.Set(m_DefaultLabel); } progress.CompletedPixel(); } } /** * PrintSelf Method */ template void SVMImageClassificationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMImageClassificationWithRuleFilter.h000066400000000000000000000110431301006202600323300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMImageClassificationWithRuleFilter_h #define otbSVMImageClassificationWithRuleFilter_h #include "otbSVMImageClassificationFilter.h" #include "otbVectorImage.h" namespace otb { /** \class SVMImageClassificationWithRuleFilter * \brief SVM Image Classification that yield distance to hyperplanes * * This class comes from SVMImageClassificationFilter that performs * SVM classification on image. Here, the class add in ThreadedGenerateData an other output * (a VectorImage) that gives the value for \f$ f(x) \f$ without the majority * vote decision on class belonging. * * \sa SVMImageClassificationFilter * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMImageClassificationWithRuleFilter : public SVMImageClassificationFilter { public: /** Standard typedefs */ typedef SVMImageClassificationWithRuleFilter Self; typedef SVMImageClassificationFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SVMImageClassificationWithRuleFilter, SVMImageClassificationFilter); typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImageConstPointerType InputImageConstPointerType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::MaskImageType MaskImageType; typedef typename Superclass::MaskImageConstPointerType MaskImageConstPointerType; typedef typename Superclass::MaskImagePointerType MaskImagePointerType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; typedef typename Superclass::OutputImageRegionType OutputImageRegionType; typedef typename Superclass::LabelType LabelType; typedef typename Superclass::ModelType ModelType; typedef typename Superclass::ModelPointerType ModelPointerType; typedef typename ModelType::NodeCacheType NodeCacheType; typedef typename ModelType::MeasurementType MeasurementType; typedef typename ModelType::DistancesVectorType DistanceValueType; typedef typename DistanceValueType::ValueType RuleValueType; typedef VectorImage OutputRuleImageType; typedef typename OutputRuleImageType::Pointer OutputRuleImagePointerType; typedef typename OutputRuleImageType::RegionType OutputRuleImageRegionType; typedef typename OutputRuleImageType::PixelType RuleType; /** Access to the Rule image */ itkGetObjectMacro(OutputRule, OutputRuleImageType); protected: /** Constructor */ SVMImageClassificationWithRuleFilter(); /** Destructor */ ~SVMImageClassificationWithRuleFilter() ITK_OVERRIDE {} /** GenerateOutputInformation * Set the number of bands of the output rule image. * Copy information from the input image if existing. **/ void GenerateOutputInformation() ITK_OVERRIDE; /** AllocateOutputs * Output allocation redefinition for VectorImage (used in TOutputRuleImage) **/ void AllocateOutputs() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: SVMImageClassificationWithRuleFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OutputRuleImagePointerType m_OutputRule; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMImageClassificationWithRuleFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMImageClassificationWithRuleFilter.txx000066400000000000000000000114641301006202600327330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Copyright (c) Institut Telecom; Telecom bretagne. All rights reserved. See IMTCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMImageClassificationWithRuleFilter_txx #define otbSVMImageClassificationWithRuleFilter_txx #include "otbSVMImageClassificationWithRuleFilter.h" #include "itkNumericTraits.h" namespace otb { template SVMImageClassificationWithRuleFilter ::SVMImageClassificationWithRuleFilter() { m_OutputRule = OutputRuleImageType::New(); } template void SVMImageClassificationWithRuleFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); if (this->GetModel() == ITK_NULLPTR) { itkGenericExceptionMacro(<< "No model for classification"); } // add output information on the rule image this->GetOutputRule()->SetNumberOfComponentsPerPixel( this->GetModel()->GetNumberOfClasses() * (this->GetModel()->GetNumberOfClasses() - 1) / 2); this->GetOutputRule()->CopyInformation(this->GetInput()); this->GetOutputRule()->SetRegions(this->GetInput()->GetLargestPossibleRegion()); } template void SVMImageClassificationWithRuleFilter ::AllocateOutputs() { Superclass::AllocateOutputs(); if (this->GetModel() == ITK_NULLPTR) { itkGenericExceptionMacro(<< "No model for classification"); } // add allocation for the rule image OutputRuleImageType * output = this->GetOutputRule(); output->SetNumberOfComponentsPerPixel( this->GetModel()->GetNumberOfClasses() * (this->GetModel()->GetNumberOfClasses() - 1) / 2); output->Allocate(); } template void SVMImageClassificationWithRuleFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Get the input pointers InputImageConstPointerType inputPtr = this->GetInput(); MaskImageConstPointerType inputMaskPtr = this->GetInputMask(); OutputImagePointerType outputPtr = this->GetOutput(); OutputRuleImagePointerType outputRulePtr = this->GetOutputRule(); // Progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define iterators typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator MaskIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionIterator OutputRuleIteratorType; InputIteratorType inIt(inputPtr, outputRegionForThread); OutputIteratorType outIt(outputPtr, outputRegionForThread); OutputRuleIteratorType outRuleIt(outputRulePtr, outputRegionForThread); // Eventually iterate on masks MaskIteratorType maskIt; if (inputMaskPtr) { maskIt = MaskIteratorType(inputMaskPtr, outputRegionForThread); maskIt.GoToBegin(); } bool validPoint = true; typename ModelType::DistancesVectorType defaultDistancesVector (outputRulePtr->GetNumberOfComponentsPerPixel()); defaultDistancesVector.Fill(itk::NumericTraits::ZeroValue()); // Walk the part of the images for (inIt.GoToBegin(), outIt.GoToBegin(), outRuleIt.GoToBegin(); !inIt.IsAtEnd() && !outIt.IsAtEnd() && !outRuleIt.IsAtEnd(); ++inIt, ++outIt, ++outRuleIt) { // Check pixel validity if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } // If point is valid if (validPoint) { // Classifify MeasurementType measure; for (unsigned int i = 0; i < inIt.Get().Size(); ++i) { measure.push_back(inIt.Get()[i]); } outIt.Set(this->GetModel()->EvaluateLabel(measure)); // And get rules outRuleIt.Set(this->GetModel()->EvaluateHyperplanesDistances(measure)); } else { // else, set default value outIt.Set(this->GetDefaultLabel()); outRuleIt.Set(defaultDistancesVector); } progress.CompletedPixel(); } } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMImageModelEstimator.h000066400000000000000000000100201301006202600274650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMImageModelEstimator_h #define otbSVMImageModelEstimator_h #include "vcl_deprecated_header.h" #include "itkImageModelEstimatorBase.h" #include "itkImageRegionIterator.h" #include "otbSVMModelEstimator.h" namespace otb { /** \class SVMImageModelEstimator * \brief Class for SVM model estimation from images used for classification. * * * The basic functionality of the SVMImageModelEstimator is to * generate the models used in SVM classification. It * requires input images and a training image to be provided by the * user. This object supports data handling of multiband images. The * object accepts the input image as a VectorImage only, where each * pixel is a vector and each element of the vector corresponds to an * entry from 1 particular band of a multiband dataset. A single band * image is treated as a vector image with a single element for every * vector. The classified image is treated as a single band scalar * image. * * \deprecated * * \sa MachineLearningModel * \sa LibSVMMachineLearningModel * \sa ImageClassificationFilter * * \ingroup ClassificationFilters * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMImageModelEstimator : public SVMModelEstimator { public: /** Standard class typedefs. */ typedef SVMImageModelEstimator Self; typedef SVMModelEstimator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SVMImageModelEstimator, otb::SVMModelEstimator); /** Type definition for the input image. */ typedef typename TInputImage::Pointer InputImagePointer; /** Type definitions for the training image. */ typedef typename TTrainingImage::Pointer TrainingImagePointer; /** Type definition for the vector associated with * input image pixel type. */ typedef typename TInputImage::PixelType InputImagePixelType; /** Type definitions for the vector holding * training image pixel type. */ typedef typename TTrainingImage::PixelType TrainingImagePixelType; /** Type definitions for the iterators for the input and training images. */ typedef itk::ImageRegionIterator InputImageIterator; typedef itk::ImageRegionIterator TrainingImageIterator; /** Set the input image */ void SetInputImage(const TInputImage * inputImage); /** Set the training image */ void SetTrainingImage(const TTrainingImage * trainingImage); /** Get the input image */ const TInputImage * GetInputImage(); /** Get the training image */ const TTrainingImage * GetTrainingImage(); protected: /** Constructor */ SVMImageModelEstimator(); /** Destructor */ ~SVMImageModelEstimator() ITK_OVERRIDE; /** PrintSelf */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Implement the prepare data step from SVMModelEstimator */ void PrepareData() ITK_OVERRIDE; private: SVMImageModelEstimator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // class SVMImageModelEstimator } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMImageModelEstimator.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMImageModelEstimator.txx000066400000000000000000000104561301006202600300760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMImageModelEstimator_txx #define otbSVMImageModelEstimator_txx #include "otbSVMImageModelEstimator.h" #include "otbMacro.h" #include "itkCommand.h" #include "itkImageRegionConstIterator.h" namespace otb { template SVMImageModelEstimator ::SVMImageModelEstimator() { this->SetNumberOfRequiredInputs(2); } template SVMImageModelEstimator ::~SVMImageModelEstimator(void) {} /* * PrintSelf */ template void SVMImageModelEstimator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void SVMImageModelEstimator ::SetInputImage(const TInputImage * inputImage) { this->itk::ProcessObject::SetNthInput(0, const_cast(inputImage)); } template void SVMImageModelEstimator ::SetTrainingImage(const TTrainingImage * trainingImage) { this->itk::ProcessObject::SetNthInput(1, const_cast(trainingImage)); } template const TInputImage * SVMImageModelEstimator ::GetInputImage() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TTrainingImage * SVMImageModelEstimator ::GetTrainingImage() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } /** * Generate data (start the model building process) */ template void SVMImageModelEstimator ::PrepareData() { // Get input and output pointers const TInputImage * inputImage = this->GetInputImage(); const TTrainingImage * trainingImage = this->GetTrainingImage(); typename Superclass::ModelType * model = this->GetModel(); // Do some error checking typename TInputImage::SizeType inputImageSize = inputImage->GetBufferedRegion().GetSize(); typename TTrainingImage::SizeType trainingImageSize = trainingImage->GetBufferedRegion().GetSize(); // Check if size of the two inputs are same for (unsigned int i = 0; i < TInputImage::ImageDimension; ++i) { if (inputImageSize[i] != trainingImageSize[i]) throw itk::ExceptionObject( __FILE__, __LINE__, "Input image size is not the same as the training image size.", ITK_LOCATION); } // Declaration of the iterators on the input and training images typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator TrainingIteratorType; InputIteratorType inIt(inputImage, inputImage->GetBufferedRegion()); TrainingIteratorType trIt(trainingImage, trainingImage->GetBufferedRegion()); inIt.GoToBegin(); trIt.GoToBegin(); // Erase previous samples model->ClearSamples(); //This works with Image< itk::Vector > and with VectorImage< scalar >. unsigned int numberOfComponents = inIt.Get().Size(); while (!inIt.IsAtEnd() && !trIt.IsAtEnd()) { if (trIt.Get() != 0) { typename Superclass::ModelType::MeasurementType v; for (unsigned int k = 0; k < numberOfComponents; ++k) { v.push_back(inIt.Get()[k]); } model->AddSample(v, trIt.Get()); } ++inIt; ++trIt; } } } //End namespace OTB #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMMarginSampler.h000066400000000000000000000062061301006202600263460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMMarginSampler_h #define otbSVMMarginSampler_h #include "itkSampleClassifierFilter.h" #include "itkVectorImage.h" namespace otb { /** \class SVMMarginSampler * \brief Implement one iteration of active learning by margin * \ingroup ActiveLearningFilters * * \ingroup OTBSVMLearning */ template< class TSample, class TModel > class ITK_EXPORT SVMMarginSampler : public itk::Statistics::SampleClassifierFilter< TSample > { public: /** Standard class typedef*/ typedef SVMMarginSampler Self; typedef itk::Statistics::SampleClassifierFilter< TSample > Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkTypeMacro(SVMMarginSampler, itk::Statistics::SampleClassifierFilter); itkNewMacro(Self); /** Output type for GetClassSample method */ typedef typename Superclass::MembershipSampleType OutputType; /** typedefs from TSample object */ typedef typename TSample::MeasurementType MeasurementType; typedef typename TSample::MeasurementVectorType MeasurementVectorType; typedef std::pair IndexAndDistanceType; typedef std::vector IndexAndDistanceVectorType; typedef std::vector IndexVectorType; static bool Compare(const IndexAndDistanceType& l1, const IndexAndDistanceType & l2) { bool resp = l2.second > l1.second; return resp; } /** Type definitions for the SVM Model. */ typedef TModel SVMModelType; typedef typename SVMModelType::Pointer SVMModelPointer; typedef typename SVMModelType::DistancesVectorType DistancesVectorType; itkSetMacro(NumberOfCandidates, unsigned int); itkGetMacro(NumberOfCandidates, unsigned int); /** Set the model */ itkSetObjectMacro(Model, SVMModelType); /** Get the number of classes. */ itkGetObjectMacro(Model, SVMModelType); const IndexVectorType & GetMarginSamples() { return m_MarginSamples; } protected: SVMMarginSampler(); ~SVMMarginSampler() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Starts the classification process */ void GenerateData() ITK_OVERRIDE; virtual void DoMarginSampling(); private: /** Output pointer (MembershipSample) */ //typename OutputType::Pointer m_Output; SVMModelPointer m_Model; unsigned int m_NumberOfCandidates; IndexVectorType m_MarginSamples; }; // end of class } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMMarginSampler.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMMarginSampler.txx000066400000000000000000000071431301006202600267430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMMarginSampler_txx #define otbSVMMarginSampler_txx #include "otbSVMMarginSampler.h" #include "otbMacro.h" namespace otb { template< class TSample, class TModel > SVMMarginSampler< TSample, TModel > ::SVMMarginSampler() { m_NumberOfCandidates = 10; } template< class TSample, class TModel > void SVMMarginSampler< TSample, TModel > ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template< class TSample, class TModel > void SVMMarginSampler< TSample, TModel > ::GenerateData() { if(!m_Model) { itkExceptionMacro("No model, can not do classification."); } if(m_Model->GetNumberOfSupportVectors() == 0) { itkExceptionMacro(<<"SVM model does not contain any support vector, can not perform margin sampling."); } OutputType* output = const_cast(this->GetOutput()); output->SetSample(this->GetInput()); this->DoMarginSampling(); } template< class TSample, class TModel > void SVMMarginSampler< TSample, TModel > ::DoMarginSampling() { IndexAndDistanceVectorType idDistVector; OutputType* output = const_cast(this->GetOutput()); typename TSample::ConstIterator iter = this->GetInput()->Begin(); typename TSample::ConstIterator end = this->GetInput()->End(); typename OutputType::ConstIterator iterO = output->Begin(); typename OutputType::ConstIterator endO = output->End(); typename TSample::MeasurementVectorType measurements; int numberOfComponentsPerSample = iter.GetMeasurementVector().Size(); otbMsgDevMacro( << "Starting iterations " ); while (iter != end && iterO != endO) { int i = 0; typename SVMModelType::MeasurementType modelMeasurement; measurements = iter.GetMeasurementVector(); // otbMsgDevMacro( << "Loop on components " << svm_type ); for (i=0; iEvaluateHyperplanesDistances(modelMeasurement); double minDistance = vcl_abs(hdistances[0]); // Compute th min distances for(unsigned int j = 1; jAddInstance(static_cast(classLabel), iterO.GetInstanceIdentifier()); } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMModel.h000066400000000000000000000300441301006202600246420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMModel_h #define otbSVMModel_h #include "itkObjectFactory.h" #include "itkDataObject.h" #include "itkVariableLengthVector.h" #include "itkTimeProbe.h" #include "svm.h" namespace otb { /** \class SVMModel * \brief Class for SVM models. * * \TODO update documentation * * The basic functionality of the SVMModel framework base class is to * generate the models used in SVM classification. It requires input * images and a training image to be provided by the user. * This object supports data handling of multiband images. The object * accepts the input image in vector format only, where each pixel is a * vector and each element of the vector corresponds to an entry from * 1 particular band of a multiband dataset. A single band image is treated * as a vector image with a single element for every vector. The classified * image is treated as a single band scalar image. * * A membership function represents a specific knowledge about * a class. In other words, it should tell us how "likely" is that a * measurement vector (pattern) belong to the class. * * As the method name indicates, you can have more than one membership * function. One for each classes. The order you put the membership * calculator becomes the class label for the class that is represented * by the membership calculator. * * * \ingroup ClassificationFilters * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMModel : public itk::DataObject { public: /** Standard class typedefs. */ typedef SVMModel Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Value type */ typedef TValue ValueType; /** Label Type */ typedef TLabel LabelType; typedef std::vector MeasurementType; typedef std::pair SampleType; typedef std::vector SamplesVectorType; /** Cache vector type */ typedef std::vector CacheVectorType; /** Distances vector */ typedef itk::VariableLengthVector ProbabilitiesVectorType; typedef itk::VariableLengthVector DistancesVectorType; typedef struct svm_node * NodeCacheType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(SVMModel, itk::DataObject); /** Get the number of classes. */ unsigned int GetNumberOfClasses(void) const { if (m_Model) return (unsigned int) (m_Model->nr_class); return 0; } /** Get the number of hyperplane. */ unsigned int GetNumberOfHyperplane(void) const { if (m_Model) return (unsigned int) (m_Model->nr_class * (m_Model->nr_class - 1) / 2); return 0; } /** Gets the model */ const struct svm_model* GetModel() { return m_Model; } /** Gets the parameters */ struct svm_parameter& GetParameters() { return m_Parameters; } /** Gets the parameters */ const struct svm_parameter& GetParameters() const { return m_Parameters; } /** Saves the model to a file */ void SaveModel(const char* model_file_name) const; void SaveModel(const std::string& model_file_name) const { //implemented in term of const char * version this->SaveModel(model_file_name.c_str()); } /** Loads the model from a file */ void LoadModel(const char* model_file_name); void LoadModel(const std::string& model_file_name) { //implemented in term of const char * version this->LoadModel(model_file_name.c_str()); } /** Set the SVM type to C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR */ void SetSVMType(int svmtype) { m_Parameters.svm_type = svmtype; m_ModelUpToDate = false; this->Modified(); } /** Get the SVM type (C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR) */ int GetSVMType(void) const { return m_Parameters.svm_type; } /** Set the kernel type to LINEAR, POLY, RBF, SIGMOID linear: u'*v polynomial: (gamma*u'*v + coef0)^degree radial basis function: exp(-gamma*|u-v|^2) sigmoid: tanh(gamma*u'*v + coef0)*/ void SetKernelType(int kerneltype) { m_Parameters.kernel_type = kerneltype; m_ModelUpToDate = false; this->Modified(); } /** Get the kernel type */ int GetKernelType(void) const { return m_Parameters.kernel_type; } /** Set the degree of the polynomial kernel */ void SetPolynomialKernelDegree(int degree) { m_Parameters.degree = degree; m_ModelUpToDate = false; this->Modified(); } /** Get the degree of the polynomial kernel */ int GetPolynomialKernelDegree(void) const { return m_Parameters.degree; } /** Set the gamma parameter for poly/rbf/sigmoid kernels */ virtual void SetKernelGamma(double gamma) { m_Parameters.gamma = gamma; m_ModelUpToDate = false; this->Modified(); } /** Get the gamma parameter for poly/rbf/sigmoid kernels */ double GetKernelGamma(void) const { return m_Parameters.gamma; } /** Set the coef0 parameter for poly/sigmoid kernels */ void SetKernelCoef0(double coef0) { m_Parameters.coef0 = coef0; m_ModelUpToDate = false; this->Modified(); } /** Get the coef0 parameter for poly/sigmoid kernels */ double GetKernelCoef0(void) const { //return m_Parameters.coef0; return m_Parameters.coef0; } /** Set the Nu parameter for the training */ void SetNu(double nu) { m_Parameters.nu = nu; m_ModelUpToDate = false; this->Modified(); } /** Set the Nu parameter for the training */ double GetNu(void) const { //return m_Parameters.nu; return m_Parameters.nu; } /** Set the cache size in MB for the training */ void SetCacheSize(int cSize) { m_Parameters.cache_size = static_cast(cSize); m_ModelUpToDate = false; this->Modified(); } /** Get the cache size in MB for the training */ int GetCacheSize(void) const { return static_cast(m_Parameters.cache_size); } /** Set the C parameter for the training for C_SVC, EPSILON_SVR and NU_SVR */ void SetC(double c) { m_Parameters.C = c; m_ModelUpToDate = false; this->Modified(); } /** Get the C parameter for the training for C_SVC, EPSILON_SVR and NU_SVR */ double GetC(void) const { return m_Parameters.C; } /** Set the tolerance for the stopping criterion for the training*/ void SetEpsilon(double eps) { m_Parameters.eps = eps; m_ModelUpToDate = false; this->Modified(); } /** Get the tolerance for the stopping criterion for the training*/ double GetEpsilon(void) const { return m_Parameters.eps; } /* Set the value of p for EPSILON_SVR */ void SetP(double p) { m_Parameters.p = p; m_ModelUpToDate = false; this->Modified(); } /* Get the value of p for EPSILON_SVR */ double GetP(void) const { return m_Parameters.p; } /** Use the shrinking heuristics for the training */ void DoShrinking(bool s) { m_Parameters.shrinking = static_cast(s); m_ModelUpToDate = false; this->Modified(); } /** Get Use the shrinking heuristics for the training boolea */ bool GetDoShrinking(void) const { return static_cast(m_Parameters.shrinking); } /** Do probability estimates */ void DoProbabilityEstimates(bool prob) { m_Parameters.probability = static_cast(prob); m_ModelUpToDate = false; this->Modified(); } /** Get Do probability estimates boolean */ bool GetDoProbabilityEstimates(void) const { return static_cast(m_Parameters.probability); } /** Test if the model has probabilities */ bool HasProbabilities(void) const { return static_cast(svm_check_probability_model(m_Model)); } /** Return number of support vectors */ int GetNumberOfSupportVectors(void) const { if (m_Model) return m_Model->l; return 0; } /** Return rho values */ double * GetRho(void) const { if (m_Model) return m_Model->rho; return ITK_NULLPTR; } /** Return the support vectors */ svm_node ** GetSupportVectors(void) { if (m_Model) return m_Model->SV; return ITK_NULLPTR; } /** Set the support vectors and changes the l number of support vectors accordind to sv.*/ void SetSupportVectors(svm_node ** sv, int nbOfSupportVector); /** Return the alphas values (SV Coef) */ double ** GetAlpha(void) { if (m_Model) return m_Model->sv_coef; return ITK_NULLPTR; } /** Set the alphas values (SV Coef) */ void SetAlpha(double ** alpha, int nbOfSupportVector); /** Return the labels lists */ int * GetLabels() { if (m_Model) return m_Model->label; return ITK_NULLPTR; } /** Get the number of SV per classes */ int * GetNumberOfSVPerClasse() { if (m_Model) return m_Model->nSV; return ITK_NULLPTR; } struct svm_problem& GetProblem() { return m_Problem; } /** Allocate the problem */ void BuildProblem(); /** Check consistency (potentially throws exception) */ void ConsistencyCheck(); /** Estimate the model */ void Train(); /** Cross validation (returns the accuracy) */ double CrossValidation(unsigned int nbFolders); /** Predict (Please note that due to caching this method is not * thread safe. If you want to run multiple concurrent instances of * this method, please consider using the GetCopy() method to clone the * model.)*/ LabelType EvaluateLabel(const MeasurementType& measure) const; /** Evaluate hyperplan distances (Please note that due to caching this method is not * thread safe. If you want to run multiple concurrent instances of * this method, please consider using the GetCopy() method to clone the * model.)**/ DistancesVectorType EvaluateHyperplanesDistances(const MeasurementType& measure) const; /** Evaluate probabilities of each class. Returns a probability vector ordered * by increasing class label value * (Please note that due to caching this method is not thread safe. * If you want to run multiple concurrent instances of * this method, please consider using the GetCopy() method to clone the * model.)**/ ProbabilitiesVectorType EvaluateProbabilities(const MeasurementType& measure) const; /** Add a new sample to the list */ void AddSample(const MeasurementType& measure, const LabelType& label); /** Clear all samples */ void ClearSamples(); /** Set the samples vector */ void SetSamples(const SamplesVectorType& samples); /** Reset all the model, leaving it in the same state that just * before constructor call */ void Reset(); protected: /** Constructor */ SVMModel(); /** Destructor */ ~SVMModel() ITK_OVERRIDE; /** Display infos */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Delete any allocated problem */ void DeleteProblem(); /** Delete any allocated model */ void DeleteModel(); /** Initializes default parameters */ void Initialize() ITK_OVERRIDE; private: SVMModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Container to hold the SVM model itself */ struct svm_model* m_Model; /** True if model is up-to-date */ mutable bool m_ModelUpToDate; /** Container of the SVM problem */ struct svm_problem m_Problem; /** Container of the SVM parameters */ struct svm_parameter m_Parameters; /** true if problem is up-to-date */ bool m_ProblemUpToDate; /** Contains the samples */ SamplesVectorType m_Samples; }; // class SVMModel } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMModel.txx000066400000000000000000000365151301006202600252470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMModel_txx #define otbSVMModel_txx #include "otbSVMModel.h" #include "otbMacro.h" #include namespace otb { // TODO: Check memory allocation in this class template SVMModel::SVMModel() { // Default parameters this->SetSVMType(C_SVC); this->SetKernelType(LINEAR); this->SetPolynomialKernelDegree(3); this->SetKernelGamma(1.); // 1/k this->SetKernelCoef0(1.); this->SetNu(0.5); this->SetCacheSize(40); this->SetC(1); this->SetEpsilon(1e-3); this->SetP(0.1); this->DoShrinking(true); this->DoProbabilityEstimates(false); m_Parameters.nr_weight = 0; m_Parameters.weight_label = ITK_NULLPTR; m_Parameters.weight = ITK_NULLPTR; m_Model = ITK_NULLPTR; this->Initialize(); } template SVMModel::~SVMModel() { this->DeleteModel(); this->DeleteProblem(); } template void SVMModel::Initialize() { // Initialize model /* if (!m_Model) { m_Model = new struct svm_model; m_Model->l = 0; m_Model->nr_class = 0; m_Model->SV = NULL; m_Model->sv_coef = NULL; m_Model->rho = NULL; m_Model->label = NULL; m_Model->probA = NULL; m_Model->probB = NULL; m_Model->nSV = NULL; m_ModelUpToDate = false; } */ m_ModelUpToDate = false; // Initialize problem m_Problem.l = 0; m_Problem.y = ITK_NULLPTR; m_Problem.x = ITK_NULLPTR; m_ProblemUpToDate = false; } template void SVMModel::Reset() { this->DeleteProblem(); this->DeleteModel(); // Clear samples m_Samples.clear(); // Initialize values this->Initialize(); } template void SVMModel::DeleteModel() { if(m_Model) { svm_free_and_destroy_model(&m_Model); } m_Model = ITK_NULLPTR; } template void SVMModel::DeleteProblem() { // Deallocate any existing problem if (m_Problem.y) { delete[] m_Problem.y; m_Problem.y = ITK_NULLPTR; } if (m_Problem.x) { for (int i = 0; i < m_Problem.l; ++i) { if (m_Problem.x[i]) { delete[] m_Problem.x[i]; } } delete[] m_Problem.x; m_Problem.x = ITK_NULLPTR; } m_Problem.l = 0; m_ProblemUpToDate = false; } template void SVMModel::AddSample(const MeasurementType& measure, const LabelType& label) { SampleType newSample(measure, label); m_Samples.push_back(newSample); m_ProblemUpToDate = false; } template void SVMModel::ClearSamples() { m_Samples.clear(); m_ProblemUpToDate = false; } template void SVMModel::SetSamples(const SamplesVectorType& samples) { m_Samples = samples; m_ProblemUpToDate = false; } template void SVMModel::BuildProblem() { // Check if problem is up-to-date if (m_ProblemUpToDate) { return; } // Get number of samples int probl = m_Samples.size(); if (probl < 1) { itkExceptionMacro(<< "No samples, can not build SVM problem."); } otbMsgDebugMacro(<< "Rebuilding problem ..."); // Get the size of the samples long int elements = m_Samples[0].first.size() + 1; // Deallocate any previous problem this->DeleteProblem(); // Allocate the problem m_Problem.l = probl; m_Problem.y = new double[probl]; m_Problem.x = new struct svm_node*[probl]; for (int i = 0; i < probl; ++i) { // Initialize labels to 0 m_Problem.y[i] = 0; m_Problem.x[i] = new struct svm_node[elements]; // Initialize elements (value = 0; index = -1) for (unsigned int j = 0; j < static_cast(elements); ++j) { m_Problem.x[i][j].index = -1; m_Problem.x[i][j].value = 0; } } // Iterate on the samples typename SamplesVectorType::const_iterator sIt = m_Samples.begin(); int sampleIndex = 0; int maxElementIndex = 0; while (sIt != m_Samples.end()) { // Get the sample measurement and label MeasurementType measure = sIt->first; LabelType label = sIt->second; // Set the label m_Problem.y[sampleIndex] = label; int elementIndex = 0; // Populate the svm nodes for (typename MeasurementType::const_iterator eIt = measure.begin(); eIt != measure.end() && elementIndex < elements; ++eIt, ++elementIndex) { m_Problem.x[sampleIndex][elementIndex].index = elementIndex + 1; m_Problem.x[sampleIndex][elementIndex].value = (*eIt); } // Get the max index if (elementIndex > maxElementIndex) { maxElementIndex = elementIndex; } ++sampleIndex; ++sIt; } // Compute the kernel gamma from maxElementIndex if necessary if (this->GetKernelGamma() == 0) { this->SetKernelGamma(1.0 / static_cast(maxElementIndex)); } // problem is up-to-date m_ProblemUpToDate = true; } template double SVMModel::CrossValidation(unsigned int nbFolders) { // Build problem this->BuildProblem(); // Check consistency this->ConsistencyCheck(); // Get the length of the problem int length = m_Problem.l; // Temporary memory to store cross validation results double *target = new double[length]; // Do cross validation svm_cross_validation(&m_Problem, &m_Parameters, nbFolders, target); // Evaluate accuracy int i; double total_correct = 0.; for (i = 0; i < length; ++i) { if (target[i] == m_Problem.y[i]) { ++total_correct; } } double accuracy = total_correct / length; // Free temporary memory delete[] target; // return accuracy value return accuracy; } template void SVMModel::ConsistencyCheck() { if (m_Parameters.svm_type == ONE_CLASS && this->GetDoProbabilityEstimates()) { otbMsgDebugMacro(<< "Disabling SVM probability estimates for ONE_CLASS SVM type."); this->DoProbabilityEstimates(false); } const char* error_msg = svm_check_parameter(&m_Problem, &m_Parameters); if (error_msg) { throw itk::ExceptionObject(__FILE__, __LINE__, error_msg, ITK_LOCATION); } } template void SVMModel::Train() { // If the model is already up-to-date, return if (m_ModelUpToDate) { return; } // Build problem this->BuildProblem(); // Check consistency this->ConsistencyCheck(); // train the model m_Model = svm_train(&m_Problem, &m_Parameters); // Set the model as up-to-date m_ModelUpToDate = true; } template typename SVMModel::LabelType SVMModel::EvaluateLabel(const MeasurementType& measure) const { // Check if model is up-to-date if (!m_ModelUpToDate) { itkExceptionMacro(<< "Model is not up-to-date, can not predict label"); } // Check probability prediction bool predict_probability = svm_check_probability_model(m_Model); if (this->GetSVMType() == ONE_CLASS) { predict_probability = 0; } // Get type and number of classes int svm_type = svm_get_svm_type(m_Model); int nr_class = svm_get_nr_class(m_Model); // Allocate space for labels double *prob_estimates = ITK_NULLPTR; // Eventually allocate space for probabilities if (predict_probability) { if (svm_type == NU_SVR || svm_type == EPSILON_SVR) { otbMsgDevMacro( << "Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma), sigma=" << svm_get_svr_probability(m_Model)); } else { prob_estimates = new double[nr_class]; } } // Allocate nodes (/TODO if performances problems are related to too // many allocations, a cache approach can be set) struct svm_node * x = new struct svm_node[measure.size() + 1]; int valueIndex = 0; // Fill the node for (typename MeasurementType::const_iterator mIt = measure.begin(); mIt != measure.end(); ++mIt, ++valueIndex) { x[valueIndex].index = valueIndex + 1; x[valueIndex].value = (*mIt); } // terminate node x[measure.size()].index = -1; x[measure.size()].value = 0; LabelType label = 0; if (predict_probability && (svm_type == C_SVC || svm_type == NU_SVC)) { label = static_cast(svm_predict_probability(m_Model, x, prob_estimates)); } else { label = static_cast(svm_predict(m_Model, x)); } // Free allocated memory delete[] x; if (prob_estimates) { delete[] prob_estimates; } return label; } template typename SVMModel::DistancesVectorType SVMModel::EvaluateHyperplanesDistances(const MeasurementType& measure) const { // Check if model is up-to-date if (!m_ModelUpToDate) { itkExceptionMacro(<< "Model is not up-to-date, can not predict label"); } // Allocate nodes (/TODO if performances problems are related to too // many allocations, a cache approach can be set) struct svm_node * x = new struct svm_node[measure.size() + 1]; int valueIndex = 0; // Fill the node for (typename MeasurementType::const_iterator mIt = measure.begin(); mIt != measure.end(); ++mIt, ++valueIndex) { x[valueIndex].index = valueIndex + 1; x[valueIndex].value = (*mIt); } // terminate node x[measure.size()].index = -1; x[measure.size()].value = 0; // Initialize distances vector DistancesVectorType distances(m_Model->nr_class*(m_Model->nr_class - 1) / 2); // predict distances vector svm_predict_values(m_Model, x, (double*) (distances.GetDataPointer())); // Free allocated memory delete[] x; return (distances); } template typename SVMModel::ProbabilitiesVectorType SVMModel::EvaluateProbabilities(const MeasurementType& measure) const { // Check if model is up-to-date if (!m_ModelUpToDate) { itkExceptionMacro(<< "Model is not up-to-date, can not predict probabilities"); } if (!this->HasProbabilities()) { throw itk::ExceptionObject(__FILE__, __LINE__, "Model does not support probability estimates", ITK_LOCATION); } // Get number of classes int nr_class = svm_get_nr_class(m_Model); // Allocate nodes (/TODO if performances problems are related to too // many allocations, a cache approach can be set) struct svm_node * x = new struct svm_node[measure.size() + 1]; int valueIndex = 0; // Fill the node for (typename MeasurementType::const_iterator mIt = measure.begin(); mIt != measure.end(); ++mIt, ++valueIndex) { x[valueIndex].index = valueIndex + 1; x[valueIndex].value = (*mIt); } // Termination node x[measure.size()].index = -1; x[measure.size()].value = 0; double* dec_values = new double[nr_class]; svm_predict_probability(m_Model, x, dec_values); // Reorder values in increasing class label int* labels = m_Model->label; std::vector orderedLabels(nr_class); std::copy(labels, labels + nr_class, orderedLabels.begin()); std::sort(orderedLabels.begin(), orderedLabels.end()); ProbabilitiesVectorType probabilities(nr_class); for (int i = 0; i < nr_class; ++i) { // svm_predict_probability is such that "dec_values[i]" corresponds to label "labels[i]" std::vector::iterator it = std::find(orderedLabels.begin(), orderedLabels.end(), labels[i]); probabilities[it - orderedLabels.begin()] = dec_values[i]; } // Free allocated memory delete[] x; delete[] dec_values; return probabilities; } template void SVMModel::SaveModel(const char* model_file_name) const { if (svm_save_model(model_file_name, m_Model) != 0) { itkExceptionMacro(<< "Problem while saving SVM model " << std::string(model_file_name)); } } template void SVMModel::LoadModel(const char* model_file_name) { this->DeleteModel(); m_Model = svm_load_model(model_file_name); if (m_Model == ITK_NULLPTR) { itkExceptionMacro(<< "Problem while loading SVM model " << std::string(model_file_name)); } m_Parameters = m_Model->param; m_ModelUpToDate = true; } template void SVMModel::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } template void SVMModel::SetSupportVectors(svm_node ** sv, int nbOfSupportVector) { if (!m_Model) { itkExceptionMacro( "Internal SVM model is empty!"); } // erase the old SV // delete just the first element, it destoyes the whole pointers (cf SV filling with x_space) delete[] (m_Model->SV[0]); for (int n = 0; n < m_Model->l; ++n) { m_Model->SV[n] = ITK_NULLPTR; } delete[] (m_Model->SV); m_Model->SV = ITK_NULLPTR; m_Model->SV = new struct svm_node*[m_Model->l]; // copy new SV values svm_node **SV = m_Model->SV; // Compute the total number of SV elements. unsigned int elements = 0; for (int p = 0; p < nbOfSupportVector; ++p) { //std::cout << p << " "; const svm_node *tempNode = sv[p]; //std::cout << p << " "; while (tempNode->index != -1) { tempNode++; ++elements; } ++elements; // for -1 values } if (m_Model->l > 0) { SV[0] = new struct svm_node[elements]; memcpy(SV[0], sv[0], sizeof(svm_node*) * elements); } svm_node *x_space = SV[0]; int j = 0; for (int i = 0; i < m_Model->l; ++i) { // SV SV[i] = &x_space[j]; const svm_node *p = sv[i]; svm_node * pCpy = SV[i]; while (p->index != -1) { pCpy->index = p->index; pCpy->value = p->value; ++p; ++pCpy; ++j; } pCpy->index = -1; ++j; } if (m_Model->l > 0) { delete[] SV[0]; } } template void SVMModel::SetAlpha(double ** alpha, int itkNotUsed(nbOfSupportVector)) { if (!m_Model) { itkExceptionMacro( "Internal SVM model is empty!"); } // Erase the old sv_coef for (int i = 0; i < m_Model->nr_class - 1; ++i) { delete[] m_Model->sv_coef[i]; } delete[] m_Model->sv_coef; // copy new sv_coef values m_Model->sv_coef = new double*[m_Model->nr_class - 1]; for (int i = 0; i < m_Model->nr_class - 1; ++i) m_Model->sv_coef[i] = new double[m_Model->l]; for (int i = 0; i < m_Model->l; ++i) { // sv_coef for (int k = 0; k < m_Model->nr_class - 1; ++k) { m_Model->sv_coef[k][i] = alpha[k][i]; } } } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMModelEstimator.h000066400000000000000000000223051301006202600265330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMModelEstimator_h #define otbSVMModelEstimator_h #include "otbSVMModel.h" #include "itkProcessObject.h" namespace otb { /** \class SVMModelEstimator * \brief Class for SVM model estimation from images used for classification. * * * The basic functionality of the SVMModelEstimator framework base class is to * generate the models used in SVM classification. It requires input * images and a training image to be provided by the user. * This object supports data handling of multiband images. The object * accepts the input image in vector format only, where each pixel is a * vector and each element of the vector corresponds to an entry from * 1 particular band of a multiband dataset. A single band image is treated * as a vector image with a single element for every vector. The classified * image is treated as a single band scalar image. * * The template parameter is the type of a membership function the * ModelEstimator populates. * * A membership function represents a specific knowledge about * a class. In other words, it should tell us how "likely" is that a * measurement vector (pattern) belong to the class. * * As the method name indicates, you can have more than one membership * function. One for each classes. The order you put the membership * calculator becomes the class label for the class that is represented * by the membership calculator. * * * \ingroup ClassificationFilters * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMModelEstimator : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef SVMModelEstimator Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Model typedef */ typedef SVMModel ModelType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Macro defining the type*/ itkTypeMacro(SVMModelEstimator, SuperClass); /** Get the output model */ ModelType * GetModel(); /** Get the output model */ const ModelType * GetModel() const; /** Type definitions for the SVM Model. */ typedef SVMModel SVMModelType; typedef typename SVMModelType::Pointer SVMModelPointer; /** Get the cross validation accuracy measures */ itkGetMacro(InitialCrossValidationAccuracy, double); itkGetMacro(FinalCrossValidationAccuracy, double); /** Activate/Deactivate parameters optimization */ itkSetMacro(ParametersOptimization, bool); itkGetMacro(ParametersOptimization, bool); itkBooleanMacro(ParametersOptimization); /** Set/Get the number of steps for the coarse optimization */ itkSetMacro(CoarseOptimizationNumberOfSteps, unsigned int); itkGetMacro(CoarseOptimizationNumberOfSteps, unsigned int); /** Set/Get the number of steps for the fine optimization */ itkSetMacro(FineOptimizationNumberOfSteps, unsigned int); itkGetMacro(FineOptimizationNumberOfSteps, unsigned int); /** Set/Get the number of cross validation folders */ itkSetMacro(NumberOfCrossValidationFolders, unsigned int); itkGetMacro(NumberOfCrossValidationFolders, unsigned int); /** Get the number of classes */ unsigned int GetNumberOfClasses() { return this->GetModel()->GetNumberOfClasses(); } /** Set the SVM type to ONE_CLASS, C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR */ void SetSVMType(int svmtype) { this->GetModel()->SetSVMType(svmtype); this->Modified(); } /** Get the SVM type (C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR) */ int GetSVMType(void) { return this->GetModel()->GetSVMType(); } /** Set the kernel type to LINEAR, POLY, RBF, SIGMOID * - linear: \f$ u'*v \f$ * - polynomial: \f$ (\gamma*u'*v + coef0)^{degree} \f$ * - radial basis function: \f$ exp(-\gamma*|u-v|^2) \f$ * - sigmoid: \f$ tanh(\gamma*u'*v + coef0) \f$ */ void SetKernelType(int kerneltype) { this->GetModel()->SetKernelType(kerneltype); this->Modified(); } /** Get the kernel type */ int GetKernelType(void) { return this->GetModel()->GetKernelType(); } /** Set the degree of the polynomial kernel */ void SetPolynomialKernelDegree(int degree) { this->GetModel()->SetPolynomialKernelDegree(degree); this->Modified(); } /** Get the degree of the polynomial kernel */ int GetPolynomialKernelDegree(void) { return this->GetModel()->GetPolynomialKernelDegree(); } /** Set the gamma parameter for poly/rbf/sigmoid kernels */ void SetKernelGamma(double gamma) { this->GetModel()->SetKernelGamma(gamma); this->Modified(); } /** Get the gamma parameter for poly/rbf/sigmoid kernels */ double GetKernelGamma(void) { return this->GetModel()->GetKernelGamma(); } /** Set the coef0 parameter for poly/sigmoid kernels */ void SetKernelCoef0(double coef0) { this->GetModel()->SetKernelCoef0(coef0); this->Modified(); } /** Get the coef0 parameter for poly/sigmoid kernels */ double GetKernelCoef0(void) { return this->GetModel()->GetKernelCoef0(); } /** Set the Nu parameter for the training */ void SetNu(double nu) { this->GetModel()->SetNu(nu); this->Modified(); } /** Set the Nu parameter for the training */ double GetNu(void) { return this->GetModel()->GetNu(); } /** Set the cache size in MB for the training */ void SetCacheSize(int cSize) { this->GetModel()->SetCacheSize(cSize); this->Modified(); } /** Get the cache size in MB for the training */ int GetCacheSize(void) { return (this->GetModel()->GetCacheSize()); } /** Set the C parameter for the training for C_SVC, EPSILON_SVR and NU_SVR */ void SetC(double c) { this->GetModel()->SetC(c); this->Modified(); } /** Get the C parameter for the training for C_SVC, EPSILON_SVR and NU_SVR */ double GetC(void) { return this->GetModel()->GetC(); } /** Set the tolerance for the stopping criterion for the training*/ void SetEpsilon(double eps) { this->GetModel()->SetEpsilon(eps); this->Modified(); } /** Get the tolerance for the stopping criterion for the training*/ double GetEpsilon(void) { return this->GetModel()->GetEpsilon(); } /* Set the value of p for EPSILON_SVR */ void SetP(double p) { //param.svm_type = EPSILON_SVR; this->GetModel()->SetP(p); this->Modified(); } /* Get the value of p for EPSILON_SVR */ double GetP(void) { return this->GetModel()->GetP(); } /** Use the shrinking heuristics for the training */ void DoShrinking(bool s) { this->GetModel()->DoShrinking(s); this->Modified(); } /** Get Use the shrinking heuristics for the training boolean */ bool GetDoShrinking(void) { return (this->GetModel()->GetDoShrinking()); } /** Do probability estimates */ void DoProbabilityEstimates(bool prob) { this->GetModel()->DoProbabilityEstimates(prob); this->Modified(); } /** Get Do probability estimates boolean */ bool GetDoProbabilityEstimates(void) { return (this->GetModel()->GetDoProbabilityEstimates()); } /** Save the model */ virtual void SaveModel(const char * fname) { this->GetModel()->SaveModel(fname); } virtual void SaveModel(const std::string& fname) { //implemented in term of const char * version this->SaveModel(fname.c_str()); } protected: /** Constructor */ SVMModelEstimator(); /** Destructor */ ~SVMModelEstimator() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Starts the modelling process */ void GenerateData() ITK_OVERRIDE; /** This virtual function must be implemented in subclasses to populate the model with samples */ virtual void PrepareData(){} /** Optimize parameters */ void OptimizeParameters(); /** The number of classes */ unsigned int m_NumberOfClasses; private: SVMModelEstimator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented // Initial cross validation accuracy double m_InitialCrossValidationAccuracy; // Final cross validationa accuracy double m_FinalCrossValidationAccuracy; // Do parameters optimization, default : false bool m_ParametersOptimization; // Number of steps for the coarse search unsigned int m_CoarseOptimizationNumberOfSteps; // Number of steps for the fine search unsigned int m_FineOptimizationNumberOfSteps; // Number of cross validation folders unsigned int m_NumberOfCrossValidationFolders; }; // class SVMModelEstimator } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMModelEstimator.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMModelEstimator.txx000066400000000000000000000175741301006202600271430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMModelEstimator_txx #define otbSVMModelEstimator_txx #include "otbSVMModelEstimator.h" #include "otbSVMCrossValidationCostFunction.h" #include "otbExhaustiveExponentialOptimizer.h" #include "itkRegularStepGradientDescentOptimizer.h" #include "otbMacro.h" #include "itkCommand.h" namespace otb { template SVMModelEstimator ::SVMModelEstimator(void) : m_NumberOfClasses(0) { // Cross validation accuracy measures m_InitialCrossValidationAccuracy = 0.; m_FinalCrossValidationAccuracy = 0.; m_ParametersOptimization = false; m_NumberOfCrossValidationFolders = 5; m_CoarseOptimizationNumberOfSteps = 5; m_FineOptimizationNumberOfSteps = 5; this->SetNumberOfRequiredInputs(0); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, ModelType::New()); } template typename SVMModelEstimator::ModelType * SVMModelEstimator ::GetModel() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template const typename SVMModelEstimator::ModelType * SVMModelEstimator ::GetModel() const { if (this->GetNumberOfOutputs() < 1) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template SVMModelEstimator ::~SVMModelEstimator(void) {} /* * PrintSelf */ template void SVMModelEstimator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // end PrintSelf /** * Generate data (start the model building process) */ template void SVMModelEstimator ::GenerateData() { // Get the pointer to the output model ModelType * outputPtr = this->GetModel(); // Reset the model outputPtr->Reset(); // Prepare data this->PrepareData(); // Compute accuracy and eventually optimize parameters this->OptimizeParameters(); // Train the model outputPtr->Train(); } // end Generate data template void SVMModelEstimator ::OptimizeParameters() { typedef SVMCrossValidationCostFunction CrossValidationFunctionType; typename CrossValidationFunctionType::Pointer crossValidationFunction = CrossValidationFunctionType::New(); crossValidationFunction->SetModel(this->GetModel()); crossValidationFunction->SetNumberOfCrossValidationFolders(m_NumberOfCrossValidationFolders); typename CrossValidationFunctionType::ParametersType initialParameters, coarseBestParameters, fineBestParameters; switch (this->GetModel()->GetKernelType()) { case LINEAR: // C initialParameters.SetSize(1); initialParameters[0] = this->GetModel()->GetC(); break; case POLY: // C, gamma and coef0 initialParameters.SetSize(3); initialParameters[0] = this->GetModel()->GetC(); initialParameters[1] = this->GetModel()->GetKernelGamma(); initialParameters[2] = this->GetModel()->GetKernelCoef0(); break; case RBF: // C and gamma initialParameters.SetSize(2); initialParameters[0] = this->GetModel()->GetC(); initialParameters[1] = this->GetModel()->GetKernelGamma(); break; case SIGMOID: // C, gamma and coef0 initialParameters.SetSize(3); initialParameters[0] = this->GetModel()->GetC(); initialParameters[1] = this->GetModel()->GetKernelGamma(); initialParameters[2] = this->GetModel()->GetKernelCoef0(); break; default: // Only C initialParameters.SetSize(1); initialParameters[0] = this->GetModel()->GetC(); break; } m_InitialCrossValidationAccuracy = crossValidationFunction->GetValue(initialParameters); m_FinalCrossValidationAccuracy = m_InitialCrossValidationAccuracy; otbMsgDebugMacro(<< "Initial accuracy : " << m_InitialCrossValidationAccuracy << ", Parameters Optimization" << m_ParametersOptimization); if (m_ParametersOptimization) { otbMsgDebugMacro(<< "Model parameters optimization"); typename ExhaustiveExponentialOptimizer::Pointer coarseOptimizer = ExhaustiveExponentialOptimizer::New(); typename ExhaustiveExponentialOptimizer::StepsType coarseNbSteps(initialParameters.Size()); coarseNbSteps.Fill(m_CoarseOptimizationNumberOfSteps); coarseOptimizer->SetNumberOfSteps(coarseNbSteps); coarseOptimizer->SetCostFunction(crossValidationFunction); coarseOptimizer->SetInitialPosition(initialParameters); coarseOptimizer->StartOptimization(); coarseBestParameters = coarseOptimizer->GetMaximumMetricValuePosition(); otbMsgDevMacro( << "Coarse minimum accuracy: " << coarseOptimizer->GetMinimumMetricValue() << " " << coarseOptimizer->GetMinimumMetricValuePosition() ); otbMsgDevMacro( << "Coarse maximum accuracy: " << coarseOptimizer->GetMaximumMetricValue() << " " << coarseOptimizer->GetMaximumMetricValuePosition() ); typename ExhaustiveExponentialOptimizer::Pointer fineOptimizer = ExhaustiveExponentialOptimizer::New(); typename ExhaustiveExponentialOptimizer::StepsType fineNbSteps(initialParameters.Size()); fineNbSteps.Fill(m_FineOptimizationNumberOfSteps); double stepLength = 1. / static_cast(m_FineOptimizationNumberOfSteps); fineOptimizer->SetNumberOfSteps(fineNbSteps); fineOptimizer->SetStepLength(stepLength); fineOptimizer->SetCostFunction(crossValidationFunction); fineOptimizer->SetInitialPosition(coarseBestParameters); fineOptimizer->StartOptimization(); otbMsgDevMacro(<< "Fine minimum accuracy: " << fineOptimizer->GetMinimumMetricValue() << " " << fineOptimizer->GetMinimumMetricValuePosition() ); otbMsgDevMacro(<< "Fine maximum accuracy: " << fineOptimizer->GetMaximumMetricValue() << " " << fineOptimizer->GetMaximumMetricValuePosition() ); fineBestParameters = fineOptimizer->GetMaximumMetricValuePosition(); m_FinalCrossValidationAccuracy = fineOptimizer->GetMaximumMetricValue(); switch (this->GetModel()->GetKernelType()) { case LINEAR: // C this->GetModel()->SetC(fineBestParameters[0]); break; case POLY: // C, gamma and coef0 this->GetModel()->SetC(fineBestParameters[0]); this->GetModel()->SetKernelGamma(fineBestParameters[1]); this->GetModel()->SetKernelCoef0(fineBestParameters[2]); break; case RBF: // C and gamma this->GetModel()->SetC(fineBestParameters[0]); this->GetModel()->SetKernelGamma(fineBestParameters[1]); break; case SIGMOID: // C, gamma and coef0 this->GetModel()->SetC(fineBestParameters[0]); this->GetModel()->SetKernelGamma(fineBestParameters[1]); this->GetModel()->SetKernelCoef0(fineBestParameters[2]); break; default: // Only C this->GetModel()->SetC(fineBestParameters[0]); break; } } } } //End namespace OTB #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMPointSetModelEstimator.h000066400000000000000000000101561301006202600302220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMPointSetModelEstimator_h #define otbSVMPointSetModelEstimator_h #include "vcl_deprecated_header.h" #include "otbSVMModelEstimator.h" namespace otb { /** \class SVMPointSetModelEstimator * \brief Class for SVM model * estimation from PointSets used for classification. * * * The basic functionality of the SVMPointSetModelEstimator is to * generate the models used in SVM classification. It * requires one input poinset and a training pointset to be provided by the * user. This object supports data handling of multiband data. The * object accepts the input image as a VectorImage only, where each * pixel is a vector and each element of the vector corresponds to an * entry from 1 particular band of a multiband dataset. A single band * data set is treated as a vector with a single element for every * vector. The classified data is treated as a single band scalar * data. * * \deprecated * * \sa MachineLearningModel * \sa LibSVMMachineLearningModel * \sa ImageClassificationFilter * * \ingroup ClassificationFilters * * \ingroup OTBSVMLearning */ template class ITK_EXPORT SVMPointSetModelEstimator : public SVMModelEstimator { public: /** Standard class typedefs. */ typedef SVMPointSetModelEstimator Self; typedef SVMModelEstimator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SVMPointSetModelEstimator, SVMModelEstimator); /** Type definition for the input image. */ typedef typename TInputPointSet::Pointer InputPointSetPointer; /** Type definitions for the training image. */ typedef typename TTrainingPointSet::Pointer TrainingPointSetPointer; /** Type definition for the vector associated with * input image pixel type. */ typedef typename TInputPointSet::PixelType InputPointSetPixelType; typedef typename TInputPointSet::PointType InputPointType; /** Type definitions for the vector holding * training image pixel type. */ typedef typename TTrainingPointSet::PixelType TrainingPointSetPixelType; /** Type definitions for the iterators for the input and training images. */ typedef typename TInputPointSet::PointsContainerConstIterator InputPointSetIteratorType; typedef typename TTrainingPointSet::PointsContainerConstIterator TrainingPointSetIteratorType; /** Set the input image */ void SetInputPointSet(const TInputPointSet * inputPointSet); /** Set the training image */ void SetTrainingPointSet(const TTrainingPointSet * trainingPointSet); /** Get the input image */ const TInputPointSet * GetInputPointSet(); /** Get the training image */ const TTrainingPointSet * GetTrainingPointSet(); protected: /** Constructor */ SVMPointSetModelEstimator(); /** Destructor */ ~SVMPointSetModelEstimator() ITK_OVERRIDE; /** PrintSelf */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Prepare data */ void PrepareData() ITK_OVERRIDE; private: SVMPointSetModelEstimator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // class SVMPointSetModelEstimator } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMPointSetModelEstimator.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMPointSetModelEstimator.txx000066400000000000000000000113761301006202600306230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMPointSetModelEstimator_txx #define otbSVMPointSetModelEstimator_txx #include "otbSVMPointSetModelEstimator.h" #include "itkCommand.h" #include "otbMacro.h" namespace otb { template SVMPointSetModelEstimator ::SVMPointSetModelEstimator(void) : SVMModelEstimator() { this->SetNumberOfRequiredInputs(2); } template SVMPointSetModelEstimator ::~SVMPointSetModelEstimator(void) {} /* * PrintSelf */ template void SVMPointSetModelEstimator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // end PrintSelf template void SVMPointSetModelEstimator ::SetInputPointSet(const TInputPointSet * inputPointSet) { this->itk::ProcessObject::SetNthInput(0, const_cast(inputPointSet)); } template void SVMPointSetModelEstimator ::SetTrainingPointSet(const TTrainingPointSet * trainingPointSet) { this->itk::ProcessObject::SetNthInput(1, const_cast(trainingPointSet)); } template const TInputPointSet * SVMPointSetModelEstimator ::GetInputPointSet() { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TTrainingPointSet * SVMPointSetModelEstimator ::GetTrainingPointSet() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } /** * Generate data (start the model building process) */ template void SVMPointSetModelEstimator ::PrepareData() { //Do some error checking const TInputPointSet * inputPointSet = this->GetInputPointSet(); const TTrainingPointSet * trainingPointSet = this->GetTrainingPointSet(); typename Superclass::ModelType * model = this->GetModel(); int inputPointSetSize = inputPointSet->GetNumberOfPoints(); int trainingPointSetSize = trainingPointSet->GetNumberOfPoints(); // Check if size of the two inputs are same if (inputPointSetSize != trainingPointSetSize) throw itk::ExceptionObject( __FILE__, __LINE__, "Input pointset size is not the same as the training pointset size.", ITK_LOCATION); // Declaration of the iterators on the input and training images InputPointSetIteratorType inIt = inputPointSet->GetPoints()->Begin(); TrainingPointSetIteratorType trIt = trainingPointSet->GetPoints()->Begin(); InputPointSetIteratorType inEnd = inputPointSet->GetPoints()->End(); TrainingPointSetIteratorType trEnd = trainingPointSet->GetPoints()->End(); // Erase previous samples model->ClearSamples(); otbMsgDevMacro(<< " Input nb points " << inputPointSetSize); otbMsgDevMacro(<< " Training nb points " << trainingPointSetSize); unsigned int dataId = 0; while (inIt != inEnd && trIt != trEnd) { typename TTrainingPointSet::PixelType label = itk::NumericTraits::Zero; trainingPointSet->GetPointData(dataId, &label); otbMsgDevMacro(<< " Label " << label); typename TInputPointSet::PixelType value; inputPointSet->GetPointData(dataId, &value); typename Superclass::ModelType::MeasurementType v; typename TInputPointSet::PixelType::iterator pIt = value.begin(); typename TInputPointSet::PixelType::iterator pEnd = value.end(); while (pIt != pEnd) { v.push_back(*pIt); ++pIt; } model->AddSample(v, label); ++inIt; ++trIt; ++dataId; } } } //End namespace OTB #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMSampleListModelEstimator.h000066400000000000000000000147621301006202600305410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMSampleListModelEstimator_h #define otbSVMSampleListModelEstimator_h #include "vcl_deprecated_header.h" #include "itkImageModelEstimatorBase.h" #include "itkImageRegionIterator.h" #include "otbSVMModelEstimator.h" namespace otb { namespace Functor { /** \class VectorToMeasurementVectorFunctor * \brief Helper class to convert itk::Vector and itk::FixedArray samples to internal * training vector type. * * \sa Vector * \sa FixedArray * * \ingroup OTBSVMLearning */ template class VectorToMeasurementVectorFunctor { public: typedef TVector VectorType; typedef std::vector MeasurementVectorType; inline MeasurementVectorType operator ()(const VectorType& value) const { MeasurementVectorType output; for (unsigned int i = 0; i < value.Size(); ++i) { output.push_back(value[i]); } return output; } }; /** \class VariableLengthVectorToMeasurementVectorFunctor * \brief Helper class to convert itk::VariableLengthVector samples to internal * training vector type. * \sa VariableLengthVector * * \ingroup OTBSVMLearning */ template class VariableLengthVectorToMeasurementVectorFunctor { public: typedef TVector VectorType; typedef std::vector MeasurementVectorType; inline MeasurementVectorType operator ()(const VectorType& value) const { MeasurementVectorType output; for (unsigned int i = 0; i < value.GetNumberOfElements(); ++i) { output.push_back(value.GetElement(i)); } return output; } }; } /** * \class SVMSampleListModelEstimator * \brief Class for SVM model estimation from SampleLists used for classification. * * * The basic functionality of the SVMSampleListModelEstimator is to * generate the models used in SVM classification. It * requires one input poinset and a training pointset to be provided by the * user. This object supports data handling of multiband data. The * object accepts the input image as a VectorImage only, where each * pixel is a vector and each element of the vector corresponds to an * entry from 1 particular band of a multiband dataset. A single band * data set is treated as a vector with a single element for every * vector. The classified data is treated as a single band scalar * data. * * \deprecated * * \sa MachineLearningModel * \sa LibSVMMachineLearningModel * \sa ImageClassificationFilter * * \ingroup ClassificationFilters * * \ingroup OTBSVMLearning */ template > class ITK_EXPORT SVMSampleListModelEstimator : public SVMModelEstimator { public: /** Standard class typedefs. */ typedef SVMSampleListModelEstimator Self; typedef SVMModelEstimator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SVMSampleListModelEstimator, SVMModelEstimator); /** Type definition for the input image. */ typedef TInputSampleList InputSampleListType; typedef typename TInputSampleList::Pointer InputSampleListPointer; /** Type definitions for the training image. */ typedef TTrainingSampleList TrainingSampleListType; typedef typename TTrainingSampleList::Pointer TrainingSampleListPointer; /** Type definition for the vector associated with * input image pixel type. */ typedef typename TInputSampleList::ValueType InputSampleListValueType; /** Type definitions for the vector holding * training image pixel type. */ typedef typename TTrainingSampleList::ValueType TrainingSampleListValueType; /** Type definitions for the iterators for the input and training images. */ typedef typename TInputSampleList::ConstIterator InputSampleListIteratorType; typedef typename TTrainingSampleList::ConstIterator TrainingSampleListIteratorType; /** Measurement functor typedef */ typedef TMeasurementFunctor MeasurementFunctorType; /** Set the input image. */ //itkSetObjectMacro(InputSampleList, TInputSampleList); void SetInputSampleList(const InputSampleListType* inputSampleList); /** Get the input image. */ //itkGetObjectMacro(InputSampleList, TInputSampleList); const InputSampleListType* GetInputSampleList(); /** Set the training image. */ //itkSetMacro(TrainingSampleList, TrainingSampleListPointer); void SetTrainingSampleList(const TrainingSampleListType* trainingSampleList); /** Get the training image. */ //itkGetMacro(TrainingSampleList, TrainingSampleListPointer); const TrainingSampleListType* GetTrainingSampleList(); protected: /** Constructor */ SVMSampleListModelEstimator(); /** Destructor */ ~SVMSampleListModelEstimator() ITK_OVERRIDE; /** PrintSelf */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** PrepareData method */ void PrepareData() ITK_OVERRIDE; private: SVMSampleListModelEstimator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented TrainingSampleListPointer m_TrainingSampleList; InputSampleListPointer m_InputSampleList; }; // class SVMSampleListModelEstimator } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMSampleListModelEstimator.txx" #endif #endif OTB-release-5.8/Modules/Learning/SVMLearning/include/otbSVMSampleListModelEstimator.txx000066400000000000000000000137131301006202600311300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMSampleListModelEstimator_txx #define otbSVMSampleListModelEstimator_txx #include "otbSVMSampleListModelEstimator.h" #include "itkCommand.h" #include "otbMacro.h" namespace otb { template SVMSampleListModelEstimator ::SVMSampleListModelEstimator(void) : SVMModelEstimator() { this->SetNumberOfRequiredInputs(2); } template SVMSampleListModelEstimator ::~SVMSampleListModelEstimator(void) {} //Set the input sample list template void SVMSampleListModelEstimator ::SetInputSampleList( const InputSampleListType* inputSampleList ) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast< InputSampleListType* >(inputSampleList) ); } // Set the label sample list template void SVMSampleListModelEstimator ::SetTrainingSampleList(const TrainingSampleListType* trainingSampleList) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(1, const_cast(trainingSampleList) ); } // Get the input sample list template const typename SVMSampleListModelEstimator::InputSampleListType * SVMSampleListModelEstimator ::GetInputSampleList( ) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0) ); } // Get the input label sample list template const typename SVMSampleListModelEstimator::TrainingSampleListType * SVMSampleListModelEstimator ::GetTrainingSampleList( ) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(1)); } /* * PrintSelf */ template void SVMSampleListModelEstimator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } // end PrintSelf /** * Generate data (start the model building process) */ template void SVMSampleListModelEstimator ::PrepareData() { //Do some error checking InputSampleListPointer inputSampleList = const_cast(this->GetInputSampleList()); TrainingSampleListPointer trainingSampleList = const_cast(this->GetTrainingSampleList()); typename Superclass::ModelType * model = this->GetModel(); int inputSampleListSize = inputSampleList->Size(); int trainingSampleListSize = trainingSampleList->Size(); // Check if size of the two inputs are same if (inputSampleListSize != trainingSampleListSize) { /*throw itk::ExceptionObject( __FILE__, __LINE__, "Input pointset size is not the same as the training pointset size.", ITK_LOCATION); */ itkExceptionMacro(<< "Input pointset size is not the same as the training pointset size (" << inputSampleListSize << " vs "<< trainingSampleListSize << ")."); } // Declaration of the iterators on the input and training images InputSampleListIteratorType inIt = inputSampleList->Begin(); TrainingSampleListIteratorType trIt = trainingSampleList->Begin(); InputSampleListIteratorType inEnd = inputSampleList->End(); TrainingSampleListIteratorType trEnd = trainingSampleList->End(); // Clear previous samples model->ClearSamples(); otbMsgDebugMacro(<< " Input nb points " << inputSampleListSize); otbMsgDebugMacro(<< " Training nb points " << trainingSampleListSize); MeasurementFunctorType mfunctor; while (inIt != inEnd && trIt != trEnd) { typename TTrainingSampleList::MeasurementType label = trIt.GetMeasurementVector()[0]; typename TInputSampleList::MeasurementVectorType value = inIt.GetMeasurementVector(); model->AddSample(mfunctor(value), label); ++inIt; ++trIt; } } } //End namespace OTB #endif OTB-release-5.8/Modules/Learning/SVMLearning/otb-module.cmake000066400000000000000000000006231301006202600237640ustar00rootroot00000000000000set(DOCUMENTATION "Deprecated classes for SVM learning. See module 'Supervised' for a replacement") otb_module(OTBSVMLearning DEPENDS OTBVectorDataBase OTBITK OTBImageBase OTBLibSVM OTBLabelMap OTBStreaming OTBCommon TEST_DEPENDS OTBStatistics OTBImageIO OTBMoments OTBVectorDataIO OTBIOXML OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Learning/SVMLearning/src/000077500000000000000000000000001301006202600215015ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/SVMLearning/src/CMakeLists.txt000066400000000000000000000005171301006202600242440ustar00rootroot00000000000000set(OTBSVMLearning_SRC otbExhaustiveExponentialOptimizer.cxx ) add_library(OTBSVMLearning ${OTBSVMLearning_SRC}) target_link_libraries(OTBSVMLearning ${OTBVectorDataBase_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBLibSVM_LIBRARIES} ${OTBStreaming_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBSVMLearning) OTB-release-5.8/Modules/Learning/SVMLearning/src/otbExhaustiveExponentialOptimizer.cxx000066400000000000000000000135151301006202600311760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbExhaustiveExponentialOptimizer.h" #include "itkCommand.h" #include "itkEventObject.h" namespace otb { /** * Constructor */ ExhaustiveExponentialOptimizer ::ExhaustiveExponentialOptimizer() { itkDebugMacro("Constructor"); m_GeometricProgression = 2.0; m_StepLength = 1.0; m_CurrentIteration = 0; m_CurrentValue = 0; m_CurrentParameter = 0; m_CurrentIndex.Fill(0); m_Stop = false; m_NumberOfSteps.Fill(0); } /** * Start walking */ void ExhaustiveExponentialOptimizer::StartOptimization(void) { this->StartWalking(); } void ExhaustiveExponentialOptimizer ::StartWalking(void) { itkDebugMacro("StartWalking"); this->InvokeEvent(itk::StartEvent()); ParametersType initialPos = this->GetInitialPosition(); m_MinimumMetricValuePosition = initialPos; m_MaximumMetricValuePosition = initialPos; MeasureType initialValue = this->GetValue(this->GetInitialPosition()); m_MaximumMetricValue = initialValue; m_MinimumMetricValue = initialValue; m_CurrentIteration = 0; m_MaximumNumberOfIterations = 1; const unsigned int spaceDimension = this->GetInitialPosition().GetSize(); for (unsigned int i = 0; i < spaceDimension; ++i) { m_MaximumNumberOfIterations *= (2 * m_NumberOfSteps[i] + 1); } m_CurrentIndex.SetSize(spaceDimension); m_CurrentIndex.Fill(0); ScalesType scales = this->GetScales(); // Make sure the scales have been set properly if (scales.size() != spaceDimension) { itkExceptionMacro(<< "The size of Scales is " << scales.size() << ", but the NumberOfParameters is " << spaceDimension << "."); } // Setup first grid position. ParametersType position(spaceDimension); for (unsigned int i = 0; i < spaceDimension; ++i) { position[i] = this->GetInitialPosition()[i] * vcl_pow(m_GeometricProgression, -static_cast(m_NumberOfSteps[i]) * m_StepLength) * scales[i]; } this->SetCurrentPosition(position); itkDebugMacro("Calling ResumeWalking"); this->ResumeWalking(); } /** * Resume the optimization */ void ExhaustiveExponentialOptimizer ::ResumeWalking(void) { itkDebugMacro("ResumeWalk"); m_Stop = false; while (!m_Stop) { ParametersType currentPosition = this->GetCurrentPosition(); if (m_Stop) { StopWalking(); break; } m_CurrentValue = this->GetValue(currentPosition); if (m_CurrentValue > m_MaximumMetricValue) { m_MaximumMetricValue = m_CurrentValue; m_MaximumMetricValuePosition = currentPosition; } if (m_CurrentValue < m_MinimumMetricValue) { m_MinimumMetricValue = m_CurrentValue; m_MinimumMetricValuePosition = currentPosition; } if (m_Stop) { this->StopWalking(); break; } this->InvokeEvent(itk::IterationEvent()); this->AdvanceOneStep(); m_CurrentIteration++; } } void ExhaustiveExponentialOptimizer ::StopWalking(void) { itkDebugMacro("StopWalking"); m_Stop = true; this->InvokeEvent(itk::EndEvent()); } void ExhaustiveExponentialOptimizer ::AdvanceOneStep(void) { itkDebugMacro("AdvanceOneStep"); const unsigned int spaceDimension = m_CostFunction->GetNumberOfParameters(); ParametersType newPosition(spaceDimension); IncrementIndex(newPosition); itkDebugMacro(<< "new position = " << newPosition); this->SetCurrentPosition(newPosition); } void ExhaustiveExponentialOptimizer ::IncrementIndex(ParametersType& newPosition) { unsigned int idx = 0; const unsigned int spaceDimension = m_CostFunction->GetNumberOfParameters(); while (idx < spaceDimension) { m_CurrentIndex[idx]++; if (m_CurrentIndex[idx] > (2 * m_NumberOfSteps[idx])) { m_CurrentIndex[idx] = 0; ++idx; } else { break; } } if (idx == spaceDimension) { m_Stop = true; } for (unsigned int i = 0; i < spaceDimension; ++i) { newPosition[i] = this->GetInitialPosition()[i] * this->GetScales()[i] * vcl_pow(m_GeometricProgression, static_cast(m_CurrentIndex[i] - m_NumberOfSteps[i]) * m_StepLength); } } void ExhaustiveExponentialOptimizer ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "CurrentValue = " << m_CurrentValue << std::endl; os << indent << "NumberOfSteps = " << m_NumberOfSteps << std::endl; os << indent << "CurrentIteration = " << m_CurrentIteration << std::endl; os << indent << "Stop = " << m_Stop << std::endl; os << indent << "CurrentParameter = " << m_CurrentParameter << std::endl; os << indent << "GeometricProgression = " << m_GeometricProgression << std::endl; os << indent << "CurrentIndex = " << m_CurrentIndex << std::endl; os << indent << "MaximumNumberOfIterations = " << m_MaximumNumberOfIterations << std::endl; os << indent << "MaximumMetricValue = " << m_MaximumMetricValue << std::endl; os << indent << "MinimumMetricValue = " << m_MinimumMetricValue << std::endl; os << indent << "MinimumMetricValuePosition = " << m_MinimumMetricValuePosition << std::endl; os << indent << "MaximumMetricValuePosition = " << m_MaximumMetricValuePosition << std::endl; } } // end namespace itk OTB-release-5.8/Modules/Learning/SVMLearning/test/000077500000000000000000000000001301006202600216715ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/SVMLearning/test/CMakeLists.txt000066400000000000000000000205411301006202600244330ustar00rootroot00000000000000otb_module_test() set(OTBSVMLearningTests otbSVMLearningTestDriver.cxx otbSVMImageClassificationWithRuleFilter.cxx otbLabelMapSVMClassifier.cxx otbSVMPointSetModelEstimatorTrain.cxx otbExhaustiveExponentialOptimizerNew.cxx otbSVMImageModelEstimatorModelAccessor.cxx otbSVMImageClassificationFilter.cxx otbSVMModelNew.cxx otbSVMImageModelEstimatorNew.cxx otbSVMImageModelEstimatorTrainOneClass.cxx otbSVMCrossValidationCostFunctionNew.cxx otbSVMModelLoadSave.cxx otbSVMClassifierPointSet.cxx otbSVMImageClassificationWithRuleFilterNew.cxx otbSVMImageModelEstimatorTrain.cxx otbObjectDetectionClassifier.cxx otbSVMClassifierNew.cxx otbSVMSampleListModelEstimatorTest.cxx otbSVMModelAccessor.cxx otbSVMModelLoad.cxx otbSVMImageClassificationFilterNew.cxx otbSVMPointSetModelEstimatorNew.cxx otbSVMMarginSampler.cxx otbExhaustiveExponentialOptimizerTest.cxx ) add_executable(otbSVMLearningTestDriver ${OTBSVMLearningTests}) target_link_libraries(otbSVMLearningTestDriver ${OTBSVMLearning-Test_LIBRARIES}) otb_module_target_label(otbSVMLearningTestDriver) # Tests Declaration otb_add_test(NAME leTvSVMImageClassificationWithRuleFilter COMMAND otbSVMLearningTestDriver --compare-image ${NOTOL} ${BASELINE}/leSVMImageClassificationWithRuleFilterOutput.tif ${TEMP}/leSVMImageClassificationWithRuleFilterOutput.tif otbSVMImageClassificationWithRuleFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/svm_model_image ${TEMP}/leSVMImageClassificationWithRuleFilterOutput.tif) #otb_add_test(NAME obTvLabelMapSVMClassifier COMMAND otbSVMLearningTestDriver #otbLabelMapSVMClassifier #${INPUTDATA}/maur.tif #${INPUTDATA}/maur_labelled.tif #${TEMP}/obTvLabelMapSVMClassifierLabeledOutput.tif) otb_add_test(NAME obTuLabelMapSVMClassifierNew COMMAND otbSVMLearningTestDriver otbLabelMapSVMClassifierNew) otb_add_test(NAME leTvSVMPointSetModelEstimatorTrain COMMAND otbSVMLearningTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/leTvsvm_model_pointset ${TEMP}/leTvsvm_model_pointset otbSVMPointSetModelEstimatorTrain ${TEMP}/leTvsvm_model_pointset) otb_add_test(NAME leTuExhaustiveExponentialOptimizerNew COMMAND otbSVMLearningTestDriver otbExhaustiveExponentialOptimizerNew) otb_add_test(NAME leTvSVMImageModelEstimatorModelAccessor COMMAND otbSVMLearningTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/leSVMModelEstimatorModelAccessor.txt ${TEMP}/leSVMModelEstimatorModelAccessor.txt otbSVMImageModelEstimatorModelAccessor ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4_train.c1.hdr ${TEMP}/leSVMModelEstimatorModelAccessor.txt) otb_add_test(NAME leTvSVMImageClassificationFilter COMMAND otbSVMLearningTestDriver --compare-image ${NOTOL} ${BASELINE}/leSVMImageClassificationFilterOutput.tif ${TEMP}/leSVMImageClassificationFilterOutput.tif otbSVMImageClassificationFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/svm_model_image ${TEMP}/leSVMImageClassificationFilterOutput.tif) otb_add_test(NAME leTuSVMModelNew COMMAND otbSVMLearningTestDriver otbSVMModelNew) otb_add_test(NAME leTuSVMImageModelEstimatorNew COMMAND otbSVMLearningTestDriver otbSVMImageModelEstimatorNew) otb_add_test(NAME leTvSVMImageModelEstimatorTrainOneClass COMMAND otbSVMLearningTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/leTvsvm_model_image_one_class ${TEMP}/leTvsvm_model_image_one_class otbSVMImageModelEstimatorTrainOneClass ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4_train_one_class.tif ${TEMP}/leTvsvm_model_image_one_class) otb_add_test(NAME leTuSVMCrossValidationCostFunctionNew COMMAND otbSVMLearningTestDriver otbSVMCrossValidationCostFunctionNew) otb_add_test(NAME leTvSVMModelLoadSave COMMAND otbSVMLearningTestDriver --compare-ascii ${NOTOL} ${INPUTDATA}/svm_model ${TEMP}/svmmodel_test otbSVMModelLoadSave ${INPUTDATA}/svm_model ${TEMP}/svmmodel_test) otb_add_test(NAME leTvSVMClassifierPointSet COMMAND otbSVMLearningTestDriver otbSVMClassifierPointSet ${INPUTDATA}/svm_model_pointset) otb_add_test(NAME leTuSVMImageClassificationWithRuleFilterNew COMMAND otbSVMLearningTestDriver otbSVMImageClassificationWithRuleFilterNew) otb_add_test(NAME leTvSVMImageModelEstimatorTrain COMMAND otbSVMLearningTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/leTvsvm_model_image ${TEMP}/leTvsvm_model_image otbSVMImageModelEstimatorTrain ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4_train.c1.hdr ${TEMP}/leTvsvm_model_image 0 ) # RK: 09/2016. LibSVM has serious issues in the code. Fixing this third party code is the right fix # which requires some time and communication with upstream developer. But in the mean-time this failing test # cannot be attributed to way OTB or OTB dashboard. For this reason, I am skipping 'baseline' comparison of output # results. From this day onwards test results are not validated and can have bad results. # If and When libsvm code is fixed, we put back test validation. Until then, we are extremely sorry for this action. # Twisting the test to check only some parameters while skipping always problematic ones does not seems a right choice. # After all, test has problem which is clear, a fix is needed for sure and that fix must be applied upstream # --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/leTvsvm_model_image_opt # ${TEMP}/leTvsvm_model_image_opt otb_add_test(NAME leTvSVMImageModelEstimatorTrainWithOptimization COMMAND otbSVMLearningTestDriver otbSVMImageModelEstimatorTrain ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4_train.c1.hdr ${TEMP}/leTvsvm_model_image_opt 1) otb_add_test(NAME odTuObjectDetectionClassifierNew COMMAND otbSVMLearningTestDriver otbObjectDetectionClassifierNew ) otb_add_test(NAME odTvObjectDetectionClassifierStreaming COMMAND otbSVMLearningTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/TvObjectDetectionClassifierOutput.txt ${TEMP}/TvObjectDetectionClassifierOutputStreaming.txt otbObjectDetectionClassifier ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01_extract_amplitude.tif ${INPUTDATA}/ObjectReco/Boats/FeatureStats_RadiometricMoments_amplitude.xml ${BASELINE_FILES}/TvDescriptorsSVMModelCreation.svm ${TEMP}/TvObjectDetectionClassifierOutputStreaming.txt 50 # streaming 5 # neighborhood radius ) otb_add_test(NAME odTvObjectDetectionClassifier COMMAND otbSVMLearningTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/TvObjectDetectionClassifierOutput.txt ${TEMP}/TvObjectDetectionClassifierOutput.txt otbObjectDetectionClassifier ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01_extract_amplitude.tif ${INPUTDATA}/ObjectReco/Boats/FeatureStats_RadiometricMoments_amplitude.xml ${BASELINE_FILES}/TvDescriptorsSVMModelCreation.svm ${TEMP}/TvObjectDetectionClassifierOutput.txt 0 # streaming 5 # neighborhood radius ) otb_add_test(NAME leTuSVMClassifierNew COMMAND otbSVMLearningTestDriver otbSVMClassifierNew) otb_add_test(NAME leTvSVMSampleListModelEstimatorTest COMMAND otbSVMLearningTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/leTvSVMSampleListModelEstimatorModel.txt ${TEMP}/leTvSVMSampleListModelEstimatorModel.txt otbSVMSampleListModelEstimatorTest ${EXAMPLEDATA}/qb_RoadExtract.tif ${EXAMPLEDATA}/qb_RoadExtract_easyClassification.shp ${TEMP}/leTvSVMSampleListModelEstimatorModel.txt ) otb_add_test(NAME leTuSVMSampleListModelEstimatorNew COMMAND otbSVMLearningTestDriver otbSVMSampleListModelEstimatorNew) otb_add_test(NAME leTvSVMModelAccessor COMMAND otbSVMLearningTestDriver --compare-ascii ${EPSILON_5} ${BASELINE_FILES}/leSVMModelAccessor.txt ${TEMP}/leSVMModelAccessor.txt otbSVMModelAccessor ${INPUTDATA}/svm_model ${TEMP}/leSVMModelAccessor.txt) otb_add_test(NAME leTuSVMModelLoad COMMAND otbSVMLearningTestDriver otbSVMModelLoad ${INPUTDATA}/svm_model) otb_add_test(NAME leTuSVMImageClassificationFilterNew COMMAND otbSVMLearningTestDriver otbSVMImageClassificationFilterNew) otb_add_test(NAME leTuSVMPointSetModelEstimatorNew COMMAND otbSVMLearningTestDriver otbSVMPointSetModelEstimatorNew) otb_add_test(NAME leTuSVMMarginSamplerNew COMMAND otbSVMLearningTestDriver otbSVMMarginSamplerNew) otb_add_test(NAME leTvExhaustiveExponentialOptimizerTest COMMAND otbSVMLearningTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvExhaustiveExponentialOptimizerOutput.txt ${TEMP}/leTvExhaustiveExponentialOptimizerTestOutput.txt otbExhaustiveExponentialOptimizerTest ${TEMP}/leTvExhaustiveExponentialOptimizerTestOutput.txt) OTB-release-5.8/Modules/Learning/SVMLearning/test/otbExhaustiveExponentialOptimizerNew.cxx000066400000000000000000000015701301006202600320360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbExhaustiveExponentialOptimizer.h" int otbExhaustiveExponentialOptimizerNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { otb::ExhaustiveExponentialOptimizer::Pointer opt = otb::ExhaustiveExponentialOptimizer::New(); std::cout << opt << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbExhaustiveExponentialOptimizerTest.cxx000066400000000000000000000150311301006202600322210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbExhaustiveExponentialOptimizer.h" #include "itkArray.h" /** class Quadratic2DCostFunction * brief: Class for 2D quadratic function evaluation. * This class represent a 2 quadratic function which is defined by * a * x^2 + b * y^2 + c * x * y + d * x + e * y + f * a, b, c, d, e, f are the model internal parameters * x, y are the parameters of this function * */ class Quadratic2DCostFunction : public itk::SingleValuedCostFunction { public: /** Standard class typedefs. */ typedef Quadratic2DCostFunction Self; typedef itk::SingleValuedCostFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Type definitions for the quadratic Model. */ typedef Superclass::MeasureType MeasureType; typedef Superclass::ParametersType ParametersType; typedef Superclass::ParametersValueType ParametersValueType; /** Type definitions for the quadratic Model. */ typedef ParametersValueType ModelValueType; typedef ParametersType ModelType; /** Set the parameters of the quadratic function */ void SetFunctionInternalParameters(ModelValueType aCoef, ModelValueType bCoef, ModelValueType cCoef, ModelValueType dCoef, ModelValueType eCoef, ModelValueType fCoef) { m_FunctionInternalParameters[0] = aCoef; m_FunctionInternalParameters[1] = bCoef; m_FunctionInternalParameters[2] = cCoef; m_FunctionInternalParameters[3] = dCoef; m_FunctionInternalParameters[4] = eCoef; m_FunctionInternalParameters[5] = fCoef; }; void SetFunctionInternalParameters(ModelType quadraticModel2D) { this->SetFunctionInternalParameters(quadraticModel2D[0], quadraticModel2D[1], quadraticModel2D[2], quadraticModel2D[3], quadraticModel2D[4], quadraticModel2D[5]); }; /** \return The accuracy value corresponding the parameters */ MeasureType GetValue(const ParametersType& parameters) const ITK_OVERRIDE { return static_cast ( m_FunctionInternalParameters.GetElement(0) * parameters.GetElement(0) * parameters.GetElement(0) + m_FunctionInternalParameters.GetElement(1) * parameters.GetElement(1) * parameters.GetElement(1) + m_FunctionInternalParameters.GetElement(2) * parameters.GetElement(0) * parameters.GetElement(1) + m_FunctionInternalParameters.GetElement(3) * parameters.GetElement(0) + m_FunctionInternalParameters.GetElement(4) * parameters.GetElement(1) + m_FunctionInternalParameters.GetElement(5) ); }; /** \return the number of parameters to optimize */ unsigned int GetNumberOfParameters(void) const ITK_OVERRIDE {return 2; }; /** \return The accuracy derivative corresponding to the parameters */ void GetDerivative(const ParametersType& itkNotUsed(parameters), DerivativeType& itkNotUsed(derivative)) const ITK_OVERRIDE {}; /// Constructor Quadratic2DCostFunction() { m_FunctionInternalParameters = ModelType(6); m_FunctionInternalParameters.Fill(0.0); }; /// Destructor ~Quadratic2DCostFunction() ITK_OVERRIDE{}; private: Quadratic2DCostFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ModelType m_FunctionInternalParameters; }; // class Quadratic2DCostFunction int otbExhaustiveExponentialOptimizerTest(int itkNotUsed(argc), char* argv[]) { Quadratic2DCostFunction::Pointer costFunction = Quadratic2DCostFunction::New(); costFunction->SetFunctionInternalParameters(1.0, 1.0, 0.0, -6.0, 4.0, 13.0); // (x-3)^2 + (y+2)^2 => solution: x=3 and y=-2 typedef Quadratic2DCostFunction::ParametersType ParametersType; ParametersType initialPosition = ParametersType(2); initialPosition[0] = 4.5; initialPosition[1] = -5.3; std::cout << "initial position: " << costFunction->GetValue(initialPosition) << std::endl; otb::ExhaustiveExponentialOptimizer::Pointer optimizer = otb::ExhaustiveExponentialOptimizer::New(); typedef otb::ExhaustiveExponentialOptimizer::StepsType StepOptimizerType; StepOptimizerType nbSteps(initialPosition.Size()); nbSteps.Fill(5); optimizer->SetNumberOfSteps(nbSteps); optimizer->SetCostFunction(costFunction); optimizer->SetInitialPosition(initialPosition); optimizer->StartOptimization(); std::cout << "Minimum cost function founded: " << optimizer->GetMinimumMetricValue() << " " << optimizer->GetMinimumMetricValuePosition() << std::endl; std::cout << "Maximum cost function founded: " << optimizer->GetMaximumMetricValue() << " " << optimizer->GetMaximumMetricValuePosition() << std::endl; otb::ExhaustiveExponentialOptimizer::Pointer fineoptimizer = otb::ExhaustiveExponentialOptimizer::New(); double stepLength = 1. / static_cast(5); fineoptimizer->SetNumberOfSteps(nbSteps); fineoptimizer->SetStepLength(stepLength); fineoptimizer->SetCostFunction(costFunction); fineoptimizer->SetInitialPosition(optimizer->GetMinimumMetricValuePosition()); fineoptimizer->StartOptimization(); std::cout << "fine minimum cost function founded: " << fineoptimizer->GetMinimumMetricValue() << " " << fineoptimizer->GetMinimumMetricValuePosition() << std::endl; std::cout << "fine maximum cost function founded: " << fineoptimizer->GetMaximumMetricValue() << " " << fineoptimizer->GetMaximumMetricValuePosition() << std::endl; std::ofstream file; file.open(argv[1]); file << "initial value: " << costFunction->GetValue(initialPosition) << ", position: " << initialPosition <<"\n"; file << "minimum: " << fineoptimizer->GetMinimumMetricValue() << ", position: " << fineoptimizer->GetMinimumMetricValuePosition() << "\n"; file << "maximum: " << fineoptimizer->GetMaximumMetricValue() << ", position: " << fineoptimizer->GetMaximumMetricValuePosition() << "\n"; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbLabelMapSVMClassifier.cxx000066400000000000000000000175161301006202600272040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include #include #include "otbVectorImage.h" #include "otbAttributesMapLabelObjectWithClassLabel.h" #include "itkLabelImageToLabelMapFilter.h" #include "otbShapeAttributesLabelMapFilter.h" #include "otbBandsStatisticsAttributesLabelMapFilter.h" #include "otbLabelMapWithClassLabelToLabeledSampleListFilter.h" #include "otbSVMSampleListModelEstimator.h" #include "otbLabelMapSVMClassifier.h" #include "otbLabelMapWithClassLabelToClassLabelImageFilter.h" const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef double DoublePixelType; typedef otb::AttributesMapLabelObjectWithClassLabel LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::VectorImage VectorImageType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader LabeledReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter LabeledWriterType; typedef itk::LabelImageToLabelMapFilter LabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeFilterType; typedef otb::BandsStatisticsAttributesLabelMapFilter BandsStatisticsFilterType; // SVM model estimation typedef itk::VariableLengthVector VectorType; typedef itk::FixedArray TrainingVectorType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::ListSample TrainingListSampleType; typedef otb::LabelMapWithClassLabelToLabeledSampleListFilter ListSampleFilterType; typedef otb::Functor::VariableLengthVectorToMeasurementVectorFunctor MeasurementVectorFunctorType; typedef otb::SVMSampleListModelEstimator SVMEstimatorType; typedef otb::LabelMapSVMClassifier ClassifierType; typedef otb::LabelMapWithClassLabelToClassLabelImageFilter ClassifImageGeneratorType; LabelObjectType::Pointer makeTrainingSample(LabelMapType* labelMap, LabelType labelObjectId, LabelType classLabel) { LabelObjectType::Pointer newLabelObject = LabelObjectType::New(); newLabelObject->CopyAllFrom( labelMap->GetLabelObject(labelObjectId) ); newLabelObject->SetClassLabel(classLabel); return newLabelObject; } int otbLabelMapSVMClassifierNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { ClassifierType::Pointer classifier = ClassifierType::New(); return EXIT_SUCCESS; } int otbLabelMapSVMClassifier(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * lfname = argv[2]; const char * outfname = argv[3]; // Filters instantiation ReaderType::Pointer reader = ReaderType::New(); LabeledReaderType::Pointer labeledReader = LabeledReaderType::New(); LabelMapFilterType::Pointer filter = LabelMapFilterType::New(); ShapeFilterType::Pointer shapeFilter = ShapeFilterType::New(); BandsStatisticsFilterType::Pointer radiometricFilter = BandsStatisticsFilterType::New(); LabelMapType::Pointer trainingLabelMap = LabelMapType::New(); ListSampleFilterType::Pointer labelMap2SampleList = ListSampleFilterType::New(); SVMEstimatorType::Pointer svmEstim = SVMEstimatorType::New(); ClassifierType::Pointer classifier = ClassifierType::New(); ClassifImageGeneratorType::Pointer imGenerator = ClassifImageGeneratorType::New(); LabeledWriterType::Pointer writer = LabeledWriterType::New(); // Read inputs reader->SetFileName(infname); labeledReader->SetFileName(lfname); // Make a LabelMap out of it filter->SetInput(labeledReader->GetOutput()); filter->SetBackgroundValue(itk::NumericTraits::max()); //Compute shape and radimometric attributes shapeFilter->SetInput(filter->GetOutput()); radiometricFilter->SetInput(shapeFilter->GetOutput()); radiometricFilter->SetFeatureImage(reader->GetOutput()); radiometricFilter->Update(); // Build a sub-LabelMap with class-labeled LabelObject LabelMapType::Pointer labelMap = radiometricFilter->GetOutput(); // The following is very specific to the input specified in CMakeLists // water trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 13, 0)); // road trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 88, 1)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 114, 1)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 144, 1)); // boat trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 52, 2)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 31, 2)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 11, 2)); // roof trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 58, 3)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 60, 3)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 27, 3)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 81, 3)); // vegetation trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 161, 4)); trainingLabelMap->PushLabelObject(makeTrainingSample(labelMap, 46, 4)); // Make a ListSample out of trainingLabelMap labelMap2SampleList->SetInputLabelMap(trainingLabelMap); std::vector attributes = labelMap->GetLabelObject(0)->GetAvailableAttributes(); std::vector::const_iterator attrIt; for (attrIt = attributes.begin(); attrIt != attributes.end(); ++attrIt) { labelMap2SampleList->GetMeasurementFunctor().AddAttribute((*attrIt).c_str()); } labelMap2SampleList->Update(); // Estimate SVM model svmEstim->SetInputSampleList(labelMap2SampleList->GetOutputSampleList()); svmEstim->SetTrainingSampleList(labelMap2SampleList->GetOutputTrainingSampleList()); svmEstim->Modified(); svmEstim->Update(); // Classify using the whole LabelMap with estimated model classifier->SetInput(labelMap); classifier->SetModel(svmEstim->GetModel()); for (attrIt = attributes.begin(); attrIt != attributes.end(); ++attrIt) { classifier->GetMeasurementFunctor().AddAttribute((*attrIt).c_str()); } classifier->Update(); // Make a labeled image with the classification result imGenerator->SetInput(classifier->GetOutput()); writer->SetInput(imGenerator->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbObjectDetectionClassifier.cxx000066400000000000000000000117741301006202600302060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbImage.h" #include "otbRadiometricMomentsImageFunction.h" #include "itkListSample.h" #include "itkVariableLengthVector.h" #include "otbObjectDetectionClassifier.h" #include "otbImageFileReader.h" #include "otbImageFunctionAdaptor.h" #include "otbStatisticsXMLFileReader.h" #include "itkPreOrderTreeIterator.h" const unsigned int Dimension = 2; typedef int LabelType; typedef double PixelType; typedef double FunctionPrecisionType; typedef double CoordRepType; typedef otb::Image ImageType; typedef otb::VectorData<> VectorDataType; typedef VectorDataType::PointType PointType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef otb::ObjectDetectionClassifier < ImageType, VectorDataType, LabelType, FunctionPrecisionType, CoordRepType > ObjectDetectionClassifierType; typedef otb::RadiometricMomentsImageFunction FunctionType; typedef otb::ImageFunctionAdaptor AdaptedFunctionType; typedef otb::ImageFileReader ImageReaderType; typedef ObjectDetectionClassifierType::SVMModelType SVMModelType; typedef ObjectDetectionClassifierType::SVMModelPointerType SVMModelPointerType; typedef otb::StatisticsXMLFileReader StatisticsXMLFileReaderType; struct ComparePoint { bool operator () (PointType p, PointType q) { // order with the y axis position if (p[1] < q[1]) return true; if (p[1] > q[1]) return false; // If one the same line, // order with the x axis position if (p[0] < q[0]) return true; return false; } }; std::ostream &operator<<(std::ostream &stream, PointType p) { stream << p[0] << " " << p[1]; return stream; } int otbObjectDetectionClassifierNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { ObjectDetectionClassifierType::Pointer object = ObjectDetectionClassifierType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } int otbObjectDetectionClassifier(int argc, char* argv[]) { if (argc != 7) { std::cerr << "Wrong number of arguments" << std::endl; return EXIT_FAILURE; } const char* inputImageFileName = argv[1]; const char* inputFeatureStats = argv[2]; const char* inputSVMModel = argv[3]; const char* outputVectorDataFileName = argv[4]; int streaming = atoi(argv[5]); int neighborhood = atoi(argv[6]); ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(inputImageFileName); StatisticsXMLFileReaderType::Pointer statisticsReader = StatisticsXMLFileReaderType::New(); statisticsReader->SetFileName(inputFeatureStats); SVMModelPointerType svmModel = SVMModelType::New(); svmModel->LoadModel(inputSVMModel); AdaptedFunctionType::Pointer descriptorsFunction = AdaptedFunctionType::New(); descriptorsFunction->SetInputImage(imageReader->GetOutput()); descriptorsFunction->GetInternalImageFunction()->SetNeighborhoodRadius(neighborhood); ObjectDetectionClassifierType::Pointer classifier = ObjectDetectionClassifierType::New(); classifier->SetInputImage(imageReader->GetOutput()); classifier->SetNeighborhoodRadius(neighborhood); classifier->SetSVMModel(svmModel); classifier->SetDescriptorsFunction(descriptorsFunction); classifier->SetNoClassLabel(0); classifier->SetClassKey("Class"); classifier->SetShifts(statisticsReader->GetStatisticVectorByName("mean")); classifier->SetScales(statisticsReader->GetStatisticVectorByName("stddev")); classifier->GetStreamer()->SetNumberOfLinesStrippedStreaming( streaming ); classifier->SetGridStep(neighborhood/2); classifier->Update(); std::vector points; VectorDataType::Pointer vectorData = classifier->GetOutputVectorData(); TreeIteratorType itVector(vectorData->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsPointFeature()) { points.push_back(itVector.Get()->GetPoint()); } ++itVector; } std::sort(points.begin(), points.end(), ComparePoint()); std::ofstream file(outputVectorDataFileName); std::copy(points.begin(), points.end(), std::ostream_iterator(file, "\n")); file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMClassifierNew.cxx000066400000000000000000000023011301006202600262420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkPointSetToListSampleAdaptor.h" #include "itkSubsample.h" #include "otbSVMClassifier.h" int otbSVMClassifierNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef int LabelPixelType; typedef itk::PointSet PointSetType; typedef itk::Statistics::PointSetToListSampleAdaptor DataSampleType; typedef otb::SVMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); std::cout << classifier << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMClassifierPointSet.cxx000066400000000000000000000072171301006202600272710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkPoint.h" #include "itkPointSetToListSampleAdaptor.h" #include "itkSubsample.h" #include "otbSVMClassifier.h" int otbSVMClassifierPointSet(int argc, char* argv[]) { if (argc != 2) { std::cout << "Usage : " << argv[0] << " modelFile" << std::endl; return EXIT_FAILURE; } const char * modelFilename = argv[1]; std::cout << "Building the pointset" << std::endl; typedef double InputPixelType; typedef int LabelPixelType; typedef std::vector InputVectorType; const unsigned int Dimension = 2; typedef itk::PointSet MeasurePointSetType; MeasurePointSetType::Pointer mPSet = MeasurePointSetType::New(); typedef MeasurePointSetType::PointType MeasurePointType; typedef MeasurePointSetType::PointsContainer MeasurePointsContainer; MeasurePointsContainer::Pointer mCont = MeasurePointsContainer::New(); unsigned int pointId; for (pointId = 0; pointId < 20; pointId++) { MeasurePointType mP; mP[0] = pointId; mP[1] = pointId; InputVectorType measure; //measure.push_back(vcl_pow(pointId, 2.0)); measure.push_back(double(2.0 * pointId)); measure.push_back(double(-10)); mCont->InsertElement(pointId, mP); mPSet->SetPointData(pointId, measure); } mPSet->SetPoints(mCont); std::cout << "PointSet built" << std::endl; typedef itk::Statistics::PointSetToListSampleAdaptor SampleType; SampleType::Pointer sample = SampleType::New(); sample->SetPointSet(mPSet); std::cout << "Sample set to Adaptor" << std::endl; /** preparing classifier and decision rule object */ typedef otb::SVMModel ModelType; ModelType::Pointer model = ModelType::New(); model->LoadModel(modelFilename); std::cout << "Model loaded" << std::endl; int numberOfClasses = model->GetNumberOfClasses(); typedef otb::SVMClassifier ClassifierType; ClassifierType::Pointer classifier = ClassifierType::New(); classifier->SetNumberOfClasses(numberOfClasses); classifier->SetModel(model); classifier->SetInput(sample.GetPointer()); classifier->Update(); /* Build the class map */ std::cout << "classifier get output" << std::endl; ClassifierType::OutputType* membershipSample = classifier->GetOutput(); std::cout << "Sample iterators" << std::endl; ClassifierType::OutputType::ConstIterator m_iter = membershipSample->Begin(); ClassifierType::OutputType::ConstIterator m_last = membershipSample->End(); double error = 0.0; pointId = 0; while (m_iter != m_last) { ClassifierType::ClassLabelType label = m_iter.GetClassLabel(); InputVectorType measure; mPSet->GetPointData(pointId, &measure); if (label != ((measure[0] + measure[1]) > 0)) error++; std::cout << label << "/" << ((measure[0] + measure[1]) > 0) << std::endl; ++pointId; ++m_iter; } std::cout << "Error = " << error / pointId << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMCrossValidationCostFunctionNew.cxx000066400000000000000000000021351301006202600316260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbSVMCrossValidationCostFunction.h" int otbSVMCrossValidationCostFunctionNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef unsigned char LabelPixelType; typedef otb::SVMModel ModelType; typedef otb::SVMCrossValidationCostFunction FunctionType; FunctionType::Pointer function = FunctionType::New(); std::cout << function << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMImageClassificationFilter.cxx000066400000000000000000000040031301006202600305510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSVMImageClassificationFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbSVMImageClassificationFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * modelfname = argv[2]; const char * outfname = argv[3]; const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::SVMImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::ModelType ModelType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); ModelType::Pointer model = ModelType::New(); model->LoadModel(modelfname); filter->SetModel(model); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMImageClassificationFilterNew.cxx000066400000000000000000000023621301006202600312310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSVMImageClassificationFilter.h" #include "otbVectorImage.h" #include "otbImage.h" int otbSVMImageClassificationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::SVMImageClassificationFilter ClassificationFilterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMImageClassificationWithRuleFilter.cxx000066400000000000000000000037771301006202600322560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSVMImageClassificationWithRuleFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbSVMImageClassificationWithRuleFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * modelfname = argv[2]; const char * outfname = argv[3]; const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::SVMImageClassificationWithRuleFilter ClassificationFilterType; typedef ClassificationFilterType::ModelType ModelType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); ModelType::Pointer model = ModelType::New(); model->LoadModel(modelfname); filter->SetModel(model); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMImageClassificationWithRuleFilterNew.cxx000066400000000000000000000024061301006202600327140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSVMImageClassificationWithRuleFilter.h" #include "otbImage.h" int otbSVMImageClassificationWithRuleFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::SVMImageClassificationWithRuleFilter ClassificationWithRuleFilterType; // Instantiating object ClassificationWithRuleFilterType::Pointer filter = ClassificationWithRuleFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMImageModelEstimatorModelAccessor.cxx000066400000000000000000000114341301006202600320520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbSVMModel.h" #include "otbSVMImageModelEstimator.h" #include "otbImageFileReader.h" int otbSVMImageModelEstimatorModelAccessor(int itkNotUsed(argc), char* argv[]) { const char* inputImageFileName = argv[1]; const char* trainingImageFileName = argv[2]; const char* outputModelFileName = argv[3]; typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image TrainingImageType; typedef otb::SVMImageModelEstimator EstimatorType; typedef otb::ImageFileReader InputReaderType; typedef otb::ImageFileReader TrainingReaderType; InputReaderType::Pointer inputReader = InputReaderType::New(); TrainingReaderType::Pointer trainingReader = TrainingReaderType::New(); inputReader->SetFileName(inputImageFileName); trainingReader->SetFileName(trainingImageFileName); inputReader->Update(); trainingReader->Update(); EstimatorType::Pointer svmEstimator = EstimatorType::New(); svmEstimator->SetInputImage(inputReader->GetOutput()); svmEstimator->SetTrainingImage(trainingReader->GetOutput()); svmEstimator->ParametersOptimizationOff(); svmEstimator->Update(); typedef EstimatorType::SVMModelPointer SVMModelPointer; SVMModelPointer ptrModel = svmEstimator->GetModel(); std::ofstream f; unsigned int nbClass = ptrModel->GetNumberOfClasses(); unsigned int nbSupportVector = ptrModel->GetNumberOfSupportVectors(); f.open(outputModelFileName); f << "Test methods of SVMModel class:" << std::endl; f << " - GetNumberOfClasses() " << nbClass << std::endl; f << " - GetNumberOfHyperplane() " << ptrModel->GetNumberOfHyperplane() << std::endl; f << " - GetNumberOfSupportVectors() " << nbSupportVector << std::endl; f << " - GetSupportVectors() [nb support vector][]" << std::endl; svm_node ** SVs = ptrModel->GetSupportVectors(); if (SVs == ITK_NULLPTR) { itkGenericExceptionMacro(<< "SVs NULL"); } for (unsigned int i = 0; i < nbSupportVector; ++i) { if (SVs[i] == ITK_NULLPTR) itkGenericExceptionMacro(<< "SVs " << i << " NULL"); f << std::endl; f << " SV[" << i << "]:"; const svm_node *p = SVs[i]; /* for(unsigned int j=0; jGetKernelType() == PRECOMPUTED) { f << " " << p->value; } else { while (p->index != -1) { f << " [" << p->index << ";" << p->value << "] "; p++; } } f << std::endl; // } } f << " - GetRho() [nr_class*(nr_class-1)/2]" << std::endl; unsigned int taille = nbClass * (nbClass - 1) / 2; double * rhos = ptrModel->GetRho(); if (rhos == ITK_NULLPTR) { itkGenericExceptionMacro(<< "rhos NULL"); } f << std::setprecision(10) << " "; for (unsigned int i = 0; i < taille; ++i) { f << " " << rhos[i]; } f << std::endl; f << " - GetAlpha() [nb class-1][nb support vector]" << std::endl; double ** alphas = ptrModel->GetAlpha(); if (alphas == ITK_NULLPTR) { itkGenericExceptionMacro(<< "alphas NULL"); } for (unsigned int i = 0; i < nbClass - 1; ++i) { if (alphas[i] == ITK_NULLPTR) itkGenericExceptionMacro(<< "alphas " << i << " NULL"); f << " "; for (unsigned int j = 0; j < nbSupportVector; ++j) { f << " " << alphas[i][j]; } } f << std::endl; // f << " - Evaluate() (double) -> "<Evaluate()<EvaluateHyperplaneDistance(); // f << " - EvaluateHyperplaneDistance() VariableLengthVector() nb value(s): "<<_evaluateHyperplaneDistance.Size()< #include "otbSVMImageModelEstimator.h" int otbSVMImageModelEstimatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image TrainingImageType; typedef otb::SVMImageModelEstimator EstimatorType; EstimatorType::Pointer svmModel = EstimatorType::New(); std::cout << svmModel << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMImageModelEstimatorTrain.cxx000066400000000000000000000044421301006202600304050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include #include "otbSVMImageModelEstimator.h" #include "otbImageFileReader.h" int otbSVMImageModelEstimatorTrain(int itkNotUsed(argc), char* argv[]) { // Force the pseudo-random number generator to always output // the same sequence of random numbers // Done because, in case of optimization, rand() is called by libsvm srand(0); const char* inputImageFileName = argv[1]; const char* trainingImageFileName = argv[2]; const char* outputModelFileName = argv[3]; const bool optimization = atoi(argv[4]); typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image TrainingImageType; typedef otb::SVMImageModelEstimator EstimatorType; typedef otb::ImageFileReader InputReaderType; typedef otb::ImageFileReader TrainingReaderType; InputReaderType::Pointer inputReader = InputReaderType::New(); TrainingReaderType::Pointer trainingReader = TrainingReaderType::New(); EstimatorType::Pointer svmEstimator = EstimatorType::New(); inputReader->SetFileName(inputImageFileName); trainingReader->SetFileName(trainingImageFileName); inputReader->Update(); trainingReader->Update(); svmEstimator->SetInputImage(inputReader->GetOutput()); svmEstimator->SetTrainingImage(trainingReader->GetOutput()); svmEstimator->SetParametersOptimization(optimization); svmEstimator->Update(); otbGenericMsgDebugMacro(<< "Saving model"); svmEstimator->GetModel()->SaveModel(outputModelFileName); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMImageModelEstimatorTrainOneClass.cxx000066400000000000000000000040511301006202600320310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbVectorImage.h" #include #include "otbSVMImageModelEstimator.h" #include "otbImageFileReader.h" int otbSVMImageModelEstimatorTrainOneClass(int itkNotUsed(argc), char* argv[]) { const char* inputImageFileName = argv[1]; const char* trainingImageFileName = argv[2]; const char* outputModelFileName = argv[3]; typedef double InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image TrainingImageType; typedef otb::SVMImageModelEstimator EstimatorType; typedef otb::ImageFileReader InputReaderType; typedef otb::ImageFileReader TrainingReaderType; InputReaderType::Pointer inputReader = InputReaderType::New(); TrainingReaderType::Pointer trainingReader = TrainingReaderType::New(); EstimatorType::Pointer svmEstimator = EstimatorType::New(); inputReader->SetFileName(inputImageFileName); trainingReader->SetFileName(trainingImageFileName); inputReader->Update(); trainingReader->Update(); svmEstimator->SetInputImage(inputReader->GetOutput()); svmEstimator->SetTrainingImage(trainingReader->GetOutput()); svmEstimator->SetSVMType(ONE_CLASS); svmEstimator->Update(); otbGenericMsgDebugMacro(<< "Saving model"); svmEstimator->GetModel()->SaveModel(outputModelFileName); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMLearningTestDriver.cxx000066400000000000000000000024321301006202600272640ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbSVMImageClassificationWithRuleFilter); REGISTER_TEST(otbLabelMapSVMClassifierNew); REGISTER_TEST(otbLabelMapSVMClassifier); REGISTER_TEST(otbSVMPointSetModelEstimatorTrain); REGISTER_TEST(otbExhaustiveExponentialOptimizerNew); REGISTER_TEST(otbSVMImageModelEstimatorModelAccessor); REGISTER_TEST(otbSVMImageClassificationFilter); REGISTER_TEST(otbSVMModelNew); REGISTER_TEST(otbSVMImageModelEstimatorNew); REGISTER_TEST(otbSVMImageModelEstimatorTrainOneClass); REGISTER_TEST(otbSVMCrossValidationCostFunctionNew); REGISTER_TEST(otbSVMModelLoadSave); REGISTER_TEST(otbSVMClassifierPointSet); REGISTER_TEST(otbSVMImageClassificationWithRuleFilterNew); REGISTER_TEST(otbSVMImageModelEstimatorTrain); REGISTER_TEST(otbObjectDetectionClassifierNew); REGISTER_TEST(otbObjectDetectionClassifier); REGISTER_TEST(otbSVMClassifierNew); REGISTER_TEST(otbSVMSampleListModelEstimatorNew); REGISTER_TEST(otbSVMSampleListModelEstimatorTest); REGISTER_TEST(otbSVMModelAccessor); REGISTER_TEST(otbSVMModelLoad); REGISTER_TEST(otbSVMImageClassificationFilterNew); REGISTER_TEST(otbSVMPointSetModelEstimatorNew); REGISTER_TEST(otbSVMMarginSamplerNew); REGISTER_TEST(otbExhaustiveExponentialOptimizerTest); } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMMarginSampler.cxx000066400000000000000000000024271301006202600262560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "itkListSample.h" #include "otbSVMMarginSampler.h" #include "otbSVMModel.h" int otbSVMMarginSamplerNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef itk::VariableLengthVector SampleType; typedef itk::Statistics::ListSample SampleListType; typedef otb::SVMModel SVMModelType; typedef otb::SVMMarginSampler MarginSamplerType; MarginSamplerType::Pointer marginSampler = MarginSamplerType::New(); std::cout << marginSampler << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMModelAccessor.cxx000066400000000000000000000065511301006202600262420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include #include "otbSVMModel.h" int otbSVMModelAccessor(int itkNotUsed(argc), char* argv[]) { typedef unsigned char InputPixelType; typedef unsigned char LabelPixelType; typedef otb::SVMModel ModelType; ModelType::Pointer ptrModel = ModelType::New(); ptrModel->LoadModel(argv[1]); std::ofstream f; unsigned int nbClass = ptrModel->GetNumberOfClasses(); unsigned int nbSupportVector = ptrModel->GetNumberOfSupportVectors(); f.open(argv[2]); f << "Test methods of SVMModel class:" << std::endl; f << " - GetNumberOfClasses() " << nbClass << std::endl; f << " - GetNumberOfHyperplane() " << ptrModel->GetNumberOfHyperplane() << std::endl; f << " - GetNumberOfSupportVectors() " << nbSupportVector << std::endl; f << " - GetSupportVectors() [nb support vector][]" << std::endl; svm_node ** SVs = ptrModel->GetSupportVectors(); if (SVs == ITK_NULLPTR) { itkGenericExceptionMacro(<< "SVs NULL"); } for (unsigned int i = 0; i < nbSupportVector; ++i) { if (SVs[i] == ITK_NULLPTR) itkGenericExceptionMacro(<< "SVs " << i << " NULL"); f << std::endl; f << " SV[" << i << "]:"; const svm_node *p = SVs[i]; while (p->index != -1) { f << " [" << p->index << ";" << p->value << "] "; p++; } f << std::endl; } f << " - GetRho() [nr_class*(nr_class-1)/2]" << std::endl; unsigned int taille = nbClass * (nbClass - 1) / 2; double * rhos = ptrModel->GetRho(); if (rhos == ITK_NULLPTR) { itkGenericExceptionMacro(<< "rhos NULL"); } f << " "; for (unsigned int i = 0; i < taille; ++i) { f << " " << rhos[i]; } f << std::endl; f << " - GetAlpha() [nb class-1][nb support vector]" << std::endl; double ** alphas = ptrModel->GetAlpha(); if (alphas == ITK_NULLPTR) { itkGenericExceptionMacro(<< "alphas NULL"); } for (unsigned int i = 0; i < nbClass - 1; ++i) { if (alphas[i] == ITK_NULLPTR) itkGenericExceptionMacro(<< "alphas " << i << " NULL"); f << " "; for (unsigned int j = 0; j < nbSupportVector; ++j) { f << " " << alphas[i][j]; } } f << std::endl; // f << " - Evaluate() (double) -> "<Evaluate()<EvaluateHyperplaneDistance(); // f << " - EvaluateHyperplaneDistance() VariableLengthVector() nb value(s): "<<_evaluateHyperplaneDistance.Size()< #include "otbSVMModel.h" int otbSVMModelCopyTest(int itkNotUsed(argc), char* argv[]) { typedef unsigned char InputPixelType; typedef unsigned char LabelPixelType; typedef otb::SVMModel ModelType; ModelType::Pointer svmModel = ModelType::New(); svmModel->LoadModel(argv[1]); ModelType::Pointer svmModelCopy = svmModel->GetCopy(); svmModelCopy->SaveModel(argv[2]); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMModelLoad.cxx000066400000000000000000000017171301006202600253560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbSVMModel.h" int otbSVMModelLoad(int itkNotUsed(argc), char* argv[]) { typedef unsigned char InputPixelType; typedef unsigned char LabelPixelType; typedef otb::SVMModel ModelType; ModelType::Pointer svmModel = ModelType::New(); svmModel->LoadModel(argv[1]); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMModelLoadSave.cxx000066400000000000000000000017641301006202600261770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbSVMModel.h" int otbSVMModelLoadSave(int itkNotUsed(argc), char* argv[]) { typedef unsigned char InputPixelType; typedef unsigned char LabelPixelType; typedef otb::SVMModel ModelType; ModelType::Pointer svmModel = ModelType::New(); svmModel->LoadModel(argv[1]); svmModel->SaveModel(argv[2]); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMModelNew.cxx000066400000000000000000000017431301006202600252270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include #include "otbSVMModel.h" int otbSVMModelNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef unsigned char LabelPixelType; typedef otb::SVMModel ModelType; ModelType::Pointer svmModel = ModelType::New(); std::cout << svmModel << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMPointSetModelEstimatorNew.cxx000066400000000000000000000023671301006202600306100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include #include "otbSVMPointSetModelEstimator.h" int otbSVMPointSetModelEstimatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef std::vector InputPixelType; typedef double LabelPixelType; const unsigned int Dimension = 2; typedef itk::PointSet MeasurePointSetType; typedef itk::PointSet LabelPointSetType; typedef otb::SVMPointSetModelEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); std::cout << estimator << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMPointSetModelEstimatorTrain.cxx000066400000000000000000000051531301006202600311300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include #include "otbSVMPointSetModelEstimator.h" int otbSVMPointSetModelEstimatorTrain(int itkNotUsed(argc), char* argv[]) { const char* outputModelFileName = argv[1]; typedef std::vector InputPixelType; typedef double LabelPixelType; const unsigned int Dimension = 2; typedef itk::PointSet MeasurePointSetType; typedef itk::PointSet LabelPointSetType; typedef MeasurePointSetType::PointType MeasurePointType; typedef LabelPointSetType::PointType LabelPointType; typedef MeasurePointSetType::PointsContainer MeasurePointsContainer; typedef LabelPointSetType::PointsContainer LabelPointsContainer; MeasurePointSetType::Pointer mPSet = MeasurePointSetType::New(); LabelPointSetType::Pointer lPSet = LabelPointSetType::New(); MeasurePointsContainer::Pointer mCont = MeasurePointsContainer::New(); LabelPointsContainer::Pointer lCont = LabelPointsContainer::New(); for (unsigned int pointId = 0; pointId < 20; pointId++) { MeasurePointType mP; LabelPointType lP; mP[0] = pointId; mP[1] = pointId; lP[0] = pointId; lP[1] = pointId; InputPixelType measure; measure.push_back(double(2.0 * pointId)); measure.push_back(double(-10)); LabelPixelType label = static_cast((measure[0] + measure[1]) > 0); //2x-10>0 mCont->InsertElement(pointId, mP); mPSet->SetPointData(pointId, measure); lCont->InsertElement(pointId, lP); lPSet->SetPointData(pointId, label); } mPSet->SetPoints(mCont); lPSet->SetPoints(lCont); typedef otb::SVMPointSetModelEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); estimator->SetInputPointSet(mPSet); estimator->SetTrainingPointSet(lPSet); estimator->ParametersOptimizationOff(); estimator->Update(); estimator->GetModel()->SaveModel(outputModelFileName); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/SVMLearning/test/otbSVMSampleListModelEstimatorTest.cxx000066400000000000000000000072311301006202600313010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbSVMSampleListModelEstimator.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbListSampleGenerator.h" int otbSVMSampleListModelEstimatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double InputPixelType; typedef double LabelPixelType; typedef itk::VariableLengthVector SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::FixedArray TrainingSampleType; typedef itk::Statistics::ListSample TrainingListSampleType; typedef otb::SVMSampleListModelEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); std::cout << estimator << std::endl; return EXIT_SUCCESS; } int otbSVMSampleListModelEstimatorTest(int argc, char* argv[]) { if (argc != 4) { std::cerr << "Usage: " << argv[0] << " inputImage inputVectorData outputModelFileName" << std::endl; return EXIT_FAILURE; } std::string imageFilename = argv[1]; std::string vectorDataFilename = argv[2]; std::string outputModelFileName= argv[3]; int maxTrainingSize = 500; int maxValidationSize = 500; double validationTrainingProportion = 0.5; std::string classKey = "Class"; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFilename); reader->UpdateOutputInformation(); typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileReader VectorDataReaderType; VectorDataReaderType::Pointer vectorReader = VectorDataReaderType::New(); vectorReader->SetFileName(vectorDataFilename); typedef otb::ListSampleGenerator ListSampleGeneratorType; ListSampleGeneratorType::Pointer generator = ListSampleGeneratorType::New(); generator->SetMaxTrainingSize(maxTrainingSize); generator->SetMaxValidationSize(maxValidationSize); generator->SetValidationTrainingProportion(validationTrainingProportion); generator->SetInput(reader->GetOutput()); generator->SetInputVectorData(vectorReader->GetOutput()); typedef ListSampleGeneratorType::ListSampleType ListSampleType; typedef ListSampleGeneratorType::ListLabelType TrainingListSampleType; typedef otb::SVMSampleListModelEstimator EstimatorType; EstimatorType::Pointer estimator = EstimatorType::New(); estimator->SetInputSampleList(generator->GetTrainingListSample()); estimator->SetTrainingSampleList(generator->GetTrainingListLabel()); estimator->Update(); estimator->GetModel()->SaveModel(outputModelFileName); // Print the ListSample generator std::cout << generator << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Sampling/000077500000000000000000000000001301006202600203375ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Sampling/CMakeLists.txt000066400000000000000000000001201301006202600230700ustar00rootroot00000000000000project(OTBSampling) set(OTBSampling_LIBRARIES OTBSampling) otb_module_impl() OTB-release-5.8/Modules/Learning/Sampling/include/000077500000000000000000000000001301006202600217625ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Sampling/include/otbImageSampleExtractorFilter.h000066400000000000000000000141001301006202600300620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSampleExtractorFilter_h #define otbImageSampleExtractorFilter_h #include "otbPersistentSamplingFilterBase.h" #include "otbPersistentFilterStreamingDecorator.h" #include "otbOGRDataSourceWrapper.h" #include "otbImage.h" namespace otb { /** * \class PersistentImageSampleExtractorFilter * * \brief Persistent filter to extract sample values from an image * * \ingroup OTBSampling */ template class ITK_EXPORT PersistentImageSampleExtractorFilter : public PersistentSamplingFilterBase { public: /** Standard Self typedef */ typedef PersistentImageSampleExtractorFilter Self; typedef PersistentSamplingFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::PointType PointType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType InternalPixelType; typedef ogr::DataSource OGRDataType; typedef ogr::DataSource::Pointer OGRDataPointer; typedef itk::DataObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentImageSampleExtractorFilter, PersistentSamplingFilterBase); /** Set the output samples OGR container * (shall be equal to the input container for an 'update' mode) */ void SetOutputSamples(ogr::DataSource* data); /** Get the output samples OGR container */ ogr::DataSource* GetOutputSamples(); void Synthetize(void) ITK_OVERRIDE{} /** Reset method called before starting the streaming*/ void Reset(void) ITK_OVERRIDE; itkSetMacro(SampleFieldPrefix, std::string); itkGetMacro(SampleFieldPrefix, std::string); /** Directly set the output field names (the prefix won't be used) */ void SetSampleFieldNames(std::vector &names); /** Get the sample names */ const std::vector & GetSampleFieldNames(); protected: /** Constructor */ PersistentImageSampleExtractorFilter(); /** Destructor */ ~PersistentImageSampleExtractorFilter() ITK_OVERRIDE {} void GenerateOutputInformation() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; /** process only points */ void ThreadedGenerateVectorData(const ogr::Layer& layerForThread, itk::ThreadIdType threadid) ITK_OVERRIDE; private: PersistentImageSampleExtractorFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Initialize fields to store extracted values (Real type) */ void InitializeFields(); /** Prefix to generate field names for each input channel * (ignored if the field names are given directly) */ std::string m_SampleFieldPrefix; /** List of field names for each component */ std::vector m_SampleFieldNames; }; /** * \class ImageSampleExtractorFilter * * \brief Extract sample values from an image into an OGRDataSource using a persistent filter * * \sa PersistentImageSampleExtractorFilter * * \ingroup OTBSampling */ template class ITK_EXPORT ImageSampleExtractorFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef ImageSampleExtractorFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef otb::ogr::DataSource OGRDataType; typedef typename Superclass::FilterType FilterType; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageSampleExtractorFilter, PersistentFilterStreamingDecorator); using Superclass::SetInput; virtual void SetInput(const TInputImage* image); const TInputImage* GetInput(); void SetSamplePositions(const otb::ogr::DataSource* data); const otb::ogr::DataSource* GetSamplePositions(); void SetOutputSamples(OGRDataType::Pointer data); const otb::ogr::DataSource* GetOutputSamples(); void SetOutputFieldPrefix(const std::string &key); std::string GetOutputFieldPrefix(); /** Set the output field names */ void SetOutputFieldNames(std::vector &names); /** Get the output field names */ const std::vector & GetOutputFieldNames(); void SetLayerIndex(int index); int GetLayerIndex(); void SetClassFieldName(const std::string &name); std::string GetClassFieldName(void); protected: /** Constructor */ ImageSampleExtractorFilter() {} /** Destructor */ ~ImageSampleExtractorFilter() ITK_OVERRIDE {} private: ImageSampleExtractorFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageSampleExtractorFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbImageSampleExtractorFilter.txx000066400000000000000000000216771301006202600304770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSampleExtractorFilter_txx #define otbImageSampleExtractorFilter_txx #include "otbImageSampleExtractorFilter.h" #include "itkDefaultConvertPixelTraits.h" #include "itkProgressReporter.h" namespace otb { // --------- otb::PersistentImageSampleExtractorFilter --------------------- template PersistentImageSampleExtractorFilter ::PersistentImageSampleExtractorFilter() : m_SampleFieldPrefix(std::string("band_")) { this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0,TInputImage::New()); } template void PersistentImageSampleExtractorFilter ::SetOutputSamples(ogr::DataSource* data) { this->SetNthOutput(1,data); } template ogr::DataSource* PersistentImageSampleExtractorFilter ::GetOutputSamples() { if (this->GetNumberOfOutputs() < 2) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void PersistentImageSampleExtractorFilter ::Reset(void) { // Check output field names TInputImage* inputImage = const_cast(this->GetInput()); inputImage->UpdateOutputInformation(); unsigned int nbBand = inputImage->GetNumberOfComponentsPerPixel(); if (m_SampleFieldNames.size()) { if ( m_SampleFieldNames.size() != nbBand) { itkExceptionMacro(<< "Wrong number of field names given, got " <GetSampleFieldPrefix() << i; m_SampleFieldNames.push_back(oss.str()); } } // initialize additional fields for output this->InitializeFields(); // initialize output DataSource ogr::DataSource* inputDS = const_cast(this->GetOGRData()); ogr::DataSource* output = this->GetOutputSamples(); this->InitializeOutputDataSource(inputDS,output); } template void PersistentImageSampleExtractorFilter ::SetSampleFieldNames(std::vector &names) { m_SampleFieldNames.clear(); for (unsigned int i=0 ; i const std::vector & PersistentImageSampleExtractorFilter ::GetSampleFieldNames() { return m_SampleFieldNames; } template void PersistentImageSampleExtractorFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // Check SRS of input image and samples std::string projectionRefWkt = this->GetInput()->GetProjectionRef(); bool projectionInformationAvailable = !projectionRefWkt.empty(); if(projectionInformationAvailable) { OGRSpatialReference imgSRS; const char *projWktCstr = projectionRefWkt.c_str(); char **projWktPointer = const_cast(&projWktCstr); OGRErr err = imgSRS.importFromWkt( projWktPointer ); if (err == OGRERR_NONE) { // get input layer ogr::Layer inLayer = this->GetOGRData()->GetLayer(this->GetLayerIndex()); if ( !imgSRS.IsSame(inLayer.GetSpatialRef()) ) { char *layerSrsWkt = NULL; inLayer.GetSpatialRef()->exportToPrettyWkt(&layerSrsWkt); itkExceptionMacro(<< "Spatial reference of input image and samples don't match: \n" << projectionRefWkt << "\nvs\n"<< layerSrsWkt); } } } } template void PersistentImageSampleExtractorFilter ::GenerateInputRequestedRegion() { InputImageType *input = const_cast(this->GetInput()); RegionType requested = this->GetOutput()->GetRequestedRegion(); input->SetRequestedRegion(requested); } template void PersistentImageSampleExtractorFilter ::ThreadedGenerateVectorData(const ogr::Layer& layerForThread, itk::ThreadIdType threadid) { // Retrieve inputs TInputImage* inputImage = const_cast(this->GetInput()); unsigned int nbBand = inputImage->GetNumberOfComponentsPerPixel(); ogr::Layer outputLayer = this->GetInMemoryOutput(threadid); itk::ProgressReporter progress( this, threadid, layerForThread.GetFeatureCount(true) ); // Loop across the features in the layer (filtered by requested region in BeforeTGD already) OGRGeometry *geom; PointType imgPoint; IndexType imgIndex; PixelType imgPixel; double imgComp; ogr::Layer::const_iterator featIt = layerForThread.begin(); for(; featIt!=layerForThread.end(); ++featIt) { geom = featIt->ogr().GetGeometryRef(); switch (geom->getGeometryType()) { case wkbPoint: case wkbPoint25D: { OGRPoint* castPoint = dynamic_cast(geom); if (castPoint == NULL) { // Wrong Type ! break; } imgPoint[0] = castPoint->getX(); imgPoint[1] = castPoint->getY(); inputImage->TransformPhysicalPointToIndex(imgPoint,imgIndex); imgPixel = inputImage->GetPixel(imgIndex); ogr::Feature dstFeature(outputLayer.GetLayerDefn()); dstFeature.SetFrom( *featIt, TRUE ); dstFeature.SetFID(featIt->GetFID()); for (unsigned int i=0 ; i(itk::DefaultConvertPixelTraits::GetNthComponent(i,imgPixel)); // Fill the output OGRDataSource dstFeature[m_SampleFieldNames[i]].SetValue(imgComp); } outputLayer.CreateFeature( dstFeature ); break; } default: { otbWarningMacro("Geometry not handled: " << geom->getGeometryName()); break; } } progress.CompletedPixel(); } } template void PersistentImageSampleExtractorFilter ::InitializeFields() { this->ClearAdditionalFields(); for (unsigned int i=0 ; iCreateAdditionalField(m_SampleFieldNames[i],OFTReal,24,15); } } // -------------- otb::ImageSampleExtractorFilter -------------------------- template void ImageSampleExtractorFilter ::SetInput(const TInputImage* image) { this->GetFilter()->SetInput(image); } template const TInputImage* ImageSampleExtractorFilter ::GetInput() { return this->GetFilter()->GetInput(); } template void ImageSampleExtractorFilter ::SetSamplePositions(const otb::ogr::DataSource* data) { this->GetFilter()->SetOGRData(data); } template const otb::ogr::DataSource* ImageSampleExtractorFilter ::GetSamplePositions() { return this->GetFilter()->GetOGRData(); } template void ImageSampleExtractorFilter ::SetOutputSamples(OGRDataType::Pointer data) { this->GetFilter()->SetOutputSamples(data); } template const otb::ogr::DataSource* ImageSampleExtractorFilter ::GetOutputSamples() { return this->GetFilter()->GetOutputSamples(); } template void ImageSampleExtractorFilter ::SetOutputFieldPrefix(const std::string &key) { this->GetFilter()->SetSampleFieldPrefix(key); } template std::string ImageSampleExtractorFilter ::GetOutputFieldPrefix() { return this->GetFilter()->GetSampleFieldPrefix(); } template void ImageSampleExtractorFilter ::SetOutputFieldNames(std::vector &names) { this->GetFilter()->SetSampleFieldNames(names); } template const std::vector & ImageSampleExtractorFilter ::GetOutputFieldNames() { return this->GetFilter()->GetSampleFieldNames(); } template void ImageSampleExtractorFilter ::SetLayerIndex(int index) { this->GetFilter()->SetLayerIndex(index); } template int ImageSampleExtractorFilter ::GetLayerIndex() { return this->GetFilter()->GetLayerIndex(); } template void ImageSampleExtractorFilter ::SetClassFieldName(const std::string &name) { this->GetFilter()->SetFieldName(name); } template std::string ImageSampleExtractorFilter ::GetClassFieldName(void) { return this->GetFilter()->GetFieldName(); } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbOGRDataToClassStatisticsFilter.h000066400000000000000000000154661301006202600306070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDataToClassStatisticsFilter_h #define otbOGRDataToClassStatisticsFilter_h #include "otbPersistentSamplingFilterBase.h" #include "otbPersistentFilterStreamingDecorator.h" #include "itkSimpleDataObjectDecorator.h" namespace otb { /** * \class PersistentOGRDataToClassStatisticsFilter * * \brief Persistent filter to compute class statistics based on vectors * * \ingroup OTBSampling */ template class ITK_EXPORT PersistentOGRDataToClassStatisticsFilter : public PersistentSamplingFilterBase { public: /** Standard Self typedef */ typedef PersistentOGRDataToClassStatisticsFilter Self; typedef PersistentSamplingFilterBase< TInputImage, TMaskImage> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::PointType PointType; /** Wrap output type as DataObject */ typedef std::map ClassCountMapType; typedef std::map PolygonSizeMapType; typedef itk::SimpleDataObjectDecorator ClassCountObjectType; typedef itk::SimpleDataObjectDecorator PolygonSizeObjectType; typedef itk::DataObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentOGRDataToClassStatisticsFilter, PersistentSamplingFilterBase); void Synthetize(void) ITK_OVERRIDE; /** Reset method called before starting the streaming*/ void Reset(void) ITK_OVERRIDE; /** the class count map is stored as output #2 */ const ClassCountObjectType* GetClassCountOutput() const; ClassCountObjectType* GetClassCountOutput(); /** the polygon size map is stored as output #3 */ const PolygonSizeObjectType* GetPolygonSizeOutput() const; PolygonSizeObjectType* GetPolygonSizeOutput(); /** Make a DataObject of the correct type to be used as the specified * output. */ itk::DataObject::Pointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; protected: /** Constructor */ PersistentOGRDataToClassStatisticsFilter(); /** Destructor */ ~PersistentOGRDataToClassStatisticsFilter() ITK_OVERRIDE {} /** Implement generic method called at each candidate position */ void ProcessSample(const ogr::Feature& feature, typename TInputImage::IndexType& imgIndex, typename TInputImage::PointType& imgPoint, itk::ThreadIdType& threadid) ITK_OVERRIDE; /** Prepare temporary variables for the current feature */ void PrepareFeature(const ogr::Feature& feature, itk::ThreadIdType& threadid) ITK_OVERRIDE; private: PersistentOGRDataToClassStatisticsFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Number of pixels in all the polygons (per thread) */ std::vector m_NbPixelsThread; /** Number of pixels in each classes (per thread) */ std::vector m_ElmtsInClassThread; /** Number of pixels in each polygons (per thread) */ std::vector m_PolygonThread; /** Class name of the current feature (per thread) */ std::vector m_CurrentClass; /** FID of the current feature (per thread) */ std::vector m_CurrentFID; }; /** * \class OGRDataToClassStatisticsFilter * * \brief Computes class statistics based on vectors using a persistent filter * * \sa PersistentOGRDataToClassStatisticsFilter * * \ingroup OTBSampling */ template class ITK_EXPORT OGRDataToClassStatisticsFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef OGRDataToClassStatisticsFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef TMaskImage MaskImageType; typedef otb::ogr::DataSource OGRDataType; typedef typename Superclass::FilterType FilterType; typedef typename FilterType::ClassCountMapType ClassCountMapType; typedef typename FilterType::PolygonSizeMapType PolygonSizeMapType; typedef typename FilterType::ClassCountObjectType ClassCountObjectType; typedef typename FilterType::PolygonSizeObjectType PolygonSizeObjectType; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(OGRDataToClassStatisticsFilter, PersistentFilterStreamingDecorator); using Superclass::SetInput; virtual void SetInput(const TInputImage* image); const TInputImage* GetInput(); void SetOGRData(const otb::ogr::DataSource* data); const otb::ogr::DataSource* GetOGRData(); void SetMask(const TMaskImage* mask); const TMaskImage* GetMask(); void SetFieldName(std::string &key); std::string GetFieldName(); void SetLayerIndex(int index); int GetLayerIndex(); const ClassCountObjectType* GetClassCountOutput() const; ClassCountObjectType* GetClassCountOutput(); const PolygonSizeObjectType* GetPolygonSizeOutput() const; PolygonSizeObjectType* GetPolygonSizeOutput(); protected: /** Constructor */ OGRDataToClassStatisticsFilter() {} /** Destructor */ ~OGRDataToClassStatisticsFilter() ITK_OVERRIDE {} private: OGRDataToClassStatisticsFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOGRDataToClassStatisticsFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbOGRDataToClassStatisticsFilter.txx000066400000000000000000000224721301006202600311760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDataToClassStatisticsFilter_txx #define otbOGRDataToClassStatisticsFilter_txx #include "otbOGRDataToClassStatisticsFilter.h" namespace otb { // --------- otb::PersistentOGRDataToClassStatisticsFilter --------------------- template PersistentOGRDataToClassStatisticsFilter ::PersistentOGRDataToClassStatisticsFilter() { this->SetNumberOfRequiredOutputs(3); this->SetNthOutput(0,TInputImage::New()); this->SetNthOutput(1,ClassCountObjectType::New()); this->SetNthOutput(2,PolygonSizeObjectType::New()); } template void PersistentOGRDataToClassStatisticsFilter ::Synthetize(void) { otb::ogr::DataSource* vectors = const_cast(this->GetOGRData()); vectors->GetLayer(this->GetLayerIndex()).SetSpatialFilter(ITK_NULLPTR); ClassCountMapType &classCount = this->GetClassCountOutput()->Get(); PolygonSizeMapType &polygonSize = this->GetPolygonSizeOutput()->Get(); // Reset outputs classCount.clear(); polygonSize.clear(); // Copy temporary stats to outputs for (unsigned int k=0 ; k < this->GetNumberOfThreads() ; k++) { ClassCountMapType::iterator itClass = m_ElmtsInClassThread[k].begin(); for (; itClass != m_ElmtsInClassThread[k].end() ; ++itClass) { if (classCount.count(itClass->first)) { classCount[itClass->first] += itClass->second; } else { classCount[itClass->first] = itClass->second; } } PolygonSizeMapType::iterator itPoly = m_PolygonThread[k].begin(); for (; itPoly != m_PolygonThread[k].end() ; ++itPoly) { if (polygonSize.count(itPoly->first)) { polygonSize[itPoly->first] += itPoly->second; } else { polygonSize[itPoly->first] = itPoly->second; } } } m_ElmtsInClassThread.clear(); m_PolygonThread.clear(); m_NbPixelsThread.clear(); } template void PersistentOGRDataToClassStatisticsFilter ::Reset(void) { m_ElmtsInClassThread.clear(); m_PolygonThread.clear(); m_NbPixelsThread.clear(); m_ElmtsInClassThread.resize(this->GetNumberOfThreads()); m_PolygonThread.resize(this->GetNumberOfThreads()); m_NbPixelsThread.resize(this->GetNumberOfThreads()); m_CurrentClass.resize(this->GetNumberOfThreads()); m_CurrentFID.resize(this->GetNumberOfThreads()); } template const typename PersistentOGRDataToClassStatisticsFilter::ClassCountObjectType* PersistentOGRDataToClassStatisticsFilter ::GetClassCountOutput() const { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename PersistentOGRDataToClassStatisticsFilter::ClassCountObjectType* PersistentOGRDataToClassStatisticsFilter ::GetClassCountOutput() { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename PersistentOGRDataToClassStatisticsFilter::PolygonSizeObjectType* PersistentOGRDataToClassStatisticsFilter ::GetPolygonSizeOutput() const { if (this->GetNumberOfOutputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template typename PersistentOGRDataToClassStatisticsFilter::PolygonSizeObjectType* PersistentOGRDataToClassStatisticsFilter ::GetPolygonSizeOutput() { if (this->GetNumberOfOutputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template itk::DataObject::Pointer PersistentOGRDataToClassStatisticsFilter ::MakeOutput(DataObjectPointerArraySizeType idx) { switch (idx) { case 0: return static_cast(TInputImage::New().GetPointer()); break; case 1: return static_cast(ClassCountObjectType::New().GetPointer()); break; case 2: return static_cast(PolygonSizeObjectType::New().GetPointer()); break; default: // might as well make an image return static_cast(TInputImage::New().GetPointer()); break; } } template void PersistentOGRDataToClassStatisticsFilter ::ProcessSample( const ogr::Feature&, typename TInputImage::IndexType&, typename TInputImage::PointType&, itk::ThreadIdType& threadid) { std::string& className = m_CurrentClass[threadid]; unsigned long& fId = m_CurrentFID[threadid]; m_ElmtsInClassThread[threadid][className]++; m_PolygonThread[threadid][fId]++; m_NbPixelsThread[threadid]++; } template void PersistentOGRDataToClassStatisticsFilter ::PrepareFeature(const ogr::Feature& feature, itk::ThreadIdType& threadid) { std::string className(feature.ogr().GetFieldAsString(this->GetFieldIndex())); unsigned long fId = feature.ogr().GetFID(); if (!m_ElmtsInClassThread[threadid].count(className)) { m_ElmtsInClassThread[threadid][className] = 0; } if (!m_PolygonThread[threadid].count(fId)) { m_PolygonThread[threadid][fId] = 0; } m_CurrentClass[threadid] = className; m_CurrentFID[threadid] = fId; } // -------------- otb::OGRDataToClassStatisticsFilter -------------------------- template void OGRDataToClassStatisticsFilter ::SetInput(const TInputImage* image) { this->GetFilter()->SetInput(image); } template const TInputImage* OGRDataToClassStatisticsFilter ::GetInput() { return this->GetFilter()->GetInput(); } template void OGRDataToClassStatisticsFilter ::SetOGRData(const otb::ogr::DataSource* data) { this->GetFilter()->SetOGRData(data); } template const otb::ogr::DataSource* OGRDataToClassStatisticsFilter ::GetOGRData() { return this->GetFilter()->GetOGRData(); } template void OGRDataToClassStatisticsFilter ::SetMask(const TMaskImage* mask) { this->GetFilter()->SetMask(mask); } template const TMaskImage* OGRDataToClassStatisticsFilter ::GetMask() { return this->GetFilter()->GetMask(); } template void OGRDataToClassStatisticsFilter ::SetFieldName(std::string &key) { this->GetFilter()->SetFieldName(key); } template std::string OGRDataToClassStatisticsFilter ::GetFieldName() { return this->GetFilter()->GetFieldName(); } template void OGRDataToClassStatisticsFilter ::SetLayerIndex(int index) { this->GetFilter()->SetLayerIndex(index); } template int OGRDataToClassStatisticsFilter ::GetLayerIndex() { return this->GetFilter()->GetLayerIndex(); } template const typename OGRDataToClassStatisticsFilter::ClassCountObjectType* OGRDataToClassStatisticsFilter ::GetClassCountOutput() const { return this->GetFilter()->GetClassCountOutput(); } template typename OGRDataToClassStatisticsFilter::ClassCountObjectType* OGRDataToClassStatisticsFilter ::GetClassCountOutput() { return this->GetFilter()->GetClassCountOutput(); } template const typename OGRDataToClassStatisticsFilter::PolygonSizeObjectType* OGRDataToClassStatisticsFilter ::GetPolygonSizeOutput() const { return this->GetFilter()->GetPolygonSizeOutput(); } template typename OGRDataToClassStatisticsFilter::PolygonSizeObjectType* OGRDataToClassStatisticsFilter ::GetPolygonSizeOutput() { return this->GetFilter()->GetPolygonSizeOutput(); } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbOGRDataToSamplePositionFilter.h000066400000000000000000000223771301006202600304340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDataToSamplePositionFilter_h #define otbOGRDataToSamplePositionFilter_h #include "otbPersistentSamplingFilterBase.h" #include "otbPersistentFilterStreamingDecorator.h" #include "otbSamplingRateCalculator.h" #include "otbPeriodicSampler.h" #include "otbImage.h" namespace otb { /** * \class PersistentOGRDataToSamplePositionFilter * * \brief Persistent filter to extract sample position from an image * * This filter uses an input image (to define the sampling grid), an optional * input mask, and a set of input vectors that define the sampling regions for * each class. * * The filter has a set of samplers (one for each class), they define what * sampling rate and strategy should be performed. * * Several levels of output are supported. For instance, with two outputs : * when the sampler from level 1 discards a sample, the sampler from level 2 is * called. * * \ingroup OTBSampling */ template class ITK_EXPORT PersistentOGRDataToSamplePositionFilter : public PersistentSamplingFilterBase { public: /** Standard Self typedef */ typedef PersistentOGRDataToSamplePositionFilter Self; typedef PersistentSamplingFilterBase< TInputImage, TMaskImage> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::PointType PointType; typedef TMaskImage MaskImageType; typedef typename MaskImageType::Pointer MaskImagePointer; typedef ogr::DataSource OGRDataType; typedef ogr::DataSource::Pointer OGRDataPointer; typedef TSampler SamplerType; typedef typename SamplerType::Pointer SamplerPointerType; typedef typename SamplerType::ParameterType SamplerParameterType; typedef typename std::map SamplerMapType; typedef std::map ClassPartitionType; typedef itk::DataObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentOGRDataToSamplePositionFilter, PersistentSamplingFilterBase); void Synthetize(void) ITK_OVERRIDE{} /** Reset method called before starting the streaming*/ void Reset(void) ITK_OVERRIDE; /** Get a reference to the internal samplers at a given level */ SamplerMapType& GetSamplers(unsigned int level); /** Set an output container for sample position associated * with corresponding rates, for a given level.*/ void SetOutputPositionContainerAndRates( otb::ogr::DataSource* data, const SamplingRateCalculator::MapRateType& map, unsigned int level); /** Get the output position container of a given level */ const otb::ogr::DataSource* GetOutputPositionContainer(unsigned int level) const; otb::ogr::DataSource* GetOutputPositionContainer(unsigned int level); /** Get the number of sampling levels used in this filter.*/ unsigned int GetNumberOfLevels(); /** Clear all output position containers */ void ClearOutputs(); /** Make a DataObject of the correct type to be used as the specified * output. */ itk::DataObject::Pointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; /** Get/Set of the field name storing the original FID of each sample */ itkSetMacro(OriginFieldName, std::string); itkGetMacro(OriginFieldName, std::string); protected: /** Constructor */ PersistentOGRDataToSamplePositionFilter(); /** Destructor */ ~PersistentOGRDataToSamplePositionFilter() ITK_OVERRIDE {} /** Call samplers on a current position, for a given class */ void ProcessSample(const ogr::Feature& feature, typename TInputImage::IndexType& imgIndex, typename TInputImage::PointType& imgPoint, itk::ThreadIdType& threadid) ITK_OVERRIDE; /** Method to split the input OGRDataSource * according to the class partition */ void DispatchInputVectors(void) ITK_OVERRIDE; private: PersistentOGRDataToSamplePositionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void ComputeClassPartition(void); /** (internal) map associating a class name with a thread number */ ClassPartitionType m_ClassPartition; /** Internal samplers*/ std::vector m_Samplers; /** Field name to store the FID of the geometry each sample comes from */ std::string m_OriginFieldName; }; /** * \class OGRDataToSamplePositionFilter * * \brief Extracts sample position from an image using a persistent filter * * \sa PersistentOGRDataToSamplePositionFilter * * \ingroup OTBSampling */ template , class TSampler = otb::PeriodicSampler > class ITK_EXPORT OGRDataToSamplePositionFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef OGRDataToSamplePositionFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef TMaskImage MaskImageType; typedef otb::ogr::DataSource OGRDataType; typedef typename Superclass::FilterType FilterType; typedef TSampler SamplerType; typedef typename SamplerType::Pointer SamplerPointerType; typedef typename SamplerType::ParameterType SamplerParameterType; typedef typename std::map SamplerMapType; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(OGRDataToSamplePositionFilter, PersistentFilterStreamingDecorator); using Superclass::SetInput; /** Set the input image */ virtual void SetInput(const TInputImage* image); /** Get the input image*/ const TInputImage* GetInput(); /** Set the input OGRDataSource containing sampling areas */ void SetOGRData(const otb::ogr::DataSource* data); /** Get the input OGRDataSource containing sampling areas */ const otb::ogr::DataSource* GetOGRData(); /** Set the input mask (optional) */ void SetMask(const TMaskImage* mask); /** Get input mask (may be null)*/ const TMaskImage* GetMask(); /** Set the field name containing class names*/ void SetFieldName(std::string key); /** Get the field name containing class names*/ std::string GetFieldName(); /** Set the layer index containing sampling areas*/ void SetLayerIndex(int index); /** Get the layer index containing sampling areas*/ int GetLayerIndex(); /** Set the sampling parameters for all classes at a given level.*/ void SetSamplerParameters(SamplerParameterType param, unsigned int level=0); /** Get a reference to the internal sampler map at a given level.*/ SamplerMapType& GetSamplers(unsigned int level=0); /** Set the output container with the associated rates at a given level.*/ void SetOutputPositionContainerAndRates( otb::ogr::DataSource* data, const SamplingRateCalculator::MapRateType& map, unsigned int level=0); /** Get the output position container at a given level.*/ otb::ogr::DataSource* GetOutputPositionContainer(unsigned int level=0); /** Set the field name storing the original FID of each sample*/ void SetOriginFieldName(std::string key); /** Get the field name storing the original FID of each sample*/ std::string GetOriginFieldName(); protected: /** Constructor */ OGRDataToSamplePositionFilter() {} /** Destructor */ ~OGRDataToSamplePositionFilter() ITK_OVERRIDE {} private: OGRDataToSamplePositionFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOGRDataToSamplePositionFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbOGRDataToSamplePositionFilter.txx000066400000000000000000000321611301006202600310200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDataToSamplePositionFilter_txx #define otbOGRDataToSamplePositionFilter_txx #include "otbOGRDataToSamplePositionFilter.h" #include "itkTimeProbe.h" namespace otb { // --------- otb::PersistentOGRDataToSamplePositionFilter --------------------- template PersistentOGRDataToSamplePositionFilter ::PersistentOGRDataToSamplePositionFilter() { this->SetNumberOfRequiredOutputs(2); m_OriginFieldName = std::string("originfid"); } template void PersistentOGRDataToSamplePositionFilter ::Reset(void) { // Reset samplers for (unsigned int i=0 ; i < m_Samplers.size() ; ++i) { for (typename SamplerMapType::iterator iter = m_Samplers[i].begin(); iter != m_Samplers[i].end(); ++iter) { iter->second->Reset(); } } // Add an extra field for the original FID this->ClearAdditionalFields(); this->CreateAdditionalField(this->GetOriginFieldName(),OFTInteger,12); // compute label mapping this->ComputeClassPartition(); // Prepare outputs ogr::DataSource* inputDS = const_cast(this->GetOGRData()); for (unsigned int k=0 ; k < this->GetNumberOfLevels() ; k++) { otb::ogr::DataSource* output = this->GetOutputPositionContainer(k); if (output) { this->InitializeOutputDataSource(inputDS, output); } } } template typename PersistentOGRDataToSamplePositionFilter::SamplerMapType& PersistentOGRDataToSamplePositionFilter ::GetSamplers(unsigned int level) { if (m_Samplers.size() < (level + 1)) { itkExceptionMacro("The sampler level "<< level << " doesn't exist !"); } return m_Samplers[level]; } template void PersistentOGRDataToSamplePositionFilter ::SetOutputPositionContainerAndRates( otb::ogr::DataSource* data, const SamplingRateCalculator::MapRateType& map, unsigned int level) { // set the output dataset this->SetNthOutput(1+level,data); // instantiate the corresponding samplers if (m_Samplers.size() < (level + 1)) { m_Samplers.resize(level + 1); } m_Samplers[level].clear(); for (SamplingRateCalculator::MapRateType::const_iterator it = map.begin() ; it != map.end(); ++it) { SamplerPointerType sampler = SamplerType::New(); sampler->SetNumberOfElements(it->second.Required,it->second.Tot); m_Samplers[level][it->first] = sampler; } } template otb::ogr::DataSource* PersistentOGRDataToSamplePositionFilter ::GetOutputPositionContainer(unsigned int level) { if (this->GetNumberOfOutputs() < (level + 2)) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(level + 1)); } template unsigned int PersistentOGRDataToSamplePositionFilter ::GetNumberOfLevels() { return (this->GetNumberOfOutputs() - 1); } template void PersistentOGRDataToSamplePositionFilter ::ClearOutputs() { // remove output position containers for (unsigned int i = (this->GetNumberOfOutputs() - 1) ; i > 0 ; --i) { this->itk::ProcessObject::RemoveOutput(i); } // remove samplers m_Samplers.clear(); } template itk::DataObject::Pointer PersistentOGRDataToSamplePositionFilter ::MakeOutput(DataObjectPointerArraySizeType idx) { if (idx == 0) { // the output image return static_cast(TInputImage::New().GetPointer()); } else if (idx > 0) { // sample position containers return static_cast(otb::ogr::DataSource::New().GetPointer()); } // might as well make an image return static_cast(TInputImage::New().GetPointer()); } template void PersistentOGRDataToSamplePositionFilter ::ProcessSample(const ogr::Feature& feature, typename TInputImage::IndexType&, typename TInputImage::PointType& imgPoint, itk::ThreadIdType& threadid) { std::string className(feature.ogr().GetFieldAsString(this->GetFieldIndex())); for (unsigned int i=0 ; iGetNumberOfLevels() ; ++i) { if (m_Samplers[i][className]->TakeSample()) { OGRPoint ogrTmpPoint; ogrTmpPoint.setX(imgPoint[0]); ogrTmpPoint.setY(imgPoint[1]); ogr::Layer outputLayer = this->GetInMemoryOutput(threadid,i); ogr::Feature feat(outputLayer.GetLayerDefn()); feat.SetFrom(feature); feat[this->GetOriginFieldName()].SetValue(static_cast(feature.GetFID())); feat.SetGeometry(&ogrTmpPoint); outputLayer.CreateFeature(feat); break; } } } template void PersistentOGRDataToSamplePositionFilter ::DispatchInputVectors() { TInputImage* outputImage = this->GetOutput(); ogr::DataSource* vectors = const_cast(this->GetOGRData()); ogr::Layer inLayer = vectors->GetLayer(this->GetLayerIndex()); const RegionType& requestedRegion = outputImage->GetRequestedRegion(); itk::ContinuousIndex startIndex(requestedRegion.GetIndex()); itk::ContinuousIndex endIndex(requestedRegion.GetUpperIndex()); startIndex[0] += -0.5; startIndex[1] += -0.5; endIndex[0] += 0.5; endIndex[1] += 0.5; itk::Point startPoint; itk::Point endPoint; outputImage->TransformContinuousIndexToPhysicalPoint(startIndex, startPoint); outputImage->TransformContinuousIndexToPhysicalPoint(endIndex, endPoint); // create geometric extent OGRPolygon tmpPolygon; OGRLinearRing ring; ring.addPoint(startPoint[0],startPoint[1],0.0); ring.addPoint(startPoint[0],endPoint[1] ,0.0); ring.addPoint(endPoint[0] ,endPoint[1] ,0.0); ring.addPoint(endPoint[0] ,startPoint[1],0.0); ring.addPoint(startPoint[0],startPoint[1],0.0); tmpPolygon.addRing(&ring); inLayer.SetSpatialFilter(&tmpPolygon); unsigned int numberOfThreads = this->GetNumberOfThreads(); std::vector tmpLayers; for (unsigned int i=0 ; iGetInMemoryInput(i)); } OGRFeatureDefn &layerDefn = inLayer.GetLayerDefn(); ogr::Layer::const_iterator featIt = inLayer.begin(); std::string className; for(; featIt!=inLayer.end(); ++featIt) { ogr::Feature dstFeature(layerDefn); dstFeature.SetFrom( *featIt, TRUE ); dstFeature.SetFID(featIt->GetFID()); className = featIt->ogr().GetFieldAsString(this->GetFieldIndex()); tmpLayers[m_ClassPartition[className]].CreateFeature( dstFeature ); } inLayer.SetSpatialFilter(ITK_NULLPTR); } template void PersistentOGRDataToSamplePositionFilter ::ComputeClassPartition(void) { m_ClassPartition.clear(); typedef std::map ClassCountMapType; ClassCountMapType classCounts; for (typename SamplerMapType::const_iterator it = m_Samplers[0].begin() ; it != m_Samplers[0].end(); ++it) { classCounts[it->first] = it->second->GetTotalElements(); } int numberOfThreads = this->GetNumberOfThreads(); typedef std::vector LoadVectorType; LoadVectorType currentLoad; currentLoad.resize(numberOfThreads, 0UL); ClassCountMapType::iterator largestClass; unsigned long minLoad; unsigned int destThread; while (classCounts.size()) { // find class with highest number of total elements largestClass = classCounts.begin(); for (ClassCountMapType::iterator iter = classCounts.begin() ; iter != classCounts.end() ; ++iter) { if (iter->second > largestClass->second) { largestClass = iter; } } // affect this class to the thread with lowest load minLoad = currentLoad[0]; destThread = 0; for (unsigned int k = 0 ; k < currentLoad.size() ; ++k) { if (currentLoad[k] < minLoad) { minLoad = currentLoad[k]; destThread = k; } } m_ClassPartition[largestClass->first] = destThread; currentLoad[destThread] += largestClass->second; // remove class from classCounts classCounts.erase(largestClass); } } // -------------- otb::OGRDataToSamplePositionFilter -------------------------- template void OGRDataToSamplePositionFilter ::SetInput(const TInputImage* image) { this->GetFilter()->SetInput(image); } template const TInputImage* OGRDataToSamplePositionFilter ::GetInput() { return this->GetFilter()->GetInput(); } template void OGRDataToSamplePositionFilter ::SetOGRData(const otb::ogr::DataSource* data) { this->GetFilter()->SetOGRData(data); } template const otb::ogr::DataSource* OGRDataToSamplePositionFilter ::GetOGRData() { return this->GetFilter()->GetOGRData(); } template void OGRDataToSamplePositionFilter ::SetMask(const TMaskImage* mask) { this->GetFilter()->SetMask(mask); } template const TMaskImage* OGRDataToSamplePositionFilter ::GetMask() { return this->GetFilter()->GetMask(); } template void OGRDataToSamplePositionFilter ::SetFieldName(std::string key) { this->GetFilter()->SetFieldName(key); } template std::string OGRDataToSamplePositionFilter ::GetFieldName() { return this->GetFilter()->GetFieldName(); } template void OGRDataToSamplePositionFilter ::SetLayerIndex(int index) { this->GetFilter()->SetLayerIndex(index); } template int OGRDataToSamplePositionFilter ::GetLayerIndex() { return this->GetFilter()->GetLayerIndex(); } template void OGRDataToSamplePositionFilter ::SetSamplerParameters(SamplerParameterType param, unsigned int level) { SamplerMapType &samplers = this->GetSamplers(level); for (typename SamplerMapType::iterator it = samplers.begin() ; it != samplers.end() ; ++it) { it->second->SetParameters(param); } } template typename OGRDataToSamplePositionFilter::SamplerMapType& OGRDataToSamplePositionFilter ::GetSamplers(unsigned int level) { return this->GetFilter()->GetSamplers(level); } template void OGRDataToSamplePositionFilter ::SetOutputPositionContainerAndRates( otb::ogr::DataSource* data, const SamplingRateCalculator::MapRateType& map, unsigned int level) { this->GetFilter()->SetOutputPositionContainerAndRates(data,map,level); } template otb::ogr::DataSource* OGRDataToSamplePositionFilter ::GetOutputPositionContainer(unsigned int level) { return this->GetFilter()->GetOutputPositionContainer(level); } template void OGRDataToSamplePositionFilter ::SetOriginFieldName(std::string key) { this->GetFilter()->SetOriginFieldName(key); } template std::string OGRDataToSamplePositionFilter ::GetOriginFieldName() { return this->GetFilter()->GetOriginFieldName(); } } // end of namespace otb #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbPersistentSamplingFilterBase.h000066400000000000000000000203371301006202600304410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentSamplingFilterBase_h #define otbPersistentSamplingFilterBase_h #include "otbPersistentImageFilter.h" #include "otbOGRDataSourceWrapper.h" #include "otbImage.h" namespace otb { /** \class PersistentSamplingFilterBase * \brief Base class for persistent filter doing sampling tasks * * \note This class contains pure virtual method, and can not be instantiated. * * \sa PersistentOGRDataToClassStatisticsFilter * \sa PersistentOGRDataToSamplePositionFilter * * \ingroup OTBSampling */ template > class ITK_EXPORT PersistentSamplingFilterBase : public otb::PersistentImageFilter { public: /** Standard typedefs */ typedef PersistentSamplingFilterBase Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkTypeMacro(PersistentSamplingFilterBase, PersistentImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TMaskImage MaskImageType; typedef typename TInputImage::RegionType RegionType; typedef ogr::DataSource::Pointer OGRDataPointer; /** Set the input OGRDataSource that contains sampling areas for each class*/ void SetOGRData(const ogr::DataSource* vector); /** Get the input OGRDataSource with sampling regions*/ const ogr::DataSource* GetOGRData(); /** Set an input mask (optional) */ void SetMask(const TMaskImage* mask); /** Get the input mask (may be null) */ const TMaskImage* GetMask(); /** Set the OGR layer creation options */ void SetOGRLayerCreationOptions(const std::vector & options); /** Get the OGR layer creation options */ const std::vector& GetOGRLayerCreationOptions(); /** Set/Get macro for the field name containing class names * in the input vectors.*/ itkSetMacro(FieldName, std::string); itkGetMacro(FieldName, std::string); /** Get macro for the field index (deduced from the field name) */ itkGetMacro(FieldIndex, int); /** Set/Get macro for the layer index containing the sampling areas */ itkSetMacro(LayerIndex, int); itkGetMacro(LayerIndex, int); /** Set/Get macro for the layer name */ itkSetMacro(OutLayerName, std::string); itkGetMacro(OutLayerName, std::string); protected: /** Constructor */ PersistentSamplingFilterBase(); /** Destructor */ ~PersistentSamplingFilterBase() ITK_OVERRIDE {} /** Use the same output information as input image, check the field index * and the mask footprint */ void GenerateOutputInformation() ITK_OVERRIDE; /** Use an empty region to input image (pixel values not needed) and set * the requested region for the mask */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Generate data should thread over */ void GenerateData(void) ITK_OVERRIDE; /** Allocate in-memory layers for input and outputs */ void AllocateOutputs(void) ITK_OVERRIDE; /** Start of main processing loop */ virtual void ThreadedGenerateVectorData(const ogr::Layer& layerForThread, itk::ThreadIdType threadid); /** Process a geometry, recursive method when the geometry is a collection */ void ExploreGeometry(const ogr::Feature& feature, OGRGeometry* geom, RegionType& region, itk::ThreadIdType& threadid); /** Process a line string : use pixels that cross the line */ virtual void ProcessLine(const ogr::Feature& feature, OGRLineString* line, RegionType& region, itk::ThreadIdType& threadid); /** Process a polygon : use pixels inside the polygon */ virtual void ProcessPolygon(const ogr::Feature& feature, OGRPolygon* polygon, RegionType& region, itk::ThreadIdType& threadid); /** Generic method called for each matching pixel position (NOT IMPLEMENTED)*/ virtual void ProcessSample(const ogr::Feature& feature, typename TInputImage::IndexType& imgIndex, typename TInputImage::PointType& imgPoint, itk::ThreadIdType& threadid); /** Generic method called once before processing each feature */ virtual void PrepareFeature(const ogr::Feature& feature, itk::ThreadIdType& threadid); /** Common function to test if a point is inside a polygon */ bool IsSampleInsidePolygon(OGRPolygon* poly, OGRPoint* tmpPoint); /** Common function to test if a pixel crosses the line */ bool IsSampleOnLine(OGRLineString* line, typename TInputImage::PointType& position, typename TInputImage::SpacingType& absSpacing, OGRPolygon& tmpPolygon); /** Get the region bounding a set of features */ RegionType FeatureBoundingRegion(const TInputImage* image, otb::ogr::Layer::const_iterator& featIt) const; /** Method to split the input OGRDataSource between several containers * for each thread. Default is to put the same number of features for * each thread.*/ virtual void DispatchInputVectors(void); /** Gather the content of in-memory output layer into the filter outputs */ virtual void GatherOutputVectors(void); /** Utility method to add new fields on an output layer */ virtual void InitializeOutputDataSource(ogr::DataSource* inputDS, ogr::DataSource* outputDS); typedef struct { std::string Name; OGRFieldType Type; int Width; int Precision; } SimpleFieldDefn; /** Clear current additional fields */ void ClearAdditionalFields(); /** Create a new additional field */ void CreateAdditionalField(std::string name, OGRFieldType type, int width=0, int precision=0); /** Get a reference over the additional fields */ const std::vector& GetAdditionalFields(); /** Callback function to launch VectorThreadedGenerateData in each thread */ static ITK_THREAD_RETURN_TYPE VectorThreaderCallback(void *arg); /** basically the same struct as itk::ImageSource::ThreadStruct */ struct VectorThreadStruct { Pointer Filter; }; /** Give access to in-memory input layers */ ogr::Layer GetInMemoryInput(unsigned int threadId); /** Give access to in-memory output layers */ ogr::Layer GetInMemoryOutput(unsigned int threadId, unsigned int index=0); private: PersistentSamplingFilterBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Field name containing the class name*/ std::string m_FieldName; /** Field index corresponding to the field name m_FieldName */ int m_FieldIndex; /** Layer to use in the input vector file, default to 0 */ int m_LayerIndex; /** name of the output layers */ std::string m_OutLayerName; /** Creation option for output layers */ std::vector m_OGRLayerCreationOptions; /** Additional field definitions to add in output data sources */ std::vector m_AdditionalFields; /** In-memory containers storing input geometries for each thread*/ std::vector m_InMemoryInputs; /** In-memory containers storing position during iteration loop*/ std::vector > m_InMemoryOutputs; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPersistentSamplingFilterBase.txx" #endif #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbPersistentSamplingFilterBase.txx000066400000000000000000000667761301006202600310560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentSamplingFilterBase_txx #define otbPersistentSamplingFilterBase_txx #include "otbPersistentSamplingFilterBase.h" #include "otbMaskedIteratorDecorator.h" #include "itkImageRegionConstIteratorWithOnlyIndex.h" #include "itkImageRegionConstIterator.h" #include "otbMacro.h" #include "itkTimeProbe.h" #include "itkProgressReporter.h" namespace otb { template PersistentSamplingFilterBase ::PersistentSamplingFilterBase() : m_FieldName(std::string("class")) , m_FieldIndex(0) , m_LayerIndex(0) , m_OutLayerName(std::string("output")) , m_OGRLayerCreationOptions() , m_AdditionalFields() { this->SetNthOutput(0,TInputImage::New()); } template void PersistentSamplingFilterBase ::SetOGRData(const otb::ogr::DataSource* vector) { this->SetNthInput(1, const_cast( vector )); } template const otb::ogr::DataSource* PersistentSamplingFilterBase ::GetOGRData() { if (this->GetNumberOfInputs()<2) { return 0; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template void PersistentSamplingFilterBase ::SetMask(const TMaskImage* mask) { this->SetNthInput(2, const_cast( mask )); } template const TMaskImage* PersistentSamplingFilterBase ::GetMask() { if (this->GetNumberOfInputs()<3) { return 0; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template void PersistentSamplingFilterBase ::SetOGRLayerCreationOptions(const std::vector & options) { m_OGRLayerCreationOptions.clear(); m_OGRLayerCreationOptions = options; } template const std::vector& PersistentSamplingFilterBase ::GetOGRLayerCreationOptions() { return m_OGRLayerCreationOptions; } template void PersistentSamplingFilterBase ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // Get OGR field index const otb::ogr::DataSource* vectors = this->GetOGRData(); otb::ogr::Layer::const_iterator featIt = vectors->GetLayer(m_LayerIndex).begin(); int fieldIndex = featIt->ogr().GetFieldIndex(this->m_FieldName.c_str()); if (fieldIndex < 0) { itkGenericExceptionMacro("Field named "<m_FieldName<<" not found!"); } this->m_FieldIndex = fieldIndex; const MaskImageType *mask = this->GetMask(); if (mask) { const InputImageType *input = this->GetInput(); if (mask->GetLargestPossibleRegion() != input->GetLargestPossibleRegion() ) { itkGenericExceptionMacro("Mask and input image have a different size!"); } if (mask->GetOrigin() != input->GetOrigin()) { itkGenericExceptionMacro("Mask and input image have a different origin!"); } if (mask->GetSpacing() != input->GetSpacing()) { itkGenericExceptionMacro("Mask and input image have a different spacing!"); } } } template void PersistentSamplingFilterBase ::GenerateInputRequestedRegion() { InputImageType *input = const_cast(this->GetInput()); MaskImageType *mask = const_cast(this->GetMask()); RegionType requested = this->GetOutput()->GetRequestedRegion(); RegionType emptyRegion = input->GetLargestPossibleRegion(); emptyRegion.SetSize(0,0); emptyRegion.SetSize(1,0); input->SetRequestedRegion(emptyRegion); if (mask) { mask->SetRequestedRegion(requested); } } template void PersistentSamplingFilterBase ::GenerateData(void) { this->AllocateOutputs(); this->BeforeThreadedGenerateData(); // Split the data into in-memory layers this->DispatchInputVectors(); // struct to store filter pointer VectorThreadStruct str; str.Filter = this; // Get the output pointer //const InputImageType *outputPtr = this->GetOutput(); this->GetMultiThreader()->SetNumberOfThreads( this->GetNumberOfThreads() ); this->GetMultiThreader()->SetSingleMethod(this->VectorThreaderCallback, &str); // multithread the execution this->GetMultiThreader()->SingleMethodExecute(); // gather the data from in-memory output layers this->GatherOutputVectors(); this->AfterThreadedGenerateData(); } template void PersistentSamplingFilterBase ::AllocateOutputs(void) { Superclass::AllocateOutputs(); ogr::DataSource* vectors = const_cast(this->GetOGRData()); ogr::Layer inLayer = vectors->GetLayer(m_LayerIndex); unsigned int numberOfThreads = this->GetNumberOfThreads(); // Prepare temporary input this->m_InMemoryInputs.clear(); this->m_InMemoryInputs.reserve(numberOfThreads); std::string tmpLayerName("thread"); OGRSpatialReference * oSRS = ITK_NULLPTR; if (inLayer.GetSpatialRef()) { oSRS = inLayer.GetSpatialRef()->Clone(); } OGRFeatureDefn &layerDefn = inLayer.GetLayerDefn(); //std::vector tmpLayers; for (unsigned int i=0 ; i < numberOfThreads ; i++) { ogr::DataSource::Pointer tmpOgrDS = ogr::DataSource::New(); ogr::Layer tmpLayer = tmpOgrDS->CreateLayer( tmpLayerName, oSRS, inLayer.GetGeomType()); // add field definitions for (int k=0 ; k < layerDefn.GetFieldCount() ; k++) { OGRFieldDefn originDefn(layerDefn.GetFieldDefn(k)); ogr::FieldDefn fieldDefn(originDefn); tmpLayer.CreateField(fieldDefn); } this->m_InMemoryInputs.push_back(tmpOgrDS); } // Prepare in-memory outputs this->m_InMemoryOutputs.clear(); this->m_InMemoryOutputs.reserve(numberOfThreads); tmpLayerName = std::string("threadOut"); for (unsigned int i=0 ; i < numberOfThreads ; i++) { std::vector tmpContainer; // iterate over outputs, only process ogr::DataSource for (unsigned int k=0 ; k < this->GetNumberOfOutputs() ; k++) { ogr::DataSource* realOutput = dynamic_cast( this->itk::ProcessObject::GetOutput(k)); if (realOutput) { ogr::Layer realLayer = realOutput->GetLayersCount() == 1 ? realOutput->GetLayer(0) : realOutput->GetLayer(m_OutLayerName); OGRFeatureDefn &outLayerDefn = realLayer.GetLayerDefn(); ogr::DataSource::Pointer tmpOutput = ogr::DataSource::New(); ogr::Layer tmpLayer = tmpOutput->CreateLayer( tmpLayerName, oSRS, realLayer.GetGeomType()); // add field definitions for (int f=0 ; f < outLayerDefn.GetFieldCount() ; f++) { OGRFieldDefn originDefn(outLayerDefn.GetFieldDefn(f)); tmpLayer.CreateField(originDefn); } tmpContainer.push_back(tmpOutput); } } this->m_InMemoryOutputs.push_back(tmpContainer); } } template void PersistentSamplingFilterBase ::GatherOutputVectors(void) { // clean temporary inputs this->m_InMemoryInputs.clear(); unsigned int numberOfThreads = this->GetNumberOfThreads(); // gather temporary outputs and write to output const otb::ogr::DataSource* vectors = this->GetOGRData(); itk::TimeProbe chrono; chrono.Start(); unsigned int count = 0; for (unsigned int k=0 ; k < this->GetNumberOfOutputs() ; k++) { ogr::DataSource* realOutput = dynamic_cast( this->itk::ProcessObject::GetOutput(k)); if (realOutput) { ogr::Layer outLayer = realOutput->GetLayersCount() == 1 ? realOutput->GetLayer(0) : realOutput->GetLayer(m_OutLayerName); OGRErr err = outLayer.ogr().StartTransaction(); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Unable to start transaction for OGR layer " << outLayer.ogr().GetName() << "."); } for (unsigned int thread=0 ; thread < numberOfThreads ; thread++) { ogr::Layer inLayer = this->m_InMemoryOutputs[thread][count]->GetLayerChecked(0); if (!inLayer) { continue; } ogr::Layer::const_iterator tmpIt = inLayer.begin(); // This test only uses 1 input, not compatible with multiple OGRData inputs if (vectors == realOutput) { // Update mode for(; tmpIt!=inLayer.end(); ++tmpIt) { outLayer.SetFeature( *tmpIt ); } } else { // Copy mode for(; tmpIt!=inLayer.end(); ++tmpIt) { ogr::Feature dstFeature(outLayer.GetLayerDefn()); dstFeature.SetFrom( *tmpIt, TRUE ); outLayer.CreateFeature( dstFeature ); } } } err = outLayer.ogr().CommitTransaction(); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Unable to commit transaction for OGR layer " << outLayer.ogr().GetName() << "."); } count++; } } chrono.Stop(); otbMsgDebugMacro(<< "write ogr points took " << chrono.GetTotal() << " sec"); this->m_InMemoryOutputs.clear(); } template void PersistentSamplingFilterBase ::ThreadedGenerateVectorData(const ogr::Layer& layerForThread, itk::ThreadIdType threadid) { // Retrieve inputs TInputImage* inputImage = const_cast(this->GetInput()); TInputImage* outputImage = this->GetOutput(); RegionType requestedRegion = outputImage->GetRequestedRegion(); itk::ProgressReporter progress( this, threadid, layerForThread.GetFeatureCount(true) ); // Loop across the features in the layer (filtered by requested region in BeforeTGD already) ogr::Layer::const_iterator featIt = layerForThread.begin(); for(; featIt!=layerForThread.end(); ++featIt) { // Compute the intersection of thread region and polygon bounding region, called "considered region" // This need not be done in ThreadedGenerateData and could be pre-processed and cached before filter execution if needed RegionType consideredRegion = FeatureBoundingRegion(inputImage, featIt); bool regionNotEmpty = consideredRegion.Crop(requestedRegion); if (regionNotEmpty) { this->PrepareFeature(*featIt,threadid); this->ExploreGeometry(*featIt, featIt->ogr().GetGeometryRef(),consideredRegion,threadid); } progress.CompletedPixel(); } } template void PersistentSamplingFilterBase ::ExploreGeometry(const ogr::Feature& feature, OGRGeometry* geom, RegionType& region, itk::ThreadIdType& threadid) { typename TInputImage::PointType imgPoint; typename TInputImage::IndexType imgIndex; switch (geom->getGeometryType()) { case wkbPoint: case wkbPoint25D: { OGRPoint* castPoint = dynamic_cast(geom); if (castPoint == ITK_NULLPTR) break; imgPoint[0] = castPoint->getX(); imgPoint[1] = castPoint->getY(); const TInputImage* img = this->GetInput(); const TMaskImage* mask = this->GetMask(); img->TransformPhysicalPointToIndex(imgPoint,imgIndex); if ((mask == ITK_NULLPTR) || mask->GetPixel(imgIndex)) { this->ProcessSample(feature, imgIndex, imgPoint, threadid); } break; } case wkbLineString: case wkbLineString25D: { OGRLineString* castLineString = dynamic_cast(geom); if (castLineString == ITK_NULLPTR) break; this->ProcessLine(feature,castLineString,region,threadid); break; } case wkbPolygon: case wkbPolygon25D: { OGRPolygon* castPolygon = dynamic_cast(geom); if (castPolygon == ITK_NULLPTR) break; this->ProcessPolygon(feature,castPolygon,region,threadid); break; } case wkbMultiPoint: case wkbMultiPoint25D: case wkbMultiLineString: case wkbMultiLineString25D: case wkbMultiPolygon: case wkbMultiPolygon25D: case wkbGeometryCollection: case wkbGeometryCollection25D: { OGRGeometryCollection *geomCollection = dynamic_cast(geom); if (geomCollection) { unsigned int nbGeom = geomCollection->getNumGeometries(); for (unsigned int i=0 ; i < nbGeom ; ++i) { this->ExploreGeometry(feature, geomCollection->getGeometryRef(i), region, threadid); } } else { otbWarningMacro("Geometry not recognized as a collection : " << geom->getGeometryName()); } break; } default: { otbWarningMacro("Geometry not handled: " << geom->getGeometryName()); break; } } } template void PersistentSamplingFilterBase ::ProcessLine(const ogr::Feature& feature, OGRLineString* line, RegionType& region, itk::ThreadIdType& threadid) { OGRPolygon tmpPolygon; OGRLinearRing ring; ring.addPoint(0.0,0.0,0.0); ring.addPoint(1.0,0.0,0.0); ring.addPoint(1.0,1.0,0.0); ring.addPoint(0.0,1.0,0.0); ring.addPoint(0.0,0.0,0.0); tmpPolygon.addRing(&ring); const TInputImage* img = this->GetInput(); TMaskImage* mask = const_cast(this->GetMask()); typename TInputImage::IndexType imgIndex; typename TInputImage::PointType imgPoint; typename TInputImage::SpacingType imgAbsSpacing = img->GetSpacing(); if (imgAbsSpacing[0] < 0) imgAbsSpacing[0] = -imgAbsSpacing[0]; if (imgAbsSpacing[1] < 0) imgAbsSpacing[1] = -imgAbsSpacing[1]; if (mask) { // For pixels in consideredRegion and not masked typedef MaskedIteratorDecorator< itk::ImageRegionConstIterator, itk::ImageRegionConstIterator > MaskedIteratorType; MaskedIteratorType it(mask, mask, region); it.GoToBegin(); while (!it.IsAtEnd()) { imgIndex = it.GetIndex(); img->TransformIndexToPhysicalPoint(imgIndex,imgPoint); bool isInside = this->IsSampleOnLine(line,imgPoint,imgAbsSpacing,tmpPolygon); if (isInside) { this->ProcessSample(feature,imgIndex, imgPoint, threadid); } ++it; } } else { typedef itk::ImageRegionConstIteratorWithOnlyIndex NoValueIteratorType; NoValueIteratorType it(img,region); it.GoToBegin(); while (!it.IsAtEnd()) { imgIndex = it.GetIndex(); img->TransformIndexToPhysicalPoint(imgIndex,imgPoint); bool isInside = this->IsSampleOnLine(line,imgPoint,imgAbsSpacing,tmpPolygon); if (isInside) { this->ProcessSample(feature,imgIndex, imgPoint, threadid); } ++it; } } } template void PersistentSamplingFilterBase ::ProcessPolygon(const ogr::Feature& feature, OGRPolygon* polygon, RegionType& region, itk::ThreadIdType& threadid) { const TInputImage* img = this->GetInput(); TMaskImage* mask = const_cast(this->GetMask()); typename TInputImage::IndexType imgIndex; typename TInputImage::PointType imgPoint; OGRPoint tmpPoint; if (mask) { // For pixels in consideredRegion and not masked typedef MaskedIteratorDecorator< itk::ImageRegionConstIterator, itk::ImageRegionConstIterator > MaskedIteratorType; MaskedIteratorType it(mask, mask, region); it.GoToBegin(); while (!it.IsAtEnd()) { imgIndex = it.GetIndex(); img->TransformIndexToPhysicalPoint(imgIndex,imgPoint); tmpPoint.setX(imgPoint[0]); tmpPoint.setY(imgPoint[1]); bool isInside = this->IsSampleInsidePolygon(polygon,&tmpPoint); if (isInside) { this->ProcessSample(feature,imgIndex, imgPoint, threadid); } ++it; } } else { typedef itk::ImageRegionConstIteratorWithOnlyIndex NoValueIteratorType; NoValueIteratorType it(img,region); it.GoToBegin(); while (!it.IsAtEnd()) { imgIndex = it.GetIndex(); img->TransformIndexToPhysicalPoint(imgIndex,imgPoint); tmpPoint.setX(imgPoint[0]); tmpPoint.setY(imgPoint[1]); bool isInside = this->IsSampleInsidePolygon(polygon,&tmpPoint); if (isInside) { this->ProcessSample(feature,imgIndex, imgPoint, threadid); } ++it; } } } template void PersistentSamplingFilterBase ::ProcessSample(const ogr::Feature& , typename TInputImage::IndexType& , typename TInputImage::PointType& , itk::ThreadIdType& ) { itkExceptionMacro("Method ProcessSample not implemented !"); } template void PersistentSamplingFilterBase ::PrepareFeature(const ogr::Feature&, itk::ThreadIdType&) { // Nothing to do here } template inline bool PersistentSamplingFilterBase ::IsSampleInsidePolygon(OGRPolygon* poly, OGRPoint* tmpPoint) { bool ret = poly->getExteriorRing()->isPointInRing(tmpPoint); if (ret) { for (int k=0 ; kgetNumInteriorRings() ; k++) { if (poly->getInteriorRing(k)->isPointInRing(tmpPoint)) { ret = false; break; } } } return ret; } template inline bool PersistentSamplingFilterBase ::IsSampleOnLine(OGRLineString* line, typename TInputImage::PointType& position, typename TInputImage::SpacingType& absSpacing, OGRPolygon& tmpPolygon) { tmpPolygon.getExteriorRing()->setPoint(0 ,position[0]-0.5*absSpacing[0] ,position[1]-0.5*absSpacing[1] ,0.0); tmpPolygon.getExteriorRing()->setPoint(1 ,position[0]+0.5*absSpacing[0] ,position[1]-0.5*absSpacing[1] ,0.0); tmpPolygon.getExteriorRing()->setPoint(2 ,position[0]+0.5*absSpacing[0] ,position[1]+0.5*absSpacing[1] ,0.0); tmpPolygon.getExteriorRing()->setPoint(3 ,position[0]-0.5*absSpacing[0] ,position[1]+0.5*absSpacing[1] ,0.0); tmpPolygon.getExteriorRing()->setPoint(4 ,position[0]-0.5*absSpacing[0] ,position[1]-0.5*absSpacing[1] ,0.0); return line->Intersects(&tmpPolygon); } template typename PersistentSamplingFilterBase::RegionType PersistentSamplingFilterBase ::FeatureBoundingRegion(const TInputImage* image, otb::ogr::Layer::const_iterator& featIt) const { // otb::ogr wrapper is incomplete and leaky abstraction is inevitable here OGREnvelope envelope; featIt->GetGeometry()->getEnvelope(&envelope); itk::Point lowerPoint, upperPoint; lowerPoint[0] = envelope.MinX; lowerPoint[1] = envelope.MinY; upperPoint[0] = envelope.MaxX; upperPoint[1] = envelope.MaxY; typename TInputImage::IndexType lowerIndex; typename TInputImage::IndexType upperIndex; image->TransformPhysicalPointToIndex(lowerPoint, lowerIndex); image->TransformPhysicalPointToIndex(upperPoint, upperIndex); // swap coordinate to keep lowerIndex as start index if (lowerIndex[0] > upperIndex[0]) { int tmp = lowerIndex[0]; lowerIndex[0] = upperIndex[0]; upperIndex[0] = tmp; } if (lowerIndex[1] > upperIndex[1]) { int tmp = lowerIndex[1]; lowerIndex[1] = upperIndex[1]; upperIndex[1] = tmp; } RegionType region; region.SetIndex(lowerIndex); region.SetUpperIndex(upperIndex); return region; } template void PersistentSamplingFilterBase ::DispatchInputVectors() { TInputImage* outputImage = this->GetOutput(); ogr::DataSource* vectors = const_cast(this->GetOGRData()); ogr::Layer inLayer = vectors->GetLayer(m_LayerIndex); const RegionType& requestedRegion = outputImage->GetRequestedRegion(); itk::ContinuousIndex startIndex(requestedRegion.GetIndex()); itk::ContinuousIndex endIndex(requestedRegion.GetUpperIndex()); startIndex[0] += -0.5; startIndex[1] += -0.5; endIndex[0] += 0.5; endIndex[1] += 0.5; itk::Point startPoint; itk::Point endPoint; outputImage->TransformContinuousIndexToPhysicalPoint(startIndex, startPoint); outputImage->TransformContinuousIndexToPhysicalPoint(endIndex, endPoint); // create geometric extent OGRPolygon tmpPolygon; OGRLinearRing ring; ring.addPoint(startPoint[0],startPoint[1],0.0); ring.addPoint(startPoint[0],endPoint[1] ,0.0); ring.addPoint(endPoint[0] ,endPoint[1] ,0.0); ring.addPoint(endPoint[0] ,startPoint[1],0.0); ring.addPoint(startPoint[0],startPoint[1],0.0); tmpPolygon.addRing(&ring); inLayer.SetSpatialFilter(&tmpPolygon); unsigned int numberOfThreads = this->GetNumberOfThreads(); std::vector tmpLayers; tmpLayers.reserve(numberOfThreads); for (unsigned int i=0 ; iGetInMemoryInput(i)); } OGRFeatureDefn &layerDefn = inLayer.GetLayerDefn(); ogr::Layer::const_iterator featIt = inLayer.begin(); unsigned int counter=0; for(; featIt!=inLayer.end(); ++featIt) { ogr::Feature dstFeature(layerDefn); dstFeature.SetFrom( *featIt, TRUE ); dstFeature.SetFID(featIt->GetFID()); tmpLayers[counter].CreateFeature( dstFeature ); counter++; if (counter >= tmpLayers.size()) counter = 0; } inLayer.SetSpatialFilter(ITK_NULLPTR); } template void PersistentSamplingFilterBase ::InitializeOutputDataSource(ogr::DataSource* inputDS, ogr::DataSource* outputDS) { TInputImage *inputImage = const_cast(this->GetInput()); inputImage->UpdateOutputInformation(); ogr::Layer inLayer = inputDS->GetLayer(this->GetLayerIndex()); bool updateMode = false; if (inputDS == outputDS) { updateMode = true; // Check m_OutLayerName is same as input layer name m_OutLayerName = inLayer.GetName(); } // First get list of current fields OGRFeatureDefn &layerDefn = inLayer.GetLayerDefn(); std::map currentFields; for (int k=0 ; kGetInput()->GetProjectionRef(); bool projectionInformationAvailable = !projectionRefWkt.empty(); OGRSpatialReference * oSRS = ITK_NULLPTR; if(projectionInformationAvailable) { oSRS = static_cast(OSRNewSpatialReference(projectionRefWkt.c_str())); } // Create layer outLayer = outputDS->CreateLayer( this->GetOutLayerName(), oSRS, wkbPoint, this->GetOGRLayerCreationOptions()); // Copy existing fields for (int k=0 ; k void PersistentSamplingFilterBase ::ClearAdditionalFields() { this->m_AdditionalFields.clear(); } template void PersistentSamplingFilterBase ::CreateAdditionalField(std::string name, OGRFieldType type, int width, int precision) { SimpleFieldDefn defn; defn.Name = name; defn.Type = type; defn.Width = width; defn.Precision = precision; this->m_AdditionalFields.push_back(defn); } template const std::vector< typename PersistentSamplingFilterBase ::SimpleFieldDefn>& PersistentSamplingFilterBase ::GetAdditionalFields() { return this->m_AdditionalFields; } template ITK_THREAD_RETURN_TYPE PersistentSamplingFilterBase ::VectorThreaderCallback(void *arg) { VectorThreadStruct *str = (VectorThreadStruct*)(((itk::MultiThreader::ThreadInfoStruct *)(arg))->UserData); int threadId = ((itk::MultiThreader::ThreadInfoStruct *)(arg))->ThreadID; int threadCount = ((itk::MultiThreader::ThreadInfoStruct *)(arg))->NumberOfThreads; ogr::Layer layer = str->Filter->GetInMemoryInput(threadId); if (threadId < threadCount) { str->Filter->ThreadedGenerateVectorData(layer,threadId); } return ITK_THREAD_RETURN_VALUE; } template ogr::Layer PersistentSamplingFilterBase ::GetInMemoryInput(unsigned int threadId) { if (threadId >= m_InMemoryInputs.size()) { itkExceptionMacro(<< "Requested in-memory input layer not available " << threadId << " (total size : "<< m_InMemoryInputs.size() <<")."); } return m_InMemoryInputs[threadId]->GetLayerChecked(0); } template ogr::Layer PersistentSamplingFilterBase ::GetInMemoryOutput(unsigned int threadId, unsigned int index) { if (threadId >= m_InMemoryOutputs.size()) { itkExceptionMacro(<< "Requested in-memory output layer not available " << threadId << " (total size : "<< m_InMemoryOutputs.size() <<")."); } if (index >= m_InMemoryOutputs[threadId].size()) { itkExceptionMacro(<< "Requested output dataset not available " << index << " (available : "<< m_InMemoryOutputs[threadId].size() <<")."); } return m_InMemoryOutputs[threadId][index]->GetLayerChecked(0); } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbSamplingRateCalculator.h000066400000000000000000000075211301006202600272450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSamplingRateCalculator_h #define otbSamplingRateCalculator_h #include "itkImageRegion.h" #include "itkVectorContainer.h" #include namespace otb { /** \class SamplingRateCalculator * \brief This class is a sampling rate calculator. * * It computes sampling rates for each class, given input statistics on * available samples, and a sampling strategy. * * \ingroup OTBSampling */ class ITK_EXPORT SamplingRateCalculator : public itk::Object { public: /** Standard typedefs */ typedef SamplingRateCalculator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** typdefs **/ typedef std::map ClassCountMapType; typedef ClassCountMapType::const_iterator constItMapType; typedef struct Triplet { unsigned long Required; unsigned long Tot; double Rate; bool operator==(const struct Triplet & triplet) const; } TripletType; typedef std::map MapRateType; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SamplingRateCalculator, itk::Object); /** Method to manually set the number of samples required in each class */ void SetNbOfSamplesByClass(const ClassCountMapType &required); /** Method to set the same number of required samples in each class */ void SetNbOfSamplesAllClasses(unsigned long); /** Method to set a percentage of samples for each class */ void SetPercentageOfSamples(double percent); /** Method to set the total number of samples to generate */ void SetTotalNumberOfSamples(unsigned long value); /** Method to choose a sampling strategy based on the smallest class. * The number of samples in each class is set to this minimum size*/ void SetMinimumNbOfSamplesByClass(void); /** Method to select all available samples */ void SetAllSamples(void); /** Method to export sampling rates in a CSV file. * Columns are : class name, required samples, total samples, rate.*/ void Write(std::string filename); /** Method to import sampling rates from a CSV file. * Columns are : class name, required samples, total samples, rate.*/ void Read(std::string filename); /** Get macro to the computed sampling rates.*/ itkGetConstReferenceMacro(RatesByClass,MapRateType); /** Set method to input the total number of samples in each class. * This method should be called before the other Set... methods * that apply a sampling strategy */ void SetClassCount(const ClassCountMapType& map); /** Clear internal data */ void ClearRates(void); static ClassCountMapType ReadRequiredSamples(const std::string& filename); protected: /** Constructor */ SamplingRateCalculator(); /** Destructor */ ~SamplingRateCalculator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SamplingRateCalculator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Update the computed rate for a given class.*/ void UpdateRate(const std::string &name); /** Internal sampling rates.*/ MapRateType m_RatesByClass; }; } // End namespace otb #endif OTB-release-5.8/Modules/Learning/Sampling/include/otbSamplingRateCalculatorList.h000066400000000000000000000067211301006202600301020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSamplingRateCalculatorList_h #define otbSamplingRateCalculatorList_h #include "otbSamplingRateCalculator.h" #include "otbObjectList.h" namespace otb { /** \class SamplingRateCalculatorList * \brief This class is a list of sampling rate calculators. * * It computes sampling rates for each image and each class, given input * statistics on available samples, and a sampling strategy. The sampling * strategies are made from the combination of : * - the sampling strategies of otb::SamplingRateCalculator (mono-image) * - a multi-image behaviour : proportional / constant / custom * * \ingroup OTBSampling */ class ITK_EXPORT SamplingRateCalculatorList : public ObjectList { public: /** Standard typedefs */ typedef SamplingRateCalculatorList Self; typedef ObjectList Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef SamplingRateCalculator::ClassCountMapType ClassCountMapType; typedef SamplingRateCalculator::MapRateType MapRateType; enum PartitionType { PROPORTIONAL, EQUAL, CUSTOM }; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(SamplingRateCalculatorList, ObjectList); /** Set the class counts for input 'index' */ void SetNthClassCount(unsigned int index,const ClassCountMapType &map); /** Get the sampling rates computed for input 'index' */ const MapRateType & GetRatesByClass(unsigned int index); /** Clear internal data */ void ClearRates(void); /** Method to select all available samples */ void SetAllSamples(PartitionType t); /** Method to choose a sampling strategy based on the smallest class. * The number of samples in each class is set to this minimum size*/ void SetMinimumNbOfSamplesByClass(PartitionType t); /** Method to set the same number of required samples in each class */ void SetNbOfSamplesAllClasses(std::vector &nb, PartitionType t); /** Method to manually set the number of samples required in each class */ void SetNbOfSamplesByClass(const std::vector &required, PartitionType t); /** Method to use a percentage of the samples available in each * class */ void SetPercentageOfSamples(std::vector &p, PartitionType t); /** Method to set the total number of samples and use classes proportions */ void SetTotalNumberOfSamples(std::vector &tot, PartitionType t); protected: /** Constructor */ SamplingRateCalculatorList(){} /** Destructor */ ~SamplingRateCalculatorList() ITK_OVERRIDE {} private: SamplingRateCalculatorList(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void UpdateGlobalCounts(); ClassCountMapType m_GlobalCountMap; }; } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Sampling/otb-module.cmake000066400000000000000000000004611301006202600234110ustar00rootroot00000000000000set(DOCUMENTATION "This module contains OTB sampling framework.") otb_module(OTBSampling DEPENDS OTBCommon OTBConversion OTBImageManipulation OTBITK OTBStatistics TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase OTBIOXML DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Learning/Sampling/src/000077500000000000000000000000001301006202600211265ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Sampling/src/CMakeLists.txt000066400000000000000000000004771301006202600236760ustar00rootroot00000000000000set(OTBSampling_SRC otbSamplingRateCalculator.cxx otbSamplingRateCalculatorList.cxx ) add_library(OTBSampling ${OTBSampling_SRC}) target_link_libraries(OTBSampling ${OTBCommon_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBStatistics_LIBRARIES} ${OTBIOGDAL_LBRARIES} ) otb_module_target(OTBSampling) OTB-release-5.8/Modules/Learning/Sampling/src/otbSamplingRateCalculator.cxx000066400000000000000000000244071301006202600267660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSamplingRateCalculator.h" #include "otbStringUtils.h" #include "otbMacro.h" #include #include #include #include "itksys/SystemTools.hxx" namespace otb { bool SamplingRateCalculator::TripletType::operator==(const SamplingRateCalculator::TripletType & triplet) const { return bool((Required == triplet.Required)|| (Tot == triplet.Tot)|| (Rate == triplet.Rate)); } SamplingRateCalculator ::SamplingRateCalculator() { } void SamplingRateCalculator ::SetMinimumNbOfSamplesByClass(void) { unsigned long smallestNbofSamples = itk::NumericTraits::max(); MapRateType::iterator it = m_RatesByClass.begin(); for (; it != m_RatesByClass.end() ; ++it) { if (smallestNbofSamples > it->second.Tot) { smallestNbofSamples = it->second.Tot; } } // Check if there is an empty class if (smallestNbofSamples == 0UL) { otbWarningMacro("There is an empty class, sample size is set to zero!"); } this->SetNbOfSamplesAllClasses( smallestNbofSamples ); } void SamplingRateCalculator ::SetNbOfSamplesAllClasses(unsigned long dRequiredNbSamples) { MapRateType::iterator it = m_RatesByClass.begin(); for (; it != m_RatesByClass.end() ; ++it) { it->second.Required = dRequiredNbSamples; this->UpdateRate(it->first); } } void SamplingRateCalculator ::SetNbOfSamplesByClass(const ClassCountMapType &required) { ClassCountMapType::const_iterator it = required.begin(); for (; it != required.end() ; ++it) { if (m_RatesByClass.count(it->first)) { m_RatesByClass[it->first].Required = it->second; this->UpdateRate(it->first); } else { TripletType triplet; triplet.Tot = 0UL; triplet.Required = it->second; triplet.Rate = 0.0; m_RatesByClass[it->first] = triplet; } } } void SamplingRateCalculator ::SetAllSamples(void) { MapRateType::iterator it = m_RatesByClass.begin(); for (; it != m_RatesByClass.end() ; ++it) { it->second.Required = it->second.Tot; it->second.Rate = 1.0; } } void SamplingRateCalculator ::SetPercentageOfSamples(double percent) { MapRateType::iterator it = m_RatesByClass.begin(); for (; it != m_RatesByClass.end() ; ++it) { it->second.Required = static_cast(vcl_floor(0.5+percent * it->second.Tot)); it->second.Rate = percent; } } void SamplingRateCalculator ::SetTotalNumberOfSamples(unsigned long value) { // First, get total number of samples unsigned long totalNumberOfSamplesAvailable = 0; MapRateType::iterator it = m_RatesByClass.begin(); for (; it != m_RatesByClass.end() ; ++it) { totalNumberOfSamplesAvailable+=it->second.Tot; } // Then compute number of samples for each class for (it = m_RatesByClass.begin(); it != m_RatesByClass.end() ; ++it) { double ratio = it->second.Tot / static_cast(totalNumberOfSamplesAvailable); it->second.Required = static_cast(0.5+ratio*value); this->UpdateRate(it->first); } } void SamplingRateCalculator ::Write(std::string filename) { std::ofstream file(filename.c_str(), std::ios::out | std::ios::trunc); if (file) { itk::Indent indent(0); this->PrintSelf(file,indent); file.close(); } else { itkExceptionMacro(<< " Couldn't open " << filename); } } void SamplingRateCalculator ::Read(std::string filename) { std::ifstream ifs(filename.c_str()); typedef std::vector > ListType; if (ifs) { this->ClearRates(); std::string line; TripletType tpt; std::string sep(""); ListType parts; while(std::getline(ifs,line)) { if (line.empty()) continue; std::string::size_type pos = line.find_first_not_of(" \t"); if (pos != std::string::npos && line[pos] == '#') continue; if (sep.empty()) { // Try to detect the separator std::vector separators(4); separators[0] = "\t"; separators[1] = ";"; separators[2] = ","; separators[3] = " "; ListType words; for (unsigned int k=0 ; k(val1, "number of samples"); tpt.Tot = Utils::LexicalCast(val2, "number of samples"); tpt.Rate = Utils::LexicalCast(val3, "rate"); m_RatesByClass[name] = tpt; } } } ifs.close(); } else { itkExceptionMacro(<< " Couldn't open " << filename); } } void SamplingRateCalculator ::SetClassCount(const ClassCountMapType& map) { ClassCountMapType::const_iterator it = map.begin(); for (; it != map.end() ; ++it) { if (m_RatesByClass.count(it->first)) { m_RatesByClass[it->first].Tot = it->second; this->UpdateRate(it->first); } else { TripletType triplet; triplet.Tot = it->second; triplet.Required = 0UL; triplet.Rate = 0.0; m_RatesByClass[it->first] = triplet; } } } void SamplingRateCalculator ::ClearRates(void) { m_RatesByClass.clear(); } SamplingRateCalculator::ClassCountMapType SamplingRateCalculator ::ReadRequiredSamples(const std::string& filename) { ClassCountMapType output; std::ifstream ifs(filename.c_str()); typedef std::vector > ListType; if (ifs) { std::string line; std::string sep(""); ListType parts; while(std::getline(ifs,line)) { if (line.empty()) continue; std::string::size_type pos = line.find_first_not_of(" \t"); if (pos != std::string::npos && line[pos] == '#') continue; if (sep.empty()) { // Try to detect the separator std::vector separators(4); separators[0] = "\t"; separators[1] = ";"; separators[2] = ","; separators[3] = " "; ListType words; for (unsigned int k=0 ; k= 2) { sep = separators[k]; break; } } if (sep.empty()) continue; } // parse the line boost::split(parts, line, boost::is_any_of(sep)); if (parts.size() >= 2) { std::string::size_type pos1 = line.find_first_not_of(" \t", parts[0].begin() - line.begin()); std::string::size_type pos2 = line.find_last_not_of(" \t", parts[0].end() - line.begin() -1); std::string::size_type pos3 = line.find_first_not_of(" \t", parts[1].begin() - line.begin()); std::string::size_type pos4 = line.find_last_not_of(" \t", parts[1].end() - line.begin() -1); if (pos2 != std::string::npos && pos1 <= pos2 && pos4 != std::string::npos && pos3 <= pos4) { std::string name = line.substr(pos1, pos2 - pos1 + 1); std::string value = line.substr(pos3, pos4 - pos3 + 1); output[name] = Utils::LexicalCast(value, "number of samples"); } } } ifs.close(); } else { itkGenericExceptionMacro(<< " Couldn't open " << filename); } return output; } void SamplingRateCalculator ::UpdateRate(const std::string &name) { if (m_RatesByClass[name].Tot) { m_RatesByClass[name].Rate = std::min( static_cast(m_RatesByClass[name].Required) / static_cast(m_RatesByClass[name].Tot), 1.0); } else { // Set to 0 as rate is undefined m_RatesByClass[name].Rate = 0.0; } } void SamplingRateCalculator ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "#className requiredSamples totalSamples rate" << std::endl; MapRateType::const_iterator itRates = m_RatesByClass.begin(); for(; itRates != m_RatesByClass.end(); ++itRates) { TripletType tpt=itRates->second; os << indent << itRates->first << "\t" << tpt.Required << "\t" << tpt.Tot << "\t" << tpt.Rate << std::endl; } } } // End namespace otb OTB-release-5.8/Modules/Learning/Sampling/src/otbSamplingRateCalculatorList.cxx000066400000000000000000000264241301006202600276230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSamplingRateCalculatorList.h" #include "otbMacro.h" namespace otb { void SamplingRateCalculatorList ::SetNthClassCount(unsigned int index,const ClassCountMapType &map) { if (index >= this->Size()) { unsigned int currentSize = this->Size(); for (unsigned int i = currentSize ; i < (index+1) ; i++ ) { this->PushBack(SamplingRateCalculator::New()); } } this->GetNthElement(index)->SetClassCount(map); } const SamplingRateCalculatorList::MapRateType & SamplingRateCalculatorList ::GetRatesByClass(unsigned int index) { if (index >= this->Size()) { itkGenericExceptionMacro("Requesting an index ("<Size()<<")"); } return this->GetNthElement(index)->GetRatesByClass(); } void SamplingRateCalculatorList ::ClearRates(void) { for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->ClearRates(); } } void SamplingRateCalculatorList ::SetAllSamples(PartitionType t) { this->UpdateGlobalCounts(); switch (t) { case PROPORTIONAL: case EQUAL: case CUSTOM: { for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetAllSamples(); } break; } default: itkGenericExceptionMacro("Unknown partition mode"); break; } } void SamplingRateCalculatorList ::SetMinimumNbOfSamplesByClass(PartitionType t) { this->UpdateGlobalCounts(); switch (t) { case PROPORTIONAL: case EQUAL: { // Use the smallest class globally to derive the constant needed unsigned long smallest = itk::NumericTraits::max(); ClassCountMapType::iterator it = m_GlobalCountMap.begin(); for (; it != m_GlobalCountMap.end() ; ++it) { if (smallest > it->second && it->second > 0UL) { smallest = it->second; } } if (smallest == itk::NumericTraits::max()) { otbWarningMacro("All classes are empty !"); smallest = 0UL; } std::vector needed; needed.push_back(smallest); this->SetNbOfSamplesAllClasses(needed,t); break; } case CUSTOM: { // Use the smallest class in each input for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetMinimumNbOfSamplesByClass(); } break; } default: itkGenericExceptionMacro("Unknown partition mode"); break; } } void SamplingRateCalculatorList ::SetNbOfSamplesAllClasses(std::vector &nb, PartitionType t) { if (nb.empty()) { itkGenericExceptionMacro("No number of samples given"); } this->UpdateGlobalCounts(); ClassCountMapType::const_iterator it; ClassCountMapType needed; switch (t) { case PROPORTIONAL: { for (unsigned int i=0 ; iSize() ; i++) { needed.clear(); for (it = m_GlobalCountMap.begin(); it != m_GlobalCountMap.end() ; ++it) { const MapRateType& rates = this->GetNthElement(i)->GetRatesByClass(); MapRateType::const_iterator curIt = rates.find(it->first); if (curIt != rates.end() && it->second > 0UL) { unsigned long curTotal = (curIt->second).Tot; needed[it->first] = static_cast(vcl_floor( static_cast(nb[0]) * static_cast(curTotal) / static_cast(it->second))); } else { needed[it->first] = 0UL; } } this->GetNthElement(i)->SetNbOfSamplesByClass(needed); } break; } case EQUAL: { for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetNbOfSamplesAllClasses( static_cast(vcl_floor( (double)nb[0] / (double)this->Size()))); } break; } case CUSTOM: { if (nb.size() < this->Size()) { itkGenericExceptionMacro("Not enough values present to set custom requested numbers in all inputs"); } for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetNbOfSamplesAllClasses(nb[i]); } break; } default: itkGenericExceptionMacro("Unknown partition mode"); break; } } void SamplingRateCalculatorList ::SetNbOfSamplesByClass(const std::vector &required, PartitionType t) { if (required.empty()) { itkGenericExceptionMacro("No number of samples given"); } this->UpdateGlobalCounts(); ClassCountMapType::const_iterator it; ClassCountMapType::const_iterator inputIt; ClassCountMapType needed; switch (t) { case PROPORTIONAL: { for (unsigned int i=0 ; iSize() ; i++) { needed.clear(); for (it = m_GlobalCountMap.begin(); it != m_GlobalCountMap.end() ; ++it) { const MapRateType &rates = this->GetNthElement(i)->GetRatesByClass(); MapRateType::const_iterator curIt = rates.find(it->first); inputIt = required[0].find(it->first); if (curIt != rates.end() && inputIt != required[0].end() && it->second > 0UL) { unsigned long curTotal = (curIt->second).Tot; needed[it->first] = static_cast(vcl_floor( static_cast(inputIt->second) * static_cast(curTotal) / static_cast(it->second))); } else { needed[it->first] = 0UL; } } this->GetNthElement(i)->SetNbOfSamplesByClass(needed); } break; } case EQUAL: { for (unsigned int i=0 ; iSize() ; i++) { needed.clear(); for (it = m_GlobalCountMap.begin(); it != m_GlobalCountMap.end() ; ++it) { const MapRateType &rates = this->GetNthElement(i)->GetRatesByClass(); MapRateType::const_iterator curIt = rates.find(it->first); inputIt = required[0].find(it->first); if (curIt != rates.end() && inputIt != required[0].end() && it->second > 0UL) { unsigned long curTotal = (curIt->second).Tot; unsigned long curNeeded = static_cast(vcl_floor( static_cast(inputIt->second) / static_cast(this->Size()))); needed[it->first] = std::min(curTotal,curNeeded); } else { needed[it->first] = 0UL; } } this->GetNthElement(i)->SetNbOfSamplesByClass(needed); } break; } case CUSTOM: { if (required.size() < this->Size()) { itkGenericExceptionMacro("Not enough values present to set custom requested numbers in all inputs"); } for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetNbOfSamplesByClass(required[i]); } break; } default: itkGenericExceptionMacro("Unknown partition mode"); break; } } void SamplingRateCalculatorList ::SetPercentageOfSamples(std::vector &p, PartitionType t) { if (p.empty()) { itkGenericExceptionMacro("No percentage given"); } this->UpdateGlobalCounts(); ClassCountMapType::const_iterator it; ClassCountMapType needed; switch (t) { case PROPORTIONAL: { for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetPercentageOfSamples(p[0]); } break; } case EQUAL: { needed.clear(); for (it = m_GlobalCountMap.begin(); it != m_GlobalCountMap.end() ; ++it) { needed[it->first]=static_cast(vcl_floor(0.5 + it->second * p[0] / (double)this->Size())); } for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetNbOfSamplesByClass(needed); } break; } case CUSTOM: { if (p.size() < this->Size()) { itkGenericExceptionMacro("Not enough values present to set custom percents in all inputs"); } for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetPercentageOfSamples(p[i]); } break; } default: itkGenericExceptionMacro("Unknown partition mode"); break; } } void SamplingRateCalculatorList ::SetTotalNumberOfSamples(std::vector &tot, PartitionType t) { if (tot.empty()) { itkGenericExceptionMacro("No percentage given"); } this->UpdateGlobalCounts(); ClassCountMapType needed; switch (t) { case PROPORTIONAL: { unsigned long total_nb_samples = 0UL; std::vector nb_samples(this->Size(),0UL); for (unsigned int i=0 ; iSize() ; i++) { // Compute the total number of samples for image i const MapRateType & rates = this->GetNthElement(i)->GetRatesByClass(); for(MapRateType::const_iterator it = rates.begin();it!=rates.end();++it) { nb_samples[i]+=it->second.Tot; } total_nb_samples+=nb_samples[i]; } for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetTotalNumberOfSamples(vcl_floor(0.5+tot[0]*nb_samples[i]/static_cast(total_nb_samples))); } break; } case EQUAL: { unsigned long total_by_image = static_cast(vcl_floor(tot[0]/static_cast(this->Size()))); for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetTotalNumberOfSamples(total_by_image); } break; } case CUSTOM: { if (tot.size() < this->Size()) { itkGenericExceptionMacro("Not enough values present to set total samples in all inputs"); } for (unsigned int i=0 ; iSize() ; i++) { this->GetNthElement(i)->SetTotalNumberOfSamples(tot[i]); } break; } default: itkGenericExceptionMacro("Unknown partition mode"); break; } } void SamplingRateCalculatorList ::UpdateGlobalCounts() { m_GlobalCountMap.clear(); for (unsigned int i=0 ; iSize() ; i++) { const MapRateType &rates = this->GetNthElement(i)->GetRatesByClass(); MapRateType::const_iterator it = rates.begin(); for (; it != rates.end() ; ++it) { m_GlobalCountMap[it->first] += it->second.Tot; } } } } // end of namespace otb OTB-release-5.8/Modules/Learning/Sampling/test/000077500000000000000000000000001301006202600213165ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Sampling/test/CMakeLists.txt000066400000000000000000000104571301006202600240650ustar00rootroot00000000000000otb_module_test() set(OTBSamplingTests otbSamplingTestDriver.cxx otbOGRDataToSamplePositionFilterTest.cxx otbSamplingRateCalculatorTest.cxx otbOGRDataToClassStatisticsFilterTest.cxx otbImageSampleExtractorFilterTest.cxx otbSamplingRateCalculatorListTest.cxx ) add_executable(otbSamplingTestDriver ${OTBSamplingTests}) target_link_libraries(otbSamplingTestDriver ${OTBSampling-Test_LIBRARIES}) otb_module_target_label(otbSamplingTestDriver) # Tests Declaration # ---------------- SamplingRateCalculator ------------------------------------ otb_add_test(NAME leTuSamplingRateCalculatorNew COMMAND otbSamplingTestDriver otbSamplingRateCalculatorNew ) otb_add_test(NAME leTvSamplingRateCalculator COMMAND otbSamplingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvSamplingRateCalculator.txt ${TEMP}/leTvSamplingRateCalculator.txt otbSamplingRateCalculator ${TEMP}/leTvSamplingRateCalculator.txt) # ----------------- OGRDataToSamplePositionFilter ---------------------------- otb_add_test(NAME leTuOGRDataToSamplePositionFilterNew COMMAND otbSamplingTestDriver otbOGRDataToSamplePositionFilterNew ) otb_add_test(NAME leTvOGRDataToSamplePositionFilterPoly COMMAND otbSamplingTestDriver otbOGRDataToSamplePositionFilter ${INPUTDATA}/variousVectors.sqlite 0 ${TEMP}/leTvOGRDataToSamplePositionFilterOutput_Poly.sqlite ${BASELINE_FILES}/leTvOGRDataToSamplePositionFilterOutput_Poly.sqlite ) otb_add_test(NAME leTvOGRDataToSamplePositionFilterPolyPattern COMMAND otbSamplingTestDriver otbOGRDataToSamplePositionFilterPattern ${INPUTDATA}/variousVectors.sqlite ${TEMP}/leTvOGRDataToSamplePositionFilterOutput_PolyPattern.sqlite ${BASELINE_FILES}/leTvOGRDataToSamplePositionFilterOutput_PolyPattern.sqlite ) otb_add_test(NAME leTvOGRDataToSamplePositionFilterLines COMMAND otbSamplingTestDriver otbOGRDataToSamplePositionFilter ${INPUTDATA}/variousVectors.sqlite 1 ${TEMP}/leTvOGRDataToSamplePositionFilterOutput_Lines.sqlite ${BASELINE_FILES}/leTvOGRDataToSamplePositionFilterOutput_Lines.sqlite ) otb_add_test(NAME leTvOGRDataToSamplePositionFilterPoints COMMAND otbSamplingTestDriver otbOGRDataToSamplePositionFilter ${INPUTDATA}/variousVectors.sqlite 2 ${TEMP}/leTvOGRDataToSamplePositionFilterOutput_Points.sqlite ${BASELINE_FILES}/leTvOGRDataToSamplePositionFilterOutput_Points.sqlite ) # --------------- OGRDataToClassStatisticsFilter ----------------------------- otb_add_test(NAME leTuOGRDataToClassStatisticsFilterNew COMMAND otbSamplingTestDriver otbOGRDataToClassStatisticsFilterNew ) otb_add_test(NAME leTvOGRDataToClassStatisticsFilter COMMAND otbSamplingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvOGRDataToClassStatisticsFilterOutput.txt ${TEMP}/leTvOGRDataToClassStatisticsFilterOutput.txt otbOGRDataToClassStatisticsFilter ${INPUTDATA}/variousVectors.sqlite ${TEMP}/leTvOGRDataToClassStatisticsFilterOutput.txt) # --------------- ImageSampleExtractorFilter ----------------------------- otb_add_test(NAME leTuImageSampleExtractorFilterNew COMMAND otbSamplingTestDriver otbImageSampleExtractorFilterNew ) otb_add_test(NAME leTvImageSampleExtractorFilter COMMAND otbSamplingTestDriver --compare-ogr ${EPSILON_6} ${BASELINE_FILES}/leTvImageSampleExtractorFilterTest.sqlite ${TEMP}/leTvImageSampleExtractorFilterTest.sqlite otbImageSampleExtractorFilter ${INPUTDATA}/variousVectors.sqlite ${TEMP}/leTvImageSampleExtractorFilterTest.sqlite) otb_add_test(NAME leTvImageSampleExtractorFilterUpdate COMMAND otbSamplingTestDriver --compare-ogr ${EPSILON_6} ${BASELINE_FILES}/leTvImageSampleExtractorFilterUpdateTest.shp ${TEMP}/leTvImageSampleExtractorFilterUpdateTest.shp otbImageSampleExtractorFilterUpdate ${INPUTDATA}/variousVectors.sqlite ${TEMP}/leTvImageSampleExtractorFilterUpdateTest.shp) # ---------------- SamplingRateCalculatorList --------------------------------- otb_add_test(NAME leTuSamplingRateCalculatorListNew COMMAND otbSamplingTestDriver otbSamplingRateCalculatorListNew ) otb_add_test(NAME leTvSamplingRateCalculatorList COMMAND otbSamplingTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/leTvSamplingRateCalculatorList.txt ${TEMP}/leTvSamplingRateCalculatorList.txt otbSamplingRateCalculatorList ${TEMP}/leTvSamplingRateCalculatorList.txt) OTB-release-5.8/Modules/Learning/Sampling/test/otbImageSampleExtractorFilterTest.cxx000066400000000000000000000127471301006202600306500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageSampleExtractorFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "itkPhysicalPointImageSource.h" #include "itkTimeProbe.h" #include int otbImageSampleExtractorFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::VectorImage InputImageType; typedef otb::ImageSampleExtractorFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbImageSampleExtractorFilter(int argc, char* argv[]) { typedef otb::VectorImage InputImageType; typedef otb::ImageSampleExtractorFilter FilterType; if (argc < 3) { std::cout << "Usage : "< ImageSourceType; ImageSourceType::Pointer imgSource = ImageSourceType::New(); imgSource->SetSize(region.GetSize()); imgSource->SetSpacing(spacing); imgSource->SetOrigin(origin); FilterType::Pointer filter = FilterType::New(); filter->SetInput(imgSource->GetOutput()); filter->SetLayerIndex(2); filter->SetSamplePositions(vectors); filter->SetOutputSamples(output); filter->SetClassFieldName(classFieldName); filter->SetOutputFieldPrefix(outputPrefix); itk::TimeProbe chrono; chrono.Start(); filter->Update(); chrono.Stop(); std::cout << "Extraction took "<< chrono.GetTotal() << " sec" << std::endl; return EXIT_SUCCESS; } int otbImageSampleExtractorFilterUpdate(int argc, char* argv[]) { typedef otb::VectorImage InputImageType; typedef otb::ImageSampleExtractorFilter FilterType; if (argc < 3) { std::cout << "Usage : "<GetLayer(2); OGRSpatialReference * oSRS = inLayer.GetSpatialRef()->Clone(); output->CreateLayer( inLayer.GetName(), oSRS, inLayer.GetLayerDefn().GetGeomType()); otb::ogr::Layer dstLayer = output->GetLayer(0); OGRFieldDefn labelField(classFieldName.c_str(),OFTString); dstLayer.CreateField(labelField, true); const OGRErr err = dstLayer.ogr().StartTransaction(); if (err == OGRERR_NONE) { otb::ogr::Layer::const_iterator featIt = inLayer.begin(); for(; featIt!=inLayer.end(); ++featIt) { otb::ogr::Feature dstFeature(dstLayer.GetLayerDefn()); dstFeature.SetFrom( *featIt, TRUE ); dstLayer.CreateFeature( dstFeature ); } const OGRErr err2 = dstLayer.ogr().CommitTransaction(); if (err2 == OGRERR_NONE) { output->Clear(); otb::ogr::DataSource::Pointer outputUpdate = otb::ogr::DataSource::New(outputPath,otb::ogr::DataSource::Modes::Update_LayerUpdate); typedef itk::PhysicalPointImageSource ImageSourceType; ImageSourceType::Pointer imgSource = ImageSourceType::New(); imgSource->SetSize(region.GetSize()); imgSource->SetSpacing(spacing); imgSource->SetOrigin(origin); FilterType::Pointer filter = FilterType::New(); filter->SetInput(imgSource->GetOutput()); filter->SetLayerIndex(0); filter->SetSamplePositions(outputUpdate); filter->SetOutputSamples(outputUpdate); filter->SetClassFieldName(classFieldName); filter->SetOutputFieldPrefix(outputPrefix); itk::TimeProbe chrono; chrono.Start(); filter->Update(); chrono.Stop(); std::cout << "Extraction took "<< chrono.GetTotal() << " sec" << std::endl; } else { std::cout<< "Unable to commit transaction for OGR layer " << dstLayer.ogr().GetName() << "." << std::endl; return EXIT_FAILURE; } } else { std::cout << "Unable to start transaction for OGR layer " << dstLayer.ogr().GetName() << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Sampling/test/otbOGRDataToClassStatisticsFilterTest.cxx000066400000000000000000000111501301006202600313400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRDataToClassStatisticsFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include int otbOGRDataToClassStatisticsFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::VectorImage InputImageType; typedef otb::Image MaskImageType; typedef otb::OGRDataToClassStatisticsFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbOGRDataToClassStatisticsFilter(int argc, char* argv[]) { typedef otb::VectorImage InputImageType; typedef otb::Image MaskImageType; typedef otb::OGRDataToClassStatisticsFilter FilterType; if (argc < 3) { std::cout << "Usage : "<SetNumberOfComponentsPerPixel(3); inputImage->SetLargestPossibleRegion(region); inputImage->SetOrigin(origin); inputImage->SetSpacing(spacing); // Don't allocate the input image, the filter should not need it //inputImage->Allocate(); //inputImage->FillBuffer(pixel); MaskImageType::Pointer mask = MaskImageType::New(); mask->SetRegions(region); mask->SetOrigin(origin); mask->SetSpacing(spacing); mask->Allocate(); itk::ImageRegionIterator it(mask,region); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd() ; ++it, ++count) { it.Set(count % 2); } std::string fieldName("Label"); FilterType::Pointer filter = FilterType::New(); filter->SetInput(inputImage); filter->SetMask(mask); filter->SetOGRData(vectors); filter->SetFieldName(fieldName); filter->SetLayerIndex(0); filter->Update(); FilterType::ClassCountMapType &classCount = filter->GetClassCountOutput()->Get(); FilterType::PolygonSizeMapType &polySize = filter->GetPolygonSizeOutput()->Get(); FilterType::ClassCountMapType::const_iterator itClass; FilterType::PolygonSizeMapType::const_iterator itPoly; std::ofstream ofs; ofs.open(outputPath.c_str()); ofs << "# Layer 0 : polygons"<first << " = "<< itClass->second << std::endl; } ofs << "# Vector sizes"<first << " = "<< itPoly->second << std::endl; } filter->SetLayerIndex(1); filter->Update(); ofs << "# Layer 1 : lines"<first << " = "<< itClass->second << std::endl; } ofs << "# Vector sizes"<first << " = "<< itPoly->second << std::endl; } filter->SetLayerIndex(2); filter->Update(); ofs << "# Layer 2 : points"<first << " = "<< itClass->second << std::endl; } ofs << "# Vector sizes"<first << " = "<< itPoly->second << std::endl; } ofs.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Sampling/test/otbOGRDataToSamplePositionFilterTest.cxx000066400000000000000000000247721301006202600312040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbOGRDataToSamplePositionFilter.h" #include "otbPatternSampler.h" #include "otbVectorImage.h" #include "otbImage.h" #include // hard-coded rates for the multi-layer OGRDataSource (polygon/lines/points) otb::SamplingRateCalculator::MapRateType GetRatesForMinimumSamples(unsigned int index) { otb::SamplingRateCalculator::MapRateType ratesByClass; otb::SamplingRateCalculator::TripletType triplet; if (index == 0) { // Polygons triplet.Tot = 104; triplet.Required = 104; triplet.Rate = 1.0; ratesByClass[std::string("1")] = triplet; triplet.Tot = 160; triplet.Required = 104; triplet.Rate = 0.65; ratesByClass[std::string("2")] = triplet; triplet.Tot = 211; triplet.Required = 104; triplet.Rate = 0.49289; ratesByClass[std::string("3")] = triplet; } else if (index == 1) { // Lines triplet.Tot = 63; triplet.Required = 27; triplet.Rate = 0.42857; ratesByClass[std::string("1")] = triplet; triplet.Tot = 100; triplet.Required = 27; triplet.Rate = 0.27; ratesByClass[std::string("2")] = triplet; triplet.Tot = 27; triplet.Required = 27; triplet.Rate = 1.0; ratesByClass[std::string("3")] = triplet; } else if (index == 2) { // Points triplet.Tot = 2; triplet.Required = 1; triplet.Rate = 0.5; ratesByClass[std::string("1")] = triplet; triplet.Tot = 1; triplet.Required = 1; triplet.Rate = 1.0; ratesByClass[std::string("2")] = triplet; triplet.Tot = 2; triplet.Required = 1; triplet.Rate = 0.5; ratesByClass[std::string("3")] = triplet; } return ratesByClass; } int TestPositionContainers(otb::ogr::DataSource *output, otb::ogr::DataSource *baseline) { double epsilon=0.01; otb::ogr::Layer baselineLayer = baseline->GetLayer(0); otb::ogr::Layer outputLayer = output->GetLayer(0); otb::ogr::Layer::iterator itBase = baselineLayer.begin(); for (;itBase != baselineLayer.end(); ++itBase) { const OGRGeometry* cstpgeomBase = itBase->GetGeometry(); OGRGeometry* pgeomBase = cstpgeomBase->clone(); OGRPoint* castPointBase = dynamic_cast(pgeomBase); if (castPointBase == NULL) { std::cerr << "Could not dynamic_cast pgeomBase" << std::endl; return EXIT_FAILURE; } else { bool found=false; otb::ogr::Layer::iterator itOutput = outputLayer.begin(); for (;itOutput != outputLayer.end(); ++itOutput) { const OGRGeometry* cstpgeomOutput = itOutput->GetGeometry(); OGRGeometry* pgeomOutput = cstpgeomOutput->clone(); OGRPoint* castPointOutput = dynamic_cast(pgeomOutput); if (castPointOutput == NULL) { std::cerr << "Could not dynamic_cast pgeomOutput" << std::endl; return EXIT_FAILURE; } else { if ( (fabs(castPointBase->getX()-castPointOutput->getX())getY()-castPointOutput->getY())ogr().GetFID(); std::cerr << "Could not find point ("<< castPointBase->getX() << "," << castPointBase->getY() << "); feature ID = " << featureId << "." << std::endl; return EXIT_FAILURE; } } } return EXIT_SUCCESS; } int otbOGRDataToSamplePositionFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::VectorImage InputImageType; typedef otb::Image MaskImageType; typedef otb::OGRDataToSamplePositionFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } int otbOGRDataToSamplePositionFilter(int argc, char* argv[]) { typedef otb::VectorImage InputImageType; typedef otb::Image MaskImageType; if (argc < 5) { std::cout << "Usage : "<SetNumberOfComponentsPerPixel(3); inputImage->SetLargestPossibleRegion(region); inputImage->SetOrigin(origin); inputImage->SetSpacing(spacing); // Don't allocate the input image, the filter should not need it //inputImage->Allocate(); //inputImage->FillBuffer(pixel); MaskImageType::Pointer mask = MaskImageType::New(); mask->SetRegions(region); mask->SetOrigin(origin); mask->SetSpacing(spacing); mask->Allocate(); itk::ImageRegionIterator it(mask,region); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd() ; ++it, ++count) { it.Set(count % 2); } std::string fieldName("Label"); otb::SamplingRateCalculator::MapRateType ratesByClass = GetRatesForMinimumSamples(LayerIndex); otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New(outputPath,otb::ogr::DataSource::Modes::Overwrite); itk::MetaDataDictionary dict; inputImage->SetMetaDataDictionary(dict); mask->SetMetaDataDictionary(dict); //-------------------------------------------------------------- typedef otb::OGRDataToSamplePositionFilter< InputImageType,MaskImageType> SelectionFilterType; SelectionFilterType::Pointer selector = SelectionFilterType::New(); selector->SetInput(inputImage); selector->SetMask(mask); selector->SetOGRData(vectors); selector->SetOutputPositionContainerAndRates(output,ratesByClass); selector->SetFieldName(fieldName); selector->SetLayerIndex(LayerIndex); selector->Update(); otb::ogr::DataSource::Pointer baseline = otb::ogr::DataSource::New(baselineVectorPath, otb::ogr::DataSource::Modes::Read); return TestPositionContainers(output,baseline); } int otbOGRDataToSamplePositionFilterPattern(int argc, char* argv[]) { typedef otb::VectorImage InputImageType; typedef otb::Image MaskImageType; if (argc < 4) { std::cout << "Usage : "<SetNumberOfComponentsPerPixel(3); inputImage->SetLargestPossibleRegion(region); inputImage->SetOrigin(origin); inputImage->SetSpacing(spacing); // Don't allocate the input image, the filter should not need it //inputImage->Allocate(); //inputImage->FillBuffer(pixel); MaskImageType::Pointer mask = MaskImageType::New(); mask->SetRegions(region); mask->SetOrigin(origin); mask->SetSpacing(spacing); mask->Allocate(); itk::ImageRegionIterator it(mask,region); unsigned int count = 0; for (it.GoToBegin(); !it.IsAtEnd() ; ++it, ++count) { it.Set(count % 2); } std::string fieldName("Label"); otb::SamplingRateCalculator::MapRateType ratesByClass = GetRatesForMinimumSamples(LayerIndex); otb::ogr::DataSource::Pointer output = otb::ogr::DataSource::New(outputPath,otb::ogr::DataSource::Modes::Overwrite); //-------------------------------------------------------------- typedef otb::OGRDataToSamplePositionFilter< InputImageType,MaskImageType,otb::PatternSampler> SelectionFilterType; SelectionFilterType::Pointer selector = SelectionFilterType::New(); selector->SetInput(inputImage); selector->SetMask(mask); selector->SetOGRData(vectors); selector->SetOutputPositionContainerAndRates(output,ratesByClass); selector->SetFieldName(fieldName); selector->SetLayerIndex(LayerIndex); // set sampling patterns for polygon layer std::string patternClass1("1111"); std::string patternClass2("1001011011111011011011111011100100111001101110101111110110111110101101011110000110111111100111111110010001011010101101111110011101110011001111111110000101000110"); std::string patternClass3("1000011011111001011011001011100100110001101100101110110110101110101101001100000110011111100111011000010001011010101100011000011100100011001111110110000101000110101101101000001001010010011001010100101000010010110"); otb::PatternSampler::ParameterType param1, param2, param3; param1.Seed = 0UL; param1.MaxPatternSize=0UL; param1.Pattern1 = std::vector(); param1.Pattern2 = std::vector(); param2 = param1; param3 = param1; otb::PatternSampler::ImportPatterns(patternClass1,param1); otb::PatternSampler::ImportPatterns(patternClass2,param2); otb::PatternSampler::ImportPatterns(patternClass3,param3); (selector->GetSamplers())[std::string("1")]->SetParameters(param1); (selector->GetSamplers())[std::string("2")]->SetParameters(param2); (selector->GetSamplers())[std::string("3")]->SetParameters(param3); selector->Update(); otb::ogr::DataSource::Pointer baseline = otb::ogr::DataSource::New(baselineVectorPath, otb::ogr::DataSource::Modes::Read); return TestPositionContainers(output,baseline); } OTB-release-5.8/Modules/Learning/Sampling/test/otbSamplingRateCalculatorListTest.cxx000066400000000000000000000160731301006202600306520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSamplingRateCalculatorList.h" #include "otbStatisticsXMLFileReader.h" #include "itkVariableLengthVector.h" #include int otbSamplingRateCalculatorListNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::SamplingRateCalculatorList RateCalculatorListType; RateCalculatorListType::Pointer rateCalculator = RateCalculatorListType::New(); std::cout << rateCalculator << std::endl; return EXIT_SUCCESS; } int otbSamplingRateCalculatorList(int itkNotUsed(argc), char* argv[]) { std::ofstream file(argv[1], std::ios::out | std::ios::trunc); if (!file) { std::cout << " Couldn't open " << argv[1]; return EXIT_FAILURE; } itk::Indent indent_1(1); typedef otb::SamplingRateCalculatorList::ClassCountMapType ClassCountMapType; typedef otb::SamplingRateCalculatorList::PartitionType PartitionType; PartitionType typeProportional = otb::SamplingRateCalculatorList::PROPORTIONAL; PartitionType typeEqual = otb::SamplingRateCalculatorList::EQUAL; PartitionType typeCustom = otb::SamplingRateCalculatorList::CUSTOM; std::string c1("1"); std::string c2("2"); std::string c3("3"); std::string c4("4"); ClassCountMapType classCount1, classCount2, classCount3; // input 1 classCount1[c1] = 104; classCount1[c2] = 160; classCount1[c3] = 211; // input 2 classCount2[c1] = 98; classCount2[c2] = 190; classCount2[c3] = 178; // input 3 classCount3[c1] = 130; classCount3[c2] = 144; classCount3[c4] = 250; std::vector nbSamplesCst; nbSamplesCst.push_back(151); std::vector percent; percent.push_back(0.33); std::vector total; total.push_back(300); std::vector nbSamplesCstCustom; nbSamplesCstCustom.push_back(70); nbSamplesCstCustom.push_back(80); nbSamplesCstCustom.push_back(90); ClassCountMapType needed1; needed1[c1] = 140; needed1[c2] = 130; needed1[c3] = 124; std::vector nbByClass; nbByClass.push_back(needed1); ClassCountMapType needed2; needed2[c1] = 67; needed2[c2] = 55; needed2[c3] = 72; ClassCountMapType needed3; needed3[c1] = 77; needed3[c2] = 69; needed3[c3] = 34; ClassCountMapType needed4; needed4[c1] = 86; needed4[c2] = 43; needed4[c4] = 98; std::vector nbByClassCustom; nbByClassCustom.push_back(needed2); nbByClassCustom.push_back(needed3); nbByClassCustom.push_back(needed4); typedef otb::SamplingRateCalculatorList RateCalculatorListType; RateCalculatorListType::Pointer rateCalcList = RateCalculatorListType::New(); rateCalcList->SetNthClassCount(0,classCount1); rateCalcList->SetNthClassCount(2,classCount3); rateCalcList->SetNthClassCount(1,classCount2); file << "# Test the strategy : smallest - equal" << std::endl; rateCalcList->SetMinimumNbOfSamplesByClass(typeEqual); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : smallest - custom" << std::endl; rateCalcList->SetMinimumNbOfSamplesByClass(typeCustom); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : constant - proportional" << std::endl; rateCalcList->SetNbOfSamplesAllClasses(nbSamplesCst,typeProportional); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : constant - equal" << std::endl; rateCalcList->SetNbOfSamplesAllClasses(nbSamplesCst,typeEqual); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : constant - custom" << std::endl; rateCalcList->SetNbOfSamplesAllClasses(nbSamplesCstCustom,typeCustom); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : byClass - proportional" << std::endl; rateCalcList->SetNbOfSamplesByClass(nbByClass,typeProportional); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : byClass - equal" << std::endl; rateCalcList->SetNbOfSamplesByClass(nbByClass,typeEqual); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : byClass - custom" << std::endl; rateCalcList->SetNbOfSamplesByClass(nbByClassCustom,typeCustom); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file << "# Test the strategy : all - equal" << std::endl; rateCalcList->SetAllSamples(typeEqual); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file <<"#Test the strategy : percent - proportional"<SetPercentageOfSamples(percent,typeProportional); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file <<"#Test the strategy : percent - equal"<SetPercentageOfSamples(percent,typeEqual); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file <<"#Test the strategy : total - proportional"<SetTotalNumberOfSamples(total,typeProportional); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file <<"#Test the strategy : total - equal"<SetTotalNumberOfSamples(total,typeEqual); for (unsigned int i=0 ; iSize() ; i++) { file << "# Input "<< i << std::endl; rateCalcList->GetNthElement(i)->Print(file, indent_1); } file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Sampling/test/otbSamplingRateCalculatorTest.cxx000066400000000000000000000037501301006202600300140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSamplingRateCalculator.h" #include "otbStatisticsXMLFileReader.h" #include "itkVariableLengthVector.h" int otbSamplingRateCalculatorNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef otb::SamplingRateCalculator RateCalculatorype; RateCalculatorype::Pointer rateCalculator = RateCalculatorype::New(); std::cout << rateCalculator << std::endl; return EXIT_SUCCESS; } int otbSamplingRateCalculator(int itkNotUsed(argc), char* argv[]) { std::string outputRatesTxt(argv[1]); typedef otb::SamplingRateCalculator::ClassCountMapType ClassCountMapType; ClassCountMapType classCount; classCount[std::string("1")] = 104; classCount[std::string("2")] = 160; classCount[std::string("3")] = 211; unsigned int nbSamples = 83; typedef otb::SamplingRateCalculator RateCalculatorype; RateCalculatorype::Pointer rateCalculator = RateCalculatorype::New(); rateCalculator->SetClassCount(classCount); rateCalculator->SetNbOfSamplesAllClasses(nbSamples); rateCalculator->Write(outputRatesTxt); rateCalculator->Print(std::cout); // Read back RateCalculatorype::Pointer rateCalculatorCheck = RateCalculatorype::New(); rateCalculatorCheck->Read(outputRatesTxt); if ( rateCalculator->GetRatesByClass() != rateCalculatorCheck->GetRatesByClass() ) { std::cout << "Imported rates by class are different from exported ones!" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Sampling/test/otbSamplingTestDriver.cxx000066400000000000000000000012271301006202600263370ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbSamplingRateCalculatorNew); REGISTER_TEST(otbSamplingRateCalculator); REGISTER_TEST(otbOGRDataToSamplePositionFilterNew); REGISTER_TEST(otbOGRDataToSamplePositionFilter); REGISTER_TEST(otbOGRDataToSamplePositionFilterPattern); REGISTER_TEST(otbOGRDataToClassStatisticsFilterNew); REGISTER_TEST(otbOGRDataToClassStatisticsFilter); REGISTER_TEST(otbImageSampleExtractorFilterNew); REGISTER_TEST(otbImageSampleExtractorFilter); REGISTER_TEST(otbImageSampleExtractorFilterUpdate); REGISTER_TEST(otbSamplingRateCalculatorListNew); REGISTER_TEST(otbSamplingRateCalculatorList); } OTB-release-5.8/Modules/Learning/Supervised/000077500000000000000000000000001301006202600207165ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/CMakeLists.txt000066400000000000000000000001261301006202600234550ustar00rootroot00000000000000project(OTBSupervised) set(OTBSupervised_LIBRARIES OTBSupervised) otb_module_impl() OTB-release-5.8/Modules/Learning/Supervised/include/000077500000000000000000000000001301006202600223415ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/include/otbBoostMachineLearningModel.h000066400000000000000000000117231301006202600302370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoostMachineLearningModel_h #define otbBoostMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" class CvBoost; namespace otb { template class ITK_EXPORT BoostMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef BoostMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(BoostMachineLearningModel, MachineLearningModel); /** Setters/Getters to the Boost type * It can be CvBoost::DISCRETE, CvBoost::REAL, CvBoost::LOGIT, CvBoost::GENTLE * Default is CvBoost::REAL. * \see http://docs.opencv.org/modules/ml/doc/boosting.html#cvboostparams-cvboostparams */ itkGetMacro(BoostType, int); itkSetMacro(BoostType, int); /** Setters/Getters to the split criteria * It can be CvBoost::DEFAULT, CvBoost::GINI, CvBoost::MISCLASS, CvBoost::SQERR * Default is CvBoost::DEFAULT. It uses default value according to \c BoostType * \see http://docs.opencv.org/modules/ml/doc/boosting.html#cvboost-predict */ itkGetMacro(SplitCrit, int); itkSetMacro(SplitCrit, int); /** Setters/Getters to the number of weak classifiers. * Default is 100. * \see http://docs.opencv.org/modules/ml/doc/boosting.html#cvboostparams-cvboostparams */ itkGetMacro(WeakCount, int); itkSetMacro(WeakCount, int); /** Setters/Getters to the threshold WeightTrimRate. * A threshold between 0 and 1 used to save computational time. * Samples with summary weight \f$ w \leq 1 - WeightTrimRate \f$ do not participate in the next iteration of training. * Set this parameter to 0 to turn off this functionality. * Default is 0.95 * \see http://docs.opencv.org/modules/ml/doc/boosting.html#cvboostparams-cvboostparams */ itkGetMacro(WeightTrimRate, double); itkSetMacro(WeightTrimRate, double); /** Setters/Getters to the maximum depth of the tree. * Default is 1 * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(MaxDepth, int); itkSetMacro(MaxDepth, int); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} protected: /** Constructor */ BoostMachineLearningModel(); /** Destructor */ ~BoostMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: BoostMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CvBoost * m_BoostModel; int m_BoostType; int m_WeakCount; double m_WeightTrimRate; int m_SplitCrit; int m_MaxDepth; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBoostMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbBoostMachineLearningModel.txx000066400000000000000000000111471301006202600306330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoostMachineLearningModel_txx #define otbBoostMachineLearningModel_txx #include "otbBoostMachineLearningModel.h" #include "otbOpenCVUtils.h" #include #include "itkMacro.h" namespace otb { template BoostMachineLearningModel ::BoostMachineLearningModel() : m_BoostModel (new CvBoost), m_BoostType(CvBoost::REAL), m_WeakCount(100), m_WeightTrimRate(0.95), m_SplitCrit(CvBoost::DEFAULT), m_MaxDepth(1) { this->m_ConfidenceIndex = true; } template BoostMachineLearningModel ::~BoostMachineLearningModel() { delete m_BoostModel; } /** Train the machine learning model */ template void BoostMachineLearningModel ::Train() { //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); cv::Mat labels; otb::ListSampleToMat(this->GetTargetListSample(),labels); CvBoostParams params = CvBoostParams(m_BoostType, m_WeakCount, m_WeightTrimRate, m_MaxDepth, false, ITK_NULLPTR); params.split_criteria = m_SplitCrit; //train the Boost model cv::Mat var_type = cv::Mat(this->GetInputListSample()->GetMeasurementVectorSize() + 1, 1, CV_8U ); var_type.setTo(cv::Scalar(CV_VAR_NUMERICAL) ); // all inputs are numerical var_type.at(this->GetInputListSample()->GetMeasurementVectorSize(), 0) = CV_VAR_CATEGORICAL; m_BoostModel->train(samples,CV_ROW_SAMPLE,labels,cv::Mat(),cv::Mat(),var_type,cv::Mat(),params); } template typename BoostMachineLearningModel ::TargetSampleType BoostMachineLearningModel ::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(input,sample); cv::Mat missing = cv::Mat(1,input.Size(), CV_8U ); missing.setTo(0); double result = m_BoostModel->predict(sample,missing); TargetSampleType target; target[0] = static_cast(result); if (quality != ITK_NULLPTR) { (*quality) = static_cast( m_BoostModel->predict(sample,missing,cv::Range::all(),false,true)); } return target; } template void BoostMachineLearningModel ::Save(const std::string & filename, const std::string & name) { if (name == "") m_BoostModel->save(filename.c_str(), ITK_NULLPTR); else m_BoostModel->save(filename.c_str(), name.c_str()); } template void BoostMachineLearningModel ::Load(const std::string & filename, const std::string & name) { if (name == "") m_BoostModel->load(filename.c_str(), ITK_NULLPTR); else m_BoostModel->load(filename.c_str(), name.c_str()); } template bool BoostMachineLearningModel ::CanReadFile(const std::string & file) { std::ifstream ifs; ifs.open(file.c_str()); if(!ifs) { std::cerr<<"Could not read file "<getName()) != std::string::npos) if (line.find(CV_TYPE_NAME_ML_BOOSTING) != std::string::npos) { //std::cout<<"Reading a "< bool BoostMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void BoostMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbBoostMachineLearningModelFactory.h000066400000000000000000000044231301006202600315660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoostMachineLearningModelFactory_h #define otbBoostMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class BoostMachineLearningModelFactory * \brief Creation d'un instance d'un objet SVMMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT BoostMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef BoostMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BoostMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer Factory = BoostMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(Factory); } protected: BoostMachineLearningModelFactory(); ~BoostMachineLearningModelFactory() ITK_OVERRIDE; private: BoostMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBoostMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbBoostMachineLearningModelFactory.txx000066400000000000000000000036631301006202600321670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoostMachineLearningModelFactory_txx #define otbBoostMachineLearningModelFactory_txx #include "otbBoostMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbBoostMachineLearningModel.h" #include "itkVersion.h" namespace otb { template BoostMachineLearningModelFactory ::BoostMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbBoostMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "Boost ML Model", 1, itk::CreateObjectFunction >::New()); } template BoostMachineLearningModelFactory ::~BoostMachineLearningModelFactory() { } template const char* BoostMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* BoostMachineLearningModelFactory ::GetDescription() const { return "Boost machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbConfusionMatrixCalculator.h000066400000000000000000000154621301006202600303710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConfusionMatrixCalculator_h #define otbConfusionMatrixCalculator_h #include "otbMacro.h" #include "otbConfusionMatrixMeasurements.h" namespace otb { /** \class ConfusionMatrixCalculator * This class computes a confusion matrix from 2 lists of labels. It * assumes that the 2 lists have the same length and uses the * position of the labels in the lists to build the pairs * reference/produced labels. * * The rows and columns of the output confusion matrix are sorted according to increasing class labels. * * For a 2 classes problem, the confusion matrix is organized as follows: * \f[ \left( \begin{array}{cc} True Positives & False Negatives \\ False Positives & True Negatives \end{array} \right) \f] * * Please note that when accessing the confusion matrix values, the first index is the row index (reference samples), * and the second is the column index (produced samples), so that accessing the false positive rate is done by * calling GetConfusionMatrix()[1, 0] for the case of a 2 classes problem. * * Some measurements are computed by this class: * If we consider true positive (TP), true negative (TN), false positive (FP) and false negative (FP) rates, then in the 2 classes case: * \f[ precision = \frac{TP}{\left( TP + FP \right) } \f] * \f[ recall = \frac{TP}{\left( TP + FN \right) } \f] * \f[ FScore = \frac{2 * precision * recall}{\left( precision + recall \right) } \f] * * In case of multiclasses problem, these measurements are extended by considering one class versus others. * * Moreover overall accuracy and \f[ \kappa \f] index are computed. * * \ingroup OTBSupervised */ template class ITK_EXPORT ConfusionMatrixCalculator : public itk::Object { public: /** Standard class typedefs */ typedef ConfusionMatrixCalculator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ConfusionMatrixCalculator, itk::Object); /** Method for creation through the object factory. */ itkNewMacro(Self); /** List to store the corresponding labels */ typedef TRefListLabel RefListLabelType; typedef typename RefListLabelType::Pointer RefListLabelPointerType; typedef TProdListLabel ProdListLabelType; typedef typename ProdListLabelType::Pointer ProdListLabelPointerType; typedef typename RefListLabelType::ValueType::ValueType ClassLabelType; typedef std::map MapOfClassesType; typedef std::map MapOfIndicesType; /** Type for the confusion matrix */ typedef itk::VariableSizeMatrix ConfusionMatrixType; /** Type for the confusion matrix measurements calculator*/ typedef otb::ConfusionMatrixMeasurements ConfusionMatrixMeasurementsType; /** Type for the measurement */ typedef itk::VariableLengthVector MeasurementType; /** * \deprecated in OTB 3.16, please use void Compute(void) instead. */ itkLegacyMacro( virtual void Update() ); /** Computes m_ConfusionMatrix and then the measurements over it. */ void Compute(void); /** Accessors */ itkSetObjectMacro(ReferenceLabels, RefListLabelType); itkGetConstObjectMacro(ReferenceLabels, RefListLabelType); itkSetObjectMacro(ProducedLabels, ProdListLabelType); itkGetConstObjectMacro(ProducedLabels, ProdListLabelType); itkGetMacro(TruePositiveValues, MeasurementType); itkGetMacro(TrueNegativeValues, MeasurementType); itkGetMacro(FalsePositiveValues, MeasurementType); itkGetMacro(FalseNegativeValues, MeasurementType); itkGetMacro(TruePositiveValue, double); itkGetMacro(TrueNegativeValue, double); itkGetMacro(FalsePositiveValue, double); itkGetMacro(FalseNegativeValue, double); itkGetMacro(KappaIndex, double); itkGetMacro(OverallAccuracy, double); itkGetMacro(Precisions, MeasurementType); itkGetMacro(Recalls, MeasurementType); itkGetMacro(FScores, MeasurementType); itkGetMacro(Precision, double); itkGetMacro(Recall, double); itkGetMacro(FScore, double); itkGetMacro(NumberOfClasses, unsigned short); itkGetMacro(NumberOfSamples, unsigned long); itkGetMacro(ConfusionMatrix, ConfusionMatrixType); /* Gives the correspondence between a class label * and its index in the confusion matrix */ MapOfClassesType GetMapOfClasses() const { return m_MapOfClasses; } /* Gives the correspondence between an index in the * confusion matrix and the class label */ MapOfIndicesType GetMapOfIndices() const { return m_MapOfIndices; } protected: ConfusionMatrixCalculator(); ~ConfusionMatrixCalculator() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ConfusionMatrixCalculator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_KappaIndex; double m_OverallAccuracy; MeasurementType m_FalseNegativeValues; MeasurementType m_TrueNegativeValues; MeasurementType m_FalsePositiveValues; MeasurementType m_TruePositiveValues; MeasurementType m_Precisions; MeasurementType m_Recalls; MeasurementType m_FScores; double m_FalseNegativeValue; double m_TrueNegativeValue; double m_FalsePositiveValue; double m_TruePositiveValue; double m_Precision; double m_Recall; double m_FScore; MapOfClassesType m_MapOfClasses; MapOfIndicesType m_MapOfIndices; unsigned short m_NumberOfClasses; unsigned long m_NumberOfSamples; ConfusionMatrixType m_ConfusionMatrix; typename ConfusionMatrixMeasurementsType::Pointer m_ConfMatMeasurements; RefListLabelPointerType m_ReferenceLabels; ProdListLabelPointerType m_ProducedLabels; }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConfusionMatrixCalculator.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbConfusionMatrixCalculator.txx000066400000000000000000000127631301006202600307660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConfusionMatrixCalculator_txx #define otbConfusionMatrixCalculator_txx #include "otbConfusionMatrixCalculator.h" namespace otb { template ConfusionMatrixCalculator ::ConfusionMatrixCalculator() : m_KappaIndex(0.0), m_OverallAccuracy(0.0), m_FalseNegativeValue(0.0), m_TrueNegativeValue(0.0), m_FalsePositiveValue(0.0), m_TruePositiveValue(0.0), m_Precision(0.0), m_Recall(0.0), m_FScore(0.0), m_NumberOfClasses(0), m_NumberOfSamples(0) { m_ConfusionMatrix = ConfusionMatrixType(m_NumberOfClasses, m_NumberOfClasses); m_ConfusionMatrix.Fill(0); m_ConfMatMeasurements = ConfusionMatrixMeasurementsType::New(); m_ReferenceLabels = RefListLabelType::New(); m_ProducedLabels = ProdListLabelType::New(); } #if !defined(ITK_LEGACY_REMOVE) template void ConfusionMatrixCalculator ::Update() { itkWarningMacro("otb::ConfusionMatrixCalculator::Update() is DEPRECATED. " "Use otb::ConfusionMatrixCalculator::Compute() instead."); this->Compute(); } #endif template void ConfusionMatrixCalculator ::Compute() { typename RefListLabelType::ConstIterator refIterator = m_ReferenceLabels->Begin(); typename ProdListLabelType::ConstIterator prodIterator = m_ProducedLabels->Begin(); //check that both lists have the same number of samples if ( (m_ReferenceLabels->Size() != m_ProducedLabels->Size()) || (m_ReferenceLabels->Size() == 0 ) || (m_ProducedLabels->Size() == 0 ) ) { otbMsgDebugMacro(<< "refLabels size = " << m_ReferenceLabels->Size() << " / proLabels size = " << m_ProducedLabels->Size()); throw itk::ExceptionObject(__FILE__, __LINE__, "ListSample size mismatch", ITK_LOCATION); } m_NumberOfSamples = m_ReferenceLabels->Size(); // count the number of classes int countClasses = 0; while (refIterator != m_ReferenceLabels->End()) { ClassLabelType currentLabel = refIterator.GetMeasurementVector()[0]; if (m_MapOfClasses.find(currentLabel) == m_MapOfClasses.end()) { m_MapOfClasses[currentLabel] = countClasses; m_MapOfIndices[countClasses] = currentLabel; ++countClasses; } ++refIterator; } m_NumberOfClasses = countClasses; // SORTING of m_MapOfClasses and m_MapOfIndices according to increasing class labels typename MapOfClassesType::iterator itMapOfClasses; itMapOfClasses = m_MapOfClasses.begin(); unsigned int itElt = 0; while (itMapOfClasses != m_MapOfClasses.end()) { ClassLabelType currentLabel = itMapOfClasses->first; m_MapOfClasses[currentLabel] = itElt; m_MapOfIndices[itElt] = currentLabel; ++itMapOfClasses; ++itElt; } std::vector samplesPerClass; for (unsigned int i = 0; i < m_NumberOfClasses; ++i) samplesPerClass.push_back(0); m_ConfusionMatrix = ConfusionMatrixType(m_NumberOfClasses, m_NumberOfClasses); m_ConfusionMatrix.Fill(0); refIterator = m_ReferenceLabels->Begin(); prodIterator = m_ProducedLabels->Begin(); while (refIterator != m_ReferenceLabels->End()) { int refLabel = refIterator.GetMeasurementVector()[0]; int prodLabel = prodIterator.GetMeasurementVector()[0]; int refPos = m_MapOfClasses[refLabel]; int prodPos = m_MapOfClasses[prodLabel]; ++samplesPerClass[refPos]; m_ConfusionMatrix(refPos, prodPos) += 1; ++refIterator; ++prodIterator; } m_ConfMatMeasurements->SetConfusionMatrix(m_ConfusionMatrix); m_ConfMatMeasurements->Compute(); this->m_TruePositiveValues = m_ConfMatMeasurements->GetTruePositiveValues(); this->m_FalseNegativeValues = m_ConfMatMeasurements->GetFalseNegativeValues(); this->m_TrueNegativeValues = m_ConfMatMeasurements->GetTrueNegativeValues(); this->m_FalsePositiveValues = m_ConfMatMeasurements->GetFalsePositiveValues(); this->m_Precisions = m_ConfMatMeasurements->GetPrecisions(); this->m_Recalls = m_ConfMatMeasurements->GetRecalls(); this->m_FScores = m_ConfMatMeasurements->GetFScores(); this->m_TruePositiveValue = m_ConfMatMeasurements->GetTruePositiveValue(); this->m_FalseNegativeValue = m_ConfMatMeasurements->GetFalseNegativeValue(); this->m_TrueNegativeValue = m_ConfMatMeasurements->GetTrueNegativeValue(); this->m_FalsePositiveValue = m_ConfMatMeasurements->GetFalsePositiveValue(); this->m_Precision = m_ConfMatMeasurements->GetPrecision(); this->m_Recall = m_ConfMatMeasurements->GetRecall(); this->m_FScore = m_ConfMatMeasurements->GetFScore(); this->m_OverallAccuracy = m_ConfMatMeasurements->GetOverallAccuracy(); this->m_KappaIndex = m_ConfMatMeasurements->GetKappaIndex(); } template void ConfusionMatrixCalculator ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "TODO"; } } #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbConfusionMatrixMeasurements.h000066400000000000000000000135701301006202600307460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConfusionMatrixMeasurements_h #define otbConfusionMatrixMeasurements_h #include "itkObject.h" #include "itkObjectFactory.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" namespace otb { /** \class ConfusionMatrixMeasurements * This class computes measurements on the input confusion matrix. * * For a 2 classes problem, the confusion matrix is organized as follows: * \f[ \left( \begin{array}{cc} True Positives & False Negatives \\ False Positives & True Negatives \end{array} \right) \f] * * Please note that when accessing the confusion matrix values, the first index is the row index (reference samples), * and the second is the column index (produced samples). * * Some measurements are computed by this class: * If we consider true positive (TP), true negative (TN), false positive (FP) and false negative (FP) rates, then in the 2 classes case: * \f[ precision = \frac{TP}{\left( TP + FP \right) } \f] * \f[ recall = \frac{TP}{\left( TP + FN \right) } \f] * \f[ FScore = \frac{2 * precision * recall}{\left( precision + recall \right) } \f] * * Moreover overall accuracy and \f[ \kappa \f] index are computed. * * * \ingroup OTBSupervised */ template , class TLabel = int > class ITK_EXPORT ConfusionMatrixMeasurements : public itk::Object { public: /** Standard class typedefs */ typedef ConfusionMatrixMeasurements Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ConfusionMatrixMeasurements, itk::Object); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TLabel ClassLabelType; typedef std::map MapOfClassesType; typedef std::map MapOfIndicesType; /** Type for the confusion matrix */ typedef TConfusionMatrix ConfusionMatrixType; /** Type for the measurement */ typedef itk::VariableLengthVector MeasurementType; /** Computes the measurements over m_ConfusionMatrix. */ void Compute(void); /** Accessors */ itkSetMacro(ConfusionMatrix, ConfusionMatrixType); itkGetMacro(TruePositiveValues, MeasurementType); itkGetMacro(TrueNegativeValues, MeasurementType); itkGetMacro(FalsePositiveValues, MeasurementType); itkGetMacro(FalseNegativeValues, MeasurementType); itkGetMacro(TruePositiveValue, double); itkGetMacro(TrueNegativeValue, double); itkGetMacro(FalsePositiveValue, double); itkGetMacro(FalseNegativeValue, double); itkGetMacro(KappaIndex, double); itkGetMacro(OverallAccuracy, double); itkGetMacro(Precisions, MeasurementType); itkGetMacro(Recalls, MeasurementType); itkGetMacro(FScores, MeasurementType); itkGetMacro(Precision, double); itkGetMacro(Recall, double); itkGetMacro(FScore, double); itkGetMacro(NumberOfClasses, unsigned short); itkGetMacro(NumberOfSamples, unsigned long); /* Gives the correspondence between a class label * and its index in the confusion matrix */ virtual void SetMapOfClasses(const MapOfClassesType _arg) { m_MapOfClasses = _arg; typename MapOfClassesType::iterator itMapOfClasses; m_MapOfIndices.clear(); for (itMapOfClasses = m_MapOfClasses.begin(); itMapOfClasses != m_MapOfClasses.end(); ++itMapOfClasses) { m_MapOfIndices[itMapOfClasses->second] = itMapOfClasses->first; } } MapOfClassesType GetMapOfClasses() const { return m_MapOfClasses; } /* Gives the correspondence between an index in the * confusion matrix and the class label */ virtual void SetMapOfIndices(const MapOfIndicesType _arg) { m_MapOfIndices = _arg; typename MapOfIndicesType::iterator itMapOfIndices; m_MapOfClasses.clear(); for (itMapOfIndices = m_MapOfIndices.begin(); itMapOfIndices != m_MapOfIndices.end(); ++itMapOfIndices) { m_MapOfClasses[itMapOfIndices->second] = itMapOfIndices->first; } } MapOfIndicesType GetMapOfIndices() const { return m_MapOfIndices; } protected: ConfusionMatrixMeasurements(); ~ConfusionMatrixMeasurements() ITK_OVERRIDE {} //void PrintSelf(std::ostream& os, itk::Indent indent) const; private: ConfusionMatrixMeasurements(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double m_KappaIndex; double m_OverallAccuracy; MeasurementType m_FalseNegativeValues; MeasurementType m_TrueNegativeValues; MeasurementType m_FalsePositiveValues; MeasurementType m_TruePositiveValues; MeasurementType m_Precisions; MeasurementType m_Recalls; MeasurementType m_FScores; double m_FalseNegativeValue; double m_TrueNegativeValue; double m_FalsePositiveValue; double m_TruePositiveValue; double m_Precision; double m_Recall; double m_FScore; MapOfClassesType m_MapOfClasses; MapOfIndicesType m_MapOfIndices; unsigned short m_NumberOfClasses; unsigned long m_NumberOfSamples; ConfusionMatrixType m_ConfusionMatrix; }; } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbConfusionMatrixMeasurements.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbConfusionMatrixMeasurements.txx000066400000000000000000000136461301006202600313460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConfusionMatrixMeasurements_txx #define otbConfusionMatrixMeasurements_txx #include "otbConfusionMatrixMeasurements.h" namespace otb { template ConfusionMatrixMeasurements ::ConfusionMatrixMeasurements() : m_KappaIndex(0.0), m_OverallAccuracy(0.0), m_FalseNegativeValue(0.0), m_TrueNegativeValue(0.0), m_FalsePositiveValue(0.0), m_TruePositiveValue(0.0), m_NumberOfClasses(0), m_NumberOfSamples(0) { m_ConfusionMatrix = ConfusionMatrixType(m_NumberOfClasses, m_NumberOfClasses); m_ConfusionMatrix.Fill(0); } template void ConfusionMatrixMeasurements ::Compute() { m_NumberOfClasses = m_ConfusionMatrix.Rows(); m_FalseNegativeValues = MeasurementType(m_NumberOfClasses); m_TrueNegativeValues = MeasurementType(m_NumberOfClasses); m_FalsePositiveValues = MeasurementType(m_NumberOfClasses); m_TruePositiveValues = MeasurementType(m_NumberOfClasses); m_FalseNegativeValues.Fill(0); m_FalsePositiveValues.Fill(0); m_TruePositiveValues.Fill(0); m_TrueNegativeValues.Fill(0); const double epsilon = 0.0000000001; double luckyRate = 0.; this->m_NumberOfSamples = 0; this->m_OverallAccuracy = 0.; for (unsigned int i = 0; i < m_NumberOfClasses; ++i) { double sum_along_row_i = 0.; double sum_along_column_i = 0.; for (unsigned int j = 0; j < m_NumberOfClasses; ++j) { sum_along_row_i += m_ConfusionMatrix(i, j); sum_along_column_i += m_ConfusionMatrix(j, i); this->m_NumberOfSamples += m_ConfusionMatrix(i, j); // i != j if (i != j) { this->m_FalseNegativeValues[i] += m_ConfusionMatrix(i, j); this->m_FalsePositiveValues[i] += m_ConfusionMatrix(j, i); } // i == j else { this->m_OverallAccuracy += m_ConfusionMatrix(i, i); this->m_TruePositiveValues[i] = m_ConfusionMatrix(i, i); } } luckyRate += sum_along_row_i * sum_along_column_i; } this->m_TrueNegativeValues.Fill(m_NumberOfSamples); this->m_TrueNegativeValues -= this->m_FalseNegativeValues + this->m_FalsePositiveValues + this->m_TruePositiveValues; if (m_NumberOfClasses == 2) { this->m_TruePositiveValue = m_ConfusionMatrix(0, 0); this->m_FalseNegativeValue = m_ConfusionMatrix(0, 1); this->m_FalsePositiveValue = m_ConfusionMatrix(1, 0); this->m_TrueNegativeValue = m_ConfusionMatrix(1, 1); /*std::cout << "TP= " << this->m_TruePositiveValue << std::endl; std::cout << "FN= " << this->m_FalseNegativeValue << std::endl; std::cout << "FP= " << this->m_FalsePositiveValue << std::endl; std::cout << "TN= " << this->m_TrueNegativeValue << std::endl; */ } else { /*std::cout << "TP= " << this->m_TruePositiveValues << std::endl; std::cout << "FN= " << this->m_FalseNegativeValues << std::endl; std::cout << "FP= " << this->m_FalsePositiveValues << std::endl; std::cout << "TN= " << this->m_TrueNegativeValues << std::endl; */ } m_Precisions = MeasurementType(m_NumberOfClasses); m_Recalls = MeasurementType(m_NumberOfClasses); m_FScores = MeasurementType(m_NumberOfClasses); m_Precisions.Fill(0.); m_Recalls.Fill(0.); m_FScores.Fill(0.); if (m_NumberOfSamples > 0) { this->m_OverallAccuracy /= static_cast(m_NumberOfSamples); luckyRate /= vcl_pow(m_NumberOfSamples, 2.0); if (vcl_abs(1 - luckyRate) > epsilon) { m_KappaIndex = (m_OverallAccuracy - luckyRate) / (1 - luckyRate); } else { this->m_KappaIndex = 1.; } } else { this->m_OverallAccuracy = 0.; this->m_KappaIndex = 0.; // no samples, no need to continue return; } for (unsigned int i = 0; i < m_NumberOfClasses; ++i) { if (vcl_abs(this->m_TruePositiveValues[i] + this->m_FalsePositiveValues[i]) > epsilon) { this->m_Precisions[i] = this->m_TruePositiveValues[i] / (this->m_TruePositiveValues[i] + this->m_FalsePositiveValues[i]); } if (vcl_abs(this->m_TruePositiveValues[i] + this->m_FalseNegativeValues[i]) > epsilon) { this->m_Recalls[i] = this->m_TruePositiveValues[i] / (this->m_TruePositiveValues[i] + this->m_FalseNegativeValues[i]); } if (vcl_abs(this->m_Recalls[i] + this->m_Precisions[i]) > epsilon) { this->m_FScores[i] = 2 * this->m_Recalls[i] * this->m_Precisions[i] / (this->m_Recalls[i] + this->m_Precisions[i]); } } if (m_NumberOfClasses == 2) { if (vcl_abs(this->m_TruePositiveValue + this->m_FalsePositiveValue) > epsilon) { this->m_Precision = this->m_TruePositiveValue / (this->m_TruePositiveValue + this->m_FalsePositiveValue); } if (vcl_abs(this->m_TruePositiveValue + this->m_FalseNegativeValue) > epsilon) { this->m_Recall = this->m_TruePositiveValue / (this->m_TruePositiveValue + this->m_FalseNegativeValue); } if (vcl_abs(this->m_Recall + this->m_Precision) > epsilon) { this->m_FScore = 2 * this->m_Recall * this->m_Precision / (this->m_Recall + this->m_Precision); } } } /* template void ConfusionMatrixMeasurements ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "TODO"; }*/ } #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbCvRTreesWrapper.h000066400000000000000000000036071301006202600262630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbCvRTreesWrapper_h #define otbCvRTreesWrapper_h #include "otbOpenCVUtils.h" #include namespace otb { /** \class CvRTreesWrapper * \brief Wrapper for OpenCV Random Trees * * \ingroup OTBSupervised */ class OTBSupervised_EXPORT CvRTreesWrapper : public CvRTrees { public: typedef std::vector VotesVectorType; CvRTreesWrapper(); ~CvRTreesWrapper() ITK_OVERRIDE; /** Compute the number of votes for each class. */ void get_votes(const cv::Mat& sample, const cv::Mat& missing, VotesVectorType& vote_count) const; /** Predict the confidence of the classifcation by computing the proportion of trees which voted for the majority class. */ float predict_confidence(const cv::Mat& sample, const cv::Mat& missing = cv::Mat()) const; /** Predict the confidence margin of the classifcation by computing the difference in votes between the first and second most voted classes. This measure is preferred to the proportion of votes of the majority class, since it provides information about the conflict between the most likely classes. */ float predict_margin(const cv::Mat& sample, const cv::Mat& missing = cv::Mat()) const; }; } #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbDecisionTreeMachineLearningModel.h000066400000000000000000000206201301006202600315220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecisionTreeMachineLearningModel_h #define otbDecisionTreeMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" class CvDTree; namespace otb { template class ITK_EXPORT DecisionTreeMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef DecisionTreeMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(DecisionTreeMachineLearningModel, MachineLearningModel); /** Setters/Getters to the maximum depth of the tree. * The maximum possible depth of the tree. That is the training algorithms attempts to split a node * while its depth is less than MaxDepth. The actual depth may be smaller if the other termination criteria * are met, and/or if the tree is pruned. * Default is INT_MAX * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(MaxDepth, int); itkSetMacro(MaxDepth, int); /** Setters/Getters to the minimum number of sample in each node. * If the number of samples in a node is less than this parameter then the node will not be split. * Default is 10 * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(MinSampleCount, int); itkSetMacro(MinSampleCount, int); /** Termination Criteria for regression tree. * If all absolute differences between an estimated value in a node * and values of train samples in this node are less than this parameter * then the node will not be split. * Default is 0.01 * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(RegressionAccuracy, double); itkSetMacro(RegressionAccuracy, double); /** If true then surrogate splits will be built. * These splits allow working with missing data and compute variable importance correctly. * Default is true * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(UseSurrogates, bool); itkSetMacro(UseSurrogates, bool); /** Cluster possible values of a categorical variable into \f$ K \leq MaxCategories \f$ clusters to find * a suboptimal split. If a discrete variable, on which the training procedure tries to make a split, * takes more than max_categories values, the precise best subset estimation may take a very long time * because the algorithm is exponential. Instead, many decision trees engines (including ML) try to find * sub-optimal split in this case by clustering all the samples into max_categories clusters * that is some categories are merged together. The clustering is applied only in n>2-class classification problems * for categorical variables with N > max_categories possible values. In case of regression and 2-class classification * the optimal split can be found efficiently without employing clustering, thus the parameter is not used in these cases. * Default is 10 * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(MaxCategories, int); itkSetMacro(MaxCategories, int); /** If cv_folds > 1 then prune a tree with K-fold cross-validation where K is equal to cv_folds. * Default is 10 * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(CVFolds, int); itkSetMacro(CVFolds, int); /** If true then a pruning will be harsher. This will make a tree more compact and * more resistant to the training data noise but a bit less accurate. * Default is true * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(Use1seRule, bool); itkSetMacro(Use1seRule, bool); /** If true then pruned branches are physically removed from the tree. * Otherwise they are retained and it is possible to get results * from the original unpruned (or pruned less aggressively) tree by decreasing CvDTree::pruned_tree_idx parameter. * Default is true * \see http://docs.opencv.org/modules/ml/doc/decision_trees.html#CvDTreeParams::CvDTreeParams%28%29 */ itkGetMacro(TruncatePrunedTree, bool); itkSetMacro(TruncatePrunedTree, bool); /* The array of a priori class probabilities, sorted by the class label * value. The parameter can be used to tune the decision tree preferences toward * a certain class. For example, if you want to detect some rare anomaly * occurrence, the training base will likely contain much more normal cases than * anomalies, so a very good classification performance will be achieved just by * considering every case as normal. To avoid this, the priors can be specified, * where the anomaly probability is artificially increased (up to 0.5 or even * greater), so the weight of the misclassified anomalies becomes much bigger, * and the tree is adjusted properly. You can also think about this parameter as * weights of prediction categories which determine relative weights that you * give to misclassification. That is, if the weight of the first category is 1 * and the weight of the second category is 10, then each mistake in predicting * the second category is equivalent to making 10 mistakes in predicting the first category. */ std::vector GetPriors() const { return m_Priors; } /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} protected: /** Constructor */ DecisionTreeMachineLearningModel(); /** Destructor */ ~DecisionTreeMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: DecisionTreeMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CvDTree * m_DTreeModel; int m_MaxDepth; int m_MinSampleCount; double m_RegressionAccuracy; bool m_UseSurrogates; int m_MaxCategories; int m_CVFolds; bool m_Use1seRule; bool m_TruncatePrunedTree; std::vector m_Priors; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDecisionTreeMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbDecisionTreeMachineLearningModel.txx000066400000000000000000000116331301006202600321220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecisionTreeMachineLearningModel_txx #define otbDecisionTreeMachineLearningModel_txx #include "otbDecisionTreeMachineLearningModel.h" #include "otbOpenCVUtils.h" #include #include "itkMacro.h" namespace otb { template DecisionTreeMachineLearningModel ::DecisionTreeMachineLearningModel() : m_DTreeModel (new CvDTree), m_MaxDepth(INT_MAX), m_MinSampleCount(10), m_RegressionAccuracy(0.01), m_UseSurrogates(true), m_MaxCategories(10), m_CVFolds(10), m_Use1seRule(true), m_TruncatePrunedTree(true) { this->m_IsRegressionSupported = true; } template DecisionTreeMachineLearningModel ::~DecisionTreeMachineLearningModel() { delete m_DTreeModel; } /** Train the machine learning model */ template void DecisionTreeMachineLearningModel ::Train() { //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); cv::Mat labels; otb::ListSampleToMat(this->GetTargetListSample(),labels); float * priors = m_Priors.empty() ? ITK_NULLPTR : &m_Priors.front(); CvDTreeParams params = CvDTreeParams(m_MaxDepth, m_MinSampleCount, m_RegressionAccuracy, m_UseSurrogates, m_MaxCategories, m_CVFolds, m_Use1seRule, m_TruncatePrunedTree, priors); //train the Decision Tree model cv::Mat var_type = cv::Mat(this->GetInputListSample()->GetMeasurementVectorSize() + 1, 1, CV_8U ); var_type.setTo(cv::Scalar(CV_VAR_NUMERICAL) ); // all inputs are numerical if (!this->m_RegressionMode) //Classification var_type.at(this->GetInputListSample()->GetMeasurementVectorSize(), 0) = CV_VAR_CATEGORICAL; m_DTreeModel->train(samples,CV_ROW_SAMPLE,labels,cv::Mat(),cv::Mat(),var_type,cv::Mat(),params); } template typename DecisionTreeMachineLearningModel ::TargetSampleType DecisionTreeMachineLearningModel ::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(input,sample); double result = m_DTreeModel->predict(sample, cv::Mat(), false)->value; TargetSampleType target; target[0] = static_cast(result); if (quality != ITK_NULLPTR) { if (!this->m_ConfidenceIndex) { itkExceptionMacro("Confidence index not available for this classifier !"); } } return target; } template void DecisionTreeMachineLearningModel ::Save(const std::string & filename, const std::string & name) { if (name == "") m_DTreeModel->save(filename.c_str(), ITK_NULLPTR); else m_DTreeModel->save(filename.c_str(), name.c_str()); } template void DecisionTreeMachineLearningModel ::Load(const std::string & filename, const std::string & name) { if (name == "") m_DTreeModel->load(filename.c_str(), ITK_NULLPTR); else m_DTreeModel->load(filename.c_str(), name.c_str()); } template bool DecisionTreeMachineLearningModel ::CanReadFile(const std::string & file) { std::ifstream ifs; ifs.open(file.c_str()); if(!ifs) { std::cerr<<"Could not read file "<getName()) != std::string::npos) if (line.find(CV_TYPE_NAME_ML_TREE) != std::string::npos) { //std::cout<<"Reading a "< bool DecisionTreeMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void DecisionTreeMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbDecisionTreeMachineLearningModelFactory.h000066400000000000000000000045401301006202600330550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecisionTreeMachineLearningModelFactory_h #define otbDecisionTreeMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class DecisionTreeMachineLearningModelFactory * \brief Creation d'un instance d'un objet SVMMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT DecisionTreeMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef DecisionTreeMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DecisionTreeMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer Factory = DecisionTreeMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(Factory); } protected: DecisionTreeMachineLearningModelFactory(); ~DecisionTreeMachineLearningModelFactory() ITK_OVERRIDE; private: DecisionTreeMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDecisionTreeMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbDecisionTreeMachineLearningModelFactory.txx000066400000000000000000000040271301006202600334510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDecisionTreeMachineLearningModelFactory_txx #define otbDecisionTreeMachineLearningModelFactory_txx #include "otbDecisionTreeMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbDecisionTreeMachineLearningModel.h" #include "itkVersion.h" namespace otb { template DecisionTreeMachineLearningModelFactory ::DecisionTreeMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbDecisionTreeMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "Decision Tree ML Model", 1, itk::CreateObjectFunction >::New()); } template DecisionTreeMachineLearningModelFactory ::~DecisionTreeMachineLearningModelFactory() { } template const char* DecisionTreeMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* DecisionTreeMachineLearningModelFactory ::GetDescription() const { return "Decision Tree machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbGradientBoostedTreeMachineLearningModel.h000066400000000000000000000131541301006202600330460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGradientBoostedTreeMachineLearningModel_h #define otbGradientBoostedTreeMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" class CvGBTrees; namespace otb { template class ITK_EXPORT GradientBoostedTreeMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef GradientBoostedTreeMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(GradientBoostedTreeMachineLearningModel, MachineLearningModel); /** Type of the loss function used for training. * It must be one of the following types: CvGBTrees::SQUARED_LOSS, CvGBTrees::ABSOLUTE_LOSS, * CvGBTrees::HUBER_LOSS, CvGBTrees::DEVIANCE_LOSS. * The first three types are used for regression problems, and the last one for classification. * Default is CvGBTrees::DEVIANCE_LOSS * \see http://docs.opencv.org/modules/ml/doc/gradient_boosted_trees.html#cvgbtreesparams-cvgbtreesparams */ itkGetMacro(LossFunctionType, int); itkSetMacro(LossFunctionType, int); /** Count of boosting algorithm iterations. weak_count*K is the total count of trees in the GBT model, * where K is the output classes count (equal to one in case of a regression). * Default is 200 * \see http://docs.opencv.org/modules/ml/doc/gradient_boosted_trees.html#cvgbtreesparams-cvgbtreesparams */ itkGetMacro(WeakCount, int); itkSetMacro(WeakCount, int); /** Regularization parameter. * Default is 0.8 * \see http://docs.opencv.org/modules/ml/doc/gradient_boosted_trees.html#cvgbtreesparams-cvgbtreesparams */ itkGetMacro(Shrinkage, double); itkSetMacro(Shrinkage, double); /** Portion of the whole training set used for each algorithm iteration. Subset is generated randomly. * For more information see http://www.salfordsystems.com/doc/StochasticBoostingSS.pdf. * Default is 0.01 * \see http://docs.opencv.org/modules/ml/doc/gradient_boosted_trees.html#cvgbtreesparams-cvgbtreesparams */ itkGetMacro(SubSamplePortion, double); itkSetMacro(SubSamplePortion, double); /** Maximum depth of each decision tree. * Default is 3 * \see http://docs.opencv.org/modules/ml/doc/gradient_boosted_trees.html#cvgbtreesparams-cvgbtreesparams */ itkGetMacro(MaxDepth, int); itkSetMacro(MaxDepth, int); /** If true then surrogate splits will be built. * These splits allow working with missing data and compute variable importance correctly. * Default is false * \see http://docs.opencv.org/modules/ml/doc/gradient_boosted_trees.html#cvgbtreesparams-cvgbtreesparams */ itkGetMacro(UseSurrogates, bool); itkSetMacro(UseSurrogates, bool); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} protected: /** Constructor */ GradientBoostedTreeMachineLearningModel(); /** Destructor */ ~GradientBoostedTreeMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GradientBoostedTreeMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CvGBTrees * m_GBTreeModel; int m_LossFunctionType; int m_WeakCount; double m_Shrinkage; double m_SubSamplePortion; int m_MaxDepth; bool m_UseSurrogates; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGradientBoostedTreeMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbGradientBoostedTreeMachineLearningModel.txx000066400000000000000000000116671301006202600334510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGradientBoostedTreeMachineLearningModel_txx #define otbGradientBoostedTreeMachineLearningModel_txx #include "otbGradientBoostedTreeMachineLearningModel.h" #include "otbOpenCVUtils.h" #include #include "itkMacro.h" namespace otb { template GradientBoostedTreeMachineLearningModel ::GradientBoostedTreeMachineLearningModel() : m_GBTreeModel (new CvGBTrees), m_LossFunctionType(CvGBTrees::DEVIANCE_LOSS),//m_LossFunctionType(CvGBTrees::SQUARED_LOSS), m_WeakCount(200), m_Shrinkage(0.01), m_SubSamplePortion(0.8), m_MaxDepth(3), m_UseSurrogates(false) { this->m_IsRegressionSupported = true; } template GradientBoostedTreeMachineLearningModel ::~GradientBoostedTreeMachineLearningModel() { delete m_GBTreeModel; } /** Train the machine learning model */ template void GradientBoostedTreeMachineLearningModel ::Train() { //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); cv::Mat labels; otb::ListSampleToMat(this->GetTargetListSample(),labels); CvGBTreesParams params = CvGBTreesParams(m_LossFunctionType, m_WeakCount, m_Shrinkage, m_SubSamplePortion, m_MaxDepth, m_UseSurrogates); //train the Decision Tree model cv::Mat var_type = cv::Mat(this->GetInputListSample()->GetMeasurementVectorSize() + 1, 1, CV_8U ); var_type.setTo(cv::Scalar(CV_VAR_NUMERICAL) ); // all inputs are numerical if (!this->m_RegressionMode) //Classification var_type.at(this->GetInputListSample()->GetMeasurementVectorSize(), 0) = CV_VAR_CATEGORICAL; m_GBTreeModel->train(samples,CV_ROW_SAMPLE,labels,cv::Mat(),cv::Mat(),var_type,cv::Mat(),params, false); } template typename GradientBoostedTreeMachineLearningModel ::TargetSampleType GradientBoostedTreeMachineLearningModel ::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(input,sample); double result = m_GBTreeModel->predict(sample); //, cv::Mat(), false)->value; TargetSampleType target; target[0] = static_cast(result); if (quality != ITK_NULLPTR) { if (!this->m_ConfidenceIndex) { itkExceptionMacro("Confidence index not available for this classifier !"); } } return target; } template void GradientBoostedTreeMachineLearningModel ::Save(const std::string & filename, const std::string & name) { if (name == "") m_GBTreeModel->save(filename.c_str(), ITK_NULLPTR); else m_GBTreeModel->save(filename.c_str(), name.c_str()); } template void GradientBoostedTreeMachineLearningModel ::Load(const std::string & filename, const std::string & name) { if (name == "") m_GBTreeModel->load(filename.c_str(), ITK_NULLPTR); else m_GBTreeModel->load(filename.c_str(), name.c_str()); } template bool GradientBoostedTreeMachineLearningModel ::CanReadFile(const std::string & file) { std::ifstream ifs; ifs.open(file.c_str()); if(!ifs) { std::cerr<<"Could not read file "<getName()) != std::string::npos) if (line.find(CV_TYPE_NAME_ML_GBT) != std::string::npos) { //std::cout<<"Reading a "< bool GradientBoostedTreeMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void GradientBoostedTreeMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif otbGradientBoostedTreeMachineLearningModelFactory.h000066400000000000000000000046551301006202600343250ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGradientBoostedTreeMachineLearningModelFactory_h #define otbGradientBoostedTreeMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class GradientBoostedTreeMachineLearningModelFactory * \brief Creation d'un instance d'un objet SVMMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT GradientBoostedTreeMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef GradientBoostedTreeMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(GradientBoostedTreeMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer Factory = GradientBoostedTreeMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(Factory); } protected: GradientBoostedTreeMachineLearningModelFactory(); ~GradientBoostedTreeMachineLearningModelFactory() ITK_OVERRIDE; private: GradientBoostedTreeMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGradientBoostedTreeMachineLearningModelFactory.txx" #endif #endif otbGradientBoostedTreeMachineLearningModelFactory.txx000066400000000000000000000041731301006202600347140ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGradientBoostedTreeMachineLearningModelFactory_txx #define otbGradientBoostedTreeMachineLearningModelFactory_txx #include "otbGradientBoostedTreeMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbGradientBoostedTreeMachineLearningModel.h" #include "itkVersion.h" namespace otb { template GradientBoostedTreeMachineLearningModelFactory ::GradientBoostedTreeMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbGradientBoostedTreeMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "Gradient Boosted Tree ML Model", 1, itk::CreateObjectFunction >::New()); } template GradientBoostedTreeMachineLearningModelFactory ::~GradientBoostedTreeMachineLearningModelFactory() { } template const char* GradientBoostedTreeMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* GradientBoostedTreeMachineLearningModelFactory ::GetDescription() const { return "Gradient Boosted Tree machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbImageClassificationFilter.h000066400000000000000000000113401301006202600302620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageClassificationFilter_h #define otbImageClassificationFilter_h #include "itkImageToImageFilter.h" #include "otbMachineLearningModel.h" #include "otbImage.h" namespace otb { /** \class ImageClassificationFilter * \brief This filter performs the classification of a VectorImage using a Model. * * This filter is streamed and threaded, allowing to classify huge images * while fully using several core. * * \sa Classifier * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBSupervised */ template class ITK_EXPORT ImageClassificationFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef ImageClassificationFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageClassificationFilter, ImageToImageFilter); typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::InternalPixelType ValueType; typedef TMaskImage MaskImageType; typedef typename MaskImageType::ConstPointer MaskImageConstPointerType; typedef typename MaskImageType::Pointer MaskImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType LabelType; typedef MachineLearningModel ModelType; typedef typename ModelType::Pointer ModelPointerType; typedef otb::Image ConfidenceImageType; typedef typename ConfidenceImageType::Pointer ConfidenceImagePointerType; /** Set/Get the model */ itkSetObjectMacro(Model, ModelType); itkGetObjectMacro(Model, ModelType); /** Set/Get the default label */ itkSetMacro(DefaultLabel, LabelType); itkGetMacro(DefaultLabel, LabelType); /** Set/Get the confidence map flag */ itkSetMacro(UseConfidenceMap, bool); itkGetMacro(UseConfidenceMap, bool); itkSetMacro(BatchMode, bool); itkGetMacro(BatchMode, bool); itkBooleanMacro(BatchMode); /** * If set, only pixels within the mask will be classified. * All pixels with a value greater than 0 in the mask, will be classified. * \param mask The input mask. */ void SetInputMask(const MaskImageType * mask); /** * Get the input mask. * \return The mask. */ const MaskImageType * GetInputMask(void); /** * Get the output confidence map */ ConfidenceImageType * GetOutputConfidence(void); protected: /** Constructor */ ImageClassificationFilter(); /** Destructor */ ~ImageClassificationFilter() ITK_OVERRIDE {} /** Threaded generate data */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; void ClassicThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId); void BatchThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId); /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageClassificationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The model used for classification */ ModelPointerType m_Model; /** Default label for invalid pixels (when using a mask) */ LabelType m_DefaultLabel; /** Flag to produce the confidence map (if the model supports it) */ bool m_UseConfidenceMap; bool m_BatchMode; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageClassificationFilter.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbImageClassificationFilter.txx000066400000000000000000000236351301006202600306700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageClassificationFilter_txx #define otbImageClassificationFilter_txx #include "otbImageClassificationFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template ImageClassificationFilter ::ImageClassificationFilter() { this->SetNumberOfIndexedInputs(2); this->SetNumberOfRequiredInputs(1); m_DefaultLabel = itk::NumericTraits::ZeroValue(); this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0,TOutputImage::New()); this->SetNthOutput(1,ConfidenceImageType::New()); m_UseConfidenceMap = false; m_BatchMode = true; } template void ImageClassificationFilter ::SetInputMask(const MaskImageType * mask) { this->itk::ProcessObject::SetNthInput(1, const_cast(mask)); } template const typename ImageClassificationFilter ::MaskImageType * ImageClassificationFilter ::GetInputMask() { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template typename ImageClassificationFilter ::ConfidenceImageType * ImageClassificationFilter ::GetOutputConfidence() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void ImageClassificationFilter ::BeforeThreadedGenerateData() { if (!m_Model) { itkGenericExceptionMacro(<< "No model for classification"); } if(m_BatchMode) { #ifdef _OPENMP // OpenMP will take care of threading this->SetNumberOfThreads(1); #endif } } template void ImageClassificationFilter ::ClassicThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Get the input pointers InputImageConstPointerType inputPtr = this->GetInput(); MaskImageConstPointerType inputMaskPtr = this->GetInputMask(); OutputImagePointerType outputPtr = this->GetOutput(); ConfidenceImagePointerType confidencePtr = this->GetOutputConfidence(); // Progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define iterators typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator MaskIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionIterator ConfidenceMapIteratorType; InputIteratorType inIt(inputPtr, outputRegionForThread); OutputIteratorType outIt(outputPtr, outputRegionForThread); // Eventually iterate on masks MaskIteratorType maskIt; if (inputMaskPtr) { maskIt = MaskIteratorType(inputMaskPtr, outputRegionForThread); maskIt.GoToBegin(); } // setup iterator for confidence map bool computeConfidenceMap(m_UseConfidenceMap && m_Model->HasConfidenceIndex() && !m_Model->GetRegressionMode()); ConfidenceMapIteratorType confidenceIt; if (computeConfidenceMap) { confidenceIt = ConfidenceMapIteratorType(confidencePtr,outputRegionForThread); confidenceIt.GoToBegin(); } bool validPoint = true; double confidenceIndex = 0.0; // Walk the part of the image for (inIt.GoToBegin(), outIt.GoToBegin(); !inIt.IsAtEnd() && !outIt.IsAtEnd(); ++inIt, ++outIt) { // Check pixel validity if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } // If point is valid if (validPoint) { // Classifify if (computeConfidenceMap) { outIt.Set(m_Model->Predict(inIt.Get(),&confidenceIndex)[0]); } else { outIt.Set(m_Model->Predict(inIt.Get())[0]); } } else { // else, set default value outIt.Set(m_DefaultLabel); confidenceIndex = 0.0; } if (computeConfidenceMap) { confidenceIt.Set(confidenceIndex); ++confidenceIt; } progress.CompletedPixel(); } } template void ImageClassificationFilter ::BatchThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { bool computeConfidenceMap(m_UseConfidenceMap && m_Model->HasConfidenceIndex() && !m_Model->GetRegressionMode()); // Get the input pointers InputImageConstPointerType inputPtr = this->GetInput(); MaskImageConstPointerType inputMaskPtr = this->GetInputMask(); OutputImagePointerType outputPtr = this->GetOutput(); ConfidenceImagePointerType confidencePtr = this->GetOutputConfidence(); // Progress reporting itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define iterators typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionConstIterator MaskIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionIterator ConfidenceMapIteratorType; InputIteratorType inIt(inputPtr, outputRegionForThread); OutputIteratorType outIt(outputPtr, outputRegionForThread); MaskIteratorType maskIt; if (inputMaskPtr) { maskIt = MaskIteratorType(inputMaskPtr, outputRegionForThread); maskIt.GoToBegin(); } // typedef typename ModelType::InputValueType InputValueType; typedef typename ModelType::InputSampleType InputSampleType; typedef typename ModelType::InputListSampleType InputListSampleType; typedef typename ModelType::TargetValueType TargetValueType; // typedef typename ModelType::TargetSampleType TargetSampleType; typedef typename ModelType::TargetListSampleType TargetListSampleType; // typedef typename ModelType::ConfidenceValueType ConfidenceValueType; // typedef typename ModelType::ConfidenceSampleType ConfidenceSampleType; typedef typename ModelType::ConfidenceListSampleType ConfidenceListSampleType; typename InputListSampleType::Pointer samples = InputListSampleType::New(); unsigned int num_features = inputPtr->GetNumberOfComponentsPerPixel(); samples->SetMeasurementVectorSize(num_features); InputSampleType sample(num_features); // Fill the samples bool validPoint = true; for (inIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt) { // Check pixel validity if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } if(validPoint) { typename InputImageType::PixelType pix = inIt.Get(); for(size_t feat=0; featPushBack(sample); } } //Make the batch prediction typename TargetListSampleType::Pointer labels; typename ConfidenceListSampleType::Pointer confidences; if(computeConfidenceMap) confidences = ConfidenceListSampleType::New(); // This call is threadsafe labels = m_Model->PredictBatch(samples,confidences); // Set the output values ConfidenceMapIteratorType confidenceIt; if (computeConfidenceMap) { confidenceIt = ConfidenceMapIteratorType(confidencePtr,outputRegionForThread); confidenceIt.GoToBegin(); } typename TargetListSampleType::ConstIterator labIt = labels->Begin(); maskIt.GoToBegin(); for (outIt.GoToBegin(); labIt!=labels->End() && !outIt.IsAtEnd(); ++outIt) { double confidenceIndex = 0.0; TargetValueType labelValue(m_DefaultLabel); if (inputMaskPtr) { validPoint = maskIt.Get() > 0; ++maskIt; } if (validPoint) { labelValue = labIt.GetMeasurementVector()[0]; if(computeConfidenceMap) { confidenceIndex = confidences->GetMeasurementVector(labIt.GetInstanceIdentifier())[0]; } ++labIt; } outIt.Set(labelValue); if(computeConfidenceMap) { confidenceIt.Set(confidenceIndex); ++confidenceIt; } progress.CompletedPixel(); } } template void ImageClassificationFilter ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) { if(m_BatchMode) { this->BatchThreadedGenerateData(outputRegionForThread, threadId); } else { this->ClassicThreadedGenerateData(outputRegionForThread, threadId); } } /** * PrintSelf Method */ template void ImageClassificationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbKNearestNeighborsMachineLearningModel.h000066400000000000000000000100221301006202600325150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKNearestNeighborsMachineLearningModel_h #define otbKNearestNeighborsMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" class CvKNearest; namespace otb { template class ITK_EXPORT KNearestNeighborsMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef KNearestNeighborsMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(KNearestNeighborsMachineLearningModel, MachineLearningModel); /** Setters/Getters to the number of neighbors to use * Default is 32 * \see http://docs.opencv.org/modules/ml/doc/k_nearest_neighbors.html */ itkGetMacro(K, int); itkSetMacro(K, int); /** Decision rule once the KNN are found : * [for classification] * - KNN_VOTING : output value with maximum occurrences (for classification) * [for regression] * - KNN_MEAN : output mean value of neighbors * - KNN_MEDIAN : output median value of neighbors */ enum {KNN_VOTING, KNN_MEAN, KNN_MEDIAN}; /** Setters/Getters to the decision rule */ itkGetMacro(DecisionRule, int); itkSetMacro(DecisionRule, int); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} protected: /** Constructor */ KNearestNeighborsMachineLearningModel(); /** Destructor */ ~KNearestNeighborsMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: KNearestNeighborsMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CvKNearest * m_KNearestModel; int m_K; int m_DecisionRule; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKNearestNeighborsMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbKNearestNeighborsMachineLearningModel.txx000066400000000000000000000206561301006202600331270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKNearestNeighborsMachineLearningModel_txx #define otbKNearestNeighborsMachineLearningModel_txx #include #include "otbKNearestNeighborsMachineLearningModel.h" #include "otbOpenCVUtils.h" #include #include #include "itkMacro.h" namespace otb { template KNearestNeighborsMachineLearningModel ::KNearestNeighborsMachineLearningModel() : m_KNearestModel (new CvKNearest), m_K(32), m_DecisionRule(KNN_VOTING) { this->m_ConfidenceIndex = true; this->m_IsRegressionSupported = true; } template KNearestNeighborsMachineLearningModel ::~KNearestNeighborsMachineLearningModel() { delete m_KNearestModel; } /** Train the machine learning model */ template void KNearestNeighborsMachineLearningModel ::Train() { //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); cv::Mat labels; otb::ListSampleToMat(this->GetTargetListSample(), labels); // update decision rule if needed if (this->m_RegressionMode) { if (this->m_DecisionRule == KNN_VOTING) { this->SetDecisionRule(KNN_MEAN); } } else { if (this->m_DecisionRule != KNN_VOTING) { this->SetDecisionRule(KNN_VOTING); } } //train the KNN model m_KNearestModel->train(samples, labels, cv::Mat(), this->m_RegressionMode, m_K, false); } template typename KNearestNeighborsMachineLearningModel ::TargetSampleType KNearestNeighborsMachineLearningModel ::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(input, sample); float result; cv::Mat nearest(1,m_K,CV_32FC1); result = m_KNearestModel->find_nearest(sample, m_K,ITK_NULLPTR,ITK_NULLPTR,&nearest,ITK_NULLPTR); // compute quality if asked (only happens in classification mode) if (quality != ITK_NULLPTR) { assert(!this->m_RegressionMode); unsigned int accuracy = 0; for (int k=0 ; k < m_K ; ++k) { if (nearest.at(0,k) == result) { accuracy++; } } (*quality) = static_cast(accuracy); } // Decision rule : // VOTING is OpenCV default behaviour for classification // MEAN is OpenCV default behaviour for regression // MEDIAN : only case that must be handled here if (this->m_DecisionRule == KNN_MEDIAN) { std::multiset values; for (int k=0 ; k < m_K ; ++k) { values.insert(nearest.at(0,k)); } std::multiset::iterator median = values.begin(); int pos = (m_K >> 1); for (int k=0 ; k < pos ; ++k , ++median) {} result = *median; } TargetSampleType target; target[0] = static_cast(result); return target; } template void KNearestNeighborsMachineLearningModel ::Save(const std::string & filename, const std::string & itkNotUsed(name)) { //there is no m_KNearestModel->save(filename.c_str(), name.c_str()). //We need to save the K parameter, IsRegression flag, DecisionRule and the samples. std::ofstream ofs(filename.c_str()); //Save K parameter and IsRegression flag. ofs << "K=" << m_K << "\n"; ofs << "IsRegression=" << this->m_RegressionMode << "\n"; // Save the DecisionRule if regression if (this->m_RegressionMode) { ofs << "DecisionRule=" << m_DecisionRule << "\n"; } //Save the samples. First column is the Label and other columns are the sample data. typename InputListSampleType::ConstIterator sampleIt = this->GetInputListSample()->Begin(); typename TargetListSampleType::ConstIterator labelIt = this->GetTargetListSample()->Begin(); const unsigned int sampleSize = this->GetInputListSample()->GetMeasurementVectorSize(); for(; sampleIt!=this->GetInputListSample()->End(); ++sampleIt,++labelIt) { // Retrieve sample typename InputListSampleType::MeasurementVectorType sample = sampleIt.GetMeasurementVector(); ofs < void KNearestNeighborsMachineLearningModel ::Load(const std::string & filename, const std::string & itkNotUsed(name)) { //there is no m_KNearestModel->load(filename.c_str(), name.c_str()); std::ifstream ifs(filename.c_str()); if(!ifs) { itkExceptionMacro(<<"Could not read file "<SetK(boost::lexical_cast(line.substr(pos+1, nextpos-pos-1))); //second line is the IsRegression parameter std::getline(ifs, line); pos = line.find_first_of("=", 0); nextpos = line.find_first_of(" \n\r", pos+1); this->SetRegressionMode(boost::lexical_cast(line.substr(pos+1, nextpos-pos-1))); //third line is the DecisionRule parameter (only for regression) if (this->m_RegressionMode) { std::getline(ifs, line); pos = line.find_first_of("=", 0); nextpos = line.find_first_of(" \n\r", pos+1); this->SetDecisionRule(boost::lexical_cast(line.substr(pos+1, nextpos-pos-1))); } //Clear previous listSample (if any) typename InputListSampleType::Pointer samples = InputListSampleType::New(); typename TargetListSampleType::Pointer labels = TargetListSampleType::New(); //Read a txt file. First column is the label, other columns are the sample data. unsigned int nbFeatures = 0; while (!ifs.eof()) { std::getline(ifs, line); if(nbFeatures == 0) { nbFeatures = std::count(line.begin(),line.end(),' '); } if(line.size()>1) { // Parse label pos = line.find_first_of(" ", 0); TargetSampleType label; label[0] = static_cast(boost::lexical_cast(line.substr(0, pos))); // Parse sample features InputSampleType sample(nbFeatures); sample.Fill(0); unsigned int id = 0; nextpos = line.find_first_of(" ", pos+1); while(nextpos != std::string::npos) { nextpos = line.find_first_of(" \n\r", pos+1); std::string subline = line.substr(pos+1, nextpos-pos-1); //sample[id] = static_cast(boost::lexical_cast(subline)); sample[id] = atof(subline.c_str()); pos = nextpos; id++; } samples->SetMeasurementVectorSize(itk::NumericTraits::GetLength(sample)); samples->PushBack(sample); labels->PushBack(label); } } ifs.close(); this->SetInputListSample(samples); this->SetTargetListSample(labels); this->Train(); } template bool KNearestNeighborsMachineLearningModel ::CanReadFile(const std::string & file) { try { this->Load(file); } catch(...) { return false; } return true; } template bool KNearestNeighborsMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void KNearestNeighborsMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif otbKNearestNeighborsMachineLearningModelFactory.h000066400000000000000000000046531301006202600340030ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKNearestNeighborsMachineLearningModelFactory_h #define otbKNearestNeighborsMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class KNearestNeighborsMachineLearningModelFactory * \brief Creation d'un instance d'un objet KNearestNeighborsMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT KNearestNeighborsMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef KNearestNeighborsMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(KNearestNeighborsMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer KNNFactory = KNearestNeighborsMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(KNNFactory); } protected: KNearestNeighborsMachineLearningModelFactory(); ~KNearestNeighborsMachineLearningModelFactory() ITK_OVERRIDE; private: KNearestNeighborsMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbKNearestNeighborsMachineLearningModelFactory.txx" #endif #endif otbKNearestNeighborsMachineLearningModelFactory.txx000066400000000000000000000040771301006202600343770ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbKNearestNeighborsMachineLearningModelFactory_txx #define otbKNearestNeighborsMachineLearningModelFactory_txx #include "otbKNearestNeighborsMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbKNearestNeighborsMachineLearningModel.h" #include "itkVersion.h" namespace otb { template KNearestNeighborsMachineLearningModelFactory ::KNearestNeighborsMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbKNearestNeighborsMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "KNN ML Model", 1, itk::CreateObjectFunction >::New()); } template KNearestNeighborsMachineLearningModelFactory ::~KNearestNeighborsMachineLearningModelFactory() { } template const char* KNearestNeighborsMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* KNearestNeighborsMachineLearningModelFactory ::GetDescription() const { return "KNN machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbLibSVMMachineLearningModel.h000066400000000000000000000116011301006202600302400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLibSVMMachineLearningModel_h #define otbLibSVMMachineLearningModel_h #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" // SVM estimator #include "otbSVMSampleListModelEstimator.h" // Validation #include "otbSVMClassifier.h" namespace otb { template class ITK_EXPORT LibSVMMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef LibSVMMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; // LibSVM related typedefs typedef otb::Functor::VariableLengthVectorToMeasurementVectorFunctor MeasurementVectorFunctorType; typedef otb::SVMSampleListModelEstimator SVMEstimatorType; typedef otb::SVMClassifier ClassifierType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(SVMMachineLearningModel, MachineLearningModel); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string &filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} //Setters/Getters to SVM model otbGetObjectMemberMacro(SVMestimator, SVMType, int); otbSetObjectMemberMacro(SVMestimator, SVMType, int); otbGetObjectMemberMacro(SVMestimator, KernelType, int); otbSetObjectMemberMacro(SVMestimator, KernelType, int); otbGetObjectMemberMacro(SVMestimator, C, double); otbSetObjectMemberMacro(SVMestimator, C, double); // TODO : we should harmonize this parameter name : ParameterOptimization -> ParametersOptimization bool GetParameterOptimization() { return this->m_SVMestimator->GetParametersOptimization(); } void SetParameterOptimization(bool value) { this->m_SVMestimator->SetParametersOptimization(value); this->Modified(); } otbGetObjectMemberMacro(SVMestimator, DoProbabilityEstimates, bool); void SetDoProbabilityEstimates(bool value) { this->m_SVMestimator->DoProbabilityEstimates(value); } otbGetObjectMemberMacro(SVMestimator, Epsilon, double); otbSetObjectMemberMacro(SVMestimator, Epsilon, double); otbGetObjectMemberMacro(SVMestimator, P, double); otbSetObjectMemberMacro(SVMestimator, P, double); otbGetObjectMemberMacro(SVMestimator, Nu, double); otbSetObjectMemberMacro(SVMestimator, Nu, double); protected: /** Constructor */ LibSVMMachineLearningModel(); /** Destructor */ ~LibSVMMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LibSVMMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented typename SVMEstimatorType::Pointer m_SVMestimator; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLibSVMMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbLibSVMMachineLearningModel.txx000066400000000000000000000113001301006202600306300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLibSVMMachineLearningModel_txx #define otbLibSVMMachineLearningModel_txx #include #include "otbLibSVMMachineLearningModel.h" namespace otb { template LibSVMMachineLearningModel ::LibSVMMachineLearningModel() { m_SVMestimator = SVMEstimatorType::New(); m_SVMestimator->SetSVMType(C_SVC); m_SVMestimator->SetC(1.0); m_SVMestimator->SetKernelType(LINEAR); m_SVMestimator->SetParametersOptimization(false); m_SVMestimator->DoProbabilityEstimates(false); //m_SVMestimator->SetEpsilon(1e-6); this->m_IsRegressionSupported = true; } template LibSVMMachineLearningModel ::~LibSVMMachineLearningModel() { //delete m_SVMModel; } /** Train the machine learning model */ template void LibSVMMachineLearningModel ::Train() { // Set up SVM's parameters // CvSVMParams params; // params.svm_type = m_SVMType; // params.kernel_type = m_KernelType; // params.term_crit = cvTermCriteria(m_TermCriteriaType, m_MaxIter, m_Epsilon); // // Train the SVM m_SVMestimator->SetInputSampleList(this->GetInputListSample()); m_SVMestimator->SetTrainingSampleList(this->GetTargetListSample()); m_SVMestimator->Update(); this->m_ConfidenceIndex = this->GetDoProbabilityEstimates(); } template typename LibSVMMachineLearningModel ::TargetSampleType LibSVMMachineLearningModel ::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { TargetSampleType target; MeasurementVectorFunctorType mfunctor; target = m_SVMestimator->GetModel()->EvaluateLabel(mfunctor(input)); if (quality != ITK_NULLPTR) { if (!this->m_ConfidenceIndex) { itkExceptionMacro("Confidence index not available for this classifier !"); } typename SVMEstimatorType::ModelType::ProbabilitiesVectorType probaVector = m_SVMestimator->GetModel()->EvaluateProbabilities(mfunctor(input)); double maxProb = 0.0; double secProb = 0.0; for (unsigned int i=0 ; i(maxProb - secProb); } return target; } template void LibSVMMachineLearningModel ::Save(const std::string & filename, const std::string & itkNotUsed(name)) { m_SVMestimator->GetModel()->SaveModel(filename.c_str()); } template void LibSVMMachineLearningModel ::Load(const std::string & filename, const std::string & itkNotUsed(name)) { m_SVMestimator->GetModel()->LoadModel(filename.c_str()); this->m_ConfidenceIndex = m_SVMestimator->GetModel()->HasProbabilities(); } template bool LibSVMMachineLearningModel ::CanReadFile(const std::string & file) { //TODO: Rework. std::ifstream ifs; ifs.open(file.c_str()); if(!ifs) { std::cerr<<"Could not read file "<getName()) != std::string::npos) if (line.find("svm_type") != std::string::npos) { //std::cout<<"Reading a libSVM model"< bool LibSVMMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void LibSVMMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbLibSVMMachineLearningModelFactory.h000066400000000000000000000044051301006202600315740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLibSVMMachineLearningModelFactory_h #define otbLibSVMMachineLearningModelFactory_h #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class LibSVMMachineLearningModelFactory * \brief Creation d'un instance d'un objet SVMMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT LibSVMMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef LibSVMMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LibSVMMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer LibSVMFactory = LibSVMMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(LibSVMFactory); } protected: LibSVMMachineLearningModelFactory(); ~LibSVMMachineLearningModelFactory() ITK_OVERRIDE; private: LibSVMMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLibSVMMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbLibSVMMachineLearningModelFactory.txx000066400000000000000000000037011301006202600321660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLibSVMMachineLearningModelFactory_txx #define otbLibSVMMachineLearningModelFactory_txx #include "otbLibSVMMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbLibSVMMachineLearningModel.h" #include "itkVersion.h" namespace otb { template LibSVMMachineLearningModelFactory ::LibSVMMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbLibSVMMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "LibSVM ML Model", 1, itk::CreateObjectFunction >::New()); } template LibSVMMachineLearningModelFactory ::~LibSVMMachineLearningModelFactory() { } template const char* LibSVMMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* LibSVMMachineLearningModelFactory ::GetDescription() const { return "LibSVM machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbMachineLearningModel.h000066400000000000000000000211261301006202600272260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMachineLearningModel_h #define otbMachineLearningModel_h #include "itkObject.h" #include "itkVariableLengthVector.h" #include "itkListSample.h" namespace otb { /** \class MachineLearningModel * \brief MachineLearningModel is the base class for all classifier objects (SVM, KNN, * Random Forests, Artificial Neural Network, ...) implemented in the supervised classification framework of the OTB. * * MachineLearningModel is an abstract object that specifies behavior and * interface of supervised classifiers (SVM, KNN, Random Forests, Artificial * Neural Network, ...) in the generic supervised classification framework of the OTB. * The main generic virtual methods specifically implemented in each classifier * derived from the MachineLearningModel class are two learning-related methods: * Train() and Save(), and three classification-related methods: Load(), * DoPredict() and optionnaly DoPredictBatch(). * * Thus, each classifier derived from the MachineLearningModel class * computes its corresponding model with Train() and exports it with * the help of the Save() method. * * It is also possible to classify any input sample composed of several * features (or any number of bands in the case of a pixel extracted * from a multi-band image) with the help of the Predict() method which * needs a previous loading of the classification model with the Load() method. * * \sa MachineLearningModelFactory * \sa LibSVMMachineLearningModel * \sa SVMMachineLearningModel * \sa BoostMachineLearningModel * \sa KNearestNeighborsMachineLearningModel * \sa DecisionTreeMachineLearningModel * \sa RandomForestsMachineLearningModel * \sa GradientBoostedTreeMachineLearningModel * \sa NormalBayesMachineLearningModel * \sa NeuralNetworkMachineLearningModel * \sa SharkRandomForestsMachineLearningModel * \sa ImageClassificationFilter * * * \ingroup OTBSupervised */ template class ITK_EXPORT MachineLearningModel : public itk::Object { public: /**\name Standard ITK typedefs */ //@{ typedef MachineLearningModel Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; //@} /**\name Input related typedefs */ //@{ typedef TInputValue InputValueType; typedef itk::VariableLengthVector InputSampleType; typedef itk::Statistics::ListSample InputListSampleType; //@} /**\name Target related typedefs */ //@{ typedef TTargetValue TargetValueType; typedef itk::FixedArray TargetSampleType; typedef itk::Statistics::ListSample TargetListSampleType; //@} /**\name Confidence value typedef */ typedef TConfidenceValue ConfidenceValueType; typedef itk::FixedArray ConfidenceSampleType; typedef itk::Statistics::ListSample ConfidenceListSampleType; /**\name Standard macros */ //@{ /** Run-time type information (and related methods). */ itkTypeMacro(MachineLearningModel, itk::Object); //@} /** Train the machine learning model */ virtual void Train() =0; /** Predict a single sample * \param input The sample * \param quality A pointer to the quality variable were to store * quality value, or NULL * \return The predicted label */ TargetSampleType Predict(const InputSampleType& input, ConfidenceValueType *quality = ITK_NULLPTR) const; /** Predict a batch of samples (InputListSampleType) * \param input The batch of sample to predict * \param quality A pointer to the list were to store * quality value, or NULL * \return The predicted labels * Note that this method will be multi-threaded if OTB is built * with OpenMP. */ typename TargetListSampleType::Pointer PredictBatch(const InputListSampleType * input, ConfidenceListSampleType * quality = ITK_NULLPTR) const; /** THIS METHOD IS DEPRECATED AND SHOULD NOT BE USED. */ void PredictAll(); /**\name Classification model file manipulation */ //@{ /** Save the model to file */ virtual void Save(const std::string & filename, const std::string & name="") = 0; /** Load the model from file */ virtual void Load(const std::string & filename, const std::string & name="") = 0; //@} /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ virtual bool CanReadFile(const std::string &) = 0; /** Is the input model file writable and compatible with the corresponding classifier ? */ virtual bool CanWriteFile(const std::string &) = 0; //@} /** Query capacity to produce a confidence index */ bool HasConfidenceIndex() const {return m_ConfidenceIndex;} /**\name Input list of samples accessors */ //@{ itkSetObjectMacro(InputListSample,InputListSampleType); itkGetObjectMacro(InputListSample,InputListSampleType); itkGetConstObjectMacro(InputListSample,InputListSampleType); //@} /**\name Classification output accessors */ //@{ /** Set the target labels (to be used before training) */ itkSetObjectMacro(TargetListSample,TargetListSampleType); /** Get the target labels (to be used after PredictAll) */ itkGetObjectMacro(TargetListSample,TargetListSampleType); //@} itkGetObjectMacro(ConfidenceListSample,ConfidenceListSampleType); /**\name Use model in regression mode */ //@{ itkGetMacro(RegressionMode,bool); void SetRegressionMode(bool flag); //@} protected: /** Constructor */ MachineLearningModel(); /** Destructor */ ~MachineLearningModel() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Input list sample */ typename InputListSampleType::Pointer m_InputListSample; /** Target list sample */ typename TargetListSampleType::Pointer m_TargetListSample; typename ConfidenceListSampleType::Pointer m_ConfidenceListSample; /** flag to choose between classification and regression modes */ bool m_RegressionMode; /** flag that indicates if the model supports regression, child * classes should modify it in their constructor if they support * regression mode */ bool m_IsRegressionSupported; /** flag that tells if the model support confidence index output */ bool m_ConfidenceIndex; /** Is DoPredictBatch multi-threaded ? */ bool m_IsDoPredictBatchMultiThreaded; private: /** Actual implementation of BatchPredicition * Default implementation will call DoPredict iteratively * \param input The input batch * \param startIndex Index of the first sample to predict * \param size Number of samples to predict * \param target Pointer to the list of produced labels * \param quality Pointer to the list of produced confidence * values, or NULL * * Override me if internal implementation allows for batch * prediction. * * Also set m_IsDoPredictBatchMultiThreaded to true if internal * implementation allows for parallel batch prediction. */ virtual void DoPredictBatch(const InputListSampleType * input, const unsigned int & startIndex, const unsigned int & size, TargetListSampleType * target, ConfidenceListSampleType * quality = ITK_NULLPTR) const; /** Actual implementation of single sample prediction * \param input sample to predict * \param quality Pointer to a variable to store confidence value, * or NULL * \return The predicted label */ virtual TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType * quality= ITK_NULLPTR) const = 0; MachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbMachineLearningModel.txx000066400000000000000000000136361301006202600276310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMachineLearningModel_txx #define otbMachineLearningModel_txx #ifdef _OPENMP # include #endif #include "otbMachineLearningModel.h" #include "itkMultiThreader.h" namespace otb { template MachineLearningModel ::MachineLearningModel() : m_RegressionMode(false), m_IsRegressionSupported(false), m_ConfidenceIndex(false), m_IsDoPredictBatchMultiThreaded(false) {} template MachineLearningModel ::~MachineLearningModel() {} template void MachineLearningModel ::SetRegressionMode(bool flag) { if (flag && !m_IsRegressionSupported) { itkGenericExceptionMacro(<< "Regression mode not implemented."); } if (m_RegressionMode != flag) { m_RegressionMode = flag; this->Modified(); } } template void MachineLearningModel ::PredictAll() { itkWarningMacro("MachineLearningModel::PredictAll() has been DEPRECATED. Use MachineLearningModel::PredictBatch() instead."); typename TargetListSampleType::Pointer targets = this->GetTargetListSample(); targets->Clear(); typename TargetListSampleType::Pointer tmpTargets = this->PredictBatch(this->GetInputListSample()); targets->Graft(tmpTargets); } template typename MachineLearningModel ::TargetSampleType MachineLearningModel ::Predict(const InputSampleType& input, ConfidenceValueType *quality) const { // Call protected specialization entry point return this->DoPredict(input,quality); } template typename MachineLearningModel ::TargetListSampleType::Pointer MachineLearningModel ::PredictBatch(const InputListSampleType * input, ConfidenceListSampleType * quality) const { typename TargetListSampleType::Pointer targets = TargetListSampleType::New(); targets->Resize(input->Size()); if(quality!=ITK_NULLPTR) { quality->Clear(); quality->Resize(input->Size()); } if(m_IsDoPredictBatchMultiThreaded) { // Simply calls DoPredictBatch this->DoPredictBatch(input,0,input->Size(),targets,quality); return targets; } else { #ifdef _OPENMP // OpenMP threading here unsigned int nb_threads(0), threadId(0), nb_batches(0); #pragma omp parallel shared(nb_threads,nb_batches) private(threadId) { // Get number of threads configured with ITK omp_set_num_threads(itk::MultiThreader::GetGlobalDefaultNumberOfThreads()); nb_threads = omp_get_num_threads(); threadId = omp_get_thread_num(); nb_batches = std::min(nb_threads,(unsigned int)input->Size()); // Ensure that we do not spawn unncessary threads if(threadIdSize()/nb_batches); unsigned int batch_start = threadId*batch_size; if(threadId == nb_threads-1) { batch_size+=input->Size()%nb_batches; } this->DoPredictBatch(input,batch_start,batch_size,targets,quality); } } #else this->DoPredictBatch(input,0,input->Size(),targets,quality); #endif return targets; } } template void MachineLearningModel ::DoPredictBatch(const InputListSampleType * input, const unsigned int & startIndex, const unsigned int & size, TargetListSampleType * targets, ConfidenceListSampleType * quality) const { assert(input != ITK_NULLPTR); assert(targets != ITK_NULLPTR); assert(input->Size()==targets->Size()&&"Input sample list and target label list do not have the same size."); assert(((quality==ITK_NULLPTR)||(quality->Size()==input->Size()))&&"Quality samples list is not null and does not have the same size as input samples list"); if(startIndex+size>input->Size()) { itkExceptionMacro(<<"requested range ["<Size()<<"["); } if(quality != ITK_NULLPTR) { for(unsigned int id = startIndex;idDoPredict(input->GetMeasurementVector(id),&confidence); quality->SetMeasurementVector(id,confidence); targets->SetMeasurementVector(id,target); } } else { for(unsigned int id = startIndex;idDoPredict(input->GetMeasurementVector(id)); targets->SetMeasurementVector(id,target); } } } template void MachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbMachineLearningModelFactory.h000066400000000000000000000050371301006202600305610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMachineLearningModelFactory_h #define otbMachineLearningModelFactory_h #include "otbMachineLearningModel.h" #include "otbMachineLearningModelFactoryBase.h" namespace otb { /** \class MachineLearningModelFactory * \brief Creation of object instance using object factory. * * \ingroup OTBSupervised */ template class MachineLearningModelFactory : public MachineLearningModelFactoryBase { public: /** Standard class typedefs. */ typedef MachineLearningModelFactory Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class Methods used to interface with the registered factories */ /** Run-time type information (and related methods). */ itkTypeMacro(MachineLearningModelFactory, itk::Object); /** Convenient typedefs. */ typedef otb::MachineLearningModel MachineLearningModelType; typedef typename MachineLearningModelType::Pointer MachineLearningModelTypePointer; /** Mode in which the files is intended to be used */ typedef enum { ReadMode, WriteMode } FileModeType; /** Create the appropriate MachineLearningModel depending on the particulars of the file. */ static MachineLearningModelTypePointer CreateMachineLearningModel(const std::string& path, FileModeType mode); static void CleanFactories(); protected: MachineLearningModelFactory(); ~MachineLearningModelFactory() ITK_OVERRIDE; private: MachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Register Built-in factories */ static void RegisterBuiltInFactories(); /** Register a single factory, ensuring it has not been registered * twice */ static void RegisterFactory(itk::ObjectFactoryBase * factory); }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbMachineLearningModelFactory.txx000066400000000000000000000177301301006202600311600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMachineLearningModelFactory_txx #define otbMachineLearningModelFactory_txx #include "otbMachineLearningModelFactory.h" #include "otbConfigure.h" #ifdef OTB_USE_OPENCV #include "otbKNearestNeighborsMachineLearningModelFactory.h" #include "otbRandomForestsMachineLearningModelFactory.h" #include "otbSVMMachineLearningModelFactory.h" #include "otbBoostMachineLearningModelFactory.h" #include "otbNeuralNetworkMachineLearningModelFactory.h" #include "otbNormalBayesMachineLearningModelFactory.h" #include "otbDecisionTreeMachineLearningModelFactory.h" #include "otbGradientBoostedTreeMachineLearningModelFactory.h" #endif #ifdef OTB_USE_LIBSVM #include "otbLibSVMMachineLearningModelFactory.h" #endif #ifdef OTB_USE_SHARK #include "otbSharkRandomForestsMachineLearningModelFactory.h" #endif #include "itkMutexLockHolder.h" namespace otb { template typename MachineLearningModel::Pointer MachineLearningModelFactory ::CreateMachineLearningModel(const std::string& path, FileModeType mode) { RegisterBuiltInFactories(); std::list possibleMachineLearningModel; std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("otbMachineLearningModel"); for(std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { MachineLearningModel * io = dynamic_cast*>(i->GetPointer()); if(io) { possibleMachineLearningModel.push_back(io); } else { std::cerr << "Error MachineLearningModel Factory did not return an MachineLearningModel: " << (*i)->GetNameOfClass() << std::endl; } } for(typename std::list::iterator k = possibleMachineLearningModel.begin(); k != possibleMachineLearningModel.end(); ++k) { if( mode == ReadMode ) { if((*k)->CanReadFile(path)) { return *k; } } else if( mode == WriteMode ) { if((*k)->CanWriteFile(path)) { return *k; } } } return ITK_NULLPTR; } template void MachineLearningModelFactory ::RegisterBuiltInFactories() { itk::MutexLockHolder lockHolder(mutex); #ifdef OTB_USE_LIBSVM RegisterFactory(LibSVMMachineLearningModelFactory::New()); #endif #ifdef OTB_USE_SHARK RegisterFactory(SharkRandomForestsMachineLearningModelFactory::New()); #endif #ifdef OTB_USE_OPENCV RegisterFactory(RandomForestsMachineLearningModelFactory::New()); RegisterFactory(SVMMachineLearningModelFactory::New()); RegisterFactory(BoostMachineLearningModelFactory::New()); RegisterFactory(NeuralNetworkMachineLearningModelFactory::New()); RegisterFactory(NormalBayesMachineLearningModelFactory::New()); RegisterFactory(DecisionTreeMachineLearningModelFactory::New()); RegisterFactory(GradientBoostedTreeMachineLearningModelFactory::New()); RegisterFactory(KNearestNeighborsMachineLearningModelFactory::New()); #endif } template void MachineLearningModelFactory ::RegisterFactory(itk::ObjectFactoryBase * factory) { // Unregister any previously registered factory of the same class // Might be more intensive but static bool is not an option due to // ld error. itk::ObjectFactoryBase::UnRegisterFactory(factory); itk::ObjectFactoryBase::RegisterFactory(factory); } template void MachineLearningModelFactory ::CleanFactories() { itk::MutexLockHolder lockHolder(mutex); std::list factories = itk::ObjectFactoryBase::GetRegisteredFactories(); std::list::iterator itFac; for (itFac = factories.begin(); itFac != factories.end() ; ++itFac) { #ifdef OTB_USE_LIBSVM LibSVMMachineLearningModelFactory *libsvmFactory = dynamic_cast *>(*itFac); if (libsvmFactory) { itk::ObjectFactoryBase::UnRegisterFactory(libsvmFactory); continue; } #endif #ifdef OTB_USE_SHARK SharkRandomForestsMachineLearningModelFactory *sharkRFFactory = dynamic_cast *>(*itFac); if (sharkRFFactory) { itk::ObjectFactoryBase::UnRegisterFactory(sharkRFFactory); continue; } #endif #ifdef OTB_USE_OPENCV // RandomForest RandomForestsMachineLearningModelFactory *rfFactory = dynamic_cast *>(*itFac); if (rfFactory) { itk::ObjectFactoryBase::UnRegisterFactory(rfFactory); continue; } // SVM SVMMachineLearningModelFactory *svmFactory = dynamic_cast *>(*itFac); if (svmFactory) { itk::ObjectFactoryBase::UnRegisterFactory(svmFactory); continue; } // Boost BoostMachineLearningModelFactory *boostFactory = dynamic_cast *>(*itFac); if (boostFactory) { itk::ObjectFactoryBase::UnRegisterFactory(boostFactory); continue; } // ANN NeuralNetworkMachineLearningModelFactory *annFactory = dynamic_cast *>(*itFac); if (annFactory) { itk::ObjectFactoryBase::UnRegisterFactory(annFactory); continue; } // Bayes NormalBayesMachineLearningModelFactory *bayesFactory = dynamic_cast *>(*itFac); if (bayesFactory) { itk::ObjectFactoryBase::UnRegisterFactory(bayesFactory); continue; } // Decision Tree DecisionTreeMachineLearningModelFactory *dtFactory = dynamic_cast *>(*itFac); if (dtFactory) { itk::ObjectFactoryBase::UnRegisterFactory(dtFactory); continue; } // Gradient Boosted tree GradientBoostedTreeMachineLearningModelFactory *gbtFactory = dynamic_cast *>(*itFac); if (gbtFactory) { itk::ObjectFactoryBase::UnRegisterFactory(gbtFactory); continue; } // KNN KNearestNeighborsMachineLearningModelFactory *knnFactory = dynamic_cast *>(*itFac); if (knnFactory) { itk::ObjectFactoryBase::UnRegisterFactory(knnFactory); continue; } #endif } } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbMachineLearningModelFactoryBase.h000066400000000000000000000033321301006202600313500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMachineLearningModelFactoryBase_h #define otbMachineLearningModelFactoryBase_h #include "itkMutexLock.h" #include "OTBSupervisedExport.h" namespace otb { /** \class MachineLearningModelFactoryBase * \brief Base class for the MachinelearningModelFactory * * This class intends to hold the static attributes that can not be * part of a template class (ld error). * * * \ingroup OTBSupervised */ class OTBSupervised_EXPORT MachineLearningModelFactoryBase : public itk::Object { public: /** Standard class typedefs. */ typedef MachineLearningModelFactoryBase Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(MachineLearningModelFactoryBase, itk::Object); protected: MachineLearningModelFactoryBase(); ~MachineLearningModelFactoryBase() ITK_OVERRIDE; static itk::SimpleMutexLock mutex; private: MachineLearningModelFactoryBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNeuralNetworkMachineLearningModel.h000066400000000000000000000175771301006202600317660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeuralNetworkMachineLearningModel_h #define otbNeuralNetworkMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-align" #include #pragma GCC diagnostic pop #else #include #endif #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Woverloaded-virtual" #include #pragma GCC diagnostic pop #else #include #endif #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" namespace otb { template class ITK_EXPORT NeuralNetworkMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef NeuralNetworkMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; typedef std::map MapOfLabelsType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(NeuralNetworkMachineLearningModel, MachineLearningModel); /** Setters/Getters to the train method * 2 methods are available: * - CvANN_MLP_TrainParams::BACKPROP The back-propagation algorithm. * - CvANN_MLP_TrainParams::RPROP The RPROP algorithm. * Default is CvANN_MLP_TrainParams::RPROP. * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(TrainMethod, int); itkSetMacro(TrainMethod, int); /** * Set the number of neurons in each layer (including input and output layers). * The number of neuron in the first layer (input layer) must be equal * to the number of samples in the \c InputListSample */ void SetLayerSizes (const std::vector layers); /** Setters/Getters to the neuron activation function * 3 methods are available: * - CvANN_MLP::IDENTITY * - CvANN_MLP::SIGMOID_SYM * - CvANN_MLP::GAUSSIAN * Default is CvANN_MLP::SIGMOID_SYM * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(ActivateFunction, int); itkSetMacro(ActivateFunction, int); /** Setters/Getters to the alpha parameter of the activation function * Default is 0. * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(Alpha, double); itkSetMacro(Alpha, double); /** Setters/Getters to the beta parameter of the activation function * Default is 0. * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(Beta, double); itkSetMacro(Beta, double); /** Strength of the weight gradient term in the BACKPROP method. * The recommended value is about 0.1 * Default is 0.1 * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(BackPropDWScale, double); itkSetMacro(BackPropDWScale, double); /** Strength of the momentum term (the difference between weights on the 2 previous iterations). * This parameter provides some inertia to smooth the random fluctuations of the weights. * It can vary from 0 (the feature is disabled) to 1 and beyond. * The value 0.1 or so is good enough * Default is 0.1 * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(BackPropMomentScale, double); itkSetMacro(BackPropMomentScale, double); /** Initial value \f$ \Delta_0 \f$ of update-values \f$ \Delta_{ij} \f$ in RPROP method. * Default is 0.1 * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(RegPropDW0, double); itkSetMacro(RegPropDW0, double); /** Update-values lower limit \f$ \Delta_{min} \f$ in RPROP method. * It must be positive. Default is FLT_EPSILON * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(RegPropDWMin, double); itkSetMacro(RegPropDWMin, double); /** Termination criteria. * It can be CV_TERMCRIT_ITER or CV_TERMCRIT_EPS or CV_TERMCRIT_ITER+CV_TERMCRIT_EPS * default is CV_TERMCRIT_ITER+CV_TERMCRIT_EPS. * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(TermCriteriaType, int); itkSetMacro(TermCriteriaType, int); /** Maximum number of iteration used in the Termination criteria. * default is 1000 * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(MaxIter, int); itkSetMacro(MaxIter, int); /** Epsilon value used in the Termination criteria. * default is 0.01 * \see http://docs.opencv.org/modules/ml/doc/neural_networks.html */ itkGetMacro(Epsilon, double); itkSetMacro(Epsilon, double); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} protected: /** Constructor */ NeuralNetworkMachineLearningModel(); /** Destructor */ ~NeuralNetworkMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; void LabelsToMat(const TargetListSampleType * listSample, cv::Mat & output); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: NeuralNetworkMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void CreateNetwork(); CvANN_MLP_TrainParams SetNetworkParameters(); void SetupNetworkAndTrain(cv::Mat& labels); CvANN_MLP * m_ANNModel; int m_TrainMethod; int m_ActivateFunction; std::vector m_LayerSizes; double m_Alpha; double m_Beta; double m_BackPropDWScale; double m_BackPropMomentScale; double m_RegPropDW0; double m_RegPropDWMin; int m_TermCriteriaType; int m_MaxIter; double m_Epsilon; CvMat* m_CvMatOfLabels; MapOfLabelsType m_MapOfLabels; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNeuralNetworkMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNeuralNetworkMachineLearningModel.txx000066400000000000000000000246571301006202600323570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeuralNetworkMachineLearningModel_txx #define otbNeuralNetworkMachineLearningModel_txx #include #include "otbNeuralNetworkMachineLearningModel.h" #include "otbOpenCVUtils.h" #include "itkMacro.h" // itkExceptionMacro namespace otb { template NeuralNetworkMachineLearningModel::NeuralNetworkMachineLearningModel() : m_ANNModel (new CvANN_MLP), m_TrainMethod(CvANN_MLP_TrainParams::RPROP), m_ActivateFunction(CvANN_MLP::SIGMOID_SYM), m_Alpha(1.), m_Beta(1.), m_BackPropDWScale(0.1), m_BackPropMomentScale(0.1), m_RegPropDW0(0.1), m_RegPropDWMin(FLT_EPSILON), m_TermCriteriaType(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS), m_MaxIter(1000), m_Epsilon(0.01), m_CvMatOfLabels(ITK_NULLPTR) { this->m_ConfidenceIndex = true; this->m_IsRegressionSupported = true; } template NeuralNetworkMachineLearningModel::~NeuralNetworkMachineLearningModel() { delete m_ANNModel; cvReleaseMat(&m_CvMatOfLabels); } /** Sets the topology of the NN */ template void NeuralNetworkMachineLearningModel::SetLayerSizes(const std::vector layers) { const unsigned int nbLayers = layers.size(); if (nbLayers < 3) itkExceptionMacro(<< "Number of layers in the Neural Network must be >= 3") m_LayerSizes = layers; } /** Converts a ListSample of VariableLengthVector to a CvMat. The user * is responsible for freeing the output pointer with the * cvReleaseMat function. A null pointer is resturned in case the * conversion failed. */ template void NeuralNetworkMachineLearningModel::LabelsToMat(const TargetListSampleType * labels, cv::Mat & output) { unsigned int nbSamples = 0; if (labels != ITK_NULLPTR) { nbSamples = labels->Size(); } // Check for valid listSample if (nbSamples > 0) { // Build an iterator typename TargetListSampleType::ConstIterator labelSampleIt = labels->Begin(); TargetValueType classLabel; for (; labelSampleIt != labels->End(); ++labelSampleIt) { // Retrieve labelSample typename TargetListSampleType::MeasurementVectorType labelSample = labelSampleIt.GetMeasurementVector(); classLabel = labelSample[0]; if (m_MapOfLabels.count(classLabel) == 0) { m_MapOfLabels[classLabel] = -1; } } unsigned int nbClasses = m_MapOfLabels.size(); typename MapOfLabelsType::iterator itMapOfLabels = m_MapOfLabels.begin(); unsigned itLabel = 0; for (; itMapOfLabels != m_MapOfLabels.end(); ++itMapOfLabels) { classLabel = itMapOfLabels->first; m_MapOfLabels[classLabel] = itLabel; if (itLabel == 0) { if (m_CvMatOfLabels) { cvReleaseMat(&m_CvMatOfLabels); } m_CvMatOfLabels = cvCreateMat(1, nbClasses, CV_32SC1); } m_CvMatOfLabels->data.i[itLabel] = classLabel; ++itLabel; } // Allocate CvMat // Sample index unsigned int sampleIdx = 0; labelSampleIt = labels->Begin(); output.create(nbSamples, nbClasses, CV_32FC1); output.setTo(-m_Beta); // Fill the cv matrix for (; labelSampleIt != labels->End(); ++labelSampleIt, ++sampleIdx) { // Retrieve labelSample typename TargetListSampleType::MeasurementVectorType labelSample = labelSampleIt.GetMeasurementVector(); classLabel = labelSample[0]; unsigned int indexLabel = m_MapOfLabels[classLabel]; output.at (sampleIdx, indexLabel) = m_Beta; } } } template void NeuralNetworkMachineLearningModel::CreateNetwork() { //Create the neural network const unsigned int nbLayers = m_LayerSizes.size(); if ( nbLayers == 0 ) itkExceptionMacro(<< "Number of layers in the Neural Network must be >= 3") cv::Mat layers = cv::Mat(nbLayers, 1, CV_32SC1); for (unsigned int i = 0; i < nbLayers; i++) { layers.row(i) = m_LayerSizes[i]; } m_ANNModel->create(layers, m_ActivateFunction, m_Alpha, m_Beta); } template CvANN_MLP_TrainParams NeuralNetworkMachineLearningModel::SetNetworkParameters() { CvANN_MLP_TrainParams params; params.train_method = m_TrainMethod; params.bp_dw_scale = m_BackPropDWScale; params.bp_moment_scale = m_BackPropMomentScale; params.rp_dw0 = m_RegPropDW0; params.rp_dw_min = m_RegPropDWMin; CvTermCriteria term_crit = cvTermCriteria(m_TermCriteriaType, m_MaxIter, m_Epsilon); params.term_crit = term_crit; return params; } template void NeuralNetworkMachineLearningModel::SetupNetworkAndTrain(cv::Mat& labels) { //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); this->CreateNetwork(); CvANN_MLP_TrainParams params = this->SetNetworkParameters(); //train the Neural network model m_ANNModel->train(samples, labels, cv::Mat(), cv::Mat(), params); } /** Train the machine learning model for classification*/ template void NeuralNetworkMachineLearningModel::Train() { //Transform the targets into a matrix of labels cv::Mat matOutputANN; if (this->m_RegressionMode) { // MODE REGRESSION otb::ListSampleToMat(this->GetTargetListSample(), matOutputANN); } else { // MODE CLASSIFICATION : store the map between internal labels and output labels LabelsToMat(this->GetTargetListSample(), matOutputANN); } this->SetupNetworkAndTrain(matOutputANN); } template typename NeuralNetworkMachineLearningModel::TargetSampleType NeuralNetworkMachineLearningModel< TInputValue, TOutputValue>::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(input, sample); cv::Mat response; //(1, 1, CV_32FC1); m_ANNModel->predict(sample, response); TargetSampleType target; float currentResponse = 0; float maxResponse = response.at (0, 0); if (this->m_RegressionMode) { // MODE REGRESSION : only output first response target[0] = maxResponse; return target; } // MODE CLASSIFICATION : find the highest response float secondResponse = -1e10; target[0] = m_CvMatOfLabels->data.i[0]; unsigned int nbClasses = m_CvMatOfLabels->cols; for (unsigned itLabel = 1; itLabel < nbClasses; ++itLabel) { currentResponse = response.at (0, itLabel); if (currentResponse > maxResponse) { secondResponse = maxResponse; maxResponse = currentResponse; target[0] = m_CvMatOfLabels->data.i[itLabel]; } else { if (currentResponse > secondResponse) { secondResponse = currentResponse; } } } if (quality != ITK_NULLPTR) { (*quality) = static_cast(maxResponse) - static_cast(secondResponse); } return target; } template void NeuralNetworkMachineLearningModel::Save(const std::string & filename, const std::string & name) { const char* lname = "my_nn"; if ( !name.empty() ) lname = name.c_str(); CvFileStorage* fs = ITK_NULLPTR; fs = cvOpenFileStorage(filename.c_str(), ITK_NULLPTR, CV_STORAGE_WRITE); if ( !fs ) { itkExceptionMacro("Could not open the file " << filename << " for writing"); } m_ANNModel->write(fs, lname); if (m_CvMatOfLabels != ITK_NULLPTR) cvWrite(fs, "class_labels", m_CvMatOfLabels); cvReleaseFileStorage(&fs); } template void NeuralNetworkMachineLearningModel::Load(const std::string & filename, const std::string & name) { const char* lname = ITK_NULLPTR; if ( !name.empty() ) lname = name.c_str(); cv::FileNode model_node; cv::FileStorage fs(filename,cv::FileStorage::READ); if (!fs.isOpened()) { itkExceptionMacro("Could not open the file " << filename << " for reading"); } if( lname ) model_node = fs[lname]; else { cv::FileNode root = fs.root(); if ( root.size() > 0) { model_node = *(root.begin()); } } m_ANNModel->read(*fs,*model_node); m_CvMatOfLabels = (CvMat*)cvReadByName( *fs, *model_node, "class_labels" ); fs.release(); } template bool NeuralNetworkMachineLearningModel::CanReadFile(const std::string & file) { std::ifstream ifs; ifs.open(file.c_str()); if (!ifs) { std::cerr << "Could not read file " << file << std::endl; return false; } while (!ifs.eof()) { std::string line; std::getline(ifs, line); if (line.find(CV_TYPE_NAME_ML_ANN_MLP) != std::string::npos) { //std::cout << "Reading a " << CV_TYPE_NAME_ML_ANN_MLP << " model" << std::endl; return true; } } ifs.close(); return false; } template bool NeuralNetworkMachineLearningModel::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void NeuralNetworkMachineLearningModel::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os, indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNeuralNetworkMachineLearningModelFactory.h000066400000000000000000000045531301006202600333040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeuralNetworkMachineLearningModelFactory_h #define otbNeuralNetworkMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class NeuralNetworkMachineLearningModelFactory * \brief Creation d'un instance d'un objet SVMMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT NeuralNetworkMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef NeuralNetworkMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(NeuralNetworkMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer Factory = NeuralNetworkMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(Factory); } protected: NeuralNetworkMachineLearningModelFactory(); ~NeuralNetworkMachineLearningModelFactory() ITK_OVERRIDE; private: NeuralNetworkMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNeuralNetworkMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNeuralNetworkMachineLearningModelFactory.txx000066400000000000000000000040731301006202600336750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNeuralNetworkMachineLearningModelFactory_txx #define otbNeuralNetworkMachineLearningModelFactory_txx #include "otbNeuralNetworkMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbNeuralNetworkMachineLearningModel.h" #include "itkVersion.h" namespace otb { template NeuralNetworkMachineLearningModelFactory ::NeuralNetworkMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbNeuralNetworkMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "Artificial Neural Network ML Model", 1, itk::CreateObjectFunction >::New()); } template NeuralNetworkMachineLearningModelFactory ::~NeuralNetworkMachineLearningModelFactory() { } template const char* NeuralNetworkMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* NeuralNetworkMachineLearningModelFactory ::GetDescription() const { return "Artificial Neural Network machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNormalBayesMachineLearningModel.h000066400000000000000000000065161301006202600313710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalBayesMachineLearningModel_h #define otbNormalBayesMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" class CvNormalBayesClassifier; namespace otb { template class ITK_EXPORT NormalBayesMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef NormalBayesMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(NormalBayesMachineLearningModel, MachineLearningModel); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} protected: /** Constructor */ NormalBayesMachineLearningModel(); /** Destructor */ ~NormalBayesMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: NormalBayesMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CvNormalBayesClassifier * m_NormalBayesModel; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNormalBayesMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNormalBayesMachineLearningModel.txx000066400000000000000000000100531301006202600317540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalBayesMachineLearningModel_txx #define otbNormalBayesMachineLearningModel_txx #include #include "itkMacro.h" #include "otbNormalBayesMachineLearningModel.h" #include "otbOpenCVUtils.h" namespace otb { template NormalBayesMachineLearningModel ::NormalBayesMachineLearningModel() : m_NormalBayesModel (new CvNormalBayesClassifier) { } template NormalBayesMachineLearningModel ::~NormalBayesMachineLearningModel() { delete m_NormalBayesModel; } /** Train the machine learning model */ template void NormalBayesMachineLearningModel ::Train() { //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); cv::Mat labels; otb::ListSampleToMat(this->GetTargetListSample(),labels); m_NormalBayesModel->train(samples,labels,cv::Mat(),cv::Mat(),false); } template typename NormalBayesMachineLearningModel ::TargetSampleType NormalBayesMachineLearningModel ::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(input,sample); cv::Mat missing = cv::Mat(1,input.Size(), CV_8U ); missing.setTo(0); double result = m_NormalBayesModel->predict(sample); TargetSampleType target; target[0] = static_cast(result); if (quality != ITK_NULLPTR) { if (!this->HasConfidenceIndex()) { itkExceptionMacro("Confidence index not available for this classifier !"); } } return target; } template void NormalBayesMachineLearningModel ::Save(const std::string & filename, const std::string & name) { if (name == "") m_NormalBayesModel->save(filename.c_str(), ITK_NULLPTR); else m_NormalBayesModel->save(filename.c_str(), name.c_str()); } template void NormalBayesMachineLearningModel ::Load(const std::string & filename, const std::string & name) { if (name == "") m_NormalBayesModel->load(filename.c_str(), ITK_NULLPTR); else m_NormalBayesModel->load(filename.c_str(), name.c_str()); } template bool NormalBayesMachineLearningModel ::CanReadFile(const std::string & file) { std::ifstream ifs; ifs.open(file.c_str()); if(!ifs) { std::cerr<<"Could not read file "< bool NormalBayesMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void NormalBayesMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNormalBayesMachineLearningModelFactory.h000066400000000000000000000045251301006202600327170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalBayesMachineLearningModelFactory_h #define otbNormalBayesMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class NormalBayesMachineLearningModelFactory * \brief Creation d'un instance d'un objet SVMMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT NormalBayesMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef NormalBayesMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(NormalBayesMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer Factory = NormalBayesMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(Factory); } protected: NormalBayesMachineLearningModelFactory(); ~NormalBayesMachineLearningModelFactory() ITK_OVERRIDE; private: NormalBayesMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNormalBayesMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbNormalBayesMachineLearningModelFactory.txx000066400000000000000000000040111301006202600333010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNormalBayesMachineLearningModelFactory_txx #define otbNormalBayesMachineLearningModelFactory_txx #include "otbNormalBayesMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbNormalBayesMachineLearningModel.h" #include "itkVersion.h" namespace otb { template NormalBayesMachineLearningModelFactory ::NormalBayesMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbNormalBayesMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "Normal Bayes ML Model", 1, itk::CreateObjectFunction >::New()); } template NormalBayesMachineLearningModelFactory ::~NormalBayesMachineLearningModelFactory() { } template const char* NormalBayesMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* NormalBayesMachineLearningModelFactory ::GetDescription() const { return "Normal Bayes machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbOpenCVUtils.h000066400000000000000000000076721301006202600254060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOpenCVUtils_h #define otbOpenCVUtils_h #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-align" #include #pragma GCC diagnostic pop #else #include #endif #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Woverloaded-virtual" #include #pragma GCC diagnostic pop #else #include #endif #include "OTBSupervisedExport.h" #include "itkListSample.h" namespace otb { template void SampleToMat(const T & sample, cv::Mat& output) { output.create(1,sample.Size(),CV_32FC1); // Loop on sample size for(unsigned int i = 0; i < sample.Size(); ++i) { output.at(0,i) = sample[i]; } } /** Converts a ListSample of VariableLengthVector to a CvMat. The user * is responsible for freeing the output pointer with the * cvReleaseMat function. A null pointer is resturned in case the * conversion failed. */ template void ListSampleToMat(const T * listSample, cv::Mat & output) { // Sample index unsigned int sampleIdx = 0; // Check for valid listSample if(listSample != ITK_NULLPTR && listSample->Size() > 0) { // Retrieve samples count unsigned int sampleCount = listSample->Size(); // Build an iterator typename T::ConstIterator sampleIt = listSample->Begin(); // Retrieve samples size alike const unsigned int sampleSize = listSample->GetMeasurementVectorSize(); // Allocate CvMat output.create(sampleCount,sampleSize,CV_32FC1); // Fill the cv matrix for(; sampleIt!=listSample->End(); ++sampleIt,++sampleIdx) { // Retrieve sample typename T::MeasurementVectorType sample = sampleIt.GetMeasurementVector(); // Loop on sample size for(unsigned int i = 0; i < sampleSize; ++i) { output.at(sampleIdx,i) = sample[i]; } } } } template void ListSampleToMat(typename T::Pointer listSample, cv::Mat & output) { return ListSampleToMat(listSample.GetPointer(), output); } template void ListSampleToMat(typename T::ConstPointer listSample, cv::Mat & output ) { return ListSampleToMat(listSample.GetPointer(), output); } template typename T::Pointer MatToListSample(const cv::Mat & cvmat) { // Build output type typename T::Pointer output = T::New(); // Get samples count unsigned sampleCount = cvmat.rows; // Get samples size unsigned int sampleSize = cvmat.cols; // Loop on samples for(unsigned int i = 0; i < sampleCount; ++i) { typename T::MeasurementVectorType sample; itk::NumericTraits::SetLength(sample, sampleSize); unsigned int realSampleSize = sample.Size(); for(unsigned int j = 0; j < realSampleSize; ++j) { // Don't forget to cast sample[j] = static_cast(cvmat.at(i,j)); } // PushBack the new sample output->PushBack(sample); } // return the output return output; } } #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbRandomForestsMachineLearningModel.h000066400000000000000000000214121301006202600317330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRandomForestsMachineLearningModel_h #define otbRandomForestsMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" #include "itkVariableSizeMatrix.h" #include "otbCvRTreesWrapper.h" class CvRTreesWrapper; namespace otb { template class ITK_EXPORT RandomForestsMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef RandomForestsMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; // Other typedef itk::VariableSizeMatrix VariableImportanceMatrixType; //opencv typedef typedef CvRTreesWrapper RFType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(RandomForestsMachineLearningModel, MachineLearningModel); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} //Setters of RT parameters (documentation get from opencv doxygen 2.4) itkGetMacro(MaxDepth, int); itkSetMacro(MaxDepth, int); itkGetMacro(MinSampleCount, int); itkSetMacro(MinSampleCount, int); itkGetMacro(RegressionAccuracy, double); itkSetMacro(RegressionAccuracy, double); itkGetMacro(ComputeSurrogateSplit, bool); itkSetMacro(ComputeSurrogateSplit, bool); itkGetMacro(MaxNumberOfCategories, int); itkSetMacro(MaxNumberOfCategories, int); std::vector GetPriors() const { return m_Priors; } void SetPriors(const std::vector & priors) { m_Priors = priors; } itkGetMacro(CalculateVariableImportance, bool); itkSetMacro(CalculateVariableImportance, bool); itkGetMacro(MaxNumberOfVariables, int); itkSetMacro(MaxNumberOfVariables, int); itkGetMacro(MaxNumberOfTrees, int); itkSetMacro(MaxNumberOfTrees, int); itkGetMacro(ForestAccuracy, float); itkSetMacro(ForestAccuracy, float); itkGetMacro(TerminationCriteria, int); itkSetMacro(TerminationCriteria, int); itkGetMacro(ComputeMargin, bool); itkSetMacro(ComputeMargin, bool); /** Returns a matrix containing variable importance */ VariableImportanceMatrixType GetVariableImportance(); float GetTrainError(); protected: /** Constructor */ RandomForestsMachineLearningModel(); /** Destructor */ ~RandomForestsMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /* /\** Input list sample *\/ */ /* typename InputListSampleType::Pointer m_InputListSample; */ /* /\** Target list sample *\/ */ /* typename TargetListSampleType::Pointer m_TargetListSample; */ private: RandomForestsMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CvRTreesWrapper * m_RFModel; /** The depth of the tree. A low value will likely underfit and conversely a * high value will likely overfit. The optimal value can be obtained using cross * validation or other suitable methods. */ int m_MaxDepth; /** minimum samples required at a leaf node for it to be split. A reasonable * value is a small percentage of the total data e.g. 1%. */ int m_MinSampleCount; /** Termination criteria for regression trees. If all absolute differences * between an estimated value in a node and values of train samples in this node * are less than this parameter then the node will not be split */ float m_RegressionAccuracy; bool m_ComputeSurrogateSplit; /** Cluster possible values of a categorical variable into * \f$ K \leq MaxCategories \f$ * clusters to find a suboptimal split. If a discrete variable, * on which the training procedure tries to make a split, takes more than * max_categories values, the precise best subset estimation may take a very * long time because the algorithm is exponential. Instead, many decision * trees engines (including ML) try to find sub-optimal split in this case by * clustering all the samples into max categories clusters that is some * categories are merged together. The clustering is applied only in n>2-class * classification problems for categorical variables with N > max_categories * possible values. In case of regression and 2-class classification the * optimal split can be found efficiently without employing clustering, thus * the parameter is not used in these cases. */ int m_MaxNumberOfCategories; /** The array of a priori class probabilities, sorted by the class label * value. The parameter can be used to tune the decision tree preferences toward * a certain class. For example, if you want to detect some rare anomaly * occurrence, the training base will likely contain much more normal cases than * anomalies, so a very good classification performance will be achieved just by * considering every case as normal. To avoid this, the priors can be specified, * where the anomaly probability is artificially increased (up to 0.5 or even * greater), so the weight of the misclassified anomalies becomes much bigger, * and the tree is adjusted properly. You can also think about this parameter as * weights of prediction categories which determine relative weights that you * give to misclassification. That is, if the weight of the first category is 1 * and the weight of the second category is 10, then each mistake in predicting * the second category is equivalent to making 10 mistakes in predicting the * first category. */ std::vector m_Priors; /** If true then variable importance will be calculated and then it can be * retrieved by CvRTreesWrapper::get_var_importance(). */ bool m_CalculateVariableImportance; /** The size of the randomly selected subset of features at each tree node and * that are used to find the best split(s). If you set it to 0 then the size will * be set to the square root of the total number of features. */ int m_MaxNumberOfVariables; /** The maximum number of trees in the forest (surprise, surprise). Typically * the more trees you have the better the accuracy. However, the improvement in * accuracy generally diminishes and asymptotes pass a certain number of * trees. Also to keep in mind, the number of tree increases the prediction time *linearly. */ int m_MaxNumberOfTrees; /** Sufficient accuracy (OOB error) */ float m_ForestAccuracy; /** The type of the termination criteria */ int m_TerminationCriteria; /** Whether to compute margin (difference in probability between the * 2 most voted classes) instead of confidence (probability of the most * voted class) in prediction*/ bool m_ComputeMargin; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRandomForestsMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbRandomForestsMachineLearningModel.txx000066400000000000000000000156731301006202600323430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRandomForestsMachineLearningModel_txx #define otbRandomForestsMachineLearningModel_txx #include #include "itkMacro.h" #include "otbRandomForestsMachineLearningModel.h" #include "otbOpenCVUtils.h" namespace otb { template RandomForestsMachineLearningModel ::RandomForestsMachineLearningModel() : m_RFModel (new CvRTreesWrapper), m_MaxDepth(5), m_MinSampleCount(10), m_RegressionAccuracy(0.01), m_ComputeSurrogateSplit(false), m_MaxNumberOfCategories(10), m_CalculateVariableImportance(false), m_MaxNumberOfVariables(0), m_MaxNumberOfTrees(100), m_ForestAccuracy(0.01), m_TerminationCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS), m_ComputeMargin(false) { this->m_ConfidenceIndex = true; this->m_IsRegressionSupported = true; } template RandomForestsMachineLearningModel ::~RandomForestsMachineLearningModel() { delete m_RFModel; } template float RandomForestsMachineLearningModel ::GetTrainError() { return m_RFModel->get_train_error(); } /** Train the machine learning model */ template void RandomForestsMachineLearningModel ::Train() { //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); cv::Mat labels; otb::ListSampleToMat(this->GetTargetListSample(),labels); //Mat var_type = Mat(ATTRIBUTES_PER_SAMPLE + 1, 1, CV_8U ); //std::cout << "priors " << m_Priors[0] << std::endl; //Define random forests paramneters //FIXME do this in the constructor? float * priors = m_Priors.empty() ? ITK_NULLPTR : &m_Priors.front(); CvRTParams params = CvRTParams(m_MaxDepth, // max depth m_MinSampleCount, // min sample count m_RegressionAccuracy, // regression accuracy: N/A here m_ComputeSurrogateSplit, // compute surrogate split, no missing data m_MaxNumberOfCategories, // max number of categories (use sub-optimal algorithm for larger numbers) priors, // the array of priors m_CalculateVariableImportance, // calculate variable importance m_MaxNumberOfVariables, // number of variables randomly selected at node and used to find the best split(s). m_MaxNumberOfTrees, // max number of trees in the forest m_ForestAccuracy, // forest accuracy m_TerminationCriteria // termination criteria ); cv::Mat var_type = cv::Mat(this->GetInputListSample()->GetMeasurementVectorSize() + 1, 1, CV_8U ); var_type.setTo(cv::Scalar(CV_VAR_NUMERICAL) ); // all inputs are numerical if(this->m_RegressionMode) var_type.at(this->GetInputListSample()->GetMeasurementVectorSize(), 0) = CV_VAR_NUMERICAL; else var_type.at(this->GetInputListSample()->GetMeasurementVectorSize(), 0) = CV_VAR_CATEGORICAL; //train the RT model m_RFModel->train(samples, CV_ROW_SAMPLE, labels, cv::Mat(), cv::Mat(), var_type, cv::Mat(), params); } template typename RandomForestsMachineLearningModel ::TargetSampleType RandomForestsMachineLearningModel ::DoPredict(const InputSampleType & value, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(value,sample); double result = m_RFModel->predict(sample); TargetSampleType target; target[0] = static_cast(result); if (quality != ITK_NULLPTR) { if(m_ComputeMargin) (*quality) = m_RFModel->predict_margin(sample); else (*quality) = m_RFModel->predict_confidence(sample); } return target[0]; } template void RandomForestsMachineLearningModel ::Save(const std::string & filename, const std::string & name) { if (name == "") m_RFModel->save(filename.c_str(), ITK_NULLPTR); else m_RFModel->save(filename.c_str(), name.c_str()); } template void RandomForestsMachineLearningModel ::Load(const std::string & filename, const std::string & name) { if (name == "") m_RFModel->load(filename.c_str(), ITK_NULLPTR); else m_RFModel->load(filename.c_str(), name.c_str()); } template bool RandomForestsMachineLearningModel ::CanReadFile(const std::string & file) { std::ifstream ifs; ifs.open(file.c_str()); if(!ifs) { std::cerr<<"Could not read file "<getName()) != std::string::npos) if (line.find(CV_TYPE_NAME_ML_RTREES) != std::string::npos) { //std::cout<<"Reading a "< bool RandomForestsMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template typename RandomForestsMachineLearningModel ::VariableImportanceMatrixType RandomForestsMachineLearningModel ::GetVariableImportance() { cv::Mat cvMat = m_RFModel->getVarImportance(); VariableImportanceMatrixType itkMat(cvMat.rows,cvMat.cols); for(int i =0; i(i,j); } } return itkMat; } template void RandomForestsMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbRandomForestsMachineLearningModelFactory.h000066400000000000000000000045661301006202600332760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRandomForestsMachineLearningModelFactory_h #define otbRandomForestsMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class RandomForestsMachineLearningModelFactory * \brief Creation of an instance of a RandomForestsMachineLearningModel object using the object factory * * \ingroup OTBSupervised */ template class ITK_EXPORT RandomForestsMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef RandomForestsMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RandomForestsMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer RFFactory = RandomForestsMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(RFFactory); } protected: RandomForestsMachineLearningModelFactory(); ~RandomForestsMachineLearningModelFactory() ITK_OVERRIDE; private: RandomForestsMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRandomForestsMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbRandomForestsMachineLearningModelFactory.txx000066400000000000000000000040301301006202600336540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRandomForestsMachineLearningModelFactory_txx #define otbRandomForestsMachineLearningModelFactory_txx #include "otbRandomForestsMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbRandomForestsMachineLearningModel.h" #include "itkVersion.h" namespace otb { template RandomForestsMachineLearningModelFactory ::RandomForestsMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbRandomForestsMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "RF ML Model", 1, itk::CreateObjectFunction >::New()); } template RandomForestsMachineLearningModelFactory ::~RandomForestsMachineLearningModelFactory() { } template const char* RandomForestsMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* RandomForestsMachineLearningModelFactory ::GetDescription() const { return "Random Forest machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbRequiresOpenCVCheck.h000066400000000000000000000013541301006202600270320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRequiresOpenCVCheck_h #define otbRequiresOpenCVCheck_h #include "otbConfigure.h" #ifndef OTB_USE_OPENCV # error "You need to enable OpenCV to compile this file" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbSVMMachineLearningModel.h000066400000000000000000000121531301006202600276140ustar00rootroot00000000000000 /*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMMachineLearningModel_h #define otbSVMMachineLearningModel_h #include "otbRequiresOpenCVCheck.h" #include "itkLightObject.h" #include "itkFixedArray.h" #include "otbMachineLearningModel.h" class CvSVM; namespace otb { /** * \brief OpenCV implementation of SVM algorithm. * * This machine learning model uses the OpenCV implementation of the * SVM algorithm. Since this implementation is buggy in the linear * case, we recommend users to use the LibSVM implementation instead, * through the otb::LibSVMMachineLearningModel. */ template class ITK_EXPORT SVMMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef SVMMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(SVMMachineLearningModel, MachineLearningModel); /** Train the machine learning model */ void Train() ITK_OVERRIDE; /** Save the model to file */ void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} //Setters/Getters to SVM model itkGetMacro(SVMType, int); itkSetMacro(SVMType, int); itkGetMacro(KernelType, int); itkSetMacro(KernelType, int); //CV_TERMCRIT_ITER or CV_TERMCRIT_EPS itkGetMacro(TermCriteriaType, int); itkSetMacro(TermCriteriaType, int); itkGetMacro(MaxIter, int); itkSetMacro(MaxIter, int); itkGetMacro(Epsilon, double); itkSetMacro(Epsilon, double); // for poly itkGetMacro(Degree, double); itkSetMacro(Degree, double); itkGetMacro(OutputDegree, double); // for poly/rbf/sigmoid itkGetMacro(Gamma, double); itkSetMacro(Gamma, double); itkGetMacro(OutputGamma, double); // for poly/sigmoid itkGetMacro(Coef0, double); itkSetMacro(Coef0, double); itkGetMacro(OutputCoef0, double); // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR itkGetMacro(C, double); itkSetMacro(C, double); itkGetMacro(OutputC, double); // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR itkGetMacro(Nu, double); itkSetMacro(Nu, double); itkGetMacro(OutputNu, double); // for CV_SVM_EPS_SVR itkGetMacro(P, double); itkSetMacro(P, double); itkGetMacro(OutputP, double); itkGetMacro(ParameterOptimization, bool); itkSetMacro(ParameterOptimization, bool); protected: /** Constructor */ SVMMachineLearningModel(); /** Destructor */ ~SVMMachineLearningModel() ITK_OVERRIDE; /** Predict values using the model */ TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SVMMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented CvSVM * m_SVMModel; int m_SVMType; int m_KernelType; double m_Degree; double m_Gamma; double m_Coef0; double m_C; double m_Nu; double m_P; int m_TermCriteriaType; int m_MaxIter; double m_Epsilon; bool m_ParameterOptimization; //Output parameters double m_OutputDegree; double m_OutputGamma; double m_OutputCoef0; double m_OutputC; double m_OutputNu; double m_OutputP; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbSVMMachineLearningModel.txx000066400000000000000000000140221301006202600302050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMMachineLearningModel_txx #define otbSVMMachineLearningModel_txx #include #include "itkMacro.h" #include "otbSVMMachineLearningModel.h" #include "otbOpenCVUtils.h" namespace otb { template SVMMachineLearningModel ::SVMMachineLearningModel() : m_SVMModel (new CvSVM), m_SVMType(CvSVM::C_SVC), m_KernelType(CvSVM::RBF), m_Degree(0), m_Gamma(1), m_Coef0(0), m_C(1), m_Nu(0), m_P(0), m_TermCriteriaType(CV_TERMCRIT_ITER), m_MaxIter(1000), m_Epsilon(FLT_EPSILON), m_ParameterOptimization(false), m_OutputDegree(0), m_OutputGamma(1), m_OutputCoef0(0), m_OutputC(1), m_OutputNu(0), m_OutputP(0) { this->m_ConfidenceIndex = true; this->m_IsRegressionSupported = true; } template SVMMachineLearningModel ::~SVMMachineLearningModel() { delete m_SVMModel; } /** Train the machine learning model */ template void SVMMachineLearningModel ::Train() { // Check that the SVM type is compatible with the chosen mode (classif/regression) if ( bool(m_SVMType == CvSVM::NU_SVR || m_SVMType == CvSVM::EPS_SVR) != this->m_RegressionMode) { itkGenericExceptionMacro("SVM type incompatible with chosen mode (classification or regression." "SVM types for classification are C_SVC, NU_SVC, ONE_CLASS. " "SVM types for regression are NU_SVR, EPS_SVR"); } //convert listsample to opencv matrix cv::Mat samples; otb::ListSampleToMat(this->GetInputListSample(), samples); cv::Mat labels; otb::ListSampleToMat(this->GetTargetListSample(),labels); // Set up SVM's parameters CvTermCriteria term_crit = cvTermCriteria(m_TermCriteriaType, m_MaxIter, m_Epsilon); CvSVMParams params( m_SVMType, m_KernelType, m_Degree, m_Gamma, m_Coef0, m_C, m_Nu, m_P, ITK_NULLPTR , term_crit ); // Train the SVM if (!m_ParameterOptimization) { m_SVMModel->train(samples, labels, cv::Mat(), cv::Mat(), params); } else { //Trains SVM with optimal parameters. //train_auto(const Mat& trainData, const Mat& responses, const Mat& varIdx, const Mat& sampleIdx, //CvSVMParams params, int k_fold=10, CvParamGrid Cgrid=CvSVM::get_default_grid(CvSVM::C), //CvParamGrid gammaGrid=CvSVM::get_default_grid(CvSVM::GAMMA), //CvParamGrid pGrid=CvSVM::get_default_grid(CvSVM::P), CvParamGrid nuGrid=CvSVM::get_default_grid(CvSVM::NU), //CvParamGrid coeffGrid=CvSVM::get_default_grid(CvSVM::COEF), CvParamGrid degreeGrid=CvSVM::get_default_grid(CvSVM::DEGREE), //bool balanced=false) //We used default parameters grid. If not enough, those grids should be expose to the user. m_SVMModel->train_auto(samples, labels, cv::Mat(), cv::Mat(), params); } // Export of the SVM parameters into the class SVMMachineLearningModel m_OutputDegree = m_SVMModel->get_params().degree; m_OutputGamma = m_SVMModel->get_params().gamma; m_OutputCoef0 = m_SVMModel->get_params().coef0; m_OutputC = m_SVMModel->get_params().C; m_OutputNu = m_SVMModel->get_params().nu; m_OutputP = m_SVMModel->get_params().p; } template typename SVMMachineLearningModel ::TargetSampleType SVMMachineLearningModel ::DoPredict(const InputSampleType & input, ConfidenceValueType *quality) const { //convert listsample to Mat cv::Mat sample; otb::SampleToMat(input,sample); double result = m_SVMModel->predict(sample,false); TargetSampleType target; target[0] = static_cast(result); if (quality != ITK_NULLPTR) { (*quality) = m_SVMModel->predict(sample,true); } return target; } template void SVMMachineLearningModel ::Save(const std::string & filename, const std::string & name) { if (name == "") m_SVMModel->save(filename.c_str(), ITK_NULLPTR); else m_SVMModel->save(filename.c_str(), name.c_str()); } template void SVMMachineLearningModel ::Load(const std::string & filename, const std::string & name) { if (name == "") m_SVMModel->load(filename.c_str(), ITK_NULLPTR); else m_SVMModel->load(filename.c_str(), name.c_str()); } template bool SVMMachineLearningModel ::CanReadFile(const std::string & file) { std::ifstream ifs; ifs.open(file.c_str()); if(!ifs) { std::cerr<<"Could not read file "<getName()) != std::string::npos) if (line.find(CV_TYPE_NAME_ML_SVM) != std::string::npos) { //std::cout<<"Reading a "< bool SVMMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return false; } template void SVMMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbSVMMachineLearningModelFactory.h000066400000000000000000000044031301006202600311430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMMachineLearningModelFactory_h #define otbSVMMachineLearningModelFactory_h #include "otbRequiresOpenCVCheck.h" #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class SVMMachineLearningModelFactory * \brief Creation d'un instance d'un objet SVMMachineLearningModel utilisant les object factory. * * \ingroup OTBSupervised */ template class ITK_EXPORT SVMMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef SVMMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE; const char* GetDescription(void) const ITK_OVERRIDE; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SVMMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer SVMFactory = SVMMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(SVMFactory); } protected: SVMMachineLearningModelFactory(); ~SVMMachineLearningModelFactory() ITK_OVERRIDE; private: SVMMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSVMMachineLearningModelFactory.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbSVMMachineLearningModelFactory.txx000066400000000000000000000036271301006202600315460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSVMMachineLearningModelFactory_txx #define otbSVMMachineLearningModelFactory_txx #include "otbSVMMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbSVMMachineLearningModel.h" #include "itkVersion.h" namespace otb { template SVMMachineLearningModelFactory ::SVMMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbSVMMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "SVM ML Model", 1, itk::CreateObjectFunction >::New()); } template SVMMachineLearningModelFactory ::~SVMMachineLearningModelFactory() { } template const char* SVMMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* SVMMachineLearningModelFactory ::GetDescription() const { return "SVM machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbSharkRandomForestsMachineLearningModel.h000066400000000000000000000142471301006202600327340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSharkRandomForestsMachineLearningModel_h #define otbSharkRandomForestsMachineLearningModel_h #include "otb_shark.h" #include "itkLightObject.h" #include "otbMachineLearningModel.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wignored-qualifiers" #endif #include "shark/Algorithms/Trainers/RFTrainer.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic pop #endif /** \class SharkRandomForestsMachineLearningModel * \brief Shark version of Random Forests algorithm * * This is a specialization of MachineLearningModel class allowing to * use Shark implementation of the Random Forests algorithm. * * It is noteworthy that training step is parallel. * * For more information, see * http://image.diku.dk/shark/doxygen_pages/html/classshark_1_1_r_f_trainer.html * * \ingroup OTBSupervised */ namespace otb { template class ITK_EXPORT SharkRandomForestsMachineLearningModel : public MachineLearningModel { public: /** Standard class typedefs. */ typedef SharkRandomForestsMachineLearningModel Self; typedef MachineLearningModel Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputValueType InputValueType; typedef typename Superclass::InputSampleType InputSampleType; typedef typename Superclass::InputListSampleType InputListSampleType; typedef typename Superclass::TargetValueType TargetValueType; typedef typename Superclass::TargetSampleType TargetSampleType; typedef typename Superclass::TargetListSampleType TargetListSampleType; typedef typename Superclass::ConfidenceValueType ConfidenceValueType; typedef typename Superclass::ConfidenceSampleType ConfidenceSampleType; typedef typename Superclass::ConfidenceListSampleType ConfidenceListSampleType; /** Run-time type information (and related methods). */ itkNewMacro(Self); itkTypeMacro(SharkRandomForestsMachineLearningModel, MachineLearningModel); /** Train the machine learning model */ virtual void Train() ITK_OVERRIDE; /** Save the model to file */ virtual void Save(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /** Load the model from file */ virtual void Load(const std::string & filename, const std::string & name="") ITK_OVERRIDE; /**\name Classification model file compatibility tests */ //@{ /** Is the input model file readable and compatible with the corresponding classifier ? */ virtual bool CanReadFile(const std::string &) ITK_OVERRIDE; /** Is the input model file writable and compatible with the corresponding classifier ? */ virtual bool CanWriteFile(const std::string &) ITK_OVERRIDE; //@} /** From Shark doc: Get the number of trees to grow.*/ itkGetMacro(NumberOfTrees,unsigned int); /** From Shark doc: Set the number of trees to grow.*/ itkSetMacro(NumberOfTrees,unsigned int); /** From Shark doc: Get the number of random attributes to investigate at each node.*/ itkGetMacro(MTry, unsigned int); /** From Shark doc: Set the number of random attributes to investigate at each node.*/ itkSetMacro(MTry, unsigned int); /** From Shark doc: Controls when a node is considered pure. If set * to 1, a node is pure when it only consists of a single node. */ itkGetMacro(NodeSize, unsigned int); /** From Shark doc: Controls when a node is considered pure. If * set to 1, a node is pure when it only consists of a single node. */ itkSetMacro(NodeSize, unsigned int); /** From Shark doc: Get the fraction of the original training * dataset to use as the out of bag sample. The default value is * 0.66.*/ itkGetMacro(OobRatio, float); /** From Shark doc: Set the fraction of the original training * dataset to use as the out of bag sample. The default value is 0.66. */ itkSetMacro(OobRatio, float); /** If true, margin confidence value will be computed */ itkGetMacro(ComputeMargin, bool); /** If true, margin confidence value will be computed */ itkSetMacro(ComputeMargin, bool); protected: /** Constructor */ SharkRandomForestsMachineLearningModel(); /** Destructor */ virtual ~SharkRandomForestsMachineLearningModel(); /** Predict values using the model */ virtual TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType *quality=ITK_NULLPTR) const ITK_OVERRIDE; virtual void DoPredictBatch(const InputListSampleType *, const unsigned int & startIndex, const unsigned int & size, TargetListSampleType *, ConfidenceListSampleType * = ITK_NULLPTR) const ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const; private: SharkRandomForestsMachineLearningModel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented shark::RFClassifier m_RFModel; shark::RFTrainer m_RFTrainer; unsigned int m_NumberOfTrees; unsigned int m_MTry; unsigned int m_NodeSize; float m_OobRatio; bool m_ComputeMargin; /** Confidence list sample */ ConfidenceValueType ComputeConfidence(shark::RealVector & probas, bool computeMargin) const; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSharkRandomForestsMachineLearningModel.txx" #endif #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbSharkRandomForestsMachineLearningModel.txx000066400000000000000000000166631301006202600333340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSharkRandomForestsMachineLearningModel_txx #define otbSharkRandomForestsMachineLearningModel_txx #include #include "itkMacro.h" #include "otbSharkRandomForestsMachineLearningModel.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wignored-qualifiers" #endif #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic pop #endif #include "otbSharkUtils.h" #include namespace otb { template SharkRandomForestsMachineLearningModel ::SharkRandomForestsMachineLearningModel() { this->m_ConfidenceIndex = true; this->m_IsRegressionSupported = false; this->m_IsDoPredictBatchMultiThreaded = true; } template SharkRandomForestsMachineLearningModel ::~SharkRandomForestsMachineLearningModel() { } /** Train the machine learning model */ template void SharkRandomForestsMachineLearningModel ::Train() { #ifdef _OPENMP omp_set_num_threads(itk::MultiThreader::GetGlobalDefaultNumberOfThreads()); #endif std::vector features; std::vector class_labels; Shark::ListSampleToSharkVector(this->GetInputListSample(), features); Shark::ListSampleToSharkVector(this->GetTargetListSample(), class_labels); shark::ClassificationDataset TrainSamples = shark::createLabeledDataFromRange(features,class_labels); //Set parameters m_RFTrainer.setMTry(m_MTry); m_RFTrainer.setNTrees(m_NumberOfTrees); m_RFTrainer.setNodeSize(m_NodeSize); m_RFTrainer.setOOBratio(m_OobRatio); m_RFTrainer.train(m_RFModel, TrainSamples); } template typename SharkRandomForestsMachineLearningModel ::ConfidenceValueType SharkRandomForestsMachineLearningModel ::ComputeConfidence(shark::RealVector & probas, bool computeMargin) const { assert(!probas.empty()&&"probas vector is empty"); assert((!computeMargin||probas.size()>1)&&"probas size should be at least 2 if computeMargin is true"); ConfidenceValueType conf{0}; if(computeMargin) { std::nth_element(probas.begin(), probas.begin()+1, probas.end(), std::greater()); conf = static_cast(probas[0]-probas[1]); } else { auto max_proba = *(std::max_element(probas.begin(), probas.end())); conf = static_cast(max_proba); } return conf; } template typename SharkRandomForestsMachineLearningModel ::TargetSampleType SharkRandomForestsMachineLearningModel ::DoPredict(const InputSampleType & value, ConfidenceValueType *quality) const { shark::RealVector samples(value.Size()); for(size_t i = 0; i < value.Size();i++) { samples.push_back(value[i]); } if (quality != ITK_NULLPTR) { shark::RealVector probas = m_RFModel(samples); (*quality) = ComputeConfidence(probas, m_ComputeMargin); } shark::ArgMaxConverter amc; amc.decisionFunction() = m_RFModel; unsigned int res; amc.eval(samples, res); TargetSampleType target; target[0] = static_cast(res); return target; } template void SharkRandomForestsMachineLearningModel ::DoPredictBatch(const InputListSampleType *input, const unsigned int & startIndex, const unsigned int & size, TargetListSampleType * targets, ConfidenceListSampleType * quality) const { assert(input != ITK_NULLPTR); assert(targets != ITK_NULLPTR); assert(input->Size()==targets->Size()&&"Input sample list and target label list do not have the same size."); assert(((quality==ITK_NULLPTR)||(quality->Size()==input->Size()))&&"Quality samples list is not null and does not have the same size as input samples list"); if(startIndex+size>input->Size()) { itkExceptionMacro(<<"requested range ["<Size()<<"["); } std::vector features; Shark::ListSampleRangeToSharkVector(input, features,startIndex,size); shark::Data inputSamples = shark::createDataFromRange(features); #ifdef _OPENMP omp_set_num_threads(itk::MultiThreader::GetGlobalDefaultNumberOfThreads()); #endif if(quality != ITK_NULLPTR) { shark::Data probas = m_RFModel(inputSamples); unsigned int id = startIndex; for(shark::RealVector && p : probas.elements()) { ConfidenceSampleType confidence; auto conf = ComputeConfidence(p, m_ComputeMargin); confidence[0] = static_cast(conf); quality->SetMeasurementVector(id,confidence); ++id; } } shark::ArgMaxConverter amc; amc.decisionFunction() = m_RFModel; auto prediction = amc(inputSamples); unsigned int id = startIndex; for(const auto& p : prediction.elements()) { TargetSampleType target; target[0] = static_cast(p); targets->SetMeasurementVector(id,target); ++id; } } template void SharkRandomForestsMachineLearningModel ::Save(const std::string & filename, const std::string & itkNotUsed(name)) { std::ofstream ofs(filename.c_str()); if(!ofs) { itkExceptionMacro(<< "Error opening " << filename.c_str() ); } shark::TextOutArchive oa(ofs); m_RFModel.save(oa,0); } template void SharkRandomForestsMachineLearningModel ::Load(const std::string & filename, const std::string & itkNotUsed(name)) { std::ifstream ifs(filename.c_str()); shark::TextInArchive ia(ifs); m_RFModel.load(ia,0); } template bool SharkRandomForestsMachineLearningModel ::CanReadFile(const std::string & file) { try { this->Load(file); m_RFModel.name(); } catch(...) { return false; } return true; } template bool SharkRandomForestsMachineLearningModel ::CanWriteFile(const std::string & itkNotUsed(file)) { return true; } template void SharkRandomForestsMachineLearningModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } //end namespace otb #endif otbSharkRandomForestsMachineLearningModelFactory.h000066400000000000000000000045761301006202600342110ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSharkRandomForestsMachineLearningModelFactory_h #define otbSharkRandomForestsMachineLearningModelFactory_h #include "itkObjectFactoryBase.h" #include "itkImageIOBase.h" namespace otb { /** \class SharkRandomForestsMachineLearningModelFactory * \brief Creation of an instance of a SharkRandomForestsMachineLearningModel object using the object factory * * \ingroup OTBSupervised */ template class ITK_EXPORT SharkRandomForestsMachineLearningModelFactory : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef SharkRandomForestsMachineLearningModelFactory Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ virtual const char* GetITKSourceVersion(void) const; virtual const char* GetDescription(void) const; /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SharkRandomForestsMachineLearningModelFactory, itk::ObjectFactoryBase); /** Register one factory of this type */ static void RegisterOneFactory(void) { Pointer RFFactory = SharkRandomForestsMachineLearningModelFactory::New(); itk::ObjectFactoryBase::RegisterFactory(RFFactory); } protected: SharkRandomForestsMachineLearningModelFactory(); virtual ~SharkRandomForestsMachineLearningModelFactory(); private: SharkRandomForestsMachineLearningModelFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSharkRandomForestsMachineLearningModelFactory.txx" #endif #endif otbSharkRandomForestsMachineLearningModelFactory.txx000066400000000000000000000041411301006202600345710ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSharkRandomForestsMachineLearningModelFactory_txx #define otbSharkRandomForestsMachineLearningModelFactory_txx #include "otbSharkRandomForestsMachineLearningModelFactory.h" #include "itkCreateObjectFunction.h" #include "otbSharkRandomForestsMachineLearningModel.h" #include "itkVersion.h" namespace otb { template SharkRandomForestsMachineLearningModelFactory ::SharkRandomForestsMachineLearningModelFactory() { std::string classOverride = std::string("otbMachineLearningModel"); std::string subclass = std::string("otbSharkRandomForestsMachineLearningModel"); this->RegisterOverride(classOverride.c_str(), subclass.c_str(), "Shark RF ML Model", 1, itk::CreateObjectFunction >::New()); } template SharkRandomForestsMachineLearningModelFactory ::~SharkRandomForestsMachineLearningModelFactory() { } template const char* SharkRandomForestsMachineLearningModelFactory ::GetITKSourceVersion(void) const { return ITK_SOURCE_VERSION; } template const char* SharkRandomForestsMachineLearningModelFactory ::GetDescription() const { return "Shark Random Forest machine learning model factory"; } } // end namespace otb #endif OTB-release-5.8/Modules/Learning/Supervised/include/otbSharkUtils.h000066400000000000000000000067361301006202600253240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSharkUtils_h #define otbSharkUtils_h #include "otb_shark.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #endif #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic pop #endif namespace otb { namespace Shark { template void ListSampleRangeToSharkVector(const T * listSample, std::vector & output, unsigned int start, unsigned int size) { assert(listSample != ITK_NULLPTR); if(start+size>listSample->Size()) { itkGenericExceptionMacro(<<"Requested range ["<Size()<<"["); } output.clear(); // Sample index unsigned int sampleIdx = start; //Check for valid listSample if(listSample->Size()>0) { // Retrieve samples size alike const unsigned int sampleSize = listSample->GetMeasurementVectorSize(); // Fill the output vector for (auto const endOfRange = start+size ; sampleIdx < endOfRange ; ++sampleIdx) { // Retrieve sample typename T::MeasurementVectorType const & sample = listSample->GetMeasurementVector(sampleIdx); // // Define a shark::RealVector // shark::RealVector rv(sampleSize); // // Loop on sample size // for(unsigned int i = 0; i < sampleSize; ++i) // { // rv[i] = sample[i]; // } // using std::move; // output.emplace_back(move(rv)); output.emplace_back(&sample[0], &sample[0]+sampleSize); } } } template void ListSampleRangeToSharkVector(const T * listSample, std::vector & output, unsigned int start, unsigned int size) { assert(listSample != ITK_NULLPTR); if(start+size>listSample->Size()) { itkGenericExceptionMacro(<<"Requested range ["<Size()<<"["); } output.clear(); // Sample index unsigned int sampleIdx = start; //Check for valid listSample if(listSample->Size()>0) { // Fill the output vector while(sampleIdxGetMeasurementVector(sampleIdx); // Define a shark::RealVector output.push_back(sample[0]); ++sampleIdx; } } } template void ListSampleToSharkVector(const T * listSample, std::vector & output) { assert(listSample != ITK_NULLPTR); ListSampleRangeToSharkVector(listSample,output,0U,static_cast(listSample->Size())); } template void ListSampleToSharkVector(const T * listSample, std::vector & output) { assert(listSample != ITK_NULLPTR); ListSampleRangeToSharkVector(listSample,output,0, static_cast(listSample->Size())); } } } #endif OTB-release-5.8/Modules/Learning/Supervised/otb-module.cmake000066400000000000000000000006761301006202600240000ustar00rootroot00000000000000set(DOCUMENTATION "This module provides the Orfeo Toolbox supervised classification and regression framework, currently based on OpenCV and/or libSVM") otb_module(OTBSupervised ENABLE_SHARED DEPENDS OTBBoost OTBCommon OTBITK OTBImageBase OPTIONAL_DEPENDS OTBOpenCV OTBSVMLearning OTBShark TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase OTBBoost DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Learning/Supervised/src/000077500000000000000000000000001301006202600215055ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/src/CMakeLists.txt000066400000000000000000000005701301006202600242470ustar00rootroot00000000000000set(OTBSupervised_SRC otbMachineLearningModelFactoryBase.cxx ) if(OTB_USE_OPENCV) list(APPEND OTBSupervised_SRC otbCvRTreesWrapper.cxx) endif() add_library(OTBSupervised ${OTBSupervised_SRC}) target_link_libraries(OTBSupervised ${OTBCommon_LIBRARIES} ${OTBSVMLearning_LIBRARIES} ${OTBOpenCV_LIBRARIES} ${OTBShark_LIBRARIES} ) otb_module_target(OTBSupervised) OTB-release-5.8/Modules/Learning/Supervised/src/otbCvRTreesWrapper.cxx000066400000000000000000000044301301006202600257750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbCvRTreesWrapper.h" #include #include namespace otb { CvRTreesWrapper::CvRTreesWrapper(){} CvRTreesWrapper::~CvRTreesWrapper(){} void CvRTreesWrapper::get_votes(const cv::Mat& sample, const cv::Mat& missing, CvRTreesWrapper::VotesVectorType& vote_count) const { vote_count.resize(nclasses); for( int k = 0; k < ntrees; k++ ) { CvDTreeNode* predicted_node = trees[k]->predict( sample, missing ); int class_idx = predicted_node->class_idx; CV_Assert( 0 <= class_idx && class_idx < nclasses ); ++vote_count[class_idx]; } } float CvRTreesWrapper::predict_margin(const cv::Mat& sample, const cv::Mat& missing) const { // Sanity check (division by ntrees later on) if(ntrees == 0) { return 0.; } std::vector classVotes; this->get_votes(sample, missing, classVotes); // We only sort the 2 greatest elements std::nth_element(classVotes.begin(), classVotes.begin()+1, classVotes.end(), std::greater()); float margin = static_cast(classVotes[0]-classVotes[1])/ntrees; return margin; } float CvRTreesWrapper::predict_confidence(const cv::Mat& sample, const cv::Mat& missing) const { // Sanity check (division by ntrees later on) if(ntrees == 0) { return 0.; } std::vector classVotes; this->get_votes(sample, missing, classVotes); unsigned int max_votes = *(std::max_element(classVotes.begin(), classVotes.end())); float confidence = static_cast(max_votes)/ntrees; return confidence; } } OTB-release-5.8/Modules/Learning/Supervised/src/otbMachineLearningModelFactoryBase.cxx000066400000000000000000000013151301006202600310660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMachineLearningModelFactoryBase.h" namespace otb { itk::SimpleMutexLock MachineLearningModelFactoryBase::mutex; } // end namespace otb OTB-release-5.8/Modules/Learning/Supervised/test/000077500000000000000000000000001301006202600216755ustar00rootroot000000000000000000209-SVMValidationLinearlySeparableProbEstimation.cxx000066400000000000000000000164401301006202600340360ustar00rootroot00000000000000OTB-release-5.8/Modules/Learning/Supervised/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbSVMSampleListModelEstimator.h" #include "otbSVMClassifier.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "otbSVMClassifier.h" #include "otbConfusionMatrixCalculator.h" #include /* This test show a problem with the SVM library using the probability estimation : bug 209. If the probability estimation is activated, the classifier isn't abble to find the hyperplan even if the sample are linearly seperable. cf. test leTvBug209_SVMValidationLinearlySeparableWithoutProbEstimate => OK and leTvBug209_SVMValidationLinearlySeparableWithProbEstimate => KO http://bugs.orfeo-toolbox.org/view.php?id=209 */ int main(int argc, char* argv[]) { if(argc != 14) { std::cerr<<"Usage: "< SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::FixedArray TrainingSampleType; typedef itk::Statistics::ListSample TrainingListSampleType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; typedef otb::SVMSampleListModelEstimator EstimatorType; typedef otb::SVMClassifier ClassifierType; typedef ClassifierType::OutputType ClassifierOutputType; typedef otb::ConfusionMatrixCalculator ConfusionMatrixCalculatorType; RandomGeneratorType::Pointer random = RandomGeneratorType::New(); random->SetSeed((unsigned int)0); // First, generate training and validation sets ListSampleType::Pointer trainingSamples = ListSampleType::New(); TrainingListSampleType::Pointer trainingLabels = TrainingListSampleType::New(); ListSampleType::Pointer validationSamples = ListSampleType::New(); TrainingListSampleType::Pointer validationLabels = TrainingListSampleType::New(); // Set the size of the measurement vectors trainingSamples ->SetMeasurementVectorSize(2); trainingLabels->SetMeasurementVectorSize(1); validationSamples->SetMeasurementVectorSize(2); validationLabels->SetMeasurementVectorSize(1); // Generate training set //std::ofstream training("training.csv"); for(unsigned int i =0; i < nbTrainingSamples; ++i) { // Generate a positive sample double angle = random->GetVariateWithOpenUpperRange( otb::CONST_2PI ); double radius = random->GetUniformVariate(prmin, prmax); SampleType pSample(2); pSample[0] = cpx+radius*vcl_sin(angle); pSample[1] = cpy+radius*vcl_cos(angle); TrainingSampleType label; label[0]=1; trainingSamples->PushBack(pSample); trainingLabels->PushBack(label); //training<<"1 1:"<GetVariateWithOpenUpperRange( otb::CONST_2PI ); radius = random->GetUniformVariate(nrmin, nrmax); SampleType nSample(2); nSample[0] = cnx+radius*vcl_sin(angle); nSample[1] = cny+radius*vcl_cos(angle); label[0]=2; trainingSamples->PushBack(nSample); trainingLabels->PushBack(label); //training<<"2 1:"<GetVariateWithOpenUpperRange( otb::CONST_2PI ); double radius = random->GetUniformVariate(prmin, prmax); SampleType pSample(2); pSample[0] = cpx+radius*vcl_sin(angle); pSample[1] = cpy+radius*vcl_cos(angle); TrainingSampleType label; label[0]=1; validationSamples->PushBack(pSample); validationLabels->PushBack(label); //validation<<"1 1:"<GetVariateWithOpenUpperRange( otb::CONST_2PI ); radius = random->GetUniformVariate(nrmin, nrmax); SampleType nSample(2); nSample[0] = cnx+radius*vcl_sin(angle); nSample[1] = cny+radius*vcl_cos(angle); label[0]=2; validationSamples->PushBack(nSample); validationLabels->PushBack(label); //validation<<"2 1:"<SetInputSampleList(trainingSamples); estimator->SetTrainingSampleList(trainingLabels); estimator->SetKernelType(kernel); estimator->DoProbabilityEstimates(probEstimate); // estimator->SetParametersOptimization(true); estimator->Update(); //estimator->SaveModel("model.svm"); // Classify ClassifierType::Pointer validationClassifier = ClassifierType::New(); validationClassifier->SetInput(validationSamples); validationClassifier->SetNumberOfClasses(2); validationClassifier->SetModel(estimator->GetModel()); validationClassifier->Update(); // Confusion ClassifierOutputType::ConstIterator it = validationClassifier->GetOutput()->Begin(); ClassifierOutputType::ConstIterator itEnd = validationClassifier->GetOutput()->End(); TrainingListSampleType::Pointer classifierListLabel = TrainingListSampleType::New(); while (it != itEnd) { classifierListLabel->PushBack(it.GetClassLabel()); ++it; } ConfusionMatrixCalculatorType::Pointer confMatCalc = ConfusionMatrixCalculatorType::New(); confMatCalc->SetReferenceLabels(validationLabels); confMatCalc->SetProducedLabels(classifierListLabel); confMatCalc->Compute(); std::cout<GetConfusionMatrix()<GetKappaIndex()<GetKappaIndex()!=1) { std::cerr<<"Kappa index should be 1."< PLabelType; typedef itk::Statistics::ListSample PListLabelType; typedef itk::FixedArray RLabelType; typedef itk::Statistics::ListSample RListLabelType; typedef otb::ConfusionMatrixCalculator CalculatorType; CalculatorType::Pointer calculator = CalculatorType::New(); std::cout << calculator << std::endl; return EXIT_SUCCESS; } int otbConfusionMatrixCalculatorSetListSamples(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " nbSamples nbClasses " << std::endl; return EXIT_FAILURE; } typedef itk::VariableLengthVector PLabelType; typedef itk::Statistics::ListSample PListLabelType; typedef itk::FixedArray RLabelType; typedef itk::Statistics::ListSample RListLabelType; typedef otb::ConfusionMatrixCalculator CalculatorType; CalculatorType::Pointer calculator = CalculatorType::New(); RListLabelType::Pointer refLabels = RListLabelType::New(); PListLabelType::Pointer prodLabels = PListLabelType::New(); // Set the measurement vector size for the list sample labels refLabels->SetMeasurementVectorSize(1); prodLabels->SetMeasurementVectorSize(1); int nbSamples = atoi(argv[1]); int nbClasses = atoi(argv[2]); for (int i = 0; i < nbSamples; ++i) { int label = (i % nbClasses) + 1; PLabelType plab; plab.SetSize(1); plab[0] = label; refLabels->PushBack(label); prodLabels->PushBack(plab); } calculator->SetReferenceLabels(refLabels); calculator->SetProducedLabels(prodLabels); //calculator->Compute(); return EXIT_SUCCESS; } /* compare to results obtained with source code available here http://en.wikibooks.org/wiki/Algorithm_Implementation/Statistics/Fleiss%27_kappa */ int otbConfusionMatrixCalculatorWrongSize(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " nbSamples nbClasses " << std::endl; return EXIT_FAILURE; } typedef itk::VariableLengthVector PLabelType; typedef itk::Statistics::ListSample PListLabelType; typedef itk::FixedArray RLabelType; typedef itk::Statistics::ListSample RListLabelType; typedef otb::ConfusionMatrixCalculator CalculatorType; CalculatorType::Pointer calculator = CalculatorType::New(); RListLabelType::Pointer refLabels = RListLabelType::New(); PListLabelType::Pointer prodLabels = PListLabelType::New(); // Set the measurement vector size for the list sample labels refLabels->SetMeasurementVectorSize(1); prodLabels->SetMeasurementVectorSize(1); int nbSamples = atoi(argv[1]); int nbClasses = atoi(argv[2]); for (int i = 0; i < nbSamples; ++i) { int label = (i % nbClasses) + 1; PLabelType plab; plab.SetSize(1); plab[0] = label; refLabels->PushBack(label); prodLabels->PushBack(plab); } PLabelType plab; plab.SetSize(1); plab[0] = 0; prodLabels->PushBack(plab); calculator->SetReferenceLabels(refLabels); calculator->SetProducedLabels(prodLabels); try { calculator->Compute(); } catch (itk::ExceptionObject) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbConfusionMatrixCalculatorCompute(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " nbSamples nbClasses " << std::endl; return EXIT_FAILURE; } typedef itk::VariableLengthVector PLabelType; typedef itk::Statistics::ListSample PListLabelType; typedef itk::FixedArray RLabelType; typedef itk::Statistics::ListSample RListLabelType; typedef otb::ConfusionMatrixCalculator CalculatorType; typedef CalculatorType::ConfusionMatrixType ConfusionMatrixType; CalculatorType::Pointer calculator = CalculatorType::New(); RListLabelType::Pointer refLabels = RListLabelType::New(); PListLabelType::Pointer prodLabels = PListLabelType::New(); // Set the measurement vector size for the list sample labels refLabels->SetMeasurementVectorSize(1); prodLabels->SetMeasurementVectorSize(1); int nbSamples = atoi(argv[1]); int nbClasses = atoi(argv[2]); ConfusionMatrixType confusionMatrix = ConfusionMatrixType(nbClasses, nbClasses); confusionMatrix.Fill(0); // confusionMatrix(0,1) =; // confusionMatrix(0,1) =; // confusionMatrix(0,1) =; for (int i = 0; i < nbSamples; ++i) { int label; label = (i % nbClasses) + 1; PLabelType plab; plab.SetSize(1); if (i == 0) { plab[0] = nbClasses; } else { plab[0] = label; } refLabels->PushBack(label); prodLabels->PushBack(plab); } calculator->SetReferenceLabels(refLabels); calculator->SetProducedLabels(prodLabels); //calculator->SetConfusionMatrix(confusionMatrix); calculator->Compute(); if (static_cast(calculator->GetNumberOfClasses()) != nbClasses) { std::cerr << "Wrong number of classes" << std::endl; return EXIT_FAILURE; } if (static_cast(calculator->GetNumberOfSamples()) != nbSamples) { std::cerr << "Wrong number of samples" << std::endl; return EXIT_FAILURE; } CalculatorType::ConfusionMatrixType confmat = calculator->GetConfusionMatrix(); // double totalError = 0.0; // for (int i = 0; i < nbClasses; ++i) // for (int j = 0; j < nbClasses; ++j) // { // double goodValue = 0.0; // if (i == j) goodValue = nbSamples / nbClasses; // else // if (confmat(i, j) != goodValue) totalError += confmat(i, j); // } // if (totalError > 0.001) // { // std::cerr << confmat << std::endl; // std::cerr << "Error = " << totalError << std::endl; // return EXIT_FAILURE; // } // if (calculator->GetKappaIndex() != 1.0) // { // std::cerr << "Kappa = " << calculator->GetKappaIndex() << std::endl; // return EXIT_FAILURE; // } // if (calculator->GetOverallAccuracy() != 1.0) // { // std::cerr << "OA = " << calculator->GetOverallAccuracy() << std::endl; // return EXIT_FAILURE; // } std::cout << "confusion matrix" << std::endl << confmat << std::endl; for (int itClasses = 0; itClasses < nbClasses; itClasses++) { std::cout << "Precision of class [" << itClasses << "] vs all: " << calculator->GetPrecisions()[itClasses] << std::endl; std::cout <<"Recall of class [" << itClasses << "] vs all: " << calculator->GetRecalls()[itClasses] << std::endl; std::cout <<"F-score of class [" << itClasses << "] vs all: " << calculator->GetFScores()[itClasses] << "\n" << std::endl; } std::cout << "Precision of the different class: " << calculator->GetPrecisions() << std::endl; std::cout << "Recall of the different class: " << calculator->GetRecalls() << std::endl; std::cout << "F-score of the different class: " << calculator->GetFScores() << std::endl; std::cout << "Kappa = " << calculator->GetKappaIndex() << std::endl; std::cout << "OA = " << calculator->GetOverallAccuracy() << std::endl; const double oa = 3 / static_cast(nbSamples); if (vcl_abs (calculator->GetOverallAccuracy() - oa) > 0.000001) { return EXIT_FAILURE; } else { return EXIT_SUCCESS; } } int otbConfusionMatrixCalculatorComputeWithBaseline(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef char ClassLabelType; typedef itk::VariableLengthVector PLabelType; typedef itk::Statistics::ListSample PListLabelType; typedef itk::FixedArray RLabelType; typedef itk::Statistics::ListSample RListLabelType; typedef otb::ConfusionMatrixCalculator CalculatorType; typedef CalculatorType::MeasurementType MeasurementType; CalculatorType::Pointer calculator = CalculatorType::New(); RListLabelType::Pointer refLabels = RListLabelType::New(); PListLabelType::Pointer prodLabels = PListLabelType::New(); int nbSamples = 12; int nbClasses = 4; // Reference samples: a b c d a b c d a b c d // Classified reference samples: a c c d d b c d d d d c std::vector labelsUniverse, labelsClassified; labelsUniverse.push_back('a'); labelsUniverse.push_back('b'); labelsUniverse.push_back('c'); labelsUniverse.push_back('d'); labelsClassified.push_back('a'); labelsClassified.push_back('c'); labelsClassified.push_back('c'); labelsClassified.push_back('d'); labelsClassified.push_back('d'); labelsClassified.push_back('b'); labelsClassified.push_back('c'); labelsClassified.push_back('d'); labelsClassified.push_back('d'); labelsClassified.push_back('d'); labelsClassified.push_back('d'); labelsClassified.push_back('c'); for (int i = 0; i < nbSamples; ++i) { ClassLabelType label = labelsUniverse[(i % nbClasses)]; PLabelType plab; plab.SetSize(1); plab[0] = labelsClassified[i]; if (i == 0) { prodLabels->SetMeasurementVectorSize(itk::NumericTraits::GetLength(plab)); } refLabels->PushBack(label); prodLabels->PushBack(plab); } int k = 0; RListLabelType::ConstIterator itRefLabels(refLabels->Begin()); PListLabelType::ConstIterator itProdLabels(prodLabels->Begin()); for (; itRefLabels != refLabels->End(); ++itRefLabels, ++itProdLabels) { std::cout << "refLabels[" << k << "] = " << itRefLabels.GetMeasurementVector()[0] << "; prodLabels[" << k << "] = " << itProdLabels.GetMeasurementVector()[0] << std::endl; ++k; } calculator->SetReferenceLabels(refLabels); calculator->SetProducedLabels(prodLabels); calculator->Compute(); CalculatorType::ConfusionMatrixType confmat = calculator->GetConfusionMatrix(); std::cout << std::endl; std::cout << "confusion matrix" << std::endl << confmat << std::endl; for (int itClasses = 0; itClasses < nbClasses; itClasses++) { std::cout << "Number of True Positives of class [" << labelsUniverse[itClasses] << "] = " << calculator->GetTruePositiveValues()[itClasses] << std::endl; std::cout << "Number of False Negatives of class [" << labelsUniverse[itClasses] << "] = " << calculator->GetFalseNegativeValues()[itClasses] << std::endl; std::cout << "Number of False Positives of class [" << labelsUniverse[itClasses] << "] = " << calculator->GetFalsePositiveValues()[itClasses] << std::endl; std::cout << "Number of True Negatives of class [" << labelsUniverse[itClasses] << "] = " << calculator->GetTrueNegativeValues()[itClasses] << std::endl; std::cout << "Precision of class [" << labelsUniverse[itClasses] << "] vs all: " << calculator->GetPrecisions()[itClasses] << std::endl; std::cout << "Recall of class [" << labelsUniverse[itClasses] << "] vs all: " << calculator->GetRecalls()[itClasses] << std::endl; std::cout << "F-score of class [" << labelsUniverse[itClasses] << "] vs all: " << calculator->GetFScores()[itClasses] << "\n" << std::endl; } std::cout << "Number of True Positives of the different classes: "<< calculator->GetTruePositiveValues()<< std::endl; std::cout << "Number of False Negatives of the different classes: "<< calculator->GetFalseNegativeValues()<< std::endl; std::cout << "Number of False Positives of the different classes: "<< calculator->GetFalsePositiveValues()<< std::endl; std::cout << "Number of True Negatives of the different classes: "<< calculator->GetTrueNegativeValues()<< std::endl; std::cout << "Precision of the different classes: " << calculator->GetPrecisions() << std::endl; std::cout << "Recall of the different classes: " << calculator->GetRecalls() << std::endl; std::cout << "F-score of the different classes: " << calculator->GetFScores() << std::endl; std::cout << "Kappa = " << calculator->GetKappaIndex() << std::endl; std::cout << "OA = " << calculator->GetOverallAccuracy() << std::endl; //****************************************** // Baselines for the different measurements //****************************************** /* The elements of the confusion matrix of the baseline blConfmat are assumed to be organized the following way, * for a set of labels {A, B, C, D}: * * Aclassified Bclassified Cclassified Dclassified * Areference cm11 cm12 cm13 cm14 * Breference cm21 cm22 cm23 cm24 * Creference cm31 cm32 cm33 cm34 * Dreference cm41 cm42 cm43 cm44 * * * which implies the following layout for the measurements: * * TruePositives FalseNegatives * FalsePositives TrueNegatives * */ MeasurementType blTP, blFN, blFP, blTN, blPrecisions, blRecalls, blFScores; CalculatorType::ConfusionMatrixType blConfmat; blConfmat.SetSize(nbClasses, nbClasses); blConfmat[0][0] = 1; blConfmat[0][1] = 0; blConfmat[0][2] = 0; blConfmat[0][3] = 2; blConfmat[1][0] = 0; blConfmat[1][1] = 1; blConfmat[1][2] = 1; blConfmat[1][3] = 1; blConfmat[2][0] = 0; blConfmat[2][1] = 0; blConfmat[2][2] = 2; blConfmat[2][3] = 1; blConfmat[3][0] = 0; blConfmat[3][1] = 0; blConfmat[3][2] = 1; blConfmat[3][3] = 2; blTP.SetSize(nbClasses); blTP[0] = 1; blTP[1] = 1; blTP[2] = 2; blTP[3] = 2; blFN.SetSize(nbClasses); blFN[0] = 2; blFN[1] = 2; blFN[2] = 1; blFN[3] = 1; blFP.SetSize(nbClasses); blFP[0] = 0; blFP[1] = 0; blFP[2] = 2; blFP[3] = 4; blTN.SetSize(nbClasses); blTN[0] = 9; blTN[1] = 9; blTN[2] = 7; blTN[3] = 5; blPrecisions.SetSize(nbClasses); blRecalls.SetSize(nbClasses); blFScores.SetSize(nbClasses); for (int itC = 0; itC < nbClasses; itC++) { blPrecisions[itC] = blTP[itC] / (blTP[itC] + blFP[itC]); blRecalls[itC] = blTP[itC] / (blTP[itC] + blFN[itC]); blFScores[itC] = 2 * blPrecisions[itC] * blRecalls[itC] / (blPrecisions[itC] + blRecalls[itC]); } if (confmat != blConfmat) { std::cout << std::endl; std::cout << "ERROR in Confusion Matrix" << std::endl; std::cout << "baseline confmat = " << std::endl << blConfmat << std::endl; std::cout << "calculated confmat = " << std::endl << confmat; return EXIT_FAILURE; } if (calculator->GetTruePositiveValues() != blTP) { std::cout << std::endl; std::cout << "ERROR in True Positive Values" << std::endl; std::cout << "baseline TPs = " << blTP << std::endl; std::cout << "calculated TPs = " << calculator->GetTruePositiveValues(); return EXIT_FAILURE; } if (calculator->GetFalseNegativeValues() != blFN) { std::cout << std::endl; std::cout << "ERROR in False Negative Values" << std::endl; std::cout << "baseline FNs = " << blFN << std::endl; std::cout << "calculated FNs = " << calculator->GetFalseNegativeValues(); return EXIT_FAILURE; } if (calculator->GetFalsePositiveValues() != blFP) { std::cout << std::endl; std::cout << "ERROR in False Positive Values" << std::endl; std::cout << "baseline FPs = " << blFP << std::endl; std::cout << "calculated FPs = " << calculator->GetFalsePositiveValues(); return EXIT_FAILURE; } if (calculator->GetTrueNegativeValues() != blTN) { std::cout << std::endl; std::cout << "ERROR in True Negative Values" << std::endl; std::cout << "baseline TNs = " << blTN << std::endl; std::cout << "calculated TNs = " << calculator->GetTrueNegativeValues(); return EXIT_FAILURE; } if (calculator->GetPrecisions() != blPrecisions) { std::cout << std::endl; std::cout << "ERROR in Precisions" << std::endl; std::cout << "baseline Precisions = " << blPrecisions << std::endl; std::cout << "calculated Precisions = " << calculator->GetPrecisions(); return EXIT_FAILURE; } if (calculator->GetRecalls() != blRecalls) { std::cout << std::endl; std::cout << "ERROR in Recalls" << std::endl; std::cout << "baseline Recalls = " << blRecalls << std::endl; std::cout << "calculated Recalls = " << calculator->GetRecalls(); return EXIT_FAILURE; } if (calculator->GetFScores() != blFScores) { std::cout << std::endl; std::cout << "ERROR in FScores" << std::endl; std::cout << "baseline FScores = " << blFScores << std::endl; std::cout << "calculated FScores = " << calculator->GetFScores(); return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Supervised/test/otbConfusionMatrixMeasurementsTest.cxx000066400000000000000000000600141301006202600315100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include #include "otbConfusionMatrixMeasurements.h" typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef unsigned char ClassLabelType; typedef int LabelPixelType; // filter type typedef otb::ConfusionMatrixMeasurements ConfusionMatrixMeasurementsType; typedef ConfusionMatrixMeasurementsType::MapOfClassesType MapOfClassesType; typedef ConfusionMatrixMeasurementsType::MapOfIndicesType MapOfIndicesType; typedef ConfusionMatrixMeasurementsType::MeasurementType MeasurementType; int CSVConfusionMatrixFileReader(const std::string fileName, MapOfClassesType &mapOfClassesRefClX, ConfusionMatrixType &confusionMatrixClX) { std::ifstream inFile; inFile.open(fileName.c_str()); if (!inFile) { std::cerr << "Confusion Matrix File opening problem with file:" << std::endl; std::cerr << fileName.c_str() << std::endl; return EXIT_FAILURE; } else { LabelPixelType labelRef = 0, labelProd = 0; std::string currentLine, refLabelsLine, prodLabelsLine, currentValue; const char endCommentChar = ':'; const char separatorChar = ','; const char eolChar = '\n'; std::getline(inFile, refLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, refLabelsLine, eolChar); // Gets the first line after the comment char until the End Of Line char std::getline(inFile, prodLabelsLine, endCommentChar); // Skips the comments std::getline(inFile, prodLabelsLine, eolChar); // Gets the second line after the comment char until the End Of Line char std::istringstream issRefLabelsLine(refLabelsLine); std::istringstream issProdLabelsLine(prodLabelsLine); MapOfClassesType mapOfClassesProdClX; mapOfClassesRefClX.clear(); mapOfClassesProdClX.clear(); int itLab = 0; while (issRefLabelsLine.good()) { std::getline(issRefLabelsLine, currentValue, separatorChar); labelRef = static_cast (std::atoi(currentValue.c_str())); mapOfClassesRefClX[labelRef] = itLab; ++itLab; } itLab = 0; while (issProdLabelsLine.good()) { std::getline(issProdLabelsLine, currentValue, separatorChar); labelProd = static_cast (std::atoi(currentValue.c_str())); mapOfClassesProdClX[labelProd] = itLab; ++itLab; } unsigned int nbRefLabelsClk = mapOfClassesRefClX.size(); unsigned int nbProdLabelsClk = mapOfClassesProdClX.size(); ConfusionMatrixType confusionMatrixClXTemp; confusionMatrixClXTemp = ConfusionMatrixType(nbRefLabelsClk, nbProdLabelsClk); confusionMatrixClXTemp.Fill(0); // Reading the confusion matrix confusionMatrixClXTemp from the file for (unsigned int itRow = 0; itRow < nbRefLabelsClk; ++itRow) { //Gets the itRow^th line after the header lines with the labels std::getline(inFile, currentLine, eolChar); std::istringstream issCurrentLine(currentLine); unsigned int itCol = 0; while (issCurrentLine.good()) { std::getline(issCurrentLine, currentValue, separatorChar); confusionMatrixClXTemp(itRow, itCol) = static_cast (std::atoi(currentValue.c_str())); ++itCol; } } MapOfClassesType::iterator itMapOfClassesRef, itMapOfClassesProd; // Formatting confusionMatrixClX from confusionMatrixClXTemp in order to make confusionMatrixClX a square matrix // from the reference labels in mapOfClassesRefClX int indiceLabelRef = 0, indiceLabelProd = 0; int indiceLabelRefTemp = 0, indiceLabelProdTemp = 0; // Initialization of confusionMatrixClX confusionMatrixClX = ConfusionMatrixType(nbRefLabelsClk, nbRefLabelsClk); confusionMatrixClX.Fill(0); for (itMapOfClassesRef = mapOfClassesRefClX.begin(); itMapOfClassesRef != mapOfClassesRefClX.end(); ++itMapOfClassesRef) { // labels labelRef of mapOfClassesRefClX are already sorted labelRef = itMapOfClassesRef->first; indiceLabelRefTemp = itMapOfClassesRef->second; for (itMapOfClassesProd = mapOfClassesProdClX.begin(); itMapOfClassesProd != mapOfClassesProdClX.end(); ++itMapOfClassesProd) { // labels labelProd of mapOfClassesProdClX are already sorted labelProd = itMapOfClassesProd->first; indiceLabelProdTemp = itMapOfClassesProd->second; // If labelProd is present in mapOfClassesRefClX if (mapOfClassesRefClX.count(labelProd) != 0) { // Indice of labelProd in mapOfClassesRefClX; itMapOfClassesRef->second elements are already SORTED indiceLabelProd = mapOfClassesRefClX[labelProd]; confusionMatrixClX(indiceLabelRef, indiceLabelProd) = confusionMatrixClXTemp(indiceLabelRefTemp, indiceLabelProdTemp); } } ++indiceLabelRef; } } inFile.close(); return EXIT_SUCCESS; } // END CSVConfusionMatrixFileReader int otbConfusionMatrixMeasurementsNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { /*typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef unsigned char LabelType; */ // filter types typedef otb::ConfusionMatrixMeasurements ConfusionMatrixMeasurements2TemplatesType; typedef otb::ConfusionMatrixMeasurements ConfusionMatrixMeasurements1TemplateType; typedef otb::ConfusionMatrixMeasurements<> ConfusionMatrixMeasurements0TemplateType; // filters ConfusionMatrixMeasurements2TemplatesType::Pointer confusionMatrixMeasurements2Templates = ConfusionMatrixMeasurements2TemplatesType::New(); ConfusionMatrixMeasurements1TemplateType::Pointer confusionMatrixMeasurements1Template = ConfusionMatrixMeasurements1TemplateType::New(); ConfusionMatrixMeasurements0TemplateType::Pointer confusionMatrixMeasurements0Template = ConfusionMatrixMeasurements0TemplateType::New(); std::cout << confusionMatrixMeasurements2Templates << std::endl; std::cout << std::endl; std::cout << confusionMatrixMeasurements1Template << std::endl; std::cout << std::endl; std::cout << confusionMatrixMeasurements0Template << std::endl; std::cout << std::endl; return EXIT_SUCCESS; } int otbConfusionMatrixMeasurementsTest(int itkNotUsed(argc), char* itkNotUsed(argv) []) { /*typedef unsigned long ConfusionMatrixEltType; typedef itk::VariableSizeMatrix ConfusionMatrixType; typedef unsigned char ClassLabelType; // filter type typedef otb::ConfusionMatrixMeasurements ConfusionMatrixMeasurementsType; typedef ConfusionMatrixMeasurementsType::MapOfClassesType MapOfClassesType; typedef ConfusionMatrixMeasurementsType::MapOfIndicesType MapOfIndicesType; typedef ConfusionMatrixMeasurementsType::MeasurementType MeasurementType; */ // mapOfClasses[label] = index in the rows/columns of the confusion matrix MapOfClassesType mapOfClasses; mapOfClasses['a'] = 0; mapOfClasses['b'] = 1; mapOfClasses['c'] = 2; mapOfClasses['d'] = 3; unsigned int nbClasses = mapOfClasses.size(); ConfusionMatrixType confMat = ConfusionMatrixType(nbClasses, nbClasses); confMat(0, 0) = 1, confMat(0, 1) = 0, confMat(0, 2) = 0, confMat(0, 3) = 2; confMat(1, 0) = 0, confMat(1, 1) = 1, confMat(1, 2) = 1, confMat(1, 3) = 1; confMat(2, 0) = 0, confMat(2, 1) = 0, confMat(2, 2) = 2, confMat(2, 3) = 1; confMat(3, 0) = 0, confMat(3, 1) = 0, confMat(3, 2) = 1, confMat(3, 3) = 2; std::cout << "confusion matrix = " << std::endl << confMat << std::endl; // filter ConfusionMatrixMeasurementsType::Pointer confMatMeasurements = ConfusionMatrixMeasurementsType::New(); confMatMeasurements->SetMapOfClasses(mapOfClasses); confMatMeasurements->SetConfusionMatrix(confMat); confMatMeasurements->Compute(); // mapOfIndices[index] = label associated to the rows/columns of the confusion matrix MapOfIndicesType mapOfIndices; MapOfIndicesType::iterator itMapOfIndices; mapOfIndices = confMatMeasurements->GetMapOfIndices(); for (itMapOfIndices = mapOfIndices.begin(); itMapOfIndices != mapOfIndices.end(); ++itMapOfIndices) { unsigned int itClasses = itMapOfIndices->first; ClassLabelType label = itMapOfIndices->second; std::cout << "Number of True Positives of class [" << label << "] = " << confMatMeasurements->GetTruePositiveValues()[itClasses] << std::endl; std::cout << "Number of False Negatives of class [" << label << "] = " << confMatMeasurements->GetFalseNegativeValues()[itClasses] << std::endl; std::cout << "Number of False Positives of class [" << label << "] = " << confMatMeasurements->GetFalsePositiveValues()[itClasses] << std::endl; std::cout << "Number of True Negatives of class [" << label << "] = " << confMatMeasurements->GetTrueNegativeValues()[itClasses] << std::endl; std::cout << "Precision of class [" << label << "] vs all: " << confMatMeasurements->GetPrecisions()[itClasses] << std::endl; std::cout << "Recall of class [" << label << "] vs all: " << confMatMeasurements->GetRecalls()[itClasses] << std::endl; std::cout << "F-score of class [" << label << "] vs all: " << confMatMeasurements->GetFScores()[itClasses] << "\n" << std::endl; } std::cout << "Number of True Positives of the different classes: "<< confMatMeasurements->GetTruePositiveValues()<< std::endl; std::cout << "Number of False Negatives of the different classes: "<< confMatMeasurements->GetFalseNegativeValues()<< std::endl; std::cout << "Number of False Positives of the different classes: "<< confMatMeasurements->GetFalsePositiveValues()<< std::endl; std::cout << "Number of True Negatives of the different classes: "<< confMatMeasurements->GetTrueNegativeValues()<< std::endl; std::cout << "Precision of the different classes: " << confMatMeasurements->GetPrecisions() << std::endl; std::cout << "Recall of the different classes: " << confMatMeasurements->GetRecalls() << std::endl; std::cout << "F-score of the different classes: " << confMatMeasurements->GetFScores() << std::endl; std::cout << "Kappa = " << confMatMeasurements->GetKappaIndex() << std::endl; std::cout << "OA = " << confMatMeasurements->GetOverallAccuracy() << std::endl; //****************************************** // Baselines for the different measurements //****************************************** /* The elements of the confusion matrix of the baseline blConfmat are assumed to be organized the following way, * for a set of labels {A, B, C, D}: * * Aclassified Bclassified Cclassified Dclassified * Areference cm11 cm12 cm13 cm14 * Breference cm21 cm22 cm23 cm24 * Creference cm31 cm32 cm33 cm34 * Dreference cm41 cm42 cm43 cm44 * * * which implies the following layout for the measurements: * * TruePositives FalseNegatives * FalsePositives TrueNegatives * */ MeasurementType blTP, blFN, blFP, blTN, blPrecisions, blRecalls, blFScores; blTP.SetSize(nbClasses); blTP[0] = 1; blTP[1] = 1; blTP[2] = 2; blTP[3] = 2; blFN.SetSize(nbClasses); blFN[0] = 2; blFN[1] = 2; blFN[2] = 1; blFN[3] = 1; blFP.SetSize(nbClasses); blFP[0] = 0; blFP[1] = 0; blFP[2] = 2; blFP[3] = 4; blTN.SetSize(nbClasses); blTN[0] = 9; blTN[1] = 9; blTN[2] = 7; blTN[3] = 5; blPrecisions.SetSize(nbClasses); blRecalls.SetSize(nbClasses); blFScores.SetSize(nbClasses); for (unsigned int itC = 0; itC < nbClasses; itC++) { blPrecisions[itC] = blTP[itC] / (blTP[itC] + blFP[itC]); blRecalls[itC] = blTP[itC] / (blTP[itC] + blFN[itC]); blFScores[itC] = 2 * blPrecisions[itC] * blRecalls[itC] / (blPrecisions[itC] + blRecalls[itC]); } if (confMatMeasurements->GetTruePositiveValues() != blTP) { std::cout << std::endl; std::cout << "ERROR in True Positive Values" << std::endl; std::cout << "baseline TPs = " << blTP << std::endl; std::cout << "calculated TPs = " << confMatMeasurements->GetTruePositiveValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetFalseNegativeValues() != blFN) { std::cout << std::endl; std::cout << "ERROR in False Negative Values" << std::endl; std::cout << "baseline FNs = " << blFN << std::endl; std::cout << "calculated FNs = " << confMatMeasurements->GetFalseNegativeValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetFalsePositiveValues() != blFP) { std::cout << std::endl; std::cout << "ERROR in False Positive Values" << std::endl; std::cout << "baseline FPs = " << blFP << std::endl; std::cout << "calculated FPs = " << confMatMeasurements->GetFalsePositiveValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetTrueNegativeValues() != blTN) { std::cout << std::endl; std::cout << "ERROR in True Negative Values" << std::endl; std::cout << "baseline TNs = " << blTN << std::endl; std::cout << "calculated TNs = " << confMatMeasurements->GetTrueNegativeValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetPrecisions() != blPrecisions) { std::cout << std::endl; std::cout << "ERROR in Precisions" << std::endl; std::cout << "baseline Precisions = " << blPrecisions << std::endl; std::cout << "calculated Precisions = " << confMatMeasurements->GetPrecisions(); return EXIT_FAILURE; } if (confMatMeasurements->GetRecalls() != blRecalls) { std::cout << std::endl; std::cout << "ERROR in Recalls" << std::endl; std::cout << "baseline Recalls = " << blRecalls << std::endl; std::cout << "calculated Recalls = " << confMatMeasurements->GetRecalls(); return EXIT_FAILURE; } if (confMatMeasurements->GetFScores() != blFScores) { std::cout << std::endl; std::cout << "ERROR in FScores" << std::endl; std::cout << "baseline FScores = " << blFScores << std::endl; std::cout << "calculated FScores = " << confMatMeasurements->GetFScores(); return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbConfusionMatrixConcatenateTest(int argc, char* argv[]) { unsigned nbClassifiers = argc - 1; MapOfClassesType mapOfClasses; MapOfIndicesType mapOfIndices; MapOfIndicesType::iterator itMapOfIndices; ConfusionMatrixType addConfusionMatrix; unsigned int nbClasses = 0; for (unsigned itClk = 0; itClk < nbClassifiers; ++itClk) { std::string fileNameCMClk= argv[itClk + 1]; MapOfClassesType mapOfClassesClk; ConfusionMatrixType confusionMatrixClk; CSVConfusionMatrixFileReader(fileNameCMClk, mapOfClassesClk, confusionMatrixClk); std::cout << fileNameCMClk << std::endl; std::cout << "confusion matrix[" << itClk << "] = " << std::endl << confusionMatrixClk << std::endl; nbClasses = confusionMatrixClk.Rows(); if (itClk == 0) { mapOfClasses = mapOfClassesClk; addConfusionMatrix = ConfusionMatrixType(nbClasses, nbClasses); addConfusionMatrix.Fill(0); } for (unsigned itRow = 0; itRow < nbClasses; ++itRow) { for (unsigned itCol = 0; itCol < nbClasses; ++itCol) { addConfusionMatrix(itRow, itCol) += confusionMatrixClk(itRow, itCol); } } } std::cout << std::endl; std::cout << "*****************************************************" << std::endl; std::cout << "ADD confusion matrix = " << std::endl << addConfusionMatrix << std::endl; std::cout << "*****************************************************" << std::endl << std::endl; // filter ConfusionMatrixMeasurementsType::Pointer confMatMeasurements = ConfusionMatrixMeasurementsType::New(); confMatMeasurements->SetMapOfClasses(mapOfClasses); confMatMeasurements->SetConfusionMatrix(addConfusionMatrix); confMatMeasurements->Compute(); mapOfIndices = confMatMeasurements->GetMapOfIndices(); for (itMapOfIndices = mapOfIndices.begin(); itMapOfIndices != mapOfIndices.end(); ++itMapOfIndices) { unsigned int itClasses = itMapOfIndices->first; LabelPixelType label = itMapOfIndices->second; std::cout << "Number of True Positives of class [" << label << "] = " << confMatMeasurements->GetTruePositiveValues()[itClasses] << std::endl; std::cout << "Number of False Negatives of class [" << label << "] = " << confMatMeasurements->GetFalseNegativeValues()[itClasses] << std::endl; std::cout << "Number of False Positives of class [" << label << "] = " << confMatMeasurements->GetFalsePositiveValues()[itClasses] << std::endl; std::cout << "Number of True Negatives of class [" << label << "] = " << confMatMeasurements->GetTrueNegativeValues()[itClasses] << std::endl; std::cout << "Precision of class [" << label << "] vs all: " << confMatMeasurements->GetPrecisions()[itClasses] << std::endl; std::cout << "Recall of class [" << label << "] vs all: " << confMatMeasurements->GetRecalls()[itClasses] << std::endl; std::cout << "F-score of class [" << label << "] vs all: " << confMatMeasurements->GetFScores()[itClasses] << "\n" << std::endl; } std::cout << "Number of True Positives of the different classes: "<< confMatMeasurements->GetTruePositiveValues()<< std::endl; std::cout << "Number of False Negatives of the different classes: "<< confMatMeasurements->GetFalseNegativeValues()<< std::endl; std::cout << "Number of False Positives of the different classes: "<< confMatMeasurements->GetFalsePositiveValues()<< std::endl; std::cout << "Number of True Negatives of the different classes: "<< confMatMeasurements->GetTrueNegativeValues()<< std::endl; std::cout << "Precision of the different classes: " << confMatMeasurements->GetPrecisions() << std::endl; std::cout << "Recall of the different classes: " << confMatMeasurements->GetRecalls() << std::endl; std::cout << "F-score of the different classes: " << confMatMeasurements->GetFScores() << std::endl; std::cout << "Kappa = " << confMatMeasurements->GetKappaIndex() << std::endl; std::cout << "OA = " << confMatMeasurements->GetOverallAccuracy() << std::endl; //****************************************** // Baselines for the different measurements //****************************************** MeasurementType blTP, blFN, blFP, blTN, blPrecisions, blRecalls, blFScores; ConfusionMatrixType addConfusionMatrixBL = ConfusionMatrixType(nbClasses, nbClasses); addConfusionMatrixBL.Fill(0); addConfusionMatrixBL(0, 0) = 16162 + 20710 + 19343 + 20774 + 19283 + 19859; addConfusionMatrixBL(0, 1) = 8256 + 3670 + 4291 + 3217 + 5071 + 4300; addConfusionMatrixBL(0, 2) = 0 + 40 + 778 + 428 + 66 + 261; addConfusionMatrixBL(0, 3) = 2 + 0 + 8 + 1 + 0 + 0; addConfusionMatrixBL(1, 0) = 1 + 1057 + 133 + 1202 + 459 + 466; addConfusionMatrixBL(1, 1) = 49740 + 45567 + 44634 + 62128 + 54688 + 48593; addConfusionMatrixBL(1, 2) = 339 + 4 + 0 + 2816 + 2458 + 4654; addConfusionMatrixBL(1, 3) = 18213 + 21665 + 23526 + 2147 + 10688 + 14580; addConfusionMatrixBL(2, 0) = 4577 + 102 + 0 + 0 + 0 + 0; addConfusionMatrixBL(2, 1) = 1993 + 15338 + 17457 + 9438 + 17975 + 13786; addConfusionMatrixBL(2, 2) = 134151 + 121792 + 123262 + 130822 + 121608 + 124928; addConfusionMatrixBL(2, 3) = 45 + 3534 + 47 + 506 + 1183 + 2052; addConfusionMatrixBL(3, 0) = 0 + 0 + 0 + 0 + 0 + 0; addConfusionMatrixBL(3, 1) = 2748 + 2583 + 6928 + 4685 + 265 + 54; addConfusionMatrixBL(3, 2) = 7879 + 3483 + 2576 + 8007 + 8169 + 9991; addConfusionMatrixBL(3, 3) = 18038 + 22599 + 19161 + 15973 + 20231 + 18620; blTP.SetSize(nbClasses); blTP[0] = 116131; blTP[1] = 305350; blTP[2] = 756563; blTP[3] = 114622; blFN.SetSize(nbClasses); blFN[0] = 30389; blFN[1] = 104408; blFN[2] = 88033; blFN[3] = 57368; blFP.SetSize(nbClasses); blFP[0] = 7997; blFP[1] = 122055; blFP[2] = 51949; blFP[3] = 98197; blTN.SetSize(nbClasses); blTN[0] = 1418347; blTN[1] = 1041051; blTN[2] = 676319; blTN[3] = 1302677; blPrecisions.SetSize(nbClasses); blRecalls.SetSize(nbClasses); blFScores.SetSize(nbClasses); for (unsigned int itC = 0; itC < nbClasses; itC++) { blPrecisions[itC] = blTP[itC] / (blTP[itC] + blFP[itC]); blRecalls[itC] = blTP[itC] / (blTP[itC] + blFN[itC]); blFScores[itC] = 2 * blPrecisions[itC] * blRecalls[itC] / (blPrecisions[itC] + blRecalls[itC]); } if (addConfusionMatrix != addConfusionMatrixBL) { std::cout << std::endl; std::cout << "ERROR in addConfusionMatrix" << std::endl; std::cout << "baseline addConfusionMatrixBL = " << std::endl << addConfusionMatrixBL << std::endl; std::cout << "calculated addConfusionMatrix = " << std::endl << addConfusionMatrix; return EXIT_FAILURE; } if (confMatMeasurements->GetTruePositiveValues() != blTP) { std::cout << std::endl; std::cout << "ERROR in True Positive Values" << std::endl; std::cout << "baseline TPs = " << blTP << std::endl; std::cout << "calculated TPs = " << confMatMeasurements->GetTruePositiveValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetFalseNegativeValues() != blFN) { std::cout << std::endl; std::cout << "ERROR in False Negative Values" << std::endl; std::cout << "baseline FNs = " << blFN << std::endl; std::cout << "calculated FNs = " << confMatMeasurements->GetFalseNegativeValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetFalsePositiveValues() != blFP) { std::cout << std::endl; std::cout << "ERROR in False Positive Values" << std::endl; std::cout << "baseline FPs = " << blFP << std::endl; std::cout << "calculated FPs = " << confMatMeasurements->GetFalsePositiveValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetTrueNegativeValues() != blTN) { std::cout << std::endl; std::cout << "ERROR in True Negative Values" << std::endl; std::cout << "baseline TNs = " << blTN << std::endl; std::cout << "calculated TNs = " << confMatMeasurements->GetTrueNegativeValues(); return EXIT_FAILURE; } if (confMatMeasurements->GetPrecisions() != blPrecisions) { std::cout << std::endl; std::cout << "ERROR in Precisions" << std::endl; std::cout << "baseline Precisions = " << blPrecisions << std::endl; std::cout << "calculated Precisions = " << confMatMeasurements->GetPrecisions(); return EXIT_FAILURE; } if (confMatMeasurements->GetRecalls() != blRecalls) { std::cout << std::endl; std::cout << "ERROR in Recalls" << std::endl; std::cout << "baseline Recalls = " << blRecalls << std::endl; std::cout << "calculated Recalls = " << confMatMeasurements->GetRecalls(); return EXIT_FAILURE; } if (confMatMeasurements->GetFScores() != blFScores) { std::cout << std::endl; std::cout << "ERROR in FScores" << std::endl; std::cout << "baseline FScores = " << blFScores << std::endl; std::cout << "calculated FScores = " << confMatMeasurements->GetFScores(); return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Supervised/test/otbImageClassificationFilter.cxx000066400000000000000000000064731301006202600302040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageClassificationFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMachineLearningModelFactory.h" const unsigned int Dimension = 2; typedef double PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::ImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::ModelType ModelType; typedef ClassificationFilterType::ValueType ValueType; typedef ClassificationFilterType::LabelType LabelType; typedef otb::MachineLearningModelFactory MachineLearningModelFactoryType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; int otbImageClassificationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); return EXIT_SUCCESS; } int otbImageClassificationFilterLoadModel(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * modelfname = argv[2]; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); ModelType::Pointer model; model = MachineLearningModelFactoryType::CreateMachineLearningModel(modelfname, MachineLearningModelFactoryType::ReadMode); if (model.IsNull()) { std::cerr << "Unable to create a model from " << modelfname << std::endl; return EXIT_FAILURE; } model->Load(modelfname); return EXIT_SUCCESS; } int otbImageClassificationFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * modelfname = argv[2]; const char * outfname = argv[3]; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); ModelType::Pointer model; model = MachineLearningModelFactoryType::CreateMachineLearningModel(modelfname, MachineLearningModelFactoryType::ReadMode); if (model.IsNull()) { std::cerr << "Unable to create a model from " << modelfname << std::endl; return EXIT_FAILURE; } model->Load(modelfname); filter->SetModel(model); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Supervised/test/otbMachineLearningModelCanRead.cxx000066400000000000000000000232151301006202600303540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include typedef otb::MachineLearningModel MachineLearningModelType; typedef MachineLearningModelType::InputValueType InputValueType; typedef MachineLearningModelType::InputSampleType InputSampleType; typedef MachineLearningModelType::InputListSampleType InputListSampleType; typedef MachineLearningModelType::TargetValueType TargetValueType; typedef MachineLearningModelType::TargetSampleType TargetSampleType; typedef MachineLearningModelType::TargetListSampleType TargetListSampleType; #ifdef OTB_USE_LIBSVM #include "otbLibSVMMachineLearningModel.h" int otbLibSVMMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::LibSVMMachineLearningModel SVMType; SVMType::Pointer classifier = SVMType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::LibSVMMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } #endif #ifdef OTB_USE_OPENCV #include "otbSVMMachineLearningModel.h" #include "otbRandomForestsMachineLearningModel.h" #include "otbBoostMachineLearningModel.h" #include "otbNeuralNetworkMachineLearningModel.h" #include "otbNormalBayesMachineLearningModel.h" #include "otbDecisionTreeMachineLearningModel.h" #include "otbGradientBoostedTreeMachineLearningModel.h" #include "otbKNearestNeighborsMachineLearningModel.h" int otbSVMMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::SVMMachineLearningModel SVMType; SVMType::Pointer classifier = SVMType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::SVMMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbRandomForestsMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::RandomForestsMachineLearningModel RFType; RFType::Pointer classifier = RFType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::RandomForestsMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbBoostMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::BoostMachineLearningModel BoostType; BoostType::Pointer classifier = BoostType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::BoostMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbNeuralNetworkMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::NeuralNetworkMachineLearningModel ANNType; ANNType::Pointer classifier = ANNType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::NeuralNetworkMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbNormalBayesMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::NormalBayesMachineLearningModel NormalBayesType; NormalBayesType::Pointer classifier = NormalBayesType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::NormalBayesMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbDecisionTreeMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::DecisionTreeMachineLearningModel DecisionTreeType; DecisionTreeType::Pointer classifier = DecisionTreeType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::DecisionTreeMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbGradientBoostedTreeMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::GradientBoostedTreeMachineLearningModel GBTreeType; GBTreeType::Pointer classifier = GBTreeType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::GradientBoostedTreeMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbKNNMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::KNearestNeighborsMachineLearningModel KNNType; KNNType::Pointer classifier = KNNType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Erreur otb::KNearestNeighborsMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } #endif #ifdef OTB_USE_SHARK #include "otbSharkRandomForestsMachineLearningModel.h" int otbSharkRFMachineLearningModelCanRead(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << "" << std::endl; std::cerr << "Called here with " << argc << " arguments\n"; for (int i = 1; i < argc; ++i) { std::cerr << " - " << argv[i] << "\n"; } return EXIT_FAILURE; } std::string filename(argv[1]); typedef otb::SharkRandomForestsMachineLearningModel RFType; RFType::Pointer classifier = RFType::New(); bool lCanRead = classifier->CanReadFile(filename); if (lCanRead == false) { std::cerr << "Error otb::SharkRandomForestsMachineLearningModel : impossible to open the file " << filename << "." << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } #endif OTB-release-5.8/Modules/Learning/Supervised/test/otbMachineLearningRegressionTests.cxx000066400000000000000000000541701301006202600312450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbConfigure.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #if defined(OTB_USE_OPENCV) || defined(OTB_USE_LIBSVM) const double otb_epsilon_01 = 0.1; #endif #include "otbMachineLearningModel.h" #ifdef OTB_USE_OPENCV #include "otbNeuralNetworkMachineLearningModel.h" #include "otbSVMMachineLearningModel.h" #include "otbBoostMachineLearningModel.h" #include "otbDecisionTreeMachineLearningModel.h" #include "otbGradientBoostedTreeMachineLearningModel.h" #include "otbKNearestNeighborsMachineLearningModel.h" #include "otbRandomForestsMachineLearningModel.h" #endif #ifdef OTB_USE_LIBSVM #include "otbLibSVMMachineLearningModel.h" #endif typedef float PrecisionType; typedef otb::MachineLearningModel MachineLearningModelRegressionType; typedef MachineLearningModelRegressionType::InputValueType InputValueRegressionType; typedef MachineLearningModelRegressionType::InputSampleType InputSampleRegressionType; typedef MachineLearningModelRegressionType::InputListSampleType InputListSampleRegressionType; typedef MachineLearningModelRegressionType::TargetValueType TargetValueRegressionType; typedef MachineLearningModelRegressionType::TargetSampleType TargetSampleRegressionType; typedef MachineLearningModelRegressionType::TargetListSampleType TargetListSampleRegressionType; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; typedef struct RegressionTestParamStruct { double vMin; double vMax; size_t count; double eps; } RegressionTestParam; template struct LinearFunctionSampleGenerator { typedef TPrecision PrecisionType; LinearFunctionSampleGenerator(TPrecision a, TPrecision b) : m_a(a), m_b(b), m_NbInputVars(1), m_NbOutputVars(1) { m_isl = InputListSampleRegressionType::New(); m_tsl = TargetListSampleRegressionType::New(); }; void GenerateSamples(TPrecision sMin, TPrecision sMax, size_t nbSamples) { m_isl->Clear(); m_tsl->Clear(); m_isl->SetMeasurementVectorSize(m_NbInputVars); m_tsl->SetMeasurementVectorSize(m_NbOutputVars); RandomGeneratorType::Pointer randomGenerator = RandomGeneratorType::GetInstance(); InputSampleRegressionType inputSample; inputSample.SetSize(m_NbInputVars); TargetSampleRegressionType outputSample; TPrecision sampleStep = (sMax-sMin)/nbSamples; for(size_t i=0; iGetUniformVariate(0.0, 1.0) * static_cast(nbSamples); TPrecision inputValue = sMin+ x*sampleStep; inputSample[0] = inputValue; outputSample[0] = m_a*inputValue+m_b; m_isl->PushBack(inputSample); m_tsl->PushBack(outputSample); } } TPrecision m_a; TPrecision m_b; const size_t m_NbInputVars; const size_t m_NbOutputVars; InputListSampleRegressionType::Pointer m_isl; TargetListSampleRegressionType::Pointer m_tsl; }; template struct BilinearFunctionSampleGenerator { typedef TPrecision PrecisionType; BilinearFunctionSampleGenerator(TPrecision a, TPrecision b, TPrecision c) : m_a(a), m_b(b), m_c(c), m_NbInputVars(2), m_NbOutputVars(1) { m_isl = InputListSampleRegressionType::New(); m_tsl = TargetListSampleRegressionType::New(); }; void GenerateSamples(TPrecision sMin, TPrecision sMax, size_t nbSamples) { m_isl->Clear(); m_tsl->Clear(); m_isl->SetMeasurementVectorSize(m_NbInputVars); m_tsl->SetMeasurementVectorSize(m_NbOutputVars); RandomGeneratorType::Pointer randomGenerator = RandomGeneratorType::GetInstance(); InputSampleRegressionType inputSample; inputSample.SetSize(m_NbInputVars); TargetSampleRegressionType outputSample; TPrecision sampleStep = (sMax-sMin)/nbSamples; for(size_t i=0; iGetUniformVariate(0.0, 1.0) * static_cast(nbSamples); TPrecision inputValue1 = sMin+ x*sampleStep; x = randomGenerator->GetUniformVariate(0.0, 1.0) * static_cast(nbSamples); TPrecision inputValue2 = sMin+ x*sampleStep; inputSample[0] = inputValue1; inputSample[1] = inputValue2; outputSample[0] = m_a*inputValue1+m_b*inputValue2+m_c; m_isl->PushBack(inputSample); m_tsl->PushBack(outputSample); } } TPrecision m_a; TPrecision m_b; TPrecision m_c; const size_t m_NbInputVars; const size_t m_NbOutputVars; InputListSampleRegressionType::Pointer m_isl; TargetListSampleRegressionType::Pointer m_tsl; }; template struct PolynomialFunctionSampleGenerator { typedef TPrecision PrecisionType; PolynomialFunctionSampleGenerator(std::vector c) : m_c(c), m_NbInputVars(1), m_NbOutputVars(1) { m_isl = InputListSampleRegressionType::New(); m_tsl = TargetListSampleRegressionType::New(); }; void GenerateSamples(TPrecision sMin, TPrecision sMax, size_t nbSamples) { m_isl->Clear(); m_tsl->Clear(); m_isl->SetMeasurementVectorSize(m_NbInputVars); m_tsl->SetMeasurementVectorSize(m_NbOutputVars); RandomGeneratorType::Pointer randomGenerator = RandomGeneratorType::GetInstance(); InputSampleRegressionType inputSample; inputSample.SetSize(m_NbInputVars); TargetSampleRegressionType outputSample; TPrecision sampleStep = (sMax-sMin)/nbSamples; for(size_t i=0; iGetUniformVariate(0.0, 1.0) * static_cast(nbSamples); TPrecision inputValue = sMin+ x*sampleStep; inputSample[0] = inputValue; TPrecision y = 0.0; for (unsigned int j=0; j(inputValue), static_cast(j)); } outputSample[0] = y; m_isl->PushBack(inputSample); m_tsl->PushBack(outputSample); } } std::vector m_c; const size_t m_NbInputVars; const size_t m_NbOutputVars; InputListSampleRegressionType::Pointer m_isl; TargetListSampleRegressionType::Pointer m_tsl; }; template int testRegression(SampleGeneratorType& sg, RegressionType& rgrsn, RegressionTestParam param) { std::cout << "Generating training samples" << std::endl; sg.GenerateSamples(param.vMin, param.vMax, param.count); rgrsn->SetInputListSample(sg.m_isl); rgrsn->SetTargetListSample(sg.m_tsl); std::cout << "Training" << std::endl; rgrsn->Train(); std::cout << "Generate validation samples"<Begin(); typename TargetListSampleRegressionType::Iterator resultIt = sg.m_tsl->Begin(); typename InputListSampleRegressionType::Iterator sampleLast = sg.m_isl->End(); typename TargetListSampleRegressionType::Iterator resultLast = sg.m_tsl->End(); typename SampleGeneratorType::PrecisionType rmse = 0.0; while(sampleIt != sampleLast && resultIt != resultLast) { //typename SampleGeneratorType::PrecisionType invalue = sampleIt.GetMeasurementVector()[0]; typename SampleGeneratorType::PrecisionType prediction = rgrsn->Predict(sampleIt.GetMeasurementVector())[0]; typename SampleGeneratorType::PrecisionType expected = resultIt.GetMeasurementVector()[0]; rmse += std::pow(prediction - expected, static_cast(2.0)); ++sampleIt; ++resultIt; } rmse = sqrt( rmse / static_cast(param.count) ); std::cout << "RMSE = "<< rmse << std::endl; if(rmse > param.eps) { std::cout << "Failed : RMSE above expected precision !" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } #ifdef OTB_USE_LIBSVM MachineLearningModelRegressionType::Pointer getLibSVMRegressionModel() { typedef otb::LibSVMMachineLearningModel libsvmType; libsvmType::Pointer regression = libsvmType::New(); regression->SetRegressionMode(true); regression->SetSVMType(EPSILON_SVR); regression->SetKernelType(RBF); regression->SetEpsilon(1e-5); regression->SetParameterOptimization(true); return regression.GetPointer(); } int otbLibSVMRegressionTests(int itkNotUsed(argc), char * itkNotUsed(argv) []) { int status = EXIT_SUCCESS; int ret; MachineLearningModelRegressionType::Pointer regression; RegressionTestParam param; param.vMin = -0.5; param.vMax = 0.5; param.count = 200; param.eps = otb_epsilon_01; std::cout << "Testing regression on a linear monovariate function" << std::endl; LinearFunctionSampleGenerator lfsg(2.0, 1.0); regression = getLibSVMRegressionModel(); ret = testRegression(lfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a bilinear function" << std::endl; BilinearFunctionSampleGenerator bfsg(2.0,-1.0,1.0); regression = getLibSVMRegressionModel(); ret = testRegression(bfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a polynomial function" << std::endl; std::vector coeffs; coeffs.push_back(0.0); coeffs.push_back(-1.0); coeffs.push_back(0.0); coeffs.push_back(4.0); PolynomialFunctionSampleGenerator pfsg(coeffs); regression = getLibSVMRegressionModel(); ret = testRegression(pfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } return status; } #endif #ifdef OTB_USE_OPENCV MachineLearningModelRegressionType::Pointer getNeuralNetworkRegressionModel(unsigned int nbInputVar) { typedef otb::NeuralNetworkMachineLearningModel NeuralNetworkType; NeuralNetworkType::Pointer regression = NeuralNetworkType::New(); regression->SetRegressionMode(1); regression->SetTrainMethod(CvANN_MLP_TrainParams::BACKPROP); std::vector layerSizes; layerSizes.push_back(nbInputVar); layerSizes.push_back(5); layerSizes.push_back(1); regression->SetLayerSizes(layerSizes); regression->SetActivateFunction(CvANN_MLP::SIGMOID_SYM); regression->SetAlpha(1.0); regression->SetBeta(1.0); regression->SetBackPropDWScale(0.1); regression->SetBackPropMomentScale(0.1); regression->SetRegPropDW0(0.1); regression->SetRegPropDWMin(1e-7); regression->SetTermCriteriaType(CV_TERMCRIT_EPS); regression->SetEpsilon(1e-5); regression->SetMaxIter(1e4); return regression.GetPointer(); } int otbNeuralNetworkRegressionTests(int itkNotUsed(argc), char * itkNotUsed(argv) []) { int status = EXIT_SUCCESS; int ret; MachineLearningModelRegressionType::Pointer regression; RegressionTestParam param; param.vMin = -0.5; param.vMax = 0.5; param.count = 20000; param.eps = otb_epsilon_01; std::cout << "Testing regression on a linear monovariate function" << std::endl; LinearFunctionSampleGenerator lfsg(2.0, 1.0); regression = getNeuralNetworkRegressionModel(1); ret = testRegression(lfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a bilinear function" << std::endl; BilinearFunctionSampleGenerator bfsg(2.0,-1.0,1.0); regression = getNeuralNetworkRegressionModel(2); ret = testRegression(bfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a polynomial function" << std::endl; std::vector coeffs; coeffs.push_back(0.0); coeffs.push_back(-1.0); coeffs.push_back(0.0); coeffs.push_back(4.0); PolynomialFunctionSampleGenerator pfsg(coeffs); regression = getNeuralNetworkRegressionModel(1); ret = testRegression(pfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } return status; } MachineLearningModelRegressionType::Pointer getSVMRegressionModel() { typedef otb::SVMMachineLearningModel SVMType; SVMType::Pointer regression = SVMType::New(); regression->SetRegressionMode(1); regression->SetSVMType(CvSVM::NU_SVR); regression->SetNu(0.5); regression->SetKernelType(CvSVM::RBF); regression->SetTermCriteriaType(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS); regression->SetMaxIter(100000); regression->SetEpsilon(1e-5); regression->SetParameterOptimization(true); return regression.GetPointer(); } int otbSVMRegressionTests(int itkNotUsed(argc), char * itkNotUsed(argv) []) { int status = EXIT_SUCCESS; int ret; MachineLearningModelRegressionType::Pointer regression; RegressionTestParam param; param.vMin = -0.5; param.vMax = 0.5; param.count = 200; param.eps = otb_epsilon_01; std::cout << "Testing regression on a linear monovariate function" << std::endl; LinearFunctionSampleGenerator lfsg(2.0, 1.0); regression = getSVMRegressionModel(); ret = testRegression(lfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a bilinear function" << std::endl; BilinearFunctionSampleGenerator bfsg(2.0,-1.0,1.0); regression = getSVMRegressionModel(); ret = testRegression(bfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a polynomial function" << std::endl; std::vector coeffs; coeffs.push_back(0.0); coeffs.push_back(-1.0); coeffs.push_back(0.0); coeffs.push_back(4.0); PolynomialFunctionSampleGenerator pfsg(coeffs); regression = getSVMRegressionModel(); ret = testRegression(pfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } return status; } MachineLearningModelRegressionType::Pointer getDecisionTreeRegressionModel() { typedef otb::DecisionTreeMachineLearningModel DTreeType; DTreeType::Pointer regression = DTreeType::New(); regression->SetRegressionMode(true); regression->SetRegressionAccuracy(0.005); return regression.GetPointer(); } int otbDecisionTreeRegressionTests(int itkNotUsed(argc), char * itkNotUsed(argv) []) { int status = EXIT_SUCCESS; int ret; MachineLearningModelRegressionType::Pointer regression; RegressionTestParam param; param.vMin = -0.5; param.vMax = 0.5; param.count = 200; param.eps = otb_epsilon_01; std::cout << "Testing regression on a linear monovariate function" << std::endl; LinearFunctionSampleGenerator lfsg(2.0, 1.0); regression = getDecisionTreeRegressionModel(); ret = testRegression(lfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a bilinear function" << std::endl; BilinearFunctionSampleGenerator bfsg(2.0,-1.0,1.0); regression = getDecisionTreeRegressionModel(); // increase the number of training samples for bilinear function param.count = 1000; ret = testRegression(bfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a polynomial function" << std::endl; std::vector coeffs; coeffs.push_back(0.0); coeffs.push_back(-1.0); coeffs.push_back(0.0); coeffs.push_back(4.0); PolynomialFunctionSampleGenerator pfsg(coeffs); param.count = 200; regression = getDecisionTreeRegressionModel(); ret = testRegression(pfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } return status; } MachineLearningModelRegressionType::Pointer getGradientBoostedTreeRegressionModel() { typedef otb::GradientBoostedTreeMachineLearningModel GBTreeType; GBTreeType::Pointer regression = GBTreeType::New(); regression->SetRegressionMode(true); regression->SetShrinkage(0.1); regression->SetSubSamplePortion(0.8); regression->SetLossFunctionType(CvGBTrees::SQUARED_LOSS); return regression.GetPointer(); } int otbGradientBoostedTreeRegressionTests(int itkNotUsed(argc), char * itkNotUsed(argv) []) { int status = EXIT_SUCCESS; int ret; MachineLearningModelRegressionType::Pointer regression; RegressionTestParam param; param.vMin = -0.5; param.vMax = 0.5; param.count = 200; param.eps = otb_epsilon_01; std::cout << "Testing regression on a linear monovariate function" << std::endl; LinearFunctionSampleGenerator lfsg(2.0, 1.0); regression = getGradientBoostedTreeRegressionModel(); ret = testRegression(lfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a bilinear function" << std::endl; BilinearFunctionSampleGenerator bfsg(2.0,-1.0,1.0); // increase number of training samples for bilinear function param.count = 1000; regression = getGradientBoostedTreeRegressionModel(); ret = testRegression(bfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a polynomial function" << std::endl; std::vector coeffs; coeffs.push_back(0.0); coeffs.push_back(-1.0); coeffs.push_back(0.0); coeffs.push_back(4.0); PolynomialFunctionSampleGenerator pfsg(coeffs); param.count = 200; regression = getGradientBoostedTreeRegressionModel(); ret = testRegression(pfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } return status; } MachineLearningModelRegressionType::Pointer getKNearestNeighborsRegressionModel() { typedef otb::KNearestNeighborsMachineLearningModel KNNType; KNNType::Pointer regression = KNNType::New(); regression->SetRegressionMode(true); regression->SetK(5); regression->SetDecisionRule(KNNType::KNN_MEDIAN); return regression.GetPointer(); } int otbKNearestNeighborsRegressionTests(int itkNotUsed(argc), char * itkNotUsed(argv) []) { int status = EXIT_SUCCESS; int ret; MachineLearningModelRegressionType::Pointer regression; RegressionTestParam param; param.vMin = -0.5; param.vMax = 0.5; param.count = 200; param.eps = otb_epsilon_01; std::cout << "Testing regression on a linear monovariate function" << std::endl; LinearFunctionSampleGenerator lfsg(2.0, 1.0); regression = getKNearestNeighborsRegressionModel(); ret = testRegression(lfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a bilinear function" << std::endl; BilinearFunctionSampleGenerator bfsg(2.0,-1.0,1.0); regression = getKNearestNeighborsRegressionModel(); ret = testRegression(bfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a polynomial function" << std::endl; std::vector coeffs; coeffs.push_back(0.0); coeffs.push_back(-1.0); coeffs.push_back(0.0); coeffs.push_back(4.0); PolynomialFunctionSampleGenerator pfsg(coeffs); regression = getKNearestNeighborsRegressionModel(); ret = testRegression(pfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } return status; } MachineLearningModelRegressionType::Pointer getRandomForestsRegressionModel() { typedef otb::RandomForestsMachineLearningModel RFType; RFType::Pointer regression = RFType::New(); regression->SetRegressionMode(true); regression->SetRegressionAccuracy(0.005); return regression.GetPointer(); } int otbRandomForestsRegressionTests(int itkNotUsed(argc), char * itkNotUsed(argv) []) { int status = EXIT_SUCCESS; int ret; MachineLearningModelRegressionType::Pointer regression; RegressionTestParam param; param.vMin = -0.5; param.vMax = 0.5; param.count = 200; param.eps = otb_epsilon_01; std::cout << "Testing regression on a linear monovariate function" << std::endl; LinearFunctionSampleGenerator lfsg(2.0, 1.0); regression = getRandomForestsRegressionModel(); ret = testRegression(lfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a bilinear function" << std::endl; BilinearFunctionSampleGenerator bfsg(2.0,-1.0,1.0); // increase number of training samples for bilinear function param.count = 1000; regression = getRandomForestsRegressionModel(); ret = testRegression(bfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } std::cout << "Testing regression on a polynomial function" << std::endl; std::vector coeffs; coeffs.push_back(0.0); coeffs.push_back(-1.0); coeffs.push_back(0.0); coeffs.push_back(4.0); PolynomialFunctionSampleGenerator pfsg(coeffs); param.count = 200; regression = getRandomForestsRegressionModel(); ret = testRegression(pfsg,regression,param); if (ret == EXIT_FAILURE) { status = EXIT_FAILURE; } return status; } #endif OTB-release-5.8/Modules/Learning/Supervised/test/otbSharkImageClassificationFilter.cxx000066400000000000000000000137621301006202600311740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageClassificationFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSharkRandomForestsMachineLearningModelFactory.h" #include #include const unsigned int Dimension = 2; typedef float PixelType; typedef unsigned short LabeledPixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabeledImageType; typedef otb::ImageClassificationFilter ClassificationFilterType; typedef ClassificationFilterType::ModelType ModelType; typedef ClassificationFilterType::ValueType ValueType; typedef ClassificationFilterType::LabelType LabelType; typedef otb::SharkRandomForestsMachineLearningModelFactory MachineLearningModelFactoryType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader MaskReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SharkRandomForestsMachineLearningModel MachineLearningModelType; typedef MachineLearningModelType::InputValueType LocalInputValueType; typedef MachineLearningModelType::InputSampleType LocalInputSampleType; typedef MachineLearningModelType::InputListSampleType LocalInputListSampleType; typedef MachineLearningModelType::TargetValueType LocalTargetValueType; typedef MachineLearningModelType::TargetSampleType LocalTargetSampleType; typedef MachineLearningModelType::TargetListSampleType LocalTargetListSampleType; void generateSamples(unsigned int num_classes, unsigned int num_samples, unsigned int num_features, LocalInputListSampleType * samples, LocalTargetListSampleType * labels) { std::default_random_engine generator; std::uniform_int_distribution label_distribution(1,num_classes); std::uniform_int_distribution feat_distribution(0,256); for(size_t scount=0; scountSetMeasurementVectorSize(num_features); samples->PushBack(sample); labels->PushBack(label); } } void buildModel(unsigned int num_classes, unsigned int num_samples, unsigned int num_features, std::string modelfname) { LocalInputListSampleType::Pointer samples = LocalInputListSampleType::New(); LocalTargetListSampleType::Pointer labels = LocalTargetListSampleType::New(); std::cout << "Sample generation\n"; generateSamples(num_classes, num_samples, num_features, samples, labels); MachineLearningModelType::Pointer classifier = MachineLearningModelType::New(); classifier->SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->SetRegressionMode(false); classifier->SetNumberOfTrees(100); classifier->SetMTry(0); classifier->SetNodeSize(25); classifier->SetOobRatio(0.3); std::cout << "Training\n"; using TimeT = std::chrono::milliseconds; auto start = std::chrono::system_clock::now(); classifier->Train(); auto duration = std::chrono::duration_cast< TimeT> (std::chrono::system_clock::now() - start); auto elapsed = duration.count(); std::cout << "Training took " << elapsed << " ms\n"; classifier->Save(modelfname); } int otbSharkImageClassificationFilter(int argc, char * argv[]) { if(argc<5 || argc>7) { std::cout << "Usage: input_image output_image output_confidence batchmode [in_model_name] [mask_name]\n"; } std::string imfname = argv[1]; std::string outfname = argv[2]; std::string conffname = argv[3]; bool batch = (std::string(argv[4])=="1"); std::string modelfname = "/tmp/rf_model.txt"; std::string maskfname{}; MaskReaderType::Pointer mask_reader = MaskReaderType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imfname); reader->UpdateOutputInformation(); auto num_features = reader->GetOutput()->GetNumberOfComponentsPerPixel(); std::cout << "Image has " << num_features << " bands\n"; if(argc>5) { modelfname = argv[5]; } else { buildModel(3, 1000, num_features, modelfname); } ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); MachineLearningModelType::Pointer model = MachineLearningModelType::New(); model->Load(modelfname); filter->SetModel(model); filter->SetInput(reader->GetOutput()); if(argc==7) { maskfname = argv[6]; mask_reader->SetFileName(maskfname); filter->SetInputMask(mask_reader->GetOutput()); } WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); std::cout << "Classification\n"; filter->SetBatchMode(batch); filter->SetUseConfidenceMap(true); using TimeT = std::chrono::milliseconds; auto start = std::chrono::system_clock::now(); writer->Update(); auto duration = std::chrono::duration_cast< TimeT> (std::chrono::system_clock::now() - start); auto elapsed = duration.count(); std::cout << "Classification took " << elapsed << " ms\n"; auto confWriter = otb::ImageFileWriter::New(); confWriter->SetInput(filter->GetOutputConfidence()); confWriter->SetFileName(conffname); confWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Learning/Supervised/test/otbSupervisedTestDriver.cxx000066400000000000000000000054541301006202600273030ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbConfusionMatrixCalculatorNew); REGISTER_TEST(otbConfusionMatrixCalculatorSetListSamples); REGISTER_TEST(otbConfusionMatrixCalculatorWrongSize); REGISTER_TEST(otbConfusionMatrixCalculatorCompute); REGISTER_TEST(otbConfusionMatrixCalculatorComputeWithBaseline); REGISTER_TEST(otbConfusionMatrixMeasurementsNew); REGISTER_TEST(otbConfusionMatrixMeasurementsTest); REGISTER_TEST(otbConfusionMatrixConcatenateTest); #ifdef OTB_USE_LIBSVM REGISTER_TEST(otbLibSVMMachineLearningModelCanRead); #endif #ifdef OTB_USE_OPENCV REGISTER_TEST(otbSVMMachineLearningModelCanRead); REGISTER_TEST(otbRandomForestsMachineLearningModelCanRead); REGISTER_TEST(otbBoostMachineLearningModelCanRead); REGISTER_TEST(otbNeuralNetworkMachineLearningModelCanRead); REGISTER_TEST(otbNormalBayesMachineLearningModelCanRead); REGISTER_TEST(otbDecisionTreeMachineLearningModelCanRead); REGISTER_TEST(otbGradientBoostedTreeMachineLearningModelCanRead); REGISTER_TEST(otbKNNMachineLearningModelCanRead); #endif #ifdef OTB_USE_LIBSVM REGISTER_TEST(otbLibSVMMachineLearningModelNew); REGISTER_TEST(otbLibSVMMachineLearningModel); REGISTER_TEST(otbLibSVMRegressionTests); #endif #ifdef OTB_USE_OPENCV REGISTER_TEST(otbSVMMachineLearningModelNew); REGISTER_TEST(otbSVMMachineLearningModel); REGISTER_TEST(otbSVMMachineLearningRegressionModel); REGISTER_TEST(otbKNearestNeighborsMachineLearningModelNew); REGISTER_TEST(otbKNearestNeighborsMachineLearningModel); REGISTER_TEST(otbRandomForestsMachineLearningModelNew); REGISTER_TEST(otbRandomForestsMachineLearningModel); REGISTER_TEST(otbBoostMachineLearningModelNew); REGISTER_TEST(otbBoostMachineLearningModel); REGISTER_TEST(otbANNMachineLearningModelNew); REGISTER_TEST(otbANNMachineLearningModel); REGISTER_TEST(otbNormalBayesMachineLearningModelNew); REGISTER_TEST(otbNormalBayesMachineLearningModel); REGISTER_TEST(otbDecisionTreeMachineLearningModelNew); REGISTER_TEST(otbDecisionTreeMachineLearningModel); REGISTER_TEST(otbGradientBoostedTreeMachineLearningModelNew); REGISTER_TEST(otbGradientBoostedTreeMachineLearningModel); REGISTER_TEST(otbNeuralNetworkRegressionTests); REGISTER_TEST(otbSVMRegressionTests); REGISTER_TEST(otbDecisionTreeRegressionTests); REGISTER_TEST(otbGradientBoostedTreeRegressionTests); REGISTER_TEST(otbKNearestNeighborsRegressionTests); REGISTER_TEST(otbRandomForestsRegressionTests); #endif #ifdef OTB_USE_SHARK REGISTER_TEST(otbSharkRFMachineLearningModelNew); REGISTER_TEST(otbSharkRFMachineLearningModel); REGISTER_TEST(otbSharkRFMachineLearningModelCanRead); REGISTER_TEST(otbSharkImageClassificationFilter); #endif REGISTER_TEST(otbImageClassificationFilterNew); REGISTER_TEST(otbImageClassificationFilter); } OTB-release-5.8/Modules/Learning/Supervised/test/otbTrainMachineLearningModel.cxx000066400000000000000000001222171301006202600301360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include #include #include "otbConfusionMatrixCalculator.h" #include "otb_boost_string_header.h" typedef otb::MachineLearningModel MachineLearningModelType; typedef MachineLearningModelType::InputValueType InputValueType; typedef MachineLearningModelType::InputSampleType InputSampleType; typedef MachineLearningModelType::InputListSampleType InputListSampleType; typedef MachineLearningModelType::TargetValueType TargetValueType; typedef MachineLearningModelType::TargetSampleType TargetSampleType; typedef MachineLearningModelType::TargetListSampleType TargetListSampleType; typedef otb::MachineLearningModel MachineLearningModelRegressionType; typedef MachineLearningModelRegressionType::InputValueType InputValueRegressionType; typedef MachineLearningModelRegressionType::InputSampleType InputSampleRegressionType; typedef MachineLearningModelRegressionType::InputListSampleType InputListSampleRegressionType; typedef MachineLearningModelRegressionType::TargetValueType TargetValueRegressionType; typedef MachineLearningModelRegressionType::TargetSampleType TargetSampleRegressionType; typedef MachineLearningModelRegressionType::TargetListSampleType TargetListSampleRegressionType; typedef otb::ConfusionMatrixCalculator ConfusionMatrixCalculatorType; bool ReadDataFile(const std::string & infname, InputListSampleType * samples, TargetListSampleType * labels) { std::ifstream ifs; ifs.open(infname.c_str()); if(!ifs) { std::cout<<"Could not read file "<1) { InputSampleType sample(nbfeatures); sample.Fill(0); std::string::size_type pos = line.find_first_of(" ", 0); // Parse label TargetSampleType label; label[0] = atoi(line.substr(0, pos).c_str()); bool endOfLine = false; unsigned int id = 0; while(!endOfLine) { std::string::size_type nextpos = line.find_first_of(" ", pos+1); if(pos == std::string::npos) { endOfLine = true; nextpos = line.size()-1; } else { std::string feature = line.substr(pos,nextpos-pos); std::string::size_type semicolonpos = feature.find_first_of(":"); id = atoi(feature.substr(0,semicolonpos).c_str()); sample[id - 1] = atof(feature.substr(semicolonpos+1,feature.size()-semicolonpos).c_str()); pos = nextpos; } } samples->SetMeasurementVectorSize(itk::NumericTraits::GetLength(sample)); samples->PushBack(sample); labels->PushBack(label); } } //std::cout<<"Retrieved "<Size()<<" samples"<1) { InputSampleRegressionType sample(nbfeatures); sample.Fill(0); std::string::size_type pos = line.find_first_of(" ", 0); // Parse label TargetSampleRegressionType label; label[0] = atof(line.substr(0, pos).c_str()); bool endOfLine = false; unsigned int id = 0; while(!endOfLine) { std::string::size_type nextpos = line.find_first_of(" ", pos+1); if(nextpos == std::string::npos) { endOfLine = true; nextpos = line.size()-1; } else { std::string feature = line.substr(pos,nextpos-pos); std::string::size_type semicolonpos = feature.find_first_of(":"); id = atoi(feature.substr(0,semicolonpos).c_str()); sample[id - 1] = atof(feature.substr(semicolonpos+1,feature.size()-semicolonpos).c_str()); pos = nextpos; } } samples->SetMeasurementVectorSize(itk::NumericTraits::GetLength(sample)); samples->PushBack(sample); labels->PushBack(label); } } //std::cout<<"Retrieved "<Size()<<" samples"< SVMType; SVMType::Pointer svmclassifier = SVMType::New(); return EXIT_SUCCESS; } int otbLibSVMMachineLearningModel(int argc, char * argv[]) { if (argc != 3) { std::cout<<"Wrong number of arguments "< SVMType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if (!ReadDataFile(argv[1], samples, labels)) { std::cout << "Failed to read samples file " << argv[1] << std::endl; return EXIT_FAILURE; } SVMType::Pointer classifier = SVMType::New(); classifier->SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); classifier->SetTargetListSample(predicted); classifier->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout << "Confusion matrix: " << std::endl; std::cout << cmCalculator->GetConfusionMatrix() << std::endl; const float kappaIdx = cmCalculator->GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy() << std::endl; classifier->Save(argv[2]); //Load Model to new LibSVM TargetListSampleType::Pointer predictedLoad = TargetListSampleType::New(); SVMType::Pointer classifierLoad = SVMType::New(); classifierLoad->Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< SVMType; SVMType::Pointer svmclassifier = SVMType::New(); return EXIT_SUCCESS; } int otbSVMMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< SVMType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!ReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); classifier->SetTargetListSample(predicted); classifier->PredictAll(); classifier->Save(argv[2]); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< SVMType; InputListSampleRegressionType::Pointer samples = InputListSampleRegressionType::New(); TargetListSampleRegressionType::Pointer labels = TargetListSampleRegressionType::New(); TargetListSampleRegressionType::Pointer predicted = TargetListSampleRegressionType::New(); if(!ReadDataRegressionFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<SetRegressionMode(1); classifier->SetSVMType(CvSVM::EPS_SVR); classifier->SetP(10); classifier->SetKernelType(CvSVM::RBF); classifier->SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); //Predict age using first line of abalone dataset //1:-1 2:0.027027 3:0.0420168 4:-0.831858 5:-0.63733 6:-0.699395 7:-0.735352 //8:-0.704036 // Input value is 15. InputListSampleRegressionType::Pointer samplesT = InputListSampleRegressionType::New(); //Init sample list to 8 (size of abalone dataset) InputSampleRegressionType sample(8); sample.Fill(0); sample[0] = -1; sample[1] = 0.027027; sample[2] = 0.0420168; sample[3] = -0.831858; sample[4] = -0.63733; sample[5] = -0.699395; sample[6] = -0.735352; sample[7] = -0.704036; samplesT->SetMeasurementVectorSize(itk::NumericTraits::GetLength(sample)); samplesT->PushBack(sample); classifier->SetInputListSample(samplesT); classifier->SetTargetListSample(predicted); classifier->PredictAll(); const float age = 15; if ( vcl_abs(age - predicted->GetMeasurementVector(0)[0]) <= 0.3 ) { return EXIT_SUCCESS; } else { std::cout << age << "\t" << predicted->GetMeasurementVector(0)[0] << "\n"; return EXIT_FAILURE; } } int otbKNearestNeighborsMachineLearningModelNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::KNearestNeighborsMachineLearningModel KNearestNeighborsType; KNearestNeighborsType::Pointer knnclassifier = KNearestNeighborsType::New(); return EXIT_SUCCESS; } int otbKNearestNeighborsMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< KNearestNeighborsType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!ReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); //write the model classifier->Save(argv[2]); classifier->SetTargetListSample(predicted); classifier->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< RandomForestType; RandomForestType::Pointer rfclassifier = RandomForestType::New(); return EXIT_SUCCESS; } int otbRandomForestsMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< RandomForestType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!ReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "< priors(26,1.); RandomForestType::Pointer classifier = RandomForestType::New(); classifier->SetInputListSample(samples); classifier->SetTargetListSample(labels); //set parameters classifier->SetPriors(priors); // classifier->SetMaxNumberOfTrees(30); // classifier->SetMaxDepth(30); // classifier->SetMaxNumberOfCategories(30); // classifier->SetMaxNumberOfVariables(4); classifier->Train(); classifier->Save(argv[2]); classifier->SetTargetListSample(predicted); classifier->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< BoostType; BoostType::Pointer classifier = BoostType::New(); return EXIT_SUCCESS; } int otbBoostMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< BoostType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!ReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<Size(); ++itLabel) { currentLabel = labels->GetMeasurementVector(itLabel); labels->SetMeasurementVector(itLabel, (2 * (currentLabel[0] % 2)) + 1); } BoostType::Pointer classifier = BoostType::New(); classifier->SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); classifier->SetTargetListSample(predicted); classifier->PredictAll(); classifier->Save(argv[2]); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< ANNType; ANNType::Pointer classifier = ANNType::New(); return EXIT_SUCCESS; } int otbANNMachineLearningModel(int argc, char * argv[]) { if (argc != 3) { std::cout<<"Wrong number of arguments "< ANNType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if (!ReadDataFile(argv[1], samples, labels)) { std::cout << "Failed to read samples file " << argv[1] << std::endl; return EXIT_FAILURE; } std::vector layerSizes; layerSizes.push_back(16); layerSizes.push_back(100); layerSizes.push_back(100); layerSizes.push_back(26); ANNType::Pointer classifier = ANNType::New(); classifier->SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->SetLayerSizes(layerSizes); /*classifier->SetTrainMethod(CvANN_MLP_TrainParams::RPROP); classifier->SetRegPropDW0(0.1); classifier->SetRegPropDWMin(0.1); classifier->SetTermCriteriaType(CV_TERMCRIT_ITER); classifier->SetMaxIter(300); classifier->SetEpsilon(0.01); */ classifier->Train(); classifier->SetTargetListSample(predicted); classifier->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout << "Confusion matrix: " << std::endl; std::cout << cmCalculator->GetConfusionMatrix() << std::endl; const float kappaIdx = cmCalculator->GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy() << std::endl; classifier->Save(argv[2]); //Load Model to new ANN TargetListSampleType::Pointer predictedLoad = TargetListSampleType::New(); ANNType::Pointer classifierLoad = ANNType::New(); classifierLoad->Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< NormalBayesType; NormalBayesType::Pointer classifier = NormalBayesType::New(); return EXIT_SUCCESS; } int otbNormalBayesMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< NormalBayesType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!ReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); classifier->SetTargetListSample(predicted); classifier->PredictAll(); classifier->Save(argv[2]); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< DecisionTreeType; DecisionTreeType::Pointer classifier = DecisionTreeType::New(); return EXIT_SUCCESS; } int otbDecisionTreeMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< DecisionTreeType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!ReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); classifier->SetTargetListSample(predicted); classifier->PredictAll(); classifier->Save(argv[2]); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< GBTreeType; GBTreeType::Pointer classifier = GBTreeType::New(); return EXIT_SUCCESS; } int otbGradientBoostedTreeMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< GBTreeType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!ReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->Train(); classifier->SetTargetListSample(predicted); classifier->PredictAll(); classifier->Save(argv[2]); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Load(argv[2]); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); classifierLoad->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< // If shark is on, then we are using c++11 bool SharkReadDataFile(const std::string & infname, InputListSampleType * samples, TargetListSampleType * labels) { std::ifstream ifs(infname.c_str()); if(!ifs) { std::cout<<"Could not read file "<1) { InputSampleType sample(nbfeatures); sample.Fill(0); std::string::size_type pos = line.find_first_of(" ", 0); // Parse label TargetSampleType label; label[0] = std::stoi(line.substr(0, pos).c_str()); bool endOfLine = false; unsigned int id = 0; while(!endOfLine) { std::string::size_type nextpos = line.find_first_of(" ", pos+1); if(pos == std::string::npos) { endOfLine = true; nextpos = line.size()-1; } else { std::string feature = line.substr(pos,nextpos-pos); std::string::size_type semicolonpos = feature.find_first_of(":"); id = std::stoi(feature.substr(0,semicolonpos).c_str()); sample[id - 1] = atof(feature.substr(semicolonpos+1,feature.size()-semicolonpos).c_str()); pos = nextpos; } } samples->SetMeasurementVectorSize(itk::NumericTraits::GetLength(sample)); samples->PushBack(sample); labels->PushBack(label); } } //std::cout<<"Retrieved "<Size()<<" samples"<1) { InputSampleRegressionType sample(nbfeatures); sample.Fill(0); std::string::size_type pos = line.find_first_of(" ", 0); // Parse label TargetSampleRegressionType label; label[0] = atof(line.substr(0, pos).c_str()); bool endOfLine = false; unsigned int id = 0; while(!endOfLine) { std::string::size_type nextpos = line.find_first_of(" ", pos+1); if(nextpos == std::string::npos) { endOfLine = true; nextpos = line.size()-1; } else { std::string feature = line.substr(pos,nextpos-pos); std::string::size_type semicolonpos = feature.find_first_of(":"); id = std::stoi(feature.substr(0,semicolonpos).c_str()); sample[id - 1] = atof(feature.substr(semicolonpos+1,feature.size()-semicolonpos).c_str()); pos = nextpos; } } samples->SetMeasurementVectorSize(itk::NumericTraits::GetLength(sample)); samples->PushBack(sample); labels->PushBack(label); } } //std::cout<<"Retrieved "<Size()<<" samples"< SharkRFType; SharkRFType::Pointer classifier = SharkRFType::New(); return EXIT_SUCCESS; } int otbSharkRFMachineLearningModel(int argc, char * argv[]) { if (argc != 3 ) { std::cout<<"Wrong number of arguments "< RandomForestType; InputListSampleType::Pointer samples = InputListSampleType::New(); TargetListSampleType::Pointer labels = TargetListSampleType::New(); TargetListSampleType::Pointer predicted = TargetListSampleType::New(); if(!SharkReadDataFile(argv[1],samples,labels)) { std::cout<<"Failed to read samples file "<SetInputListSample(samples); classifier->SetTargetListSample(labels); classifier->SetRegressionMode(false); classifier->SetNumberOfTrees(100); classifier->SetMTry(0); classifier->SetNodeSize(25); classifier->SetOobRatio(0.3); std::cout << "Train\n"; classifier->Train(); std::cout << "Save\n"; classifier->Save(argv[2]); std::cout << "Predict\n"; classifier->SetTargetListSample(predicted); classifier->PredictAll(); ConfusionMatrixCalculatorType::Pointer cmCalculator = ConfusionMatrixCalculatorType::New(); cmCalculator->SetProducedLabels(predicted); cmCalculator->SetReferenceLabels(labels); cmCalculator->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()<Begin(); // auto lIt = labels->Begin(); // auto start = std::chrono::system_clock::now(); // for(; sIt != samples->End(); ++sIt, ++lIt) // { // classifier->Predict(sIt.GetMeasurementVector())[0]; // } // auto duration = std::chrono::duration_cast< TimeT> // (std::chrono::system_clock::now() - start); // auto elapsed = duration.count(); // std::cout << "Predict took " << elapsed << " ms\n"; // std::cout << "Single sample OA = " << oa << '\n'; //Load Model to new RF TargetListSampleType::Pointer predictedLoad = TargetListSampleType::New(); RandomForestType::Pointer classifierLoad = RandomForestType::New(); std::cout << "Load\n"; classifierLoad->Load(argv[2]); auto start = std::chrono::system_clock::now(); classifierLoad->SetInputListSample(samples); classifierLoad->SetTargetListSample(predictedLoad); std::cout << "Predict loaded\n"; classifierLoad->PredictAll(); using TimeT = std::chrono::milliseconds; auto duration = std::chrono::duration_cast< TimeT> (std::chrono::system_clock::now() - start); auto elapsed = duration.count(); std::cout << "PredictAll took " << elapsed << " ms\n"; ConfusionMatrixCalculatorType::Pointer cmCalculatorLoad = ConfusionMatrixCalculatorType::New(); cmCalculatorLoad->SetProducedLabels(predictedLoad); cmCalculatorLoad->SetReferenceLabels(labels); cmCalculatorLoad->Compute(); std::cout<<"Confusion matrix: "<GetConfusionMatrix()<GetKappaIndex(); std::cout<<"Kappa: "<GetOverallAccuracy()< Pointer; typedef itk::SmartPointer ConstPointer; /** Retrieve the singleton instance */ static Pointer Instance(); /** Run-time type information (and related methods). */ itkTypeMacro(MPIConfig, itk::LightObject); /** MPI Parameters accessors */ itkGetMacro(MyRank, unsigned int); itkGetMacro(NbProcs,unsigned int); /** Initialize MPI Processus */ void Init(int& argc, char** &argv, bool abortOnException = true); /** Abort all MPI processus. */ void abort(int errCode); /** Blocks until all processes have reached this routine */ void barrier(); /** Log error */ void logError(const std::string message); /** Log info */ void logInfo(const std::string message); protected: /** Constructor */ MPIConfig(); /** Destructor */ virtual ~MPIConfig(); private: MPIConfig(const MPIConfig &); //purposely not implemented void operator =(const MPIConfig&); //purposely not implemented // MPI rank unsigned int m_MyRank; // Number of MPI processus unsigned int m_NbProcs; // Boolean to abort on exception bool m_abortOnException; // Boolean to test if the MPI environment is initialized bool m_initialized; static Pointer m_Singleton; }; } // End namespace otb #endif //__otbMPIConfig_h OTB-release-5.8/Modules/MPI/MPIConfig/otb-module.cmake000066400000000000000000000004641301006202600223030ustar00rootroot00000000000000set(DOCUMENTATION "Provides a helper class to configure and use MPI.") otb_module(OTBMPIConfig DEPENDS OTBITK OTBImageIO OTBStreaming OTBMPI TEST_DEPENDS OTBBoost OTBImageBase OTBImageManipulation OTBMPITiffWriter OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/MPI/MPIConfig/src/000077500000000000000000000000001301006202600200155ustar00rootroot00000000000000OTB-release-5.8/Modules/MPI/MPIConfig/src/CMakeLists.txt000066400000000000000000000004741301006202600225620ustar00rootroot00000000000000#${otb-module} will be the name of this module and will not need to be #changed when this module is renamed. set(${otb-module}_SRC otbMPIConfig.cxx ) add_library(${otb-module} ${${otb-module}_SRC}) target_link_libraries(${otb-module} ${OTBCommon_LIBRARIES} ${OTBMPI_LIBRARIES}) otb_module_target(${otb-module}) OTB-release-5.8/Modules/MPI/MPIConfig/src/otbMPIConfig.cxx000066400000000000000000000101361301006202600230220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMPIConfig.h" #include #include #include #include #include #include #if defined(__GNUC__) || defined(__clang__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wunused-parameter" #include # pragma GCC diagnostic pop #else #include #endif /** * Call the MPI routine MPIFunc with arguments Args (surrounded by * parentheses). If the result is not MPI_SUCCESS, throw an exception. */ #define OTB_MPI_CHECK_RESULT( MPIFunc, Args ) \ { \ int _result = MPIFunc Args; \ if (_result != MPI_SUCCESS) \ { \ std::stringstream message; \ message << "otb::ERROR: " << #MPIFunc << " (Code = " << _result; \ ::itk::ExceptionObject _e(__FILE__, __LINE__, message.str().c_str()); \ throw _e; \ } \ } namespace otb { /** Initialize the singleton */ MPIConfig::Pointer MPIConfig::m_Singleton = NULL; MPIConfig::Pointer MPIConfig::Instance() { if(m_Singleton.GetPointer() == NULL) { m_Singleton = itk::ObjectFactory::Create(); if(m_Singleton.GetPointer() == NULL) { m_Singleton = new MPIConfig; } m_Singleton->UnRegister(); } return m_Singleton; } /** CreateInitialize MPI environment */ MPIConfig::MPIConfig() : m_MyRank(-1), m_NbProcs(0), m_abortOnException(true), m_initialized(false) { } /** Shuts down the MPI environment. */ MPIConfig::~MPIConfig() { if (m_initialized) { if (std::uncaught_exception() && m_abortOnException) { abort(EXIT_FAILURE); } else { int finalized; OTB_MPI_CHECK_RESULT(MPI_Finalized,(&finalized)); if (!finalized) { OTB_MPI_CHECK_RESULT(MPI_Finalize,()); } } } } /** Initialize MPI environment */ void MPIConfig::Init(int& argc, char** &argv, bool abortOnException) { // Abort on exception m_abortOnException = abortOnException; // Initialize int initialized; OTB_MPI_CHECK_RESULT(MPI_Initialized,(&initialized)); m_initialized = (initialized == 1); if (!m_initialized) { OTB_MPI_CHECK_RESULT(MPI_Init, (&argc, &argv)); m_initialized = true; } // Get MPI rank int irank = 0; OTB_MPI_CHECK_RESULT(MPI_Comm_rank, (MPI_COMM_WORLD , &irank)); if(irank<0) { logError("Negative MPI rank"); abort(EXIT_FAILURE); } m_MyRank = static_cast(irank); // Get MPI NbProocs int inbprocs=0; OTB_MPI_CHECK_RESULT(MPI_Comm_size, (MPI_COMM_WORLD , &inbprocs)); if(inbprocs<1) { logError("Negative or null number of processes"); abort(EXIT_FAILURE); } m_NbProcs = static_cast(inbprocs); } void MPIConfig::abort(int errCode) { OTB_MPI_CHECK_RESULT(MPI_Abort, (MPI_COMM_WORLD, errCode)); } void MPIConfig::barrier() { OTB_MPI_CHECK_RESULT(MPI_Barrier, (MPI_COMM_WORLD)); } void MPIConfig::logError(const std::string message) { if (m_MyRank == 0) { std::cerr << message << std::endl; } } void MPIConfig::logInfo(const std::string message) { if (m_MyRank == 0) { std::cout << message << std::endl; } } } // End namespace otb OTB-release-5.8/Modules/MPI/MPIConfig/test/000077500000000000000000000000001301006202600202055ustar00rootroot00000000000000OTB-release-5.8/Modules/MPI/MPIConfig/test/CMakeLists.txt000066400000000000000000000010711301006202600227440ustar00rootroot00000000000000otb_module_test() #${otb-module} will be the name of this module and will not need to be #changed when this module is renamed. set(${otb-module}Tests otbMPIConfigTestDriver.cxx otbMPIConfigTest.cxx ) add_executable(otbMPIConfigTestDriver ${${otb-module}Tests}) target_link_libraries(otbMPIConfigTestDriver ${${otb-module}-Test_LIBRARIES} ${Boost_SYSTEM_LIBRARY} ${Boost_CHRONO_LIBRARY}) otb_module_target_label(otbMPIConfigTestDriver) # MPI Hello test otb_add_test_mpi(NAME otbMPIConfigTest NBPROCS 2 COMMAND otbMPIConfigTestDriver otbMPIConfigTest ) OTB-release-5.8/Modules/MPI/MPIConfig/test/otbMPIConfigTest.cxx000066400000000000000000000017731301006202600240610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMPIConfig.h" #include #include "itkMultiThreader.h" int otbMPIConfigTest(int argc, char* argv[]) { // MPI Configuration typedef otb::MPIConfig MPIConfigType; MPIConfigType::Pointer config = MPIConfigType::Instance(); config->Init(argc,argv,true); // Test std::cout<<"OTB MPI config test. I am process "<GetMyRank()<<" among "<GetNbProcs()<<"."< #include #include // SPTW #include #include #if defined(__GNUC__) || defined(__clang__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wunused-parameter" #include "sptw.h" # pragma GCC diagnostic pop #else #include "sptw.h" #endif // GDAL-OTB datatype brigde #include "otbGdalDataTypeBridge.h" namespace otb { /** \class SimpleParallelTiffWriter * \brief Writes a GeoTiff image using parallel non collective operations. * * SimpleParallelTiffWriter writes its input data to a single output file. * SimpleParallelTiffWriter interfaces with an MPI-IO based class to write out the * data with streaming process and multiple processing nodes. * * SimpleParallelTiffWriter will divide the output into several pieces * (controlled by SetNumberOfDivisionsStrippedStreaming, SetNumberOfLinesStrippedStreaming, * SetAutomaticStrippedStreaming, SetTileDimensionTiledStreaming or SetAutomaticTiledStreaming), * and call the upstream pipeline for each piece, tiling the individual outputs into one large * output. This reduces the memory footprint for the application since * each filter does not have to process the entire dataset at once. * * SimpleParallelTiffWriter will write directly the streaming buffer in the image file, so * that the output image never needs to be completely allocated * * SimpleParallelTiffWriter implements a version of Simple Parallel Tiff Writer (SPTW, * D.M. Mattli, USGS) * * Splitting strategies are close to those implemented in ImageFileWriter, except * layout is optimized for the number of MPI processes for stripped regions. * TODO: optimize the splitting layout for tiled regions * * * \sa ImageFileWriter * \ingroup OTBMPITiffWriter */ template class ITK_EXPORT SimpleParallelTiffWriter : public itk::ProcessObject { public: /** Standard class typedefs. */ typedef SimpleParallelTiffWriter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SimpleParallelTiffWriter, itk::ProcessObject); /** Some typedefs for the input and output. */ typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::IndexType InputIndexType; typedef TInputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename Superclass::DataObjectPointer DataObjectPointer; /** The Filename Helper. */ typedef otb::ExtendedFilenameToWriterOptions FNameHelperType; /** Dimension of input image. */ itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension); /** Streaming manager base class pointer */ typedef otb::StreamingManager StreamingManagerType; typedef typename StreamingManagerType::Pointer StreamingManagerPointerType; /** Return the StreamingManager object responsible for dividing * the region to write */ StreamingManagerType* GetStreamingManager(void) { return m_StreamingManager; } /** Set a user-specified implementation of StreamingManager * used to divide the largest possible region in several divisions */ void SetStreamingManager(StreamingManagerType* streamingManager) { m_StreamingManager = streamingManager; } /** Set the streaming mode to 'stripped' and configure the number of strips * which will be used to stream the image */ void SetNumberOfDivisionsStrippedStreaming(unsigned int nbDivisions); /** Set the streaming mode to 'tiled' and configure the number of tiles * which will be used to stream the image */ void SetNumberOfDivisionsTiledStreaming(unsigned int nbDivisions); /** Set the streaming mode to 'stripped' and configure the number of strips * which will be used to stream the image with respect to a number of line * per strip */ void SetNumberOfLinesStrippedStreaming(unsigned int nbLinesPerStrip); /** Set the streaming mode to 'stripped' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option. * The bias parameter is a multiplier applied on the estimated memory size * of the pipeline and can be used to fine tune the potential gap between * estimated memory and actual memory used, which can happen because of * composite filters for example */ void SetAutomaticStrippedStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the streaming mode to 'tiled' and configure the dimension of the tiles * in pixels for each dimension (square tiles will be generated) */ void SetTileDimensionTiledStreaming(unsigned int tileDimension); /** Set the streaming mode to 'tiled' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Tiles will be square. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option * The bias parameter is a multiplier applied on the estimated memory size * of the pipeline and can be used to fine tune the potential gap between * estimated memory and actual memory used, which can happen because of * composite filters for example */ void SetAutomaticTiledStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the streaming mode to 'adaptative' and configure the number of MB * available. The actual number of divisions is computed automatically * by estimating the memory consumption of the pipeline. * Tiles will try to match the input file tile scheme. * Setting the availableRAM parameter to 0 means that the available RAM * is set from the CMake configuration option */ void SetAutomaticAdaptativeStreaming(unsigned int availableRAM = 0, double bias = 1.0); /** Set the only input of the writer */ using Superclass::SetInput; virtual void SetInput(const InputImageType *input); /** Get writer only input */ const InputImageType* GetInput(); /** Does the real work. */ virtual void Update(); /** SimpleParallelTiffWriter Methods */ virtual void SetFileName(const char* extendedFileName); virtual void SetFileName(std::string extendedFileName); virtual const char* GetFileName () const; /** Specify the region to write. If left NULL, then the whole image * is written. */ void SetIORegion(const itk::ImageIORegion& region); itkGetConstReferenceMacro(IORegion, itk::ImageIORegion); /** By default the MetaDataDictionary is taken from the input image and * passed to the ImageIO. In some cases, however, a user may prefer to * introduce her/his own MetaDataDictionary. This is often the case of * the ImageSeriesWriter. This flag defined whether the MetaDataDictionary * to use will be the one from the input image or the one already set in * the ImageIO object. */ itkSetMacro(UseInputMetaDataDictionary, bool); itkGetConstReferenceMacro(UseInputMetaDataDictionary, bool); itkBooleanMacro(UseInputMetaDataDictionary); itkSetObjectMacro(ImageIO, otb::ImageIOBase); itkGetObjectMacro(ImageIO, otb::ImageIOBase); itkGetConstObjectMacro(ImageIO, otb::ImageIOBase); /* Writer modes */ itkSetMacro(Verbose, bool); itkGetMacro(Verbose, bool); itkSetMacro(VirtualMode, bool); itkGetMacro(VirtualMode, bool); /* GeoTiff options */ itkSetMacro(TiffTileSize, int); itkGetMacro(TiffTileSize, int); itkSetMacro(TiffTiledMode, bool); itkGetMacro(TiffTiledMode, bool); protected: SimpleParallelTiffWriter(); virtual ~SimpleParallelTiffWriter(); void PrintSelf(std::ostream& os, itk::Indent indent) const; private: SimpleParallelTiffWriter(const SimpleParallelTiffWriter &); //purposely not implemented void operator =(const SimpleParallelTiffWriter&); //purposely not implemented void ObserveSourceFilterProgress(itk::Object* object, const itk::EventObject & event ) { if (typeid(event) != typeid(itk::ProgressEvent)) { return; } itk::ProcessObject* processObject = dynamic_cast(object); if (processObject) { m_DivisionProgress = processObject->GetProgress(); } this->UpdateFilterProgress(); } void UpdateFilterProgress() { this->UpdateProgress( (m_DivisionProgress + m_CurrentDivision) / m_NumberOfDivisions ); } /* * Returns the process id which process a given region */ unsigned int GetProcFromDivision(unsigned int regionIndex); /* * Arranges the splitting layout to match the number of MPI processes */ unsigned int OptimizeStrippedSplittingLayout(unsigned int n); unsigned int m_NumberOfDivisions; unsigned int m_CurrentDivision; float m_DivisionProgress; /** SimpleParallelTiffWriter Parameters */ std::string m_FileName; otb::ImageIOBase::Pointer m_ImageIO; bool m_UserSpecifiedImageIO; //track whether the ImageIO is user specified itk::ImageIORegion m_IORegion; bool m_UserSpecifiedIORegion; // track whether the region is user specified bool m_FactorySpecifiedImageIO; //track whether the factory mechanism set the ImageIO bool m_UseInputMetaDataDictionary; // whether to use the // MetaDataDictionary from the // input or not. bool m_WriteGeomFile; // Write a geom file to store the // kwl FNameHelperType::Pointer m_FilenameHelper; StreamingManagerPointerType m_StreamingManager; bool m_IsObserving; unsigned long m_ObserverID; InputIndexType m_ShiftOutputIndex; int m_TiffTileSize; bool m_Verbose; bool m_VirtualMode; bool m_TiffTiledMode; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbSimpleParallelTiffWriter.txx" #endif #endif OTB-release-5.8/Modules/MPI/MPITiffWriter/include/otbSimpleParallelTiffWriter.txx000066400000000000000000000577421301006202600277360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ TODO: Add copyright notice for Remi Cresson (IRSTEA) This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimpleParallelTiffWriter_txx #define otbSimpleParallelTiffWriter_txx #include "otbSimpleParallelTiffWriter.h" #include "itkTimeProbe.h" using std::vector; using sptw::PTIFF; using sptw::open_raster; using sptw::create_generic_raster; using sptw::SPTW_ERROR; namespace otb { /** * */ template SimpleParallelTiffWriter ::SimpleParallelTiffWriter() : m_NumberOfDivisions(0), m_CurrentDivision(0), m_DivisionProgress(0.0), m_UserSpecifiedImageIO(true), m_UserSpecifiedIORegion(false), m_FactorySpecifiedImageIO(false), m_UseInputMetaDataDictionary(false), m_WriteGeomFile(false), m_FilenameHelper(), m_IsObserving(true), m_ObserverID(0) { //Init output index shift m_ShiftOutputIndex.Fill(0); // Default TIFF tile size, can be modified later m_TiffTileSize = 1024; // Strip blocks m_TiffTiledMode = false; // Verbose m_Verbose = false; // Virtual mode m_VirtualMode = false; // By default, we use striped streaming, with automatic region size // We don't set any parameter, so the memory size is retrieved from the OTB configuration options //this->SetAutomaticAdaptativeStreaming(); this->SetAutomaticStrippedStreaming(); m_FilenameHelper = FNameHelperType::New(); } /** * */ template SimpleParallelTiffWriter ::~SimpleParallelTiffWriter() { } template unsigned int SimpleParallelTiffWriter ::GetProcFromDivision(unsigned int regionIndex) { if (otb::MPIConfig::Instance()->GetNbProcs()==0) return 0; return ( regionIndex % otb::MPIConfig::Instance()->GetNbProcs()); } /* * Arranges the splitting layout to match the number of MPI processes */ template unsigned int SimpleParallelTiffWriter ::OptimizeStrippedSplittingLayout(unsigned int n) { unsigned int m = static_cast(otb::MPIConfig::Instance()->GetNbProcs()); if (n > m) { float div = static_cast(n) / static_cast(otb::MPIConfig::Instance()->GetNbProcs()); m *= static_cast(div); } itkDebugMacro( "Changing number of split from " << n << " to " << m ); return m; } template void SimpleParallelTiffWriter ::SetNumberOfDivisionsStrippedStreaming(unsigned int nbDivisions) { typedef otb::NumberOfDivisionsStrippedStreamingManager NumberOfDivisionsStrippedStreamingManagerType; typename NumberOfDivisionsStrippedStreamingManagerType::Pointer streamingManager = NumberOfDivisionsStrippedStreamingManagerType::New(); streamingManager->SetNumberOfDivisions(nbDivisions); m_StreamingManager = streamingManager; } template void SimpleParallelTiffWriter ::SetNumberOfDivisionsTiledStreaming(unsigned int nbDivisions) { typedef otb::NumberOfDivisionsTiledStreamingManager NumberOfDivisionsTiledStreamingManagerType; typename NumberOfDivisionsTiledStreamingManagerType::Pointer streamingManager = NumberOfDivisionsTiledStreamingManagerType::New(); streamingManager->SetNumberOfDivisions(nbDivisions); m_StreamingManager = streamingManager; } template void SimpleParallelTiffWriter ::SetNumberOfLinesStrippedStreaming(unsigned int nbLinesPerStrip) { typedef otb::NumberOfLinesStrippedStreamingManager NumberOfLinesStrippedStreamingManagerType; typename NumberOfLinesStrippedStreamingManagerType::Pointer streamingManager = NumberOfLinesStrippedStreamingManagerType::New(); streamingManager->SetNumberOfLinesPerStrip(nbLinesPerStrip); m_StreamingManager = streamingManager; } template void SimpleParallelTiffWriter ::SetAutomaticStrippedStreaming(unsigned int availableRAM, double bias) { typedef otb::RAMDrivenStrippedStreamingManager RAMDrivenStrippedStreamingManagerType; typename RAMDrivenStrippedStreamingManagerType::Pointer streamingManager = RAMDrivenStrippedStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } template void SimpleParallelTiffWriter ::SetTileDimensionTiledStreaming(unsigned int tileDimension) { typedef otb::TileDimensionTiledStreamingManager TileDimensionTiledStreamingManagerType; typename TileDimensionTiledStreamingManagerType::Pointer streamingManager = TileDimensionTiledStreamingManagerType::New(); streamingManager->SetTileDimension(tileDimension); m_StreamingManager = streamingManager; } template void SimpleParallelTiffWriter ::SetAutomaticTiledStreaming(unsigned int availableRAM, double bias) { typedef otb::RAMDrivenTiledStreamingManager RAMDrivenTiledStreamingManagerType; typename RAMDrivenTiledStreamingManagerType::Pointer streamingManager = RAMDrivenTiledStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } template void SimpleParallelTiffWriter ::SetAutomaticAdaptativeStreaming(unsigned int availableRAM, double bias) { typedef otb::RAMDrivenAdaptativeStreamingManager RAMDrivenAdaptativeStreamingManagerType; typename RAMDrivenAdaptativeStreamingManagerType::Pointer streamingManager = RAMDrivenAdaptativeStreamingManagerType::New(); streamingManager->SetAvailableRAMInMB(availableRAM); streamingManager->SetBias(bias); m_StreamingManager = streamingManager; } #ifndef ITK_LEGACY_REMOVE #endif // ITK_LEGACY_REMOVE /** * */ template void SimpleParallelTiffWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "File Name: " << (m_FileName.data() ? m_FileName.data() : "(none)") << std::endl; os << indent << "Image IO: "; if (m_ImageIO.IsNull()) { os << "(none)\n"; } else { os << m_ImageIO << "\n"; } os << indent << "IO Region: " << m_IORegion << "\n"; if (m_UseInputMetaDataDictionary) { os << indent << "UseInputMetaDataDictionary: On\n"; } else { os << indent << "UseInputMetaDataDictionary: Off\n"; } if (m_FactorySpecifiedImageIO) { os << indent << "FactorySpecifiedmageIO: On\n"; } else { os << indent << "FactorySpecifiedmageIO: Off\n"; } } //--------------------------------------------------------- template void SimpleParallelTiffWriter ::SetIORegion(const itk::ImageIORegion& region) { itkDebugMacro("setting IORegion to " << region); if (m_IORegion != region) { m_IORegion = region; this->Modified(); m_UserSpecifiedIORegion = true; } } template void SimpleParallelTiffWriter ::SetInput(const InputImageType* input) { this->ProcessObject::SetNthInput(0,const_cast(input)); } template const TInputImage* SimpleParallelTiffWriter ::GetInput() { if (this->GetNumberOfInputs() < 1) { return 0; } return static_cast(this->ProcessObject::GetInput(0)); } /** * Update method : update output information of input and write to file */ template void SimpleParallelTiffWriter ::Update() { // Update output information on input image InputImagePointer inputPtr = const_cast(this->GetInput()); // Make sure input is available if ( inputPtr.IsNull() ) { itkExceptionMacro(<< "No input to writer"); } /** Parse streaming modes */ if(m_FilenameHelper->StreamingTypeIsSet()) { itkWarningMacro(<<"Streaming configuration through extended filename is used. Any previous streaming configuration (ram value, streaming mode ...) will be ignored."); std::string type = m_FilenameHelper->GetStreamingType(); std::string sizemode = "auto"; if(m_FilenameHelper->StreamingSizeModeIsSet()) { sizemode = m_FilenameHelper->GetStreamingSizeMode(); } double sizevalue = 0.; if(m_FilenameHelper->StreamingSizeValueIsSet()) { sizevalue = m_FilenameHelper->GetStreamingSizeValue(); } if(type == "auto") { if(sizemode != "auto") { itkWarningMacro(<<"In auto streaming type, the sizemode option will be ignored."); } if(sizevalue == 0.) { itkWarningMacro("sizemode is auto but sizevalue is 0. Value will be fetched from configuration file if any, or from cmake configuration otherwise."); } this->SetAutomaticAdaptativeStreaming(sizevalue); } else if(type == "tiled") { if(sizemode == "auto") { if(sizevalue == 0.) { itkWarningMacro("sizemode is auto but sizevalue is 0. Value will be fetched from configuration file if any, or from cmake configuration otherwise."); } this->SetAutomaticTiledStreaming(sizevalue); } else if(sizemode == "nbsplits") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to nbsplits but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetNumberOfDivisionsTiledStreaming(static_cast(sizevalue)); } else if(sizemode == "height") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to height but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetTileDimensionTiledStreaming(static_cast(sizevalue)); } } else if(type == "stripped") { if(sizemode == "auto") { if(sizevalue == 0.) { itkWarningMacro("sizemode is auto but sizevalue is 0. Value will be fetched from configuration file if any, or from cmake configuration otherwise."); } this->SetAutomaticStrippedStreaming(sizevalue); } else if(sizemode == "nbsplits") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to nbsplits but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetNumberOfDivisionsStrippedStreaming(static_cast(sizevalue)); } else if(sizemode == "height") { if(sizevalue == 0.) { itkWarningMacro("Streaming sizemode is set to height but sizevalue is 0. This will result in upredicted behaviour. Please consider setting the sizevalue by using &streaming:sizevalue=x."); } this->SetNumberOfLinesStrippedStreaming(static_cast(sizevalue)); } } else if (type == "none") { if(sizemode!="" || sizevalue!=0.) { itkWarningMacro("Streaming is explicitly disabled, sizemode and sizevalue will be ignored."); } this->SetNumberOfDivisionsTiledStreaming(0); } } else { if(m_FilenameHelper->StreamingSizeValueIsSet() || m_FilenameHelper->StreamingSizeModeIsSet()) { itkWarningMacro(<<"No streaming type is set, streaming sizemode and sizevalue will be ignored."); } } this->SetAbortGenerateData(0); this->SetProgress(0.0); /** * Tell all Observers that the filter is starting */ this->InvokeEvent(itk::StartEvent()); /* * Check filename */ if (m_VirtualMode) { m_FileName = "virtualFile.tif"; } if (m_FileName == "") { // Make sure that filename is not empty itkExceptionMacro(<< "No filename was specified"); otb::MPIConfig::Instance()->abort(EXIT_FAILURE); } std::string::size_type idx; idx = m_FileName.rfind('.'); if(idx != std::string::npos) { std::string extension = m_FileName.substr(idx+1); boost::algorithm::to_lower(extension); if (boost::iequals(extension, "tif")) { // Extension is TIF } else { // Other extension itkExceptionMacro(<<"Filename must have .tif extension !"); otb::MPIConfig::Instance()->abort(EXIT_FAILURE); } } else { // Missing extension itkWarningMacro(<<"Filename has no extension. Adding <.tif> extension."); m_FileName += ".tif"; } /** * Grab the input */ inputPtr->UpdateOutputInformation(); InputImageRegionType inputRegion = inputPtr->GetLargestPossibleRegion(); /** Parse region size modes */ if(m_FilenameHelper->BoxIsSet()) { typedef boost::tokenizer > Tokenizer; boost::char_separator sep(":"); Tokenizer tokens(m_FilenameHelper->GetBox(), sep); Tokenizer::iterator it = tokens.begin(); typename InputImageRegionType::IndexType start; typename InputImageRegionType::SizeType size; start[0] = atoi(it->c_str()); // first index on X ++it; start[1] = atoi(it->c_str()); // first index on Y ++it; size[0] = atoi(it->c_str()); // size along X ++it; size[1] = atoi(it->c_str()); // size along Y inputRegion.SetSize(size); m_ShiftOutputIndex = start; inputRegion.SetIndex(m_ShiftOutputIndex); if (!inputRegion.Crop(inputPtr->GetLargestPossibleRegion())) { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested box region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } otbMsgDevMacro(<< "inputRegion " << inputRegion); } // Get number of bands & pixel data type GDALDataType dataType; int nBands = 1; typedef typename InputImageType::PixelType ImagePixelType; if (strcmp(this->GetInput()->GetNameOfClass(), "VectorImage") == 0) { // Input is a vector image typedef typename InputImageType::InternalPixelType VectorImagePixelType; typedef typename InputImageType::AccessorFunctorType AccessorFunctorType; dataType = otb::GdalDataTypeBridge::GetGDALDataType(); nBands *= AccessorFunctorType::GetVectorLength(this->GetInput()); } else { // Input is an image dataType = otb::GdalDataTypeBridge::GetGDALDataType(); } /************************************************************************ * Raster creation ************************************************************************/ // First, compute the block size int block_size_x = m_TiffTiledMode; if (m_TiffTiledMode) { // When mode is tiled, check the GeoTiff tile size int inputRegionMinSize = std::min(inputRegion.GetSize()[0], inputRegion.GetSize()[1]); if (m_TiffTileSize > inputRegionMinSize) { // Find the nearest (floor) power of 2 block_size_x = (int) std::pow(2, std::floor(std::log((double) inputRegionMinSize)/std::log(2.0))); itkWarningMacro(<<"GeoTiff tile size is bigger than image. Setting to " << block_size_x); } } else { // When mode is not tiled (i.e. striped) block_size_x = inputPtr->GetLargestPossibleRegion().GetSize()[0]; } // Master process (Rank 0) is responsible for the creation of the output raster. if (otb::MPIConfig::Instance()->GetMyRank() == 0 && !m_VirtualMode) { // Set geotransform double geotransform[6]; geotransform[0] = inputPtr->GetOrigin()[0] - 0.5*inputPtr->GetSpacing()[0]; geotransform[1] = inputPtr->GetSpacing()[0]; geotransform[2] = 0.0; geotransform[3] = inputPtr->GetOrigin()[1] - 0.5*inputPtr->GetSpacing()[1]; geotransform[4] = 0.0; geotransform[5] = inputPtr->GetSpacing()[1]; // Call SPTW routine that creates the output raster SPTW_ERROR sperr = create_generic_raster(m_FileName, inputPtr->GetLargestPossibleRegion().GetSize()[0], inputPtr->GetLargestPossibleRegion().GetSize()[1], nBands, dataType, geotransform, inputPtr->GetProjectionRef(), block_size_x, m_TiffTiledMode); if (sperr != sptw::SP_None) { itkExceptionMacro(<<"Error creating raster"); otb::MPIConfig::Instance()->abort(EXIT_FAILURE); } } // Wait for rank 0 to finish creating the output raster otb::MPIConfig::Instance()->barrier(); /************************************************************************ * Raster update: open raster ************************************************************************/ // Open raster (if not in virtual mode) PTIFF* output_raster = NULL; if (!m_VirtualMode) { output_raster = open_raster(m_FileName); // First, populate blocks offsets if (otb::MPIConfig::Instance()->GetMyRank() == 0) { SPTW_ERROR sperr = populate_tile_offsets(output_raster, block_size_x, m_TiffTiledMode); if (sperr != sptw::SP_None) { itkExceptionMacro(<<"Error populating tile offsets\n"); otb::MPIConfig::Instance()->abort(EXIT_FAILURE); } } // Wait for tile offsets to be populated otb::MPIConfig::Instance()->barrier(); close_raster(output_raster); // Now open it output_raster = open_raster(m_FileName); otb::MPIConfig::Instance()->barrier(); if (output_raster == NULL) { itkExceptionMacro(<<"Could not open output raster"); otb::MPIConfig::Instance()->abort(EXIT_FAILURE); } } /************************************************************************ * Raster update: write regions ************************************************************************/ // Time probe for overall process time itk::TimeProbe overallTime; overallTime.Start(); // Check that streaming is relevant m_StreamingManager->PrepareStreaming(inputPtr, inputRegion); m_NumberOfDivisions = m_StreamingManager->GetNumberOfSplits(); // Recompute a new splitting layout which fits better the MPI number of processes // TODO make it work on tiled splits ! // [dirtycode] unsigned int newNumberOfStrippedSplits = OptimizeStrippedSplittingLayout(m_NumberOfDivisions); this->SetNumberOfDivisionsStrippedStreaming(newNumberOfStrippedSplits); m_StreamingManager->PrepareStreaming(inputPtr, inputRegion); m_NumberOfDivisions = m_StreamingManager->GetNumberOfSplits(); // [/dirtycode] // Configure process objects this->UpdateProgress(0); m_CurrentDivision = 0; m_DivisionProgress = 0; // Get the source process object itk::ProcessObject* source = inputPtr->GetSource(); m_IsObserving = false; m_ObserverID = 0; // Check if source exists if(source) { typedef itk::MemberCommand CommandType; typedef typename CommandType::Pointer CommandPointerType; CommandPointerType command = CommandType::New(); command->SetCallbackFunction(this, &Self::ObserveSourceFilterProgress); m_ObserverID = source->AddObserver(itk::ProgressEvent(), command); m_IsObserving = true; } else { itkWarningMacro(<< "Could not get the source process object. Progress report might be buggy"); } // Loop on streaming tiles double processDuration(0), writeDuration(0), numberOfProcessedRegions(0); InputImageRegionType streamRegion; for (m_CurrentDivision = 0; m_CurrentDivision < m_NumberOfDivisions && !this->GetAbortGenerateData(); m_CurrentDivision++, m_DivisionProgress = 0, this->UpdateFilterProgress()) { streamRegion = m_StreamingManager->GetSplit(m_CurrentDivision); if (GetProcFromDivision(m_CurrentDivision) == otb::MPIConfig::Instance()->GetMyRank()) { /* * Processing */ itk::TimeProbe processingTime; processingTime.Start(); inputPtr->SetRequestedRegion(streamRegion); inputPtr->PropagateRequestedRegion(); inputPtr->UpdateOutputData(); processingTime.Stop(); processDuration += processingTime.GetTotal(); /* * Writing using SPTW */ itk::TimeProbe writingTime; writingTime.Start(); if (!m_VirtualMode) { sptw::write_area(output_raster, inputPtr->GetBufferPointer(), streamRegion.GetIndex()[0], streamRegion.GetIndex()[1], streamRegion.GetIndex()[0] + streamRegion.GetSize()[0] -1, streamRegion.GetIndex()[1] + streamRegion.GetSize()[1] -1); } writingTime.Stop(); writeDuration += writingTime.GetTotal(); numberOfProcessedRegions += 1; } } // Clean up close_raster(output_raster); output_raster = NULL; // We wait for other process otb::MPIConfig::Instance()->barrier(); overallTime.Stop(); /* TODO: Use MPIConfig helper instead of MPI methods // Get timings const int nValues = 3; double runtimes[nValues] = {processDuration, writeDuration, numberOfProcessedRegions}; std::vector process_runtimes(otb::MPIConfig::Instance()->GetNbProcs()*nValues); MPI_Gather(runtimes, nValues, MPI_DOUBLE, &(process_runtimes[0]), nValues, MPI_DOUBLE, 0, MPI_COMM_WORLD); // Display timings if (otb::MPIConfig::Instance()->GetMyRank() == 0 && m_Verbose) { itkDebugMacro( "Runtime, in seconds" ); itkDebugMacro( "Process Id\tProcessing\tWriting" ); for (unsigned int i = 0; i < process_runtimes.size(); i+=nValues) { itkDebugMacro( <<(int (i/nValues)) << "\t" << process_runtimes[i] << "\t" << process_runtimes[i+1] << "\t("<< process_runtimes[i+2] << " regions)" ); } itkDebugMacro( "Overall time:" << overallTime.GetTotal() ); } */ /** * If we ended due to aborting, push the progress up to 1.0 (since * it probably didn't end there) */ if (!this->GetAbortGenerateData()) { this->UpdateProgress(1.0); } // Notify end event observers this->InvokeEvent(itk::EndEvent()); if (m_IsObserving) { m_IsObserving = false; source->RemoveObserver(m_ObserverID); } /* * Writing the geom (only master process) */ if ( otb::MPIConfig::Instance()->GetMyRank() == 0 && (m_WriteGeomFile || m_FilenameHelper->GetWriteGEOMFile()) ) { otb::ImageKeywordlist otb_kwl; itk::MetaDataDictionary dict = this->GetInput()->GetMetaDataDictionary(); itk::ExposeMetaData(dict, otb::MetaDataKey::OSSIMKeywordlistKey, otb_kwl); WriteGeometry(otb_kwl, this->GetFileName()); } /** * Release any inputs if marked for release */ this->ReleaseInputs(); //Reset global shift on input region (box parameter) //It allows calling multiple updates over the writer m_ShiftOutputIndex.Fill(0); // Wait for other processes otb::MPIConfig::Instance()->barrier(); } template void SimpleParallelTiffWriter ::SetFileName(std::string extendedFileName) { this->SetFileName(extendedFileName.c_str()); } template void SimpleParallelTiffWriter ::SetFileName(const char* extendedFileName) { this->m_FilenameHelper->SetExtendedFileName(extendedFileName); m_FileName = this->m_FilenameHelper->GetSimpleFileName(); m_ImageIO = NULL; this->Modified(); } template const char* SimpleParallelTiffWriter ::GetFileName () const { return this->m_FilenameHelper->GetSimpleFileName(); } } #endif OTB-release-5.8/Modules/MPI/MPITiffWriter/otb-module.cmake000066400000000000000000000005661301006202600231660ustar00rootroot00000000000000set(DOCUMENTATION "This module contains MPI tiff writer") otb_module(OTBMPITiffWriter DEPENDS OTBBoost OTBCommon OTBExtendedFilename OTBGDAL OTBGdalAdapters OTBITK OTBImageBase OTBImageIO OTBOSSIMAdapters OTBSPTW OTBStreaming OTBMPI OTBMPIConfig TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/MPI/MPITiffWriter/test/000077500000000000000000000000001301006202600210655ustar00rootroot00000000000000OTB-release-5.8/Modules/MPI/MPITiffWriter/test/CMakeLists.txt000066400000000000000000000013021301006202600236210ustar00rootroot00000000000000otb_module_test() set(OTBMPITiffWriterTests otbMPITiffWriterTestDriver.cxx otbMPISPTWReadWriteTest.cxx ) add_executable(otbMPITiffWriterTestDriver ${OTBMPITiffWriterTests}) # target link libraries target_link_libraries(otbMPITiffWriterTestDriver ${OTBMPITiffWriter-Test_LIBRARIES}) otb_module_target_label(otbMPITiffWriterTestDriver) # Tests Declaration otb_add_test_mpi(NAME otbMPISPTWReadWriteTest NBPROCS 2 COMMAND otbMPITiffWriterTestDriver --compare-image ${NOTOL} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/otbMPITiffWriterTestOutput.tif otbMPISPTWReadWriteTest ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/otbMPITiffWriterTestOutput.tif ) OTB-release-5.8/Modules/MPI/MPITiffWriter/test/otbMPISPTWReadWriteTest.cxx000066400000000000000000000037361301006202600261410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Includes #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbMPIConfig.h" #include "otbSimpleParallelTiffWriter.h" #include #include int otbMPISPTWReadWriteTest(int argc, char* argv[]) { // Initialize MPI environment otb::MPIConfig::Pointer config = otb::MPIConfig::Instance(); config->Init(argc,argv); // Get command line arguments if (argc != 3) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << " inputImageFile outputImageFile " << std::endl; return EXIT_SUCCESS; } // Image typedefs typedef float PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::SimpleParallelTiffWriter WriterType; // Reader configuration ReaderType::Pointer reader = ReaderType::New(); std::string inputFilename = std::string(argv[1]); reader->SetFileName(inputFilename); reader->GenerateOutputInformation(); // Writer configuration WriterType::Pointer writer = WriterType::New(); std::string outputFilename = std::string(argv[2]); writer->SetFileName(outputFilename); writer->SetInput(reader->GetOutput()); // Execute the MPI pipeline try{ writer->Update(); } catch (std::exception & err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err.what() << std::endl; config->abort(EXIT_FAILURE); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/MPI/MPITiffWriter/test/otbMPITiffWriterTestDriver.cxx000066400000000000000000000001341301006202600267630ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMPISPTWReadWriteTest); } OTB-release-5.8/Modules/MPI/MPIVrtWriter/000077500000000000000000000000001301006202600177715ustar00rootroot00000000000000OTB-release-5.8/Modules/MPI/MPIVrtWriter/CMakeLists.txt000066400000000000000000000000511301006202600225250ustar00rootroot00000000000000project(MPIVrtWriter) otb_module_impl() OTB-release-5.8/Modules/MPI/MPIVrtWriter/include/000077500000000000000000000000001301006202600214145ustar00rootroot00000000000000OTB-release-5.8/Modules/MPI/MPIVrtWriter/include/otbMPIVrtWriter.h000066400000000000000000000212531301006202600246130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMPIVrtWriter_h #define otbMPIVrtWriter_h #include "otbMPIConfig.h" #include "otbImageFileWriter.h" #include "itkRegionOfInterestImageFilter.h" #include "otbNumberOfDivisionsTiledStreamingManager.h" #include #include #include #include #include #include #if defined(__GNUC__) || defined(__clang__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wshadow" #include # pragma GCC diagnostic pop #else #include #endif #include namespace otb { /** *\brief Write image data to multiple files with MPI processus and add a VRT file. * * The image is divided into several pieces. * Each pieces is distributed to a MPI processus. * Each MPI processus write their pieces into a separate * file. * The master processus writes a VRT file (optional). * *\param img Image *\param output Output Filename *\param availableRAM Available memory for streaming *\param writeVRTFile Activate the VRT file writing */ template void WriteMPI(TImage *img, const std::string &output, unsigned int availableRAM = 0, bool writeVRTFile=true) { typename otb::MPIConfig::Pointer mpiConfig = otb::MPIConfig::Instance(); unsigned int myRank = mpiConfig->GetMyRank(); unsigned int nbProcs = mpiConfig->GetNbProcs(); typedef otb::ImageFileWriter WriterType; typedef otb::NumberOfDivisionsTiledStreamingManager StreamingManagerType; typedef itk::RegionOfInterestImageFilter ExtractFilterType; // First, update infomration from image to write img->UpdateOutputInformation(); // Configure streaming manager typename StreamingManagerType::Pointer streamingManager = StreamingManagerType::New(); streamingManager->SetNumberOfDivisions(nbProcs); streamingManager->PrepareStreaming(img,img->GetLargestPossibleRegion()); unsigned int numberOfSplits = streamingManager->GetNumberOfSplits(); // This vector will hold all regions to write for current rank std::vector regionsToWrite; // Handle both cases when there are much more (resp. less) region to // write than NbProcs if(myRank < numberOfSplits) { unsigned int splitIdx = myRank; while(splitIdx < numberOfSplits) { typename TImage::RegionType currentRegion = streamingManager->GetSplit(splitIdx); regionsToWrite.push_back(currentRegion); splitIdx+=nbProcs; } } // Output prefix std::string extension = itksys::SystemTools::GetFilenameExtension(output); if (extension != ".vrt") { // TODO: Maybe remove this if (extension == "") { // Missing extension mpiConfig->logInfo("Filename has no extension. Adding <.vrt> extension."); } else { // Bad extension mpiConfig->logError("Filename must have .vrt extension!"); mpiConfig->abort(EXIT_FAILURE); } } std::vector joins; joins.push_back(itksys::SystemTools::GetFilenamePath(output).append("/")); joins.push_back(itksys::SystemTools::GetFilenameWithoutExtension(output)); std::string prefix = itksys::SystemTools::JoinPath(joins); // Data type std::string dataTypeStr = "Float32"; GDALImageIO::Pointer gdalImageIO; // Now write all the regions for(typename std::vector::const_iterator it = regionsToWrite.begin(); it!=regionsToWrite.end();++it) { typename ExtractFilterType::Pointer extractFilter = ExtractFilterType::New(); extractFilter->SetInput(img); extractFilter->SetRegionOfInterest(*it); // Writer // Output Filename std::stringstream ss; ss<GetIndex()[0]<<"_"<GetIndex()[1]<<"_"<GetSize()[0]<<"_"<GetSize()[1]<<".tif"; typename WriterType::Pointer writer = WriterType::New(); writer->SetFileName(ss.str()); writer->SetInput(extractFilter->GetOutput()); // Datatype gdalImageIO = dynamic_cast(writer->GetImageIO()); if(gdalImageIO.IsNotNull()) { dataTypeStr = gdalImageIO->GetGdalPixelTypeAsString(); } if (!availableRAM) { writer->SetNumberOfDivisionsTiledStreaming(0); } else { writer->SetAutomaticAdaptativeStreaming(availableRAM); } // Pipeline execution try { writer->Update(); } catch (itk::ExceptionObject& err) { std::stringstream message; message << "ExceptionObject caught: " << err << std::endl; mpiConfig->logError(message.str()); mpiConfig->abort(EXIT_FAILURE); } } // MPI process synchronization mpiConfig->barrier(); // Write VRT file try { if (writeVRTFile && (myRank == 0)) { // VRT Filename std::stringstream vrtfOut; vrtfOut<< prefix << ".vrt"; // Data type GDALDataType dataType; dataType = GDALGetDataTypeByName(dataTypeStr.c_str()); int imageSizeY = img->GetLargestPossibleRegion().GetSize()[1]; int imageSizeX = img->GetLargestPossibleRegion().GetSize()[0]; const unsigned int nbBands = img->GetNumberOfComponentsPerPixel(); // Get VRT driver GDALAllRegister(); GDALDriver *driver = GetGDALDriverManager()->GetDriverByName("VRT"); if (driver == NULL) { mpiConfig->logError("Error opening VRT driver."); mpiConfig->abort(EXIT_FAILURE); } // Create output raster GDALDataset *VRTOutput = driver->Create(vrtfOut.str().c_str(), imageSizeX, imageSizeY, 0, dataType, NULL); // No options if (VRTOutput == NULL) { mpiConfig->logError("driver->Create call failed.\n"); mpiConfig->abort(EXIT_FAILURE); } // Set GeoTransform double gt[6]; gt[0] = img->GetOrigin()[0] - 0.5*img->GetSpacing()[0]; gt[1] = img->GetSpacing()[0]; gt[2] = 0.0; gt[3] = img->GetOrigin()[1] - 0.5*img->GetSpacing()[1]; gt[4] = 0.0; gt[5] = img->GetSpacing()[1]; VRTOutput->SetGeoTransform(gt); // Set projection OGRSpatialReference out_sr; char *wkt = NULL; out_sr.SetFromUserInput(img->GetProjectionRef().c_str()); out_sr.exportToWkt(&wkt); VRTOutput->SetProjection(wkt); for(unsigned int band = 1; band<=nbBands;++band) { VRTOutput->AddBand(dataType, NULL); typename TImage::RegionType currentRegion; for(unsigned int id=0; id < numberOfSplits; ++id) { currentRegion = streamingManager->GetSplit(id); int tileSizeX = currentRegion.GetSize()[0]; int tileSizeY = currentRegion.GetSize()[1]; int tileIndexX = currentRegion.GetIndex()[0]; int tileIndexY = currentRegion.GetIndex()[1]; std::stringstream tileFileName; tileFileName < (VRTOutput->GetRasterBand(band)); VRTBand->AddSimpleSource(dataset->GetRasterBand(band), 0, //xOffSrc 0, //yOffSrc tileSizeX, //xSizeSrc tileSizeY, //ySizeSrc tileIndexX, //xOffDest tileIndexY, //yOffDest tileSizeX, //xSizeDest tileSizeY, //ySizeDest "near", VRT_NODATA_UNSET); } } // Close OGRFree(wkt); GDALClose(VRTOutput); } } catch (itk::ExceptionObject& err) { std::stringstream message; message << "ExceptionObject caught: " << err << std::endl; mpiConfig->logError(message.str()); mpiConfig->abort(EXIT_FAILURE); } } } // End namespace otb #endif //__otbMPIVrtWriter_h OTB-release-5.8/Modules/MPI/MPIVrtWriter/otb-module.cmake000066400000000000000000000003771301006202600230510ustar00rootroot00000000000000set(DOCUMENTATION "Provides a template function for MPI writing to a VRT file") otb_module(OTBMPIVrtWriter DEPENDS OTBMPIConfig OTBPanSharpening OTBProjection OTBInterpolation OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/MPI/MPIVrtWriter/test/000077500000000000000000000000001301006202600207505ustar00rootroot00000000000000OTB-release-5.8/Modules/MPI/MPIVrtWriter/test/CMakeLists.txt000066400000000000000000000014041301006202600235070ustar00rootroot00000000000000otb_module_test() #${otb-module} will be the name of this module and will not need to be #changed when this module is renamed. set(${otb-module}Tests otbMPIVrtWriterTestDriver.cxx otbMPIReadWriteTest.cxx ) add_executable(otbMPIVrtWriterTestDriver ${${otb-module}Tests}) target_link_libraries(otbMPIVrtWriterTestDriver ${${otb-module}-Test_LIBRARIES}) otb_module_target_label(otbMPIVrtWriterTestDriver) # MPI Hello test otb_add_test_mpi(NAME otbMPIVrtWriterTest NBPROCS 2 COMMAND otbMPIVrtWriterTestDriver --compare-image ${NOTOL} ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/otbMPIVrtWriterTestOutput.vrt otbMPIReadWriteTest ${INPUTDATA}/ToulouseQuickBird_Extrait_1500_3750.tif ${TEMP}/otbMPIVrtWriterTestOutput.vrt ) OTB-release-5.8/Modules/MPI/MPIVrtWriter/test/otbMPIReadWriteTest.cxx000066400000000000000000000040101301006202600252700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // Includes #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbMPIConfig.h" #include "otbMPIVrtWriter.h" #include #include // Test int otbMPIReadWriteTest(int argc, char * argv[]) { // Mono-thread execution itk::MultiThreader::SetGlobalMaximumNumberOfThreads(1); itk::MultiThreader::SetGlobalDefaultNumberOfThreads(1); // MPI Initialization typedef otb::MPIConfig MPIConfigType; MPIConfigType::Pointer config = MPIConfigType::Instance(); config->Init(argc,argv,true); // Verify the number of parameters in the command line if (argc != 3) { std::stringstream message; message << "Usage: " << std::endl; message << argv[0] << " inputImageFile outputImageFile " << std::endl; config->logError(message.str()); config->abort(EXIT_FAILURE); } // Image types typedef float PixelType; const unsigned int Dimension = 2; typedef otb::VectorImage ImageType; // Reader typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); // Reader configuration std::string inputFilename = std::string(argv[1]); reader->SetFileName(inputFilename); // Update MPI Pipeline std::string outputFilename = std::string(argv[2]); otb::WriteMPI(reader->GetOutput(),outputFilename); config->barrier(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/MPI/MPIVrtWriter/test/otbMPIVrtWriterTestDriver.cxx000066400000000000000000000001331301006202600265300ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMPIReadWriteTest); } OTB-release-5.8/Modules/OBIA/000077500000000000000000000000001301006202600155405ustar00rootroot00000000000000OTB-release-5.8/Modules/OBIA/RCC8/000077500000000000000000000000001301006202600162375ustar00rootroot00000000000000OTB-release-5.8/Modules/OBIA/RCC8/CMakeLists.txt000066400000000000000000000001031301006202600207710ustar00rootroot00000000000000project(OTBRCC8) set(OTBRCC8_LIBRARIES OTBRCC8) otb_module_impl() OTB-release-5.8/Modules/OBIA/RCC8/include/000077500000000000000000000000001301006202600176625ustar00rootroot00000000000000OTB-release-5.8/Modules/OBIA/RCC8/include/otbImageListToRCC8GraphFilter.h000066400000000000000000000063521301006202600254770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToRCC8GraphFilter_h #define otbImageListToRCC8GraphFilter_h #include "otbRCC8GraphSource.h" #include "otbImageList.h" namespace otb { /** \class ImageListToRCC8GraphFilter * \brief Base class for filters taking an images list as input to * produce a RCC8 graph. * * \ingroup OTBRCC8 */ template class ITK_EXPORT ImageListToRCC8GraphFilter : public RCC8GraphSource { public: /** Standard typedefs */ typedef ImageListToRCC8GraphFilter Self; typedef RCC8GraphSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageListToRCC8GraphFilter, RCC8GraphSource); /** Template input parameters typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef ImageList InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::ConstPointer InputImageListConstPointer; /** Template output parameters typedefs */ typedef TOutputGraph OutputGraphType; typedef typename Superclass::OutputGraphPointerType OutputGraphPointerType; typedef typename OutputGraphType::VertexType VertexType; typedef typename VertexType::Pointer VertexPointerType; typedef typename OutputGraphType::RCC8ValueType RCC8ValueType; /** InputImage dimension constant */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** Overriding the SetInput() and GetInput() methods */ using Superclass::SetInput; virtual void SetInput(const InputImageListType * imageList); virtual InputImageListType * GetInput(void); protected: /** Constructor */ ImageListToRCC8GraphFilter(); /** Destructor */ ~ImageListToRCC8GraphFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageListToRCC8GraphFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageListToRCC8GraphFilter.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbImageListToRCC8GraphFilter.txx000066400000000000000000000037411301006202600260720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageListToRCC8GraphFilter_txx #define otbImageListToRCC8GraphFilter_txx #include "otbImageListToRCC8GraphFilter.h" namespace otb { /** * Constructor */ template ImageListToRCC8GraphFilter ::ImageListToRCC8GraphFilter() { this->SetNumberOfRequiredInputs(1); } /** * Input Connection * \param image The input image. */ template void ImageListToRCC8GraphFilter ::SetInput(const InputImageListType *imageList) { // A single input image this->itk::ProcessObject::SetNthInput(0, const_cast(imageList)); } /** * Input image retrieval * \return The input image. */ template typename ImageListToRCC8GraphFilter::InputImageListType * ImageListToRCC8GraphFilter ::GetInput(void) { // If there is no input if (this->GetNumberOfInputs() < 1) { // exit return ITK_NULLPTR; } // else return the first input return static_cast (this->itk::ProcessObject::GetInput(0)); } /** * PrintSelf Method */ template void ImageListToRCC8GraphFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbImageMultiSegmentationToRCC8GraphFilter.h000066400000000000000000000077521301006202600302410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageMultiSegmentationToRCC8GraphFilter_h #define otbImageMultiSegmentationToRCC8GraphFilter_h #include "otbImageListToRCC8GraphFilter.h" namespace otb { /** * \class ImageMultiSegmentationToRCC8GraphFilter * \brief This class takes a list of labelled segmentation images * and build the RCC8 graph of the set of regions it represents. * * \ingroup OTBRCC8 */ template class ITK_EXPORT ImageMultiSegmentationToRCC8GraphFilter : public ImageListToRCC8GraphFilter { public: /** Standard class typedefs. */ typedef ImageMultiSegmentationToRCC8GraphFilter Self; typedef ImageListToRCC8GraphFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageMultiSegmentationToRCC8GraphFilter, ImageListToRCC8GraphFilter); /** Input related typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename Superclass::InputImageListType InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename InputImageListType::ConstIterator ConstListIteratorType; /** Output related typedefs */ typedef TOutputGraph OutputGraphType; typedef typename OutputGraphType::Pointer OutputGraphPointerType; typedef typename OutputGraphType::VertexType VertexType; typedef typename VertexType::Pointer VertexPointerType; typedef typename VertexType::PathType PathType; typedef typename OutputGraphType::VertexDescriptorType VertexDescriptorType; /** Knowledge enum typedef */ typedef typename OutputGraphType::RCC8ValueType RCC8ValueType; typedef enum {NO_INFO, LEVEL_1, LEVEL_3, FULL} KnowledgeValueType; typedef std::pair KnowledgeStateType; /** Toogle optimisation flag */ itkBooleanMacro(Optimisation); itkSetMacro(Optimisation, bool); /** * Get the number of occurrences of the given value * \return The value. */ unsigned int GetRelationsCount(RCC8ValueType val); /** * Get number of relations * \return The number of relations. */ unsigned int GetNumberOfRelations(void); protected: /** Constructor */ ImageMultiSegmentationToRCC8GraphFilter(); /** Destructor */ ~ImageMultiSegmentationToRCC8GraphFilter() ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Get the composition knowledge. * \param r1 First RCC8 relation value, * \param r2 Second RCC8 relation value, * \return The knowledge associated with the composition. */ KnowledgeStateType GetKnowledge(RCC8ValueType r1, RCC8ValueType r2); private: /** Optimisation flag */ bool m_Optimisation; unsigned int m_Accumulator[8]; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageMultiSegmentationToRCC8GraphFilter.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbImageMultiSegmentationToRCC8GraphFilter.txx000066400000000000000000000254701301006202600306320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageMultiSegmentationToRCC8GraphFilter_txx #define otbImageMultiSegmentationToRCC8GraphFilter_txx #include "otbImageMultiSegmentationToRCC8GraphFilter.h" #include "itkMinimumMaximumImageCalculator.h" #include "otbPolygonToPolygonRCC8Calculator.h" #include "otbRCC8VertexIterator.h" #include "otbRCC8InEdgeIterator.h" #include "otbRCC8OutEdgeIterator.h" #include "itkProgressReporter.h" #include "otbImageToEdgePathFilter.h" #include "otbSimplifyPathListFilter.h" namespace otb { /** * Constructor. */ template ImageMultiSegmentationToRCC8GraphFilter ::ImageMultiSegmentationToRCC8GraphFilter() { m_Optimisation = false; } /** * Destructor. */ template ImageMultiSegmentationToRCC8GraphFilter ::~ImageMultiSegmentationToRCC8GraphFilter() {} template unsigned int ImageMultiSegmentationToRCC8GraphFilter ::GetRelationsCount(RCC8ValueType val) { return m_Accumulator[val]; } template unsigned int ImageMultiSegmentationToRCC8GraphFilter ::GetNumberOfRelations() { unsigned int result = 0; for (unsigned int i = 0; i < 8; ++i) { result += m_Accumulator[i]; } return result; } template typename ImageMultiSegmentationToRCC8GraphFilter ::KnowledgeStateType ImageMultiSegmentationToRCC8GraphFilter ::GetKnowledge(RCC8ValueType r1, RCC8ValueType r2) { m_Accumulator[0] = 0; m_Accumulator[1] = 0; m_Accumulator[2] = 0; m_Accumulator[3] = 0; m_Accumulator[4] = 0; m_Accumulator[5] = 0; m_Accumulator[6] = 0; m_Accumulator[7] = 0; // otbMsgDebugMacro(<<"RCC8GraphFilter: entering GetKnowledge method."); // This is the RCC8 composition table const int knowledge[8][8] = { /** DC EC PO TPP TPPi NTPP i EQ */ /** DC */ {-3, -2, -2, -2, 0, -2, 0, 0}, /** EC */ {-1, -3, -2, -3, -1, -3, 0, 1}, /** PO */ {-1, -1, -3, -3, -1, -3, -1, 2}, /** TPP */ { 0, -1, -2, -3, -3, 5, -1, 3}, /** TPPi*/ {-1, -1, -1, -3, -1, -3, 6, 4}, /** NTPP*/ { 0, 0, -2, 5, -2, 5, -3, 5}, /** NTPPi*/ {-1, -1, -1, -1, 6, -3, 6, 6}, /** EQ */ { 0, 1, 2, 3, 4, 5, 6, 7} }; int value = knowledge[r1][r2]; // Each negative case correspond to a level of knowledge if (value >= 0) { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method: FULL"); return KnowledgeStateType(FULL, static_cast(value)); } else if (value == -1) { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method: LEVEL_1"); return KnowledgeStateType(LEVEL_1, OTB_RCC8_DC); } else if (value == -2) { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method.LEVEL_3"); return KnowledgeStateType(LEVEL_3, OTB_RCC8_DC); } else { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method.NO_INFO"); return KnowledgeStateType(NO_INFO, OTB_RCC8_DC); } } /** * Main computation method. */ template void ImageMultiSegmentationToRCC8GraphFilter ::GenerateData() { // Input image list pointer InputImageListPointerType segList = this->GetInput(); // Output graph pointer OutputGraphPointerType graph = this->GetOutput(); // invert value vector RCC8ValueType invert[8] = {OTB_RCC8_DC, OTB_RCC8_EC, OTB_RCC8_PO, OTB_RCC8_TPPI, OTB_RCC8_TPP, OTB_RCC8_NTPPI, OTB_RCC8_NTPP, OTB_RCC8_EQ}; // Some typedefs typedef otb::ImageToEdgePathFilter EdgeExtractionFilterType; typedef otb::SimplifyPathListFilter SimplifyPathFilterType; typedef typename SimplifyPathFilterType::InputListType PathListType; typedef itk::MinimumMaximumImageCalculator MinMaxCalculatorType; typedef PolygonToPolygonRCC8Calculator RCC8CalculatorType; typedef RCC8VertexIterator VertexIteratorType; typedef RCC8InEdgeIterator InEdgeIteratorType; // Vector of label std::vector maxLabelVector; // Vertex indexes unsigned int vertexIndex = 0; unsigned int segmentationImageIndex = 0; unsigned int nbVertices = 0; // For each segmentation image for (ConstListIteratorType it = segList->Begin(); it != segList->End(); ++it) { // Compute the maximum label typename MinMaxCalculatorType::Pointer minMax = MinMaxCalculatorType::New(); minMax->SetImage(it.Get()); minMax->ComputeMaximum(); maxLabelVector.push_back(minMax->GetMaximum()); otbMsgDebugMacro(<< "Number of objects in image " << segmentationImageIndex << ": " << minMax->GetMaximum()); // then for each region of the images for (PixelType label = 1; label <= maxLabelVector.back(); ++label) { typename PathListType::Pointer region = PathListType::New(); typename EdgeExtractionFilterType::Pointer extraction = EdgeExtractionFilterType::New(); extraction->SetInput(it.Get()); extraction->SetForegroundValue(label); extraction->Update(); region->PushBack(extraction->GetOutput()); typename SimplifyPathFilterType::Pointer simplifier = SimplifyPathFilterType::New(); simplifier->SetInput(region); simplifier->GetFunctor().SetTolerance(0.1); simplifier->Update(); // Create a new vertex VertexPointerType vertex = VertexType::New(); // Set its properties vertex->SetPath(simplifier->GetOutput()->GetNthElement(0)); vertex->SetSegmentationLevel(segmentationImageIndex / 2); vertex->SetSegmentationType(segmentationImageIndex % 2); // Put it in the graph graph->SetVertex(vertexIndex, vertex); ++vertexIndex; ++nbVertices; } ++segmentationImageIndex; } itk::ProgressReporter progress(this, 0, nbVertices*nbVertices); VertexIteratorType vIt1(graph); VertexIteratorType vIt2(graph); // For each couple of vertices for (vIt1.GoToBegin(); !vIt1.IsAtEnd(); ++vIt1) { for (vIt2.GoToBegin(); !vIt2.IsAtEnd(); ++vIt2) { //We do not examine each couple because of the RCC8 symmetry if (vIt1.GetIndex() < vIt2.GetIndex()) { // Compute the RCC8 relation typename RCC8CalculatorType::Pointer calc = RCC8CalculatorType::New(); calc->SetPolygon1(vIt1.Get()->GetPath()); calc->SetPolygon2(vIt2.Get()->GetPath()); RCC8ValueType value = OTB_RCC8_DC; // if the optimisations are activated if (m_Optimisation) { // otbMsgDebugMacro(<<"RCC8GraphFilter: Entering optimisation loop"); InEdgeIteratorType inIt1(vIt1.GetIndex(), graph); InEdgeIteratorType inIt2(vIt2.GetIndex(), graph); // otbMsgDebugMacro(<<"Optimisation loop: iterators initialised"); VertexDescriptorType betweenIndex; KnowledgeStateType know(NO_INFO, OTB_RCC8_DC); inIt1.GoToBegin(); // Iterate through the edges going to the first vertex while (!inIt1.IsAtEnd() && (know.first != FULL)) { betweenIndex = inIt1.GetSourceIndex(); inIt2.GoToBegin(); bool edgeFound = false; while (!inIt2.IsAtEnd() && (know.first != FULL)) { // try to find an intermediate vertex between the two ones which // we vant to compute the relationship if (inIt2.GetSourceIndex() == betweenIndex) { // if an intermediate vertex is found edgeFound = true; // otbMsgDebugMacro(<<"Optimisation loop: found an intermediary vertex:" <SetLevel1APrioriKnowledge(know.first == LEVEL_1); calc->SetLevel3APrioriKnowledge(know.first == LEVEL_3); // otbMsgDebugMacro(<<"Optimisation loop: knowledge: "<SetLevel1APrioriKnowledge(know.first == LEVEL_1); calc->SetLevel3APrioriKnowledge(know.first == LEVEL_3); // otbMsgDebugMacro(<<"Optimisation loop: knowledge: "<Compute(); value = calc->GetValue(); } // otbMsgDebugMacro(<<"RCC8GraphFilter: Leaving optimisation loop"); } // If the optimisations are not activated else { calc->Compute(); value = calc->GetValue(); } m_Accumulator[value] += 1; m_Accumulator[invert[value]] += 1; // If the vertices are connected if (value > OTB_RCC8_DC) { // Add the edge to the graph. otbMsgDevMacro(<< "Adding edge: " << vIt1.GetIndex() << " -> " << vIt2.GetIndex() << ": " << value); graph->AddEdge(vIt1.GetIndex(), vIt2.GetIndex(), value); } } progress.CompletedPixel(); progress.CompletedPixel(); } } } template void ImageMultiSegmentationToRCC8GraphFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbImageToImageRCC8Calculator.h000066400000000000000000000160621301006202600254670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToImageRCC8Calculator_h #define otbImageToImageRCC8Calculator_h #include "itkImageToImageFilter.h" #include "itkObjectFactory.h" #include "otbRCC8Value.h" #include "otbImage.h" namespace otb { /** * \class ImageToImageRCC8Calculator * \brief This class compute the RCC8 relation between the regions from two segmentation images. * * The RCC8 system comes from qualitative spatial reasoning. * It is a set of pairwise disjoint exhaustive relation between two closed region of space. * There are 8 possible relations : * DC: Disconnected * EC: Externaly connected * PO: Partial overlap * TPP: Tangential proper part * NTPP: Non tangential proper part * TPPI: Tangential proper part inverse * NTPPI: Non tangential proper part inverse * EQ: Equivalence * * The goal of this class is to determine which of these 8 relations link the two inputs regions represented * by the segmentation images. Since this class will further be used iteratively on a possibly large set * of region, it is optimised : the decision is managed by a decision tree, and the input data size is reduced * to the smallest set needed to determine the relation. * * \ingroup OTBRCC8 */ template class ITK_EXPORT ImageToImageRCC8Calculator : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef ImageToImageRCC8Calculator Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageToImageRCC8Calculator, ImageToImageFilter); /** Types definitions for the input image. */ typedef TInputImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef typename ImageType::ConstPointer ImageConstPointerType; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::RegionType RegionType; /** Internal bool image type */ typedef bool BoolPixelType; typedef otb::Image BoolImageType; typedef typename BoolImageType::Pointer BoolImagePointerType; /** RCC8 values type */ typedef RCC8Value RCC8ValueType; /** * Get the RCC8 relation. * \return The RCC8 relation value. */ RCC8ValueType GetValue(void); /** * Set the first input image. * \param image */ void SetInput1(ImageType * image); /** * Set the second input image. * \param image */ void SetInput2(ImageType * image); /** * Get the first input image. * \return The first input image. */ ImageType * GetInput1(void); /** * Get the second input image. * \return The second input image. */ ImageType * GetInput2(void); /** Set/Get the inside value of the region of image 1*/ itkSetMacro(InsideValue1, PixelType); itkGetMacro(InsideValue1, PixelType); /** Set/Get the inside value of the region of image 2*/ itkSetMacro(InsideValue2, PixelType); itkGetMacro(InsideValue2, PixelType); /** Set external knowledge to help the decision process */ itkSetMacro(Level1APrioriKnowledge, bool); itkSetMacro(Level3APrioriKnowledge, bool); itkGetMacro(Level1APrioriKnowledge, bool); itkGetMacro(Level3APrioriKnowledge, bool); protected: /** Constructor */ ImageToImageRCC8Calculator(); /** Destructor */ ~ImageToImageRCC8Calculator() ITK_OVERRIDE {} /** * Compute the minimal image region required. * \return The minimal region required. */ RegionType ComputeMinimalRegion(void); /** * Compute the intersection between regions edges. * \return true if the intersection is not empty. */ bool ComputeEdgeEdgeBool(void); /** * Compute the intersection between exterior of region1 and * interior of region2. * \return true if the intersection is not empty. */ bool ComputeExterInterBool(void); /** * Compute the intersection between interior of region1 and * exterior of region2. * \return true if the intersection is not empty. */ bool ComputeInterExterBool(void); /** * Compute the intersection between regions interiors. * \return true if the intersection is not empty. */ bool ComputeInterInterBool(void); /** * Compute the relation value from the input booleans. Please note * that the actual computed value is set to the m_Value parameters, and has * nothing to do with the returned boolean, which indicates if the determination * process was successful. * \param edgeEdgeBool True if edge-edge intersection is not empty. * \param interExterBool True if interior-exterior intersection is not empty. * \param exterInterBool True if exterior-interior intersection is not empty. * \return True if the decision process was successful. */ bool ComputeRelation(bool edgeEdgeBool, bool interExterBool, bool exterInterBool); /** * Test if the boolean image is totally black or not. This is a based on the lazy operator * paradigm. * \param image The image to test. * \return True or false. */ bool IsBoolImageNotEmpty(BoolImagePointerType image); /** * Compute a bool image of minimal ROI size, surrounded by a false padding, and corresponding * to the input image. * \param image The image to convert. * \param insideValue The inside value. * \return The converted image */ BoolImagePointerType ConvertToBoolImage(ImagePointerType image, PixelType insideValue); /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** The RCC8 relation value */ RCC8ValueType m_Value; /** The minimal ROI needed to compute the relation value */ RegionType m_MinimalROI; /** Decision tree Level 1 A priori knowledge */ bool m_Level1APrioriKnowledge; /** Decision tree Level 3 A priori knowledge */ bool m_Level3APrioriKnowledge; /** Inside value 1 */ PixelType m_InsideValue1; /** Inside value 2 */ PixelType m_InsideValue2; /** Internal bool image representation*/ BoolImagePointerType m_BoolImage1; BoolImagePointerType m_BoolImage2; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToImageRCC8Calculator.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbImageToImageRCC8Calculator.txx000066400000000000000000000443031301006202600260620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToImageRCC8Calculator_txx #define otbImageToImageRCC8Calculator_txx #include "otbImageToImageRCC8Calculator.h" #include "itkUnaryFunctorImageFilter.h" #include "itkBinaryDilateImageFilter.h" #include "itkBinaryBallStructuringElement.h" #include "itkInvertIntensityImageFilter.h" #include "itkSubtractImageFilter.h" #include "itkAndImageFilter.h" #include "itkImageRegionIterator.h" #include "otbBinaryImageMinimalBoundingRegionCalculator.h" #include "otbMacro.h" //TODELETE #include "otbImageFileWriter.h" //TODELETE #include "itkCastImageFilter.h" namespace otb { /** * Constructor */ template ImageToImageRCC8Calculator ::ImageToImageRCC8Calculator() { m_Value = OTB_RCC8_DC; m_InsideValue1 = static_cast(255); m_InsideValue2 = static_cast(255); m_Level1APrioriKnowledge = false; m_Level3APrioriKnowledge = false; this->SetNumberOfRequiredInputs(2); } /** * Set the first input image. * \param image */ template void ImageToImageRCC8Calculator ::SetInput1(ImageType * image) { this->SetNthInput(0, const_cast(image)); } /** * Set the second input image. * \param image */ template void ImageToImageRCC8Calculator ::SetInput2(ImageType * image) { this->SetNthInput(1, const_cast(image)); } /** * Get the first input image. * \return The first input image. */ template typename ImageToImageRCC8Calculator ::ImageType* ImageToImageRCC8Calculator ::GetInput1(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(0)); } /** * Get the second input image. * \return The second input image. */ template typename ImageToImageRCC8Calculator ::ImageType* ImageToImageRCC8Calculator ::GetInput2(void) { return dynamic_cast(this->itk::ProcessObject::GetInput(1)); } /** * Get the RCC8 relation. * \return The RCC8 relation value. */ template typename ImageToImageRCC8Calculator ::RCC8ValueType ImageToImageRCC8Calculator ::GetValue(void) { return m_Value; } /** * Compute the minimal image region required. * \return The minimal region required. */ template typename ImageToImageRCC8Calculator ::RegionType ImageToImageRCC8Calculator ::ComputeMinimalRegion(void) { // Input images pointers typename ImageType::Pointer image1 = this->GetInput1(); typename ImageType::Pointer image2 = this->GetInput2(); typename ImageType::RegionType region1, region2, region; typedef otb::BinaryImageMinimalBoundingRegionCalculator RegionCalculator; typename RegionCalculator::Pointer rc = RegionCalculator::New(); rc->SetInput(image1); rc->SetPad(2); rc->SetInsideValue(this->GetInsideValue1()); rc->Update(); region1 = rc->GetRegion(); rc = RegionCalculator::New(); rc->SetInput(image2); rc->SetPad(2); rc->SetInsideValue(this->GetInsideValue2()); rc->Update(); region2 = rc->GetRegion(); // otbMsgDebugMacro(<<"RCC8Calculator->ComputeMinimalRegion() Region1: index: "<ComputeMinimalRegion() Region2: index: "<ComputeMinimalRegion() Region1: index: "<ComputeMinimalRegion() Region2: index: "<GetLargestPossibleRegion()); region.Crop(image2->GetLargestPossibleRegion()); // otbMsgDebugMacro(<<"RCC8Calculator->ComputeMinimalRegion(): index: "<ComputeMinimalRegion(): index: "< typename ImageToImageRCC8Calculator ::BoolImagePointerType ImageToImageRCC8Calculator ::ConvertToBoolImage(ImagePointerType image, PixelType insideValue) { typedef itk::ImageRegionConstIterator ConstIterator; typedef itk::ImageRegionIterator Iterator; typename BoolImageType::Pointer output = BoolImageType::New(); typename BoolImageType::SizeType boolImageSize; boolImageSize[0] = m_MinimalROI.GetSize()[0] + 2; boolImageSize[1] = m_MinimalROI.GetSize()[1] + 2; typename BoolImageType::IndexType boolImageIndex; boolImageIndex[0] = m_MinimalROI.GetIndex()[0] - 1; boolImageIndex[1] = m_MinimalROI.GetIndex()[1] - 1; //otbMsgDebugMacro(<<"RCC8Calculator->ConvertToBoolImage() size: "<SetRegions(boolRegion); output->Allocate(); output->FillBuffer(false); ConstIterator inputIt(image, m_MinimalROI); Iterator outputIt(output, m_MinimalROI); inputIt.GoToBegin(); outputIt.GoToBegin(); while (!inputIt.IsAtEnd() && !outputIt.IsAtEnd()) { outputIt.Set(inputIt.Get() == insideValue); ++inputIt; ++outputIt; } return output; } /** * Compute the intersection between regions edges. * \return true if the intersection is not empty. */ template bool ImageToImageRCC8Calculator ::ComputeEdgeEdgeBool(void) { /// Definition of the Filters used to compute the boolean typedef itk::SubtractImageFilter SubtractFilterType; typedef itk::BinaryBallStructuringElement BinaryBallStructuringElementType; typedef itk::BinaryDilateImageFilter DilateFilterType; typedef itk::AndImageFilter AndFilterType; /// Declaration and instantiation typename DilateFilterType::Pointer dilateFilter1 = DilateFilterType::New(); typename DilateFilterType::Pointer dilateFilter2 = DilateFilterType::New(); typename SubtractFilterType::Pointer subtractFilter1 = SubtractFilterType::New(); typename SubtractFilterType::Pointer subtractFilter2 = SubtractFilterType::New(); typename AndFilterType::Pointer andFilter = AndFilterType::New(); /// Configuration of the erosion filter BinaryBallStructuringElementType structElement1, structElement2; structElement1.SetRadius(1); structElement2.SetRadius(1); structElement1.CreateStructuringElement(); structElement2.CreateStructuringElement(); dilateFilter1->SetKernel(structElement1); dilateFilter2->SetKernel(structElement2); /// The erosion is performed to get the surrounding edge of this /// region by subtraction to the original image dilateFilter1->SetInput(m_BoolImage1); dilateFilter1->Update(); subtractFilter1->SetInput2(m_BoolImage1); subtractFilter1->SetInput1(dilateFilter1->GetOutput()); subtractFilter1->Update(); /// The erosion is performed to get the surrounding edge of this /// region by subtraction to the original image dilateFilter2->SetInput(m_BoolImage2); dilateFilter2->Update(); subtractFilter2->SetInput2(m_BoolImage2); subtractFilter2->SetInput1(dilateFilter2->GetOutput()); subtractFilter2->Update(); /// Now we can compute the intersection between the 2 edges andFilter->SetInput1(subtractFilter1->GetOutput()); andFilter->SetInput2(subtractFilter2->GetOutput()); andFilter->Update(); /// test if the intersection is empty or not return this->IsBoolImageNotEmpty(andFilter->GetOutput()); } /** * Compute the intersection between exterior of region1 and * interior of region2. * \return true if the intersection is not empty. */ template bool ImageToImageRCC8Calculator ::ComputeExterInterBool(void) { /// Definition of the filters used typedef itk::InvertIntensityImageFilter InvertFilterType; typedef itk::AndImageFilter AndFilterType; /// Declaration and instantiation typename InvertFilterType::Pointer invert = InvertFilterType::New(); typename AndFilterType::Pointer andFilter = AndFilterType::New(); /// The exterior is the inverted input image invert->SetMaximum(true); invert->SetInput(m_BoolImage1); andFilter->SetInput1(m_BoolImage2); andFilter->SetInput2(invert->GetOutput()); andFilter->Update(); /// test if the intersection is empty or not return IsBoolImageNotEmpty(andFilter->GetOutput()); } /** * Compute the intersection between interior of region1 and * exterior of region2. * \return true if the intersection is not empty. */ template bool ImageToImageRCC8Calculator ::ComputeInterExterBool(void) { /// Definition of the filters used typedef itk::InvertIntensityImageFilter InvertFilterType; typedef itk::AndImageFilter AndFilterType; //TODELETE typedef otb::Image TmpImageType; //TODELETE typedef itk::CastImageFilter CastFilterType; //TODELETE typedef ImageFileWriter WriterType; /// Declaration and instantiation typename InvertFilterType::Pointer invert = InvertFilterType::New(); typename AndFilterType::Pointer andFilter = AndFilterType::New(); /// The exterior is the inverted input image invert->SetMaximum(true); invert->SetInput(m_BoolImage2); //TODELETE typename CastFilterType::Pointer caster = CastFilterType::New(); //TODELETE caster->SetInput(invert->GetOutput()); //TODELETE typename WriterType::Pointer writer = WriterType::New(); //TODELETE writer->SetFileName("invert.tif"); //TODELETE writer->SetInput(caster->GetOutput()); //TODELETE writer->Update(); andFilter->SetInput1(m_BoolImage1); andFilter->SetInput2(invert->GetOutput()); andFilter->Update(); //TODELETE caster = CastFilterType::New(); //TODELETE caster->SetInput(andFilter->GetOutput()); //TODELETE writer = WriterType::New(); //TODELETE writer->SetFileName("and.tif"); //TODELETE writer->SetInput(caster->GetOutput()); //TODELETE writer->Update(); /// test if the intersection is empty or not return IsBoolImageNotEmpty(andFilter->GetOutput()); } /** * Compute the intersection between regions interiors. * \return true if the intersection is not empty. */ template bool ImageToImageRCC8Calculator ::ComputeInterInterBool(void) { /// Definition of the filters used typedef itk::AndImageFilter AndFilterType; /// Declaration and instantiation typename AndFilterType::Pointer andFilter = AndFilterType::New(); /// The exterior is the inverted input image andFilter->SetInput1(m_BoolImage1); andFilter->SetInput2(m_BoolImage2); andFilter->Update(); /// test if the intersection is empty or not return IsBoolImageNotEmpty(andFilter->GetOutput()); } /** * Compute the relation value from the input booleans. Please note * that the actual computed value is set to the m_Value parameters, and has * nothing to do with the returned boolean, which indicates if the determination * process was successful. * \param edgeEdgeBool True if edge-edge intersection is not empty. * \param interExterBool True if interior-exterior intersection is not empty. * \param exterInterBool True if exterior-interior intersection is not empty. * \return True if the decision process was successful. */ template bool ImageToImageRCC8Calculator ::ComputeRelation(bool edgeEdgeBool, bool interExterBool, bool exterInterBool) { // otbMsgDebugMacro(<<"RCC8Calculator->ComputeRelation()"); // This decision process is based on a decision tree if ((!interExterBool) && (edgeEdgeBool) && (!exterInterBool)) { m_Value = OTB_RCC8_EQ; return true; } else if ((!interExterBool) && (edgeEdgeBool) && (exterInterBool)) { m_Value = OTB_RCC8_TPP; return true; } else if ((interExterBool) && (!edgeEdgeBool) && (!exterInterBool)) { m_Value = OTB_RCC8_NTPPI; return true; } else if ((interExterBool) && (!edgeEdgeBool) && (exterInterBool)) { m_Value = OTB_RCC8_DC; return true; } else if ((interExterBool) && (edgeEdgeBool) && (!exterInterBool)) { m_Value = OTB_RCC8_TPPI; return true; } else { return false; } } /** * Test if the boolean image is totally black or not. This is a based on the lazy operator * paradigm. * \param image The image to test. * \return True or false. */ template bool ImageToImageRCC8Calculator ::IsBoolImageNotEmpty(BoolImagePointerType image) { typedef itk::ImageRegionConstIterator IteratorType; // TODO : we'll eventually need to change something. IteratorType it(image, image->GetLargestPossibleRegion()); it.GoToBegin(); while (!it.IsAtEnd()) { if (it.Get()) { return true; } ++it; } return false; } /** * Main computation method. */ template void ImageToImageRCC8Calculator ::GenerateData(void) { // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData()"); /// First we compute the minimal region of interest we will use for the relation computation m_MinimalROI = this->ComputeMinimalRegion(); /// If they are disjoint, the answer is trivial if ((m_MinimalROI.GetSize()[0] <= 1) || (m_MinimalROI.GetSize()[1] <= 1)) { /// The relation is DC m_Value = OTB_RCC8_DC; // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData(): Disjoint regions"); } else { /// else each input images is cast to boolean type and reduced to // the minimal region m_BoolImage1 = ConvertToBoolImage(this->GetInput1(), m_InsideValue1); m_BoolImage2 = ConvertToBoolImage(this->GetInput2(), m_InsideValue2); // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData(): Bool images computed: "<GetLargestPossibleRegion().GetSize()); /// Then the boolean which will be used to determine the relation /// are declared bool edgeEdgeBool, interExterBool, exterInterBool, interInterBool; /// The boolean edgeEdge is needed in each case, so it si computed /// now edgeEdgeBool = ComputeEdgeEdgeBool(); // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData(): edgeEdge "<GenerateData(): edgeEdge "<GetLevel1APrioriKnowledge()) { /// If the Level1APrioriKnowledge is set, then the /// interExterBool is set to true // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData(): Level1APrioriKnowledge."); interExterBool = true; } else { /// Else it must be computed interExterBool = ComputeInterExterBool(); // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData(): interExter "<GenerateData(): interExter "<GetLevel3APrioriKnowledge()) { /// If the Level3APRioriKnowledge flag is set, this boolean /// can be determined from the two others // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData(): Level3APrioriKnowledge."); exterInterBool = true; } else { /// Else it must be computed exterInterBool = ComputeExterInterBool(); // otbMsgDebugMacro(<<"RCC8Calculator->GenerateData(): ExterInter "<GenerateData(): ExterInter "<GenerateData(): InterInter "<GenerateData(): InterInter "< void ImageToImageRCC8Calculator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace itk #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbPolygonListToRCC8GraphFilter.h000066400000000000000000000136701301006202600261050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolygonListToRCC8GraphFilter_h #define otbPolygonListToRCC8GraphFilter_h #include "otbRCC8GraphSource.h" #include "otbPolygonToPolygonRCC8Calculator.h" #include "otbRCC8VertexIterator.h" #include "otbRCC8InEdgeIterator.h" #include "otbRCC8OutEdgeIterator.h" namespace otb { /** * \class PolygonListToRCC8GraphFilter * \brief This class computes an RCC8 graph from a set of polygons. * \sa ImageMultiSegmentationToRCC8GraphFilter * * \ingroup OTBRCC8 */ template class ITK_EXPORT PolygonListToRCC8GraphFilter : public RCC8GraphSource { public: /** Standard class typedefs. */ typedef PolygonListToRCC8GraphFilter Self; typedef RCC8GraphSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PolygonListToRCC8GraphFilter, RCC8GraphSource); /** Input related typedef */ typedef TPolygonList PolygonListType; typedef typename PolygonListType::ConstPointer PolygonListConstPointerType; typedef typename PolygonListType::ObjectType PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; /** Output related typedefs */ typedef TOutputGraph OutputGraphType; typedef typename OutputGraphType::Pointer OutputGraphPointerType; typedef typename OutputGraphType::VertexType VertexType; typedef typename VertexType::Pointer VertexPointerType; typedef typename VertexType::PathType PathType; typedef typename OutputGraphType::VertexDescriptorType VertexDescriptorType; /** Knowledge enum typedef */ typedef typename OutputGraphType::RCC8ValueType RCC8ValueType; typedef enum {NO_INFO, LEVEL_1, LEVEL_3, FULL} KnowledgeValueType; typedef std::pair KnowledgeStateType; /** RCC8 calculator typedef */ typedef PolygonToPolygonRCC8Calculator RCC8CalculatorType; /** Graph iterators typedefs */ typedef RCC8VertexIterator VertexIteratorType; typedef RCC8InEdgeIterator InEdgeIteratorType; typedef RCC8OutEdgeIterator OutEdgeIteratorType; typedef typename VertexIteratorType::VertexDescriptorType EdgePairElementType; typedef std::pair EdgePairType; typedef std::map EdgeMapType; typedef std::vector EdgeMapVectorType; typedef std::vector SegmentationRangesType; /** Toogle optimisation flag */ itkBooleanMacro(Optimisation); itkSetMacro(Optimisation, bool); itkBooleanMacro(UseInverted); itkSetMacro(UseInverted, bool); void SetSegmentationRanges(SegmentationRangesType ranges) { m_SegmentationRanges = ranges; } const SegmentationRangesType& GetSegmentationRanges() const { return m_SegmentationRanges; } /** * Get the number of occurrences of the given value * \return The value. */ unsigned int GetRelationsCount(RCC8ValueType val); /** * Get number of relations * \return The number of relations. */ unsigned int GetNumberOfRelations(void); using Superclass::SetInput; /** Set the input of the filter */ virtual void SetInput(const PolygonListType *input); /** Get the input of the filter */ const PolygonListType * GetInput(void); protected: /** Constructor */ PolygonListToRCC8GraphFilter(); /** Destructor */ ~PolygonListToRCC8GraphFilter() ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** Multi-threading implementation */ virtual void BeforeThreadedGenerateData(); virtual void AfterThreadedGenerateData(); /** startIndex and stopIndex represent the indices of the vertex to examine in thread threadId */ virtual void ThreadedGenerateData(unsigned int startIndex, unsigned int stopIndex, itk::ThreadIdType threadId); /** Static function used as a "callback" by the MultiThreader. The threading * library will call this routine for each thread, which will delegate the * control to ThreadedGenerateData(). */ static ITK_THREAD_RETURN_TYPE ThreaderCallback(void *arg); /** Internal structure used for passing image data into the threading library */ struct ThreadStruct { Pointer Filter; }; /** End Multi-threading implementation */ /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Get the composition knowledge. * \param r1 First RCC8 relation value, * \param r2 Second RCC8 relation value, * \return The knowledge associated with the composition. */ KnowledgeStateType GetKnowledge(RCC8ValueType r1, RCC8ValueType r2); private: /** Optimisation flag */ bool m_Optimisation; unsigned int m_Accumulator[8]; EdgeMapVectorType m_EdgesPerThread; /** This array stores the indices corresponding to each segmentation */ SegmentationRangesType m_SegmentationRanges; /** If set to true, the filter will also add the invert relationship * between v2 and v1 */ bool m_UseInverted; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPolygonListToRCC8GraphFilter.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbPolygonListToRCC8GraphFilter.txx000066400000000000000000000363031301006202600264770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolygonListToRCC8GraphFilter_txx #define otbPolygonListToRCC8GraphFilter_txx #include "otbPolygonListToRCC8GraphFilter.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor. */ template PolygonListToRCC8GraphFilter ::PolygonListToRCC8GraphFilter() { this->SetNumberOfRequiredInputs(1); m_Optimisation = false; m_UseInverted = false; } /** * Destructor. */ template PolygonListToRCC8GraphFilter ::~PolygonListToRCC8GraphFilter() {} template void PolygonListToRCC8GraphFilter ::SetInput(const PolygonListType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template const typename PolygonListToRCC8GraphFilter::PolygonListType * PolygonListToRCC8GraphFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template unsigned int PolygonListToRCC8GraphFilter ::GetRelationsCount(RCC8ValueType val) { return m_Accumulator[val]; } template unsigned int PolygonListToRCC8GraphFilter ::GetNumberOfRelations() { unsigned int result = 0; for (unsigned int i = 0; i < 8; ++i) { result += m_Accumulator[i]; } return result; } template typename PolygonListToRCC8GraphFilter ::KnowledgeStateType PolygonListToRCC8GraphFilter ::GetKnowledge(RCC8ValueType r1, RCC8ValueType r2) { m_Accumulator[0] = 0; m_Accumulator[1] = 0; m_Accumulator[2] = 0; m_Accumulator[3] = 0; m_Accumulator[4] = 0; m_Accumulator[5] = 0; m_Accumulator[6] = 0; m_Accumulator[7] = 0; // otbMsgDebugMacro(<<"RCC8GraphFilter: entering GetKnowledge method."); // This is the RCC8 composition table const int knowledge[8][8] = { /** DC EC PO TPP TPPi NTPP i EQ */ /** DC */ {-3, -2, -2, -2, 0, -2, 0, 0}, /** EC */ {-1, -3, -2, -3, -1, -3, 0, 1}, /** PO */ {-1, -1, -3, -3, -1, -3, -1, 2}, /** TPP */ { 0, -1, -2, -3, -3, 5, -1, 3}, /** TPPi*/ {-1, -1, -1, -3, -1, -3, 6, 4}, /** NTPP*/ { 0, 0, -2, 5, -2, 5, -3, 5}, /** NTPPi*/ {-1, -1, -1, -1, 6, -3, 6, 6}, /** EQ */ { 0, 1, 2, 3, 4, 5, 6, 7} }; int value = knowledge[r1][r2]; // Each negative case correspond to a level of knowledge if (value >= 0) { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method: FULL"); return KnowledgeStateType(FULL, static_cast(value)); } else if (value == -1) { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method: LEVEL_1"); return KnowledgeStateType(LEVEL_1, OTB_RCC8_DC); } else if (value == -2) { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method.LEVEL_3"); return KnowledgeStateType(LEVEL_3, OTB_RCC8_DC); } else { // otbMsgDebugMacro(<<"RCC8GraphFilter: leaving GetKnowledge method.NO_INFO"); return KnowledgeStateType(NO_INFO, OTB_RCC8_DC); } } /** * Main computation method. */ template void PolygonListToRCC8GraphFilter ::GenerateData() { // Call a method that can be overridden by a subclass to perform // some calculations prior to splitting the main computations into // separate threads this->BeforeThreadedGenerateData(); // Set up the multithreaded processing ThreadStruct str; str.Filter = this; // // Initializing edges vectors per thread EdgeMapType defaultEdgeMap; m_EdgesPerThread = EdgeMapVectorType(this->GetNumberOfThreads(), defaultEdgeMap); // Setting up multithreader this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads()); this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str); // multithread the execution this->GetMultiThreader()->SingleMethodExecute(); // Call a method that can be overridden by a subclass to perform // some calculations after all the threads have completed this->AfterThreadedGenerateData(); } template void PolygonListToRCC8GraphFilter ::BeforeThreadedGenerateData() { // Output graph pointer OutputGraphPointerType graph = this->GetOutput(); PolygonListConstPointerType inputPtr = this->GetInput(); // Initializing output graph graph->SetNumberOfVertices(inputPtr->Size()); graph->Build(); // Vertex indexes unsigned int nbVertices = 0; typedef typename PolygonListType::ConstIterator PolygonListConstIteratorType; // Loads the polygons list to graph nodes for (PolygonListConstIteratorType it = inputPtr->Begin(); it != inputPtr->End(); ++it) { // Create a new vertex VertexPointerType vertex = VertexType::New(); // Set its properties vertex->SetPath(it.Get()); // look for the appropriate segmentation index unsigned int segIndex = 1; while (segIndex < m_SegmentationRanges.size() && (nbVertices < m_SegmentationRanges[segIndex - 1] || nbVertices >= m_SegmentationRanges[segIndex])) { ++segIndex; } vertex->SetSegmentationLevel(segIndex - 1); // Put it in the graph graph->SetVertex(nbVertices, vertex); otbMsgDevMacro(<< "Adding vertex: " << nbVertices); ++nbVertices; } } template void PolygonListToRCC8GraphFilter ::ThreadedGenerateData(unsigned int startIndex, unsigned int stopIndex, itk::ThreadIdType threadId) { //std::cout<<"Starting thread "<GetOutput(); PolygonListConstPointerType inputPtr = this->GetInput(); // invert value vector RCC8ValueType invert[8] = {OTB_RCC8_DC, OTB_RCC8_EC, OTB_RCC8_PO, OTB_RCC8_TPPI, OTB_RCC8_TPP, OTB_RCC8_NTPPI, OTB_RCC8_NTPP, OTB_RCC8_EQ}; unsigned int nbVertices = graph->GetNumberOfVertices(); itk::ProgressReporter progress(this, threadId, ((int) stopIndex - (int) startIndex)*nbVertices); otbMsgDevMacro(<< "Adjacency matrix size: " << nbVertices * nbVertices); VertexIteratorType vIt1(graph); VertexIteratorType vIt2(graph); unsigned int count = 0; // For each couple of vertices for (vIt1.GoToBegin(); !vIt1.IsAtEnd(); ++vIt1) { // TODO: this is not correct and should be replaced by a // vIt1(graph, index1, index2), which does not exist for the moment if ((count >= startIndex) && (count < stopIndex)) { for (vIt2.GoToBegin(); !vIt2.IsAtEnd(); ++vIt2) { //We do not examine each couple because of the RCC8 symmetry if (vIt1.GetIndex() < vIt2.GetIndex()) { // Compute the RCC8 relation typename RCC8CalculatorType::Pointer calc = RCC8CalculatorType::New(); calc->SetPolygon1(vIt1.Get()->GetPath()); calc->SetPolygon2(vIt2.Get()->GetPath()); RCC8ValueType value = OTB_RCC8_DC; // if the optimisations are activated if (m_Optimisation) { // otbMsgDebugMacro(<<"RCC8GraphFilter: Entering optimisation loop"); InEdgeIteratorType inIt1(vIt1.GetIndex(), graph); InEdgeIteratorType inIt2(vIt2.GetIndex(), graph); // otbMsgDebugMacro(<<"Optimisation loop: iterators initialised"); VertexDescriptorType betweenIndex; KnowledgeStateType know(NO_INFO, OTB_RCC8_DC); inIt1.GoToBegin(); // Iterate through the edges going to the first vertex while (!inIt1.IsAtEnd() && (know.first != FULL)) { betweenIndex = inIt1.GetSourceIndex(); inIt2.GoToBegin(); bool edgeFound = false; while (!inIt2.IsAtEnd() && (know.first != FULL)) { // try to find an intermediate vertex between the two ones which // we vant to compute the relationship if (inIt2.GetSourceIndex() == betweenIndex) { // if an intermediate vertex is found edgeFound = true; // otbMsgDebugMacro(<<"Optimisation loop: found an intermediary vertex:" <SetLevel1APrioriKnowledge(know.first == LEVEL_1); calc->SetLevel3APrioriKnowledge(know.first == LEVEL_3); // otbMsgDebugMacro(<<"Optimisation loop: knowledge: "<SetLevel1APrioriKnowledge(know.first == LEVEL_1); calc->SetLevel3APrioriKnowledge(know.first == LEVEL_3); // otbMsgDebugMacro(<<"Optimisation loop: knowledge: "<Compute(); value = calc->GetValue(); } // otbMsgDebugMacro(<<"RCC8GraphFilter: Leaving optimisation loop"); } // If the optimisations are not activated else { calc->Compute(); value = calc->GetValue(); } m_Accumulator[value] += 1; m_Accumulator[invert[value]] += 1; // If the vertices are connected if (value > OTB_RCC8_DC) { // Add the edge to the graph. otbMsgDevMacro(<< "Adding edge: " << vIt1.GetIndex() << " -> " << vIt2.GetIndex() << ": " << value); if (value == OTB_RCC8_NTPPI) { m_EdgesPerThread[threadId][EdgePairType(vIt2.GetIndex(), vIt1.GetIndex())] = OTB_RCC8_NTPP; } else if (value == OTB_RCC8_TPPI) { m_EdgesPerThread[threadId][EdgePairType(vIt2.GetIndex(), vIt1.GetIndex())] = OTB_RCC8_TPP; } else { m_EdgesPerThread[threadId][EdgePairType(vIt1.GetIndex(), vIt2.GetIndex())] = value; } if (m_UseInverted) { m_EdgesPerThread[threadId][EdgePairType(vIt2.GetIndex(), vIt1.GetIndex())] = invert[value]; } } } progress.CompletedPixel(); progress.CompletedPixel(); } } ++count; } otbMsgDebugMacro(<< "End thread " << threadId); } template void PolygonListToRCC8GraphFilter ::AfterThreadedGenerateData() { // in order to have the same output graph whatever the number of // thread is, we use a map to sort the edges in lexicographical // order OutputGraphPointerType graph = this->GetOutput(); EdgeMapType globalEdgeMap; // merge all edges for (typename EdgeMapVectorType::iterator vIt = m_EdgesPerThread.begin(); vIt != m_EdgesPerThread.end(); ++vIt) { for (typename EdgeMapType::iterator mIt = (*vIt).begin(); mIt != (*vIt).end(); ++mIt) { globalEdgeMap[mIt->first] = mIt->second; } } // Report edges to the graph for (typename EdgeMapType::iterator mIt = globalEdgeMap.begin(); mIt != globalEdgeMap.end(); ++mIt) { graph->AddEdge(mIt->first.first, mIt->first.second, mIt->second); } } // Callback routine used by the threading library. This routine just calls // the ThreadedGenerateData method after setting the correct region for this // thread. template ITK_THREAD_RETURN_TYPE PolygonListToRCC8GraphFilter ::ThreaderCallback(void *arg) { ThreadStruct *str; int threadId, threadCount; unsigned int total, start, stop; threadId = ((itk::MultiThreader::ThreadInfoStruct *) (arg))->ThreadID; threadCount = ((itk::MultiThreader::ThreadInfoStruct *) (arg))->NumberOfThreads; str = (ThreadStruct *) (((itk::MultiThreader::ThreadInfoStruct *) (arg))->UserData); total = str->Filter->GetOutput()->GetNumberOfVertices(); if (threadId < static_cast(total)) { // Split the adjacency matrix in strip of equal dimension start = static_cast(vcl_floor(total * vcl_sqrt(static_cast(threadId) / static_cast(threadCount)) + 0.5)); stop = static_cast(vcl_floor(total * vcl_sqrt(static_cast(threadId + 1) / static_cast(threadCount)) + 0.5)); if (stop > total) stop = total; // For very small graphs it might occur that start = stop. In this // case the vertex at that index will be processed in the next strip. if (start != stop) { str->Filter->ThreadedGenerateData(start, stop, threadId); } } // else // { // otherwise don't use this thread. Sometimes the threads don't // break up very well and it is just as efficient to leave a // few threads idle. // } return ITK_THREAD_RETURN_VALUE; } template void PolygonListToRCC8GraphFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbPolygonToPolygonRCC8Calculator.h000066400000000000000000000111601301006202600264730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolygonToPolygonRCC8Calculator_h #define otbPolygonToPolygonRCC8Calculator_h #include "itkObject.h" #include "otbRCC8Value.h" #include "otbImage.h" namespace otb { /** * \class PolygonToPolygonRCC8Calculator * \brief This class compute the RCC8 relation between the regions from two segmentation images. * * The RCC8 system comes from qualitative spatial reasoning. * It is a set of pairwise disjoint exhaustive relation between two closed region of space. * There are 8 possible relations : * DC: Disconnected * EC: Externaly connected * PO: Partial overlap * TPP: Tangential proper part * NTPP: Non tangential proper part * TPPI: Tangential proper part inverse * NTPPI: Non tangential proper part inverse * EQ: Equivalence * * The goal of this class is to determine which of these 8 relations link the two inputs regions represented * by the closed input path. Since this class will further be used iteratively on a possibly large set * of regiosn, it is optimised : the decision is managed by a decision tree. * * \ingroup OTBRCC8 */ template class ITK_EXPORT PolygonToPolygonRCC8Calculator : public itk::Object { public: /** Standard class typedefs. */ typedef PolygonToPolygonRCC8Calculator Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PolygonToPolygonRCC8Calculator, Object); /** Types definitions for the input image. */ typedef TInputPolygon PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; typedef typename PolygonType::ConstPointer PolygonConstPointerType; typedef typename PolygonType::VertexListType VertexListType; typedef typename PolygonType::ContinuousIndexType ContinuousIndexType; typedef typename PolygonType::RegionType::ImageRegionType RegionType; typedef typename VertexListType::ConstIterator VertexListConstIteratorType; typedef std::vector BoolVectorType; /** RCC8 values type */ typedef RCC8Value RCC8ValueType; /** * Get the RCC8 relation. * \return The RCC8 relation value. */ RCC8ValueType GetValue(void); /** Set external knowledge to help the decision process */ itkSetMacro(Level1APrioriKnowledge, bool); itkSetMacro(Level3APrioriKnowledge, bool); itkGetMacro(Level1APrioriKnowledge, bool); itkGetMacro(Level3APrioriKnowledge, bool); itkSetObjectMacro(Polygon1, PolygonType); itkSetObjectMacro(Polygon2, PolygonType); itkGetObjectMacro(Polygon1, PolygonType); itkGetObjectMacro(Polygon2, PolygonType); /** Main computation method */ void Compute(void); virtual bool ComputeRelation(bool edgeEdgeBool, bool interExterBool, bool exterInterBool); virtual bool ComputeInterExter(PolygonPointerType path1, PolygonPointerType path2); virtual bool ComputeEdgeEdge(PolygonPointerType path1, PolygonPointerType path2); virtual bool ComputeInterInter(PolygonPointerType path1, PolygonPointerType path2); virtual bool RegionsIntersectionIsNull(const RegionType& region1, const RegionType& region2); protected: /** Constructor */ PolygonToPolygonRCC8Calculator(); /** Destructor */ ~PolygonToPolygonRCC8Calculator() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** The RCC8 relation value */ RCC8ValueType m_Value; /** Decision tree Level 1 A priori knowledge */ bool m_Level1APrioriKnowledge; /** Decision tree Level 3 A priori knowledge */ bool m_Level3APrioriKnowledge; /** Polygon of region 1 */ PolygonPointerType m_Polygon1; /** Polygon of region 2 */ PolygonPointerType m_Polygon2; /** Epsilon */ double m_Epsilon; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPolygonToPolygonRCC8Calculator.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbPolygonToPolygonRCC8Calculator.txx000066400000000000000000000233161301006202600270750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPolygonToPolygonRCC8Calculator_txx #define otbPolygonToPolygonRCC8Calculator_txx #include "otbPolygonToPolygonRCC8Calculator.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template PolygonToPolygonRCC8Calculator ::PolygonToPolygonRCC8Calculator() { m_Value = OTB_RCC8_DC; m_Level1APrioriKnowledge = false; m_Level3APrioriKnowledge = false; } /** * Get the RCC8 relation. * \return The RCC8 relation value. */ template typename PolygonToPolygonRCC8Calculator ::RCC8ValueType PolygonToPolygonRCC8Calculator ::GetValue(void) { return m_Value; } template void PolygonToPolygonRCC8Calculator ::Compute(void) { // First check if bounding regions are disjoints RegionType region1 = m_Polygon1->GetBoundingRegion().GetImageRegion(); RegionType region2 = m_Polygon2->GetBoundingRegion().GetImageRegion(); // If intersection is not null, we have to do the computation if (!RegionsIntersectionIsNull(region1, region2)) { bool edgeEdgeBool, interExterBool, exterInterBool, interInterBool; /// The boolean edgeEdge is needed in each case, so it si computed /// now edgeEdgeBool = ComputeEdgeEdge(m_Polygon1, m_Polygon2); //std::cout<<"EdgeEdge: "<GetLevel1APrioriKnowledge()) { interExterBool = true; } else { /// Else it must be computed interExterBool = ComputeInterExter(m_Polygon1, m_Polygon2); } //std::cout<<"InterExter: "<GetLevel3APrioriKnowledge()) { /// If the Level3APRioriKnowledge flag is set, this boolean /// can be determined from the two others exterInterBool = true; } else { /// Else it must be computed exterInterBool = ComputeInterExter(m_Polygon2, m_Polygon1); } //std::cout<<"ExterInter: "< bool PolygonToPolygonRCC8Calculator ::RegionsIntersectionIsNull(const RegionType& region1, const RegionType& region2) { for (unsigned int dim = 0; dim < RegionType::ImageDimension; ++dim) { if (region1.GetIndex()[dim] + static_cast(region1.GetSize()[dim]) < region2.GetIndex()[dim]) { return true; } else if (region2.GetIndex()[dim] + static_cast(region2.GetSize()[dim]) < region1.GetIndex()[dim]) { return true; } } return false; } template bool PolygonToPolygonRCC8Calculator ::ComputeRelation(bool edgeEdgeBool, bool interExterBool, bool exterInterBool) { // This decision process is based on a decision tree if ((!interExterBool) && (edgeEdgeBool) && (!exterInterBool)) { m_Value = OTB_RCC8_EQ; return true; } else if ((!interExterBool) && (edgeEdgeBool) && (exterInterBool)) { m_Value = OTB_RCC8_TPP; return true; } else if ((interExterBool) && (!edgeEdgeBool) && (!exterInterBool)) { m_Value = OTB_RCC8_NTPPI; return true; } else if ((interExterBool) && (!edgeEdgeBool) && (exterInterBool)) { m_Value = OTB_RCC8_DC; return true; } else if ((interExterBool) && (edgeEdgeBool) && (!exterInterBool)) { m_Value = OTB_RCC8_TPPI; return true; } else { return false; } } template bool PolygonToPolygonRCC8Calculator ::ComputeInterExter(PolygonPointerType polygon1, PolygonPointerType polygon2) { bool resp = false; VertexListConstIteratorType it = polygon1->GetVertexList()->Begin(); VertexListConstIteratorType it_end = polygon1->GetVertexList()->End(); ContinuousIndexType current = it.Value(); ContinuousIndexType first = current; bool isInside = polygon2->IsInside(current); bool firstIsInside = isInside; bool isExterior = !isInside && !polygon2->IsOnEdge(current); //std::cout<IsOnEdge(current)<IsInside(it.Value()); if (isInside && nextIsInside) { //std::cout<NbCrossing(current, it.Value())<NbCrossing(current, it.Value()) > 0; } current = it.Value(); isInside = nextIsInside; isExterior = !isInside && !polygon2->IsOnEdge(current); //std::cout<IsOnEdge(current)<NbCrossing(current, first) > 0; //std::cout<NbCrossing(current, first)< bool PolygonToPolygonRCC8Calculator ::ComputeInterInter(PolygonPointerType polygon1, PolygonPointerType polygon2) { bool resp = false; VertexListConstIteratorType it = polygon1->GetVertexList()->Begin(); VertexListConstIteratorType it_end = polygon1->GetVertexList()->End(); ContinuousIndexType current = it.Value(); ContinuousIndexType first = current; bool currentIsInside = polygon2->IsInside(current); bool firstIsInside = currentIsInside; if (currentIsInside) { resp = true; } ++it; while (!resp && it != it_end) { bool nextIsInside = polygon2->IsInside(it.Value()); if (!currentIsInside && !nextIsInside && !polygon2->IsOnEdge(current) && !polygon2->IsOnEdge(it.Value())) { unsigned int nbCrossings = polygon2->NbCrossing(current, it.Value()); resp = nbCrossings > 0; } currentIsInside = nextIsInside; current = it.Value(); if (currentIsInside) { resp = true; } ++it; } if (!resp && !currentIsInside && !firstIsInside && !polygon2->IsOnEdge(current) && !polygon2->IsOnEdge(first)) { unsigned int nbCrossings = polygon2->NbCrossing(current, first); resp = nbCrossings > 0; } return resp; } template bool PolygonToPolygonRCC8Calculator ::ComputeEdgeEdge(PolygonPointerType polygon1, PolygonPointerType polygon2) { bool resp = false; VertexListConstIteratorType it = polygon1->GetVertexList()->Begin(); VertexListConstIteratorType it_end = polygon1->GetVertexList()->End(); ContinuousIndexType current = it.Value(); resp = polygon2->IsOnEdge(current); //std::cout<<"IsOnEdge: "<IsOnEdge(current)<NbTouching(current, it.Value()) > 0) { resp = true; //std::cout<<"NbCrossing: "< "<NbCrossing(current, it.Value())<NbCrossing(current, it.Value()) > 0) { resp = true; //std::cout<<"NbTouching: "< "<NbTouching(current, it.Value())<IsOnEdge(current)) { resp = true; //std::cout<<"IsOnEdge: "<IsOnEdge(current)<NbTouching(current, first) > 0) { resp = true; //std::cout<<"NbCrossing: "< "<NbCrossing(current, first)<NbCrossing(current, first) > 0) { resp = true; //std::cout<<"NbTouching: "< "<NbTouching(current, first)< void PolygonToPolygonRCC8Calculator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8Edge.h000066400000000000000000000033771301006202600220360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8Edge_h #define otbRCC8Edge_h #include "itkDataObject.h" #include "itkObjectFactory.h" #include "otbRCC8Value.h" namespace otb { /** \class RCC8Edge * \brief Base class to represent an edge in a RCC8 Graph. * * \sa RCC8Graph, RCC8VertexBase * * \ingroup OTBRCC8 */ class ITK_EXPORT RCC8Edge : public itk::DataObject { public: /** Standard class typedefs */ typedef RCC8Edge Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RCC8Edge, DataObject); /** RCC8 values typedef */ typedef RCC8Value RCC8ValueType; /** RCC8 relation value accessors */ itkGetMacro(Value, RCC8ValueType); itkSetMacro(Value, RCC8ValueType); protected: /** Constructor */ RCC8Edge(); /** Desctructor */ ~RCC8Edge() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** The RCC8 value */ RCC8ValueType m_Value; }; } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8EdgeIterator.h000066400000000000000000000066301301006202600235430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8EdgeIterator_h #define otbRCC8EdgeIterator_h #include "otbRCC8Graph.h" namespace otb { /** * \class RCC8EdgeIterator * \brief Iterates on the graph edges. * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8EdgeIterator { public: /** self typedef */ typedef RCC8EdgeIterator Self; /** Graph typedef */ typedef TGraph GraphType; typedef typename GraphType::InternalGraphType InternalGraphType; typedef typename GraphType::Pointer GraphPointerType; typedef typename GraphType::EdgePointerType EdgePointerType; typedef typename GraphType::VertexPointerType VertexPointerType; typedef typename GraphType::VertexDescriptorType VertexDescriptorType; typedef typename GraphType::RCC8ValueType RCC8ValueType; /** typedef of the internal iterator */ typedef typename boost::graph_traits::edge_iterator InternalIteratorType; /** Typedef of the index map */ typedef typename boost::property_map::type IndexMapType; /** Constructor */ RCC8EdgeIterator(); /** Copy constructor */ RCC8EdgeIterator(const Self &iter); /** Constructor with input graph */ RCC8EdgeIterator(TGraph * graph); /** * Get the current edge value. * \return The value of the current edge pointed by the iterator. */ RCC8ValueType GetValue(void); /** * Return the source vertex of the current edge. * \return The source edge. */ VertexPointerType GetSourceVertex(void); /** * Return the target vertex of the current edge. * \return The target vertex. */ VertexPointerType GetTargetVertex(void); /** * Return the source vertex index of the current edge. * \return The source vertex index. */ VertexDescriptorType GetSourceIndex(void); /** * Return the target vertex index of the current edge. * \return The target vertex index. */ VertexDescriptorType GetTargetIndex(void); /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ bool IsAtEnd(void); /** * Go to the beginning. */ void GoToBegin(void); /** * Increment. */ Self& operator ++(); /** * Decrement. */ Self& operator --(); /** * Add */ Self& operator +(int i); /** * Remove */ Self& operator -(int i); /** * Difference comparison operator. */ bool operator !=(const Self& it); /** * Equality comparison operator. */ bool operator ==(const Self& it); /** * Instantiation operator. */ Self& operator =(const Self& it); private: // End InternalIteratorType m_End; // Internal iterator. InternalIteratorType m_Iter; // Input graph pointer GraphPointerType m_Graph; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8EdgeIterator.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8EdgeIterator.txx000066400000000000000000000106161301006202600241360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8EdgeIterator_txx #define otbRCC8EdgeIterator_txx #include "otbRCC8EdgeIterator.h" namespace otb { /** Constructor */ template RCC8EdgeIterator ::RCC8EdgeIterator() { m_Graph = GraphType::New(); boost::tuples::tie(m_Iter, m_End) = edges(*m_Graph->GetGraph()); } /** * Copy operator. */ template RCC8EdgeIterator ::RCC8EdgeIterator(const Self& iter) { m_Iter = iter.m_Iter; m_Graph = iter.m_Graph; m_End = iter.m_End; } /** *Constructor with input graph */ template RCC8EdgeIterator ::RCC8EdgeIterator(TGraph * graph) { m_Graph = graph; boost::tuples::tie(m_Iter, m_End) = edges(*m_Graph->GetGraph()); } /** * Get the current edge value. * \return The value of the current edge pointed by the iterator. */ template typename RCC8EdgeIterator ::RCC8ValueType RCC8EdgeIterator ::GetValue(void) { return (*m_Graph->GetGraph())[*m_Iter]->GetValue(); } /** * Return the source vertex of the current edge. * \return The source edge. */ template typename RCC8EdgeIterator ::VertexPointerType RCC8EdgeIterator ::GetSourceVertex(void) { return (*m_Graph->GetGraph())[source(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return the target vertex of the current edge. * \return The target vertex. */ template typename RCC8EdgeIterator ::VertexPointerType RCC8EdgeIterator ::GetTargetVertex(void) { return (*m_Graph->GetGraph())[target(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return the source vertex index of the current edge. * \return The source vertex index. */ template typename RCC8EdgeIterator ::VertexDescriptorType RCC8EdgeIterator ::GetSourceIndex(void) { IndexMapType index = get(boost::vertex_index, (*m_Graph->GetGraph())); return index[source(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return the target vertex index of the current edge. * \return The target vertex index. */ template typename RCC8EdgeIterator ::VertexDescriptorType RCC8EdgeIterator ::GetTargetIndex(void) { IndexMapType index = get(boost::vertex_index, (*m_Graph->GetGraph())); return index[target(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ template bool RCC8EdgeIterator ::IsAtEnd(void) { return (m_Iter == m_End); } /** * Go to the beginning. */ template void RCC8EdgeIterator ::GoToBegin(void) { boost::tuples::tie(m_Iter, m_End) = edges(*m_Graph->GetGraph()); } /** * Increment. */ template typename RCC8EdgeIterator ::Self& RCC8EdgeIterator ::operator++ () { ++m_Iter; return *this; } /** * Decrement. */ template typename RCC8EdgeIterator ::Self& RCC8EdgeIterator ::operator-- () { --m_Iter; return *this; } /** * Add */ template typename RCC8EdgeIterator ::Self& RCC8EdgeIterator ::operator + (int i) { m_Iter = m_Iter + i; return *this; } /** * Remove */ template typename RCC8EdgeIterator ::Self& RCC8EdgeIterator ::operator - (int i) { m_Iter = m_Iter - i; return *this; } /** * Difference comparison operator. */ template bool RCC8EdgeIterator ::operator != (const Self &iter) { return (m_Iter != iter.m_Iter); } /** * Equality comparison operator. */ template bool RCC8EdgeIterator ::operator == (const Self &iter) { return (m_Iter == iter.m_Iter); } /** * Instantiation operator. */ template typename RCC8EdgeIterator ::Self& RCC8EdgeIterator ::operator = (const Self &iter) { m_Iter = iter.m_Iter; return *this; } } // End namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8Graph.h000066400000000000000000000111411301006202600222170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8Graph_h #define otbRCC8Graph_h #include "otbRCC8Edge.h" //fix compilation in VS7.1 for boost 1.42 //similar to the fix in Monteverdi #ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST #define BOOST_NO_0X_HDR_INITIALIZER_LIST #endif #include "otb_boost_graph_header.h" #include "otbImage.h" #include "otbImageList.h" namespace otb { /** * \class RCC8Graph * \brief This class is a data structure designed to store RCC8 Graph * computed from a pyramidal segmentation. * * A batch of boost operation has been embedded in order to provide * basic functionality such as adding a new edge, or retrieving the * number of vertices. A method is also provided to retrieve the boost * graph object, in case more advanced processing is required. One * should remember that if a peculiar operation is needed for some * applications, one should provide a patch for this class including * the new functionnalities, for consistency reason. * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8Graph : public itk::DataObject { public: /** Standard class typedefs. */ typedef RCC8Graph Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RCC8Graph, itk::DataObject); /** Vertex typedef */ typedef TVertex VertexType; typedef typename VertexType::Pointer VertexPointerType; /** Edge typedef */ typedef RCC8Edge EdgeType; typedef typename EdgeType::Pointer EdgePointerType; typedef typename EdgeType::RCC8ValueType RCC8ValueType; /** Typedef for the boost graph representation */ typedef boost::adjacency_list InternalGraphType; /** Edges and vertices descriptors typedefs (boost objects)*/ typedef typename InternalGraphType::vertex_descriptor VertexDescriptorType; typedef typename InternalGraphType::edge_descriptor EdgeDescriptorType; /** Getters and Setters for the number of vertices */ itkSetMacro(NumberOfVertices, unsigned int); itkGetConstReferenceMacro(NumberOfVertices, unsigned int); /** * Return the internal boost graph object. * \return The internal boost graph object */ InternalGraphType * GetGraph(void) { return &m_Graph; } /** * Since the number of vertices is mandatory to instantiate the * internal boost representation, the build method has to be called * once this parameter is set. */ void Build(void); /** * Set a vertex. * \param index The index of the vertex in the graph. * \param vertex The vertex to set. */ void SetVertex(unsigned int index, VertexPointerType vertex); /** * Get a vertex. * \param index The index of the vertex in the graph * \return The vertex. */ VertexPointerType GetVertex(unsigned int index); /** * Add an edge in the graph. * \param index1 The index of the source vertex. * \param index2 The index of the target vertex. * \param r The RCC8 value. */ void AddEdge(unsigned int index1, unsigned int index2, RCC8ValueType r); /** * Get number of edges * /return The number of edges. */ unsigned int GetNumberOfEdges(void); protected: /** Constructor */ RCC8Graph(); /** Destructor */ ~RCC8Graph() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Initialize a range of vertex. * \param num The index of the last vertices to initialize. */ void InitializeGraph(unsigned int num); private: /** Defines the number of vertices (ie total number of segmentation regions)*/ unsigned int m_NumberOfVertices; /** Internal representation using the boost graph library */ InternalGraphType m_Graph; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8Graph.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8Graph.txx000066400000000000000000000057761301006202600226340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8Graph_txx #define otbRCC8Graph_txx #include "otbRCC8Graph.h" namespace otb { /** * Constructor */ template RCC8Graph ::RCC8Graph() { m_NumberOfVertices = 0; } /** * since the number of vertices is mandatory to instantiate the * internal boost representation, the build method has to be called * once this parameter is set. */ template void RCC8Graph ::Build(void) { this->InitializeGraph(m_NumberOfVertices - 1); } /** * Initialize a range of vertex. * \param num The index of the last vertices to initialize. */ template void RCC8Graph ::InitializeGraph(unsigned int num) { for (unsigned int i = boost::num_vertices(m_Graph); i <= num; ++i) { VertexDescriptorType id = boost::add_vertex(m_Graph); VertexPointerType vertex = VertexType::New(); m_Graph[id] = vertex; } } /** * Set a vertex. * \param index The index of the vertex in the graph. * \param vertex The vertex to set. */ template void RCC8Graph ::SetVertex(unsigned int index, VertexPointerType vertex) { if (index >= m_NumberOfVertices) { this->InitializeGraph(index); m_NumberOfVertices = index + 1; } VertexDescriptorType v = *boost::vertices(m_Graph).first; m_Graph[v + index] = vertex; } /** * Get a vertex. * \param index The index of the vertex in the graph * \return The vertex. */ template typename RCC8Graph ::VertexPointerType RCC8Graph ::GetVertex(unsigned int index) { VertexDescriptorType v = *boost::vertices(m_Graph).first; return m_Graph[v + index]; } /** * Add an edge in the graph. * \param index1 The index of the source vertex. * \param index2 The index of the target vertex. * \param r The rcc8 value associated to the edge. */ template void RCC8Graph ::AddEdge(unsigned int index1, unsigned int index2, RCC8ValueType r) { EdgeDescriptorType e = boost::add_edge(index1, index2, m_Graph).first; EdgeType::Pointer edge = EdgeType::New(); edge->SetValue(r); m_Graph[e] = edge; } /** * Get number of edges * /return The number of edges. */ template unsigned int RCC8Graph ::GetNumberOfEdges(void) { return num_edges(m_Graph); } /** * PrintSelf method */ template void RCC8Graph ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8GraphFileReader.h000066400000000000000000000072221301006202600241470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8GraphFileReader_h #define otbRCC8GraphFileReader_h #include "otbRCC8GraphSource.h" #include "itkMacro.h" namespace otb { /** \class RCC8GraphFileReaderException * \brief Base exception class for IO problems during reading. * * \ingroup OTBRCC8 */ class ITK_EXPORT RCC8GraphFileReaderException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(RCC8GraphFileReaderException, ExceptionObject); /** Constructor. */ RCC8GraphFileReaderException(const char *file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} /** Constructor. */ RCC8GraphFileReaderException(const std::string & file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} }; /** * \class RCC8GraphFileReader * \brief This class reads a RCC8 graph from a .dot file (graphviz format). * * The parsing algorithm reads the lines from the file, deciding if the line is * a vertex or edge line. It then call the correct parse method between ParseEdge * and ParseVertex. The ParseVertex use builds an AttributesMap and pass it to a new * vertex. * * \sa RCC8GraphFileWriter * \sa RCC8Graph * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8GraphFileReader : public RCC8GraphSource { public: /** Standards typedef */ typedef RCC8GraphFileReader Self; typedef RCC8GraphSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** Runtime type information */ itkTypeMacro(RCC8GraphFileReader, RCC8GraphSource); /** Output related typedefs */ typedef TOutputGraph OutputGraphType; typedef typename Superclass::OutputGraphPointerType OutputGraphPointerType; typedef typename OutputGraphType::VertexType VertexType; typedef typename VertexType::Pointer VertexPointerType; typedef typename OutputGraphType::RCC8ValueType RCC8ValueType; /** Set the filename */ itkSetStringMacro(FileName); /** Get the filename */ itkGetStringMacro(FileName); protected: /** Constructor */ RCC8GraphFileReader(); /** Destructor */ ~RCC8GraphFileReader() ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** * Parse edge information from a given line. * \param line The line to parse. */ void ParseEdge(const std::string& line); /** * Parse vertex information from a given line. * \param line The line to parse. */ void ParseVertex(const std::string& line); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** File name */ std::string m_FileName; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8GraphFileReader.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8GraphFileReader.txx000066400000000000000000000104731301006202600245450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8GraphFileReader_txx #define otbRCC8GraphFileReader_txx #include "otbRCC8GraphFileReader.h" #include "otbRCC8VertexIterator.h" #include "otbMacro.h" #include #include #include namespace otb { /** * Constructor */ template RCC8GraphFileReader ::RCC8GraphFileReader() { m_FileName = ""; } /** * Destructor */ template RCC8GraphFileReader ::~RCC8GraphFileReader() { } /** * Parse edge information from a given line. * \param line The line to parse. */ template void RCC8GraphFileReader ::ParseEdge(const std::string& line) { typename std::string::size_type pos1 = line.find_first_of(" ", 0); typename std::string::size_type pos2 = line.find_first_of(" ", pos1 + 1); typename std::string::size_type pos3 = line.find_first_of(" ", pos2 + 1); unsigned int source = atoi(line.substr(0, pos1).c_str()); unsigned int target = atoi(line.substr(pos2 + 1, pos3 - pos2 - 1).c_str()); typename std::string::size_type pos4 = line.find_first_of("\"", 0); typename std::string::size_type pos5 = line.find_first_of("\" ", pos4 + 1); RCC8ValueType value = static_cast(atoi(line.substr(pos4 + 1, pos5 - pos4 - 1).c_str())); otbMsgDevMacro(<< "RCC8GraphFileReader: Edge line parsed: " << source << " -> " << target << " " << value); this->GetOutput()->AddEdge(source, target, value); } /** * Parse vertex information from a given line. * \param line The line to parse. */ template void RCC8GraphFileReader ::ParseVertex(const std::string& line) { typename VertexType::AttributesMapType attr; typename std::string::size_type pos = line.find_first_of(" ", 0); unsigned int index = atoi(line.substr(0, pos).c_str()); otbMsgDevMacro(<< "RCC8GraphFileReader: Vertex index: " << index); typename std::string::size_type midPos, nextPos; midPos = line.find_first_of("\"", pos + 2); nextPos = line.find_first_of("\"", midPos + 1); std::string key, value; while ((midPos != std::string::npos) && (nextPos != std::string::npos)) { key = line.substr(pos + 2, midPos - pos - 3); value = line.substr(midPos + 1, nextPos - midPos - 1); attr[key] = value; otbMsgDevMacro(<< "RCC8GraphFileReader: Vertex attribute: " << key << " " << value); pos = nextPos; midPos = line.find_first_of("\"", pos + 2); nextPos = line.find_first_of("\"", midPos + 1); } typename VertexType::Pointer vertex = VertexType::New(); vertex->SetAttributesMap(attr); this->GetOutput()->SetVertex(index, vertex); } /** * Generate data method */ template void RCC8GraphFileReader ::GenerateData() { std::ifstream fin; std::string line; // open file input stream fin.open(m_FileName.c_str()); // Test if the file has been opened correctly if (!fin) { RCC8GraphFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << " Could not create IO object for file "; msg << m_FileName << "." << std::endl; e.SetDescription(msg.str().c_str()); throw e; return; } // if so, parse it while (!fin.eof()) { std::getline(fin, line); if (line.find("->") != std::string::npos) { // edge line this->ParseEdge(line); } else if (line.find("[") != std::string::npos) { // vertex line this->ParseVertex(line); } } fin.close(); } /** * PrintSelf method */ template void RCC8GraphFileReader ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8GraphFileWriter.h000066400000000000000000000113721301006202600242220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8GraphFileWriter_h #define otbRCC8GraphFileWriter_h #include "itkProcessObject.h" #include "itkMacro.h" #include "otbRCC8Graph.h" namespace otb { /** \class RCC8GraphFileWriterException * \brief Base exception class for IO problems during writing. * * \ingroup OTBRCC8 */ class ITK_EXPORT RCC8GraphFileWriterException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(RCC8GraphFileWriterException, ExceptionObject); /** Constructor. */ RCC8GraphFileWriterException(const char *file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} /** Constructor. */ RCC8GraphFileWriterException(const std::string & file, unsigned int line, const char* message = "Error in IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} }; /** * \class RCC8GraphFileWriter * \brief This class writes a RCC8 Graph to a dot file (graphviz file format). * * The writer first loops on the vertices of the graph, getting the property map * from each vertex and printing it in a line. * * It then iterates on the edges of the graphs, printing source index, target index, * and RCC8 value in a line for each of them. * * \sa RCC8GraphFileReader * \sa RCC8Graph * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8GraphFileWriter : public itk::ProcessObject { public: /** Standards typedefs */ typedef RCC8GraphFileWriter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RCC8GraphFileWriter, ProcessObject); /** Typedefs for the output graph type */ typedef TInputGraph InputGraphType; typedef typename InputGraphType::Pointer InputGraphPointerType; typedef typename InputGraphType::VertexType VertexType; typedef typename VertexType::Pointer VertexPointerType; typedef typename InputGraphType::VertexDescriptorType VertexDescriptorType; typedef typename InputGraphType::RCC8ValueType RCC8ValueType; typedef typename VertexType::AttributesMapType AttributesMapType; /** Set the filename */ itkSetStringMacro(FileName); /** Get the filename */ itkGetStringMacro(FileName); using Superclass::SetInput; /** * Set the input graph. * \param inputGraph The graph to write. */ virtual void SetInput(const InputGraphType* inputGraph); /** * Get the input graph. * \return The input graph pointer. */ virtual InputGraphPointerType GetInput(); /** * Update method. */ void Update(void) ITK_OVERRIDE; protected: /** Constructor */ RCC8GraphFileWriter(); /** Destructor */ ~RCC8GraphFileWriter() ITK_OVERRIDE; /** * Main computation method. */ void GenerateData(void) ITK_OVERRIDE; /** * Write Method. * Performs checkings and invoke GenerateData(). */ virtual void Write(void); /** * Write an edge to file. * \param of The output file stream. * \param source The index of the source vertex. * \param target The index of the target vertex. * \param value The value of the edge. */ void WriteEdge(std::ofstream& of, VertexDescriptorType source, VertexDescriptorType target, RCC8ValueType value); /** * Write a vertex to file. * \param of The output file stream. * \param index The index of the edge to write. * \param vertex The pointer to the vertex object. */ void WriteVertex(std::ofstream& of, VertexDescriptorType index, VertexPointerType vertex); /** * PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** Filename of the graph file to write */ std::string m_FileName; }; } // namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8GraphFileWriter.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8GraphFileWriter.txx000066400000000000000000000130771301006202600246220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8GraphFileWriter_txx #define otbRCC8GraphFileWriter_txx #include "otbRCC8GraphFileWriter.h" #include "otbRCC8VertexIterator.h" #include "otbRCC8EdgeIterator.h" #include "otbMacro.h" #include namespace otb { /** * Constructor */ template RCC8GraphFileWriter ::RCC8GraphFileWriter() { this->SetNumberOfRequiredInputs(1); m_FileName = ""; } /** * Destructor */ template RCC8GraphFileWriter ::~RCC8GraphFileWriter() { } /** * Set the input graph. * \param graph The graph to write. */ template void RCC8GraphFileWriter ::SetInput(const InputGraphType * graph) { this->itk::ProcessObject::SetNthInput(0, const_cast(graph)); } /** * Get the input graph. * \return The input graph pointer. */ template typename RCC8GraphFileWriter ::InputGraphPointerType RCC8GraphFileWriter ::GetInput(void) { return static_cast(this->itk::ProcessObject::GetInput(0)); } /** * Update method. * (Call the Write() method). */ template void RCC8GraphFileWriter ::Update(void) { this->Write(); } /** * Write Method. * Performs checkings and invoke GenerateData(). */ template void RCC8GraphFileWriter ::Write(void) { InputGraphType * input = this->GetInput(); itkDebugMacro(<< "Writing a RCC8Graph file"); // Make sure input is available if (input == ITK_NULLPTR) { itkExceptionMacro(<< "No input to writer!"); } // Make sure that we can write the file given the name // if (m_FileName == "") { itkExceptionMacro(<< "No filename was specified"); } // Pipeline updating sequence input->UpdateOutputInformation(); input->PropagateRequestedRegion(); input->UpdateOutputData(); // GenerateData (actually write file) this->GenerateData(); } /** * Main computation method. */ template void RCC8GraphFileWriter ::GenerateData() { otbMsgDevMacro(<< "RCC8GraphFileWriter: GenerateData call"); // input graph pointer InputGraphPointerType input = this->GetInput(); // iterators typedefs typedef otb::RCC8VertexIterator VertexIteratorType; typedef otb::RCC8EdgeIterator EdgeIteratorType; // Output file stream std::ofstream out; // open the outputfile out.open(m_FileName.c_str(), std::ios::out); // Test if the file has been opened correctly if (!out) { RCC8GraphFileWriterException e(__FILE__, __LINE__); std::ostringstream msg; msg << " Could not create IO object for file "; msg << m_FileName << "." << std::endl; e.SetDescription(msg.str().c_str()); throw e; return; } // Start writing the graph to file out << "digraph G {" << std::endl; // For each vertex in the graph VertexIteratorType vIt(input); for (vIt.GoToBegin(); !vIt.IsAtEnd(); ++vIt) { this->WriteVertex(out, vIt.GetIndex(), vIt.Get()); } // For each edge in the graph EdgeIteratorType eIt(input); for (eIt.GoToBegin(); !eIt.IsAtEnd(); ++eIt) { this->WriteEdge(out, eIt.GetSourceIndex(), eIt.GetTargetIndex(), eIt.GetValue()); } // Ends the graph writing out << "}" << std::endl; // Close the file out.close(); } /** * Write an edge to file. * \param of The output file stream. * \param source The index of the source vertex. * \param target The index of the target vertex. * \param value The value of the edge. */ template void RCC8GraphFileWriter ::WriteEdge(std::ofstream& of, VertexDescriptorType source, VertexDescriptorType target, RCC8ValueType value) { otbMsgDevMacro(<< "RCC8GraphFileWriter: WriteEdge call: " << source << " " << target << " " << value); of << source << " -> " << target << " "; of << "[Value=\"" << value << "\"];"; of << std::endl; } /** * Write a vertex to file. * \param of The output file stream. * \param index The index of the edge to write. * \param vertex The pointer to the vertex object. */ template void RCC8GraphFileWriter ::WriteVertex(std::ofstream& of, VertexDescriptorType index, VertexPointerType vertex) { typedef typename VertexType::AttributesMapType AttributesMapType; typedef typename AttributesMapType::iterator IteratorType; AttributesMapType attr = vertex->GetAttributesMap(); otbMsgDevMacro(<< "RCC8GraphFileWriter: WriteVertex call: " << index); of << index << " ["; IteratorType it = attr.begin(); while (it != attr.end()) { of << (*it).first << "=\""; of << (*it).second << "\""; ++it; if (it == attr.end()) { of << "];" << std::endl; } else { of << ","; } } } /** * PrintSelf method */ template void RCC8GraphFileWriter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8GraphSource.h000066400000000000000000000040431301006202600234030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8GraphSource_h #define otbRCC8GraphSource_h #include "itkProcessObject.h" namespace otb { /** \class RCC8GraphSource * \brief Base class for all the filters producing an otbRCC8Graph * \ingroup DataSources * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8GraphSource : public itk::ProcessObject { public: /** Standard typedefs */ typedef RCC8GraphSource Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(RCC8GraphSource, itk::ProcessObject); /** Data object pointer type */ typedef itk::DataObject::Pointer DataObjectPointer; /** Template parameter typedef*/ typedef TOutputGraph OutputGraphType; typedef typename OutputGraphType::Pointer OutputGraphPointerType; /** Overriding of the GetOutput() method */ virtual OutputGraphType * GetOutput(void); protected: /** Constructor */ RCC8GraphSource(); /** Destructor */ ~RCC8GraphSource() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RCC8GraphSource(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8GraphSource.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8GraphSource.txx000066400000000000000000000027211301006202600240000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8GraphSource_txx #define otbRCC8GraphSource_txx #include "otbRCC8GraphSource.h" namespace otb { /** * Constructor */ template RCC8GraphSource ::RCC8GraphSource() { this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, TOutputGraph::New().GetPointer()); } /** * Get the output Graph * \return The output graph produced. */ template typename RCC8GraphSource::OutputGraphType * RCC8GraphSource ::GetOutput(void) { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } /** * PrintSelf Method */ template void RCC8GraphSource ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8InEdgeIterator.h000066400000000000000000000063721301006202600240350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8InEdgeIterator_h #define otbRCC8InEdgeIterator_h #include "otbRCC8Graph.h" namespace otb { /** * \class RCC8InEdgeIterator * \brief Iterates on the graph in edges from a vertex. * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8InEdgeIterator { public: /** self typedef */ typedef RCC8InEdgeIterator Self; /** Graph typedef */ typedef TGraph GraphType; typedef typename GraphType::InternalGraphType InternalGraphType; typedef typename GraphType::Pointer GraphPointerType; typedef typename GraphType::EdgePointerType EdgePointerType; typedef typename GraphType::VertexPointerType VertexPointerType; typedef typename GraphType::VertexDescriptorType VertexDescriptorType; typedef typename GraphType::RCC8ValueType RCC8ValueType; /** typedef of the internal iterator */ typedef typename boost::graph_traits::in_edge_iterator InternalIteratorType; /** Typedef of the index map */ typedef typename boost::property_map::type IndexMapType; /** Constructor */ RCC8InEdgeIterator(); /** Copy constructor */ RCC8InEdgeIterator(const Self &iter); /** Constructor with input graph */ RCC8InEdgeIterator(VertexDescriptorType vertex, GraphType * graph); /** * Get the current edge value. * \return The value of the current edge pointed by the iterator. */ RCC8ValueType GetValue(void); /** * Return the source vertex of the current edge. * \return The source edge. */ VertexPointerType GetSourceVertex(void); /** * Return the source vertex index of the current edge. * \return The source vertex index. */ VertexDescriptorType GetSourceIndex(void); /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ bool IsAtEnd(void); /** * Go to the beginning. */ void GoToBegin(void); /** * Increment. */ Self& operator ++(); /** * Decrement. */ Self& operator --(); /** * Add */ Self& operator +(int i); /** * Remove */ Self& operator -(int i); /** * Difference comparison operator. */ bool operator !=(const Self& it); /** * Equality comparison operator. */ bool operator ==(const Self& it); /** * Instantiation operator. */ Self& operator =(const Self& it); private: // End InternalIteratorType m_End; // Internal iterator. InternalIteratorType m_Iter; // Input graph pointer GraphPointerType m_Graph; // Target vertex index VertexDescriptorType m_VertexIndex; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8InEdgeIterator.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8InEdgeIterator.txx000066400000000000000000000076751301006202600244400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8InEdgeIterator_txx #define otbRCC8InEdgeIterator_txx #include "otbRCC8InEdgeIterator.h" namespace otb { /** Constructor */ template RCC8InEdgeIterator ::RCC8InEdgeIterator() { m_Graph = GraphType::New(); boost::tuples::tie(m_Iter, m_End) = in_edges(0, *m_Graph->GetGraph()); } /** * Copy operator. */ template RCC8InEdgeIterator ::RCC8InEdgeIterator(const Self& iter) { m_Iter = iter.m_Iter; m_Graph = iter.m_Graph; m_VertexIndex = iter.m_VertexIndex; m_End = iter.m_End; } /** *Constructor with input graph */ template RCC8InEdgeIterator ::RCC8InEdgeIterator(VertexDescriptorType vertex, GraphType * graph) { m_Graph = graph; m_VertexIndex = vertex; boost::tuples::tie(m_Iter, m_End) = in_edges(vertex, *m_Graph->GetGraph()); } /** * Get the current edge value. * \return The value of the current edge pointed by the iterator. */ template typename RCC8InEdgeIterator ::RCC8ValueType RCC8InEdgeIterator ::GetValue(void) { return (*m_Graph->GetGraph())[*m_Iter]->GetValue(); } /** * Return the source vertex of the current edge. * \return The source edge. */ template typename RCC8InEdgeIterator ::VertexPointerType RCC8InEdgeIterator ::GetSourceVertex(void) { return (*m_Graph->GetGraph())[source(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return the source vertex index of the current edge. * \return The source vertex index. */ template typename RCC8InEdgeIterator ::VertexDescriptorType RCC8InEdgeIterator ::GetSourceIndex(void) { IndexMapType index = get(boost::vertex_index, (*m_Graph->GetGraph())); return index[source(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ template bool RCC8InEdgeIterator ::IsAtEnd(void) { return (m_Iter == m_End); } /** * Go to the beginning. */ template void RCC8InEdgeIterator ::GoToBegin(void) { boost::tuples::tie(m_Iter, m_End) = in_edges(m_VertexIndex, *m_Graph->GetGraph()); } /** * Increment. */ template typename RCC8InEdgeIterator ::Self& RCC8InEdgeIterator ::operator++ () { ++m_Iter; return *this; } /** * Decrement. */ template typename RCC8InEdgeIterator ::Self& RCC8InEdgeIterator ::operator-- () { --m_Iter; return *this; } /** * Add */ template typename RCC8InEdgeIterator ::Self& RCC8InEdgeIterator ::operator + (int i) { m_Iter = m_Iter + i; return *this; } /** * Remove */ template typename RCC8InEdgeIterator ::Self& RCC8InEdgeIterator ::operator - (int i) { m_Iter = m_Iter - i; return *this; } /** * Difference comparison operator. */ template bool RCC8InEdgeIterator ::operator != (const Self &iter) { return (m_Iter != iter.m_Iter); } /** * Equality comparison operator. */ template bool RCC8InEdgeIterator ::operator == (const Self &iter) { return (m_Iter == iter.m_Iter); } /** * Instantiation operator. */ template typename RCC8InEdgeIterator ::Self& RCC8InEdgeIterator ::operator = (const Self &iter) { m_Iter = iter.m_Iter; return *this; } } // End namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8OutEdgeIterator.h000066400000000000000000000064061301006202600242340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8OutEdgeIterator_h #define otbRCC8OutEdgeIterator_h #include "otbRCC8Graph.h" namespace otb { /** * \class RCC8OutEdgeIterator * \brief Iterates on the graph out edges from a vertex. * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8OutEdgeIterator { public: /** self typedef */ typedef RCC8OutEdgeIterator Self; /** Graph typedef */ typedef TGraph GraphType; typedef typename GraphType::InternalGraphType InternalGraphType; typedef typename GraphType::Pointer GraphPointerType; typedef typename GraphType::EdgePointerType EdgePointerType; typedef typename GraphType::VertexPointerType VertexPointerType; typedef typename GraphType::VertexDescriptorType VertexDescriptorType; typedef typename GraphType::RCC8ValueType RCC8ValueType; /** typedef of the internal iterator */ typedef typename boost::graph_traits::out_edge_iterator InternalIteratorType; /** Typedef of the index map */ typedef typename boost::property_map::type IndexMapType; /** Constructor */ RCC8OutEdgeIterator(); /** Copy constructor */ RCC8OutEdgeIterator(const Self &iter); /** Constructor with input graph */ RCC8OutEdgeIterator(VertexDescriptorType vertex, TGraph * graph); /** * Get the current edge value. * \return The value of the current edge pointed by the iterator. */ RCC8ValueType GetValue(void); /** * Return the target vertex of the current edge. * \return The target vertex. */ VertexPointerType GetTargetVertex(void); /** * Return the target vertex index of the current edge. * \return The target vertex index. */ VertexDescriptorType GetTargetIndex(void); /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ bool IsAtEnd(void); /** * Go to the beginning. */ void GoToBegin(void); /** * Increment. */ Self& operator ++(); /** * Decrement. */ Self& operator --(); /** * Add */ Self& operator +(int i); /** * Remove */ Self& operator -(int i); /** * Difference comparison operator. */ bool operator !=(const Self& it); /** * Equality comparison operator. */ bool operator ==(const Self& it); /** * Instantiation operator. */ Self& operator =(const Self& it); private: // End InternalIteratorType m_End; // Internal iterator. InternalIteratorType m_Iter; // Input graph pointer GraphPointerType m_Graph; // source vertex descriptor VertexDescriptorType m_VertexIndex; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8OutEdgeIterator.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8OutEdgeIterator.txx000066400000000000000000000076571301006202600246410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8OutEdgeIterator_txx #define otbRCC8OutEdgeIterator_txx #include "otbRCC8OutEdgeIterator.h" namespace otb { /** Constructor */ template RCC8OutEdgeIterator ::RCC8OutEdgeIterator() { m_Graph = GraphType::New(); tie(m_Iter, m_End) = out_edges(0, *m_Graph->GetGraph()); } /** * Copy operator. */ template RCC8OutEdgeIterator ::RCC8OutEdgeIterator(const Self& iter) { m_Iter = iter.m_Iter; m_Graph = iter.m_Graph; m_VertexIndex = iter.m_VertexIndex; m_End = iter.m_End; } /** *Constructor with input graph */ template RCC8OutEdgeIterator ::RCC8OutEdgeIterator(VertexDescriptorType vertex, TGraph * graph) { m_Graph = graph; m_VertexIndex = vertex; tie(m_Iter, m_End) = out_edges(vertex, *m_Graph->GetGraph()); } /** * Get the current edge value. * \return The value of the current edge pointed by the iterator. */ template typename RCC8OutEdgeIterator ::RCC8ValueType RCC8OutEdgeIterator ::GetValue(void) { return (*m_Graph->GetGraph())[*m_Iter]->GetValue(); } /** * Return the target vertex of the current edge. * \return The target vertex. */ template typename RCC8OutEdgeIterator ::VertexPointerType RCC8OutEdgeIterator ::GetTargetVertex(void) { return (*m_Graph->GetGraph())[target(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return the target vertex index of the current edge. * \return The target vertex index. */ template typename RCC8OutEdgeIterator ::VertexDescriptorType RCC8OutEdgeIterator ::GetTargetIndex(void) { IndexMapType index = get(boost::vertex_index, (*m_Graph->GetGraph())); return index[target(*m_Iter, (*m_Graph->GetGraph()))]; } /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ template bool RCC8OutEdgeIterator ::IsAtEnd(void) { return (m_Iter == m_End); } /** * Go to the beginning. */ template void RCC8OutEdgeIterator ::GoToBegin(void) { tie(m_Iter, m_End) = out_edges(m_VertexIndex, *m_Graph->GetGraph()); } /** * Increment. */ template typename RCC8OutEdgeIterator ::Self& RCC8OutEdgeIterator ::operator++ () { ++m_Iter; return *this; } /** * Decrement. */ template typename RCC8OutEdgeIterator ::Self& RCC8OutEdgeIterator ::operator-- () { --m_Iter; return *this; } /** * Add */ template typename RCC8OutEdgeIterator ::Self& RCC8OutEdgeIterator ::operator + (int i) { m_Iter = m_Iter + i; return *this; } /** * Remove */ template typename RCC8OutEdgeIterator ::Self& RCC8OutEdgeIterator ::operator - (int i) { m_Iter = m_Iter - i; return *this; } /** * Difference comparison operator. */ template bool RCC8OutEdgeIterator ::operator != (const Self &iter) { return (m_Iter != iter.m_Iter); } /** * Equality comparison operator. */ template bool RCC8OutEdgeIterator ::operator == (const Self &iter) { return (m_Iter == iter.m_Iter); } /** * Instantiation operator. */ template typename RCC8OutEdgeIterator ::Self& RCC8OutEdgeIterator ::operator = (const Self &iter) { m_Iter = iter.m_Iter; return *this; } } // End namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8Value.h000066400000000000000000000015571301006202600222440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8Value_h #define otbRCC8Value_h namespace otb { // Coding enum system to represent the RCC8 relation values. typedef enum { OTB_RCC8_DC, OTB_RCC8_EC, OTB_RCC8_PO, OTB_RCC8_TPP, OTB_RCC8_TPPI, OTB_RCC8_NTPP, OTB_RCC8_NTPPI, OTB_RCC8_EQ } RCC8Value; } // End namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexBase.h000066400000000000000000000057371301006202600232440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexBase_h #define otbRCC8VertexBase_h #include "itkDataObject.h" #include "itkObjectFactory.h" #include namespace otb { /** \class RCC8VertexBase * \brief Base class to represent a vertex in a RCC8 Graph. * * This class can be derived to add attributes to the vertices of the * RCC8 graph. * * \sa RCC8Graph, RCC8Edge * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8VertexBase : public itk::DataObject { public: /** Standard class typedefs */ typedef RCC8VertexBase Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RCC8VertexBase, DataObject); /** Input image associated typedefs*/ typedef TPath PathType; typedef typename PathType::Pointer PathPointerType; typedef typename PathType::ContinuousIndexType ContinuousIndexType; /** char* vector attributes */ typedef std::map AttributesMapType; /** Segmentation image index accessors */ itkGetMacro(SegmentationLevel, unsigned int); itkSetMacro(SegmentationLevel, unsigned int); itkGetMacro(SegmentationType, bool); itkSetMacro(SegmentationType, bool); /** Object label in image accessor */ itkGetObjectMacro(Path, PathType); itkSetObjectMacro(Path, PathType); /** * Set the VertexBase attributes from the attributes vector. * \param attributes The vector containing the parsed attributes. */ virtual void SetAttributesMap(AttributesMapType attributes); /** * Get an attributes vector representing the VertexBase attributes. * \return The attributes vector */ virtual AttributesMapType GetAttributesMap(void); protected: /** Constructor */ RCC8VertexBase(); /** Desctructor */ ~RCC8VertexBase() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** The segmentation level */ unsigned int m_SegmentationLevel; /** True if bright details, false otherwise */ bool m_SegmentationType; /** The path of the edge of the region */ PathPointerType m_Path; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8VertexBase.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexBase.txx000066400000000000000000000063611301006202600236320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexBase_txx #define otbRCC8VertexBase_txx #include "otbRCC8VertexBase.h" namespace otb { /** * Constructor */ template RCC8VertexBase ::RCC8VertexBase() { m_SegmentationLevel = 0; m_SegmentationType = true; m_Path = PathType::New(); m_Path->Initialize(); } /** * Set the VertexBase attributes from the attributes vector. * \param attributes The vector containing the parsed attributes. */ template void RCC8VertexBase ::SetAttributesMap(AttributesMapType attributes) { m_SegmentationLevel = static_cast(atoi(attributes["SegmentationLevel"].c_str())); m_SegmentationType = static_cast(atoi(attributes["SegmentationType"].c_str())); unsigned int nbPoints = static_cast(atoi(attributes["NumberOfPointsInPath"].c_str())); std::ostringstream oss; m_Path = PathType::New(); m_Path->Initialize(); for (unsigned int i = 0; i < nbPoints; ++i) { ContinuousIndexType newPoint; oss << "P" << i << "x"; newPoint[0] = atof(attributes[oss.str()].c_str()); oss.str(""); oss << "P" << i << "y"; newPoint[1] = atof(attributes[oss.str()].c_str()); oss.str(""); m_Path->AddVertex(newPoint); } } /** * Get an attributes vector representing the VertexBase attributes. * \return The attributes vector */ template typename RCC8VertexBase::AttributesMapType RCC8VertexBase ::GetAttributesMap(void) { std::ostringstream oss; AttributesMapType results; oss << m_SegmentationLevel; results["SegmentationLevel"] = oss.str(); oss.str(""); oss << m_SegmentationType; results["SegmentationType"] = oss.str(); oss.str(""); oss << m_Path->GetVertexList()->Size(); results["NumberOfPointsInPath"] = oss.str(); oss.str(""); typename PathType::VertexListType::ConstIterator it; unsigned int index = 0; for (it = m_Path->GetVertexList()->Begin(); it != m_Path->GetVertexList()->End(); ++it, ++index) { ContinuousIndexType point = it.Value(); oss << "P" << index << "x"; std::string key = oss.str(); oss.str(""); oss << point[0]; results[key] = oss.str(); oss.str(""); oss << "P" << index << "y"; key = oss.str(); oss.str(""); oss << point[1]; results[key] = oss.str(); oss.str(""); } return results; } /** * PrintSelf method */ template void RCC8VertexBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "SegmentationLevel: " << m_SegmentationLevel << std::endl; os << indent << "SegmentationType: " << m_SegmentationType << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexIterator.h000066400000000000000000000057031301006202600241540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexIterator_h #define otbRCC8VertexIterator_h #include "otbRCC8Graph.h" namespace otb { /** * \class RCC8VertexIterator * \brief Iterates on the graph vertices * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8VertexIterator { public: /** self typedef */ typedef RCC8VertexIterator Self; /** Graph typedef */ typedef TGraph GraphType; typedef typename GraphType::InternalGraphType InternalGraphType; typedef typename GraphType::Pointer GraphPointerType; typedef typename GraphType::VertexPointerType VertexPointerType; typedef typename GraphType::VertexDescriptorType VertexDescriptorType; /** typedef of the internal iterator */ typedef typename boost::graph_traits::vertex_iterator InternalIteratorType; /** Typedef of the index map */ typedef typename boost::property_map::type IndexMapType; /** Constructor */ RCC8VertexIterator(); /** Copy constructor */ RCC8VertexIterator(const Self &iter); /** Constructor with input graph */ RCC8VertexIterator(TGraph * graph); /** * Get the current vertex. * \return The current vertex pointed by the iterator. */ VertexPointerType Get(void); /** * Set the current vertex. * \param vertex The vertex to set. */ void Set(VertexPointerType vertex); /** * Get the current vertex index. * \return The current vertex index. */ VertexDescriptorType GetIndex(void); /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ bool IsAtEnd(void); /** * Go to the beginning. */ void GoToBegin(void); /** * Increment. */ Self& operator ++(); /** * Decrement. */ Self& operator --(); /** * Add */ Self& operator +(int i); /** * Remove */ Self& operator -(int i); /** * Difference comparison operator. */ bool operator !=(const Self& it); /** * Equality comparison operator. */ bool operator ==(const Self& it); /** * Instantiation operator. */ Self& operator =(const Self& it); private: // End InternalIteratorType m_End; // Internal iterator. InternalIteratorType m_Iter; // Input graph pointer GraphPointerType m_Graph; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8VertexIterator.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexIterator.txx000066400000000000000000000072431301006202600245510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexIterator_txx #define otbRCC8VertexIterator_txx #include "otbRCC8VertexIterator.h" namespace otb { /** * Constructor */ template RCC8VertexIterator ::RCC8VertexIterator() { m_Graph = GraphType::New(); boost::tie(m_Iter, m_End) = boost::vertices(*(m_Graph->GetGraph())); } /** * Copy operator. */ template RCC8VertexIterator ::RCC8VertexIterator(const Self& iter) { m_Iter = iter.m_Iter; m_Graph = iter.m_Graph; m_End = iter.m_End; } /** *Constructor with input graph */ template RCC8VertexIterator ::RCC8VertexIterator(TGraph * graph) { m_Graph = graph; boost::tie(m_Iter, m_End) = boost::vertices(*(m_Graph->GetGraph())); } /** * Get the current object. * \return The current object pointed by the iterator. */ template typename RCC8VertexIterator ::VertexPointerType RCC8VertexIterator ::Get(void) { return (*(m_Graph->GetGraph()))[*m_Iter]; } /** * Set the current vertex. * \param vertex The vertex to set. */ template void RCC8VertexIterator ::Set(VertexPointerType vertex) { (*(m_Graph->GetGraph()))[*m_Iter] = vertex; } /** * Get the current vertex index. * \return The current vertex index. */ template typename RCC8VertexIterator ::VertexDescriptorType RCC8VertexIterator ::GetIndex(void) { IndexMapType index = get(boost::vertex_index, (*m_Graph->GetGraph())); return index[*m_Iter]; } /** * Return true if the iterator is at the end. * \return True if the iterator is at the end. */ template bool RCC8VertexIterator ::IsAtEnd(void) { return (m_Iter == m_End); } /** * Go to the beginning. */ template void RCC8VertexIterator ::GoToBegin(void) { boost::tie(m_Iter, m_End) = boost::vertices(*(m_Graph->GetGraph())); } /** * Increment. */ template typename RCC8VertexIterator ::Self& RCC8VertexIterator ::operator++ () { ++m_Iter; return *this; } /** * Decrement. */ template typename RCC8VertexIterator ::Self& RCC8VertexIterator ::operator-- () { --m_Iter; return *this; } /** * Add */ template typename RCC8VertexIterator ::Self& RCC8VertexIterator ::operator + (int i) { m_Iter = m_Iter + i; return *this; } /** * Remove */ template typename RCC8VertexIterator ::Self& RCC8VertexIterator ::operator - (int i) { m_Iter = m_Iter - i; return *this; } /** * Difference comparison operator. */ template bool RCC8VertexIterator ::operator != (const Self &iter) { return (m_Iter != iter.m_Iter); } /** * Equality comparison operator. */ template bool RCC8VertexIterator ::operator == (const Self &iter) { return (m_Iter == iter.m_Iter); } /** * Instantiation operator. */ template typename RCC8VertexIterator ::Self& RCC8VertexIterator ::operator = (const Self &iter) { m_Iter = iter.m_Iter; return *this; } } // End namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexWithCompacity.h000066400000000000000000000051151301006202600251440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexWithCompacity_h #define otbRCC8VertexWithCompacity_h #include "otbRCC8VertexBase.h" namespace otb { /** \class RCC8VertexWithCompacity * \brief Class to represent a vertex in a RCC8 Graph with the compacity value of * the represented region. * * \sa RCC8Graph, RCC8Edge, RCC8VertexBase * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8VertexWithCompacity : public RCC8VertexBase { public: /** Standard class typedefs */ typedef RCC8VertexWithCompacity Self; typedef otb::RCC8VertexBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RCC8VertexWithCompacity, RCC8VertexBase); /** Input image associated typedefs*/ typedef TPath PathType; /** Precision typedef */ typedef TPrecision PrecisionType; /** char* vector attributes */ typedef typename Superclass::AttributesMapType AttributesMapType; /** Segmentation image index accessors */ itkGetMacro(Compacity, PrecisionType); itkSetMacro(Compacity, PrecisionType); /** * Set the VertexWithCompacity attributes from the attributes vector. * \param attributes The vector containing the parsed attributes. */ void SetAttributesMap(AttributesMapType attributes) ITK_OVERRIDE; /** * Get an attributes vector representing the VertexWithCompacity attributes. * \return The attributes vector */ AttributesMapType GetAttributesMap(void) ITK_OVERRIDE; protected: /** Constructor */ RCC8VertexWithCompacity(); /** Desctructor */ ~RCC8VertexWithCompacity() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** The compacity */ PrecisionType m_Compacity; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8VertexWithCompacity.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexWithCompacity.txx000066400000000000000000000040271301006202600255410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexWithCompacity_txx #define otbRCC8VertexWithCompacity_txx #include "otbRCC8VertexWithCompacity.h" namespace otb { /** * Constructor */ template RCC8VertexWithCompacity ::RCC8VertexWithCompacity() { m_Compacity = 0.0; } /** * Set the VertexWithCompacity attributes from the attributes vector. * \param attributes The vector containing the parsed attributes. */ template void RCC8VertexWithCompacity ::SetAttributesMap(AttributesMapType attributes) { this->Superclass::SetAttributesMap(attributes); m_Compacity = static_cast(atof(attributes["Compacity"].c_str())); } /** * Get an attributes vector representing the VertexBase attributes. * \return The attributes vector */ template typename RCC8VertexWithCompacity::AttributesMapType RCC8VertexWithCompacity ::GetAttributesMap(void) { std::stringstream oss; AttributesMapType results; results = this->Superclass::GetAttributesMap(); oss << m_Compacity; results["Compacity"] = oss.str(); oss.str(""); return results; } /** * PrintSelf method */ template void RCC8VertexWithCompacity ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Compacity: " << m_Compacity << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexWithRegionCenter.h000066400000000000000000000053221301006202600256000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexWithRegionCenter_h #define otbRCC8VertexWithRegionCenter_h #include "otbRCC8VertexBase.h" namespace otb { /** \class RCC8VertexWithRegionCenter * \brief Class to represent a vertex in a RCC8 Graph with the compacity value of * the represented region. * * \sa RCC8Graph, RCC8Edge, RCC8VertexBase * * \ingroup OTBRCC8 */ template class ITK_EXPORT RCC8VertexWithRegionCenter : public RCC8VertexBase { public: /** Standard class typedefs */ typedef RCC8VertexWithRegionCenter Self; typedef otb::RCC8VertexBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(RCC8VertexWithRegionCenter, RCC8VertexBase); /** Input image associated typedefs*/ typedef TLabel LabelType; /** Precision typedef */ typedef TPrecision PrecisionType; /** char* vector attributes */ typedef typename Superclass::AttributesMapType AttributesMapType; itkGetMacro(RegionCenterXCoordinate, PrecisionType); itkSetMacro(RegionCenterXCoordinate, PrecisionType); itkGetMacro(RegionCenterYCoordinate, PrecisionType); itkSetMacro(RegionCenterYCoordinate, PrecisionType); /** * Set the VertexWithRegionCenter attributes from the attributes vector. * \param attributes The vector containing the parsed attributes. */ void SetAttributesMap(AttributesMapType attributes); /** * Get an attributes vector representing the VertexWithRegionCenter attributes. * \return The attributes vector */ AttributesMapType GetAttributesMap(void); protected: /** Constructor */ RCC8VertexWithRegionCenter(); /** Desctructor */ ~RCC8VertexWithRegionCenter() {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const; private: /** The compacity */ PrecisionType m_RegionCenterXCoordinate; PrecisionType m_RegionCenterYCoordinate; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRCC8VertexWithRegionCenter.txx" #endif #endif OTB-release-5.8/Modules/OBIA/RCC8/include/otbRCC8VertexWithRegionCenter.txx000066400000000000000000000047551301006202600262050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRCC8VertexWithRegionCenter_txx #define otbRCC8VertexWithRegionCenter_txx #include "otbRCC8VertexWithRegionCenter.h" namespace otb { /** * Constructor */ template RCC8VertexWithRegionCenter ::RCC8VertexWithRegionCenter() { m_RegionCenterXCoordinate = 0.0; m_RegionCenterYCoordinate = 0.0; } /** * Set the VertexWithRegionCenter attributes from the attributes vector. * \param attributes The vector containing the parsed attributes. */ template void RCC8VertexWithRegionCenter ::SetAttributesMap(AttributesMapType attributes) { this->Superclass::SetAttributesMap(attributes); m_RegionCenterXCoordinate = static_cast(atof(attributes["RegionCenterXCoordinate"].c_str())); m_RegionCenterYCoordinate = static_cast(atof(attributes["RegionCenterYCoordinate"].c_str())); } /** * Get an attributes vector representing the VertexBase attributes. * \return The attributes vector */ template typename RCC8VertexWithRegionCenter::AttributesMapType RCC8VertexWithRegionCenter ::GetAttributesMap(void) { std::stringstream oss; AttributesMapType results; results = this->Superclass::GetAttributesMap(); oss << m_RegionCenterXCoordinate; results["RegionCenterXCoordinate"] = oss.str(); oss.str(""); oss << m_RegionCenterYCoordinate; results["RegionCenterYCoordinate"] = oss.str(); oss.str(""); return results; } /** * PrintSelf method */ template void RCC8VertexWithRegionCenter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "RegionCenterXCoordinate: " << m_RegionCenterXCoordinate << std::endl; os << indent << "RegionCenterXCoordinate: " << m_RegionCenterYCoordinate << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/OBIA/RCC8/otb-module.cmake000066400000000000000000000012171301006202600213110ustar00rootroot00000000000000set(DOCUMENTATION "The region connection calculus (RCC) is used for qualitative spatial representation and . RCC abstractly describes regions by their possible relations to each other (8 basic relations are possible between two regions). The RCC8 constraint language has been popularly adopted by the GIS communities. This module provides classes related to this purpose.") otb_module(OTBRCC8 DEPENDS OTBITK OTBImageBase OTBRoadExtraction OTBImageManipulation OTBPath OTBCommon OTBBoostAdapters OTBObjectList TEST_DEPENDS OTBVectorDataBase OTBTestKernel OTBImageIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/OBIA/RCC8/src/000077500000000000000000000000001301006202600170265ustar00rootroot00000000000000OTB-release-5.8/Modules/OBIA/RCC8/src/CMakeLists.txt000066400000000000000000000003741301006202600215720ustar00rootroot00000000000000set(OTBRCC8_SRC otbRCC8Edge.cxx ) add_library(OTBRCC8 ${OTBRCC8_SRC}) target_link_libraries(OTBRCC8 ${OTBImageManipulation_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBBoost_LIBRARIES} ) otb_module_target(OTBRCC8) OTB-release-5.8/Modules/OBIA/RCC8/src/otbRCC8Edge.cxx000066400000000000000000000016051301006202600215450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8Edge.h" namespace otb { /** * Constructor */ RCC8Edge::RCC8Edge() { m_Value = OTB_RCC8_DC; } /** * PrintSelf method */ void RCC8Edge::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "RCC8 Value: " << m_Value << std::endl; } } // end namespace otb OTB-release-5.8/Modules/OBIA/RCC8/test/000077500000000000000000000000001301006202600172165ustar00rootroot00000000000000OTB-release-5.8/Modules/OBIA/RCC8/test/CMakeLists.txt000066400000000000000000000136731301006202600217700ustar00rootroot00000000000000otb_module_test() set(OTBRCC8Tests otbRCC8TestDriver.cxx otbRCC8GraphNew.cxx otbRCC8GraphFileReader.cxx otbRCC8GraphIOEndToEnd.cxx otbPolygonListToRCC8GraphFilter.cxx otbRCC8VertexBase.cxx otbRCC8GraphFileReaderNew.cxx otbRCC8VertexWithCompacityNew.cxx otbImageMultiSegmentationToRCC8GraphFilterNew.cxx otbRCC8GraphFileWriterNew.cxx otbPolygonToPolygonRCC8Calculator.cxx otbImageListToRCC8GraphFilterNew.cxx otbImageToImageRCC8Calculator.cxx otbRCC8Edge.cxx otbPolygonListToRCC8GraphFilterNew.cxx otbRCC8VertexWithCompacity.cxx otbRCC8EdgeNew.cxx otbPolygonToPolygonRCC8CalculatorNew.cxx otbRCC8VertexBaseNew.cxx otbRCC8Graph.cxx otbRCC8GraphSourceNew.cxx otbRCC8GraphFileWriter.cxx otbImageMultiSegmentationToRCC8GraphFilter.cxx otbImageToImageRCC8CalculatorNew.cxx ) add_executable(otbRCC8TestDriver ${OTBRCC8Tests}) target_link_libraries(otbRCC8TestDriver ${OTBRCC8-Test_LIBRARIES}) otb_module_target_label(otbRCC8TestDriver) # Tests Declaration otb_add_test(NAME srTuRCC8GraphNew COMMAND otbRCC8TestDriver otbRCC8GraphNew) otb_add_test(NAME srTvRCC8GraphFileReader COMMAND otbRCC8TestDriver otbRCC8GraphFileReader ${TEMP}/srRCC8GraphWriterOutput1.dot ) set_property(TEST srTvRCC8GraphFileReader PROPERTY DEPENDS srTvRCC8GraphFileWriter) otb_add_test(NAME srTvRCC8GraphIOEndToEnd COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8GraphWriterOutput1.dot ${TEMP}/srRCC8GraphIOEndToEndOut.dot otbRCC8GraphIOEndToEnd ${BASELINE_FILES}/srRCC8GraphWriterOutput1.dot ${TEMP}/srRCC8GraphIOEndToEndOut.dot ) otb_add_test(NAME srTvPolygonListToRCC8GraphFilter COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srTvPolygonListToRCC8GraphFilterOutput.dot ${TEMP}/srTvPolygonListToRCC8GraphFilterOutput.dot otbPolygonListToRCC8GraphFilter ${TEMP}/srTvPolygonListToRCC8GraphFilterOutput.dot) otb_add_test(NAME srTvRCC8VertexBase COMMAND otbRCC8TestDriver otbRCC8VertexBase 5 5 ) otb_add_test(NAME srTuRCC8GraphFileReaderNew COMMAND otbRCC8TestDriver otbRCC8GraphFileReaderNew) otb_add_test(NAME srTuRCC8VertexWithCompacityNew COMMAND otbRCC8TestDriver otbRCC8VertexWithCompacityNew) otb_add_test(NAME srTuMultiSegToRCC8GraphFilterNew COMMAND otbRCC8TestDriver otbImageMultiSegmentationToRCC8GraphFilterNew) otb_add_test(NAME srTuRCC8GraphFileWriterNew COMMAND otbRCC8TestDriver otbRCC8GraphFileWriterNew) otb_add_test(NAME srTvPolygonRCC8Calculator COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8PolygonToPolygonCalculatorOutput.txt ${TEMP}/srRCC8PolygonToPolygonCalculatorOutput.txt otbPolygonToPolygonRCC8Calculator 4 ${TEMP}/srRCC8PolygonToPolygonCalculatorOutput.txt ${INPUTDATA}/rcc8_mire1.png ${INPUTDATA}/rcc8_mire2.png ${INPUTDATA}/rcc8_mire3.png ${INPUTDATA}/rcc8_mire4.png ) otb_add_test(NAME srTuImageListToRCC8GraphFilterNew COMMAND otbRCC8TestDriver otbImageListToRCC8GraphFilterNew) otb_add_test(NAME srTvRCC8Calculator COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8CalculatorOutput.txt ${TEMP}/srRCC8CalculatorOutput.txt otbImageToImageRCC8Calculator 4 ${TEMP}/srRCC8CalculatorOutput.txt ${INPUTDATA}/rcc8_mire1.png ${INPUTDATA}/rcc8_mire2.png ${INPUTDATA}/rcc8_mire3.png ${INPUTDATA}/rcc8_mire4.png ) otb_add_test(NAME srTvRCC8Edge COMMAND otbRCC8TestDriver otbRCC8Edge ) otb_add_test(NAME srTuPolygonListToRCC8GraphFilterNew COMMAND otbRCC8TestDriver otbPolygonListToRCC8GraphFilterNew) otb_add_test(NAME srTvRCC8VertexWithCompacity COMMAND otbRCC8TestDriver otbRCC8VertexWithCompacity 5 5 0.125354 ) otb_add_test(NAME srTuRCC8EdgeNew COMMAND otbRCC8TestDriver otbRCC8EdgeNew) otb_add_test(NAME srTuPolygonRCC8CalculatorNew COMMAND otbRCC8TestDriver otbPolygonToPolygonRCC8CalculatorNew) otb_add_test(NAME srTuRCC8VertexBaseNew COMMAND otbRCC8TestDriver otbRCC8VertexBaseNew) otb_add_test(NAME srTvRCC8Graph COMMAND otbRCC8TestDriver otbRCC8Graph ) otb_add_test(NAME srTuRCC8GraphSourceNew COMMAND otbRCC8TestDriver otbRCC8GraphSourceNew) otb_add_test(NAME srTvRCC8GraphFileWriter COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8GraphWriterOutput1.dot ${TEMP}/srRCC8GraphWriterOutput1.dot otbRCC8GraphFileWriter ${TEMP}/srRCC8GraphWriterOutput1.dot ) otb_add_test(NAME srTvMultiSegToRCC8GraphFilter1 COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8GraphFilterOutput.dot ${TEMP}/srRCC8GraphFilterOutput.dot otbImageMultiSegmentationToRCC8GraphFilter ${TEMP}/srRCC8GraphFilterOutput.dot 0 2 ${INPUTDATA}/Seg1InputForRCC8Graph.tif ${INPUTDATA}/Seg2InputForRCC8Graph.tif ) otb_add_test(NAME srTvMultiSegToRCC8GraphFilter2 COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8GraphFilterOutput2.dot ${TEMP}/srRCC8GraphFilterOutput2.dot otbImageMultiSegmentationToRCC8GraphFilter ${TEMP}/srRCC8GraphFilterOutput2.dot 0 3 ${INPUTDATA}/Seg3InputForRCC8Graph.tif ${INPUTDATA}/Seg4InputForRCC8Graph.tif ${INPUTDATA}/Seg5InputForRCC8Graph.tif ) otb_add_test(NAME srTvMultiSegToRCC8GraphFilter2WithOpti COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8GraphFilterOutput2.dot ${TEMP}/srRCC8GraphFilterOutput2WithOpti.dot otbImageMultiSegmentationToRCC8GraphFilter ${TEMP}/srRCC8GraphFilterOutput2WithOpti.dot 1 3 ${INPUTDATA}/Seg3InputForRCC8Graph.tif ${INPUTDATA}/Seg4InputForRCC8Graph.tif ${INPUTDATA}/Seg5InputForRCC8Graph.tif ) otb_add_test(NAME srTvMultiSegToRCC8GraphFilter1WithOpti COMMAND otbRCC8TestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/srRCC8GraphFilterOutput.dot ${TEMP}/srRCC8GraphFilterOutputWithOpti.dot otbImageMultiSegmentationToRCC8GraphFilter ${TEMP}/srRCC8GraphFilterOutputWithOpti.dot 1 2 ${INPUTDATA}/Seg1InputForRCC8Graph.tif ${INPUTDATA}/Seg2InputForRCC8Graph.tif ) otb_add_test(NAME srTuRCC8CalculatorNew COMMAND otbRCC8TestDriver otbImageToImageRCC8CalculatorNew) OTB-release-5.8/Modules/OBIA/RCC8/test/otbImageListToRCC8GraphFilterNew.cxx000066400000000000000000000026231301006202600260550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8Graph.h" #include "otbRCC8VertexBase.h" #include "otbImageListToRCC8GraphFilter.h" #include "otbPolygon.h" int otbImageListToRCC8GraphFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned short LabelPixelType; typedef otb::Polygon<> PathType; typedef otb::Image LabelImageType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::ImageListToRCC8GraphFilter ImageListToRCC8GraphFilterType; // Instantiation ImageListToRCC8GraphFilterType::Pointer filter = ImageListToRCC8GraphFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbImageMultiSegmentationToRCC8GraphFilter.cxx000066400000000000000000000045651301006202600301470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageList.h" #include "otbPolygon.h" #include "otbRCC8VertexBase.h" #include "otbImageMultiSegmentationToRCC8GraphFilter.h" #include "otbImageFileReader.h" #include "otbRCC8GraphFileWriter.h" int otbImageMultiSegmentationToRCC8GraphFilter(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; char * outputFilename = argv[1]; int useOptimisation = atoi(argv[2]); unsigned int nbImages = atoi(argv[3]); // typedefs typedef unsigned short LabelPixelType; typedef otb::Image LabelImageType; typedef otb::Polygon<> PolygonType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::ImageMultiSegmentationToRCC8GraphFilter RCC8GraphFilterType; typedef otb::ImageList ImageListType; typedef otb::ImageFileReader ReaderType; typedef otb::RCC8GraphFileWriter GraphWriterType; ImageListType::Pointer inputList = ImageListType::New(); // Reading input images for (unsigned int i = 0; i < nbImages; ++i) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[4 + i]); reader->Update(); inputList->PushBack(reader->GetOutput()); } std::cout << "Input image loaded into images list." << std::endl; // Instantiation RCC8GraphFilterType::Pointer filter = RCC8GraphFilterType::New(); filter->SetInput(inputList); filter->SetOptimisation(useOptimisation > 0); // Writing output graph GraphWriterType::Pointer writer = GraphWriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbImageMultiSegmentationToRCC8GraphFilterNew.cxx000066400000000000000000000026341301006202600306140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8Graph.h" #include "otbRCC8VertexBase.h" #include "otbPolygon.h" #include "otbImageMultiSegmentationToRCC8GraphFilter.h" int otbImageMultiSegmentationToRCC8GraphFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned short LabelPixelType; typedef otb::Polygon<> PolygonType; typedef otb::Image LabelImageType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::ImageMultiSegmentationToRCC8GraphFilter RCC8GraphFilterType; // Instantiation RCC8GraphFilterType::Pointer filter = RCC8GraphFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbImageToImageRCC8Calculator.cxx000066400000000000000000000070341301006202600253750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToImageRCC8Calculator.h" #include "otbImageList.h" #include "otbImageFileReader.h" int otbImageToImageRCC8Calculator(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; int nbImages = atoi(argv[1]); char * outfile = argv[2]; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageToImageRCC8Calculator CalculatorType; typedef otb::ImageList ImageListType; typedef ImageListType::Iterator IteratorType; // reference image list ImageListType::Pointer images = ImageListType::New(); // Reading input images std::ofstream out; out.open(outfile, std::ios::out); out << "Test results from otbImageToImageRCC8calculator test." << std::endl; for (int k = 1; k <= nbImages; ++k) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[2 + k]); reader->Update(); images->PushBack(reader->GetOutput()); } // Declaration CalculatorType::Pointer calc, calc1, calc2; // Computing relations for each images couple int i = 1; int j = 1; for (IteratorType it1 = images->Begin(); it1 != images->End(); ++it1) { for (IteratorType it2 = images->Begin(); it2 != images->End(); ++it2) { std::cout << "Test: computing relation " << i << "," << j << std::endl; calc = CalculatorType::New(); calc->SetInput1(it1.Get()); calc->SetInput2(it2.Get()); calc->Update(); out << calc->GetValue() << "\t"; if (calc->GetValue() < 3 || calc->GetValue() == 4 || calc->GetValue() == 6) { calc1 = CalculatorType::New(); calc1->SetInput1(it1.Get()); calc1->SetInput2(it2.Get()); calc1->SetLevel1APrioriKnowledge(true); calc1->Update(); if (calc1->GetValue() != calc->GetValue()) { std::cout << "Test failed: Result with level1AprioriKnowledge "; std::cout << "different from result without a priori knowledge" << std::endl; std::cout << calc->GetValue() << "!=" << calc1->GetValue() << std::endl; return EXIT_FAILURE; } } if (calc->GetValue() < 4) { calc2 = CalculatorType::New(); calc2->SetInput1(it1.Get()); calc2->SetInput2(it2.Get()); calc2->SetLevel3APrioriKnowledge(true); calc2->Update(); if (calc2->GetValue() != calc->GetValue()) { std::cout << "Test failed: Result with level3AprioriKnowledge "; std::cout << "different from result without a priori knowledge" << std::endl; std::cout << calc->GetValue() << "!=" << calc1->GetValue() << std::endl; return EXIT_FAILURE; } } ++j; } j = 1; ++i; out << std::endl; } out.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbImageToImageRCC8CalculatorNew.cxx000066400000000000000000000020411301006202600260400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToImageRCC8Calculator.h" int otbImageToImageRCC8CalculatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // const unsigned int Dimension = 2; // typedef unsigned char PixelType; // typedef otb::Image ImageType; // typedef otb::ImageToImageRCC8Calculator CalculatorType; // //Instantiation // CalculatorType::Pointer calc = CalculatorType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbPolygonListToRCC8GraphFilter.cxx000066400000000000000000000063451301006202600260150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPolygon.h" #include "otbObjectList.h" #include "otbRCC8VertexBase.h" #include "otbPolygonListToRCC8GraphFilter.h" #include "otbRCC8GraphFileWriter.h" // typedefs typedef otb::Polygon<> PolygonType; typedef otb::ObjectList PolygonListType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::PolygonListToRCC8GraphFilter RCC8GraphFilterType; typedef otb::RCC8GraphFileWriter GraphWriterType; PolygonType::VertexType Vertex(double i,double j) { PolygonType::VertexType vertex; vertex[0] = i; vertex[1] = j; return vertex; } int otbPolygonListToRCC8GraphFilter(int itkNotUsed(argc), char* argv[]) { char * outfile = argv[1]; PolygonListType::Pointer regions = PolygonListType::New(); RCC8GraphFilterType::SegmentationRangesType ranges; ranges.push_back(0); PolygonType::Pointer polygon = PolygonType::New(); polygon->AddVertex(Vertex(0,0)); polygon->AddVertex(Vertex(2,0)); polygon->AddVertex(Vertex(2,6)); polygon->AddVertex(Vertex(0,6)); regions->PushBack(polygon); polygon = PolygonType::New(); polygon->AddVertex(Vertex(1,1)); polygon->AddVertex(Vertex(4,1)); polygon->AddVertex(Vertex(4,5)); polygon->AddVertex(Vertex(1,5)); regions->PushBack(polygon); ranges.push_back(2); polygon = PolygonType::New(); polygon->AddVertex(Vertex(3,1)); polygon->AddVertex(Vertex(4,1)); polygon->AddVertex(Vertex(4,2)); polygon->AddVertex(Vertex(3,2)); regions->PushBack(polygon); polygon = PolygonType::New(); polygon->AddVertex(Vertex(5,1)); polygon->AddVertex(Vertex(8,1)); polygon->AddVertex(Vertex(8,5)); polygon->AddVertex(Vertex(5,5)); regions->PushBack(polygon); ranges.push_back(4); polygon = PolygonType::New(); polygon->AddVertex(Vertex(6,2)); polygon->AddVertex(Vertex(7,2)); polygon->AddVertex(Vertex(7,3)); polygon->AddVertex(Vertex(6,3)); regions->PushBack(polygon); polygon = PolygonType::New(); polygon->AddVertex(Vertex(8,1)); polygon->AddVertex(Vertex(9,1)); polygon->AddVertex(Vertex(9,5)); polygon->AddVertex(Vertex(8,5)); regions->PushBack(polygon); // Filter instantiation RCC8GraphFilterType::Pointer filter = RCC8GraphFilterType::New(); filter->SetInput(regions); filter->SetSegmentationRanges(ranges); GraphWriterType::Pointer writer = GraphWriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfile); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbPolygonListToRCC8GraphFilterNew.cxx000066400000000000000000000024561301006202600264660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8Graph.h" #include "otbPolygon.h" #include "otbObjectList.h" #include "otbRCC8VertexBase.h" #include "otbPolygonListToRCC8GraphFilter.h" int otbPolygonListToRCC8GraphFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // typedefs typedef otb::Polygon<> PolygonType; typedef otb::ObjectList PolygonListType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::PolygonListToRCC8GraphFilter RCC8GraphFilterType; // Instantiation RCC8GraphFilterType::Pointer filter = RCC8GraphFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbPolygonToPolygonRCC8Calculator.cxx000066400000000000000000000121141301006202600264020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPolygonToPolygonRCC8Calculator.h" #include "otbImageFileReader.h" #include "otbPolygon.h" #include "otbImageToEdgePathFilter.h" #include "otbSimplifyPathListFilter.h" int otbPolygonToPolygonRCC8Calculator(int itkNotUsed(argc), char* argv[]) { const unsigned int Dimension = 2; int nbImages = atoi(argv[1]); char * outfile = argv[2]; typedef unsigned char PixelType; typedef otb::Polygon<> PolygonType; typedef otb::Image ImageType; typedef otb::ImageToEdgePathFilter EdgeExtractionFilterType; typedef otb::SimplifyPathListFilter SimplifyPathFilterType; typedef SimplifyPathFilterType::InputListType PathListType; typedef otb::ImageFileReader ReaderType; typedef otb::PolygonToPolygonRCC8Calculator CalculatorType; PolygonType::Pointer path = PolygonType::New(); PolygonType::ContinuousIndexType a1, a2, a3, a4, a5, a6, a7; a1[0] = 0; a1[1] = 0; a2[0] = 10; a2[1] = 0; a3[0] = 10; a3[1] = 10; a4[0] = 10; a4[1] = 0; a5[0] = 5; a5[1] = 5; a6[0] = 5; a6[1] = 0; a7[0] = 100; a7[1] = 100; path->AddVertex(a1); path->AddVertex(a2); path->AddVertex(a3); path->AddVertex(a4); CalculatorType::Pointer calc = CalculatorType::New(); typedef PathListType::Iterator IteratorType; // reference image list PathListType::Pointer regions = PathListType::New(); // Reading input images std::ofstream out; out.open(outfile, std::ios::out); out << "Test results from otbPolygonToPolygonRCC8calculator test." << std::endl; for (int cpt = 1; cpt <= nbImages; ++cpt) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[2 + cpt]); EdgeExtractionFilterType::Pointer extraction = EdgeExtractionFilterType::New(); extraction->SetInput(reader->GetOutput()); extraction->SetForegroundValue(255); extraction->Update(); regions->PushBack(extraction->GetOutput()); } SimplifyPathFilterType::Pointer simplifier = SimplifyPathFilterType::New(); simplifier->SetInput(regions); simplifier->GetFunctor().SetTolerance(0.1); simplifier->Update(); // Declaration CalculatorType::Pointer calc1, calc2, calc3; // Computing relations for each images couple unsigned int i = 1; unsigned int j = 1; for (IteratorType it1 = simplifier->GetOutput()->Begin(); it1 != simplifier->GetOutput()->End(); ++it1) { for (IteratorType it2 = simplifier->GetOutput()->Begin(); it2 != simplifier->GetOutput()->End(); ++it2) { std::cout << "Test: computing relation " << i << "," << j << std::endl; calc1 = CalculatorType::New(); calc1->SetPolygon1(it1.Get()); calc1->SetPolygon2(it2.Get()); calc1->Compute(); out << calc1->GetValue() << "\t"; std::cout << "Result without a priori knowledge " << calc1->GetValue() << std::endl; if (calc1->GetValue() < 3 || calc1->GetValue() == 4 || calc1->GetValue() == 6) { calc2 = CalculatorType::New(); calc2->SetPolygon1(it1.Get()); calc2->SetPolygon2(it2.Get()); calc2->SetLevel1APrioriKnowledge(true); calc2->Compute(); std::cout << "Result with level1 a priori knowledge " << calc2->GetValue() << std::endl; if (calc2->GetValue() != calc1->GetValue()) { std::cout << "Test failed: Result with level1AprioriKnowledge "; std::cout << "different from result without a priori knowledge" << std::endl; std::cout << calc1->GetValue() << "!=" << calc2->GetValue() << std::endl; return EXIT_FAILURE; } } if (calc1->GetValue() < 4) { calc3 = CalculatorType::New(); calc3->SetPolygon1(it1.Get()); calc3->SetPolygon2(it2.Get()); calc3->SetLevel3APrioriKnowledge(true); calc3->Compute(); std::cout << "Result with level3 a priori knowledge " << calc3->GetValue() << std::endl; if (calc3->GetValue() != calc1->GetValue()) { std::cout << "Test failed: Result with level3AprioriKnowledge "; std::cout << "different from result without a priori knowledge" << std::endl; std::cout << calc1->GetValue() << "!=" << calc3->GetValue() << std::endl; return EXIT_FAILURE; } } ++j; } j = 1; ++i; out << std::endl; } out.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbPolygonToPolygonRCC8CalculatorNew.cxx000066400000000000000000000020141301006202600270520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbPolygonToPolygonRCC8Calculator.h" #include "otbPolygon.h" int otbPolygonToPolygonRCC8CalculatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PolygonType; typedef otb::PolygonToPolygonRCC8Calculator CalculatorType; //Instantiation CalculatorType::Pointer calc = CalculatorType::New(); std::cout << calc << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8Edge.cxx000066400000000000000000000021301301006202600217270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8Edge.h" #include int otbRCC8Edge(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::RCC8Edge RCC8EdgeType; typedef RCC8EdgeType::RCC8ValueType RCC8ValueType; RCC8ValueType value = otb::OTB_RCC8_DC; // Instantiation RCC8EdgeType::Pointer edge = RCC8EdgeType::New(); edge->SetValue(value); if (edge->GetValue() != value) { std::cout << "Test failed: edge->GetValue()!=value" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8EdgeNew.cxx000066400000000000000000000015521301006202600224100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8Edge.h" #include int otbRCC8EdgeNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::RCC8Edge RCC8EdgeType; // Instantiation RCC8EdgeType::Pointer rcc8 = RCC8EdgeType::New(); std::cout << rcc8 << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8Graph.cxx000066400000000000000000000160741301006202600221400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8VertexBase.h" #include "otbRCC8VertexIterator.h" #include "otbRCC8EdgeIterator.h" #include "otbRCC8InEdgeIterator.h" #include "otbRCC8OutEdgeIterator.h" #include "otbMacro.h" #include "otbPolygon.h" int otbRCC8Graph(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int nbVertices = 2; typedef otb::Polygon<> PathType; typedef PathType::VertexType PointType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::RCC8VertexIterator VertexIteratorType; typedef otb::RCC8EdgeIterator EdgeIteratorType; // Instantiation RCC8GraphType::Pointer rcc8Graph = RCC8GraphType::New(); // Setting the number of vertices rcc8Graph->SetNumberOfVertices(nbVertices - 1); // Call to the build method rcc8Graph->Build(); PointType p1, p2, p3, p4, p5, p6; p1[0] = 0; p1[1] = 0; p2[0] = 10; p2[1] = 10; p3[0] = 10; p3[1] = 0; p4[0] = 20; p4[1] = 20; p5[0] = 20; p5[1] = 10; p6[0] = 10; p6[1] = 20; unsigned int vertex1SegLevel = 0; unsigned int vertex2SegLevel = 10; bool vertex1SegType = true; bool vertex2SegType = false; PathType::Pointer path1 = PathType::New(); path1->AddVertex(p1); path1->AddVertex(p2); path1->AddVertex(p3); VertexType::Pointer vertex1 = VertexType::New(); vertex1->SetSegmentationLevel(vertex1SegLevel); vertex1->SetSegmentationType(vertex1SegType); vertex1->SetPath(path1); PathType::Pointer path2 = PathType::New(); path2->AddVertex(p4); path2->AddVertex(p5); path2->AddVertex(p6); VertexType::Pointer vertex2 = VertexType::New(); vertex2->SetSegmentationLevel(vertex2SegLevel); vertex2->SetSegmentationType(vertex2SegType); vertex2->SetPath(path2); rcc8Graph->SetVertex(0, vertex1); rcc8Graph->SetVertex(1, vertex2); otbControlConditionTestMacro(rcc8Graph->GetNumberOfVertices() != nbVertices, "rcc8Graph->GetNumberOfVertices()!=nbVertices"); otbControlConditionTestMacro(rcc8Graph->GetVertex(0)->GetSegmentationLevel() != vertex1SegLevel, "rcc8Graph->GetVertex(0)->GetSegmentationLevel()!=vertex1SegLevel"); otbControlConditionTestMacro(rcc8Graph->GetVertex(0)->GetSegmentationType() != vertex1SegType, "rcc8Graph->GetVertex(0)->GetSegmentationType()!=vertex1SegType"); otbControlConditionTestMacro(rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(0) != p1, "rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(0)!=p1"); otbControlConditionTestMacro(rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(1) != p2, "rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(1)!=p2"); otbControlConditionTestMacro(rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(2) != p3, "rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(2)!=p3"); otbControlConditionTestMacro(rcc8Graph->GetVertex(1)->GetSegmentationLevel() != vertex2SegLevel, "rcc8Graph->GetVertex(1)->GetSegmentationLevel()!=vertex2SegLevel"); otbControlConditionTestMacro(rcc8Graph->GetVertex(1)->GetSegmentationType() != vertex2SegType, "rcc8Graph->GetVertex(1)->GetObjectLabelInImgage()!=vertex2SegType"); otbControlConditionTestMacro(rcc8Graph->GetVertex(1)->GetPath()->GetVertexList()->GetElement(0) != p4, "rcc8Graph->GetVertex(1)->GetPath()->GetVertexList()->GetElement(0)!=p4"); otbControlConditionTestMacro(rcc8Graph->GetVertex(1)->GetPath()->GetVertexList()->GetElement(1) != p5, "rcc8Graph->GetVertex(1)->GetPath()->GetVertexList()->GetElement(1)!=p5"); otbControlConditionTestMacro(rcc8Graph->GetVertex(1)->GetPath()->GetVertexList()->GetElement(2) != p6, "rcc8Graph->GetVertex(1)->GetPath()->GetVertexList()->GetElement(2)!=p6"); VertexIteratorType v(rcc8Graph); v.GoToBegin(); otbControlConditionTestMacro(v.Get()->GetSegmentationLevel() != vertex1SegLevel, "v.Get()->GetSegmentationLevel()!=vertex1SegLevel"); otbControlConditionTestMacro(v.Get()->GetSegmentationType() != vertex1SegType, "v.Get()->GetSegmentationType()!=vertex1SegType"); otbControlConditionTestMacro(v.Get()->GetPath()->GetVertexList()->GetElement(0) != p1, "v.Get()->GetPath()->GetVertexList()->GetElement(0)!=p1"); otbControlConditionTestMacro(v.Get()->GetPath()->GetVertexList()->GetElement(1) != p2, "v.Get()->GetPath()->GetVertexList()->GetElement(1)!=p2"); otbControlConditionTestMacro(v.Get()->GetPath()->GetVertexList()->GetElement(2) != p3, "v.Get()->GetPath()->GetVertexList()->GetElement(2)!=p3"); ++v; otbControlConditionTestMacro(v.Get()->GetSegmentationLevel() != vertex2SegLevel, "v.Get()->GetSegmentationLevel()!=vertex2SegLevel"); otbControlConditionTestMacro(v.Get()->GetSegmentationType() != vertex2SegType, "v.Get()->GetObjectLabelInImgage()!=vertex2SegType"); otbControlConditionTestMacro(v.Get()->GetPath()->GetVertexList()->GetElement(0) != p4, "rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(0)!=p4"); otbControlConditionTestMacro(v.Get()->GetPath()->GetVertexList()->GetElement(1) != p5, "rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(1)!=p5"); otbControlConditionTestMacro(v.Get()->GetPath()->GetVertexList()->GetElement(2) != p6, "rcc8Graph->GetVertex(0)->GetPath()->GetVertexList()->GetElement(2)!=p6"); // Testing the edge iterator rcc8Graph->AddEdge(0, 1, otb::OTB_RCC8_NTPPI); otbControlConditionTestMacro(rcc8Graph->GetNumberOfEdges() != 1, "rcc8Graph->GetNumberOfEdges()!=1"); EdgeIteratorType e(rcc8Graph); e.GoToBegin(); otbControlConditionTestMacro(e.GetValue() != otb::OTB_RCC8_NTPPI, "e.GetValue()!=otb::OTB_RCC8_NTPPI"); otbControlConditionTestMacro(e.GetSourceIndex() != 0, "e.GetSourceIndex()!=0"); otbControlConditionTestMacro(e.GetTargetIndex() != 1, "e.GetTargetIndex()!=1"); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8GraphFileReader.cxx000066400000000000000000000112641301006202600240570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8VertexIterator.h" #include "otbRCC8EdgeIterator.h" #include "otbRCC8VertexBase.h" #include "otbRCC8GraphFileReader.h" #include "otbMacro.h" #include "otbPolygon.h" int otbRCC8GraphFileReader(int itkNotUsed(argc), char* argv[]) { char * inputFilename = argv[1]; typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::RCC8GraphFileReader RCC8GraphFileReaderType; typedef otb::RCC8VertexIterator VertexIteratorType; typedef otb::RCC8EdgeIterator EdgeIteratorType; // Instantiation RCC8GraphFileReaderType::Pointer rcc8GraphReader = RCC8GraphFileReaderType::New(); rcc8GraphReader->SetFileName(inputFilename); rcc8GraphReader->Update(); // Getting the output graph RCC8GraphType::Pointer graph = rcc8GraphReader->GetOutput(); // Checking vertices VertexIteratorType vIt(graph); unsigned int count = 0; otbControlConditionTestMacro(graph->GetNumberOfVertices() != 4, "graph->GetNumberOfVertices()!=4"); otbControlConditionTestMacro(graph->GetNumberOfEdges() != 6, "graph->GetNumberOfEdges()!=6"); // Checking edges EdgeIteratorType eIt(graph); count = 0; for (eIt.GoToBegin(); !eIt.IsAtEnd(); ++eIt, ++count) { switch (count) { case 0: otbControlConditionTestMacro(eIt.GetValue() != otb::OTB_RCC8_EC, "eIt.GetValue()!=otb::OTB_RCC8_EC"); otbControlConditionTestMacro(eIt.GetSourceIndex() != 0, "eIt.GetSourceIndex()!=0"); otbControlConditionTestMacro(eIt.GetTargetIndex() != 1, "eIt.GetTargetIndex()!=1"); break; case 1: otbControlConditionTestMacro(eIt.GetValue() != otb::OTB_RCC8_PO, "eIt.GetValue()!=otb::OTB_RCC8_PO"); otbControlConditionTestMacro(eIt.GetSourceIndex() != 1, "eIt.GetSourceIndex()!=1"); otbControlConditionTestMacro(eIt.GetTargetIndex() != 2, "eIt.GetTargetIndex()!=2"); break; case 2: otbControlConditionTestMacro(eIt.GetValue() != otb::OTB_RCC8_TPP, "eIt.GetValue()!=otb::OTB_RCC8_TPP"); otbControlConditionTestMacro(eIt.GetSourceIndex() != 2, "eIt.GetSourceIndex()!=2"); otbControlConditionTestMacro(eIt.GetTargetIndex() != 3, "eIt.GetTargetIndex()!=3"); break; case 3: otbControlConditionTestMacro(eIt.GetValue() != otb::OTB_RCC8_TPPI, "eIt.GetValue()!=otb::OTB_RCC8_TPPI"); otbControlConditionTestMacro(eIt.GetSourceIndex() != 0, "eIt.GetSourceIndex()!=0"); otbControlConditionTestMacro(eIt.GetTargetIndex() != 2, "eIt.GetTargetIndex()!=2"); break; case 4: otbControlConditionTestMacro(eIt.GetValue() != otb::OTB_RCC8_NTPP, "eIt.GetValue()!=otb::OTB_RCC8_NTPP"); otbControlConditionTestMacro(eIt.GetSourceIndex() != 1, "eIt.GetSourceIndex()!=1"); otbControlConditionTestMacro(eIt.GetTargetIndex() != 3, "eIt.GetTargetIndex()!=3"); break; case 5: otbControlConditionTestMacro(eIt.GetValue() != otb::OTB_RCC8_NTPPI, "eIt.GetValue()!=otb::OTB_RCC8_NTPPI"); otbControlConditionTestMacro(eIt.GetSourceIndex() != 0, "eIt.GetSourceIndex()!=0"); otbControlConditionTestMacro(eIt.GetTargetIndex() != 3, "eIt.GetTargetIndex()!=3"); break; default: otbControlConditionTestMacro(true, "Error in graph reading."); break; } } return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8GraphFileReaderNew.cxx000066400000000000000000000022651301006202600245320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8Graph.h" #include "otbRCC8VertexBase.h" #include "otbRCC8GraphFileReader.h" #include "otbPolygon.h" int otbRCC8GraphFileReaderNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::RCC8GraphFileReader RCC8GraphFileReaderType; // Instantiation RCC8GraphFileReaderType::Pointer rcc8GraphReader = RCC8GraphFileReaderType::New(); std::cout << rcc8GraphReader << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8GraphFileWriter.cxx000066400000000000000000000052421301006202600241300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8VertexBase.h" #include "otbRCC8GraphFileWriter.h" #include "otbPolygon.h" int otbRCC8GraphFileWriter(int itkNotUsed(argc), char* argv[]) { const char * outputFile = argv[1]; typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::RCC8GraphFileWriter RCC8GraphFileWriterType; // Graph instantiation RCC8GraphType::Pointer rcc8Graph = RCC8GraphType::New(); rcc8Graph->SetNumberOfVertices(4); rcc8Graph->Build(); // Vertex filling PathType::Pointer path = PathType::New(); path->Initialize(); PathType::ContinuousIndexType p1, p2, p3; p1[0] = 0; p1[1] = 0; p2[0] = 10; p2[1] = 10; p3[0] = -5; p3[1] = 2; path->AddVertex(p1); path->AddVertex(p2); path->AddVertex(p3); VertexType::Pointer vertex1, vertex2, vertex3, vertex4; vertex1 = VertexType::New(); vertex1->SetSegmentationLevel(0); vertex1->SetSegmentationType(0); vertex1->SetPath(path); rcc8Graph->SetVertex(0, vertex1); vertex2 = VertexType::New(); vertex2->SetSegmentationLevel(1); vertex2->SetSegmentationType(1); vertex2->SetPath(path); rcc8Graph->SetVertex(1, vertex2); vertex3 = VertexType::New(); vertex3->SetSegmentationLevel(2); vertex3->SetSegmentationType(0); vertex3->SetPath(path); rcc8Graph->SetVertex(2, vertex3); vertex4 = VertexType::New(); vertex4->SetSegmentationLevel(3); vertex4->SetSegmentationType(0); vertex4->SetPath(path); rcc8Graph->SetVertex(3, vertex4); // Edge filling rcc8Graph->AddEdge(0, 1, otb::OTB_RCC8_EC); rcc8Graph->AddEdge(1, 2, otb::OTB_RCC8_PO); rcc8Graph->AddEdge(2, 3, otb::OTB_RCC8_TPP); rcc8Graph->AddEdge(0, 2, otb::OTB_RCC8_TPPI); rcc8Graph->AddEdge(1, 3, otb::OTB_RCC8_NTPP); rcc8Graph->AddEdge(0, 3, otb::OTB_RCC8_NTPPI); // Instantiation RCC8GraphFileWriterType::Pointer rcc8GraphWriter = RCC8GraphFileWriterType::New(); rcc8GraphWriter->SetFileName(outputFile); rcc8GraphWriter->SetInput(rcc8Graph); rcc8GraphWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8GraphFileWriterNew.cxx000066400000000000000000000022331301006202600245770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8VertexBase.h" #include "otbRCC8GraphFileWriter.h" #include "otbPolygon.h" int otbRCC8GraphFileWriterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::RCC8GraphFileWriter RCC8GraphFileWriterType; // Instantiation RCC8GraphFileWriterType::Pointer rcc8GraphWriter = RCC8GraphFileWriterType::New(); std::cout << rcc8GraphWriter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8GraphIOEndToEnd.cxx000066400000000000000000000030361301006202600237430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8VertexBase.h" #include "otbRCC8GraphFileReader.h" #include "otbRCC8GraphFileWriter.h" #include "otbPolygon.h" int otbRCC8GraphIOEndToEnd(int itkNotUsed(argc), char* argv[]) { char * inputFilename = argv[1]; char * outputFilename = argv[2]; typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::RCC8GraphFileReader RCC8GraphFileReaderType; typedef otb::RCC8GraphFileWriter RCC8GraphFileWriterType; // End to end test RCC8GraphFileReaderType::Pointer rcc8GraphReader = RCC8GraphFileReaderType::New(); rcc8GraphReader->SetFileName(inputFilename); RCC8GraphFileWriterType::Pointer rcc8GraphWriter = RCC8GraphFileWriterType::New(); rcc8GraphWriter->SetInput(rcc8GraphReader->GetOutput()); rcc8GraphWriter->SetFileName(outputFilename); rcc8GraphWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8GraphNew.cxx000066400000000000000000000020241301006202600226000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8Graph.h" #include "otbRCC8VertexBase.h" #include "otbPolygon.h" int otbRCC8GraphNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; // Instantiation RCC8GraphType::Pointer rcc8Graph = RCC8GraphType::New(); std::cout << rcc8Graph << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8GraphSourceNew.cxx000066400000000000000000000022471301006202600237700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8Graph.h" #include "otbRCC8GraphSource.h" #include "otbRCC8VertexBase.h" #include "otbPolygon.h" int otbRCC8GraphSourceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase VertexType; typedef otb::RCC8Graph RCC8GraphType; typedef otb::RCC8GraphSource RCC8GraphSourceType; // Instantiation RCC8GraphSourceType::Pointer rcc8GraphSource = RCC8GraphSourceType::New(); std::cout << rcc8GraphSource << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8TestDriver.cxx000066400000000000000000000020721301006202600231630ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbRCC8GraphNew); REGISTER_TEST(otbRCC8GraphFileReader); REGISTER_TEST(otbRCC8GraphIOEndToEnd); REGISTER_TEST(otbPolygonListToRCC8GraphFilter); REGISTER_TEST(otbRCC8VertexBase); REGISTER_TEST(otbRCC8GraphFileReaderNew); REGISTER_TEST(otbRCC8VertexWithCompacityNew); REGISTER_TEST(otbImageMultiSegmentationToRCC8GraphFilterNew); REGISTER_TEST(otbRCC8GraphFileWriterNew); REGISTER_TEST(otbPolygonToPolygonRCC8Calculator); REGISTER_TEST(otbImageListToRCC8GraphFilterNew); REGISTER_TEST(otbImageToImageRCC8Calculator); REGISTER_TEST(otbRCC8Edge); REGISTER_TEST(otbPolygonListToRCC8GraphFilterNew); REGISTER_TEST(otbRCC8VertexWithCompacity); REGISTER_TEST(otbRCC8EdgeNew); REGISTER_TEST(otbPolygonToPolygonRCC8CalculatorNew); REGISTER_TEST(otbRCC8VertexBaseNew); REGISTER_TEST(otbRCC8Graph); REGISTER_TEST(otbRCC8GraphSourceNew); REGISTER_TEST(otbRCC8GraphFileWriter); REGISTER_TEST(otbImageMultiSegmentationToRCC8GraphFilter); REGISTER_TEST(otbImageToImageRCC8CalculatorNew); } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8VertexBase.cxx000066400000000000000000000114651301006202600231460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8VertexBase.h" #include "otbPolygon.h" #include "otbMacro.h" int otbRCC8VertexBase(int itkNotUsed(argc), char* argv[]) { typedef otb::Polygon<> PathType; unsigned int imageLevel = atoi(argv[1]); bool imageType = atoi(argv[2]); typedef otb::RCC8VertexBase RCC8VertexType; typedef RCC8VertexType::AttributesMapType AttributesMapType; // Instantiation RCC8VertexType::Pointer vertex1 = RCC8VertexType::New(); PathType::Pointer path = PathType::New(); path->Initialize(); PathType::ContinuousIndexType p1, p2, p3; p1[0] = 0; p1[1] = 0; p2[0] = 10; p2[1] = 10; p3[0] = -5; p3[1] = 2; path->AddVertex(p1); path->AddVertex(p2); path->AddVertex(p3); // Getters / setters tests vertex1->SetSegmentationLevel(imageLevel); vertex1->SetSegmentationType(imageType); vertex1->SetPath(path); otbControlConditionTestMacro(vertex1->GetSegmentationLevel() != imageLevel, "Test failed: vertex1->GetSegmentationLevel()!=imageLevel"); otbControlConditionTestMacro(vertex1->GetSegmentationType() != imageType, "Test failed: vertex1->GetSegmentationType()!=imageType"); otbControlConditionTestMacro(vertex1->GetPath()->GetVertexList()->GetElement(0) != p1, "Test failed:vertex1->GetPath()->GetVertexList()->GetElement(0)!=p1"); otbControlConditionTestMacro(vertex1->GetPath()->GetVertexList()->GetElement(1) != p2, "Test failed:vertex1->GetPath()->GetVertexList()->GetElement(1)!=p2"); otbControlConditionTestMacro(vertex1->GetPath()->GetVertexList()->GetElement(2) != p3, "Test failed:vertex1->GetPath()->GetVertexList()->GetElement(2)!=p3"); // attributes vector set test AttributesMapType attr1 = vertex1->GetAttributesMap(); otbControlConditionTestMacro(attr1["SegmentationLevel"].compare(std::string(argv[1])) != 0, "Test failed: vertex1->GetAttributesMap()[\"SegmentationLevel\"]!=std::string(argv[1])"); otbControlConditionTestMacro(atoi(attr1["SegmentationType"].c_str()) != static_cast(imageType), "Test failed:atoi(attr1[\"SegmentationType\"].c_str())!=imageType "); otbControlConditionTestMacro(atof(attr1["P0x"].c_str()) != p1[0], "Test failed: atof(attr1[\"P0x\"].c_str())!=p1[0]"); otbControlConditionTestMacro(atof(attr1["P0y"].c_str()) != p1[1], "Test failed: atof(attr1[\"P0y\"].c_str())!=p1[1]"); otbControlConditionTestMacro(atof(attr1["P1x"].c_str()) != p2[0], "Test failed: atof(attr1[\"P1x\"].c_str())!=p2[0]"); otbControlConditionTestMacro(atof(attr1["P1y"].c_str()) != p2[1], "Test failed: atof(attr1[\"P1y\"].c_str())!=p2[1]"); otbControlConditionTestMacro(atof(attr1["P2x"].c_str()) != p3[0], "Test failed: atof(attr1[\"P2x\"].c_str())!=p3[0]"); otbControlConditionTestMacro(atof(attr1["P2y"].c_str()) != p3[1], "Test failed: atof( attr1[\"P2y\"].c_str())!=p3[1]"); // attributes vector get test RCC8VertexType::Pointer vertex2 = RCC8VertexType::New(); vertex2->SetAttributesMap(attr1); otbControlConditionTestMacro(vertex1->GetSegmentationLevel() != vertex2->GetSegmentationLevel(), "Test failed: vertex1->GetSegmentationLevel()!=vertex2->GetSegmentationLevel()"); otbControlConditionTestMacro(vertex1->GetSegmentationType() != vertex2->GetSegmentationType(), "Test failed: vertex1->GetSegmentationType()!=vertex2->GetSegmentationType()"); otbControlConditionTestMacro(vertex2->GetPath()->GetVertexList()->GetElement(0) != p1, "Test failed:vertex2->GetPath()->GetVertexList()->GetElement(0)!=p1"); otbControlConditionTestMacro(vertex2->GetPath()->GetVertexList()->GetElement(1) != p2, "Test failed:vertex2->GetPath()->GetVertexList()->GetElement(1)!=p2"); otbControlConditionTestMacro(vertex2->GetPath()->GetVertexList()->GetElement(2) != p3, "Test failed:vertex2->GetPath()->GetVertexList()->GetElement(2)!=p3"); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8VertexBaseNew.cxx000066400000000000000000000017201301006202600236110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8VertexBase.h" #include "otbPolygon.h" int otbRCC8VertexBaseNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PathType; typedef otb::RCC8VertexBase RCC8VertexType; // Instantiation RCC8VertexType::Pointer rcc8Vertex = RCC8VertexType::New(); std::cout << rcc8Vertex << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8VertexWithCompacity.cxx000066400000000000000000000125471301006202600250620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRCC8VertexWithCompacity.h" #include "otbMacro.h" #include "otbPolygon.h" int otbRCC8VertexWithCompacity(int itkNotUsed(argc), char* argv[]) { typedef otb::Polygon<> PathType; typedef double PrecisionType; unsigned int imageLevel = atoi(argv[1]); bool imageType = atoi(argv[2]); PrecisionType compacity = atof(argv[3]); typedef otb::RCC8VertexWithCompacity RCC8VertexType; typedef RCC8VertexType::AttributesMapType AttributesMapType; // Instantiation RCC8VertexType::Pointer vertex1 = RCC8VertexType::New(); PathType::Pointer path = PathType::New(); path->Initialize(); PathType::ContinuousIndexType p1, p2, p3; p1[0] = 0; p1[1] = 0; p2[0] = 10; p2[1] = 10; p3[0] = -5; p3[1] = 2; path->AddVertex(p1); path->AddVertex(p2); path->AddVertex(p3); // Getters / setters tests vertex1->SetSegmentationLevel(imageLevel); vertex1->SetSegmentationType(imageType); vertex1->SetPath(path); vertex1->SetCompacity(compacity); otbControlConditionTestMacro(vertex1->GetSegmentationLevel() != imageLevel, "Test failed: vertex1->GetSegmentationLevel()!=imageLevel"); otbControlConditionTestMacro(vertex1->GetSegmentationType() != imageType, "Test failed: vertex1->GetSegmentationType()!=imageType"); otbControlConditionTestMacro(vertex1->GetPath()->GetVertexList()->GetElement(0) != p1, "Test failed:vertex1->GetPath()->GetVertexList()->GetElement(0)!=p1"); otbControlConditionTestMacro(vertex1->GetPath()->GetVertexList()->GetElement(1) != p2, "Test failed:vertex1->GetPath()->GetVertexList()->GetElement(1)!=p2"); otbControlConditionTestMacro(vertex1->GetPath()->GetVertexList()->GetElement(2) != p3, "Test failed:vertex1->GetPath()->GetVertexList()->GetElement(2)!=p3"); otbControlConditionTestMacro(vertex1->GetCompacity() != compacity, "Test failed: vertex1->GetSegmentationImageIndex()!=imageIndex"); // attributes vector set test AttributesMapType attr1 = vertex1->GetAttributesMap(); std::ostringstream oss; oss << p1[0]; otbControlConditionTestMacro(attr1["P0x"].compare(oss.str()) != 0, "Test failed:attr1[\"P0x\"].compare(std::string(p1[0]))!=0"); oss.str(""); oss << p1[1]; otbControlConditionTestMacro(attr1["P0y"].compare(oss.str()) != 0, "Test failed:attr1[\"P0y\"].compare(std::string(p1[1]))!=0"); oss.str(""); oss << p2[0]; otbControlConditionTestMacro(attr1["P1x"].compare(oss.str()) != 0, "Test failed:attr1[\"P1x\"].compare(std::string(p2[0]))!=0"); oss.str(""); oss << p2[1]; otbControlConditionTestMacro(attr1["P1y"].compare(oss.str()) != 0, "Test failed:attr1[\"P1y\"].compare(std::string(p2[1]))!=0"); oss.str(""); oss << p3[0]; otbControlConditionTestMacro(attr1["P2x"].compare(oss.str()) != 0, "Test failed:attr1[\"P2x\"].compare(std::string(p3[0]))!=0"); oss.str(""); oss << p3[1]; otbControlConditionTestMacro(attr1["P2y"].compare(oss.str()) != 0, "Test failed:attr1[\"P2y\"].compare(std::string(p3[1]))!=0"); otbControlConditionTestMacro(attr1["Compacity"].compare(std::string(argv[3])) != 0, "Test failed: vertex1->GetAttributesMap()[\"Compacity\"]!=std::string(argv[2])"); // attributes vector get test RCC8VertexType::Pointer vertex2 = RCC8VertexType::New(); vertex2->SetAttributesMap(attr1); otbControlConditionTestMacro(vertex1->GetSegmentationLevel() != vertex2->GetSegmentationLevel(), "Test failed: vertex1->GetSegmentationLevel()!=vertex2->GetSegmentationLevel()"); otbControlConditionTestMacro(vertex1->GetSegmentationType() != vertex2->GetSegmentationType(), "Test failed: vertex1->GetSegmentationType()!=vertex2->GetSegmentationType()"); otbControlConditionTestMacro(vertex2->GetPath()->GetVertexList()->GetElement(0) != p1, "Test failed:vertex2->GetPath()->GetVertexList()->GetElement(0)!=p1"); otbControlConditionTestMacro(vertex2->GetPath()->GetVertexList()->GetElement(1) != p2, "Test failed:vertex2->GetPath()->GetVertexList()->GetElement(1)!=p2"); otbControlConditionTestMacro(vertex2->GetPath()->GetVertexList()->GetElement(2) != p3, "Test failed:vertex2->GetPath()->GetVertexList()->GetElement(2)!=p3"); otbControlConditionTestMacro(vertex1->GetCompacity() != vertex2->GetCompacity(), "Test failed: vertex1->GetCompacity()!=vertex2->GetCompacity()"); return EXIT_SUCCESS; } OTB-release-5.8/Modules/OBIA/RCC8/test/otbRCC8VertexWithCompacityNew.cxx000066400000000000000000000021411301006202600255210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRCC8VertexWithCompacity.h" #include "otbPolygon.h" int otbRCC8VertexWithCompacityNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Polygon<> PathType; typedef float PrecisionType; typedef otb::RCC8VertexWithCompacity RCC8VertexType; // Instantiation RCC8VertexType::Pointer rcc8Vertex = RCC8VertexType::New(); std::cout << rcc8Vertex << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/000077500000000000000000000000001301006202600171455ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/000077500000000000000000000000001301006202600205235ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/CMakeLists.txt000066400000000000000000000000461301006202600232630ustar00rootroot00000000000000project(OTBIndices) otb_module_impl() OTB-release-5.8/Modules/Radiometry/Indices/include/000077500000000000000000000000001301006202600221465ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/include/otbBuiltUpIndicesFunctor.h000066400000000000000000000124141301006202600272520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBuiltUpIndicesFunctor_h #define otbBuiltUpIndicesFunctor_h #include "otbVegetationIndicesFunctor.h" namespace otb { namespace Functor { /** * \class TM4AndTM5IndexBase * \brief Base class for TM4 And TM5 channels of Land Sat * (equivalent to Red and NIR of SPOT5) * * Implement operators for UnaryFunctorImageFilter templated with a * VectorImage and BinaryFunctorImageFilter templated with single * images. * Subclasses should NOT overload operators, they must re-implement * the Evaluate() method. * * \ingroup Radiometry * * \ingroup OTBIndices */ template class TM4AndTM5IndexBase { public: /// Vector pixel type used to support both vector images and multiple /// input images typedef itk::VariableLengthVector InputVectorType; //operators != bool operator !=(const TM4AndTM5IndexBase&) const { return true; } //operator == bool operator ==(const TM4AndTM5IndexBase& other) const { return !(*this != other); } // Operator on vector pixel type inline TOutput operator ()(const InputVectorType& inputVector) const { return this->Evaluate(inputVector[m_TM4Index - 1], static_cast(inputVector[m_TM5Index - 1])); } // Binary operator inline TOutput operator ()(const TInput1& tm4, const TInput2& tm5) const { return this->Evaluate(tm4, tm5); } /// Constructor TM4AndTM5IndexBase() : m_TM4Index(4), m_TM5Index(5) {} /// Desctructor virtual ~TM4AndTM5IndexBase() {} /// Set TM4 Index void SetIndex1(unsigned int channel) { m_TM4Index = channel; } /// Get TM4 Index unsigned int GetIndex1() const { return m_TM4Index; } /// Set TM5 Index void SetIndex2(unsigned int channel) { m_TM5Index = channel; } /// Get TM5 Index unsigned int GetIndex2() const { return m_TM5Index; } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_TM4Index = channel; } if (band == BandName::NIR) { m_TM5Index = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_TM4Index; } if (band == BandName::NIR) { return m_TM5Index; } } /** Return the index name */ virtual std::string GetName() const = 0; protected: // This method must be reimplemented in subclasses to actually // compute the index value virtual TOutput Evaluate(const TInput1& tm4, const TInput2& tm5) const = 0; private: unsigned int m_TM4Index; unsigned int m_TM5Index; }; /** \class NDBI * \brief This functor computes the Normalized Difference Built Up Index (NDBI) * * [Zha 2003] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class NDBI : public TM4AndTM5IndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDBI"; } /// Constructor NDBI() {} /// Desctructor ~NDBI() ITK_OVERRIDE {} // Operator on r and nir single pixel values protected: inline TOutput Evaluate(const TInput1& pTM4, const TInput2& pTM5) const ITK_OVERRIDE { double dTM4 = static_cast(pTM4); double dTM5 = static_cast(pTM5); if (dTM5 + dTM4 == 0) { return static_cast(0.); } return (static_cast((dTM5 - dTM4) / (dTM5 + dTM4))); } }; /** \class ISU * \brief This functor computes the Index surfaces built (ISU) * * [Abdellaoui 1997 ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class ISU : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "ISU"; } /// Constructor ISU() : m_A(100.), m_B(25.) {} /// Desctructor ~ISU() ITK_OVERRIDE {} /** Set/Get A correction */ void SetA(const double pA) { m_A = pA; } double GetA(void) const { return (m_A); } /** Set/Get B correction */ void SetB(const double pB) { m_B = pB; } double GetB(void) const { return (m_B); } protected: inline TOutput Evaluate(const TInput1& pRed, const TInput2& pNIR) const ITK_OVERRIDE { double dRed = static_cast(pRed); double dNIR = static_cast(pNIR); if (dNIR == 0) { return static_cast(0.); } return (static_cast(m_A - (m_B * dRed) / (dNIR))); } private: double m_A; double m_B; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbGAndRIndexImageFilter.h000066400000000000000000000060111301006202600270560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGAndRIndexImageFilter_h #define otbGAndRIndexImageFilter_h #include "itkBinaryFunctorImageFilter.h" #include "otbSoilIndicesFunctor.h" namespace otb { /** \class GAndRIndexImageFilter * \brief TODO * * \ingroup Radiometry * * * \ingroup OTBIndices */ template > class ITK_EXPORT GAndRIndexImageFilter : public itk::BinaryFunctorImageFilter { public: /** Standard typedefs */ typedef GAndRIndexImageFilter Self; typedef itk::BinaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(GAndRIndexImageFilter, BinaryFunctorImageFilter); void SetInputG(const TInputImageG * image1); void SetInputR(const TInputImageR * image2); /** Template parameters typedefs */ typedef typename Superclass::Input1ImageType GInputImageType; typedef typename Superclass::Input1ImagePointer GInputImagePointer; typedef typename Superclass::Input2ImageType RInputImageType; typedef typename Superclass::Input2ImagePointer RInputImagePointer; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointer OutputImagePointer; typedef typename Superclass::FunctorType FunctorType; typedef typename Superclass::OutputImageRegionType OutputImageRegionType; protected: GAndRIndexImageFilter(); ~GAndRIndexImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /* void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ); */ private: GAndRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGAndRIndexImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbGAndRIndexImageFilter.txx000066400000000000000000000070141301006202600274560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGAndRIndexImageFilter_txx #define otbGAndRIndexImageFilter_txx #include "otbGAndRIndexImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template GAndRIndexImageFilter ::GAndRIndexImageFilter() { } /** * Connect one of the operands for pixel-wise addition */ template void GAndRIndexImageFilter ::SetInputG(const TInputImageG * image1) { // Process object is not const-correct so the const casting is required. this->SetInput1(image1); } /** * Connect one of the operands for pixel-wise addition */ template void GAndRIndexImageFilter ::SetInputR(const TInputImageR * image2) { // Process object is not const-correct so the const casting is required. // SetNthInput(1, const_cast( image2 )); this->SetInput2(image2); } /** * ThreadedGenerateData Performs the pixel-wise addition */ /* template void GAndRIndexImageFilter ::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, itk::ThreadIdType threadId) { // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImageG so it cannot be used for the second input. RInputImagePointer inputPtr1 = dynamic_cast(itk::ProcessObject::GetInput(0)); NIRInputImagePointer inputPtr2 = dynamic_cast(itk::ProcessObject::GetInput(1)); OutputImagePointer outputPtr = this->GetOutput(0); itk::ImageRegionConstIterator inputItR(inputPtr1, outputRegionForThread); itk::ImageRegionConstIterator inputItNIR(inputPtr2, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputItR.GoToBegin(); inputItNIR.GoToBegin(); outputIt.GoToBegin(); while( !inputItR.IsAtEnd() ) { outputIt.Set( this->GetFunctor()( inputItR.Get(), inputItNIR.Get() ) ); ++inputItNIR; ++inputItR; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } */ template void GAndRIndexImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbLandsatTMIndices.h000066400000000000000000001471701301006202600261640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLandsatTMIndices_h #define otbLandsatTMIndices_h #include "otbMath.h" #include "itkVariableLengthVector.h" #include "otbBandName.h" #include "otbFuzzyVariable.h" #include #include namespace otb { namespace Functor { namespace LandsatTM { /// Landsat 5 or 7 enum SATType {L5, L7}; /// Thermal band in Kelvin or Celsius enum DegreeType {Kelvin, HundredsKelvin, Celsius}; /// Reflectances in thousands or in (0-1) enum ReflectanceType {Thousands, Normalized}; /** * \class LandsatTMIndexBase * \brief Base class for Landsat-TM indices * * Implement operators for UnaryFunctorImageFilter templated with a * vector pixel having 8 components. The order of the components * defaults to the one of Lansat 7, but the Landsat 5 order is also * available. Any other order of bands can be manually selected. * Subclasses should overload operator(). This class assumes * that the input image is calibrated in reflectances and in * temperature. The reflectances can be given in the 0-1 range * (Normalized) or in 0-1000 (Thousands). Temperatures can be given * in Kelvin, in Kelvin*100 or in Celsius. Appropriate accessors * are available for setting these units. * * \ingroup Radiometry * * \ingroup OTBIndices */ template class LandsatTMIndexBase { public: //operators != bool operator !=(const LandsatTMIndexBase&) const { return false; } //operator == bool operator ==(const LandsatTMIndexBase& other) const { return !(*this != other); } /// Constructor LandsatTMIndexBase() : m_EpsilonToBeConsideredAsZero(0.0000001), m_TM1(0), m_TM2(1), m_TM3(2), m_TM4(3), m_TM5(4), m_TM60(5), m_TM61(5), m_TM62(6), m_TM7(7), m_SAT(L7), m_Degree(Celsius), m_Reflectance(Normalized) {} /// Desctructor virtual ~LandsatTMIndexBase() {} /** Set index, generic method */ void SetIndex(BandName::LandsatTMBandNames band, unsigned int channel) { switch( band ) { case BandName::TM1: m_TM1 = channel; break; case BandName::TM2: m_TM2 = channel; break; case BandName::TM3: m_TM3 = channel; break; case BandName::TM4: m_TM4 = channel; break; case BandName::TM5: m_TM5 = channel; break; case BandName::TM60: m_TM60 = channel; break; case BandName::TM61: m_TM61 = channel; break; case BandName::TM62: m_TM62 = channel; break; case BandName::TM7: m_TM7 = channel; break; } } /** Get index, generic method */ unsigned int GetIndex(BandName::LandsatTMBandNames band) const { switch( band ) { case BandName::TM1: return m_TM1; break; case BandName::TM2: return m_TM2; break; case BandName::TM3: return m_TM3; break; case BandName::TM4: return m_TM4; break; case BandName::TM5: return m_TM5; break; case BandName::TM60: return m_TM60; break; case BandName::TM61: return m_TM61; break; case BandName::TM62: return m_TM62; break; case BandName::TM7: return m_TM7; break; } return m_TM1; } unsigned int GetTM1() const { return this->m_TM1; } unsigned int GetTM2() const { return this->m_TM2; } unsigned int GetTM3() const { return this->m_TM3; } unsigned int GetTM4() const { return this->m_TM4; } unsigned int GetTM5() const { return this->m_TM5; } unsigned int GetTM60() const { return this->m_TM60; } unsigned int GetTM61() const { return this->m_TM61; } unsigned int GetTM62() const { return this->m_TM62; } unsigned int GetTM7() const { return this->m_TM7; } void SetSAT(SATType sat) { this->m_SAT = sat; if( sat == L5 ) { m_TM1 = 0; m_TM2 = 1; m_TM3 = 2; m_TM4 = 3; m_TM5 = 4; m_TM60 = 5; m_TM7 = 6; m_SAT = L5; } else { m_TM1 = 0; m_TM2 = 1; m_TM3 = 2; m_TM4 = 3; m_TM5 = 4; m_TM61 = 5; m_TM62 = 6; m_TM7 = 7; m_SAT = L7; } } SATType GetSAT() const { return this->m_SAT; } void SetDegree(DegreeType deg) { this->m_Degree = deg; } DegreeType GetDegre() const { return this->m_Degree; } void SetReflectance(ReflectanceType ref) { this->m_Reflectance = ref; } ReflectanceType GetReflectance() const { return this->m_Reflectance; } double GetEpsilonToBeConsideredAsZero() const { return this->m_EpsilonToBeConsideredAsZero; } protected: /// Prepare the values so they are normalized and in C TInput PrepareValues(const TInput& inputPixel) { TInput newPix( inputPixel ); if( this->m_Degree == Kelvin ) { if(this->m_SAT == L5) { newPix[this->m_TM60] = newPix[this->m_TM60]-273.15; } else { newPix[this->m_TM61] = newPix[this->m_TM61]-273.15; newPix[this->m_TM62] = newPix[this->m_TM62]-273.15; } } else if( this->m_Degree == HundredsKelvin ) { if(this->m_SAT == L5) { newPix[this->m_TM60] = newPix[this->m_TM60]/100.-273.15; } else { newPix[this->m_TM61] = newPix[this->m_TM61]/100.-273.15; newPix[this->m_TM62] = newPix[this->m_TM62]/100.-273.15; } } if( this->m_Reflectance == Thousands ) { newPix[this->m_TM1] = newPix[this->m_TM1]/1000.; newPix[this->m_TM2] = newPix[this->m_TM2]/1000.; newPix[this->m_TM3] = newPix[this->m_TM3]/1000.; newPix[this->m_TM4] = newPix[this->m_TM4]/1000.; newPix[this->m_TM5] = newPix[this->m_TM5]/1000.; newPix[this->m_TM7] = newPix[this->m_TM7]/1000.; } return newPix; } double m_EpsilonToBeConsideredAsZero; unsigned int m_TM1; unsigned int m_TM2; unsigned int m_TM3; unsigned int m_TM4; unsigned int m_TM5; unsigned int m_TM60; unsigned int m_TM61; unsigned int m_TM62; unsigned int m_TM7; SATType m_SAT; DegreeType m_Degree; ReflectanceType m_Reflectance; }; /** \class LandsatTMIndex * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class LandsatTMIndex : public LandsatTMIndexBase { public: // Operator performing the work inline TOutput operator ()(const TInput& inputPixel) const; /** Return the index name */ virtual std::string GetName() const = 0; LandsatTMIndex() {} ~LandsatTMIndex() ITK_OVERRIDE {} }; /** \class Bright * Brightness index for LandsatTM. Computes a weighted mean of the * non thermal bands as follows : * \f[ * \frac{1}{8}\left( TM1 + TM2 + 2\times TM3 + 2\times TM4 + TM5 + TM7\right) * \f] * This expression is the one used in Baraldi et al. 2006, "Automatic * Spectral Rule-Based Preliminary Mapping of Calibrated Landsat TM * and ETM+ Images", IEEE Trans. on Geoscience and Remote Sensing, * vol 44, no 9. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class Bright : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "Bright"; } Bright() {} ~Bright() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = (newPixel[this->m_TM1]+newPixel[this->m_TM2]+2*newPixel[this->m_TM3]+2*newPixel[this->m_TM4]+newPixel[this->m_TM5]+newPixel[this->m_TM7])/8.0; return static_cast(result); } }; /** \class Vis * Visible index for LandsatTM. Computes a mean of the 3 visible * bands as follows: * \f[ * \frac{1}{3}\left( TM1 + TM2 + TM3 \right)} * \f] * This expression is the one used in Baraldi et al. 2006, "Automatic * Spectral Rule-Based Preliminary Mapping of Calibrated Landsat TM * and ETM+ Images", IEEE Trans. on Geoscience and Remote Sensing, * vol 44, no 9. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class Vis : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "Vis"; } Vis() {} ~Vis() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = (newPixel[this->m_TM1]+newPixel[this->m_TM2]+newPixel[this->m_TM3])/3.0; return static_cast(result); } }; /** \class NIR * NIR index for LandsatTM. Alias for the TM4 band. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class NIR : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NIR"; } NIR() {} ~NIR() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = newPixel[this->m_TM4]; return static_cast(result); } }; /** \class MIR1 * MIR1 index for LandsatTM. Alias for the TM5 band. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class MIR1 : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "MIR1"; } MIR1() {} ~MIR1() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = newPixel[this->m_TM5]; return static_cast(result); } }; /** \class MIR2 * MIR2 index for LandsatTM. Alias for the TM7 band. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class MIR2 : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "MIR2"; } MIR2() {} ~MIR2() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = newPixel[this->m_TM7]; return static_cast(result); } }; /** \class TIR * TIR index for LandsatTM. This is TM60 for Landsat 5 and TM62 for Landsat 7. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class TIR : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "TIR"; } TIR() {} ~TIR() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = newPixel[this->m_TM62]; if( this->m_SAT == L5 ) result = newPixel[this->m_TM60]; return static_cast(result); } }; /** \class MIRTIR * * MIRTIR index for LandsatTM. * * In general, clouds tend * to be colder and feature a higher reflectance at the 1700 nm * wavelength (TM5) than cold and highly reflective barren land. To * enhance this difference, a well known TM band 5/6 composite is * specifically designed for cloud detection in : * * R. Irish, "Landsat 7 automatic cloud cover assessment (ACCA)", * Poc. of SPIE, vol 4049, pp. 348-355, 2000. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class MIRTIR : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "MIRTIR"; } MIRTIR() {} ~MIRTIR() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double tir = newPixel[this->m_TM62]; double mir1 = newPixel[this->m_TM5]; if( this->m_SAT == L5 ) tir = newPixel[this->m_TM60]; double result = 255*(1 - mir1)*(tir+100)/100.; return static_cast(result); } }; /** \class NDVI * * NDVI index for LandsatTM. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class NDVI : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDVI"; } NDVI() {} ~NDVI() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = (newPixel[this->m_TM4] - newPixel[this->m_TM3])/ (newPixel[this->m_TM4] + newPixel[this->m_TM3] + this->m_EpsilonToBeConsideredAsZero); return static_cast(result); } }; /** \class NDBSI * * Normalized Difference Bare Soil index for LandsatTM. * * \f[ * \frac{\left( TM5 - TM4 \right)}{\left( TM5 + TM4 + \epsilon \right)} * \f] * * This expression is the one used in Baraldi et al. 2006, "Automatic * Spectral Rule-Based Preliminary Mapping of Calibrated Landsat TM * and ETM+ Images", IEEE Trans. on Geoscience and Remote Sensing, * vol 44, no 9. * * NDBSI > -0.2 is a strong (necessary, but not sufficient) * indication of the presence of bare soil areas. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class NDBSI : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDBSI"; } NDBSI() {} ~NDBSI() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = (newPixel[this->m_TM5] - newPixel[this->m_TM4])/ (newPixel[this->m_TM5] + newPixel[this->m_TM4] + this->m_EpsilonToBeConsideredAsZero); return static_cast(result); } }; /** \class BIO * * Another Bare Soil index for LandsatTM. * * \f[ * \frac{\left( (TM5 + TM3) - (TM4 + TM1) \right)}{\left( (TM5 + TM3) + (TM4 + TM1) \right)} * \f] * * This expression is the one used in: Roy PS, Miyatake S and Rikimaru * A (1997) Biophysical Spectral Response Modelling Approach for * Forest Density Stratification. FCD Mapper Users Guide. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class BIO : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "BIO"; } BIO() {} ~BIO() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = ((newPixel[this->m_TM5] + newPixel[this->m_TM3]) - (newPixel[this->m_TM4] + newPixel[this->m_TM1])) /((newPixel[this->m_TM5] + newPixel[this->m_TM3]) + (newPixel[this->m_TM4] + newPixel[this->m_TM1])); return static_cast(result); } }; /** \class NDSI * * Normalized Difference Snow index for LandsatTM. * * \f[ * \frac{\left( TM2 - TM5 \right)}{\left( TM2 + TM5 + \epsilon \right)} * \f] * * This expression is the one used in R. Irish, "Landsat 7 automatic * cloud cover assessment (ACCA)", Poc. of SPIE, vol 4049, * pp. 348-355, 2000. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class NDSI : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDSI"; } NDSI() {} ~NDSI() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = (newPixel[this->m_TM2] - newPixel[this->m_TM5]) /(newPixel[this->m_TM2] + newPixel[this->m_TM5] + this->m_EpsilonToBeConsideredAsZero); return static_cast(result); } }; /** \class NDSIVis * * Baraldi's Normalized Difference Snow index for LandsatTM. * * \f[ * \frac{\left( Vis - TM5 \right)}{\left( Vis + TM5 + \epsilon \right)} * \f] * * where * * \f[ * Vis = \frac{1}{3}\left( TM1 + TM2 + TM3 \right)} * \f] * * This expression is the one used in Baraldi et al. 2006, "Automatic * Spectral Rule-Based Preliminary Mapping of Calibrated Landsat TM * and ETM+ Images", IEEE Trans. on Geoscience and Remote Sensing, * vol 44, no 9. * * and is an adaptation of the one given in R. Irish, "Landsat 7 * automatic cloud cover assessment (ACCA)", Poc. of SPIE, vol 4049, * pp. 348-355, 2000. * * NDSIVis > 0.5 is a strong (necessary, but not sufficient) * indication of the presence of snow areas. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class NDSIVis : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDSIVis"; } NDSIVis() {} ~NDSIVis() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double vis = (newPixel[this->m_TM1]+newPixel[this->m_TM2]+newPixel[this->m_TM3])/3.0; double result = (vis - newPixel[this->m_TM5])/(vis + newPixel[this->m_TM5] + this->m_EpsilonToBeConsideredAsZero); return static_cast(result); } }; /** \class NDBBBI * * Normalized Difference Blue-band component in Built-up areas and * Barren land index for LandsatTM. * * \f[ * \frac{\left( TM1 - TM5 \right)}{\left( TM1 + TM5 + \epsilon \right)} * \f] * * This expression is the one used in Baraldi et al. 2006, "Automatic * Spectral Rule-Based Preliminary Mapping of Calibrated Landsat TM * and ETM+ Images", IEEE Trans. on Geoscience and Remote Sensing, * vol 44, no 9. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class NDBBBI : public LandsatTMIndex { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDBBBI"; } NDBBBI() {} ~NDBBBI() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); double result = (newPixel[this->m_TM1] - newPixel[this->m_TM5]) /(newPixel[this->m_TM1] + newPixel[this->m_TM5] + this->m_EpsilonToBeConsideredAsZero); return static_cast(result); } }; /** \class LandsatTMLinguisticVariables * * Implementation of the linguistic labels assigned to fuzzy sets * providing a complete partition of a feature space consisting of * scalar variables representing specific Landsat TM indices as * described in Baraldi et al. 2006, "Automatic Spectral Rule-Based * Preliminary Mapping of Calibrated Landsat TM and ETM+ Images", * IEEE Trans. on Geoscience and Remote Sensing, vol 44, no 9. * * The hard coded thresholds are taken from table III of the paper. * The implementation proposed here is not at all optimal in the sense * that otb::FuzzyVariables are used where simple thresholds would be * enough. This is done like this so this class can also provide (TODO) * membership values instead of crisp ones. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class LinguisticVariables : public LandsatTMIndexBase > { public: typedef typename TInput::ValueType PrecisionType; typedef typename itk::FixedArray OutputPixelType; typedef otb::FuzzyVariable FuzzyVarType; enum LinguisticValues {MINlv=0, Low=MINlv, Medium, MAXlv=2, High=MAXlv}; enum Indices { MINid=0, bright=MINid, vis, nir, mir1, mir2, tir, mirtir, ndsivis, ndbbbi, ndvi, MAXid=10, ndbsi=MAXid }; /** Return the index name */ virtual std::string GetName() const { return "LandsatTM Linguistic Variables"; } LinguisticVariables() { m_FvBright = FuzzyVarType::New(); m_FvVis = FuzzyVarType::New(); m_FvNIR = FuzzyVarType::New(); m_FvMIR1 = FuzzyVarType::New(); m_FvMIR2 = FuzzyVarType::New(); m_FvTIR = FuzzyVarType::New(); m_FvMIRTIR = FuzzyVarType::New(); m_FvNDSIVis = FuzzyVarType::New(); m_FvNDBBBI = FuzzyVarType::New(); m_FvNDVI = FuzzyVarType::New(); m_FvNDBSI = FuzzyVarType::New(); PrecisionType maximumValue = itk::NumericTraits::max(); PrecisionType minimumValue = itk::NumericTraits::NonpositiveMin(); // the thresholds are computed wrt Baraldi's paper (normalized 0-255 values) m_FvBright->SetMembership(Low, minimumValue, minimumValue, 40/255., 40/255.); m_FvBright->SetMembership(Medium, 40/255., 40/255., 60/255., 60/255.); m_FvBright->SetMembership(High, 60/255., 60/255., maximumValue, maximumValue); m_FvVis->SetMembership(Low, minimumValue, minimumValue, 30/255., 30/255.); m_FvVis->SetMembership(Medium, 30/255., 30/255., 50/255., 50/255.); m_FvVis->SetMembership(High, 50/255., 50/255., maximumValue, maximumValue); m_FvNIR->SetMembership(Low, minimumValue, minimumValue, 40/255., 40/255.); m_FvNIR->SetMembership(Medium, 40/255., 40/255., 60/255., 60/255.); m_FvNIR->SetMembership(High, 60/255., 60/255., maximumValue, maximumValue); m_FvMIR1->SetMembership(Low, minimumValue, minimumValue, 40/255., 40/255.); m_FvMIR1->SetMembership(Medium, 40/255., 40/255., 60/255., 60/255.); m_FvMIR1->SetMembership(High, 60/255., 60/255., maximumValue, maximumValue); m_FvMIR2->SetMembership(Low, minimumValue, minimumValue, 30/255., 30/255.); m_FvMIR2->SetMembership(Medium, 30/255., 30/255., 50/255., 50/255.); m_FvMIR2->SetMembership(High, 50/255., 50/255., maximumValue, maximumValue); m_FvTIR->SetMembership(Low, minimumValue, minimumValue, 0, 0); m_FvTIR->SetMembership(Medium, 0, 0, 28, 28); m_FvTIR->SetMembership(High, 28, 28, maximumValue, maximumValue); m_FvMIRTIR->SetMembership(Low, minimumValue, minimumValue, 180, 180); m_FvMIRTIR->SetMembership(Medium, 180, 180, 220, 220); m_FvMIRTIR->SetMembership(High, 220, 220, maximumValue, maximumValue); m_FvNDSIVis->SetMembership(Low, minimumValue, minimumValue, 0, 0); m_FvNDSIVis->SetMembership(Medium, 0, 0, 0.5, 0.5); m_FvNDSIVis->SetMembership(High, 0.5, 0.5, maximumValue, maximumValue); m_FvNDBBBI ->SetMembership(Low, minimumValue, minimumValue, -0.20, -0.20); m_FvNDBBBI->SetMembership(Medium, -0.20, -0.20, 0.10, 0.10); m_FvNDBBBI->SetMembership(High, 0.10, 0.10, maximumValue, maximumValue); m_FvNDVI->SetMembership(Low, minimumValue, minimumValue, 0.35, 0.35); m_FvNDVI->SetMembership(Medium, 0.35, 0.35, 0.6, 0.6); m_FvNDVI->SetMembership(High, 0.6, 0.6, maximumValue, maximumValue); m_FvNDBSI->SetMembership(Low, minimumValue, minimumValue, -0.20, -0.20); m_FvNDBSI->SetMembership(Medium, -0.20, -0.20, 0.0, 0.0); m_FvNDBSI->SetMembership(High, 0.0, 0.0, maximumValue, maximumValue); } ~LinguisticVariables() ITK_OVERRIDE {} inline itk::FixedArray operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); itk::FixedArray result; result[ bright ] = m_FvBright->GetMaxVar(Bright()( newPixel )); result[ vis ] = m_FvVis->GetMaxVar(Vis()( newPixel )); result[ nir ] = m_FvNIR->GetMaxVar(NIR()( newPixel )); result[ mir1 ] = m_FvMIR1->GetMaxVar(MIR1()( newPixel )); MIR2 mir2F; mir2F.SetSAT( this->m_SAT ); result[ mir2 ] = m_FvMIR2->GetMaxVar(mir2F( newPixel )); TIR tirF; tirF.SetSAT( this->m_SAT ); result[ tir ] = m_FvTIR->GetMaxVar(tirF( newPixel )); MIRTIR mirtirF; mirtirF.SetSAT( this->m_SAT ); result[ mirtir ] = m_FvMIRTIR->GetMaxVar(mirtirF( newPixel )); result[ ndsivis ] = m_FvNDSIVis->GetMaxVar(NDSIVis()( newPixel )); result[ ndbbbi ] = m_FvNDBBBI->GetMaxVar(NDBBBI()( newPixel )); result[ ndvi ] = m_FvNDVI->GetMaxVar(NDVI()( newPixel )); result[ ndbsi ] = m_FvNDBSI->GetMaxVar(NDBSI()( newPixel )); return result; } protected: typename FuzzyVarType::Pointer m_FvBright; typename FuzzyVarType::Pointer m_FvVis; typename FuzzyVarType::Pointer m_FvNIR; typename FuzzyVarType::Pointer m_FvMIR1; typename FuzzyVarType::Pointer m_FvMIR2; typename FuzzyVarType::Pointer m_FvTIR; typename FuzzyVarType::Pointer m_FvMIRTIR; typename FuzzyVarType::Pointer m_FvNDSIVis; typename FuzzyVarType::Pointer m_FvNDBBBI; typename FuzzyVarType::Pointer m_FvNDVI; typename FuzzyVarType::Pointer m_FvNDBSI; }; /** \class KernelSpectralRule * * Implementation of the Kernel Spectral rules for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * This is a virtual class defining the common accessors to the 14 spectral rules * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class KernelSpectralRule : public LandsatTMIndexBase { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ virtual std::string GetName() const { return "LandsatTM KernelSpectralRule"; } KernelSpectralRule() : m_TV1(0.7), m_TV2(0.5) { } ~KernelSpectralRule() ITK_OVERRIDE {} void SetTV1(PrecisionType tv1) { this->m_TV1 = tv1; } void SetTV2(PrecisionType tv2) { this->m_TV2 = tv2; } PrecisionType GetTV1() const { return this->m_TV1; } PrecisionType GetTV2() const { return this->m_TV2; } protected: /** Tolerance value 1*/ PrecisionType m_TV1; /** Tolerance value 2*/ PrecisionType m_TV2; void SetMinMax(const TInput& inputPixel, PrecisionType* max13, PrecisionType* min123, PrecisionType* max123, PrecisionType* min12347, PrecisionType* max12347, PrecisionType* max234, PrecisionType* max45) { std::vector< PrecisionType > v13; v13.push_back(inputPixel[this->m_TM1]); v13.push_back(inputPixel[this->m_TM3]); *max13 = *(std::max_element ( v13.begin(), v13.end() )); std::vector< PrecisionType > v123; v123.push_back(inputPixel[this->m_TM1]); v123.push_back(inputPixel[this->m_TM2]); v123.push_back(inputPixel[this->m_TM3]); *max123 = *(std::max_element ( v123.begin(), v123.end() )); *min123 = *(std::min_element ( v123.begin(), v123.end() )); std::vector< PrecisionType > v12347; v12347.push_back(inputPixel[this->m_TM1]); v12347.push_back(inputPixel[this->m_TM2]); v12347.push_back(inputPixel[this->m_TM3]); v12347.push_back(inputPixel[this->m_TM4]); v12347.push_back(inputPixel[this->m_TM7]); *max12347 = *(std::max_element ( v12347.begin(), v12347.end() )); *min12347 = *(std::min_element ( v12347.begin(), v12347.end() )); std::vector< PrecisionType > v234; v234.push_back(inputPixel[this->m_TM2]); v234.push_back(inputPixel[this->m_TM3]); v234.push_back(inputPixel[this->m_TM4]); *max234 = *(std::max_element ( v234.begin(), v234.end() )); std::vector< PrecisionType > v45; v45.push_back(inputPixel[this->m_TM4]); v45.push_back(inputPixel[this->m_TM5]); *max45 = *(std::max_element ( v45.begin(), v45.end() )); } }; /** \class ThickCloudsSpectralRule * * Implementation of the ThickCloudsSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class ThickCloudsSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM ThickCloudsSpectralRule"; } ThickCloudsSpectralRule() { } ~ThickCloudsSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = ( ((min123 >= (this->m_TV1 * max123) && (max123 <= this->m_TV1 * newPixel[this->m_TM4])) || ((newPixel[this->m_TM2] >= this->m_TV1 * max13) && (max123 <= newPixel[this->m_TM4]))) && (newPixel[this->m_TM5] <= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] >= this->m_TV1 * max123) && (newPixel[this->m_TM7] <= this->m_TV1 * newPixel[this->m_TM4])); return static_cast(result); } }; /** \class ThinCloudsSpectralRule * * Implementation of the ThinCloudsSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class ThinCloudsSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM ThinCloudsSpectralRule"; } ThinCloudsSpectralRule() { } ~ThinCloudsSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (min123 >= (this->m_TV1 * max123)) && (newPixel[this->m_TM4] >= max123) && !((newPixel[this->m_TM1] <= newPixel[this->m_TM2] && newPixel[this->m_TM2] <= newPixel[this->m_TM3] && newPixel[this->m_TM3] <= newPixel[this->m_TM4]) && (newPixel[this->m_TM3] >= this->m_TV1 * newPixel[this->m_TM4])) && (newPixel[this->m_TM4] >= this->m_TV1 * newPixel[this->m_TM5]) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] >= this->m_TV1 * max123) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM7]); return static_cast(result); } }; /** \class SnowOrIceSpectralRule * * Implementation of the SnowOrIceSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class SnowOrIceSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM SnowOrIceSpectralRule"; } SnowOrIceSpectralRule() { } ~SnowOrIceSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (min123 >= (this->m_TV1 * max123)) && (newPixel[this->m_TM4] >= (this->m_TV1 * max123)) && (newPixel[this->m_TM5] <= this->m_TV2 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] <= this->m_TV1 * min123) && (newPixel[this->m_TM5] <= this->m_TV1 * max123) && (newPixel[this->m_TM7] <= this->m_TV2 * newPixel[this->m_TM4]) && (newPixel[this->m_TM7] <= this->m_TV1 * min123); return static_cast(result); } }; /** \class WaterOrShadowSpectralRule * * Implementation of the WaterOrShadowSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class WaterOrShadowSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM WaterOrShadowSpectralRule"; } WaterOrShadowSpectralRule() { } ~WaterOrShadowSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); bool result = (newPixel[this->m_TM1] >= newPixel[this->m_TM2]) && (newPixel[this->m_TM2] >= newPixel[this->m_TM3]) && (newPixel[this->m_TM3] >= newPixel[this->m_TM4]) && (newPixel[this->m_TM4] >= newPixel[this->m_TM5]) && (newPixel[this->m_TM4] >= newPixel[this->m_TM7]); return static_cast(result); } }; /** \class PitbogOrGreenhouseSpectralRule * * Implementation of the PitbogOrGreenhouseSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class PitbogOrGreenhouseSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM PitbogOrGreenhouseSpectralRule"; } PitbogOrGreenhouseSpectralRule() { } ~PitbogOrGreenhouseSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (newPixel[this->m_TM3] >= this->m_TV1 * newPixel[this->m_TM1]) && (newPixel[this->m_TM1] >= this->m_TV1 * newPixel[this->m_TM3]) && (max123 <= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] <= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM3] >= this->m_TV2 * newPixel[this->m_TM5]) && (min123 >= this->m_TV1 * newPixel[this->m_TM7]); return static_cast(result); } }; /** \class DominantBlueSpectralRule * * Implementation of the DominantBlueSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class DominantBlueSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM DominantBlueSpectralRule"; } DominantBlueSpectralRule() { } ~DominantBlueSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); bool result = (newPixel[this->m_TM1] >= this->m_TV1 * newPixel[this->m_TM2]) && (newPixel[this->m_TM1] >= this->m_TV1 * newPixel[this->m_TM3]) && (newPixel[this->m_TM1] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM1] >= this->m_TV1 * newPixel[this->m_TM5]) && (newPixel[this->m_TM1] >= this->m_TV1 * newPixel[this->m_TM7]); return static_cast(result); } }; /** \class VegetationSpectralRule * * Implementation of the VegetationSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class VegetationSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM VegetationSpectralRule"; } VegetationSpectralRule() { } ~VegetationSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (newPixel[this->m_TM2] >= this->m_TV2 * newPixel[this->m_TM1]) && (newPixel[this->m_TM2] >= this->m_TV1 * newPixel[this->m_TM3]) && (newPixel[this->m_TM3] < this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM4] > max123) && (newPixel[this->m_TM5] < this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM3]) && (newPixel[this->m_TM7] < this->m_TV1 * newPixel[this->m_TM5]); return static_cast(result); } }; /** \class RangelandSpectralRule * * Implementation of the RangelandSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class RangelandSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM RangelandSpectralRule"; } RangelandSpectralRule() { } ~RangelandSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (newPixel[this->m_TM2] >= this->m_TV2 * newPixel[this->m_TM1]) && (newPixel[this->m_TM2] >= this->m_TV1 * newPixel[this->m_TM3]) && (newPixel[this->m_TM4] > max123) && (newPixel[this->m_TM3] < this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM4] >= this->m_TV1 * newPixel[this->m_TM5]) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] > max123) && (newPixel[this->m_TM7] < this->m_TV1 * max45) && (newPixel[this->m_TM5] >= newPixel[this->m_TM7]); return static_cast(result); } }; /** \class BarrenLandOrBuiltUpOrCloudsSpectralRule * * Implementation of the BarrenLandOrBuiltUpOrCloudsSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class BarrenLandOrBuiltUpOrCloudsSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM BarrenLandOrBuiltUpOrCloudsSpectralRule"; } BarrenLandOrBuiltUpOrCloudsSpectralRule() { } ~BarrenLandOrBuiltUpOrCloudsSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (newPixel[this->m_TM3] >= this->m_TV2 * newPixel[this->m_TM1]) && (newPixel[this->m_TM3] >= this->m_TV1 * newPixel[this->m_TM2]) && (newPixel[this->m_TM4] >= this->m_TV1 * max123) && (newPixel[this->m_TM5] >= max123) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM7]) && (newPixel[this->m_TM7] >= this->m_TV2 * max45); return static_cast(result); } }; /** \class FlatResponseBarrenLandOrBuiltUpSpectralRule * * Implementation of the FlatResponseBarrenLandOrBuiltUpSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class FlatResponseBarrenLandOrBuiltUpSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM FlatResponseBarrenLandOrBuiltUpSpectralRule"; } FlatResponseBarrenLandOrBuiltUpSpectralRule() { } ~FlatResponseBarrenLandOrBuiltUpSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (newPixel[this->m_TM5] >= this->m_TV1 * max12347) && (min12347 >= this->m_TV2 * newPixel[this->m_TM5]); return static_cast(result); } }; /** \class ShadowWithBarrenLandSpectralRule * * Implementation of the ShadowWithBarrenLandSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class ShadowWithBarrenLandSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM ShadowWithBarrenLandSpectralRule"; } ShadowWithBarrenLandSpectralRule() { } ~ShadowWithBarrenLandSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); bool result = (newPixel[this->m_TM1] >= newPixel[this->m_TM2]) && (newPixel[this->m_TM2] >= newPixel[this->m_TM3]) && (newPixel[this->m_TM3] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM1] >= newPixel[this->m_TM5]) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM7]); return static_cast(result); } }; /** \class ShadowWithVegetationSpectralRule * * Implementation of the ShadowWithVegetationSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class ShadowWithVegetationSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM ShadowWithVegetationSpectralRule"; } ShadowWithVegetationSpectralRule() { } ~ShadowWithVegetationSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); bool result = (newPixel[this->m_TM1] >= newPixel[this->m_TM2]) && (newPixel[this->m_TM2] >= newPixel[this->m_TM3]) && (newPixel[this->m_TM1] >= this->m_TV2 * newPixel[this->m_TM4]) && (newPixel[this->m_TM3] < this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM5] < this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM3] >= this->m_TV2 * newPixel[this->m_TM5]) && (newPixel[this->m_TM7] < this->m_TV1 * newPixel[this->m_TM4]); return static_cast(result); } }; /** \class ShadowCloudOrSnowSpectralRule * * Implementation of the ShadowCloudOrSnowSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class ShadowCloudOrSnowSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM ShadowCloudOrSnowSpectralRule"; } ShadowCloudOrSnowSpectralRule() { } ~ShadowCloudOrSnowSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); PrecisionType max13; PrecisionType max123; PrecisionType min123; PrecisionType max12347; PrecisionType min12347; PrecisionType max234; PrecisionType max45; this->SetMinMax(newPixel, &max13, &min123, &max123, &min12347, &max12347, &max234, &max45); bool result = (newPixel[this->m_TM1] >= this->m_TV1 * max234) && (max234 >= this->m_TV1 * newPixel[this->m_TM1]) && (newPixel[this->m_TM5] < newPixel[this->m_TM1]) && (newPixel[this->m_TM7] < this->m_TV1 * newPixel[this->m_TM1]); return static_cast(result); } }; /** \class WetlandSpectralRule * * Implementation of the WetlandSpectralRule for Landsat TM image * land cover classification as described in table IV of Baraldi et * al. 2006, "Automatic Spectral Rule-Based Preliminary Mapping of * Calibrated Landsat TM and ETM+ Images", IEEE Trans. on Geoscience * and Remote Sensing, vol 44, no 9. * * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBIndices */ template class WetlandSpectralRule : public KernelSpectralRule { public: typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM WetlandSpectralRule"; } WetlandSpectralRule() { } ~WetlandSpectralRule() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { TInput newPixel(this->PrepareValues( inputPixel )); bool result = (newPixel[this->m_TM1] >= newPixel[this->m_TM2]) && (newPixel[this->m_TM2] >= newPixel[this->m_TM3]) && (newPixel[this->m_TM1] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM3] < newPixel[this->m_TM4]) && (newPixel[this->m_TM4] >= this->m_TV1 * newPixel[this->m_TM5]) && (newPixel[this->m_TM5] >= this->m_TV1 * newPixel[this->m_TM4]) && (newPixel[this->m_TM3] >= this->m_TV2 * newPixel[this->m_TM5]) && (newPixel[this->m_TM5] >= newPixel[this->m_TM7]); return static_cast(result); } }; } // namespace LandsatTM } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbMultiChannelGAndRIndexImageFilter.h000066400000000000000000000102071301006202600313640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelGAndRIndexImageFilter_h #define otbMultiChannelGAndRIndexImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "otbSoilIndicesFunctor.h" namespace otb { /** \class MultiChannelGAndRIndexImageFilter * \brief Implements multi channel G and R pixel-wise generic index operation on one vector image. * * This class is parameterized over the type of the input image and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * \sa UnaryFunctorImageFilter * \ingroup Radiometry * * \ingroup OTBIndices */ template > class ITK_EXPORT MultiChannelGAndRIndexImageFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef MultiChannelGAndRIndexImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiChannelGAndRIndexImageFilter, UnaryFunctorImageFilter); /** Some typedefs. */ typedef TFunction FunctorType; /** Set/Get the Green channel index. Value must be in [1...[ */ itkSetMacro(GreenIndex, unsigned int); itkGetMacro(GreenIndex, unsigned int); /** Set/Get the Red channel index. Value must be in [1...[ */ itkSetMacro(RedIndex, unsigned int); itkGetMacro(RedIndex, unsigned int); /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::GREEN) { m_GreenIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::GREEN) { return m_GreenIndex; } } protected: /// Constructor MultiChannelGAndRIndexImageFilter() : m_GreenIndex(1), m_RedIndex(2) {}; /// Destructor ~MultiChannelGAndRIndexImageFilter() ITK_OVERRIDE {} /// Before generating data, set functor parameters void BeforeThreadedGenerateData() ITK_OVERRIDE { unsigned int lNbChan = this->GetInput()->GetNumberOfComponentsPerPixel(); if (m_GreenIndex < 1 || m_RedIndex < 1 || m_GreenIndex > lNbChan || m_RedIndex > lNbChan) { itkExceptionMacro(<< "Channel indices must belong to range [1, ...["); } this->GetFunctor().SetGreenIndex(m_GreenIndex); this->GetFunctor().SetRedIndex(m_RedIndex); } /// PrintSelf Method void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { this->Superclass::PrintSelf(os, indent); os << indent << "Green index: " << m_GreenIndex << std::endl; os << indent << "Red index: " << m_RedIndex << std::endl; } private: MultiChannelGAndRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Green channel index */ unsigned int m_GreenIndex; /** Red channel index */ unsigned int m_RedIndex; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbMultiChannelRAndBAndNIRIndexImageFilter.h000066400000000000000000000113431301006202600323550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelRAndBAndNIRIndexImageFilter_h #define otbMultiChannelRAndBAndNIRIndexImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "otbVegetationIndicesFunctor.h" namespace otb { /** \class MultiChannelRAndBAndNIRIndexImageFilter * \brief Implements multi channel R and B and NIR pixel-wise generic index operation on one vector image. * * This class is parameterized over the type of the input image and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * \sa UnaryFunctorImageFilter * \ingroup Radiometry * * \ingroup OTBIndices */ template > class ITK_EXPORT MultiChannelRAndBAndNIRIndexImageFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef MultiChannelRAndBAndNIRIndexImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiChannelRAndBAndNIRIndexImageFilter, UnaryFunctorImageFilter); /** Some typedefs. */ typedef TFunction FunctorType; /** Set/Get the red channel index. Value must be in [1...[ */ itkSetMacro(RedIndex, unsigned int); itkGetMacro(RedIndex, unsigned int); /** Set/Get the blue channel index. Value must be in [1...[ */ itkSetMacro(BlueIndex, unsigned int); itkGetMacro(BlueIndex, unsigned int); /** Set/Get the nir channel index. Value must be in [1...[ */ itkSetMacro(NIRIndex, unsigned int); itkGetMacro(NIRIndex, unsigned int); /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::BLUE) { m_BlueIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::BLUE) { return m_BlueIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } protected: /// Constructor MultiChannelRAndBAndNIRIndexImageFilter() : m_RedIndex(3), m_BlueIndex(1), m_NIRIndex(4) {}; /// Destructor ~MultiChannelRAndBAndNIRIndexImageFilter() ITK_OVERRIDE {} /// Before generating data, set functor parameters void BeforeThreadedGenerateData() ITK_OVERRIDE { unsigned int lNbChan = this->GetInput()->GetNumberOfComponentsPerPixel(); if (m_RedIndex < 1 || m_BlueIndex < 1 || m_NIRIndex < 1 || m_RedIndex > lNbChan || m_BlueIndex > lNbChan || m_NIRIndex > lNbChan) { itkExceptionMacro(<< "Channel indices must belong to range [1, ...["); } this->GetFunctor().SetRedIndex(m_RedIndex); this->GetFunctor().SetBlueIndex(m_BlueIndex); this->GetFunctor().SetNIRIndex(m_NIRIndex); } /// PrintSelf void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { this->Superclass::PrintSelf(os, indent); os << indent << "Red index: " << m_RedIndex << std::endl; os << indent << "Blue index: " << m_BlueIndex << std::endl; os << indent << "NIR index: " << m_NIRIndex << std::endl; } private: MultiChannelRAndBAndNIRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Red channel index */ unsigned int m_RedIndex; /** Blue channel index */ unsigned int m_BlueIndex; /** NIR channel index */ unsigned int m_NIRIndex; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbMultiChannelRAndGAndNIRIndexImageFilter.h000066400000000000000000000113631301006202600323640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelRAndGAndNIRIndexImageFilter_h #define otbMultiChannelRAndGAndNIRIndexImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "otbVegetationIndicesFunctor.h" namespace otb { /** \class MultiChannelRAndGAndNIRIndexImageFilter * \brief Implements multi channel R and G and NIR pixel-wise generic index operation on one vector image. * * This class is parameterized over the type of the input image and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * \sa UnaryFunctorImageFilter * \ingroup Radiometry * * \ingroup OTBIndices */ template > class ITK_EXPORT MultiChannelRAndGAndNIRIndexImageFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef MultiChannelRAndGAndNIRIndexImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiChannelRAndGAndNIRIndexImageFilter, UnaryFunctorImageFilter); /** Some typedefs. */ typedef TFunction FunctorType; /** Set/Get the red channel index. Value must be in [1...[ */ itkSetMacro(RedIndex, unsigned int); itkGetMacro(RedIndex, unsigned int); /** Set/Get the green channel index. Value must be in [1...[ */ itkSetMacro(GreenIndex, unsigned int); itkGetMacro(GreenIndex, unsigned int); /** Set/Get the nir channel index. Value must be in [1...[ */ itkSetMacro(NIRIndex, unsigned int); itkGetMacro(NIRIndex, unsigned int); /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::GREEN) { m_GreenIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::GREEN) { return m_GreenIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } protected: /// Constructor MultiChannelRAndGAndNIRIndexImageFilter() : m_RedIndex(3), m_GreenIndex(2), m_NIRIndex(4) {}; /// Destructor ~MultiChannelRAndGAndNIRIndexImageFilter() ITK_OVERRIDE {} /// Before generating data, set functor parameters void BeforeThreadedGenerateData() ITK_OVERRIDE { unsigned int lNbChan = this->GetInput()->GetNumberOfComponentsPerPixel(); if (m_RedIndex < 1 || m_GreenIndex < 1 || m_NIRIndex < 1 || m_RedIndex > lNbChan || m_GreenIndex > lNbChan || m_NIRIndex > lNbChan) { itkExceptionMacro(<< "Channel indices must belong to range [1, ...["); } this->GetFunctor().SetRedIndex(m_RedIndex); this->GetFunctor().SetGreenIndex(m_GreenIndex); this->GetFunctor().SetNIRIndex(m_NIRIndex); } /// PrintSelf void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { this->Superclass::PrintSelf(os, indent); os << indent << "Red index: " << m_RedIndex << std::endl; os << indent << "Green index: " << m_GreenIndex << std::endl; os << indent << "NIR index: " << m_NIRIndex << std::endl; } private: MultiChannelRAndGAndNIRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Red channel index */ unsigned int m_RedIndex; /** Green channel index */ unsigned int m_GreenIndex; /** NIR channel index */ unsigned int m_NIRIndex; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbMultiChannelRAndNIRIndexImageFilter.h000066400000000000000000000102011301006202600316200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelRAndNIRIndexImageFilter_h #define otbMultiChannelRAndNIRIndexImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "otbVegetationIndicesFunctor.h" namespace otb { /** \class MultiChannelRAndNIRIndexImageFilter * \brief Implements multi channel R and NIR pixel-wise generic index operation on one vector image. * * This class is parameterized over the type of the input image and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * \sa UnaryFunctorImageFilter * \ingroup Radiometry * * \ingroup OTBIndices */ template > class ITK_EXPORT MultiChannelRAndNIRIndexImageFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef MultiChannelRAndNIRIndexImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiChannelRAndNIRIndexImageFilter, UnaryFunctorImageFilter); /** Some typedefs. */ typedef TFunction FunctorType; /** Set/Get the red channel index. Value must be in [1...[ */ itkSetMacro(RedIndex, unsigned int); itkGetMacro(RedIndex, unsigned int); /** Set/Get the nir channel index. Value must be in [1...[ */ itkSetMacro(NIRIndex, unsigned int); itkGetMacro(NIRIndex, unsigned int); /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } protected: /// Constructor MultiChannelRAndNIRIndexImageFilter() : m_RedIndex(3), m_NIRIndex(4) {}; /// Destructor ~MultiChannelRAndNIRIndexImageFilter() ITK_OVERRIDE {} /// Before generating data, set functor parameters void BeforeThreadedGenerateData() ITK_OVERRIDE { unsigned int lNbChan = this->GetInput()->GetNumberOfComponentsPerPixel(); if (m_RedIndex < 1 || m_NIRIndex < 1 || m_RedIndex > lNbChan || m_NIRIndex > lNbChan) { itkExceptionMacro(<< "Channel indices must belong to range [1, ...["); } this->GetFunctor().SetRedIndex(m_RedIndex); this->GetFunctor().SetNIRIndex(m_NIRIndex); } /// PrintSelf Method void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { this->Superclass::PrintSelf(os, indent); os << indent << "Red index: " << m_RedIndex << std::endl; os << indent << "NIR index: " << m_NIRIndex << std::endl; } private: MultiChannelRAndNIRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Red channel index */ unsigned int m_RedIndex; /** NIR channel index */ unsigned int m_NIRIndex; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbMultiChannelRadiometricImageFilter.h000066400000000000000000000117671301006202600317170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiChannelRadiometricImageFilter_h #define otbMultiChannelRadiometricImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "otbMacro.h" #include "otbBandName.h" namespace otb { /** \class MultiChannelRadiometricImageFilter * \brief Implements multi channel radiometric indices operation on one vector image. * * This class is parameterized over the type of the input image and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * \sa UnaryFunctorImageFilter * \ingroup Radiometry * * \ingroup OTBIndices */ template class ITK_EXPORT MultiChannelRadiometricImageFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef MultiChannelRadiometricImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiChannelRadiometricImageFilter, UnaryFunctorImageFilter); /** Some typedefs. */ typedef TFunction FunctorType; /** Set index, generic method */ virtual void SetIndex(BandName::BandName band, unsigned int channel) { switch (band) { case BandName::BLUE: m_BlueIndex = channel; break; case BandName::GREEN: m_GreenIndex = channel; break; case BandName::RED: m_RedIndex = channel; break; case BandName::NIR: m_NIRIndex = channel; break; case BandName::MIR: m_MIRIndex = channel; break; default: otbMsgDevMacro(<< "Band type not expected, you should probably do something about it!"); } } /** Get index, generic method */ virtual unsigned int GetIndex(BandName::BandName band) const { switch (band) { case BandName::BLUE: return m_BlueIndex; break; case BandName::GREEN: return m_GreenIndex; break; case BandName::RED: return m_RedIndex; break; case BandName::NIR: return m_NIRIndex; break; case BandName::MIR: return m_MIRIndex; break; default: otbMsgDevMacro(<< "Band type not expected, you should probably do something about it!"); } return 0; } protected: /// Constructor MultiChannelRadiometricImageFilter() : m_BlueIndex(0), m_GreenIndex(0), m_RedIndex(0), m_NIRIndex(0), m_MIRIndex(0) {}; /// Destructor virtual ~MultiChannelRadiometricImageFilter() {} /// Before generating data, set functor parameters virtual void BeforeThreadedGenerateData() { // unsigned int lNbChan = this->GetInput()->GetNumberOfComponentsPerPixel(); /* if (m_RedIndex < 1 || m_NIRIndex < 1 || m_RedIndex > lNbChan || m_NIRIndex > lNbChan) { itkExceptionMacro(<< "Channel indices must belong to range [1, ...["); }*/ this->GetFunctor().SetIndex(BandName::BLUE, m_BlueIndex); this->GetFunctor().SetIndex(BandName::GREEN, m_GreenIndex); this->GetFunctor().SetIndex(BandName::RED, m_RedIndex); this->GetFunctor().SetIndex(BandName::NIR, m_NIRIndex); this->GetFunctor().SetIndex(BandName::MIR, m_MIRIndex); } /// PrintSelf Method void PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "Blue index: " << m_BlueIndex << std::endl; os << indent << "Green index: " << m_GreenIndex << std::endl; os << indent << "Red index: " << m_RedIndex << std::endl; os << indent << "NIR index: " << m_NIRIndex << std::endl; os << indent << "MIR index: " << m_MIRIndex << std::endl; } private: MultiChannelRadiometricImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Blue channel index */ unsigned int m_BlueIndex; /** Green channel index */ unsigned int m_GreenIndex; /** Red channel index */ unsigned int m_RedIndex; /** NIR channel index */ unsigned int m_NIRIndex; /** MIR channel index */ unsigned int m_MIRIndex; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbNDVIDataNodeFeatureFunction.h000066400000000000000000000101571301006202600302120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNDVIDataNodeFeatureFunction_h #define otbNDVIDataNodeFeatureFunction_h #include "otbDataNodeImageFunction.h" #include "otbVegetationIndicesFunctor.h" #include "otbPolyLineImageConstIterator.h" namespace otb { /** \class NDVIDataNodeFeatureFunction * \brief Compute a NDVI based feature alongside a * datanode. * * This function compute a feature alongside a datanode. * The feature is (NDVI >= threshold) per cent along the * tested datanode. * * \ingroup Functions * \sa DataNodeImageFunction * \sa SpectralAngleDataNodeFeatureFunction * * \ingroup OTBIndices */ template < class TImage, class TCoordRep = double, class TPrecision = double > class ITK_EXPORT NDVIDataNodeFeatureFunction : public DataNodeImageFunction, TCoordRep, TPrecision> { public: /** Standard class typedefs. */ typedef NDVIDataNodeFeatureFunction Self; typedef DataNodeImageFunction, TCoordRep, TPrecision> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(NDVIDataNodeFeatureFunction, DataNodeImageFunction); /** Some typedefs. */ typedef typename Superclass::DataNodeType DataNodeType; typedef typename DataNodeType::LineType LineType; typedef TImage InputImageType; typedef typename InputImageType::ConstPointer InputImageConstPointer; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType ScalarRealType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::IndexValueType IndexValueType; typedef TCoordRep CoordRepType; typedef TPrecision PrecisionType; typedef PolyLineImageConstIterator ImageLineIteratorType; typedef Functor::NDVI NDVIFunctorType; typedef std::vector OutputType; OutputType Evaluate( const DataNodeType& node ) const ITK_OVERRIDE; /** Set/Get methods */ itkGetConstMacro(NDVIThreshold, PrecisionType); itkSetMacro(NDVIThreshold, PrecisionType); //TODO replace by metadata parsing unsigned int GetREDChannelIndex() const { return m_NDVIFunctor.GetRedIndex()+1; } void SetREDChannelIndex(unsigned int id) { m_NDVIFunctor.SetRedIndex(id-1); } unsigned int GetNIRChannelIndex() const { return m_NDVIFunctor.GetNIRIndex()+1; } void SetNIRChannelIndex(unsigned int id) { m_NDVIFunctor.SetNIRIndex(id-1); } protected: NDVIDataNodeFeatureFunction(); ~NDVIDataNodeFeatureFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: NDVIDataNodeFeatureFunction(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** NDVI Threshold & Functor */ PrecisionType m_NDVIThreshold; NDVIFunctorType m_NDVIFunctor; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbNDVIDataNodeFeatureFunction.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbNDVIDataNodeFeatureFunction.txx000066400000000000000000000075011301006202600306050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNDVIDataNodeFeatureFunction_txx #define otbNDVIDataNodeFeatureFunction_txx #include "otbNDVIDataNodeFeatureFunction.h" namespace otb { /** * Constructor */ template NDVIDataNodeFeatureFunction ::NDVIDataNodeFeatureFunction() { m_NDVIThreshold = 0.3; //Advised for QuickBird images this->SetREDChannelIndex(3); //for QuickBird images this->SetNIRChannelIndex(4); //for QuickBird images } /** * Standard "PrintSelf" method */ template void NDVIDataNodeFeatureFunction ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf( os, indent ); os << indent << "NDVI Threshold: " << m_NDVIThreshold << std::endl; os << indent << "RED Channel Index: " << this->GetREDChannelIndex() << std::endl; os << indent << "NIR Channel Index: " << this->GetNIRChannelIndex() << std::endl; } template typename NDVIDataNodeFeatureFunction ::OutputType NDVIDataNodeFeatureFunction ::Evaluate( const DataNodeType& node ) const { if(!((this->GetREDChannelIndex() <= this->GetInputImage()->GetNumberOfComponentsPerPixel()) && (this->GetNIRChannelIndex() <= this->GetInputImage()->GetNumberOfComponentsPerPixel()) && (this->GetREDChannelIndex() > 0) && (this->GetNIRChannelIndex() > 0))) { itkExceptionMacro(<< "Invalid RED or NIR Channel Index"); } const typename ImageLineIteratorType::PathType* path; switch (node.GetNodeType()) { case FEATURE_POINT: { itkExceptionMacro(<< "This DataNode type is not handle yet"); break; } case FEATURE_LINE: { path = node.GetLine(); break; } case FEATURE_POLYGON: { path = node.GetPolygonExteriorRing(); break; } default: { itkExceptionMacro(<< "This DataNode type is not handle yet"); break; } } ImageLineIteratorType lineIt(this->GetInputImage(), path); lineIt.GoToBegin(); double nbValidPixel=0.; double nbVisitedPixel=0.; while(!lineIt.IsAtEnd()) { if(this->IsInsideBuffer(lineIt.GetIndex())) { PixelType pixel = this->GetInputImage()->GetPixel(lineIt.GetIndex()); if(m_NDVIFunctor(pixel [this->GetREDChannelIndex() - 1], pixel [this->GetNIRChannelIndex() - 1]) >= this->GetNDVIThreshold()) { nbValidPixel += 1; } nbVisitedPixel += 1; } ++lineIt; } OutputType output; if(nbVisitedPixel == 0) { //std::cout << "nbValidPixel: " << nbValidPixel << "nbVisitedPixel" << nbVisitedPixel << std::endl; //itkExceptionMacro(<< "The DataNode and the Support Image are disjointed"); output.push_back(static_cast(0.)); } else { output.push_back(static_cast(nbValidPixel/nbVisitedPixel)); } output.push_back(static_cast(nbValidPixel)); output.push_back(static_cast(nbVisitedPixel)); return output; } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbRAndBAndNIRIndexImageFilter.h000066400000000000000000000052621301006202600300540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAndBAndNIRIndexImageFilter_h #define otbRAndBAndNIRIndexImageFilter_h #include "itkTernaryFunctorImageFilter.h" #include "otbVegetationIndicesFunctor.h" namespace otb { /** \class RAndBAndNIRIndexImageFilter * \brief TODO * * \ingroup Radiometry * * * \ingroup OTBIndices */ template > class ITK_EXPORT RAndBAndNIRIndexImageFilter : public itk::TernaryFunctorImageFilter { public: /** Standard typedefs */ typedef RAndBAndNIRIndexImageFilter Self; typedef itk::TernaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(RAndBAndNIRIndexImageFilter, TernaryFunctorImageFilter); void SetInputR(const TInputImageR * image); void SetInputB(const TInputImageB * image); void SetInputNIR(const TInputImageNIR * image); /** Template parameters typedefs */ typedef typename Superclass::Input1ImageType RInputImageType; typedef typename Superclass::Input2ImageType BInputImageType; typedef typename Superclass::Input3ImageType NIRInputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::FunctorType FunctorType; protected: RAndBAndNIRIndexImageFilter(); ~RAndBAndNIRIndexImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RAndBAndNIRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRAndBAndNIRIndexImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbRAndBAndNIRIndexImageFilter.txx000066400000000000000000000045761301006202600304570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAndBAndNIRIndexImageFilter_txx #define otbRAndBAndNIRIndexImageFilter_txx #include "otbRAndBAndNIRIndexImageFilter.h" namespace otb { /** * Constructor */ template RAndBAndNIRIndexImageFilter ::RAndBAndNIRIndexImageFilter() { } /** * Connect one of the operands for pixel-wise addition */ template void RAndBAndNIRIndexImageFilter ::SetInputR(const TInputImageR * image) { // Process object is not const-correct so the const casting is required. this->SetInput1(image); } /** * Connect one of the operands for pixel-wise addition */ template void RAndBAndNIRIndexImageFilter ::SetInputB(const TInputImageB * image) { this->SetInput2(image); } /** * Connect one of the operands for pixel-wise addition */ template void RAndBAndNIRIndexImageFilter ::SetInputNIR(const TInputImageNIR * image) { this->SetInput3(image); } template void RAndBAndNIRIndexImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbRAndGAndNIRIndexImageFilter.h000066400000000000000000000052611301006202600300600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAndGAndNIRIndexImageFilter_h #define otbRAndGAndNIRIndexImageFilter_h #include "itkTernaryFunctorImageFilter.h" #include "otbVegetationIndicesFunctor.h" namespace otb { /** \class RAndGAndNIRIndexImageFilter * \brief TODO * * \ingroup Radiometry * * * \ingroup OTBIndices */ template > class ITK_EXPORT RAndGAndNIRIndexImageFilter : public itk::TernaryFunctorImageFilter { public: /** Standard typedefs */ typedef RAndGAndNIRIndexImageFilter Self; typedef itk::TernaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(RAndGAndNIRIndexImageFilter, TernaryFunctorImageFilter); void SetInputR(const TInputImageR * image); void SetInputG(const TInputImageG * image); void SetInputNIR(const TInputImageNIR * image); /** Template parameters typedefs */ typedef typename Superclass::Input1ImageType RInputImageType; typedef typename Superclass::Input2ImageType GInputImageType; typedef typename Superclass::Input3ImageType NIRInputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::FunctorType FunctorType; protected: RAndGAndNIRIndexImageFilter(); ~RAndGAndNIRIndexImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RAndGAndNIRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRAndGAndNIRIndexImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbRAndGAndNIRIndexImageFilter.txx000066400000000000000000000045761301006202600304640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAndGAndNIRIndexImageFilter_txx #define otbRAndGAndNIRIndexImageFilter_txx #include "otbRAndGAndNIRIndexImageFilter.h" namespace otb { /** * Constructor */ template RAndGAndNIRIndexImageFilter ::RAndGAndNIRIndexImageFilter() { } /** * Connect one of the operands for pixel-wise addition */ template void RAndGAndNIRIndexImageFilter ::SetInputR(const TInputImageR * image) { // Process object is not const-correct so the const casting is required. this->SetInput1(image); } /** * Connect one of the operands for pixel-wise addition */ template void RAndGAndNIRIndexImageFilter ::SetInputG(const TInputImageG * image) { this->SetInput2(image); } /** * Connect one of the operands for pixel-wise addition */ template void RAndGAndNIRIndexImageFilter ::SetInputNIR(const TInputImageNIR * image) { this->SetInput3(image); } template void RAndGAndNIRIndexImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbRAndNIRIndexImageFilter.h000066400000000000000000000060601301006202600273240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAndNIRIndexImageFilter_h #define otbRAndNIRIndexImageFilter_h #include "itkBinaryFunctorImageFilter.h" #include "otbVegetationIndicesFunctor.h" namespace otb { /** \class RAndNIRIndexImageFilter * \brief TODO * * \ingroup Radiometry * * \ingroup OTBIndices */ template > class ITK_EXPORT RAndNIRIndexImageFilter : public itk::BinaryFunctorImageFilter { public: /** Standard typedefs */ typedef RAndNIRIndexImageFilter Self; typedef itk::BinaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(RAndNIRIndexImageFilter, BinaryFunctorImageFilter); void SetInputR(const TInputImageR * image1); void SetInputNIR(const TInputImageNIR * image2); /** Template parameters typedefs */ typedef typename Superclass::Input1ImageType RInputImageType; typedef typename Superclass::Input1ImagePointer RInputImagePointer; typedef typename Superclass::Input2ImageType NIRInputImageType; typedef typename Superclass::Input2ImagePointer NIRInputImagePointer; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointer OutputImagePointer; typedef typename Superclass::FunctorType FunctorType; typedef typename Superclass::OutputImageRegionType OutputImageRegionType; protected: RAndNIRIndexImageFilter(); ~RAndNIRIndexImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /* void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ); */ private: RAndNIRIndexImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRAndNIRIndexImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbRAndNIRIndexImageFilter.txx000066400000000000000000000070741301006202600277260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRAndNIRIndexImageFilter_txx #define otbRAndNIRIndexImageFilter_txx #include "otbRAndNIRIndexImageFilter.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { /** * Constructor */ template RAndNIRIndexImageFilter ::RAndNIRIndexImageFilter() { } /** * Connect one of the operands for pixel-wise addition */ template void RAndNIRIndexImageFilter ::SetInputR(const TInputImageR * image1) { // Process object is not const-correct so the const casting is required. this->SetInput1(image1); } /** * Connect one of the operands for pixel-wise addition */ template void RAndNIRIndexImageFilter ::SetInputNIR(const TInputImageNIR * image2) { // Process object is not const-correct so the const casting is required. // SetNthInput(1, const_cast( image2 )); this->SetInput2(image2); } /** * ThreadedGenerateData Performs the pixel-wise addition */ /* template void RAndNIRIndexImageFilter ::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, itk::ThreadIdType threadId) { // We use dynamic_cast since inputs are stored as DataObjects. The // ImageToImageFilter::GetInput(int) always returns a pointer to a // TInputImageR so it cannot be used for the second input. RInputImagePointer inputPtr1 = dynamic_cast(itk::ProcessObject::GetInput(0)); NIRInputImagePointer inputPtr2 = dynamic_cast(itk::ProcessObject::GetInput(1)); OutputImagePointer outputPtr = this->GetOutput(0); itk::ImageRegionConstIterator inputItR(inputPtr1, outputRegionForThread); itk::ImageRegionConstIterator inputItNIR(inputPtr2, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); inputItR.GoToBegin(); inputItNIR.GoToBegin(); outputIt.GoToBegin(); while( !inputItR.IsAtEnd() ) { outputIt.Set( this->GetFunctor()( inputItR.Get(), inputItNIR.Get() ) ); ++inputItNIR; ++inputItR; ++outputIt; progress.CompletedPixel(); // potential exception thrown here } } */ template void RAndNIRIndexImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbSoilIndicesFunctor.h000066400000000000000000000250301301006202600265720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSoilIndicesFunctor_h #define otbSoilIndicesFunctor_h #include "otbMath.h" #include "itkVariableLengthVector.h" #include "otbBandName.h" namespace otb { namespace Functor { /** * \class GAndRIndexBase * * \brief Base class for Green And Red channels of Spot Images * XS1 corresponds to the green channel * XS2 corresponds to the red channel * XS3 corresponds to the Nir channel * XS4 corresponds to the Mir channel (for Spot 4 & 5) * Implement operators for UnaryFunctorImageFilter templated with a * VectorImage and BinaryFunctorImageFilter templated with single * images. * Subclasses should NOT overload operators, they must re-implement * the Evaluate() method. * * \ingroup Radiometry * * \ingroup OTBIndices */ template class GAndRIndexBase { public: /// Vector pixel type used to support both vector images and multiple /// input images typedef itk::VariableLengthVector InputVectorType; //operators != bool operator !=(const GAndRIndexBase&) const { return true; } //operator == bool operator ==(const GAndRIndexBase& other) const { return !(*this != other); } // Operator on vector pixel type inline TOutput operator ()(const InputVectorType& inputVector) const { return this->Evaluate(inputVector[m_GreenIndex - 1], static_cast(inputVector[m_RedIndex - 1])); } // Binary operator inline TOutput operator ()(const TInput1& g, const TInput2& r) const { return this->Evaluate(g, r); } /// Constructor GAndRIndexBase() : m_EpsilonToBeConsideredAsZero(0.0000001), m_GreenIndex(1), m_RedIndex(2) {} /// Desctructor virtual ~GAndRIndexBase() {} /// Set Green Index void SetGreenIndex(unsigned int channel) { m_GreenIndex = channel; } /// Get Green Index unsigned int GetGreenIndex() const { return m_GreenIndex; } /// Set Red Index void SetRedIndex(unsigned int channel) { m_RedIndex = channel; } /// Get Red Index unsigned int GetRedIndex() const { return m_RedIndex; } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::GREEN) { m_GreenIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::GREEN) { return m_GreenIndex; } } /** Return the index name */ virtual std::string GetName() const = 0; protected: // This method must be reimplemented in subclasses to actually // compute the index value virtual TOutput Evaluate(const TInput1& g, const TInput2& r) const = 0; double m_EpsilonToBeConsideredAsZero; private: unsigned int m_GreenIndex; unsigned int m_RedIndex; }; /** * \class GAndRAndNirIndexBase * \brief Base class for Green And Red And NIR channels of Spot Images * * * \ingroup Radiometry * * \ingroup OTBIndices */ template class GAndRAndNirIndexBase { public: /// Vector pixel type used to support both vector images and multiple /// input images typedef itk::VariableLengthVector InputVectorType; //operators != bool operator !=(const GAndRAndNirIndexBase&) const { return true; } //operator == bool operator ==(const GAndRAndNirIndexBase& other) const { return !(*this != other); } // Operator on vector pixel type inline TOutput operator ()(const InputVectorType& inputVector) const { return this->Evaluate(static_cast(inputVector[m_GreenIndex - 1]), static_cast(inputVector[m_RedIndex - 1]), static_cast(inputVector[m_NIRIndex - 1])); } // Binary operator inline TOutput operator ()(const TInput1& g, const TInput2& r, const TInput2& nir) const { return this->Evaluate(g, r, nir); } /// Constructor GAndRAndNirIndexBase() : m_EpsilonToBeConsideredAsZero(0.0000001), m_GreenIndex(1), m_RedIndex(2), m_NIRIndex(3) {} /// Desctructor virtual ~GAndRAndNirIndexBase() {} /// Set Green Index void SetGreenIndex(unsigned int channel) { m_GreenIndex = channel; } /// Get Green Index unsigned int GetGreenIndex() const { return m_GreenIndex; } /// Set Red Index void SetRedIndex(unsigned int channel) { m_RedIndex = channel; } /// Get Red Index unsigned int GetRedIndex() const { return m_RedIndex; } /// Set Nir Index void SetNIRIndex(unsigned int channel) { m_NIRIndex = channel; } /// Get Nir Index unsigned int GetNIRIndex() const { return m_NIRIndex; } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::GREEN) { m_GreenIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::GREEN) { return m_GreenIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } /** Return the index name */ virtual std::string GetName() const = 0; protected: // This method must be reimplemented in subclasses to actually // compute the index value virtual TOutput Evaluate(const TInput1& g, const TInput2& r, const TInput2& nir) const = 0; double m_EpsilonToBeConsideredAsZero; private: unsigned int m_GreenIndex; unsigned int m_RedIndex; unsigned int m_NIRIndex; }; /** \class IR * \brief This functor computes the Redness Index (IR) * * [Pouget et al., "Caracteristiques spectrales des surfaces sableuses * de la region cotiere nord-ouest de l'Egypte: application aux donnees * satellitaires Spot, In: 2eme Journeees de Teledetection: Caracterisation * et suivi des milieux terrestres en regions arides et tropicales. 4-6/12/1990 * Ed. ORSTOM, Collection Colloques et Seminaires, Paris, pp. 27-38] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class IR : public GAndRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "IR"; } /// Constructor IR() {} /// Desctructor ~IR() ITK_OVERRIDE {} // Operator on r and nir single pixel values protected: inline TOutput Evaluate(const TInput1& pGreen, const TInput2& pRed) const ITK_OVERRIDE { double dGreen = static_cast(pGreen); double dRed = static_cast(pRed); if (vcl_abs(dGreen) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return static_cast(dRed * dRed / (dGreen * dGreen * dGreen)); } }; /** \class IC * \brief This functor computes the Color Index (IC) * * [Pouget et al., "Caracteristiques spectrales des surfaces sableuses * de la region cotiere nord-ouest de l'Egypte: application aux donnees * satellitaires Spot, In: 2eme Journeees de Teledetection: Caracterisation * et suivi des milieux terrestres en regions arides et tropicales. 4-6/12/1990 * Ed. ORSTOM, Collection Colloques et Seminaires, Paris, pp. 27-38] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class IC : public GAndRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "IC"; } /// Constructor IC() {} /// Desctructor ~IC() ITK_OVERRIDE {} // Operator on r and nir single pixel values protected: inline TOutput Evaluate(const TInput1& pGreen, const TInput2& pRed) const ITK_OVERRIDE { double dGreen = static_cast(pGreen); double dRed = static_cast(pRed); if (vcl_abs(dGreen + dRed) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast((dRed - dGreen) / (dRed + dGreen))); } }; /** \class IB * \brief This functor computes the Brilliance Index (IB) * * [ ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class IB : public GAndRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "IB"; } /// Constructor IB() {} /// Desctructor ~IB() ITK_OVERRIDE {} // Operator on r and nir single pixel values protected: inline TOutput Evaluate(const TInput1& pGreen, const TInput2& pRed) const ITK_OVERRIDE { double dGreen = static_cast(pGreen); double dRed = static_cast(pRed); return (static_cast(vcl_sqrt((dRed * dRed + dGreen * dGreen) / 2.))); } }; /** \class IB2 * \brief This functor computes the Brilliance Index (IB2) * * [ ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class IB2 : public GAndRAndNirIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "IB2"; } /// Constructor IB2() {} /// Desctructor ~IB2() ITK_OVERRIDE {} // Operator on r and nir single pixel values protected: inline TOutput Evaluate(const TInput1& pGreen, const TInput2& pRed, const TInput2& pNir) const ITK_OVERRIDE { double dGreen = static_cast(pGreen); double dRed = static_cast(pRed); double dNir = static_cast(pNir); return (static_cast(vcl_sqrt((dRed * dRed + dGreen * dGreen + dNir * dNir) / 3.))); } }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbVegetationIndicesFunctor.h000066400000000000000000001031331301006202600277720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVegetationIndicesFunctor_h #define otbVegetationIndicesFunctor_h #include "otbMath.h" #include "itkVariableLengthVector.h" #include "otbBandName.h" namespace otb { namespace Functor { /** * \class RAndNIRIndexBase * \brief Base class for R And NIR based Index * * Implement operators for UnaryFunctorImageFilter templated with a * VectorImage and BinaryFunctorImageFilter templated with single * images. * Subclasses should NOT overload operators, they must re-implement * the Evaluate() method. * * \ingroup Radiometry * * \ingroup OTBIndices */ template class RAndNIRIndexBase { public: /// Vector pixel type used to support both vector images and multiple /// input images typedef itk::VariableLengthVector InputVectorType; //operators != bool operator !=(const RAndNIRIndexBase&) const { return true; } //operator == bool operator ==(const RAndNIRIndexBase& other) const { return !(*this != other); } // Operator on vector pixel type inline TOutput operator ()(const InputVectorType& inputVector) const { return this->Evaluate(inputVector[m_RedIndex - 1], static_cast(inputVector[m_NIRIndex - 1])); } // Binary operator inline TOutput operator ()(const TInput1& r, const TInput2& nir) const { return this->Evaluate(r, nir); } /// Constructor RAndNIRIndexBase() : m_EpsilonToBeConsideredAsZero(0.0000001), m_RedIndex(3), m_NIRIndex(4) {} /// Desctructor virtual ~RAndNIRIndexBase() {} /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } /// Set Red Index void SetRedIndex(unsigned int channel) { m_RedIndex = channel; } /// Get Red Index unsigned int GetRedIndex() const { return m_RedIndex; } /// Set NIR Index void SetNIRIndex(unsigned int channel) { m_NIRIndex = channel; } /// Get NIR Index unsigned int GetNIRIndex() const { return m_NIRIndex; } /** Return the index name */ virtual std::string GetName() const = 0; protected: // This method must be reimplemented in subclasses to actually // compute the index value virtual TOutput Evaluate(const TInput1& r, const TInput2& nir) const = 0; double m_EpsilonToBeConsideredAsZero; private: unsigned int m_RedIndex; unsigned int m_NIRIndex; }; /** * \class RAndBAndNIRIndexBase * \brief base class for R, B And NIR based Index * Implement operators for UnaryFunctorImageFilter templated with a * VectorImage and BinaryFunctorImageFilter templated with single * images. * Subclasses should NOT overload operators, they must re-implement * the Evaluate() method. * \ingroup Radiometry * * \ingroup OTBIndices */ template class RAndBAndNIRIndexBase { public: /// Vector pixel type used to support both vector images and multiple /// input images typedef itk::VariableLengthVector InputVectorType; //operators != bool operator !=(const RAndBAndNIRIndexBase&) const { return true; } //operator == bool operator ==(const RAndBAndNIRIndexBase& other) const { return !(*this != other); } // Operator on vector pixel type inline TOutput operator ()(const InputVectorType& inputVector) { return this->Evaluate(inputVector[m_RedIndex - 1], static_cast(inputVector[m_BlueIndex - 1]), static_cast(inputVector[m_NIRIndex - 1])); } // Binary operator inline TOutput operator ()(const TInput1& r, const TInput2& b, const TInput2& nir) { return this->Evaluate(r, b, nir); } /// Constructor RAndBAndNIRIndexBase() : m_EpsilonToBeConsideredAsZero(0.0000001), m_RedIndex(3), m_BlueIndex(1), m_NIRIndex(4) {} /// Desctructor virtual ~RAndBAndNIRIndexBase() {} /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::BLUE) { m_BlueIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::BLUE) { return m_BlueIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } /// Set Red Index void SetRedIndex(unsigned int channel) { m_RedIndex = channel; } /// Get Red Index unsigned int GetRedIndex() const { return m_RedIndex; } /// Set Blue Index void SetBlueIndex(unsigned int channel) { m_BlueIndex = channel; } /// Get Blue Index unsigned int GetBlueIndex() const { return m_BlueIndex; } /// Set NIR Index void SetNIRIndex(unsigned int channel) { m_NIRIndex = channel; } /// Get NIR Index unsigned int GetNIRIndex() const { return m_NIRIndex; } /** Return the index name */ virtual std::string GetName() const = 0; protected: // This method must be reimplemented in subclasses to actually // compute the index value virtual TOutput Evaluate(const TInput1& r, const TInput2& b, const TInput3& nir) const = 0; double m_EpsilonToBeConsideredAsZero; private: unsigned int m_RedIndex; unsigned int m_BlueIndex; unsigned int m_NIRIndex; }; /** * \class RAndGAndNIRIndexBase * \brief base class for R, G And NIR based Index * Implement operators for UnaryFunctorImageFilter templated with a * VectorImage and BinaryFunctorImageFilter templated with single * images. * Subclasses should NOT overload operators, they must re-implement * the Evaluate() method. * \ingroup Radiometry * * \ingroup OTBIndices */ template class RAndGAndNIRIndexBase { public: /// Vector pixel type used to support both vector images and multiple /// input images typedef itk::VariableLengthVector InputVectorType; //operators != bool operator !=(const RAndGAndNIRIndexBase&) const { return true; } //operator == bool operator ==(const RAndGAndNIRIndexBase& other) const { return !(*this != other); } // Operator on vector pixel type inline TOutput operator ()(const InputVectorType& inputVector) { return this->Evaluate(inputVector[m_RedIndex - 1], static_cast(inputVector[m_GreenIndex - 1]), static_cast(inputVector[m_NIRIndex - 1])); } // Binary operator inline TOutput operator ()(const TInput1& r, const TInput2& g, const TInput2& nir) { return this->Evaluate(r, g, nir); } /// Constructor RAndGAndNIRIndexBase() : m_EpsilonToBeConsideredAsZero(0.0000001), m_RedIndex(3), m_GreenIndex(2), m_NIRIndex(4) {} /// Desctructor virtual ~RAndGAndNIRIndexBase() {} /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::GREEN) { m_GreenIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::GREEN) { return m_GreenIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } /// Set Red Index void SetRedIndex(unsigned int channel) { m_RedIndex = channel; } /// Get Red Index unsigned int GetRedIndex() const { return m_RedIndex; } /// Set Green Index void SetGreenIndex(unsigned int channel) { m_GreenIndex = channel; } /// Get Green Index unsigned int GetGreenIndex() const { return m_GreenIndex; } /// Set NIR Index void SetNIRIndex(unsigned int channel) { m_NIRIndex = channel; } /// Get NIR Index unsigned int GetNIRIndex() const { return m_NIRIndex; } /** Return the index name */ virtual std::string GetName() const = 0; protected: // This method must be reimplemented in subclasses to actually // compute the index value virtual TOutput Evaluate(const TInput1& r, const TInput2& g, const TInput3& nir) const = 0; double m_EpsilonToBeConsideredAsZero; private: unsigned int m_RedIndex; unsigned int m_GreenIndex; unsigned int m_NIRIndex; }; /** \class NDVI * \brief This functor computes the Normalized Difference Vegetation Index (NDVI) * * [Rouse et al., 1973] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class NDVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDVI"; } /// Constructor NDVI() {} /// Desctructor ~NDVI() ITK_OVERRIDE {} // Operator on r and nir single pixel values protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dr = static_cast(r); double dnir = static_cast(nir); if (vcl_abs(dnir + dr) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast((dnir - dr) / (dnir + dr))); } }; /** \class RVI * \brief This functor computes the Ratio Vegetation Index (RVI) * * [Pearson et Miller, 1972] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class RVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "RVI"; } RVI() {} ~RVI() ITK_OVERRIDE {} protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dr = static_cast(r); double dnir = static_cast(nir); if (vcl_abs(dr) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast(dnir / dr)); } }; /** \class PVI * \brief This functor computes the Perpendicular Vegetation Index (PVI) * * [Richardson et Wiegand, 1977] * * Default values for A and B are from * C. L. Wiegand, A. J. Richardson, D. E. Escobar, and A. H. Gerbermann, * "Vegetation Indices in Crop Assessments", REMOTE SENS. ENVIRON. 35:105-119 (1991) * * \ingroup Functor2 * \ingroup Radiometry * * \ingroup OTBIndices */ template class PVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "PVI"; } PVI() : m_A(0.90893), m_B(7.46216), m_Coeff(0.74) {} ~PVI() ITK_OVERRIDE {} /** Set/Get A and B parameters */ void SetA(const double A) { m_A = A; m_Coeff = 1. / (vcl_sqrt(m_A * m_A + 1.)); } double GetA(void) const { return (m_A); } void SetB(const double B) { m_B = B; } double GetB(void) const { return (m_B); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dnir = static_cast(nir); double dr = static_cast(r); return (static_cast((dnir - m_A * dr - m_B) * m_Coeff)); } private: /** A and B parameters */ double m_A; double m_B; /** Denominator, pre-calculed when the A variable is set */ double m_Coeff; }; /** \class SAVI * \brief This functor computes the Soil Adjusted Vegetation Index (SAVI) * * [Huete, 1988] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class SAVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "SAVI"; } SAVI() : m_L(0.5) {} ~SAVI() ITK_OVERRIDE {} /** Set/Get L correction */ void SetL(const double L) { m_L = L; } double GetL(void) const { return (m_L); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dnir = static_cast(nir); double dr = static_cast(r); double denominator = dnir + dr + m_L; if (vcl_abs(denominator) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast(((dnir - dr) * (1 + m_L)) / denominator)); } private: /** L correction */ double m_L; }; /** \class TSAVI * \brief This functor computes the Transformed Soil Adjusted Vegetation Index (TSAVI) * * [Baret et al. 1989, Baret et Guyot, 1991] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class TSAVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "TSAVI"; } TSAVI() : m_A(0.7), m_S(0.9), m_X(0.08) {} ~TSAVI() ITK_OVERRIDE {} /** Set/Get S and A parameters */ void SetS(const double S) { m_S = S; } double GetS(void) const { return (m_S); } void SetA(const double A) { m_A = A; } double GetA(void) const { return (m_A); } /** Set/Get X parameter */ void SetX(const double X) { m_X = X; } double GetX(void) const { return (m_X); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dnir = static_cast(nir); double dr = static_cast(r); double denominator = m_A * dnir + dr + m_X * (1. + m_A * m_A); if (vcl_abs(denominator) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast((m_A * (dnir - m_A * dr - m_S)) / denominator)); } private: /** A and S parameters */ double m_A; double m_S; /** X parameter */ double m_X; }; /** \class WDVI * \brief This functor computes the Weighted Difference Vegetation Index (WDVI) * * [Clevers, 1988] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class WDVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "WDVI"; } /// Constructor WDVI() : m_S(0.4) {} /// Desctructor ~WDVI() ITK_OVERRIDE {} // Operator on r and nir single pixel values /** Set/Get Slop of soil line */ void SetS(const double s) { m_S = s; } double GetS(void) const { return (m_S); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dr = static_cast(r); double dnir = static_cast(nir); return (dnir - m_S * dr); } private: /** Slope of soil line */ double m_S; }; /** \class MSAVI * \brief This functor computes the Modified Soil Adjusted Vegetation Index (MSAVI) * * [Qi et al., 1994] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class MSAVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "MSAVI"; } typedef NDVI NDVIFunctorType; typedef SAVI SAVIFunctorType; typedef WDVI WDVIFunctorType; MSAVI() : m_S(0.4) { m_WDVIfunctor.SetS(m_S); } ~MSAVI() ITK_OVERRIDE {} /** Set/Get Slop of soil line */ void SetS(const double s) { m_S = s; m_WDVIfunctor.SetS(m_S); } double GetS(void) const { return (m_S); } NDVIFunctorType GetNDVI(void) const { return (m_NDVIfunctor); } WDVIFunctorType GetWDVI(void) const { return (m_WDVIfunctor); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dnir = static_cast(nir); double dr = static_cast(r); double dNDVI = this->GetNDVI() (r, nir); double dWDVI = this->GetWDVI() (r, nir); double dL = 1 - 2 * m_S * dNDVI * dWDVI; double denominator = dnir + dr + dL; if (vcl_abs(denominator) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast(((dnir - dr) * (1 + dL)) / denominator)); } private: /** Slope of soil line */ double m_S; NDVIFunctorType m_NDVIfunctor; WDVIFunctorType m_WDVIfunctor; }; /** \class MSAVI2 * \brief This functor computes the Modified Soil Adjusted Vegetation Index (MSAVI2) * * [Qi et al., 1994] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class MSAVI2 : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "MSAVI2"; } MSAVI2() {} ~MSAVI2() ITK_OVERRIDE {} protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dnir = static_cast(nir); double dr = static_cast(r); double sqrt_value = (2 * dnir + 1) * (2 * dnir + 1) - 8 * (dnir - dr); if (sqrt_value < 0.) { return static_cast(0.); } return (static_cast((2 * dnir + 1 - vcl_sqrt(sqrt_value)) / 2.)); } }; /** \class GEMI * \brief This functor computes the Global Environment Monitoring Index (GEMI) * * [Pinty & Verstraete , 1992] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class GEMI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "GEMI"; } GEMI() {} ~GEMI() ITK_OVERRIDE {} protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dnir = static_cast(nir); double dr = static_cast(r); double dnu; double dnumerateur_nu; double ddenominateur_nu = dnir + dr + 0.5; if (vcl_abs(ddenominateur_nu) < this->m_EpsilonToBeConsideredAsZero) { dnu = 0; } else { dnumerateur_nu = 2 * (dnir * dnir - dr * dr) + 1.5 * dnir + 0.5 * dr; dnu = dnumerateur_nu / ddenominateur_nu; } double ddenominateur_GEMI = 1 - dr; if (vcl_abs(ddenominateur_GEMI) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast((dnu * (1 - 0.25 * dnu) - (dr - 0.125)) / ddenominateur_GEMI)); } }; /** \class AVI * \brief This functor computes the Angular Vegetation Index (AVI) * * This vegetation index use three inputs channels * * [Plummer & al., 1994] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class AVI : public RAndGAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "AVI"; } AVI() : m_LambdaG(560.), m_LambdaR(660.), m_LambdaNir(830.) {} ~AVI() ITK_OVERRIDE {} /** Set/Get Lambda red parameter*/ void SetLambdaR(const double lr) { m_LambdaR = lr; } double GetLambdaR(void) const { return (m_LambdaR); } /** Set/Get Lambda green parameter */ void SetLambdaG(const double lg) { m_LambdaG = lg; } double GetLambdaG(void) const { return (m_LambdaG); } /** Set/Get Lambda red parameter */ void SetLambdaNir(const double lnir) { m_LambdaNir = lnir; } double GetLambdaNir(void) const { return (m_LambdaNir); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& g, const TInput3& nir) const ITK_OVERRIDE { double dr = static_cast(r); double dg = static_cast(g); double dnir = static_cast(nir); double dfact1 = (m_LambdaNir - m_LambdaR) / m_LambdaR; double dfact2 = (m_LambdaR - m_LambdaG) / m_LambdaR; double dterm1; double dterm2; if (vcl_abs(dnir - dr) < this->m_EpsilonToBeConsideredAsZero) { dterm1 = 0; } else { dterm1 = vcl_atan(dfact1 / (dnir - dr)); } if (vcl_abs(dg - dr) < this->m_EpsilonToBeConsideredAsZero) { dterm2 = 0; } else { dterm2 = vcl_atan(dfact2 / (dg - dr)); } return static_cast(dterm1 + dterm2); } private: /** Central wavelength of the green channel (=Lambda1) */ double m_LambdaG; /** Central wavelength of the red channel (=Lambda2) */ double m_LambdaR; /** Central wavelength of the nir channel (=Lambda3) */ double m_LambdaNir; }; /** \class ARVI * \brief This functor computes the Atmospherically Resistant Vegetation Index (ARVI) * * This vegetation index use three inputs channels * * [Yoram J. Kaufman and Didier Tanre, 1992] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class ARVI : public RAndBAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "ARVI"; } ARVI() : m_Gamma(0.5) {} ~ARVI() ITK_OVERRIDE {} /** Set/Get Gamma parameter */ void SetGamma(const double gamma) { m_Gamma = gamma; } double GetGamma(void) const { return (m_Gamma); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& b, const TInput3& nir) const ITK_OVERRIDE { double dr = static_cast(r); double db = static_cast(b); double dnir = static_cast(nir); double RHOrb = dr - m_Gamma * (db - dr); double denominator = dnir + RHOrb; if (vcl_abs(denominator) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast((dnir - RHOrb) / denominator)); } private: /** Gamma parameter */ double m_Gamma; }; /** \class TSARVI * \brief This functor computes the Transformed Soil Atmospherical Resistant Vegetation Index (TSARVI) * * [Yoram J. Kaufman and Didier Tanre, 1992] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class TSARVI : public RAndBAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "TSARVI"; } TSARVI() : m_A(0.0), m_B(0.0), m_X(0.08), m_Gamma(0.5) {} ~TSARVI() ITK_OVERRIDE {} /** Set/Get A and B parameters */ void SetA(const double A) { m_A = A; } double GetA(void) const { return (m_A); } void SetB(const double B) { m_B = B; } double GetB(void) const { return (m_B); } /** Set/Get X parameter */ void SetX(const double X) { m_X = X; } double GetX(void) const { return (m_X); } /** Set/Get the gamma parameter */ void SetGamma(const double gamma) { m_Gamma = gamma; } double GetGamma(void) const { return (m_Gamma); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& b, const TInput3& nir) const ITK_OVERRIDE { double dr = static_cast(r); double db = static_cast(b); double dnir = static_cast(nir); double dRB = dr - m_Gamma * (db - dr); double denominator = dRB + m_A * dnir - m_A * m_B + m_X * (1. + m_A * m_A); if (vcl_abs(denominator) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return (static_cast((m_A * (dnir - m_A * dRB - m_B)) / denominator)); } private: /** A and B parameters */ double m_A; double m_B; /** X parameter */ double m_X; /** Gamma parameter */ double m_Gamma; }; /** \class EVI * \brief This functor computes the Enhanced Vegetation Index (EVI) * * This vegetation index use three inputs channels * * [Huete, Justice, & Liu, 1994; Huete, Liu, Batchily, & van Leeuwen, 1997] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class EVI : public RAndBAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "EVI"; } EVI() : m_G(2.5), m_C1(6.0), m_C2(7.5), m_L(1.0) {} ~EVI() ITK_OVERRIDE {} /** Set/Get G parameter */ void SetG(const double g) { m_G = g; } double GetG(void) const { return (m_G); } /** Set/Get C1 parameter */ void SetC1(const double c1) { m_C1 = c1; } double GetC1(void) const { return (m_C1); } /** Set/Get C2 parameter */ void SetC2(const double c2) { m_C2 = c2; } double GetC2(void) const { return (m_C2); } /** Set/Get L parameter */ void SetL(const double l) { m_L = l; } double GetL(void) const { return (m_L); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& b, const TInput3& nir) const ITK_OVERRIDE { double dr = static_cast(r); double db = static_cast(b); double dnir = static_cast(nir); double denominator = dnir + m_C1 * dr - m_C2 * db + m_L; if (vcl_abs(denominator) < this->m_EpsilonToBeConsideredAsZero) { return (static_cast(0.)); } return (static_cast(m_G * (dnir - dr) / denominator)); } private: /** Gain factor */ double m_G; /** Coefficient of the aerosol resistance term */ double m_C1; /** Coefficient of the aerosol resistance term */ double m_C2; /** Canopy background adjustment */ double m_L; }; /** \class IPVI * \brief This functor computes the Infrared Percentage Vegetation Index (IPVI) * * [Crippen, 1990] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class IPVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "IPVI"; } IPVI() {} ~IPVI() ITK_OVERRIDE {} protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dr = static_cast(r); double dnir = static_cast(nir); if (vcl_abs(dnir + dr) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } else { return (static_cast(dnir / (dnir + dr))); } } }; /** \class TNDVI * \brief This functor computes the Transformed NDVI (TNDVI) * * [Deering, 1975] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class TNDVI : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "TNDVI"; } typedef NDVI NDVIFunctorType; TNDVI() {} ~TNDVI() ITK_OVERRIDE {} NDVIFunctorType GetNDVI(void) const { return (m_NDVIfunctor); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dval = this->GetNDVI() (r, nir) + 0.5; if (dval < 0) { return (static_cast(0)); } else { return (static_cast(vcl_sqrt(dval))); } } private: NDVIFunctorType m_NDVIfunctor; }; /** \class LAIFromNDVILogarithmic * \brief computes the LAI from NDVI * * This functor computes the LAI from NDVI using a * logarithmic relationship. Asrar et al. (1984), Baret and Guyot * (1991) and Wilson and Meyers (2007). Default values for the * parameters are taken from A. Bsaibes et al. / Remote Sensing of * Environment 113 (2009) 716-729 * * * \ingroup Functor * \ingroup Radiometry * \ingroup VegetationIndices * * \ingroup OTBIndices */ template class LAIFromNDVILogarithmic : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LAIFromNDVILogarithmic"; } typedef NDVI NDVIFunctorType; LAIFromNDVILogarithmic() : m_NdviSoil(0.10), m_NdviInf(0.89), m_ExtinctionCoefficient(0.71) {} ~LAIFromNDVILogarithmic() ITK_OVERRIDE {} NDVIFunctorType GetNDVI(void) const { return (m_NDVIfunctor); } void SetNdviSoil(const double val) { m_NdviSoil = val; } double GetNdviSoil(void) const { return (m_NdviSoil); } void SetNdviInf(const double val) { m_NdviInf = val; } double GetNdviInf(void) const { return (m_NdviInf); } void SetExtinctionCoefficient(const double val) { m_ExtinctionCoefficient = val; } double GetExtinctionCoefficient(void) const { return (m_ExtinctionCoefficient); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double dval = this->GetNDVI() (r, nir); if (dval < 0) { return (static_cast(0)); } else { return (static_cast( -(1.0/m_ExtinctionCoefficient)*vcl_log((dval- m_NdviInf)/(m_NdviSoil-m_NdviInf)) )); } } private: NDVIFunctorType m_NDVIfunctor; double m_NdviSoil; double m_NdviInf; double m_ExtinctionCoefficient; }; /** \class LAIFromReflectancesLinear * \brief computes the LAI from reflectances * * This functor computes the LAI from reflectances using a * linear relationship. * \f$ LAI = \beta_0 + \sum_j \beta_j \rho_j \f$ where \f$ \rho \f$ are the * reflectances * Default values for the parameters are taken from A. Bsaibes et * al. / Remote Sensing of Environment 113 (2009) 716-729 * * * \ingroup Functor * \ingroup Radiometry * \ingroup VegetationIndices * * \ingroup OTBIndices */ template class LAIFromReflectancesLinear : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LAIFromReflectancesLinear"; } typedef NDVI NDVIFunctorType; LAIFromReflectancesLinear() : m_RedCoef(-17.91), m_NirCoef(12.26) {} ~LAIFromReflectancesLinear() ITK_OVERRIDE {} NDVIFunctorType GetReflectances(void) const { return (m_NDVIfunctor); } void SetRedCoef(const double val) { m_RedCoef = val; } double GetRedCoef(void) const { return (m_RedCoef); } void SetNirCoef(const double val) { m_NirCoef = val; } double GetNirCoef(void) const { return (m_NirCoef); } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { return (static_cast(m_RedCoef*r+m_NirCoef*nir)); } private: NDVIFunctorType m_NDVIfunctor; double m_RedCoef; double m_NirCoef; }; /** \class LAIFromNDVIFormosat2Functor * * \brief use red and nir image band to compute LAI image using formula * a*(exp(nir-red)/((red+nir)*b)-exp(c*b)); * with a = 0.1519 b = 3.9443 c = 0.13 * this formula is only valid for Formosat 2 reflectance TOC * * This relationship have been presented by : * M. Claverie, V. Demarez, B. Duchemin, * Spatialization of crop leaf area index and biomass by combining a simple crop model * safy and high spatial and temporal resolutions remote sensing data. * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class LAIFromNDVIFormosat2Functor : public RAndNIRIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LAIFromNDVIFormosat2Functor"; } /// Constructor LAIFromNDVIFormosat2Functor() {} /// Desctructor ~LAIFromNDVIFormosat2Functor() ITK_OVERRIDE {} // Operator on r and nir single pixel values protected: inline TOutput Evaluate(const TInput1& r, const TInput2& nir) const ITK_OVERRIDE { double a = 0.1519; double b = 3.9443; double c = 0.13; double dr = static_cast(r); double dnir = static_cast(nir); if (vcl_abs(dnir + dr) < this->m_EpsilonToBeConsideredAsZero) { return static_cast(0.); } return static_cast(a*(vcl_exp(static_cast(dnir-dr)/static_cast(dr+dnir)*b)-vcl_exp(c*b))); }; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbWaterIndicesFunctor.h000066400000000000000000000407211301006202600267520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaterIndicesFunctor_h #define otbWaterIndicesFunctor_h #include "otbMath.h" #include "itkVariableLengthVector.h" #include "otbSqrtSpectralAngleFunctor.h" #include "otbBandName.h" namespace otb { namespace Functor { /** * \class WaterIndexBase * \brief Base class * * Implement operators for UnaryFunctorImageFilter templated with a * VectorImage and BinaryFunctorImageFilter templated with single * images. * Subclasses should NOT overload operators, they must re-implement * the Evaluate() method. * * \ingroup Radiometry * * \ingroup OTBIndices */ template class WaterIndexBase { public: /// Vector pixel type used to support both vector images and multiple /// input images typedef itk::VariableLengthVector InputVectorType; //operators != bool operator !=(const WaterIndexBase&) const { return true; } //operator == bool operator ==(const WaterIndexBase& other) const { return !(*this != other); } // Operator on vector pixel type inline TOutput operator ()(const InputVectorType& inputVector) const { return this->Evaluate(inputVector[m_Index1 - 1], static_cast(inputVector[m_Index2 - 1])); } // Binary operator inline TOutput operator ()(const TInput1& id1, const TInput2& id2) const { return this->Evaluate(id1, id2); } /// Constructor WaterIndexBase() {} /// Desctructor virtual ~WaterIndexBase() {} /// Set Index 1 void SetIndex1(unsigned int channel) { m_Index1 = channel; } /// Get Index 1 unsigned int GetIndex1() const { return m_Index1; } /// Set Index 2 void SetIndex2(unsigned int channel) { m_Index2 = channel; } /// Get Index 2 unsigned int GetIndex2() const { return m_Index2; } /** Return the index name */ virtual std::string GetName() const = 0; protected: // This method must be reimplemented in subclasses to actually // compute the index value virtual TOutput Evaluate(const TInput1& id1, const TInput2& id2) const = 0; private: unsigned int m_Index1; unsigned int m_Index2; }; /** \class WaterIndexFunctor * \brief This functor will be used for most of water index functors. * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class WaterIndexFunctor : public WaterIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "WaterIndexFunctor"; } WaterIndexFunctor() {} ~WaterIndexFunctor() ITK_OVERRIDE {} protected: inline TOutput Evaluate(const TInput1& id1, const TInput2& id2) const ITK_OVERRIDE { double dindex1 = static_cast(id1); double dindex2 = static_cast(id2); double ddenom = dindex1 + dindex2; if (ddenom == 0) { return static_cast(0.); } return (static_cast((dindex1 - dindex2) / ddenom)); } }; /** \class SRWI * \brief This functor computes the Simple Ratio Water Index (SRWI) * \brief For MODIS bands 860 & 1240 * * [Zarco-Tejada 2001] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class SRWI : public WaterIndexBase { public: /** Return the index name */ virtual std::string GetName() const { return "SRWI"; } SRWI() {} virtual ~SRWI() {} protected: inline TOutput Evaluate(const TInput1& rho860, const TInput2& rho1240) const { double drho860 = static_cast(rho860); double drho1240 = static_cast(rho1240); if (drho1240 == 0) { return static_cast(0.); } return (static_cast(drho860 / drho1240)); } }; /** \class NDWI * \brief This functor computes the Normalized Difference Water Index (NDWI) * \brief Also called : * \brief NDII (Normalized Difference Infrared Index) * \brief LSWI (Land Surface Water Index) * \brief NDWI (Normalized Difference Moisture Index) * * [Gao, 1996 ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class NDWI : public WaterIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDWI"; } typedef WaterIndexFunctor WIFunctorType; /// Constructor NDWI() {} /// Desctructor ~NDWI() ITK_OVERRIDE {} WIFunctorType GetWIFunctor(void) const { return (m_WIFunctor); } /// Set Index NIR void SetNIRIndex(unsigned int channel) { this->SetIndex1(channel); } /// Get Index NIR unsigned int GetNIRIndex() const { return this->GetIndex1(); } /// Set Index MIR void SetMIRIndex(unsigned int channel) { this->SetIndex2(channel); } /// Get Index MIR unsigned int GetMIRIndex() const { return this->GetIndex2(); } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::NIR) { this->SetIndex1(channel); } if (band == BandName::MIR) { this->SetIndex2(channel); } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::NIR) { return this->GetIndex1(); } if (band == BandName::MIR) { return this->GetIndex2(); } } protected: inline TOutput Evaluate(const TInput1& nir, const TInput2& mir) const ITK_OVERRIDE { return (static_cast(GetWIFunctor() (nir, mir))); } private: // Water Index Classic Functor WIFunctorType m_WIFunctor; }; /** \class NDWI2 * \brief This functor computes the Normalized Difference Water Index (NDWI2) * * [McFeeters, 1996 ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class NDWI2 : public WaterIndexBase { public: /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "NDWI2"; } typedef WaterIndexFunctor WIFunctorType; /// Constructor NDWI2() {} /// Desctructor ~NDWI2() ITK_OVERRIDE {} WIFunctorType GetWIFunctor(void) const { return (m_WIFunctor); } /// Set Index G void SetGIndex(unsigned int channel) { this->SetIndex1(channel); } /// Get Index G unsigned int GetGIndex() const { return this->GetIndex1(); } /// Set Index NIR void SetNIRIndex(unsigned int channel) { this->SetIndex2(channel); } /// Get Index NIR unsigned int GetNIRIndex() const { return this->GetIndex2(); } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::GREEN) { this->SetIndex1(channel); } if (band == BandName::NIR) { this->SetIndex2(channel); } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::GREEN) { return this->GetIndex1(); } if (band == BandName::NIR) { return this->GetIndex2(); } } protected: inline TOutput Evaluate(const TInput1& g, const TInput2& nir) const ITK_OVERRIDE { return (static_cast(GetWIFunctor() (g, nir))); } private: // Water Index Classic Functor WIFunctorType m_WIFunctor; }; /** \class MNDWI * \brief This functor computes the Modified Normalized Difference Water Index (MNDWI) * * [Xu & al., 2006 ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class MNDWI : public WaterIndexBase { public: /** Return the index name */ virtual std::string GetName() const { return "MNDWI"; } typedef WaterIndexFunctor WIFunctorType; /// Constructor MNDWI() {} /// Desctructor virtual ~MNDWI() {} WIFunctorType GetWIFunctor(void) const { return (m_WIFunctor); } /// Set Index G void SetGIndex(unsigned int channel) { this->SetIndex1(channel); } /// Get Index G unsigned int GetGIndex() const { return this->GetIndex1(); } /// Set Index MIR void SetMIRIndex(unsigned int channel) { this->SetIndex2(channel); } /// Get Index MIR unsigned int GetMIRIndex() const { return this->GetIndex2(); } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::GREEN) { this->SetIndex1(channel); } if (band == BandName::MIR) { this->SetIndex2(channel); } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::GREEN) { return this->GetIndex1(); } if (band == BandName::MIR) { return this->GetIndex2(); } } protected: inline TOutput Evaluate(const TInput1& g, const TInput2& mir) const { return (static_cast(GetWIFunctor() (g, mir))); } private: // Water Index Classic Functor WIFunctorType m_WIFunctor; }; /** \class NDPI * \brief This functor computes the Normalized Difference Pond Index (NDPI) * * [J.P Lacaux & al., 2006 ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class NDPI : public WaterIndexBase { public: /** Return the index name */ virtual std::string GetName() const { return "NDPI"; } typedef WaterIndexFunctor WIFunctorType; /// Constructor NDPI() {} /// Desctructor virtual ~NDPI() {} WIFunctorType GetWIFunctor(void) const { return (m_WIFunctor); } /// Set Index MIR void SetMIRIndex(unsigned int channel) { this->SetIndex1(channel); } /// Get Index MIR unsigned int GetMIRIndex() const { return this->GetIndex1(); } /// Set Index G void SetGIndex(unsigned int channel) { this->SetIndex2(channel); } /// Get Index G unsigned int GetGIndex() const { return this->GetIndex2(); } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::MIR) { this->SetIndex1(channel); } if (band == BandName::GREEN) { this->SetIndex2(channel); } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::MIR) { return this->GetIndex1(); } if (band == BandName::GREEN) { return this->GetIndex2(); } } protected: inline TOutput Evaluate(const TInput1& mir, const TInput2& g) const { return (static_cast(GetWIFunctor() (mir, g))); } private: // Water Index Classic Functor WIFunctorType m_WIFunctor; }; /** \class NDTI * \brief This functor computes the Normalized Difference Turbidity Index (NDTI) * * [J.P Lacaux & al., 2006 ] * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class NDTI : public WaterIndexBase { public: /** Return the index name */ virtual std::string GetName() const { return "NDTI"; } typedef WaterIndexFunctor WIFunctorType; /// Constructor NDTI() {} /// Desctructor virtual ~NDTI() {} WIFunctorType GetWIFunctor(void) const { return (m_WIFunctor); } // FIXME why now using Red and Green fully spelled as everywhere //else ??? /// Set Index R void SetRIndex(unsigned int channel) { this->SetIndex1(channel); } /// Get Index R unsigned int GetRIndex() const { return this->GetIndex1(); } /// Set Index G void SetGIndex(unsigned int channel) { this->SetIndex2(channel); } /// Get Index G unsigned int GetGIndex() const { return this->GetIndex2(); } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { this->SetIndex1(channel); } if (band == BandName::GREEN) { this->SetIndex2(channel); } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return this->GetIndex1(); } if (band == BandName::GREEN) { return this->GetIndex2(); } } protected: inline TOutput Evaluate(const TInput1& r, const TInput2& g) const { return (static_cast(GetWIFunctor() (r, g))); } private: // Water Index Classic Functor WIFunctorType m_WIFunctor; }; /** \class WaterSqrtSpectralAngleFunctor * \brief This functor uses a spectral angle with a particular reference pixel. * * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBIndices */ template class WaterSqrtSpectralAngleFunctor : public SqrtSpectralAngleFunctor { public: /** Return the index name */ virtual std::string GetName() const { return "WaterSqrtSpectralAngleFunctor"; } typedef WaterSqrtSpectralAngleFunctor Self; typedef SqrtSpectralAngleFunctor Superclass; typedef TInputVectorPixel InputVectorPixelType; WaterSqrtSpectralAngleFunctor() { //Set the channels indices m_BlueIndex = 0; m_GreenIndex = 1; m_RedIndex = 2; m_NIRIndex = 3; //Set reference water value InputVectorPixelType reference; reference.SetSize(4); reference[0] = 136.0; reference[1] = 132.0; reference[2] = 47.0; reference[3] = 24.0; this->SetReferenceWaterPixel(reference); } ~WaterSqrtSpectralAngleFunctor() ITK_OVERRIDE {} /** Set Reference Pixel */ void SetReferenceWaterPixel(InputVectorPixelType ref) { if (ref.GetSize() != 4) { } InputVectorPixelType reference; reference.SetSize(4); reference[m_BlueIndex] = ref[0]; reference[m_GreenIndex] = ref[1]; reference[m_RedIndex] = ref[2]; reference[m_NIRIndex] = ref[3]; this->SetReferencePixel(reference); } /** Getters and setters */ void SetBlueChannel(unsigned int channel) { m_BlueIndex = channel; } unsigned int GetBlueChannel() const { return m_BlueIndex; } void SetGreenChannel(unsigned int channel) { m_GreenIndex = channel; } unsigned int GetGreenChannel() const { return m_GreenIndex; } void SetRedChannel(unsigned int channel) { m_RedIndex = channel; } unsigned int GetRedChannel() const { return m_RedIndex; } void SetNIRChannel(unsigned int channel) { m_NIRIndex = channel; } unsigned int GetNIRChannel() const { return m_NIRIndex; } /** Set index, generic method */ void SetIndex(BandName::BandName band, unsigned int channel) { if (band == BandName::RED) { m_RedIndex = channel; } if (band == BandName::GREEN) { m_GreenIndex = channel; } if (band == BandName::BLUE) { m_BlueIndex = channel; } if (band == BandName::NIR) { m_NIRIndex = channel; } } /** Get index, generic method */ unsigned int GetIndex(BandName::BandName band) const { if (band == BandName::RED) { return m_RedIndex; } if (band == BandName::GREEN) { return m_GreenIndex; } if (band == BandName::BLUE) { return m_BlueIndex; } if (band == BandName::NIR) { return m_NIRIndex; } } protected: inline TOutputPixel Evaluate(const TInputVectorPixel& inPix) const ITK_OVERRIDE { return static_cast(Superclass::Evaluate(inPix)); } /** Channels */ int m_BlueIndex; int m_GreenIndex; int m_RedIndex; int m_NIRIndex; }; } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/Indices/include/otbWaterSqrtSpectralAngleImageFilter.h000066400000000000000000000057211301006202600315430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWaterSqrtSpectralAngleImageFilter_h #define otbWaterSqrtSpectralAngleImageFilter_h #include "otbWaterIndicesFunctor.h" #include "itkUnaryFunctorImageFilter.h" namespace otb { /** \class WaterSqrtSpectralAngleImageFilter * \brief Compute a radiometric water indice * * This filter calculates a pixel wise water indice by calculating * the spectral angle distance with a reference radiometry. * This class is templated over the input multispectral image type, * and the output image type. * By default, the filter use the channel 0 as blue, the channel 1 as * green, the channel 2 as red, and the channel 3 as near * infrared. It can be changed with the SetBlue, SetGreen, SetRed and * SetIR methods. * * In the output image, value clse to zero denotes a highest * probability of water. * * \sa SpectralAngleDistanceImageFilter * * \ingroup OTBIndices */ template > class ITK_EXPORT WaterSqrtSpectralAngleImageFilter : public itk::UnaryFunctorImageFilter { public: /** Standard class typedefs. */ typedef WaterSqrtSpectralAngleImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(WaterSqrtSpectralAngleImageFilter, itk::UnaryFunctorImageFilter); /** Some convenient typedef. */ typedef TInputVectorImage InputVectorImageType; typedef typename InputVectorImageType::PixelType InputVectorPixelType; typedef TOutputImage OutputImageType; protected: WaterSqrtSpectralAngleImageFilter() {} ~WaterSqrtSpectralAngleImageFilter() ITK_OVERRIDE {} private: WaterSqrtSpectralAngleImageFilter(Self &); // purposely not implemented void operator =(const Self&); // purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #endif #endif OTB-release-5.8/Modules/Radiometry/Indices/otb-module.cmake000066400000000000000000000012141301006202600235720ustar00rootroot00000000000000set(DOCUMENTATION "With multispectral sensors, several indices can be computed combining several spectral bands to show features that are not obvious using only one band. This module contains filters that can compute classical indices, such as NDVI (Normalized Difference Vegetation Index), NDWI (Normalized DifferenceWater Index) and so on.") otb_module(OTBIndices DEPENDS OTBCommon OTBFuzzy OTBITK OTBImageManipulation OTBMetadata OTBPath OTBVectorDataBase TEST_DEPENDS OTBImageBase OTBImageIO OTBObjectList OTBProjection OTBTestKernel OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Radiometry/Indices/test/000077500000000000000000000000001301006202600215025ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/00134-feature_extraction.cxx000066400000000000000000000103401301006202600265640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "itkMeanImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbMultiChannelExtractROI.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" int main(int itkNotUsed(argc), char* argv[]) { const char * inputName = argv[1]; const char * outputName = argv[2]; const unsigned int radius = atoi(argv[3]); const unsigned int id = atoi(argv[4]); const unsigned int size = atoi(argv[5]); typedef double PixelType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter ListToImageFilterType; typedef otb::MultiToMonoChannelExtractROI ExtractorFilterType; typedef otb::MultiChannelExtractROI MultiChannelExtractorFilterType; typedef itk::MeanImageFilter MeanFilterType; typedef otb::Functor::NDVI NDVIFunctorType; typedef otb::MultiChannelRAndNIRIndexImageFilter NDVIFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ImageListType::Pointer imListOut = ImageListType::New(); ExtractorFilterType::Pointer extract = ExtractorFilterType::New(); MultiChannelExtractorFilterType::Pointer MCExtract = MultiChannelExtractorFilterType::New(); MeanFilterType::Pointer meanner = MeanFilterType::New(); NDVIFilterType::Pointer ndvi = NDVIFilterType::New(); ListToImageFilterType::Pointer caster = ListToImageFilterType::New(); reader->SetFileName(inputName); reader->GenerateOutputInformation(); ImageType::RegionType region; ImageType::SizeType extSize; ImageType::IndexType extId; extSize.Fill(size); extId.Fill(id); region.SetSize(extSize); region.SetIndex(extId); MCExtract->SetInput(reader->GetOutput()); MCExtract->SetExtractionRegion(region); MCExtract->UpdateOutputInformation(); extract->SetInput(MCExtract->GetOutput()); extract->SetChannel(1); extract->UpdateOutputInformation(); ImageType::SizeType rad; rad[0] = radius; rad[1] = radius; meanner->SetInput(extract->GetOutput()); meanner->SetRadius(rad); ndvi->SetInput(MCExtract->GetOutput()); imListOut->PushBack(meanner->GetOutput()); imListOut->PushBack(ndvi->GetOutput()); caster->SetInput(imListOut); writer->SetInput(caster->GetOutput()); writer->SetFileName(outputName); writer->Update(); /*** With 2 writers : OK */ /* typedef otb::ImageFileWriter WriterMonoType; WriterMonoType::Pointer w1 = WriterMonoType::New(); WriterMonoType::Pointer w2 = WriterMonoType::New(); w1->SetInput( imListOut->GetNthElement(0) ); w2->SetInput( imListOut->GetNthElement(1) ); w1->SetFileName("meaner.tif"); w2->SetFileName("ndvi.tif"); w1->Update(); w2->Update(); */ return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/CMakeLists.txt000066400000000000000000000650501301006202600242500ustar00rootroot00000000000000otb_module_test() set(OTBIndicesTests otbIndicesTestDriver.cxx otbRAndGAndNIRVegetationIndexImageFilterNew.cxx otbAVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx otbNDVIDataNodeFeatureFunction.cxx otbRAndNIRVegetationIndexImageFilterNew.cxx otbMultiChannelRAndBAndNIRVegetationIndexImageFilterNew.cxx otbLandsatTMIndexNDSITest.cxx otbLandsatTMIndexBIOTest.cxx otbLAIFromReflectancesLinearFunctorTest.cxx otbSetASetBMultiChannelRAndNIRVegetationIndexImageFilter.cxx otbWDVIRAndNIRVegetationIndexImageFilter.cxx otbGAndRIndexImageFilter.cxx otbRAndBAndNIRVegetationIndexImageFilter.cxx otbIBMultiChannelGAndRAndNIRIndexImageFilter.cxx otbLandsatTMIndexMIR2Test.cxx otbLandsatTMIndexNDVITest.cxx otbISURAndNIRIndexImageFilter.cxx otbLAIFromNDVILogarithmicFunctorTest.cxx otbMultiChannelRAndNIRVegetationIndexImageFilter.cxx otbLandsatTMIndexVisTest.cxx otbWaterSqrtSpectralAngleImageFilter.cxx otbMultiChannelRAndGAndNIRIndexImageFilterNew.cxx otbLandsatTMIndexBrightTest.cxx otbMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx otbMultiChannelRAndNIRVegetationIndexImageFilterNew.cxx otbLandsatTMBrightTest.cxx otbLandsatTMThinCloudTest.cxx otbISUMultiChannelRAndNIRIndexImageFilter.cxx otbAVIRAndGAndNIRVegetationIndexImageFilter.cxx otbMultiChannelGAndRIndexImageFilter.cxx otbLandsatTMIndexMIRTIRTest.cxx otbLandsatTMIndexMIR1Test.cxx otbRAndNIRVegetationIndexImageFilter.cxx otbLandsatTMVegetationTest.cxx otbEVIRAndBAndNIRVegetationIndexImageFilter.cxx otbNDBITM4AndTM5IndexImageFilter.cxx otbLandsatTMIndexNDBBBITest.cxx otbIBGAndRAndNIRIndexImageFilter.cxx otbGAndRIndexImageFilterNew.cxx otbEVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx otbNDBIMultiChannelTM4AndTM5IndexImageFilter.cxx otbMultiChannelGAndRIndexImageFilterNew.cxx otbNDWIWaterIndexImageFilter.cxx otbLandsatTMIndexTIRTest.cxx otbTSARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx otbLandsatTMLinguisticLabelsTest.cxx otbNDWIMultiChannelWaterIndexImageFilter.cxx otbWDVIMultiChannelRAndNIRVegetationIndexImageFilter.cxx otbLandsatTMIndexNDSIVisTest.cxx otbRAndBAndNIRVegetationIndexImageFilterNew.cxx otbLandsatTMIndexNIRTest.cxx otbSetASetBRAndNIRVegetationIndexImageFilter.cxx otbLandsatTMKernelSpectralRules.cxx otbLandsatTMIndexNDBSITest.cxx otbTSARVIRAndBAndNIRVegetationIndexImageFilter.cxx otbLandsatTMThickCloudTest.cxx ) add_executable(otbIndicesTestDriver ${OTBIndicesTests}) target_link_libraries(otbIndicesTestDriver ${OTBIndices-Test_LIBRARIES}) otb_module_target_label(otbIndicesTestDriver) # Tests Declaration otb_add_test(NAME raTuRAndGAndNIRVegetationIndexImageFilterNew COMMAND otbIndicesTestDriver otbRAndGAndNIRVegetationIndexImageFilterNew ) otb_add_test(NAME raTvAVI_MultiChannelRAndGAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raMultiChannelRAndGAndNIRVegetationIndex_AVI_qb_RoadExtract.tif ${TEMP}/raMultiChannelRAndGAndNIRVegetationIndex_AVI_qb_RoadExtract.tif otbAVIMultiChannelRAndGAndNIRVegetationIndexImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raMultiChannelRAndGAndNIRVegetationIndex_AVI_qb_RoadExtract.tif 3 # red 2 # green 4 # nir 660. # lambda r 560. # lambda g 830. # lambda nir ) otb_add_test(NAME bfTvNDVIDataNodeFeatureFunction_Polygon COMMAND otbIndicesTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvNDVIDataNodeFeatureFunctionOutput_Polygon.shp ${TEMP}/bfTvNDVIDataNodeFeatureFunctionOutput_Polygon.shp otbNDVIDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_BUILDINGS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvNDVIDataNodeFeatureFunctionOutput_Polygon.shp 0 ) otb_add_test(NAME bfTvNDVIDataNodeFeatureFunction_Line COMMAND otbIndicesTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/bfTvNDVIDataNodeFeatureFunctionOutput_Line.shp ${TEMP}/bfTvNDVIDataNodeFeatureFunctionOutput_Line.shp otbNDVIDataNodeFeatureFunction ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE_ROADS.shp ${INPUTDATA}/Dempster-Shafer/ROI_QB_TOULOUSE.TIF ${INPUTDATA}/DEM/srtm_directory ${TEMP}/bfTvNDVIDataNodeFeatureFunctionOutput_Line.shp 0 ) otb_add_test(NAME bfTuNDVIDataNodeFeatureFunctionNew COMMAND otbIndicesTestDriver otbNDVIDataNodeFeatureFunctionNew ) otb_add_test(NAME raTuRAndNIRVegetationIndexImageFilterNew COMMAND otbIndicesTestDriver otbRAndNIRVegetationIndexImageFilterNew ) otb_add_test(NAME raTuMultiChannelRAndBAndNIRVegetationIndexImageFilterNew COMMAND otbIndicesTestDriver otbMultiChannelRAndBAndNIRVegetationIndexImageFilterNew ) otb_add_test(NAME raTvLandsatTMIndexNDSITest COMMAND otbIndicesTestDriver otbLandsatTMIndexNDSI 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvLandsatTMIndexBIOTest COMMAND otbIndicesTestDriver otbLandsatTMIndexBIO 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvLAIFromReflectancesLinearFunctorTest COMMAND otbIndicesTestDriver otbLAIFromReflectancesLinear 3 # red 4 # nir -18 # red coef 13 # nir coef ) otb_add_test(NAME raTvPVI_MultiChannelRAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raMultiChannelRAndNIRVegetationIndex_PVI_verySmallFSATSWcRcNir.tif ${TEMP}/raMultiChannelRAndNIRVegetationIndex_PVI_verySmallFSATSWcRcNir.tif otbSetASetBMultiChannelRAndNIRVegetationIndexImageFilter PVI 0.7 0.9 ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raMultiChannelRAndNIRVegetationIndex_PVI_verySmallFSATSWcRcNir.tif 3 4 ) otb_add_test(NAME raTvWDVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_WDVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_WDVI_verySmallFSATSWcRcNir.tif otbWDVIRAndNIRVegetationIndexImageFilter ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_WDVI_verySmallFSATSWcRcNir.tif 2.0 # g : slope of soil line ) otb_add_test(NAME raTvIR_GAndRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raGAndRIndexImageFilter_IR_verySmallFSATSW.tif ${TEMP}/raGAndRIndexImageFilter_IR_verySmallFSATSW.tif otbGAndRIndexImageFilter IR ${INPUTDATA}/verySmallFSATSW_g.tif ${INPUTDATA}/verySmallFSATSW_r.tif ${TEMP}/raGAndRIndexImageFilter_IR_verySmallFSATSW.tif ) otb_add_test(NAME raTvIB_GAndRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raGAndRIndexImageFilter_IB_verySmallFSATSW.tif ${TEMP}/raGAndRIndexImageFilter_IB_verySmallFSATSW.tif otbGAndRIndexImageFilter IB ${INPUTDATA}/verySmallFSATSW_g.tif ${INPUTDATA}/verySmallFSATSW_r.tif ${TEMP}/raGAndRIndexImageFilter_IB_verySmallFSATSW.tif ) otb_add_test(NAME raTvIC_GAndRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raGAndRIndexImageFilter_IC_verySmallFSATSW.tif ${TEMP}/raGAndRIndexImageFilter_IC_verySmallFSATSW.tif otbGAndRIndexImageFilter IC ${INPUTDATA}/verySmallFSATSW_g.tif ${INPUTDATA}/verySmallFSATSW_r.tif ${TEMP}/raGAndRIndexImageFilter_IC_verySmallFSATSW.tif ) otb_add_test(NAME raTvARVI_RAndBAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndBAndNIRVegetationIndex_ARVI_verySmallFSATSWcRcBcNir.tif ${TEMP}/raRAndBAndNIRVegetationIndex_ARVI_verySmallFSATSWcRcBcNir.tif otbRAndBAndNIRVegetationIndexImageFilter ARVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_b.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndBAndNIRVegetationIndex_ARVI_verySmallFSATSWcRcBcNir.tif 0.6 # Gamma parameter ) otb_add_test(NAME raTvIB2_MultiChannelGAndRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_6} ${BASELINE}/raMultiChannelGAndRAndNIRIndex_IB2_Romania_Extract.tif ${TEMP}/raMultiChannelGAndRAndNIRIndex_IB2_Romania_Extract.tif otbIBMultiChannelGAndRAndNIRIndexImageFilter ${INPUTDATA}/Romania_Extract.tif ${TEMP}/raMultiChannelGAndRAndNIRIndex_IB2_Romania_Extract.tif 2 1 3 ) otb_add_test(NAME raTvLandsatTMIndexMIR2Test COMMAND otbIndicesTestDriver otbLandsatTMIndexMIR2 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvLandsatTMIndexNDVITest COMMAND otbIndicesTestDriver otbLandsatTMIndexNDVI 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvISU_RAndNIRBuiltUpIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRBuiltUpIndex_ISU_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRBuiltUpIndex_ISU_verySmallFSATSWcRcNir.tif otbISURAndNIRIndexImageFilter ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRBuiltUpIndex_ISU_verySmallFSATSWcRcNir.tif 100. 25. ) otb_add_test(NAME raTvLAIFromNDVILogarithmicFunctorTest COMMAND otbIndicesTestDriver otbLAIFromNDVILogarithmic 3 # red 4 # nir 0.12 # ndvi soil 0.91 # ndvi infinity 0.70 # extinction coefficient ) otb_add_test(NAME raTvLAIFromNDVIFormosat2_MultiChannelRAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_8} ${BASELINE}/raRAndNIRVegetationIndex_LAIFromNDVIFormosat2_verySmallFSATSWcRcNir.tif ${TEMP}/raMultiChannelRAndNIRVegetationIndex_LAIFromNDVIFormosat2_verySmallFSATSWcRcNir.tif otbMultiChannelRAndNIRVegetationIndexImageFilter LAIFormosat2 ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raMultiChannelRAndNIRVegetationIndex_LAIFromNDVIFormosat2_verySmallFSATSWcRcNir.tif 1 4 ) otb_add_test(NAME raTvLandsatTMIndexVisTest COMMAND otbIndicesTestDriver otbLandsatTMIndexVis 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvWaterSqrtSpectralAngleImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raWater_SqrtSpectralAngle.tif ${TEMP}/raWater_SqrtSpectralAngle.tif otbWaterSqrtSpectralAngleImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raWater_SqrtSpectralAngle.tif 0 1 2 3 ) otb_add_test(NAME raTuMultiChannelRAndGAndNIRIndexImageFilterNew COMMAND otbIndicesTestDriver otbMultiChannelRAndGAndNIRIndexImageFilterNew ) otb_add_test(NAME raTvLandsatTMIndexBrightTest COMMAND otbIndicesTestDriver otbLandsatTMIndexBright 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvARVI_MultiChannelRAndBAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raMultiChannelRAndBAndNIRVegetationIndex_ARVI_verySmallFSATSWcRcBcNir.tif ${TEMP}/raMultiChannelRAndBAndNIRVegetationIndex_ARVI_verySmallFSATSWcRcBcNir.tif otbMultiChannelRAndBAndNIRVegetationIndexImageFilter ARVI ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raMultiChannelRAndBAndNIRVegetationIndex_ARVI_verySmallFSATSWcRcBcNir.tif 3 1 4 0.6 # Gamma parameter ) otb_add_test(NAME raTvLandsatTMBrightTest COMMAND otbIndicesTestDriver otbLandsatTMBrightTest ${INPUTDATA}/L5Strip.tif ${TEMP}/raTvLandsatTMBrightTest_cloudImage.tif ) otb_add_test(NAME raTvLandsatTMThinCloudTest COMMAND otbIndicesTestDriver otbLandsatTMThinCloudTest ${INPUTDATA}/L5Strip.tif ${TEMP}/raTvLandsatTMThinCloudTest_cloudImage.tif ) otb_add_test(NAME raTvISU_MultiChannelRAndNIRBuiltUpIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRBuiltUpIndex_ISU_qb_RoadExtract.tif ${TEMP}/raRAndNIRBuiltUpIndex_ISU_qb_RoadExtract.tif otbISUMultiChannelRAndNIRIndexImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raRAndNIRBuiltUpIndex_ISU_qb_RoadExtract.tif 3 4 # red nir channels 100. 25. ) otb_add_test(NAME raTvAVI_RAndGAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndGAndNIRVegetationIndex_AVI_verySmallFSATSWcRcGcNir.tif ${TEMP}/raRAndGAndNIRVegetationIndex_AVI_verySmallFSATSWcRcGcNir.tif otbAVIRAndGAndNIRVegetationIndexImageFilter ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_g.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndGAndNIRVegetationIndex_AVI_verySmallFSATSWcRcGcNir.tif 660. # lambda r 560. # lambda g 830. # lambda nir ) otb_add_test(NAME raTvIB_MultiChannelGAndRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_10} ${BASELINE}/raMultiChannelGAndRIndex_IB_Romania_Extract.tif ${TEMP}/raMultiChannelGAndRIndex_IB_Romania_Extract.tif otbMultiChannelGAndRIndexImageFilter IB ${INPUTDATA}/Romania_Extract.tif ${TEMP}/raMultiChannelGAndRIndex_IB_Romania_Extract.tif 1 2 ) otb_add_test(NAME raTvIR_MultiChannelGAndRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_10} ${BASELINE}/raMultiChannelGAndRIndex_IR_Romania_Extract.tif ${TEMP}/raMultiChannelGAndRIndex_IR_Romania_Extract.tif otbMultiChannelGAndRIndexImageFilter IR ${INPUTDATA}/Romania_Extract.tif ${TEMP}/raMultiChannelGAndRIndex_IR_Romania_Extract.tif 1 2 ) otb_add_test(NAME raTvIC_MultiChannelGAndRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${NOTOL} ${BASELINE}/raMultiChannelGAndRIndex_IC_Romania_Extract.tif ${TEMP}/raMultiChannelGAndRIndex_IC_Romania_Extract.tif otbMultiChannelGAndRIndexImageFilter IC ${INPUTDATA}/Romania_Extract.tif ${TEMP}/raMultiChannelGAndRIndex_IC_Romania_Extract.tif 1 2 ) otb_add_test(NAME raTvLandsatTMIndexMIRTIRTest COMMAND otbIndicesTestDriver otbLandsatTMIndexMIRTIR 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvLandsatTMIndexMIR1Test COMMAND otbIndicesTestDriver otbLandsatTMIndexMIR1 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvMSAVI2_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_8} ${BASELINE}/raRAndNIRVegetationIndex_MSAVI2_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_MSAVI2_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter MSAVI2 ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_MSAVI2_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvRVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${NOTOL} ${BASELINE}/raRAndNIRVegetationIndex_RVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_RVI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter RVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_RVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvMSAVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_8} ${BASELINE}/raRAndNIRVegetationIndex_MSAVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_MSAVI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter MSAVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_MSAVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvNDVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${NOTOL} ${BASELINE}/raRAndNIRVegetationIndex_NDVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_NDVI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter NDVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_NDVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvTSAVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_TSAVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_TSAVI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter TSAVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_TSAVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvIPVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_IPVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_IPVI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter IPVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_IPVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvTNDVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_TNDVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_TNDVI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter TNDVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_TNDVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvSAVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${NOTOL} ${BASELINE}/raRAndNIRVegetationIndex_SAVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_SAVI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter SAVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_SAVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvLAIFromNDVIFormosat2_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_LAIFromNDVIFormosat2_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_LAIFromNDVIFormosat2_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter LAIFormosat2 ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_LAIFromNDVIFormosat2_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvGEMI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_GEMI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_GEMI_verySmallFSATSWcRcNir.tif otbRAndNIRVegetationIndexImageFilter GEMI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_GEMI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvLandsatTMVegetationTest COMMAND otbIndicesTestDriver otbLandsatTMVegetationTest ${INPUTDATA}/L5Strip.tif ${TEMP}/raTvLandsatTMVegetationTest_Image.tif ) otb_add_test(NAME raTvEVI_RAndBAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndBAndNIRVegetationIndex_EVI_verySmallFSATSWcRcBcNir.tif ${TEMP}/raRAndBAndNIRVegetationIndex_EVI_verySmallFSATSWcRcBcNir.tif otbEVIRAndBAndNIRVegetationIndexImageFilter EVI ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_b.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndBAndNIRVegetationIndex_EVI_verySmallFSATSWcRcBcNir.tif 2.5 6.0 7.5 1.0 ) otb_add_test(NAME raTvNDBI_TM4AndTM5BuiltUpIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTM4AndTM5BuiltUpIndex_NDBI_verySmallFSATSW.tif ${TEMP}/raTM4AndTM5BuiltUpIndex_NDBI_verySmallFSATSW.tif otbNDBITM4AndTM5IndexImageFilter ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raTM4AndTM5BuiltUpIndex_NDBI_verySmallFSATSW.tif ) otb_add_test(NAME raTvLandsatTMIndexNDBBBITest COMMAND otbIndicesTestDriver otbLandsatTMIndexNDBBBI 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvIB2_GAndRAndNIRIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raGAndRAndNIRIndexImageFilter_IB2_verySmallFSATSW.tif ${TEMP}/raGAndRAndNIRIndexImageFilter_IB2_verySmallFSATSW.tif otbIBGAndRAndNIRIndexImageFilter ${INPUTDATA}/verySmallFSATSW_g.tif ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raGAndRAndNIRIndexImageFilter_IB2_verySmallFSATSW.tif ) otb_add_test(NAME raTuGAndRIndexImageFilterNew COMMAND otbIndicesTestDriver otbGAndRIndexImageFilterNew ) otb_add_test(NAME raTvEVI_MultiChannelRAndBAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndBAndNIRVegetationIndex_EVI_qb_RoadExtract.tif ${TEMP}/raRAndBAndNIRVegetationIndex_EVI_qb_RoadExtract.tif otbEVIMultiChannelRAndBAndNIRVegetationIndexImageFilter EVI ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raRAndBAndNIRVegetationIndex_EVI_qb_RoadExtract.tif 3 # red 1 # blue 4 # nir 10.0 # gain factor 30.0 # coefficient of the aerosol resistance term 7.5 # coefficient of the aerosol resistance term 400.0 # canopy background adjustment ) otb_add_test(NAME raTvNDBI_MultiChannelTM4AndTM5BuiltUpIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTM4AndTM5BuiltUpIndex_NDBI_qb_RoadExtract.tif ${TEMP}/raTM4AndTM5BuiltUpIndex_NDBI_qb_RoadExtract.tif otbNDBIMultiChannelTM4AndTM5IndexImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raTM4AndTM5BuiltUpIndex_NDBI_qb_RoadExtract.tif 3 # red 4 # nir ) otb_add_test(NAME raTuMultiChannelGAndRIndexImageFilterNew COMMAND otbIndicesTestDriver otbMultiChannelGAndRIndexImageFilterNew ) otb_add_test(NAME raTvNDWI_WaterIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raWaterIndex_NDWI_verySmallFSATSW.tif ${TEMP}/raWaterIndex_NDWI_verySmallFSATSW.tif otbNDWIWaterIndexImageFilter ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raWaterIndex_NDWI_verySmallFSATSW.tif ) otb_add_test(NAME raTvLandsatTMIndexTIRTest COMMAND otbIndicesTestDriver otbLandsatTMIndexTIR 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvTSARVI_MultiChannelRAndBAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndBAndNIRVegetationIndex_TSARVI_qb_RoadExtract.tif ${TEMP}/raRAndBAndNIRVegetationIndex_TSARVI_qb_RoadExtract.tif otbTSARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raRAndBAndNIRVegetationIndex_TSARVI_qb_RoadExtract.tif 3 # red 1 # blue 4 # nir 0.7 # a ( pente de la droite des sols nus dans l'espace RB/PIR ) 0.9 # b ( ordonnee a l'origine de la droite des sols nus dans l'espace RB/PIR ) 0.08 # x coeff a priori constant 0.5 # gamma ) otb_add_test(NAME raTvLandsatTMLinguisticLabelsTest COMMAND otbIndicesTestDriver otbLandsatTMLinguisticLabels 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvLandsatTMLinguisticLabelsTest2 COMMAND otbIndicesTestDriver otbLandsatTMLinguisticLabels 3 #TM1 4 #TM2 80 #TM3 100 #TM4 33 #TM5 1 #TM61 8 #TM62 51 #TM7 ) otb_add_test(NAME raTvNDWI_MultiChannelWaterIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raMultiChannelWaterIndex_NDWI_qb_RoadExtract.tif ${TEMP}/raMultiChannelWaterIndex_NDWI_qb_RoadExtract.tif otbNDWIMultiChannelWaterIndexImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raMultiChannelWaterIndex_NDWI_qb_RoadExtract.tif 3 4 # mir nir channels ) otb_add_test(NAME raTvWDVI_MultiChannelRAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_WDVI_qb_RoadExtract.tif ${TEMP}/raRAndNIRVegetationIndex_WDVI_qb_RoadExtract.tif otbWDVIMultiChannelRAndNIRVegetationIndexImageFilter ${INPUTDATA}/qb_RoadExtract2sub200x200.tif ${TEMP}/raRAndNIRVegetationIndex_WDVI_qb_RoadExtract.tif 3 # red 4 # nir 2.0 # g : slope of soil line ) otb_add_test(NAME raTvLandsatTMIndexNDSIVisTest COMMAND otbIndicesTestDriver otbLandsatTMIndexNDSIVis 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTuRAndBAndNIRVegetationIndexImageFilterNew COMMAND otbIndicesTestDriver otbRAndBAndNIRVegetationIndexImageFilterNew ) otb_add_test(NAME raTvLandsatTMIndexNIRTest COMMAND otbIndicesTestDriver otbLandsatTMIndexNIR 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvPVI_RAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndNIRVegetationIndex_PVI_verySmallFSATSWcRcNir.tif ${TEMP}/raRAndNIRVegetationIndex_PVI_verySmallFSATSWcRcNir.tif otbSetASetBRAndNIRVegetationIndexImageFilter PVI 0.7 0.9 ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndNIRVegetationIndex_PVI_verySmallFSATSWcRcNir.tif ) otb_add_test(NAME raTvLandsatTMKernelSpectralRulesTest2 COMMAND otbIndicesTestDriver otbLandsatTMKernelSpectralRules 49 #TM1 50 #TM2 70 #TM3 100 #TM4 69 #TM5 0 #TM61 0 #TM62 0 #TM7 ) otb_add_test(NAME raTvLandsatTMKernelSpectralRulesTest COMMAND otbIndicesTestDriver otbLandsatTMKernelSpectralRules 63 #TM1 64 #TM2 57 #TM3 150 #TM4 33 #TM5 1 #TM61 8 #TM62 51 #TM7 ) otb_add_test(NAME raTvLandsatTMKernelSpectralRulesWithImageTest COMMAND otbIndicesTestDriver otbLandsatTMKernelSpectralRulesWithImage ${INPUTDATA}/L5Strip.tif ) otb_add_test(NAME raTvLandsatTMIndexNDBSITest COMMAND otbIndicesTestDriver otbLandsatTMIndexNDBSI 3 #TM1 4 #TM2 8 #TM3 21 #TM4 33 #TM5 41 #TM61 8 #TM62 21 #TM7 ) otb_add_test(NAME raTvTSARVI_RAndBAndNIRVegetationIndexImageFilter COMMAND otbIndicesTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raRAndBAndNIRVegetationIndex_TSARVI_verySmallFSATSWcRcBcNir.tif ${TEMP}/raRAndBAndNIRVegetationIndex_TSARVI_verySmallFSATSWcRcBcNir.tif otbTSARVIRAndBAndNIRVegetationIndexImageFilter ${INPUTDATA}/verySmallFSATSW_r.tif ${INPUTDATA}/verySmallFSATSW_b.tif ${INPUTDATA}/verySmallFSATSW_nir.tif ${TEMP}/raRAndBAndNIRVegetationIndex_TSARVI_verySmallFSATSWcRcBcNir.tif 0.7 # a ( pente de la droite des sols nus dans l'espace RB/PIR ) 0.9 # b ( ordonnee a l'origine de la droite des sols nus dans l'espace RB/PIR ) 0.08 # x coeff a priori constant 0.5 # gamma ) otb_add_test(NAME raTvLandsatTMThickCloudTest COMMAND otbIndicesTestDriver otbLandsatTMThickCloudTest ${INPUTDATA}/L5Strip.tif ${TEMP}/raTvLandsatTMThickCloudTest_cloudImage.tif ) otbAVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000047561301006202600346120ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndGAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbAVIMultiChannelRAndGAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::AVI FunctorType; typedef otb::MultiChannelRAndGAndNIRIndexImageFilter MultiChannelRAndGAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndGAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndGAndNIRIndexImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int greenChannel(::atoi(argv[4])); unsigned int nirChannel(::atoi(argv[5])); double lg(::atof(argv[6])); double lr(::atof(argv[7])); double lnir(::atof(argv[8])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetGreenIndex(greenChannel); filter->SetNIRIndex(nirChannel); filter->SetInput(reader->GetOutput()); filter->GetFunctor().SetLambdaG(lg); filter->GetFunctor().SetLambdaR(lr); filter->GetFunctor().SetLambdaNir(lnir); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbAVIRAndGAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000055661301006202600323650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndGAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbAVIRAndGAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputGImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader GReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::AVI FunctorType; typedef otb::RAndGAndNIRIndexImageFilter RAndGAndNIRIndexImageFilterType; // Instantiating object RAndGAndNIRIndexImageFilterType::Pointer filter = RAndGAndNIRIndexImageFilterType::New(); RReaderType::Pointer readerR = RReaderType::New(); GReaderType::Pointer readerG = GReaderType::New(); NIRReaderType::Pointer readerNIR = NIRReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameG = argv[2]; const char * inputFilenameNIR = argv[3]; const char * outputFilename = argv[4]; double lg(::atof(argv[5])); double lr(::atof(argv[6])); double lnir(::atof(argv[7])); readerR->SetFileName(inputFilenameR); readerG->SetFileName(inputFilenameG); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputG(readerG->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); filter->GetFunctor().SetLambdaR(lr); filter->GetFunctor().SetLambdaG(lg); filter->GetFunctor().SetLambdaNir(lnir); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbEVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000057461301006202600346110ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template int generic_EVIMultiChannelRAndBAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelRAndBAndNIRIndexImageFilter MultiChannelRAndBAndNIRIndexImageFilterType; // Instantiating object typename MultiChannelRAndBAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndBAndNIRIndexImageFilterType::New(); typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int blueChannel(::atoi(argv[4])); unsigned int nirChannel(::atoi(argv[5])); double g(::atof(argv[6])); double c1(::atof(argv[7])); double c2(::atof(argv[8])); double l(::atof(argv[9])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetBlueIndex(blueChannel); filter->SetNIRIndex(nirChannel); filter->SetInput(reader->GetOutput()); filter->GetFunctor().SetG(g); filter->GetFunctor().SetC1(c1); filter->GetFunctor().SetC2(c2); filter->GetFunctor().SetL(l); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbEVIMultiChannelRAndBAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "EVI") return (generic_EVIMultiChannelRAndBAndNIRVegetationIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbEVIRAndBAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000065621301006202600323610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template int generic_EVIRAndBAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader BReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::RAndBAndNIRIndexImageFilter RAndBAndNIRIndexImageFilterType; // Instantiating object typename RAndBAndNIRIndexImageFilterType::Pointer filter = RAndBAndNIRIndexImageFilterType::New(); typename RReaderType::Pointer readerR = RReaderType::New(); typename BReaderType::Pointer readerB = BReaderType::New(); typename NIRReaderType::Pointer readerNIR = NIRReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameB = argv[2]; const char * inputFilenameNIR = argv[3]; const char * outputFilename = argv[4]; double g(::atof(argv[5])); double c1(::atof(argv[6])); double c2(::atof(argv[7])); double l(::atof(argv[8])); readerR->SetFileName(inputFilenameR); readerB->SetFileName(inputFilenameB); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputB(readerB->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); filter->GetFunctor().SetG(g); filter->GetFunctor().SetC1(c1); filter->GetFunctor().SetC2(c2); filter->GetFunctor().SetL(l); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbEVIRAndBAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputBImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "EVI") return (generic_EVIRAndBAndNIRVegetationIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbGAndRIndexImageFilter.cxx000066400000000000000000000062471301006202600270000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbGAndRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template int generic_GAndRIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader GReaderType; typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::GAndRIndexImageFilter GAndRIndexImageFilterType; // Instantiating object typename GAndRIndexImageFilterType::Pointer filter = GAndRIndexImageFilterType::New(); typename GReaderType::Pointer readerG = GReaderType::New(); typename RReaderType::Pointer readerR = RReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilenameG = argv[1]; const char * inputFilenameR = argv[2]; const char * outputFilename = argv[3]; readerG->SetFileName(inputFilenameG); readerR->SetFileName(inputFilenameR); writer->SetFileName(outputFilename); filter->SetInputG(readerG->GetOutput()); filter->SetInputR(readerR->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbGAndRIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image InputGImageType; typedef otb::Image InputRImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "IR") return (generic_GAndRIndexImageFilter > (argc, argv)); else if (strArgv == "IC") return (generic_GAndRIndexImageFilter > (argc, argv)); else if (strArgv == "IB") return (generic_GAndRIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbGAndRIndexImageFilterNew.cxx000066400000000000000000000024411301006202600274420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbGAndRIndexImageFilter.h" #include "otbImage.h" #include "otbImage.h" int otbGAndRIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image InputGImageType; typedef otb::Image InputRImageType; typedef otb::Image OutputImageType; typedef otb::GAndRIndexImageFilter GAndRIndexImageFilterType; // Instantiating object GAndRIndexImageFilterType::Pointer filter = GAndRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbIBGAndRAndNIRIndexImageFilter.cxx000066400000000000000000000054241301006202600302030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndGAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSoilIndicesFunctor.h" int otbIBGAndRAndNIRIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputGImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader GReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::IB2 FunctorType; // Warning : the order of the channels are not the same between the functor and the filter typedef otb::RAndGAndNIRIndexImageFilter RAndGAndNIRIndexImageFilterType; // Instantiating object RAndGAndNIRIndexImageFilterType::Pointer filter = RAndGAndNIRIndexImageFilterType::New(); RReaderType::Pointer readerR = RReaderType::New(); GReaderType::Pointer readerG = GReaderType::New(); NIRReaderType::Pointer readerNIR = NIRReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameG = argv[2]; const char * inputFilenameNIR = argv[3]; const char * outputFilename = argv[4]; readerR->SetFileName(inputFilenameR); readerG->SetFileName(inputFilenameG); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputG(readerG->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbIBMultiChannelGAndRAndNIRIndexImageFilter.cxx000066400000000000000000000046151301006202600325100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndGAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbSoilIndicesFunctor.h" int otbIBMultiChannelGAndRAndNIRIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::IB2 FunctorType; // Warning : the order of the channels are not the same between the functor and the filter typedef otb::MultiChannelRAndGAndNIRIndexImageFilter MultiChannelRAndGAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndGAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndGAndNIRIndexImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int greenChannel(::atoi(argv[4])); unsigned int nirChannel(::atoi(argv[5])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetGreenIndex(greenChannel); filter->SetNIRIndex(nirChannel); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbISUMultiChannelRAndNIRIndexImageFilter.cxx000066400000000000000000000044221301006202600321200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBuiltUpIndicesFunctor.h" int otbISUMultiChannelRAndNIRIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::ISU FunctorType; typedef otb::MultiChannelRAndNIRIndexImageFilter MultiChannelRAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndNIRIndexImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int nirChannel(::atoi(argv[4])); double a(::atof(argv[5])); double b(::atof(argv[6])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetNIRIndex(nirChannel); filter->SetInput(reader->GetOutput()); filter->GetFunctor().SetA(a); filter->GetFunctor().SetB(b); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbISURAndNIRIndexImageFilter.cxx000066400000000000000000000046331301006202600276200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBuiltUpIndicesFunctor.h" int otbISURAndNIRIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::ISU FunctorType; typedef otb::RAndNIRIndexImageFilter RAndNIRIndexImageFilterType; // Instantiating object RAndNIRIndexImageFilterType::Pointer filter = RAndNIRIndexImageFilterType::New(); RReaderType::Pointer readerR = RReaderType::New(); NIRReaderType::Pointer readerNIR = NIRReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameNIR = argv[2]; const char * outputFilename = argv[3]; double a(::atof(argv[4])); double b(::atof(argv[5])); readerR->SetFileName(inputFilenameR); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); filter->GetFunctor().SetA(a); filter->GetFunctor().SetB(b); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbIndicesTestDriver.cxx000066400000000000000000000060621301006202600263310ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbRAndGAndNIRVegetationIndexImageFilterNew); REGISTER_TEST(otbAVIMultiChannelRAndGAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbNDVIDataNodeFeatureFunctionNew); REGISTER_TEST(otbNDVIDataNodeFeatureFunction); REGISTER_TEST(otbRAndNIRVegetationIndexImageFilterNew); REGISTER_TEST(otbMultiChannelRAndBAndNIRVegetationIndexImageFilterNew); REGISTER_TEST(otbLandsatTMIndexNDSI); REGISTER_TEST(otbLandsatTMIndexBIO); REGISTER_TEST(otbLAIFromReflectancesLinear); REGISTER_TEST(otbSetASetBMultiChannelRAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbWDVIRAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbGAndRIndexImageFilter); REGISTER_TEST(otbRAndBAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbIBMultiChannelGAndRAndNIRIndexImageFilter); REGISTER_TEST(otbLandsatTMIndexMIR2); REGISTER_TEST(otbLandsatTMIndexNDVI); REGISTER_TEST(otbISURAndNIRIndexImageFilter); REGISTER_TEST(otbLAIFromNDVILogarithmic); REGISTER_TEST(otbMultiChannelRAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbLandsatTMIndexVis); REGISTER_TEST(otbWaterSqrtSpectralAngleImageFilter); REGISTER_TEST(otbMultiChannelRAndGAndNIRIndexImageFilterNew); REGISTER_TEST(otbLandsatTMIndexBright); REGISTER_TEST(otbMultiChannelRAndBAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbMultiChannelRAndNIRVegetationIndexImageFilterNew); REGISTER_TEST(otbLandsatTMBrightTest); REGISTER_TEST(otbLandsatTMThinCloudTest); REGISTER_TEST(otbISUMultiChannelRAndNIRIndexImageFilter); REGISTER_TEST(otbAVIRAndGAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbMultiChannelGAndRIndexImageFilter); REGISTER_TEST(otbLandsatTMIndexMIRTIR); REGISTER_TEST(otbLandsatTMIndexMIR1); REGISTER_TEST(otbRAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbLandsatTMVegetationTest); REGISTER_TEST(otbEVIRAndBAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbNDBITM4AndTM5IndexImageFilter); REGISTER_TEST(otbLandsatTMIndexNDBBBI); REGISTER_TEST(otbIBGAndRAndNIRIndexImageFilter); REGISTER_TEST(otbGAndRIndexImageFilterNew); REGISTER_TEST(otbEVIMultiChannelRAndBAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbNDBIMultiChannelTM4AndTM5IndexImageFilter); REGISTER_TEST(otbMultiChannelGAndRIndexImageFilterNew); REGISTER_TEST(otbNDWIWaterIndexImageFilter); REGISTER_TEST(otbLandsatTMIndexTIR); REGISTER_TEST(otbTSARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbLandsatTMLinguisticLabels); REGISTER_TEST(otbNDWIMultiChannelWaterIndexImageFilter); REGISTER_TEST(otbWDVIMultiChannelRAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbLandsatTMIndexNDSIVis); REGISTER_TEST(otbRAndBAndNIRVegetationIndexImageFilterNew); REGISTER_TEST(otbLandsatTMIndexNIR); REGISTER_TEST(otbSetASetBRAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbLandsatTMKernelSpectralRules); REGISTER_TEST(otbLandsatTMKernelSpectralRulesWithImage); REGISTER_TEST(otbLandsatTMIndexNDBSI); REGISTER_TEST(otbTSARVIRAndBAndNIRVegetationIndexImageFilter); REGISTER_TEST(otbLandsatTMThickCloudTest); } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLAIFromNDVILogarithmicFunctorTest.cxx000066400000000000000000000031001301006202600312230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVegetationIndicesFunctor.h" int otbLAIFromNDVILogarithmic(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::Functor::LAIFromNDVILogarithmic FunctorType; FunctorType laiFunct = FunctorType(); double redValue = (::atof(argv[1])); double nirValue = (::atof(argv[2])); double ndviSoil(::atof(argv[3])); double ndviInf(::atof(argv[4])); double extCoef(::atof(argv[5])); double ndvi = (nirValue-redValue)/(nirValue+redValue); double goodResult = -1/extCoef*vcl_log((ndvi-ndviInf)/(ndviSoil-ndviInf)); laiFunct.SetNdviInf(ndviInf); laiFunct.SetNdviSoil(ndviSoil); laiFunct.SetExtinctionCoefficient(extCoef); laiFunct.SetRedIndex(1); laiFunct.SetNIRIndex(2); itk::VariableLengthVector pixel; pixel.Reserve(2); pixel[0] = redValue; pixel[1] = nirValue; double result = laiFunct(pixel); if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLAIFromReflectancesLinearFunctorTest.cxx000066400000000000000000000026451301006202600320460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbVegetationIndicesFunctor.h" int otbLAIFromReflectancesLinear(int itkNotUsed(argc), char * argv[]) { typedef double PixelType; typedef otb::Functor::LAIFromReflectancesLinear FunctorType; FunctorType laiFunct = FunctorType(); double redValue = (::atof(argv[1])); double nirValue = (::atof(argv[2])); double redCoef(::atof(argv[3])); double nirCoef(::atof(argv[4])); double goodResult = redCoef*redValue+nirCoef*nirValue; laiFunct.SetRedCoef(redCoef); laiFunct.SetNirCoef(nirCoef); laiFunct.SetRedIndex(1); laiFunct.SetNIRIndex(2); itk::VariableLengthVector pixel; pixel.Reserve(2); pixel[0] = redValue; pixel[1] = nirValue; double result = laiFunct(pixel); if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMBrightTest.cxx000066400000000000000000000036641301006202600265730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLandsatTMIndices.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include #include int otbLandsatTMBrightTest(int itkNotUsed(argc), char * argv[]) { typedef float InputPixelType; typedef double OutputPixelType; typedef otb::VectorImage< InputPixelType, 2 > InputImageType; typedef otb::Image< OutputPixelType, 2 > OutputImageType; typedef otb::ImageFileReader< InputImageType > ReaderType; typedef otb::ImageFileWriter< OutputImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); WriterType::Pointer writer = WriterType::New(); writer->SetFileName( argv[2] ); typedef otb::Functor::LandsatTM::Bright R1FunctorType; R1FunctorType r1Funct = R1FunctorType(); r1Funct.SetDegree(otb::Functor::LandsatTM::HundredsKelvin); r1Funct.SetReflectance(otb::Functor::LandsatTM::Thousands); r1Funct.SetSAT(otb::Functor::LandsatTM::L5); typedef itk::UnaryFunctorImageFilter< InputImageType, OutputImageType, R1FunctorType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexBIOTest.cxx000066400000000000000000000031421301006202600267440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexBIO(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::BIO FunctorType; FunctorType bioFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = ((TM5+TM3)-(TM4+TM1))/((TM5+TM3)+(TM4+TM1)); std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = bioFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexBrightTest.cxx000066400000000000000000000031441301006202600275540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexBright(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::Bright FunctorType; FunctorType brightFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = (TM1+TM2+2*TM3+2*TM4+TM5+TM7)/8.0; std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = brightFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexMIR1Test.cxx000066400000000000000000000030761301006202600270510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexMIR1(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::MIR1 FunctorType; FunctorType mir1Funct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = TM5; std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = mir1Funct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexMIR2Test.cxx000066400000000000000000000030761301006202600270520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexMIR2(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::MIR2 FunctorType; FunctorType mir2Funct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = TM7; std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = mir2Funct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexMIRTIRTest.cxx000066400000000000000000000031361301006202600273440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexMIRTIR(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::MIRTIR FunctorType; FunctorType mirtirFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = 255*(1-TM5)*(TM62+100)/100.; std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = mirtirFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexNDBBBITest.cxx000066400000000000000000000032031301006202600272510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexNDBBBI(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::NDBBBI FunctorType; FunctorType ndbbbiFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = (TM1-TM5)/(TM1+TM5+ndbbbiFunct.GetEpsilonToBeConsideredAsZero()); std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = ndbbbiFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexNDBSITest.cxx000066400000000000000000000031761301006202600272010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexNDBSI(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::NDBSI FunctorType; FunctorType ndbsiFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = (TM5-TM4)/(TM5+TM4+ndbsiFunct.GetEpsilonToBeConsideredAsZero()); std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = ndbsiFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexNDSITest.cxx000066400000000000000000000031711301006202600270720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexNDSI(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::NDSI FunctorType; FunctorType ndsiFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = (TM2-TM5)/(TM2+TM5+ndsiFunct.GetEpsilonToBeConsideredAsZero()); std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = ndsiFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexNDSIVisTest.cxx000066400000000000000000000032521301006202600275540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexNDSIVis(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::NDSIVis FunctorType; FunctorType ndsiVisFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double vis = (TM1+TM2+TM3)/3.0; double goodResult = (vis-TM5)/(vis+TM5+ndsiVisFunct.GetEpsilonToBeConsideredAsZero()); std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = ndsiVisFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexNDVITest.cxx000066400000000000000000000031711301006202600270750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexNDVI(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::NDVI FunctorType; FunctorType ndviFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = (TM4-TM3)/(TM4+TM3+ndviFunct.GetEpsilonToBeConsideredAsZero()); std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = ndviFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexNIRTest.cxx000066400000000000000000000030721301006202600267650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexNIR(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::NIR FunctorType; FunctorType nirFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = TM4; std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = nirFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexTIRTest.cxx000066400000000000000000000044061301006202600267750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexTIR(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > L7InputPixelType; typedef itk::FixedArray< double, 7 > L5InputPixelType; typedef otb::Functor::LandsatTM::TIR L7FunctorType; L7FunctorType tirFunctL7 = L7FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM60 = (::atof(argv[6])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); tirFunctL7.SetSAT(otb::Functor::LandsatTM::L7); double goodResult = TM62; std::cout << goodResult; L7InputPixelType pixelL7; pixelL7[0] = TM1; pixelL7[1] = TM2; pixelL7[2] = TM3; pixelL7[3] = TM4; pixelL7[4] = TM5; pixelL7[5] = TM61; pixelL7[6] = TM62; pixelL7[7] = TM7; double result = tirFunctL7(pixelL7); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; typedef otb::Functor::LandsatTM::TIR L5FunctorType; L5FunctorType tirFunctL5 = L5FunctorType(); tirFunctL5.SetSAT(otb::Functor::LandsatTM::L5); goodResult = TM60; std::cout << goodResult; L5InputPixelType pixelL5; pixelL5[0] = TM1; pixelL5[1] = TM2; pixelL5[2] = TM3; pixelL5[3] = TM4; pixelL5[4] = TM5; pixelL5[5] = TM60; pixelL5[6] = TM7; result = tirFunctL5(pixelL5); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMIndexVisTest.cxx000066400000000000000000000031101301006202600270670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMIndexVis(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::Vis FunctorType; FunctorType visFunct = FunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); double goodResult = (TM1+TM2+TM3)/3.0; std::cout << goodResult; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; double result = visFunct(pixel); std::cout << " " << result << std::endl; if( result!=goodResult ) return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMKernelSpectralRules.cxx000066400000000000000000000332071301006202600304410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" #include #include #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "itkImageRegionConstIterator.h" #include int computeRules(double TM1, double TM2, double TM3, double TM4, double TM5, double TM61, double TM62, double TM7) { typedef double PrecisionType; typedef itk::FixedArray< PrecisionType, 8 > InputPixelType; typedef unsigned char OutputPixelType; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; std::vector< PrecisionType > v13; v13.push_back(TM1); v13.push_back(TM3); PrecisionType max13 = *(max_element ( v13.begin(), v13.end() )); std::vector< PrecisionType > v123; v123.push_back(TM1); v123.push_back(TM2); v123.push_back(TM3); PrecisionType max123 = *(max_element ( v123.begin(), v123.end() )); PrecisionType min123 = *(min_element ( v123.begin(), v123.end() )); std::vector< PrecisionType > v12347; v12347.push_back(TM1); v12347.push_back(TM2); v12347.push_back(TM3); v12347.push_back(TM4); v12347.push_back(TM7); PrecisionType max12347 = *(max_element ( v12347.begin(), v12347.end() )); PrecisionType min12347 = *(min_element ( v12347.begin(), v12347.end() )); std::vector< PrecisionType > v234; v234.push_back(TM2); v234.push_back(TM3); v234.push_back(TM4); PrecisionType max234 = *(max_element ( v234.begin(), v234.end() )); std::vector< PrecisionType > v45; v45.push_back(TM4); v45.push_back(TM5); PrecisionType max45 = *(max_element ( v45.begin(), v45.end() )); PrecisionType TV1 = 0.7; PrecisionType TV2 = 0.5; typedef otb::Functor::LandsatTM::ThickCloudsSpectralRule R1FunctorType; R1FunctorType r1Funct = R1FunctorType(); OutputPixelType result = r1Funct(pixel); OutputPixelType goodResult = static_cast( ( ((min123 >= (TV1 * max123)) && (max123 <= TV1 * TM4)) || ((TM2 >= TV1 * max13) && (max123 <= TM4))) && (TM5 <= TV1 * TM4) && (TM5 >= TV1 * max123) && (TM7 <= TV1 * TM4)); if( result!=goodResult ) { std::cerr << "Rule 1 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::ThinCloudsSpectralRule R2FunctorType; R2FunctorType r2Funct = R2FunctorType(); result = r2Funct(pixel); goodResult = static_cast((min123 >= (TV1 * max123)) && (TM4 >= max123) && !(TM1<=TM2 && TM2<=TM3 && TM3<=TM4 && TM3 >= TV1*TM4) && (TM4 >= TV1*TM5) && (TM5 >= TV1*TM4) && (TM5 >= TV1*max123) && (TM5 >= TV1*TM7)); if( result!=goodResult ) { std::cerr << "Rule 2 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::SnowOrIceSpectralRule R3FunctorType; R3FunctorType r3Funct = R3FunctorType(); result = r3Funct(pixel); goodResult = static_cast((min123 >= (TV1 * max123)) && (TM4 >= TV1 * max123) && (TM5 <= TV2 * TM4) && (TM5 <= TV1* min123) && (TM7 <= TV2 * TM4) && (TM7 <= TV1*min123)); if( result!=goodResult ) { std::cerr << "Rule 3 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::WaterOrShadowSpectralRule R4FunctorType; R4FunctorType r4Funct = R4FunctorType(); result = r4Funct(pixel); goodResult = static_cast((TM1 >= TM2) && (TM2 >= TM3) && (TM3 >= TM4) && (TM4 >= TM5) && (TM4 >= TM7)); if( result!=goodResult ) { std::cerr << "Rule 4 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::PitbogOrGreenhouseSpectralRule R5FunctorType; R5FunctorType r5Funct = R5FunctorType(); result = r5Funct(pixel); goodResult = static_cast((TM3 >= TV1 * TM1) && (TM1 >= TV1 * TM3) && (max123 <= TV1 * TM4) && (TM5 <= TV1 * TM4) && (TM3 >= TV2 * TM5) && (min123 >= TV1 * TM7)); if( result!=goodResult ) { std::cerr << "Rule 5 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::DominantBlueSpectralRule R6FunctorType; R6FunctorType r6Funct = R6FunctorType(); result = r6Funct(pixel); goodResult = static_cast((TM1 >= TV1 * TM2) && (TM1 >= TV1 * TM3) && (TM1 >= TV1 * TM4) && (TM1 >= TV1 * TM5) && (TM1 >= TV1 * TM7)); if( result!=goodResult ) { std::cerr << "Rule 6 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::VegetationSpectralRule R7FunctorType; R7FunctorType r7Funct = R7FunctorType(); result = r7Funct(pixel); goodResult = static_cast((TM2 >= TV2 * TM1) && (TM2 >= TV1 * TM3) && (TM3 < TV1 * TM4) && (TM4 > max123) && (TM5 < TV1 * TM4) && (TM5 >= TV1 * TM3) && (TM7 < TV1 * TM5)); if( result!=goodResult ) { std::cerr << "Rule 7 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::RangelandSpectralRule R8FunctorType; R8FunctorType r8Funct = R8FunctorType(); result = r8Funct(pixel); goodResult = static_cast((TM2 >= TV2 * TM1) && (TM2 >= TV1 * TM3) && (TM4 > max123) && (TM3 < TV1 * TM4) && (TM4 >= TV1 * TM5) && (TM5 >= TV1 * TM4) && (TM5 > max123) && (TM7 < TV1 * max45) && (TM5 >= TM7)); if( result!=goodResult ) { std::cerr << "Rule 8 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::BarrenLandOrBuiltUpOrCloudsSpectralRule R9FunctorType; R9FunctorType r9Funct = R9FunctorType(); result = r9Funct(pixel); goodResult = static_cast((TM3 >= TV2 * TM1) && (TM3 >= TV1 * TM2) && (TM4 >= TV1 * max123) && (TM5 >= max123) && (TM5 >= TV1 * TM4) && (TM5 >= TV1 * TM7) && (TM7 >= TV2 * max45)); if( result!=goodResult ) { std::cerr << "Rule 9 " << goodResult << " " << result << std::endl; std::cerr << TM1 << " " << TM2 << " " << TM3 << " " << TM4 << " " << TM5 << " " << TM7 << std::endl; std::cerr << max123 << " " << min123 << " " << max45 << " " << max234 << " " << min12347 << " " << max12347 << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::FlatResponseBarrenLandOrBuiltUpSpectralRule R10FunctorType; R10FunctorType r10Funct = R10FunctorType(); result = r10Funct(pixel); goodResult = static_cast((TM5 >= TV1 * max12347) && (min12347 >= TV2 * TM5)); if( result!=goodResult ) { std::cerr << "Rule 10 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::ShadowWithBarrenLandSpectralRule R11FunctorType; R11FunctorType r11Funct = R11FunctorType(); result = r11Funct(pixel); goodResult = static_cast((TM1 >= TM2 ) && (TM2 >= TM3) && (TM3 >= TV1 * TM4) && (TM1 >= TM5) && (TM5 >= TV1 * TM4) && (TM5 >= TV2 * TM7)); if( result!=goodResult ) { std::cerr << "Rule 11 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::ShadowWithVegetationSpectralRule R12FunctorType; R12FunctorType r12Funct = R12FunctorType(); result = r12Funct(pixel); goodResult = static_cast((TM1 >= TM2) && (TM2 >= TM3) && (TM1 >= TV2 * TM4) && (TM3 < TV1 * TM4) && (TM5 < TV1 * TM4) && (TM3 >= TV2 * TM5) && (TM7 < TV1 * TM4)); if( result!=goodResult ) { std::cerr << "Rule 12 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::ShadowCloudOrSnowSpectralRule R13FunctorType; R13FunctorType r13Funct = R13FunctorType(); result = r13Funct(pixel); goodResult = static_cast((TM1 >= TV1 * max234) && (max234 >= TV1 * TM1) && (TM5 < TM1) && (TM7 < TV1 * TM1)); if( result!=goodResult ) { std::cerr << "Rule 13 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } typedef otb::Functor::LandsatTM::WetlandSpectralRule R14FunctorType; R14FunctorType r14Funct = R14FunctorType(); result = r14Funct(pixel); goodResult = static_cast((TM1 >= TM2) && (TM2 >= TM3) && (TM1 >= TV1 * TM4) && (TM3 < TM4) && (TM4 >= TV1 * TM5) && (TM5 >= TV1 * TM4) && (TM3 >= TV2 * TM5) && (TM5 >= TM7)); if( result!=goodResult ) { std::cerr << "Rule 14 " << goodResult << " " << result << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbLandsatTMKernelSpectralRules(int itkNotUsed(argc), char * argv[]) { double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); return computeRules(TM1, TM2, TM3, TM4, TM5, TM61, TM62, TM7); } int otbLandsatTMKernelSpectralRulesWithImage(int itkNotUsed(argc), char * argv[]) { typedef double InputPixelType; typedef otb::VectorImage< InputPixelType, 2 > InputImageType; typedef otb::ImageFileReader< InputImageType > ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); reader->Update(); typedef itk::ImageRegionConstIterator< InputImageType > IteratorType; IteratorType it(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); it.GoToBegin(); if( it.Get().Size() != 7 && it.Get().Size() != 8) { std::cerr << " Image must have either 7 or 8 bands " << std::endl; return EXIT_FAILURE; } while(! it.IsAtEnd() ) { InputImageType::PixelType pix = it.Get(); int returnCode = EXIT_FAILURE; if( pix.Size() == 7 ) { returnCode = computeRules(pix[0], pix[1], pix[2], pix[3], pix[4], pix[5], pix[5], pix[6]); } if( pix.Size() == 8 ) { returnCode = computeRules(pix[0], pix[1], pix[2], pix[3], pix[4], pix[5], pix[6], pix[7]); } if( returnCode == EXIT_FAILURE ) { return EXIT_FAILURE; } ++it; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMLinguisticLabelsTest.cxx000066400000000000000000000116231301006202600306030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" int otbLandsatTMLinguisticLabels(int itkNotUsed(argc), char * argv[]) { typedef double OutputPixelType; typedef itk::FixedArray< double, 8 > InputPixelType; typedef otb::Functor::LandsatTM::LinguisticVariables LVFunctorType; LVFunctorType lvFunct = LVFunctorType(); double TM1 = (::atof(argv[1])); double TM2 = (::atof(argv[2])); double TM3 = (::atof(argv[3])); double TM4 = (::atof(argv[4])); double TM5 = (::atof(argv[5])); double TM61 = (::atof(argv[6])); double TM62 = (::atof(argv[7])); double TM7 = (::atof(argv[8])); unsigned int lo = LVFunctorType::Low; unsigned int me = LVFunctorType::Medium; unsigned int hi = LVFunctorType::High; InputPixelType pixel; pixel[0] = TM1; pixel[1] = TM2; pixel[2] = TM3; pixel[3] = TM4; pixel[4] = TM5; pixel[5] = TM61; pixel[6] = TM62; pixel[7] = TM7; OutputPixelType bright = otb::Functor::LandsatTM::Bright()( pixel ); OutputPixelType vis = otb::Functor::LandsatTM::Vis()( pixel ); OutputPixelType nir = otb::Functor::LandsatTM::NIR()( pixel ); OutputPixelType mir1 = otb::Functor::LandsatTM::MIR1()( pixel ); OutputPixelType mir2 = otb::Functor::LandsatTM::MIR2()( pixel ); OutputPixelType tir = otb::Functor::LandsatTM::TIR()( pixel ); OutputPixelType mirtir = otb::Functor::LandsatTM::MIRTIR()( pixel ); OutputPixelType ndsivis = otb::Functor::LandsatTM::NDSIVis()( pixel ); OutputPixelType ndbbbi = otb::Functor::LandsatTM::NDBBBI()( pixel ); OutputPixelType ndvi = otb::Functor::LandsatTM::NDVI()( pixel ); OutputPixelType ndbsi = otb::Functor::LandsatTM::NDBSI()( pixel ); LVFunctorType::OutputPixelType result = lvFunct( pixel ); // Bright { unsigned int goodResult = lo; if( bright > 40/255. ) goodResult = me; if( bright > 60/255. ) goodResult = hi; if( result[ LVFunctorType::bright ] != goodResult ) return EXIT_FAILURE; } // Vis { unsigned int goodResult = lo; if( vis > 30/255. ) goodResult = me; if( vis > 50/255. ) goodResult = hi; if( result[ LVFunctorType::vis ] != goodResult ) return EXIT_FAILURE; } // Nir { unsigned int goodResult = lo; if( nir > 40/255. ) goodResult = me; if( nir > 60/255. ) goodResult = hi; if( result[ LVFunctorType::nir ] != goodResult ) return EXIT_FAILURE; } // Mir1 { unsigned int goodResult = lo; if( mir1 > 40/255. ) goodResult = me; if( mir1 > 60/255. ) goodResult = hi; if( result[ LVFunctorType::mir1 ] != goodResult ) return EXIT_FAILURE; } // Mir2 { unsigned int goodResult = lo; if( mir2 > 30/255. ) goodResult = me; if( mir2 > 50/255. ) goodResult = hi; if( result[ LVFunctorType::mir2 ] != goodResult ) return EXIT_FAILURE; } // Tir { unsigned int goodResult = lo; if( tir > 0 ) goodResult = me; if( tir > 28 ) goodResult = hi; if( result[ LVFunctorType::tir ] != goodResult ) return EXIT_FAILURE; } // Mirtir { unsigned int goodResult = lo; if( mirtir > 180 ) goodResult = me; if( mirtir > 220 ) goodResult = hi; if( result[ LVFunctorType::mirtir ] != goodResult ) return EXIT_FAILURE; } // Ndsivis { unsigned int goodResult = lo; if( ndsivis > 0.0 ) goodResult = me; if( ndsivis > 0.5 ) goodResult = hi; if( result[ LVFunctorType::ndsivis ] != goodResult ) return EXIT_FAILURE; } // Ndbbbi { unsigned int goodResult = lo; if( ndbbbi > -0.20 ) goodResult = me; if( ndbbbi > 0.10 ) goodResult = hi; if( result[ LVFunctorType::ndbbbi ] != goodResult ) return EXIT_FAILURE; } // Ndvi { unsigned int goodResult = lo; if( ndvi > 0.35 ) goodResult = me; if( ndvi > 0.60 ) goodResult = hi; if( result[ LVFunctorType::ndvi ] != goodResult ) return EXIT_FAILURE; } // Ndbsi { unsigned int goodResult = lo; if( ndbsi > -0.20 ) goodResult = me; if( ndbsi > 0.0 ) goodResult = hi; if( result[ LVFunctorType::ndbsi ] != goodResult ) return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMThickCloudTest.cxx000066400000000000000000000037141301006202600274010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLandsatTMIndices.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include #include int otbLandsatTMThickCloudTest(int itkNotUsed(argc), char * argv[]) { typedef double InputPixelType; typedef double OutputPixelType; typedef otb::VectorImage< InputPixelType, 2 > InputImageType; typedef otb::Image< OutputPixelType, 2 > OutputImageType; typedef otb::ImageFileReader< InputImageType > ReaderType; typedef otb::ImageFileWriter< OutputImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); WriterType::Pointer writer = WriterType::New(); writer->SetFileName( argv[2] ); typedef otb::Functor::LandsatTM::ThickCloudsSpectralRule R1FunctorType; typedef itk::UnaryFunctorImageFilter< InputImageType, OutputImageType, R1FunctorType > FilterType; FilterType::Pointer filter = FilterType::New(); (filter->GetFunctor()).SetDegree(otb::Functor::LandsatTM::HundredsKelvin); (filter->GetFunctor()).SetReflectance(otb::Functor::LandsatTM::Thousands); (filter->GetFunctor()).SetSAT(otb::Functor::LandsatTM::L5); filter->SetInput( reader->GetOutput() ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMThinCloudTest.cxx000066400000000000000000000037211301006202600272370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include #include int otbLandsatTMThinCloudTest(int itkNotUsed(argc), char * argv[]) { typedef double InputPixelType; typedef double OutputPixelType; typedef otb::VectorImage< InputPixelType, 2 > InputImageType; typedef otb::Image< OutputPixelType, 2 > OutputImageType; typedef otb::ImageFileReader< InputImageType > ReaderType; typedef otb::ImageFileWriter< OutputImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); WriterType::Pointer writer = WriterType::New(); writer->SetFileName( argv[2] ); typedef otb::Functor::LandsatTM::ThinCloudsSpectralRule R1FunctorType; typedef itk::UnaryFunctorImageFilter< InputImageType, OutputImageType, R1FunctorType > FilterType; FilterType::Pointer filter = FilterType::New(); (filter->GetFunctor()).SetDegree(otb::Functor::LandsatTM::HundredsKelvin); (filter->GetFunctor()).SetReflectance(otb::Functor::LandsatTM::Thousands); (filter->GetFunctor()).SetSAT(otb::Functor::LandsatTM::L5); filter->SetInput( reader->GetOutput() ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbLandsatTMVegetationTest.cxx000066400000000000000000000036461301006202600274610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbLandsatTMIndices.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include #include int otbLandsatTMVegetationTest(int itkNotUsed(argc), char * argv[]) { typedef double InputPixelType; typedef unsigned char OutputPixelType; typedef otb::VectorImage< InputPixelType, 2 > InputImageType; typedef otb::Image< OutputPixelType, 2 > OutputImageType; typedef otb::ImageFileReader< InputImageType > ReaderType; typedef otb::ImageFileWriter< OutputImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); WriterType::Pointer writer = WriterType::New(); writer->SetFileName( argv[2] ); typedef otb::Functor::LandsatTM::VegetationSpectralRule R1FunctorType; R1FunctorType r1Funct = R1FunctorType(); r1Funct.SetDegree(otb::Functor::LandsatTM::HundredsKelvin); r1Funct.SetReflectance(otb::Functor::LandsatTM::Thousands); typedef itk::UnaryFunctorImageFilter< InputImageType, OutputImageType, R1FunctorType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbMultiChannelGAndRIndexImageFilter.cxx000066400000000000000000000061721301006202600313010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelGAndRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVegetationIndicesFunctor.h" template int generic_MultiChannelGAndRIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelGAndRIndexImageFilter MultiChannelGAndRIndexImageFilterType; // Instantiating object typename MultiChannelGAndRIndexImageFilterType::Pointer filter = MultiChannelGAndRIndexImageFilterType::New(); typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int greenChannel(::atoi(argv[3])); unsigned int redChannel(::atoi(argv[4])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetGreenIndex(greenChannel); filter->SetRedIndex(redChannel); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbMultiChannelGAndRIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "IR") return (generic_MultiChannelGAndRIndexImageFilter > (argc, argv)); else if (strArgv == "IC") return (generic_MultiChannelGAndRIndexImageFilter > (argc, argv)); else if (strArgv == "IB") return (generic_MultiChannelGAndRIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbMultiChannelGAndRIndexImageFilterNew.cxx000066400000000000000000000024651301006202600317540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelGAndRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" int otbMultiChannelGAndRIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::MultiChannelGAndRIndexImageFilter MultiChannelGAndRIndexImageFilterType; // Instantiating object MultiChannelGAndRIndexImageFilterType::Pointer filter = MultiChannelGAndRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000054611301006202600342370ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template int generic_MultiChannelRAndBAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelRAndBAndNIRIndexImageFilter MultiChannelRAndBAndNIRIndexImageFilterType; // Instantiating object typename MultiChannelRAndBAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndBAndNIRIndexImageFilterType::New(); typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int blueChannel(::atoi(argv[4])); unsigned int nirChannel(::atoi(argv[5])); double gamma(::atof(argv[6])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetBlueIndex(blueChannel); filter->SetNIRIndex(nirChannel); filter->GetFunctor().SetGamma(gamma); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbMultiChannelRAndBAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "ARVI") return (generic_MultiChannelRAndBAndNIRVegetationIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } otbMultiChannelRAndBAndNIRVegetationIndexImageFilterNew.cxx000066400000000000000000000024571301006202600347130ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" int otbMultiChannelRAndBAndNIRVegetationIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::MultiChannelRAndBAndNIRIndexImageFilter MultiChannelRAndBAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndBAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndBAndNIRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbMultiChannelRAndGAndNIRIndexImageFilterNew.cxx000066400000000000000000000024451301006202600327460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndGAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" int otbMultiChannelRAndGAndNIRIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::MultiChannelRAndGAndNIRIndexImageFilter MultiChannelRAndGAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndGAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndGAndNIRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbMultiChannelRAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000130141301006202600335620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template int generic_MultiChannelRAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelRAndNIRIndexImageFilter MultiChannelRAndNIRIndexImageFilterType; // Instantiating object typename MultiChannelRAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndNIRIndexImageFilterType::New(); typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int nirChannel(::atoi(argv[4])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetNIRIndex(nirChannel); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbMultiChannelRAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "NDVI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "RVI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "SAVI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "TSAVI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "MSAVI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "MSAVI2") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "GEMI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "IPVI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "TNDVI") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "LAIFormosat2") return (generic_MultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } otbMultiChannelRAndNIRVegetationIndexImageFilterNew.cxx000066400000000000000000000024271301006202600341630ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" int otbMultiChannelRAndNIRVegetationIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::MultiChannelRAndNIRIndexImageFilter MultiChannelRAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndNIRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbNDBIMultiChannelTM4AndTM5IndexImageFilter.cxx000066400000000000000000000043011301006202600323500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkUnaryFunctorImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBuiltUpIndicesFunctor.h" int otbNDBIMultiChannelTM4AndTM5IndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::NDBI FunctorType; typedef itk::UnaryFunctorImageFilter UnaryFunctorImageFilterType; // Instantiating object UnaryFunctorImageFilterType::Pointer filter = UnaryFunctorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int tm4Channel(::atoi(argv[3])); unsigned int tm5Channel(::atoi(argv[4])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->GetFunctor().SetIndex1(tm4Channel); filter->GetFunctor().SetIndex2(tm5Channel); //filter->GetFunctor().SetTM5Index(tm5Channel); //filter->GetFunctor().SetTM4Index(tm4Channel); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbNDBITM4AndTM5IndexImageFilter.cxx000066400000000000000000000044751301006202600300600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkBinaryFunctorImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbBuiltUpIndicesFunctor.h" int otbNDBITM4AndTM5IndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputTM4ImageType; typedef otb::Image InputTM5ImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader TM4ReaderType; typedef otb::ImageFileReader TM5ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::NDBI FunctorType; typedef itk::BinaryFunctorImageFilter BinaryFunctorImageFilterType; // Instantiating object BinaryFunctorImageFilterType::Pointer filter = BinaryFunctorImageFilterType::New(); TM4ReaderType::Pointer readerTM4 = TM4ReaderType::New(); TM5ReaderType::Pointer readerTM5 = TM5ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilenameTM4 = argv[1]; const char * inputFilenameTM5 = argv[2]; const char * outputFilename = argv[3]; readerTM4->SetFileName(inputFilenameTM4); readerTM5->SetFileName(inputFilenameTM5); writer->SetFileName(outputFilename); filter->SetInput1(readerTM4->GetOutput()); filter->SetInput2(readerTM5->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbNDVIDataNodeFeatureFunction.cxx000066400000000000000000000124671301006202600301270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbNDVIDataNodeFeatureFunction.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataIntoImageProjectionFilter.h" #include "otbVectorDataFileWriter.h" #include "itkPreOrderTreeIterator.h" int otbNDVIDataNodeFeatureFunctionNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::NDVIDataNodeFeatureFunction NDVIDataNodeFeaturefunctionType; NDVIDataNodeFeaturefunctionType::Pointer NDVIFeature = NDVIDataNodeFeaturefunctionType::New(); std::cout << NDVIFeature << std::endl; return EXIT_SUCCESS; } int otbNDVIDataNodeFeatureFunction(int itkNotUsed(argc), char* argv[]) { const char * inputVD = argv[1]; const char * inputImg = argv[2]; const char * DEMDir = argv[3]; const char * outputVD = argv[4]; int DisplayWarnings = atoi(argv[5]); typedef double CoordRepType; typedef double PrecisionType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ImageReaderType; typedef otb::VectorData VectorDataType; typedef VectorDataType::DataNodeType DataNodeType; typedef otb::VectorDataFileReader VectorDataReaderType; typedef otb::VectorDataIntoImageProjectionFilter VectorDataReProjFilter; typedef otb::VectorDataFileWriter VectorDataWriterType; typedef itk::PreOrderTreeIterator TreeIteratorType; typedef otb::NDVIDataNodeFeatureFunction NDVIDataNodeFeaturefunctionType; typedef NDVIDataNodeFeaturefunctionType::OutputType NDVIFeatureOutputType; ImageReaderType::Pointer imgReader = ImageReaderType::New(); VectorDataReaderType::Pointer vdReader = VectorDataReaderType::New(); VectorDataReProjFilter::Pointer vdReProjFilter = VectorDataReProjFilter::New(); VectorDataWriterType::Pointer vdWriter = VectorDataWriterType::New(); NDVIDataNodeFeaturefunctionType::Pointer NDVIFeatureFunction = NDVIDataNodeFeaturefunctionType::New(); if (!DisplayWarnings) { imgReader->SetGlobalWarningDisplay(0); } otb::DEMHandler::Instance()->OpenDEMDirectory(DEMDir); vdReader->SetFileName(inputVD); vdReader->Update(); imgReader->SetFileName(inputImg); imgReader->UpdateOutputInformation(); imgReader->Update(); //Needed to set m_EndIndex, m_StartIndex in otbDataNodeImageFunction vdReProjFilter->SetInputImage(imgReader->GetOutput()); vdReProjFilter->SetInputVectorData(vdReader->GetOutput()); vdReProjFilter->SetUseOutputSpacingAndOriginFromImage(true); vdReProjFilter->Update(); /* std::cout<< "vdReProjFilter->GetOutput()->Size(): " << vdReProjFilter->GetOutput()->Size() << std::endl; */ NDVIFeatureFunction->SetREDChannelIndex(3); NDVIFeatureFunction->SetNIRChannelIndex(4); NDVIFeatureFunction->SetNDVIThreshold(0.047); NDVIFeatureFunction->SetInputImage(imgReader->GetOutput()); // Output VectorDataType::Pointer outVD = VectorDataType::New(); // Retrieving root node DataNodeType::Pointer root = outVD->GetDataTree()->GetRoot()->Get(); // Create the document node DataNodeType::Pointer document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); // Adding the layer to the data tree outVD->GetDataTree()->Add(document, root); // Create the folder node DataNodeType::Pointer folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); // Adding the layer to the data tree outVD->GetDataTree()->Add(folder, document); TreeIteratorType itVector(vdReProjFilter->GetOutput()->GetDataTree()); itVector.GoToBegin(); while (!itVector.IsAtEnd()) { if (itVector.Get()->IsLineFeature() || itVector.Get()->IsPolygonFeature()) { const DataNodeType::Pointer currentGeometry = itVector.Get(); NDVIFeatureOutputType currentResult; currentResult = NDVIFeatureFunction->Evaluate(*(currentGeometry.GetPointer())); currentGeometry->SetFieldAsDouble("NDVI", (double)(currentResult[0])); outVD->GetDataTree()->Add(currentGeometry, folder); } ++itVector; } vdWriter->SetInput(outVD); vdWriter->SetFileName(outputVD); vdWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbNDWIMultiChannelWaterIndexImageFilter.cxx000066400000000000000000000041331301006202600321050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkUnaryFunctorImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbWaterIndicesFunctor.h" int otbNDWIMultiChannelWaterIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::NDWI FunctorType; typedef itk::UnaryFunctorImageFilter UnaryFunctorImageFilterType; // Instantiating object UnaryFunctorImageFilterType::Pointer filter = UnaryFunctorImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int nirChannel(::atoi(argv[3])); unsigned int mirChannel(::atoi(argv[4])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->GetFunctor().SetNIRIndex(nirChannel); filter->GetFunctor().SetMIRIndex(mirChannel); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbNDWIWaterIndexImageFilter.cxx000066400000000000000000000044671301006202600276130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkBinaryFunctorImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbWaterIndicesFunctor.h" int otbNDWIWaterIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputNIRImageType; typedef otb::Image InputMIRImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileReader MIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::NDWI FunctorType; typedef itk::BinaryFunctorImageFilter BinaryFunctorImageFilterType; // Instantiating object BinaryFunctorImageFilterType::Pointer filter = BinaryFunctorImageFilterType::New(); NIRReaderType::Pointer readerNIR = NIRReaderType::New(); MIRReaderType::Pointer readerMIR = MIRReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilenameNIR = argv[1]; const char * inputFilenameMIR = argv[2]; const char * outputFilename = argv[3]; readerNIR->SetFileName(inputFilenameNIR); readerMIR->SetFileName(inputFilenameMIR); writer->SetFileName(outputFilename); filter->SetInput1(readerNIR->GetOutput()); filter->SetInput2(readerMIR->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbRAndBAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000062461301006202600320140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template int generic_RAndBAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader BReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::RAndBAndNIRIndexImageFilter RAndBAndNIRIndexImageFilterType; // Instantiating object typename RAndBAndNIRIndexImageFilterType::Pointer filter = RAndBAndNIRIndexImageFilterType::New(); typename RReaderType::Pointer readerR = RReaderType::New(); typename BReaderType::Pointer readerB = BReaderType::New(); typename NIRReaderType::Pointer readerNIR = NIRReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameB = argv[2]; const char * inputFilenameNIR = argv[3]; const char * outputFilename = argv[4]; double gamma(::atof(argv[5])); readerR->SetFileName(inputFilenameR); readerB->SetFileName(inputFilenameB); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputB(readerB->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); filter->GetFunctor().SetGamma(gamma); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbRAndBAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputBImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "ARVI") return (generic_RAndBAndNIRVegetationIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbRAndBAndNIRVegetationIndexImageFilterNew.cxx000066400000000000000000000026201301006202600324560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" int otbRAndBAndNIRVegetationIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputBImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::RAndBAndNIRIndexImageFilter RAndBAndNIRIndexImageFilterType; // Instantiating object RAndBAndNIRIndexImageFilterType::Pointer filter = RAndBAndNIRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbRAndGAndNIRVegetationIndexImageFilterNew.cxx000066400000000000000000000026201301006202600324630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndGAndNIRIndexImageFilter.h" #include "otbImage.h" int otbRAndGAndNIRVegetationIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputGImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::RAndGAndNIRIndexImageFilter RAndGAndNIRIndexImageFilterType; // Instantiating object RAndGAndNIRIndexImageFilterType::Pointer filter = RAndGAndNIRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbRAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000131131301006202600312560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template int generic_RAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::RAndNIRIndexImageFilter RAndNIRIndexImageFilterType; // Instantiating object typename RAndNIRIndexImageFilterType::Pointer filter = RAndNIRIndexImageFilterType::New(); typename RReaderType::Pointer readerR = RReaderType::New(); typename NIRReaderType::Pointer readerNIR = NIRReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameNIR = argv[2]; const char * outputFilename = argv[3]; readerR->SetFileName(inputFilenameR); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } int otbRAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "NDVI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "RVI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "SAVI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "TSAVI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "MSAVI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "MSAVI2") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "GEMI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "IPVI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "TNDVI") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else if (strArgv == "LAIFormosat2") return (generic_RAndNIRVegetationIndexImageFilter > (argc, argv)); else return EXIT_FAILURE; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbRAndNIRVegetationIndexImageFilterNew.cxx000066400000000000000000000024731301006202600317370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImage.h" int otbRAndNIRVegetationIndexImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::RAndNIRIndexImageFilter RAndNIRIndexImageFilterType; // Instantiating object RAndNIRIndexImageFilterType::Pointer filter = RAndNIRIndexImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbSetASetBMultiChannelRAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000051041301006202600350370ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template void generic_SetASetBMultiChannelRAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MultiChannelRAndNIRIndexImageFilter MultiChannelRAndNIRIndexImageFilterType; // Instantiating object typename MultiChannelRAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndNIRIndexImageFilterType::New(); typename ReaderType::Pointer reader = ReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); double a(::atof(argv[1])); double b(::atof(argv[2])); const char * inputFilename = argv[3]; const char * outputFilename = argv[4]; unsigned int redChannel(::atoi(argv[5])); unsigned int nirChannel(::atoi(argv[6])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); filter->SetRedIndex(redChannel); filter->SetNIRIndex(nirChannel); filter->GetFunctor().SetA(a); filter->GetFunctor().SetB(b); writer->SetInput(filter->GetOutput()); writer->Update(); } int otbSetASetBMultiChannelRAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "PVI") generic_SetASetBMultiChannelRAndNIRVegetationIndexImageFilter > (argc, argv); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbSetASetBRAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000053201301006202600326120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" template void generic_SetASetBRAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::RAndNIRIndexImageFilter RAndNIRIndexImageFilterType; // Instantiating object typename RAndNIRIndexImageFilterType::Pointer filter = RAndNIRIndexImageFilterType::New(); typename RReaderType::Pointer readerR = RReaderType::New(); typename NIRReaderType::Pointer readerNIR = NIRReaderType::New(); typename WriterType::Pointer writer = WriterType::New(); double a(::atof(argv[1])); double b(::atof(argv[2])); const char * inputFilenameR = argv[3]; const char * inputFilenameNIR = argv[4]; const char * outputFilename = argv[5]; readerR->SetFileName(inputFilenameR); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); filter->GetFunctor().SetA(a); filter->GetFunctor().SetB(b); writer->SetInput(filter->GetOutput()); writer->Update(); } int otbSetASetBRAndNIRVegetationIndexImageFilter(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; std::string strArgv(argv[1]); argc--; argv++; if (strArgv == "PVI") generic_SetASetBRAndNIRVegetationIndexImageFilter > (argc, argv); return EXIT_SUCCESS; } otbTSARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000050341301006202600351640ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbTSARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::TSARVI FunctorType; typedef otb::MultiChannelRAndBAndNIRIndexImageFilter MultiChannelRAndBAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndBAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndBAndNIRIndexImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int blueChannel(::atoi(argv[4])); unsigned int nirChannel(::atoi(argv[5])); double a(::atof(argv[6])); double b(::atof(argv[7])); double x(::atof(argv[8])); double gamma(::atof(argv[9])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetBlueIndex(blueChannel); filter->SetNIRIndex(nirChannel); filter->SetInput(reader->GetOutput()); filter->GetFunctor().SetA(a); filter->GetFunctor().SetB(b); filter->GetFunctor().SetX(x); filter->GetFunctor().SetGamma(gamma); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbTSARVIRAndBAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000056471301006202600327510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndBAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbTSARVIRAndBAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputBImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader BReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::TSARVI FunctorType; typedef otb::RAndBAndNIRIndexImageFilter RAndBAndNIRIndexImageFilterType; // Instantiating object RAndBAndNIRIndexImageFilterType::Pointer filter = RAndBAndNIRIndexImageFilterType::New(); RReaderType::Pointer readerR = RReaderType::New(); BReaderType::Pointer readerB = BReaderType::New(); NIRReaderType::Pointer readerNIR = NIRReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameB = argv[2]; const char * inputFilenameNIR = argv[3]; const char * outputFilename = argv[4]; double a(::atof(argv[5])); double b(::atof(argv[6])); double x(::atof(argv[7])); double gamma(::atof(argv[8])); readerR->SetFileName(inputFilenameR); readerB->SetFileName(inputFilenameB); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputB(readerB->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); filter->GetFunctor().SetA(a); filter->GetFunctor().SetB(b); filter->GetFunctor().SetX(x); filter->GetFunctor().SetGamma(gamma); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbWDVIMultiChannelRAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000042721301006202600342030ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Indices/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbMultiChannelRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbWDVIMultiChannelRAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::WDVI FunctorType; typedef otb::MultiChannelRAndNIRIndexImageFilter MultiChannelRAndNIRIndexImageFilterType; // Instantiating object MultiChannelRAndNIRIndexImageFilterType::Pointer filter = MultiChannelRAndNIRIndexImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int redChannel(::atoi(argv[3])); unsigned int nirChannel(::atoi(argv[4])); double s(::atof(argv[5])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->SetRedIndex(redChannel); filter->SetNIRIndex(nirChannel); filter->SetInput(reader->GetOutput()); filter->GetFunctor().SetS(s); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbWDVIRAndNIRVegetationIndexImageFilter.cxx000066400000000000000000000045021301006202600317520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbRAndNIRIndexImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbWDVIRAndNIRVegetationIndexImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image InputRImageType; typedef otb::Image InputNIRImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader RReaderType; typedef otb::ImageFileReader NIRReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::WDVI FunctorType; typedef otb::RAndNIRIndexImageFilter RAndNIRIndexImageFilterType; // Instantiating object RAndNIRIndexImageFilterType::Pointer filter = RAndNIRIndexImageFilterType::New(); RReaderType::Pointer readerR = RReaderType::New(); NIRReaderType::Pointer readerNIR = NIRReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilenameR = argv[1]; const char * inputFilenameNIR = argv[2]; const char * outputFilename = argv[3]; double s(::atof(argv[4])); readerR->SetFileName(inputFilenameR); readerNIR->SetFileName(inputFilenameNIR); writer->SetFileName(outputFilename); filter->SetInputR(readerR->GetOutput()); filter->SetInputNIR(readerNIR->GetOutput()); filter->GetFunctor().SetS(s); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Indices/test/otbWaterSqrtSpectralAngleImageFilter.cxx000066400000000000000000000042341301006202600314500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbWaterSqrtSpectralAngleImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbWaterSqrtSpectralAngleImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef otb::VectorImage InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::WaterSqrtSpectralAngleImageFilter WaterSqrtSpectralAngleImageFilterType; // Instantiating objects WaterSqrtSpectralAngleImageFilterType::Pointer filter = WaterSqrtSpectralAngleImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; unsigned int blueChannel(::atoi(argv[3])); unsigned int greenChannel(::atoi(argv[4])); unsigned int redChannel(::atoi(argv[5])); unsigned int nirChannel(::atoi(argv[6])); reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); filter->GetFunctor().SetBlueChannel(blueChannel); filter->GetFunctor().SetGreenChannel(greenChannel); filter->GetFunctor().SetRedChannel(redChannel); filter->GetFunctor().SetNIRChannel(nirChannel); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/LandSatClassifier/000077500000000000000000000000001301006202600225005ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/LandSatClassifier/CMakeLists.txt000066400000000000000000000000611301006202600252350ustar00rootroot00000000000000project(OTBLandSatClassifier) otb_module_impl() OTB-release-5.8/Modules/Radiometry/LandSatClassifier/include/000077500000000000000000000000001301006202600241235ustar00rootroot00000000000000otbLandsatTMSpectralRuleBasedClassifier.h000066400000000000000000000520431301006202600340470ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/LandSatClassifier/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLandsatTMSRBC_h #define otbLandsatTMSRBC_h #include "otbLandsatTMIndices.h" namespace otb { namespace Functor { namespace LandsatTM { /** \class SpectralRuleBasedClassifier * * \brief Implementation of the SpectralRuleBasedClassifier for * Landsat TM image land cover classification as described in table * IV of Baraldi et al. 2006, "Automatic Spectral Rule-Based * Preliminary Mapping of Calibrated Landsat TM and ETM+ Images", * IEEE Trans. on Geoscience and Remote Sensing, vol 44, no 9. This * classifier assumes that the input image is calibrated in * reflectances and in temperature. The reflectances can be given in * the 0-1 range (Normalized) or in 0-1000 (Thousands). Temperatures * can be given in Kelvin, in Kelvin*100 or in Celsius. Appropriate * accessors are available for setting these units. * * The OTB development team acknowledges the contribution of Andrea * Baraldi, who provided the correct set of threshold values for the * published rule set implementation to be reproduced. Andrea Baraldi * is the inventor of the Satellite Image Automatic Mapper TradeMark (SIAM) * software product conceived, developed and supported solely by * Baraldi Consultancy in Remote Sensing of Andrea Baraldi. * * \ingroup Functor * \ingroup Radiometry * \ingroup LandsatTMIndices * * \ingroup OTBLandSatClassifier */ template class SpectralRuleBasedClassifier : public KernelSpectralRule { public: // Spectral categories enum SpectralCategory { NOCLASS, // 0 -if the pixel is not classified; just for error // checking; different from SU, which is a real rejection // class TKCL, // 1 -thick clouds TNCL, // 2 -thin clouds; possible confusions with cold light toned // (highly reflective) barren land and range land SN, // 3 -snow ICSN, // 4 -ice or snow DPWASH, // 5 -deep clear water and shadow areas; possible confusions // with lava rocks SLWASH, // 6 -shallow clear water and shadow areas PBHNDVI, // 7 -pit bog with high NDVI PBMNDVI, // 8 -pit bog with medium NDVI PBLNDVI, // 9 -pit bog with low NDVI; possible confusions with // greenhouses SVHNIR, // 10 - strong vegetation with high NIR; includes broadleaved // decideous forests, vegetated cropland and pastures; // possible confusions with mixed forests SVLNIR, // 11 -strong vegetation with low NIR; includes evergreen // forests and mixed forests; possible confusions with // forest land in shadow areas AVHNIR, // 12 -average vegetation with high NIR; includes cropland and // pastures; possible confusions with evergreen forests // and mixed forests AVLNIR, // 13 -average vegetation with low NIR; includes evergreen // forests, especially coniferous; possible confusions // with forest land in shadow areas WVHNIR, // 14 -weak vegetation with high NIR; includes scarcely // vegetated areas WVLNIR, // 15 -weak vegetation with low NIR; includes forested wetland SSRHNIR, // 16 -strong shrub rangeland with high NIR; includes // herbaceous rangeland; possible confusions with shrub // and brush rangeland SSRLNIR, // 17 -strong shrub rangeland with low NIR; includes shrub // and brush rangeland; possible confusions with // herbaceous rangeland ASRHNIR, // 18 -average shrub rangeland with high NIR; includes // herbaceous rangeland; possible confusions with shrub // and brush rangeland ASRLNIR, // 19 -average shrub rangeland with low NIR; includes shrub // and brush rangeland; possible confusions with // herbaceous rangeland SHR, // 20 - strong herbaceous rangeland; possible confusions with // vegetated cropland ans pastures AHR, // 21 -average herbaceous rangeland; includes herbaceous // rangeland and barren land scarcely vegetated; possible // confusions with vegetated cropland and pastures DR, // 22 -dark rangeland; includes mixed rangeland eventually in // shadow areas and non forested wetland; possible // confusions with mixed urban or built up BBBHTIRF, // 23 -bright barren land or built up with high TIR and flat // spectral response; includes urban or built up and // concrete roads BBBHTIRNF, // 24 -bright barren land or built up with high TIR and non flat // spectral response; BBBLTIRF, // 25 -bright barren land or built up with low TIR and flat // spectral response; includes urban or built up and // concrete roads BBBLTIRNF, // 26 -bright barren land or built up with low TIR and non flat // spectral response; SBBHTIRF, // 27 -strong barren land or built up with high TIR and flat // spectral response; includes urban or built up and // concrete roads SBBHTIRNF, // 28 -strong barren land or built up with high TIR with non flat // spectral response; includes ploughed fields, barren // land -- including bare exposed rocks -- and beaches SBBLTIRF, // 29 -strong barren land or built up with low TIR and flat // spectral response; includes urban or built up and // concrete roads SBBLTIRNF, // 30 -strong barren land or built up with low TIR with non flat // spectral response; includes ploughed fields, barren // land -- including bare exposed rocks -- and beaches ABBHTIRF, // 31 -average barren land or built up with high TIR and flat // spectral response; includes urban or built up and // concrete roads ABBHTIRNF, // 32 -average barren land or built up with high TIR with non flat // spectral response ABBLTIRF, // 33 -average barren land or built up with low TIR and flat // spectral response; includes urban or built up and // concrete roads ABBLTIRNF, // 34 -average barren land or built up with low TIR with non flat // spectral response DBBHTIRF, // 35 -dark barren land or built up with high TIR and flat // spectral response; includes urban or built up land, // in particular parking lots, concrete roads, asphalt // roads, grey-brown tile roofs, tan composite shingle // roofs; possible confusions with barren land on dark // mountain slopes including burned areas and bare // exposed rocks, especially dark-toned soil DBBHTIRNF, // 36 -dark barren land or built up with high TIR and non // flat spectral response; includes barren land, bare // exposed rocks, especially dark-toned soil DBBLTIRF, // 37 -dark barren land or built up with low TIR and flat // spectral response; includes urban or built up land, // in particular parking lots, concrete roads, asphalt // roads, grey-brown tile roofs, tan composite shingle // roofs; possible confusions with barren land on dark // mountain slopes including burned areas and bare // exposed rocks, especially dark-toned soil DBBLTIRNF, // 38 -dark barren land or built up with low TIR and non // flat spectral response; includes barren land, bare // exposed rocks, especially dark-toned soil WR, // 39 -weak rangeland; includes herbaceous rangeland SHV, // 40 -shadow area with vegetation; possible confusions // with non forested wetland SHB, // 41 -shadow with barren land; includes also lava rock; // possible confusions with buil up areas, especially // asphalt roads SHCL, // 42 -clouds in shadow areas TWASHSN, // 43 -snow in shadow areas WE, // 44 -non forested wetland; possible confusions with // shadow areas with vegetation TWA, // 45 -turbid water; possible confusions with shadow areas SU // 46 -shadow areas or unknown pixels }; typedef typename TInput::ValueType PrecisionType; typedef bool OutputPixelType; /** Return the index name */ std::string GetName() const ITK_OVERRIDE { return "LandsatTM SpectralRuleBasedClassifier"; } SpectralRuleBasedClassifier() { } ~SpectralRuleBasedClassifier() ITK_OVERRIDE {} inline TOutput operator ()(const TInput& inputPixel) { // We normalize the pixel just once, so that the indices do not // need to do it TInput newPixel(this->PrepareValues( inputPixel )); // Get the linguistic variables typedef LinguisticVariables LVType; LVType lvf = LVType(); lvf.SetSAT( this->m_SAT ); typename LVType::OutputPixelType lv = lvf( newPixel ); typedef ThickCloudsSpectralRule TKCLSRType; TKCLSRType tkclsrf = TKCLSRType(); tkclsrf.SetTV1( this->m_TV1 ); tkclsrf.SetTV2( this->m_TV2 ); tkclsrf.SetSAT( this->m_SAT ); bool tkclsr = tkclsrf( newPixel ); typedef ThinCloudsSpectralRule TNCLSRType; TNCLSRType tnclsrf = TNCLSRType(); tnclsrf.SetTV1( this->m_TV1 ); tnclsrf.SetTV2( this->m_TV2 ); tnclsrf.SetSAT( this->m_SAT ); bool tnclsr = tnclsrf( newPixel ); bool lBright = (lv[ LVType::bright ] == LVType::Low); bool lVis = (lv[ LVType::vis ] == LVType::Low); bool lNIR = (lv[ LVType::nir ] == LVType::Low); bool hNDSIVis = (lv[ LVType::ndsivis ] == LVType::High); bool lMIR1 = (lv[ LVType::mir1 ] == LVType::Low); bool lMIR2 = (lv[ LVType::mir2 ] == LVType::Low); bool hTIR = (lv[ LVType::tir ] == LVType::High); bool hMIRTIR = (lv[ LVType::mirtir ] == LVType::High); bool mMIRTIR = (lv[ LVType::mirtir ] == LVType::Medium); bool lMIRTIR = (lv[ LVType::mirtir ] == LVType::Low); // cloud spectral category bool clsc = (tkclsr || tnclsr) && !(lBright || lVis || lNIR || hNDSIVis || lMIR1 || lMIR2 || hTIR || hMIRTIR); // thick cloud spectral category if(clsc && lMIRTIR) return static_cast(TKCL); // thin cloud spectral category if(clsc && mMIRTIR) return static_cast(TNCL); typedef SnowOrIceSpectralRule SNICSRType; SNICSRType snicsrf = SNICSRType(); snicsrf.SetTV1( this->m_TV1 ); snicsrf.SetTV2( this->m_TV2 ); snicsrf.SetSAT( this->m_SAT ); bool snicsr = snicsrf( newPixel ); bool lNDBSI = (lv[ LVType::ndbsi ] == LVType::Low); bool lNDSIVis = (lv[ LVType::ndsivis ] == LVType::Low); bool hMIR1 = (lv[ LVType::mir1 ] == LVType::High); bool hMIR2 = (lv[ LVType::mir2 ] == LVType::High); // snow or ice spectral category bool snicsc = (snicsr && lNDBSI && !(lBright || lVis || lNDSIVis || lNIR || hMIR1 || hMIR2 || hTIR )); // snow spectral category if(snicsc && hNDSIVis) return static_cast(SN); bool mNDSIVis = (lv[ LVType::ndsivis ] == LVType::Medium); // ice or snow spectral category if(snicsc && mNDSIVis) return static_cast(ICSN); typedef WaterOrShadowSpectralRule WASHSRType; WASHSRType washsrf = WASHSRType(); washsrf.SetTV1( this->m_TV1 ); washsrf.SetTV2( this->m_TV2 ); washsrf.SetSAT( this->m_SAT ); bool washsr = washsrf( newPixel ); bool lNDVI = (lv[ LVType::ndvi ] == LVType::Low); bool lTIR = (lv[ LVType::tir ] == LVType::Low); // water or shadow spectral category bool washsc = washsr && lBright && lVis && lNDVI && lNIR && lMIR1 && lMIR2 && !(lTIR); // deep water or shadow spectral category if( washsc && hNDSIVis) return static_cast(DPWASH); // shallow water or shadow spectral category if( washsc && !(hNDSIVis)) return static_cast(SLWASH); typedef PitbogOrGreenhouseSpectralRule PBGHSRType; PBGHSRType pbghsrf = PBGHSRType(); pbghsrf.SetTV1( this->m_TV1 ); pbghsrf.SetTV2( this->m_TV2 ); pbghsrf.SetSAT( this->m_SAT ); bool pbghsr = pbghsrf( newPixel ); // Pit bog spectral category bool pbsc = pbghsr && lMIR1 && lMIR2 && lNDBSI && !(lNIR); bool mNDVI = (lv[ LVType::ndvi ] == LVType::Medium); bool hNDVI = (lv[ LVType::ndvi ] == LVType::High); // Pit bog categories for each ndvi if( pbsc && hNDVI) return static_cast(PBHNDVI); if( pbsc && mNDVI) return static_cast(PBMNDVI); if( pbsc && lNDVI) return static_cast(PBLNDVI); typedef VegetationSpectralRule VSRType; VSRType vsrf = VSRType(); vsrf.SetTV1( this->m_TV1 ); vsrf.SetTV2( this->m_TV2 ); vsrf.SetSAT( this->m_SAT ); bool vsr = vsrf( newPixel ); bool hNDBSI = (lv[ LVType::ndbsi ] == LVType::High); bool hNIR = (lv[ LVType::nir ] == LVType::High); // strong vegetation spectral category bool svsc = vsr && hNDVI && !(hMIR1 || hMIR2 || hNDBSI); if( svsc && hNIR) return static_cast(SVHNIR); if( svsc && !(hNIR)) return static_cast(SVLNIR); typedef ShadowWithVegetationSpectralRule SHVSRType; SHVSRType shvsrf = SHVSRType(); shvsrf.SetTV1( this->m_TV1 ); shvsrf.SetTV2( this->m_TV2 ); shvsrf.SetSAT( this->m_SAT ); bool shvsr = shvsrf( newPixel ); typedef DominantBlueSpectralRule DBSRType; DBSRType dbsrf = DBSRType(); dbsrf.SetTV1( this->m_TV1 ); dbsrf.SetTV2( this->m_TV2 ); dbsrf.SetSAT( this->m_SAT ); bool dbsr = dbsrf( newPixel ); // average vegetation spectral category bool avsc = (vsr || shvsr) && mNDVI && !(hMIR1 || hMIR2 || hNDBSI || dbsr); if( avsc && hNIR) return static_cast(AVHNIR); if( avsc && !(hNIR)) return static_cast(AVLNIR); typedef RangelandSpectralRule RSRType; RSRType rsrf = RSRType(); rsrf.SetTV1( this->m_TV1 ); rsrf.SetTV2( this->m_TV2 ); rsrf.SetSAT( this->m_SAT ); bool rsr = rsrf( newPixel ); // weak vegetation spectral category bool wvsc = (vsr || rsr || shvsr) && lNDVI && lNDBSI && lMIR1 && lMIR2 && !(dbsr); if( wvsc && hNIR) return static_cast(WVHNIR); if( wvsc && !(hNIR)) return static_cast(WVLNIR); bool mNDBSI = (lv[ LVType::ndbsi ] == LVType::Medium); // strong shrub rangeland spectral category bool ssrsc = rsr && hNDVI && mNDBSI; if( ssrsc && hNIR) return static_cast(SSRHNIR); if( ssrsc && !(hNIR)) return static_cast(SSRLNIR); typedef WetlandSpectralRule WESRType; WESRType wesrf = WESRType(); wesrf.SetTV1( this->m_TV1 ); wesrf.SetTV2( this->m_TV2 ); wesrf.SetSAT( this->m_SAT ); bool wesr = wesrf( newPixel ); // average shrub rangeland spectral category bool asrsc = rsr && mNDVI && mNDBSI && !(shvsr || wesr); if( asrsc && hNIR) return static_cast(ASRHNIR); if( asrsc && !(hNIR)) return static_cast(ASRLNIR); // strong herbaceous rangeland spectral category bool shrsc = rsr && hNDVI && hNDBSI; if( shrsc ) return static_cast(SHR); typedef BarrenLandOrBuiltUpOrCloudsSpectralRule BBCSRType; BBCSRType bbcsrf = BBCSRType(); bbcsrf.SetTV1( this->m_TV1 ); bbcsrf.SetTV2( this->m_TV2 ); bbcsrf.SetSAT( this->m_SAT ); bool bbcsr = bbcsrf( newPixel ); // average herbaceous rangeland spectral category bool ahrsc = (rsr || bbcsr) && mNDVI && hNDBSI; if( ahrsc ) return static_cast(AHR); // dark rangeland spectral category bool drsc = (vsr || rsr) && lNDVI && lMIR2 && !(hNIR || hMIR1 || lNDBSI); if( drsc ) return static_cast(DR); // bright barren land or built up spectral category bool bbbsc = bbcsr && hNIR && lNDVI && hNDBSI && !(lMIR1 || lMIR2); bool lNDBBBI = (lv[ LVType::ndbbbi ] == LVType::Low); bool bbbhtirsc = bbbsc && hTIR; if( bbbhtirsc && !(lNDBBBI) ) return static_cast(BBBHTIRF); if( bbbhtirsc && lNDBBBI ) return static_cast(BBBHTIRNF); bool bbbltirsc = bbbsc && !(hTIR); if( bbbltirsc && !(lNDBBBI) ) return static_cast(BBBLTIRF); if( bbbltirsc && lNDBBBI ) return static_cast(BBBLTIRNF); typedef FlatResponseBarrenLandOrBuiltUpSpectralRule FBBSRType; FBBSRType fbbsrf = FBBSRType(); fbbsrf.SetTV1( this->m_TV1 ); fbbsrf.SetTV2( this->m_TV2 ); fbbsrf.SetSAT( this->m_SAT ); bool fbbsr = fbbsrf( newPixel ); // strong barren land or built up spectral category bool sbbsc = (bbcsr || fbbsr) && lNDVI && hNDBSI && !( hNIR || lMIR1); bool sbbhtirsc = sbbsc && hTIR; if( sbbhtirsc && (dbsr || fbbsr) ) return static_cast(SBBHTIRF); if( sbbhtirsc && !(dbsr || fbbsr) ) return static_cast(SBBHTIRNF); bool sbbltirsc = sbbsc && !(hTIR); if( sbbltirsc && (dbsr || fbbsr) ) return static_cast(SBBLTIRF); if( sbbltirsc && !((dbsr || fbbsr)) ) return static_cast(SBBLTIRNF); // average barren land or built up spectral category bool abbsc = (bbcsr || fbbsr) && lNDVI && mNDBSI && !(lMIR1); bool abbhtirsc = abbsc && hTIR; if( abbhtirsc && !(lNDBBBI) ) return static_cast(ABBHTIRF); if( abbhtirsc && lNDBBBI ) return static_cast(ABBHTIRNF); bool abbltirsc = abbsc && !(hTIR); if( abbltirsc && !(lNDBBBI) ) return static_cast(ABBLTIRF); if( abbltirsc && lNDBBBI ) return static_cast(ABBLTIRNF); // dark barren land or built bool dbbsc = (bbcsr || fbbsr) && lNDVI && lMIR1 && !( hNIR || hMIR2 || lNDBSI); bool dbbhtirsc = dbbsc && hTIR; if( dbbhtirsc && (dbsr || fbbsr) ) return static_cast(DBBHTIRF); if( dbbhtirsc && !(dbsr || fbbsr) ) return static_cast(DBBHTIRNF); bool dbbltirsc = dbbsc && !(hTIR); if( dbbltirsc && (dbsr || fbbsr) ) return static_cast(DBBLTIRF); if( dbbltirsc && !((dbsr || fbbsr)) ) return static_cast(DBBLTIRNF); // weak rangeland spectral category bool wrsc = rsr && lNDVI && !(lNDBSI); if( wrsc ) return static_cast(WR); // shadow area with vegetation spectral category bool shvsc = dbsr && shvsr && lBright && lVis && lNIR && lMIR1 && lMIR2 && !(hNDVI); if( shvsc ) return static_cast(SHV); typedef ShadowWithBarrenLandSpectralRule SHBSRType; SHBSRType shbsrf = SHBSRType(); shbsrf.SetTV1( this->m_TV1 ); shbsrf.SetTV2( this->m_TV2 ); shbsrf.SetSAT( this->m_SAT ); bool shbsr = shbsrf( newPixel ); // shadow with barren land spectral category bool shbsc = dbsr && shbsr && lBright && lVis && lNDVI && lNIR && lMIR1 && lMIR2; if( shbsc ) return static_cast(SHB); typedef ShadowCloudOrSnowSpectralRule SHCLSNSRType; SHCLSNSRType shclsnsrf = SHCLSNSRType(); shclsnsrf.SetTV1( this->m_TV1 ); shclsnsrf.SetTV2( this->m_TV2 ); shclsnsrf.SetSAT( this->m_SAT ); bool shclsnsr = shclsnsrf( newPixel ); // clouds in shadow areas spectral category bool shclsc = dbsr && shclsnsr && !(hNDSIVis || lNIR || lBright || lVis || hNDBSI || hTIR); if( shclsc ) return static_cast(SHCL); bool hBright = (lv[ LVType::bright ] == LVType::High); bool hVis = (lv[ LVType::vis ] == LVType::High); // turbid water or shadow snow spectral category bool twashsnsc = dbsr && shclsnsr && hNDSIVis && lNIR && lMIR1 && lMIR2 && !(hBright || hVis || hNDBSI || hTIR); if( twashsnsc ) return static_cast(TWASHSN); // non forested wetland spectral category bool wesc = dbsr && wesr && lBright && lVis && lNIR && lMIR1 && lMIR2 && !(hNDVI || hNDBSI || lNDSIVis); if( wesc ) return static_cast(WE); // turbid water spectral category bool twasc = dbsr && lNDVI && lMIR1 && lMIR2 && !(hBright || hVis || hNIR || lNDSIVis); if( twasc ) return static_cast(TWA); return static_cast(SU); } }; } // namespace LandsatTM } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/LandSatClassifier/otb-module.cmake000066400000000000000000000003111301006202600255440ustar00rootroot00000000000000set(DOCUMENTATION "TODO") otb_module(OTBLandSatClassifier DEPENDS OTBIndices TEST_DEPENDS OTBITK OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Radiometry/LandSatClassifier/test/000077500000000000000000000000001301006202600234575ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/LandSatClassifier/test/CMakeLists.txt000066400000000000000000000011401301006202600262130ustar00rootroot00000000000000otb_module_test() set(OTBLandSatClassifierTests otbLandsatTMSpectralRuleBasedClassifierTest.cxx otbLandSatClassifierTestDriver.cxx ) add_executable(otbLandSatClassifierTestDriver ${OTBLandSatClassifierTests}) target_link_libraries(otbLandSatClassifierTestDriver ${OTBLandSatClassifier-Test_LIBRARIES}) otb_module_target_label(otbLandSatClassifierTestDriver) otb_add_test(NAME raTvLandsatTMSpectralRuleBasedClassifierTest COMMAND otbLandSatClassifierTestDriver otbLandsatTMSpectralRuleBasedClassifierTest ${INPUTDATA}/L5Strip.tif ${TEMP}/raTvLandsatTMSpectralRuleBasedClassifierTest_Image.tif ) OTB-release-5.8/Modules/Radiometry/LandSatClassifier/test/otbLandSatClassifierTestDriver.cxx000066400000000000000000000001601301006202600322540ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbLandsatTMSpectralRuleBasedClassifierTest); } otbLandsatTMSpectralRuleBasedClassifierTest.cxx000066400000000000000000000037461301006202600346240ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/LandSatClassifier/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLandsatTMSpectralRuleBasedClassifier.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkUnaryFunctorImageFilter.h" #include int otbLandsatTMSpectralRuleBasedClassifierTest(int itkNotUsed(argc), char * argv[]) { typedef double InputPixelType; typedef unsigned char OutputPixelType; typedef otb::VectorImage< InputPixelType, 2 > InputImageType; typedef otb::Image< OutputPixelType, 2 > OutputImageType; typedef otb::ImageFileReader< InputImageType > ReaderType; typedef otb::ImageFileWriter< OutputImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); WriterType::Pointer writer = WriterType::New(); writer->SetFileName( argv[2] ); typedef otb::Functor::LandsatTM::SpectralRuleBasedClassifier FunctorType; typedef itk::UnaryFunctorImageFilter< InputImageType, OutputImageType, FunctorType > FilterType; FilterType::Pointer filter = FilterType::New(); (filter->GetFunctor()).SetDegree(otb::Functor::LandsatTM::HundredsKelvin); (filter->GetFunctor()).SetReflectance(otb::Functor::LandsatTM::Thousands); (filter->GetFunctor()).SetSAT(otb::Functor::LandsatTM::L5); filter->SetInput( reader->GetOutput() ); writer->SetInput( filter->GetOutput() ); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/000077500000000000000000000000001301006202600227105ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/CMakeLists.txt000066400000000000000000000001551301006202600254510ustar00rootroot00000000000000project(OTBOpticalCalibration) set(OTBOpticalCalibration_LIBRARIES OTBOpticalCalibration) otb_module_impl() OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/000077500000000000000000000000001301006202600243335ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbAeronetData.h000066400000000000000000000063041301006202600274030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAeronetData_h #define otbAeronetData_h #include "itkDataObject.h" #include "itkObjectFactory.h" #include "itkMacro.h" #include "OTBOpticalCalibrationExport.h" namespace otb { /** * \class AeronetData * \brief This class is a data structure designed to store Aeronet data * extracted from a aeronet file. * * \sa AeronetFileReader * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT AeronetData : public itk::DataObject { public: /** Standard class typedefs. */ typedef AeronetData Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(AeronetData, itk::DataObject); /** Set/Get Solar Zenith Angle data */ itkSetMacro(SolarZenithAngle, double); itkGetMacro(SolarZenithAngle, double); /** Set/Get Angst data */ itkSetMacro(AngstromCoefficient, double); itkGetMacro(AngstromCoefficient, double); /** Set/Get Water data */ itkSetMacro(Water, double); itkGetMacro(Water, double); /** Set/Get AerosolOpticalThickness data */ itkSetMacro(AerosolOpticalThickness, double); itkGetMacro(AerosolOpticalThickness, double); /** Statistic : Standard deviation data */ itkSetMacro(StdDev, double); itkGetMacro(StdDev, double); /** Set/Get Cloud estimation data */ itkSetMacro(CloudEstimation, bool); itkGetMacro(CloudEstimation, bool); /** Set/Get Data Date */ itkSetMacro(DataDate, std::string); itkGetMacro(DataDate, std::string); /** Set/Get Number of date used */ itkSetMacro(NumberOfDateUsed, unsigned int); itkGetMacro(NumberOfDateUsed, unsigned int); /** Statistic : Epsilon date */ itkSetMacro(EpsilonDate, double); itkGetMacro(EpsilonDate, double); protected: /** Constructor */ AeronetData(); /** Destructor */ ~AeronetData() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** Angstrom coefficient */ double m_AngstromCoefficient; /** Water data */ double m_Water; /** Aerosol optical thickness data */ double m_AerosolOpticalThickness; /** Cloud estimation data */ bool m_CloudEstimation; /** Solar Zenith Angle */ double m_SolarZenithAngle; /** Statistic : Standard deviation data */ double m_StdDev; /** Data Date */ std::string m_DataDate; /** Epsilon to select time */ double m_EpsilonDate; /** Number of date used */ unsigned int m_NumberOfDateUsed; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbAeronetFileReader.h000066400000000000000000000116371301006202600305410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAeronetFileReader_h #define otbAeronetFileReader_h #include #include #include "OTBOpticalCalibrationExport.h" #include "itkProcessObject.h" namespace otb { class AeronetData; /** \class AeronetFileReaderException * \brief Base exception class for Aeronet problems during reading. * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT AeronetFileReaderException : public itk::ExceptionObject { public: /** Run-time information. */ itkTypeMacro(AeronetFileReaderException, ExceptionObject); /** Constructor. */ AeronetFileReaderException(const char *file, unsigned int line, const char* message = "Error in Radiometry IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} /** Constructor. */ AeronetFileReaderException(const std::string & file, unsigned int line, const char* message = "Error in Radiometry IO", const char* loc = "Unknown") : ExceptionObject(file, line, message, loc) {} }; /** * \class AeronetFileReader * \brief This class reads a Aeronet data from an Aeronet file. * * This class reads a Aeronet data from an Aeronet file. * * This file must contain the following fields (contains in the line 5) * column 1 : The date "Date (dd/mm/yyyy)" * 2 : The time "Time (hh:mm:ss)" * 6 : Aerosol Optical for 670 nm "AOT_675" * 15 : Aerosol Optical for 440 nm "AOT_440" * 19 : Water "Water (cm)" * 37 : Angstrom value "440-870Angstrom" * 44 : Solar zenith angle "Solar_Zenith_Angle" * The datas start in the line number 6. * * \sa AeronetData * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT AeronetFileReader : public itk::ProcessObject { public: /** Standards typedef */ typedef AeronetFileReader Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** Runtime type information */ itkTypeMacro(AeronetFileReader, itk::ProcessObject); /** Overriding of the GetOutput() method */ virtual AeronetData * GetOutput(void); /** Set the filename */ itkSetStringMacro(FileName); /** Get the filename */ itkGetStringMacro(FileName); /** Set/Get the day value */ itkSetMacro(Day, int); itkGetMacro(Day, int); /** Set/Get the month value */ itkSetMacro(Month, int); itkGetMacro(Month, int); /** Set/Get the year value */ itkSetMacro(Year, int); itkGetMacro(Year, int); /** Set/Get the hour value */ itkSetMacro(Hour, int); itkGetMacro(Hour, int); /** Set/Get the minute value */ itkSetMacro(Minute, int); itkGetMacro(Minute, int); /** Set/Get the epsilon for the time (tolerance for one hour) */ itkSetMacro(Epsilon, double); itkGetMacro(Epsilon, double); protected: /** Constructor */ AeronetFileReader(); /** Destructor */ ~AeronetFileReader() ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** Standards privates typedefs */ typedef std::vector VectorString; typedef std::vector VectorDouble; typedef std::vector MatrixString; /** Parse the string and return a list of strings which separated by ',' char */ VectorString ParseLine(const std::string& line) const; /** * Parse valid line method */ void ParseValidLine(const double& ref_date, const VectorString& line, const double& epsilon, VectorDouble& water, VectorDouble& angst, VectorDouble& tau_day, VectorDouble& solarZenithAngle) const; /** * Compute statistics method (mean and stddev) */ void GetStatistics(const VectorDouble& vec, double& mean, double& stddev) const; /** File name */ std::string m_FileName; /** Day value */ int m_Day; /** Month value */ int m_Month; /** Year value */ int m_Year; /** Hour value */ int m_Hour; /** Minute value */ int m_Minute; /** Epsilon to select time */ double m_Epsilon; }; } #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbAtmosphericCorrectionParameters.h000066400000000000000000000123771301006202600335550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAtmosphericCorrectionParameters_h #define otbAtmosphericCorrectionParameters_h #include "OTBOpticalCalibrationExport.h" #include "itkObject.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" #include "otbObjectList.h" #include "otbFilterFunctionValues.h" #include #include namespace otb { /** \class AtmosphericCorrectionParameters * \brief This class contains all atmospheric correction parameters. * * Each value can be read in the metadata of an image (ex: SPOT5, ...) or directly set by the user. * * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT AtmosphericCorrectionParameters : public itk::DataObject { public: /** Standard typedefs */ typedef AtmosphericCorrectionParameters Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(AtmosphericCorrectionParameters, Object); /** Creation through object factory macro */ itkNewMacro(Self); typedef enum {NO_AEROSOL = 0, CONTINENTAL = 1, MARITIME = 2, URBAN = 3, DESERTIC = 4} AerosolModelType; typedef ObjectList InternalWavelengthSpectralBandVectorType; typedef InternalWavelengthSpectralBandVectorType::Pointer WavelengthSpectralBandVectorType; /** * Set/Get the atmospheric pressure. */ itkSetMacro(AtmosphericPressure, double); itkGetMacro(AtmosphericPressure, double); /** * Set/Get the water vapor amount. */ itkSetMacro(WaterVaporAmount, double); itkGetMacro(WaterVaporAmount, double); /** * Set/Get the ozone amount. */ itkSetMacro(OzoneAmount, double); itkGetMacro(OzoneAmount, double); /** * Set/Get the aerosol model. */ itkSetEnumMacro(AerosolModel, AerosolModelType); itkGetEnumMacro(AerosolModel, AerosolModelType); /** * Set/Get the aerosol optical. */ itkSetMacro(AerosolOptical, double); itkGetMacro(AerosolOptical, double); /** Get/Set Aeronet file name. */ itkSetMacro(AeronetFileName, std::string); itkGetMacro(AeronetFileName, std::string); /** Read the aeronet data and extract aerosol optical and water vapor amount. */ void ReadAeronetData(const std::string& file, int year, int month, int day, int hour, int minute, double epsi); void UpdateAeronetData(const std::string& file, int year, int month, int day, int hour, int minute, double epsi); void UpdateAeronetData(const std::string& file, int year, int month, int day, int hour, int minute) { this->UpdateAeronetData(file, year, month, day, hour, minute, 0.4); } void UpdateAeronetData(int year, int month, int day, int hour, int minute, double epsi) { this->UpdateAeronetData(m_AeronetFileName, year, month, day, hour, minute, epsi); } void UpdateAeronetData(int year, int month, int day, int hour, int minute) { this->UpdateAeronetData(m_AeronetFileName, year, month, day, hour, minute, 0.4); } void UpdateAeronetData(const std::string& file, int year, int hour, int minute) { this->UpdateAeronetData(file, year, m_Month, m_Day, hour, minute, 0.4); } void UpdateAeronetData(int year, int hour, int minute) { this->UpdateAeronetData(m_AeronetFileName, year, m_Month, m_Day, hour, minute, 0.4); } /*void UpdateAeronetData(const std::string& file, int year, int hour, int minute, double epsi) CHRIS { this->UpdateAeronetData(file, year, m_Month, m_Day, hour, minute, epsi); } void UpdateAeronetData(const std::string& file, int year, int hour, int minute) { this->UpdateAeronetData(file, year, m_Month, m_Day, hour, minute, 0.4); }*/ /** Constructor */ AtmosphericCorrectionParameters(); /** Destructor */ ~AtmosphericCorrectionParameters() ITK_OVERRIDE {} protected: /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: AtmosphericCorrectionParameters(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Path to an Aeronet data file, allows computing aerosol optical and water vapor amounts. */ std::string m_AeronetFileName; /** Day */ int m_Day; /** Month */ int m_Month; /** The Atmospheric pressure */ double m_AtmosphericPressure; /** The Water vapor amount (Total water vapor content over vertical atmospheric column) */ double m_WaterVaporAmount; /** The Ozone amount (Stratospheric ozone layer content) */ double m_OzoneAmount; /** The Aerosol model */ AerosolModelType m_AerosolModel; /** The Aerosol optical (radiative impact of aerosol for the reference wavelength 550-nm) */ double m_AerosolOptical; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbAtmosphericRadiativeTerms.h000066400000000000000000000225011301006202600323330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAtmosphericRadiativeTerms_h #define otbAtmosphericRadiativeTerms_h #include "OTBOpticalCalibrationExport.h" #include "itkDataObject.h" #include "itkObjectFactory.h" #include "itkMacro.h" #include namespace otb { /** \class AtmosphericRadiativeTermsSingleChannel * \brief This class contains all atmospheric radiative terms for one channel. * * Each value can be deducted from the atmospheric correction parameters (using 6S) * or directly set by the user. * * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT AtmosphericRadiativeTermsSingleChannel : public itk::DataObject { public: /** Standard typedefs */ typedef AtmosphericRadiativeTermsSingleChannel Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(AtmosphericRadiativeTermsSingleChannel, DataObject); /** Creation through object factory macro */ itkNewMacro(Self); /** * Set/Get the intrinsic atmospheric reflectance. */ itkSetMacro(IntrinsicAtmosphericReflectance, double); itkGetMacro(IntrinsicAtmosphericReflectance, double); /** * Set/Get the spherical albedo of the atmosphere. */ itkSetMacro(SphericalAlbedo, double); itkGetMacro(SphericalAlbedo, double); /** * Set/Get the total gaseous transmission. */ itkSetMacro(TotalGaseousTransmission, double); itkGetMacro(TotalGaseousTransmission, double); /** * Set/Get the downward transmittance of the atmosphere. */ itkSetMacro(DownwardTransmittance, double); itkGetMacro(DownwardTransmittance, double); /** * Set/Get the upward transmittance of the atmosphere. */ itkSetMacro(UpwardTransmittance, double); itkGetMacro(UpwardTransmittance, double); /** * Set/Get the upward diffuse transmittance */ itkSetMacro(UpwardDiffuseTransmittance, double); itkGetMacro(UpwardDiffuseTransmittance, double); /** * Set/Get the upward direct transmittance */ itkSetMacro(UpwardDirectTransmittance, double); itkGetMacro(UpwardDirectTransmittance, double); /** * Set/Get the upward diffuse transmittance for rayleigh */ itkSetMacro(UpwardDiffuseTransmittanceForRayleigh, double); itkGetMacro(UpwardDiffuseTransmittanceForRayleigh, double); /** * Set/Get the upward diffuse transmittance for aerosols */ itkSetMacro(UpwardDiffuseTransmittanceForAerosol, double); itkGetMacro(UpwardDiffuseTransmittanceForAerosol, double); /** * Set/Get the wavelength */ itkSetMacro(WavelengthSpectralBand, double); itkGetMacro(WavelengthSpectralBand, double); protected: /** Constructor */ AtmosphericRadiativeTermsSingleChannel(); /** Destructor */ ~AtmosphericRadiativeTermsSingleChannel() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: AtmosphericRadiativeTermsSingleChannel(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The intrinsic atmospheric reflectance. */ double m_IntrinsicAtmosphericReflectance; /** The spherical albedo of the atmosphere.*/ double m_SphericalAlbedo; /**The total gaseous transmission (for all species). */ double m_TotalGaseousTransmission; /** The downward transmittance. */ double m_DownwardTransmittance; /** The upward transmittance. */ double m_UpwardTransmittance; /** The upward diffuse transmittance. */ double m_UpwardDiffuseTransmittance; /** The upward direct transmittance. */ double m_UpwardDirectTransmittance; /** The upward diffuse transmittance for rayleigh. */ double m_UpwardDiffuseTransmittanceForRayleigh; /** The upward diffuse transmittance for aerosols. */ double m_UpwardDiffuseTransmittanceForAerosol; /** Wavelength associated with the data: not used in the computation, for reference only */ double m_WavelengthSpectralBand; }; /** \class AtmosphericRadiativeTerms * \brief This class is a vector of AtmosphericRadiativeTermsSingleChannel, * it contains all atmospheric radiative terms for each studied channel. * * \ingroup AtmosphericRadiativeTermSingleChannel * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT AtmosphericRadiativeTerms : public itk::DataObject { public: /** Standard typedefs */ typedef AtmosphericRadiativeTerms Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(AtmosphericRadiativeTerms, DataObject); /** Creation through object factory macro */ itkNewMacro(Self); typedef AtmosphericRadiativeTermsSingleChannel::Pointer ValueType; typedef std::vector VectorValueType; typedef std::vector DataVectorType; typedef DataVectorType::size_type DataVectorSizeType; /** * Set/Get the values. */ void SetValues(const VectorValueType& val) { m_Values = val; this->Modified(); } VectorValueType& GetValues() { return m_Values; } const VectorValueType& GetValues() const { return m_Values; } /** Set/Get the data classified by channel. */ /** Set methods with vectors. */ void SetIntrinsicAtmosphericReflectances(const DataVectorType& vect); void SetSphericalAlbedos(const DataVectorType& vect); void SetTotalGaseousTransmissions(const DataVectorType& vect); void SetDownwardTransmittances(const DataVectorType& vect); void SetUpwardTransmittances(const DataVectorType& vect); void SetUpwardDiffuseTransmittances(const DataVectorType& vect); void SetUpwardDirectTransmittances(const DataVectorType& vect); void SetUpwardDiffuseTransmittancesForRayleigh(const DataVectorType& vect); void SetUpwardDiffuseTransmittancesForAerosol(const DataVectorType& vect); void SetWavelengthSpectralBand(const DataVectorType& vect); /** Set methods with index. */ void SetValueByIndex(unsigned int id, const ValueType& val); void SetIntrinsicAtmosphericReflectance(unsigned int id, const double& val); void SetSphericalAlbedo(unsigned int id, const double& val); void SetTotalGaseousTransmission(unsigned int id, const double& val); void SetDownwardTransmittance(unsigned int id, const double& val); void SetUpwardTransmittance(unsigned int id, const double& val); void SetUpwardDiffuseTransmittance(unsigned int id, const double& val); void SetUpwardDirectTransmittance(unsigned int id, const double& val); void SetUpwardDiffuseTransmittanceForRayleigh(unsigned int id, const double& val); void SetUpwardDiffuseTransmittanceForAerosol(unsigned int id, const double& val); void SetWavelengthSpectralBand(unsigned int id, const double& val); /** Get methods with vectors. */ DataVectorType GetIntrinsicAtmosphericReflectances() const; DataVectorType GetSphericalAlbedos() const; DataVectorType GetTotalGaseousTransmissions() const; DataVectorType GetDownwardTransmittances() const; DataVectorType GetUpwardTransmittances() const; DataVectorType GetUpwardDiffuseTransmittances() const; DataVectorType GetUpwardDirectTransmittances() const; DataVectorType GetUpwardDiffuseTransmittancesForRayleigh() const; DataVectorType GetUpwardDiffuseTransmittancesForAerosol() const; DataVectorType GetWavelengthSpectralBand() const; /** Get methods with index. */ double GetIntrinsicAtmosphericReflectance(unsigned int id) const; double GetSphericalAlbedo(unsigned int id) const; double GetTotalGaseousTransmission(unsigned int id) const; double GetDownwardTransmittance(unsigned int id) const; double GetUpwardTransmittance(unsigned int id) const; double GetUpwardDiffuseTransmittance(unsigned int id) const; double GetUpwardDirectTransmittance(unsigned int id) const; double GetUpwardDiffuseTransmittanceForRayleigh(unsigned int id) const; double GetUpwardDiffuseTransmittanceForAerosol(unsigned int id) const; double GetWavelengthSpectralBand(unsigned int id) const; const ValueType GetValueByIndex(unsigned int id) const; /** Initialization method.*/ void ValuesInitialization(DataVectorSizeType nbChannel); protected: /** Constructor */ AtmosphericRadiativeTerms(); /** Destructor */ ~AtmosphericRadiativeTerms() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: AtmosphericRadiativeTerms(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The vector containing each channel information. */ VectorValueType m_Values; /** Boolean to know if m_Values has been initialized. */ bool m_IsInitialized; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbImageMetadataCorrectionParameters.h000066400000000000000000000117321301006202600337540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageMetadataCorrectionParameters_h #define otbImageMetadataCorrectionParameters_h #include "OTBOpticalCalibrationExport.h" #include "itkObject.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" #include "otbObjectList.h" #include "otbFilterFunctionValues.h" #include #include namespace otb { /** \class ImageMetadataCorrectionParameters * \brief This class contains all atmospheric correction parameters. * * Each value can be read in the metadata of an image (ex: SPOT5, ...) or directly set by the user. * * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT ImageMetadataCorrectionParameters : public itk::DataObject { public: /** Standard typedefs */ typedef ImageMetadataCorrectionParameters Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(ImageMetadataCorrectionParameters, Object); /** Creation through object factory macro */ itkNewMacro(Self); typedef ObjectList InternalWavelengthSpectralBandVectorType; typedef InternalWavelengthSpectralBandVectorType::Pointer WavelengthSpectralBandVectorType; /** * Set/Get the solar zenithal angle. */ itkSetMacro(SolarZenithalAngle, double); itkGetMacro(SolarZenithalAngle, double); /** * Set/Get the solar azimutal angle. */ itkSetMacro(SolarAzimutalAngle, double); itkGetMacro(SolarAzimutalAngle, double); /** * Set/Get the viewing zenithal angle. */ itkSetMacro(ViewingZenithalAngle, double); itkGetMacro(ViewingZenithalAngle, double); /** * Set/Get the viewing azimutal angle. */ itkSetMacro(ViewingAzimutalAngle, double); itkGetMacro(ViewingAzimutalAngle, double); /** * Set/Get the month. */ itkSetClampMacro(Month, unsigned int, 1, 12); itkGetMacro(Month, unsigned int); /** * Set/Get the day. */ itkSetClampMacro(Day, unsigned int, 1, 31); itkGetMacro(Day, unsigned int); /** * Set/Get the year. */ itkSetMacro(Year, unsigned int); itkGetMacro(Year, unsigned int); /** Get/Set FilterFunction file name. */ itkSetMacro(FilterFunctionValuesFileName, std::string); itkGetMacro(FilterFunctionValuesFileName, std::string); /** * Set/Get the wavelength spectral band. */ void SetWavelengthSpectralBand(const WavelengthSpectralBandVectorType& waveband) { m_WavelengthSpectralBand = waveband; } void SetWavelengthSpectralBandWithIndex(unsigned int id, const FilterFunctionValues::Pointer& function) { if (m_WavelengthSpectralBand->Size() < id + 1) { for (unsigned int j = 0; j < (id + 1 - m_WavelengthSpectralBand->Size()); ++j) { FilterFunctionValues::Pointer temp; m_WavelengthSpectralBand->PushBack(temp); } } m_WavelengthSpectralBand->SetNthElement(id, function); } WavelengthSpectralBandVectorType GetWavelengthSpectralBand() const { return m_WavelengthSpectralBand; } const WavelengthSpectralBandVectorType * GetWavelengthSpectralBandRef() const { return &m_WavelengthSpectralBand; } /** * Read a file that contains filter function values on the 6S format. */ void LoadFilterFunctionValue(const std::string& filename); void LoadFilterFunctionValue() { this->LoadFilterFunctionValue(m_FilterFunctionValuesFileName); } /** Constructor */ ImageMetadataCorrectionParameters(); /** Destructor */ ~ImageMetadataCorrectionParameters() ITK_OVERRIDE {} protected: /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageMetadataCorrectionParameters(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The Solar zenithal angle */ double m_SolarZenithalAngle; /** The Solar azimutal angle */ double m_SolarAzimutalAngle; /** The Viewing zenithal angle */ double m_ViewingZenithalAngle; /** The Viewing azimutal angle */ double m_ViewingAzimutalAngle; /** The Month */ unsigned int m_Month; /** The Day (in the month) */ unsigned int m_Day; /** The Year */ unsigned int m_Year; std::string m_FilterFunctionValuesFileName; /** Wavelength for the each spectral band definition */ WavelengthSpectralBandVectorType m_WavelengthSpectralBand; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbImageToLuminanceImageFilter.h000066400000000000000000000153061301006202600325100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToLuminanceImageFilter_h #define otbImageToLuminanceImageFilter_h #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "itkNumericTraits.h" #include "otbMacro.h" #include "otbOpticalImageMetadataInterfaceFactory.h" #include namespace otb { namespace Functor { /** * \class ImageToLuminanceImageFunctor * \brief Add beta to the quotient Input over alpha. * * \sa ImageToLuminanceImageFilter * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ template class ImageToLuminanceImageFunctor { public: ImageToLuminanceImageFunctor() : m_Alpha(1.), m_Beta(0.) {} virtual ~ImageToLuminanceImageFunctor() {} void SetAlpha(double alpha) { m_Alpha = alpha; } void SetBeta(double beta) { m_Beta = beta; } double GetAlpha() { return m_Alpha; } double GetBeta() { return m_Beta; } inline TOutput operator ()(const TInput& inPixel) const { TOutput outPixel; double temp; temp = static_cast(inPixel) / m_Alpha + m_Beta; outPixel = static_cast(temp); return outPixel; } private: double m_Alpha; double m_Beta; }; } /** \class ImageToLuminanceImageFilter * \brief Convert a raw value into a luminance value * * Transform a classical image into the luminance image. For this it * uses the functor ImageToLuminanceImageFunctor calling for each component of each pixel. * * * For Spot image in the dimap format, the correction parameters are * retrieved automatically from the metadata * * \ingroup ImageToLuminanceImageFunctor * \ingroup Radiometry * * \example Radiometry/AtmosphericCorrectionSequencement.cxx * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT ImageToLuminanceImageFilter : public UnaryImageFunctorWithVectorImageFilter > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::ImageToLuminanceImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef ImageToLuminanceImageFilter Self; typedef UnaryImageFunctorWithVectorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(ImageToLuminanceImageFilter, UnaryImageFunctorWithVectorImageFiltermageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename itk::VariableLengthVector VectorType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; /** Set the absolute calibration gains. */ itkSetMacro(Alpha, VectorType); /** Give the absolute calibration gains. */ itkGetConstReferenceMacro(Alpha, VectorType); /** Set the absolute calibration bias. */ itkSetMacro(Beta, VectorType); /** Give the absolute calibration bias. */ itkGetConstReferenceMacro(Beta, VectorType); protected: /** Constructor */ ImageToLuminanceImageFilter() { m_Alpha.SetSize(0); m_Beta.SetSize(0); }; /** Destructor */ ~ImageToLuminanceImageFilter() ITK_OVERRIDE {} /** Update the functor list and input parameters */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); if (m_Alpha.GetSize() == 0) { m_Alpha = imageMetadataInterface->GetPhysicalGain(); } if (m_Beta.GetSize() == 0) { m_Beta = imageMetadataInterface->GetPhysicalBias(); } otbMsgDevMacro(<< "Dimension: "); otbMsgDevMacro(<< "m_Alpha.GetSize(): " << m_Alpha.GetSize()); otbMsgDevMacro(<< "m_Beta.GetSize() : " << m_Beta.GetSize()); otbMsgDevMacro( << "this->GetInput()->GetNumberOfComponentsPerPixel() : " << this->GetInput()->GetNumberOfComponentsPerPixel()); if ((m_Alpha.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel()) || (m_Beta.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel())) { itkExceptionMacro(<< "Alpha and Beta parameters should have the same size as the number of bands"); } otbMsgDevMacro(<< "Using correction parameters: "); otbMsgDevMacro(<< "Alpha (gain): " << m_Alpha); otbMsgDevMacro(<< "Beta (bias): " << m_Beta); this->GetFunctorVector().clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { FunctorType functor; functor.SetAlpha(m_Alpha[i]); functor.SetBeta(m_Beta[i]); this->GetFunctorVector().push_back(functor); } } private: /** Ponderation declaration*/ VectorType m_Alpha; VectorType m_Beta; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbImageToReflectanceImageFilter.h000066400000000000000000000274001301006202600330060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToReflectanceImageFilter_h #define otbImageToReflectanceImageFilter_h #include "otbImageToLuminanceImageFilter.h" #include "otbLuminanceToReflectanceImageFilter.h" namespace otb { namespace Functor { /** \class ImageToReflectanceImageFunctor * \brief Call the ImageToLuminanceFunctor over the input and the LuminanceToReflectanceFunctor to this result. * * * \sa ImageToReflectanceImageFilter * * \ingroup Functor * \ingroup ImageToLuminanceFunctor * \ingroup LuminanceToReflectanceFunctor * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ template class ImageToReflectanceImageFunctor { public: ImageToReflectanceImageFunctor() {} virtual ~ImageToReflectanceImageFunctor() {} typedef Functor::ImageToLuminanceImageFunctor ImToLumFunctorType; typedef Functor::LuminanceToReflectanceImageFunctor LumToReflecFunctorType; void SetAlpha(double alpha) { m_ImToLumFunctor.SetAlpha(alpha); } void SetBeta(double beta) { m_ImToLumFunctor.SetBeta(beta); } void SetSolarIllumination(double solarIllumination) { m_LumToReflecFunctor.SetSolarIllumination(solarIllumination); } void SetIlluminationCorrectionCoefficient(double coef) { m_LumToReflecFunctor.SetIlluminationCorrectionCoefficient(coef); } void SetUseClamp(bool useClamp) { m_LumToReflecFunctor.SetUseClamp(useClamp); } double GetAlpha() { return m_ImToLumFunctor.GetAlpha(); } double GetBeta() { return m_ImToLumFunctor.GetBeta(); } double GetSolarIllumination() { return m_LumToReflecFunctor.GetSolarIllumination(); } double GetIlluminationCorrectionCoefficient() { return m_LumToReflecFunctor.GetIlluminationCorrectionCoefficient(); } bool GetUseClamp() { return m_LumToReflecFunctor.GetUseClamp(); } inline TOutput operator ()(const TInput& inPixel) const { TOutput outPixel; TOutput tempPix; tempPix = m_ImToLumFunctor(inPixel); outPixel = m_LumToReflecFunctor(tempPix); return outPixel; } private: ImToLumFunctorType m_ImToLumFunctor; LumToReflecFunctorType m_LumToReflecFunctor; }; } /** \class ImageToReflectanceImageFilter * \brief Convert a raw value into a reflectance value * * Transform a classical image into the reflectance image. For this it uses the functor ImageToReflectanceFunctor calling for each component of each pixel. * The flux normalization coefficient (that is the ratio solar distance over mean solar distance) can be directly set or the user can * give the day and the month of the observation and the class will used a coefficient given by a 6S routine that will give the corresponding coefficient. * To note that in the case, 6S gives the square of the distances ratio. * * * For Spot image in the dimap format, the correction parameters are * retrieved automatically from the metadata * * \ingroup ImageToReflectanceImageFunctor * \ingroup ImageToLuminanceImageFilter * \ingroup ReflectanceToLuminanceImageFilter * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT ImageToReflectanceImageFilter : public UnaryImageFunctorWithVectorImageFilter > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::ImageToReflectanceImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef ImageToReflectanceImageFilter Self; typedef UnaryImageFunctorWithVectorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(ImageToReflectanceImageFilter, UnaryImageFunctorWithVectorImageFiltermageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename itk::VariableLengthVector VectorType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; /** Set the absolute calibration gains. */ itkSetMacro(Alpha, VectorType); /** Give the absolute calibration gains. */ itkGetConstReferenceMacro(Alpha, VectorType); /** Set the absolute calibration bias. */ itkSetMacro(Beta, VectorType); /** Give the absolute calibration bias. */ itkGetConstReferenceMacro(Beta, VectorType); /** Set the solar illumination value. */ itkSetMacro(SolarIllumination, VectorType); /** Give the solar illumination value. */ itkGetConstReferenceMacro(SolarIllumination, VectorType); /** Set the zenithal solar angle. */ itkSetMacro(ZenithalSolarAngle, double); /** Give the zenithal solar angle. */ itkGetConstReferenceMacro(ZenithalSolarAngle, double); /** Set the useClamp flag. */ itkSetMacro(UseClamp,bool); /** Give the useClamp flag. */ itkGetConstReferenceMacro(UseClamp,bool); /** Set/Get the sun elevation angle (internally handled by the zenithal angle)*/ virtual void SetElevationSolarAngle(double elevationAngle) { double zenithalAngle = 90.0 - elevationAngle; if (this->m_ZenithalSolarAngle != zenithalAngle) { this->m_ZenithalSolarAngle = zenithalAngle; this->Modified(); } } virtual double GetElevationSolarAngle() const { return 90.0 - this->m_ZenithalSolarAngle; } /** Set the flux normalization coefficient. */ void SetFluxNormalizationCoefficient(double coef) { m_FluxNormalizationCoefficient = coef; m_IsSetFluxNormalizationCoefficient = true; this->Modified(); } /** Set the acquisition day. */ itkSetClampMacro(Day, int, 1, 31); /** Get the acquisition day. */ itkGetConstReferenceMacro(Day, int); /** Set the acquisition month. */ itkSetClampMacro(Month, int, 1, 12); /** Set the acquisition month. */ itkGetConstReferenceMacro(Month, int); protected: /** Constructor */ ImageToReflectanceImageFilter() : m_ZenithalSolarAngle(120.), //invalid value which will lead to negative radiometry m_FluxNormalizationCoefficient(1.), m_UseClamp(true), m_IsSetFluxNormalizationCoefficient(false), m_Day(0), m_Month(0) { m_Alpha.SetSize(0); m_Beta.SetSize(0); m_SolarIllumination.SetSize(0); }; /** Destructor */ ~ImageToReflectanceImageFilter() ITK_OVERRIDE {} /** Update the functor list and input parameters */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); if (m_Alpha.GetSize() == 0) { m_Alpha = imageMetadataInterface->GetPhysicalGain(); } if (m_Beta.GetSize() == 0) { m_Beta = imageMetadataInterface->GetPhysicalBias(); } if ((m_Day == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Day = imageMetadataInterface->GetDay(); } if ((m_Month == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Month = imageMetadataInterface->GetMonth(); } if (m_SolarIllumination.GetSize() == 0) { m_SolarIllumination = imageMetadataInterface->GetSolarIrradiance(); } if (m_ZenithalSolarAngle == 120.0) { //the zenithal angle is the complementary of the elevation angle m_ZenithalSolarAngle = 90.0 - imageMetadataInterface->GetSunElevation(); } otbMsgDevMacro(<< "Using correction parameters: "); otbMsgDevMacro(<< "Alpha (gain): " << m_Alpha); otbMsgDevMacro(<< "Beta (bias): " << m_Beta); otbMsgDevMacro(<< "Day: " << m_Day); otbMsgDevMacro(<< "Month: " << m_Month); otbMsgDevMacro(<< "Solar irradiance: " << m_SolarIllumination); otbMsgDevMacro(<< "Zenithal angle: " << m_ZenithalSolarAngle); if ((m_Alpha.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel()) || (m_Beta.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel()) || (m_SolarIllumination.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel())) { itkExceptionMacro( << "Alpha, Beta and SolarIllumination parameters should have the same size as the number of bands"); } this->GetFunctorVector().clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { FunctorType functor; double coefTemp = 0.; if (!m_IsSetFluxNormalizationCoefficient) { if (m_Day * m_Month != 0 && m_Day < 32 && m_Month < 13) { double dsol = VarSol::GetVarSol(m_Day, m_Month); coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * dsol; } else { itkExceptionMacro(<< "Day has to be included between 1 and 31, Month between 1 and 12."); } } else { coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * m_FluxNormalizationCoefficient * m_FluxNormalizationCoefficient; } functor.SetIlluminationCorrectionCoefficient(1. / coefTemp); functor.SetAlpha(m_Alpha[i]); functor.SetBeta(m_Beta[i]); functor.SetSolarIllumination(m_SolarIllumination[i]); functor.SetUseClamp(m_UseClamp); this->GetFunctorVector().push_back(functor); } } private: /** Ponderation declaration*/ VectorType m_Alpha; VectorType m_Beta; /** Set the zenithal soalr angle. */ double m_ZenithalSolarAngle; /** Flux normalization coefficient. */ double m_FluxNormalizationCoefficient; /** Solar illumination value. */ VectorType m_SolarIllumination; /** Flag to activate clamping between 0 and 1 */ bool m_UseClamp; /** Used to know if the user has set a value for the FluxNormalizationCoefficient parameter * or if the class has to compute it */ bool m_IsSetFluxNormalizationCoefficient; /** Acquisition Day*/ int m_Day; /** Acquisition Month*/ int m_Month; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbLuminanceToImageImageFilter.h000066400000000000000000000153411301006202600325070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLuminanceToImageImageFilter_h #define otbLuminanceToImageImageFilter_h #include "otb_6S.h" #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "itkNumericTraits.h" #include "otbMacro.h" #include "otbOpticalImageMetadataInterfaceFactory.h" #include namespace otb { namespace Functor { /** * \class LuminanceToImageImageFunctor * \brief Subtract beta to the Input and multiply by alpha. * * \sa LuminanceToImageImageFilter * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ template class LuminanceToImageImageFunctor { public: LuminanceToImageImageFunctor() : m_Alpha(1.), m_Beta(0.) {} virtual ~LuminanceToImageImageFunctor() {} void SetAlpha(double alpha) { m_Alpha = alpha; } void SetBeta(double beta) { m_Beta = beta; } double GetAlpha() { return m_Alpha; } double GetBeta() { return m_Beta; } inline TOutput operator ()(const TInput& inPixel) const { TOutput outPixel; double temp; temp = (static_cast(inPixel) - m_Beta) * m_Alpha; outPixel = static_cast(temp); return outPixel; } private: double m_Alpha; double m_Beta; }; } /** \class LuminanceToImageImageFilter * \brief Convert a raw value into a luminance value * * Transform a luminance image into a classical image. For this it * uses the functor LuminanceToImageImageFunctor calling for each component of each pixel. * * * For Spot image in the dimap format, the correction parameters are * retrieved automatically from the metadata * * \ingroup LuminanceToImageImageFunctor * \ingroup Radiometry * * \example Radiometry/AtmosphericCorrectionSequencement.cxx * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT LuminanceToImageImageFilter : public UnaryImageFunctorWithVectorImageFilter > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::LuminanceToImageImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef LuminanceToImageImageFilter Self; typedef UnaryImageFunctorWithVectorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(LuminanceToImageImageFilter, UnaryImageFunctorWithVectorImageFiltermageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename itk::VariableLengthVector VectorType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; /** Set the absolute calibration gains. */ itkSetMacro(Alpha, VectorType); /** Give the absolute calibration gains. */ itkGetConstReferenceMacro(Alpha, VectorType); /** Set the absolute calibration bias. */ itkSetMacro(Beta, VectorType); /** Give the absolute calibration bias. */ itkGetConstReferenceMacro(Beta, VectorType); protected: /** Constructor */ LuminanceToImageImageFilter() { m_Alpha.SetSize(0); m_Beta.SetSize(0); }; /** Destructor */ ~LuminanceToImageImageFilter() ITK_OVERRIDE {} /** Update the functor list and input parameters */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); if (m_Alpha.GetSize() == 0) { m_Alpha = imageMetadataInterface->GetPhysicalGain(); } if (m_Beta.GetSize() == 0) { m_Beta = imageMetadataInterface->GetPhysicalBias(); } otbMsgDevMacro(<< "Dimension: "); otbMsgDevMacro(<< "m_Alpha.GetSize(): " << m_Alpha.GetSize()); otbMsgDevMacro(<< "m_Beta.GetSize() : " << m_Beta.GetSize()); otbMsgDevMacro( << "this->GetInput()->GetNumberOfComponentsPerPixel() : " << this->GetInput()->GetNumberOfComponentsPerPixel()); if ((m_Alpha.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel()) || (m_Beta.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel())) { itkExceptionMacro(<< "Alpha and Beta parameters should have the same size as the number of bands"); } otbMsgDevMacro(<< "Using correction parameters: "); otbMsgDevMacro(<< "Alpha (gain): " << m_Alpha); otbMsgDevMacro(<< "Beta (bias): " << m_Beta); this->GetFunctorVector().clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { FunctorType functor; functor.SetAlpha(m_Alpha[i]); functor.SetBeta(m_Beta[i]); this->GetFunctorVector().push_back(functor); } } private: /** Ponderation declaration*/ VectorType m_Alpha; VectorType m_Beta; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbLuminanceToReflectanceImageFilter.h000066400000000000000000000250721301006202600337020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLuminanceToReflectanceImageFilter_h #define otbLuminanceToReflectanceImageFilter_h #include "otbVarSol.h" #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbMacro.h" #include "otbOpticalImageMetadataInterfaceFactory.h" #include namespace otb { namespace Functor { /** * \class LuminanceToReflectanceImageFunctor * \brief Compupute reflectance from the luminance value * * Multiply by Pi and by an illumination correction coefficient the * quotient between the input and the given solar illumination. * * * \sa LuminanceToReflectanceImageFilter * * \ingroup Functor * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ template class LuminanceToReflectanceImageFunctor { public: LuminanceToReflectanceImageFunctor() : m_SolarIllumination(1.0), m_IlluminationCorrectionCoefficient(1.0), m_UseClamp(true) {} virtual ~LuminanceToReflectanceImageFunctor() {} void SetSolarIllumination(double solarIllumination) { m_SolarIllumination = solarIllumination; } void SetIlluminationCorrectionCoefficient(double coef) { m_IlluminationCorrectionCoefficient = coef; } void SetUseClamp(bool useClamp) { m_UseClamp = useClamp; } double GetSolarIllumination() { return m_SolarIllumination; } double GetIlluminationCorrectionCoefficient() { return m_IlluminationCorrectionCoefficient; } bool GetUseClamp() { return m_UseClamp; } inline TOutput operator ()(const TInput& inPixel) const { TOutput outPixel; double temp; temp = static_cast(inPixel) * static_cast(CONST_PI) * m_IlluminationCorrectionCoefficient / m_SolarIllumination; if (m_UseClamp) { temp = std::max(temp,0.); temp = std::min(temp,1.); } outPixel = static_cast(temp); return outPixel; } private: double m_SolarIllumination; double m_IlluminationCorrectionCoefficient; double m_UseClamp; }; } /** \class LuminanceToReflectanceImageFilter * \brief Convert luminance value into reflectance value * * Transform a luminance image into the reflectance. For this it uses the * functor LuminanceToReflectanceImageFunctor calling for each component of each pixel. * * * For Spot image in the dimap format, the correction parameters are * retrieved automatically from the metadata * * \ingroup ImageToLuminanceImageFunctor * \ingroup Radiometry * * \example Radiometry/AtmosphericCorrectionSequencement.cxx * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT LuminanceToReflectanceImageFilter : public UnaryImageFunctorWithVectorImageFilter > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::LuminanceToReflectanceImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef LuminanceToReflectanceImageFilter Self; typedef UnaryImageFunctorWithVectorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(LuminanceToReflectanceImageFilter, UnaryImageFunctorWithVectorImageFiltermageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename itk::VariableLengthVector VectorType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; /** Set the solar illumination value. */ itkSetMacro(SolarIllumination, VectorType); /** Give the solar illumination value. */ itkGetConstReferenceMacro(SolarIllumination, VectorType); /** Set the zenithal solar angle. */ itkSetMacro(ZenithalSolarAngle, double); /** Give the zenithal solar angle. */ itkGetConstReferenceMacro(ZenithalSolarAngle, double); /** Set/Get the sun elevation angle (internally handled by the zenithal angle)*/ virtual void SetElevationSolarAngle(double elevationAngle) { double zenithalAngle = 90.0 - elevationAngle; if (this->m_ZenithalSolarAngle != zenithalAngle) { this->m_ZenithalSolarAngle = zenithalAngle; this->Modified(); } } virtual double GetElevationSolarAngle() const { return 90.0 - this->m_ZenithalSolarAngle; } /** Set the day. */ itkSetClampMacro(Day, int, 1, 31); /** Give the day. */ itkGetConstReferenceMacro(Day, int); /** Set the month. */ itkSetClampMacro(Month, int, 1, 12); /** Give the month. */ itkGetConstReferenceMacro(Month, int); /** Set the flux normalization coefficient. */ void SetFluxNormalizationCoefficient(double coef) { m_FluxNormalizationCoefficient = coef; m_IsSetFluxNormalizationCoefficient = true; this->Modified(); } /** Give the flux normalization coefficient. */ itkGetConstReferenceMacro(FluxNormalizationCoefficient, double); /** Set the IsSetFluxNormalizationCoefficient boolean. */ itkSetMacro(IsSetFluxNormalizationCoefficient, bool); /** Give the IsSetFluxNormalizationCoefficient boolean. */ itkGetConstReferenceMacro(IsSetFluxNormalizationCoefficient, bool); /** Set the UseClamp boolean. */ itkSetMacro(UseClamp, bool); /** Give the UseClamp boolean. */ itkGetConstReferenceMacro(UseClamp, bool); protected: /** Constructor */ LuminanceToReflectanceImageFilter() : m_ZenithalSolarAngle(120.0), //invalid value which will lead to negative radiometry m_FluxNormalizationCoefficient(1.), m_Day(0), m_Month(0), m_IsSetFluxNormalizationCoefficient(false), m_UseClamp(true) { m_SolarIllumination.SetSize(0); }; /** Destructor */ ~LuminanceToReflectanceImageFilter() ITK_OVERRIDE {} /** Update the functor list and input parameters */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); if ((m_Day == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Day = imageMetadataInterface->GetDay(); } if ((m_Month == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Month = imageMetadataInterface->GetMonth(); } if (m_SolarIllumination.GetSize() == 0) { m_SolarIllumination = imageMetadataInterface->GetSolarIrradiance(); } if (m_ZenithalSolarAngle == 120.0) { //the zenithal angle is the complementary of the elevation angle m_ZenithalSolarAngle = 90.0 - imageMetadataInterface->GetSunElevation(); } otbMsgDevMacro(<< "Using correction parameters: "); otbMsgDevMacro(<< "Day: " << m_Day); otbMsgDevMacro(<< "Month: " << m_Month); otbMsgDevMacro(<< "Solar irradiance: " << m_SolarIllumination); otbMsgDevMacro(<< "Zenithal angle: " << m_ZenithalSolarAngle); if ((m_SolarIllumination.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel())) { itkExceptionMacro(<< "SolarIllumination parameter should have the same size as the number of bands"); } this->GetFunctorVector().clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { FunctorType functor; double coefTemp = 0.; if (!m_IsSetFluxNormalizationCoefficient) { if (m_Day * m_Month != 0 && m_Day < 32 && m_Month < 13) { double dsol = VarSol::GetVarSol(m_Day, m_Month); coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * dsol; } else { itkExceptionMacro(<< "Day has to be included between 1 and 31, Month between 1 and 12."); } } else { coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * m_FluxNormalizationCoefficient * m_FluxNormalizationCoefficient; } functor.SetIlluminationCorrectionCoefficient(1. / coefTemp); functor.SetSolarIllumination(static_cast(m_SolarIllumination[i])); functor.SetUseClamp(m_UseClamp); this->GetFunctorVector().push_back(functor); } } private: /** Set the zenithal soalr angle. */ double m_ZenithalSolarAngle; /** Flux normalization coefficient. */ double m_FluxNormalizationCoefficient; /** Acquisition day. */ int m_Day; /** Acquisition month. */ int m_Month; /** Solar illumination value. */ VectorType m_SolarIllumination; /** Used to know if the user has set a value for the FluxNormalizationCoefficient parameter * or if the class has to compute it */ bool m_IsSetFluxNormalizationCoefficient; /** Clamp values to [0,1] */ bool m_UseClamp; }; } // end namespace otb #endif otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h000066400000000000000000000134541301006202600407020ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms_h #define otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms_h #include "otbAtmosphericRadiativeTerms.h" #include "otbImageMetadataCorrectionParameters.h" #include "otbSIXSTraits.h" #include "otbMacro.h" namespace otb { /** \class RadiometryCorrectionParametersToAtmosphericRadiativeTerms * \brief TODO. * * TODO * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ class RadiometryCorrectionParametersToAtmosphericRadiativeTerms { public: /** Call the varSol function*/ static AtmosphericRadiativeTerms::Pointer Compute(AtmosphericCorrectionParameters* paramAtmo, ImageMetadataCorrectionParameters* paramAcqui) { AtmosphericRadiativeTerms::Pointer radTermsOut = AtmosphericRadiativeTerms::New(); typedef AtmosphericCorrectionParameters::WavelengthSpectralBandVectorType WavelengthSpectralBandVectorType; WavelengthSpectralBandVectorType WavelengthSpectralBandVector = paramAcqui->GetWavelengthSpectralBand(); unsigned int NbBand = WavelengthSpectralBandVector->Size(); radTermsOut->ValuesInitialization(NbBand); double atmosphericReflectance(0.); double atmosphericSphericalAlbedo(0.); double totalGaseousTransmission(0.); double downwardTransmittance(0.); double upwardTransmittance(0.); double upwardDiffuseTransmittance(0.); double upwardDirectTransmittance(0.); double upwardDiffuseTransmittanceForRayleigh(0.); double upwardDiffuseTransmittanceForAerosol(0.); for (unsigned int i = 0; i < NbBand; ++i) { atmosphericReflectance = 0.; atmosphericSphericalAlbedo = 0.; totalGaseousTransmission = 0.; downwardTransmittance = 0.; upwardTransmittance = 0.; upwardDiffuseTransmittance = 0.; upwardDirectTransmittance = 0.; upwardDiffuseTransmittanceForRayleigh = 0.; upwardDiffuseTransmittanceForAerosol = 0.; SIXSTraits::ComputeAtmosphericParameters( paramAcqui->GetSolarZenithalAngle(), /** The Solar zenithal angle */ paramAcqui->GetSolarAzimutalAngle(), /** The Solar azimutal angle */ paramAcqui->GetViewingZenithalAngle(), /** The Viewing zenithal angle */ paramAcqui->GetViewingAzimutalAngle(), /** The Viewing azimutal angle */ paramAcqui->GetMonth(), /** The Month */ paramAcqui->GetDay(), /** The Day (in the month) */ paramAtmo->GetAtmosphericPressure(), /** The Atmospheric pressure */ paramAtmo->GetWaterVaporAmount(), /** The Water vapor amount (Total water vapor content over vertical atmospheric column) */ paramAtmo->GetOzoneAmount(), /** The Ozone amount (Stratospheric ozone layer content) */ paramAtmo->GetAerosolModel(), /** The Aerosol model */ paramAtmo->GetAerosolOptical(), /** The Aerosol optical (radiative impact of aerosol for the reference wavelength 550-nm) */ paramAcqui->GetWavelengthSpectralBand()->GetNthElement(i), /** Wavelength for the spectral band definition */ /** Note : The Max wavelength spectral band value must be updated ! */ atmosphericReflectance, /** Atmospheric reflectance */ atmosphericSphericalAlbedo, /** atmospheric spherical albedo */ totalGaseousTransmission, /** Total gaseous transmission */ downwardTransmittance, /** downward transmittance */ upwardTransmittance, /** upward transmittance */ upwardDiffuseTransmittance, /** Upward diffuse transmittance */ upwardDirectTransmittance, /** Upward direct transmittance */ upwardDiffuseTransmittanceForRayleigh, /** Upward diffuse transmittance for rayleigh */ upwardDiffuseTransmittanceForAerosol /** Upward diffuse transmittance for aerosols */ ); radTermsOut->SetIntrinsicAtmosphericReflectance(i, atmosphericReflectance); radTermsOut->SetSphericalAlbedo(i, atmosphericSphericalAlbedo); radTermsOut->SetTotalGaseousTransmission(i, totalGaseousTransmission); radTermsOut->SetDownwardTransmittance(i, downwardTransmittance); radTermsOut->SetUpwardTransmittance(i, upwardTransmittance); radTermsOut->SetUpwardDiffuseTransmittance(i, upwardDiffuseTransmittance); radTermsOut->SetUpwardDirectTransmittance(i, upwardDirectTransmittance); radTermsOut->SetUpwardDiffuseTransmittanceForRayleigh(i, upwardDiffuseTransmittanceForRayleigh); radTermsOut->SetUpwardDiffuseTransmittanceForAerosol(i, upwardDiffuseTransmittanceForAerosol); radTermsOut->SetWavelengthSpectralBand(i, paramAcqui->GetWavelengthSpectralBand()->GetNthElement(i)->GetCenterSpectralValue()); } return radTermsOut; } }; } //end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbReflectanceToImageImageFilter.h000066400000000000000000000264531301006202600330150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReflectanceToImageImageFilter_h #define otbReflectanceToImageImageFilter_h #include "otbLuminanceToImageImageFilter.h" #include "otbReflectanceToLuminanceImageFilter.h" namespace otb { namespace Functor { /** \class ReflectanceToImageImageFunctor * \brief Call the ReflectanceToLuminanceFunctor over the input and the LuminanceToImageFunctor to this result. * * * \sa ReflectanceToImageImageFilter * * \ingroup Functor * \ingroup LuminanceToImageFunctor * \ingroup ReflectanceToLuminanceFunctor * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ template class ReflectanceToImageImageFunctor { public: ReflectanceToImageImageFunctor() {} virtual ~ReflectanceToImageImageFunctor() {} typedef Functor::LuminanceToImageImageFunctor LumToImFunctorType; typedef Functor::ReflectanceToLuminanceImageFunctor ReflecToLumFunctorType; void SetAlpha(double alpha) { m_LumToImFunctor.SetAlpha(alpha); } void SetBeta(double beta) { m_LumToImFunctor.SetBeta(beta); } void SetSolarIllumination(double solarIllumination) { m_ReflecToLumFunctor.SetSolarIllumination(solarIllumination); } void SetIlluminationCorrectionCoefficient(double coef) { m_ReflecToLumFunctor.SetIlluminationCorrectionCoefficient(coef); } double GetAlpha() { return m_LumToImFunctor.GetAlpha(); } double GetBeta() { return m_LumToImFunctor.GetBeta(); } double GetSolarIllumination() { return m_ReflecToLumFunctor.GetSolarIllumination(); } double GetIlluminationCorrectionCoefficient() { return m_ReflecToLumFunctor.GetIlluminationCorrectionCoefficient(); } inline TOutput operator ()(const TInput& inPixel) const { TOutput outPixel; TOutput tempPix; tempPix = m_ReflecToLumFunctor(inPixel); outPixel = m_LumToImFunctor(tempPix); return outPixel; } private: LumToImFunctorType m_LumToImFunctor; ReflecToLumFunctorType m_ReflecToLumFunctor; }; } /** \class ReflectanceToImageImageFilter * \brief Convert a reflectance into a raw value value * * Transform a reflectance image into a classical image image. For this it uses the functor ReflectanceToImageFunctor calling for each component of each pixel. * The flux normalization coefficient (that is the ratio solar distance over mean solar distance) can be directly set or the user can * give the day and the month of the observation and the class will used a coefficient given by a 6S routine that will give the corresponding coefficient. * To note that in the case, 6S gives the square of the distances ratio. * * * For Spot image in the dimap format, the correction parameters are * retrieved automatically from the metadata * * \ingroup ReflectanceToImageImageFunctor * \ingroup LuminanceToImageImageFilter * \ingroup ReflectanceToLuminanceImageFilter * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT ReflectanceToImageImageFilter : public UnaryImageFunctorWithVectorImageFilter > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::ReflectanceToImageImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef ReflectanceToImageImageFilter Self; typedef UnaryImageFunctorWithVectorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(ReflectanceToImageImageFilter, UnaryImageFunctorWithVectorImageFiltermageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename itk::VariableLengthVector VectorType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; /** Set the absolute calibration gains. */ itkSetMacro(Alpha, VectorType); /** Give the absolute calibration gains. */ itkGetConstReferenceMacro(Alpha, VectorType); /** Set the absolute calibration bias. */ itkSetMacro(Beta, VectorType); /** Give the absolute calibration bias. */ itkGetConstReferenceMacro(Beta, VectorType); /** Set the solar illumination value. */ itkSetMacro(SolarIllumination, VectorType); /** Give the solar illumination value. */ itkGetConstReferenceMacro(SolarIllumination, VectorType); /** Set the zenithal solar angle. */ itkSetMacro(ZenithalSolarAngle, double); /** Give the zenithal solar angle. */ itkGetConstReferenceMacro(ZenithalSolarAngle, double); /** Set/Get the sun elevation angle (internally handled by the zenithal angle)*/ virtual void SetElevationSolarAngle(double elevationAngle) { double zenithalAngle = 90.0 - elevationAngle; if (this->m_ZenithalSolarAngle != zenithalAngle) { this->m_ZenithalSolarAngle = zenithalAngle; this->Modified(); } } virtual double GetElevationSolarAngle() const { return 90.0 - this->m_ZenithalSolarAngle; } /** Set the flux normalization coefficient. */ void SetFluxNormalizationCoefficient(double coef) { m_FluxNormalizationCoefficient = coef; m_IsSetFluxNormalizationCoefficient = true; this->Modified(); } /** Set the acquisition day. */ itkSetClampMacro(Day, int, 1, 31); /** Get the acquisition day. */ itkGetConstReferenceMacro(Day, int); /** Set the acquisition month. */ itkSetClampMacro(Month, int, 1, 12); /** Set the acquisition month. */ itkGetConstReferenceMacro(Month, int); protected: /** Constructor */ ReflectanceToImageImageFilter() : m_ZenithalSolarAngle(120.), //invalid value which will lead to negative radiometry m_FluxNormalizationCoefficient(1.), m_IsSetFluxNormalizationCoefficient(false), m_Day(0), m_Month(0) { m_Alpha.SetSize(0); m_Beta.SetSize(0); m_SolarIllumination.SetSize(0); }; /** Destructor */ ~ReflectanceToImageImageFilter() ITK_OVERRIDE {} /** Update the functor list and input parameters */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); if (m_Alpha.GetSize() == 0) { m_Alpha = imageMetadataInterface->GetPhysicalGain(); } if (m_Beta.GetSize() == 0) { m_Beta = imageMetadataInterface->GetPhysicalBias(); } if ((m_Day == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Day = imageMetadataInterface->GetDay(); } if ((m_Month == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Month = imageMetadataInterface->GetMonth(); } if (m_SolarIllumination.GetSize() == 0) { m_SolarIllumination = imageMetadataInterface->GetSolarIrradiance(); } if (m_ZenithalSolarAngle == 120.0) { //the zenithal angle is the complementary of the elevation angle m_ZenithalSolarAngle = 90.0 - imageMetadataInterface->GetSunElevation(); } otbMsgDevMacro(<< "Using correction parameters: "); otbMsgDevMacro(<< "Alpha (gain): " << m_Alpha); otbMsgDevMacro(<< "Beta (bias): " << m_Beta); otbMsgDevMacro(<< "Day: " << m_Day); otbMsgDevMacro(<< "Month: " << m_Month); otbMsgDevMacro(<< "Solar irradiance: " << m_SolarIllumination); otbMsgDevMacro(<< "Zenithal angle: " << m_ZenithalSolarAngle); if ((m_Alpha.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel()) || (m_Beta.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel()) || (m_SolarIllumination.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel())) { itkExceptionMacro( << "Alpha, Beta and SolarIllumination parameters should have the same size as the number of bands"); } this->GetFunctorVector().clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { FunctorType functor; double coefTemp = 0.; if (!m_IsSetFluxNormalizationCoefficient) { if (m_Day * m_Month != 0 && m_Day < 32 && m_Month < 13) { coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * VarSol::GetVarSol(m_Day,m_Month); } else { itkExceptionMacro(<< "Day has to be included between 1 and 31, Month between 1 and 12."); } } else { coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * m_FluxNormalizationCoefficient * m_FluxNormalizationCoefficient; } functor.SetIlluminationCorrectionCoefficient(coefTemp); functor.SetAlpha(m_Alpha[i]); functor.SetBeta(m_Beta[i]); functor.SetSolarIllumination(m_SolarIllumination[i]); this->GetFunctorVector().push_back(functor); } } private: /** Ponderation declaration*/ VectorType m_Alpha; VectorType m_Beta; /** Set the zenithal soalr angle. */ double m_ZenithalSolarAngle; /** Flux normalization coefficient. */ double m_FluxNormalizationCoefficient; /** Solar illumination value. */ VectorType m_SolarIllumination; /** Used to know if the user has set a value for the FluxNormalizationCoefficient parameter * or if the class has to compute it */ bool m_IsSetFluxNormalizationCoefficient; /** Acquisition Day*/ int m_Day; /** Acquisition Month*/ int m_Month; }; } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbReflectanceToLuminanceImageFilter.h000066400000000000000000000243601301006202600337010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReflectanceToLuminanceImageFilter_h #define otbReflectanceToLuminanceImageFilter_h #include "otbVarSol.h" #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbMath.h" #include "otbMacro.h" #include "otbOpticalImageMetadataInterfaceFactory.h" #include namespace otb { namespace Functor { /** * \class ReflectanceToLuminanceImageFunctor * \brief Compupute luminance from the reflectance value * * Divide by Pi and multiply by an illumination correction coefficient * and the given solar illumination. * * * \sa ReflectanceToLuminanceImageFilter * * \ingroup Functor * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ template class ReflectanceToLuminanceImageFunctor { public: ReflectanceToLuminanceImageFunctor() : m_SolarIllumination(1.0), m_IlluminationCorrectionCoefficient(1.0) {} virtual ~ReflectanceToLuminanceImageFunctor() {} void SetSolarIllumination(double solarIllumination) { m_SolarIllumination = solarIllumination; } void SetIlluminationCorrectionCoefficient(double coef) { m_IlluminationCorrectionCoefficient = coef; } double GetSolarIllumination() { return m_SolarIllumination; } double GetIlluminationCorrectionCoefficient() { return m_IlluminationCorrectionCoefficient; } inline TOutput operator ()(const TInput& inPixel) const { TOutput outPixel; double temp; temp = static_cast(inPixel) / static_cast(CONST_PI) * m_IlluminationCorrectionCoefficient * m_SolarIllumination; outPixel = static_cast(temp); return outPixel; } private: double m_SolarIllumination; double m_IlluminationCorrectionCoefficient; }; } /** \class ReflectanceToLuminanceImageFilter * \brief Convert reflectance value into luminance value * * Transform a reflectance image into the luminance. For this it uses the * functor ReflectanceToLuminanceImageFunctor calling for each component of each pixel. * * * For Spot image in the dimap format, the correction parameters are * retrieved automatically from the metadata * * \ingroup ImageToLuminanceImageFunctor * \ingroup Radiometry * * \example Radiometry/AtmosphericCorrectionSequencement.cxx * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT ReflectanceToLuminanceImageFilter : public UnaryImageFunctorWithVectorImageFilter > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::ReflectanceToLuminanceImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef ReflectanceToLuminanceImageFilter Self; typedef UnaryImageFunctorWithVectorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(ReflectanceToLuminanceImageFilter, UnaryImageFunctorWithVectorImageFiltermageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename itk::VariableLengthVector VectorType; /** Image size "typedef" definition. */ typedef typename InputImageType::SizeType SizeType; /** Set the solar illumination value. */ itkSetMacro(SolarIllumination, VectorType); /** Give the solar illumination value. */ itkGetConstReferenceMacro(SolarIllumination, VectorType); /** Set the zenithal solar angle. */ itkSetMacro(ZenithalSolarAngle, double); /** Give the zenithal solar angle. */ itkGetConstReferenceMacro(ZenithalSolarAngle, double); /** Set/Get the sun elevation angle (internally handled by the zenithal angle)*/ virtual void SetElevationSolarAngle(double elevationAngle) { double zenithalAngle = 90.0 - elevationAngle; if (this->m_ZenithalSolarAngle != zenithalAngle) { this->m_ZenithalSolarAngle = zenithalAngle; this->Modified(); } } virtual double GetElevationSolarAngle() const { return 90.0 - this->m_ZenithalSolarAngle; } /** Set the day. */ itkSetClampMacro(Day, int, 1, 31); /** Give the day. */ itkGetConstReferenceMacro(Day, int); /** Set the month. */ itkSetClampMacro(Month, int, 1, 12); /** Give the month. */ itkGetConstReferenceMacro(Month, int); /** Set the flux normalization coefficient. */ void SetFluxNormalizationCoefficient(double coef) { m_FluxNormalizationCoefficient = coef; m_IsSetFluxNormalizationCoefficient = true; this->Modified(); } /** Give the flux normalization coefficient. */ itkGetConstReferenceMacro(FluxNormalizationCoefficient, double); /** Set the IsSetFluxNormalizationCoefficient boolean. */ itkSetMacro(IsSetFluxNormalizationCoefficient, bool); /** Give the IsSetFluxNormalizationCoefficient boolean. */ itkGetConstReferenceMacro(IsSetFluxNormalizationCoefficient, bool); /** Set the UseClamp boolean. */ itkSetMacro(UseClamp, bool); /** Give the UseClamp boolean. */ itkGetConstReferenceMacro(UseClamp, bool); protected: /** Constructor */ ReflectanceToLuminanceImageFilter() : m_ZenithalSolarAngle(120.0), //invalid value which will lead to negative radiometry m_FluxNormalizationCoefficient(1.), m_Day(0), m_Month(0), m_IsSetFluxNormalizationCoefficient(false) { m_SolarIllumination.SetSize(0); }; /** Destructor */ ~ReflectanceToLuminanceImageFilter() ITK_OVERRIDE {} /** Update the functor list and input parameters */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); if ((m_Day == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Day = imageMetadataInterface->GetDay(); } if ((m_Month == 0) && (!m_IsSetFluxNormalizationCoefficient)) { m_Month = imageMetadataInterface->GetMonth(); } if (m_SolarIllumination.GetSize() == 0) { m_SolarIllumination = imageMetadataInterface->GetSolarIrradiance(); } if (m_ZenithalSolarAngle == 120.0) { //the zenithal angle is the complementary of the elevation angle m_ZenithalSolarAngle = 90.0 - imageMetadataInterface->GetSunElevation(); } std::cout << "Using correction parameters: " << std::endl; std::cout<< "Day: " << m_Day << std::endl; std::cout<< "Month: " << m_Month << std::endl; std::cout<< "Solar irradiance: " << m_SolarIllumination << std::endl; std::cout<< "Zenithal angle: " << m_ZenithalSolarAngle << std::endl; if ((m_SolarIllumination.GetSize() != this->GetInput()->GetNumberOfComponentsPerPixel())) { itkExceptionMacro(<< "SolarIllumination parameter should have the same size as the number of bands"); } this->GetFunctorVector().clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { FunctorType functor; double coefTemp = 0.; if (!m_IsSetFluxNormalizationCoefficient) { if (m_Day * m_Month != 0 && m_Day < 32 && m_Month < 13) { coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * VarSol::GetVarSol(m_Day,m_Month); } else { itkExceptionMacro(<< "Day has to be included between 1 and 31, Month between 1 and 12."); } } else { coefTemp = vcl_cos(m_ZenithalSolarAngle * CONST_PI_180) * m_FluxNormalizationCoefficient * m_FluxNormalizationCoefficient; } functor.SetIlluminationCorrectionCoefficient(coefTemp); functor.SetSolarIllumination(static_cast(m_SolarIllumination[i])); this->GetFunctorVector().push_back(functor); } } private: /** Set the zenithal soalr angle. */ double m_ZenithalSolarAngle; /** Flux normalization coefficient. */ double m_FluxNormalizationCoefficient; /** Acquisition day. */ int m_Day; /** Acquisition month. */ int m_Month; /** Solar illumination value. */ VectorType m_SolarIllumination; /** Used to know if the user has set a value for the FluxNormalizationCoefficient parameter * or if the class has to compute it */ bool m_IsSetFluxNormalizationCoefficient; /** Clamp values to [0,1] */ bool m_UseClamp; }; } // end namespace otb #endif otbReflectanceToSurfaceReflectanceImageFilter.h000066400000000000000000000227271301006202600354400ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReflectanceToSurfaceReflectanceImageFilter_h #define otbReflectanceToSurfaceReflectanceImageFilter_h #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h" #include "otbAtmosphericCorrectionParameters.h" #include "otbMacro.h" #include "itkMetaDataDictionary.h" #include namespace otb { namespace Functor { /** * \class ReflectanceToSurfaceReflectanceImageFunctor * \brief Compute the surface reflectance pixel from a TOA reflectance. * * \ingroup Functor * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ template class ReflectanceToSurfaceReflectanceImageFunctor { public: ReflectanceToSurfaceReflectanceImageFunctor() { m_Coefficient = 1.; m_Residu = 1.; m_SphericalAlbedo = 1.; } virtual ~ReflectanceToSurfaceReflectanceImageFunctor() {} /** * Set/Get the spherical albedo of the atmosphere. */ void SetSphericalAlbedo(double albedo) { m_SphericalAlbedo = albedo; } double GetSphericalAlbedo() { return m_SphericalAlbedo; } /** * Set/Get Coefficient, computed from AtmosphericRadiativeTermsPointerType datas. */ void SetCoefficient(double coef) { m_Coefficient = coef; } double GetCoefficient() { return m_Coefficient; } /** * Set/Get Residu, computed from AtmosphericRadiativeTermsPointerType datas. */ void SetResidu(double res) { m_Residu = res; } double GetResidu() { return m_Residu; } inline TOutput operator ()(const TInput& inPixel) { TOutput outPixel; double temp, temp2; temp = (static_cast(inPixel) + m_Residu)* m_Coefficient; temp2 = temp / (1. + m_SphericalAlbedo * temp); outPixel = static_cast(temp2); return outPixel; } private: double m_SphericalAlbedo; double m_Coefficient; double m_Residu; }; } /** \class ReflectanceToSurfaceReflectanceImageFilter * \brief Calculates the slope, the orientation incidence and exitance radius values for each pixel. * * * \ingroup AtmosphericRadiativeTerms * \ingroup AtmosphericCorrectionParameters * \ingroup LuminanceToReflectanceImageFilter * \ingroup ImageToReflectanceImageFilter * \ingroup ImageMetadataCorrectionParameters * \ingroup otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms * \ingroup Radiometry * * \example Radiometry/AtmosphericCorrectionSequencement.cxx * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT ReflectanceToSurfaceReflectanceImageFilter : public UnaryImageFunctorWithVectorImageFilter > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::ReflectanceToSurfaceReflectanceImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef ReflectanceToSurfaceReflectanceImageFilter Self; typedef UnaryImageFunctorWithVectorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(ReflectanceToSurfaceReflectanceImageFilter, UnaryImageFunctorWithVectorImageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef typename AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef typename AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef typename AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::WavelengthSpectralBandType ValueType; //float typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; //std::vector typedef typename AcquiCorrectionParametersType::WavelengthSpectralBandVectorType WavelengthSpectralBandVectorType; typedef itk::MetaDataDictionary MetaDataDictionaryType; /** Get/Set Atmospheric Radiative Terms. */ void SetAtmosphericRadiativeTerms(AtmosphericRadiativeTermsPointerType atmoRadTerms) { m_AtmosphericRadiativeTerms = atmoRadTerms; this->SetNthInput(1, m_AtmosphericRadiativeTerms); m_IsSetAtmosphericRadiativeTerms = true; this->Modified(); } itkGetObjectMacro(AtmosphericRadiativeTerms, AtmosphericRadiativeTermsType); /** Get/Set Atmospheric Correction Parameters. */ void SetAtmoCorrectionParameters(AtmoCorrectionParametersPointerType atmoCorrTerms) { m_AtmoCorrectionParameters = atmoCorrTerms; this->SetNthInput(2, m_AtmoCorrectionParameters); m_IsSetAtmoCorrectionParameters = true; this->Modified(); } itkGetObjectMacro(AtmoCorrectionParameters, AtmoCorrectionParametersType); /** Get/Set Acquisition Correction Parameters. */ void SetAcquiCorrectionParameters(AcquiCorrectionParametersPointerType acquiCorrTerms) { m_AcquiCorrectionParameters = acquiCorrTerms; this->SetNthInput(3, m_AcquiCorrectionParameters); m_IsSetAcquiCorrectionParameters = true; this->Modified(); } itkGetObjectMacro(AcquiCorrectionParameters, AcquiCorrectionParametersType); /** Compute radiative terms if necessary and then update functors attributs. */ void GenerateParameters(); /** Set/Get UseGenerateParameters. */ itkSetMacro(UseGenerateParameters, bool); itkGetMacro(UseGenerateParameters, bool); itkBooleanMacro(UseGenerateParameters); /** Set/Get IsSetAtmosphericRadiativeTerms */ itkSetMacro(IsSetAtmosphericRadiativeTerms, bool); itkGetMacro(IsSetAtmosphericRadiativeTerms, bool); itkBooleanMacro(IsSetAtmosphericRadiativeTerms); protected: /** Constructor */ ReflectanceToSurfaceReflectanceImageFilter(); /** Destructor */ ~ReflectanceToSurfaceReflectanceImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Initialize the parameters of the functor before the threads run. */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Fill AtmosphericRadiativeTerms using image metadata*/ void UpdateAtmosphericRadiativeTerms(); /** Update Functors parameters */ void UpdateFunctors(); /** If modified, we need to compute the functor parameters again */ void Modified() const ITK_OVERRIDE; private: bool m_IsSetAtmosphericRadiativeTerms; bool m_IsSetAtmoCorrectionParameters; bool m_IsSetAcquiCorrectionParameters; /** Enable/Disable GenerateParameters in GenerateOutputInformation. * Useful for image view that call GenerateOutputInformation each time you move the full area. */ bool m_UseGenerateParameters; /** True if the functor parameters have been generated */ mutable bool m_FunctorParametersHaveBeenComputed; AtmosphericRadiativeTermsPointerType m_AtmosphericRadiativeTerms; AtmoCorrectionParametersPointerType m_AtmoCorrectionParameters; AcquiCorrectionParametersPointerType m_AcquiCorrectionParameters; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbReflectanceToSurfaceReflectanceImageFilter.txx" #endif #endif otbReflectanceToSurfaceReflectanceImageFilter.txx000066400000000000000000000175351301006202600360350ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReflectanceToSurfaceReflectanceImageFilter_txx #define otbReflectanceToSurfaceReflectanceImageFilter_txx #include "otbReflectanceToSurfaceReflectanceImageFilter.h" #include "otbOpticalImageMetadataInterfaceFactory.h" namespace otb { /** * Constructor */ template ReflectanceToSurfaceReflectanceImageFilter ::ReflectanceToSurfaceReflectanceImageFilter() : m_IsSetAtmosphericRadiativeTerms(false), m_IsSetAtmoCorrectionParameters(false), m_IsSetAcquiCorrectionParameters(false), m_UseGenerateParameters(true) { m_AtmosphericRadiativeTerms = AtmosphericRadiativeTermsType::New(); m_AtmoCorrectionParameters = AtmoCorrectionParametersType::New(); m_AcquiCorrectionParameters = AcquiCorrectionParametersType::New(); } template void ReflectanceToSurfaceReflectanceImageFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); if (m_UseGenerateParameters) this->GenerateParameters(); } template void ReflectanceToSurfaceReflectanceImageFilter ::Modified() const { Superclass::Modified(); m_FunctorParametersHaveBeenComputed = false; } template void ReflectanceToSurfaceReflectanceImageFilter ::GenerateParameters() { if (!m_IsSetAtmosphericRadiativeTerms) { this->UpdateAtmosphericRadiativeTerms(); m_IsSetAtmosphericRadiativeTerms = true; } if (!m_FunctorParametersHaveBeenComputed) { this->UpdateFunctors(); m_FunctorParametersHaveBeenComputed = true; } } template void ReflectanceToSurfaceReflectanceImageFilter ::UpdateAtmosphericRadiativeTerms() { if (this->GetInput() == ITK_NULLPTR) { itkExceptionMacro(<< "Input must be set before updating the atmospheric radiative terms"); } // Atmospheric parameters if (!m_IsSetAtmoCorrectionParameters) { itkExceptionMacro(<< "Atmospheric correction parameters must be provided before updating the atmospheric radiative terms"); } // load filter function values bool SetFilterFunctionValuesFileName=false; if (m_AcquiCorrectionParameters->GetFilterFunctionValuesFileName() != "") { m_AcquiCorrectionParameters->LoadFilterFunctionValue(); SetFilterFunctionValuesFileName=true; } MetaDataDictionaryType dict = this->GetInput()->GetMetaDataDictionary(); OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI(dict); if (m_AtmoCorrectionParameters->GetAeronetFileName() != "") m_AtmoCorrectionParameters->UpdateAeronetData(imageMetadataInterface->GetYear(), imageMetadataInterface->GetHour(), imageMetadataInterface->GetMinute()); // Acquisition parameters if (!m_IsSetAcquiCorrectionParameters) // Get info from image metadata interface { m_AcquiCorrectionParameters = AcquiCorrectionParametersType::New(); m_AcquiCorrectionParameters->SetSolarZenithalAngle(90. - imageMetadataInterface->GetSunElevation()); m_AcquiCorrectionParameters->SetSolarAzimutalAngle(imageMetadataInterface->GetSunAzimuth()); m_AcquiCorrectionParameters->SetViewingZenithalAngle(90. - imageMetadataInterface->GetSatElevation()); m_AcquiCorrectionParameters->SetViewingAzimutalAngle(imageMetadataInterface->GetSatAzimuth()); m_AcquiCorrectionParameters->SetDay(imageMetadataInterface->GetDay()); m_AcquiCorrectionParameters->SetMonth(imageMetadataInterface->GetMonth()); if (!SetFilterFunctionValuesFileName) { if (imageMetadataInterface->GetSpectralSensitivity()->Capacity() > 0) { m_AcquiCorrectionParameters->SetWavelengthSpectralBand(imageMetadataInterface->GetSpectralSensitivity()); } else { otbMsgDevMacro(<< "use dummy filter"); WavelengthSpectralBandVectorType spectralDummy; spectralDummy->Clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { spectralDummy->PushBack(FilterFunctionValuesType::New()); } m_AcquiCorrectionParameters->SetWavelengthSpectralBand(spectralDummy); } } } m_AtmosphericRadiativeTerms = CorrectionParametersToRadiativeTermsType::Compute(m_AtmoCorrectionParameters,m_AcquiCorrectionParameters); } template void ReflectanceToSurfaceReflectanceImageFilter ::UpdateFunctors() { if (this->GetInput() == ITK_NULLPTR) { itkExceptionMacro(<< "Input must be set before updating the functors"); } MetaDataDictionaryType dict = this->GetInput()->GetMetaDataDictionary(); OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI(dict); this->GetFunctorVector().clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { double coef; double res; // Don't change the order of atmospheric parameters. //FIXME Need to check in 6S that //unsigned int wavelengthPosition = imageMetadataInterface->BandIndexToWavelengthPosition(i); unsigned int wavelengthPosition = i; coef = static_cast(m_AtmosphericRadiativeTerms->GetTotalGaseousTransmission(wavelengthPosition) * m_AtmosphericRadiativeTerms->GetDownwardTransmittance(wavelengthPosition) * m_AtmosphericRadiativeTerms->GetUpwardTransmittance(wavelengthPosition)); coef = 1. / coef; res = -m_AtmosphericRadiativeTerms->GetIntrinsicAtmosphericReflectance(wavelengthPosition); FunctorType functor; functor.SetCoefficient(coef); functor.SetResidu(res); functor.SetSphericalAlbedo(static_cast(m_AtmosphericRadiativeTerms->GetSphericalAlbedo(wavelengthPosition))); this->GetFunctorVector().push_back(functor); otbMsgDevMacro(<< "Parameters to compute surface reflectance: "); otbMsgDevMacro(<< "Band wavelengh position: " << wavelengthPosition); otbMsgDevMacro(<< "Coef (A): " << functor.GetCoefficient()); otbMsgDevMacro(<< "Residu: " << functor.GetResidu()); otbMsgDevMacro(<< "Spherical albedo: " << functor.GetSphericalAlbedo()); } } /* Standard "PrintSelf" method */ template void ReflectanceToSurfaceReflectanceImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "Atmospheric radiative terms : " << m_AtmosphericRadiativeTerms << std::endl; os << indent << "Atmospheric correction terms : " << m_AtmoCorrectionParameters << std::endl; os << indent << "Acquisition correction terms : " << m_AcquiCorrectionParameters << std::endl; } } //end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbSIXSTraits.h000066400000000000000000000120451301006202600271700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSIXSTraits_h #define otbSIXSTraits_h #include "OTBOpticalCalibrationExport.h" #include "otbAtmosphericCorrectionParameters.h" namespace otb { /** \class SIXSTraits * \brief SIXSTraits operations. * * Call 6S main function. The main method call 6S to calculate atmospheric correction parameters. * It use by the OTB Atmospheric correction framework. * * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT SIXSTraits { public: /** Standard class typedefs. */ typedef SIXSTraits Self; typedef FilterFunctionValues WavelengthSpectralType; typedef AtmosphericCorrectionParameters::AerosolModelType AerosolModelType; typedef WavelengthSpectralType::WavelengthSpectralBandType WavelengthSpectralBandType; typedef WavelengthSpectralType::ValuesVectorType ValuesVectorType; /** Call 6S main function */ static void ComputeAtmosphericParameters( const double SolarZenithalAngle, /** The Solar zenithal angle */ const double SolarAzimutalAngle, /** The Solar azimutal angle */ const double ViewingZenithalAngle, /** The Viewing zenithal angle */ const double ViewingAzimutalAngle, /** The Viewing azimutal angle */ const unsigned int Month, /** The Month */ const unsigned int Day, /** The Day (in the month) */ const double AtmosphericPressure, /** The Atmospheric pressure */ const double WaterVaporAmount, /** The Water vapor amount (Total water vapor content over vertical atmospheric column) */ const double OzoneAmount, /** The Ozone amount (Stratospheric ozone layer content) */ const AerosolModelType& AerosolModel, /** The Aerosol model */ const double AerosolOptical, /** The Aerosol optical (radiative impact of aerosol for the reference wavelength 550-nm) */ WavelengthSpectralType* WavelengthSpectralBand, /** Wavelength for the spectral band definition */ /** Note : The Max wavelength spectral band value must be updated ! */ double& AtmosphericReflectance, /** Atmospheric reflectance */ double& AtmosphericSphericalAlbedo, /** atmospheric spherical albedo */ double& TotalGaseousTransmission, /** Total gaseous transmission */ double& DownwardTransmittance, /** downward transmittance */ double& UpwardTransmittance, /** upward transmittance */ double& UpwardDiffuseTransmittance, /** upward diffuse transmittance */ double& UpwardDirectTransmittance, /** Upward direct transmittance */ double& UpwardDiffuseTransmittanceForRayleigh, /** upward diffuse transmittance for rayleigh */ double& UpwardDiffuseTransmittanceForAerosol /** upward diffuse transmittance for aerosols */ ); /** * Check the correpondance between the vector value size and * the interval number between min and max. * If the vector step is not at 0.0025, the new values are computed. * The output vector values is store in the m_FilterFunctionValues6S * of WavelengthSpectralBand * */ static void ComputeWavelengthSpectralBandValuesFor6S( const double SIXSStepOfWavelengthSpectralBandValues, WavelengthSpectralType* WavelengthSpectralBand ); static void ComputeEnvironmentalContribution(const double diffuseTransmittanceForRayleighScattering, const double diffuseTransmittanceForAerosolScattering, const double radiusInKilometers, const double altitude, const double cosineOfViewingAngle, double& rayleighEstimation, double& aerosolEstimation, double& globalEstimation); }; } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbSpectralSensitivityReader.h000066400000000000000000000064501301006202600323710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralSensitivityReader_h #define otbSpectralSensitivityReader_h #include "itkProcessObject.h" #include "itkImageBase.h" #include "otbObjectList.h" #include "otbFilterFunctionValues.h" #include "OTBOpticalCalibrationExport.h" namespace otb { /** \class SpectralSensitivityReader * \brief Read a file that contains spectral sensitivity * * This class read a file that contains spectral sensitivity values and fill * a structure that contains man and max wavelengths, the coefficients list and the step. * * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT SpectralSensitivityReader : public itk::ProcessObject { public: /** Standard class typedefs */ typedef SpectralSensitivityReader Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through the object factory */ itkNewMacro(Self); /** Standard type macros */ itkTypeMacro(SpectralSensitivityReader, itk::ProcessObject); typedef FilterFunctionValues::Pointer FFVFPointerType; typedef FilterFunctionValues::ValuesVectorType ValuesVectorType; typedef ObjectList WavelengthSpectralBandVectorType; typedef WavelengthSpectralBandVectorType::Pointer WavelengthSpectralBandVectorPointerType; typedef itk::ImageBase<2> ImageType; typedef ImageType::Pointer ImagePointerType; /** Get/Set filename */ itkGetConstMacro(FileName, std::string); itkSetStringMacro(FileName); /** Get/Set path */ itkGetConstMacro(DataPath, std::string); itkSetStringMacro(DataPath); /** Override of the GetOutput() method */ virtual WavelengthSpectralBandVectorType * GetOutput(void); virtual const WavelengthSpectralBandVectorType * GetOutput(void) const; /** Image */ itkSetObjectMacro(Image, ImageType); itkGetConstObjectMacro(Image, ImageType); protected: SpectralSensitivityReader(); ~SpectralSensitivityReader() ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** Find the filename using image metadata */ void FindFileName(); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Struct use to remove multiple spaces in file */ struct BothAre { char c; BothAre(char r) : c(r) {} bool operator()(char l, char r) const { return r == c && l == c; } }; private: SpectralSensitivityReader(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string m_FileName; std::string m_DataPath; ImagePointerType m_Image; }; } // end namespace otb #endif otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h000066400000000000000000000267741301006202600360040ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSurfaceAdjacencyEffectCorrectionSchemeFilter_h #define otbSurfaceAdjacencyEffectCorrectionSchemeFilter_h #include "itkNumericTraits.h" #include #include "otbUnaryFunctorNeighborhoodImageFilter.h" #include "itkVariableSizeMatrix.h" #include "otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h" #include namespace otb { namespace Functor { /** \class ComputeNeighborhoodContributionFunctor * \brief Unary neighborhood functor to compute the value of a pixel which is a sum * of the surrounding pixels value ponderated by a coefficient. * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBOpticalCalibration */ template class ComputeNeighborhoodContributionFunctor { public: ComputeNeighborhoodContributionFunctor() {} virtual ~ComputeNeighborhoodContributionFunctor() {} typedef itk::VariableSizeMatrix WeightingMatrixType; typedef typename std::vector WeightingValuesContainerType; typedef typename TOutput::RealValueType RealValueType; typedef std::vector DoubleContainerType; void SetWeightingValues(const WeightingValuesContainerType& cont) { m_WeightingValues = cont; } void SetUpwardTransmittanceRatio(DoubleContainerType upwardTransmittanceRatio) { m_UpwardTransmittanceRatio = upwardTransmittanceRatio; } void SetDiffuseRatio(DoubleContainerType diffuseRatio) { m_DiffuseRatio = diffuseRatio; } WeightingValuesContainerType GetWeightingValues() { return m_WeightingValues; } DoubleContainerType GetUpwardTransmittanceRatio() { return m_UpwardTransmittanceRatio; } DoubleContainerType GetDiffuseRatio() { return m_DiffuseRatio; } inline TOutput operator ()(const TNeighIter& it) { unsigned int neighborhoodSize = it.Size(); double contribution = 0.; TOutput outPixel; outPixel.SetSize(it.GetCenterPixel().Size()); // Loop over each component const unsigned int size = outPixel.GetSize(); for (unsigned int j = 0; j < size; ++j) { contribution = 0; // Load the current channel ponderation value matrix WeightingMatrixType TempChannelWeighting = m_WeightingValues[j]; // Loop over the neighborhood for (unsigned int i = 0; i < neighborhoodSize; ++i) { // Current neighborhood pixel index calculation unsigned int RowIdx = 0; unsigned int ColIdx = 0; RowIdx = i / TempChannelWeighting.Cols(); ColIdx = i - RowIdx*TempChannelWeighting.Cols(); // Extract the current neighborhood pixel ponderation double idVal = TempChannelWeighting(RowIdx, ColIdx); // Extract the current neighborhood pixel value TOutput tempPix = it.GetPixel(i); contribution += static_cast(tempPix[j]) * idVal; } outPixel[j] = static_cast(it.GetCenterPixel()[j]) *m_UpwardTransmittanceRatio[j] + contribution * m_DiffuseRatio[j]; } return outPixel; } private: WeightingValuesContainerType m_WeightingValues; DoubleContainerType m_UpwardTransmittanceRatio; DoubleContainerType m_DiffuseRatio; }; } /** \class SurfaceAdjacencyEffectCorrectionSchemeFilter * \brief Correct the scheme taking care of the surrounding pixels. * * The SurfaceAdjacencyEffectCorrectionSchemeFilter class allows introducing a neighbor correction to the * reflectance estimation. The satellite signal is considered as to be a combinaison of the signal coming from * the target pixel and a weighting of the siganls coming from the neighbor pixels. * * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ template class ITK_EXPORT SurfaceAdjacencyEffectCorrectionSchemeFilter : public UnaryFunctorNeighborhoodImageFilter< TInputImage, TOutputImage, typename Functor::ComputeNeighborhoodContributionFunctor, typename TOutputImage::PixelType> > { public: /** "typedef" to simplify the variables definition and the declaration. */ typedef Functor::ComputeNeighborhoodContributionFunctor, typename TOutputImage::PixelType> FunctorType; /** "typedef" for standard classes. */ typedef SurfaceAdjacencyEffectCorrectionSchemeFilter Self; typedef UnaryFunctorNeighborhoodImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::OutputImageType OutputImageType; typedef std::vector DoubleContainerType; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(SurfaceAdjacencyEffectCorrectionSchemeFilter, UnaryFunctorNeighborhoodImageFilter); /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::SizeType SizeType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef typename AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef typename AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef typename AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::WavelengthSpectralBandType ValueType; //float typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; //std::vector typedef typename AcquiCorrectionParametersType::WavelengthSpectralBandVectorType WavelengthSpectralBandVectorType; typedef itk::MetaDataDictionary MetaDataDictionaryType; /** Storage ponderation values types*/ typedef itk::VariableSizeMatrix WeightingMatrixType; typedef typename std::vector WeightingValuesContainerType; /** typedef for calculation*/ typedef typename itk::ConstNeighborhoodIterator NeighborIterType; /** Set/Get the Size of the neighbor window. */ void SetWindowRadius(unsigned int rad) { this->SetRadius(rad); m_WindowRadius = rad; this->Modified(); } itkGetConstReferenceMacro(WindowRadius, unsigned int); /** Set/Get the pixel spacing in kilometers */ itkSetMacro(PixelSpacingInKilometers, double); itkGetMacro(PixelSpacingInKilometers, double); /** Set/Get the viewing angle */ itkSetMacro(ZenithalViewingAngle, double); itkGetMacro(ZenithalViewingAngle, double); /** Get/Set Atmospheric Radiative Terms. */ void SetAtmosphericRadiativeTerms(AtmosphericRadiativeTermsPointerType atmoRadTerms) { m_AtmosphericRadiativeTerms = atmoRadTerms; this->SetNthInput(1, m_AtmosphericRadiativeTerms); m_IsSetAtmosphericRadiativeTerms = true; this->Modified(); } itkGetObjectMacro(AtmosphericRadiativeTerms, AtmosphericRadiativeTermsType); /** Get/Set Atmospheric Correction Parameters. */ void SetAtmoCorrectionParameters(AtmoCorrectionParametersPointerType atmoCorrTerms) { m_AtmoCorrectionParameters = atmoCorrTerms; this->SetNthInput(2, m_AtmoCorrectionParameters); m_IsSetAtmoCorrectionParameters = true; this->Modified(); } itkGetObjectMacro(AtmoCorrectionParameters, AtmoCorrectionParametersType); /** Get/Set Acquisition Correction Parameters. */ void SetAcquiCorrectionParameters(AcquiCorrectionParametersPointerType acquiCorrTerms) { m_AcquiCorrectionParameters = acquiCorrTerms; this->SetNthInput(3, m_AcquiCorrectionParameters); m_IsSetAcquiCorrectionParameters = true; this->Modified(); } itkGetObjectMacro(AcquiCorrectionParameters, AcquiCorrectionParametersType); /** Compute radiative terms if necessary and then update functors attibuts. */ void GenerateParameters(); /** Set/Get IsSetAtmosphericRadiativeTerms */ itkSetMacro(IsSetAtmosphericRadiativeTerms, bool); itkGetMacro(IsSetAtmosphericRadiativeTerms, bool); itkBooleanMacro(IsSetAtmosphericRadiativeTerms); protected: SurfaceAdjacencyEffectCorrectionSchemeFilter(); ~SurfaceAdjacencyEffectCorrectionSchemeFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Initialize the parameters of the functor before the threads run. */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Fill AtmosphericRadiativeTerms using image metadata*/ void UpdateAtmosphericRadiativeTerms(); /** Compute the functor parameters */ void UpdateFunctors(); /** If modified, we need to compute the functor parameters again */ void Modified() const ITK_OVERRIDE; private: bool m_IsSetAtmosphericRadiativeTerms; bool m_IsSetAtmoCorrectionParameters; bool m_IsSetAcquiCorrectionParameters; /** Radiative terms object */ AtmosphericRadiativeTermsPointerType m_AtmosphericRadiativeTerms; AtmoCorrectionParametersPointerType m_AtmoCorrectionParameters; AcquiCorrectionParametersPointerType m_AcquiCorrectionParameters; /** Size of the window. */ unsigned int m_WindowRadius; /** Weighting values for the neighbor pixels.*/ WeightingValuesContainerType m_WeightingValues; /** True if the functor parameters have been generated */ mutable bool m_FunctorParametersHaveBeenComputed; /** Pixel spacing in kilometers */ double m_PixelSpacingInKilometers; /** Viewing angle in degree */ double m_ZenithalViewingAngle; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.txx" #endif #endif otbSurfaceAdjacencyEffectCorrectionSchemeFilter.txx000066400000000000000000000216121301006202600363620ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSurfaceAdjacencyEffectCorrectionSchemeFilter_txx #define otbSurfaceAdjacencyEffectCorrectionSchemeFilter_txx #include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkNeighborhoodInnerProduct.h" #include "itkImageRegionIterator.h" #include "itkNeighborhoodAlgorithm.h" #include "itkOffset.h" #include "itkProgressReporter.h" #include "otbImage.h" #include "otbSIXSTraits.h" #include "otbMath.h" #include "otbOpticalImageMetadataInterfaceFactory.h" namespace otb { template SurfaceAdjacencyEffectCorrectionSchemeFilter ::SurfaceAdjacencyEffectCorrectionSchemeFilter() : m_IsSetAtmosphericRadiativeTerms(false), m_IsSetAtmoCorrectionParameters(false), m_IsSetAcquiCorrectionParameters(false), m_WindowRadius(1), m_FunctorParametersHaveBeenComputed(false), m_PixelSpacingInKilometers(1.), m_ZenithalViewingAngle(361.) { m_AtmosphericRadiativeTerms = AtmosphericRadiativeTermsType::New(); m_AtmoCorrectionParameters = AtmoCorrectionParametersType::New(); m_AcquiCorrectionParameters = AcquiCorrectionParametersType::New(); } template void SurfaceAdjacencyEffectCorrectionSchemeFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); this->GenerateParameters(); } template void SurfaceAdjacencyEffectCorrectionSchemeFilter ::Modified() const { Superclass::Modified(); m_FunctorParametersHaveBeenComputed = false; } template void SurfaceAdjacencyEffectCorrectionSchemeFilter ::UpdateAtmosphericRadiativeTerms() { if (this->GetInput() == ITK_NULLPTR) { itkExceptionMacro(<< "Input must be set before updating the atmospheric radiative terms"); } // Atmospheric parameters if (!m_IsSetAtmoCorrectionParameters) { itkExceptionMacro(<< "Atmospheric correction parameters must be provided before updating the atmospheric radiative terms"); } // Acquisition parameters if (!m_IsSetAcquiCorrectionParameters) // Get info from image metadata interface { MetaDataDictionaryType dict = this->GetInput()->GetMetaDataDictionary(); OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI(dict); m_AcquiCorrectionParameters = AcquiCorrectionParametersType::New(); m_AcquiCorrectionParameters->SetSolarZenithalAngle(90. - imageMetadataInterface->GetSunElevation()); m_AcquiCorrectionParameters->SetSolarAzimutalAngle(imageMetadataInterface->GetSunAzimuth()); m_AcquiCorrectionParameters->SetViewingZenithalAngle(90. - imageMetadataInterface->GetSatElevation()); m_AcquiCorrectionParameters->SetViewingAzimutalAngle(imageMetadataInterface->GetSatAzimuth()); m_AcquiCorrectionParameters->SetDay(imageMetadataInterface->GetDay()); m_AcquiCorrectionParameters->SetMonth(imageMetadataInterface->GetMonth()); if (imageMetadataInterface->GetSpectralSensitivity()->Capacity() > 0) { m_AcquiCorrectionParameters->SetWavelengthSpectralBand(imageMetadataInterface->GetSpectralSensitivity()); } else { otbMsgDevMacro(<< "use dummy filter"); WavelengthSpectralBandVectorType spectralDummy; spectralDummy->Clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { spectralDummy->PushBack(FilterFunctionValuesType::New()); } m_AcquiCorrectionParameters->SetWavelengthSpectralBand(spectralDummy); } } m_AtmosphericRadiativeTerms = CorrectionParametersToRadiativeTermsType::Compute(m_AtmoCorrectionParameters,m_AcquiCorrectionParameters); } template void SurfaceAdjacencyEffectCorrectionSchemeFilter ::GenerateParameters() { if (!m_IsSetAtmosphericRadiativeTerms) { this->UpdateAtmosphericRadiativeTerms(); m_IsSetAtmosphericRadiativeTerms = true; } if (!m_FunctorParametersHaveBeenComputed) { this->UpdateFunctors(); m_FunctorParametersHaveBeenComputed = true; } } template void SurfaceAdjacencyEffectCorrectionSchemeFilter ::UpdateFunctors() { // get pointers to the input and output typename InputImageType::Pointer inputPtr = const_cast(this->GetInput()); typename OutputImageType::Pointer outputPtr = const_cast(this->GetOutput()); WeightingMatrixType radiusMatrix(2*m_WindowRadius + 1, 2*m_WindowRadius + 1); radiusMatrix.Fill(0.); double center = static_cast(m_WindowRadius); for (unsigned int i = 0; i < m_WindowRadius + 1; ++i) { for (unsigned int j = 0; j < m_WindowRadius + 1; ++j) { double id = static_cast(i); double jd = static_cast(j); double currentRadius = m_PixelSpacingInKilometers * vcl_sqrt(vcl_pow(id - center, 2) + vcl_pow(jd - center, 2)); radiusMatrix(i, j) = currentRadius; radiusMatrix(2 * m_WindowRadius - i, j) = currentRadius; radiusMatrix(2 * m_WindowRadius - i, 2 * m_WindowRadius - j) = currentRadius; radiusMatrix(i, 2 * m_WindowRadius - j) = currentRadius; } } for (unsigned int band = 0; band < inputPtr->GetNumberOfComponentsPerPixel(); ++band) { double rayleigh = m_AtmosphericRadiativeTerms->GetUpwardDiffuseTransmittanceForRayleigh(band); double aerosol = m_AtmosphericRadiativeTerms->GetUpwardDiffuseTransmittanceForAerosol(band); WeightingMatrixType currentWeightingMatrix(2*m_WindowRadius + 1, 2*m_WindowRadius + 1); currentWeightingMatrix.Fill(0.); for (unsigned int i = 0; i < 2 * m_WindowRadius + 1; ++i) { for (unsigned int j = 0; j < 2 * m_WindowRadius + 1; ++j) { double notUsed1, notUsed2; double factor = 1; double palt = 1000.; SIXSTraits::ComputeEnvironmentalContribution(rayleigh, aerosol, radiusMatrix(i,j), palt, vcl_cos(m_ZenithalViewingAngle * CONST_PI_180), notUsed1, notUsed2, factor); //Call to 6S currentWeightingMatrix(i, j) = factor; } } m_WeightingValues.push_back(currentWeightingMatrix); } DoubleContainerType upwardTransmittanceRatio, diffuseRatio; for (unsigned int band = 0; band < inputPtr->GetNumberOfComponentsPerPixel(); ++band) { upwardTransmittanceRatio.push_back(m_AtmosphericRadiativeTerms->GetUpwardTransmittance( band) / m_AtmosphericRadiativeTerms->GetUpwardDirectTransmittance(band)); diffuseRatio.push_back(m_AtmosphericRadiativeTerms->GetUpwardDiffuseTransmittance( band) / m_AtmosphericRadiativeTerms->GetUpwardDirectTransmittance(band)); } this->GetFunctor().SetUpwardTransmittanceRatio(upwardTransmittanceRatio); this->GetFunctor().SetDiffuseRatio(diffuseRatio); this->GetFunctor().SetWeightingValues(m_WeightingValues); } /** * Standard "PrintSelf" method */ template void SurfaceAdjacencyEffectCorrectionSchemeFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "Radius : " << m_WindowRadius << std::endl; os << indent << "Pixel spacing in kilometers: " << m_PixelSpacingInKilometers << std::endl; os << indent << "Zenithal viewing angle in degree: " << m_AcquiCorrectionParameters->GetViewingZenithalAngle() << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbVarSol.h000066400000000000000000000034751301006202600264300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVarSol_h #define otbVarSol_h #include "itkMacro.h" #include "otbMath.h" namespace otb { /** \class VarSol * \brief VarSol operations. * * Call VarSol main function * * [1] Vermote, E., Tanre, D., Deuze, J., Herman, M., Morcette, J., 1997. * Second simulation of the satellite signal in the solar spectrum, 6S: An overview. * IEEE Transactions on Geoscience and Remote Sensing 35 * \ingroup Radiometry * * * \ingroup OTBOpticalCalibration */ class ITK_EXPORT VarSol { public: /** Call the varSol function*/ static double GetVarSol(const int day, const int month) { /* System generated locals */ double d__1; /* Local variables */ int j; double om; /* calculation of the variability of the solar constant during the year. */ /* day is the number of the day in the month */ if (month <= 2) j = (month - 1) * 31 + day; else if (month > 8) j = (month - 1) * 31 - (month - 2) / 2 - 2 + day; else j = (month - 1) * 31 - (month - 1) / 2 - 2 + day; om = (double) (j - 4) * .9856 * CONST_PI_180; /* Computing 2nd power */ d__1 = 1. - vcl_cos(om) * .01673; return 1. / (d__1 * d__1); } }; } //end namespace otb #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/include/otbWavelengthSpectralBands.h000066400000000000000000000046321301006202600317700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWavelengthSpectralBands_h #define otbWavelengthSpectralBands_h #include "otbObjectList.h" #include "otbFilterFunctionValues.h" #include "OTBOpticalCalibrationExport.h" namespace otb { /** \class WavelengthSpectralBands * \brief This class contains the values of the filter functions * * \ingroup IO * * \ingroup OTBOpticalCalibration */ class OTBOpticalCalibration_EXPORT WavelengthSpectralBands : public itk::DataObject { public: /** Standard typedefs */ typedef WavelengthSpectralBands Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkTypeMacro(WavelengthSpectralBands, DataObject); /** Creation through object factory macro */ itkNewMacro(Self); typedef FilterFunctionValues FilterFunctionValuesType; typedef ObjectList InternalWavelengthSpectralBandListType; typedef InternalWavelengthSpectralBandListType::Pointer WavelengthSpectralBandListType; //typedef std::map FilterFunctionValuesMapType; /** Set the number of bands. */ itkSetMacro(NbBands, unsigned int); /** Get the number of bands. */ itkGetMacro(NbBands, unsigned int); protected: /** Constructor */ WavelengthSpectralBands(); /** Destructor */ ~WavelengthSpectralBands() ITK_OVERRIDE {} /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: WavelengthSpectralBands(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** List that contains the filter function value. */ WavelengthSpectralBandListType m_WavelengthSpectralBandsList; unsigned int m_NbBands; }; } //end namespace #endif OTB-release-5.8/Modules/Radiometry/OpticalCalibration/otb-module.cmake000066400000000000000000000011141301006202600257560ustar00rootroot00000000000000set(DOCUMENTATION "Digital number to luminance correction. luminance to refletance image conversion. atmospheric correction for TOA (top of atmosphere) to TOC (top of canopy) reflectance estimation. correction of the adjacency effects taking into account the neighborhood contribution.") otb_module(OTBOpticalCalibration ENABLE_SHARED DEPENDS OTB6S OTBBoostAdapters OTBCommon OTBITK OTBImageBase OTBImageManipulation OTBMetadata OTBOSSIMAdapters OTBObjectList TEST_DEPENDS OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/000077500000000000000000000000001301006202600234775ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/CMakeLists.txt000066400000000000000000000012601301006202600262360ustar00rootroot00000000000000set(OTBOpticalCalibration_SRC otbAtmosphericCorrectionParameters.cxx otbAeronetData.cxx otbWavelengthSpectralBands.cxx otbSpectralSensitivityReader.cxx otbAeronetFileReader.cxx otbSIXSTraits.cxx otbAtmosphericRadiativeTerms.cxx otbImageMetadataCorrectionParameters.cxx ) add_library(OTBOpticalCalibration ${OTBOpticalCalibration_SRC}) target_link_libraries(OTBOpticalCalibration ${OTB6S_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBITK_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBMetadata_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBObjectList_LIBRARIES} ) otb_module_target(OTBOpticalCalibration) OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbAeronetData.cxx000066400000000000000000000033571301006202600271270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAeronetData.h" namespace otb { /** * Constructor */ AeronetData ::AeronetData() : m_AngstromCoefficient(0), m_Water(0), m_AerosolOpticalThickness(0), m_CloudEstimation(false), m_SolarZenithAngle(0), m_StdDev(0.0), m_DataDate(""), m_EpsilonDate(0.0), m_NumberOfDateUsed(0) {} /** * PrintSelf method */ void AeronetData ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << "Angstrom coefficient : " << m_AngstromCoefficient << std::endl; os << "Water data : " << m_Water << std::endl; os << "Aerosol optical thickness data: " << m_AerosolOpticalThickness << std::endl; os << "Cloud estimation dat : " << m_CloudEstimation << std::endl; os << "Solar Zenith Angle : " << m_SolarZenithAngle << std::endl; os << "Statistic : Standard deviation data: " << m_StdDev << std::endl; os << "Data Date : " << m_DataDate << std::endl; os << "Epsilon to select time : " << m_EpsilonDate << std::endl; os << "Number of date used: " << m_NumberOfDateUsed << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbAeronetFileReader.cxx000066400000000000000000000240111301006202600302460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAeronetFileReader.h" #include #include #include #include "otbMath.h" #include "otbAeronetData.h" namespace otb { namespace internal { typedef struct { int year; int month; int day; int hour; int minute; int second; } Date; double GetJulian(const Date& date) { // From // http://en.wikipedia.org/wiki/Julian_day#Converting_Julian_or_Gregorian_calendar_date_to_Julian_Day_Number // the value is slightly different than the one provided by the ossim // method, but this is now correct according to // http://aa.usno.navy.mil/data/docs/JulianDate.php int a = (14-date.month)/12.0; int y = date.year + 4800 - a; int m = date.month + 12 * a - 3; int jdn = date.day + (153 * m +2)/5 + 365*y + y/4 - y/100 + y/400 - 32045; return jdn + (date.hour-12)/24. + date.minute/1440. + date.second/86400.; } Date ParseDate(const std::string& d, const std::string& t) { Date date; date.day = atoi(d.substr(0,2).c_str()); date.month = atoi(d.substr(3,2).c_str()); date.year = atoi(d.substr(6,4).c_str()); date.hour = atoi(t.substr(0,2).c_str()); date.minute = atoi(t.substr(3,2).c_str()); date.second = atoi(t.substr(6,2).c_str()); return date; } } /** * Constructor */ AeronetFileReader ::AeronetFileReader() : m_FileName(""), m_Day(1), m_Month(1), m_Year(2000), m_Hour(12), m_Minute(0), m_Epsilon(0.4) { this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, AeronetData::New().GetPointer()); } /** * Destructor */ AeronetFileReader ::~AeronetFileReader() { } /** * Get the output aeronet data * \return The aeronet data extracted. */ AeronetData * AeronetFileReader ::GetOutput(void) { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } /** * Parse line method */ AeronetFileReader::VectorString AeronetFileReader ::ParseLine(const std::string& line) const { VectorString strVector; std::string word(""); strVector.clear(); for (unsigned int i = 0; i < line.size(); ++i) { if (line[i] == ',') { strVector.push_back(word); word = ""; } else if (i == (line.size() - 1)) { word.push_back(line[i]); strVector.push_back(word); word = ""; } else { word.push_back(line[i]); } } return strVector; } /** * Parse a valid line method */ void AeronetFileReader ::ParseValidLine(const double& ref_date, const VectorString& line, const double& epsilon, VectorDouble& water, VectorDouble& angst, VectorDouble& tau_day, VectorDouble& solarZenithAngle) const { unsigned int col_date = 0; unsigned int col_time = 1; unsigned int col_670 = 6; unsigned int col_440 = 15; unsigned int col_angst = 37; unsigned int col_vapor = 19; unsigned int col_solarZenithAngle = 44; internal::Date current_date = internal::ParseDate(line[col_date], line[col_time]); double dcurrent_date = GetJulian(current_date); // Check hour +/- epsilon if (vcl_abs(dcurrent_date - ref_date) < epsilon) { double dwater = atof(line[col_vapor].c_str()); double dangst = atof(line[col_angst].c_str()); double dsolarZenithAngle = atof(line[col_solarZenithAngle].c_str()); double dtau_670 = atof(line[col_670].c_str()); double dtau_440 = atof(line[col_440].c_str()); double dtau_550 = ((670. - 550.) * dtau_440 + (550 - 440) * dtau_670) / (670. - 440.); tau_day.push_back(dtau_550); angst.push_back(dangst); water.push_back(dwater); solarZenithAngle.push_back(dsolarZenithAngle); } } /** * Compute statistics method */ void AeronetFileReader ::GetStatistics(const VectorDouble& vec, double& mean, double& stddev) const { double sum(0.); double sumOfSquares(0.); mean = 0.; stddev = 0.; if (vec.size() <= 0) return; for (unsigned int i = 0; i < vec.size(); ++i) { sum += vec[i]; sumOfSquares += vec[i] * vec[i]; } // get the mean value const double num = static_cast(vec.size()); if (num == 1) { mean = sum; stddev = 0.; } else if (num > 1) { mean = sum / num; stddev = (sumOfSquares - (sum * sum / num)) / (num - 1.); } } /** * Generate data method */ void AeronetFileReader ::GenerateData() { std::ifstream fin; std::string line; // open file input stream fin.open(m_FileName.c_str()); // Test if the file has been opened correctly if (!fin) { AeronetFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << " Could not open IO object for file "; msg << m_FileName << "." << std::endl; e.SetDescription(msg.str().c_str()); throw e; return; } // Read information lines (5 lines) std::getline(fin, line); std::getline(fin, line); std::getline(fin, line); std::getline(fin, line); std::getline(fin, line); unsigned int col_date = 0; unsigned int col_time = 1; unsigned int col_670 = 6; unsigned int col_440 = 15; unsigned int col_angst = 37; unsigned int col_vapor = 19; unsigned int col_solarZenithAngle = 44; VectorString list_str; list_str = ParseLine(line); if ((list_str[col_date] != "Date(dd-mm-yy)") || (list_str[col_time] != "Time(hh:mm:ss)") || (list_str[col_670] != "AOT_675") || (list_str[col_440] != "AOT_440") || (list_str[col_angst] != "440-870Angstrom") || (list_str[col_vapor] != "Water(cm)") || (list_str[col_solarZenithAngle] != "Solar_Zenith_Angle") ) { AeronetFileReaderException e(__FILE__, __LINE__); std::ostringstream msg; msg << " The file "; msg << m_FileName << " is not conform." << std::endl; e.SetDescription(msg.str().c_str()); throw e; return; } //Compute input date internal::Date date = {m_Year, m_Month, m_Day, m_Hour, m_Minute, 0}; double dinputDate = internal::GetJulian(date); MatrixString tabStr; // if so, parse it and select only valid lines for the input date while (!fin.eof()) { std::getline(fin, line); std::string word(""); VectorString listStr; listStr = ParseLine(line); // Select only valid lines: good day if (listStr.size() > 0) { internal::Date currentDate = internal::ParseDate(listStr[col_date], listStr[col_time]); if ((listStr[col_670] != "N/A") && (listStr[col_440] != "N/A") && (static_cast(GetJulian(currentDate)) == static_cast(dinputDate)) ) { tabStr.push_back(listStr); } } } fin.close(); if (tabStr.size() <= 0) { itkExceptionMacro( << "The aeronet file (" << m_FileName << ") doesn't contain valid data for the day (dd/mm/yyyy) " << m_Day << "/" << m_Month << "/" << m_Year << "."); } //Compute time for one hour internal::Date temp = {m_Year, m_Month, m_Day, 10, 0, 0}; double dhour1 = internal::GetJulian(temp); temp.hour = 11; double dhour2 = internal::GetJulian(temp); // Update epsilon for one hour double epsilon = m_Epsilon * (dhour2 - dhour1); VectorDouble water; VectorDouble tau_day; VectorDouble angst; VectorDouble solarZenithAngle; for (unsigned int idCurrentLine = 0; idCurrentLine < tabStr.size(); idCurrentLine++) { VectorString current_line2 = tabStr[idCurrentLine]; ParseValidLine(dinputDate, current_line2, epsilon, water, angst, tau_day, solarZenithAngle); } if (tau_day.size() <= 0) { itkExceptionMacro( << "The aeronet file (" << m_FileName << ") doesn't contain valid data for the time (hh:mm:ss) " << m_Hour << ":" << m_Minute << ":00 with a tolerance of " << m_Epsilon << ". Select an other file or increase the epsilon value."); } double tau_mean(0.); double tau_stddev(0.); GetStatistics(tau_day, tau_mean, tau_stddev); if (tau_stddev > 0.8) { itkExceptionMacro(<< "The stddev of the Aerosol Optical Thickness selected is upper than 0.8."); } double angst_mean(0.); double angst_stddev(0.); double water_mean(0.); double water_stddev(0.); double solarZenithAngle_mean(0.); double solarZenithAngle_stddev(0.); // double stddev = (0.02 > tau_stddev ? 0.02 : tau_stddev ); double stddev(tau_stddev); GetStatistics(angst, angst_mean, angst_stddev); GetStatistics(water, water_mean, water_stddev); GetStatistics(solarZenithAngle, solarZenithAngle_mean, solarZenithAngle_stddev); AeronetData * aeronetData = this->GetOutput(); aeronetData->SetAerosolOpticalThickness(tau_mean); aeronetData->SetStdDev(stddev); aeronetData->SetAngstromCoefficient(angst_mean); aeronetData->SetWater(water_mean); aeronetData->SetSolarZenithAngle(solarZenithAngle_mean); std::ostringstream msg; msg << "(hh/mm/yyyy hh:mm:ss) " << m_Day << "/" << m_Month << "/" << m_Year << " " << m_Hour << ":" << m_Minute << ":00"; std::string str(msg.str()); aeronetData->SetDataDate(str); aeronetData->SetNumberOfDateUsed(tau_day.size()); aeronetData->SetEpsilonDate(m_Epsilon); // Cloud estimation if (stddev > 0.05) { aeronetData->SetCloudEstimation(true); } else { aeronetData->SetCloudEstimation(false); } } /** * PrintSelf method */ void AeronetFileReader ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbAtmosphericCorrectionParameters.cxx000066400000000000000000000043741301006202600332720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAtmosphericCorrectionParameters.h" #include #include "otbAeronetFileReader.h" #include "otbSpectralSensitivityReader.h" #include "otbAeronetData.h" namespace otb { AtmosphericCorrectionParameters ::AtmosphericCorrectionParameters() { m_AtmosphericPressure = 1030.; m_WaterVaporAmount = 2.5; m_OzoneAmount = 0.28; m_AerosolModel = CONTINENTAL; m_AerosolOptical = 0.2; m_AeronetFileName = ""; m_Day = 1; m_Month = 1; } /** Get data from aeronet file*/ void AtmosphericCorrectionParameters ::UpdateAeronetData(const std::string& file, int year, int month, int day, int hour, int minute, double epsi) { if (file == "") itkExceptionMacro(<< "No Aeronet filename specified."); AeronetFileReader::Pointer reader = AeronetFileReader::New(); reader->SetFileName(file); reader->SetDay(day); reader->SetMonth(month); reader->SetYear(year); reader->SetHour(hour); reader->SetMinute(minute); reader->SetEpsilon(epsi); reader->Update(); m_AerosolOptical = reader->GetOutput()->GetAerosolOpticalThickness(); m_WaterVaporAmount = reader->GetOutput()->GetWater(); } /**PrintSelf method */ void AtmosphericCorrectionParameters ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << indent << "Atmospheric pressure : " << m_AtmosphericPressure << std::endl; os << indent << "Water vapor amount : " << m_WaterVaporAmount << std::endl; os << indent << "Ozone amount : " << m_OzoneAmount << std::endl; os << indent << "Aerosol model : " << m_AerosolModel << std::endl; os << indent << "Aerosol optical : " << m_AerosolOptical << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbAtmosphericRadiativeTerms.cxx000066400000000000000000000446341301006202600320650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAtmosphericRadiativeTerms.h" namespace otb { /************** AtmosphericRadiativeTermsSingleChannel******************/ /** Constructor */ AtmosphericRadiativeTermsSingleChannel::AtmosphericRadiativeTermsSingleChannel() : m_IntrinsicAtmosphericReflectance(0.04), m_SphericalAlbedo(0.09), m_TotalGaseousTransmission(0.95), m_DownwardTransmittance(0.91), m_UpwardTransmittance(0.94), m_UpwardDiffuseTransmittance(0.09), m_UpwardDirectTransmittance(0.85), m_UpwardDiffuseTransmittanceForRayleigh(0.05), m_UpwardDiffuseTransmittanceForAerosol(0.04), m_WavelengthSpectralBand(0.0) { } /**PrintSelf method */ void AtmosphericRadiativeTermsSingleChannel ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Atmospheric Intrinsic Reflectance : " << m_IntrinsicAtmosphericReflectance << std::endl; os << indent << "Atmosphere Shperical Albedo : " << m_SphericalAlbedo << std::endl; os << indent << "Total Gaseous Transmission : " << m_TotalGaseousTransmission << std::endl; os << indent << "Atmospher Downward Transmittance : " << m_DownwardTransmittance << std::endl; os << indent << "Atmospher Upward Transmittance : " << m_UpwardTransmittance << std::endl; os << indent << "Upward Diffuse Transmittance : " << m_UpwardDiffuseTransmittance << std::endl; os << indent << "Upward Direct Transmittance : " << m_UpwardDirectTransmittance << std::endl; os << indent << "Upward Diffuse Transmittance for Rayleigh: " << m_UpwardDiffuseTransmittanceForRayleigh << std::endl; os << indent << "Upward Diffuse Transmittance for aerosols: " << m_UpwardDiffuseTransmittanceForAerosol << std::endl; } /***************** AtmosphericRadiativeTerms **************************/ /**CONSTRUCTOR. */ AtmosphericRadiativeTerms ::AtmosphericRadiativeTerms() { m_Values.clear(); m_IsInitialized = false; } void AtmosphericRadiativeTerms ::ValuesInitialization(DataVectorSizeType nbChannel) { for (DataVectorSizeType j = 0; j < nbChannel; ++j) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } m_IsInitialized = true; } /** SET ACCESSORS WITH VECTORS. */ void AtmosphericRadiativeTerms ::SetIntrinsicAtmosphericReflectances(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetIntrinsicAtmosphericReflectance(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetSphericalAlbedos(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetSphericalAlbedo(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetTotalGaseousTransmissions(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetTotalGaseousTransmission(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetDownwardTransmittances(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetDownwardTransmittance(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetUpwardTransmittances(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetUpwardTransmittance(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetUpwardDiffuseTransmittances(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetUpwardDiffuseTransmittance(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetUpwardDirectTransmittances(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetUpwardDirectTransmittance(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetUpwardDiffuseTransmittancesForRayleigh(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetUpwardDiffuseTransmittanceForRayleigh(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetUpwardDiffuseTransmittancesForAerosol(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetUpwardDiffuseTransmittanceForAerosol(vect[nbChannel]); } } void AtmosphericRadiativeTerms ::SetWavelengthSpectralBand(const DataVectorType& vect) { if (!m_IsInitialized) { this->ValuesInitialization(vect.size()); } for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel) { m_Values[nbChannel]->SetWavelengthSpectralBand(vect[nbChannel]); } } /** SET ACCESSORS WITH INDEX. */ void AtmosphericRadiativeTerms ::SetValueByIndex(unsigned int id, const ValueType& val) { if (m_IsInitialized) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id] = val; } else { itkExceptionMacro(<< "Can't insert value before iniatilizing vector value..." << std::endl); } } void AtmosphericRadiativeTerms ::SetIntrinsicAtmosphericReflectance(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetIntrinsicAtmosphericReflectance(val); } void AtmosphericRadiativeTerms ::SetSphericalAlbedo(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetSphericalAlbedo(val); } void AtmosphericRadiativeTerms ::SetTotalGaseousTransmission(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetTotalGaseousTransmission(val); } void AtmosphericRadiativeTerms ::SetDownwardTransmittance(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetDownwardTransmittance(val); } void AtmosphericRadiativeTerms ::SetUpwardTransmittance(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetUpwardTransmittance(val); } void AtmosphericRadiativeTerms ::SetUpwardDiffuseTransmittance(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetUpwardDiffuseTransmittance(val); } void AtmosphericRadiativeTerms ::SetUpwardDirectTransmittance(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetUpwardDirectTransmittance(val); } void AtmosphericRadiativeTerms ::SetUpwardDiffuseTransmittanceForRayleigh(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetUpwardDiffuseTransmittanceForRayleigh(val); } void AtmosphericRadiativeTerms ::SetUpwardDiffuseTransmittanceForAerosol(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetUpwardDiffuseTransmittanceForAerosol(val); } void AtmosphericRadiativeTerms ::SetWavelengthSpectralBand(unsigned int id, const double& val) { if (m_Values.size() < id + 1) { while (id >= m_Values.size()) { ValueType temp = AtmosphericRadiativeTermsSingleChannel::New(); m_Values.push_back(temp); } } m_Values[id]->SetWavelengthSpectralBand(val); } /** GET ACCESSORS WITH VECTORS. */ AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetIntrinsicAtmosphericReflectances() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetIntrinsicAtmosphericReflectance(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetSphericalAlbedos() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetSphericalAlbedo(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetTotalGaseousTransmissions() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetTotalGaseousTransmission(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetDownwardTransmittances() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetDownwardTransmittance(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetUpwardTransmittances() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetUpwardTransmittance(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetUpwardDiffuseTransmittances() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetUpwardDiffuseTransmittance(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetUpwardDirectTransmittances() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetUpwardDirectTransmittance(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetUpwardDiffuseTransmittancesForRayleigh() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetUpwardDiffuseTransmittanceForRayleigh(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetUpwardDiffuseTransmittancesForAerosol() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetUpwardDiffuseTransmittanceForAerosol(); } return vect; } AtmosphericRadiativeTerms::DataVectorType AtmosphericRadiativeTerms ::GetWavelengthSpectralBand() const { DataVectorType vect(m_Values.size(), 0); for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel) { vect[nbChannel] = m_Values[nbChannel]->GetWavelengthSpectralBand(); } return vect; } /** GET ACCESSORS WITH INDEX. */ double AtmosphericRadiativeTerms ::GetIntrinsicAtmosphericReflectance(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetIntrinsicAtmosphericReflectance(); } double AtmosphericRadiativeTerms ::GetSphericalAlbedo(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetSphericalAlbedo(); } double AtmosphericRadiativeTerms ::GetTotalGaseousTransmission(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetTotalGaseousTransmission(); } double AtmosphericRadiativeTerms ::GetDownwardTransmittance(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetDownwardTransmittance(); } double AtmosphericRadiativeTerms ::GetUpwardTransmittance(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetUpwardTransmittance(); } double AtmosphericRadiativeTerms ::GetUpwardDiffuseTransmittance(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetUpwardDiffuseTransmittance(); } double AtmosphericRadiativeTerms ::GetUpwardDirectTransmittance(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetUpwardDirectTransmittance(); } double AtmosphericRadiativeTerms ::GetUpwardDiffuseTransmittanceForRayleigh(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetUpwardDiffuseTransmittanceForRayleigh(); } double AtmosphericRadiativeTerms ::GetUpwardDiffuseTransmittanceForAerosol(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetUpwardDiffuseTransmittanceForAerosol(); } double AtmosphericRadiativeTerms ::GetWavelengthSpectralBand(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]->GetWavelengthSpectralBand(); } const AtmosphericRadiativeTerms::ValueType AtmosphericRadiativeTerms ::GetValueByIndex(unsigned int id) const { if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id << " for " << m_Values.size() << " bands."); return m_Values[id]; } /**PrintSelf method */ void AtmosphericRadiativeTerms ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << m_Values.size() << " channels:" << std::endl; for (unsigned int i = 0; i < m_Values.size(); ++i) { os << "Channel " << i << " : " << std::endl; //ValueType::(os, indent); os << indent << "Intrinsic Atmospheric Reflectance : " << m_Values[i]->GetIntrinsicAtmosphericReflectance() << std::endl; os << indent << "Shperical Albedo of the Atmosphere : " << m_Values[i]->GetSphericalAlbedo() << std::endl; os << indent << "Total Gaseous Transmission : " << m_Values[i]->GetTotalGaseousTransmission() << std::endl; os << indent << "Atmosphere Downward Transmittance : " << m_Values[i]->GetDownwardTransmittance() << std::endl; os << indent << "Atmosphere Upward Transmittance : " << m_Values[i]->GetUpwardTransmittance() << std::endl; os << indent << "Upward Diffuse Transmittance : " << m_Values[i]->GetUpwardDiffuseTransmittance() << std::endl; os << indent << "Upward Direct Transmittance : " << m_Values[i]->GetUpwardDirectTransmittance() << std::endl; os << indent << "Rayleigh Upward Diffuse Transmittance : " << m_Values[i]->GetUpwardDiffuseTransmittanceForRayleigh() << std::endl; os << indent << "Aerosols Upward Diffuse Transmittance : " << m_Values[i]->GetUpwardDiffuseTransmittanceForAerosol() << std::endl; os << indent << "Wavelength : " << m_Values[i]->GetWavelengthSpectralBand() << std::endl; } } } // end namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbImageMetadataCorrectionParameters.cxx000066400000000000000000000050561301006202600334750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageMetadataCorrectionParameters.h" #include "otbSpectralSensitivityReader.h" namespace otb { /*********************** ImageMetadataCorrectionParameters **************************/ /** * Constructor */ ImageMetadataCorrectionParameters ::ImageMetadataCorrectionParameters() { m_SolarZenithalAngle = 361.; m_SolarAzimutalAngle = 361.; m_ViewingZenithalAngle = 361.; m_ViewingAzimutalAngle = 361.; m_Month = 0; m_Day = 0; m_Year = 0; m_FilterFunctionValuesFileName = ""; m_WavelengthSpectralBand = InternalWavelengthSpectralBandVectorType::New(); m_WavelengthSpectralBand->Clear(); } /** Get data from filter function file*/ void ImageMetadataCorrectionParameters ::LoadFilterFunctionValue(const std::string& filename) { m_WavelengthSpectralBand->Clear(); SpectralSensitivityReader::Pointer spectralSensitivityReader = SpectralSensitivityReader::New(); spectralSensitivityReader->SetFileName(filename); spectralSensitivityReader->Update(); m_WavelengthSpectralBand = spectralSensitivityReader->GetOutput(); } /**PrintSelf method */ void ImageMetadataCorrectionParameters ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << "Solar zenithal angle : " << m_SolarZenithalAngle << std::endl; os << "Solar azimutal angle : " << m_SolarAzimutalAngle << std::endl; os << "Viewing zenithal angle: " << m_ViewingZenithalAngle << std::endl; os << "Viewing azimutal angle: " << m_ViewingAzimutalAngle << std::endl; os << "Month : " << m_Month << std::endl; os << "Day : " << m_Day << std::endl; os << "Year : " << m_Year << std::endl; // Function values print : os << "Filter function values: " << std::endl; for (unsigned int i = 0; i < m_WavelengthSpectralBand->Size(); ++i) { os << indent << "Channel " << i + 1 << " : " << std::endl; os << indent << m_WavelengthSpectralBand->GetNthElement(i) << std::endl; } } } // end namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbSIXSTraits.cxx000066400000000000000000000303401301006202600267050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: 2008-05-30 Version: 2.2.0 Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSIXSTraits.h" #include "otb_6S.h" #include "main_6s.h" #include "otbMacro.h" #include namespace otb { void SIXSTraits::ComputeAtmosphericParameters( const double SolarZenithalAngle, /** The Solar zenithal angle */ const double SolarAzimutalAngle, /** The Solar azimutal angle */ const double ViewingZenithalAngle, /** The Viewing zenithal angle */ const double ViewingAzimutalAngle, /** The Viewing azimutal angle */ const unsigned int Month, /** The Month */ const unsigned int Day, /** The Day (in the month) */ const double AtmosphericPressure, /** The Atmospheric pressure */ const double WaterVaporAmount, /** The Water vapor amount (Total water vapor content over vertical atmospheric column) */ const double OzoneAmount, /** The Ozone amount (Stratospheric ozone layer content) */ const AerosolModelType& AerosolModel, /** The Aerosol model */ const double AerosolOptical, /** The Aerosol optical (radiative impact of aerosol for the reference wavelength 550-nm) */ WavelengthSpectralType* WavelengthSpectralBand, /** Wavelength for the spectral band definition */ /** Note : The Max wavelength spectral band value must be updated ! */ double& AtmosphericReflectance, /** Atmospheric reflectance */ double& AtmosphericSphericalAlbedo, /** atmospheric spherical albedo */ double& TotalGaseousTransmission, /** Total gaseous transmission */ double& DownwardTransmittance, /** downward transmittance */ double& UpwardTransmittance, /** upward transmittance */ double& UpwardDiffuseTransmittance, /** upward diffuse transmittance */ double& UpwardDirectTransmittance, /** Upward direct transmittance */ double& UpwardDiffuseTransmittanceForRayleigh, /** upward diffuse transmittance for rayleigh */ double& UpwardDiffuseTransmittanceForAerosol /** supward diffuse transmittance for aerosols */ ) { // geometrical conditions otb_6s_doublereal asol(static_cast(SolarZenithalAngle)); otb_6s_doublereal phi0(static_cast(SolarAzimutalAngle)); otb_6s_doublereal avis(static_cast(ViewingZenithalAngle)); otb_6s_doublereal phiv(static_cast(ViewingAzimutalAngle)); otb_6s_integer month(static_cast(Month)); otb_6s_integer jday(static_cast(Day)); otb_6s_doublereal pressure(static_cast(AtmosphericPressure)); otb_6s_doublereal uw(static_cast(WaterVaporAmount)); otb_6s_doublereal uo3(static_cast(OzoneAmount)); // atmospheric model otb_6s_integer iaer(static_cast(AerosolModel)); otb_6s_doublereal taer55(static_cast(AerosolOptical)); // Init output parameters AtmosphericReflectance = 0.; AtmosphericSphericalAlbedo = 0.; TotalGaseousTransmission = 0.; DownwardTransmittance = 0.; UpwardTransmittance = 0.; UpwardDiffuseTransmittance = 0.; UpwardDirectTransmittance = 0.; UpwardDiffuseTransmittanceForRayleigh = 0.; UpwardDiffuseTransmittanceForAerosol = 0.; otb_6s_doublereal wlinf(0.), wlsup(0.); otb_6s_doublereal otb_ratm__(0.), sast(0.), tgasm(0.), sdtott(0.), sutott(0.); otb_6s_doublereal tdif_up(0.), tdir_up(0.), tdif_up_ray(0.), tdif_up_aer(0.); // 6S official Wavelength Spectral Band step value const float SIXSStepOfWavelengthSpectralBandValues = .0025; // Generate 6s Wavelength Spectral Band with the offcicial step value ComputeWavelengthSpectralBandValuesFor6S(SIXSStepOfWavelengthSpectralBandValues, WavelengthSpectralBand // Update ); try { // 6S official tab size Wavelength Spectral const otb_6s_integer S_6S_SIZE = 1501; // Generate WavelengthSpectralBand in 6S compatible buffer s[1501] wlinf = static_cast(WavelengthSpectralBand->GetMinSpectralValue()); wlsup = static_cast(WavelengthSpectralBand->GetMaxSpectralValue()); otb_6s_integer iinf = static_cast((wlinf - (float) .25) / SIXSStepOfWavelengthSpectralBandValues + (float) 1.5); otb_6s_integer cpt = iinf - 1; otb_6s_doublereal s[S_6S_SIZE]; const ValuesVectorType& FilterFunctionValues6S = WavelengthSpectralBand->GetFilterFunctionValues6S(); // Set the values of FilterFunctionValues6S in s between [iinf-1; isup] for (unsigned int i = 0; i < FilterFunctionValues6S.size() && cpt < S_6S_SIZE; ++i) { s[cpt] = FilterFunctionValues6S[i]; ++cpt; } // Call 6s main function otbMsgDevMacro(<< "Start call 6S main function ..."); otb_6s_ssssss_otb_main_function(&asol, &phi0, &avis, &phiv, &month, &jday, &pressure, &uw, &uo3, &iaer, &taer55, &wlinf, &wlsup, s, &otb_ratm__, &sast, &tgasm, &sdtott, &sutott, &tdif_up, &tdir_up, &tdif_up_ray, &tdif_up_aer); otbMsgDevMacro(<< "Done call 6S main function!"); } catch (std::bad_alloc& err) { itkGenericExceptionMacro(<< "Exception bad_alloc in SIXSTraits class: " << (char*) err.what()); } catch (...) { itkGenericExceptionMacro(<< "Unknown exception in SIXSTraits class (catch(...)"); } // Set outputs parameters AtmosphericReflectance = static_cast(otb_ratm__); AtmosphericSphericalAlbedo = static_cast(sast); TotalGaseousTransmission = static_cast(tgasm); DownwardTransmittance = static_cast(sdtott); UpwardTransmittance = static_cast(sutott); UpwardDiffuseTransmittance = static_cast(tdif_up); UpwardDirectTransmittance = static_cast(tdir_up); UpwardDiffuseTransmittanceForRayleigh = static_cast(tdif_up_ray); UpwardDiffuseTransmittanceForAerosol = static_cast(tdif_up_aer); } void SIXSTraits::ComputeWavelengthSpectralBandValuesFor6S( const double SIXSStepOfWavelengthSpectralBandValues, WavelengthSpectralType* WavelengthSpectralBand ) { const double epsilon(.000001); const double L_min = static_cast(WavelengthSpectralBand->GetMinSpectralValue()); const double L_max = static_cast(WavelengthSpectralBand->GetMaxSpectralValue()); const double L_userStep = static_cast(WavelengthSpectralBand->GetUserStep()); const ValuesVectorType& FilterFunctionValues = WavelengthSpectralBand->GetFilterFunctionValues(); unsigned int i = 1; unsigned int j = 1; const double invStep = static_cast(1. / L_userStep); double value(0.); if (FilterFunctionValues.size() <= 1) { itkGenericExceptionMacro(<< "The FilterFunctionValues vector must have more than 1 values !"); } if (! (L_min + static_cast(FilterFunctionValues.size() - 1) * L_userStep < (L_max + epsilon) ) ) { itkGenericExceptionMacro( << "The following condition: " << L_min << "+(" << FilterFunctionValues.size() << "-1)*" << L_userStep << " < (" << L_max << "+" << epsilon << ") is not respected !" << "val1 " << L_min + static_cast(FilterFunctionValues.size() - 1) * L_userStep << " val2 " << L_max - epsilon); } // Generate WavelengthSpectralBand if the step is not the official 6S step value if (vcl_abs(L_userStep - SIXSStepOfWavelengthSpectralBandValues) > epsilon) { ValuesVectorType values(1, FilterFunctionValues[0]); //vector size 1 with the value vect[0] // Stop the interpolation at the max spectral value. value = SIXSStepOfWavelengthSpectralBandValues; while (L_min + value <= L_max) { // Search the User interval that surround the StepOfWavelengthSpectralBandValues current value. // removed the <= here, might be wrong while (j * L_userStep < value) { ++j; } // Check if we are not out of bound if (j >= FilterFunctionValues.size()) { itkGenericExceptionMacro( << "Index " << j << " out of bound for FilterFunctionValues vector (size: " << FilterFunctionValues.size() << ")." << " and value is " << value << " and SIXSStepOfWavelengthSpectralBandValues is " << SIXSStepOfWavelengthSpectralBandValues<< " and i is " << i); } double valueTemp; valueTemp = static_cast(FilterFunctionValues[j - 1]) + ((static_cast(FilterFunctionValues[j]) - static_cast(FilterFunctionValues[j - 1])) * invStep) * (value - L_userStep * (j - 1)); values.push_back(static_cast(valueTemp)); ++i; value += SIXSStepOfWavelengthSpectralBandValues; } if (L_min + (i - 1) * SIXSStepOfWavelengthSpectralBandValues != L_max) { values.push_back(0); } // Store this values WavelengthSpectralBand->SetFilterFunctionValues6S(values); // Store the new Max MaxSpectralValue WavelengthSpectralBand->SetMaxSpectralValue(static_cast(L_min + i * SIXSStepOfWavelengthSpectralBandValues)); } else { // Init with copy of FilterFunctionValues input vector values WavelengthSpectralBand->SetFilterFunctionValues6S(FilterFunctionValues); } } void SIXSTraits::ComputeEnvironmentalContribution(const double diffuseTransmittanceForRayleighScattering, const double diffuseTransmittanceForAerosolScattering, const double radiusInKilometers, const double altitude, const double cosineOfViewingAngle, double& rayleighEstimation, double& aerosolEstimation, double& globalEstimation) { otb_6s_doublereal difr(static_cast(diffuseTransmittanceForRayleighScattering)); otb_6s_doublereal difa(static_cast(diffuseTransmittanceForAerosolScattering)); otb_6s_doublereal rad(static_cast(radiusInKilometers)); otb_6s_doublereal palt(static_cast(altitude)); otb_6s_doublereal xmuv(static_cast(cosineOfViewingAngle)); otb_6s_doublereal fra(0.), fae(0.), fr(0.); otb_6s_enviro_(&difr, &difa, &rad, &palt, &xmuv, &fra, &fae, &fr); rayleighEstimation = static_cast(fra); aerosolEstimation = static_cast(fae); globalEstimation = static_cast(fr); } } // namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbSpectralSensitivityReader.cxx000066400000000000000000000131171301006202600321060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSpectralSensitivityReader.h" #include #include #include #include "otb_boost_string_header.h" #include "itksys/SystemTools.hxx" #include "otbSpotImageMetadataInterface.h" #include "itkMacro.h" namespace otb { SpectralSensitivityReader ::SpectralSensitivityReader() : m_FileName(""), m_DataPath("") { this->Superclass::SetNumberOfRequiredOutputs(1); this->Superclass::SetNthOutput(0, WavelengthSpectralBandVectorType::New().GetPointer()); m_Image = ImageType::New(); } SpectralSensitivityReader ::~SpectralSensitivityReader() { } SpectralSensitivityReader::WavelengthSpectralBandVectorType * SpectralSensitivityReader ::GetOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } const SpectralSensitivityReader::WavelengthSpectralBandVectorType * SpectralSensitivityReader ::GetOutput() const { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->ProcessObject::GetOutput(0)); } void SpectralSensitivityReader ::FindFileName() { if (m_Image.IsNull()) { itkExceptionMacro(<< "An input image has to be set or set directly the filename"); } std::string sensor(""); std::ostringstream oss; try { SpotImageMetadataInterface::Pointer lImageMetadata = SpotImageMetadataInterface::New(); lImageMetadata->SetMetaDataDictionary(m_Image->GetMetaDataDictionary()); sensor = lImageMetadata->GetSensorID(); sensor = itksys::SystemTools::UpperCase(sensor); // Suppress spaces sensor.erase(std::remove_if(sensor.begin(), sensor.end(), isspace), sensor.end()); oss.str(""); oss << lImageMetadata->GetInstrument(); oss << lImageMetadata->GetInstrumentIndex(); } catch (itk::ExceptionObject& err) { itkExceptionMacro(<< "Invalid input image" << err.GetDescription()); } std::string instrument = oss.str(); oss.str(""); oss << m_DataPath; oss << "/"; oss << sensor; oss << "/"; oss << instrument; oss << "/rep6S.dat"; m_FileName = oss.str(); } void SpectralSensitivityReader ::GenerateData() { if (m_FileName == "") this->FindFileName(); WavelengthSpectralBandVectorType * wavelengthSpectralBand = this->GetOutput(); if ( !itksys::SystemTools::FileExists(m_FileName.c_str()) ) { itkExceptionMacro(<< m_FileName << " does not exist."); } std::ifstream file(m_FileName.c_str()); if (!file) itkExceptionMacro(<< "Enable to read " << m_FileName << " file."); std::string line; double mini = 0; double maxi = 0.; bool firstLine = true; unsigned int nbBands = 0; // used to store the coef std::vector valuesVector; while (std::getline(file, line)) { // Replace any tabulation by a space std::string::size_type tabpos = line.find('\t'); while (tabpos != std::string::npos) { line.at(tabpos) = ' '; tabpos = line.find('\t'); } // Replace multiple spaces by a unique space std::unique(line.begin(), line.end(), SpectralSensitivityReader::BothAre(' ')); // if the first character is a space, erase it boost::trim(line); std::vector keywordStrings; boost::split(keywordStrings, line, boost::is_any_of(" ")); if (keywordStrings.size() < 3) itkExceptionMacro(<< "Invalid file format"); // Store min wavelength if (firstLine) { mini = atof(keywordStrings[0].c_str()); nbBands = keywordStrings.size() - 2; for (unsigned int j = 0; j < nbBands; ++j) { wavelengthSpectralBand->PushBack(FilterFunctionValues::New()); ValuesVectorType temp; valuesVector.push_back(temp); } firstLine = false; } if (nbBands != keywordStrings.size() - 2) itkExceptionMacro(<< "Invalid file format"); for (unsigned int i = 0; i < nbBands; ++i) { valuesVector[i].push_back(atof(keywordStrings[i + 2].c_str())); } maxi = atof(keywordStrings[0].c_str()); } //while ( std::getline( file, line ) ) for (unsigned int j = 0; j < nbBands; ++j) { wavelengthSpectralBand->GetNthElement(j)->SetFilterFunctionValues(valuesVector[j]); wavelengthSpectralBand->GetNthElement(j)->SetMinSpectralValue(mini); wavelengthSpectralBand->GetNthElement(j)->SetMaxSpectralValue(maxi); } } /**PrintSelf method */ void SpectralSensitivityReader ::PrintSelf(std::ostream& os, itk::Indent indent) const { os << "DataPath: " << m_DataPath << std::endl; if (m_FileName != "") os << "FileName: " << m_FileName << std::endl; // Function values print : const WavelengthSpectralBandVectorType * wavelengthSpectralBand = this->GetOutput(); os << "Filter function values: " << std::endl; for (unsigned int i = 0; i < wavelengthSpectralBand->Size(); ++i) { os << indent << "Channel " << i + 1 << " : " << std::endl; os << indent << wavelengthSpectralBand->GetNthElement(i) << std::endl; } } } // end namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/src/otbWavelengthSpectralBands.cxx000066400000000000000000000023151301006202600315030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWavelengthSpectralBands.h" #include namespace otb { /*********************** WavelengthSpectralBands **************************/ WavelengthSpectralBands ::WavelengthSpectralBands() { m_WavelengthSpectralBandsList = InternalWavelengthSpectralBandListType::New(); m_NbBands = 0; } /**PrintSelf method */ void WavelengthSpectralBands ::PrintSelf(std::ostream& os, itk::Indent indent) const { for (unsigned int i = 0; i < m_NbBands; ++i) { os << indent << "Filter function values " << i << ":" << std::endl; os << indent << m_WavelengthSpectralBandsList->GetNthElement(i) << std::endl; } } } // end namespace otb OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/000077500000000000000000000000001301006202600236675ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/CMakeLists.txt000066400000000000000000001227351301006202600264410ustar00rootroot00000000000000otb_module_test() set(OTBOpticalCalibrationTests otbOpticalCalibrationTestDriver.cxx otbSpectralSensitivityReaderTest.cxx otbReflectanceToImageImageFilter.cxx otbReflectanceToLuminanceImageFilterNew.cxx otbLuminanceToReflectanceImageFilterNew.cxx otbLuminanceToReflectanceImageFilterAuto.cxx otbImageToLuminanceImageFilterNew.cxx otbRadiometryCorrectionParametersToAtmosphericRadiativeTermsNew.cxx otbLuminanceToImageImageFilterAuto.cxx otbLuminanceToImageImageFilterNew.cxx otbReflectanceToLuminanceImageFilterAuto.cxx otbAeronetExtractDataBadData.cxx otbRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter.cxx otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.cxx otbSurfaceAdjacencyEffectCorrectionSchemeFilterNew.cxx otbImageToReflectanceImageFilterAuto.cxx otbAtmosphericCorrectionParametersNew.cxx otbImageToReflectanceImageFilterNew.cxx otbWavelengthSpectralBandsTest.cxx otbAtmosphericRadiativeTermsTest.cxx otbImageToReflectanceImageFilter.cxx otbLuminanceToReflectanceImageFilter.cxx otbReflectanceToImageImageFilterAuto.cxx otbAeronetNew.cxx otbAeronetExtractData.cxx otbReflectanceToSurfaceReflectanceImageFilterTest.cxx otbImageMetadataCorrectionParametersNew.cxx otbImageToLuminanceImageFilterAuto.cxx otbAtmosphericCorrectionSequencement.cxx otbSIXSTraitsTest.cxx otbSIXSTraitsComputeAtmosphericParameters.cxx otbReflectanceToImageImageFilterNew.cxx otbSurfaceAdjacencyEffectCorrectionSchemeFilter.cxx otbLuminanceToImageImageFilter.cxx otbReflectanceToLuminanceImageFilter.cxx otbImageToLuminanceImageFilter.cxx ) add_executable(otbOpticalCalibrationTestDriver ${OTBOpticalCalibrationTests}) target_link_libraries(otbOpticalCalibrationTestDriver ${OTBOpticalCalibration-Test_LIBRARIES}) otb_module_target_label(otbOpticalCalibrationTestDriver) set_linker_stack_size_flag(otbOpticalCalibrationTestDriver 10000000) # Tests Declaration otb_add_test(NAME raTuSpectralSensitivityReaderNew COMMAND otbOpticalCalibrationTestDriver otbSpectralSensitivityReaderNew ) otb_add_test(NAME raTvSpectralSensitivityReaderSpot4Test COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_5} ${BASELINE_FILES}/raTvSpectralSensitivityReaderSpot4Test.txt ${TEMP}/raTvSpectralSensitivityReaderSpot4Test.txt --ignore-lines-with 2 DataPath FileName otbSpectralSensitivityReaderGenericTest ${INPUTDATA}/Radiometry/SPOT4/HRVIR1/rep6S.dat LARGEINPUT{SPOT4/ROMANIA/raTvS4_20020518_Reflectance.img} ${TEMP}/raTvSpectralSensitivityReaderSpot4Test.txt ) otb_add_test(NAME raTvSpectralSensitivityReaderGenericTest COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_5} ${BASELINE_FILES}/raTvSpectralSensitivityReaderGenericTest.txt ${TEMP}/raTvSpectralSensitivityReaderGenericTest.txt --ignore-lines-with 2 DataPath FileName otbSpectralSensitivityReaderGenericTest ${INPUTDATA}/Radiometry/SPOT5/HRG1/rep6S.dat ${INPUTDATA}/SPOT5_EXTRACTS/Arcachon/Arcachon_extrait_3852_3319_546_542.tif ${TEMP}/raTvSpectralSensitivityReaderGenericTest.txt ) otb_add_test(NAME raTvSpectralSensitivityReaderTest COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_5} ${BASELINE_FILES}/raTvSpectralSensitivityReaderGenericTest.txt ${TEMP}/rcTuSpectralSensitivityReaderTest.txt --ignore-lines-with 2 DataPath FileName otbSpectralSensitivityReaderTest ${INPUTDATA}/Radiometry ${INPUTDATA}/SPOT5_EXTRACTS/Arcachon/Arcachon_extrait_3852_3319_546_542.tif ${TEMP}/rcTuSpectralSensitivityReaderTest.txt ) otb_add_test(NAME raTvReflectanceToImageImageFilterDayMonth COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvReflectanceToImageImageFilterDayMonth.tif otbReflectanceToImageImageFilter ${BASELINE}/raTvImageToReflectanceImageFilter.tif ${TEMP}/raTvReflectanceToImageImageFilterDayMonth.tif 0.2 #radius 1 #channel 1 alpha 2 #channel 2 alpha 3 #channel 3 alpha 4 #channel 4 alpha 10 #channel 1 beta 11 #channel 2 beta 12 #channel 3 beta 13 #channel 4 beta 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 3 #day 5 #month ) otb_add_test(NAME raTvReflectanceToImageImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvReflectanceToImageImageFilterDsol.tif otbReflectanceToImageImageFilter ${BASELINE}/raTvImageToReflectanceImageFilterDsol.tif ${TEMP}/raTvReflectanceToImageImageFilterDsol.tif 0.2 #radius 1 #channel 1 alpha 2 #channel 2 alpha 3 #channel 3 alpha 4 #channel 4 alpha 10 #channel 1 beta 11 #channel 2 beta 12 #channel 3 beta 13 #channel 4 beta 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 0.9923885328 #d/d0 corresponding to the date 03/05 ) otb_add_test(NAME raTvRomaniaReflectanceToImage COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${INPUTDATA}/Romania_Extract.tif ${TEMP}/raTvRomaniaImage.tif otbReflectanceToImageImageFilter ${BASELINE}/raTvRomania_Reflectance.tif ${TEMP}/raTvRomaniaImage.tif 27.3 # = 90-62.70 : elevation et azimuth solaire 1.981247824 #channel 1 alpha = 0.881338*2.24800 4.332207085 #channel 2 alpha = 0.858713*5.04500 2.32064768 #channel 3 alpha = 0.685568*3.38500 9.3177861 #channel 4 alpha = 6.19122*1.50500 0 #channel 1 beta 0 #channel 2 beta 0 #channel 3 beta 0 #channel 4 beta 1057.56 #channel 1 illumination 1570.23 #channel 2 illumination 1842.94 #channel 3 illumination 232.820 #channel 4 illumination 0.9889145564708814 #= sqrt(0.977952) d/d0 corresponding to the date 03/05 ) otb_add_test(NAME raTuReflectanceToLuminanceImageFilterNew COMMAND otbOpticalCalibrationTestDriver otbReflectanceToLuminanceImageFilterNew ) otb_add_test(NAME raTuLuminanceToReflectanceImageFilterNew COMMAND otbOpticalCalibrationTestDriver otbLuminanceToReflectanceImageFilterNew ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterAutoQuickbirdPAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdPAN.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdPAN.tif otbLuminanceToReflectanceImageFilterAuto LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdPAN.tif ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterAutoWV2PAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoWV2PAN.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoWV2PAN.tif otbLuminanceToReflectanceImageFilterAuto LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoWV2PAN.tif ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterAutoSpot5 COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoSpot5.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoSpot5.img otbLuminanceToReflectanceImageFilterAuto LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoSpot5.img ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterAutoIkonos COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoIkonos.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoIkonos.tif otbLuminanceToReflectanceImageFilterAuto LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_pan_0000000.tif} ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoIkonos.tif ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterAutoWV2MULTI COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoWV2Multi.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoWV2Multi.tif otbLuminanceToReflectanceImageFilterAuto LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL/09DEC10103019-M2AS-052298844010_01_P001.TIF} ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoWV2Multi.tif ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterAutoQuickbirdXS COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdXS.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdXS.tif otbLuminanceToReflectanceImageFilterAuto LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdXS.tif ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterAutoFORMOSAT COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoFormosat.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoFormosat.img otbLuminanceToReflectanceImageFilterAuto LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} ${TEMP}/raTvLuminanceToReflectanceImageFilterAutoFormosat.img ) otb_add_test(NAME raTuImageToLuminanceImageFilterNew COMMAND otbOpticalCalibrationTestDriver otbImageToLuminanceImageFilterNew ) otb_add_test(NAME raTuRadiometryCorrectionParametersToAtmosphericRadiativeTermsNew COMMAND otbOpticalCalibrationTestDriver otbRadiometryCorrectionParametersToAtmosphericRadiativeTermsNew) otb_add_test(NAME raTuLuminanceToImageImageFilterNew COMMAND otbOpticalCalibrationTestDriver otbLuminanceToImageImageFilterNew ) #FIXME Those tests have performing local copies of header, baselines...They were migrate "as it" for now in version 5.0 but # something cleaner could be done in the future. #TODO Rewrite those tests and ban local copy and cmake trickery if(OTB_DATA_USE_LARGEINPUT) set(TOULOUSEQBDIR ${TEMP}/OpticalCalibLumToImQBPAN) file(MAKE_DIRECTORY ${TOULOUSEQBDIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${TOULOUSEQBDIR}) otb_copy_rename(${BASELINE}/raTvImageToLuminanceImageFilterAutoQuickbirdPAN.tif ${TOULOUSEQBDIR}/02APR01105228-P1BS-000000128955_01_P001.TIF) otb_add_test(NAME raTvLuminanceToImageImageFilterAutoQuickbirdPAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${TOULOUSEQBDIR}/raTvSMALLTOULOUSELuminanceToImageImageFilterAutoQuickbirdPAN.tif ${TOULOUSEQBDIR}/raTvLuminanceToImageImageFilterAutoQuickbirdPAN.tif otbLuminanceToImageImageFilterAuto ${TOULOUSEQBDIR}/02APR01105228-P1BS-000000128955_01_P001.TIF LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TOULOUSEQBDIR}/raTvLuminanceToImageImageFilterAutoQuickbirdPAN.tif ${TOULOUSEQBDIR}/raTvSMALLTOULOUSELuminanceToImageImageFilterAutoQuickbirdPAN.tif ) set(TOULOUSEQBDIR ${TEMP}/OpticalCalibLumToImQBXS) file(MAKE_DIRECTORY ${TOULOUSEQBDIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${TOULOUSEQBDIR}) otb_copy_rename(${BASELINE}/raTvImageToLuminanceImageFilterAutoQuickbirdXS.tif ${TOULOUSEQBDIR}/02APR01105228-M1BS-000000128955_01_P001.TIF) otb_add_test(NAME raTvLuminanceToImageImageFilterAutoQuickbirdXS COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${TOULOUSEQBDIR}/raTvSMALLTOULOUSELuminanceToImageImageFilterAutoQuickbirdXS.tif ${TOULOUSEQBDIR}/raTvLuminanceToImageImageFilterAutoQuickbirdXS.tif otbLuminanceToImageImageFilterAuto ${TOULOUSEQBDIR}/02APR01105228-M1BS-000000128955_01_P001.TIF LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TOULOUSEQBDIR}/raTvLuminanceToImageImageFilterAutoQuickbirdXS.tif ${TOULOUSEQBDIR}/raTvSMALLTOULOUSELuminanceToImageImageFilterAutoQuickbirdXS.tif ) set(ROMEWV2DIR ${TEMP}/OpticalCalibLumToImWv2MULTI) file(MAKE_DIRECTORY ${ROMEWV2DIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${ROMEWV2DIR}) otb_copy_rename(${BASELINE}/raTvImageToLuminanceImageFilterAutoWV2Multi.tif ${ROMEWV2DIR}/09DEC10103019-M2AS-052298844010_01_P001.TIF) otb_add_test(NAME raTvLuminanceToImageImageFilterAutoWV2MULTI COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${ROMEWV2DIR}/raTvSMALLROMELuminanceToImageImageFilterAutoWV2Multi.tif ${ROMEWV2DIR}/raTvLuminanceToImageImageFilterAutoWV2Multi.tif otbLuminanceToImageImageFilterAuto ${ROMEWV2DIR}/09DEC10103019-M2AS-052298844010_01_P001.TIF LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL/09DEC10103019-M2AS-052298844010_01_P001.TIF} ${ROMEWV2DIR}/raTvLuminanceToImageImageFilterAutoWV2Multi.tif ${ROMEWV2DIR}/raTvSMALLROMELuminanceToImageImageFilterAutoWV2Multi.tif ) set(BLOSSEVILLEIKONOSDIR ${TEMP}/OpticalCalibLumToImIkonos) file(MAKE_DIRECTORY ${BLOSSEVILLEIKONOSDIR}) file(GLOB MTDATA ${OTB_DATA_LARGEINPUT_ROOT}/IKONOS/BLOSSEVILLE/*metadata.txt ${OTB_DATA_LARGEINPUT_ROOT}/IKONOS/BLOSSEVILLE/*pan*) file(COPY ${MTDATA} DESTINATION ${BLOSSEVILLEIKONOSDIR}) otb_copy_rename(${BASELINE}/raTvImageToLuminanceImageFilterAutoIkonos.tif ${BLOSSEVILLEIKONOSDIR}/po_2619900_pan_0000000.tif) otb_add_test(NAME raTvLuminanceToImageImageFilterAutoIkonos COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BLOSSEVILLEIKONOSDIR}/raTvSMALLBLOSSEVILLELuminanceToImageImageFilterAutoIkonos.tif ${BLOSSEVILLEIKONOSDIR}/raTvLuminanceToImageImageFilterAutoIkonos.tif otbLuminanceToImageImageFilterAuto ${BLOSSEVILLEIKONOSDIR}/po_2619900_pan_0000000.tif LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_pan_0000000.tif} ${BLOSSEVILLEIKONOSDIR}/raTvLuminanceToImageImageFilterAutoIkonos.tif ${BLOSSEVILLEIKONOSDIR}/raTvSMALLBLOSSEVILLELuminanceToImageImageFilterAutoIkonos.tif ) set(TEHERANSPOT5DIR ${TEMP}/OpticalCalibLumToImSPOT5) file(MAKE_DIRECTORY ${TEHERANSPOT5DIR}) file(GLOB MTDATA ${OTB_DATA_LARGEINPUT_ROOT}/SPOT5/TEHERAN/*.DIM) file(COPY ${MTDATA} DESTINATION ${TEHERANSPOT5DIR}) otb_copy_rename(${BASELINE}/raTvImageToLuminanceImageFilterAutoSpot5.tif ${TEHERANSPOT5DIR}/IMAGERY.TIF) otb_add_test(NAME raTvLuminanceToImageImageFilterAutoSpot5 COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${TEHERANSPOT5DIR}/raTvSMALLTEHERANLuminanceToImageImageFilterAutoSpot5.img ${TEHERANSPOT5DIR}/raTvLuminanceToImageImageFilterAutoSpot5.tif otbLuminanceToImageImageFilterAuto ${TEHERANSPOT5DIR}/IMAGERY.TIF LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} ${TEHERANSPOT5DIR}/raTvLuminanceToImageImageFilterAutoSpot5.tif ${TEHERANSPOT5DIR}/raTvSMALLTEHERANLuminanceToImageImageFilterAutoSpot5.img ) set(ROMEWV2DIR ${TEMP}/OpticalCalibLumToImWv2PAN) file(MAKE_DIRECTORY ${ROMEWV2DIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${ROMEWV2DIR}) otb_copy_rename(${BASELINE}/raTvImageToLuminanceImageFilterAutoWV2PAN.tif ${ROMEWV2DIR}/09DEC10103019-P2AS-052298844010_01_P001.TIF) otb_add_test(NAME raTvLuminanceToImageImageFilterAutoWV2PAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${ROMEWV2DIR}/raTvSMALLROMELuminanceToImageImageFilterAutoWV2PAN.tif ${ROMEWV2DIR}/raTvLuminanceToImageImageFilterAutoWV2PAN.tif otbLuminanceToImageImageFilterAuto ${ROMEWV2DIR}/09DEC10103019-P2AS-052298844010_01_P001.TIF LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} ${ROMEWV2DIR}/raTvLuminanceToImageImageFilterAutoWV2PAN.tif ${ROMEWV2DIR}/raTvSMALLROMELuminanceToImageImageFilterAutoWV2PAN.tif ) set(SUDOUESTFORMOSATDIR ${TEMP}/OpticalCalibLumToImFormosat) file(MAKE_DIRECTORY ${SUDOUESTFORMOSATDIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/FORMOSAT/Sudouest_20071013_MS_fmsat) file(GLOB MTDATA ${MTDATADIR}/*.DIM) file(COPY ${MTDATA} DESTINATION ${SUDOUESTFORMOSATDIR}) otb_copy_rename(${BASELINE}/raTvImageToLuminanceImageFilterAutoFormosat.tif ${SUDOUESTFORMOSATDIR}/IMAGERY.TIF) otb_add_test(NAME raTvLuminanceToImageImageFilterAutoFORMOSAT COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${SUDOUESTFORMOSATDIR}/raTvSMALLSOLuminanceToImageImageFilterAutoFormosat.img ${SUDOUESTFORMOSATDIR}/raTvLuminanceToImageImageFilterAutoFormosat.tif otbLuminanceToImageImageFilterAuto ${SUDOUESTFORMOSATDIR}/IMAGERY.TIF LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} ${SUDOUESTFORMOSATDIR}/raTvLuminanceToImageImageFilterAutoFormosat.tif ${SUDOUESTFORMOSATDIR}/raTvSMALLSOLuminanceToImageImageFilterAutoFormosat.img ) set(TOULOUSEQBDIR ${TEMP}/OpticalCalibRefToLumQBPAN) file(MAKE_DIRECTORY ${TOULOUSEQBDIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${TOULOUSEQBDIR}) otb_copy_rename(${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdPAN.tif ${TOULOUSEQBDIR}/02APR01105228-P1BS-000000128955_01_P001.TIF) otb_add_test(NAME raTvReflectanceToLuminanceImageFilterAutoQuickbirdPAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoQuickbirdPAN.tif ${TOULOUSEQBDIR}/raTvReflectanceToLuminanceImageFilterAutoQuickbirdPAN.tif otbReflectanceToLuminanceImageFilterAuto ${TOULOUSEQBDIR}/02APR01105228-P1BS-000000128955_01_P001.TIF ${TOULOUSEQBDIR}/raTvReflectanceToLuminanceImageFilterAutoQuickbirdPAN.tif ) set(ROMEWV2DIR ${TEMP}/OpticalCalibRefToLumWv2PAN) file(MAKE_DIRECTORY ${ROMEWV2DIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${ROMEWV2DIR}) otb_copy_rename(${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoWV2PAN.tif ${ROMEWV2DIR}/09DEC10103019-P2AS-052298844010_01_P001.TIF) otb_add_test(NAME raTvReflectanceToLuminanceImageFilterAutoWV2PAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoWV2PAN.tif ${ROMEWV2DIR}/raTvReflectanceToLuminanceImageFilterAutoWV2PAN.tif otbReflectanceToLuminanceImageFilterAuto ${ROMEWV2DIR}/09DEC10103019-P2AS-052298844010_01_P001.TIF ${ROMEWV2DIR}/raTvReflectanceToLuminanceImageFilterAutoWV2PAN.tif ) set(TEHERANSPOT5DIR ${TEMP}/OpticalCalibRefToLumSPOT5) file(MAKE_DIRECTORY ${TEHERANSPOT5DIR}) file(GLOB MTDATA ${OTB_DATA_LARGEINPUT_ROOT}/SPOT5/TEHERAN/*.DIM) file(COPY ${MTDATA} DESTINATION ${TEHERANSPOT5DIR}) otb_copy_rename(${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoSpot5.tif ${TEHERANSPOT5DIR}/IMAGERY.TIF) otb_add_test(NAME raTvReflectanceToLuminanceImageFilterAutoSpot5 COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoSpot5.tif ${TEHERANSPOT5DIR}/raTvReflectanceToLuminanceImageFilterAutoSpot5.img otbReflectanceToLuminanceImageFilterAuto ${TEHERANSPOT5DIR}/IMAGERY.TIF ${TEHERANSPOT5DIR}/raTvReflectanceToLuminanceImageFilterAutoSpot5.img ) set(BLOSSEVILLEIKONOSDIR ${TEMP}/OpticalCalibRefToLumIkonos) file(MAKE_DIRECTORY ${BLOSSEVILLEIKONOSDIR}) file(GLOB MTDATA ${OTB_DATA_LARGEINPUT_ROOT}/IKONOS/BLOSSEVILLE/*metadata.txt ${OTB_DATA_LARGEINPUT_ROOT}/IKONOS/BLOSSEVILLE/*pan*) file(COPY ${MTDATA} DESTINATION ${BLOSSEVILLEIKONOSDIR}) otb_copy_rename(${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoIkonos.tif ${BLOSSEVILLEIKONOSDIR}/po_2619900_pan_0000000.tif) otb_add_test(NAME raTvReflectanceToLuminanceImageFilterAutoIkonos COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoIkonos.tif ${BLOSSEVILLEIKONOSDIR}/raTvReflectanceToLuminanceImageFilterAutoIkonos.tif otbReflectanceToLuminanceImageFilterAuto ${BLOSSEVILLEIKONOSDIR}/po_2619900_pan_0000000.tif ${BLOSSEVILLEIKONOSDIR}/raTvReflectanceToLuminanceImageFilterAutoIkonos.tif ) set(TOULOUSEQBDIR ${TEMP}/OpticalCalibRefToLumQBXS) file(MAKE_DIRECTORY ${TOULOUSEQBDIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${TOULOUSEQBDIR}) otb_copy_rename(${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoQuickbirdXS.tif ${TOULOUSEQBDIR}/02APR01105228-M1BS-000000128955_01_P001.TIF) otb_add_test(NAME raTvReflectanceToLuminanceImageFilterAutoQuickbirdXS COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoQuickbirdXS.tif ${TOULOUSEQBDIR}/raTvReflectanceToLuminanceImageFilterAutoQuickbirdXS.tif otbReflectanceToLuminanceImageFilterAuto ${TOULOUSEQBDIR}/02APR01105228-M1BS-000000128955_01_P001.TIF ${TOULOUSEQBDIR}/raTvReflectanceToLuminanceImageFilterAutoQuickbirdXS.tif ) set(ROMEWV2DIR ${TEMP}/OpticalCalibRefToLumWv2MULTI) file(MAKE_DIRECTORY ${ROMEWV2DIR}) set(MTDATADIR ${OTB_DATA_LARGEINPUT_ROOT}/WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL) file(GLOB MTDATA ${MTDATADIR}/*TIL ${MTDATADIR}/*RPB ${MTDATADIR}/*XML ${MTDATADIR}/*IMD) file(COPY ${MTDATA} DESTINATION ${ROMEWV2DIR}) otb_copy_rename(${BASELINE}/raTvLuminanceToReflectanceImageFilterAutoWV2Multi.tif ${ROMEWV2DIR}/09DEC10103019-M2AS-052298844010_01_P001.TIF) otb_add_test(NAME raTvReflectanceToLuminanceImageFilterAutoWV2MULTI COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoWV2Multi.tif ${ROMEWV2DIR}/raTvReflectanceToLuminanceImageFilterAutoWV2Multi.tif otbReflectanceToLuminanceImageFilterAuto ${ROMEWV2DIR}/09DEC10103019-M2AS-052298844010_01_P001.TIF ${ROMEWV2DIR}/raTvReflectanceToLuminanceImageFilterAutoWV2Multi.tif ) endif() otb_add_test(NAME raTvAeronetExtractData_BadDate COMMAND otbOpticalCalibrationTestDriver otbAeronetExtractDataBadData ${INPUTDATA}/AERONET/090101_091231_Seysses.lev15 23 # Day 2 # Month 2009 # Year 11 # Hour 0 # Minute 0.4 # Epsilon ) otb_add_test(NAME raTvAeronetExtractData_BadHour COMMAND otbOpticalCalibrationTestDriver otbAeronetExtractDataBadData ${INPUTDATA}/AERONET/090101_091231_Seysses.lev15 16 # Day 2 # Month 2009 # Year 10 # Hour 0 # Minute 0.4 # Epsilon ) otb_add_test(NAME raTvRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvRomania_Correction.tif ${TEMP}/raTvRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter.tif otbRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter ${BASELINE}/raTvRomania_Reflectance.tif ${TEMP}/raTvRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter.tif ${INPUTDATA}/romania_parameter.txt # atmo param; ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_B3.txt # wavelengths, channel 3 ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_B2.txt # wavelengths, channel 2 ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_B1.txt # wavelengths, channel 1 ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_MIR.txt # wavelengths, channel 4 ) otb_add_test(NAME raTvRadiometryCorrectionParametersToAtmosphericRadiativeTerms COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/raTvSIXSTraitsComputeAtmosphericParametersTest.txt ${TEMP}/raTvCorrectionTo6SRadiative.txt otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms ${INPUTDATA}/in6S_otb ${TEMP}/raTvCorrectionTo6SRadiative.txt ) otb_add_test(NAME raTuSurfaceAdjacencyEffectCorrectionSchemeFilterNew COMMAND otbOpticalCalibrationTestDriver otbSurfaceAdjacencyEffectCorrectionSchemeFilterNew ) otb_add_test(NAME raTvImageToReflectanceImageFilterAuto COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToReflectanceImageFilterAuto.tif ${TEMP}/raTvImageToReflectanceImageFilterAuto.img otbImageToReflectanceImageFilterAuto LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} ${TEMP}/raTvImageToReflectanceImageFilterAuto.img ) otb_add_test(NAME raTuImageToReflectanceImageFilterAutoFORMOSAT2 COMMAND otbOpticalCalibrationTestDriver otbImageToReflectanceImageFilterAuto LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} ${TEMP}/raTvImageToReflectanceImageFilterAutoFORMOSAT2.tif ) otb_add_test(NAME raTuAtmosphericCorrectionParametersNew COMMAND otbOpticalCalibrationTestDriver otbAtmosphericCorrectionParametersNew ) otb_add_test(NAME raTuImageToReflectanceImageFilterNew COMMAND otbOpticalCalibrationTestDriver otbImageToReflectanceImageFilterNew ) otb_add_test(NAME raTuWavelengthSpectralBandsNew COMMAND otbOpticalCalibrationTestDriver otbWavelengthSpectralBandsNew ) otb_add_test(NAME raTuFilterFunctionValuesNew COMMAND otbOpticalCalibrationTestDriver otbFilterFunctionValuesNew ) otb_add_test(NAME raTvAtmosphericRadiativeTermsTest COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/raTvAtmosphericRadiativeTermsTest.txt ${TEMP}/raTvAtmosphericRadiativeTermsTest.txt otbAtmosphericRadiativeTermsTest ${TEMP}/raTvAtmosphericRadiativeTermsTest.txt ) otb_add_test(NAME raTuAtmosphericRadiativeTermsNew COMMAND otbOpticalCalibrationTestDriver otbAtmosphericRadiativeTermsNew ) otb_add_test(NAME raTuAtmosphericRadiativeTermsSingleChannelNew COMMAND otbOpticalCalibrationTestDriver otbAtmosphericRadiativeTermsSingleChannelNew ) otb_add_test(NAME raTvImageToReflectanceImageFilterDayMonth COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToReflectanceImageFilter.tif ${TEMP}/raTvImageToReflectanceImageFilterDayMonth.tif otbImageToReflectanceImageFilter ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvImageToReflectanceImageFilterDayMonth.tif 0.2 #radius 1 #channel 1 alpha 2 #channel 2 alpha 3 #channel 3 alpha 4 #channel 4 alpha 10 #channel 1 beta 11 #channel 2 beta 12 #channel 3 beta 13 #channel 4 beta 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 3 #day 5 #month ) otb_add_test(NAME raTvImageToReflectanceImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToReflectanceImageFilterDsol.tif ${TEMP}/raTvImageToReflectanceImageFilterDsol.tif otbImageToReflectanceImageFilter ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvImageToReflectanceImageFilterDsol.tif 0.2 #radius 1 #channel 1 alpha 2 #channel 2 alpha 3 #channel 3 alpha 4 #channel 4 alpha 10 #channel 1 beta 11 #channel 2 beta 12 #channel 3 beta 13 #channel 4 beta 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 0.9923885328 #d/d0 corresponding to the date 03/05 ) otb_add_test(NAME raTvRomaniaImageToReflectance COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvRomania_Reflectance.tif ${TEMP}/raTvRomaniaReflectanceImage.tif otbImageToReflectanceImageFilter ${INPUTDATA}/Romania_Extract.tif ${TEMP}/raTvRomaniaReflectanceImage.tif 27.3 # = 90-62.70 : elevation et azimuth solaire 1.981247824 #channel 1 alpha = 0.881338*2.24800 4.332207085 #channel 2 alpha = 0.858713*5.04500 2.32064768 #channel 3 alpha = 0.685568*3.38500 9.3177861 #channel 4 alpha = 6.19122*1.50500 0 #channel 1 beta 0 #channel 2 beta 0 #channel 3 beta 0 #channel 4 beta 1057.56 #channel 1 illumination 1570.23 #channel 2 illumination 1842.94 #channel 3 illumination 232.820 #channel 4 illumination 0.9889145564708814 #= sqrt(0.977952) d/d0 corresponding to the date 03/05 ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilterDayMonth COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilter.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterDayMonth.tif otbLuminanceToReflectanceImageFilter ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterDayMonth.tif 0.2 #radius 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 3 #day 5 #month ) otb_add_test(NAME raTvLuminanceToReflectanceImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvLuminanceToReflectanceImageFilterDsol.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterDsol.tif otbLuminanceToReflectanceImageFilter ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvLuminanceToReflectanceImageFilterDsol.tif 0.2 #radius 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 0.9923885328 #d/d0 corresponding to the date 03/05 ) otb_add_test(NAME raTuReflectanceToImageImageFilterAutoFORMOSAT2 COMMAND otbOpticalCalibrationTestDriver otbReflectanceToImageImageFilterAuto LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} ${TEMP}/raTvReflectanceToImageImageFilterAutoFORMOSAT2.tif ${TEMP}/raTvSMALLReflectanceToImageImageFilterAutoFORMOSAT2.tif ) otb_add_test(NAME raTvReflectanceToImageImageFilterAutoSpot5 COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${TEHERANSPOT5DIR}/raTvSMALLTEHERANReflectanceToImageImageFilterAutoSpot5.img ${TEHERANSPOT5DIR}/raTvReflectanceToImageImageFilterAutoSpot5.tif otbReflectanceToImageImageFilterAuto ${TEHERANSPOT5DIR}/IMAGERY.TIF LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} ${TEHERANSPOT5DIR}/raTvReflectanceToImageImageFilterAutoSpot5.tif ${TEHERANSPOT5DIR}/raTvSMALLTEHERANReflectanceToImageImageFilterAutoSpot5.img ) otb_add_test(NAME raTuAeronetNew COMMAND otbOpticalCalibrationTestDriver otbAeronetNew ) otb_add_test(NAME raTvAeronet_ToulouseLevel20_ExtractData COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_6} ${BASELINE_FILES}/raAeronetExtractData_ToulouseLevel20_31_08_1999_16_30_epsilon_2.txt ${TEMP}/raAeronetExtractData_ToulouseLevel20_31_08_1999_16_30_epsilon_2.txt otbAeronetExtractData ${INPUTDATA}/AERONET/990101_011231_Toulouse.lev20 31 # Day 8 # Month 1999 # Year 16 # Hour 30 # Minute 2 # Epsilon ${TEMP}/raAeronetExtractData_ToulouseLevel20_31_08_1999_16_30_epsilon_2.txt ) otb_add_test(NAME raTvAeronet_ArcachonLevel10_ExtractData COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_6} ${BASELINE_FILES}/raAeronetExtractData_ArcachonLevel10_16_08_2009_13_00_epsilon_1.txt ${TEMP}/raAeronetExtractData_ArcachonLevel10_16_08_2009_13_00_epsilon_1.txt otbAeronetExtractData ${INPUTDATA}/AERONET/080101_091231_Arcachon.lev10 16 # Day 8 # Month 2009 # Year 13 # Hour 0 # Minute 1 # Epsilon ${TEMP}/raAeronetExtractData_ArcachonLevel10_16_08_2009_13_00_epsilon_1.txt ) otb_add_test(NAME raTvAeronet_SeyssesLevel15_ExtractData COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_6} ${BASELINE_FILES}/raAeronetExtractData_SeyssesLevel15_23_03_2009_11_00_00_epsilon_0dot4.txt ${TEMP}/raAeronetExtractData_SeyssesLevel15_23_03_2009_11_00_00_epsilon_0dot4.txt otbAeronetExtractData ${INPUTDATA}/AERONET/090101_091231_Seysses.lev15 23 # Day 3 # Month 2009 # Year 10 # Hour 0 # Minute 0.4 # Epsilon ${TEMP}/raAeronetExtractData_SeyssesLevel15_23_03_2009_11_00_00_epsilon_0dot4.txt ) otb_add_test(NAME raTuReflectanceToSurfaceReflectanceImageFilterNew COMMAND otbOpticalCalibrationTestDriver otbReflectanceToSurfaceReflectanceImageFilterNew ) otb_add_test(NAME raTvReflectanceToSurfaceReflectanceImageFilter2 COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvReflectanceToSurfaceReflectanceImageFilter2.tif ${TEMP}/raTvReflectanceToSurfaceReflectanceImageFilter2.tif otbReflectanceToSurfaceReflectanceImageFilterTest2 ${INPUTDATA}/ToulouseExtract_WithGeom.tif ${TEMP}/raTvReflectanceToSurfaceReflectanceImageFilter2.tif 1013 1.424 0.344 1 0.1 ) otb_add_test(NAME raTvReflectanceToSurfaceReflectanceImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvReflectanceToSurfaceReflectanceImageFilter.tif ${TEMP}/raTvReflectanceToSurfaceReflectanceImageFilter.tif otbReflectanceToSurfaceReflectanceImageFilterTest ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvReflectanceToSurfaceReflectanceImageFilter.tif 1 1 1 1 # intrinsic atmospheric reflectance 2 2 2 2 # spherical albedo of the atmosphere 3 3 3 3 # total transmission 2 2 2 2 # downward transmittance 3 3 3 3 # upward transmittance ) otb_add_test(NAME raTuImageMetadataCorrectionParametersNew COMMAND otbOpticalCalibrationTestDriver otbImageMetadataCorrectionParametersNew ) otb_add_test(NAME raTvImageToLuminanceImageFilterAutoFORMOSAT COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoFormosat.tif ${TEMP}/raTvImageToLuminanceImageFilterAutoFormosat.img otbImageToLuminanceImageFilterAuto LARGEINPUT{FORMOSAT/Sudouest_20071013_MS_fmsat/IMAGERY.TIF} ${TEMP}/raTvImageToLuminanceImageFilterAutoFormosat.img ) otb_add_test(NAME raTvImageToLuminanceImageFilterAutoIkonos COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoIkonos.tif ${TEMP}/raTvImageToLuminanceImageFilterAutoIkonos.tif otbImageToLuminanceImageFilterAuto LARGEINPUT{IKONOS/BLOSSEVILLE/po_2619900_pan_0000000.tif} ${TEMP}/raTvImageToLuminanceImageFilterAutoIkonos.tif ) otb_add_test(NAME raTvImageToLuminanceImageFilterAutoQuickbirdXS COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoQuickbirdXS.tif ${TEMP}/raTvImageToLuminanceImageFilterAutoQuickbirdXS.tif otbImageToLuminanceImageFilterAuto LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_MUL/02APR01105228-M1BS-000000128955_01_P001.TIF} ${TEMP}/raTvImageToLuminanceImageFilterAutoQuickbirdXS.tif ) otb_add_test(NAME raTvImageToLuminanceImageFilterAutoQuickbirdPAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoQuickbirdPAN.tif ${TEMP}/raTvImageToLuminanceImageFilterAutoQuickbirdPAN.tif otbImageToLuminanceImageFilterAuto LARGEINPUT{QUICKBIRD/TOULOUSE/000000128955_01_P001_PAN/02APR01105228-P1BS-000000128955_01_P001.TIF} ${TEMP}/raTvImageToLuminanceImageFilterAutoQuickbirdPAN.tif ) otb_add_test(NAME raTvImageToLuminanceImageFilterAutoWV2MULTI COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoWV2Multi.tif ${TEMP}/raTvImageToLuminanceImageFilterAutoWV2Multi.tif otbImageToLuminanceImageFilterAuto LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_MUL/09DEC10103019-M2AS-052298844010_01_P001.TIF} ${TEMP}/raTvImageToLuminanceImageFilterAutoWV2Multi.tif ) otb_add_test(NAME raTvImageToLuminanceImageFilterAutoSpot5 COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoSpot5.tif ${TEMP}/raTvImageToLuminanceImageFilterAutoSpot5.img otbImageToLuminanceImageFilterAuto LARGEINPUT{SPOT5/TEHERAN/IMAGERY.TIF} ${TEMP}/raTvImageToLuminanceImageFilterAutoSpot5.img ) otb_add_test(NAME raTvImageToLuminanceImageFilterAutoWV2PAN COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilterAutoWV2PAN.tif ${TEMP}/raTvImageToLuminanceImageFilterAutoWV2PAN.tif otbImageToLuminanceImageFilterAuto LARGEINPUT{WORLDVIEW2/ROME/WV-2_standard_8band_bundle_16bit/052298844010_01_P001_PAN/09DEC10103019-P2AS-052298844010_01_P001.TIF} ${TEMP}/raTvImageToLuminanceImageFilterAutoWV2PAN.tif ) otb_add_test(NAME raTvAtmosphericCorrectionSequencementTest COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_10} ${BASELINE}/raTvRomaniaAtmosphericCorrectionSequencement.tif ${TEMP}/raTvRomaniaAtmosphericCorrectionSequencement.tif otbAtmosphericCorrectionSequencementTest ${INPUTDATA}/Romania_Extract.tif ${TEMP}/raTvRomaniaAtmosphericCorrectionSequencement.tif ${INPUTDATA}/atmosphericCorrectionSequencement_alpha_beta.txt 27.3 #elevation et azimuth solaire 4 #day 12 #month ${INPUTDATA}/atmosphericCorrectionSequencement_solar_illumination.txt 152.7 2.5 -77.0 1013. 2.48134 0.34400 1 0.199854 ${INPUTDATA}/atmosphericCorrectionSequencement_wavelength_spectral_bands_spot4_1.txt 2 # Radius; 0.020 # pixel spacing in kilometers ) otb_add_test(NAME raTuSIXSTraitsTest COMMAND otbOpticalCalibrationTestDriver otbSIXSTraitsTest) otb_add_test(NAME raTvSIXSTraitsComputeAtmosphericParametersTest COMMAND otbOpticalCalibrationTestDriver --compare-ascii ${EPSILON_4} ${BASELINE_FILES}/raTvSIXSTraitsComputeAtmosphericParametersTest.txt ${TEMP}/raTvSIXSTraitsComputeAtmosphericParametersTest.txt otbSIXSTraitsComputeAtmosphericParametersTest ${INPUTDATA}/in6S_otb ${TEMP}/raTvSIXSTraitsComputeAtmosphericParametersTest.txt ) otb_add_test(NAME raTuReflectanceToImageImageFilterNew COMMAND otbOpticalCalibrationTestDriver otbReflectanceToImageImageFilterNew ) otb_add_test(NAME raTvSurfaceAdjacencyEffectCorrectionSchemeFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSurfaceAdjacencyEffect6SCorrectionSchemeFilter.tif ${TEMP}/raTvSurfaceAdjacencyEffect6SCorrectionSchemeFilter.tif otbSurfaceAdjacencyEffectCorrectionSchemeFilter ${BASELINE}/raTvRomania_Correction.tif ${TEMP}/raTvSurfaceAdjacencyEffect6SCorrectionSchemeFilter.tif 2 # Radius; 0.020 # pixel spacing in kilometers ${INPUTDATA}/romania_parameter.txt # atmo param; ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_B3.txt # wavelengths, channel 3 ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_B2.txt # wavelengths, channel 2 ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_B1.txt # wavelengths, channel 1 ${INPUTDATA}/RADIO_WAVELENGHT_SPECTRAL_BAND_SPOT4_1_MIR.txt # wavelengths, channel 4 ${TEMP}/raTvSurfaceAdjacencyEffect6SCorrectionSchemeFilterOutput6SVallues.txt ) otb_add_test(NAME raTvLuminanceToImageImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvverySmallFSATSWImageFilter.tif otbLuminanceToImageImageFilter ${BASELINE}/raTvImageToLuminanceImageFilter.tif ${TEMP}/raTvverySmallFSATSWImageFilter.tif 10 #channel 1 alpha 20 #channel 2 alpha 30 #channel 3 alpha 40 #channel 4 alpha 1 #channel 1 beta 2 #channel 2 beta 3 #channel 3 beta 4 #channel 4 beta ) otb_add_test(NAME raTvReflectanceToLuminanceImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvverySmallFSATSWImageFilterDsol.tif otbReflectanceToLuminanceImageFilter ${BASELINE}/raTvLuminanceToReflectanceImageFilterDsol.tif ${TEMP}/raTvverySmallFSATSWImageFilterDsol.tif 0.2 #radius 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 0.9923885328 ) otb_add_test(NAME raTvReflectanceToLuminanceImageFilterDayMonth COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvverySmallFSATSWImageFilterDayMonth.tif otbReflectanceToLuminanceImageFilter ${BASELINE}/raTvLuminanceToReflectanceImageFilter.tif ${TEMP}/raTvverySmallFSATSWImageFilterDayMonth.tif 0.2 #radius 10 #channel 1 illumination 20 #channel 2 illumination 30 #channel 3 illumination 40 #channel 4 illumination 3 #day 5 #month ) otb_add_test(NAME raTvImageToLuminanceImageFilter COMMAND otbOpticalCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvImageToLuminanceImageFilter.tif ${TEMP}/raTvImageToLuminanceImageFilter.tif otbImageToLuminanceImageFilter ${INPUTDATA}/verySmallFSATSW.tif ${TEMP}/raTvImageToLuminanceImageFilter.tif 10 #channel 1 alpha 20 #channel 2 alpha 30 #channel 3 alpha 40 #channel 4 alpha 1 #channel 1 beta 2 #channel 2 beta 3 #channel 3 beta 4 #channel 4 beta ) OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbAeronetExtractData.cxx000066400000000000000000000052671301006202600306540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAeronetData.h" #include "otbAeronetFileReader.h" #include "itksys/SystemTools.hxx" #include #include int otbAeronetExtractData(int itkNotUsed(argc), char * argv[]) { otb::AeronetFileReader::Pointer reader = otb::AeronetFileReader::New(); reader->SetFileName(argv[1]); reader->SetDay(atoi(argv[2])); reader->SetMonth(atoi(argv[3])); reader->SetYear(atoi(argv[4])); reader->SetHour(atoi(argv[5])); reader->SetMinute(atoi(argv[6])); reader->SetEpsilon(atof(argv[7])); reader->Update(); otb::AeronetData::Pointer data = reader->GetOutput(); std::ofstream fout(argv[8]); fout << "Aeronet data extracted:" << std::endl; fout << "Input file name: " << itksys::SystemTools::GetFilenameName(std::string(argv[1])) << std::endl; fout << "Inputs user parameters:" << std::endl; fout << " Day: " << reader->GetDay() << std::endl; fout << " Month: " << reader->GetMonth() << std::endl; fout << " Year: " << reader->GetYear() << std::endl; fout << " Hour: " << reader->GetHour() << std::endl; fout << " Minute: " << reader->GetMinute() << std::endl; fout << "Outputs results:" << std::endl; fout << std::setprecision(15) << std::endl; fout << " AerosolOpticalThickness: " << data->GetAerosolOpticalThickness() << std::endl; fout << " AngstromCoefficient: " << data->GetAngstromCoefficient() << std::endl; fout << " Water: " << data->GetWater() << std::endl; fout << " CloudEstimation: " << data->GetCloudEstimation() << std::endl; fout << " SolarZenithAngle: " << data->GetSolarZenithAngle() << std::endl; fout << " Statisctics:" << std::endl; fout << " Date: " << data->GetDataDate() << std::endl; fout << " Epsilon date: " << data->GetEpsilonDate() << std::endl; fout << " Number Of date used: " << data->GetNumberOfDateUsed() << std::endl; fout << " StdDev Aero. Optical Thic.:" << data->GetStdDev() << std::endl; fout.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbAeronetExtractDataBadData.cxx000066400000000000000000000022301301006202600320400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAeronetData.h" #include "otbAeronetFileReader.h" #include "otbSystem.h" int otbAeronetExtractDataBadData(int itkNotUsed(argc), char * argv[]) { otb::AeronetFileReader::Pointer reader = otb::AeronetFileReader::New(); reader->SetFileName(argv[1]); reader->SetDay(atoi(argv[2])); reader->SetMonth(atoi(argv[3])); reader->SetYear(atoi(argv[4])); reader->SetHour(atoi(argv[5])); reader->SetMinute(atoi(argv[6])); reader->SetEpsilon(atof(argv[7])); try { reader->Update(); } catch (itk::ExceptionObject e) { return EXIT_SUCCESS; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbAeronetNew.cxx000066400000000000000000000016471301006202600271770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAeronetData.h" #include "otbAeronetFileReader.h" int otbAeronetNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { otb::AeronetData::Pointer data = otb::AeronetData::New(); otb::AeronetFileReader::Pointer reader = otb::AeronetFileReader::New(); std::cout << data << std::endl; std::cout << reader << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbAtmosphericCorrectionParametersNew.cxx000066400000000000000000000023051301006202600341240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAtmosphericCorrectionParameters.h" #include int otbAtmosphericCorrectionParametersNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AtmosphericCorrectionParameters AtmosphericCorrectionParametersType; typedef otb::FilterFunctionValues FilterFunctionValuesType; // Instantiating object AtmosphericCorrectionParametersType::Pointer objectAtmo = AtmosphericCorrectionParametersType::New(); FilterFunctionValuesType::Pointer objectFilter = FilterFunctionValuesType::New(); std::cout << objectAtmo << std::endl; std::cout << objectFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbAtmosphericCorrectionSequencement.cxx000066400000000000000000000257741301006202600340220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToLuminanceImageFilter.h" #include "otbLuminanceToReflectanceImageFilter.h" #include "otbReflectanceToSurfaceReflectanceImageFilter.h" #include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include int otbAtmosphericCorrectionSequencementTest(int argc, char *argv[]) { if (argc != 19) { std::cerr << "Missing Parameters " << std::endl; std::cerr << "Usage: " << argv[0]; std::cerr << " inputImage , outputImage," << std::endl; std::cerr << " alphaBetaFileName , solarZenithalAngle , day, month , solarIlluminationFileName," << std::endl; std::cerr << " solarAzimutalAngle , viewingZenithalAngle , viewingAzimutalAngle," << std::endl; std::cerr << " atmosphericPressure , waterVaporAmount , ozoneAmount , aerosolModel , AerosolOptical," << std::endl; std::cerr << " wavelengthSpectralBandFileName , adjacencyEffect6SCorrectionWindowRadius, pixelSpacingInKilometers" << std::endl; std::cerr << std::endl; return 1; } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); //------------------------------- typedef otb::ImageToLuminanceImageFilter ImageToLuminanceImageFilterType; typedef ImageToLuminanceImageFilterType::VectorType VectorType; VectorType alpha(nbOfComponent); VectorType beta(nbOfComponent); alpha.Fill(0); beta.Fill(0); std::ifstream fin; fin.open(argv[3]); double dalpha(0.), dbeta(0.); for (unsigned int i = 0; i < nbOfComponent; ++i) { fin >> dalpha; fin >> dbeta; alpha[i] = dalpha; beta[i] = dbeta; } fin.close(); ImageToLuminanceImageFilterType::Pointer filterImageToLuminance = ImageToLuminanceImageFilterType::New(); filterImageToLuminance->SetAlpha(alpha); filterImageToLuminance->SetBeta(beta); filterImageToLuminance->SetInput(reader->GetOutput()); //------------------------------- typedef otb::LuminanceToReflectanceImageFilter LuminanceToReflectanceImageFilterType; typedef LuminanceToReflectanceImageFilterType::VectorType VectorType; VectorType solarIllumination(nbOfComponent); solarIllumination.Fill(0); fin.open(argv[7]); double dsolarIllumination(0.); for (unsigned int i = 0; i < nbOfComponent; ++i) { fin >> dsolarIllumination; solarIllumination[i] = dsolarIllumination; } fin.close(); LuminanceToReflectanceImageFilterType::Pointer filterLuminanceToReflectance = LuminanceToReflectanceImageFilterType::New(); const int day(atoi(argv[5])); const int month(atoi(argv[6])); filterLuminanceToReflectance->SetZenithalSolarAngle(static_cast(atof(argv[4]))); filterLuminanceToReflectance->SetDay(day); filterLuminanceToReflectance->SetMonth(month); filterLuminanceToReflectance->SetSolarIllumination(solarIllumination); filterLuminanceToReflectance->SetInput(filterImageToLuminance->GetOutput()); //------------------------------- /*typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms RadiometryCorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmosphericCorrectionParametersType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef AtmosphericCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; AtmosphericCorrectionParametersType::Pointer dataAtmosphericCorrectionParameters = AtmosphericCorrectionParametersType::New(); AtmosphericRadiativeTermsType::Pointer dataAtmosphericRadiativeTerms = AtmosphericRadiativeTermsType::New(); */ typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; //std::vector AcquiCorrectionParametersPointerType paramAcqui = AcquiCorrectionParametersType::New(); AtmoCorrectionParametersPointerType paramAtmo = AtmoCorrectionParametersType::New(); FilterFunctionValuesType::Pointer functionValues; double minSpectralValue(0.); double maxSpectralValue(0.); double userStep(0.); double value(0.); unsigned int nbBands(0); unsigned int nbValuesPerBand(0); std::string sString; ValuesVectorType valuesVector; fin.open(argv[16]); fin >> nbBands; for (unsigned int i = 0; i < nbBands; ++i) { valuesVector.clear(); fin >> sString; fin >> minSpectralValue; fin >> maxSpectralValue; fin >> userStep; fin >> nbValuesPerBand; for (unsigned int j = 0; j < nbValuesPerBand; ++j) { fin >> value; valuesVector.push_back(value); } FilterFunctionValuesType::Pointer functionValues2 = FilterFunctionValuesType::New(); functionValues2->SetFilterFunctionValues(valuesVector); functionValues2->SetMinSpectralValue(minSpectralValue); functionValues2->SetMaxSpectralValue(maxSpectralValue); functionValues2->SetUserStep(userStep); paramAcqui->SetWavelengthSpectralBandWithIndex(i, functionValues2); } fin.close(); // Set parameters /*dataAtmosphericCorrectionParameters->SetSolarZenithalAngle(filterLuminanceToReflectance->GetZenithalSolarAngle()); dataAtmosphericCorrectionParameters->SetSolarAzimutalAngle(static_cast(atof(argv[8]))); dataAtmosphericCorrectionParameters->SetViewingZenithalAngle(static_cast(atof(argv[9]))); dataAtmosphericCorrectionParameters->SetViewingAzimutalAngle(static_cast(atof(argv[10]))); dataAtmosphericCorrectionParameters->SetMonth(month); dataAtmosphericCorrectionParameters->SetDay(day); dataAtmosphericCorrectionParameters->SetAtmosphericPressure(static_cast(atof(argv[11]))); dataAtmosphericCorrectionParameters->SetWaterVaporAmount(static_cast(atof(argv[12]))); dataAtmosphericCorrectionParameters->SetOzoneAmount(static_cast(atof(argv[13]))); AerosolModelType aerosolModel = static_cast(::atoi(argv[14])); dataAtmosphericCorrectionParameters->SetAerosolModel(aerosolModel); dataAtmosphericCorrectionParameters->SetAerosolOptical(static_cast(atof(argv[15]))); RadiometryCorrectionParametersToRadiativeTermsType::Pointer filterAtmosphericCorrectionParametersTo6SRadiativeTerms = RadiometryCorrectionParametersToRadiativeTermsType::New(); filterAtmosphericCorrectionParametersTo6SRadiativeTerms->SetInput(dataAtmosphericCorrectionParameters); filterAtmosphericCorrectionParametersTo6SRadiativeTerms->Update(); */ paramAcqui->SetSolarZenithalAngle(filterLuminanceToReflectance->GetZenithalSolarAngle()); paramAcqui->SetSolarAzimutalAngle(static_cast(atof(argv[8]))); paramAcqui->SetViewingZenithalAngle(static_cast(atof(argv[9]))); paramAcqui->SetViewingAzimutalAngle(static_cast(atof(argv[10]))); paramAcqui->SetMonth(month); paramAcqui->SetDay(day); paramAtmo->SetAtmosphericPressure(static_cast(atof(argv[11]))); paramAtmo->SetWaterVaporAmount(static_cast(atof(argv[12]))); paramAtmo->SetOzoneAmount(static_cast(atof(argv[13]))); AerosolModelType aerosolModel = static_cast(::atoi(argv[14])); paramAtmo->SetAerosolModel(aerosolModel); paramAtmo->SetAerosolOptical(static_cast(atof(argv[15]))); AtmosphericRadiativeTermsPointerType radiative = CorrectionParametersToRadiativeTermsType::Compute(paramAtmo,paramAcqui); //------------------------------- typedef otb::ReflectanceToSurfaceReflectanceImageFilter ReflectanceToSurfaceReflectanceImageFilterType; ReflectanceToSurfaceReflectanceImageFilterType::Pointer filterReflectanceToSurfaceReflectanceImageFilter = ReflectanceToSurfaceReflectanceImageFilterType::New(); filterReflectanceToSurfaceReflectanceImageFilter->SetAtmosphericRadiativeTerms(radiative); filterReflectanceToSurfaceReflectanceImageFilter->SetInput(filterLuminanceToReflectance->GetOutput()); //------------------------------- typedef otb::SurfaceAdjacencyEffectCorrectionSchemeFilter SurfaceAdjacencyEffectCorrectionSchemeFilterType; SurfaceAdjacencyEffectCorrectionSchemeFilterType::Pointer filterSurfaceAdjacencyEffectCorrectionSchemeFilter = SurfaceAdjacencyEffectCorrectionSchemeFilterType::New(); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetAtmosphericRadiativeTerms(radiative); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetWindowRadius(atoi(argv[17])); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetPixelSpacingInKilometers(static_cast(atof(argv[18]))); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetZenithalViewingAngle(paramAcqui->GetViewingZenithalAngle()); filterSurfaceAdjacencyEffectCorrectionSchemeFilter->SetInput(filterReflectanceToSurfaceReflectanceImageFilter->GetOutput()); //------------------------------- WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(filterSurfaceAdjacencyEffectCorrectionSchemeFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbAtmosphericRadiativeTermsTest.cxx000066400000000000000000000111341301006202600331020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbAtmosphericRadiativeTerms.h" #include int otbAtmosphericRadiativeTermsNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; // Instantiating object AtmosphericRadiativeTermsType::Pointer object = AtmosphericRadiativeTermsType::New(); return EXIT_SUCCESS; } int otbAtmosphericRadiativeTermsSingleChannelNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::AtmosphericRadiativeTermsSingleChannel AtmosphericRadiativeTermsType; // Instantiating object AtmosphericRadiativeTermsType::Pointer object = AtmosphericRadiativeTermsType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } std::ostream& operator<<(std::ostream& os, const otb::AtmosphericRadiativeTerms::DataVectorType& values) { os << "["; if (values.size() > 0) { os << values[0]; } for (unsigned int i = 1; i < values.size(); ++i) { os << ", "; os << values[i]; } os << "]\n"; return os; } int otbAtmosphericRadiativeTermsTest(int itkNotUsed(argc), char * argv[]) { char * filename = argv[1]; std::ofstream file; file.open(filename); typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; // Instantiating object AtmosphericRadiativeTermsType::Pointer object = AtmosphericRadiativeTermsType::New(); object->ValuesInitialization(3); // Set the values AtmosphericRadiativeTermsType::DataVectorType values; values.push_back(1.0); values.push_back(2.0); values.push_back(3.0); object->SetIntrinsicAtmosphericReflectances(values); object->SetSphericalAlbedos(values); object->SetTotalGaseousTransmissions(values); object->SetDownwardTransmittances(values); object->SetUpwardTransmittances(values); object->SetUpwardDiffuseTransmittances(values); object->SetUpwardDirectTransmittances(values); object->SetUpwardDiffuseTransmittancesForRayleigh(values); object->SetUpwardDiffuseTransmittancesForAerosol(values); object->SetWavelengthSpectralBand(values); file << object << std::endl; file << "\n\n TESTING ACCESSOR OUT OF RANGE \n\n"; object->SetSphericalAlbedo(3, 4.0); object->SetTotalGaseousTransmission(5, 5.0); object->SetDownwardTransmittance(6, 6.0); object->SetUpwardTransmittance(7, 7.0); object->SetUpwardDiffuseTransmittance(8, 8.0); object->SetUpwardDirectTransmittance(9, 9.0); object->SetUpwardDiffuseTransmittanceForRayleigh(10, 10.0); object->SetUpwardDiffuseTransmittanceForAerosol(11, 11.0); object->SetWavelengthSpectralBand(12, 12.0); file << object << std::endl; file << "\n\n TESTING ACCESSOR \n\n"; file << object->GetIntrinsicAtmosphericReflectances() << std::endl; file << object->GetSphericalAlbedos() << std::endl; file << object->GetTotalGaseousTransmissions() << std::endl; file << object->GetDownwardTransmittances() << std::endl; file << object->GetUpwardTransmittances() << std::endl; file << object->GetUpwardDiffuseTransmittances() << std::endl; file << object->GetUpwardDirectTransmittances() << std::endl; file << object->GetUpwardDiffuseTransmittancesForRayleigh() << std::endl; file << object->GetUpwardDiffuseTransmittancesForAerosol() << std::endl; file << object->GetWavelengthSpectralBand() << std::endl; file << "\n\n TESTING ACCESSOR WITH INDEX\n\n"; file << object->GetIntrinsicAtmosphericReflectance(0) << std::endl; file << object->GetSphericalAlbedo(5) << std::endl; file << object->GetTotalGaseousTransmission(5) << std::endl; file << object->GetDownwardTransmittance(5) << std::endl; file << object->GetUpwardTransmittance(5) << std::endl; file << object->GetUpwardDiffuseTransmittance(5) << std::endl; file << object->GetUpwardDirectTransmittance(5) << std::endl; file << object->GetUpwardDiffuseTransmittanceForRayleigh(5) << std::endl; file << object->GetUpwardDiffuseTransmittanceForAerosol(5) << std::endl; file << object->GetWavelengthSpectralBand(12) << std::endl; file << std::endl; file << object->GetValueByIndex(5) << std::endl; file.close(); return EXIT_SUCCESS; } otbImageMetadataCorrectionParametersNew.cxx000066400000000000000000000017121301006202600342530ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageMetadataCorrectionParameters.h" int otbImageMetadataCorrectionParametersNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::ImageMetadataCorrectionParameters CorrectionParametersType; // Instantiating object CorrectionParametersType::Pointer objectAtmo = CorrectionParametersType::New(); std::cout << objectAtmo << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbImageToLuminanceImageFilter.cxx000066400000000000000000000045551301006202600324230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToLuminanceImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbImageToLuminanceImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageToLuminanceImageFilter ImageToLuminanceImageFilterType; typedef ImageToLuminanceImageFilterType::VectorType VectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); VectorType alpha(nbOfComponent); VectorType beta(nbOfComponent); alpha.Fill(0); beta.Fill(0); for (unsigned int i = 0; i < nbOfComponent; ++i) { alpha[i] = static_cast(atof(argv[i + 3])); beta[i] = static_cast(atof(argv[i + 7])); } // Instantiating object ImageToLuminanceImageFilterType::Pointer filter = ImageToLuminanceImageFilterType::New(); filter->SetAlpha(alpha); filter->SetBeta(beta); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbImageToLuminanceImageFilterAuto.cxx000066400000000000000000000044021301006202600332430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToLuminanceImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" //Test the retrieval of parameters from the image metadata int otbImageToLuminanceImageFilterAuto(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageToLuminanceImageFilter ImageToLuminanceImageFilterType; typedef otb::MultiChannelExtractROI RoiFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); // Instantiating object ImageToLuminanceImageFilterType::Pointer filter = ImageToLuminanceImageFilterType::New(); filter->SetInput(reader->GetOutput()); RoiFilterType::Pointer roiFilter = RoiFilterType::New(); roiFilter->SetStartX(1000); roiFilter->SetStartY(1000); roiFilter->SetSizeX(100); roiFilter->SetSizeY(100); roiFilter->SetInput(filter->GetOutput()); writer->SetInput(roiFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbImageToLuminanceImageFilterNew.cxx000066400000000000000000000022271301006202600330670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToLuminanceImageFilter.h" int otbImageToLuminanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::ImageToLuminanceImageFilter ImageToLuminanceImageFilterType; // Instantiating object ImageToLuminanceImageFilterType::Pointer filter = ImageToLuminanceImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbImageToReflectanceImageFilter.cxx000066400000000000000000000061771301006202600327250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToReflectanceImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVariableLengthVector.h" int otbImageToReflectanceImageFilter(int argc, char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const double angle = static_cast(atof(argv[3])); double flux = 0.; int day = 1; int month = 1; if (argc == 17) { flux = static_cast(atof(argv[16])); } else { day = atoi(argv[16]); month = atoi(argv[17]); } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageToReflectanceImageFilter ImageToReflectanceImageFilterType; typedef ImageToReflectanceImageFilterType::VectorType VectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); VectorType alpha(nbOfComponent); VectorType beta(nbOfComponent); VectorType solarIllumination(nbOfComponent); alpha.Fill(0); beta.Fill(0); solarIllumination.Fill(0); for (unsigned int i = 0; i < nbOfComponent; ++i) { alpha[i] = static_cast(atof(argv[i + 4])); beta[i] = static_cast(atof(argv[i + 8])); solarIllumination[i] = static_cast(atof(argv[i + 12])); } // Instantiating object ImageToReflectanceImageFilterType::Pointer filter = ImageToReflectanceImageFilterType::New(); filter->SetAlpha(alpha); filter->SetBeta(beta); filter->SetZenithalSolarAngle(angle); filter->SetSolarIllumination(solarIllumination); filter->SetUseClamp(false); if (argc == 17) { filter->SetFluxNormalizationCoefficient(flux); } else { filter->SetDay(day); filter->SetMonth(month); } filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbImageToReflectanceImageFilterAuto.cxx000066400000000000000000000043761301006202600335550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToReflectanceImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" int otbImageToReflectanceImageFilterAuto(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageToReflectanceImageFilter ImageToReflectanceImageFilterType; typedef otb::MultiChannelExtractROI RoiFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); // Instantiating object ImageToReflectanceImageFilterType::Pointer filter = ImageToReflectanceImageFilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetUseClamp(false); RoiFilterType::Pointer roiFilter = RoiFilterType::New(); roiFilter->SetStartX(1000); roiFilter->SetStartY(1000); roiFilter->SetSizeX(100); roiFilter->SetSizeY(100); roiFilter->SetInput(filter->GetOutput()); writer->SetInput(roiFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbImageToReflectanceImageFilterNew.cxx000066400000000000000000000022431301006202600333650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageToReflectanceImageFilter.h" int otbImageToReflectanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::ImageToReflectanceImageFilter ImageToReflectanceImageFilterType; // Instantiating object ImageToReflectanceImageFilterType::Pointer filter = ImageToReflectanceImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbLuminanceToImageImageFilter.cxx000066400000000000000000000046561301006202600324250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLuminanceToImageImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVariableLengthVector.h" int otbLuminanceToImageImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::LuminanceToImageImageFilter LuminanceToImageImageFilterType; typedef LuminanceToImageImageFilterType::VectorType VectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); VectorType alpha(nbOfComponent); VectorType beta(nbOfComponent); alpha.Fill(0); beta.Fill(0); for (unsigned int i = 0; i < nbOfComponent; ++i) { alpha[i] = static_cast(atof(argv[i + 3])); beta[i] = static_cast(atof(argv[i + 7])); } // Instantiating object LuminanceToImageImageFilterType::Pointer filter = LuminanceToImageImageFilterType::New(); filter->SetAlpha(alpha); filter->SetBeta(beta); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbLuminanceToImageImageFilterAuto.cxx000066400000000000000000000051651301006202600332520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLuminanceToImageImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" //Test the retrieval of parameters from the image metadata int otbLuminanceToImageImageFilterAuto(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * inputFileName2 = argv[2]; const char * outputFileName = argv[3]; const char * outputFileName2 = argv[4]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::LuminanceToImageImageFilter LuminanceToImageImageFilterType; typedef otb::MultiChannelExtractROI RoiFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); ReaderType::Pointer reader2 = ReaderType::New(); WriterType::Pointer writer2 = WriterType::New(); reader2->SetFileName(inputFileName2); writer2->SetFileName(outputFileName2); reader2->UpdateOutputInformation(); // Instantiating object LuminanceToImageImageFilterType::Pointer filter = LuminanceToImageImageFilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); RoiFilterType::Pointer roiFilter = RoiFilterType::New(); roiFilter->SetStartX(1000); roiFilter->SetStartY(1000); roiFilter->SetSizeX(100); roiFilter->SetSizeY(100); roiFilter->SetInput(reader2->GetOutput()); writer2->SetInput(roiFilter->GetOutput()); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbLuminanceToImageImageFilterNew.cxx000066400000000000000000000022631301006202600330670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLuminanceToImageImageFilter.h" #include "otbVectorImage.h" int otbLuminanceToImageImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::LuminanceToImageImageFilter LuminanceToImageImageFilterType; // Instantiating object LuminanceToImageImageFilterType::Pointer filter = LuminanceToImageImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbLuminanceToReflectanceImageFilter.cxx000066400000000000000000000060441301006202600336070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLuminanceToReflectanceImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbLuminanceToReflectanceImageFilter(int argc, char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const double angle = static_cast(atof(argv[3])); double flux = 0.; int day = 1; int month = 1; if (argc == 9) { flux = static_cast(atof(argv[8])); } else { day = atoi(argv[8]); month = atoi(argv[9]); } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::LuminanceToReflectanceImageFilter LuminanceToReflectanceImageFilterType; typedef LuminanceToReflectanceImageFilterType::VectorType VectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); // WARNING : 1 ELEMENT FOR EACH PIXEL IMAGE COMPONENT VectorType solarIllumination(nbOfComponent); solarIllumination.Fill(0); solarIllumination[0] = static_cast(atof(argv[4])); solarIllumination[1] = static_cast(atof(argv[5])); solarIllumination[2] = static_cast(atof(argv[6])); solarIllumination[3] = static_cast(atof(argv[7])); // Instantiating object LuminanceToReflectanceImageFilterType::Pointer filter = LuminanceToReflectanceImageFilterType::New(); filter->SetZenithalSolarAngle(angle); filter->SetSolarIllumination(solarIllumination); filter->SetUseClamp(false); if (argc == 9) { filter->SetFluxNormalizationCoefficient(flux); } else { filter->SetDay(day); filter->SetMonth(month); } filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbLuminanceToReflectanceImageFilterAuto.cxx000066400000000000000000000051641301006202600343630ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageToLuminanceImageFilter.h" #include "otbLuminanceToReflectanceImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" int otbLuminanceToReflectanceImageFilterAuto(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageToLuminanceImageFilter ImageToLuminanceImageFilterType; typedef otb::LuminanceToReflectanceImageFilter LuminanceToReflectanceImageFilterType; typedef otb::MultiChannelExtractROI RoiFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); // Instantiating object ImageToLuminanceImageFilterType::Pointer filterToLuminance = ImageToLuminanceImageFilterType::New(); filterToLuminance->SetInput(reader->GetOutput()); LuminanceToReflectanceImageFilterType::Pointer filterToReflectance = LuminanceToReflectanceImageFilterType::New(); filterToReflectance->SetInput(filterToLuminance->GetOutput()); filterToReflectance->SetUseClamp(false); RoiFilterType::Pointer roiFilter = RoiFilterType::New(); roiFilter->SetStartX(1000); roiFilter->SetStartY(1000); roiFilter->SetSizeX(100); roiFilter->SetSizeY(100); roiFilter->SetInput(filterToReflectance->GetOutput()); writer->SetInput(roiFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbLuminanceToReflectanceImageFilterNew.cxx000066400000000000000000000023271301006202600342020ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbLuminanceToReflectanceImageFilter.h" #include "otbVectorImage.h" int otbLuminanceToReflectanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::LuminanceToReflectanceImageFilter LuminanceToReflectanceImageFilterType; // Instantiating object LuminanceToReflectanceImageFilterType::Pointer filter = LuminanceToReflectanceImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbOpticalCalibrationTestDriver.cxx000066400000000000000000000045501301006202600327030ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbSpectralSensitivityReaderNew); REGISTER_TEST(otbSpectralSensitivityReaderTest); REGISTER_TEST(otbSpectralSensitivityReaderGenericTest); REGISTER_TEST(otbReflectanceToImageImageFilter); REGISTER_TEST(otbReflectanceToLuminanceImageFilterNew); REGISTER_TEST(otbLuminanceToReflectanceImageFilterNew); REGISTER_TEST(otbLuminanceToReflectanceImageFilterAuto); REGISTER_TEST(otbImageToLuminanceImageFilterNew); REGISTER_TEST(otbRadiometryCorrectionParametersToAtmosphericRadiativeTermsNew); REGISTER_TEST(otbLuminanceToImageImageFilterAuto); REGISTER_TEST(otbLuminanceToImageImageFilterNew); REGISTER_TEST(otbReflectanceToLuminanceImageFilterAuto); REGISTER_TEST(otbAeronetExtractDataBadData); REGISTER_TEST(otbRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter); REGISTER_TEST(otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms); REGISTER_TEST(otbSurfaceAdjacencyEffectCorrectionSchemeFilterNew); REGISTER_TEST(otbImageToReflectanceImageFilterAuto); REGISTER_TEST(otbAtmosphericCorrectionParametersNew); REGISTER_TEST(otbImageToReflectanceImageFilterNew); REGISTER_TEST(otbFilterFunctionValuesNew); REGISTER_TEST(otbWavelengthSpectralBandsNew); REGISTER_TEST(otbAtmosphericRadiativeTermsNew); REGISTER_TEST(otbAtmosphericRadiativeTermsSingleChannelNew); REGISTER_TEST(otbAtmosphericRadiativeTermsTest); REGISTER_TEST(otbImageToReflectanceImageFilter); REGISTER_TEST(otbLuminanceToReflectanceImageFilter); REGISTER_TEST(otbReflectanceToImageImageFilterAuto); REGISTER_TEST(otbAeronetNew); REGISTER_TEST(otbAeronetExtractData); REGISTER_TEST(otbReflectanceToSurfaceReflectanceImageFilterNew); REGISTER_TEST(otbReflectanceToSurfaceReflectanceImageFilterTest); REGISTER_TEST(otbReflectanceToSurfaceReflectanceImageFilterTest2); REGISTER_TEST(otbImageMetadataCorrectionParametersNew); REGISTER_TEST(otbImageToLuminanceImageFilterAuto); REGISTER_TEST(otbAtmosphericCorrectionSequencementTest); REGISTER_TEST(otbSIXSTraitsTest); REGISTER_TEST(otbSIXSTraitsComputeAtmosphericParametersTest); REGISTER_TEST(otbReflectanceToImageImageFilterNew); REGISTER_TEST(otbSurfaceAdjacencyEffectCorrectionSchemeFilter); REGISTER_TEST(otbLuminanceToImageImageFilter); REGISTER_TEST(otbReflectanceToLuminanceImageFilter); REGISTER_TEST(otbImageToLuminanceImageFilter); } otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.cxx000066400000000000000000000214541301006202600406100ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h" #include "otbAtmosphericCorrectionParameters.h" #include #include #include #include #include int otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " wavelenghFile outputFile " << std::endl; return EXIT_FAILURE; } const char * wavelenghFile = argv[1]; const char * outputFile = argv[2]; typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef otb::AtmosphericRadiativeTerms RadiativeTermsType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::WavelengthSpectralBandType ValueType; typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; // Instantiating object AtmoCorrectionParametersType::Pointer paramAtmo = AtmoCorrectionParametersType::New(); AcquiCorrectionParametersType::Pointer paramAcqui = AcquiCorrectionParametersType::New(); AerosolModelType aerosolModel; FilterFunctionValuesType::Pointer functionValues = FilterFunctionValuesType::New(); ValuesVectorType vect; ValueType val = 0.0025; vect.clear(); // Filter function values initialization float minSpectralValue(0.); float maxSpectralValue(0.); float value(0.); // Correction parameters initialization double solarZenithalAngle(0.); double solarAzimutalAngle(0.); double viewingZenithalAngle(0.); double viewingAzimutalAngle(0.); unsigned int month(0); unsigned int day(0); double atmosphericPressure(0.); double waterVaporAmount(0.); double ozoneAmount(0.); double aerosolOptical(0.); std::ifstream fin; std::ofstream fout; //Read input file parameters fin.open(wavelenghFile); fin >> solarZenithalAngle; //asol; fin >> solarAzimutalAngle; //phi0; fin >> viewingZenithalAngle; //avis; fin >> viewingAzimutalAngle; //phiv; fin >> month; //month; fin >> day; //jday; fin >> atmosphericPressure; //pressure; fin >> waterVaporAmount; //uw; fin >> ozoneAmount; //uo3; unsigned int aer(0); fin >> aer; //iaer; aerosolModel = static_cast(aer); fin >> aerosolOptical; //taer55; fin >> minSpectralValue; //wlinf; fin >> maxSpectralValue; //wlsup; std::string line; std::getline(fin, line); while (std::getline(fin, line)) { value = atof(line.c_str()); vect.push_back(value); } fin.close(); functionValues->SetFilterFunctionValues(vect); functionValues->SetMinSpectralValue(minSpectralValue); functionValues->SetMaxSpectralValue(maxSpectralValue); functionValues->SetUserStep(val); paramAcqui->SetWavelengthSpectralBandWithIndex(0, functionValues); // Set parameters paramAcqui->SetSolarZenithalAngle(static_cast(solarZenithalAngle)); paramAcqui->SetSolarAzimutalAngle(static_cast(solarAzimutalAngle)); paramAcqui->SetViewingZenithalAngle(static_cast(viewingZenithalAngle)); paramAcqui->SetViewingAzimutalAngle(static_cast(viewingAzimutalAngle)); paramAcqui->SetMonth(month); paramAcqui->SetDay(day); paramAtmo->SetAtmosphericPressure(static_cast(atmosphericPressure)); paramAtmo->SetWaterVaporAmount(static_cast(waterVaporAmount)); paramAtmo->SetOzoneAmount(static_cast(ozoneAmount)); paramAtmo->SetAerosolModel(aerosolModel); paramAtmo->SetAerosolOptical(static_cast(aerosolOptical)); RadiativeTermsType::Pointer radiative = CorrectionParametersToRadiativeTermsType::Compute(paramAtmo,paramAcqui); fout.open(outputFile); fout << " ---------------------------------------------------------" << std::endl; fout << "Inputs values:" << std::setprecision(10) << std::endl; fout << " -----> SolarZenithalAngle : " << solarZenithalAngle << std::endl; fout << " -----> SolarAzimutalAngle : " << solarAzimutalAngle << std::endl; fout << " -----> ViewingZenithalAngle : " << viewingZenithalAngle << std::endl; fout << " -----> ViewingAzimutalAngle : " << viewingAzimutalAngle << std::endl; fout << " -----> Month : " << month << std::endl; fout << " -----> Day : " << day << std::endl; fout << " -----> AtmosphericPressure : " << atmosphericPressure << std::endl; fout << " -----> WaterVaporAmount : " << waterVaporAmount << std::endl; fout << " -----> OzoneAmount : " << ozoneAmount << std::endl; fout << " -----> AerosolModel : " << aer << std::endl; fout << " -----> AerosolOptical : " << aerosolOptical << std::endl; fout << " -----> MinSpectralValue : " << minSpectralValue << std::endl; fout << " -----> MaxSpectralValue : " << maxSpectralValue << std::endl; fout << " -----> UserStep : " << functionValues->GetUserStep() << std::endl; fout << " ---------------------------------------------------------" << std::endl; fout << "Outputs values:" << std::endl; fout << " -----> atmospheric reflectance : " << radiative->GetIntrinsicAtmosphericReflectance(0) << std::endl; fout << " -----> atmospheric spherical albedo : " << radiative->GetSphericalAlbedo(0) << std::endl; fout << " -----> total gaseous transmission : " << radiative->GetTotalGaseousTransmission(0) << std::endl; fout << " -----> downward transmittance : " << radiative->GetDownwardTransmittance(0) << std::endl; fout << " -----> upward transmittance : " << radiative->GetUpwardTransmittance(0) << std::endl; fout << " -----> upward diffuse transmittance : " << radiative->GetUpwardDiffuseTransmittance(0) << std::endl; fout << " -----> upward direct transmittance : " << radiative->GetUpwardDirectTransmittance(0) << std::endl; fout << " -----> upward diffuse transmittance for rayleigh : " << radiative->GetUpwardDiffuseTransmittanceForRayleigh(0) << std::endl; fout << " -----> upward diffuse transmittance for aerosols : " << radiative->GetUpwardDiffuseTransmittanceForAerosol(0) << std::endl; fout << " -----> MinSpectralValue update: " << functionValues->GetMinSpectralValue() << std::endl; fout << " -----> MaxSpectralValue update : " << functionValues->GetMaxSpectralValue() << std::endl; fout << " ---------------------------------------------------------" << std::endl; fout << "Input wavelength band values [" << functionValues->GetFilterFunctionValues().size() << "]:" << std::endl; for (unsigned int i = 0; i < functionValues->GetFilterFunctionValues().size(); ++i) { fout << " " << functionValues->GetFilterFunctionValues()[i] << std::endl; } fout << " ---------------------------------------------------------" << std::endl; fout << "Output wavelength band values 6S [" << functionValues->GetFilterFunctionValues6S().size() << "]:" << std::endl; for (unsigned int i = 0; i < functionValues->GetFilterFunctionValues6S().size(); ++i) { fout << " " << functionValues->GetFilterFunctionValues6S()[i] << std::endl; } fout << std::endl; fout.close(); return EXIT_SUCCESS; } otbRadiometryCorrectionParametersToAtmosphericRadiativeTermsNew.cxx000066400000000000000000000024351301006202600412600ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h" #include int otbRadiometryCorrectionParametersToAtmosphericRadiativeTermsNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms RadiometryCorrectionParametersToAtmosphericRadiativeTermsType; // Instantiating object //RadiometryCorrectionParametersToAtmosphericRadiativeTermsType::Pointer object = // RadiometryCorrectionParametersToAtmosphericRadiativeTermsType::New(); RadiometryCorrectionParametersToAtmosphericRadiativeTermsType* object = new RadiometryCorrectionParametersToAtmosphericRadiativeTermsType; std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbReflectanceToImageImageFilter.cxx000066400000000000000000000133641301006202600327210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbReflectanceToImageImageFilter.h" //#include "otbReflectanceToLuminanceImageFilter.h" //#include "otbLuminanceToImageImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVariableLengthVector.h" int otbReflectanceToImageImageFilter(int argc, char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const double angle = static_cast(atof(argv[3])); double flux = 0.; int day = 1; int month = 1; if (argc == 17) { flux = static_cast(atof(argv[16])); } else { day = atoi(argv[16]); month = atoi(argv[17]); } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToImageImageFilter ReflectanceToImageImageFilterType; typedef ReflectanceToImageImageFilterType::VectorType VectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); VectorType alpha(nbOfComponent); VectorType beta(nbOfComponent); VectorType solarIllumination(nbOfComponent); alpha.Fill(0); beta.Fill(0); solarIllumination.Fill(0); for (unsigned int i = 0; i < nbOfComponent; ++i) { alpha[i] = static_cast(atof(argv[i + 4])); beta[i] = static_cast(atof(argv[i + 8])); solarIllumination[i] = static_cast(atof(argv[i + 12])); } // Instantiating object ReflectanceToImageImageFilterType::Pointer filter = ReflectanceToImageImageFilterType::New(); filter->SetAlpha(alpha); filter->SetBeta(beta); filter->SetZenithalSolarAngle(angle); filter->SetSolarIllumination(solarIllumination); if (argc == 17) { filter->SetFluxNormalizationCoefficient(flux); } else { filter->SetDay(day); filter->SetMonth(month); } filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; /*const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const double angle = static_cast(atof(argv[3])); double flux = 0.; int day = 1; int month = 1; if (argc == 17) { flux = static_cast(atof(argv[16])); } else { day = atoi(argv[16]); month = atoi(argv[17]); } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToLuminanceImageFilter ReflectanceToLuminanceImageFilterType; typedef otb::LuminanceToImageImageFilter LuminanceToImageImageFilterType; typedef ReflectanceToLuminanceImageFilterType::VectorType VectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); VectorType alpha(nbOfComponent); VectorType beta(nbOfComponent); VectorType solarIllumination(nbOfComponent); alpha.Fill(0); beta.Fill(0); solarIllumination.Fill(0); for (unsigned int i = 0; i < nbOfComponent; ++i) { alpha[i] = static_cast(atof(argv[i + 4])); beta[i] = static_cast(atof(argv[i + 8])); solarIllumination[i] = static_cast(atof(argv[i + 12])); } // Instantiating object ReflectanceToLuminanceImageFilterType::Pointer filter = ReflectanceToLuminanceImageFilterType::New(); LuminanceToImageImageFilterType::Pointer filter2 = LuminanceToImageImageFilterType::New(); filter2->SetAlpha(alpha); filter2->SetBeta(beta); filter->SetZenithalSolarAngle(angle); filter->SetSolarIllumination(solarIllumination); if (argc == 17) { filter->SetFluxNormalizationCoefficient(flux); } else { filter->SetDay(day); filter->SetMonth(month); } filter->SetInput(reader->GetOutput()); filter2->SetInput(filter->GetOutput()); writer->SetInput(filter2->GetOutput()); writer->Update(); return EXIT_SUCCESS; */ } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbReflectanceToImageImageFilterAuto.cxx000066400000000000000000000051661301006202600335530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbReflectanceToImageImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkVariableLengthVector.h" #include "otbMultiChannelExtractROI.h" int otbReflectanceToImageImageFilterAuto(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * inputFileName2 = argv[2]; const char * outputFileName = argv[3]; const char * outputFileName2 = argv[4]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToImageImageFilter ReflectanceToImageImageFilterType; typedef otb::MultiChannelExtractROI RoiFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); ReaderType::Pointer reader2 = ReaderType::New(); WriterType::Pointer writer2 = WriterType::New(); reader2->SetFileName(inputFileName2); writer2->SetFileName(outputFileName2); reader2->UpdateOutputInformation(); // Instantiating object ReflectanceToImageImageFilterType::Pointer filter = ReflectanceToImageImageFilterType::New(); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); RoiFilterType::Pointer roiFilter = RoiFilterType::New(); roiFilter->SetStartX(1000); roiFilter->SetStartY(1000); roiFilter->SetSizeX(100); roiFilter->SetSizeY(100); roiFilter->SetInput(reader2->GetOutput()); writer2->SetInput(roiFilter->GetOutput()); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbReflectanceToImageImageFilterNew.cxx000066400000000000000000000022431301006202600333650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbReflectanceToImageImageFilter.h" int otbReflectanceToImageImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::ReflectanceToImageImageFilter ReflectanceToImageImageFilterType; // Instantiating object ReflectanceToImageImageFilterType::Pointer filter = ReflectanceToImageImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbReflectanceToLuminanceImageFilter.cxx000066400000000000000000000060101301006202600336000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbReflectanceToLuminanceImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbReflectanceToLuminanceImageFilter(int argc, char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const double angle = static_cast(atof(argv[3])); double flux = 0.; int day = 1; int month = 1; if (argc == 9) { flux = static_cast(atof(argv[8])); } else { day = atoi(argv[8]); month = atoi(argv[9]); } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToLuminanceImageFilter ReflectanceToLuminanceImageFilterType; typedef ReflectanceToLuminanceImageFilterType::VectorType VectorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbOfComponent = reader->GetOutput()->GetNumberOfComponentsPerPixel(); // WARNING : 1 ELEMENT FOR EACH PIXEL IMAGE COMPONENT VectorType solarIllumination(nbOfComponent); solarIllumination.Fill(0); solarIllumination[0] = static_cast(atof(argv[4])); solarIllumination[1] = static_cast(atof(argv[5])); solarIllumination[2] = static_cast(atof(argv[6])); solarIllumination[3] = static_cast(atof(argv[7])); // Instantiating object ReflectanceToLuminanceImageFilterType::Pointer filter = ReflectanceToLuminanceImageFilterType::New(); filter->SetZenithalSolarAngle(angle); filter->SetSolarIllumination(solarIllumination); filter->SetUseClamp(false); if (argc == 9) { filter->SetFluxNormalizationCoefficient(flux); } else { filter->SetDay(day); filter->SetMonth(month); } filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReflectanceToLuminanceImageFilterAuto.cxx000066400000000000000000000037321301006202600343620ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbReflectanceToLuminanceImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMultiChannelExtractROI.h" int otbReflectanceToLuminanceImageFilterAuto(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToLuminanceImageFilter ReflectanceToLuminanceImageFilterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); // Instantiating object ReflectanceToLuminanceImageFilterType::Pointer filterToLuminance = ReflectanceToLuminanceImageFilterType::New(); filterToLuminance->SetInput(reader->GetOutput()); writer->SetInput(filterToLuminance->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbReflectanceToLuminanceImageFilterNew.cxx000066400000000000000000000022731301006202600342020ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbReflectanceToLuminanceImageFilter.h" int otbReflectanceToLuminanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::ReflectanceToLuminanceImageFilter ReflectanceToLuminanceImageFilterType; // Instantiating object ReflectanceToLuminanceImageFilterType::Pointer filter = ReflectanceToLuminanceImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbReflectanceToSurfaceReflectanceImageFilterTest.cxx000066400000000000000000000134031301006202600361760ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbReflectanceToSurfaceReflectanceImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbOpticalImageMetadataInterfaceFactory.h" int otbReflectanceToSurfaceReflectanceImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::ReflectanceToSurfaceReflectanceImageFilter ReflectanceToSurfaceReflectanceImageFilterType; // Instantiating object ReflectanceToSurfaceReflectanceImageFilterType::Pointer filter = ReflectanceToSurfaceReflectanceImageFilterType::New(); return EXIT_SUCCESS; } int otbReflectanceToSurfaceReflectanceImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToSurfaceReflectanceImageFilter ReflectanceToSurfaceReflectanceImageFilterType; typedef otb::AtmosphericRadiativeTerms::DataVectorType DataVectorType; otb::AtmosphericRadiativeTerms::Pointer atmoRadTerms = otb::AtmosphericRadiativeTerms::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbChannel = reader->GetOutput()->GetNumberOfComponentsPerPixel(); DataVectorType intrinsic; DataVectorType albedo; DataVectorType gaseous; DataVectorType downTrans; DataVectorType upTrans; for (unsigned int j = 0; j < nbChannel; ++j) { intrinsic.push_back(static_cast(atof(argv[3 + j]))); albedo.push_back(static_cast(atof(argv[3 + j + nbChannel]))); gaseous.push_back(static_cast(atof(argv[3 + j + 2 * nbChannel]))); downTrans.push_back(static_cast(atof(argv[3 + j + 3 * nbChannel]))); upTrans.push_back(static_cast(atof(argv[3 + j + 4 * nbChannel]))); } atmoRadTerms->SetIntrinsicAtmosphericReflectances(intrinsic); atmoRadTerms->SetSphericalAlbedos(albedo); atmoRadTerms->SetTotalGaseousTransmissions(gaseous); atmoRadTerms->SetDownwardTransmittances(downTrans); atmoRadTerms->SetUpwardTransmittances(upTrans); // Instantiating object ReflectanceToSurfaceReflectanceImageFilterType::Pointer filter = ReflectanceToSurfaceReflectanceImageFilterType::New(); filter->SetAtmosphericRadiativeTerms(atmoRadTerms); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } //Check the correct generation of the atmospheric parameters int otbReflectanceToSurfaceReflectanceImageFilterTest2(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToSurfaceReflectanceImageFilter ReflectanceToSurfaceReflectanceImageFilterType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; AtmoCorrectionParametersType::Pointer paramAtmo = AtmoCorrectionParametersType::New(); paramAtmo->SetAtmosphericPressure(static_cast(atof(argv[3]))); paramAtmo->SetWaterVaporAmount(static_cast(atof(argv[4]))); paramAtmo->SetOzoneAmount(static_cast(atof(argv[5]))); paramAtmo->SetAerosolModel(static_cast(atoi(argv[6]))); paramAtmo->SetAerosolOptical(static_cast(atof(argv[7]))); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); // Instantiating object ReflectanceToSurfaceReflectanceImageFilterType::Pointer filter = ReflectanceToSurfaceReflectanceImageFilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetAtmoCorrectionParameters(paramAtmo); writer->SetInput(filter->GetOutput()); writer->Update(); /*filter->GenerateParameters(); otb::AtmosphericRadiativeTerms::Pointer terms = filter->GetAtmosphericRadiativeTerms(); std::ofstream fout (outputFileName); fout << terms; fout.close(); */ return EXIT_SUCCESS; } otbRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter.cxx000066400000000000000000000155311301006202600401600ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbReflectanceToSurfaceReflectanceImageFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include #include int otbRomaniaReflectanceToRomaniaSurfaceReflectanceImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const char * paramFile = argv[3]; std::vector wavelenghFiles; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ReflectanceToSurfaceReflectanceImageFilter ReflectanceToSurfaceReflectanceImageFilterType; typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::WavelengthSpectralBandType ValueType; //float typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; //std::vector AcquiCorrectionParametersPointerType paramAcqui = AcquiCorrectionParametersType::New(); AtmoCorrectionParametersPointerType paramAtmo = AtmoCorrectionParametersType::New(); FilterFunctionValuesType::Pointer functionValues; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); unsigned int nbChannel = reader->GetOutput()->GetNumberOfComponentsPerPixel(); for (unsigned int i = 0; i < nbChannel; ++i) { wavelenghFiles.push_back(argv[i + 4]); } ValueType val = 0.0025; // Correction parameters initialization double solarZenithalAngle(0.); double solarAzimutalAngle(0.); double viewingZenithalAngle(0.); double viewingAzimutalAngle(0.); unsigned int month(0); unsigned int day(0); double atmosphericPressure(0.); double waterVaporAmount(0.); double ozoneAmount(0.); double aerosolOptical(0.); std::ifstream fin; fin.open(paramFile); //Read input file parameters fin >> solarZenithalAngle; //asol; fin >> solarAzimutalAngle; //phi0; fin >> viewingZenithalAngle; //avis; fin >> viewingAzimutalAngle; //phiv; fin >> month; //month; fin >> day; //jday; fin >> atmosphericPressure; //pressure; fin >> waterVaporAmount; //uw; fin >> ozoneAmount; //uo3; unsigned int aer(0); fin >> aer; //iaer; AerosolModelType aerosolModel = static_cast(aer); fin >> aerosolOptical; //taer55; fin.close(); // Set atmospheric parameters /*param->SetSolarZenithalAngle(static_cast(solarZenithalAngle)); param->SetSolarAzimutalAngle(static_cast(solarAzimutalAngle)); param->SetViewingZenithalAngle(static_cast(viewingZenithalAngle)); param->SetViewingAzimutalAngle(static_cast(viewingAzimutalAngle)); param->SetMonth(month); param->SetDay(day); param->SetAtmosphericPressure(static_cast(atmosphericPressure)); param->SetWaterVaporAmount(static_cast(waterVaporAmount)); param->SetOzoneAmount(static_cast(ozoneAmount)); param->SetAerosolModel(aerosolModel); param->SetAerosolOptical(static_cast(aerosolOptical)); */ paramAcqui->SetSolarZenithalAngle(solarZenithalAngle); paramAcqui->SetSolarAzimutalAngle(solarAzimutalAngle); paramAcqui->SetViewingZenithalAngle(viewingZenithalAngle); paramAcqui->SetViewingAzimutalAngle(viewingAzimutalAngle); paramAcqui->SetMonth(month); paramAcqui->SetDay(day); paramAtmo->SetAtmosphericPressure(atmosphericPressure); paramAtmo->SetWaterVaporAmount(waterVaporAmount); paramAtmo->SetOzoneAmount(ozoneAmount); paramAtmo->SetAerosolModel(aerosolModel); paramAtmo->SetAerosolOptical(aerosolOptical); ValuesVectorType vect; for (unsigned int j = 0; j < nbChannel; ++j) { functionValues = FilterFunctionValuesType::New(); vect.clear(); // Filter function values initialization float minSpectralValue(0.); float maxSpectralValue(0.); float value(0.); std::ifstream fin2; //Read input file parameters fin2.open(wavelenghFiles[j]); fin2 >> minSpectralValue; //wlinf; fin2 >> maxSpectralValue; //wlsup; while (fin2.good()) { std::string line; std::getline(fin2, line); if (!line.empty()) { value = atof(line.c_str()); vect.push_back(value); } } fin2.close(); functionValues->SetFilterFunctionValues(vect); functionValues->SetMinSpectralValue(minSpectralValue); functionValues->SetMaxSpectralValue(maxSpectralValue); functionValues->SetUserStep(val); paramAcqui->SetWavelengthSpectralBandWithIndex(j, functionValues); } AtmosphericRadiativeTermsPointerType radiative = CorrectionParametersToRadiativeTermsType::Compute(paramAtmo,paramAcqui); // Instantiating object ReflectanceToSurfaceReflectanceImageFilterType::Pointer filter = ReflectanceToSurfaceReflectanceImageFilterType::New(); filter->SetAtmosphericRadiativeTerms(radiative); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbSIXSTraitsComputeAtmosphericParameters.cxx000066400000000000000000000165621301006202600346100ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSIXSTraits.h" #include #include #include #include int otbSIXSTraitsComputeAtmosphericParametersTest(int itkNotUsed(argc), char * argv[]) { const char * inname = argv[1]; const char * outname = argv[2]; typedef otb::AtmosphericCorrectionParameters AtmosphericCorrectionParametersType; // Instantiating object typedef otb::FilterFunctionValues FilterFunctionValuesType; FilterFunctionValuesType::Pointer functionValues = FilterFunctionValuesType::New(); FilterFunctionValuesType::ValuesVectorType vect; double SolarZenithalAngle(0.); double SolarAzimutalAngle(0.); double ViewingZenithalAngle(0.); double ViewingAzimutalAngle(0.); unsigned int Month(0); unsigned int Day(0); double AtmosphericPressure(0.); double WaterVaporAmount(0.); double OzoneAmount(0.); typedef AtmosphericCorrectionParametersType::AerosolModelType AerosolModelType; AerosolModelType AerosolModel; double AerosolOptical(0.); double AtmosphericReflectance(0.); double AtmosphericSphericalAlbedo(0.); double TotalGaseousTransmission(0.); double DownwardTransmittance(0.); double UpwardTransmittance(0.); double UpwardDiffuseTransmittance(0.); double UpwardDirectTransmittance(0.); double UpwardDiffuseTransmittanceForRayleigh(0.); double UpwardDiffuseTransmittanceForAerosol(0.); std::ifstream fin; std::ofstream fout; //Read input file parameters fin.open(inname); fin >> SolarZenithalAngle; //asol; fin >> SolarAzimutalAngle; //phi0; fin >> ViewingZenithalAngle; //avis; fin >> ViewingAzimutalAngle; //phiv; fin >> Month; //month; fin >> Day; //jday; fin >> AtmosphericPressure; //pressure; fin >> WaterVaporAmount; //uw; fin >> OzoneAmount; //uo3; unsigned int aer(0); fin >> aer; //iaer; AerosolModel = static_cast(aer); fin >> AerosolOptical; //taer55; float MinSpectralValue(0.); float MaxSpectralValue(0.); float value(0.); fin >> MinSpectralValue; //wlinf; fin >> MaxSpectralValue; //wlsup; std::string line; std::getline(fin, line); while (std::getline(fin, line)) { value = atof(line.c_str()); vect.push_back(value); } fin.close(); functionValues->SetFilterFunctionValues(vect); functionValues->SetMinSpectralValue(MinSpectralValue); functionValues->SetMaxSpectralValue(MaxSpectralValue); functionValues->SetUserStep(.0025); otb::SIXSTraits::ComputeAtmosphericParameters( SolarZenithalAngle, SolarAzimutalAngle, ViewingZenithalAngle, ViewingAzimutalAngle, Month, Day, AtmosphericPressure, WaterVaporAmount, OzoneAmount, AerosolModel, AerosolOptical, functionValues, AtmosphericReflectance, AtmosphericSphericalAlbedo, TotalGaseousTransmission, DownwardTransmittance, UpwardTransmittance, UpwardDiffuseTransmittance, UpwardDirectTransmittance, UpwardDiffuseTransmittanceForRayleigh, UpwardDiffuseTransmittanceForAerosol); fout.open(outname); fout << " ---------------------------------------------------------" << std::endl; fout << "Inputs values:" << std::setprecision(10) << std::endl; fout << " -----> SolarZenithalAngle : " << SolarZenithalAngle << std::endl; fout << " -----> SolarAzimutalAngle : " << SolarAzimutalAngle << std::endl; fout << " -----> ViewingZenithalAngle : " << ViewingZenithalAngle << std::endl; fout << " -----> ViewingAzimutalAngle : " << ViewingAzimutalAngle << std::endl; fout << " -----> Month : " << Month << std::endl; fout << " -----> Day : " << Day << std::endl; fout << " -----> AtmosphericPressure : " << AtmosphericPressure << std::endl; fout << " -----> WaterVaporAmount : " << WaterVaporAmount << std::endl; fout << " -----> OzoneAmount : " << OzoneAmount << std::endl; fout << " -----> AerosolModel : " << aer << std::endl; fout << " -----> AerosolOptical : " << AerosolOptical << std::endl; fout << " -----> MinSpectralValue : " << MinSpectralValue << std::endl; fout << " -----> MaxSpectralValue : " << MaxSpectralValue << std::endl; fout << " -----> UserStep : " << functionValues->GetUserStep() << std::endl; fout << " ---------------------------------------------------------" << std::endl; fout << "Outputs values:" << std::endl; fout << " -----> atmospheric reflectance : " << AtmosphericReflectance << std::endl; fout << " -----> atmospheric spherical albedo : " << AtmosphericSphericalAlbedo << std::endl; fout << " -----> total gaseous transmission : " << TotalGaseousTransmission << std::endl; fout << " -----> downward transmittance : " << DownwardTransmittance << std::endl; fout << " -----> upward transmittance : " << UpwardTransmittance << std::endl; fout << " -----> upward diffuse transmittance : " << UpwardDiffuseTransmittance << std::endl; fout << " -----> upward direct transmittance : " << UpwardDirectTransmittance << std::endl; fout << " -----> upward diffuse transmittance for rayleigh : " << UpwardDiffuseTransmittanceForRayleigh << std::endl; fout << " -----> upward diffuse transmittance for aerosols : " << UpwardDiffuseTransmittanceForAerosol << std::endl; fout << " -----> MinSpectralValue update: " << functionValues->GetMinSpectralValue() << std::endl; fout << " -----> MaxSpectralValue update : " << functionValues->GetMaxSpectralValue() << std::endl; fout << " ---------------------------------------------------------" << std::endl; fout << "Input wavelength band values [" << functionValues->GetFilterFunctionValues().size() << "]:" << std::endl; for (unsigned int i = 0; i < functionValues->GetFilterFunctionValues().size(); ++i) { fout << " " << functionValues->GetFilterFunctionValues()[i] << std::endl; } fout << " ---------------------------------------------------------" << std::endl; fout << "Output wavelength band values 6S [" << functionValues->GetFilterFunctionValues6S().size() << "]:" << std::endl; for (unsigned int i = 0; i < functionValues->GetFilterFunctionValues6S().size(); ++i) { fout << " " << functionValues->GetFilterFunctionValues6S()[i] << std::endl; } fout << std::endl; fout.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbSIXSTraitsTest.cxx000066400000000000000000000014071301006202600277370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSIXSTraits.h" int otbSIXSTraitsTest(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { otb::SIXSTraits *var(ITK_NULLPTR); var = new otb::SIXSTraits(); delete var; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbSpectralSensitivityReaderNew.cxx000066400000000000000000000015441301006202600327510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSpectralSensitivityReader.h" using namespace otb; int otbSpectralSensitivityReaderNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { SpectralSensitivityReader::Pointer spectSen = SpectralSensitivityReader::New(); std::cout << spectSen << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbSpectralSensitivityReaderTest.cxx000066400000000000000000000045751301006202600331460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSpectralSensitivityReader.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" using namespace otb; int otbSpectralSensitivityReaderNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { SpectralSensitivityReader::Pointer spectSen = SpectralSensitivityReader::New(); std::cout << spectSen << std::endl; return EXIT_SUCCESS; } int otbSpectralSensitivityReaderTest(int itkNotUsed(argc), char* argv[]) { const char * dataPath = argv[1]; const char * imageName = argv[2]; const char * output = argv[3]; typedef VectorImage ImageType; typedef ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageName); reader->UpdateOutputInformation(); SpectralSensitivityReader::Pointer spectSen = SpectralSensitivityReader::New(); spectSen->SetDataPath(dataPath); spectSen->SetImage(reader->GetOutput()); spectSen->Update(); std::ofstream fout(output); fout << spectSen << std::endl; fout.close(); return EXIT_SUCCESS; } int otbSpectralSensitivityReaderGenericTest(int itkNotUsed(argc), char* argv[]) { const char * sensitivityFileName = argv[1]; const char * imageName = argv[2]; const char * output = argv[3]; typedef VectorImage ImageType; typedef ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageName); reader->UpdateOutputInformation(); SpectralSensitivityReader::Pointer spectSen = SpectralSensitivityReader::New(); spectSen->SetFileName(sensitivityFileName); // std::cout << "test : " << "filemane " << spectSen->GetFileName() <SetImage(reader->GetOutput()); spectSen->Update(); std::ofstream fout(output); fout << spectSen << std::endl; fout.close(); return EXIT_SUCCESS; } otbSurfaceAdjacencyEffectCorrectionSchemeFilter.cxx000066400000000000000000000150401301006202600356730ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h" #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbAtmosphericCorrectionParameters.h" #include "otbAtmosphericRadiativeTerms.h" #include #include int otbSurfaceAdjacencyEffectCorrectionSchemeFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const char * paramFile = argv[5]; const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SurfaceAdjacencyEffectCorrectionSchemeFilter SurfaceAdjacencyEffectCorrectionSchemeFilterType; typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::WavelengthSpectralBandType ValueType; //float typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; //std::vector AcquiCorrectionParametersPointerType paramAcqui = AcquiCorrectionParametersType::New(); AtmoCorrectionParametersPointerType paramAtmo = AtmoCorrectionParametersType::New(); FilterFunctionValuesType::Pointer functionValues; // Instantiating object SurfaceAdjacencyEffectCorrectionSchemeFilterType::Pointer filter = SurfaceAdjacencyEffectCorrectionSchemeFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); std::vector wavelenghFiles; unsigned int nbChannel = reader->GetOutput()->GetNumberOfComponentsPerPixel(); for (unsigned int i = 0; i < nbChannel; ++i) { wavelenghFiles.push_back(argv[i + 6]); } ValueType val = 0.0025; // Correction parameters initialization double solarZenithalAngle(0.); double solarAzimutalAngle(0.); double viewingZenithalAngle(0.); double viewingAzimutalAngle(0.); unsigned int month(0); unsigned int day(0); double atmosphericPressure(0.); double waterVaporAmount(0.); double ozoneAmount(0.); double aerosolOptical(0.); std::ifstream fin; fin.open(paramFile); //Read input file parameters fin >> solarZenithalAngle; //asol; fin >> solarAzimutalAngle; //phi0; fin >> viewingZenithalAngle; //avis; fin >> viewingAzimutalAngle; //phiv; fin >> month; //month; fin >> day; //jday; fin >> atmosphericPressure; //pressure; fin >> waterVaporAmount; //uw; fin >> ozoneAmount; //uo3; unsigned int aer(0); fin >> aer; //iaer; AerosolModelType aerosolModel = static_cast(aer); fin >> aerosolOptical; //taer55; fin.close(); // Set atmospheric parameters paramAcqui->SetSolarZenithalAngle(solarZenithalAngle); paramAcqui->SetSolarAzimutalAngle(solarAzimutalAngle); paramAcqui->SetViewingZenithalAngle(viewingZenithalAngle); paramAcqui->SetViewingAzimutalAngle(viewingAzimutalAngle); paramAcqui->SetMonth(month); paramAcqui->SetDay(day); paramAtmo->SetAtmosphericPressure(atmosphericPressure); paramAtmo->SetWaterVaporAmount(waterVaporAmount); paramAtmo->SetOzoneAmount(ozoneAmount); paramAtmo->SetAerosolModel(aerosolModel); paramAtmo->SetAerosolOptical(aerosolOptical); ValuesVectorType vect; for (unsigned int j = 0; j < nbChannel; ++j) { functionValues = FilterFunctionValuesType::New(); vect.clear(); // Filter function values initialization float minSpectralValue(0.); float maxSpectralValue(0.); float value(0.); std::ifstream fin2; //Read input file parameters fin2.open(wavelenghFiles[j]); fin2 >> minSpectralValue; //wlinf; fin2 >> maxSpectralValue; //wlsup; std::string line; std::getline(fin2, line); while (std::getline(fin2, line) ) { value = atof(line.c_str()); vect.push_back(value); std::cout << "value " << value << std::endl; } std::cout << "vec size " << vect.size()<< std::endl; fin2.close(); functionValues->SetFilterFunctionValues(vect); functionValues->SetMinSpectralValue(minSpectralValue); functionValues->SetMaxSpectralValue(maxSpectralValue); functionValues->SetUserStep(val); paramAcqui->SetWavelengthSpectralBandWithIndex(j, functionValues); } AtmosphericRadiativeTermsPointerType radiative = CorrectionParametersToRadiativeTermsType::Compute(paramAtmo,paramAcqui); filter->SetAtmosphericRadiativeTerms(radiative); filter->SetWindowRadius(atoi(argv[3])); filter->SetPixelSpacingInKilometers(static_cast(atof(argv[4]))); filter->SetZenithalViewingAngle(paramAcqui->GetViewingZenithalAngle()); filter->SetInput(reader->GetOutput()); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbSurfaceAdjacencyEffectCorrectionSchemeFilterNew.cxx000066400000000000000000000024721301006202600363520ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h" #include "otbVectorImage.h" #include "otbImage.h" int otbSurfaceAdjacencyEffectCorrectionSchemeFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage InputImageType; typedef otb::SurfaceAdjacencyEffectCorrectionSchemeFilter SurfaceAdjacencyEffectCorrectionSchemeFilterType; // Instantiating object SurfaceAdjacencyEffectCorrectionSchemeFilterType::Pointer filter = SurfaceAdjacencyEffectCorrectionSchemeFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/OpticalCalibration/test/otbWavelengthSpectralBandsTest.cxx000066400000000000000000000017521301006202600325370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWavelengthSpectralBands.h" using namespace otb; int otbFilterFunctionValuesNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { FilterFunctionValues::Pointer spectSen = FilterFunctionValues::New(); return EXIT_SUCCESS; } int otbWavelengthSpectralBandsNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { WavelengthSpectralBands::Pointer spectSen = WavelengthSpectralBands::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/000077500000000000000000000000001301006202600217425ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/CMakeLists.txt000066400000000000000000000000551301006202600245020ustar00rootroot00000000000000project(OTBSARCalibration) otb_module_impl() OTB-release-5.8/Modules/Radiometry/SARCalibration/include/000077500000000000000000000000001301006202600233655ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarBrightnessFunction.h000066400000000000000000000132531301006202600305330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarBrightnessFunction_h #define otbSarBrightnessFunction_h #include "otbSarBrightnessFunctor.h" #include "otbSarParametricMapFunction.h" namespace otb { /** * \class SarBrightnessFunction * \brief Calculate the backscatter for the given pixel * * Calculate the brigthness value for the given pixel * * If called with a ContinuousIndex or Point, the calculation is performed * at the nearest neighbor. * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double ). * * \ingroup ImageFunctions * * \ingroup OTBSARCalibration */ template class ITK_EXPORT SarBrightnessFunction : public itk::ImageFunction::AbsType, TCoordRep> { public: /** Standard class typedefs. */ typedef SarBrightnessFunction Self; typedef itk::ImageFunction::AbsType, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(SarBrightnessFunction, itk::ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename Superclass::OutputType OutputType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Datatype used for the evaluation */ typedef double RealType; typedef otb::Functor::SarBrightnessFunctor FunctorType; typedef typename FunctorType::RealType FunctorRealType; typedef otb::SarParametricMapFunction ParametricFunctionType; typedef typename ParametricFunctionType::Pointer ParametricFunctionPointer; typedef typename ParametricFunctionType::ConstPointer ParametricFunctionConstPointer; /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Set the input image. * \warning this method caches BufferedRegion information. * If the BufferedRegion has changed, user must call * SetInputImage again to update cached values. */ void SetInputImage( const InputImageType * ptr ) ITK_OVERRIDE; /** Get/Set the Scale value */ itkSetMacro(Scale, FunctorRealType); itkGetMacro(Scale, FunctorRealType); /** Get/Set the Offset value */ itkSetObjectMacro(Noise, ParametricFunctionType); itkGetConstObjectMacro(Noise, ParametricFunctionType); itkGetObjectMacro(Noise, ParametricFunctionType); /** Get/Set the flag which indicate if we use the Offset value */ itkSetMacro(EnableNoise, bool); itkGetMacro(EnableNoise, bool); /** Get/Set the AntennaPatternNewGain value */ itkSetObjectMacro(AntennaPatternNewGain, ParametricFunctionType); itkGetConstObjectMacro(AntennaPatternNewGain, ParametricFunctionType); itkGetObjectMacro(AntennaPatternNewGain, ParametricFunctionType); /** Get/Set the AntennaPatternOldGain value */ itkSetObjectMacro(AntennaPatternOldGain, ParametricFunctionType); itkGetObjectMacro(AntennaPatternOldGain, ParametricFunctionType); itkGetConstObjectMacro(AntennaPatternOldGain, ParametricFunctionType); /** Get/Set the RangeSpreadLoss value */ itkSetObjectMacro(RangeSpreadLoss, ParametricFunctionType); itkGetConstObjectMacro(RangeSpreadLoss, ParametricFunctionType); itkGetObjectMacro(RangeSpreadLoss, ParametricFunctionType); protected: SarBrightnessFunction(); ~SarBrightnessFunction() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SarBrightnessFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FunctorRealType m_Scale; ParametricFunctionPointer m_Noise; bool m_EnableNoise; ParametricFunctionPointer m_AntennaPatternNewGain; ParametricFunctionPointer m_AntennaPatternOldGain; ParametricFunctionPointer m_RangeSpreadLoss; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbSarBrightnessFunction.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarBrightnessFunction.txx000066400000000000000000000102201301006202600311160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarBrightnessFunction_txx #define otbSarBrightnessFunction_txx #include "otbSarBrightnessFunction.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template SarBrightnessFunction ::SarBrightnessFunction(): m_Scale(1.0) { m_Noise = ParametricFunctionType::New(); m_AntennaPatternNewGain = ParametricFunctionType::New(); m_AntennaPatternOldGain = ParametricFunctionType::New(); m_RangeSpreadLoss = ParametricFunctionType::New(); m_Noise->SetConstantValue(0.0); m_EnableNoise = true; m_AntennaPatternNewGain->SetConstantValue(1.0); m_AntennaPatternOldGain->SetConstantValue(1.0); m_RangeSpreadLoss->SetConstantValue(1.0); } /** * Initialize by setting the input image */ template void SarBrightnessFunction ::SetInputImage( const InputImageType * ptr ) { Superclass::SetInputImage(ptr); m_Noise->SetInputImage(ptr); m_AntennaPatternNewGain->SetInputImage(ptr); m_AntennaPatternOldGain->SetInputImage(ptr); m_RangeSpreadLoss->SetInputImage(ptr); } /** * */ template void SarBrightnessFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); if (m_Noise) { os << indent << "Noise:\n"; m_Noise->Print(os, indent.GetNextIndent()); } if (m_AntennaPatternNewGain) { os << indent << "AntennaPatternNewGain:\n"; m_AntennaPatternNewGain->Print(os, indent.GetNextIndent()); } if (m_AntennaPatternOldGain) { os << indent << "AntennaPatternOldGain:\n"; m_AntennaPatternOldGain->Print(os, indent.GetNextIndent()); } if (m_RangeSpreadLoss) { os << indent << "RangeSpreadLoss:\n"; m_RangeSpreadLoss->Print(os, indent.GetNextIndent()); } } /** * */ template typename SarBrightnessFunction ::OutputType SarBrightnessFunction ::EvaluateAtIndex(const IndexType& index) const { RealType result; result = itk::NumericTraits::Zero; if (!this->GetInputImage()) { return (itk::NumericTraits::max()); } if (!this->IsInsideBuffer(index)) { return (itk::NumericTraits::max()); } FunctorRealType noise = itk::NumericTraits::Zero; FunctorRealType antennaPatternNewGain = itk::NumericTraits::Zero; FunctorRealType antennaPatternOldGain = itk::NumericTraits::Zero; FunctorRealType rangeSpreadLoss = itk::NumericTraits::Zero; if (m_EnableNoise) { noise = static_cast(m_Noise->EvaluateAtIndex(index)); } antennaPatternNewGain = static_cast(m_AntennaPatternNewGain->EvaluateAtIndex(index)); antennaPatternOldGain = static_cast(m_AntennaPatternOldGain->EvaluateAtIndex(index)); rangeSpreadLoss = static_cast(m_RangeSpreadLoss->EvaluateAtIndex(index)); FunctorType functor; if (m_EnableNoise) { functor.SetNoise(noise); } functor.SetScale(m_Scale); functor.SetAntennaPatternNewGain(antennaPatternNewGain); functor.SetAntennaPatternOldGain(antennaPatternOldGain); functor.SetRangeSpreadLoss(rangeSpreadLoss); const std::complex pVal = this->GetInputImage()->GetPixel(index); const RealType value = std::sqrt((pVal.real() * pVal.real()) + (pVal.imag()* pVal.imag())); result = functor(value); return static_cast(result); } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarBrightnessFunctor.h000066400000000000000000000060631301006202600303670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarBrightnessFunctor_h #define otbSarBrightnessFunctor_h #include "otbMath.h" #include "itkNumericTraits.h" namespace otb { namespace Functor { /** * \class SarBrightnessFunctor * \brief Compute the brightness value. * \f$ \beta^{0} = (scale * DN^{2} + offset) * OldGain / NewGain * RangeSpreadLoss \f$ * * * \ingroup OTBSARCalibration */ template class ITK_EXPORT SarBrightnessFunctor { public: typedef TInput InputType; typedef TOutput OutputType; typedef typename itk::NumericTraits::AbsType RealType; SarBrightnessFunctor() { m_Noise = 0.0; m_Scale = 1.0; m_AntennaPatternOldGain = 1.0; m_AntennaPatternNewGain = 1.0; m_RangeSpreadLoss = 1.0; }; ~SarBrightnessFunctor(){}; inline TOutput operator ()(const TInput& value) const { RealType digitalNumber = static_cast (vcl_abs(value)); RealType beta; beta = m_Scale * (digitalNumber * digitalNumber - m_Noise); beta *= m_AntennaPatternOldGain; beta /= m_AntennaPatternNewGain; beta *= m_RangeSpreadLoss; if(beta < 0.0) { beta = 0.0; } return static_cast(beta); } /** Set offset method */ void SetNoise(RealType value) { m_Noise = value; } /** Get offset method */ RealType GetNoise() const { return m_Noise; } /** Set scale method */ void SetScale(RealType value) { m_Scale = value; } /** Get scale method */ RealType GetScale() const { return m_Scale; } /** Set antennaPatternNewGain method */ void SetAntennaPatternNewGain(RealType value) { m_AntennaPatternNewGain = value; } /** Get antennaPatternNewGain method */ RealType GetAntennaPatternNewGain() const { return m_AntennaPatternNewGain; } /** Set antennaPatternOldGain method */ void SetAntennaPatternOldGain(RealType value) { m_AntennaPatternOldGain = value; } /** Get antennaPatternOldGain method */ RealType GetAntennaPatternOldGain() const { return m_AntennaPatternOldGain; } /** Set rangeSpreadLoss method */ void SetRangeSpreadLoss(RealType value) { m_RangeSpreadLoss = value; } /** Get scale method */ RealType GetRangeSpreadLoss() const { return m_RangeSpreadLoss; } private: RealType m_Noise; RealType m_Scale; RealType m_AntennaPatternNewGain; RealType m_AntennaPatternOldGain; RealType m_RangeSpreadLoss; }; } } #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarBrightnessToImageFilter.h000066400000000000000000000072751301006202600314500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarBrightnessToImageFilter_h #define otbSarBrightnessToImageFilter_h #include "otbSarBrightnessFunction.h" #include "otbFunctionToImageFilter.h" namespace otb { /** \class SarBrightnessToImageFilter * \brief Evaluates the SarBrightnessFunction onto a source image * * The function has to inherit from itkImageFunction * * \ingroup ImageFilters * * \ingroup OTBSARCalibration */ template class ITK_EXPORT SarBrightnessToImageFilter : public FunctionToImageFilter > { public: /** Standard class typedefs. */ typedef SarBrightnessToImageFilter Self; typedef FunctionToImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SarBrightnessToImageFilter, FunctionToImageFilter); /** Some typedefs. */ /** Image size typedef. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointer; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename Superclass::InputImagePixelType InputImagePixelType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointer OutputImagePointer; typedef typename Superclass::OutputImageRegionType OutputImageRegionType; typedef typename Superclass::OutputImagePixelType OutputImagePixelType; /** Type of function. */ typedef typename Superclass::FunctionType FunctionType; typedef typename Superclass::FunctionPointer FunctionPointer; typedef typename Superclass::FunctionValueType FunctionValueType; typedef typename Superclass::FunctionPositionType FunctionPositionType; typedef typename FunctionType::ParametricFunctionPointer ParametricFunctionPointer; typedef typename FunctionType::ParametricFunctionConstPointer ParametricFunctionConstPointer; typedef typename FunctionType::ParametricFunctionType ParametricFunctionType; void SetEnableNoise(bool inArg) { this->GetFunction()->SetEnableNoise(inArg); } protected: SarBrightnessToImageFilter(); ~SarBrightnessToImageFilter() ITK_OVERRIDE {} /** Update the function list and input parameters*/ void BeforeThreadedGenerateData() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SarBrightnessToImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSarBrightnessToImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarBrightnessToImageFilter.txx000066400000000000000000000064531301006202600320410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarBrightnessToImageFilter_txx #define otbSarBrightnessToImageFilter_txx #include "otbSarBrightnessToImageFilter.h" #include "otbSarImageMetadataInterfaceFactory.h" namespace otb { /** * Constructor */ template SarBrightnessToImageFilter ::SarBrightnessToImageFilter() { } template void SarBrightnessToImageFilter ::BeforeThreadedGenerateData() { // will SetInputImage on the function Superclass::BeforeThreadedGenerateData(); SarImageMetadataInterface::Pointer imageMetadataInterface = SarImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); FunctionPointer function = this->GetFunction(); function->SetScale(imageMetadataInterface->GetRadiometricCalibrationScale()); ParametricFunctionPointer noise = function->GetNoise(); noise->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationNoise()); noise->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationNoisePolynomialDegree()); noise->EvaluateParametricCoefficient(); ParametricFunctionPointer antennaPatternNewGain = function->GetAntennaPatternNewGain(); antennaPatternNewGain->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternNewGain()); antennaPatternNewGain->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree()); antennaPatternNewGain->EvaluateParametricCoefficient(); ParametricFunctionPointer antennaPatternOldGain = function->GetAntennaPatternOldGain(); antennaPatternOldGain->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternOldGain()); antennaPatternOldGain->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree()); antennaPatternOldGain->EvaluateParametricCoefficient(); ParametricFunctionPointer rangeSpreadLoss = function->GetRangeSpreadLoss(); rangeSpreadLoss->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationRangeSpreadLoss()); rangeSpreadLoss->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationRangeSpreadLossPolynomialDegree()); rangeSpreadLoss->EvaluateParametricCoefficient(); #if 0 this->Print(std::cout, id); #endif } template void SarBrightnessToImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); if (this->GetFunction()) { os << indent << "Function:\n"; this->GetFunction()->Print(os, indent.GetNextIndent()); } } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarParametricMapFunction.h000066400000000000000000000116431301006202600311510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarParametricMapFunction_h #define otbSarParametricMapFunction_h #include "itkImageFunction.h" #include "itkPointSet.h" #include "itkVariableSizeMatrix.h" namespace otb { /** * \class SarParametricMapFunction * \brief Evaluates a parametric bidimensionnal polynomial model from a PointSet * * \note This is an internal class used by the Sar calibration framework. * * \ingroup ImageFunctions * * \ingroup OTBSARCalibration */ template class ITK_EXPORT SarParametricMapFunction : public itk::ImageFunction::ScalarRealType, TCoordRep> { public: /** Standard class typedefs. */ typedef SarParametricMapFunction Self; typedef itk::ImageFunction::ScalarRealType, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(SarParametricMapFunction, itk::ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename Superclass::OutputType OutputType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); typedef itk::PointSet PointSetType; typedef typename PointSetType::Pointer PointSetPointer; typedef typename PointSetType::ConstPointer PointSetConstPointer; typedef typename PointSetType::PointType PointType; typedef typename PointSetType::PixelType PixelType; typedef itk::VariableSizeMatrix MatrixType; /** Datatype used for the evaluation */ typedef typename itk::NumericTraits::ScalarRealType RealType; /** Evaluate the function at specific positions */ RealType Evaluate(const PointType& point) const ITK_OVERRIDE; /** Evalulate the function at specified index */ RealType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE { PointType point; point[0] = static_cast(index[0]); point[1] = static_cast(index[1]); return this->Evaluate(point); } RealType EvaluateAtContinuousIndex( const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Get/Set the PointSet pointer*/ itkGetObjectMacro(PointSet, PointSetType); itkGetConstObjectMacro(PointSet, PointSetType); void SetPointSet(PointSetPointer val) { m_IsInitialize = false; m_PointSet = val; this->Modified(); } /** Get/Set the Coeff pointer*/ itkSetMacro(Coeff, MatrixType); itkGetMacro(Coeff, MatrixType); itkGetConstMacro(Coeff, MatrixType); /** Get/Set the Coeff pointer*/ itkGetConstReferenceMacro(IsInitialize, bool); /** Get/Set the PolynomalSize pointer*/ void SetPolynomalSize(const IndexType PolynomalSize); /** Evaluate parametric coefficient from pointset */ void EvaluateParametricCoefficient(); /** Set constante value for evaluation*/ void SetConstantValue(const RealType& value); protected: SarParametricMapFunction(); ~SarParametricMapFunction() ITK_OVERRIDE{} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: SarParametricMapFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented double Horner(PointType point) const; PointSetPointer m_PointSet; MatrixType m_Coeff; bool m_IsInitialize; double m_ProductWidth; /// the width of the complete product (read from metadata) double m_ProductHeight; /// the height of the complete product (read from metadata) }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSarParametricMapFunction.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarParametricMapFunction.txx000066400000000000000000000152751301006202600315520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarParametricMapFunction_txx #define otbSarParametricMapFunction_txx #include "otbSarParametricMapFunction.h" #include "itkNumericTraits.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "otbImageKeywordlist.h" #include namespace otb { /** * Constructor */ template SarParametricMapFunction ::SarParametricMapFunction() : m_PointSet(PointSetType::New()), m_IsInitialize(false), m_ProductWidth(0), m_ProductHeight(0) { m_Coeff.SetSize(1, 1); m_Coeff.Fill(0); } template void SarParametricMapFunction ::SetConstantValue(const RealType& value) { PointType p0; p0.Fill(0); m_ProductWidth = 1; m_ProductHeight = 1; m_IsInitialize = false; m_PointSet->Initialize(); m_PointSet->SetPoint(0, p0); m_PointSet->SetPointData(0, value); EvaluateParametricCoefficient(); this->Modified(); } template void SarParametricMapFunction ::SetPolynomalSize(const IndexType polynomalSize) { m_Coeff.SetSize(polynomalSize[1] + 1, polynomalSize[0] + 1); m_Coeff.Fill(0); this->Modified(); } template double SarParametricMapFunction ::Horner(PointType point) const { // Implementation of a Horner scheme evaluation for bivariate polynomial point[0] /= m_ProductWidth; point[1] /= m_ProductHeight; double result = 0; for (unsigned int ycoeff = m_Coeff.Rows(); ycoeff > 0; --ycoeff) { double intermediate = 0; for (unsigned int xcoeff = m_Coeff.Cols(); xcoeff > 0; --xcoeff) { //std::cout << "m_Coeff(" << ycoeff-1 << "," << xcoeff-1 << ") = " << m_Coeff(ycoeff-1, xcoeff-1) << std::endl; intermediate = intermediate * point[0] + m_Coeff(ycoeff-1, xcoeff-1); } result += vcl_pow( static_cast(point[1]), static_cast(ycoeff-1) ) * intermediate; } return result; } template void SarParametricMapFunction ::EvaluateParametricCoefficient() { PointSetPointer pointSet = this->GetPointSet(); PointType coef; PointType point; coef.Fill(0); point.Fill(0); typename PointSetType::PixelType pointValue; pointValue = itk::NumericTraits::Zero; if (pointSet->GetNumberOfPoints() == 0) { itkExceptionMacro(<< "PointSet must be set before evaluating the parametric coefficient (at least one value)"); } else if (pointSet->GetNumberOfPoints() == 1) { pointSet->GetPointData(0, &pointValue); m_Coeff(0, 0) = pointValue; } else { // Get input region for normalization of coordinates const itk::MetaDataDictionary& dict = this->GetInputImage()->GetMetaDataDictionary(); if (dict.HasKey(MetaDataKey::OSSIMKeywordlistKey)) { ImageKeywordlist imageKeywordlist; itk::ExposeMetaData(dict, MetaDataKey::OSSIMKeywordlistKey, imageKeywordlist); std::string nbLinesValue = imageKeywordlist.GetMetadataByKey("number_lines"); std::string nbSamplesValue = imageKeywordlist.GetMetadataByKey("number_samples"); // TODO: Don't use atof! m_ProductWidth = atof(nbSamplesValue.c_str()); m_ProductHeight = atof(nbLinesValue.c_str()); } else { m_ProductHeight = this->GetInputImage()->GetLargestPossibleRegion().GetSize()[0]; m_ProductWidth = this->GetInputImage()->GetLargestPossibleRegion().GetSize()[1]; } // Perform the plane least square estimation unsigned int nbRecords = pointSet->GetNumberOfPoints(); unsigned int nbCoef = m_Coeff.Rows() * m_Coeff.Cols(); vnl_matrix a(nbRecords, nbCoef); vnl_vector b(nbRecords), bestParams(nbCoef); a.fill(0); b.fill(0); bestParams.fill(0); // Fill the linear system for (unsigned int i = 0; i < nbRecords; ++i) { this->GetPointSet()->GetPoint(i, &point); this->GetPointSet()->GetPointData(i, &pointValue); b(i) = pointValue; //std::cout << "point = " << point << std::endl; //std::cout << "b(" << i << ") = " << pointValue << std::endl; for (unsigned int xcoeff = 0; xcoeff < m_Coeff.Cols(); ++xcoeff) { double xpart = vcl_pow( static_cast(point[0]) / m_ProductWidth, static_cast(xcoeff)); for (unsigned int ycoeff = 0; ycoeff < m_Coeff.Rows(); ++ycoeff) { double ypart = vcl_pow( static_cast(point[1]) / m_ProductHeight, static_cast(ycoeff)); a(i, xcoeff * m_Coeff.Rows() + ycoeff) = xpart * ypart; //std::cout << "a(" << i << "," << xcoeff * m_Coeff.Rows() + ycoeff << ") = " << xpart * ypart << std::endl; } } } // Solve linear system with SVD decomposition vnl_svd svd(a); bestParams = svd.solve(b); for (unsigned int xcoeff = 0; xcoeff < m_Coeff.Cols(); ++xcoeff) { for (unsigned int ycoeff = 0; ycoeff < m_Coeff.Rows(); ++ycoeff) { m_Coeff(ycoeff, xcoeff) = bestParams(xcoeff * m_Coeff.Rows() + ycoeff); //std::cout << "m_Coeff(" << ycoeff << "," << xcoeff << ") = " << m_Coeff(ycoeff, xcoeff) << std::endl; } } } m_IsInitialize = true; } /** * */ template typename SarParametricMapFunction ::RealType SarParametricMapFunction ::Evaluate(const PointType& point) const { RealType result = itk::NumericTraits::Zero; if (!m_IsInitialize) { itkExceptionMacro(<< "Must call EvaluateParametricCoefficient before evaluating"); } else if (m_Coeff.Rows() * m_Coeff.Cols() == 1) { result = m_Coeff(0, 0); } else { result = this->Horner(point); } return result; } /** * */ template void SarParametricMapFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); os << indent << "Polynom coefficients: " << m_Coeff << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarRadiometricCalibrationFunction.h000066400000000000000000000166051301006202600330410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarRadiometricCalibrationFunction_h #define otbSarRadiometricCalibrationFunction_h #include "otbSarParametricMapFunction.h" #include "otbSarCalibrationLookupData.h" #include "otbMath.h" namespace otb { /** * \class SarRadiometricCalibrationFunction * \brief Calculate the backscatter for the given pixel * * Calculate the backscatter for the given pixel * * If called with a ContinuousIndex or Point, the calculation is performed * at the nearest neighbor. * * This class is templated over the input image type and the * coordinate representation type (e.g. float or double ). * * \ingroup ImageFunctions * * \ingroup OTBSARCalibration */ template class ITK_EXPORT SarRadiometricCalibrationFunction : public itk::ImageFunction::AbsType, TCoordRep> { public: /** Standard class typedefs. */ typedef SarRadiometricCalibrationFunction Self; typedef itk::ImageFunction::AbsType, TCoordRep> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(SarRadiometricCalibrationFunction, itk::ImageFunction); /** Method for creation through the object factory. */ itkNewMacro(Self); /** InputImageType typedef support. */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename Superclass::OutputType OutputType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::ContinuousIndexType ContinuousIndexType; typedef typename Superclass::PointType PointType; itkStaticConstMacro(ImageDimension, unsigned int, InputImageType::ImageDimension); /** Datatype used for the evaluation */ typedef double RealType; // typedef otb::Functor::SarRadiometricCalibrationFunctor FunctorType; // typedef typename FunctorType::RealType FunctorRealType; typedef otb::SarParametricMapFunction ParametricFunctionType; typedef typename ParametricFunctionType::Pointer ParametricFunctionPointer; typedef typename ParametricFunctionType::ConstPointer ParametricFunctionConstPointer; /** Evalulate the function at specified index */ OutputType EvaluateAtIndex(const IndexType& index) const ITK_OVERRIDE; /** Evaluate the function at non-integer positions */ OutputType Evaluate(const PointType& point) const ITK_OVERRIDE { IndexType index; this->ConvertPointToNearestIndex(point, index); return this->EvaluateAtIndex(index); } OutputType EvaluateAtContinuousIndex(const ContinuousIndexType& cindex) const ITK_OVERRIDE { IndexType index; this->ConvertContinuousIndexToNearestIndex(cindex, index); return this->EvaluateAtIndex(index); } /** Set the input image. * \warning this method caches BufferedRegion information. * If the BufferedRegion has changed, user must call * SetInputImage again to update cached values. */ void SetInputImage( const InputImageType * ptr ) ITK_OVERRIDE; /** Get/Set the Scale value */ itkSetMacro(Scale, RealType); itkGetMacro(Scale, RealType); /** Get/Set the Noise value */ itkSetObjectMacro(Noise, ParametricFunctionType); itkGetConstObjectMacro(Noise, ParametricFunctionType); itkGetObjectMacro(Noise, ParametricFunctionType); /** Get/Set the flag which indicate if we use the Offset value */ itkSetMacro(EnableNoise, bool); itkGetMacro(EnableNoise, bool); /** Get/Set the AntennaPatternNewGain value */ itkSetObjectMacro(AntennaPatternNewGain, ParametricFunctionType); itkGetConstObjectMacro(AntennaPatternNewGain, ParametricFunctionType); itkGetObjectMacro(AntennaPatternNewGain, ParametricFunctionType); /** Get/Set the AntennaPatternOldGain value */ itkSetObjectMacro(AntennaPatternOldGain, ParametricFunctionType); itkGetObjectMacro(AntennaPatternOldGain, ParametricFunctionType); itkGetConstObjectMacro(AntennaPatternOldGain, ParametricFunctionType); /** Get/Set the IncidenceAngle value */ itkSetObjectMacro(IncidenceAngle, ParametricFunctionType); itkGetConstObjectMacro(IncidenceAngle, ParametricFunctionType); itkGetObjectMacro(IncidenceAngle, ParametricFunctionType); /** Get/Set the RangeSpreadLoss value */ itkSetObjectMacro(RangeSpreadLoss, ParametricFunctionType); itkGetConstObjectMacro(RangeSpreadLoss, ParametricFunctionType); itkGetObjectMacro(RangeSpreadLoss, ParametricFunctionType); /** Set the RescalingFactor value */ itkSetMacro(RescalingFactor, RealType); /** Get/Set flag to indicate if these are used */ itkSetMacro(ApplyAntennaPatternGain, bool); itkGetMacro(ApplyAntennaPatternGain, bool); itkSetMacro(ApplyIncidenceAngleCorrection, bool); itkGetMacro(ApplyIncidenceAngleCorrection, bool); itkSetMacro(ApplyRangeSpreadLossCorrection, bool); itkGetMacro(ApplyRangeSpreadLossCorrection, bool); itkSetMacro(ApplyLookupDataCorrection, bool); itkGetMacro(ApplyLookupDataCorrection, bool); itkSetMacro(ApplyRescalingFactor, bool); itkGetMacro(ApplyRescalingFactor, bool); typedef SarCalibrationLookupData::Pointer LookupDataPointer; /** Set SetCalibrationLookupData instance */ void SetCalibrationLookupData(LookupDataPointer lut) { m_Lut = lut; } protected: /** ctor */ SarRadiometricCalibrationFunction(); /** default, empty, virtual dtor */ ~SarRadiometricCalibrationFunction() ITK_OVERRIDE{} /** print method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Flags to indicate if these values needs to be applied in calibration*/ private: SarRadiometricCalibrationFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented RealType m_Scale; bool m_EnableNoise; RealType m_RescalingFactor; bool m_ApplyAntennaPatternGain; bool m_ApplyIncidenceAngleCorrection; bool m_ApplyRangeSpreadLossCorrection; bool m_ApplyLookupDataCorrection; bool m_ApplyRescalingFactor; ParametricFunctionPointer m_Noise; ParametricFunctionPointer m_AntennaPatternNewGain; ParametricFunctionPointer m_AntennaPatternOldGain; ParametricFunctionPointer m_IncidenceAngle; ParametricFunctionPointer m_RangeSpreadLoss; LookupDataPointer m_Lut; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION # include "otbSarRadiometricCalibrationFunction.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbSarRadiometricCalibrationFunction.txx000066400000000000000000000125211301006202600334260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarRadiometricCalibrationFunction_txx #define otbSarRadiometricCalibrationFunction_txx #include "otbSarRadiometricCalibrationFunction.h" #include "itkNumericTraits.h" namespace otb { /** * Constructor */ template SarRadiometricCalibrationFunction ::SarRadiometricCalibrationFunction() : m_Scale(1.0) , m_EnableNoise(false) , m_RescalingFactor(1.0) , m_ApplyAntennaPatternGain(true) , m_ApplyIncidenceAngleCorrection(true) , m_ApplyRangeSpreadLossCorrection(true) , m_ApplyLookupDataCorrection(false) , m_ApplyRescalingFactor(false) { /* initialize parametric functions */ m_Noise = ParametricFunctionType::New(); m_AntennaPatternNewGain = ParametricFunctionType::New(); m_AntennaPatternOldGain = ParametricFunctionType::New(); m_IncidenceAngle = ParametricFunctionType::New(); m_RangeSpreadLoss = ParametricFunctionType::New(); /* initialize default values in paramerticFunction instances */ m_Noise->SetConstantValue(0.0); m_AntennaPatternNewGain->SetConstantValue(1.0); m_AntennaPatternOldGain->SetConstantValue(1.0); m_IncidenceAngle->SetConstantValue(CONST_PI_2); m_RangeSpreadLoss->SetConstantValue(1.0); // m_Lut = 0; //new LookupTableBase(); } /** * Initialize by setting the input image */ template void SarRadiometricCalibrationFunction ::SetInputImage( const InputImageType * ptr ) { Superclass::SetInputImage(ptr); m_Noise->SetInputImage(ptr); m_IncidenceAngle->SetInputImage(ptr); m_AntennaPatternNewGain->SetInputImage(ptr); m_AntennaPatternOldGain->SetInputImage(ptr); m_RangeSpreadLoss->SetInputImage(ptr); } /** * Print */ template void SarRadiometricCalibrationFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { this->Superclass::PrintSelf(os, indent); } /* Function: EvaluateAtIndex. This computes the required values for each pixel * whose index is given in indexType argument. To convert index to point it uses * InputImage::TransformIndexToPhysicalPoint(). IncidenceAngle and similar are * computed based on this calculated point in SarParametricFunction */ template typename SarRadiometricCalibrationFunction ::OutputType SarRadiometricCalibrationFunction ::EvaluateAtIndex(const IndexType& index) const { if (!this->IsInsideBuffer(index)) { itkDebugMacro( << "ERROR with IsInsideBuffer"); return (itk::NumericTraits::max()); } /* convert index to point */ PointType point; if (m_ApplyAntennaPatternGain || m_ApplyIncidenceAngleCorrection || m_ApplyRangeSpreadLossCorrection) this->GetInputImage()->TransformIndexToPhysicalPoint( index, point); /** digitalNumber: * For complex pixel type, vcl_abs() returns the modulus. which is * sqrt((I*I) + (Q*Q)). Where I and Q are real and imaginary part of the * complex pixel. So to to get (I*I) + (Q*Q) in our calculation, the output * of vcl_abs() is squared. See below (digitalNumber * digitalNumber) where * digitalNumber is the output of vcl_abs() which is sqrt((I*I) + (Q*Q)). For * non-complex pixel types, vcl_abs() simply returns absolute value. */ const std::complex pVal = this->GetInputImage()->GetPixel(index); const RealType digitalNumber = std::sqrt((pVal.real() * pVal.real()) + (pVal.imag()* pVal.imag())); RealType sigma = m_Scale * digitalNumber * digitalNumber; /** subtract noise if enabled. */ if (m_EnableNoise) { sigma -= static_cast(m_Noise->Evaluate(point)); } /** Apply incidence angle correction if needed */ if (m_ApplyIncidenceAngleCorrection) { sigma *= vcl_sin(static_cast(m_IncidenceAngle->Evaluate(point))); } /** Apply old and new antenna pattern gain. */ if (m_ApplyAntennaPatternGain) { sigma *= static_cast(m_AntennaPatternNewGain->Evaluate(point)); sigma /= static_cast(m_AntennaPatternOldGain->Evaluate(point)); } /** Apply range spread loss if needed. */ if (m_ApplyRangeSpreadLossCorrection) { sigma *= static_cast(m_RangeSpreadLoss->Evaluate(point)); } /** Lookup value has effect on for some sensors which does not required the * above values (incidence angle, rangespreadloss etc.. */ if (m_ApplyLookupDataCorrection) { RealType lutVal = static_cast(m_Lut->GetValue(index[0], index[1])); sigma /= lutVal * lutVal; } /** rescaling factor has effect only with CosmoSkymed Products */ if (m_ApplyRescalingFactor) { sigma /= m_RescalingFactor; } if(sigma < 0.0) { sigma = 0.0; } return static_cast(sigma); } } // end namespace otb #endif otbSarRadiometricCalibrationToImageFilter.h000066400000000000000000000124721301006202600336660ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarRadiometricCalibrationToImageFilter_h #define otbSarRadiometricCalibrationToImageFilter_h #include "otbSarRadiometricCalibrationFunction.h" #include "otbFunctionToImageFilter.h" namespace otb { /** \class SarRadiometricCalibrationToImageFilter * \brief Evaluates the SarRadiometricCalibrationFunction onto a source image * The BeforeThreadedGenerateData create a SarImageMetadataInterface based on * input metadata dictionary. The nature of product(TerrSARX, Sentinel1, etc..) * are thus detected automatically from this. The filter then reads necessary * parameters required to perform SarCalibration in a generic way. * * BeforeThreadedGenerateData() instantiate a SarRadiometricCalibrationFunction * and pass the values taken from SarImageMetadataInterface instance to it. This * is where the actual computation of sigma (backscatter) occurs. * * Noise, Antenna pattern gain (old && new), range spread loss, incidence angle * data members used in this class are all instances of SarPrametricFunction * class. Each have a Evaluate() method and a special * EvaluateParametricCoefficient() which computes the actual value. * * The technical details and more discussion of SarCalibration can be found in jira * story #863. * * \see \c otb::SarParametricFunction * \see \c otb::SarCalibrationLookupBase * References (Retrieved on 08-Sept-2015) * Sentinel1 - https://sentinel.esa.int/web/sentinel/sentinel-1-sar-wiki/-/wiki/Sentinel%20One/Application+of+Radiometric+Calibration+LUT * Radarsat2 - http://gs.mdacorporation.com/products/sensor/radarsat2/RS2_Product_Description.pdf * * \ingroup ImageFilters * * \ingroup OTBSARCalibration */ template class ITK_EXPORT SarRadiometricCalibrationToImageFilter : public FunctionToImageFilter > { public: /** Standard class typedefs. */ typedef SarRadiometricCalibrationToImageFilter Self; typedef FunctionToImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SarRadiometricCalibrationToImageFilter, FunctionToImageFilter); /** Some typedefs. */ /** Image size typedef. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointer; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename Superclass::InputImagePixelType InputImagePixelType; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointer OutputImagePointer; typedef typename Superclass::OutputImageRegionType OutputImageRegionType; typedef typename Superclass::OutputImagePixelType OutputImagePixelType; /** Type of function. */ typedef typename Superclass::FunctionType FunctionType; typedef typename Superclass::FunctionPointer FunctionPointer; typedef typename Superclass::FunctionValueType FunctionValueType; typedef typename Superclass::FunctionPositionType FunctionPositionType; typedef typename FunctionType::ParametricFunctionPointer ParametricFunctionPointer; typedef typename FunctionType::ParametricFunctionConstPointer ParametricFunctionConstPointer; typedef typename FunctionType::ParametricFunctionType ParametricFunctionType; /** Enable/disable the noise flag in SarRadiometricCalibrationFunction */ void SetEnableNoise(bool inArg) { this->GetFunction()->SetEnableNoise(inArg); } itkSetMacro(LookupSelected, short); itkGetConstMacro(LookupSelected, short); protected: /** Default ctor */ SarRadiometricCalibrationToImageFilter(); /** Empty, default virtual dtor */ ~SarRadiometricCalibrationToImageFilter() ITK_OVERRIDE {} /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Update the function list and input parameters*/ void BeforeThreadedGenerateData() ITK_OVERRIDE; private: SarRadiometricCalibrationToImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented short m_LookupSelected; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSarRadiometricCalibrationToImageFilter.txx" #endif #endif otbSarRadiometricCalibrationToImageFilter.txx000066400000000000000000000153571301006202600342670ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSarRadiometricCalibrationToImageFilter_txx #define otbSarRadiometricCalibrationToImageFilter_txx #include "otbSarRadiometricCalibrationToImageFilter.h" #include "otbSarImageMetadataInterfaceFactory.h" #include "otbSarCalibrationLookupData.h" namespace otb { /** * Constructor */ template SarRadiometricCalibrationToImageFilter ::SarRadiometricCalibrationToImageFilter() : m_LookupSelected(0) { } template void SarRadiometricCalibrationToImageFilter ::GenerateOutputInformation( ) { Superclass::GenerateOutputInformation(); // Retrieving input/output pointers InputImagePointer inputPtr = this->GetInput(); if (inputPtr.IsNull()) { itkExceptionMacro(<< "At least one input is missing." << " Input is missing :" << inputPtr.GetPointer() ) } OutputImagePointer outputPtr = this->GetOutput(); if (outputPtr.IsNull()) { itkExceptionMacro(<< "At least one output is missing." << " Output is missing :" << outputPtr.GetPointer() ) } } template void SarRadiometricCalibrationToImageFilter ::BeforeThreadedGenerateData() { // will SetInputImage on the function Superclass::BeforeThreadedGenerateData(); /** cretate a SarImageMetadataInterface instance from * GetMetaDataDictionary(). This will return the appropriate IMI depending on * the Sensor information & co available in GetMetaDataDictionary() */ SarImageMetadataInterface::Pointer imageMetadataInterface = SarImageMetadataInterfaceFactory::CreateIMI( this->GetInput()->GetMetaDataDictionary()); /** Get the SarRadiometricCalibrationFunction function instance. */ FunctionPointer function = this->GetFunction(); /** check if there is a calibration lookupdata is available with the * product. eg. Sentinel1. This means * A. The computation of the backscatter is based on this lookup value which * depends on the given product.* * B. The other value such as antenna pattern gain, rangespread loss, incidence * angle has no effect in calibration */ bool apply = imageMetadataInterface->HasCalibrationLookupDataFlag(); /* Below lines will toggle the necessary flags which can help skip some * computation. For example, if there is lookup value and ofcourse antenna * pattern gain is not required. Even if we try to compute the value with * SarParametricFunction we get 1. This is the safe side. But as we are so sure * we skip all those calls to EvaluateParametricCoefficient and also the * Evaluate(). For the function the value is 1 by default. */ function->SetApplyAntennaPatternGain(!apply); function->SetApplyIncidenceAngleCorrection(!apply); function->SetApplyRangeSpreadLossCorrection(!apply); function->SetApplyRescalingFactor(!apply); function->SetApplyLookupDataCorrection(apply); function->SetScale(imageMetadataInterface->GetRadiometricCalibrationScale()); /* Compute noise if enabled */ if( function->GetEnableNoise()) { ParametricFunctionPointer noise; noise = function->GetNoise(); noise->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationNoise()); noise->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationNoisePolynomialDegree()); noise->EvaluateParametricCoefficient(); } /* Compute old and new antenna pattern gain */ if(function->GetApplyAntennaPatternGain()) { ParametricFunctionPointer antennaPatternNewGain; antennaPatternNewGain = function->GetAntennaPatternNewGain(); antennaPatternNewGain->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternNewGain()); antennaPatternNewGain->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternNewGainPolynomialDegree()); antennaPatternNewGain->EvaluateParametricCoefficient(); ParametricFunctionPointer antennaPatternOldGain; antennaPatternOldGain = function->GetAntennaPatternOldGain(); antennaPatternOldGain->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternOldGain()); antennaPatternOldGain->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationAntennaPatternOldGainPolynomialDegree()); antennaPatternOldGain->EvaluateParametricCoefficient(); } /* Compute incidence angle */ if (function->GetApplyIncidenceAngleCorrection()) { ParametricFunctionPointer incidenceAngle; incidenceAngle = function->GetIncidenceAngle(); incidenceAngle->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationIncidenceAngle()); incidenceAngle->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationIncidenceAnglePolynomialDegree()); incidenceAngle->EvaluateParametricCoefficient(); } /* Compute Range spread Loss */ if (function->GetApplyRangeSpreadLossCorrection()) { ParametricFunctionPointer rangeSpreadLoss; rangeSpreadLoss = function->GetRangeSpreadLoss(); rangeSpreadLoss->SetPointSet(imageMetadataInterface->GetRadiometricCalibrationRangeSpreadLoss()); rangeSpreadLoss->SetPolynomalSize(imageMetadataInterface->GetRadiometricCalibrationRangeSpreadLossPolynomialDegree()); rangeSpreadLoss->EvaluateParametricCoefficient(); } /** Get the lookupdata instance. unlike the all the above this is not a * parametricFunction instance. But rather an internal class in IMI called * SarCalibrationLookupData. * *NOTE: As the computation of lookup data for sensors is not universal. One must *provide a sub-class. See Also: otbSentinel1ImageMetadataInterface, otbTerraSarImageMetadataInterface, *otbRadarsat2ImageMetadataInterface */ if (function->GetApplyLookupDataCorrection()) { function->SetCalibrationLookupData(imageMetadataInterface->GetCalibrationLookupData(this->GetLookupSelected())); } /** This was introduced for cosmoskymed which required a rescaling factor */ if (function->GetApplyRescalingFactor()) { function->SetRescalingFactor(imageMetadataInterface->GetRescalingFactor()); } } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbTerraSarBrightnessFunctor.h000066400000000000000000000051141301006202600313610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTerraSarBrightnessFunctor_h #define otbTerraSarBrightnessFunctor_h #include "otbMath.h" #include namespace otb { namespace Functor { /** * \class TerraSarBrightnessFunctor * \brief Compute beta naught coefficient. * * This functor is intended to be used by the * TerrasarBrightnessImageFilter. * * For more information on Terrasar calibration, * please refer to the * documentation of this filter. * * \sa TerraSarBrightnessImageFilter * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBSARCalibration */ template class TerraSarBrightnessFunctor { public: TerraSarBrightnessFunctor(); virtual ~TerraSarBrightnessFunctor() {} /** Accessors */ void SetCalibrationFactor(double val) { m_CalibrationFactor = val; } double GetCalibrationFactor() { return m_CalibrationFactor; } /** Set results in decibels */ void SetResultsInDecibels(bool db) { m_ResultsInDecibels = db; } /** Get the value of the flag */ bool GetResultsInDecibels() { return m_ResultsInDecibels; } /** Set Default value for null or negative pixel beta */ void SetDefaultValue(double db) { m_DefaultValue = db; } /** Set Default value for null or negative pixel beta */ bool GetDefaultValue() { return m_DefaultValue; } /** We assume that the input pixel is a scalar -> modulus image */ inline TOutput operator ()(const TInput& inPix); /** We assume that the input pixel is a complex -> complex image */ inline std::complex operator ()(const std::complex& inPix); private: /** Calibration Factor */ double m_CalibrationFactor; /** Shall we compute results in decibels ? */ bool m_ResultsInDecibels; /** Default value for null or negative pixel beta */ double m_DefaultValue; }; } // end namespace functor } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTerraSarBrightnessFunctor.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbTerraSarBrightnessFunctor.txx000066400000000000000000000041301301006202600317520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTerraSarBrightnessFunctor_txx #define otbTerraSarBrightnessFunctor_txx #include "otbTerraSarBrightnessFunctor.h" #include "itkNumericTraits.h" namespace otb { namespace Functor { template TerraSarBrightnessFunctor ::TerraSarBrightnessFunctor() { m_CalibrationFactor = itk::NumericTraits::Zero; m_ResultsInDecibels = false; m_DefaultValue = 0.00001; // Default value is 10^-5 } template TOutput TerraSarBrightnessFunctor ::operator() (const TInput &inPix) { // Formula: Beta^0 = Ks * |DN|^2 // First, square the input pixel double squareInPix = vcl_pow(static_cast(inPix), 2.); // Then apply the calibration factor double beta = m_CalibrationFactor * squareInPix; if (beta <= 0) beta = m_DefaultValue; // Results in decibels case if (m_ResultsInDecibels) { beta = 10 * vcl_log10(beta); } return static_cast(beta); } template std::complex TerraSarBrightnessFunctor ::operator() (const std::complex &inPix) { // First, extract modulus and phase double modulus = vcl_sqrt(inPix.real() * inPix.real() + inPix.imag() * inPix.imag()); double phase = vcl_atan2(inPix.imag(), inPix.real()); // Then, calibrate the modulus double beta = this->operator() (modulus); // Last, put back the phase std::complex out(std::polar(beta, phase)); return out; } } // namespace Functor } // namespace otb #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbTerraSarBrightnessImageFilter.h000066400000000000000000000124301301006202600321300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTerraSarBrightnessImageFilter_h #define otbTerraSarBrightnessImageFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkMetaDataDictionary.h" #include "otbTerraSarBrightnessFunctor.h" namespace otb { /** \class TerraSarBrightnessImageFilter * \brief Calculates the brightness of TerraSar sensor images. * * Implementation of the brightness algorithm has been made following * Infoterra documentation "Radiometric Calibration of TerraSAR-X * Data". * * This filter computes the beta naught (\f$ \beta^{0} \f$) using the following formula: * \f[\beta^{0} = k_{s} \cdot |DN|^{2} \f] * * Where \f$ k_{s} \f$ is the calibration factor, which is imported * from the input image metadata, even if one can set different values * using the proper accessors. * * Results can be obtained either in linear or logarithmic scale * (decibels), using the ResultsInDecibels flag. * * This filter works with either real or complex image. In the case of * the complex images (SLC products for instance), modulus and phase * are extracted, sigma naught is computed from the modulus and the * phase is set back to the result. * * For implementation details, consider reading the code * TerraSarBrightnessFunctor. * * \sa TerraSarBrightnessFunctor * \sa TerraSarBrightnessImageFilter * * \ingroup Streamed * \ingroup Multithreaded * \ingroup Radiometry * * \ingroup OTBSARCalibration */ template class ITK_EXPORT TerraSarBrightnessImageFilter : public itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, typename Functor::TerraSarBrightnessFunctor< typename itk::NumericTraits::ValueType, typename itk::NumericTraits::ValueType> > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename itk::NumericTraits::ValueType InputValueType; typedef typename itk::NumericTraits::ValueType OutputValueType; typedef typename Functor::TerraSarBrightnessFunctor FunctorType; typedef itk::MetaDataDictionary MetaDataDictionaryType; /** "typedef" for standard classes. */ typedef TerraSarBrightnessImageFilter Self; typedef itk::UnaryFunctorImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(TerraSarBrightnessImageFilter, itk::UnaryFunctorImageFilter); /** Set the calibration factor*/ void SetCalibrationFactor(double pCalibrationFactor) { this->GetFunctor().SetCalibrationFactor(pCalibrationFactor); this->Modified(); } /** Get the calibration factor */ double GetCalibrationFactor() { return this->GetFunctor().GetCalibrationFactor(); } /** Set the ResultsInDecibels flag */ void SetResultsInDecibels(bool db) { this->GetFunctor().SetResultsInDecibels(db); this->Modified(); } /** Get the ResultsInDecibels flag */ bool GetResultsInDecibels() { return this->GetFunctor().GetResultsInDecibels(); } /** Set the default value (replacing negative beta) */ void SetDefaultValue(double value) { this->GetFunctor().SetResultsInDecibels(value); this->Modified(); } double GetDefaultValue() { return this->GetFunctor().SetResultsInDecibels(); } protected: /** Constructor */ TerraSarBrightnessImageFilter(){}; /** Destructor */ ~TerraSarBrightnessImageFilter() ITK_OVERRIDE {} /** Initialize the functor vector */ void BeforeThreadedGenerateData() ITK_OVERRIDE; private: TerraSarBrightnessImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbTerraSarBrightnessImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/include/otbTerraSarBrightnessImageFilter.txx000066400000000000000000000031401301006202600325220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbTerraSarBrightnessImageFilter_txx #define otbTerraSarBrightnessImageFilter_txx #include "otbTerraSarBrightnessImageFilter.h" #include "otbTerraSarImageMetadataInterface.h" namespace otb { template void TerraSarBrightnessImageFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); // Load metada TerraSarImageMetadataInterface::Pointer lImageMetadata = otb::TerraSarImageMetadataInterface::New(); lImageMetadata->SetMetaDataDictionary(this->GetInput()->GetMetaDataDictionary()); bool mdIsAvailable = lImageMetadata->CanRead(); // If the user doesn't set it AND the metadata is available, set calFactor using image metadata if (this->GetCalibrationFactor() == itk::NumericTraits::Zero) { if (mdIsAvailable) { this->SetCalibrationFactor(lImageMetadata->GetCalibrationFactor()); } else { itkExceptionMacro(<< "Invalid input image. Only TerraSar images are supproted"); } } } } #endif OTB-release-5.8/Modules/Radiometry/SARCalibration/otb-module.cmake000066400000000000000000000006001301006202600250070ustar00rootroot00000000000000set(DOCUMENTATION "This module contains tools related to SAR calibration (classes to compute the backscatter or the brigthness of a given pixel and so on).") otb_module(OTBSARCalibration DEPENDS OTBCommon OTBITK OTBMetadata OTBOSSIMAdapters TEST_DEPENDS OTBImageBase OTBImageIO OTBStatistics OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Radiometry/SARCalibration/test/000077500000000000000000000000001301006202600227215ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/CMakeLists.txt000066400000000000000000000314231301006202600254640ustar00rootroot00000000000000otb_module_test() set(OTBSARCalibrationTests otbSARCalibrationTestDriver.cxx otbSarBrightnessFunction.cxx otbSarBrightnessToImageFilterTestWithoutNoise.cxx otbTerraSarBrightnessImageFilterTest.cxx otbSarRadiometricCalibrationToImageFilterWithRealPixelTest.cxx otbTerraSarBrightnessImageFilterNew.cxx otbSarParametricMapFunctionToImageFilter.cxx otbSarRadiometricCalibrationToImageFilterWithExtractROIBeforeTest.cxx otbSarRadiometricCalibrationToImageFilterWithComplexPixelTestWithoutNoise.cxx otbSarBrightnessFunctorWithoutNoise.cxx otbTerraSarBrightnessFunctor.cxx otbSarBrightnessToImageWithComplexPixelFilterTest.cxx otbSarParametricMapFunctionTest.cxx otbSarRadiometricCalibrationToImageFilterCompareTest.cxx otbSarBrightnessFunctor.cxx otbSarBrightnessFunctionWithoutNoise.cxx otbSarRadiometricCalibrationFunction.cxx otbSarRadiometricCalibrationFunctionWithoutNoise.cxx otbTerraSarBrightnessImageComplexFilterTest.cxx otbSarRadiometricCalibrationToImageFilterWithComplexPixelTest.cxx otbSarBrightnessToImageFilterTest.cxx ) add_executable(otbSARCalibrationTestDriver ${OTBSARCalibrationTests}) target_link_libraries(otbSARCalibrationTestDriver ${OTBSARCalibration-Test_LIBRARIES}) otb_module_target_label(otbSARCalibrationTestDriver) # Tests Declaration otb_add_test(NAME raTvSarBrightnessFunction COMMAND otbSARCalibrationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/raTvSarBrightnessFunctionOutputAscii.txt ${TEMP}/raTvSarBrightnessFunctionOutputAsciiWithNoise.txt otbSarBrightnessFunction ${INPUTDATA}/scene.png ${TEMP}/raTvSarBrightnessFunctionOutputAsciiWithNoise.txt ) otb_add_test(NAME raTvSarBrightnessToImageFilterWithoutNoise COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarBrightnessToImageFilter_TSX_PANGKALANBUUN_HH_WN.tif ${TEMP}/raTvSarBrightnessToImageFilter_TSX_PANGKALANBUUN_HH_WN.tif otbSarBrightnessToImageFilterTestWithoutNoise LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} ${TEMP}/raTvSarBrightnessToImageFilter_TSX_PANGKALANBUUN_HH_WN.tif 1000 1000 250 250 # Extract ) #otb_add_test(NAME raTvTerraSarBrightnessImageFilterUPSALA COMMAND otbSARCalibrationTestDriver #--compare-image ${EPSILON_12} #${BASELINE}/raTvTerraSarBrightnessImageFilter_UPSALA.tif #${TEMP}/raTvTerraSarBrightnessImageFilter_UPSALA.tif #otbTerraSarBrightnessImageFilterTest #LARGEINPUT{TERRASARX/UPSALA_GLACIER/TSX1_SAR__MGD/IMAGEDATA/IMAGE_HH_SRA_strip_012.tif} #${TEMP}/raTvTerraSarBrightnessImageFilter_UPSALA.tif #1 # use metadata #0 # results in linear scale #2000 2000 250 250 # Extract #) otb_add_test(NAME raTvTerraSarBrightnessImageFilterTest COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvTerraSarBrightnessImageFilterTest.tif ${TEMP}/raTvTerraSarBrightnessImageFilterTest.tif otbTerraSarBrightnessImageFilterTest ${INPUTDATA}/ExtractIMAGE_HH_SRA_strip_012.tif ${TEMP}/raTvTerraSarBrightnessImageFilterTest.tif 0 # don't use metadata 0 # results in linear scale ) otb_add_test(NAME raTvSarRadiometricCalibrationToImageWithRealPixelFilter_TSX_PANGKALANBUUN COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarRadiometricCalibrationToImageFilter_TSX_PANGKALANBUUN_HH.tif ${TEMP}/raTvSarRadiometricCalibrationToImageFilterRealPixel_TSX_PANGKALANBUUN_HH.tif otbSarRadiometricCalibrationToImageFilterWithRealPixelTest LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} ${TEMP}/raTvSarRadiometricCalibrationToImageFilterRealPixel_TSX_PANGKALANBUUN_HH.tif 1000 1000 250 250 # Extract ) #otb_add_test(NAME raTvSarRadiometricCalibrationToImageWithRealPixelFilter_TSX_UPSALA COMMAND otbSARCalibrationTestDriver #--compare-image ${EPSILON_12} #${BASELINE}/raTvSarRadiometricCalibrationToImageFilter_TSX_UPSALA.tif #${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_UPSALA.tif #otbSarRadiometricCalibrationToImageFilterWithRealPixelTest #LARGEINPUT{TERRASARX/UPSALA_GLACIER/TSX1_SAR__MGD/IMAGEDATA/IMAGE_HH_SRA_strip_012.tif} #${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_UPSALA.tif #2000 2000 250 250 # Extract #) otb_add_test(NAME raTuTerraSarBrightnessImageFilterNew COMMAND otbSARCalibrationTestDriver otbTerraSarBrightnessImageFilterNew ) otb_add_test(NAME raTvSarParametricMapFunctionToImageFilter COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarParametricMapFunctionToImageFilter.tif ${TEMP}/raTvSarParametricMapFunctionToImageFilter.tif otbSarParametricMapFunctionToImageFilter ${TEMP}/raTvSarParametricMapFunctionToImageFilter.tif 100 200 # image size ) otb_add_test(NAME raTvSarRadiometricCalibrationToImagePixelFilterWithExtractROIBefore_TSX_PANGKALANBUUN COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarRadiometricCalibrationToImageFilterWithExtractROIBefore_TSX_PANGKALANBUUN_HH.tif ${TEMP}/raTvSarRadiometricCalibrationToImageFilterWithExtractROIBefore_TSX_PANGKALANBUUN_HH.tif otbSarRadiometricCalibrationToImageFilterWithExtractROIBeforeTest LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} ${TEMP}/raTvSarRadiometricCalibrationToImageFilterWithExtractROIBefore_TSX_PANGKALANBUUN_HH.tif 1000 1000 250 250 # Extract ) otb_add_test(NAME raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_TSX_PANGKALANBUUN COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarRadiometricCalibrationToImageFilter_TSX_PANGKALANBUUN_HH_WN.tif ${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_PANGKALANBUUN_HH_WN.tif otbSarRadiometricCalibrationToImageFilterWithComplexPixelTestWithoutNoise LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} ${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_PANGKALANBUUN_HH_WN.tif 1000 1000 250 250 # Extract ) #Sentinel-1 L1, SLC otb_add_test(NAME raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_SENTINEL1 COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_SENTINEL1_VV.tif ${TEMP}/raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_SENTINEL1_VV.tif otbSarRadiometricCalibrationToImageFilterWithComplexPixelTestWithoutNoise LARGEINPUT{SENTINEL1/S1A_S6_SLC__1SSV_20150619T195043/measurement/s1a-s6-slc-vv-20150619t195043-20150619t195101-006447-00887d-001.tiff} ${TEMP}/raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_SENTINEL1_VV.tif 1100 1900 450 450 # Extract ) #Radarsat2 otb_add_test(NAME raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_RADARSAT2 COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_6} ${BASELINE}/raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_RADARSAT2_HV.tif ${TEMP}/raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_RADARSAT2_HV.tif otbSarRadiometricCalibrationToImageFilterWithComplexPixelTestWithoutNoise LARGEINPUT{RADARSAT2/ALTONA/Fine_Quad-Pol_Dataset/PK6621_DK406_FQ9_20080405_124900_HH_VV_HV_VH_SLC_Altona/imagery_HV.tif} ${TEMP}/raTvSarRadiometricCalibrationToImageWithComplexPixelFilterWithoutNoise_RADARSAT2_HV.tif 11 11 650 750 # Extract ) otb_add_test(NAME raTuSarBrightnessFunctorWithoutNoise COMMAND otbSARCalibrationTestDriver otbSarBrightnessFunctorWithoutNoise ) otb_add_test(NAME raTvTerraSarBrightnessFunctor COMMAND otbSARCalibrationTestDriver --compare-ascii ${EPSILON_12} ${BASELINE_FILES}/raTvTerraSarBrightnessImageFunctor.txt ${TEMP}/raTvTerraSarBrightnessImageFunctor.txt otbTerraSarBrightnessFunctor 12 # real pixel 12 # complex real part pixel 0 # complex imaginary part pixel 1 # calFactor ${TEMP}/raTvTerraSarBrightnessImageFunctor.txt ) otb_add_test(NAME raTvSarBrightnessToImageWithComplexPixelFilter COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarBrightnessToImageFilter_TSX_PANGKALANBUUN_HH.tif ${TEMP}/raTvSarBrightnessToImageFilterComplexPixel_TSX_PANGKALANBUUN_HH.tif otbSarBrightnessToImageWithComplexPixelFilterTest LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} ${TEMP}/raTvSarBrightnessToImageFilterComplexPixel_TSX_PANGKALANBUUN_HH.tif 1000 1000 250 250 # Extract ) otb_add_test(NAME raTvSarParametricMapFunction COMMAND otbSARCalibrationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/raTvSarParametricMapFunctionOutputAscii.txt ${TEMP}/raTvSarParametricMapFunctionOutputAscii.txt otbSarParametricMapFunctionTest ${INPUTDATA}/scene.png ${TEMP}/raTvSarParametricMapFunctionOutputAscii.txt ) otb_add_test(NAME raTvSarRadiometricCalibrationToImageCompareFilter_TSX_PANGKALANBUUN COMMAND otbSARCalibrationTestDriver otbSarRadiometricCalibrationToImageFilterCompareTest LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} 1000 1000 250 250 # Extract ) otb_add_test(NAME raTuSarBrightnessFunctor COMMAND otbSARCalibrationTestDriver otbSarBrightnessFunctor ) otb_add_test(NAME raTvSarBrightnessFunctionWithoutNoise COMMAND otbSARCalibrationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/raTvSarBrightnessFunctionOutputAscii.txt ${TEMP}/raTvSarBrightnessFunctionOutputAsciiWithoutNoise.txt otbSarBrightnessFunctionWithoutNoise ${INPUTDATA}/scene.png ${TEMP}/raTvSarBrightnessFunctionOutputAsciiWithoutNoise.txt ) otb_add_test(NAME raTvSarRadiometricCalibrationFunction COMMAND otbSARCalibrationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/raTvSarRadiometricCalibrationFunctionOutputAscii.txt ${TEMP}/raTvSarRadiometricCalibrationFunctionOutputAsciiWithNoise.txt otbSarRadiometricCalibrationFunction ${INPUTDATA}/scene.png ${TEMP}/raTvSarRadiometricCalibrationFunctionOutputAsciiWithNoise.txt ) otb_add_test(NAME raTvSarRadiometricCalibrationFunctionWithoutNoise COMMAND otbSARCalibrationTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/raTvSarRadiometricCalibrationFunctionOutputAscii.txt ${TEMP}/raTvSarRadiometricCalibrationFunctionOutputAsciiWithoutNoise.txt otbSarRadiometricCalibrationFunctionWithoutNoise ${INPUTDATA}/scene.png ${TEMP}/raTvSarRadiometricCalibrationFunctionOutputAsciiWithoutNoise.txt ) #otb_add_test(NAME raTvTerraSarBrightnessImageComplexFilterTORONTO COMMAND otbSARCalibrationTestDriver #--compare-image ${EPSILON_12} #${BASELINE}/raTvTerraSarBrightnessComplexImageFilter_TORONTO.tif #${TEMP}/raTvTerraSarBrightnessImageComplexFilter_TORONTO.tif #otbTerraSarBrightnessImageComplexFilterTest #LARGEINPUT{TERRASARX/TORONTO/TSX1_SAR__SSC/IMAGEDATA/IMAGE_HH_SRA_spot_074.cos} #${TEMP}/raTvTerraSarBrightnessImageComplexFilter_TORONTO.tif #1 # use metadata #0 # results in linear scale #2000 2000 250 250 # Extract #) otb_add_test(NAME raTvTerraSarBrightnessImageComplexFilterTest COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvTerraSarBrightnessImageComplexFilterTest.tif ${TEMP}/raTvTerraSarBrightnessImageComplexFilterTest.tif otbTerraSarBrightnessImageComplexFilterTest ${INPUTDATA}/ExtractIMAGE_HH_SRA_spot_074.tif ${TEMP}/raTvTerraSarBrightnessImageComplexFilterTest.tif 0 # don't use metadata 0 # results in linear scale ) otb_add_test(NAME raTvSarRadiometricCalibrationToImageWithComplexPixelFilter_TSX_PANGKALANBUUN COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarRadiometricCalibrationToImageFilter_TSX_PANGKALANBUUN_HH.tif ${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_PANGKALANBUUN_HH.tif otbSarRadiometricCalibrationToImageFilterWithComplexPixelTest LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} ${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_PANGKALANBUUN_HH.tif 1000 1000 250 250 # Extract ) #otb_add_test(NAME raTvSarRadiometricCalibrationToImageWithComplexPixelFilter_TSX_TORONTO COMMAND otbSARCalibrationTestDriver #--compare-image ${EPSILON_12} #${BASELINE}/raTvSarRadiometricCalibrationToImageFilter_TSX_TORONTO.tif #${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_TORONTO.tif #otbSarRadiometricCalibrationToImageFilterWithComplexPixelTest #LARGEINPUT{TERRASARX/TORONTO/TSX1_SAR__SSC/IMAGEDATA/IMAGE_HH_SRA_spot_074.cos} #${TEMP}/raTvSarRadiometricCalibrationToImageFilter_TSX_TORONTO.tif #2000 2000 250 250 # Extract #) otb_add_test(NAME raTvSarBrightnessToImageFilter COMMAND otbSARCalibrationTestDriver --compare-image ${EPSILON_12} ${BASELINE}/raTvSarBrightnessToImageFilter_TSX_PANGKALANBUUN_HH.tif ${TEMP}/raTvSarBrightnessToImageFilter_TSX_PANGKALANBUUN_HH.tif otbSarBrightnessToImageFilterTest LARGEINPUT{TERRASARX/PANGKALANBUUN/IMAGEDATA/IMAGE_HH_SRA_stripFar_008.cos} ${TEMP}/raTvSarBrightnessToImageFilter_TSX_PANGKALANBUUN_HH.tif 1000 1000 250 250 # Extract ) OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSARCalibrationTestDriver.cxx000066400000000000000000000024011301006202600307600ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbSarBrightnessFunction); REGISTER_TEST(otbSarBrightnessToImageFilterTestWithoutNoise); REGISTER_TEST(otbTerraSarBrightnessImageFilterTest); REGISTER_TEST(otbSarRadiometricCalibrationToImageFilterWithRealPixelTest); REGISTER_TEST(otbTerraSarBrightnessImageFilterNew); REGISTER_TEST(otbSarParametricMapFunctionToImageFilter); REGISTER_TEST(otbSarRadiometricCalibrationToImageFilterWithExtractROIBeforeTest); REGISTER_TEST(otbSarRadiometricCalibrationToImageFilterWithComplexPixelTestWithoutNoise); REGISTER_TEST(otbSarBrightnessFunctorWithoutNoise); REGISTER_TEST(otbTerraSarBrightnessFunctor); REGISTER_TEST(otbSarBrightnessToImageWithComplexPixelFilterTest); REGISTER_TEST(otbSarParametricMapFunctionTest); REGISTER_TEST(otbSarRadiometricCalibrationToImageFilterCompareTest); REGISTER_TEST(otbSarBrightnessFunctor); REGISTER_TEST(otbSarBrightnessFunctionWithoutNoise); REGISTER_TEST(otbSarRadiometricCalibrationFunction); REGISTER_TEST(otbSarRadiometricCalibrationFunctionWithoutNoise); REGISTER_TEST(otbTerraSarBrightnessImageComplexFilterTest); REGISTER_TEST(otbSarRadiometricCalibrationToImageFilterWithComplexPixelTest); REGISTER_TEST(otbSarBrightnessToImageFilterTest); } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarBrightnessFunction.cxx000066400000000000000000000045451301006202600304460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarBrightnessFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" #include int otbSarBrightnessFunction(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef InputImageType::IndexType IndexType; typedef otb::ImageFileReader ReaderType; typedef otb::SarBrightnessFunction FunctionType; /**Instantiation ofa Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); ReaderType::Pointer reader = ReaderType::New(); std::ofstream outfile(outfname); /** Input Image*/ reader->SetFileName(infname); reader->Update(); /** Computing the density around a pixel */ filter->SetInputImage(reader->GetOutput()); /** Test on some indexes and some physical coordinates*/ InputImageType::SizeType size = reader->GetOutput()->GetRequestedRegion().GetSize(); FunctionType::PointType pDst; IndexType index; index[0] = 0; index[1] = 0; outfile << "Sar Brightness value computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; index[0] = static_cast(size[0] / 2.); index[1] = static_cast(size[1] / 4.); outfile << "Sar Brightness value computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; pDst[0] = static_cast(size[0] / 4.); pDst[1] = static_cast(size[1] / 8.); outfile << "Sar Brightness value computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarBrightnessFunctionWithoutNoise.cxx000066400000000000000000000046471301006202600330330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarBrightnessFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" #include #include "otbMath.h" int otbSarBrightnessFunctionWithoutNoise(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef InputImageType::IndexType IndexType; typedef otb::ImageFileReader ReaderType; typedef otb::SarBrightnessFunction FunctionType; /**Instantiation ofa Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); ReaderType::Pointer reader = ReaderType::New(); std::ofstream outfile(outfname); /** Input Image*/ reader->SetFileName(infname); reader->Update(); /** Computing the density around a pixel */ filter->SetInputImage(reader->GetOutput()); filter->SetEnableNoise(false); /** Test on some indexes and some physical coordinates*/ InputImageType::SizeType size = reader->GetOutput()->GetRequestedRegion().GetSize(); FunctionType::PointType pDst; IndexType index; index[0] = 0; index[1] = 0; outfile << "Sar Brightness value computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; index[0] = static_cast(size[0] / 2.); index[1] = static_cast(size[1] / 4.); outfile << "Sar Brightness value computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; pDst[0] = static_cast(size[0] / 4.); pDst[1] = static_cast(size[1] / 8.); outfile << "Sar Brightness value computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarBrightnessFunctor.cxx000066400000000000000000000031331301006202600302710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSarBrightnessFunctor.h" #include "otbMath.h" int otbSarBrightnessFunctor(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double ScalarType; typedef otb::Functor::SarBrightnessFunctor FunctorType; FunctorType funct; funct.SetNoise( 10.0); if( vcl_abs(funct.GetNoise() -10.0) > 0.0) { return false; } funct.SetScale( 10.0); if( vcl_abs(funct.GetScale() -10.0) > 0.0) { return false; } funct.SetAntennaPatternNewGain( 10.0); if( vcl_abs(funct.GetAntennaPatternNewGain() -10.0) > 0.0) { return false; } funct.SetAntennaPatternOldGain( 10.0); if( vcl_abs(funct.GetAntennaPatternOldGain() -10.0) > 0.0) { return false; } funct.SetRangeSpreadLoss( 10.0); if( vcl_abs(funct.GetRangeSpreadLoss() -10.0) > 0.0) { return false; } std::cout << "First BetaNaught : " << funct.operator ()( 0.) << std::endl; std::cout << "Second BetaNaught : " << funct.operator ()( 1.) << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarBrightnessFunctorWithoutNoise.cxx000066400000000000000000000051601301006202600326550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSarBrightnessFunctor.h" #include "otbMath.h" int otbSarBrightnessFunctorWithoutNoise(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double ScalarType; typedef otb::Functor::SarBrightnessFunctor FunctorType; FunctorType functWithNoise; FunctorType functWithoutNoise; // With Noise functWithNoise.SetNoise( 0.0); if( vcl_abs(functWithNoise.GetNoise() -0.0) > 0.0) { return false; } functWithNoise.SetScale( 10.0); if( vcl_abs(functWithNoise.GetScale() -10.0) > 0.0) { return false; } functWithNoise.SetAntennaPatternNewGain( 10.0); if( vcl_abs(functWithNoise.GetAntennaPatternNewGain() -10.0) > 0.0) { return false; } functWithNoise.SetAntennaPatternOldGain( 10.0); if( vcl_abs(functWithNoise.GetAntennaPatternOldGain() -10.0) > 0.0) { return false; } functWithNoise.SetRangeSpreadLoss( 10.0); if( vcl_abs(functWithNoise.GetRangeSpreadLoss() -10.0) > 0.0) { return false; } // Without Noise functWithoutNoise.SetScale(10.0); if (vcl_abs(functWithoutNoise.GetScale() - 10.0) > 0.0) { return false; } functWithoutNoise.SetAntennaPatternNewGain(10.0); if (vcl_abs(functWithoutNoise.GetAntennaPatternNewGain() - 10.0) > 0.0) { return false; } functWithoutNoise.SetAntennaPatternOldGain(10.0); if (vcl_abs(functWithoutNoise.GetAntennaPatternOldGain() - 10.0) > 0.0) { return false; } functWithoutNoise.SetRangeSpreadLoss(10.0); if (vcl_abs(functWithoutNoise.GetRangeSpreadLoss() - 10.0) > 0.0) { return false; } std::cout << "First BetaNaught (With Noise = 0): " << functWithNoise.operator ()( 0.) << " *** " \ << "First BetaNaught (Without Noise): " << functWithoutNoise.operator ()( 0.) \ << std::endl; std::cout << "Second BetaNaught (With Noise = 0): " << functWithNoise.operator ()( 1.) << " *** " \ << "Second BetaNaught (Without Noise): " << functWithoutNoise.operator ()( 1.) \ << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarBrightnessToImageFilterTest.cxx000066400000000000000000000047011301006202600322060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbSarBrightnessToImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkExtractImageFilter.h" int otbSarBrightnessToImageFilterTest(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef RealType PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarBrightnessToImageFilter FilterType; typedef itk::ExtractImageFilter ExtractorType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); if (argc > 3) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[3]); id[1] = atoi(argv[4]); OutputImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(filter->GetOutput()); writer->SetInput(extractor->GetOutput()); } else { // Calibrate the whole image writer->SetInput(filter->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } otbSarBrightnessToImageFilterTestWithoutNoise.cxx000066400000000000000000000047561301006202600345230ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbSarBrightnessToImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkExtractImageFilter.h" int otbSarBrightnessToImageFilterTestWithoutNoise(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef RealType PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarBrightnessToImageFilter FilterType; typedef itk::ExtractImageFilter ExtractorType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); filter->SetEnableNoise(false); if (argc > 3) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[3]); id[1] = atoi(argv[4]); OutputImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(filter->GetOutput()); writer->SetInput(extractor->GetOutput()); } else { // Calibrate the whole image writer->SetInput(filter->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } otbSarBrightnessToImageWithComplexPixelFilterTest.cxx000066400000000000000000000047211301006202600353170ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbSarBrightnessToImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkExtractImageFilter.h" int otbSarBrightnessToImageWithComplexPixelFilterTest(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef std::complex PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarBrightnessToImageFilter FilterType; typedef itk::ExtractImageFilter ExtractorType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); if (argc > 3) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[3]); id[1] = atoi(argv[4]); OutputImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(filter->GetOutput()); writer->SetInput(extractor->GetOutput()); } else { // Calibrate the whole image writer->SetInput(filter->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarParametricMapFunctionTest.cxx000066400000000000000000000070051301006202600317150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbImage.h" #include "otbImageFileReader.h" #include "otbSarParametricMapFunction.h" int otbSarParametricMapFunctionTest(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef InputImageType::IndexType IndexType; typedef InputImageType::PixelType InputPixelType; typedef otb::ImageFileReader ReaderType; typedef otb::SarParametricMapFunction FunctionType; typedef FunctionType::PointSetType PointSetType; /**Instantiation ofa Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); ReaderType::Pointer reader = ReaderType::New(); PointSetType::Pointer points = PointSetType::New(); PointSetType::Pointer coefValue = PointSetType::New(); std::ofstream outfile(outfname); /** Input Image*/ reader->SetFileName(infname); reader->Update(); filter->SetInputImage(reader->GetOutput()); /** Test on some indexes and some physical coordinates*/ InputImageType::SizeType size = reader->GetOutput()->GetRequestedRegion().GetSize(); FunctionType::PointType p0; IndexType index; InputPixelType value; FunctionType::PointType pDst; p0[0] = static_cast(size[0] / 2.); p0[1] = static_cast(size[1] / 4.); value = 10.0; points->SetPoint(0, p0); points->SetPointData(0, value); filter->SetPointSet(points); filter->EvaluateParametricCoefficient(); std::cout << filter << std::endl; p0[0] = static_cast(size[0] / 4.); p0[1] = static_cast(size[1] / 8.); value = 20.0; points->SetPoint(1, p0); points->SetPointData(1, value); filter->SetPointSet(points); IndexType polynomalSize; polynomalSize[0] = 1; polynomalSize[1] = 0; filter->SetPolynomalSize(polynomalSize); filter->EvaluateParametricCoefficient(); std::cout << filter << std::endl; index[0] = 0; index[1] = 0; outfile << "Sar Radiometric Calibration computed for the point : DN[" << index <<"] = " << reader->GetOutput()->GetPixel(index) << " is " << filter->EvaluateAtIndex(index) << std::endl; index[0] = static_cast(size[0] / 2.); index[1] = static_cast(size[1] / 4.); outfile << "Sar Radiometric Calibration computed for the point : DN[" << index <<"] = " << reader->GetOutput()->GetPixel(index) << " is " << filter->EvaluateAtIndex(index) << std::endl; index[0] = static_cast(size[0] / 2.); index[1] = static_cast(size[1] / 8.); outfile << "Sar Radiometric Calibration computed for the point : DN[" << index <<"] = " << reader->GetOutput()->GetPixel(index) << " is " << filter->EvaluateAtIndex(index) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarParametricMapFunctionToImageFilter.cxx000066400000000000000000000077041301006202600334770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImage.h" #include "otbFunctionToImageFilter.h" #include "otbSarParametricMapFunction.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbSarParametricMapFunctionToImageFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef InputImageType::IndexType IndexType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarParametricMapFunction FunctionType; typedef otb::FunctionToImageFilter FilterType; typedef FunctionType::PointSetType PointSetType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); PointSetType::Pointer points = PointSetType::New(); InputImageType::Pointer image = InputImageType::New(); InputImageType::RegionType region; InputImageType::IndexType index; InputImageType::SizeType size; size[0] = (unsigned int)( ::atoi(argv[2]) ); size[1] = (unsigned int)( ::atoi(argv[3]) ); region.SetSize(size); index[0] = 0; index[1] = 0; region.SetIndex(index); image->SetRegions(region); image->Allocate(); image->UpdateOutputInformation(); std::cout << "main image size : " << image->GetLargestPossibleRegion().GetSize() << std::endl; writer->SetFileName(argv[1]); filter->SetInput(image); FunctionType* function = filter->GetFunction(); function->SetInputImage(image); /** Test on some indexes and some physical coordinates*/ FunctionType::PointType p0; PixelType value; p0[0] = static_cast(0); p0[1] = static_cast(0); value = 10.0; points->SetPoint(0, p0); points->SetPointData(0, value); p0[0] = static_cast(size[0] / 2.); p0[1] = static_cast(size[1] / 2.); value = 100.0; points->SetPoint(1, p0); points->SetPointData(1, value); p0[0] = static_cast(size[0] / 4.); p0[1] = static_cast(size[1] / 4.); value = 50.0; points->SetPoint(2, p0); points->SetPointData(2, value); function->SetPointSet(points); IndexType polynomalSize; polynomalSize[0] = 2; polynomalSize[1] = 0; function->SetPolynomalSize(polynomalSize); function->EvaluateParametricCoefficient(); function->Print(std::cout); // FunctionType::IndexType index; index[0] = 0; index[1] = 0; std::cout << index << " -> " << function->EvaluateAtIndex(index) << std::endl; index[0] = 50; index[1] = 100; std::cout << index << " -> " << function->EvaluateAtIndex(index) << std::endl; index[0] = 100; index[1] = 50; std::cout << index << " -> " << function->EvaluateAtIndex(index) << std::endl; writer->SetInput(filter->GetOutput()); writer->SetNumberOfDivisionsStrippedStreaming(2); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarRadiometricCalibrationFunction.cxx000066400000000000000000000046311301006202600327440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarRadiometricCalibrationFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" #include int otbSarRadiometricCalibrationFunction(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef InputImageType::IndexType IndexType; typedef otb::ImageFileReader ReaderType; typedef otb::SarRadiometricCalibrationFunction FunctionType; /**Instantiation ofa Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); ReaderType::Pointer reader = ReaderType::New(); std::ofstream outfile(outfname); /** Input Image*/ reader->SetFileName(infname); reader->Update(); /** Computing the density around a pixel */ filter->SetInputImage(reader->GetOutput()); /** Test on some indexes and some physical coordinates*/ InputImageType::SizeType size = reader->GetOutput()->GetRequestedRegion().GetSize(); FunctionType::PointType pDst; IndexType index; index[0] = 0; index[1] = 0; outfile << "Sar Radiometric Calibration computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; index[0] = static_cast(size[0] / 2.); index[1] = static_cast(size[1] / 4.); outfile << "Sar Radiometric Calibration computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; pDst[0] = static_cast(size[0] / 2.); pDst[1] = static_cast(size[1] / 4.); outfile << "Sar Radiometric Calibration computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } otbSarRadiometricCalibrationFunctionWithoutNoise.cxx000066400000000000000000000047061301006202600352520ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarRadiometricCalibrationFunction.h" #include "otbImage.h" #include "otbImageFileReader.h" #include int otbSarRadiometricCalibrationFunctionWithoutNoise(int itkNotUsed(argc), char* argv[]) { const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef InputImageType::IndexType IndexType; typedef otb::ImageFileReader ReaderType; typedef otb::SarRadiometricCalibrationFunction FunctionType; /**Instantiation ofa Smart Pointer*/ FunctionType::Pointer filter = FunctionType::New(); ReaderType::Pointer reader = ReaderType::New(); std::ofstream outfile(outfname); /** Input Image*/ reader->SetFileName(infname); reader->Update(); /** Computing the density around a pixel */ filter->SetInputImage(reader->GetOutput()); filter->SetEnableNoise(false); /** Test on some indexes and some physical coordinates*/ InputImageType::SizeType size = reader->GetOutput()->GetRequestedRegion().GetSize(); FunctionType::PointType pDst; IndexType index; index[0] = 0; index[1] = 0; outfile << "Sar Radiometric Calibration computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; index[0] = static_cast(size[0] / 2.); index[1] = static_cast(size[1] / 4.); outfile << "Sar Radiometric Calibration computed for the point : " << index << " is " << filter->EvaluateAtIndex(index) << std::endl; pDst[0] = static_cast(size[0] / 2.); pDst[1] = static_cast(size[1] / 4.); outfile << "Sar Radiometric Calibration computed for the point : " << pDst << " is " << filter->Evaluate(pDst) << std::endl; outfile.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbSarRadiometricCalibrationFunctor.cxx000066400000000000000000000032721301006202600325770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSarRadiometricCalibrationFunctor.h" int otbSarRadiometricCalibrationFunctor(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double ScalarType; typedef otb::Functor::SarRadiometricCalibrationFunctor FunctorType; FunctorType funct; funct.SetNoise( 10.0); if( abs(funct.GetNoise() -10.0) > 0.0) { return false; } funct.SetScale( 10.0); if( abs(funct.GetScale() -10.0) > 0.0) { return false; } funct.SetAntennaPatternNewGain( 10.0); if( abs(funct.GetAntennaPatternNewGain() -10.0) > 0.0) { return false; } funct.SetAntennaPatternOldGain( 10.0); if( abs(funct.GetAntennaPatternOldGain() -10.0) > 0.0) { return false; } funct.SetIncidenceAngle( 10.0); if( abs(funct.GetIncidenceAngle() -10.0) > 0.0) { return false; } funct.SetRangeSpreadLoss( 10.0); if( abs(funct.GetRangeSpreadLoss() -10.0) > 0.0) { return false; } std::cout << "First sigma : " << funct.operator ()( 0.) << std::endl; std::cout << "Second sigma : " << funct.operator ()( 1.) << std::endl; return EXIT_SUCCESS; } otbSarRadiometricCalibrationFunctorWithoutNoise.cxx000066400000000000000000000054741301006202600351100ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbSarRadiometricCalibrationFunctor.h" int otbSarRadiometricCalibrationFunctorWithoutNoise(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef double ScalarType; typedef otb::Functor::SarRadiometricCalibrationFunctor FunctorType; FunctorType functWithNoise; FunctorType functWithoutNoise; // With Noise functWithNoise.SetNoise( 0.0); if( abs(functWithNoise.GetNoise() -0.0) > 0.0) { return false; } functWithNoise.SetScale( 10.0); if( abs(functWithNoise.GetScale() -10.0) > 0.0) { return false; } functWithNoise.SetAntennaPatternNewGain( 10.0); if( abs(functWithNoise.GetAntennaPatternNewGain() -10.0) > 0.0) { return false; } functWithNoise.SetAntennaPatternOldGain( 10.0); if( abs(functWithNoise.GetAntennaPatternOldGain() -10.0) > 0.0) { return false; } functWithNoise.SetIncidenceAngle( 10.0); if( abs(functWithNoise.GetIncidenceAngle() -10.0) > 0.0) { return false; } functWithNoise.SetRangeSpreadLoss( 10.0); if( abs(functWithNoise.GetRangeSpreadLoss() -10.0) > 0.0) { return false; } // Without Noise functWithoutNoise.SetScale( 10.0); if( abs(functWithoutNoise.GetScale() -10.0) > 0.0) { return false; } functWithoutNoise.SetAntennaPatternNewGain( 10.0); if( abs(functWithoutNoise.GetAntennaPatternNewGain() -10.0) > 0.0) { return false; } functWithoutNoise.SetAntennaPatternOldGain( 10.0); if( abs(functWithoutNoise.GetAntennaPatternOldGain() -10.0) > 0.0) { return false; } functWithoutNoise.SetIncidenceAngle( 10.0); if( abs(functWithoutNoise.GetIncidenceAngle() -10.0) > 0.0) { return false; } functWithoutNoise.SetRangeSpreadLoss( 10.0); if( abs(functWithoutNoise.GetRangeSpreadLoss() -10.0) > 0.0) { return false; } std::cout << "First sigma (With Noise = 0): " << functWithNoise.operator ()( 0.) << " *** " \ << "First sigma (Without Noise): " << functWithoutNoise.operator ()( 0.) \ << std::endl; std::cout << "Second sigma (With Noise = 0): " << functWithNoise.operator ()( 1.) << " *** " \ << "Second sigma (Without Noise): " << functWithoutNoise.operator ()( 1.) \ << std::endl; return EXIT_SUCCESS; } otbSarRadiometricCalibrationToImageFilterCompareTest.cxx000066400000000000000000000070661301006202600357470ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarRadiometricCalibrationToImageFilter.h" #include "otbImageFileReader.h" #include "otbExtractROI.h" #include "itkUnaryFunctorImageFilter.h" #include "itkComplexToModulusImageFilter.h" #include "otbStreamingCompareImageFilter.h" int otbSarRadiometricCalibrationToImageFilterCompareTest(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef std::complex PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::SarRadiometricCalibrationToImageFilter FilterComplexType; typedef otb::SarRadiometricCalibrationToImageFilter FilterRealType; typedef otb::ExtractROI ExtractorType; typedef itk::ComplexToModulusImageFilter ModulusType; typedef otb::StreamingCompareImageFilter CompareFilterType; // Instantiating object FilterComplexType::Pointer filterComplex = FilterComplexType::New(); FilterRealType::Pointer filterReal = FilterRealType::New(); ReaderType::Pointer reader = ReaderType::New(); ExtractorType::Pointer extractorComplex = ExtractorType::New(); ExtractorType::Pointer extractorReal = ExtractorType::New(); ModulusType::Pointer modulus = ModulusType::New(); CompareFilterType::Pointer compare = CompareFilterType::New(); reader->SetFileName(argv[1]); filterComplex->SetInput(reader->GetOutput()); modulus->SetInput(reader->GetOutput()); filterReal->SetInput(modulus->GetOutput()); filterComplex->UpdateOutputInformation(); filterReal->UpdateOutputInformation(); if (argc > 2) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[2]); id[1] = atoi(argv[3]); OutputImageType::SizeType size; size[0] = atoi(argv[4]); size[1] = atoi(argv[5]); region.SetIndex(id); region.SetSize(size); extractorComplex->SetExtractionRegion(region); extractorComplex->SetInput(filterComplex->GetOutput()); extractorReal->SetExtractionRegion(region); extractorReal->SetInput(filterReal->GetOutput()); compare->SetInput1(extractorComplex->GetOutput()); compare->SetInput2(extractorReal->GetOutput()); } else { compare->SetInput1(filterComplex->GetOutput()); compare->SetInput2(filterReal->GetOutput()); } compare->Update(); if(compare->GetMAE() > 0.00000001) { std::cout << "MAE : " << compare->GetMAE() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } otbSarRadiometricCalibrationToImageFilterWithComplexPixelTest.cxx000066400000000000000000000052151301006202600376200ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarRadiometricCalibrationToImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "otbMultiChannelExtractROI.h" #include "otbComplexToVectorImageCastFilter.h" int otbSarRadiometricCalibrationToImageFilterWithComplexPixelTest(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef std::complex PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarRadiometricCalibrationToImageFilter CalibFilterType; typedef otb::ExtractROI ExtractorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); CalibFilterType::Pointer calibFilter = CalibFilterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); calibFilter->SetInput(reader->GetOutput()); if (argc > 3) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[3]); id[1] = atoi(argv[4]); OutputImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(calibFilter->GetOutput()); writer->SetInput(extractor->GetOutput()); } else { // Calibrate the whole image writer->SetInput(calibFilter->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } otbSarRadiometricCalibrationToImageFilterWithComplexPixelTestWithoutNoise.cxx000066400000000000000000000052771301006202600422120ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarRadiometricCalibrationToImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "otbMultiChannelExtractROI.h" #include "otbComplexToVectorImageCastFilter.h" int otbSarRadiometricCalibrationToImageFilterWithComplexPixelTestWithoutNoise(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef std::complex PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarRadiometricCalibrationToImageFilter CalibFilterType; typedef otb::ExtractROI ExtractorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); CalibFilterType::Pointer calibFilter = CalibFilterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); calibFilter->SetInput(reader->GetOutput()); calibFilter->SetEnableNoise(false); if (argc > 3) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[3]); id[1] = atoi(argv[4]); OutputImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(calibFilter->GetOutput()); writer->SetInput(extractor->GetOutput()); } else { // Calibrate the whole image writer->SetInput(calibFilter->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } otbSarRadiometricCalibrationToImageFilterWithExtractROIBeforeTest.cxx000066400000000000000000000052531301006202600403200ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSarRadiometricCalibrationToImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbExtractROI.h" #include "otbMultiChannelExtractROI.h" #include "otbComplexToVectorImageCastFilter.h" int otbSarRadiometricCalibrationToImageFilterWithExtractROIBeforeTest(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef std::complex PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarRadiometricCalibrationToImageFilter CalibFilterType; typedef otb::ExtractROI ExtractorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); CalibFilterType::Pointer calibFilter = CalibFilterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); if (argc > 3) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[3]); id[1] = atoi(argv[4]); OutputImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(reader->GetOutput()); extractor->Update(); calibFilter->SetInput(extractor->GetOutput()); } else { // Calibrate the whole image calibFilter->SetInput(reader->GetOutput()); } writer->SetInput(calibFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbSarRadiometricCalibrationToImageFilterWithRealPixelTest.cxx000066400000000000000000000051061301006202600370730ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbSarRadiometricCalibrationToImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkExtractImageFilter.h" int otbSarRadiometricCalibrationToImageFilterWithRealPixelTest(int argc, char * argv[]) { const unsigned int Dimension = 2; typedef float RealType; typedef RealType PixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::SarRadiometricCalibrationToImageFilter FilterType; typedef itk::ExtractImageFilter ExtractorType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); if (argc > 3) { // Generate an extract from the large input OutputImageType::RegionType region; OutputImageType::IndexType id; id[0] = atoi(argv[3]); id[1] = atoi(argv[4]); OutputImageType::SizeType size; size[0] = atoi(argv[5]); size[1] = atoi(argv[6]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(filter->GetOutput()); writer->SetInput(extractor->GetOutput()); } else { // Calibrate the whole image writer->SetInput(filter->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbTerraSarBrightnessFunctor.cxx000066400000000000000000000030641301006202600312720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "itkMacro.h" #include "otbTerraSarBrightnessFunctor.h" int otbTerraSarBrightnessFunctor(int itkNotUsed(argc), char * argv[]) { char * outFilename = argv[5]; double calFact = atof(argv[4]); typedef double ScalarType; typedef std::complex ComplexType; typedef otb::Functor::TerraSarBrightnessFunctor FunctorType; FunctorType funct; funct.SetCalibrationFactor(calFact); funct.SetResultsInDecibels(false); ScalarType inPix = static_cast(atof(argv[1])); ComplexType inCplxPix(static_cast(atof(argv[2])), static_cast(atof(argv[3]))); std::ofstream file; file.open(outFilename); file << std::fixed << std::setprecision(10); file << "Scalar pixel : " << inPix << " -> " << funct.operator ()(inPix) << std::endl; file << "Complex pixel : " << inCplxPix << " -> " << funct.operator ()(inCplxPix) << std::endl; file.close(); return EXIT_SUCCESS; } otbTerraSarBrightnessImageComplexFilterTest.cxx000066400000000000000000000055651301006202600341630ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/SARCalibration/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbTerraSarBrightnessImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "itkExtractImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbComplexToVectorImageCastFilter.h" int otbTerraSarBrightnessImageComplexFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const bool useMetadata = atoi(argv[3]); const bool resultsInDb = atoi(argv[4]); typedef std::complex ComplexType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::TerraSarBrightnessImageFilter FilterType; typedef itk::ExtractImageFilter ExtractorType; typedef otb::ComplexToVectorImageCastFilter CastType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); CastType::Pointer caster = CastType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); filter->SetInput(reader->GetOutput()); filter->SetResultsInDecibels(resultsInDb); if (useMetadata) { // Generate an extract from the large input ImageType::RegionType region; ImageType::IndexType id; id[0] = atoi(argv[5]); id[1] = atoi(argv[6]); ImageType::SizeType size; size[0] = atoi(argv[7]); size[1] = atoi(argv[8]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(filter->GetOutput()); caster->SetInput(extractor->GetOutput()); } else { filter->SetCalibrationFactor(10); caster->SetInput(filter->GetOutput()); } writer->SetInput(caster->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbTerraSarBrightnessImageFilterNew.cxx000066400000000000000000000024231301006202600325120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbTerraSarBrightnessImageFilter.h" #include "otbImage.h" int otbTerraSarBrightnessImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Image ImageType; typedef otb::Image, 2> ComplexImageType; typedef otb::TerraSarBrightnessImageFilter FilterType; typedef otb::TerraSarBrightnessImageFilter ComplexFilterType; FilterType::Pointer filter = FilterType::New(); ComplexFilterType::Pointer complexFilter = ComplexFilterType::New(); std::cout << filter << std::endl; std::cout << complexFilter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/SARCalibration/test/otbTerraSarBrightnessImageFilterTest.cxx000066400000000000000000000046311301006202600327030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbTerraSarBrightnessImageFilter.h" #include "otbImage.h" #include "itkExtractImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbTerraSarBrightnessImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const bool useMetadata = atoi(argv[3]); const bool resultsInDb = atoi(argv[4]); typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::TerraSarBrightnessImageFilter FilterType; typedef itk::ExtractImageFilter ExtractorType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); ExtractorType::Pointer extractor = ExtractorType::New(); reader->SetFileName(inputFileName); writer->SetFileName(outputFileName); reader->UpdateOutputInformation(); filter->SetInput(reader->GetOutput()); filter->SetResultsInDecibels(resultsInDb); if (useMetadata) { // Generate an extract from the large input ImageType::RegionType region; ImageType::IndexType id; id[0] = atoi(argv[5]); id[1] = atoi(argv[6]); ImageType::SizeType size; size[0] = atoi(argv[7]); size[1] = atoi(argv[8]); region.SetIndex(id); region.SetSize(size); extractor->SetExtractionRegion(region); extractor->SetInput(filter->GetOutput()); writer->SetInput(extractor->GetOutput()); } else { filter->SetCalibrationFactor(10); writer->SetInput(filter->GetOutput()); } writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/000077500000000000000000000000001301006202600212715ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Simulation/CMakeLists.txt000066400000000000000000000001251301006202600240270ustar00rootroot00000000000000project(OTBSimulation) set(OTBSimulation_LIBRARIES OTBSimulation) otb_module_impl() OTB-release-5.8/Modules/Radiometry/Simulation/include/000077500000000000000000000000001301006202600227145ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Simulation/include/otbAtmosphericEffects.h000066400000000000000000000111411301006202600273460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAtmosphericEffects_h #define otbAtmosphericEffects_h #include "otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h" namespace otb { /** \class AtmosphericEffects * \brief This class applies atmospheric effects, computed from otbAtmosphericCorrectionParametersTo6SRadiativeTerms to an input spectrum (otbSpectralResponse) using the otbSurfaceReflectanceToReflectanceFilter. * * The two templates indicate: * - the SpectralResponse input (from the JPL ASTER spectral library for example see : http://speclib.jpl.nasa.gov/) * - the SatelliteRSR relatives spectral response of a sensor (RSR). * * \sa itk::DataObject * * \ingroup OTBSimulation */ template class AtmosphericEffects : public itk::DataObject { public: /** Standard class typedefs */ typedef AtmosphericEffects Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Template parameters typedef. */ /** Spectral response of a material (from the JPL ASTER spectral library for example)*/ typedef TSpectralResponse InputSpectralResponseType; /** Template parameters typedef. */ /** The relatives spectral response of a sensor (RSR)*/ typedef TRSR InputRSRType; typedef typename InputRSRType::Pointer InputRSRPointerType; typedef typename InputSpectralResponseType::Pointer InputSpectralResponsePointerType; typedef typename InputRSRType::PrecisionType PrecisionType; typedef typename InputRSRType::ValuePrecisionType ValuePrecisionType; typedef typename InputSpectralResponseType::PairType PairType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef typename AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; /** Standard macros */ itkNewMacro(Self); itkTypeMacro(AtmosphericEffects, DataObject); itkGetConstObjectMacro(InputSatRSR, InputRSRType); itkSetObjectMacro(InputSatRSR, InputRSRType); itkGetConstObjectMacro(InputSpectralResponse, InputSpectralResponseType); itkSetObjectMacro(InputSpectralResponse, InputSpectralResponseType); /** Get/Set Atmospheric Radiative Terms. */ void SetAtmosphericRadiativeTerms(AtmosphericRadiativeTermsPointerType atmoRadTerms) { m_AtmosphericRadiativeTerms = atmoRadTerms; this->Modified(); } itkGetConstObjectMacro(AtmosphericRadiativeTerms, AtmosphericRadiativeTermsType); //itkSetObjectMacro(AtmosphericRadiativeTerms, AtmosphericRadiativeTermsType); itkGetObjectMacro(CorrectedSpectralResponse, InputSpectralResponseType); // void LoadFilterFunctionAtmosphericCorrectionParameters( double step = 0.0025); void Process(/*const unsigned int numBand*/); protected: /** Constructor */ AtmosphericEffects(); /** Constructor from a ASCII file */ //AtmosphericEffects( const std::string & filename ); /** Destructor */ ~AtmosphericEffects() ITK_OVERRIDE {}; /** PrintSelf method */ //void PrintSelf(std::ostream& os, itk::Indent indent) const; private: AtmosphericEffects(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented AtmosphericRadiativeTermsPointerType m_AtmosphericRadiativeTerms; InputSpectralResponsePointerType m_InputSpectralResponse; InputSpectralResponsePointerType m_CorrectedSpectralResponse; InputRSRPointerType m_InputSatRSR; bool m_IsSetAtmosphericRadiativeTerms; }; }// end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAtmosphericEffects.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbAtmosphericEffects.txx000066400000000000000000000117661301006202600277570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAtmosphericEffects_txx #define otbAtmosphericEffects_txx #include "otbAtmosphericEffects.h" #include "otbSurfaceReflectanceToReflectanceFilter.h" namespace otb { template AtmosphericEffects ::AtmosphericEffects() : m_IsSetAtmosphericRadiativeTerms(false) { m_InputSpectralResponse = InputSpectralResponseType::New(); m_CorrectedSpectralResponse = InputSpectralResponseType::New(); m_InputSatRSR = InputRSRType::New(); } /* template void AtmosphericEffects ::LoadFilterFunctionAtmosphericCorrectionParameters(double step) { //LMoad the filter function from the RSR for (unsigned int i=0; im_InputSatRSR->GetNbBands(); ++i) { m_DataAtmosphericCorrectionParameters->SetWavelenghtSpectralBandWithIndex(i, this->m_InputSatRSR->GetRSR()[i]->GetFilterFunctionValues (step)); } } */ template void AtmosphericEffects ::Process(/*const unsigned int numBand*/) { /*typedef otb::AtmosphericCorrectionParametersTo6SAtmosphericRadiativeTerms AtmosphericCorrectionParametersTo6SRadiativeTermsType; AtmosphericCorrectionParametersTo6SRadiativeTermsType::Pointer filterAtmosphericCorrectionParametersTo6SRadiativeTerms = AtmosphericCorrectionParametersTo6SRadiativeTermsType::New(); //Set filter function to get the RSR Sat!!!//TODO typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; ValuesVectorType valuesVector; const double step = 0.0025; for (unsigned int i=0; i < this->m_InputSatRSR->GetNbBands(); ++i) { //Foreach band valuesVector.clear(); PairType inter; inter = (this->m_InputSatRSR->GetRSR())[i]->GetInterval(); otbGenericMsgDebugMacro(<<"inter " << inter.first << " " << inter.second); PairType pair; pair.first=(inter.first+inter.second)/2.0; pair.second=0.; m_CorrectedSpectralResponse->GetResponse().push_back(pair); for ( double j=inter.first; j <= inter.second; j+=step) { valuesVector.push_back( (*this->m_InputSatRSR->GetRSR()[i])(j) ); } FilterFunctionValuesType::Pointer functionValues = FilterFunctionValuesType::New(); functionValues->SetFilterFunctionValues(valuesVector); functionValues->SetMinSpectralValue(inter.first); functionValues->SetMaxSpectralValue(inter.second - step); //TODO Is it the efficient method Problem in 6STraits functionValues->SetUserStep( step ); m_DataAtmosphericCorrectionParameters->SetWavelengthSpectralBandWithIndex(i, functionValues); } filterAtmosphericCorrectionParametersTo6SRadiativeTerms->SetInput( m_DataAtmosphericCorrectionParameters ); filterAtmosphericCorrectionParametersTo6SRadiativeTerms->Update(); otbGenericMsgDebugMacro(<<"6S radiative term performed"); typedef typename InputSpectralResponseType::ImageType ImageType; typedef SurfaceReflectanceToReflectanceFilter SurfaceReflectanceToReflectanceFilterType; typename SurfaceReflectanceToReflectanceFilterType::Pointer filterSRToR = SurfaceReflectanceToReflectanceFilterType::New(); filterSRToR->SetAtmosphericRadiativeTerms( filterAtmosphericCorrectionParametersTo6SRadiativeTerms->GetOutput() ); typename ImageType::Pointer image = ImageType::New(); this->m_InputSpectralResponse->GetImage(image); filterSRToR->SetInput( image ); filterSRToR->Update(); this->m_CorrectedSpectralResponse->SetFromImage( filterSRToR->GetOutput() ); */ /*if (m_IsSetAtmosphericRadiativeTerms) {*/ typedef typename InputSpectralResponseType::ImageType ImageType; typedef SurfaceReflectanceToReflectanceFilter SurfaceReflectanceToReflectanceFilterType; typename SurfaceReflectanceToReflectanceFilterType::Pointer filterSRToR = SurfaceReflectanceToReflectanceFilterType::New(); filterSRToR->SetAtmosphericRadiativeTerms( m_AtmosphericRadiativeTerms ); typename ImageType::Pointer image = ImageType::New(); this->m_InputSpectralResponse->GetImage(image); filterSRToR->SetInput( image ); filterSRToR->Update(); this->m_CorrectedSpectralResponse->SetFromImage( filterSRToR->GetOutput() ); /*} else itkExceptionMacro(<< "Atmospheric radiative terms must be provided before updating the CSR (Corrected Spectral Response)"); */ } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbDataSpecP5B.h000066400000000000000000000036501301006202600255710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDataSpecP5B_h #define otbDataSpecP5B_h namespace otb { /** \struct DataSpec * \brief This struct contains the specific absorption coefficients of each constituent and the refractive index of leaf materia * * [1] = wavelength (nm) * [2] = refractive index of leaf material * [3] = specific absorption coefficient of chlorophyll (a+b) (cm2.microg-1) * [4] = specific absorption coefficient of carotenoids (cm2.microg-1) * [5] = specific absorption coefficient of brown pigments (arbitrary units) * [6] = specific absorption coefficient of water (cm-1) * [7] = specific absorption coefficient of dry matter (g.cm-1) * [8] = direct light * [9] = diffuse light * [10] = dry soil * [11] = wet soil * Feret et al. (2008), PROSPECT-4 and 5: Advances in the Leaf Optical * Properties Model Separating Photosynthetic Pigments, Remote Sensing of * Environment * The specific absorption coefficient corresponding to brown pigment is * provided by Frederic Baret (EMMAH, INRA Avignon, baret@avignon.inra.fr) * and used with his autorization. */ struct DataSpec { double lambda; double refLeafMatInd; double chlAbsCoef; double carAbsCoef; double brownAbsCoef; double waterAbsCoef; double dryAbsCoef; double directLight; double diffuseLight; double drySoil; double wetSoil; }; extern const DataSpec DataSpecP5B[2101]; } #endif /* otbDataSpecP5B_h */ OTB-release-5.8/Modules/Radiometry/Simulation/include/otbImageSimulationMethod.h000066400000000000000000000165621301006202600300340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSimulationMethod_h #define otbImageSimulationMethod_h #include "itkImageSource.h" #include "otbProspectModel.h" #include "otbSailModel.h" #include "otbLabelMapToSimulatedImageFilter.h" #include "otbMultiToMonoChannelExtractROI.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" //#include "otbStreamingResampleImageFilter.h" #include "itkResampleImageFilter.h" #include "otbProlateInterpolateImageFunction.h" #include "itkLabelMapToLabelImageFilter.h" namespace otb { /** * \class ImageSimulationMethod * \brief Image simulation method * * ImageSimulationMethod converts a vectorData describing spatial distribution of materials into an image of reflectance. * Reflectance image is computed by applying the RSR (relatives spectral response) of the satellite to the spectra obtained * by the spectrum simulator. Then the satellite FTM is applied to compute spatial distribution of spectra. * FTM is computed using otbResampleImageFilter and a ProlateInterpolateImageFunction. * This method is not a true composite filter and the method UpdateData() must be called in a main program using this class. * *In order to avoid homogenous regions of a material, for each pixel in the region a noise is added to the reference sprectrum obtained from the spectrum simulator (see LabelMapToSimulatedImageFilter). * * \sa ImageSource * * \ingroup OTBSimulation */ template class ITK_EXPORT ImageSimulationMethod : public itk::ImageSource { public: /** * Standard "Self" & Superclass typedef. */ typedef ImageSimulationMethod Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputVectorData InputVectorDataType; typedef typename InputVectorDataType::Pointer InputVectorDataPointer; typedef typename InputVectorDataType::ConstPointer InputVectorDataConstPointer; typedef TSpatialisation SpatialisationType; typedef typename SpatialisationType::Pointer SpatialisationPointer; typedef typename SpatialisationType::OutputLabelMapType LabelMapType; typedef typename LabelMapType::LabelObjectType::LabelType LabelType; typedef TSimulationStep1 SimulationStep1Type; typedef typename SimulationStep1Type::Pointer SimulationStep1Pointer; typedef TSimulationStep2 SimulationStep2Type; typedef typename SimulationStep2Type::Pointer SimulationStep2Pointer; typedef TFTM FTMType; typedef typename FTMType::Pointer FTMPointer; typedef TOutputImage OutputImageType; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::IndexType IndexType; typedef typename OutputImageType::InternalPixelType InternalPixelType; typedef otb::Image OutputLabelImageType; typedef otb::LabelMapToSimulatedImageFilter LabelMapToSimulatedImageFilterType; typedef typename LabelMapToSimulatedImageFilterType::Pointer LabelMapToSimulatedImageFilterPointer; typedef otb::MultiToMonoChannelExtractROI MultiToMonoChannelFilterType; typedef typename MultiToMonoChannelFilterType::Pointer MultiToMonoChannelFilterPointer; typedef MultiToMonoChannelFilterType::OutputImageType SingleImageType; typedef otb::ImageList ImageListType; typedef typename ImageListType::Pointer ImageListPointer; typedef otb::ImageListToVectorImageFilter ImageListToVectorImageFilterType; typedef typename ImageListToVectorImageFilterType::Pointer ImageListToVectorImageFilterPointer; typedef otb::ProlateInterpolateImageFunction InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointer; typedef itk::ResampleImageFilter FTMFilterType; // typedef otb::StreamingResampleImageFilter FTMFilterType; typedef typename FTMFilterType::Pointer FTMFilterPointer; typedef itk::LabelMapToLabelImageFilter LabelMapToLabelImageFilterType; typedef typename LabelMapToLabelImageFilterType::Pointer LabelMapToLabelImageFilterPointer; /** Standard Macro*/ itkTypeMacro(ImageSimulationMethod, ImageSource) ; itkNewMacro(Self) ; itkSetMacro(NumberOfComponentsPerPixel, unsigned int) ; itkGetMacro(NumberOfComponentsPerPixel, unsigned int) ; //prolate radius itkSetMacro(Radius, unsigned int) ; itkGetMacro(Radius, unsigned int) ; itkSetMacro(SatRSRFilename, std::string) ; itkGetMacro(SatRSRFilename, std::string) ; itkSetMacro(PathRoot, std::string) ; itkGetMacro(PathRoot, std::string) ; itkSetMacro(Mean, double) ; itkGetMacro(Mean, double) ; itkSetMacro(Variance, double) ; itkGetMacro(Variance, double) ; itkSetObjectMacro(Spatialisation, SpatialisationType) ; // itkSetObjectMacro(LabelMapToSimulatedImage, LabelMapToSimulatedImageType); // itkSetObjectMacro(FTM, FTMType); /** Set/Get Input */ itkSetObjectMacro(InputVectorData, InputVectorDataType) ; itkGetConstObjectMacro(InputVectorData, InputVectorDataType) ; // void SetInput(const InputVectorDataType *object); // InputVectorDataType * GetInput(); /** Get outputs */ virtual OutputLabelImageType * GetOutputLabelImage(); virtual OutputImageType * GetOutputReflectanceImage(); void UpdateData(); protected: ImageSimulationMethod(); ~ImageSimulationMethod() ITK_OVERRIDE { } void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; // virtual void GenerateData(); void GenerateOutputInformation() ITK_OVERRIDE; private: ImageSimulationMethod(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfComponentsPerPixel; unsigned int m_Radius; //radius of prolate interpolate std::string m_SatRSRFilename; std::string m_PathRoot; double m_Mean; double m_Variance; InputVectorDataPointer m_InputVectorData; SpatialisationPointer m_Spatialisation; LabelMapToSimulatedImageFilterPointer m_LabelMapToSimulatedImageFilter; // FTMPointer m_FTM; std::vector m_MultiToMonoChannelFilterList; ImageListPointer m_ImageList; ImageListToVectorImageFilterPointer m_ImageListToVectorImageFilter; std::vector m_FTMFilterList; std::vector m_InterpolatorList; LabelMapToLabelImageFilterPointer m_LabelMapToLabelImageFilter; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageSimulationMethod.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbImageSimulationMethod.txx000066400000000000000000000303711301006202600304220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageSimulationMethod_txx #define otbImageSimulationMethod_txx #include "otbImageSimulationMethod.h" namespace otb { template ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> ::ImageSimulationMethod() { //instantiation m_Spatialisation = SpatialisationType::New(); m_LabelMapToSimulatedImageFilter = LabelMapToSimulatedImageFilterType::New(); m_LabelMapToLabelImageFilter = LabelMapToLabelImageFilterType::New(); // this->SetNumberOfRequiredOutputs(2); // this->SetNthOutput(0, OutputImageType::New()); // this->SetNthOutput(1, OutputLabelImageType::New()); //TODO a changer mais pour le moment obligatoire car ProlateInterpolateImageFunction // ne fonctionne qu'avec des images mono canal. // m_FTMFilter = FTMFilterType::New(); // m_Interpolator = InterpolatorType::New(); // m_MultiToMonoChannelFilter = MultiToMonoChannelFilterType::New(); m_ImageList = ImageListType::New(); m_ImageListToVectorImageFilter = ImageListToVectorImageFilterType::New(); //default value m_NumberOfComponentsPerPixel = 3; m_Radius = 3; m_SatRSRFilename = ""; m_PathRoot = ""; m_Mean = 0.0; m_Variance = 1e-8; } //The 3 commented methods are needed for a true composite filters. // template // void // ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> // ::SetInput(const InputVectorDataType* object) // { // this->itk::ProcessObject::SetNthInput(0, const_cast(object)); // } // // template // typename ImageSimulationMethod::InputVectorDataType * // ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> // ::GetInput() // { // return static_cast(this->itk::ProcessObject::GetInput(0)); // } /** Get output reflectance image */ // template // typename ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage>::OutputImageType * // ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> // ::GetOutputReflectanceImage() // { // if(this->GetNumberOfOutputs() < 2) // { // //exit // return 0; // } // return static_cast(this->itk::ProcessObject::GetOutput(0)); // } // // /** Get output label image */ // template // typename ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage>::OutputLabelImageType * // ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> // ::GetOutputLabelImage() // { // if(this->GetNumberOfOutputs() < 2) // { // //exit // return 0; // } // return static_cast(this->itk::ProcessObject::GetOutput(1)); // } /** Get output reflectance image */ template typename ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage>::OutputImageType * ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> ::GetOutputReflectanceImage() { return m_ImageListToVectorImageFilter->GetOutput(); } /** Get output label image */ template typename ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage>::OutputLabelImageType * ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> ::GetOutputLabelImage() { return m_LabelMapToLabelImageFilter->GetOutput(); } template void ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); OutputImageType * outputReflImage = this->GetOutputReflectanceImage(); // m_Spatialisation->SetInput(m_InputVectorData); m_Spatialisation->UpdateOutputInformation(); outputReflImage->SetNumberOfComponentsPerPixel(m_NumberOfComponentsPerPixel); outputReflImage->SetLargestPossibleRegion(m_Spatialisation->GetOutput()->GetLargestPossibleRegion()); outputReflImage->SetOrigin(m_Spatialisation->GetOutput()->GetOrigin()); OutputLabelImageType * outputLabelImage = this->GetOutputLabelImage(); outputLabelImage->SetLargestPossibleRegion(m_Spatialisation->GetOutput()->GetLargestPossibleRegion()); outputLabelImage->SetOrigin(m_Spatialisation->GetOutput()->GetOrigin()); } template void ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> ::UpdateData() { // m_Spatialisation->SetInput(m_InputVectorData); // m_Spatialisation->SetInitialLabel(1); // m_Spatialisation->SetBackgroundValue(0); m_LabelMapToSimulatedImageFilter->SetInput(m_Spatialisation->GetOutput()); m_LabelMapToSimulatedImageFilter->SetNumberOfComponentsPerPixel(m_NumberOfComponentsPerPixel); m_LabelMapToSimulatedImageFilter->SetSatRSRFilename(m_SatRSRFilename); m_LabelMapToSimulatedImageFilter->SetNumberOfThreads(1); m_LabelMapToSimulatedImageFilter->SetPathRoot(m_PathRoot); m_LabelMapToSimulatedImageFilter->SetMean(m_Mean); m_LabelMapToSimulatedImageFilter->SetVariance(m_Variance); m_LabelMapToLabelImageFilter->SetInput(m_Spatialisation->GetOutput()); m_LabelMapToSimulatedImageFilter->UpdateOutputInformation(); for (unsigned int i = 0; i < m_NumberOfComponentsPerPixel; ++i) { MultiToMonoChannelFilterPointer multiToMonoChannelFilter = MultiToMonoChannelFilterType::New(); InterpolatorPointer interpolator = InterpolatorType::New(); FTMFilterPointer FTMFilter = FTMFilterType::New(); multiToMonoChannelFilter->SetInput(m_LabelMapToSimulatedImageFilter->GetOutput()); multiToMonoChannelFilter->SetChannel(i + 1); multiToMonoChannelFilter->SetExtractionRegion( m_LabelMapToSimulatedImageFilter->GetOutput()->GetLargestPossibleRegion()); //TODO comment changer interpolateur ! interpolator->SetInputImage(multiToMonoChannelFilter->GetOutput()); interpolator->SetRadius(m_Radius); interpolator->Initialize(); multiToMonoChannelFilter->UpdateOutputInformation(); FTMFilter->SetInterpolator(interpolator); // FTMFilter->SetOutputSize(multiToMonoChannelFilter->GetOutput()->GetLargestPossibleRegion().GetSize()); FTMFilter->SetSize(multiToMonoChannelFilter->GetOutput()->GetLargestPossibleRegion().GetSize()); FTMFilter->SetOutputSpacing(multiToMonoChannelFilter->GetOutput()->GetSpacing()); FTMFilter->SetOutputOrigin(multiToMonoChannelFilter->GetOutput()->GetOrigin()); FTMFilter->SetInput(multiToMonoChannelFilter->GetOutput()); FTMFilter->Update(); m_ImageList->PushBack(FTMFilter->GetOutput()); } m_ImageListToVectorImageFilter->SetInput(m_ImageList); } //In case of a true composite filter // template // void // ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> // ::GenerateData() // { // // // m_Spatialisation->SetInput(m_InputVectorData); // // m_Spatialisation->SetInitialLabel(1); // // m_Spatialisation->SetBackgroundValue(0); // // m_LabelMapToSimulatedImageFilter->SetInput(m_Spatialisation->GetOutput()); // m_LabelMapToSimulatedImageFilter->SetNumberOfComponentsPerPixel(m_NumberOfComponentsPerPixel); // m_LabelMapToSimulatedImageFilter->SetSatRSRFilename(m_SatRSRFilename); // m_LabelMapToSimulatedImageFilter->SetNumberOfThreads(1); // m_LabelMapToSimulatedImageFilter->SetPathRoot(m_PathRoot); // m_LabelMapToSimulatedImageFilter->SetMean(m_Mean); // m_LabelMapToSimulatedImageFilter->SetVariance(m_Variance); // // m_LabelMapToLabelImageFilter->SetInput(m_Spatialisation->GetOutput()); // m_LabelMapToLabelImageFilter->GraftNthOutput(0, this->GetOutputLabelImage()); // m_LabelMapToLabelImageFilter->Update(); // this->GraftNthOutput(1, m_LabelMapToLabelImageFilter->GetOutput()); // // // m_LabelMapToSimulatedImageFilter->GraftNthOutput(0, this->GetOutputReflectanceImage()); // // m_LabelMapToSimulatedImageFilter->Update(); // // this->GraftNthOutput(0, m_LabelMapToSimulatedImageFilter->GetOutput()); // // for(unsigned int i = 0; iSetInput(m_LabelMapToSimulatedImageFilter->GetOutput()); // multiToMonoChannelFilter->SetChannel(i+1); // multiToMonoChannelFilter->SetExtractionRegion(m_LabelMapToSimulatedImageFilter->GetOutput()->GetLargestPossibleRegion()); // // // //TODO comment changer interpolateur ! // interpolator->SetInputImage(multiToMonoChannelFilter->GetOutput()); // interpolator->SetRadius(m_Radius); // interpolator->Initialize(); // // multiToMonoChannelFilter->UpdateOutputInformation(); // // FTMFilter->SetInterpolator(interpolator); // // FTMFilter->SetOutputSize(multiToMonoChannelFilter->GetOutput()->GetLargestPossibleRegion().GetSize()); // FTMFilter->SetSize(multiToMonoChannelFilter->GetOutput()->GetLargestPossibleRegion().GetSize()); // FTMFilter->SetOutputSpacing(multiToMonoChannelFilter->GetOutput()->GetSpacing()); // FTMFilter->SetOutputOrigin(multiToMonoChannelFilter->GetOutput()->GetOrigin()); // FTMFilter->SetInput(multiToMonoChannelFilter->GetOutput()); // FTMFilter->Update(); // // m_ImageList->PushBack(FTMFilter->GetOutput()); // } // m_ImageListToVectorImageFilter->SetInput(m_ImageList); // // m_ImageListToVectorImageFilter->GraftNthOutput(0, this->GetOutputReflectanceImage()); // m_ImageListToVectorImageFilter->Update(); // this->GraftNthOutput(0, m_ImageListToVectorImageFilter->GetOutput()); // // } template void ImageSimulationMethod< TInputVectorData, TSpatialisation, TSimulationStep1, TSimulationStep2, TFTM, TOutputImage> ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbLabelMapToSimulatedImageFilter.h000066400000000000000000000130121301006202600315300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToSimulatedImageFilter_h #define otbLabelMapToSimulatedImageFilter_h #include "itkLabelMapFilter.h" #include "otbLabelToProSailParameters.h" #include "otbReduceSpectralResponse.h" #include "otbGaussianAdditiveNoiseSampleListFilter.h" #include "otbSatelliteRSR.h" namespace otb { /** * \class LabelMapToSimulatedImageFilter * \brief Transform a labelMap into an image. * * LabelMapToSimulatedImageFilter convert a label map into a reflectance image. * Reflectance of the image is computed by applying the RSR (relative spectral response) of the satellite to the spectrum obtained * by the spectrum simulator (or read in the database). A gaussian noise is added to the reflectance value of * each pixel of the object. However the method used to add this noise (itk::Statistics::MersenneTwisterRandomVariateGenerator) * is not thread safe, and then (even if all the remaining is multithread) the number of thread must be set to 1. * * \sa LabelMapFilter * * \ingroup OTBSimulation */ template class ITK_EXPORT LabelMapToSimulatedImageFilter : public itk::LabelMapFilter { public: /** * Standard "Self" & Superclass typedef. */ typedef LabelMapToSimulatedImageFilter Self; typedef itk::LabelMapFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputLabelMap InputLabelMapType; typedef typename InputLabelMapType::Pointer InputLabelMapPointer; typedef typename InputLabelMapType::ConstPointer InputLabelMapConstPointer; typedef typename InputLabelMapType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType; typedef typename LabelObjectType::AttributesValueType AttributesValueType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::IndexType IndexType; typedef typename OutputImageType::InternalPixelType InternalPixelType; typedef TSimuStep1 SimulationStep1Type; typedef typename SimulationStep1Type::Pointer SimulationStep1Pointer; typedef TSimuStep2 SimulationStep2Type; typedef typename SimulationStep2Type::Pointer SimulationStep2Pointer; //TODO: template ?? typedef LabelToProSailParameters LabelToParametersType; typedef typename LabelToParametersType::Pointer LabelToParametersPointer; typedef SpectralResponse SpectralResponseType; typedef typename SpectralResponseType::Pointer SpectralResponsePointer; typedef SatelliteRSR SatelliteRSRType; typedef typename SatelliteRSRType::Pointer SatelliteRSRPointer; typedef ReduceSpectralResponse ReduceSpectralResponseType; typedef typename ReduceSpectralResponseType::Pointer ReduceSpectralResponsePointer; typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType; typedef typename RandomGeneratorType::Pointer RandomGeneratorPointer; /** Standard Macro*/ itkTypeMacro(LabelMapToSimulatedImageFilter, LabelMapFilter); itkNewMacro(Self); itkSetMacro(NumberOfComponentsPerPixel, unsigned int); itkGetMacro(NumberOfComponentsPerPixel, unsigned int); itkSetMacro(SatRSRFilename, std::string); itkGetMacro(SatRSRFilename, std::string); itkSetMacro(PathRoot, std::string); itkGetMacro(PathRoot, std::string); itkSetMacro(Mean, double); itkGetMacro(Mean, double); itkSetMacro(Variance, double); itkGetMacro(Variance, double); protected: LabelMapToSimulatedImageFilter(); ~LabelMapToSimulatedImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void BeforeThreadedGenerateData() ITK_OVERRIDE; void ThreadedProcessLabelObject( LabelObjectType * labelObject ) ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; private: LabelMapToSimulatedImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfComponentsPerPixel; std::string m_SatRSRFilename; std::string m_PathRoot; /** Mean value of gaussien noise for spectra simulation.*/ double m_Mean; /** Variance of gaussien noise for spectra simulation.*/ double m_Variance; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapToSimulatedImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbLabelMapToSimulatedImageFilter.txx000066400000000000000000000121031301006202600321240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToSimulatedImageFilter_txx #define otbLabelMapToSimulatedImageFilter_txx #include "otbLabelMapToSimulatedImageFilter.h" namespace otb { template LabelMapToSimulatedImageFilter ::LabelMapToSimulatedImageFilter() { m_NumberOfComponentsPerPixel = 3; m_SatRSRFilename=""; m_PathRoot=""; m_Mean=0.0; m_Variance=1e-8; } template void LabelMapToSimulatedImageFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); OutputImageType * output = this->GetOutput(); output->SetNumberOfComponentsPerPixel(m_NumberOfComponentsPerPixel); } template void LabelMapToSimulatedImageFilter ::BeforeThreadedGenerateData() { OutputImageType * output = this->GetOutput(); const InputLabelMapType * input = this->GetInput(); typename OutputImageType::PixelType pixel; pixel.SetSize(m_NumberOfComponentsPerPixel); pixel.Fill( input->GetBackgroundValue() ); output->FillBuffer(pixel); Superclass::BeforeThreadedGenerateData(); } template void LabelMapToSimulatedImageFilter ::ThreadedProcessLabelObject( LabelObjectType * labelObject ) { ReduceSpectralResponsePointer reduceSpectralResponse = ReduceSpectralResponseType::New(); SatelliteRSRPointer satRSR = SatelliteRSRType::New(); //Compute the spectral response associated to this object. SpectralResponsePointer readSpectrum = SpectralResponseType::New(); bool hasPath = false; //Check if the spectrum associated to this object is given by a database. for (unsigned int i = 0; i < labelObject->GetNumberOfAttributes(); ++i) { if (labelObject->GetAvailableAttributes()[i].compare("path") == 0) hasPath = true; } if (hasPath == true) { readSpectrum->Load(m_PathRoot + labelObject->GetAttribute("path"), 100); reduceSpectralResponse->SetInputSpectralResponse(readSpectrum); } else //compute the spectrum using ProSail { LabelToParametersPointer labelToParams = LabelToParametersType::New(); SimulationStep1Pointer simuStep1 = SimulationStep1Type::New(); SimulationStep2Pointer simuStep2 = SimulationStep2Type::New(); //Compute params needed to the spectrum simulator labelToParams->SetLabel(labelObject->GetAttribute("area")); labelToParams->GenerateData(); simuStep1->SetInput(labelToParams->GetStep1Parameters()); simuStep2->SetParameters(labelToParams->GetStep2Parameters()); simuStep2->SetReflectance(simuStep1->GetReflectance()); simuStep2->SetTransmittance(simuStep1->GetTransmittance()); simuStep2->Update(); reduceSpectralResponse->SetInputSpectralResponse(simuStep2->GetViewingReflectance()); } //compute the satellite response of this spectrum satRSR->Clear(); satRSR->SetNbBands(m_NumberOfComponentsPerPixel); satRSR->Load(m_SatRSRFilename); reduceSpectralResponse->SetInputSatRSR(satRSR); reduceSpectralResponse->CalculateResponse(); typename OutputImageType::PixelType pixel; pixel.SetSize(m_NumberOfComponentsPerPixel); //TODO Change with a multithreaded method RandomGeneratorPointer randomGen = RandomGeneratorType::GetInstance(); ConstLineIteratorType lit = ConstLineIteratorType (labelObject); while ( !lit.IsAtEnd() ) { IndexType idx = lit.GetLine().GetIndex(); unsigned long length = lit.GetLine().GetLength(); for (unsigned int i = 0; i < length; ++i) { //add gaussian white noise for (unsigned int j = 0; j < m_NumberOfComponentsPerPixel; ++j) { double ran = randomGen->GetNormalVariate(m_Mean, m_Variance); pixel[j] = static_cast (reduceSpectralResponse->GetReduceResponse()->GetResponse()[j].second + ran); } this->GetOutput()->SetPixel(idx, pixel); idx[0]++; } ++lit; } } template void LabelMapToSimulatedImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } //end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbLabelToProSailParameters.h000066400000000000000000000061751301006202600304430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelToProSailParameters_h #define otbLabelToProSailParameters_h #include "otbLabelToSimulationParametersBase.h" namespace otb { /** * \class LabelToProSailParameters * \brief Take a label corresponding to a spectrum type for vegetation and outputs the ProSail parameters needed to get a spectrum of that type. * * Output parameters concerns: * - Step1: parameters for PROSPECT simulation. * - Step2: parameters for SAIL simulation (see http://teledetection.ipgp.jussieu.fr/prosail/). * * WARNING: an only set of parameters is defined for all vegetation types. * * Prospect Parameters * Cab = 30; % chlorophyll content (ug.cm-2) * Car = 10; % carotenoid content (ug.cm-2) * Cbrown = 0.0; % brown pigment content (arbitrary units) * Cw = 0.015; % EWT (cm) * Cm = 0.009; % LMA (g.cm-2) * N = 1.2; % structure coefficient * * Sail Parameters * lai = 2; % leaf area index * angl = 50; % average leaf angle (deg) * psoil = 1; % soil coefficient * skyl = 70; % % diffuse/direct radiation * hspot = 0.2; % hot spot * ihot = 1.0; % * tts = 30; % solar zenith angle (deg) * tto = 0; % observer zenith angle (deg) * psi = 0; % azimuth (deg) * * * TODO : define different vegetation types and ProSail parameters associated. * * \sa LabelToSimulationParametersBase * * \ingroup OTBSimulation */ template class ITK_EXPORT LabelToProSailParameters : public LabelToSimulationParametersBase { public: /**Standard "Self" & Superclass typedef*/ typedef LabelToProSailParameters Self; typedef LabelToSimulationParametersBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef typename Superclass::ParametersType ParametersType; typedef typename Superclass::LabelType LabelType; /** Standard Macro*/ itkTypeMacro(LabelToProSailParameters, LabelToSimulationParametersBase); itkNewMacro(Self); // virtual const ParametersType & GetStep1Parameters(); //virtual const ParametersType & GetStep2Parameters(); void GenerateData() ITK_OVERRIDE; protected: LabelToProSailParameters(); ~LabelToProSailParameters() ITK_OVERRIDE {} private: LabelToProSailParameters(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelToProSailParameters.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbLabelToProSailParameters.txx000066400000000000000000000042471301006202600310350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelToProSailParameters_txx #define otbLabelToProSailParameters_txx #include "itkNumericTraits.h" #include "otbMacro.h" #include "otbLabelToProSailParameters.h" namespace otb { template LabelToProSailParameters ::LabelToProSailParameters() { //default parameters ParametersType Step1Parameters; ParametersType Step2Parameters; Step1Parameters.SetSize(6); Step2Parameters.SetSize(8); Step1Parameters[0] = 30.0; Step1Parameters[1] = 10.0; Step1Parameters[2] = 0.0; Step1Parameters[3] = 0.015; Step1Parameters[4] = 0.009; Step1Parameters[5] = 1.2; Step2Parameters[0] = 2; Step2Parameters[1] = 50; Step2Parameters[2] = 1; Step2Parameters[3] = 70; Step2Parameters[4] = 0.2; Step2Parameters[5] = 30; Step2Parameters[6] = 0; Step2Parameters[7] = 0; this->SetStep1Parameters(Step1Parameters); this->SetStep2Parameters(Step2Parameters); } //template //const typename LabelToProSailParameters::ParametersType & //LabelToProSailParameters //::GetStep1Parameters() //{ // return this->m_Step1Parameters; //} //template //const typename LabelToProSailParameters::ParametersType & //LabelToProSailParameters //::GetStep2Parameters() //{ // return this->m_Step2Parameters; //} template void LabelToProSailParameters ::GenerateData() { ParametersType Step1Parameters=this->GetStep1Parameters(); ParametersType Step2Parameters=this->GetStep2Parameters(); otbMsgDevMacro(<<" Step1Parameters"< class ITK_EXPORT LabelToSimulationParametersBase : public itk::ProcessObject { public: /**Standard "Self" & Superclass typedef*/ typedef LabelToSimulationParametersBase Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TLabel LabelType; typedef double ParametersValueType; typedef itk::Array ParametersType; /** Standard Macro*/ itkTypeMacro(LabelToSimulationParametersBase, ProcessObject); itkSetMacro(Label, LabelType); itkGetMacro(Label, LabelType); itkSetMacro(Step1Parameters, ParametersType); itkGetMacro(Step1Parameters, ParametersType); itkSetMacro(Step2Parameters, ParametersType); itkGetMacro(Step2Parameters, ParametersType); //virtual const ParametersType & GetStep1Parameters() = 0; //virtual const ParametersType & GetStep2Parameters() = 0; protected: LabelToSimulationParametersBase(){}; ~LabelToSimulationParametersBase() ITK_OVERRIDE {} private: LabelToSimulationParametersBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ParametersType m_Step1Parameters; ParametersType m_Step2Parameters; LabelType m_Label; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbLeafParameters.h000066400000000000000000000050671301006202600264750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLeafParameters_h #define otbLeafParameters_h #include "itkDataObject.h" #include "itkMacro.h" #include "itkObjectFactory.h" #include "OTBSimulationExport.h" namespace otb { /** \class LeafParameters * \brief Data class containing Leaf Parameters. * * \sa itk::DataObject * * \ingroup OTBSimulation */ class OTBSimulation_EXPORT LeafParameters : public itk::DataObject { public: /** Standard class typedefs */ typedef LeafParameters Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkTypeMacro(LeafParameters, DataObject); itkNewMacro(Self); /** Set/Get Chlorophyll content (ug/cm2)*/ itkSetMacro(Cab, double); itkGetMacro(Cab, double); /** Set/Get Carotenoid content (ug/cm2)*/ itkSetMacro(Car, double); itkGetMacro(Car, double); /** Set/Get Brown pigment content (arbitrary unit)*/ itkSetMacro(CBrown, double); itkGetMacro(CBrown, double); /** Set/Get equivalent leaf water thickness, EWT (cm)*/ itkSetMacro(Cw, double); itkGetMacro(Cw, double); /** Set/Get leaf dry matter, LMA (g/cm2)*/ itkSetMacro(Cm, double); itkGetMacro(Cm, double); /** Set/Get leaf structure coef*/ itkSetMacro(N, double); itkGetMacro(N, double); protected: /** Constructor */ LeafParameters(); /** Destructor */ ~LeafParameters() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LeafParameters(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented double m_Cab; //Chlorophyll content double m_Car; //Carotenoid content double m_CBrown; //Brown pigment content double m_Cw; //EWT double m_Cm; //LMA double m_N; //structure coef }; }// end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbProSailParameters.h000066400000000000000000000072721301006202600271770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProSailParameters_h #define otbProSailParameters_h #include "itkDataObject.h" #include "itkMacro.h" #include "itkObjectFactory.h" namespace otb { /** \class ProSailParameters * \brief this class implements the ProSailParameters lib. * * see http://teledetection.ipgp.jussieu.fr/prosail/ * \sa itk::DataObject * * \ingroup OTBSimulation */ class ITK_EXPORT ProSailParameters : public itk::DataObject { public: /** Standard class typedefs */ typedef ProSailParameters Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkTypeMacro(ProSailParameters, DataObject); itkNewMacro(Self); /** Set/Get Chlorophyll content (ug/cm2)*/ itkSetMacro(Cab, double); itkGetMacro(Cab, double); /** Set/Get Carotenoid content (ug/cm2)*/ itkSetMacro(Car, double); itkGetMacro(Car, double); /** Set/Get Brown pigment content (arbitrary unit)*/ itkSetMacro(CBrown, double); itkGetMacro(CBrown, double); /** Set/Get EWT (cm)*/ itkSetMacro(Cw, double); itkGetMacro(Cw, double); /** Set/Get LMA (g/cm2)*/ itkSetMacro(Cm, double); itkGetMacro(Cm, double); /** Set/Get structure coef*/ itkSetMacro(N, double); itkGetMacro(N, double); /** Set/Get leaf area index */ itkSetMacro(LAI, double); itkGetMacro(LAI, double); /** Set/Get average leaf angle (deg)*/ itkSetMacro(Angl, double); itkGetMacro(Angl, double); /** Set/Get soil coefficient*/ itkSetMacro(PSoil, double); itkGetMacro(PSoil, double); /** Set/Get diffuse/direct radiation*/ itkSetMacro(Skyl, double); itkGetMacro(Skyl, double); /** Set/Get hot spot */ itkSetMacro(HSpot, double); itkGetMacro(HSpot, double); /** Set/Get solar zenith angle (deg) */ itkSetMacro(TTS, double); itkGetMacro(TTS, double); /** Set/Get observer zenith angle (deg) */ itkSetMacro(TTO, double); itkGetMacro(TTO, double); /** Set/Get azimuth(deg) */ itkSetMacro(PSI, double); itkGetMacro(PSI, double); protected: /** Constructor */ ProSailParameters(); /** Destructor */ virtual ~ProSailParameters() {}; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const; private: ProSailParameters(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented double m_Cab; //Chlorophyll content double m_Car; //Carotenoid content double m_CBrown; //Brown pigment content double m_Cw; //EWT double m_Cm; //LMA double m_N; //structure coef double m_LAI; //leaf area index double m_Angl; //average leaf angle double m_PSoil; //soil coefficient double m_Skyl; //diffuse/direct radiation double m_HSpot; //hot spot double m_TTS; //solar zenith angle double m_TTO; //observer zenith angle double m_PSI; //azimuth }; }// end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbProspectModel.h000066400000000000000000000056251301006202600263620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProspectModel_h #define otbProspectModel_h #include "OTBSimulationExport.h" #include "otbLeafParameters.h" #include "otbDataSpecP5B.h" #include "otbSimulationStep1Base.h" namespace otb { /** \class ProspectModel * \brief This class implements the Prospect Model (see http://teledetection.ipgp.jussieu.fr/prosail/), * * It computes leaf reflectance and transmittance from a set of parameters (contained in a LeafParameters class) * * \sa itk::DataObject * \sa SimulationStep1Base * * \ingroup OTBSimulation */ class OTBSimulation_EXPORT ProspectModel : public SimulationStep1Base { public: /** Standard class typedefs */ typedef ProspectModel Self; typedef SimulationStep1Base Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::LeafParameters LeafParametersType; typedef Superclass::SpectralResponseType SpectralResponseType; typedef Superclass::ParametersType ParametersType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Standard macros */ itkNewMacro(Self); itkTypeMacro(ProspectModel, SpectrumGeneratorBase); /** Set/Get Input */ using Superclass::SetInput; virtual void SetInput(const ParametersType &); void SetInput(const LeafParametersType *object); LeafParametersType * GetInput(); /** GenerateData */ void GenerateData() ITK_OVERRIDE; /** Get Output reflectance/transmittance*/ SpectralResponseType * GetReflectance() ITK_OVERRIDE; SpectralResponseType * GetTransmittance() ITK_OVERRIDE; protected: /** Constructor */ ProspectModel(); /** Destructor */ ~ProspectModel() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE; using Superclass::MakeOutput; /** Compute Transmission of isotropic radiation across an interface between two dielectrics*/ double Tav(const int theta, double ref); private: ProspectModel(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; }// end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbReduceSpectralResponse.h000066400000000000000000000124171301006202600302230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReduceSpectralResponse_h #define otbReduceSpectralResponse_h #include "itkDataObject.h" #include #include #include #include #include namespace otb { /** \class ReduceSpectralResponse * \brief This class computes the reduced spectral response of each band of a sensor * * It takes the spectral response of an object and the relative * spectral response of a satellite (one response per band) to * compute the satellite spectral bands. * * There are 2 operating modes: * - luminance mode (default): integrates the spectral response over each band * - reflectance mode (needs to call SetReflectanceMode(true)): takes into account * the solar irradiance in the integration * * The two templates indicate: * - the SpectralResponse input * - the relative spectral response (RSR) of a sensor * * The computation assumes that the RSR of the sensor has a * wavelength resolution similar or better than the spectral * response to be reduced. If this is not the case, it is wise to * oversample it (by linear interpolation, for instance). * * The method CalculateResponse must be called. * * \sa itk::DataObject * \sa SpectralResponse * \sa SatelliteRSR * * * \ingroup OTBSimulation */ template class ReduceSpectralResponse : public itk::DataObject { public: /** Standard class typedefs */ typedef ReduceSpectralResponse Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Template parameters typedef */ typedef TSpectralResponse InputSpectralResponseType; typedef TRSR InputRSRType; typedef typename InputSpectralResponseType::PairType PairType; typedef typename InputRSRType::Pointer InputRSRPointerType; typedef typename InputSpectralResponseType::Pointer InputSpectralResponsePointerType; typedef typename InputRSRType::PrecisionType PrecisionType; typedef typename InputRSRType::ValuePrecisionType ValuePrecisionType; typedef typename InputSpectralResponseType::VectorPairType VectorPairType; //TODO need a specific class for the integration of stectral responses (now it is in the functor) typedef typename InputRSRType::RSRVectorType RSRVectorType; typedef typename std::vector ReduceSpectralResponseVectorType; /** Standard macros */ itkNewMacro(Self) ; itkTypeMacro(ReduceSpectralResponse, DataObject) ; itkGetConstObjectMacro(InputSatRSR, InputRSRType) ; itkSetObjectMacro(InputSatRSR, InputRSRType) ; itkGetConstObjectMacro(InputSpectralResponse, InputSpectralResponseType) ; itkSetObjectMacro(InputSpectralResponse, InputSpectralResponseType) ; /** The GetReduceResponse method gives the output. The first value in the pair is the central wavelength of the band (see SpectralResponse). */ itkGetObjectMacro(ReduceResponse, InputSpectralResponseType) ; itkSetMacro(ReflectanceMode, bool); itkGetConstMacro(ReflectanceMode, bool); /** Clear the vector data */ virtual bool Clear(); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * \param PrecisionType * \return The integrated value of the RSR for the input spectral response. */ inline ValuePrecisionType operator()(const unsigned int numBand); /** Calculate the vector response for each band of the sensor*/ void CalculateResponse(); /** Create and load Spectral response and satellite RSR from files*/ void LoadInputsFromFiles(const std::string & spectralResponseFile, const std::string & RSRFile, const unsigned int nbRSRBands, ValuePrecisionType coefNormSpectre = 1.0, ValuePrecisionType coefNormRSR = 1.0); protected: /** Constructor */ ReduceSpectralResponse(); /** Constructor from a ASCII file */ //ReduceSpectralResponse( const std::string & filename ); /** Destructor */ ~ReduceSpectralResponse() ITK_OVERRIDE { } ; /** PrintSelf method */ //void PrintSelf(std::ostream& os, itk::Indent indent) const; /** Input relative spectral sensor model of response */ InputRSRPointerType m_InputSatRSR; /** Input spectral response (usually from a library) */ InputSpectralResponsePointerType m_InputSpectralResponse; private: ReduceSpectralResponse(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** the computed response */ InputSpectralResponsePointerType m_ReduceResponse; /** Choose between reflectance or luminance mode */ bool m_ReflectanceMode; }; }// end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbReduceSpectralResponse.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbReduceSpectralResponse.txx000066400000000000000000000154571301006202600306260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReduceSpectralResponse_txx #define otbReduceSpectralResponse_txx #include #include "itkNumericTraits.h" #include "otbReduceSpectralResponse.h" namespace otb { template ReduceSpectralResponse ::ReduceSpectralResponse() : m_ReflectanceMode(false) { m_ReduceResponse = InputSpectralResponseType::New(); } template bool ReduceSpectralResponse ::Clear() { return ( m_InputSatRSR->Clear() & m_InputSpectralResponse->Clear() ); } template inline T trapezoid_area(T x1, T x2, T y1, T y2) { /* We compute the area of the trapezoid by computing the lower square and the upper triangle. /- |y2 /- | /- | /- | y1 +----------+ | | | | | | +----------+ x1 x2 (x2-x1)*min(y1,y2) + (x2-x1)*abs(y2-y1)/2 */ return (x2-x1)*std::min(y1,y2) + (x2-x1)*fabs(y2-y1)*0.5; } template inline typename ReduceSpectralResponse::ValuePrecisionType ReduceSpectralResponse ::operator()(const unsigned int numBand) { if (numBand >= m_InputSatRSR->GetNbBands()) { itkExceptionMacro(<< "There is no band num " << numBand << " in the RSR vector!(Size of the current RSR vector is " << m_InputSatRSR->GetNbBands() << ")" ); } else { ValuePrecisionType res = itk::NumericTraits::ZeroValue(); typename InputRSRType::SpectralResponseType* solarIrradiance = this->m_InputSatRSR->GetSolarIrradiance(); if(m_ReflectanceMode) { if (solarIrradiance == ITK_NULLPTR) { itkExceptionMacro(<<"Error occurs getting solar irradiance. Solar irradiance is mandatory using the reflectance mode."); } } typename VectorPairType::const_iterator it; VectorPairType pairs = (m_InputSatRSR->GetRSR())[numBand]->GetResponse(); it = pairs.begin(); ValuePrecisionType totalArea(0); //start with the second value for the numerical integration ++it; while (it != pairs.end()) { PrecisionType lambda1 = (*(it-1)).first; PrecisionType lambda2 = (*it).first; // PrecisionType deltaLambda = lambda2-lambda1; ValuePrecisionType rsr1 = (*(it-1)).second; ValuePrecisionType rsr2 = (*it).second; ValuePrecisionType spectrum1 = (*m_InputSpectralResponse)(lambda1); ValuePrecisionType spectrum2 = (*m_InputSpectralResponse)(lambda2); /* In order to simplify the computation for the reflectance mode, we introduce the solar irradiance in the general formula with a value of 1.0 for the luminance case. In this way the formula is the same if we weight the RSR by the solar irradiance before the integration. */ ValuePrecisionType solarIrradiance1(1.0); ValuePrecisionType solarIrradiance2(1.0); if(m_ReflectanceMode) { solarIrradiance1 = (*solarIrradiance)(lambda1); solarIrradiance2 = (*solarIrradiance)(lambda2); } rsr1 *= solarIrradiance1; rsr2 *= solarIrradiance2; res += trapezoid_area(lambda1, lambda2, rsr1*spectrum1, rsr2*spectrum2); totalArea += trapezoid_area(lambda1, lambda2, rsr1, rsr2); ++it; } return res / totalArea; } } template void ReduceSpectralResponse ::CalculateResponse() { m_ReduceResponse->Clear(); //Compute the reduce response for each band of the sensor for (unsigned int i=0; iGetNbBands(); ++i) { m_InputSpectralResponse->SetPosGuessMin((this->m_InputSatRSR->GetRSR())[i]->GetInterval().first); m_InputSpectralResponse->SetUsePosGuess(true); PairType pair; //pair.first = center wavelength of the band pair.first = ((this->m_InputSatRSR->GetRSR())[i]->GetInterval().first + (this->m_InputSatRSR->GetRSR())[i]->GetInterval().second); pair.first = pair.first / 2.0; pair.second = (*this)(i); m_ReduceResponse->GetResponse().push_back(pair); m_InputSpectralResponse->SetUsePosGuess(false); } } template void ReduceSpectralResponse ::LoadInputsFromFiles (const std::string & spectralResponseFile, const std::string & RSRFile, const unsigned int nbRSRBands, ValuePrecisionType coefNormSpectre, ValuePrecisionType coefNormRSR) { //Instantiation m_InputSpectralResponse=InputSpectralResponseType::New(); /** Load the spectral response file*/ m_InputSpectralResponse->Load(spectralResponseFile, coefNormSpectre); m_InputSatRSR=InputRSRType::New(); /** Set the satellite number of bands */ m_InputSatRSR->SetNbBands(nbRSRBands); /** Load the satellite response file*/ m_InputSatRSR->Load(RSRFile, coefNormRSR); } template void ReduceSpectralResponse ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os<m_InputSatRSR->GetSolarIrradiance()->PrintSelf(os, indent); os<GetResponse().begin(); it != m_ReduceResponse->GetResponse().end(); ++it) { os <GetResponse().begin() << ": [" << (*it).first << ","<< (*it).second << "]" << std::endl; } } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbReduceSpectralResponseClassifierRAndNIR.h000066400000000000000000000131131301006202600333400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReduceSpectralResponseClassifierRAndNIR_h #define otbReduceSpectralResponseClassifierRAndNIR_h #include "otbReduceSpectralResponse.h" #include "otbVegetationIndicesFunctor.h" namespace otb { /** \class ReduceSpectralResponseClassifierRAndNIR * \brief this class represents a hierarchy of vector data. * * This class contains the spectral response from an object and the relative spectral * response of a satellite (one response per band) * * This class compute the reduce spectral response of each band of a sensor * * The two templates indicate * - the SpectralResponse input (from the JPL ASTER spectral library for example) * - the relative spectral response of a sensor * * The elements in the ReduceSpectralResponseClassifierRAndNIR have their coordinates in the projection * specified by the Wkt string. This class also offer the possibility to store * the coordinates directly into an image coordinate system, using the origin and * spacing in a similar way as the corresponding image. * * \sa itk::DataObject * \sa SpectralResponse * \sa SatelliteRSR * * * \ingroup OTBSimulation */ template > class ReduceSpectralResponseClassifierRAndNIR : public itk::DataObject { //friend class public: /** Standard class typedefs */ typedef ReduceSpectralResponseClassifierRAndNIR Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Template parameters typedef */ typedef TReduceSpectralResponse InputReduceSpectralResponseType; typedef TFunction FunctorType; typedef typename TReduceSpectralResponse::Pointer InputReduceSpectralResponsePointerType; typedef typename InputReduceSpectralResponseType::ValuePrecisionType ValuePrecisionType; /** Standard macros */ itkNewMacro(Self); itkTypeMacro(ReduceSpectralResponseClassifierRAndNIR, DataObject); itkGetConstObjectMacro(InputReduceSpectralResponse, InputReduceSpectralResponseType); itkSetObjectMacro(InputReduceSpectralResponse, InputReduceSpectralResponseType); itkGetConstMacro(RBandNumber, unsigned int); itkSetMacro(RBandNumber, unsigned int); itkGetConstMacro(NIRBandNumber, unsigned int); itkSetMacro(NIRBandNumber, unsigned int); /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType& GetFunctor() { return m_Functor; }; /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType& functor) { m_Functor = functor; } /** Clear the vector data */ virtual bool Clear(); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * \param ValuePrecisionType * \return the indice value. */ inline ValuePrecisionType operator()(); protected: /** Constructor */ ReduceSpectralResponseClassifierRAndNIR(); /** Constructor from a ASCII file */ //ReduceSpectralResponseClassifierRAndNIR( const std::string & filename ); /** Destructor */ ~ReduceSpectralResponseClassifierRAndNIR() ITK_OVERRIDE {}; /** PrintSelf method */ //void PrintSelf(std::ostream& os, itk::Indent indent) const; private: ReduceSpectralResponseClassifierRAndNIR(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Input reduce spectral sensor model of response */ InputReduceSpectralResponsePointerType m_InputReduceSpectralResponse; /** Number of the red band in the ReduceSpectralResponse vector */ unsigned int m_RBandNumber; /** Number of the NIR band in the ReduceSpectralResponse vector */ unsigned int m_NIRBandNumber; /** Indice classifier */ FunctorType m_Functor; }; }// end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbReduceSpectralResponseClassifierRAndNIR.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbReduceSpectralResponseClassifierRAndNIR.txx000066400000000000000000000036471301006202600337470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbReduceSpectralResponseClassifierRAndNIR_txx #define otbReduceSpectralResponseClassifierRAndNIR_txx #include "otbReduceSpectralResponseClassifierRAndNIR.h" #include namespace otb { template ReduceSpectralResponseClassifierRAndNIR ::ReduceSpectralResponseClassifierRAndNIR() { //m_Response = VectorType::New(); } template bool ReduceSpectralResponseClassifierRAndNIR ::Clear() { return ( m_InputReduceSpectralResponse->Clear() ); } template inline typename ReduceSpectralResponseClassifierRAndNIR ::ValuePrecisionType ReduceSpectralResponseClassifierRAndNIR ::operator()() { return m_Functor((*m_InputReduceSpectralResponse)(m_RBandNumber), (*m_InputReduceSpectralResponse)(m_NIRBandNumber)); } template void ReduceSpectralResponseClassifierRAndNIR ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSailModel.h000066400000000000000000000117511301006202600254500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSailModel_h #define otbSailModel_h #include "OTBSimulationExport.h" #include "otbSpectralResponse.h" #include "otbDataSpecP5B.h" #include "otbSimulationStep2Base.h" namespace otb { /** \class SailModel * \brief This class implements the SAIL model (see http://teledetection.ipgp.jussieu.fr/prosail/). * * Hemispherical and viewing reflectances and absorptances are computed from 400 to 2500 nm (step 1nm). * Input Reflectance and transmittance must be spectrum (otbSpectralResponse) from 400 nm to 2500 nm with step 1nm. * \sa itk::ProcessObject * \sa SimulationStep2Base * * \ingroup OTBSimulation */ class OTBSimulation_EXPORT SailModel : public SimulationStep2Base { public: /** Standard class typedefs */ typedef SailModel Self; typedef SimulationStep2Base Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef Superclass::SpectralResponseType SpectralResponseType; typedef std::vector VectorType; typedef Superclass::ParametersType ParametersType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Standard macros */ itkNewMacro(Self); itkTypeMacro(SailModel, ProcessObject); /** Set Inputs */ void SetReflectance(const SpectralResponseType *object) ITK_OVERRIDE; SpectralResponseType * GetReflectance(); void SetTransmittance(const SpectralResponseType *object) ITK_OVERRIDE; SpectralResponseType * GetTransmittance(); /** Set parameters */ /** Set/Get leaf area index */ itkSetMacro(LAI, double); itkGetMacro(LAI, double); /** Set/Get average leaf angle (deg)*/ itkSetMacro(Angl, double); itkGetMacro(Angl, double); /** Set/Get soil coefficient*/ itkSetMacro(PSoil, double); itkGetMacro(PSoil, double); /** Set/Get diffuse/direct radiation*/ itkSetMacro(Skyl, double); itkGetMacro(Skyl, double); /** Set/Get hot spot */ itkSetMacro(HSpot, double); itkGetMacro(HSpot, double); /** Set/Get solar zenith angle (deg) */ itkSetMacro(TTS, double); itkGetMacro(TTS, double); /** Set/Get observer zenith angle (deg) */ itkSetMacro(TTO, double); itkGetMacro(TTO, double); /** Set/Get azimuth(deg) */ itkSetMacro(PSI, double); itkGetMacro(PSI, double); /** Get the computed fcover */ itkGetMacro(FCoverView, double); /** GenerateData */ void GenerateData() ITK_OVERRIDE; /** Get Output */ virtual SpectralResponseType * GetViewingReflectance(); virtual SpectralResponseType * GetHemisphericalReflectance(); virtual SpectralResponseType * GetViewingAbsorptance(); virtual SpectralResponseType * GetHemisphericalAbsorptance(); const ParametersType GetInput(); void SetInput(const ParametersType &); using Superclass::SetInput; protected: /** Constructor */ SailModel(); /** Destructor */ ~SailModel() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE; using Superclass::MakeOutput; /** Compute Leaf Angle Distribution */ void Calc_LIDF(const double a, VectorType &lidf); void Campbell(const double ala, VectorType &freq); /** J functions */ double Jfunc1(const double k, const double l, const double t); double Jfunc2(const double k, const double l, const double t); double Jfunc3(const double k, const double l, const double t); /** Volscatt */ void Volscatt(const double tts, const double tto, const double psi, const double ttl, VectorType &result); private: SailModel(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented double m_LAI; //leaf area index double m_Angl; //average leaf angle double m_PSoil; //soil coefficient double m_Skyl; //diffuse/direct radiation double m_HSpot; //hot spot double m_TTS; //solar zenith angle double m_TTO; //observer zenith angle double m_PSI; //azimuth double m_FCoverView; //fCover in the viewing direction }; }// end namespace otb #ifndef OTB_MANUAL_INSTANTIATION // #include "otbSailModel.cxx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSatelliteRSR.h000066400000000000000000000111311301006202600261040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSatelliteRSR_h #define otbSatelliteRSR_h #include #include #include #include #include "otbSpectralResponse.h" namespace otb { /** \class SatelliteRSR * \brief This class represents a hierarchy of vector data. * * This class contains an std::vector of spectral response, class otb::SpectralResponse (one for each band of the satellite). * * * The two templates indicate: * - the precision of the wavelength (X) (by default: double) * - the precision of the gain associated to the wavelength (Y) (by default: double) * \sa SpectralResponse * \sa itk::DataObject * * \ingroup OTBSimulation */ template class SatelliteRSR: public itk::DataObject { public: /** Standard class typedefs */ typedef SatelliteRSR Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macros */ itkNewMacro(Self) ; itkTypeMacro(SatelliteRSR, DataObject) ; /** Set the number of band of the satellite from an ASCII file * Need to parse first all the file to determine the number of columns */ itkGetConstMacro(NbBands, unsigned int) ; itkSetMacro(NbBands, unsigned int) ; itkSetMacro(SortBands, bool) ; /** Template parameters typedef */ typedef TPrecision PrecisionType; typedef TValuePrecision ValuePrecisionType; typedef SpectralResponse SpectralResponseType; typedef typename SpectralResponseType::Pointer SpectralResponsePointerType; typedef std::vector RSRVectorType; typedef typename SpectralResponseType::VectorPairType VectorPairType; /** Clear the vector data */ virtual bool Clear(); /** Return the number of element in the vector (nb bands) */ virtual int Size() const; /** Fill from a ASCII file (spectral gauge)*/ void Load(const std::string & filename, ValuePrecisionType coefNormalization = 1.0); /** Fill from user defined criteria (sampling band from lambdaMin to lambdaMax with Bandwidth width) */ void Load(PrecisionType lambdaMin, PrecisionType lambdaMax, PrecisionType sampling, ValuePrecisionType coefNormalization = 1.0); /** Compare RSR response (order bands from high to low frequency)*/ struct sort_band { bool operator()(SpectralResponsePointerType a, SpectralResponsePointerType b) { PrecisionType aFirstNotNull; PrecisionType bFirstNotNull; typename VectorPairType::const_iterator it = a->GetResponse().begin(); while ((*it).second == 0) { ++it; } aFirstNotNull = (*it).first; typename VectorPairType::const_iterator it2 = b->GetResponse().begin(); while ((*it2).second == 0) { ++it2; } bFirstNotNull = (*it2).first; return aFirstNotNull < bFirstNotNull; } }; /** * \param PrecisionType * \param Band * \return The interpolated value of the SR for the numBand (band num 0 to band num (m_NbBands-1)). */ inline ValuePrecisionType operator()(const PrecisionType & lambda, const unsigned int numBand); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** get vector of RSR */ RSRVectorType & GetRSR() { return m_RSR; } /** get the solar irradiance */ SpectralResponseType* GetSolarIrradiance() { return m_SolarIrradiance; } protected: /** Constructor */ SatelliteRSR(); /** Constructor from a ASCII file */ //SatelliteRSR( const std::string & filename ); /** Destructor */ ~SatelliteRSR() ITK_OVERRIDE { } ; bool m_SortBands; private: SatelliteRSR(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Vector of SpectralResponse */ RSRVectorType m_RSR; /** Solar irradiance vector */ SpectralResponsePointerType m_SolarIrradiance; /** Number of bands*/ unsigned int m_NbBands; }; }// end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSatelliteRSR.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSatelliteRSR.txx000066400000000000000000000121061301006202600265030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSatelliteRSR_txx #define otbSatelliteRSR_txx #include "otbSatelliteRSR.h" namespace otb { template SatelliteRSR::SatelliteRSR() { //m_RSR = VectorType::New(); m_SortBands = true; m_SolarIrradiance = SpectralResponseType::New(); } template void SatelliteRSR::Load(const std::string & filename, ValuePrecisionType coefNormalization) { //Parse 6S file Reduce spectral response //Begin by getting the number of band of the satellite //unsigned int nbBands= this->SetNbBands ( filename ); std::ifstream fin(filename.c_str()); if (fin.fail()) { itkExceptionMacro(<<"Error opening file" << filename); } // For each band for (unsigned int i = 0; i < m_NbBands; ++i) { //Create a SpectralResponse for the band i SpectralResponsePointerType RSRBand = SpectralResponseType::New(); m_RSR.push_back(RSRBand); } PrecisionType currentLambda; PrecisionType solarIrradiance; while (!fin.eof()) { //Parse the 6S.txt file fin >> currentLambda; fin >> solarIrradiance; m_SolarIrradiance->GetResponse().push_back(std::make_pair(currentLambda, solarIrradiance)); //for each band add a pair of values (wavelength and % response) for (unsigned int i = 0; i < m_NbBands; ++i) { std::pair currentPair; currentPair.first = currentLambda; fin >> currentPair.second; currentPair.second = currentPair.second / coefNormalization; //Include only non null value //TODO m_RSR[i]->GetResponse().push_back(currentPair); } } fin.close(); if (m_SortBands) { //Sort the vector of SpectralResponse (band order by minimum wavelength first not null response std::sort(m_RSR.begin(), m_RSR.end(), sort_band()); } } template void SatelliteRSR::Load(PrecisionType lambdaMin, PrecisionType lambdaMax, PrecisionType sampling, ValuePrecisionType coefNormalization) { m_NbBands = 1; const double wavelengthPrecision = 0.0025; //in um if (0 == sampling) { sampling = wavelengthPrecision; } // For each band for (unsigned int i = 0; i < m_NbBands; ++i) { //Create a SpectralResponse for the band i SpectralResponsePointerType RSRBand = SpectralResponseType::New(); m_RSR.push_back(RSRBand); } PrecisionType currentLambda; ValuePrecisionType value = 1.0; for (double j = lambdaMin; j < lambdaMax; j = j + sampling) { currentLambda = j; std::pair currentPair; currentPair.first = currentLambda; currentPair.second = value / coefNormalization; m_RSR[0]->GetResponse().push_back(currentPair); } } template bool SatelliteRSR::Clear() { m_RSR.clear(); return true; } template int SatelliteRSR::Size() const { return m_RSR.size(); } template inline typename SatelliteRSR::ValuePrecisionType SatelliteRSR::operator()( const PrecisionType & lambda, const unsigned int numBand) { //Get the response of the band number numBand at the wavelenght lambda if (numBand >= m_NbBands) { itkExceptionMacro(<<"There is no band num " << numBand<< " in the RSR vector!(Size of the current RSR vector is " << m_NbBands <<")"); } else { return (*(m_RSR[numBand]))(lambda); } } template void SatelliteRSR::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << std::endl; //typename VectorPairType::iterator it = m_RSR.begin(); //it = m_RSR.at(0); for (typename RSRVectorType::const_iterator it = m_RSR.begin(); it != m_RSR.end(); ++it) { os << indent << "Band Number " << it - m_RSR.begin() << std::endl; (*it)->PrintSelf(os, indent); os << std::endl; } } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSimulationStep1Base.h000066400000000000000000000042121301006202600274250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimulationStep1Base_h #define otbSimulationStep1Base_h #include "itkProcessObject.h" #include "otbSpectralResponse.h" namespace otb { /** * \class SimulationStep1Base * \brief Base class for all method that simulate the Reflectance and Transmittance of an object. (ex: Prospect) * * \sa ProcessObject * * \ingroup OTBSimulation */ class ITK_EXPORT SimulationStep1Base : public itk::ProcessObject { public: /**Standard "Self" & Superclass typedef*/ typedef SimulationStep1Base Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef double ParametersValueType; typedef itk::Array ParametersType; typedef otb::SpectralResponse SpectralResponseType; /** Standard Macro*/ itkTypeMacro(SimulationStep1Base, ProcessObject); itkSetMacro(Parameters, ParametersType) itkGetMacro(Parameters, ParametersType) //virtual void SetInput(const ParametersType &) = 0; virtual SpectralResponseType * GetReflectance() = 0; virtual SpectralResponseType * GetTransmittance() = 0; protected: SimulationStep1Base(){}; ~SimulationStep1Base() ITK_OVERRIDE {} private: SimulationStep1Base(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ParametersType m_Parameters; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSimulationStep2Base.h000066400000000000000000000041051301006202600274270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSimulationStep2Base_h #define otbSimulationStep2Base_h #include "itkProcessObject.h" #include "otbSpectralResponse.h" namespace otb { /** * \class SimulationStep2Base * \brief Base class for all methods that generate spectrum of an object using its reflectance and transmittance * \brief (ex: Sail http://teledetection.ipgp.jussieu.fr/prosail/). * * \sa ProcessObject * * \ingroup OTBSimulation */ class ITK_EXPORT SimulationStep2Base : public itk::ProcessObject { public: /**Standard "Self" & Superclass typedef*/ typedef SimulationStep2Base Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef SpectralResponse SpectralResponseType; typedef double ParametersValueType; typedef itk::Array ParametersType; /** Standard Macro*/ itkTypeMacro(SimulationStep2Base, ProcessObject) ; itkSetMacro(Parameters, ParametersType) itkGetMacro(Parameters, ParametersType) //; virtual void SetReflectance(const SpectralResponseType *) = 0; virtual void SetTransmittance(const SpectralResponseType *) = 0; protected: SimulationStep2Base() { } ; ~SimulationStep2Base() ITK_OVERRIDE { } private: SimulationStep2Base(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented ParametersType m_Parameters; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSpatialisationFilter.h000066400000000000000000000112021301006202600277200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpatialisationFilter_h #define otbSpatialisationFilter_h #include "itkLabelObject.h" #include "otbLabelMapSource.h" #include "itkSize.h" #include "itkImageRegionIterator.h" #include "otbImage.h" namespace otb { /** * \class SpatialisationFilter * \brief Create a label map from objects description. * * Objects are described by: * - Vector of area: indicating the spectral type of the object (rock, grass, forest, ..). * - Vector of paths: indicating the path of files containing associated spectra or "" if spectrum will be simulated. * * SpatialisationFilter creates a labelMap containing NumberOfObjects[0]*NumberOfObject[1] objects (number of objects by line, number of objects by column). * Each object is rectangular of size ObjectSize. * Two attributes "path" and "area" are added to each object using SetPathVector and SetAreaVector. * The Label of each object is set using SetLabels. * * \sa LabelMapSource * * \ingroup OTBSimulation */ template class ITK_EXPORT SpatialisationFilter : public LabelMapSource { public: /** * Standard "Self" & Superclass typedef. */ typedef SpatialisationFilter Self; typedef LabelMapSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TLabelMap OutputLabelMapType; typedef typename OutputLabelMapType::Pointer OutputLabelMapPointer; typedef typename OutputLabelMapType::ConstPointer OutputLabelMapConstPointer; typedef typename OutputLabelMapType::IndexType IndexType; typedef typename OutputLabelMapType::RegionType RegionType; typedef typename OutputLabelMapType::LabelObjectType::LabelType LabelType; typedef typename OutputLabelMapType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::AttributesValueType AttributesValueType; typedef itk::Size<2> SizeType; typedef std::vector VectorType; typedef std::vector LabelVectorType; /** Standard Macro*/ itkTypeMacro(SpatialisationFilter, LabelMapSource); itkNewMacro(Self); /**Set input vector data*/ itkSetMacro(ObjectSize, SizeType); itkGetMacro(ObjectSize, SizeType); itkSetMacro(NumberOfObjects, SizeType); itkGetMacro(NumberOfObjects, SizeType); // itkSetMacro(PathVector, VectorType); // itkGetMacro(PathVector, VectorType); // // itkSetMacro(AreaVector, VectorType); // itkGetMacro(AreaVector, VectorType); void SetPathVector(VectorType & v) { m_PathVector=v; } void SetAreaVector(VectorType & v) { m_AreaVector=v; } void SetLabels(LabelVectorType & v) { m_Labels=v; } protected: SpatialisationFilter(); ~SpatialisationFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; virtual void ProcessObject(unsigned int obj); void GenerateOutputInformation() ITK_OVERRIDE; private: SpatialisationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Common size for all objects in number of pixels (number of rows, number of columns).*/ SizeType m_ObjectSize; /** Number of objects contained in the image (number of objects by line, number of objects by column).*/ SizeType m_NumberOfObjects; /**Vector containing the path for spectra files (if any) for each object. */ /** If no path is given (empty path: "") spectrum is simulated from default parameters.*/ VectorType m_PathVector; //vector containing the spectrum path (if any) for each object /** Vector containing the spectral type of each object.*/ VectorType m_AreaVector; //vector containing the the type of each object /** Vector containing the label of each object (ex.: 1, 2, 25, etc.).*/ LabelVectorType m_Labels; //vector containing the label of each object. }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbSpatialisationFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSpatialisationFilter.txx000066400000000000000000000067131301006202600303270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpatialisationFilter_txx #define otbSpatialisationFilter_txx #include "itkNumericTraits.h" #include "otbSpatialisationFilter.h" namespace otb { template SpatialisationFilter ::SpatialisationFilter() { //default value } template void SpatialisationFilter ::GenerateData() { if (m_AreaVector.size() != (m_NumberOfObjects[0] * m_NumberOfObjects[1])) { itkExceptionMacro( << "Size problem : AreaVector size must be equal to "<< m_NumberOfObjects[0]*m_NumberOfObjects[1] ); } if (m_PathVector.size() != (m_NumberOfObjects[0] * m_NumberOfObjects[1])) { itkExceptionMacro( << "Size problem : PathVector size must be equal to "<< m_NumberOfObjects[0]*m_NumberOfObjects[1] ); } if (m_Labels.size() != (m_NumberOfObjects[0] * m_NumberOfObjects[1])) { itkExceptionMacro( << "Size problem : Labels size must be equal to "<< m_NumberOfObjects[0]*m_NumberOfObjects[1] ); } unsigned int numberOfObjects = m_NumberOfObjects[0] * m_NumberOfObjects[1]; //first object must have label 1. 0 is for background value in a label map. for (unsigned int i = 0; i < numberOfObjects; ++i) { this->ProcessObject(i); } } template void SpatialisationFilter ::ProcessObject(unsigned int obj) { IndexType index; IndexType startIndex; startIndex[1]= static_cast ( ((obj) / m_NumberOfObjects[0]) * m_ObjectSize[1] ); startIndex[0]= static_cast ( ((obj) % m_NumberOfObjects[0]) * m_ObjectSize[0] ); for(unsigned int col=startIndex[0]; colGetOutput()->AddPixel(index, m_Labels[obj]); } } this->GetOutput()->GetLabelObject(m_Labels[obj])->SetAttribute( "area", m_AreaVector[obj] ); if(m_PathVector[obj]!="") this->GetOutput()->GetLabelObject(m_Labels[obj])->SetAttribute( "path", m_PathVector[obj] ); } template void SpatialisationFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); RegionType region; SizeType size; IndexType index; index.Fill(0); size[0] = m_ObjectSize[0] * m_NumberOfObjects[0]; size[1] = m_ObjectSize[1] * m_NumberOfObjects[1]; region.SetSize(size); region.SetIndex(index); // RegionType requestedRegion; // size[0]=m_ObjectSize[0]; // size[1]=m_ObjectSize[1]; // requestedRegion.SetSize(size); // requestedRegion.SetIndex(index); this->GetOutput()->SetLargestPossibleRegion(region); // this->GetOutput()->SetRequestedRegion(requestedRegion); } template void SpatialisationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSpectralResponse.h000066400000000000000000000130521301006202600270670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralResponse_h #define otbSpectralResponse_h #include "itkDataObject.h" #include #include #include #include #include #include "otbVectorImage.h" #include "itkImageRegionIterator.h" #include "otbAtmosphericCorrectionParameters.h" #include namespace otb { /** \class SpectralResponse * \brief This class represents the spectral response of an object (or a satellite band). * * This class contains a SORTED std::vector of std::pair values. * The first argument of the pair is a wavelength lambda (in micro meters). * The second argument of the pair is the reflectance response associated to lambda. * * The two templates indicate: * - the precision of the wavelength (X) (by default: double), * - the precision of the reflectance associated to the wavelength (Y) (by default: double). * * This Spectral response can be loaded from ASCII file (JPL spectral library Version 1.2) * http://speclib.jpl.nasa.gov. * \sa itk::DataObject * * \ingroup OTBSimulation */ template class SpectralResponse: public itk::DataObject { public: /** Standard class typedefs */ typedef SpectralResponse Self; typedef itk::DataObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Template parameters typedef */ typedef TPrecision PrecisionType; typedef TValuePrecision ValuePrecisionType; typedef std::pair PairType; //typedef boost::shared_ptr PairPointerType; typedef typename std::vector VectorPairType; /** Standard image typedef */ typedef otb::VectorImage ImageType; typedef typename ImageType::Pointer ImagePointerType; typedef itk::ImageRegionIterator IteratorType; /** Standard filter functions values typedef */ typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef itk::SmartPointer FilterFunctionValuesPointerType; typedef std::pair IntervalType; /** Standard macros */ itkNewMacro(Self); itkTypeMacro(SpectralResponse, DataObject); itkSetMacro(SensitivityThreshold, TPrecision); itkGetConstMacro(SensitivityThreshold, TPrecision); itkSetMacro(UsePosGuess, bool); itkGetConstMacro(UsePosGuess, bool); /** Clear the vector of data pairs */ virtual bool Clear(); /** Return the number of element in the vector (number of pairs) */ virtual unsigned int Size() const; /** Fill from a ASCII file (CD-ROM ASTER Spectral library Version 1.2)*/ void Load(const std::string & filename, ValuePrecisionType coefNormalization = 1.0); /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** get vector of spectral responses */ VectorPairType & GetResponse() { return m_Response; } void SetResponse(const VectorPairType& resp) { m_Response = resp; } /** * \param PrecisionType * \return The interpolate value of the SR (for now a simple linear interpolation is used). */ inline ValuePrecisionType operator()(const PrecisionType & lambda); /** Operator for comparing Pair Lambda/Response * Pairs are ordered by wavelength */ struct sort_pair { bool operator()(PairType a, PairType b) { return a.first < b.first; } }; /** Drop null value of reflectance in the Vector */ //void DropNullReflectance() {} /** Transform the SR in a image to compute the TOA reflectance*/ ImagePointerType GetImage(ImagePointerType image) const; /** Transform the image to an SR structure*/ void SetFromImage(ImagePointerType image); /** Transform the SR in a Filter Function (6S parameters)*/ FilterFunctionValuesPointerType GetFilterFunctionValues(double step = 0.0025); /** Get the wavelength of the first and last not null reflectance */ IntervalType GetInterval() { if (!m_IntervalComputed) this->ComputeInterval(); return m_Interval; } /** set index in m_Response vector to accelerate () operator **/ void SetPosGuessMin(const PrecisionType & lambda); protected: /** Constructor */ SpectralResponse(); /** Constructor from a ASCII file */ //SpectralResponse( const std::string & filename ); /** Destructor */ ~SpectralResponse() ITK_OVERRIDE { } ; /** PrintSelf method */ //void PrintSelf(std::ostream& os, itk::Indent indent) const; /** Spectral response vector of pairs (first=lambda; second=response)*/ VectorPairType m_Response; /** Minimum value to consider that the spectral response is not null */ TPrecision m_SensitivityThreshold; IntervalType m_Interval; unsigned long m_PosGuess; bool m_IntervalComputed; bool m_UsePosGuess; void ComputeInterval(); private: SpectralResponse(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; }// end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSpectralResponse.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSpectralResponse.txx000066400000000000000000000205301301006202600274620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSpectralResponse_txx #define otbSpectralResponse_txx #include "itkNumericTraits.h" #include "otbSpectralResponse.h" #include namespace otb { template SpectralResponse::SpectralResponse() { m_SensitivityThreshold = 0.01; m_IntervalComputed = false; m_PosGuess = 0; m_UsePosGuess=false; } template void SpectralResponse::Load(const std::string & filename, ValuePrecisionType coefNormalization) { //Parse JPL file spectral response (ASCII file) //Begin line 27 std::ifstream fin(filename.c_str()); if (fin.fail()) { itkExceptionMacro(<<"Error opening file" << filename); } int NumLigne = 26; // Go to the line 27 //Ignore first 26th lines which are metadatas information for (int i = 0; i < NumLigne; ++i) fin.ignore(std::numeric_limits::max(), '\n'); while (!fin.eof()) { //For each std::pair currentPair; fin >> currentPair.first; fin >> currentPair.second; currentPair.second = currentPair.second / coefNormalization; if (currentPair.first != itk::NumericTraits::ZeroValue() && currentPair.second != itk::NumericTraits< TValuePrecision>::ZeroValue()) //Add not null pair of values to the vector m_Response.push_back(currentPair); } fin.close(); //Sort the vector using the specific functor sort_pair std::sort(m_Response.begin(), m_Response.end(), sort_pair()); m_IntervalComputed = false; } template bool SpectralResponse::Clear() { m_Response.clear(); m_IntervalComputed = false; return true; } template unsigned int SpectralResponse::Size() const { return m_Response.size(); } template void SpectralResponse::SetPosGuessMin(const PrecisionType & lambda) { m_PosGuess = 0; if (m_Response.size() <= 1) { itkExceptionMacro(<<"ERROR spectral response need at least 2 value to perform interpolation."); } TPrecision lambdaMax = this->GetInterval().second; if (lambda > lambdaMax) return; typename VectorPairType::const_iterator it = m_Response.begin(); while (((*it).first < lambda)) { m_PosGuess++; ++it; if (it == (m_Response.end())) return; } if (m_PosGuess > 0) m_PosGuess--; return; } template inline typename SpectralResponse::ValuePrecisionType SpectralResponse::operator()(const PrecisionType & lambda) { //Suppose that the vector is sorted //Guess a starting lambda if (m_Response.size() <= 1) { itkExceptionMacro(<<"ERROR spectral response need at least 2 value to perform interpolation."); } typename VectorPairType::const_iterator beg = m_Response.begin(); typename VectorPairType::const_iterator last = m_Response.end(); --last; TPrecision lambdaMin = this->GetInterval().first; TPrecision lambdaMax = this->GetInterval().second; if (lambda < lambdaMin) return static_cast (0.0); if (lambda > lambdaMax) return static_cast (0.0); typename VectorPairType::const_iterator it; if(m_UsePosGuess) it= beg + m_PosGuess; else it= beg; TPrecision lambda1 = (*beg).first; TValuePrecision SR1 = static_cast (0.0); while (((*it).first < lambda)) { lambda1 = (*it).first; SR1 = (*it).second; ++it; if (it == (m_Response.end())) { return static_cast (0.0); } } TPrecision lambda2 = (*it).first; // if the guess is just right if (lambda2 == lambda) { return (*it).second; } else { TPrecision lambdaDist = lambda - lambda1; TPrecision ratio = lambdaDist / (lambda2 - lambda1); TValuePrecision SR2 = (*it).second; return static_cast (ratio * SR1 + (1 - ratio) * SR2); } } template typename SpectralResponse::ImagePointerType SpectralResponse::GetImage( ImagePointerType image) const { typename ImageType::IndexType start; start[0] = 0; start[1] = 0; typename ImageType::SizeType size; size[0] = 1; size[1] = 1; typename ImageType::PointType origin; origin[0] = 0; origin[1] = 0; typename ImageType::SpacingType spacing; spacing[0] = 1; spacing[1] = 1; typename ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); image->SetRegions(region); image->SetNumberOfComponentsPerPixel(this->Size()); image->Allocate(); typename ImageType::IndexType idx; typename ImageType::PixelType pixel; pixel.SetSize(this->Size()); for (unsigned int j = 0; j < this->Size(); ++j) { pixel[j] = m_Response[j].second; } idx[0] = 0; idx[1] = 0; image->SetPixel(idx, pixel); return image; } template void SpectralResponse::SetFromImage(ImagePointerType image) { typename ImageType::IndexType idx; idx[0] = 0; idx[1] = 0; for (unsigned int j = 0; j < this->Size(); ++j) { m_Response[j].second = image->GetPixel(idx)[j]; } m_IntervalComputed = false; } template typename SpectralResponse::FilterFunctionValuesPointerType SpectralResponse::GetFilterFunctionValues(double step) { //Assume that the SR is sorted typename FilterFunctionValuesType::ValuesVectorType valuesVector; Self& responseCalculator = *this; for (double i = m_Response.front().first; i <= m_Response.back().first; i += step) { valuesVector.push_back(responseCalculator(i)); } FilterFunctionValuesPointerType functionValues = FilterFunctionValuesType::New(); functionValues->SetFilterFunctionValues(valuesVector); functionValues->SetMinSpectralValue(m_Response.front().first); functionValues->SetMaxSpectralValue(m_Response.back().first); functionValues->SetUserStep(step); return functionValues; } template void SpectralResponse::ComputeInterval() { typename VectorPairType::const_iterator it = m_Response.begin(); while ((*it).second <= m_SensitivityThreshold) { ++it; if (it == (m_Response.end() - 1)) { m_Interval.first = static_cast (0.0); m_Interval.second = static_cast (0.0); m_IntervalComputed = true; return; } } m_Interval.first = (*it).first; it = (m_Response.end() - 1); while ((*it).second <= m_SensitivityThreshold) { if (it == (m_Response.begin())) { m_Interval.second = (*it).first; m_IntervalComputed = true; return; } --it; } m_Interval.second = (*it).first; m_IntervalComputed = true; } template void SpectralResponse::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << std::endl; os << indent << "[Wavelength (micrometers), Reflectance (percent)]" << std::endl; for (typename VectorPairType::const_iterator it = m_Response.begin(); it != m_Response.end(); ++it) { os << indent << "Num " << it - m_Response.begin() << ": [" << (*it).first << "," << (*it).second << "]" << std::endl; } } } // end namespace otb #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSurfaceReflectanceToReflectanceFilter.h000066400000000000000000000254401301006202600331300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSurfaceReflectanceToReflectanceFilter_h #define otbSurfaceReflectanceToReflectanceFilter_h #include "otbUnaryImageFunctorWithVectorImageFilter.h" #include "otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h" #include "itkMetaDataDictionary.h" // #include "itkFactory.h" namespace otb { namespace Functor { /** * \class ReflectanceToSurfaceReflectanceImageFunctor * \brief Compute the surface reflectance pixel from a TOA reflectance. * * \ingroup Functor * \ingroup Radiometry * * \ingroup OTBSimulation */ template class ReflectanceToSurfaceReflectanceImageFunctor { public: /** "typedef" for standard classes. */ typedef ReflectanceToSurfaceReflectanceImageFunctor Self; ReflectanceToSurfaceReflectanceImageFunctor() { m_Coefficient = 1.; m_Residu = 1.; m_SphericalAlbedo = 1.; }; virtual ~ReflectanceToSurfaceReflectanceImageFunctor() {}; /** * Set/Get the spherical albedo of the atmosphere. */ void SetSphericalAlbedo(double albedo) { m_SphericalAlbedo=albedo; }; double GetSphericalAlbedo() { return m_SphericalAlbedo; }; /** * Set/Get Coefficient, computed from AtmosphericRadiativeTermsPointerType data. */ void SetCoefficient(double coef) { m_Coefficient = coef; }; double GetCoefficient() { return m_Coefficient; }; /** * Set/Get Residu, computed from AtmosphericRadiativeTermsPointerType data. */ void SetResidu(double res) { m_Residu = res; }; double GetResidu() { return m_Residu; }; inline TOutput operator() (const TInput & inPixel) { // std::cout << "m_Coefficient "<< m_Coefficient << std::endl; // std::cout << "m_Residu "<< m_Residu << std::endl; TOutput outPixel; // outPixel.first = inPixel.first; double temp, temp1, temp2; // temp = static_cast(inPixel)*m_Coefficient + m_Residu; // temp2 = temp / (1. + m_SphericalAlbedo * temp); temp = 1. - (static_cast(inPixel) * m_SphericalAlbedo); //temp1 = 1/temp; // std::cout << "------------------------------" << std::endl; // std::cout << "B "<< temp << std::endl; // std::cout << "B*residu "<< temp*m_Residu << std::endl; // std::cout << "m_Coefficient*static_cast(inPixel) "<< m_Coefficient*static_cast(inPixel) << std::endl; // std::cout << "albedo "<< m_SphericalAlbedo << std::endl; // std::cout << "all gaz "<< m_Coefficient << std::endl; // std::cout << "residu "<< m_Residu << std::endl; //std::cout << "temp2 "<< temp2 << std::endl; temp2 = m_Residu; // std::cout << "temp2 "<< temp2 << std::endl; temp1 = 1. / temp; // std::cout << "temp1 "<< temp1 << std::endl; temp2 += temp1*m_Coefficient*static_cast(inPixel); // std::cout << "1-row*S "<< temp << std::endl; // outPixel = vcl_fabs (static_cast(temp2)); outPixel = static_cast(temp2); // std::cout << "in out "<< static_cast(inPixel) << "; " << static_cast(outPixel)<< std::endl; // std::cout <<"plot " << m_Residu << "+" << m_Coefficient << "*(x/(1-x*" << m_SphericalAlbedo << "))" << std::endl; // std::cout << "------------------------------" << std::endl; return outPixel; } /** Compare two indices. */ bool operator==(const Self &func) const { return ( (m_SphericalAlbedo == func.m_SphericalAlbedo) && (m_Coefficient == func.m_Coefficient) && (m_Residu == func.m_Residu) ); } /** Compare two indices. */ bool operator!=(const Self &func) const { return ( (m_SphericalAlbedo != func.m_SphericalAlbedo) && (m_Coefficient != func.m_Coefficient) && (m_Residu != func.m_Residu) ); } private: double m_SphericalAlbedo; double m_Coefficient; double m_Residu; }; } /** \class SurfaceReflectanceToReflectanceFilter * \brief Calculates the slope, the orientation incidence and exitance radius values for each pixel. * * * \ingroup AtmosphericRadiativeTerms * \ingroup AtmosphericCorrectionParameters * \ingroup LuminanceToReflectanceImageFilter * \ingroup ImageToReflectanceImageFilter * \ingroup Radiometry * * \ingroup OTBSimulation */ template class ITK_EXPORT SurfaceReflectanceToReflectanceFilter : public UnaryImageFunctorWithVectorImageFilter< TInputImage, TOutputImage, typename Functor::ReflectanceToSurfaceReflectanceImageFunctor< typename TInputImage::InternalPixelType, typename TOutputImage::InternalPixelType > > { public: /** Extract input and output images dimensions.*/ itkStaticConstMacro( InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro( OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** "typedef" to simplify the variables definition and the declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename Functor::ReflectanceToSurfaceReflectanceImageFunctor FunctorType; /** "typedef" for standard classes. */ typedef SurfaceReflectanceToReflectanceFilter Self; typedef UnaryImageFunctorWithVectorImageFilter< InputImageType, OutputImageType, FunctorType > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** object factory method. */ itkNewMacro(Self); /** return class name. */ itkTypeMacro(SurfaceReflectanceToReflectanceFilter, UnaryImageFunctorWithVectorImageFilter); /** Supported images definition. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::InternalPixelType InputInternalPixelType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::InternalPixelType OutputInternalPixelType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef typename AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef typename AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef typename AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; typedef otb::FilterFunctionValues FilterFunctionValuesType; typedef FilterFunctionValuesType::WavelengthSpectralBandType ValueType; //float typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; //std::vector typedef typename AcquiCorrectionParametersType::WavelengthSpectralBandVectorType WavelengthSpectralBandVectorType; typedef itk::MetaDataDictionary MetaDataDictionaryType; /** Get/Set Atmospheric Radiative Terms. */ void SetAtmosphericRadiativeTerms(AtmosphericRadiativeTermsPointerType atmoRadTerms) { m_AtmosphericRadiativeTerms = atmoRadTerms; this->SetNthInput(1, m_AtmosphericRadiativeTerms); m_IsSetAtmosphericRadiativeTerms = true; this->Modified(); } itkGetObjectMacro(AtmosphericRadiativeTerms, AtmosphericRadiativeTermsType); /** Get/Set Atmospheric Correction Parameters. */ void SetAtmoCorrectionParameters(AtmoCorrectionParametersPointerType atmoCorrTerms) { m_AtmoCorrectionParameters = atmoCorrTerms; this->SetNthInput(2, m_AtmoCorrectionParameters); m_IsSetAtmoCorrectionParameters = true; this->Modified(); } itkGetObjectMacro(AtmoCorrectionParameters, AtmoCorrectionParametersType); /** Get/Set Acquisition Correction Parameters. */ void SetAcquiCorrectionParameters(AcquiCorrectionParametersPointerType acquiCorrTerms) { m_AcquiCorrectionParameters = acquiCorrTerms; this->SetNthInput(3, m_AcquiCorrectionParameters); m_IsSetAcquiCorrectionParameters = true; this->Modified(); } /** Compute radiative terms if necessary and then updtae functors attibuts. */ void GenerateParameters(); /** Set/Get UseGenerateParameters. */ itkSetMacro(UseGenerateParameters, bool); itkGetMacro(UseGenerateParameters, bool); /** Set/Get IsSetAtmosphericRadiativeTerms */ itkSetMacro(IsSetAtmosphericRadiativeTerms, bool); itkGetMacro(IsSetAtmosphericRadiativeTerms, bool); protected: /** Constructor */ SurfaceReflectanceToReflectanceFilter(); /** Destructor */ ~SurfaceReflectanceToReflectanceFilter() ITK_OVERRIDE {}; /** Initialize the functor vector */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Fill AtmosphericRadiativeTerms using image metadata*/ void UpdateAtmosphericRadiativeTerms(); /** Update Functors parameters */ void UpdateFunctors(); /** If modified, we need to compute the functor parameters again */ void Modified() const ITK_OVERRIDE; private: bool m_IsSetAtmosphericRadiativeTerms; bool m_IsSetAtmoCorrectionParameters; bool m_IsSetAcquiCorrectionParameters; /** Radiative terms object */ AtmosphericRadiativeTermsPointerType m_AtmosphericRadiativeTerms; AtmoCorrectionParametersPointerType m_AtmoCorrectionParameters; AcquiCorrectionParametersPointerType m_AcquiCorrectionParameters; bool m_UseGenerateParameters; /** True if the functor parameters have been generated */ mutable bool m_FunctorParametersHaveBeenComputed; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSurfaceReflectanceToReflectanceFilter.txx" #endif #endif OTB-release-5.8/Modules/Radiometry/Simulation/include/otbSurfaceReflectanceToReflectanceFilter.txx000066400000000000000000000134701301006202600335240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSurfaceReflectanceToReflectanceFilter_txx #define otbSurfaceReflectanceToReflectanceFilter_txx #include "otbSurfaceReflectanceToReflectanceFilter.h" #include "otbOpticalImageMetadataInterfaceFactory.h" namespace otb { /** * Constructor */ template SurfaceReflectanceToReflectanceFilter ::SurfaceReflectanceToReflectanceFilter() : m_IsSetAtmosphericRadiativeTerms(false), m_IsSetAtmoCorrectionParameters(false), m_IsSetAcquiCorrectionParameters(false), m_UseGenerateParameters(true) { m_AtmosphericRadiativeTerms = AtmosphericRadiativeTermsType::New(); m_AtmoCorrectionParameters = AtmoCorrectionParametersType::New(); m_AcquiCorrectionParameters = AcquiCorrectionParametersType::New(); } template void SurfaceReflectanceToReflectanceFilter ::UpdateAtmosphericRadiativeTerms() { if (this->GetInput() == ITK_NULLPTR) { itkExceptionMacro(<< "Input must be set before updating the atmospheric radiative terms"); } // Atmospheric parameters if (!m_IsSetAtmoCorrectionParameters) { itkExceptionMacro(<< "Atmospheric correction parameters must be provided before updating the atmospheric radiative terms"); } // Acquisition parameters if (!m_IsSetAcquiCorrectionParameters) // Get info from image metadata interface { MetaDataDictionaryType dict = this->GetInput()->GetMetaDataDictionary(); OpticalImageMetadataInterface::Pointer imageMetadataInterface = OpticalImageMetadataInterfaceFactory::CreateIMI(dict); m_AcquiCorrectionParameters = AcquiCorrectionParametersType::New(); m_AcquiCorrectionParameters->SetSolarZenithalAngle(90. - imageMetadataInterface->GetSunElevation()); m_AcquiCorrectionParameters->SetSolarAzimutalAngle(imageMetadataInterface->GetSunAzimuth()); m_AcquiCorrectionParameters->SetViewingZenithalAngle(90. - imageMetadataInterface->GetSatElevation()); m_AcquiCorrectionParameters->SetViewingAzimutalAngle(imageMetadataInterface->GetSatAzimuth()); m_AcquiCorrectionParameters->SetDay(imageMetadataInterface->GetDay()); m_AcquiCorrectionParameters->SetMonth(imageMetadataInterface->GetMonth()); if (imageMetadataInterface->GetSpectralSensitivity()->Capacity() > 0) { m_AcquiCorrectionParameters->SetWavelengthSpectralBand(imageMetadataInterface->GetSpectralSensitivity()); } else { otbMsgDevMacro(<< "use dummy filter"); WavelengthSpectralBandVectorType spectralDummy; spectralDummy->Clear(); for (unsigned int i = 0; i < this->GetInput()->GetNumberOfComponentsPerPixel(); ++i) { spectralDummy->PushBack(FilterFunctionValuesType::New()); } m_AcquiCorrectionParameters->SetWavelengthSpectralBand(spectralDummy); } } m_AtmosphericRadiativeTerms = CorrectionParametersToRadiativeTermsType::Compute(m_AtmoCorrectionParameters,m_AcquiCorrectionParameters); } template void SurfaceReflectanceToReflectanceFilter ::BeforeThreadedGenerateData() { Superclass::BeforeThreadedGenerateData(); if(m_UseGenerateParameters) this->GenerateParameters(); } template void SurfaceReflectanceToReflectanceFilter ::Modified() const { Superclass::Modified(); m_FunctorParametersHaveBeenComputed = false; } template void SurfaceReflectanceToReflectanceFilter ::UpdateFunctors() { //this->GetFunctor().clear(); // for (unsigned int i = 0; iGetInput()->GetNumberOfComponentsPerPixel(); ++i) for (unsigned int i = 0; iGetWavelengthSpectralBand().size(); ++i) { double coef; double res; coef = static_cast(m_AtmosphericRadiativeTerms->GetTotalGaseousTransmission(i) * m_AtmosphericRadiativeTerms->GetDownwardTransmittance(i) * m_AtmosphericRadiativeTerms->GetUpwardTransmittance(i) ); //coef = 1. / coef; // res = -m_AtmosphericRadiativeTerms->GetIntrinsicAtmosphericReflectance(i) * coef; res = m_AtmosphericRadiativeTerms->GetIntrinsicAtmosphericReflectance(i); FunctorType functor; functor.SetCoefficient(coef); functor.SetResidu(res); functor.SetSphericalAlbedo(static_cast(m_AtmosphericRadiativeTerms->GetSphericalAlbedo(i))); this->GetFunctorVector().push_back(functor); // this->SetFunctor(functor); } } template void SurfaceReflectanceToReflectanceFilter ::GenerateParameters() { if (!m_IsSetAtmosphericRadiativeTerms) { this->UpdateAtmosphericRadiativeTerms(); m_IsSetAtmosphericRadiativeTerms=true; } if (!m_FunctorParametersHaveBeenComputed) { this->UpdateFunctors(); m_FunctorParametersHaveBeenComputed = true; } } } #endif OTB-release-5.8/Modules/Radiometry/Simulation/otb-module.cmake000066400000000000000000000015531301006202600243460ustar00rootroot00000000000000set(DOCUMENTATION "This module deals with image simulation algorithm. Using objects transmittance and reflectance and sensor characteristics, it can be possible to generate realistic hyperspectral synthetic set of data. This module includes PROSPECT (leaf optical properties) and SAIL (canopy bidirectional reflectance) models, as well as PROSAIL, which is the combination of the two previous ones.") otb_module(OTBSimulation ENABLE_SHARED DEPENDS OTBStatistics OTBITK OTBMetadata OTBImageBase OTBLabelMap OTBImageManipulation OTBIndices OTBCommon OTBInterpolation OTBBoostAdapters OTBOpticalCalibration OTBObjectList TEST_DEPENDS OTBVectorDataBase OTBConversion OTBImageIO OTBTestKernel OTBLearningBase OTBSupervised OTBSVMLearning OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Radiometry/Simulation/src/000077500000000000000000000000001301006202600220605ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Simulation/src/CMakeLists.txt000066400000000000000000000006371301006202600246260ustar00rootroot00000000000000set(OTBSimulation_SRC otbSailModel.cxx otbProspectModel.cxx otbDataSpecP5B.cxx otbLeafParameters.cxx ) add_library(OTBSimulation ${OTBSimulation_SRC}) target_link_libraries(OTBSimulation ${OTBMetadata_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBOpticalCalibration_LIBRARIES} ${OTBBoost_LIBRARIES} ) otb_module_target(OTBSimulation) OTB-release-5.8/Modules/Radiometry/Simulation/src/otbDataSpecP5B.cxx000066400000000000000000007401561301006202600253210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDataSpecP5B.h" namespace otb { const DataSpec DataSpecP5B[] = { { 400, 1.4955, 2.676E-02, 2.895E-01, 5.272E-01, 5.800E-05, 1.097E+02, 5.910E-01, 2.413E+00, 2.377E-01, 3.208E-02 }, { 401, 1.4958, 3.113E-02, 2.796E-01, 5.262E-01, 5.852E-05, 1.037E+02, 5.980E-01, 2.413E+00, 2.373E-01, 3.195E-02 }, { 402, 1.4960, 3.561E-02, 2.693E-01, 5.252E-01, 5.900E-05, 9.798E+01, 6.050E-01, 2.414E+00, 2.369E-01, 3.181E-02 }, { 403, 1.4964, 3.972E-02, 2.601E-01, 5.242E-01, 5.989E-05, 9.244E+01, 6.120E-01, 2.414E+00, 2.365E-01, 3.168E-02 }, { 404, 1.4971, 4.322E-02, 2.525E-01, 5.232E-01, 6.100E-05, 8.713E+01, 6.190E-01, 2.414E+00, 2.360E-01, 3.154E-02 }, { 405, 1.4978, 4.606E-02, 2.456E-01, 5.222E-01, 6.203E-05, 8.231E+01, 6.260E-01, 2.415E+00, 2.356E-01, 3.141E-02 }, { 406, 1.4986, 4.815E-02, 2.402E-01, 5.212E-01, 6.300E-05, 7.806E+01, 6.330E-01, 2.415E+00, 2.352E-01, 3.125E-02 }, { 407, 1.4995, 5.007E-02, 2.352E-01, 5.202E-01, 6.399E-05, 7.404E+01, 6.400E-01, 2.415E+00, 2.348E-01, 3.108E-02 }, { 408, 1.5006, 5.188E-02, 2.303E-01, 5.192E-01, 6.500E-05, 7.013E+01, 6.470E-01, 2.415E+00, 2.344E-01, 3.092E-02 }, { 409, 1.5016, 5.346E-02, 2.255E-01, 5.182E-01, 6.603E-05, 6.654E+01, 6.540E-01, 2.416E+00, 2.340E-01, 3.076E-02 }, { 410, 1.5024, 5.526E-02, 2.203E-01, 5.172E-01, 6.700E-05, 6.300E+01, 6.610E-01, 2.416E+00, 2.336E-01, 3.059E-02 }, { 411, 1.5031, 5.721E-02, 2.151E-01, 5.162E-01, 6.790E-05, 5.954E+01, 6.680E-01, 2.416E+00, 2.332E-01, 3.044E-02 }, { 412, 1.5041, 5.891E-02, 2.105E-01, 5.152E-01, 6.900E-05, 5.616E+01, 6.750E-01, 2.417E+00, 2.328E-01, 3.028E-02 }, { 413, 1.5052, 6.004E-02, 2.069E-01, 5.142E-01, 7.050E-05, 5.300E+01, 6.820E-01, 2.417E+00, 2.324E-01, 3.012E-02 }, { 414, 1.5065, 6.100E-02, 2.035E-01, 5.132E-01, 7.200E-05, 5.001E+01, 6.890E-01, 2.417E+00, 2.320E-01, 2.996E-02 }, { 415, 1.5076, 6.189E-02, 2.002E-01, 5.122E-01, 7.312E-05, 4.723E+01, 6.960E-01, 2.418E+00, 2.316E-01, 2.980E-02 }, { 416, 1.5088, 6.259E-02, 1.971E-01, 5.112E-01, 7.400E-05, 4.463E+01, 7.030E-01, 2.418E+00, 2.312E-01, 2.969E-02 }, { 417, 1.5099, 6.318E-02, 1.943E-01, 5.102E-01, 7.490E-05, 4.220E+01, 7.100E-01, 2.418E+00, 2.308E-01, 2.957E-02 }, { 418, 1.5110, 6.367E-02, 1.914E-01, 5.092E-01, 7.600E-05, 3.996E+01, 7.170E-01, 2.418E+00, 2.304E-01, 2.946E-02 }, { 419, 1.5122, 6.416E-02, 1.889E-01, 5.082E-01, 7.740E-05, 3.780E+01, 7.240E-01, 2.419E+00, 2.299E-01, 2.934E-02 }, { 420, 1.5134, 6.475E-02, 1.866E-01, 5.072E-01, 7.900E-05, 3.567E+01, 7.310E-01, 2.419E+00, 2.295E-01, 2.923E-02 }, { 421, 1.5144, 6.555E-02, 1.844E-01, 5.062E-01, 8.063E-05, 3.362E+01, 7.376E-01, 2.418E+00, 2.290E-01, 2.911E-02 }, { 422, 1.5156, 6.628E-02, 1.823E-01, 5.052E-01, 8.200E-05, 3.170E+01, 7.442E-01, 2.417E+00, 2.284E-01, 2.900E-02 }, { 423, 1.5168, 6.690E-02, 1.805E-01, 5.042E-01, 8.297E-05, 2.993E+01, 7.508E-01, 2.416E+00, 2.278E-01, 2.888E-02 }, { 424, 1.5181, 6.718E-02, 1.792E-01, 5.032E-01, 8.400E-05, 2.832E+01, 7.574E-01, 2.415E+00, 2.272E-01, 2.877E-02 }, { 425, 1.5195, 6.747E-02, 1.777E-01, 5.022E-01, 8.551E-05, 2.679E+01, 7.640E-01, 2.414E+00, 2.267E-01, 2.865E-02 }, { 426, 1.5206, 6.795E-02, 1.762E-01, 5.012E-01, 8.700E-05, 2.535E+01, 7.706E-01, 2.413E+00, 2.263E-01, 2.854E-02 }, { 427, 1.5212, 6.855E-02, 1.747E-01, 5.002E-01, 8.800E-05, 2.402E+01, 7.772E-01, 2.412E+00, 2.259E-01, 2.842E-02 }, { 428, 1.5219, 6.897E-02, 1.735E-01, 4.992E-01, 8.900E-05, 2.276E+01, 7.838E-01, 2.411E+00, 2.254E-01, 2.831E-02 }, { 429, 1.5228, 6.931E-02, 1.724E-01, 4.982E-01, 9.050E-05, 2.150E+01, 7.904E-01, 2.410E+00, 2.250E-01, 2.819E-02 }, { 430, 1.5235, 6.978E-02, 1.715E-01, 4.972E-01, 9.200E-05, 2.024E+01, 7.970E-01, 2.410E+00, 2.246E-01, 2.808E-02 }, { 431, 1.5241, 7.037E-02, 1.707E-01, 4.960E-01, 9.300E-05, 1.901E+01, 8.036E-01, 2.409E+00, 2.243E-01, 2.793E-02 }, { 432, 1.5249, 7.082E-02, 1.701E-01, 4.948E-01, 9.400E-05, 1.785E+01, 8.102E-01, 2.408E+00, 2.240E-01, 2.779E-02 }, { 433, 1.5256, 7.114E-02, 1.694E-01, 4.936E-01, 9.550E-05, 1.676E+01, 8.168E-01, 2.407E+00, 2.237E-01, 2.764E-02 }, { 434, 1.5262, 7.141E-02, 1.688E-01, 4.924E-01, 9.700E-05, 1.575E+01, 8.234E-01, 2.406E+00, 2.234E-01, 2.750E-02 }, { 435, 1.5267, 7.160E-02, 1.682E-01, 4.912E-01, 9.801E-05, 1.481E+01, 8.300E-01, 2.405E+00, 2.231E-01, 2.735E-02 }, { 436, 1.5272, 7.174E-02, 1.678E-01, 4.900E-01, 9.900E-05, 1.392E+01, 8.366E-01, 2.404E+00, 2.228E-01, 2.720E-02 }, { 437, 1.5276, 7.177E-02, 1.674E-01, 4.888E-01, 1.005E-04, 1.312E+01, 8.432E-01, 2.403E+00, 2.224E-01, 2.705E-02 }, { 438, 1.5279, 7.171E-02, 1.670E-01, 4.876E-01, 1.020E-04, 1.233E+01, 8.498E-01, 2.402E+00, 2.221E-01, 2.690E-02 }, { 439, 1.5282, 7.155E-02, 1.667E-01, 4.864E-01, 1.031E-04, 1.161E+01, 8.564E-01, 2.401E+00, 2.218E-01, 2.675E-02 }, { 440, 1.5286, 7.120E-02, 1.664E-01, 4.852E-01, 1.040E-04, 1.096E+01, 8.630E-01, 2.400E+00, 2.215E-01, 2.660E-02 }, { 441, 1.5290, 7.048E-02, 1.659E-01, 4.840E-01, 1.050E-04, 1.041E+01, 8.743E-01, 2.412E+00, 2.215E-01, 2.646E-02 }, { 442, 1.5292, 6.963E-02, 1.653E-01, 4.829E-01, 1.060E-04, 9.924E+00, 8.856E-01, 2.424E+00, 2.215E-01, 2.632E-02 }, { 443, 1.5294, 6.883E-02, 1.647E-01, 4.817E-01, 1.070E-04, 9.410E+00, 8.969E-01, 2.435E+00, 2.215E-01, 2.618E-02 }, { 444, 1.5294, 6.789E-02, 1.641E-01, 4.805E-01, 1.080E-04, 8.947E+00, 9.082E-01, 2.447E+00, 2.215E-01, 2.604E-02 }, { 445, 1.5295, 6.685E-02, 1.632E-01, 4.793E-01, 1.090E-04, 8.508E+00, 9.195E-01, 2.459E+00, 2.214E-01, 2.590E-02 }, { 446, 1.5293, 6.583E-02, 1.624E-01, 4.781E-01, 1.100E-04, 8.087E+00, 9.308E-01, 2.471E+00, 2.215E-01, 2.578E-02 }, { 447, 1.5291, 6.480E-02, 1.615E-01, 4.769E-01, 1.110E-04, 7.640E+00, 9.421E-01, 2.483E+00, 2.215E-01, 2.566E-02 }, { 448, 1.5289, 6.358E-02, 1.605E-01, 4.757E-01, 1.120E-04, 7.268E+00, 9.534E-01, 2.494E+00, 2.216E-01, 2.553E-02 }, { 449, 1.5286, 6.225E-02, 1.592E-01, 4.745E-01, 1.130E-04, 6.939E+00, 9.647E-01, 2.506E+00, 2.217E-01, 2.541E-02 }, { 450, 1.5282, 6.090E-02, 1.577E-01, 4.733E-01, 1.140E-04, 6.660E+00, 9.760E-01, 2.518E+00, 2.217E-01, 2.529E-02 }, { 451, 1.5278, 5.956E-02, 1.561E-01, 4.720E-01, 1.150E-04, 6.422E+00, 9.873E-01, 2.530E+00, 2.218E-01, 2.523E-02 }, { 452, 1.5273, 5.813E-02, 1.544E-01, 4.708E-01, 1.160E-04, 6.222E+00, 9.986E-01, 2.542E+00, 2.219E-01, 2.518E-02 }, { 453, 1.5268, 5.677E-02, 1.528E-01, 4.695E-01, 1.170E-04, 6.010E+00, 1.010E+00, 2.553E+00, 2.219E-01, 2.513E-02 }, { 454, 1.5262, 5.553E-02, 1.513E-01, 4.683E-01, 1.180E-04, 5.782E+00, 1.021E+00, 2.565E+00, 2.220E-01, 2.508E-02 }, { 455, 1.5256, 5.439E-02, 1.497E-01, 4.670E-01, 1.190E-04, 5.573E+00, 1.033E+00, 2.577E+00, 2.221E-01, 2.502E-02 }, { 456, 1.5249, 5.330E-02, 1.483E-01, 4.658E-01, 1.200E-04, 5.370E+00, 1.044E+00, 2.589E+00, 2.222E-01, 2.502E-02 }, { 457, 1.5243, 5.224E-02, 1.468E-01, 4.645E-01, 1.210E-04, 5.173E+00, 1.055E+00, 2.601E+00, 2.224E-01, 2.502E-02 }, { 458, 1.5237, 5.135E-02, 1.454E-01, 4.633E-01, 1.220E-04, 4.946E+00, 1.066E+00, 2.612E+00, 2.225E-01, 2.502E-02 }, { 459, 1.5230, 5.056E-02, 1.440E-01, 4.620E-01, 1.230E-04, 4.761E+00, 1.078E+00, 2.624E+00, 2.227E-01, 2.501E-02 }, { 460, 1.5224, 4.990E-02, 1.425E-01, 4.608E-01, 1.240E-04, 4.575E+00, 1.089E+00, 2.636E+00, 2.228E-01, 2.501E-02 }, { 461, 1.5217, 4.934E-02, 1.411E-01, 4.597E-01, 1.250E-04, 4.419E+00, 1.094E+00, 2.634E+00, 2.230E-01, 2.501E-02 }, { 462, 1.5210, 4.891E-02, 1.397E-01, 4.587E-01, 1.260E-04, 4.259E+00, 1.100E+00, 2.632E+00, 2.231E-01, 2.501E-02 }, { 463, 1.5203, 4.852E-02, 1.384E-01, 4.577E-01, 1.270E-04, 4.117E+00, 1.105E+00, 2.630E+00, 2.233E-01, 2.500E-02 }, { 464, 1.5196, 4.812E-02, 1.371E-01, 4.566E-01, 1.280E-04, 4.006E+00, 1.110E+00, 2.628E+00, 2.234E-01, 2.500E-02 }, { 465, 1.5189, 4.767E-02, 1.358E-01, 4.556E-01, 1.289E-04, 3.945E+00, 1.116E+00, 2.626E+00, 2.236E-01, 2.500E-02 }, { 466, 1.5184, 4.729E-02, 1.347E-01, 4.546E-01, 1.300E-04, 3.853E+00, 1.121E+00, 2.623E+00, 2.238E-01, 2.500E-02 }, { 467, 1.5178, 4.698E-02, 1.335E-01, 4.535E-01, 1.315E-04, 3.784E+00, 1.126E+00, 2.621E+00, 2.240E-01, 2.499E-02 }, { 468, 1.5173, 4.673E-02, 1.325E-01, 4.525E-01, 1.330E-04, 3.671E+00, 1.131E+00, 2.619E+00, 2.241E-01, 2.499E-02 }, { 469, 1.5170, 4.647E-02, 1.316E-01, 4.515E-01, 1.340E-04, 3.554E+00, 1.137E+00, 2.617E+00, 2.243E-01, 2.499E-02 }, { 470, 1.5166, 4.622E-02, 1.308E-01, 4.504E-01, 1.350E-04, 3.462E+00, 1.142E+00, 2.615E+00, 2.245E-01, 2.499E-02 }, { 471, 1.5163, 4.606E-02, 1.302E-01, 4.494E-01, 1.364E-04, 3.363E+00, 1.147E+00, 2.613E+00, 2.247E-01, 2.498E-02 }, { 472, 1.5159, 4.589E-02, 1.296E-01, 4.484E-01, 1.380E-04, 3.282E+00, 1.153E+00, 2.611E+00, 2.249E-01, 2.498E-02 }, { 473, 1.5156, 4.570E-02, 1.292E-01, 4.473E-01, 1.396E-04, 3.184E+00, 1.158E+00, 2.609E+00, 2.251E-01, 2.498E-02 }, { 474, 1.5153, 4.552E-02, 1.288E-01, 4.463E-01, 1.410E-04, 3.102E+00, 1.163E+00, 2.607E+00, 2.253E-01, 2.498E-02 }, { 475, 1.5150, 4.535E-02, 1.285E-01, 4.453E-01, 1.424E-04, 3.051E+00, 1.169E+00, 2.605E+00, 2.256E-01, 2.497E-02 }, { 476, 1.5148, 4.519E-02, 1.282E-01, 4.442E-01, 1.440E-04, 2.983E+00, 1.174E+00, 2.602E+00, 2.258E-01, 2.483E-02 }, { 477, 1.5145, 4.492E-02, 1.280E-01, 4.432E-01, 1.459E-04, 2.947E+00, 1.179E+00, 2.600E+00, 2.260E-01, 2.468E-02 }, { 478, 1.5142, 4.466E-02, 1.277E-01, 4.422E-01, 1.480E-04, 2.913E+00, 1.184E+00, 2.598E+00, 2.262E-01, 2.453E-02 }, { 479, 1.5139, 4.442E-02, 1.274E-01, 4.411E-01, 1.499E-04, 2.869E+00, 1.190E+00, 2.596E+00, 2.264E-01, 2.438E-02 }, { 480, 1.5135, 4.413E-02, 1.270E-01, 4.401E-01, 1.520E-04, 2.803E+00, 1.195E+00, 2.594E+00, 2.266E-01, 2.423E-02 }, { 481, 1.5131, 4.373E-02, 1.265E-01, 4.388E-01, 1.544E-04, 2.777E+00, 1.194E+00, 2.579E+00, 2.269E-01, 2.423E-02 }, { 482, 1.5125, 4.325E-02, 1.260E-01, 4.375E-01, 1.570E-04, 2.751E+00, 1.194E+00, 2.565E+00, 2.271E-01, 2.423E-02 }, { 483, 1.5119, 4.275E-02, 1.253E-01, 4.362E-01, 1.596E-04, 2.726E+00, 1.193E+00, 2.550E+00, 2.273E-01, 2.423E-02 }, { 484, 1.5111, 4.216E-02, 1.244E-01, 4.350E-01, 1.620E-04, 2.702E+00, 1.192E+00, 2.535E+00, 2.276E-01, 2.422E-02 }, { 485, 1.5103, 4.149E-02, 1.234E-01, 4.337E-01, 1.643E-04, 2.679E+00, 1.191E+00, 2.521E+00, 2.278E-01, 2.422E-02 }, { 486, 1.5092, 4.073E-02, 1.223E-01, 4.324E-01, 1.670E-04, 2.656E+00, 1.191E+00, 2.506E+00, 2.280E-01, 2.422E-02 }, { 487, 1.5080, 3.989E-02, 1.211E-01, 4.311E-01, 1.704E-04, 2.634E+00, 1.190E+00, 2.491E+00, 2.283E-01, 2.422E-02 }, { 488, 1.5067, 3.895E-02, 1.197E-01, 4.298E-01, 1.740E-04, 2.613E+00, 1.189E+00, 2.477E+00, 2.285E-01, 2.421E-02 }, { 489, 1.5051, 3.791E-02, 1.182E-01, 4.285E-01, 1.775E-04, 2.593E+00, 1.188E+00, 2.462E+00, 2.287E-01, 2.421E-02 }, { 490, 1.5034, 3.683E-02, 1.166E-01, 4.272E-01, 1.810E-04, 2.573E+00, 1.188E+00, 2.448E+00, 2.289E-01, 2.421E-02 }, { 491, 1.5015, 3.571E-02, 1.150E-01, 4.260E-01, 1.849E-04, 2.554E+00, 1.187E+00, 2.433E+00, 2.293E-01, 2.450E-02 }, { 492, 1.4994, 3.455E-02, 1.132E-01, 4.247E-01, 1.890E-04, 2.536E+00, 1.186E+00, 2.418E+00, 2.297E-01, 2.479E-02 }, { 493, 1.4971, 3.335E-02, 1.114E-01, 4.234E-01, 1.934E-04, 2.519E+00, 1.185E+00, 2.404E+00, 2.302E-01, 2.508E-02 }, { 494, 1.4947, 3.215E-02, 1.096E-01, 4.221E-01, 1.980E-04, 2.502E+00, 1.185E+00, 2.389E+00, 2.306E-01, 2.537E-02 }, { 495, 1.4921, 3.094E-02, 1.076E-01, 4.208E-01, 2.031E-04, 2.486E+00, 1.184E+00, 2.374E+00, 2.310E-01, 2.566E-02 }, { 496, 1.4894, 2.972E-02, 1.056E-01, 4.195E-01, 2.090E-04, 2.471E+00, 1.183E+00, 2.360E+00, 2.314E-01, 2.565E-02 }, { 497, 1.4866, 2.850E-02, 1.035E-01, 4.183E-01, 2.158E-04, 2.457E+00, 1.182E+00, 2.345E+00, 2.319E-01, 2.565E-02 }, { 498, 1.4837, 2.730E-02, 1.013E-01, 4.170E-01, 2.230E-04, 2.443E+00, 1.182E+00, 2.330E+00, 2.324E-01, 2.565E-02 }, { 499, 1.4807, 2.615E-02, 9.901E-02, 4.157E-01, 2.303E-04, 2.430E+00, 1.181E+00, 2.316E+00, 2.329E-01, 2.565E-02 }, { 500, 1.4776, 2.502E-02, 9.660E-02, 4.144E-01, 2.380E-04, 2.417E+00, 1.180E+00, 2.301E+00, 2.333E-01, 2.564E-02 }, { 501, 1.4744, 2.392E-02, 9.420E-02, 4.135E-01, 2.463E-04, 2.405E+00, 1.180E+00, 2.290E+00, 2.340E-01, 2.564E-02 }, { 502, 1.4712, 2.284E-02, 9.179E-02, 4.127E-01, 2.550E-04, 2.394E+00, 1.181E+00, 2.279E+00, 2.346E-01, 2.564E-02 }, { 503, 1.4680, 2.179E-02, 8.939E-02, 4.118E-01, 2.640E-04, 2.384E+00, 1.181E+00, 2.268E+00, 2.353E-01, 2.564E-02 }, { 504, 1.4647, 2.077E-02, 8.699E-02, 4.109E-01, 2.730E-04, 2.374E+00, 1.181E+00, 2.257E+00, 2.359E-01, 2.563E-02 }, { 505, 1.4615, 1.979E-02, 8.460E-02, 4.100E-01, 2.819E-04, 2.365E+00, 1.182E+00, 2.246E+00, 2.366E-01, 2.563E-02 }, { 506, 1.4583, 1.883E-02, 8.221E-02, 4.092E-01, 2.910E-04, 2.356E+00, 1.182E+00, 2.234E+00, 2.371E-01, 2.570E-02 }, { 507, 1.4553, 1.790E-02, 7.983E-02, 4.083E-01, 3.004E-04, 2.348E+00, 1.182E+00, 2.223E+00, 2.376E-01, 2.577E-02 }, { 508, 1.4523, 1.702E-02, 7.746E-02, 4.074E-01, 3.100E-04, 2.341E+00, 1.182E+00, 2.212E+00, 2.381E-01, 2.584E-02 }, { 509, 1.4495, 1.617E-02, 7.510E-02, 4.065E-01, 3.194E-04, 2.334E+00, 1.183E+00, 2.201E+00, 2.387E-01, 2.591E-02 }, { 510, 1.4468, 1.536E-02, 7.275E-02, 4.057E-01, 3.290E-04, 2.328E+00, 1.183E+00, 2.190E+00, 2.392E-01, 2.598E-02 }, { 511, 1.4443, 1.458E-02, 7.041E-02, 4.047E-01, 3.390E-04, 2.323E+00, 1.183E+00, 2.179E+00, 2.396E-01, 2.598E-02 }, { 512, 1.4419, 1.383E-02, 6.809E-02, 4.038E-01, 3.490E-04, 2.318E+00, 1.184E+00, 2.168E+00, 2.400E-01, 2.598E-02 }, { 513, 1.4397, 1.312E-02, 6.578E-02, 4.028E-01, 3.588E-04, 2.314E+00, 1.184E+00, 2.157E+00, 2.405E-01, 2.598E-02 }, { 514, 1.4377, 1.246E-02, 6.349E-02, 4.019E-01, 3.680E-04, 2.310E+00, 1.184E+00, 2.146E+00, 2.409E-01, 2.597E-02 }, { 515, 1.4360, 1.183E-02, 6.122E-02, 4.009E-01, 3.767E-04, 2.307E+00, 1.185E+00, 2.135E+00, 2.413E-01, 2.597E-02 }, { 516, 1.4344, 1.126E-02, 5.897E-02, 4.000E-01, 3.860E-04, 2.304E+00, 1.185E+00, 2.123E+00, 2.418E-01, 2.597E-02 }, { 517, 1.4331, 1.074E-02, 5.673E-02, 3.990E-01, 3.962E-04, 2.302E+00, 1.185E+00, 2.112E+00, 2.422E-01, 2.597E-02 }, { 518, 1.4319, 1.027E-02, 5.453E-02, 3.981E-01, 4.040E-04, 2.301E+00, 1.185E+00, 2.101E+00, 2.427E-01, 2.596E-02 }, { 519, 1.4310, 9.855E-03, 5.234E-02, 3.971E-01, 4.069E-04, 2.300E+00, 1.186E+00, 2.090E+00, 2.431E-01, 2.596E-02 }, { 520, 1.4302, 9.490E-03, 5.018E-02, 3.962E-01, 4.090E-04, 2.300E+00, 1.186E+00, 2.079E+00, 2.436E-01, 2.596E-02 }, { 521, 1.4296, 9.176E-03, 4.805E-02, 3.952E-01, 4.138E-04, 2.300E+00, 1.191E+00, 2.076E+00, 2.441E-01, 2.596E-02 }, { 522, 1.4291, 8.910E-03, 4.594E-02, 3.943E-01, 4.160E-04, 2.300E+00, 1.195E+00, 2.073E+00, 2.446E-01, 2.595E-02 }, { 523, 1.4288, 8.698E-03, 4.387E-02, 3.933E-01, 4.112E-04, 2.300E+00, 1.200E+00, 2.070E+00, 2.452E-01, 2.595E-02 }, { 524, 1.4286, 8.542E-03, 4.182E-02, 3.924E-01, 4.090E-04, 2.300E+00, 1.204E+00, 2.067E+00, 2.457E-01, 2.595E-02 }, { 525, 1.4286, 8.437E-03, 3.981E-02, 3.914E-01, 4.176E-04, 2.300E+00, 1.209E+00, 2.064E+00, 2.462E-01, 2.595E-02 }, { 526, 1.4286, 8.381E-03, 3.783E-02, 3.905E-01, 4.270E-04, 2.300E+00, 1.213E+00, 2.061E+00, 2.467E-01, 2.594E-02 }, { 527, 1.4287, 8.373E-03, 3.588E-02, 3.895E-01, 4.268E-04, 2.300E+00, 1.218E+00, 2.058E+00, 2.472E-01, 2.594E-02 }, { 528, 1.4288, 8.411E-03, 3.397E-02, 3.886E-01, 4.230E-04, 2.300E+00, 1.222E+00, 2.055E+00, 2.477E-01, 2.594E-02 }, { 529, 1.4290, 8.486E-03, 3.210E-02, 3.876E-01, 4.237E-04, 2.300E+00, 1.227E+00, 2.052E+00, 2.482E-01, 2.594E-02 }, { 530, 1.4292, 8.595E-03, 3.026E-02, 3.867E-01, 4.290E-04, 2.300E+00, 1.231E+00, 2.049E+00, 2.487E-01, 2.593E-02 }, { 531, 1.4294, 8.735E-03, 2.847E-02, 3.846E-01, 4.371E-04, 2.300E+00, 1.236E+00, 2.045E+00, 2.492E-01, 2.593E-02 }, { 532, 1.4296, 8.905E-03, 2.672E-02, 3.824E-01, 4.450E-04, 2.300E+00, 1.240E+00, 2.042E+00, 2.497E-01, 2.593E-02 }, { 533, 1.4298, 9.098E-03, 2.501E-02, 3.803E-01, 4.506E-04, 2.300E+00, 1.245E+00, 2.039E+00, 2.502E-01, 2.593E-02 }, { 534, 1.4300, 9.313E-03, 2.334E-02, 3.782E-01, 4.560E-04, 2.300E+00, 1.249E+00, 2.036E+00, 2.507E-01, 2.592E-02 }, { 535, 1.4302, 9.544E-03, 2.172E-02, 3.760E-01, 4.631E-04, 2.300E+00, 1.254E+00, 2.033E+00, 2.512E-01, 2.592E-02 }, { 536, 1.4303, 9.789E-03, 2.015E-02, 3.739E-01, 4.700E-04, 2.300E+00, 1.258E+00, 2.030E+00, 2.517E-01, 2.614E-02 }, { 537, 1.4305, 1.004E-02, 1.863E-02, 3.718E-01, 4.748E-04, 2.300E+00, 1.263E+00, 2.027E+00, 2.522E-01, 2.635E-02 }, { 538, 1.4306, 1.030E-02, 1.715E-02, 3.696E-01, 4.800E-04, 2.300E+00, 1.267E+00, 2.024E+00, 2.527E-01, 2.657E-02 }, { 539, 1.4307, 1.056E-02, 1.573E-02, 3.675E-01, 4.879E-04, 2.300E+00, 1.272E+00, 2.021E+00, 2.532E-01, 2.679E-02 }, { 540, 1.4308, 1.083E-02, 1.436E-02, 3.654E-01, 4.950E-04, 2.300E+00, 1.276E+00, 2.018E+00, 2.537E-01, 2.700E-02 }, { 541, 1.4309, 1.108E-02, 1.304E-02, 3.639E-01, 4.983E-04, 2.300E+00, 1.278E+00, 2.011E+00, 2.542E-01, 2.700E-02 }, { 542, 1.4309, 1.133E-02, 1.178E-02, 3.625E-01, 5.030E-04, 2.300E+00, 1.279E+00, 2.004E+00, 2.546E-01, 2.700E-02 }, { 543, 1.4310, 1.157E-02, 1.057E-02, 3.611E-01, 5.141E-04, 2.300E+00, 1.281E+00, 1.997E+00, 2.551E-01, 2.700E-02 }, { 544, 1.4310, 1.180E-02, 9.420E-03, 3.597E-01, 5.270E-04, 2.300E+00, 1.282E+00, 1.990E+00, 2.556E-01, 2.699E-02 }, { 545, 1.4310, 1.201E-02, 8.330E-03, 3.582E-01, 5.363E-04, 2.300E+00, 1.284E+00, 1.983E+00, 2.561E-01, 2.699E-02 }, { 546, 1.4309, 1.221E-02, 7.301E-03, 3.568E-01, 5.440E-04, 2.300E+00, 1.285E+00, 1.975E+00, 2.566E-01, 2.735E-02 }, { 547, 1.4308, 1.239E-02, 6.334E-03, 3.554E-01, 5.532E-04, 2.300E+00, 1.287E+00, 1.968E+00, 2.571E-01, 2.772E-02 }, { 548, 1.4307, 1.256E-02, 5.429E-03, 3.540E-01, 5.640E-04, 2.300E+00, 1.288E+00, 1.961E+00, 2.576E-01, 2.808E-02 }, { 549, 1.4305, 1.271E-02, 4.589E-03, 3.525E-01, 5.759E-04, 2.300E+00, 1.290E+00, 1.954E+00, 2.582E-01, 2.844E-02 }, { 550, 1.4303, 1.286E-02, 3.816E-03, 3.511E-01, 5.880E-04, 2.300E+00, 1.291E+00, 1.947E+00, 2.587E-01, 2.880E-02 }, { 551, 1.4301, 1.300E-02, 3.109E-03, 3.500E-01, 5.998E-04, 2.300E+00, 1.293E+00, 1.940E+00, 2.592E-01, 2.880E-02 }, { 552, 1.4298, 1.314E-02, 2.471E-03, 3.489E-01, 6.110E-04, 2.300E+00, 1.294E+00, 1.933E+00, 2.598E-01, 2.880E-02 }, { 553, 1.4294, 1.327E-02, 1.903E-03, 3.478E-01, 6.215E-04, 2.300E+00, 1.296E+00, 1.926E+00, 2.603E-01, 2.879E-02 }, { 554, 1.4290, 1.340E-02, 1.406E-03, 3.467E-01, 6.310E-04, 2.300E+00, 1.297E+00, 1.919E+00, 2.609E-01, 2.879E-02 }, { 555, 1.4285, 1.353E-02, 9.822E-04, 3.456E-01, 6.391E-04, 2.300E+00, 1.299E+00, 1.912E+00, 2.614E-01, 2.879E-02 }, { 556, 1.4280, 1.367E-02, 6.322E-04, 3.445E-01, 6.460E-04, 2.300E+00, 1.300E+00, 1.904E+00, 2.620E-01, 2.879E-02 }, { 557, 1.4274, 1.380E-02, 3.577E-04, 3.434E-01, 6.520E-04, 2.300E+00, 1.302E+00, 1.897E+00, 2.626E-01, 2.878E-02 }, { 558, 1.4268, 1.394E-02, 1.599E-04, 3.423E-01, 6.580E-04, 2.300E+00, 1.303E+00, 1.890E+00, 2.631E-01, 2.878E-02 }, { 559, 1.4262, 1.408E-02, 4.019E-05, 3.412E-01, 6.647E-04, 2.300E+00, 1.305E+00, 1.883E+00, 2.637E-01, 2.878E-02 }, { 560, 1.4255, 1.421E-02, 0.000E+00, 3.401E-01, 6.720E-04, 2.300E+00, 1.306E+00, 1.876E+00, 2.642E-01, 2.878E-02 }, { 561, 1.4248, 1.435E-02, 0.000E+00, 3.383E-01, 6.793E-04, 2.300E+00, 1.309E+00, 1.871E+00, 2.647E-01, 2.877E-02 }, { 562, 1.4241, 1.451E-02, 0.000E+00, 3.366E-01, 6.860E-04, 2.300E+00, 1.312E+00, 1.867E+00, 2.651E-01, 2.877E-02 }, { 563, 1.4234, 1.469E-02, 0.000E+00, 3.348E-01, 6.920E-04, 2.300E+00, 1.314E+00, 1.862E+00, 2.655E-01, 2.877E-02 }, { 564, 1.4227, 1.489E-02, 0.000E+00, 3.330E-01, 6.990E-04, 2.300E+00, 1.317E+00, 1.857E+00, 2.659E-01, 2.877E-02 }, { 565, 1.4220, 1.511E-02, 0.000E+00, 3.312E-01, 7.084E-04, 2.300E+00, 1.320E+00, 1.852E+00, 2.664E-01, 2.877E-02 }, { 566, 1.4213, 1.535E-02, 0.000E+00, 3.294E-01, 7.180E-04, 2.300E+00, 1.323E+00, 1.848E+00, 2.667E-01, 2.884E-02 }, { 567, 1.4206, 1.561E-02, 0.000E+00, 3.276E-01, 7.257E-04, 2.300E+00, 1.325E+00, 1.843E+00, 2.671E-01, 2.891E-02 }, { 568, 1.4199, 1.589E-02, 0.000E+00, 3.258E-01, 7.340E-04, 2.300E+00, 1.328E+00, 1.838E+00, 2.675E-01, 2.898E-02 }, { 569, 1.4192, 1.619E-02, 0.000E+00, 3.241E-01, 7.455E-04, 2.300E+00, 1.331E+00, 1.833E+00, 2.679E-01, 2.905E-02 }, { 570, 1.4185, 1.650E-02, 0.000E+00, 3.223E-01, 7.590E-04, 2.300E+00, 1.334E+00, 1.829E+00, 2.683E-01, 2.912E-02 }, { 571, 1.4179, 1.683E-02, 0.000E+00, 3.202E-01, 7.729E-04, 2.300E+00, 1.336E+00, 1.824E+00, 2.686E-01, 2.912E-02 }, { 572, 1.4173, 1.716E-02, 0.000E+00, 3.182E-01, 7.870E-04, 2.300E+00, 1.339E+00, 1.819E+00, 2.690E-01, 2.911E-02 }, { 573, 1.4167, 1.749E-02, 0.000E+00, 3.162E-01, 8.020E-04, 2.300E+00, 1.342E+00, 1.814E+00, 2.694E-01, 2.911E-02 }, { 574, 1.4161, 1.782E-02, 0.000E+00, 3.141E-01, 8.190E-04, 2.300E+00, 1.345E+00, 1.810E+00, 2.698E-01, 2.911E-02 }, { 575, 1.4156, 1.814E-02, 0.000E+00, 3.121E-01, 8.386E-04, 2.300E+00, 1.347E+00, 1.805E+00, 2.702E-01, 2.911E-02 }, { 576, 1.4151, 1.846E-02, 0.000E+00, 3.100E-01, 8.580E-04, 2.300E+00, 1.350E+00, 1.800E+00, 2.707E-01, 2.918E-02 }, { 577, 1.4146, 1.876E-02, 0.000E+00, 3.080E-01, 8.754E-04, 2.300E+00, 1.353E+00, 1.795E+00, 2.712E-01, 2.926E-02 }, { 578, 1.4141, 1.905E-02, 0.000E+00, 3.059E-01, 8.960E-04, 2.300E+00, 1.356E+00, 1.791E+00, 2.717E-01, 2.934E-02 }, { 579, 1.4137, 1.933E-02, 0.000E+00, 3.039E-01, 9.238E-04, 2.300E+00, 1.358E+00, 1.786E+00, 2.722E-01, 2.942E-02 }, { 580, 1.4133, 1.960E-02, 0.000E+00, 3.019E-01, 9.520E-04, 2.300E+00, 1.361E+00, 1.781E+00, 2.727E-01, 2.950E-02 }, { 581, 1.4129, 1.986E-02, 0.000E+00, 2.999E-01, 9.745E-04, 2.300E+00, 1.361E+00, 1.774E+00, 2.732E-01, 2.978E-02 }, { 582, 1.4126, 2.011E-02, 0.000E+00, 2.979E-01, 1.000E-03, 2.300E+00, 1.360E+00, 1.767E+00, 2.737E-01, 3.006E-02 }, { 583, 1.4123, 2.035E-02, 0.000E+00, 2.959E-01, 1.037E-03, 2.300E+00, 1.360E+00, 1.760E+00, 2.742E-01, 3.034E-02 }, { 584, 1.4120, 2.058E-02, 0.000E+00, 2.940E-01, 1.079E-03, 2.300E+00, 1.360E+00, 1.752E+00, 2.747E-01, 3.062E-02 }, { 585, 1.4117, 2.079E-02, 0.000E+00, 2.920E-01, 1.119E-03, 2.300E+00, 1.359E+00, 1.745E+00, 2.752E-01, 3.090E-02 }, { 586, 1.4114, 2.100E-02, 0.000E+00, 2.900E-01, 1.159E-03, 2.300E+00, 1.359E+00, 1.738E+00, 2.757E-01, 3.090E-02 }, { 587, 1.4112, 2.120E-02, 0.000E+00, 2.881E-01, 1.204E-03, 2.300E+00, 1.359E+00, 1.731E+00, 2.762E-01, 3.090E-02 }, { 588, 1.4109, 2.138E-02, 0.000E+00, 2.861E-01, 1.253E-03, 2.300E+00, 1.358E+00, 1.724E+00, 2.767E-01, 3.090E-02 }, { 589, 1.4107, 2.155E-02, 0.000E+00, 2.841E-01, 1.304E-03, 2.300E+00, 1.358E+00, 1.717E+00, 2.772E-01, 3.089E-02 }, { 590, 1.4105, 2.171E-02, 0.000E+00, 2.821E-01, 1.356E-03, 2.300E+00, 1.358E+00, 1.710E+00, 2.777E-01, 3.089E-02 }, { 591, 1.4103, 2.185E-02, 0.000E+00, 2.803E-01, 1.408E-03, 2.300E+00, 1.357E+00, 1.702E+00, 2.782E-01, 3.089E-02 }, { 592, 1.4101, 2.199E-02, 0.000E+00, 2.784E-01, 1.459E-03, 2.300E+00, 1.357E+00, 1.695E+00, 2.787E-01, 3.089E-02 }, { 593, 1.4099, 2.211E-02, 0.000E+00, 2.766E-01, 1.510E-03, 2.300E+00, 1.356E+00, 1.688E+00, 2.792E-01, 3.088E-02 }, { 594, 1.4097, 2.222E-02, 0.000E+00, 2.747E-01, 1.567E-03, 2.300E+00, 1.356E+00, 1.681E+00, 2.797E-01, 3.088E-02 }, { 595, 1.4095, 2.231E-02, 0.000E+00, 2.728E-01, 1.635E-03, 2.300E+00, 1.356E+00, 1.674E+00, 2.802E-01, 3.088E-02 }, { 596, 1.4093, 2.241E-02, 0.000E+00, 2.710E-01, 1.700E-03, 2.300E+00, 1.355E+00, 1.667E+00, 2.807E-01, 3.088E-02 }, { 597, 1.4091, 2.250E-02, 0.000E+00, 2.691E-01, 1.758E-03, 2.300E+00, 1.355E+00, 1.659E+00, 2.812E-01, 3.087E-02 }, { 598, 1.4089, 2.259E-02, 0.000E+00, 2.673E-01, 1.860E-03, 2.300E+00, 1.355E+00, 1.652E+00, 2.818E-01, 3.087E-02 }, { 599, 1.4087, 2.269E-02, 0.000E+00, 2.654E-01, 2.042E-03, 2.300E+00, 1.354E+00, 1.645E+00, 2.823E-01, 3.087E-02 }, { 600, 1.4086, 2.279E-02, 0.000E+00, 2.636E-01, 2.224E-03, 2.300E+00, 1.354E+00, 1.638E+00, 2.828E-01, 3.087E-02 }, { 601, 1.4084, 2.291E-02, 0.000E+00, 2.618E-01, 2.323E-03, 2.300E+00, 1.356E+00, 1.635E+00, 2.833E-01, 3.098E-02 }, { 602, 1.4082, 2.304E-02, 0.000E+00, 2.601E-01, 2.366E-03, 2.300E+00, 1.357E+00, 1.631E+00, 2.838E-01, 3.110E-02 }, { 603, 1.4081, 2.319E-02, 0.000E+00, 2.584E-01, 2.400E-03, 2.300E+00, 1.359E+00, 1.628E+00, 2.844E-01, 3.122E-02 }, { 604, 1.4079, 2.337E-02, 0.000E+00, 2.566E-01, 2.448E-03, 2.300E+00, 1.360E+00, 1.624E+00, 2.849E-01, 3.133E-02 }, { 605, 1.4078, 2.356E-02, 0.000E+00, 2.549E-01, 2.519E-03, 2.300E+00, 1.362E+00, 1.621E+00, 2.855E-01, 3.145E-02 }, { 606, 1.4077, 2.378E-02, 0.000E+00, 2.532E-01, 2.587E-03, 2.300E+00, 1.363E+00, 1.617E+00, 2.861E-01, 3.147E-02 }, { 607, 1.4076, 2.403E-02, 0.000E+00, 2.515E-01, 2.629E-03, 2.300E+00, 1.365E+00, 1.614E+00, 2.866E-01, 3.150E-02 }, { 608, 1.4075, 2.430E-02, 0.000E+00, 2.497E-01, 2.653E-03, 2.300E+00, 1.366E+00, 1.610E+00, 2.872E-01, 3.152E-02 }, { 609, 1.4075, 2.459E-02, 0.000E+00, 2.480E-01, 2.674E-03, 2.300E+00, 1.368E+00, 1.607E+00, 2.878E-01, 3.155E-02 }, { 610, 1.4075, 2.489E-02, 0.000E+00, 2.463E-01, 2.691E-03, 2.300E+00, 1.370E+00, 1.604E+00, 2.884E-01, 3.157E-02 }, { 611, 1.4075, 2.520E-02, 0.000E+00, 2.447E-01, 2.704E-03, 2.300E+00, 1.371E+00, 1.600E+00, 2.890E-01, 3.157E-02 }, { 612, 1.4075, 2.552E-02, 0.000E+00, 2.431E-01, 2.715E-03, 2.300E+00, 1.373E+00, 1.597E+00, 2.896E-01, 3.157E-02 }, { 613, 1.4076, 2.586E-02, 0.000E+00, 2.414E-01, 2.727E-03, 2.300E+00, 1.374E+00, 1.593E+00, 2.902E-01, 3.156E-02 }, { 614, 1.4077, 2.620E-02, 0.000E+00, 2.398E-01, 2.740E-03, 2.300E+00, 1.376E+00, 1.590E+00, 2.908E-01, 3.156E-02 }, { 615, 1.4077, 2.654E-02, 0.000E+00, 2.382E-01, 2.753E-03, 2.300E+00, 1.377E+00, 1.586E+00, 2.913E-01, 3.156E-02 }, { 616, 1.4078, 2.687E-02, 0.000E+00, 2.366E-01, 2.764E-03, 2.300E+00, 1.379E+00, 1.583E+00, 2.919E-01, 3.163E-02 }, { 617, 1.4079, 2.719E-02, 0.000E+00, 2.350E-01, 2.775E-03, 2.300E+00, 1.380E+00, 1.579E+00, 2.924E-01, 3.170E-02 }, { 618, 1.4080, 2.750E-02, 0.000E+00, 2.334E-01, 2.785E-03, 2.300E+00, 1.382E+00, 1.576E+00, 2.929E-01, 3.177E-02 }, { 619, 1.4081, 2.778E-02, 0.000E+00, 2.318E-01, 2.797E-03, 2.300E+00, 1.383E+00, 1.572E+00, 2.934E-01, 3.184E-02 }, { 620, 1.4082, 2.803E-02, 0.000E+00, 2.302E-01, 2.810E-03, 2.300E+00, 1.385E+00, 1.569E+00, 2.939E-01, 3.191E-02 }, { 621, 1.4083, 2.826E-02, 0.000E+00, 2.288E-01, 2.824E-03, 2.300E+00, 1.385E+00, 1.564E+00, 2.944E-01, 3.198E-02 }, { 622, 1.4083, 2.845E-02, 0.000E+00, 2.273E-01, 2.839E-03, 2.300E+00, 1.385E+00, 1.560E+00, 2.950E-01, 3.205E-02 }, { 623, 1.4083, 2.862E-02, 0.000E+00, 2.258E-01, 2.854E-03, 2.300E+00, 1.385E+00, 1.555E+00, 2.955E-01, 3.212E-02 }, { 624, 1.4083, 2.877E-02, 0.000E+00, 2.244E-01, 2.868E-03, 2.300E+00, 1.386E+00, 1.550E+00, 2.960E-01, 3.219E-02 }, { 625, 1.4082, 2.888E-02, 0.000E+00, 2.229E-01, 2.881E-03, 2.300E+00, 1.386E+00, 1.546E+00, 2.965E-01, 3.227E-02 }, { 626, 1.4082, 2.898E-02, 0.000E+00, 2.215E-01, 2.893E-03, 2.300E+00, 1.386E+00, 1.541E+00, 2.970E-01, 3.263E-02 }, { 627, 1.4081, 2.905E-02, 0.000E+00, 2.200E-01, 2.907E-03, 2.300E+00, 1.386E+00, 1.536E+00, 2.975E-01, 3.299E-02 }, { 628, 1.4079, 2.910E-02, 0.000E+00, 2.185E-01, 2.922E-03, 2.300E+00, 1.386E+00, 1.532E+00, 2.980E-01, 3.335E-02 }, { 629, 1.4078, 2.916E-02, 0.000E+00, 2.171E-01, 2.938E-03, 2.300E+00, 1.386E+00, 1.527E+00, 2.985E-01, 3.371E-02 }, { 630, 1.4077, 2.921E-02, 0.000E+00, 2.156E-01, 2.955E-03, 2.300E+00, 1.387E+00, 1.523E+00, 2.990E-01, 3.408E-02 }, { 631, 1.4076, 2.928E-02, 0.000E+00, 2.143E-01, 2.972E-03, 2.300E+00, 1.387E+00, 1.518E+00, 2.995E-01, 3.407E-02 }, { 632, 1.4076, 2.938E-02, 0.000E+00, 2.129E-01, 2.988E-03, 2.300E+00, 1.387E+00, 1.513E+00, 2.999E-01, 3.407E-02 }, { 633, 1.4076, 2.951E-02, 0.000E+00, 2.115E-01, 3.000E-03, 2.300E+00, 1.387E+00, 1.509E+00, 3.004E-01, 3.407E-02 }, { 634, 1.4078, 2.969E-02, 0.000E+00, 2.102E-01, 3.011E-03, 2.300E+00, 1.387E+00, 1.504E+00, 3.008E-01, 3.407E-02 }, { 635, 1.4080, 2.993E-02, 0.000E+00, 2.088E-01, 3.023E-03, 2.300E+00, 1.387E+00, 1.499E+00, 3.013E-01, 3.406E-02 }, { 636, 1.4083, 3.022E-02, 0.000E+00, 2.074E-01, 3.038E-03, 2.300E+00, 1.387E+00, 1.495E+00, 3.017E-01, 3.425E-02 }, { 637, 1.4087, 3.059E-02, 0.000E+00, 2.061E-01, 3.057E-03, 2.300E+00, 1.388E+00, 1.490E+00, 3.022E-01, 3.443E-02 }, { 638, 1.4093, 3.102E-02, 0.000E+00, 2.047E-01, 3.076E-03, 2.300E+00, 1.388E+00, 1.485E+00, 3.026E-01, 3.461E-02 }, { 639, 1.4100, 3.152E-02, 0.000E+00, 2.033E-01, 3.094E-03, 2.300E+00, 1.388E+00, 1.481E+00, 3.030E-01, 3.479E-02 }, { 640, 1.4108, 3.208E-02, 0.000E+00, 2.020E-01, 3.111E-03, 2.300E+00, 1.388E+00, 1.476E+00, 3.035E-01, 3.498E-02 }, { 641, 1.4118, 3.269E-02, 0.000E+00, 2.007E-01, 3.127E-03, 2.300E+00, 1.387E+00, 1.470E+00, 3.039E-01, 3.515E-02 }, { 642, 1.4128, 3.335E-02, 0.000E+00, 1.994E-01, 3.144E-03, 2.300E+00, 1.386E+00, 1.464E+00, 3.044E-01, 3.533E-02 }, { 643, 1.4140, 3.405E-02, 0.000E+00, 1.981E-01, 3.162E-03, 2.300E+00, 1.384E+00, 1.458E+00, 3.048E-01, 3.551E-02 }, { 644, 1.4153, 3.478E-02, 0.000E+00, 1.968E-01, 3.181E-03, 2.300E+00, 1.383E+00, 1.451E+00, 3.053E-01, 3.568E-02 }, { 645, 1.4166, 3.552E-02, 0.000E+00, 1.955E-01, 3.202E-03, 2.300E+00, 1.382E+00, 1.445E+00, 3.057E-01, 3.586E-02 }, { 646, 1.4179, 3.626E-02, 0.000E+00, 1.942E-01, 3.223E-03, 2.300E+00, 1.381E+00, 1.439E+00, 3.062E-01, 3.593E-02 }, { 647, 1.4193, 3.698E-02, 0.000E+00, 1.929E-01, 3.242E-03, 2.300E+00, 1.379E+00, 1.433E+00, 3.066E-01, 3.600E-02 }, { 648, 1.4206, 3.767E-02, 0.000E+00, 1.916E-01, 3.263E-03, 2.300E+00, 1.378E+00, 1.427E+00, 3.071E-01, 3.607E-02 }, { 649, 1.4218, 3.831E-02, 0.000E+00, 1.903E-01, 3.289E-03, 2.300E+00, 1.377E+00, 1.421E+00, 3.075E-01, 3.614E-02 }, { 650, 1.4229, 3.890E-02, 0.000E+00, 1.890E-01, 3.315E-03, 2.300E+00, 1.376E+00, 1.415E+00, 3.080E-01, 3.621E-02 }, { 651, 1.4240, 3.943E-02, 0.000E+00, 1.878E-01, 3.338E-03, 2.300E+00, 1.374E+00, 1.408E+00, 3.086E-01, 3.636E-02 }, { 652, 1.4250, 3.993E-02, 0.000E+00, 1.865E-01, 3.362E-03, 2.300E+00, 1.373E+00, 1.402E+00, 3.092E-01, 3.650E-02 }, { 653, 1.4261, 4.043E-02, 0.000E+00, 1.853E-01, 3.390E-03, 2.300E+00, 1.372E+00, 1.396E+00, 3.097E-01, 3.664E-02 }, { 654, 1.4272, 4.095E-02, 0.000E+00, 1.841E-01, 3.423E-03, 2.300E+00, 1.371E+00, 1.390E+00, 3.103E-01, 3.679E-02 }, { 655, 1.4284, 4.152E-02, 0.000E+00, 1.829E-01, 3.461E-03, 2.300E+00, 1.369E+00, 1.384E+00, 3.109E-01, 3.693E-02 }, { 656, 1.4298, 4.217E-02, 0.000E+00, 1.816E-01, 3.508E-03, 2.300E+00, 1.368E+00, 1.378E+00, 3.117E-01, 3.710E-02 }, { 657, 1.4315, 4.293E-02, 0.000E+00, 1.804E-01, 3.567E-03, 2.300E+00, 1.367E+00, 1.371E+00, 3.125E-01, 3.727E-02 }, { 658, 1.4335, 4.380E-02, 0.000E+00, 1.792E-01, 3.636E-03, 2.300E+00, 1.366E+00, 1.365E+00, 3.133E-01, 3.743E-02 }, { 659, 1.4357, 4.478E-02, 0.000E+00, 1.780E-01, 3.712E-03, 2.300E+00, 1.364E+00, 1.359E+00, 3.141E-01, 3.760E-02 }, { 660, 1.4383, 4.588E-02, 0.000E+00, 1.768E-01, 3.791E-03, 2.300E+00, 1.363E+00, 1.353E+00, 3.149E-01, 3.777E-02 }, { 661, 1.4411, 4.709E-02, 0.000E+00, 1.755E-01, 3.866E-03, 2.300E+00, 1.364E+00, 1.350E+00, 3.156E-01, 3.782E-02 }, { 662, 1.4442, 4.837E-02, 0.000E+00, 1.742E-01, 3.931E-03, 2.300E+00, 1.365E+00, 1.347E+00, 3.162E-01, 3.786E-02 }, { 663, 1.4475, 4.970E-02, 0.000E+00, 1.729E-01, 3.981E-03, 2.300E+00, 1.366E+00, 1.344E+00, 3.169E-01, 3.791E-02 }, { 664, 1.4509, 5.106E-02, 0.000E+00, 1.717E-01, 4.019E-03, 2.300E+00, 1.367E+00, 1.340E+00, 3.176E-01, 3.795E-02 }, { 665, 1.4544, 5.239E-02, 0.000E+00, 1.704E-01, 4.049E-03, 2.300E+00, 1.368E+00, 1.337E+00, 3.182E-01, 3.800E-02 }, { 666, 1.4579, 5.368E-02, 0.000E+00, 1.691E-01, 4.072E-03, 2.300E+00, 1.368E+00, 1.334E+00, 3.188E-01, 3.829E-02 }, { 667, 1.4614, 5.488E-02, 0.000E+00, 1.679E-01, 4.087E-03, 2.300E+00, 1.369E+00, 1.331E+00, 3.193E-01, 3.858E-02 }, { 668, 1.4649, 5.595E-02, 0.000E+00, 1.666E-01, 4.098E-03, 2.300E+00, 1.370E+00, 1.328E+00, 3.199E-01, 3.887E-02 }, { 669, 1.4682, 5.688E-02, 0.000E+00, 1.653E-01, 4.109E-03, 2.300E+00, 1.371E+00, 1.325E+00, 3.204E-01, 3.916E-02 }, { 670, 1.4714, 5.765E-02, 0.000E+00, 1.641E-01, 4.122E-03, 2.300E+00, 1.372E+00, 1.322E+00, 3.210E-01, 3.945E-02 }, { 671, 1.4744, 5.826E-02, 0.000E+00, 1.627E-01, 4.137E-03, 2.300E+00, 1.373E+00, 1.318E+00, 3.216E-01, 3.944E-02 }, { 672, 1.4773, 5.871E-02, 0.000E+00, 1.613E-01, 4.150E-03, 2.300E+00, 1.374E+00, 1.315E+00, 3.221E-01, 3.944E-02 }, { 673, 1.4802, 5.900E-02, 0.000E+00, 1.600E-01, 4.160E-03, 2.300E+00, 1.375E+00, 1.312E+00, 3.227E-01, 3.944E-02 }, { 674, 1.4830, 5.914E-02, 0.000E+00, 1.586E-01, 4.173E-03, 2.300E+00, 1.376E+00, 1.309E+00, 3.232E-01, 3.944E-02 }, { 675, 1.4857, 5.914E-02, 0.000E+00, 1.572E-01, 4.196E-03, 2.300E+00, 1.377E+00, 1.306E+00, 3.238E-01, 3.943E-02 }, { 676, 1.4884, 5.899E-02, 0.000E+00, 1.559E-01, 4.223E-03, 2.300E+00, 1.377E+00, 1.303E+00, 3.244E-01, 3.980E-02 }, { 677, 1.4909, 5.868E-02, 0.000E+00, 1.545E-01, 4.248E-03, 2.300E+00, 1.378E+00, 1.299E+00, 3.250E-01, 4.016E-02 }, { 678, 1.4932, 5.819E-02, 0.000E+00, 1.532E-01, 4.270E-03, 2.300E+00, 1.379E+00, 1.296E+00, 3.257E-01, 4.052E-02 }, { 679, 1.4951, 5.748E-02, 0.000E+00, 1.518E-01, 4.293E-03, 2.300E+00, 1.380E+00, 1.293E+00, 3.263E-01, 4.088E-02 }, { 680, 1.4963, 5.650E-02, 0.000E+00, 1.504E-01, 4.318E-03, 2.300E+00, 1.381E+00, 1.290E+00, 3.269E-01, 4.124E-02 }, { 681, 1.4967, 5.522E-02, 0.000E+00, 1.491E-01, 4.347E-03, 2.300E+00, 1.375E+00, 1.281E+00, 3.275E-01, 4.131E-02 }, { 682, 1.4958, 5.361E-02, 0.000E+00, 1.478E-01, 4.381E-03, 2.300E+00, 1.368E+00, 1.271E+00, 3.281E-01, 4.138E-02 }, { 683, 1.4936, 5.168E-02, 0.000E+00, 1.464E-01, 4.418E-03, 2.300E+00, 1.362E+00, 1.262E+00, 3.288E-01, 4.146E-02 }, { 684, 1.4899, 4.941E-02, 0.000E+00, 1.451E-01, 4.458E-03, 2.300E+00, 1.355E+00, 1.253E+00, 3.294E-01, 4.153E-02 }, { 685, 1.4847, 4.689E-02, 0.000E+00, 1.437E-01, 4.500E-03, 2.300E+00, 1.349E+00, 1.243E+00, 3.300E-01, 4.160E-02 }, { 686, 1.4780, 4.416E-02, 0.000E+00, 1.424E-01, 4.545E-03, 2.300E+00, 1.343E+00, 1.234E+00, 3.304E-01, 4.167E-02 }, { 687, 1.4702, 4.128E-02, 0.000E+00, 1.411E-01, 4.594E-03, 2.300E+00, 1.336E+00, 1.225E+00, 3.309E-01, 4.174E-02 }, { 688, 1.4618, 3.834E-02, 0.000E+00, 1.397E-01, 4.646E-03, 2.300E+00, 1.330E+00, 1.215E+00, 3.313E-01, 4.181E-02 }, { 689, 1.4530, 3.541E-02, 0.000E+00, 1.384E-01, 4.701E-03, 2.300E+00, 1.323E+00, 1.206E+00, 3.317E-01, 4.188E-02 }, { 690, 1.4445, 3.254E-02, 0.000E+00, 1.370E-01, 4.760E-03, 2.300E+00, 1.317E+00, 1.197E+00, 3.322E-01, 4.195E-02 }, { 691, 1.4366, 2.978E-02, 0.000E+00, 1.358E-01, 4.827E-03, 2.300E+00, 1.311E+00, 1.187E+00, 3.325E-01, 4.195E-02 }, { 692, 1.4296, 2.717E-02, 0.000E+00, 1.345E-01, 4.903E-03, 2.300E+00, 1.304E+00, 1.178E+00, 3.328E-01, 4.194E-02 }, { 693, 1.4237, 2.473E-02, 0.000E+00, 1.333E-01, 4.986E-03, 2.300E+00, 1.298E+00, 1.168E+00, 3.332E-01, 4.194E-02 }, { 694, 1.4190, 2.247E-02, 0.000E+00, 1.320E-01, 5.071E-03, 2.300E+00, 1.291E+00, 1.159E+00, 3.335E-01, 4.194E-02 }, { 695, 1.4154, 2.039E-02, 0.000E+00, 1.308E-01, 5.154E-03, 2.300E+00, 1.285E+00, 1.150E+00, 3.338E-01, 4.194E-02 }, { 696, 1.4129, 1.850E-02, 0.000E+00, 1.295E-01, 5.244E-03, 2.300E+00, 1.279E+00, 1.140E+00, 3.341E-01, 4.193E-02 }, { 697, 1.4112, 1.678E-02, 0.000E+00, 1.283E-01, 5.351E-03, 2.300E+00, 1.272E+00, 1.131E+00, 3.345E-01, 4.193E-02 }, { 698, 1.4104, 1.523E-02, 0.000E+00, 1.270E-01, 5.470E-03, 2.300E+00, 1.266E+00, 1.122E+00, 3.348E-01, 4.193E-02 }, { 699, 1.4102, 1.384E-02, 0.000E+00, 1.258E-01, 5.594E-03, 2.300E+00, 1.259E+00, 1.112E+00, 3.351E-01, 4.193E-02 }, { 700, 1.4106, 1.259E-02, 0.000E+00, 1.245E-01, 5.722E-03, 2.300E+00, 1.253E+00, 1.103E+00, 3.355E-01, 4.193E-02 }, { 701, 1.4113, 1.147E-02, 0.000E+00, 1.234E-01, 5.855E-03, 2.300E+00, 1.236E+00, 1.085E+00, 3.361E-01, 4.214E-02 }, { 702, 1.4124, 1.048E-02, 0.000E+00, 1.223E-01, 5.995E-03, 2.300E+00, 1.219E+00, 1.068E+00, 3.367E-01, 4.236E-02 }, { 703, 1.4137, 9.594E-03, 0.000E+00, 1.212E-01, 6.146E-03, 2.300E+00, 1.201E+00, 1.050E+00, 3.373E-01, 4.257E-02 }, { 704, 1.4152, 8.804E-03, 0.000E+00, 1.200E-01, 6.303E-03, 2.300E+00, 1.184E+00, 1.032E+00, 3.379E-01, 4.279E-02 }, { 705, 1.4168, 8.099E-03, 0.000E+00, 1.189E-01, 6.463E-03, 2.300E+00, 1.167E+00, 1.014E+00, 3.385E-01, 4.301E-02 }, { 706, 1.4186, 7.465E-03, 0.000E+00, 1.178E-01, 6.628E-03, 2.300E+00, 1.150E+00, 9.965E-01, 3.392E-01, 4.332E-02 }, { 707, 1.4204, 6.892E-03, 0.000E+00, 1.167E-01, 6.804E-03, 2.300E+00, 1.133E+00, 9.788E-01, 3.398E-01, 4.363E-02 }, { 708, 1.4222, 6.371E-03, 0.000E+00, 1.156E-01, 6.993E-03, 2.300E+00, 1.115E+00, 9.610E-01, 3.405E-01, 4.394E-02 }, { 709, 1.4242, 5.897E-03, 0.000E+00, 1.144E-01, 7.197E-03, 2.300E+00, 1.098E+00, 9.433E-01, 3.412E-01, 4.426E-02 }, { 710, 1.4261, 5.461E-03, 0.000E+00, 1.133E-01, 7.415E-03, 2.300E+00, 1.081E+00, 9.255E-01, 3.418E-01, 4.457E-02 }, { 711, 1.4281, 5.061E-03, 0.000E+00, 1.122E-01, 7.647E-03, 2.300E+00, 1.064E+00, 9.078E-01, 3.424E-01, 4.462E-02 }, { 712, 1.4301, 4.691E-03, 0.000E+00, 1.111E-01, 7.893E-03, 2.300E+00, 1.047E+00, 8.900E-01, 3.429E-01, 4.466E-02 }, { 713, 1.4321, 4.348E-03, 0.000E+00, 1.100E-01, 8.157E-03, 2.300E+00, 1.029E+00, 8.723E-01, 3.434E-01, 4.471E-02 }, { 714, 1.4341, 4.029E-03, 0.000E+00, 1.089E-01, 8.445E-03, 2.300E+00, 1.012E+00, 8.545E-01, 3.439E-01, 4.476E-02 }, { 715, 1.4361, 3.733E-03, 0.000E+00, 1.078E-01, 8.763E-03, 2.300E+00, 9.950E-01, 8.368E-01, 3.444E-01, 4.480E-02 }, { 716, 1.4382, 3.456E-03, 0.000E+00, 1.067E-01, 9.109E-03, 2.300E+00, 9.778E-01, 8.190E-01, 3.449E-01, 4.495E-02 }, { 717, 1.4402, 3.199E-03, 0.000E+00, 1.056E-01, 9.479E-03, 2.300E+00, 9.606E-01, 8.013E-01, 3.454E-01, 4.509E-02 }, { 718, 1.4422, 2.960E-03, 0.000E+00, 1.046E-01, 9.871E-03, 2.300E+00, 9.434E-01, 7.835E-01, 3.459E-01, 4.523E-02 }, { 719, 1.4442, 2.736E-03, 0.000E+00, 1.035E-01, 1.029E-02, 2.300E+00, 9.262E-01, 7.658E-01, 3.464E-01, 4.538E-02 }, { 720, 1.4462, 2.528E-03, 0.000E+00, 1.024E-01, 1.072E-02, 2.300E+00, 9.090E-01, 7.480E-01, 3.469E-01, 4.552E-02 }, { 721, 1.4481, 2.334E-03, 0.000E+00, 1.013E-01, 1.119E-02, 2.300E+00, 9.248E-01, 7.579E-01, 3.476E-01, 4.566E-02 }, { 722, 1.4500, 2.153E-03, 0.000E+00, 1.003E-01, 1.168E-02, 2.300E+00, 9.405E-01, 7.677E-01, 3.483E-01, 4.581E-02 }, { 723, 1.4518, 1.985E-03, 0.000E+00, 9.931E-02, 1.218E-02, 2.300E+00, 9.563E-01, 7.776E-01, 3.490E-01, 4.595E-02 }, { 724, 1.4536, 1.829E-03, 0.000E+00, 9.829E-02, 1.268E-02, 2.300E+00, 9.720E-01, 7.874E-01, 3.497E-01, 4.609E-02 }, { 725, 1.4554, 1.683E-03, 0.000E+00, 9.727E-02, 1.319E-02, 2.300E+00, 9.878E-01, 7.973E-01, 3.504E-01, 4.624E-02 }, { 726, 1.4571, 1.549E-03, 0.000E+00, 9.625E-02, 1.372E-02, 2.300E+00, 1.004E+00, 8.071E-01, 3.512E-01, 4.653E-02 }, { 727, 1.4587, 1.424E-03, 0.000E+00, 9.524E-02, 1.428E-02, 2.300E+00, 1.019E+00, 8.170E-01, 3.520E-01, 4.682E-02 }, { 728, 1.4603, 1.309E-03, 0.000E+00, 9.422E-02, 1.487E-02, 2.300E+00, 1.035E+00, 8.268E-01, 3.529E-01, 4.711E-02 }, { 729, 1.4618, 1.202E-03, 0.000E+00, 9.320E-02, 1.551E-02, 2.300E+00, 1.051E+00, 8.367E-01, 3.537E-01, 4.739E-02 }, { 730, 1.4632, 1.103E-03, 0.000E+00, 9.218E-02, 1.621E-02, 2.300E+00, 1.067E+00, 8.465E-01, 3.545E-01, 4.768E-02 }, { 731, 1.4646, 1.012E-03, 0.000E+00, 9.120E-02, 1.699E-02, 2.300E+00, 1.082E+00, 8.564E-01, 3.549E-01, 4.805E-02 }, { 732, 1.4659, 9.269E-04, 0.000E+00, 9.022E-02, 1.787E-02, 2.300E+00, 1.098E+00, 8.662E-01, 3.553E-01, 4.841E-02 }, { 733, 1.4671, 8.485E-04, 0.000E+00, 8.924E-02, 1.886E-02, 2.300E+00, 1.114E+00, 8.761E-01, 3.557E-01, 4.877E-02 }, { 734, 1.4683, 7.768E-04, 0.000E+00, 8.827E-02, 1.992E-02, 2.300E+00, 1.130E+00, 8.859E-01, 3.560E-01, 4.913E-02 }, { 735, 1.4694, 7.110E-04, 0.000E+00, 8.729E-02, 2.101E-02, 2.300E+00, 1.145E+00, 8.958E-01, 3.564E-01, 4.949E-02 }, { 736, 1.4704, 6.505E-04, 0.000E+00, 8.631E-02, 2.207E-02, 2.300E+00, 1.161E+00, 9.056E-01, 3.568E-01, 4.971E-02 }, { 737, 1.4713, 5.948E-04, 0.000E+00, 8.533E-02, 2.306E-02, 2.300E+00, 1.177E+00, 9.155E-01, 3.572E-01, 4.993E-02 }, { 738, 1.4721, 5.437E-04, 0.000E+00, 8.435E-02, 2.394E-02, 2.300E+00, 1.193E+00, 9.253E-01, 3.575E-01, 5.014E-02 }, { 739, 1.4729, 4.967E-04, 0.000E+00, 8.337E-02, 2.469E-02, 2.300E+00, 1.208E+00, 9.352E-01, 3.579E-01, 5.036E-02 }, { 740, 1.4736, 4.539E-04, 0.000E+00, 8.239E-02, 2.532E-02, 2.300E+00, 1.224E+00, 9.450E-01, 3.583E-01, 5.058E-02 }, { 741, 1.4742, 4.150E-04, 0.000E+00, 8.155E-02, 2.583E-02, 2.300E+00, 1.182E+00, 9.114E-01, 3.587E-01, 5.073E-02 }, { 742, 1.4747, 3.794E-04, 0.000E+00, 8.070E-02, 2.623E-02, 2.300E+00, 1.139E+00, 8.777E-01, 3.591E-01, 5.089E-02 }, { 743, 1.4752, 3.471E-04, 0.000E+00, 7.985E-02, 2.652E-02, 2.300E+00, 1.097E+00, 8.441E-01, 3.595E-01, 5.105E-02 }, { 744, 1.4756, 3.177E-04, 0.000E+00, 7.901E-02, 2.672E-02, 2.300E+00, 1.054E+00, 8.104E-01, 3.600E-01, 5.121E-02 }, { 745, 1.4759, 2.909E-04, 0.000E+00, 7.816E-02, 2.689E-02, 2.300E+00, 1.012E+00, 7.768E-01, 3.604E-01, 5.136E-02 }, { 746, 1.4762, 2.666E-04, 0.000E+00, 7.732E-02, 2.702E-02, 2.300E+00, 9.693E-01, 7.431E-01, 3.609E-01, 5.156E-02 }, { 747, 1.4764, 2.450E-04, 0.000E+00, 7.647E-02, 2.713E-02, 2.300E+00, 9.269E-01, 7.095E-01, 3.615E-01, 5.175E-02 }, { 748, 1.4765, 2.255E-04, 0.000E+00, 7.562E-02, 2.722E-02, 2.300E+00, 8.844E-01, 6.758E-01, 3.621E-01, 5.195E-02 }, { 749, 1.4766, 2.079E-04, 0.000E+00, 7.478E-02, 2.728E-02, 2.300E+00, 8.420E-01, 6.422E-01, 3.626E-01, 5.214E-02 }, { 750, 1.4766, 1.924E-04, 0.000E+00, 7.393E-02, 2.733E-02, 2.300E+00, 7.995E-01, 6.085E-01, 3.632E-01, 5.233E-02 }, { 751, 1.4767, 1.773E-04, 0.000E+00, 7.319E-02, 2.738E-02, 2.300E+00, 7.571E-01, 5.749E-01, 3.637E-01, 5.253E-02 }, { 752, 1.4767, 1.629E-04, 0.000E+00, 7.245E-02, 2.741E-02, 2.300E+00, 7.146E-01, 5.412E-01, 3.643E-01, 5.272E-02 }, { 753, 1.4767, 1.493E-04, 0.000E+00, 7.171E-02, 2.745E-02, 2.300E+00, 6.722E-01, 5.076E-01, 3.649E-01, 5.292E-02 }, { 754, 1.4767, 1.364E-04, 0.000E+00, 7.097E-02, 2.748E-02, 2.300E+00, 6.297E-01, 4.739E-01, 3.654E-01, 5.311E-02 }, { 755, 1.4766, 1.243E-04, 0.000E+00, 7.023E-02, 2.751E-02, 2.300E+00, 5.873E-01, 4.403E-01, 3.660E-01, 5.330E-02 }, { 756, 1.4766, 1.128E-04, 0.000E+00, 6.949E-02, 2.754E-02, 2.300E+00, 5.448E-01, 4.066E-01, 3.667E-01, 5.355E-02 }, { 757, 1.4765, 1.020E-04, 0.000E+00, 6.875E-02, 2.758E-02, 2.300E+00, 5.024E-01, 3.730E-01, 3.674E-01, 5.380E-02 }, { 758, 1.4764, 9.188E-05, 0.000E+00, 6.801E-02, 2.763E-02, 2.300E+00, 4.599E-01, 3.393E-01, 3.681E-01, 5.404E-02 }, { 759, 1.4763, 8.240E-05, 0.000E+00, 6.727E-02, 2.767E-02, 2.300E+00, 4.175E-01, 3.057E-01, 3.688E-01, 5.429E-02 }, { 760, 1.4762, 7.354E-05, 0.000E+00, 6.653E-02, 2.771E-02, 2.300E+00, 3.750E-01, 2.720E-01, 3.695E-01, 5.454E-02 }, { 761, 1.4761, 6.529E-05, 0.000E+00, 6.586E-02, 2.773E-02, 2.300E+00, 4.185E-01, 3.015E-01, 3.700E-01, 5.461E-02 }, { 762, 1.4759, 5.763E-05, 0.000E+00, 6.519E-02, 2.773E-02, 2.300E+00, 4.619E-01, 3.310E-01, 3.705E-01, 5.468E-02 }, { 763, 1.4758, 5.054E-05, 0.000E+00, 6.452E-02, 2.774E-02, 2.300E+00, 5.054E-01, 3.605E-01, 3.710E-01, 5.475E-02 }, { 764, 1.4756, 4.400E-05, 0.000E+00, 6.385E-02, 2.774E-02, 2.300E+00, 5.488E-01, 3.900E-01, 3.715E-01, 5.482E-02 }, { 765, 1.4754, 3.800E-05, 0.000E+00, 6.318E-02, 2.773E-02, 2.300E+00, 5.923E-01, 4.195E-01, 3.719E-01, 5.489E-02 }, { 766, 1.4752, 3.251E-05, 0.000E+00, 6.251E-02, 2.770E-02, 2.300E+00, 6.357E-01, 4.490E-01, 3.722E-01, 5.489E-02 }, { 767, 1.4751, 2.753E-05, 0.000E+00, 6.184E-02, 2.766E-02, 2.300E+00, 6.792E-01, 4.785E-01, 3.725E-01, 5.488E-02 }, { 768, 1.4748, 2.302E-05, 0.000E+00, 6.117E-02, 2.761E-02, 2.300E+00, 7.226E-01, 5.080E-01, 3.728E-01, 5.488E-02 }, { 769, 1.4746, 1.898E-05, 0.000E+00, 6.050E-02, 2.757E-02, 2.300E+00, 7.661E-01, 5.375E-01, 3.731E-01, 5.488E-02 }, { 770, 1.4744, 1.539E-05, 0.000E+00, 5.983E-02, 2.754E-02, 2.300E+00, 8.095E-01, 5.670E-01, 3.733E-01, 5.488E-02 }, { 771, 1.4742, 1.222E-05, 0.000E+00, 5.913E-02, 2.752E-02, 2.300E+00, 8.530E-01, 5.965E-01, 3.736E-01, 5.490E-02 }, { 772, 1.4739, 9.466E-06, 0.000E+00, 5.843E-02, 2.748E-02, 2.300E+00, 8.964E-01, 6.260E-01, 3.739E-01, 5.493E-02 }, { 773, 1.4737, 7.101E-06, 0.000E+00, 5.773E-02, 2.741E-02, 2.300E+00, 9.399E-01, 6.555E-01, 3.742E-01, 5.496E-02 }, { 774, 1.4734, 5.109E-06, 0.000E+00, 5.704E-02, 2.731E-02, 2.300E+00, 9.833E-01, 6.850E-01, 3.745E-01, 5.498E-02 }, { 775, 1.4732, 3.473E-06, 0.000E+00, 5.634E-02, 2.720E-02, 2.300E+00, 1.027E+00, 7.145E-01, 3.747E-01, 5.501E-02 }, { 776, 1.4729, 2.175E-06, 0.000E+00, 5.564E-02, 2.710E-02, 2.300E+00, 1.070E+00, 7.440E-01, 3.752E-01, 5.549E-02 }, { 777, 1.4727, 1.196E-06, 0.000E+00, 5.494E-02, 2.701E-02, 2.300E+00, 1.114E+00, 7.735E-01, 3.758E-01, 5.597E-02 }, { 778, 1.4725, 5.200E-07, 0.000E+00, 5.424E-02, 2.690E-02, 2.300E+00, 1.157E+00, 8.030E-01, 3.763E-01, 5.645E-02 }, { 779, 1.4722, 1.270E-07, 0.000E+00, 5.354E-02, 2.675E-02, 2.300E+00, 1.201E+00, 8.325E-01, 3.768E-01, 5.692E-02 }, { 780, 1.4720, 0.000E+00, 0.000E+00, 5.284E-02, 2.659E-02, 2.300E+00, 1.244E+00, 8.620E-01, 3.773E-01, 5.740E-02 }, { 781, 1.4718, 0.000E+00, 0.000E+00, 5.226E-02, 2.645E-02, 2.300E+00, 1.242E+00, 8.586E-01, 3.778E-01, 5.753E-02 }, { 782, 1.4716, 0.000E+00, 0.000E+00, 5.167E-02, 2.633E-02, 2.300E+00, 1.240E+00, 8.552E-01, 3.783E-01, 5.766E-02 }, { 783, 1.4714, 0.000E+00, 0.000E+00, 5.109E-02, 2.624E-02, 2.300E+00, 1.238E+00, 8.518E-01, 3.789E-01, 5.778E-02 }, { 784, 1.4712, 0.000E+00, 0.000E+00, 5.050E-02, 2.613E-02, 2.300E+00, 1.235E+00, 8.484E-01, 3.794E-01, 5.791E-02 }, { 785, 1.4710, 0.000E+00, 0.000E+00, 4.992E-02, 2.593E-02, 2.300E+00, 1.233E+00, 8.450E-01, 3.799E-01, 5.804E-02 }, { 786, 1.4708, 0.000E+00, 0.000E+00, 4.933E-02, 2.558E-02, 2.300E+00, 1.231E+00, 8.416E-01, 3.804E-01, 5.813E-02 }, { 787, 1.4706, 0.000E+00, 0.000E+00, 4.874E-02, 2.523E-02, 2.300E+00, 1.229E+00, 8.382E-01, 3.808E-01, 5.821E-02 }, { 788, 1.4703, 0.000E+00, 0.000E+00, 4.816E-02, 2.513E-02, 2.300E+00, 1.227E+00, 8.348E-01, 3.813E-01, 5.830E-02 }, { 789, 1.4701, 0.000E+00, 0.000E+00, 4.757E-02, 2.501E-02, 2.300E+00, 1.225E+00, 8.314E-01, 3.817E-01, 5.839E-02 }, { 790, 1.4700, 0.000E+00, 0.000E+00, 4.699E-02, 2.466E-02, 2.300E+00, 1.223E+00, 8.280E-01, 3.822E-01, 5.847E-02 }, { 791, 1.4698, 0.000E+00, 0.000E+00, 4.646E-02, 2.447E-02, 2.300E+00, 1.220E+00, 8.246E-01, 3.825E-01, 5.884E-02 }, { 792, 1.4696, 0.000E+00, 0.000E+00, 4.594E-02, 2.412E-02, 2.300E+00, 1.218E+00, 8.212E-01, 3.829E-01, 5.920E-02 }, { 793, 1.4694, 0.000E+00, 0.000E+00, 4.542E-02, 2.389E-02, 2.300E+00, 1.216E+00, 8.178E-01, 3.832E-01, 5.956E-02 }, { 794, 1.4692, 0.000E+00, 0.000E+00, 4.490E-02, 2.374E-02, 2.300E+00, 1.214E+00, 8.144E-01, 3.836E-01, 5.992E-02 }, { 795, 1.4690, 0.000E+00, 0.000E+00, 4.437E-02, 2.355E-02, 2.300E+00, 1.212E+00, 8.110E-01, 3.839E-01, 6.028E-02 }, { 796, 1.4688, 0.000E+00, 0.000E+00, 4.385E-02, 2.337E-02, 2.300E+00, 1.210E+00, 8.076E-01, 3.843E-01, 6.028E-02 }, { 797, 1.4686, 0.000E+00, 0.000E+00, 4.333E-02, 2.318E-02, 2.300E+00, 1.207E+00, 8.042E-01, 3.846E-01, 6.028E-02 }, { 798, 1.4684, 0.000E+00, 0.000E+00, 4.281E-02, 2.304E-02, 2.300E+00, 1.205E+00, 8.008E-01, 3.850E-01, 6.028E-02 }, { 799, 1.4682, 0.000E+00, 0.000E+00, 4.228E-02, 2.281E-02, 2.300E+00, 1.203E+00, 7.974E-01, 3.853E-01, 6.027E-02 }, { 800, 1.4681, 0.000E+00, 0.000E+00, 4.176E-02, 2.246E-02, 2.300E+00, 1.201E+00, 7.940E-01, 3.857E-01, 6.027E-02 }, { 801, 1.4679, 0.000E+00, 0.000E+00, 4.128E-02, 2.243E-02, 2.300E+00, 1.188E+00, 7.840E-01, 3.862E-01, 6.063E-02 }, { 802, 1.4677, 0.000E+00, 0.000E+00, 4.081E-02, 2.238E-02, 2.300E+00, 1.174E+00, 7.739E-01, 3.866E-01, 6.100E-02 }, { 803, 1.4675, 0.000E+00, 0.000E+00, 4.033E-02, 2.222E-02, 2.300E+00, 1.161E+00, 7.639E-01, 3.871E-01, 6.136E-02 }, { 804, 1.4674, 0.000E+00, 0.000E+00, 3.985E-02, 2.204E-02, 2.300E+00, 1.147E+00, 7.538E-01, 3.876E-01, 6.172E-02 }, { 805, 1.4672, 0.000E+00, 0.000E+00, 3.937E-02, 2.201E-02, 2.300E+00, 1.134E+00, 7.438E-01, 3.881E-01, 6.208E-02 }, { 806, 1.4670, 0.000E+00, 0.000E+00, 3.889E-02, 2.204E-02, 2.300E+00, 1.121E+00, 7.337E-01, 3.886E-01, 6.223E-02 }, { 807, 1.4668, 0.000E+00, 0.000E+00, 3.841E-02, 2.196E-02, 2.300E+00, 1.107E+00, 7.237E-01, 3.891E-01, 6.237E-02 }, { 808, 1.4666, 0.000E+00, 0.000E+00, 3.793E-02, 2.177E-02, 2.300E+00, 1.094E+00, 7.136E-01, 3.896E-01, 6.251E-02 }, { 809, 1.4665, 0.000E+00, 0.000E+00, 3.746E-02, 2.190E-02, 2.300E+00, 1.080E+00, 7.036E-01, 3.901E-01, 6.266E-02 }, { 810, 1.4663, 0.000E+00, 0.000E+00, 3.698E-02, 2.188E-02, 2.300E+00, 1.067E+00, 6.935E-01, 3.906E-01, 6.280E-02 }, { 811, 1.4662, 0.000E+00, 0.000E+00, 3.657E-02, 2.188E-02, 2.300E+00, 1.054E+00, 6.835E-01, 3.911E-01, 6.280E-02 }, { 812, 1.4660, 0.000E+00, 0.000E+00, 3.615E-02, 2.198E-02, 2.300E+00, 1.040E+00, 6.734E-01, 3.917E-01, 6.279E-02 }, { 813, 1.4659, 0.000E+00, 0.000E+00, 3.574E-02, 2.210E-02, 2.300E+00, 1.027E+00, 6.634E-01, 3.922E-01, 6.279E-02 }, { 814, 1.4657, 0.000E+00, 0.000E+00, 3.533E-02, 2.223E-02, 2.300E+00, 1.013E+00, 6.533E-01, 3.928E-01, 6.279E-02 }, { 815, 1.4655, 0.000E+00, 0.000E+00, 3.492E-02, 2.233E-02, 2.300E+00, 1.000E+00, 6.433E-01, 3.933E-01, 6.279E-02 }, { 816, 1.4654, 0.000E+00, 0.000E+00, 3.451E-02, 2.248E-02, 2.300E+00, 9.866E-01, 6.332E-01, 3.939E-01, 6.300E-02 }, { 817, 1.4652, 0.000E+00, 0.000E+00, 3.409E-02, 2.276E-02, 2.300E+00, 9.732E-01, 6.232E-01, 3.944E-01, 6.322E-02 }, { 818, 1.4651, 0.000E+00, 0.000E+00, 3.368E-02, 2.304E-02, 2.300E+00, 9.598E-01, 6.131E-01, 3.950E-01, 6.344E-02 }, { 819, 1.4649, 0.000E+00, 0.000E+00, 3.327E-02, 2.311E-02, 2.300E+00, 9.464E-01, 6.031E-01, 3.955E-01, 6.365E-02 }, { 820, 1.4648, 0.000E+00, 0.000E+00, 3.286E-02, 2.329E-02, 2.300E+00, 9.330E-01, 5.930E-01, 3.961E-01, 6.387E-02 }, { 821, 1.4646, 0.000E+00, 0.000E+00, 3.249E-02, 2.388E-02, 2.300E+00, 9.416E-01, 5.972E-01, 3.966E-01, 6.433E-02 }, { 822, 1.4645, 0.000E+00, 0.000E+00, 3.212E-02, 2.446E-02, 2.300E+00, 9.502E-01, 6.013E-01, 3.971E-01, 6.479E-02 }, { 823, 1.4643, 0.000E+00, 0.000E+00, 3.175E-02, 2.475E-02, 2.300E+00, 9.588E-01, 6.055E-01, 3.976E-01, 6.525E-02 }, { 824, 1.4641, 0.000E+00, 0.000E+00, 3.139E-02, 2.516E-02, 2.300E+00, 9.674E-01, 6.096E-01, 3.981E-01, 6.571E-02 }, { 825, 1.4639, 0.000E+00, 0.000E+00, 3.102E-02, 2.620E-02, 2.300E+00, 9.760E-01, 6.138E-01, 3.987E-01, 6.616E-02 }, { 826, 1.4638, 0.000E+00, 0.000E+00, 3.065E-02, 2.769E-02, 2.300E+00, 9.846E-01, 6.179E-01, 3.991E-01, 6.643E-02 }, { 827, 1.4636, 0.000E+00, 0.000E+00, 3.028E-02, 2.830E-02, 2.300E+00, 9.932E-01, 6.221E-01, 3.995E-01, 6.669E-02 }, { 828, 1.4635, 0.000E+00, 0.000E+00, 2.991E-02, 2.914E-02, 2.300E+00, 1.002E+00, 6.262E-01, 3.999E-01, 6.696E-02 }, { 829, 1.4633, 0.000E+00, 0.000E+00, 2.954E-02, 3.108E-02, 2.300E+00, 1.010E+00, 6.304E-01, 4.003E-01, 6.722E-02 }, { 830, 1.4631, 0.000E+00, 0.000E+00, 2.918E-02, 3.214E-02, 2.300E+00, 1.019E+00, 6.345E-01, 4.007E-01, 6.749E-02 }, { 831, 1.4630, 0.000E+00, 0.000E+00, 2.885E-02, 3.297E-02, 2.300E+00, 1.028E+00, 6.387E-01, 4.010E-01, 6.749E-02 }, { 832, 1.4628, 0.000E+00, 0.000E+00, 2.852E-02, 3.459E-02, 2.300E+00, 1.036E+00, 6.428E-01, 4.013E-01, 6.748E-02 }, { 833, 1.4627, 0.000E+00, 0.000E+00, 2.819E-02, 3.606E-02, 2.300E+00, 1.045E+00, 6.470E-01, 4.015E-01, 6.748E-02 }, { 834, 1.4626, 0.000E+00, 0.000E+00, 2.786E-02, 3.662E-02, 2.300E+00, 1.053E+00, 6.511E-01, 4.018E-01, 6.748E-02 }, { 835, 1.4625, 0.000E+00, 0.000E+00, 2.753E-02, 3.702E-02, 2.300E+00, 1.062E+00, 6.553E-01, 4.021E-01, 6.748E-02 }, { 836, 1.4623, 0.000E+00, 0.000E+00, 2.720E-02, 3.788E-02, 2.300E+00, 1.071E+00, 6.594E-01, 4.023E-01, 6.747E-02 }, { 837, 1.4622, 0.000E+00, 0.000E+00, 2.688E-02, 3.829E-02, 2.300E+00, 1.079E+00, 6.636E-01, 4.026E-01, 6.747E-02 }, { 838, 1.4620, 0.000E+00, 0.000E+00, 2.655E-02, 3.854E-02, 2.300E+00, 1.088E+00, 6.677E-01, 4.028E-01, 6.747E-02 }, { 839, 1.4619, 0.000E+00, 0.000E+00, 2.622E-02, 3.909E-02, 2.300E+00, 1.096E+00, 6.719E-01, 4.031E-01, 6.747E-02 }, { 840, 1.4617, 0.000E+00, 0.000E+00, 2.589E-02, 3.949E-02, 2.300E+00, 1.105E+00, 6.760E-01, 4.034E-01, 6.747E-02 }, { 841, 1.4616, 0.000E+00, 0.000E+00, 2.559E-02, 3.972E-02, 2.300E+00, 1.105E+00, 6.752E-01, 4.038E-01, 6.776E-02 }, { 842, 1.4614, 0.000E+00, 0.000E+00, 2.529E-02, 4.000E-02, 2.300E+00, 1.106E+00, 6.744E-01, 4.043E-01, 6.806E-02 }, { 843, 1.4613, 0.000E+00, 0.000E+00, 2.499E-02, 4.040E-02, 2.300E+00, 1.106E+00, 6.736E-01, 4.047E-01, 6.836E-02 }, { 844, 1.4611, 0.000E+00, 0.000E+00, 2.469E-02, 4.057E-02, 2.300E+00, 1.107E+00, 6.728E-01, 4.052E-01, 6.866E-02 }, { 845, 1.4610, 0.000E+00, 0.000E+00, 2.440E-02, 4.075E-02, 2.300E+00, 1.107E+00, 6.720E-01, 4.056E-01, 6.896E-02 }, { 846, 1.4608, 0.000E+00, 0.000E+00, 2.410E-02, 4.115E-02, 2.300E+00, 1.108E+00, 6.712E-01, 4.061E-01, 6.938E-02 }, { 847, 1.4607, 0.000E+00, 0.000E+00, 2.380E-02, 4.127E-02, 2.300E+00, 1.108E+00, 6.704E-01, 4.066E-01, 6.981E-02 }, { 848, 1.4605, 0.000E+00, 0.000E+00, 2.350E-02, 4.149E-02, 2.300E+00, 1.109E+00, 6.696E-01, 4.070E-01, 7.023E-02 }, { 849, 1.4604, 0.000E+00, 0.000E+00, 2.320E-02, 4.204E-02, 2.300E+00, 1.109E+00, 6.688E-01, 4.075E-01, 7.066E-02 }, { 850, 1.4602, 0.000E+00, 0.000E+00, 2.290E-02, 4.199E-02, 2.300E+00, 1.110E+00, 6.680E-01, 4.079E-01, 7.109E-02 }, { 851, 1.4601, 0.000E+00, 0.000E+00, 2.264E-02, 4.223E-02, 2.300E+00, 1.110E+00, 6.672E-01, 4.082E-01, 7.108E-02 }, { 852, 1.4600, 0.000E+00, 0.000E+00, 2.238E-02, 4.254E-02, 2.300E+00, 1.110E+00, 6.664E-01, 4.085E-01, 7.108E-02 }, { 853, 1.4599, 0.000E+00, 0.000E+00, 2.212E-02, 4.272E-02, 2.300E+00, 1.111E+00, 6.656E-01, 4.088E-01, 7.108E-02 }, { 854, 1.4597, 0.000E+00, 0.000E+00, 2.186E-02, 4.280E-02, 2.300E+00, 1.111E+00, 6.648E-01, 4.091E-01, 7.108E-02 }, { 855, 1.4596, 0.000E+00, 0.000E+00, 2.159E-02, 4.306E-02, 2.300E+00, 1.112E+00, 6.640E-01, 4.094E-01, 7.107E-02 }, { 856, 1.4595, 0.000E+00, 0.000E+00, 2.133E-02, 4.360E-02, 2.300E+00, 1.112E+00, 6.632E-01, 4.097E-01, 7.107E-02 }, { 857, 1.4594, 0.000E+00, 0.000E+00, 2.107E-02, 4.369E-02, 2.300E+00, 1.113E+00, 6.624E-01, 4.099E-01, 7.107E-02 }, { 858, 1.4592, 0.000E+00, 0.000E+00, 2.081E-02, 4.379E-02, 2.300E+00, 1.113E+00, 6.616E-01, 4.102E-01, 7.107E-02 }, { 859, 1.4591, 0.000E+00, 0.000E+00, 2.055E-02, 4.433E-02, 2.300E+00, 1.114E+00, 6.608E-01, 4.104E-01, 7.106E-02 }, { 860, 1.4589, 0.000E+00, 0.000E+00, 2.029E-02, 4.454E-02, 2.300E+00, 1.114E+00, 6.600E-01, 4.107E-01, 7.106E-02 }, { 861, 1.4587, 0.000E+00, 0.000E+00, 2.006E-02, 4.466E-02, 2.300E+00, 1.114E+00, 6.580E-01, 4.110E-01, 7.113E-02 }, { 862, 1.4586, 0.000E+00, 0.000E+00, 1.983E-02, 4.505E-02, 2.300E+00, 1.113E+00, 6.560E-01, 4.113E-01, 7.119E-02 }, { 863, 1.4584, 0.000E+00, 0.000E+00, 1.961E-02, 4.527E-02, 2.300E+00, 1.113E+00, 6.540E-01, 4.116E-01, 7.126E-02 }, { 864, 1.4583, 0.000E+00, 0.000E+00, 1.938E-02, 4.552E-02, 2.300E+00, 1.112E+00, 6.520E-01, 4.119E-01, 7.132E-02 }, { 865, 1.4582, 0.000E+00, 0.000E+00, 1.915E-02, 4.605E-02, 2.300E+00, 1.112E+00, 6.500E-01, 4.122E-01, 7.139E-02 }, { 866, 1.4582, 0.000E+00, 0.000E+00, 1.893E-02, 4.658E-02, 2.300E+00, 1.111E+00, 6.480E-01, 4.128E-01, 7.197E-02 }, { 867, 1.4581, 0.000E+00, 0.000E+00, 1.870E-02, 4.691E-02, 2.300E+00, 1.111E+00, 6.460E-01, 4.134E-01, 7.256E-02 }, { 868, 1.4580, 0.000E+00, 0.000E+00, 1.847E-02, 4.705E-02, 2.300E+00, 1.110E+00, 6.440E-01, 4.139E-01, 7.315E-02 }, { 869, 1.4579, 0.000E+00, 0.000E+00, 1.825E-02, 4.713E-02, 2.300E+00, 1.110E+00, 6.420E-01, 4.145E-01, 7.373E-02 }, { 870, 1.4577, 0.000E+00, 0.000E+00, 1.802E-02, 4.752E-02, 2.300E+00, 1.109E+00, 6.400E-01, 4.150E-01, 7.432E-02 }, { 871, 1.4576, 0.000E+00, 0.000E+00, 1.782E-02, 4.833E-02, 2.300E+00, 1.109E+00, 6.380E-01, 4.155E-01, 7.432E-02 }, { 872, 1.4574, 0.000E+00, 0.000E+00, 1.762E-02, 4.867E-02, 2.300E+00, 1.108E+00, 6.360E-01, 4.160E-01, 7.431E-02 }, { 873, 1.4572, 0.000E+00, 0.000E+00, 1.742E-02, 4.894E-02, 2.300E+00, 1.108E+00, 6.340E-01, 4.165E-01, 7.431E-02 }, { 874, 1.4571, 0.000E+00, 0.000E+00, 1.723E-02, 4.960E-02, 2.300E+00, 1.107E+00, 6.320E-01, 4.170E-01, 7.431E-02 }, { 875, 1.4569, 0.000E+00, 0.000E+00, 1.703E-02, 5.006E-02, 2.300E+00, 1.107E+00, 6.300E-01, 4.175E-01, 7.431E-02 }, { 876, 1.4568, 0.000E+00, 0.000E+00, 1.683E-02, 5.050E-02, 2.300E+00, 1.106E+00, 6.280E-01, 4.178E-01, 7.445E-02 }, { 877, 1.4566, 0.000E+00, 0.000E+00, 1.663E-02, 5.115E-02, 2.300E+00, 1.106E+00, 6.260E-01, 4.182E-01, 7.459E-02 }, { 878, 1.4565, 0.000E+00, 0.000E+00, 1.643E-02, 5.153E-02, 2.300E+00, 1.105E+00, 6.240E-01, 4.185E-01, 7.474E-02 }, { 879, 1.4563, 0.000E+00, 0.000E+00, 1.623E-02, 5.204E-02, 2.300E+00, 1.105E+00, 6.220E-01, 4.189E-01, 7.488E-02 }, { 880, 1.4562, 0.000E+00, 0.000E+00, 1.604E-02, 5.298E-02, 2.300E+00, 1.104E+00, 6.200E-01, 4.193E-01, 7.502E-02 }, { 881, 1.4560, 0.000E+00, 0.000E+00, 1.586E-02, 5.346E-02, 2.300E+00, 1.087E+00, 6.094E-01, 4.196E-01, 7.521E-02 }, { 882, 1.4559, 0.000E+00, 0.000E+00, 1.568E-02, 5.386E-02, 2.300E+00, 1.070E+00, 5.988E-01, 4.200E-01, 7.539E-02 }, { 883, 1.4558, 0.000E+00, 0.000E+00, 1.551E-02, 5.465E-02, 2.300E+00, 1.053E+00, 5.882E-01, 4.204E-01, 7.558E-02 }, { 884, 1.4556, 0.000E+00, 0.000E+00, 1.533E-02, 5.528E-02, 2.300E+00, 1.036E+00, 5.776E-01, 4.207E-01, 7.576E-02 }, { 885, 1.4554, 0.000E+00, 0.000E+00, 1.516E-02, 5.566E-02, 2.300E+00, 1.019E+00, 5.670E-01, 4.211E-01, 7.595E-02 }, { 886, 1.4553, 0.000E+00, 0.000E+00, 1.498E-02, 5.596E-02, 2.300E+00, 1.002E+00, 5.564E-01, 4.214E-01, 7.614E-02 }, { 887, 1.4551, 0.000E+00, 0.000E+00, 1.481E-02, 5.653E-02, 2.300E+00, 9.850E-01, 5.458E-01, 4.217E-01, 7.632E-02 }, { 888, 1.4550, 0.000E+00, 0.000E+00, 1.463E-02, 5.745E-02, 2.300E+00, 9.680E-01, 5.352E-01, 4.221E-01, 7.651E-02 }, { 889, 1.4548, 0.000E+00, 0.000E+00, 1.446E-02, 5.789E-02, 2.300E+00, 9.510E-01, 5.246E-01, 4.224E-01, 7.670E-02 }, { 890, 1.4547, 0.000E+00, 0.000E+00, 1.428E-02, 5.831E-02, 2.300E+00, 9.340E-01, 5.140E-01, 4.227E-01, 7.689E-02 }, { 891, 1.4545, 0.000E+00, 0.000E+00, 1.414E-02, 5.924E-02, 2.300E+00, 9.170E-01, 5.034E-01, 4.230E-01, 7.717E-02 }, { 892, 1.4544, 0.000E+00, 0.000E+00, 1.400E-02, 5.982E-02, 2.300E+00, 9.000E-01, 4.928E-01, 4.232E-01, 7.745E-02 }, { 893, 1.4542, 0.000E+00, 0.000E+00, 1.385E-02, 6.009E-02, 2.300E+00, 8.830E-01, 4.822E-01, 4.235E-01, 7.772E-02 }, { 894, 1.4541, 0.000E+00, 0.000E+00, 1.371E-02, 6.035E-02, 2.300E+00, 8.660E-01, 4.716E-01, 4.237E-01, 7.800E-02 }, { 895, 1.4539, 0.000E+00, 0.000E+00, 1.357E-02, 6.094E-02, 2.300E+00, 8.490E-01, 4.610E-01, 4.240E-01, 7.828E-02 }, { 896, 1.4538, 0.000E+00, 0.000E+00, 1.343E-02, 6.185E-02, 2.300E+00, 8.320E-01, 4.504E-01, 4.242E-01, 7.848E-02 }, { 897, 1.4536, 0.000E+00, 0.000E+00, 1.328E-02, 6.226E-02, 2.300E+00, 8.150E-01, 4.398E-01, 4.245E-01, 7.867E-02 }, { 898, 1.4535, 0.000E+00, 0.000E+00, 1.314E-02, 6.269E-02, 2.300E+00, 7.980E-01, 4.292E-01, 4.247E-01, 7.887E-02 }, { 899, 1.4533, 0.000E+00, 0.000E+00, 1.300E-02, 6.360E-02, 2.300E+00, 7.810E-01, 4.186E-01, 4.250E-01, 7.907E-02 }, { 900, 1.4532, 0.000E+00, 0.000E+00, 1.286E-02, 6.407E-02, 2.300E+00, 7.640E-01, 4.080E-01, 4.252E-01, 7.927E-02 }, { 901, 1.4531, 0.000E+00, 0.000E+00, 1.275E-02, 6.458E-02, 2.300E+00, 7.758E-01, 4.130E-01, 4.255E-01, 7.943E-02 }, { 902, 1.4529, 0.000E+00, 0.000E+00, 1.265E-02, 6.562E-02, 2.300E+00, 7.876E-01, 4.179E-01, 4.258E-01, 7.959E-02 }, { 903, 1.4528, 0.000E+00, 0.000E+00, 1.255E-02, 6.636E-02, 2.300E+00, 7.994E-01, 4.229E-01, 4.261E-01, 7.975E-02 }, { 904, 1.4526, 0.000E+00, 0.000E+00, 1.245E-02, 6.672E-02, 2.300E+00, 8.112E-01, 4.278E-01, 4.264E-01, 7.991E-02 }, { 905, 1.4525, 0.000E+00, 0.000E+00, 1.235E-02, 6.699E-02, 2.300E+00, 8.230E-01, 4.328E-01, 4.267E-01, 8.007E-02 }, { 906, 1.4524, 0.000E+00, 0.000E+00, 1.225E-02, 6.769E-02, 2.300E+00, 8.348E-01, 4.377E-01, 4.270E-01, 8.006E-02 }, { 907, 1.4522, 0.000E+00, 0.000E+00, 1.215E-02, 6.900E-02, 2.300E+00, 8.466E-01, 4.427E-01, 4.274E-01, 8.006E-02 }, { 908, 1.4521, 0.000E+00, 0.000E+00, 1.205E-02, 6.989E-02, 2.300E+00, 8.584E-01, 4.476E-01, 4.277E-01, 8.006E-02 }, { 909, 1.4519, 0.000E+00, 0.000E+00, 1.195E-02, 7.037E-02, 2.300E+00, 8.702E-01, 4.526E-01, 4.281E-01, 8.006E-02 }, { 910, 1.4518, 0.000E+00, 0.000E+00, 1.185E-02, 7.085E-02, 2.300E+00, 8.820E-01, 4.575E-01, 4.284E-01, 8.005E-02 }, { 911, 1.4516, 0.000E+00, 0.000E+00, 1.175E-02, 7.187E-02, 2.300E+00, 8.938E-01, 4.625E-01, 4.288E-01, 8.022E-02 }, { 912, 1.4515, 0.000E+00, 0.000E+00, 1.165E-02, 7.358E-02, 2.300E+00, 9.056E-01, 4.674E-01, 4.291E-01, 8.039E-02 }, { 913, 1.4513, 0.000E+00, 0.000E+00, 1.155E-02, 7.486E-02, 2.300E+00, 9.174E-01, 4.724E-01, 4.295E-01, 8.056E-02 }, { 914, 1.4512, 0.000E+00, 0.000E+00, 1.145E-02, 7.562E-02, 2.300E+00, 9.292E-01, 4.773E-01, 4.298E-01, 8.073E-02 }, { 915, 1.4511, 0.000E+00, 0.000E+00, 1.135E-02, 7.630E-02, 2.300E+00, 9.410E-01, 4.823E-01, 4.302E-01, 8.090E-02 }, { 916, 1.4509, 0.000E+00, 0.000E+00, 1.125E-02, 7.792E-02, 2.300E+00, 9.528E-01, 4.872E-01, 4.306E-01, 8.120E-02 }, { 917, 1.4508, 0.000E+00, 0.000E+00, 1.115E-02, 8.085E-02, 2.300E+00, 9.646E-01, 4.922E-01, 4.311E-01, 8.151E-02 }, { 918, 1.4506, 0.000E+00, 0.000E+00, 1.105E-02, 8.292E-02, 2.300E+00, 9.764E-01, 4.971E-01, 4.315E-01, 8.181E-02 }, { 919, 1.4505, 0.000E+00, 0.000E+00, 1.096E-02, 8.410E-02, 2.300E+00, 9.882E-01, 5.021E-01, 4.319E-01, 8.212E-02 }, { 920, 1.4503, 0.000E+00, 0.000E+00, 1.086E-02, 8.528E-02, 2.300E+00, 1.000E+00, 5.070E-01, 4.324E-01, 8.243E-02 }, { 921, 1.4502, 0.000E+00, 0.000E+00, 1.076E-02, 8.801E-02, 2.300E+00, 9.771E-01, 4.948E-01, 4.328E-01, 8.272E-02 }, { 922, 1.4500, 0.000E+00, 0.000E+00, 1.066E-02, 9.268E-02, 2.300E+00, 9.542E-01, 4.826E-01, 4.333E-01, 8.301E-02 }, { 923, 1.4498, 0.000E+00, 0.000E+00, 1.056E-02, 9.584E-02, 2.300E+00, 9.313E-01, 4.704E-01, 4.337E-01, 8.330E-02 }, { 924, 1.4497, 0.000E+00, 0.000E+00, 1.047E-02, 9.819E-02, 2.300E+00, 9.084E-01, 4.582E-01, 4.342E-01, 8.359E-02 }, { 925, 1.4495, 0.000E+00, 0.000E+00, 1.037E-02, 1.012E-01, 2.300E+00, 8.855E-01, 4.460E-01, 4.346E-01, 8.389E-02 }, { 926, 1.4493, 0.000E+00, 0.000E+00, 1.027E-02, 1.042E-01, 2.300E+00, 8.626E-01, 4.338E-01, 4.351E-01, 8.404E-02 }, { 927, 1.4492, 0.000E+00, 0.000E+00, 1.017E-02, 1.066E-01, 2.300E+00, 8.397E-01, 4.216E-01, 4.355E-01, 8.419E-02 }, { 928, 1.4491, 0.000E+00, 0.000E+00, 1.008E-02, 1.113E-01, 2.300E+00, 8.168E-01, 4.094E-01, 4.359E-01, 8.434E-02 }, { 929, 1.4489, 0.000E+00, 0.000E+00, 9.980E-03, 1.194E-01, 2.300E+00, 7.939E-01, 3.972E-01, 4.364E-01, 8.449E-02 }, { 930, 1.4488, 0.000E+00, 0.000E+00, 9.884E-03, 1.246E-01, 2.300E+00, 7.710E-01, 3.850E-01, 4.368E-01, 8.464E-02 }, { 931, 1.4487, 0.000E+00, 0.000E+00, 9.787E-03, 1.281E-01, 2.300E+00, 7.481E-01, 3.728E-01, 4.370E-01, 8.495E-02 }, { 932, 1.4485, 0.000E+00, 0.000E+00, 9.691E-03, 1.327E-01, 2.300E+00, 7.252E-01, 3.606E-01, 4.373E-01, 8.526E-02 }, { 933, 1.4483, 0.000E+00, 0.000E+00, 9.595E-03, 1.374E-01, 2.300E+00, 7.023E-01, 3.484E-01, 4.376E-01, 8.557E-02 }, { 934, 1.4481, 0.000E+00, 0.000E+00, 9.500E-03, 1.410E-01, 2.300E+00, 6.794E-01, 3.362E-01, 4.378E-01, 8.588E-02 }, { 935, 1.4479, 0.000E+00, 0.000E+00, 9.404E-03, 1.465E-01, 2.300E+00, 6.565E-01, 3.240E-01, 4.381E-01, 8.619E-02 }, { 936, 1.4478, 0.000E+00, 0.000E+00, 9.309E-03, 1.557E-01, 2.300E+00, 6.336E-01, 3.118E-01, 4.384E-01, 8.636E-02 }, { 937, 1.4477, 0.000E+00, 0.000E+00, 9.214E-03, 1.635E-01, 2.300E+00, 6.107E-01, 2.996E-01, 4.386E-01, 8.653E-02 }, { 938, 1.4476, 0.000E+00, 0.000E+00, 9.120E-03, 1.688E-01, 2.300E+00, 5.878E-01, 2.874E-01, 4.389E-01, 8.670E-02 }, { 939, 1.4474, 0.000E+00, 0.000E+00, 9.025E-03, 1.732E-01, 2.300E+00, 5.649E-01, 2.752E-01, 4.392E-01, 8.686E-02 }, { 940, 1.4472, 0.000E+00, 0.000E+00, 8.931E-03, 1.818E-01, 2.300E+00, 5.420E-01, 2.630E-01, 4.394E-01, 8.703E-02 }, { 941, 1.4469, 0.000E+00, 0.000E+00, 8.837E-03, 1.963E-01, 2.300E+00, 5.412E-01, 2.621E-01, 4.397E-01, 8.737E-02 }, { 942, 1.4466, 0.000E+00, 0.000E+00, 8.743E-03, 2.050E-01, 2.300E+00, 5.403E-01, 2.611E-01, 4.400E-01, 8.771E-02 }, { 943, 1.4465, 0.000E+00, 0.000E+00, 8.650E-03, 2.106E-01, 2.300E+00, 5.395E-01, 2.602E-01, 4.403E-01, 8.804E-02 }, { 944, 1.4463, 0.000E+00, 0.000E+00, 8.557E-03, 2.187E-01, 2.300E+00, 5.386E-01, 2.592E-01, 4.406E-01, 8.838E-02 }, { 945, 1.4462, 0.000E+00, 0.000E+00, 8.464E-03, 2.287E-01, 2.300E+00, 5.378E-01, 2.583E-01, 4.409E-01, 8.872E-02 }, { 946, 1.4461, 0.000E+00, 0.000E+00, 8.371E-03, 2.386E-01, 2.300E+00, 5.369E-01, 2.573E-01, 4.412E-01, 8.882E-02 }, { 947, 1.4461, 0.000E+00, 0.000E+00, 8.279E-03, 2.468E-01, 2.300E+00, 5.361E-01, 2.564E-01, 4.415E-01, 8.893E-02 }, { 948, 1.4461, 0.000E+00, 0.000E+00, 8.187E-03, 2.542E-01, 2.300E+00, 5.352E-01, 2.554E-01, 4.418E-01, 8.904E-02 }, { 949, 1.4460, 0.000E+00, 0.000E+00, 8.095E-03, 2.701E-01, 2.300E+00, 5.344E-01, 2.545E-01, 4.421E-01, 8.914E-02 }, { 950, 1.4457, 0.000E+00, 0.000E+00, 8.004E-03, 2.976E-01, 2.300E+00, 5.335E-01, 2.535E-01, 4.424E-01, 8.925E-02 }, { 951, 1.4455, 0.000E+00, 0.000E+00, 7.913E-03, 3.153E-01, 2.300E+00, 5.327E-01, 2.526E-01, 4.427E-01, 8.947E-02 }, { 952, 1.4453, 0.000E+00, 0.000E+00, 7.822E-03, 3.274E-01, 2.300E+00, 5.318E-01, 2.516E-01, 4.430E-01, 8.969E-02 }, { 953, 1.4451, 0.000E+00, 0.000E+00, 7.732E-03, 3.438E-01, 2.300E+00, 5.310E-01, 2.507E-01, 4.433E-01, 8.991E-02 }, { 954, 1.4450, 0.000E+00, 0.000E+00, 7.641E-03, 3.622E-01, 2.300E+00, 5.301E-01, 2.497E-01, 4.436E-01, 9.013E-02 }, { 955, 1.4449, 0.000E+00, 0.000E+00, 7.552E-03, 3.785E-01, 2.300E+00, 5.293E-01, 2.488E-01, 4.438E-01, 9.035E-02 }, { 956, 1.4448, 0.000E+00, 0.000E+00, 7.462E-03, 3.930E-01, 2.300E+00, 5.284E-01, 2.478E-01, 4.439E-01, 9.058E-02 }, { 957, 1.4447, 0.000E+00, 0.000E+00, 7.373E-03, 4.068E-01, 2.300E+00, 5.276E-01, 2.469E-01, 4.440E-01, 9.081E-02 }, { 958, 1.4445, 0.000E+00, 0.000E+00, 7.284E-03, 4.184E-01, 2.300E+00, 5.267E-01, 2.459E-01, 4.441E-01, 9.104E-02 }, { 959, 1.4445, 0.000E+00, 0.000E+00, 7.195E-03, 4.273E-01, 2.300E+00, 5.259E-01, 2.450E-01, 4.441E-01, 9.127E-02 }, { 960, 1.4445, 0.000E+00, 0.000E+00, 7.107E-03, 4.385E-01, 2.300E+00, 5.250E-01, 2.440E-01, 4.442E-01, 9.151E-02 }, { 961, 1.4442, 0.000E+00, 0.000E+00, 7.019E-03, 4.538E-01, 2.300E+00, 5.362E-01, 2.484E-01, 4.443E-01, 9.189E-02 }, { 962, 1.4440, 0.000E+00, 0.000E+00, 6.932E-03, 4.611E-01, 2.300E+00, 5.474E-01, 2.528E-01, 4.444E-01, 9.227E-02 }, { 963, 1.4438, 0.000E+00, 0.000E+00, 6.844E-03, 4.633E-01, 2.300E+00, 5.586E-01, 2.572E-01, 4.445E-01, 9.265E-02 }, { 964, 1.4437, 0.000E+00, 0.000E+00, 6.758E-03, 4.663E-01, 2.300E+00, 5.698E-01, 2.616E-01, 4.446E-01, 9.303E-02 }, { 965, 1.4436, 0.000E+00, 0.000E+00, 6.671E-03, 4.701E-01, 2.300E+00, 5.810E-01, 2.660E-01, 4.447E-01, 9.341E-02 }, { 966, 1.4436, 0.000E+00, 0.000E+00, 6.585E-03, 4.733E-01, 2.300E+00, 5.922E-01, 2.704E-01, 4.450E-01, 9.355E-02 }, { 967, 1.4435, 0.000E+00, 0.000E+00, 6.499E-03, 4.756E-01, 2.300E+00, 6.034E-01, 2.748E-01, 4.453E-01, 9.369E-02 }, { 968, 1.4434, 0.000E+00, 0.000E+00, 6.414E-03, 4.772E-01, 2.300E+00, 6.146E-01, 2.792E-01, 4.456E-01, 9.384E-02 }, { 969, 1.4434, 0.000E+00, 0.000E+00, 6.329E-03, 4.785E-01, 2.300E+00, 6.258E-01, 2.836E-01, 4.459E-01, 9.398E-02 }, { 970, 1.4434, 0.000E+00, 0.000E+00, 6.244E-03, 4.800E-01, 2.300E+00, 6.370E-01, 2.880E-01, 4.462E-01, 9.412E-02 }, { 971, 1.4434, 0.000E+00, 0.000E+00, 6.160E-03, 4.814E-01, 2.300E+00, 6.482E-01, 2.924E-01, 4.465E-01, 9.437E-02 }, { 972, 1.4432, 0.000E+00, 0.000E+00, 6.076E-03, 4.827E-01, 2.300E+00, 6.594E-01, 2.968E-01, 4.468E-01, 9.461E-02 }, { 973, 1.4430, 0.000E+00, 0.000E+00, 5.993E-03, 4.843E-01, 2.300E+00, 6.706E-01, 3.012E-01, 4.471E-01, 9.485E-02 }, { 974, 1.4428, 0.000E+00, 0.000E+00, 5.910E-03, 4.864E-01, 2.300E+00, 6.818E-01, 3.056E-01, 4.474E-01, 9.509E-02 }, { 975, 1.4427, 0.000E+00, 0.000E+00, 5.827E-03, 4.870E-01, 2.300E+00, 6.930E-01, 3.100E-01, 4.477E-01, 9.534E-02 }, { 976, 1.4426, 0.000E+00, 0.000E+00, 5.745E-03, 4.867E-01, 2.300E+00, 7.042E-01, 3.144E-01, 4.479E-01, 9.540E-02 }, { 977, 1.4425, 0.000E+00, 0.000E+00, 5.663E-03, 4.864E-01, 2.300E+00, 7.154E-01, 3.188E-01, 4.482E-01, 9.546E-02 }, { 978, 1.4423, 0.000E+00, 0.000E+00, 5.581E-03, 4.857E-01, 2.300E+00, 7.266E-01, 3.232E-01, 4.485E-01, 9.552E-02 }, { 979, 1.4421, 0.000E+00, 0.000E+00, 5.500E-03, 4.841E-01, 2.300E+00, 7.378E-01, 3.276E-01, 4.487E-01, 9.558E-02 }, { 980, 1.4420, 0.000E+00, 0.000E+00, 5.419E-03, 4.821E-01, 2.300E+00, 7.490E-01, 3.320E-01, 4.490E-01, 9.564E-02 }, { 981, 1.4418, 0.000E+00, 0.000E+00, 5.339E-03, 4.804E-01, 2.300E+00, 7.564E-01, 3.344E-01, 4.492E-01, 9.569E-02 }, { 982, 1.4416, 0.000E+00, 0.000E+00, 5.259E-03, 4.786E-01, 2.300E+00, 7.638E-01, 3.368E-01, 4.495E-01, 9.575E-02 }, { 983, 1.4415, 0.000E+00, 0.000E+00, 5.180E-03, 4.764E-01, 2.300E+00, 7.712E-01, 3.392E-01, 4.497E-01, 9.580E-02 }, { 984, 1.4414, 0.000E+00, 0.000E+00, 5.101E-03, 4.738E-01, 2.300E+00, 7.786E-01, 3.416E-01, 4.500E-01, 9.586E-02 }, { 985, 1.4414, 0.000E+00, 0.000E+00, 5.023E-03, 4.710E-01, 2.300E+00, 7.860E-01, 3.440E-01, 4.502E-01, 9.591E-02 }, { 986, 1.4414, 0.000E+00, 0.000E+00, 4.945E-03, 4.677E-01, 2.300E+00, 7.934E-01, 3.464E-01, 4.506E-01, 9.617E-02 }, { 987, 1.4415, 0.000E+00, 0.000E+00, 4.867E-03, 4.641E-01, 2.300E+00, 8.008E-01, 3.488E-01, 4.509E-01, 9.643E-02 }, { 988, 1.4416, 0.000E+00, 0.000E+00, 4.790E-03, 4.604E-01, 2.300E+00, 8.082E-01, 3.512E-01, 4.513E-01, 9.669E-02 }, { 989, 1.4416, 0.000E+00, 0.000E+00, 4.713E-03, 4.570E-01, 2.300E+00, 8.156E-01, 3.536E-01, 4.516E-01, 9.695E-02 }, { 990, 1.4415, 0.000E+00, 0.000E+00, 4.637E-03, 4.532E-01, 2.300E+00, 8.230E-01, 3.560E-01, 4.520E-01, 9.722E-02 }, { 991, 1.4414, 0.000E+00, 0.000E+00, 4.561E-03, 4.482E-01, 2.300E+00, 8.304E-01, 3.584E-01, 4.525E-01, 9.797E-02 }, { 992, 1.4413, 0.000E+00, 0.000E+00, 4.486E-03, 4.434E-01, 2.300E+00, 8.378E-01, 3.608E-01, 4.530E-01, 9.872E-02 }, { 993, 1.4411, 0.000E+00, 0.000E+00, 4.411E-03, 4.397E-01, 2.300E+00, 8.452E-01, 3.632E-01, 4.535E-01, 9.947E-02 }, { 994, 1.4409, 0.000E+00, 0.000E+00, 4.337E-03, 4.362E-01, 2.300E+00, 8.526E-01, 3.656E-01, 4.540E-01, 1.002E-01 }, { 995, 1.4407, 0.000E+00, 0.000E+00, 4.263E-03, 4.316E-01, 2.300E+00, 8.600E-01, 3.680E-01, 4.545E-01, 1.010E-01 }, { 996, 1.4405, 0.000E+00, 0.000E+00, 4.190E-03, 4.265E-01, 2.300E+00, 8.674E-01, 3.704E-01, 4.549E-01, 1.010E-01 }, { 997, 1.4403, 0.000E+00, 0.000E+00, 4.117E-03, 4.215E-01, 2.300E+00, 8.748E-01, 3.728E-01, 4.553E-01, 1.010E-01 }, { 998, 1.4401, 0.000E+00, 0.000E+00, 4.044E-03, 4.168E-01, 2.300E+00, 8.822E-01, 3.752E-01, 4.557E-01, 1.010E-01 }, { 999, 1.4400, 0.000E+00, 0.000E+00, 3.972E-03, 4.121E-01, 2.300E+00, 8.896E-01, 3.776E-01, 4.561E-01, 1.010E-01 }, { 1000, 1.4399, 0.000E+00, 0.000E+00, 3.901E-03, 4.072E-01, 2.300E+00, 8.970E-01, 3.800E-01, 4.565E-01, 1.010E-01 }, { 1001, 1.4397, 0.000E+00, 0.000E+00, 3.830E-03, 4.017E-01, 2.300E+00, 8.952E-01, 3.786E-01, 4.568E-01, 1.010E-01 }, { 1002, 1.4395, 0.000E+00, 0.000E+00, 3.760E-03, 3.963E-01, 2.300E+00, 8.933E-01, 3.771E-01, 4.571E-01, 1.011E-01 }, { 1003, 1.4394, 0.000E+00, 0.000E+00, 3.690E-03, 3.915E-01, 2.300E+00, 8.915E-01, 3.757E-01, 4.573E-01, 1.011E-01 }, { 1004, 1.4393, 0.000E+00, 0.000E+00, 3.620E-03, 3.868E-01, 2.300E+00, 8.896E-01, 3.742E-01, 4.576E-01, 1.012E-01 }, { 1005, 1.4392, 0.000E+00, 0.000E+00, 3.552E-03, 3.816E-01, 2.300E+00, 8.878E-01, 3.728E-01, 4.579E-01, 1.012E-01 }, { 1006, 1.4392, 0.000E+00, 0.000E+00, 3.483E-03, 3.760E-01, 2.300E+00, 8.859E-01, 3.713E-01, 4.579E-01, 1.015E-01 }, { 1007, 1.4391, 0.000E+00, 0.000E+00, 3.416E-03, 3.701E-01, 2.300E+00, 8.841E-01, 3.699E-01, 4.580E-01, 1.017E-01 }, { 1008, 1.4391, 0.000E+00, 0.000E+00, 3.348E-03, 3.640E-01, 2.300E+00, 8.822E-01, 3.684E-01, 4.580E-01, 1.019E-01 }, { 1009, 1.4390, 0.000E+00, 0.000E+00, 3.282E-03, 3.581E-01, 2.300E+00, 8.804E-01, 3.670E-01, 4.580E-01, 1.022E-01 }, { 1010, 1.4389, 0.000E+00, 0.000E+00, 3.215E-03, 3.521E-01, 2.300E+00, 8.785E-01, 3.655E-01, 4.581E-01, 1.024E-01 }, { 1011, 1.4387, 0.000E+00, 0.000E+00, 3.150E-03, 3.461E-01, 2.300E+00, 8.767E-01, 3.641E-01, 4.582E-01, 1.026E-01 }, { 1012, 1.4386, 0.000E+00, 0.000E+00, 3.085E-03, 3.402E-01, 2.300E+00, 8.748E-01, 3.626E-01, 4.583E-01, 1.028E-01 }, { 1013, 1.4385, 0.000E+00, 0.000E+00, 3.020E-03, 3.349E-01, 2.300E+00, 8.730E-01, 3.612E-01, 4.584E-01, 1.031E-01 }, { 1014, 1.4384, 0.000E+00, 0.000E+00, 2.956E-03, 3.297E-01, 2.300E+00, 8.711E-01, 3.597E-01, 4.585E-01, 1.033E-01 }, { 1015, 1.4384, 0.000E+00, 0.000E+00, 2.893E-03, 3.243E-01, 2.300E+00, 8.693E-01, 3.583E-01, 4.586E-01, 1.035E-01 }, { 1016, 1.4383, 0.000E+00, 0.000E+00, 2.830E-03, 3.191E-01, 2.300E+00, 8.674E-01, 3.568E-01, 4.589E-01, 1.035E-01 }, { 1017, 1.4381, 0.000E+00, 0.000E+00, 2.768E-03, 3.141E-01, 2.300E+00, 8.656E-01, 3.554E-01, 4.591E-01, 1.035E-01 }, { 1018, 1.4379, 0.000E+00, 0.000E+00, 2.706E-03, 3.086E-01, 2.300E+00, 8.637E-01, 3.539E-01, 4.594E-01, 1.035E-01 }, { 1019, 1.4378, 0.000E+00, 0.000E+00, 2.645E-03, 3.022E-01, 2.300E+00, 8.619E-01, 3.525E-01, 4.597E-01, 1.035E-01 }, { 1020, 1.4376, 0.000E+00, 0.000E+00, 2.585E-03, 2.957E-01, 2.300E+00, 8.600E-01, 3.510E-01, 4.599E-01, 1.035E-01 }, { 1021, 1.4374, 0.000E+00, 0.000E+00, 2.525E-03, 2.897E-01, 2.300E+00, 8.588E-01, 3.499E-01, 4.602E-01, 1.035E-01 }, { 1022, 1.4372, 0.000E+00, 0.000E+00, 2.465E-03, 2.840E-01, 2.300E+00, 8.575E-01, 3.487E-01, 4.604E-01, 1.035E-01 }, { 1023, 1.4371, 0.000E+00, 0.000E+00, 2.407E-03, 2.782E-01, 2.300E+00, 8.563E-01, 3.476E-01, 4.606E-01, 1.035E-01 }, { 1024, 1.4370, 0.000E+00, 0.000E+00, 2.348E-03, 2.724E-01, 2.300E+00, 8.550E-01, 3.464E-01, 4.608E-01, 1.035E-01 }, { 1025, 1.4369, 0.000E+00, 0.000E+00, 2.291E-03, 2.672E-01, 2.300E+00, 8.538E-01, 3.453E-01, 4.611E-01, 1.035E-01 }, { 1026, 1.4368, 0.000E+00, 0.000E+00, 2.234E-03, 2.621E-01, 2.300E+00, 8.525E-01, 3.441E-01, 4.613E-01, 1.042E-01 }, { 1027, 1.4367, 0.000E+00, 0.000E+00, 2.178E-03, 2.566E-01, 2.300E+00, 8.513E-01, 3.430E-01, 4.614E-01, 1.049E-01 }, { 1028, 1.4365, 0.000E+00, 0.000E+00, 2.122E-03, 2.506E-01, 2.300E+00, 8.500E-01, 3.418E-01, 4.616E-01, 1.056E-01 }, { 1029, 1.4365, 0.000E+00, 0.000E+00, 2.067E-03, 2.444E-01, 2.300E+00, 8.488E-01, 3.407E-01, 4.618E-01, 1.063E-01 }, { 1030, 1.4364, 0.000E+00, 0.000E+00, 2.012E-03, 2.391E-01, 2.300E+00, 8.475E-01, 3.395E-01, 4.620E-01, 1.070E-01 }, { 1031, 1.4364, 0.000E+00, 0.000E+00, 1.959E-03, 2.357E-01, 2.300E+00, 8.463E-01, 3.384E-01, 4.622E-01, 1.075E-01 }, { 1032, 1.4363, 0.000E+00, 0.000E+00, 1.905E-03, 2.331E-01, 2.300E+00, 8.450E-01, 3.372E-01, 4.623E-01, 1.080E-01 }, { 1033, 1.4363, 0.000E+00, 0.000E+00, 1.853E-03, 2.299E-01, 2.300E+00, 8.438E-01, 3.361E-01, 4.625E-01, 1.086E-01 }, { 1034, 1.4363, 0.000E+00, 0.000E+00, 1.801E-03, 2.251E-01, 2.300E+00, 8.425E-01, 3.349E-01, 4.627E-01, 1.091E-01 }, { 1035, 1.4363, 0.000E+00, 0.000E+00, 1.750E-03, 2.198E-01, 2.300E+00, 8.413E-01, 3.338E-01, 4.628E-01, 1.096E-01 }, { 1036, 1.4363, 0.000E+00, 0.000E+00, 1.699E-03, 2.151E-01, 2.300E+00, 8.400E-01, 3.326E-01, 4.628E-01, 1.096E-01 }, { 1037, 1.4362, 0.000E+00, 0.000E+00, 1.649E-03, 2.109E-01, 2.300E+00, 8.388E-01, 3.315E-01, 4.627E-01, 1.096E-01 }, { 1038, 1.4361, 0.000E+00, 0.000E+00, 1.600E-03, 2.064E-01, 2.300E+00, 8.375E-01, 3.303E-01, 4.627E-01, 1.096E-01 }, { 1039, 1.4360, 0.000E+00, 0.000E+00, 1.551E-03, 2.020E-01, 2.300E+00, 8.363E-01, 3.292E-01, 4.627E-01, 1.096E-01 }, { 1040, 1.4359, 0.000E+00, 0.000E+00, 1.503E-03, 1.981E-01, 2.300E+00, 8.350E-01, 3.280E-01, 4.626E-01, 1.096E-01 }, { 1041, 1.4357, 0.000E+00, 0.000E+00, 1.456E-03, 1.944E-01, 2.300E+00, 8.333E-01, 3.268E-01, 4.626E-01, 1.096E-01 }, { 1042, 1.4356, 0.000E+00, 0.000E+00, 1.409E-03, 1.904E-01, 2.300E+00, 8.316E-01, 3.256E-01, 4.626E-01, 1.096E-01 }, { 1043, 1.4354, 0.000E+00, 0.000E+00, 1.363E-03, 1.868E-01, 2.300E+00, 8.299E-01, 3.244E-01, 4.625E-01, 1.096E-01 }, { 1044, 1.4352, 0.000E+00, 0.000E+00, 1.318E-03, 1.841E-01, 2.300E+00, 8.282E-01, 3.232E-01, 4.625E-01, 1.096E-01 }, { 1045, 1.4351, 0.000E+00, 0.000E+00, 1.274E-03, 1.818E-01, 2.300E+00, 8.265E-01, 3.220E-01, 4.625E-01, 1.096E-01 }, { 1046, 1.4351, 0.000E+00, 0.000E+00, 1.230E-03, 1.790E-01, 2.300E+00, 8.248E-01, 3.208E-01, 4.625E-01, 1.096E-01 }, { 1047, 1.4350, 0.000E+00, 0.000E+00, 1.187E-03, 1.752E-01, 2.300E+00, 8.231E-01, 3.196E-01, 4.626E-01, 1.096E-01 }, { 1048, 1.4349, 0.000E+00, 0.000E+00, 1.144E-03, 1.715E-01, 2.300E+00, 8.214E-01, 3.184E-01, 4.626E-01, 1.096E-01 }, { 1049, 1.4349, 0.000E+00, 0.000E+00, 1.102E-03, 1.687E-01, 2.300E+00, 8.197E-01, 3.172E-01, 4.627E-01, 1.096E-01 }, { 1050, 1.4348, 0.000E+00, 0.000E+00, 1.061E-03, 1.664E-01, 2.300E+00, 8.180E-01, 3.160E-01, 4.628E-01, 1.096E-01 }, { 1051, 1.4347, 0.000E+00, 0.000E+00, 1.021E-03, 1.639E-01, 2.300E+00, 8.163E-01, 3.148E-01, 4.628E-01, 1.097E-01 }, { 1052, 1.4345, 0.000E+00, 0.000E+00, 9.811E-04, 1.613E-01, 2.300E+00, 8.146E-01, 3.136E-01, 4.629E-01, 1.099E-01 }, { 1053, 1.4343, 0.000E+00, 0.000E+00, 9.422E-04, 1.586E-01, 2.300E+00, 8.129E-01, 3.124E-01, 4.630E-01, 1.100E-01 }, { 1054, 1.4342, 0.000E+00, 0.000E+00, 9.040E-04, 1.562E-01, 2.300E+00, 8.112E-01, 3.112E-01, 4.631E-01, 1.102E-01 }, { 1055, 1.4342, 0.000E+00, 0.000E+00, 8.665E-04, 1.545E-01, 2.300E+00, 8.095E-01, 3.100E-01, 4.631E-01, 1.103E-01 }, { 1056, 1.4342, 0.000E+00, 0.000E+00, 8.297E-04, 1.532E-01, 2.300E+00, 8.078E-01, 3.088E-01, 4.632E-01, 1.105E-01 }, { 1057, 1.4341, 0.000E+00, 0.000E+00, 7.937E-04, 1.522E-01, 2.300E+00, 8.061E-01, 3.076E-01, 4.633E-01, 1.108E-01 }, { 1058, 1.4340, 0.000E+00, 0.000E+00, 7.584E-04, 1.510E-01, 2.300E+00, 8.044E-01, 3.064E-01, 4.634E-01, 1.110E-01 }, { 1059, 1.4339, 0.000E+00, 0.000E+00, 7.239E-04, 1.495E-01, 2.300E+00, 8.027E-01, 3.052E-01, 4.635E-01, 1.112E-01 }, { 1060, 1.4338, 0.000E+00, 0.000E+00, 6.901E-04, 1.475E-01, 2.300E+00, 8.010E-01, 3.040E-01, 4.636E-01, 1.114E-01 }, { 1061, 1.4337, 0.000E+00, 0.000E+00, 6.571E-04, 1.457E-01, 2.300E+00, 7.977E-01, 3.023E-01, 4.640E-01, 1.118E-01 }, { 1062, 1.4335, 0.000E+00, 0.000E+00, 6.248E-04, 1.447E-01, 2.300E+00, 7.944E-01, 3.006E-01, 4.645E-01, 1.121E-01 }, { 1063, 1.4334, 0.000E+00, 0.000E+00, 5.933E-04, 1.442E-01, 2.300E+00, 7.911E-01, 2.989E-01, 4.649E-01, 1.125E-01 }, { 1064, 1.4333, 0.000E+00, 0.000E+00, 5.626E-04, 1.438E-01, 2.300E+00, 7.878E-01, 2.972E-01, 4.653E-01, 1.129E-01 }, { 1065, 1.4333, 0.000E+00, 0.000E+00, 5.326E-04, 1.433E-01, 2.300E+00, 7.845E-01, 2.955E-01, 4.658E-01, 1.132E-01 }, { 1066, 1.4334, 0.000E+00, 0.000E+00, 5.034E-04, 1.426E-01, 2.300E+00, 7.812E-01, 2.938E-01, 4.661E-01, 1.132E-01 }, { 1067, 1.4333, 0.000E+00, 0.000E+00, 4.750E-04, 1.418E-01, 2.300E+00, 7.779E-01, 2.921E-01, 4.664E-01, 1.132E-01 }, { 1068, 1.4333, 0.000E+00, 0.000E+00, 4.473E-04, 1.412E-01, 2.300E+00, 7.746E-01, 2.904E-01, 4.667E-01, 1.132E-01 }, { 1069, 1.4332, 0.000E+00, 0.000E+00, 4.205E-04, 1.410E-01, 2.300E+00, 7.713E-01, 2.887E-01, 4.670E-01, 1.132E-01 }, { 1070, 1.4330, 0.000E+00, 0.000E+00, 3.944E-04, 1.409E-01, 2.300E+00, 7.680E-01, 2.870E-01, 4.673E-01, 1.132E-01 }, { 1071, 1.4329, 0.000E+00, 0.000E+00, 3.691E-04, 1.408E-01, 2.300E+00, 7.647E-01, 2.853E-01, 4.673E-01, 1.135E-01 }, { 1072, 1.4328, 0.000E+00, 0.000E+00, 3.446E-04, 1.406E-01, 2.300E+00, 7.614E-01, 2.836E-01, 4.674E-01, 1.138E-01 }, { 1073, 1.4327, 0.000E+00, 0.000E+00, 3.210E-04, 1.405E-01, 2.300E+00, 7.581E-01, 2.819E-01, 4.675E-01, 1.141E-01 }, { 1074, 1.4325, 0.000E+00, 0.000E+00, 2.981E-04, 1.408E-01, 2.300E+00, 7.548E-01, 2.802E-01, 4.676E-01, 1.144E-01 }, { 1075, 1.4324, 0.000E+00, 0.000E+00, 2.760E-04, 1.414E-01, 2.300E+00, 7.515E-01, 2.785E-01, 4.677E-01, 1.146E-01 }, { 1076, 1.4322, 0.000E+00, 0.000E+00, 2.548E-04, 1.426E-01, 2.300E+00, 7.482E-01, 2.768E-01, 4.677E-01, 1.148E-01 }, { 1077, 1.4321, 0.000E+00, 0.000E+00, 2.344E-04, 1.435E-01, 2.300E+00, 7.449E-01, 2.751E-01, 4.678E-01, 1.150E-01 }, { 1078, 1.4319, 0.000E+00, 0.000E+00, 2.148E-04, 1.438E-01, 2.300E+00, 7.416E-01, 2.734E-01, 4.679E-01, 1.152E-01 }, { 1079, 1.4318, 0.000E+00, 0.000E+00, 1.960E-04, 1.439E-01, 2.300E+00, 7.383E-01, 2.717E-01, 4.680E-01, 1.154E-01 }, { 1080, 1.4317, 0.000E+00, 0.000E+00, 1.780E-04, 1.443E-01, 2.300E+00, 7.350E-01, 2.700E-01, 4.681E-01, 1.156E-01 }, { 1081, 1.4316, 0.000E+00, 0.000E+00, 1.609E-04, 1.456E-01, 2.300E+00, 7.326E-01, 2.687E-01, 4.682E-01, 1.158E-01 }, { 1082, 1.4315, 0.000E+00, 0.000E+00, 1.446E-04, 1.475E-01, 2.300E+00, 7.302E-01, 2.674E-01, 4.684E-01, 1.160E-01 }, { 1083, 1.4314, 0.000E+00, 0.000E+00, 1.292E-04, 1.498E-01, 2.300E+00, 7.278E-01, 2.661E-01, 4.685E-01, 1.162E-01 }, { 1084, 1.4314, 0.000E+00, 0.000E+00, 1.146E-04, 1.519E-01, 2.300E+00, 7.254E-01, 2.648E-01, 4.687E-01, 1.163E-01 }, { 1085, 1.4313, 0.000E+00, 0.000E+00, 1.009E-04, 1.534E-01, 2.300E+00, 7.230E-01, 2.635E-01, 4.688E-01, 1.165E-01 }, { 1086, 1.4312, 0.000E+00, 0.000E+00, 8.804E-05, 1.547E-01, 2.300E+00, 7.206E-01, 2.622E-01, 4.690E-01, 1.168E-01 }, { 1087, 1.4310, 0.000E+00, 0.000E+00, 7.603E-05, 1.561E-01, 2.300E+00, 7.182E-01, 2.609E-01, 4.692E-01, 1.171E-01 }, { 1088, 1.4309, 0.000E+00, 0.000E+00, 6.488E-05, 1.580E-01, 2.300E+00, 7.158E-01, 2.596E-01, 4.694E-01, 1.174E-01 }, { 1089, 1.4307, 0.000E+00, 0.000E+00, 5.460E-05, 1.604E-01, 2.300E+00, 7.134E-01, 2.583E-01, 4.696E-01, 1.176E-01 }, { 1090, 1.4305, 0.000E+00, 0.000E+00, 4.519E-05, 1.632E-01, 2.300E+00, 7.110E-01, 2.570E-01, 4.698E-01, 1.179E-01 }, { 1091, 1.4304, 0.000E+00, 0.000E+00, 3.666E-05, 1.659E-01, 2.300E+00, 7.086E-01, 2.557E-01, 4.701E-01, 1.182E-01 }, { 1092, 1.4303, 0.000E+00, 0.000E+00, 2.901E-05, 1.677E-01, 2.300E+00, 7.062E-01, 2.544E-01, 4.704E-01, 1.184E-01 }, { 1093, 1.4302, 0.000E+00, 0.000E+00, 2.225E-05, 1.693E-01, 2.300E+00, 7.038E-01, 2.531E-01, 4.708E-01, 1.186E-01 }, { 1094, 1.4302, 0.000E+00, 0.000E+00, 1.637E-05, 1.712E-01, 2.300E+00, 7.014E-01, 2.518E-01, 4.711E-01, 1.188E-01 }, { 1095, 1.4301, 0.000E+00, 0.000E+00, 1.138E-05, 1.739E-01, 2.300E+00, 6.990E-01, 2.505E-01, 4.714E-01, 1.191E-01 }, { 1096, 1.4300, 0.000E+00, 0.000E+00, 7.297E-06, 1.777E-01, 2.300E+00, 6.966E-01, 2.492E-01, 4.715E-01, 1.191E-01 }, { 1097, 1.4297, 0.000E+00, 0.000E+00, 4.111E-06, 1.824E-01, 2.300E+00, 6.942E-01, 2.479E-01, 4.716E-01, 1.192E-01 }, { 1098, 1.4295, 0.000E+00, 0.000E+00, 1.830E-06, 1.866E-01, 2.300E+00, 6.918E-01, 2.466E-01, 4.716E-01, 1.193E-01 }, { 1099, 1.4294, 0.000E+00, 0.000E+00, 4.581E-07, 1.890E-01, 2.300E+00, 6.894E-01, 2.453E-01, 4.717E-01, 1.194E-01 }, { 1100, 1.4293, 0.000E+00, 0.000E+00, 0.000E+00, 1.906E-01, 2.300E+00, 6.870E-01, 2.440E-01, 4.718E-01, 1.195E-01 }, { 1101, 1.4292, 0.000E+00, 0.000E+00, 0.000E+00, 1.929E-01, 2.300E+00, 6.634E-01, 2.356E-01, 4.717E-01, 1.196E-01 }, { 1102, 1.4291, 0.000E+00, 0.000E+00, 0.000E+00, 1.967E-01, 2.300E+00, 6.397E-01, 2.271E-01, 4.717E-01, 1.197E-01 }, { 1103, 1.4290, 0.000E+00, 0.000E+00, 0.000E+00, 2.005E-01, 2.300E+00, 6.161E-01, 2.187E-01, 4.716E-01, 1.199E-01 }, { 1104, 1.4289, 0.000E+00, 0.000E+00, 0.000E+00, 2.031E-01, 2.300E+00, 5.924E-01, 2.102E-01, 4.716E-01, 1.200E-01 }, { 1105, 1.4288, 0.000E+00, 0.000E+00, 0.000E+00, 2.051E-01, 2.300E+00, 5.688E-01, 2.018E-01, 4.715E-01, 1.202E-01 }, { 1106, 1.4286, 0.000E+00, 0.000E+00, 0.000E+00, 2.079E-01, 2.300E+00, 5.451E-01, 1.933E-01, 4.718E-01, 1.204E-01 }, { 1107, 1.4284, 0.000E+00, 0.000E+00, 0.000E+00, 2.123E-01, 2.300E+00, 5.215E-01, 1.849E-01, 4.720E-01, 1.206E-01 }, { 1108, 1.4283, 0.000E+00, 0.000E+00, 0.000E+00, 2.166E-01, 2.300E+00, 4.978E-01, 1.764E-01, 4.723E-01, 1.209E-01 }, { 1109, 1.4283, 0.000E+00, 0.000E+00, 0.000E+00, 2.196E-01, 2.300E+00, 4.742E-01, 1.680E-01, 4.725E-01, 1.211E-01 }, { 1110, 1.4284, 0.000E+00, 0.000E+00, 0.000E+00, 2.219E-01, 2.300E+00, 4.505E-01, 1.595E-01, 4.728E-01, 1.213E-01 }, { 1111, 1.4284, 0.000E+00, 0.000E+00, 0.000E+00, 2.251E-01, 2.300E+00, 4.269E-01, 1.511E-01, 4.731E-01, 1.215E-01 }, { 1112, 1.4284, 0.000E+00, 0.000E+00, 0.000E+00, 2.298E-01, 2.300E+00, 4.032E-01, 1.426E-01, 4.733E-01, 1.217E-01 }, { 1113, 1.4284, 0.000E+00, 0.000E+00, 0.000E+00, 2.337E-01, 2.300E+00, 3.796E-01, 1.342E-01, 4.736E-01, 1.218E-01 }, { 1114, 1.4283, 0.000E+00, 0.000E+00, 0.000E+00, 2.346E-01, 2.300E+00, 3.559E-01, 1.257E-01, 4.739E-01, 1.220E-01 }, { 1115, 1.4282, 0.000E+00, 0.000E+00, 0.000E+00, 2.342E-01, 2.300E+00, 3.323E-01, 1.173E-01, 4.742E-01, 1.221E-01 }, { 1116, 1.4282, 0.000E+00, 0.000E+00, 0.000E+00, 2.353E-01, 2.300E+00, 3.086E-01, 1.088E-01, 4.743E-01, 1.223E-01 }, { 1117, 1.4280, 0.000E+00, 0.000E+00, 0.000E+00, 2.397E-01, 2.300E+00, 2.850E-01, 1.004E-01, 4.745E-01, 1.225E-01 }, { 1118, 1.4278, 0.000E+00, 0.000E+00, 0.000E+00, 2.450E-01, 2.300E+00, 2.613E-01, 9.190E-02, 4.746E-01, 1.226E-01 }, { 1119, 1.4276, 0.000E+00, 0.000E+00, 0.000E+00, 2.491E-01, 2.300E+00, 2.377E-01, 8.345E-02, 4.748E-01, 1.228E-01 }, { 1120, 1.4275, 0.000E+00, 0.000E+00, 0.000E+00, 2.528E-01, 2.300E+00, 2.140E-01, 7.500E-02, 4.749E-01, 1.229E-01 }, { 1121, 1.4274, 0.000E+00, 0.000E+00, 0.000E+00, 2.578E-01, 2.300E+00, 2.231E-01, 7.790E-02, 4.749E-01, 1.231E-01 }, { 1122, 1.4272, 0.000E+00, 0.000E+00, 0.000E+00, 2.650E-01, 2.300E+00, 2.321E-01, 8.080E-02, 4.749E-01, 1.233E-01 }, { 1123, 1.4270, 0.000E+00, 0.000E+00, 0.000E+00, 2.719E-01, 2.300E+00, 2.412E-01, 8.370E-02, 4.749E-01, 1.234E-01 }, { 1124, 1.4268, 0.000E+00, 0.000E+00, 0.000E+00, 2.765E-01, 2.300E+00, 2.502E-01, 8.660E-02, 4.749E-01, 1.236E-01 }, { 1125, 1.4267, 0.000E+00, 0.000E+00, 0.000E+00, 2.811E-01, 2.300E+00, 2.593E-01, 8.950E-02, 4.749E-01, 1.238E-01 }, { 1126, 1.4267, 0.000E+00, 0.000E+00, 0.000E+00, 2.891E-01, 2.300E+00, 2.683E-01, 9.240E-02, 4.749E-01, 1.240E-01 }, { 1127, 1.4266, 0.000E+00, 0.000E+00, 0.000E+00, 3.023E-01, 2.300E+00, 2.774E-01, 9.530E-02, 4.749E-01, 1.241E-01 }, { 1128, 1.4265, 0.000E+00, 0.000E+00, 0.000E+00, 3.164E-01, 2.300E+00, 2.864E-01, 9.820E-02, 4.749E-01, 1.243E-01 }, { 1129, 1.4264, 0.000E+00, 0.000E+00, 0.000E+00, 3.271E-01, 2.300E+00, 2.955E-01, 1.011E-01, 4.749E-01, 1.245E-01 }, { 1130, 1.4263, 0.000E+00, 0.000E+00, 0.000E+00, 3.378E-01, 2.300E+00, 3.045E-01, 1.040E-01, 4.749E-01, 1.246E-01 }, { 1131, 1.4262, 0.000E+00, 0.000E+00, 0.000E+00, 3.533E-01, 2.300E+00, 3.136E-01, 1.069E-01, 4.751E-01, 1.248E-01 }, { 1132, 1.4260, 0.000E+00, 0.000E+00, 0.000E+00, 3.770E-01, 2.300E+00, 3.226E-01, 1.098E-01, 4.753E-01, 1.250E-01 }, { 1133, 1.4259, 0.000E+00, 0.000E+00, 0.000E+00, 4.037E-01, 2.300E+00, 3.317E-01, 1.127E-01, 4.755E-01, 1.252E-01 }, { 1134, 1.4258, 0.000E+00, 0.000E+00, 0.000E+00, 4.281E-01, 2.300E+00, 3.407E-01, 1.156E-01, 4.757E-01, 1.253E-01 }, { 1135, 1.4257, 0.000E+00, 0.000E+00, 0.000E+00, 4.502E-01, 2.300E+00, 3.498E-01, 1.185E-01, 4.759E-01, 1.255E-01 }, { 1136, 1.4256, 0.000E+00, 0.000E+00, 0.000E+00, 4.712E-01, 2.300E+00, 3.588E-01, 1.214E-01, 4.761E-01, 1.257E-01 }, { 1137, 1.4256, 0.000E+00, 0.000E+00, 0.000E+00, 4.932E-01, 2.300E+00, 3.679E-01, 1.243E-01, 4.764E-01, 1.259E-01 }, { 1138, 1.4255, 0.000E+00, 0.000E+00, 0.000E+00, 5.202E-01, 2.300E+00, 3.769E-01, 1.272E-01, 4.766E-01, 1.261E-01 }, { 1139, 1.4254, 0.000E+00, 0.000E+00, 0.000E+00, 5.572E-01, 2.300E+00, 3.860E-01, 1.301E-01, 4.768E-01, 1.263E-01 }, { 1140, 1.4252, 0.000E+00, 0.000E+00, 0.000E+00, 6.052E-01, 2.300E+00, 3.950E-01, 1.330E-01, 4.770E-01, 1.265E-01 }, { 1141, 1.4250, 0.000E+00, 0.000E+00, 0.000E+00, 6.520E-01, 2.300E+00, 3.950E-01, 1.328E-01, 4.773E-01, 1.267E-01 }, { 1142, 1.4249, 0.000E+00, 0.000E+00, 0.000E+00, 6.863E-01, 2.300E+00, 3.949E-01, 1.326E-01, 4.775E-01, 1.268E-01 }, { 1143, 1.4248, 0.000E+00, 0.000E+00, 0.000E+00, 7.159E-01, 2.300E+00, 3.949E-01, 1.324E-01, 4.777E-01, 1.269E-01 }, { 1144, 1.4247, 0.000E+00, 0.000E+00, 0.000E+00, 7.535E-01, 2.300E+00, 3.948E-01, 1.322E-01, 4.779E-01, 1.271E-01 }, { 1145, 1.4244, 0.000E+00, 0.000E+00, 0.000E+00, 8.064E-01, 2.300E+00, 3.948E-01, 1.320E-01, 4.782E-01, 1.272E-01 }, { 1146, 1.4241, 0.000E+00, 0.000E+00, 0.000E+00, 8.597E-01, 2.300E+00, 3.947E-01, 1.318E-01, 4.784E-01, 1.274E-01 }, { 1147, 1.4239, 0.000E+00, 0.000E+00, 0.000E+00, 8.981E-01, 2.300E+00, 3.947E-01, 1.316E-01, 4.786E-01, 1.275E-01 }, { 1148, 1.4237, 0.000E+00, 0.000E+00, 0.000E+00, 9.253E-01, 2.300E+00, 3.946E-01, 1.314E-01, 4.788E-01, 1.277E-01 }, { 1149, 1.4235, 0.000E+00, 0.000E+00, 0.000E+00, 9.493E-01, 2.300E+00, 3.946E-01, 1.312E-01, 4.791E-01, 1.278E-01 }, { 1150, 1.4234, 0.000E+00, 0.000E+00, 0.000E+00, 9.769E-01, 2.300E+00, 3.945E-01, 1.310E-01, 4.793E-01, 1.279E-01 }, { 1151, 1.4233, 0.000E+00, 0.000E+00, 0.000E+00, 1.008E+00, 2.300E+00, 3.945E-01, 1.308E-01, 4.793E-01, 1.281E-01 }, { 1152, 1.4231, 0.000E+00, 0.000E+00, 0.000E+00, 1.041E+00, 2.300E+00, 3.944E-01, 1.306E-01, 4.794E-01, 1.282E-01 }, { 1153, 1.4230, 0.000E+00, 0.000E+00, 0.000E+00, 1.073E+00, 2.300E+00, 3.944E-01, 1.304E-01, 4.794E-01, 1.284E-01 }, { 1154, 1.4228, 0.000E+00, 0.000E+00, 0.000E+00, 1.100E+00, 2.300E+00, 3.943E-01, 1.302E-01, 4.795E-01, 1.285E-01 }, { 1155, 1.4226, 0.000E+00, 0.000E+00, 0.000E+00, 1.119E+00, 2.300E+00, 3.943E-01, 1.300E-01, 4.796E-01, 1.287E-01 }, { 1156, 1.4224, 0.000E+00, 0.000E+00, 0.000E+00, 1.131E+00, 2.300E+00, 3.942E-01, 1.298E-01, 4.795E-01, 1.288E-01 }, { 1157, 1.4224, 0.000E+00, 0.000E+00, 0.000E+00, 1.140E+00, 2.300E+00, 3.942E-01, 1.296E-01, 4.795E-01, 1.290E-01 }, { 1158, 1.4223, 0.000E+00, 0.000E+00, 0.000E+00, 1.150E+00, 2.300E+00, 3.941E-01, 1.294E-01, 4.795E-01, 1.291E-01 }, { 1159, 1.4223, 0.000E+00, 0.000E+00, 0.000E+00, 1.160E+00, 2.300E+00, 3.941E-01, 1.292E-01, 4.795E-01, 1.293E-01 }, { 1160, 1.4222, 0.000E+00, 0.000E+00, 0.000E+00, 1.170E+00, 2.300E+00, 3.940E-01, 1.290E-01, 4.795E-01, 1.294E-01 }, { 1161, 1.4222, 0.000E+00, 0.000E+00, 0.000E+00, 1.181E+00, 2.300E+00, 4.020E-01, 1.314E-01, 4.799E-01, 1.296E-01 }, { 1162, 1.4221, 0.000E+00, 0.000E+00, 0.000E+00, 1.190E+00, 2.300E+00, 4.099E-01, 1.337E-01, 4.802E-01, 1.297E-01 }, { 1163, 1.4221, 0.000E+00, 0.000E+00, 0.000E+00, 1.194E+00, 2.300E+00, 4.179E-01, 1.361E-01, 4.805E-01, 1.299E-01 }, { 1164, 1.4221, 0.000E+00, 0.000E+00, 0.000E+00, 1.196E+00, 2.300E+00, 4.258E-01, 1.384E-01, 4.808E-01, 1.300E-01 }, { 1165, 1.4219, 0.000E+00, 0.000E+00, 0.000E+00, 1.197E+00, 2.300E+00, 4.338E-01, 1.408E-01, 4.811E-01, 1.302E-01 }, { 1166, 1.4217, 0.000E+00, 0.000E+00, 0.000E+00, 1.200E+00, 2.300E+00, 4.417E-01, 1.431E-01, 4.811E-01, 1.303E-01 }, { 1167, 1.4216, 0.000E+00, 0.000E+00, 0.000E+00, 1.203E+00, 2.300E+00, 4.497E-01, 1.455E-01, 4.811E-01, 1.304E-01 }, { 1168, 1.4215, 0.000E+00, 0.000E+00, 0.000E+00, 1.205E+00, 2.300E+00, 4.576E-01, 1.478E-01, 4.811E-01, 1.306E-01 }, { 1169, 1.4215, 0.000E+00, 0.000E+00, 0.000E+00, 1.206E+00, 2.300E+00, 4.656E-01, 1.502E-01, 4.811E-01, 1.307E-01 }, { 1170, 1.4214, 0.000E+00, 0.000E+00, 0.000E+00, 1.207E+00, 2.300E+00, 4.735E-01, 1.525E-01, 4.811E-01, 1.309E-01 }, { 1171, 1.4212, 0.000E+00, 0.000E+00, 0.000E+00, 1.213E+00, 2.300E+00, 4.815E-01, 1.549E-01, 4.813E-01, 1.310E-01 }, { 1172, 1.4210, 0.000E+00, 0.000E+00, 0.000E+00, 1.223E+00, 2.300E+00, 4.894E-01, 1.572E-01, 4.815E-01, 1.312E-01 }, { 1173, 1.4208, 0.000E+00, 0.000E+00, 0.000E+00, 1.232E+00, 2.300E+00, 4.974E-01, 1.596E-01, 4.816E-01, 1.314E-01 }, { 1174, 1.4207, 0.000E+00, 0.000E+00, 0.000E+00, 1.234E+00, 2.300E+00, 5.053E-01, 1.619E-01, 4.818E-01, 1.316E-01 }, { 1175, 1.4206, 0.000E+00, 0.000E+00, 0.000E+00, 1.232E+00, 2.300E+00, 5.133E-01, 1.643E-01, 4.820E-01, 1.318E-01 }, { 1176, 1.4206, 0.000E+00, 0.000E+00, 0.000E+00, 1.229E+00, 2.300E+00, 5.212E-01, 1.666E-01, 4.825E-01, 1.320E-01 }, { 1177, 1.4206, 0.000E+00, 0.000E+00, 0.000E+00, 1.230E+00, 2.300E+00, 5.292E-01, 1.690E-01, 4.829E-01, 1.322E-01 }, { 1178, 1.4206, 0.000E+00, 0.000E+00, 0.000E+00, 1.233E+00, 2.300E+00, 5.371E-01, 1.713E-01, 4.833E-01, 1.323E-01 }, { 1179, 1.4206, 0.000E+00, 0.000E+00, 0.000E+00, 1.236E+00, 2.300E+00, 5.451E-01, 1.737E-01, 4.838E-01, 1.325E-01 }, { 1180, 1.4205, 0.000E+00, 0.000E+00, 0.000E+00, 1.239E+00, 2.300E+00, 5.530E-01, 1.760E-01, 4.842E-01, 1.327E-01 }, { 1181, 1.4203, 0.000E+00, 0.000E+00, 0.000E+00, 1.241E+00, 2.300E+00, 5.526E-01, 1.757E-01, 4.845E-01, 1.329E-01 }, { 1182, 1.4200, 0.000E+00, 0.000E+00, 0.000E+00, 1.244E+00, 2.300E+00, 5.522E-01, 1.754E-01, 4.847E-01, 1.331E-01 }, { 1183, 1.4199, 0.000E+00, 0.000E+00, 0.000E+00, 1.248E+00, 2.300E+00, 5.518E-01, 1.751E-01, 4.850E-01, 1.334E-01 }, { 1184, 1.4198, 0.000E+00, 0.000E+00, 0.000E+00, 1.252E+00, 2.300E+00, 5.514E-01, 1.748E-01, 4.852E-01, 1.336E-01 }, { 1185, 1.4199, 0.000E+00, 0.000E+00, 0.000E+00, 1.256E+00, 2.300E+00, 5.510E-01, 1.745E-01, 4.855E-01, 1.338E-01 }, { 1186, 1.4201, 0.000E+00, 0.000E+00, 0.000E+00, 1.258E+00, 2.300E+00, 5.506E-01, 1.742E-01, 4.857E-01, 1.340E-01 }, { 1187, 1.4204, 0.000E+00, 0.000E+00, 0.000E+00, 1.260E+00, 2.300E+00, 5.502E-01, 1.739E-01, 4.858E-01, 1.343E-01 }, { 1188, 1.4205, 0.000E+00, 0.000E+00, 0.000E+00, 1.262E+00, 2.300E+00, 5.498E-01, 1.736E-01, 4.860E-01, 1.346E-01 }, { 1189, 1.4205, 0.000E+00, 0.000E+00, 0.000E+00, 1.265E+00, 2.300E+00, 5.494E-01, 1.733E-01, 4.862E-01, 1.348E-01 }, { 1190, 1.4203, 0.000E+00, 0.000E+00, 0.000E+00, 1.267E+00, 2.300E+00, 5.490E-01, 1.730E-01, 4.864E-01, 1.351E-01 }, { 1191, 1.4200, 0.000E+00, 0.000E+00, 0.000E+00, 1.270E+00, 2.300E+00, 5.486E-01, 1.727E-01, 4.863E-01, 1.352E-01 }, { 1192, 1.4196, 0.000E+00, 0.000E+00, 0.000E+00, 1.272E+00, 2.300E+00, 5.482E-01, 1.724E-01, 4.863E-01, 1.353E-01 }, { 1193, 1.4192, 0.000E+00, 0.000E+00, 0.000E+00, 1.275E+00, 2.300E+00, 5.478E-01, 1.721E-01, 4.863E-01, 1.353E-01 }, { 1194, 1.4189, 0.000E+00, 0.000E+00, 0.000E+00, 1.277E+00, 2.300E+00, 5.474E-01, 1.718E-01, 4.863E-01, 1.354E-01 }, { 1195, 1.4187, 0.000E+00, 0.000E+00, 0.000E+00, 1.280E+00, 2.300E+00, 5.470E-01, 1.715E-01, 4.863E-01, 1.355E-01 }, { 1196, 1.4187, 0.000E+00, 0.000E+00, 0.000E+00, 1.282E+00, 2.300E+00, 5.466E-01, 1.712E-01, 4.863E-01, 1.358E-01 }, { 1197, 1.4188, 0.000E+00, 0.000E+00, 0.000E+00, 1.283E+00, 2.300E+00, 5.462E-01, 1.709E-01, 4.864E-01, 1.361E-01 }, { 1198, 1.4188, 0.000E+00, 0.000E+00, 0.000E+00, 1.283E+00, 2.300E+00, 5.458E-01, 1.706E-01, 4.864E-01, 1.364E-01 }, { 1199, 1.4187, 0.000E+00, 0.000E+00, 0.000E+00, 1.279E+00, 2.300E+00, 5.454E-01, 1.703E-01, 4.864E-01, 1.367E-01 }, { 1200, 1.4186, 0.000E+00, 0.000E+00, 0.000E+00, 1.272E+00, 2.300E+00, 5.450E-01, 1.700E-01, 4.864E-01, 1.369E-01 }, { 1201, 1.4185, 0.000E+00, 0.000E+00, 0.000E+00, 1.266E+00, 2.300E+00, 5.477E-01, 1.707E-01, 4.866E-01, 1.371E-01 }, { 1202, 1.4182, 0.000E+00, 0.000E+00, 0.000E+00, 1.267E+00, 2.301E+00, 5.504E-01, 1.713E-01, 4.868E-01, 1.373E-01 }, { 1203, 1.4181, 0.000E+00, 0.000E+00, 0.000E+00, 1.271E+00, 2.301E+00, 5.531E-01, 1.720E-01, 4.870E-01, 1.374E-01 }, { 1204, 1.4179, 0.000E+00, 0.000E+00, 0.000E+00, 1.273E+00, 2.302E+00, 5.558E-01, 1.726E-01, 4.872E-01, 1.376E-01 }, { 1205, 1.4178, 0.000E+00, 0.000E+00, 0.000E+00, 1.271E+00, 2.303E+00, 5.585E-01, 1.733E-01, 4.874E-01, 1.377E-01 }, { 1206, 1.4177, 0.000E+00, 0.000E+00, 0.000E+00, 1.265E+00, 2.305E+00, 5.612E-01, 1.739E-01, 4.875E-01, 1.383E-01 }, { 1207, 1.4177, 0.000E+00, 0.000E+00, 0.000E+00, 1.260E+00, 2.306E+00, 5.639E-01, 1.746E-01, 4.875E-01, 1.388E-01 }, { 1208, 1.4176, 0.000E+00, 0.000E+00, 0.000E+00, 1.258E+00, 2.308E+00, 5.666E-01, 1.752E-01, 4.876E-01, 1.394E-01 }, { 1209, 1.4175, 0.000E+00, 0.000E+00, 0.000E+00, 1.258E+00, 2.310E+00, 5.693E-01, 1.759E-01, 4.877E-01, 1.399E-01 }, { 1210, 1.4173, 0.000E+00, 0.000E+00, 0.000E+00, 1.257E+00, 2.312E+00, 5.720E-01, 1.765E-01, 4.877E-01, 1.405E-01 }, { 1211, 1.4173, 0.000E+00, 0.000E+00, 0.000E+00, 1.252E+00, 2.315E+00, 5.747E-01, 1.772E-01, 4.878E-01, 1.407E-01 }, { 1212, 1.4172, 0.000E+00, 0.000E+00, 0.000E+00, 1.247E+00, 2.317E+00, 5.774E-01, 1.778E-01, 4.878E-01, 1.409E-01 }, { 1213, 1.4171, 0.000E+00, 0.000E+00, 0.000E+00, 1.243E+00, 2.320E+00, 5.801E-01, 1.785E-01, 4.878E-01, 1.411E-01 }, { 1214, 1.4170, 0.000E+00, 0.000E+00, 0.000E+00, 1.243E+00, 2.323E+00, 5.828E-01, 1.791E-01, 4.878E-01, 1.412E-01 }, { 1215, 1.4168, 0.000E+00, 0.000E+00, 0.000E+00, 1.243E+00, 2.327E+00, 5.855E-01, 1.798E-01, 4.879E-01, 1.414E-01 }, { 1216, 1.4167, 0.000E+00, 0.000E+00, 0.000E+00, 1.240E+00, 2.330E+00, 5.882E-01, 1.804E-01, 4.881E-01, 1.415E-01 }, { 1217, 1.4165, 0.000E+00, 0.000E+00, 0.000E+00, 1.233E+00, 2.334E+00, 5.909E-01, 1.811E-01, 4.884E-01, 1.415E-01 }, { 1218, 1.4164, 0.000E+00, 0.000E+00, 0.000E+00, 1.224E+00, 2.338E+00, 5.936E-01, 1.817E-01, 4.887E-01, 1.415E-01 }, { 1219, 1.4163, 0.000E+00, 0.000E+00, 0.000E+00, 1.216E+00, 2.342E+00, 5.963E-01, 1.824E-01, 4.889E-01, 1.416E-01 }, { 1220, 1.4161, 0.000E+00, 0.000E+00, 0.000E+00, 1.214E+00, 2.346E+00, 5.990E-01, 1.830E-01, 4.892E-01, 1.416E-01 }, { 1221, 1.4158, 0.000E+00, 0.000E+00, 0.000E+00, 1.214E+00, 2.350E+00, 5.984E-01, 1.826E-01, 4.893E-01, 1.420E-01 }, { 1222, 1.4156, 0.000E+00, 0.000E+00, 0.000E+00, 1.213E+00, 2.354E+00, 5.978E-01, 1.822E-01, 4.893E-01, 1.423E-01 }, { 1223, 1.4155, 0.000E+00, 0.000E+00, 0.000E+00, 1.210E+00, 2.359E+00, 5.972E-01, 1.818E-01, 4.894E-01, 1.427E-01 }, { 1224, 1.4154, 0.000E+00, 0.000E+00, 0.000E+00, 1.205E+00, 2.364E+00, 5.966E-01, 1.814E-01, 4.895E-01, 1.431E-01 }, { 1225, 1.4153, 0.000E+00, 0.000E+00, 0.000E+00, 1.200E+00, 2.369E+00, 5.960E-01, 1.810E-01, 4.896E-01, 1.434E-01 }, { 1226, 1.4151, 0.000E+00, 0.000E+00, 0.000E+00, 1.199E+00, 2.374E+00, 5.954E-01, 1.806E-01, 4.897E-01, 1.438E-01 }, { 1227, 1.4151, 0.000E+00, 0.000E+00, 0.000E+00, 1.198E+00, 2.379E+00, 5.948E-01, 1.802E-01, 4.897E-01, 1.442E-01 }, { 1228, 1.4151, 0.000E+00, 0.000E+00, 0.000E+00, 1.197E+00, 2.384E+00, 5.942E-01, 1.798E-01, 4.898E-01, 1.445E-01 }, { 1229, 1.4150, 0.000E+00, 0.000E+00, 0.000E+00, 1.194E+00, 2.389E+00, 5.936E-01, 1.794E-01, 4.899E-01, 1.449E-01 }, { 1230, 1.4148, 0.000E+00, 0.000E+00, 0.000E+00, 1.189E+00, 2.395E+00, 5.930E-01, 1.790E-01, 4.900E-01, 1.453E-01 }, { 1231, 1.4147, 0.000E+00, 0.000E+00, 0.000E+00, 1.184E+00, 2.400E+00, 5.924E-01, 1.786E-01, 4.901E-01, 1.453E-01 }, { 1232, 1.4146, 0.000E+00, 0.000E+00, 0.000E+00, 1.180E+00, 2.406E+00, 5.918E-01, 1.782E-01, 4.902E-01, 1.452E-01 }, { 1233, 1.4145, 0.000E+00, 0.000E+00, 0.000E+00, 1.176E+00, 2.412E+00, 5.912E-01, 1.778E-01, 4.903E-01, 1.452E-01 }, { 1234, 1.4144, 0.000E+00, 0.000E+00, 0.000E+00, 1.171E+00, 2.418E+00, 5.906E-01, 1.774E-01, 4.904E-01, 1.452E-01 }, { 1235, 1.4143, 0.000E+00, 0.000E+00, 0.000E+00, 1.166E+00, 2.423E+00, 5.900E-01, 1.770E-01, 4.905E-01, 1.452E-01 }, { 1236, 1.4141, 0.000E+00, 0.000E+00, 0.000E+00, 1.161E+00, 2.430E+00, 5.894E-01, 1.766E-01, 4.907E-01, 1.453E-01 }, { 1237, 1.4139, 0.000E+00, 0.000E+00, 0.000E+00, 1.158E+00, 2.436E+00, 5.888E-01, 1.762E-01, 4.909E-01, 1.454E-01 }, { 1238, 1.4136, 0.000E+00, 0.000E+00, 0.000E+00, 1.157E+00, 2.442E+00, 5.882E-01, 1.758E-01, 4.912E-01, 1.455E-01 }, { 1239, 1.4134, 0.000E+00, 0.000E+00, 0.000E+00, 1.157E+00, 2.448E+00, 5.876E-01, 1.754E-01, 4.914E-01, 1.455E-01 }, { 1240, 1.4133, 0.000E+00, 0.000E+00, 0.000E+00, 1.155E+00, 2.454E+00, 5.870E-01, 1.750E-01, 4.916E-01, 1.456E-01 }, { 1241, 1.4130, 0.000E+00, 0.000E+00, 0.000E+00, 1.152E+00, 2.461E+00, 5.848E-01, 1.742E-01, 4.919E-01, 1.456E-01 }, { 1242, 1.4128, 0.000E+00, 0.000E+00, 0.000E+00, 1.148E+00, 2.467E+00, 5.825E-01, 1.734E-01, 4.921E-01, 1.456E-01 }, { 1243, 1.4128, 0.000E+00, 0.000E+00, 0.000E+00, 1.142E+00, 2.473E+00, 5.803E-01, 1.726E-01, 4.924E-01, 1.456E-01 }, { 1244, 1.4128, 0.000E+00, 0.000E+00, 0.000E+00, 1.138E+00, 2.480E+00, 5.780E-01, 1.718E-01, 4.926E-01, 1.456E-01 }, { 1245, 1.4127, 0.000E+00, 0.000E+00, 0.000E+00, 1.133E+00, 2.486E+00, 5.758E-01, 1.710E-01, 4.929E-01, 1.456E-01 }, { 1246, 1.4126, 0.000E+00, 0.000E+00, 0.000E+00, 1.130E+00, 2.493E+00, 5.735E-01, 1.702E-01, 4.929E-01, 1.458E-01 }, { 1247, 1.4124, 0.000E+00, 0.000E+00, 0.000E+00, 1.126E+00, 2.499E+00, 5.713E-01, 1.694E-01, 4.929E-01, 1.460E-01 }, { 1248, 1.4122, 0.000E+00, 0.000E+00, 0.000E+00, 1.123E+00, 2.506E+00, 5.690E-01, 1.686E-01, 4.930E-01, 1.462E-01 }, { 1249, 1.4122, 0.000E+00, 0.000E+00, 0.000E+00, 1.120E+00, 2.512E+00, 5.668E-01, 1.678E-01, 4.930E-01, 1.464E-01 }, { 1250, 1.4121, 0.000E+00, 0.000E+00, 0.000E+00, 1.116E+00, 2.519E+00, 5.645E-01, 1.670E-01, 4.930E-01, 1.467E-01 }, { 1251, 1.4121, 0.000E+00, 0.000E+00, 0.000E+00, 1.111E+00, 2.525E+00, 5.623E-01, 1.662E-01, 4.929E-01, 1.469E-01 }, { 1252, 1.4121, 0.000E+00, 0.000E+00, 0.000E+00, 1.107E+00, 2.532E+00, 5.600E-01, 1.654E-01, 4.928E-01, 1.471E-01 }, { 1253, 1.4119, 0.000E+00, 0.000E+00, 0.000E+00, 1.103E+00, 2.538E+00, 5.578E-01, 1.646E-01, 4.927E-01, 1.474E-01 }, { 1254, 1.4118, 0.000E+00, 0.000E+00, 0.000E+00, 1.101E+00, 2.545E+00, 5.555E-01, 1.638E-01, 4.926E-01, 1.476E-01 }, { 1255, 1.4116, 0.000E+00, 0.000E+00, 0.000E+00, 1.101E+00, 2.551E+00, 5.533E-01, 1.630E-01, 4.924E-01, 1.478E-01 }, { 1256, 1.4115, 0.000E+00, 0.000E+00, 0.000E+00, 1.101E+00, 2.558E+00, 5.510E-01, 1.622E-01, 4.926E-01, 1.479E-01 }, { 1257, 1.4113, 0.000E+00, 0.000E+00, 0.000E+00, 1.101E+00, 2.564E+00, 5.488E-01, 1.614E-01, 4.928E-01, 1.479E-01 }, { 1258, 1.4112, 0.000E+00, 0.000E+00, 0.000E+00, 1.100E+00, 2.570E+00, 5.465E-01, 1.606E-01, 4.930E-01, 1.480E-01 }, { 1259, 1.4112, 0.000E+00, 0.000E+00, 0.000E+00, 1.098E+00, 2.577E+00, 5.443E-01, 1.598E-01, 4.932E-01, 1.480E-01 }, { 1260, 1.4111, 0.000E+00, 0.000E+00, 0.000E+00, 1.094E+00, 2.583E+00, 5.420E-01, 1.590E-01, 4.934E-01, 1.481E-01 }, { 1261, 1.4111, 0.000E+00, 0.000E+00, 0.000E+00, 1.089E+00, 2.589E+00, 5.406E-01, 1.585E-01, 4.935E-01, 1.481E-01 }, { 1262, 1.4110, 0.000E+00, 0.000E+00, 0.000E+00, 1.085E+00, 2.595E+00, 5.392E-01, 1.579E-01, 4.936E-01, 1.481E-01 }, { 1263, 1.4108, 0.000E+00, 0.000E+00, 0.000E+00, 1.084E+00, 2.601E+00, 5.378E-01, 1.574E-01, 4.937E-01, 1.481E-01 }, { 1264, 1.4106, 0.000E+00, 0.000E+00, 0.000E+00, 1.083E+00, 2.607E+00, 5.364E-01, 1.568E-01, 4.938E-01, 1.481E-01 }, { 1265, 1.4104, 0.000E+00, 0.000E+00, 0.000E+00, 1.083E+00, 2.613E+00, 5.350E-01, 1.563E-01, 4.939E-01, 1.481E-01 }, { 1266, 1.4102, 0.000E+00, 0.000E+00, 0.000E+00, 1.082E+00, 2.619E+00, 5.336E-01, 1.557E-01, 4.939E-01, 1.481E-01 }, { 1267, 1.4102, 0.000E+00, 0.000E+00, 0.000E+00, 1.081E+00, 2.625E+00, 5.322E-01, 1.552E-01, 4.940E-01, 1.481E-01 }, { 1268, 1.4102, 0.000E+00, 0.000E+00, 0.000E+00, 1.080E+00, 2.631E+00, 5.308E-01, 1.546E-01, 4.940E-01, 1.481E-01 }, { 1269, 1.4103, 0.000E+00, 0.000E+00, 0.000E+00, 1.079E+00, 2.636E+00, 5.294E-01, 1.541E-01, 4.941E-01, 1.481E-01 }, { 1270, 1.4103, 0.000E+00, 0.000E+00, 0.000E+00, 1.080E+00, 2.642E+00, 5.280E-01, 1.535E-01, 4.941E-01, 1.481E-01 }, { 1271, 1.4101, 0.000E+00, 0.000E+00, 0.000E+00, 1.083E+00, 2.647E+00, 5.266E-01, 1.530E-01, 4.942E-01, 1.483E-01 }, { 1272, 1.4099, 0.000E+00, 0.000E+00, 0.000E+00, 1.087E+00, 2.652E+00, 5.252E-01, 1.524E-01, 4.943E-01, 1.485E-01 }, { 1273, 1.4097, 0.000E+00, 0.000E+00, 0.000E+00, 1.093E+00, 2.657E+00, 5.238E-01, 1.519E-01, 4.945E-01, 1.487E-01 }, { 1274, 1.4095, 0.000E+00, 0.000E+00, 0.000E+00, 1.099E+00, 2.662E+00, 5.224E-01, 1.513E-01, 4.946E-01, 1.489E-01 }, { 1275, 1.4093, 0.000E+00, 0.000E+00, 0.000E+00, 1.104E+00, 2.667E+00, 5.210E-01, 1.508E-01, 4.947E-01, 1.491E-01 }, { 1276, 1.4091, 0.000E+00, 0.000E+00, 0.000E+00, 1.107E+00, 2.672E+00, 5.196E-01, 1.502E-01, 4.948E-01, 1.492E-01 }, { 1277, 1.4091, 0.000E+00, 0.000E+00, 0.000E+00, 1.109E+00, 2.677E+00, 5.182E-01, 1.497E-01, 4.950E-01, 1.493E-01 }, { 1278, 1.4091, 0.000E+00, 0.000E+00, 0.000E+00, 1.111E+00, 2.681E+00, 5.168E-01, 1.491E-01, 4.951E-01, 1.494E-01 }, { 1279, 1.4090, 0.000E+00, 0.000E+00, 0.000E+00, 1.115E+00, 2.685E+00, 5.154E-01, 1.486E-01, 4.953E-01, 1.494E-01 }, { 1280, 1.4089, 0.000E+00, 0.000E+00, 0.000E+00, 1.121E+00, 2.689E+00, 5.140E-01, 1.480E-01, 4.954E-01, 1.495E-01 }, { 1281, 1.4088, 0.000E+00, 0.000E+00, 0.000E+00, 1.129E+00, 2.693E+00, 5.114E-01, 1.472E-01, 4.957E-01, 1.499E-01 }, { 1282, 1.4085, 0.000E+00, 0.000E+00, 0.000E+00, 1.137E+00, 2.697E+00, 5.088E-01, 1.463E-01, 4.959E-01, 1.502E-01 }, { 1283, 1.4083, 0.000E+00, 0.000E+00, 0.000E+00, 1.147E+00, 2.701E+00, 5.062E-01, 1.455E-01, 4.962E-01, 1.506E-01 }, { 1284, 1.4081, 0.000E+00, 0.000E+00, 0.000E+00, 1.156E+00, 2.704E+00, 5.036E-01, 1.446E-01, 4.965E-01, 1.510E-01 }, { 1285, 1.4080, 0.000E+00, 0.000E+00, 0.000E+00, 1.164E+00, 2.707E+00, 5.010E-01, 1.438E-01, 4.967E-01, 1.513E-01 }, { 1286, 1.4079, 0.000E+00, 0.000E+00, 0.000E+00, 1.170E+00, 2.711E+00, 4.984E-01, 1.429E-01, 4.969E-01, 1.513E-01 }, { 1287, 1.4078, 0.000E+00, 0.000E+00, 0.000E+00, 1.175E+00, 2.713E+00, 4.958E-01, 1.421E-01, 4.972E-01, 1.513E-01 }, { 1288, 1.4077, 0.000E+00, 0.000E+00, 0.000E+00, 1.181E+00, 2.716E+00, 4.932E-01, 1.412E-01, 4.974E-01, 1.513E-01 }, { 1289, 1.4078, 0.000E+00, 0.000E+00, 0.000E+00, 1.188E+00, 2.719E+00, 4.906E-01, 1.404E-01, 4.976E-01, 1.513E-01 }, { 1290, 1.4078, 0.000E+00, 0.000E+00, 0.000E+00, 1.196E+00, 2.721E+00, 4.880E-01, 1.395E-01, 4.979E-01, 1.513E-01 }, { 1291, 1.4078, 0.000E+00, 0.000E+00, 0.000E+00, 1.206E+00, 2.723E+00, 4.854E-01, 1.387E-01, 4.980E-01, 1.513E-01 }, { 1292, 1.4077, 0.000E+00, 0.000E+00, 0.000E+00, 1.216E+00, 2.725E+00, 4.828E-01, 1.378E-01, 4.982E-01, 1.513E-01 }, { 1293, 1.4076, 0.000E+00, 0.000E+00, 0.000E+00, 1.227E+00, 2.726E+00, 4.802E-01, 1.370E-01, 4.984E-01, 1.513E-01 }, { 1294, 1.4075, 0.000E+00, 0.000E+00, 0.000E+00, 1.239E+00, 2.728E+00, 4.776E-01, 1.361E-01, 4.986E-01, 1.513E-01 }, { 1295, 1.4073, 0.000E+00, 0.000E+00, 0.000E+00, 1.252E+00, 2.729E+00, 4.750E-01, 1.353E-01, 4.988E-01, 1.513E-01 }, { 1296, 1.4070, 0.000E+00, 0.000E+00, 0.000E+00, 1.267E+00, 2.730E+00, 4.724E-01, 1.344E-01, 4.987E-01, 1.517E-01 }, { 1297, 1.4068, 0.000E+00, 0.000E+00, 0.000E+00, 1.283E+00, 2.730E+00, 4.698E-01, 1.336E-01, 4.987E-01, 1.521E-01 }, { 1298, 1.4066, 0.000E+00, 0.000E+00, 0.000E+00, 1.297E+00, 2.731E+00, 4.672E-01, 1.327E-01, 4.987E-01, 1.525E-01 }, { 1299, 1.4064, 0.000E+00, 0.000E+00, 0.000E+00, 1.310E+00, 2.731E+00, 4.646E-01, 1.319E-01, 4.987E-01, 1.529E-01 }, { 1300, 1.4064, 0.000E+00, 0.000E+00, 0.000E+00, 1.323E+00, 2.721E+00, 4.620E-01, 1.310E-01, 4.987E-01, 1.533E-01 }, { 1301, 1.4062, 0.000E+00, 0.000E+00, 0.000E+00, 1.336E+00, 2.736E+00, 4.553E-01, 1.291E-01, 4.987E-01, 1.533E-01 }, { 1302, 1.4061, 0.000E+00, 0.000E+00, 0.000E+00, 1.351E+00, 2.728E+00, 4.485E-01, 1.271E-01, 4.987E-01, 1.533E-01 }, { 1303, 1.4059, 0.000E+00, 0.000E+00, 0.000E+00, 1.370E+00, 2.719E+00, 4.418E-01, 1.252E-01, 4.987E-01, 1.534E-01 }, { 1304, 1.4056, 0.000E+00, 0.000E+00, 0.000E+00, 1.392E+00, 2.712E+00, 4.350E-01, 1.232E-01, 4.987E-01, 1.534E-01 }, { 1305, 1.4055, 0.000E+00, 0.000E+00, 0.000E+00, 1.416E+00, 2.698E+00, 4.283E-01, 1.213E-01, 4.987E-01, 1.535E-01 }, { 1306, 1.4055, 0.000E+00, 0.000E+00, 0.000E+00, 1.440E+00, 2.702E+00, 4.215E-01, 1.193E-01, 4.987E-01, 1.535E-01 }, { 1307, 1.4055, 0.000E+00, 0.000E+00, 0.000E+00, 1.465E+00, 2.691E+00, 4.148E-01, 1.174E-01, 4.987E-01, 1.535E-01 }, { 1308, 1.4055, 0.000E+00, 0.000E+00, 0.000E+00, 1.489E+00, 2.688E+00, 4.080E-01, 1.154E-01, 4.987E-01, 1.534E-01 }, { 1309, 1.4056, 0.000E+00, 0.000E+00, 0.000E+00, 1.511E+00, 2.686E+00, 4.013E-01, 1.135E-01, 4.987E-01, 1.534E-01 }, { 1310, 1.4057, 0.000E+00, 0.000E+00, 0.000E+00, 1.532E+00, 2.682E+00, 3.945E-01, 1.115E-01, 4.987E-01, 1.534E-01 }, { 1311, 1.4058, 0.000E+00, 0.000E+00, 0.000E+00, 1.555E+00, 2.676E+00, 3.878E-01, 1.096E-01, 4.987E-01, 1.534E-01 }, { 1312, 1.4058, 0.000E+00, 0.000E+00, 0.000E+00, 1.580E+00, 2.675E+00, 3.810E-01, 1.076E-01, 4.987E-01, 1.534E-01 }, { 1313, 1.4056, 0.000E+00, 0.000E+00, 0.000E+00, 1.610E+00, 2.677E+00, 3.743E-01, 1.057E-01, 4.987E-01, 1.534E-01 }, { 1314, 1.4055, 0.000E+00, 0.000E+00, 0.000E+00, 1.642E+00, 2.670E+00, 3.675E-01, 1.037E-01, 4.987E-01, 1.534E-01 }, { 1315, 1.4053, 0.000E+00, 0.000E+00, 0.000E+00, 1.672E+00, 2.671E+00, 3.608E-01, 1.018E-01, 4.987E-01, 1.534E-01 }, { 1316, 1.4051, 0.000E+00, 0.000E+00, 0.000E+00, 1.701E+00, 2.668E+00, 3.540E-01, 9.980E-02, 4.987E-01, 1.534E-01 }, { 1317, 1.4050, 0.000E+00, 0.000E+00, 0.000E+00, 1.728E+00, 2.670E+00, 3.473E-01, 9.785E-02, 4.987E-01, 1.534E-01 }, { 1318, 1.4049, 0.000E+00, 0.000E+00, 0.000E+00, 1.758E+00, 2.674E+00, 3.405E-01, 9.590E-02, 4.987E-01, 1.534E-01 }, { 1319, 1.4048, 0.000E+00, 0.000E+00, 0.000E+00, 1.791E+00, 2.674E+00, 3.338E-01, 9.395E-02, 4.987E-01, 1.534E-01 }, { 1320, 1.4046, 0.000E+00, 0.000E+00, 0.000E+00, 1.831E+00, 2.683E+00, 3.270E-01, 9.200E-02, 4.987E-01, 1.534E-01 }, { 1321, 1.4045, 0.000E+00, 0.000E+00, 0.000E+00, 1.872E+00, 2.674E+00, 3.239E-01, 9.110E-02, 4.987E-01, 1.534E-01 }, { 1322, 1.4044, 0.000E+00, 0.000E+00, 0.000E+00, 1.911E+00, 2.675E+00, 3.207E-01, 9.020E-02, 4.987E-01, 1.534E-01 }, { 1323, 1.4044, 0.000E+00, 0.000E+00, 0.000E+00, 1.943E+00, 2.682E+00, 3.176E-01, 8.930E-02, 4.987E-01, 1.534E-01 }, { 1324, 1.4044, 0.000E+00, 0.000E+00, 0.000E+00, 1.974E+00, 2.683E+00, 3.144E-01, 8.840E-02, 4.987E-01, 1.534E-01 }, { 1325, 1.4045, 0.000E+00, 0.000E+00, 0.000E+00, 2.007E+00, 2.665E+00, 3.113E-01, 8.750E-02, 4.987E-01, 1.534E-01 }, { 1326, 1.4045, 0.000E+00, 0.000E+00, 0.000E+00, 2.047E+00, 2.661E+00, 3.081E-01, 8.660E-02, 4.986E-01, 1.534E-01 }, { 1327, 1.4043, 0.000E+00, 0.000E+00, 0.000E+00, 2.098E+00, 2.668E+00, 3.050E-01, 8.570E-02, 4.986E-01, 1.534E-01 }, { 1328, 1.4042, 0.000E+00, 0.000E+00, 0.000E+00, 2.153E+00, 2.670E+00, 3.018E-01, 8.480E-02, 4.986E-01, 1.534E-01 }, { 1329, 1.4040, 0.000E+00, 0.000E+00, 0.000E+00, 2.203E+00, 2.674E+00, 2.987E-01, 8.390E-02, 4.986E-01, 1.534E-01 }, { 1330, 1.4040, 0.000E+00, 0.000E+00, 0.000E+00, 2.243E+00, 2.664E+00, 2.955E-01, 8.300E-02, 4.986E-01, 1.534E-01 }, { 1331, 1.4041, 0.000E+00, 0.000E+00, 0.000E+00, 2.277E+00, 2.661E+00, 2.924E-01, 8.210E-02, 4.987E-01, 1.534E-01 }, { 1332, 1.4041, 0.000E+00, 0.000E+00, 0.000E+00, 2.312E+00, 2.665E+00, 2.892E-01, 8.120E-02, 4.987E-01, 1.534E-01 }, { 1333, 1.4040, 0.000E+00, 0.000E+00, 0.000E+00, 2.357E+00, 2.668E+00, 2.861E-01, 8.030E-02, 4.987E-01, 1.534E-01 }, { 1334, 1.4036, 0.000E+00, 0.000E+00, 0.000E+00, 2.415E+00, 2.681E+00, 2.829E-01, 7.940E-02, 4.987E-01, 1.534E-01 }, { 1335, 1.4034, 0.000E+00, 0.000E+00, 0.000E+00, 2.479E+00, 2.686E+00, 2.798E-01, 7.850E-02, 4.987E-01, 1.534E-01 }, { 1336, 1.4032, 0.000E+00, 0.000E+00, 0.000E+00, 2.540E+00, 2.684E+00, 2.766E-01, 7.760E-02, 4.989E-01, 1.532E-01 }, { 1337, 1.4031, 0.000E+00, 0.000E+00, 0.000E+00, 2.590E+00, 2.697E+00, 2.735E-01, 7.670E-02, 4.990E-01, 1.531E-01 }, { 1338, 1.4030, 0.000E+00, 0.000E+00, 0.000E+00, 2.631E+00, 2.712E+00, 2.703E-01, 7.580E-02, 4.991E-01, 1.529E-01 }, { 1339, 1.4031, 0.000E+00, 0.000E+00, 0.000E+00, 2.666E+00, 2.720E+00, 2.672E-01, 7.490E-02, 4.993E-01, 1.527E-01 }, { 1340, 1.4033, 0.000E+00, 0.000E+00, 0.000E+00, 2.701E+00, 2.717E+00, 2.640E-01, 7.400E-02, 4.994E-01, 1.526E-01 }, { 1341, 1.4033, 0.000E+00, 0.000E+00, 0.000E+00, 2.738E+00, 2.726E+00, 2.512E-01, 7.040E-02, 4.996E-01, 1.523E-01 }, { 1342, 1.4033, 0.000E+00, 0.000E+00, 0.000E+00, 2.780E+00, 2.744E+00, 2.383E-01, 6.680E-02, 4.997E-01, 1.520E-01 }, { 1343, 1.4031, 0.000E+00, 0.000E+00, 0.000E+00, 2.829E+00, 2.743E+00, 2.255E-01, 6.320E-02, 4.999E-01, 1.517E-01 }, { 1344, 1.4028, 0.000E+00, 0.000E+00, 0.000E+00, 2.889E+00, 2.751E+00, 2.126E-01, 5.960E-02, 5.000E-01, 1.515E-01 }, { 1345, 1.4023, 0.000E+00, 0.000E+00, 0.000E+00, 2.960E+00, 2.763E+00, 1.998E-01, 5.600E-02, 5.002E-01, 1.512E-01 }, { 1346, 1.4017, 0.000E+00, 0.000E+00, 0.000E+00, 3.033E+00, 2.778E+00, 1.869E-01, 5.240E-02, 5.002E-01, 1.510E-01 }, { 1347, 1.4013, 0.000E+00, 0.000E+00, 0.000E+00, 3.097E+00, 2.793E+00, 1.741E-01, 4.880E-02, 5.003E-01, 1.509E-01 }, { 1348, 1.4010, 0.000E+00, 0.000E+00, 0.000E+00, 3.146E+00, 2.818E+00, 1.612E-01, 4.520E-02, 5.003E-01, 1.507E-01 }, { 1349, 1.4010, 0.000E+00, 0.000E+00, 0.000E+00, 3.181E+00, 2.835E+00, 1.484E-01, 4.160E-02, 5.003E-01, 1.506E-01 }, { 1350, 1.4008, 0.000E+00, 0.000E+00, 0.000E+00, 3.226E+00, 2.865E+00, 1.355E-01, 3.800E-02, 5.004E-01, 1.504E-01 }, { 1351, 1.4007, 0.000E+00, 0.000E+00, 0.000E+00, 3.267E+00, 2.879E+00, 1.227E-01, 3.440E-02, 5.004E-01, 1.504E-01 }, { 1352, 1.4004, 0.000E+00, 0.000E+00, 0.000E+00, 3.319E+00, 2.899E+00, 1.098E-01, 3.080E-02, 5.004E-01, 1.504E-01 }, { 1353, 1.4002, 0.000E+00, 0.000E+00, 0.000E+00, 3.363E+00, 2.918E+00, 9.695E-02, 2.720E-02, 5.004E-01, 1.504E-01 }, { 1354, 1.4000, 0.000E+00, 0.000E+00, 0.000E+00, 3.412E+00, 2.936E+00, 8.410E-02, 2.360E-02, 5.004E-01, 1.504E-01 }, { 1355, 1.4002, 0.000E+00, 0.000E+00, 0.000E+00, 3.449E+00, 2.953E+00, 7.125E-02, 2.000E-02, 5.004E-01, 1.504E-01 }, { 1356, 1.4004, 0.000E+00, 0.000E+00, 0.000E+00, 3.504E+00, 2.966E+00, 5.840E-02, 1.640E-02, 5.002E-01, 1.500E-01 }, { 1357, 1.4009, 0.000E+00, 0.000E+00, 0.000E+00, 3.544E+00, 2.977E+00, 4.555E-02, 1.280E-02, 5.000E-01, 1.497E-01 }, { 1358, 1.4011, 0.000E+00, 0.000E+00, 0.000E+00, 3.600E+00, 2.981E+00, 3.270E-02, 9.200E-03, 4.998E-01, 1.493E-01 }, { 1359, 1.4015, 0.000E+00, 0.000E+00, 0.000E+00, 3.648E+00, 2.942E+00, 1.985E-02, 5.600E-03, 4.996E-01, 1.489E-01 }, { 1360, 1.4016, 0.000E+00, 0.000E+00, 0.000E+00, 3.701E+00, 2.887E+00, 7.000E-03, 2.000E-03, 4.995E-01, 1.486E-01 }, { 1361, 1.4015, 0.000E+00, 0.000E+00, 0.000E+00, 3.752E+00, 2.864E+00, 6.800E-03, 1.950E-03, 4.993E-01, 1.481E-01 }, { 1362, 1.4010, 0.000E+00, 0.000E+00, 0.000E+00, 3.802E+00, 2.877E+00, 6.600E-03, 1.900E-03, 4.992E-01, 1.476E-01 }, { 1363, 1.4002, 0.000E+00, 0.000E+00, 0.000E+00, 3.871E+00, 2.886E+00, 6.400E-03, 1.850E-03, 4.991E-01, 1.471E-01 }, { 1364, 1.3996, 0.000E+00, 0.000E+00, 0.000E+00, 3.927E+00, 2.888E+00, 6.200E-03, 1.800E-03, 4.990E-01, 1.466E-01 }, { 1365, 1.3992, 0.000E+00, 0.000E+00, 0.000E+00, 3.985E+00, 2.891E+00, 6.000E-03, 1.750E-03, 4.989E-01, 1.461E-01 }, { 1366, 1.3989, 0.000E+00, 0.000E+00, 0.000E+00, 4.064E+00, 2.899E+00, 5.800E-03, 1.700E-03, 4.989E-01, 1.454E-01 }, { 1367, 1.3992, 0.000E+00, 0.000E+00, 0.000E+00, 4.125E+00, 2.887E+00, 5.600E-03, 1.650E-03, 4.989E-01, 1.447E-01 }, { 1368, 1.3994, 0.000E+00, 0.000E+00, 0.000E+00, 4.216E+00, 2.884E+00, 5.400E-03, 1.600E-03, 4.989E-01, 1.440E-01 }, { 1369, 1.3997, 0.000E+00, 0.000E+00, 0.000E+00, 4.302E+00, 2.900E+00, 5.200E-03, 1.550E-03, 4.989E-01, 1.433E-01 }, { 1370, 1.4000, 0.000E+00, 0.000E+00, 0.000E+00, 4.389E+00, 2.929E+00, 5.000E-03, 1.500E-03, 4.989E-01, 1.425E-01 }, { 1371, 1.4000, 0.000E+00, 0.000E+00, 0.000E+00, 4.504E+00, 2.969E+00, 4.800E-03, 1.450E-03, 4.989E-01, 1.414E-01 }, { 1372, 1.4000, 0.000E+00, 0.000E+00, 0.000E+00, 4.630E+00, 3.014E+00, 4.600E-03, 1.400E-03, 4.989E-01, 1.403E-01 }, { 1373, 1.4003, 0.000E+00, 0.000E+00, 0.000E+00, 4.737E+00, 3.053E+00, 4.400E-03, 1.350E-03, 4.989E-01, 1.392E-01 }, { 1374, 1.4002, 0.000E+00, 0.000E+00, 0.000E+00, 4.904E+00, 3.075E+00, 4.200E-03, 1.300E-03, 4.989E-01, 1.381E-01 }, { 1375, 1.3999, 0.000E+00, 0.000E+00, 0.000E+00, 5.092E+00, 3.111E+00, 4.000E-03, 1.250E-03, 4.989E-01, 1.370E-01 }, { 1376, 1.4002, 0.000E+00, 0.000E+00, 0.000E+00, 5.260E+00, 3.128E+00, 3.800E-03, 1.200E-03, 4.988E-01, 1.363E-01 }, { 1377, 1.4004, 0.000E+00, 0.000E+00, 0.000E+00, 5.479E+00, 3.130E+00, 3.600E-03, 1.150E-03, 4.988E-01, 1.355E-01 }, { 1378, 1.4008, 0.000E+00, 0.000E+00, 0.000E+00, 5.720E+00, 3.103E+00, 3.400E-03, 1.100E-03, 4.988E-01, 1.348E-01 }, { 1379, 1.4009, 0.000E+00, 0.000E+00, 0.000E+00, 6.006E+00, 3.051E+00, 3.200E-03, 1.050E-03, 4.988E-01, 1.340E-01 }, { 1380, 1.4019, 0.000E+00, 0.000E+00, 0.000E+00, 6.242E+00, 2.979E+00, 3.000E-03, 1.000E-03, 4.988E-01, 1.332E-01 }, { 1381, 1.4015, 0.000E+00, 0.000E+00, 0.000E+00, 6.580E+00, 2.941E+00, 3.900E-03, 1.250E-03, 4.979E-01, 1.321E-01 }, { 1382, 1.4010, 0.000E+00, 0.000E+00, 0.000E+00, 6.927E+00, 2.920E+00, 4.800E-03, 1.500E-03, 4.970E-01, 1.309E-01 }, { 1383, 1.4000, 0.000E+00, 0.000E+00, 0.000E+00, 7.313E+00, 2.931E+00, 5.700E-03, 1.750E-03, 4.962E-01, 1.298E-01 }, { 1384, 1.4001, 0.000E+00, 0.000E+00, 0.000E+00, 7.633E+00, 2.950E+00, 6.600E-03, 2.000E-03, 4.953E-01, 1.287E-01 }, { 1385, 1.3988, 0.000E+00, 0.000E+00, 0.000E+00, 8.089E+00, 2.978E+00, 7.500E-03, 2.250E-03, 4.944E-01, 1.275E-01 }, { 1386, 1.3978, 0.000E+00, 0.000E+00, 0.000E+00, 8.545E+00, 3.025E+00, 8.400E-03, 2.500E-03, 4.940E-01, 1.264E-01 }, { 1387, 1.3971, 0.000E+00, 0.000E+00, 0.000E+00, 9.030E+00, 3.048E+00, 9.300E-03, 2.750E-03, 4.937E-01, 1.252E-01 }, { 1388, 1.3960, 0.000E+00, 0.000E+00, 0.000E+00, 9.591E+00, 3.066E+00, 1.020E-02, 3.000E-03, 4.933E-01, 1.240E-01 }, { 1389, 1.3967, 0.000E+00, 0.000E+00, 0.000E+00, 1.002E+01, 3.087E+00, 1.110E-02, 3.250E-03, 4.930E-01, 1.229E-01 }, { 1390, 1.3958, 0.000E+00, 0.000E+00, 0.000E+00, 1.063E+01, 3.099E+00, 1.200E-02, 3.500E-03, 4.926E-01, 1.217E-01 }, { 1391, 1.3955, 0.000E+00, 0.000E+00, 0.000E+00, 1.122E+01, 3.090E+00, 1.290E-02, 3.750E-03, 4.926E-01, 1.209E-01 }, { 1392, 1.3952, 0.000E+00, 0.000E+00, 0.000E+00, 1.184E+01, 3.088E+00, 1.380E-02, 4.000E-03, 4.926E-01, 1.201E-01 }, { 1393, 1.3953, 0.000E+00, 0.000E+00, 0.000E+00, 1.245E+01, 3.081E+00, 1.470E-02, 4.250E-03, 4.926E-01, 1.193E-01 }, { 1394, 1.3945, 0.000E+00, 0.000E+00, 0.000E+00, 1.316E+01, 3.085E+00, 1.560E-02, 4.500E-03, 4.926E-01, 1.185E-01 }, { 1395, 1.3960, 0.000E+00, 0.000E+00, 0.000E+00, 1.369E+01, 3.071E+00, 1.650E-02, 4.750E-03, 4.926E-01, 1.178E-01 }, { 1396, 1.3961, 0.000E+00, 0.000E+00, 0.000E+00, 1.434E+01, 3.065E+00, 1.740E-02, 5.000E-03, 4.926E-01, 1.169E-01 }, { 1397, 1.3950, 0.000E+00, 0.000E+00, 0.000E+00, 1.509E+01, 3.069E+00, 1.830E-02, 5.250E-03, 4.926E-01, 1.161E-01 }, { 1398, 1.3946, 0.000E+00, 0.000E+00, 0.000E+00, 1.578E+01, 3.067E+00, 1.920E-02, 5.500E-03, 4.926E-01, 1.152E-01 }, { 1399, 1.3942, 0.000E+00, 0.000E+00, 0.000E+00, 1.646E+01, 3.085E+00, 2.010E-02, 5.750E-03, 4.926E-01, 1.143E-01 }, { 1400, 1.3938, 0.000E+00, 0.000E+00, 0.000E+00, 1.714E+01, 3.094E+00, 2.100E-02, 6.000E-03, 4.926E-01, 1.135E-01 }, { 1401, 1.3935, 0.000E+00, 0.000E+00, 0.000E+00, 1.781E+01, 3.110E+00, 2.095E-02, 5.950E-03, 4.926E-01, 1.128E-01 }, { 1402, 1.3926, 0.000E+00, 0.000E+00, 0.000E+00, 1.854E+01, 3.136E+00, 2.090E-02, 5.900E-03, 4.926E-01, 1.122E-01 }, { 1403, 1.3926, 0.000E+00, 0.000E+00, 0.000E+00, 1.919E+01, 3.149E+00, 2.085E-02, 5.850E-03, 4.926E-01, 1.116E-01 }, { 1404, 1.3930, 0.000E+00, 0.000E+00, 0.000E+00, 1.980E+01, 3.158E+00, 2.080E-02, 5.800E-03, 4.926E-01, 1.109E-01 }, { 1405, 1.3943, 0.000E+00, 0.000E+00, 0.000E+00, 2.029E+01, 3.191E+00, 2.075E-02, 5.750E-03, 4.926E-01, 1.103E-01 }, { 1406, 1.3943, 0.000E+00, 0.000E+00, 0.000E+00, 2.089E+01, 3.230E+00, 2.070E-02, 5.700E-03, 4.926E-01, 1.098E-01 }, { 1407, 1.3944, 0.000E+00, 0.000E+00, 0.000E+00, 2.146E+01, 3.265E+00, 2.065E-02, 5.650E-03, 4.926E-01, 1.093E-01 }, { 1408, 1.3944, 0.000E+00, 0.000E+00, 0.000E+00, 2.202E+01, 3.298E+00, 2.060E-02, 5.600E-03, 4.926E-01, 1.088E-01 }, { 1409, 1.3937, 0.000E+00, 0.000E+00, 0.000E+00, 2.260E+01, 3.356E+00, 2.055E-02, 5.550E-03, 4.926E-01, 1.083E-01 }, { 1410, 1.3933, 0.000E+00, 0.000E+00, 0.000E+00, 2.313E+01, 3.419E+00, 2.050E-02, 5.500E-03, 4.925E-01, 1.078E-01 }, { 1411, 1.3934, 0.000E+00, 0.000E+00, 0.000E+00, 2.360E+01, 3.476E+00, 2.045E-02, 5.450E-03, 4.933E-01, 1.070E-01 }, { 1412, 1.3934, 0.000E+00, 0.000E+00, 0.000E+00, 2.407E+01, 3.534E+00, 2.040E-02, 5.400E-03, 4.940E-01, 1.062E-01 }, { 1413, 1.3935, 0.000E+00, 0.000E+00, 0.000E+00, 2.450E+01, 3.584E+00, 2.035E-02, 5.350E-03, 4.947E-01, 1.054E-01 }, { 1414, 1.3933, 0.000E+00, 0.000E+00, 0.000E+00, 2.493E+01, 3.632E+00, 2.030E-02, 5.300E-03, 4.955E-01, 1.046E-01 }, { 1415, 1.3931, 0.000E+00, 0.000E+00, 0.000E+00, 2.533E+01, 3.708E+00, 2.025E-02, 5.250E-03, 4.962E-01, 1.039E-01 }, { 1416, 1.3928, 0.000E+00, 0.000E+00, 0.000E+00, 2.571E+01, 3.775E+00, 2.020E-02, 5.200E-03, 4.968E-01, 1.037E-01 }, { 1417, 1.3925, 0.000E+00, 0.000E+00, 0.000E+00, 2.606E+01, 3.847E+00, 2.015E-02, 5.150E-03, 4.974E-01, 1.036E-01 }, { 1418, 1.3920, 0.000E+00, 0.000E+00, 0.000E+00, 2.641E+01, 3.931E+00, 2.010E-02, 5.100E-03, 4.980E-01, 1.035E-01 }, { 1419, 1.3918, 0.000E+00, 0.000E+00, 0.000E+00, 2.673E+01, 3.987E+00, 2.005E-02, 5.050E-03, 4.986E-01, 1.034E-01 }, { 1420, 1.3915, 0.000E+00, 0.000E+00, 0.000E+00, 2.701E+01, 4.071E+00, 2.000E-02, 5.000E-03, 4.992E-01, 1.032E-01 }, { 1421, 1.3910, 0.000E+00, 0.000E+00, 0.000E+00, 2.729E+01, 4.156E+00, 2.170E-02, 5.450E-03, 4.994E-01, 1.029E-01 }, { 1422, 1.3904, 0.000E+00, 0.000E+00, 0.000E+00, 2.756E+01, 4.242E+00, 2.340E-02, 5.900E-03, 4.997E-01, 1.026E-01 }, { 1423, 1.3898, 0.000E+00, 0.000E+00, 0.000E+00, 2.782E+01, 4.320E+00, 2.510E-02, 6.350E-03, 4.999E-01, 1.024E-01 }, { 1424, 1.3892, 0.000E+00, 0.000E+00, 0.000E+00, 2.806E+01, 4.395E+00, 2.680E-02, 6.800E-03, 5.001E-01, 1.021E-01 }, { 1425, 1.3880, 0.000E+00, 0.000E+00, 0.000E+00, 2.835E+01, 4.480E+00, 2.850E-02, 7.250E-03, 5.003E-01, 1.018E-01 }, { 1426, 1.3872, 0.000E+00, 0.000E+00, 0.000E+00, 2.856E+01, 4.561E+00, 3.020E-02, 7.700E-03, 5.004E-01, 1.016E-01 }, { 1427, 1.3865, 0.000E+00, 0.000E+00, 0.000E+00, 2.875E+01, 4.638E+00, 3.190E-02, 8.150E-03, 5.005E-01, 1.015E-01 }, { 1428, 1.3858, 0.000E+00, 0.000E+00, 0.000E+00, 2.892E+01, 4.708E+00, 3.360E-02, 8.600E-03, 5.006E-01, 1.013E-01 }, { 1429, 1.3852, 0.000E+00, 0.000E+00, 0.000E+00, 2.908E+01, 4.782E+00, 3.530E-02, 9.050E-03, 5.006E-01, 1.012E-01 }, { 1430, 1.3843, 0.000E+00, 0.000E+00, 0.000E+00, 2.926E+01, 4.846E+00, 3.700E-02, 9.500E-03, 5.007E-01, 1.010E-01 }, { 1431, 1.3838, 0.000E+00, 0.000E+00, 0.000E+00, 2.940E+01, 4.906E+00, 3.870E-02, 9.950E-03, 5.007E-01, 1.010E-01 }, { 1432, 1.3829, 0.000E+00, 0.000E+00, 0.000E+00, 2.956E+01, 4.974E+00, 4.040E-02, 1.040E-02, 5.008E-01, 1.010E-01 }, { 1433, 1.3823, 0.000E+00, 0.000E+00, 0.000E+00, 2.966E+01, 5.026E+00, 4.210E-02, 1.085E-02, 5.008E-01, 1.010E-01 }, { 1434, 1.3810, 0.000E+00, 0.000E+00, 0.000E+00, 2.982E+01, 5.071E+00, 4.380E-02, 1.130E-02, 5.008E-01, 1.010E-01 }, { 1435, 1.3801, 0.000E+00, 0.000E+00, 0.000E+00, 2.993E+01, 5.131E+00, 4.550E-02, 1.175E-02, 5.008E-01, 1.010E-01 }, { 1436, 1.3794, 0.000E+00, 0.000E+00, 0.000E+00, 3.003E+01, 5.179E+00, 4.720E-02, 1.220E-02, 5.008E-01, 1.010E-01 }, { 1437, 1.3785, 0.000E+00, 0.000E+00, 0.000E+00, 3.014E+01, 5.220E+00, 4.890E-02, 1.265E-02, 5.008E-01, 1.010E-01 }, { 1438, 1.3776, 0.000E+00, 0.000E+00, 0.000E+00, 3.023E+01, 5.271E+00, 5.060E-02, 1.310E-02, 5.008E-01, 1.010E-01 }, { 1439, 1.3771, 0.000E+00, 0.000E+00, 0.000E+00, 3.029E+01, 5.322E+00, 5.230E-02, 1.355E-02, 5.008E-01, 1.010E-01 }, { 1440, 1.3765, 0.000E+00, 0.000E+00, 0.000E+00, 3.036E+01, 5.358E+00, 5.400E-02, 1.400E-02, 5.008E-01, 1.010E-01 }, { 1441, 1.3758, 0.000E+00, 0.000E+00, 0.000E+00, 3.042E+01, 5.403E+00, 5.795E-02, 1.505E-02, 5.008E-01, 1.010E-01 }, { 1442, 1.3751, 0.000E+00, 0.000E+00, 0.000E+00, 3.046E+01, 5.441E+00, 6.190E-02, 1.610E-02, 5.008E-01, 1.010E-01 }, { 1443, 1.3743, 0.000E+00, 0.000E+00, 0.000E+00, 3.049E+01, 5.460E+00, 6.585E-02, 1.715E-02, 5.008E-01, 1.010E-01 }, { 1444, 1.3733, 0.000E+00, 0.000E+00, 0.000E+00, 3.052E+01, 5.481E+00, 6.980E-02, 1.820E-02, 5.008E-01, 1.010E-01 }, { 1445, 1.3725, 0.000E+00, 0.000E+00, 0.000E+00, 3.053E+01, 5.500E+00, 7.375E-02, 1.925E-02, 5.008E-01, 1.010E-01 }, { 1446, 1.3717, 0.000E+00, 0.000E+00, 0.000E+00, 3.055E+01, 5.523E+00, 7.770E-02, 2.030E-02, 5.007E-01, 1.012E-01 }, { 1447, 1.3711, 0.000E+00, 0.000E+00, 0.000E+00, 3.056E+01, 5.548E+00, 8.165E-02, 2.135E-02, 5.006E-01, 1.014E-01 }, { 1448, 1.3707, 0.000E+00, 0.000E+00, 0.000E+00, 3.056E+01, 5.560E+00, 8.560E-02, 2.240E-02, 5.006E-01, 1.016E-01 }, { 1449, 1.3703, 0.000E+00, 0.000E+00, 0.000E+00, 3.055E+01, 5.575E+00, 8.955E-02, 2.345E-02, 5.005E-01, 1.019E-01 }, { 1450, 1.3700, 0.000E+00, 0.000E+00, 0.000E+00, 3.054E+01, 5.582E+00, 9.350E-02, 2.450E-02, 5.004E-01, 1.021E-01 }, { 1451, 1.3700, 0.000E+00, 0.000E+00, 0.000E+00, 3.051E+01, 5.597E+00, 9.745E-02, 2.555E-02, 5.004E-01, 1.021E-01 }, { 1452, 1.3697, 0.000E+00, 0.000E+00, 0.000E+00, 3.049E+01, 5.611E+00, 1.014E-01, 2.660E-02, 5.005E-01, 1.021E-01 }, { 1453, 1.3692, 0.000E+00, 0.000E+00, 0.000E+00, 3.045E+01, 5.639E+00, 1.054E-01, 2.765E-02, 5.005E-01, 1.021E-01 }, { 1454, 1.3685, 0.000E+00, 0.000E+00, 0.000E+00, 3.041E+01, 5.653E+00, 1.093E-01, 2.870E-02, 5.006E-01, 1.021E-01 }, { 1455, 1.3680, 0.000E+00, 0.000E+00, 0.000E+00, 3.035E+01, 5.675E+00, 1.133E-01, 2.975E-02, 5.006E-01, 1.021E-01 }, { 1456, 1.3675, 0.000E+00, 0.000E+00, 0.000E+00, 3.029E+01, 5.682E+00, 1.172E-01, 3.080E-02, 5.008E-01, 1.021E-01 }, { 1457, 1.3670, 0.000E+00, 0.000E+00, 0.000E+00, 3.023E+01, 5.685E+00, 1.212E-01, 3.185E-02, 5.011E-01, 1.021E-01 }, { 1458, 1.3667, 0.000E+00, 0.000E+00, 0.000E+00, 3.014E+01, 5.680E+00, 1.251E-01, 3.290E-02, 5.014E-01, 1.021E-01 }, { 1459, 1.3662, 0.000E+00, 0.000E+00, 0.000E+00, 3.006E+01, 5.689E+00, 1.291E-01, 3.395E-02, 5.016E-01, 1.020E-01 }, { 1460, 1.3657, 0.000E+00, 0.000E+00, 0.000E+00, 2.998E+01, 5.711E+00, 1.330E-01, 3.500E-02, 5.019E-01, 1.020E-01 }, { 1461, 1.3659, 0.000E+00, 0.000E+00, 0.000E+00, 2.983E+01, 5.723E+00, 1.327E-01, 3.495E-02, 5.020E-01, 1.023E-01 }, { 1462, 1.3658, 0.000E+00, 0.000E+00, 0.000E+00, 2.971E+01, 5.715E+00, 1.324E-01, 3.490E-02, 5.022E-01, 1.026E-01 }, { 1463, 1.3656, 0.000E+00, 0.000E+00, 0.000E+00, 2.957E+01, 5.716E+00, 1.321E-01, 3.485E-02, 5.023E-01, 1.029E-01 }, { 1464, 1.3656, 0.000E+00, 0.000E+00, 0.000E+00, 2.936E+01, 5.732E+00, 1.318E-01, 3.480E-02, 5.025E-01, 1.032E-01 }, { 1465, 1.3654, 0.000E+00, 0.000E+00, 0.000E+00, 2.917E+01, 5.741E+00, 1.315E-01, 3.475E-02, 5.026E-01, 1.035E-01 }, { 1466, 1.3650, 0.000E+00, 0.000E+00, 0.000E+00, 2.899E+01, 5.743E+00, 1.312E-01, 3.470E-02, 5.027E-01, 1.036E-01 }, { 1467, 1.3653, 0.000E+00, 0.000E+00, 0.000E+00, 2.872E+01, 5.752E+00, 1.309E-01, 3.465E-02, 5.028E-01, 1.037E-01 }, { 1468, 1.3651, 0.000E+00, 0.000E+00, 0.000E+00, 2.851E+01, 5.745E+00, 1.306E-01, 3.460E-02, 5.029E-01, 1.037E-01 }, { 1469, 1.3649, 0.000E+00, 0.000E+00, 0.000E+00, 2.829E+01, 5.744E+00, 1.303E-01, 3.455E-02, 5.031E-01, 1.038E-01 }, { 1470, 1.3650, 0.000E+00, 0.000E+00, 0.000E+00, 2.800E+01, 5.757E+00, 1.300E-01, 3.450E-02, 5.032E-01, 1.039E-01 }, { 1471, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 2.777E+01, 5.766E+00, 1.297E-01, 3.445E-02, 5.032E-01, 1.049E-01 }, { 1472, 1.3641, 0.000E+00, 0.000E+00, 0.000E+00, 2.754E+01, 5.780E+00, 1.294E-01, 3.440E-02, 5.033E-01, 1.059E-01 }, { 1473, 1.3644, 0.000E+00, 0.000E+00, 0.000E+00, 2.722E+01, 5.787E+00, 1.291E-01, 3.435E-02, 5.033E-01, 1.069E-01 }, { 1474, 1.3640, 0.000E+00, 0.000E+00, 0.000E+00, 2.699E+01, 5.798E+00, 1.288E-01, 3.430E-02, 5.034E-01, 1.079E-01 }, { 1475, 1.3644, 0.000E+00, 0.000E+00, 0.000E+00, 2.664E+01, 5.810E+00, 1.285E-01, 3.425E-02, 5.034E-01, 1.088E-01 }, { 1476, 1.3643, 0.000E+00, 0.000E+00, 0.000E+00, 2.638E+01, 5.808E+00, 1.282E-01, 3.420E-02, 5.032E-01, 1.092E-01 }, { 1477, 1.3644, 0.000E+00, 0.000E+00, 0.000E+00, 2.611E+01, 5.815E+00, 1.279E-01, 3.415E-02, 5.030E-01, 1.096E-01 }, { 1478, 1.3647, 0.000E+00, 0.000E+00, 0.000E+00, 2.581E+01, 5.825E+00, 1.276E-01, 3.410E-02, 5.028E-01, 1.100E-01 }, { 1479, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 2.555E+01, 5.824E+00, 1.273E-01, 3.405E-02, 5.026E-01, 1.104E-01 }, { 1480, 1.3649, 0.000E+00, 0.000E+00, 0.000E+00, 2.522E+01, 5.827E+00, 1.270E-01, 3.400E-02, 5.024E-01, 1.107E-01 }, { 1481, 1.3644, 0.000E+00, 0.000E+00, 0.000E+00, 2.497E+01, 5.854E+00, 1.384E-01, 3.690E-02, 5.022E-01, 1.108E-01 }, { 1482, 1.3641, 0.000E+00, 0.000E+00, 0.000E+00, 2.468E+01, 5.878E+00, 1.497E-01, 3.980E-02, 5.020E-01, 1.108E-01 }, { 1483, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 2.443E+01, 5.900E+00, 1.611E-01, 4.270E-02, 5.019E-01, 1.108E-01 }, { 1484, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 2.413E+01, 5.908E+00, 1.724E-01, 4.560E-02, 5.017E-01, 1.108E-01 }, { 1485, 1.3633, 0.000E+00, 0.000E+00, 0.000E+00, 2.388E+01, 5.922E+00, 1.838E-01, 4.850E-02, 5.015E-01, 1.108E-01 }, { 1486, 1.3631, 0.000E+00, 0.000E+00, 0.000E+00, 2.364E+01, 5.940E+00, 1.951E-01, 5.140E-02, 5.017E-01, 1.114E-01 }, { 1487, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 2.332E+01, 5.962E+00, 2.065E-01, 5.430E-02, 5.019E-01, 1.120E-01 }, { 1488, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 2.307E+01, 5.963E+00, 2.178E-01, 5.720E-02, 5.021E-01, 1.126E-01 }, { 1489, 1.3643, 0.000E+00, 0.000E+00, 0.000E+00, 2.274E+01, 5.966E+00, 2.292E-01, 6.010E-02, 5.023E-01, 1.133E-01 }, { 1490, 1.3642, 0.000E+00, 0.000E+00, 0.000E+00, 2.250E+01, 5.982E+00, 2.405E-01, 6.300E-02, 5.025E-01, 1.139E-01 }, { 1491, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 2.218E+01, 5.990E+00, 2.519E-01, 6.590E-02, 5.027E-01, 1.144E-01 }, { 1492, 1.3643, 0.000E+00, 0.000E+00, 0.000E+00, 2.193E+01, 5.994E+00, 2.632E-01, 6.880E-02, 5.029E-01, 1.150E-01 }, { 1493, 1.3642, 0.000E+00, 0.000E+00, 0.000E+00, 2.163E+01, 6.016E+00, 2.746E-01, 7.170E-02, 5.031E-01, 1.156E-01 }, { 1494, 1.3637, 0.000E+00, 0.000E+00, 0.000E+00, 2.139E+01, 6.014E+00, 2.859E-01, 7.460E-02, 5.033E-01, 1.161E-01 }, { 1495, 1.3640, 0.000E+00, 0.000E+00, 0.000E+00, 2.107E+01, 6.025E+00, 2.973E-01, 7.750E-02, 5.035E-01, 1.167E-01 }, { 1496, 1.3638, 0.000E+00, 0.000E+00, 0.000E+00, 2.082E+01, 6.008E+00, 3.086E-01, 8.040E-02, 5.036E-01, 1.171E-01 }, { 1497, 1.3640, 0.000E+00, 0.000E+00, 0.000E+00, 2.052E+01, 6.022E+00, 3.200E-01, 8.330E-02, 5.037E-01, 1.175E-01 }, { 1498, 1.3640, 0.000E+00, 0.000E+00, 0.000E+00, 2.025E+01, 6.021E+00, 3.313E-01, 8.620E-02, 5.038E-01, 1.180E-01 }, { 1499, 1.3640, 0.000E+00, 0.000E+00, 0.000E+00, 2.001E+01, 6.027E+00, 3.427E-01, 8.910E-02, 5.040E-01, 1.184E-01 }, { 1500, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 1.972E+01, 6.027E+00, 3.540E-01, 9.200E-02, 5.041E-01, 1.188E-01 }, { 1501, 1.3645, 0.000E+00, 0.000E+00, 0.000E+00, 1.951E+01, 6.035E+00, 3.541E-01, 9.200E-02, 5.039E-01, 1.192E-01 }, { 1502, 1.3650, 0.000E+00, 0.000E+00, 0.000E+00, 1.924E+01, 6.025E+00, 3.541E-01, 9.200E-02, 5.037E-01, 1.196E-01 }, { 1503, 1.3650, 0.000E+00, 0.000E+00, 0.000E+00, 1.900E+01, 6.009E+00, 3.542E-01, 9.200E-02, 5.036E-01, 1.200E-01 }, { 1504, 1.3652, 0.000E+00, 0.000E+00, 0.000E+00, 1.874E+01, 5.989E+00, 3.542E-01, 9.200E-02, 5.034E-01, 1.204E-01 }, { 1505, 1.3657, 0.000E+00, 0.000E+00, 0.000E+00, 1.847E+01, 5.987E+00, 3.543E-01, 9.200E-02, 5.033E-01, 1.208E-01 }, { 1506, 1.3656, 0.000E+00, 0.000E+00, 0.000E+00, 1.827E+01, 5.984E+00, 3.543E-01, 9.200E-02, 5.035E-01, 1.212E-01 }, { 1507, 1.3660, 0.000E+00, 0.000E+00, 0.000E+00, 1.802E+01, 5.971E+00, 3.544E-01, 9.200E-02, 5.036E-01, 1.216E-01 }, { 1508, 1.3657, 0.000E+00, 0.000E+00, 0.000E+00, 1.784E+01, 5.971E+00, 3.544E-01, 9.200E-02, 5.038E-01, 1.220E-01 }, { 1509, 1.3661, 0.000E+00, 0.000E+00, 0.000E+00, 1.758E+01, 5.973E+00, 3.545E-01, 9.200E-02, 5.040E-01, 1.223E-01 }, { 1510, 1.3665, 0.000E+00, 0.000E+00, 0.000E+00, 1.734E+01, 5.951E+00, 3.545E-01, 9.200E-02, 5.042E-01, 1.227E-01 }, { 1511, 1.3667, 0.000E+00, 0.000E+00, 0.000E+00, 1.712E+01, 5.952E+00, 3.546E-01, 9.200E-02, 5.044E-01, 1.233E-01 }, { 1512, 1.3670, 0.000E+00, 0.000E+00, 0.000E+00, 1.688E+01, 5.939E+00, 3.546E-01, 9.200E-02, 5.047E-01, 1.239E-01 }, { 1513, 1.3666, 0.000E+00, 0.000E+00, 0.000E+00, 1.671E+01, 5.933E+00, 3.547E-01, 9.200E-02, 5.049E-01, 1.245E-01 }, { 1514, 1.3669, 0.000E+00, 0.000E+00, 0.000E+00, 1.647E+01, 5.931E+00, 3.547E-01, 9.200E-02, 5.051E-01, 1.251E-01 }, { 1515, 1.3673, 0.000E+00, 0.000E+00, 0.000E+00, 1.623E+01, 5.925E+00, 3.548E-01, 9.200E-02, 5.054E-01, 1.257E-01 }, { 1516, 1.3673, 0.000E+00, 0.000E+00, 0.000E+00, 1.606E+01, 5.909E+00, 3.548E-01, 9.200E-02, 5.057E-01, 1.262E-01 }, { 1517, 1.3680, 0.000E+00, 0.000E+00, 0.000E+00, 1.583E+01, 5.897E+00, 3.549E-01, 9.200E-02, 5.061E-01, 1.268E-01 }, { 1518, 1.3686, 0.000E+00, 0.000E+00, 0.000E+00, 1.562E+01, 5.884E+00, 3.549E-01, 9.200E-02, 5.065E-01, 1.274E-01 }, { 1519, 1.3686, 0.000E+00, 0.000E+00, 0.000E+00, 1.545E+01, 5.881E+00, 3.550E-01, 9.200E-02, 5.068E-01, 1.279E-01 }, { 1520, 1.3689, 0.000E+00, 0.000E+00, 0.000E+00, 1.525E+01, 5.876E+00, 3.550E-01, 9.200E-02, 5.072E-01, 1.285E-01 }, { 1521, 1.3693, 0.000E+00, 0.000E+00, 0.000E+00, 1.504E+01, 5.856E+00, 3.556E-01, 9.210E-02, 5.072E-01, 1.291E-01 }, { 1522, 1.3690, 0.000E+00, 0.000E+00, 0.000E+00, 1.489E+01, 5.843E+00, 3.561E-01, 9.220E-02, 5.073E-01, 1.298E-01 }, { 1523, 1.3694, 0.000E+00, 0.000E+00, 0.000E+00, 1.468E+01, 5.830E+00, 3.567E-01, 9.230E-02, 5.073E-01, 1.305E-01 }, { 1524, 1.3697, 0.000E+00, 0.000E+00, 0.000E+00, 1.447E+01, 5.818E+00, 3.572E-01, 9.240E-02, 5.073E-01, 1.311E-01 }, { 1525, 1.3695, 0.000E+00, 0.000E+00, 0.000E+00, 1.432E+01, 5.807E+00, 3.578E-01, 9.250E-02, 5.074E-01, 1.318E-01 }, { 1526, 1.3697, 0.000E+00, 0.000E+00, 0.000E+00, 1.413E+01, 5.799E+00, 3.583E-01, 9.260E-02, 5.072E-01, 1.321E-01 }, { 1527, 1.3698, 0.000E+00, 0.000E+00, 0.000E+00, 1.395E+01, 5.792E+00, 3.589E-01, 9.270E-02, 5.071E-01, 1.324E-01 }, { 1528, 1.3696, 0.000E+00, 0.000E+00, 0.000E+00, 1.381E+01, 5.776E+00, 3.594E-01, 9.280E-02, 5.069E-01, 1.327E-01 }, { 1529, 1.3698, 0.000E+00, 0.000E+00, 0.000E+00, 1.364E+01, 5.783E+00, 3.600E-01, 9.290E-02, 5.068E-01, 1.329E-01 }, { 1530, 1.3700, 0.000E+00, 0.000E+00, 0.000E+00, 1.348E+01, 5.776E+00, 3.605E-01, 9.300E-02, 5.067E-01, 1.332E-01 }, { 1531, 1.3706, 0.000E+00, 0.000E+00, 0.000E+00, 1.329E+01, 5.767E+00, 3.611E-01, 9.310E-02, 5.067E-01, 1.337E-01 }, { 1532, 1.3705, 0.000E+00, 0.000E+00, 0.000E+00, 1.316E+01, 5.762E+00, 3.616E-01, 9.320E-02, 5.067E-01, 1.342E-01 }, { 1533, 1.3709, 0.000E+00, 0.000E+00, 0.000E+00, 1.298E+01, 5.769E+00, 3.622E-01, 9.330E-02, 5.067E-01, 1.347E-01 }, { 1534, 1.3712, 0.000E+00, 0.000E+00, 0.000E+00, 1.282E+01, 5.756E+00, 3.627E-01, 9.340E-02, 5.067E-01, 1.352E-01 }, { 1535, 1.3717, 0.000E+00, 0.000E+00, 0.000E+00, 1.265E+01, 5.762E+00, 3.633E-01, 9.350E-02, 5.067E-01, 1.357E-01 }, { 1536, 1.3718, 0.000E+00, 0.000E+00, 0.000E+00, 1.254E+01, 5.737E+00, 3.638E-01, 9.360E-02, 5.068E-01, 1.360E-01 }, { 1537, 1.3721, 0.000E+00, 0.000E+00, 0.000E+00, 1.238E+01, 5.740E+00, 3.644E-01, 9.370E-02, 5.070E-01, 1.363E-01 }, { 1538, 1.3721, 0.000E+00, 0.000E+00, 0.000E+00, 1.223E+01, 5.757E+00, 3.649E-01, 9.380E-02, 5.071E-01, 1.366E-01 }, { 1539, 1.3724, 0.000E+00, 0.000E+00, 0.000E+00, 1.206E+01, 5.756E+00, 3.655E-01, 9.390E-02, 5.072E-01, 1.369E-01 }, { 1540, 1.3723, 0.000E+00, 0.000E+00, 0.000E+00, 1.193E+01, 5.751E+00, 3.660E-01, 9.400E-02, 5.074E-01, 1.372E-01 }, { 1541, 1.3721, 0.000E+00, 0.000E+00, 0.000E+00, 1.181E+01, 5.754E+00, 3.659E-01, 9.390E-02, 5.075E-01, 1.377E-01 }, { 1542, 1.3723, 0.000E+00, 0.000E+00, 0.000E+00, 1.166E+01, 5.751E+00, 3.658E-01, 9.380E-02, 5.076E-01, 1.381E-01 }, { 1543, 1.3723, 0.000E+00, 0.000E+00, 0.000E+00, 1.152E+01, 5.750E+00, 3.657E-01, 9.370E-02, 5.078E-01, 1.385E-01 }, { 1544, 1.3725, 0.000E+00, 0.000E+00, 0.000E+00, 1.137E+01, 5.744E+00, 3.656E-01, 9.360E-02, 5.079E-01, 1.390E-01 }, { 1545, 1.3723, 0.000E+00, 0.000E+00, 0.000E+00, 1.126E+01, 5.744E+00, 3.655E-01, 9.350E-02, 5.080E-01, 1.394E-01 }, { 1546, 1.3723, 0.000E+00, 0.000E+00, 0.000E+00, 1.114E+01, 5.754E+00, 3.654E-01, 9.340E-02, 5.080E-01, 1.396E-01 }, { 1547, 1.3727, 0.000E+00, 0.000E+00, 0.000E+00, 1.100E+01, 5.744E+00, 3.653E-01, 9.330E-02, 5.079E-01, 1.398E-01 }, { 1548, 1.3729, 0.000E+00, 0.000E+00, 0.000E+00, 1.088E+01, 5.735E+00, 3.652E-01, 9.320E-02, 5.078E-01, 1.400E-01 }, { 1549, 1.3730, 0.000E+00, 0.000E+00, 0.000E+00, 1.075E+01, 5.740E+00, 3.651E-01, 9.310E-02, 5.077E-01, 1.403E-01 }, { 1550, 1.3730, 0.000E+00, 0.000E+00, 0.000E+00, 1.064E+01, 5.732E+00, 3.650E-01, 9.300E-02, 5.077E-01, 1.405E-01 }, { 1551, 1.3730, 0.000E+00, 0.000E+00, 0.000E+00, 1.054E+01, 5.728E+00, 3.649E-01, 9.290E-02, 5.075E-01, 1.407E-01 }, { 1552, 1.3731, 0.000E+00, 0.000E+00, 0.000E+00, 1.044E+01, 5.731E+00, 3.648E-01, 9.280E-02, 5.074E-01, 1.410E-01 }, { 1553, 1.3734, 0.000E+00, 0.000E+00, 0.000E+00, 1.032E+01, 5.724E+00, 3.647E-01, 9.270E-02, 5.073E-01, 1.413E-01 }, { 1554, 1.3734, 0.000E+00, 0.000E+00, 0.000E+00, 1.022E+01, 5.724E+00, 3.646E-01, 9.260E-02, 5.072E-01, 1.415E-01 }, { 1555, 1.3736, 0.000E+00, 0.000E+00, 0.000E+00, 1.011E+01, 5.715E+00, 3.645E-01, 9.250E-02, 5.071E-01, 1.418E-01 }, { 1556, 1.3737, 0.000E+00, 0.000E+00, 0.000E+00, 1.001E+01, 5.697E+00, 3.644E-01, 9.240E-02, 5.072E-01, 1.424E-01 }, { 1557, 1.3738, 0.000E+00, 0.000E+00, 0.000E+00, 9.912E+00, 5.693E+00, 3.643E-01, 9.230E-02, 5.074E-01, 1.429E-01 }, { 1558, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 9.839E+00, 5.703E+00, 3.642E-01, 9.220E-02, 5.075E-01, 1.435E-01 }, { 1559, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 9.754E+00, 5.700E+00, 3.641E-01, 9.210E-02, 5.077E-01, 1.440E-01 }, { 1560, 1.3734, 0.000E+00, 0.000E+00, 0.000E+00, 9.660E+00, 5.713E+00, 3.640E-01, 9.200E-02, 5.078E-01, 1.446E-01 }, { 1561, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 9.563E+00, 5.728E+00, 3.626E-01, 9.155E-02, 5.079E-01, 1.451E-01 }, { 1562, 1.3736, 0.000E+00, 0.000E+00, 0.000E+00, 9.477E+00, 5.731E+00, 3.611E-01, 9.110E-02, 5.080E-01, 1.455E-01 }, { 1563, 1.3738, 0.000E+00, 0.000E+00, 0.000E+00, 9.383E+00, 5.735E+00, 3.597E-01, 9.065E-02, 5.082E-01, 1.460E-01 }, { 1564, 1.3737, 0.000E+00, 0.000E+00, 0.000E+00, 9.305E+00, 5.743E+00, 3.582E-01, 9.020E-02, 5.083E-01, 1.465E-01 }, { 1565, 1.3738, 0.000E+00, 0.000E+00, 0.000E+00, 9.202E+00, 5.754E+00, 3.568E-01, 8.975E-02, 5.084E-01, 1.470E-01 }, { 1566, 1.3736, 0.000E+00, 0.000E+00, 0.000E+00, 9.133E+00, 5.753E+00, 3.553E-01, 8.930E-02, 5.084E-01, 1.475E-01 }, { 1567, 1.3737, 0.000E+00, 0.000E+00, 0.000E+00, 9.047E+00, 5.744E+00, 3.539E-01, 8.885E-02, 5.084E-01, 1.480E-01 }, { 1568, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 8.977E+00, 5.746E+00, 3.524E-01, 8.840E-02, 5.084E-01, 1.485E-01 }, { 1569, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 8.898E+00, 5.746E+00, 3.510E-01, 8.795E-02, 5.084E-01, 1.489E-01 }, { 1570, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 8.820E+00, 5.746E+00, 3.495E-01, 8.750E-02, 5.084E-01, 1.494E-01 }, { 1571, 1.3734, 0.000E+00, 0.000E+00, 0.000E+00, 8.742E+00, 5.750E+00, 3.481E-01, 8.705E-02, 5.084E-01, 1.498E-01 }, { 1572, 1.3734, 0.000E+00, 0.000E+00, 0.000E+00, 8.665E+00, 5.749E+00, 3.466E-01, 8.660E-02, 5.084E-01, 1.501E-01 }, { 1573, 1.3734, 0.000E+00, 0.000E+00, 0.000E+00, 8.588E+00, 5.743E+00, 3.452E-01, 8.615E-02, 5.084E-01, 1.504E-01 }, { 1574, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 8.509E+00, 5.740E+00, 3.437E-01, 8.570E-02, 5.084E-01, 1.508E-01 }, { 1575, 1.3732, 0.000E+00, 0.000E+00, 0.000E+00, 8.448E+00, 5.747E+00, 3.423E-01, 8.525E-02, 5.084E-01, 1.511E-01 }, { 1576, 1.3733, 0.000E+00, 0.000E+00, 0.000E+00, 8.364E+00, 5.739E+00, 3.408E-01, 8.480E-02, 5.084E-01, 1.512E-01 }, { 1577, 1.3732, 0.000E+00, 0.000E+00, 0.000E+00, 8.295E+00, 5.755E+00, 3.394E-01, 8.435E-02, 5.084E-01, 1.513E-01 }, { 1578, 1.3732, 0.000E+00, 0.000E+00, 0.000E+00, 8.234E+00, 5.749E+00, 3.379E-01, 8.390E-02, 5.085E-01, 1.515E-01 }, { 1579, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 8.157E+00, 5.753E+00, 3.365E-01, 8.345E-02, 5.085E-01, 1.516E-01 }, { 1580, 1.3736, 0.000E+00, 0.000E+00, 0.000E+00, 8.104E+00, 5.745E+00, 3.350E-01, 8.300E-02, 5.085E-01, 1.517E-01 }, { 1581, 1.3739, 0.000E+00, 0.000E+00, 0.000E+00, 8.036E+00, 5.732E+00, 3.350E-01, 8.290E-02, 5.087E-01, 1.517E-01 }, { 1582, 1.3742, 0.000E+00, 0.000E+00, 0.000E+00, 7.959E+00, 5.735E+00, 3.349E-01, 8.280E-02, 5.089E-01, 1.517E-01 }, { 1583, 1.3741, 0.000E+00, 0.000E+00, 0.000E+00, 7.890E+00, 5.724E+00, 3.349E-01, 8.270E-02, 5.090E-01, 1.517E-01 }, { 1584, 1.3738, 0.000E+00, 0.000E+00, 0.000E+00, 7.834E+00, 5.725E+00, 3.348E-01, 8.260E-02, 5.092E-01, 1.517E-01 }, { 1585, 1.3737, 0.000E+00, 0.000E+00, 0.000E+00, 7.773E+00, 5.712E+00, 3.348E-01, 8.250E-02, 5.094E-01, 1.517E-01 }, { 1586, 1.3737, 0.000E+00, 0.000E+00, 0.000E+00, 7.712E+00, 5.702E+00, 3.347E-01, 8.240E-02, 5.096E-01, 1.517E-01 }, { 1587, 1.3736, 0.000E+00, 0.000E+00, 0.000E+00, 7.654E+00, 5.700E+00, 3.347E-01, 8.230E-02, 5.097E-01, 1.517E-01 }, { 1588, 1.3735, 0.000E+00, 0.000E+00, 0.000E+00, 7.609E+00, 5.699E+00, 3.346E-01, 8.220E-02, 5.099E-01, 1.517E-01 }, { 1589, 1.3737, 0.000E+00, 0.000E+00, 0.000E+00, 7.548E+00, 5.686E+00, 3.346E-01, 8.210E-02, 5.101E-01, 1.517E-01 }, { 1590, 1.3738, 0.000E+00, 0.000E+00, 0.000E+00, 7.495E+00, 5.685E+00, 3.345E-01, 8.200E-02, 5.103E-01, 1.517E-01 }, { 1591, 1.3741, 0.000E+00, 0.000E+00, 0.000E+00, 7.432E+00, 5.672E+00, 3.345E-01, 8.190E-02, 5.103E-01, 1.521E-01 }, { 1592, 1.3743, 0.000E+00, 0.000E+00, 0.000E+00, 7.374E+00, 5.659E+00, 3.344E-01, 8.180E-02, 5.104E-01, 1.525E-01 }, { 1593, 1.3744, 0.000E+00, 0.000E+00, 0.000E+00, 7.315E+00, 5.627E+00, 3.344E-01, 8.170E-02, 5.104E-01, 1.530E-01 }, { 1594, 1.3744, 0.000E+00, 0.000E+00, 0.000E+00, 7.252E+00, 5.613E+00, 3.343E-01, 8.160E-02, 5.105E-01, 1.534E-01 }, { 1595, 1.3743, 0.000E+00, 0.000E+00, 0.000E+00, 7.203E+00, 5.590E+00, 3.343E-01, 8.150E-02, 5.106E-01, 1.538E-01 }, { 1596, 1.3740, 0.000E+00, 0.000E+00, 0.000E+00, 7.164E+00, 5.591E+00, 3.342E-01, 8.140E-02, 5.103E-01, 1.541E-01 }, { 1597, 1.3740, 0.000E+00, 0.000E+00, 0.000E+00, 7.124E+00, 5.563E+00, 3.342E-01, 8.130E-02, 5.101E-01, 1.544E-01 }, { 1598, 1.3741, 0.000E+00, 0.000E+00, 0.000E+00, 7.084E+00, 5.552E+00, 3.341E-01, 8.120E-02, 5.099E-01, 1.547E-01 }, { 1599, 1.3741, 0.000E+00, 0.000E+00, 0.000E+00, 7.041E+00, 5.525E+00, 3.341E-01, 8.110E-02, 5.097E-01, 1.550E-01 }, { 1600, 1.3742, 0.000E+00, 0.000E+00, 0.000E+00, 6.987E+00, 5.517E+00, 3.340E-01, 8.100E-02, 5.095E-01, 1.553E-01 }, { 1601, 1.3742, 0.000E+00, 0.000E+00, 0.000E+00, 6.943E+00, 5.506E+00, 3.338E-01, 8.085E-02, 5.093E-01, 1.555E-01 }, { 1602, 1.3741, 0.000E+00, 0.000E+00, 0.000E+00, 6.910E+00, 5.494E+00, 3.335E-01, 8.070E-02, 5.091E-01, 1.557E-01 }, { 1603, 1.3743, 0.000E+00, 0.000E+00, 0.000E+00, 6.865E+00, 5.459E+00, 3.333E-01, 8.055E-02, 5.089E-01, 1.558E-01 }, { 1604, 1.3743, 0.000E+00, 0.000E+00, 0.000E+00, 6.828E+00, 5.450E+00, 3.330E-01, 8.040E-02, 5.087E-01, 1.560E-01 }, { 1605, 1.3743, 0.000E+00, 0.000E+00, 0.000E+00, 6.776E+00, 5.438E+00, 3.328E-01, 8.025E-02, 5.085E-01, 1.562E-01 }, { 1606, 1.3742, 0.000E+00, 0.000E+00, 0.000E+00, 6.742E+00, 5.428E+00, 3.325E-01, 8.010E-02, 5.086E-01, 1.568E-01 }, { 1607, 1.3741, 0.000E+00, 0.000E+00, 0.000E+00, 6.714E+00, 5.407E+00, 3.323E-01, 7.995E-02, 5.087E-01, 1.573E-01 }, { 1608, 1.3740, 0.000E+00, 0.000E+00, 0.000E+00, 6.695E+00, 5.391E+00, 3.320E-01, 7.980E-02, 5.088E-01, 1.578E-01 }, { 1609, 1.3740, 0.000E+00, 0.000E+00, 0.000E+00, 6.654E+00, 5.382E+00, 3.318E-01, 7.965E-02, 5.089E-01, 1.584E-01 }, { 1610, 1.3738, 0.000E+00, 0.000E+00, 0.000E+00, 6.630E+00, 5.376E+00, 3.315E-01, 7.950E-02, 5.090E-01, 1.589E-01 }, { 1611, 1.3736, 0.000E+00, 0.000E+00, 0.000E+00, 6.599E+00, 5.358E+00, 3.313E-01, 7.935E-02, 5.091E-01, 1.590E-01 }, { 1612, 1.3734, 0.000E+00, 0.000E+00, 0.000E+00, 6.567E+00, 5.347E+00, 3.310E-01, 7.920E-02, 5.092E-01, 1.590E-01 }, { 1613, 1.3733, 0.000E+00, 0.000E+00, 0.000E+00, 6.526E+00, 5.333E+00, 3.308E-01, 7.905E-02, 5.093E-01, 1.591E-01 }, { 1614, 1.3731, 0.000E+00, 0.000E+00, 0.000E+00, 6.501E+00, 5.319E+00, 3.305E-01, 7.890E-02, 5.095E-01, 1.592E-01 }, { 1615, 1.3730, 0.000E+00, 0.000E+00, 0.000E+00, 6.474E+00, 5.301E+00, 3.303E-01, 7.875E-02, 5.096E-01, 1.592E-01 }, { 1616, 1.3730, 0.000E+00, 0.000E+00, 0.000E+00, 6.449E+00, 5.292E+00, 3.300E-01, 7.860E-02, 5.095E-01, 1.594E-01 }, { 1617, 1.3731, 0.000E+00, 0.000E+00, 0.000E+00, 6.420E+00, 5.284E+00, 3.298E-01, 7.845E-02, 5.093E-01, 1.595E-01 }, { 1618, 1.3730, 0.000E+00, 0.000E+00, 0.000E+00, 6.401E+00, 5.274E+00, 3.295E-01, 7.830E-02, 5.092E-01, 1.597E-01 }, { 1619, 1.3732, 0.000E+00, 0.000E+00, 0.000E+00, 6.363E+00, 5.258E+00, 3.293E-01, 7.815E-02, 5.091E-01, 1.598E-01 }, { 1620, 1.3731, 0.000E+00, 0.000E+00, 0.000E+00, 6.345E+00, 5.253E+00, 3.290E-01, 7.800E-02, 5.090E-01, 1.600E-01 }, { 1621, 1.3730, 0.000E+00, 0.000E+00, 0.000E+00, 6.309E+00, 5.249E+00, 3.280E-01, 7.770E-02, 5.089E-01, 1.600E-01 }, { 1622, 1.3729, 0.000E+00, 0.000E+00, 0.000E+00, 6.282E+00, 5.233E+00, 3.270E-01, 7.740E-02, 5.087E-01, 1.600E-01 }, { 1623, 1.3728, 0.000E+00, 0.000E+00, 0.000E+00, 6.250E+00, 5.222E+00, 3.260E-01, 7.710E-02, 5.086E-01, 1.600E-01 }, { 1624, 1.3727, 0.000E+00, 0.000E+00, 0.000E+00, 6.214E+00, 5.211E+00, 3.250E-01, 7.680E-02, 5.085E-01, 1.600E-01 }, { 1625, 1.3726, 0.000E+00, 0.000E+00, 0.000E+00, 6.186E+00, 5.204E+00, 3.240E-01, 7.650E-02, 5.084E-01, 1.600E-01 }, { 1626, 1.3725, 0.000E+00, 0.000E+00, 0.000E+00, 6.163E+00, 5.210E+00, 3.230E-01, 7.620E-02, 5.083E-01, 1.603E-01 }, { 1627, 1.3726, 0.000E+00, 0.000E+00, 0.000E+00, 6.130E+00, 5.200E+00, 3.220E-01, 7.590E-02, 5.083E-01, 1.606E-01 }, { 1628, 1.3725, 0.000E+00, 0.000E+00, 0.000E+00, 6.121E+00, 5.193E+00, 3.210E-01, 7.560E-02, 5.083E-01, 1.608E-01 }, { 1629, 1.3726, 0.000E+00, 0.000E+00, 0.000E+00, 6.091E+00, 5.186E+00, 3.200E-01, 7.530E-02, 5.082E-01, 1.611E-01 }, { 1630, 1.3726, 0.000E+00, 0.000E+00, 0.000E+00, 6.076E+00, 5.177E+00, 3.190E-01, 7.500E-02, 5.082E-01, 1.614E-01 }, { 1631, 1.3724, 0.000E+00, 0.000E+00, 0.000E+00, 6.053E+00, 5.175E+00, 3.180E-01, 7.470E-02, 5.082E-01, 1.618E-01 }, { 1632, 1.3719, 0.000E+00, 0.000E+00, 0.000E+00, 6.048E+00, 5.178E+00, 3.170E-01, 7.440E-02, 5.082E-01, 1.621E-01 }, { 1633, 1.3718, 0.000E+00, 0.000E+00, 0.000E+00, 6.016E+00, 5.173E+00, 3.160E-01, 7.410E-02, 5.082E-01, 1.625E-01 }, { 1634, 1.3716, 0.000E+00, 0.000E+00, 0.000E+00, 6.005E+00, 5.152E+00, 3.150E-01, 7.380E-02, 5.082E-01, 1.628E-01 }, { 1635, 1.3715, 0.000E+00, 0.000E+00, 0.000E+00, 5.982E+00, 5.135E+00, 3.140E-01, 7.350E-02, 5.082E-01, 1.631E-01 }, { 1636, 1.3712, 0.000E+00, 0.000E+00, 0.000E+00, 5.973E+00, 5.139E+00, 3.130E-01, 7.320E-02, 5.082E-01, 1.631E-01 }, { 1637, 1.3713, 0.000E+00, 0.000E+00, 0.000E+00, 5.947E+00, 5.128E+00, 3.120E-01, 7.290E-02, 5.082E-01, 1.632E-01 }, { 1638, 1.3711, 0.000E+00, 0.000E+00, 0.000E+00, 5.940E+00, 5.121E+00, 3.110E-01, 7.260E-02, 5.082E-01, 1.632E-01 }, { 1639, 1.3710, 0.000E+00, 0.000E+00, 0.000E+00, 5.919E+00, 5.114E+00, 3.100E-01, 7.230E-02, 5.082E-01, 1.632E-01 }, { 1640, 1.3707, 0.000E+00, 0.000E+00, 0.000E+00, 5.911E+00, 5.126E+00, 3.090E-01, 7.200E-02, 5.082E-01, 1.632E-01 }, { 1641, 1.3708, 0.000E+00, 0.000E+00, 0.000E+00, 5.887E+00, 5.107E+00, 3.089E-01, 7.190E-02, 5.082E-01, 1.632E-01 }, { 1642, 1.3707, 0.000E+00, 0.000E+00, 0.000E+00, 5.875E+00, 5.104E+00, 3.087E-01, 7.180E-02, 5.082E-01, 1.632E-01 }, { 1643, 1.3708, 0.000E+00, 0.000E+00, 0.000E+00, 5.846E+00, 5.100E+00, 3.086E-01, 7.170E-02, 5.082E-01, 1.632E-01 }, { 1644, 1.3708, 0.000E+00, 0.000E+00, 0.000E+00, 5.826E+00, 5.109E+00, 3.084E-01, 7.160E-02, 5.082E-01, 1.632E-01 }, { 1645, 1.3710, 0.000E+00, 0.000E+00, 0.000E+00, 5.798E+00, 5.114E+00, 3.083E-01, 7.150E-02, 5.082E-01, 1.632E-01 }, { 1646, 1.3712, 0.000E+00, 0.000E+00, 0.000E+00, 5.787E+00, 5.112E+00, 3.081E-01, 7.140E-02, 5.085E-01, 1.632E-01 }, { 1647, 1.3715, 0.000E+00, 0.000E+00, 0.000E+00, 5.751E+00, 5.128E+00, 3.080E-01, 7.130E-02, 5.089E-01, 1.632E-01 }, { 1648, 1.3715, 0.000E+00, 0.000E+00, 0.000E+00, 5.746E+00, 5.136E+00, 3.078E-01, 7.120E-02, 5.092E-01, 1.632E-01 }, { 1649, 1.3716, 0.000E+00, 0.000E+00, 0.000E+00, 5.718E+00, 5.131E+00, 3.077E-01, 7.110E-02, 5.096E-01, 1.632E-01 }, { 1650, 1.3714, 0.000E+00, 0.000E+00, 0.000E+00, 5.705E+00, 5.152E+00, 3.075E-01, 7.100E-02, 5.099E-01, 1.632E-01 }, { 1651, 1.3714, 0.000E+00, 0.000E+00, 0.000E+00, 5.685E+00, 5.175E+00, 3.074E-01, 7.090E-02, 5.101E-01, 1.633E-01 }, { 1652, 1.3712, 0.000E+00, 0.000E+00, 0.000E+00, 5.684E+00, 5.193E+00, 3.072E-01, 7.080E-02, 5.104E-01, 1.635E-01 }, { 1653, 1.3713, 0.000E+00, 0.000E+00, 0.000E+00, 5.657E+00, 5.200E+00, 3.071E-01, 7.070E-02, 5.106E-01, 1.636E-01 }, { 1654, 1.3709, 0.000E+00, 0.000E+00, 0.000E+00, 5.658E+00, 5.244E+00, 3.069E-01, 7.060E-02, 5.109E-01, 1.638E-01 }, { 1655, 1.3708, 0.000E+00, 0.000E+00, 0.000E+00, 5.644E+00, 5.257E+00, 3.068E-01, 7.050E-02, 5.111E-01, 1.639E-01 }, { 1656, 1.3704, 0.000E+00, 0.000E+00, 0.000E+00, 5.648E+00, 5.273E+00, 3.066E-01, 7.040E-02, 5.109E-01, 1.639E-01 }, { 1657, 1.3704, 0.000E+00, 0.000E+00, 0.000E+00, 5.626E+00, 5.289E+00, 3.065E-01, 7.030E-02, 5.107E-01, 1.639E-01 }, { 1658, 1.3700, 0.000E+00, 0.000E+00, 0.000E+00, 5.626E+00, 5.335E+00, 3.063E-01, 7.020E-02, 5.106E-01, 1.639E-01 }, { 1659, 1.3698, 0.000E+00, 0.000E+00, 0.000E+00, 5.619E+00, 5.366E+00, 3.062E-01, 7.010E-02, 5.104E-01, 1.639E-01 }, { 1660, 1.3695, 0.000E+00, 0.000E+00, 0.000E+00, 5.618E+00, 5.389E+00, 3.060E-01, 7.000E-02, 5.102E-01, 1.639E-01 }, { 1661, 1.3694, 0.000E+00, 0.000E+00, 0.000E+00, 5.603E+00, 5.427E+00, 3.054E-01, 6.975E-02, 5.100E-01, 1.639E-01 }, { 1662, 1.3692, 0.000E+00, 0.000E+00, 0.000E+00, 5.614E+00, 5.453E+00, 3.047E-01, 6.950E-02, 5.098E-01, 1.639E-01 }, { 1663, 1.3690, 0.000E+00, 0.000E+00, 0.000E+00, 5.597E+00, 5.490E+00, 3.041E-01, 6.925E-02, 5.097E-01, 1.639E-01 }, { 1664, 1.3687, 0.000E+00, 0.000E+00, 0.000E+00, 5.603E+00, 5.522E+00, 3.034E-01, 6.900E-02, 5.095E-01, 1.639E-01 }, { 1665, 1.3687, 0.000E+00, 0.000E+00, 0.000E+00, 5.582E+00, 5.562E+00, 3.028E-01, 6.875E-02, 5.093E-01, 1.639E-01 }, { 1666, 1.3684, 0.000E+00, 0.000E+00, 0.000E+00, 5.584E+00, 5.605E+00, 3.021E-01, 6.850E-02, 5.091E-01, 1.639E-01 }, { 1667, 1.3685, 0.000E+00, 0.000E+00, 0.000E+00, 5.564E+00, 5.652E+00, 3.015E-01, 6.825E-02, 5.090E-01, 1.639E-01 }, { 1668, 1.3684, 0.000E+00, 0.000E+00, 0.000E+00, 5.563E+00, 5.698E+00, 3.008E-01, 6.800E-02, 5.088E-01, 1.639E-01 }, { 1669, 1.3683, 0.000E+00, 0.000E+00, 0.000E+00, 5.547E+00, 5.744E+00, 3.002E-01, 6.775E-02, 5.086E-01, 1.639E-01 }, { 1670, 1.3683, 0.000E+00, 0.000E+00, 0.000E+00, 5.545E+00, 5.743E+00, 2.995E-01, 6.750E-02, 5.084E-01, 1.639E-01 }, { 1671, 1.3687, 0.000E+00, 0.000E+00, 0.000E+00, 5.536E+00, 5.642E+00, 2.989E-01, 6.725E-02, 5.083E-01, 1.639E-01 }, { 1672, 1.3681, 0.000E+00, 0.000E+00, 0.000E+00, 5.542E+00, 5.689E+00, 2.982E-01, 6.700E-02, 5.083E-01, 1.639E-01 }, { 1673, 1.3678, 0.000E+00, 0.000E+00, 0.000E+00, 5.529E+00, 5.722E+00, 2.976E-01, 6.675E-02, 5.082E-01, 1.639E-01 }, { 1674, 1.3674, 0.000E+00, 0.000E+00, 0.000E+00, 5.532E+00, 5.755E+00, 2.969E-01, 6.650E-02, 5.081E-01, 1.639E-01 }, { 1675, 1.3670, 0.000E+00, 0.000E+00, 0.000E+00, 5.525E+00, 5.798E+00, 2.963E-01, 6.625E-02, 5.081E-01, 1.639E-01 }, { 1676, 1.3665, 0.000E+00, 0.000E+00, 0.000E+00, 5.533E+00, 5.847E+00, 2.956E-01, 6.600E-02, 5.081E-01, 1.639E-01 }, { 1677, 1.3665, 0.000E+00, 0.000E+00, 0.000E+00, 5.528E+00, 5.875E+00, 2.950E-01, 6.575E-02, 5.081E-01, 1.639E-01 }, { 1678, 1.3664, 0.000E+00, 0.000E+00, 0.000E+00, 5.529E+00, 5.918E+00, 2.943E-01, 6.550E-02, 5.080E-01, 1.638E-01 }, { 1679, 1.3663, 0.000E+00, 0.000E+00, 0.000E+00, 5.516E+00, 5.971E+00, 2.937E-01, 6.525E-02, 5.080E-01, 1.638E-01 }, { 1680, 1.3659, 0.000E+00, 0.000E+00, 0.000E+00, 5.524E+00, 6.022E+00, 2.930E-01, 6.500E-02, 5.080E-01, 1.638E-01 }, { 1681, 1.3659, 0.000E+00, 0.000E+00, 0.000E+00, 5.516E+00, 6.061E+00, 2.923E-01, 6.480E-02, 5.080E-01, 1.639E-01 }, { 1682, 1.3656, 0.000E+00, 0.000E+00, 0.000E+00, 5.526E+00, 6.116E+00, 2.915E-01, 6.460E-02, 5.080E-01, 1.640E-01 }, { 1683, 1.3655, 0.000E+00, 0.000E+00, 0.000E+00, 5.520E+00, 6.173E+00, 2.908E-01, 6.440E-02, 5.080E-01, 1.641E-01 }, { 1684, 1.3654, 0.000E+00, 0.000E+00, 0.000E+00, 5.520E+00, 6.214E+00, 2.900E-01, 6.420E-02, 5.080E-01, 1.641E-01 }, { 1685, 1.3655, 0.000E+00, 0.000E+00, 0.000E+00, 5.516E+00, 6.266E+00, 2.893E-01, 6.400E-02, 5.080E-01, 1.642E-01 }, { 1686, 1.3654, 0.000E+00, 0.000E+00, 0.000E+00, 5.522E+00, 6.319E+00, 2.885E-01, 6.380E-02, 5.080E-01, 1.642E-01 }, { 1687, 1.3654, 0.000E+00, 0.000E+00, 0.000E+00, 5.511E+00, 6.381E+00, 2.878E-01, 6.360E-02, 5.080E-01, 1.642E-01 }, { 1688, 1.3651, 0.000E+00, 0.000E+00, 0.000E+00, 5.527E+00, 6.426E+00, 2.870E-01, 6.340E-02, 5.080E-01, 1.642E-01 }, { 1689, 1.3651, 0.000E+00, 0.000E+00, 0.000E+00, 5.511E+00, 6.486E+00, 2.863E-01, 6.320E-02, 5.080E-01, 1.642E-01 }, { 1690, 1.3648, 0.000E+00, 0.000E+00, 0.000E+00, 5.519E+00, 6.541E+00, 2.855E-01, 6.300E-02, 5.080E-01, 1.642E-01 }, { 1691, 1.3648, 0.000E+00, 0.000E+00, 0.000E+00, 5.515E+00, 6.579E+00, 2.848E-01, 6.280E-02, 5.082E-01, 1.643E-01 }, { 1692, 1.3647, 0.000E+00, 0.000E+00, 0.000E+00, 5.520E+00, 6.616E+00, 2.840E-01, 6.260E-02, 5.084E-01, 1.643E-01 }, { 1693, 1.3648, 0.000E+00, 0.000E+00, 0.000E+00, 5.510E+00, 6.666E+00, 2.833E-01, 6.240E-02, 5.086E-01, 1.644E-01 }, { 1694, 1.3647, 0.000E+00, 0.000E+00, 0.000E+00, 5.518E+00, 6.728E+00, 2.825E-01, 6.220E-02, 5.088E-01, 1.645E-01 }, { 1695, 1.3647, 0.000E+00, 0.000E+00, 0.000E+00, 5.523E+00, 6.771E+00, 2.818E-01, 6.200E-02, 5.090E-01, 1.645E-01 }, { 1696, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 5.538E+00, 6.807E+00, 2.810E-01, 6.180E-02, 5.093E-01, 1.645E-01 }, { 1697, 1.3647, 0.000E+00, 0.000E+00, 0.000E+00, 5.535E+00, 6.858E+00, 2.803E-01, 6.160E-02, 5.095E-01, 1.645E-01 }, { 1698, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 5.544E+00, 6.907E+00, 2.795E-01, 6.140E-02, 5.098E-01, 1.645E-01 }, { 1699, 1.3644, 0.000E+00, 0.000E+00, 0.000E+00, 5.557E+00, 6.959E+00, 2.788E-01, 6.120E-02, 5.101E-01, 1.645E-01 }, { 1700, 1.3640, 0.000E+00, 0.000E+00, 0.000E+00, 5.571E+00, 7.006E+00, 2.780E-01, 6.100E-02, 5.103E-01, 1.645E-01 }, { 1701, 1.3638, 0.000E+00, 0.000E+00, 0.000E+00, 5.583E+00, 7.052E+00, 2.777E-01, 6.090E-02, 5.106E-01, 1.645E-01 }, { 1702, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 5.606E+00, 7.093E+00, 2.774E-01, 6.080E-02, 5.108E-01, 1.645E-01 }, { 1703, 1.3634, 0.000E+00, 0.000E+00, 0.000E+00, 5.607E+00, 7.136E+00, 2.771E-01, 6.070E-02, 5.111E-01, 1.645E-01 }, { 1704, 1.3632, 0.000E+00, 0.000E+00, 0.000E+00, 5.629E+00, 7.164E+00, 2.768E-01, 6.060E-02, 5.114E-01, 1.645E-01 }, { 1705, 1.3631, 0.000E+00, 0.000E+00, 0.000E+00, 5.636E+00, 7.199E+00, 2.765E-01, 6.050E-02, 5.116E-01, 1.645E-01 }, { 1706, 1.3628, 0.000E+00, 0.000E+00, 0.000E+00, 5.664E+00, 7.232E+00, 2.762E-01, 6.040E-02, 5.117E-01, 1.645E-01 }, { 1707, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 5.670E+00, 7.266E+00, 2.759E-01, 6.030E-02, 5.118E-01, 1.645E-01 }, { 1708, 1.3627, 0.000E+00, 0.000E+00, 0.000E+00, 5.693E+00, 7.315E+00, 2.756E-01, 6.020E-02, 5.119E-01, 1.645E-01 }, { 1709, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 5.702E+00, 7.340E+00, 2.753E-01, 6.010E-02, 5.120E-01, 1.645E-01 }, { 1710, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 5.733E+00, 7.361E+00, 2.750E-01, 6.000E-02, 5.121E-01, 1.645E-01 }, { 1711, 1.3627, 0.000E+00, 0.000E+00, 0.000E+00, 5.752E+00, 7.399E+00, 2.747E-01, 5.990E-02, 5.122E-01, 1.645E-01 }, { 1712, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 5.766E+00, 7.440E+00, 2.744E-01, 5.980E-02, 5.122E-01, 1.645E-01 }, { 1713, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 5.776E+00, 7.473E+00, 2.741E-01, 5.970E-02, 5.122E-01, 1.645E-01 }, { 1714, 1.3623, 0.000E+00, 0.000E+00, 0.000E+00, 5.797E+00, 7.505E+00, 2.738E-01, 5.960E-02, 5.123E-01, 1.645E-01 }, { 1715, 1.3622, 0.000E+00, 0.000E+00, 0.000E+00, 5.811E+00, 7.525E+00, 2.735E-01, 5.950E-02, 5.123E-01, 1.645E-01 }, { 1716, 1.3619, 0.000E+00, 0.000E+00, 0.000E+00, 5.829E+00, 7.557E+00, 2.732E-01, 5.940E-02, 5.120E-01, 1.642E-01 }, { 1717, 1.3620, 0.000E+00, 0.000E+00, 0.000E+00, 5.842E+00, 7.579E+00, 2.729E-01, 5.930E-02, 5.116E-01, 1.639E-01 }, { 1718, 1.3619, 0.000E+00, 0.000E+00, 0.000E+00, 5.877E+00, 7.604E+00, 2.726E-01, 5.920E-02, 5.113E-01, 1.636E-01 }, { 1719, 1.3619, 0.000E+00, 0.000E+00, 0.000E+00, 5.891E+00, 7.633E+00, 2.723E-01, 5.910E-02, 5.110E-01, 1.633E-01 }, { 1720, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 5.930E+00, 7.653E+00, 2.720E-01, 5.900E-02, 5.107E-01, 1.630E-01 }, { 1721, 1.3615, 0.000E+00, 0.000E+00, 0.000E+00, 5.945E+00, 7.674E+00, 2.689E-01, 5.830E-02, 5.104E-01, 1.630E-01 }, { 1722, 1.3612, 0.000E+00, 0.000E+00, 0.000E+00, 5.972E+00, 7.691E+00, 2.658E-01, 5.760E-02, 5.102E-01, 1.630E-01 }, { 1723, 1.3611, 0.000E+00, 0.000E+00, 0.000E+00, 5.999E+00, 7.699E+00, 2.627E-01, 5.690E-02, 5.100E-01, 1.630E-01 }, { 1724, 1.3611, 0.000E+00, 0.000E+00, 0.000E+00, 6.025E+00, 7.708E+00, 2.596E-01, 5.620E-02, 5.098E-01, 1.630E-01 }, { 1725, 1.3612, 0.000E+00, 0.000E+00, 0.000E+00, 6.051E+00, 7.721E+00, 2.565E-01, 5.550E-02, 5.095E-01, 1.630E-01 }, { 1726, 1.3613, 0.000E+00, 0.000E+00, 0.000E+00, 6.087E+00, 7.730E+00, 2.534E-01, 5.480E-02, 5.096E-01, 1.629E-01 }, { 1727, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 6.096E+00, 7.729E+00, 2.503E-01, 5.410E-02, 5.096E-01, 1.627E-01 }, { 1728, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 6.136E+00, 7.712E+00, 2.472E-01, 5.340E-02, 5.097E-01, 1.626E-01 }, { 1729, 1.3618, 0.000E+00, 0.000E+00, 0.000E+00, 6.166E+00, 7.702E+00, 2.441E-01, 5.270E-02, 5.097E-01, 1.624E-01 }, { 1730, 1.3618, 0.000E+00, 0.000E+00, 0.000E+00, 6.198E+00, 7.695E+00, 2.410E-01, 5.200E-02, 5.098E-01, 1.623E-01 }, { 1731, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 6.219E+00, 7.670E+00, 2.379E-01, 5.130E-02, 5.095E-01, 1.623E-01 }, { 1732, 1.3615, 0.000E+00, 0.000E+00, 0.000E+00, 6.256E+00, 7.644E+00, 2.348E-01, 5.060E-02, 5.092E-01, 1.623E-01 }, { 1733, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 6.284E+00, 7.618E+00, 2.317E-01, 4.990E-02, 5.089E-01, 1.623E-01 }, { 1734, 1.3615, 0.000E+00, 0.000E+00, 0.000E+00, 6.335E+00, 7.585E+00, 2.286E-01, 4.920E-02, 5.086E-01, 1.623E-01 }, { 1735, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 6.369E+00, 7.555E+00, 2.255E-01, 4.850E-02, 5.083E-01, 1.623E-01 }, { 1736, 1.3618, 0.000E+00, 0.000E+00, 0.000E+00, 6.392E+00, 7.517E+00, 2.224E-01, 4.780E-02, 5.085E-01, 1.617E-01 }, { 1737, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 6.445E+00, 7.479E+00, 2.193E-01, 4.710E-02, 5.086E-01, 1.612E-01 }, { 1738, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 6.493E+00, 7.451E+00, 2.162E-01, 4.640E-02, 5.088E-01, 1.607E-01 }, { 1739, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 6.517E+00, 7.435E+00, 2.131E-01, 4.570E-02, 5.090E-01, 1.602E-01 }, { 1740, 1.3613, 0.000E+00, 0.000E+00, 0.000E+00, 6.571E+00, 7.408E+00, 2.100E-01, 4.500E-02, 5.091E-01, 1.597E-01 }, { 1741, 1.3612, 0.000E+00, 0.000E+00, 0.000E+00, 6.617E+00, 7.379E+00, 2.119E-01, 4.535E-02, 5.092E-01, 1.597E-01 }, { 1742, 1.3612, 0.000E+00, 0.000E+00, 0.000E+00, 6.658E+00, 7.363E+00, 2.138E-01, 4.570E-02, 5.093E-01, 1.597E-01 }, { 1743, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 6.689E+00, 7.347E+00, 2.157E-01, 4.605E-02, 5.094E-01, 1.597E-01 }, { 1744, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 6.748E+00, 7.332E+00, 2.176E-01, 4.640E-02, 5.095E-01, 1.597E-01 }, { 1745, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 6.796E+00, 7.332E+00, 2.195E-01, 4.675E-02, 5.096E-01, 1.597E-01 }, { 1746, 1.3618, 0.000E+00, 0.000E+00, 0.000E+00, 6.842E+00, 7.332E+00, 2.214E-01, 4.710E-02, 5.096E-01, 1.597E-01 }, { 1747, 1.3621, 0.000E+00, 0.000E+00, 0.000E+00, 6.897E+00, 7.304E+00, 2.233E-01, 4.745E-02, 5.096E-01, 1.597E-01 }, { 1748, 1.3623, 0.000E+00, 0.000E+00, 0.000E+00, 6.955E+00, 7.295E+00, 2.252E-01, 4.780E-02, 5.096E-01, 1.597E-01 }, { 1749, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 7.003E+00, 7.296E+00, 2.271E-01, 4.815E-02, 5.096E-01, 1.597E-01 }, { 1750, 1.3626, 0.000E+00, 0.000E+00, 0.000E+00, 7.054E+00, 7.291E+00, 2.290E-01, 4.850E-02, 5.096E-01, 1.597E-01 }, { 1751, 1.3626, 0.000E+00, 0.000E+00, 0.000E+00, 7.111E+00, 7.292E+00, 2.309E-01, 4.885E-02, 5.097E-01, 1.594E-01 }, { 1752, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 7.179E+00, 7.292E+00, 2.328E-01, 4.920E-02, 5.098E-01, 1.592E-01 }, { 1753, 1.3627, 0.000E+00, 0.000E+00, 0.000E+00, 7.235E+00, 7.281E+00, 2.347E-01, 4.955E-02, 5.099E-01, 1.590E-01 }, { 1754, 1.3633, 0.000E+00, 0.000E+00, 0.000E+00, 7.274E+00, 7.283E+00, 2.366E-01, 4.990E-02, 5.101E-01, 1.588E-01 }, { 1755, 1.3637, 0.000E+00, 0.000E+00, 0.000E+00, 7.339E+00, 7.264E+00, 2.385E-01, 5.025E-02, 5.102E-01, 1.586E-01 }, { 1756, 1.3637, 0.000E+00, 0.000E+00, 0.000E+00, 7.414E+00, 7.250E+00, 2.404E-01, 5.060E-02, 5.102E-01, 1.585E-01 }, { 1757, 1.3636, 0.000E+00, 0.000E+00, 0.000E+00, 7.481E+00, 7.240E+00, 2.423E-01, 5.095E-02, 5.103E-01, 1.585E-01 }, { 1758, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 7.536E+00, 7.228E+00, 2.442E-01, 5.130E-02, 5.103E-01, 1.584E-01 }, { 1759, 1.3633, 0.000E+00, 0.000E+00, 0.000E+00, 7.594E+00, 7.210E+00, 2.461E-01, 5.165E-02, 5.104E-01, 1.584E-01 }, { 1760, 1.3630, 0.000E+00, 0.000E+00, 0.000E+00, 7.669E+00, 7.186E+00, 2.480E-01, 5.200E-02, 5.105E-01, 1.584E-01 }, { 1761, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 7.734E+00, 7.164E+00, 2.427E-01, 5.085E-02, 5.102E-01, 1.580E-01 }, { 1762, 1.3632, 0.000E+00, 0.000E+00, 0.000E+00, 7.776E+00, 7.143E+00, 2.373E-01, 4.970E-02, 5.100E-01, 1.576E-01 }, { 1763, 1.3636, 0.000E+00, 0.000E+00, 0.000E+00, 7.833E+00, 7.114E+00, 2.320E-01, 4.855E-02, 5.098E-01, 1.572E-01 }, { 1764, 1.3641, 0.000E+00, 0.000E+00, 0.000E+00, 7.893E+00, 7.101E+00, 2.266E-01, 4.740E-02, 5.096E-01, 1.568E-01 }, { 1765, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 7.952E+00, 7.069E+00, 2.213E-01, 4.625E-02, 5.094E-01, 1.563E-01 }, { 1766, 1.3651, 0.000E+00, 0.000E+00, 0.000E+00, 8.000E+00, 7.038E+00, 2.159E-01, 4.510E-02, 5.092E-01, 1.559E-01 }, { 1767, 1.3653, 0.000E+00, 0.000E+00, 0.000E+00, 8.045E+00, 7.003E+00, 2.106E-01, 4.395E-02, 5.090E-01, 1.555E-01 }, { 1768, 1.3648, 0.000E+00, 0.000E+00, 0.000E+00, 8.103E+00, 6.974E+00, 2.052E-01, 4.280E-02, 5.088E-01, 1.550E-01 }, { 1769, 1.3640, 0.000E+00, 0.000E+00, 0.000E+00, 8.155E+00, 6.928E+00, 1.999E-01, 4.165E-02, 5.086E-01, 1.546E-01 }, { 1770, 1.3630, 0.000E+00, 0.000E+00, 0.000E+00, 8.205E+00, 6.889E+00, 1.945E-01, 4.050E-02, 5.084E-01, 1.541E-01 }, { 1771, 1.3620, 0.000E+00, 0.000E+00, 0.000E+00, 8.241E+00, 6.839E+00, 1.892E-01, 3.935E-02, 5.082E-01, 1.541E-01 }, { 1772, 1.3615, 0.000E+00, 0.000E+00, 0.000E+00, 8.264E+00, 6.793E+00, 1.838E-01, 3.820E-02, 5.081E-01, 1.541E-01 }, { 1773, 1.3608, 0.000E+00, 0.000E+00, 0.000E+00, 8.321E+00, 6.764E+00, 1.785E-01, 3.705E-02, 5.079E-01, 1.541E-01 }, { 1774, 1.3608, 0.000E+00, 0.000E+00, 0.000E+00, 8.352E+00, 6.729E+00, 1.731E-01, 3.590E-02, 5.078E-01, 1.541E-01 }, { 1775, 1.3611, 0.000E+00, 0.000E+00, 0.000E+00, 8.394E+00, 6.694E+00, 1.678E-01, 3.475E-02, 5.076E-01, 1.541E-01 }, { 1776, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 8.430E+00, 6.661E+00, 1.624E-01, 3.360E-02, 5.078E-01, 1.541E-01 }, { 1777, 1.3628, 0.000E+00, 0.000E+00, 0.000E+00, 8.448E+00, 6.613E+00, 1.571E-01, 3.245E-02, 5.079E-01, 1.541E-01 }, { 1778, 1.3638, 0.000E+00, 0.000E+00, 0.000E+00, 8.477E+00, 6.572E+00, 1.517E-01, 3.130E-02, 5.081E-01, 1.541E-01 }, { 1779, 1.3645, 0.000E+00, 0.000E+00, 0.000E+00, 8.512E+00, 6.546E+00, 1.464E-01, 3.015E-02, 5.082E-01, 1.541E-01 }, { 1780, 1.3649, 0.000E+00, 0.000E+00, 0.000E+00, 8.535E+00, 6.522E+00, 1.410E-01, 2.900E-02, 5.084E-01, 1.541E-01 }, { 1781, 1.3646, 0.000E+00, 0.000E+00, 0.000E+00, 8.562E+00, 6.507E+00, 1.356E-01, 2.790E-02, 5.086E-01, 1.541E-01 }, { 1782, 1.3637, 0.000E+00, 0.000E+00, 0.000E+00, 8.593E+00, 6.482E+00, 1.302E-01, 2.680E-02, 5.088E-01, 1.541E-01 }, { 1783, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 8.618E+00, 6.484E+00, 1.248E-01, 2.570E-02, 5.091E-01, 1.541E-01 }, { 1784, 1.3613, 0.000E+00, 0.000E+00, 0.000E+00, 8.640E+00, 6.479E+00, 1.194E-01, 2.460E-02, 5.093E-01, 1.541E-01 }, { 1785, 1.3601, 0.000E+00, 0.000E+00, 0.000E+00, 8.670E+00, 6.494E+00, 1.140E-01, 2.350E-02, 5.095E-01, 1.541E-01 }, { 1786, 1.3595, 0.000E+00, 0.000E+00, 0.000E+00, 8.689E+00, 6.496E+00, 1.086E-01, 2.240E-02, 5.095E-01, 1.541E-01 }, { 1787, 1.3593, 0.000E+00, 0.000E+00, 0.000E+00, 8.720E+00, 6.491E+00, 1.032E-01, 2.130E-02, 5.095E-01, 1.541E-01 }, { 1788, 1.3599, 0.000E+00, 0.000E+00, 0.000E+00, 8.738E+00, 6.461E+00, 9.780E-02, 2.020E-02, 5.095E-01, 1.541E-01 }, { 1789, 1.3607, 0.000E+00, 0.000E+00, 0.000E+00, 8.755E+00, 6.440E+00, 9.240E-02, 1.910E-02, 5.095E-01, 1.541E-01 }, { 1790, 1.3614, 0.000E+00, 0.000E+00, 0.000E+00, 8.777E+00, 6.430E+00, 8.700E-02, 1.800E-02, 5.095E-01, 1.541E-01 }, { 1791, 1.3623, 0.000E+00, 0.000E+00, 0.000E+00, 8.778E+00, 6.413E+00, 8.160E-02, 1.690E-02, 5.095E-01, 1.541E-01 }, { 1792, 1.3627, 0.000E+00, 0.000E+00, 0.000E+00, 8.778E+00, 6.421E+00, 7.620E-02, 1.580E-02, 5.095E-01, 1.541E-01 }, { 1793, 1.3627, 0.000E+00, 0.000E+00, 0.000E+00, 8.794E+00, 6.399E+00, 7.080E-02, 1.470E-02, 5.095E-01, 1.541E-01 }, { 1794, 1.3624, 0.000E+00, 0.000E+00, 0.000E+00, 8.805E+00, 6.379E+00, 6.540E-02, 1.360E-02, 5.095E-01, 1.541E-01 }, { 1795, 1.3622, 0.000E+00, 0.000E+00, 0.000E+00, 8.807E+00, 6.365E+00, 6.000E-02, 1.250E-02, 5.095E-01, 1.541E-01 }, { 1796, 1.3619, 0.000E+00, 0.000E+00, 0.000E+00, 8.809E+00, 6.372E+00, 5.460E-02, 1.140E-02, 5.095E-01, 1.541E-01 }, { 1797, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 8.811E+00, 6.346E+00, 4.920E-02, 1.030E-02, 5.095E-01, 1.541E-01 }, { 1798, 1.3616, 0.000E+00, 0.000E+00, 0.000E+00, 8.799E+00, 6.321E+00, 4.380E-02, 9.200E-03, 5.095E-01, 1.541E-01 }, { 1799, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 8.795E+00, 6.310E+00, 3.840E-02, 8.100E-03, 5.095E-01, 1.541E-01 }, { 1800, 1.3619, 0.000E+00, 0.000E+00, 0.000E+00, 8.789E+00, 6.314E+00, 3.300E-02, 7.000E-03, 5.095E-01, 1.541E-01 }, { 1801, 1.3621, 0.000E+00, 0.000E+00, 0.000E+00, 8.779E+00, 6.282E+00, 3.160E-02, 6.700E-03, 5.095E-01, 1.540E-01 }, { 1802, 1.3622, 0.000E+00, 0.000E+00, 0.000E+00, 8.767E+00, 6.277E+00, 3.020E-02, 6.400E-03, 5.095E-01, 1.539E-01 }, { 1803, 1.3626, 0.000E+00, 0.000E+00, 0.000E+00, 8.754E+00, 6.270E+00, 2.880E-02, 6.100E-03, 5.095E-01, 1.538E-01 }, { 1804, 1.3630, 0.000E+00, 0.000E+00, 0.000E+00, 8.750E+00, 6.258E+00, 2.740E-02, 5.800E-03, 5.095E-01, 1.538E-01 }, { 1805, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 8.738E+00, 6.242E+00, 2.600E-02, 5.500E-03, 5.094E-01, 1.537E-01 }, { 1806, 1.3637, 0.000E+00, 0.000E+00, 0.000E+00, 8.739E+00, 6.234E+00, 2.460E-02, 5.200E-03, 5.094E-01, 1.537E-01 }, { 1807, 1.3639, 0.000E+00, 0.000E+00, 0.000E+00, 8.735E+00, 6.221E+00, 2.320E-02, 4.900E-03, 5.094E-01, 1.537E-01 }, { 1808, 1.3636, 0.000E+00, 0.000E+00, 0.000E+00, 8.744E+00, 6.231E+00, 2.180E-02, 4.600E-03, 5.094E-01, 1.537E-01 }, { 1809, 1.3632, 0.000E+00, 0.000E+00, 0.000E+00, 8.753E+00, 6.221E+00, 2.040E-02, 4.300E-03, 5.094E-01, 1.537E-01 }, { 1810, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 8.755E+00, 6.205E+00, 1.900E-02, 4.000E-03, 5.094E-01, 1.537E-01 }, { 1811, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 8.780E+00, 6.192E+00, 1.760E-02, 3.700E-03, 5.090E-01, 1.537E-01 }, { 1812, 1.3623, 0.000E+00, 0.000E+00, 0.000E+00, 8.787E+00, 6.192E+00, 1.620E-02, 3.400E-03, 5.086E-01, 1.537E-01 }, { 1813, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 8.790E+00, 6.179E+00, 1.480E-02, 3.100E-03, 5.082E-01, 1.537E-01 }, { 1814, 1.3628, 0.000E+00, 0.000E+00, 0.000E+00, 8.798E+00, 6.159E+00, 1.340E-02, 2.800E-03, 5.078E-01, 1.537E-01 }, { 1815, 1.3634, 0.000E+00, 0.000E+00, 0.000E+00, 8.794E+00, 6.143E+00, 1.200E-02, 2.500E-03, 5.074E-01, 1.537E-01 }, { 1816, 1.3638, 0.000E+00, 0.000E+00, 0.000E+00, 8.811E+00, 6.143E+00, 1.060E-02, 2.200E-03, 5.073E-01, 1.536E-01 }, { 1817, 1.3645, 0.000E+00, 0.000E+00, 0.000E+00, 8.820E+00, 6.120E+00, 9.200E-03, 1.900E-03, 5.072E-01, 1.535E-01 }, { 1818, 1.3649, 0.000E+00, 0.000E+00, 0.000E+00, 8.836E+00, 6.098E+00, 7.800E-03, 1.600E-03, 5.071E-01, 1.534E-01 }, { 1819, 1.3652, 0.000E+00, 0.000E+00, 0.000E+00, 8.845E+00, 6.087E+00, 6.400E-03, 1.300E-03, 5.070E-01, 1.534E-01 }, { 1820, 1.3652, 0.000E+00, 0.000E+00, 0.000E+00, 8.854E+00, 6.063E+00, 5.000E-03, 1.000E-03, 5.069E-01, 1.533E-01 }, { 1821, 1.3650, 0.000E+00, 0.000E+00, 0.000E+00, 8.858E+00, 6.056E+00, 4.900E-03, 1.000E-03, 5.071E-01, 1.533E-01 }, { 1822, 1.3645, 0.000E+00, 0.000E+00, 0.000E+00, 8.868E+00, 6.053E+00, 4.800E-03, 1.000E-03, 5.074E-01, 1.533E-01 }, { 1823, 1.3642, 0.000E+00, 0.000E+00, 0.000E+00, 8.869E+00, 6.040E+00, 4.700E-03, 1.000E-03, 5.076E-01, 1.533E-01 }, { 1824, 1.3639, 0.000E+00, 0.000E+00, 0.000E+00, 8.884E+00, 6.044E+00, 4.600E-03, 1.000E-03, 5.079E-01, 1.533E-01 }, { 1825, 1.3638, 0.000E+00, 0.000E+00, 0.000E+00, 8.888E+00, 6.007E+00, 4.500E-03, 1.000E-03, 5.082E-01, 1.533E-01 }, { 1826, 1.3636, 0.000E+00, 0.000E+00, 0.000E+00, 8.900E+00, 5.996E+00, 4.400E-03, 1.000E-03, 5.081E-01, 1.531E-01 }, { 1827, 1.3634, 0.000E+00, 0.000E+00, 0.000E+00, 8.922E+00, 5.994E+00, 4.300E-03, 1.000E-03, 5.081E-01, 1.528E-01 }, { 1828, 1.3631, 0.000E+00, 0.000E+00, 0.000E+00, 8.951E+00, 5.997E+00, 4.200E-03, 1.000E-03, 5.080E-01, 1.526E-01 }, { 1829, 1.3632, 0.000E+00, 0.000E+00, 0.000E+00, 8.973E+00, 5.975E+00, 4.100E-03, 1.000E-03, 5.080E-01, 1.524E-01 }, { 1830, 1.3631, 0.000E+00, 0.000E+00, 0.000E+00, 9.010E+00, 5.954E+00, 4.000E-03, 1.000E-03, 5.079E-01, 1.522E-01 }, { 1831, 1.3630, 0.000E+00, 0.000E+00, 0.000E+00, 9.034E+00, 5.946E+00, 3.900E-03, 1.000E-03, 5.076E-01, 1.519E-01 }, { 1832, 1.3624, 0.000E+00, 0.000E+00, 0.000E+00, 9.110E+00, 5.927E+00, 3.800E-03, 1.000E-03, 5.073E-01, 1.517E-01 }, { 1833, 1.3623, 0.000E+00, 0.000E+00, 0.000E+00, 9.146E+00, 5.914E+00, 3.700E-03, 1.000E-03, 5.070E-01, 1.515E-01 }, { 1834, 1.3623, 0.000E+00, 0.000E+00, 0.000E+00, 9.195E+00, 5.890E+00, 3.600E-03, 1.000E-03, 5.067E-01, 1.512E-01 }, { 1835, 1.3623, 0.000E+00, 0.000E+00, 0.000E+00, 9.259E+00, 5.873E+00, 3.500E-03, 1.000E-03, 5.064E-01, 1.510E-01 }, { 1836, 1.3626, 0.000E+00, 0.000E+00, 0.000E+00, 9.315E+00, 5.832E+00, 3.400E-03, 1.000E-03, 5.066E-01, 1.504E-01 }, { 1837, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 9.380E+00, 5.794E+00, 3.300E-03, 1.000E-03, 5.069E-01, 1.497E-01 }, { 1838, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 9.457E+00, 5.768E+00, 3.200E-03, 1.000E-03, 5.071E-01, 1.491E-01 }, { 1839, 1.3630, 0.000E+00, 0.000E+00, 0.000E+00, 9.535E+00, 5.728E+00, 3.100E-03, 1.000E-03, 5.073E-01, 1.484E-01 }, { 1840, 1.3628, 0.000E+00, 0.000E+00, 0.000E+00, 9.633E+00, 5.681E+00, 3.000E-03, 1.000E-03, 5.076E-01, 1.478E-01 }, { 1841, 1.3622, 0.000E+00, 0.000E+00, 0.000E+00, 9.723E+00, 5.680E+00, 2.900E-03, 9.500E-04, 5.079E-01, 1.473E-01 }, { 1842, 1.3615, 0.000E+00, 0.000E+00, 0.000E+00, 9.824E+00, 5.655E+00, 2.800E-03, 9.000E-04, 5.083E-01, 1.468E-01 }, { 1843, 1.3607, 0.000E+00, 0.000E+00, 0.000E+00, 9.935E+00, 5.648E+00, 2.700E-03, 8.500E-04, 5.087E-01, 1.463E-01 }, { 1844, 1.3601, 0.000E+00, 0.000E+00, 0.000E+00, 1.005E+01, 5.620E+00, 2.600E-03, 8.000E-04, 5.091E-01, 1.458E-01 }, { 1845, 1.3597, 0.000E+00, 0.000E+00, 0.000E+00, 1.018E+01, 5.594E+00, 2.500E-03, 7.500E-04, 5.095E-01, 1.453E-01 }, { 1846, 1.3597, 0.000E+00, 0.000E+00, 0.000E+00, 1.031E+01, 5.567E+00, 2.400E-03, 7.000E-04, 5.097E-01, 1.441E-01 }, { 1847, 1.3599, 0.000E+00, 0.000E+00, 0.000E+00, 1.042E+01, 5.557E+00, 2.300E-03, 6.500E-04, 5.100E-01, 1.429E-01 }, { 1848, 1.3597, 0.000E+00, 0.000E+00, 0.000E+00, 1.059E+01, 5.552E+00, 2.200E-03, 6.000E-04, 5.103E-01, 1.417E-01 }, { 1849, 1.3597, 0.000E+00, 0.000E+00, 0.000E+00, 1.075E+01, 5.553E+00, 2.100E-03, 5.500E-04, 5.105E-01, 1.404E-01 }, { 1850, 1.3595, 0.000E+00, 0.000E+00, 0.000E+00, 1.094E+01, 5.539E+00, 2.000E-03, 5.000E-04, 5.108E-01, 1.392E-01 }, { 1851, 1.3599, 0.000E+00, 0.000E+00, 0.000E+00, 1.110E+01, 5.523E+00, 1.900E-03, 4.500E-04, 5.110E-01, 1.384E-01 }, { 1852, 1.3593, 0.000E+00, 0.000E+00, 0.000E+00, 1.139E+01, 5.507E+00, 1.800E-03, 4.000E-04, 5.112E-01, 1.375E-01 }, { 1853, 1.3597, 0.000E+00, 0.000E+00, 0.000E+00, 1.160E+01, 5.505E+00, 1.700E-03, 3.500E-04, 5.115E-01, 1.366E-01 }, { 1854, 1.3602, 0.000E+00, 0.000E+00, 0.000E+00, 1.184E+01, 5.487E+00, 1.600E-03, 3.000E-04, 5.117E-01, 1.358E-01 }, { 1855, 1.3613, 0.000E+00, 0.000E+00, 0.000E+00, 1.208E+01, 5.474E+00, 1.500E-03, 2.500E-04, 5.119E-01, 1.349E-01 }, { 1856, 1.3625, 0.000E+00, 0.000E+00, 0.000E+00, 1.235E+01, 5.462E+00, 1.400E-03, 2.000E-04, 5.122E-01, 1.341E-01 }, { 1857, 1.3633, 0.000E+00, 0.000E+00, 0.000E+00, 1.266E+01, 5.450E+00, 1.300E-03, 1.500E-04, 5.125E-01, 1.332E-01 }, { 1858, 1.3638, 0.000E+00, 0.000E+00, 0.000E+00, 1.301E+01, 5.448E+00, 1.200E-03, 1.000E-04, 5.128E-01, 1.323E-01 }, { 1859, 1.3645, 0.000E+00, 0.000E+00, 0.000E+00, 1.334E+01, 5.441E+00, 1.100E-03, 5.000E-05, 5.131E-01, 1.315E-01 }, { 1860, 1.3643, 0.000E+00, 0.000E+00, 0.000E+00, 1.375E+01, 5.440E+00, 1.000E-03, 1.000E-04, 5.134E-01, 1.306E-01 }, { 1861, 1.3648, 0.000E+00, 0.000E+00, 0.000E+00, 1.412E+01, 5.442E+00, 1.900E-03, 2.000E-04, 5.138E-01, 1.287E-01 }, { 1862, 1.3629, 0.000E+00, 0.000E+00, 0.000E+00, 1.478E+01, 5.449E+00, 2.800E-03, 4.000E-04, 5.142E-01, 1.269E-01 }, { 1863, 1.3632, 0.000E+00, 0.000E+00, 0.000E+00, 1.529E+01, 5.466E+00, 3.700E-03, 6.000E-04, 5.147E-01, 1.250E-01 }, { 1864, 1.3635, 0.000E+00, 0.000E+00, 0.000E+00, 1.586E+01, 5.461E+00, 4.600E-03, 8.000E-04, 5.151E-01, 1.231E-01 }, { 1865, 1.3645, 0.000E+00, 0.000E+00, 0.000E+00, 1.641E+01, 5.452E+00, 5.500E-03, 1.000E-03, 5.155E-01, 1.212E-01 }, { 1866, 1.3647, 0.000E+00, 0.000E+00, 0.000E+00, 1.709E+01, 5.445E+00, 6.400E-03, 1.200E-03, 5.153E-01, 1.192E-01 }, { 1867, 1.3662, 0.000E+00, 0.000E+00, 0.000E+00, 1.774E+01, 5.412E+00, 7.300E-03, 1.400E-03, 5.152E-01, 1.171E-01 }, { 1868, 1.3668, 0.000E+00, 0.000E+00, 0.000E+00, 1.853E+01, 5.379E+00, 8.200E-03, 1.600E-03, 5.150E-01, 1.151E-01 }, { 1869, 1.3684, 0.000E+00, 0.000E+00, 0.000E+00, 1.925E+01, 5.280E+00, 9.100E-03, 1.800E-03, 5.148E-01, 1.131E-01 }, { 1870, 1.3653, 0.000E+00, 0.000E+00, 0.000E+00, 2.051E+01, 5.228E+00, 1.000E-02, 2.000E-03, 5.146E-01, 1.111E-01 }, { 1871, 1.3658, 0.000E+00, 0.000E+00, 0.000E+00, 2.148E+01, 5.199E+00, 1.090E-02, 2.200E-03, 5.142E-01, 1.077E-01 }, { 1872, 1.3663, 0.000E+00, 0.000E+00, 0.000E+00, 2.250E+01, 5.171E+00, 1.180E-02, 2.400E-03, 5.137E-01, 1.044E-01 }, { 1873, 1.3663, 0.000E+00, 0.000E+00, 0.000E+00, 2.367E+01, 5.139E+00, 1.270E-02, 2.600E-03, 5.133E-01, 1.010E-01 }, { 1874, 1.3671, 0.000E+00, 0.000E+00, 0.000E+00, 2.483E+01, 5.124E+00, 1.360E-02, 2.800E-03, 5.128E-01, 9.765E-02 }, { 1875, 1.3668, 0.000E+00, 0.000E+00, 0.000E+00, 2.622E+01, 5.112E+00, 1.450E-02, 3.000E-03, 5.124E-01, 9.430E-02 }, { 1876, 1.3680, 0.000E+00, 0.000E+00, 0.000E+00, 2.751E+01, 5.129E+00, 1.540E-02, 3.200E-03, 5.102E-01, 9.322E-02 }, { 1877, 1.3626, 0.000E+00, 0.000E+00, 0.000E+00, 2.972E+01, 5.144E+00, 1.630E-02, 3.400E-03, 5.081E-01, 9.214E-02 }, { 1878, 1.3620, 0.000E+00, 0.000E+00, 0.000E+00, 3.144E+01, 5.173E+00, 1.720E-02, 3.600E-03, 5.059E-01, 9.106E-02 }, { 1879, 1.3624, 0.000E+00, 0.000E+00, 0.000E+00, 3.317E+01, 5.176E+00, 1.810E-02, 3.800E-03, 5.037E-01, 8.998E-02 }, { 1880, 1.3627, 0.000E+00, 0.000E+00, 0.000E+00, 3.504E+01, 5.185E+00, 1.900E-02, 4.000E-03, 5.016E-01, 8.890E-02 }, { 1881, 1.3617, 0.000E+00, 0.000E+00, 0.000E+00, 3.725E+01, 5.183E+00, 1.810E-02, 3.800E-03, 5.016E-01, 8.870E-02 }, { 1882, 1.3628, 0.000E+00, 0.000E+00, 0.000E+00, 3.927E+01, 5.200E+00, 1.720E-02, 3.600E-03, 5.016E-01, 8.850E-02 }, { 1883, 1.3562, 0.000E+00, 0.000E+00, 0.000E+00, 4.269E+01, 5.202E+00, 1.630E-02, 3.400E-03, 5.015E-01, 8.829E-02 }, { 1884, 1.3557, 0.000E+00, 0.000E+00, 0.000E+00, 4.530E+01, 5.204E+00, 1.540E-02, 3.200E-03, 5.015E-01, 8.809E-02 }, { 1885, 1.3558, 0.000E+00, 0.000E+00, 0.000E+00, 4.789E+01, 5.224E+00, 1.450E-02, 3.000E-03, 5.015E-01, 8.789E-02 }, { 1886, 1.3559, 0.000E+00, 0.000E+00, 0.000E+00, 5.060E+01, 5.244E+00, 1.360E-02, 2.800E-03, 5.019E-01, 8.823E-02 }, { 1887, 1.3555, 0.000E+00, 0.000E+00, 0.000E+00, 5.360E+01, 5.297E+00, 1.270E-02, 2.600E-03, 5.023E-01, 8.857E-02 }, { 1888, 1.3508, 0.000E+00, 0.000E+00, 0.000E+00, 5.761E+01, 5.318E+00, 1.180E-02, 2.400E-03, 5.026E-01, 8.891E-02 }, { 1889, 1.3504, 0.000E+00, 0.000E+00, 0.000E+00, 6.088E+01, 5.375E+00, 1.090E-02, 2.200E-03, 5.030E-01, 8.924E-02 }, { 1890, 1.3511, 0.000E+00, 0.000E+00, 0.000E+00, 6.401E+01, 5.441E+00, 1.000E-02, 2.000E-03, 5.034E-01, 8.958E-02 }, { 1891, 1.3520, 0.000E+00, 0.000E+00, 0.000E+00, 6.720E+01, 5.491E+00, 9.100E-03, 1.800E-03, 5.038E-01, 9.038E-02 }, { 1892, 1.3525, 0.000E+00, 0.000E+00, 0.000E+00, 7.059E+01, 5.561E+00, 8.200E-03, 1.600E-03, 5.042E-01, 9.118E-02 }, { 1893, 1.3493, 0.000E+00, 0.000E+00, 0.000E+00, 7.497E+01, 5.629E+00, 7.300E-03, 1.400E-03, 5.046E-01, 9.198E-02 }, { 1894, 1.3503, 0.000E+00, 0.000E+00, 0.000E+00, 7.841E+01, 5.687E+00, 6.400E-03, 1.200E-03, 5.050E-01, 9.278E-02 }, { 1895, 1.3524, 0.000E+00, 0.000E+00, 0.000E+00, 8.157E+01, 5.757E+00, 5.500E-03, 1.000E-03, 5.055E-01, 9.358E-02 }, { 1896, 1.3546, 0.000E+00, 0.000E+00, 0.000E+00, 8.469E+01, 5.830E+00, 4.600E-03, 8.000E-04, 5.061E-01, 9.411E-02 }, { 1897, 1.3578, 0.000E+00, 0.000E+00, 0.000E+00, 8.752E+01, 5.911E+00, 3.700E-03, 6.000E-04, 5.067E-01, 9.464E-02 }, { 1898, 1.3556, 0.000E+00, 0.000E+00, 0.000E+00, 9.189E+01, 5.998E+00, 2.800E-03, 4.000E-04, 5.073E-01, 9.518E-02 }, { 1899, 1.3583, 0.000E+00, 0.000E+00, 0.000E+00, 9.456E+01, 6.090E+00, 1.900E-03, 2.000E-04, 5.080E-01, 9.571E-02 }, { 1900, 1.3601, 0.000E+00, 0.000E+00, 0.000E+00, 9.722E+01, 6.193E+00, 1.000E-03, 0.000E+00, 5.086E-01, 9.624E-02 }, { 1901, 1.3610, 0.000E+00, 0.000E+00, 0.000E+00, 9.995E+01, 6.330E+00, 1.000E-03, 0.000E+00, 5.086E-01, 9.694E-02 }, { 1902, 1.3595, 0.000E+00, 0.000E+00, 0.000E+00, 1.033E+02, 6.449E+00, 1.000E-03, 0.000E+00, 5.086E-01, 9.765E-02 }, { 1903, 1.3599, 0.000E+00, 0.000E+00, 0.000E+00, 1.057E+02, 6.581E+00, 1.000E-03, 0.000E+00, 5.085E-01, 9.835E-02 }, { 1904, 1.3606, 0.000E+00, 0.000E+00, 0.000E+00, 1.078E+02, 6.710E+00, 1.000E-03, 0.000E+00, 5.085E-01, 9.905E-02 }, { 1905, 1.3611, 0.000E+00, 0.000E+00, 0.000E+00, 1.097E+02, 6.838E+00, 1.000E-03, 0.000E+00, 5.085E-01, 9.975E-02 }, { 1906, 1.3598, 0.000E+00, 0.000E+00, 0.000E+00, 1.123E+02, 6.970E+00, 1.000E-03, 0.000E+00, 5.081E-01, 9.931E-02 }, { 1907, 1.3600, 0.000E+00, 0.000E+00, 0.000E+00, 1.140E+02, 7.107E+00, 1.000E-03, 0.000E+00, 5.076E-01, 9.886E-02 }, { 1908, 1.3601, 0.000E+00, 0.000E+00, 0.000E+00, 1.157E+02, 7.238E+00, 1.000E-03, 0.000E+00, 5.072E-01, 9.842E-02 }, { 1909, 1.3606, 0.000E+00, 0.000E+00, 0.000E+00, 1.171E+02, 7.388E+00, 1.000E-03, 0.000E+00, 5.068E-01, 9.797E-02 }, { 1910, 1.3599, 0.000E+00, 0.000E+00, 0.000E+00, 1.190E+02, 7.506E+00, 1.000E-03, 0.000E+00, 5.064E-01, 9.752E-02 }, { 1911, 1.3600, 0.000E+00, 0.000E+00, 0.000E+00, 1.203E+02, 7.635E+00, 1.000E-03, 0.000E+00, 5.059E-01, 9.511E-02 }, { 1912, 1.3603, 0.000E+00, 0.000E+00, 0.000E+00, 1.215E+02, 7.767E+00, 1.000E-03, 0.000E+00, 5.055E-01, 9.269E-02 }, { 1913, 1.3608, 0.000E+00, 0.000E+00, 0.000E+00, 1.226E+02, 7.874E+00, 1.000E-03, 0.000E+00, 5.051E-01, 9.027E-02 }, { 1914, 1.3606, 0.000E+00, 0.000E+00, 0.000E+00, 1.240E+02, 7.977E+00, 1.000E-03, 0.000E+00, 5.047E-01, 8.786E-02 }, { 1915, 1.3613, 0.000E+00, 0.000E+00, 0.000E+00, 1.248E+02, 8.071E+00, 1.000E-03, 0.000E+00, 5.042E-01, 8.544E-02 }, { 1916, 1.3615, 0.000E+00, 0.000E+00, 0.000E+00, 1.257E+02, 8.150E+00, 1.000E-03, 0.000E+00, 5.038E-01, 8.363E-02 }, { 1917, 1.3614, 0.000E+00, 0.000E+00, 0.000E+00, 1.265E+02, 8.220E+00, 1.000E-03, 0.000E+00, 5.034E-01, 8.182E-02 }, { 1918, 1.3606, 0.000E+00, 0.000E+00, 0.000E+00, 1.275E+02, 8.292E+00, 1.000E-03, 0.000E+00, 5.030E-01, 8.002E-02 }, { 1919, 1.3600, 0.000E+00, 0.000E+00, 0.000E+00, 1.281E+02, 8.350E+00, 1.000E-03, 0.000E+00, 5.027E-01, 7.821E-02 }, { 1920, 1.3591, 0.000E+00, 0.000E+00, 0.000E+00, 1.286E+02, 8.449E+00, 1.000E-03, 0.000E+00, 5.023E-01, 7.640E-02 }, { 1921, 1.3582, 0.000E+00, 0.000E+00, 0.000E+00, 1.292E+02, 8.521E+00, 1.250E-03, 5.000E-05, 5.019E-01, 7.433E-02 }, { 1922, 1.3573, 0.000E+00, 0.000E+00, 0.000E+00, 1.296E+02, 8.583E+00, 1.500E-03, 1.000E-04, 5.015E-01, 7.226E-02 }, { 1923, 1.3564, 0.000E+00, 0.000E+00, 0.000E+00, 1.299E+02, 8.666E+00, 1.750E-03, 1.500E-04, 5.011E-01, 7.020E-02 }, { 1924, 1.3556, 0.000E+00, 0.000E+00, 0.000E+00, 1.303E+02, 8.723E+00, 2.000E-03, 2.000E-04, 5.007E-01, 6.813E-02 }, { 1925, 1.3547, 0.000E+00, 0.000E+00, 0.000E+00, 1.304E+02, 8.759E+00, 2.250E-03, 2.500E-04, 5.003E-01, 6.606E-02 }, { 1926, 1.3538, 0.000E+00, 0.000E+00, 0.000E+00, 1.306E+02, 8.821E+00, 2.500E-03, 3.000E-04, 5.003E-01, 6.446E-02 }, { 1927, 1.3530, 0.000E+00, 0.000E+00, 0.000E+00, 1.306E+02, 8.864E+00, 2.750E-03, 3.500E-04, 5.003E-01, 6.285E-02 }, { 1928, 1.3522, 0.000E+00, 0.000E+00, 0.000E+00, 1.306E+02, 8.909E+00, 3.000E-03, 4.000E-04, 5.003E-01, 6.124E-02 }, { 1929, 1.3513, 0.000E+00, 0.000E+00, 0.000E+00, 1.305E+02, 8.941E+00, 3.250E-03, 4.500E-04, 5.003E-01, 5.963E-02 }, { 1930, 1.3505, 0.000E+00, 0.000E+00, 0.000E+00, 1.304E+02, 8.949E+00, 3.500E-03, 5.000E-04, 5.003E-01, 5.802E-02 }, { 1931, 1.3497, 0.000E+00, 0.000E+00, 0.000E+00, 1.301E+02, 8.955E+00, 3.750E-03, 5.500E-04, 4.992E-01, 5.701E-02 }, { 1932, 1.3489, 0.000E+00, 0.000E+00, 0.000E+00, 1.299E+02, 8.983E+00, 4.000E-03, 6.000E-04, 4.980E-01, 5.600E-02 }, { 1933, 1.3481, 0.000E+00, 0.000E+00, 0.000E+00, 1.296E+02, 9.022E+00, 4.250E-03, 6.500E-04, 4.969E-01, 5.499E-02 }, { 1934, 1.3473, 0.000E+00, 0.000E+00, 0.000E+00, 1.291E+02, 9.043E+00, 4.500E-03, 7.000E-04, 4.958E-01, 5.398E-02 }, { 1935, 1.3465, 0.000E+00, 0.000E+00, 0.000E+00, 1.287E+02, 9.044E+00, 4.750E-03, 7.500E-04, 4.946E-01, 5.297E-02 }, { 1936, 1.3457, 0.000E+00, 0.000E+00, 0.000E+00, 1.282E+02, 9.028E+00, 5.000E-03, 8.000E-04, 4.943E-01, 5.225E-02 }, { 1937, 1.3450, 0.000E+00, 0.000E+00, 0.000E+00, 1.275E+02, 9.034E+00, 5.250E-03, 8.500E-04, 4.939E-01, 5.154E-02 }, { 1938, 1.3442, 0.000E+00, 0.000E+00, 0.000E+00, 1.270E+02, 9.052E+00, 5.500E-03, 9.000E-04, 4.935E-01, 5.083E-02 }, { 1939, 1.3434, 0.000E+00, 0.000E+00, 0.000E+00, 1.264E+02, 9.048E+00, 5.750E-03, 9.500E-04, 4.931E-01, 5.011E-02 }, { 1940, 1.3427, 0.000E+00, 0.000E+00, 0.000E+00, 1.256E+02, 9.041E+00, 6.000E-03, 1.000E-03, 4.927E-01, 4.940E-02 }, { 1941, 1.3420, 0.000E+00, 0.000E+00, 0.000E+00, 1.249E+02, 9.037E+00, 7.100E-03, 1.200E-03, 4.924E-01, 4.883E-02 }, { 1942, 1.3412, 0.000E+00, 0.000E+00, 0.000E+00, 1.242E+02, 9.036E+00, 8.200E-03, 1.400E-03, 4.920E-01, 4.826E-02 }, { 1943, 1.3405, 0.000E+00, 0.000E+00, 0.000E+00, 1.232E+02, 9.035E+00, 9.300E-03, 1.600E-03, 4.916E-01, 4.769E-02 }, { 1944, 1.3398, 0.000E+00, 0.000E+00, 0.000E+00, 1.224E+02, 9.021E+00, 1.040E-02, 1.800E-03, 4.912E-01, 4.712E-02 }, { 1945, 1.3391, 0.000E+00, 0.000E+00, 0.000E+00, 1.216E+02, 9.016E+00, 1.150E-02, 2.000E-03, 4.908E-01, 4.655E-02 }, { 1946, 1.3384, 0.000E+00, 0.000E+00, 0.000E+00, 1.206E+02, 9.008E+00, 1.260E-02, 2.200E-03, 4.907E-01, 4.626E-02 }, { 1947, 1.3377, 0.000E+00, 0.000E+00, 0.000E+00, 1.197E+02, 8.970E+00, 1.370E-02, 2.400E-03, 4.905E-01, 4.597E-02 }, { 1948, 1.3371, 0.000E+00, 0.000E+00, 0.000E+00, 1.190E+02, 8.974E+00, 1.480E-02, 2.600E-03, 4.904E-01, 4.567E-02 }, { 1949, 1.3364, 0.000E+00, 0.000E+00, 0.000E+00, 1.178E+02, 8.953E+00, 1.590E-02, 2.800E-03, 4.902E-01, 4.538E-02 }, { 1950, 1.3357, 0.000E+00, 0.000E+00, 0.000E+00, 1.170E+02, 8.957E+00, 1.700E-02, 3.000E-03, 4.901E-01, 4.508E-02 }, { 1951, 1.3351, 0.000E+00, 0.000E+00, 0.000E+00, 1.157E+02, 8.937E+00, 1.810E-02, 3.200E-03, 4.902E-01, 4.508E-02 }, { 1952, 1.3344, 0.000E+00, 0.000E+00, 0.000E+00, 1.149E+02, 8.923E+00, 1.920E-02, 3.400E-03, 4.903E-01, 4.508E-02 }, { 1953, 1.3338, 0.000E+00, 0.000E+00, 0.000E+00, 1.140E+02, 8.912E+00, 2.030E-02, 3.600E-03, 4.904E-01, 4.508E-02 }, { 1954, 1.3332, 0.000E+00, 0.000E+00, 0.000E+00, 1.128E+02, 8.895E+00, 2.140E-02, 3.800E-03, 4.905E-01, 4.507E-02 }, { 1955, 1.3326, 0.000E+00, 0.000E+00, 0.000E+00, 1.118E+02, 8.891E+00, 2.250E-02, 4.000E-03, 4.906E-01, 4.507E-02 }, { 1956, 1.3320, 0.000E+00, 0.000E+00, 0.000E+00, 1.110E+02, 8.880E+00, 2.360E-02, 4.200E-03, 4.905E-01, 4.529E-02 }, { 1957, 1.3314, 0.000E+00, 0.000E+00, 0.000E+00, 1.097E+02, 8.867E+00, 2.470E-02, 4.400E-03, 4.904E-01, 4.550E-02 }, { 1958, 1.3308, 0.000E+00, 0.000E+00, 0.000E+00, 1.088E+02, 8.855E+00, 2.580E-02, 4.600E-03, 4.902E-01, 4.572E-02 }, { 1959, 1.3302, 0.000E+00, 0.000E+00, 0.000E+00, 1.076E+02, 8.852E+00, 2.690E-02, 4.800E-03, 4.901E-01, 4.594E-02 }, { 1960, 1.3297, 0.000E+00, 0.000E+00, 0.000E+00, 1.066E+02, 8.861E+00, 2.800E-02, 5.000E-03, 4.900E-01, 4.615E-02 }, { 1961, 1.3291, 0.000E+00, 0.000E+00, 0.000E+00, 1.058E+02, 8.864E+00, 3.150E-02, 5.650E-03, 4.900E-01, 4.615E-02 }, { 1962, 1.3286, 0.000E+00, 0.000E+00, 0.000E+00, 1.044E+02, 8.876E+00, 3.500E-02, 6.300E-03, 4.900E-01, 4.615E-02 }, { 1963, 1.3280, 0.000E+00, 0.000E+00, 0.000E+00, 1.036E+02, 8.869E+00, 3.850E-02, 6.950E-03, 4.900E-01, 4.615E-02 }, { 1964, 1.3275, 0.000E+00, 0.000E+00, 0.000E+00, 1.023E+02, 8.872E+00, 4.200E-02, 7.600E-03, 4.900E-01, 4.614E-02 }, { 1965, 1.3270, 0.000E+00, 0.000E+00, 0.000E+00, 1.014E+02, 8.855E+00, 4.550E-02, 8.250E-03, 4.900E-01, 4.614E-02 }, { 1966, 1.3265, 0.000E+00, 0.000E+00, 0.000E+00, 1.005E+02, 8.828E+00, 4.900E-02, 8.900E-03, 4.902E-01, 4.614E-02 }, { 1967, 1.3260, 0.000E+00, 0.000E+00, 0.000E+00, 9.928E+01, 8.839E+00, 5.250E-02, 9.550E-03, 4.904E-01, 4.614E-02 }, { 1968, 1.3255, 0.000E+00, 0.000E+00, 0.000E+00, 9.831E+01, 8.855E+00, 5.600E-02, 1.020E-02, 4.906E-01, 4.613E-02 }, { 1969, 1.3251, 0.000E+00, 0.000E+00, 0.000E+00, 9.711E+01, 8.856E+00, 5.950E-02, 1.085E-02, 4.907E-01, 4.613E-02 }, { 1970, 1.3246, 0.000E+00, 0.000E+00, 0.000E+00, 9.631E+01, 8.833E+00, 6.300E-02, 1.150E-02, 4.909E-01, 4.613E-02 }, { 1971, 1.3242, 0.000E+00, 0.000E+00, 0.000E+00, 9.488E+01, 8.842E+00, 6.650E-02, 1.215E-02, 4.911E-01, 4.613E-02 }, { 1972, 1.3237, 0.000E+00, 0.000E+00, 0.000E+00, 9.412E+01, 8.843E+00, 7.000E-02, 1.280E-02, 4.913E-01, 4.612E-02 }, { 1973, 1.3233, 0.000E+00, 0.000E+00, 0.000E+00, 9.341E+01, 8.830E+00, 7.350E-02, 1.345E-02, 4.914E-01, 4.612E-02 }, { 1974, 1.3229, 0.000E+00, 0.000E+00, 0.000E+00, 9.206E+01, 8.808E+00, 7.700E-02, 1.410E-02, 4.916E-01, 4.612E-02 }, { 1975, 1.3225, 0.000E+00, 0.000E+00, 0.000E+00, 9.121E+01, 8.818E+00, 8.050E-02, 1.475E-02, 4.918E-01, 4.612E-02 }, { 1976, 1.3221, 0.000E+00, 0.000E+00, 0.000E+00, 9.009E+01, 8.807E+00, 8.400E-02, 1.540E-02, 4.930E-01, 4.626E-02 }, { 1977, 1.3217, 0.000E+00, 0.000E+00, 0.000E+00, 8.929E+01, 8.797E+00, 8.750E-02, 1.605E-02, 4.941E-01, 4.640E-02 }, { 1978, 1.3213, 0.000E+00, 0.000E+00, 0.000E+00, 8.804E+01, 8.794E+00, 9.100E-02, 1.670E-02, 4.953E-01, 4.655E-02 }, { 1979, 1.3209, 0.000E+00, 0.000E+00, 0.000E+00, 8.725E+01, 8.791E+00, 9.450E-02, 1.735E-02, 4.964E-01, 4.669E-02 }, { 1980, 1.3206, 0.000E+00, 0.000E+00, 0.000E+00, 8.611E+01, 8.795E+00, 9.800E-02, 1.800E-02, 4.976E-01, 4.683E-02 }, { 1981, 1.3203, 0.000E+00, 0.000E+00, 0.000E+00, 8.532E+01, 8.771E+00, 9.720E-02, 1.785E-02, 4.976E-01, 4.731E-02 }, { 1982, 1.3199, 0.000E+00, 0.000E+00, 0.000E+00, 8.460E+01, 8.754E+00, 9.640E-02, 1.770E-02, 4.976E-01, 4.779E-02 }, { 1983, 1.3196, 0.000E+00, 0.000E+00, 0.000E+00, 8.336E+01, 8.759E+00, 9.560E-02, 1.755E-02, 4.976E-01, 4.827E-02 }, { 1984, 1.3193, 0.000E+00, 0.000E+00, 0.000E+00, 8.262E+01, 8.760E+00, 9.480E-02, 1.740E-02, 4.976E-01, 4.875E-02 }, { 1985, 1.3190, 0.000E+00, 0.000E+00, 0.000E+00, 8.151E+01, 8.746E+00, 9.400E-02, 1.725E-02, 4.977E-01, 4.922E-02 }, { 1986, 1.3187, 0.000E+00, 0.000E+00, 0.000E+00, 8.076E+01, 8.762E+00, 9.320E-02, 1.710E-02, 4.977E-01, 4.965E-02 }, { 1987, 1.3185, 0.000E+00, 0.000E+00, 0.000E+00, 7.973E+01, 8.778E+00, 9.240E-02, 1.695E-02, 4.977E-01, 5.009E-02 }, { 1988, 1.3182, 0.000E+00, 0.000E+00, 0.000E+00, 7.904E+01, 8.790E+00, 9.160E-02, 1.680E-02, 4.977E-01, 5.052E-02 }, { 1989, 1.3180, 0.000E+00, 0.000E+00, 0.000E+00, 7.800E+01, 8.795E+00, 9.080E-02, 1.665E-02, 4.977E-01, 5.095E-02 }, { 1990, 1.3177, 0.000E+00, 0.000E+00, 0.000E+00, 7.723E+01, 8.811E+00, 9.000E-02, 1.650E-02, 4.977E-01, 5.138E-02 }, { 1991, 1.3175, 0.000E+00, 0.000E+00, 0.000E+00, 7.628E+01, 8.848E+00, 8.920E-02, 1.635E-02, 4.977E-01, 5.192E-02 }, { 1992, 1.3173, 0.000E+00, 0.000E+00, 0.000E+00, 7.557E+01, 8.874E+00, 8.840E-02, 1.620E-02, 4.978E-01, 5.246E-02 }, { 1993, 1.3171, 0.000E+00, 0.000E+00, 0.000E+00, 7.463E+01, 8.885E+00, 8.760E-02, 1.605E-02, 4.978E-01, 5.299E-02 }, { 1994, 1.3169, 0.000E+00, 0.000E+00, 0.000E+00, 7.392E+01, 8.913E+00, 8.680E-02, 1.590E-02, 4.978E-01, 5.353E-02 }, { 1995, 1.3168, 0.000E+00, 0.000E+00, 0.000E+00, 7.298E+01, 8.944E+00, 8.600E-02, 1.575E-02, 4.978E-01, 5.407E-02 }, { 1996, 1.3166, 0.000E+00, 0.000E+00, 0.000E+00, 7.234E+01, 8.980E+00, 8.520E-02, 1.560E-02, 4.978E-01, 5.463E-02 }, { 1997, 1.3165, 0.000E+00, 0.000E+00, 0.000E+00, 7.141E+01, 8.988E+00, 8.440E-02, 1.545E-02, 4.978E-01, 5.518E-02 }, { 1998, 1.3163, 0.000E+00, 0.000E+00, 0.000E+00, 7.082E+01, 9.001E+00, 8.360E-02, 1.530E-02, 4.978E-01, 5.574E-02 }, { 1999, 1.3162, 0.000E+00, 0.000E+00, 0.000E+00, 6.986E+01, 9.034E+00, 8.280E-02, 1.515E-02, 4.978E-01, 5.630E-02 }, { 2000, 1.3161, 0.000E+00, 0.000E+00, 0.000E+00, 6.924E+01, 9.076E+00, 8.200E-02, 1.500E-02, 4.979E-01, 5.685E-02 }, { 2001, 1.3160, 0.000E+00, 0.000E+00, 0.000E+00, 6.865E+01, 9.111E+00, 8.015E-02, 1.465E-02, 4.981E-01, 5.702E-02 }, { 2002, 1.3159, 0.000E+00, 0.000E+00, 0.000E+00, 6.779E+01, 9.141E+00, 7.830E-02, 1.430E-02, 4.983E-01, 5.720E-02 }, { 2003, 1.3159, 0.000E+00, 0.000E+00, 0.000E+00, 6.688E+01, 9.171E+00, 7.645E-02, 1.395E-02, 4.985E-01, 5.737E-02 }, { 2004, 1.3158, 0.000E+00, 0.000E+00, 0.000E+00, 6.634E+01, 9.214E+00, 7.460E-02, 1.360E-02, 4.986E-01, 5.754E-02 }, { 2005, 1.3157, 0.000E+00, 0.000E+00, 0.000E+00, 6.548E+01, 9.255E+00, 7.275E-02, 1.325E-02, 4.988E-01, 5.771E-02 }, { 2006, 1.3156, 0.000E+00, 0.000E+00, 0.000E+00, 6.490E+01, 9.303E+00, 7.090E-02, 1.290E-02, 4.991E-01, 5.807E-02 }, { 2007, 1.3155, 0.000E+00, 0.000E+00, 0.000E+00, 6.412E+01, 9.356E+00, 6.905E-02, 1.255E-02, 4.994E-01, 5.843E-02 }, { 2008, 1.3154, 0.000E+00, 0.000E+00, 0.000E+00, 6.358E+01, 9.406E+00, 6.720E-02, 1.220E-02, 4.996E-01, 5.879E-02 }, { 2009, 1.3153, 0.000E+00, 0.000E+00, 0.000E+00, 6.281E+01, 9.448E+00, 6.535E-02, 1.185E-02, 4.999E-01, 5.916E-02 }, { 2010, 1.3152, 0.000E+00, 0.000E+00, 0.000E+00, 6.232E+01, 9.516E+00, 6.350E-02, 1.150E-02, 5.002E-01, 5.952E-02 }, { 2011, 1.3151, 0.000E+00, 0.000E+00, 0.000E+00, 6.156E+01, 9.578E+00, 6.165E-02, 1.115E-02, 5.004E-01, 6.013E-02 }, { 2012, 1.3150, 0.000E+00, 0.000E+00, 0.000E+00, 6.105E+01, 9.638E+00, 5.980E-02, 1.080E-02, 5.006E-01, 6.073E-02 }, { 2013, 1.3150, 0.000E+00, 0.000E+00, 0.000E+00, 6.029E+01, 9.692E+00, 5.795E-02, 1.045E-02, 5.009E-01, 6.134E-02 }, { 2014, 1.3149, 0.000E+00, 0.000E+00, 0.000E+00, 5.980E+01, 9.763E+00, 5.610E-02, 1.010E-02, 5.011E-01, 6.194E-02 }, { 2015, 1.3148, 0.000E+00, 0.000E+00, 0.000E+00, 5.907E+01, 9.845E+00, 5.425E-02, 9.750E-03, 5.013E-01, 6.255E-02 }, { 2016, 1.3147, 0.000E+00, 0.000E+00, 0.000E+00, 5.857E+01, 9.953E+00, 5.240E-02, 9.400E-03, 5.016E-01, 6.301E-02 }, { 2017, 1.3146, 0.000E+00, 0.000E+00, 0.000E+00, 5.788E+01, 1.004E+01, 5.055E-02, 9.050E-03, 5.018E-01, 6.347E-02 }, { 2018, 1.3146, 0.000E+00, 0.000E+00, 0.000E+00, 5.746E+01, 1.014E+01, 4.870E-02, 8.700E-03, 5.021E-01, 6.393E-02 }, { 2019, 1.3145, 0.000E+00, 0.000E+00, 0.000E+00, 5.680E+01, 1.027E+01, 4.685E-02, 8.350E-03, 5.023E-01, 6.439E-02 }, { 2020, 1.3144, 0.000E+00, 0.000E+00, 0.000E+00, 5.632E+01, 1.039E+01, 4.500E-02, 8.000E-03, 5.025E-01, 6.486E-02 }, { 2021, 1.3143, 0.000E+00, 0.000E+00, 0.000E+00, 5.566E+01, 1.052E+01, 4.965E-02, 8.800E-03, 5.028E-01, 6.524E-02 }, { 2022, 1.3142, 0.000E+00, 0.000E+00, 0.000E+00, 5.503E+01, 1.063E+01, 5.430E-02, 9.600E-03, 5.030E-01, 6.563E-02 }, { 2023, 1.3141, 0.000E+00, 0.000E+00, 0.000E+00, 5.463E+01, 1.077E+01, 5.895E-02, 1.040E-02, 5.033E-01, 6.601E-02 }, { 2024, 1.3140, 0.000E+00, 0.000E+00, 0.000E+00, 5.398E+01, 1.091E+01, 6.360E-02, 1.120E-02, 5.035E-01, 6.640E-02 }, { 2025, 1.3139, 0.000E+00, 0.000E+00, 0.000E+00, 5.356E+01, 1.103E+01, 6.825E-02, 1.200E-02, 5.037E-01, 6.679E-02 }, { 2026, 1.3138, 0.000E+00, 0.000E+00, 0.000E+00, 5.294E+01, 1.119E+01, 7.290E-02, 1.280E-02, 5.038E-01, 6.720E-02 }, { 2027, 1.3137, 0.000E+00, 0.000E+00, 0.000E+00, 5.256E+01, 1.135E+01, 7.755E-02, 1.360E-02, 5.038E-01, 6.761E-02 }, { 2028, 1.3136, 0.000E+00, 0.000E+00, 0.000E+00, 5.197E+01, 1.150E+01, 8.220E-02, 1.440E-02, 5.039E-01, 6.802E-02 }, { 2029, 1.3135, 0.000E+00, 0.000E+00, 0.000E+00, 5.138E+01, 1.165E+01, 8.685E-02, 1.520E-02, 5.039E-01, 6.843E-02 }, { 2030, 1.3134, 0.000E+00, 0.000E+00, 0.000E+00, 5.098E+01, 1.181E+01, 9.150E-02, 1.600E-02, 5.040E-01, 6.885E-02 }, { 2031, 1.3133, 0.000E+00, 0.000E+00, 0.000E+00, 5.047E+01, 1.201E+01, 9.615E-02, 1.680E-02, 5.040E-01, 6.943E-02 }, { 2032, 1.3132, 0.000E+00, 0.000E+00, 0.000E+00, 5.006E+01, 1.217E+01, 1.008E-01, 1.760E-02, 5.040E-01, 7.002E-02 }, { 2033, 1.3131, 0.000E+00, 0.000E+00, 0.000E+00, 4.951E+01, 1.234E+01, 1.055E-01, 1.840E-02, 5.040E-01, 7.060E-02 }, { 2034, 1.3130, 0.000E+00, 0.000E+00, 0.000E+00, 4.915E+01, 1.251E+01, 1.101E-01, 1.920E-02, 5.040E-01, 7.119E-02 }, { 2035, 1.3129, 0.000E+00, 0.000E+00, 0.000E+00, 4.860E+01, 1.269E+01, 1.148E-01, 2.000E-02, 5.040E-01, 7.177E-02 }, { 2036, 1.3128, 0.000E+00, 0.000E+00, 0.000E+00, 4.806E+01, 1.287E+01, 1.194E-01, 2.080E-02, 5.044E-01, 7.267E-02 }, { 2037, 1.3127, 0.000E+00, 0.000E+00, 0.000E+00, 4.773E+01, 1.307E+01, 1.241E-01, 2.160E-02, 5.049E-01, 7.356E-02 }, { 2038, 1.3126, 0.000E+00, 0.000E+00, 0.000E+00, 4.718E+01, 1.325E+01, 1.287E-01, 2.240E-02, 5.053E-01, 7.445E-02 }, { 2039, 1.3125, 0.000E+00, 0.000E+00, 0.000E+00, 4.685E+01, 1.346E+01, 1.334E-01, 2.320E-02, 5.058E-01, 7.534E-02 }, { 2040, 1.3124, 0.000E+00, 0.000E+00, 0.000E+00, 4.635E+01, 1.364E+01, 1.380E-01, 2.400E-02, 5.062E-01, 7.623E-02 }, { 2041, 1.3123, 0.000E+00, 0.000E+00, 0.000E+00, 4.584E+01, 1.384E+01, 1.363E-01, 2.370E-02, 5.065E-01, 7.693E-02 }, { 2042, 1.3122, 0.000E+00, 0.000E+00, 0.000E+00, 4.553E+01, 1.403E+01, 1.346E-01, 2.340E-02, 5.068E-01, 7.764E-02 }, { 2043, 1.3121, 0.000E+00, 0.000E+00, 0.000E+00, 4.503E+01, 1.423E+01, 1.329E-01, 2.310E-02, 5.070E-01, 7.834E-02 }, { 2044, 1.3120, 0.000E+00, 0.000E+00, 0.000E+00, 4.473E+01, 1.441E+01, 1.312E-01, 2.280E-02, 5.073E-01, 7.904E-02 }, { 2045, 1.3119, 0.000E+00, 0.000E+00, 0.000E+00, 4.426E+01, 1.461E+01, 1.295E-01, 2.250E-02, 5.076E-01, 7.974E-02 }, { 2046, 1.3118, 0.000E+00, 0.000E+00, 0.000E+00, 4.379E+01, 1.481E+01, 1.278E-01, 2.220E-02, 5.076E-01, 8.027E-02 }, { 2047, 1.3117, 0.000E+00, 0.000E+00, 0.000E+00, 4.348E+01, 1.499E+01, 1.261E-01, 2.190E-02, 5.076E-01, 8.080E-02 }, { 2048, 1.3116, 0.000E+00, 0.000E+00, 0.000E+00, 4.302E+01, 1.517E+01, 1.244E-01, 2.160E-02, 5.076E-01, 8.133E-02 }, { 2049, 1.3115, 0.000E+00, 0.000E+00, 0.000E+00, 4.273E+01, 1.534E+01, 1.227E-01, 2.130E-02, 5.076E-01, 8.186E-02 }, { 2050, 1.3114, 0.000E+00, 0.000E+00, 0.000E+00, 4.228E+01, 1.554E+01, 1.210E-01, 2.100E-02, 5.076E-01, 8.239E-02 }, { 2051, 1.3113, 0.000E+00, 0.000E+00, 0.000E+00, 4.186E+01, 1.571E+01, 1.193E-01, 2.070E-02, 5.077E-01, 8.283E-02 }, { 2052, 1.3112, 0.000E+00, 0.000E+00, 0.000E+00, 4.155E+01, 1.591E+01, 1.176E-01, 2.040E-02, 5.078E-01, 8.327E-02 }, { 2053, 1.3110, 0.000E+00, 0.000E+00, 0.000E+00, 4.115E+01, 1.607E+01, 1.159E-01, 2.010E-02, 5.079E-01, 8.371E-02 }, { 2054, 1.3109, 0.000E+00, 0.000E+00, 0.000E+00, 4.072E+01, 1.622E+01, 1.142E-01, 1.980E-02, 5.080E-01, 8.415E-02 }, { 2055, 1.3108, 0.000E+00, 0.000E+00, 0.000E+00, 4.046E+01, 1.637E+01, 1.125E-01, 1.950E-02, 5.081E-01, 8.459E-02 }, { 2056, 1.3107, 0.000E+00, 0.000E+00, 0.000E+00, 4.002E+01, 1.653E+01, 1.108E-01, 1.920E-02, 5.085E-01, 8.514E-02 }, { 2057, 1.3106, 0.000E+00, 0.000E+00, 0.000E+00, 3.975E+01, 1.667E+01, 1.091E-01, 1.890E-02, 5.089E-01, 8.570E-02 }, { 2058, 1.3105, 0.000E+00, 0.000E+00, 0.000E+00, 3.934E+01, 1.678E+01, 1.074E-01, 1.860E-02, 5.093E-01, 8.626E-02 }, { 2059, 1.3104, 0.000E+00, 0.000E+00, 0.000E+00, 3.894E+01, 1.690E+01, 1.057E-01, 1.830E-02, 5.097E-01, 8.681E-02 }, { 2060, 1.3103, 0.000E+00, 0.000E+00, 0.000E+00, 3.868E+01, 1.698E+01, 1.040E-01, 1.800E-02, 5.101E-01, 8.737E-02 }, { 2061, 1.3102, 0.000E+00, 0.000E+00, 0.000E+00, 3.827E+01, 1.708E+01, 1.054E-01, 1.825E-02, 5.100E-01, 8.764E-02 }, { 2062, 1.3101, 0.000E+00, 0.000E+00, 0.000E+00, 3.790E+01, 1.718E+01, 1.068E-01, 1.850E-02, 5.100E-01, 8.791E-02 }, { 2063, 1.3099, 0.000E+00, 0.000E+00, 0.000E+00, 3.762E+01, 1.725E+01, 1.082E-01, 1.875E-02, 5.099E-01, 8.817E-02 }, { 2064, 1.3098, 0.000E+00, 0.000E+00, 0.000E+00, 3.726E+01, 1.734E+01, 1.096E-01, 1.900E-02, 5.098E-01, 8.844E-02 }, { 2065, 1.3097, 0.000E+00, 0.000E+00, 0.000E+00, 3.687E+01, 1.739E+01, 1.110E-01, 1.925E-02, 5.098E-01, 8.871E-02 }, { 2066, 1.3096, 0.000E+00, 0.000E+00, 0.000E+00, 3.664E+01, 1.748E+01, 1.124E-01, 1.950E-02, 5.095E-01, 8.911E-02 }, { 2067, 1.3095, 0.000E+00, 0.000E+00, 0.000E+00, 3.628E+01, 1.755E+01, 1.138E-01, 1.975E-02, 5.092E-01, 8.951E-02 }, { 2068, 1.3094, 0.000E+00, 0.000E+00, 0.000E+00, 3.592E+01, 1.761E+01, 1.152E-01, 2.000E-02, 5.089E-01, 8.992E-02 }, { 2069, 1.3093, 0.000E+00, 0.000E+00, 0.000E+00, 3.568E+01, 1.767E+01, 1.166E-01, 2.025E-02, 5.086E-01, 9.032E-02 }, { 2070, 1.3092, 0.000E+00, 0.000E+00, 0.000E+00, 3.536E+01, 1.771E+01, 1.180E-01, 2.050E-02, 5.083E-01, 9.072E-02 }, { 2071, 1.3091, 0.000E+00, 0.000E+00, 0.000E+00, 3.499E+01, 1.777E+01, 1.194E-01, 2.075E-02, 5.080E-01, 9.072E-02 }, { 2072, 1.3090, 0.000E+00, 0.000E+00, 0.000E+00, 3.479E+01, 1.783E+01, 1.208E-01, 2.100E-02, 5.078E-01, 9.072E-02 }, { 2073, 1.3088, 0.000E+00, 0.000E+00, 0.000E+00, 3.447E+01, 1.787E+01, 1.222E-01, 2.125E-02, 5.076E-01, 9.071E-02 }, { 2074, 1.3087, 0.000E+00, 0.000E+00, 0.000E+00, 3.413E+01, 1.794E+01, 1.236E-01, 2.150E-02, 5.073E-01, 9.071E-02 }, { 2075, 1.3086, 0.000E+00, 0.000E+00, 0.000E+00, 3.392E+01, 1.795E+01, 1.250E-01, 2.175E-02, 5.071E-01, 9.071E-02 }, { 2076, 1.3085, 0.000E+00, 0.000E+00, 0.000E+00, 3.363E+01, 1.799E+01, 1.264E-01, 2.200E-02, 5.071E-01, 9.089E-02 }, { 2077, 1.3084, 0.000E+00, 0.000E+00, 0.000E+00, 3.329E+01, 1.805E+01, 1.278E-01, 2.225E-02, 5.071E-01, 9.107E-02 }, { 2078, 1.3082, 0.000E+00, 0.000E+00, 0.000E+00, 3.309E+01, 1.809E+01, 1.292E-01, 2.250E-02, 5.071E-01, 9.125E-02 }, { 2079, 1.3081, 0.000E+00, 0.000E+00, 0.000E+00, 3.280E+01, 1.813E+01, 1.306E-01, 2.275E-02, 5.071E-01, 9.143E-02 }, { 2080, 1.3080, 0.000E+00, 0.000E+00, 0.000E+00, 3.251E+01, 1.820E+01, 1.320E-01, 2.300E-02, 5.071E-01, 9.162E-02 }, { 2081, 1.3079, 0.000E+00, 0.000E+00, 0.000E+00, 3.231E+01, 1.827E+01, 1.317E-01, 2.290E-02, 5.071E-01, 9.209E-02 }, { 2082, 1.3078, 0.000E+00, 0.000E+00, 0.000E+00, 3.200E+01, 1.830E+01, 1.314E-01, 2.280E-02, 5.071E-01, 9.256E-02 }, { 2083, 1.3076, 0.000E+00, 0.000E+00, 0.000E+00, 3.172E+01, 1.835E+01, 1.311E-01, 2.270E-02, 5.070E-01, 9.303E-02 }, { 2084, 1.3075, 0.000E+00, 0.000E+00, 0.000E+00, 3.154E+01, 1.841E+01, 1.308E-01, 2.260E-02, 5.070E-01, 9.350E-02 }, { 2085, 1.3074, 0.000E+00, 0.000E+00, 0.000E+00, 3.127E+01, 1.846E+01, 1.305E-01, 2.250E-02, 5.070E-01, 9.397E-02 }, { 2086, 1.3073, 0.000E+00, 0.000E+00, 0.000E+00, 3.097E+01, 1.852E+01, 1.302E-01, 2.240E-02, 5.070E-01, 9.447E-02 }, { 2087, 1.3072, 0.000E+00, 0.000E+00, 0.000E+00, 3.071E+01, 1.856E+01, 1.299E-01, 2.230E-02, 5.069E-01, 9.496E-02 }, { 2088, 1.3070, 0.000E+00, 0.000E+00, 0.000E+00, 3.052E+01, 1.861E+01, 1.296E-01, 2.220E-02, 5.069E-01, 9.546E-02 }, { 2089, 1.3069, 0.000E+00, 0.000E+00, 0.000E+00, 3.025E+01, 1.866E+01, 1.293E-01, 2.210E-02, 5.068E-01, 9.596E-02 }, { 2090, 1.3068, 0.000E+00, 0.000E+00, 0.000E+00, 2.999E+01, 1.871E+01, 1.290E-01, 2.200E-02, 5.068E-01, 9.646E-02 }, { 2091, 1.3067, 0.000E+00, 0.000E+00, 0.000E+00, 2.980E+01, 1.876E+01, 1.287E-01, 2.190E-02, 5.067E-01, 9.691E-02 }, { 2092, 1.3066, 0.000E+00, 0.000E+00, 0.000E+00, 2.958E+01, 1.881E+01, 1.284E-01, 2.180E-02, 5.067E-01, 9.737E-02 }, { 2093, 1.3064, 0.000E+00, 0.000E+00, 0.000E+00, 2.929E+01, 1.885E+01, 1.281E-01, 2.170E-02, 5.066E-01, 9.782E-02 }, { 2094, 1.3063, 0.000E+00, 0.000E+00, 0.000E+00, 2.906E+01, 1.890E+01, 1.278E-01, 2.160E-02, 5.066E-01, 9.827E-02 }, { 2095, 1.3062, 0.000E+00, 0.000E+00, 0.000E+00, 2.888E+01, 1.896E+01, 1.275E-01, 2.150E-02, 5.065E-01, 9.872E-02 }, { 2096, 1.3061, 0.000E+00, 0.000E+00, 0.000E+00, 2.865E+01, 1.903E+01, 1.272E-01, 2.140E-02, 5.064E-01, 9.886E-02 }, { 2097, 1.3060, 0.000E+00, 0.000E+00, 0.000E+00, 2.840E+01, 1.907E+01, 1.269E-01, 2.130E-02, 5.062E-01, 9.899E-02 }, { 2098, 1.3059, 0.000E+00, 0.000E+00, 0.000E+00, 2.822E+01, 1.911E+01, 1.266E-01, 2.120E-02, 5.061E-01, 9.913E-02 }, { 2099, 1.3058, 0.000E+00, 0.000E+00, 0.000E+00, 2.799E+01, 1.916E+01, 1.263E-01, 2.110E-02, 5.059E-01, 9.926E-02 }, { 2100, 1.3057, 0.000E+00, 0.000E+00, 0.000E+00, 2.776E+01, 1.921E+01, 1.260E-01, 2.100E-02, 5.058E-01, 9.940E-02 }, { 2101, 1.3056, 0.000E+00, 0.000E+00, 0.000E+00, 2.751E+01, 1.927E+01, 1.262E-01, 2.105E-02, 5.054E-01, 9.976E-02 }, { 2102, 1.3055, 0.000E+00, 0.000E+00, 0.000E+00, 2.737E+01, 1.929E+01, 1.264E-01, 2.110E-02, 5.050E-01, 1.001E-01 }, { 2103, 1.3053, 0.000E+00, 0.000E+00, 0.000E+00, 2.713E+01, 1.932E+01, 1.266E-01, 2.115E-02, 5.047E-01, 1.005E-01 }, { 2104, 1.3052, 0.000E+00, 0.000E+00, 0.000E+00, 2.692E+01, 1.935E+01, 1.268E-01, 2.120E-02, 5.043E-01, 1.008E-01 }, { 2105, 1.3051, 0.000E+00, 0.000E+00, 0.000E+00, 2.671E+01, 1.936E+01, 1.270E-01, 2.125E-02, 5.039E-01, 1.012E-01 }, { 2106, 1.3050, 0.000E+00, 0.000E+00, 0.000E+00, 2.657E+01, 1.940E+01, 1.272E-01, 2.130E-02, 5.043E-01, 1.018E-01 }, { 2107, 1.3049, 0.000E+00, 0.000E+00, 0.000E+00, 2.637E+01, 1.943E+01, 1.274E-01, 2.135E-02, 5.047E-01, 1.025E-01 }, { 2108, 1.3047, 0.000E+00, 0.000E+00, 0.000E+00, 2.617E+01, 1.947E+01, 1.276E-01, 2.140E-02, 5.050E-01, 1.031E-01 }, { 2109, 1.3046, 0.000E+00, 0.000E+00, 0.000E+00, 2.597E+01, 1.951E+01, 1.278E-01, 2.145E-02, 5.054E-01, 1.037E-01 }, { 2110, 1.3045, 0.000E+00, 0.000E+00, 0.000E+00, 2.584E+01, 1.953E+01, 1.280E-01, 2.150E-02, 5.058E-01, 1.043E-01 }, { 2111, 1.3044, 0.000E+00, 0.000E+00, 0.000E+00, 2.565E+01, 1.956E+01, 1.282E-01, 2.155E-02, 5.056E-01, 1.045E-01 }, { 2112, 1.3043, 0.000E+00, 0.000E+00, 0.000E+00, 2.547E+01, 1.960E+01, 1.284E-01, 2.160E-02, 5.055E-01, 1.047E-01 }, { 2113, 1.3041, 0.000E+00, 0.000E+00, 0.000E+00, 2.528E+01, 1.961E+01, 1.286E-01, 2.165E-02, 5.054E-01, 1.049E-01 }, { 2114, 1.3040, 0.000E+00, 0.000E+00, 0.000E+00, 2.518E+01, 1.962E+01, 1.288E-01, 2.170E-02, 5.052E-01, 1.051E-01 }, { 2115, 1.3039, 0.000E+00, 0.000E+00, 0.000E+00, 2.501E+01, 1.966E+01, 1.290E-01, 2.175E-02, 5.051E-01, 1.053E-01 }, { 2116, 1.3038, 0.000E+00, 0.000E+00, 0.000E+00, 2.485E+01, 1.966E+01, 1.292E-01, 2.180E-02, 5.050E-01, 1.059E-01 }, { 2117, 1.3037, 0.000E+00, 0.000E+00, 0.000E+00, 2.466E+01, 1.969E+01, 1.294E-01, 2.185E-02, 5.048E-01, 1.064E-01 }, { 2118, 1.3035, 0.000E+00, 0.000E+00, 0.000E+00, 2.455E+01, 1.970E+01, 1.296E-01, 2.190E-02, 5.047E-01, 1.070E-01 }, { 2119, 1.3034, 0.000E+00, 0.000E+00, 0.000E+00, 2.438E+01, 1.972E+01, 1.298E-01, 2.195E-02, 5.046E-01, 1.075E-01 }, { 2120, 1.3033, 0.000E+00, 0.000E+00, 0.000E+00, 2.420E+01, 1.974E+01, 1.300E-01, 2.200E-02, 5.044E-01, 1.081E-01 }, { 2121, 1.3032, 0.000E+00, 0.000E+00, 0.000E+00, 2.401E+01, 1.974E+01, 1.301E-01, 2.200E-02, 5.047E-01, 1.081E-01 }, { 2122, 1.3031, 0.000E+00, 0.000E+00, 0.000E+00, 2.386E+01, 1.976E+01, 1.301E-01, 2.200E-02, 5.051E-01, 1.081E-01 }, { 2123, 1.3029, 0.000E+00, 0.000E+00, 0.000E+00, 2.374E+01, 1.978E+01, 1.302E-01, 2.200E-02, 5.054E-01, 1.081E-01 }, { 2124, 1.3028, 0.000E+00, 0.000E+00, 0.000E+00, 2.358E+01, 1.979E+01, 1.302E-01, 2.200E-02, 5.057E-01, 1.081E-01 }, { 2125, 1.3027, 0.000E+00, 0.000E+00, 0.000E+00, 2.342E+01, 1.982E+01, 1.303E-01, 2.200E-02, 5.060E-01, 1.081E-01 }, { 2126, 1.3026, 0.000E+00, 0.000E+00, 0.000E+00, 2.328E+01, 1.982E+01, 1.303E-01, 2.200E-02, 5.055E-01, 1.086E-01 }, { 2127, 1.3025, 0.000E+00, 0.000E+00, 0.000E+00, 2.318E+01, 1.983E+01, 1.304E-01, 2.200E-02, 5.050E-01, 1.092E-01 }, { 2128, 1.3023, 0.000E+00, 0.000E+00, 0.000E+00, 2.304E+01, 1.986E+01, 1.304E-01, 2.200E-02, 5.045E-01, 1.098E-01 }, { 2129, 1.3022, 0.000E+00, 0.000E+00, 0.000E+00, 2.289E+01, 1.988E+01, 1.305E-01, 2.200E-02, 5.040E-01, 1.103E-01 }, { 2130, 1.3021, 0.000E+00, 0.000E+00, 0.000E+00, 2.275E+01, 1.989E+01, 1.305E-01, 2.200E-02, 5.035E-01, 1.109E-01 }, { 2131, 1.3020, 0.000E+00, 0.000E+00, 0.000E+00, 2.262E+01, 1.989E+01, 1.306E-01, 2.200E-02, 5.039E-01, 1.111E-01 }, { 2132, 1.3019, 0.000E+00, 0.000E+00, 0.000E+00, 2.252E+01, 1.993E+01, 1.306E-01, 2.200E-02, 5.043E-01, 1.114E-01 }, { 2133, 1.3017, 0.000E+00, 0.000E+00, 0.000E+00, 2.239E+01, 1.993E+01, 1.307E-01, 2.200E-02, 5.047E-01, 1.116E-01 }, { 2134, 1.3016, 0.000E+00, 0.000E+00, 0.000E+00, 2.227E+01, 1.997E+01, 1.307E-01, 2.200E-02, 5.051E-01, 1.118E-01 }, { 2135, 1.3015, 0.000E+00, 0.000E+00, 0.000E+00, 2.214E+01, 2.001E+01, 1.308E-01, 2.200E-02, 5.055E-01, 1.121E-01 }, { 2136, 1.3014, 0.000E+00, 0.000E+00, 0.000E+00, 2.202E+01, 2.001E+01, 1.308E-01, 2.200E-02, 5.053E-01, 1.121E-01 }, { 2137, 1.3013, 0.000E+00, 0.000E+00, 0.000E+00, 2.194E+01, 2.004E+01, 1.309E-01, 2.200E-02, 5.051E-01, 1.122E-01 }, { 2138, 1.3011, 0.000E+00, 0.000E+00, 0.000E+00, 2.183E+01, 2.007E+01, 1.309E-01, 2.200E-02, 5.048E-01, 1.123E-01 }, { 2139, 1.3010, 0.000E+00, 0.000E+00, 0.000E+00, 2.172E+01, 2.011E+01, 1.310E-01, 2.200E-02, 5.046E-01, 1.124E-01 }, { 2140, 1.3009, 0.000E+00, 0.000E+00, 0.000E+00, 2.162E+01, 2.013E+01, 1.310E-01, 2.200E-02, 5.044E-01, 1.124E-01 }, { 2141, 1.3008, 0.000E+00, 0.000E+00, 0.000E+00, 2.150E+01, 2.015E+01, 1.301E-01, 2.185E-02, 5.041E-01, 1.128E-01 }, { 2142, 1.3007, 0.000E+00, 0.000E+00, 0.000E+00, 2.140E+01, 2.017E+01, 1.292E-01, 2.170E-02, 5.037E-01, 1.132E-01 }, { 2143, 1.3005, 0.000E+00, 0.000E+00, 0.000E+00, 2.133E+01, 2.019E+01, 1.283E-01, 2.155E-02, 5.034E-01, 1.136E-01 }, { 2144, 1.3004, 0.000E+00, 0.000E+00, 0.000E+00, 2.123E+01, 2.022E+01, 1.274E-01, 2.140E-02, 5.031E-01, 1.140E-01 }, { 2145, 1.3003, 0.000E+00, 0.000E+00, 0.000E+00, 2.112E+01, 2.023E+01, 1.265E-01, 2.125E-02, 5.028E-01, 1.144E-01 }, { 2146, 1.3002, 0.000E+00, 0.000E+00, 0.000E+00, 2.102E+01, 2.023E+01, 1.256E-01, 2.110E-02, 5.024E-01, 1.145E-01 }, { 2147, 1.3001, 0.000E+00, 0.000E+00, 0.000E+00, 2.091E+01, 2.026E+01, 1.247E-01, 2.095E-02, 5.021E-01, 1.146E-01 }, { 2148, 1.2999, 0.000E+00, 0.000E+00, 0.000E+00, 2.085E+01, 2.027E+01, 1.238E-01, 2.080E-02, 5.018E-01, 1.147E-01 }, { 2149, 1.2998, 0.000E+00, 0.000E+00, 0.000E+00, 2.077E+01, 2.029E+01, 1.229E-01, 2.065E-02, 5.015E-01, 1.148E-01 }, { 2150, 1.2997, 0.000E+00, 0.000E+00, 0.000E+00, 2.067E+01, 2.028E+01, 1.220E-01, 2.050E-02, 5.011E-01, 1.150E-01 }, { 2151, 1.2996, 0.000E+00, 0.000E+00, 0.000E+00, 2.058E+01, 2.027E+01, 1.211E-01, 2.035E-02, 5.009E-01, 1.149E-01 }, { 2152, 1.2995, 0.000E+00, 0.000E+00, 0.000E+00, 2.049E+01, 2.029E+01, 1.202E-01, 2.020E-02, 5.007E-01, 1.149E-01 }, { 2153, 1.2993, 0.000E+00, 0.000E+00, 0.000E+00, 2.040E+01, 2.029E+01, 1.193E-01, 2.005E-02, 5.005E-01, 1.149E-01 }, { 2154, 1.2992, 0.000E+00, 0.000E+00, 0.000E+00, 2.033E+01, 2.031E+01, 1.184E-01, 1.990E-02, 5.003E-01, 1.149E-01 }, { 2155, 1.2991, 0.000E+00, 0.000E+00, 0.000E+00, 2.027E+01, 2.029E+01, 1.175E-01, 1.975E-02, 5.000E-01, 1.149E-01 }, { 2156, 1.2990, 0.000E+00, 0.000E+00, 0.000E+00, 2.018E+01, 2.026E+01, 1.166E-01, 1.960E-02, 4.998E-01, 1.149E-01 }, { 2157, 1.2989, 0.000E+00, 0.000E+00, 0.000E+00, 2.010E+01, 2.030E+01, 1.157E-01, 1.945E-02, 4.996E-01, 1.149E-01 }, { 2158, 1.2987, 0.000E+00, 0.000E+00, 0.000E+00, 2.002E+01, 2.030E+01, 1.148E-01, 1.930E-02, 4.994E-01, 1.149E-01 }, { 2159, 1.2986, 0.000E+00, 0.000E+00, 0.000E+00, 1.995E+01, 2.030E+01, 1.139E-01, 1.915E-02, 4.992E-01, 1.149E-01 }, { 2160, 1.2985, 0.000E+00, 0.000E+00, 0.000E+00, 1.987E+01, 2.030E+01, 1.130E-01, 1.900E-02, 4.990E-01, 1.149E-01 }, { 2161, 1.2984, 0.000E+00, 0.000E+00, 0.000E+00, 1.983E+01, 2.031E+01, 1.129E-01, 1.895E-02, 4.988E-01, 1.149E-01 }, { 2162, 1.2983, 0.000E+00, 0.000E+00, 0.000E+00, 1.976E+01, 2.029E+01, 1.127E-01, 1.890E-02, 4.986E-01, 1.149E-01 }, { 2163, 1.2981, 0.000E+00, 0.000E+00, 0.000E+00, 1.969E+01, 2.029E+01, 1.126E-01, 1.885E-02, 4.984E-01, 1.149E-01 }, { 2164, 1.2980, 0.000E+00, 0.000E+00, 0.000E+00, 1.963E+01, 2.026E+01, 1.124E-01, 1.880E-02, 4.981E-01, 1.149E-01 }, { 2165, 1.2979, 0.000E+00, 0.000E+00, 0.000E+00, 1.958E+01, 2.025E+01, 1.123E-01, 1.875E-02, 4.979E-01, 1.149E-01 }, { 2166, 1.2978, 0.000E+00, 0.000E+00, 0.000E+00, 1.952E+01, 2.023E+01, 1.121E-01, 1.870E-02, 4.978E-01, 1.149E-01 }, { 2167, 1.2977, 0.000E+00, 0.000E+00, 0.000E+00, 1.946E+01, 2.020E+01, 1.120E-01, 1.865E-02, 4.976E-01, 1.149E-01 }, { 2168, 1.2975, 0.000E+00, 0.000E+00, 0.000E+00, 1.942E+01, 2.016E+01, 1.118E-01, 1.860E-02, 4.974E-01, 1.149E-01 }, { 2169, 1.2974, 0.000E+00, 0.000E+00, 0.000E+00, 1.938E+01, 2.015E+01, 1.117E-01, 1.855E-02, 4.972E-01, 1.149E-01 }, { 2170, 1.2973, 0.000E+00, 0.000E+00, 0.000E+00, 1.933E+01, 2.012E+01, 1.115E-01, 1.850E-02, 4.970E-01, 1.149E-01 }, { 2171, 1.2972, 0.000E+00, 0.000E+00, 0.000E+00, 1.928E+01, 2.009E+01, 1.114E-01, 1.845E-02, 4.972E-01, 1.149E-01 }, { 2172, 1.2970, 0.000E+00, 0.000E+00, 0.000E+00, 1.923E+01, 2.007E+01, 1.112E-01, 1.840E-02, 4.974E-01, 1.149E-01 }, { 2173, 1.2969, 0.000E+00, 0.000E+00, 0.000E+00, 1.918E+01, 2.003E+01, 1.111E-01, 1.835E-02, 4.975E-01, 1.149E-01 }, { 2174, 1.2967, 0.000E+00, 0.000E+00, 0.000E+00, 1.913E+01, 1.998E+01, 1.109E-01, 1.830E-02, 4.977E-01, 1.149E-01 }, { 2175, 1.2966, 0.000E+00, 0.000E+00, 0.000E+00, 1.909E+01, 1.995E+01, 1.108E-01, 1.825E-02, 4.979E-01, 1.149E-01 }, { 2176, 1.2965, 0.000E+00, 0.000E+00, 0.000E+00, 1.904E+01, 1.991E+01, 1.106E-01, 1.820E-02, 4.979E-01, 1.149E-01 }, { 2177, 1.2964, 0.000E+00, 0.000E+00, 0.000E+00, 1.900E+01, 1.986E+01, 1.105E-01, 1.815E-02, 4.979E-01, 1.149E-01 }, { 2178, 1.2962, 0.000E+00, 0.000E+00, 0.000E+00, 1.896E+01, 1.980E+01, 1.103E-01, 1.810E-02, 4.979E-01, 1.149E-01 }, { 2179, 1.2961, 0.000E+00, 0.000E+00, 0.000E+00, 1.889E+01, 1.975E+01, 1.102E-01, 1.805E-02, 4.979E-01, 1.149E-01 }, { 2180, 1.2960, 0.000E+00, 0.000E+00, 0.000E+00, 1.884E+01, 1.969E+01, 1.100E-01, 1.800E-02, 4.979E-01, 1.149E-01 }, { 2181, 1.2959, 0.000E+00, 0.000E+00, 0.000E+00, 1.880E+01, 1.964E+01, 1.094E-01, 1.790E-02, 4.963E-01, 1.149E-01 }, { 2182, 1.2958, 0.000E+00, 0.000E+00, 0.000E+00, 1.874E+01, 1.959E+01, 1.087E-01, 1.780E-02, 4.946E-01, 1.150E-01 }, { 2183, 1.2957, 0.000E+00, 0.000E+00, 0.000E+00, 1.870E+01, 1.953E+01, 1.081E-01, 1.770E-02, 4.929E-01, 1.151E-01 }, { 2184, 1.2956, 0.000E+00, 0.000E+00, 0.000E+00, 1.866E+01, 1.947E+01, 1.074E-01, 1.760E-02, 4.912E-01, 1.152E-01 }, { 2185, 1.2955, 0.000E+00, 0.000E+00, 0.000E+00, 1.860E+01, 1.941E+01, 1.068E-01, 1.750E-02, 4.895E-01, 1.152E-01 }, { 2186, 1.2954, 0.000E+00, 0.000E+00, 0.000E+00, 1.856E+01, 1.936E+01, 1.061E-01, 1.740E-02, 4.889E-01, 1.155E-01 }, { 2187, 1.2953, 0.000E+00, 0.000E+00, 0.000E+00, 1.852E+01, 1.931E+01, 1.055E-01, 1.730E-02, 4.883E-01, 1.157E-01 }, { 2188, 1.2951, 0.000E+00, 0.000E+00, 0.000E+00, 1.849E+01, 1.922E+01, 1.048E-01, 1.720E-02, 4.877E-01, 1.160E-01 }, { 2189, 1.2950, 0.000E+00, 0.000E+00, 0.000E+00, 1.845E+01, 1.918E+01, 1.042E-01, 1.710E-02, 4.871E-01, 1.163E-01 }, { 2190, 1.2949, 0.000E+00, 0.000E+00, 0.000E+00, 1.843E+01, 1.912E+01, 1.035E-01, 1.700E-02, 4.865E-01, 1.165E-01 }, { 2191, 1.2948, 0.000E+00, 0.000E+00, 0.000E+00, 1.839E+01, 1.905E+01, 1.029E-01, 1.690E-02, 4.859E-01, 1.165E-01 }, { 2192, 1.2947, 0.000E+00, 0.000E+00, 0.000E+00, 1.837E+01, 1.899E+01, 1.022E-01, 1.680E-02, 4.854E-01, 1.166E-01 }, { 2193, 1.2945, 0.000E+00, 0.000E+00, 0.000E+00, 1.837E+01, 1.890E+01, 1.016E-01, 1.670E-02, 4.848E-01, 1.166E-01 }, { 2194, 1.2944, 0.000E+00, 0.000E+00, 0.000E+00, 1.838E+01, 1.885E+01, 1.009E-01, 1.660E-02, 4.842E-01, 1.166E-01 }, { 2195, 1.2943, 0.000E+00, 0.000E+00, 0.000E+00, 1.837E+01, 1.881E+01, 1.003E-01, 1.650E-02, 4.836E-01, 1.167E-01 }, { 2196, 1.2942, 0.000E+00, 0.000E+00, 0.000E+00, 1.836E+01, 1.874E+01, 9.960E-02, 1.640E-02, 4.833E-01, 1.174E-01 }, { 2197, 1.2941, 0.000E+00, 0.000E+00, 0.000E+00, 1.835E+01, 1.867E+01, 9.895E-02, 1.630E-02, 4.830E-01, 1.181E-01 }, { 2198, 1.2939, 0.000E+00, 0.000E+00, 0.000E+00, 1.835E+01, 1.861E+01, 9.830E-02, 1.620E-02, 4.827E-01, 1.188E-01 }, { 2199, 1.2938, 0.000E+00, 0.000E+00, 0.000E+00, 1.835E+01, 1.858E+01, 9.765E-02, 1.610E-02, 4.824E-01, 1.196E-01 }, { 2200, 1.2937, 0.000E+00, 0.000E+00, 0.000E+00, 1.834E+01, 1.852E+01, 9.700E-02, 1.600E-02, 4.821E-01, 1.203E-01 }, { 2201, 1.2936, 0.000E+00, 0.000E+00, 0.000E+00, 1.833E+01, 1.846E+01, 9.775E-02, 1.610E-02, 4.820E-01, 1.201E-01 }, { 2202, 1.2935, 0.000E+00, 0.000E+00, 0.000E+00, 1.833E+01, 1.840E+01, 9.850E-02, 1.620E-02, 4.819E-01, 1.200E-01 }, { 2203, 1.2933, 0.000E+00, 0.000E+00, 0.000E+00, 1.833E+01, 1.834E+01, 9.925E-02, 1.630E-02, 4.818E-01, 1.199E-01 }, { 2204, 1.2932, 0.000E+00, 0.000E+00, 0.000E+00, 1.834E+01, 1.829E+01, 1.000E-01, 1.640E-02, 4.817E-01, 1.197E-01 }, { 2205, 1.2931, 0.000E+00, 0.000E+00, 0.000E+00, 1.833E+01, 1.824E+01, 1.008E-01, 1.650E-02, 4.816E-01, 1.196E-01 }, { 2206, 1.2930, 0.000E+00, 0.000E+00, 0.000E+00, 1.834E+01, 1.818E+01, 1.015E-01, 1.660E-02, 4.816E-01, 1.191E-01 }, { 2207, 1.2928, 0.000E+00, 0.000E+00, 0.000E+00, 1.834E+01, 1.813E+01, 1.023E-01, 1.670E-02, 4.815E-01, 1.186E-01 }, { 2208, 1.2927, 0.000E+00, 0.000E+00, 0.000E+00, 1.832E+01, 1.807E+01, 1.030E-01, 1.680E-02, 4.815E-01, 1.181E-01 }, { 2209, 1.2925, 0.000E+00, 0.000E+00, 0.000E+00, 1.831E+01, 1.803E+01, 1.038E-01, 1.690E-02, 4.815E-01, 1.176E-01 }, { 2210, 1.2924, 0.000E+00, 0.000E+00, 0.000E+00, 1.829E+01, 1.798E+01, 1.045E-01, 1.700E-02, 4.815E-01, 1.171E-01 }, { 2211, 1.2923, 0.000E+00, 0.000E+00, 0.000E+00, 1.828E+01, 1.792E+01, 1.053E-01, 1.710E-02, 4.817E-01, 1.167E-01 }, { 2212, 1.2922, 0.000E+00, 0.000E+00, 0.000E+00, 1.828E+01, 1.787E+01, 1.060E-01, 1.720E-02, 4.818E-01, 1.163E-01 }, { 2213, 1.2920, 0.000E+00, 0.000E+00, 0.000E+00, 1.829E+01, 1.782E+01, 1.068E-01, 1.730E-02, 4.820E-01, 1.159E-01 }, { 2214, 1.2919, 0.000E+00, 0.000E+00, 0.000E+00, 1.829E+01, 1.780E+01, 1.075E-01, 1.740E-02, 4.821E-01, 1.156E-01 }, { 2215, 1.2918, 0.000E+00, 0.000E+00, 0.000E+00, 1.830E+01, 1.775E+01, 1.083E-01, 1.750E-02, 4.823E-01, 1.152E-01 }, { 2216, 1.2917, 0.000E+00, 0.000E+00, 0.000E+00, 1.832E+01, 1.773E+01, 1.090E-01, 1.760E-02, 4.827E-01, 1.152E-01 }, { 2217, 1.2916, 0.000E+00, 0.000E+00, 0.000E+00, 1.835E+01, 1.768E+01, 1.098E-01, 1.770E-02, 4.831E-01, 1.152E-01 }, { 2218, 1.2914, 0.000E+00, 0.000E+00, 0.000E+00, 1.836E+01, 1.768E+01, 1.105E-01, 1.780E-02, 4.836E-01, 1.151E-01 }, { 2219, 1.2913, 0.000E+00, 0.000E+00, 0.000E+00, 1.837E+01, 1.766E+01, 1.113E-01, 1.790E-02, 4.840E-01, 1.151E-01 }, { 2220, 1.2912, 0.000E+00, 0.000E+00, 0.000E+00, 1.837E+01, 1.763E+01, 1.120E-01, 1.800E-02, 4.844E-01, 1.151E-01 }, { 2221, 1.2911, 0.000E+00, 0.000E+00, 0.000E+00, 1.838E+01, 1.762E+01, 1.118E-01, 1.795E-02, 4.849E-01, 1.151E-01 }, { 2222, 1.2910, 0.000E+00, 0.000E+00, 0.000E+00, 1.837E+01, 1.763E+01, 1.115E-01, 1.790E-02, 4.853E-01, 1.151E-01 }, { 2223, 1.2908, 0.000E+00, 0.000E+00, 0.000E+00, 1.840E+01, 1.764E+01, 1.113E-01, 1.785E-02, 4.858E-01, 1.151E-01 }, { 2224, 1.2907, 0.000E+00, 0.000E+00, 0.000E+00, 1.842E+01, 1.764E+01, 1.110E-01, 1.780E-02, 4.862E-01, 1.151E-01 }, { 2225, 1.2906, 0.000E+00, 0.000E+00, 0.000E+00, 1.843E+01, 1.766E+01, 1.108E-01, 1.775E-02, 4.867E-01, 1.151E-01 }, { 2226, 1.2905, 0.000E+00, 0.000E+00, 0.000E+00, 1.846E+01, 1.770E+01, 1.105E-01, 1.770E-02, 4.873E-01, 1.151E-01 }, { 2227, 1.2904, 0.000E+00, 0.000E+00, 0.000E+00, 1.849E+01, 1.774E+01, 1.103E-01, 1.765E-02, 4.879E-01, 1.151E-01 }, { 2228, 1.2902, 0.000E+00, 0.000E+00, 0.000E+00, 1.851E+01, 1.779E+01, 1.100E-01, 1.760E-02, 4.884E-01, 1.151E-01 }, { 2229, 1.2901, 0.000E+00, 0.000E+00, 0.000E+00, 1.854E+01, 1.786E+01, 1.098E-01, 1.755E-02, 4.890E-01, 1.151E-01 }, { 2230, 1.2900, 0.000E+00, 0.000E+00, 0.000E+00, 1.857E+01, 1.795E+01, 1.095E-01, 1.750E-02, 4.896E-01, 1.151E-01 }, { 2231, 1.2899, 0.000E+00, 0.000E+00, 0.000E+00, 1.858E+01, 1.803E+01, 1.093E-01, 1.745E-02, 4.902E-01, 1.151E-01 }, { 2232, 1.2898, 0.000E+00, 0.000E+00, 0.000E+00, 1.860E+01, 1.814E+01, 1.090E-01, 1.740E-02, 4.908E-01, 1.151E-01 }, { 2233, 1.2896, 0.000E+00, 0.000E+00, 0.000E+00, 1.864E+01, 1.825E+01, 1.088E-01, 1.735E-02, 4.914E-01, 1.151E-01 }, { 2234, 1.2895, 0.000E+00, 0.000E+00, 0.000E+00, 1.865E+01, 1.836E+01, 1.085E-01, 1.730E-02, 4.920E-01, 1.151E-01 }, { 2235, 1.2894, 0.000E+00, 0.000E+00, 0.000E+00, 1.867E+01, 1.851E+01, 1.083E-01, 1.725E-02, 4.926E-01, 1.151E-01 }, { 2236, 1.2893, 0.000E+00, 0.000E+00, 0.000E+00, 1.870E+01, 1.866E+01, 1.080E-01, 1.720E-02, 4.924E-01, 1.151E-01 }, { 2237, 1.2892, 0.000E+00, 0.000E+00, 0.000E+00, 1.875E+01, 1.881E+01, 1.078E-01, 1.715E-02, 4.922E-01, 1.151E-01 }, { 2238, 1.2890, 0.000E+00, 0.000E+00, 0.000E+00, 1.879E+01, 1.895E+01, 1.075E-01, 1.710E-02, 4.920E-01, 1.151E-01 }, { 2239, 1.2889, 0.000E+00, 0.000E+00, 0.000E+00, 1.883E+01, 1.913E+01, 1.073E-01, 1.705E-02, 4.919E-01, 1.151E-01 }, { 2240, 1.2888, 0.000E+00, 0.000E+00, 0.000E+00, 1.888E+01, 1.931E+01, 1.070E-01, 1.700E-02, 4.917E-01, 1.151E-01 }, { 2241, 1.2887, 0.000E+00, 0.000E+00, 0.000E+00, 1.893E+01, 1.951E+01, 1.065E-01, 1.695E-02, 4.914E-01, 1.151E-01 }, { 2242, 1.2886, 0.000E+00, 0.000E+00, 0.000E+00, 1.897E+01, 1.972E+01, 1.059E-01, 1.690E-02, 4.911E-01, 1.151E-01 }, { 2243, 1.2884, 0.000E+00, 0.000E+00, 0.000E+00, 1.903E+01, 1.994E+01, 1.054E-01, 1.685E-02, 4.908E-01, 1.151E-01 }, { 2244, 1.2883, 0.000E+00, 0.000E+00, 0.000E+00, 1.908E+01, 2.017E+01, 1.048E-01, 1.680E-02, 4.905E-01, 1.151E-01 }, { 2245, 1.2882, 0.000E+00, 0.000E+00, 0.000E+00, 1.913E+01, 2.040E+01, 1.043E-01, 1.675E-02, 4.902E-01, 1.151E-01 }, { 2246, 1.2881, 0.000E+00, 0.000E+00, 0.000E+00, 1.919E+01, 2.065E+01, 1.037E-01, 1.670E-02, 4.902E-01, 1.151E-01 }, { 2247, 1.2880, 0.000E+00, 0.000E+00, 0.000E+00, 1.924E+01, 2.089E+01, 1.032E-01, 1.665E-02, 4.902E-01, 1.151E-01 }, { 2248, 1.2878, 0.000E+00, 0.000E+00, 0.000E+00, 1.929E+01, 2.114E+01, 1.026E-01, 1.660E-02, 4.902E-01, 1.151E-01 }, { 2249, 1.2877, 0.000E+00, 0.000E+00, 0.000E+00, 1.934E+01, 2.140E+01, 1.021E-01, 1.655E-02, 4.901E-01, 1.151E-01 }, { 2250, 1.2876, 0.000E+00, 0.000E+00, 0.000E+00, 1.940E+01, 2.163E+01, 1.015E-01, 1.650E-02, 4.901E-01, 1.151E-01 }, { 2251, 1.2875, 0.000E+00, 0.000E+00, 0.000E+00, 1.946E+01, 2.186E+01, 1.010E-01, 1.645E-02, 4.901E-01, 1.150E-01 }, { 2252, 1.2874, 0.000E+00, 0.000E+00, 0.000E+00, 1.951E+01, 2.210E+01, 1.004E-01, 1.640E-02, 4.900E-01, 1.149E-01 }, { 2253, 1.2873, 0.000E+00, 0.000E+00, 0.000E+00, 1.961E+01, 2.236E+01, 9.985E-02, 1.635E-02, 4.899E-01, 1.148E-01 }, { 2254, 1.2872, 0.000E+00, 0.000E+00, 0.000E+00, 1.966E+01, 2.262E+01, 9.930E-02, 1.630E-02, 4.898E-01, 1.148E-01 }, { 2255, 1.2871, 0.000E+00, 0.000E+00, 0.000E+00, 1.973E+01, 2.290E+01, 9.875E-02, 1.625E-02, 4.897E-01, 1.147E-01 }, { 2256, 1.2870, 0.000E+00, 0.000E+00, 0.000E+00, 1.980E+01, 2.313E+01, 9.820E-02, 1.620E-02, 4.895E-01, 1.141E-01 }, { 2257, 1.2869, 0.000E+00, 0.000E+00, 0.000E+00, 1.985E+01, 2.339E+01, 9.765E-02, 1.615E-02, 4.893E-01, 1.134E-01 }, { 2258, 1.2867, 0.000E+00, 0.000E+00, 0.000E+00, 1.991E+01, 2.361E+01, 9.710E-02, 1.610E-02, 4.891E-01, 1.128E-01 }, { 2259, 1.2866, 0.000E+00, 0.000E+00, 0.000E+00, 1.997E+01, 2.386E+01, 9.655E-02, 1.605E-02, 4.889E-01, 1.121E-01 }, { 2260, 1.2865, 0.000E+00, 0.000E+00, 0.000E+00, 2.004E+01, 2.410E+01, 9.600E-02, 1.600E-02, 4.887E-01, 1.115E-01 }, { 2261, 1.2864, 0.000E+00, 0.000E+00, 0.000E+00, 2.013E+01, 2.434E+01, 9.590E-02, 1.595E-02, 4.889E-01, 1.115E-01 }, { 2262, 1.2863, 0.000E+00, 0.000E+00, 0.000E+00, 2.020E+01, 2.455E+01, 9.580E-02, 1.590E-02, 4.892E-01, 1.115E-01 }, { 2263, 1.2862, 0.000E+00, 0.000E+00, 0.000E+00, 2.027E+01, 2.479E+01, 9.570E-02, 1.585E-02, 4.894E-01, 1.114E-01 }, { 2264, 1.2861, 0.000E+00, 0.000E+00, 0.000E+00, 2.038E+01, 2.499E+01, 9.560E-02, 1.580E-02, 4.896E-01, 1.114E-01 }, { 2265, 1.2860, 0.000E+00, 0.000E+00, 0.000E+00, 2.046E+01, 2.521E+01, 9.550E-02, 1.575E-02, 4.898E-01, 1.114E-01 }, { 2266, 1.2859, 0.000E+00, 0.000E+00, 0.000E+00, 2.054E+01, 2.541E+01, 9.540E-02, 1.570E-02, 4.900E-01, 1.111E-01 }, { 2267, 1.2858, 0.000E+00, 0.000E+00, 0.000E+00, 2.062E+01, 2.562E+01, 9.530E-02, 1.565E-02, 4.902E-01, 1.108E-01 }, { 2268, 1.2856, 0.000E+00, 0.000E+00, 0.000E+00, 2.071E+01, 2.583E+01, 9.520E-02, 1.560E-02, 4.904E-01, 1.105E-01 }, { 2269, 1.2855, 0.000E+00, 0.000E+00, 0.000E+00, 2.079E+01, 2.605E+01, 9.510E-02, 1.555E-02, 4.906E-01, 1.102E-01 }, { 2270, 1.2854, 0.000E+00, 0.000E+00, 0.000E+00, 2.087E+01, 2.626E+01, 9.500E-02, 1.550E-02, 4.908E-01, 1.099E-01 }, { 2271, 1.2853, 0.000E+00, 0.000E+00, 0.000E+00, 2.094E+01, 2.643E+01, 9.490E-02, 1.545E-02, 4.910E-01, 1.097E-01 }, { 2272, 1.2852, 0.000E+00, 0.000E+00, 0.000E+00, 2.103E+01, 2.657E+01, 9.480E-02, 1.540E-02, 4.912E-01, 1.095E-01 }, { 2273, 1.2850, 0.000E+00, 0.000E+00, 0.000E+00, 2.111E+01, 2.674E+01, 9.470E-02, 1.535E-02, 4.914E-01, 1.093E-01 }, { 2274, 1.2849, 0.000E+00, 0.000E+00, 0.000E+00, 2.126E+01, 2.688E+01, 9.460E-02, 1.530E-02, 4.916E-01, 1.091E-01 }, { 2275, 1.2848, 0.000E+00, 0.000E+00, 0.000E+00, 2.135E+01, 2.701E+01, 9.450E-02, 1.525E-02, 4.918E-01, 1.089E-01 }, { 2276, 1.2847, 0.000E+00, 0.000E+00, 0.000E+00, 2.145E+01, 2.718E+01, 9.440E-02, 1.520E-02, 4.920E-01, 1.086E-01 }, { 2277, 1.2846, 0.000E+00, 0.000E+00, 0.000E+00, 2.153E+01, 2.732E+01, 9.430E-02, 1.515E-02, 4.923E-01, 1.084E-01 }, { 2278, 1.2845, 0.000E+00, 0.000E+00, 0.000E+00, 2.164E+01, 2.742E+01, 9.420E-02, 1.510E-02, 4.925E-01, 1.082E-01 }, { 2279, 1.2844, 0.000E+00, 0.000E+00, 0.000E+00, 2.174E+01, 2.754E+01, 9.410E-02, 1.505E-02, 4.927E-01, 1.079E-01 }, { 2280, 1.2843, 0.000E+00, 0.000E+00, 0.000E+00, 2.183E+01, 2.763E+01, 9.400E-02, 1.500E-02, 4.929E-01, 1.077E-01 }, { 2281, 1.2842, 0.000E+00, 0.000E+00, 0.000E+00, 2.192E+01, 2.777E+01, 9.355E-02, 1.495E-02, 4.926E-01, 1.074E-01 }, { 2282, 1.2841, 0.000E+00, 0.000E+00, 0.000E+00, 2.202E+01, 2.794E+01, 9.310E-02, 1.490E-02, 4.924E-01, 1.071E-01 }, { 2283, 1.2840, 0.000E+00, 0.000E+00, 0.000E+00, 2.212E+01, 2.804E+01, 9.265E-02, 1.485E-02, 4.921E-01, 1.068E-01 }, { 2284, 1.2839, 0.000E+00, 0.000E+00, 0.000E+00, 2.223E+01, 2.821E+01, 9.220E-02, 1.480E-02, 4.919E-01, 1.064E-01 }, { 2285, 1.2838, 0.000E+00, 0.000E+00, 0.000E+00, 2.234E+01, 2.836E+01, 9.175E-02, 1.475E-02, 4.916E-01, 1.061E-01 }, { 2286, 1.2837, 0.000E+00, 0.000E+00, 0.000E+00, 2.245E+01, 2.850E+01, 9.130E-02, 1.470E-02, 4.910E-01, 1.056E-01 }, { 2287, 1.2836, 0.000E+00, 0.000E+00, 0.000E+00, 2.264E+01, 2.863E+01, 9.085E-02, 1.465E-02, 4.904E-01, 1.051E-01 }, { 2288, 1.2834, 0.000E+00, 0.000E+00, 0.000E+00, 2.276E+01, 2.878E+01, 9.040E-02, 1.460E-02, 4.898E-01, 1.046E-01 }, { 2289, 1.2833, 0.000E+00, 0.000E+00, 0.000E+00, 2.287E+01, 2.896E+01, 8.995E-02, 1.455E-02, 4.892E-01, 1.041E-01 }, { 2290, 1.2832, 0.000E+00, 0.000E+00, 0.000E+00, 2.301E+01, 2.913E+01, 8.950E-02, 1.450E-02, 4.886E-01, 1.036E-01 }, { 2291, 1.2831, 0.000E+00, 0.000E+00, 0.000E+00, 2.313E+01, 2.922E+01, 8.905E-02, 1.445E-02, 4.885E-01, 1.029E-01 }, { 2292, 1.2830, 0.000E+00, 0.000E+00, 0.000E+00, 2.327E+01, 2.937E+01, 8.860E-02, 1.440E-02, 4.884E-01, 1.021E-01 }, { 2293, 1.2829, 0.000E+00, 0.000E+00, 0.000E+00, 2.338E+01, 2.947E+01, 8.815E-02, 1.435E-02, 4.883E-01, 1.013E-01 }, { 2294, 1.2828, 0.000E+00, 0.000E+00, 0.000E+00, 2.351E+01, 2.960E+01, 8.770E-02, 1.430E-02, 4.882E-01, 1.005E-01 }, { 2295, 1.2827, 0.000E+00, 0.000E+00, 0.000E+00, 2.363E+01, 2.970E+01, 8.725E-02, 1.425E-02, 4.882E-01, 9.971E-02 }, { 2296, 1.2826, 0.000E+00, 0.000E+00, 0.000E+00, 2.377E+01, 2.982E+01, 8.680E-02, 1.420E-02, 4.879E-01, 9.941E-02 }, { 2297, 1.2825, 0.000E+00, 0.000E+00, 0.000E+00, 2.385E+01, 2.997E+01, 8.635E-02, 1.415E-02, 4.875E-01, 9.910E-02 }, { 2298, 1.2824, 0.000E+00, 0.000E+00, 0.000E+00, 2.409E+01, 3.006E+01, 8.590E-02, 1.410E-02, 4.872E-01, 9.879E-02 }, { 2299, 1.2823, 0.000E+00, 0.000E+00, 0.000E+00, 2.418E+01, 3.018E+01, 8.545E-02, 1.405E-02, 4.869E-01, 9.849E-02 }, { 2300, 1.2822, 0.000E+00, 0.000E+00, 0.000E+00, 2.433E+01, 3.028E+01, 8.500E-02, 1.400E-02, 4.866E-01, 9.818E-02 }, { 2301, 1.2821, 0.000E+00, 0.000E+00, 0.000E+00, 2.444E+01, 3.040E+01, 8.430E-02, 1.385E-02, 4.863E-01, 9.818E-02 }, { 2302, 1.2820, 0.000E+00, 0.000E+00, 0.000E+00, 2.459E+01, 3.053E+01, 8.360E-02, 1.370E-02, 4.860E-01, 9.818E-02 }, { 2303, 1.2818, 0.000E+00, 0.000E+00, 0.000E+00, 2.470E+01, 3.060E+01, 8.290E-02, 1.355E-02, 4.857E-01, 9.817E-02 }, { 2304, 1.2817, 0.000E+00, 0.000E+00, 0.000E+00, 2.485E+01, 3.066E+01, 8.220E-02, 1.340E-02, 4.853E-01, 9.817E-02 }, { 2305, 1.2816, 0.000E+00, 0.000E+00, 0.000E+00, 2.495E+01, 3.070E+01, 8.150E-02, 1.325E-02, 4.850E-01, 9.817E-02 }, { 2306, 1.2815, 0.000E+00, 0.000E+00, 0.000E+00, 2.523E+01, 3.076E+01, 8.080E-02, 1.310E-02, 4.847E-01, 9.817E-02 }, { 2307, 1.2814, 0.000E+00, 0.000E+00, 0.000E+00, 2.534E+01, 3.078E+01, 8.010E-02, 1.295E-02, 4.844E-01, 9.817E-02 }, { 2308, 1.2813, 0.000E+00, 0.000E+00, 0.000E+00, 2.549E+01, 3.075E+01, 7.940E-02, 1.280E-02, 4.841E-01, 9.816E-02 }, { 2309, 1.2812, 0.000E+00, 0.000E+00, 0.000E+00, 2.564E+01, 3.074E+01, 7.870E-02, 1.265E-02, 4.838E-01, 9.816E-02 }, { 2310, 1.2811, 0.000E+00, 0.000E+00, 0.000E+00, 2.579E+01, 3.072E+01, 7.800E-02, 1.250E-02, 4.835E-01, 9.816E-02 }, { 2311, 1.2810, 0.000E+00, 0.000E+00, 0.000E+00, 2.592E+01, 3.065E+01, 7.730E-02, 1.235E-02, 4.832E-01, 9.809E-02 }, { 2312, 1.2809, 0.000E+00, 0.000E+00, 0.000E+00, 2.611E+01, 3.058E+01, 7.660E-02, 1.220E-02, 4.830E-01, 9.802E-02 }, { 2313, 1.2808, 0.000E+00, 0.000E+00, 0.000E+00, 2.623E+01, 3.051E+01, 7.590E-02, 1.205E-02, 4.828E-01, 9.795E-02 }, { 2314, 1.2807, 0.000E+00, 0.000E+00, 0.000E+00, 2.653E+01, 3.045E+01, 7.520E-02, 1.190E-02, 4.825E-01, 9.788E-02 }, { 2315, 1.2806, 0.000E+00, 0.000E+00, 0.000E+00, 2.664E+01, 3.034E+01, 7.450E-02, 1.175E-02, 4.823E-01, 9.781E-02 }, { 2316, 1.2805, 0.000E+00, 0.000E+00, 0.000E+00, 2.681E+01, 3.029E+01, 7.380E-02, 1.160E-02, 4.823E-01, 9.741E-02 }, { 2317, 1.2804, 0.000E+00, 0.000E+00, 0.000E+00, 2.695E+01, 3.023E+01, 7.310E-02, 1.145E-02, 4.823E-01, 9.700E-02 }, { 2318, 1.2803, 0.000E+00, 0.000E+00, 0.000E+00, 2.712E+01, 3.015E+01, 7.240E-02, 1.130E-02, 4.823E-01, 9.660E-02 }, { 2319, 1.2802, 0.000E+00, 0.000E+00, 0.000E+00, 2.727E+01, 3.004E+01, 7.170E-02, 1.115E-02, 4.823E-01, 9.620E-02 }, { 2320, 1.2801, 0.000E+00, 0.000E+00, 0.000E+00, 2.744E+01, 3.000E+01, 7.100E-02, 1.100E-02, 4.823E-01, 9.580E-02 }, { 2321, 1.2800, 0.000E+00, 0.000E+00, 0.000E+00, 2.756E+01, 2.998E+01, 7.105E-02, 1.100E-02, 4.823E-01, 9.537E-02 }, { 2322, 1.2799, 0.000E+00, 0.000E+00, 0.000E+00, 2.789E+01, 2.991E+01, 7.110E-02, 1.100E-02, 4.823E-01, 9.495E-02 }, { 2323, 1.2799, 0.000E+00, 0.000E+00, 0.000E+00, 2.802E+01, 2.986E+01, 7.115E-02, 1.100E-02, 4.823E-01, 9.453E-02 }, { 2324, 1.2798, 0.000E+00, 0.000E+00, 0.000E+00, 2.819E+01, 2.984E+01, 7.120E-02, 1.100E-02, 4.823E-01, 9.411E-02 }, { 2325, 1.2797, 0.000E+00, 0.000E+00, 0.000E+00, 2.838E+01, 2.981E+01, 7.125E-02, 1.100E-02, 4.823E-01, 9.369E-02 }, { 2326, 1.2796, 0.000E+00, 0.000E+00, 0.000E+00, 2.855E+01, 2.976E+01, 7.130E-02, 1.100E-02, 4.822E-01, 9.319E-02 }, { 2327, 1.2795, 0.000E+00, 0.000E+00, 0.000E+00, 2.869E+01, 2.973E+01, 7.135E-02, 1.100E-02, 4.822E-01, 9.269E-02 }, { 2328, 1.2795, 0.000E+00, 0.000E+00, 0.000E+00, 2.903E+01, 2.976E+01, 7.140E-02, 1.100E-02, 4.822E-01, 9.219E-02 }, { 2329, 1.2794, 0.000E+00, 0.000E+00, 0.000E+00, 2.916E+01, 2.977E+01, 7.145E-02, 1.100E-02, 4.822E-01, 9.169E-02 }, { 2330, 1.2793, 0.000E+00, 0.000E+00, 0.000E+00, 2.934E+01, 2.979E+01, 7.150E-02, 1.100E-02, 4.822E-01, 9.118E-02 }, { 2331, 1.2792, 0.000E+00, 0.000E+00, 0.000E+00, 2.951E+01, 2.981E+01, 7.155E-02, 1.100E-02, 4.817E-01, 9.118E-02 }, { 2332, 1.2791, 0.000E+00, 0.000E+00, 0.000E+00, 2.969E+01, 2.985E+01, 7.160E-02, 1.100E-02, 4.813E-01, 9.118E-02 }, { 2333, 1.2791, 0.000E+00, 0.000E+00, 0.000E+00, 2.988E+01, 2.989E+01, 7.165E-02, 1.100E-02, 4.809E-01, 9.118E-02 }, { 2334, 1.2790, 0.000E+00, 0.000E+00, 0.000E+00, 3.002E+01, 2.999E+01, 7.170E-02, 1.100E-02, 4.805E-01, 9.117E-02 }, { 2335, 1.2789, 0.000E+00, 0.000E+00, 0.000E+00, 3.038E+01, 3.000E+01, 7.175E-02, 1.100E-02, 4.801E-01, 9.117E-02 }, { 2336, 1.2788, 0.000E+00, 0.000E+00, 0.000E+00, 3.054E+01, 3.005E+01, 7.180E-02, 1.100E-02, 4.797E-01, 9.078E-02 }, { 2337, 1.2788, 0.000E+00, 0.000E+00, 0.000E+00, 3.073E+01, 3.007E+01, 7.185E-02, 1.100E-02, 4.793E-01, 9.039E-02 }, { 2338, 1.2787, 0.000E+00, 0.000E+00, 0.000E+00, 3.092E+01, 3.011E+01, 7.190E-02, 1.100E-02, 4.789E-01, 9.000E-02 }, { 2339, 1.2787, 0.000E+00, 0.000E+00, 0.000E+00, 3.107E+01, 3.017E+01, 7.195E-02, 1.100E-02, 4.785E-01, 8.961E-02 }, { 2340, 1.2786, 0.000E+00, 0.000E+00, 0.000E+00, 3.145E+01, 3.022E+01, 7.200E-02, 1.100E-02, 4.781E-01, 8.922E-02 }, { 2341, 1.2785, 0.000E+00, 0.000E+00, 0.000E+00, 3.160E+01, 3.023E+01, 7.195E-02, 1.100E-02, 4.778E-01, 8.888E-02 }, { 2342, 1.2785, 0.000E+00, 0.000E+00, 0.000E+00, 3.180E+01, 3.029E+01, 7.190E-02, 1.100E-02, 4.776E-01, 8.853E-02 }, { 2343, 1.2784, 0.000E+00, 0.000E+00, 0.000E+00, 3.199E+01, 3.028E+01, 7.185E-02, 1.100E-02, 4.773E-01, 8.819E-02 }, { 2344, 1.2784, 0.000E+00, 0.000E+00, 0.000E+00, 3.219E+01, 3.029E+01, 7.180E-02, 1.100E-02, 4.771E-01, 8.785E-02 }, { 2345, 1.2783, 0.000E+00, 0.000E+00, 0.000E+00, 3.238E+01, 3.027E+01, 7.175E-02, 1.100E-02, 4.768E-01, 8.750E-02 }, { 2346, 1.2782, 0.000E+00, 0.000E+00, 0.000E+00, 3.272E+01, 3.027E+01, 7.170E-02, 1.100E-02, 4.769E-01, 8.779E-02 }, { 2347, 1.2781, 0.000E+00, 0.000E+00, 0.000E+00, 3.290E+01, 3.024E+01, 7.165E-02, 1.100E-02, 4.770E-01, 8.808E-02 }, { 2348, 1.2780, 0.000E+00, 0.000E+00, 0.000E+00, 3.311E+01, 3.019E+01, 7.160E-02, 1.100E-02, 4.770E-01, 8.837E-02 }, { 2349, 1.2779, 0.000E+00, 0.000E+00, 0.000E+00, 3.331E+01, 3.010E+01, 7.155E-02, 1.100E-02, 4.771E-01, 8.866E-02 }, { 2350, 1.2778, 0.000E+00, 0.000E+00, 0.000E+00, 3.348E+01, 3.010E+01, 7.150E-02, 1.100E-02, 4.772E-01, 8.895E-02 }, { 2351, 1.2777, 0.000E+00, 0.000E+00, 0.000E+00, 3.388E+01, 3.003E+01, 7.145E-02, 1.100E-02, 4.773E-01, 8.865E-02 }, { 2352, 1.2776, 0.000E+00, 0.000E+00, 0.000E+00, 3.404E+01, 2.993E+01, 7.140E-02, 1.100E-02, 4.773E-01, 8.836E-02 }, { 2353, 1.2776, 0.000E+00, 0.000E+00, 0.000E+00, 3.426E+01, 2.983E+01, 7.135E-02, 1.100E-02, 4.774E-01, 8.807E-02 }, { 2354, 1.2775, 0.000E+00, 0.000E+00, 0.000E+00, 3.447E+01, 2.984E+01, 7.130E-02, 1.100E-02, 4.775E-01, 8.777E-02 }, { 2355, 1.2774, 0.000E+00, 0.000E+00, 0.000E+00, 3.468E+01, 2.975E+01, 7.125E-02, 1.100E-02, 4.775E-01, 8.748E-02 }, { 2356, 1.2773, 0.000E+00, 0.000E+00, 0.000E+00, 3.486E+01, 2.966E+01, 7.120E-02, 1.100E-02, 4.776E-01, 8.680E-02 }, { 2357, 1.2772, 0.000E+00, 0.000E+00, 0.000E+00, 3.528E+01, 2.958E+01, 7.115E-02, 1.100E-02, 4.777E-01, 8.613E-02 }, { 2358, 1.2771, 0.000E+00, 0.000E+00, 0.000E+00, 3.547E+01, 2.948E+01, 7.110E-02, 1.100E-02, 4.778E-01, 8.546E-02 }, { 2359, 1.2770, 0.000E+00, 0.000E+00, 0.000E+00, 3.570E+01, 2.930E+01, 7.105E-02, 1.100E-02, 4.779E-01, 8.478E-02 }, { 2360, 1.2769, 0.000E+00, 0.000E+00, 0.000E+00, 3.592E+01, 2.926E+01, 7.100E-02, 1.100E-02, 4.780E-01, 8.411E-02 }, { 2361, 1.2768, 0.000E+00, 0.000E+00, 0.000E+00, 3.610E+01, 2.920E+01, 7.025E-02, 1.090E-02, 4.778E-01, 8.332E-02 }, { 2362, 1.2767, 0.000E+00, 0.000E+00, 0.000E+00, 3.656E+01, 2.913E+01, 6.950E-02, 1.080E-02, 4.777E-01, 8.254E-02 }, { 2363, 1.2766, 0.000E+00, 0.000E+00, 0.000E+00, 3.675E+01, 2.902E+01, 6.875E-02, 1.070E-02, 4.776E-01, 8.176E-02 }, { 2364, 1.2765, 0.000E+00, 0.000E+00, 0.000E+00, 3.697E+01, 2.890E+01, 6.800E-02, 1.060E-02, 4.774E-01, 8.097E-02 }, { 2365, 1.2764, 0.000E+00, 0.000E+00, 0.000E+00, 3.716E+01, 2.882E+01, 6.725E-02, 1.050E-02, 4.773E-01, 8.019E-02 }, { 2366, 1.2763, 0.000E+00, 0.000E+00, 0.000E+00, 3.761E+01, 2.872E+01, 6.650E-02, 1.040E-02, 4.770E-01, 8.011E-02 }, { 2367, 1.2762, 0.000E+00, 0.000E+00, 0.000E+00, 3.777E+01, 2.873E+01, 6.575E-02, 1.030E-02, 4.767E-01, 8.003E-02 }, { 2368, 1.2761, 0.000E+00, 0.000E+00, 0.000E+00, 3.801E+01, 2.870E+01, 6.500E-02, 1.020E-02, 4.765E-01, 7.995E-02 }, { 2369, 1.2760, 0.000E+00, 0.000E+00, 0.000E+00, 3.827E+01, 2.865E+01, 6.425E-02, 1.010E-02, 4.762E-01, 7.987E-02 }, { 2370, 1.2759, 0.000E+00, 0.000E+00, 0.000E+00, 3.848E+01, 2.858E+01, 6.350E-02, 1.000E-02, 4.759E-01, 7.979E-02 }, { 2371, 1.2758, 0.000E+00, 0.000E+00, 0.000E+00, 3.892E+01, 2.854E+01, 6.275E-02, 9.900E-03, 4.756E-01, 7.946E-02 }, { 2372, 1.2757, 0.000E+00, 0.000E+00, 0.000E+00, 3.913E+01, 2.850E+01, 6.200E-02, 9.800E-03, 4.754E-01, 7.914E-02 }, { 2373, 1.2757, 0.000E+00, 0.000E+00, 0.000E+00, 3.938E+01, 2.846E+01, 6.125E-02, 9.700E-03, 4.751E-01, 7.882E-02 }, { 2374, 1.2756, 0.000E+00, 0.000E+00, 0.000E+00, 3.957E+01, 2.838E+01, 6.050E-02, 9.600E-03, 4.748E-01, 7.849E-02 }, { 2375, 1.2755, 0.000E+00, 0.000E+00, 0.000E+00, 4.007E+01, 2.834E+01, 5.975E-02, 9.500E-03, 4.745E-01, 7.817E-02 }, { 2376, 1.2754, 0.000E+00, 0.000E+00, 0.000E+00, 4.024E+01, 2.823E+01, 5.900E-02, 9.400E-03, 4.747E-01, 7.754E-02 }, { 2377, 1.2753, 0.000E+00, 0.000E+00, 0.000E+00, 4.050E+01, 2.820E+01, 5.825E-02, 9.300E-03, 4.748E-01, 7.691E-02 }, { 2378, 1.2753, 0.000E+00, 0.000E+00, 0.000E+00, 4.078E+01, 2.817E+01, 5.750E-02, 9.200E-03, 4.749E-01, 7.628E-02 }, { 2379, 1.2752, 0.000E+00, 0.000E+00, 0.000E+00, 4.096E+01, 2.809E+01, 5.675E-02, 9.100E-03, 4.750E-01, 7.565E-02 }, { 2380, 1.2751, 0.000E+00, 0.000E+00, 0.000E+00, 4.147E+01, 2.803E+01, 5.600E-02, 9.000E-03, 4.752E-01, 7.502E-02 }, { 2381, 1.2750, 0.000E+00, 0.000E+00, 0.000E+00, 4.167E+01, 2.803E+01, 5.685E-02, 9.100E-03, 4.752E-01, 7.496E-02 }, { 2382, 1.2749, 0.000E+00, 0.000E+00, 0.000E+00, 4.196E+01, 2.801E+01, 5.770E-02, 9.200E-03, 4.753E-01, 7.489E-02 }, { 2383, 1.2749, 0.000E+00, 0.000E+00, 0.000E+00, 4.220E+01, 2.794E+01, 5.855E-02, 9.300E-03, 4.754E-01, 7.483E-02 }, { 2384, 1.2748, 0.000E+00, 0.000E+00, 0.000E+00, 4.268E+01, 2.791E+01, 5.940E-02, 9.400E-03, 4.755E-01, 7.476E-02 }, { 2385, 1.2747, 0.000E+00, 0.000E+00, 0.000E+00, 4.293E+01, 2.790E+01, 6.025E-02, 9.500E-03, 4.755E-01, 7.470E-02 }, { 2386, 1.2746, 0.000E+00, 0.000E+00, 0.000E+00, 4.319E+01, 2.784E+01, 6.110E-02, 9.600E-03, 4.752E-01, 7.394E-02 }, { 2387, 1.2745, 0.000E+00, 0.000E+00, 0.000E+00, 4.342E+01, 2.779E+01, 6.195E-02, 9.700E-03, 4.748E-01, 7.318E-02 }, { 2388, 1.2745, 0.000E+00, 0.000E+00, 0.000E+00, 4.388E+01, 2.781E+01, 6.280E-02, 9.800E-03, 4.744E-01, 7.242E-02 }, { 2389, 1.2744, 0.000E+00, 0.000E+00, 0.000E+00, 4.413E+01, 2.782E+01, 6.365E-02, 9.900E-03, 4.740E-01, 7.167E-02 }, { 2390, 1.2743, 0.000E+00, 0.000E+00, 0.000E+00, 4.439E+01, 2.781E+01, 6.450E-02, 1.000E-02, 4.736E-01, 7.091E-02 }, { 2391, 1.2742, 0.000E+00, 0.000E+00, 0.000E+00, 4.464E+01, 2.781E+01, 6.535E-02, 1.010E-02, 4.736E-01, 7.083E-02 }, { 2392, 1.2742, 0.000E+00, 0.000E+00, 0.000E+00, 4.513E+01, 2.783E+01, 6.620E-02, 1.020E-02, 4.735E-01, 7.074E-02 }, { 2393, 1.2741, 0.000E+00, 0.000E+00, 0.000E+00, 4.538E+01, 2.785E+01, 6.705E-02, 1.030E-02, 4.734E-01, 7.066E-02 }, { 2394, 1.2741, 0.000E+00, 0.000E+00, 0.000E+00, 4.565E+01, 2.785E+01, 6.790E-02, 1.040E-02, 4.734E-01, 7.058E-02 }, { 2395, 1.2740, 0.000E+00, 0.000E+00, 0.000E+00, 4.590E+01, 2.782E+01, 6.875E-02, 1.050E-02, 4.733E-01, 7.050E-02 }, { 2396, 1.2739, 0.000E+00, 0.000E+00, 0.000E+00, 4.638E+01, 2.782E+01, 6.960E-02, 1.060E-02, 4.731E-01, 7.015E-02 }, { 2397, 1.2739, 0.000E+00, 0.000E+00, 0.000E+00, 4.663E+01, 2.779E+01, 7.045E-02, 1.070E-02, 4.729E-01, 6.981E-02 }, { 2398, 1.2738, 0.000E+00, 0.000E+00, 0.000E+00, 4.690E+01, 2.779E+01, 7.130E-02, 1.080E-02, 4.727E-01, 6.946E-02 }, { 2399, 1.2738, 0.000E+00, 0.000E+00, 0.000E+00, 4.714E+01, 2.778E+01, 7.215E-02, 1.090E-02, 4.725E-01, 6.912E-02 }, { 2400, 1.2737, 0.000E+00, 0.000E+00, 0.000E+00, 4.764E+01, 2.783E+01, 7.300E-02, 1.100E-02, 4.723E-01, 6.878E-02 }, { 2401, 1.2736, 0.000E+00, 0.000E+00, 0.000E+00, 4.787E+01, 2.784E+01, 7.085E-02, 1.070E-02, 4.718E-01, 6.878E-02 }, { 2402, 1.2736, 0.000E+00, 0.000E+00, 0.000E+00, 4.817E+01, 2.788E+01, 6.870E-02, 1.040E-02, 4.714E-01, 6.877E-02 }, { 2403, 1.2735, 0.000E+00, 0.000E+00, 0.000E+00, 4.836E+01, 2.791E+01, 6.655E-02, 1.010E-02, 4.709E-01, 6.877E-02 }, { 2404, 1.2735, 0.000E+00, 0.000E+00, 0.000E+00, 4.894E+01, 2.799E+01, 6.440E-02, 9.800E-03, 4.704E-01, 6.877E-02 }, { 2405, 1.2734, 0.000E+00, 0.000E+00, 0.000E+00, 4.917E+01, 2.804E+01, 6.225E-02, 9.500E-03, 4.699E-01, 6.877E-02 }, { 2406, 1.2733, 0.000E+00, 0.000E+00, 0.000E+00, 4.940E+01, 2.812E+01, 6.010E-02, 9.200E-03, 4.695E-01, 6.803E-02 }, { 2407, 1.2733, 0.000E+00, 0.000E+00, 0.000E+00, 4.997E+01, 2.811E+01, 5.795E-02, 8.900E-03, 4.691E-01, 6.730E-02 }, { 2408, 1.2732, 0.000E+00, 0.000E+00, 0.000E+00, 5.021E+01, 2.819E+01, 5.580E-02, 8.600E-03, 4.686E-01, 6.657E-02 }, { 2409, 1.2732, 0.000E+00, 0.000E+00, 0.000E+00, 5.050E+01, 2.819E+01, 5.365E-02, 8.300E-03, 4.682E-01, 6.584E-02 }, { 2410, 1.2731, 0.000E+00, 0.000E+00, 0.000E+00, 5.078E+01, 2.817E+01, 5.150E-02, 8.000E-03, 4.678E-01, 6.511E-02 }, { 2411, 1.2730, 0.000E+00, 0.000E+00, 0.000E+00, 5.131E+01, 2.817E+01, 4.935E-02, 7.700E-03, 4.678E-01, 6.445E-02 }, { 2412, 1.2730, 0.000E+00, 0.000E+00, 0.000E+00, 5.159E+01, 2.831E+01, 4.720E-02, 7.400E-03, 4.678E-01, 6.379E-02 }, { 2413, 1.2729, 0.000E+00, 0.000E+00, 0.000E+00, 5.191E+01, 2.837E+01, 4.505E-02, 7.100E-03, 4.678E-01, 6.313E-02 }, { 2414, 1.2729, 0.000E+00, 0.000E+00, 0.000E+00, 5.246E+01, 2.848E+01, 4.290E-02, 6.800E-03, 4.678E-01, 6.247E-02 }, { 2415, 1.2728, 0.000E+00, 0.000E+00, 0.000E+00, 5.275E+01, 2.853E+01, 4.075E-02, 6.500E-03, 4.678E-01, 6.182E-02 }, { 2416, 1.2727, 0.000E+00, 0.000E+00, 0.000E+00, 5.310E+01, 2.859E+01, 3.860E-02, 6.200E-03, 4.678E-01, 6.167E-02 }, { 2417, 1.2727, 0.000E+00, 0.000E+00, 0.000E+00, 5.339E+01, 2.870E+01, 3.645E-02, 5.900E-03, 4.677E-01, 6.153E-02 }, { 2418, 1.2726, 0.000E+00, 0.000E+00, 0.000E+00, 5.401E+01, 2.874E+01, 3.430E-02, 5.600E-03, 4.677E-01, 6.138E-02 }, { 2419, 1.2726, 0.000E+00, 0.000E+00, 0.000E+00, 5.429E+01, 2.887E+01, 3.215E-02, 5.300E-03, 4.677E-01, 6.124E-02 }, { 2420, 1.2725, 0.000E+00, 0.000E+00, 0.000E+00, 5.462E+01, 2.898E+01, 3.000E-02, 5.000E-03, 4.677E-01, 6.110E-02 }, { 2421, 1.2725, 0.000E+00, 0.000E+00, 0.000E+00, 5.523E+01, 2.910E+01, 3.195E-02, 5.250E-03, 4.675E-01, 6.018E-02 }, { 2422, 1.2724, 0.000E+00, 0.000E+00, 0.000E+00, 5.555E+01, 2.923E+01, 3.390E-02, 5.500E-03, 4.673E-01, 5.927E-02 }, { 2423, 1.2724, 0.000E+00, 0.000E+00, 0.000E+00, 5.588E+01, 2.934E+01, 3.585E-02, 5.750E-03, 4.671E-01, 5.835E-02 }, { 2424, 1.2723, 0.000E+00, 0.000E+00, 0.000E+00, 5.618E+01, 2.944E+01, 3.780E-02, 6.000E-03, 4.668E-01, 5.743E-02 }, { 2425, 1.2723, 0.000E+00, 0.000E+00, 0.000E+00, 5.686E+01, 2.959E+01, 3.975E-02, 6.250E-03, 4.666E-01, 5.652E-02 }, { 2426, 1.2722, 0.000E+00, 0.000E+00, 0.000E+00, 5.713E+01, 2.973E+01, 4.170E-02, 6.500E-03, 4.662E-01, 5.619E-02 }, { 2427, 1.2722, 0.000E+00, 0.000E+00, 0.000E+00, 5.746E+01, 2.987E+01, 4.365E-02, 6.750E-03, 4.658E-01, 5.585E-02 }, { 2428, 1.2721, 0.000E+00, 0.000E+00, 0.000E+00, 5.808E+01, 3.002E+01, 4.560E-02, 7.000E-03, 4.653E-01, 5.552E-02 }, { 2429, 1.2721, 0.000E+00, 0.000E+00, 0.000E+00, 5.841E+01, 3.016E+01, 4.755E-02, 7.250E-03, 4.649E-01, 5.519E-02 }, { 2430, 1.2720, 0.000E+00, 0.000E+00, 0.000E+00, 5.878E+01, 3.035E+01, 4.950E-02, 7.500E-03, 4.645E-01, 5.485E-02 }, { 2431, 1.2720, 0.000E+00, 0.000E+00, 0.000E+00, 5.946E+01, 3.043E+01, 5.145E-02, 7.750E-03, 4.640E-01, 5.485E-02 }, { 2432, 1.2719, 0.000E+00, 0.000E+00, 0.000E+00, 5.976E+01, 3.064E+01, 5.340E-02, 8.000E-03, 4.636E-01, 5.485E-02 }, { 2433, 1.2719, 0.000E+00, 0.000E+00, 0.000E+00, 6.009E+01, 3.084E+01, 5.535E-02, 8.250E-03, 4.632E-01, 5.485E-02 }, { 2434, 1.2718, 0.000E+00, 0.000E+00, 0.000E+00, 6.039E+01, 3.098E+01, 5.730E-02, 8.500E-03, 4.627E-01, 5.484E-02 }, { 2435, 1.2718, 0.000E+00, 0.000E+00, 0.000E+00, 6.107E+01, 3.122E+01, 5.925E-02, 8.750E-03, 4.623E-01, 5.484E-02 }, { 2436, 1.2717, 0.000E+00, 0.000E+00, 0.000E+00, 6.146E+01, 3.132E+01, 6.120E-02, 9.000E-03, 4.620E-01, 5.455E-02 }, { 2437, 1.2717, 0.000E+00, 0.000E+00, 0.000E+00, 6.180E+01, 3.151E+01, 6.315E-02, 9.250E-03, 4.616E-01, 5.425E-02 }, { 2438, 1.2716, 0.000E+00, 0.000E+00, 0.000E+00, 6.250E+01, 3.164E+01, 6.510E-02, 9.500E-03, 4.613E-01, 5.396E-02 }, { 2439, 1.2716, 0.000E+00, 0.000E+00, 0.000E+00, 6.286E+01, 3.184E+01, 6.705E-02, 9.750E-03, 4.609E-01, 5.366E-02 }, { 2440, 1.2715, 0.000E+00, 0.000E+00, 0.000E+00, 6.316E+01, 3.204E+01, 6.900E-02, 1.000E-02, 4.606E-01, 5.337E-02 }, { 2441, 1.2715, 0.000E+00, 0.000E+00, 0.000E+00, 6.392E+01, 3.221E+01, 6.755E-02, 9.800E-03, 4.602E-01, 5.337E-02 }, { 2442, 1.2714, 0.000E+00, 0.000E+00, 0.000E+00, 6.427E+01, 3.233E+01, 6.610E-02, 9.600E-03, 4.599E-01, 5.337E-02 }, { 2443, 1.2714, 0.000E+00, 0.000E+00, 0.000E+00, 6.462E+01, 3.255E+01, 6.465E-02, 9.400E-03, 4.595E-01, 5.336E-02 }, { 2444, 1.2713, 0.000E+00, 0.000E+00, 0.000E+00, 6.539E+01, 3.282E+01, 6.320E-02, 9.200E-03, 4.592E-01, 5.336E-02 }, { 2445, 1.2713, 0.000E+00, 0.000E+00, 0.000E+00, 6.574E+01, 3.315E+01, 6.175E-02, 9.000E-03, 4.588E-01, 5.336E-02 }, { 2446, 1.2713, 0.000E+00, 0.000E+00, 0.000E+00, 6.609E+01, 3.339E+01, 6.030E-02, 8.800E-03, 4.585E-01, 5.316E-02 }, { 2447, 1.2713, 0.000E+00, 0.000E+00, 0.000E+00, 6.685E+01, 3.360E+01, 5.885E-02, 8.600E-03, 4.581E-01, 5.297E-02 }, { 2448, 1.2712, 0.000E+00, 0.000E+00, 0.000E+00, 6.725E+01, 3.384E+01, 5.740E-02, 8.400E-03, 4.578E-01, 5.278E-02 }, { 2449, 1.2712, 0.000E+00, 0.000E+00, 0.000E+00, 6.759E+01, 3.410E+01, 5.595E-02, 8.200E-03, 4.574E-01, 5.258E-02 }, { 2450, 1.2712, 0.000E+00, 0.000E+00, 0.000E+00, 6.842E+01, 3.426E+01, 5.450E-02, 8.000E-03, 4.571E-01, 5.239E-02 }, { 2451, 1.2712, 0.000E+00, 0.000E+00, 0.000E+00, 6.881E+01, 3.452E+01, 5.305E-02, 7.800E-03, 4.567E-01, 5.192E-02 }, { 2452, 1.2711, 0.000E+00, 0.000E+00, 0.000E+00, 6.918E+01, 3.472E+01, 5.160E-02, 7.600E-03, 4.564E-01, 5.145E-02 }, { 2453, 1.2711, 0.000E+00, 0.000E+00, 0.000E+00, 7.009E+01, 3.497E+01, 5.015E-02, 7.400E-03, 4.561E-01, 5.099E-02 }, { 2454, 1.2710, 0.000E+00, 0.000E+00, 0.000E+00, 7.046E+01, 3.519E+01, 4.870E-02, 7.200E-03, 4.557E-01, 5.052E-02 }, { 2455, 1.2710, 0.000E+00, 0.000E+00, 0.000E+00, 7.084E+01, 3.539E+01, 4.725E-02, 7.000E-03, 4.554E-01, 5.005E-02 }, { 2456, 1.2710, 0.000E+00, 0.000E+00, 0.000E+00, 7.174E+01, 3.561E+01, 4.580E-02, 6.800E-03, 4.551E-01, 4.963E-02 }, { 2457, 1.2710, 0.000E+00, 0.000E+00, 0.000E+00, 7.212E+01, 3.578E+01, 4.435E-02, 6.600E-03, 4.548E-01, 4.921E-02 }, { 2458, 1.2709, 0.000E+00, 0.000E+00, 0.000E+00, 7.249E+01, 3.604E+01, 4.290E-02, 6.400E-03, 4.545E-01, 4.878E-02 }, { 2459, 1.2709, 0.000E+00, 0.000E+00, 0.000E+00, 7.340E+01, 3.618E+01, 4.145E-02, 6.200E-03, 4.541E-01, 4.836E-02 }, { 2460, 1.2709, 0.000E+00, 0.000E+00, 0.000E+00, 7.381E+01, 3.636E+01, 4.000E-02, 6.000E-03, 4.538E-01, 4.793E-02 }, { 2461, 1.2709, 0.000E+00, 0.000E+00, 0.000E+00, 7.423E+01, 3.660E+01, 3.960E-02, 5.950E-03, 4.535E-01, 4.777E-02 }, { 2462, 1.2709, 0.000E+00, 0.000E+00, 0.000E+00, 7.514E+01, 3.674E+01, 3.920E-02, 5.900E-03, 4.532E-01, 4.761E-02 }, { 2463, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.554E+01, 3.682E+01, 3.880E-02, 5.850E-03, 4.529E-01, 4.744E-02 }, { 2464, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.591E+01, 3.699E+01, 3.840E-02, 5.800E-03, 4.526E-01, 4.728E-02 }, { 2465, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.675E+01, 3.711E+01, 3.800E-02, 5.750E-03, 4.523E-01, 4.711E-02 }, { 2466, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.718E+01, 3.735E+01, 3.760E-02, 5.700E-03, 4.522E-01, 4.727E-02 }, { 2467, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.801E+01, 3.758E+01, 3.720E-02, 5.650E-03, 4.521E-01, 4.743E-02 }, { 2468, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.839E+01, 3.792E+01, 3.680E-02, 5.600E-03, 4.521E-01, 4.759E-02 }, { 2469, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.880E+01, 3.796E+01, 3.640E-02, 5.550E-03, 4.520E-01, 4.774E-02 }, { 2470, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 7.970E+01, 3.812E+01, 3.600E-02, 5.500E-03, 4.519E-01, 4.790E-02 }, { 2471, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 8.005E+01, 3.821E+01, 3.560E-02, 5.450E-03, 4.518E-01, 4.796E-02 }, { 2472, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 8.046E+01, 3.833E+01, 3.520E-02, 5.400E-03, 4.518E-01, 4.801E-02 }, { 2473, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 8.136E+01, 3.856E+01, 3.480E-02, 5.350E-03, 4.517E-01, 4.807E-02 }, { 2474, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 8.173E+01, 3.874E+01, 3.440E-02, 5.300E-03, 4.516E-01, 4.813E-02 }, { 2475, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 8.215E+01, 3.877E+01, 3.400E-02, 5.250E-03, 4.516E-01, 4.818E-02 }, { 2476, 1.2708, 0.000E+00, 0.000E+00, 0.000E+00, 8.295E+01, 3.884E+01, 3.360E-02, 5.200E-03, 4.513E-01, 4.833E-02 }, { 2477, 1.2709, 0.000E+00, 0.000E+00, 0.000E+00, 8.338E+01, 3.883E+01, 3.320E-02, 5.150E-03, 4.510E-01, 4.847E-02 }, { 2478, 1.2709, 0.000E+00, 0.000E+00, 0.000E+00, 8.423E+01, 3.879E+01, 3.280E-02, 5.100E-03, 4.507E-01, 4.861E-02 }, { 2479, 1.2710, 0.000E+00, 0.000E+00, 0.000E+00, 8.474E+01, 3.886E+01, 3.240E-02, 5.050E-03, 4.505E-01, 4.876E-02 }, { 2480, 1.2710, 0.000E+00, 0.000E+00, 0.000E+00, 8.510E+01, 3.900E+01, 3.200E-02, 5.000E-03, 4.502E-01, 4.890E-02 }, { 2481, 1.2711, 0.000E+00, 0.000E+00, 0.000E+00, 8.584E+01, 3.900E+01, 3.110E-02, 4.850E-03, 4.499E-01, 4.904E-02 }, { 2482, 1.2712, 0.000E+00, 0.000E+00, 0.000E+00, 8.617E+01, 3.906E+01, 3.020E-02, 4.700E-03, 4.497E-01, 4.919E-02 }, { 2483, 1.2712, 0.000E+00, 0.000E+00, 0.000E+00, 8.637E+01, 3.905E+01, 2.930E-02, 4.550E-03, 4.494E-01, 4.933E-02 }, { 2484, 1.2713, 0.000E+00, 0.000E+00, 0.000E+00, 8.708E+01, 3.916E+01, 2.840E-02, 4.400E-03, 4.491E-01, 4.947E-02 }, { 2485, 1.2714, 0.000E+00, 0.000E+00, 0.000E+00, 8.762E+01, 3.928E+01, 2.750E-02, 4.250E-03, 4.488E-01, 4.962E-02 }, { 2486, 1.2715, 0.000E+00, 0.000E+00, 0.000E+00, 8.884E+01, 3.948E+01, 2.660E-02, 4.100E-03, 4.487E-01, 4.961E-02 }, { 2487, 1.2716, 0.000E+00, 0.000E+00, 0.000E+00, 8.904E+01, 3.943E+01, 2.570E-02, 3.950E-03, 4.486E-01, 4.961E-02 }, { 2488, 1.2717, 0.000E+00, 0.000E+00, 0.000E+00, 8.945E+01, 3.951E+01, 2.480E-02, 3.800E-03, 4.485E-01, 4.961E-02 }, { 2489, 1.2718, 0.000E+00, 0.000E+00, 0.000E+00, 9.055E+01, 3.964E+01, 2.390E-02, 3.650E-03, 4.483E-01, 4.961E-02 }, { 2490, 1.2719, 0.000E+00, 0.000E+00, 0.000E+00, 9.089E+01, 3.953E+01, 2.300E-02, 3.500E-03, 4.482E-01, 4.960E-02 }, { 2491, 1.2720, 0.000E+00, 0.000E+00, 0.000E+00, 9.134E+01, 3.960E+01, 2.210E-02, 3.350E-03, 4.482E-01, 4.960E-02 }, { 2492, 1.2722, 0.000E+00, 0.000E+00, 0.000E+00, 9.204E+01, 3.958E+01, 2.120E-02, 3.200E-03, 4.482E-01, 4.960E-02 }, { 2493, 1.2723, 0.000E+00, 0.000E+00, 0.000E+00, 9.244E+01, 3.954E+01, 2.030E-02, 3.050E-03, 4.482E-01, 4.960E-02 }, { 2494, 1.2725, 0.000E+00, 0.000E+00, 0.000E+00, 9.308E+01, 3.940E+01, 1.940E-02, 2.900E-03, 4.482E-01, 4.959E-02 }, { 2495, 1.2726, 0.000E+00, 0.000E+00, 0.000E+00, 9.333E+01, 3.936E+01, 1.850E-02, 2.750E-03, 4.482E-01, 4.959E-02 }, { 2496, 1.2728, 0.000E+00, 0.000E+00, 0.000E+00, 9.358E+01, 3.917E+01, 1.760E-02, 2.600E-03, 4.478E-01, 4.944E-02 }, { 2497, 1.2730, 0.000E+00, 0.000E+00, 0.000E+00, 9.416E+01, 3.926E+01, 1.670E-02, 2.450E-03, 4.475E-01, 4.930E-02 }, { 2498, 1.2732, 0.000E+00, 0.000E+00, 0.000E+00, 9.448E+01, 3.893E+01, 1.580E-02, 2.300E-03, 4.471E-01, 4.915E-02 }, { 2499, 1.2734, 0.000E+00, 0.000E+00, 0.000E+00, 9.499E+01, 3.921E+01, 1.490E-02, 2.150E-03, 4.467E-01, 4.900E-02 }, { 2500, 1.2736, 0.000E+00, 0.000E+00, 0.000E+00, 9.530E+01, 3.871E+01, 1.400E-02, 2.000E-03, 4.464E-01, 4.885E-02 } }; } OTB-release-5.8/Modules/Radiometry/Simulation/src/otbLeafParameters.cxx000066400000000000000000000025401301006202600262050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLeafParameters.h" namespace otb { /** * Constructor */ LeafParameters ::LeafParameters() { m_Cab=30.0; m_Car=10.0; m_CBrown=0.0; m_Cw=0.015; m_Cm=0.009; m_N=1.2; } /** * Destructor */ LeafParameters ::~LeafParameters() {} /**PrintSelf method */ void LeafParameters ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << "Chlorophyll content : " << m_Cab << std::endl; os << "Carotenoid content : " << m_Car << std::endl; os << "Brown pigment content : " << m_CBrown << std::endl; os << "EWT : " << m_Cw << std::endl; os << "LMA : " << m_Cm << std::endl; os << "structure coef : " << m_N << std::endl; } } // end namespace otb OTB-release-5.8/Modules/Radiometry/Simulation/src/otbProspectModel.cxx000066400000000000000000000151721301006202600260770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkNumericTraits.h" #include "otbProspectModel.h" #include "otb_boost_expint_header.h" #include #include "otbMath.h" //TODO check EPSILON matlab #define EPSILON 0.0000000000000000000000001 namespace otb { /** Constructor */ ProspectModel ::ProspectModel() { this->ProcessObject::SetNumberOfRequiredInputs(1); this->ProcessObject::SetNumberOfRequiredOutputs(2); SpectralResponseType::Pointer outputRefl = static_cast(this->MakeOutput(0).GetPointer()); this->itk::ProcessObject::SetNthOutput(0, outputRefl.GetPointer()); SpectralResponseType::Pointer outputTrans = static_cast(this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, outputTrans.GetPointer()); } /** Destructor */ ProspectModel ::~ProspectModel() {} /** Set Input */ void ProspectModel ::SetInput(const LeafParametersType * object) { this->itk::ProcessObject::SetNthInput(0, const_cast(object)); } /** Get Input */ ProspectModel::LeafParametersType * ProspectModel ::GetInput() { if(this->GetNumberOfInputs() != 1) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } /** Make outputs */ ProspectModel::DataObjectPointer ProspectModel ::MakeOutput(DataObjectPointerArraySizeType) { return static_cast(SpectralResponseType::New().GetPointer()); } /** Get Reflectance */ ProspectModel::SpectralResponseType * ProspectModel ::GetReflectance() { if(this->GetNumberOfOutputs() < 2) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } /** Get Transmittance */ ProspectModel::SpectralResponseType * ProspectModel ::GetTransmittance() { if(this->GetNumberOfOutputs() < 2) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } /** Set Parameters */ void ProspectModel ::SetInput(const ParametersType & params) { // m_Parameters = params; if(params.Size()!=6) itkExceptionMacro( << "Must have 6 parameters in that order : Cab, Car, CBrown, Cw, Cm, N" ); LeafParametersType::Pointer leafParams = LeafParametersType::New(); leafParams->SetCab(params[0]); leafParams->SetCar(params[1]); leafParams->SetCBrown(params[2]); leafParams->SetCw(params[3]); leafParams->SetCm(params[4]); leafParams->SetN(params[5]); this->itk::ProcessObject::SetNthInput(0, leafParams); } /** Plant Leaf Reflectance and Transmittance computation from 400nm to 2500 nm*/ void ProspectModel ::GenerateData() { LeafParametersType::Pointer leafParameters = this->GetInput(); SpectralResponseType::Pointer outRefl = this->GetReflectance(); SpectralResponseType::Pointer outTrans = this->GetTransmittance(); unsigned int alpha=40; double lambda, n, k, trans, t12, temp, t21, r12, r21, x, y, ra, ta, r90, t90; double delta, beta, va, vb, vbNN, vbNNinv, vainv, s1, s2, s3, RN, TN; double N, Cab, Car, CBrown, Cw, Cm; N = leafParameters->GetN(); Cab = leafParameters->GetCab(); Car = leafParameters->GetCar(); CBrown = leafParameters->GetCBrown(); Cw = leafParameters->GetCw(); Cm = leafParameters->GetCm(); int nbdata = sizeof(DataSpecP5B) / sizeof(DataSpec); for (int i = 0; i < nbdata; ++i) { lambda = DataSpecP5B[i].lambda; n = DataSpecP5B[i].refLeafMatInd; k = Cab*DataSpecP5B[i].chlAbsCoef+Car*DataSpecP5B[i].carAbsCoef+CBrown*DataSpecP5B[i].brownAbsCoef+Cw*DataSpecP5B[i].waterAbsCoef; k = k + Cm*DataSpecP5B[i].dryAbsCoef; k = k / N; if(k == itk::NumericTraits::ZeroValue() ) k=EPSILON; trans=(1.-k)*exp(-k)+k*k*boost::math::expint(1, k); t12 = this->Tav(alpha, n); temp = this->Tav(90, n); t21 = temp/(n*n); r12 = 1.-t12; r21 = 1.-t21; x = t12/temp; y = x*(temp-1)+1-t12; ra = r12+(t12*t21*r21*(trans*trans))/(1.-r21*r21*trans*trans); ta = (t12*t21*trans)/(1.-r21*r21*trans*trans); r90 = (ra-y)/x; t90 = ta/x; delta = (t90*t90-r90*r90-1.)*(t90*t90-r90*r90-1.) - 4.*r90*r90; if(delta < 0) delta = EPSILON; else delta=vcl_sqrt(delta); beta = (1.+r90*r90-t90*t90-delta)/(2.*r90); va=(1.+r90*r90-t90*t90+delta)/(2.*r90); if ((beta-r90)<=0) vb=vcl_sqrt(beta*(va-r90)/(va*EPSILON)); else vb=vcl_sqrt(beta*(va-r90)/(va*(beta-r90))); vbNN = vcl_pow(vb, N-1.); vbNNinv = 1./vbNN; vainv = 1./va; s1=ta*t90*(vbNN-vbNNinv); s2=ta*(va-vainv); s3=va*vbNN-vainv*vbNNinv-r90*(vbNN-vbNNinv); RN=ra+s1/s3; TN=s2/s3; SpectralResponseType::PairType rrefl; SpectralResponseType::PairType ttrans; rrefl.first=lambda/1000.0; rrefl.second=RN; ttrans.first=lambda/1000.0; ttrans.second=TN; outRefl->GetResponse().push_back(rrefl); outTrans->GetResponse().push_back(ttrans); } } double ProspectModel ::Tav(const int theta, double ref) { double theta_rad = theta*CONST_PI/180; double r2, rp, rm, a, k, ds, k2, rm2, res, b1, b2, b; double ts, tp1, tp2, tp3, tp4, tp5, tp; r2=ref*ref; rp=r2+1; rm=r2-1; a=(ref+1)*(ref+1)/2; k=-(r2-1)*(r2-1)/4; ds=sin(theta_rad); k2=k*k; rm2=rm*rm; if(theta_rad==0) res=4*ref/((ref+1)*(ref+1)); else { if(theta_rad==CONST_PI/2) b1=itk::NumericTraits::ZeroValue(); else b1=vcl_sqrt((ds*ds-rp/2)*(ds*ds-rp/2)+k); b2=ds*ds-rp/2; b=b1-b2; ts=(k2/(6*vcl_pow(b, 3))+k/b-b/2)-(k2/(6*vcl_pow(a, 3))+k/a-a/2); tp1=-2*r2*(b-a)/(rp*rp); tp2=-2*r2*rp*log(b/a)/rm2; tp3=r2*(1./b-1./a)/2; tp4=16*r2*r2*(r2*r2+1)*log((2*rp*b-rm2)/(2*rp*a-rm2))/(vcl_pow(rp, 3)*rm2); tp5=16*vcl_pow(r2, 3)*(1./(2*rp*b-rm2)-1./(2*rp*a-rm2))/vcl_pow(rp, 3); tp=tp1+tp2+tp3+tp4+tp5; res=(ts+tp)/(2*ds*ds); } return res; } void ProspectModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb OTB-release-5.8/Modules/Radiometry/Simulation/src/otbSailModel.cxx000066400000000000000000000451201301006202600251640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkNumericTraits.h" #include "otbSailModel.h" #include "otb_boost_expint_header.h" #include #include "otbMath.h" //TODO check EPSILON matlab #define EPSILON 0.0000000000000000000000001 namespace otb { /** Constructor */ SailModel ::SailModel() : m_LAI(2), m_Angl(50), m_PSoil(1), m_Skyl(70), m_HSpot(0.2), m_TTS(30), m_TTO(0), m_PSI(0), m_FCoverView(0.0) { this->ProcessObject::SetNumberOfRequiredInputs(2); this->ProcessObject::SetNumberOfRequiredOutputs(4); SpectralResponseType::Pointer vRefl = static_cast(this->MakeOutput(0).GetPointer()); this->itk::ProcessObject::SetNthOutput(0, vRefl.GetPointer()); SpectralResponseType::Pointer hRefl = static_cast(this->MakeOutput(1).GetPointer()); this->itk::ProcessObject::SetNthOutput(1, hRefl.GetPointer()); SpectralResponseType::Pointer vAbs = static_cast(this->MakeOutput(2).GetPointer()); this->itk::ProcessObject::SetNthOutput(2, vAbs.GetPointer()); SpectralResponseType::Pointer hAbs = static_cast(this->MakeOutput(3).GetPointer()); this->itk::ProcessObject::SetNthOutput(3, hAbs.GetPointer()); } /** Destructor */ SailModel ::~SailModel() {} /** Set/Get input reflectance */ void SailModel ::SetReflectance(const SpectralResponseType * object) { this->itk::ProcessObject::SetNthInput(0, const_cast(object)); } SailModel::SpectralResponseType * SailModel ::GetReflectance() { if(this->GetNumberOfInputs() != 2) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } /** Set/Get input transmittance */ void SailModel ::SetTransmittance(const SpectralResponseType * object) { this->itk::ProcessObject::SetNthInput(1, const_cast(object)); } SailModel::SpectralResponseType * SailModel ::GetTransmittance() { if(this->GetNumberOfInputs() != 2) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } /** Make output */ SailModel::DataObjectPointer SailModel ::MakeOutput(DataObjectPointerArraySizeType) { return static_cast(SpectralResponseType::New().GetPointer()); } /** Get output viewing reflectance */ SailModel::SpectralResponseType * SailModel ::GetViewingReflectance() { if(this->GetNumberOfOutputs() < 4) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } /** Get output hemispherical reflectance */ SailModel::SpectralResponseType * SailModel ::GetHemisphericalReflectance() { if(this->GetNumberOfOutputs() < 4) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } /** Get output viewing absorptance */ SailModel::SpectralResponseType * SailModel ::GetViewingAbsorptance() { if(this->GetNumberOfOutputs() < 4) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } /** Get output hemispherical absorptance */ SailModel::SpectralResponseType * SailModel ::GetHemisphericalAbsorptance() { if(this->GetNumberOfOutputs() < 4) { //exit return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(3)); } /** Set Parameters */ void SailModel ::SetInput(const ParametersType & params) { if(params.Size()!=8) itkExceptionMacro( << "Must have 8 parameters in that order : LAI, Angl, PSoil, Skyl, HSpot, TTS, TTO, PSI" ); this->SetParameters(params); m_LAI=params[0]; m_Angl=params[1]; m_PSoil=params[2]; m_Skyl=params[3]; m_HSpot=params[4]; m_TTS=params[5]; m_TTO=params[6]; m_PSI=params[7]; } /** Get Parameters */ const SailModel::ParametersType SailModel ::GetInput() { ParametersType parameters=this->GetParameters(); if(parameters.Size()!=8) { parameters[0]=m_LAI; parameters[1]=m_Angl; parameters[2]=m_PSoil; parameters[3]=m_Skyl; parameters[4]=m_HSpot; parameters[5]=m_TTS; parameters[6]=m_TTO; parameters[7]=m_PSI; this->SetParameters(parameters); } return this->GetParameters(); } /** Generate data */ void SailModel ::GenerateData() { SpectralResponseType::Pointer inRefl = this->GetReflectance(); SpectralResponseType::Pointer inTrans = this->GetTransmittance(); SpectralResponseType::Pointer outVRefl = this->GetViewingReflectance(); SpectralResponseType::Pointer outHRefl = this->GetHemisphericalReflectance(); SpectralResponseType::Pointer outVAbs = this->GetViewingAbsorptance(); SpectralResponseType::Pointer outHAbs = this->GetHemisphericalAbsorptance(); // LEAF ANGLE DISTRIBUTION double rd = CONST_PI/180; VectorType lidf; this->Calc_LIDF(m_Angl, lidf); double cts, cto, ctscto, tants, tanto, cospsi, dso; cts = vcl_cos(rd*m_TTS); cto = vcl_cos(rd*m_TTO); ctscto = cts*cto; tants = vcl_tan(rd*m_TTS); tanto = vcl_tan(rd*m_TTO); cospsi = vcl_cos(rd*m_PSI); dso = vcl_sqrt(tants*tants+tanto*tanto-2.*tants*tanto*cospsi); // angular distance, compensation of shadow length // Calculate geometric factors associated with extinction and scattering // Initialise sums double ks = 0; double ko = 0; double bf = 0; double sob = 0; double sof = 0; double ttl, ctl, ksli, koli, sobli, sofli, bfli; double chi_s, chi_o, frho, ftau; VectorType result(4); // Weighted sums over LIDF for(unsigned int i=0; iVolscatt(m_TTS, m_TTO, m_PSI, ttl, result); chi_s = result[0]; chi_o = result[1]; frho = result[2]; ftau = result[3]; //******************************************************************************** //* SUITS SYSTEM COEFFICIENTS //* //* ks : Extinction coefficient for direct solar flux //* ko : Extinction coefficient for direct observed flux //* att : Attenuation coefficient for diffuse flux //* sigb : Backscattering coefficient of the diffuse downward flux //* sigf : Forwardscattering coefficient of the diffuse upward flux //* sf : Scattering coefficient of the direct solar flux for downward diffuse flux //* sb : Scattering coefficient of the direct solar flux for upward diffuse flux //* vf : Scattering coefficient of upward diffuse flux in the observed direction //* vb : Scattering coefficient of downward diffuse flux in the observed direction //* w : Bidirectional scattering coefficient //******************************************************************************** // Extinction coefficients ksli = chi_s/cts; koli = chi_o/cto; // Area scattering coefficient fractions sobli = frho*CONST_PI/ctscto; sofli = ftau*CONST_PI/ctscto; bfli = ctl*ctl; ks = ks+ksli*lidf[i]; ko = ko+koli*lidf[i]; bf = bf+bfli*lidf[i]; sob = sob+sobli*lidf[i]; sof = sof+sofli*lidf[i]; } // Geometric factors to be used later with rho and tau double sdb, sdf, dob, dof, ddb, ddf; sdb = 0.5*(ks+bf); sdf = 0.5*(ks-bf); dob = 0.5*(ko+bf); dof = 0.5*(ko-bf); ddb = 0.5*(1.+bf); ddf = 0.5*(1.-bf); double lambda, Es, Ed, Rsoil1, Rsoil2, rsoil0, rho, tau, PARdiro, PARdifo; double sigb, sigf, att, m2, m, sb, sf, vb, vf, w; double tss, too, tsstoo, rdd, tdd, rsd, tsd, rdo, tdo, rsos, rsod; double rddt, rsdt, rdot, rsodt, rsost, rsot, dn; double e1, e2, rinf, rinf2, re, denom, J1ks, J2ks, J1ko, J2ko; double Ps, Qs, Pv, Qv, z, g1, g2, Tv1, Tv2, T1, T2, T3; double alf, sumint, fhot, x1, y1, f1, fint, x2, y2, f2; double resh, resv, absh, absv; int nbdata = sizeof(DataSpecP5B) / sizeof(DataSpec); for (int i = 0; i < nbdata; ++i) { lambda = DataSpecP5B[i].lambda; Es = DataSpecP5B[i].directLight; //8 Ed = DataSpecP5B[i].diffuseLight; //9 Rsoil1 = DataSpecP5B[i].drySoil; //10 Rsoil2 = DataSpecP5B[i].wetSoil; //11 rho = inRefl->GetResponse()[i].second; //rho = LRT[1][i]; tau = inTrans->GetResponse()[i].second; //tau = LRT[2][i]; // direct/diffuse light //Es = direct //Ed = diffuse PARdiro = (1-m_Skyl/100.)*Es; PARdifo = (m_Skyl/100.)*Ed; // Soil Reflectance Properties //rsoil1 = dry soil //rsoil2 = wet soil rsoil0 = m_PSoil*Rsoil1+(1-m_PSoil)*Rsoil2; // Here rho and tau come in sigb = ddb*rho+ddf*tau; sigf = ddf*rho+ddb*tau; att = 1.-sigf; m2 = (att+sigb)*(att-sigb); if(m2<=0) m2 = 0; m = vcl_sqrt(m2); sb = sdb*rho+sdf*tau; sf = sdf*rho+sdb*tau; vb = dob*rho+dof*tau; vf = dof*rho+dob*tau; w = sob*rho+sof*tau; // Here the LAI comes in // Outputs for the case LAI = 0 if (m_LAI<0) { //tss = 1; too = 1; tsstoo = 1; rdd = 0; tdd = 1; rsd = 0; tsd = 0; rdo = 0; tdo = 0; //rso = 0; rsos = 0; rsod = 0; rddt = rsoil0; rsdt = rsoil0; rdot = rsoil0; rsodt = 0; rsost = rsoil0; //rsot = rsoil0; } // Other cases (LAI > 0) e1 = exp(-m*m_LAI); e2 = e1*e1; rinf = (att-m)/sigb; rinf2 = rinf*rinf; re = rinf*e1; denom = 1.-rinf2*e2; J1ks=Jfunc1(ks, m, m_LAI); J2ks=Jfunc2(ks, m, m_LAI); J1ko=Jfunc1(ko, m, m_LAI); J2ko=Jfunc2(ko, m, m_LAI); Ps = (sf+sb*rinf)*J1ks; Qs = (sf*rinf+sb)*J2ks; Pv = (vf+vb*rinf)*J1ko; Qv = (vf*rinf+vb)*J2ko; rdd = rinf*(1.-e2)/denom; tdd = (1.-rinf2)*e1/denom; tsd = (Ps-re*Qs)/denom; rsd = (Qs-re*Ps)/denom; tdo = (Pv-re*Qv)/denom; rdo = (Qv-re*Pv)/denom; tss = exp(-ks*m_LAI); too = exp(-ko*m_LAI); z = Jfunc3(ks, ko, m_LAI); g1 = (z-J1ks*too)/(ko+m); g2 = (z-J1ko*tss)/(ks+m); Tv1 = (vf*rinf+vb)*g1; Tv2 = (vf+vb*rinf)*g2; T1 = Tv1*(sf+sb*rinf); T2 = Tv2*(sf*rinf+sb); T3 = (rdo*Qs+tdo*Ps)*rinf; // Multiple scattering contribution to bidirectional canopy reflectance rsod = (T1+T2-T3)/(1.-rinf2); // Treatment of the hotspot-effect alf=1e6; // Apply correction 2/(K+k) suggested by F.-M. Bron if (m_HSpot>0) alf=(dso/m_HSpot)*2./(ks+ko); if (alf>200) alf=200; if (alf==0) { // The pure hotspot - no shadow tsstoo = tss; sumint = (1-tss)/(ks*m_LAI); } else { // Outside the hotspot fhot=m_LAI*vcl_sqrt(ko*ks); // Integrate by exponential Simpson method in 20 steps // the steps are arranged according to equal partitioning // of the slope of the joint probability function x1=0; y1=0; f1=1; fint=(1.-exp(-alf))*0.05; sumint=0; for(unsigned int j=1; j<=20; ++j) { if (j<20) x2 = -vcl_log(1.-j*fint)/alf; else x2 = 1; y2 = -(ko+ks)*m_LAI*x2+fhot*(1.-exp(-alf*x2))/alf; f2 = exp(y2); sumint = sumint+(f2-f1)*(x2-x1)/(y2-y1); x1=x2; y1=y2; f1=f2; } tsstoo=f1; } // Bidirectional reflectance // Single scattering contribution rsos = w*m_LAI*sumint; // Total canopy contribution // rso=rsos+rsod; //Interaction with the soil dn=1.-rsoil0*rdd; rddt = rdd+tdd*rsoil0*tdd/dn; rsdt = rsd+(tsd+tss)*rsoil0*tdd/dn; rdot = rdo+tdd*rsoil0*(tdo+too)/dn; rsodt = rsod+((tss+tsd)*tdo+(tsd+tss*rsoil0*rdd)*too)*rsoil0/dn; rsost = rsos+tsstoo*rsoil0; rsot = rsost+rsodt; resh = (rddt*PARdifo+rsdt*PARdiro)/(PARdiro+PARdifo); resv = (rdot*PARdifo+rsot*PARdiro)/(PARdiro+PARdifo); absh = (1-rddt-(1-rsoil0)*(tdd+(tdd*rdd*rsoil0)/dn)); absv = (1-rsdt-(1-rsoil0)*(tss+(tss*rsoil0*rdd+tsd)/dn)); SpectralResponseType::PairType response; response.first=lambda/1000.0; response.second=resh; outHRefl->GetResponse().push_back(response); response.second=resv; outVRefl->GetResponse().push_back(response); response.second=absh; outHAbs->GetResponse().push_back(response); response.second=absv; outVAbs->GetResponse().push_back(response); } m_FCoverView = 1-too; } void SailModel ::Calc_LIDF(const double a, VectorType &lidf) { int ala=a; VectorType freq; Campbell(ala, freq); lidf=freq; } void SailModel ::Campbell(const double ala, VectorType &freq) { unsigned int n=18; double excent = exp(-1.6184e-5*vcl_pow(ala, 3)+2.1145e-3*ala*ala-1.2390e-1*ala+3.2491); double sum=0; unsigned int tx2, tx1; double tl1, tl2, x1, x2, v, alpha, alpha2, x12, x22, alpx1, alpx2, dum, almx1, almx2; VectorType temp; for(unsigned int i=0; i1) { alpx1 = vcl_sqrt(alpha2+x12); alpx2 = vcl_sqrt(alpha2+x22); dum = x1*alpx1+alpha2*log(x1+alpx1); v = vcl_abs(dum-(x2*alpx2+alpha2*log(x2+alpx2))); temp.push_back( v ); sum = sum + v; } else { almx1 = sqrt(alpha2-x12); almx2 = sqrt(alpha2-x22); dum = x1*almx1+alpha2*asin(x1/alpha); v = vcl_abs(dum-(x2*almx2+alpha2*asin(x2/alpha))); temp.push_back( v ); sum = sum + v; } } } for(unsigned int i=0; ipi/2, bottom side of the leaves is observed for leaf azimut // interval betao+phi1e-6) cosbts = -cs/ss; cosbto=5; if (vcl_abs(so)>1e-6) cosbto = -co/so; if (vcl_abs(cosbts)<1) { bts = vcl_acos(cosbts); ds = ss; } else { bts = CONST_PI; ds = cs; } chi_s = 2./CONST_PI*((bts-CONST_PI*0.5)*cs+vcl_sin(bts)*ss); if (vcl_abs(cosbto)<1) { bto = vcl_acos(cosbto); doo = so; } else if(tto<90) { bto = CONST_PI; doo = co; } else { bto = 0; doo = -co; } chi_o = 2./CONST_PI*((bto-CONST_PI*0.5)*co+vcl_sin(bto)*so); // .............................................................................. // Computation of auxiliary azimut angles bt1, bt2, bt3 used // for the computation of the bidirectional scattering coefficient w // ............................................................................. btran1 = vcl_abs(bts-bto); btran2 = CONST_PI - vcl_abs(bts+bto-CONST_PI); if (psir<=btran1) { bt1=psir; bt2=btran1; bt3=btran2; } else { bt1=btran1; if (psir<=btran2) { bt2=psir; bt3=btran2; } else { bt2=btran2; bt3=psir; } } t1 = 2.*cs*co+ss*so*cospsi; t2 = 0; if (bt2>0) t2=sin(bt2)*(2.*ds*doo+ss*so*cos(bt1)*cos(bt3)); denom = 2.*CONST_PI*CONST_PI; frho = ((CONST_PI-bt2)*t1+t2)/denom; ftau = (-bt2*t1+t2)/denom; if (frho<0) frho = 0; if (ftau<0) ftau = 0; result[0] = chi_s; result[1] = chi_o; result[2] = frho; result[3] = ftau; } double SailModel ::Jfunc1(const double k, const double l, const double t) { //J1 function with avoidance of singularity problem double v; double del=(k-l)*t; if(vcl_abs(del)>1e-3) { v = (exp(-l*t)-exp(-k*t))/(k-l); return v; } else { v = 0.5*t*(exp(-k*t)+exp(-l*t))*(1.-del*del/12.); return v; } } double SailModel ::Jfunc2(const double k, const double l, const double t) { double v; v = (1.-exp(-(k+l)*t))/(k+l); return v; } double SailModel ::Jfunc3(const double k, const double l, const double t) { double v; v = (1.-exp(-(k+l)*t))/(k+l); return v; } void SailModel ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb OTB-release-5.8/Modules/Radiometry/Simulation/test/000077500000000000000000000000001301006202600222505ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Simulation/test/CMakeLists.txt000066400000000000000000000214771301006202600250230ustar00rootroot00000000000000otb_module_test() #Paths for spectral libraries set(SPECTRUM_DB ${INPUTDATA}/BD-CNES) set(SRCLASS0 ${SPECTRUM_DB}/JHU/becknic/manmade/txt) set(SRCLASS1 ${SPECTRUM_DB}/JHU/becknic/water/txt) set(SRCLASS2 ${SPECTRUM_DB}/JHU/becknic/soils/txt) set(SRCLASS3 ${SPECTRUM_DB}/JHU/becknic/vegetation/txt) set(SRCLASS4 ${SPECTRUM_DB}/JHU/becknic/rocks/sedimentary/powder/0_75/txt) set(OTBSimulationTests otbSimulationTestDriver.cxx otbReduceSpectralResponseSVMClassifier.cxx otbProspectTransTest.cxx otbReduceSpectralResponseClassifierRAndNIR.cxx otbSpectralResponseNew.cxx otbSatelliteRSR.cxx otbSurfaceReflectanceToReflectanceFilterNew.cxx otbImageSimulationMethodWithSpatialisationTest.cxx otbImageSimulationMethodSVMClassif.cxx otbReduceSpectralResponseNew.cxx otbReduceSpectralResponse.cxx otbAtmosphericEffects.cxx otbProspectReflTest.cxx otbSpatialisationTestNew.cxx otbLabelMapToSimulatedImageFilterTest.cxx otbImageSimulationMethodKMeansClassif.cxx otbSpectralResponse.cxx otbAtmosphericCorrectionsRSRSVMClassifier.cxx otbSpatialisationTest.cxx otbImageSimulationMethodWithVectorDataTest.cxx otbSailReflVTest.cxx otbSatelliteRSRNew.cxx otbSailReflHTest.cxx otbFilterFunctionValues.cxx ) add_executable(otbSimulationTestDriver ${OTBSimulationTests}) target_link_libraries(otbSimulationTestDriver ${OTBSimulation-Test_LIBRARIES}) otb_module_target_label(otbSimulationTestDriver) # Tests Declaration otb_add_test(NAME siTuRSRSVMClassifier COMMAND otbSimulationTestDriver otbReduceSpectralResponseSVMClassifier ${SRCLASS0} ${SRCLASS1} ${SRCLASS2} ${SRCLASS3} ${SRCLASS4} ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nbBands 0.1 #percentage of validation files ) otb_add_test(NAME siTvProspectTransTest COMMAND otbSimulationTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/Simulation/siTvProspectTransTest.txt ${TEMP}/siTvProspectTransTest.txt otbProspectTransTest 30.0 #cab 10.0 #car 0.0 #CBrown 0.015 #Cw 0.009 #Cm 1.2 #N ${TEMP}/siTvProspectTransTest.txt ) otb_add_test(NAME siTuReduceSpectralResponseClassifierRAndNIR COMMAND otbSimulationTestDriver otbReduceSpectralResponseClassifierRAndNIR ${SPECTRUM_DB}/JHU/becknic/manmade/txt/0092uuu.txt ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 1 #red index 2 #NIR index ) otb_add_test(NAME siTuSpectralResponseNew COMMAND otbSimulationTestDriver otbSpectralResponseNew ) otb_add_test(NAME siTuSatelliteRSRCheckValue COMMAND otbSimulationTestDriver otbSatelliteRSRCheckValue ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 0.50 #lambda 0 #num band 0.557 #expected ) otb_add_test(NAME siTuSatelliteRSRSolarIrradianceCheckValue2 COMMAND otbSimulationTestDriver otbSatelliteRSRSolarIrradianceCheckValue ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 1.7525000e+00 #lambda 1.8526000e+02 #expected ) otb_add_test(NAME siTuSatelliteRSRSolarIrradianceCheckValue COMMAND otbSimulationTestDriver otbSatelliteRSRSolarIrradianceCheckValue ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 0.45 #lambda 2.0573899e3 #expected ) otb_add_test(NAME siTuSatelliteRSR COMMAND otbSimulationTestDriver otbSatelliteRSR ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 2.5 #lambda 2 #num band ) otb_add_test(NAME siTuSatelliteRSRCheckValue2 COMMAND otbSimulationTestDriver otbSatelliteRSRCheckValue ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 0.68 #lambda 1 #num band 0.717 #expected ) otb_add_test(NAME siTuReflectanceToSurfaceReflectanceFilterNew COMMAND otbSimulationTestDriver otbSurfaceReflectanceToReflectanceFilterNew ) otb_add_test(NAME siTuImageSimulationMethodWithSpatialisationTest COMMAND otbSimulationTestDriver otbImageSimulationMethodWithSpatialisationTest ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb bands ${SPECTRUM_DB}/ #root path of spectrum 3 #prolate radius ${TEMP}/ImageSimulationMethodWithSpatialisationTest.tif ${TEMP}/LabelImageSimulationMethodWithSpatialisationTest.tif ) otb_add_test(NAME siTuReduceSpectralResponseNew COMMAND otbSimulationTestDriver otbReduceSpectralResponseNew ) otb_add_test(NAME siTuReduceSpectralResponseReflectanceMode COMMAND otbSimulationTestDriver otbReduceSpectralResponse ${SPECTRUM_DB}/jpl/beckman/minerals/Arsenate/txt/A01Ac.txt ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 1 #reflectance mode ) otb_add_test(NAME siTuReduceSpectralResponse COMMAND otbSimulationTestDriver otbReduceSpectralResponse ${SPECTRUM_DB}/jpl/beckman/minerals/Arsenate/txt/A01Ac.txt ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb band 0 #reflectance mode ) otb_add_test(NAME siTuReduceSpectralResponseSimpleValues COMMAND otbSimulationTestDriver otbReduceSpectralResponseSimpleValues ${TEMP}/siTuReduceSpectralResponseSimpleValuesRSRLum.txt 0 # reflectance mode ) otb_add_test(NAME siTuReduceSpectralResponseSimpleValuesReflectance COMMAND otbSimulationTestDriver otbReduceSpectralResponseSimpleValues ${TEMP}/siTuReduceSpectralResponseSimpleValuesRSRRefl.txt 1 # reflectance mode ) otb_add_test(NAME siTvReduceSpectralResponseReflectanceMode COMMAND otbSimulationTestDriver otbReduceSpectralResponse ${INPUTDATA}/SpectralResponse1.txt ${INPUTDATA}/Radiometry/Test/rep6S.dat 4 #nb band 1 #reflectance mode ${TEMP}/siTvReduceSpectralResponseReflectanceMode.txt ) otb_add_test(NAME siTvProspectReflTest COMMAND otbSimulationTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/Simulation/siTvProspectReflTest.txt ${TEMP}/siTvProspectReflTest.txt otbProspectReflTest 30.0 #cab 10.0 #car 0.0 #CBrown 0.015 #Cw 0.009 #Cm 1.2 #N ${TEMP}/siTvProspectReflTest.txt ) otb_add_test(NAME siTuSpatialisationTestNew COMMAND otbSimulationTestDriver otbSpatialisationTestNew ) otb_add_test(NAME siTuLabelMapToSimulatedImageFilterTest COMMAND otbSimulationTestDriver otbLabelMapToSimulatedImageFilterTest ${INPUTDATA}/Simulation/Shapefile/culturesWithAndWithoutPath.shp ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb bands ${SPECTRUM_DB}/jpl/beckman/minerals/ #root path of spectrum ${TEMP}/LabelMapToSimulatedImageFilterTest.tif ) otb_add_test(NAME siTuImageSimulationMethodKMeansClassif COMMAND otbSimulationTestDriver otbImageSimulationMethodKMeansClassif ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb bands ${SPECTRUM_DB}/ #root path of spectrum 3 #prolate radius ${TEMP}/siTuImageSimulationMethodKMeansClassif.tif ${TEMP}/siTuKMeansClassifLabelImage.tif ) otb_add_test(NAME siTuSpectralResponse COMMAND otbSimulationTestDriver otbSpectralResponse ${SPECTRUM_DB}/JHU/becknic/manmade/txt/0092uuu.txt 2.5 #lambda ) otb_add_test(NAME siTvSpatialisationTest COMMAND otbSimulationTestDriver --compare-image ${NOTOL} ${BASELINE}/Simulation/siTvSpatialisationTest.tif ${TEMP}/siTvSpatialisationTest.tif otbSpatialisationTest ${TEMP}/siTvSpatialisationTest.tif ) otb_add_test(NAME siTuImageSimulationMethodWithVectorDataTest COMMAND otbSimulationTestDriver otbImageSimulationMethodWithVectorDataTest ${INPUTDATA}/Simulation/Shapefile/stickPolygons_small.shp ${INPUTDATA}/Radiometry/SPOT5/HRG2/rep6S.dat 4 #nb bands ${SPECTRUM_DB}/ #root path of spectrum 3 #prolate radius ${TEMP}/ImageSimulationMethodTest.tif ${TEMP}/LabelImageSimulationMethodTest.tif ) otb_add_test(NAME siTvSailReflVTest COMMAND otbSimulationTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/Simulation/siTvSailReflVTest.txt ${TEMP}/siTvSailReflVTest.txt otbSailReflVTest 30.0 #cab 10.0 #car 0.0 #CBrown 0.015 #Cw 0.009 #Cm 1.2 #N 2 #LAI 50 #Angl 1 #PSoil 70 #Skyl 0.2 #HSpot 30 #TTS 0 #TTO 0 #PSI ${TEMP}/siTvSailReflVTest.txt ) otb_add_test(NAME siTuSatelliteRSRNew COMMAND otbSimulationTestDriver otbSatelliteRSRNew ) otb_add_test(NAME siTvSailReflHTest COMMAND otbSimulationTestDriver --compare-ascii ${EPSILON_3} ${BASELINE_FILES}/Simulation/siTvSailReflHTest.txt ${TEMP}/siTvSailReflHTest.txt otbSailReflHTest 30.0 #cab 10.0 #car 0.0 #CBrown 0.015 #Cw 0.009 #Cm 1.2 #N 2 #LAI 50 #Angl 1 #PSoil 70 #Skyl 0.2 #HSpot 30 #TTS 0 #TTO 0 #PSI ${TEMP}/siTvSailReflHTest.txt ) otb_add_test(NAME raTvFilterFunctionValuesSpectralResponseTest COMMAND otbSimulationTestDriver --compare-ascii ${EPSILON_6} ${BASELINE_FILES}/raTvFilterFunctionValuesSpectralResponseTest.txt ${TEMP}/raTvFilterFunctionValuesSpectralResponseTest.txt otbFilterFunctionValuesSpectralResponseTest ${SPECTRUM_DB}/JHU/becknic/manmade/txt/0092uuu.txt ${TEMP}/raTvFilterFunctionValuesSpectralResponseTest.txt 0.0025 ) otb_add_test(NAME raTuFilterFunctionValuesTest COMMAND otbSimulationTestDriver otbFilterFunctionValuesTest ${TEMP}/raTuFilterFunctionValuesTest.txt 0.5 # lambda min 0.7 # lambda max 0.05 # user step 0.2 0.5 0.3 0.9 0.8 # vector ) OTB-release-5.8/Modules/Radiometry/Simulation/test/otbAtmosphericCorrectionsRSRSVMClassifier.cxx000066400000000000000000000355521301006202600331660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAtmosphericEffects.h" #include "otbSatelliteRSR.h" #include "otbReduceSpectralResponse.h" #include "otbSVMSampleListModelEstimator.h" #include "otbSVMClassifier.h" #include "otbConfusionMatrixCalculator.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include int otbAtmosphericCorrectionsRSRSVMClassifier(int argc, char * argv[]) { typedef otb::SpectralResponse SpectralResponseType; typedef SpectralResponseType::Pointer SpectralResponsePointerType; typedef otb::SatelliteRSR SatRSRType; typedef SatRSRType::Pointer SatRSRPointerType; typedef otb::ReduceSpectralResponse ReduceSpectralResponseType; typedef otb::AtmosphericEffects AtmosphericEffectsType; /*typedef AtmosphericEffectsType::AtmosphericCorrectionParametersType AtmosphericCorrectionParametersType; chris typedef AtmosphericCorrectionParametersType::AerosolModelType AerosolModelType; typedef AtmosphericCorrectionParametersType::AerosolModelType AerosolModelType; */ typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; typedef itk::VariableLengthVector SampleType; typedef itk::Statistics::ListSample SampleListType; typedef itk::FixedArray TrainingSampleType; typedef itk::Statistics::ListSample TrainingSampleListType; typedef otb::SVMSampleListModelEstimator SVMModelEstimatorType; typedef otb::SVMClassifier SVMClassifierType; typedef SVMClassifierType::OutputType ClassifierOutputType; typedef otb::ConfusionMatrixCalculator ConfusionMatrixCalculatorType; if (argc != 20) { std::cout << argv[0] << std::endl << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << std::endl; return EXIT_FAILURE; } /* 27.3 #elevation et azimuth solaire 4 #day 12 #month # AtmosphericCorrectionParametersTo6SAtmosphericRadiativeTerms parameters 152.7 #solar azimutal angle 2.5 #viewing zenithal angle -77.0 #viewing azimutal angle 1013. #atmo pressure 2.48134 #water vapour amount 0.34400 #ozone amount 1 #aerosol model type 0.199854 #aerosol optical */ //Get input parameters std::vector dirSR; dirSR.push_back(argv[1]); dirSR.push_back(argv[2]); dirSR.push_back(argv[3]); dirSR.push_back(argv[4]); dirSR.push_back(argv[5]); const std::string fileSatG(argv[6]); unsigned int nbBand = atoi(argv[7]); const int day(atoi(argv[8])); const int month(atoi(argv[9])); const double zenithSolarAngle(static_cast (atof(argv[10]))); const double azimutSolarAngle(static_cast (atof(argv[11]))); const double viewingZenitalAngle(static_cast (atof(argv[12]))); const double viewingAzimutalAngle(static_cast (atof(argv[13]))); const double atmoPressure(static_cast (atof(argv[14]))); const double waterVaporAmount(static_cast (atof(argv[15]))); const double ozoneAmount(static_cast (atof(argv[16]))); const int aerosolModelValue(::atoi(argv[17])); const double aerosolOptical(static_cast (atof(argv[18]))); float percentage = atof(argv[19]); //Instantiation /*AtmosphericCorrectionParametersType::Pointer chris dataAtmosphericCorrectionParameters = AtmosphericCorrectionParametersType::New(); */ AcquiCorrectionParametersPointerType paramAcqui = AcquiCorrectionParametersType::New(); AtmoCorrectionParametersPointerType paramAtmo = AtmoCorrectionParametersType::New(); SatRSRPointerType satRSR = SatRSRType::New(); satRSR->SetNbBands(nbBand); satRSR->Load(fileSatG); // Set parameters /*dataAtmosphericCorrectionParameters->SetSolarZenithalAngle(zenithSolarAngle); chris dataAtmosphericCorrectionParameters->SetSolarAzimutalAngle(azimutSolarAngle); dataAtmosphericCorrectionParameters->SetViewingZenithalAngle(viewingZenitalAngle); dataAtmosphericCorrectionParameters->SetViewingAzimutalAngle(viewingAzimutalAngle); dataAtmosphericCorrectionParameters->SetMonth(month); dataAtmosphericCorrectionParameters->SetDay(day); dataAtmosphericCorrectionParameters->SetAtmosphericPressure(atmoPressure); dataAtmosphericCorrectionParameters->SetWaterVaporAmount(waterVaporAmount); dataAtmosphericCorrectionParameters->SetOzoneAmount(ozoneAmount); AerosolModelType aerosolModel = static_cast (aerosolModelValue); dataAtmosphericCorrectionParameters->SetAerosolModel(aerosolModel); dataAtmosphericCorrectionParameters->SetAerosolOptical(aerosolOptical); */ paramAcqui->SetSolarZenithalAngle(zenithSolarAngle); paramAcqui->SetSolarAzimutalAngle(azimutSolarAngle); paramAcqui->SetViewingZenithalAngle(viewingZenitalAngle); paramAcqui->SetViewingAzimutalAngle(viewingAzimutalAngle); paramAcqui->SetMonth(month); paramAcqui->SetDay(day); paramAtmo->SetAtmosphericPressure(atmoPressure); paramAtmo->SetWaterVaporAmount(waterVaporAmount); paramAtmo->SetOzoneAmount(ozoneAmount); AerosolModelType aerosolModel = static_cast(aerosolModelValue); paramAtmo->SetAerosolModel(aerosolModel); paramAtmo->SetAerosolOptical(aerosolOptical); AtmosphericRadiativeTermsPointerType radiative = CorrectionParametersToRadiativeTermsType::Compute(paramAtmo,paramAcqui); //divide into training and testing files //90% of files are used for training and 10% for testing std::vector trainingFiles; //contains training files for all classes std::vector trainingClasses; //contains training classes for each files std::vector testingFiles; //contains testing files for this classes std::vector testingGTClasses; //contains testing ground truth classes for each files unsigned int ind; for (unsigned int i = 0; i < dirSR.size(); ++i) //for each class (directory) { std::cout << "dirSR[" << i << "] : " << dirSR[i] << std::endl; // Find all .txt file in the directory std::string fileExp = dirSR[i]; fileExp.append("/*.txt"); itksys::Glob glob; if ( glob.FindFiles( fileExp ) == false ) { std::cout<<"No .txt file found in "< result = glob.GetFiles(); std::vector training; //contains training files for this class (directory) std::vector testing; //contains testing files for this class (directory) training = result; // initiating random number generation itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New(); //randomGen->Initialize(); for (unsigned int j = 0; j < static_cast (percentage * result.size()); ++j) { ind = randomGen->GetIntegerVariate() % (result.size()); testing.push_back(result[ind]); training.erase(training.begin() + j); } //add to global training files and testing files for (unsigned int k = 0; k < testing.size(); ++k) { std::cout << "testing[" << k << "] : " << testing[k] << std::endl; testingFiles.push_back(testing[k]); testingGTClasses.push_back(i); } for (unsigned int l = 0; l < training.size(); ++l) { std::cout << "training[" << l << "] : " << training[l] << std::endl; trainingFiles.push_back(training[l]); trainingClasses.push_back(i); //class is the directory number } } //compute spectral response for all training files SampleListType::Pointer sampleList = SampleListType::New(); TrainingSampleListType::Pointer trainingList = TrainingSampleListType::New(); for (unsigned int i = 0; i < trainingFiles.size(); ++i) { SpectralResponsePointerType spectralResponse = SpectralResponseType::New(); ReduceSpectralResponseType::Pointer reduceSpectralResponse = ReduceSpectralResponseType::New(); AtmosphericEffectsType::Pointer atmosphericEffectsFilter = AtmosphericEffectsType::New(); std::cout << "training file : " << trainingFiles[i] << std::endl; spectralResponse->Load(trainingFiles[i], 100.0); //Compute Reduce Spectral Response reduceSpectralResponse->SetInputSatRSR(satRSR); reduceSpectralResponse->SetInputSpectralResponse(spectralResponse); reduceSpectralResponse->CalculateResponse(); atmosphericEffectsFilter->SetAtmosphericRadiativeTerms(radiative); atmosphericEffectsFilter->SetInputSatRSR(satRSR); atmosphericEffectsFilter->SetInputSpectralResponse(reduceSpectralResponse->GetReduceResponse()); atmosphericEffectsFilter->Process(); //Get the response in an itk::VariableLengthVector and add it to the sample list for SVMModelEstimator SampleType sample; TrainingSampleType trainingSample; sample.SetSize(atmosphericEffectsFilter->GetCorrectedSpectralResponse()->Size()); std::cout << "corrected response : ["; for (unsigned int j = 0; j < atmosphericEffectsFilter->GetCorrectedSpectralResponse()->Size(); ++j) { sample[j] = atmosphericEffectsFilter->GetCorrectedSpectralResponse()->GetResponse()[j].second; std::cout << atmosphericEffectsFilter->GetCorrectedSpectralResponse()->GetResponse()[j].second << " "; } std::cout << "]" << std::endl; sampleList->PushBack(sample); trainingSample = trainingClasses[i]; std::cout << "training class : " << trainingSample << std::endl; trainingList->PushBack(trainingSample); } //SVM model estimator SVMModelEstimatorType::Pointer estimator = SVMModelEstimatorType::New(); estimator->SetInputSampleList(sampleList); estimator->SetTrainingSampleList(trainingList); estimator->DoProbabilityEstimates(true); estimator->Update(); estimator->GetModel()->SaveModel("model.txt"); //compute spectral response for testing files sampleList->Clear(); //clear the sample list to re use it for testing samples TrainingSampleListType::Pointer groundTruthClassList = TrainingSampleListType::New(); for (unsigned int i = 0; i < testingFiles.size(); ++i) { SpectralResponsePointerType spectralResponse = SpectralResponseType::New(); ReduceSpectralResponseType::Pointer reduceSpectralResponse = ReduceSpectralResponseType::New(); AtmosphericEffectsType::Pointer atmosphericEffectsFilter = AtmosphericEffectsType::New(); std::cout << "testing file : " << testingFiles[i] << std::endl; spectralResponse->Load(testingFiles[i], 100.0); //Compute Reduce Spectral Response reduceSpectralResponse->SetInputSatRSR(satRSR); reduceSpectralResponse->SetInputSpectralResponse(spectralResponse); reduceSpectralResponse->CalculateResponse(); atmosphericEffectsFilter->SetAtmosphericRadiativeTerms(radiative); atmosphericEffectsFilter->SetInputSatRSR(satRSR); atmosphericEffectsFilter->SetInputSpectralResponse(reduceSpectralResponse->GetReduceResponse()); atmosphericEffectsFilter->Process(); //Get the response in an itk::VariableLengthVector and add it to the sample list for SVMClassifier SampleType sample; TrainingSampleType gtClass; sample.SetSize(atmosphericEffectsFilter->GetCorrectedSpectralResponse()->Size()); for (unsigned int j = 0; j < atmosphericEffectsFilter->GetCorrectedSpectralResponse()->Size(); ++j) { sample[j] = atmosphericEffectsFilter->GetCorrectedSpectralResponse()->GetResponse()[j].second; } sampleList->PushBack(sample); gtClass = testingGTClasses[i]; groundTruthClassList->PushBack(gtClass); } //SVM Classifier SVMClassifierType::Pointer classifier = SVMClassifierType::New(); classifier->SetModel(estimator->GetModel()); classifier->SetInput(sampleList); classifier->SetNumberOfClasses(dirSR.size()); classifier->Update(); ClassifierOutputType::ConstIterator it = classifier->GetOutput()->Begin(); TrainingSampleListType::Pointer classifierListLabel = TrainingSampleListType::New(); while (it != classifier->GetOutput()->End()) { std::cout << "class : " << it.GetClassLabel() << std::endl; classifierListLabel->PushBack(it.GetClassLabel()); ++it; } for (unsigned int i = 0; i < testingFiles.size(); ++i) { std::cout << "ground truth class : " << testingGTClasses[i] << std::endl; } //Compute confusion matrix ConfusionMatrixCalculatorType::Pointer confMatCalc = ConfusionMatrixCalculatorType::New(); confMatCalc->SetReferenceLabels(groundTruthClassList); confMatCalc->SetProducedLabels(classifierListLabel); confMatCalc->Compute(); std::cout << std::endl; std::cout << "Confusion matrix: " << std::endl << confMatCalc->GetConfusionMatrix() << std::endl << std::endl; std::cout << "Kappa Index: " << std::endl << confMatCalc->GetKappaIndex() << std::endl << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbAtmosphericEffects.cxx000066400000000000000000000125021301006202600272570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbSatelliteRSR.h" #include "otbAtmosphericEffects.h" #include "otbReduceSpectralResponse.h" #include "otbAtmosphericCorrectionParameters.h" #include "otbImageMetadataCorrectionParameters.h" int otbAtmosphericEffects(int argc, char * argv[]) { typedef otb::SpectralResponse< double, double> SpectralResponseType; typedef otb::SatelliteRSR< double, double> SatRSRType; typedef otb::ReduceSpectralResponse< SpectralResponseType, SatRSRType> ReduceSpectralResponseType; typedef otb::AtmosphericEffects< SpectralResponseType, SatRSRType> AtmosphericEffectsType; typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType; typedef otb::AtmosphericCorrectionParameters AtmoCorrectionParametersType; typedef AtmoCorrectionParametersType::Pointer AtmoCorrectionParametersPointerType; typedef AtmoCorrectionParametersType::AerosolModelType AerosolModelType; typedef otb::ImageMetadataCorrectionParameters AcquiCorrectionParametersType; typedef AcquiCorrectionParametersType::Pointer AcquiCorrectionParametersPointerType; typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; typedef AtmosphericRadiativeTermsType::Pointer AtmosphericRadiativeTermsPointerType; if ( argc!= 15 ) { std::cout <" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << std::endl; return EXIT_FAILURE; } const std::string file(argv[1]); const std::string fileSatG(argv[2]); unsigned int nbBand = atoi(argv[3]); const int day(atoi(argv[4])); const int month(atoi(argv[5])); const double zenithSolarAngle(static_cast(atof(argv[6]))); const double azimutSolarAngle(static_cast(atof(argv[7]))); const double viewingZenitalAngle(static_cast(atof(argv[8]))); const double viewingAzimutalAngle(static_cast(atof(argv[9]))); const double atmoPressure(static_cast(atof(argv[10]))); const double waterVaporAmount(static_cast(atof(argv[11]))); const double ozoneAmount(static_cast(atof(argv[12]))); const int aerosolModelValue(::atoi(argv[13])); const double aerosolOptical( static_cast(atof(argv[14])) ); //Instantiation SpectralResponseType::Pointer spectrum = SpectralResponseType::New(); SatRSRType::Pointer satRSR=SatRSRType::New(); //AtmosphericCorrectionParametersType::Pointer dataAtmosphericCorrectionParameters = AtmosphericCorrectionParametersType::New(); AcquiCorrectionParametersPointerType paramAcqui = AcquiCorrectionParametersType::New(); AtmoCorrectionParametersPointerType paramAtmo = AtmoCorrectionParametersType::New(); ReduceSpectralResponseType::Pointer reduceSpectralResponse = ReduceSpectralResponseType::New(); AtmosphericEffectsType::Pointer atmosphericEffectsFilter = AtmosphericEffectsType::New(); spectrum->Load(file, 100.0); satRSR->SetNbBands(nbBand); satRSR->Load(fileSatG); // Set parameters paramAcqui->SetSolarZenithalAngle(zenithSolarAngle); paramAcqui->SetSolarAzimutalAngle(azimutSolarAngle); paramAcqui->SetViewingZenithalAngle(viewingZenitalAngle); paramAcqui->SetViewingAzimutalAngle(viewingAzimutalAngle); paramAcqui->SetMonth(month); paramAcqui->SetDay(day); paramAtmo->SetAtmosphericPressure(atmoPressure); paramAtmo->SetWaterVaporAmount(waterVaporAmount); paramAtmo->SetOzoneAmount(ozoneAmount); AerosolModelType aerosolModel = static_cast(aerosolModelValue); paramAtmo->SetAerosolModel(aerosolModel); paramAtmo->SetAerosolOptical(aerosolOptical); AtmosphericRadiativeTermsPointerType radiative = CorrectionParametersToRadiativeTermsType::Compute(paramAtmo,paramAcqui); //Compute Reduce Spectral Response reduceSpectralResponse->SetInputSatRSR(satRSR); reduceSpectralResponse->SetInputSpectralResponse(spectrum); reduceSpectralResponse->CalculateResponse(); atmosphericEffectsFilter->SetAtmosphericRadiativeTerms(radiative); atmosphericEffectsFilter->SetInputSatRSR(satRSR); atmosphericEffectsFilter->SetInputSpectralResponse(reduceSpectralResponse->GetReduceResponse()); atmosphericEffectsFilter->Process(); atmosphericEffectsFilter->GetCorrectedSpectralResponse(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbFilterFunctionValues.cxx000066400000000000000000000070041301006202600276150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSIXSTraits.h" #include #include #include "otbObjectList.h" #include "itksys/SystemTools.hxx" #include "otbSpectralResponse.h" int otbFilterFunctionValuesSpectralResponseTest(int argc, char * argv[]) { if ( argc!=4) { std::cout << argv[0] << std::endl << "\t" << "" << "\t" << ""<< "\t" << ""< ResponseType; typedef ResponseType::Pointer ResponsePointerType; typedef otb::FilterFunctionValues FilterFunctionValuesType; //Instantiation ResponsePointerType myResponse=ResponseType::New(); //Load file into vector myResponse->Load(inFile, 100.0); //itk::Indent ind; typedef otb::FilterFunctionValues FilterFunctionValuesType; // Instantiating object FilterFunctionValuesType::Pointer filterFunctionValues=myResponse->GetFilterFunctionValues(step); FilterFunctionValuesType::ValuesVectorType object= filterFunctionValues->GetFilterFunctionValues(); // Writing output file std::ofstream file; file.open(outname); file << "Output vector :" << std::endl; for (unsigned int i = 0; i < object.size(); ++i) { file << object[i] << std::endl; } file << std::endl; file << "L_min :" << filterFunctionValues->GetMinSpectralValue() << std::endl; file << "L_max :" << filterFunctionValues->GetMaxSpectralValue() << std::endl; file.close(); return EXIT_SUCCESS; } int otbFilterFunctionValuesTest(int argc, char * argv[]) { char * outname = argv[1]; const double SIXSStepOfWavelengthSpectralBandValues(0.0025); typedef otb::FilterFunctionValues FilterFunctionValuesType; // Instantiating object FilterFunctionValuesType::Pointer object = FilterFunctionValuesType::New(); FilterFunctionValuesType::ValuesVectorType vect; for (int i = 5; i < argc; ++i) { vect.push_back(atof(argv[i])); } object->SetMinSpectralValue(atof(argv[2])); object->SetMaxSpectralValue(atof(argv[3])); object->SetUserStep(atof(argv[4])); object->SetFilterFunctionValues(vect); // Call interpolate otb::SIXSTraits::ComputeWavelengthSpectralBandValuesFor6S( SIXSStepOfWavelengthSpectralBandValues, object); // Writing output file std::ofstream file; file.open(outname); file << "Input Vector :" << std::endl; for (unsigned int i = 0; i < vect.size(); ++i) { file << vect[i] << std::endl; } file << std::endl; file << "Output vector :" << std::endl; for (unsigned int i = 0; i < object->GetFilterFunctionValues6S().size(); ++i) { file << object->GetFilterFunctionValues6S()[i] << std::endl; } file << std::endl; file << "L_min :" << object->GetMinSpectralValue() << std::endl; file << "L_max :" << object->GetMaxSpectralValue() << std::endl; file.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbImageSimulationMethodKMeansClassif.cxx000066400000000000000000000166121301006202600323430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataToLabelMapWithAttributesFilter.h" #include "otbSpatialisationFilter.h" #include "otbImageSimulationMethod.h" #include "otbAttributesMapLabelObject.h" #include "otbImageFileReader.h" #include "itkWeightedCentroidKdTreeGenerator.h" #include "itkKdTreeBasedKmeansEstimator.h" #include "otbKMeansImageClassificationFilter.h" int otbImageSimulationMethodKMeansClassif(int itkNotUsed(argc), char * argv[]) { const char * satRSRFilename = argv[1]; unsigned int nbBands = static_cast(atoi(argv[2])); const char * rootPath = argv[3]; unsigned int radius = atoi(argv[4]); const char * outfilename = argv[5]; const char * outLabelfilename = argv[6]; const unsigned int nbClasses = 4; double ConvergenceThreshold = 0.0001; unsigned int NumberOfIterations = 1000; typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::Image LabelImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileWriter ImageWriterType; typedef otb::ImageFileWriter LabelImageWriterType; typedef otb::VectorData VectorDataType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::SpatialisationFilter SpatialisationFilterType; typedef otb::ProspectModel SimulationStep1Type; typedef otb::SailModel SimulationStep2Type; typedef otb::ProlateInterpolateImageFunction FTMType; typedef otb::ImageSimulationMethod ImageSimulationMethodType; typedef OutputImageType::PixelType SampleType; typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::WeightedCentroidKdTreeGenerator TreeGeneratorType; typedef TreeGeneratorType::KdTreeType TreeType; typedef itk::Statistics::KdTreeBasedKmeansEstimator EstimatorType; typedef otb::KMeansImageClassificationFilter ClassificationFilterType; typedef itk::ImageRegionIterator ImageRegionIteratorType; /** Instantiation of pointer objects*/ ImageWriterType::Pointer writer = ImageWriterType::New(); LabelImageWriterType::Pointer labelWriter = LabelImageWriterType::New(); ImageSimulationMethodType::Pointer imageSimulation = ImageSimulationMethodType::New(); SpatialisationFilterType::Pointer spatialisationFilter = SpatialisationFilterType::New(); ClassificationFilterType::Pointer classifier = ClassificationFilterType::New(); SpatialisationFilterType::SizeType objectSize; objectSize[0]=300; objectSize[1]=300; SpatialisationFilterType::SizeType nbOjects; nbOjects[0]=2; nbOjects[1]=2; std::vector pathVector(nbClasses); pathVector[0]="JHU/becknic/rocks/sedimentary/powder/0_75/txt/greywa1f.txt"; pathVector[1]=""; pathVector[2]="JHU/becknic/water/txt/coarse.txt"; pathVector[3]="JHU/becknic/soils/txt/0015c.txt"; std::vector areaVector(nbClasses); areaVector[0]="sedimentaryRock"; areaVector[1]="prosail"; areaVector[2]="water"; areaVector[3]="soils"; std::vector labels(nbClasses); labels[0]=1; labels[1]=2; labels[2]=3; labels[3]=4; spatialisationFilter->SetObjectSize(objectSize); spatialisationFilter->SetNumberOfObjects(nbOjects); spatialisationFilter->SetPathVector(pathVector); spatialisationFilter->SetAreaVector(areaVector); spatialisationFilter->SetLabels(labels); imageSimulation->SetSpatialisation(spatialisationFilter); imageSimulation->SetNumberOfComponentsPerPixel(nbBands); imageSimulation->SetSatRSRFilename(satRSRFilename); imageSimulation->SetPathRoot(rootPath); imageSimulation->SetRadius(radius); // imageSimulation->SetMean(); // imageSimulation->SetVariance(); imageSimulation->UpdateData(); imageSimulation->GetOutputReflectanceImage()->Update(); //get all the pixel of the image for KMeans centroid estimation OutputImageType::IndexType centroidIndex; centroidIndex[0]=objectSize[0]/2; centroidIndex[1]=objectSize[1]/2; EstimatorType::ParametersType initialCentroids(nbBands * nbClasses); ImageRegionIteratorType it(imageSimulation->GetOutputReflectanceImage(), imageSimulation->GetOutputReflectanceImage()->GetLargestPossibleRegion()); it.GoToBegin(); ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(nbBands); unsigned int x=0; unsigned int classIndex=0; while(!it.IsAtEnd()) { if(it.GetIndex()==centroidIndex) { for(unsigned int j=0; jPushBack(it.Get()); ++it; } TreeGeneratorType::Pointer treeGenerator = TreeGeneratorType::New(); treeGenerator->SetSample(listSample); treeGenerator->SetBucketSize(100 / (10 * nbClasses)); treeGenerator->Update(); EstimatorType::Pointer estimator = EstimatorType::New(); estimator->SetKdTree(treeGenerator->GetOutput()); estimator->SetParameters(initialCentroids); estimator->SetMaximumIteration(NumberOfIterations); estimator->SetCentroidPositionChangesThreshold(ConvergenceThreshold); estimator->StartOptimization(); classifier->SetCentroids(estimator->GetParameters()); classifier->SetInput(imageSimulation->GetOutputReflectanceImage()); //Write the result to an image file writer->SetFileName(outfilename); writer->SetInput(imageSimulation->GetOutputReflectanceImage()); writer->Update(); labelWriter->SetFileName(outLabelfilename); // labelWriter->SetInput(imageSimulation->GetOutputLabelImage()); labelWriter->SetInput(classifier->GetOutput()); labelWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbImageSimulationMethodSVMClassif.cxx000066400000000000000000000142651301006202600316340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ //Warning !! the SVM model estimator do not converge in this test !! #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataToLabelMapWithAttributesFilter.h" #include "otbSpatialisationFilter.h" #include "otbImageSimulationMethod.h" #include "otbAttributesMapLabelObject.h" #include "otbSVMImageModelEstimator.h" #include "otbSVMImageClassificationFilter.h" #include "otbImageFileReader.h" int otbImageSimulationMethodSVMClassif(int itkNotUsed(argc), char * argv[]) { const char * satRSRFilename = argv[1]; unsigned int nbBands = static_cast(atoi(argv[2])); const char * rootPath = argv[3]; unsigned int radius = atoi(argv[4]); const char * outfilename = argv[5]; const char * outLabelfilename = argv[6]; typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::Image LabelImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileWriter ImageWriterType; typedef otb::ImageFileWriter LabelImageWriterType; typedef otb::VectorData VectorDataType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::SpatialisationFilter SpatialisationFilterType; // typedef otb::VectorDataToLabelMapWithAttributesFilter SpatialisationFilterType; typedef otb::ProspectModel SimulationStep1Type; typedef otb::SailModel SimulationStep2Type; typedef otb::ProlateInterpolateImageFunction FTMType; typedef otb::ImageSimulationMethod ImageSimulationMethodType; typedef otb::SVMImageModelEstimator SVMEstimatorType; typedef otb::SVMImageClassificationFilter SVMClassificationFilterType; /** Instantiation of pointer objects*/ ImageWriterType::Pointer writer = ImageWriterType::New(); LabelImageWriterType::Pointer labelWriter = LabelImageWriterType::New(); ImageSimulationMethodType::Pointer imageSimulation = ImageSimulationMethodType::New(); SpatialisationFilterType::Pointer spatialisationFilter = SpatialisationFilterType::New(); SVMEstimatorType::Pointer svmEstimator = SVMEstimatorType::New(); SVMClassificationFilterType::Pointer classifier = SVMClassificationFilterType::New(); SpatialisationFilterType::SizeType objectSize; objectSize[0]=300; objectSize[1]=300; SpatialisationFilterType::SizeType nbOjects; nbOjects[0]=2; nbOjects[1]=1; std::vector pathVector(2); pathVector[0]="JHU/becknic/rocks/sedimentary/powder/0_75/txt/greywa1f.txt"; pathVector[1]=""; // pathVector[2]="JHU/becknic/manmade/txt/0092uuu.txt"; // pathVector[3]="JHU/becknic/vegetation/txt/conifers.txt"; // pathVector[4]="JHU/becknic/manmade/txt/0834uuu.txt"; // pathVector[5]="JHU/becknic/vegetation/txt/grass.txt"; // pathVector[6]="JHU/becknic/water/txt/coarse.txt"; // pathVector[7]="JHU/becknic/rocks/igneous/solid/txt/andesi1s.txt"; // pathVector[8]="JHU/becknic/soils/txt/0015c.txt"; std::vector areaVector(2); areaVector[0]="sedimentaryRock"; areaVector[1]="prosail"; // areaVector[2]="manmade"; // areaVector[3]="conifers"; // areaVector[4]="manmade"; // areaVector[5]="grass"; // areaVector[6]="water"; // areaVector[7]="igneousRocks"; // areaVector[8]="soils"; std::vector labels(2); labels[0]=1; labels[1]=2; // labels[2]=1; // labels[3]=2; // labels[4]=3; // labels[5]=2; // labels[6]=4; // labels[7]=5; // labels[8]=3; spatialisationFilter->SetObjectSize(objectSize); spatialisationFilter->SetNumberOfObjects(nbOjects); spatialisationFilter->SetPathVector(pathVector); spatialisationFilter->SetAreaVector(areaVector); spatialisationFilter->SetLabels(labels); imageSimulation->SetSpatialisation(spatialisationFilter); imageSimulation->SetNumberOfComponentsPerPixel(nbBands); imageSimulation->SetSatRSRFilename(satRSRFilename); imageSimulation->SetPathRoot(rootPath); imageSimulation->SetRadius(radius); // imageSimulation->SetMean(); // imageSimulation->SetVariance(); imageSimulation->UpdateData(); svmEstimator->SetInputImage(imageSimulation->GetOutputReflectanceImage()); svmEstimator->SetTrainingImage(imageSimulation->GetOutputLabelImage()); svmEstimator->SetParametersOptimization(false); svmEstimator->DoProbabilityEstimates(true); svmEstimator->Update(); classifier->SetModel(svmEstimator->GetModel()); classifier->SetInput(imageSimulation->GetOutput()); //Write the result to an image file writer->SetFileName(outfilename); writer->SetInput(imageSimulation->GetOutputReflectanceImage()); writer->Update(); labelWriter->SetFileName(outLabelfilename); // labelWriter->SetInput(imageSimulation->GetOutputLabelImage()); labelWriter->SetInput(classifier->GetOutput()); labelWriter->Update(); return EXIT_SUCCESS; } otbImageSimulationMethodWithSpatialisationTest.cxx000066400000000000000000000117661301006202600342660ustar00rootroot00000000000000OTB-release-5.8/Modules/Radiometry/Simulation/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include "otbVectorDataFileReader.h" #include "otbSpatialisationFilter.h" #include "otbImageSimulationMethod.h" #include "otbAttributesMapLabelObject.h" #include "otbImageFileReader.h" int otbImageSimulationMethodWithSpatialisationTest(int itkNotUsed(argc), char * argv[]) { const char * satRSRFilename = argv[1]; unsigned int nbBands = static_cast(atoi(argv[2])); const char * rootPath = argv[3]; unsigned int radius = atoi(argv[4]); const char * outfilename = argv[5]; const char * outLabelfilename = argv[6]; typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::Image LabelImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileWriter ImageWriterType; typedef otb::ImageFileWriter LabelImageWriterType; typedef otb::VectorData VectorDataType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::SpatialisationFilter SpatialisationFilterType; typedef otb::ProspectModel SimulationStep1Type; typedef otb::SailModel SimulationStep2Type; typedef otb::ProlateInterpolateImageFunction FTMType; typedef otb::ImageSimulationMethod ImageSimulationMethodType; /** Instantiation of pointer objects*/ ImageWriterType::Pointer writer = ImageWriterType::New(); LabelImageWriterType::Pointer labelWriter = LabelImageWriterType::New(); ImageSimulationMethodType::Pointer imageSimulation = ImageSimulationMethodType::New(); SpatialisationFilterType::Pointer spatialisationFilter = SpatialisationFilterType::New(); SpatialisationFilterType::SizeType objectSize; objectSize[0]=300; objectSize[1]=300; SpatialisationFilterType::SizeType nbOjects; nbOjects[0]=3; nbOjects[1]=3; std::vector pathVector(9); pathVector[0]="JHU/becknic/rocks/sedimentary/powder/0_75/txt/greywa1f.txt"; pathVector[1]=""; pathVector[2]="JHU/becknic/manmade/txt/0092uuu.txt"; pathVector[3]="JHU/becknic/vegetation/txt/conifers.txt"; pathVector[4]="JHU/becknic/manmade/txt/0834uuu.txt"; pathVector[5]="JHU/becknic/vegetation/txt/grass.txt"; pathVector[6]="JHU/becknic/water/txt/coarse.txt"; pathVector[7]="JHU/becknic/rocks/igneous/solid/txt/andesi1s.txt"; pathVector[8]="JHU/becknic/soils/txt/0015c.txt"; std::vector areaVector(9); areaVector[0]="sedimentaryRock"; areaVector[1]="prosail"; areaVector[2]="manmade"; areaVector[3]="conifers"; areaVector[4]="manmade"; areaVector[5]="grass"; areaVector[6]="water"; areaVector[7]="igneousRocks"; areaVector[8]="soils"; std::vector labels(9); labels[0]=1; labels[1]=2; labels[2]=1; labels[3]=2; labels[4]=3; labels[5]=2; labels[6]=4; labels[7]=5; labels[8]=3; spatialisationFilter->SetObjectSize(objectSize); spatialisationFilter->SetNumberOfObjects(nbOjects); spatialisationFilter->SetPathVector(pathVector); spatialisationFilter->SetAreaVector(areaVector); spatialisationFilter->SetLabels(labels); imageSimulation->SetSpatialisation(spatialisationFilter); imageSimulation->SetNumberOfComponentsPerPixel(nbBands); imageSimulation->SetSatRSRFilename(satRSRFilename); imageSimulation->SetPathRoot(rootPath); imageSimulation->SetRadius(radius); // imageSimulation->SetMean(); // imageSimulation->SetVariance(); imageSimulation->UpdateData(); //Write the result to an image file writer->SetFileName(outfilename); writer->SetInput(imageSimulation->GetOutputReflectanceImage()); writer->Update(); labelWriter->SetFileName(outLabelfilename); labelWriter->SetInput(imageSimulation->GetOutputLabelImage()); labelWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbImageSimulationMethodWithVectorDataTest.cxx000066400000000000000000000100271301006202600334020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImage.h" #include "otbImageFileWriter.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataToLabelMapWithAttributesFilter.h" #include "otbImageSimulationMethod.h" #include "otbAttributesMapLabelObject.h" #include "otbImageFileReader.h" int otbImageSimulationMethodWithVectorDataTest(int itkNotUsed(argc), char * argv[]) { const char * infilename = argv[1]; const char * satRSRFilename = argv[2]; unsigned int nbBands = static_cast(atoi(argv[3])); const char * rootPath = argv[4]; unsigned int radius = atoi(argv[5]); const char * outfilename = argv[6]; const char * outLabelfilename = argv[7]; typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::Image LabelImageType; typedef otb::VectorImage OutputImageType; typedef otb::ImageFileWriter ImageWriterType; typedef otb::ImageFileWriter LabelImageWriterType; typedef otb::VectorData VectorDataType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::VectorDataFileReader VectorDataFileReaderType; typedef otb::VectorDataToLabelMapWithAttributesFilter SpatialisationFilterType; typedef otb::ProspectModel SimulationStep1Type; typedef otb::SailModel SimulationStep2Type; typedef otb::ProlateInterpolateImageFunction FTMType; typedef otb::ImageSimulationMethod ImageSimulationMethodType; /** Instantiation of pointer objects*/ VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); ImageWriterType::Pointer writer = ImageWriterType::New(); LabelImageWriterType::Pointer labelWriter = LabelImageWriterType::New(); ImageSimulationMethodType::Pointer imageSimulation = ImageSimulationMethodType::New(); SpatialisationFilterType::Pointer spatialisationFilter = SpatialisationFilterType::New(); reader->SetFileName(infilename); reader->Update(); spatialisationFilter->SetInput(reader->GetOutput()); spatialisationFilter->SetInitialLabel(1); spatialisationFilter->SetBackgroundValue(0); imageSimulation->SetSpatialisation(spatialisationFilter); imageSimulation->SetNumberOfComponentsPerPixel(nbBands); imageSimulation->SetSatRSRFilename(satRSRFilename); imageSimulation->SetPathRoot(rootPath); imageSimulation->SetRadius(radius); // imageSimulation->SetMean(); // imageSimulation->SetVariance(); imageSimulation->UpdateData(); //Write the result to an image file writer->SetFileName(outfilename); writer->SetInput(imageSimulation->GetOutputReflectanceImage()); writer->Update(); labelWriter->SetFileName(outLabelfilename); labelWriter->SetInput(imageSimulation->GetOutputLabelImage()); labelWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbLabelMapToSimulatedImageFilterTest.cxx000066400000000000000000000064471301006202600323150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorData.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataToLabelMapWithAttributesFilter.h" #include "otbAttributesMapLabelObject.h" #include "otbVectorImage.h" #include "otbImageFileWriter.h" #include "otbLabelMapToSimulatedImageFilter.h" #include "otbProspectModel.h" #include "otbSailModel.h" int otbLabelMapToSimulatedImageFilterTest(int itkNotUsed(argc), char * argv[]) { const char * infilename = argv[1]; const char * satRSRFilename = argv[2]; unsigned int nbBands = static_cast(atoi(argv[3])); const char * rootPath = argv[4]; const char * outfilename = argv[5]; typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::VectorImage LabeledImageType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorData VectorDataType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::VectorDataFileReader VectorDataFileReaderType; typedef otb::VectorDataToLabelMapWithAttributesFilter VectorDataToLabelMapFilterType; typedef otb::ProspectModel ProspectType; typedef otb::SailModel SailType; typedef otb::LabelMapToSimulatedImageFilter LabelMapToSimulatedImageFilterType; /** Instantiation of pointer objects*/ VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); VectorDataToLabelMapFilterType::Pointer vectorDataToLabelMap = VectorDataToLabelMapFilterType::New(); LabelMapToSimulatedImageFilterType::Pointer labelMapToImageFilter = LabelMapToSimulatedImageFilterType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infilename); reader->Update(); vectorDataToLabelMap->SetInput(reader->GetOutput()); vectorDataToLabelMap->SetInitialLabel(1); vectorDataToLabelMap->SetBackgroundValue(0); labelMapToImageFilter->SetInput(vectorDataToLabelMap->GetOutput()); labelMapToImageFilter->SetNumberOfComponentsPerPixel(nbBands); labelMapToImageFilter->SetSatRSRFilename(satRSRFilename); labelMapToImageFilter->SetNumberOfThreads(1); // must be set to 1 labelMapToImageFilter->SetPathRoot(rootPath); //Write the result to an image file writer->SetFileName(outfilename); writer->SetInput(labelMapToImageFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbProspectReflTest.cxx000066400000000000000000000035271301006202600267600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbProspectModel.h" #include #include int otbProspectReflTest(int argc, char * argv[]) { if(argc != 8) { std::cout<<"Wrong number of arguments !"<(atof(argv[1])); double Car=static_cast(atof(argv[2])); double CBrown=static_cast(atof(argv[3])); double Cw=static_cast(atof(argv[4])); double Cm=static_cast(atof(argv[5])); double N=static_cast(atof(argv[6])); char * OutputName = argv[7]; //typedef typedef otb::ProspectModel PropectType; typedef otb::LeafParameters LeafParametersType; //instantiation LeafParametersType::Pointer leafParams = LeafParametersType::New(); PropectType::Pointer prospect = PropectType::New(); leafParams->SetCab(Cab); leafParams->SetCar(Car); leafParams->SetCBrown(CBrown); leafParams->SetCw(Cw); leafParams->SetCm(Cm); leafParams->SetN(N); prospect->SetInput(leafParams); prospect->Update(); std::ofstream outputFile(OutputName, std::ios::out); for(unsigned int i=0; iGetReflectance()->Size(); ++i) { outputFile<GetReflectance()->GetResponse()[i].second< #include int otbProspectTransTest(int argc, char * argv[]) { if(argc != 8) { std::cout<<"Wrong number of arguments !"<(atof(argv[1])); double Car=static_cast(atof(argv[2])); double CBrown=static_cast(atof(argv[3])); double Cw=static_cast(atof(argv[4])); double Cm=static_cast(atof(argv[5])); double N=static_cast(atof(argv[6])); char * OutputName = argv[7]; typedef otb::ProspectModel PropectType; typedef otb::LeafParameters LeafParametersType; LeafParametersType::Pointer leafParams = LeafParametersType::New(); PropectType::Pointer prospect = PropectType::New(); leafParams->SetCab(Cab); leafParams->SetCar(Car); leafParams->SetCBrown(CBrown); leafParams->SetCw(Cw); leafParams->SetCm(Cm); leafParams->SetN(N); prospect->SetInput(leafParams); prospect->Update(); std::ofstream outputFile(OutputName, std::ios::out); for(unsigned int i=0; iGetTransmittance()->Size(); ++i) { outputFile<GetTransmittance()->GetResponse()[i].second< ResponseType; typedef ResponseType::Pointer ResponsePointerType; typedef ResponseType::VectorPairType SpectrumType; typedef ResponseType::PairType PairType; typedef otb::SatelliteRSR SatRSRType; typedef SatRSRType::Pointer SatRSRPointerType; typedef otb::ReduceSpectralResponse ReduceResponseType; typedef ReduceResponseType::Pointer ReduceResponseTypePointerType; int otbReduceSpectralResponse(int argc, char * argv[]) { if ((argc != 5) && (argc != 6)) { std::cout << argv[0] << std::endl << "\t" << ""; std::cout << "\t" << "" << "\t" << ""; std::cout << "\t" << "" << "\t" << "()" << std::endl; return EXIT_FAILURE; } const std::string spectreFile(argv[1]); const std::string RSRfile(argv[2]); unsigned int nbBand = atoi(argv[3]); bool reflectanceMode(atoi(argv[4])); //Instantiation ResponsePointerType mySpectralResponse = ResponseType::New(); /** Load the spectral response file*/ mySpectralResponse->Load(spectreFile, 100.0); SatRSRPointerType myRSR = SatRSRType::New(); /** Set the satellite number of bands */ myRSR->SetNbBands(nbBand); /** Load the satellite response file*/ myRSR->Load(RSRfile); //Instantiation ReduceResponseTypePointerType myReduceResponse = ReduceResponseType::New(); /** Load the satellite response in the simulator */ myReduceResponse->SetInputSatRSR(myRSR); /** Load the spectral response of the object in the simulator*/ myReduceResponse->SetInputSpectralResponse(mySpectralResponse); /** Set the reflectance or luminance mode */ myReduceResponse->SetReflectanceMode(reflectanceMode); myReduceResponse->CalculateResponse(); /** Print the Reduce SR*/ std::cout << myReduceResponse << std::endl; if (argc == 6) { char * outputName = argv[5]; std::ofstream outputFile(outputName, std::ios::out); outputFile << myReduceResponse << std::endl; } else std::cout << myReduceResponse << std::endl; return EXIT_SUCCESS; } bool check_spectral_response(ResponsePointerType spectralResponse, SpectrumType::const_iterator first, SpectrumType::const_iterator last, ResponseType::ValuePrecisionType tolerance) { while( first != last ) { ResponseType::ValuePrecisionType expected = (*first).second; ResponseType::ValuePrecisionType actual = (*spectralResponse)((*first).first); if(fabs(expected - actual) > tolerance) return false; ++first; } return true; } int otbReduceSpectralResponseSimpleValues(int argc, char * argv[]) { if (argc != 3) { std::cout << argv[0] << "\t "; std::cout << "\t "; std::cout << std::endl; return EXIT_FAILURE; } // let's create a spectral response const ResponseType::PrecisionType lambdaMin(0.4); const ResponseType::PrecisionType lambdaMax(1.4); const ResponseType::PrecisionType lambdaStep(0.001); ResponseType::PrecisionType currentLambda(lambdaMin); SpectrumType spectrum; while(currentLambda < lambdaMax) { PairType spectralValue; spectralValue.first = currentLambda; spectralValue.second = ResponseType::ValuePrecisionType(1.0); spectrum.push_back(spectralValue); currentLambda += lambdaStep; } ResponsePointerType spectralResponse = ResponseType::New(); spectralResponse->SetResponse(spectrum); // Check that the spectral response is OK const ResponseType::ValuePrecisionType tolerance = 10e-6; if(!check_spectral_response(spectralResponse, spectrum.begin(), spectrum.end(), tolerance)) { std::cout << "Error detected in stored spectral response (without guess)" << std::endl; return EXIT_FAILURE; } spectralResponse->SetUsePosGuess(true); if(!check_spectral_response(spectralResponse, spectrum.begin(), spectrum.end(), tolerance)) { std::cout << "Error detected in stored spectral response (with guess)" << std::endl; return EXIT_FAILURE; } // Let's create a satellite RSR with 2 bands and constant solar irradiance per band // Disjoint bands and B0 is shorter wavelength than B1 for simplicity const std::string RSRfileName(argv[1]); std::ofstream satFile(RSRfileName.c_str()); const ResponseType::PrecisionType lambdaMinB0(0.45); const ResponseType::PrecisionType lambdaMaxB0(0.65); const ResponseType::PrecisionType lambdaMinB1(0.75); const ResponseType::PrecisionType lambdaMaxB1(0.85); const ResponseType::ValuePrecisionType rsrValueB0(0.5); const ResponseType::ValuePrecisionType rsrValueB1(1.0); const ResponseType::ValuePrecisionType solarIrradianceB0(2.0); const ResponseType::ValuePrecisionType solarIrradianceB1(4.0); currentLambda = lambdaMin; while(currentLambda < lambdaMax) { ResponseType::ValuePrecisionType solarIrradiance(0); ResponseType::ValuePrecisionType rsrB0(0); ResponseType::ValuePrecisionType rsrB1(0); // B0 if(currentLambda >= lambdaMinB0 && currentLambda <= lambdaMaxB0) { solarIrradiance = solarIrradianceB0; rsrB0 = rsrValueB0; } // B1 if(currentLambda >= lambdaMinB1 && currentLambda <= lambdaMaxB1) { solarIrradiance = solarIrradianceB1; rsrB1 = rsrValueB1; } satFile.setf( std::ios::fixed, std:: ios::floatfield ); satFile.precision(4); satFile << currentLambda << "\t" << solarIrradiance << "\t" << rsrB0 << "\t" << rsrB1 << "\t" << std::endl; currentLambda += lambdaStep; } satFile.close(); SatRSRPointerType myRSR = SatRSRType::New(); myRSR->SetNbBands(2); myRSR->Load(RSRfileName); ReduceResponseTypePointerType myReduceResponse = ReduceResponseType::New(); myReduceResponse->SetInputSatRSR(myRSR); myReduceResponse->SetInputSpectralResponse(spectralResponse); myReduceResponse->SetReflectanceMode(static_cast(atoi(argv[2]))); myReduceResponse->CalculateResponse(); //check B0 ResponseType::ValuePrecisionType b0Result = (*myReduceResponse)(0); ResponseType::PrecisionType centralLambda = 0.5*(lambdaMaxB0+lambdaMinB0); ResponseType::ValuePrecisionType b0Expected = ((*spectralResponse)(centralLambda)); if(fabs(b0Result-b0Expected)>tolerance) { std::cout << "Wrong value for B0: expected eq. luminance = " << b0Expected << "; got " << b0Result << std::endl; return EXIT_FAILURE; } //check B1 ResponseType::ValuePrecisionType b1Result = (*myReduceResponse)(1); centralLambda = 0.5*(lambdaMaxB1+lambdaMinB1); ResponseType::ValuePrecisionType b1Expected = ((*spectralResponse)(centralLambda)); if(fabs(b1Result-b1Expected)>tolerance) { std::cout << "Wrong value for B1: expected eq. luminance = " << b1Expected << "; got " << b1Result << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbReduceSpectralResponseClassifierRAndNIR.cxx000066400000000000000000000056201301006202600332530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbSatelliteRSR.h" #include "otbReduceSpectralResponseClassifierRAndNIR.h" int otbReduceSpectralResponseClassifierRAndNIR(int argc, char * argv[]) { if ( argc!=6 ) { std::cout << argv[0] << std::endl << "\t" << ""<< "\t" << ""<< "\t" << "" << "\t" << ""<< "\t" << ""<< std::endl; //bin/otbReduceSpectralResponseFunctor ~/manuel/Datas_Geos/Simulateur_Spectres/usgs_datas/JHU/becknic/vegetation/txt/grass.txt ~/manuel/Datas_Geos/Rsr/SPOT3/HRV1/rep6S.dat 3 1 > a.out // bin/otbReduceSpectralResponseClassifierRAndNIR ~/manuel/Datas_Geos/Simulateur_Spectres/usgs_datas/JHU/becknic/vegetation/txt/decidous.txt ~/manuel/Datas_Geos/Rsr/SPOT5/VEGETATION/rep6S.dat 4 1 2 return EXIT_FAILURE; } typedef otb::SpectralResponse< double, double> ResponseType; typedef otb::SatelliteRSR< double, double> SatRSRType; typedef otb::ReduceSpectralResponse < ResponseType, SatRSRType> ReduceResponseType; typedef ReduceResponseType::Pointer ReduceResponseTypePointerType; typedef otb::Functor::NDVI TFunctionType; typedef otb::ReduceSpectralResponseClassifierRAndNIR ReduceSpectralResponseClassifierRAndNIRType; typedef ReduceSpectralResponseClassifierRAndNIRType::Pointer ReduceSpectralResponseClassifierRAndNIRPointerType; const std::string spectreFile(argv[1]); const std::string RSRfile(argv[2]); unsigned int nbBand = atoi(argv[3]); unsigned int RBand = atoi(argv[4]); unsigned int NIRBand = atoi(argv[5]); ReduceResponseTypePointerType myReduceResponse=ReduceResponseType::New(); //Instantiation //ResponsePointerType myResponse=ResponseType::New(); /** Load the spectral response of the object and the satellite response in the simulator */ myReduceResponse->LoadInputsFromFiles(spectreFile, RSRfile, nbBand, 100.0, 1.0); //Instantiation ReduceSpectralResponseClassifierRAndNIRPointerType myIndice=ReduceSpectralResponseClassifierRAndNIRType::New(); myIndice->SetInputReduceSpectralResponse(myReduceResponse); //FunctorType //myIndice->SetFunctor(myReduceResponse); myIndice->SetRBandNumber(RBand); myIndice->SetNIRBandNumber(NIRBand); std::cout << "NDVI value " << (*myIndice)() << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbReduceSpectralResponseNew.cxx000066400000000000000000000023261301006202600306020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbSatelliteRSR.h" #include "otbReduceSpectralResponse.h" int otbReduceSpectralResponseNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::SpectralResponse< double, double> ResponseType; //typedef ResponseType::Pointer ResponsePointerType; typedef otb::SatelliteRSR< double, double> SatRSRType; //typedef SatRSRType::Pointer SatRSRPointerType; typedef otb::ReduceSpectralResponse < ResponseType, SatRSRType> ReduceResponseType; typedef ReduceResponseType::Pointer ReduceResponseTypePointerType; //Instantiation ReduceResponseTypePointerType myResponse=ReduceResponseType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbReduceSpectralResponseSVMClassifier.cxx000066400000000000000000000233531301006202600325260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSatelliteRSR.h" #include "otbReduceSpectralResponse.h" #include "otbSVMSampleListModelEstimator.h" #include "otbSVMClassifier.h" #include "otbConfusionMatrixCalculator.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include int otbReduceSpectralResponseSVMClassifier(int argc, char * argv[]) { typedef otb::SpectralResponse ResponseType; typedef ResponseType::Pointer ResponsePointerType; typedef otb::SatelliteRSR SatRSRType; typedef SatRSRType::Pointer SatRSRPointerType; typedef otb::ReduceSpectralResponse ReduceResponseType; typedef ReduceResponseType::Pointer ReduceResponseTypePointerType; typedef itk::VariableLengthVector SampleType; typedef itk::Statistics::ListSample SampleListType; typedef itk::FixedArray TrainingSampleType; typedef itk::Statistics::ListSample TrainingSampleListType; typedef otb::SVMSampleListModelEstimator SVMModelEstimatorType; typedef otb::SVMClassifier SVMClassifierType; typedef SVMClassifierType::OutputType ClassifierOutputType; typedef otb::ConfusionMatrixCalculator ConfusionMatrixCalculatorType; if (argc != 9) { std::cout << argv[0] << std::endl << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << std::endl; return EXIT_FAILURE; } //Instantiation //Load fileSR into vector std::vector dirSR; dirSR.push_back(argv[1]); dirSR.push_back(argv[2]); dirSR.push_back(argv[3]); dirSR.push_back(argv[4]); dirSR.push_back(argv[5]); const std::string fileSatG(argv[6]); unsigned int nbBand = atoi(argv[7]); float percentage = atof(argv[8]); SatRSRPointerType satRSR = SatRSRType::New(); /** Set the satellite number of bands */ satRSR->SetNbBands(nbBand); /** Load the satellite response file*/ satRSR->Load(fileSatG); //divide into training and testing files //90% of files are used for training and 10% for testing std::vector trainingFiles; //contains training files for all classes std::vector trainingClasses; //contains training classes for each files std::vector testingFiles; //contains testing files for this classes std::vector testingGTClasses; //contains testing ground truth classes for each files unsigned int ind; const std::string regularExpressionPattern = ".*\\.txt$"; for (unsigned int i = 0; i < dirSR.size(); ++i) //for each class (directory) { std::cout << "dirSR[" << i << "] : " << dirSR[i] << std::endl; std::string fileExp = dirSR[i]; // Find all .txt file in the directory fileExp.append("/*.txt"); itksys::Glob glob; if ( glob.FindFiles( fileExp ) == false ) { std::cout<<"No .txt file found in "< result = glob.GetFiles(); std::vector training; //contains training files for this class (directory) std::vector testing; //contains testing files for this class (directory) training = result; // initiating random number generation itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New(); //randomGen->Initialize(); for (unsigned int j = 0; j < static_cast (percentage * result.size()); ++j) { ind = randomGen->GetIntegerVariate() % (result.size()); testing.push_back(result[ind]); training.erase(training.begin() + (ind - j)); } //add to global training files and testing files for (unsigned int k = 0; k < testing.size(); ++k) { std::cout << "testing[" << k << "] : " << testing[k] << std::endl; testingFiles.push_back(testing[k]); testingGTClasses.push_back(i); } for (unsigned int l = 0; l < training.size(); ++l) { std::cout << "training[" << l << "] : " << training[l] << std::endl; trainingFiles.push_back(training[l]); trainingClasses.push_back(i); //class is the directory number } } //compute spectral response for all training files SampleListType::Pointer sampleList = SampleListType::New(); TrainingSampleListType::Pointer trainingList = TrainingSampleListType::New(); for (unsigned int i = 0; i < trainingFiles.size(); ++i) { ResponsePointerType spectralResponse = ResponseType::New(); std::cout << "training file : " << trainingFiles[i] << std::endl; spectralResponse->Load(trainingFiles[i], 100.0); //Compute Reduce Spectral Response ReduceResponseTypePointerType reduceResponse = ReduceResponseType::New(); /** Load the satellite response in the simulator */ reduceResponse->SetInputSatRSR(satRSR); /** Load the spectral response of the object in the simulator*/ reduceResponse->SetInputSpectralResponse(spectralResponse); reduceResponse->CalculateResponse(); //Get the response in an itk::VariableLengthVector and add it to the sample list for SVMModelEstimator SampleType sample; TrainingSampleType trainingSample; sample.SetSize(reduceResponse->GetReduceResponse()->Size()); std::cout << "reduce response : ["; for (unsigned int j = 0; j < reduceResponse->GetReduceResponse()->Size(); ++j) { sample[j] = reduceResponse->GetReduceResponse()->GetResponse()[j].second; std::cout << reduceResponse->GetReduceResponse()->GetResponse()[j].second << " "; } std::cout << "]" << std::endl; sampleList->SetMeasurementVectorSize(nbBand); sampleList->PushBack(sample); trainingSample = trainingClasses[i]; std::cout << "training class : " << trainingSample << std::endl; trainingList->PushBack(trainingSample); } //SVM model estimator SVMModelEstimatorType::Pointer estimator = SVMModelEstimatorType::New(); estimator->SetInputSampleList(sampleList); estimator->SetTrainingSampleList(trainingList); estimator->SetNu(0.5); estimator->SetKernelGamma(1); estimator->SetKernelCoef0(1); estimator->SetC(1); estimator->SetEpsilon(0.001); estimator->SetP(0.1); estimator->DoProbabilityEstimates(true); estimator->Update(); estimator->GetModel()->SaveModel("model.txt"); //compute spectral response for testing files sampleList->Clear(); //clear the sample list to re use it for testing samples TrainingSampleListType::Pointer groundTruthClassList = TrainingSampleListType::New(); for (unsigned int i = 0; i < testingFiles.size(); ++i) { ResponsePointerType spectralResponse = ResponseType::New(); std::cout << "testing file : " << testingFiles[i] << std::endl; spectralResponse->Load(testingFiles[i], 100.0); //Compute Reduce Spectral Response ReduceResponseTypePointerType reduceResponse = ReduceResponseType::New(); /** Load the satellite response in the simulator */ reduceResponse->SetInputSatRSR(satRSR); /** Load the spectral response of the object in the simulator*/ reduceResponse->SetInputSpectralResponse(spectralResponse); reduceResponse->CalculateResponse(); //Get the response in an itk::VariableLengthVector and add it to the sample list for SVMClassifier SampleType sample; TrainingSampleType gtClass; sample.SetSize(reduceResponse->GetReduceResponse()->Size()); for (unsigned int j = 0; j < reduceResponse->GetReduceResponse()->Size(); ++j) { sample[j] = reduceResponse->GetReduceResponse()->GetResponse()[j].second; } sampleList->PushBack(sample); gtClass = testingGTClasses[i]; groundTruthClassList->PushBack(gtClass); } //SVM Classifier SVMClassifierType::Pointer classifier = SVMClassifierType::New(); classifier->SetModel(estimator->GetModel()); classifier->SetInput(sampleList); classifier->SetNumberOfClasses(dirSR.size()); classifier->Update(); ClassifierOutputType::ConstIterator it = classifier->GetOutput()->Begin(); TrainingSampleListType::Pointer classifierListLabel = TrainingSampleListType::New(); while (it != classifier->GetOutput()->End()) { std::cout << "class : " << it.GetClassLabel() << std::endl; classifierListLabel->PushBack(it.GetClassLabel()); ++it; } for (unsigned int i = 0; i < testingFiles.size(); ++i) { std::cout << "ground truth class : " << testingGTClasses[i] << std::endl; } //Compute confusion matrix ConfusionMatrixCalculatorType::Pointer confMatCalc = ConfusionMatrixCalculatorType::New(); confMatCalc->SetReferenceLabels(groundTruthClassList); confMatCalc->SetProducedLabels(classifierListLabel); confMatCalc->Compute(); std::cout << std::endl; std::cout << "Confusion matrix: " << std::endl << confMatCalc->GetConfusionMatrix() << std::endl << std::endl; std::cout << "Kappa Index: " << std::endl << confMatCalc->GetKappaIndex() << std::endl << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbSailReflHTest.cxx000066400000000000000000000051721301006202600261570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbSailModel.h" #include "otbProspectModel.h" #include #include int otbSailReflHTest(int argc, char * argv[]) { if(argc != 16) { std::cout<<"Wrong number of arguments !"<(atof(argv[1])); double Car=static_cast(atof(argv[2])); double CBrown=static_cast(atof(argv[3])); double Cw=static_cast(atof(argv[4])); double Cm=static_cast(atof(argv[5])); double N=static_cast(atof(argv[6])); double LAI=static_cast(atof(argv[7])); double Angl=static_cast(atof(argv[8])); double PSoil=static_cast(atof(argv[9])); double Skyl=static_cast(atof(argv[10])); double HSpot=static_cast(atof(argv[11])); double TTS=static_cast(atof(argv[12])); double TTO=static_cast(atof(argv[13])); double PSI=static_cast(atof(argv[14])); char * OutputName = argv[15]; typedef otb::ProspectModel ProspectType; typedef otb::SailModel SailType; typedef otb::LeafParameters LeafParametersType; LeafParametersType::Pointer leafParams = LeafParametersType::New(); ProspectType::Pointer prospect = ProspectType::New(); SailType::Pointer sail = SailType::New(); leafParams->SetCab(Cab); leafParams->SetCar(Car); leafParams->SetCBrown(CBrown); leafParams->SetCw(Cw); leafParams->SetCm(Cm); leafParams->SetN(N); prospect->SetInput(leafParams); sail->SetLAI(LAI); sail->SetAngl(Angl); sail->SetPSoil(PSoil); sail->SetSkyl(Skyl); sail->SetHSpot(HSpot); sail->SetTTS(TTS); sail->SetTTO(TTO); sail->SetPSI(PSI); sail->SetReflectance(prospect->GetReflectance()); sail->SetTransmittance(prospect->GetTransmittance()); sail->Update(); std::ofstream outputFile(OutputName, std::ios::out); for(unsigned int i=0; iGetHemisphericalReflectance()->Size(); ++i) { outputFile<GetHemisphericalReflectance()->GetResponse()[i].second< #include int otbSailReflVTest(int argc, char * argv[]) { if(argc != 16) { std::cout<<"Wrong number of arguments !"<(atof(argv[1])); double Car=static_cast(atof(argv[2])); double CBrown=static_cast(atof(argv[3])); double Cw=static_cast(atof(argv[4])); double Cm=static_cast(atof(argv[5])); double N=static_cast(atof(argv[6])); double LAI=static_cast(atof(argv[7])); double Angl=static_cast(atof(argv[8])); double PSoil=static_cast(atof(argv[9])); double Skyl=static_cast(atof(argv[10])); double HSpot=static_cast(atof(argv[11])); double TTS=static_cast(atof(argv[12])); double TTO=static_cast(atof(argv[13])); double PSI=static_cast(atof(argv[14])); char * OutputName = argv[15]; typedef otb::ProspectModel ProspectType; typedef otb::SailModel SailType; typedef otb::LeafParameters LeafParametersType; LeafParametersType::Pointer leafParams = LeafParametersType::New(); ProspectType::Pointer prospect = ProspectType::New(); SailType::Pointer sail = SailType::New(); leafParams->SetCab(Cab); leafParams->SetCar(Car); leafParams->SetCBrown(CBrown); leafParams->SetCw(Cw); leafParams->SetCm(Cm); leafParams->SetN(N); prospect->SetInput(leafParams); sail->SetLAI(LAI); sail->SetAngl(Angl); sail->SetPSoil(PSoil); sail->SetSkyl(Skyl); sail->SetHSpot(HSpot); sail->SetTTS(TTS); sail->SetTTO(TTO); sail->SetPSI(PSI); sail->SetReflectance(prospect->GetReflectance()); sail->SetTransmittance(prospect->GetTransmittance()); sail->Update(); std::ofstream outputFile(OutputName, std::ios::out); for(unsigned int i=0; iGetViewingReflectance()->Size(); ++i) { outputFile<GetViewingReflectance()->GetResponse()[i].second< ResponseType; typedef ResponseType::Pointer ResponsePointerType; if ( argc!=5 ) { std::cout << argv[0] << std::endl << "\t" << ""<< "\t" << ""<< "\t" << ""<< "\t" << ""<< std::endl; return EXIT_FAILURE; } //Instantiation ResponsePointerType myResponse=ResponseType::New(); myResponse->SetNbBands(atoi(argv[2])); //Load file into vector const std::string file(argv[1]); myResponse->Load(file); //itk::Indent ind; unsigned int NumBand = atoi(argv[4]); double lambda = atof(argv[3]); std::cout << myResponse <GetRSR()[NumBand]->GetResponse()[i]->first<<","<< NumBand <<")= " << myResponse->GetRSR()[NumBand]->GetResponse()[i]->second << std::endl; // } return EXIT_SUCCESS; } int otbSatelliteRSRCheckValue(int argc, char * argv[]) { typedef otb::SatelliteRSR< double, double> ResponseType; typedef ResponseType::Pointer ResponsePointerType; if ( argc!=6 ) { std::cout << argv[0] << std::endl << "\t" << ""<< "\t" << ""<< "\t" << ""<< "\t" << ""<< "\t" << "" << std::endl; return EXIT_FAILURE; } //Instantiation ResponsePointerType myResponse=ResponseType::New(); myResponse->SetNbBands(atoi(argv[2])); //Load file into vector const std::string file(argv[1]); myResponse->Load(file); //itk::Indent ind; unsigned int NumBand = atoi(argv[4]); double lambda = atof(argv[3]); double expected = atof(argv[5]); double rsr_value = (*myResponse)(lambda, NumBand); std::cout << "RSR("<"<< "\t" << ""<< "\t" << ""<< "\t" << "\t" << "" << std::endl; return EXIT_FAILURE; } //Instantiation ResponsePointerType myResponse=ResponseType::New(); myResponse->SetNbBands(atoi(argv[2])); //Load file into vector const std::string file(argv[1]); myResponse->Load(file); //itk::Indent ind; double lambda = atof(argv[3]); double expected = atof(argv[4]); double solar_irradiance = (*(myResponse->GetSolarIrradiance()))(lambda); std::cout << "SolarIrradiance("< ResponseType; typedef ResponseType::Pointer ResponsePointerType; //Instantiation ResponsePointerType myResponse=ResponseType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbSimulationTestDriver.cxx000066400000000000000000000026161301006202600276460ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbReduceSpectralResponseSVMClassifier); REGISTER_TEST(otbProspectTransTest); REGISTER_TEST(otbReduceSpectralResponseClassifierRAndNIR); REGISTER_TEST(otbSpectralResponseNew); REGISTER_TEST(otbSatelliteRSR); REGISTER_TEST(otbSatelliteRSRCheckValue); REGISTER_TEST(otbSatelliteRSRSolarIrradianceCheckValue); REGISTER_TEST(otbSurfaceReflectanceToReflectanceFilterNew); REGISTER_TEST(otbSurfaceReflectanceToReflectanceFilterTest); REGISTER_TEST(otbImageSimulationMethodWithSpatialisationTest); REGISTER_TEST(otbImageSimulationMethodSVMClassif); REGISTER_TEST(otbReduceSpectralResponseNew); REGISTER_TEST(otbReduceSpectralResponse); REGISTER_TEST(otbReduceSpectralResponseSimpleValues); REGISTER_TEST(otbAtmosphericEffects); REGISTER_TEST(otbProspectReflTest); REGISTER_TEST(otbSpatialisationTestNew); REGISTER_TEST(otbLabelMapToSimulatedImageFilterTest); REGISTER_TEST(otbImageSimulationMethodKMeansClassif); REGISTER_TEST(otbSpectralResponse); REGISTER_TEST(otbAtmosphericCorrectionsRSRSVMClassifier); REGISTER_TEST(otbSpatialisationTest); REGISTER_TEST(otbImageSimulationMethodWithVectorDataTest); REGISTER_TEST(otbSailReflVTest); REGISTER_TEST(otbSatelliteRSRNew); REGISTER_TEST(otbSailReflHTest); REGISTER_TEST(otbFilterFunctionValuesSpectralResponseTest); REGISTER_TEST(otbFilterFunctionValuesTest); } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbSpatialisationTest.cxx000066400000000000000000000061151301006202600273300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkLabelMapToLabelImageFilter.h" #include "otbImageFileWriter.h" #include "otbSpatialisationFilter.h" #include "otbAttributesMapLabelObject.h" int otbSpatialisationTest(int itkNotUsed(argc), char * argv[]) { const char * outfilename = argv[1]; typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::Image ImageType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::ImageFileWriter ImageWriterType; typedef otb::SpatialisationFilter FilterType; typedef itk::LabelMapToLabelImageFilter LabelMapToLabelImageFilterType; /** Instantiation of pointer objects*/ ImageWriterType::Pointer writer = ImageWriterType::New(); FilterType::Pointer filter = FilterType::New(); LabelMapToLabelImageFilterType::Pointer labelMapToLabelImageFilter = LabelMapToLabelImageFilterType::New(); FilterType::SizeType objectSize; objectSize[0]=300; objectSize[1]=300; FilterType::SizeType nbOjects; nbOjects[0]=3; nbOjects[1]=3; std::vector pathVector(9); pathVector[0]="path1"; pathVector[1]="path2"; pathVector[2]="path3"; pathVector[3]="path4"; pathVector[4]="path5"; pathVector[5]="path6"; pathVector[6]="path7"; pathVector[7]="path8"; pathVector[8]="path9"; std::vector areaVector(9); areaVector[0]="moutains"; areaVector[1]="plants"; areaVector[2]="roads"; areaVector[3]="forest"; areaVector[4]="vegetables"; areaVector[5]="cars"; areaVector[6]="water"; areaVector[7]="rocks"; areaVector[8]="lunar"; std::vector labels(9); labels[0]=1; labels[1]=2; labels[2]=3; labels[3]=4; labels[4]=5; labels[5]=6; labels[6]=7; labels[7]=8; labels[8]=9; filter->SetObjectSize(objectSize); filter->SetNumberOfObjects(nbOjects); filter->SetPathVector(pathVector); filter->SetAreaVector(areaVector); filter->SetLabels(labels); filter->Update(); // // // std::cout<<"nb labels : "<GetOutput()->GetNumberOfLabelObjects()<GetOutput()->PrintLabelObjects(); labelMapToLabelImageFilter->SetInput(filter->GetOutput()); labelMapToLabelImageFilter->Update(); // writer->SetFileName(outfilename); writer->SetInput(labelMapToLabelImageFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbSpatialisationTestNew.cxx000066400000000000000000000022171301006202600300010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbSpatialisationFilter.h" #include "otbAttributesMapLabelObject.h" int otbSpatialisationTestNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::SpatialisationFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbSpectralResponse.cxx000066400000000000000000000026371301006202600270050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbSpectralResponse.h" int otbSpectralResponse(int argc, char * argv[]) { typedef otb::SpectralResponse< double, double> ResponseType; typedef ResponseType::Pointer ResponsePointerType; typedef otb::VectorImage ImageType; if ( argc!=3 ) { std::cout << argv[0] << std::endl << "\t" << "" << "\t" << ""<< std::endl; return EXIT_FAILURE; } //Instantiation ResponsePointerType myResponse=ResponseType::New(); //Load file into vector const std::string file(argv[1]); myResponse->Load(file, 100.0); //itk::Indent ind; double lambda = atof(argv[2]); ImageType::Pointer image = ImageType::New(); myResponse->GetImage(image); std::cout< ResponseType; typedef ResponseType::Pointer ResponsePointerType; //Instantiation ResponsePointerType myResponse=ResponseType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Radiometry/Simulation/test/otbSurfaceReflectanceToReflectanceFilterNew.cxx000066400000000000000000000120071301006202600335040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbSpectralResponse.h" #include "otbSurfaceReflectanceToReflectanceFilter.h" int otbSurfaceReflectanceToReflectanceFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef otb::SurfaceReflectanceToReflectanceFilter< ImageType, ImageType> SurfaceReflectanceToReflectanceFilterType; typedef SurfaceReflectanceToReflectanceFilterType::Pointer SurfaceReflectanceToReflectanceFilterPointerType; //Instantiation SurfaceReflectanceToReflectanceFilterPointerType object=SurfaceReflectanceToReflectanceFilterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } int otbSurfaceReflectanceToReflectanceFilterTest(int argc, char * argv[]) { if ( argc != 7 ) { std::cout << argv[0] << std::endl << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << "\t" << "" << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; // typedef itk::ImageRegionIterator< ImageType > IteratorType; //typedef ResponseType::PairType PairType; //typedef otb::ObjectList< PairType > PairListType; // PairListType::Pointer pairList = PairListType::New(); typedef otb::SurfaceReflectanceToReflectanceFilter< ImageType, ImageType> SurfaceReflectanceToReflectanceFilterType; typedef SurfaceReflectanceToReflectanceFilterType::Pointer SurfaceReflectanceToReflectanceFilterPointerType; typedef otb::SpectralResponse< PixelType, PixelType> ResponseType; typedef ResponseType::Pointer ResponsePointerType; // ResponsePointerType myResponse=ResponseType::New(); //Load file into vector const std::string file(argv[1]); myResponse->Load(file, 100.0); std::cout << "Input SpectResponse " << myResponse << std::endl; //rsr to image ImageType::IndexType start; start[0] = 0; start[1] = 0; ImageType::SizeType size; size[0] = 1; size[1] = 1; std::cout << "Image size: " << size << std::endl; ImageType::PointType origin; origin[0] = 0; origin[1] = 0; //origin[1] = -90; ImageType::SpacingType spacing; spacing[0] = 1; spacing[1] = 1; //spacing[1] = -resolution; ImageType::RegionType region; region.SetSize( size ); region.SetIndex( start ); ImageType::Pointer image = ImageType::New(); image->SetRegions( region ); image->SetNumberOfComponentsPerPixel( (myResponse)->Size() ); image->Allocate(); ImageType::PixelType pixel; pixel.SetSize((myResponse)->Size()); for ( unsigned int i = 0; i<(myResponse)->Size(); ++i ) { pixel[i] = myResponse->GetResponse()[i].second; } image->SetPixel(start, pixel); //Instantiation SurfaceReflectanceToReflectanceFilterPointerType myFilter=SurfaceReflectanceToReflectanceFilterType::New(); // myFilter->SetInput(image); // // typedef otb::AtmosphericRadiativeTerms::DataVectorType DataVectorType; // otb::AtmosphericRadiativeTerms::Pointer atmo = otb::AtmosphericRadiativeTerms::New(); // // DataVectorType intrinsic; // DataVectorType albedo; // DataVectorType gaseous; // DataVectorType downTrans; // DataVectorType upTrans; // // // intrinsic.push_back(static_cast(atof(argv[2]))); // albedo.push_back(static_cast(atof(argv[3]))); // gaseous.push_back(static_cast(atof(argv[4]))); // downTrans.push_back(static_cast(atof(argv[5]))); // upTrans.push_back(static_cast(atof(argv[6]))); // // // atmo->SetIntrinsicAtmosphericReflectances(intrinsic); // atmo->SetSphericalAlbedos(albedo); // atmo->SetTotalGaseousTransmissions(gaseous); // atmo->SetDownwardTransmittances(downTrans); // atmo->SetUpwardTransmittances(upTrans); // // myFilter->SetAtmosphericRadiativeTerms(atmo); // myFilter->Update(); // // i = 0; // IteratorType iterator2( myFilter->GetOutput(), myFilter->GetOutput()->GetRequestedRegion() ); // for ( iterator2.GoToBegin(); !iterator2.IsAtEnd(); ++iterator2 ) // { // myResponse->GetResponse()[i]->second = iterator2.Get()[]; // ++i; // } // // std::cout << "Output SpectResponse " << myResponse << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/000077500000000000000000000000001301006202600175005ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisparityMap/000077500000000000000000000000001301006202600221065ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisparityMap/CMakeLists.txt000066400000000000000000000000531301006202600246440ustar00rootroot00000000000000project(OTBDisparityMap) otb_module_impl() OTB-release-5.8/Modules/Registration/DisparityMap/include/000077500000000000000000000000001301006202600235315ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapEstimationMethod.h000066400000000000000000000165051301006202600322220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapEstimationMethod_h #define otbDisparityMapEstimationMethod_h #include "itkImageToImageMetric.h" #include "itkSingleValuedNonLinearOptimizer.h" #include "itkDataObjectDecorator.h" #include "itkPointSet.h" #include "otbPointSetSource.h" namespace otb { /** \class DisparityMapEstimationMethod * \brief This class performs an estimation of the local displacement * modelled by a given transform between the fixed and the moving image, * at each point of the given point set. * * It uses the ITK registration framework locally for each point and thus * provides the flexibility of this framework. The parameters of each transform * are stored in the output point set associated data. Optimizer, metric, * interpolator and transform fixed parameters have to be set by the user. * * This filters returns the pointset enriched with a set of value as PointData, in order of apparition : * - The final metric value, * - The column displacement value, * - The row displacement value, * - The final estimated parameters of the transform. * * This class is derived from the MAECENAS code provided by Jordi Inglada, * from CNES. * * \sa FineRegistrationImageFilter, FastCorrelationImageFilter * * \ingroup OTBDisparityMap */ template class ITK_EXPORT DisparityMapEstimationMethod : public PointSetSource { public: /** Standard class typedefs. */ typedef DisparityMapEstimationMethod Self; typedef PointSetSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DisparityMapEstimationMethod, ProcessObject); /** Typedef for the Fixed image. */ typedef TFixedImage FixedImageType; typedef typename FixedImageType::Pointer FixedImagePointerType; typedef typename FixedImageType::PixelType FixedPixelType; typedef typename FixedImageType::SizeType SizeType; /** Typedef for the Moving image. */ typedef TMovingImage MovingImageType; typedef typename MovingImageType::Pointer MovingImagePointerType; typedef typename MovingImageType::PixelType MovingPixelType; /** Typedef for the input and output point set */ typedef TPointSet PointSetType; typedef typename PointSetType::Pointer PointSetPointerType; /** Typedef for the generic metric. */ typedef itk::ImageToImageMetric MetricType; typedef typename MetricType::Pointer MetricPointerType; typedef typename MetricType::FixedImageRegionType FixedImageRegionType; /** Typedef for the generic transform . */ typedef typename MetricType::TransformType TransformType; typedef typename TransformType::Pointer TransformPointerType; /** Using Decorator pattern for enabling the Transform to be passed in the data pipeline */ typedef itk::DataObjectDecorator TransformOutputType; typedef typename TransformOutputType::Pointer TransformOutputPointerType; typedef typename TransformOutputType::ConstPointer TransformOutputConstPointerType; /** Typedef for the generic interpolator. */ typedef typename MetricType::InterpolatorType InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointerType; /** Typedef for the generic optimizer. */ typedef itk::SingleValuedNonLinearOptimizer OptimizerType; typedef typename OptimizerType::Pointer OptimizerPointerType; /** Type of the Transformation parameters This is the same type used to * represent the search space of the optimization algorithm */ typedef typename MetricType::TransformParametersType ParametersType; /** Smart Pointer type to a DataObject. */ typedef typename itk::DataObject::Pointer DataObjectPointer; /** Set/Get the Optimizer. */ itkSetObjectMacro(Optimizer, OptimizerType); itkGetObjectMacro(Optimizer, OptimizerType); /** Set/Get the Metric. */ itkSetObjectMacro(Metric, MetricType); itkGetObjectMacro(Metric, MetricType); /** Set/Get the Transform. */ itkSetObjectMacro(Transform, TransformType); itkGetObjectMacro(Transform, TransformType); /** Set/Get the Interpolator. */ itkSetObjectMacro(Interpolator, InterpolatorType); itkGetObjectMacro(Interpolator, InterpolatorType); /** Set/Get the window radius */ itkSetMacro(WinSize, SizeType); itkGetMacro(WinSize, SizeType); /** Set/Get the exploration area radius */ itkSetMacro(ExploSize, SizeType); itkGetMacro(ExploSize, SizeType); /** Set/Get the initial transformation parameters. */ itkSetMacro(InitialTransformParameters, ParametersType); itkGetConstReferenceMacro(InitialTransformParameters, ParametersType); /** * Set the source pointset. * \param pointset The source pointset. */ void SetPointSet(const TPointSet * pointset); /** * Get the source pointset. * \return The source pointset. */ const TPointSet * GetPointSet(void); /** * Set the fixed image. * \param image The fixed image. **/ void SetFixedImage(const TFixedImage * image); /** * Get the fixed image. * \return The fixed image. **/ const TFixedImage * GetFixedImage(void); /** * Set the moving image. * \param image The mobing image. **/ void SetMovingImage(const TMovingImage * image); /** * Get the fixed image. * \return The fixed image. **/ const TMovingImage * GetMovingImage(void); protected: /** * Constructor. */ DisparityMapEstimationMethod(); /** * Destructor. */ ~DisparityMapEstimationMethod() ITK_OVERRIDE; /** * Standard PrintSelf method. */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Main computation method. */ void GenerateData() ITK_OVERRIDE; private: DisparityMapEstimationMethod(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** * The metric used for local registration. */ MetricPointerType m_Metric; /** * The optimizer used for local registration. */ OptimizerPointerType m_Optimizer; /** * The transform used for local registration. */ TransformPointerType m_Transform; /** * The interpolator used for local registration. */ InterpolatorPointerType m_Interpolator; /** * The initial transform parameters. */ ParametersType m_InitialTransformParameters; /** * The size of the exploration area */ SizeType m_ExploSize; /** * The size of the window */ SizeType m_WinSize; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDisparityMapEstimationMethod.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapEstimationMethod.txx000066400000000000000000000242741301006202600326200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapEstimationMethod_txx #define otbDisparityMapEstimationMethod_txx #include "otbDisparityMapEstimationMethod.h" #include "itkImageRegistrationMethod.h" #include "otbExtractROI.h" #include "otbMacro.h" // #include "otbImageFileWriter.h" // namespace otb { /* * Constructor. */ template DisparityMapEstimationMethod ::DisparityMapEstimationMethod() { this->SetNumberOfRequiredInputs(3); //this->SetNumberOfRequiredOutputs(1); // this->SetReleaseDataFlag(false); this->SetReleaseDataBeforeUpdateFlag(false); m_Transform = ITK_NULLPTR; // has to be provided by the user. m_Interpolator = ITK_NULLPTR; // has to be provided by the user. m_Metric = ITK_NULLPTR; // has to be provided by the user. m_Optimizer = ITK_NULLPTR; // has to be provided by the user. m_WinSize.Fill(15); m_ExploSize.Fill(10); m_InitialTransformParameters = ParametersType(1); m_InitialTransformParameters.Fill(0.0f); } /* * Destructor. */ template DisparityMapEstimationMethod ::~DisparityMapEstimationMethod() {} /** * Set the source pointset. * \param pointset The source pointset. */ template void DisparityMapEstimationMethod ::SetPointSet(const TPointSet * pointset) { this->itk::ProcessObject::SetNthInput(0, const_cast(pointset)); } /** * Get the source pointset. * \return The source pointset. */ template const TPointSet * DisparityMapEstimationMethod ::GetPointSet(void) { return static_cast(this->itk::ProcessObject::GetInput(0)); } /** * Set the fixed image. * \param image The fixed image. **/ template void DisparityMapEstimationMethod ::SetFixedImage(const TFixedImage * image) { this->itk::ProcessObject::SetNthInput(1, const_cast(image)); } /** * Get the fixed image. * \return The fixed image. **/ template const TFixedImage * DisparityMapEstimationMethod ::GetFixedImage(void) { return static_cast(this->itk::ProcessObject::GetInput(1)); } /** * Set the moving image. * \param image The mobing image. **/ template void DisparityMapEstimationMethod ::SetMovingImage(const TMovingImage * image) { this->itk::ProcessObject::SetNthInput(2, const_cast(image)); } /** * Get the fixed image. * \return The fixed image. **/ template const TMovingImage * DisparityMapEstimationMethod ::GetMovingImage(void) { return static_cast(this->itk::ProcessObject::GetInput(2)); } /** * Main computation method. */ template void DisparityMapEstimationMethod ::GenerateData(void) { // inputs pointers const FixedImageType * fixed = this->GetFixedImage(); const MovingImageType * moving = this->GetMovingImage(); const PointSetType * pointSet = this->GetPointSet(); PointSetType* output = this->GetOutput(); // Typedefs typedef typename PointSetType::PointsContainer PointsContainer; typedef typename PointsContainer::ConstIterator PointsIterator; typedef itk::ImageRegistrationMethod RegistrationType; typedef otb::ExtractROI FixedExtractType; typedef otb::ExtractROI MovingExtractType; // points retrieving typename PointsContainer::ConstPointer points = pointSet->GetPoints(); // Iterator set up PointsIterator pointIterator = points->Begin(); PointsIterator end = points->End(); unsigned int dataId = 0; otbMsgDevMacro(<< "Starting registration"); /// Iterate through the point set while (pointIterator != end) { typename PointSetType::PointType p = pointIterator.Value(); // access the point // Extract the needed sub-images typename FixedExtractType::Pointer fixedExtractor = FixedExtractType::New(); typename MovingExtractType::Pointer movingExtractor = MovingExtractType::New(); fixedExtractor->SetInput(fixed); movingExtractor->SetInput(moving); // Fixed extractor setup fixedExtractor->SetStartX(static_cast(p[0] - m_ExploSize[0])); fixedExtractor->SetStartY(static_cast(p[1] - m_ExploSize[1])); fixedExtractor->SetSizeX(static_cast(2 * m_ExploSize[0] + 1)); fixedExtractor->SetSizeY(static_cast(2 * m_ExploSize[1] + 1)); otbMsgDevMacro(<< "Point id: " << dataId); otbMsgDevMacro( << "Fixed region: origin(" << p[0] - m_ExploSize[0] << ", " << p[1] - m_ExploSize[1] << ") size(" << 2 * m_ExploSize[0] + 1 << ", " << 2 * m_ExploSize[1] + 1 << ")"); // Moving extractor setup movingExtractor->SetStartX(static_cast(p[0] - m_WinSize[0])); movingExtractor->SetStartY(static_cast(p[1] - m_WinSize[1])); movingExtractor->SetSizeX(static_cast(2 * m_WinSize[0] + 1)); movingExtractor->SetSizeY(static_cast(2 * m_WinSize[1] + 1)); otbMsgDevMacro( << "Moving region: origin(" << p[0] - m_WinSize[0] << ", " << p[1] - m_WinSize[1] << ") size(" << 2 * m_WinSize[0] + 1 << ", " << 2 * m_WinSize[1] + 1 << ")"); // update the extractors fixedExtractor->Update(); movingExtractor->Update(); // std::cout<<"Fixed extract origin: "<GetOutput()->GetOrigin()<GetOutput()->GetSpacing()<GetOutput()->GetOrigin()<GetOutput()->GetSpacing()< FixedWriterType; // typedef otb::ImageFileWriter MovingWriterType; // typename FixedWriterType::Pointer fwriter = FixedWriterType::New(); // typename MovingWriterType::Pointer mwriter = MovingWriterType::New(); // std::ostringstream oss; // oss.str(""); // oss<<"Fixed"<SetInput(fixedExtractor->GetOutput()); // fwriter->SetFileName(oss.str()); // fwriter->Update(); // oss.str(""); // oss<<"Moving"<SetInput(movingExtractor->GetOutput()); // mwriter->SetFileName(oss.str()); // mwriter->Update(); // Registration filter definition typename RegistrationType::Pointer registration = RegistrationType::New(); // Registration filter setup registration->SetOptimizer(m_Optimizer); registration->SetTransform(m_Transform); registration->SetInterpolator(m_Interpolator); registration->SetMetric(m_Metric); registration->SetFixedImage(fixedExtractor->GetOutput()); registration->SetMovingImage(movingExtractor->GetOutput()); // initial transform parameters setup registration->SetInitialTransformParameters(m_InitialTransformParameters); m_Interpolator->SetInputImage(movingExtractor->GetOutput()); // Perform the registration registration->Update(); // Retrieve the final parameters ParametersType finalParameters = registration->GetLastTransformParameters(); double value = m_Optimizer->GetValue(registration->GetLastTransformParameters()); // Computing moving image point typename FixedImageType::PointType inputPoint, outputPoint; typename FixedImageType::IndexType inputIndex; // ensure that we have the right coord rep type inputIndex[0] = static_cast(p[0]); inputIndex[1] = static_cast(p[1]); fixed->TransformIndexToPhysicalPoint(inputIndex, inputPoint); m_Transform->SetParameters(finalParameters); outputPoint = m_Transform->TransformPoint(inputPoint); otbMsgDevMacro(<< "Metric value: " << value); otbMsgDevMacro(<< "Transform parameters: " << finalParameters); otbMsgDevMacro( << "Displacement: (" << outputPoint[0] - inputPoint[0] << ", " << outputPoint[1] - inputPoint[1] << ")"); otbMsgDevMacro(<< "Final parameters: " << finalParameters); ParametersType data(finalParameters.GetSize() + 3); data[0] = value; data[1] = outputPoint[0] - inputPoint[0]; data[2] = outputPoint[1] - inputPoint[1]; for (unsigned int i = 0; i < finalParameters.GetSize(); ++i) { data[i + 3] = finalParameters[i]; } // Set the parameters value in the point set data container. output->SetPoint(dataId, p); output->SetPointData(dataId, data); // otbMsgDevMacro(<<"Point "< void DisparityMapEstimationMethod ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Window size: " << m_WinSize << std::endl; os << indent << "Exploration size: " << m_ExploSize << std::endl; } } #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapMedianFilter.h000066400000000000000000000154241301006202600313070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapMedianFilter_h #define otbDisparityMapMedianFilter_h #ifdef ITK_USE_CONSOLIDATED_MORPHOLOGY #include "itkOptMedianImageFilter.h" #else #include "itkImageToImageFilter.h" #include "otbImage.h" namespace otb { /** \class DisparityMapMedianFilter * \brief Applies a median filter to a monoband disparity map with an associated mask * * Computes an image where a given pixel is the median value of the * the pixels in a neighborhood about the corresponding input pixel. Pixels taken into * account for the median computation have a value different from zero in the associated mask. * * A detection of incoherences between the input disparity map and the median is performed (a pixel corresponds * to an incoherence if the absolute value of the difference between the pixel value in the disparity map and in the median * image is higher than the incoherence threshold (whose default value is 1). The input disparity map and mask are updated: their value on incoherences becomes 0. * * The median image is then computed again on incoherences using the updated disparity map and mask. * * Inputs (with corresponding method): * - disparity map (SetInput()) * - associated mask (SetMaskInput()) * - radius (SetRadius()) * - incoherence threshold (SetIncoherenceThreshold()) * Outputs (with corresponding method): * - median image (GetOutput()) * - mask associated to the median image (GetOutputMask()) * - updated disparity map with incoherence removal (GetOutputDisparityMap()) * - mask associated to the updated disparity map (GetOutputDisparityMask()) * * A median filter is one of the family of nonlinear filters. It is * used to smooth an image without being biased by outliers or shot noise. * * This filter requires that the input pixel type provides an operator<() * (LessThan Comparable). * * \sa Image * \sa Neighborhood * \sa NeighborhoodOperator * \sa NeighborhoodIterator * * \ingroup IntensityImageFilters * * \ingroup OTBDisparityMap */ template class ITK_EXPORT DisparityMapMedianFilter : public itk::ImageToImageFilter< TInputImage, TOutputImage> { public: /** Extract dimension from input and output image. */ itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); itkStaticConstMacro(OutputImageDimension, unsigned int, TOutputImage::ImageDimension); /** Convenient typedefs for simplifying declarations. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TMask MaskImageType; /** Standard class typedefs. */ typedef DisparityMapMedianFilter Self; typedef itk::ImageToImageFilter< InputImageType, OutputImageType> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DisparityMapMedianFilter, ImageToImageFilter); /** Image typedef support. */ typedef typename InputImageType::PixelType InputPixelType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename MaskImageType::PixelType MaskImagePixelType; typedef typename MaskImageType::Pointer MaskImagePointerType; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename InputImageType::SizeType SizeType; typedef typename OutputImageType::IndexValueType IndexValueType; /** Set input mask **/ void SetMaskInput( const TMask * inputmask); // mask corresponding to the subpixel disparity map /** Get the input mask */ const TMask * GetMaskInput(); /** Get the output mask **/ TMask * GetOutputMask(); // mask corresponding to the median disparity map /** Get the updated disparity map **/ TOutputImage * GetOutputDisparityMap(); // input disparity map updated (incoherences between median and input disparity map are removed) /** Get the updated disparity mask **/ TMask * GetOutputDisparityMask(); /** Set/Get the radius of the neighborhood used to compute the median. */ itkSetMacro(Radius, SizeType); itkGetMacro(Radius, SizeType); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } /** Set/Get the incoherence threshold */ itkSetMacro(IncoherenceThreshold, double); itkGetMacro(IncoherenceThreshold, double); #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(SameDimensionCheck, (itk::Concept::SameDimension)); itkConceptMacro(InputConvertibleToOutputCheck, (itk::Concept::Convertible)); itkConceptMacro(InputLessThanComparableCheck, (itk::Concept::LessThanComparable)); /** End concept checking */ #endif protected: DisparityMapMedianFilter(); ~DisparityMapMedianFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** MedianImageFilter needs a larger input requested region than * the output requested region. As such, MedianImageFilter needs * to provide an implementation for GenerateInputRequestedRegion() * in order to inform the pipeline execution model. * * \sa ImageToImageFilter::GenerateInputRequestedRegion() */ void GenerateInputRequestedRegion() throw(itk::InvalidRequestedRegionError) ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** apply median filter */ void GenerateData() ITK_OVERRIDE; private: DisparityMapMedianFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Radius of median filter */ SizeType m_Radius; /** Threshold of incoherence between original and filtered disparity */ double m_IncoherenceThreshold; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDisparityMapMedianFilter.txx" #endif #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapMedianFilter.txx000066400000000000000000000400531301006202600316770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapMedianFilter_txx #define otbDisparityMapMedianFilter_txx #ifdef ITK_USE_CONSOLIDATED_MORPHOLOGY #else #include "otbDisparityMapMedianFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkNeighborhoodAlgorithm.h" #include "itkProgressReporter.h" namespace otb { template DisparityMapMedianFilter ::DisparityMapMedianFilter() { this->SetNumberOfRequiredInputs( 1 ); this->SetNumberOfRequiredOutputs(4); this->SetNthOutput(1,TMask::New()); this->SetNthOutput(2,TOutputImage::New()); this->SetNthOutput(3,TMask::New()); m_Radius.Fill(3); m_IncoherenceThreshold = 1.0; } template void DisparityMapMedianFilter ::SetMaskInput( const TMask * inputmask) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( inputmask )); } template const TMask * DisparityMapMedianFilter ::GetMaskInput() { if (this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template TMask * DisparityMapMedianFilter ::GetOutputMask() { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template TOutputImage * DisparityMapMedianFilter ::GetOutputDisparityMap() { if (this->GetNumberOfOutputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template TMask * DisparityMapMedianFilter ::GetOutputDisparityMask() { if (this->GetNumberOfOutputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(3)); } template void DisparityMapMedianFilter ::GenerateOutputInformation() { // Call superclass implementation Superclass::GenerateOutputInformation(); // Retrieve output pointers typename Superclass::InputImagePointer inputPtr = const_cast< TInputImage * >( this->GetInput() ); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); TMask * outputmaskPtr = this->GetOutputMask(); typename Superclass::OutputImagePointer outputdisparitymapPtr = this->GetOutputDisparityMap(); TMask * outputdisparitymaskPtr = this->GetOutputDisparityMask(); // Update size and spacing according to grid step InputImageRegionType largestRegion = outputPtr->GetLargestPossibleRegion(); SizeType outputSize = largestRegion.GetSize(); // Set largest region size largestRegion.SetSize(outputSize); outputPtr->SetLargestPossibleRegion(largestRegion); outputmaskPtr->SetLargestPossibleRegion(largestRegion); outputdisparitymapPtr->SetLargestPossibleRegion(largestRegion); outputdisparitymaskPtr->SetLargestPossibleRegion(largestRegion); } template void DisparityMapMedianFilter ::GenerateInputRequestedRegion() throw (itk::InvalidRequestedRegionError) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output typename Superclass::InputImagePointer inputPtr = const_cast< TInputImage * >( this->GetInput() ); TMask * inputmaskPtr = const_cast< TMask * >(this->GetMaskInput()); typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); TMask * outputmaskPtr = this->GetOutputMask(); typename Superclass::OutputImagePointer outputdisparitymapPtr = this->GetOutputDisparityMap(); TMask * outputdisparitymaskPtr = this->GetOutputDisparityMask(); if ( !inputPtr || !outputPtr || !outputmaskPtr || !outputdisparitymapPtr || !outputdisparitymaskPtr) { return; } if (inputmaskPtr) { // check that the mask has the same size as the input image if (inputmaskPtr->GetLargestPossibleRegion() != inputPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Input image and mask image don't have the same size ! Input image :"<< inputPtr->GetLargestPossibleRegion()<< "; Mask image :"<GetLargestPossibleRegion()); } } // get a copy of the input requested region (should equal the output // requested region) typename TInputImage::RegionType inputRequestedRegion; inputRequestedRegion = inputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius inputRequestedRegion.PadByRadius( m_Radius); // crop the input requested region at the input's largest possible region if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) ) { inputPtr->SetRequestedRegion( inputRequestedRegion ); if (inputmaskPtr) { inputmaskPtr->SetRequestedRegion( inputRequestedRegion ); } return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inputPtr->SetRequestedRegion( inputRequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region."); e.SetDataObject(inputPtr); throw e; } } template< class TInputImage, class TOutputImage, class TMask> void DisparityMapMedianFilter< TInputImage, TOutputImage, TMask> ::GenerateData() { // Allocate outputs this->AllocateOutputs(); // Get the image pointers typename OutputImageType::Pointer output = this->GetOutput(); typename InputImageType::ConstPointer input = this->GetInput(); typename MaskImageType::ConstPointer inputmaskPtr = this->GetMaskInput(); TMask * outputmaskPtr = this->GetOutputMask(); TOutputImage * outputdisparitymapPtr = this->GetOutputDisparityMap(); TMask * outputdisparitymaskPtr = this->GetOutputDisparityMask(); SizeType imgSize = output->GetLargestPossibleRegion().GetSize(); /** Input iterators */ itk::ConstNeighborhoodIterator InputIt(m_Radius, input,input->GetRequestedRegion()); itk::ConstNeighborhoodIterator MaskInputIt; if (inputmaskPtr) { MaskInputIt.Initialize(m_Radius, inputmaskPtr,inputmaskPtr->GetRequestedRegion()); } /** Output iterators */ itk::ImageRegionIteratorWithIndex outputIt(output,output->GetRequestedRegion()); itk::ImageRegionIterator outputMaskIt(outputmaskPtr,output->GetRequestedRegion()); itk::ImageRegionIterator outputDisparityMapIt(outputdisparitymapPtr,output->GetRequestedRegion()); itk::ImageRegionIterator outputDisparityMaskIt(outputdisparitymaskPtr,output->GetRequestedRegion()); outputIt.GoToBegin(); outputMaskIt.GoToBegin(); outputDisparityMapIt.GoToBegin(); outputDisparityMaskIt.GoToBegin(); std::vector pixels; while ( !outputIt.IsAtEnd() && !outputMaskIt.IsAtEnd() && !outputDisparityMapIt.IsAtEnd() && !outputDisparityMapIt.IsAtEnd()) { if (outputIt.GetIndex()[0] >= static_cast(m_Radius[0]) && outputIt.GetIndex()[0] < static_cast(imgSize[0]) - static_cast(m_Radius[0]) && outputIt.GetIndex()[1] >= static_cast(m_Radius[1]) && outputIt.GetIndex()[1] < static_cast(imgSize[1]) - static_cast(m_Radius[1])) { // determine pixels in the neighborhood window whose subpixel mask is not equal to 0 int p = 0; pixels.clear(); if (inputmaskPtr) { MaskInputIt.SetLocation(outputIt.GetIndex()); } InputIt.SetLocation(outputIt.GetIndex()); for (unsigned int i=0; i0) { //outputMaskIt.Set(itk::NumericTraits::max()); outputMaskIt.Set(1); // get the median value if ((p & 0x1) == 0) { const unsigned int medianPosition_low = p/2 - 1; const unsigned int medianPosition_high = p/2; const typename std::vector::iterator medianIterator_low = pixels.begin() + medianPosition_low; const typename std::vector::iterator medianIterator_high = pixels.begin() + medianPosition_high; std::nth_element(pixels.begin(), medianIterator_low, pixels.end()); std::nth_element(pixels.begin(), medianIterator_high, pixels.end()); outputIt.Set( static_cast ((*medianIterator_low + *medianIterator_high)/2) ); } else { const unsigned int medianPosition = p/2; const typename std::vector::iterator medianIterator = pixels.begin() + medianPosition; std::nth_element(pixels.begin(), medianIterator, pixels.end()); outputIt.Set( static_cast (*medianIterator) ); } } else { outputIt.Set(0.0); outputMaskIt.Set(0); } } else { outputIt.Set(0.0); outputMaskIt.Set(0); } outputDisparityMapIt.Set( static_cast (InputIt.GetCenterPixel())); // copy the input disparity map if (inputmaskPtr) { outputDisparityMaskIt.Set(MaskInputIt.GetCenterPixel()); // copy the input disparity mask } else { outputDisparityMaskIt.Set(1); // if no mask is given, fill with 1 by default } ++outputIt; ++outputMaskIt; ++outputDisparityMapIt; ++outputDisparityMaskIt; } //Remove incoherences between disparity and median// // creation of the auxiliary image that store positions of incoherences between the median and the input disparity map MaskImagePointerType image_aux = MaskImageType::New(); image_aux->SetRegions(input->GetRequestedRegion()); image_aux->Allocate(); image_aux->FillBuffer(0); itk::NeighborhoodIterator image_aux_It(m_Radius, image_aux,input->GetRequestedRegion()); outputIt.GoToBegin(); outputMaskIt.GoToBegin(); itk::ImageRegionConstIterator MedianIt(output,output->GetRequestedRegion()); while (!outputIt.IsAtEnd() && !outputMaskIt.IsAtEnd()) { if (outputIt.GetIndex()[0] >= static_cast(m_Radius[0]) && outputIt.GetIndex()[0] < static_cast(imgSize[0]) - static_cast(m_Radius[0]) && outputIt.GetIndex()[1] >= static_cast(m_Radius[1]) && outputIt.GetIndex()[1] < static_cast(imgSize[1]) - static_cast(m_Radius[1])) { InputIt.SetLocation(outputIt.GetIndex()); MedianIt.SetIndex(outputIt.GetIndex()); outputDisparityMapIt.SetIndex(outputIt.GetIndex()); outputDisparityMaskIt.SetIndex(outputIt.GetIndex()); image_aux_It.SetLocation(outputIt.GetIndex()); if (inputmaskPtr) { MaskInputIt.SetLocation(outputIt.GetIndex()); } if ((!inputmaskPtr || (inputmaskPtr && MaskInputIt.GetCenterPixel() != 0)) && std::fabs(InputIt.GetCenterPixel() - MedianIt.Get())>m_IncoherenceThreshold) { outputDisparityMapIt.Set(0.0); //Remove pixel from disparity map// outputDisparityMaskIt.Set(0); for (unsigned int i=0; i updatedDisparityMapIt(m_Radius, outputdisparitymapPtr,output->GetRequestedRegion()); itk::ConstNeighborhoodIterator updatedDisparityMaskIt(m_Radius, outputdisparitymaskPtr,output->GetRequestedRegion()); outputIt.GoToBegin(); outputMaskIt.GoToBegin(); updatedDisparityMapIt.GoToBegin(); updatedDisparityMaskIt.GoToBegin(); while ( !updatedDisparityMapIt.IsAtEnd() && !updatedDisparityMaskIt.IsAtEnd() && !outputIt.IsAtEnd() && !outputMaskIt.IsAtEnd()) { if (outputIt.GetIndex()[0] >= static_cast(m_Radius[0]) && outputIt.GetIndex()[0] < static_cast(imgSize[0]) - static_cast(m_Radius[0]) && outputIt.GetIndex()[1] >= static_cast(m_Radius[1]) && outputIt.GetIndex()[1] < static_cast(imgSize[1]) - static_cast(m_Radius[1])) { image_aux_It.SetLocation(outputIt.GetIndex()); if (image_aux_It.GetCenterPixel() != 0) { // determine pixels in the neighborhood window whose subpixel mask is not equal to 0 int p=0; pixels.clear(); for (unsigned int i=0; i0) { //outputMaskIt.Set(itk::NumericTraits::max()); outputMaskIt.Set(1); // get the median value if ((p & 0x1) == 0) { const unsigned int medianPosition_low = p/2 - 1; const unsigned int medianPosition_high = p/2; const typename std::vector::iterator medianIterator_low = pixels.begin() + medianPosition_low; const typename std::vector::iterator medianIterator_high = pixels.begin() + medianPosition_high; std::nth_element(pixels.begin(), medianIterator_low, pixels.end()); std::nth_element(pixels.begin(), medianIterator_high, pixels.end()); outputIt.Set( static_cast ((*medianIterator_low + *medianIterator_high)/2) ); } else { const unsigned int medianPosition = p/2; const typename std::vector::iterator medianIterator = pixels.begin() + medianPosition; std::nth_element(pixels.begin(), medianIterator, pixels.end()); outputIt.Set( static_cast (*medianIterator) ); } } else { outputIt.Set(0.0); outputMaskIt.Set(0); } } } ++outputIt; ++outputMaskIt; ++updatedDisparityMapIt; ++updatedDisparityMaskIt; } } /** * Standard "PrintSelf" method */ template void DisparityMapMedianFilter ::PrintSelf( std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf( os, indent ); os << indent << "Radius: " << m_Radius << std::endl; } } // end namespace otb #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapTo3DFilter.h000066400000000000000000000144051301006202600306610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapTo3DFilter_h #define otbDisparityMapTo3DFilter_h #include "itkImageToImageFilter.h" #include "otbGenericRSTransform.h" #include "otbLineOfSightOptimizer.h" #include "otbVectorImage.h" #include "otbImage.h" namespace otb { /** \class DisparityMapTo3DFilter * \brief Project an input disparity map into a 3D points * * This filter uses an input disparity map (horizontal and vertical) to project 3D points. * The output image contains the 3D points coordinates for each location of input disparity. * The 3D coordinates (sorted by band) are : longitude , latitude (in degree, wrt WGS84) and altitude (in meters) * * \sa FineRegistrationImageFilter * \sa StereorectificationDisplacementFieldSource * \sa SubPixelDisparityImageFilter * \sa PixelWiseBlockMatchingImageFilter * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBDisparityMap */ template , class TEpipolarGridImage = otb::VectorImage , class TMaskImage = otb::Image > class ITK_EXPORT DisparityMapTo3DFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef DisparityMapTo3DFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DisparityMapTo3DFilter, ImageToImageFilter); /** Useful typedefs */ typedef TDisparityImage DisparityMapType; typedef TOutputImage OutputImageType; typedef TEpipolarGridImage GridImageType; typedef TMaskImage MaskImageType; typedef typename OutputImageType::RegionType RegionType; typedef typename OutputImageType::PixelType DEMPixelType; // 3D RS transform // TODO: Allow tuning precision (i.e. double or float) typedef double PrecisionType; typedef otb::GenericRSTransform RSTransformType; // 3D points typedef typename RSTransformType::InputPointType TDPointType; typedef otb::LineOfSightOptimizer OptimizerType; typedef typename OptimizerType::PointSetType PointSetType; typedef typename PointSetType::PointsContainer PointsContainer; typedef typename PointSetType::PointDataContainer LabelContainer; typedef otb::ImageKeywordlist ImageKeywordListType; /** Set horizontal disparity map input */ void SetHorizontalDisparityMapInput( const TDisparityImage * hmap); /** Set vertical disparity map input */ void SetVerticalDisparityMapInput( const TDisparityImage * vmap); /** Set left epipolar grid (deformation grid from sensor image to epipolar space, regular in epipolar space)*/ void SetLeftEpipolarGridInput( const TEpipolarGridImage * grid); /** Set right epipolar grid (deformation grid from sensor image to epipolar space, regular in epipolar space)*/ void SetRightEpipolarGridInput( const TEpipolarGridImage * grid); /** Set mask associated to disparity maps (optional, pixels with a null mask value are ignored) */ void SetDisparityMaskInput( const TMaskImage * mask); /** Get the inputs */ const TDisparityImage * GetHorizontalDisparityMapInput() const; const TDisparityImage * GetVerticalDisparityMapInput() const; const TEpipolarGridImage * GetLeftEpipolarGridInput() const; const TEpipolarGridImage * GetRightEpipolarGridInput() const; const TMaskImage * GetDisparityMaskInput() const; /** Set left keywordlist */ void SetLeftKeywordList(const ImageKeywordListType kwl) { this->m_LeftKeywordList = kwl; this->Modified(); } /** Get left keywordlist */ const ImageKeywordListType & GetLeftKeywordList() const { return this->m_LeftKeywordList; } /** Set right keywordlist */ void SetRightKeywordList(const ImageKeywordListType kwl) { this->m_RightKeywordList = kwl; this->Modified(); } /** Get right keywordlist */ const ImageKeywordListType & GetRightKeywordList() const { return this->m_RightKeywordList; } protected: /** Constructor */ DisparityMapTo3DFilter(); /** Destructor */ ~DisparityMapTo3DFilter() ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Override VerifyInputInformation() since this filter's inputs do * not need to occupy the same physical space. * * \sa ProcessObject::VerifyInputInformation */ void VerifyInputInformation() ITK_OVERRIDE {} private: DisparityMapTo3DFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Keywordlist of left sensor image */ ImageKeywordListType m_LeftKeywordList; /** Keywordlist of right sensor image */ ImageKeywordListType m_RightKeywordList; /** Left sensor image transform */ RSTransformType::Pointer m_LeftToGroundTransform; /** Right sensor image transform */ RSTransformType::Pointer m_RightToGroundTransform; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDisparityMapTo3DFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapTo3DFilter.txx000066400000000000000000000427751301006202600312700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapTo3DFilter_txx #define otbDisparityMapTo3DFilter_txx #include "otbDisparityMapTo3DFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" namespace otb { template DisparityMapTo3DFilter ::DisparityMapTo3DFilter() { // Set the number of inputs this->SetNumberOfRequiredInputs(5); this->SetNumberOfRequiredInputs(1); // Set the outputs this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0,TOutputImage::New()); } template DisparityMapTo3DFilter ::~DisparityMapTo3DFilter() {} template void DisparityMapTo3DFilter ::SetHorizontalDisparityMapInput( const TDisparityImage * hmap) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( hmap )); } template void DisparityMapTo3DFilter ::SetVerticalDisparityMapInput( const TDisparityImage * vmap) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( vmap )); } template void DisparityMapTo3DFilter ::SetLeftEpipolarGridInput( const TEpipolarGridImage * grid) { // Process object is not const-correct so the const casting is required. this->SetNthInput(2, const_cast( grid )); } template void DisparityMapTo3DFilter ::SetRightEpipolarGridInput( const TEpipolarGridImage * grid) { // Process object is not const-correct so the const casting is required. this->SetNthInput(3, const_cast( grid )); } template void DisparityMapTo3DFilter ::SetDisparityMaskInput( const TMaskImage * mask) { // Process object is not const-correct so the const casting is required. this->SetNthInput(4, const_cast( mask )); } template const TDisparityImage * DisparityMapTo3DFilter ::GetHorizontalDisparityMapInput() const { if(this->GetNumberOfInputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TDisparityImage * DisparityMapTo3DFilter ::GetVerticalDisparityMapInput() const { if(this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template const TEpipolarGridImage * DisparityMapTo3DFilter ::GetLeftEpipolarGridInput() const { if(this->GetNumberOfInputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template const TEpipolarGridImage * DisparityMapTo3DFilter ::GetRightEpipolarGridInput() const { if(this->GetNumberOfInputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3)); } template const TMaskImage * DisparityMapTo3DFilter ::GetDisparityMaskInput() const { if(this->GetNumberOfInputs()<5) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(4)); } template void DisparityMapTo3DFilter ::GenerateOutputInformation() { const TDisparityImage * horizDisp = this->GetHorizontalDisparityMapInput(); TOutputImage * outputPtr = this->GetOutput(); outputPtr->SetLargestPossibleRegion(horizDisp->GetLargestPossibleRegion()); outputPtr->SetNumberOfComponentsPerPixel(3); // copy also origin and spacing outputPtr->SetOrigin(horizDisp->GetOrigin()); outputPtr->SetSpacing(horizDisp->GetSpacing()); } template void DisparityMapTo3DFilter ::GenerateInputRequestedRegion() { // For the epi grid : generate full buffer here ! TEpipolarGridImage * leftGrid = const_cast(this->GetLeftEpipolarGridInput()); TEpipolarGridImage * rightGrid = const_cast(this->GetRightEpipolarGridInput()); leftGrid->SetRequestedRegionToLargestPossibleRegion(); rightGrid->SetRequestedRegionToLargestPossibleRegion(); TOutputImage * outputDEM = this->GetOutput(); TDisparityImage * horizDisp = const_cast(this->GetHorizontalDisparityMapInput()); TDisparityImage * vertiDisp = const_cast(this->GetVerticalDisparityMapInput()); TMaskImage * maskDisp = const_cast(this->GetDisparityMaskInput()); // We impose that both disparity map inputs have the same size if(vertiDisp && horizDisp->GetLargestPossibleRegion() != vertiDisp->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Horizontal and vertical disparity maps do not have the same size ! Horizontal largest region: " <GetLargestPossibleRegion()<<", vertical largest region: "<GetLargestPossibleRegion()); } if (maskDisp && horizDisp->GetLargestPossibleRegion() != maskDisp->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Disparity map and mask do not have the same size ! Map region : " <GetLargestPossibleRegion()<<", mask region : "<GetLargestPossibleRegion()); } horizDisp->SetRequestedRegion( outputDEM->GetRequestedRegion() ); if (vertiDisp) { vertiDisp->SetRequestedRegion( outputDEM->GetRequestedRegion() ); } if (maskDisp) { maskDisp->SetRequestedRegion( outputDEM->GetRequestedRegion() ); } // Check that the keywordlists are not empty if (m_LeftKeywordList.GetSize() == 0 || m_RightKeywordList.GetSize() == 0) { itkExceptionMacro(<<"At least one of the image keywordlist is empty : can't instantiate corresponding projection"); } } template void DisparityMapTo3DFilter ::BeforeThreadedGenerateData() { // Instantiate transforms m_LeftToGroundTransform = RSTransformType::New(); m_RightToGroundTransform = RSTransformType::New(); m_LeftToGroundTransform->SetInputKeywordList(m_LeftKeywordList); m_RightToGroundTransform->SetInputKeywordList(m_RightKeywordList); m_LeftToGroundTransform->InstantiateTransform(); m_RightToGroundTransform->InstantiateTransform(); } template void DisparityMapTo3DFilter ::ThreadedGenerateData(const RegionType & itkNotUsed(outputRegionForThread), itk::ThreadIdType itkNotUsed(threadId)) { const TDisparityImage * horizDisp = this->GetHorizontalDisparityMapInput(); const TDisparityImage * vertiDisp = this->GetVerticalDisparityMapInput(); const TMaskImage * disparityMask = this->GetDisparityMaskInput(); TOutputImage * outputDEM = this->GetOutput(); // Get epipolar grids const TEpipolarGridImage * leftGrid = this->GetLeftEpipolarGridInput(); const TEpipolarGridImage * rightGrid = this->GetRightEpipolarGridInput(); typename TEpipolarGridImage::RegionType gridRegion = leftGrid->GetLargestPossibleRegion(); typename TOutputImage::RegionType outputRequestedRegion = outputDEM->GetRequestedRegion(); itk::ImageRegionIterator demIt(outputDEM,outputRequestedRegion); itk::ImageRegionConstIteratorWithIndex horizIt(horizDisp,outputRequestedRegion); demIt.GoToBegin(); horizIt.GoToBegin(); bool useVerti = false; itk::ImageRegionConstIteratorWithIndex vertiIt; if (vertiDisp) { useVerti = true; vertiIt = itk::ImageRegionConstIteratorWithIndex(vertiDisp,outputRequestedRegion); vertiIt.GoToBegin(); } bool useMask = false; itk::ImageRegionConstIterator maskIt; if (disparityMask) { useMask = true; maskIt = itk::ImageRegionConstIterator(disparityMask,outputRequestedRegion); maskIt.GoToBegin(); } double elevationMin = 0.0; double elevationMax = 300.0; typename OptimizerType::Pointer optimizer = OptimizerType::New(); typename TDisparityImage::PointType epiPoint; itk::ContinuousIndex gridIndexConti; double subPixIndex[2]; typename GridImageType::IndexType ulIndex, urIndex, lrIndex, llIndex; typename GridImageType::PixelType ulPixel(2); typename GridImageType::PixelType urPixel(2); typename GridImageType::PixelType lrPixel(2); typename GridImageType::PixelType llPixel(2); typename GridImageType::PixelType cPixel(2); typename GridImageType::PointType ulPoint; typename GridImageType::PointType urPoint; typename GridImageType::PointType lrPoint; typename GridImageType::PointType llPoint; TDPointType sensorPoint; TDPointType leftGroundHmin; TDPointType leftGroundHmax; TDPointType rightGroundHmin; TDPointType rightGroundHmax; while (!demIt.IsAtEnd() && !horizIt.IsAtEnd()) { // check mask value if any if (useMask) { if (!(maskIt.Get() > 0)) { // TODO : what to do when masked ? put a no-data value ? typename OutputImageType::PixelType pixel3D(3); pixel3D.Fill(0); demIt.Set(pixel3D); ++demIt; ++horizIt; if (useVerti) ++vertiIt; ++maskIt; continue; } } // compute left ray horizDisp->TransformIndexToPhysicalPoint(horizIt.GetIndex(),epiPoint); leftGrid->TransformPhysicalPointToContinuousIndex(epiPoint,gridIndexConti); ulIndex[0] = static_cast(vcl_floor(gridIndexConti[0])); ulIndex[1] = static_cast(vcl_floor(gridIndexConti[1])); if (ulIndex[0] < gridRegion.GetIndex(0)) ulIndex[0] = gridRegion.GetIndex(0); if (ulIndex[1] < gridRegion.GetIndex(1)) ulIndex[1] = gridRegion.GetIndex(1); if (ulIndex[0] > (gridRegion.GetIndex(0) + static_cast(gridRegion.GetSize(0)) - 2)) { ulIndex[0] = gridRegion.GetIndex(0) + gridRegion.GetSize(0) - 2; } if (ulIndex[1] > (gridRegion.GetIndex(1) + static_cast(gridRegion.GetSize(1)) - 2)) { ulIndex[1] = gridRegion.GetIndex(1) + gridRegion.GetSize(1) - 2; } urIndex[0] = ulIndex[0] + 1; urIndex[1] = ulIndex[1]; lrIndex[0] = ulIndex[0] + 1; lrIndex[1] = ulIndex[1] + 1; llIndex[0] = ulIndex[0]; llIndex[1] = ulIndex[1] + 1; subPixIndex[0] = gridIndexConti[0] - static_cast(ulIndex[0]); subPixIndex[1] = gridIndexConti[1] - static_cast(ulIndex[1]); leftGrid->TransformIndexToPhysicalPoint(ulIndex, ulPoint); leftGrid->TransformIndexToPhysicalPoint(urIndex, urPoint); leftGrid->TransformIndexToPhysicalPoint(lrIndex, lrPoint); leftGrid->TransformIndexToPhysicalPoint(llIndex, llPoint); ulPixel[0] = (leftGrid->GetPixel(ulIndex))[0] + ulPoint[0]; ulPixel[1] = (leftGrid->GetPixel(ulIndex))[1] + ulPoint[1]; urPixel[0] = (leftGrid->GetPixel(urIndex))[0] + urPoint[0]; urPixel[1] = (leftGrid->GetPixel(urIndex))[1] + urPoint[1]; lrPixel[0] = (leftGrid->GetPixel(lrIndex))[0] + lrPoint[0]; lrPixel[1] = (leftGrid->GetPixel(lrIndex))[1] + lrPoint[1]; llPixel[0] = (leftGrid->GetPixel(llIndex))[0] + llPoint[0]; llPixel[1] = (leftGrid->GetPixel(llIndex))[1] + llPoint[1]; cPixel = (ulPixel * (1.0 - subPixIndex[0]) + urPixel * subPixIndex[0]) * (1.0 - subPixIndex[1]) + (llPixel * (1.0 - subPixIndex[0]) + lrPixel * subPixIndex[0]) * subPixIndex[1]; sensorPoint[0] = cPixel[0]; sensorPoint[1] = cPixel[1]; sensorPoint[2] = elevationMin; leftGroundHmin = m_LeftToGroundTransform->TransformPoint(sensorPoint); sensorPoint[2] = elevationMax; leftGroundHmax = m_LeftToGroundTransform->TransformPoint(sensorPoint); // compute right ray itk::ContinuousIndex rightIndexEstimate; rightIndexEstimate[0] = static_cast((horizIt.GetIndex())[0]) + static_cast(horizIt.Get()); double verticalShift = 0; if (useVerti) verticalShift = static_cast(vertiIt.Get()); rightIndexEstimate[1] = static_cast((horizIt.GetIndex())[1]) + verticalShift; horizDisp->TransformContinuousIndexToPhysicalPoint(rightIndexEstimate,epiPoint); rightGrid->TransformPhysicalPointToContinuousIndex(epiPoint,gridIndexConti); ulIndex[0] = static_cast(vcl_floor(gridIndexConti[0])); ulIndex[1] = static_cast(vcl_floor(gridIndexConti[1])); if (ulIndex[0] < gridRegion.GetIndex(0)) ulIndex[0] = gridRegion.GetIndex(0); if (ulIndex[1] < gridRegion.GetIndex(1)) ulIndex[1] = gridRegion.GetIndex(1); if (ulIndex[0] > (gridRegion.GetIndex(0) + static_cast(gridRegion.GetSize(0)) - 2)) { ulIndex[0] = gridRegion.GetIndex(0) + gridRegion.GetSize(0) - 2; } if (ulIndex[1] > (gridRegion.GetIndex(1) + static_cast(gridRegion.GetSize(1)) - 2)) { ulIndex[1] = gridRegion.GetIndex(1) + gridRegion.GetSize(1) - 2; } urIndex[0] = ulIndex[0] + 1; urIndex[1] = ulIndex[1]; lrIndex[0] = ulIndex[0] + 1; lrIndex[1] = ulIndex[1] + 1; llIndex[0] = ulIndex[0]; llIndex[1] = ulIndex[1] + 1; subPixIndex[0] = gridIndexConti[0] - static_cast(ulIndex[0]); subPixIndex[1] = gridIndexConti[1] - static_cast(ulIndex[1]); rightGrid->TransformIndexToPhysicalPoint(ulIndex, ulPoint); rightGrid->TransformIndexToPhysicalPoint(urIndex, urPoint); rightGrid->TransformIndexToPhysicalPoint(lrIndex, lrPoint); rightGrid->TransformIndexToPhysicalPoint(llIndex, llPoint); ulPixel[0] = (rightGrid->GetPixel(ulIndex))[0] + ulPoint[0]; ulPixel[1] = (rightGrid->GetPixel(ulIndex))[1] + ulPoint[1]; urPixel[0] = (rightGrid->GetPixel(urIndex))[0] + urPoint[0]; urPixel[1] = (rightGrid->GetPixel(urIndex))[1] + urPoint[1]; lrPixel[0] = (rightGrid->GetPixel(lrIndex))[0] + lrPoint[0]; lrPixel[1] = (rightGrid->GetPixel(lrIndex))[1] + lrPoint[1]; llPixel[0] = (rightGrid->GetPixel(llIndex))[0] + llPoint[0]; llPixel[1] = (rightGrid->GetPixel(llIndex))[1] + llPoint[1]; cPixel = (ulPixel * (1.0 - subPixIndex[0]) + urPixel * subPixIndex[0]) * (1.0 - subPixIndex[1]) + (llPixel * (1.0 - subPixIndex[0]) + lrPixel * subPixIndex[0]) * subPixIndex[1]; sensorPoint[0] = cPixel[0]; sensorPoint[1] = cPixel[1]; sensorPoint[2] = elevationMin; rightGroundHmin = m_RightToGroundTransform->TransformPoint(sensorPoint); sensorPoint[2] = elevationMax; rightGroundHmax = m_RightToGroundTransform->TransformPoint(sensorPoint); // Compute ray intersection with the generic line of sight optimizer typename PointSetType::Pointer pointSetA = PointSetType::New(); typename PointSetType::Pointer pointSetB = PointSetType::New(); pointSetA->SetPoint(0,leftGroundHmax); pointSetA->SetPoint(1,rightGroundHmax); pointSetA->SetPointData(0,0); pointSetA->SetPointData(1,1); pointSetB->SetPoint(0,leftGroundHmin); pointSetB->SetPoint(1,rightGroundHmin); pointSetB->SetPointData(0,0); pointSetB->SetPointData(1,1); TDPointType midPoint3D = optimizer->Compute(pointSetA,pointSetB); // record 3D point typename OutputImageType::PixelType pixel3D(3); pixel3D[0] = midPoint3D[0]; pixel3D[1] = midPoint3D[1]; pixel3D[2] = midPoint3D[2]; demIt.Set(pixel3D); ++demIt; ++horizIt; if (useVerti) ++vertiIt; if (useMask) ++maskIt; } } } #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapToDEMFilter.h000066400000000000000000000163241301006202600310220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapToDEMFilter_h #define otbDisparityMapToDEMFilter_h #include "itkImageToImageFilter.h" #include "otbGenericRSTransform.h" #include "itkImageRegionSplitter.h" #include "otbVectorImage.h" #include "otbImage.h" namespace otb { /** \class DisparityMapToDEMFilter * \brief Project an input disparity map into a regular DEM * * This filter uses an input disparity map (horizontal and vertical) to produce a DEM with a regular sampling * in the chosen map projection system. The elevation is computed from the triangulation of the "left-right" pairs * of pixels matched. When several elevations are possible on a DEM cell, the highest is kept. Note : disparity maps * and DEM are expected to be of scalar image type. * * The inputs are: * - the horizontal and vertical disparity maps (SetHorizontalDisparityMapInput, SetVerticalDisparityMapInput) * - the original image pair (in sensor geometry) (SetLeftInput, SetRightInput) * - the deformation grids of the epipolar geometry (SetLeftEpipolarGridInput, SetRightEpipolarGridInput) * - the mask associated to the input disparity maps (SetDisparityMaskInput) * [- the DEM map projection system] * * The outputs are: * - the DEM (GetDEMOutput) * * \sa FineRegistrationImageFilter * \sa StereorectificationDisplacementFieldSource * \sa SubPixelDisparityImageFilter * \sa PixelWiseBlockMatchingImageFilter * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBDisparityMap */ template , class TMaskImage = otb::Image > class ITK_EXPORT DisparityMapToDEMFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef DisparityMapToDEMFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DisparityMapToDEMFilter, ImageToImageFilter); /** Useful typedefs */ typedef TDisparityImage DisparityMapType; typedef TInputImage SensorImageType; typedef TOutputDEMImage DEMImageType; typedef TEpipolarGridImage GridImageType; typedef TMaskImage MaskImageType; typedef typename DEMImageType::RegionType RegionType; typedef typename DEMImageType::PixelType DEMPixelType; typedef itk::ImageRegionSplitter<2> SplitterType; // 3D RS transform // TODO: Allow tuning precision (i.e. double or float) typedef otb::GenericRSTransform RSTransformType; //typedef typename RSTransformType::Pointer RSTransformPointerType; // 3D points typedef typename RSTransformType::InputPointType TDPointType; /** Set horizontal disparity map input */ void SetHorizontalDisparityMapInput( const TDisparityImage * hmap); /** Set vertical disparity map input */ void SetVerticalDisparityMapInput( const TDisparityImage * vmap); /** Set left input */ void SetLeftInput( const TInputImage * image); /** Set right input */ void SetRightInput( const TInputImage * image); /** Set left epipolar grid (deformation grid from sensor image to epipolar space, regular in epipolar space)*/ void SetLeftEpipolarGridInput( const TEpipolarGridImage * grid); /** Set right epipolar grid (deformation grid from sensor image to epipolar space, regular in epipolar space)*/ void SetRightEpipolarGridInput( const TEpipolarGridImage * grid); /** Set mask associated to disparity maps (optional, pixels with a null mask value are ignored) */ void SetDisparityMaskInput( const TMaskImage * mask); /** Get the inputs */ const TDisparityImage * GetHorizontalDisparityMapInput() const; const TDisparityImage * GetVerticalDisparityMapInput() const; const TInputImage * GetLeftInput() const; const TInputImage * GetRightInput() const; const TEpipolarGridImage * GetLeftEpipolarGridInput() const; const TEpipolarGridImage * GetRightEpipolarGridInput() const; const TMaskImage * GetDisparityMaskInput() const; /** Get DEM output*/ const TOutputDEMImage * GetDEMOutput() const; TOutputDEMImage * GetDEMOutput(); /** Set/Get macro for minimum elevation */ itkSetMacro(ElevationMin, double); itkGetConstReferenceMacro(ElevationMin, double); /** Set/Get macro for maximum elevation */ itkSetMacro(ElevationMax, double); itkGetConstReferenceMacro(ElevationMax, double); /** Set/Get macro for DEM grid step */ itkSetMacro(DEMGridStep, double); itkGetConstReferenceMacro(DEMGridStep, double); protected: /** Constructor */ DisparityMapToDEMFilter(); /** Destructor */ ~DisparityMapToDEMFilter() ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** After threaded generate data : sum up temporary DEMs */ void AfterThreadedGenerateData() ITK_OVERRIDE; /** Override VerifyInputInformation() since this filter's inputs do * not need to occupy the same physical space. * * \sa ProcessObject::VerifyInputInformation */ void VerifyInputInformation() ITK_OVERRIDE {} private: DisparityMapToDEMFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Minimum elevation of the DEM in meters */ double m_ElevationMin; /** Maximum elevation of the DEM in meters */ double m_ElevationMax; /** DEM grid step (in meters) */ double m_DEMGridStep; /** Region splitter for input disparity maps */ SplitterType::Pointer m_InputSplitter; /** Number of splits used for input multithreading */ unsigned int m_UsedInputSplits; /** Temporary DEMs for mutlithreading */ std::vector m_TempDEMRegions; /** Left sensor image transform */ RSTransformType::Pointer m_LeftToGroundTransform; /** Right sensor image transform */ RSTransformType::Pointer m_RightToGroundTransform; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDisparityMapToDEMFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityMapToDEMFilter.txx000066400000000000000000001144431301006202600314170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityMapToDEMFilter_txx #define otbDisparityMapToDEMFilter_txx #include "otbDisparityMapToDEMFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" namespace otb { template DisparityMapToDEMFilter ::DisparityMapToDEMFilter() { // Set the number of inputs this->SetNumberOfRequiredInputs(7); this->SetNumberOfRequiredInputs(1); // Set the outputs this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0,TOutputDEMImage::New()); // Default DEM reconstruction parameters m_ElevationMin = 0.0; m_ElevationMax = 100.0; m_DEMGridStep = 10.0; m_InputSplitter = SplitterType::New(); m_UsedInputSplits = 1; } template DisparityMapToDEMFilter ::~DisparityMapToDEMFilter() {} template void DisparityMapToDEMFilter ::SetHorizontalDisparityMapInput( const TDisparityImage * hmap) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( hmap )); } template void DisparityMapToDEMFilter ::SetVerticalDisparityMapInput( const TDisparityImage * vmap) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( vmap )); } template void DisparityMapToDEMFilter ::SetLeftInput( const TInputImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(2, const_cast( image )); } template void DisparityMapToDEMFilter ::SetRightInput( const TInputImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(3, const_cast( image )); } template void DisparityMapToDEMFilter ::SetLeftEpipolarGridInput( const TEpipolarGridImage * grid) { // Process object is not const-correct so the const casting is required. this->SetNthInput(4, const_cast( grid )); } template void DisparityMapToDEMFilter ::SetRightEpipolarGridInput( const TEpipolarGridImage * grid) { // Process object is not const-correct so the const casting is required. this->SetNthInput(5, const_cast( grid )); } template void DisparityMapToDEMFilter ::SetDisparityMaskInput( const TMaskImage * mask) { // Process object is not const-correct so the const casting is required. this->SetNthInput(6, const_cast( mask )); } template const TDisparityImage * DisparityMapToDEMFilter ::GetHorizontalDisparityMapInput() const { if(this->GetNumberOfInputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TDisparityImage * DisparityMapToDEMFilter ::GetVerticalDisparityMapInput() const { if(this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template const TInputImage * DisparityMapToDEMFilter ::GetLeftInput() const { if(this->GetNumberOfInputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template const TInputImage * DisparityMapToDEMFilter ::GetRightInput() const { if(this->GetNumberOfInputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3)); } template const TEpipolarGridImage * DisparityMapToDEMFilter ::GetLeftEpipolarGridInput() const { if(this->GetNumberOfInputs()<5) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(4)); } template const TEpipolarGridImage * DisparityMapToDEMFilter ::GetRightEpipolarGridInput() const { if(this->GetNumberOfInputs()<6) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(5)); } template const TMaskImage * DisparityMapToDEMFilter ::GetDisparityMaskInput() const { if(this->GetNumberOfInputs()<7) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(6)); } template const TOutputDEMImage * DisparityMapToDEMFilter ::GetDEMOutput() const { if(this->GetNumberOfOutputs()<1) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template TOutputDEMImage * DisparityMapToDEMFilter ::GetDEMOutput() { if(this->GetNumberOfOutputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template void DisparityMapToDEMFilter ::GenerateOutputInformation() { // Get common area between images const TInputImage * leftImgPtr = this->GetLeftInput(); const TInputImage * rightImgPtr = this->GetRightInput(); TOutputDEMImage * outputPtr = this->GetDEMOutput(); // Set-up a transform to use the DEMHandler typedef otb::GenericRSTransform<> RSTransform2DType; RSTransform2DType::Pointer leftToGroundTransform = RSTransform2DType::New(); leftToGroundTransform->SetInputKeywordList(leftImgPtr->GetImageKeywordlist()); leftToGroundTransform->InstantiateTransform(); RSTransform2DType::Pointer rightToGroundTransform = RSTransform2DType::New(); rightToGroundTransform->SetInputKeywordList(rightImgPtr->GetImageKeywordlist()); rightToGroundTransform->InstantiateTransform(); // left image typename SensorImageType::SizeType inputSize = leftImgPtr->GetLargestPossibleRegion().GetSize(); typename SensorImageType::PointType ulp, urp, llp, lrp; itk::ContinuousIndex ul(leftImgPtr->GetLargestPossibleRegion().GetIndex()); ul[0] += -0.5; ul[1] += -0.5; itk::ContinuousIndex ur(ul); itk::ContinuousIndex lr(ul); itk::ContinuousIndex ll(ul); ur[0] += static_cast(inputSize[0]); lr[0] += static_cast(inputSize[0]); lr[1] += static_cast(inputSize[1]); ll[1] += static_cast(inputSize[1]); leftImgPtr->TransformContinuousIndexToPhysicalPoint(ul,ulp); leftImgPtr->TransformContinuousIndexToPhysicalPoint(ur,urp); leftImgPtr->TransformContinuousIndexToPhysicalPoint(ll,llp); leftImgPtr->TransformContinuousIndexToPhysicalPoint(lr,lrp); RSTransform2DType::OutputPointType left_ul, left_ur, left_ll, left_lr; left_ul = leftToGroundTransform->TransformPoint(ulp); left_ur = leftToGroundTransform->TransformPoint(urp); left_ll = leftToGroundTransform->TransformPoint(llp); left_lr = leftToGroundTransform->TransformPoint(lrp); // right image inputSize = rightImgPtr->GetLargestPossibleRegion().GetSize(); ul = rightImgPtr->GetLargestPossibleRegion().GetIndex(); ul[0] += -0.5; ul[1] += -0.5; ur = ul; lr = ul; ll = ul; ur[0] += static_cast(inputSize[0]); lr[0] += static_cast(inputSize[0]); lr[1] += static_cast(inputSize[1]); ll[1] += static_cast(inputSize[1]); rightImgPtr->TransformContinuousIndexToPhysicalPoint(ul,ulp); rightImgPtr->TransformContinuousIndexToPhysicalPoint(ur,urp); rightImgPtr->TransformContinuousIndexToPhysicalPoint(ll,llp); rightImgPtr->TransformContinuousIndexToPhysicalPoint(lr,lrp); RSTransform2DType::OutputPointType right_ul, right_ur, right_lr, right_ll; right_ul = rightToGroundTransform->TransformPoint(ulp); right_ur = rightToGroundTransform->TransformPoint(urp); right_ll = rightToGroundTransform->TransformPoint(llp); right_lr = rightToGroundTransform->TransformPoint(lrp); double left_xmin = std::min(std::min(std::min(left_ul[0],left_ur[0]),left_lr[0]),left_ll[0]); double left_xmax = std::max(std::max(std::max(left_ul[0],left_ur[0]),left_lr[0]),left_ll[0]); double left_ymin = std::min(std::min(std::min(left_ul[1],left_ur[1]),left_lr[1]),left_ll[1]); double left_ymax = std::max(std::max(std::max(left_ul[1],left_ur[1]),left_lr[1]),left_ll[1]); double right_xmin = std::min(std::min(std::min(right_ul[0],right_ur[0]),right_lr[0]),right_ll[0]); double right_xmax = std::max(std::max(std::max(right_ul[0],right_ur[0]),right_lr[0]),right_ll[0]); double right_ymin = std::min(std::min(std::min(right_ul[1],right_ur[1]),right_lr[1]),right_ll[1]); double right_ymax = std::max(std::max(std::max(right_ul[1],right_ur[1]),right_lr[1]),right_ll[1]); double box_xmin = std::max(left_xmin,right_xmin); double box_xmax = std::min(left_xmax,right_xmax); double box_ymin = std::max(left_ymin,right_ymin); double box_ymax = std::min(left_ymax,right_ymax); if (box_xmin >= box_xmax || box_ymin >= box_ymax) { itkExceptionMacro(<<"Wrong reconstruction area, images don't overlap, check image corners"); } // Compute step : // TODO : use a clean RS transform instead typename TOutputDEMImage::SpacingType outSpacing; outSpacing[0] = 57.295779513 * m_DEMGridStep / (6378137.0 * vcl_cos((box_ymin + box_ymax) * 0.5 * 0.01745329251)); outSpacing[1] = -57.295779513 * m_DEMGridStep / 6378137.0; outputPtr->SetSpacing(outSpacing); // Choose origin typename TOutputDEMImage::PointType outOrigin; outOrigin[0] = box_xmin + 0.5 * outSpacing[0]; outOrigin[1] = box_ymax + 0.5 * outSpacing[1]; outputPtr->SetOrigin(outOrigin); // Compute output size typename DEMImageType::RegionType outRegion; outRegion.SetIndex(0,0); outRegion.SetIndex(1,0); outRegion.SetSize(0, static_cast((box_xmax - box_xmin) / vcl_abs(outSpacing[0]))); outRegion.SetSize(1, static_cast((box_ymax - box_ymin) / vcl_abs(outSpacing[1]))); outputPtr->SetLargestPossibleRegion(outRegion); outputPtr->SetNumberOfComponentsPerPixel(1); } template void DisparityMapToDEMFilter ::GenerateInputRequestedRegion() { // For the epi grid : generate full buffer here ! TEpipolarGridImage * leftGrid = const_cast(this->GetLeftEpipolarGridInput()); TEpipolarGridImage * rightGrid = const_cast(this->GetRightEpipolarGridInput()); leftGrid->SetRequestedRegionToLargestPossibleRegion(); rightGrid->SetRequestedRegionToLargestPossibleRegion(); leftGrid->UpdateOutputData(); rightGrid->UpdateOutputData(); // For the input left-right images // -> No need, only use metadata and keywordlist const TInputImage * leftSensor = this->GetLeftInput(); TOutputDEMImage * outputDEM = this->GetDEMOutput(); typename DEMImageType::RegionType outRegion = outputDEM->GetRequestedRegion(); typename DEMImageType::PointType outOrigin = outputDEM->GetOrigin(); typename DEMImageType::SpacingType outSpacing = outputDEM->GetSpacing(); RSTransformType::Pointer groundToLeftTransform = RSTransformType::New(); groundToLeftTransform->SetOutputKeywordList(leftSensor->GetImageKeywordlist()); groundToLeftTransform->InstantiateTransform(); // For the disparity maps and mask // Iterate over OutputRequestedRegion corners for elevation min and max TDisparityImage * horizDisp = const_cast(this->GetHorizontalDisparityMapInput()); TDisparityImage * vertiDisp = const_cast(this->GetVerticalDisparityMapInput()); TMaskImage * maskDisp = const_cast(this->GetDisparityMaskInput()); // We impose that both disparity map inputs have the same size if(horizDisp->GetLargestPossibleRegion() != vertiDisp->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Horizontal and vertical disparity maps do not have the same size ! Horizontal largest region: " <GetLargestPossibleRegion()<<", vertical largest region: "<GetLargestPossibleRegion()); } if (maskDisp && horizDisp->GetLargestPossibleRegion() != maskDisp->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Disparity map and mask do not have the same size ! Map region : " <GetLargestPossibleRegion()<<", mask region : "<GetLargestPossibleRegion()); } // up left at elevation min TDPointType corners[8]; corners[0][0]= outOrigin[0] + outSpacing[0] * (-0.5 + static_cast(outRegion.GetIndex(0))); corners[0][1]= outOrigin[1] + outSpacing[1] * (-0.5 + static_cast(outRegion.GetIndex(1))); corners[0][2]= m_ElevationMin; // up left at elevation max corners[1][0]= corners[0][0]; corners[1][1]= corners[0][1]; corners[1][2]= m_ElevationMax; // up right at elevation min corners[2][0]= corners[0][0] + outSpacing[0] * static_cast(outRegion.GetSize(0)); corners[2][1]= corners[0][1]; corners[2][2]= m_ElevationMin; // up right at elevation max corners[3][0]= corners[2][0]; corners[3][1]= corners[2][1]; corners[3][2]= m_ElevationMax; // low right at elevation min corners[4][0]= corners[0][0] + outSpacing[0] * static_cast(outRegion.GetSize(0)); corners[4][1]= corners[0][1] + outSpacing[1] * static_cast(outRegion.GetSize(1)); corners[4][2]= m_ElevationMin; // low right at elevation max corners[5][0]= corners[4][0]; corners[5][1]= corners[4][1]; corners[5][2]= m_ElevationMax; // low left at elevation min corners[6][0]= corners[0][0]; corners[6][1]= corners[0][1] + outSpacing[1] * static_cast(outRegion.GetSize(1)); corners[6][2]= m_ElevationMin; // low left at elevation max corners[7][0]= corners[6][0]; corners[7][1]= corners[6][1]; corners[7][2]= m_ElevationMax; double x_loc,y_loc; double a_grid,b_grid; double u_loc[2]; double v_loc[2]; double det; typename GridImageType::IndexType gridIndex; typename GridImageType::IndexType gridIndexU; typename GridImageType::IndexType gridIndexV; typename GridImageType::PointType gridPoint; typename GridImageType::PointType gridPointU; typename GridImageType::PointType gridPointV; typename GridImageType::PixelType origLoc(2); typename GridImageType::PixelType uUnitLoc(2); typename GridImageType::PixelType vUnitLoc(2); typename GridImageType::RegionType gridRegion = leftGrid->GetLargestPossibleRegion(); itk::ContinuousIndex gridContiIndex; typename DisparityMapType::PointType epiPosition; itk::ContinuousIndex epiContiIndex; double epiIndexMin[2]; double epiIndexMax[2]; int maxGridIndex[2]; int minGridIndex[2]; epiIndexMin[0] = itk::NumericTraits::Zero; epiIndexMin[1] = itk::NumericTraits::Zero; epiIndexMax[0] = itk::NumericTraits::Zero; epiIndexMax[1] = itk::NumericTraits::Zero; maxGridIndex[0] = static_cast(gridRegion.GetIndex(0) + gridRegion.GetSize(0)) - 2; maxGridIndex[1] = static_cast(gridRegion.GetIndex(1) + gridRegion.GetSize(1)) - 2; minGridIndex[0] = static_cast(gridRegion.GetIndex(0)); minGridIndex[1] = static_cast(gridRegion.GetIndex(1)); for (unsigned int k=0; k<8; k++) { // compute left image coordinate TDPointType tmpSensor = groundToLeftTransform->TransformPoint(corners[k]); // compute epipolar position gridIndex[0] = minGridIndex[0]; gridIndex[1] = minGridIndex[1]; //we assume 3 iterations are enough to find the 4 surrounding pixels for (unsigned int s=0; s<3; s++) { gridIndexU[0] = gridIndex[0] + 1; gridIndexU[1] = gridIndex[1]; gridIndexV[0] = gridIndex[0]; gridIndexV[1] = gridIndex[1] + 1; leftGrid->TransformIndexToPhysicalPoint(gridIndex, gridPoint); leftGrid->TransformIndexToPhysicalPoint(gridIndexU, gridPointU); leftGrid->TransformIndexToPhysicalPoint(gridIndexV, gridPointV); origLoc[0] = (leftGrid->GetPixel(gridIndex))[0] + gridPoint[0]; origLoc[1] = (leftGrid->GetPixel(gridIndex))[1] + gridPoint[1]; uUnitLoc[0] = (leftGrid->GetPixel(gridIndexU))[0] + gridPointU[0]; uUnitLoc[1] = (leftGrid->GetPixel(gridIndexU))[1] + gridPointU[1]; vUnitLoc[0] = (leftGrid->GetPixel(gridIndexV))[0] + gridPointV[0]; vUnitLoc[1] = (leftGrid->GetPixel(gridIndexV))[1] + gridPointV[1]; u_loc[0] = static_cast(uUnitLoc[0] - origLoc[0]); u_loc[1] = static_cast(uUnitLoc[1] - origLoc[1]); v_loc[0] = static_cast(vUnitLoc[0] - origLoc[0]); v_loc[1] = static_cast(vUnitLoc[1] - origLoc[1]); det = u_loc[0] * v_loc[1] - v_loc[0] * u_loc[1]; x_loc = static_cast(tmpSensor[0]) - static_cast(origLoc[0]); y_loc = static_cast(tmpSensor[1]) - static_cast(origLoc[1]); a_grid = (x_loc * v_loc[1] - y_loc * v_loc[0]) / det; b_grid = (y_loc * u_loc[0] - x_loc * u_loc[1]) / det; gridContiIndex[0] = static_cast(gridIndex[0]) + a_grid; gridContiIndex[1] = static_cast(gridIndex[1]) + b_grid; leftGrid->TransformContinuousIndexToPhysicalPoint(gridContiIndex, epiPosition); horizDisp->TransformPhysicalPointToContinuousIndex(epiPosition,epiContiIndex); if (0.0 < a_grid && a_grid < 1.0 && 0.0 < b_grid && b_grid < 1.0) { // The four nearest positions in epipolar grid have been found : stop search break; } else { // Shift the gridIndex int a_grid_int = static_cast(gridIndex[0]) + static_cast(vcl_floor(a_grid)); int b_grid_int = static_cast(gridIndex[1]) + static_cast(vcl_floor(b_grid)); if (a_grid_int < minGridIndex[0]) a_grid_int = minGridIndex[0]; if (a_grid_int > maxGridIndex[0]) a_grid_int = maxGridIndex[0]; if (b_grid_int < minGridIndex[1]) b_grid_int = minGridIndex[1]; if (b_grid_int > maxGridIndex[1]) b_grid_int = maxGridIndex[1]; gridIndex[0] = a_grid_int; gridIndex[1] = b_grid_int; } } if (k==0) { epiIndexMin[0] = epiContiIndex[0]; epiIndexMin[1] = epiContiIndex[1]; epiIndexMax[0] = epiContiIndex[0]; epiIndexMax[1] = epiContiIndex[1]; } else { if (epiContiIndex[0] < epiIndexMin[0]) epiIndexMin[0] = epiContiIndex[0]; if (epiContiIndex[1] < epiIndexMin[1]) epiIndexMin[1] = epiContiIndex[1]; if (epiIndexMax[0] < epiContiIndex[0]) epiIndexMax[0] = epiContiIndex[0]; if (epiIndexMax[1] < epiContiIndex[1]) epiIndexMax[1] = epiContiIndex[1]; } } typename DisparityMapType::RegionType inputDisparityRegion; inputDisparityRegion.SetIndex(0, static_cast(vcl_floor(epiIndexMin[0] + 0.5))); inputDisparityRegion.SetIndex(1, static_cast(vcl_floor(epiIndexMin[1] + 0.5))); inputDisparityRegion.SetSize(0, 1 + static_cast(vcl_floor(epiIndexMax[0] - epiIndexMin[0] + 0.5))); inputDisparityRegion.SetSize(1, 1 + static_cast(vcl_floor(epiIndexMax[1] - epiIndexMin[1] + 0.5))); // crop the disparity region at the largest possible region if ( inputDisparityRegion.Crop(horizDisp->GetLargestPossibleRegion())) { horizDisp->SetRequestedRegion( inputDisparityRegion ); vertiDisp->SetRequestedRegion( inputDisparityRegion ); if (maskDisp) { maskDisp->SetRequestedRegion( inputDisparityRegion ); } } else { // use empty region typename DisparityMapType::RegionType emptyRegion; emptyRegion.SetIndex(horizDisp->GetLargestPossibleRegion().GetIndex()); emptyRegion.SetSize(0,0); emptyRegion.SetSize(1,0); horizDisp->SetRequestedRegion( emptyRegion ); vertiDisp->SetRequestedRegion( emptyRegion ); if (maskDisp) { maskDisp->SetRequestedRegion( emptyRegion ); } // no exception : it can happen in this filter if (0) { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) horizDisp->SetRequestedRegion( inputDisparityRegion ); vertiDisp->SetRequestedRegion( inputDisparityRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of disparity map."); e.SetDataObject(horizDisp); throw e; } } } template void DisparityMapToDEMFilter ::BeforeThreadedGenerateData() { const TDisparityImage * horizDisp = this->GetHorizontalDisparityMapInput(); const TInputImage * leftSensor = this->GetLeftInput(); const TInputImage * rightSensor = this->GetRightInput(); const TOutputDEMImage * outputDEM = this->GetDEMOutput(); typename DisparityMapType::RegionType requestedRegion = horizDisp->GetRequestedRegion(); m_UsedInputSplits = m_InputSplitter->GetNumberOfSplits(requestedRegion, this->GetNumberOfThreads()); m_LeftToGroundTransform = RSTransformType::New(); m_RightToGroundTransform = RSTransformType::New(); m_LeftToGroundTransform->SetInputKeywordList(leftSensor->GetImageKeywordlist()); m_RightToGroundTransform->SetInputKeywordList(rightSensor->GetImageKeywordlist()); m_LeftToGroundTransform->InstantiateTransform(); m_RightToGroundTransform->InstantiateTransform(); // ensure empty regions are not processed if (requestedRegion.GetSize(0) == 0 && requestedRegion.GetSize(1) == 0) { m_UsedInputSplits = 0; } if (m_UsedInputSplits <= static_cast(this->GetNumberOfThreads())) { m_TempDEMRegions.clear(); for (unsigned int i=0; iSetNumberOfComponentsPerPixel(1); tmpImg->SetRegions(outputDEM->GetRequestedRegion()); tmpImg->Allocate(); typename DEMImageType::PixelType minElevation = static_cast(m_ElevationMin); tmpImg->FillBuffer(minElevation); m_TempDEMRegions.push_back(tmpImg); } } else { itkExceptionMacro(<<"Wrong number of splits for input multithreading : "< void DisparityMapToDEMFilter ::ThreadedGenerateData(const RegionType & itkNotUsed(outputRegionForThread), itk::ThreadIdType threadId) { const TDisparityImage * horizDisp = this->GetHorizontalDisparityMapInput(); const TDisparityImage * vertiDisp = this->GetVerticalDisparityMapInput(); const TMaskImage * disparityMask = this->GetDisparityMaskInput(); const TOutputDEMImage * outputDEM = this->GetDEMOutput(); const TEpipolarGridImage * leftGrid = this->GetLeftEpipolarGridInput(); const TEpipolarGridImage * rightGrid = this->GetRightEpipolarGridInput(); typename TEpipolarGridImage::RegionType gridRegion = leftGrid->GetLargestPossibleRegion(); TOutputDEMImage * tmpDEM = ITK_NULLPTR; typename TOutputDEMImage::RegionType outputRequestedRegion = outputDEM->GetRequestedRegion(); typename TDisparityImage::RegionType disparityRegion; if (static_cast(threadId) < m_UsedInputSplits) { disparityRegion = m_InputSplitter->GetSplit(threadId,m_UsedInputSplits,horizDisp->GetRequestedRegion()); tmpDEM = m_TempDEMRegions[threadId]; } else { return; } itk::ImageRegionConstIteratorWithIndex horizIt(horizDisp,disparityRegion); itk::ImageRegionConstIteratorWithIndex vertiIt(vertiDisp,disparityRegion); horizIt.GoToBegin(); vertiIt.GoToBegin(); bool useMask = false; itk::ImageRegionConstIterator maskIt; if (disparityMask) { useMask = true; maskIt = itk::ImageRegionConstIterator(disparityMask,disparityRegion); maskIt.GoToBegin(); } typename TDisparityImage::PointType epiPoint; itk::ContinuousIndex gridIndexConti; double subPixIndex[2]; typename GridImageType::IndexType ulIndex, urIndex, lrIndex, llIndex; typename GridImageType::PixelType ulPixel(2); typename GridImageType::PixelType urPixel(2); typename GridImageType::PixelType lrPixel(2); typename GridImageType::PixelType llPixel(2); typename GridImageType::PixelType cPixel(2); typename GridImageType::PointType ulPoint; typename GridImageType::PointType urPoint; typename GridImageType::PointType lrPoint; typename GridImageType::PointType llPoint; TDPointType sensorPoint; TDPointType leftGroundHmin; TDPointType leftGroundHmax; TDPointType rightGroundHmin; TDPointType rightGroundHmax; while (!horizIt.IsAtEnd() && !vertiIt.IsAtEnd()) { // check mask value if any if (useMask) { if (!(maskIt.Get() > 0)) { ++horizIt; ++vertiIt; ++maskIt; continue; } } // compute left ray horizDisp->TransformIndexToPhysicalPoint(horizIt.GetIndex(),epiPoint); leftGrid->TransformPhysicalPointToContinuousIndex(epiPoint,gridIndexConti); ulIndex[0] = static_cast(vcl_floor(gridIndexConti[0])); ulIndex[1] = static_cast(vcl_floor(gridIndexConti[1])); if (ulIndex[0] < gridRegion.GetIndex(0)) ulIndex[0] = gridRegion.GetIndex(0); if (ulIndex[1] < gridRegion.GetIndex(1)) ulIndex[1] = gridRegion.GetIndex(1); if (ulIndex[0] > (gridRegion.GetIndex(0) + static_cast(gridRegion.GetSize(0)) - 2)) { ulIndex[0] = gridRegion.GetIndex(0) + gridRegion.GetSize(0) - 2; } if (ulIndex[1] > (gridRegion.GetIndex(1) + static_cast(gridRegion.GetSize(1)) - 2)) { ulIndex[1] = gridRegion.GetIndex(1) + gridRegion.GetSize(1) - 2; } urIndex[0] = ulIndex[0] + 1; urIndex[1] = ulIndex[1]; lrIndex[0] = ulIndex[0] + 1; lrIndex[1] = ulIndex[1] + 1; llIndex[0] = ulIndex[0]; llIndex[1] = ulIndex[1] + 1; subPixIndex[0] = gridIndexConti[0] - static_cast(ulIndex[0]); subPixIndex[1] = gridIndexConti[1] - static_cast(ulIndex[1]); leftGrid->TransformIndexToPhysicalPoint(ulIndex, ulPoint); leftGrid->TransformIndexToPhysicalPoint(urIndex, urPoint); leftGrid->TransformIndexToPhysicalPoint(lrIndex, lrPoint); leftGrid->TransformIndexToPhysicalPoint(llIndex, llPoint); ulPixel[0] = (leftGrid->GetPixel(ulIndex))[0] + ulPoint[0]; ulPixel[1] = (leftGrid->GetPixel(ulIndex))[1] + ulPoint[1]; urPixel[0] = (leftGrid->GetPixel(urIndex))[0] + urPoint[0]; urPixel[1] = (leftGrid->GetPixel(urIndex))[1] + urPoint[1]; lrPixel[0] = (leftGrid->GetPixel(lrIndex))[0] + lrPoint[0]; lrPixel[1] = (leftGrid->GetPixel(lrIndex))[1] + lrPoint[1]; llPixel[0] = (leftGrid->GetPixel(llIndex))[0] + llPoint[0]; llPixel[1] = (leftGrid->GetPixel(llIndex))[1] + llPoint[1]; cPixel = (ulPixel * (1.0 - subPixIndex[0]) + urPixel * subPixIndex[0]) * (1.0 - subPixIndex[1]) + (llPixel * (1.0 - subPixIndex[0]) + lrPixel * subPixIndex[0]) * subPixIndex[1]; sensorPoint[0] = cPixel[0]; sensorPoint[1] = cPixel[1]; sensorPoint[2] = m_ElevationMin; leftGroundHmin = m_LeftToGroundTransform->TransformPoint(sensorPoint); sensorPoint[2] = m_ElevationMax; leftGroundHmax = m_LeftToGroundTransform->TransformPoint(sensorPoint); // compute right ray itk::ContinuousIndex rightIndexEstimate; rightIndexEstimate[0] = static_cast((horizIt.GetIndex())[0]) + static_cast(horizIt.Get()); rightIndexEstimate[1] = static_cast((horizIt.GetIndex())[1]) + static_cast(vertiIt.Get()); horizDisp->TransformContinuousIndexToPhysicalPoint(rightIndexEstimate,epiPoint); rightGrid->TransformPhysicalPointToContinuousIndex(epiPoint,gridIndexConti); ulIndex[0] = static_cast(vcl_floor(gridIndexConti[0])); ulIndex[1] = static_cast(vcl_floor(gridIndexConti[1])); if (ulIndex[0] < gridRegion.GetIndex(0)) ulIndex[0] = gridRegion.GetIndex(0); if (ulIndex[1] < gridRegion.GetIndex(1)) ulIndex[1] = gridRegion.GetIndex(1); if (ulIndex[0] > (gridRegion.GetIndex(0) + static_cast(gridRegion.GetSize(0)) - 2)) { ulIndex[0] = gridRegion.GetIndex(0) + gridRegion.GetSize(0) - 2; } if (ulIndex[1] > (gridRegion.GetIndex(1) + static_cast(gridRegion.GetSize(1)) - 2)) { ulIndex[1] = gridRegion.GetIndex(1) + gridRegion.GetSize(1) - 2; } urIndex[0] = ulIndex[0] + 1; urIndex[1] = ulIndex[1]; lrIndex[0] = ulIndex[0] + 1; lrIndex[1] = ulIndex[1] + 1; llIndex[0] = ulIndex[0]; llIndex[1] = ulIndex[1] + 1; subPixIndex[0] = gridIndexConti[0] - static_cast(ulIndex[0]); subPixIndex[1] = gridIndexConti[1] - static_cast(ulIndex[1]); rightGrid->TransformIndexToPhysicalPoint(ulIndex, ulPoint); rightGrid->TransformIndexToPhysicalPoint(urIndex, urPoint); rightGrid->TransformIndexToPhysicalPoint(lrIndex, lrPoint); rightGrid->TransformIndexToPhysicalPoint(llIndex, llPoint); ulPixel[0] = (rightGrid->GetPixel(ulIndex))[0] + ulPoint[0]; ulPixel[1] = (rightGrid->GetPixel(ulIndex))[1] + ulPoint[1]; urPixel[0] = (rightGrid->GetPixel(urIndex))[0] + urPoint[0]; urPixel[1] = (rightGrid->GetPixel(urIndex))[1] + urPoint[1]; lrPixel[0] = (rightGrid->GetPixel(lrIndex))[0] + lrPoint[0]; lrPixel[1] = (rightGrid->GetPixel(lrIndex))[1] + lrPoint[1]; llPixel[0] = (rightGrid->GetPixel(llIndex))[0] + llPoint[0]; llPixel[1] = (rightGrid->GetPixel(llIndex))[1] + llPoint[1]; cPixel = (ulPixel * (1.0 - subPixIndex[0]) + urPixel * subPixIndex[0]) * (1.0 - subPixIndex[1]) + (llPixel * (1.0 - subPixIndex[0]) + lrPixel * subPixIndex[0]) * subPixIndex[1]; sensorPoint[0] = cPixel[0]; sensorPoint[1] = cPixel[1]; sensorPoint[2] = m_ElevationMin; rightGroundHmin = m_RightToGroundTransform->TransformPoint(sensorPoint); sensorPoint[2] = m_ElevationMax; rightGroundHmax = m_RightToGroundTransform->TransformPoint(sensorPoint); // Compute ray intersection (mid-point method), TODO : implement non-iterative method from Hartley & Sturm double a = (leftGroundHmax[0] - leftGroundHmin[0]) * (leftGroundHmax[0] - leftGroundHmin[0]) + (leftGroundHmax[1] - leftGroundHmin[1]) * (leftGroundHmax[1] - leftGroundHmin[1]) + (leftGroundHmax[2] - leftGroundHmin[2]) * (leftGroundHmax[2] - leftGroundHmin[2]); double b = (rightGroundHmax[0] - rightGroundHmin[0]) * (rightGroundHmax[0] - rightGroundHmin[0]) + (rightGroundHmax[1] - rightGroundHmin[1]) * (rightGroundHmax[1] - rightGroundHmin[1]) + (rightGroundHmax[2] - rightGroundHmin[2]) * (rightGroundHmax[2] - rightGroundHmin[2]); double c = -(leftGroundHmax[0] - leftGroundHmin[0]) * (rightGroundHmax[0] - rightGroundHmin[0]) -(leftGroundHmax[1] - leftGroundHmin[1]) * (rightGroundHmax[1] - rightGroundHmin[1]) -(leftGroundHmax[2] - leftGroundHmin[2]) * (rightGroundHmax[2] - rightGroundHmin[2]); double g = (leftGroundHmax[0] - leftGroundHmin[0]) * (rightGroundHmin[0] - leftGroundHmin[0]) + (leftGroundHmax[1] - leftGroundHmin[1]) * (rightGroundHmin[1] - leftGroundHmin[1]) + (leftGroundHmax[2] - leftGroundHmin[2]) * (rightGroundHmin[2] - leftGroundHmin[2]); double h = -(rightGroundHmax[0] - rightGroundHmin[0]) * (rightGroundHmin[0] - leftGroundHmin[0]) -(rightGroundHmax[1] - rightGroundHmin[1]) * (rightGroundHmin[1] - leftGroundHmin[1]) -(rightGroundHmax[2] - rightGroundHmin[2]) * (rightGroundHmin[2] - leftGroundHmin[2]); double rLeft = (b * g - c * h) / (a * b - c * c); double rRight = (a * h - c * g) / (a * b - c * c); TDPointType leftFoot; leftFoot.SetToBarycentricCombination(leftGroundHmax,leftGroundHmin,rLeft ); TDPointType rightFoot; rightFoot.SetToBarycentricCombination(rightGroundHmax,rightGroundHmin,rRight); TDPointType midPoint3D; midPoint3D.SetToMidPoint(leftFoot,rightFoot); // Is point inside DEM area ? typename DEMImageType::PointType midPoint2D; midPoint2D[0] = midPoint3D[0]; midPoint2D[1] = midPoint3D[1]; itk::ContinuousIndex midIndex; outputDEM->TransformPhysicalPointToContinuousIndex(midPoint2D,midIndex); typename DEMImageType::IndexType cellIndex; //TODO JGT check if cellIndex should be calculed from the center of the pixel // TransformContinuousIndexToPhysicalPoint with index [0,0] returns Origin of image // TransformContinuousIndexToPhysicalPoint with index [0.5,0.5] returns a slight difference from Origin of image cellIndex[0] = static_cast(vcl_floor(midIndex[0] + 0.5)); cellIndex[1] = static_cast(vcl_floor(midIndex[1] + 0.5)); if (outputRequestedRegion.IsInside(cellIndex)) { // Estimate local reference elevation (average, DEM or geoid) => NO NEED, ALREADY HAVE 3D RAYS //double localElevation = demHandler->GetHeightAboveEllipsoid(midPoint2D); // Add point to its corresponding cell (keep maximum) DEMPixelType cellHeight = static_cast(midPoint3D[2]); if (cellHeight > tmpDEM->GetPixel(cellIndex) && cellHeight < static_cast(m_ElevationMax)) { tmpDEM->SetPixel(cellIndex,cellHeight); } } ++horizIt; ++vertiIt; if (useMask) ++maskIt; } } template void DisparityMapToDEMFilter ::AfterThreadedGenerateData() { TOutputDEMImage * outputDEM = this->GetDEMOutput(); if (m_TempDEMRegions.size() < 1) { outputDEM->FillBuffer(m_ElevationMin); return; } itk::ImageRegionIterator outputDEMIt(outputDEM,outputDEM->GetRequestedRegion()); itk::ImageRegionIterator firstDEMIt(m_TempDEMRegions[0],outputDEM->GetRequestedRegion()); outputDEMIt.GoToBegin(); firstDEMIt.GoToBegin(); // Copy first DEM while (!outputDEMIt.IsAtEnd() && !firstDEMIt.IsAtEnd()) { outputDEMIt.Set(firstDEMIt.Get()); ++outputDEMIt; ++firstDEMIt; } // Check DEMs from other threads and keep the maximum elevation for (unsigned int i=1; i tmpDEMIt(m_TempDEMRegions[i],outputDEM->GetRequestedRegion()); outputDEMIt.GoToBegin(); tmpDEMIt.GoToBegin(); while (!outputDEMIt.IsAtEnd() && !tmpDEMIt.IsAtEnd()) { if (tmpDEMIt.Get() > outputDEMIt.Get()) { outputDEMIt.Set(tmpDEMIt.Get()); } ++outputDEMIt; ++tmpDEMIt; } } } } #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityTranslateFilter.h000066400000000000000000000120621301006202600314040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityTranslateFilter_h #define otbDisparityTranslateFilter_h #include "itkImageToImageFilter.h" #include "otbVectorImage.h" #include "otbImage.h" namespace otb { /** \class DisparityTranslateFilter * \brief Translate epipolar disparities into sensor disparities * * This filter resamples a disparity map computed in epipolar geometry * into a disparity map relative to sensor geometry. The output disparity * map is aligned on the left sensor image. The disparity values are computed * relative to the physical coordinates of the left and right sensor images. * The vertical disparity mask input and the mask are optional. * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBDisparityMap */ template , class TSensorImage = otb::Image , class TMaskImage = otb::Image > class ITK_EXPORT DisparityTranslateFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef DisparityTranslateFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(DisparityTranslateFilter, ImageToImageFilter); /** Useful typedefs */ typedef TDisparityImage DispMapType; typedef TGridImage GridType; typedef TMaskImage MaskType; typedef TSensorImage SensorType; typedef typename DispMapType::PixelType PixelType; typedef typename DispMapType::RegionType RegionType; typedef typename DispMapType::SizeType SizeType; typedef typename DispMapType::IndexType IndexType; typedef typename DispMapType::SpacingType SpacingType; typedef typename DispMapType::PointType PointType; typedef typename DispMapType::IndexValueType IndexValueType; typedef typename GridType::RegionType GridRegionType; /** Set/Get macro for NoDataValue */ itkSetMacro(NoDataValue, PixelType); itkGetConstReferenceMacro(NoDataValue, PixelType); /** Set the horizontal disparity map */ void SetHorizontalDisparityMapInput( const TDisparityImage * hmap ); /** Set the vertical disparity map */ void SetVerticalDisparityMapInput( const TDisparityImage * vmap ); /** Set the inverse left epipolar grid */ void SetInverseEpipolarLeftGrid( const TGridImage * lgrid ); /** Set the direct epipolar right grid */ void SetDirectEpipolarRightGrid( const TGridImage * rgrid ); /** Set the mask relative to the input disparity map */ void SetDisparityMaskInput(const TMaskImage * mask); /** Set the left input sensor image * (used as a support for the output disparity map) */ void SetLeftSensorImageInput( const TSensorImage * left); /** Get the inputs */ const TDisparityImage * GetHorizontalDisparityMapInput() const; const TDisparityImage * GetVerticalDisparityMapInput() const; const TGridImage * GetInverseEpipolarLeftGrid() const; const TGridImage * GetDirectEpipolarRightGrid() const; const TMaskImage * GetDisparityMaskInput() const; const TSensorImage * GetLeftSensorImageInput() const; /** Get output disparity maps */ TDisparityImage * GetHorizontalDisparityMapOutput(); TDisparityImage * GetVerticalDisparityMapOutput(); protected: /** Constructor */ DisparityTranslateFilter(); /** Destructor */ ~DisparityTranslateFilter() ITK_OVERRIDE{}; /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Override VerifyInputInformation() since this filter's inputs do * not need to occupy the same physical space. * * \sa ProcessObject::VerifyInputInformation */ void VerifyInputInformation() ITK_OVERRIDE {} private: DisparityTranslateFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented PixelType m_NoDataValue; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbDisparityTranslateFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbDisparityTranslateFilter.txx000066400000000000000000000472271301006202600320130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbDisparityTranslateFilter_txx #define otbDisparityTranslateFilter_txx #include "otbDisparityTranslateFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkImageRegionIterator.h" namespace otb { template DisparityTranslateFilter ::DisparityTranslateFilter() { m_NoDataValue = -32768; // Set the number of inputs (1 moving image by default -> 3 inputs) this->SetNumberOfRequiredInputs(6); this->SetNumberOfRequiredInputs(1); // Set the outputs this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0,TDisparityImage::New()); this->SetNthOutput(1,TDisparityImage::New()); } template void DisparityTranslateFilter ::SetHorizontalDisparityMapInput( const TDisparityImage * hmap ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( hmap )); } template void DisparityTranslateFilter ::SetVerticalDisparityMapInput( const TDisparityImage * vmap ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( vmap )); } template void DisparityTranslateFilter ::SetInverseEpipolarLeftGrid( const TGridImage * lgrid ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(2, const_cast( lgrid )); } template void DisparityTranslateFilter ::SetDirectEpipolarRightGrid( const TGridImage * rgrid ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(3, const_cast( rgrid )); } template void DisparityTranslateFilter ::SetDisparityMaskInput( const TMaskImage * mask ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(4, const_cast( mask )); } template void DisparityTranslateFilter ::SetLeftSensorImageInput(const TSensorImage * left) { // Process object is not const-correct so the const casting is required. this->SetNthInput(5, const_cast( left )); } template const TDisparityImage * DisparityTranslateFilter ::GetHorizontalDisparityMapInput() const { if (this->GetNumberOfInputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TDisparityImage * DisparityTranslateFilter ::GetVerticalDisparityMapInput() const { if (this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template const TGridImage * DisparityTranslateFilter ::GetInverseEpipolarLeftGrid() const { if (this->GetNumberOfInputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template const TGridImage * DisparityTranslateFilter ::GetDirectEpipolarRightGrid() const { if (this->GetNumberOfInputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3)); } template const TMaskImage * DisparityTranslateFilter ::GetDisparityMaskInput() const { if (this->GetNumberOfInputs()<5) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(4)); } template const TSensorImage * DisparityTranslateFilter ::GetLeftSensorImageInput() const { if (this->GetNumberOfInputs()<6) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(5)); } template TDisparityImage * DisparityTranslateFilter ::GetHorizontalDisparityMapOutput() { if (this->GetNumberOfOutputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template TDisparityImage * DisparityTranslateFilter ::GetVerticalDisparityMapOutput() { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void DisparityTranslateFilter ::GenerateOutputInformation() { // this->Superclass::GenerateOutputInformation(); TDisparityImage * horizOut = this->GetHorizontalDisparityMapOutput(); TDisparityImage * vertiOut = this->GetVerticalDisparityMapOutput(); const TSensorImage * leftIn = this->GetLeftSensorImageInput(); horizOut->CopyInformation(leftIn); vertiOut->CopyInformation(leftIn); // Set the NoData value std::vector noDataValueAvailable; noDataValueAvailable.push_back(true); std::vector noDataValue; noDataValue.push_back(m_NoDataValue); itk::MetaDataDictionary& dict = horizOut->GetMetaDataDictionary(); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); dict = vertiOut->GetMetaDataDictionary(); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); } template void DisparityTranslateFilter ::GenerateInputRequestedRegion() { this->Superclass::GenerateInputRequestedRegion(); TGridImage * leftGrid = const_cast(this->GetInverseEpipolarLeftGrid()); TGridImage * rightGrid = const_cast(this->GetDirectEpipolarRightGrid()); leftGrid->SetRequestedRegionToLargestPossibleRegion(); rightGrid->SetRequestedRegionToLargestPossibleRegion(); leftGrid->UpdateOutputData(); rightGrid->UpdateOutputData(); TSensorImage * leftIn = const_cast(this->GetLeftSensorImageInput()); RegionType emptyRegion = leftIn->GetLargestPossibleRegion(); emptyRegion.SetSize(0,0); emptyRegion.SetSize(1,0); leftIn->SetRequestedRegion(emptyRegion); TDisparityImage * horizOut = this->GetHorizontalDisparityMapOutput(); TDisparityImage * horizIn = const_cast(this->GetHorizontalDisparityMapInput()); TDisparityImage * vertiIn = const_cast(this->GetVerticalDisparityMapInput()); TMaskImage * maskIn = const_cast(this->GetDisparityMaskInput()); RegionType requested = this->GetHorizontalDisparityMapOutput()->GetRequestedRegion(); RegionType inputlargest = this->GetHorizontalDisparityMapInput()->GetLargestPossibleRegion(); RegionType inputRequested; GridRegionType gridLargest = leftGrid->GetLargestPossibleRegion(); IndexType minIndex,maxIndex; // -Wmaybe-uninitialized typedef typename IndexType::IndexValueType IndexValueType; minIndex.Fill(itk::NumericTraits::Zero); maxIndex.Fill(itk::NumericTraits::Zero); IndexType corners[4]; for(int i = 0; i < 4; i++) corners[i].Fill(itk::NumericTraits::Zero); corners[0] = requested.GetIndex(); corners[1] = requested.GetIndex(); corners[1][0] += static_cast(requested.GetSize()[0]) - 1; corners[2] = requested.GetIndex(); corners[2][1] += static_cast(requested.GetSize()[1]) - 1; corners[3] = requested.GetIndex(); corners[3][0] += static_cast(requested.GetSize()[0]) - 1; corners[3][1] += static_cast(requested.GetSize()[1]) - 1; for (unsigned int k=0; k<4; ++k) { PointType pointSensor; horizOut->TransformIndexToPhysicalPoint(corners[k],pointSensor); itk::ContinuousIndex indexGrid; leftGrid->TransformPhysicalPointToContinuousIndex(pointSensor,indexGrid); IndexType ul; ul[0] = static_cast(vcl_floor(indexGrid[0])); ul[1] = static_cast(vcl_floor(indexGrid[1])); if (ul[0] < gridLargest.GetIndex()[0]) ul[0] = gridLargest.GetIndex()[0]; if (ul[1] < gridLargest.GetIndex()[1]) ul[1] = gridLargest.GetIndex()[1]; if (ul[0] > static_cast(gridLargest.GetIndex()[0] + gridLargest.GetSize()[0]-2)) ul[0] = (gridLargest.GetIndex()[0] + gridLargest.GetSize()[0]-2); if (ul[1] > static_cast(gridLargest.GetIndex()[1] + gridLargest.GetSize()[1]-2)) ul[1] = (gridLargest.GetIndex()[1] + gridLargest.GetSize()[1]-2); IndexType ur = ul; ur[0] += 1; IndexType ll = ul; ll[1] += 1; IndexType lr = ul; lr[0] += 1; lr[1] += 1; double rx = indexGrid[0] - static_cast(ul[0]); double ry = indexGrid[1] - static_cast(ul[1]); PointType pointEpi = pointSensor; pointEpi[0] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[0] + rx * leftGrid->GetPixel(ur)[0]) + ry * ((1. - rx) * leftGrid->GetPixel(ll)[0] + rx * leftGrid->GetPixel(lr)[0]); pointEpi[1] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[1] + rx * leftGrid->GetPixel(ur)[1]) + ry * ((1. - rx) * leftGrid->GetPixel(ll)[1] + rx * leftGrid->GetPixel(lr)[1]); itk::ContinuousIndex indexEpi; horizIn->TransformPhysicalPointToContinuousIndex(pointEpi,indexEpi); if (k == 0) { minIndex[0] = static_cast(vcl_floor(indexEpi[0])); minIndex[1] = static_cast(vcl_floor(indexEpi[1])); maxIndex[0] = static_cast(vcl_ceil(indexEpi[0])); maxIndex[1] = static_cast(vcl_ceil(indexEpi[1])); } else { if (minIndex[0]>static_cast(vcl_floor(indexEpi[0]))) minIndex[0]=static_cast(vcl_floor(indexEpi[0])); if (minIndex[1]>static_cast(vcl_floor(indexEpi[1]))) minIndex[1]=static_cast(vcl_floor(indexEpi[1])); if (maxIndex[0](vcl_ceil(indexEpi[0]))) maxIndex[0]=static_cast(vcl_ceil(indexEpi[0])); if (maxIndex[1](vcl_ceil(indexEpi[1]))) maxIndex[1]=static_cast(vcl_ceil(indexEpi[1])); } } inputRequested.SetIndex(minIndex); inputRequested.SetSize(0,static_cast(maxIndex[0]-minIndex[0])); inputRequested.SetSize(1,static_cast(maxIndex[1]-minIndex[1])); if (!inputRequested.Crop(inputlargest)) { inputRequested.SetSize(0,0); inputRequested.SetSize(1,0); inputRequested.SetIndex(inputlargest.GetIndex()); } horizIn->SetRequestedRegion(inputRequested); if (vertiIn) vertiIn->SetRequestedRegion(inputRequested); if (maskIn) maskIn->SetRequestedRegion(inputRequested); } template void DisparityTranslateFilter ::ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { const TGridImage * leftGrid = this->GetInverseEpipolarLeftGrid(); const TGridImage * rightGrid = this->GetDirectEpipolarRightGrid(); TDisparityImage * horizOut = this->GetHorizontalDisparityMapOutput(); TDisparityImage * vertiOut = this->GetVerticalDisparityMapOutput(); const TDisparityImage * horizIn = this->GetHorizontalDisparityMapInput(); const TDisparityImage * vertiIn = this->GetVerticalDisparityMapInput(); const TMaskImage * maskIn = this->GetDisparityMaskInput(); GridRegionType leftLargest = leftGrid->GetLargestPossibleRegion(); GridRegionType rightLargest = rightGrid->GetLargestPossibleRegion(); RegionType buffered = horizIn->GetBufferedRegion(); const bool emptyInputRegion=buffered.GetNumberOfPixels() == 0; typedef itk::ImageRegionIteratorWithIndex DispIterator; DispIterator horizIter(horizOut, outputRegionForThread); DispIterator vertiIter(vertiOut, outputRegionForThread); horizIter.GoToBegin(); vertiIter.GoToBegin(); while (!horizIter.IsAtEnd() && !vertiIter.IsAtEnd()) { if(!emptyInputRegion) { PointType pointSensor; horizOut->TransformIndexToPhysicalPoint(horizIter.GetIndex(), pointSensor); itk::ContinuousIndex indexGrid; leftGrid->TransformPhysicalPointToContinuousIndex(pointSensor, indexGrid); // Interpolate in left grid typedef typename IndexType::IndexValueType IndexValueType; IndexType ul; ul[0] = static_cast (vcl_floor(indexGrid[0])); ul[1] = static_cast (vcl_floor(indexGrid[1])); if (ul[0] < leftLargest.GetIndex()[0]) ul[0] = leftLargest.GetIndex()[0]; if (ul[1] < leftLargest.GetIndex()[1]) ul[1] = leftLargest.GetIndex()[1]; if (ul[0] > static_cast(leftLargest.GetIndex()[0] + leftLargest.GetSize()[0] - 2)) ul[0] = (leftLargest.GetIndex()[0] + leftLargest.GetSize()[0] - 2); if (ul[1] > static_cast(leftLargest.GetIndex()[1] + leftLargest.GetSize()[1] - 2)) ul[1] = (leftLargest.GetIndex()[1] + leftLargest.GetSize()[1] - 2); IndexType ur = ul; ur[0] += 1; IndexType ll = ul; ll[1] += 1; IndexType lr = ul; lr[0] += 1; lr[1] += 1; double rx = indexGrid[0] - static_cast (ul[0]); double ry = indexGrid[1] - static_cast (ul[1]); PointType pointEpi = pointSensor; pointEpi[0] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[0] + rx * leftGrid->GetPixel(ur)[0]) + ry * ((1. - rx) * leftGrid->GetPixel(ll)[0] + rx * leftGrid->GetPixel(lr)[0]); pointEpi[1] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[1] + rx * leftGrid->GetPixel(ur)[1]) + ry * ((1. - rx) * leftGrid->GetPixel(ll)[1] + rx * leftGrid->GetPixel(lr)[1]); itk::ContinuousIndex indexEpi; horizIn->TransformPhysicalPointToContinuousIndex(pointEpi, indexEpi); // Interpolate in disparity map ul[0] = static_cast (vcl_floor(indexEpi[0])); ul[1] = static_cast (vcl_floor(indexEpi[1])); if (ul[0] < buffered.GetIndex()[0]) ul[0] = buffered.GetIndex()[0]; if (ul[1] < buffered.GetIndex()[1]) ul[1] = buffered.GetIndex()[1]; if (ul[0] > static_cast(buffered.GetIndex()[0] + buffered.GetSize()[0] - 2)) ul[0] = (buffered.GetIndex()[0] + buffered.GetSize()[0] - 2); if (ul[1] > static_cast(buffered.GetIndex()[1] + buffered.GetSize()[1] - 2)) ul[1] = (buffered.GetIndex()[1] + buffered.GetSize()[1] - 2); ur = ul; ur[0] += 1; ll = ul; ll[1] += 1; lr = ul; lr[0] += 1; lr[1] += 1; // check if all corners are valid if (!maskIn || (maskIn && maskIn->GetPixel(ul) > 0 && maskIn->GetPixel(ur) > 0 && maskIn->GetPixel(ll) > 0 && maskIn->GetPixel(lr) > 0)) { rx = indexEpi[0] - static_cast (ul[0]); ry = indexEpi[1] - static_cast (ul[1]); itk::ContinuousIndex indexRight(indexEpi); indexRight[0] += (1. - ry) * ((1. - rx) * horizIn->GetPixel(ul) + rx * horizIn->GetPixel(ur)) + ry * ((1. - rx) * horizIn->GetPixel(ll) + rx * horizIn->GetPixel(lr)); if (vertiIn) { indexRight[1] += (1. - ry) * ((1. - rx) * vertiIn->GetPixel(ul) + rx * vertiIn->GetPixel(ur)) + ry * ((1. - rx) * vertiIn->GetPixel(ll) + rx * vertiIn->GetPixel(lr)); } PointType pointRight; horizIn->TransformContinuousIndexToPhysicalPoint(indexRight, pointRight); itk::ContinuousIndex indexGridRight; rightGrid->TransformPhysicalPointToContinuousIndex(pointRight, indexGridRight); // Interpolate in right grid ul[0] = static_cast (vcl_floor(indexGridRight[0])); ul[1] = static_cast (vcl_floor(indexGridRight[1])); if (ul[0] < rightLargest.GetIndex()[0]) ul[0] = rightLargest.GetIndex()[0]; if (ul[1] < rightLargest.GetIndex()[1]) ul[1] = rightLargest.GetIndex()[1]; if (ul[0] > static_cast(rightLargest.GetIndex()[0] + rightLargest.GetSize()[0] - 2)) ul[0] = (rightLargest.GetIndex()[0] + rightLargest.GetSize()[0] - 2); if (ul[1] > static_cast(rightLargest.GetIndex()[1] + rightLargest.GetSize()[1] - 2)) ul[1] = (rightLargest.GetIndex()[1] + rightLargest.GetSize()[1] - 2); ur = ul; ur[0] += 1; ll = ul; ll[1] += 1; lr = ul; lr[0] += 1; lr[1] += 1; rx = indexGridRight[0] - static_cast (ul[0]); ry = indexGridRight[1] - static_cast (ul[1]); PointType pointSensorRight = pointRight; pointSensorRight[0] += (1. - ry) * ((1. - rx) * rightGrid->GetPixel(ul)[0] + rx * rightGrid->GetPixel(ur)[0]) + ry * ((1. - rx) * rightGrid->GetPixel(ll)[0] + rx * rightGrid->GetPixel(lr)[0]); pointSensorRight[1] += (1. - ry) * ((1. - rx) * rightGrid->GetPixel(ul)[1] + rx * rightGrid->GetPixel(ur)[1]) + ry * ((1. - rx) * rightGrid->GetPixel(ll)[1] + rx * rightGrid->GetPixel(lr)[1]); horizIter.Set(pointSensorRight[0] - pointSensor[0]); vertiIter.Set(pointSensorRight[1] - pointSensor[1]); } else { horizIter.Set(m_NoDataValue); vertiIter.Set(m_NoDataValue); } } else { horizIter.Set(m_NoDataValue); vertiIter.Set(m_NoDataValue); } ++horizIter; ++vertiIter; } } } #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbFineRegistrationImageFilter.h000066400000000000000000000233311301006202600317760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFineRegistrationImageFilter_h #define otbFineRegistrationImageFilter_h #include "itkImageToImageFilter.h" #include "itkInterpolateImageFunction.h" #include "itkContinuousIndex.h" #include "itkTranslationTransform.h" #include "itkImageToImageMetric.h" namespace otb { /** \class FineRegistrationImageFilter * \brief Computes a displacement field between two images using a given metric. * * This filter tries to find at each location of the fixed image the corresponding best matching * patch of radius set by SetRadius() method in the moving image within a search windows whose radius * is defined by SetSearchRadius() method. * * To do so, it optimizes a metric set using the SetMetric() method, which accepts any itk metric * deriving from the itk::ImageToImageMetric. The MinimizeOn()/MinimizeOff() flag allows searching for * minimum or maximum depending on the metric (default is On). * * Once a coarse (pixel wise) offset has been found, this match is further refined using golden section search search * until convergence accuracy (given by the SetConvergenceAccuracy()) is reached, or when the max number of iteration () is reached. * * The filter proposes two outputs: GetOutput() return the image of the metric optimum at each location, and * the GetOutputDisplacementField() method returns the corresponding offset. * * If the UseSpacingOn() flag is used, the output displacement field takes the input image spacing into account. * otherwise, the displacement field is expressed in pixels (default ins On). * * This filter accepts fixed and moving images with different sizes and spacing. Metric and search windows radius * are expressed in terms of number of pixels in the fixed image. * * An initial offset can be used to reduce computation time in case of input and moving images with a significant * offset. This offset is taken into account in the output displacement field. * * It is possible to generate an output metric map and displacement field at a coarser resolution by setting * grid step to value higher than 1 (grid step is expressed in terms of number of fixed image pixels). * Default value is 1. * * The FineRegistrationImageFilter allows using the full range of itk::ImageToImageMetric provided by itk. * * \example DisparityMap/FineRegistrationImageFilterExample.cxx * * \sa FastCorrelationImageFilter, DisparityMapEstimationMethod * \ingroup IntensityImageFilters, Streamed * * \ingroup OTBDisparityMap */ template class ITK_EXPORT FineRegistrationImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef FineRegistrationImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(FineRegistrationImageFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef typename T0utputCorrelation::RegionType OutputImageRegionType; typedef typename TOutputDisplacementField::PixelType DisplacementValueType; typedef typename TInputImage::Pointer InputImagePointerType; typedef typename TInputImage::RegionType InputImageRegionType; typedef typename TInputImage::SizeType SizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::SpacingType SpacingType; typedef typename TInputImage::PointType PointType; typedef typename TInputImage::OffsetType OffsetType; typedef itk::InterpolateImageFunction InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointerType; typedef itk::ContinuousIndex ContinuousIndexType; typedef itk::ImageToImageMetric MetricType; typedef typename MetricType::Pointer MetricPointerType; typedef itk::TranslationTransform TranslationType; typedef typename TranslationType::Pointer TranslationPointerType; typedef typename itk::Transform TransformType; typedef typename TransformType::Pointer TransformPointerType; /** Set/Get the Metric used to compare images */ itkSetObjectMacro(Metric, MetricType); itkGetObjectMacro(Metric, MetricType); /** Set/Get the interpolator used to interpolate moving image at non-grid positions */ itkSetObjectMacro(Interpolator, InterpolatorType); itkGetObjectMacro(Interpolator, InterpolatorType); /** Connect one of the operands for pixel-wise addition */ void SetFixedInput( const TInputImage * image); /** Connect one of the operands for pixel-wise addition */ void SetMovingInput( const TInputImage * image); /** Get the inputs */ const TInputImage * GetFixedInput(); const TInputImage * GetMovingInput(); /** Get the output displacement field */ TOutputDisplacementField * GetOutputDisplacementField(); /** Set the radius of the area on which metric is evaluated */ itkSetMacro(Radius, SizeType); itkGetMacro(Radius, SizeType); /** Set the searh radius */ itkSetMacro(SearchRadius, SizeType); itkGetMacro(SearchRadius, SizeType); /** Set/Get convergence accuracy */ itkSetMacro(ConvergenceAccuracy, double); itkGetMacro(ConvergenceAccuracy, double); /** Set/Get subpixel accuracy */ itkSetMacro(SubPixelAccuracy, double); itkGetMacro(SubPixelAccuracy, double); /** Set/Get max number of iterations */ itkSetMacro(MaxIter, int); itkGetMacro(MaxIter, int); /** True if metric should be minimized. False otherwise */ itkSetMacro(Minimize, bool); itkBooleanMacro(Minimize); /** True if displacement field takes spacing into account. False otherwise */ itkSetMacro(UseSpacing, bool); itkBooleanMacro(UseSpacing); /** Set default offset between the two images */ itkSetMacro(InitialOffset, SpacingType); itkGetConstReferenceMacro(InitialOffset, SpacingType); /** Set the grid step */ itkSetMacro(GridStep, OffsetType); itkGetConstReferenceMacro(GridStep, OffsetType); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } /** Set unsigned int radius */ void SetSearchRadius(unsigned int radius) { m_SearchRadius.Fill(radius); } /** Set unsigned int grid step */ void SetGridStep(unsigned int step) { m_GridStep.Fill(step); } /** Set/Get the transform for the initial offset */ itkSetObjectMacro(Transform, TransformType); itkGetConstObjectMacro(Transform, TransformType); protected: /** Constructor */ FineRegistrationImageFilter(); /** Destructor */ ~FineRegistrationImageFilter() ITK_OVERRIDE {}; /** Threaded generate data */ void GenerateData() ITK_OVERRIDE; /** Generate the input requested regions */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; private: FineRegistrationImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented inline double callMetric(double val1,double val2,double &oldRes,bool &flag); inline void updateOptParams(double potBestVal,double parx,double pary, //inputs double &bestVal, typename TranslationType::ParametersType& optParams); //outputs inline void updatePoints(double& gn, double& in1, double& in2, double &in3, //inputs double& out1, double& out2, double& out3, double& out4); //outputs inline void updateMinimize(double& a, double& b); /** The radius for correlation */ SizeType m_Radius; /** The search radius */ SizeType m_SearchRadius; /** Minimize/maximize metric */ bool m_Minimize; /** If true, displacement field uses spacing. Otherwise, uses pixel grid */ bool m_UseSpacing; /** Search step */ double m_ConvergenceAccuracy; double m_SubPixelAccuracy; /** Max number of iterations */ int m_MaxIter; /** The interpolator */ InterpolatorPointerType m_Interpolator; /** The metric */ MetricPointerType m_Metric; /** The translation */ TranslationPointerType m_Translation; /** Default offset */ SpacingType m_InitialOffset; /** Grid step */ OffsetType m_GridStep; /** Transform for initial offset */ TransformPointerType m_Transform; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbFineRegistrationImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbFineRegistrationImageFilter.txx000066400000000000000000000445561301006202600324060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbFineRegistrationImageFilter_txx #define otbFineRegistrationImageFilter_txx #include "otbFineRegistrationImageFilter.h" #include "itkProgressReporter.h" #include "itkLinearInterpolateImageFunction.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkNormalizedCorrelationImageToImageMetric.h" #include "itkMacro.h" namespace otb { /** * Constructor */ template FineRegistrationImageFilter ::FineRegistrationImageFilter() { this->SetNumberOfRequiredInputs( 2 ); this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(1, TOutputDisplacementField::New()); // Default radius m_Radius.Fill(2); m_SearchRadius.Fill(4); // Default sub-pixel precision m_SubPixelAccuracy = 0.1; m_ConvergenceAccuracy = 0.01; // Max number of iterations m_MaxIter = 100; // Flags m_UseSpacing = true; m_Minimize = true; // Default currentMetric m_Metric = itk::NormalizedCorrelationImageToImageMetric ::New(); // Default interpolator m_Interpolator = itk::LinearInterpolateImageFunction::New(); // Translation m_Translation = TranslationType::New(); // Grid Step m_GridStep.Fill(1); // Default offset m_InitialOffset.Fill(0); m_Transform = ITK_NULLPTR; } template void FineRegistrationImageFilter ::SetFixedInput( const TInputImage * image ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( image )); } template void FineRegistrationImageFilter ::SetMovingInput( const TInputImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( image )); } template const TInputImage * FineRegistrationImageFilter ::GetFixedInput() { if (this->GetNumberOfInputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TInputImage * FineRegistrationImageFilter ::GetMovingInput() { if (this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template TOutputDisplacementField * FineRegistrationImageFilter ::GetOutputDisplacementField() { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void FineRegistrationImageFilter ::GenerateOutputInformation() { // Call superclass implementation Superclass::GenerateOutputInformation(); // Retrieve output pointers TOutputCorrelation * outputPtr = this->GetOutput(); TOutputDisplacementField *outputFieldPtr = this->GetOutputDisplacementField(); // Update size and spacing according to grid step InputImageRegionType largestRegion = outputPtr->GetLargestPossibleRegion(); SizeType outputSize = largestRegion.GetSize(); SpacingType outputSpacing = outputPtr->GetSpacing(); for(unsigned int dim = 0; dim < TOutputCorrelation::ImageDimension; ++dim) { outputSize[dim] /= m_GridStep[dim]; outputSpacing[dim] *= m_GridStep[dim]; } // Set spacing outputPtr->SetSpacing(outputSpacing); outputFieldPtr->SetSpacing(outputSpacing); // Set largest region size largestRegion.SetSize(outputSize); outputPtr->SetLargestPossibleRegion(largestRegion); outputFieldPtr->SetLargestPossibleRegion(largestRegion); } template void FineRegistrationImageFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output TInputImage * fixedPtr = const_cast< TInputImage * >( this->GetFixedInput()); TInputImage * movingPtr = const_cast< TInputImage * >( this->GetMovingInput()); TOutputCorrelation * outputPtr = this->GetOutput(); if ( !fixedPtr || !movingPtr || !outputPtr ) { return; } // get a copy of the fixed requested region (should equal the output // requested region) InputImageRegionType fixedRequestedRegion, movingRequestedRegion; fixedRequestedRegion = outputPtr->GetRequestedRegion(); // Apply grid step SizeType fixedRequestedSize = fixedRequestedRegion.GetSize(); IndexType fixedRequestedIndex = fixedRequestedRegion.GetIndex(); for(unsigned int dim = 0; dim < TOutputCorrelation::ImageDimension; ++dim) { fixedRequestedSize [dim] *= m_GridStep[dim]; fixedRequestedIndex[dim] *= m_GridStep[dim]; } fixedRequestedRegion.SetSize(fixedRequestedSize); fixedRequestedRegion.SetIndex(fixedRequestedIndex); // pad the input requested region by the operator radius fixedRequestedRegion.PadByRadius( m_Radius ); // get a copy of the moving requested region (should equal the output // requested region) InputImageRegionType searchFixedRequestedRegion = fixedRequestedRegion; searchFixedRequestedRegion.PadByRadius(m_SearchRadius); // Find corners of the search window IndexType ulIndex = searchFixedRequestedRegion.GetIndex(); IndexType lrIndex; for(unsigned int dim = 0; dim < TInputImage::ImageDimension; ++dim) { lrIndex[dim]= searchFixedRequestedRegion.GetIndex()[dim] + searchFixedRequestedRegion.GetSize()[dim]-1; } // Transform to physical space PointType ulPoint, lrPoint; fixedPtr->TransformIndexToPhysicalPoint(lrIndex, lrPoint); fixedPtr->TransformIndexToPhysicalPoint(ulIndex, ulPoint); // Apply default offset lrPoint += m_InitialOffset; ulPoint += m_InitialOffset; // Transform back into moving region index space IndexType movingIndex1, movingIndex2, movingIndex; movingPtr->TransformPhysicalPointToIndex(ulPoint, movingIndex1); movingPtr->TransformPhysicalPointToIndex(lrPoint, movingIndex2); // Find requested region SizeType movingSize; for(unsigned int dim = 0; dim < TInputImage::ImageDimension; ++dim) { movingIndex[dim] = std::min(movingIndex1[dim], movingIndex2[dim]); movingSize[dim] = std::max(movingIndex1[dim], movingIndex2[dim]) - movingIndex[dim] + 1; } movingRequestedRegion.SetIndex(movingIndex); movingRequestedRegion.SetSize(movingSize); // crop the fixed region at the fixed's largest possible region if ( fixedRequestedRegion.Crop(fixedPtr->GetLargestPossibleRegion())) { fixedPtr->SetRequestedRegion( fixedRequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) fixedPtr->SetRequestedRegion( fixedRequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(fixedPtr); throw e; } // crop the moving region at the moving's largest possible region if ( movingRequestedRegion.Crop(movingPtr->GetLargestPossibleRegion())) { movingPtr->SetRequestedRegion( movingRequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). This case might happen so we do not throw any exception but // request a null region instead movingSize.Fill(0); movingRequestedRegion.SetSize(movingSize); movingIndex.Fill(0); movingRequestedRegion.SetIndex(movingIndex); // store what we tried to request (prior to trying to crop) movingPtr->SetRequestedRegion(movingRequestedRegion); } return; } template double FineRegistrationImageFilter ::callMetric(double val1,double val2,double &oldRes,bool &flag) { typename TranslationType::ParametersType paramsgn(2); paramsgn[0]=val1; paramsgn[1]=val2; double res=oldRes; flag=false; try { res=m_Metric->GetValue(paramsgn); } catch(itk::ExceptionObject& err) { flag=true; itkWarningMacro(<< err.GetDescription()); } return res; } template void FineRegistrationImageFilter ::updateOptParams(double potBestVal,double parx,double pary,double &bestVal, typename TranslationType::ParametersType& optParams) { if (bestVal>potBestVal) { bestVal=potBestVal; optParams[0]=parx; optParams[1]=pary; } } template void FineRegistrationImageFilter ::updatePoints(double& gn, double& in1, double& in2, double &in3, double& out1, double& out2, double& out3, double& out4) { out1=out2; out2=in3; out3=in1+gn*(in2-in1); out4=in2-gn*(in2-in1); } template void FineRegistrationImageFilter ::updateMinimize(double& a, double& b) { if(!m_Minimize) { a = -a; b = -b; } } template void FineRegistrationImageFilter ::GenerateData() { // Allocate outputs this->AllocateOutputs(); // Get the image pointers const TInputImage * fixedPtr = this->GetFixedInput(); const TInputImage * movingPtr = this->GetMovingInput(); TOutputCorrelation * outputPtr = this->GetOutput(); TOutputDisplacementField * outputDfPtr = this->GetOutputDisplacementField(); // Wire currentMetric m_Interpolator->SetInputImage(this->GetMovingInput()); m_Metric->SetTransform(m_Translation); m_Metric->SetInterpolator(m_Interpolator); m_Metric->SetFixedImage(fixedPtr); m_Metric->SetMovingImage(movingPtr); m_Metric->SetComputeGradient(false); /** Output iterators */ itk::ImageRegionIteratorWithIndex outputIt(outputPtr, outputPtr->GetRequestedRegion()); itk::ImageRegionIterator outputDfIt(outputDfPtr, outputPtr->GetRequestedRegion()); outputIt.GoToBegin(); outputDfIt.GoToBegin(); // support progress methods/callbacks itk::ProgressReporter progress(this, 0, outputPtr->GetRequestedRegion().GetNumberOfPixels()); // GoToBegin outputIt.GoToBegin(); outputDfIt.GoToBegin(); // Correl, max correl, maxPosition double currentMetric, optMetric; // Optimal translation parameters typename TranslationType::ParametersType params(2), optParams(2); // Final displacement value DisplacementValueType displacementValue; displacementValue[0] = m_InitialOffset[0]; displacementValue[1] = m_InitialOffset[1]; // Local initial offset: enable the possibility of a different initial offset for each pixel SpacingType localOffset = m_InitialOffset; // Get fixed image spacing SpacingType fixedSpacing = fixedPtr->GetSpacing(); // Walk the images while (!outputIt.IsAtEnd() && !outputDfIt.IsAtEnd() ) { // Reset if(m_Minimize) { optMetric = itk::NumericTraits::max(); } else { optMetric = itk::NumericTraits::NonpositiveMin(); } optParams.Fill(0); // Build the region on which to compute the currentMetric InputImageRegionType currentMetricRegion; // Apply grid step IndexType currentIndex = outputIt.GetIndex(); for(unsigned int dim = 0; dim < TInputImage::ImageDimension; ++dim) { currentIndex[dim] *= m_GridStep[dim]; } currentMetricRegion.SetIndex(currentIndex); SizeType size; size.Fill(1); currentMetricRegion.SetSize(size); currentMetricRegion.PadByRadius(m_Radius); currentMetricRegion.Crop(fixedPtr->GetLargestPossibleRegion()); m_Metric->SetFixedImageRegion(currentMetricRegion); m_Metric->Initialize(); // Compute the local offset if required (and the transform was specified) if (m_Transform.IsNotNull()) { PointType inputPoint, outputPoint; for(unsigned int dim = 0; dim < TInputImage::ImageDimension; ++dim) { inputPoint[dim] = currentIndex[dim]; } outputPoint = m_Transform->TransformPoint(inputPoint); for(unsigned int dim = 0; dim < TInputImage::ImageDimension; ++dim) { localOffset[dim] = outputPoint[dim] - inputPoint[dim]; //FIXME check the direction } } // Compute the correlation at each location for(int i = -static_cast(m_SearchRadius[0]); i <= static_cast(m_SearchRadius[0]); ++i) { for(int j = -static_cast(m_SearchRadius[1]); j <= static_cast(m_SearchRadius[1]); ++j) { params[0] = localOffset[0] + static_cast(i*fixedSpacing[0]); params[1] = localOffset[1] + static_cast(j*fixedSpacing[1]); try { // compute currentMetric currentMetric = m_Metric->GetValue(params); // Check for maximum if((m_Minimize && (currentMetric < optMetric)) || (!m_Minimize && (currentMetric > optMetric))) { optMetric = currentMetric; optParams = params; } } catch(itk::ExceptionObject& err) { itkWarningMacro(<(subPixelSpacing[0]); double ay=optParams[1]-static_cast(subPixelSpacing[1]); double bx=optParams[0]+static_cast(subPixelSpacing[0]); double by=optParams[1]+static_cast(subPixelSpacing[1]); double cx=bx-gn*(bx-ax); double cy=optParams[1];//by-gn*(by-ay); double dx=ax+gn*(bx-ax); double dy=optParams[1];//ay+gn*(by-ay); double fc=0,fd=0; bool exitWhile=false; int nbIter=0; double bestvalold=itk::NumericTraits::max(),bestval=optMetric; double diff=itk::NumericTraits::max(); double diffx=itk::NumericTraits::max(); double diffy=itk::NumericTraits::max(); //init fc=callMetric(cx,cy,fc,exitWhile); fd=callMetric(dx,dy,fd,exitWhile); updateMinimize(fc,fd); //loop while ( (diffx > m_SubPixelAccuracy || diffy > m_SubPixelAccuracy) && (diff>m_ConvergenceAccuracy) && (!exitWhile) && (nbIter<=m_MaxIter)) { nbIter++; // x direction if (fc, class TMaskImage = otb::Image, class TResidueImage = otb::Image > class ITK_EXPORT MultiDisparityMapTo3DFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef MultiDisparityMapTo3DFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(MultiDisparityMapTo3DFilter, ImageToImageFilter); /** Useful typedefs */ typedef TDisparityImage DisparityMapType; typedef TOutputImage OutputImageType; typedef TMaskImage MaskImageType; typedef TResidueImage ResidueImageType; typedef typename OutputImageType::RegionType RegionType; typedef typename OutputImageType::PixelType DEMPixelType; // 3D RS transform // TODO: Allow tuning precision (i.e. double or float) typedef double PrecisionType; typedef otb::GenericRSTransform RSTransformType; // 3D points typedef typename RSTransformType::InputPointType TDPointType; typedef otb::LineOfSightOptimizer OptimizerType; typedef typename OptimizerType::PointSetType PointSetType; typedef typename PointSetType::PointsContainer PointsContainer; typedef typename PointSetType::PointDataContainer LabelContainer; typedef otb::ImageKeywordlist ImageKeywordListType; typedef std::map > DispMapIteratorList; typedef std::map > MaskIteratorList; /** Set the number of moving images (referred earlier as N) */ void SetNumberOfMovingImages(unsigned int nb); /** Get the number of moving images (referred earlier as N) */ unsigned int GetNumberOfMovingImages(); /** Set horizontal disparity map input corresponding to the moving image 'index' */ void SetHorizontalDisparityMapInput(unsigned int index, const TDisparityImage * hmap); /** Set vertical disparity map input corresponding to the moving image 'index'*/ void SetVerticalDisparityMapInput(unsigned int index, const TDisparityImage * vmap); /** Set mask associated to disparity maps corresponding to the moving image 'index' * (optional, pixels with a null mask value are ignored) */ void SetDisparityMaskInput(unsigned int index, const TMaskImage * mask); /** Get the inputs */ const TDisparityImage * GetHorizontalDisparityMapInput(unsigned int index) const; const TDisparityImage * GetVerticalDisparityMapInput(unsigned int index) const; const TMaskImage * GetDisparityMaskInput(unsigned int index) const; /** Get residue output*/ const TResidueImage * GetResidueOutput() const; TResidueImage * GetResidueOutput(); /** Set keywordlist of the reference image */ void SetReferenceKeywordList(const ImageKeywordListType kwl) { this->m_ReferenceKeywordList = kwl; this->Modified(); } /** Get keywordlist of the reference image */ const ImageKeywordListType & GetReferenceKeywordList() const { return this->m_ReferenceKeywordList; } /** Set keywordlist of the moving image 'index' */ void SetMovingKeywordList(unsigned int index, const ImageKeywordListType kwl); /** Get keywordlist of the moving image 'index' */ const ImageKeywordListType & GetMovingKeywordList(unsigned int index) const; protected: /** Constructor */ MultiDisparityMapTo3DFilter(); /** Destructor */ ~MultiDisparityMapTo3DFilter() ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: MultiDisparityMapTo3DFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Keywordlist of reference sensor image */ ImageKeywordListType m_ReferenceKeywordList; /** Keywordlists of moving sensor images */ std::vector m_MovingKeywordLists; /** Reference sensor image transform */ RSTransformType::Pointer m_ReferenceToGroundTransform; /** Moving sensor image transforms */ std::vector m_MovingToGroundTransform; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMultiDisparityMapTo3DFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbMultiDisparityMapTo3DFilter.txx000066400000000000000000000372531301006202600322760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiDisparityMapTo3DFilter_txx #define otbMultiDisparityMapTo3DFilter_txx #include "otbMultiDisparityMapTo3DFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" namespace otb { template MultiDisparityMapTo3DFilter ::MultiDisparityMapTo3DFilter() { // Set the number of inputs (1 moving image by default -> 3 inputs) this->SetNumberOfRequiredInputs(3); this->SetNumberOfRequiredInputs(1); this->m_MovingKeywordLists.resize(1); // Set the outputs this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0,TOutputImage::New()); this->SetNthOutput(1,TResidueImage::New()); } template MultiDisparityMapTo3DFilter ::~MultiDisparityMapTo3DFilter() {} template void MultiDisparityMapTo3DFilter ::SetNumberOfMovingImages(unsigned int nb) { if (nb > 0) { this->SetNumberOfRequiredInputs(3 * nb); this->m_MovingKeywordLists.resize(nb); } } template unsigned int MultiDisparityMapTo3DFilter ::GetNumberOfMovingImages() { return this->m_MovingKeywordLists.size(); } template void MultiDisparityMapTo3DFilter ::SetHorizontalDisparityMapInput(unsigned int index, const TDisparityImage * hmap) { if ((3 * (index + 1)) > this->GetNumberOfRequiredInputs()) { itkExceptionMacro(<<"Index is greater than the number of moving images"); } // Process object is not const-correct so the const casting is required. this->SetNthInput(3 * index, const_cast( hmap )); } template void MultiDisparityMapTo3DFilter ::SetVerticalDisparityMapInput(unsigned int index, const TDisparityImage * vmap) { if ((3 * (index + 1)) > this->GetNumberOfRequiredInputs()) { itkExceptionMacro(<<"Index is greater than the number of moving images"); } // Process object is not const-correct so the const casting is required. this->SetNthInput(3 * index + 1, const_cast( vmap )); } template void MultiDisparityMapTo3DFilter ::SetDisparityMaskInput(unsigned int index, const TMaskImage * mask) { if ((3 * (index + 1)) > this->GetNumberOfRequiredInputs()) { itkExceptionMacro(<<"Index is greater than the number of moving images"); } // Process object is not const-correct so the const casting is required. this->SetNthInput(3 * index + 2, const_cast( mask )); } template const TDisparityImage * MultiDisparityMapTo3DFilter ::GetHorizontalDisparityMapInput(unsigned int index) const { if ((3 * (index + 1)) > this->GetNumberOfRequiredInputs()) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3 * index)); } template const TDisparityImage * MultiDisparityMapTo3DFilter ::GetVerticalDisparityMapInput(unsigned int index) const { if ((3 * (index + 1)) > this->GetNumberOfRequiredInputs()) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3 * index + 1)); } template const TMaskImage * MultiDisparityMapTo3DFilter ::GetDisparityMaskInput(unsigned int index) const { if ((3 * (index + 1)) > this->GetNumberOfRequiredInputs()) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3 * index + 2)); } template const TResidueImage * MultiDisparityMapTo3DFilter ::GetResidueOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template TResidueImage * MultiDisparityMapTo3DFilter ::GetResidueOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void MultiDisparityMapTo3DFilter ::SetMovingKeywordList(unsigned int index, const ImageKeywordListType kwl) { if (this->m_MovingKeywordLists.size() > index) { this->m_MovingKeywordLists[index] = kwl; } } template const typename MultiDisparityMapTo3DFilter::ImageKeywordListType & MultiDisparityMapTo3DFilter ::GetMovingKeywordList(unsigned int index) const { if (this->m_MovingKeywordLists.size() <= index) { itkExceptionMacro(<<"Keywordlist index is outside the container"); } return this->m_MovingKeywordLists[index]; } template void MultiDisparityMapTo3DFilter ::GenerateOutputInformation() { const TDisparityImage * horizDisp = this->GetHorizontalDisparityMapInput(0); TOutputImage * outputPtr = this->GetOutput(); TResidueImage * residuePtr = this->GetResidueOutput(); if (horizDisp) { outputPtr->SetLargestPossibleRegion(horizDisp->GetLargestPossibleRegion()); outputPtr->SetNumberOfComponentsPerPixel(3); residuePtr->SetLargestPossibleRegion(horizDisp->GetLargestPossibleRegion()); residuePtr->SetNumberOfComponentsPerPixel(1); // copy also origin and spacing outputPtr->SetOrigin(horizDisp->GetOrigin()); outputPtr->SetSpacing(horizDisp->GetSpacing()); residuePtr->SetOrigin(horizDisp->GetOrigin()); residuePtr->SetSpacing(horizDisp->GetSpacing()); if (this->m_ReferenceKeywordList.GetSize() > 0) { itk::EncapsulateMetaData (outputPtr->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, this->m_ReferenceKeywordList); itk::EncapsulateMetaData (residuePtr->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, this->m_ReferenceKeywordList); } else { itkExceptionMacro(<<"Reference keywordlist is missing"); } } else { itkExceptionMacro(<< "First horizontal disparity map is missing"); } } template void MultiDisparityMapTo3DFilter ::GenerateInputRequestedRegion() { RegionType requested = this->GetOutput()->GetRequestedRegion(); RegionType largest = this->GetHorizontalDisparityMapInput(0)->GetLargestPossibleRegion(); for (unsigned int i=0; iGetNumberOfRequiredInputs(); ++i) { unsigned int index = i % 3; unsigned int pos = i / 3; switch (index) { case 0: { // check horizontal disparity maps TDisparityImage * horizDisp = const_cast(this->GetHorizontalDisparityMapInput(pos)); if (horizDisp) { if (horizDisp->GetLargestPossibleRegion() != largest) { itkExceptionMacro(<<"Horizontal disparity map at position "<SetRequestedRegion(requested); } else { itkExceptionMacro(<<"Horizontal disparity map at position "<(this->GetVerticalDisparityMapInput(pos)); if (vertiDisp) { if (vertiDisp->GetLargestPossibleRegion() != largest) { itkExceptionMacro(<<"Vertical disparity map at position "<SetRequestedRegion(requested); } } break; case 2: { // check disparity masks TMaskImage * maskDisp = const_cast(this->GetDisparityMaskInput(pos)); if (maskDisp) { if (maskDisp->GetLargestPossibleRegion() != largest) { itkExceptionMacro(<<"Disparity mask at position "<SetRequestedRegion(requested); } } break; default: itkExceptionMacro(<< "Unexpected value for (i%3) "); } } // Check moving keywordlist for (unsigned int k=0; km_MovingKeywordLists.size(); ++k) { if (this->m_MovingKeywordLists[k].GetSize() == 0) { itkExceptionMacro(<< "Keywordlist of moving image at position "< void MultiDisparityMapTo3DFilter ::BeforeThreadedGenerateData() { // Instantiate all transforms this->m_ReferenceToGroundTransform = RSTransformType::New(); this->m_ReferenceToGroundTransform->SetInputKeywordList(this->m_ReferenceKeywordList); this->m_ReferenceToGroundTransform->InstantiateTransform(); this->m_MovingToGroundTransform.clear(); for (unsigned int k=0; km_MovingKeywordLists.size(); ++k) { RSTransformType::Pointer transfo = RSTransformType::New(); transfo->SetInputKeywordList(this->m_MovingKeywordLists[k]); transfo->InstantiateTransform(); this->m_MovingToGroundTransform.push_back(transfo); } } template void MultiDisparityMapTo3DFilter ::ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { TOutputImage * outputPtr = this->GetOutput(); TResidueImage * residuePtr = this->GetResidueOutput(); itk::ImageRegionIteratorWithIndex outIt(outputPtr,outputRegionForThread); itk::ImageRegionIterator resIt(residuePtr,outputRegionForThread); typename OptimizerType::Pointer optimizer = OptimizerType::New(); DispMapIteratorList hDispIts; DispMapIteratorList vDispIts; MaskIteratorList maskIts; for (unsigned int k=0; km_MovingKeywordLists.size(); ++k) { // Iterators over horizontal disparity maps hDispIts[k] = itk::ImageRegionConstIterator(this->GetHorizontalDisparityMapInput(k),outputRegionForThread); hDispIts[k].GoToBegin(); // Iterators over vertical disparity maps if (this->GetVerticalDisparityMapInput(k)) { vDispIts[k] = itk::ImageRegionConstIterator(this->GetVerticalDisparityMapInput(k),outputRegionForThread); vDispIts[k].GoToBegin(); } // Iterators over disparity masks if (this->GetDisparityMaskInput(k)) { maskIts[k] = itk::ImageRegionConstIterator(this->GetDisparityMaskInput(k),outputRegionForThread); maskIts[k].GoToBegin(); } } outIt.GoToBegin(); resIt.GoToBegin(); PrecisionType altiMin = 0; PrecisionType altiMax = 500; typename OutputImageType::PointType pointRef; TDPointType currentPoint; typename OutputImageType::PixelType outPixel(3); PrecisionType globalResidue; typename PointSetType::Pointer pointSetA = PointSetType::New(); typename PointSetType::Pointer pointSetB = PointSetType::New(); while (!outIt.IsAtEnd()) { pointSetA->Initialize(); pointSetB->Initialize(); // Compute reference line of sight TDPointType pointA, pointB; outputPtr->TransformIndexToPhysicalPoint(outIt.GetIndex(), pointRef); currentPoint[0] = pointRef[0]; currentPoint[1] = pointRef[1]; currentPoint[2] = altiMax; pointA = this->m_ReferenceToGroundTransform->TransformPoint(currentPoint); currentPoint[2] = altiMin; pointB = this->m_ReferenceToGroundTransform->TransformPoint(currentPoint); pointSetA->SetPoint(0, pointA); pointSetB->SetPoint(0, pointB); pointSetA->SetPointData(0,0); pointSetB->SetPointData(0,0); unsigned int nbPoints = 1; for (unsigned int k=0; km_MovingKeywordLists.size(); ++k) { // Compute the N moving lines of sight TDPointType pointAi, pointBi; if (maskIts.count(k) && !(maskIts[k].Get() > 0)) { continue; } currentPoint[0] = pointRef[0] + hDispIts[k].Get(); currentPoint[1] = pointRef[1]; if (vDispIts.count(k)) { currentPoint[1] += vDispIts[k].Get(); } currentPoint[2] = altiMax; pointAi = this->m_MovingToGroundTransform[k]->TransformPoint(currentPoint); currentPoint[2] = altiMin; pointBi = this->m_MovingToGroundTransform[k]->TransformPoint(currentPoint); pointSetA->SetPoint(nbPoints, pointAi); pointSetB->SetPoint(nbPoints, pointBi); pointSetA->SetPointData(nbPoints,k+1); pointSetB->SetPointData(nbPoints,k+1); ++nbPoints; } // Check if there are at least 2 lines of sight, then compute intersection if (nbPoints >= 2) { TDPointType intersection = optimizer->Compute(pointSetA,pointSetB); outPixel[0] = intersection[0]; outPixel[1] = intersection[1]; outPixel[2] = intersection[2]; globalResidue = optimizer->GetGlobalResidue(); } else { outPixel.Fill(0); globalResidue = 0; } outIt.Set(outPixel); resIt.Set(globalResidue); // Increment all iterators for (typename DispMapIteratorList::iterator hIt = hDispIts.begin(); hIt != hDispIts.end(); ++hIt) { ++hIt->second; } for (typename DispMapIteratorList::iterator vIt = vDispIts.begin(); vIt != vDispIts.end(); ++vIt) { ++vIt->second; } for (typename MaskIteratorList::iterator mIt = maskIts.begin(); mIt != maskIts.end(); ++mIt) { ++mIt->second; } ++outIt; ++resIt; } } } #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbNCCRegistrationFilter.h000066400000000000000000000123241301006202600305550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNCCRegistrationFilter_h #define otbNCCRegistrationFilter_h #include "itkPDEDeformableRegistrationFilter.h" #include "otbNCCRegistrationFunction.h" namespace otb { /** \class NCCRegistrationFilter * \brief Deformably register two images using the PDEs and NCC. * * NCCRegistrationFilter implements the ####### * register two images by computing the displacement field which will map a * moving image onto a fixed image. * * A displacement field is represented as a image whose pixel type is some * vector type with at least N elements, where N is the dimension of * the fixed image. The vector type must support element access via operator * []. It is assumed that the vector elements behave like floating point * scalars. * * This class is templated over the fixed image type, moving image type * and the displacement field type. * * The input fixed and moving images are set via methods SetFixedImage * and SetMovingImage respectively. An initial displacement field maybe set via * SetInitialDisplacementField or SetInput. If no initial field is set, * a zero field is used as the initial condition. * * The algorithm has one parameter: the number of iteration to be performed. * * The output displacement field can be obtained via methods GetOutput * or GetDisplacementField. * * This class make use of the finite difference solver hierarchy. Update * for each iteration is computed in NCCRegistrationFunction. * * \warning This filter assumes that the fixed image type, moving image type * and displacement field type all have the same number of dimensions. * * \sa NCCRegistrationFunction * \ingroup DeformableImageRegistration MultiThreaded * * \example DisparityMap/NCCRegistrationFilterExample.cxx * * * * \ingroup OTBDisparityMap */ template class ITK_EXPORT NCCRegistrationFilter : public itk::PDEDeformableRegistrationFilter { public: /** Standard class typedefs. */ typedef NCCRegistrationFilter Self; typedef itk::PDEDeformableRegistrationFilter< TFixedImage, TMovingImage, TDisplacementField> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(NCCRegistrationFilter, itk::PDEDeformableRegistrationFilter); /** Inherit types from superclass. */ typedef typename Superclass::TimeStepType TimeStepType; /** FixedImage image type. */ typedef typename Superclass::FixedImageType FixedImageType; typedef typename Superclass::FixedImagePointer FixedImagePointer; /** MovingImage image type. */ typedef typename Superclass::MovingImageType MovingImageType; typedef typename Superclass::MovingImagePointer MovingImagePointer; /** Displacement field type. */ typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldPointer DisplacementFieldPointer; /** FiniteDifferenceFunction type. */ typedef typename Superclass::FiniteDifferenceFunctionType FiniteDifferenceFunctionType; /** NCCRegistrationFilterFunction type. */ typedef NCCRegistrationFunction NCCRegistrationFunctionType; typedef typename NCCRegistrationFunctionType::RadiusType RadiusType; /** Get the metric value. The metric value is computed over the the * overlapping region between the two images. This is value is only * available for the previous iteration and NOT the current * iteration. *\return metric **/ virtual double GetMetric() const; /** * Set the NCC radius * \param radius */ virtual void SetNCCRadius(RadiusType radius); /** * Get the radius. * \return radius. **/ virtual RadiusType GetNCCRadius() const; protected: NCCRegistrationFilter(); ~NCCRegistrationFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Initialize the state of filter and equation before each iteration. */ void InitializeIteration() ITK_OVERRIDE; /** Apply update. */ using Superclass::ApplyUpdate; virtual void ApplyUpdate(TimeStepType dt); /** Update the Input requested region. */ void GenerateInputRequestedRegion() ITK_OVERRIDE; private: NCCRegistrationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNCCRegistrationFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbNCCRegistrationFilter.txx000066400000000000000000000160401301006202600311500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNCCRegistrationFilter_txx #define otbNCCRegistrationFilter_txx #include "otbNCCRegistrationFilter.h" namespace otb { /* * Default constructor */ template NCCRegistrationFilter ::NCCRegistrationFilter() { typename NCCRegistrationFunctionType::Pointer drfp; drfp = NCCRegistrationFunctionType::New(); drfp->SetDisplacementField(this->GetDisplacementField()); this->SetDifferenceFunction(static_cast( drfp.GetPointer())); } template void NCCRegistrationFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "NCC Radius: " << this->GetNCCRadius() << std::endl; } /* * Set the function state values before each iteration */ template void NCCRegistrationFilter ::InitializeIteration() { // call the superclass implementation Superclass::InitializeIteration(); // set the gradient selection flag NCCRegistrationFunctionType *drfp = dynamic_cast (this->GetDifferenceFunction().GetPointer()); if (!drfp) { itkExceptionMacro(<< "Could not cast difference function to NCCRegistrationFunction"); } /* * Smooth the displacement field if ( this->GetSmoothDisplacementField() ) { this->SmoothDisplacementField(); } */ } /* * Get the metric value from the difference function */ template double NCCRegistrationFilter ::GetMetric() const { NCCRegistrationFunctionType *drfp = dynamic_cast (this->GetDifferenceFunction().GetPointer()); if (!drfp) { itkExceptionMacro(<< "Could not cast difference function to NCCRegistrationFunction"); } return drfp->GetEnergy(); } /* * */ template typename NCCRegistrationFilter::RadiusType NCCRegistrationFilter ::GetNCCRadius() const { NCCRegistrationFunctionType *drfp = dynamic_cast (this->GetDifferenceFunction().GetPointer()); if (!drfp) { itkExceptionMacro(<< "Could not cast difference function to NCCRegistrationFunction"); } return drfp->GetRadius(); } /* * */ template void NCCRegistrationFilter ::SetNCCRadius(RadiusType radius) { NCCRegistrationFunctionType *drfp = dynamic_cast (this->GetDifferenceFunction().GetPointer()); if (!drfp) { itkExceptionMacro(<< "Could not cast difference function to NCCRegistrationFunction"); } drfp->SetRadius(radius); this->Modified(); } template void NCCRegistrationFilter ::GenerateInputRequestedRegion() { // get pointers to the input and output typename Superclass::FixedImagePointer fixedPtr = const_cast(this->GetFixedImage()); typename Superclass::MovingImagePointer movingPtr = const_cast(this->GetMovingImage()); typename TDisplacementField::Pointer outputPtr = this->GetOutput(); if (!fixedPtr || !movingPtr || !outputPtr) { return; } // get a copy of the input requested region (should equal the output // requested region) typename TDisplacementField::RegionType requestedRegion; requestedRegion = outputPtr->GetRequestedRegion(); // pad the input requested region by the operator radius requestedRegion.PadByRadius(this->GetNCCRadius()); // crop the input requested region at the input's largest possible region if (requestedRegion.Crop(fixedPtr->GetLargestPossibleRegion())) { if (requestedRegion.Crop(movingPtr->GetLargestPossibleRegion())) { fixedPtr->SetRequestedRegion(requestedRegion); movingPtr->SetRequestedRegion(requestedRegion); return; } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) movingPtr->SetRequestedRegion(requestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription( "Requested region is (at least partially) outside the largest possible region of the moving image."); e.SetDataObject(movingPtr); throw e; } } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) fixedPtr->SetRequestedRegion(requestedRegion); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); e.SetLocation(ITK_LOCATION); e.SetDescription("Requested region is (at least partially) outside the largest possible region of the fixed image."); e.SetDataObject(fixedPtr); throw e; } } /* * Get the metric value from the difference function */ template void NCCRegistrationFilter ::ApplyUpdate(TimeStepType dt) { // If we smooth the update buffer before applying it, then the are // approximating a viscuous problem as opposed to an elastic problem /* if ( this->GetSmoothUpdateField() ) { this->SmoothUpdateField(); } */ this->Superclass::ApplyUpdate(dt); NCCRegistrationFunctionType *drfp = dynamic_cast (this->GetDifferenceFunction().GetPointer()); if (!drfp) { itkExceptionMacro(<< "Could not cast difference function to NCCRegistrationFunction"); } // this->SetRMSChange( drfp->GetRMSChange() ); } } // end namespace otb #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbNCCRegistrationFunction.h000066400000000000000000000155301301006202600311170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNCCRegistrationFunction_h #define otbNCCRegistrationFunction_h #include "itkPDEDeformableRegistrationFunction.h" #include "itkPoint.h" #include "itkLinearInterpolateImageFunction.h" #include "itkCentralDifferenceImageFunction.h" namespace otb { /** * \class NCCRegistrationFunction * * This class has been copied from its itk version to provide a quick fix of itk bug #8288. * It is intended to be removed once the bug has been corrected in ITK. * * For more information, please refer to the ITK original class. * * \todo Check if the bug has been corrected in the next ITK version. * * \sa itk::NCCRegistrationFunction * \ingroup FiniteDifferenceFunctions * * \ingroup OTBDisparityMap */ template class ITK_EXPORT NCCRegistrationFunction : public itk::PDEDeformableRegistrationFunction { public: /** Standard class typedefs. */ typedef NCCRegistrationFunction Self; typedef itk::PDEDeformableRegistrationFunction Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(NCCRegistrationFunction, PDEDeformableRegistrationFunction); /** MovingImage image type. */ typedef typename Superclass::MovingImageType MovingImageType; typedef typename Superclass::MovingImagePointer MovingImagePointer; /** FixedImage image type. */ typedef typename Superclass::FixedImageType FixedImageType; typedef typename Superclass::FixedImagePointer FixedImagePointer; typedef typename FixedImageType::IndexType IndexType; typedef typename FixedImageType::SizeType SizeType; typedef typename FixedImageType::SpacingType SpacingType; /** Displacement field type. */ typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldTypePointer DisplacementFieldTypePointer; /** Inherit some enums from the superclass. */ itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension); /** Inherit some enums from the superclass. */ typedef typename Superclass::PixelType PixelType; typedef typename Superclass::RadiusType RadiusType; typedef typename Superclass::NeighborhoodType NeighborhoodType; // typedef typename Superclass::NeighborhoodType BoundaryNeighborhoodType; typedef typename Superclass::FloatOffsetType FloatOffsetType; typedef typename Superclass::TimeStepType TimeStepType; /** Interpolator type. */ typedef double CoordRepType; typedef itk::InterpolateImageFunction InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointer; typedef typename InterpolatorType::PointType PointType; typedef itk::LinearInterpolateImageFunction DefaultInterpolatorType; /** Covariant vector type. */ typedef itk::CovariantVector CovariantVectorType; /** Gradient calculator type. */ typedef itk::CentralDifferenceImageFunction GradientCalculatorType; typedef typename GradientCalculatorType::Pointer GradientCalculatorPointer; /** Set the moving image interpolator. */ void SetMovingImageInterpolator(InterpolatorType * ptr) { m_MovingImageInterpolator = ptr; } /** Get the moving image interpolator. */ InterpolatorType * GetMovingImageInterpolator(void) { return m_MovingImageInterpolator; } /** This class uses a constant timestep of 1. */ TimeStepType ComputeGlobalTimeStep(void * itkNotUsed(GlobalData)) const ITK_OVERRIDE { return m_TimeStep; } /** Return a pointer to a global data structure that is passed to * this object from the solver at each calculation. */ void *GetGlobalDataPointer() const ITK_OVERRIDE { GlobalDataStruct *global = new GlobalDataStruct(); return global; } /** Release memory for global data structure. */ void ReleaseGlobalDataPointer(void *GlobalData) const ITK_OVERRIDE { delete (GlobalDataStruct *) GlobalData; } /** Set the object's state before each iteration. */ void InitializeIteration() ITK_OVERRIDE; /** This method is called by a finite difference solver image filter at * each pixel that does not lie on a data set boundary */ PixelType ComputeUpdate(const NeighborhoodType& neighborhood, void *globalData, const FloatOffsetType& offset = FloatOffsetType(0.0)) ITK_OVERRIDE; protected: NCCRegistrationFunction(); ~NCCRegistrationFunction() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** FixedImage image neighborhood iterator type. */ typedef itk::ConstNeighborhoodIterator FixedImageNeighborhoodIteratorType; /** A global data type for this class of equation. Used to store * iterators for the fixed image. */ struct GlobalDataStruct { FixedImageNeighborhoodIteratorType m_FixedImageIterator; }; private: NCCRegistrationFunction(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Cache fixed image information. */ SpacingType m_FixedImageSpacing; PointType m_FixedImageOrigin; /** Function to compute derivatives of the fixed image. */ GradientCalculatorPointer m_FixedImageGradientCalculator; /** Function to interpolate the moving image. */ InterpolatorPointer m_MovingImageInterpolator; /** The global timestep. */ TimeStepType m_TimeStep; /** Threshold below which the denominator term is considered zero. */ double m_DenominatorThreshold; /** Threshold below which two intensity value are assumed to match. */ double m_IntensityDifferenceThreshold; mutable double m_MetricTotal; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNCCRegistrationFunction.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbNCCRegistrationFunction.txx000066400000000000000000000170341301006202600315140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNCCRegistrationFunction_txx #define otbNCCRegistrationFunction_txx #include "vnl/vnl_math.h" #include "itkNeighborhoodIterator.h" #include "otbMacro.h" #include "otbNCCRegistrationFunction.h" namespace otb { /* * Default constructor */ template NCCRegistrationFunction ::NCCRegistrationFunction() { RadiusType r; unsigned int j; for (j = 0; j < ImageDimension; ++j) { r[j] = 1; } this->SetRadius(r); m_MetricTotal = 0.0; m_TimeStep = 1.0; m_DenominatorThreshold = 1e-9; m_IntensityDifferenceThreshold = 0.001; this->SetMovingImage(ITK_NULLPTR); this->SetFixedImage(ITK_NULLPTR); m_FixedImageSpacing.Fill(1.0); m_FixedImageOrigin.Fill(0.0); m_FixedImageGradientCalculator = GradientCalculatorType::New(); typename DefaultInterpolatorType::Pointer interp = DefaultInterpolatorType::New(); m_MovingImageInterpolator = static_cast( interp.GetPointer()); } /* * Standard "PrintSelf" method. */ template void NCCRegistrationFunction ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); /* os << indent << "MovingImageIterpolator: "; os << m_MovingImageInterpolator.GetPointer() << std::endl; os << indent << "FixedImageGradientCalculator: "; os << m_FixedImageGradientCalculator.GetPointer() << std::endl; os << indent << "DenominatorThreshold: "; os << m_DenominatorThreshold << std::endl; os << indent << "IntensityDifferenceThreshold: "; os << m_IntensityDifferenceThreshold << std::endl; */ } /* * Set the function state values before each iteration */ template void NCCRegistrationFunction ::InitializeIteration() { if (!this->m_MovingImage || !this->m_FixedImage || !m_MovingImageInterpolator) { itkExceptionMacro(<< "MovingImage, FixedImage and/or Interpolator not set"); } // cache fixed image information m_FixedImageSpacing = this->m_FixedImage->GetSpacing(); m_FixedImageOrigin = this->m_FixedImage->GetOrigin(); // setup gradient calculator m_FixedImageGradientCalculator->SetInputImage(this->m_FixedImage); // setup moving image interpolator m_MovingImageInterpolator->SetInputImage(this->m_MovingImage); otbMsgDevMacro( " total metric " << m_MetricTotal << " field size " << this->GetDisplacementField()->GetLargestPossibleRegion().GetSize() << " image size " << this->m_FixedImage->GetLargestPossibleRegion().GetSize() ); m_MetricTotal = 0.0; } /* * Compute update at a non boundary neighbourhood */ template typename NCCRegistrationFunction ::PixelType NCCRegistrationFunction ::ComputeUpdate(const NeighborhoodType& it, void * itkNotUsed(globalData), const FloatOffsetType& itkNotUsed(offset)) { PixelType update; update.Fill(0.0); unsigned int j; IndexType oindex = it.GetIndex(); typename FixedImageType::SizeType hradius = it.GetRadius(); FixedImageType* img = const_cast(this->m_FixedImage.GetPointer()); typename FixedImageType::SizeType imagesize = img->GetLargestPossibleRegion().GetSize(); itk::NeighborhoodIterator hoodIt(hradius, img, img->GetRequestedRegion()); hoodIt.SetLocation(oindex); double sff = 0.0; double smm = 0.0; double sfm = 0.0; double fixedValue; double movingValue; double derivativeF[ImageDimension]; double derivativeM[ImageDimension]; for (j = 0; j < ImageDimension; ++j) { derivativeF[j] = 0; derivativeM[j] = 0; } unsigned int indct; unsigned int hoodlen = hoodIt.Size(); for (indct = 0; indct < hoodlen - 1; indct++) { IndexType index = hoodIt.GetIndex(indct); bool inimage = true; for (unsigned int dd = 0; dd < ImageDimension; dd++) { if (index[dd] < 0 || index[dd] > static_cast(imagesize[dd] - 1)) inimage = false; } if (inimage) { // Get fixed image related information CovariantVectorType fixedGradient; double fixedGradientSquaredMagnitude = 0; // Note: no need to check the index is within // fixed image buffer. This is done by the external filter. fixedValue = (double) this->m_FixedImage->GetPixel(index); fixedGradient = m_FixedImageGradientCalculator->EvaluateAtIndex(index); for (j = 0; j < ImageDimension; ++j) { fixedGradientSquaredMagnitude += vnl_math_sqr(fixedGradient[j]) * m_FixedImageSpacing[j]; } // Get moving image related information PointType mappedPoint; typedef typename TDisplacementField::PixelType DisplacementPixelType; // Edited by OTB developers DisplacementPixelType vec; vec.Fill(0); if (this->GetDisplacementField()->GetBufferedRegion().IsInside(index)) { vec = this->GetDisplacementField()->GetPixel(index); } // End Edited by OTB developers for (j = 0; j < ImageDimension; ++j) { mappedPoint[j] = double(index[j]) * m_FixedImageSpacing[j] + m_FixedImageOrigin[j]; mappedPoint[j] += vec[j]; } if (m_MovingImageInterpolator->IsInsideBuffer(mappedPoint)) { movingValue = m_MovingImageInterpolator->Evaluate(mappedPoint); } else { movingValue = 0.0; } sff += fixedValue * fixedValue; smm += movingValue * movingValue; sfm += fixedValue * movingValue; for (unsigned int dim = 0; dim < ImageDimension; ++dim) { double differential = fixedGradient[dim]; derivativeF[dim] += fixedValue * differential; derivativeM[dim] += movingValue * differential; } } } double updatenorm = 0.0; if ((sff * smm) != 0.0) { double factor = 1.0 / vcl_sqrt(sff * smm); for (unsigned int i = 0; i < ImageDimension; ++i) { update[i] = factor * (derivativeF[i] - (sfm / smm) * derivativeM[i]); updatenorm += (update[i] * update[i]); } updatenorm = vcl_sqrt(updatenorm); m_MetricTotal += sfm * factor; this->m_Energy += sfm * factor; } else { for (unsigned int i = 0; i < ImageDimension; ++i) { update[i] = 0.0; } updatenorm = 1.0; } // if ( fixedValue > 0.40 && movingValue > 0.40) std::cout << " update norm " << updatenorm; if (this->GetNormalizeGradient() && updatenorm != 0.0) { update /= (updatenorm); } return update * this->m_GradientStep; } } // end namespace otbs #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbPixelWiseBlockMatchingImageFilter.h000066400000000000000000000424431301006202600330660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPixelWiseBlockMatchingImageFilter_h #define otbPixelWiseBlockMatchingImageFilter_h #include "itkImageToImageFilter.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionIterator.h" #include "otbImage.h" namespace otb { namespace Functor { /** \class SSDBlockMatching * \brief Functor to perform simple SSD block-matching * * This functor is designed to work with the * PixelWiseBlockMatchingImageFilter. It performs a simple * SSD (Sum of Square Distances) block-matching. The functor is * templated by the type of inputs images and output metric image, * and is using two neighborhood iterators as inputs. * * \ingroup OTBDisparityMap */ template ITK_EXPORT class SSDBlockMatching { public: typedef itk::ConstNeighborhoodIterator ConstNeighborhoodIteratorType; typedef typename TOutputMetricImage::ValueType MetricValueType; // Implement the SSD operator inline MetricValueType operator()(ConstNeighborhoodIteratorType & a, ConstNeighborhoodIteratorType & b) const { MetricValueType ssd = 0; // For some reason, iterators do not work on neighborhoods for(unsigned int i = 0; i ITK_EXPORT class SSDDivMeanBlockMatching { public: typedef itk::ConstNeighborhoodIterator ConstNeighborhoodIteratorType; typedef typename TOutputMetricImage::ValueType MetricValueType; // Implement the SSD DivMean operator inline MetricValueType operator()(ConstNeighborhoodIteratorType & a, ConstNeighborhoodIteratorType & b) const { MetricValueType ssd = 0; MetricValueType meana = 0; MetricValueType meanb = 0; for(unsigned int i = 0; i ITK_EXPORT class NCCBlockMatching { public: typedef itk::ConstNeighborhoodIterator ConstNeighborhoodIteratorType; typedef typename TOutputMetricImage::ValueType MetricValueType; // Implement the NCC operator inline MetricValueType operator()(ConstNeighborhoodIteratorType & a, ConstNeighborhoodIteratorType & b) const { //MetricValueType meanA(0),meanB(0), sigmaA(0), sigmaB(0), cov(0), ncc(0); double meanA=0.0; double meanB=0.0; double sigmaA=0.0; double sigmaB=0.0; double cov=0.0; double ncc=0.0; double valueA; double valueB; double size=a.Size(); // For some reason, iterators do not work on neighborhoods for(unsigned int i = 0; i(a.GetPixel(i)); meanB+=static_cast(b.GetPixel(i)); } // Compute mean meanA/=size; meanB/=size; for(unsigned int i = 0; i(a.GetPixel(i)); valueB=static_cast(b.GetPixel(i)); cov+=(valueA-meanA)*(valueB-meanB); sigmaA+=(valueA-meanA)*(valueA-meanA); sigmaB+=(valueB-meanB)*(valueB-meanB); } cov/=size-1; sigmaA/=size-1; sigmaB/=size-1; sigmaA = vcl_sqrt(sigmaA); sigmaB = vcl_sqrt(sigmaB); if(sigmaA > 1e-20 && sigmaB > 1e-20) { ncc = vcl_abs(cov)/(sigmaA*sigmaB); } else { ncc = 0; } return static_cast(ncc); } }; /** \class LPBlockMatching * \brief Functor to perform block-matching based on the L^p pseudo-norm * * This functor is designed to work with the * PixelWiseBlockMatchingImageFilter. It performs a distance computation between * two windows based on the L^p pseudo norm (p greater than 0). The functor is * templated by the type of inputs images and output metric image, * and is using two neighborhood iterators as inputs. * * \ingroup OTBDisparityMap */ template ITK_EXPORT class LPBlockMatching { public: typedef itk::ConstNeighborhoodIterator ConstNeighborhoodIteratorType; typedef typename TOutputMetricImage::ValueType MetricValueType; LPBlockMatching(): m_P(1) { } void SetP(double p) { if (p > 0.0) { m_P = p; } else { m_P = 1.0; } } // Implement the Lp metric inline MetricValueType operator()(ConstNeighborhoodIteratorType & a, ConstNeighborhoodIteratorType & b) const { MetricValueType score(0); // For some reason, iterators do not work on neighborhoods for(unsigned int i = 0; i(a.GetPixel(i)-b.GetPixel(i))) , m_P); } return score; } private: double m_P; }; } // End Namespace Functor /** \class PixelWiseBlockMatchingImageFilter * \brief Perform 2D block matching between two images * * This filter performs pixel-wise 2D block-matching * between a pair of image. This is especially useful in the case of * stereo pairs in epipolar geometry, where displacements * corresponding to differences of elevation occur in the horizontal * direction only (in that case, the exploration along the vertical * direction can be disabled). Please note that only integer pixel * displacement are explored. For finer results, consider up-sampling * the input images or use the SubPixelDisparityImageFilter. * * The block-matching metric itself is defined by a template functor * on neighborhood iterators. A wide range of block-matching * criterions can be implemented this way, but the default functor * performs a simple SSD (Sum of Square Distances). The radius of the * blocks can be set using the SetRadius() method. The filter will * try to minimize the metric value by default. Setting the minimize * flag to off using the MinimizeOff() method will make the filter * try to maximize the metric. * * Only a user defined area of disparities between the two images is * explored, which can be set by using the SetMinimumHorizontalDisparity() * , SetMinimumVerticalDisparity(), SetMaximumHorizontalDisparity() * and SetMaximumVerticalDisparity() methods. * * This filter has three outputs: the first is the metric image, * which contains the metric optimum value corresponding to the * estimated displacement. The second and last outputs are the * horizontal and vertical disparity maps, which can be retrieved * using the GetHorizontalDisparityOutput() and GetVerticalDisparityOutput() * methods. They contain the horizontal and vertical local displacement * between the two input images (displacement is given in pixels, from left * image to right image). * * Masks are not mandatory. A mask allows indicating pixels validity in * either left or right image. Left and right masks can be used independently. * If masks are used, only pixels whose mask values are strictly positive * will be considered for disparity matching. The other will exhibit a null * metric value and a disparity corresponding to the minimum allowed * disparity. * * The disparity exploration can also be reduced thanks to initial disparity * maps. The user can provide initial disparity estimate (using the same image * type and size as the output disparities), or global disparity values. Then * an exploration radius indicates the disparity range to be explored around * the initial estimate (global minimum and maximum values are still in use). * * \sa FineRegistrationImageFilter * \sa StereorectificationDisplacementFieldSource * \sa SubPixelDisparityImageFilter * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBDisparityMap */ template , class TBlockMatchingFunctor = Functor::SSDBlockMatching > class ITK_EXPORT PixelWiseBlockMatchingImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef PixelWiseBlockMatchingImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(PixelWiseBlockMatchingImageFilter, ImageToImageFilter); /** Useful typedefs */ typedef TInputImage InputImageType; typedef TOutputMetricImage OutputMetricImageType; typedef TOutputDisparityImage OutputDisparityImageType; typedef TMaskImage InputMaskImageType; typedef TBlockMatchingFunctor BlockMatchingFunctorType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SpacingType SpacingType; typedef typename InputImageType::PointType PointType; typedef typename TOutputMetricImage::ValueType MetricValueType; typedef typename OutputDisparityImageType::PixelType DisparityPixelType; typedef itk::ConstNeighborhoodIterator ConstNeighborhoodIteratorType; /** Set left input */ void SetLeftInput( const TInputImage * image); /** Set right input */ void SetRightInput( const TInputImage * image); /** Set mask input (optional) */ void SetLeftMaskInput(const TMaskImage * image); /** Set right mask input (optional) */ void SetRightMaskInput(const TMaskImage * image); /** Get the inputs */ const TInputImage * GetLeftInput() const; const TInputImage * GetRightInput() const; const TMaskImage * GetLeftMaskInput() const; const TMaskImage * GetRightMaskInput() const; /** Get the metric output */ const TOutputMetricImage * GetMetricOutput() const; TOutputMetricImage * GetMetricOutput(); /** Get the disparity output */ const TOutputDisparityImage * GetHorizontalDisparityOutput() const; TOutputDisparityImage * GetHorizontalDisparityOutput(); /** Get the disparity output */ const TOutputDisparityImage * GetVerticalDisparityOutput() const; TOutputDisparityImage * GetVerticalDisparityOutput(); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } /** Set/Get the radius of the area on which metric is evaluated */ itkSetMacro(Radius, SizeType); itkGetConstReferenceMacro(Radius, SizeType); /*** Set/Get the minimum disparity to explore */ itkSetMacro(MinimumHorizontalDisparity,int); itkGetConstReferenceMacro(MinimumHorizontalDisparity,int); /*** Set/Get the maximum disparity to explore */ itkSetMacro(MaximumHorizontalDisparity,int); itkGetConstReferenceMacro(MaximumHorizontalDisparity,int); /*** Set/Get the minimum disparity to explore */ itkSetMacro(MinimumVerticalDisparity,int); itkGetConstReferenceMacro(MinimumVerticalDisparity,int); /*** Set/Get the maximum disparity to explore */ itkSetMacro(MaximumVerticalDisparity,int); itkGetConstReferenceMacro(MaximumVerticalDisparity,int); itkSetMacro(Minimize, bool); itkGetConstReferenceMacro(Minimize,bool); itkBooleanMacro(Minimize); /** Set/Get the exploration radius in the disparity space */ itkSetMacro(ExplorationRadius, SizeType); itkGetConstReferenceMacro(ExplorationRadius, SizeType); /** Set/Get the initial horizontal disparity */ itkSetMacro(InitHorizontalDisparity,int); itkGetConstReferenceMacro(InitHorizontalDisparity,int); /** Set/Get the initial vertical disparity */ itkSetMacro(InitVerticalDisparity,int); itkGetConstReferenceMacro(InitVerticalDisparity,int); /** Get the functor for parameters setting */ BlockMatchingFunctorType & GetFunctor() { return m_Functor; } /** Get the functor (const version) */ const BlockMatchingFunctorType & GetFunctor() const { return m_Functor; } /** Set initial horizontal disparity field (optional, ITK_OVERRIDE m_InitHorizontalDisparity) */ void SetHorizontalDisparityInput( const TOutputDisparityImage * hfield); /** Set initial vertical disparity field (optional, ITK_OVERRIDE m_InitVerticalDisparity) */ void SetVerticalDisparityInput( const TOutputDisparityImage * vfield); /** Get the initial disparity fields */ const TOutputDisparityImage * GetHorizontalDisparityInput() const; const TOutputDisparityImage * GetVerticalDisparityInput() const; /** Set/Get macro for the subsampling step */ itkSetMacro(Step, unsigned int); itkGetMacro(Step, unsigned int); /** Set/Get macro for the grid start index */ itkSetMacro(GridIndex, IndexType); itkGetConstReferenceMacro(GridIndex, IndexType); /** Conversion function between full and subsampled grid region */ static RegionType ConvertFullToSubsampledRegion(RegionType full, unsigned int step, IndexType index); /** Conversion function between subsampled and full grid region */ static RegionType ConvertSubsampledToFullRegion(RegionType sub, unsigned int step, IndexType index); protected: /** Constructor */ PixelWiseBlockMatchingImageFilter(); /** Destructor */ ~PixelWiseBlockMatchingImageFilter() ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: PixelWiseBlockMatchingImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemeFnted /** The radius of the blocks */ SizeType m_Radius; /** The min disparity to explore */ int m_MinimumHorizontalDisparity; /** The max disparity to explore */ int m_MaximumHorizontalDisparity; /** The min disparity to explore */ int m_MinimumVerticalDisparity; /** The max disparity to explore */ int m_MaximumVerticalDisparity; /** Should we minimize or maximize ? */ bool m_Minimize; /** The exploration radius for disparities (used if non null) */ SizeType m_ExplorationRadius; /** Block-matching functor */ BlockMatchingFunctorType m_Functor; /** Initial horizontal disparity (0 by default, used if an exploration radius is set and if no input horizontal disparity map is given) */ int m_InitHorizontalDisparity; /** Initial vertical disparity (0 by default, used if an exploration radius is set and if no input vertical disparity map is given) */ int m_InitVerticalDisparity; /** Computation step : disparities are computed on locations of a subsampled grid */ unsigned int m_Step; /** Starting index for the subsampled grid. The index is measured with respect to the input image grid * Each coordinate shall lie in [0, m_Step-1] */ IndexType m_GridIndex; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPixelWiseBlockMatchingImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbPixelWiseBlockMatchingImageFilter.txx000066400000000000000000000772611301006202600334700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPixelWiseBlockMatchingImageFilter_txx #define otbPixelWiseBlockMatchingImageFilter_txx #include "otbPixelWiseBlockMatchingImageFilter.h" #include "itkProgressReporter.h" #include "itkConstantBoundaryCondition.h" namespace otb { template PixelWiseBlockMatchingImageFilter ::PixelWiseBlockMatchingImageFilter() { // Set the number of inputs this->SetNumberOfRequiredInputs(6); this->SetNumberOfRequiredInputs(2); // Set the outputs this->SetNumberOfRequiredOutputs(3); this->SetNthOutput(0,TOutputMetricImage::New()); this->SetNthOutput(1,TOutputDisparityImage::New()); this->SetNthOutput(2,TOutputDisparityImage::New()); // Default parameters m_Radius.Fill(2); // Minimize by default m_Minimize = true; // Default disparity range m_MinimumHorizontalDisparity = -10; m_MaximumHorizontalDisparity = 10; m_MinimumVerticalDisparity = 0; m_MaximumVerticalDisparity = 0; // Default initial disparity m_InitHorizontalDisparity = 0; m_InitVerticalDisparity = 0; // Default exploration radius : 0 (not used) m_ExplorationRadius.Fill(0); // Default step m_Step = 1; // Default grid index m_GridIndex[0] = 0; m_GridIndex[1] = 0; } template PixelWiseBlockMatchingImageFilter ::~PixelWiseBlockMatchingImageFilter() {} template void PixelWiseBlockMatchingImageFilter ::SetLeftInput(const TInputImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( image )); } template void PixelWiseBlockMatchingImageFilter ::SetRightInput(const TInputImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( image )); } template void PixelWiseBlockMatchingImageFilter ::SetLeftMaskInput(const TMaskImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(2, const_cast( image )); } template void PixelWiseBlockMatchingImageFilter ::SetRightMaskInput(const TMaskImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(3, const_cast( image )); } template const TInputImage * PixelWiseBlockMatchingImageFilter ::GetLeftInput() const { if (this->GetNumberOfInputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TInputImage * PixelWiseBlockMatchingImageFilter ::GetRightInput() const { if(this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template const TMaskImage * PixelWiseBlockMatchingImageFilter ::GetLeftMaskInput() const { if(this->GetNumberOfInputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template const TMaskImage * PixelWiseBlockMatchingImageFilter ::GetRightMaskInput() const { if(this->GetNumberOfInputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3)); } template const TOutputMetricImage * PixelWiseBlockMatchingImageFilter ::GetMetricOutput() const { if (this->GetNumberOfOutputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template TOutputMetricImage * PixelWiseBlockMatchingImageFilter ::GetMetricOutput() { if (this->GetNumberOfOutputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template const TOutputDisparityImage * PixelWiseBlockMatchingImageFilter ::GetHorizontalDisparityOutput() const { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template TOutputDisparityImage * PixelWiseBlockMatchingImageFilter ::GetHorizontalDisparityOutput() { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const TOutputDisparityImage * PixelWiseBlockMatchingImageFilter ::GetVerticalDisparityOutput() const { if (this->GetNumberOfOutputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template TOutputDisparityImage * PixelWiseBlockMatchingImageFilter ::GetVerticalDisparityOutput() { if (this->GetNumberOfOutputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template void PixelWiseBlockMatchingImageFilter ::SetHorizontalDisparityInput( const TOutputDisparityImage * hfield) { // Process object is not const-correct so the const casting is required. this->SetNthInput(4, const_cast( hfield )); } template void PixelWiseBlockMatchingImageFilter ::SetVerticalDisparityInput( const TOutputDisparityImage * vfield) { // Process object is not const-correct so the const casting is required. this->SetNthInput(5, const_cast( vfield )); } template const TOutputDisparityImage * PixelWiseBlockMatchingImageFilter ::GetHorizontalDisparityInput() const { if(this->GetNumberOfInputs()<5) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(4)); } template const TOutputDisparityImage * PixelWiseBlockMatchingImageFilter ::GetVerticalDisparityInput() const { if(this->GetNumberOfInputs()<6) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(5)); } template void PixelWiseBlockMatchingImageFilter ::GenerateOutputInformation() { // Call superclass implementation Superclass::GenerateOutputInformation(); // Sanity check if (this->m_Step == 0) this->m_Step = 1; this->m_GridIndex[0] = this->m_GridIndex[0] % this->m_Step; this->m_GridIndex[1] = this->m_GridIndex[1] % this->m_Step; // Modify output size and index depending on the step const TInputImage * inLeftPtr = this->GetLeftInput(); RegionType outputLargest = this->ConvertFullToSubsampledRegion(inLeftPtr->GetLargestPossibleRegion(), this->m_Step, this->m_GridIndex); TOutputMetricImage * outMetricPtr = const_cast(this->GetMetricOutput()); TOutputDisparityImage * outHDispPtr = const_cast(this->GetHorizontalDisparityOutput()); TOutputDisparityImage * outVDispPtr = const_cast(this->GetVerticalDisparityOutput()); outMetricPtr->SetLargestPossibleRegion(outputLargest); outHDispPtr->SetLargestPossibleRegion(outputLargest); outVDispPtr->SetLargestPossibleRegion(outputLargest); // Adapt spacing SpacingType outSpacing = inLeftPtr->GetSpacing(); outSpacing[0] *= static_cast(this->m_Step); outSpacing[1] *= static_cast(this->m_Step); outMetricPtr->SetSpacing(outSpacing); outHDispPtr->SetSpacing(outSpacing); outVDispPtr->SetSpacing(outSpacing); // Adapt origin PointType outOrigin = inLeftPtr->GetOrigin(); SpacingType inSpacing = inLeftPtr->GetSpacing(); outOrigin[0] += inSpacing[0] * static_cast(this->m_GridIndex[0]); outOrigin[1] += inSpacing[1] * static_cast(this->m_GridIndex[1]); outMetricPtr->SetOrigin(outOrigin); outHDispPtr->SetOrigin(outOrigin); outVDispPtr->SetOrigin(outOrigin); } template void PixelWiseBlockMatchingImageFilter ::GenerateInputRequestedRegion() { // Call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve input pointers TInputImage * inLeftPtr = const_cast(this->GetLeftInput()); TInputImage * inRightPtr = const_cast(this->GetRightInput()); TMaskImage * inLeftMaskPtr = const_cast(this->GetLeftMaskInput()); TMaskImage * inRightMaskPtr = const_cast(this->GetRightMaskInput()); TOutputDisparityImage * inHDispPtr = const_cast(this->GetHorizontalDisparityInput()); TOutputDisparityImage * inVDispPtr = const_cast(this->GetVerticalDisparityInput()); TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TOutputDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TOutputDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); // Check pointers before using them if(!inLeftPtr || !inRightPtr || !outMetricPtr || !outHDispPtr || !outVDispPtr) { return; } // Now, we impose that both inputs have the same size if(inLeftPtr->GetLargestPossibleRegion() != inRightPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Left and right images do not have the same size ! Left largest region: "<GetLargestPossibleRegion()<<", right largest region: "<GetLargestPossibleRegion()); } // We also check that left mask image has same size if present if(inLeftMaskPtr && inLeftPtr->GetLargestPossibleRegion() != inLeftMaskPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Left and mask images do not have the same size ! Left largest region: "<GetLargestPossibleRegion()<<", mask largest region: "<GetLargestPossibleRegion()); } // We also check that right mask image has same size if present if(inRightMaskPtr && inRightPtr->GetLargestPossibleRegion() != inRightMaskPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Right and mask images do not have the same size ! Right largest region: "<GetLargestPossibleRegion()<<", mask largest region: "<GetLargestPossibleRegion()); } // We check that the input initial disparity maps have the same size if present if (inHDispPtr && inLeftPtr->GetLargestPossibleRegion() != inHDispPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Left image and initial horizontal disparity map do not have the same size ! Left largest region: "<GetLargestPossibleRegion()<<", horizontal disparity largest region: "<GetLargestPossibleRegion()); } if (inVDispPtr && inLeftPtr->GetLargestPossibleRegion() != inVDispPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Left image and initial vertical disparity map do not have the same size ! Left largest region: "<GetLargestPossibleRegion()<<", vertical disparity largest region: "<GetLargestPossibleRegion()); } // Sanity check if (this->m_Step == 0) this->m_Step = 1; this->m_GridIndex[0] = this->m_GridIndex[0] % this->m_Step; this->m_GridIndex[1] = this->m_GridIndex[1] % this->m_Step; // Retrieve requested region (TODO: check if we need to handle // region for outHDispPtr) RegionType inputLeftRegion = this->ConvertSubsampledToFullRegion(outMetricPtr->GetRequestedRegion(), this->m_Step, this->m_GridIndex); // Pad by the appropriate radius inputLeftRegion.PadByRadius(m_Radius); // Now, we must find the corresponding region in moving image IndexType rightRequestedRegionIndex = inputLeftRegion.GetIndex(); rightRequestedRegionIndex[0]+=m_MinimumHorizontalDisparity; rightRequestedRegionIndex[1]+=m_MinimumVerticalDisparity; SizeType rightRequestedRegionSize = inputLeftRegion.GetSize(); rightRequestedRegionSize[0]+= m_MaximumHorizontalDisparity - m_MinimumHorizontalDisparity; rightRequestedRegionSize[1]+= m_MaximumVerticalDisparity - m_MinimumVerticalDisparity; RegionType inputRightRegion; inputRightRegion.SetIndex(rightRequestedRegionIndex); inputRightRegion.SetSize(rightRequestedRegionSize); // crop the left region at the left's largest possible region if ( inputLeftRegion.Crop(inLeftPtr->GetLargestPossibleRegion())) { inLeftPtr->SetRequestedRegion( inputLeftRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inLeftPtr->SetRequestedRegion( inputLeftRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of left image."); e.SetDataObject(inLeftPtr); throw e; } // crop the right region at the right's largest possible region if ( inputRightRegion.Crop(inRightPtr->GetLargestPossibleRegion())) { inRightPtr->SetRequestedRegion( inputRightRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inRightPtr->SetRequestedRegion( inputRightRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of right image."); e.SetDataObject(inRightPtr); throw e; } if(inLeftMaskPtr) { // no need to crop the mask region : left mask and left image have same largest possible region inLeftMaskPtr->SetRequestedRegion( inputLeftRegion ); } if(inRightMaskPtr) { // no need to crop the mask region : right mask and right image have same largest possible region inRightMaskPtr->SetRequestedRegion( inputRightRegion ); } if (inHDispPtr && inVDispPtr) { inHDispPtr->SetRequestedRegion( inputLeftRegion ); inVDispPtr->SetRequestedRegion( inputLeftRegion ); } } template void PixelWiseBlockMatchingImageFilter ::BeforeThreadedGenerateData() { TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TOutputDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TOutputDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); // Sanity check if (this->m_Step == 0) this->m_Step = 1; this->m_GridIndex[0] = this->m_GridIndex[0] % this->m_Step; this->m_GridIndex[1] = this->m_GridIndex[1] % this->m_Step; // Fill buffers with default values outMetricPtr->FillBuffer(0.); outHDispPtr->FillBuffer(static_cast(m_MaximumHorizontalDisparity) / static_cast(m_Step)); outVDispPtr->FillBuffer(static_cast(m_MinimumVerticalDisparity) / static_cast(m_Step)); } template void PixelWiseBlockMatchingImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve pointers const TInputImage * inLeftPtr = this->GetLeftInput(); const TInputImage * inRightPtr = this->GetRightInput(); const TMaskImage * inLeftMaskPtr = this->GetLeftMaskInput(); const TMaskImage * inRightMaskPtr = this->GetRightMaskInput(); const TOutputDisparityImage * inHDispPtr = this->GetHorizontalDisparityInput(); const TOutputDisparityImage * inVDispPtr = this->GetVerticalDisparityInput(); TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TOutputDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TOutputDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); // Set-up progress reporting (this is not exact, since we do not // account for pixels that are out of range for a given disparity itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()*(m_MaximumHorizontalDisparity - m_MinimumHorizontalDisparity + 1)*(m_MaximumVerticalDisparity - m_MinimumVerticalDisparity + 1),100); // Handle initialization properly typename InputMaskImageType::Pointer initMaskPtr = InputMaskImageType::New(); initMaskPtr->SetRegions(outputRegionForThread); initMaskPtr->Allocate(); initMaskPtr->FillBuffer(0); // Compute region for thread at full resolution RegionType fullRegionForThread = this->ConvertSubsampledToFullRegion(outputRegionForThread, this->m_Step, this->m_GridIndex); // Check if we use initial disparities and exploration radius bool useExplorationRadius = false; bool useInitDispMaps = false; if (m_ExplorationRadius[0] >= 1 || m_ExplorationRadius[1] >= 1) { useExplorationRadius = true; if (inHDispPtr && inVDispPtr) { useInitDispMaps = true; } } // step value as disparityType DisparityPixelType stepDisparityInv = 1. / static_cast(this->m_Step); // We loop on disparities for(int vdisparity = m_MinimumVerticalDisparity; vdisparity <= m_MaximumVerticalDisparity; ++vdisparity) { for(int hdisparity = m_MinimumHorizontalDisparity; hdisparity <= m_MaximumHorizontalDisparity; ++hdisparity) { // First, we cast output region to the right image IndexType rightRequestedRegionIndex = fullRegionForThread.GetIndex(); rightRequestedRegionIndex[0]+=hdisparity; rightRequestedRegionIndex[1]+=vdisparity; // We crop RegionType inputRightRegion; inputRightRegion.SetIndex(rightRequestedRegionIndex); inputRightRegion.SetSize(fullRegionForThread.GetSize()); inputRightRegion.Crop(inRightPtr->GetLargestPossibleRegion()); // And then cast back IndexType leftRequestedRegionIndex = inputRightRegion.GetIndex(); leftRequestedRegionIndex[0]-=hdisparity; leftRequestedRegionIndex[1]-=vdisparity; RegionType inputLeftRegion; inputLeftRegion.SetIndex(leftRequestedRegionIndex); inputLeftRegion.SetSize(inputRightRegion.GetSize()); // Compute the equivalent region in subsampled grid RegionType outputRegion = this->ConvertFullToSubsampledRegion(inputLeftRegion, this->m_Step, this->m_GridIndex); // Define iterators itk::ConstNeighborhoodIterator leftIt(m_Radius,inLeftPtr,inputLeftRegion); itk::ConstNeighborhoodIterator rightIt(m_Radius,inRightPtr,inputRightRegion); itk::ImageRegionIterator outMetricIt(outMetricPtr,outputRegion); itk::ImageRegionIterator outHDispIt(outHDispPtr,outputRegion); itk::ImageRegionIterator outVDispIt(outVDispPtr,outputRegion); itk::ImageRegionConstIterator inLeftMaskIt; itk::ImageRegionConstIterator inRightMaskIt; itk::ImageRegionConstIterator inHDispIt; itk::ImageRegionConstIterator inVDispIt; itk::ImageRegionIterator initIt(initMaskPtr,outputRegion); itk::ConstantBoundaryCondition nbc1; itk::ConstantBoundaryCondition nbc2; leftIt.OverrideBoundaryCondition(&nbc1); rightIt.OverrideBoundaryCondition(&nbc2); // If we have a mask, define the iterator if(inLeftMaskPtr) { inLeftMaskIt = itk::ImageRegionConstIterator(inLeftMaskPtr,inputLeftRegion); inLeftMaskIt.GoToBegin(); } if(inRightMaskPtr) { inRightMaskIt = itk::ImageRegionConstIterator(inRightMaskPtr,inputRightRegion); inRightMaskIt.GoToBegin(); } // If we use initial disparity maps, define the iterators if (useInitDispMaps) { inHDispIt = itk::ImageRegionConstIterator(inHDispPtr,inputLeftRegion); inVDispIt = itk::ImageRegionConstIterator(inVDispPtr,inputLeftRegion); inHDispIt.GoToBegin(); inVDispIt.GoToBegin(); } // Initialize iterators leftIt.GoToBegin(); rightIt.GoToBegin(); outMetricIt.GoToBegin(); outHDispIt.GoToBegin(); outVDispIt.GoToBegin(); initIt.GoToBegin(); // Loop on pixels while(!leftIt.IsAtEnd() || !rightIt.IsAtEnd() || !outMetricIt.IsAtEnd() || !outHDispIt.IsAtEnd() || !outVDispIt.IsAtEnd() || !initIt.IsAtEnd()) { // If the pixel location is on the subsampled grid IndexType tmpIndex = leftIt.GetIndex(leftIt.GetCenterNeighborhoodIndex()); if (((tmpIndex[0] - this->m_GridIndex[0] + this->m_Step) % this->m_Step == 0) && ((tmpIndex[1] - this->m_GridIndex[1] + this->m_Step) % this->m_Step == 0)) { // If the mask is present and valid if(!inLeftMaskPtr || (inLeftMaskPtr && inLeftMaskIt.Get() > 0) ) { if(!inRightMaskPtr || (inRightMaskPtr && inRightMaskIt.Get() > 0) ) { int estimatedMinHDisp = m_MinimumHorizontalDisparity; int estimatedMinVDisp = m_MinimumVerticalDisparity; int estimatedMaxHDisp = m_MaximumHorizontalDisparity; int estimatedMaxVDisp = m_MaximumVerticalDisparity; if (useExplorationRadius) { // compute disparity bounds from initial position and exploration radius if (useInitDispMaps) { estimatedMinHDisp = inHDispIt.Get() - m_ExplorationRadius[0]; estimatedMinVDisp = inVDispIt.Get() - m_ExplorationRadius[1]; estimatedMaxHDisp = inHDispIt.Get() + m_ExplorationRadius[0]; estimatedMaxVDisp = inVDispIt.Get() + m_ExplorationRadius[1]; } else { estimatedMinHDisp = m_InitHorizontalDisparity - m_ExplorationRadius[0]; estimatedMinVDisp = m_InitVerticalDisparity - m_ExplorationRadius[1]; estimatedMaxHDisp = m_InitHorizontalDisparity + m_ExplorationRadius[0]; estimatedMaxVDisp = m_InitVerticalDisparity + m_ExplorationRadius[1]; } // clamp to the minimum disparities if (estimatedMinHDisp < m_MinimumHorizontalDisparity) { estimatedMinHDisp = m_MinimumHorizontalDisparity; } if (estimatedMinVDisp < m_MinimumVerticalDisparity) { estimatedMinVDisp = m_MinimumVerticalDisparity; } } if (vdisparity >= estimatedMinVDisp && vdisparity <= estimatedMaxVDisp && hdisparity >= estimatedMinHDisp && hdisparity <= estimatedMaxHDisp) { // Compute the block matching value double metric = m_Functor(leftIt,rightIt); // If we are at first loop, fill both outputs // We adapt the disparity value to keep consistent with disparity map index space if(initIt.Get()==0) { outHDispIt.Set(static_cast(hdisparity) * stepDisparityInv); outVDispIt.Set(static_cast(vdisparity) * stepDisparityInv); outMetricIt.Set(metric); initIt.Set(1); } else if(m_Minimize && metric < outMetricIt.Get()) { outHDispIt.Set(static_cast(hdisparity) * stepDisparityInv); outVDispIt.Set(static_cast(vdisparity) * stepDisparityInv); outMetricIt.Set(metric); } else if(!m_Minimize && metric > outMetricIt.Get()) { outHDispIt.Set(static_cast(hdisparity) * stepDisparityInv); outVDispIt.Set(static_cast(vdisparity) * stepDisparityInv); outMetricIt.Set(metric); } } } } ++outMetricIt; ++outHDispIt; ++outVDispIt; ++initIt; progress.CompletedPixel(); } ++leftIt; ++rightIt; if(inLeftMaskPtr) { ++inLeftMaskIt; } if(inRightMaskPtr) { ++inRightMaskIt; } if(useInitDispMaps) { ++inHDispIt; ++inVDispIt; } } } } } template typename PixelWiseBlockMatchingImageFilter::RegionType PixelWiseBlockMatchingImageFilter ::ConvertFullToSubsampledRegion(RegionType full, unsigned int step, IndexType index) { IndexType shiftedFull = full.GetIndex(); shiftedFull[0] -= index[0]; shiftedFull[1] -= index[1]; IndexType subIndex; subIndex[0] = (shiftedFull[0]) / step; subIndex[1] = (shiftedFull[1]) / step; if (shiftedFull[0] % step) ++subIndex[0]; if (shiftedFull[1] % step) ++subIndex[1]; if (shiftedFull[0]<0) subIndex[0] = 0; if (shiftedFull[1]<0) subIndex[1] = 0; SizeType subSize; subSize[0] = (full.GetSize(0) - (subIndex[0] * step) + shiftedFull[0]) / step; subSize[1] = (full.GetSize(1) - (subIndex[1] * step) + shiftedFull[1]) / step; if ((full.GetSize(0) - (subIndex[0] * step) + shiftedFull[0]) % step) ++subSize[0]; if ((full.GetSize(1) - (subIndex[1] * step) + shiftedFull[1]) % step) ++subSize[1]; RegionType subRegion; subRegion.SetIndex(subIndex); subRegion.SetSize(subSize); return subRegion; } template typename PixelWiseBlockMatchingImageFilter::RegionType PixelWiseBlockMatchingImageFilter ::ConvertSubsampledToFullRegion(RegionType sub, unsigned int step, IndexType index) { IndexType fullIndex; fullIndex[0] = sub.GetIndex(0) * step + index[0]; fullIndex[1] = sub.GetIndex(1) * step + index[1]; SizeType fullSize; fullSize[0] = sub.GetSize(0) * step; fullSize[1] = sub.GetSize(1) * step; if (fullSize[0] > 0) fullSize[0] -= (step - 1); if (fullSize[1] > 0) fullSize[1] -= (step - 1); RegionType fullRegion; fullRegion.SetIndex(fullIndex); fullRegion.SetSize(fullSize); return fullRegion; } } // End namespace otb #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbSubPixelDisparityImageFilter.h000066400000000000000000000253051301006202600321510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSubPixelDisparityImageFilter_h #define otbSubPixelDisparityImageFilter_h #include "otbPixelWiseBlockMatchingImageFilter.h" #include "itkTranslationTransform.h" #include "itkResampleImageFilter.h" namespace otb { /** \class SubPixelDisparityImageFilter * \brief Perform sub-pixel disparity estimation from input integer disparities and the image pair that was used * * This filter is intended to be placed after a PixelWiseBlockMatchingImageFilter. Its role is to produce an estimate * of the disparities (both horizontal and vertical) with sub-pixel precision. The integer input disparities are used * as starting points for the disparity refinement. The refinement is done within a 3x3 neighborhood around this * position (it is neighborhood in the 2D disparity space). If no input disparity is given, the shift between * input images is assumed to be null along both directions. * * Left and right masks can be used to skip the sub-pixel disparity refinement for couples of pixels carrying a * non-positive mask value. * * The exploration limits for horizontal and vertical disparities can be set like in PixelWiseBlockMatchingFilter. * If the 3x3 neighborhood around the initial estimate is not inside the exploration area, refinement is skipped for * the current pixel. * * Before trying to refine the integer disparity, the filter checks that the initial position is an extrema for the * metric used. Depending on the 3x3 neighborhood, the refinement can be done along the horizontal axis only, along * the vertical axis only, and also in 2D. Three refinement methods are proposed : parabolic, triangular and dichotomy. * The parabolic method tries to fit a parabola to the metric scores on the 3x3 neighborhood. The triangular * method tries to fit local scores to a circular cone. The dichotomy method tries to find the local extrema by * a dichotomic search (non-integer disparity positions are tested after a resampling of the right image). * * \sa PixelWiseBlockMatchingImageFilter * \sa FineRegistrationImageFilter * \sa StereorectificationDisplacementFieldSource * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBDisparityMap */ template , class TBlockMatchingFunctor = Functor::SSDBlockMatching > class ITK_EXPORT SubPixelDisparityImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef SubPixelDisparityImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(SubPixelDisparityImageFilter, ImageToImageFilter); /** Useful typedefs */ typedef TInputImage InputImageType; typedef TOutputMetricImage OutputMetricImageType; typedef TDisparityImage OutputDisparityImageType; typedef TMaskImage InputMaskImageType; typedef TBlockMatchingFunctor BlockMatchingFunctorType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SpacingType SpacingType; typedef typename InputImageType::PointType PointType; typedef typename TOutputMetricImage::ValueType MetricValueType; typedef typename OutputDisparityImageType::PixelType DisparityPixelType; typedef itk::ConstNeighborhoodIterator ConstNeighborhoodIteratorType; typedef itk::ResampleImageFilter ResamplerFilterType; typedef itk::TranslationTransform TransformationType; typedef otb::PixelWiseBlockMatchingImageFilter < InputImageType, OutputMetricImageType, OutputDisparityImageType, InputMaskImageType, BlockMatchingFunctorType> BlockMatchingFilterType; itkStaticConstMacro(PARABOLIC,int,0); itkStaticConstMacro(TRIANGULAR,int,1); itkStaticConstMacro(DICHOTOMY,int,2); /** Set left input */ void SetLeftInput( const TInputImage * image); /** Set right input */ void SetRightInput( const TInputImage * image); /** Set initial horizontal disparity field */ void SetHorizontalDisparityInput( const TDisparityImage * hfield); /** Set initial vertical disparity field */ void SetVerticalDisparityInput( const TDisparityImage * vfield); /** Set the input metric image */ void SetMetricInput(const TOutputMetricImage * image); /** Get the initial disparity fields */ const TDisparityImage * GetHorizontalDisparityInput() const; const TDisparityImage * GetVerticalDisparityInput() const; /** Set mask input (optional) */ void SetLeftMaskInput(const TMaskImage * image); /** Set right mask input (optional) */ void SetRightMaskInput(const TMaskImage * image); /** Get the inputs */ const TInputImage * GetLeftInput() const; const TInputImage * GetRightInput() const; const TMaskImage * GetLeftMaskInput() const; const TMaskImage * GetRightMaskInput() const; /** Get the metric output */ const TOutputMetricImage * GetMetricOutput() const; TOutputMetricImage * GetMetricOutput(); /** Get the disparity output */ const TDisparityImage * GetHorizontalDisparityOutput() const; TDisparityImage * GetHorizontalDisparityOutput(); /** Get the disparity output */ const TDisparityImage * GetVerticalDisparityOutput() const; TDisparityImage * GetVerticalDisparityOutput(); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } /** Set/Get the radius of the area on which metric is evaluated */ itkSetMacro(Radius, SizeType); itkGetConstReferenceMacro(Radius, SizeType); /*** Set/Get the minimum disparity to explore */ itkSetMacro(MinimumHorizontalDisparity,int); itkGetConstReferenceMacro(MinimumHorizontalDisparity,int); /*** Set/Get the maximum disparity to explore */ itkSetMacro(MaximumHorizontalDisparity,int); itkGetConstReferenceMacro(MaximumHorizontalDisparity,int); /*** Set/Get the minimum disparity to explore */ itkSetMacro(MinimumVerticalDisparity,int); itkGetConstReferenceMacro(MinimumVerticalDisparity,int); /*** Set/Get the maximum disparity to explore */ itkSetMacro(MaximumVerticalDisparity,int); itkGetConstReferenceMacro(MaximumVerticalDisparity,int); itkSetMacro(Minimize, bool); itkGetConstReferenceMacro(Minimize,bool); itkBooleanMacro(Minimize); /** Get the functor for parameters setting */ BlockMatchingFunctorType & GetFunctor() { return m_Functor; } /** Get the functor (const version) */ const BlockMatchingFunctorType & GetFunctor() const { return m_Functor; } /** Set/Get the refinement method (PARABOLIC, TRIANGULAR or DICHOTOMY) */ itkSetMacro(RefineMethod,int); itkGetMacro(RefineMethod,int); void SetInputsFromBlockMatchingFilter(const BlockMatchingFilterType * filter); protected: /** Constructor */ SubPixelDisparityImageFilter(); /** Destructor */ ~SubPixelDisparityImageFilter() ITK_OVERRIDE; /** \brief Verify that the input images are compatible * * This method needs to be re-implemented from ImageToImageFilter since * the initial images and disparity maps may not have the same size */ void VerifyInputInformation() ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Before threaded generate data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const RegionType & outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** After threaded generate data */ void AfterThreadedGenerateData() ITK_OVERRIDE; private: SubPixelDisparityImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** parabolic refinement method */ void ParabolicRefinement(const RegionType& outputRegionForThread, itk::ThreadIdType threadId); /** triangular refinement method */ void TriangularRefinement(const RegionType& outputRegionForThread, itk::ThreadIdType threadId); /** dichotomy refinement method */ void DichotomyRefinement(const RegionType& outputRegionForThread, itk::ThreadIdType threadId); /** The radius of the blocks */ SizeType m_Radius; /** The min disparity to explore */ int m_MinimumHorizontalDisparity; /** The max disparity to explore */ int m_MaximumHorizontalDisparity; /** The min disparity to explore */ int m_MinimumVerticalDisparity; /** The max disparity to explore */ int m_MaximumVerticalDisparity; /** Should we minimize or maximize ? */ bool m_Minimize; /** Block-matching functor */ BlockMatchingFunctorType m_Functor; /** Refinement method (PARABOLIC, TRIANGULAR or DICHOTOMY)*/ int m_RefineMethod; /** Stores the number of pixels whose refined position has a worse metric than the initial position */ std::vector m_WrongExtrema; /** Stores the computed grid step of the disparity map (internal purpose only) */ unsigned int m_Step; /** Stores the computed grid start index of the disparity map (internal purpose only) */ IndexType m_GridIndex; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbSubPixelDisparityImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/DisparityMap/include/otbSubPixelDisparityImageFilter.txx000066400000000000000000002336131301006202600325500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbSubPixelDisparityImageFilter_txx #define otbSubPixelDisparityImageFilter_txx #include "otbSubPixelDisparityImageFilter.h" namespace otb { template SubPixelDisparityImageFilter ::SubPixelDisparityImageFilter() { // Set the number of required inputs this->SetNumberOfRequiredInputs(3); // Set the outputs this->SetNumberOfRequiredOutputs(3); this->SetNthOutput(0,TDisparityImage::New()); this->SetNthOutput(1,TDisparityImage::New()); this->SetNthOutput(2,TOutputMetricImage::New()); // Default parameters m_Radius.Fill(2); // Minimize by default m_Minimize = true; // Default disparity range m_MinimumHorizontalDisparity = -10; m_MaximumHorizontalDisparity = 10; m_MinimumVerticalDisparity = 0; m_MaximumVerticalDisparity = 0; // Default refinement method : parabolic m_RefineMethod = 0; // Default step value m_Step = 1; // Default grid index m_GridIndex[0] = 0; m_GridIndex[1] = 0; } template SubPixelDisparityImageFilter ::~SubPixelDisparityImageFilter() {} template void SubPixelDisparityImageFilter ::SetLeftInput(const TInputImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( image )); } template void SubPixelDisparityImageFilter ::SetRightInput(const TInputImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( image )); } template void SubPixelDisparityImageFilter ::SetHorizontalDisparityInput( const TDisparityImage * hfield) { // Process object is not const-correct so the const casting is required. this->SetNthInput(2, const_cast( hfield )); } template void SubPixelDisparityImageFilter ::SetVerticalDisparityInput( const TDisparityImage * vfield) { // Process object is not const-correct so the const casting is required. this->SetNthInput(3, const_cast( vfield )); } template void SubPixelDisparityImageFilter ::SetLeftMaskInput(const TMaskImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(4, const_cast( image )); } template void SubPixelDisparityImageFilter ::SetRightMaskInput(const TMaskImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(5, const_cast( image )); } template void SubPixelDisparityImageFilter ::SetMetricInput(const TOutputMetricImage * image) { // Process object is not const-correct so the const casting is required. this->SetNthInput(6, const_cast( image )); } template const TInputImage * SubPixelDisparityImageFilter ::GetLeftInput() const { if (this->GetNumberOfIndexedInputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TInputImage * SubPixelDisparityImageFilter ::GetRightInput() const { if(this->GetNumberOfIndexedInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template const TDisparityImage * SubPixelDisparityImageFilter ::GetHorizontalDisparityInput() const { if(this->GetNumberOfIndexedInputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template const TDisparityImage * SubPixelDisparityImageFilter ::GetVerticalDisparityInput() const { if(this->GetNumberOfIndexedInputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3)); } template const TMaskImage * SubPixelDisparityImageFilter ::GetLeftMaskInput() const { if(this->GetNumberOfIndexedInputs()<5) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(4)); } template const TMaskImage * SubPixelDisparityImageFilter ::GetRightMaskInput() const { if(this->GetNumberOfIndexedInputs()<6) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(5)); } template const TDisparityImage * SubPixelDisparityImageFilter ::GetHorizontalDisparityOutput() const { if (this->GetNumberOfOutputs()<1) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template TDisparityImage * SubPixelDisparityImageFilter ::GetHorizontalDisparityOutput() { if (this->GetNumberOfOutputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template const TDisparityImage * SubPixelDisparityImageFilter ::GetVerticalDisparityOutput() const { if (this->GetNumberOfOutputs()<2) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template TDisparityImage * SubPixelDisparityImageFilter ::GetVerticalDisparityOutput() { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const TOutputMetricImage * SubPixelDisparityImageFilter ::GetMetricOutput() const { if (this->GetNumberOfOutputs()<3) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template TOutputMetricImage * SubPixelDisparityImageFilter ::GetMetricOutput() { if (this->GetNumberOfOutputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template void SubPixelDisparityImageFilter ::SetInputsFromBlockMatchingFilter(const BlockMatchingFilterType * filter) { this->SetLeftInput(filter->GetLeftInput()); this->SetRightInput(filter->GetRightInput()); this->SetRadius(filter->GetRadius()); this->SetMinimumHorizontalDisparity(filter->GetMinimumHorizontalDisparity()); this->SetMaximumHorizontalDisparity(filter->GetMaximumHorizontalDisparity()); this->SetMinimumVerticalDisparity(filter->GetMinimumVerticalDisparity()); this->SetMaximumVerticalDisparity(filter->GetMaximumVerticalDisparity()); this->SetMinimize(filter->GetMinimize()); this->SetMetricInput(filter->GetMetricOutput()); if (filter->GetHorizontalDisparityOutput()) { this->SetHorizontalDisparityInput(filter->GetHorizontalDisparityOutput()); } if (filter->GetVerticalDisparityOutput()) { this->SetVerticalDisparityInput(filter->GetVerticalDisparityOutput()); } if (filter->GetLeftMaskInput()) { this->SetLeftMaskInput(filter->GetLeftMaskInput()); } if (filter->GetRightMaskInput()) { this->SetRightMaskInput(filter->GetRightMaskInput()); } } template void SubPixelDisparityImageFilter ::VerifyInputInformation() { // Retrieve input pointers const TInputImage * inLeftPtr = this->GetLeftInput(); const TInputImage * inRightPtr = this->GetRightInput(); const TMaskImage * inLeftMaskPtr = this->GetLeftMaskInput(); const TMaskImage * inRightMaskPtr = this->GetRightMaskInput(); const TDisparityImage * inHDispPtr = this->GetHorizontalDisparityInput(); const TDisparityImage * inVDispPtr = this->GetVerticalDisparityInput(); // Check pointers before using them if(!inLeftPtr || !inRightPtr) { itkExceptionMacro(<<"Missing input, need left and right input images."); } if (!inHDispPtr) { itkExceptionMacro(<<"Input horizontal disparity map is missing"); } // Now, we impose that both inputs have the same size if(inLeftPtr->GetLargestPossibleRegion() != inRightPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Left and right images do not have the same size ! Left largest region: "<GetLargestPossibleRegion()<<", right largest region: "<GetLargestPossibleRegion()); } // We also check that left mask image has same size if present if(inLeftMaskPtr && inLeftPtr->GetLargestPossibleRegion() != inLeftMaskPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Left and mask images do not have the same size ! Left largest region: "<GetLargestPossibleRegion()<<", mask largest region: "<GetLargestPossibleRegion()); } // We also check that right mask image has same size if present if(inRightMaskPtr && inRightPtr->GetLargestPossibleRegion() != inRightMaskPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Right and mask images do not have the same size ! Right largest region: "<GetLargestPossibleRegion()<<", mask largest region: "<GetLargestPossibleRegion()); } // We check that the input initial disparity maps have the same size if present if (inHDispPtr && inVDispPtr && inHDispPtr->GetLargestPossibleRegion() != inVDispPtr->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Initial horizontal and vertical disparity maps don't have the same size ! Horizontal disparity largest region: "<GetLargestPossibleRegion()<<", vertical disparity largest region: "<GetLargestPossibleRegion()); } } template void SubPixelDisparityImageFilter ::GenerateOutputInformation() { // Retrieve input pointers const TInputImage * inLeftPtr = this->GetLeftInput(); const TDisparityImage * inHDispPtr = this->GetHorizontalDisparityInput(); TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); outMetricPtr->CopyInformation(inHDispPtr); outHDispPtr->CopyInformation(inHDispPtr); outVDispPtr->CopyInformation(inHDispPtr); // Check the size of the input disparity maps (possible subsampled grid) SpacingType leftSpacing = inLeftPtr->GetSpacing(); SpacingType dispSpacing = inHDispPtr->GetSpacing(); PointType leftOrigin = inLeftPtr->GetOrigin(); PointType dispOrigin = inHDispPtr->GetOrigin(); double ratioX = dispSpacing[0] / leftSpacing[0]; double ratioY = dispSpacing[1] / leftSpacing[1]; int stepX = static_cast(vcl_floor(ratioX + 0.5)); int stepY = static_cast(vcl_floor(ratioY + 0.5)); if (stepX < 1 || stepY < 1 || stepX != stepY) { itkExceptionMacro(<<"Incompatible spacing values between disparity map and input image. Left spacing: "<m_Step = static_cast(stepX); double shiftX = (dispOrigin[0] - leftOrigin[0]) / leftSpacing[0]; double shiftY = (dispOrigin[1] - leftOrigin[1]) / leftSpacing[1]; this->m_GridIndex[0] = static_cast(vcl_floor(shiftX + 0.5)); this->m_GridIndex[1] = static_cast(vcl_floor(shiftY + 0.5)); } template void SubPixelDisparityImageFilter ::GenerateInputRequestedRegion() { // Call superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve input pointers TInputImage * inLeftPtr = const_cast(this->GetLeftInput()); TInputImage * inRightPtr = const_cast(this->GetRightInput()); TMaskImage * inLeftMaskPtr = const_cast(this->GetLeftMaskInput()); TMaskImage * inRightMaskPtr = const_cast(this->GetRightMaskInput()); TDisparityImage * inHDispPtr = const_cast(this->GetHorizontalDisparityInput()); TDisparityImage * inVDispPtr = const_cast(this->GetVerticalDisparityInput()); TDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); // Retrieve requested region (TODO: check if we need to handle // region for outHDispPtr) RegionType outputRequestedRegion = outHDispPtr->GetRequestedRegion(); RegionType fullRequestedRegion = BlockMatchingFilterType::ConvertSubsampledToFullRegion(outputRequestedRegion, this->m_Step, this->m_GridIndex); // Pad by the appropriate radius RegionType inputLeftRegion = fullRequestedRegion; inputLeftRegion.PadByRadius(m_Radius); // Now, we must find the corresponding region in moving image IndexType rightRequestedRegionIndex = fullRequestedRegion.GetIndex(); rightRequestedRegionIndex[0]+=m_MinimumHorizontalDisparity; rightRequestedRegionIndex[1]+=m_MinimumVerticalDisparity; SizeType rightRequestedRegionSize = fullRequestedRegion.GetSize(); rightRequestedRegionSize[0]+= m_MaximumHorizontalDisparity - m_MinimumHorizontalDisparity; rightRequestedRegionSize[1]+= m_MaximumVerticalDisparity - m_MinimumVerticalDisparity; RegionType inputRightRegion; inputRightRegion.SetIndex(rightRequestedRegionIndex); inputRightRegion.SetSize(rightRequestedRegionSize); RegionType inputRightMaskRegion = inputRightRegion; inputRightRegion.PadByRadius(m_Radius); // crop the left region at the left's largest possible region if ( inputLeftRegion.Crop(inLeftPtr->GetLargestPossibleRegion())) { inLeftPtr->SetRequestedRegion( inputLeftRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) inLeftPtr->SetRequestedRegion( inputLeftRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of left image."); e.SetDataObject(inLeftPtr); throw e; } // crop the right region at the right's largest possible region if ( inputRightRegion.Crop(inRightPtr->GetLargestPossibleRegion())) { inRightPtr->SetRequestedRegion( inputRightRegion ); inputRightMaskRegion.Crop(inRightPtr->GetLargestPossibleRegion()); } else { // Depending on the minimum and maximum disparities, the right side patch can // be outside the image : in this case, just request an empty region inputRightRegion.SetIndex(inRightPtr->GetLargestPossibleRegion().GetIndex()); inputRightRegion.SetSize(0,0); inputRightRegion.SetSize(1,0); inRightPtr->SetRequestedRegion( inputRightRegion ); inputRightMaskRegion = inputRightRegion; // // Couldn't crop the region (requested region is outside the largest // // possible region). Throw an exception. // // store what we tried to request (prior to trying to crop) // inRightPtr->SetRequestedRegion( inputRightRegion ); // // // build an exception // itk::InvalidRequestedRegionError e(__FILE__, __LINE__); // std::ostringstream msg; // msg << this->GetNameOfClass() // << "::GenerateInputRequestedRegion()"; // e.SetLocation(msg.str().c_str()); // e.SetDescription("Requested region is (at least partially) outside the largest possible region of right image."); // e.SetDataObject(inRightPtr); // throw e; } if(inLeftMaskPtr) { // no need to crop the mask region : left mask and left image have same largest possible region inLeftMaskPtr->SetRequestedRegion( fullRequestedRegion ); } if(inRightMaskPtr) { inRightMaskPtr->SetRequestedRegion( inputRightMaskRegion ); } if (inHDispPtr) { inHDispPtr->SetRequestedRegion( outputRequestedRegion ); } if (inVDispPtr) { inVDispPtr->SetRequestedRegion( outputRequestedRegion ); } } template void SubPixelDisparityImageFilter ::BeforeThreadedGenerateData() { TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); // Fill buffers with default values outMetricPtr->FillBuffer(0.); outHDispPtr->FillBuffer(static_cast(m_MinimumHorizontalDisparity) / static_cast(this->m_Step)); outVDispPtr->FillBuffer(static_cast(m_MinimumVerticalDisparity) / static_cast(this->m_Step)); m_WrongExtrema.resize(this->GetNumberOfThreads()); } template void SubPixelDisparityImageFilter ::ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // choose the refinement method to use switch(m_RefineMethod) { // 0 = Parabolic fit case 0 : ParabolicRefinement(outputRegionForThread, threadId); break; // 1 = triangular fit case 1 : TriangularRefinement(outputRegionForThread, threadId); break; // 2 = dichotomy search case 2 : DichotomyRefinement(outputRegionForThread, threadId); break; default : break; } } template void SubPixelDisparityImageFilter ::ParabolicRefinement(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve pointers const TInputImage * inLeftPtr = this->GetLeftInput(); const TInputImage * inRightPtr = this->GetRightInput(); const TMaskImage * inLeftMaskPtr = this->GetLeftMaskInput(); const TMaskImage * inRightMaskPtr = this->GetRightMaskInput(); const TDisparityImage * inHDispPtr = this->GetHorizontalDisparityInput(); const TDisparityImage * inVDispPtr = this->GetVerticalDisparityInput(); TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); unsigned int nb_WrongExtrema = 0; // Set-up progress reporting (this is not exact, since we do not // account for pixels that won't be refined) itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels(),100); RegionType fullRegionForThread = BlockMatchingFilterType::ConvertSubsampledToFullRegion(outputRegionForThread, this->m_Step, this->m_GridIndex); itk::ConstNeighborhoodIterator leftIt(m_Radius,inLeftPtr,fullRegionForThread); itk::ImageRegionIterator outHDispIt(outHDispPtr,outputRegionForThread); itk::ImageRegionIterator outVDispIt(outVDispPtr,outputRegionForThread); itk::ImageRegionIterator outMetricIt(outMetricPtr,outputRegionForThread); itk::ImageRegionConstIterator inHDispIt; itk::ImageRegionConstIterator inVDispIt; itk::ImageRegionConstIterator inLeftMaskIt; itk::ImageRegionConstIterator inRightMaskIt; bool useHorizontalDisparity = false; bool useVerticalDisparity = false; if (inHDispPtr) { useHorizontalDisparity = true; inHDispIt = itk::ImageRegionConstIterator(inHDispPtr,outputRegionForThread); inHDispIt.GoToBegin(); } if (inVDispPtr) { useVerticalDisparity = true; inVDispIt = itk::ImageRegionConstIterator(inVDispPtr,outputRegionForThread); inVDispIt.GoToBegin(); } if(inLeftMaskPtr) { inLeftMaskIt = itk::ImageRegionConstIterator(inLeftMaskPtr,fullRegionForThread); inLeftMaskIt.GoToBegin(); } RegionType rightBufferedRegion = inRightPtr->GetBufferedRegion(); if(inRightMaskPtr) { RegionType inRightMaskRegion = inRightMaskPtr->GetBufferedRegion(); inRightMaskIt = itk::ImageRegionConstIterator(inRightMaskPtr,inRightMaskRegion); } itk::ConstantBoundaryCondition nbc1; leftIt.OverrideBoundaryCondition(&nbc1); leftIt.GoToBegin(); outHDispIt.GoToBegin(); outVDispIt.GoToBegin(); outMetricIt.GoToBegin(); /* Specific variables */ IndexType curLeftPos; IndexType curRightPos; float hDisp_f; float vDisp_f; int hDisp_i; int vDisp_i; // compute metric around current right position bool horizontalInterpolation = false; bool verticalInterpolation = false; typename ResamplerFilterType::Pointer resampler; // step value as disparityType DisparityPixelType stepDisparity = static_cast(this->m_Step); DisparityPixelType stepDisparityInv = 1. / stepDisparity; // metrics for neighbors positions : first index is x, second is y double neighborsMetric[3][3] = {{0,0,0},{0,0,0},{0,0,0}}; while (!leftIt.IsAtEnd() || !outHDispIt.IsAtEnd() || !outVDispIt.IsAtEnd() || !outMetricIt.IsAtEnd()) { // If the pixel location is on the subsampled grid curLeftPos = leftIt.GetIndex(); if (((curLeftPos[0] - this->m_GridIndex[0] + this->m_Step) % this->m_Step == 0) && ((curLeftPos[1] - this->m_GridIndex[1] + this->m_Step) % this->m_Step == 0)) { horizontalInterpolation = false; verticalInterpolation = false; /* compute estimated right position */ if (useHorizontalDisparity) { hDisp_f = static_cast(inHDispIt.Get()) * stepDisparity; hDisp_i = static_cast(vcl_floor(hDisp_f + 0.5)); curRightPos[0] = curLeftPos[0] + hDisp_i; } else { hDisp_i = 0; curRightPos[0] = curLeftPos[0]; } if (useVerticalDisparity) { vDisp_f = static_cast(inVDispIt.Get()) * stepDisparity; vDisp_i = static_cast(vcl_floor(vDisp_f + 0.5)); curRightPos[1] = curLeftPos[1] + vDisp_i; } else { vDisp_i = 0; curRightPos[1] = curLeftPos[1]; } // check if the current right position is inside the right image if (rightBufferedRegion.IsInside(curRightPos)) { if (inRightMaskPtr) { // Set right mask iterator position inRightMaskIt.SetIndex(curRightPos); } // check that the current positions are not masked if(!inLeftMaskPtr || (inLeftMaskPtr && inLeftMaskIt.Get() > 0) ) { if(!inRightMaskPtr || (inRightMaskPtr && inRightMaskIt.Get() > 0) ) { RegionType smallRightRegion; smallRightRegion.SetIndex(0,curRightPos[0]-1); smallRightRegion.SetIndex(1,curRightPos[1]-1); smallRightRegion.SetSize(0,3); smallRightRegion.SetSize(1,3); itk::ConstNeighborhoodIterator rightIt(m_Radius,inRightPtr,smallRightRegion); itk::ConstantBoundaryCondition nbc2; rightIt.OverrideBoundaryCondition(&nbc2); // compute metric at centre position rightIt.SetLocation(curRightPos); neighborsMetric[1][1] = m_Functor(leftIt,rightIt); if (m_MinimumVerticalDisparity < vDisp_i && vDisp_i < m_MaximumVerticalDisparity) { IndexType upIndex(curRightPos); upIndex[1]+= (-1); IndexType downIndex(curRightPos); downIndex[1]+= 1; if ( rightBufferedRegion.IsInside(upIndex) && rightBufferedRegion.IsInside(downIndex) ) { rightIt.SetLocation(upIndex); neighborsMetric[1][0] = m_Functor(leftIt,rightIt); rightIt.SetLocation(downIndex); neighborsMetric[1][2] = m_Functor(leftIt,rightIt); // check that current position is an extrema if (m_Minimize) { if (neighborsMetric[1][1] < neighborsMetric[1][0] && neighborsMetric[1][1] < neighborsMetric[1][2]) { verticalInterpolation = true; } } else { if (neighborsMetric[1][1] > neighborsMetric[1][0] && neighborsMetric[1][1] > neighborsMetric[1][2]) { verticalInterpolation = true; } } } } if (m_MinimumHorizontalDisparity < hDisp_i && hDisp_i < m_MaximumHorizontalDisparity) { IndexType leftIndex(curRightPos); leftIndex[0]+= (-1); IndexType rightIndex(curRightPos); rightIndex[0]+= 1; if ( rightBufferedRegion.IsInside(leftIndex) && rightBufferedRegion.IsInside(rightIndex) ) { rightIt.SetLocation(rightIndex); neighborsMetric[2][1] = m_Functor(leftIt,rightIt); rightIt.SetLocation(leftIndex); neighborsMetric[0][1] = m_Functor(leftIt,rightIt); // check that current position is an extrema if (m_Minimize) { if (neighborsMetric[1][1] < neighborsMetric[0][1] && neighborsMetric[1][1] < neighborsMetric[2][1]) { horizontalInterpolation = true; } } else { if (neighborsMetric[1][1] > neighborsMetric[0][1] && neighborsMetric[1][1] > neighborsMetric[2][1]) { horizontalInterpolation = true; } } } } // if both vertical and horizontal interpolation, compute metrics on corners if (verticalInterpolation && horizontalInterpolation) { IndexType uprightIndex(curRightPos); uprightIndex[0]+= 1; uprightIndex[1]+= (-1); rightIt.SetLocation(uprightIndex); neighborsMetric[2][0] = m_Functor(leftIt,rightIt); IndexType downrightIndex(curRightPos); downrightIndex[0]+= 1; downrightIndex[1]+= 1; rightIt.SetLocation(downrightIndex); neighborsMetric[2][2] = m_Functor(leftIt,rightIt); IndexType downleftIndex(curRightPos); downleftIndex[0]+= (-1); downleftIndex[1]+= 1; rightIt.SetLocation(downleftIndex); neighborsMetric[0][2] = m_Functor(leftIt,rightIt); IndexType upleftIndex(curRightPos); upleftIndex[0]+= (-1); upleftIndex[1]+= (-1); rightIt.SetLocation(upleftIndex); neighborsMetric[0][0] = m_Functor(leftIt,rightIt); //check that it is an extrema if (m_Minimize) { if (neighborsMetric[1][1] > neighborsMetric[2][0] || neighborsMetric[1][1] > neighborsMetric[2][2] || neighborsMetric[1][1] > neighborsMetric[0][2] || neighborsMetric[1][1] > neighborsMetric[0][0]) { verticalInterpolation = false; horizontalInterpolation = false; } } else { if (neighborsMetric[1][1] < neighborsMetric[2][0] || neighborsMetric[1][1] < neighborsMetric[2][2] || neighborsMetric[1][1] < neighborsMetric[0][2] || neighborsMetric[1][1] < neighborsMetric[0][0]) { verticalInterpolation = false; horizontalInterpolation = false; } } } } } } // Interpolate position : parabola fit if (verticalInterpolation && !horizontalInterpolation) { //vertical only double deltaV = 0.5 - (1.0 / (1.0 + (neighborsMetric[1][0]-neighborsMetric[1][1]) / (neighborsMetric[1][2]-neighborsMetric[1][1]))); if (deltaV > (-0.5) && deltaV < 0.5) { outVDispIt.Set( (static_cast(vDisp_i) + deltaV) * stepDisparityInv); } else { verticalInterpolation = false; } } else if (!verticalInterpolation && horizontalInterpolation) { // horizontal only double deltaH = 0.5 - (1.0 / (1.0 + (neighborsMetric[0][1]-neighborsMetric[1][1]) / (neighborsMetric[2][1]-neighborsMetric[1][1]))); if (deltaH > (-0.5) && deltaH < 0.5) { outHDispIt.Set( (static_cast(hDisp_i) + deltaH) * stepDisparityInv); } else { horizontalInterpolation = false; } } else if (verticalInterpolation && horizontalInterpolation) { //both horizontal and vertical double dx = 0.5 * (neighborsMetric[2][1] - neighborsMetric[0][1]); double dy = 0.5 * (neighborsMetric[1][2] - neighborsMetric[1][0]); double dxx = neighborsMetric[2][1] + neighborsMetric[0][1] - 2.0 * neighborsMetric[1][1]; double dyy = neighborsMetric[1][2] + neighborsMetric[1][0] - 2.0 * neighborsMetric[1][1]; double dxy = 0.25*(neighborsMetric[2][2] + neighborsMetric[0][0] - neighborsMetric[0][2] - neighborsMetric[2][0]); double det = dxx*dyy - dxy*dxy; if (vcl_abs(det) < (1e-10)) { verticalInterpolation = false; horizontalInterpolation = false; } else { double deltaH = (-dx * dyy + dy * dxy )/det; double deltaV = ( dx * dxy - dy * dxx )/det; if (deltaH > (-1.0) && deltaH < 1.0 && deltaV > (-1.0) && deltaV < 1.0) { outHDispIt.Set( (static_cast(hDisp_i) + deltaH) * stepDisparityInv); outVDispIt.Set( (static_cast(vDisp_i) + deltaV) * stepDisparityInv); } else { verticalInterpolation = false; horizontalInterpolation = false; } } } if (!verticalInterpolation) { // No vertical interpolation done : simply copy the integer vertical disparity outVDispIt.Set( static_cast(vDisp_i) * stepDisparityInv); } if (!horizontalInterpolation) { // No horizontal interpolation done : simply copy the integer horizontal disparity outHDispIt.Set( static_cast(hDisp_i) * stepDisparityInv); } if (!verticalInterpolation && !horizontalInterpolation) { // no interpolation done : keep current score outMetricIt.Set(static_cast(neighborsMetric[1][1])); } else { // interpolation done, use a resampler to compute new score typename TInputImage::Pointer fakeRightPtr = TInputImage::New(); fakeRightPtr->SetRegions(rightBufferedRegion); fakeRightPtr->SetPixelContainer((const_cast(inRightPtr))->GetPixelContainer()); itk::ConstNeighborhoodIterator shiftedIt; itk::ConstantBoundaryCondition nbc3; shiftedIt.OverrideBoundaryCondition(&nbc3); SizeType windowSize; windowSize[0] = 2 * m_Radius[0] + 1; windowSize[1] = 2 * m_Radius[1] + 1; IndexType upleftCorner; upleftCorner[0] = curRightPos[0] - m_Radius[0]; upleftCorner[1] = curRightPos[1] - m_Radius[1]; TransformationType::Pointer transfo = TransformationType::New(); TransformationType::OutputVectorType offsetTransfo(2); RegionType tinyShiftedRegion; tinyShiftedRegion.SetSize(0, 1); tinyShiftedRegion.SetSize(1, 1); tinyShiftedRegion.SetIndex(0, curRightPos[0]); tinyShiftedRegion.SetIndex(1, curRightPos[1]); resampler = ResamplerFilterType::New(); resampler->SetInput(fakeRightPtr); resampler->SetSize(windowSize); resampler->SetNumberOfThreads(1); resampler->SetTransform(transfo); resampler->SetOutputStartIndex(upleftCorner); offsetTransfo[0] = outHDispIt.Get() * stepDisparity - static_cast(hDisp_i); offsetTransfo[1] = outVDispIt.Get() * stepDisparity - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); outMetricIt.Set(m_Functor(leftIt,shiftedIt)); if ((outMetricIt.Get() > neighborsMetric[1][1] && m_Minimize) || (outMetricIt.Get() < neighborsMetric[1][1] && !m_Minimize)) { nb_WrongExtrema++; } } progress.CompletedPixel(); ++outHDispIt; ++outVDispIt; ++outMetricIt; if (useHorizontalDisparity) { ++inHDispIt; } if (useVerticalDisparity) { ++inVDispIt; } } ++leftIt; if(inLeftMaskPtr) { ++inLeftMaskIt; } } m_WrongExtrema[threadId] = static_cast(nb_WrongExtrema) / static_cast(outputRegionForThread.GetNumberOfPixels()); } template void SubPixelDisparityImageFilter ::TriangularRefinement(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve pointers const TInputImage * inLeftPtr = this->GetLeftInput(); const TInputImage * inRightPtr = this->GetRightInput(); const TMaskImage * inLeftMaskPtr = this->GetLeftMaskInput(); const TMaskImage * inRightMaskPtr = this->GetRightMaskInput(); const TDisparityImage * inHDispPtr = this->GetHorizontalDisparityInput(); const TDisparityImage * inVDispPtr = this->GetVerticalDisparityInput(); TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); unsigned int nb_WrongExtrema = 0; // Set-up progress reporting (this is not exact, since we do not // account for pixels that won't be refined) itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels(),100); RegionType fullRegionForThread = BlockMatchingFilterType::ConvertSubsampledToFullRegion(outputRegionForThread, this->m_Step, this->m_GridIndex); itk::ConstNeighborhoodIterator leftIt(m_Radius,inLeftPtr,fullRegionForThread); itk::ImageRegionIterator outHDispIt(outHDispPtr,outputRegionForThread); itk::ImageRegionIterator outVDispIt(outVDispPtr,outputRegionForThread); itk::ImageRegionIterator outMetricIt(outMetricPtr,outputRegionForThread); itk::ImageRegionConstIterator inHDispIt; itk::ImageRegionConstIterator inVDispIt; itk::ImageRegionConstIterator inLeftMaskIt; itk::ImageRegionConstIterator inRightMaskIt; bool useHorizontalDisparity = false; bool useVerticalDisparity = false; if (inHDispPtr) { useHorizontalDisparity = true; inHDispIt = itk::ImageRegionConstIterator(inHDispPtr,outputRegionForThread); inHDispIt.GoToBegin(); } if (inVDispPtr) { useVerticalDisparity = true; inVDispIt = itk::ImageRegionConstIterator(inVDispPtr,outputRegionForThread); inVDispIt.GoToBegin(); } if(inLeftMaskPtr) { inLeftMaskIt = itk::ImageRegionConstIterator(inLeftMaskPtr,fullRegionForThread); inLeftMaskIt.GoToBegin(); } RegionType rightBufferedRegion = inRightPtr->GetBufferedRegion(); if(inRightMaskPtr) { RegionType inRightMaskRegion = inRightMaskPtr->GetBufferedRegion(); inRightMaskIt = itk::ImageRegionConstIterator(inRightMaskPtr,inRightMaskRegion); } itk::ConstantBoundaryCondition nbc1; leftIt.OverrideBoundaryCondition(&nbc1); leftIt.GoToBegin(); outHDispIt.GoToBegin(); outVDispIt.GoToBegin(); outMetricIt.GoToBegin(); /* Specific variables */ IndexType curLeftPos; IndexType curRightPos; float hDisp_f; float vDisp_f; int hDisp_i; int vDisp_i; // compute metric around current right position bool horizontalInterpolation = false; bool verticalInterpolation = false; typename ResamplerFilterType::Pointer resampler; // step value as disparityType DisparityPixelType stepDisparity = static_cast(this->m_Step); DisparityPixelType stepDisparityInv = 1. / stepDisparity; // metrics for neighbors positions : first index is x, second is y double neighborsMetric[3][3] = {{0,0,0},{0,0,0},{0,0,0}}; while (!leftIt.IsAtEnd() || !outHDispIt.IsAtEnd() || !outVDispIt.IsAtEnd() || !outMetricIt.IsAtEnd()) { // If the pixel location is on the subsampled grid curLeftPos = leftIt.GetIndex(); if (((curLeftPos[0] - this->m_GridIndex[0] + this->m_Step) % this->m_Step == 0) && ((curLeftPos[1] - this->m_GridIndex[1] + this->m_Step) % this->m_Step == 0)) { horizontalInterpolation = false; verticalInterpolation = false; /* compute estimated right position */ if (useHorizontalDisparity) { hDisp_f = static_cast(inHDispIt.Get()) * stepDisparity; hDisp_i = static_cast(vcl_floor(hDisp_f + 0.5)); curRightPos[0] = curLeftPos[0] + hDisp_i; } else { hDisp_i = 0; curRightPos[0] = curLeftPos[0]; } if (useVerticalDisparity) { vDisp_f = static_cast(inVDispIt.Get()) * stepDisparity; vDisp_i = static_cast(vcl_floor(vDisp_f + 0.5)); curRightPos[1] = curLeftPos[1] + vDisp_i; } else { vDisp_i = 0; curRightPos[1] = curLeftPos[1]; } // check if the current right position is inside the right image if (rightBufferedRegion.IsInside(curRightPos)) { if (inRightMaskPtr) { // Set right mask iterator position inRightMaskIt.SetIndex(curRightPos); } // check that the current positions are not masked if(!inLeftMaskPtr || (inLeftMaskPtr && inLeftMaskIt.Get() > 0) ) { if(!inRightMaskPtr || (inRightMaskPtr && inRightMaskIt.Get() > 0) ) { RegionType smallRightRegion; smallRightRegion.SetIndex(0,curRightPos[0]-1); smallRightRegion.SetIndex(1,curRightPos[1]-1); smallRightRegion.SetSize(0,3); smallRightRegion.SetSize(1,3); itk::ConstNeighborhoodIterator rightIt(m_Radius,inRightPtr,smallRightRegion); itk::ConstantBoundaryCondition nbc2; rightIt.OverrideBoundaryCondition(&nbc2); // compute metric at centre position rightIt.SetLocation(curRightPos); neighborsMetric[1][1] = m_Functor(leftIt,rightIt); if (m_MinimumVerticalDisparity < vDisp_i && vDisp_i < m_MaximumVerticalDisparity) { IndexType upIndex(curRightPos); upIndex[1]+= (-1); IndexType downIndex(curRightPos); downIndex[1]+= 1; if ( rightBufferedRegion.IsInside(upIndex) && rightBufferedRegion.IsInside(downIndex) ) { rightIt.SetLocation(upIndex); neighborsMetric[1][0] = m_Functor(leftIt,rightIt); rightIt.SetLocation(downIndex); neighborsMetric[1][2] = m_Functor(leftIt,rightIt); // check that current position is an extrema if (m_Minimize) { if (neighborsMetric[1][1] < neighborsMetric[1][0] && neighborsMetric[1][1] < neighborsMetric[1][2]) { verticalInterpolation = true; } } else { if (neighborsMetric[1][1] > neighborsMetric[1][0] && neighborsMetric[1][1] > neighborsMetric[1][2]) { verticalInterpolation = true; } } } } if (m_MinimumHorizontalDisparity < hDisp_i && hDisp_i < m_MaximumHorizontalDisparity) { IndexType leftIndex(curRightPos); leftIndex[0]+= (-1); IndexType rightIndex(curRightPos); rightIndex[0]+= 1; if ( rightBufferedRegion.IsInside(leftIndex) && rightBufferedRegion.IsInside(rightIndex) ) { rightIt.SetLocation(rightIndex); neighborsMetric[2][1] = m_Functor(leftIt,rightIt); rightIt.SetLocation(leftIndex); neighborsMetric[0][1] = m_Functor(leftIt,rightIt); // check that current position is an extrema if (m_Minimize) { if (neighborsMetric[1][1] < neighborsMetric[0][1] && neighborsMetric[1][1] < neighborsMetric[2][1]) { horizontalInterpolation = true; } } else { if (neighborsMetric[1][1] > neighborsMetric[0][1] && neighborsMetric[1][1] > neighborsMetric[2][1]) { horizontalInterpolation = true; } } } } // if both vertical and horizontal interpolation, compute metrics on corners if (verticalInterpolation && horizontalInterpolation) { IndexType uprightIndex(curRightPos); uprightIndex[0]+= 1; uprightIndex[1]+= (-1); rightIt.SetLocation(uprightIndex); neighborsMetric[2][0] = m_Functor(leftIt,rightIt); IndexType downrightIndex(curRightPos); downrightIndex[0]+= 1; downrightIndex[1]+= 1; rightIt.SetLocation(downrightIndex); neighborsMetric[2][2] = m_Functor(leftIt,rightIt); IndexType downleftIndex(curRightPos); downleftIndex[0]+= (-1); downleftIndex[1]+= 1; rightIt.SetLocation(downleftIndex); neighborsMetric[0][2] = m_Functor(leftIt,rightIt); IndexType upleftIndex(curRightPos); upleftIndex[0]+= (-1); upleftIndex[1]+= (-1); rightIt.SetLocation(upleftIndex); neighborsMetric[0][0] = m_Functor(leftIt,rightIt); //check that it is an extrema if (m_Minimize) { if (neighborsMetric[1][1] > neighborsMetric[2][0] || neighborsMetric[1][1] > neighborsMetric[2][2] || neighborsMetric[1][1] > neighborsMetric[0][2] || neighborsMetric[1][1] > neighborsMetric[0][0]) { verticalInterpolation = false; horizontalInterpolation = false; } } else { if (neighborsMetric[1][1] < neighborsMetric[2][0] || neighborsMetric[1][1] < neighborsMetric[2][2] || neighborsMetric[1][1] < neighborsMetric[0][2] || neighborsMetric[1][1] < neighborsMetric[0][0]) { verticalInterpolation = false; horizontalInterpolation = false; } } } } } } // Interpolate position : triangular fit if (verticalInterpolation && !horizontalInterpolation) { //vertical only double deltaV; if ((neighborsMetric[1][0] < neighborsMetric[1][2] && m_Minimize) || (neighborsMetric[1][0] > neighborsMetric[1][2] && !m_Minimize)) { deltaV = 0.5 * ((neighborsMetric[1][0]-neighborsMetric[1][2])/(neighborsMetric[1][2]-neighborsMetric[1][1])); } else { deltaV = 0.5 * ((neighborsMetric[1][0]-neighborsMetric[1][2])/(neighborsMetric[1][0]-neighborsMetric[1][1])); } if (deltaV > (-0.5) && deltaV < 0.5) { outVDispIt.Set( (static_cast(vDisp_i) + deltaV) * stepDisparityInv); } else { verticalInterpolation = false; } } else if (!verticalInterpolation && horizontalInterpolation) { // horizontal only double deltaH; if ((neighborsMetric[0][1] < neighborsMetric[2][1] && m_Minimize) || (neighborsMetric[0][1] > neighborsMetric[2][1] && !m_Minimize)) { deltaH = 0.5 * ((neighborsMetric[0][1]-neighborsMetric[2][1])/(neighborsMetric[2][1]-neighborsMetric[1][1])); } else { deltaH = 0.5 * ((neighborsMetric[0][1]-neighborsMetric[2][1])/(neighborsMetric[0][1]-neighborsMetric[1][1])); } if (deltaH > (-0.5) && deltaH < 0.5) { outHDispIt.Set( (static_cast(hDisp_i) + deltaH) * stepDisparityInv); } else { horizontalInterpolation = false; } } else if (verticalInterpolation && horizontalInterpolation) { //both horizontal and vertical double deltaH; double deltaV; if ((neighborsMetric[1][0] < neighborsMetric[1][2] && m_Minimize) || (neighborsMetric[1][0] > neighborsMetric[1][2] && !m_Minimize)) { deltaV = 0.5 * ((neighborsMetric[1][0]-neighborsMetric[1][2])/(neighborsMetric[1][2]-neighborsMetric[1][1])); } else { deltaV = 0.5 * ((neighborsMetric[1][0]-neighborsMetric[1][2])/(neighborsMetric[1][0]-neighborsMetric[1][1])); } if ((neighborsMetric[0][1] < neighborsMetric[2][1] && m_Minimize) || (neighborsMetric[0][1] > neighborsMetric[2][1] && !m_Minimize)) { deltaH = 0.5 * ((neighborsMetric[0][1]-neighborsMetric[2][1])/(neighborsMetric[2][1]-neighborsMetric[1][1])); } else { deltaH = 0.5 * ((neighborsMetric[0][1]-neighborsMetric[2][1])/(neighborsMetric[0][1]-neighborsMetric[1][1])); } if (deltaV > (-1.0) && deltaV < 1.0 && deltaH > (-1.0) && deltaH < 1.0) { outVDispIt.Set( (static_cast(vDisp_i) + deltaV) * stepDisparityInv); outHDispIt.Set( (static_cast(hDisp_i) + deltaH) * stepDisparityInv); } else { verticalInterpolation = false; horizontalInterpolation = false; } } if (!verticalInterpolation) { // No vertical interpolation done : simply copy the integer vertical disparity outVDispIt.Set( static_cast(vDisp_i) * stepDisparityInv); } if (!horizontalInterpolation) { // No horizontal interpolation done : simply copy the integer horizontal disparity outHDispIt.Set( static_cast(hDisp_i) * stepDisparityInv); } if (!verticalInterpolation && !horizontalInterpolation) { // no interpolation done : keep current score outMetricIt.Set(static_cast(neighborsMetric[1][1])); } else { // interpolation done, use a resampler to compute new score typename TInputImage::Pointer fakeRightPtr = TInputImage::New(); fakeRightPtr->SetRegions(rightBufferedRegion); fakeRightPtr->SetPixelContainer((const_cast(inRightPtr))->GetPixelContainer()); itk::ConstNeighborhoodIterator shiftedIt; itk::ConstantBoundaryCondition nbc3; shiftedIt.OverrideBoundaryCondition(&nbc3); SizeType windowSize; windowSize[0] = 2 * m_Radius[0] + 1; windowSize[1] = 2 * m_Radius[1] + 1; IndexType upleftCorner; upleftCorner[0] = curRightPos[0] - m_Radius[0]; upleftCorner[1] = curRightPos[1] - m_Radius[1]; TransformationType::Pointer transfo = TransformationType::New(); TransformationType::OutputVectorType offsetTransfo(2); RegionType tinyShiftedRegion; tinyShiftedRegion.SetSize(0, 1); tinyShiftedRegion.SetSize(1, 1); tinyShiftedRegion.SetIndex(0, curRightPos[0]); tinyShiftedRegion.SetIndex(1, curRightPos[1]); resampler = ResamplerFilterType::New(); resampler->SetInput(fakeRightPtr); resampler->SetSize(windowSize); resampler->SetNumberOfThreads(1); resampler->SetTransform(transfo); resampler->SetOutputStartIndex(upleftCorner); offsetTransfo[0] = outHDispIt.Get() * stepDisparity - static_cast(hDisp_i); offsetTransfo[1] = outVDispIt.Get() * stepDisparity - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); outMetricIt.Set(m_Functor(leftIt,shiftedIt)); if ((outMetricIt.Get() > neighborsMetric[1][1] && m_Minimize) || (outMetricIt.Get() < neighborsMetric[1][1] && !m_Minimize)) { nb_WrongExtrema++; } } progress.CompletedPixel(); ++outHDispIt; ++outVDispIt; ++outMetricIt; if (useHorizontalDisparity) { ++inHDispIt; } if (useVerticalDisparity) { ++inVDispIt; } } ++leftIt; if(inLeftMaskPtr) { ++inLeftMaskIt; } } m_WrongExtrema[threadId] = static_cast(nb_WrongExtrema) / static_cast(outputRegionForThread.GetNumberOfPixels()); } template void SubPixelDisparityImageFilter ::DichotomyRefinement(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve pointers const TInputImage * inLeftPtr = this->GetLeftInput(); const TInputImage * inRightPtr = this->GetRightInput(); const TMaskImage * inLeftMaskPtr = this->GetLeftMaskInput(); const TMaskImage * inRightMaskPtr = this->GetRightMaskInput(); const TDisparityImage * inHDispPtr = this->GetHorizontalDisparityInput(); const TDisparityImage * inVDispPtr = this->GetVerticalDisparityInput(); TOutputMetricImage * outMetricPtr = this->GetMetricOutput(); TDisparityImage * outHDispPtr = this->GetHorizontalDisparityOutput(); TDisparityImage * outVDispPtr = this->GetVerticalDisparityOutput(); unsigned int nb_WrongExtrema = 0; // Set-up progress reporting (this is not exact, since we do not // account for pixels that won't be refined) itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels(),100); RegionType fullRegionForThread = BlockMatchingFilterType::ConvertSubsampledToFullRegion(outputRegionForThread, this->m_Step, this->m_GridIndex); itk::ConstNeighborhoodIterator leftIt(m_Radius,inLeftPtr,fullRegionForThread); itk::ImageRegionIterator outHDispIt(outHDispPtr,outputRegionForThread); itk::ImageRegionIterator outVDispIt(outVDispPtr,outputRegionForThread); itk::ImageRegionIterator outMetricIt(outMetricPtr,outputRegionForThread); itk::ImageRegionConstIterator inHDispIt; itk::ImageRegionConstIterator inVDispIt; itk::ImageRegionConstIterator inLeftMaskIt; itk::ImageRegionConstIterator inRightMaskIt; bool useHorizontalDisparity = false; bool useVerticalDisparity = false; if (inHDispPtr) { useHorizontalDisparity = true; inHDispIt = itk::ImageRegionConstIterator(inHDispPtr,outputRegionForThread); inHDispIt.GoToBegin(); } if (inVDispPtr) { useVerticalDisparity = true; inVDispIt = itk::ImageRegionConstIterator(inVDispPtr,outputRegionForThread); inVDispIt.GoToBegin(); } if(inLeftMaskPtr) { inLeftMaskIt = itk::ImageRegionConstIterator(inLeftMaskPtr,fullRegionForThread); inLeftMaskIt.GoToBegin(); } RegionType rightBufferedRegion = inRightPtr->GetBufferedRegion(); if(inRightMaskPtr) { RegionType inRightMaskRegion = inRightMaskPtr->GetBufferedRegion(); inRightMaskIt = itk::ImageRegionConstIterator(inRightMaskPtr,inRightMaskRegion); } itk::ConstantBoundaryCondition nbc1; leftIt.OverrideBoundaryCondition(&nbc1); leftIt.GoToBegin(); outHDispIt.GoToBegin(); outVDispIt.GoToBegin(); outMetricIt.GoToBegin(); /* Specific variables */ IndexType curLeftPos; IndexType curRightPos; float hDisp_f; float vDisp_f; int hDisp_i; int vDisp_i; typename TInputImage::Pointer fakeRightPtr = TInputImage::New(); fakeRightPtr->SetRegions(rightBufferedRegion); fakeRightPtr->SetPixelContainer((const_cast(inRightPtr))->GetPixelContainer()); // compute metric around current right position bool horizontalInterpolation = false; bool verticalInterpolation = false; // metrics for neighbors positions : first index is x, second is y double neighborsMetric[3][3] = {{0,0,0},{0,0,0},{0,0,0}}; unsigned int nbIterMax = 10; // set the output size and start index to the center position // then set the smaller shift in the transform IndexType upleftCorner; SizeType windowSize; windowSize[0] = 2 * m_Radius[0] + 1; windowSize[1] = 2 * m_Radius[1] + 1; TransformationType::Pointer transfo = TransformationType::New(); TransformationType::OutputVectorType offsetTransfo(2); offsetTransfo[0] = 0.0; offsetTransfo[1] = 0.0; typename ResamplerFilterType::Pointer resampler; // step value as disparityType DisparityPixelType stepDisparity = static_cast(this->m_Step); DisparityPixelType stepDisparityInv = 1. / stepDisparity; RegionType tinyShiftedRegion; tinyShiftedRegion.SetIndex(0, m_Radius[0]); tinyShiftedRegion.SetIndex(1, m_Radius[1]); tinyShiftedRegion.SetSize(0, 1); tinyShiftedRegion.SetSize(1, 1); // iterators on right image itk::ConstNeighborhoodIterator rightIt; itk::ConstNeighborhoodIterator shiftedIt; itk::ConstantBoundaryCondition nbc2; itk::ConstantBoundaryCondition nbc3; rightIt.OverrideBoundaryCondition(&nbc2); shiftedIt.OverrideBoundaryCondition(&nbc3); bool centreHasMoved; while (!leftIt.IsAtEnd() || !outHDispIt.IsAtEnd() || !outVDispIt.IsAtEnd() || !outMetricIt.IsAtEnd()) { // If the pixel location is on the subsampled grid curLeftPos = leftIt.GetIndex(); if (((curLeftPos[0] - this->m_GridIndex[0] + this->m_Step) % this->m_Step == 0) && ((curLeftPos[1] - this->m_GridIndex[1] + this->m_Step) % this->m_Step == 0)) { horizontalInterpolation = false; verticalInterpolation = false; /* compute estimated right position */ if (useHorizontalDisparity) { hDisp_f = static_cast(inHDispIt.Get()) * stepDisparity; hDisp_i = static_cast(vcl_floor(hDisp_f + 0.5)); curRightPos[0] = curLeftPos[0] + hDisp_i; } else { hDisp_i = 0; curRightPos[0] = curLeftPos[0]; } if (useVerticalDisparity) { vDisp_f = static_cast(inVDispIt.Get()) * stepDisparity; vDisp_i = static_cast(vcl_floor(vDisp_f + 0.5)); curRightPos[1] = curLeftPos[1] + vDisp_i; } else { vDisp_i = 0; curRightPos[1] = curLeftPos[1]; } // update resampler input position upleftCorner[0] = curRightPos[0] - m_Radius[0]; upleftCorner[1] = curRightPos[1] - m_Radius[1]; // resampler resampler = ResamplerFilterType::New(); resampler->SetInput(fakeRightPtr); resampler->SetSize(windowSize); resampler->SetNumberOfThreads(1); resampler->SetTransform(transfo); resampler->SetOutputStartIndex(upleftCorner); tinyShiftedRegion.SetIndex(0, curRightPos[0]); tinyShiftedRegion.SetIndex(1, curRightPos[1]); // check if the current right position is inside the right image if (rightBufferedRegion.IsInside(curRightPos)) { if (inRightMaskPtr) { // Set right mask iterator position inRightMaskIt.SetIndex(curRightPos); } // check that the current positions are not masked if(!inLeftMaskPtr || (inLeftMaskPtr && inLeftMaskIt.Get() > 0) ) { if(!inRightMaskPtr || (inRightMaskPtr && inRightMaskIt.Get() > 0) ) { RegionType smallRightRegion; smallRightRegion.SetIndex(0,curRightPos[0]-1); smallRightRegion.SetIndex(1,curRightPos[1]-1); smallRightRegion.SetSize(0,3); smallRightRegion.SetSize(1,3); rightIt.Initialize(m_Radius,inRightPtr,smallRightRegion); // compute metric at centre position rightIt.SetLocation(curRightPos); neighborsMetric[1][1] = m_Functor(leftIt,rightIt); if (m_MinimumVerticalDisparity < vDisp_i && vDisp_i < m_MaximumVerticalDisparity) { IndexType upIndex(curRightPos); upIndex[1]+= (-1); IndexType downIndex(curRightPos); downIndex[1]+= 1; if ( rightBufferedRegion.IsInside(upIndex) && rightBufferedRegion.IsInside(downIndex) ) { rightIt.SetLocation(upIndex); neighborsMetric[1][0] = m_Functor(leftIt,rightIt); rightIt.SetLocation(downIndex); neighborsMetric[1][2] = m_Functor(leftIt,rightIt); // check that current position is an extrema if (m_Minimize) { if (neighborsMetric[1][1] < neighborsMetric[1][0] && neighborsMetric[1][1] < neighborsMetric[1][2]) { verticalInterpolation = true; } } else { if (neighborsMetric[1][1] > neighborsMetric[1][0] && neighborsMetric[1][1] > neighborsMetric[1][2]) { verticalInterpolation = true; } } } } if (m_MinimumHorizontalDisparity < hDisp_i && hDisp_i < m_MaximumHorizontalDisparity) { IndexType leftIndex(curRightPos); leftIndex[0]+= (-1); IndexType rightIndex(curRightPos); rightIndex[0]+= 1; if ( rightBufferedRegion.IsInside(leftIndex) && rightBufferedRegion.IsInside(rightIndex) ) { rightIt.SetLocation(rightIndex); neighborsMetric[2][1] = m_Functor(leftIt,rightIt); rightIt.SetLocation(leftIndex); neighborsMetric[0][1] = m_Functor(leftIt,rightIt); // check that current position is an extrema if (m_Minimize) { if (neighborsMetric[1][1] < neighborsMetric[0][1] && neighborsMetric[1][1] < neighborsMetric[2][1]) { horizontalInterpolation = true; } } else { if (neighborsMetric[1][1] > neighborsMetric[0][1] && neighborsMetric[1][1] > neighborsMetric[2][1]) { horizontalInterpolation = true; } } } } // if both vertical and horizontal interpolation, compute metrics on corners if (verticalInterpolation && horizontalInterpolation) { IndexType uprightIndex(curRightPos); uprightIndex[0]+= 1; uprightIndex[1]+= (-1); rightIt.SetLocation(uprightIndex); neighborsMetric[2][0] = m_Functor(leftIt,rightIt); IndexType downrightIndex(curRightPos); downrightIndex[0]+= 1; downrightIndex[1]+= 1; rightIt.SetLocation(downrightIndex); neighborsMetric[2][2] = m_Functor(leftIt,rightIt); IndexType downleftIndex(curRightPos); downleftIndex[0]+= (-1); downleftIndex[1]+= 1; rightIt.SetLocation(downleftIndex); neighborsMetric[0][2] = m_Functor(leftIt,rightIt); IndexType upleftIndex(curRightPos); upleftIndex[0]+= (-1); upleftIndex[1]+= (-1); rightIt.SetLocation(upleftIndex); neighborsMetric[0][0] = m_Functor(leftIt,rightIt); //check that it is an extrema if (m_Minimize) { if (neighborsMetric[1][1] > neighborsMetric[2][0] || neighborsMetric[1][1] > neighborsMetric[2][2] || neighborsMetric[1][1] > neighborsMetric[0][2] || neighborsMetric[1][1] > neighborsMetric[0][0]) { verticalInterpolation = false; horizontalInterpolation = false; } } else { if (neighborsMetric[1][1] < neighborsMetric[2][0] || neighborsMetric[1][1] < neighborsMetric[2][2] || neighborsMetric[1][1] < neighborsMetric[0][2] || neighborsMetric[1][1] < neighborsMetric[0][0]) { verticalInterpolation = false; horizontalInterpolation = false; } } } } } } // Interpolate position : dichotomy if (verticalInterpolation && !horizontalInterpolation) { double ya = static_cast(vDisp_i -1); double yb = static_cast(vDisp_i); double yc = static_cast(vDisp_i +1); double s_yb = neighborsMetric[1][1]; double yd; double s_yd; offsetTransfo[0] = 0.0; for (unsigned int k=0; k(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_yd = m_Functor(leftIt,shiftedIt); if ((s_yds_yb && !m_Minimize)) { ya = yb; yb = yd; s_yb = s_yd; } else { yc = yd; } } else { yd = 0.5 * (ya+yb); offsetTransfo[1] = yd - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_yd = m_Functor(leftIt,shiftedIt); if ((s_yds_yb && !m_Minimize)) { yc = yb; yb = yd; s_yb = s_yd; } else { ya = yd; } } } outVDispIt.Set( yb * stepDisparityInv ); outMetricIt.Set( s_yb ); } else if (!verticalInterpolation && horizontalInterpolation) { double xa = static_cast(hDisp_i -1); double xb = static_cast(hDisp_i); double xc = static_cast(hDisp_i +1); double s_xb = neighborsMetric[1][1]; double xd; double s_xd; offsetTransfo[1] = 0.0; for (unsigned int k=0; k(hDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_xd = m_Functor(leftIt,shiftedIt); if ((s_xds_xb && !m_Minimize)) { xa = xb; xb = xd; s_xb = s_xd; } else { xc = xd; } } else { xd = 0.5 * (xa+xb); offsetTransfo[0] = xd - static_cast(hDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_xd = m_Functor(leftIt,shiftedIt); if ((s_xds_xb && !m_Minimize)) { xc = xb; xb = xd; s_xb = s_xd; } else { xa = xd; } } } outHDispIt.Set( xb * stepDisparityInv ); outMetricIt.Set( s_xb ); } else if (verticalInterpolation && horizontalInterpolation) { double xa = static_cast(hDisp_i); double ya = static_cast(vDisp_i - 1); double xb = static_cast(hDisp_i); double yb = static_cast(vDisp_i); double yc = static_cast(vDisp_i + 1); double xe = static_cast(hDisp_i - 1); double ye = static_cast(vDisp_i); double xf = static_cast(hDisp_i + 1); double s_b = neighborsMetric[1][1]; double xd = xb; double yd = yb; double s_d; for (unsigned int k=0; k(hDisp_i); offsetTransfo[1] = yd - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_d = m_Functor(leftIt,shiftedIt); if ((s_ds_b && !m_Minimize)) { centreHasMoved = true; ya = yb; yb = yd; s_b = s_d; } else { yc = yd; } } else { yd = 0.5 * (ya+yb); offsetTransfo[0] = xd - static_cast(hDisp_i); offsetTransfo[1] = yd - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_d = m_Functor(leftIt,shiftedIt); if ((s_ds_b && !m_Minimize)) { centreHasMoved = true; yc = yb; yb = yd; s_b = s_d; } else { ya = yd; } } if (centreHasMoved) { // update points e and f ye = yb; offsetTransfo[0] = xe - static_cast(hDisp_i); offsetTransfo[1] = ye - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); offsetTransfo[0] = xf - static_cast(hDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); } // Horizontal step centreHasMoved = false; if ( (xb-xe) < (xf-xb) ) { xd = 0.5 * (xf+xb); offsetTransfo[0] = xd - static_cast(hDisp_i); offsetTransfo[1] = yd - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_d = m_Functor(leftIt,shiftedIt); if ((s_ds_b && !m_Minimize)) { centreHasMoved = true; xe = xb; xb = xd; s_b = s_d; } else { xf = xd; } } else { xd = 0.5 * (xe+xb); offsetTransfo[0] = xd - static_cast(hDisp_i); offsetTransfo[1] = yd - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); s_d = m_Functor(leftIt,shiftedIt); if ((s_ds_b && !m_Minimize)) { centreHasMoved = true; xf = xb; xb = xd; s_b = s_d; } else { xe = xd; } } if (centreHasMoved) { // update a and c xa = xb; offsetTransfo[0] = xa - static_cast(hDisp_i); offsetTransfo[1] = ya - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); offsetTransfo[1] = yc - static_cast(vDisp_i); transfo->SetOffset(offsetTransfo); resampler->Modified(); resampler->Update(); shiftedIt.Initialize(m_Radius,resampler->GetOutput(),tinyShiftedRegion); } } outHDispIt.Set( xb * stepDisparityInv); outVDispIt.Set( yb * stepDisparityInv); outMetricIt.Set( s_b ); } if (!verticalInterpolation) { // No vertical interpolation done : simply copy the integer vertical disparity outVDispIt.Set( static_cast(vDisp_i) * stepDisparityInv); } if (!horizontalInterpolation) { // No horizontal interpolation done : simply copy the integer horizontal disparity outHDispIt.Set( static_cast(hDisp_i) * stepDisparityInv); } if (!verticalInterpolation && !horizontalInterpolation) { outMetricIt.Set(static_cast(neighborsMetric[1][1])); } else { if ((outMetricIt.Get() > neighborsMetric[1][1] && m_Minimize) || (outMetricIt.Get() < neighborsMetric[1][1] && !m_Minimize)) { nb_WrongExtrema++; } } progress.CompletedPixel(); ++outHDispIt; ++outVDispIt; ++outMetricIt; if (useHorizontalDisparity) { ++inHDispIt; } if (useVerticalDisparity) { ++inVDispIt; } } ++leftIt; if(inLeftMaskPtr) { ++inLeftMaskIt; } } m_WrongExtrema[threadId] = static_cast(nb_WrongExtrema) / static_cast(outputRegionForThread.GetNumberOfPixels()); } template void SubPixelDisparityImageFilter ::AfterThreadedGenerateData() { double wrongExtremaPercent = 0; for (unsigned int i=0; i ImageType; typedef itk::TranslationTransform TransformType; typedef TransformType::ParametersType ParametersType; typedef itk::PointSet PointSetType; typedef otb::DisparityMapEstimationMethod DMEstimationType; typedef itk::NormalizedCorrelationImageToImageMetric MetricType; typedef itk::LinearInterpolateImageFunction InterpolatorType; typedef itk::GradientDescentOptimizer OptimizerType; typedef otb::ImageFileReader ReaderType; typedef otb::ThresholdImageToPointSetFilter PointSetSourceType; typedef PointSetType::PointsContainer::Iterator PointSetIteratorType; typedef PointSetType::PointDataContainer::Iterator PointDataIteratorType; //Input images reading ReaderType::Pointer fixedReader = ReaderType::New(); ReaderType::Pointer movingReader = ReaderType::New(); ReaderType::Pointer pointSetReader = ReaderType::New(); fixedReader->SetFileName(fixedFileName); movingReader->SetFileName(movingFileName); pointSetReader->SetFileName(pointSetFileName); fixedReader->Update(); movingReader->Update(); pointSetReader->Update(); // Ajout typedef itk::MinimumMaximumImageCalculator MinMaxType; MinMaxType::Pointer mm = MinMaxType::New(); mm->SetImage(pointSetReader->GetOutput()); mm->ComputeMinimum(); mm->ComputeMaximum(); std::cout << "min: " << (int) mm->GetMinimum() << " max: " << (int) mm->GetMaximum() << std::endl; PointSetSourceType::Pointer pointSetSource = PointSetSourceType::New(); pointSetSource->SetLowerThreshold(mm->GetMaximum()); pointSetSource->SetUpperThreshold(mm->GetMaximum()); pointSetSource->SetInput(0, pointSetReader->GetOutput()); pointSetSource->Update(); std::cout << "PointSet size: " << pointSetSource->GetOutput()->GetPoints()->Size() << std::endl; // Instantiation DMEstimationType::Pointer dmestimator = DMEstimationType::New(); TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); MetricType::Pointer metric = MetricType::New(); // Set up dmestimator->SetTransform(transform); dmestimator->SetOptimizer(optimizer); dmestimator->SetInterpolator(interpolator); dmestimator->SetMetric(metric); // For gradient descent optimizer->SetLearningRate(5.0); optimizer->SetNumberOfIterations(600); DMEstimationType::ParametersType initialParameters(transform->GetNumberOfParameters()); initialParameters[0] = 0.0; // Initial offset in mm along X initialParameters[1] = 0.0; // Initial offset in mm along Y //Initial parameter set up // dmestimator->SetInitialTransformParameters(initialParameters); // inputs wiring ImageType::SizeType win, explo; win.Fill(winSize); explo.Fill(exploSize); dmestimator->SetFixedImage(fixedReader->GetOutput()); dmestimator->SetMovingImage(movingReader->GetOutput()); dmestimator->SetPointSet(pointSetSource->GetOutput()); dmestimator->SetWinSize(win); dmestimator->SetExploSize(explo); dmestimator->SetInitialTransformParameters(initialParameters); // Estimation trigger dmestimator->Update(); // Point set retrieving PointSetType::Pointer pointSet = dmestimator->GetOutput(); // Writing output transform parameters std::ofstream out; out.open(outputFileName, std::ios::out); out.setf(std::ios::fixed); // out.setprecision(10); PointSetIteratorType it = pointSet->GetPoints()->Begin(); // unsigned int idData=0; PointDataIteratorType itData = pointSet->GetPointData()->Begin(); std::cout << "Point data size: " << pointSet->GetPointData()->Size() << std::endl; for (; it != pointSet->GetPoints()->End() && itData != pointSet->GetPointData()->End(); ++it, ++itData) { out << "Point " << it.Value() << " -> transform parameters: "; out << itData.Value(); out << std::endl; } out.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbDisparityMapEstimationMethodNew.cxx000066400000000000000000000027451301006202600326040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDisparityMapEstimationMethod.h" #include "otbImage.h" #include "itkTranslationTransform.h" int otbDisparityMapEstimationMethodNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char PixelType; typedef otb::Image ImageType; typedef itk::TranslationTransform TransformType; typedef TransformType::ParametersType ParametersType; typedef itk::PointSet PointSetType; typedef otb::DisparityMapEstimationMethod DMEstimationType; // Instantiation DMEstimationType::Pointer dmestimator = DMEstimationType::New(); std::cout << dmestimator << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbDisparityMapMedianFilter.cxx000066400000000000000000000045441301006202600312170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDisparityMapMedianFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStandardWriterWatcher.h" const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image FloatImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter FloatWriterType; typedef otb::DisparityMapMedianFilter DisparityMapMedianFilterType; int otbDisparityMapMedianFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation DisparityMapMedianFilterType::Pointer filter = DisparityMapMedianFilterType::New(); return EXIT_SUCCESS; } int otbDisparityMapMedianFilter(int argc, char* argv[]) { if ((argc != 5) && (argc != 6)) { std::cerr << "Usage: " << argv[0] << " hdispinput_fname output_fname radius incoherencethres (maskinput_fname) "; return EXIT_FAILURE; } // Instantiation DisparityMapMedianFilterType::Pointer filter = DisparityMapMedianFilterType::New(); ReaderType::Pointer imgReader = ReaderType::New(); imgReader->SetFileName(argv[1]); filter->SetInput(imgReader->GetOutput()); filter->SetRadius(atoi(argv[3])); filter->SetIncoherenceThreshold(atof(argv[4])); ReaderType::Pointer maskReader = ReaderType::New(); if (argc > 5) { maskReader->SetFileName(argv[5]); filter->SetMaskInput(maskReader->GetOutput()); } FloatWriterType::Pointer writer = FloatWriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); otb::StandardWriterWatcher watcher1(writer, filter, "filtering"); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbDisparityMapTestDriver.cxx000066400000000000000000000021101301006202600307320ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbDisparityMapEstimationMethod); REGISTER_TEST(otbDisparityMapToDEMFilterNew); REGISTER_TEST(otbDisparityMapToDEMFilter); REGISTER_TEST(otbDisparityMapMedianFilterNew); REGISTER_TEST(otbDisparityMapMedianFilter); REGISTER_TEST(otbDisparityTranslateFilterNew); REGISTER_TEST(otbDisparityTranslateFilter); REGISTER_TEST(otbSubPixelDisparityImageFilterNew); REGISTER_TEST(otbSubPixelDisparityImageFilter); REGISTER_TEST(otbDisparityMapEstimationMethodNew); REGISTER_TEST(otbDisparityMapTo3DFilterNew); REGISTER_TEST(otbDisparityMapTo3DFilter); REGISTER_TEST(otbMultiDisparityMapTo3DFilterNew); REGISTER_TEST(otbMultiDisparityMapTo3DFilter); REGISTER_TEST(otbFineRegistrationImageFilterNew); REGISTER_TEST(otbFineRegistrationImageFilterTest); REGISTER_TEST(otbNCCRegistrationFilter); REGISTER_TEST(otbNCCRegistrationFilterNew); REGISTER_TEST(otbPixelWiseBlockMatchingImageFilter); REGISTER_TEST(otbPixelWiseBlockMatchingImageFilterNew); REGISTER_TEST(otbPixelWiseBlockMatchingImageFilterNCC); } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbDisparityMapTo3DFilter.cxx000066400000000000000000000070451301006202600305720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDisparityMapTo3DFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToImageListFilter.h" typedef otb::Image FloatImageType; typedef otb::VectorImage FloatVectorImageType; typedef otb::DisparityMapTo3DFilter StereoFilterType; int otbDisparityMapTo3DFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv) []) { // Instantiation StereoFilterType::Pointer filter = StereoFilterType::New(); return EXIT_SUCCESS; } int otbDisparityMapTo3DFilter(int argc, char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorToListFilterType; if (argc < 7) { std::cout << "Usage: "<SetFileName(argv[1]); ReaderType::Pointer leftReader = ReaderType::New(); leftReader->SetFileName(argv[2]); leftReader->UpdateOutputInformation(); ReaderType::Pointer rightReader = ReaderType::New(); rightReader->SetFileName(argv[3]); rightReader->UpdateOutputInformation(); ReaderVectorType::Pointer leftGridReader = ReaderVectorType::New(); leftGridReader->SetFileName(argv[4]); ReaderVectorType::Pointer rightGridReader = ReaderVectorType::New(); rightGridReader->SetFileName(argv[5]); ReaderType::Pointer maskReader = ReaderType::New(); if (argc == 8) { maskReader->SetFileName(argv[7]); } VectorToListFilterType::Pointer vectorToListFilter = VectorToListFilterType::New(); vectorToListFilter->SetInput(dispReader->GetOutput()); vectorToListFilter->UpdateOutputInformation(); StereoFilterType::Pointer filter = StereoFilterType::New(); filter->SetHorizontalDisparityMapInput(vectorToListFilter->GetOutput()->GetNthElement(0)); filter->SetVerticalDisparityMapInput(vectorToListFilter->GetOutput()->GetNthElement(1)); filter->SetLeftKeywordList(leftReader->GetOutput()->GetImageKeywordlist()); filter->SetRightKeywordList(rightReader->GetOutput()->GetImageKeywordlist()); filter->SetLeftEpipolarGridInput(leftGridReader->GetOutput()); filter->SetRightEpipolarGridInput(rightGridReader->GetOutput()); if (argc == 8) { filter->SetDisparityMaskInput(maskReader->GetOutput()); } WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[6]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbDisparityMapToDEMFilter.cxx000066400000000000000000000103511301006202600307230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDisparityMapToDEMFilter.h" #include "otbImageFileWriter.h" #include "otbStandardWriterWatcher.h" #include "otbImageFileReader.h" #include "otbImageList.h" #include "otbVectorImageToImageListFilter.h" const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image FloatImageType; typedef unsigned char MaskPixelType; typedef otb::Image MaskImageType; typedef otb::VectorImage FloatVectorImageType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorImageToListFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader MaskReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::DisparityMapToDEMFilter DisparityToElevationFilterType; int otbDisparityMapToDEMFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation DisparityToElevationFilterType::Pointer filter = DisparityToElevationFilterType::New(); return EXIT_SUCCESS; } int otbDisparityMapToDEMFilter(int argc, char* argv[]) { if ((argc != 11) && (argc != 12)) { std::cerr << "Usage: " << argv[0]; std::cerr << " dispinput_fname sensorleftinput_fname sensorrighttinput_fname gridleftinput_fname gridrightinput_fname" << std::endl; std::cerr << " outputDEM_filename " << std::endl; std::cerr << " elevmin elevmax avgelev DEMgridstep (maskinput_fname) " << std::endl; return EXIT_FAILURE; } DisparityToElevationFilterType::Pointer filter = DisparityToElevationFilterType::New(); VectorImageToListFilterType::Pointer vectorToList = VectorImageToListFilterType::New(); ReaderType::Pointer dispReader = ReaderType::New(); dispReader->SetFileName(argv[1]); vectorToList->SetInput(dispReader->GetOutput()); vectorToList->UpdateOutputInformation(); ReaderType::Pointer sensorLeftReader = ReaderType::New(); sensorLeftReader->SetFileName(argv[2]); ReaderType::Pointer sensorRightReader = ReaderType::New(); sensorRightReader->SetFileName(argv[3]); ReaderType::Pointer gridLeftReader = ReaderType::New(); gridLeftReader->SetFileName(argv[4]); ReaderType::Pointer gridRightReader = ReaderType::New(); gridRightReader->SetFileName(argv[5]); filter->SetHorizontalDisparityMapInput(vectorToList->GetOutput()->GetNthElement(0)); filter->SetVerticalDisparityMapInput(vectorToList->GetOutput()->GetNthElement(1)); filter->SetLeftInput(sensorLeftReader->GetOutput()); filter->SetRightInput(sensorRightReader->GetOutput()); filter->SetLeftEpipolarGridInput(gridLeftReader->GetOutput()); filter->SetRightEpipolarGridInput(gridRightReader->GetOutput()); filter->SetElevationMin(atof(argv[7])); filter->SetElevationMax(atof(argv[8])); filter->SetDEMGridStep(atof(argv[10])); otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(atof(argv[9])); MaskReaderType::Pointer maskReader; if (argc == 12) { maskReader = MaskReaderType::New(); maskReader->SetFileName(argv[11]); filter->SetDisparityMaskInput(maskReader->GetOutput()); } WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[6]); otb::StandardWriterWatcher watcher(writer, filter, "disparity to DEM "); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbDisparityTranslateFilter.cxx000066400000000000000000000072531301006202600313210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbDisparityTranslateFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToImageListFilter.h" #include "otbImageListToVectorImageFilter.h" typedef otb::Image FloatImageType; typedef otb::VectorImage FloatVectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter WriterScalarType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorToListFilterType; typedef otb::ImageListToVectorImageFilter ListToVectorFilterType; typedef otb::DisparityTranslateFilter TranslateFilter; int otbDisparityTranslateFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation TranslateFilter::Pointer filter = TranslateFilter::New(); return EXIT_SUCCESS; } int otbDisparityTranslateFilter(int argc, char* argv[]) { if (argc < 6) { std::cout << "Usage: "<SetFileName(argv[1]); ReaderVectorType::Pointer leftGridReader = ReaderVectorType::New(); leftGridReader->SetFileName(argv[2]); ReaderVectorType::Pointer rightGridReader = ReaderVectorType::New(); rightGridReader->SetFileName(argv[3]); ReaderType::Pointer leftSensor = ReaderType::New(); leftSensor->SetFileName(argv[4]); VectorToListFilterType::Pointer vectorToListFilter = VectorToListFilterType::New(); vectorToListFilter->SetInput(dispReader->GetOutput()); vectorToListFilter->UpdateOutputInformation(); TranslateFilter::Pointer translator = TranslateFilter::New(); translator->SetHorizontalDisparityMapInput(vectorToListFilter->GetOutput()->GetNthElement(0)); translator->SetVerticalDisparityMapInput(vectorToListFilter->GetOutput()->GetNthElement(1)); translator->SetInverseEpipolarLeftGrid(leftGridReader->GetOutput()); translator->SetDirectEpipolarRightGrid(rightGridReader->GetOutput()); translator->SetLeftSensorImageInput(leftSensor->GetOutput()); ImageListType::Pointer outputList = ImageListType::New(); outputList->PushBack(translator->GetHorizontalDisparityMapOutput()); outputList->PushBack(translator->GetVerticalDisparityMapOutput()); ListToVectorFilterType::Pointer listToVectorFilter = ListToVectorFilterType::New(); listToVectorFilter->SetInput(outputList); WriterType::Pointer writer = WriterType::New(); writer->SetInput(listToVectorFilter->GetOutput()); writer->SetFileName(argv[5]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbFineRegistrationImageFilterNew.cxx000066400000000000000000000025161301006202600323610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "itkFixedArray.h" #include "otbFineRegistrationImageFilter.h" int otbFineRegistrationImageFilterNew( int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef double PixelType; const unsigned int Dimension = 2; typedef itk::FixedArray DisplacementValueType; typedef otb::Image< PixelType> ImageType; typedef otb::Image FieldImageType; typedef otb::FineRegistrationImageFilter RegistrationFilterType; RegistrationFilterType::Pointer filter = RegistrationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbFineRegistrationImageFilterTest.cxx000066400000000000000000000143341301006202600325500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkFixedArray.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbFineRegistrationImageFilter.h" #include "otbStandardFilterWatcher.h" #include "itkTimeProbe.h" #include "otbExtractROI.h" #include "itkNormalizedCorrelationImageToImageMetric.h" #include "itkMeanReciprocalSquareDifferenceImageToImageMetric.h" #include "itkMeanSquaresImageToImageMetric.h" int otbFineRegistrationImageFilterTest( int argc, char * argv[] ) { if(argc!=16) { std::cerr<<"Usage: "< DisplacementValueType; typedef otb::Image< PixelType, Dimension > ImageType; typedef otb::Image FieldImageType; typedef otb::ImageFileReader< ImageType > ReaderType; typedef otb::ImageFileWriter< ImageType > CorrelWriterType; typedef otb::ImageFileWriter< FieldImageType> FieldWriterType; typedef otb::ExtractROI ExtractFiltertype; typedef otb::FineRegistrationImageFilter RegistrationFilterType; ReaderType::Pointer freader = ReaderType::New(); freader->SetFileName(fixedFileName); //freader->Update(); ReaderType::Pointer mreader = ReaderType::New(); mreader->SetFileName(movingFileName); //mreader->Update(); ExtractFiltertype::Pointer fextract = ExtractFiltertype::New(); fextract->SetInput(freader->GetOutput()); fextract->SetStartX(startX); fextract->SetStartY(startY); fextract->SetSizeX(sizeX); fextract->SetSizeY(sizeY); ExtractFiltertype::Pointer mextract = ExtractFiltertype::New(); mextract->SetInput(mreader->GetOutput()); mextract->SetStartX(startX); mextract->SetStartY(startY); mextract->SetSizeX(sizeX); mextract->SetSizeY(sizeY); RegistrationFilterType::Pointer registration = RegistrationFilterType::New(); registration->SetFixedInput(/*freader*/fextract->GetOutput()); registration->SetMovingInput(/*mreader*/mextract->GetOutput()); registration->SetRadius(radius); registration->SetSearchRadius(sradius); registration->SetConvergenceAccuracy(precision); registration->SetGridStep(gridStep); RegistrationFilterType::SpacingType offset; offset[0] = offsetx; offset[1] = offsety; registration->SetInitialOffset(offset); switch(metric) { case 0: { std::cout<<"Metric: correlation"< NCCType; NCCType::Pointer metricPtr = NCCType::New(); metricPtr->SubtractMeanOff(); registration->SetMetric(metricPtr); registration->MinimizeOn(); break; } case 1: { std::cout<<"Metric: normalized correlation"< NCCType; NCCType::Pointer metricPtr = NCCType::New(); metricPtr->SubtractMeanOn(); registration->SetMetric(metricPtr); registration->MinimizeOn(); break; } case 2: { std::cout<<"Metric: mean squares"< MeanSquareType; MeanSquareType::Pointer metricPtr = MeanSquareType::New(); registration->SetMetric(metricPtr); registration->MinimizeOn(); break; } case 3: { std::cout<<"Metric: mean reciprocal square difference"< MRSDType; MRSDType::Pointer metricPtr = MRSDType::New(); registration->SetMetric(metricPtr); registration->MinimizeOff(); break; } default: { std::cerr<<"Metric id should be between 0 and 3"<Update(); chrono.Stop(); std::cout<SetFileName(correlFileName); correlWriter->SetInput(registration->GetOutput()); correlWriter->SetNumberOfDivisionsStrippedStreaming(2); correlWriter->Update(); FieldWriterType::Pointer fieldWriter = FieldWriterType::New(); fieldWriter->SetFileName(fieldFileName); fieldWriter->SetInput(registration->GetOutputDisplacementField()); fieldWriter->SetNumberOfDivisionsStrippedStreaming(2); fieldWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbMultiDisparityMapTo3DFilter.cxx000066400000000000000000000106171301006202600316040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMultiDisparityMapTo3DFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToImageListFilter.h" typedef otb::Image FloatImageType; typedef otb::VectorImage FloatVectorImageType; typedef otb::MultiDisparityMapTo3DFilter Multi3DFilterType; int otbMultiDisparityMapTo3DFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation Multi3DFilterType::Pointer multiFilter = Multi3DFilterType::New(); return EXIT_SUCCESS; } int otbMultiDisparityMapTo3DFilter(int argc, char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter WriterScalarType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorToListFilterType; if (argc < 10) { std::cout << "Usage: "<SetFileName(argv[1]); masterReader->UpdateOutputInformation(); ReaderType::Pointer slave1Reader = ReaderType::New(); slave1Reader->SetFileName(argv[2]); slave1Reader->UpdateOutputInformation(); ReaderType::Pointer slave2Reader = ReaderType::New(); slave2Reader->SetFileName(argv[3]); slave2Reader->UpdateOutputInformation(); ReaderVectorType::Pointer disp1Reader = ReaderVectorType::New(); disp1Reader->SetFileName(argv[4]); ReaderVectorType::Pointer disp2Reader = ReaderVectorType::New(); disp2Reader->SetFileName(argv[5]); ReaderType::Pointer mask1Reader = ReaderType::New(); mask1Reader->SetFileName(argv[6]); ReaderType::Pointer mask2Reader = ReaderType::New(); mask2Reader->SetFileName(argv[7]); VectorToListFilterType::Pointer vectorToListFilter1 = VectorToListFilterType::New(); vectorToListFilter1->SetInput(disp1Reader->GetOutput()); vectorToListFilter1->UpdateOutputInformation(); VectorToListFilterType::Pointer vectorToListFilter2 = VectorToListFilterType::New(); vectorToListFilter2->SetInput(disp2Reader->GetOutput()); vectorToListFilter2->UpdateOutputInformation(); Multi3DFilterType::Pointer multiFilter = Multi3DFilterType::New(); multiFilter->SetReferenceKeywordList(masterReader->GetOutput()->GetImageKeywordlist()); multiFilter->SetNumberOfMovingImages(2); multiFilter->SetHorizontalDisparityMapInput(0,vectorToListFilter1->GetOutput()->GetNthElement(0)); multiFilter->SetVerticalDisparityMapInput(0,vectorToListFilter1->GetOutput()->GetNthElement(1)); multiFilter->SetDisparityMaskInput(0,mask1Reader->GetOutput()); multiFilter->SetMovingKeywordList(0,slave1Reader->GetOutput()->GetImageKeywordlist()); multiFilter->SetHorizontalDisparityMapInput(1,vectorToListFilter2->GetOutput()->GetNthElement(0)); multiFilter->SetVerticalDisparityMapInput(1,vectorToListFilter2->GetOutput()->GetNthElement(1)); multiFilter->SetDisparityMaskInput(1,mask2Reader->GetOutput()); multiFilter->SetMovingKeywordList(1,slave2Reader->GetOutput()->GetImageKeywordlist()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(multiFilter->GetOutput()); writer->SetFileName(argv[8]); writer->Update(); WriterScalarType::Pointer writer2 = WriterScalarType::New(); writer2->SetInput(multiFilter->GetResidueOutput()); writer2->SetFileName(argv[9]); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbNCCRegistrationFilter.cxx000066400000000000000000000057141301006202600304710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileWriter.h" #include "otbImageFileReader.h" #include "otbNCCRegistrationFilter.h" #include "itkRecursiveGaussianImageFilter.h" int otbNCCRegistrationFilter(int argc, char* argv[]) { if (argc != 7) { std::cerr << "Usage: " << argv[0]; std::cerr << " fixedFileName movingFileName fieldOutName"; std::cerr << "explorationSize bluringSigma nbIterations "; return EXIT_FAILURE; } const unsigned int ImageDimension = 2; typedef double PixelType; typedef itk::Vector DisplacementPixelType; typedef otb::Image MovingImageType; typedef otb::Image FixedImageType; typedef otb::Image DisplacementFieldType; typedef otb::ImageFileReader FixedReaderType; FixedReaderType::Pointer fReader = FixedReaderType::New(); fReader->SetFileName(argv[1]); typedef otb::ImageFileReader MovingReaderType; MovingReaderType::Pointer mReader = MovingReaderType::New(); mReader->SetFileName(argv[2]); typedef itk::RecursiveGaussianImageFilter FixedBlurType; FixedBlurType::Pointer fBlur = FixedBlurType::New(); fBlur->SetInput(fReader->GetOutput()); fBlur->SetSigma(atof(argv[5])); typedef itk::RecursiveGaussianImageFilter MovingBlurType; MovingBlurType::Pointer mBlur = MovingBlurType::New(); mBlur->SetInput(mReader->GetOutput()); mBlur->SetSigma(atof(argv[5])); typedef otb::NCCRegistrationFilter RegistrationFilterType; RegistrationFilterType::Pointer registrator = RegistrationFilterType::New(); registrator->SetMovingImage(mBlur->GetOutput()); registrator->SetFixedImage(fBlur->GetOutput()); typedef RegistrationFilterType::RadiusType RadiusType; RadiusType radius; radius[0] = atoi(argv[4]); radius[1] = atoi(argv[4]); registrator->SetNCCRadius(radius); registrator->SetNumberOfIterations(atoi(argv[6])); typedef otb::ImageFileWriter DFWriterType; DFWriterType::Pointer dfWriter = DFWriterType::New(); dfWriter->SetFileName(argv[3]); dfWriter->SetInput(registrator->GetOutput()); dfWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbNCCRegistrationFilterNew.cxx000066400000000000000000000026241301006202600311400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbNCCRegistrationFilter.h" #include "otbImage.h" int otbNCCRegistrationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int ImageDimension = 2; typedef double PixelType; typedef itk::Vector DisplacementPixelType; //Allocate Images typedef otb::Image MovingImageType; typedef otb::Image FixedImageType; typedef otb::Image DisplacementFieldType; //Create the filter typedef otb::NCCRegistrationFilter RegistrationFilterType; // Instantiation RegistrationFilterType::Pointer filter = RegistrationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbPixelWiseBlockMatchingImageFilter.cxx000066400000000000000000000104771301006202600327770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbPixelWiseBlockMatchingImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStandardWriterWatcher.h" typedef otb::Image ImageType; typedef otb::Image FloatImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter FloatWriterType; typedef otb::PixelWiseBlockMatchingImageFilter PixelWiseBlockMatchingImageFilterType; typedef otb::Functor::NCCBlockMatching NCCBlockMatchingFunctorType; typedef otb::PixelWiseBlockMatchingImageFilter PixelWiseNCCBlockMatchingImageFilterType; int otbPixelWiseBlockMatchingImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation PixelWiseBlockMatchingImageFilterType::Pointer bmFilter = PixelWiseBlockMatchingImageFilterType::New(); return EXIT_SUCCESS; } int otbPixelWiseBlockMatchingImageFilter(int argc, char * argv[]) { ReaderType::Pointer leftReader = ReaderType::New(); leftReader->SetFileName(argv[1]); ReaderType::Pointer rightReader = ReaderType::New(); rightReader->SetFileName(argv[2]); PixelWiseBlockMatchingImageFilterType::Pointer bmFilter = PixelWiseBlockMatchingImageFilterType::New(); bmFilter->SetLeftInput(leftReader->GetOutput()); bmFilter->SetRightInput(rightReader->GetOutput()); bmFilter->SetRadius(atoi(argv[5])); bmFilter->SetMinimumHorizontalDisparity(atoi(argv[6])); bmFilter->SetMaximumHorizontalDisparity(atoi(argv[7])); ReaderType::Pointer maskReader = ReaderType::New(); if(argc > 8) { maskReader->SetFileName(argv[8]); bmFilter->SetLeftMaskInput(maskReader->GetOutput()); } FloatWriterType::Pointer dispWriter = FloatWriterType::New(); dispWriter->SetInput(bmFilter->GetHorizontalDisparityOutput()); dispWriter->SetFileName(argv[3]); otb::StandardWriterWatcher watcher1(dispWriter,bmFilter,"Computing disparity map"); dispWriter->Update(); FloatWriterType::Pointer metricWriter = FloatWriterType::New(); metricWriter->SetInput(bmFilter->GetMetricOutput()); metricWriter->SetFileName(argv[4]); otb::StandardWriterWatcher watcher2(metricWriter,bmFilter,"Computing metric map"); metricWriter->Update(); return EXIT_SUCCESS; } int otbPixelWiseBlockMatchingImageFilterNCC(int argc, char * argv[]) { ReaderType::Pointer leftReader = ReaderType::New(); leftReader->SetFileName(argv[1]); ReaderType::Pointer rightReader = ReaderType::New(); rightReader->SetFileName(argv[2]); PixelWiseNCCBlockMatchingImageFilterType::Pointer bmFilter = PixelWiseNCCBlockMatchingImageFilterType::New(); bmFilter->SetLeftInput(leftReader->GetOutput()); bmFilter->SetRightInput(rightReader->GetOutput()); bmFilter->SetRadius(atoi(argv[5])); bmFilter->SetMinimumHorizontalDisparity(atoi(argv[6])); bmFilter->SetMaximumHorizontalDisparity(atoi(argv[7])); bmFilter->MinimizeOff(); ReaderType::Pointer maskReader = ReaderType::New(); if(argc > 8) { maskReader->SetFileName(argv[8]); bmFilter->SetLeftMaskInput(maskReader->GetOutput()); } FloatWriterType::Pointer dispWriter = FloatWriterType::New(); dispWriter->SetInput(bmFilter->GetHorizontalDisparityOutput()); dispWriter->SetFileName(argv[3]); otb::StandardWriterWatcher watcher1(dispWriter,bmFilter,"Computing disparity map"); dispWriter->Update(); FloatWriterType::Pointer metricWriter = FloatWriterType::New(); metricWriter->SetInput(bmFilter->GetMetricOutput()); metricWriter->SetFileName(argv[4]); otb::StandardWriterWatcher watcher2(metricWriter,bmFilter,"Computing metric map"); metricWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisparityMap/test/otbSubPixelDisparityImageFilter.cxx000066400000000000000000000165071301006202600320640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbSubPixelDisparityImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStandardWriterWatcher.h" #include "otbImage.h" const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image FloatImageType; typedef otb::Functor::NCCBlockMatching NCCBlockMatchingFunctorType; typedef otb::SubPixelDisparityImageFilter NCCSubPixelDisparityFilterType; typedef otb::Functor::SSDBlockMatching SSDBlockMatchingFunctorType; typedef otb::SubPixelDisparityImageFilter SSDSubPixelDisparityFilterType; typedef otb::Functor::LPBlockMatching LPBlockMatchingFunctorType; typedef otb::SubPixelDisparityImageFilter LPSubPixelDisparityFilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; int otbSubPixelDisparityImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation SSDSubPixelDisparityFilterType::Pointer filter = SSDSubPixelDisparityFilterType::New(); return EXIT_SUCCESS; } template int ProcessAndWriteOutput(otb::SubPixelDisparityImageFilter * subPixFilter,int argc,char* argv[]) { ReaderType::Pointer leftReader = ReaderType::New(); leftReader->SetFileName(argv[1]); ReaderType::Pointer rightReader = ReaderType::New(); rightReader->SetFileName(argv[2]); ReaderType::Pointer bmhdispReader = ReaderType::New(); bmhdispReader->SetFileName(argv[3]); // ReaderType::Pointer bmvdispReader = ReaderType::New(); // bmvdispReader->SetFileName(argv[3]); ReaderType::Pointer metricReader = ReaderType::New(); metricReader->SetFileName(argv[4]); // subPixFilter->SetVerticalDisparityInput(bmvdispReader->GetVerticalDisparityOutput()); subPixFilter->SetLeftInput(leftReader->GetOutput()); subPixFilter->SetRightInput(rightReader->GetOutput()); subPixFilter->SetHorizontalDisparityInput(bmhdispReader->GetOutput()); subPixFilter->SetRadius(atoi(argv[10])); subPixFilter->SetMinimumHorizontalDisparity(atoi(argv[11])); subPixFilter->SetMaximumHorizontalDisparity(atoi(argv[12])); subPixFilter->SetMinimumVerticalDisparity(atoi(argv[13])); subPixFilter->SetMaximumVerticalDisparity(atoi(argv[14])); subPixFilter->SetMetricInput(metricReader->GetOutput()); ReaderType::Pointer leftMaskReader = ReaderType::New(); ReaderType::Pointer rightMaskReader = ReaderType::New(); if (argc > 15) { leftMaskReader->SetFileName(argv[15]); subPixFilter->SetLeftMaskInput(leftMaskReader->GetOutput()); } if (argc > 16) { rightMaskReader->SetFileName(argv[16]); subPixFilter->SetRightMaskInput(rightMaskReader->GetOutput()); } switch (atoi(argv[9])) { case 1: subPixFilter->SetRefineMethod(NCCSubPixelDisparityFilterType::PARABOLIC); break; case 2: subPixFilter->SetRefineMethod(NCCSubPixelDisparityFilterType::TRIANGULAR); break; case 3: subPixFilter->SetRefineMethod(NCCSubPixelDisparityFilterType::DICHOTOMY); break; default: std::cout << "wrong pixel mode" << std::endl; return EXIT_FAILURE; break; } otb::StandardWriterWatcher watcher(subPixFilter, "Sub-pixel refinement"); // writers // horizontal disparity writer WriterType::Pointer hdispWriter = WriterType::New(); hdispWriter->SetInput(subPixFilter->GetHorizontalDisparityOutput()); hdispWriter->SetFileName(argv[5]); otb::StandardWriterWatcher watcher1(hdispWriter, subPixFilter, "Computing disparity "); hdispWriter->Update(); // vertical disparity writer WriterType::Pointer vdispWriter = WriterType::New(); vdispWriter->SetInput(subPixFilter->GetVerticalDisparityOutput()); vdispWriter->SetFileName(argv[6]); vdispWriter->Update(); // metric writer // vertical disparity writer WriterType::Pointer metricWriter = WriterType::New(); metricWriter->SetInput(subPixFilter->GetMetricOutput()); metricWriter->SetFileName(argv[7]); metricWriter->Update(); return EXIT_SUCCESS; } int otbSubPixelDisparityImageFilter(int argc, char* argv[]) { if ((argc < 15) || (argc > 17)) { std::cerr << "Usage: " << argv[0] << " leftinput_fname rightinput_fname blockmatchinginput_fname blockmatchingmetricinput_fname "; std::cerr << "hdispoutput_fname vdispoutput_fname metricoutput_fname " << std::endl; std::cerr << "metric (0=SSD, 1=NCC, 2=LP pseudo norm) "; std::cerr << "subpixelmode (1=parabolic,2=triangular,3=dichotomy)" << std::endl; std::cerr << "radius minhdisp maxhdisp minvdisp maxvdisp " << std::endl; std::cerr << "(leftmaskinput_fname) (rightmaskinput_fname)" << std::endl; return EXIT_FAILURE; } SSDSubPixelDisparityFilterType::Pointer SSDSubPixFilter = SSDSubPixelDisparityFilterType::New(); NCCSubPixelDisparityFilterType::Pointer NCCSubPixFilter = NCCSubPixelDisparityFilterType::New(); LPSubPixelDisparityFilterType::Pointer LPSubPixFilter = LPSubPixelDisparityFilterType::New(); // Instantiation switch (atoi(argv[8])) { case 0: SSDSubPixFilter->MinimizeOn(); return ProcessAndWriteOutput (SSDSubPixFilter, argc, argv); break; case 1: NCCSubPixFilter->MinimizeOff(); return ProcessAndWriteOutput (NCCSubPixFilter, argc, argv); break; case 2: LPSubPixFilter->MinimizeOff(); return ProcessAndWriteOutput (LPSubPixFilter, argc, argv); break; default: std::cout << "wrong norm type (0=SSD, 1=NCC, 2=LP pseudo norm)" << std::endl; return EXIT_FAILURE; break; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Registration/DisplacementField/000077500000000000000000000000001301006202600230545ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/CMakeLists.txt000066400000000000000000000000601301006202600256100ustar00rootroot00000000000000project(OTBDisplacementField) otb_module_impl() OTB-release-5.8/Modules/Registration/DisplacementField/include/000077500000000000000000000000001301006202600244775ustar00rootroot00000000000000otbBSplinesInterpolateDisplacementFieldGenerator.h000066400000000000000000000063401301006202600363730ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSplinesInterpolateDisplacementFieldGenerator_h #define otbBSplinesInterpolateDisplacementFieldGenerator_h #include "otbPointSetToDisplacementFieldGenerator.h" namespace otb { /** \class BSplinesInterpolateDisplacementFieldGenerator * \brief This filters encapsulate the itk::DisplacementFieldSource to produce a BSpline interpolation of the point in point set whose metric values are * sufficient. * \sa itk::DisplacementFieldSource * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ template class ITK_EXPORT BSplinesInterpolateDisplacementFieldGenerator : public PointSetToDisplacementFieldGenerator { public: /** Standard typedefs */ typedef BSplinesInterpolateDisplacementFieldGenerator Self; typedef PointSetToDisplacementFieldGenerator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(BSplinesInterpolateDisplacementFieldGenerator, PointSetToDisplacementFieldGenerator); /** Template parameters typedefs */ typedef typename Superclass::PointSetType PointSetType; typedef typename Superclass::PointSetPointerType PointSetPointerType; typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldPointerType DisplacementFieldPointerType; typedef typename Superclass::IndexType IndexType; typedef typename DisplacementFieldType::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::PointType PointType; typedef typename Superclass::IndexVectorType IndexVectorType; typedef typename Superclass::DistanceVectorType DistanceVectorType; protected: /** Constructor */ BSplinesInterpolateDisplacementFieldGenerator() {}; /** Destructor */ ~BSplinesInterpolateDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; private: BSplinesInterpolateDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBSplinesInterpolateDisplacementFieldGenerator.txx" #endif #endif otbBSplinesInterpolateDisplacementFieldGenerator.txx000066400000000000000000000120211301006202600367600ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSplinesInterpolateDisplacementFieldGenerator_txx #define otbBSplinesInterpolateDisplacementFieldGenerator_txx #include "otbBSplinesInterpolateDisplacementFieldGenerator.h" // Disabling deprecation warning if on visual #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable:4996) #endif #include "itkLandmarkDisplacementFieldSource.h" // Enabling remaining deprecation warning #ifdef _MSC_VER #pragma warning(pop) #endif #include "otbMacro.h" #include "otbImage.h" #include "itkImageRegionIterator.h" namespace otb { /** Main computation method */ template void BSplinesInterpolateDisplacementFieldGenerator ::GenerateData(void) { DisplacementFieldPointerType outputPtr = this->GetOutput(); typedef itk::Vector VectorType; typedef otb::Image ImageType; typedef itk::LandmarkDisplacementFieldSource DisplacementFieldSourceType; typedef typename DisplacementFieldSourceType::LandmarkContainer LandmarkContainerType; typedef typename DisplacementFieldSourceType::LandmarkPointType LandmarkPointType; typedef typename PointSetType::PointsContainer PointsContainer; typedef typename PointsContainer::ConstIterator PointsIterator; typedef typename PointSetType::PointDataContainer PointDataContainer; typedef typename PointDataContainer::ConstIterator PointDataIterator; typename LandmarkContainerType::Pointer sourceLandmarks = LandmarkContainerType::New(); typename LandmarkContainerType::Pointer targetLandmarks = LandmarkContainerType::New(); LandmarkPointType sourcePoint; LandmarkPointType targetPoint; PointsIterator pointIterator = this->GetPointSet()->GetPoints()->Begin(); PointsIterator end = this->GetPointSet()->GetPoints()->End(); unsigned int pointId = 0; PointDataIterator pointDataIterator = this->GetPointSet()->GetPointData()->Begin(); while (pointIterator != end) { typename PointDataContainer::Element valueAndDisplacements = pointDataIterator.Value(); if (vcl_abs(valueAndDisplacements[0]) >= this->GetMetricThreshold()) { typename PointSetType::PointType p = pointIterator.Value(); // access the point sourcePoint[0] = p[0]; sourcePoint[1] = p[1]; targetPoint[0] = p[0] - valueAndDisplacements[1]; targetPoint[1] = p[1] - valueAndDisplacements[2]; otbMsgDebugMacro( << "Adding landmark " << pointId << ", source point: " << sourcePoint << ", targetpoint: " << targetPoint); sourceLandmarks->InsertElement(pointId, sourcePoint); targetLandmarks->InsertElement(pointId, targetPoint); ++pointId; } ++pointIterator; ++pointDataIterator; } typename DisplacementFieldSourceType::Pointer deformer = DisplacementFieldSourceType::New(); deformer->SetOutputSpacing(this->GetOutputSpacing()); deformer->SetOutputOrigin(this->GetOutputOrigin()); deformer->SetOutputRegion(outputPtr->GetRequestedRegion()); deformer->SetSourceLandmarks(sourceLandmarks.GetPointer()); deformer->SetTargetLandmarks(targetLandmarks.GetPointer()); deformer->Update(); outputPtr->Allocate(); PixelType defaultPixel; defaultPixel.SetSize(2); defaultPixel.Fill(this->GetDefaultValue()); outputPtr->FillBuffer(defaultPixel); typedef itk::ImageRegionIterator ImageIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; ImageIteratorType inIt(deformer->GetOutput(), outputPtr->GetRequestedRegion()); OutputIteratorType outIt(outputPtr, outputPtr->GetRequestedRegion()); int i = 0; // Casting otb::Image, 2> to otb::VectorImage for (inIt.GoToBegin(), outIt.GoToBegin(); (!inIt.IsAtEnd()) && (!outIt.IsAtEnd()); ++inIt, ++outIt, ++i) { typename ImageType::PixelType inPixel; inPixel = inIt.Get(); PixelType outPixel; outPixel.SetSize(2); outPixel[0] = -inPixel[0]; outPixel[1] = -inPixel[1]; outIt.Set(outPixel); } } /** * PrintSelf Method */ template void BSplinesInterpolateDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbBSplinesInterpolateTransformDisplacementFieldGenerator.h000066400000000000000000000134141301006202600402670ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSplinesInterpolateTransformDisplacementFieldGenerator_h #define otbBSplinesInterpolateTransformDisplacementFieldGenerator_h #include "otbPointSetWithTransformToDisplacementFieldGenerator.h" #include "itkUnaryFunctorImageFilter.h" #include "itkBSplineScatteredDataPointSetToImageFilter.h" #include "itkBSplineControlPointImageFunction.h" #include "otbImage.h" #include "otbMath.h" #include namespace otb { /** \class BSplinesInterpolateTransformDisplacementFieldGenerator * \brief This class generate the displacement field by using spline interpolation on the parameters of the transform. * * Spline interpolation of non regularly scattered data is provided * by the itk::BSplineScatteredDataPointSetToImageFilter. It allows interpolation using any spline order and implements a multi-level approach. * * This filter is used for each parameter. One can also specify the indices of the angular parameters. Angular parameters are first * converted to complex exponential, the interpolated and converted back to the angular space. This is done to avoid interpolating angular discontinuities, * which is a non-sense. * * \sa itk::BSplineScatteredDataPointSetToImageFilter * * \ingroup OTBDisplacementField */ template class ITK_EXPORT BSplinesInterpolateTransformDisplacementFieldGenerator : public PointSetWithTransformToDisplacementFieldGenerator { public: /** Standard typedefs */ typedef BSplinesInterpolateTransformDisplacementFieldGenerator Self; typedef PointSetWithTransformToDisplacementFieldGenerator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(BSplinesInterpolateTransformDisplacementFieldGenerator, PointSetWithTransformsToDisplacementFieldGenerator); /** Template parameters typedefs */ typedef typename Superclass::PointSetType PointSetType; typedef typename Superclass::PointSetPointerType PointSetPointerType; typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldPointerType DisplacementFieldPointerType; typedef typename Superclass::IndexType IndexType; typedef typename DisplacementFieldType::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::PointType PointType; typedef typename Superclass::IndexVectorType IndexVectorType; typedef typename Superclass::DistanceVectorType DistanceVectorType; typedef typename Superclass::ParametersType ParametersType; /** Filters definition */ typedef itk::Vector PointSetDataType; typedef otb::Image InternalImageType; typedef itk::PointSet InternalPointSetType; typedef itk::BSplineScatteredDataPointSetToImageFilter SPlineInterpolateFilterType; typedef typename SPlineInterpolateFilterType::Pointer SPlineInterpolateFilterPointerType; typedef itk::BSplineControlPointImageFunction BSplinerType; /** * Add an angular parameter. Angular parameters are transformed by complex exponential during interpolation so as to avoid discontinuity. * \param index The index of the angular parameter. */ void AddAngularParameter(unsigned int index); /** * Remove an angular parameter. * \param index The index of the angular parameter. */ void RemoveAngularParameter(unsigned int index); itkSetMacro(SplineOrder, unsigned int); itkGetMacro(SplineOrder, unsigned int); itkSetMacro(NumberOfControlPoints, unsigned int); itkGetMacro(NumberOfControlPoints, unsigned int); itkSetMacro(NumberOfLevels, unsigned int); itkGetMacro(NumberOfLevels, unsigned int); protected: /** Constructor */ BSplinesInterpolateTransformDisplacementFieldGenerator(); /** Destructor */ ~BSplinesInterpolateTransformDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; void GenerateOutputInformation() ITK_OVERRIDE; /** * Test whether a parameter is angular or not. * \param index The index of the parameter to test. */ bool IsAngular(unsigned int index); private: BSplinesInterpolateTransformDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented IndexVectorType m_AngularParameters; unsigned int m_SplineOrder; unsigned int m_NumberOfControlPoints; unsigned int m_NumberOfLevels; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBSplinesInterpolateTransformDisplacementFieldGenerator.txx" #endif #endif otbBSplinesInterpolateTransformDisplacementFieldGenerator.txx000066400000000000000000000173561301006202600406740ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBSplinesInterpolateTransformDisplacementFieldGenerator_txx #define otbBSplinesInterpolateTransformDisplacementFieldGenerator_txx #include "otbBSplinesInterpolateTransformDisplacementFieldGenerator.h" #include "itkLandmarkDisplacementFieldSource.h" #include "otbObjectList.h" #include "otbMacro.h" namespace otb { template BSplinesInterpolateTransformDisplacementFieldGenerator ::BSplinesInterpolateTransformDisplacementFieldGenerator() { m_SplineOrder = 3; m_NumberOfControlPoints = 4; m_NumberOfLevels = 6; } template void BSplinesInterpolateTransformDisplacementFieldGenerator ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); this->GetOutput()->SetNumberOfComponentsPerPixel(2); } /** Main computation method */ template void BSplinesInterpolateTransformDisplacementFieldGenerator ::GenerateData(void) { DisplacementFieldPointerType outputPtr = this->GetOutput(); // Default displacement field PixelType defaultValue(2); defaultValue.Fill(this->GetDefaultValue()); outputPtr->Allocate(); outputPtr->FillBuffer(defaultValue); typedef otb::ObjectList SPlineInterpolatorListType; typedef typename PointSetType::PointsContainer::ConstIterator PointSetIteratorType; // Initialization of the splines interpolator typename SPlineInterpolatorListType::Pointer splineIntList = SPlineInterpolatorListType::New(); for (unsigned int paramIndex = 0; paramIndex < this->GetTransform()->GetNumberOfParameters(); ++paramIndex) { // Create a new interpolator splineIntList->PushBack(BSplinerType::New()); // Create a new point set typename InternalPointSetType::Pointer tmpPointSet = InternalPointSetType::New(); tmpPointSet->Initialize(); unsigned int pointDataCounter = 0; for (PointSetIteratorType it = this->GetPointSet()->GetPoints()->Begin(); it != this->GetPointSet()->GetPoints()->End(); ++it) { if (vcl_abs(this->GetPointSet()->GetPointData()->GetElement(pointDataCounter)[0]) >= this->GetMetricThreshold()) { typename InternalPointSetType::PixelType V(0.0); if (!IsAngular(paramIndex)) { V[0] = this->GetPointSet()->GetPointData()->GetElement(pointDataCounter)[paramIndex + 3]; V[1] = this->GetPointSet()->GetPointData()->GetElement(pointDataCounter)[paramIndex + 3]; } else { V[0] = static_cast(vcl_cos(this->GetPointSet()->GetPointData()->GetElement(pointDataCounter)[paramIndex + 3])); V[1] = static_cast(vcl_sin(this->GetPointSet()->GetPointData()->GetElement(pointDataCounter)[paramIndex + 3])); } unsigned long nbPoints = tmpPointSet->GetNumberOfPoints(); tmpPointSet->SetPoint(nbPoints, it.Value()); tmpPointSet->SetPointData(nbPoints, V); } ++pointDataCounter; } SPlineInterpolateFilterPointerType splineFilter = SPlineInterpolateFilterType::New(); // Set the interpolator parameters splineFilter->SetInput(tmpPointSet); splineFilter->SetSplineOrder(m_SplineOrder); typename SPlineInterpolateFilterType::ArrayType ncps; ncps.Fill(m_NumberOfControlPoints); splineFilter->SetNumberOfControlPoints(ncps); splineFilter->SetNumberOfLevels(m_NumberOfLevels); // splineFilter->SetGenerateOutputImage(false); // Define the parametric domain. splineFilter->SetOrigin(this->GetOutput()->GetOrigin()); splineFilter->SetSpacing(this->GetOutput()->GetSpacing()); splineFilter->SetSize(this->GetOutput()->GetLargestPossibleRegion().GetSize()); splineFilter->Update(); // Image function splineIntList->Back()->SetSplineOrder( splineFilter->GetSplineOrder() ); splineIntList->Back()->SetSize( splineFilter->GetSize() ); splineIntList->Back()->SetSpacing( splineFilter->GetSpacing() ); splineIntList->Back()->SetOrigin( splineFilter->GetOrigin() ); splineIntList->Back()->SetInputImage( static_cast(splineFilter->GetPhiLattice().GetPointer()) ); } // Interpolation typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType outIt(outputPtr, outputPtr->GetRequestedRegion()); // main loop for (outIt.GoToBegin(); !outIt.IsAtEnd(); ++outIt) { // Index of the pixel IndexType index = outIt.GetIndex(); // parameters vector ParametersType params(this->GetTransform()->GetNumberOfParameters()); // we iterate over the number of parameters of the transform for (unsigned int paramIndex = 0; paramIndex < this->GetTransform()->GetNumberOfParameters(); ++paramIndex) { typename InternalPointSetType::PointType p; this->GetOutput()->TransformIndexToPhysicalPoint(index, p); typename InternalPointSetType::PixelType V(0.0); // For each parameter we use the associated spline interpolator if (!IsAngular(paramIndex)) { V = splineIntList->GetNthElement(paramIndex)->EvaluateAtParametricPoint(p); params[paramIndex] = V[0]; } else { V = splineIntList->GetNthElement(paramIndex)->EvaluateAtParametricPoint(p); params[paramIndex] = vcl_atan2(V[1], V[0]); } // We then compute the target point using the transform this->GetTransform()->SetParameters(params); PointType sourcePoint, targetPoint; outputPtr->TransformIndexToPhysicalPoint(index, sourcePoint); targetPoint = this->GetTransform()->TransformPoint(sourcePoint); // And the displacement PixelType pixel; pixel.SetSize(2); pixel[0] = static_cast(targetPoint[0] - sourcePoint[0]); pixel[1] = static_cast(targetPoint[1] - sourcePoint[1]); outIt.Set(pixel); } } } template void BSplinesInterpolateTransformDisplacementFieldGenerator ::AddAngularParameter(unsigned int index) { m_AngularParameters.push_back(index); } template void BSplinesInterpolateTransformDisplacementFieldGenerator ::RemoveAngularParameter(unsigned int index) { m_AngularParameters.erase(index); } template bool BSplinesInterpolateTransformDisplacementFieldGenerator ::IsAngular(unsigned int index) { bool resp = std::binary_search(m_AngularParameters.begin(), m_AngularParameters.end(), index); return resp; } /** * PrintSelf Method */ template void BSplinesInterpolateTransformDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.h000066400000000000000000000066131301006202600407260ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNNearestPointsLinearInterpolateDisplacementFieldGenerator_h #define otbNNearestPointsLinearInterpolateDisplacementFieldGenerator_h #include "otbPointSetToDisplacementFieldGenerator.h" namespace otb { /** \class NNearestPointsLinearInterpolateDisplacementFieldGenerator * \brief This class generate the displacement field by performing a linear interpolation of the displacement induced by the n nearest point. * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ template class ITK_EXPORT NNearestPointsLinearInterpolateDisplacementFieldGenerator : public PointSetToDisplacementFieldGenerator { public: /** Standard typedefs */ typedef NNearestPointsLinearInterpolateDisplacementFieldGenerator Self; typedef PointSetToDisplacementFieldGenerator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NNearestPointsLinearInterpolateDisplacementFieldGenerator, PointSetToDisplacementFieldGenerator); /** Template parameters typedefs */ typedef typename Superclass::PointSetType PointSetType; typedef typename Superclass::PointSetPointerType PointSetPointerType; typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldPointerType DisplacementFieldPointerType; typedef typename Superclass::IndexType IndexType; typedef typename DisplacementFieldType::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::PointType PointType; typedef typename Superclass::IndexVectorType IndexVectorType; typedef typename Superclass::DistanceVectorType DistanceVectorType; itkSetMacro(NumberOfPoints, unsigned int); itkGetMacro(NumberOfPoints, unsigned int); protected: /** Constructor */ NNearestPointsLinearInterpolateDisplacementFieldGenerator() {}; /** Destructor */ ~NNearestPointsLinearInterpolateDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; private: NNearestPointsLinearInterpolateDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfPoints; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.txx" #endif #endif otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.txx000066400000000000000000000060271301006202600413210ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNNearestPointsLinearInterpolateDisplacementFieldGenerator_txx #define otbNNearestPointsLinearInterpolateDisplacementFieldGenerator_txx #define EPSILON 1e-15 #include "otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbMacro.h" namespace otb { /** Main computation method */ template void NNearestPointsLinearInterpolateDisplacementFieldGenerator ::GenerateData(void) { DisplacementFieldPointerType outputPtr = this->GetOutput(); PixelType defaultValue(2); defaultValue.Fill(this->GetDefaultValue()); outputPtr->Allocate(); outputPtr->FillBuffer(defaultValue); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it(outputPtr, outputPtr->GetRequestedRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { IndexType index = it.GetIndex(); IndexVectorType indexVector = this->GenerateNearestValidPointsPointSet(it.GetIndex(), m_NumberOfPoints); PixelType pixel(2); double xdisplacement, ydisplacement, normalization; xdisplacement = 0; ydisplacement = 0; normalization = 0; for (typename IndexVectorType::iterator indexIt = indexVector.begin(); indexIt != indexVector.end(); ++indexIt) { PointType point; point[0] = static_cast(this->GetPointSet()->GetPoints()->GetElement(*indexIt)[0]); point[1] = static_cast(this->GetPointSet()->GetPoints()->GetElement(*indexIt)[1]); double distance = this->EuclideanDistanceMetric(index, point); if (distance < EPSILON) { distance = EPSILON; } xdisplacement += this->GetPointSet()->GetPointData()->GetElement((*indexIt))[1] / distance; ydisplacement += this->GetPointSet()->GetPointData()->GetElement((*indexIt))[2] / distance; normalization += 1 / distance; } if (normalization > 0) { pixel[0] = static_cast(xdisplacement / normalization); pixel[1] = static_cast(ydisplacement / normalization); } else { pixel = defaultValue; } it.Set(pixel); } } /** * PrintSelf Method */ template void NNearestPointsLinearInterpolateDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.h000066400000000000000000000074261301006202600416130ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator_h #define otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator_h #include "otbPointSetWithTransformToDisplacementFieldGenerator.h" namespace otb { /** \class NNearestTransformsLinearInterpolateDisplacementFieldGenerator * \brief generate the displacement field by performing a linear interpolation * * This class generate the displacement field by performing a linear interpolation of * the displacements from the transforms induced by the n nearest points. * * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ template class ITK_EXPORT NNearestTransformsLinearInterpolateDisplacementFieldGenerator : public PointSetWithTransformToDisplacementFieldGenerator { public: /** Standard typedefs */ typedef NNearestTransformsLinearInterpolateDisplacementFieldGenerator Self; typedef PointSetWithTransformToDisplacementFieldGenerator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NNearestTransformsLinearInterpolateDisplacementFieldGenerator, PointSetWithTransformsToDisplacementFieldGenerator); /** Template parameters typedefs */ typedef typename Superclass::PointSetType PointSetType; typedef typename Superclass::PointSetPointerType PointSetPointerType; typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldPointerType DisplacementFieldPointerType; typedef typename Superclass::IndexType IndexType; typedef typename DisplacementFieldType::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::PointType PointType; typedef typename Superclass::IndexVectorType IndexVectorType; typedef typename Superclass::DistanceVectorType DistanceVectorType; typedef typename Superclass::TransformType TransformType; typedef typename TransformType::ParametersType ParametersType; itkSetMacro(NumberOfPoints, unsigned int); itkGetMacro(NumberOfPoints, unsigned int); protected: /** Constructor */ NNearestTransformsLinearInterpolateDisplacementFieldGenerator() {}; /** Destructor */ ~NNearestTransformsLinearInterpolateDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; private: NNearestTransformsLinearInterpolateDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented unsigned int m_NumberOfPoints; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.txx" #endif #endif otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.txx000066400000000000000000000067601301006202600422070ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator_txx #define otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator_txx #define EPSILON 1e-15 #include "otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbMacro.h" namespace otb { /** Main computation method */ template void NNearestTransformsLinearInterpolateDisplacementFieldGenerator ::GenerateData(void) { DisplacementFieldPointerType outputPtr = this->GetOutput(); PixelType defaultValue(2); defaultValue.Fill(this->GetDefaultValue()); outputPtr->Allocate(); outputPtr->FillBuffer(defaultValue); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it(outputPtr, outputPtr->GetRequestedRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { IndexType index = it.GetIndex(); IndexVectorType indexVector = this->GenerateNearestValidPointsPointSet(it.GetIndex(), m_NumberOfPoints); PixelType pixel(2); double xdisplacement, ydisplacement, normalization; xdisplacement = 0; ydisplacement = 0; normalization = 0; for (typename IndexVectorType::iterator indexIt = indexVector.begin(); indexIt != indexVector.end(); ++indexIt) { PointType point; point[0] = static_cast(this->GetPointSet()->GetPoints()->GetElement(*indexIt)[0]); point[1] = static_cast(this->GetPointSet()->GetPoints()->GetElement(*indexIt)[1]); double distance = this->EuclideanDistanceMetric(index, point); if (distance < EPSILON) { distance = EPSILON; } ParametersType params(this->GetTransform()->GetNumberOfParameters()); for (unsigned int i = 0; i < this->GetTransform()->GetNumberOfParameters(); ++i) { params[i] = this->GetPointSet()->GetPointData()->GetElement((*indexIt))[i + 3]; } this->GetTransform()->SetParameters(params); PointType sourcePoint, targetPoint; outputPtr->TransformIndexToPhysicalPoint(it.GetIndex(), sourcePoint); targetPoint = this->GetTransform()->TransformPoint(sourcePoint); xdisplacement += (targetPoint[0] - sourcePoint[0]) / distance; ydisplacement += (targetPoint[1] - sourcePoint[1]) / distance; normalization += 1 / distance; } if (normalization > 0) { pixel[0] = static_cast(xdisplacement / normalization); pixel[1] = static_cast(ydisplacement / normalization); } else { pixel = defaultValue; } it.Set(pixel); } } /** * PrintSelf Method */ template void NNearestTransformsLinearInterpolateDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbNearestPointDisplacementFieldGenerator.h000066400000000000000000000060461301006202600350630ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNearestPointDisplacementFieldGenerator_h #define otbNearestPointDisplacementFieldGenerator_h #include "otbPointSetToDisplacementFieldGenerator.h" namespace otb { /** \class NearestPointDisplacementFieldGenerator * \brief This class implements the simplest way to displacement field generation using a point set. * In each pixel location, the displacement is considered to be the displacement of the nearest seed point in the point set. * * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ template class ITK_EXPORT NearestPointDisplacementFieldGenerator : public PointSetToDisplacementFieldGenerator { public: /** Standard typedefs */ typedef NearestPointDisplacementFieldGenerator Self; typedef PointSetToDisplacementFieldGenerator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NearestPointDisplacementFieldGenerator, PointSetToDisplacementFieldGenerator); /** Template parameters typedefs */ typedef typename Superclass::PointSetType PointSetType; typedef typename Superclass::PointSetPointerType PointSetPointerType; typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldPointerType DisplacementFieldPointerType; typedef typename Superclass::IndexType IndexType; typedef typename DisplacementFieldType::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::IndexVectorType IndexVectorType; protected: /** Constructor */ NearestPointDisplacementFieldGenerator() {}; /** Destructor */ ~NearestPointDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; private: NearestPointDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNearestPointDisplacementFieldGenerator.txx" #endif #endif otbNearestPointDisplacementFieldGenerator.txx000066400000000000000000000041111301006202600354460ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNearestPointDisplacementFieldGenerator_txx #define otbNearestPointDisplacementFieldGenerator_txx #include "otbNearestPointDisplacementFieldGenerator.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbMacro.h" namespace otb { /** Main computation method */ template void NearestPointDisplacementFieldGenerator ::GenerateData(void) { DisplacementFieldPointerType outputPtr = this->GetOutput(); PixelType defaultValue(2); defaultValue.Fill(this->GetDefaultValue()); outputPtr->Allocate(); outputPtr->FillBuffer(defaultValue); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it(outputPtr, outputPtr->GetRequestedRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { IndexVectorType indexVector = this->GenerateNearestValidPointsPointSet(it.GetIndex(), 1); PixelType p(2); if (indexVector.size() >= 1) { p[0] = static_cast(this->GetPointSet()->GetPointData()->GetElement(indexVector[0])[1]); p[1] = static_cast(this->GetPointSet()->GetPointData()->GetElement(indexVector[0])[2]); } else { p = defaultValue; } it.Set(p); } } /** * PrintSelf Method */ template void NearestPointDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbNearestTransformDisplacementFieldGenerator.h000066400000000000000000000064541301006202600357500ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNearestTransformDisplacementFieldGenerator_h #define otbNearestTransformDisplacementFieldGenerator_h #include "otbPointSetWithTransformToDisplacementFieldGenerator.h" namespace otb { /** \class NearestTransformDisplacementFieldGenerator * \brief This class implements displacement field generation by taking into account the local transform of the * nearest point in pointset. * * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ template class ITK_EXPORT NearestTransformDisplacementFieldGenerator : public PointSetWithTransformToDisplacementFieldGenerator { public: /** Standard typedefs */ typedef NearestTransformDisplacementFieldGenerator Self; typedef PointSetWithTransformToDisplacementFieldGenerator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(NearestTransformDisplacementFieldGenerator, PointSetWithTransformToDisplacementFieldGenerator); /** Template parameters typedefs */ typedef typename Superclass::PointSetType PointSetType; typedef typename Superclass::PointSetPointerType PointSetPointerType; typedef typename Superclass::DisplacementFieldType DisplacementFieldType; typedef typename Superclass::DisplacementFieldPointerType DisplacementFieldPointerType; typedef typename Superclass::IndexType IndexType; typedef typename Superclass::PointType PointType; typedef typename DisplacementFieldType::PixelType PixelType; typedef typename Superclass::ValueType ValueType; typedef typename Superclass::IndexVectorType IndexVectorType; typedef typename Superclass::TransformType TransformType; typedef typename TransformType::ParametersType ParametersType; protected: /** Constructor */ NearestTransformDisplacementFieldGenerator() {}; /** Destructor */ ~NearestTransformDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; private: NearestTransformDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbNearestTransformDisplacementFieldGenerator.txx" #endif #endif otbNearestTransformDisplacementFieldGenerator.txx000066400000000000000000000050571301006202600363420ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbNearestTransformDisplacementFieldGenerator_txx #define otbNearestTransformDisplacementFieldGenerator_txx #include "otbNearestTransformDisplacementFieldGenerator.h" #include "itkImageRegionIteratorWithIndex.h" #include "otbMacro.h" namespace otb { /** Main computation method */ template void NearestTransformDisplacementFieldGenerator ::GenerateData(void) { DisplacementFieldPointerType outputPtr = this->GetOutput(); PixelType defaultValue(2); defaultValue.Fill(this->GetDefaultValue()); outputPtr->Allocate(); outputPtr->FillBuffer(defaultValue); typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it(outputPtr, outputPtr->GetRequestedRegion()); for (it.GoToBegin(); !it.IsAtEnd(); ++it) { IndexVectorType indexVector = this->GenerateNearestValidPointsPointSet(it.GetIndex(), 1); PixelType pixel(2); if (indexVector.size() >= 1) { ParametersType params(this->GetTransform()->GetNumberOfParameters()); for (unsigned int i = 0; i < this->GetTransform()->GetNumberOfParameters(); ++i) { params[i] = this->GetPointSet()->GetPointData()->GetElement(indexVector[0])[i + 3]; } this->GetTransform()->SetParameters(params); PointType sourcePoint, targetPoint; outputPtr->TransformIndexToPhysicalPoint(it.GetIndex(), sourcePoint); targetPoint = this->GetTransform()->TransformPoint(sourcePoint); pixel[0] = static_cast(targetPoint[0] - sourcePoint[0]); pixel[1] = static_cast(targetPoint[1] - sourcePoint[1]); } else { pixel = defaultValue; } it.Set(pixel); } } /** * PrintSelf Method */ template void NearestTransformDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbPointSetToDisplacementFieldGenerator.h000066400000000000000000000125331301006202600345160ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetToDisplacementFieldGenerator_h #define otbPointSetToDisplacementFieldGenerator_h #include "itkImageSource.h" namespace otb { namespace Functor { /** \class DistanceComparisonFunctor * \brief This functor is used in nearest neighborhood sorting. * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ class DistanceComparisonFunctor { public: DistanceComparisonFunctor() {} virtual ~DistanceComparisonFunctor() {} typedef std::vector DistanceVectorType; void SetDistanceVector(DistanceVectorType& vec) { m_DistanceVector = vec; } DistanceVectorType GetDistanceVector(void) { return m_DistanceVector; } inline bool operator ()(const unsigned int a1, const unsigned int a2) { return m_DistanceVector[a1] < m_DistanceVector[a2]; } private: DistanceVectorType m_DistanceVector; }; } /** \class PointSetToDisplacementFieldGenerator * \brief Base class for filters generating a displacement field from a point set enriched with displacement and local transform information. * The output of the filters deriving from this base class can be passed to the itk::WarpImageFilter for image resampling. * \sa DisparityMapEstimationMethod * \sa itk::WarpImageFilter * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ template class ITK_EXPORT PointSetToDisplacementFieldGenerator : public itk::ImageSource { public: /** Standard typedefs */ typedef PointSetToDisplacementFieldGenerator Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(PointSetToDisplacementFieldGenerator, ImageSource); /** Template parameters typedefs */ typedef TPointSet PointSetType; typedef typename PointSetType::Pointer PointSetPointerType; typedef TDisplacementField DisplacementFieldType; typedef typename DisplacementFieldType::Pointer DisplacementFieldPointerType; typedef typename DisplacementFieldType::IndexType IndexType; typedef typename DisplacementFieldType::SizeType SizeType; typedef typename DisplacementFieldType::SpacingType SpacingType; typedef typename DisplacementFieldType::PointType PointType; typedef typename DisplacementFieldType::InternalPixelType ValueType; /** More typedefs */ typedef std::vector DistanceVectorType; typedef std::vector IndexVectorType; /** * Set the pointset containing the disparity. * \param pointset The pointset containing the disparity. */ void SetPointSet(const TPointSet * pointset); /** * Get the pointset containing the disparity. * \return The pointset containing the disparity. */ const TPointSet * GetPointSet(void); itkSetMacro(MetricThreshold, double); itkGetMacro(MetricThreshold, double); itkSetMacro(DefaultValue, ValueType); itkGetMacro(DefaultValue, ValueType); itkSetMacro(OutputSize, SizeType); itkGetConstReferenceMacro(OutputSize, SizeType); itkSetMacro(OutputSpacing, SpacingType); itkGetConstReferenceMacro(OutputSpacing, SpacingType); itkSetMacro(OutputOrigin, PointType); itkGetConstReferenceMacro(OutputOrigin, PointType); protected: /** Constructor */ PointSetToDisplacementFieldGenerator(); /** Destructor */ ~PointSetToDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** * Generate the n nearest valid point in point set, where a valid point has a sufficient metric value. * \param index The index of the pixel to compute. * \param n The number of nearest point to seek. * \return A vector containing the index of the nearest point from nearest to most far. */ IndexVectorType GenerateNearestValidPointsPointSet(IndexType index, unsigned int n = 1); /** Euclidean distance of point to index */ double EuclideanDistanceMetric(IndexType index, PointType p); private: PointSetToDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** * The threshold of metric value. */ double m_MetricThreshold; /** The output size */ SizeType m_OutputSize; /** The output spacing. */ SpacingType m_OutputSpacing; /** The output origin */ PointType m_OutputOrigin; /** Default value */ ValueType m_DefaultValue; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetToDisplacementFieldGenerator.txx" #endif #endif otbPointSetToDisplacementFieldGenerator.txx000066400000000000000000000115141301006202600351100ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetToDisplacementFieldGenerator_txx #define otbPointSetToDisplacementFieldGenerator_txx #include "otbPointSetToDisplacementFieldGenerator.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template PointSetToDisplacementFieldGenerator ::PointSetToDisplacementFieldGenerator() { this->SetNumberOfRequiredInputs(1); m_MetricThreshold = 0.; m_OutputSize.Fill(100); m_OutputSpacing.Fill(1.); m_OutputOrigin.Fill(0.); m_DefaultValue = 0; // m_NearestPoints = PointSetType::New(); } /** * Set the pointset containing the disparity. * \param pointset The pointset containing the disparity. */ template void PointSetToDisplacementFieldGenerator ::SetPointSet(const TPointSet * pointset) { this->itk::ProcessObject::SetNthInput(0, const_cast(pointset)); } /** * Get the pointset containing the disparity. * \return The pointset containing the disparity. */ template const TPointSet * PointSetToDisplacementFieldGenerator ::GetPointSet(void) { return static_cast(this->itk::ProcessObject::GetInput(0)); } /** Generate output information */ template void PointSetToDisplacementFieldGenerator ::GenerateOutputInformation(void) { DisplacementFieldPointerType outputPtr = this->GetOutput(); typename DisplacementFieldType::RegionType largest; largest.SetSize(m_OutputSize); IndexType index; index.Fill(0); largest.SetIndex(index); outputPtr->SetRegions(largest); outputPtr->SetSpacing(m_OutputSpacing); outputPtr->SetOrigin(m_OutputOrigin); // Force the displacement field to have vector pixel of size 2. outputPtr->SetNumberOfComponentsPerPixel(2); } /** * Generate the n nearest point in point set * \param index The index of the pixel to compute. * \param n The number of nearest point to seek. * \return A vector containing the index of the nearest point from nearest to most far. */ template typename PointSetToDisplacementFieldGenerator ::IndexVectorType PointSetToDisplacementFieldGenerator ::GenerateNearestValidPointsPointSet(IndexType index, unsigned int n) { typedef Functor::DistanceComparisonFunctor ComparisonFunctorType; DistanceVectorType distanceVector; IndexVectorType indexVector; IndexVectorType sortVector; unsigned int i = 0; unsigned int j = 0; typedef typename PointSetType::PointsContainer::ConstIterator PointSetIteratorType; PointSetIteratorType it = this->GetPointSet()->GetPoints()->Begin(); for (; it != this->GetPointSet()->GetPoints()->End(); ++it) { PointType p; p[0] = it.Value()[0]; p[1] = it.Value()[1]; if (vcl_abs(this->GetPointSet()->GetPointData()->GetElement(j)[0]) >= m_MetricThreshold) { distanceVector.push_back(EuclideanDistanceMetric(index, p)); sortVector.push_back(i); indexVector.push_back(j); ++i; } ++j; } ComparisonFunctorType comp; comp.SetDistanceVector(distanceVector); sort(sortVector.begin(), sortVector.end(), comp); // building output vector unsigned int nbElements = (n < indexVector.size() ? n : indexVector.size()); IndexVectorType output; for (i = 0; i < nbElements; ++i) { output.push_back(indexVector[sortVector[i]]); } return output; } template double PointSetToDisplacementFieldGenerator ::EuclideanDistanceMetric(IndexType index, PointType p) { PointType pprime; // our point are expressed in index and not in physical coordinates //this->GetOutput()->TransformIndexToPhysicalPoint(index, pprime); return vcl_sqrt(vcl_pow(index[0] - p[0], 2) + vcl_pow(index[1] - p[1], 2)); } /** * PrintSelf Method */ template void PointSetToDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbPointSetWithTransformToDisplacementFieldGenerator.h000066400000000000000000000075031301006202600372470ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetWithTransformToDisplacementFieldGenerator_h #define otbPointSetWithTransformToDisplacementFieldGenerator_h #include "otbPointSetToDisplacementFieldGenerator.h" #include "itkTransform.h" namespace otb { /** \class PointSetWithTransformToDisplacementFieldGenerator * \brief Base class for filters generating a displacement field from a point set enriched with local transform information. * * The output of the filters deriving from this base class can be passed to the itk::WarpImageFilter for image resampling. * * \sa DisparityMapEstimationMethod * \sa itk::WarpImageFilter * * \ingroup DisparityMap * * \ingroup OTBDisplacementField */ template class ITK_EXPORT PointSetWithTransformToDisplacementFieldGenerator : public PointSetToDisplacementFieldGenerator { public: /** Standard typedefs */ typedef PointSetWithTransformToDisplacementFieldGenerator Self; typedef PointSetToDisplacementFieldGenerator Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(PointSetWithTransformToDisplacementFieldGenerator, PointSetToDisplacementFieldGenerator); /** Template parameters typedefs */ typedef TPointSet PointSetType; typedef typename PointSetType::Pointer PointSetPointerType; typedef TDisplacementField DisplacementFieldType; typedef typename DisplacementFieldType::Pointer DisplacementFieldPointerType; typedef typename DisplacementFieldType::IndexType IndexType; typedef typename DisplacementFieldType::SizeType SizeType; typedef typename DisplacementFieldType::SpacingType SpacingType; typedef typename DisplacementFieldType::PointType PointType; typedef typename DisplacementFieldType::InternalPixelType ValueType; /** More typedefs */ typedef typename Superclass::DistanceVectorType DistanceVectorType; typedef typename Superclass::IndexVectorType IndexVectorType; /** Transform typedefs */ typedef itk::Transform TransformType; typedef typename TransformType::Pointer TransformPointerType; typedef typename TransformType::ParametersType ParametersType; /** Set/Get the Transform. */ itkSetObjectMacro(Transform, TransformType); itkGetObjectMacro(Transform, TransformType); protected: /** Constructor */ PointSetWithTransformToDisplacementFieldGenerator(); /** Destructor */ ~PointSetWithTransformToDisplacementFieldGenerator() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: PointSetWithTransformToDisplacementFieldGenerator(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** * The transform used for local registration. */ TransformPointerType m_Transform; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPointSetWithTransformToDisplacementFieldGenerator.txx" #endif #endif otbPointSetWithTransformToDisplacementFieldGenerator.txx000066400000000000000000000025421301006202600376410ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPointSetWithTransformToDisplacementFieldGenerator_txx #define otbPointSetWithTransformToDisplacementFieldGenerator_txx #include "otbPointSetWithTransformToDisplacementFieldGenerator.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template PointSetWithTransformToDisplacementFieldGenerator ::PointSetWithTransformToDisplacementFieldGenerator() { m_Transform = ITK_NULLPTR; // has to be provided by the user } /** * PrintSelf Method */ template void PointSetWithTransformToDisplacementFieldGenerator ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Registration/DisplacementField/otb-module.cmake000066400000000000000000000011431301006202600261240ustar00rootroot00000000000000set(DOCUMENTATION "This module contains filters that generate a deformation field by using some interpolation criterion on the deformation values from the point set. Several interpolation methods are available (Nearest neighbours, linear, BSpline). The class otb::StereorectificationDisplacementFieldSource is specialized in generating a deformation field between two images in epipolar geometry (horizontal shifts).") otb_module(OTBDisplacementField DEPENDS OTBCommon OTBITK OTBImageBase OTBObjectList TEST_DEPENDS OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Registration/DisplacementField/test/000077500000000000000000000000001301006202600240335ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/CMakeLists.txt000066400000000000000000000114211301006202600265720ustar00rootroot00000000000000otb_module_test() set(OTBDisplacementFieldTests otbDisplacementFieldTestDriver.cxx otbNearestTransformDisplacementFieldGeneratorNew.cxx otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.cxx otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.cxx otbNearestPointDisplacementFieldGeneratorNew.cxx otbPointSetToDisplacementFieldGeneratorNew.cxx otbPointSetWithTransformToDisplacementFieldGeneratorNew.cxx otbBSplinesInterpolateDisplacementFieldGeneratorNew.cxx otbNNearestTransformsLinearInterpolateDisplacementFieldGeneratorNew.cxx otbNNearestPointsLinearInterpolateDisplacementFieldGeneratorNew.cxx otbNearestTransformDisplacementFieldGenerator.cxx otbNearestPointDisplacementFieldGenerator.cxx otbBSplinesInterpolateTransformDisplacementFieldGenerator.cxx otbBSplinesInterpolateDisplacementFieldGenerator.cxx otbBSplinesInterpolateTransformDisplacementFieldGeneratorNew.cxx ) add_executable(otbDisplacementFieldTestDriver ${OTBDisplacementFieldTests}) target_link_libraries(otbDisplacementFieldTestDriver ${OTBDisplacementField-Test_LIBRARIES}) otb_module_target_label(otbDisplacementFieldTestDriver) # Tests Declaration otb_add_test(NAME dmTuNearestTransformDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbNearestTransformDisplacementFieldGeneratorNew) otb_add_test(NAME dmTvNNearestTransformsLinearInterpolateDisplacementFieldGenerator COMMAND otbDisplacementFieldTestDriver --compare-image ${EPSILON_10} ${BASELINE}/dmTvNNearestTransformsLinearInterpolateDeformationField.hdr ${TEMP}/dmTvNNearestTransformsLinearInterpolateDisplacementField.hdr otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator ${TEMP}/dmTvNNearestTransformsLinearInterpolateDisplacementField.hdr ) otb_add_test(NAME dmTvNNearestPointsLinearInterpolateDisplacementFieldGenerator COMMAND otbDisplacementFieldTestDriver --compare-image ${EPSILON_10} ${BASELINE}/dmTvNNearestPointsLinearInterpolateDeformationField.hdr ${TEMP}/dmTvNNearestPointsLinearInterpolateDisplacementField.hdr otbNNearestPointsLinearInterpolateDisplacementFieldGenerator ${TEMP}/dmTvNNearestPointsLinearInterpolateDisplacementField.hdr ) otb_add_test(NAME dmTuNearestPointDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbNearestPointDisplacementFieldGeneratorNew) otb_add_test(NAME dmTuPointSetToDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbPointSetToDisplacementFieldGeneratorNew) otb_add_test(NAME dmTuPointSetWithTransformToDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbPointSetWithTransformToDisplacementFieldGeneratorNew) otb_add_test(NAME dmTuNNearestTransformsLinearInterpolateDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbNNearestTransformsLinearInterpolateDisplacementFieldGeneratorNew) otb_add_test(NAME dmTuBSplinesInterpolateDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbNNearestPointsLinearInterpolateDisplacementFieldGeneratorNew) otb_add_test(NAME dmTuNNearestPointsLinearInterpolateDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbNNearestPointsLinearInterpolateDisplacementFieldGeneratorNew) otb_add_test(NAME dmTvNearestTransformDisplacementFieldGenerator COMMAND otbDisplacementFieldTestDriver --compare-image ${EPSILON_10} ${BASELINE}/dmTvNearestTransformDeformationField.hdr ${TEMP}/dmTvNearestTransformDisplacementField.hdr otbNearestTransformDisplacementFieldGenerator ${TEMP}/dmTvNearestTransformDisplacementField.hdr ) otb_add_test(NAME dmTvNearestPointDisplacementFieldGenerator COMMAND otbDisplacementFieldTestDriver --compare-image ${EPSILON_10} ${BASELINE}/dmTvNearestPointDeformationField.hdr ${TEMP}/dmTvNearestPointDisplacementField.hdr otbNearestPointDisplacementFieldGenerator ${TEMP}/dmTvNearestPointDisplacementField.hdr ) #otb_add_test(NAME dmTvBSplinesInterpolateTransformDisplacementFieldGenerator COMMAND otbDisplacementFieldTestDriver #--compare-image ${EPSILON_4} #${BASELINE}/dmTvBSplinesInterpolateTransformDeformationFieldGenerator.hdr #${TEMP}/dmTvBSplinesInterpolateTransformDisplacementFieldGenerator.hdr #otbBSplinesInterpolateTransformDisplacementFieldGenerator #${TEMP}/dmTvBSplinesInterpolateTransformDisplacementFieldGenerator.hdr #) otb_add_test(NAME dmTvBSplinesInterpolateDisplacementFieldGenerator COMMAND otbDisplacementFieldTestDriver --compare-image ${EPSILON_10} ${BASELINE}/dmTvBSplinesInterpolateDeformationField.hdr ${TEMP}/dmTvBSplinesInterpolateDisplacementField.hdr otbBSplinesInterpolateDisplacementFieldGenerator ${TEMP}/dmTvBSplinesInterpolateDisplacementField.hdr ) otb_add_test(NAME dmTuBSplinesInterpolateTransformDisplacementFieldGeneratorNew COMMAND otbDisplacementFieldTestDriver otbBSplinesInterpolateTransformDisplacementFieldGeneratorNew) otbBSplinesInterpolateDisplacementFieldGenerator.cxx000066400000000000000000000053611301006202600363040ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbBSplinesInterpolateDisplacementFieldGenerator.h" #include "otbImageFileWriter.h" int otbBSplinesInterpolateDisplacementFieldGenerator(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const char * outfname = argv[1]; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::Array ParamType; typedef itk::PointSet PointSetType; typedef PointSetType::PointType PointType; typedef otb::BSplinesInterpolateDisplacementFieldGenerator FilterType; typedef otb::ImageFileWriter WriterType; ImageType::SizeType size; size.Fill(100); double thresh = 0.9; // Preparing point set PointSetType::Pointer ps = PointSetType::New(); PointType p1, p2, p3, p4, p5; ParamType pd1(3), pd2(3), pd3(3), pd4(3), pd5(3); p1[0] = 10; p1[1] = 10; p2[0] = 75; p2[1] = 10; p3[0] = 50; p3[1] = 50; p4[0] = 10; p4[1] = 60; p5[0] = 85; p5[1] = 70; pd1[0] = 0.95; pd1[1] = 10; pd1[2] = -5; pd2[0] = 0.98; pd2[1] = 2; pd2[2] = 5; pd3[0] = 0.5; pd3[1] = 20; pd3[2] = -20; pd4[0] = 0.91; pd4[1] = 15; pd4[2] = -5; pd5[0] = 0.91; pd5[1] = 5; pd5[2] = 5; ps->SetPoint(0, p1); ps->SetPointData(0, pd1); ps->SetPoint(1, p2); ps->SetPointData(1, pd2); ps->SetPoint(2, p3); ps->SetPointData(2, pd3); ps->SetPoint(3, p4); ps->SetPointData(3, pd4); ps->SetPoint(4, p5); ps->SetPointData(4, pd5); // Instantiating object FilterType::Pointer filter = FilterType::New(); filter->SetOutputSize(size); filter->SetMetricThreshold(thresh); filter->SetPointSet(ps); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } otbBSplinesInterpolateDisplacementFieldGeneratorNew.cxx000066400000000000000000000026711301006202600367570ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbBSplinesInterpolateDisplacementFieldGenerator.h" int otbBSplinesInterpolateDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 3; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::FixedArray PointType; typedef itk::PointSet PointSetType; typedef otb::BSplinesInterpolateDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbBSplinesInterpolateTransformDisplacementFieldGenerator.cxx000066400000000000000000000066151301006202600402030ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbBSplinesInterpolateTransformDisplacementFieldGenerator.h" #include "otbImageFileWriter.h" #include "itkEuler2DTransform.h" int otbBSplinesInterpolateTransformDisplacementFieldGenerator(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const char * outfname = argv[1]; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::Array ParamType; typedef itk::PointSet PointSetType; typedef PointSetType::PointType PointType; typedef otb::BSplinesInterpolateTransformDisplacementFieldGenerator FilterType; typedef otb::ImageFileWriter WriterType; typedef itk::Euler2DTransform TransformType; ImageType::SizeType size; size.Fill(100); double thresh = 0.9; // Preparing point set PointSetType::Pointer ps = PointSetType::New(); PointType p1, p2, p3, p4, p5; ParamType pd1(6), pd2(6), pd3(6), pd4(6), pd5(6); itk::Point center; p1[0] = 10; p1[1] = 10; p2[0] = 75; p2[1] = 10; p3[0] = 50; p3[1] = 50; p4[0] = 10; p4[1] = 60; p5[0] = 85; p5[1] = 70; center.Fill(50); pd1[0] = 0.95; pd1[1] = 0; pd1[2] = 0; pd1[3] = 0.03925; pd1[4] = 5; pd1[5] = 5; pd2[0] = 0.98; pd2[1] = 0; pd2[2] = 0; pd2[3] = -0.03925; pd2[4] = 5; pd2[5] = -5; pd3[0] = 0.5; pd3[1] = 0; pd3[2] = 0; pd3[3] = 0; pd3[4] = 0; pd3[5] = 0; pd4[0] = 0.91; pd4[1] = 0; pd4[2] = 0; pd4[3] = 0.03925; pd4[4] = -5; pd4[5] = 5; pd5[0] = 0.91; pd5[1] = 0; pd5[2] = 0; pd5[3] = -0.03925; pd5[4] = -5; pd5[5] = -5; ps->SetPoint(0, p1); ps->SetPointData(0, pd1); ps->SetPoint(1, p2); ps->SetPointData(1, pd2); ps->SetPoint(2, p3); ps->SetPointData(2, pd3); ps->SetPoint(3, p4); ps->SetPointData(3, pd4); ps->SetPoint(4, p5); ps->SetPointData(4, pd5); TransformType::Pointer transform = TransformType::New(); transform->SetCenter(center); // Instantiating object FilterType::Pointer filter = FilterType::New(); filter->SetOutputSize(size); filter->SetMetricThreshold(thresh); filter->SetPointSet(ps); filter->SetTransform(transform); filter->AddAngularParameter(0); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } otbBSplinesInterpolateTransformDisplacementFieldGeneratorNew.cxx000066400000000000000000000027741301006202600406570ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbBSplinesInterpolateTransformDisplacementFieldGenerator.h" int otbBSplinesInterpolateTransformDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::Array ParametersType; typedef itk::PointSet PointSetType; typedef otb::BSplinesInterpolateTransformDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/DisplacementField/test/otbDisplacementFieldTestDriver.cxx000066400000000000000000000020451301006202600326550ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbNearestTransformDisplacementFieldGeneratorNew); REGISTER_TEST(otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator); REGISTER_TEST(otbNNearestPointsLinearInterpolateDisplacementFieldGenerator); REGISTER_TEST(otbNearestPointDisplacementFieldGeneratorNew); REGISTER_TEST(otbPointSetToDisplacementFieldGeneratorNew); REGISTER_TEST(otbPointSetWithTransformToDisplacementFieldGeneratorNew); REGISTER_TEST(otbBSplinesInterpolateDisplacementFieldGeneratorNew); REGISTER_TEST(otbNNearestTransformsLinearInterpolateDisplacementFieldGeneratorNew); REGISTER_TEST(otbNNearestPointsLinearInterpolateDisplacementFieldGeneratorNew); REGISTER_TEST(otbNearestTransformDisplacementFieldGenerator); REGISTER_TEST(otbNearestPointDisplacementFieldGenerator); REGISTER_TEST(otbBSplinesInterpolateTransformDisplacementFieldGenerator); REGISTER_TEST(otbBSplinesInterpolateDisplacementFieldGenerator); REGISTER_TEST(otbBSplinesInterpolateTransformDisplacementFieldGeneratorNew); } otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.cxx000066400000000000000000000055751301006202600406430ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.h" #include "otbImageFileWriter.h" int otbNNearestPointsLinearInterpolateDisplacementFieldGenerator(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const char * outfname = argv[1]; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::Array ParamType; typedef itk::PointSet PointSetType; typedef PointSetType::PointType PointType; typedef otb::NNearestPointsLinearInterpolateDisplacementFieldGenerator FilterType; typedef otb::ImageFileWriter WriterType; ImageType::SizeType size; size.Fill(100); double thresh = 0.9; // Preparing point set PointSetType::Pointer ps = PointSetType::New(); PointType p1, p2, p3, p4, p5; ParamType pd1(3), pd2(3), pd3(3), pd4(3), pd5(3); p1[0] = 10; p1[1] = 10; p2[0] = 75; p2[1] = 10; p3[0] = 50; p3[1] = 50; p4[0] = 10; p4[1] = 60; p5[0] = 85; p5[1] = 70; pd1[0] = 0.95; pd1[1] = 10; pd1[2] = -5; pd2[0] = 0.98; pd2[1] = 2; pd2[2] = 5; pd3[0] = 0.5; pd3[1] = 20; pd3[2] = -20; pd4[0] = 0.91; pd4[1] = 15; pd4[2] = -5; pd5[0] = 0.91; pd5[1] = 5; pd5[2] = 5; ps->SetPoint(0, p1); ps->SetPointData(0, pd1); ps->SetPoint(1, p2); ps->SetPointData(1, pd2); ps->SetPoint(2, p3); ps->SetPointData(2, pd3); ps->SetPoint(3, p4); ps->SetPointData(3, pd4); ps->SetPoint(4, p5); ps->SetPointData(4, pd5); // Instantiating object FilterType::Pointer filter = FilterType::New(); filter->SetOutputSize(size); filter->SetMetricThreshold(thresh); filter->SetNumberOfPoints(5); filter->SetPointSet(ps); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } otbNNearestPointsLinearInterpolateDisplacementFieldGeneratorNew.cxx000066400000000000000000000030141301006202600412770ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNNearestPointsLinearInterpolateDisplacementFieldGenerator.h" int otbNNearestPointsLinearInterpolateDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PointType PointType; typedef itk::PointSet PointSetType; typedef otb::NNearestPointsLinearInterpolateDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.cxx000066400000000000000000000067251301006202600415230ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.h" #include "otbImageFileWriter.h" #include "itkEuler2DTransform.h" int otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const char * outfname = argv[1]; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::Array ParamType; typedef itk::PointSet PointSetType; typedef PointSetType::PointType PointType; typedef otb::NNearestTransformsLinearInterpolateDisplacementFieldGenerator FilterType; typedef otb::ImageFileWriter WriterType; typedef itk::Euler2DTransform TransformType; ImageType::SizeType size; size.Fill(100); double thresh = 0.9; // Preparing point set PointSetType::Pointer ps = PointSetType::New(); PointType p1, p2, p3, p4, p5; ParamType pd1(6), pd2(6), pd3(6), pd4(6), pd5(6); itk::Point center; p1[0] = 10; p1[1] = 10; p2[0] = 75; p2[1] = 10; p3[0] = 50; p3[1] = 50; p4[0] = 10; p4[1] = 60; p5[0] = 85; p5[1] = 70; center.Fill(50); pd1[0] = 0.95; pd1[1] = 0; pd1[2] = 0; pd1[3] = 5; pd1[4] = 5; pd1[5] = 0.001769; pd2[0] = 0.98; pd2[1] = 0; pd2[2] = 0; pd2[3] = -5; pd2[4] = 5; pd2[5] = -0.001769; pd3[0] = 0.5; pd3[1] = 0; pd3[2] = 0; pd3[3] = 0; pd3[4] = 0; pd3[5] = 0; pd4[0] = 0.91; pd4[1] = 0; pd4[2] = 0; pd4[3] = 5; pd4[4] = -5; pd4[5] = 0.001769; pd5[0] = 0.91; pd5[1] = 0; pd5[2] = 0; pd5[3] = -5; pd5[4] = -5; pd5[5] = -0.001769; ps->SetPoint(0, p1); ps->SetPointData(0, pd1); ps->SetPoint(1, p2); ps->SetPointData(1, pd2); ps->SetPoint(2, p3); ps->SetPointData(2, pd3); ps->SetPoint(3, p4); ps->SetPointData(3, pd4); ps->SetPoint(4, p5); ps->SetPointData(4, pd5); TransformType::Pointer transform = TransformType::New(); transform->SetCenter(center); // Instantiating object FilterType::Pointer filter = FilterType::New(); filter->SetOutputSize(size); filter->SetMetricThreshold(thresh); filter->SetNumberOfPoints(5); filter->SetPointSet(ps); filter->SetTransform(transform); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } otbNNearestTransformsLinearInterpolateDisplacementFieldGeneratorNew.cxx000066400000000000000000000030501301006202600421610ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNNearestTransformsLinearInterpolateDisplacementFieldGenerator.h" int otbNNearestTransformsLinearInterpolateDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PointType PointType; typedef itk::PointSet PointSetType; typedef otb::NNearestTransformsLinearInterpolateDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbNearestPointDisplacementFieldGenerator.cxx000066400000000000000000000052621301006202600347710ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNearestPointDisplacementFieldGenerator.h" #include "otbImageFileWriter.h" int otbNearestPointDisplacementFieldGenerator(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const char * outfname = argv[1]; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::Array ParamType; typedef itk::PointSet PointSetType; typedef PointSetType::PointType PointType; typedef otb::NearestPointDisplacementFieldGenerator FilterType; typedef otb::ImageFileWriter WriterType; ImageType::SizeType size; size.Fill(100); double thresh = 0.9; // Preparing point set PointSetType::Pointer ps = PointSetType::New(); PointType p1, p2, p3, p4, p5; ParamType pd1(3), pd2(3), pd3(3), pd4(3), pd5(3); p1[0] = 10; p1[1] = 10; p2[0] = 75; p2[1] = 10; p3[0] = 50; p3[1] = 50; p4[0] = 10; p4[1] = 60; p5[0] = 85; p5[1] = 70; pd1[0] = 0.95; pd1[1] = 10; pd1[2] = -5; pd2[0] = 0.98; pd2[1] = 2; pd2[2] = 5; pd3[0] = 0.5; pd3[1] = 20; pd3[2] = -20; pd4[0] = 0.91; pd4[1] = 15; pd4[2] = -5; pd5[0] = 0.91; pd5[1] = 5; pd5[2] = 5; ps->SetPoint(0, p1); ps->SetPointData(0, pd1); ps->SetPoint(1, p2); ps->SetPointData(1, pd2); ps->SetPoint(2, p3); ps->SetPointData(2, pd3); ps->SetPoint(3, p4); ps->SetPointData(3, pd4); ps->SetPoint(4, p5); ps->SetPointData(4, pd5); // Instantiating object FilterType::Pointer filter = FilterType::New(); filter->SetOutputSize(size); filter->SetMetricThreshold(thresh); filter->SetPointSet(ps); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } otbNearestPointDisplacementFieldGeneratorNew.cxx000066400000000000000000000025411301006202600354400ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNearestPointDisplacementFieldGenerator.h" int otbNearestPointDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::FixedArray PointDataType; typedef itk::PointSet PointSetType; typedef otb::NearestPointDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbNearestTransformDisplacementFieldGenerator.cxx000066400000000000000000000063671301006202600356620ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNearestTransformDisplacementFieldGenerator.h" #include "otbImageFileWriter.h" #include "itkEuler2DTransform.h" int otbNearestTransformDisplacementFieldGenerator(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const char * outfname = argv[1]; typedef double PixelType; typedef otb::VectorImage ImageType; typedef itk::Array ParamType; typedef itk::PointSet PointSetType; typedef PointSetType::PointType PointType; typedef otb::NearestTransformDisplacementFieldGenerator FilterType; typedef otb::ImageFileWriter WriterType; typedef itk::Euler2DTransform TransformType; ImageType::SizeType size; size.Fill(100); double thresh = 0.9; // Preparing point set PointSetType::Pointer ps = PointSetType::New(); PointType p1, p2, p3, p4, p5; ParamType pd1(6), pd2(6), pd3(6), pd4(6), pd5(6); itk::Point center; p1[0] = 10; p1[1] = 10; p2[0] = 75; p2[1] = 10; p3[0] = 50; p3[1] = 50; p4[0] = 10; p4[1] = 60; p5[0] = 85; p5[1] = 70; center.Fill(50); pd1[0] = 0.95; pd1[1] = 0; pd1[2] = 0; pd1[3] = 5; pd1[4] = 5; pd1[5] = 0.001769; pd2[0] = 0.98; pd2[1] = 0; pd2[2] = 0; pd2[3] = -5; pd2[4] = 5; pd2[5] = -0.001769; pd3[0] = 0.5; pd3[1] = 0; pd3[2] = 0; pd3[3] = 0; pd3[4] = 0; pd3[5] = 0; pd4[0] = 0.91; pd4[1] = 0; pd4[2] = 0; pd4[3] = 5; pd4[4] = -5; pd4[5] = 0.001769; pd5[0] = 0.91; pd5[1] = 0; pd5[2] = 0; pd5[3] = -5; pd5[4] = -5; pd5[5] = -0.001769; ps->SetPoint(0, p1); ps->SetPointData(0, pd1); ps->SetPoint(1, p2); ps->SetPointData(1, pd2); ps->SetPoint(2, p3); ps->SetPointData(2, pd3); ps->SetPoint(3, p4); ps->SetPointData(3, pd4); ps->SetPoint(4, p5); ps->SetPointData(4, pd5); TransformType::Pointer transform = TransformType::New(); transform->SetCenter(center); // Instantiating object FilterType::Pointer filter = FilterType::New(); filter->SetOutputSize(size); filter->SetMetricThreshold(thresh); filter->SetPointSet(ps); filter->SetTransform(transform); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outfname); writer->Update(); return EXIT_SUCCESS; } otbNearestTransformDisplacementFieldGeneratorNew.cxx000066400000000000000000000026431301006202600363250ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbNearestTransformDisplacementFieldGenerator.h" int otbNearestTransformDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PointType PointType; typedef itk::PointSet PointSetType; typedef otb::NearestTransformDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbPointSetToDisplacementFieldGeneratorNew.cxx000066400000000000000000000025711301006202600351000ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbPointSetToDisplacementFieldGenerator.h" int otbPointSetToDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PointType PointType; typedef itk::PointSet PointSetType; typedef otb::PointSetToDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbPointSetWithTransformToDisplacementFieldGeneratorNew.cxx000066400000000000000000000027241301006202600376300ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/DisplacementField/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "itkPointSet.h" #include "otbVectorImage.h" #include "otbPointSetWithTransformToDisplacementFieldGenerator.h" int otbPointSetWithTransformToDisplacementFieldGeneratorNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double PixelType; typedef otb::VectorImage ImageType; typedef ImageType::PointType PointType; typedef itk::PointSet PointSetType; typedef otb::PointSetWithTransformToDisplacementFieldGenerator FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/Stereo/000077500000000000000000000000001301006202600207415ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/Stereo/CMakeLists.txt000066400000000000000000000000451301006202600235000ustar00rootroot00000000000000project(OTBStereo) otb_module_impl() OTB-release-5.8/Modules/Registration/Stereo/include/000077500000000000000000000000001301006202600223645ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/Stereo/include/otbAdhesionCorrectionFilter.h000066400000000000000000000155061301006202600302010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAdhesionCorrectionFilter_h #define otbAdhesionCorrectionFilter_h #include "itkImageToImageFilter.h" #include "otbImage.h" #include "itkConstNeighborhoodIterator.h" #include "itkImageRegionConstIterator.h" #include "itkImageLinearConstIteratorWithIndex.h" #include namespace otb { /** \class AdhesionCorrectionFilter * \brief This filter eliminates pixels risking adhesion from the input disparity map. * To do so it applies the following steps : * - computation of incoherence areas (look for jumps in the disparity map) * - computation of no detected jumps thanks to an image representing edges (Canny filtering) * - computation of intersections between jumps in the disparity map * - creation of a risk map (pixels potentially affected by adhesion) * - computation of extrema in the risk map * - extension of risk map borders: pixels touching borders of the risk map are removed * * Inputs are provided as follows: * - SetInput() provides an image of edges detected in the reference image (for instance using Canny algorithm) * - SetMedianDisparityInput() provides the median disparity map * - SetMedianMaskInput() provides the mask associated to the median disparity map * - SetEdgesDisparityInput() provides an image of edges detected in the median disparity map * - SetSubPixelMaskInput() provides the mask associated to the subpixel disparity map * * The filter proposes as outputs: * - GetOutput() provides the disparity map after adhesion correction * - GetOutputMask() provides the mask associated to the disparity map after adhesion correction * - GetOutputRiskEdges() provides the map of risk edges * * * \sa FineRegistrationImageFilter, FastCorrelationImageFilter, DisparityMapEstimationMethod, DisparityMapAndMaskEstimationFilter * \ingroup IntensityImageFilters, Streamed * * See Publications : N. Sabater, J.M. Morel, A. Almansa and G. Blanchet, "Discarding moving objects in quasi-simultaneous stereovision", in IEEE International Conference on Image Processing, ICIP'10, 2010. * N. Sabater, J.M. Morel and A. Almansa, "Sub-pixel stereo matching", in IEEE International Geoscience and Remote Sensing Symposium, IGARSS'10, 2010. * * \ingroup OTBStereo */ template class ITK_EXPORT AdhesionCorrectionFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef AdhesionCorrectionFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(AdhesionCorrectionFilter, ImageToImageFilter); /** Some convenient typedefs. */ typedef typename TImage::RegionType ImageRegionType; typedef typename TImage::PixelType PixelType; typedef typename TImage::Pointer ImagePointerType; typedef typename TImage::SizeType SizeType; typedef typename TImage::IndexType IndexType; typedef typename TImage::SpacingType SpacingType; typedef typename TImage::PointType PointType; typedef typename TImage::OffsetType OffsetType; typedef typename TMask::Pointer MaskImagePointerType; typedef typename TMask::PixelType MaskImagePixelType; typedef itk::ConstNeighborhoodIterator NeighborhoodIteratorType; typedef otb::Image AuxImageType; typedef typename AuxImageType::Pointer AuxImagePointerType; typedef std::vector IntVectorType; /** Set input images **/ void SetMedianDisparityInput( const TImage * medianmap); void SetMedianMaskInput( const TMask * medianmask); void SetEdgesDisparityInput( const TImage * cannymedianmap); void SetSubPixelMaskInput( const TMask * subpixelmask); /** Get the inputs */ const TImage * GetMedianDisparityInput(); const TMask * GetMedianMaskInput(); const TImage * GetEdgesDisparityInput(); const TMask * GetSubPixelMaskInput(); /** Get the output mask **/ TMask * GetOutputMask(); // mask corresponding to the corrected disparity map /** Get the output risk edges **/ TImage * GetOutputRiskEdges(); /** Set/Get the radius */ itkSetMacro(Radius, SizeType); itkGetMacro(Radius, SizeType); /** Set unsigned int radius */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); } /** Set/Get the threshold for the tolerated difference between disparities */ itkSetMacro(Tolerance, double); itkGetMacro(Tolerance, double); /** Set/Get the discontinuity threshold */ itkSetMacro(DiscontinuityThreshold, double); itkGetMacro(DiscontinuityThreshold, double); /** Set/Get the high discontinuity threshold */ itkSetMacro(DiscontinuityHighThreshold, double); itkGetMacro(DiscontinuityHighThreshold, double); /** Set/Get the maximum edge gap */ itkSetMacro(MaxEdgeGap, double); itkGetMacro(MaxEdgeGap, double); /** Set/Get the edge threshold */ itkSetMacro(EdgeThreshold, double); itkGetMacro(EdgeThreshold, double); protected: /** Constructor */ AdhesionCorrectionFilter(); /** Destructor */ ~AdhesionCorrectionFilter() ITK_OVERRIDE {}; /** Threaded generate data */ void GenerateData() ITK_OVERRIDE; /** Generate the input requested regions */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Generate output information */ void GenerateOutputInformation(void) ITK_OVERRIDE; private: AdhesionCorrectionFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented SizeType m_ImageSize; /** The radius for correlation */ SizeType m_Radius; /** Tolerance */ double m_Tolerance; /** Thresholds */ double m_DiscontinuityThreshold; double m_DiscontinuityHighThreshold; double m_MaxEdgeGap; double m_EdgeThreshold; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbAdhesionCorrectionFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbAdhesionCorrectionFilter.txx000066400000000000000000002007551301006202600305770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbAdhesionCorrectionFilter_txx #define otbAdhesionCorrectionFilter_txx #include "otbAdhesionCorrectionFilter.h" #include "itkProgressReporter.h" #include "itkLinearInterpolateImageFunction.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkNormalizedCorrelationImageToImageMetric.h" #include "itkExceptionObject.h" namespace otb { /** * Constructor */ template AdhesionCorrectionFilter ::AdhesionCorrectionFilter() { this->SetNumberOfRequiredInputs( 5 ); this->SetNumberOfRequiredOutputs(3); this->SetNthOutput(1,TMask::New()); this->SetNthOutput(2,TImage::New()); // Default radius m_Radius.Fill(3); // Default Tolerance m_Tolerance = 0.25; // Default Thresholds m_DiscontinuityThreshold = 10.0; m_DiscontinuityHighThreshold = 30.0; m_MaxEdgeGap = 100.0; m_EdgeThreshold = 100.0; } template void AdhesionCorrectionFilter ::SetMedianDisparityInput( const TImage * medianmap ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( medianmap )); } template void AdhesionCorrectionFilter ::SetMedianMaskInput( const TMask * medianmask) { // Process object is not const-correct so the const casting is required. this->SetNthInput(2, const_cast( medianmask )); } template void AdhesionCorrectionFilter ::SetEdgesDisparityInput( const TImage * cannymedianmap) { // Process object is not const-correct so the const casting is required. this->SetNthInput(3, const_cast( cannymedianmap )); } template void AdhesionCorrectionFilter ::SetSubPixelMaskInput( const TMask * subpixelmask) { // Process object is not const-correct so the const casting is required. this->SetNthInput(4, const_cast( subpixelmask )); } template const TImage * AdhesionCorrectionFilter ::GetMedianDisparityInput() { if (this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template const TMask * AdhesionCorrectionFilter ::GetMedianMaskInput() { if (this->GetNumberOfInputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template const TImage * AdhesionCorrectionFilter ::GetEdgesDisparityInput() { if (this->GetNumberOfInputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3)); } template const TMask * AdhesionCorrectionFilter ::GetSubPixelMaskInput() { if (this->GetNumberOfInputs()<5) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(4)); } template TMask * AdhesionCorrectionFilter ::GetOutputMask() { if (this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template TImage * AdhesionCorrectionFilter ::GetOutputRiskEdges() { if (this->GetNumberOfOutputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(2)); } template void AdhesionCorrectionFilter ::GenerateOutputInformation() { // Call superclass implementation Superclass::GenerateOutputInformation(); // Retrieve output pointers TImage * outputPtr = this->GetOutput(); TMask * outputMaskPtr = this->GetOutputMask(); TImage * outputriskedgesPtr = this->GetOutputRiskEdges(); // Update size and spacing according to grid step ImageRegionType largestRegion = outputPtr->GetLargestPossibleRegion(); SizeType outputSize = largestRegion.GetSize(); m_ImageSize = outputSize; SpacingType outputSpacing = outputPtr->GetSpacing(); // Set spacing outputPtr->SetSpacing(outputSpacing); outputMaskPtr->SetSpacing(outputSpacing); outputriskedgesPtr->SetSpacing(outputSpacing); // Set largest region size largestRegion.SetSize(outputSize); outputPtr->SetLargestPossibleRegion(largestRegion); outputMaskPtr->SetLargestPossibleRegion(largestRegion); outputriskedgesPtr->SetLargestPossibleRegion(largestRegion); } template void AdhesionCorrectionFilter ::GenerateInputRequestedRegion() { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the input and output TImage * canny_edges = const_cast< TImage * >( this->GetInput()); TImage * old_disparityPtr = const_cast< TImage * >( this->GetMedianDisparityInput()); TMask * old_maskPtr = const_cast< TMask * >( this->GetMedianMaskInput()); TImage * canny_disparity = const_cast< TImage * >(this->GetEdgesDisparityInput()); TMask * subpixelmaskPtr = const_cast< TMask * >(this->GetSubPixelMaskInput()); TImage * outputPtr = this->GetOutput(); TMask * outputmaskPtr = this->GetOutputMask(); TImage * outputriskedgesPtr = this->GetOutputRiskEdges(); if ( !canny_edges || !old_disparityPtr || !old_maskPtr || !canny_disparity || !subpixelmaskPtr || !outputPtr || !outputmaskPtr || !outputriskedgesPtr) { return; } // get a copy of the fixed requested region (should equal the output // requested region) ImageRegionType RequestedRegion; RequestedRegion = outputPtr->GetRequestedRegion(); SizeType Big_Radius; Big_Radius[0] = m_Radius[0] +2; Big_Radius[1] = m_Radius[1] +2; RequestedRegion.PadByRadius( Big_Radius ); // crop the region at the largest possible region if ( RequestedRegion.Crop(canny_edges->GetLargestPossibleRegion())) { canny_edges->SetRequestedRegion( RequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) canny_edges->SetRequestedRegion( RequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(canny_edges); throw e; } // crop the region at the largest possible region if ( RequestedRegion.Crop(old_disparityPtr->GetLargestPossibleRegion())) { old_disparityPtr->SetRequestedRegion( RequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) old_disparityPtr->SetRequestedRegion( RequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(old_disparityPtr); throw e; } // crop the region at the largest possible region if ( RequestedRegion.Crop(old_maskPtr->GetLargestPossibleRegion())) { old_maskPtr->SetRequestedRegion( RequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) old_maskPtr->SetRequestedRegion( RequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(old_maskPtr); throw e; } // crop the region at the largest possible region if ( RequestedRegion.Crop(canny_disparity->GetLargestPossibleRegion())) { canny_disparity->SetRequestedRegion( RequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) canny_disparity->SetRequestedRegion( RequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(canny_disparity); throw e; } // crop the region at the largest possible region if ( RequestedRegion.Crop(subpixelmaskPtr->GetLargestPossibleRegion())) { subpixelmaskPtr->SetRequestedRegion( RequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) subpixelmaskPtr->SetRequestedRegion( RequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(subpixelmaskPtr); throw e; } return; } template void AdhesionCorrectionFilter ::GenerateData() { // Allocate outputs this->AllocateOutputs(); // get pointers to the input and output TImage * canny_edges = const_cast< TImage * >( this->GetInput()); TImage * old_disparityPtr = const_cast< TImage * >( this->GetMedianDisparityInput()); TMask * old_maskPtr = const_cast< TMask * >( this->GetMedianMaskInput()); TImage * canny_disparity = const_cast< TImage * >(this->GetEdgesDisparityInput()); TMask * subpixelmaskPtr = const_cast< TMask * >(this->GetSubPixelMaskInput()); TImage * outputPtr = this->GetOutput(); TMask * outputmaskPtr = this->GetOutputMask(); TImage * outputriskedgesPtr = this->GetOutputRiskEdges(); outputriskedgesPtr->FillBuffer(0.0); int win = m_Radius[0]+1; // should be also equal to m_Radius[1] int patch_side = 2*win+1; int patch_side_small = 2*(win-1)+1; int big_dist = 3*win; int dif, new_step; /* positions around a pixel*/ IntVectorType ring; IntVectorType pix; ring.push_back(-1-outputPtr->GetRequestedRegion().GetSize()[0] - outputPtr->GetRequestedRegion().GetIndex()[0]); ring.push_back(0-outputPtr->GetRequestedRegion().GetSize()[0] - outputPtr->GetRequestedRegion().GetIndex()[0]); ring.push_back(1-outputPtr->GetRequestedRegion().GetSize()[0] - outputPtr->GetRequestedRegion().GetIndex()[0]); ring.push_back(1); ring.push_back(1+outputPtr->GetRequestedRegion().GetSize()[0] + outputPtr->GetRequestedRegion().GetIndex()[0]); ring.push_back(outputPtr->GetRequestedRegion().GetSize()[0] + outputPtr->GetRequestedRegion().GetIndex()[0]); ring.push_back(-1+outputPtr->GetRequestedRegion().GetSize()[0] + outputPtr->GetRequestedRegion().GetIndex()[0]); ring.push_back(-1); //// Compute incoherences (jumps) of the disparity map in the epipolar direction //// disparity_jump = mask of jumps in the epipolar direction: //// flags to disparity jump: 1--->jump due to a left border //// 2--->jump due to a right border //// 3--->jump due to a hole. Seems to be a left border //// 4--->jump due to a hole. Seems to be a right border AuxImagePointerType disparity_jump = AuxImageType::New(); disparity_jump->SetRegions(old_disparityPtr->GetRequestedRegion()); disparity_jump->Allocate(); disparity_jump->FillBuffer(0); AuxImagePointerType disparity_jump2 = AuxImageType::New(); disparity_jump2->SetRegions(old_disparityPtr->GetRequestedRegion()); disparity_jump2->Allocate(); disparity_jump2->FillBuffer(0); AuxImagePointerType aux = AuxImageType::New(); aux->SetRegions(outputPtr->GetRequestedRegion()); aux->Allocate(); aux->FillBuffer(0); /** input iterators */ itk::ImageRegionConstIterator old_disparityIt(old_disparityPtr,old_disparityPtr->GetRequestedRegion()); itk::ImageRegionConstIterator old_maskIt(old_maskPtr,old_maskPtr->GetRequestedRegion()); itk::ImageRegionConstIterator canny_disparityIt(canny_disparity,canny_disparity->GetRequestedRegion()); itk::ImageRegionConstIterator canny_edgesIt(canny_edges,canny_edges->GetRequestedRegion()); IndexType index, index2, index_pos, index_pos_actual, index_pos_old, index_pos_new, index_pos0; /** Output iterators */ itk::ImageRegionIterator new_disparityIt(outputPtr,outputPtr->GetRequestedRegion()); itk::ImageRegionIterator new_maskIt(outputmaskPtr,outputPtr->GetRequestedRegion()); itk::ImageRegionIterator disparity_jumpIt(disparity_jump,outputPtr->GetRequestedRegion()); itk::ImageRegionIterator disparity_jump2It(disparity_jump2,outputPtr->GetRequestedRegion()); itk::ImageRegionIterator risk_edgesIt(outputriskedgesPtr,outputPtr->GetRequestedRegion()); itk::ImageRegionIterator auxIt(aux,outputPtr->GetRequestedRegion()); new_maskIt.GoToBegin(); new_disparityIt.GoToBegin(); /** INITIALIZATION */ while (!new_maskIt.IsAtEnd() && !new_disparityIt.IsAtEnd()) { old_maskIt.SetIndex(new_maskIt.GetIndex()); old_disparityIt.SetIndex(new_disparityIt.GetIndex()); new_maskIt.Set(old_maskIt.Get()); new_disparityIt.Set(old_disparityIt.Get()); ++old_disparityIt; ++new_maskIt; ++new_disparityIt; ++old_maskIt; } new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos=new_disparityIt.GetIndex(); if (new_disparityIt.GetIndex()[1] >= outputPtr->GetRequestedRegion().GetIndex()[1] && new_disparityIt.GetIndex()[1] < static_cast(m_ImageSize[1]) - win) { old_maskIt.SetIndex(index_pos); while (old_maskIt.Get() == 0 && new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0]) { ++new_disparityIt; old_maskIt.SetIndex(new_disparityIt.GetIndex()); } index_pos = new_disparityIt.GetIndex(); disparity_jumpIt.SetIndex(index_pos); disparity_jumpIt.Set(-1); // first disparity in the epipolar line int k=0; while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - win) { index_pos = new_disparityIt.GetIndex(); if (old_maskPtr->GetPixel(index_pos) == 0) // holes in the disparity map { if (k==0) { k++; int i=1; index[0]=index_pos[0]+i; index[1]=index_pos[1]; old_maskIt.SetIndex(index); new_disparityIt.SetIndex(index); while(new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && old_maskIt.Get()==0) { i++; index[0]=index_pos[0]+i; new_disparityIt.SetIndex(index); old_maskIt.SetIndex(index); } if (new_disparityIt.GetIndex()[0] == static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { disparity_jumpIt.SetIndex(index_pos); disparity_jumpIt.Set(4); } else { index[0]=index_pos[0]-1; index2[0]=index_pos[0]+i; index2[1]=index_pos[1]; if (vcl_abs(old_disparityPtr->GetPixel(index) - old_disparityPtr->GetPixel(index2)) > m_Tolerance) { if (old_disparityPtr->GetPixel(index) < old_disparityPtr->GetPixel(index2)) { index2[0] = index_pos[0] + i -1; disparity_jumpIt.SetIndex(index2); disparity_jumpIt.Set(3); if (i>=win) { disparity_jumpIt.SetIndex(index_pos); disparity_jumpIt.Set(4); // big holes } } else { disparity_jumpIt.SetIndex(index_pos); disparity_jumpIt.Set(4); if (i>=win) { index[0]=index_pos[0] + i -1; disparity_jumpIt.SetIndex(index); disparity_jumpIt.Set(3); // big holes } } } } } } else // Disparity map discontinuities { if (canny_disparity->GetPixel(index_pos) > m_DiscontinuityThreshold ) { int pp=0; for(k=0; k<8; k++) { index[0]=index_pos[0]+ring[k]; index[1]=index_pos[1]; if(old_maskPtr->GetPixel(index)==0) pp++; } if(pp==0) { index[0]=index_pos[0]-1; index[1]=index_pos[1]; index2[0]=index_pos[0]+1; index2[1]=index_pos[1]; if (old_disparityPtr->GetPixel(index) < old_disparityPtr->GetPixel(index2)) { disparity_jumpIt.SetIndex(index); disparity_jumpIt.Set(1); } if (old_disparityPtr->GetPixel(index) > old_disparityPtr->GetPixel(index2)) { disparity_jumpIt.SetIndex(index2); disparity_jumpIt.Set(2); } } } k=0; } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Compute jumps of the disparity map in the epipolar direction not detected by Canny */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos = new_disparityIt.GetIndex(); old_maskIt.SetIndex(index_pos); while (old_maskIt.Get() == 0 && new_disparityIt.GetIndex()[0] < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { ++new_disparityIt; old_maskIt.SetIndex(new_disparityIt.GetIndex()); } index_pos = new_disparityIt.GetIndex(); old_disparityIt.SetIndex(index_pos); // double disp = old_disparityIt.Get(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { index_pos = new_disparityIt.GetIndex(); index = index_pos; index[0] = index_pos[0]+1; old_maskIt.SetIndex(index_pos); if (old_maskIt.Get() != 0 && old_maskPtr->GetPixel(index) != 0) { if (vcl_abs(old_disparityPtr->GetPixel(index_pos) - old_disparityPtr->GetPixel(index)) > m_Tolerance) { if (old_disparityPtr->GetPixel(index) > old_disparityPtr->GetPixel(index_pos) && disparity_jump->GetPixel(index_pos) == 0) { disparity_jumpIt.SetIndex(index_pos); disparity_jumpIt.Set(1); } if (old_disparityPtr->GetPixel(index) < old_disparityPtr->GetPixel(index_pos) && disparity_jump->GetPixel(index) == 0) { disparity_jumpIt.SetIndex(index); disparity_jumpIt.Set(2); } } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Compute intersections between jumps */ /** disparity_jump2 = mask of jumps in the orthogonal epipolar direction: */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos = new_disparityIt.GetIndex(); ++new_disparityIt; while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { index_pos = new_disparityIt.GetIndex(); disparity_jumpIt.SetIndex(index_pos); if (disparity_jumpIt.Get() == 1 || disparity_jumpIt.Get() == 2 ) { for (int k=0; k<8; k++) { index=index_pos; index[0]=index_pos[0]+ring[k]; disparity_jumpIt.SetIndex(index); if ((disparity_jumpIt.Get() == 1 || disparity_jumpIt.Get() == 2) && disparity_jumpIt.Get() != disparity_jump->GetPixel(index_pos)) { for (int i=-2*win; i<=2*win; i++) { int l=-2-win; index2[0] = index_pos[0] + i; index2[1] = index_pos[1] + l; while (old_maskPtr->GetBufferedRegion().IsInside(index2) && old_maskPtr->GetPixel(index2) == 0) { l++; index2[1] = index_pos[1] + l; } if (index2[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index2[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) // add this condition to avoid seg fault { disparity_jump2It.SetIndex(index2); disparity_jump2It.Set(7); } } } } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Only keep 1 pixel for each discontinuity */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos = new_disparityIt.GetIndex(); old_maskIt.SetIndex(index_pos); while (old_maskIt.Get() == 0 && new_disparityIt.GetIndex()[0] < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { ++new_disparityIt; old_maskIt.SetIndex(new_disparityIt.GetIndex()); } while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { index_pos = new_disparityIt.GetIndex(); disparity_jumpIt.SetIndex(index_pos); if (disparity_jumpIt.Get() == 1) { int i = 1; index = index_pos; index[0] = index_pos[0] + i; disparity_jumpIt.SetIndex(index); while (disparity_jumpIt.Get() == 1 ) { disparity_jumpIt.Set(0); i++; index[0] = index_pos[0] + i; disparity_jumpIt.SetIndex(index); } } disparity_jumpIt.SetIndex(index_pos); if (disparity_jumpIt.Get() == 2) { int i=-1; index = index_pos; index[0] = index_pos[0] + i; disparity_jumpIt.SetIndex(index); while (disparity_jumpIt.Get() == 2 ) { disparity_jumpIt.Set(0); i--; index[0] = index_pos[0] + i; disparity_jumpIt.SetIndex(index); } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Risk zone = pixels to the right for jumps with flag 1 or 3 and pixels to the left for jumps with flag 1 or 3 */ /** Inside the risk zone, we look for edges which may cause the adhesion--->risk_edges */ // Exploring the left-right epipolar direction new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos = new_disparityIt.GetIndex(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { index_pos = new_disparityIt.GetIndex(); disparity_jumpIt.SetIndex(index_pos); double value_max = m_EdgeThreshold; int index_max = -100; // Canny edges should be larger than m_EdgeThreshold if (disparity_jumpIt.Get() == 1) { int l=1; while (index_pos[0]+l(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && l<=big_dist && index_pos[0]+l(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index_pos[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index = index_pos; index[0] = index_pos[0] + l; if (canny_edges->GetPixel(index)>value_max) { value_max = canny_edges->GetPixel(index); index_max = index_pos[0] + l; } l++; } } if (disparity_jumpIt.Get() == 3) { int l=1; while (index_pos[0]+l(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && l<=big_dist && index_pos[0]+l(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index_pos[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] ) { index = index_pos; index[0] = index_pos[0] + l; if (canny_edges->GetPixel(index)>value_max) { value_max = canny_edges->GetPixel(index); index_max = index_pos[0] + l; } l++; } } if (disparity_jumpIt.Get() == 2) { int l=-1; while (index_pos[0]+l>=outputPtr->GetRequestedRegion().GetIndex()[0] && l>=-big_dist && index_pos[0]+l(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index_pos[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index = index_pos; index[0] = index_pos[0] + l; if (canny_edges->GetPixel(index)>value_max) { value_max = canny_edges->GetPixel(index); index_max = index_pos[0] + l; } l--; } } if (disparity_jumpIt.Get() == 4) { int l=-1; while (index_pos[0]+l>=outputPtr->GetRequestedRegion().GetIndex()[0] && l>=-big_dist && index_pos[0]+l(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index_pos[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index = index_pos; index[0] = index_pos[0] + l; if (canny_edges->GetPixel(index)>value_max) { value_max = canny_edges->GetPixel(index); index_max = index_pos[0] + l; } l--; } } if(index_max !=-100) { index = index_pos; index[0] = index_max; risk_edgesIt.SetIndex(index); risk_edgesIt.Set(1); // flag= 1 for risk edges } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Find extreme of risk edges : extreme points in the edges have flag 2, an the other edge points have flag = 1 */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos = new_disparityIt.GetIndex(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0]-1) { index_pos = new_disparityIt.GetIndex(); risk_edgesIt.SetIndex(index_pos); if (risk_edgesIt.Get() == 1) { int pp=0; for (int k=0; k<8; k++) { index = index_pos; index[0] = index_pos[0] + ring[k]; risk_edgesIt.SetIndex(index); if(risk_edgesIt.Get() > 0) pp++; } risk_edgesIt.SetIndex(index_pos); if (pp == 0) risk_edgesIt.Set(0); //remove isolate points if (pp == 1) risk_edgesIt.Set(2); if(pp==2) { int l=0; pix.clear(); for(int k=0; k<8; k++) { index = index_pos; index[0] = index_pos[0] + ring[k]; risk_edgesIt.SetIndex(index); if(risk_edgesIt.Get() > 0) { pix.push_back(k); l++; } } dif = (int) vcl_abs(pix[0]-pix[1]); risk_edgesIt.SetIndex(index_pos); if (dif==1 || dif==7) risk_edgesIt.Set(2); } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** extend extreme edges if necessary : * extreme points in the edges have flag 2, an the other edge points have flag = 1 */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] -1) { index_pos = new_disparityIt.GetIndex(); ++new_disparityIt; while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { index_pos = new_disparityIt.GetIndex(); risk_edgesIt.SetIndex(index_pos); if (risk_edgesIt.Get() == 2) { new_step = 1; index_pos_old = index_pos; while (new_step == 1) { new_step = 0; for(int k=0; k<8; k++) {//Ignore merging cases index_pos_actual = index_pos_old; index_pos_actual[0] = index_pos_old[0] +ring[k]; double m_max = 0; // if the next pixel is the continuation of the border,we extend the risk edge // // The extend the border, it has to be as prevalent as before // canny_edgesIt.SetIndex(index_pos_actual); if (canny_edgesIt.Get()>m_DiscontinuityHighThreshold && vcl_abs(canny_edgesIt.Get() - canny_edges->GetPixel(index_pos_old)) < m_MaxEdgeGap) { if (outputriskedgesPtr->GetPixel(index_pos_actual) ==0 && canny_edges->GetPixel(index_pos_actual) > m_max) { index_pos_new = index_pos_actual; new_step = 1; } } } if (new_step ==1) { risk_edgesIt.SetIndex(index_pos_old); risk_edgesIt.Set(1); risk_edgesIt.SetIndex(index_pos_new); risk_edgesIt.Set(2); auxIt.SetIndex(index_pos_new); auxIt.Set(1); index_pos_old = index_pos_new; //steps++; } } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Cut risk edges * remove pixel edges when the associated patch has the same disparity * Ie: the patch is in a planar surfarce without jumps */ int Count; int big_win = win + 1; // int half_big_win = (2*big_win +1)*(2*big_win +1) /2; double Tol2 = m_Tolerance/2; new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos = new_disparityIt.GetIndex(); if (index_pos[1]>=big_win + outputPtr->GetRequestedRegion().GetIndex()[1]) { while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { index_pos = new_disparityIt.GetIndex(); auxIt.SetIndex(index_pos); if( auxIt.Get() !=0 ) { double m_max = -10000000.; double m_min = -m_max; Count=0; for(int j= -big_win; j<= big_win; j++) { for(int i= -big_win; i<= big_win; i++) { if (index_pos[0] + i >= old_disparityPtr->GetRequestedRegion().GetIndex()[0] && index_pos[0] + i < static_cast(old_disparityPtr->GetRequestedRegion().GetSize()[0]) + old_disparityPtr->GetRequestedRegion().GetIndex()[0] && index_pos[1] + j >= old_disparityPtr->GetRequestedRegion().GetIndex()[1] && index_pos[1] + j < static_cast(old_disparityPtr->GetRequestedRegion().GetSize()[1]) + old_disparityPtr->GetRequestedRegion().GetIndex()[1]) { index_pos0[0] = index_pos[0] + i; index_pos0[1] = index_pos[1] + j; old_maskIt.SetIndex(index_pos0); if (old_maskIt.Get() == 1) { if (old_disparityPtr->GetPixel(index_pos0) > m_max) m_max = old_disparityPtr->GetPixel(index_pos0); if (old_disparityPtr->GetPixel(index_pos0) < m_min) m_min = old_disparityPtr->GetPixel(index_pos0); Count++; } new_disparityIt.SetIndex(index_pos); } } } /// If we have ~ the same disparity in a patch of radius big_win and we known the disparity for more the half pixels in this patch // risk_edgesIt.SetIndex(index_pos); if ((m_max-m_min)0) risk_edgesIt.Set(0); else { for(int j= -win; j<= win; j++) { for(int i= -win; i<= win; i++) { if (index_pos[0] + i >= outputPtr->GetRequestedRegion().GetIndex()[0] && index_pos[0] + i < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index_pos[1] + j >= outputPtr->GetRequestedRegion().GetIndex()[1] && index_pos[1] + j < static_cast(outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos0[0] = index_pos[0] + i; index_pos0[1] = index_pos[1] + j; new_disparityIt.SetIndex(index_pos0); new_maskIt.SetIndex(index_pos0); new_disparityIt.Set(0); new_maskIt.Set(0); } } } } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; index_pos = new_disparityIt.GetIndex(); } } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Remove edges with only 1 or 2 pixels */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]- 1) { ++new_disparityIt; while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0]-1) { index_pos = new_disparityIt.GetIndex(); risk_edgesIt.SetIndex(index_pos); if (risk_edgesIt.Get() == 2) { int pp=0; for(int k=0; k<8; k++) { index[0]=index_pos[0]+ring[k]; index[1]=index_pos[1]; risk_edgesIt.SetIndex(index); if (risk_edgesIt.Get() == 2) {// 2pix edge risk_edgesIt.Set(0); risk_edgesIt.SetIndex(index_pos); risk_edgesIt.Set(0); } risk_edgesIt.SetIndex(index); if (risk_edgesIt.Get() == 0) pp++; } risk_edgesIt.SetIndex(index_pos); if (pp == 8) risk_edgesIt.Set(0); // 1pix edge } ++new_disparityIt; ++disparity_jumpIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Remove pixels risking adhesion */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] - 1) { index_pos = new_disparityIt.GetIndex(); old_maskIt.SetIndex(index_pos); while (old_maskIt.Get() == 0 && new_disparityIt.GetIndex()[0] < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0]- 1) { ++new_disparityIt; old_maskIt.SetIndex(new_disparityIt.GetIndex()); } index_pos = new_disparityIt.GetIndex(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { index_pos = new_disparityIt.GetIndex(); int pp=0; int pp2=0; if (outputriskedgesPtr->GetPixel(index_pos) != 0) {// left int l=-patch_side; index[0]=index_pos[0]+l; index[1]=index_pos[1]; while ((new_disparityIt.GetIndex()[0] + l) >= outputPtr->GetRequestedRegion().GetIndex()[0] && l<=0 && disparity_jump->GetPixel(index) !=1 ) { l++; index[0]=index_pos[0]+l; } index[0]=index_pos[0]+l; if (disparity_jump->GetPixel(index) == 1) { pp++; for (int ii=l+1; ii<=0; ii++) { index[0]=index_pos[0]+ii; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); } int i=1; index[0]=index_pos[0]+i; while (disparity_jump->GetPixel(index) !=1 && i<=win) { index[0]=index_pos[0]+i; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); i++; index[0]=index_pos[0]+i; } pp2=0; index[0]=index_pos[0]+i; index[1]=index_pos[1]; if(disparity_jump->GetPixel(index) == 1) {//2a adhesion for(int j=1; j<=win; j++) { index2[0]=index_pos[0]+i+j; index2[1]=index_pos[1]; risk_edgesIt.SetIndex(index2); if (risk_edgesIt.Get() != 0) pp2++; } index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); if (pp2==0) disparity_jumpIt.Set(0); } index[0]=index_pos[0]+i+1; disparity_jumpIt.SetIndex(index); if(disparity_jumpIt.Get() == 1) { for(int j=1; j<=win; j++) { index2[0]=index_pos[0]+i+1+j; index2[1]=index_pos[1]; risk_edgesIt.SetIndex(index2); if (risk_edgesIt.Get() != 0) pp2++; } index[0]=index_pos[0]+i+1; disparity_jumpIt.SetIndex(index); if (pp2==0) disparity_jumpIt.Set(0); } } l=-big_dist; index[0]=index_pos[0]+l; index[1]=index_pos[1]; while ((new_disparityIt.GetIndex()[0] + l) >= outputPtr->GetRequestedRegion().GetIndex()[0] && l<=0 && disparity_jump->GetPixel(index) != 3) { l++; index[0]=index_pos[0]+l; } index[0]=index_pos[0]+l; if(disparity_jump->GetPixel(index) == 3) { pp++; for(int ii=l+1; ii<=0; ii++) { index[0]=index_pos[0]+ii; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); } int i=1; index[0]=index_pos[0]+i; while (disparity_jump->GetPixel(index) !=1 && i<=win) { index[0]=index_pos[0]+i; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); i++; index[0]=index_pos[0]+i; } pp2=0; index[0]=index_pos[0]+i; if (disparity_jump->GetPixel(index)==1) {//2a adhesion for (int j=1; j<=win; j++) { index2[0]=index_pos[0]+i+j; index2[1]=index_pos[1]; if(outputriskedgesPtr->GetPixel(index2) != 0) pp2++; } index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); if (pp2 == 0) disparity_jumpIt.Set(0); } index[0]=index_pos[0]+i+1; if (disparity_jump->GetPixel(index)==1) { for (int j=1; j<=win; j++) { index2[0]=index_pos[0]+i+1+j; index2[1]=index_pos[1]; if(outputriskedgesPtr->GetPixel(index2) != 0) pp2++; } index[0]=index_pos[0]+i+1; disparity_jumpIt.SetIndex(index); if (pp2 == 0) disparity_jumpIt.Set(0); } } // right l=patch_side; index[0]=index_pos[0]+l; index[1]=index_pos[1]; while ((new_disparityIt.GetIndex()[0] + l) < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0]- 1 && l>=0 && disparity_jump->GetPixel(index) != 2) { l--; index[0]=index_pos[0]+l; } index[0]=index_pos[0]+l; if(disparity_jump->GetPixel(index)==2) { pp++; for (int ii=l-1; ii>=0; ii--) { index[0]=index_pos[0]+ii; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); } int i=-1; index[0]=index_pos[0]+i; while (disparity_jump->GetPixel(index) != 2 && i>=-win) { index[0]=index_pos[0]+i; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); i--; index[0]=index_pos[0]+i; } pp2 = 0; index[0]=index_pos[0]+i; if (disparity_jump->GetPixel(index) == 2) {//2a adhesion for (int j=-1; j>=-win; j--) { index2[0]=index_pos[0]+i+j; index2[1]=index_pos[1]; if (outputriskedgesPtr->GetPixel(index2) !=0 ) pp2++; } index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); if (pp2==0) disparity_jumpIt.Set(0); } index[0]=index_pos[0]+i-1; if (disparity_jump->GetPixel(index) == 2) { for (int j=-1; j>=-win; j--) { index2[0]=index_pos[0]+i-1+j; index2[1]=index_pos[1]; if (outputriskedgesPtr->GetPixel(index2) !=0 ) pp2++; } index[0]=index_pos[0]+i-1; disparity_jumpIt.SetIndex(index); if (pp2==0) disparity_jumpIt.Set(0); } } l=big_dist; index[0]=index_pos[0]+l; index[1]=index_pos[1]; while ((new_disparityIt.GetIndex()[0] + l) < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0]- 1 && l>=0 && disparity_jump->GetPixel(index) != 4) { l--; index[0]=index_pos[0]+l; } index[0]=index_pos[0]+l; if (disparity_jump->GetPixel(index) == 4) { pp++; for (int ii=l-1; ii>=0; ii--) { index[0]=index_pos[0]+ii; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); } int i=-1; index[0]=index_pos[0]+i; while (disparity_jump->GetPixel(index) != 2 && i>=-win) { index[0]=index_pos[0]+i; new_disparityIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.SetIndex(index); new_maskIt.Set(0); i--; index[0]=index_pos[0]+i; } pp2=0; index[0]=index_pos[0]+i; if (disparity_jump->GetPixel(index) == 2) {//2a adhesion for (int j=-1; j>=-win; j--) { index2[0]=index_pos[0]+i+j; index2[1]=index_pos[1]; if (outputriskedgesPtr->GetPixel(index2) !=0 ) pp2++; } index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); if (pp2==0) disparity_jumpIt.Set(0); } index[0]=index_pos[0]+i-1; if (disparity_jump->GetPixel(index) == 2) { for (int j=-1; j>=-win; j--) { index2[0]=index_pos[0]+i-1+j; index2[1]=index_pos[1]; if (outputriskedgesPtr->GetPixel(index2) !=0 ) pp2++; } index[0]=index_pos[0]+i-1; disparity_jumpIt.SetIndex(index); if (pp2==0) disparity_jumpIt.Set(0); } } // if(pp==0) /// remove around the risk_edge if no disparity jump have been found // unique difference between new_adhesion and new_adhesion_2 // the version 2 commented the previous line for (int i=-win+1; i<=win-1; i++) { for (int k=-win+1; k<=win-1; k++) { index2[0]=index_pos[0]+i; index2[1]=index_pos[1]+k; if (index2[0]>=outputPtr->GetRequestedRegion().GetIndex()[0] && index2[1]>=outputPtr->GetRequestedRegion().GetIndex()[1] && index2[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index2[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { new_disparityIt.SetIndex(index2); new_maskIt.SetIndex(index2); new_disparityIt.Set(0); new_maskIt.Set(0); } } } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** remove around the disparity jump if no risk_edge have been found */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos = new_disparityIt.GetIndex(); old_maskIt.SetIndex(index_pos); while (old_maskIt.Get() == 0 && new_disparityIt.GetIndex()[0] < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { ++new_disparityIt; old_maskIt.SetIndex(new_disparityIt.GetIndex()); } while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { index_pos = new_disparityIt.GetIndex(); index[0]=index_pos[0]+1; index[1]=index_pos[1]; new_maskIt.SetIndex(index); risk_edgesIt.SetIndex(index); if ((disparity_jump->GetPixel(index_pos)==1 || disparity_jump->GetPixel(index_pos)==3) && new_maskIt.Get() !=0 && risk_edgesIt.Get() ==0 ) { int i=1; index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); while (i<=patch_side_small && disparity_jumpIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1 && disparity_jumpIt.Get()==0) { new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); i++; index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); } } index[0]=index_pos[0]-1; index[1]=index_pos[1]; new_maskIt.SetIndex(index); risk_edgesIt.SetIndex(index); if ((disparity_jump->GetPixel(index_pos)==2 || disparity_jump->GetPixel(index_pos)==4) && new_maskIt.Get() !=0 && risk_edgesIt.Get() ==0 ) { int i=-1; index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); while (i>=-patch_side_small && disparity_jumpIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1 && disparity_jumpIt.Get()==0 ) { new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); i--; index[0]=index_pos[0]+i; disparity_jumpIt.SetIndex(index); } } new_disparityIt.SetIndex(index_pos); ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Vertical lines (perpendicular to epipolar lines) */ /** Jumps of the disparity map in the other direction * disparity_jump_2: flag 7---> special case: intersections * flag 5---> jump due to an upper border * flag 6---> jump due to an lower border * flag 8---> jump due to an upper border + intersection * flag 9---> jump due to an lower border + intersection */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { index2 = new_disparityIt.GetIndex(); index=index2; old_maskIt.SetIndex(index2); while (old_maskIt.Get() == 0 && new_disparityIt.GetIndex()[1] < static_cast(outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] - 1) { index[1]=index[1]+1; old_maskIt.SetIndex(index); new_disparityIt.SetIndex(index); } double disp=old_disparityPtr->GetPixel(index); int k=0; while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] -1) { index_pos = new_disparityIt.GetIndex(); old_maskIt.SetIndex(index_pos); if (old_maskIt.Get() == 0) k++; else { if (vcl_abs(old_disparityPtr->GetPixel(index_pos)-disp)>m_Tolerance && k<=win) {//only small holes disparity_jump2It.SetIndex(index_pos); if (old_disparityPtr->GetPixel(index_pos)>disp) disparity_jump2It.Set(5); index[0]=index_pos[0]-1; index[1]=index_pos[1]; disparity_jump2It.SetIndex(index); if (old_disparityPtr->GetPixel(index_pos)GetPixel(index_pos); } index[0]=index_pos[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } new_disparityIt.SetIndex(index2); ++new_disparityIt; } /** Vertical lines (perpendicular to epipolar lines) part2 */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { int k=0; index2 = new_disparityIt.GetIndex(); index=index2; while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] - 1) { index_pos = new_disparityIt.GetIndex(); if (disparity_jump2->GetPixel(index_pos) == 7) { double disp=old_disparityPtr->GetPixel(index_pos); for (int i=0; i<=big_dist; i++) { if (index_pos[1]+i < static_cast(outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { index_pos0[0]=index_pos[0]; index_pos0[1]=index_pos[1]+i; if (old_maskPtr->GetPixel(index_pos0)==0) k++; else { if (vcl_abs(old_disparityPtr->GetPixel(index_pos0)-disp)>m_Tolerance/2 && k<=win) {//only small holes disparity_jump2It.SetIndex(index_pos0); if (old_disparityPtr->GetPixel(index_pos0)>disp) disparity_jump2It.Set(8); index[0]=index_pos0[0]-1; index[1]=index_pos0[1]; disparity_jump2It.SetIndex(index); if (old_disparityPtr->GetPixel(index_pos0)GetPixel(index_pos0); } } } } index[0]=index_pos[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } new_disparityIt.SetIndex(index2); ++new_disparityIt; } /** remove neighborhood if there is an edge near the first disparities */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]-1) { index_pos = new_disparityIt.GetIndex(); old_maskIt.SetIndex(index_pos); while (old_maskIt.Get() == 0 && new_disparityIt.GetIndex()[0] < static_cast(outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { ++new_disparityIt; old_maskIt.SetIndex(new_disparityIt.GetIndex()); } index_pos = new_disparityIt.GetIndex(); for (int l=patch_side; l>0; l--) { index[0]=index_pos[0]+l; index[1]=index_pos[1]; if (disparity_jump->GetPixel(index) != 0 || disparity_jump2->GetPixel(index) != 0 || outputriskedgesPtr->GetPixel(index) != 0) { for (int i=-win; i<=win; i++) { for (int k=-win; k<=win; k++) { index2[0]=index_pos[0]+l+i; index2[1]=index_pos[1]+k; if (index2[0]>=outputPtr->GetRequestedRegion().GetIndex()[0] && index2[1]>=outputPtr->GetRequestedRegion().GetIndex()[1] && index2[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] && index2[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1]) { new_disparityIt.SetIndex(index2); new_maskIt.SetIndex(index2); new_disparityIt.Set(0); new_maskIt.Set(0); } } } } } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } /** Remove pixels risking adhesion in the vertical direction(perpendicular to epipolar) */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { index2 = new_disparityIt.GetIndex(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] - 1) { index_pos = new_disparityIt.GetIndex(); if (outputriskedgesPtr->GetPixel(index_pos) != 0) { int l = 0 - vcl_min(big_dist,static_cast(index_pos[1])); //out of bound checking index[0] = index_pos[0]; index[1] = index_pos[1] + l; while(l<=0 && disparity_jump2->GetPixel(index) != 5) { l++; index[1]=index_pos[1]+l; } index[1] = index_pos[1] + l; disparity_jump2It.SetIndex(index); if (disparity_jump2It.Get() == 5 && l != 0) disparity_jump2It.Set(0); for (int i = l; i <= 0; i++) { index[1] = index_pos[1] + i; new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); } int maxSize=static_cast(disparity_jump2->GetRequestedRegion().GetSize()[1]); l = vcl_min(static_cast((maxSize-1)- index_pos[1]),big_dist); //out of bound checking index[0] = index_pos[0]; index[1] = index_pos[1] + l; while (l >= 0 && disparity_jump2->GetPixel(index) != 6) { l--; index[1] = index_pos[1] + l; } index[1] = index_pos[1] + l; disparity_jump2It.SetIndex(index); if (disparity_jump2It.Get() == 6 && l != 0) disparity_jump2It.Set(0); for (int i = l; i >= 0; i--) { index[1] = index_pos[1] + i; new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); } l = 0 - vcl_min(big_dist,static_cast(index_pos[1])); index[0] = index_pos[0]; index[1] = index_pos[1]+l; while (l <= 0 && disparity_jump2->GetPixel(index) != 8) { l++; index[1] = index_pos[1] + l; } index[1] = index_pos[1] + l; disparity_jump2It.SetIndex(index); if (disparity_jump2It.Get() == 8 && l != 0) disparity_jump2It.Set(0); for (int i = l; i <= 0; i++) { index[1] = index_pos[1] + i; new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); } l = vcl_min(static_cast((maxSize-1)- index_pos[1]),big_dist); index[0] = index_pos[0]; index[1] = index_pos[1] + l; while (l >= 0 && disparity_jump2->GetPixel(index) != 9) { l--; index[1] = index_pos[1] + l; } index[1] = index_pos[1] + l; disparity_jump2It.SetIndex(index); if (disparity_jump2It.Get() == 9 && l != 0) disparity_jump2It.Set(0); for (int i = l; i >= 0; i--) { index[1] = index_pos[1] + i; new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); } } index[0]=index_pos[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } new_disparityIt.SetIndex(index2); ++new_disparityIt; } /** remove pixels around disparity jumps with no risk edges */ new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[0](outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] -1) { index2 = new_disparityIt.GetIndex(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] - 1) { index_pos = new_disparityIt.GetIndex(); if (disparity_jump2->GetPixel(index_pos) == 5 || disparity_jump2->GetPixel(index_pos) == 8) { int l=0; index[0]=index_pos[0]; index[1]=index_pos[1]+l; while (l<=patch_side_small && index_pos[1]+l(outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] -1 && disparity_jump2->GetPixel(index) != 6) { new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); l++; index[1]=index_pos[1]+l; } } if (disparity_jump2->GetPixel(index_pos) == 6 || disparity_jump2->GetPixel(index_pos) == 9) { int l=0; index[0]=index_pos[0]; index[1]=index_pos[1]+l; while (l>=-patch_side_small && index_pos[1]+l>=outputPtr->GetRequestedRegion().GetIndex()[1] && disparity_jump2->GetPixel(index) != 5) { new_disparityIt.SetIndex(index); new_maskIt.SetIndex(index); new_disparityIt.Set(0); new_maskIt.Set(0); l--; index[1]=index_pos[1]+l; } } index[0]=index_pos[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } new_disparityIt.SetIndex(index2); ++new_disparityIt; } /** Reject isolated disparities * ie: In the patch is the only meaningful match */ int nb_disp =3; new_disparityIt.GoToBegin(); while (new_disparityIt.GetIndex()[1](outputPtr->GetRequestedRegion().GetSize()[1]) + outputPtr->GetRequestedRegion().GetIndex()[1] -1) { index_pos = new_disparityIt.GetIndex(); while (new_disparityIt.GetIndex()[0] (outputPtr->GetRequestedRegion().GetSize()[0]) + outputPtr->GetRequestedRegion().GetIndex()[0] - 1) { index_pos = new_disparityIt.GetIndex(); new_maskIt.SetIndex(index_pos); if (new_maskIt.Get() != 0 && subpixelmaskPtr->GetPixel(index_pos) != 0) { nb_disp = 0; for (int j= -win+1; j<= win-1; j++) { for (int i= -win+1; i<= win-1; i++) { index_pos0[0]=index_pos[0]+i; index_pos0[1]=index_pos[1]+j; new_maskIt.SetIndex(index_pos0); if(new_maskIt.Get() != 0 && subpixelmaskPtr->GetPixel(index_pos0) != 0) nb_disp++; } } } if(nb_disp<=2) { new_maskIt.SetIndex(index_pos); new_disparityIt.SetIndex(index_pos); new_maskIt.Set(0); new_disparityIt.Set(0); } ++new_disparityIt; } index[0]=outputPtr->GetRequestedRegion().GetIndex()[0]; index[1]=index_pos[1]+1; new_disparityIt.SetIndex(index); } } } // end namespace otb #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbBijectionCoherencyFilter.h000066400000000000000000000112251301006202600301570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBijectionCoherencyFilter_h #define otbBijectionCoherencyFilter_h #include "itkImageToImageFilter.h" #include "otbLineOfSightOptimizer.h" #include "otbImage.h" namespace otb { /** \class BijectionCoherencyFilter * \brief Left-right coherency filter for disparity maps * * This filter checks that left-to-right and right-to-left disparities (computed * for a given stereo pair) are compatible, within a given tolerance radius. * Disparities are expected to be given in index coordinates between a pair of * epipolar images of equal size. 1D or 2D disparities may be supplied. * Left-to-right disparities will be referred as direct, right-to-left as * reverse. * The output is a mask for coherent direct disparities. * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBStereo */ template > class ITK_EXPORT BijectionCoherencyFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef BijectionCoherencyFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(BijectionCoherencyFilter, ImageToImageFilter); /** Useful typedefs */ typedef TDisparityImage DispMapType; typedef TOutputImage MaskType; typedef typename MaskType::RegionType OutputRegionType; typedef typename DispMapType::RegionType InputRegionType; typedef typename DispMapType::SizeType SizeType; typedef typename DispMapType::IndexType IndexType; /** Set the direct horizontal disparity map */ void SetDirectHorizontalDisparityMapInput( const TDisparityImage * hmap ); /** Set the direct vertical disparity map */ void SetDirectVerticalDisparityMapInput( const TDisparityImage * vmap ); /** Set the reverse horizontal disparity map */ void SetReverseHorizontalDisparityMapInput( const TDisparityImage * hmap ); /** Set the reverse vertical disparity map */ void SetReverseVerticalDisparityMapInput( const TDisparityImage * vmap ); /** Get the inputs */ const TDisparityImage * GetDirectHorizontalDisparityMapInput() const; const TDisparityImage * GetDirectVerticalDisparityMapInput() const; const TDisparityImage * GetReverseHorizontalDisparityMapInput() const; const TDisparityImage * GetReverseVerticalDisparityMapInput() const; /** Set the tolerance radius */ itkSetMacro(Tolerance,double); /** Get the tolerance radius */ itkGetMacro(Tolerance,double); /** Set/Get macro for exploration area */ itkSetMacro(MinHDisp,int); itkGetMacro(MinHDisp,int); itkSetMacro(MaxHDisp,int); itkGetMacro(MaxHDisp,int); itkSetMacro(MinVDisp,int); itkGetMacro(MinVDisp,int); itkSetMacro(MaxVDisp,int); itkGetMacro(MaxVDisp,int); protected: /** Constructor */ BijectionCoherencyFilter(); /** Destructor */ ~BijectionCoherencyFilter() ITK_OVERRIDE{}; /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const OutputRegionType & outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; private: BijectionCoherencyFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Tolerance radius (in pixels) */ double m_Tolerance; /** Minimum horizontal input disparity */ int m_MinHDisp; /** Maximum horizontal input disparity */ int m_MaxHDisp; /** Minimum vertical input disparity */ int m_MinVDisp; /** Maximum vertical input disparity */ int m_MaxVDisp; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbBijectionCoherencyFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbBijectionCoherencyFilter.txx000066400000000000000000000252021301006202600305530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBijectionCoherencyFilter_txx #define otbBijectionCoherencyFilter_txx #include "otbBijectionCoherencyFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" namespace otb { template BijectionCoherencyFilter ::BijectionCoherencyFilter() { // Set the number of inputs (1 moving image by default -> 3 inputs) this->SetNumberOfRequiredInputs(4); this->SetNumberOfRequiredInputs(1); this->m_Tolerance = 1.; this->m_MinHDisp = -5; this->m_MaxHDisp = 5; this->m_MinVDisp = -5; this->m_MaxVDisp = 5; // Set the outputs this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0,TOutputImage::New()); } template void BijectionCoherencyFilter ::SetDirectHorizontalDisparityMapInput( const TDisparityImage * hmap ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( hmap )); } template void BijectionCoherencyFilter ::SetDirectVerticalDisparityMapInput( const TDisparityImage * vmap ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( vmap )); } template void BijectionCoherencyFilter ::SetReverseHorizontalDisparityMapInput( const TDisparityImage * hmap ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(2, const_cast( hmap )); } template void BijectionCoherencyFilter ::SetReverseVerticalDisparityMapInput( const TDisparityImage * vmap ) { // Process object is not const-correct so the const casting is required. this->SetNthInput(3, const_cast( vmap )); } template const TDisparityImage * BijectionCoherencyFilter ::GetDirectHorizontalDisparityMapInput() const { if (this->GetNumberOfInputs()<1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TDisparityImage * BijectionCoherencyFilter ::GetDirectVerticalDisparityMapInput() const { if (this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template const TDisparityImage * BijectionCoherencyFilter ::GetReverseHorizontalDisparityMapInput() const { if (this->GetNumberOfInputs()<3) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(2)); } template const TDisparityImage * BijectionCoherencyFilter ::GetReverseVerticalDisparityMapInput() const { if (this->GetNumberOfInputs()<4) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(3)); } template void BijectionCoherencyFilter ::GenerateOutputInformation() { this->Superclass::GenerateOutputInformation(); // check that both direct and reverse disparity maps are present const TDisparityImage * directHmap = this->GetDirectHorizontalDisparityMapInput(); const TDisparityImage * reverseHmap = this->GetReverseHorizontalDisparityMapInput(); const TDisparityImage * directVmap = this->GetDirectVerticalDisparityMapInput(); const TDisparityImage * reverseVmap = this->GetReverseVerticalDisparityMapInput(); if (!directHmap) { itkExceptionMacro(<<"Direct horizontal disparity map is missing"); } if (!reverseHmap) { itkExceptionMacro(<<"Reverse horizontal disparity map is missing"); } if (directVmap && directVmap->GetLargestPossibleRegion() != directHmap->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Horizontal and vertical direct disparity maps have different sizes."); } if (reverseVmap && reverseVmap->GetLargestPossibleRegion() != reverseHmap->GetLargestPossibleRegion()) { itkExceptionMacro(<<"Horizontal and vertical reverse disparity maps have different sizes."); } if (this->m_MinHDisp > this->m_MaxHDisp) { itkExceptionMacro(<<"Wrong horizontal exploration values"); } if (this->m_MinVDisp > this->m_MaxVDisp) { itkExceptionMacro(<<"Wrong horizontal exploration values"); } } template void BijectionCoherencyFilter ::GenerateInputRequestedRegion() { this->Superclass::GenerateInputRequestedRegion(); OutputRegionType requested = this->GetOutput()->GetRequestedRegion(); InputRegionType directLargest = this->GetDirectHorizontalDisparityMapInput()->GetLargestPossibleRegion(); InputRegionType directRequested; InputRegionType reverseLargest = this->GetReverseHorizontalDisparityMapInput()->GetLargestPossibleRegion(); InputRegionType reverseRequested; this->CallCopyOutputRegionToInputRegion(directRequested,requested); reverseRequested.SetIndex(0,requested.GetIndex(0) + this->m_MinHDisp); reverseRequested.SetIndex(1,requested.GetIndex(1) + this->m_MinVDisp); reverseRequested.SetSize(0,requested.GetSize(0) + this->m_MaxHDisp - this->m_MinHDisp); reverseRequested.SetSize(1,requested.GetSize(1) + this->m_MaxVDisp - this->m_MinVDisp); if (!reverseRequested.Crop(reverseLargest)) { reverseRequested.SetIndex(0,reverseLargest.GetIndex(0)); reverseRequested.SetIndex(1,reverseLargest.GetIndex(1)); reverseRequested.SetSize(0,0); reverseRequested.SetSize(1,0); } TDisparityImage * directHmap = const_cast(this->GetDirectHorizontalDisparityMapInput()); TDisparityImage * directVmap = const_cast(this->GetDirectVerticalDisparityMapInput()); TDisparityImage * reverseHmap = const_cast(this->GetReverseHorizontalDisparityMapInput()); TDisparityImage * reverseVmap = const_cast(this->GetReverseVerticalDisparityMapInput()); directHmap->SetRequestedRegion(directRequested); if (directVmap) directVmap->SetRequestedRegion(directRequested); reverseHmap->SetRequestedRegion(reverseRequested); if (reverseVmap) reverseVmap->SetRequestedRegion(reverseRequested); } template void BijectionCoherencyFilter ::ThreadedGenerateData(const OutputRegionType & outputRegionForThread, itk::ThreadIdType itkNotUsed(threadId)) { const TDisparityImage * directHmap = this->GetDirectHorizontalDisparityMapInput(); const TDisparityImage * directVmap = this->GetDirectVerticalDisparityMapInput(); const TDisparityImage * reverseHmap = this->GetReverseHorizontalDisparityMapInput(); const TDisparityImage * reverseVmap = this->GetReverseVerticalDisparityMapInput(); TOutputImage * output = this->GetOutput(); InputRegionType buffered = reverseHmap->GetBufferedRegion(); typedef itk::ImageRegionIterator MaskIteratorType; MaskIteratorType outIter = MaskIteratorType(output,outputRegionForThread); typedef itk::ImageRegionConstIteratorWithIndex DispIteratorType; DispIteratorType directHorizIter = DispIteratorType(directHmap,outputRegionForThread); DispIteratorType directVertiIter; if (directVmap) { directVertiIter = DispIteratorType(directVmap,outputRegionForThread); directVertiIter.GoToBegin(); } outIter.GoToBegin(); directHorizIter.GoToBegin(); while (!outIter.IsAtEnd()) { IndexType startIndex = directHorizIter.GetIndex(); itk::ContinuousIndex tmpIndex(startIndex); tmpIndex[0] += directHorizIter.Get(); if (directVmap) tmpIndex[1] += directVertiIter.Get(); // Interpolate in reverse disparity map typedef typename IndexType::IndexValueType IndexValueType; IndexType ul,ur,ll,lr; ul[0] = static_cast(vcl_floor(tmpIndex[0])); ul[1] = static_cast(vcl_floor(tmpIndex[1])); if (ul[0] < buffered.GetIndex()[0]) ul[0] = buffered.GetIndex()[0]; if (ul[1] < buffered.GetIndex()[1]) ul[1] = buffered.GetIndex()[1]; if (ul[0] > static_cast(buffered.GetIndex()[0] + buffered.GetSize()[0]-1)) ul[0]=(buffered.GetIndex()[0]+buffered.GetSize()[0]-1); if (ul[1] > static_cast(buffered.GetIndex()[1] + buffered.GetSize()[1]-1)) ul[1] = (buffered.GetIndex()[1]+buffered.GetSize()[1]-1); ur = ul; ll = ul; lr = ul; if (ul[0] < static_cast(buffered.GetIndex()[0] + buffered.GetSize()[0]-1)) { ur[0] += 1; lr[0] += 1; } if (ul[1] < static_cast(buffered.GetIndex()[1] + buffered.GetSize()[1]-1)) { ll[1] += 1; lr[1] += 1; } double rx = tmpIndex[0] - static_cast(ul[0]); double ry = tmpIndex[1] - static_cast(ul[1]); itk::ContinuousIndex backIndex(tmpIndex); backIndex[0] += (1. - ry) * ((1. - rx) * reverseHmap->GetPixel(ul) + rx * reverseHmap->GetPixel(ur)) + ry * ((1. - rx) * reverseHmap->GetPixel(ll) + rx * reverseHmap->GetPixel(lr)); if (reverseVmap) { backIndex[1] += (1. - ry) * ((1. - rx) * reverseVmap->GetPixel(ul) + rx * reverseVmap->GetPixel(ur)) + ry * ((1. - rx) * reverseVmap->GetPixel(ll) + rx * reverseVmap->GetPixel(lr)); } if (vcl_abs(backIndex[0] - static_cast(startIndex[0]))< this->m_Tolerance && vcl_abs(backIndex[1] - static_cast(startIndex[1]))< this->m_Tolerance) { outIter.Set(255); } else { outIter.Set(0); } ++outIter; ++directHorizIter; if (directVmap) ++directVertiIter; } } } #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbLineOfSightOptimizer.h000066400000000000000000000066741301006202600273350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineOfSightOptimizer_h #define otbLineOfSightOptimizer_h #include "itkObject.h" #include "itkPointSet.h" namespace otb { /** \class LineOfSightOptimizer * \brief Compute the position of a 3D point from a set of N lines of sight * * This filter can use at least 2 lines of sight to estimate the position of * the intersection using a Mean Square optimization method. * This filter is templated over the precision of 3 points coordinates * * * \ingroup OTBStereo */ template class ITK_EXPORT LineOfSightOptimizer : public itk::Object { public: /** Standard class typedef */ typedef LineOfSightOptimizer Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(LineOfSightOptimizer, itk::Object); /** Useful typedefs */ typedef TPrecision PrecisionType; typedef TLabel LabelType; typedef itk::DefaultStaticMeshTraits MeshType; typedef itk::PointSet PointSetType; typedef typename PointSetType::PointType PointType; typedef typename PointSetType::Pointer PointSetPointerType; typedef typename PointSetType::PointsContainerConstIterator PointSetConstIteratorType; typedef typename PointSetType::PointDataContainerIterator LabelIteratorType; typedef std::vector ResidueType; /** Compute the best intersection between N lines of sight. * Starting points of every line of sight are stored in the point set 'pointA' * ending points are stored in 'pointB' (however, the computation is symmetrical)*/ PointType Compute(PointSetPointerType pointA, PointSetPointerType pointB); /** Get the residues from last computation */ //itkGetMacro(Residues,ResidueType); ResidueType GetResidues() { return m_Residues; } /** Get the global residue from last computation */ itkGetMacro(GlobalResidue,PrecisionType); protected: /** Constructor */ LineOfSightOptimizer(); /** Destructor */ ~LineOfSightOptimizer() ITK_OVERRIDE{}; private: LineOfSightOptimizer(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** residues from the last computation on each line of sight */ ResidueType m_Residues; /** global residu from last computation */ PrecisionType m_GlobalResidue; /** Internal matrices for computation */ vnl_matrix m_InvCumul; vnl_matrix m_Identity; vnl_vector m_SecCumul; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLineOfSightOptimizer.txx" #endif #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbLineOfSightOptimizer.txx000066400000000000000000000073331301006202600277220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLineOfSightOptimizer_txx #define otbLineOfSightOptimizer_txx #include "otbLineOfSightOptimizer.h" #include "vnl/vnl_inverse.h" namespace otb { template LineOfSightOptimizer ::LineOfSightOptimizer() { m_Residues.clear(); m_GlobalResidue = 0; m_InvCumul = vnl_matrix(3,3); m_Identity = vnl_matrix(3,3); m_Identity.fill(0); m_Identity.fill_diagonal(1.); m_SecCumul = vnl_vector(3); } template typename LineOfSightOptimizer::PointType LineOfSightOptimizer ::Compute(PointSetPointerType pointA, PointSetPointerType pointB) { // First, empty the cumulators and residues m_InvCumul.fill(0); m_SecCumul.fill(0); m_Residues.clear(); vnl_matrix idMinusViViT(3,3); vnl_matrix vi(3,1); vnl_vector si(3); PointType result; //check inputs if (pointA->GetNumberOfPoints() != pointB->GetNumberOfPoints() || pointA->GetNumberOfPoints() < 2) { itkExceptionMacro(<<"Points are missing in at least one of the input point sets."); return result; } // iterate over lines of sight PointSetConstIteratorType itPointA = pointA->GetPoints()->Begin(); PointSetConstIteratorType itPointB = pointB->GetPoints()->Begin(); while (itPointA != pointA->GetPoints()->End() && itPointB != pointB->GetPoints()->End()) { vi(0,0) = itPointB.Value()[0] - itPointA.Value()[0]; vi(1,0) = itPointB.Value()[1] - itPointA.Value()[1]; vi(2,0) = itPointB.Value()[2] - itPointA.Value()[2]; PrecisionType norm_inv = 1. / vcl_sqrt(vi(0,0)*vi(0,0)+vi(1,0)*vi(1,0)+vi(2,0)*vi(2,0)); vi(0,0) *= norm_inv; vi(1,0) *= norm_inv; vi(2,0) *= norm_inv; si(0) = itPointA.Value()[0]; si(1) = itPointA.Value()[1]; si(2) = itPointA.Value()[2]; idMinusViViT = m_Identity - (vi * vi.transpose()); m_InvCumul+=idMinusViViT; m_SecCumul+=(idMinusViViT * si); ++itPointA; ++itPointB; } vnl_vector intersection = vnl_inverse(m_InvCumul) * m_SecCumul; result[0] = intersection[0]; result[1] = intersection[1]; result[2] = intersection[2]; // Compute residues m_GlobalResidue = 0; vnl_vector AB(3); vnl_vector AC(3); PrecisionType res2; itPointA = pointA->GetPoints()->Begin(); itPointB = pointB->GetPoints()->Begin(); while (itPointA != pointA->GetPoints()->End() && itPointB != pointB->GetPoints()->End()) { AB[0] = itPointB.Value()[0] - itPointA.Value()[0]; AB[1] = itPointB.Value()[1] - itPointA.Value()[1]; AB[2] = itPointB.Value()[2] - itPointA.Value()[2]; AC[0] = intersection[0] - itPointA.Value()[0]; AC[1] = intersection[1] - itPointA.Value()[1]; AC[2] = intersection[2] - itPointA.Value()[2]; res2 = std::max(0.0,dot_product(AC,AC) - (dot_product(AB,AC) * dot_product(AB,AC)) / (dot_product(AB,AB))); m_Residues.push_back( vcl_sqrt( res2 ) ); m_GlobalResidue += res2; ++itPointA; ++itPointB; } m_GlobalResidue = vcl_sqrt(m_GlobalResidue); return result; } } #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbMulti3DMapToDEMFilter.h000066400000000000000000000247401301006202600271670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMulti3DMapToDEMFilter_h #define otbMulti3DMapToDEMFilter_h #include "itkImageToImageFilter.h" #include "otbImageToGenericRSOutputParameters.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkImageRegionConstIterator.h" #include "otbVectorImage.h" #include "otbImage.h" #include "itkImageRegionSplitter.h" #include "otbObjectList.h" namespace otb { namespace CellFusionMode { enum CellFusionMode { MIN = 0, MAX = 1, MEAN = 2, ACC = 3 //return accumulator for debug purpose }; } /** \class Multi3DMapToDEMFilter * \brief Project N 3D images (long,lat,alti) into a regular DEM in the chosen map projection system. * * This filter uses a group of N 3D points images and project then onto a regular DEM grid parametrized by DEMGridStep (in meter). * The 3D coordinates (sorted by band) of input map are : longitude , latitude (in degree, wrt WGS84) and altitude (in meters) * * DEM cell fusion strategy available are : * - 0 MIN : we keep the minimum altitude * - 1 MAX : we keep the maximum altitude * - 2 MEAN : mean is computed * - 3 ACC : returns cell count (useful to create mask from output) * * empty cell are filled with the NoDataValue (-32768 by default) * * if 3Map are not in sensor geometry Min and MaxElevation parameters are useless * otherwise Min and MaxElevation are used to reproject DEM long/lat in sensor geometry to extend area search in input 3Map * * DEM parameters are automatically deduced by the union of input extent if SetOutputParametersFrom3DMap is called without parameters. If * an index is given, the 3D corresponding Map is used to deduced Output parameters (expect Spacing which is calculated for DEMGridStep (in meter)) * * DEM output parameters can also be manually filled using Setters for : * Origin, Spacing, Size, StartIndex, ProjectionRef * thus DEMGridStep parameter is ignored in this case (replaced by Spacing) * * \sa FineRegistrationImageFilter * \sa MultiDisparityMapTo3DFilter * * \ingroup Streamed * \ingroup Threaded * * * \ingroup OTBStereo */ template , class TMaskImage = otb::Image, class TOutputDEMImage = otb::Image > class ITK_EXPORT Multi3DMapToDEMFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef Multi3DMapToDEMFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(Multi3DMapToDEMFilter, ImageToImageFilter); /** Useful typedefs */ typedef T3DImage InputMapType; typedef TOutputDEMImage OutputImageType; typedef TMaskImage MaskImageType; typedef otb::Image AccumulatorImageType; typedef typename OutputImageType::RegionType RegionType; typedef typename OutputImageType::PixelType DEMPixelType; typedef typename OutputImageType::PointType OriginType; typedef typename OutputImageType::SpacingType SpacingType; typedef typename OutputImageType::SizeType SizeType; typedef typename OutputImageType::IndexType IndexType; typedef typename AccumulatorImageType::PixelType AccumulatorPixelType; typedef typename InputMapType::PixelType MapPixelType; typedef typename InputMapType::InternalPixelType InputInternalPixelType; // 3D RS transform // TODO: Allow tuning precision (i.e. double or float) typedef double PrecisionType; typedef otb::GenericRSTransform RSTransformType; typedef otb::ImageToGenericRSOutputParameters OutputParametersEstimatorType; // 3D points typedef typename RSTransformType::InputPointType TDPointType; // 2D Transform typedef otb::GenericRSTransform<> RSTransform2DType; typedef otb::ImageKeywordlist ImageKeywordListType; typedef std::map > MapIteratorList; typedef std::map > MaskIteratorList; typedef double ValueType; typedef itk::VariableLengthVector MeasurementType; typedef itk::ImageRegionSplitter<2> SplitterType; typedef otb::ObjectList SplitterListType; /** Set the number of 3D images (referred earlier as N) */ void SetNumberOf3DMaps(unsigned int nb); /** Get the number of 3D images (referred earlier as N) */ unsigned int GetNumberOf3DMaps(); /** Set 3D map input at corresponding 'index' */ void Set3DMapInput(unsigned int index, const T3DImage * hmap); /** Set mask associated to 3D maps 'index' * (optional, pixels with a null mask value are ignored) */ void SetMaskInput(unsigned int index, const TMaskImage * mask); /** Get the inputs */ const T3DImage * Get3DMapInput(unsigned int index) const; const TMaskImage * GetMaskInput(unsigned int index) const; /** Get DEM output*/ const TOutputDEMImage * GetDEMOutput() const; TOutputDEMImage * GetDEMOutput(); /** Set/Get macro for DEM grid step */ itkSetMacro(DEMGridStep, double); itkGetConstReferenceMacro(DEMGridStep, double); /** Set/Get macro for CellFusionMode */ itkSetMacro(CellFusionMode, int); itkGetConstReferenceMacro(CellFusionMode, int); /** Set/Get macro for NoDataValue */ itkSetMacro(NoDataValue, DEMPixelType); itkGetConstReferenceMacro(NoDataValue, DEMPixelType); /** compute * Set DEM extent using 3DMap 'index' , if index =-1 union of all input Map extent is done */ void SetOutputParametersFrom3DMap(int index=-1) { if (static_cast((2 * (index + 1))) > this->GetNumberOfInputs()) { itkExceptionMacro(<< "input at position "< m_MapKeywordLists; /** Reference sensor image transform */ RSTransformType::Pointer m_ReferenceToGroundTransform; /** Moving sensor image transforms */ std::vector m_MapToGroundTransform; std::vector m_MapMinVal; std::vector m_MapMaxVal; /** DEM grid step (in meters) */ double m_DEMGridStep; /** Temporary DEMs for multithreading */ std::vector m_TempDEMRegions; /** Temporary accumulator for multithreading and mean calculus*/ std::vector m_TempDEMAccumulatorRegions; std::vector m_NumberOfSplit; // number of split for each map // std::vector m_ThreadProcessed; // /** Region splitter for input disparity maps */ SplitterListType::Pointer m_MapSplitterList; DEMPixelType m_NoDataValue; int m_CellFusionMode; std::string m_ProjectionRef; /** Minimum elevation of the DEM in meters */ double m_ElevationMin; /** Maximum elevation of the DEM in meters */ double m_ElevationMax; SizeType m_OutputSize; IndexType m_OutputStartIndex; SpacingType m_OutputSpacing; OriginType m_OutputOrigin; SizeType m_Margin; int m_OutputParametersFrom3DMap; bool m_IsGeographic; /** internal transform between WGS84 and user's ProjRef */ RSTransform2DType::Pointer m_GroundTransform; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMulti3DMapToDEMFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbMulti3DMapToDEMFilter.txx000066400000000000000000001000431301006202600275520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMulti3DMapToDEMFilter_txx #define otbMulti3DMapToDEMFilter_txx #include "otbMulti3DMapToDEMFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" #include "otbStreamingStatisticsVectorImageFilter.h" #include "otbInverseSensorModel.h" namespace otb { template Multi3DMapToDEMFilter::Multi3DMapToDEMFilter() { // Set the number of inputs (1 image one optional mask) this->SetNumberOfIndexedInputs(2); this->SetNumberOfRequiredInputs(1); //this->m_MapKeywordLists.resize(1); m_DEMGridStep = 10.0; // Set the outputs this->SetNumberOfIndexedOutputs(1); this->SetNthOutput(0, TOutputDEMImage::New()); // Default DEM reconstruction parameters m_MapSplitterList = SplitterListType::New(); m_NoDataValue = -32768; m_ElevationMin = -100; m_ElevationMax = 500; m_CellFusionMode = otb::CellFusionMode::MAX; m_OutputParametersFrom3DMap = -2; m_IsGeographic=true; m_Margin[0]=10; m_Margin[1]=10; } template Multi3DMapToDEMFilter::~Multi3DMapToDEMFilter() { } template void Multi3DMapToDEMFilter::SetNumberOf3DMaps(unsigned int nb) { if (nb > 0) { this->SetNumberOfIndexedInputs(2 * nb); } } template unsigned int Multi3DMapToDEMFilter::GetNumberOf3DMaps() { return this->GetNumberOfInputs() / 2; } template void Multi3DMapToDEMFilter::Set3DMapInput(unsigned int index, const T3DImage * map) { if ((2 * (index + 1)) > this->GetNumberOfInputs()) { itkExceptionMacro(<<"Index is greater than the number of images"); } // Process object is not const-correct so the const casting is required. this->SetNthInput(2 * index, const_cast (map)); } template void Multi3DMapToDEMFilter::SetMaskInput(unsigned int index, const TMaskImage * mask) { if ((2 * (index + 1)) > this->GetNumberOfInputs()) { itkExceptionMacro(<<"Index is greater than the number of images"); } // Process object is not const-correct so the const casting is required. this->SetNthInput(2 * index + 1, const_cast (mask)); } template const T3DImage * Multi3DMapToDEMFilter::Get3DMapInput(unsigned int index) const { if ((2 * (index + 1)) > this->GetNumberOfInputs()) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(2 * index)); } template const TMaskImage * Multi3DMapToDEMFilter::GetMaskInput(unsigned int index) const { if ((2 * (index + 1)) > this->GetNumberOfInputs()) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(2 * index + 1)); } template const TOutputDEMImage * Multi3DMapToDEMFilter::GetDEMOutput() const { if (this->GetNumberOfOutputs() < 1) { return 0; } return static_cast (this->itk::ProcessObject::GetOutput(0)); } template TOutputDEMImage * Multi3DMapToDEMFilter::GetDEMOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetOutput(0)); } template void Multi3DMapToDEMFilter::SetOutputParametersFromImage() { int index = m_OutputParametersFrom3DMap; if (static_cast ((2 * (index + 1))) > this->GetNumberOfInputs()) { itkExceptionMacro(<< "input at position "<GetNumberOfInputs() / 2; unsigned int indexStart = 0; unsigned int indexEnd = numberOfInputs - 1; if (index != -1) { indexStart = index; indexEnd = index; } //compute DEM extent union of 3D map extent TOutputDEMImage * outputPtr = this->GetDEMOutput(); // Set-up a transform to use the DEMHandler // DEM BBox itk::NumericTraits::max(); double box_xmin = itk::NumericTraits::max(); double box_xmax = itk::NumericTraits::NonpositiveMin(); double box_ymin = itk::NumericTraits::max(); double box_ymax = itk::NumericTraits::NonpositiveMin(); for (unsigned int k = indexStart; k <= indexEnd; ++k) { T3DImage *imgPtr = const_cast (this->Get3DMapInput(k)); RSTransform2DType::Pointer mapToGroundTransform = RSTransform2DType::New(); ImageKeywordListType imageKWL = imgPtr->GetImageKeywordlist(); mapToGroundTransform->SetInputKeywordList(imageKWL); /*if(!m_ProjectionRef.empty()) { mapToGroundTransform->SetOutputProjectionRef(m_ProjectionRef); }*/ mapToGroundTransform->InstantiateTransform(); typename InputMapType::SizeType inputSize = imgPtr->GetLargestPossibleRegion().GetSize(); typename InputMapType::PointType ulPt, urPt, llPt, lrPt; itk::ContinuousIndex ulIdx(imgPtr->GetLargestPossibleRegion().GetIndex()); ulIdx[0] += -0.5; ulIdx[1] += -0.5; itk::ContinuousIndex urIdx(ulIdx); itk::ContinuousIndex lrIdx(ulIdx); itk::ContinuousIndex llIdx(ulIdx); urIdx[0] += static_cast(inputSize[0]); lrIdx[0] += static_cast(inputSize[0]); lrIdx[1] += static_cast(inputSize[1]); llIdx[1] += static_cast(inputSize[1]); imgPtr->TransformContinuousIndexToPhysicalPoint(ulIdx,ulPt); imgPtr->TransformContinuousIndexToPhysicalPoint(urIdx,urPt); imgPtr->TransformContinuousIndexToPhysicalPoint(llIdx,llPt); imgPtr->TransformContinuousIndexToPhysicalPoint(lrIdx,lrPt); RSTransform2DType::OutputPointType ul, ur, lr, ll; ul = mapToGroundTransform->TransformPoint(ulPt); ur = mapToGroundTransform->TransformPoint(urPt); ll = mapToGroundTransform->TransformPoint(llPt); lr = mapToGroundTransform->TransformPoint(lrPt); double xmin = std::min(std::min(std::min(ul[0], ur[0]), lr[0]), ll[0]); double xmax = std::max(std::max(std::max(ul[0], ur[0]), lr[0]), ll[0]); double ymin = std::min(std::min(std::min(ul[1], ur[1]), lr[1]), ll[1]); double ymax = std::max(std::max(std::max(ul[1], ur[1]), lr[1]), ll[1]); box_xmin = std::min(box_xmin, xmin); box_xmax = std::max(box_xmax, xmax); box_ymin = std::min(box_ymin, ymin); box_ymax = std::max(box_ymax, ymax); /* if (imageKWL.GetSize() > 0) { itk::EncapsulateMetaData(outputPtr->GetMetaDataDictionary(), MetaDataKey::OSSIMKeywordlistKey, imageKWL); }*/ } // Compute step : // TODO : use a clean RS transform instead typename TOutputDEMImage::SpacingType outSpacing; //std::cout<<" GrisStep "<SetSpacing(outSpacing); // Choose origin typename TOutputDEMImage::PointType outOrigin; outOrigin[0] = box_xmin + 0.5 * outSpacing[0]; outOrigin[1] = box_ymax + 0.5 * outSpacing[1]; outputPtr->SetOrigin(outOrigin); // Compute output size typename TOutputDEMImage::RegionType outRegion; outRegion.SetIndex(0, 0); outRegion.SetIndex(1, 0); outRegion.SetSize(0, static_cast(vcl_floor((box_xmax - box_xmin) / vcl_abs(outSpacing[0]) + 0.5))); outRegion.SetSize(1, static_cast(vcl_floor((box_ymax - box_ymin) / vcl_abs(outSpacing[1]) + 0.5))); outputPtr->SetLargestPossibleRegion(outRegion); outputPtr->SetNumberOfComponentsPerPixel(1); itk::MetaDataDictionary & dictOutput =outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData (dictOutput, MetaDataKey::ProjectionRefKey, static_cast(otb::GeoInformationConversion::ToWKT(4326))); //test if WGS 84 -> true -> nothing to do //false project bool isWGS84 =!(m_ProjectionRef.compare( static_cast(otb::GeoInformationConversion::ToWKT(4326)))); if(!m_ProjectionRef.empty() && !isWGS84) { typename OutputParametersEstimatorType::Pointer genericRSEstimator = OutputParametersEstimatorType::New(); genericRSEstimator->SetInput(outputPtr); // genericRSEstimator->SetInputProjectionRef( static_cast(otb::GeoInformationConversion::ToWKT(4326))); genericRSEstimator->SetOutputProjectionRef(m_ProjectionRef); genericRSEstimator->Compute(); outputPtr->SetSpacing(genericRSEstimator->GetOutputSpacing()); outputPtr->SetOrigin(genericRSEstimator->GetOutputOrigin()); // Compute output size typename TOutputDEMImage::RegionType outRegion2; outRegion2.SetIndex(0, 0); outRegion2.SetIndex(1, 0); outRegion2.SetSize(0, genericRSEstimator->GetOutputSize()[0]); //TODO JGT check the size //outRegion.SetSize(1, static_cast ((box_ymax - box_ymin) / vcl_abs(outSpacing[1])+1)); outRegion2.SetSize(1, genericRSEstimator->GetOutputSize()[1]); outputPtr->SetLargestPossibleRegion(outRegion2); outputPtr->SetNumberOfComponentsPerPixel(1); itk::MetaDataDictionary & dict =outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData (dict, MetaDataKey::ProjectionRefKey, m_ProjectionRef); } this->Modified(); } template void Multi3DMapToDEMFilter::GenerateOutputInformation() { // TOutputDEMImage * outputPtr = this->GetDEMOutput(); // if (this->m_OutputParametersFrom3DMap == -2) { outputPtr->SetOrigin(m_OutputOrigin); outputPtr->SetSpacing(m_OutputSpacing); typename TOutputDEMImage::RegionType outRegion; outRegion.SetIndex(m_OutputStartIndex); outRegion.SetSize(m_OutputSize); outputPtr->SetLargestPossibleRegion(outRegion); outputPtr->SetNumberOfComponentsPerPixel(1); if (!m_ProjectionRef.empty()) { // fill up the metadata information for ProjectionRef itk::MetaDataDictionary& dict = this->GetOutput()->GetMetaDataDictionary(); itk::EncapsulateMetaData(dict, MetaDataKey::ProjectionRefKey, m_ProjectionRef); } } else { this->SetOutputParametersFromImage(); } if (!m_ProjectionRef.empty()) { OGRSpatialReference oSRS; char *wkt = const_cast (m_ProjectionRef.c_str()); oSRS.importFromWkt(&wkt); m_IsGeographic = oSRS.IsGeographic(); // TODO check if this test is valid for all projection systems } // Set the NoData value std::vector noDataValueAvailable; noDataValueAvailable.push_back(true); std::vector noDataValue; noDataValue.push_back(m_NoDataValue); itk::MetaDataDictionary& dict = outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); } template void Multi3DMapToDEMFilter::GenerateInputRequestedRegion() { const TOutputDEMImage * outputDEM = this->GetDEMOutput(); typename TOutputDEMImage::RegionType outRegion = outputDEM->GetRequestedRegion(); typename TOutputDEMImage::PointType outOrigin = outputDEM->GetOrigin(); typename TOutputDEMImage::SpacingType outSpacing = outputDEM->GetSpacing(); // up left at elevation min TDPointType corners[8]; corners[0][0] = outOrigin[0] + outSpacing[0] * (-0.5 + static_cast(outRegion.GetIndex(0))); corners[0][1] = outOrigin[1] + outSpacing[1] * (-0.5 + static_cast(outRegion.GetIndex(1))); corners[0][2] = m_ElevationMin; // up left at elevation max corners[1][0] = corners[0][0]; corners[1][1] = corners[0][1]; corners[1][2] = m_ElevationMax; // up right at elevation min corners[2][0] = corners[0][0] + outSpacing[0] * static_cast(outRegion.GetSize(0)); corners[2][1] = corners[0][1]; corners[2][2] = m_ElevationMin; // up right at elevation max corners[3][0] = corners[2][0]; corners[3][1] = corners[2][1]; corners[3][2] = m_ElevationMax; // low right at elevation min corners[4][0] = corners[0][0] + outSpacing[0] * static_cast(outRegion.GetSize(0)); corners[4][1] = corners[0][1] + outSpacing[1] * static_cast(outRegion.GetSize(1)); corners[4][2] = m_ElevationMin; // low right at elevation max corners[5][0] = corners[4][0]; corners[5][1] = corners[4][1]; corners[5][2] = m_ElevationMax; // low left at elevation min corners[6][0] = corners[0][0]; corners[6][1] = corners[0][1] + outSpacing[1] * static_cast(outRegion.GetSize(1)); corners[6][2] = m_ElevationMin; // low left at elevation max corners[7][0] = corners[6][0]; corners[7][1] = corners[6][1]; corners[7][2] = m_ElevationMax; for (unsigned int k = 0; k < this->GetNumberOf3DMaps(); ++k) { //set requested to largest and check that mask has the same size T3DImage *imgPtr = const_cast (this->Get3DMapInput(k)); RSTransformType::Pointer groundToSensorTransform = RSTransformType::New(); //groundToSensorTransform->SetInputKeywordList(outputDEM->GetImageKeywordlist()); //groundToSensorTransform->SetInputOrigin(outputDEM->GetOrigin()); //groundToSensorTransform->SetInputSpacing(outputDEM->GetSpacing()); groundToSensorTransform->SetInputProjectionRef(m_ProjectionRef); groundToSensorTransform->SetOutputKeywordList(imgPtr->GetImageKeywordlist()); groundToSensorTransform->SetOutputOrigin(imgPtr->GetOrigin()); groundToSensorTransform->SetOutputSpacing(imgPtr->GetSpacing()); groundToSensorTransform->InstantiateTransform(); typename T3DImage::RegionType mapRegion = imgPtr->GetLargestPossibleRegion(); itk::ContinuousIndex mapContiIndex; long int maxMapIndex[2] = { 0, 0 }; long int minMapIndex[2] = { 0, 0 }; maxMapIndex[0] = static_cast (mapRegion.GetIndex(0) + mapRegion.GetSize(0)); maxMapIndex[1] = static_cast (mapRegion.GetIndex(1) + mapRegion.GetSize(1)); minMapIndex[0] = static_cast (mapRegion.GetIndex(0)); minMapIndex[1] = static_cast (mapRegion.GetIndex(1)); long int minMapRequestedIndex[2] = { 0, 0 }; minMapRequestedIndex[0]= maxMapIndex[0]+1; minMapRequestedIndex[1]= maxMapIndex[1]+1; long int maxMapRequestedIndex[2] = { 0, 0 }; maxMapRequestedIndex[0]= 0; maxMapRequestedIndex[1]= 0; for (unsigned int i = 0; i < 8; i++) { TDPointType tmpSensor = groundToSensorTransform->TransformPoint( corners[i] ); minMapRequestedIndex[0] = std::min( minMapRequestedIndex[0], static_cast ( tmpSensor[0] - m_Margin[0] ) ); minMapRequestedIndex[1] = std::min( minMapRequestedIndex[1], static_cast ( tmpSensor[1] - m_Margin[1] ) ); maxMapRequestedIndex[0] = std::max( maxMapRequestedIndex[0], static_cast ( tmpSensor[0] + m_Margin[0] ) ); maxMapRequestedIndex[1] = std::max( maxMapRequestedIndex[1], static_cast ( tmpSensor[1] + m_Margin[1] ) ); minMapRequestedIndex[0] = std::max(minMapRequestedIndex[0], minMapIndex[0]); minMapRequestedIndex[1] = std::max(minMapRequestedIndex[1], minMapIndex[1]); maxMapRequestedIndex[0] = std::min(maxMapRequestedIndex[0], maxMapIndex[0]); maxMapRequestedIndex[1] = std::min(maxMapRequestedIndex[1], maxMapIndex[1]); } RegionType largest = imgPtr->GetLargestPossibleRegion(); RegionType requestedRegion = largest; if ((minMapRequestedIndex[0] < maxMapRequestedIndex[0]) && (minMapRequestedIndex[1] < maxMapRequestedIndex[1])) { requestedRegion.SetSize(0, maxMapRequestedIndex[0] - minMapRequestedIndex[0]); requestedRegion.SetSize(1, maxMapRequestedIndex[1] - minMapRequestedIndex[1]); requestedRegion.SetIndex(0, minMapRequestedIndex[0]); requestedRegion.SetIndex(1, minMapRequestedIndex[1]); } else { requestedRegion.SetSize(0, 0); requestedRegion.SetSize(1, 0); requestedRegion.SetIndex(0, minMapIndex[0]); requestedRegion.SetIndex(1, minMapIndex[1]); } imgPtr->SetRequestedRegion(requestedRegion); TMaskImage *mskPtr = const_cast (this->GetMaskInput(k)); if (mskPtr) { if (mskPtr->GetLargestPossibleRegion() != largest) { itkExceptionMacro(<<"mask and map at position "<SetRequestedRegion(requestedRegion); } } } template void Multi3DMapToDEMFilter::BeforeThreadedGenerateData() { const TOutputDEMImage * outputDEM = this->GetDEMOutput(); //create splits // for each map we check if the input region can be split into threadNb m_NumberOfSplit.resize(this->GetNumberOf3DMaps()); unsigned int maximumRegionsNumber = 1; for (unsigned int k = 0; k < this->GetNumberOf3DMaps(); ++k) { m_MapSplitterList->PushBack(SplitterType::New()); T3DImage *imgPtr = const_cast (this->Get3DMapInput(k)); typename T3DImage::RegionType requestedRegion = imgPtr->GetRequestedRegion(); typename T3DImage::SizeType requestedSize=requestedRegion.GetSize(); unsigned int regionsNumber =0; if(requestedSize[0]*requestedSize[1]!=0) { regionsNumber = m_MapSplitterList->GetNthElement(k)->GetNumberOfSplits(requestedRegion, this->GetNumberOfThreads()); } m_NumberOfSplit[k] = regionsNumber; otbMsgDevMacro( "map " << k << " will be split into " << regionsNumber << " regions" ); if (maximumRegionsNumber < regionsNumber) maximumRegionsNumber = regionsNumber; } m_TempDEMRegions.clear(); m_TempDEMAccumulatorRegions.clear(); //m_ThreadProcessed.resize(maximumRegionsNumber); for (unsigned int i = 0; i < maximumRegionsNumber; i++) { //m_ThreadProcessed[i] = 0; typename TOutputDEMImage::Pointer tmpImg = TOutputDEMImage::New(); tmpImg->SetNumberOfComponentsPerPixel(1); //Two components for mean calculus ? tmpImg->SetRegions(outputDEM->GetRequestedRegion()); tmpImg->Allocate(); tmpImg->FillBuffer(m_NoDataValue); m_TempDEMRegions.push_back(tmpImg); typename AccumulatorImageType::Pointer tmpImg2 = AccumulatorImageType::New(); tmpImg2->SetNumberOfComponentsPerPixel(1); //Two components for mean calculus ? tmpImg2->SetRegions(outputDEM->GetRequestedRegion()); tmpImg2->Allocate(); tmpImg2->FillBuffer(0.); m_TempDEMAccumulatorRegions.push_back(tmpImg2); } if (!this->m_IsGeographic) { m_GroundTransform = RSTransform2DType::New(); m_GroundTransform->SetInputProjectionRef(static_cast (otb::GeoInformationConversion::ToWKT(4326))); m_GroundTransform->SetOutputProjectionRef(m_ProjectionRef); m_GroundTransform->InstantiateTransform(); } } template void Multi3DMapToDEMFilter::ThreadedGenerateData( const RegionType & itkNotUsed(outputRegionForThread), itk::ThreadIdType threadId) { TOutputDEMImage * outputPtr = this->GetOutput(); typename OutputImageType::PointType pointRef; typename OutputImageType::PointType pointRefStep; typename OutputImageType::RegionType requestedRegion = outputPtr->GetRequestedRegion(); // typename TOutputDEMImage::SpacingType step = outputPtr->GetSpacing(); //convert requested region to Long/Lat // typename TOutputDEMImage::SizeType size = requestedRegion.GetSize(); typename TOutputDEMImage::IndexType index = requestedRegion.GetIndex(); outputPtr->TransformIndexToPhysicalPoint(index, pointRef); /* InputInternalPixelType regionLong1 = pointRef[0]; InputInternalPixelType regionLat1 = pointRef[1]; InputInternalPixelType regionLong2 = pointRef[0] + size[0] * step[0]; InputInternalPixelType regionLat2 = pointRef[1] + size[1] * step[1]; InputInternalPixelType minLong = std::min(regionLong1, regionLong2); InputInternalPixelType minLat = std::min(regionLat1, regionLat2); InputInternalPixelType maxLong = std::max(regionLong1, regionLong2); InputInternalPixelType maxLat = std::max(regionLat1, regionLat2); */ TOutputDEMImage * tmpDEM = ITK_NULLPTR; AccumulatorImageType *tmpAcc = ITK_NULLPTR; typename TOutputDEMImage::RegionType outputRequestedRegion = outputPtr->GetRequestedRegion(); typename T3DImage::RegionType splitRegion; MapPixelType position; itk::ImageRegionConstIterator mapIt; for (unsigned int k = 0; k < this->GetNumberOf3DMaps(); ++k) { if (m_NumberOfSplit[k] > 0) { T3DImage *imgPtr = const_cast (this->Get3DMapInput(k)); TMaskImage *mskPtr = const_cast (this->GetMaskInput(k)); typename InputMapType::PointType origin; origin = imgPtr->GetOrigin(); typename InputMapType::SpacingType spacing; spacing = imgPtr->GetSpacing(); if (static_cast (threadId) < m_NumberOfSplit[k]) { splitRegion = m_MapSplitterList->GetNthElement(k)->GetSplit(threadId, m_NumberOfSplit[k], imgPtr->GetRequestedRegion()); tmpDEM = m_TempDEMRegions[threadId]; tmpAcc = m_TempDEMAccumulatorRegions[threadId]; mapIt = itk::ImageRegionConstIterator(imgPtr, splitRegion); mapIt.GoToBegin(); itk::ImageRegionConstIterator maskIt; bool useMask = false; if (mskPtr) { useMask = true; maskIt = itk::ImageRegionConstIterator(mskPtr, splitRegion); maskIt.GoToBegin(); } while (!mapIt.IsAtEnd()) { // check mask value if any if (useMask) { if (!(maskIt.Get() > 0)) { ++mapIt; ++maskIt; continue; } } position = mapIt.Get(); //std::cout<<"position"<m_IsGeographic) { //std::cout<<"is geographic "<TransformPoint(tmpPoint); position[0] = groundPosition[0]; position[1] = groundPosition[1]; } //test if position is in DEM BBOX /** -Wunused-variable bool isInDEM = (position[0] >= minLong) && (position[0] < maxLong) && (position[1] >= minLat) && (position[1] < maxLat); **/ // Is point inside DEM area ? typename OutputImageType::PointType point2D; point2D[0] = position[0]; point2D[1] = position[1]; itk::ContinuousIndex continuousIndex; //std::cout<<"point2D "<TransformPhysicalPointToContinuousIndex(point2D, continuousIndex); typename OutputImageType::IndexType cellIndex; cellIndex[0] = static_cast (vcl_floor(continuousIndex[0] + 0.5)); cellIndex[1] = static_cast (vcl_floor(continuousIndex[1] + 0.5)); //std::cout<<"cellindex "< (position[2]); //if (cellHeight > tmpDEM->GetPixel(cellIndex) && cellHeight < static_cast(m_ElevationMax)) // { // tmpDEM->SetPixel(cellIndex,tmpDEM->GetPixel(cellIndex)+1); AccumulatorPixelType accPixel = tmpAcc->GetPixel(cellIndex); tmpAcc->SetPixel(cellIndex, tmpAcc->GetPixel(cellIndex) + 1); if (accPixel == 0) { tmpDEM->SetPixel(cellIndex, cellHeight); } else { DEMPixelType cellCurrentValue = tmpDEM->GetPixel(cellIndex); switch (this->m_CellFusionMode) { case otb::CellFusionMode::MIN: { if (cellHeight < cellCurrentValue) { tmpDEM->SetPixel(cellIndex, cellHeight); } } break; case otb::CellFusionMode::MAX: { if (cellHeight > cellCurrentValue) { tmpDEM->SetPixel(cellIndex, cellHeight); } } break; case otb::CellFusionMode::MEAN: { tmpDEM->SetPixel(cellIndex, cellCurrentValue + cellHeight); } break; case otb::CellFusionMode::ACC: { } break; default: itkExceptionMacro(<< "Unexpected value cell fusion mode :"<m_CellFusionMode) ; break; } } } ++mapIt; if (useMask) ++maskIt; } } else { splitRegion = requestedRegion; otbMsgDevMacro( "map " << k << " will not be split " ); } } } } template void Multi3DMapToDEMFilter::AfterThreadedGenerateData() { TOutputDEMImage * outputDEM = this->GetOutput(); //check is that case can occur if (m_TempDEMRegions.size() < 1) { outputDEM->FillBuffer(m_NoDataValue); return; } itk::ImageRegionIterator outputDEMIt(outputDEM, outputDEM->GetRequestedRegion()); itk::ImageRegionIterator firstDEMIt(m_TempDEMRegions[0], outputDEM->GetRequestedRegion()); itk::ImageRegionIterator firstDEMAccIt(m_TempDEMAccumulatorRegions[0], outputDEM->GetRequestedRegion()); //we use the first accumulator as global accumulator over tmpAcc for mean calculus outputDEMIt.GoToBegin(); firstDEMIt.GoToBegin(); firstDEMAccIt.GoToBegin(); // Copy first DEM while (!outputDEMIt.IsAtEnd() && !firstDEMIt.IsAtEnd() && !firstDEMAccIt.IsAtEnd()) { AccumulatorPixelType accPixel = firstDEMAccIt.Get(); //useless test tempDEm is initialized with NoDataValue if (accPixel == 0) { outputDEMIt.Set(m_NoDataValue); } else { DEMPixelType pixelValue = firstDEMIt.Get(); outputDEMIt.Set(pixelValue); if ((this->m_CellFusionMode == otb::CellFusionMode::MEAN) && (m_TempDEMRegions.size() == 1)) { outputDEMIt.Set(firstDEMIt.Get() / static_cast (accPixel)); } if (this->m_CellFusionMode == otb::CellFusionMode::ACC) { outputDEMIt.Set(static_cast (accPixel)); } } ++outputDEMIt; ++firstDEMIt; ++firstDEMAccIt; } // Check DEMs from other threads and keep the maximum elevation for (unsigned int i = 1; i < m_TempDEMRegions.size(); i++) { itk::ImageRegionIterator tmpDEMIt(m_TempDEMRegions[i], outputDEM->GetRequestedRegion()); itk::ImageRegionIterator tmpDEMAccIt(m_TempDEMAccumulatorRegions[i], outputDEM->GetRequestedRegion()); outputDEMIt.GoToBegin(); tmpDEMIt.GoToBegin(); tmpDEMAccIt.GoToBegin(); firstDEMAccIt.GoToBegin(); //Global Accumulator while (!outputDEMIt.IsAtEnd() && !tmpDEMIt.IsAtEnd() && !tmpDEMAccIt.IsAtEnd() && !firstDEMAccIt.IsAtEnd()) { // get the accumulator value AccumulatorPixelType accPixel = tmpDEMAccIt.Get(); if (accPixel != 0) { DEMPixelType cellCurrentValue = outputDEMIt.Get(); DEMPixelType cellHeight = tmpDEMIt.Get(); switch (this->m_CellFusionMode) { case otb::CellFusionMode::MIN: { if ((cellHeight < cellCurrentValue) || (cellCurrentValue == m_NoDataValue)) { outputDEMIt.Set(cellHeight); } } break; case otb::CellFusionMode::MAX: { if ((cellHeight > cellCurrentValue) || ((cellCurrentValue == m_NoDataValue))) { outputDEMIt.Set(cellHeight); } } break; case otb::CellFusionMode::MEAN: { outputDEMIt.Set( cellCurrentValue * static_cast (cellCurrentValue != m_NoDataValue) + cellHeight); firstDEMAccIt.Set(firstDEMAccIt.Get() + accPixel); } break; case otb::CellFusionMode::ACC: { firstDEMAccIt.Set(firstDEMAccIt.Get() + accPixel); } break; default: itkExceptionMacro(<< "Unexpected value cell fusion mode :"<m_CellFusionMode); break; } } if (i == (m_TempDEMRegions.size() - 1)) { if (this->m_CellFusionMode == otb::CellFusionMode::MEAN) { if (static_cast (firstDEMAccIt.Get()) != 0) { outputDEMIt.Set(outputDEMIt.Get() / static_cast (firstDEMAccIt.Get())); } else { outputDEMIt.Set(m_NoDataValue); } } else if (this->m_CellFusionMode == otb::CellFusionMode::ACC) { outputDEMIt.Set(static_cast (firstDEMAccIt.Get())); } } ++outputDEMIt; ++tmpDEMIt; ++tmpDEMAccIt; ++firstDEMAccIt; } } } } #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbStereoSensorModelToElevationMapFilter.h000066400000000000000000000227741301006202600326500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStereoSensorModelToElevationMapFilter_h #define otbStereoSensorModelToElevationMapFilter_h #include "itkImageToImageFilter.h" #include "itkInterpolateImageFunction.h" #include "otbGenericRSTransform.h" #include "itkNormalizedCorrelationImageToImageMetric.h" namespace otb { /** * \class StereoSensorModelToElevationFilter * \brief Using sensor models to perform correlation along epipolars * * This filter uses a pair of stereo images along-track to build an elevation * map. * * Images are not resampled to epipolar geometry. Instead, for each * patch of the master image, corresponding patches are interpolated * in the slave image according to a range of candidate * elevations. Colocalisation is achieved through the * GenericRSTransform for each pixel of the patch, which means the * interpolated path follows the warping between the two images (it is * not necesseraly aligned with slave image boundary). The elevation * achieving the higher correlation is kept in the final elevation * map. * * Setting-up the elevation exploration range is simple : the * LowerElevation and HigherElevation parameters allows setting the * exploration range offsets with respect to the local elevation, and * the ElevationStep parameter allows setting the step between * candidate elevation. The local elevation can either be constant * over the whole scene, or interpolated in a Digital Elevation * Model. The latter allows accounting for highly varying elevation in * large scene, and allows reducing the elevation exploration * range. Please note that one can also use a geoid file along with * the DEM. * * Correlation parameters are as follows : * - The radius allows tuning patches size (default is 3), * - The CorrelationThreshold allows setting a threshold below which * correlation is considered to fail. If the correlation maxima is * below this threshold, the estimated elevation is * discarded (default is 0.7). * - The VarianceThreshold allows discarding master patches for which * variance is too small to yield reliable correlation. If the * variance of the current master patch lies below this threshold, no * elevation exploration is performed at this location (default is 4). * * This filter supports multi-threading and streaming. It can * process images of any size and does not requires input images * size to match. If images extents do not match, elevation will * only be estimated over their overlapping extent. The elevation * map is produced in the geometry and grid of the master input * image. * * \ingroup Streamed * \ingroup Threaded * * \ingroup OTBStereo */ template class ITK_EXPORT StereoSensorModelToElevationFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs */ typedef StereoSensorModelToElevationFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(StereoSensorModelToElevationFilter, ImageToImageFilter); /** Convenient typedefs */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputHeight OutputImageType; typedef typename OutputImageType::RegionType OutputRegionType; typedef typename OutputImageType::PixelType HeightType; typedef typename OutputImageType::PointType OutputPointType; typedef itk::InterpolateImageFunction InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointerType; typedef GenericRSTransform<> GenericRSTransformType; typedef GenericRSTransform GenericRSTransform3DType; typedef itk::NormalizedCorrelationImageToImageMetric CorrelationMetricType; typedef typename InputImageType::SizeType RadiusType; /** Set the master input image */ void SetMasterInput(const TInputImage * image); /** Set the slave input iamge */ void SetSlaveInput(const TInputImage * image); /** Get the master input image */ const TInputImage * GetMasterInput() const; /** Get the slave input image */ const TInputImage * GetSlaveInput() const; /** Get the output correlation map */ TOutputHeight * GetCorrelationOutput(); /** Set the lower offset for the local elevation * exploration. Default is -20 meters. */ itkSetMacro(LowerElevation, double); /** Set the lower offset for the local elevation * exploration. Default is 20 meters. */ itkSetMacro(HigherElevation, double); /** Set the step of the elevation exploration. Default is 1 meters. */ itkSetMacro(ElevationStep, double); /** Set the threshold of the correlation to keep estimated * height. Default is 0.7. */ itkSetMacro(CorrelationThreshold, double); /** Get the threshold of the correlation to keep estimated * height. Default is 0.7. */ itkGetMacro(CorrelationThreshold, double); /** Set the threshold on the variance of the master patch to start * elevation estimation. Default is 4. */ itkSetMacro(VarianceThreshold, double); /** Set the threshold on the variance of the master patch to start * elevation estimation. Default is 4. */ itkGetMacro(VarianceThreshold, double); /** Set the SubtractInitialElevation flag. If set to true, the * elevation map will only contains the difference between the * estimated elevation and the initial one. If set to false, * elevation is absolute. Default is false. */ itkSetMacro(SubtractInitialElevation, bool); /** Get the SubtractInitialElevation flag. If set to true, the * elevation map will only contains the difference between the * estimated elevation and the initial one. If set to false, * elevation is absolute. Default is false. */ itkGetMacro(SubtractInitialElevation, bool); /** Toggle the SubtractInitialElevation flag. If set to true, the * elevation map will only contains the difference between the * estimated elevation and the initial one. If set to false, * elevation is absolute. Default is false. */ itkBooleanMacro(SubtractInitialElevation); /** Set the radius of the patches. Default is 3. */ void SetRadius(unsigned int radius) { m_Radius.Fill(radius); this->Modified(); } protected: /** Constructor */ StereoSensorModelToElevationFilter(); /** Destructor */ ~StereoSensorModelToElevationFilter() ITK_OVERRIDE; /** Threaded generate data */ void ThreadedGenerateData(const OutputRegionType& outputRegionForThread, itk::ThreadIdType threadId) ITK_OVERRIDE; /** Generate the input requested regions */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Things to do before the threaded generate-data */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Override VerifyInputInformation() since this filter's inputs do * not need to occupy the same physical space. * * \sa ProcessObject::VerifyInputInformation */ void VerifyInputInformation() ITK_OVERRIDE {} private: StereoSensorModelToElevationFilter(const Self&); // purposely not implemented void operator=(const Self&); // purposely not implemented inline double Correlation(const std::vector& master, const std::vector& slave) const; /** Interpolator for slave image */ InterpolatorPointerType m_Interpolator; /** Radius of the patches */ RadiusType m_Radius; /** Lower offset for the local elevation exploration. */ double m_LowerElevation; /** Higher offset for the local elevation exploration. */ double m_HigherElevation; /** Step of the elevation exploration. */ double m_ElevationStep; /** If set to true, the local elevation is extracted from a DEM + geoid. If set to false, average elevation is used. Default is false. */ bool m_UseDEM; /** Threshold of the correlation to keep estimated height. */ double m_CorrelationThreshold; /** Threshold on the variance of the master patch to start elevation * estimation. */ double m_VarianceThreshold; /** If set to true, the elevation map will only contains the * difference between the estimated elevation and the initial * one. If set to false, elevation is absolute. Default is false. */ bool m_SubtractInitialElevation; /** Master to slave transform */ GenericRSTransform3DType::Pointer m_MasterToSlave; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStereoSensorModelToElevationMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbStereoSensorModelToElevationMapFilter.txx000066400000000000000000000453571301006202600332460ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStereoSensorModelToElevationMapFilter_txx #define otbStereoSensorModelToElevationMapFilter_txx #include "otbStereoSensorModelToElevationMapFilter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkProgressReporter.h" #include "itkLinearInterpolateImageFunction.h" #include "otbBCOInterpolateImageFunction.h" #include "itkConstNeighborhoodIterator.h" #include "otbDEMHandler.h" namespace otb { template StereoSensorModelToElevationFilter ::StereoSensorModelToElevationFilter() { // Filter has two inputs this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(1, OutputImageType::New()); // Default interpolator m_Interpolator = itk::LinearInterpolateImageFunction::New(); // Default correlation radius m_Radius.Fill(3); // Height exploration setup m_LowerElevation = -20; m_HigherElevation = 20; m_ElevationStep = 1.; m_CorrelationThreshold = 0.7; m_VarianceThreshold = 4; m_SubtractInitialElevation = false; // DEM handling (deprecated) m_UseDEM = false; } template StereoSensorModelToElevationFilter ::~StereoSensorModelToElevationFilter() {} template void StereoSensorModelToElevationFilter ::SetMasterInput(const TInputImage * image) { this->SetNthInput(0, const_cast( image )); } template void StereoSensorModelToElevationFilter ::SetSlaveInput(const TInputImage * image) { this->SetNthInput(1, const_cast( image )); } template const TInputImage * StereoSensorModelToElevationFilter ::GetMasterInput() const { if(this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(0)); } template const TInputImage * StereoSensorModelToElevationFilter ::GetSlaveInput() const { if(this->GetNumberOfInputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetInput(1)); } template TOutputHeight * StereoSensorModelToElevationFilter ::GetCorrelationOutput() { if(this->GetNumberOfOutputs()<2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void StereoSensorModelToElevationFilter ::GenerateInputRequestedRegion() { // Call the superclass implementation Superclass::GenerateInputRequestedRegion(); // Retrieve pointers InputImageType * masterPtr = const_cast(this->GetMasterInput()); InputImageType * slavePtr = const_cast(this->GetSlaveInput()); OutputImageType * outputPtr = this->GetOutput(); if ( !masterPtr || !slavePtr || !outputPtr ) { return; } // get a copy of the fixed requested region (should equal the output // requested region) typename InputImageType::RegionType masterRequestedRegion, slaveRequestedRegion; masterRequestedRegion = outputPtr->GetRequestedRegion(); // pad the master requested region by the operator radius masterRequestedRegion.PadByRadius( m_Radius ); // Find corners of the master requested region typename InputImageType::IndexType mul, mur, mll, mlr; mul = masterRequestedRegion.GetIndex(); mur = masterRequestedRegion.GetIndex(); mur[0] += masterRequestedRegion.GetSize()[0]-1; mll = masterRequestedRegion.GetIndex(); mll[1] += masterRequestedRegion.GetSize()[1]-1; mlr = masterRequestedRegion.GetIndex(); mlr[0] += masterRequestedRegion.GetSize()[0]-1; mlr[1] += masterRequestedRegion.GetSize()[1]-1; // Transform to physical space typename InputImageType::PointType mpul, mpur, mpll, mplr; masterPtr->TransformIndexToPhysicalPoint(mul, mpul); masterPtr->TransformIndexToPhysicalPoint(mur, mpur); masterPtr->TransformIndexToPhysicalPoint(mll, mpll); masterPtr->TransformIndexToPhysicalPoint(mlr, mplr); // Build the transform to switch from the master to the slave image typename GenericRSTransformType::Pointer transform = GenericRSTransformType::New(); transform->SetInputKeywordList(masterPtr->GetImageKeywordlist()); transform->SetOutputKeywordList(slavePtr->GetImageKeywordlist()); transform->InstantiateTransform(); typename GenericRSTransformType::ParametersType params(1); // Build minimum height and maximum height points corresponding to // corners of the master requested region typename InputImageType::PointType sMinPul, sMinPur, sMinPll, sMinPlr, sMaxPul, sMaxPur, sMaxPll, sMaxPlr; // Lower case params[0] = m_LowerElevation; transform->SetParameters(params); sMinPul = transform->TransformPoint(mpul); sMinPur = transform->TransformPoint(mpur); sMinPll = transform->TransformPoint(mpll); sMinPlr = transform->TransformPoint(mplr); // Higher case params[0] = m_HigherElevation; transform->SetParameters(params); sMaxPul = transform->TransformPoint(mpul); sMaxPur = transform->TransformPoint(mpur); sMaxPll = transform->TransformPoint(mpll); sMaxPlr = transform->TransformPoint(mplr); // Transform to index typename InputImageType::IndexType sMinul, sMinur, sMinll, sMinlr, sMaxul, sMaxur, sMaxll, sMaxlr; slavePtr->TransformPhysicalPointToIndex(sMinPul, sMinul); slavePtr->TransformPhysicalPointToIndex(sMaxPul, sMaxul); slavePtr->TransformPhysicalPointToIndex(sMinPur, sMinur); slavePtr->TransformPhysicalPointToIndex(sMaxPur, sMaxur); slavePtr->TransformPhysicalPointToIndex(sMinPll, sMinll); slavePtr->TransformPhysicalPointToIndex(sMaxPll, sMaxll); slavePtr->TransformPhysicalPointToIndex(sMinPlr, sMinlr); slavePtr->TransformPhysicalPointToIndex(sMaxPlr, sMaxlr); // Find the corresponding bounding box typename InputImageType::IndexType sul, slr; sul[0] = std::min(std::min(std::min(sMinul[0], sMaxul[0]), std::min(sMinur[0], sMaxur[0])), std::min(std::min(sMinll[0], sMaxll[0]), std::min(sMinlr[0], sMaxlr[0]))); sul[1] = std::min(std::min(std::min(sMinul[1], sMaxul[1]), std::min(sMinur[1], sMaxur[1])), std::min(std::min(sMinll[1], sMaxll[1]), std::min(sMinlr[1], sMaxlr[1]))); slr[0] = std::max(std::max(std::max(sMinul[0], sMaxul[0]), std::max(sMinur[0], sMaxur[0])), std::max(std::max(sMinll[0], sMaxll[0]), std::max(sMinlr[0], sMaxlr[0]))); slr[1] = std::max(std::max(std::max(sMinul[1], sMaxul[1]), std::max(sMinur[1], sMaxur[1])), std::max(std::max(sMinll[1], sMaxll[1]), std::max(sMinlr[1], sMaxlr[1]))); // Build the slave requested region slaveRequestedRegion.SetIndex(sul); typename InputImageType::SizeType ssize; ssize[0] = slr[0] - sul[0]+1; ssize[1] = slr[1] - sul[1]+1; slaveRequestedRegion.SetSize(ssize); // crop the master region at the master's largest possible region if ( masterRequestedRegion.Crop(masterPtr->GetLargestPossibleRegion())) { masterPtr->SetRequestedRegion( masterRequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). Throw an exception. // store what we tried to request (prior to trying to crop) masterPtr->SetRequestedRegion( masterRequestedRegion ); // build an exception itk::InvalidRequestedRegionError e(__FILE__, __LINE__); std::ostringstream msg; msg << this->GetNameOfClass() << "::GenerateInputRequestedRegion()"; e.SetLocation(msg.str().c_str()); e.SetDescription("Requested region is (at least partially) outside the largest possible region of image 1."); e.SetDataObject(masterPtr); throw e; } // crop the slave region at the slave's largest possible region if ( slaveRequestedRegion.Crop(slavePtr->GetLargestPossibleRegion())) { slavePtr->SetRequestedRegion( slaveRequestedRegion ); } else { // Couldn't crop the region (requested region is outside the largest // possible region). This case might happen so we do not throw any exception but // request a null region instead typename InputImageType::SizeType slaveSize; slaveSize.Fill(0); slaveRequestedRegion.SetSize(slaveSize); typename InputImageType::IndexType slaveIndex; slaveIndex.Fill(0); slaveRequestedRegion.SetIndex(slaveIndex); // store what we tried to request (prior to trying to crop) slavePtr->SetRequestedRegion(slaveRequestedRegion); } return; } template void StereoSensorModelToElevationFilter ::BeforeThreadedGenerateData() { // Wire the interpolator m_Interpolator->SetInputImage(this->GetSlaveInput()); this->GetCorrelationOutput()->FillBuffer(0.); // Initialize with average elevation this->GetOutput()->FillBuffer(otb::DEMHandler::Instance()->GetDefaultHeightAboveEllipsoid()); // Initialize with DEM elevation (not threadable because of some // mutex in ossim) OutputImageType * outputPtr = this->GetOutput(); typename GenericRSTransformType::Pointer rsTransform = GenericRSTransformType::New(); rsTransform->SetInputKeywordList(outputPtr->GetImageKeywordlist()); rsTransform->InstantiateTransform(); // Fill output itk::ImageRegionIteratorWithIndex outputIt(outputPtr, outputPtr->GetBufferedRegion()); for(outputIt.GoToBegin(); !outputIt.IsAtEnd(); ++outputIt) { // Retrieve physical point OutputPointType outputPoint, geoPoint; outputPtr->TransformIndexToPhysicalPoint(outputIt.GetIndex(), outputPoint); // Transform to geo point geoPoint = rsTransform->TransformPoint(outputPoint); outputIt.Set(otb::DEMHandler::Instance()->GetHeightAboveEllipsoid(geoPoint)); } const InputImageType* masterPtr = this->GetMasterInput(); const InputImageType* slavePtr = this->GetSlaveInput(); // Set-up the forward-inverse sensor model transform m_MasterToSlave = GenericRSTransform3DType::New(); m_MasterToSlave->SetInputKeywordList(masterPtr->GetImageKeywordlist()); m_MasterToSlave->SetOutputKeywordList(slavePtr->GetImageKeywordlist()); m_MasterToSlave->InstantiateTransform(); } template void StereoSensorModelToElevationFilter ::ThreadedGenerateData(const OutputRegionType & outputRegionForThread, itk::ThreadIdType threadId) { // Retrieve pointers const InputImageType* masterPtr = this->GetMasterInput(); OutputImageType* outputPtr = this->GetOutput(); OutputImageType* correlPtr = this->GetCorrelationOutput(); // TODO: Uncomment when model optimization pushed // // GCP refinement // unsigned int gcpCount1 = this->GetMasterInput()->GetGCPCount(); // unsigned int gcpCount2 = this->GetSlaveInput()->GetGCPCount(); // transform->ClearInputTiePoints(); // transform->ClearOutputTiePoints(); // for(unsigned int i = 0; i < gcpCount1; ++i) // { // typename GenericRSTransformType::InputPointType imagePoint, groundPoint, groundPointWGS84; // // Transform GCP ground part to WGS84 // groundPoint[0] = this->GetMasterInput()->GetGCPs(i).m_GCPX; // groundPoint[1] = this->GetMasterInput()->GetGCPs(i).m_GCPY; // typename GenericRSTransformType::Pointer gcpTransform = GenericRSTransformType::New(); // gcpTransform->SetInputProjectionRef(this->GetInput()->GetGCPProjection()); // gcpTransform->InstantiateTransform(); // groundPointWGS84 = gcpTransform->TransformPoint(groundPoint); // imagePoint[0] = this->GetMasterInput()->GetGCPs(i).m_GCPCol; // imagePoint[1] = this->GetMasterInput()->GetGCPs(i).m_GCPRow; // transform->AddInputTiePoint(imagePoint, groundPointWGS84); // transform->OptimizeInputTransformOn(); // } // for(unsigned int i = 0; i < gcpCount2; ++i) // { // typename GenericRSTransformType::InputPointType imagePoint, groundPoint, groundPointWGS84; // // Transform GCP ground part to WGS84 // groundPoint[0] = this->GetSlaveInput()->GetGCPs(i).m_GCPX; // groundPoint[1] = this->GetSlaveInput()->GetGCPs(i).m_GCPY; // typename GenericRSTransformType::Pointer gcpTransform = GenericRSTransformType::New(); // gcpTransform->SetInputProjectionRef(this->GetInput()->GetGCPProjection()); // gcpTransform->InstantiateTransform(); // groundPointWGS84 = gcpTransform->TransformPoint(groundPoint); // imagePoint[0] = this->GetSlaveInput()->GetGCPs(i).m_GCPCol; // imagePoint[1] = this->GetSlaveInput()->GetGCPs(i).m_GCPRow; // transform->AddOutputTiePoint(imagePoint, groundPointWGS84); // transform->OptimizeOutputTransformOn(); // } // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // Define an iterator on the output elevation map itk::ConstNeighborhoodIterator inputIt(m_Radius, masterPtr, outputRegionForThread); itk::ImageRegionIterator outputIt(outputPtr, outputRegionForThread); itk::ImageRegionIteratorWithIndex correlIt(correlPtr, outputRegionForThread); // Start visiting buffer again outputIt.GoToBegin(); correlIt.GoToBegin(); inputIt.GoToBegin(); // This will hold the master patch std::vector master; master.reserve(inputIt.Size()); master = std::vector(inputIt.Size(), 0); // And this will hold the slave patch std::vector slave; slave.reserve(inputIt.Size()); slave = std::vector(inputIt.Size(), 0); // Walk the output map while(!outputIt.IsAtEnd() && !inputIt.IsAtEnd()) { // Define some loop variables typename InputImageType::PointType inPoint, outPoint, currentPoint, optimalPoint; typename GenericRSTransform3DType::InputPointType in3DPoint, out3DPoint; typename InputImageType::IndexType index; // Retrieve initial height double initHeight = outputIt.Get(); double optimalHeight = initHeight; double optimalCorrelation = 0; // Check if there is an height info if(initHeight != -32768) { // These are used to estimate master patch variance double masterSum = 0; double masterVariance = 0; // Fill master patch for(unsigned int i = 0; i < inputIt.Size(); ++i) { // Add to the master vector double value = inputIt.GetPixel(i); master[i] = value; // Cumulate for mean masterSum += value; } // Finalize mean masterSum /= inputIt.Size(); // Complete pooled variance computation for(unsigned int i = 0; i < inputIt.Size(); ++i) { masterVariance += (master[i] - masterSum) * (master[i] - masterSum); } masterVariance /= (inputIt.Size()-1); // Check for high enough variance so that correlation will be reliable if(masterVariance > m_VarianceThreshold) { // Explore candidate heights for(double height = initHeight + m_LowerElevation; height < initHeight + m_HigherElevation; height += m_ElevationStep) { // Interpolate slave patch for(unsigned int i = 0; i < inputIt.Size(); ++i) { // Retrieve the current index index = inputIt.GetIndex(i); // Retrieve master physical point masterPtr->TransformIndexToPhysicalPoint(index, inPoint); in3DPoint[0] = inPoint[0]; in3DPoint[1] = inPoint[1]; in3DPoint[2] = height; // Transform to slave out3DPoint = m_MasterToSlave->TransformPoint(in3DPoint); outPoint[0] = out3DPoint[0]; outPoint[1] = out3DPoint[1]; // Interpolate if(m_Interpolator->IsInsideBuffer(outPoint)) { // And fill slave vector slave[i] = m_Interpolator->Evaluate(outPoint); } else { // If out of buffer, fill with 0. slave[i] = 0.; } } // Now that we have the master and slave patches, call the // correlation function double correlationValue = this->Correlation(master, slave); // Check if a better correlation was found if(correlationValue > optimalCorrelation) { // If found, update values optimalCorrelation = correlationValue; optimalHeight = height; } } } // TODO: refinenement step ? } // Final check on best correlation value double finalOffset = 0.; // Switch to subtract initial elevation mode if(m_SubtractInitialElevation) { finalOffset = initHeight; } if(optimalCorrelation > m_CorrelationThreshold) { outputIt.Set(optimalHeight-finalOffset); correlIt.Set(optimalCorrelation); } else { outputIt.Set(initHeight - finalOffset); correlIt.Set(0); } // Update progress progress.CompletedPixel(); // And iterators ++inputIt; ++outputIt; ++correlIt; } } template double StereoSensorModelToElevationFilter ::Correlation(const std::vector& master, const std::vector& slave) const { double meanSlave = 0; double meanMaster = 0; double correlationValue = 0; // Compute means for(unsigned int i = 0; i < master.size(); ++i) { meanSlave += slave[i]; meanMaster += master[i]; } meanSlave /= slave.size(); meanMaster /= master.size(); double crossProd = 0.; double squareSumMaster = 0.; double squareSumSlave = 0.; // Compute correlation for(unsigned int i = 0; i < master.size(); ++i) { crossProd += (slave[i]-meanSlave) * (master[i]-meanMaster); squareSumSlave += (slave[i]-meanSlave) * (slave[i]-meanSlave); squareSumMaster += (master[i]-meanMaster) * (master[i]-meanMaster); } correlationValue = vcl_abs(crossProd/(vcl_sqrt(squareSumSlave)*vcl_sqrt(squareSumMaster))); return correlationValue; } } // end namespace otb #endif OTB-release-5.8/Modules/Registration/Stereo/include/otbStereorectificationDisplacementFieldSource.h000066400000000000000000000206721301006202600337340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStereorectificationDisplacementFieldSource_h #define otbStereorectificationDisplacementFieldSource_h #include "itkImageSource.h" #include "otbGenericRSTransform.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkVector.h" #include "otbMacro.h" namespace otb { /** \class StereorectificationDisplacementFieldSource * \brief Compute the deformation fields for stereo-rectification * * The geometry of acqusition related to stereo pairs is such that * the displacement related to the elevation between the two images * of the pair always occurs along lines that are called epipolar * lines. * * In the case of conic acqusition, these lines are perfectly * parallel by definition, while in push-broom geometry, these lines * might not be exactly parallel due to perturbations during * acquisition, especially when considering a large field of view. * * The purpose of stereo-rectification is to warp both images of the * pairs so that the displacement related to the elevation only * occurs in the horizontal direction (i.e. epipolar lines are * horizontal). This operation is useful for mainly two reasons: it * allows searching for disparities in one direction only, and it * allows deriving anaglyph for 3D viewing with 3D glasses. * * This filter allows you to compute the deformation fields up to the * sensor model precision needed to warp a pair of stereo images into * epipolar geometry. Warping can be done using the * otb::StreamingWarpImageFilter. * * Since lines might not be perfectly regular, the algorithm * performed by this filter uses the otb::GenericRSTransform * capabilities to compute the local epipolar lines, and iteratively * build a resampling grid by propagating along these locally * estimated lines. * * Epipolar images will have a null origin and a size as given by the * GetRectifiedImageSize() method. The deformation fields and size * are derived to produce epipolar images covering the whole extent * of the left image. * * The SetAverageElevation() method allows you to set the elevation * hypothesis on which the epipolar geometry is built. It means that * any pair of pixels in the stereo pair whose elevation is exactly * equal to the average elevation will have a null disparity (no * displacement). The SetElevationOffset() method allows tuning the * elevation offset which is only used for local epipolar lines * estimation. The default value of 50 meters should do. * * Additionnaly, the SetScale() method allows deriving deformation * fields and images size at a coarser (scale > 1) or finer (scale < * 1) resolution. The SetGridStep() allows tuning the step of the * resampling grid. Please keep in mind that the whole grid is loaded * into memory, and that the epipolar lines direction may only vary * smoothly. When working with large images, a coarse grid-step will * generally be accurate enough and will preserve the memory resources. * * \sa StreamingWarpImageFilter * \sa StereoSensorModelToElevationMapFilter * * \ingroup OTBStereo */ template class ITK_EXPORT StereorectificationDisplacementFieldSource : public itk::ImageSource { public: /** Standard class typedefs */ typedef StereorectificationDisplacementFieldSource Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; // Inputs and outputs relative typedefs typedef TInputImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; // Image related typedefs typedef typename OutputImageType::SizeType SizeType; typedef typename OutputImageType::PointType PointType; typedef typename OutputImageType::SpacingType SpacingType; typedef typename OutputImageType::RegionType RegionType; // 3D RS transform // TODO: Allow tuning precision (i.e. double or float) typedef otb::GenericRSTransform RSTransformType; typedef typename RSTransformType::Pointer RSTransformPointerType; // 3D points typedef typename RSTransformType::InputPointType TDPointType; /** Method for creation through the object factory. */ itkNewMacro( Self ); /** Run-time type information (and related methods). */ itkTypeMacro( StereorectificationDisplacementFieldSource, ImageSource ); /** Get/Set the scale */ itkSetMacro(Scale,double); itkGetConstReferenceMacro(Scale,double); /** Get/Set the grid scale */ itkSetMacro(GridStep,double); itkGetMacro(GridStep,double); /** Get/Set left image for stereo-rectification */ itkSetObjectMacro(LeftImage,InputImageType); itkGetObjectMacro(LeftImage,InputImageType); /** Get/Set right image for stereo-rectification */ itkSetObjectMacro(RightImage,InputImageType); itkGetObjectMacro(RightImage,InputImageType); /** Get the size of the rectified image */ itkGetConstReferenceMacro(RectifiedImageSize,SizeType); /** Get the estimated mean baseline ratio */ itkGetConstReferenceMacro(MeanBaselineRatio,double); /** Return the left deformation field (const version) */ const OutputImageType * GetLeftDisplacementFieldOutput() const; /** Return the left deformation field */ OutputImageType * GetLeftDisplacementFieldOutput(); /** Return the left deformation field (const version) */ const OutputImageType * GetRightDisplacementFieldOutput() const; /** Return the left deformation field */ OutputImageType * GetRightDisplacementFieldOutput(); itkSetMacro(UseDEM,bool); itkGetMacro(UseDEM,bool); itkBooleanMacro(UseDEM); protected: /** Constructor */ StereorectificationDisplacementFieldSource( void ); /** Destructor */ ~StereorectificationDisplacementFieldSource( void ) ITK_OVERRIDE {}; /** Generate output images information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Enlarge output requested region (no streaming) */ void EnlargeOutputRequestedRegion(itk::DataObject * itkNotUsed(output)) ITK_OVERRIDE; /** Compute the deformation field */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf( std::ostream& os, itk::Indent indent ) const ITK_OVERRIDE; private: StereorectificationDisplacementFieldSource( const Self& ); // purposely // not // implemented void operator=( const Self& ); //purposely not implemented /** This elevation offset is used to compute the epipolar direction */ double m_ElevationOffset; /** A scale greater than 1 will lead to zoomed stereo-rectified * pairs */ double m_Scale; /** Controls the step of the resampling grid (in pixels). A finer * step will lead to more memory consumption. */ double m_GridStep; /** Left image */ InputImagePointerType m_LeftImage; /** Right image */ InputImagePointerType m_RightImage; /** Left to right transform */ RSTransformPointerType m_LeftToRightTransform; /** Right to left transform */ RSTransformPointerType m_RightToLeftTransform; /** Size of the rectified images */ SizeType m_RectifiedImageSize; /** Output origin in left image (internal use) */ TDPointType m_OutputOriginInLeftImage; /** This variable contains the estimated mean baseline ratio over * the image */ double m_MeanBaselineRatio; /** If set to true, elevation is retrieved through * DEMHandler::GetHeightAboveEllipsoid(). If false, elevation is * retrieved from DEMHandler::GetDefaultHeightAboveEllipsoid() */ bool m_UseDEM; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbStereorectificationDisplacementFieldSource.txx" #endif #endif otbStereorectificationDisplacementFieldSource.txx000066400000000000000000000462411301006202600342510ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/Stereo/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStereoSensorModelToElevationMapFilter_txx #define otbStereoSensorModelToElevationMapFilter_txx #include "otbStereorectificationDisplacementFieldSource.h" #include "itkProgressReporter.h" #include "otbMath.h" // For partial specialization #include "otbVectorImage.h" #include "otbDEMHandler.h" namespace otb { template StereorectificationDisplacementFieldSource ::StereorectificationDisplacementFieldSource() : m_ElevationOffset(50), m_Scale(1), m_GridStep(1), m_LeftImage(), m_RightImage(), m_LeftToRightTransform(), m_RightToLeftTransform(), m_OutputOriginInLeftImage(), m_MeanBaselineRatio(0), m_UseDEM(false) { // Set the number of outputs to 2 (one deformation field for each // image) this->SetNumberOfRequiredOutputs(2); // Create the 2nd input (not created by default) this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageType::New()); // Build the RS Transforms m_LeftToRightTransform = RSTransformType::New(); m_RightToLeftTransform = RSTransformType::New(); } template const typename StereorectificationDisplacementFieldSource ::OutputImageType * StereorectificationDisplacementFieldSource ::GetLeftDisplacementFieldOutput() const { if (this->GetNumberOfOutputs() < 1) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template typename StereorectificationDisplacementFieldSource ::OutputImageType * StereorectificationDisplacementFieldSource ::GetLeftDisplacementFieldOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template const typename StereorectificationDisplacementFieldSource ::OutputImageType * StereorectificationDisplacementFieldSource ::GetRightDisplacementFieldOutput() const { if (this->GetNumberOfOutputs() < 2) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template typename StereorectificationDisplacementFieldSource ::OutputImageType * StereorectificationDisplacementFieldSource ::GetRightDisplacementFieldOutput() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void StereorectificationDisplacementFieldSource ::GenerateOutputInformation() { //Superclass::GenerateOutputInformation(); // Ensure that both left image and right image are available if(m_LeftImage.IsNull() || m_RightImage.IsNull()) { itkExceptionMacro(<<"Either left image or right image pointer is null, can not perform stereo-rectification."); } // Ensure input images have up-to-date information m_LeftImage->UpdateOutputInformation(); m_RightImage->UpdateOutputInformation(); // Setup the DEM handler if needed typename DEMHandler::Pointer demHandler = DEMHandler::Instance(); // Set-up a transform to use the DEMHandler typedef otb::GenericRSTransform<> RSTransform2DType; RSTransform2DType::Pointer leftToGroundTransform = RSTransform2DType::New(); leftToGroundTransform->SetInputKeywordList(m_LeftImage->GetImageKeywordlist()); leftToGroundTransform->InstantiateTransform(); // Retrieve the deformation field pointers OutputImageType * leftDFPtr = this->GetLeftDisplacementFieldOutput(); OutputImageType * rightDFPtr = this->GetRightDisplacementFieldOutput(); // Set up the RS transforms m_LeftToRightTransform->SetInputKeywordList(m_LeftImage->GetImageKeywordlist()); m_LeftToRightTransform->SetOutputKeywordList(m_RightImage->GetImageKeywordlist()); m_LeftToRightTransform->InstantiateTransform(); m_RightToLeftTransform->SetInputKeywordList(m_RightImage->GetImageKeywordlist()); m_RightToLeftTransform->SetOutputKeywordList(m_LeftImage->GetImageKeywordlist()); m_RightToLeftTransform->InstantiateTransform(); // Now, we must determine the optimized size, spacing and origin of the // stereo-rectified images, as well as the position of the origin in // the left image // First, spacing : choose a square spacing, SpacingType outputSpacing; outputSpacing.Fill(m_Scale * m_GridStep); double mean_spacing=0.5*(vcl_abs(m_LeftImage->GetSpacing()[0])+vcl_abs(m_LeftImage->GetSpacing()[1])); //double ratio_x = mean_spacing / vcl_abs(m_LeftImage->GetSpacing()[0]); //double ratio_y = mean_spacing / vcl_abs(m_LeftImage->GetSpacing()[1]); outputSpacing[0]*=mean_spacing; outputSpacing[1]*=mean_spacing; // Then, we retrieve the origin of the left input image double localElevation = otb::DEMHandler::Instance()->GetDefaultHeightAboveEllipsoid(); if(m_UseDEM) { RSTransform2DType::InputPointType tmpPoint; localElevation = demHandler->GetHeightAboveEllipsoid(leftToGroundTransform->TransformPoint(m_LeftImage->GetOrigin())); } TDPointType leftInputOrigin; leftInputOrigin[0] = m_LeftImage->GetOrigin()[0]; leftInputOrigin[1] = m_LeftImage->GetOrigin()[1]; leftInputOrigin[2] = localElevation; // Next, we will compute the parameters of the local epipolar line // at the left image origin TDPointType rightEpiPoint, leftEpiLineStart, leftEpiLineEnd; // This point is the image of the left input image origin at the // average elevation rightEpiPoint = m_LeftToRightTransform->TransformPoint(leftInputOrigin); // The beginning of the epipolar line in the left image is the image // of rightEpiPoint at a lower elevation (using the offset) rightEpiPoint[2] = localElevation - m_ElevationOffset; leftEpiLineStart = m_RightToLeftTransform->TransformPoint(rightEpiPoint); // The ending of the epipolar line in the left image is the image // of rightEpiPoint at a higher elevation (using the offset) rightEpiPoint[2] = localElevation + m_ElevationOffset; leftEpiLineEnd = m_RightToLeftTransform->TransformPoint(rightEpiPoint); // Now, we can compute the equation of the epipolar line y = a*x+b // epipolar angle is computed in left image physical space double alpha = 0; if (leftEpiLineEnd[0] == leftEpiLineStart[0]) { if (leftEpiLineEnd[1] > leftEpiLineStart[1]) { alpha = 0.5*otb::CONST_PI; } else { alpha = -0.5*otb::CONST_PI; } } else { double a = (leftEpiLineEnd[1] - leftEpiLineStart[1]) / (leftEpiLineEnd[0] - leftEpiLineStart[0]); if (leftEpiLineEnd[0] > leftEpiLineStart[0]) { alpha = vcl_atan(a); } else { alpha = otb::CONST_PI + vcl_atan(a); } } // And compute the unitary vectors of the new axis (equivalent to // the column of the rotation matrix) // TODO: Check if we need to use the input image spacing here double ux = vcl_cos(alpha); double uy = vcl_sin(alpha); double vx = - vcl_sin(alpha); double vy = vcl_cos(alpha); // Now, we will compute the bounding box of the left input image in // this rotated geometry // First we compute coordinates of the 4 corners (we omit ulx which // coordinates are {0,0}) double urx = ux * m_LeftImage->GetLargestPossibleRegion().GetSize()[0] * m_LeftImage->GetSpacing()[0]; double ury = vx * m_LeftImage->GetLargestPossibleRegion().GetSize()[0] * m_LeftImage->GetSpacing()[0]; double llx = uy * m_LeftImage->GetLargestPossibleRegion().GetSize()[1] * m_LeftImage->GetSpacing()[1]; double lly = vy * m_LeftImage->GetLargestPossibleRegion().GetSize()[1] * m_LeftImage->GetSpacing()[1]; double lrx = ux * m_LeftImage->GetLargestPossibleRegion().GetSize()[0] * m_LeftImage->GetSpacing()[0] + uy * m_LeftImage->GetLargestPossibleRegion().GetSize()[1] * m_LeftImage->GetSpacing()[1]; double lry = vx * m_LeftImage->GetLargestPossibleRegion().GetSize()[0] * m_LeftImage->GetSpacing()[0] + vy * m_LeftImage->GetLargestPossibleRegion().GetSize()[1] * m_LeftImage->GetSpacing()[1]; // Bounding box (this time we do not omit ulx) double minx = std::min(std::min(std::min(urx,llx),lrx),0.); double miny = std::min(std::min(std::min(ury,lly),lry),0.); double maxx = std::max(std::max(std::max(urx,llx),lrx),0.); double maxy = std::max(std::max(std::max(ury,lly),lry),0.); // We can now estimate the output image size, taking into account // the scale parameter m_RectifiedImageSize[0] = static_cast((maxx-minx)/(mean_spacing*m_Scale)); m_RectifiedImageSize[1] = static_cast((maxy-miny)/(mean_spacing*m_Scale)); // Now, we can compute the origin of the epipolar images in the left // input image geometry (we rotate back) m_OutputOriginInLeftImage[0] = leftInputOrigin[0] + (ux * minx + vx * miny); m_OutputOriginInLeftImage[1] = leftInputOrigin[1] + (uy * minx + vy * miny); m_OutputOriginInLeftImage[2] = localElevation; // And also the size of the deformation field SizeType outputSize; outputSize[0] = (m_RectifiedImageSize[0] / m_GridStep + 2 ); outputSize[1] = (m_RectifiedImageSize[1] / m_GridStep + 2); // Build the output largest region RegionType outputLargestRegion; outputLargestRegion.SetSize(outputSize); // Update the information leftDFPtr->SetLargestPossibleRegion(outputLargestRegion); rightDFPtr->SetLargestPossibleRegion(outputLargestRegion); leftDFPtr->SetSpacing(outputSpacing); rightDFPtr->SetSpacing(outputSpacing); leftDFPtr->SetNumberOfComponentsPerPixel(2); rightDFPtr->SetNumberOfComponentsPerPixel(2); } template void StereorectificationDisplacementFieldSource ::EnlargeOutputRequestedRegion(itk::DataObject * output) { // Call superclass Superclass::EnlargeOutputRequestedRegion(output); // Retrieve the deformation field pointers OutputImageType * leftDFPtr = this->GetLeftDisplacementFieldOutput(); OutputImageType * rightDFPtr = this->GetRightDisplacementFieldOutput(); // Prevent from streaming leftDFPtr->SetRequestedRegionToLargestPossibleRegion(); rightDFPtr->SetRequestedRegionToLargestPossibleRegion(); } template void StereorectificationDisplacementFieldSource ::GenerateData() { // Allocate the output this->AllocateOutputs(); // Setup the DEM handler if needed typename DEMHandler::Pointer demHandler = DEMHandler::Instance(); // Set-up a transform to use the DEMHandler typedef otb::GenericRSTransform<> RSTransform2DType; RSTransform2DType::Pointer leftToGroundTransform = RSTransform2DType::New(); leftToGroundTransform->SetInputKeywordList(m_LeftImage->GetImageKeywordlist()); leftToGroundTransform->InstantiateTransform(); // Retrieve the output pointers OutputImageType * leftDFPtr = this->GetLeftDisplacementFieldOutput(); OutputImageType * rightDFPtr = this->GetRightDisplacementFieldOutput(); // Declare all the TDPoint variables we will need TDPointType currentPoint1, currentPoint2,nextLineStart1,nextLineStart2, startLine1, endLine1, startLine2, endLine2, epiPoint1, epiPoint2; // Then, we retrieve the origin of the left input image double localElevation = otb::DEMHandler::Instance()->GetDefaultHeightAboveEllipsoid(); // Use the mean spacing as before double mean_spacing=0.5*(vcl_abs(m_LeftImage->GetSpacing()[0])+vcl_abs(m_LeftImage->GetSpacing()[1])); // Initialize currentPoint1 = m_OutputOriginInLeftImage; if(m_UseDEM) { RSTransform2DType::InputPointType tmpPoint; tmpPoint[0] = currentPoint1[0]; tmpPoint[1] = currentPoint1[1]; localElevation = demHandler->GetHeightAboveEllipsoid(leftToGroundTransform->TransformPoint(tmpPoint)); } currentPoint1[2] = localElevation; currentPoint2 = m_LeftToRightTransform->TransformPoint(currentPoint1); currentPoint2[2] = currentPoint1[2]; // These are the points were the next stereo-rectified image line starts nextLineStart1 = currentPoint1; nextLineStart2 = currentPoint2; // We define the iterators we will use typedef itk::ImageRegionIteratorWithIndex IteratorType; IteratorType it1(leftDFPtr,leftDFPtr->GetLargestPossibleRegion()); IteratorType it2(rightDFPtr,rightDFPtr->GetLargestPossibleRegion()); it1.GoToBegin(); it2.GoToBegin(); // Reset the mean baseline ratio m_MeanBaselineRatio = 0; // Set-up progress reporting itk::ProgressReporter progress(this, 0, leftDFPtr->GetLargestPossibleRegion().GetNumberOfPixels()); // We loop on the deformation fields while(!it1.IsAtEnd() && !it2.IsAtEnd()) { // 1 - We start by handling the special case where we are at beginning // of a new line if(it1.GetIndex()[0] == 0 || it2.GetIndex()[0] == 0) { // In which case we reset the current points currentPoint1 = nextLineStart1; currentPoint2 = nextLineStart2; } // 2 - Next, we will fill the deformation fields typename OutputImageType::PixelType dFValue1 = it1.Get(); typename OutputImageType::PixelType dFValue2 = it2.Get(); // We must cast iterators position to physical space PointType currentDFPoint1, currentDFPoint2; leftDFPtr->TransformIndexToPhysicalPoint(it1.GetIndex(), currentDFPoint1); rightDFPtr->TransformIndexToPhysicalPoint(it2.GetIndex(), currentDFPoint2); // Now we can compute the shifts dFValue1[0] = currentPoint1[0] - currentDFPoint1[0]; dFValue1[1] = currentPoint1[1] - currentDFPoint1[1]; dFValue2[0] = currentPoint2[0] - currentDFPoint2[0]; dFValue2[1] = currentPoint2[1] - currentDFPoint2[1]; // And set the values it1.Set(dFValue1); it2.Set(dFValue2); // 3 - Next, we will compute epipolar lines direction in both // images double a1; // First, for image 1 // This point is the image of the left input image origin at the // average elevation epiPoint2 = m_LeftToRightTransform->TransformPoint(currentPoint1); // The beginning of the epipolar line in the left image is the image // of epiPoint2 at a lower elevation (using the offset) epiPoint2[2] = localElevation - m_ElevationOffset; startLine1 = m_RightToLeftTransform->TransformPoint(epiPoint2); // The endning of the epipolar line in the left image is the image // of epiPoint2 at a higher elevation (using the offset) epiPoint2[2] = localElevation + m_ElevationOffset; endLine1 = m_RightToLeftTransform->TransformPoint(epiPoint2); // Estimate the local baseline ratio double localBaselineRatio = vcl_sqrt((endLine1[0] - startLine1[0]) * (endLine1[0] - startLine1[0]) + (endLine1[1] - startLine1[1]) * (endLine1[1] - startLine1[1])) / (2 * m_ElevationOffset); m_MeanBaselineRatio+=localBaselineRatio; // Now, we can compute the equation of the epipolar line y = a*x+b // (compute angle in physical space) double alpha1 = 0; if (endLine1[0] == startLine1[0]) { if (endLine1[1] > startLine1[1]) { alpha1 = 0.5*otb::CONST_PI; } else { alpha1 = -0.5*otb::CONST_PI; } } else { a1 = (endLine1[1] - startLine1[1]) / (endLine1[0] - startLine1[0]); if (endLine1[0] > startLine1[0]) { alpha1 = vcl_atan(a1); } else { alpha1 = otb::CONST_PI + vcl_atan(a1); } } // We do the same for image 2 currentPoint2[2] = localElevation; epiPoint1 = m_RightToLeftTransform->TransformPoint(currentPoint2); epiPoint1[2] = localElevation - m_ElevationOffset; startLine2 = m_LeftToRightTransform->TransformPoint(epiPoint1); epiPoint1[2] = localElevation + m_ElevationOffset; endLine2 = m_LeftToRightTransform->TransformPoint(epiPoint1); // 4 - Determine position of next points // We want to move m_Scale pixels away in the epipolar line of the // first image // Take into account height direction //double alpha1 = otb::CONST_PI - vcl_atan(a1); double deltax1 = m_Scale * m_GridStep * mean_spacing * vcl_cos(alpha1); double deltay1 = m_Scale * m_GridStep * mean_spacing * vcl_sin(alpha1); // Now we move currentPoint1 currentPoint1[0]+=deltax1; currentPoint1[1]+=deltay1; if(m_UseDEM) { RSTransform2DType::InputPointType tmpPoint; tmpPoint[0] = currentPoint1[0]; tmpPoint[1] = currentPoint1[1]; localElevation = demHandler->GetHeightAboveEllipsoid(leftToGroundTransform->TransformPoint(tmpPoint)); } currentPoint1[2] = localElevation; // And we compute the equivalent displacement in right image currentPoint2 = m_LeftToRightTransform->TransformPoint(currentPoint1); // 5 - Finally, we have to handle a special case for beginning of // line, since at this position we are able to compute the // position of the beginning of next line if(it1.GetIndex()[0] == 0 || it2.GetIndex()[0] == 0) { // We want to move 1 pixel away in the direction orthogonal to // epipolar line double nextdeltax1 = -m_Scale * mean_spacing * m_GridStep * vcl_sin(alpha1); double nextdeltay1 = m_Scale * mean_spacing * m_GridStep * vcl_cos(alpha1); // We can then update nextLineStart1 nextLineStart1[0] = currentPoint1[0] - deltax1 + nextdeltax1; nextLineStart1[1] = currentPoint1[1] - deltay1 + nextdeltay1; nextLineStart1[2] = localElevation; if(m_UseDEM) { RSTransform2DType::InputPointType tmpPoint; tmpPoint[0] = nextLineStart1[0]; tmpPoint[1] = nextLineStart1[1]; nextLineStart1[2] = demHandler->GetHeightAboveEllipsoid(leftToGroundTransform->TransformPoint(tmpPoint)); } // By construction, nextLineStart2 is always the image of // nextLineStart1 by the left to right transform at the m_AverageElevation nextLineStart2 = m_LeftToRightTransform->TransformPoint(nextLineStart1); } // Last, we move forward ++it1; ++it2; // Update progress progress.CompletedPixel(); } // Compute the mean baseline ratio m_MeanBaselineRatio /= leftDFPtr->GetBufferedRegion().GetNumberOfPixels(); } template void StereorectificationDisplacementFieldSource ::PrintSelf( std::ostream& os, itk::Indent indent ) const { // Call superclass implementation Superclass::PrintSelf(os,indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Registration/Stereo/otb-module.cmake000066400000000000000000000007121301006202600240120ustar00rootroot00000000000000set(DOCUMENTATION "This module contains tools related to stereo-reconstruction. Classes that allow block matching, fine registration, adherence correction, elevation map construction are available.") otb_module(OTBStereo DEPENDS OTBCommon OTBITK OTBImageBase OTBInterpolation OTBOSSIMAdapters OTBObjectList OTBStatistics OTBTransform TEST_DEPENDS OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Registration/Stereo/test/000077500000000000000000000000001301006202600217205ustar00rootroot00000000000000OTB-release-5.8/Modules/Registration/Stereo/test/CMakeLists.txt000066400000000000000000000223311301006202600244610ustar00rootroot00000000000000otb_module_test() set(OTBStereoTests otbStereoTestDriver.cxx otbBijectionCoherencyFilter.cxx otbMulti3DMapToDEMFilter.cxx otbAdhesionCorrectionFilter.cxx otbStereoSensorModelToElevationMapFilter.cxx otbStereorectificationDisplacementFieldSource.cxx ) add_executable(otbStereoTestDriver ${OTBStereoTests}) target_link_libraries(otbStereoTestDriver ${OTBStereo-Test_LIBRARIES}) otb_module_target_label(otbStereoTestDriver) # Tests Declaration otb_add_test(NAME dmTuBijectionCoherencyFilterNew COMMAND otbStereoTestDriver otbBijectionCoherencyFilterNew) otb_add_test(NAME dmTvBijectionCoherencyFilter COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvBijectionCoherencyFilterOutput.tif ${TEMP}/dmTvBijectionCoherencyFilterOutput.tif otbBijectionCoherencyFilter ${INPUTDATA}/sensor_stereo_blockmatching_output.tif ${INPUTDATA}/sensor_stereo_reverse_blockmatching.tif -24 0 0 0 ${TEMP}/dmTvBijectionCoherencyFilterOutput.tif ) otb_add_test(NAME dmTvMulti3DMapToDEMFilterStadiumMinROI COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvMulti3DMapToDEMFilterOutputStadiumMin.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMinROI.tif otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap1.tif ${INPUTDATA}/Stadium3DMapMask1.tif ${INPUTDATA}/Stadium3DMap2.tif ${INPUTDATA}/Stadium3DMapMask2.tif ${INPUTDATA}/Stadium3DMap3.tif ${INPUTDATA}/Stadium3DMapMask3.tif ${INPUTDATA}/Stadium3DMap4.tif ${INPUTDATA}/Stadium3DMapMask4.tif ${INPUTDATA}/Stadium3DMap5.tif ${INPUTDATA}/Stadium3DMapMask5.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMinROI.tif 2.5 0 6 4 ) otb_add_test(NAME dmTvMulti3DMapToDEMFilterStadiumMin COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvMulti3DMapToDEMFilterOutputStadiumMin.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMin.tif otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMin.tif 2.5 0 1 1 ) otb_add_test(NAME dmTuMulti3DMapToDEMFilterStadiumAcc COMMAND otbStereoTestDriver otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTuMulti3DMapToDEMFilterOutputStadiumAcc.tif 2.5 3 1 1 ) otb_add_test(NAME dmTvMulti3DMapToDEMFilterStadiumMeanEPSGWGS84 COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvMulti3DMapToDEMFilterOutputStadiumMean.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanEPSGWGS84.tif otbMulti3DMapToDEMFilterEPSG ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanEPSGWGS84.tif 2.5 2 1 1 0 0 1.43283322941157 43.5843844479961 103 107 0.000031003154124 -0.000022457882103 4326 ) otb_add_test(NAME dmTuMulti3DMapToDEMFilterStadiumMeanEPSGUTM31N COMMAND otbStereoTestDriver otbMulti3DMapToDEMFilterEPSG ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanEPSGUTM31N.tif 2.5 2 1 1 0 0 373473 4826907 103 107 2.5 -2.5 32631 ) otb_add_test(NAME dmTvMulti3DMapToDEMFilterStadiumMean COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvMulti3DMapToDEMFilterOutputStadiumMean.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMean.tif otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMean.tif 2.5 2 1 1 ) otb_add_test(NAME dmTuMulti3DMapToDEMFilterMeanMultiThreadMultiStream COMMAND otbStereoTestDriver otbMulti3DMapToDEMFilter ${BASELINE}/dmTvMultiDisparityMapTo3DFilterOutput.tif LARGEINPUT{PLEIADES/tristereo_sample/mask_1.tif} ${BASELINE}/dmTvMultiDisparityMapTo3DFilterOutput.tif LARGEINPUT{PLEIADES/tristereo_sample/mask_1.tif} ${TEMP}/dmTuMulti3DMapToDEMFilterOutputMeanMultiThreadMultiStream.tif 2.5 2 8 4) otb_add_test(NAME dmTuMulti3DMapTo3DEMFilterNew COMMAND otbStereoTestDriver otbMulti3DMapToDEMFilterNew) otb_add_test(NAME dmTvMulti3DMapToDEMFilterStadiumMeanNoData COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanNoData.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanNoData.tif otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanNoData.tif 0.7 2 1 1 ) otb_add_test(NAME dmTuMulti3DMapToDEMFilterAccMultiThreadMultiStream COMMAND otbStereoTestDriver otbMulti3DMapToDEMFilter ${BASELINE}/dmTvMultiDisparityMapTo3DFilterOutput.tif LARGEINPUT{PLEIADES/tristereo_sample/mask_1.tif} ${BASELINE}/dmTvMultiDisparityMapTo3DFilterOutput.tif LARGEINPUT{PLEIADES/tristereo_sample/mask_1.tif} ${TEMP}/dmTuMulti3DMapToDEMFilterOutputAccMultiThreadMultiStream.tif 2.5 3 8 4 ) otb_add_test(NAME dmTvMulti3DMapToDEMFilterStadiumMax COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvMulti3DMapToDEMFilterOutputStadiumMax.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMax.tif otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMax.tif 2.5 1 1 1 ) otb_add_test(NAME dmTuMulti3DMapToDEMFilterStadiumMeanLarge COMMAND otbStereoTestDriver otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTuMulti3DMapToDEMFilterOutputStadiumMeanLarge.tif 10 2 8 4 ) otb_add_test(NAME dmTvMulti3DMapToDEMFilterStadiumMeanMultiThreadMultiStream COMMAND otbStereoTestDriver --compare-image ${EPSILON_6} ${BASELINE}/dmTvMulti3DMapToDEMFilterOutputStadiumMean.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanMultiThreadMultiStream.tif otbMulti3DMapToDEMFilter ${INPUTDATA}/Stadium3DMap.tif ${INPUTDATA}/Stadium3DMapMask.tif ${INPUTDATA}/Stadium3DMapBis.tif ${INPUTDATA}/Stadium3DMapMask.tif ${TEMP}/dmTvMulti3DMapToDEMFilterOutputStadiumMeanMultiThreadMultiStream.tif 2.5 2 6 4 ) otb_add_test(NAME dmTvAdhesionCorrectionFilter COMMAND otbStereoTestDriver --compare-n-images ${EPSILON_4} 3 ${BASELINE}/dmTuAdhesionCorrectionMethod_Corrected.tif ${TEMP}/dmTuAdhesionCorrectionMethod_Corrected.tif ${BASELINE}/dmTuAdhesionCorrectionMethod_CorrectedMask.png ${TEMP}/dmTuAdhesionCorrectionMethod_CorrectedMask.png ${BASELINE}/dmTuAdhesionCorrectionMethod_RiskEdges.tif ${TEMP}/dmTuAdhesionCorrectionMethod_RiskEdges.tif otbAdhesionCorrectionFilter ${INPUTDATA}/AdhesionCorrectionFilter_MedianInput ${INPUTDATA}/AdhesionCorrectionFilter_MedianMaskInput.png ${INPUTDATA}/AdhesionCorrectionFilter_SubpixelDisparityInput ${INPUTDATA}/AdhesionCorrectionFilter_SubpixelMaskInput.png ${INPUTDATA}/AdhesionCorrectionFilter_CannyRefInput ${INPUTDATA}/AdhesionCorrectionFilter_CannyMedianInput 4 0.25 ${TEMP}/dmTuAdhesionCorrectionMethod_Corrected.tif ${TEMP}/dmTuAdhesionCorrectionMethod_CorrectedMask.png ${TEMP}/dmTuAdhesionCorrectionMethod_RiskEdges.tif ) otb_add_test(NAME dmTuAdhesionCorrectionFilterNew COMMAND otbStereoTestDriver otbAdhesionCorrectionFilterNew) otb_add_test(NAME dmTuStereoSensorModelToElevationFilterNew COMMAND otbStereoTestDriver otbStereoSensorModelToElevationMapFilterNew) #otb_add_test(NAME dmTvStereoSensorModelToElevationFilter COMMAND otbStereoTestDriver #--compare-image ${EPSILON_10} #${BASELINE}/feTvStereoSensorModelToElevationFilterOutput.tif #${TEMP}/feTvStereoSensorModelToElevationFilterOutput.tif #otbStereoSensorModelToElevationMapFilter #${EXAMPLEDATA}/sensor_stereo_left.tif #${EXAMPLEDATA}/sensor_stereo_right.tif #${TEMP}/feTvStereoSensorModelToElevationFilterOutput.tif #${INPUTDATA}/DEM/srtm_directory/ #${INPUTDATA}/DEM/egm96.grd #-20 #20 #1 #3 #) otb_add_test(NAME dmTvStereorectificationDisplacementFieldSource COMMAND otbStereoTestDriver --compare-n-images ${EPSILON_10} 2 ${BASELINE}/feTvStereorectificationDeformationFieldSourceOutput1.tif ${TEMP}/feTvStereorectificationDisplacementFieldSourceOutput1.tif ${BASELINE}/feTvStereorectificationDeformationFieldSourceOutput2.tif ${TEMP}/feTvStereorectificationDisplacementFieldSourceOutput2.tif otbStereorectificationDisplacementFieldSource ${EXAMPLEDATA}/sensor_stereo_left.tif ${EXAMPLEDATA}/sensor_stereo_right.tif ${TEMP}/feTvStereorectificationDisplacementFieldSourceOutput1.tif ${TEMP}/feTvStereorectificationDisplacementFieldSourceOutput2.tif 300 0.5 5 ) otb_add_test(NAME dmTuStereorectificationDisplacementFieldSourceNew COMMAND otbStereoTestDriver otbStereorectificationDisplacementFieldSourceNew) OTB-release-5.8/Modules/Registration/Stereo/test/otbAdhesionCorrectionFilter.cxx000066400000000000000000000115741301006202600301110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbAdhesionCorrectionFilter.h" #include "otbImageFileWriter.h" #include "otbStandardWriterWatcher.h" #include "otbImageFileReader.h" const unsigned int Dimension = 2; typedef double PixelType; typedef otb::Image ImageType; typedef unsigned char MaskPixelType; typedef otb::Image MaskImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader MaskReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter MaskWriterType; typedef otb::AdhesionCorrectionFilter AdhesionCorrectionFilterType; int otbAdhesionCorrectionFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation AdhesionCorrectionFilterType::Pointer filter = AdhesionCorrectionFilterType::New(); return EXIT_SUCCESS; } int otbAdhesionCorrectionFilter(int argc, char* argv[]) { if (argc != 12) { std::cerr << "Usage: " << argv[0]; std::cerr << "MedianDisparityFileName MedianMaskFileName SubpixelDisparityFileName SubpixelMaskFileName CannyRefFileName CannyMedianFileName Radius Tolerance"; std::cerr << " CorrectedDisparityFileName CorrectedMaskFileName RiskEdgesFileName"; return EXIT_FAILURE; } const char* medianDisparityFileName = argv[1]; const char* medianMaskFileName = argv[2]; const char* subpixelDisparityFileName = argv[3]; const char* subpixelMaskFileName = argv[4]; const char* cannyRefFileName = argv[5]; const char* cannyMedianFileName = argv[6]; const unsigned int radius = atoi(argv[7]); const float tolerance = atof(argv[8]); const char* correctedDisparityFileName = argv[9]; const char* correctedMaskFileName = argv[10]; const char* riskEdgesFileName = argv[11]; typedef otb::ImageFileReader DisparityMapReaderType; DisparityMapReaderType::Pointer mediandisparityreader = DisparityMapReaderType::New(); mediandisparityreader->SetFileName(medianDisparityFileName); MaskReaderType::Pointer medianmaskreader = MaskReaderType::New(); medianmaskreader->SetFileName(medianMaskFileName); DisparityMapReaderType::Pointer subpixeldisparityreader = DisparityMapReaderType::New(); subpixeldisparityreader->SetFileName(subpixelDisparityFileName); MaskReaderType::Pointer subpixelmaskreader = MaskReaderType::New(); subpixelmaskreader->SetFileName(subpixelMaskFileName); /// Edge images are read from Canny filtering performed with MARC2 ReaderType::Pointer cannyrefReader = ReaderType::New(); cannyrefReader->SetFileName(cannyRefFileName); ReaderType::Pointer cannymedianReader = ReaderType::New(); cannymedianReader->SetFileName(cannyMedianFileName); AdhesionCorrectionFilterType::Pointer adhesioncorrectionfilter = AdhesionCorrectionFilterType::New(); adhesioncorrectionfilter->SetInput(cannyrefReader->GetOutput()); adhesioncorrectionfilter->SetMedianDisparityInput(mediandisparityreader->GetOutput()); adhesioncorrectionfilter->SetMedianMaskInput(medianmaskreader->GetOutput()); adhesioncorrectionfilter->SetEdgesDisparityInput(cannymedianReader->GetOutput()); adhesioncorrectionfilter->SetSubPixelMaskInput(subpixelmaskreader->GetOutput()); adhesioncorrectionfilter->SetRadius(radius); adhesioncorrectionfilter->SetTolerance(tolerance); adhesioncorrectionfilter->SetDiscontinuityThreshold(10); adhesioncorrectionfilter->SetDiscontinuityHighThreshold(30); adhesioncorrectionfilter->SetMaxEdgeGap(10); adhesioncorrectionfilter->SetEdgeThreshold(30); WriterType::Pointer dfWriter = WriterType::New(); dfWriter->SetFileName(correctedDisparityFileName); dfWriter->SetInput(adhesioncorrectionfilter->GetOutput()); dfWriter->Update(); MaskWriterType::Pointer mask_writer = MaskWriterType::New(); mask_writer->SetInput(adhesioncorrectionfilter->GetOutputMask()); mask_writer->SetFileName(correctedMaskFileName); mask_writer->Update(); WriterType::Pointer riskedgesWriter = WriterType::New(); riskedgesWriter->SetFileName(riskEdgesFileName); riskedgesWriter->SetInput(adhesioncorrectionfilter->GetOutputRiskEdges()); riskedgesWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/Stereo/test/otbBijectionCoherencyFilter.cxx000066400000000000000000000060271301006202600300720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbBijectionCoherencyFilter.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToImageListFilter.h" typedef otb::Image FloatImageType; typedef otb::VectorImage FloatVectorImageType; typedef otb::BijectionCoherencyFilter BijectionFilterType; int otbBijectionCoherencyFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation BijectionFilterType::Pointer bijectFilter = BijectionFilterType::New(); return EXIT_SUCCESS; } int otbBijectionCoherencyFilter(int argc, char* argv[]) { typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileWriter WriterScalarType; typedef otb::ImageList ImageListType; typedef otb::VectorImageToImageListFilter VectorToListFilterType; if (argc < 8) { std::cout << "Usage: "<SetFileName(argv[1]); ReaderVectorType::Pointer r2lReader = ReaderVectorType::New(); r2lReader->SetFileName(argv[2]); VectorToListFilterType::Pointer vectorToListFilter1 = VectorToListFilterType::New(); vectorToListFilter1->SetInput(l2rReader->GetOutput()); vectorToListFilter1->UpdateOutputInformation(); VectorToListFilterType::Pointer vectorToListFilter2 = VectorToListFilterType::New(); vectorToListFilter2->SetInput(r2lReader->GetOutput()); vectorToListFilter2->UpdateOutputInformation(); BijectionFilterType::Pointer bijectFilter = BijectionFilterType::New(); bijectFilter->SetDirectHorizontalDisparityMapInput(vectorToListFilter1->GetOutput()->GetNthElement(0)); bijectFilter->SetReverseHorizontalDisparityMapInput(vectorToListFilter2->GetOutput()->GetNthElement(0)); bijectFilter->SetMinHDisp(atoi(argv[3])); bijectFilter->SetMaxHDisp(atoi(argv[4])); bijectFilter->SetMinVDisp(atoi(argv[5])); bijectFilter->SetMaxVDisp(atoi(argv[6])); WriterScalarType::Pointer writer = WriterScalarType::New(); writer->SetInput(bijectFilter->GetOutput()); writer->SetFileName(argv[7]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/Stereo/test/otbMulti3DMapToDEMFilter.cxx000066400000000000000000000427761301006202600271070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMulti3DMapToDEMFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorImageToImageListFilter.h" #include #include "otbGeoInformationConversion.h" typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef otb::Multi3DMapToDEMFilter Multi3DFilterType; int otbMulti3DMapToDEMFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation Multi3DFilterType::Pointer multiFilter = Multi3DFilterType::New(); return EXIT_SUCCESS; } int otbMulti3DMapToDEMFilterEPSG(int argc, char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileWriter WriterType; typedef otb::ObjectList MaskReaderListType; typedef otb::ObjectList MapReaderListType; if ((argc-15)%2 !=0) { std::cout << "Usage: "< " << std::endl; return EXIT_FAILURE; } unsigned int mapSize=(argc-15)/2; MapReaderListType::Pointer mapReaderList=MapReaderListType::New(); MaskReaderListType::Pointer maskReaderList=MaskReaderListType::New(); for(unsigned int i=0; i<(mapSize); i++) { mapReaderList->PushBack(ReaderVectorType::New()); maskReaderList->PushBack(ReaderType::New()); } // unsigned int i=1; unsigned int index=0; for(unsigned int i=1; i<(2*mapSize+1); i=i+2) { mapReaderList->GetNthElement(index)->SetFileName(argv[i]); mapReaderList->GetNthElement(index)->UpdateOutputInformation(); maskReaderList->GetNthElement(index)->SetFileName(argv[i+1]); maskReaderList->GetNthElement(index)->UpdateOutputInformation(); index++; } float gridStep=atof(argv[argc-13]); std::cout<<"gridStep "<SetNumberOf3DMaps(mapSize); multiFilter->SetDEMGridStep(gridStep); multiFilter->SetCellFusionMode(fusionMode); for(unsigned int i=0; iSet3DMapInput(i,mapReaderList->GetNthElement(i)->GetOutput()); // multiFilter->SetMapKeywordList(i,mapReaderList->GetNthElement(i)->GetOutput()->GetImageKeywordlist()); multiFilter->SetMaskInput(i,maskReaderList->GetNthElement(i)->GetOutput()); } //set output parameters // multiFilter->SetOutputParametersFrom3DMap(); VectorImageType::IndexType start; start[0] = atoi(argv[argc-9]); start[1] = atoi(argv[argc-8]); multiFilter->SetOutputStartIndex(start); VectorImageType::SizeType size; size[0] = atoi(argv[argc-5]); // X size size[1] = atoi(argv[argc-4]); //Y size multiFilter->SetOutputSize(size); VectorImageType::SpacingType spacing; spacing[0] = atof(argv[argc-3]); spacing[1] = atof(argv[argc-2]); multiFilter->SetOutputSpacing(spacing); VectorImageType::PointType origin; origin[0] = strtod(argv[argc-7], ITK_NULLPTR); origin[1] = strtod(argv[argc-6], ITK_NULLPTR); multiFilter->SetOutputOrigin(origin); std::string projectionRef=otb::GeoInformationConversion::ToWKT( atoi(argv[argc-1])); std::cout<<"projection Reference :"<SetProjectionRef(projectionRef); WriterType::Pointer writer = WriterType::New(); multiFilter->SetNumberOfThreads(atoi(argv[argc-11])); //multiFilter->Update(); writer->SetInput(multiFilter->GetOutput()); writer->SetFileName(argv[argc-14]); writer->SetNumberOfDivisionsStrippedStreaming(atoi(argv[argc-10])); writer->Update(); return EXIT_SUCCESS; /* if (argc != 12) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::UtmInverseProjection UtmMapProjectionType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; //Allocate pointer ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); OrthoRectifFilterType::Pointer orthoRectifFilter = OrthoRectifFilterType::New(); UtmMapProjectionType::Pointer utmMapProjection = UtmMapProjectionType::New(); // Set parameters ... reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); reader->GenerateOutputInformation(); std::cout << reader->GetOutput() << std::endl; orthoRectifFilter->SetInput(reader->GetOutput()); VectorImageType::IndexType start; start[0] = 0; start[1] = 0; orthoRectifFilter->SetOutputStartIndex(start); VectorImageType::SizeType size; size[0] = atoi(argv[5]); // X size size[1] = atoi(argv[6]); //Y size orthoRectifFilter->SetOutputSize(size); VectorImageType::SpacingType spacing; spacing[0] = atof(argv[7]); spacing[1] = atof(argv[8]); orthoRectifFilter->SetOutputSpacing(spacing); VectorImageType::PointType origin; origin[0] = strtod(argv[3], NULL); //Origin easting origin[1] = strtod(argv[4], NULL); //Origin northing orthoRectifFilter->SetOutputOrigin(origin); utmMapProjection->SetZone(atoi(argv[9])); utmMapProjection->SetHemisphere(argv[10][0]); orthoRectifFilter->SetMapProjection(utmMapProjection); // Deformation Field spacing VectorImageType::SpacingType gridSpacing; gridSpacing[0] = atof(argv[11]); gridSpacing[1] = -atof(argv[11]); orthoRectifFilter->SetDeformationFieldSpacing(gridSpacing); VectorImageType::PixelType no_data(reader->GetOutput()->GetNumberOfComponentsPerPixel()); no_data.Fill(0); orthoRectifFilter->SetEdgePaddingValue(no_data); writer->SetInput(orthoRectifFilter->GetOutput()); writer->SetNumberOfDivisionsTiledStreaming(4); writer->Update(); return EXIT_SUCCESS; */ /* if (argc != 12) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::UtmInverseProjection UtmMapProjectionType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; //Allocate pointer ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); OrthoRectifFilterType::Pointer orthoRectifFilter = OrthoRectifFilterType::New(); UtmMapProjectionType::Pointer utmMapProjection = UtmMapProjectionType::New(); // Set parameters ... reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); reader->GenerateOutputInformation(); std::cout << reader->GetOutput() << std::endl; orthoRectifFilter->SetInput(reader->GetOutput()); VectorImageType::IndexType start; start[0] = 0; start[1] = 0; orthoRectifFilter->SetOutputStartIndex(start); VectorImageType::SizeType size; size[0] = atoi(argv[5]); // X size size[1] = atoi(argv[6]); //Y size orthoRectifFilter->SetOutputSize(size); VectorImageType::SpacingType spacing; spacing[0] = atof(argv[7]); spacing[1] = atof(argv[8]); orthoRectifFilter->SetOutputSpacing(spacing); VectorImageType::PointType origin; origin[0] = strtod(argv[3], NULL); //Origin easting origin[1] = strtod(argv[4], NULL); //Origin northing orthoRectifFilter->SetOutputOrigin(origin); utmMapProjection->SetZone(atoi(argv[9])); utmMapProjection->SetHemisphere(argv[10][0]); orthoRectifFilter->SetMapProjection(utmMapProjection); // Deformation Field spacing VectorImageType::SpacingType gridSpacing; gridSpacing[0] = atof(argv[11]); gridSpacing[1] = -atof(argv[11]); orthoRectifFilter->SetDeformationFieldSpacing(gridSpacing); VectorImageType::PixelType no_data(reader->GetOutput()->GetNumberOfComponentsPerPixel()); no_data.Fill(0); orthoRectifFilter->SetEdgePaddingValue(no_data); writer->SetInput(orthoRectifFilter->GetOutput()); writer->SetNumberOfDivisionsTiledStreaming(4); writer->Update(); return EXIT_SUCCESS; */ } int otbMulti3DMapToDEMFilterManual(int argc, char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileWriter WriterType; typedef otb::ObjectList MaskReaderListType; typedef otb::ObjectList MapReaderListType; if ((argc-14)%2 !=0) { std::cout << "Usage: "< " << std::endl; return EXIT_FAILURE; } unsigned int mapSize=(argc-14)/2; MapReaderListType::Pointer mapReaderList=MapReaderListType::New(); MaskReaderListType::Pointer maskReaderList=MaskReaderListType::New(); for(unsigned int i=0; i<(mapSize); i++) { mapReaderList->PushBack(ReaderVectorType::New()); maskReaderList->PushBack(ReaderType::New()); } // unsigned int i=1; unsigned int index=0; for(unsigned int i=1; i<(2*mapSize+1); i=i+2) { mapReaderList->GetNthElement(index)->SetFileName(argv[i]); mapReaderList->GetNthElement(index)->UpdateOutputInformation(); maskReaderList->GetNthElement(index)->SetFileName(argv[i+1]); maskReaderList->GetNthElement(index)->UpdateOutputInformation(); index++; } float gridStep=atof(argv[argc-12]); std::cout<<"gridStep "<SetNumberOf3DMaps(mapSize); multiFilter->SetDEMGridStep(gridStep); multiFilter->SetCellFusionMode(fusionMode); for(unsigned int i=0; iSet3DMapInput(i,mapReaderList->GetNthElement(i)->GetOutput()); // multiFilter->SetMapKeywordList(i,mapReaderList->GetNthElement(i)->GetOutput()->GetImageKeywordlist()); multiFilter->SetMaskInput(i,maskReaderList->GetNthElement(i)->GetOutput()); } //set output parameters //multiFilter->SetOutputParametersFrom3DMap(); VectorImageType::IndexType start; start[0] = atoi(argv[argc-7]); start[1] = atoi(argv[argc-8]); multiFilter->SetOutputStartIndex(start); VectorImageType::SizeType size; size[0] = atoi(argv[argc-4]); // X size size[1] = atoi(argv[argc-3]); //Y size multiFilter->SetOutputSize(size); VectorImageType::SpacingType spacing; spacing[0] = atof(argv[argc-2]); spacing[1] = atof(argv[argc-1]); multiFilter->SetOutputSpacing(spacing); VectorImageType::PointType origin; origin[0] = strtod(argv[argc-6], ITK_NULLPTR); origin[1] = strtod(argv[argc-5], ITK_NULLPTR); multiFilter->SetOutputOrigin(origin); WriterType::Pointer writer = WriterType::New(); multiFilter->SetNumberOfThreads(atoi(argv[argc-10])); //multiFilter->Update(); writer->SetInput(multiFilter->GetOutput()); writer->SetFileName(argv[argc-13]); writer->SetNumberOfDivisionsStrippedStreaming(atoi(argv[argc-15])); writer->Update(); return EXIT_SUCCESS; /* if (argc != 12) { std::cout << argv[0] << " " << std::endl; return EXIT_FAILURE; } typedef otb::VectorImage VectorImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::UtmInverseProjection UtmMapProjectionType; typedef otb::OrthoRectificationFilter OrthoRectifFilterType; //Allocate pointer ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); OrthoRectifFilterType::Pointer orthoRectifFilter = OrthoRectifFilterType::New(); UtmMapProjectionType::Pointer utmMapProjection = UtmMapProjectionType::New(); // Set parameters ... reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); reader->GenerateOutputInformation(); std::cout << reader->GetOutput() << std::endl; orthoRectifFilter->SetInput(reader->GetOutput()); VectorImageType::IndexType start; start[0] = 0; start[1] = 0; orthoRectifFilter->SetOutputStartIndex(start); VectorImageType::SizeType size; size[0] = atoi(argv[5]); // X size size[1] = atoi(argv[6]); //Y size orthoRectifFilter->SetOutputSize(size); VectorImageType::SpacingType spacing; spacing[0] = atof(argv[7]); spacing[1] = atof(argv[8]); orthoRectifFilter->SetOutputSpacing(spacing); VectorImageType::PointType origin; origin[0] = strtod(argv[3], NULL); //Origin easting origin[1] = strtod(argv[4], NULL); //Origin northing orthoRectifFilter->SetOutputOrigin(origin); utmMapProjection->SetZone(atoi(argv[9])); utmMapProjection->SetHemisphere(argv[10][0]); orthoRectifFilter->SetMapProjection(utmMapProjection); // Deformation Field spacing VectorImageType::SpacingType gridSpacing; gridSpacing[0] = atof(argv[11]); gridSpacing[1] = -atof(argv[11]); orthoRectifFilter->SetDeformationFieldSpacing(gridSpacing); VectorImageType::PixelType no_data(reader->GetOutput()->GetNumberOfComponentsPerPixel()); no_data.Fill(0); orthoRectifFilter->SetEdgePaddingValue(no_data); writer->SetInput(orthoRectifFilter->GetOutput()); writer->SetNumberOfDivisionsTiledStreaming(4); writer->Update(); return EXIT_SUCCESS; */ } int otbMulti3DMapToDEMFilter(int argc, char* argv[]) { typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader ReaderVectorType; typedef otb::ImageFileWriter WriterType; typedef otb::ObjectList MaskReaderListType; typedef otb::ObjectList MapReaderListType; if ((argc-6)%2 !=0) { std::cout << "Usage: "<PushBack(ReaderVectorType::New()); maskReaderList->PushBack(ReaderType::New()); } // unsigned int i=1; unsigned int index=0; for(unsigned int i=1; i<(2*mapSize+1); i=i+2) { mapReaderList->GetNthElement(index)->SetFileName(argv[i]); mapReaderList->GetNthElement(index)->UpdateOutputInformation(); maskReaderList->GetNthElement(index)->SetFileName(argv[i+1]); maskReaderList->GetNthElement(index)->UpdateOutputInformation(); index++; } float gridStep=atof(argv[argc-4]); std::cout<<"gridStep "<SetNumberOf3DMaps(mapSize); multiFilter->SetDEMGridStep(gridStep); multiFilter->SetCellFusionMode(fusionMode); for(unsigned int i=0; iSet3DMapInput(i,mapReaderList->GetNthElement(i)->GetOutput()); // multiFilter->SetMapKeywordList(i,mapReaderList->GetNthElement(i)->GetOutput()->GetImageKeywordlist()); multiFilter->SetMaskInput(i,maskReaderList->GetNthElement(i)->GetOutput()); } multiFilter->SetOutputParametersFrom3DMap(); WriterType::Pointer writer = WriterType::New(); multiFilter->SetNumberOfThreads(atoi(argv[argc-2])); //multiFilter->Update(); writer->SetInput(multiFilter->GetOutput()); writer->SetFileName(argv[argc-5]); writer->SetNumberOfDivisionsStrippedStreaming(atoi(argv[argc-1])); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/Stereo/test/otbStereoSensorModelToElevationMapFilter.cxx000066400000000000000000000064311301006202600325470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbImage.h" #include "otbStereoSensorModelToElevationMapFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStandardFilterWatcher.h" #include "otbImageList.h" #include "otbImageListToVectorImageFilter.h" #include "otbVectorImage.h" #include "itkUnaryFunctorImageFilter.h" #include "itkDiscreteGaussianImageFilter.h" #include "itkMedianImageFilter.h" typedef otb::Image ImageType; typedef otb::Image HeightImageType; typedef otb::ImageFileReader ReaderType; typedef itk::DiscreteGaussianImageFilter GaussianFilterType; typedef otb::ImageFileWriter SingleWriterType; typedef otb::StereoSensorModelToElevationFilter StereoFilterType; typedef otb::VectorImage VectorImageType; typedef otb::ImageList ImageListType; typedef otb::ImageListToVectorImageFilter IL2VIFilterType; typedef itk::MedianImageFilter MedianFilterType; typedef otb::ImageFileWriter WriterType; int otbStereoSensorModelToElevationMapFilterNew( int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation StereoFilterType::Pointer stereoFilter = StereoFilterType::New(); return EXIT_SUCCESS; } int otbStereoSensorModelToElevationMapFilter( int itkNotUsed(argc), char * argv[] ) { ReaderType::Pointer masterReader = ReaderType::New(); masterReader->SetFileName(argv[1]); ReaderType::Pointer slaveReader = ReaderType::New(); slaveReader->SetFileName(argv[2]); GaussianFilterType::ArrayType sigma; sigma.Fill(0.5*atof(argv[8])); GaussianFilterType::Pointer gaussian1 = GaussianFilterType::New(); gaussian1->SetInput(masterReader->GetOutput()); gaussian1->SetVariance(sigma); GaussianFilterType::Pointer gaussian2 = GaussianFilterType::New(); gaussian2->SetInput(slaveReader->GetOutput()); gaussian2->SetVariance(sigma); otb::DEMHandler::Instance()->OpenDEMDirectory(argv[4]); otb::DEMHandler::Instance()->OpenGeoidFile(argv[5]); StereoFilterType::Pointer stereoFilter = StereoFilterType::New(); stereoFilter->SetMasterInput(gaussian1->GetOutput()); stereoFilter->SetSlaveInput(gaussian2->GetOutput()); stereoFilter->SetLowerElevation(atof(argv[6])); stereoFilter->SetHigherElevation(atof(argv[7])); stereoFilter->SetElevationStep(atof(argv[8])); stereoFilter->SetRadius(atoi(argv[9])); otb::StandardFilterWatcher watcher(stereoFilter,"Performing stereo-matching"); WriterType::Pointer writer = WriterType::New(); writer->SetInput(stereoFilter->GetOutput()); writer->SetFileName(argv[3]); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Registration/Stereo/test/otbStereoTestDriver.cxx000066400000000000000000000012451301006202600264300ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbBijectionCoherencyFilterNew); REGISTER_TEST(otbBijectionCoherencyFilter); REGISTER_TEST(otbMulti3DMapToDEMFilterNew); REGISTER_TEST(otbMulti3DMapToDEMFilterEPSG); REGISTER_TEST(otbMulti3DMapToDEMFilterManual); REGISTER_TEST(otbMulti3DMapToDEMFilter); REGISTER_TEST(otbAdhesionCorrectionFilterNew); REGISTER_TEST(otbAdhesionCorrectionFilter); REGISTER_TEST(otbStereoSensorModelToElevationMapFilterNew); REGISTER_TEST(otbStereoSensorModelToElevationMapFilter); REGISTER_TEST(otbStereorectificationDisplacementFieldSource); REGISTER_TEST(otbStereorectificationDisplacementFieldSourceNew); } OTB-release-5.8/Modules/Registration/Stereo/test/otbStereorectificationDisplacementFieldSource.cxx000066400000000000000000000051541301006202600336410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbStereorectificationDisplacementFieldSource.h" typedef itk::Vector DisplacementType; typedef otb::Image DisplacementFieldType; typedef otb::Image ImageType; typedef otb::StereorectificationDisplacementFieldSource DisplacementFieldSourceType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; int otbStereorectificationDisplacementFieldSourceNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { // Instantiation DisplacementFieldSourceType::Pointer dfSource = DisplacementFieldSourceType::New(); return EXIT_SUCCESS; } int otbStereorectificationDisplacementFieldSource(int itkNotUsed(argc), char * argv[]) { char * infname1 = argv[1]; char * infname2 = argv[2]; char * outfname1 = argv[3]; char * outfname2 = argv[4]; double avgElev = atof(argv[5]); double scale = atof(argv[6]); double gridStep = atoi(argv[7]); // Instantiation DisplacementFieldSourceType::Pointer dfSource = DisplacementFieldSourceType::New(); ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(infname1); ReaderType::Pointer reader2 = ReaderType::New(); reader2->SetFileName(infname2); dfSource->SetLeftImage(reader1->GetOutput()); dfSource->SetRightImage(reader2->GetOutput()); dfSource->SetGridStep(gridStep); dfSource->SetScale(scale); otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(avgElev); WriterType::Pointer writer1 = WriterType::New(); writer1->SetInput(dfSource->GetLeftDisplacementFieldOutput()); writer1->SetFileName(outfname1); writer1->Update(); WriterType::Pointer writer2 = WriterType::New(); writer2->SetInput(dfSource->GetRightDisplacementFieldOutput()); writer2->SetFileName(outfname2); writer2->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Remote/000077500000000000000000000000001301006202600162615ustar00rootroot00000000000000OTB-release-5.8/Modules/Remote/CMakeLists.txt000066400000000000000000000002561301006202600210240ustar00rootroot00000000000000# Functions to fetch remote modules. include(OTBModuleRemote) file(GLOB remotes "*.remote.cmake") foreach(remote_module ${remotes}) include(${remote_module}) endforeach() OTB-release-5.8/Modules/Remote/Mosaic.remote.cmake000066400000000000000000000005621301006202600217730ustar00rootroot00000000000000#Contact: Rémi Cresson otb_fetch_module(Mosaic "This module provides one application dedicated to images mosaicking A more detailed description can be found on the project website: https://github.com/remicres/otb-mosaic " GIT_REPOSITORY https://github.com/remicres/otb-mosaic.git GIT_TAG 9a8cdd63ed3bba500bb4ea3867abc38bce8be562 ) OTB-release-5.8/Modules/Remote/SertitObject.remote.cmake000066400000000000000000000027071301006202600231640ustar00rootroot00000000000000#Contact: arnaud.durand@sertit.u-strasbg.fr #SERTIT - University of Strasbourg http://sertit.u-strasbg.fr #Known issue with MSVC - https://github.com/sertit/SertitObject/issues/2 otb_fetch_module(SertitObject "This module provides 2 applications dedicated to object-oriented image analysis. Aggregate application: The aim of this application is to merge the result of a segmentation with a pixel-based image classification in order to produce an object-oriented image classification. The input segmentation is a labeled image, typically the result provided by the OTB application LSMSSegmentation. The output is a vector dataset containing objects and the corresponding class in the attribute table. Connected regions belonging to the same class are merged. This application could be used at the last step of the LSMS pipeline in replacement of the application LSMSVectorization. ObjectsRadiometricStatistics application: This application computes radiometric and shape attributes on a vector dataset, using an image. The results are stored in the attribute table. Shape attributes are : number of pixels, flatness, roundness, elongation, perimeter. Radiometric attributes are for each band of the input image : mean, standard-deviation, median, variance, kurtosis, skewness. The result could be use to perform further object-oriented image analysis. " GIT_REPOSITORY https://github.com/sertit/SertitObject.git GIT_TAG d228e0d65de58496e2410ae8944e715b3970760a ) OTB-release-5.8/Modules/Remote/otb-bv.remote.cmake000066400000000000000000000005061301006202600217470ustar00rootroot00000000000000#Contact: Jordi Inglada otb_fetch_module(OTBBioVars "Biophysical variable estimation from remote sensing imagery. A more detailed description can be found on the project website: http://tully.ups-tlse.fr/jordi/otb-bv " GIT_REPOSITORY http://tully.ups-tlse.fr/jordi/otb-bv.git GIT_TAG master ) OTB-release-5.8/Modules/Remote/otbFFSforGMM.remote.cmake000066400000000000000000000006071301006202600227530ustar00rootroot00000000000000#Contact: Adrien Lagrange otb_fetch_module(OTBFastFeaturesSelection "This module implements a method to perform a fast forward feature selection using a Gaussian Mixture Model. A more detailed description can be found on the project website: https://github.com/Laadr/otbFFSforGMM " GIT_REPOSITORY https://github.com/Laadr/otbFFSforGMM.git GIT_TAG master ) OTB-release-5.8/Modules/Remote/otbGRM.remote.cmake000066400000000000000000000014671301006202600217170ustar00rootroot00000000000000#Contact: Pierre Lassalle otb_fetch_module(otbGRM "This module provides the GRM OTB application to perform multiscale region-merging segmentation on satellite images. Three local homogeneity criteria are available: the Baatz & Schäpe criterion, the Full Lambda Schedule criterion and the simple Euclidean Distance criterion. This application uses the GRM (Generic Region Merging) library which allows quickly adding a new local homogeneity criterion. Look at the template header file: GRMSegmenterTemplate.h to see which format you must respect to add a new criterion. A more detailed description can be found on the project website: http://tully.ups-tlse.fr/lassallep/grm " GIT_REPOSITORY http://tully.ups-tlse.fr/lassallep/grm.git GIT_TAG a08d2309bc8d4f4ceaf1dba8bda33aa1e21fc4aa ) OTB-release-5.8/Modules/Remote/phenotb.remote.cmake000066400000000000000000000007231301006202600222160ustar00rootroot00000000000000#Contact: Jordi Inglada otb_fetch_module(OTBPhenology "This module implements several algorithms allowing to extract phenological information from time profiles. These time profiles should represent vegetation status as for instance NDVI, LAI, etc. A more detailed description can be found on the project website: http://tully.ups-tlse.fr/jordi/phenotb " GIT_REPOSITORY http://tully.ups-tlse.fr/jordi/phenotb.git GIT_TAG master ) OTB-release-5.8/Modules/Remote/temporal-gapfilling.remote.cmake000066400000000000000000000006641301006202600245200ustar00rootroot00000000000000#Contact: Jordi Inglada otb_fetch_module(OTBTemporalGapFilling "Gapfilling for time series replaces invalid pixels (as designated by a mask) by an interpolation using the valid dates of the series. A more detailed description can be found on the project website: http://tully.ups-tlse.fr/jordi/temporalgapfilling " GIT_REPOSITORY http://tully.ups-tlse.fr/jordi/temporalgapfilling.git GIT_TAG master ) OTB-release-5.8/Modules/Segmentation/000077500000000000000000000000001301006202600174635ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/CCOBIA/000077500000000000000000000000001301006202600204035ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/CCOBIA/CMakeLists.txt000066400000000000000000000000451301006202600231420ustar00rootroot00000000000000project(OTBCCOBIA) otb_module_impl() OTB-release-5.8/Modules/Segmentation/CCOBIA/include/000077500000000000000000000000001301006202600220265ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/CCOBIA/include/otbConnectedComponentMuParserFunctor.h000066400000000000000000000126151301006202600315160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConnectedComponentMuParserFunctor_h #define otbConnectedComponentMuParserFunctor_h #include "otbParser.h" #include "otbMacro.h" #include #include #include namespace otb { /** \class ConnectedComponentMuParserFunctor * \brief functor used as input to itk connected component segmentation module. * * This functor is based on the mathematical parser library muParser. * The built in functions and operators list is available at: * http://muparser.sourceforge.net/mup_features.html#idDef2 * * image pixels : * p1bX, p2bX, where X denote band index. * * Specific Functor additional input : * distance : euclidian distance * spectralAngle : NOT IMPLEMENTED * * OTB additional functions: * ndvi(r, niri) * * OTB additional constants: * e - log2e - log10e - ln2 - ln10 - pi - euler * * * \sa Parser * * * \ingroup OTBCCOBIA */ /** \class ConnectedComponentMuParserFunctor * \brief This functor use MuParser as criteria for itk connected component module * * \ingroup OTBCCOBIA */ namespace Functor { template class ITK_EXPORT ConnectedComponentMuParserFunctor { public: typedef Parser ParserType; typedef ConnectedComponentMuParserFunctor Self; std::string GetNameOfClass() { return "ConnectedComponentMuParserFunctor"; } inline bool operator()(const TInput &p1, const TInput &p2) { double value; if (p1.GetSize() != m_NbOfBands) { this->SetNumberOfBands(p1.GetSize()); } // we fill the buffer for (unsigned int i = 0; i < m_NbOfBands; ++i) { m_AImageP1[i] = static_cast (p1[i]); m_AImageP2[i] = static_cast (p2[i]); } m_Distance = 0.0; m_IntensityP1 = 0.0; m_IntensityP2 = 0.0; for (unsigned int i = 0; i < m_NbOfBands; ++i) { m_Distance += (p1[i] - p2[i]) * (p1[i] - p2[i]); m_IntensityP1 += p1[i]; m_IntensityP2 += p2[i]; } m_IntensityP1 = m_IntensityP1 / (static_cast (m_NbOfBands)); m_IntensityP2 = m_IntensityP2 / (static_cast (m_NbOfBands)); m_Distance = vcl_sqrt(m_Distance); //compute spectralAngle double scalarProd = 0.0; double normProd = 0.0; double normProd1 = 0.0; double normProd2 = 0.0; for (unsigned int i = 0; i < p1.Size(); ++i) { scalarProd += p1[i] * p2[i]; normProd1 += p1[i] * p1[i]; normProd2 += p2[i] * p2[i]; } normProd = normProd1 * normProd2; if (normProd == 0.0) { m_SpectralAngle = 0.0; } else { m_SpectralAngle = vcl_acos(scalarProd / vcl_sqrt(normProd)); } // value = m_Parser->Eval(); return static_cast (value); } void SetExpression(const std::string expression) { m_Expression = expression; m_Parser->SetExpr(m_Expression); } /** Return the expression to be parsed */ std::string GetExpression() const { return m_Expression; } /** Check the expression */ bool CheckExpression() { return m_Parser->CheckExpr(); } void SetNumberOfBands(unsigned int NbOfBands) { m_NbOfBands = NbOfBands; std::ostringstream varName; m_AImageP1.resize(NbOfBands, 0.0); m_AImageP2.resize(NbOfBands, 0.0); for (unsigned int i = 0; i < NbOfBands; ++i) { varName << "p1b" << i + 1; m_Parser->DefineVar(varName.str(), &(m_AImageP1[i])); varName.str(""); varName << "p2b" << i + 1; m_Parser->DefineVar(varName.str(), &(m_AImageP2[i])); varName.str(""); } // customized data //m_NbVar++; //this->SetDataSize(m_NbVar); m_Parser->DefineVar("distance", &m_Distance); m_Parser->DefineVar("spectralAngle", &m_SpectralAngle); m_Parser->DefineVar("intensity_p1", &m_IntensityP1); m_Parser->DefineVar("intensity_p2", &m_IntensityP2); //this->SetVarName(m_NbVar-1,"spectralDistance"); } const std::map& GetVar() const { return this->m_Parser->GetVar(); } Parser::FunctionMapType GetFunList() const { return this->m_Parser->GetFunList(); } ConnectedComponentMuParserFunctor() { m_Parser = ParserType::New(); m_NbOfBands = 0; } ~ConnectedComponentMuParserFunctor() { } private: ConnectedComponentMuParserFunctor(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented std::string m_Expression; ParserType::Pointer m_Parser; std::vector m_AImageP1; std::vector m_AImageP2; double m_Distance; double m_IntensityP1; double m_IntensityP2; double m_SpectralAngle; std::vector m_VarName; unsigned int m_NbOfBands; double m_ParserResult; }; } // end of Functor namespace }//end namespace otb #endif OTB-release-5.8/Modules/Segmentation/CCOBIA/include/otbLabelObjectOpeningMuParserFilter.h000066400000000000000000000102221301006202600312140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelObjectOpeningMuParserFilter_h #define otbLabelObjectOpeningMuParserFilter_h #include "itkProgressReporter.h" #include #include #include #include "itkArray.h" #include "itkInPlaceLabelMapFilter.h" #include "itkLabelObjectAccessors.h" #include "itkProgressReporter.h" #include "otbOBIAMuParserFunctor.h" namespace otb { /** \class LabelObjectOpeningMuParserImageFilter * \brief Label Object opening using shape and radiometric attributes. Acception/rejection * criteria is user defined via MuParser function. * * This filter is based on the mathematical parser library muParser. * The built in functions and operators list is available at: * http://muparser.sourceforge.net/mup_features.html#idDef2 * * OTB additional functions: * ndvi(r, niri) * * OTB additional constants: * e - log2e - log10e - ln2 - ln10 - pi - euler * * * \sa Parser * * * \ingroup OTBCCOBIA */ template > class ITK_EXPORT LabelObjectOpeningMuParserFilter: public itk::InPlaceLabelMapFilter { public: /** Standard class typedefs. */ typedef LabelObjectOpeningMuParserFilter Self; typedef itk::InPlaceLabelMapFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TImage ImageType; typedef typename ImageType::Pointer ImagePointer; typedef typename ImageType::ConstPointer ImageConstPointer; typedef typename ImageType::PixelType PixelType; typedef typename ImageType::IndexType IndexType; typedef typename ImageType::RegionType InputImageRegionType; typedef typename ImageType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::ConstPointer LabelObjectConstPointer; typedef TFunction FunctorType; typedef typename LabelObjectType::AttributeType AttributeType; /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(LabelObjectOpeningMuParserFilter, InPlaceLabelMapFilter); /** Set the expression to be parsed */ void SetExpression(const std::string expression); /** Return the expression to be parsed */ std::string GetExpression() const; /** Check expression to be parsed **/ bool CheckExpression(); /** Manual variables setting **/ void SetAttributes(std::vector shapeAttributes, std::vector statAttributes, int nbOfBands); /** Display varname and address **/ void DisplayVar() const; /** return list of Mu Parser variables and address**/ const std::map& GetVar() const; /** return list of Mu Parser functions**/ Parser::FunctionMapType GetFunList() const; void AllocateOutputs() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void EnlargeOutputRequestedRegion(itk::DataObject *) ITK_OVERRIDE {} void GenerateData() ITK_OVERRIDE; protected: LabelObjectOpeningMuParserFilter(); ~LabelObjectOpeningMuParserFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: LabelObjectOpeningMuParserFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented FunctorType m_Functor; std::string m_Expression; }; }//end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelObjectOpeningMuParserFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/CCOBIA/include/otbLabelObjectOpeningMuParserFilter.txx000066400000000000000000000142001301006202600316100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelObjectOpeningMuParserFilter_txx #define otbLabelObjectOpeningMuParserFilter_txx #include "otbLabelObjectOpeningMuParserFilter.h" #include #include #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" namespace otb { // constructor template LabelObjectOpeningMuParserFilter::LabelObjectOpeningMuParserFilter() { // create the output image for the removed objects this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(1, static_cast (this->MakeOutput(1).GetPointer())); } // Destructor template LabelObjectOpeningMuParserFilter::~LabelObjectOpeningMuParserFilter() { } template void LabelObjectOpeningMuParserFilter::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Expression: " << m_Expression << std::endl; } template void LabelObjectOpeningMuParserFilter::SetExpression(const std::string expression) { if (m_Expression != expression) m_Expression = expression; m_Functor.SetExpression(m_Expression); this->Modified(); } template std::string LabelObjectOpeningMuParserFilter::GetExpression() const { return m_Expression; } template const std::map& LabelObjectOpeningMuParserFilter::GetVar() const { return this->m_Functor.GetVar(); } template Parser::FunctionMapType LabelObjectOpeningMuParserFilter::GetFunList() const { return this->m_Functor.GetFunList(); } template void LabelObjectOpeningMuParserFilter::DisplayVar() const { const std::map& variables = this->m_Functor.GetVar(); // Get the number of variables std::map::const_iterator item = variables.begin(); // Query the variables for (; item != variables.end(); ++item) { std::cout << "Name: " << item->first << " Address: [0x" << item->second << "]\n"; } } template bool LabelObjectOpeningMuParserFilter::CheckExpression() { return this->m_Functor.CheckExpression(); } template void LabelObjectOpeningMuParserFilter::SetAttributes(std::vector shapeAttributes, std::vector statAttributes, int nbOfBands) { this->m_Functor.SetAttributes(shapeAttributes, statAttributes, nbOfBands); } /** Get the reduced attribute set */ template void LabelObjectOpeningMuParserFilter::AllocateOutputs() { // if told to run in place and the types support it, if (this->GetInPlace() && this->CanRunInPlace()) { // Graft this first input to the output. Later, we'll need to // remove the input's hold on the bulk data. // ImagePointer inputAsOutput = dynamic_cast (const_cast (this->GetInput())); if (inputAsOutput) { this->GraftOutput(inputAsOutput); this->GetOutput()->SetLargestPossibleRegion(this->GetOutput()->GetLargestPossibleRegion()); this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetRequestedRegion()); this->GetOutput()->SetBufferedRegion(this->GetOutput()->GetBufferedRegion()); } // If there are more than one outputs, allocate the remaining outputs for (unsigned int i = 1; i < this->GetNumberOfOutputs(); ++i) { ImagePointer outputPtr; outputPtr = this->GetOutput(i); outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); } } else { Superclass::AllocateOutputs(); // copy the content of the input image to the output image (will be done by ImageSource AllocateOutputs Method) // would never occur : inputasoutput condition is always true, since output and input type is TImage for // LabelObjectOpeningMuParserFilter class } } template void LabelObjectOpeningMuParserFilter::GenerateInputRequestedRegion() { itk::ImageToImageFilter::GenerateInputRequestedRegion(); } template void LabelObjectOpeningMuParserFilter::GenerateData() { ImageConstPointer inputPtr = this->GetInput(); // Allocate the output this->AllocateOutputs(); ImageType * output = this->GetOutput(); ImageType * output2 = this->GetOutput(1); assert( this->GetNumberOfOutputs() == 2 ); assert( output2 != NULL ); // set the background value for the second output - this is not done in the superclasses output2->SetBackgroundValue(output->GetBackgroundValue()); itk::ProgressReporter progress(this, 0, output->GetNumberOfLabelObjects()); typename ImageType::Iterator it(output); while (!it.IsAtEnd()) { typename LabelObjectType::LabelType label = it.GetLabel(); LabelObjectType * labelObject = it.GetLabelObject(); if (!m_Functor(*labelObject)) { // must increment the iterator before removing the object to avoid invalidating the iterator ++it; output2->AddLabelObject(labelObject); output->RemoveLabel(label); } else { ++it; } progress.CompletedPixel(); } } } // end namespace otb #endif otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.h000066400000000000000000000242531301006202600367310ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/CCOBIA/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter_h #define otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter_h #include "otbPersistentImageToVectorDataFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "otbConnectedComponentMuParserFunctor.h" #include "itkConnectedComponentFunctorImageFilter.h" #include "otbMaskMuParserFilter.h" #include "itkRelabelComponentImageFilter.h" #include "otbAttributesMapLabelObject.h" #include "otbLabelImageToLabelMapWithAdjacencyFilter.h" #include "otbBandsStatisticsAttributesLabelMapFilter.h" #include "otbShapeAttributesLabelMapFilter.h" #include "otbLabelObjectOpeningMuParserFilter.h" #include "otbLabelMapToVectorDataFilter.h" namespace otb { /** \class PersistentConnectedComponentSegmentationOBIAToVectorDataFilter * \brief [internal] Helper class to perform connected component segmentation on an input image, * apply OBIA filtering and output a VectorData * * The whole chain is described in : * http://wiki.orfeo-toolbox.org/index.php/Connected_component_segmentation_module * * This class wraps a whole processing chain based on connected component segmentation, * OBIA filtering and conversion to VectorData. * An optional mask can be applied to segment only the pixels inside the mask. * * Parameters of the chain are : * - MaskExpression : mathematical expression to apply on the input image to make a mask * - ConnectedComponentExpression : mathematical expression which connects two pixels * - MinimumObjectSize : minimum object size kept after segmentation * - OBIAExpression : mathematical expression for OBIA filtering * * \ingroup Streamed * * \ingroup OTBCCOBIA */ template class PersistentConnectedComponentSegmentationOBIAToVectorDataFilter : public otb::PersistentImageToVectorDataFilter { public: /** Standard Self typedef */ typedef PersistentConnectedComponentSegmentationOBIAToVectorDataFilter Self; typedef PersistentImageToVectorDataFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TVImage VectorImageType; typedef TLabelImage LabelImageType; typedef TMaskImage MaskImageType; typedef TOutputVectorData VectorDataType; typedef typename VectorImageType::Pointer VectorImagePointerType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef typename VectorImageType::PixelType VectorImagePixelType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentConnectedComponentSegmentationOBIAToVectorDataFilter, PersistentImageToVectorDataFilter); /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int, TVImage::ImageDimension); // Mask generation typedef Functor::ConnectedComponentMuParserFunctor FunctorType; typedef itk::ConnectedComponentFunctorImageFilter< VectorImageType, LabelImageType, FunctorType, MaskImageType > ConnectedComponentFilterType; // mask typedef typedef otb::MaskMuParserFilter MaskMuParserFilterType; // Labelization typedef itk::RelabelComponentImageFilter RelabelComponentFilterType; typedef otb::AttributesMapLabelObject AttributesMapLabelObjectType; typedef otb::LabelMapWithAdjacency AttributesLabelMapType; typedef otb::LabelImageToLabelMapWithAdjacencyFilter LabelImageToLabelMapFilterType; typedef otb::BandsStatisticsAttributesLabelMapFilter RadiometricLabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeLabelMapFilterType; typedef otb::LabelObjectOpeningMuParserFilter LabelObjectOpeningFilterType; typedef otb::LabelMapToVectorDataFilter LabelMapToVectorDataFilterType; typedef typename RelabelComponentFilterType::ObjectSizeType ObjectSizeType; /* Set the mathematical expression used for the mask */ itkSetStringMacro(MaskExpression); /* Get the mathematical expression used for the mask */ itkGetStringMacro(MaskExpression); /* Set the mathematical expression used during connected component segmentation */ itkSetStringMacro(ConnectedComponentExpression); /* Get the mathematical expression used during connected component segmentation */ itkGetStringMacro(ConnectedComponentExpression); /* Set the minimum object size */ itkSetMacro(MinimumObjectSize, ObjectSizeType); /* Get the minimum object size */ itkGetMacro(MinimumObjectSize, ObjectSizeType); /* Set the mathematical expression for filtering labelobjects */ itkSetStringMacro(OBIAExpression); /* Get the mathematical expression for filtering labelobjects */ itkGetStringMacro(OBIAExpression); /* Set shape reduced set attributes flag for object attributes computing */ itkSetMacro(ShapeReducedSetOfAttributes, bool); /* Get shape reduced set attributes flag for object attributes computing */ itkGetMacro(ShapeReducedSetOfAttributes, bool); /* Set stat reduced set attributes flag for object attributes computing */ itkSetMacro(StatsReducedSetOfAttributes, bool); /* Get stat reduced set attributes flag for object attributes computing */ itkGetMacro(StatsReducedSetOfAttributes, bool); /* Set compute polygon flag for object attributes computing */ itkSetMacro(ComputePolygon, bool); /* Get compute polygon flag for object attributes computing */ itkGetMacro(ComputePolygon, bool); /* Set compute Flusser flag for object attributes computing */ itkSetMacro(ComputeFlusser, bool); /* Get compute Flusser flag for object attributes computing */ itkGetMacro(ComputeFlusser, bool); /* Set compute perimeter flag for object attributes computing */ itkSetMacro(ComputePerimeter, bool); /* Get compute perimeter flag for object attributes computing */ itkGetMacro(ComputePerimeter, bool); /* Set compute feret diameter flag for object attributes computing */ itkSetMacro(ComputeFeretDiameter, bool); /* Get compute FeretdDiameter flag for object attributes computing */ itkGetMacro(ComputeFeretDiameter, bool); protected: PersistentConnectedComponentSegmentationOBIAToVectorDataFilter(); ~PersistentConnectedComponentSegmentationOBIAToVectorDataFilter() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; private: ObjectSizeType m_MinimumObjectSize; std::string m_MaskExpression; std::string m_ConnectedComponentExpression; std::string m_OBIAExpression; // attributes bool m_ShapeReducedSetOfAttributes; bool m_StatsReducedSetOfAttributes; bool m_ComputeFlusser; bool m_ComputePolygon; bool m_ComputeFeretDiameter; bool m_ComputePerimeter; VectorDataPointerType ProcessTile() ITK_OVERRIDE; }; /** \class StreamingConnectedComponentSegmentationOBIAToVectorDataFilter * \brief Performs connected component segmentation on an input image, * apply OBIA filtering and output a VectorData, with streaming capabilities * * This class wraps a whole processing chain based on connected component segmentation, * OBIA filtering and conversion to VectorData. * An optional mask can be applied to segment only the pixels inside the mask. * * The whole chain is described in : * http://wiki.orfeo-toolbox.org/index.php/Connected_component_segmentation_module * * The parameters of the processing chain must be applied on the internal filter, * which can be accessed with GetFilter. See PersistentConnectedComponentSegmentationOBIAToVectorDataFilter * * Parameters of the chain are : * - MaskExpression : mathematical expression to apply on the input image to make a mask * - ConnectedComponentExpression : mathematical expression which connects two pixels * - MinimumObjectSize : minimum object size kept after segmentation * - OBIAExpression : mathematical expression for OBIA filtering * * \sa PersistentConnectedComponentSegmentationOBIAToVectorDataFilter * \sa PersistentFilterStreamingDecorator * * \ingroup Streamed * * \ingroup OTBCCOBIA */ template class StreamingConnectedComponentSegmentationOBIAToVectorDataFilter { public: // define the PersistentStreamingLineSegmentDetector template typedef PersistentConnectedComponentSegmentationOBIAToVectorDataFilter< TVImage, TLabelImage, TMaskImage, TOutputVectorData> PersistentConnectedComponentSegmentationOBIAToVectorDataFilterType; typedef typename PersistentConnectedComponentSegmentationOBIAToVectorDataFilterType::VectorImageType VectorImageType; typedef typename PersistentConnectedComponentSegmentationOBIAToVectorDataFilterType::LabelImageType LabelImageType; typedef typename PersistentConnectedComponentSegmentationOBIAToVectorDataFilterType::MaskImageType MaskImageType; typedef typename PersistentConnectedComponentSegmentationOBIAToVectorDataFilterType::VectorDataType VectorDataType; // typedef for streaming capable filter typedef PersistentFilterStreamingDecorator FilterType; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.txx" #endif #endif otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.txx000066400000000000000000000154251301006202600373260ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/CCOBIA/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter_txx #define otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter_txx #include "otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.h" #include "otbVectorDataTransformFilter.h" #include "itkAffineTransform.h" namespace otb { template PersistentConnectedComponentSegmentationOBIAToVectorDataFilter ::PersistentConnectedComponentSegmentationOBIAToVectorDataFilter() : m_MinimumObjectSize(2), m_ShapeReducedSetOfAttributes(false), m_StatsReducedSetOfAttributes(false), m_ComputeFlusser(false), m_ComputePolygon(false), m_ComputeFeretDiameter(false), m_ComputePerimeter(false) { } template PersistentConnectedComponentSegmentationOBIAToVectorDataFilter ::~PersistentConnectedComponentSegmentationOBIAToVectorDataFilter() { } template void PersistentConnectedComponentSegmentationOBIAToVectorDataFilter ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); } template typename PersistentConnectedComponentSegmentationOBIAToVectorDataFilter::VectorDataPointerType PersistentConnectedComponentSegmentationOBIAToVectorDataFilter ::ProcessTile() { // Apply an ExtractImageFilter to avoid problems with filters asking for the LargestPossibleRegion typedef itk::ExtractImageFilter ExtractImageFilterType; typename ExtractImageFilterType::Pointer extract = ExtractImageFilterType::New(); extract->SetInput( this->GetInput() ); extract->SetExtractionRegion( this->GetOutput()->GetRequestedRegion() ); // WARNING: itk::ExtractImageFilter does not copy the MetadataDictionary typename MaskImageType::Pointer mask; if (!m_MaskExpression.empty()) { // Compute the mask typename MaskMuParserFilterType::Pointer maskFilter; maskFilter = MaskMuParserFilterType::New(); maskFilter->SetInput(extract->GetOutput()); maskFilter->SetExpression(m_MaskExpression); maskFilter->Update(); mask = maskFilter->GetOutput(); } // Perform connected components segmentation typename ConnectedComponentFilterType::Pointer connected = ConnectedComponentFilterType::New(); connected->SetInput(extract->GetOutput()); if (mask.IsNotNull()) connected->SetMaskImage(mask); connected->GetFunctor().SetExpression(m_ConnectedComponentExpression); connected->Update(); // Relabel connected component output typename RelabelComponentFilterType::Pointer relabel = RelabelComponentFilterType::New(); relabel->SetInput(connected->GetOutput()); relabel->SetMinimumObjectSize(m_MinimumObjectSize); relabel->Update(); //Attributes computation // LabelImage to Label Map transformation typename LabelImageToLabelMapFilterType::Pointer labelImageToLabelMap = LabelImageToLabelMapFilterType::New(); labelImageToLabelMap->SetInput(relabel->GetOutput()); labelImageToLabelMap->SetBackgroundValue(0); labelImageToLabelMap->Update(); typename AttributesLabelMapType::Pointer labelMap = labelImageToLabelMap->GetOutput(); if (!m_OBIAExpression.empty()) { // shape attributes computation typename ShapeLabelMapFilterType::Pointer shapeLabelMapFilter = ShapeLabelMapFilterType::New(); shapeLabelMapFilter->SetInput(labelImageToLabelMap->GetOutput()); shapeLabelMapFilter->SetReducedAttributeSet(m_ShapeReducedSetOfAttributes); shapeLabelMapFilter->SetComputePolygon(m_ComputePolygon); shapeLabelMapFilter->SetComputePerimeter(m_ComputePerimeter); shapeLabelMapFilter->SetComputeFeretDiameter(m_ComputeFeretDiameter); shapeLabelMapFilter->SetComputeFlusser(m_ComputeFlusser); // band stat attributes computation typename RadiometricLabelMapFilterType::Pointer radiometricLabelMapFilter = RadiometricLabelMapFilterType::New(); radiometricLabelMapFilter->SetInput(shapeLabelMapFilter->GetOutput()); radiometricLabelMapFilter->SetFeatureImage(extract->GetOutput()); radiometricLabelMapFilter->SetReducedAttributeSet(m_StatsReducedSetOfAttributes); // OBIA Filtering using shape and radiometric object characteristics typename LabelObjectOpeningFilterType::Pointer opening = LabelObjectOpeningFilterType::New(); opening->SetExpression(m_OBIAExpression); opening->SetInput(radiometricLabelMapFilter->GetOutput()); opening->Update(); labelMap = opening->GetOutput(); } // Transformation to VectorData typename LabelMapToVectorDataFilterType::Pointer labelMapToVectorDataFilter = LabelMapToVectorDataFilterType::New(); labelMapToVectorDataFilter->SetInput(labelMap); labelMapToVectorDataFilter->Update(); // The VectorData in output of the chain is in image index coordinate, // and the projection information is lost // Apply an affine transform to apply image origin and spacing, // and arbitrarily set the ProjectionRef to the input image ProjectionRef typedef itk::AffineTransform TransformType; typedef VectorDataTransformFilter VDTransformType; typename TransformType::ParametersType params; params.SetSize(6); params[0] = this->GetInput()->GetSpacing()[0]; params[1] = 0; params[2] = 0; params[3] = this->GetInput()->GetSpacing()[1]; params[4] = this->GetInput()->GetOrigin()[0]; params[5] = this->GetInput()->GetOrigin()[1]; typename TransformType::Pointer transform = TransformType::New(); transform->SetParameters(params); typename VDTransformType::Pointer vdTransform = VDTransformType::New(); vdTransform->SetTransform(transform); vdTransform->SetInput(labelMapToVectorDataFilter->GetOutput()); vdTransform->Update(); vdTransform->GetOutput()->SetProjectionRef(this->GetInput()->GetProjectionRef()); return vdTransform->GetOutput(); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/CCOBIA/otb-module.cmake000066400000000000000000000006501301006202600234550ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes that implement the Connected Component algorithm (segmentation).") otb_module(OTBCCOBIA DEPENDS OTBCommon OTBConversion OTBITK OTBLabelMap OTBMathParser OTBProjection OTBStreaming TEST_DEPENDS OTBImageBase OTBImageIO OTBSmoothing OTBTestKernel OTBVectorDataBase OTBVectorDataIO DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Segmentation/CCOBIA/test/000077500000000000000000000000001301006202600213625ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/CCOBIA/test/CMakeLists.txt000066400000000000000000000056651301006202600241360ustar00rootroot00000000000000otb_module_test() set(OTBCCOBIATests otbCCOBIATestDriver.cxx otbStreamingConnectedComponentOBIATest.cxx otbConnectedComponentMuParserFunctorTest.cxx otbMeanShiftStreamingConnectedComponentOBIATest.cxx otbLabelObjectOpeningMuParserFilterNew.cxx otbLabelObjectOpeningMuParserFilterTest.cxx ) add_executable(otbCCOBIATestDriver ${OTBCCOBIATests}) target_link_libraries(otbCCOBIATestDriver ${OTBCCOBIA-Test_LIBRARIES}) otb_module_target_label(otbCCOBIATestDriver) # Tests Declaration otb_add_test(NAME obTuStreamingConnectedComponentSegmentationOBIAToVectorDataFilterNew COMMAND otbCCOBIATestDriver otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilterNew) otb_add_test(NAME obTvStreamingConnectedComponentSegmentationOBIAToVectorDataFilter COMMAND otbCCOBIATestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/obTvStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.shp ${TEMP}/obTvStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.shp otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/obTvStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.shp "((b1>80) * intensity>95)" "distance<40" 15 "SHAPE_Elongation>8" 5 ) otb_add_test(NAME bfTvConnectedComponentMuParserFunctorTest COMMAND otbCCOBIATestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvConnectedComponentMuParserFunctorTest_1.tif ${TEMP}/bfTvConnectedComponentMuParserFunctorTest_1.tif otbConnectedComponentMuParserFunctorTest ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/bfTvConnectedComponentMuParserFunctorTest_1.tif "distance<40" ) otb_add_test(NAME bfTvConnectedComponentMuParserFunctorTestMask COMMAND otbCCOBIATestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvConnectedComponentMuParserFunctorTest_2.tif ${TEMP}/bfTvConnectedComponentMuParserFunctorTest_2.tif otbConnectedComponentMuParserFunctorTest ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/bfTvConnectedComponentMuParserFunctorTest_2.tif "distance<40" ${INPUTDATA}/ROI_QB_MUL_4_Mask.tif ) otb_add_test(NAME obTuMeanShiftStreamingConnectedComponentSegmentationOBIAToVectorDataFilter COMMAND otbCCOBIATestDriver otbMeanShiftStreamingConnectedComponentSegmentationOBIAToVectorDataFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/obTuMeanShiftStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.shp 9 10 0.001 "distance<10" 20 "SHAPE_Elongation>10" 5) otb_add_test(NAME bfTuLabelObjectOpeningMuParserFilterNew COMMAND otbCCOBIATestDriver otbLabelObjectOpeningMuParserFilterNew ) otb_add_test(NAME bfTvLabelObjectOpeningMuParserFilterTest COMMAND otbCCOBIATestDriver --compare-image ${NOTOL} ${BASELINE}/bfTvLabelObjectOpeningMuParserFilterTest.tif ${TEMP}/bfTvLabelObjectOpeningMuParserFilterTest.tif otbLabelObjectOpeningMuParserFilterTest ${INPUTDATA}/ROI_QB_MUL_4.tif ${INPUTDATA}/ROI_QB_MUL_4_Label.tif ${TEMP}/bfTvLabelObjectOpeningMuParserFilterTest.tif "SHAPE_Elongation>8" ) OTB-release-5.8/Modules/Segmentation/CCOBIA/test/otbCCOBIATestDriver.cxx000066400000000000000000000007451301006202600255550ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilterNew); REGISTER_TEST(otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter); REGISTER_TEST(otbConnectedComponentMuParserFunctorTest); REGISTER_TEST(otbMeanShiftStreamingConnectedComponentSegmentationOBIAToVectorDataFilter); REGISTER_TEST(otbLabelObjectOpeningMuParserFilterNew); REGISTER_TEST(otbLabelObjectOpeningMuParserFilterTest); } OTB-release-5.8/Modules/Segmentation/CCOBIA/test/otbConnectedComponentMuParserFunctorTest.cxx000066400000000000000000000052771301006202600322730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbVectorImage.h" #include "otbImage.h" #include "otbConnectedComponentMuParserFunctor.h" #include #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbConnectedComponentMuParserFunctorTest(int argc, char *argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const char * expression = argv[3]; const char * maskFilename; // maskFilename option is present if (argc == 5) { maskFilename = argv[4]; } else { maskFilename = ITK_NULLPTR; } typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputVectorImageType; typedef otb::Image InputMaskImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileReader MaskReaderType; typedef otb::Image OutputImageType; typedef otb::ImageFileWriter WriterType; typedef otb::Functor::ConnectedComponentMuParserFunctor FunctorType; typedef itk::ConnectedComponentFunctorImageFilter FilterType; MaskReaderType::Pointer maskReader; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); reader->SetFileName(inputFilename); reader->GenerateOutputInformation(); writer->SetFileName(outputFilename); filter->SetInput(reader->GetOutput()); if(ITK_NULLPTR != maskFilename) { maskReader = MaskReaderType::New(); maskReader->SetFileName(maskFilename); maskReader->GenerateOutputInformation(); filter->SetMaskImage(maskReader->GetOutput()); } std::string stringExpression(expression); filter->GetFunctor().SetExpression(stringExpression); filter->Update(); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/CCOBIA/test/otbLabelObjectOpeningMuParserFilterNew.cxx000066400000000000000000000022531301006202600316020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkLabelMap.h" #include "otbAttributesMapLabelObject.h" #include "otbLabelObjectOpeningMuParserFilter.h" int otbLabelObjectOpeningMuParserFilterNew( int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef otb::AttributesMapLabelObject AttributesMapLabelObjectType; typedef itk::LabelMap AttributesLabelMapType; typedef otb::LabelObjectOpeningMuParserFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/CCOBIA/test/otbLabelObjectOpeningMuParserFilterTest.cxx000066400000000000000000000104031301006202600317640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include #include "otbAttributesMapLabelObject.h" #include "otbLabelObjectOpeningMuParserFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbShapeAttributesLabelMapFilter.h" #include "itkLabelImageToLabelMapFilter.h" #include "itkLabelMapToLabelImageFilter.h" #include "otbBandsStatisticsAttributesLabelMapFilter.h" int otbLabelObjectOpeningMuParserFilterTest(int itkNotUsed(argc), char * argv[]) { const char * imageInputFilename = argv[1]; const char * labelImageInputFilename = argv[2]; const char * outputFilename = argv[3]; const char * expression = argv[4]; typedef float InputPixelType; const unsigned int Dimension = 2; typedef unsigned int LabelType; typedef otb::Image LabelImageType; typedef otb::VectorImage InputVectorImageType; typedef otb::ImageFileReader ImageReaderType; typedef otb::ImageFileReader LabelImageReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::AttributesMapLabelObject AttributesMapLabelObjectType; typedef itk::LabelMap AttributesLabelMapType; typedef otb::LabelObjectOpeningMuParserFilter FilterType; typedef itk::LabelImageToLabelMapFilter LabelImageToLabelMapFilterType; typedef otb::ShapeAttributesLabelMapFilter ShapeLabelMapFilterType; typedef otb::BandsStatisticsAttributesLabelMapFilter RadiometricLabelMapFilterType; typedef itk::LabelMapToLabelImageFilter LabelMapToLabelImageFilterType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); LabelImageReaderType::Pointer labelImageReader = LabelImageReaderType::New(); WriterType::Pointer writer = WriterType::New(); FilterType::Pointer filter = FilterType::New(); labelImageReader->SetFileName(labelImageInputFilename); labelImageReader->GenerateOutputInformation(); imageReader->SetFileName(imageInputFilename); imageReader->GenerateOutputInformation(); writer->SetFileName(outputFilename); LabelImageToLabelMapFilterType::Pointer labelImageToLabelMap = LabelImageToLabelMapFilterType::New(); labelImageToLabelMap->SetInput(labelImageReader->GetOutput()); labelImageToLabelMap->SetBackgroundValue(0); // shape attributes computation ShapeLabelMapFilterType::Pointer shapeLabelMapFilter = ShapeLabelMapFilterType::New(); shapeLabelMapFilter->SetInput(labelImageToLabelMap->GetOutput()); shapeLabelMapFilter->SetReducedAttributeSet(false); // band stat attributes computation RadiometricLabelMapFilterType::Pointer radiometricLabelMapFilter = RadiometricLabelMapFilterType::New(); radiometricLabelMapFilter->SetInput(shapeLabelMapFilter->GetOutput()); radiometricLabelMapFilter->SetFeatureImage(imageReader->GetOutput()); radiometricLabelMapFilter->SetReducedAttributeSet(false); radiometricLabelMapFilter->Update(); AttributesLabelMapType::Pointer AttributesLabelMap; AttributesLabelMap=radiometricLabelMapFilter->GetOutput(); std::string stringExpression(expression); filter->SetExpression(stringExpression); filter->SetInput(radiometricLabelMapFilter->GetOutput()); filter->Update(); LabelMapToLabelImageFilterType::Pointer labelMapToLabelImage = LabelMapToLabelImageFilterType::New(); labelMapToLabelImage->SetInput(filter->GetOutput()); labelMapToLabelImage->Update(); writer->SetInput(labelMapToLabelImage->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/CCOBIA/test/otbMeanShiftStreamingConnectedComponentOBIATest.cxx000066400000000000000000000070171301006202600333510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorData.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbMeanShiftSmoothingImageFilter.h" #include "otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.h" typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::Image LabelImageType; typedef otb::Image MaskImageType; typedef otb::VectorData VectorDataType; typedef VectorDataType::Pointer VectorDataPointerType; typedef otb::VectorDataFileWriter VectorDataFileWriterType; typedef VectorDataFileWriterType::Pointer VectorDataFileWriterPointerType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::StreamingConnectedComponentSegmentationOBIAToVectorDataFilter < ImageType, LabelImageType, MaskImageType, VectorDataType > ConnectedComponentSegmentationOBIAToVectorDataFilterType; typedef otb::MeanShiftSmoothingImageFilter MeanShiftFilterType; int otbMeanShiftStreamingConnectedComponentSegmentationOBIAToVectorDataFilter(int itkNotUsed(argc), char * argv[]) { /* mean shift parameters */ const char * infname = argv[1]; const char * outputFilename = argv[2]; /* mean shift parameters */ const double spatialBandwidth = atof(argv[3]); const double rangeBandwidth = atof(argv[4]); const double threshold = atof(argv[5]); /* conencted component parameters */ const char * segmentationexpression = argv[6]; unsigned int minobjectsize = atoi(argv[7]); const char * obiaexpression = argv[8]; unsigned int nbstreams = atoi(argv[9]); // add meanshift options // Instantiating object MeanShiftFilterType::Pointer meanShiftFilter = MeanShiftFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); meanShiftFilter->SetSpatialBandwidth(spatialBandwidth); meanShiftFilter->SetRangeBandwidth(rangeBandwidth); meanShiftFilter->SetThreshold(threshold); meanShiftFilter->SetInput(reader->GetOutput()); meanShiftFilter->GetRangeOutput(); ConnectedComponentSegmentationOBIAToVectorDataFilterType::FilterType::Pointer connected = ConnectedComponentSegmentationOBIAToVectorDataFilterType::FilterType::New(); connected->GetFilter()->SetInput(meanShiftFilter->GetRangeOutput()); connected->GetFilter()->SetConnectedComponentExpression(segmentationexpression); connected->GetFilter()->SetMinimumObjectSize(minobjectsize); connected->GetFilter()->SetOBIAExpression(obiaexpression); connected->GetStreamer()->SetNumberOfDivisionsStrippedStreaming(nbstreams); connected->Update(); VectorDataFileWriterPointerType vdwriter = VectorDataFileWriterType::New(); vdwriter->SetInput(connected->GetFilter()->GetOutputVectorData()); vdwriter->SetFileName(outputFilename); vdwriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/CCOBIA/test/otbStreamingConnectedComponentOBIATest.cxx000066400000000000000000000065561301006202600315610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbVectorImage.h" #include "otbVectorData.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter.h" typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::VectorImage InputVectorImageType; typedef otb::Image LabelImageType; typedef otb::Image MaskImageType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorData VectorDataType; typedef VectorDataType::Pointer VectorDataPointerType; typedef otb::VectorDataFileWriter VectorDataFileWriterType; typedef VectorDataFileWriterType::Pointer VectorDataFileWriterPointerType; typedef otb::StreamingConnectedComponentSegmentationOBIAToVectorDataFilter < InputVectorImageType, LabelImageType, MaskImageType, VectorDataType > ConnectedComponentSegmentationOBIAToVectorDataFilterType; int otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { ConnectedComponentSegmentationOBIAToVectorDataFilterType::FilterType::Pointer connected = ConnectedComponentSegmentationOBIAToVectorDataFilterType::FilterType::New(); std::cout << connected << std::endl; return EXIT_SUCCESS; } int otbStreamingConnectedComponentSegmentationOBIAToVectorDataFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const char * maskexpression = argv[3]; const char * segmentationexpression = argv[4]; unsigned int minobjectsize = atoi(argv[5]); const char * obiaexpression = argv[6]; unsigned int nbstreams = atoi(argv[7]); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); reader->UpdateOutputInformation(); ConnectedComponentSegmentationOBIAToVectorDataFilterType::FilterType::Pointer connected = ConnectedComponentSegmentationOBIAToVectorDataFilterType::FilterType::New(); connected->GetFilter()->SetInput(reader->GetOutput()); connected->GetFilter()->SetMaskExpression(maskexpression); connected->GetFilter()->SetConnectedComponentExpression(segmentationexpression); connected->GetFilter()->SetMinimumObjectSize(minobjectsize); connected->GetFilter()->SetOBIAExpression(obiaexpression); connected->GetStreamer()->SetNumberOfDivisionsStrippedStreaming(nbstreams); connected->Update(); VectorDataFileWriterPointerType vdwriter = VectorDataFileWriterType::New(); vdwriter->SetInput(connected->GetFilter()->GetOutputVectorData()); vdwriter->SetFileName(outputFilename); vdwriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/000077500000000000000000000000001301006202600216105ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Conversion/CMakeLists.txt000066400000000000000000000000511301006202600243440ustar00rootroot00000000000000project(OTBConversion) otb_module_impl() OTB-release-5.8/Modules/Segmentation/Conversion/include/000077500000000000000000000000001301006202600232335ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageRegionMergingFilter.h000066400000000000000000000135201301006202600317170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageRegionMergingFilter_h #define otbLabelImageRegionMergingFilter_h #include "otbImage.h" #include "otbVectorImage.h" #include "itkImageToImageFilter.h" #include namespace otb { /** \class LabelImageRegionMergingFilter * * * This class merges regions in the input label image according to the input * image of spectral values and the RangeBandwidth parameter. * * * \ingroup ImageSegmentation * * \ingroup OTBConversion */ template class ITK_EXPORT LabelImageRegionMergingFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef LabelImageRegionMergingFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef double RealType; /** Type macro */ itkTypeMacro(LabelImageRegionMergingFilter, ImageToImageFilter); itkNewMacro(Self); /** Template parameters typedefs */ typedef TInputLabelImage InputLabelImageType; typedef typename InputLabelImageType::PixelType InputLabelType; typedef TInputLabelImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexValueType InputIndexValueType; typedef typename InputImageType::PointType PointType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SizeType SizeType; typedef TInputSpectralImage InputSpectralImageType; typedef typename TInputSpectralImage::PixelType SpectralPixelType; typedef TOutputLabelImage OutputLabelImageType; typedef typename OutputLabelImageType::PixelType OutputLabelType; typedef TOutputLabelImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::RegionType OutputRegionType; typedef TOutputClusteredImage OutputClusteredImageType; itkStaticConstMacro(ImageDimension, unsigned int, InputLabelImageType::ImageDimension); /** Typedefs for region adjacency map */ typedef InputLabelType LabelType; typedef std::set AdjacentLabelsContainerType; typedef std::vector RegionAdjacencyMapType; /** Setters / Getters */ itkSetMacro(RangeBandwidth, RealType); itkGetMacro(RangeBandwidth, RealType); /** Returns the const image of region labels */ const OutputLabelImageType * GetLabelOutput() const; /** Returns the image of region labels */ OutputLabelImageType * GetLabelOutput(); /** Returns the const clustered output image, with one spectral value per region */ const OutputClusteredImageType * GetClusteredOutput() const; /** Returns the clustered output image, with one spectral value per region */ OutputClusteredImageType * GetClusteredOutput(); /** Sets the input image where the value of a pixel is the region id */ void SetInputLabelImage( const InputLabelImageType * labelImage); /** Sets the input image representing spectral values */ void SetInputSpectralImage( const InputSpectralImageType * spectralImage); /** Returns input label image */ InputLabelImageType * GetInputLabelImage(); /** Returns input spectral image */ InputSpectralImageType * GetInputSpectralImage(); protected: void EnlargeOutputRequestedRegion( itk::DataObject *output ) ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; /** Constructor */ LabelImageRegionMergingFilter(); /** Destructor */ ~LabelImageRegionMergingFilter() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Method to build a map of adjacent regions */ RegionAdjacencyMapType LabelImageToRegionAdjacencyMap(typename OutputLabelImageType::Pointer inputLabelImage); private: LabelImageRegionMergingFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Range bandwidth */ RealType m_RangeBandwidth; /** Number of components per pixel in the input image */ unsigned int m_NumberOfComponentsPerPixel; /** This contains the label to which each label will be merged */ std::vector m_CanonicalLabels; /** Contains the spectral value for each region */ std::vector m_Modes; /** Number of points in each region */ std::vector m_PointCounts; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelImageRegionMergingFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageRegionMergingFilter.txx000066400000000000000000000424131301006202600323160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageRegionMergingFilter_txx #define otbLabelImageRegionMergingFilter_txx #include "otbLabelImageRegionMergingFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template LabelImageRegionMergingFilter ::LabelImageRegionMergingFilter() { m_RangeBandwidth=1.0; m_NumberOfComponentsPerPixel=0; this->SetNumberOfRequiredInputs( 2 ); this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0, OutputLabelImageType::New()); this->SetNthOutput(1, OutputClusteredImageType::New()); } template void LabelImageRegionMergingFilter ::SetInputLabelImage( const TInputLabelImage * labelImage) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( labelImage )); } template void LabelImageRegionMergingFilter ::SetInputSpectralImage( const TInputSpectralImage * spectralImage) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( spectralImage )); } template TInputLabelImage * LabelImageRegionMergingFilter ::GetInputLabelImage() { return dynamic_cast(itk::ProcessObject::GetInput(0)); } template TInputSpectralImage * LabelImageRegionMergingFilter ::GetInputSpectralImage() { return dynamic_cast(itk::ProcessObject::GetInput(1)); } template LabelImageRegionMergingFilter ::~LabelImageRegionMergingFilter() { } template TOutputLabelImage * LabelImageRegionMergingFilter ::GetLabelOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template const TOutputLabelImage * LabelImageRegionMergingFilter ::GetLabelOutput() const { if (this->GetNumberOfOutputs() < 1) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template typename LabelImageRegionMergingFilter::OutputClusteredImageType * LabelImageRegionMergingFilter ::GetClusteredOutput() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename LabelImageRegionMergingFilter::OutputClusteredImageType * LabelImageRegionMergingFilter ::GetClusteredOutput() const { if (this->GetNumberOfOutputs() < 2) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void LabelImageRegionMergingFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); unsigned int numberOfComponentsPerPixel = this->GetInputSpectralImage()->GetNumberOfComponentsPerPixel(); if(this->GetClusteredOutput()) { this->GetClusteredOutput()->SetNumberOfComponentsPerPixel(numberOfComponentsPerPixel); } } template void LabelImageRegionMergingFilter ::EnlargeOutputRequestedRegion( itk::DataObject *itkNotUsed(output) ) { // This filter requires all of the output images in the buffer. for ( unsigned int j = 0; j < this->GetNumberOfOutputs(); j++ ) { if ( this->itk::ProcessObject::GetOutput(j) ) { this->itk::ProcessObject::GetOutput(j)->SetRequestedRegionToLargestPossibleRegion(); } } } template void LabelImageRegionMergingFilter ::GenerateData() { typename InputSpectralImageType::Pointer spectralImage = this->GetInputSpectralImage(); typename InputLabelImageType::Pointer inputLabelImage = this->GetInputLabelImage(); typename OutputLabelImageType::Pointer outputLabelImage = this->GetLabelOutput(); typename OutputClusteredImageType::Pointer outputClusteredImage = this->GetClusteredOutput(); // Allocate output outputLabelImage->SetBufferedRegion( outputLabelImage->GetRequestedRegion() ); outputLabelImage->Allocate(); outputClusteredImage->SetBufferedRegion( outputClusteredImage->GetRequestedRegion() ); outputClusteredImage->Allocate(); m_NumberOfComponentsPerPixel = spectralImage->GetNumberOfComponentsPerPixel(); //std::cout << "Copy input label image to output label image" << std::endl; // Copy input label image to output label image typename itk::ImageRegionConstIterator inputIt(inputLabelImage, outputLabelImage->GetRequestedRegion()); typename itk::ImageRegionIterator outputIt(outputLabelImage, outputLabelImage->GetRequestedRegion()); inputIt.GoToBegin(); outputIt.GoToBegin(); while(!inputIt.IsAtEnd()) { outputIt.Set(inputIt.Get()); ++inputIt; ++outputIt; } RegionAdjacencyMapType regionAdjacencyMap = LabelImageToRegionAdjacencyMap(outputLabelImage); unsigned int regionCount = regionAdjacencyMap.size() - 1; // Initialize arrays for mode information m_CanonicalLabels.clear(); m_CanonicalLabels.resize(regionCount+1); m_Modes.clear(); m_Modes.reserve(regionCount+1); for(unsigned int i = 0; i < regionCount+1; ++i) { m_Modes.push_back( SpectralPixelType(m_NumberOfComponentsPerPixel) ); } m_PointCounts.clear(); m_PointCounts.resize(regionCount+1); // = std::vector(regionCount+1); // Associate each label to a spectral value, a canonical label and a point count typename itk::ImageRegionConstIterator inputItWithIndex(inputLabelImage, outputLabelImage->GetRequestedRegion()); inputItWithIndex.GoToBegin(); while(!inputItWithIndex.IsAtEnd()) { LabelType label = inputItWithIndex.Get(); // if label has not been initialized yet .. if(m_PointCounts[label] == 0) { // m_CanonicalLabels[label] = label; m_Modes[label] = spectralImage->GetPixel(inputItWithIndex.GetIndex()); } m_PointCounts[label]++; ++inputItWithIndex; } // Region Merging bool finishedMerging = false; unsigned int mergeIterations = 0; //std::cout << "Start merging" << std::endl; // Iterate until no more merge to do // while(!finishedMerging) // { while(!finishedMerging) { // Initialize Canonical Labels for(LabelType curLabel = 1; curLabel <= regionCount; ++curLabel) m_CanonicalLabels[curLabel] = curLabel; // Iterate over all regions for(LabelType curLabel = 1; curLabel <= regionCount; ++curLabel) { if(m_PointCounts[curLabel] == 0) { // do not process empty regions continue; } // std::cout<<" point in label "< newModes; newModes.reserve(regionCount+1); //(regionCount+1, SpectralPixelType(m_NumberOfComponentsPerPixel)); for(unsigned int i = 0; i < regionCount+1; ++i) { newModes.push_back( SpectralPixelType(m_NumberOfComponentsPerPixel) ); } std::vector newPointCounts(regionCount+1); for(unsigned int i = 1; i < regionCount+1; ++i) { newModes[i].Fill(0); newPointCounts[i] = 0; } for(unsigned int i = 1; i < regionCount+1; ++i) { LabelType canLabel = m_CanonicalLabels[i]; unsigned int nPoints = m_PointCounts[i]; for(unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; ++comp) { newModes[canLabel][comp] += nPoints * m_Modes[i][comp]; } newPointCounts[canLabel] += nPoints; } //std::cout << "re-labeling" << std::endl; /* re-labeling */ std::vector newLabels(regionCount+1); std::vector newLabelSet(regionCount+1); for(unsigned int i = 1; i < regionCount+1; ++i) { newLabelSet[i] = false; } LabelType label = 0; for(unsigned int i = 1; i < regionCount+1; ++i) { LabelType canLabel = m_CanonicalLabels[i]; if(newLabelSet[canLabel] == false) { newLabelSet[canLabel] = true; label++; newLabels[canLabel] = label; unsigned int nPoints = newPointCounts[canLabel]; for(unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; ++comp) { m_Modes[label][comp] = newModes[canLabel][comp] / nPoints; } m_PointCounts[label] = newPointCounts[canLabel]; } } unsigned int oldRegionCount = regionCount; regionCount = label; /* reassign labels in label image */ outputIt.GoToBegin(); while(!outputIt.IsAtEnd()) { LabelType l = outputIt.Get(); LabelType canLabel; assert(m_CanonicalLabels[l] <= oldRegionCount); canLabel = newLabels[m_CanonicalLabels[l]]; outputIt.Set( canLabel ); ++outputIt; } finishedMerging = oldRegionCount == regionCount || mergeIterations >= 10 || regionCount == 1; // only one iteration for now if(!finishedMerging) { /* Update adjacency table */ regionAdjacencyMap = LabelImageToRegionAdjacencyMap(outputLabelImage); } mergeIterations++; } // end of main iteration loop // std::cout << "merge iterations: " << mergeIterations << std::endl; // std::cout << "number of label objects: " << regionCount << std::endl; // Generate clustered output itk::ImageRegionIterator outputClusteredIt(outputClusteredImage, outputClusteredImage->GetRequestedRegion() ); outputClusteredIt.GoToBegin(); outputIt.GoToBegin(); while( !outputClusteredIt.IsAtEnd() ) { LabelType label = outputIt.Get(); const SpectralPixelType & p = m_Modes[ label ]; outputClusteredIt.Set(p); ++outputClusteredIt; ++outputIt; } } template void LabelImageRegionMergingFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Range bandwidth: " << m_RangeBandwidth << std::endl; } template typename LabelImageRegionMergingFilter::RegionAdjacencyMapType LabelImageRegionMergingFilter ::LabelImageToRegionAdjacencyMap(typename OutputLabelImageType::Pointer labelImage) { // declare the output map RegionAdjacencyMapType ram; // Find the maximum label value itk::ImageRegionConstIterator it(labelImage, labelImage->GetRequestedRegion()); it.GoToBegin(); LabelType maxLabel = 0; while(!it.IsAtEnd()) { LabelType label = it.Get(); maxLabel = vcl_max(maxLabel, label); ++it; } // Set the size of the adjacency map ram.resize(maxLabel+1); // set the image region without bottom and right borders so that bottom and // right neighbors always exist RegionType regionWithoutBottomRightBorders = labelImage->GetRequestedRegion(); SizeType size = regionWithoutBottomRightBorders.GetSize(); for(unsigned int d = 0; d < ImageDimension; ++d) size[d] -= 1; regionWithoutBottomRightBorders.SetSize(size); itk::ImageRegionConstIteratorWithIndex inputIt(labelImage, regionWithoutBottomRightBorders); inputIt.GoToBegin(); while(!inputIt.IsAtEnd()) { const InputIndexType & index = inputIt.GetIndex(); LabelType label = inputIt.Get(); // check neighbors for(unsigned int d = 0; d < ImageDimension; ++d) { InputIndexType neighborIndex = index; neighborIndex[d]++; LabelType neighborLabel = labelImage->GetPixel(neighborIndex); // add adjacency if different labels if(neighborLabel != label) { ram[label].insert(neighborLabel); ram[neighborLabel].insert(label); } } ++inputIt; } return ram; } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageRegionPruningFilter.h000066400000000000000000000134741301006202600317610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageRegionPruningFilter_h #define otbLabelImageRegionPruningFilter_h #include "otbImage.h" #include "otbVectorImage.h" #include "itkImageToImageFilter.h" #include "itkNumericTraits.h" #include namespace otb { /** \class LabelImageRegionPruningFilter * * * This class merges regions in the input label image according to the input * image of spectral values and the RangeBandwidth parameter. * * * \ingroup ImageSegmentation * * \ingroup OTBConversion */ template class ITK_EXPORT LabelImageRegionPruningFilter : public itk::ImageToImageFilter { public: /** Standard class typedef */ typedef LabelImageRegionPruningFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef double RealType; /** Type macro */ itkTypeMacro(LabelImageRegionPruningFilter, ImageToImageFilter); itkNewMacro(Self); /** Template parameters typedefs */ typedef TInputLabelImage InputLabelImageType; typedef typename InputLabelImageType::PixelType InputLabelType; typedef TInputLabelImage InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType InputSizeType; typedef typename InputImageType::IndexValueType InputIndexValueType; typedef typename InputImageType::PointType PointType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SizeType SizeType; typedef TInputSpectralImage InputSpectralImageType; typedef typename TInputSpectralImage::PixelType SpectralPixelType; typedef TOutputLabelImage OutputLabelImageType; typedef typename OutputLabelImageType::PixelType OutputLabelType; typedef TOutputLabelImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename OutputImageType::PixelType OutputPixelType; typedef typename OutputImageType::RegionType OutputRegionType; typedef TOutputClusteredImage OutputClusteredImageType; itkStaticConstMacro(ImageDimension, unsigned int, InputLabelImageType::ImageDimension); /** Typedefs for region adjacency map */ typedef InputLabelType LabelType; typedef std::set AdjacentLabelsContainerType; typedef std::vector RegionAdjacencyMapType; itkSetMacro(MinRegionSize, RealType); itkGetConstMacro(MinRegionSize, RealType); /** Returns the const image of region labels */ const OutputLabelImageType * GetLabelOutput() const; /** Returns the image of region labels */ OutputLabelImageType * GetLabelOutput(); /** Returns the const clustered output image, with one spectral value per region */ const OutputClusteredImageType * GetClusteredOutput() const; /** Returns the clustered output image, with one spectral value per region */ OutputClusteredImageType * GetClusteredOutput(); /** Sets the input image where the value of a pixel is the region id */ void SetInputLabelImage( const InputLabelImageType * labelImage); /** Sets the input image representing spectral values */ void SetInputSpectralImage( const InputSpectralImageType * spectralImage); /** Returns input label image */ InputLabelImageType * GetInputLabelImage(); /** Returns input spectral image */ InputSpectralImageType * GetInputSpectralImage(); protected: void EnlargeOutputRequestedRegion( itk::DataObject *output ) ITK_OVERRIDE; void GenerateOutputInformation(void) ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; /** Constructor */ LabelImageRegionPruningFilter(); /** Destructor */ ~LabelImageRegionPruningFilter() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Method to build a map of adjacent regions */ RegionAdjacencyMapType LabelImageToRegionAdjacencyMap(typename OutputLabelImageType::Pointer inputLabelImage); private: LabelImageRegionPruningFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Number of components per pixel in the input image */ unsigned int m_NumberOfComponentsPerPixel; unsigned int m_MinRegionSize; /** This contains the label to which each label will be merged */ std::vector m_CanonicalLabels; /** Contains the spectral value for each region */ std::vector m_Modes; /** Number of points in each region */ std::vector m_PointCounts; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelImageRegionPruningFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageRegionPruningFilter.txx000066400000000000000000000433741301006202600323570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageRegionPruningFilter_txx #define otbLabelImageRegionPruningFilter_txx #include "otbLabelImageRegionPruningFilter.h" #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageRegionIterator.h" #include "itkProgressReporter.h" namespace otb { template LabelImageRegionPruningFilter ::LabelImageRegionPruningFilter() { m_NumberOfComponentsPerPixel=0; m_MinRegionSize=100; this->SetNumberOfRequiredInputs( 2 ); this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0, OutputLabelImageType::New()); this->SetNthOutput(1, OutputClusteredImageType::New()); } template void LabelImageRegionPruningFilter ::SetInputLabelImage( const TInputLabelImage * labelImage) { // Process object is not const-correct so the const casting is required. this->SetNthInput(0, const_cast( labelImage )); } template void LabelImageRegionPruningFilter ::SetInputSpectralImage( const TInputSpectralImage * spectralImage) { // Process object is not const-correct so the const casting is required. this->SetNthInput(1, const_cast( spectralImage )); } template TInputLabelImage * LabelImageRegionPruningFilter ::GetInputLabelImage() { return dynamic_cast(itk::ProcessObject::GetInput(0)); } template TInputSpectralImage * LabelImageRegionPruningFilter ::GetInputSpectralImage() { return dynamic_cast(itk::ProcessObject::GetInput(1)); } template LabelImageRegionPruningFilter ::~LabelImageRegionPruningFilter() { } template TOutputLabelImage * LabelImageRegionPruningFilter ::GetLabelOutput() { if (this->GetNumberOfOutputs() < 1) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template const TOutputLabelImage * LabelImageRegionPruningFilter ::GetLabelOutput() const { if (this->GetNumberOfOutputs() < 1) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(0)); } template typename LabelImageRegionPruningFilter::OutputClusteredImageType * LabelImageRegionPruningFilter ::GetClusteredOutput() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename LabelImageRegionPruningFilter::OutputClusteredImageType * LabelImageRegionPruningFilter ::GetClusteredOutput() const { if (this->GetNumberOfOutputs() < 2) { return 0; } return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void LabelImageRegionPruningFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); unsigned int numberOfComponentsPerPixel = this->GetInputSpectralImage()->GetNumberOfComponentsPerPixel(); if(this->GetClusteredOutput()) { this->GetClusteredOutput()->SetNumberOfComponentsPerPixel(numberOfComponentsPerPixel); } } template void LabelImageRegionPruningFilter ::EnlargeOutputRequestedRegion( itk::DataObject *itkNotUsed(output) ) { // This filter requires all of the output images in the buffer. for ( unsigned int j = 0; j < this->GetNumberOfOutputs(); j++ ) { if ( this->itk::ProcessObject::GetOutput(j) ) { this->itk::ProcessObject::GetOutput(j)->SetRequestedRegionToLargestPossibleRegion(); } } } template void LabelImageRegionPruningFilter ::GenerateData() { typename InputSpectralImageType::Pointer spectralImage = this->GetInputSpectralImage(); typename InputLabelImageType::Pointer inputLabelImage = this->GetInputLabelImage(); typename OutputLabelImageType::Pointer outputLabelImage = this->GetLabelOutput(); typename OutputClusteredImageType::Pointer outputClusteredImage = this->GetClusteredOutput(); // Allocate output outputLabelImage->SetBufferedRegion( outputLabelImage->GetRequestedRegion() ); outputLabelImage->Allocate(); outputClusteredImage->SetBufferedRegion( outputClusteredImage->GetRequestedRegion() ); outputClusteredImage->Allocate(); m_NumberOfComponentsPerPixel = spectralImage->GetNumberOfComponentsPerPixel(); //std::cout << "Copy input label image to output label image" << std::endl; // Copy input label image to output label image typename itk::ImageRegionConstIterator inputIt(inputLabelImage, outputLabelImage->GetRequestedRegion()); typename itk::ImageRegionIterator outputIt(outputLabelImage, outputLabelImage->GetRequestedRegion()); inputIt.GoToBegin(); outputIt.GoToBegin(); while(!inputIt.IsAtEnd()) { outputIt.Set(inputIt.Get()); ++inputIt; ++outputIt; } RegionAdjacencyMapType regionAdjacencyMap = LabelImageToRegionAdjacencyMap(outputLabelImage); unsigned int regionCount = regionAdjacencyMap.size() - 1; // Initialize arrays for mode information m_CanonicalLabels.clear(); m_CanonicalLabels.resize(regionCount+1); m_Modes.clear(); m_Modes.reserve(regionCount+1); for(unsigned int i = 0; i < regionCount+1; ++i) { m_Modes.push_back( SpectralPixelType(m_NumberOfComponentsPerPixel) ); } m_PointCounts.clear(); m_PointCounts.resize(regionCount+1); // = std::vector(regionCount+1); // Associate each label to a spectral value, a canonical label and a point count typename itk::ImageRegionConstIterator inputItWithIndex(inputLabelImage, outputLabelImage->GetRequestedRegion()); inputItWithIndex.GoToBegin(); while(!inputItWithIndex.IsAtEnd()) { LabelType label = inputItWithIndex.Get(); // if label has not been initialized yet .. if(m_PointCounts[label] == 0) { // m_CanonicalLabels[label] = label; m_Modes[label] = spectralImage->GetPixel(inputItWithIndex.GetIndex()); } m_PointCounts[label]++; ++inputItWithIndex; } // Region Pruning bool finishedPruning = false; unsigned int pruneIterations = 0; unsigned int minRegionCount = 0; do{ minRegionCount = 0; // Initialize Canonical Labels for(LabelType curLabel = 1; curLabel <= regionCount; ++curLabel) { m_CanonicalLabels[curLabel] = curLabel; /* if(m_PointCounts[curLabel] <= m_MinRegionSize) { minRegionCount++; }*/ } // std::cout< m_MinRegionSize)) { // do not process empty regions continue; } minRegionCount++; // std::cout<<" point in label "<::max(); while (adjIt != regionAdjacencyMap[curLabel].end()) { LabelType adjLabel = *adjIt; assert(adjLabel <= regionCount); const SpectralPixelType & adjSpectral = m_Modes[adjLabel]; // Check condition to merge regions //find the spectrally nearest adjacent label RealType norm2 = 0; for(unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; ++comp) { RealType e; e = (curSpectral[comp] - adjSpectral[comp]); norm2 += e*e; } if(norm2 < bestNorm2) { bestNorm2=norm2; neighborCandidate=adjLabel; }; ++adjIt; } // end of loop over adjacent labels if(neighborCandidate!=0) { // Find canonical label for current region LabelType curCanLabel = curLabel; //m_CanonicalLabels[curLabel]; while(m_CanonicalLabels[curCanLabel] != curCanLabel) { curCanLabel = m_CanonicalLabels[curCanLabel]; } // Find canonical label for adjacent region LabelType adjCanLabel =neighborCandidate; //m_CanonicalLabels[curLabel]; while(m_CanonicalLabels[adjCanLabel] != adjCanLabel) { adjCanLabel = m_CanonicalLabels[adjCanLabel]; } // Assign same canonical label to both regions if(curCanLabel < adjCanLabel) { m_CanonicalLabels[adjCanLabel] = curCanLabel; } else { m_CanonicalLabels[m_CanonicalLabels[curCanLabel]] = adjCanLabel; m_CanonicalLabels[curCanLabel] = adjCanLabel; } } } // end of loop over labels //std::cout << "Simplify the table of canonical labels" << std::endl; /* Simplify the table of canonical labels */ for(LabelType i = 1; i < regionCount+1; ++i) { LabelType can = i; while(m_CanonicalLabels[can] != can) { can = m_CanonicalLabels[can]; } m_CanonicalLabels[i] = can; } //std::cout << "merge regions with same canonical label" << std::endl; /* Merge regions with same canonical label */ /* - update modes and point counts */ std::vector newModes; newModes.reserve(regionCount+1); //(regionCount+1, SpectralPixelType(m_NumberOfComponentsPerPixel)); for(unsigned int i = 0; i < regionCount+1; ++i) { newModes.push_back( SpectralPixelType(m_NumberOfComponentsPerPixel) ); } std::vector newPointCounts(regionCount+1); for(unsigned int i = 1; i < regionCount+1; ++i) { newModes[i].Fill(0); newPointCounts[i] = 0; } for(unsigned int i = 1; i < regionCount+1; ++i) { LabelType canLabel = m_CanonicalLabels[i]; unsigned int nPoints = m_PointCounts[i]; for(unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; ++comp) { newModes[canLabel][comp] += nPoints * m_Modes[i][comp]; } newPointCounts[canLabel] += nPoints; } //std::cout << "re-labeling" << std::endl; /* re-labeling */ std::vector newLabels(regionCount+1); std::vector newLabelSet(regionCount+1); for(unsigned int i = 1; i < regionCount+1; ++i) { newLabelSet[i] = false; } LabelType label = 0; for(unsigned int i = 1; i < regionCount+1; ++i) { LabelType canLabel = m_CanonicalLabels[i]; if(newLabelSet[canLabel] == false) { newLabelSet[canLabel] = true; label++; newLabels[canLabel] = label; unsigned int nPoints = newPointCounts[canLabel]; for(unsigned int comp = 0; comp < m_NumberOfComponentsPerPixel; ++comp) { m_Modes[label][comp] = newModes[canLabel][comp] / nPoints; } m_PointCounts[label] = newPointCounts[canLabel]; } } unsigned int oldRegionCount = regionCount; regionCount = label; /* reassign labels in label image */ outputIt.GoToBegin(); while(!outputIt.IsAtEnd()) { LabelType l = outputIt.Get(); LabelType canLabel; itkAssertOrThrowMacro(m_CanonicalLabels[l] <= oldRegionCount,"Found a label greater than region count") canLabel = newLabels[m_CanonicalLabels[l]]; outputIt.Set( canLabel ); ++outputIt; } finishedPruning = !minRegionCount || regionCount == 1 || pruneIterations>=10; // only one iteration for now if(!finishedPruning) { /* Update adjacency table */ regionAdjacencyMap = LabelImageToRegionAdjacencyMap(outputLabelImage); } pruneIterations++; }while(!finishedPruning); // end of main iteration loop // std::cout << "merge iterations: " << mergeIterations << std::endl; // std::cout << "number of label objects: " << regionCount << std::endl; // Generate clustered output itk::ImageRegionIterator outputClusteredIt(outputClusteredImage, outputClusteredImage->GetRequestedRegion() ); outputClusteredIt.GoToBegin(); outputIt.GoToBegin(); while( !outputClusteredIt.IsAtEnd() ) { LabelType label = outputIt.Get(); const SpectralPixelType & p = m_Modes[ label ]; outputClusteredIt.Set(p); ++outputClusteredIt; ++outputIt; } } template void LabelImageRegionPruningFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Minimum Region Size: " << m_MinRegionSize << std::endl; } template typename LabelImageRegionPruningFilter::RegionAdjacencyMapType LabelImageRegionPruningFilter ::LabelImageToRegionAdjacencyMap(typename OutputLabelImageType::Pointer labelImage) { // declare the output map RegionAdjacencyMapType ram; // Find the maximum label value itk::ImageRegionConstIterator it(labelImage, labelImage->GetRequestedRegion()); it.GoToBegin(); LabelType maxLabel = 0; while(!it.IsAtEnd()) { LabelType label = it.Get(); maxLabel = vcl_max(maxLabel, label); ++it; } // Set the size of the adjacency map ram.resize(maxLabel+1); // set the image region without bottom and right borders so that bottom and // right neighbors always exist RegionType regionWithoutBottomRightBorders = labelImage->GetRequestedRegion(); SizeType size = regionWithoutBottomRightBorders.GetSize(); for(unsigned int d = 0; d < ImageDimension; ++d) size[d] -= 1; regionWithoutBottomRightBorders.SetSize(size); itk::ImageRegionConstIteratorWithIndex inputIt(labelImage, regionWithoutBottomRightBorders); inputIt.GoToBegin(); while(!inputIt.IsAtEnd()) { const InputIndexType & index = inputIt.GetIndex(); LabelType label = inputIt.Get(); // check neighbors for(unsigned int d = 0; d < ImageDimension; ++d) { InputIndexType neighborIndex = index; neighborIndex[d]++; LabelType neighborLabel = labelImage->GetPixel(neighborIndex); // add adjacency if different labels if(neighborLabel != label) { ram[label].insert(neighborLabel); ram[neighborLabel].insert(label); } } ++inputIt; } return ram; } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageToOGRDataSourceFilter.h000066400000000000000000000114341301006202600320720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageToOGRDataSourceFilter_h #define otbLabelImageToOGRDataSourceFilter_h #include "itkProcessObject.h" #include "otbOGRDataSourceWrapper.h" namespace otb { /** \class LabelImageToOGRDataSourceFilter * this class uses \c GDALPolygonize() method to transform a Label image into * a "memory" \c OGRDataSource. The layer in the DataSource is named "Layer". * Each Feature of the layer has a Integer Field which name is specified by \c SetFieldName() (default is "DN"). * Label of the input image are written into this field. * An optional input mask can be used to exclude pixels from vectorization process. * All pixels with a value of 0 in the input mask image will not be suitable for vectorization. * \note The Use8Connected parameter can be turn on and it will be used in \c GDALPolygonize(). But be carreful, it * can create cross polygons ! * \note It is a non-streamed version. * \ingroup OBIA * * * \ingroup OTBConversion */ template class ITK_EXPORT LabelImageToOGRDataSourceFilter : public itk::ProcessObject { public: /** typedef for the classes standards. */ typedef LabelImageToOGRDataSourceFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(LabelImageToOGRDataSourceFilter, ProcessObject); /** Definition of the input image */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SpacingType SpacingType; typedef typename InputImageType::PointType OriginType; typedef typename InputImageType::IndexType IndexType; typedef ogr::DataSource OGRDataSourceType; typedef typename OGRDataSourceType::Pointer OGRDataSourcePointerType; typedef ogr::Layer OGRLayerType; typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType; /** Set/Get the input image of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputImageType *input); virtual const InputImageType * GetInput(void); /** Set the input mask image. * All pixels in the mask with a value of 0 will not be considered * suitable for vectorization. */ virtual void SetInputMask(const InputImageType *input); virtual const InputImageType * GetInputMask(void); /** Set the Field Name in which labels will be written. (default is "DN") * A field "FieldName" of type integer is created in the output memory layer. */ itkSetMacro(FieldName, std::string); /** * Return the Field name in which labels have been written. */ itkGetMacro(FieldName, std::string); /** * Set the value of 8-connected neighborhood option used in \c GDALPolygonize */ itkSetMacro(Use8Connected, bool); /** * Get the value of 8-connected neighborhood option used in \c GDALPolygonize */ itkGetMacro(Use8Connected, bool); /** * Get the output \c ogr::DataSource which is a "memory" datasource. */ const OGRDataSourceType * GetOutput(); protected: LabelImageToOGRDataSourceFilter(); ~LabelImageToOGRDataSourceFilter() ITK_OVERRIDE {} void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Generate Data method*/ void GenerateData() ITK_OVERRIDE; /** DataObject pointer */ typedef itk::DataObject::Pointer DataObjectPointer; DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) ITK_OVERRIDE; using Superclass::MakeOutput; private: LabelImageToOGRDataSourceFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string m_FieldName; bool m_Use8Connected; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelImageToOGRDataSourceFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageToOGRDataSourceFilter.txx000066400000000000000000000236761301006202600325010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageToOGRDataSourceFilter_txx #define otbLabelImageToOGRDataSourceFilter_txx #include "otbLabelImageToOGRDataSourceFilter.h" #include "otbGdalDataTypeBridge.h" //gdal libraries #include "gdal.h" #include "gdal_priv.h" #include "cpl_conv.h" #include "gdal_alg.h" #include "stdint.h" //needed for uintptr_t namespace otb { template LabelImageToOGRDataSourceFilter ::LabelImageToOGRDataSourceFilter() : m_FieldName("DN"), m_Use8Connected(false) { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); GDALAllRegister(); this->ProcessObject::SetNthOutput(0, this->MakeOutput(0) ); } template typename LabelImageToOGRDataSourceFilter::DataObjectPointer LabelImageToOGRDataSourceFilter ::MakeOutput(DataObjectPointerArraySizeType itkNotUsed(idx)) { return static_cast< DataObjectPointer >(OGRDataSourceType::New().GetPointer()); } template const typename LabelImageToOGRDataSourceFilter::OGRDataSourceType * LabelImageToOGRDataSourceFilter ::GetOutput() { return static_cast< const OGRDataSourceType *>( this->ProcessObject::GetOutput(0)); } template void LabelImageToOGRDataSourceFilter ::SetInput(const InputImageType *input) { this->Superclass::SetNthInput(0, const_cast(input)); } template const typename LabelImageToOGRDataSourceFilter ::InputImageType * LabelImageToOGRDataSourceFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(0)); } template void LabelImageToOGRDataSourceFilter ::SetInputMask(const InputImageType *input) { this->Superclass::SetNthInput(1, const_cast(input)); } template const typename LabelImageToOGRDataSourceFilter ::InputImageType * LabelImageToOGRDataSourceFilter ::GetInputMask(void) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(1)); } template void LabelImageToOGRDataSourceFilter ::GenerateInputRequestedRegion(void) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the inputs typename InputImageType::Pointer input = const_cast (this->GetInput()); if ( !input ) { return; } // The input is necessarily the largest possible region. input->SetRequestedRegionToLargestPossibleRegion(); typename InputImageType::Pointer mask = const_cast (this->GetInputMask()); if(!mask) { return; } // The input is necessarily the largest possible region. mask->SetRequestedRegionToLargestPossibleRegion(); } template void LabelImageToOGRDataSourceFilter ::GenerateData(void) { if (this->GetInput()->GetRequestedRegion() != this->GetInput()->GetLargestPossibleRegion()) { itkExceptionMacro(<< "Not streamed filter. ERROR : requested region is not the largest possible region."); } SizeType size; unsigned int nbBands = 0; unsigned int bytePerPixel = 0; /* Convert the input image into a GDAL raster needed by GDALPolygonize */ size = this->GetInput()->GetLargestPossibleRegion().GetSize(); nbBands = this->GetInput()->GetNumberOfComponentsPerPixel(); bytePerPixel = sizeof(InputPixelType); // buffer casted in unsigned long cause under Win32 the address // don't begin with 0x, the address in not interpreted as // hexadecimal but alpha numeric value, then the conversion to // integer make us pointing to an non allowed memory block => Crash. std::ostringstream stream; stream << "MEM:::" << "DATAPOINTER=" << (uintptr_t)(this->GetInput()->GetBufferPointer()) << "," << "PIXELS=" << size[0] << "," << "LINES=" << size[1] << "," << "BANDS=" << nbBands << "," << "DATATYPE=" << GDALGetDataTypeName(GdalDataTypeBridge::GetGDALDataType()) << "," << "PIXELOFFSET=" << bytePerPixel * nbBands << "," << "LINEOFFSET=" << bytePerPixel * nbBands * size[0] << "," << "BANDOFFSET=" << bytePerPixel; GDALDataset * dataset = static_cast (GDALOpen(stream.str().c_str(), GA_ReadOnly)); //Set input Projection ref and Geo transform to the dataset. dataset->SetProjection(this->GetInput()->GetProjectionRef().c_str()); unsigned int projSize = this->GetInput()->GetGeoTransform().size(); double geoTransform[6]; //Set the geo transform of the input image (if any) // Reporting origin and spacing of the buffered region // the spacing is unchanged, the origin is relative to the buffered region IndexType bufferIndexOrigin = this->GetInput()->GetBufferedRegion().GetIndex(); OriginType bufferOrigin; this->GetInput()->TransformIndexToPhysicalPoint(bufferIndexOrigin, bufferOrigin); geoTransform[0] = bufferOrigin[0] - 0.5 * this->GetInput()->GetSpacing()[0]; geoTransform[3] = bufferOrigin[1] - 0.5 * this->GetInput()->GetSpacing()[1]; geoTransform[1] = this->GetInput()->GetSpacing()[0]; geoTransform[5] = this->GetInput()->GetSpacing()[1]; // FIXME: Here component 1 and 4 should be replaced by the orientation parameters if (projSize == 0) { geoTransform[2] = 0.; geoTransform[4] = 0.; } else { geoTransform[2] = this->GetInput()->GetGeoTransform()[2]; geoTransform[4] = this->GetInput()->GetGeoTransform()[4]; } dataset->SetGeoTransform(geoTransform); //Create the output layer for GDALPolygonize(). ogr::DataSource::Pointer ogrDS = ogr::DataSource::New(); OGRLayerType outputLayer = ogrDS->CreateLayer("layer",ITK_NULLPTR,wkbPolygon); OGRFieldDefn field(m_FieldName.c_str(),OFTInteger); outputLayer.CreateField(field, true); //Call GDALPolygonize() char ** options; options = ITK_NULLPTR; char * option[1]; if (m_Use8Connected == true) { std::string opt("8CONNECTED:8"); option[0] = const_cast(opt.c_str()); options=option; } /* Convert the mask input into a GDAL raster needed by GDALPolygonize */ typename InputImageType::ConstPointer inputMask = this->GetInputMask(); if (!inputMask.IsNull()) { size = this->GetInputMask()->GetLargestPossibleRegion().GetSize(); nbBands = this->GetInputMask()->GetNumberOfComponentsPerPixel(); bytePerPixel = sizeof(InputPixelType); // buffer casted in unsigned long cause under Win32 the address // don't begin with 0x, the address in not interpreted as // hexadecimal but alpha numeric value, then the conversion to // integer make us pointing to an non allowed memory block => Crash. std::ostringstream maskstream; maskstream << "MEM:::" << "DATAPOINTER=" << (uintptr_t)(this->GetInputMask()->GetBufferPointer()) << "," << "PIXELS=" << size[0] << "," << "LINES=" << size[1] << "," << "BANDS=" << nbBands << "," << "DATATYPE=" << GDALGetDataTypeName(GdalDataTypeBridge::GetGDALDataType()) << "," << "PIXELOFFSET=" << bytePerPixel * nbBands << "," << "LINEOFFSET=" << bytePerPixel * nbBands * size[0] << "," << "BANDOFFSET=" << bytePerPixel; GDALDataset * maskDataset = static_cast (GDALOpen(maskstream.str().c_str(), GA_ReadOnly)); //Set input Projection ref and Geo transform to the dataset. maskDataset->SetProjection(this->GetInputMask()->GetProjectionRef().c_str()); projSize = this->GetInputMask()->GetGeoTransform().size(); //Set the geo transform of the input mask image (if any) // Reporting origin and spacing of the buffered region // the spacing is unchanged, the origin is relative to the buffered region bufferIndexOrigin = this->GetInputMask()->GetBufferedRegion().GetIndex(); this->GetInputMask()->TransformIndexToPhysicalPoint(bufferIndexOrigin, bufferOrigin); geoTransform[0] = bufferOrigin[0] - 0.5 * this->GetInputMask()->GetSpacing()[0]; geoTransform[3] = bufferOrigin[1] - 0.5 * this->GetInputMask()->GetSpacing()[1]; geoTransform[1] = this->GetInputMask()->GetSpacing()[0]; geoTransform[5] = this->GetInputMask()->GetSpacing()[1]; // FIXME: Here component 1 and 4 should be replaced by the orientation parameters if (projSize == 0) { geoTransform[2] = 0.; geoTransform[4] = 0.; } else { geoTransform[2] = this->GetInputMask()->GetGeoTransform()[2]; geoTransform[4] = this->GetInputMask()->GetGeoTransform()[4]; } maskDataset->SetGeoTransform(geoTransform); GDALPolygonize(dataset->GetRasterBand(1), maskDataset->GetRasterBand(1), &outputLayer.ogr(), 0, options, ITK_NULLPTR, ITK_NULLPTR); GDALClose(maskDataset); } else { GDALPolygonize(dataset->GetRasterBand(1), ITK_NULLPTR, &outputLayer.ogr(), 0, options, ITK_NULLPTR, ITK_NULLPTR); } this->SetNthOutput(0,ogrDS); //Clear memory GDALClose(dataset); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageToVectorDataFilter.h000066400000000000000000000107461301006202600315310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageToVectorDataFilter_h #define otbLabelImageToVectorDataFilter_h #include "otbVectorDataSource.h" #include "otbVectorData.h" #include "otbOGRDataSourceWrapper.h" namespace otb { /** \class LabelImageToVectorDataFilter * \brief this class uses GDALPolygonize method to transform a Label image into a VectorData. * An optional input mask can be used to exclude pixels from vectorization process. * All pixels with a value of 0 in the input mask image will not be suitable for vectorization. * \note The Use8Connected parameter can be turn on and it will be used in \c GDALPolygonize(). But be carreful, it * can create cross polygons ! * \note It is a non-streamed version. * \ingroup OBIA * * \ingroup OTBConversion */ template class ITK_EXPORT LabelImageToVectorDataFilter : public VectorDataSource< otb::VectorData > { public: /** typedef for the classes standards. */ typedef LabelImageToVectorDataFilter Self; typedef VectorDataSource< VectorData > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(LabelImageToVectorDataFilter, VectorDataSource); /** Definition of the input image */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SpacingType SpacingType; typedef typename InputImageType::PointType OriginType; typedef typename InputImageType::IndexType IndexType; /** Definition of the output vector data. */ typedef VectorData VectorDataType; typedef typename VectorDataType::Pointer VectorDataPointerType; typedef typename VectorDataType::DataTreeType DataTreeType; typedef typename DataTreeType::Pointer DataTreePointerType; typedef typename DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename VectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef typename VectorDataType::LineType LineType; typedef typename VectorDataType::PointType PointType; typedef typename LineType::VertexType VertexType; typedef ogr::DataSource OGRDataSourceType; typedef typename OGRDataSourceType::Pointer OGRDataSourcePointerType; typedef ogr::Layer OGRLayerType; /** Set/Get the input image of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputImageType *input); virtual const InputImageType * GetInput(void); /** Set the input mask image. * All pixels in the mask with a value of 0 will not be considered * suitable for vectorization. */ virtual void SetInputMask(const InputImageType *input); virtual const InputImageType * GetInputMask(void); itkSetMacro(FieldName, std::string); itkGetMacro(FieldName, std::string); itkSetMacro(Use8Connected, bool); itkGetMacro(Use8Connected, bool); protected: LabelImageToVectorDataFilter(); ~LabelImageToVectorDataFilter() ITK_OVERRIDE {} void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Generate Data method*/ void GenerateData() ITK_OVERRIDE; private: LabelImageToVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string m_FieldName; bool m_Use8Connected; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelImageToVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelImageToVectorDataFilter.txx000066400000000000000000000247321301006202600321250ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelImageToVectorDataFilter_txx #define otbLabelImageToVectorDataFilter_txx #include "otbLabelImageToVectorDataFilter.h" #include "otbOGRIOHelper.h" #include "itkImageRegionIterator.h" #include "otbGdalDataTypeBridge.h" //gdal libraries #include "gdal.h" #include "gdal_priv.h" #include "cpl_conv.h" #include "gdal_alg.h" namespace otb { template LabelImageToVectorDataFilter ::LabelImageToVectorDataFilter() : m_FieldName("DN"), m_Use8Connected(false) { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(1); GDALAllRegister(); } template void LabelImageToVectorDataFilter ::SetInput(const InputImageType *input) { this->Superclass::SetNthInput(0, const_cast(input)); } template const typename LabelImageToVectorDataFilter ::InputImageType * LabelImageToVectorDataFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(0)); } template void LabelImageToVectorDataFilter ::SetInputMask(const InputImageType *input) { this->Superclass::SetNthInput(1, const_cast(input)); } template const typename LabelImageToVectorDataFilter ::InputImageType * LabelImageToVectorDataFilter ::GetInputMask(void) { if (this->GetNumberOfInputs() < 2) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(1)); } template void LabelImageToVectorDataFilter ::GenerateInputRequestedRegion(void) { // call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // get pointers to the inputs typename InputImageType::Pointer input = const_cast (this->GetInput()); if ( !input ) { return; } // The input is necessarily the largest possible region. input->SetRequestedRegionToLargestPossibleRegion(); typename InputImageType::Pointer mask = const_cast (this->GetInputMask()); if(!mask) { return; } // The input is necessarily the largest possible region. mask->SetRequestedRegionToLargestPossibleRegion(); } template void LabelImageToVectorDataFilter ::GenerateData(void) { if (this->GetInput()->GetRequestedRegion() != this->GetInput()->GetLargestPossibleRegion()) { itkExceptionMacro(<< "Not streamed filter. ERROR : requested region is not the largest possible region."); } typename InputImageType::Pointer inImage = const_cast(this->GetInput()); SizeType size = this->GetInput()->GetLargestPossibleRegion().GetSize(); unsigned int nbBands = this->GetInput()->GetNumberOfComponentsPerPixel(); unsigned int bytePerPixel = sizeof(InputPixelType); /** Convert Input image into a OGRLayer using GDALPolygonize */ // buffer casted in unsigned long cause under Win32 the address // don't begin with 0x, the address in not interpreted as // hexadecimal but alpha numeric value, then the conversion to // integer make us pointing to an non allowed memory block => Crash. std::ostringstream stream; stream << "MEM:::" << "DATAPOINTER=" << (unsigned long)(GUIntBig)(this->GetInput()->GetBufferPointer()) << "," << "PIXELS=" << size[0] << "," << "LINES=" << size[1] << "," << "BANDS=" << nbBands << "," << "DATATYPE=" << GDALGetDataTypeName(GdalDataTypeBridge::GetGDALDataType()) << "," << "PIXELOFFSET=" << bytePerPixel * nbBands << "," << "LINEOFFSET=" << bytePerPixel * nbBands * size[0] << "," << "BANDOFFSET=" << bytePerPixel; GDALDataset * dataset = static_cast (GDALOpen(stream.str().c_str(), GA_ReadOnly)); //Set input Projection ref and Geo transform to the dataset. dataset->SetProjection(this->GetInput()->GetProjectionRef().c_str()); unsigned int projSize = this->GetInput()->GetGeoTransform().size(); double geoTransform[6]; //Set the geo transform of the input image (if any) // Reporting origin and spacing of the buffered region // the spacing is unchanged, the origin is relative to the buffered region IndexType bufferIndexOrigin = this->GetInput()->GetBufferedRegion().GetIndex(); OriginType bufferOrigin; this->GetInput()->TransformIndexToPhysicalPoint(bufferIndexOrigin, bufferOrigin); geoTransform[0] = bufferOrigin[0] - 0.5 * this->GetInput()->GetSpacing()[0]; geoTransform[3] = bufferOrigin[1] - 0.5 * this->GetInput()->GetSpacing()[1]; geoTransform[1] = this->GetInput()->GetSpacing()[0]; geoTransform[5] = this->GetInput()->GetSpacing()[1]; // FIXME: Here component 1 and 4 should be replaced by the orientation parameters if (projSize == 0) { geoTransform[2] = 0.; geoTransform[4] = 0.; } else { geoTransform[2] = this->GetInput()->GetGeoTransform()[2]; geoTransform[4] = this->GetInput()->GetGeoTransform()[4]; } dataset->SetGeoTransform(geoTransform); //Create the output layer for GDALPolygonize(). ogr::DataSource::Pointer ogrDS = ogr::DataSource::New(); OGRLayerType outputLayer = ogrDS->CreateLayer("layer",ITK_NULLPTR,wkbPolygon); OGRFieldDefn field(m_FieldName.c_str(),OFTInteger); outputLayer.CreateField(field, true); //Call GDALPolygonize() char ** options; options = ITK_NULLPTR; char * option[1]; if (m_Use8Connected == true) { std::string opt("8CONNECTED:8"); option[0] = const_cast(opt.c_str()); options=option; } /* Convert the mask input into a GDAL raster needed by GDALPolygonize */ typename InputImageType::ConstPointer inputMask = this->GetInputMask(); if (!inputMask.IsNull()) { size = this->GetInputMask()->GetLargestPossibleRegion().GetSize(); nbBands = this->GetInputMask()->GetNumberOfComponentsPerPixel(); bytePerPixel = sizeof(InputPixelType); // buffer casted in unsigned long cause under Win32 the address // don't begin with 0x, the address in not interpreted as // hexadecimal but alpha numeric value, then the conversion to // integer make us pointing to an non allowed memory block => Crash. std::ostringstream maskstream; maskstream << "MEM:::" << "DATAPOINTER=" << (unsigned long) (GUIntBig) (this->GetInputMask()->GetBufferPointer()) << "," << "PIXELS=" << size[0] << "," << "LINES=" << size[1] << "," << "BANDS=" << nbBands << "," << "DATATYPE=" << GDALGetDataTypeName(GdalDataTypeBridge::GetGDALDataType()) << "," << "PIXELOFFSET=" << bytePerPixel * nbBands << "," << "LINEOFFSET=" << bytePerPixel * nbBands * size[0] << "," << "BANDOFFSET=" << bytePerPixel; GDALDataset * maskDataset = static_cast (GDALOpen(maskstream.str().c_str(), GA_ReadOnly)); //Set input Projection ref and Geo transform to the dataset. maskDataset->SetProjection(this->GetInputMask()->GetProjectionRef().c_str()); projSize = this->GetInputMask()->GetGeoTransform().size(); //Set the geo transform of the input mask image (if any) // Reporting origin and spacing of the buffered region // the spacing is unchanged, the origin is relative to the buffered region bufferIndexOrigin = this->GetInputMask()->GetBufferedRegion().GetIndex(); this->GetInputMask()->TransformIndexToPhysicalPoint(bufferIndexOrigin, bufferOrigin); geoTransform[0] = bufferOrigin[0] - 0.5 * this->GetInputMask()->GetSpacing()[0]; geoTransform[3] = bufferOrigin[1] - 0.5 * this->GetInputMask()->GetSpacing()[1]; geoTransform[1] = this->GetInputMask()->GetSpacing()[0]; geoTransform[5] = this->GetInputMask()->GetSpacing()[1]; // FIXME: Here component 1 and 4 should be replaced by the orientation parameters if (projSize == 0) { geoTransform[2] = 0.; geoTransform[4] = 0.; } else { geoTransform[2] = this->GetInputMask()->GetGeoTransform()[2]; geoTransform[4] = this->GetInputMask()->GetGeoTransform()[4]; } maskDataset->SetGeoTransform(geoTransform); GDALPolygonize(dataset->GetRasterBand(1), maskDataset->GetRasterBand(1), &outputLayer.ogr(), 0, options, ITK_NULLPTR, ITK_NULLPTR); GDALClose(maskDataset); } else { GDALPolygonize(dataset->GetRasterBand(1), ITK_NULLPTR, &outputLayer.ogr(), 0, options, ITK_NULLPTR, ITK_NULLPTR); } /** Convert OGR layer into VectorData */ // Create the document node DataNodePointerType document = DataNodeType::New(); document->SetNodeType(DOCUMENT); document->SetNodeId(outputLayer.GetLayerDefn().GetName()); // Adding the layer to the data tree VectorDataPointerType data = dynamic_cast(this->GetOutput()); data->SetProjectionRef(this->GetInput()->GetProjectionRef()); DataTreePointerType tree = data->GetDataTree(); DataNodePointerType root = tree->GetRoot()->Get(); tree->Add(document, root); //This is not good but we do not have the choice if we want to //get a hook on the internal structure InternalTreeNodeType * documentPtr = const_cast(tree->GetNode(document)); OGRIOHelper::Pointer OGRConversion = OGRIOHelper::New(); OGRConversion->ConvertOGRLayerToDataTreeNode(&outputLayer.ogr(), documentPtr); //Clear memory GDALClose(dataset); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelMapToVectorDataFilter.h000066400000000000000000000111241301006202600312130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToVectorDataFilter_h #define otbLabelMapToVectorDataFilter_h #include "otbVectorDataSource.h" #include "itkLabelMap.h" #include "otbLabelObjectFieldsFunctor.h" #include "otbLabelObjectToPolygonFunctor.h" #include "otbCorrectPolygonFunctor.h" #include "otbDataNode.h" #include #include namespace otb { /** \class LabelMapToVectorDataFilter * \brief This class vectorizes a LabelObject to a VectorData. * * LabelMapToVectorDataFilter converts a LabelMap to a * VectorData where all the pixels get the attribute value of the label object they belong. * It uses the class otbLabelObjectToPolygonFunctor which follows a finite states machine described in * * "An algorithm for the rapid computation of boundaries of run-length * encoded regions", Francis K. H. Queck, in Pattern Recognition 33 * (2000), p 1637-1649. * * Note : the output vector data contains index coordinates (not physical coordinates). * For instance, a polygon around the pixel at index (0,0) would have the following * points : [-0.5,-0.5] , [0.5,-0.5] , [0.5,0.5] , [-0.5,0.5] * * \sa VectorDataSource * \ingroup GeoSpatialAnalysis * * \ingroup OTBConversion */ template > class ITK_EXPORT LabelMapToVectorDataFilter : public VectorDataSource { public: /** Standard class typedefs. */ typedef LabelMapToVectorDataFilter Self; typedef VectorDataSource Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TLabelMap InputLabelMapType; typedef TVectorData OutputVectorDataType; typedef TFieldsFunctor FieldsFunctorType; typedef typename OutputVectorDataType::Pointer OutputVectorDataPointer; typedef typename OutputVectorDataType::ConstPointer OutputVectorDataConstPointer; typedef typename InputLabelMapType::LabelObjectType LabelObjectType; typedef typename InputLabelMapType::ConstIterator ConstIteratorType; typedef typename OutputVectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; /** Some typedefs specific to functors*/ typedef otb::Functor::LabelObjectToPolygonFunctor FunctorType; typedef otb::CorrectPolygonFunctor CorrectFunctorType; /** Standard New method. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(LabelMapToVectorDataFilter, VectorDataSource); /** Set/Get the LabelMap input of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputLabelMapType *input); virtual void SetInput(unsigned int idx, const InputLabelMapType *input); const InputLabelMapType * GetInput(void); const InputLabelMapType * GetInput(unsigned int idx); /* Set the functor used to provide additional OGR fields */ void SetFieldsFunctor(const FieldsFunctorType& functor) { m_FieldsFunctor = functor; this->Modified(); } /* Get the functor used to provide additional OGR fields */ FieldsFunctorType& GetFieldsFunctor() { return m_FieldsFunctor; } protected: LabelMapToVectorDataFilter(); ~LabelMapToVectorDataFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: LabelMapToVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented FieldsFunctorType m_FieldsFunctor; }; // end of class } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelMapToVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbLabelMapToVectorDataFilter.txx000066400000000000000000000114151301006202600316120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelMapToVectorDataFilter_txx #define otbLabelMapToVectorDataFilter_txx #include "otbLabelMapToVectorDataFilter.h" namespace otb { template LabelMapToVectorDataFilter ::LabelMapToVectorDataFilter() { /* m_BackgroundValue = NumericTraits::NonpositiveMin(); */ } template void LabelMapToVectorDataFilter ::SetInput(const InputLabelMapType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template void LabelMapToVectorDataFilter ::SetInput(unsigned int idx, const InputLabelMapType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(idx, const_cast(input)); } template const typename LabelMapToVectorDataFilter::InputLabelMapType * LabelMapToVectorDataFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template const typename LabelMapToVectorDataFilter::InputLabelMapType * LabelMapToVectorDataFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } template void LabelMapToVectorDataFilter ::GenerateData() { OutputVectorDataType * output = this->GetOutput(); const InputLabelMapType * input = this->GetInput(); FunctorType functor; CorrectFunctorType correctFunctor; /**Create usual root elements of the output vectordata*/ DataNodePointerType document = DataNodeType::New(); DataNodePointerType folder1 = DataNodeType::New(); document->SetNodeType(DOCUMENT); folder1->SetNodeType(FOLDER); DataNodePointerType root = output->GetDataTree()->GetRoot()->Get(); output->GetDataTree()->Add(document, root); output->GetDataTree()->Add(folder1, document); // Lets begin by declaring the iterator for the objects in the image. ConstIteratorType it = ConstIteratorType( input ); while ( !it.IsAtEnd() ) { /**the label object*/ const LabelObjectType * labelObject = it.GetLabelObject(); /**Get the polygon image of the labelobject using the functor*/ typename PolygonType::Pointer polygon = functor(const_cast (labelObject)); /**correct polygon if necessary*/ PolygonPointerType correctPolygon = correctFunctor(polygon); DataNodePointerType node = DataNodeType::New(); node->SetNodeType(otb::FEATURE_POLYGON); /**Store the label in the NodeId*/ std::ostringstream oss; oss << labelObject->GetLabel(); node->SetNodeId(oss.str()); //TODO hole in the polygon are not handle yet by the functor node->SetPolygonExteriorRing(correctPolygon); /** Store additional fields given by functor */ std::map fields = m_FieldsFunctor(const_cast (labelObject)); std::map::const_iterator it2; for ( it2 = fields.begin(); it2 != fields.end(); ++it2 ) { node->SetFieldAsString(it2->first, it2->second); } /**Add the polygon to the VectorData*/ output->GetDataTree()->Add(node, folder1); ++it; } } template void LabelMapToVectorDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbOGRDataSourceToLabelImageFilter.h000066400000000000000000000146321301006202600320750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDataSourceToLabelImageFilter_h #define otbOGRDataSourceToLabelImageFilter_h #include "itkImageToImageFilter.h" #include "otbMacro.h" #include "gdal.h" #include "gdal_alg.h" #include "otbOGRDataSourceWrapper.h" namespace otb { /** \class OGRDataSourceToLabelImageFilter * \brief Burn geometries from the specified VectorData into raster * * This class handles burning several input \c OGRDataSource into the * output raster. It has two different modes: * - either the burn values are extracted from a field set by * the user (default field is DN). This is the default behaviour, * - or the burn values are made of foreground (when inside * geometries) and background (outside geometries) values, which can * be set by the user. One can set this behaviour by disable the * BurnAttributeMode using the BurnAttributeModeOff() method. * * Please note that the background value is also used in * BurnAttributeModeOn() to fill areas where there are no geometries. * * Setting the output raster information can be done in two ways by: * - Setting the Origin/Size/Spacing of the output image * - Using an existing image as support via SetOutputParametersFromImage(ImageBase) * * * \ingroup OTBConversion */ template < class TOutputImage > class ITK_EXPORT OGRDataSourceToLabelImageFilter : public itk::ImageSource { public: /** Standard class typedefs */ typedef OGRDataSourceToLabelImageFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(OGRDataSourceToLabelImageFilter, itk::ImageSource); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::SpacingType OutputSpacingType; typedef typename OutputImageType::PointType OutputOriginType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::InternalPixelType OutputImageInternalPixelType; /** VectorData typedefs*/ typedef ogr::DataSource OGRDataSourceType; typedef typename OGRDataSourceType::Pointer OGRDataSourcePointerType; typedef ogr::Layer OGRLayerType; typedef itk::ImageBase ImageBaseType; /** Get Nth input \c OGRDataSource */ const OGRDataSourceType* GetInput(unsigned int idx); /** Method for adding a \c OGRDataSource to rasterize */ virtual void AddOGRDataSource(const OGRDataSourceType* ds); /** Set the size of the output image. */ itkSetMacro(OutputSize, OutputSizeType); /** Get the size of the output image. */ itkGetConstReferenceMacro(OutputSize, OutputSizeType); /** Set the origin of the output image. * \sa GetOrigin() */ itkSetMacro(OutputOrigin, OutputOriginType); virtual void SetOutputOrigin(const double origin[2]); virtual void SetOutputOrigin(const float origin[2]); itkGetConstReferenceMacro(OutputOrigin, OutputOriginType); /** Set the spacing (size of a pixel) of the output image. * \sa GetSpacing() */ virtual void SetOutputSpacing(const OutputSpacingType& spacing); virtual void SetOutputSpacing(const double spacing[2]); virtual void SetOutputSpacing(const float spacing[2]); /** Set/Get Output Projection Ref */ itkSetStringMacro(OutputProjectionRef); itkGetStringMacro(OutputProjectionRef); /** Set the attribute field on the \c OGRFeature to be used as burn value in the output image*/ itkSetStringMacro(BurnAttribute); itkGetStringMacro(BurnAttribute); /** Set/Get the background value */ itkSetMacro(BackgroundValue,OutputImageInternalPixelType); itkGetConstReferenceMacro(BackgroundValue,OutputImageInternalPixelType); /** Set/Get the foreground value */ itkSetMacro(ForegroundValue,OutputImageInternalPixelType); itkGetConstReferenceMacro(ForegroundValue,OutputImageInternalPixelType); /** Set/Get the BurnAttributeMode flag */ itkSetMacro(BurnAttributeMode,bool); itkGetConstReferenceMacro(BurnAttributeMode,bool); itkBooleanMacro(BurnAttributeMode); /** Useful to set the output parameters from an existing image*/ void SetOutputParametersFromImage(const ImageBaseType * image); protected: void GenerateData() ITK_OVERRIDE; OGRDataSourceToLabelImageFilter(); ~OGRDataSourceToLabelImageFilter() ITK_OVERRIDE {} void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: OGRDataSourceToLabelImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented std::vector< OGRLayerH > m_SrcDataSetLayers; std::vector m_BandsToBurn; // Field used to extract the burn value std::string m_BurnAttribute; // Output params std::string m_OutputProjectionRef; OutputSpacingType m_OutputSpacing; OutputOriginType m_OutputOrigin; OutputSizeType m_OutputSize; OutputIndexType m_OutputStartIndex; OutputImageInternalPixelType m_BackgroundValue; OutputImageInternalPixelType m_ForegroundValue; bool m_BurnAttributeMode; }; // end of class VectorDataToLabelImageFilter } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOGRDataSourceToLabelImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbOGRDataSourceToLabelImageFilter.txx000066400000000000000000000212101301006202600324570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRDataSourceToLabelImageFilter_txx #define otbOGRDataSourceToLabelImageFilter_txx #include "otbOGRDataSourceToLabelImageFilter.h" #include "otbOGRIOHelper.h" #include "otbGdalDataTypeBridge.h" #include "otbImageMetadataInterfaceFactory.h" #include "itkMetaDataObject.h" #include "otbMetaDataKey.h" #include "gdal_alg.h" #include "stdint.h" //needed for uintptr_t namespace otb { template< class TOutputImage> OGRDataSourceToLabelImageFilter ::OGRDataSourceToLabelImageFilter() : m_BurnAttribute("DN"), m_BackgroundValue(0), m_ForegroundValue(255), m_BurnAttributeMode(true) { this->SetNumberOfRequiredInputs(1); // Output parameters initialization m_OutputSpacing.Fill(1.0); m_OutputSize.Fill(0); m_OutputStartIndex.Fill(0); m_BandsToBurn.clear(); m_BandsToBurn.push_back(1); } template< class TOutputImage> void OGRDataSourceToLabelImageFilter ::AddOGRDataSource(const OGRDataSourceType* ds) { this->itk::ProcessObject::PushBackInput( ds ); } template < class TOutputImage> const typename OGRDataSourceToLabelImageFilter::OGRDataSourceType * OGRDataSourceToLabelImageFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } template < class TOutputImage> void OGRDataSourceToLabelImageFilter ::SetOutputSpacing(const OutputSpacingType& spacing) { if (this->m_OutputSpacing != spacing) { this->m_OutputSpacing = spacing; this->Modified(); } } template < class TOutputImage> void OGRDataSourceToLabelImageFilter ::SetOutputSpacing(const double spacing[2]) { OutputSpacingType s(spacing); this->SetOutputSpacing(s); } template < class TOutputImage> void OGRDataSourceToLabelImageFilter ::SetOutputSpacing(const float spacing[2]) { itk::Vector sf(spacing); OutputSpacingType s; s.CastFrom(sf); this->SetOutputSpacing(s); } template < class TOutputImage> void OGRDataSourceToLabelImageFilter ::SetOutputOrigin(const double origin[2]) { OutputOriginType p(origin); this->SetOutputOrigin(p); } template < class TOutputImage> void OGRDataSourceToLabelImageFilter ::SetOutputOrigin(const float origin[2]) { itk::Point of(origin); OutputOriginType p; p.CastFrom(of); this->SetOutputOrigin(p); } template < class TOutputImage> void OGRDataSourceToLabelImageFilter ::SetOutputParametersFromImage(const ImageBaseType * image) { this->SetOutputOrigin ( image->GetOrigin() ); this->SetOutputSpacing ( image->GetSpacing() ); this->SetOutputSize ( image->GetLargestPossibleRegion().GetSize() ); ImageMetadataInterfaceBase::Pointer imi = ImageMetadataInterfaceFactory::CreateIMI(image->GetMetaDataDictionary()); this->SetOutputProjectionRef(imi->GetProjectionRef()); } template< class TOutputImage> void OGRDataSourceToLabelImageFilter ::GenerateOutputInformation() { // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); if (!outputPtr) { return; } // Set the size of the output region typename TOutputImage::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(m_OutputSize); //outputLargestPossibleRegion.SetIndex(m_OutputStartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); // Set spacing and origin outputPtr->SetSpacing(m_OutputSpacing); outputPtr->SetOrigin(m_OutputOrigin); itk::MetaDataDictionary& dict = outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData (dict, MetaDataKey::ProjectionRefKey, static_cast(this->GetOutputProjectionRef())); // Generate the OGRLayers from the input OGRDataSource for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { OGRDataSourcePointerType ogrDS = dynamic_cast(this->itk::ProcessObject::GetInput(idx)); const unsigned int nbLayers = ogrDS->GetLayersCount(); for (unsigned int layer = 0; layer < nbLayers; ++layer) { m_SrcDataSetLayers.push_back( &(ogrDS->GetLayer(layer).ogr()) ); } } // Set the NoData value using the background const unsigned int & nbBands = outputPtr->GetNumberOfComponentsPerPixel(); std::vector noDataValueAvailable; noDataValueAvailable.resize(nbBands,true); std::vector noDataValue; noDataValue.resize(nbBands,static_cast(m_BackgroundValue)); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValueAvailable,noDataValueAvailable); itk::EncapsulateMetaData >(dict,MetaDataKey::NoDataValue,noDataValue); } template< class TOutputImage> void OGRDataSourceToLabelImageFilter::GenerateData() { // Call Superclass GenerateData this->AllocateOutputs(); // Get the buffered region OutputImageRegionType bufferedRegion = this->GetOutput()->GetBufferedRegion(); // nb bands const unsigned int & nbBands = this->GetOutput()->GetNumberOfComponentsPerPixel(); // register drivers GDALAllRegister(); std::ostringstream stream; stream << "MEM:::" << "DATAPOINTER=" << (uintptr_t)(this->GetOutput()->GetBufferPointer()) << "," << "PIXELS=" << bufferedRegion.GetSize()[0] << "," << "LINES=" << bufferedRegion.GetSize()[1]<< "," << "BANDS=" << nbBands << "," << "DATATYPE=" << GDALGetDataTypeName(GdalDataTypeBridge::GetGDALDataType()) << "," << "PIXELOFFSET=" << sizeof(OutputImageInternalPixelType) * nbBands << "," << "LINEOFFSET=" << sizeof(OutputImageInternalPixelType)*nbBands*bufferedRegion.GetSize()[0] << "," << "BANDOFFSET=" << sizeof(OutputImageInternalPixelType); GDALDatasetH dataset = GDALOpen(stream.str().c_str(), GA_Update); // Add the projection ref to the dataset GDALSetProjection (dataset, this->GetOutput()->GetProjectionRef().c_str()); // Set the nodata value for(unsigned int band = 0; band < nbBands; ++band) { GDALRasterBandH hBand = GDALGetRasterBand(dataset, band + 1); GDALFillRaster(hBand, m_BackgroundValue, 0); } // add the geoTransform to the dataset itk::VariableLengthVector geoTransform(6); // Reporting origin and spacing of the buffered region // the spacing is unchanged, the origin is relative to the buffered region OutputIndexType bufferIndexOrigin = bufferedRegion.GetIndex(); OutputOriginType bufferOrigin; this->GetOutput()->TransformIndexToPhysicalPoint(bufferIndexOrigin, bufferOrigin); geoTransform[0] = bufferOrigin[0] - 0.5 * this->GetOutput()->GetSpacing()[0]; geoTransform[3] = bufferOrigin[1] - 0.5 * this->GetOutput()->GetSpacing()[1]; geoTransform[1] = this->GetOutput()->GetSpacing()[0]; geoTransform[5] = this->GetOutput()->GetSpacing()[1]; // FIXME: Here component 1 and 4 should be replaced by the orientation parameters geoTransform[2] = 0.; geoTransform[4] = 0.; GDALSetGeoTransform(dataset,const_cast(geoTransform.GetDataPointer())); // Burn the geometries into the dataset if (dataset != ITK_NULLPTR) { std::vector options; std::vector foreground(nbBands*m_SrcDataSetLayers.size(),m_ForegroundValue); if(m_BurnAttributeMode) { options.push_back("ATTRIBUTE="+m_BurnAttribute); } GDALRasterizeLayers( dataset, nbBands, &m_BandsToBurn[0], m_SrcDataSetLayers.size(), &(m_SrcDataSetLayers[0]), ITK_NULLPTR, ITK_NULLPTR, &foreground[0], ogr::StringListConverter(options).to_ogr(), ITK_NULLPTR, ITK_NULLPTR ); // release the dataset GDALClose( dataset ); } } template< class TOutputImage> void OGRDataSourceToLabelImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbPersistentImageToOGRDataFilter.h000066400000000000000000000132011301006202600320240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentImageToOGRDataFilter_h #define otbPersistentImageToOGRDataFilter_h #include "otbPersistentImageFilter.h" #include "otbLabelImageToOGRDataSourceFilter.h" #include "itkMacro.h" #include namespace otb { /** \class PersistentImageToOGRDataFilter * \brief Perform vectorization in a persistent way. * * This filter is a generic filter. It is the base class of the Large scale segmentation framework. * The \c Initialize() method is used to create the new layer (LayerName) in the input \c OGRDataSource, * and the field (FieldName) in the layer. This field will contain the label of the polygon in the input image. * The \c ProcessTile() method is pure virtual and is implemented in sub class * (@see \c PersistentStreamingLabelImageToOGRDataFilter). It returns a "memory" DataSource. * This filter only copy each feature of the layer in the "memory" DataSource into the LayerName layer in the * input \c OGRDataSource set by \c SetOGRDataSource() method. * * \sa PersistentImageFilter * * * \ingroup OTBConversion */ template class ITK_EXPORT PersistentImageToOGRDataFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentImageToOGRDataFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Runtime information support. */ itkTypeMacro(PersistentImageToOGRDataFilter, PersistentImageFilter); typedef TImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType InternalPixelType; typedef ogr::DataSource OGRDataSourceType; typedef typename OGRDataSourceType::Pointer OGRDataSourcePointerType; typedef ogr::Layer OGRLayerType; typedef ogr::Feature OGRFeatureType; void AllocateOutputs(); virtual void Reset(void); virtual void Synthetize(void); /** This method creates the output layer in the OGRDataSource set by the user. * The name of the layer is set by \c SetLayerName . * \note This methode must be called before the call of Update . */ virtual void Initialize(void); /** Set/Get the name of the output layer to write in the \c ogr::DataSource. */ itkSetStringMacro(LayerName); itkGetStringMacro(LayerName); /** Set the Field Name in which labels will be written. (default is "DN") * A field FieldName is created in the output layer LayerName. The Field type is Integer. */ itkSetMacro(FieldName, std::string); /** * Return the Field name in which labels have been written. */ itkGetMacro(FieldName, std::string); /** Get the size of the tile used for streaming. * This is useful if you use for example the \c OGRFusionTileFilter * for fusioning streaming tiles. */ itkGetMacro(StreamSize, SizeType); /** Set the geometry type */ itkSetMacro(GeometryType,OGRwkbGeometryType); /** Get the geometry type */ itkGetMacro(GeometryType,OGRwkbGeometryType); /** Set the \c ogr::DataSource in which the layer LayerName will be created. */ void SetOGRDataSource( OGRDataSourcePointerType ogrDS ); /** Get the \c ogr::DataSource output. */ OGRDataSourceType * GetOGRDataSource( void ); /** Add one option for OGR layer creation */ void AddOGRLayerCreationOption(const std::string& option); /** Clear all OGR layer creation options */ void ClearOGRLayerCreationOptions(); /** Set the OGR layer creation options */ void SetOGRLayerCreationOptions(const std::vector & options); /** Get the OGR layer creation options */ const std::vector & GetOGRLayerCreationOptions(void); /** Set the field type for class label */ itkSetMacro(FieldType,OGRFieldType); /** Get the field type for class label */ itkGetMacro(FieldType,OGRFieldType); protected: PersistentImageToOGRDataFilter(); virtual ~PersistentImageToOGRDataFilter(); void PrintSelf(std::ostream& os, itk::Indent indent) const; virtual void GenerateData(); private: PersistentImageToOGRDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented virtual OGRDataSourcePointerType ProcessTile() = 0; std::string m_FieldName; std::string m_LayerName; OGRwkbGeometryType m_GeometryType; SizeType m_StreamSize; std::vector m_OGRLayerCreationOptions; OGRFieldType m_FieldType; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPersistentImageToOGRDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbPersistentImageToOGRDataFilter.txx000066400000000000000000000121601301006202600324230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentImageToOGRDataFilter_txx #define otbPersistentImageToOGRDataFilter_txx #include "otbPersistentImageToOGRDataFilter.h" #include "itkTimeProbe.h" #include #include #include "otbMacro.h" #include "otbOGRHelpers.h" namespace otb { template PersistentImageToOGRDataFilter ::PersistentImageToOGRDataFilter() : m_FieldName("DN") , m_LayerName("Layer") , m_GeometryType(wkbMultiPolygon) , m_FieldType(OFTInteger) { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(2); m_StreamSize.Fill(0); } template PersistentImageToOGRDataFilter ::~PersistentImageToOGRDataFilter() { } template void PersistentImageToOGRDataFilter ::SetOGRDataSource( OGRDataSourcePointerType ogrDS ) { this->itk::ProcessObject::SetNthInput(1, ogrDS); } template typename PersistentImageToOGRDataFilter::OGRDataSourceType * PersistentImageToOGRDataFilter ::GetOGRDataSource( void ) { return static_cast (this->itk::ProcessObject::GetInput(1)); } template void PersistentImageToOGRDataFilter ::AddOGRLayerCreationOption(const std::string& option) { m_OGRLayerCreationOptions.push_back(option); this->Modified(); } template void PersistentImageToOGRDataFilter ::ClearOGRLayerCreationOptions() { m_OGRLayerCreationOptions.clear(); this->Modified(); } template void PersistentImageToOGRDataFilter ::SetOGRLayerCreationOptions(const std::vector& options) { m_OGRLayerCreationOptions = options; this->Modified(); } template const std::vector& PersistentImageToOGRDataFilter ::GetOGRLayerCreationOptions(void) { return m_OGRLayerCreationOptions; } template void PersistentImageToOGRDataFilter ::AllocateOutputs() { // Nothing that needs to be allocated for the outputs : the output is not meant to be used } template void PersistentImageToOGRDataFilter ::Reset() { } template void PersistentImageToOGRDataFilter ::Synthetize() { } template void PersistentImageToOGRDataFilter ::Initialize() { std::string projectionRefWkt = this->GetInput()->GetProjectionRef(); bool projectionInformationAvailable = !projectionRefWkt.empty(); OGRSpatialReference * oSRS = NULL; if(projectionInformationAvailable) { oSRS = static_cast(OSRNewSpatialReference(projectionRefWkt.c_str())); } OGRDataSourcePointerType ogrDS = this->GetOGRDataSource(); OGRLayerType outLayer = ogrDS->CreateLayer(m_LayerName, oSRS ,m_GeometryType, m_OGRLayerCreationOptions); OGRFieldDefn field(m_FieldName.c_str(),m_FieldType); outLayer.CreateField(field, true); } template void PersistentImageToOGRDataFilter ::GenerateData() { if (this->GetStreamSize()[0]==0 && this->GetStreamSize()[1]==0) { this->m_StreamSize = this->GetInput()->GetRequestedRegion().GetSize(); } // call the processing function for this tile OGRDataSourcePointerType currentTileVD = this->ProcessTile(); OGRLayerType srcLayer = currentTileVD->GetLayerChecked(0); OGRDataSourcePointerType ogrDS = this->GetOGRDataSource(); OGRLayerType dstLayer = ogrDS->GetLayersCount() == 1 ? ogrDS->GetLayer(0) : ogrDS->GetLayer(m_LayerName); //Copy features contained in the memory layer (srcLayer) in the output layer itk::TimeProbe chrono; chrono.Start(); OGRErr err = dstLayer.ogr().StartTransaction(); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Unable to start transaction for OGR layer " << dstLayer.ogr().GetName() << "."); } OGRLayerType::const_iterator featIt = srcLayer.begin(); for(; featIt!=srcLayer.end(); ++featIt) { OGRFeatureType dstFeature(dstLayer.GetLayerDefn()); dstFeature.SetFrom( *featIt, TRUE ); dstLayer.CreateFeature( dstFeature ); } err = dstLayer.ogr().CommitTransaction(); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Unable to commit transaction for OGR layer " << dstLayer.ogr().GetName() << "."); } chrono.Stop(); otbMsgDebugMacro(<< "write ogr tile took " << chrono.GetTotal() << " sec"); } template void PersistentImageToOGRDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbPersistentImageToOGRLayerFilter.h000066400000000000000000000101111301006202600322240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentImageToOGRLayerFilter_h #define otbPersistentImageToOGRLayerFilter_h #include "otbPersistentImageFilter.h" #include "otbLabelImageToOGRDataSourceFilter.h" #include "otbOGRLayerWrapper.h" #include "itkMacro.h" #include namespace otb { /** \class PersistentImageToOGRLayerFilter * \brief Perform vectorization in a persistent way. * * This filter is a generic filter. It is the base class of the Large scale segmentation framework. * The \c ProcessTile() method is pure virtual and is implemented in sub class * (@see \c PersistentStreamingLabelImageToOGRDataFilter). It returns a "memory" DataSource. * This filter only copy each feature of the layer in the "memory" DataSource into the * input \c OGRLayer set by \c SetOGRLayer() method. * * \sa PersistentImageFilter * * * \ingroup OTBConversion */ template class ITK_EXPORT PersistentImageToOGRLayerFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentImageToOGRLayerFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Runtime information support. */ itkTypeMacro(PersistentImageToOGRLayerFilter, PersistentImageFilter); typedef TImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType InternalPixelType; typedef ogr::DataSource OGRDataSourceType; typedef typename OGRDataSourceType::Pointer OGRDataSourcePointerType; typedef ogr::Layer OGRLayerType; typedef ogr::Feature OGRFeatureType; void AllocateOutputs() ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; /** This method creates the output layer in the OGRLayer set by the user. * \note This methode must be called before the call of Update . */ virtual void Initialize(void); /** Get the size of the tile used for streaming. * This is useful if you use for example the \c OGRFusionTileFilter * for fusioning streaming tiles. */ itkGetMacro(StreamSize, SizeType); /** Set the \c ogr::Layer in which the geometries will be dumped */ void SetOGRLayer( const OGRLayerType & ogrLayer ); /** Get the \c ogr::Layer output. */ const OGRLayerType & GetOGRLayer( void ) const; protected: PersistentImageToOGRLayerFilter(); ~PersistentImageToOGRLayerFilter() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: PersistentImageToOGRLayerFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented virtual OGRDataSourcePointerType ProcessTile() = 0; // The layer where to dump geometries OGRLayerType m_OGRLayer; SizeType m_StreamSize; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPersistentImageToOGRLayerFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbPersistentImageToOGRLayerFilter.txx000066400000000000000000000117311301006202600326310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentImageToOGRLayerFilter_txx #define otbPersistentImageToOGRLayerFilter_txx #include "otbPersistentImageToOGRLayerFilter.h" #include "itkTimeProbe.h" #include #include #include "otbMacro.h" #include "otbOGRHelpers.h" namespace otb { template PersistentImageToOGRLayerFilter ::PersistentImageToOGRLayerFilter() : m_OGRLayer(ITK_NULLPTR, false) { m_StreamSize.Fill(0); } template PersistentImageToOGRLayerFilter ::~PersistentImageToOGRLayerFilter() { } template void PersistentImageToOGRLayerFilter ::SetOGRLayer(const OGRLayerType & ogrLayer) { m_OGRLayer = ogrLayer; this->Modified(); } template const typename PersistentImageToOGRLayerFilter::OGRLayerType& PersistentImageToOGRLayerFilter ::GetOGRLayer( void ) const { return m_OGRLayer; } template void PersistentImageToOGRLayerFilter ::AllocateOutputs() { // Nothing that needs to be allocated for the outputs : the output is not meant to be used } template void PersistentImageToOGRLayerFilter ::Reset() { } template void PersistentImageToOGRLayerFilter ::Synthetize() { } template void PersistentImageToOGRLayerFilter ::Initialize() { // Make sure input projection ref is set const_cast (this->GetInput())->UpdateOutputInformation(); // Ensure that spatial reference of the output layer matches with // the spatial reference of the input image OGRSpatialReference oSRS(this->GetInput()->GetProjectionRef().c_str()); // when dealing with .shp OGRSPatialreference is morphed to ESRI WKT, // which results in small difference in WKT with some projection reference // so the comparison must be done with WKT and ESRI WKT Mantis #ref567 OGRSpatialReference oSRSESRI(this->GetInput()->GetProjectionRef().c_str()); oSRSESRI.morphToESRI(); oSRSESRI.morphFromESRI(); if (m_OGRLayer.GetSpatialRef() && (!oSRS.IsSame(m_OGRLayer.GetSpatialRef()) && !oSRSESRI.IsSame(m_OGRLayer.GetSpatialRef()))) { if ((oSRS.Validate() != OGRERR_NONE) && (oSRSESRI.Validate() != OGRERR_NONE)) { itkExceptionMacro(<<"Input projection ref is not valid"); } itkExceptionMacro(<<"Spatial reference of input image and target layer do not match! "<< std::endl << "Input image : "<< this->GetInput()->GetProjectionRef()<< std::endl << "Target layer : "< void PersistentImageToOGRLayerFilter ::GenerateData() { if(!m_OGRLayer) { itkExceptionMacro(<<"Output OGRLayer is null."); } if (this->GetStreamSize()[0]==0 && this->GetStreamSize()[1]==0) { this->m_StreamSize = this->GetInput()->GetRequestedRegion().GetSize(); } // call the processing function for this tile OGRDataSourcePointerType currentTileVD = this->ProcessTile(); OGRLayerType srcLayer = currentTileVD->GetLayerChecked(0); // Check spatial reference matches if(srcLayer.GetSpatialRef() && m_OGRLayer.GetSpatialRef() && !srcLayer.GetSpatialRef()->IsSame(m_OGRLayer.GetSpatialRef())) { itkExceptionMacro(<<"Spatial reference of internal and target layers do not match!"); } //Copy features contained in the memory layer (srcLayer) in the output layer itk::TimeProbe chrono; chrono.Start(); OGRErr err = m_OGRLayer.ogr().StartTransaction(); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Unable to start transaction for OGR layer " << m_OGRLayer.ogr().GetName() << "."); } OGRLayerType::const_iterator featIt = srcLayer.begin(); for(; featIt!=srcLayer.end(); ++featIt) { OGRFeatureType dstFeature(m_OGRLayer.GetLayerDefn()); dstFeature.SetFrom( *featIt, TRUE ); m_OGRLayer.CreateFeature( dstFeature ); } err = m_OGRLayer.ogr().CommitTransaction(); if (err != OGRERR_NONE) { itkExceptionMacro(<< "Unable to commit transaction for OGR layer " << m_OGRLayer.ogr().GetName() << "."); } chrono.Stop(); otbMsgDebugMacro(<< "write ogr tile took " << chrono.GetTotal() << " sec"); } template void PersistentImageToOGRLayerFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbPersistentImageToVectorDataFilter.h000066400000000000000000000103321301006202600326410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentImageToVectorDataFilter_h #define otbPersistentImageToVectorDataFilter_h #include "otbPersistentImageFilter.h" #include "itkExtractImageFilter.h" #include "otbConcatenateVectorDataFilter.h" #include "otbOGRVectorDataIO.h" #include "itkMacro.h" namespace otb { /** \class PersistentImageToVectorDataFilter * \brief Perform vectorization in a persistent way. * * This filter is a generic PersistentImageFilter, which encapsulate any filter * which produces VectorData from an input Image. * * It provides a default implementation which merge * the VectorData from the different tiles/strips used during streaming into * a single VectorData, which can be accessed via GetVectorData() * * \sa PersistentImageFilter * * * \ingroup OTBConversion */ template class ITK_EXPORT PersistentImageToVectorDataFilter : public PersistentImageFilter { public: /** Standard Self typedef */ typedef PersistentImageToVectorDataFilter Self; typedef PersistentImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Runtime information support. */ itkTypeMacro(PersistentImageToVectorDataFilter, PersistentImageFilter); typedef TImage InputImageType; typedef typename InputImageType::Pointer InputImagePointer; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::IndexType IndexType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::InternalPixelType InternalPixelType; typedef TOutputVectorData OutputVectorDataType; typedef typename TOutputVectorData::Pointer OutputVectorDataPointerType; typedef itk::ExtractImageFilter ExtractImageFilterType; typedef typename ExtractImageFilterType::Pointer ExtractImageFilterPointerType; typedef otb::ConcatenateVectorDataFilter ConcatenateVectorDataFilterType; typedef typename ConcatenateVectorDataFilterType::Pointer ConcatenateVectorDataFilterPointerType; typedef otb::OGRVectorDataIO OGRVectorDataIOType; typedef typename OGRVectorDataIOType::Pointer OGRVectorDataIOPointerType; /** Smart Pointer type to a DataObject. */ typedef itk::DataObject::Pointer DataObjectPointer; OutputVectorDataType* GetOutputVectorData() const; void AllocateOutputs() ITK_OVERRIDE; void Reset(void) ITK_OVERRIDE; void Synthetize(void) ITK_OVERRIDE; /** Specify the name of the output shapefile to write. */ itkSetStringMacro(FileName); itkGetStringMacro(FileName); protected: PersistentImageToVectorDataFilter(); ~PersistentImageToVectorDataFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; ExtractImageFilterPointerType m_ExtractFilter; OutputVectorDataPointerType m_OutputVectorData; private: PersistentImageToVectorDataFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented virtual OutputVectorDataPointerType ProcessTile() = 0; OGRVectorDataIOPointerType m_VectorDataIO; std::string m_FileName; }; // end of class } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbPersistentImageToVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbPersistentImageToVectorDataFilter.txx000066400000000000000000000067611301006202600332500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbPersistentImageToVectorDataFilter_txx #define otbPersistentImageToVectorDataFilter_txx #include "otbPersistentImageToVectorDataFilter.h" namespace otb { template PersistentImageToVectorDataFilter ::PersistentImageToVectorDataFilter() { m_ExtractFilter = ExtractImageFilterType::New(); m_OutputVectorData = OutputVectorDataType::New(); m_VectorDataIO = OGRVectorDataIOType::New(); } template typename PersistentImageToVectorDataFilter::OutputVectorDataType * PersistentImageToVectorDataFilter ::GetOutputVectorData() const { return m_OutputVectorData; } template void PersistentImageToVectorDataFilter ::AllocateOutputs() { // Nothing that needs to be allocated for the outputs : the output is not meant to be used } template void PersistentImageToVectorDataFilter ::Reset() { typedef typename OutputVectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; this->GetOutputVectorData()->Clear(); DataNodePointerType root = DataNodeType::New(); root->SetNodeId("Root"); this->GetOutputVectorData()->GetDataTree()->SetRoot(root); DataNodePointerType folder = DataNodeType::New(); folder->SetNodeType(otb::FOLDER); DataNodePointerType document = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); this->GetOutputVectorData()->GetDataTree()->Add(document, this->GetOutputVectorData()->GetDataTree()->GetRoot()->Get()); this->GetOutputVectorData()->GetDataTree()->Add(folder , document); } template void PersistentImageToVectorDataFilter ::Synthetize() { } template void PersistentImageToVectorDataFilter ::GenerateData() { // call the processing function for this tile OutputVectorDataPointerType currentTileVD = this->ProcessTile(); // merge the result into the output vector data object OutputVectorDataPointerType output = GetOutputVectorData(); ConcatenateVectorDataFilterPointerType concatenate = ConcatenateVectorDataFilterType::New(); concatenate->AddInput(output); concatenate->AddInput(currentTileVD); concatenate->Update(); concatenate->GetOutput()->SetMetaDataDictionary(currentTileVD->GetMetaDataDictionary()); // copy metadata and reference the same data tree output->Graft( concatenate->GetOutput() ); } template void PersistentImageToVectorDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbRasterizeVectorDataFilter.h000066400000000000000000000141511301006202600312060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRasterizeVectorDataFilter_h #define otbRasterizeVectorDataFilter_h #include "itkUnaryFunctorImageFilter.h" #include "itkImageToImageFilter.h" #include "itkCastImageFilter.h" #include "otbMacro.h" #include "otbVectorData.h" #include "gdal.h" #include "gdal_alg.h" #include "ogr_srs_api.h" #include "otbOGRVersionProxy.h" namespace otb { /** \class RasterizeVectorDataFilter * \brief Burn geometries from the specified VectorData into raster * * This class handles burning several input VectorDatas into the * input raster. It handles producing the output in any pixel type * supported by OTB since this class inherits itk::CastImageFilter. * * An explicit list of burn values for each layer for each band must * be passed in, if not, the burn vector set by the user will be * duplicated to fit this condition. * * The user can set an OutputPixelType as a burn vector via * AddBurnValue(OutputImagePixelType burnValuesPix). To have a * different color for each VectorData, use this method with * different burnValuesPix as many times as VectorDatas set. * Again, the color will be duplicated if only one burnValuesPix * is set. * * Note : The VectorDatas and the input raster must be in the same * projectionRef. Nothing is done in this class to reproject the * VectorData into the image coordinate system. * * \ingroup OTBConversion */ template class ITK_EXPORT RasterizeVectorDataFilter : public itk::CastImageFilter< TInputImage, TOutputImage> { public: /** Standard class typedefs */ typedef RasterizeVectorDataFilter Self; typedef itk::CastImageFilter Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ //itkTypeMacro(RasterizeVectorDataFilter, itk::InPlaceImageFilter); itkTypeMacro(RasterizeVectorDataFilter, itk::CastImageFilter); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::PointType InputPointType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::InternalPixelType OutputImageInternalPixelType; /** VectorData typedefs*/ typedef TVectorData VectorDataType; typedef typename VectorDataType::DataTreeType DataTreeType; typedef typename DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename DataTreeType::Pointer DataTreePointerType; typedef typename DataTreeType::ConstPointer DataTreeConstPointerType; typedef itk::DataObject DataObjectType; const InputImageType * GetInput(); const DataObjectType* GetInput(unsigned int idx); /** Add VectorData Input */ virtual void AddVectorData(const VectorDataType* vd); /** * Set the burn values using the output pixel type; all the bands * will be burned **/ void AddColor(const OutputImagePixelType& burnValuesPix) { // checking : If used several times, the user must always set // colors with the same size. unsigned int previousBandVectorSize = m_BandsToBurn.size(); if (previousBandVectorSize != 0) { if (burnValuesPix.Size() != previousBandVectorSize) { itkExceptionMacro(<< "The color added does not have the same number of elements than the previous " << "added one." << "( Previous color size : "<< previousBandVectorSize << ", new one size :"<< burnValuesPix.Size() << ")"); } } // Add the value stored in the output image pixel type to // the burn values vector // Add all the bands to be burned and clear previous bands. m_BandsToBurn.clear(); for (unsigned int idx = 0; idx < burnValuesPix.Size(); ++idx) { m_BandsToBurn.push_back(idx + 1 ); // Gdal bands count begins from 1 m_BurnValues.push_back(static_cast(burnValuesPix.GetElement(idx))); } } protected: void GenerateData() ITK_OVERRIDE; RasterizeVectorDataFilter(); ~RasterizeVectorDataFilter() ITK_OVERRIDE { if (m_OGRDataSourcePointer != ITK_NULLPTR) { ogr::version_proxy::Close(m_OGRDataSourcePointer); } } void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: RasterizeVectorDataFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented ogr::version_proxy::GDALDatasetType * m_OGRDataSourcePointer; // Vector Of LayersH std::vector< OGRLayerH > m_SrcDataSetLayers; std::vector m_BurnValues; std::vector m_FullBurnValues; std::vector m_BandsToBurn; }; // end of class RasterizeVectorDataFilter } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbRasterizeVectorDataFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbRasterizeVectorDataFilter.txx000066400000000000000000000170761301006202600316130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRasterizeVectorDataFilter_txx #define otbRasterizeVectorDataFilter_txx #include "otbRasterizeVectorDataFilter.h" #include "otbOGRIOHelper.h" #include "otbGdalDataTypeBridge.h" namespace otb { template RasterizeVectorDataFilter ::RasterizeVectorDataFilter() : m_OGRDataSourcePointer(ITK_NULLPTR) { this->SetNumberOfRequiredInputs(1); } template void RasterizeVectorDataFilter ::AddVectorData(const VectorDataType* vd) { // Process object is not const-correct so the const_cast is required // here if (this->GetNumberOfInputs() < 1) { this->itk::ProcessObject::SetNthInput(1, const_cast(vd) ); } else { this->itk::ProcessObject::PushBackInput( vd ); } } template void RasterizeVectorDataFilter ::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); // Generate the OGRLayers from the input VectorDatas // iteration begin from 1 cause the 0th input is a image for (unsigned int idx = 1; idx < this->GetNumberOfInputs(); ++idx) { const VectorDataType* vd = dynamic_cast< const VectorDataType*>(this->itk::ProcessObject::GetInput(idx)); // Get the projection ref of the current VectorData std::string projectionRefWkt = vd->GetProjectionRef(); bool projectionInformationAvailable = !projectionRefWkt.empty(); OGRSpatialReference * oSRS = ITK_NULLPTR; if (projectionInformationAvailable) { oSRS = static_cast(OSRNewSpatialReference(projectionRefWkt.c_str())); } else { otbMsgDevMacro(<< "Projection information unavailable"); } // Retrieving root node DataTreeConstPointerType tree = vd->GetDataTree(); // Get the input tree root InternalTreeNodeType * inputRoot = const_cast(tree->GetRoot()); // Iterative method to build the layers from a VectorData OGRRegisterAll(); OGRLayer * ogrCurrentLayer = ITK_NULLPTR; std::vector ogrLayerVector; otb::OGRIOHelper::Pointer IOConversion = otb::OGRIOHelper::New(); // The method ConvertDataTreeNodeToOGRLayers create the // OGRDataSource but don t release it. Destruction is done in the // desctructor m_OGRDataSourcePointer = ITK_NULLPTR; ogrLayerVector = IOConversion->ConvertDataTreeNodeToOGRLayers(inputRoot, m_OGRDataSourcePointer, ogrCurrentLayer, oSRS); // Cast OGRLayer* to OGRLayerH for (unsigned int idx2 = 0; idx2 < ogrLayerVector.size(); ++idx2) { m_SrcDataSetLayers.push_back( (OGRLayerH)(ogrLayerVector[idx2]) ); } // Destroy the oSRS if (oSRS != ITK_NULLPTR) { OSRRelease(oSRS); } } // Some checking : Check the consistency between the band list // to burn and the burn values : // There should be "m_BandsToBurn.size()" burn values for each layer. // If not, burn values vector will be cloned as many time as the number of // OGRLayer we have if (m_BurnValues.size() != m_BandsToBurn.size() * m_SrcDataSetLayers.size()) { std::ostringstream oss; oss <<"Inconsistency detected : expected burn vector size to be equal to( bandToBurn * nb layers = " << m_BandsToBurn.size() * m_SrcDataSetLayers.size() << " ), got : "<< m_BurnValues.size()< void RasterizeVectorDataFilter::GenerateData() { // Call Superclass GenerateData Superclass::GenerateData(); // Get the buffered region OutputImageRegionType bufferedRegion = this->GetOutput()->GetBufferedRegion(); // nb bands unsigned int nbBands = this->GetOutput()->GetNumberOfComponentsPerPixel(); // register drivers GDALAllRegister(); std::ostringstream stream; stream << "MEM:::" << "DATAPOINTER=" << (unsigned long) (GUIntBig) (this->GetOutput()->GetBufferPointer()) << "," << "PIXELS=" << bufferedRegion.GetSize()[0] << "," << "LINES=" << bufferedRegion.GetSize()[1]<< "," << "BANDS=" << nbBands << "," << "DATATYPE=" << GDALGetDataTypeName(GdalDataTypeBridge::GetGDALDataType()) << "," << "PIXELOFFSET=" << sizeof(OutputImageInternalPixelType) * nbBands << "," << "LINEOFFSET=" << sizeof(OutputImageInternalPixelType)*nbBands*bufferedRegion.GetSize()[0] << "," << "BANDOFFSET=" << sizeof(OutputImageInternalPixelType); GDALDatasetH dataset = GDALOpen(stream.str().c_str(), GA_Update); // Add the projection ref to the dataset GDALSetProjection (dataset, this->GetOutput()->GetProjectionRef().c_str()); // add the geoTransform to the dataset itk::VariableLengthVector geoTransform(6); // Reporting origin and spacing of the buffered region // the spacing is unchanged, the origin is relative to the buffered region InputIndexType bufferIndexOrigin = bufferedRegion.GetIndex(); InputPointType bufferOrigin; this->GetOutput()->TransformIndexToPhysicalPoint(bufferIndexOrigin, bufferOrigin); geoTransform[0] = bufferOrigin[0] - 0.5 * this->GetOutput()->GetSpacing()[0]; geoTransform[3] = bufferOrigin[1] - 0.5 * this->GetOutput()->GetSpacing()[1]; geoTransform[1] = this->GetOutput()->GetSpacing()[0]; geoTransform[5] = this->GetOutput()->GetSpacing()[1]; // FIXME: Here component 1 and 4 should be replaced by the orientation parameters geoTransform[2] = 0.; geoTransform[4] = 0.; GDALSetGeoTransform(dataset,const_cast(geoTransform.GetDataPointer())); // Burn the geometries into the dataset if (dataset != ITK_NULLPTR) { GDALRasterizeLayers( dataset, m_BandsToBurn.size(), &(m_BandsToBurn[0]), m_SrcDataSetLayers.size(), &(m_SrcDataSetLayers[0]), ITK_NULLPTR, ITK_NULLPTR, &(m_FullBurnValues[0]), ITK_NULLPTR, GDALDummyProgress, ITK_NULLPTR ); // release the dataset GDALClose( dataset ); } } template void RasterizeVectorDataFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbVectorDataToLabelImageFilter.h000066400000000000000000000140571301006202600315300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToLabelImageFilter_h #define otbVectorDataToLabelImageFilter_h #include "itkImageToImageFilter.h" #include "itkImageRegionIterator.h" #include "otbMacro.h" #include "otbVectorData.h" #include "gdal.h" #include "ogr_api.h" #include "otbOGRVersionProxy.h" namespace otb { /** \class VectorDataToLabelImageFilter * \brief Burn geometries from the specified VectorData into raster * * This class handles burning several input VectorDatas into the * output raster. The burn values are extracted from a field set by * the user.If no burning field is set, the "FID" is used by default. * * Setting the output raster information can be done in two ways by: * - Setting the Origin/Size/Spacing of the output image * - Using an existing image as support via SetOutputParametersFromImage(ImageBase) * * OGRRegisterAll() method must have been called before applying filter. * * * \ingroup OTBConversion */ template class ITK_EXPORT VectorDataToLabelImageFilter : public itk::ImageSource { public: /** Standard class typedefs */ typedef VectorDataToLabelImageFilter Self; typedef itk::ImageSource Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(VectorDataToLabelImageFilter, itk::ImageSource); /** Method for creation through the object factory. */ itkNewMacro(Self); typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::SizeType OutputSizeType; typedef typename OutputImageType::IndexType OutputIndexType; typedef typename OutputImageType::SpacingType OutputSpacingType; typedef typename OutputImageType::PointType OutputOriginType; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; typedef typename OutputImageType::InternalPixelType OutputImageInternalPixelType; /** VectorData typedefs*/ typedef TVectorData VectorDataType; typedef typename VectorDataType::DataTreeType DataTreeType; typedef typename DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename DataTreeType::Pointer DataTreePointerType; typedef typename DataTreeType::ConstPointer DataTreeConstPointerType; typedef itk::ImageBase ImageBaseType; /** Get Nth input VectorData */ const VectorDataType* GetInput(unsigned int idx); /** Method for adding VectorData to rasterize */ virtual void AddVectorData(const VectorDataType* vd); /** Set the size of the output image. */ itkSetMacro(OutputSize, OutputSizeType); /** Get the size of the output image. */ itkGetConstReferenceMacro(OutputSize, OutputSizeType); /** Set the origin of the output image. * \sa GetOrigin() */ itkSetMacro(OutputOrigin, OutputOriginType); virtual void SetOutputOrigin(const double origin[2]); virtual void SetOutputOrigin(const float origin[2]); itkGetConstReferenceMacro(OutputOrigin, OutputOriginType); /** Set the spacing (size of a pixel) of the output image. * \sa GetSpacing() */ virtual void SetOutputSpacing(const OutputSpacingType& spacing); virtual void SetOutputSpacing(const double spacing[2]); virtual void SetOutputSpacing(const float spacing[2]); /** Set/Get Output Projection Ref */ itkSetStringMacro(OutputProjectionRef); itkGetStringMacro(OutputProjectionRef); itkSetStringMacro(BurnAttribute); itkGetStringMacro(BurnAttribute); /** Useful to set the output parameters from an existing image*/ void SetOutputParametersFromImage(const ImageBaseType * image); protected: void GenerateData() ITK_OVERRIDE; VectorDataToLabelImageFilter(); ~VectorDataToLabelImageFilter() ITK_OVERRIDE { // Destroy the geometries stored for (unsigned int idx = 0; idx < m_SrcDataSetGeometries.size(); ++idx) { OGR_G_DestroyGeometry(m_SrcDataSetGeometries[idx]); } if (m_OGRDataSourcePointer != ITK_NULLPTR) { ogr::version_proxy::Close(m_OGRDataSourcePointer); } } void GenerateOutputInformation() ITK_OVERRIDE; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: VectorDataToLabelImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented ogr::version_proxy::GDALDatasetType * m_OGRDataSourcePointer; // Vector Of OGRGeometyH std::vector< OGRGeometryH > m_SrcDataSetGeometries; std::vector m_BurnValues; std::vector m_FullBurnValues; std::vector m_BandsToBurn; // Field used to extract the burn value std::string m_BurnAttribute; // Default burn value double m_DefaultBurnValue; // Output params std::string m_OutputProjectionRef; OutputSpacingType m_OutputSpacing; OutputOriginType m_OutputOrigin; OutputSizeType m_OutputSize; OutputIndexType m_OutputStartIndex; }; // end of class VectorDataToLabelImageFilter } // end of namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToLabelImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbVectorDataToLabelImageFilter.txx000066400000000000000000000263101301006202600321170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToLabelImageFilter_txx #define otbVectorDataToLabelImageFilter_txx #include "gdal_alg.h" #include "ogr_srs_api.h" #include "otbVectorDataToLabelImageFilter.h" #include "otbOGRIOHelper.h" #include "otbGdalDataTypeBridge.h" #include "otbImageMetadataInterfaceBase.h" #include "otbImageMetadataInterfaceFactory.h" namespace otb { template VectorDataToLabelImageFilter ::VectorDataToLabelImageFilter() : m_OGRDataSourcePointer(ITK_NULLPTR), m_BurnAttribute("FID") { this->SetNumberOfRequiredInputs(1); // Output parameters initialization m_OutputSpacing.Fill(1.0); m_OutputSize.Fill(0); m_OutputStartIndex.Fill(0); // This filter is intended to work with otb::Image m_BandsToBurn.push_back(1); // Default burn value if no burnAttribute availabke m_DefaultBurnValue = 1.; } template void VectorDataToLabelImageFilter ::AddVectorData(const VectorDataType* vd) { this->itk::ProcessObject::PushBackInput( vd ); } template const typename VectorDataToLabelImageFilter::VectorDataType * VectorDataToLabelImageFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } template void VectorDataToLabelImageFilter ::SetOutputSpacing(const OutputSpacingType& spacing) { if (this->m_OutputSpacing != spacing) { this->m_OutputSpacing = spacing; this->Modified(); } } template void VectorDataToLabelImageFilter ::SetOutputSpacing(const double spacing[2]) { OutputSpacingType s(spacing); this->SetOutputSpacing(s); } template void VectorDataToLabelImageFilter ::SetOutputSpacing(const float spacing[2]) { itk::Vector sf(spacing); OutputSpacingType s; s.CastFrom(sf); this->SetOutputSpacing(s); } template void VectorDataToLabelImageFilter ::SetOutputOrigin(const double origin[2]) { OutputOriginType p(origin); this->SetOutputOrigin(p); } template void VectorDataToLabelImageFilter ::SetOutputOrigin(const float origin[2]) { itk::Point of(origin); OutputOriginType p; p.CastFrom(of); this->SetOutputOrigin(p); } template void VectorDataToLabelImageFilter ::SetOutputParametersFromImage(const ImageBaseType * src) { this->SetOutputOrigin ( src->GetOrigin() ); this->SetOutputSpacing ( src->GetSpacing() ); this->SetOutputSize ( src->GetLargestPossibleRegion().GetSize() ); ImageMetadataInterfaceBase::Pointer imi = ImageMetadataInterfaceFactory::CreateIMI(src->GetMetaDataDictionary()); this->SetOutputProjectionRef(imi->GetProjectionRef()); } template void VectorDataToLabelImageFilter ::GenerateOutputInformation() { // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); if (!outputPtr) { return; } // Set the size of the output region typename TOutputImage::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(m_OutputSize); //outputLargestPossibleRegion.SetIndex(m_OutputStartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); // Set spacing and origin outputPtr->SetSpacing(m_OutputSpacing); outputPtr->SetOrigin(m_OutputOrigin); itk::MetaDataDictionary& dict = outputPtr->GetMetaDataDictionary(); itk::EncapsulateMetaData (dict, MetaDataKey::ProjectionRefKey, static_cast(this->GetOutputProjectionRef())); // Generate the OGRLayers from the input VectorDatas // iteration begin from 1 cause the 0th input is a image for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { const VectorDataType* vd = dynamic_cast< const VectorDataType*>(this->itk::ProcessObject::GetInput(idx)); // Get the projection ref of the current VectorData std::string projectionRefWkt = vd->GetProjectionRef(); bool projectionInformationAvailable = !projectionRefWkt.empty(); OGRSpatialReference * oSRS = ITK_NULLPTR; if (projectionInformationAvailable) { oSRS = static_cast(OSRNewSpatialReference(projectionRefWkt.c_str())); } else { otbMsgDevMacro(<< "Projection information unavailable"); } // Retrieving root node DataTreeConstPointerType tree = vd->GetDataTree(); // Get the input tree root InternalTreeNodeType * inputRoot = const_cast(tree->GetRoot()); // Iterative method to build the layers from a VectorData OGRLayer * ogrCurrentLayer = ITK_NULLPTR; std::vector ogrLayerVector; otb::OGRIOHelper::Pointer IOConversion = otb::OGRIOHelper::New(); // The method ConvertDataTreeNodeToOGRLayers create the // OGRDataSource but don t release it. Destruction is done in the // desctructor m_OGRDataSourcePointer = ITK_NULLPTR; ogrLayerVector = IOConversion->ConvertDataTreeNodeToOGRLayers(inputRoot, m_OGRDataSourcePointer, ogrCurrentLayer, oSRS); // From OGRLayer* to OGRGeometryH vector for (unsigned int idx2 = 0; idx2 < ogrLayerVector.size(); ++idx2) { // test if the layers contain a field m_BurnField; int burnField = -1; if( !m_BurnAttribute.empty() ) { burnField = OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( (OGRLayerH)(ogrLayerVector[idx2]) ), m_BurnAttribute.c_str() ); // Get the geometries of the layer OGRFeatureH hFeat; OGR_L_ResetReading( (OGRLayerH)(ogrLayerVector[idx2]) ); while( ( hFeat = OGR_L_GetNextFeature( (OGRLayerH)(ogrLayerVector[idx2]) )) != ITK_NULLPTR ) { OGRGeometryH hGeom; if( OGR_F_GetGeometryRef( hFeat ) == ITK_NULLPTR ) { OGR_F_Destroy( hFeat ); continue; } hGeom = OGR_G_Clone( OGR_F_GetGeometryRef( hFeat ) ); m_SrcDataSetGeometries.push_back( hGeom ); if (burnField == -1 ) { // TODO : if no burnAttribute available, warning or raise an exception?? m_FullBurnValues.push_back(m_DefaultBurnValue++); itkWarningMacro(<<"Failed to find attribute "< #include // #include "itkImageToImageFilter.h" namespace otb { /** * \class VectorDataToLabelMapFilter * \brief Convert a vector data and produce a collection of label objects for each node * * VectorDataToLabelMapFilter convert a vector data in a LabelMap. * Each distinct object is assigned a unique label. * The final object labels start with 1 and are consecutive (depraced +10). * * \sa LabelMapSource * * \ingroup OTBConversion */ template class ITK_EXPORT VectorDataToLabelMapFilter : public LabelMapSource { public: /** * Standard "Self" & Superclass typedef. */ typedef VectorDataToLabelMapFilter Self; typedef LabelMapSource Superclass; /** Some convenient typedefs. */ typedef TVectorData InputVectorDataType; typedef TLabelMap OutputLabelMapType; typedef typename InputVectorDataType::Pointer InputVectorDataPointer; typedef typename InputVectorDataType::ConstPointer InputVectorDataConstPointer; typedef typename OutputLabelMapType::Pointer OutputLabelMapPointer; typedef typename OutputLabelMapType::ConstPointer OutputLabelMapConstPointer; typedef typename InputVectorDataType::DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename InternalTreeNodeType::ChildrenListType ChildrenListType; typedef typename InputVectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; typedef typename OutputLabelMapType::LabelType LabelType; typedef typename OutputLabelMapType::IndexType IndexType; typedef typename OutputLabelMapType::PixelType OutputLabelMapPixelType; typedef typename OutputLabelMapType::PointType OriginType; typedef typename OutputLabelMapType::SpacingType SpacingType; typedef typename OutputLabelMapType::DirectionType DirectionType; /** typedefs for correct polygon */ typedef otb::CorrectPolygonFunctor CorrectFunctorType; /** Number of dimensions. */ itkStaticConstMacro(VectorDataDimension, unsigned int, TVectorData::Dimension); /** Image size typedef. */ typedef itk::Size SizeType; typedef typename InputVectorDataType::PointType PointType; /** * Smart pointer typedef support */ typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Set the size of the output image. */ // itkSetMacro( Size, SizeType ); /** Set the starting index of the output image. */ // itkSetMacro( StartIndex, IndexType ); /** * Run-time type information (and related methods) */ itkTypeMacro(VectorDataToLabelMapFilter, ImageToImageFilter); /** * Method for creation through the object factory. */ itkNewMacro(Self); /** * Set/Get the value used as "background" in the output image. * Defaults to NumericTraits::NonpositiveMin(). */ itkSetMacro(BackgroundValue, OutputLabelMapPixelType); itkGetConstMacro(BackgroundValue, OutputLabelMapPixelType); /** Set the size of the output image. */ itkSetMacro(Size, SizeType); /** Get the size of the output image. */ itkGetConstReferenceMacro(Size, SizeType); /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(Origin, OriginType); virtual void SetOrigin(const double origin[2]); virtual void SetOrigin(const float origin[2]); itkGetConstReferenceMacro(Origin, OriginType); /** Get/Set start index*/ itkGetConstReferenceMacro(StartIndex, IndexType); itkSetMacro(StartIndex, IndexType); /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ virtual void SetSpacing(const SpacingType& spacing); virtual void SetSpacing(const double spacing[2]); virtual void SetSpacing(const float spacing[2]); itkGetConstReferenceMacro(Spacing, SpacingType); /** Set/Get the Vector data input of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputVectorDataType *input); virtual void SetInput(unsigned int idx, const InputVectorDataType *input); const InputVectorDataType * GetInput(void); const InputVectorDataType * GetInput(unsigned int idx); void GenerateOutputInformation() ITK_OVERRIDE; protected: VectorDataToLabelMapFilter(); ~VectorDataToLabelMapFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Standard pipeline method. */ void GenerateData() ITK_OVERRIDE; /** VectorDataToLabelMapFilter needs the entire input. Therefore * it must provide an implementation GenerateInputRequestedRegion(). * \sa ProcessObject::GenerateInputRequestedRegion(). */ // void GenerateInputRequestedRegion(); /** VectorDataToLabelMapFilter will produce all of the output. * Therefore it must provide an implementation of * EnlargeOutputRequestedRegion(). * \sa ProcessObject::EnlargeOutputRequestedRegion() */ // void EnlargeOutputRequestedRegion(itk::DataObject *itkNotUsed(output)); private: VectorDataToLabelMapFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void ProcessNode(InternalTreeNodeType * source); /** Current label value incremented after the vectorization of a layer*/ LabelType m_lab; //TODO donc need this attribute now compute with VectorDataProperties SpacingType m_Spacing; OriginType m_Origin; SizeType m_Size; IndexType m_StartIndex; DirectionType m_Direction; /** Background value, not use actually, background value=itk::NumericTraits::max()*/ OutputLabelMapPixelType m_BackgroundValue; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToLabelMapFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Conversion/include/otbVectorDataToLabelMapFilter.txx000066400000000000000000000275611301006202600316230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToLabelMapFilter_txx #define otbVectorDataToLabelMapFilter_txx #include "otbVectorDataToLabelMapFilter.h" #include "itkBinaryImageToLabelMapFilter.h" #include "itkNumericTraits.h" #include "otbVectorDataProperties.h" namespace otb { template VectorDataToLabelMapFilter ::VectorDataToLabelMapFilter() { m_BackgroundValue = itk::NumericTraits::max(); this->SetNumberOfRequiredInputs(1); m_Spacing.Fill(1.0); m_Origin.Fill(0.0); m_Direction.SetIdentity(); m_Size.Fill(0); m_StartIndex.Fill(0); m_lab = itk::NumericTraits::Zero; } //---------------------------------------------------------------------------- template void VectorDataToLabelMapFilter ::SetSpacing(const SpacingType& spacing) { if (this->m_Spacing != spacing) { this->m_Spacing = spacing; this->Modified(); } } //---------------------------------------------------------------------------- template void VectorDataToLabelMapFilter ::SetSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToLabelMapFilter ::SetSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToLabelMapFilter ::SetOrigin(const double origin[2]) { OriginType p(origin); this->SetOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataToLabelMapFilter ::SetOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetOrigin(p); } /** * overloaded because pb during copyinformation */ template void VectorDataToLabelMapFilter ::GenerateOutputInformation() { // we can't call the superclass method here. // get pointers to the input and output OutputLabelMapType * outputPtr = this->GetOutput(); if (!outputPtr) { return; } // Set the size of the output region typename OutputLabelMapType::RegionType outputLargestPossibleRegion; outputLargestPossibleRegion.SetSize(m_Size); outputLargestPossibleRegion.SetIndex(m_StartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); otbGenericMsgDebugMacro(<< "LargestPossibleRegion " << outputPtr->GetLargestPossibleRegion()); // Set spacing and origin outputPtr->SetSpacing(m_Spacing); outputPtr->SetOrigin(m_Origin); outputPtr->SetDirection(m_Direction); return; } /* template void VectorDataToLabelMapFilter ::GenerateInputRequestedRegion() { //call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // We need all the input. InputVectorDataPointer input = const_cast(this->GetInput()); if( !input ) { return; } input->SetRequestedRegionToLargestPossibleRegion (); } template void VectorDataToLabelMapFilter ::EnlargeOutputRequestedRegion(itk::DataObject *) { this->GetOutput() ->SetRequestedRegion( this->GetOutput()->GetLargestPossibleRegion() ); } */ template void VectorDataToLabelMapFilter ::SetInput(const InputVectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template void VectorDataToLabelMapFilter ::SetInput(unsigned int idx, const InputVectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(idx, const_cast(input)); } template const typename VectorDataToLabelMapFilter::InputVectorDataType * VectorDataToLabelMapFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return 0; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template const typename VectorDataToLabelMapFilter::InputVectorDataType * VectorDataToLabelMapFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } template void VectorDataToLabelMapFilter ::GenerateData() { // Allocate the output this->AllocateOutputs(); OutputLabelMapType * output = this->GetOutput(); //For each input for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { if (this->GetInput(idx)) { InputVectorDataConstPointer input = this->GetInput(idx); InternalTreeNodeType * inputRoot = const_cast(input->GetDataTree()->GetRoot()); //Use our own value for the background output->SetBackgroundValue(itk::NumericTraits::max()); //Set the value of the first label m_lab = itk::NumericTraits::Zero; // otbGenericMsgDebugMacro(<<"input " << idx); //The projection information output->SetMetaDataDictionary(input->GetMetaDataDictionary()); ProcessNode(inputRoot); } } } template void VectorDataToLabelMapFilter ::ProcessNode(InternalTreeNodeType * source) { // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // For each child for (typename ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { // Copy input DataNode info DataNodePointerType dataNode = (*it)->Get(); otbGenericMsgDebugMacro(<< "Type of node " << dataNode->GetNodeType() << " id" << dataNode->GetNodeId()); switch (dataNode->GetNodeType()) { case otb::ROOT: { ProcessNode((*it)); break; } case otb::DOCUMENT: { ProcessNode((*it)); break; } case otb::FOLDER: { ProcessNode((*it)); break; } case FEATURE_POINT: { otbGenericMsgDebugMacro(<< "Insert Point from vectorData"); IndexType index; this->GetOutput()->TransformPhysicalPointToIndex(dataNode->GetPoint(), index); this->GetOutput()->SetPixel(index, m_lab); m_lab += 10; break; } case otb::FEATURE_LINE: { //TODO Bresenham itkExceptionMacro( << "This type (FEATURE_LINE) is not handle (yet) by VectorDataToLabelMapFilter(), please request for it"); break; } case FEATURE_POLYGON: { /** correct polygon exterior ring (simplify and close the pokygon)*/ CorrectFunctorType correct; PolygonPointerType correctPolygonExtRing = correct(dataNode->GetPolygonExteriorRing()); typedef typename DataNodeType::PolygonType PolygonType; typedef typename PolygonType::RegionType RegionType; typedef typename PolygonType::VertexType VertexType; typedef typename IndexType::IndexValueType IndexValueType; typedef typename VertexType::ValueType VertexValueType; RegionType polygonExtRingBoundReg = correctPolygonExtRing->GetBoundingRegion(); VertexType vertex; otbMsgDevMacro( "Polygon bounding region " << polygonExtRingBoundReg); otbMsgDevMacro( "output origin " << this->GetOutput()->GetOrigin()); otbMsgDevMacro( "spacing " << this->GetOutput()->GetSpacing()); // For each position in the bounding region of the polygon for (double i = polygonExtRingBoundReg.GetOrigin(0); i < polygonExtRingBoundReg.GetOrigin(0) + polygonExtRingBoundReg.GetSize(0); i += this->GetOutput()->GetSpacing()[0]) { vertex[0] = static_cast(i); for (double j = polygonExtRingBoundReg.GetOrigin(1); j < polygonExtRingBoundReg.GetOrigin(1) + polygonExtRingBoundReg.GetSize(1); j += this->GetOutput()->GetSpacing()[1]) { vertex[1] = static_cast(j); if (correctPolygonExtRing->IsInside(vertex) || correctPolygonExtRing->IsOnEdge (vertex)) { IndexType index; index[0] = static_cast(vertex[0] - polygonExtRingBoundReg.GetOrigin(0)); index[1] = static_cast(vertex[1] - polygonExtRingBoundReg.GetOrigin(1)); // index[0] += this->GetOutput()->GetOrigin()[0]; // index[1] += this->GetOutput()->GetOrigin()[1]; // std::cout << "index " << index << std::endl; if (this->GetOutput()->HasLabel(m_lab)) { if (!this->GetOutput()->GetLabelObject(m_lab)->HasIndex(index)) { //Add a pixel to the current labelObject this->GetOutput()->SetPixel(index, m_lab); } } else { //Add a pixel to the current labelObject this->GetOutput()->SetPixel(index, m_lab); } } } } //Modify the label for the next layer m_lab += 10; break; } case FEATURE_MULTIPOINT: { itkExceptionMacro( << "This type (FEATURE_MULTIPOINT) is not handle (yet) by VectorDataToLabelMapFilter(), please request for it"); break; } case FEATURE_MULTILINE: { itkExceptionMacro( << "This type (FEATURE_MULTILINE) is not handle (yet) by VectorDataToLabelMapFilter(), please request for it"); break; } case FEATURE_MULTIPOLYGON: { itkExceptionMacro( << "This type (FEATURE_MULTIPOLYGON) is not handle (yet) by VectorDataToLabelMapFilter(), please request for it"); break; } case FEATURE_COLLECTION: { itkExceptionMacro( << "This type (FEATURE_COLLECTION) is not handle (yet) by VectorDataToLabelMapFilter(), please request for it"); break; } } } } template void VectorDataToLabelMapFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "BackgroundValue: " << static_cast::PrintType>( m_BackgroundValue) << std::endl; } } // end namespace otb #endif otbVectorDataToLabelMapWithAttributesFilter.h000066400000000000000000000174311301006202600340460ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Conversion/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToLabelMapWithAttributesFilter_h #define otbVectorDataToLabelMapWithAttributesFilter_h #include "itkLabelObject.h" #include "itkProgressReporter.h" #include "itkBarrier.h" #include "itkConceptChecking.h" #include "itkContinuousIndex.h" //#include "itkDataObject.h" #include "otbLabelMapSource.h" #include "otbCorrectPolygonFunctor.h" #include #include #include "otbVectorDataProperties.h" // #include "itkImageToImageFilter.h" namespace otb { /** * \class VectorDataToLabelMapWithAttributesFilter * \brief Converts a vector data into a LabelMap. * * VectorDataToLabelMapWithAttributesFilter convert a vector data in a LabelMap. * To each distinct object is assigned a unique label. * The first Label is set using SetInitialLabel (by default it is 0), and increases 1 by 1. * The vector data attributes are also assigned to the object in the label map. * * When AutomaticSizeComputation=True, the spacing from the vector data object * is used. Then the size and origin are computed so that the image extent * covers exactly the vector data bounding region. * * Note : the coordinates in the vector data are assumed to be physical coordinates. * * \sa LabelMapSource * * \ingroup OTBConversion */ template class ITK_EXPORT VectorDataToLabelMapWithAttributesFilter : public LabelMapSource { public: /** * Standard "Self" & Superclass typedef. */ typedef VectorDataToLabelMapWithAttributesFilter Self; typedef LabelMapSource Superclass; /** Some convenient typedefs. */ typedef TVectorData InputVectorDataType; typedef TLabelMap OutputLabelMapType; typedef typename InputVectorDataType::Pointer InputVectorDataPointer; typedef typename InputVectorDataType::ConstPointer InputVectorDataConstPointer; typedef typename OutputLabelMapType::Pointer OutputLabelMapPointer; typedef typename OutputLabelMapType::ConstPointer OutputLabelMapConstPointer; typedef typename InputVectorDataType::DataTreeType::TreeNodeType InternalTreeNodeType; typedef typename InternalTreeNodeType::ChildrenListType ChildrenListType; typedef typename InputVectorDataType::DataNodeType DataNodeType; typedef typename DataNodeType::Pointer DataNodePointerType; typedef typename DataNodeType::PolygonType PolygonType; typedef typename PolygonType::Pointer PolygonPointerType; typedef typename OutputLabelMapType::LabelType LabelType; typedef typename OutputLabelMapType::IndexType IndexType; typedef typename OutputLabelMapType::PixelType OutputLabelMapPixelType; typedef typename OutputLabelMapType::PointType OriginType; typedef typename OutputLabelMapType::SpacingType SpacingType; typedef typename OutputLabelMapType::DirectionType DirectionType; typedef typename OutputLabelMapType::RegionType RegionType; typedef typename OutputLabelMapType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::AttributesValueType AttributesValueType; typedef VectorDataProperties VectorDataPropertiesType; /** typedefs for correct polygon */ typedef otb::CorrectPolygonFunctor CorrectFunctorType; /** Number of dimensions. */ itkStaticConstMacro(VectorDataDimension, unsigned int, TVectorData::Dimension); /** Image size typedef. */ typedef itk::Size SizeType; typedef typename InputVectorDataType::PointType PointType; /** * Smart pointer typedef support */ typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** * Run-time type information (and related methods) */ itkTypeMacro(VectorDataToLabelMapWithAttributesFilter, ImageToImageFilter) ; /** * Method for creation through the object factory. */ itkNewMacro(Self) ; /** * Set/Get the value used as "background" in the output image. * Defaults to NumericTraits::NonpositiveMin(). */ itkSetMacro(BackgroundValue, OutputLabelMapPixelType) ; itkGetConstMacro(BackgroundValue, OutputLabelMapPixelType) ; /** Set the size of the output image. */ itkSetMacro(Size, SizeType) ; /** Get the size of the output image. */ itkGetConstReferenceMacro(Size, SizeType) ; /** Set the origin of the vector data. * \sa GetOrigin() */ itkSetMacro(Origin, OriginType) ; virtual void SetOrigin(const double origin[2]); virtual void SetOrigin(const float origin[2]); itkGetConstReferenceMacro(Origin, OriginType) ; /** Get/Set start index*/ itkGetConstReferenceMacro(StartIndex, IndexType) ; itkSetMacro(StartIndex, IndexType) ; /** Set the spacing (size of a pixel) of the vector data. * \sa GetSpacing() */ virtual void SetSpacing(const SpacingType& spacing); virtual void SetSpacing(const double spacing[2]); virtual void SetSpacing(const float spacing[2]); itkGetConstReferenceMacro(Spacing, SpacingType) ; /** Set/Get the Vector data input of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputVectorDataType *input); virtual void SetInput(unsigned int idx, const InputVectorDataType *input); const InputVectorDataType * GetInput(void); const InputVectorDataType * GetInput(unsigned int idx); /** Set/Get Automatic size computation mode*/ itkSetMacro(AutomaticSizeComputation, bool) ; itkGetMacro(AutomaticSizeComputation, bool) ; /** Set/Get Initial label value */ itkSetMacro(InitialLabel, LabelType) ; itkGetMacro(InitialLabel, LabelType) ; void GenerateOutputInformation() ITK_OVERRIDE; protected: VectorDataToLabelMapWithAttributesFilter(); ~VectorDataToLabelMapWithAttributesFilter() ITK_OVERRIDE { } void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** * Standard pipeline method. */ void GenerateData() ITK_OVERRIDE; /** VectorDataToLabelMapWithAttributesFilter needs the entire input. Therefore * it must provide an implementation GenerateInputRequestedRegion(). * \sa ProcessObject::GenerateInputRequestedRegion(). */ // void GenerateInputRequestedRegion(); /** VectorDataToLabelMapWithAttributesFilter will produce all of the output. * Therefore it must provide an implementation of * EnlargeOutputRequestedRegion(). * \sa ProcessObject::EnlargeOutputRequestedRegion() */ // void EnlargeOutputRequestedRegion(itk::DataObject *itkNotUsed(output)); private: VectorDataToLabelMapWithAttributesFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented void ProcessNode(InternalTreeNodeType * source); /** Current label value incremented after the vectorization of a layer*/ LabelType m_lab; /** Set to 0 by default.*/ LabelType m_InitialLabel; //TODO don't need this attributes now compute with VectorDataProperties SpacingType m_Spacing; OriginType m_Origin; SizeType m_Size; IndexType m_StartIndex; DirectionType m_Direction; /** Background value, not use actually, background value=itk::NumericTraits::max()*/ OutputLabelMapPixelType m_BackgroundValue; bool m_AutomaticSizeComputation; typename VectorDataPropertiesType::Pointer m_VectorDataProperties; }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbVectorDataToLabelMapWithAttributesFilter.txx" #endif #endif otbVectorDataToLabelMapWithAttributesFilter.txx000066400000000000000000000355071301006202600344460ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Conversion/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbVectorDataToLabelMapWithAttributesFilter_txx #define otbVectorDataToLabelMapWithAttributesFilter_txx #include "otbVectorDataToLabelMapWithAttributesFilter.h" #include "itkBinaryImageToLabelMapFilter.h" #include "itkNumericTraits.h" #include "otbVectorDataProperties.h" namespace otb { template VectorDataToLabelMapWithAttributesFilter ::VectorDataToLabelMapWithAttributesFilter() { m_BackgroundValue = itk::NumericTraits::max(); this->SetNumberOfRequiredInputs(1); m_Spacing.Fill(1.0); m_Origin.Fill(0.0); m_Direction.SetIdentity(); m_Size.Fill(0); m_StartIndex.Fill(0); m_InitialLabel = itk::NumericTraits::Zero; m_AutomaticSizeComputation=true; m_VectorDataProperties = VectorDataPropertiesType::New(); } //---------------------------------------------------------------------------- template void VectorDataToLabelMapWithAttributesFilter ::SetSpacing(const SpacingType& spacing) { if (this->m_Spacing != spacing) { this->m_Spacing = spacing; this->Modified(); } } //---------------------------------------------------------------------------- template void VectorDataToLabelMapWithAttributesFilter ::SetSpacing(const double spacing[2]) { SpacingType s(spacing); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToLabelMapWithAttributesFilter ::SetSpacing(const float spacing[2]) { itk::Vector sf(spacing); SpacingType s; s.CastFrom(sf); this->SetSpacing(s); } //---------------------------------------------------------------------------- template void VectorDataToLabelMapWithAttributesFilter ::SetOrigin(const double origin[2]) { OriginType p(origin); this->SetOrigin(p); } //---------------------------------------------------------------------------- template void VectorDataToLabelMapWithAttributesFilter ::SetOrigin(const float origin[2]) { itk::Point of(origin); OriginType p; p.CastFrom(of); this->SetOrigin(p); } /** * overloaded because pb during copyinformation */ template void VectorDataToLabelMapWithAttributesFilter ::GenerateOutputInformation() { // we can't call the superclass method here. // get pointers to the input and output OutputLabelMapType * outputPtr = this->GetOutput(); if (!outputPtr) { return; } RegionType outputLargestPossibleRegion; if(m_AutomaticSizeComputation==false) { // Set the size of the output region outputLargestPossibleRegion.SetSize(m_Size); outputLargestPossibleRegion.SetIndex(m_StartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); otbGenericMsgDebugMacro(<< "LargestPossibleRegion " << outputPtr->GetLargestPossibleRegion()); // Set spacing and origin outputPtr->SetSpacing(m_Spacing); outputPtr->SetOrigin(m_Origin); outputPtr->SetDirection(m_Direction); } else { //typename PolygonType::RegionType region; m_VectorDataProperties->SetVectorDataObject(this->GetInput()); //m_VectorDataProperties->SetBoundingRegion(region); //Compute the global bounding box of the vectordata m_VectorDataProperties->ComputeBoundingRegion(); // Compute origin and size SizeType size; SpacingType spacing = this->GetInput()->GetSpacing(); OriginType origin = m_VectorDataProperties->GetBoundingRegion().GetOrigin(); for (unsigned int i=0; i<2; ++i) { if (spacing[i] < 0.0) { origin[i] += m_VectorDataProperties->GetBoundingRegion().GetSize(i); } origin[i] += (0.5 - m_StartIndex[i]) * spacing[i]; size[i] = static_cast(vcl_ceil(vcl_abs( m_VectorDataProperties->GetBoundingRegion().GetSize(i)/spacing[i]))); } outputLargestPossibleRegion.SetSize(size); outputLargestPossibleRegion.SetIndex(m_StartIndex); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); outputPtr->SetSpacing(spacing); outputPtr->SetOrigin(origin); outputPtr->SetDirection(m_Direction); } return; } /* template void VectorDataToLabelMapWithAttributesFilter ::GenerateInputRequestedRegion() { //call the superclass' implementation of this method Superclass::GenerateInputRequestedRegion(); // We need all the input. InputVectorDataPointer input = const_cast(this->GetInput()); if( !input ) { return; } input->SetRequestedRegionToLargestPossibleRegion (); } template void VectorDataToLabelMapWithAttributesFilter ::EnlargeOutputRequestedRegion(itk::DataObject *) { this->GetOutput() ->SetRequestedRegion( this->GetOutput()->GetLargestPossibleRegion() ); } */ template void VectorDataToLabelMapWithAttributesFilter ::SetInput(const InputVectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(0, const_cast(input)); } template void VectorDataToLabelMapWithAttributesFilter ::SetInput(unsigned int idx, const InputVectorDataType *input) { // Process object is not const-correct so the const_cast is required here this->itk::ProcessObject::SetNthInput(idx, const_cast(input)); } template const typename VectorDataToLabelMapWithAttributesFilter::InputVectorDataType * VectorDataToLabelMapWithAttributesFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetInput(0)); } template const typename VectorDataToLabelMapWithAttributesFilter::InputVectorDataType * VectorDataToLabelMapWithAttributesFilter ::GetInput(unsigned int idx) { return static_cast (this->itk::ProcessObject::GetInput(idx)); } template void VectorDataToLabelMapWithAttributesFilter ::GenerateData() { // Allocate the output this->AllocateOutputs(); OutputLabelMapType * output = this->GetOutput(); //For each input for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx) { if (this->GetInput(idx)) { InputVectorDataConstPointer input = this->GetInput(idx); InternalTreeNodeType * inputRoot = const_cast(input->GetDataTree()->GetRoot()); //Use our own value for the background output->SetBackgroundValue(m_BackgroundValue); //Set the value of the first label m_lab = m_InitialLabel; // otbGenericMsgDebugMacro(<<"input " << idx); //The projection information output->SetMetaDataDictionary(input->GetMetaDataDictionary()); ProcessNode(inputRoot); } } } template void VectorDataToLabelMapWithAttributesFilter ::ProcessNode(InternalTreeNodeType * source) { // Get the children list from the input node ChildrenListType children = source->GetChildrenList(); // For each child for (typename ChildrenListType::iterator it = children.begin(); it != children.end(); ++it) { // Copy input DataNode info DataNodePointerType dataNode = (*it)->Get(); otbGenericMsgDebugMacro(<< "Type of node " << dataNode->GetNodeType() << " id" << dataNode->GetNodeId()); switch (dataNode->GetNodeType()) { case otb::ROOT: { ProcessNode((*it)); break; } case otb::DOCUMENT: { ProcessNode((*it)); break; } case otb::FOLDER: { ProcessNode((*it)); break; } case FEATURE_POINT: { otbGenericMsgDebugMacro(<< "Insert Point from vectorData"); IndexType index; this->GetOutput()->TransformPhysicalPointToIndex(dataNode->GetPoint(), index); if (this->GetOutput()->GetLargestPossibleRegion().IsInside(index)) { this->GetOutput()->SetPixel(index, m_lab); m_lab += 1; } break; } case otb::FEATURE_LINE: { //TODO Bresenham itkExceptionMacro( << "This type (FEATURE_LINE) is not handle (yet) by VectorDataToLabelMapWithAttributesFilter(), please request for it"); break; } case FEATURE_POLYGON: { /** correct polygon exterior ring (simplify and close the pokygon)*/ CorrectFunctorType correct; PolygonPointerType correctPolygonExtRing = correct(dataNode->GetPolygonExteriorRing()); //typedef typename DataNodeType::PolygonType PolygonType; typedef typename PolygonType::RegionType RSRegionType; typedef typename PolygonType::VertexType VertexType; typedef typename IndexType::IndexValueType IndexValueType; RSRegionType polygonExtRingBoundReg = correctPolygonExtRing->GetBoundingRegion(); OriginType physCorners[4]; physCorners[0][0] = polygonExtRingBoundReg.GetOrigin(0); physCorners[0][1] = polygonExtRingBoundReg.GetOrigin(1); physCorners[1] = physCorners[0]; physCorners[2] = physCorners[0]; physCorners[3] = physCorners[0]; physCorners[1][1] += polygonExtRingBoundReg.GetSize(1); physCorners[2][1] += polygonExtRingBoundReg.GetSize(1); physCorners[2][0] += polygonExtRingBoundReg.GetSize(0); physCorners[3][0] += polygonExtRingBoundReg.GetSize(0); IndexType startIdx,endIdx,tmpIdx; startIdx.Fill(itk::NumericTraits::max()); endIdx.Fill(itk::NumericTraits::NonpositiveMin()); for (unsigned int k=0; k<4; ++k) { this->GetOutput()->TransformPhysicalPointToIndex(physCorners[k],tmpIdx); startIdx[0] = std::min(startIdx[0],tmpIdx[0]); startIdx[1] = std::min(startIdx[1],tmpIdx[1]); endIdx[0] = std::max(endIdx[0],tmpIdx[0]); endIdx[1] = std::max(endIdx[1],tmpIdx[1]); } // Check that the polygon intersects the largest possible region RegionType polyRegion; polyRegion.SetIndex(startIdx); polyRegion.SetSize(0,endIdx[0] - startIdx[0] + 1); polyRegion.SetSize(1,endIdx[1] - startIdx[1] + 1); if (polyRegion.Crop(this->GetOutput()->GetLargestPossibleRegion())) { startIdx = polyRegion.GetIndex(); endIdx[0] = startIdx[0] - 1 + polyRegion.GetSize(0); endIdx[1] = startIdx[1] - 1 + polyRegion.GetSize(1); } else { // No intersection break; } OriginType tmpPoint; VertexType vertex; for (IndexValueType j=startIdx[1]; j<=endIdx[1]; ++j) { for (IndexValueType i=startIdx[0]; i<=endIdx[0]; ++i) { tmpIdx[0] = i; tmpIdx[1] = j; this->GetOutput()->TransformIndexToPhysicalPoint(tmpIdx,tmpPoint); vertex[0] = tmpPoint[0]; vertex[1] = tmpPoint[1]; if (correctPolygonExtRing->IsInside(vertex) || correctPolygonExtRing->IsOnEdge (vertex)) { // TODO : should also test interior rings if (this->GetOutput()->HasLabel(m_lab)) { if (!this->GetOutput()->GetLabelObject(m_lab)->HasIndex(tmpIdx)) { //Add a pixel to the current labelObject this->GetOutput()->SetPixel(tmpIdx, m_lab); } } else { //Add a pixel to the current labelObject this->GetOutput()->SetPixel(tmpIdx, m_lab); //add attributes AttributesValueType fieldValue; for(unsigned int ii=0; iiGetFieldList().size(); ii++) { fieldValue = static_cast( dataNode->GetFieldAsString(dataNode->GetFieldList()[ii]) ); this->GetOutput()->GetLabelObject(m_lab)->SetAttribute( dataNode->GetFieldList()[ii].c_str(), fieldValue ); } } } } } //Modify the label for the next layer m_lab += 1; break; } case FEATURE_MULTIPOINT: { itkExceptionMacro( << "This type (FEATURE_MULTIPOINT) is not handle (yet) by VectorDataToLabelMapWithAttributesFilter(), please request for it"); break; } case FEATURE_MULTILINE: { itkExceptionMacro( << "This type (FEATURE_MULTILINE) is not handle (yet) by VectorDataToLabelMapWithAttributesFilter(), please request for it"); break; } case FEATURE_MULTIPOLYGON: { itkExceptionMacro( << "This type (FEATURE_MULTIPOLYGON) is not handle (yet) by VectorDataToLabelMapWithAttributesFilter(), please request for it"); break; } case FEATURE_COLLECTION: { itkExceptionMacro( << "This type (FEATURE_COLLECTION) is not handle (yet) by VectorDataToLabelMapWithAttributesFilter(), please request for it"); break; } } } } template void VectorDataToLabelMapWithAttributesFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "BackgroundValue: " << static_cast::PrintType>( m_BackgroundValue) << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Conversion/otb-module.cmake000066400000000000000000000011431301006202600246600ustar00rootroot00000000000000set(DOCUMENTATION "This module contains tools that allow switching between different segment representations (labelImage, labelMap, OGR Layer, QGIS table). Rasterization and vectorization are important features of this module.") otb_module(OTBConversion DEPENDS OTBVectorDataBase OTBVectorDataManipulation OTBGdalAdapters OTBITK OTBImageBase OTBIOGDAL OTBStreaming OTBLabelMap OTBMetadata OTBBoost OTBGDAL OTBCommon TEST_DEPENDS OTBVectorDataIO OTBSmoothing OTBImageIO OTBProjection OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Segmentation/Conversion/test/000077500000000000000000000000001301006202600225675ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Conversion/test/CMakeLists.txt000066400000000000000000000213651301006202600253360ustar00rootroot00000000000000otb_module_test() set(OTBConversionTests otbConversionTestDriver.cxx otbVectorDataToLabelMapFilter.cxx otbOGRDataSourceToLabelImageFilter.cxx otbVectorDataToLabelMapFilterNew.cxx otbLabelImageToVectorDataFilterNew.cxx otbLabelImageToVectorDataFilter.cxx otbLabelImageToOGRDataSourceFilter.cxx otbVectorDataToLabelImageFilter.cxx otbPolygonizationRasterizationTest.cxx otbVectorDataRasterizeFilter.cxx otbLabelImageRegionPruningFilter.cxx otbLabelImageRegionMergingFilter.cxx otbLabelMapToVectorDataFilter.cxx otbLabelMapToVectorDataFilterNew.cxx ) add_executable(otbConversionTestDriver ${OTBConversionTests}) target_link_libraries(otbConversionTestDriver ${OTBConversion-Test_LIBRARIES}) otb_module_target_label(otbConversionTestDriver) # Tests Declaration otb_add_test(NAME obTvVectorDataToLabelMapFilter COMMAND otbConversionTestDriver otbVectorDataToLabelMapFilter ${INPUTDATA}/vectorIOexample_gis_to_vec.shp ${TEMP}/vectordataToLabelMap.png) otb_add_test(NAME coTuOGRDataSourceToLabelImageFilterNew COMMAND otbConversionTestDriver otbOGRDataSourceToLabelImageFilterNew ) otb_add_test(NAME coTvOGRDataSourceToLabelImageFilterSHP COMMAND otbConversionTestDriver --compare-image 0.0 ${INPUTDATA}/QB_Toulouse_ortho_labelImage.tif ${TEMP}/bfTvOGRDataSourceToLabelImageFilter_Output.tif otbOGRDataSourceToLabelImageFilter ${INPUTDATA}/QB_Toulouse_ortho_labelImage.tif ${INPUTDATA}/QB_Toulouse_ortho.shp ${TEMP}/bfTvOGRDataSourceToLabelImageFilter_Output.tif 1 0 255 ) otb_add_test(NAME bfTvOGRDataSourceToLabelImageFilterSHPForegroundMode COMMAND otbConversionTestDriver --compare-image 0.0 ${BASELINE}/bfTvOGRDataSourceToLabelImageFilter_Output_ForegroundMode.tif ${TEMP}/bfTvOGRDataSourceToLabelImageFilter_Output_ForegroundMode.tif otbOGRDataSourceToLabelImageFilter ${INPUTDATA}/QB_Toulouse_ortho_labelImage.tif ${INPUTDATA}/QB_Toulouse_ortho_partial.shp ${TEMP}/bfTvOGRDataSourceToLabelImageFilter_Output_ForegroundMode.tif 0 0 255 ) otb_add_test(NAME obTuVectorDataToLabelMapFilterNew COMMAND otbConversionTestDriver otbVectorDataToLabelMapFilterNew) otb_add_test(NAME obTuLabelImageToVectorDataFilterNew COMMAND otbConversionTestDriver otbLabelImageToVectorDataFilterNew) otb_add_test(NAME obTvLabelImageToVectorDataFilter COMMAND otbConversionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/obTuLabelImageToVectorDataFilter.shp ${TEMP}/obTuLabelImageToVectorDataFilter.shp otbLabelImageToVectorDataFilter ${INPUTDATA}/labelImage_UnsignedChar.tif ${TEMP}/obTuLabelImageToVectorDataFilter.shp ) otb_add_test(NAME obTuLabelImageToOGRDataSourceFilterNew COMMAND otbConversionTestDriver otbLabelImageToOGRDataSourceFilterNew) otb_add_test(NAME obTvLabelImageToOGRDataSourceFilter COMMAND otbConversionTestDriver otbLabelImageToOGRDataSourceFilter ${INPUTDATA}/labelImage_UnsignedChar.tif ) otb_add_test(NAME bfTuVectorDataToLabelImageFilterNew COMMAND otbConversionTestDriver otbVectorDataToLabelImageFilterNew ) otb_add_test(NAME bfTvVectorDataToLabelImageFilterSHP COMMAND otbConversionTestDriver --compare-image 0.0 ${INPUTDATA}/QB_Toulouse_ortho_labelImage.tif ${TEMP}/bfTvVectorDataToLabelImageFilter_Output.tif otbVectorDataToLabelImageFilter ${INPUTDATA}/QB_Toulouse_ortho_labelImage.tif ${INPUTDATA}/QB_Toulouse_ortho.shp ${TEMP}/bfTvVectorDataToLabelImageFilter_Output.tif ) otb_add_test(NAME bfTvPolygonizationRasterization_WGS84 COMMAND otbConversionTestDriver otbPolygonizationRasterizationTest ${INPUTDATA}/QB_Toulouse_ortho_labelImage_WGS84.tif ) otb_add_test(NAME bfTvPolygonizationRasterization_UTM COMMAND otbConversionTestDriver otbPolygonizationRasterizationTest ${INPUTDATA}/QB_Toulouse_ortho_labelImage.tif ) otb_add_test(NAME bfTvPolygonizationRasterization_Index COMMAND otbConversionTestDriver otbPolygonizationRasterizationTest ${INPUTDATA}/QB_Toulouse_labelImage_Index.tif ) otb_add_test(NAME bfTvPolygonizationRasterization_SensorModel COMMAND otbConversionTestDriver otbPolygonizationRasterizationTest ${INPUTDATA}/QB_Toulouse_SensorModel_labelImage.tif ) otb_add_test(NAME bfTvVectorDataRasterizeFilterKML COMMAND otbConversionTestDriver --compare-image 0.0001 ${BASELINE}/bfTvVectorDataRasterizeFilter_OutputKML.tif ${TEMP}/bfTvVectorDataRasterizeFilter_OutputKML.tif otbVectorDataRasterizeFilter ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif ${INPUTDATA}/Capitole-Shadows.kml ${TEMP}/bfTvVectorDataRasterizeFilter_OutputKML.tif ) otb_add_test(NAME bfTuVectorDataRasterizeFilterNew COMMAND otbConversionTestDriver otbVectorDataRasterizeFilterNew ) otb_add_test(NAME bfTvVectorDataRasterizeFilterSHP COMMAND otbConversionTestDriver --compare-image 0.0001 ${BASELINE}/bfTvVectorDataRasterizeFilter_OutputSHP.tif ${TEMP}/bfTvVectorDataRasterizeFilter_OutputSHP.tif otbVectorDataRasterizeFilter ${INPUTDATA}/QB_Toulouse_Ortho_XS.tif ${INPUTDATA}/Capitole-Shadows.shp ${TEMP}/bfTvVectorDataRasterizeFilter_OutputSHP.tif ) #otb_add_test(NAME bfTvLabelImageRegionPruningFilterQB_Suburb COMMAND otbConversionTestDriver #--compare-n-images ${EPSILON_7} 2 #${BASELINE}/bfLabelImageRegionPruningFilterMergeOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionPruningFilterMergeOutput_QB_Suburb.tif #${BASELINE}/bfLabelImageRegionPruningFilterClusteredOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionPruningFilterClusteredOutput_QB_Suburb.tif #otbLabelImageRegionPruningFilter #${INPUTDATA}/QB_Suburb.png #${TEMP}/bfLabelImageRegionPruningFilterSpectralOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionPruningFilterLabelOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionPruningFilterMergeOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionPruningFilterClusteredOutput_QB_Suburb.tif #4 25 0.1 100 10 #) #otb_add_test(NAME bfTvLabelImageRegionPruningFilterSPOT5 COMMAND otbConversionTestDriver #--compare-n-images ${EPSILON_7} 2 #${BASELINE}/bfLabelImageRegionPruningFilterMergeOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionPruningFilterMergeOutput_SPOT5.tif #${BASELINE}/bfLabelImageRegionPruningFilterClusteredOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionPruningFilterClusteredOutput_SPOT5.tif #otbLabelImageRegionPruningFilter #${INPUTDATA}/SPOT5_EXTRACTS/Arcachon/Arcachon_extrait_3852_3319_546_542.tif #${TEMP}/bfLabelImageRegionPruningFilterSpectralOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionPruningFilterLabelOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionPruningFilterMergeOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionPruningFilterClusteredOutput_SPOT5.tif #4 25 0.1 100 20 #) #otb_add_test(NAME bfTvLabelImageRegionMergingFilterQB_Suburb COMMAND otbConversionTestDriver #--compare-n-images ${EPSILON_7} 2 #${BASELINE}/bfLabelImageRegionMergingFilterMergeOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionMergingFilterMergeOutput_QB_Suburb.tif #${BASELINE}/bfLabelImageRegionMergingFilterClusteredOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionMergingFilterClusteredOutput_QB_Suburb.tif #otbLabelImageRegionMergingFilter #${INPUTDATA}/QB_Suburb.png #${TEMP}/bfLabelImageRegionMergingFilterSpectralOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionMergingFilterLabelOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionMergingFilterMergeOutput_QB_Suburb.tif #${TEMP}/bfLabelImageRegionMergingFilterClusteredOutput_QB_Suburb.tif #4 25 0.1 100 #) #otb_add_test(NAME bfTvLabelImageRegionMergingFilterSPOT5 COMMAND otbConversionTestDriver #--compare-n-images ${EPSILON_7} 2 #${BASELINE}/bfLabelImageRegionMergingFilterMergeOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionMergingFilterMergeOutput_SPOT5.tif #${BASELINE}/bfLabelImageRegionMergingFilterClusteredOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionMergingFilterClusteredOutput_SPOT5.tif #otbLabelImageRegionMergingFilter #${INPUTDATA}/SPOT5_EXTRACTS/Arcachon/Arcachon_extrait_3852_3319_546_542.tif #${TEMP}/bfLabelImageRegionMergingFilterSpectralOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionMergingFilterLabelOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionMergingFilterMergeOutput_SPOT5.tif #${TEMP}/bfLabelImageRegionMergingFilterClusteredOutput_SPOT5.tif #4 25 0.1 100 #) otb_add_test(NAME obTvLabelMapToVectorDataFilter2 COMMAND otbConversionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/obTvLabelMapToVectorDataFilter.shp ${TEMP}/obTvLabelMapToVectorDataFilter2.shp otbLabelMapToVectorDataFilter ${INPUTDATA}/rcc8_mire5.png ${TEMP}/obTvLabelMapToVectorDataFilter2.shp) otb_add_test(NAME obTvLabelMapToVectorDataFilter COMMAND otbConversionTestDriver --compare-ogr ${NOTOL} ${BASELINE_FILES}/obTvLabelMapToVectorDataFilter.shp ${TEMP}/obTvLabelMapToVectorDataFilter.shp otbLabelMapToVectorDataFilter ${INPUTDATA}/rcc8_mire1.png ${TEMP}/obTvLabelMapToVectorDataFilter.shp) otb_add_test(NAME obTuLabelMapToVectorDataFilterNew COMMAND otbConversionTestDriver otbLabelMapToVectorDataFilterNew) OTB-release-5.8/Modules/Segmentation/Conversion/test/otbConversionTestDriver.cxx000066400000000000000000000016341301006202600301650ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbVectorDataToLabelMapFilter); REGISTER_TEST(otbOGRDataSourceToLabelImageFilterNew); REGISTER_TEST(otbOGRDataSourceToLabelImageFilter); REGISTER_TEST(otbVectorDataToLabelMapFilterNew); REGISTER_TEST(otbLabelImageToVectorDataFilterNew); REGISTER_TEST(otbLabelImageToVectorDataFilter); REGISTER_TEST(otbLabelImageToOGRDataSourceFilterNew); REGISTER_TEST(otbLabelImageToOGRDataSourceFilter); REGISTER_TEST(otbVectorDataToLabelImageFilterNew); REGISTER_TEST(otbVectorDataToLabelImageFilter); REGISTER_TEST(otbPolygonizationRasterizationTest); REGISTER_TEST(otbVectorDataRasterizeFilterNew); REGISTER_TEST(otbVectorDataRasterizeFilter); REGISTER_TEST(otbLabelImageRegionPruningFilter); REGISTER_TEST(otbLabelImageRegionMergingFilter); REGISTER_TEST(otbLabelMapToVectorDataFilter); REGISTER_TEST(otbLabelMapToVectorDataFilterNew); } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbLabelImageRegionMergingFilter.cxx000066400000000000000000000071711301006202600316330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMeanShiftSmoothingImageFilter.h" #include "otbLabelImageRegionMergingFilter.h" int otbLabelImageRegionMergingFilter(int argc, char * argv[]) { if (argc != 10) { std::cerr << "Usage: " << argv[0] << " infname spectralfname labelfname labelmergedfname clusteredfname spatialBandwidth rangeBandwidth threshold maxiterationnumber" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * spectralfname = argv[2]; const char * labelfname = argv[3]; const char * labelmergedfname = argv[4]; const char * clusteredfname = argv[5]; const double spatialBandwidth = atof(argv[6]); const double rangeBandwidth = atof(argv[7]); const double threshold = atof(argv[8]); const unsigned int maxiterationnumber = atoi(argv[9]); /* maxit - threshold */ const unsigned int Dimension = 2; typedef float PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MeanShiftSmoothingImageFilter FilterType; typedef FilterType::OutputLabelImageType LabelImageType; typedef otb::ImageFileWriter LabelWriterType; typedef otb::LabelImageRegionMergingFilter MergeFilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Set filter parameters filter->SetSpatialBandwidth(spatialBandwidth); filter->SetRangeBandwidth(rangeBandwidth); filter->SetThreshold(threshold); filter->SetMaxIterationNumber(maxiterationnumber); filter->SetInput(reader->GetOutput()); //filter->SetNumberOfThreads(1); WriterType::Pointer writer2 = WriterType::New(); LabelWriterType::Pointer writer5 = LabelWriterType::New(); writer2->SetFileName(spectralfname); writer5->SetFileName(labelfname); writer2->SetInput(filter->GetRangeOutput()); writer5->SetInput(filter->GetLabelOutput()); MergeFilterType::Pointer mergeFilter = MergeFilterType::New(); mergeFilter->SetInputLabelImage(filter->GetLabelOutput()); mergeFilter->SetInputSpectralImage(filter->GetRangeOutput()); mergeFilter->SetRangeBandwidth(rangeBandwidth); LabelWriterType::Pointer mergeWriter = LabelWriterType::New(); mergeWriter->SetFileName(labelmergedfname); mergeWriter->SetInput(mergeFilter->GetOutput()); WriterType::Pointer clusteredWriter = WriterType::New(); clusteredWriter->SetFileName(clusteredfname); clusteredWriter->SetInput(mergeFilter->GetClusteredOutput()); writer2->Update(); writer5->Update(); mergeWriter->Update(); clusteredWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbLabelImageRegionPruningFilter.cxx000066400000000000000000000101101301006202600316500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMeanShiftSmoothingImageFilter.h" #include "otbLabelImageRegionMergingFilter.h" #include "otbLabelImageRegionPruningFilter.h" int otbLabelImageRegionPruningFilter(int argc, char * argv[]) { if (argc != 11) { std::cerr << "Usage: " << argv[0] << " infname spectralfname labelfname labelmergedfname clusteredfname spatialBandwidth rangeBandwidth threshold maxiterationnumber minsize" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * spectralfname = argv[2]; const char * labelfname = argv[3]; const char * labelprunedfname = argv[4]; const char * clusteredfname = argv[5]; const double spatialBandwidth = atof(argv[6]); const double rangeBandwidth = atof(argv[7]); const double threshold = atof(argv[8]); const unsigned int maxiterationnumber = atoi(argv[9]); const unsigned int minregionsize = atoi(argv[10]); /* maxit - threshold */ const unsigned int Dimension = 2; typedef float PixelType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MeanShiftSmoothingImageFilter FilterType; typedef FilterType::OutputLabelImageType LabelImageType; typedef otb::ImageFileWriter LabelWriterType; typedef otb::LabelImageRegionMergingFilter MergeFilterType; typedef otb::LabelImageRegionPruningFilter PruneFilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); // Set filter parameters filter->SetSpatialBandwidth(spatialBandwidth); filter->SetRangeBandwidth(rangeBandwidth); filter->SetThreshold(threshold); filter->SetMaxIterationNumber(maxiterationnumber); filter->SetInput(reader->GetOutput()); //filter->SetNumberOfThreads(1); WriterType::Pointer writer2 = WriterType::New(); LabelWriterType::Pointer writer5 = LabelWriterType::New(); writer2->SetFileName(spectralfname); writer5->SetFileName(labelfname); writer2->SetInput(filter->GetRangeOutput()); writer5->SetInput(filter->GetLabelOutput()); MergeFilterType::Pointer mergeFilter = MergeFilterType::New(); mergeFilter->SetInputLabelImage(filter->GetLabelOutput()); mergeFilter->SetInputSpectralImage(filter->GetRangeOutput()); mergeFilter->SetRangeBandwidth(rangeBandwidth); PruneFilterType::Pointer pruneFilter = PruneFilterType::New(); pruneFilter->SetInputLabelImage(mergeFilter->GetLabelOutput()); pruneFilter->SetInputSpectralImage(mergeFilter->GetClusteredOutput()); pruneFilter->SetMinRegionSize(minregionsize); LabelWriterType::Pointer pruneWriter = LabelWriterType::New(); pruneWriter->SetFileName(labelprunedfname); pruneWriter->SetInput(pruneFilter->GetOutput()); WriterType::Pointer clusteredWriter = WriterType::New(); clusteredWriter->SetFileName(clusteredfname); clusteredWriter->SetInput(pruneFilter->GetClusteredOutput()); writer2->Update(); writer5->Update(); pruneWriter->Update(); clusteredWriter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbLabelImageToOGRDataSourceFilter.cxx000066400000000000000000000035441301006202600320040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelImageToOGRDataSourceFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" int otbLabelImageToOGRDataSourceFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image InputLabelImageType; typedef otb::LabelImageToOGRDataSourceFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } int otbLabelImageToOGRDataSourceFilter(int argc, char * argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputLabelImageFile " << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image InputLabelImageType; typedef otb::LabelImageToOGRDataSourceFilter FilterType; typedef otb::ImageFileReader LabelImageReaderType; FilterType::Pointer filter = FilterType::New(); LabelImageReaderType::Pointer reader = LabelImageReaderType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbLabelImageToVectorDataFilter.cxx000066400000000000000000000035151301006202600314340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelImageToVectorDataFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" int otbLabelImageToVectorDataFilter(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputLabelImageFile outputVectorfile(shp)" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image InputLabelImageType; typedef otb::LabelImageToVectorDataFilter FilterType; typedef otb::ImageFileReader LabelImageReaderType; typedef FilterType::VectorDataType VectorDataType; typedef otb::VectorDataFileWriter WriterType; FilterType::Pointer filter = FilterType::New(); LabelImageReaderType::Pointer reader = LabelImageReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); filter->SetUse8Connected(false); writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbLabelImageToVectorDataFilterNew.cxx000066400000000000000000000017631301006202600321110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelImageToVectorDataFilter.h" #include "otbImage.h" int otbLabelImageToVectorDataFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image InputLabelImageType; typedef otb::LabelImageToVectorDataFilter FilterType; FilterType::Pointer filter = FilterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbLabelMapToVectorDataFilter.cxx000066400000000000000000000064271301006202600311340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageFileReader.h" #include "otbVectorDataFileWriter.h" #include "otbVectorData.h" #include "otbVectorDataProjectionFilter.h" #include #include #include "otbImage.h" #include "otbLabelMapToVectorDataFilter.h" #include "otbAttributesMapLabelObject.h" #include "itkLabelImageToLabelMapFilter.h" int otbLabelMapToVectorDataFilter(int argc, char * argv[]) { /** Use the labelObjecttopolygon functor (not thread safe) only polygon conversion is available yet*/ if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputImageFile outputVectorfile(shp)" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; // Labeled image type const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader LabeledReaderType; // Label map typedef typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef itk::LabelImageToLabelMapFilter LabelMapFilterType; typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileWriter WriterType; typedef otb::VectorDataProjectionFilter VectorDataFilterType; LabeledReaderType::Pointer lreader = LabeledReaderType::New(); lreader->SetFileName(infname); LabelMapFilterType::Pointer labelMapFilter = LabelMapFilterType::New(); labelMapFilter->SetInput(lreader->GetOutput()); labelMapFilter->SetBackgroundValue(itk::NumericTraits::min()); labelMapFilter->Update(); WriterType::Pointer writer = WriterType::New(); typedef otb::LabelMapToVectorDataFilter LabelMapToVectorDataFilterType; LabelMapToVectorDataFilterType::Pointer MyFilter = LabelMapToVectorDataFilterType::New(); MyFilter->SetInput(labelMapFilter->GetOutput()); MyFilter->Update(); MyFilter->GetOutput()->SetProjectionRef(lreader->GetOutput()->GetProjectionRef()); VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); vectorDataProjection->SetInputOrigin(lreader->GetOutput()->GetOrigin()); vectorDataProjection->SetInputSpacing(lreader->GetOutput()->GetSpacing()); vectorDataProjection->SetInput(MyFilter->GetOutput()); writer->SetFileName(outfname); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbLabelMapToVectorDataFilterNew.cxx000066400000000000000000000023111301006202600315720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelMapToVectorDataFilter.h" #include "otbVectorData.h" #include "itkAttributeLabelObject.h" int otbLabelMapToVectorDataFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { const int dim = 2; typedef otb::VectorData<> VectorDataType; typedef itk::AttributeLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::LabelMapToVectorDataFilter LabelMapToVectorDataFilterType; LabelMapToVectorDataFilterType::Pointer filter = LabelMapToVectorDataFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbOGRDataSourceToLabelImageFilter.cxx000066400000000000000000000046351301006202600320060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbOGRDataSourceToLabelImageFilter.h" #include "otbStandardOneLineFilterWatcher.h" typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::OGRDataSourceToLabelImageFilter RasterizationFilterType; int otbOGRDataSourceToLabelImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); return EXIT_SUCCESS; } int otbOGRDataSourceToLabelImageFilter(int itkNotUsed(argc), char * argv[]) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); bool mode = atoi(argv[4]); unsigned char background = atoi(argv[5]); unsigned char foreground = atoi(argv[6]); otb::ogr::DataSource::Pointer ogrDS = otb::ogr::DataSource::New(argv[2], otb::ogr::DataSource::Modes::Read); // rasterize RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); rasterization->AddOGRDataSource(ogrDS); rasterization->SetOutputParametersFromImage(reader->GetOutput()); rasterization->SetBurnAttribute("DN"); rasterization->SetBurnAttributeMode(mode); rasterization->SetBackgroundValue(background); rasterization->SetForegroundValue(foreground); /*otb::StandardOneLineFilterWatcher * watch = new otb::StandardOneLineFilterWatcher(rasterization.GetPointer(), "rasterization"); */ WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(rasterization->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbPolygonizationRasterizationTest.cxx000066400000000000000000000056511301006202600324730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbVectorDataFileReader.h" #include "otbLabelImageToVectorDataFilter.h" #include "otbVectorDataToLabelImageFilter.h" #include "otbStandardOneLineFilterWatcher.h" #include "itkNumericTraits.h" #include "itkImageRegionConstIteratorWithIndex.h" int otbPolygonizationRasterizationTest(int itkNotUsed(argc), char * argv[]) { typedef unsigned int PixelType; typedef otb::Image ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorData<> VectorDataType; typedef otb::LabelImageToVectorDataFilter LabelImageToVDFilterType; typedef otb::VectorDataToLabelImageFilter RasterizationFilterType; // Read the label image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // Instantiate a LabelImageToVectorData filter LabelImageToVDFilterType::Pointer polygonize = LabelImageToVDFilterType::New(); polygonize->SetInput(reader->GetOutput()); polygonize->Update(); // rasterize RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); rasterization->AddVectorData(polygonize->GetOutput()); rasterization->SetOutputParametersFromImage(reader->GetOutput()); rasterization->SetBurnAttribute("DN"); rasterization->Update(); // Compare the input label image and the output of the rasterization // filter, they must be exactly similar itk::ImageRegionConstIteratorWithIndex itRef(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionConstIteratorWithIndex itTest(rasterization->GetOutput(), rasterization->GetOutput()->GetLargestPossibleRegion()); for(itRef.GoToBegin(), itTest.GoToBegin(); !itRef.IsAtEnd() && !itTest.IsAtEnd(); ++itRef, ++itTest) { if (itRef.Get() != itTest.Get()) { std::cerr << "Pixel at position " << itRef.GetIndex() << " differs : in=" << itRef.Get() << " while out=" << itTest.Get() << std::endl; return EXIT_FAILURE; } } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbVectorDataRasterizeFilter.cxx000066400000000000000000000056611301006202600311230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataProjectionFilter.h" #include "otbRasterizeVectorDataFilter.h" #include "otbStandardOneLineFilterWatcher.h" typedef otb::VectorImage ImageType; typedef otb::VectorData<> VectorDataType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorDataFileReader VDReaderType; typedef otb::VectorDataProjectionFilter VDProjectionType; typedef otb::ImageFileWriter WriterType; typedef otb::RasterizeVectorDataFilter RasterizationFilterType; int otbVectorDataRasterizeFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); return EXIT_SUCCESS; } int otbVectorDataRasterizeFilter(int itkNotUsed(argc), char * argv[]) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); // Read and project the vd into the raster coordinates images VDReaderType::Pointer vdreader = VDReaderType::New(); vdreader->SetFileName(argv[2]); VDProjectionType::Pointer vdproj = VDProjectionType::New(); vdproj->SetInput(vdreader->GetOutput()); vdproj->SetInputProjectionRef(vdreader->GetOutput()->GetProjectionRef()); vdproj->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); vdproj->Update(); // rasterize RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); rasterization->SetInput(reader->GetOutput()); rasterization->AddVectorData(vdproj->GetOutput()); // choose the colors ImageType::PixelType outputcolor; outputcolor.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel()); outputcolor[0] = 0.; outputcolor[1] = 0.; outputcolor[2] = 255.; outputcolor[3] = 0.; rasterization->AddColor(outputcolor); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(rasterization->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbVectorDataToLabelImageFilter.cxx000066400000000000000000000052631301006202600314360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorDataFileReader.h" #include "otbVectorDataProjectionFilter.h" #include "otbVectorDataToLabelImageFilter.h" #include "otbStandardOneLineFilterWatcher.h" typedef otb::Image ImageType; typedef otb::VectorData<> VectorDataType; typedef otb::ImageFileReader ReaderType; typedef otb::VectorDataFileReader VDReaderType; typedef otb::VectorDataProjectionFilter VDProjectionType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorDataToLabelImageFilter RasterizationFilterType; int otbVectorDataToLabelImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); return EXIT_SUCCESS; } int otbVectorDataToLabelImageFilter(int itkNotUsed(argc), char * argv[]) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); // Read and project the vd into the raster coordinates images VDReaderType::Pointer vdreader = VDReaderType::New(); vdreader->SetFileName(argv[2]); VDProjectionType::Pointer vdproj = VDProjectionType::New(); vdproj->SetInput(vdreader->GetOutput()); vdproj->SetInputProjectionRef(vdreader->GetOutput()->GetProjectionRef()); vdproj->SetOutputProjectionRef(reader->GetOutput()->GetProjectionRef()); vdproj->Update(); // rasterize RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); rasterization->AddVectorData(vdproj->GetOutput()); rasterization->SetOutputParametersFromImage(reader->GetOutput()); rasterization->SetBurnAttribute("DN"); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(rasterization->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbVectorDataToLabelImageFilterWithoutReader.cxx000066400000000000000000000076641301006202600340750ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Conversion/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorDataToLabelImageFilter.h" #include "otbStandardOneLineFilterWatcher.h" typedef otb::Image ImageType; typedef otb::VectorData<> VectorDataType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::VectorDataToLabelImageFilter RasterizationFilterType; typedef VectorDataType::DataNodeType DataNodeType; typedef DataNodeType::PointType PointType; typedef DataNodeType::LineType LineType; typedef DataNodeType::PolygonType PolygonType; typedef LineType::VertexType VertexType; int main(int itkNotUsed(argc), char* argv[]) { //OGRRegisterAll(); // Create vector Data VectorDataType::Pointer data = VectorDataType::New(); DataNodeType::Pointer document = DataNodeType::New(); DataNodeType::Pointer folder = DataNodeType::New(); DataNodeType::Pointer polygon1 = DataNodeType::New(); DataNodeType::Pointer polygon2 = DataNodeType::New(); DataNodeType::Pointer polygon3 = DataNodeType::New(); DataNodeType::Pointer polygon4 = DataNodeType::New(); DataNodeType::Pointer polygon5 = DataNodeType::New(); document->SetNodeType(otb::DOCUMENT); folder->SetNodeType(otb::FOLDER); polygon1->SetNodeType(otb::FEATURE_POLYGON); document->SetNodeId("DOCUMENT"); folder->SetNodeId("THE_FOLDER"); polygon1->SetNodeId("FEATURE_POLYGON"); VertexType p1; p1.Fill(1); VertexType p3; p3.Fill(11); VertexType p2; p2[0] = 1; p2[1] = 11; VertexType p4; p4[0] = 11; p4[1] = 1; PolygonType::Pointer poly1 = PolygonType::New(); poly1->AddVertex(p1); poly1->AddVertex(p2); poly1->AddVertex(p3); poly1->AddVertex(p4); poly1->AddVertex(p1); polygon1->SetPolygonExteriorRing(poly1); polygon1->SetFieldAsInt("DN",32); p1.Fill(51); p3.Fill(61); p2[0] = 51; p2[1] = 61; p4[0] = 61; p4[1] = 51; PolygonType::Pointer poly2 = PolygonType::New(); poly2->AddVertex(p1); poly2->AddVertex(p2); poly2->AddVertex(p3); poly2->AddVertex(p4); poly2->AddVertex(p1); polygon2->SetLine(poly2); polygon2->SetFieldAsInt("DN",64); DataNodeType::Pointer root = data->GetDataTree()->GetRoot()->Get(); data->GetDataTree()->Add(document, root); data->GetDataTree()->Add(folder, document); data->GetDataTree()->Add(polygon1, folder); data->GetDataTree()->Add(polygon2, folder); data->Update(); // rasterize RasterizationFilterType::Pointer rasterization = RasterizationFilterType::New(); rasterization->AddVectorData(data); rasterization->SetBurnAttribute("DN"); // image infos ImageType::SizeType size; size[0] = 100; size[1] = 100; ImageType::PointType origin; origin[0]=0; origin[1]=0; ImageType::SpacingType spacing; spacing[0]=1; spacing[1]=1; rasterization->SetOutputSize(size); rasterization->SetOutputOrigin(origin); rasterization->SetOutputSpacing(spacing); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[1]); writer->SetInput(rasterization->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbVectorDataToLabelMapFilter.cxx000066400000000000000000000075211301006202600311300ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkLabelMapToLabelImageFilter.h" #include "itkTimeProbe.h" #include "otbMacro.h" #include "otbImage.h" //#include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbVectorDataToLabelMapFilter.h" #include "otbVectorDataFileReader.h" #include "itkMinimumMaximumImageCalculator.h" #include "otbAttributesMapLabelObject.h" #include "otbVectorDataProperties.h" #include "itkNumericTraits.h" int otbVectorDataToLabelMapFilter(int argc, char * argv[]) { /** Rasterize vectorData to LabelMap (only available for polygon yet)*/ if (argc != 3) { std::cerr << "Usage: " << argv[0]; std::cerr << " inputFile(shp) outputLabeledImagefile" << std::endl; return EXIT_FAILURE; } const char * infname = argv[1]; const char * outfname = argv[2]; //const char * outvectorfname = argv[3]; // Labeled image type const unsigned int Dimension = 2; typedef unsigned short LabelType; typedef otb::Image LabeledImageType; typedef otb::ImageFileWriter WriterType; // Label map typedef typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::VectorData VectorDataType; typedef otb::VectorDataFileReader ReaderType; typedef otb::VectorDataToLabelMapFilter VectorDataToLabelMapFilterType; typedef itk::LabelMapToLabelImageFilter LabelMapToLabelImageFilterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); //Update the reader reader->Update(); VectorDataToLabelMapFilterType::Pointer myFilter = VectorDataToLabelMapFilterType::New(); myFilter->SetInput(reader->GetOutput()); //TODO Simplify the use of the class VectorDataProperties //VectorDataProperties is needed to compute the ROI of the vectorData typedef otb::VectorDataProperties VectorDataPropertiesType; VectorDataPropertiesType::Pointer p = VectorDataPropertiesType::New(); //set the input vectordata to the properties properties p->SetVectorDataObject(reader->GetOutput()); typedef VectorDataType::DataNodeType::PolygonType::RegionType RegionType; RegionType region; p->SetBoundingRegion(region); //Compute the global bounding box of the vectordata p->ComputeBoundingRegion(); LabelMapType::PointType origin; origin[0] = p->GetBoundingRegion().GetImageRegion().GetIndex(0); origin[1] = p->GetBoundingRegion().GetImageRegion().GetIndex(1); //Set size, origin and spacing of the output labelmap myFilter->SetSize(p->GetBoundingRegion().GetImageRegion().GetSize()); myFilter->SetOrigin(origin); myFilter->SetSpacing(reader->GetOutput()->GetSpacing()); // Translate the LabelMap in a labeld image LabelMapToLabelImageFilterType::Pointer labelMapToImageFilter = LabelMapToLabelImageFilterType::New(); labelMapToImageFilter->SetInput(myFilter->GetOutput()); //Write the result to an image file WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(labelMapToImageFilter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Conversion/test/otbVectorDataToLabelMapFilterNew.cxx000066400000000000000000000025341301006202600316010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMacro.h" #include "otbVectorDataToLabelMapFilter.h" #include "otbAttributesMapLabelObject.h" int otbVectorDataToLabelMapFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef unsigned short LabelType; const unsigned int Dimension = 2; typedef otb::VectorData VectorDataType; typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap OutputLabelMapType; typedef otb::VectorDataToLabelMapFilter VectorDataToLabelMapFilterType; //Instantiation VectorDataToLabelMapFilterType::Pointer filter = VectorDataToLabelMapFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/000077500000000000000000000000001301006202600213545ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Labelling/CMakeLists.txt000066400000000000000000000000501301006202600241070ustar00rootroot00000000000000project(OTBLabelling) otb_module_impl() OTB-release-5.8/Modules/Segmentation/Labelling/include/000077500000000000000000000000001301006202600227775ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelToBoundaryImageFilter.h000066400000000000000000000063051301006202600310200ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkRelabelComponentImageFilter.h, v $ Language: C++ Date: $Date: 2009-04-27 22:58:48 $ Version: $Revision: 1.17 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelToBoundaryImageFilter_h #define otbLabelToBoundaryImageFilter_h #include "otbUnaryFunctorNeighborhoodImageFilter.h" namespace otb { namespace Functor { /** * \class LabelToBoundaryFunctor * * \brief Functor to extract segmentation boundaries * * Functor intended to work with 3x3 neighborhood and scalar label image * The generated boundary is 1-pixel wide, so it is not symmetric. * Output value is 1 on the boundaries and 0 in the background * * \ingroup OTBLabelling */ template < class TInput, class TOutput > class LabelToBoundaryFunctor { public: LabelToBoundaryFunctor() { } virtual ~LabelToBoundaryFunctor() { } TOutput operator() ( const TInput & input ) { unsigned char output = 1; if (input.GetCenterPixel() == input.GetPixel(5) && input.GetCenterPixel() == input.GetPixel(7) && input.GetCenterPixel() == input.GetPixel(8)) { output = 0; } return static_cast(output); } }; // end of class } // end of Functor namespace /** * \class LabelToBoundaryImageFilter * * \brief Filter to extract boundaries of a label image * * Filter intended to work with a scalar label image. * The generated boundary is 1-pixel wide, so it is not symmetric. * Output value is 1 on the boundaries and 0 in the background * * \ingroup OTBLabelling */ template < class TInputImage, class TOutputImage > class ITK_EXPORT LabelToBoundaryImageFilter : public UnaryFunctorNeighborhoodImageFilter< TInputImage, TOutputImage, Functor::LabelToBoundaryFunctor< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > { public: typedef LabelToBoundaryImageFilter Self; typedef UnaryFunctorNeighborhoodImageFilter< TInputImage, TOutputImage, Functor::LabelToBoundaryFunctor< typename itk::ConstNeighborhoodIterator, typename TOutputImage::PixelType > > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(LabelToBoundaryImageFilter,UnaryFunctorNeighborhoodImageFilter); protected: LabelToBoundaryImageFilter() { this->SetRadius(1); } ~LabelToBoundaryImageFilter() ITK_OVERRIDE { } private: LabelToBoundaryImageFilter( const Self & ); // Not implemented void operator=( const Self & ); // Not implemented }; // end of class } // end of otb namespace #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabeledOutputAccessor.h000066400000000000000000000021451301006202600301130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabeledOutputAccessor_h #define otbLabeledOutputAccessor_h #include "itkMacro.h" namespace otb { /** * \class LabeledOutputAccessor * \brief Accessor to the index of the labeled output image of the Template Filter. * * \ingroup OTBLabelling */ template class LabeledOutputAccessor { public: typedef typename TFilter::OutputImageType LabelImageType; itkStaticConstMacro(LabeledOutputIndex, unsigned int, 0); }; } #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelizeConfidenceConnectedImageFilter.h000066400000000000000000000075201301006202600333220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeConfidenceConnectedImageFilter_h #define otbLabelizeConfidenceConnectedImageFilter_h #include "itkConfidenceConnectedImageFilter.h" #include "otbLabelizeImageFilterBase.h" namespace otb { /** \class LabelizeConfidenceConnectedImageFilter * \brief Labels pixels with similar statistics using connectivity * * This class implements abstract class otb::LabelizeImageFilterBase * \see itk::ConfidenceConnectedImageFilter * * \ingroup OTBLabelling */ template class ITK_EXPORT LabelizeConfidenceConnectedImageFilter : public otb::LabelizeImageFilterBase > { public: /** typedef for standard classes. */ typedef LabelizeConfidenceConnectedImageFilter Self; typedef otb::LabelizeImageFilterBase > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** typedef to simplify variables definition and declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename TInputImage::IndexType IndexType; /** "object factory" management method. */ itkNewMacro(Self); /** Return the class name. */ itkTypeMacro(LabelizeConfidenceConnectedImageFilter, LabelizeImageFilterBase); /** Get multiplier */ double& GetMultiplier() const { return this->m_RegionGrowingFilter->GetMultiplier(); } /** Set multiplier */ void SetMultiplier(const double multiplier) { this->m_RegionGrowingFilter->SetMultiplier(multiplier); } /** Get number of iterations */ unsigned int& GetNumberOfIterations() const { return this->m_RegionGrowingFilter->GetNumberOfIterations(); } /** Set number of iterations */ void SetNumberOfIterations(const unsigned int iteration) { this->m_RegionGrowingFilter->SetNumberOfIterations(iteration); } /** Get replace value */ itkGetMacro(ReplaceValue, OutputPixelType); /** Set replace value */ itkSetMacro(ReplaceValue, OutputPixelType); /** Set initial neighborhood radius */ const unsigned int& GetInitialNeighborhoodRadius() { return this->m_RegionGrowingFilter->GetInitialNeighborhoodRadius(); } /** Set initial neighborhood radius */ void SetInitialNeighborhoodRadius(const unsigned int initial) { this->m_RegionGrowingFilter->SetInitialNeighborhoodRadius(initial); } protected: LabelizeConfidenceConnectedImageFilter(); ~LabelizeConfidenceConnectedImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Region growing */ void RegionGrowing(const IndexType indexSeed) ITK_OVERRIDE; private: LabelizeConfidenceConnectedImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Initial replace value*/ OutputPixelType m_ReplaceValue; }; // end class LabelizeconnectedThresholdImageFilter } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelizeConfidenceConnectedImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelizeConfidenceConnectedImageFilter.txx000066400000000000000000000032421301006202600337130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeConfidenceConnectedImageFilter_txx #define otbLabelizeConfidenceConnectedImageFilter_txx #include "itkNumericTraits.h" #include "otbLabelizeConfidenceConnectedImageFilter.h" namespace otb { /** * Constructor */ template LabelizeConfidenceConnectedImageFilter ::LabelizeConfidenceConnectedImageFilter() { m_ReplaceValue = itk::NumericTraits::One; } /** Region growing * */ template void LabelizeConfidenceConnectedImageFilter ::RegionGrowing(const IndexType indexSeed) { this->m_RegionGrowingFilter->SetReplaceValue(m_ReplaceValue); this->m_RegionGrowingFilter->SetSeed(indexSeed); m_ReplaceValue++; } /** PrintSelf Method * */ template void LabelizeConfidenceConnectedImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "ReplaceValue: " << m_ReplaceValue << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelizeConnectedThresholdImageFilter.h000066400000000000000000000062661301006202600332270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeConnectedThresholdImageFilter_h #define otbLabelizeConnectedThresholdImageFilter_h #include "itkConnectedThresholdImageFilter.h" #include "otbLabelizeImageFilterBase.h" namespace otb { /** \class LabelizeConnectedThresholdImageFilter * \brief TODO * * * \ingroup OTBLabelling */ template class ITK_EXPORT LabelizeConnectedThresholdImageFilter : public otb::LabelizeImageFilterBase > { public: /** typedef for standard classes. */ typedef LabelizeConnectedThresholdImageFilter Self; typedef otb::LabelizeImageFilterBase > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename TInputImage::IndexType IndexType; /** "object factory" management method. */ itkNewMacro(Self); /** Return the class name. */ itkTypeMacro(LabelizeConnectedThresholdImageFilter, LabelizeImageFilterBase); /** Get delta lower threshold */ itkGetMacro(LowerThresholdDelta, InputPixelType); /** Set delta lower threshold */ itkSetMacro(LowerThresholdDelta, InputPixelType); /** Get delta upper threshold */ itkGetMacro(UpperThresholdDelta, InputPixelType); /** Set delta upper threshold */ itkSetMacro(UpperThresholdDelta, InputPixelType); /** Get replace value */ itkGetMacro(ReplaceValue, OutputPixelType); /** Set replace value */ itkSetMacro(ReplaceValue, OutputPixelType); protected: LabelizeConnectedThresholdImageFilter(); ~LabelizeConnectedThresholdImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Region growing */ void RegionGrowing(const IndexType indexSeed) ITK_OVERRIDE; private: LabelizeConnectedThresholdImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Delta + threshold for growing region */ InputPixelType m_UpperThresholdDelta; /** Delta - threshold for growing region */ InputPixelType m_LowerThresholdDelta; /** Initial replace value*/ OutputPixelType m_ReplaceValue; }; // end class LabelizeconnectedThresholdImageFilter } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelizeConnectedThresholdImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelizeConnectedThresholdImageFilter.txx000066400000000000000000000042661301006202600336210ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeConnectedThresholdImageFilter_txx #define otbLabelizeConnectedThresholdImageFilter_txx #include "itkNumericTraits.h" #include "otbLabelizeConnectedThresholdImageFilter.h" namespace otb { /** * Constructor */ template LabelizeConnectedThresholdImageFilter ::LabelizeConnectedThresholdImageFilter() { m_LowerThresholdDelta = itk::NumericTraits::NonpositiveMin(); m_UpperThresholdDelta = itk::NumericTraits::max(); m_ReplaceValue = 5; //itk::NumericTraits::One; } /** Region growing * */ template void LabelizeConnectedThresholdImageFilter ::RegionGrowing(const IndexType indexSeed) { InputPixelType threshold = this->GetInput()->GetPixel(indexSeed); this->m_RegionGrowingFilter->SetLower(threshold - m_LowerThresholdDelta); this->m_RegionGrowingFilter->SetUpper(threshold + m_UpperThresholdDelta); this->m_RegionGrowingFilter->SetReplaceValue(m_ReplaceValue); this->m_RegionGrowingFilter->SetSeed(indexSeed); m_ReplaceValue++; } /** PrintSelf Method * */ template void LabelizeConnectedThresholdImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "LowerThresholdDelta: " << m_LowerThresholdDelta << std::endl; os << indent << "UpperThresholdDelta: " << m_UpperThresholdDelta << std::endl; os << indent << "ReplaceValue: " << m_ReplaceValue << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelizeImageFilterBase.h000066400000000000000000000105341301006202600303130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeImageFilterBase_h #define otbLabelizeImageFilterBase_h #include "itkImageToImageFilter.h" #include "itkAddImageFilter.h" #include "otbThresholdImageToPointSetFilter.h" #include "otbMultiplyByScalarImageFilter.h" namespace otb { /** \class LabelizeImageFilterBase * \brief Base class for filter labelizing image region based on segmentation. * * * \ingroup OTBLabelling */ template class ITK_EXPORT LabelizeImageFilterBase : public itk::ImageToImageFilter { public: /** typedef for standard classes. */ typedef LabelizeImageFilterBase Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** typedef to simplify variables definition and declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename TInputImage::PixelType InputPixelType; typedef typename TOutputImage::PixelType OutputPixelType; typedef typename TInputImage::IndexType IndexType; typedef itk::PointSet PointSetType; typedef typename PointSetType::Pointer PointSetPointerType; typedef TFilter RegionGrowingFilterType; typedef typename TFilter::Pointer RegionGrowingFilterPointerType; /** "object factory" management method. */ itkNewMacro(Self); /** Return the class name. */ itkTypeMacro(LabelizeImageFilterBase, ImageToImageFilter); /** Get lower threshold */ itkGetMacro(LowerThreshold, InputPixelType); /** Set lower threshold */ itkSetMacro(LowerThreshold, InputPixelType); /** Get upper threshold */ itkGetMacro(UpperThreshold, InputPixelType); /** Set upper threshold */ itkSetMacro(UpperThreshold, InputPixelType); /** Get Object count*/ // only set after completion // itkGetConstReferenceMacro(ObjectCount, unsigned long); itkGetMacro(ObjectCount, unsigned long); /** Internal */ typedef otb::ThresholdImageToPointSetFilter ThresholdFilterType; typedef typename ThresholdFilterType::Pointer ThresholdFilterPointerType; typedef otb::MultiplyByScalarImageFilter MultiplyFilterType; typedef typename MultiplyFilterType::Pointer MultiplyFilterPointerType; typedef itk::AddImageFilter AddImageFilterType; typedef typename AddImageFilterType::Pointer AddImageFilterPointerType; protected: LabelizeImageFilterBase(); ~LabelizeImageFilterBase() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** Region growing */ virtual void RegionGrowing(const IndexType itkNotUsed(indexSeed)) {} /** Instance region growing filter*/ RegionGrowingFilterPointerType m_RegionGrowingFilter; /** Lower threshold */ InputPixelType m_LowerThreshold; /** Upper threshold */ InputPixelType m_UpperThreshold; /** Point set to store thresold results */ PointSetPointerType m_PointSet; /** Multiply filter*/ MultiplyFilterPointerType m_MultiplyFilter; /** Threshold point set filter */ ThresholdFilterPointerType m_ThresholdPointSetFilter; /** Object counting */ unsigned long m_ObjectCount; private: LabelizeImageFilterBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; // end class LabelizeImageFilterBase } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelizeImageFilterBase.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelizeImageFilterBase.txx000066400000000000000000000070131301006202600307050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeImageFilterBase_txx #define otbLabelizeImageFilterBase_txx #include "otbLabelizeImageFilterBase.h" namespace otb { /** * Constructor */ template LabelizeImageFilterBase ::LabelizeImageFilterBase() { m_LowerThreshold = itk::NumericTraits::NonpositiveMin(); m_UpperThreshold = itk::NumericTraits::max(); m_MultiplyFilter = MultiplyFilterType::New(); m_MultiplyFilter->SetCoef(0.0); m_ThresholdPointSetFilter = ThresholdFilterType::New(); m_RegionGrowingFilter = RegionGrowingFilterType::New(); } /** Generate data * */ template void LabelizeImageFilterBase ::GenerateData() { // set input for region growing filter m_RegionGrowingFilter->SetInput(this->GetInput()); // create an empty image to store results computing m_MultiplyFilter->SetInput(this->GetInput()); m_MultiplyFilter->Update(); // Compute points set m_ThresholdPointSetFilter->SetInput(0, this->GetInput()); m_ThresholdPointSetFilter->SetLowerThreshold(m_LowerThreshold); m_ThresholdPointSetFilter->SetUpperThreshold(m_UpperThreshold); m_ThresholdPointSetFilter->Update(); m_PointSet = m_ThresholdPointSetFilter->GetOutput(); m_ObjectCount = 0; // Iterate Point set typedef typename PointSetType::PointsContainer ContainerType; ContainerType* pointsContainer = m_PointSet->GetPoints(); typedef typename ContainerType::Iterator IteratorType; IteratorType itList = pointsContainer->Begin(); typename OutputImageType::Pointer outputImage = m_MultiplyFilter->GetOutput(); while (itList != pointsContainer->End()) { typename PointSetType::PointType pCoordinate = (itList.Value()); typename InputImageType::IndexType index; index[0] = static_cast (pCoordinate[0]); index[1] = static_cast (pCoordinate[1]); if (outputImage->GetPixel(index) == itk::NumericTraits::ZeroValue()) { this->RegionGrowing(index); AddImageFilterPointerType addImage = AddImageFilterType::New(); addImage->SetInput1(outputImage); addImage->SetInput2(m_RegionGrowingFilter->GetOutput()); addImage->Update(); outputImage = addImage->GetOutput(); ++m_ObjectCount; } ++itList; } this->GraftOutput(outputImage); } /** PrintSelf Method * */ template void LabelizeImageFilterBase ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Seeds lower threshold: " << m_LowerThreshold << std::endl; os << indent << "Seeds upper threshold: " << m_UpperThreshold << std::endl; os << indent << "ObjectCount: " << m_ObjectCount << std::endl; os << indent << m_RegionGrowingFilter << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbLabelizeNeighborhoodConnectedImageFilter.h000066400000000000000000000076401301006202600336770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeNeighborhoodConnectedImageFilter_h #define otbLabelizeNeighborhoodConnectedImageFilter_h #include "itkNeighborhoodConnectedImageFilter.h" #include "otbLabelizeImageFilterBase.h" namespace otb { /** \class LabelizeNeighborhoodConnectedImageFilter * \brief Labels pixels that are connected to a seed and lie * within a neighborhood * * This class implements base class otb::LabelizeImageFilterBase * * First seeds are obtained with a threshold filter * For each seed, itk::NeighborhoodConnectedImageFilter labels pixel * Finally, filter produce a regions map * * \ingroup OTBLabelling */ template class ITK_EXPORT LabelizeNeighborhoodConnectedImageFilter : public otb::LabelizeImageFilterBase > { public: /** typedef for standard classes. */ typedef LabelizeNeighborhoodConnectedImageFilter Self; typedef otb::LabelizeImageFilterBase > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** typedef to simplify variables definition and declaration. */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename TInputImage::PixelType InputPixelType; typedef typename TInputImage::SizeType InputSizeType; typedef typename TInputImage::IndexType IndexType; typedef typename TOutputImage::PixelType OutputPixelType; /** "object factory" management method. */ itkNewMacro(Self); /** Return the class name. */ itkTypeMacro(LabelizeNeighborhoodConnectedImageFilter, LabelizeImageFilterBase); /** Get delta lower threshold */ itkGetMacro(LowerThresholdDelta, InputPixelType); /** Set delta lower threshold */ itkSetMacro(LowerThresholdDelta, InputPixelType); /** Get delta upper threshold */ itkGetMacro(UpperThresholdDelta, InputPixelType); /** Set delta upper threshold */ itkSetMacro(UpperThresholdDelta, InputPixelType); /** Get replace value */ itkGetMacro(ReplaceValue, OutputPixelType); /** Set replace value */ itkSetMacro(ReplaceValue, OutputPixelType); /** Get radius */ const InputSizeType& GetRadius() const { return this->m_RegionGrowingFilter->GetRadius(); } /** Set radius */ void SetRadius(const InputSizeType radius) { this->m_RegionGrowingFilter->SetRadius(radius); this->Modified(); } protected: LabelizeNeighborhoodConnectedImageFilter(); ~LabelizeNeighborhoodConnectedImageFilter() ITK_OVERRIDE {} void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** Region growing */ void RegionGrowing(const IndexType indexSeed) ITK_OVERRIDE; private: LabelizeNeighborhoodConnectedImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Delta + threshold for growing region */ InputPixelType m_UpperThresholdDelta; /** Delta - threshold for growing region */ InputPixelType m_LowerThresholdDelta; /** Initial replace value*/ OutputPixelType m_ReplaceValue; }; // end class LabelizeconnectedThresholdImageFilter } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbLabelizeNeighborhoodConnectedImageFilter.txx" #endif #endif otbLabelizeNeighborhoodConnectedImageFilter.txx000066400000000000000000000042471301006202600342140ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Labelling/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbLabelizeNeighborhoodConnectedImageFilter_txx #define otbLabelizeNeighborhoodConnectedImageFilter_txx #include "otbLabelizeNeighborhoodConnectedImageFilter.h" namespace otb { /** * Constructor */ template LabelizeNeighborhoodConnectedImageFilter ::LabelizeNeighborhoodConnectedImageFilter() { m_LowerThresholdDelta = itk::NumericTraits::NonpositiveMin(); m_UpperThresholdDelta = itk::NumericTraits::max(); m_ReplaceValue = itk::NumericTraits::One; } /** Region growing * */ template void LabelizeNeighborhoodConnectedImageFilter ::RegionGrowing(const IndexType indexSeed) { InputPixelType threshold = this->GetInput()->GetPixel(indexSeed); this->m_RegionGrowingFilter->SetLower(threshold - m_LowerThresholdDelta); this->m_RegionGrowingFilter->SetUpper(threshold + m_UpperThresholdDelta); this->m_RegionGrowingFilter->SetReplaceValue(m_ReplaceValue); this->m_RegionGrowingFilter->SetSeed(indexSeed); m_ReplaceValue++; } /** PrintSelf Method * */ template void LabelizeNeighborhoodConnectedImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "LowerThresholdDelta: " << m_LowerThresholdDelta << std::endl; os << indent << "UpperThresholdDelta: " << m_UpperThresholdDelta << std::endl; os << indent << "ReplaceValue: " << m_ReplaceValue << std::endl; } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbRelabelComponentImageFilter.h000066400000000000000000000127101301006202600312200ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkRelabelComponentImageFilter.h, v $ Language: C++ Date: $Date: 2009-04-27 22:58:48 $ Version: $Revision: 1.17 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRelabelComponentImageFilter_h #define otbRelabelComponentImageFilter_h #include "itkRelabelComponentImageFilter.h" #include namespace otb { /** * \class RelabelComponentImageFilter * \brief Relabel the components in an image such that consecutive labels are used. * * RelabelComponentImageFilter remaps the labels associated with the * objects in an image (as from the output of * ConnectedComponentImageFilter) such that the label numbers are * consecutive with no gaps between the label numbers used. By * default, the relabeling will also sort the labels based on the size * of the object: the largest object will have label #1, the second * largest will have label #2, etc. * * Label #0 is assumed to be background is left unaltered by the * relabeling. * * RelabelComponentImageFilter is typically used on the output of the * ConnectedComponentImageFilter for those applications that want to * extract the largest object or the "k" largest objects. Any * particular object can be extracted from the relabeled output using * a BinaryThresholdImageFilter. A group of objects can be extracted * from the relabled output using a ThresholdImageFilter. * * Once all the objects are relabeled, the application can query the * number of objects and the size of each object. Object sizes are * returned in a vector. The size of the background is not * calculated. So the size of object #1 is * GetSizeOfObjectsInPixels()[0], the size of object #2 is * GetSizeOfObjectsInPixels()[1], etc. * * If user sets a minimum object size, all objects with fewer pixelss * than the minimum will be discarded, so that the number of objects * reported will be only those remaining. The * GetOriginalNumberOfObjects method can be called to find out how * many objects were present before the small ones were discarded. * * RelabelComponentImageFilter can be run as an "in place" filter, * where it will overwrite its output. The default is run out of * place (or generate a separate output). "In place" operation can be * controlled via methods in the superclass, * InPlaceImageFilter::InPlaceOn() and InPlaceImageFilter::InPlaceOff(). * * \sa ConnectedComponentImageFilter, BinaryThresholdImageFilter, ThresholdImageFilter * * \ingroup Singlethreaded * * \ingroup OTBLabelling */ template class ITK_EXPORT RelabelComponentImageFilter : public itk::RelabelComponentImageFilter< TInputImage, TOutputImage > { public: /** * Standard "Self" & Superclass typedef. */ typedef RelabelComponentImageFilter Self; typedef itk::RelabelComponentImageFilter < TInputImage, TOutputImage > Superclass; /** * Types from the Superclass */ typedef typename Superclass::InputImagePointer InputImagePointer; /** * Extract some information from the image types. Dimensionality * of the two images is assumed to be the same. */ typedef typename TOutputImage::PixelType OutputPixelType; typedef typename TOutputImage::InternalPixelType OutputInternalPixelType; typedef typename TInputImage::PixelType InputPixelType; typedef typename TInputImage::InternalPixelType InputInternalPixelType; itkStaticConstMacro(ImageDimension, unsigned int, TOutputImage::ImageDimension); itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension); /** * Image typedef support */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename TInputImage::IndexType IndexType; typedef typename TInputImage::SizeType SizeType; typedef typename TOutputImage::RegionType RegionType; /** * Smart pointer typedef support */ typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** * Run-time type information (and related methods) */ itkTypeMacro(RelabelComponentImageFilter, ImageToImageFilter); /** * Method for creation through the object factory. */ itkNewMacro(Self); /** Type used as identifier for the different component labels. */ typedef unsigned long int LabelType; /** Type used to count number of pixels in objects. */ typedef unsigned long int ObjectSizeType; protected: RelabelComponentImageFilter(); virtual ~RelabelComponentImageFilter() {} void GenerateInputRequestedRegion(); void EnlargeOutputRequestedRegion(itk::DataObject *){}; private: RelabelComponentImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } // end namespace otb #ifndef ITK_MANUAL_INSTANTIATION #include "otbRelabelComponentImageFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Labelling/include/otbRelabelComponentImageFilter.txx000066400000000000000000000025611301006202600316170ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkRelabelComponentImageFilter.txx, v $ Language: C++ Date: $Date: 2009-04-27 22:58:48 $ Version: $Revision: 1.18 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbRelabelComponentImageFilter_txx #define otbRelabelComponentImageFilter_txx #include "otbRelabelComponentImageFilter.h" #include "itkImageRegionIterator.h" #include "itkNumericTraits.h" #include "itkProgressReporter.h" #include namespace otb { template RelabelComponentImageFilter ::RelabelComponentImageFilter() { } template< class TInputImage, class TOutputImage > void RelabelComponentImageFilter< TInputImage, TOutputImage > ::GenerateInputRequestedRegion() { itk::ImageToImageFilter::GenerateInputRequestedRegion(); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Labelling/otb-module.cmake000066400000000000000000000013421301006202600244250ustar00rootroot00000000000000set(DOCUMENTATION "This module contains useful tools for the task of labelling images. It is possible to label with similar statistics using connectivity, to include pixels in a growing region is to evaluate intensity value inside a specific interval, or to label pixels that are connected to a seed and lie within a neighbourhood. Remaping the labels is also possible, so that that the label numbers are consecutive with no gaps between the label numbers used. Finally, it is also possible to sort the labels based on the size of the object.") otb_module(OTBLabelling DEPENDS OTBITK OTBImageManipulation OTBPointSet TEST_DEPENDS OTBImageBase OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Segmentation/Labelling/test/000077500000000000000000000000001301006202600223335ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Labelling/test/CMakeLists.txt000066400000000000000000000053141301006202600250760ustar00rootroot00000000000000otb_module_test() set(OTBLabellingTests otbLabellingTestDriver.cxx otbLabelizeConfidenceConnectedImageFilter.cxx otbLabelizeConnectedThresholdImageFilter.cxx otbLabelizeConnectedThresholdImageFilterNew.cxx otbLabelizeNeighborhoodConnectedImageFilterNew.cxx otbLabelizeNeighborhoodConnectedImageFilter.cxx otbLabelizeConfidenceConnectedImageFilterNew.cxx otbLabelToBoundaryImageFilterNew.cxx otbLabelToBoundaryImageFilter.cxx ) add_executable(otbLabellingTestDriver ${OTBLabellingTests}) target_link_libraries(otbLabellingTestDriver ${OTBLabelling-Test_LIBRARIES}) otb_module_target_label(otbLabellingTestDriver) # Tests Declaration otb_add_test(NAME bfTvLabelizeConfidenceConnectedImageFilter COMMAND otbLabellingTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvLabelizeConfidenceConnectedImageFilterOutput.png ${TEMP}/bfTvLabelizeConfidenceConnectedImageFilterOutput.png otbLabelizeConfidenceConnectedImageFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvLabelizeConfidenceConnectedImageFilterOutput.png 127 127 2 3 1 ) otb_add_test(NAME bfTvLabelizeConnectedThresholdImageFilter COMMAND otbLabellingTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvLabelizeConnectedThresholdImageFilterOutput.png ${TEMP}/bfTvLabelizeConnectedThresholdImageFilterOutput.png otbLabelizeConnectedThresholdImageFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvLabelizeConnectedThresholdImageFilterOutput.png 170 170 80 80 ) otb_add_test(NAME bfTuLabelizeConnectedThresholdImageFilterNew COMMAND otbLabellingTestDriver otbLabelizeConnectedThresholdImageFilterNew) otb_add_test(NAME bfTuLabelizeNeighborhoodConnectedImageFilterNew COMMAND otbLabellingTestDriver otbLabelizeNeighborhoodConnectedImageFilterNew) otb_add_test(NAME bfTvLabelizeNeighborhoodConnectedImageFilter COMMAND otbLabellingTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvLabelizeNeighborhoodConnectedImageFilterOutput.png ${TEMP}/bfTvLabelizeNeighborhoodConnectedImageFilterOutput.png otbLabelizeNeighborhoodConnectedImageFilter ${INPUTDATA}/QB_Suburb.png ${TEMP}/bfTvLabelizeNeighborhoodConnectedImageFilterOutput.png 170 170 80 80 ) otb_add_test(NAME bfTuLabelizeConfidenceConnectedImageFilterNew COMMAND otbLabellingTestDriver otbLabelizeConfidenceConnectedImageFilterNew) otb_add_test(NAME bfTuLabelToBoundaryImageFilterNew COMMAND otbLabellingTestDriver otbLabelToBoundaryImageFilterNew) otb_add_test(NAME bfTvLabelToBoundaryImageFilter COMMAND otbLabellingTestDriver --compare-image ${EPSILON_7} ${BASELINE}/bfTvLabelToBoundaryImageFilterOutput.tif ${TEMP}/bfTvLabelToBoundaryImageFilterOutput.tif otbLabelToBoundaryImageFilter ${INPUTDATA}/maur_labelled.tif ${TEMP}/bfTvLabelToBoundaryImageFilterOutput.tif) OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabelToBoundaryImageFilter.cxx000066400000000000000000000035021301006202600307230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelToBoundaryImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbLabelToBoundaryImageFilter(int argc, char * argv []) { typedef unsigned int InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::LabelToBoundaryImageFilter BoundaryFilterType; typedef BoundaryFilterType::Pointer BoundaryFilterPointerType; if (argc != 3) { std::cerr << "Usage : "<SetFileName(inputPath); BoundaryFilterPointerType filter = BoundaryFilterType::New(); filter->SetInput(reader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(outputPath); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabelToBoundaryImageFilterNew.cxx000066400000000000000000000023451301006202600314010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelToBoundaryImageFilter.h" #include "otbImage.h" int otbLabelToBoundaryImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned int InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LabelToBoundaryImageFilter BoundaryFilterType; typedef BoundaryFilterType::Pointer BoundaryFilterPointerType; BoundaryFilterPointerType filter = BoundaryFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabelizeConfidenceConnectedImageFilter.cxx000066400000000000000000000063001301006202600332240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkUnaryFunctorImageFilter.h" #include "itkScalarToRGBPixelFunctor.h" #include "itkRescaleIntensityImageFilter.h" #include "otbLabelizeConfidenceConnectedImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbLabelizeConfidenceConnectedImageFilter(int itkNotUsed(argc), char * argv[]) { // Arguments char* inputImageName = argv[1]; char* outputImageName = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef itk::RGBPixel ColorPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image RGBImageType; InputPixelType lowerThreshold((InputPixelType) ::atoi(argv[3])); InputPixelType upperThreshold((InputPixelType) ::atoi(argv[4])); double multiplier = (double) (atof(argv[5])); unsigned int numberOfIterations = (unsigned int) (atoi(argv[6])); unsigned int initialRadius = (unsigned int) (atoi(argv[7])); // Reader typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Writer typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageName); // Labelize filter typedef otb::LabelizeConfidenceConnectedImageFilter LabelizeFilterType; LabelizeFilterType::Pointer filter = LabelizeFilterType::New(); filter->SetLowerThreshold(lowerThreshold); filter->SetUpperThreshold(upperThreshold); filter->SetMultiplier(multiplier); filter->SetNumberOfIterations(numberOfIterations); filter->SetInitialNeighborhoodRadius(initialRadius); // Rescale intensity typedef itk::RescaleIntensityImageFilter RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); // Label to RGB image typedef itk::Functor::ScalarToRGBPixelFunctor FunctorType; typedef itk::UnaryFunctorImageFilter ColorLabelFilterType; ColorLabelFilterType::Pointer labelToRGB = ColorLabelFilterType::New(); filter->SetInput(reader->GetOutput()); rescaler->SetInput(filter->GetOutput()); labelToRGB->SetInput(rescaler->GetOutput()); writer->SetInput(labelToRGB->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabelizeConfidenceConnectedImageFilterNew.cxx000066400000000000000000000024131301006202600336770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelizeConfidenceConnectedImageFilter.h" #include "otbImage.h" int otbLabelizeConfidenceConnectedImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LabelizeConfidenceConnectedImageFilter LabelizeFilterType; typedef LabelizeFilterType::Pointer LabelizeFilterPointerType; LabelizeFilterPointerType filter = LabelizeFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabelizeConnectedThresholdImageFilter.cxx000066400000000000000000000053661301006202600331360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkScalarToRGBPixelFunctor.h" #include "itkUnaryFunctorImageFilter.h" #include "otbLabelizeConnectedThresholdImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbLabelizeConnectedThresholdImageFilter(int itkNotUsed(argc), char * argv[]) { // Arguments char* inputImageName = argv[1]; char* outputImageName = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef itk::RGBPixel ColorPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image RGBImageType; InputPixelType lowerThreshold((InputPixelType) ::atoi(argv[3])); InputPixelType upperThreshold((InputPixelType) ::atoi(argv[4])); InputPixelType deltaLower((InputPixelType) ::atoi(argv[5])); InputPixelType deltaUpper((InputPixelType) ::atoi(argv[6])); // Reader typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Writer typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageName); // Labelize filter typedef otb::LabelizeConnectedThresholdImageFilter LabelizeFilterType; LabelizeFilterType::Pointer filter = LabelizeFilterType::New(); filter->SetLowerThreshold(lowerThreshold); filter->SetUpperThreshold(upperThreshold); filter->SetLowerThresholdDelta(deltaLower); filter->SetUpperThresholdDelta(deltaUpper); // Label to RGB image typedef itk::Functor::ScalarToRGBPixelFunctor FunctorType; typedef itk::UnaryFunctorImageFilter ColorLabelFilterType; ColorLabelFilterType::Pointer labelToRGB = ColorLabelFilterType::New(); filter->SetInput(reader->GetOutput()); labelToRGB->SetInput(filter->GetOutput()); writer->SetInput(labelToRGB->GetOutput()); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabelizeConnectedThresholdImageFilterNew.cxx000066400000000000000000000024101301006202600335730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelizeConnectedThresholdImageFilter.h" #include "otbImage.h" int otbLabelizeConnectedThresholdImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LabelizeConnectedThresholdImageFilter LabelizeFilterType; typedef LabelizeFilterType::Pointer LabelizeFilterPointerType; LabelizeFilterPointerType filter = LabelizeFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabelizeNeighborhoodConnectedImageFilter.cxx000066400000000000000000000053761301006202600336120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "itkScalarToRGBPixelFunctor.h" #include "itkUnaryFunctorImageFilter.h" #include "otbLabelizeNeighborhoodConnectedImageFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbLabelizeNeighborhoodConnectedImageFilter(int itkNotUsed(argc), char * argv[]) { // Arguments char* inputImageName = argv[1]; char* outputImageName = argv[2]; typedef unsigned short InputPixelType; typedef unsigned char OutputPixelType; typedef itk::RGBPixel ColorPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image RGBImageType; InputPixelType lowerThreshold((InputPixelType) ::atoi(argv[3])); InputPixelType upperThreshold((InputPixelType) ::atoi(argv[4])); InputPixelType deltaLower((InputPixelType) ::atoi(argv[5])); InputPixelType deltaUpper((InputPixelType) ::atoi(argv[6])); // Reader typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputImageName); // Writer typedef otb::ImageFileWriter WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputImageName); // Labelize filter typedef otb::LabelizeNeighborhoodConnectedImageFilter LabelizeFilterType; LabelizeFilterType::Pointer filter = LabelizeFilterType::New(); filter->SetLowerThreshold(lowerThreshold); filter->SetUpperThreshold(upperThreshold); filter->SetLowerThresholdDelta(deltaLower); filter->SetUpperThresholdDelta(deltaUpper); // Label to RGB image typedef itk::Functor::ScalarToRGBPixelFunctor FunctorType; typedef itk::UnaryFunctorImageFilter ColorLabelFilterType; ColorLabelFilterType::Pointer labelToRGB = ColorLabelFilterType::New(); filter->SetInput(reader->GetOutput()); labelToRGB->SetInput(filter->GetOutput()); writer->SetInput(labelToRGB->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbLabelizeNeighborhoodConnectedImageFilterNew.cxx000066400000000000000000000024211301006202600341710ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Labelling/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbLabelizeNeighborhoodConnectedImageFilter.h" #include "otbImage.h" int otbLabelizeNeighborhoodConnectedImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; const unsigned int Dimension = 2; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::LabelizeNeighborhoodConnectedImageFilter LabelizeFilterType; typedef LabelizeFilterType::Pointer LabelizeFilterPointerType; LabelizeFilterPointerType filter = LabelizeFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Labelling/test/otbLabellingTestDriver.cxx000066400000000000000000000010101301006202600274610ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbLabelizeConfidenceConnectedImageFilter); REGISTER_TEST(otbLabelizeConnectedThresholdImageFilter); REGISTER_TEST(otbLabelizeConnectedThresholdImageFilterNew); REGISTER_TEST(otbLabelizeNeighborhoodConnectedImageFilterNew); REGISTER_TEST(otbLabelizeNeighborhoodConnectedImageFilter); REGISTER_TEST(otbLabelizeConfidenceConnectedImageFilterNew); REGISTER_TEST(otbLabelToBoundaryImageFilter); REGISTER_TEST(otbLabelToBoundaryImageFilterNew); } OTB-release-5.8/Modules/Segmentation/MeanShift/000077500000000000000000000000001301006202600213415ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MeanShift/CMakeLists.txt000066400000000000000000000000501301006202600240740ustar00rootroot00000000000000project(OTBMeanShift) otb_module_impl() OTB-release-5.8/Modules/Segmentation/MeanShift/include/000077500000000000000000000000001301006202600227645ustar00rootroot00000000000000otbMeanShiftConnectedComponentSegmentationFilter.h000066400000000000000000000115461301006202600347020ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MeanShift/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanShiftConnectedComponentSegmentationFilter_h #define otbMeanShiftConnectedComponentSegmentationFilter_h #include "itkMacro.h" #include "otbConnectedComponentMuParserFunctor.h" #include "itkConnectedComponentFunctorImageFilter.h" #include "otbMaskMuParserFilter.h" #include "itkRelabelComponentImageFilter.h" #include "otbMeanShiftSmoothingImageFilter.h" namespace otb { /** \class MeanShiftConnectedComponentSegmentationFilter * \brief [internal] Helper class to perform connected component segmentation on an input image, * * * The whole chain is described in : * http://wiki.orfeo-toolbox.org/index.php/Connected_component_segmentation_module * * This class wraps a processing chain based on meanshift filtering followed by a connected component segmentation, * * An optional mask can be applied to segment only the pixels inside the mask. * * Parameters of the chain are : * - MaskExpression : mathematical expression to apply on the input image to make a mask * - ConnectedComponentExpression : mathematical expression which connects two pixels * - MinimumObjectSize : minimum object size kept after segmentation * * * \ingroup OTBMeanShift */ template class MeanShiftConnectedComponentSegmentationFilter : public itk::ImageToImageFilter { public: /** Standard Self typedef */ typedef MeanShiftConnectedComponentSegmentationFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef unsigned int ObjectSizeType; /** Some convenient typedefs. */ typedef TVInputImage VectorImageType; typedef TMaskImage MaskImageType; typedef TLabelImage LabelImageType; typedef typename VectorImageType::Pointer VectorImagePointerType; typedef typename VectorImageType::PixelType VectorImagePixelType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(MeanShiftConnectedComponentSegmentationFilter, ImageToImageFilter); /** ImageDimension constants */ itkStaticConstMacro(InputImageDimension, unsigned int,TVInputImage::ImageDimension); // Mask generation typedef Functor::ConnectedComponentMuParserFunctor FunctorType; typedef itk::ConnectedComponentFunctorImageFilter ConnectedComponentFilterType; // mask typedef typedef otb::MaskMuParserFilter MaskMuParserFilterType; // Labelization typedef itk::RelabelComponentImageFilter RelabelComponentFilterType; typedef double KernelType; typedef otb::MeanShiftSmoothingImageFilter MeanShiftFilterType; typedef typename MeanShiftFilterType::Pointer MeanShiftFilterPointerType; // ** // meanshift filter /* Set/Get mean shift filter */ itkSetObjectMacro(MeanShiftFilter, MeanShiftFilterType); itkGetObjectMacro(MeanShiftFilter, MeanShiftFilterType); /* Set the mathematical expression used for the mask */ itkSetStringMacro(MaskExpression); /* Get the mathematical expression used for the mask */ itkGetStringMacro(MaskExpression); /* Set the mathematical expression used during connected component segmentation */ itkSetStringMacro(ConnectedComponentExpression); /* Get the mathematical expression used during connected component segmentation */ itkGetStringMacro(ConnectedComponentExpression); /* Set the minimum object size */ itkSetMacro(MinimumObjectSize, ObjectSizeType); /* Get the minimum object size */ itkGetMacro(MinimumObjectSize, ObjectSizeType); protected: MeanShiftConnectedComponentSegmentationFilter(); ~MeanShiftConnectedComponentSegmentationFilter() ITK_OVERRIDE; void GenerateInputRequestedRegion() ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: MeanShiftFilterPointerType m_MeanShiftFilter; /* CC parameters */ ObjectSizeType m_MinimumObjectSize; std::string m_MaskExpression; std::string m_ConnectedComponentExpression; /* */ }; } // end namespace itk #ifndef OTB_MANUAL_INSTANTIATION #include "otbMeanShiftConnectedComponentSegmentationFilter.txx" #endif #endif otbMeanShiftConnectedComponentSegmentationFilter.txx000066400000000000000000000066071301006202600353000ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MeanShift/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanShiftConnectedComponentSegmentationFilter_txx #define otbMeanShiftConnectedComponentSegmentationFilter_txx #include "otbMeanShiftConnectedComponentSegmentationFilter.h" #include "itkExtractImageFilter.h" namespace otb { template MeanShiftConnectedComponentSegmentationFilter ::MeanShiftConnectedComponentSegmentationFilter() { m_MinimumObjectSize=2; m_MeanShiftFilter= MeanShiftFilterType::New(); } template MeanShiftConnectedComponentSegmentationFilter ::~MeanShiftConnectedComponentSegmentationFilter() { } template void MeanShiftConnectedComponentSegmentationFilter ::GenerateInputRequestedRegion() { Superclass::GenerateInputRequestedRegion(); } template void MeanShiftConnectedComponentSegmentationFilter ::GenerateData() { // Apply an ExtractImageFilter to avoid problems with filters asking for the LargestPossibleRegion typedef itk::ExtractImageFilter ExtractImageFilterType; typename ExtractImageFilterType::Pointer extract = ExtractImageFilterType::New(); extract->SetInput(this->GetInput()); extract->SetExtractionRegion(this->GetOutput()->GetRequestedRegion()); // WARNING: itk::ExtractImageFilter does not copy the MetadataDictionary // meanshift filtering //not necessary /* if (this->m_MeanShiftFilter.IsNotNull()) { itkExceptionMacro("MeanShiftFilter is null"); }*/ this->m_MeanShiftFilter->SetInput(extract->GetOutput()); //this->m_MeanShiftFilter->SetInput(this->GetInput()); typename MaskImageType::Pointer mask; if (!m_MaskExpression.empty()) { // Compute the mask typename MaskMuParserFilterType::Pointer maskFilter; maskFilter = MaskMuParserFilterType::New(); maskFilter->SetInput(this->m_MeanShiftFilter->GetOutput()); maskFilter->SetExpression(m_MaskExpression); maskFilter->Update(); mask = maskFilter->GetOutput(); } // Perform connected components segmentation typename ConnectedComponentFilterType::Pointer connected = ConnectedComponentFilterType::New(); connected->SetInput(this->m_MeanShiftFilter->GetOutput()); if (mask.IsNotNull()) connected->SetMaskImage(mask); connected->GetFunctor().SetExpression(m_ConnectedComponentExpression); connected->Update(); // Relabel connected component output typename RelabelComponentFilterType::Pointer relabel = RelabelComponentFilterType::New(); relabel->SetInput(connected->GetOutput()); relabel->SetMinimumObjectSize(m_MinimumObjectSize); relabel->Update(); this->GraftOutput(relabel->GetOutput()); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/MeanShift/include/otbMeanShiftSegmentationFilter.h000066400000000000000000000154161301006202600312530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanShiftSegmentationFilter_h #define otbMeanShiftSegmentationFilter_h #include "itkMacro.h" #include "otbMeanShiftSmoothingImageFilter.h" #include "otbLabelImageRegionMergingFilter.h" #include "otbLabelImageRegionPruningFilter.h" #include "itkRelabelComponentImageFilter.h" #include "itkConnectedComponentFunctorImageFilter.h" namespace otb { namespace Functor { template class ITK_EXPORT ConnectedLabelFunctor { public: typedef ConnectedLabelFunctor Self; std::string GetNameOfClass() { return "ConnectedLabelFunctor"; } inline bool operator()( TInput &p1, TInput &p2) { //return static_cast (0); return static_cast (p1==p2); } ConnectedLabelFunctor() { } ~ConnectedLabelFunctor() { } private: ConnectedLabelFunctor(const Self &); //purposely not implemented void operator =(const Self &); //purposely not implemented }; } // end of Functor namespace /** \class MeanShiftSegmentationFilter * * Performs segmentation of an image by chaining a mean shift filter and region * merging filter. * This filter relies on MeanShift Labeled image created from clustered filtered output of meanshift filter. * Mode search algorithm is not performed on tiles boundaries. Thus output depends on Thread numbers. * * \ingroup OTBMeanShift */ template class ITK_EXPORT MeanShiftSegmentationFilter : public itk::ImageToImageFilter { public: /** Standard Self typedef */ typedef MeanShiftSegmentationFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputImage InputSpectralImageType; typedef TOutputLabelImage OutputLabelImageType; typedef TOutputClusteredImage OutputClusteredImageType; typedef TKernel KernelType; typedef double RealType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(MeanShiftSegmentationFilter, ImageToImageFilter); /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); // Mean shift filter typedef OutputClusteredImageType MeanShiftFilteredImageType; typedef MeanShiftSmoothingImageFilter MeanShiftFilterType; typedef typename MeanShiftFilterType::Pointer MeanShiftFilterPointerType; // Region merging filter typedef typename MeanShiftFilterType::OutputLabelImageType InputLabelImageType; typedef typename MeanShiftFilterType::LabelType InputLabelPixelType; typedef LabelImageRegionMergingFilter RegionMergingFilterType; typedef typename RegionMergingFilterType::Pointer RegionMergingFilterPointerType; typedef LabelImageRegionPruningFilter RegionPruningFilterType; typedef typename RegionPruningFilterType::Pointer RegionPruningFilterPointerType; typedef Functor::ConnectedLabelFunctor LabelFunctorType; typedef itk::ConnectedComponentFunctorImageFilter RelabelComponentFilterType; typedef typename RelabelComponentFilterType::Pointer RelabelComponentFilterPointerType; /** Sets the spatial bandwidth (or radius in the case of a uniform kernel) * of the neighborhood for each pixel */ otbSetObjectMemberMacro(MeanShiftFilter,SpatialBandwidth,RealType); otbGetObjectMemberConstReferenceMacro(MeanShiftFilter,SpatialBandwidth,RealType); /** Sets the spectral bandwidth (or radius for a uniform kernel) for pixels * to be included in the same mode */ otbSetObjectMemberMacro(MeanShiftFilter,RangeBandwidth,RealType); otbGetObjectMemberConstReferenceMacro(MeanShiftFilter,RangeBandwidth,RealType); /** Set the maximum number of iterations */ otbSetObjectMemberMacro(MeanShiftFilter,MaxIterationNumber,unsigned int); otbGetObjectMemberConstReferenceMacro(MeanShiftFilter,MaxIterationNumber,unsigned int); /** Set the convergence threshold */ otbSetObjectMemberMacro(MeanShiftFilter,Threshold,RealType); otbGetObjectMemberConstReferenceMacro(MeanShiftFilter,Threshold,RealType); /** Sets the minimum region size. (after merging step clustered regions, which size is under this * threshold will be fused with adjacent region with smallest spectral distance). */ otbSetObjectMemberMacro(RegionPruningFilter,MinRegionSize,RealType); otbGetObjectMemberMacro(RegionPruningFilter,MinRegionSize,RealType); /** Returns the const image of region labels */ const OutputLabelImageType * GetLabelOutput() const; /** Returns the image of region labels */ OutputLabelImageType * GetLabelOutput(); /** Returns the const clustered output image, with one spectral value per region */ const OutputClusteredImageType * GetClusteredOutput() const; /** Returns the clustered output image, with one spectral value per region */ OutputClusteredImageType * GetClusteredOutput(); protected: MeanShiftSegmentationFilter(); ~MeanShiftSegmentationFilter() ITK_OVERRIDE; // virtual void GenerateOutputInformation(void); void GenerateData() ITK_OVERRIDE; private: MeanShiftFilterPointerType m_MeanShiftFilter; RegionMergingFilterPointerType m_RegionMergingFilter; RegionPruningFilterPointerType m_RegionPruningFilter; RelabelComponentFilterPointerType m_RelabelFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMeanShiftSegmentationFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/MeanShift/include/otbMeanShiftSegmentationFilter.txx000066400000000000000000000112371301006202600316440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMeanShiftSegmentationFilter_txx #define otbMeanShiftSegmentationFilter_txx #include "otbMeanShiftSegmentationFilter.h" namespace otb { template MeanShiftSegmentationFilter ::MeanShiftSegmentationFilter() { m_MeanShiftFilter = MeanShiftFilterType::New(); m_RegionMergingFilter = RegionMergingFilterType::New(); m_RegionPruningFilter = RegionPruningFilterType::New(); m_RelabelFilter = RelabelComponentFilterType::New(); this->SetMinRegionSize(100); this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0,TOutputLabelImage::New()); this->SetNthOutput(1,TOutputClusteredImage::New()); } template MeanShiftSegmentationFilter ::~MeanShiftSegmentationFilter() {} template TOutputLabelImage * MeanShiftSegmentationFilter ::GetLabelOutput() { return static_cast(this->itk::ProcessObject::GetOutput(0)); } template const TOutputLabelImage * MeanShiftSegmentationFilter ::GetLabelOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(0)); } template typename MeanShiftSegmentationFilter::OutputClusteredImageType * MeanShiftSegmentationFilter ::GetClusteredOutput() { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template const typename MeanShiftSegmentationFilter::OutputClusteredImageType * MeanShiftSegmentationFilter ::GetClusteredOutput() const { return static_cast(this->itk::ProcessObject::GetOutput(1)); } template void MeanShiftSegmentationFilter ::GenerateData() { this->m_MeanShiftFilter->SetInput(this->GetInput()); // Relabel output to avoid same label assigned to discontinuous areas m_RelabelFilter->SetInput(this->m_MeanShiftFilter->GetLabelOutput()); this->m_RegionMergingFilter->SetInputLabelImage(this->m_RelabelFilter->GetOutput()); this->m_RegionMergingFilter->SetInputSpectralImage(this->m_MeanShiftFilter->GetRangeOutput()); this->m_RegionMergingFilter->SetRangeBandwidth(this->GetRangeBandwidth()); if (this->GetMinRegionSize() == 0) { m_RegionMergingFilter->GraftNthOutput(0, this->GetLabelOutput()); m_RegionMergingFilter->GraftNthOutput(1, this->GetClusteredOutput()); this->m_RegionMergingFilter->Update(); this->GraftNthOutput(0, m_RegionMergingFilter->GetLabelOutput()); this->GraftNthOutput(1, m_RegionMergingFilter->GetClusteredOutput()); } else { this->m_RegionPruningFilter->SetInputLabelImage(this->m_RegionMergingFilter->GetLabelOutput()); this->m_RegionPruningFilter->SetInputSpectralImage(this->m_RegionMergingFilter->GetClusteredOutput()); m_RegionPruningFilter->GraftNthOutput(0, this->GetLabelOutput()); m_RegionPruningFilter->GraftNthOutput(1, this->GetClusteredOutput()); this->m_RegionPruningFilter->Update(); this->GraftNthOutput(0, m_RegionPruningFilter->GetLabelOutput()); this->GraftNthOutput(1, m_RegionPruningFilter->GetClusteredOutput()); } } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/MeanShift/otb-module.cmake000066400000000000000000000005021301006202600244070ustar00rootroot00000000000000set(DOCUMENTATION "This Module contains classes that implement the MeanShift segmentation algorithm.") otb_module(OTBMeanShift DEPENDS OTBCCOBIA OTBConversion OTBSmoothing OTBITK OTBMathParser TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Segmentation/MeanShift/test/000077500000000000000000000000001301006202600223205ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MeanShift/test/CMakeLists.txt000066400000000000000000000023501301006202600250600ustar00rootroot00000000000000otb_module_test() set(OTBMeanShiftTests otbMeanShiftTestDriver.cxx otbMeanShiftConnectedComponentSegmentationFilterTest.cxx otbMeanShiftSegmentationFilter.cxx ) add_executable(otbMeanShiftTestDriver ${OTBMeanShiftTests}) target_link_libraries(otbMeanShiftTestDriver ${OTBMeanShift-Test_LIBRARIES}) otb_module_target_label(otbMeanShiftTestDriver) # Tests Declaration otb_add_test(NAME obTuMeanShiftConnectedComponentSegmentationFilter COMMAND otbMeanShiftTestDriver otbMeanShiftConnectedComponentSegmentationFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/obTuMeanShiftConnectedComponentSegmentationImage.png 9 9 0.01 "distance<0.2" 50) otb_add_test(NAME obTuMeanShiftSegmentationFilterPruning COMMAND otbMeanShiftTestDriver otbMeanShiftSegmentationFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/obTuMeanShiftSegmentationFilterLabelImagePruning.tif ${TEMP}/obTuMeanShiftSegmentationFilterClusteredImagePruning.tif 4 25 100 0.1 20 ) otb_add_test(NAME obTuMeanShiftSegmentationFilter COMMAND otbMeanShiftTestDriver otbMeanShiftSegmentationFilter ${INPUTDATA}/ROI_QB_MUL_4.tif ${TEMP}/obTuMeanShiftSegmentationFilterLabelImage.tif ${TEMP}/obTuMeanShiftSegmentationFilterClusteredImage.tif 4 25 100 0.1 ) otbMeanShiftConnectedComponentSegmentationFilterTest.cxx000066400000000000000000000056731301006202600354550ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MeanShift/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbMeanShiftConnectedComponentSegmentationFilter.h" typedef float InputPixelType; const unsigned int Dimension = 2; typedef otb::Image LabelImageType; typedef otb::Image MaskImageType; typedef otb::VectorImage ImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::MeanShiftConnectedComponentSegmentationFilter < ImageType, MaskImageType, LabelImageType > MeanShiftConnectedComponentsegmentationFilterType; typedef otb::MeanShiftSmoothingImageFilter MeanShiftFilterType; int otbMeanShiftConnectedComponentSegmentationFilter(int itkNotUsed(argc), char * argv[]) { /* mean shift parameters */ const char * infname = argv[1]; const char * outputFilename = argv[2]; /* mean shift parameters */ const double spatialBandwidth = atof(argv[3]); const double rangeBandwidth = atof(argv[4]); const double threshold = atof(argv[5]); /* conencted component parameters */ const char * segmentationexpression = argv[6]; unsigned int minobjectsize = atoi(argv[7]); // add meanshift options // Instantiating object MeanShiftFilterType::Pointer meanShiftFilter = MeanShiftFilterType::New(); MeanShiftConnectedComponentsegmentationFilterType::Pointer segmentationFilter= MeanShiftConnectedComponentsegmentationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); meanShiftFilter->SetSpatialBandwidth(spatialBandwidth); meanShiftFilter->SetRangeBandwidth(rangeBandwidth); meanShiftFilter->SetThreshold(threshold); meanShiftFilter->SetInput(reader->GetOutput()); meanShiftFilter->GetRangeOutput(); // set the mean shift filter segmentationFilter->SetMeanShiftFilter(meanShiftFilter); segmentationFilter->SetInput(meanShiftFilter->GetRangeOutput()); segmentationFilter->SetConnectedComponentExpression(segmentationexpression); segmentationFilter->SetMinimumObjectSize(minobjectsize); //segmentationFilter->Update(); writer->SetInput(segmentationFilter->GetOutput()); writer->SetFileName(outputFilename); writer->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/MeanShift/test/otbMeanShiftSegmentationFilter.cxx000066400000000000000000000060501301006202600311540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMeanShiftSegmentationFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbMeanShiftSegmentationFilter(int argc, char * argv[]) { if (argc != 8 && argc != 9 ) { std::cerr << "Usage: " << argv[0] << " inputFileName outputLabelFileName outputClusteredFileName spatialBandwidth rangeBandwidth maxIter threshold minregionsize" << std::endl; return EXIT_FAILURE; } const char * inputFileName = argv[1]; const char * outputLabelFileName = argv[2]; const char * outputClusteredFileName = argv[3]; const double spatialBandwidth = atof(argv[4]); const double rangeBandwidth = atof(argv[5]); const unsigned int maxIter = atoi(argv[6]); const double threshold = atof(argv[7]); double minregionsize = 0; if(argc == 9) minregionsize = atof(argv[8]); /* maxit - threshold */ const unsigned int Dimension = 2; typedef float PixelType; typedef otb::VectorImage ImageType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter ClusteredWriterType; typedef otb::ImageFileWriter LabelWriterType; typedef otb::MeanShiftSegmentationFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Set filter parameters filter->SetSpatialBandwidth(spatialBandwidth); filter->SetRangeBandwidth(rangeBandwidth); filter->SetMaxIterationNumber(maxIter); filter->SetThreshold(threshold); filter->SetMinRegionSize(minregionsize); filter->SetInput(reader->GetOutput()); //filter->SetNumberOfThreads(1); ClusteredWriterType::Pointer writerClustered = ClusteredWriterType::New(); LabelWriterType::Pointer writerLabel = LabelWriterType::New(); writerClustered->SetFileName(outputClusteredFileName); writerLabel->SetFileName(outputLabelFileName); writerClustered->SetInput(filter->GetClusteredOutput()); writerLabel->SetInput(filter->GetLabelOutput()); writerClustered->Update(); writerLabel->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/MeanShift/test/otbMeanShiftTestDriver.cxx000066400000000000000000000002461301006202600274450ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMeanShiftConnectedComponentSegmentationFilter); REGISTER_TEST(otbMeanShiftSegmentationFilter); } OTB-release-5.8/Modules/Segmentation/Metrics/000077500000000000000000000000001301006202600210715ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Metrics/CMakeLists.txt000066400000000000000000000000461301006202600236310ustar00rootroot00000000000000project(OTBMetrics) otb_module_impl() OTB-release-5.8/Modules/Segmentation/Metrics/include/000077500000000000000000000000001301006202600225145ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Metrics/include/otbHooverInstanceFilter.h000066400000000000000000000232541301006202600274750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHooverInstanceFilter_h #define otbHooverInstanceFilter_h #include #include "itkInPlaceLabelMapFilter.h" #include "itkVariableSizeMatrix.h" #include "itkVariableLengthVector.h" namespace otb { /** \class HooverInstanceFilter * * \brief This class computes the Hoover instances. * * The Hoover instances are computed from two segmentations : ground truth (GT) and machine segmentation (MS); and * a Hoover confusion matrix. It is intended to work with AttributesMapLabelObject, where the Hoover scores will be stored. * The different instances are : * - correct detection (a GT region paired with a MS region) * - under segmentation (a MS region paired with a set of GT regions) * - over segmentation (a GT region paired with a set of MS regions) * - missed (a GT region that doesn't belong to any of the previous instances) * - noise (a MS region that doesn't belong to any of the previous instances) * * The corresponding scores are : * - RC : for correct detection * - RF : for over segmentation * - RA : for under segmentation * - RM : for missed regions (only for GT) * - RN : for noise regions (only for MS) * * These Hoover scores that are stored in the label maps are computed between 0 (if the region doesn't belong to this kind of instance) and 1. * * If the user wants to which region labels have been paired, he can set the flag UseExtendedAttributes. The extended attributes contain the * labels that have been paired in Hoover instances: * - ATTRIBUTE_CD (correct detection) : label of the corresponding region in the other segmentation * - ATTRIBUTE_OS[_x] (over segmentation) : label of the opposite over segmented region in GT / labels of the corresponding regions of MS * - ATTRIBUTE_US[_x] (under segmentation) : labels of the corresponding regions of GT / label of the under segmentated region of MS * - ATTRIBUTE_M (missed) : missed region own label (in GT) * - ATTRIBUTE_N (noise) : noise region own label (in MS) * * These attributes are handled in a different way than the Hoover scores. The simple presence of an extended attribute in a given region has a * meaning, regardless of its value. It is assumed that its value always corresponds to an existing region label. This is why these extended * attributes are not reset but removed before computing Hoover instances. * (see Hoover et al., "An experimental comparison of range image segmentation algorithms", IEEE PAMI vol. 18, no. 7, July 1996) * * \sa HooverMatrixFilter * * \ingroup OTBMetrics */ template< class TLabelMap > class ITK_EXPORT HooverInstanceFilter : public itk::InPlaceLabelMapFilter< TLabelMap > { public: /** Standard class typedefs. */ typedef HooverInstanceFilter Self; typedef itk::InPlaceLabelMapFilter< TLabelMap > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard New method. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(HooverInstanceFilter, InPlaceLabelMapFilter); /** Some convenient typedefs. */ typedef TLabelMap LabelMapType; typedef typename LabelMapType::Pointer LabelMapPointer; typedef typename LabelMapType::ConstIterator ConstIteratorType; typedef typename LabelMapType::Iterator IteratorType; typedef typename LabelMapType::LabelObjectType LabelObjectType; typedef typename LabelObjectType::AttributeType AttributeType; typedef typename LabelObjectType::AttributesValueType AttributesValueType; typedef typename LabelMapType::LabelVectorType LabelVectorType; typedef typename LabelMapType::RegionType ImageRegionType; //typedef typename LabelObjectType::LineContainerType LineContainerType; typedef typename LabelObjectType::IndexType IndexType; typedef typename LabelObjectType::LabelType LabelType; typedef unsigned long CoefficientType; typedef itk::VariableSizeMatrix MatrixType; typedef itk::VariableLengthVector CardinalVector; typedef std::set RegionSetType; typedef std::vector ObjectVectorType; void SetGroundTruthLabelMap(const LabelMapType *gt); void SetMachineSegmentationLabelMap(const LabelMapType *ms); const LabelMapType* GetGroundTruthLabelMap(); LabelMapType* GetMachineSegmentationLabelMap(); LabelMapType* GetOutputGroundTruthLabelMap(); LabelMapType* GetOutputMachineSegmentationLabelMap(); itkSetMacro(HooverMatrix, MatrixType); itkGetMacro(HooverMatrix, MatrixType); itkSetMacro(Threshold, double); itkGetMacro(Threshold, double); itkSetMacro(UseExtendedAttributes, bool); itkGetMacro(UseExtendedAttributes, bool); /** Get the average scores (after filter update) */ itkGetMacro(MeanRC, AttributesValueType); itkGetMacro(MeanRF, AttributesValueType); itkGetMacro(MeanRA, AttributesValueType); itkGetMacro(MeanRM, AttributesValueType); itkGetMacro(MeanRN, AttributesValueType); enum AttributeTypes { ATTRIBUTE_CD=100, ATTRIBUTE_OS, ATTRIBUTE_US, ATTRIBUTE_M, ATTRIBUTE_N, ATTRIBUTE_RC, ATTRIBUTE_RF, ATTRIBUTE_RA, ATTRIBUTE_RM, ATTRIBUTE_RN }; static std::string GetNameFromAttribute( const AttributeType & a ) { std::string name; switch( a ) { case ATTRIBUTE_CD: name = "HooverInstance_Ext_CD"; break; case ATTRIBUTE_OS: name = "HooverInstance_Ext_OS"; break; case ATTRIBUTE_US: name = "HooverInstance_Ext_US"; break; case ATTRIBUTE_M: name = "HooverInstance_Ext_M"; break; case ATTRIBUTE_N: name = "HooverInstance_Ext_N"; break; case ATTRIBUTE_RC: name = "HooverInstance_RC"; break; case ATTRIBUTE_RF: name = "HooverInstance_RF"; break; case ATTRIBUTE_RA: name = "HooverInstance_RA"; break; case ATTRIBUTE_RM: name = "HooverInstance_RM"; break; case ATTRIBUTE_RN: name = "HooverInstance_RN"; break; } return name; } static AttributeType GetAttributeFromName( const std::string & name ) { if ( name == "HooverInstance_Ext_CD" ) { return ATTRIBUTE_CD; } else if ( name == "HooverInstance_Ext_OS" ) { return ATTRIBUTE_OS; } else if ( name == "HooverInstance_Ext_US" ) { return ATTRIBUTE_US; } else if ( name == "HooverInstance_Ext_M" ) { return ATTRIBUTE_M; } else if ( name == "HooverInstance_Ext_N" ) { return ATTRIBUTE_N; } else if ( name == "HooverInstance_RC" ) { return ATTRIBUTE_RC; } else if ( name == "HooverInstance_RF" ) { return ATTRIBUTE_RF; } else if ( name == "HooverInstance_RA" ) { return ATTRIBUTE_RA; } else if ( name == "HooverInstance_RM" ) { return ATTRIBUTE_RM; } else if ( name == "HooverInstance_RN" ) { return ATTRIBUTE_RN; } } protected: HooverInstanceFilter(); ~HooverInstanceFilter() ITK_OVERRIDE {}; /** Re implement the allocate output method to handle the second output correctly */ void AllocateOutputs() ITK_OVERRIDE; /** Re implement the release input method to handle the second input correctly */ void ReleaseInputs() ITK_OVERRIDE; /** Actions : * - Fill cardinalities of GT regions */ void ThreadedProcessLabelObject( LabelObjectType * labelObject ) ITK_OVERRIDE; /** Actions: * - Check matrix size * - Init cardinalities lists * - Fill cardinalities list for MS (GT is done by ThreadedProcessLabelObject) */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Actions : * - Compute Hoover instances */ void AfterThreadedGenerateData() ITK_OVERRIDE; private: /** number of regions (label objects) found in ground truth (GT) */ unsigned long m_NumberOfRegionsGT; /** number of regions (label objects) found in machine segmentation (MS) */ unsigned long m_NumberOfRegionsMS; /** List of labels in GT segmentation */ LabelVectorType m_LabelsGT; /** Hoover confusion matrix computed between GT and MS*/ MatrixType m_HooverMatrix; /** List of region sizes in GT */ CardinalVector m_CardRegGT; /** List of region sizes in MS */ CardinalVector m_CardRegMS; /** Threshold used to compute Hoover instances */ double m_Threshold; /** Flag to output additional information in label maps */ bool m_UseExtendedAttributes; /** Average score for correct detection on the whole segmentation */ AttributesValueType m_MeanRC; /** Average score for over segmentation on the whole segmentation */ AttributesValueType m_MeanRF; /** Average score for under segmentation on the whole segmentation */ AttributesValueType m_MeanRA; /** Average score for missed detection on the whole segmentation */ AttributesValueType m_MeanRM; /** Average score for noise on the whole segmentation */ AttributesValueType m_MeanRN; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbHooverInstanceFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Metrics/include/otbHooverInstanceFilter.txx000066400000000000000000000445121301006202600300710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHooverInstanceFilter_txx #define otbHooverInstanceFilter_txx #include "otbHooverInstanceFilter.h" #include "otbMacro.h" namespace otb { /** Constructor */ template HooverInstanceFilter ::HooverInstanceFilter() : m_NumberOfRegionsGT(0), m_NumberOfRegionsMS(0), m_Threshold(0.8), m_UseExtendedAttributes(false) { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredOutputs(2); typename LabelMapType::Pointer secondOutput = LabelMapType::New(); this->AddOutput(secondOutput); m_HooverMatrix.SetSize(0, 0); m_CardRegGT.SetSize(0); m_CardRegMS.SetSize(0); m_LabelsGT.resize(0); m_MeanRC = static_cast(0); m_MeanRF = static_cast(0); m_MeanRA = static_cast(0); m_MeanRM = static_cast(0); m_MeanRN = static_cast(0); } /** Set the ground truth label map */ template void HooverInstanceFilter ::SetGroundTruthLabelMap(const LabelMapType *gt) { this->SetInput(0, gt); } /** Set the machine segmentation label map */ template void HooverInstanceFilter ::SetMachineSegmentationLabelMap(const LabelMapType *ms) { this->SetInput(1, ms); } /** Get the input ground truth label map */ template const TLabelMap* HooverInstanceFilter ::GetGroundTruthLabelMap() { return this->GetInput(0); } /** Get the input machine segmentation label map */ template TLabelMap* HooverInstanceFilter ::GetMachineSegmentationLabelMap() { return const_cast (this->GetInput(1)); } /** Get the output ground truth label map */ template TLabelMap* HooverInstanceFilter ::GetOutputGroundTruthLabelMap() { return this->GetOutput(0); } /** Get the output machine segmentation label map */ template TLabelMap* HooverInstanceFilter ::GetOutputMachineSegmentationLabelMap() { return this->GetOutput(1); } template void HooverInstanceFilter ::AllocateOutputs() { Superclass::AllocateOutputs(); if( this->GetInPlace() && this->CanRunInPlace() ) { LabelMapPointer secondInput = const_cast(this->GetMachineSegmentationLabelMap()); if( secondInput ) { ImageRegionType region = this->GetOutput(1)->GetLargestPossibleRegion(); this->GraftNthOutput( 1 , secondInput ); this->GetOutput(1)->SetRegions( region ); } } else { // copying the second input : machine segmentation const TLabelMap * inputMS = this->GetInput(1); TLabelMap * outputMS = this->GetOutput(1); assert( inputMS != NULL ); assert( outputMS != NULL ); outputMS->SetBackgroundValue( inputMS->GetBackgroundValue() ); ConstIteratorType it = ConstIteratorType( inputMS ); while( !it.IsAtEnd() ) { const LabelObjectType * labeObject = it.GetLabelObject(); assert( labeObject != NULL ); assert( labeObject->GetLabel() == it.GetLabel() ); typename LabelObjectType::Pointer newLabelObject = LabelObjectType::New(); newLabelObject->CopyAllFrom( labeObject ); outputMS->AddLabelObject( newLabelObject ); ++it; } } } template void HooverInstanceFilter ::ReleaseInputs() { Superclass::ReleaseInputs(); if( this->GetInPlace() ) { // Release second input TLabelMap * ptr = const_cast( this->GetInput(1) ); if( ptr ) { ptr->ReleaseData(); } } } template void HooverInstanceFilter ::BeforeThreadedGenerateData() { // first : call superclass method Superclass::BeforeThreadedGenerateData(); m_NumberOfRegionsGT = this->GetGroundTruthLabelMap()->GetNumberOfLabelObjects(); m_NumberOfRegionsMS = this->GetMachineSegmentationLabelMap()->GetNumberOfLabelObjects(); if (m_NumberOfRegionsGT == 0 || m_NumberOfRegionsMS == 0) { itkExceptionMacro("Empty label map"); } //Check the matrix size if (m_NumberOfRegionsGT != m_HooverMatrix.Rows() || m_NumberOfRegionsMS != m_HooverMatrix.Cols()) { itkExceptionMacro("The given Hoover confusion matrix ("<GetMachineSegmentationLabelMap() ); typename LabelObjectType::Pointer blankRegion; while ( !iter.IsAtEnd() ) { LabelObjectType *regionMS = iter.GetLabelObject(); m_CardRegMS[i] = regionMS->Size(); if (m_CardRegMS[i] == 0) { otbWarningMacro("Region "<SetAttribute(GetNameFromAttribute(ATTRIBUTE_RC), 0.0); regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RF), 0.0); regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RA), 0.0); regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RN), 0.0); if (m_UseExtendedAttributes) { blankRegion = LabelObjectType::New(); blankRegion->SetLabel(regionMS->GetLabel()); std::vector< std::string > attKeys = regionMS->GetAvailableAttributes(); for (unsigned int k=0; kSetAttribute(attKeys[k].c_str(), regionMS->GetAttribute(attKeys[k].c_str())); } } regionMS->CopyAttributesFrom(blankRegion); } i++; ++iter; } m_LabelsGT = this->GetGroundTruthLabelMap()->GetLabels(); } template void HooverInstanceFilter ::ThreadedProcessLabelObject( LabelObjectType * labelObject ) { // Find the index corresponding to the current label object in GT unsigned long currentRegionGT = 0; LabelType currentLabelGT = labelObject->GetLabel(); for (unsigned long k=0; kSize(); if (m_CardRegGT[currentRegionGT] == 0) { otbWarningMacro("Region "<SetAttribute(GetNameFromAttribute(ATTRIBUTE_RC), 0.0); labelObject->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RF), 0.0); labelObject->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RA), 0.0); labelObject->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RM), 0.0); if (m_UseExtendedAttributes) { typename LabelObjectType::Pointer blankRegion; blankRegion = LabelObjectType::New(); blankRegion->SetLabel(labelObject->GetLabel()); std::vector< std::string > attKeys = labelObject->GetAvailableAttributes(); for (unsigned int k=0; kSetAttribute(attKeys[k].c_str(), labelObject->GetAttribute(attKeys[k].c_str())); } } labelObject->CopyAttributesFrom(blankRegion); } } template void HooverInstanceFilter ::AfterThreadedGenerateData() { LabelMapType* outGT = this->GetOutput(0); LabelMapType* outMS = this->GetOutput(1); // Iterators on label object container (to gain efficiency when accessing them) IteratorType iterGT = IteratorType( outGT ); IteratorType iterMS = IteratorType( outMS ); // Set of classified regions RegionSetType GTindices; RegionSetType MSindices; // flags to detect empty rows or columns bool IsRowEmpty; bool IsColEmpty; // temporary buffers to compute average scores double bufferRC = 0.0; double bufferRF = 0.0; double bufferRA = 0.0; double bufferRM = 0.0; double bufferRN = 0.0; double areaGT = 0.0; double areaMS = 0.0; // first pass : loop on GT regions first for(unsigned int row=0; row(m_CardRegGT[row]) * m_Threshold; // card Ri x t IsRowEmpty = true; iterMS.GoToBegin(); for(unsigned int col=0; col(m_HooverMatrix(row, col)); if(coefT < 0.5) { // the regions Ri and ^Rj have an empty intersection : we can jump to the next matrix cell continue; } else { IsRowEmpty = false; } double tMS = static_cast(m_CardRegMS[col]) * m_Threshold; // card Rj x t otbDebugMacro(<< "* coef[" << row << "," << col << "]=" << coefT << " #tGT=" << tGT << " #tMS=" << tMS); // Looking for Correct Detection and Over Segmentation (both can happen for the same GT region) if(coefT>=tMS) { if(coefT>=tGT) { otbDebugMacro(<< "1 coef[" << row << "," << col << "]=" << coefT << " #tGT=" << tGT << " #tMS=" << tMS << " -> CD"); LabelObjectType *regionGT = iterGT.GetLabelObject(); LabelObjectType *regionMS = iterMS.GetLabelObject(); double scoreRC = m_Threshold * (std::min(coefT / tGT, coefT / tMS)); bufferRC += scoreRC * static_cast(m_CardRegGT[row]); regionGT->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RC), static_cast(scoreRC)); regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RC), static_cast(scoreRC)); if (m_UseExtendedAttributes) { regionGT->SetAttribute(GetNameFromAttribute(ATTRIBUTE_CD), static_cast(regionMS->GetLabel())); regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_CD), static_cast(regionGT->GetLabel())); } GTindices.insert(row); MSindices.insert(col); } else { otbDebugMacro(<< "2 coef[" << row << "," << col << "]=" << coefT << " #tGT=" << tGT << " #tMS=" << tMS << " -> OSmaybe"); } objectsOfMS.push_back(iterMS.GetLabelObject()); // candidate region for over-segmentation regionsOfMS.insert(col); sumOS += coefT; sumScoreRF += coefT*(coefT-1.0); } } // end of column loop otbDebugMacro(<< "end of line " << row << "; sumOS=" << sumOS << " " << regionsOfMS.size() << " of MS region"); if(sumOS>=tGT && sumOS>0) { // CD if(regionsOfMS.size()==1) { otbDebugMacro(<< "CD only"); } // OS else if(regionsOfMS.size()>1) { otbDebugMacro(<< row << " OS by "); LabelObjectType *regionGT = iterGT.GetLabelObject(); double cardRegGT = static_cast(m_CardRegGT[row]); double scoreRF = 1.0 - sumScoreRF / (cardRegGT * (cardRegGT - 1.0)); bufferRF += scoreRF * cardRegGT; regionGT->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RF), static_cast(scoreRF)); unsigned int indexOS=1; for(typename ObjectVectorType::iterator it=objectsOfMS.begin(); it!=objectsOfMS.end(); ++it) { LabelObjectType *regionMS = *it; std::ostringstream attribute; attribute << ATTRIBUTE_OS << "_" << indexOS; regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RF), static_cast(scoreRF)); if (m_UseExtendedAttributes) { regionGT->SetAttribute(attribute.str().c_str(), static_cast(regionMS->GetLabel())); regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_OS), static_cast(regionGT->GetLabel())); } indexOS++; } GTindices.insert(row); for(RegionSetType::iterator it=regionsOfMS.begin(); it!=regionsOfMS.end(); ++it) { MSindices.insert(*it); otbDebugMacro(<< *it << " "); } } else { otbDebugMacro(<< "No MS region present in potential OS instance"); } } // check for empty rows : they should be ignored and have no Hoover attribute if (IsRowEmpty) { GTindices.insert(row); } else { areaGT += static_cast(m_CardRegGT[row]); } } // end of line loop // second pass : loop on MS regions first iterMS.GoToBegin(); for(unsigned int col=0; col(m_CardRegMS[col]) * m_Threshold; IsColEmpty = true; iterGT.GoToBegin(); for(unsigned int row=0; row(m_HooverMatrix(row, col)); if(coefT < 0.5) { // the regions Ri and ^Rj have an empty intersection : we can jump to the next matrix cell continue; } else { IsColEmpty = false; } double tGT = static_cast(m_CardRegGT[row]) * m_Threshold; // Looking for Under-Segmented regions if(coefT>=tGT) { otbDebugMacro(<< "3 coef[" << row << "," << col << "]=" << coefT << " #tGT=" << tGT << " #tMS=" << tMS << " -> USmaybe"); regionsOfGT.insert(row); objectsOfGT.push_back(iterGT.GetLabelObject()); sumUS += coefT; sumScoreUS += coefT * (coefT - 1.0); sumCardUS += static_cast(m_CardRegGT[row]); } } // end of line loop // US if(sumUS>=tMS) { if(regionsOfGT.size()==1) { otbDebugMacro(<< "CD already registered"); } else if(regionsOfGT.size()>1) // Under Segmentation { LabelObjectType *regionMS = iterMS.GetLabelObject(); double scoreRA = 1.0 - sumScoreUS / (sumCardUS * (sumCardUS - 1.0)); bufferRA += scoreRA * sumCardUS; regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RA), static_cast(scoreRA)); unsigned int indexUS=1; for(typename ObjectVectorType::iterator it=objectsOfGT.begin(); it!=objectsOfGT.end(); ++it) { LabelObjectType *regionGT = *it; std::ostringstream attribute; attribute << ATTRIBUTE_US << "_" << indexUS; regionGT->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RA), static_cast(scoreRA)); if (m_UseExtendedAttributes) { regionMS->SetAttribute(attribute.str(), static_cast(regionGT->GetLabel())); regionGT->SetAttribute(GetNameFromAttribute(ATTRIBUTE_US), static_cast(regionMS->GetLabel())); } indexUS++; } MSindices.insert(col); for(RegionSetType::iterator it=regionsOfGT.begin(); it!=regionsOfGT.end(); ++it) { GTindices.insert(*it); otbDebugMacro(<< *it << " "); } otbDebugMacro(<< "US " << col); } else { otbDebugMacro(<< "No GT region present in potential US instance."); } } // check for empty columns (MS region that doesn't intersect any GT region) if (IsColEmpty) { MSindices.insert(col); } else { areaMS += static_cast(m_CardRegMS[col]); } } // end of column loop // check for Missed regions (unregistered regions in GT) iterGT.GoToBegin(); for(unsigned int i=0; i(m_CardRegGT[i]); regionGT->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RM), 1.0); if (m_UseExtendedAttributes) { regionGT->SetAttribute(GetNameFromAttribute(ATTRIBUTE_M), static_cast(regionGT->GetLabel())); } } } // check for Noise regions (unregistered regions in MS) iterMS.GoToBegin(); for(unsigned int i=0; i(m_CardRegMS[i]); regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_RN), 1.0); if (m_UseExtendedAttributes) { regionMS->SetAttribute(GetNameFromAttribute(ATTRIBUTE_N), static_cast(regionMS->GetLabel())); } } } // Compute average scores m_MeanRC = static_cast(bufferRC / areaGT); m_MeanRF = static_cast(bufferRF / areaGT); m_MeanRA = static_cast(bufferRA / areaGT); m_MeanRM = static_cast(bufferRM / areaGT); m_MeanRN = static_cast(bufferRN / areaMS); } } #endif OTB-release-5.8/Modules/Segmentation/Metrics/include/otbHooverMatrixFilter.h000066400000000000000000000071531301006202600271750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHooverMatrixFilter_h #define otbHooverMatrixFilter_h #include "itkLabelMapFilter.h" #include "itkVariableSizeMatrix.h" namespace otb { /** \class HooverMatrixFilter * * \brief This class computes the confusion matrix from two LabelMapObject * * The confusion matrix stores the number of pixel inside the intersection between * couples of region. These couples are made from a ground truth segmentation and * a machine segmentation. The line number gives the index of the ground truth region. The * column number gives the index of the machine segmentation region. * * \ingroup OTBMetrics */ template< class TLabelMap > class ITK_EXPORT HooverMatrixFilter : public itk::LabelMapFilter< TLabelMap, TLabelMap > { public: /** Standard class typedefs. */ typedef HooverMatrixFilter Self; typedef itk::LabelMapFilter< TLabelMap, TLabelMap > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard New method. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(HooverMatrixFilter, LabelMapFilter); /** Some convenient typedefs. */ typedef TLabelMap LabelMapType; typedef typename LabelMapType::LabelObjectType LabelObjectType; typedef typename LabelMapType::LabelVectorType LabelVectorType; //typedef typename LabelObjectType::LineContainerType LineContainerType; typedef typename LabelObjectType::IndexType IndexType; typedef typename LabelObjectType::LabelType LabelType; typedef unsigned long CoefficientType; typedef itk::VariableSizeMatrix MatrixType; /** Set the ground truth label map */ void SetGroundTruthLabelMap(const LabelMapType *gt); /** Set the machine segmentation label map */ void SetMachineSegmentationLabelMap(const LabelMapType *ms); /** Get the ground truth label map */ const LabelMapType* GetGroundTruthLabelMap(); /** Get the machine segmentation label map */ const LabelMapType* GetMachineSegmentationLabelMap(); /** Get the output Hoover confusion matrix */ MatrixType & GetHooverConfusionMatrix() { return m_Matrix; } protected: /** Constructor */ HooverMatrixFilter(); ~HooverMatrixFilter() ITK_OVERRIDE {}; /** Action : Resize the matrix */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** Action : fill the line of the confusion matrix corresponding to * the given label object */ void ThreadedProcessLabelObject( LabelObjectType * labelObject ) ITK_OVERRIDE; private: /** Number of label objects found in the ground truth (GT) label maps */ unsigned long m_NumberOfRegionsGT; /** Number of label objects found in the machine segmentation (MS) label maps */ unsigned long m_NumberOfRegionsMS; /** List of labels in GT label map */ LabelVectorType m_LabelsGT; /** Hoover confusion matrix */ MatrixType m_Matrix; }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbHooverMatrixFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Metrics/include/otbHooverMatrixFilter.txx000066400000000000000000000070631301006202600275710ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbHooverMatrixFilter_txx #define otbHooverMatrixFilter_txx #include "otbHooverMatrixFilter.h" namespace otb { /** Constructor */ template HooverMatrixFilter ::HooverMatrixFilter() : m_NumberOfRegionsGT(0), m_NumberOfRegionsMS(0) { this->SetNumberOfRequiredInputs(2); m_Matrix.SetSize(0, 0); } /** Set the ground truth label map */ template void HooverMatrixFilter ::SetGroundTruthLabelMap(const LabelMapType *gt) { this->SetInput(0, gt); } /** Set the machine segmentation label map */ template void HooverMatrixFilter ::SetMachineSegmentationLabelMap(const LabelMapType *ms) { this->SetInput(1, ms); } /** Get the ground truth label map */ template const TLabelMap* HooverMatrixFilter ::GetGroundTruthLabelMap() { return this->GetInput(0); } /** Get the machine segmentation label map */ template const TLabelMap* HooverMatrixFilter ::GetMachineSegmentationLabelMap() { return this->GetInput(1); } template void HooverMatrixFilter ::BeforeThreadedGenerateData() { // first : call superclass method Superclass::BeforeThreadedGenerateData(); // Set the matrix size m_NumberOfRegionsGT = this->GetGroundTruthLabelMap()->GetNumberOfLabelObjects(); m_NumberOfRegionsMS = this->GetMachineSegmentationLabelMap()->GetNumberOfLabelObjects(); m_LabelsGT = this->GetGroundTruthLabelMap()->GetLabels(); m_Matrix.SetSize(m_NumberOfRegionsGT , m_NumberOfRegionsMS); m_Matrix.Fill(0); } template void HooverMatrixFilter ::ThreadedProcessLabelObject( LabelObjectType * labelObject ) { unsigned long currentRegionMS = 0; unsigned long currentRegionGT = 0; // find the index of the current GT region LabelType currentLabelGT = labelObject->GetLabel(); for (unsigned long k=0; kGetMachineSegmentationLabelMap()->GetNthLabelObject(j%m_NumberOfRegionsMS); if (regionMS->HasIndex(idx)) { currentRegionMS = j%m_NumberOfRegionsMS; m_Matrix(currentRegionGT, currentRegionMS)++; break; } } idx[0]++; } ++lit; } } } #endif OTB-release-5.8/Modules/Segmentation/Metrics/otb-module.cmake000066400000000000000000000004461301006202600241460ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes that allow measuring the differences between two segmentations.") otb_module(OTBMetrics DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBLabelMap OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Segmentation/Metrics/test/000077500000000000000000000000001301006202600220505ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Metrics/test/CMakeLists.txt000066400000000000000000000024561301006202600246170ustar00rootroot00000000000000otb_module_test() set(OTBMetricsTests otbMetricsTestDriver.cxx otbHooverMatrixFilterNew.cxx otbHooverInstanceFilterNew.cxx otbHooverInstanceFilterToAttributeImage.cxx otbHooverMatrixFilter.cxx ) add_executable(otbMetricsTestDriver ${OTBMetricsTests}) target_link_libraries(otbMetricsTestDriver ${OTBMetrics-Test_LIBRARIES}) otb_module_target_label(otbMetricsTestDriver) # Tests Declaration otb_add_test(NAME obTuHooverMatrixFilterNew COMMAND otbMetricsTestDriver otbHooverMatrixFilterNew) otb_add_test(NAME obTuHooverInstanceFilterNew COMMAND otbMetricsTestDriver otbHooverInstanceFilterNew) otb_add_test(NAME obTvHooverInstanceFilterToAttributeImage COMMAND otbMetricsTestDriver --compare-image ${EPSILON_9} ${BASELINE}/obTvHooverInstanceFilterToAttributeImage.tif ${TEMP}/obTvHooverInstanceFilterToAttributeImage.tif otbHooverInstanceFilterToAttributeImage ${INPUTDATA}/maur_GT.tif ${INPUTDATA}/maur_labelled.tif ${TEMP}/obTvHooverInstanceFilterToAttributeImage.tif ) otb_add_test(NAME obTvHooverMatrixFilter COMMAND otbMetricsTestDriver --compare-ascii ${NOTOL} ${BASELINE_FILES}/obTvHooverMatrixFilter.txt ${TEMP}/obTvHooverMatrixFilter.txt otbHooverMatrixFilter ${INPUTDATA}/Seg1InputForRCC8Graph.tif ${INPUTDATA}/Seg2InputForRCC8Graph.tif ${TEMP}/obTvHooverMatrixFilter.txt ) OTB-release-5.8/Modules/Segmentation/Metrics/test/otbHooverInstanceFilterNew.cxx000066400000000000000000000021671301006202600300560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbHooverInstanceFilter.h" #include "itkLabelMap.h" #include "otbAttributesMapLabelObject.h" int otbHooverInstanceFilterNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::HooverInstanceFilter HooverInstanceFilterType; // instantiation HooverInstanceFilterType::Pointer object = HooverInstanceFilterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Metrics/test/otbHooverInstanceFilterToAttributeImage.cxx000066400000000000000000000102761301006202600325360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbHooverMatrixFilter.h" #include "otbHooverInstanceFilter.h" #include "otbLabelMapToAttributeImageFilter.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkLabelImageToLabelMapFilter.h" int otbHooverInstanceFilterToAttributeImage(int argc, char* argv[]) { typedef otb::AttributesMapLabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::HooverMatrixFilter HooverMatrixFilterType; typedef otb::Image ImageType; typedef otb::VectorImage VectorImageType; typedef itk::LabelImageToLabelMapFilter ImageToLabelMapFilterType; typedef otb::ImageFileReader ImageReaderType; typedef HooverMatrixFilterType::MatrixType MatrixType; typedef otb::HooverInstanceFilter InstanceFilterType; typedef otb::LabelMapToAttributeImageFilter AttributeImageFilterType; typedef otb::ImageFileWriter WriterType; if(argc != 4) { std::cerr << "Usage: " << argv[0]; std::cerr << " segmentationGT segmentationMS outputAttributeImage" << std::endl; return EXIT_FAILURE; } ImageReaderType::Pointer gt_reader = ImageReaderType::New(); gt_reader->SetFileName(argv[1]); ImageReaderType::Pointer ms_reader = ImageReaderType::New(); ms_reader->SetFileName(argv[2]); ImageToLabelMapFilterType::Pointer gt_filter = ImageToLabelMapFilterType::New(); gt_filter->SetInput(gt_reader->GetOutput()); gt_filter->SetBackgroundValue(0); ImageToLabelMapFilterType::Pointer ms_filter = ImageToLabelMapFilterType::New(); ms_filter->SetInput(ms_reader->GetOutput()); ms_filter->SetBackgroundValue(0); HooverMatrixFilterType::Pointer hooverFilter = HooverMatrixFilterType::New(); hooverFilter->SetGroundTruthLabelMap(gt_filter->GetOutput()); hooverFilter->SetMachineSegmentationLabelMap(ms_filter->GetOutput()); hooverFilter->Update(); MatrixType &mat = hooverFilter->GetHooverConfusionMatrix(); InstanceFilterType::Pointer instances = InstanceFilterType::New(); instances->SetGroundTruthLabelMap(gt_filter->GetOutput()); instances->SetMachineSegmentationLabelMap(ms_filter->GetOutput()); instances->SetThreshold(0.75); instances->SetHooverMatrix(mat); instances->SetUseExtendedAttributes(false); AttributeImageFilterType::Pointer attributeImageGT = AttributeImageFilterType::New(); attributeImageGT->SetInput(instances->GetOutputGroundTruthLabelMap()); attributeImageGT->SetAttributeForNthChannel(0, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RC)); attributeImageGT->SetAttributeForNthChannel(1, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RF)); attributeImageGT->SetAttributeForNthChannel(2, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RA)); attributeImageGT->SetAttributeForNthChannel(3, InstanceFilterType::GetNameFromAttribute(InstanceFilterType::ATTRIBUTE_RM)); WriterType::Pointer writer = WriterType::New(); writer->SetInput(attributeImageGT->GetOutput()); writer->SetFileName(argv[3]); writer->Update(); std::cout << "Mean RC ="<< instances->GetMeanRC() << std::endl; std::cout << "Mean RF ="<< instances->GetMeanRF() << std::endl; std::cout << "Mean RA ="<< instances->GetMeanRA() << std::endl; std::cout << "Mean RM ="<< instances->GetMeanRM() << std::endl; std::cout << "Mean RN ="<< instances->GetMeanRN() << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Metrics/test/otbHooverMatrixFilter.cxx000066400000000000000000000051561301006202600271050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbHooverMatrixFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "itkLabelImageToLabelMapFilter.h" int otbHooverMatrixFilter(int argc, char* argv[]) { typedef itk::LabelObject LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::HooverMatrixFilter HooverMatrixFilterType; typedef otb::Image ImageType; typedef itk::LabelImageToLabelMapFilter ImageToLabelMapFilterType; typedef otb::ImageFileReader ImageReaderType; typedef HooverMatrixFilterType::MatrixType MatrixType; if(argc != 4) { std::cerr << "Usage: " << argv[0]; std::cerr << " segmentationGT segmentationMS HooverMatrix.txt" << std::endl; return EXIT_FAILURE; } ImageReaderType::Pointer gt_reader = ImageReaderType::New(); gt_reader->SetFileName(argv[1]); ImageReaderType::Pointer ms_reader = ImageReaderType::New(); ms_reader->SetFileName(argv[2]); ImageToLabelMapFilterType::Pointer gt_filter = ImageToLabelMapFilterType::New(); gt_filter->SetInput(gt_reader->GetOutput()); gt_filter->SetBackgroundValue(0); ImageToLabelMapFilterType::Pointer ms_filter = ImageToLabelMapFilterType::New(); ms_filter->SetInput(ms_reader->GetOutput()); ms_filter->SetBackgroundValue(0); HooverMatrixFilterType::Pointer hooverFilter = HooverMatrixFilterType::New(); hooverFilter->SetGroundTruthLabelMap(gt_filter->GetOutput()); hooverFilter->SetMachineSegmentationLabelMap(ms_filter->GetOutput()); hooverFilter->Update(); std::ofstream outputFile; outputFile.open(argv[3]); MatrixType &mat = hooverFilter->GetHooverConfusionMatrix(); unsigned int n = mat.Rows(), p = mat.Cols(); for (unsigned int i=0; i LabelObjectType; typedef itk::LabelMap LabelMapType; typedef otb::HooverMatrixFilter HooverMatrixFilterType; // instantiation HooverMatrixFilterType::Pointer object = HooverMatrixFilterType::New(); std::cout << object << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Metrics/test/otbMetricsTestDriver.cxx000066400000000000000000000003541301006202600267250ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbHooverMatrixFilterNew); REGISTER_TEST(otbHooverInstanceFilterNew); REGISTER_TEST(otbHooverInstanceFilterToAttributeImage); REGISTER_TEST(otbHooverMatrixFilter); } OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/000077500000000000000000000000001301006202600237665ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/CMakeLists.txt000066400000000000000000000000641301006202600265260ustar00rootroot00000000000000project(OTBMorphologicalProfiles) otb_module_impl() OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/000077500000000000000000000000001301006202600254115ustar00rootroot00000000000000otbClosingOpeningMorphologicalFilter.h000066400000000000000000000066631301006202600350270ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbClosingOpeningMorphologicalFilter_h #define otbClosingOpeningMorphologicalFilter_h #include "itkImageToImageFilter.h" namespace otb { /** * \class ClosingOpeningMorphologicalFilter * \brief This filter implements an opening grayscale morphological operation * followed by a closing grayscale morphological operation. It tends to simplify * image by obliterating details with a lower extent than the structuring element. * * This filter implements an opening grayscale morphological operation * followed by a closing grayscale morphological operation. It tends to simplify * image by obliterating details with a lower extent than the structuring element. * * This filter can be used in the morphological pyramid analyse filter. Due to the order * of composition of the two basic morphological operation, the filtered details are dark * on a brighter background. * * \sa ClosingOpeningMorphologicalFilter, * MorphologicalPyramidAnalysisFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT ClosingOpeningMorphologicalFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef ClosingOpeningMorphologicalFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(ClosingOpeningMorphologicalFilter, ImageToImageFilter); /** Template parameter typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TKernel KernelType; /** Useful typedefs */ typedef typename InputImageType::Pointer InputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename TInputImage::PixelType PixelType; /** Kernel accessors */ itkSetMacro(Kernel, KernelType); itkGetConstReferenceMacro(Kernel, KernelType); protected: /** Constructor */ ClosingOpeningMorphologicalFilter(); /** Destructor */ ~ClosingOpeningMorphologicalFilter() ITK_OVERRIDE {} /* void GenerateInputRequestedRegion(); */ /* void EnlargeOutputRequestedRegion(itk::DataObject *itkNotUsed(output)); */ /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ClosingOpeningMorphologicalFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Morphological operation kernel */ KernelType m_Kernel; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbClosingOpeningMorphologicalFilter.txx" #endif #endif otbClosingOpeningMorphologicalFilter.txx000066400000000000000000000053571301006202600354220ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbClosingOpeningMorphologicalFilter_txx #define otbClosingOpeningMorphologicalFilter_txx #include "otbClosingOpeningMorphologicalFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkGrayscaleMorphologicalOpeningImageFilter.h" #include "itkGrayscaleMorphologicalClosingImageFilter.h" #include "itkProgressAccumulator.h" namespace otb { /** * Constructor */ template ClosingOpeningMorphologicalFilter ::ClosingOpeningMorphologicalFilter() { m_Kernel.SetRadius(1); m_Kernel.CreateStructuringElement(); } /** * Main computation method */ template void ClosingOpeningMorphologicalFilter ::GenerateData() { // Filters Typedefs (this class is actually a composite filter) typedef itk::GrayscaleMorphologicalOpeningImageFilter OpenFilterType; typedef itk::GrayscaleMorphologicalClosingImageFilter CloseFilterType; // Filters initialization typename OpenFilterType::Pointer opening = OpenFilterType::New(); typename CloseFilterType::Pointer closing = CloseFilterType::New(); // Set the kernel opening->SetKernel(this->GetKernel()); closing->SetKernel(this->GetKernel()); // Progression report management itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); progress->RegisterInternalFilter(closing, .5f); progress->RegisterInternalFilter(opening, .5f); // Internal Pipeline connexion opening->SetInput(this->GetInput()); closing->SetInput(opening->GetOutput()); // Output connexion closing->GraftOutput(this->GetOutput()); closing->Update(); this->GraftOutput(closing->GetOutput()); } /** * PrintSelf method */ template void ClosingOpeningMorphologicalFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Kernel: " << m_Kernel << std::endl; } } // End namespace otb #endif otbConvexOrConcaveClassificationFilter.h000066400000000000000000000175121301006202600353020ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbConvexOrConcaveClassificationFilter_h #define otbConvexOrConcaveClassificationFilter_h #include "itkBinaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class ConvexOrConcaveDecisionRule * \brief This functor labels the given pixel between three classes Convex, Concave and Flat. * * \par * This algorithm is based on the following publication: * \par * Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: * A new approach for the morphological segmentation of high resolution * satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, * NO. 2, February 2001, p. 309-320. * \par * * This functor implements the following decision rule to classify a pixel between the three classes * Convex, Concave and Flat. Let \f$f\f$ denote the input image and \f$\psi_{N}(f)\f$ the geodesic leveling * of \f$f\f$ with a structuring element of size \f$N\f$. One can derive the following decision rule to * classify \f$f\f$ into Convex (label \f$\stackrel{\smile}{k}\f$), Concave (label \f$\stackrel{\frown}{k}\f$) * and Flat (label \f$\bar{k}\f$): * * \f[ * \phi_{N}^{\sigma}=\left\{\begin{array}{lcl} * \stackrel{\smile}{k} &:& f-\psi_{N}(f)>\sigma\\ * \stackrel{\frown}{k} &:& \psi_{N}(f)-f>\sigma\\ * \bar{k}&:&\mid f - \psi_{N}(f) \mid \leq \sigma * \end{array}\right. * \f] * * * \ingroup OTBMorphologicalProfiles */ template class ConvexOrConcaveDecisionRule { public: /** * Constructor */ ConvexOrConcaveDecisionRule() { m_ConvexLabel = 1; m_ConcaveLabel = 2; m_FlatLabel = 0; m_Sigma = 0.0; } /** * Destructor */ virtual ~ConvexOrConcaveDecisionRule() {} /** * Label the pixel to convex, concave or flat * \return The label of the pixel * \param x The image value * \param xlevel The leveling value */ inline TOutput operator ()(const TInput& x, const TInput& xlevel) { TOutput resp = m_FlatLabel; if (static_cast(x - xlevel) > m_Sigma) { resp = m_ConvexLabel; } else if (static_cast(xlevel - x) > m_Sigma) { resp = m_ConcaveLabel; } return resp; } /** * Set the convex label * \param label the convex label */ void SetConvexLabel(const TOutput& label) { m_ConvexLabel = label; } /** * Get the convex label * \return the convex label */ TOutput GetConvexLabel(void) { return m_ConvexLabel; } /** * Set the concave label * \param label the concave label */ void SetConcaveLabel(const TOutput& label) { m_ConcaveLabel = label; } /** * Get the concave label * \return the concave label */ TOutput GetConcaveLabel(void) { return m_ConcaveLabel; } /** * Set the flat label * \param label the flat label */ void SetFlatLabel(const TOutput& label) { m_FlatLabel = label; } /** * Get the flat label * \return the flat label */ TOutput GetFlatLabel(void) { return m_FlatLabel; } /** * Set the tolerance value * \param sigma the tolerance value */ void SetSigma(const double& sigma) { m_Sigma = sigma; } /** * Get the tolerance value * \return the tolerance value */ double GetSigma(void) { return m_Sigma; } private: /** Label of the convex class */ TOutput m_ConvexLabel; /** Label of the concave class */ TOutput m_ConcaveLabel; /** Label of the flat class */ TOutput m_FlatLabel; /** Sigma (tolerance) parameter */ double m_Sigma; }; } //end namespace Functor /** \class ConvexOrConcaveClassificationFilter * \brief This filter apply the Convex, Concave and flat classification functor to the whole image. * * Please refer to the documentation of the Functor::ConvexOrConcaveDecisionRule for more details. * * \sa GeodesicMorphologyDecompositionImageFilter * \sa GeodesicMorphologyLevelingFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT ConvexOrConcaveClassificationFilter : public itk::BinaryFunctorImageFilter > { public: /** Standard typedefs */ typedef ConvexOrConcaveClassificationFilter Self; typedef itk::BinaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ConvexOrConcaveClassificationFilter, BinaryFunctorImageFilter); /** Template class typedef */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType LabelType; typedef Functor::ConvexOrConcaveDecisionRule DecisionFunctorType; /** * Set the input image * \param image the input image * */ using Superclass::SetInput; void SetInput(const TInputImage * image) ITK_OVERRIDE { this->SetInput1(image); } /** * Set the input leveling image * \param leveling the input leveling image * */ void SetInputLeveling(const TInputImage * leveling) { this->SetInput2(leveling); } /** Set/Get the convex label */ itkSetMacro(ConvexLabel, LabelType); itkGetMacro(ConvexLabel, LabelType); /** Set/Get the concave label */ itkSetMacro(ConcaveLabel, LabelType); itkGetMacro(ConcaveLabel, LabelType); /** Set/Get the flat label */ itkSetMacro(FlatLabel, LabelType); itkGetMacro(FlatLabel, LabelType); /** Set/Get the tolerance value */ itkSetMacro(Sigma, double); itkGetMacro(Sigma, double); /** Set the functor parameters before calling the ThreadedGenerateData() */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { this->GetFunctor().SetConvexLabel(m_ConvexLabel); this->GetFunctor().SetConcaveLabel(m_ConcaveLabel); this->GetFunctor().SetFlatLabel(m_FlatLabel); this->GetFunctor().SetSigma(m_Sigma); } protected: /** Constructor */ ConvexOrConcaveClassificationFilter() { m_ConvexLabel = 1; m_ConcaveLabel = 2; m_FlatLabel = 0; m_Sigma = 0.0; }; /** Destructor */ ~ConvexOrConcaveClassificationFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << indent << "ConvexLabel: " << m_ConvexLabel << std::endl; os << indent << "ConcaveLabel: " << m_ConcaveLabel << std::endl; os << indent << "FlatLabel: " << m_FlatLabel << std::endl; os << indent << "Sigma: " << m_Sigma << std::endl; } private: ConvexOrConcaveClassificationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Label of the convex class */ LabelType m_ConvexLabel; /** Label of the concave class */ LabelType m_ConcaveLabel; /** Label of the flat class */ LabelType m_FlatLabel; /** Tolerance value */ double m_Sigma; }; } // End namespace otb #endif otbGeodesicMorphologyDecompositionImageFilter.h000066400000000000000000000161101301006202600366570ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeodesicMorphologyDecompositionImageFilter_h #define otbGeodesicMorphologyDecompositionImageFilter_h #include "otbGeodesicMorphologyLevelingFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkSubtractImageFilter.h" #include "itkOpeningByReconstructionImageFilter.h" #include "itkClosingByReconstructionImageFilter.h" #include "otbMacro.h" namespace otb { /** \class GeodesicMorphologyDecompositionImageFilter * \brief This class implements a geodesic morphology based image analysis algorithm. * \par * This algorithm is based on the following publication: * \par * Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: * A new approach for the morphological segmentation of high resolution * satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, * NO. 2, February 2001, p. 309-320. * \par * * Given \f$\gamma^{\star}_{N}\f$ the geodesic opening by reconstruction morphological operator * and \f$\varphi^{\star}_{N}\f$ the geodesic closing by reconstruction morphological operator * for a structuring element of size \f$N\f$, one can define the two following membership functions for * the input image \f$f\f$: * * \f[ * \stackrel{\smile}{\mu} = f-\gamma^{\star}_{N}(f) * \f] * \f[ * \stackrel{\frown}{\mu} = \phi^{\star}_{N}(f)-f * \f] * * Where \f$\stackrel{\smile}{\mu}\f$ denotes the likelihood of the current pixel to belong to a convex structure * of the input image \f$f\f$ (i.e. brighter than the surrounding background) with respect to the size of the * structuring element \f$N\f$, and \f$\stackrel{\frown}{\mu}\f$ denotes the likelihood of the current pixel to * belong to a concave structure. * * This two membership functions can be used to define a simplification operator \f$\psi_{N}\f$ called leveling, * which removes from the input image \f$f\f$ the structures located by \f$\stackrel{\smile}{\mu}\f$ and * \f$\stackrel{\frown}{\mu}\f$: * * \f[ * \psi_{N}(f)= \left\{\begin{array}{lcl} * \gamma^{\star}_{N}(f)&:& \stackrel{\smile}{\mu}>\stackrel{\frown}{\mu}\\ * \varphi^{\star}_{N}(f)&:& \stackrel{\frown}{\mu}>\stackrel{\smile}{\mu}\\ * f&:&\stackrel{\frown}{\mu}=\stackrel{\smile}{\mu} * \end{array}\right. * \f] * * This filter performs this image decomposition at a given structuring element size. The GetOutput() method returns * \f$\psi_{N}(f)\f$, the GetConvexMap() method returns \f$\stackrel{\smile}{\mu}\f$ and the GetConcaveMap() method * returns \f$\stackrel{\frown}{\mu}\f$. * * The PreserveIntensities and the FullyConnected flags reflects the option of the geodesic morphology filters from ITK. * * \sa GeodesicMorphologyLevelingFilter * \sa itk::OpeningByReconstructionImageFilter * \sa itk::ClosingByReconstructionImageFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT GeodesicMorphologyDecompositionImageFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef GeodesicMorphologyDecompositionImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(GeodesicMorphologyDecompositionImageFilter, ImageToImageFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TStructuringElement StructuringElementType; typedef typename StructuringElementType::RadiusType RadiusType; typedef itk::OpeningByReconstructionImageFilter OpeningFilterType; typedef itk::ClosingByReconstructionImageFilter ClosingFilterType; typedef itk::SubtractImageFilter ConvexFilterType; typedef itk::SubtractImageFilter ConcaveFilterType; typedef otb::GeodesicMorphologyLevelingFilter LevelingFilterType; /** Pointers typedefs*/ typedef typename OpeningFilterType::Pointer OpeningFilterPointerType; typedef typename ClosingFilterType::Pointer ClosingFilterPointerType; typedef typename LevelingFilterType::Pointer LevelingFilterPointerType; typedef typename ConvexFilterType::Pointer ConvexFilterPointerType; typedef typename ConcaveFilterType::Pointer ConcaveFilterPointerType; /** Radius of the structuring element */ itkSetMacro(Radius, RadiusType); itkGetConstReferenceMacro(Radius, RadiusType); /** * Get the convex likehood map. * \return The convex likehood map. */ OutputImageType * GetConvexMap(void); /** * Get the concave likehood map. * \return The concave likehood map. */ OutputImageType * GetConcaveMap(void); /** FullyConnected flag */ itkSetMacro(FullyConnected, bool); itkGetMacro(FullyConnected, bool); /** Preserve intensities flag */ itkSetMacro(PreserveIntensities, bool); itkGetMacro(PreserveIntensities, bool); protected: /** GenerateData */ void GenerateData(void) ITK_OVERRIDE; /** Constructor */ GeodesicMorphologyDecompositionImageFilter(); /** Destructor */ ~GeodesicMorphologyDecompositionImageFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: GeodesicMorphologyDecompositionImageFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Radius of the structuring element */ RadiusType m_Radius; /** Opening filter */ OpeningFilterPointerType m_OpeningFilter; /** Closing filter */ ClosingFilterPointerType m_ClosingFilter; /** First subtract filter (output is the convex map)*/ ConvexFilterPointerType m_ConvexFilter; /** Second subtract filter (output is the concave map) */ ConcaveFilterPointerType m_ConcaveFilter; /** Leveling function */ LevelingFilterPointerType m_LevelingFilter; /** Preserve intensities in morphological operators */ bool m_PreserveIntensities; /** Use fully connected morphological operators */ bool m_FullyConnected; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGeodesicMorphologyDecompositionImageFilter.txx" #endif #endif otbGeodesicMorphologyDecompositionImageFilter.txx000066400000000000000000000101211301006202600372470ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeodesicMorphologyDecompositionImageFilter_txx #define otbGeodesicMorphologyDecompositionImageFilter_txx #include "otbGeodesicMorphologyDecompositionImageFilter.h" namespace otb { /** * Constructor */ template GeodesicMorphologyDecompositionImageFilter ::GeodesicMorphologyDecompositionImageFilter() { this->SetNumberOfRequiredOutputs(3); this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, OutputImageType::New()); this->SetNthOutput(2, OutputImageType::New()); m_Radius.Fill(1); m_OpeningFilter = OpeningFilterType::New(); m_ClosingFilter = ClosingFilterType::New(); m_LevelingFilter = LevelingFilterType::New(); m_ConvexFilter = ConvexFilterType::New(); m_ConcaveFilter = ConcaveFilterType::New(); m_FullyConnected = true; m_PreserveIntensities = true; } /** * Main computation method */ template void GeodesicMorphologyDecompositionImageFilter ::GenerateData() { StructuringElementType se; se.SetRadius(m_Radius); se.CreateStructuringElement(); m_OpeningFilter->SetInput(this->GetInput()); m_OpeningFilter->SetKernel(se); m_OpeningFilter->SetPreserveIntensities(m_PreserveIntensities); m_OpeningFilter->SetFullyConnected(m_FullyConnected); m_ClosingFilter->SetInput(this->GetInput()); m_ClosingFilter->SetKernel(se); m_ClosingFilter->SetPreserveIntensities(m_PreserveIntensities); m_ClosingFilter->SetFullyConnected(m_FullyConnected); m_ConvexFilter->SetInput1(this->GetInput()); m_ConvexFilter->SetInput2(m_OpeningFilter->GetOutput()); m_ConcaveFilter->SetInput1(m_ClosingFilter->GetOutput()); m_ConcaveFilter->SetInput2(this->GetInput()); m_LevelingFilter->SetInput(this->GetInput()); m_LevelingFilter->SetInputConvexMap(m_ConvexFilter->GetOutput()); m_LevelingFilter->SetInputConcaveMap(m_ConcaveFilter->GetOutput()); m_ConvexFilter->GraftOutput(this->GetConvexMap()); m_ConvexFilter->Update(); this->GraftNthOutput(1, m_ConvexFilter->GetOutput()); m_ConcaveFilter->GraftOutput(this->GetConcaveMap()); m_ConcaveFilter->Update(); this->GraftNthOutput(2, m_ConcaveFilter->GetOutput()); m_LevelingFilter->GraftOutput(this->GetOutput()); m_LevelingFilter->Update(); this->GraftOutput(m_LevelingFilter->GetOutput()); } /** * Get the convex map */ template TOutputImage * GeodesicMorphologyDecompositionImageFilter ::GetConvexMap() { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetOutput(1)); } /** * Get the concave map */ template TOutputImage * GeodesicMorphologyDecompositionImageFilter ::GetConcaveMap() { if (this->GetNumberOfOutputs() < 3) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetOutput(2)); } /** * PrintSelf Method */ template void GeodesicMorphologyDecompositionImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbGeodesicMorphologyIterativeDecompositionImageFilter.h000066400000000000000000000137631301006202600405470ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeodesicMorphologyIterativeDecompositionImageFilter_h #define otbGeodesicMorphologyIterativeDecompositionImageFilter_h #include "otbImageToImageListFilter.h" #include "otbGeodesicMorphologyDecompositionImageFilter.h" namespace otb { /** \class GeodesicMorphologyIterativeDecompositionImageFilter * \brief This class recursively apply geodesic decomposition. * * \par * This algorithm is derived from the following publication: * \par * Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: * A new approach for the morphological segmentation of high resolution * satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, * NO. 2, February 2001, p. 309-320. * \par * * It provides a geodesic decomposition of the input image, with the following scheme. * Let \f$f_0\f$ denote the input image,\f$\stackrel{\smile}{\mu}_{N}(f)\f$ denote * the convex membership function, \f$ \stackrel{\frown}{\mu}_{N}(f) \f$ denote the concave * membership function and \f$\psi_{N}(f)\f$ denote the leveling function, for a given radius \f$ N \f$ * as defined in the documentation of the GeodesicMorphologyDecompositionImageFilter . * Let \f$[N_{1},\ldots, N_{n}]\f$ denote a range of increasing radius (or scales). The iterative * decomposition is defined as follows: * * \f[ * f_{n} = \psi_{N_{n}}(f_{n-1}) * \f] * * \f[ * \stackrel{\frown}{f}_{n} = \stackrel{\frown}{\mu}_{N_{N}}(f_{n}) * \f] * * \f[ * \stackrel{\smile}{f}_{n} = \stackrel{\smile}{\mu}_{N_{N}}(f_{n}) * \f] * * The \f$ \stackrel{\frown}{f}_{n}\f$ and \f$\stackrel{\frown}{f}_{n}\f$ are membership function * for the convex (resp. concave) objects whose size is comprised between \f$N_{n-1} \f$ and \f$N_n\f$ . * * \sa GeodescicMorphologyDecompositionImageFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT GeodesicMorphologyIterativeDecompositionImageFilter : public ImageToImageListFilter { public: /** Standard typedefs */ typedef GeodesicMorphologyIterativeDecompositionImageFilter Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(GeodesicMorphologyIterativeDecompositionImageFilter, ImageToImageListFilter); /** Input image dimension constant macro */ itkStaticConstMacro(InputImageDimension, unsigned int, TImage::ImageDimension); /** Output related typedefs */ typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename Superclass::OutputImagePointerType OutputImagePointerType; /** Input related typedefs */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImageRegionType InputImageRegionType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename InputImageType::ConstPointer InputImageConstPointerType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::ValueType ValueType; typedef typename InputImageType::PixelType PixelType; typedef typename InputImageType::SpacingType SpacingType; typedef TStructuringElement StructuringElementType; /** Typedef of the decomposition filter */ typedef GeodesicMorphologyDecompositionImageFilter DecompositionFilterType; typedef typename DecompositionFilterType::Pointer DecompositionFilterPointerType; /** Accessors */ itkSetMacro(Step, unsigned int); itkGetMacro(Step, unsigned int); itkSetMacro(InitialValue, unsigned int); itkGetMacro(InitialValue, unsigned int); itkSetMacro(NumberOfIterations, unsigned int); itkGetMacro(NumberOfIterations, unsigned int); /** * Get The leveling images for each scale. * \return The leveling images for each scale. */ OutputImageListType* GetOutput(void) ITK_OVERRIDE; /** * Get convex membership function for each scale * \return The convex membership function for each scale. */ OutputImageListType * GetConvexOutput(void); /** * Get The concave membership function for each scale * \return The concave membership function for each scale. */ OutputImageListType * GetConcaveOutput(void); protected: /** Constructor */ GeodesicMorphologyIterativeDecompositionImageFilter(); /** Destructor */ ~GeodesicMorphologyIterativeDecompositionImageFilter() ITK_OVERRIDE {} /** Generate output information */ void GenerateOutputInformation() ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** Printself method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: /** The step for the scale analysis */ unsigned int m_Step; /** The initial value for the scale */ unsigned int m_InitialValue; /** The number of iterations */ unsigned int m_NumberOfIterations; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbGeodesicMorphologyIterativeDecompositionImageFilter.txx" #endif #endif otbGeodesicMorphologyIterativeDecompositionImageFilter.txx000066400000000000000000000165641301006202600411450ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeodesicMorphologyIterativeDecompositionImageFilter_txx #define otbGeodesicMorphologyIterativeDecompositionImageFilter_txx #include "otbGeodesicMorphologyIterativeDecompositionImageFilter.h" #include "itkProgressAccumulator.h" #include "otbMacro.h" namespace otb { /** * Constructor */ template GeodesicMorphologyIterativeDecompositionImageFilter ::GeodesicMorphologyIterativeDecompositionImageFilter() { this->SetNumberOfRequiredInputs(1); this->SetNumberOfRequiredOutputs(3); m_NumberOfIterations = 2; m_InitialValue = 1; m_Step = 1; OutputImageListPointerType convList = OutputImageListType::New(); this->SetNthOutput(0, convList.GetPointer()); OutputImageListPointerType concList = OutputImageListType::New(); this->SetNthOutput(1, concList.GetPointer()); OutputImageListPointerType outputList = OutputImageListType::New(); this->SetNthOutput(2, outputList.GetPointer()); } template typename GeodesicMorphologyIterativeDecompositionImageFilter ::OutputImageListType* GeodesicMorphologyIterativeDecompositionImageFilter ::GetOutput(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(2)); } template typename GeodesicMorphologyIterativeDecompositionImageFilter ::OutputImageListType* GeodesicMorphologyIterativeDecompositionImageFilter ::GetConvexOutput(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(0)); } template typename GeodesicMorphologyIterativeDecompositionImageFilter ::OutputImageListType* GeodesicMorphologyIterativeDecompositionImageFilter ::GetConcaveOutput(void) { return dynamic_cast(this->itk::ProcessObject::GetOutput(1)); } template void GeodesicMorphologyIterativeDecompositionImageFilter ::GenerateOutputInformation(void) { // Retrieving input/output pointers InputImagePointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); OutputImageListPointerType convOutputPtr = this->GetConvexOutput(); OutputImageListPointerType concOutputPtr = this->GetConcaveOutput(); if (outputPtr) { if (outputPtr->Size() != m_NumberOfIterations) { // in this case, clear the list outputPtr->Clear(); for (unsigned int i = 0; i < m_NumberOfIterations; ++i) { //Create the output image outputPtr->PushBack(OutputImageType::New()); } } // For each output image typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); while (outputListIt != outputPtr->End()) { //Set the image information outputListIt.Get()->CopyInformation(this->GetInput()); outputListIt.Get()->SetRequestedRegion(this->GetInput()->GetLargestPossibleRegion()); ++outputListIt; } } if (convOutputPtr) { if (convOutputPtr->Size() != m_NumberOfIterations) { // in this case, clear the list convOutputPtr->Clear(); for (unsigned int i = 0; i < m_NumberOfIterations; ++i) { //Create the output image convOutputPtr->PushBack(OutputImageType::New()); } } // For each output image typename OutputImageListType::Iterator outputListIt = convOutputPtr->Begin(); while (outputListIt != convOutputPtr->End()) { //Set the image information outputListIt.Get()->CopyInformation(this->GetInput()); outputListIt.Get()->SetRequestedRegion(this->GetInput()->GetLargestPossibleRegion()); ++outputListIt; } } if (concOutputPtr) { if (concOutputPtr->Size() != m_NumberOfIterations) { // in this case, clear the list concOutputPtr->Clear(); for (unsigned int i = 0; i < m_NumberOfIterations; ++i) { //Create the output image concOutputPtr->PushBack(OutputImageType::New()); } } // For each output image typename OutputImageListType::Iterator outputListIt = concOutputPtr->Begin(); while (outputListIt != concOutputPtr->End()) { //Set the image information outputListIt.Get()->CopyInformation(this->GetInput()); outputListIt.Get()->SetRequestedRegion(this->GetInput()->GetLargestPossibleRegion()); ++outputListIt; } } } template void GeodesicMorphologyIterativeDecompositionImageFilter ::GenerateInputRequestedRegion(void) { // Retrieving input/output pointers InputImagePointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); // For each output image typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); inputPtr->SetRequestedRegion(outputListIt.Get()->GetRequestedRegion()); } /** * Main computation method */ template void GeodesicMorphologyIterativeDecompositionImageFilter ::GenerateData(void) { //Input image pointer InputImagePointerType current = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); OutputImageListPointerType convOutputPtr = this->GetConvexOutput(); OutputImageListPointerType concOutputPtr = this->GetConcaveOutput(); unsigned int i = 0; DecompositionFilterPointerType filter; while (i < m_NumberOfIterations) { filter = DecompositionFilterType::New(); typename StructuringElementType::RadiusType radius; radius.Fill(m_InitialValue + i * m_Step); filter->SetRadius(radius); filter->SetInput(current); filter->GetOutput()->UpdateOutputInformation(); filter->GetOutput()->SetRequestedRegion(outputPtr->GetNthElement(i)->GetRequestedRegion()); filter->GetOutput()->PropagateRequestedRegion(); filter->GetOutput()->UpdateOutputData(); outputPtr->SetNthElement(i, filter->GetOutput()); concOutputPtr->SetNthElement(i, filter->GetConvexMap()); convOutputPtr->SetNthElement(i, filter->GetConcaveMap()); current = filter->GetOutput(); ++i; } } /** * PrintSelf method */ template void GeodesicMorphologyIterativeDecompositionImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "NumberOfIterations: " << m_NumberOfIterations << std::endl; os << indent << "InitialValue: " << m_InitialValue << std::endl; os << indent << "Step: " << m_Step << std::endl; } } // End namespace otb #endif otbGeodesicMorphologyLevelingFilter.h000066400000000000000000000077341301006202600346610ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbGeodesicMorphologyLevelingFilter_h #define otbGeodesicMorphologyLevelingFilter_h #include "itkTernaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class LevelingFunctor * \brief This functor performs the pixel-wise leveling operation needed in the * geodesic morphology decomposition filter. For more details, please refer to * the documentation of this filter. * \sa GeodesicMorphologyDecompositionImageFilter * * \ingroup OTBMorphologicalProfiles */ template class LevelingFunctor { public: /// Constructor LevelingFunctor() {} /// Destructor virtual ~LevelingFunctor() {} inline TOutput operator ()(const TInput& pixel, const TInputMap& convexPixel, const TInputMap& concavePixel) { TOutput result; if (convexPixel > concavePixel) { result = static_cast(pixel - convexPixel); } else if (convexPixel < concavePixel) { result = static_cast(concavePixel + pixel); } else { result = static_cast(pixel); } return result; } }; } // end namespace Functor /** \class GeodesicMorphologyLevelingFilter * \brief This filter performs the leveling operation defined in the documentation of * the geodesic decomposition image filter, given the original image, convex and concave membership * functions. Please refer to the documentation of this filter for more details. * * \sa GeodesicMorphologyDecompositionImageFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT GeodesicMorphologyLevelingFilter : public itk::TernaryFunctorImageFilter > { public: /** Standard typedefs */ typedef GeodesicMorphologyLevelingFilter Self; typedef itk::TernaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(GeodesicMorphologyLevelingFilter, TernaryFunctorImageFilter); /** * Set the convex membership image. */ void SetInputConvexMap(const TInputMaps * convexMap) { this->SetInput2(convexMap); } /** * Set the concave membership image. */ void SetInputConcaveMap(const TInputMaps * concaveMap) { this->SetInput3(concaveMap); } /** * Set the original input image */ using Superclass::SetInput; void SetInput(const TInputImage * input) ITK_OVERRIDE { this->SetInput1(input); } protected: /** Constructor */ GeodesicMorphologyLevelingFilter() {}; /** Destructor */ ~GeodesicMorphologyLevelingFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: GeodesicMorphologyLevelingFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/otbImageToProfileFilter.h000066400000000000000000000107441301006202600323110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToProfileFilter_h #define otbImageToProfileFilter_h #include "otbImageToImageListFilter.h" namespace otb { /** \class ImageToProfileFilter * \brief Base class to produce a profile of the response of a given filter for a range of parameter. * * Let \f$ f \f$ denote an image, and \f$ \phi_{N}\f$ an image operator with the parameter \f$ N \f$ . * A profile \f$ \Pi_{\phi}(f)\f$ of \f$ f \f$ by \f$ \phi \f$ is defined as follows: * \f[ * \Pi_{\phi}(f)= \{\phi_{n}(f), n \in \{n_{1},\ldots, n_{N}\} \} * \f] * * with \f$ \{n_{1},\ldots, n_{N}\} \f$ being a range of parameter. This class is a base class templated * by the type of the filter \f$ \phi \f$. The SetProfileParameter() is a virtual method meant to be * rewritten so that the filter can be correctly set up in sub-classes. * * \sa MorphologicalOpeningProfileFilter * \sa MorhologicalClosingProfileFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT ImageToProfileFilter : public ImageToImageListFilter { public: /** Standard typedefs */ typedef ImageToProfileFilter Self; typedef ImageToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ImageToProfileFilter, ImageToImageListFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TParameter ParameterType; typedef TFilter FilterType; typedef typename FilterType::Pointer FilterPointerType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename Superclass::OutputImageListPointerType OutputImageListPointerType; typedef typename Superclass::InputImagePointer InputImagePointerType; /** Get/Set the initial value */ itkSetMacro(InitialValue, ParameterType); itkGetMacro(InitialValue, ParameterType); /** Get/Set the profile size */ itkSetMacro(ProfileSize, unsigned int); itkGetMacro(ProfileSize, unsigned int); /** Get/Set the profile step */ itkSetMacro(Step, ParameterType); itkGetMacro(Step, ParameterType); /** Get/Set the output index */ itkSetMacro(OutputIndex, unsigned int); itkGetMacro(OutputIndex, unsigned int); protected: /** * Set the profile parameter */ virtual void SetProfileParameter(ParameterType /*param*/) {} /** Get the pointer to the filter */ itkGetObjectMacro(Filter, FilterType); /** GenerateData method */ void GenerateData(void) ITK_OVERRIDE; /** GenerateOutputInformation method */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Generate input requested region */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Constructor */ ImageToProfileFilter(); /** Destructor */ ~ImageToProfileFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ImageToProfileFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The filter used to compute the profile */ FilterPointerType m_Filter; /** The profile parameters */ unsigned int m_ProfileSize; /** Initial value */ ParameterType m_InitialValue; /** Step */ ParameterType m_Step; /** The index of the output of the filter used for the profile */ unsigned int m_OutputIndex; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbImageToProfileFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/otbImageToProfileFilter.txx000066400000000000000000000110301301006202600326720ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbImageToProfileFilter_txx #define otbImageToProfileFilter_txx #include "otbImageToProfileFilter.h" namespace otb { /** * Constructor */ template ImageToProfileFilter ::ImageToProfileFilter() { m_InitialValue = 0; m_Step = 1; m_ProfileSize = 10; m_OutputIndex = 0; m_Filter = FilterType::New(); } /** * GenerateOutputInformation method */ template void ImageToProfileFilter ::GenerateOutputInformation(void) { // Retrieving input/output pointers InputImagePointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); if (outputPtr) { if (outputPtr->Size() != m_ProfileSize) { // in this case, clear the list outputPtr->Clear(); for (unsigned int i = 0; i < m_ProfileSize; ++i) { //Create the output image outputPtr->PushBack(OutputImageType::New()); } } // For each output image typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); m_Filter->SetInput(inputPtr); m_Filter->UpdateOutputInformation(); while (outputListIt != outputPtr->End()) { //Set the image information outputListIt.Get()->CopyInformation(m_Filter->GetOutput(m_OutputIndex)); outputListIt.Get()->SetLargestPossibleRegion(m_Filter->GetOutput(m_OutputIndex)->GetLargestPossibleRegion()); ++outputListIt; } } } /** * Generate input requested region */ template void ImageToProfileFilter ::GenerateInputRequestedRegion(void) { // Retrieving input/output pointers InputImagePointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); // For each output image typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); m_Filter->SetInput(inputPtr); // Use the filter to generate input requested region while (outputListIt != outputPtr->End()) { m_Filter->GetOutput(m_OutputIndex)->SetRequestedRegion(outputListIt.Get()->GetRequestedRegion()); m_Filter->PropagateRequestedRegion(outputListIt.Get()); ++outputListIt; } } /** * GenerateData method */ template void ImageToProfileFilter ::GenerateData(void) { // Retrieving input/output pointers InputImagePointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); m_Filter->SetInput(inputPtr); for (unsigned int i = 0; i < m_ProfileSize; ++i) { ParameterType profileParameter = m_InitialValue + static_cast(i) * m_Step; this->SetProfileParameter(profileParameter); m_Filter->GetOutput(m_OutputIndex)->SetRequestedRegion(outputPtr->GetNthElement(i)->GetRequestedRegion()); m_Filter->Update(); outputPtr->SetNthElement(i, static_cast(m_Filter->GetOutput(m_OutputIndex))); outputPtr->GetNthElement(i)->DisconnectPipeline(); } } /** * PrintSelf Method */ template void ImageToProfileFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Filter: " << m_Filter->GetNameOfClass() << std::endl; os << indent << "OutputIndex: " << m_OutputIndex << std::endl; os << indent << "ProfileSize: " << m_ProfileSize << std::endl; os << indent << "InitialValue: " << m_InitialValue << std::endl; os << indent << "Step: " << m_Step << std::endl; } } // End namespace otb #endif otbMorphologicalClosingProfileFilter.h000066400000000000000000000064301301006202600350200ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalClosingProfileFilter_h #define otbMorphologicalClosingProfileFilter_h #include "otbImageToProfileFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkClosingByReconstructionImageFilter.h" namespace otb { /** \class MorphologicalClosingProfileFilter * \brief This filter compute the morphological closing profile. * * This algorithm is based on the following publication: * \par * Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: * A new approach for the morphological segmentation of high resolution * satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, * NO. 2, February 2001, p. 309-320. * \par * * The opening profile is a set of images being the result of a geodesic morphological * closing by reconstruction with an increasing range of structuring element sizes. * * For more information on profiles please refer to the documentation of the otb::ImageToProfileFilter * class. * * \sa ImageToProfileFilter * \sa itk::ClosingByReconstructionImageFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT MorphologicalClosingProfileFilter : public ImageToProfileFilter, unsigned int> { public: /** Standard typedefs */ typedef MorphologicalClosingProfileFilter Self; typedef ImageToProfileFilter, unsigned int> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(MorphologicalClosingProfileFilter, ImageToProfileFilter); typedef TStructuringElement StructuringElementType; typedef typename Superclass::ParameterType ParameterType; protected: /** Set the profile parameter */ void SetProfileParameter(ParameterType param) ITK_OVERRIDE { StructuringElementType se; se.SetRadius(param); se.CreateStructuringElement(); this->GetFilter()->SetKernel(se); } /** Constructor */ MorphologicalClosingProfileFilter() {}; /** Destructor */ ~MorphologicalClosingProfileFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: MorphologicalClosingProfileFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif otbMorphologicalOpeningProfileFilter.h000066400000000000000000000064301301006202600350210ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalOpeningProfileFilter_h #define otbMorphologicalOpeningProfileFilter_h #include "otbImageToProfileFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkOpeningByReconstructionImageFilter.h" namespace otb { /** \class MorphologicalOpeningProfileFilter * \brief This filter compute the morphological opening profile. * * This algorithm is based on the following publication: * \par * Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: * A new approach for the morphological segmentation of high resolution * satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, * NO. 2, February 2001, p. 309-320. * \par * * The opening profile is a set of images being the result of a geodesic morphological * opening by reconstruction with an increasing range of structuring element sizes. * * For more information on profiles please refer to the documentation of the otb::ImageToProfileFilter * class. * * \sa ImageToProfileFilter * \sa itk::OpeningByReconstructionImageFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT MorphologicalOpeningProfileFilter : public ImageToProfileFilter, unsigned int> { public: /** Standard typedefs */ typedef MorphologicalOpeningProfileFilter Self; typedef ImageToProfileFilter, unsigned int> Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(MorphologicalOpeningProfileFilter, ImageToProfileFilter); typedef TStructuringElement StructuringElementType; typedef typename Superclass::ParameterType ParameterType; protected: /** Set the profile parameter */ void SetProfileParameter(ParameterType param) ITK_OVERRIDE { StructuringElementType se; se.SetRadius(param); se.CreateStructuringElement(); this->GetFilter()->SetKernel(se); } /** Constructor */ MorphologicalOpeningProfileFilter() {}; /** Destructor */ ~MorphologicalOpeningProfileFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); } private: MorphologicalOpeningProfileFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // End namespace otb #endif otbMorphologicalProfilesSegmentationFilter.h000066400000000000000000000124721301006202600362450ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalProfilesSegmentationFilter_h #define otbMorphologicalProfilesSegmentationFilter_h #include "otbMorphologicalOpeningProfileFilter.h" #include "otbMorphologicalClosingProfileFilter.h" #include "otbProfileToProfileDerivativeFilter.h" #include "otbProfileDerivativeToMultiScaleCharacteristicsFilter.h" #include "otbMultiScaleConvexOrConcaveClassificationFilter.h" #include "otbImage.h" #include "itkScalarConnectedComponentImageFilter.h" #include "itkBinaryBallStructuringElement.h" namespace otb { /** \class MorphologicalProfilesSegmentationFilter * \brief This class implements segmentation by morphological profiles * * This filter implements segmentation based on the morphological * profiles, based on this work: * \par * Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: * A new approach for the morphological segmentation of high resolution * satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, * NO. 2, February 2001, p. 309-320. * \par * * This filter is composite and creates the full pipeline to * implement the method. the * otb::MultiScaleConvexOrConcaveClassificationFilter is wired to an * itk::ScalarConnectedComponentImageFilter so as to get a labeled * raster output. * \sa otb::MorphologicalOpeningProfileFilter * \sa otb::MorphologicalClosingProfileFilter * \sa otb::ProfileToProfileDerivativeFilter * \sa otb::ProfileDerivativeToMultiScaleCharacteristicsFilter * \sa otb::MultiScaleConvexOrConcaveClassificationFilter * * \ingroup OTBMorphologicalProfiles */ template > class ITK_EXPORT MorphologicalProfilesSegmentationFilter : public itk::ImageToImageFilter { public: /** Standard Self typedef */ typedef MorphologicalProfilesSegmentationFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef TOutputImage OutputImageType; typedef otb::Image InternalImageType; typedef TStructuringElement StructuringElementType; typedef otb::MorphologicalOpeningProfileFilter OpeningProfileFilterType; typedef otb::MorphologicalClosingProfileFilter ClosingProfileFilterType; typedef otb::ProfileToProfileDerivativeFilter DerivativeFilterType; typedef otb::ProfileDerivativeToMultiScaleCharacteristicsFilter MultiScaleCharacteristicsFilterType; typedef otb::MultiScaleConvexOrConcaveClassificationFilter MultiScaleClassificationFilterType; typedef itk::ScalarConnectedComponentImageFilter ConnectedComponentsFilterType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(MorphologicalProfilesSegmentationFilter, itk::ImageToImageFilter); itkSetMacro(ProfileSize,unsigned int); itkGetConstReferenceMacro(ProfileSize,unsigned int); itkSetMacro(ProfileStart,unsigned int); itkGetConstReferenceMacro(ProfileStart,unsigned int); itkSetMacro(ProfileStep,unsigned int); itkGetConstReferenceMacro(ProfileStep,unsigned int); itkSetMacro(Sigma,double); itkGetConstReferenceMacro(Sigma,double); protected: MorphologicalProfilesSegmentationFilter(); ~MorphologicalProfilesSegmentationFilter() ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: typename OpeningProfileFilterType::Pointer m_OpeningProfile; typename ClosingProfileFilterType::Pointer m_ClosingProfile; typename DerivativeFilterType::Pointer m_OpeningDerivativeProfile; typename DerivativeFilterType::Pointer m_ClosingDerivativeProfile; typename MultiScaleCharacteristicsFilterType::Pointer m_OpeningCharacteristicsFilter; typename MultiScaleCharacteristicsFilterType::Pointer m_ClosingCharacteristicsFilter; typename MultiScaleClassificationFilterType::Pointer m_ClassificationFilter; typename ConnectedComponentsFilterType::Pointer m_ConnectedComponentsFilter; unsigned int m_ProfileSize; unsigned int m_ProfileStart; unsigned int m_ProfileStep; double m_Sigma; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbMorphologicalProfilesSegmentationFilter.txx" #endif #endif otbMorphologicalProfilesSegmentationFilter.txx000066400000000000000000000075361301006202600366460ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMorphologicalProfilesSegmentationFilter_txx #define otbMorphologicalProfilesSegmentationFilter_txx #include "otbMorphologicalProfilesSegmentationFilter.h" namespace otb { template MorphologicalProfilesSegmentationFilter ::MorphologicalProfilesSegmentationFilter() { m_ProfileSize = 5; m_ProfileStart = 1; m_ProfileStep = 1; m_Sigma = 0.0; m_ClassificationFilter = MultiScaleClassificationFilterType::New(); m_ConnectedComponentsFilter = ConnectedComponentsFilterType::New(); m_OpeningProfile = OpeningProfileFilterType::New(); m_ClosingProfile = ClosingProfileFilterType::New(); m_OpeningDerivativeProfile = DerivativeFilterType::New(); m_ClosingDerivativeProfile = DerivativeFilterType::New(); m_OpeningCharacteristicsFilter = MultiScaleCharacteristicsFilterType::New(); m_ClosingCharacteristicsFilter = MultiScaleCharacteristicsFilterType::New(); // Wire pipeline m_OpeningDerivativeProfile->SetInput(m_OpeningProfile->GetOutput()); m_ClosingDerivativeProfile->SetInput(m_ClosingProfile->GetOutput()); m_OpeningCharacteristicsFilter->SetInput(m_OpeningDerivativeProfile->GetOutput()); m_ClosingCharacteristicsFilter->SetInput(m_ClosingDerivativeProfile->GetOutput()); m_ClassificationFilter->SetOpeningProfileDerivativeMaxima(m_OpeningCharacteristicsFilter->GetOutput()); m_ClassificationFilter->SetOpeningProfileCharacteristics(m_OpeningCharacteristicsFilter->GetOutputCharacteristics()); m_ClassificationFilter->SetClosingProfileDerivativeMaxima(m_ClosingCharacteristicsFilter->GetOutput()); m_ClassificationFilter->SetClosingProfileCharacteristics(m_ClosingCharacteristicsFilter->GetOutputCharacteristics()); m_ConnectedComponentsFilter->SetInput(m_ClassificationFilter->GetOutput()); } template MorphologicalProfilesSegmentationFilter ::~MorphologicalProfilesSegmentationFilter() {} template void MorphologicalProfilesSegmentationFilter ::GenerateData() { m_OpeningProfile->SetInput(this->GetInput()); m_ClosingProfile->SetInput(this->GetInput()); m_OpeningProfile->SetProfileSize(m_ProfileSize); m_OpeningProfile->SetInitialValue(m_ProfileStart); m_OpeningProfile->SetStep(m_ProfileStep); m_ClosingProfile->SetProfileSize(m_ProfileSize); m_ClosingProfile->SetInitialValue(m_ProfileStart); m_ClosingProfile->SetStep(m_ProfileStep); m_OpeningCharacteristicsFilter->SetInitialValue(m_ProfileStart); m_OpeningCharacteristicsFilter->SetStep(m_ProfileStep); m_ClosingCharacteristicsFilter->SetInitialValue(m_ProfileStart); m_ClosingCharacteristicsFilter->SetStep(m_ProfileStep); m_ClassificationFilter->SetSigma(m_Sigma); m_ClassificationFilter->SetLabelSeparator(m_ProfileStart + m_ProfileSize * m_ProfileStep); m_ConnectedComponentsFilter->GraftOutput(this->GetOutput()); m_ConnectedComponentsFilter->Update(); this->GraftOutput(m_ConnectedComponentsFilter->GetOutput()); } } #endif otbMultiScaleConvexOrConcaveClassificationFilter.h000066400000000000000000000173001301006202600372600ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbMultiScaleConvexOrConcaveClassificationFilter_h #define otbMultiScaleConvexOrConcaveClassificationFilter_h #include "otbQuaternaryFunctorImageFilter.h" namespace otb { namespace Functor { /** \class MultiScaleConvexOrConcaveDecisionRule * \brief This Functor apply a classification rule on two membership value along with two labels. * * \par * This algorithm is based on the following publication: * \par * Martino Pesaresi and Jon Alti Benediktsson, Member, IEEE: * A new approach for the morphological segmentation of high resolution * satellite imagery. IEEE Transactions on geoscience and remote sensing, vol. 39, * NO. 2, February 2001, p. 309-320. * \par * * Given \f$x_1\f$ and \f$x_2\f$ two membership values, \f$L_1, L_2\f$ two labels associated, * and \f$\sigma\f$ a tolerance value, the following decision rule is applied: * * \f[ * L=\left\{\begin{array}{lcl} * L_{1} &:& x_{1}>x_{2} \quad and \quad x_{1}>\sigma\\ * L_{2} &:& x_{2}>x_{1} \quad and \quad x_{2}>\sigma\\ * 0 &:& otherwise. * \end{array}\right. * \f] * * To help the distinction between \f$L_{1}\f$ labels and \f$L_{2}\f$, * this functor adds the m_LabelSeparators value to the \f$L_{1}\f$ labels. * * This functor is the decision rule used for multi-scale classification using * morphological profiles. * * \ingroup OTBMorphologicalProfiles */ template class MultiScaleConvexOrConcaveDecisionRule { public: /** * Constructor */ MultiScaleConvexOrConcaveDecisionRule() { m_Sigma = 0.0; m_LabelSeparator = 10; } /** * Destructor */ virtual ~MultiScaleConvexOrConcaveDecisionRule() {} /** * Label the pixel to convex, concave or flat * \return The label of the pixel * \param opDeMax The max of the opening profile derivative * \param cloDeMax The max of the closing profile derivative * \param opDeChar The characteristic of the opening profile * \param cloDeChar The characteristic of the closing profile */ inline TLabeled operator ()(const TInput& opDeMax, const TInput& cloDeMax, const TLabeled& opDeChar, const TLabeled& cloDeChar) { TLabeled resp = 0; if (opDeMax > cloDeMax && static_cast(opDeMax) > m_Sigma) { resp = m_LabelSeparator + opDeChar; } else if (cloDeMax > opDeMax && static_cast(cloDeMax) > m_Sigma) { resp = cloDeChar; } return resp; } /** * Set the tolerance value * \param sigma the tolerance value */ void SetSigma(const double& sigma) { m_Sigma = sigma; } /** * Get the tolerance value * \return the tolerance value */ double GetSigma(void) { return m_Sigma; } /** * Set the label separator * \param labelSeparator the label separator */ void SetLabelSeparator(const TLabeled& labelSeparator) { m_LabelSeparator = labelSeparator; } /** * Get the label separator * \return the label separator */ TLabeled GetLabelSeparator(void) { return m_LabelSeparator; } private: /** Sigma (tolerance) parameter */ double m_Sigma; /** Separate between convex and concave labels */ TLabeled m_LabelSeparator; }; } //end namespace Functor /** \class MultiScaleConvexOrConcaveClassificationFilter * \brief Apply the MultiScaleConvexOrConcaveDecisionRule to whole images. * * See MultiScaleConvexOrConcaveDecisionRule functor documentation for more details. * * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT MultiScaleConvexOrConcaveClassificationFilter : public QuaternaryFunctorImageFilter > { public: /** Standard typedefs */ typedef MultiScaleConvexOrConcaveClassificationFilter Self; typedef QuaternaryFunctorImageFilter > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(MultiScaleConvexOrConcaveClassificationFilter, QuaternaryFunctorImageFilter); /** Template class typedef */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::PixelType LabelType; typedef Functor::MultiScaleConvexOrConcaveDecisionRule DecisionFunctorType; /** * Set the opening profile derivative maxima image * \param derivativeMaxima the opening profile derivative maxima image * */ void SetOpeningProfileDerivativeMaxima(const TInputImage * derivativeMaxima) { this->SetInput1(derivativeMaxima); } /** * Set the opening profile characteristics image * \param characteristics the opening profile characteristics image * */ void SetOpeningProfileCharacteristics(const TOutputImage * characteristics) { this->SetInput3(characteristics); } /** * Set the closing profile derivative maxima image * \param derivativeMaxima the closing profile derivative maxima image * */ void SetClosingProfileDerivativeMaxima(const TInputImage * derivativeMaxima) { this->SetInput2(derivativeMaxima); } /** * Set the closing profile characteristics image * \param characteristics the closing profile characteristics image * */ void SetClosingProfileCharacteristics(const TOutputImage * characteristics) { this->SetInput4(characteristics); } /** Set/Get the tolerance value */ itkSetMacro(Sigma, double); itkGetMacro(Sigma, double); /** Set/Get the label separator */ itkSetMacro(LabelSeparator, LabelType); itkGetMacro(LabelSeparator, LabelType); /** Set the functor parameters before calling the ThreadedGenerateData() */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE { this->GetFunctor().SetLabelSeparator(m_LabelSeparator); this->GetFunctor().SetSigma(m_Sigma); } protected: /** Constructor */ MultiScaleConvexOrConcaveClassificationFilter() { m_LabelSeparator = 10; m_Sigma = 0.0; }; /** Destructor */ ~MultiScaleConvexOrConcaveClassificationFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE { Superclass::PrintSelf(os, indent); os << indent << "LabelSeparator: " << m_LabelSeparator << std::endl; os << indent << "Sigma: " << m_Sigma << std::endl; } private: MultiScaleConvexOrConcaveClassificationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Label separator between convex and concave labels */ LabelType m_LabelSeparator; /** Tolerance value */ double m_Sigma; }; } // End namespace otb #endif otbOpeningClosingMorphologicalFilter.h000066400000000000000000000066621301006202600350260ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOpeningClosingMorphologicalFilter_h #define otbOpeningClosingMorphologicalFilter_h #include "itkImageToImageFilter.h" namespace otb { /** * \class OpeningClosingMorphologicalFilter * \brief This filter implements an opening grayscale morphological operation * followed by a closing grayscale morphological operation. It tends to simplify * image by obliterating details with a lower extent than the structuring element. * * This filter implements an opening grayscale morphological operation * followed by a closing grayscale morphological operation. It tends to simplify * image by obliterating details with a lower extent than the structuring element. * * This filter can be used in the morphological pyramid analyse filter. Due to the order * of composition of the two basic morphological operation, the filtered details are dark * on a brighter background. * * \sa ClosingOpeningMorphologicalFilter, * MorphologicalPyramidAnalyseFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT OpeningClosingMorphologicalFilter : public itk::ImageToImageFilter { public: /** Standard typedefs */ typedef OpeningClosingMorphologicalFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Creation through object factory macro */ itkNewMacro(Self); /** Type macro */ itkTypeMacro(OpeningClosingMorphologicalFilter, ImageToImageFilter); /** Template parameter typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TKernel KernelType; /** Useful typedefs */ typedef typename InputImageType::Pointer InputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename TInputImage::PixelType PixelType; /** Kernel accessors */ itkSetMacro(Kernel, KernelType); itkGetConstReferenceMacro(Kernel, KernelType); protected: /** Constructor */ OpeningClosingMorphologicalFilter(); /** Destructor */ ~OpeningClosingMorphologicalFilter() ITK_OVERRIDE {} /* void GenerateInputRequestedRegion(); */ /* void EnlargeOutputRequestedRegion(itk::DataObject *itkNotUsed(output)); */ /** Main computation method */ void GenerateData() ITK_OVERRIDE; /** PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: OpeningClosingMorphologicalFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Morphological operation kernel */ KernelType m_Kernel; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOpeningClosingMorphologicalFilter.txx" #endif #endif otbOpeningClosingMorphologicalFilter.txx000066400000000000000000000053601301006202600354140ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOpeningClosingMorphologicalFilter_txx #define otbOpeningClosingMorphologicalFilter_txx #include "otbOpeningClosingMorphologicalFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkGrayscaleMorphologicalOpeningImageFilter.h" #include "itkGrayscaleMorphologicalClosingImageFilter.h" #include "itkProgressAccumulator.h" namespace otb { /** * Constructor */ template OpeningClosingMorphologicalFilter ::OpeningClosingMorphologicalFilter() { m_Kernel.SetRadius(1); m_Kernel.CreateStructuringElement(); } /** * Main computation method */ template void OpeningClosingMorphologicalFilter ::GenerateData() { // Filters Typedefs (this class is actually a composite filter) typedef itk::GrayscaleMorphologicalOpeningImageFilter OpenFilterType; typedef itk::GrayscaleMorphologicalClosingImageFilter CloseFilterType; // Filters initialization typename OpenFilterType::Pointer opening = OpenFilterType::New(); typename CloseFilterType::Pointer closing = CloseFilterType::New(); // Set the kernel opening->SetKernel(this->GetKernel()); closing->SetKernel(this->GetKernel()); // Progression report management itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New(); progress->SetMiniPipelineFilter(this); progress->RegisterInternalFilter(opening, .5f); progress->RegisterInternalFilter(closing, .5f); // Internal Pipeline connexion closing->SetInput(this->GetInput()); opening->SetInput(closing->GetOutput()); // Output connexion opening->GraftOutput(this->GetOutput()); opening->Update(); this->GraftOutput(opening->GetOutput()); } /** * PrintSelf method */ template void OpeningClosingMorphologicalFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "Kernel: " << m_Kernel << std::endl; } } // End namespace otb #endif otbProfileDerivativeToMultiScaleCharacteristicsFilter.h000066400000000000000000000106361301006202600403310ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProfileDerivativeToMultiScaleCharacteristicsFilter_h #define otbProfileDerivativeToMultiScaleCharacteristicsFilter_h #include "otbImageListToImageFilter.h" namespace otb { /** \class ProfileDerivativeToMultiScaleCharacteristicsFilter * \brief This filter extracts the maximum derivative value of the input profile. * * This filter extracts the maximum derivative value of the input profile as well * as the parameter (called characteristic) for which this maxima occurs. * * The maxima can be retrieved by the GetOutput() image, while the characteristics * can be retrieved by the GetOutputCharacteristics(). * * Please note that this characteristics can be scaled using the InitialValue and Step * parameter corresponding to the input profile. * * \sa ProfileToProfileDerivativeImageFilter * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT ProfileDerivativeToMultiScaleCharacteristicsFilter : public ImageListToImageFilter { public: /** Standard typedefs */ typedef ProfileDerivativeToMultiScaleCharacteristicsFilter Self; typedef ImageListToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ProfileDerivativeToMultiScaleCharacteristicsFilter, ImageToImageListFilter); /** Template parameters typedefs */ typedef TInputImage InputImageType; typedef TOutputImage OutputImageType; typedef TLabeledImage LabeledImageType; typedef typename InputImageType::Pointer InputImagePointerType; typedef typename OutputImageType::Pointer OutputImagePointerType; typedef typename LabeledImageType::Pointer LabeledImagePointerType; typedef typename Superclass::InputImageListType InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename OutputImageType::RegionType RegionType; typedef typename LabeledImageType::PixelType LabeledPixelType; typedef typename OutputImageType::PixelType OutputPixelType; /** * Returns the characteristics image. * \return The Characteristics image. */ virtual TLabeledImage * GetOutputCharacteristics(void); /** Set/Get the initial profile value */ itkSetMacro(InitialValue, LabeledPixelType); itkGetMacro(InitialValue, LabeledPixelType); /** Set/Get the profile step */ itkSetMacro(Step, LabeledPixelType); itkGetMacro(Step, LabeledPixelType); protected: /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** GenerateOutputInformation * Set the number of bands of the output. * Copy information from the first image of the list if existing. **/ void GenerateOutputInformation(void) ITK_OVERRIDE; /** * GenerateInputRequestedRegion * Set the requested region of each image in the list. */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; /** Constructor */ ProfileDerivativeToMultiScaleCharacteristicsFilter(); /** Destructor */ ~ProfileDerivativeToMultiScaleCharacteristicsFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ProfileDerivativeToMultiScaleCharacteristicsFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** The initial value of the profile */ LabeledPixelType m_InitialValue; /** The step of the profile */ LabeledPixelType m_Step; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbProfileDerivativeToMultiScaleCharacteristicsFilter.txx" #endif #endif otbProfileDerivativeToMultiScaleCharacteristicsFilter.txx000066400000000000000000000166071301006202600407310ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProfileDerivativeToMultiScaleCharacteristicsFilter_txx #define otbProfileDerivativeToMultiScaleCharacteristicsFilter_txx #include "otbProfileDerivativeToMultiScaleCharacteristicsFilter.h" #include "itkImageRegionIterator.h" #include #include "otbMacro.h" namespace otb { template ProfileDerivativeToMultiScaleCharacteristicsFilter ::ProfileDerivativeToMultiScaleCharacteristicsFilter(void) { this->SetNumberOfRequiredOutputs(2); this->SetNthOutput(0, OutputImageType::New()); this->SetNthOutput(1, LabeledImageType::New()); m_InitialValue = 0; m_Step = 1; } template TLabeledImage * ProfileDerivativeToMultiScaleCharacteristicsFilter ::GetOutputCharacteristics(void) { if (this->GetNumberOfOutputs() < 2) { return ITK_NULLPTR; } return static_cast (this->itk::ProcessObject::GetOutput(1)); } /** * GenerateOutputInformation */ template void ProfileDerivativeToMultiScaleCharacteristicsFilter ::GenerateOutputInformation(void) { InputImageListPointerType inputPtr = this->GetInput(); OutputImagePointerType outputPtr = this->GetOutput(); LabeledImagePointerType outputLabeledPtr = this->GetOutputCharacteristics(); if (inputPtr->Size() > 0) { typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); outputPtr->CopyInformation(inputListIt.Get()); outputLabeledPtr->CopyInformation(inputListIt.Get()); } } /** * GenerateInputRequestedRegion */ template void ProfileDerivativeToMultiScaleCharacteristicsFilter ::GenerateInputRequestedRegion(void) { InputImageListPointerType inputPtr = this->GetInput(); typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); RegionType region1 = this->GetOutput()->GetRequestedRegion(); RegionType region2 = this->GetOutputCharacteristics()->GetRequestedRegion(); RegionType region; /** * Compute the appropriate requested region: * This is the smaller region containing the two output regions */ if (region1 == this->GetOutput()->GetLargestPossibleRegion() && region2 != this->GetOutputCharacteristics()->GetLargestPossibleRegion()) { region = region2; } else if (region1 != this->GetOutput()->GetLargestPossibleRegion() && region2 == this->GetOutputCharacteristics()->GetLargestPossibleRegion()) { region = region1; } else { int xul1 = region1.GetIndex()[0]; int xul2 = region2.GetIndex()[0]; int yul1 = region1.GetIndex()[1]; int yul2 = region2.GetIndex()[1]; int xlr1 = region1.GetIndex()[0] + region1.GetSize()[0]; int xlr2 = region2.GetIndex()[0] + region2.GetSize()[0]; int ylr1 = region1.GetIndex()[1] + region1.GetSize()[1]; int ylr2 = region2.GetIndex()[1] + region2.GetSize()[1]; int xul = std::min(xul1, xul2); int yul = std::min(yul1, yul2); int xlr = std::max(xlr1, xlr2); int ylr = std::max(ylr1, ylr2); typename RegionType::IndexType index; index[0] = xul; index[1] = yul; typename RegionType::SizeType size; size[0] = static_cast(xlr - xul); size[1] = static_cast(ylr - yul); region.SetIndex(index); region.SetSize(size); } while (inputListIt != inputPtr->End()) { inputListIt.Get()->SetRequestedRegion(region); ++inputListIt; } } /** * Main computation method */ template void ProfileDerivativeToMultiScaleCharacteristicsFilter ::GenerateData(void) { OutputImagePointerType outputPtr = this->GetOutput(); LabeledImagePointerType outputLabeledPtr = this->GetOutputCharacteristics(); InputImageListPointerType inputPtr = this->GetInput(); // Output image initializations outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); outputPtr->Allocate(); outputPtr->FillBuffer(0); outputLabeledPtr->SetBufferedRegion(outputLabeledPtr->GetRequestedRegion()); outputLabeledPtr->Allocate(); outputLabeledPtr->FillBuffer(0); // defines input and output iterators typedef itk::ImageRegionConstIterator InputIteratorType; typedef itk::ImageRegionIterator OutputIteratorType; typedef itk::ImageRegionIterator LabeledIteratorType; typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); // defines a vector of input iterators typedef std::vector InputIteratorListType; InputIteratorListType inputIteratorList; // fills the vector of input iterators for (; inputListIt != inputPtr->End(); ++inputListIt) { inputIteratorList.push_back(InputIteratorType(inputListIt.Get(), inputListIt.Get()->GetRequestedRegion())); inputIteratorList.back().GoToBegin(); } // walk through the output images OutputIteratorType outputIt(outputPtr, outputPtr->GetRequestedRegion()); outputIt.GoToBegin(); LabeledIteratorType labeledIt(outputLabeledPtr, outputLabeledPtr->GetRequestedRegion()); labeledIt.GoToBegin(); bool inputIteratorsAtEnd = false; for (typename InputIteratorListType::iterator it = inputIteratorList.begin(); it != inputIteratorList.end(); ++it) { inputIteratorsAtEnd = inputIteratorsAtEnd || it->IsAtEnd(); } while (!outputIt.IsAtEnd() && !labeledIt.IsAtEnd() && !inputIteratorsAtEnd) { unsigned int index = 0; OutputPixelType outputPixel = 0; LabeledPixelType outputChar = 0; // for each input iterator, check the output and characteristics for (typename InputIteratorListType::iterator it = inputIteratorList.begin(); it != inputIteratorList.end(); ++it) { if (it->Get() > outputPixel) { outputPixel = it->Get(); outputChar = m_InitialValue + m_Step * (static_cast(index)); } ++index; } outputIt.Set(outputPixel); labeledIt.Set(outputChar); ++outputIt; ++labeledIt; for (typename InputIteratorListType::iterator it = inputIteratorList.begin(); it != inputIteratorList.end(); ++it) { ++(*it); inputIteratorsAtEnd = inputIteratorsAtEnd || it->IsAtEnd(); } } } /** * PrintSelf Method */ template void ProfileDerivativeToMultiScaleCharacteristicsFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif otbProfileToProfileDerivativeFilter.h000066400000000000000000000077061301006202600346370ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProfileToProfileDerivativeFilter_h #define otbProfileToProfileDerivativeFilter_h #include "otbImageListToImageListFilter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkSubtractImageFilter.h" #include "itkAbsImageFilter.h" namespace otb { /** \class ProfileToProfileDerivativeFilter * \brief This filter computes the derivative of a given profile. * * For the profile \f$ \Pi_{\phi}(f)= \{\phi_{n}(f), n \in \{n_{1},\ldots, n_{N}\}\}\f$, the * profile derivative is defined by: * * \f[ * \Delta\Pi_{\phi}(f)= \{\Delta\phi_{n}(f), n \in \{n_{1},\ldots, n_{N}\}\} * \f] * * with \f$ \Delta\phi_{n}(f) = \mid \Pi_{\phi_{n2}}(f)-\Pi_{\phi_{n1}}(f) \mid \f$ * * \ingroup Streamed * * \ingroup OTBMorphologicalProfiles */ template class ITK_EXPORT ProfileToProfileDerivativeFilter : public ImageListToImageListFilter { public: /** Standard typedefs */ typedef ProfileToProfileDerivativeFilter Self; typedef ImageListToImageListFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(ProfileToProfileDerivativeFilter, ImageListToImageListFilter); /** Template parameters typedefs */ typedef typename Superclass::InputImageListType InputImageListType; typedef typename InputImageListType::Pointer InputImageListPointerType; typedef typename Superclass::OutputImageListType OutputImageListType; typedef typename OutputImageListType::Pointer OutputImageListPointerType; typedef typename OutputImageListType::ImageType OutputImageType; typedef typename InputImageListType::ImageType InputImageType; typedef typename InputImageType::Pointer InputImagePointerType; /** typedefs of the filters used for the derivative */ typedef itk::SubtractImageFilter SubtractFilterType; typedef itk::AbsImageFilter AbsFilterType; typedef typename SubtractFilterType::Pointer SubtractFilterPointerType; typedef typename AbsFilterType::Pointer AbsFilterPointerType; /** Generate output information for the ImageList and for each image in the list. */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Generate input requested region for each image in the list. */ void GenerateInputRequestedRegion(void) ITK_OVERRIDE; protected: /** Main computation method */ void GenerateData(void) ITK_OVERRIDE; /** Constructor */ ProfileToProfileDerivativeFilter(); /** Destructor */ ~ProfileToProfileDerivativeFilter() ITK_OVERRIDE {} /**PrintSelf method */ void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; private: ProfileToProfileDerivativeFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented /** Subtract filter for the dervivative */ SubtractFilterPointerType m_SubtractFilter; /** Abs filter for the derivative */ AbsFilterPointerType m_AbsFilter; }; } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbProfileToProfileDerivativeFilter.txx" #endif #endif otbProfileToProfileDerivativeFilter.txx000066400000000000000000000113301301006202600352170ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbProfileToProfileDerivativeFilter_txx #define otbProfileToProfileDerivativeFilter_txx #include "otbProfileToProfileDerivativeFilter.h" namespace otb { /** * Constructor */ template ProfileToProfileDerivativeFilter ::ProfileToProfileDerivativeFilter() { m_SubtractFilter = SubtractFilterType::New(); m_AbsFilter = AbsFilterType::New(); } /** Generate output information for the ImageList and for each image in the List. */ template void ProfileToProfileDerivativeFilter ::GenerateOutputInformation() { // Retrieving input/output pointers InputImageListPointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); if (outputPtr) { if (outputPtr->Size() != inputPtr->Size() - 1) { // in this case, clear the list outputPtr->Clear(); typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); ++inputListIt; while (inputListIt != inputPtr->End()) { outputPtr->PushBack(OutputImageType::New()); ++inputListIt; } } // For each input image typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); ++inputListIt; while (inputListIt != inputPtr->End() && outputListIt != outputPtr->End()) { // Create the output image and set its information outputListIt.Get()->CopyInformation(inputListIt.Get()); outputListIt.Get()->SetLargestPossibleRegion(inputListIt.Get()->GetLargestPossibleRegion()); ++inputListIt; ++outputListIt; } } } /** Generate input requested region for each image in the List. */ template void ProfileToProfileDerivativeFilter ::GenerateInputRequestedRegion() { // Retrieving input/output pointers InputImageListPointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); // For each input image and corresponding output image typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); // Use the filter to generate input requested region while (inputListIt != inputPtr->End() && outputListIt != outputPtr->End()) { inputListIt.Get()->SetRequestedRegion(outputListIt.Get()->GetRequestedRegion()); ++inputListIt; ++outputListIt; } } /** Main computation method */ template void ProfileToProfileDerivativeFilter ::GenerateData() { m_AbsFilter->SetInput(m_SubtractFilter->GetOutput()); // Retrieving input/output pointers InputImageListPointerType inputPtr = this->GetInput(); OutputImageListPointerType outputPtr = this->GetOutput(); // For each input image and corresponding output image typename InputImageListType::ConstIterator inputListIt = inputPtr->Begin(); typename OutputImageListType::Iterator outputListIt = outputPtr->Begin(); unsigned int counter = 0; InputImagePointerType lastImage = inputListIt.Get(); ++inputListIt; while (inputListIt != inputPtr->End() && outputListIt != outputPtr->End()) { m_SubtractFilter->SetInput1(inputListIt.Get()); m_SubtractFilter->SetInput2(lastImage); m_AbsFilter->GetOutput()->SetRequestedRegion(outputListIt.Get()->GetRequestedRegion()); m_AbsFilter->Update(); outputPtr->SetNthElement(counter, static_cast(m_AbsFilter->GetOutput())); outputListIt.Get()->DisconnectPipeline(); lastImage = inputListIt.Get(); ++inputListIt; ++outputListIt; ++counter; } } /** * PrintSelf Method */ template void ProfileToProfileDerivativeFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); } } // End namespace otb #endif OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/otb-module.cmake000066400000000000000000000005251301006202600270410ustar00rootroot00000000000000set(DOCUMENTATION "This module contains mono and multi-scale convex/concave image classification based on geodesic morphology characteristics.") otb_module(OTBMorphologicalProfiles DEPENDS OTBCommon OTBITK OTBImageBase OTBObjectList TEST_DEPENDS OTBImageIO OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/000077500000000000000000000000001301006202600247455ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/CMakeLists.txt000066400000000000000000000250551301006202600275140ustar00rootroot00000000000000otb_module_test() set(OTBMorphologicalProfilesTests otbMorphologicalProfilesTestDriver.cxx otbMorphologicalProfilesSegmentationFilter.cxx otbProfileToProfileDerivativeFilterNew.cxx otbGeodesicMorphologyDecompositionImageFilter.cxx otbMorphologicalClosingProfileFilterNew.cxx otbConvexOrConcaveClassificationFilter.cxx otbGeodesicMorphologyLevelingFilter.cxx otbConvexOrConcaveClassificationFilterNew.cxx otbMultiScaleConvexOrConcaveClassificationFilter.cxx otbMorphologicalOpeningProfileFilter.cxx otbGeodesicMorphologyIterativeDecompositionImageFilter.cxx otbGeodesicMorphologyIterativeDecompositionImageFilterNew.cxx otbGeodesicMorphologyLevelingFilterNew.cxx otbClosingOpeningMorphologicalFilter.cxx otbProfileDerivativeToMultiScaleCharacteristicsFilterNew.cxx otbProfileToProfileDerivativeFilter.cxx otbOpeningClosingMorphologicalFilterNew.cxx otbGeodesicMorphologyDecompositionImageFilterNew.cxx otbMorphologicalOpeningProfileFilterNew.cxx otbProfileDerivativeToMultiScaleCharacteristicsFilter.cxx otbMultiScaleConvexOrConcaveClassificationFilterNew.cxx otbClosingOpeningMorphologicalFilterNew.cxx otbOpeningClosingMorphologicalFilter.cxx otbMorphologicalClosingProfileFilter.cxx ) add_executable(otbMorphologicalProfilesTestDriver ${OTBMorphologicalProfilesTests}) target_link_libraries(otbMorphologicalProfilesTestDriver ${OTBMorphologicalProfiles-Test_LIBRARIES}) otb_module_target_label(otbMorphologicalProfilesTestDriver) # Tests Declaration otb_add_test(NAME obTvMorphologicalProfilesSegmentationFilter COMMAND otbMorphologicalProfilesTestDriver --compare-image ${NOTOL} ${BASELINE}/obTvMorphologicalProfilesSegmentationFilter.tif ${TEMP}/obTvMorphologicalProfilesSegmentationFilter.tif otbMorphologicalProfilesSegmentationFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/obTvMorphologicalProfilesSegmentationFilter.tif 1 1 5 ) otb_add_test(NAME msTuProfileToProfileDerivativeFilterNew COMMAND otbMorphologicalProfilesTestDriver otbProfileToProfileDerivativeFilterNew) otb_add_test(NAME msTvGeodesicMorphologyDecompositionImageFilter COMMAND otbMorphologicalProfilesTestDriver --compare-n-images ${NOTOL} 3 ${BASELINE}/msGeodesicMorphologyDecompositionImageFilterConvexOutput.tif ${TEMP}/msGeodesicMorphologyDecompositionImageFilterConvexOutput.tif ${BASELINE}/msGeodesicMorphologyDecompositionImageFilterConcaveOutput.tif ${TEMP}/msGeodesicMorphologyDecompositionImageFilterConcaveOutput.tif ${BASELINE}/msGeodesicMorphologyDecompositionImageFilterLevelingOutput.tif ${TEMP}/msGeodesicMorphologyDecompositionImageFilterLevelingOutput.tif otbGeodesicMorphologyDecompositionImageFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msGeodesicMorphologyDecompositionImageFilterConvexOutput.tif ${TEMP}/msGeodesicMorphologyDecompositionImageFilterConcaveOutput.tif ${TEMP}/msGeodesicMorphologyDecompositionImageFilterLevelingOutput.tif 4 ) otb_add_test(NAME msTuMorphologicalClosingProfileFilterNew COMMAND otbMorphologicalProfilesTestDriver otbMorphologicalClosingProfileFilterNew) otb_add_test(NAME msTvConvexOrConcaveClassificationFilter COMMAND otbMorphologicalProfilesTestDriver --compare-image ${NOTOL} ${BASELINE}/msConvexOrConcaveClassificationFilterOutput.png ${TEMP}/msConvexOrConcaveClassificationFilterOutput.png otbConvexOrConcaveClassificationFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles_leveling.tif ${TEMP}/msConvexOrConcaveClassificationFilterOutput.png 0.5 ) otb_add_test(NAME msTvGeodesicMorphologyLevelingFilter COMMAND otbMorphologicalProfilesTestDriver --compare-image ${NOTOL} ${BASELINE}/msGeodesicMorphologyLevelingFilterOutput.tif ${TEMP}/msGeodesicMorphologyLevelingFilterOutput.tif otbGeodesicMorphologyLevelingFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles_convex.tif ${INPUTDATA}/ROI_IKO_PAN_LesHalles_concave.tif ${TEMP}/msGeodesicMorphologyLevelingFilterOutput.tif ) otb_add_test(NAME msTuConvexOrConcaveClassificationFilterNew COMMAND otbMorphologicalProfilesTestDriver otbConvexOrConcaveClassificationFilterNew) otb_add_test(NAME msTvMultiScaleConvexOrConcaveClassificationFilter COMMAND otbMorphologicalProfilesTestDriver --compare-image ${NOTOL} ${BASELINE}/msMultiScaleConvexOrConcaveClassificationFilterOutput.tif ${TEMP}/msMultiScaleConvexOrConcaveClassificationFilterOutput.tif otbMultiScaleConvexOrConcaveClassificationFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msMultiScaleConvexOrConcaveClassificationFilterOutput.tif 5 1 1 1. ) otb_add_test(NAME msTvMorphologicalOpeningProfileFilter COMMAND otbMorphologicalProfilesTestDriver --compare-n-images ${NOTOL} 4 ${BASELINE}/msMorphologicalOpeningProfileFilterOutput1.tif ${TEMP}/msMorphologicalOpeningProfileFilterOutput1.tif ${BASELINE}/msMorphologicalOpeningProfileFilterOutput2.tif ${TEMP}/msMorphologicalOpeningProfileFilterOutput2.tif ${BASELINE}/msMorphologicalOpeningProfileFilterOutput3.tif ${TEMP}/msMorphologicalOpeningProfileFilterOutput3.tif ${BASELINE}/msMorphologicalOpeningProfileFilterOutput4.tif ${TEMP}/msMorphologicalOpeningProfileFilterOutput4.tif otbMorphologicalOpeningProfileFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msMorphologicalOpeningProfileFilterOutput tif 4 1 1 ) otb_add_test(NAME msTvGeodesicMorphologyIterativeDecompositionImageFilter COMMAND otbMorphologicalProfilesTestDriver --compare-n-images ${NOTOL} 6 ${BASELINE}/msGeodesicMorphologyIterativeDecompositionImageFilter_concMap_1.tif ${TEMP}/msGeodesicMorphologyIterativeDecompositionImageFilter_concMap_1.tif ${BASELINE}/msGeodesicMorphologyIterativeDecompositionImageFilter_concMap_2.tif ${TEMP}/msGeodesicMorphologyIterativeDecompositionImageFilter_concMap_2.tif ${BASELINE}/msGeodesicMorphologyIterativeDecompositionImageFilter_convMap_1.tif ${TEMP}/msGeodesicMorphologyIterativeDecompositionImageFilter_convMap_1.tif ${BASELINE}/msGeodesicMorphologyIterativeDecompositionImageFilter_convMap_2.tif ${TEMP}/msGeodesicMorphologyIterativeDecompositionImageFilter_convMap_2.tif ${BASELINE}/msGeodesicMorphologyIterativeDecompositionImageFilter_leveling_1.tif ${TEMP}/msGeodesicMorphologyIterativeDecompositionImageFilter_leveling_1.tif ${BASELINE}/msGeodesicMorphologyIterativeDecompositionImageFilter_leveling_2.tif ${TEMP}/msGeodesicMorphologyIterativeDecompositionImageFilter_leveling_2.tif otbGeodesicMorphologyIterativeDecompositionImageFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msGeodesicMorphologyIterativeDecompositionImageFilter tif 2 3 2 ) otb_add_test(NAME msTuGeodesicMorphologyIterativeDecompositionImageFilterNew COMMAND otbMorphologicalProfilesTestDriver otbGeodesicMorphologyIterativeDecompositionImageFilterNew) otb_add_test(NAME msTuGeodesicMorphologyLevelingFilterNew COMMAND otbMorphologicalProfilesTestDriver otbGeodesicMorphologyLevelingFilterNew) otb_add_test(NAME bfTvClosingOpeningFilter COMMAND otbMorphologicalProfilesTestDriver --compare-image ${NOTOL} ${BASELINE}/bfFiltreClosingOpening_1.tif ${TEMP}/bfFiltreClosingOpening_1.tif otbClosingOpeningMorphologicalFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/bfFiltreClosingOpening_1.tif 1) otb_add_test(NAME msTuProfileDerivativeToMultiScaleCharacteristicsFilterNew COMMAND otbMorphologicalProfilesTestDriver otbProfileDerivativeToMultiScaleCharacteristicsFilterNew) otb_add_test(NAME msTvProfileToProfileDerivativeFilter COMMAND otbMorphologicalProfilesTestDriver --compare-n-images ${NOTOL} 4 ${BASELINE}/msProfileToProfileDerivativeFilterOutput1.tif ${TEMP}/msProfileToProfileDerivativeFilterOutput1.tif ${BASELINE}/msProfileToProfileDerivativeFilterOutput2.tif ${TEMP}/msProfileToProfileDerivativeFilterOutput2.tif ${BASELINE}/msProfileToProfileDerivativeFilterOutput3.tif ${TEMP}/msProfileToProfileDerivativeFilterOutput3.tif ${BASELINE}/msProfileToProfileDerivativeFilterOutput4.tif ${TEMP}/msProfileToProfileDerivativeFilterOutput4.tif otbProfileToProfileDerivativeFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msProfileToProfileDerivativeFilterOutput tif 5 1 1 ) otb_add_test(NAME bfTuOpeningClosingFilterNew COMMAND otbMorphologicalProfilesTestDriver otbOpeningClosingMorphologicalFilterNew ) otb_add_test(NAME msTuGeodesicMorphologyDecompositionImageFilterNew COMMAND otbMorphologicalProfilesTestDriver otbGeodesicMorphologyDecompositionImageFilterNew) otb_add_test(NAME msTuMorphologicalOpeningProfileFilterNew COMMAND otbMorphologicalProfilesTestDriver otbMorphologicalOpeningProfileFilterNew) otb_add_test(NAME msTvProfileDerivativeToMultiScaleCharacteristicsFilter COMMAND otbMorphologicalProfilesTestDriver --compare-n-images ${NOTOL} 2 ${BASELINE}/msProfileDerivativeToMultiScaleCharacteristicsFilterOutput.tif ${TEMP}/msProfileDerivativeToMultiScaleCharacteristicsFilterOutput.tif ${BASELINE}/msProfileDerivativeToMultiScaleCharacteristicsFilterOutputCharacteristics.tif ${TEMP}/msProfileDerivativeToMultiScaleCharacteristicsFilterOutputCharacteristics.tif otbProfileDerivativeToMultiScaleCharacteristicsFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msProfileDerivativeToMultiScaleCharacteristicsFilterOutput.tif ${TEMP}/msProfileDerivativeToMultiScaleCharacteristicsFilterOutputCharacteristics.tif 5 1 1 ) otb_add_test(NAME msTuMultiScaleConvexOrConcaveClassificationFilterNew COMMAND otbMorphologicalProfilesTestDriver otbMultiScaleConvexOrConcaveClassificationFilterNew) otb_add_test(NAME bfTuClosingOpeningFilterNew COMMAND otbMorphologicalProfilesTestDriver otbClosingOpeningMorphologicalFilterNew ) otb_add_test(NAME bfTvOpeningClosingFilter COMMAND otbMorphologicalProfilesTestDriver --compare-image ${NOTOL} ${BASELINE}/bfFiltreOpeningClosing_1.tif ${TEMP}/bfFiltreOpeningClosing_1.tif otbOpeningClosingMorphologicalFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/bfFiltreOpeningClosing_1.tif 1) otb_add_test(NAME msTvMorphologicalClosingProfileFilter COMMAND otbMorphologicalProfilesTestDriver --compare-n-images ${NOTOL} 4 ${BASELINE}/msMorphologicalClosingProfileFilterOutput1.tif ${TEMP}/msMorphologicalClosingProfileFilterOutput1.tif ${BASELINE}/msMorphologicalClosingProfileFilterOutput2.tif ${TEMP}/msMorphologicalClosingProfileFilterOutput2.tif ${BASELINE}/msMorphologicalClosingProfileFilterOutput3.tif ${TEMP}/msMorphologicalClosingProfileFilterOutput3.tif ${BASELINE}/msMorphologicalClosingProfileFilterOutput4.tif ${TEMP}/msMorphologicalClosingProfileFilterOutput4.tif otbMorphologicalClosingProfileFilter ${INPUTDATA}/ROI_IKO_PAN_LesHalles.tif ${TEMP}/msMorphologicalClosingProfileFilterOutput tif 4 1 1 ) otbClosingOpeningMorphologicalFilter.cxx000066400000000000000000000043161301006202600347270ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbClosingOpeningMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbClosingOpeningMorphologicalFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const unsigned int Radius = atoi(argv[3]); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::ClosingOpeningMorphologicalFilter ClosingOpeningFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Creating Kernel StructuringElementType structElt; structElt.SetRadius(Radius); structElt.CreateStructuringElement(); // Instantiating the opening closing filter ClosingOpeningFilterType::Pointer openingClosing = ClosingOpeningFilterType::New(); openingClosing->SetInput(reader->GetOutput()); openingClosing->SetKernel(structElt); // Write the result to file WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(openingClosing->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbClosingOpeningMorphologicalFilterNew.cxx000066400000000000000000000031211301006202600353720ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbClosingOpeningMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImage.h" int otbClosingOpeningMorphologicalFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::ClosingOpeningMorphologicalFilter ClosingOpeningFilterType; // instantiating the opening closing filter ClosingOpeningFilterType::Pointer openingClosing = ClosingOpeningFilterType::New(); std::cout << openingClosing << std::endl; return EXIT_SUCCESS; } otbConvexOrConcaveClassificationFilter.cxx000066400000000000000000000040171301006202600352050ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbConvexOrConcaveClassificationFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbConvexOrConcaveClassificationFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * levelingfname = argv[2]; const char * outfname = argv[3]; const double sigma = atof(argv[4]); typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ConvexOrConcaveClassificationFilter ClassificationFilterType; // Instantiating objects ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); ReaderType::Pointer levelingReader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); reader->SetFileName(infname); levelingReader->SetFileName(levelingfname); filter->SetInput(reader->GetOutput()); filter->SetInputLeveling(levelingReader->GetOutput()); filter->SetConvexLabel(255); filter->SetConcaveLabel(128); filter->SetFlatLabel(0); filter->SetSigma(sigma); writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbConvexOrConcaveClassificationFilterNew.cxx000066400000000000000000000021511301006202600356540ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbConvexOrConcaveClassificationFilter.h" #include "otbImage.h" int otbConvexOrConcaveClassificationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ConvexOrConcaveClassificationFilter ClassificationFilterType; // Instantiating object ClassificationFilterType::Pointer filter = ClassificationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbGeodesicMorphologyDecompositionImageFilter.cxx000066400000000000000000000047231301006202600365750ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeodesicMorphologyDecompositionImageFilter.h" #include "otbGeodesicMorphologyDecompositionImageFilter.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkBinaryBallStructuringElement.h" int otbGeodesicMorphologyDecompositionImageFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * convexfname = argv[2]; const char * concavefname = argv[3]; const char * levelingfname = argv[4]; const unsigned int sesize = atoi(argv[5]); typedef otb::Image ImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef StructuringElementType::RadiusType RadiusType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::GeodesicMorphologyDecompositionImageFilter GeodesicMorphologyDecompositionImageFilterType; // Instantiating object GeodesicMorphologyDecompositionImageFilterType::Pointer filter = GeodesicMorphologyDecompositionImageFilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(infname); filter->SetInput(reader->GetOutput()); RadiusType radius; radius.Fill(sesize); filter->SetRadius(radius); // writer the leveling map WriterType::Pointer writer = WriterType::New(); writer->SetFileName(levelingfname); writer->SetInput(filter->GetOutput()); writer->Update(); // write the convex map writer = WriterType::New(); writer->SetFileName(convexfname); writer->SetInput(filter->GetConvexMap()); writer->Update(); // write the concave map writer = WriterType::New(); writer->SetFileName(concavefname); writer->SetInput(filter->GetConcaveMap()); writer->Update(); return EXIT_SUCCESS; } otbGeodesicMorphologyDecompositionImageFilterNew.cxx000066400000000000000000000025031301006202600372410ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeodesicMorphologyDecompositionImageFilter.h" #include "otbImage.h" #include "itkBinaryBallStructuringElement.h" int otbGeodesicMorphologyDecompositionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::GeodesicMorphologyDecompositionImageFilter GeodesicMorphologyDecompositionImageFilterType; // Instantiating object GeodesicMorphologyDecompositionImageFilterType::Pointer filter = GeodesicMorphologyDecompositionImageFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbGeodesicMorphologyIterativeDecompositionImageFilter.cxx000066400000000000000000000071011301006202600404430ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeodesicMorphologyIterativeDecompositionImageFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbGeodesicMorphologyIterativeDecompositionImageFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; const unsigned int numberOfLevels = atoi(argv[4]); const unsigned int step = atoi(argv[5]); const unsigned int initValue = atoi(argv[6]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::Image InputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::GeodesicMorphologyIterativeDecompositionImageFilter DecompositionImageFilterType; typedef DecompositionImageFilterType::OutputImageListType::Iterator ImageListIterator; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Instantiation DecompositionImageFilterType::Pointer decomposition = DecompositionImageFilterType::New(); decomposition->SetNumberOfIterations(numberOfLevels); decomposition->SetStep(step); decomposition->SetInitialValue(initValue); decomposition->SetInput(reader->GetOutput()); decomposition->Update(); // Retrieving iterators on the results images ImageListIterator itAnalyse = decomposition->GetOutput()->Begin(); ImageListIterator itConvexMap = decomposition->GetConvexOutput()->Begin(); ImageListIterator itConcaveMap = decomposition->GetConcaveOutput()->Begin(); WriterType::Pointer writer; int i = 1; std::ostringstream oss; // Writing the results images while ((itAnalyse != decomposition->GetOutput()->End()) && (itConvexMap != decomposition->GetConvexOutput()->End()) && (itConcaveMap != decomposition->GetConcaveOutput()->End()) ) { oss << outputFilenamePrefix << "_leveling_" << i << "." << outputFilenameSuffix; writer = WriterType::New(); writer->SetInput(itAnalyse.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); oss << outputFilenamePrefix << "_convMap_" << i << "." << outputFilenameSuffix; writer = WriterType::New(); writer->SetInput(itConvexMap.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); oss << outputFilenamePrefix << "_concMap_" << i << "." << outputFilenameSuffix; writer = WriterType::New(); writer->SetInput(itConcaveMap.Get()); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); ++itAnalyse; ++itConvexMap; ++itConcaveMap; ++i; } return EXIT_SUCCESS; } otbGeodesicMorphologyIterativeDecompositionImageFilterNew.cxx000066400000000000000000000026161301006202600411230ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeodesicMorphologyIterativeDecompositionImageFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImage.h" #include "itkMacro.h" int otbGeodesicMorphologyIterativeDecompositionImageFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::Image InputImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::GeodesicMorphologyIterativeDecompositionImageFilter DecompositionFilterType; // Instantiation DecompositionFilterType::Pointer decomposition = DecompositionFilterType::New(); std::cout << decomposition << std::endl; return EXIT_SUCCESS; } otbGeodesicMorphologyLevelingFilter.cxx000066400000000000000000000036301301006202600345570ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeodesicMorphologyLevelingFilter.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbGeodesicMorphologyLevelingFilter(int itkNotUsed(argc), char * argv[]) { const char * infname = argv[1]; const char * inconvfname = argv[2]; const char * inconcfname = argv[3]; const char * outfname = argv[4]; typedef otb::Image ImageType; typedef otb::GeodesicMorphologyLevelingFilter FilterType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; ReaderType::Pointer convreader, concreader, reader; reader = ReaderType::New(); convreader = ReaderType::New(); concreader = ReaderType::New(); reader->SetFileName(infname); convreader->SetFileName(inconvfname); concreader->SetFileName(inconcfname); FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); filter->SetInputConvexMap(convreader->GetOutput()); filter->SetInputConcaveMap(concreader->GetOutput()); WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(filter->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbGeodesicMorphologyLevelingFilterNew.cxx000066400000000000000000000020101301006202600352200ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGeodesicMorphologyLevelingFilter.h" #include "otbImage.h" int otbGeodesicMorphologyLevelingFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { typedef otb::Image ImageType; typedef otb::GeodesicMorphologyLevelingFilter FilterType; FilterType::Pointer filter = FilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbMorphologicalClosingProfileFilter.cxx000066400000000000000000000051011301006202600347210ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalClosingProfileFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkMacro.h" int otbMorphologicalClosingProfileFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; const unsigned int profileSize = atoi(argv[4]); const unsigned int initialValue = atoi(argv[5]); const unsigned int step = atoi(argv[5]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::MorphologicalClosingProfileFilter ClosingProfileFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Instantiation ClosingProfileFilterType::Pointer profileFilter = ClosingProfileFilterType::New(); profileFilter->SetInput(reader->GetOutput()); profileFilter->SetProfileSize(profileSize); profileFilter->SetInitialValue(initialValue); profileFilter->SetStep(step); profileFilter->Update(); WriterType::Pointer writer; // std::stringstream oss; std::ostringstream oss; // Writing the results images for (unsigned int i = 1; i <= profileSize; ++i) { writer = WriterType::New(); oss << outputFilenamePrefix << i << "." << outputFilenameSuffix; writer->SetInput(profileFilter->GetOutput()->GetNthElement(i - 1)); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); } return EXIT_SUCCESS; } otbMorphologicalClosingProfileFilterNew.cxx000066400000000000000000000024571301006202600354060ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalClosingProfileFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImage.h" #include "itkMacro.h" int otbMorphologicalClosingProfileFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::Image InputImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::MorphologicalClosingProfileFilter ClosingProfileFilterType; // Instantiation ClosingProfileFilterType::Pointer filter = ClosingProfileFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbMorphologicalOpeningProfileFilter.cxx000066400000000000000000000051011301006202600347220ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalOpeningProfileFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkMacro.h" int otbMorphologicalOpeningProfileFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; const unsigned int profileSize = atoi(argv[4]); const unsigned int initialValue = atoi(argv[5]); const unsigned int step = atoi(argv[6]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::MorphologicalOpeningProfileFilter OpeningProfileFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Instantiation OpeningProfileFilterType::Pointer profileFilter = OpeningProfileFilterType::New(); profileFilter->SetInput(reader->GetOutput()); profileFilter->SetProfileSize(profileSize); profileFilter->SetInitialValue(initialValue); profileFilter->SetStep(step); profileFilter->Update(); WriterType::Pointer writer; // std::stringstream oss; std::ostringstream oss; // Writing the results images for (unsigned int i = 1; i <= profileSize; ++i) { writer = WriterType::New(); oss << outputFilenamePrefix << i << "." << outputFilenameSuffix; writer->SetInput(profileFilter->GetOutput()->GetNthElement(i - 1)); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); } return EXIT_SUCCESS; } otbMorphologicalOpeningProfileFilterNew.cxx000066400000000000000000000024601301006202600354010ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalOpeningProfileFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImage.h" #include "itkMacro.h" int otbMorphologicalOpeningProfileFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef otb::Image InputImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::MorphologicalOpeningProfileFilter OpeningProfileFilterType; // Instantiation OpeningProfileFilterType::Pointer filter = OpeningProfileFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbMorphologicalProfilesSegmentationFilter.cxx000066400000000000000000000044771301006202600361620ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalProfilesSegmentationFilter.h" #include "itkMacro.h" #include "otbVectorImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" int otbMorphologicalProfilesSegmentationFilter(int argc, char * argv[]) { if (argc != 6 ) { std::cerr << "Usage: " << argv[0] << " inputFileName outputFileName start step size" << std::endl; return EXIT_FAILURE; } const char * inputFileName = argv[1]; const char * outputFileName = argv[2]; const unsigned int start = atoi(argv[3]); const unsigned int step = atoi(argv[4]); const unsigned int size = atoi(argv[5]); const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image ImageType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter LabelWriterType; typedef otb::MorphologicalProfilesSegmentationFilter FilterType; // Instantiating object FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); // Set filter parameters filter->SetProfileStart(start); filter->SetProfileSize(size); filter->SetProfileStep(step); filter->SetInput(reader->GetOutput()); //filter->SetNumberOfThreads(1); LabelWriterType::Pointer writerLabel = LabelWriterType::New(); writerLabel->SetFileName(outputFileName); writerLabel->SetInput(filter->GetOutput()); writerLabel->Update(); return EXIT_SUCCESS; } otbMorphologicalProfilesTestDriver.cxx000066400000000000000000000026721301006202600344450ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbMorphologicalProfilesSegmentationFilter); REGISTER_TEST(otbProfileToProfileDerivativeFilterNew); REGISTER_TEST(otbGeodesicMorphologyDecompositionImageFilter); REGISTER_TEST(otbMorphologicalClosingProfileFilterNew); REGISTER_TEST(otbConvexOrConcaveClassificationFilter); REGISTER_TEST(otbGeodesicMorphologyLevelingFilter); REGISTER_TEST(otbConvexOrConcaveClassificationFilterNew); REGISTER_TEST(otbMultiScaleConvexOrConcaveClassificationFilter); REGISTER_TEST(otbMorphologicalOpeningProfileFilter); REGISTER_TEST(otbGeodesicMorphologyIterativeDecompositionImageFilter); REGISTER_TEST(otbGeodesicMorphologyIterativeDecompositionImageFilterNew); REGISTER_TEST(otbGeodesicMorphologyLevelingFilterNew); REGISTER_TEST(otbClosingOpeningMorphologicalFilter); REGISTER_TEST(otbProfileDerivativeToMultiScaleCharacteristicsFilterNew); REGISTER_TEST(otbProfileToProfileDerivativeFilter); REGISTER_TEST(otbOpeningClosingMorphologicalFilterNew); REGISTER_TEST(otbGeodesicMorphologyDecompositionImageFilterNew); REGISTER_TEST(otbMorphologicalOpeningProfileFilterNew); REGISTER_TEST(otbProfileDerivativeToMultiScaleCharacteristicsFilter); REGISTER_TEST(otbMultiScaleConvexOrConcaveClassificationFilterNew); REGISTER_TEST(otbClosingOpeningMorphologicalFilterNew); REGISTER_TEST(otbOpeningClosingMorphologicalFilter); REGISTER_TEST(otbMorphologicalClosingProfileFilter); } otbMultiScaleConvexOrConcaveClassificationFilter.cxx000066400000000000000000000114611301006202600371710ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalOpeningProfileFilter.h" #include "otbMorphologicalClosingProfileFilter.h" #include "otbProfileToProfileDerivativeFilter.h" #include "otbProfileDerivativeToMultiScaleCharacteristicsFilter.h" #include "otbMultiScaleConvexOrConcaveClassificationFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkMacro.h" int otbMultiScaleConvexOrConcaveClassificationFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; const unsigned int profileSize = atoi(argv[3]); const unsigned int initialValue = atoi(argv[4]); const unsigned int step = atoi(argv[5]); const double sigma = atof(argv[6]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef unsigned short LabeledPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter LabeledWriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::MorphologicalOpeningProfileFilter OpeningProfileFilterType; typedef otb::MorphologicalClosingProfileFilter ClosingProfileFilterType; typedef otb::ProfileToProfileDerivativeFilter DerivativeFilterType; typedef otb::ProfileDerivativeToMultiScaleCharacteristicsFilter MultiScaleCharacteristicsFilterType; typedef otb::MultiScaleConvexOrConcaveClassificationFilter MultiScaleClassificationFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Instantiation OpeningProfileFilterType::Pointer oprofileFilter = OpeningProfileFilterType::New(); oprofileFilter->SetInput(reader->GetOutput()); oprofileFilter->SetProfileSize(profileSize); oprofileFilter->SetInitialValue(initialValue); oprofileFilter->SetStep(step); ClosingProfileFilterType::Pointer cprofileFilter = ClosingProfileFilterType::New(); cprofileFilter->SetInput(reader->GetOutput()); cprofileFilter->SetProfileSize(profileSize); cprofileFilter->SetInitialValue(initialValue); cprofileFilter->SetStep(step); DerivativeFilterType::Pointer oderivativeFilter = DerivativeFilterType::New(); oderivativeFilter->SetInput(oprofileFilter->GetOutput()); DerivativeFilterType::Pointer cderivativeFilter = DerivativeFilterType::New(); cderivativeFilter->SetInput(cprofileFilter->GetOutput()); MultiScaleCharacteristicsFilterType::Pointer omsCharFilter = MultiScaleCharacteristicsFilterType::New(); omsCharFilter->SetInput(oderivativeFilter->GetOutput()); omsCharFilter->SetInitialValue(initialValue); omsCharFilter->SetStep(step); MultiScaleCharacteristicsFilterType::Pointer cmsCharFilter = MultiScaleCharacteristicsFilterType::New(); cmsCharFilter->SetInput(cderivativeFilter->GetOutput()); cmsCharFilter->SetInitialValue(initialValue); cmsCharFilter->SetStep(step); MultiScaleClassificationFilterType::Pointer classificationFilter = MultiScaleClassificationFilterType::New(); classificationFilter->SetOpeningProfileDerivativeMaxima(omsCharFilter->GetOutput()); classificationFilter->SetOpeningProfileCharacteristics(omsCharFilter->GetOutputCharacteristics()); classificationFilter->SetClosingProfileDerivativeMaxima(cmsCharFilter->GetOutput()); classificationFilter->SetClosingProfileCharacteristics(cmsCharFilter->GetOutputCharacteristics()); classificationFilter->SetSigma(sigma); classificationFilter->SetLabelSeparator(initialValue + profileSize * step); LabeledWriterType::Pointer labeledWriter = LabeledWriterType::New(); labeledWriter->SetFileName(outputFilename); labeledWriter->SetInput(classificationFilter->GetOutput()); labeledWriter->Update(); return EXIT_SUCCESS; } otbMultiScaleConvexOrConcaveClassificationFilterNew.cxx000066400000000000000000000026361301006202600376470ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkUnaryFunctorImageFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbMultiScaleConvexOrConcaveClassificationFilter.h" #include "otbImage.h" #include "itkMacro.h" int otbMultiScaleConvexOrConcaveClassificationFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef unsigned short LabeledPixelType; typedef otb::Image InputImageType; typedef otb::Image LabeledImageType; typedef otb::MultiScaleConvexOrConcaveClassificationFilter MultiScaleClassificationFilterType; // Instantiation MultiScaleClassificationFilterType::Pointer filter = MultiScaleClassificationFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbOpeningClosingMorphologicalFilter.cxx000066400000000000000000000043161301006202600347270ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" int otbOpeningClosingMorphologicalFilter(int itkNotUsed(argc), char * argv[]) { const unsigned int Dimension = 2; const unsigned int Radius = atoi(argv[3]); const char * inputFilename = argv[1]; const char * outputFilename = argv[2]; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Creating Kernel StructuringElementType structElt; structElt.SetRadius(Radius); structElt.CreateStructuringElement(); // Instantiating the opening closing filter OpeningClosingFilterType::Pointer openingClosing = OpeningClosingFilterType::New(); openingClosing->SetInput(reader->GetOutput()); openingClosing->SetKernel(structElt); // Write the result to file WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); writer->SetInput(openingClosing->GetOutput()); writer->Update(); return EXIT_SUCCESS; } otbOpeningClosingMorphologicalFilterNew.cxx000066400000000000000000000031211301006202600353720ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkMacro.h" #include "otbOpeningClosingMorphologicalFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImage.h" int otbOpeningClosingMorphologicalFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef unsigned char InputPixelType; typedef unsigned char OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::OpeningClosingMorphologicalFilter OpeningClosingFilterType; // instantiating the opening closing filter OpeningClosingFilterType::Pointer openingClosing = OpeningClosingFilterType::New(); std::cout << openingClosing << std::endl; return EXIT_SUCCESS; } otbProfileDerivativeToMultiScaleCharacteristicsFilter.cxx000066400000000000000000000066541301006202600402450ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalOpeningProfileFilter.h" #include "otbProfileToProfileDerivativeFilter.h" #include "otbProfileDerivativeToMultiScaleCharacteristicsFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkMacro.h" int otbProfileDerivativeToMultiScaleCharacteristicsFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilename1 = argv[2]; const char * outputFilename2 = argv[3]; const unsigned int profileSize = atoi(argv[4]); const unsigned int initialValue = atoi(argv[5]); const unsigned int step = atoi(argv[6]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef unsigned short LabeledPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image LabeledImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef otb::ImageFileWriter LabeledWriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::MorphologicalOpeningProfileFilter OpeningProfileFilterType; typedef otb::ProfileToProfileDerivativeFilter DerivativeFilterType; typedef otb::ProfileDerivativeToMultiScaleCharacteristicsFilter MultiScaleCharacteristicsFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Instantiation OpeningProfileFilterType::Pointer profileFilter = OpeningProfileFilterType::New(); profileFilter->SetInput(reader->GetOutput()); profileFilter->SetProfileSize(profileSize); profileFilter->SetInitialValue(initialValue); profileFilter->SetStep(step); DerivativeFilterType::Pointer derivativeFilter = DerivativeFilterType::New(); derivativeFilter->SetInput(profileFilter->GetOutput()); MultiScaleCharacteristicsFilterType::Pointer msCharFilter = MultiScaleCharacteristicsFilterType::New(); msCharFilter->SetInput(derivativeFilter->GetOutput()); msCharFilter->SetInitialValue(initialValue); msCharFilter->SetStep(step); WriterType::Pointer writer = WriterType::New(); LabeledWriterType::Pointer labeledWriter = LabeledWriterType::New(); writer->SetFileName(outputFilename1); writer->SetInput(msCharFilter->GetOutput()); writer->Update(); labeledWriter->SetFileName(outputFilename2); labeledWriter->SetInput(msCharFilter->GetOutputCharacteristics()); labeledWriter->Update(); return EXIT_SUCCESS; } otbProfileDerivativeToMultiScaleCharacteristicsFilterNew.cxx000066400000000000000000000027011301006202600407040ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbProfileDerivativeToMultiScaleCharacteristicsFilter.h" #include "otbImage.h" #include "itkMacro.h" int otbProfileDerivativeToMultiScaleCharacteristicsFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef unsigned short LabeledPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::Image LabeledImageType; typedef otb::ProfileDerivativeToMultiScaleCharacteristicsFilter MultiScaleCharacteristicsFilterType; MultiScaleCharacteristicsFilterType::Pointer filter = MultiScaleCharacteristicsFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } otbProfileToProfileDerivativeFilter.cxx000066400000000000000000000055501301006202600345410ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbMorphologicalOpeningProfileFilter.h" #include "otbProfileToProfileDerivativeFilter.h" #include "itkBinaryBallStructuringElement.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "otbImage.h" #include "itkMacro.h" int otbProfileToProfileDerivativeFilter(int itkNotUsed(argc), char * argv[]) { const char * inputFilename = argv[1]; const char * outputFilenamePrefix = argv[2]; const char * outputFilenameSuffix = argv[3]; const unsigned int profileSize = atoi(argv[4]); const unsigned int initialValue = atoi(argv[5]); const unsigned int step = atoi(argv[5]); const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter WriterType; typedef itk::BinaryBallStructuringElement StructuringElementType; typedef otb::MorphologicalOpeningProfileFilter OpeningProfileFilterType; typedef otb::ProfileToProfileDerivativeFilter DerivativeFilterType; // Reading input image ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // Instantiation OpeningProfileFilterType::Pointer profileFilter = OpeningProfileFilterType::New(); profileFilter->SetInput(reader->GetOutput()); profileFilter->SetProfileSize(profileSize); profileFilter->SetInitialValue(initialValue); profileFilter->SetStep(step); DerivativeFilterType::Pointer derivativeFilter = DerivativeFilterType::New(); derivativeFilter->SetInput(profileFilter->GetOutput()); derivativeFilter->Update(); WriterType::Pointer writer; // std::stringstream oss; std::ostringstream oss; // Writing the results images for (unsigned int i = 1; i < profileSize; ++i) { writer = WriterType::New(); oss << outputFilenamePrefix << i << "." << outputFilenameSuffix; writer->SetInput(derivativeFilter->GetOutput()->GetNthElement(i - 1)); writer->SetFileName(oss.str().c_str()); writer->Update(); oss.str(""); } return EXIT_SUCCESS; } otbProfileToProfileDerivativeFilterNew.cxx000066400000000000000000000024141301006202600352070ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/MorphologicalProfiles/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbProfileToProfileDerivativeFilter.h" #include "otbImage.h" #include "itkMacro.h" int otbProfileToProfileDerivativeFilterNew(int itkNotUsed(argc), char * itkNotUsed(argv) []) { const unsigned int Dimension = 2; typedef double InputPixelType; typedef double OutputPixelType; typedef otb::Image InputImageType; typedef otb::Image OutputImageType; typedef otb::ProfileToProfileDerivativeFilter DerivativeFilterType; DerivativeFilterType::Pointer filter = DerivativeFilterType::New(); std::cout << filter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/OGRProcessing/000077500000000000000000000000001301006202600221475ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/OGRProcessing/CMakeLists.txt000066400000000000000000000000541301006202600247060ustar00rootroot00000000000000project(OTBOGRProcessing) otb_module_impl() OTB-release-5.8/Modules/Segmentation/OGRProcessing/include/000077500000000000000000000000001301006202600235725ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/OGRProcessing/include/otbOGRLayerStreamStitchingFilter.h000066400000000000000000000123551301006202600323010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRLayerStreamStitchingFilter_h #define otbOGRLayerStreamStitchingFilter_h #include "otbOGRDataSourceWrapper.h" #include "otbMacro.h" //#if(GDAL_VERSION_NUM < 1800) //#error OGRLayerStreamStitchingFilter requires GDAL version >= 1.8.0 //#endif #include "itkProgressReporter.h" #include namespace otb { /** \class OGRLayerStreamStitchingFilter * \brief This filter fusion the geometries in a layer (\c OGRLayer) along streaming lines. * It is a in-line filter which means that the result of the fusion overwrites the input layer. * The strategy for merging polygons is quite simple. A polygon P1 is merge with a polygon P2 if: * - P1 and P2 are on different side of the streaming line * - P1 and P2 intersect each other. * - P2 has the largest intersection with P1 among all other polygons Pi intersecting P1. * The \c SetStreamSize() method allows retrieving the number of streams in row and column, * and their pixel coordinates. * The input image is used to transform pixel coordinates of the streaming lines into * coordinate system of the image, which must be the same as the one in the OGR input file. * This filter is intended to be used after \c StreamingVectorizedSegmentationOGR. * @see Example/StreamingMeanShiftSegmentation.cxx * * \ingroup OBIA * * * * \ingroup OTBOGRProcessing */ template class ITK_EXPORT OGRLayerStreamStitchingFilter : public itk::ProcessObject { public: /** typedef for the classes standards. */ typedef OGRLayerStreamStitchingFilter Self; typedef itk::ProcessObject Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Definition of the input image */ typedef TInputImage InputImageType; typedef typename InputImageType::PixelType InputPixelType; typedef typename InputImageType::IndexType InputIndexType; typedef typename InputImageType::SizeType SizeType; typedef typename InputImageType::RegionType RegionType; typedef typename InputImageType::SpacingType SpacingType; typedef typename InputImageType::PointType OriginType; typedef typename InputImageType::IndexType IndexType; typedef ogr::Layer OGRLayerType; typedef ogr::Feature OGRFeatureType; /** Set the input image of this process object. */ using Superclass::SetInput; virtual void SetInput(const InputImageType *input); /** Get the input image. */ virtual const InputImageType * GetInput(void); /** Method for management of the object factory. */ itkNewMacro(Self); /** Return the name of the class. */ itkTypeMacro(OGRLayerStreamStitchingFilter, ProcessObject); /** Set the input OGRLayer */ void SetOGRLayer( const OGRLayerType & ogrLayer ); /** Get the input OGRLayer */ const OGRLayerType & GetOGRLayer( void ) const; /** Set the stream size. * As this filter is intended to be used right after the \c StreamingVectorizedSegmentation, * use the \c GetStreamSize() method on it to get the correct stream size. */ itkSetMacro(StreamSize, SizeType); /** Get stream size*/ itkGetMacro(StreamSize, SizeType); /** Generate Data method. This method must be called explicitly (not through the \c Update method). */ void GenerateData() ITK_OVERRIDE; protected: OGRLayerStreamStitchingFilter(); ~OGRLayerStreamStitchingFilter() ITK_OVERRIDE {} struct FusionStruct { unsigned int indStream1; unsigned int indStream2; double overlap; }; struct FeatureStruct { FeatureStruct(OGRFeatureDefn & defn) : feat(defn), fusioned(false) { } OGRFeatureType feat; bool fusioned; }; struct SortFeatureStruct { bool operator() (FusionStruct f1, FusionStruct f2) { return (f1.overlap > f2.overlap); } } SortFeature; /** Main computation method. if line is true process row part, else process column part. */ void ProcessStreamingLine(bool line, itk::ProgressReporter &progress); /** get length in case of OGRGeometryCollection. * This function recodes the get_lenght method available since gdal 1.8.0 * in the case of OGRGeometryCollection. The aim is to allow accessing polygon stiching * functionalities with gdal 1.6. */ double GetLengthOGRGeometryCollection(OGRGeometryCollection * intersection); private: OGRLayerStreamStitchingFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented SizeType m_StreamSize; unsigned int m_Radius; OGRLayerType m_OGRLayer; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbOGRLayerStreamStitchingFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/OGRProcessing/include/otbOGRLayerStreamStitchingFilter.txx000066400000000000000000000350601301006202600326730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbOGRLayerStreamStitchingFilter_txx #define otbOGRLayerStreamStitchingFilter_txx #include "otbOGRLayerStreamStitchingFilter.h" #include "itkContinuousIndex.h" #include #include "ogrsf_frmts.h" #include "itkTimeProbe.h" #include namespace otb { template OGRLayerStreamStitchingFilter ::OGRLayerStreamStitchingFilter() : m_Radius(2), m_OGRLayer(ITK_NULLPTR, false) { m_StreamSize.Fill(0); } template void OGRLayerStreamStitchingFilter ::SetInput(const InputImageType *input) { this->Superclass::SetNthInput(0, const_cast(input)); } template const typename OGRLayerStreamStitchingFilter ::InputImageType * OGRLayerStreamStitchingFilter ::GetInput(void) { if (this->GetNumberOfInputs() < 1) { return ITK_NULLPTR; } return static_cast(this->Superclass::GetInput(0)); } template void OGRLayerStreamStitchingFilter ::SetOGRLayer( const OGRLayerType& ogrLayer ) { m_OGRLayer = ogrLayer; this->Modified(); } template const typename OGRLayerStreamStitchingFilter::OGRLayerType & OGRLayerStreamStitchingFilter ::GetOGRLayer( void ) const { return m_OGRLayer; } template double OGRLayerStreamStitchingFilter ::GetLengthOGRGeometryCollection( OGRGeometryCollection * intersection ) { double dfLength = 0.0; for( int iGeom = 0; iGeom < intersection->getNumGeometries(); iGeom++ ) { OGRGeometry* geom = intersection->getGeometryRef(iGeom); switch( wkbFlatten(geom->getGeometryType()) ) { case wkbLinearRing: case wkbLineString: dfLength += ((OGRCurve *) geom)->get_Length(); break; case wkbGeometryCollection: dfLength += GetLengthOGRGeometryCollection(dynamic_cast (geom)); break; default: break; } } return dfLength; } template void OGRLayerStreamStitchingFilter ::ProcessStreamingLine( bool line, itk::ProgressReporter & progress) { typename InputImageType::ConstPointer inputImage = this->GetInput(); //compute the number of stream division in row and column SizeType imageSize = this->GetInput()->GetLargestPossibleRegion().GetSize(); unsigned int nbRowStream = static_cast(imageSize[1] / m_StreamSize[1] + 1); unsigned int nbColStream = static_cast(imageSize[0] / m_StreamSize[0] + 1); /*unsigned long startReporter; unsigned long stopReporter; if (!line) { startReporter = 0; stopReporter = 50; } else { startReporter = 50; stopReporter = 100; } itk::ProgressReporter progress(this,0,2*nbRowStream*nbColStream,100,startReporter); */ for(unsigned int x=1; x<=nbColStream; x++) { OGRErr errStart = m_OGRLayer.ogr().StartTransaction(); if (errStart != OGRERR_NONE) { itkExceptionMacro(<< "Unable to start transaction for OGR layer " << m_OGRLayer.ogr().GetName() << "."); } for(unsigned int y=1; y<=nbRowStream; y++) { //Compute Stream line OGRLineString streamLine; itk::ContinuousIndex startIndex; itk::ContinuousIndex endIndex; if(!line) { // Treat vertical stream line startIndex[0] = static_cast(m_StreamSize[0] * x) - 0.5; startIndex[1] = static_cast(m_StreamSize[1] * (y-1)) - 0.5; endIndex = startIndex; endIndex[1] += static_cast(m_StreamSize[1]); } else { // Treat horizontal stream line startIndex[0] = static_cast(m_StreamSize[0] * (x-1)) - 0.5; startIndex[1] = static_cast(m_StreamSize[1] * y) - 0.5; endIndex = startIndex; endIndex[0] += static_cast(m_StreamSize[0]); } OriginType startPoint; inputImage->TransformContinuousIndexToPhysicalPoint(startIndex, startPoint); OriginType endPoint; inputImage->TransformContinuousIndexToPhysicalPoint(endIndex, endPoint); streamLine.addPoint(startPoint[0], startPoint[1]); streamLine.addPoint(endPoint[0], endPoint[1]); //First we get all the feature that intersect the streaming line of the Upper/left stream std::vector upperStreamFeatureList; upperStreamFeatureList.clear(); IndexType UpperLeftCorner; IndexType LowerRightCorner; if(!line) { // Treat Row stream //Compute the spatial filter of the upper stream UpperLeftCorner[0] = x*m_StreamSize[0] - 1 - m_Radius; UpperLeftCorner[1] = m_StreamSize[1]*(y-1); LowerRightCorner[0] = m_StreamSize[0]*x - 1; LowerRightCorner[1] = m_StreamSize[1]*y - 1; } else { // Treat Column stream //Compute the spatial filter of the left stream UpperLeftCorner[0] = (x-1)*m_StreamSize[0]; UpperLeftCorner[1] = m_StreamSize[1]*y - 1 - m_Radius; LowerRightCorner[0] = m_StreamSize[0]*x - 1; LowerRightCorner[1] = m_StreamSize[1]*y - 1; //-1 to stop just before stream line } OriginType ulCorner; inputImage->TransformIndexToPhysicalPoint(UpperLeftCorner, ulCorner); OriginType lrCorner; inputImage->TransformIndexToPhysicalPoint(LowerRightCorner, lrCorner); m_OGRLayer.SetSpatialFilterRect(ulCorner[0],lrCorner[1],lrCorner[0],ulCorner[1]); std::set upperFIDs; OGRLayerType::const_iterator featIt = m_OGRLayer.begin(); for(; featIt!=m_OGRLayer.end(); ++featIt) { FeatureStruct s(m_OGRLayer.GetLayerDefn()); s.feat = *featIt; s.fusioned = false; upperStreamFeatureList.push_back(s); upperFIDs.insert((*featIt).GetFID()); } //Do the same thing for the lower/right stream std::vector lowerStreamFeatureList; lowerStreamFeatureList.clear(); if(!line) { //Compute the spatial filter of the lower stream UpperLeftCorner[0] = x*m_StreamSize[0]; UpperLeftCorner[1] = m_StreamSize[1]*(y-1); LowerRightCorner[0] = m_StreamSize[0]*x + m_Radius; LowerRightCorner[1] = m_StreamSize[1]*y - 1; } else { //Compute the spatial filter of the right stream UpperLeftCorner[0] = (x-1)*m_StreamSize[0]; UpperLeftCorner[1] = m_StreamSize[1]*y; LowerRightCorner[0] = m_StreamSize[0]*x - 1; LowerRightCorner[1] = m_StreamSize[1]*y + m_Radius; } inputImage->TransformIndexToPhysicalPoint(UpperLeftCorner, ulCorner); inputImage->TransformIndexToPhysicalPoint(LowerRightCorner, lrCorner); m_OGRLayer.SetSpatialFilterRect(ulCorner[0],lrCorner[1],lrCorner[0],ulCorner[1]); for(featIt = m_OGRLayer.begin(); featIt!=m_OGRLayer.end(); ++featIt) { if(upperFIDs.find((*featIt).GetFID()) == upperFIDs.end()) { FeatureStruct s(m_OGRLayer.GetLayerDefn()); s.feat = *featIt; s.fusioned = false; lowerStreamFeatureList.push_back(s); } } unsigned int nbUpperPolygons = upperStreamFeatureList.size(); unsigned int nbLowerPolygons = lowerStreamFeatureList.size(); std::vector fusionList; fusionList.clear(); for(unsigned int u=0; ugetGeometryType() == wkbPolygon) { fusion.overlap = dynamic_cast(intersection.get())->get_Area(); } else if(intersection->getGeometryType() == wkbMultiPolygon) { fusion.overlap = dynamic_cast(intersection.get())->get_Area(); } else if(intersection->getGeometryType() == wkbGeometryCollection) { fusion.overlap = dynamic_cast(intersection.get())->get_Area(); } else if(intersection->getGeometryType() == wkbLineString) { fusion.overlap = dynamic_cast(intersection.get())->get_Length(); } else if (intersection->getGeometryType() == wkbMultiLineString) { #if(GDAL_VERSION_NUM < 1800) fusion.overlap = GetLengthOGRGeometryCollection(dynamic_cast (intersection.get())); #else fusion.overlap = dynamic_cast(intersection.get())->get_Length(); #endif } /** -Wunused-variable long upperFID = upper.feat.GetFID(); long lowerFID = lower.feat.GetFID(); **/ fusionList.push_back(fusion); } } } } } unsigned int fusionListSize = fusionList.size(); std::sort(fusionList.begin(),fusionList.end(),SortFeature); for(unsigned int i=0; i()); break; } default: { fusionFeature[0].SetValue(field.GetValue()); } } #else // Only OFTInteger supported in this case fusionFeature[0].SetValue(field.GetValue()); #endif m_OGRLayer.CreateFeature(fusionFeature); m_OGRLayer.DeleteFeature(lower.feat.GetFID()); m_OGRLayer.DeleteFeature(upper.feat.GetFID()); } catch(itk::ExceptionObject& err) { otbWarningMacro(<<"An exception was caught during fusion: "< void OGRLayerStreamStitchingFilter ::GenerateData(void) { if(!m_OGRLayer) { itkExceptionMacro(<<"Input OGR layer is null!"); } this->InvokeEvent(itk::StartEvent()); typename InputImageType::ConstPointer inputImage = this->GetInput(); //compute the number of stream division in row and column SizeType imageSize = this->GetInput()->GetLargestPossibleRegion().GetSize(); unsigned int nbRowStream = static_cast(imageSize[1] / m_StreamSize[1] + 1); unsigned int nbColStream = static_cast(imageSize[0] / m_StreamSize[0] + 1); itk::ProgressReporter progress(this,0,2*nbRowStream*nbColStream,100,0); //Process column this->ProcessStreamingLine(false, progress); //Process row this->ProcessStreamingLine(true, progress); this->InvokeEvent(itk::EndEvent()); } } // end namespace otb #endif otbStreamingImageToOGRLayerSegmentationFilter.h000066400000000000000000000313711301006202600346660ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/OGRProcessing/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingImageToOGRLayerSegmentationFilter_h #define otbStreamingImageToOGRLayerSegmentationFilter_h #include "itkExtractImageFilter.h" #include "otbPersistentFilterStreamingDecorator.h" #include "otbPersistentImageToOGRLayerFilter.h" #include "otbRelabelComponentImageFilter.h" #include "itkMultiplyImageFilter.h" #include "otbLabeledOutputAccessor.h" #include "otbMeanShiftSmoothingImageFilter.h" namespace otb { /** * \class LabeledOutputAccessor * \brief Specialized class to get the index of the labeled output image in mean shift filter (new version). * * \ingroup OTBOGRProcessing */ template class LabeledOutputAccessor > { public: typedef typename MeanShiftSmoothingImageFilter::OutputLabelImageType LabelImageType; itkStaticConstMacro(LabeledOutputIndex, unsigned int, 0); }; /** \class PersistentStreamingLabelImageToOGRDataFilter * \brief This filter is a framework for large scale segmentation. * For a detailed description @see StreamingImageToOGRLayerSegmentationFilter * * \ingroup OTBOGRProcessing */ template class PersistentImageToOGRLayerSegmentationFilter : public otb::PersistentImageToOGRLayerFilter { public: /** Standard Self typedef */ typedef PersistentImageToOGRLayerSegmentationFilter Self; typedef PersistentImageToOGRLayerFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointerType; typedef TSegmentationFilter SegmentationFilterType; typedef typename LabeledOutputAccessor::LabelImageType LabelImageType; typedef typename LabelImageType::PixelType LabelPixelType; typedef otb::LabelImageToOGRDataSourceFilter LabelImageToOGRDataSourceFilterType; typedef typename Superclass::OGRDataSourceType OGRDataSourceType; typedef typename Superclass::OGRDataSourcePointerType OGRDataSourcePointerType; typedef typename Superclass::OGRLayerType OGRLayerType; typedef RelabelComponentImageFilter RelabelComponentImageFilterType; typedef itk::MultiplyImageFilter MultiplyImageFilterType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(PersistentImageToOGRLayerSegmentationFilter, PersistentImageToOGRLayerFilter); /** Return a pointer to the segmentation filter used. */ itkGetObjectMacro(SegmentationFilter, SegmentationFilterType); itkSetStringMacro(FieldName); itkGetStringMacro(FieldName); /** Set the first Label value (default is 1). Incremental step is 1.*/ void SetStartLabel(const LabelPixelType & label) { m_StartLabel = label; m_TileMaxLabel = label; } /** Return the first label value*/ itkGetMacro(StartLabel, LabelPixelType); /** * Set the value of 8-connected neighborhood option used in \c LabelImageToOGRDataSourceFilter */ itkSetMacro(Use8Connected, bool); /** * Get the value of 8-connected neighborhood option used in \c LabelImageToOGRDataSourceFilter */ itkGetMacro(Use8Connected, bool); /** Set the option for filtering small objects. Default to false. */ itkSetMacro(FilterSmallObject, bool); /** Return the value of filter small objects option.*/ itkGetMacro(FilterSmallObject, bool); /** Set the minimum object size (in pixels) in case FilterSmallObject option is true.*/ itkSetMacro(MinimumObjectSize, unsigned int); /** Get the minimum object size.*/ itkGetMacro(MinimumObjectSize, unsigned int); /** Option for simplifying geometries. Default to false.*/ itkSetMacro(Simplify, bool); itkGetMacro(Simplify, bool); /** Set the tolerance value for simplifying geometries. * \sa \c OGRGeometry::Simplify() \c OGRGeometry::SimplifyPreserveTopology() */ itkSetMacro(SimplificationTolerance, double); /** Get the tolerance value for simplifying geometries. * \sa \c OGRGeometry::Simplify() \c OGRGeometry::SimplifyPreserveTopology() */ itkGetMacro(SimplificationTolerance, double); /** Set/Get the input mask image. * All pixels in the mask with a value of 0 will not be considered * suitable for vectorization. */ virtual void SetInputMask(const LabelImageType *mask); virtual const LabelImageType * GetInputMask(void); protected: PersistentImageToOGRLayerSegmentationFilter(); ~PersistentImageToOGRLayerSegmentationFilter() ITK_OVERRIDE; private: PersistentImageToOGRLayerSegmentationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented OGRDataSourcePointerType ProcessTile() ITK_OVERRIDE; int m_TileMaxLabel; LabelPixelType m_StartLabel; typename SegmentationFilterType::Pointer m_SegmentationFilter; std::string m_FieldName; unsigned int m_TileNumber; bool m_Use8Connected; bool m_FilterSmallObject; unsigned int m_MinimumObjectSize; bool m_Simplify; double m_SimplificationTolerance; }; /** \class StreamingImageToOGRLayerSegmentationFilter * \brief This filter is a framework for large scale segmentation. * It is a persistent filter that process the input image tile by tile. * This filter is templated over the segmentation filter. This later is used to segment each tile of the input image. * Each segmentation result (for each tile) is then vectorized using \c LabelImageToOGRDataSourceFilter * (based on \c GDALPolygonize()). * The output \c OGRDataSource of the \c LabelImageToOGRDataSourceFilter is a "memory" DataSource * (ie all features of a tile are kept in memory). From here some optional processing can be done, * depending on input parameters : * - Simplify option : If set to true, the SimplificationTolerance parameter is used to simplify all geometries, * using the \c OGRGeometry::Simplify() method, based on Douglas-Peuker algorithm. * - FilterSmallObject option : if set to true, polygons with a size less than MinimumObjectSize (in pixels) * are discarded. * Finally all features contained in the "memory" DataSource are copied into the input Layer, * in the layer specified with the \c SetLayerName() method. * * \note The Use8Connected parameter can be turn on and it will be used in \c GDALPolygonize(). But be carreful, it * can create cross polygons ! * \note The input mask can be used to exclude pixels from vectorization process. * All pixels with a value of 0 in the input mask image will not be suitable for vectorization. * * \ingroup OTBOGRProcessing */ template class ITK_EXPORT StreamingImageToOGRLayerSegmentationFilter : public PersistentFilterStreamingDecorator > { public: /** Standard Self typedef */ typedef StreamingImageToOGRLayerSegmentationFilter Self; typedef PersistentFilterStreamingDecorator > Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Type macro */ itkNewMacro(Self); /** Creation through object factory macro */ itkTypeMacro(StreamingImageToOGRLayerSegmentationFilter, PersistentFilterStreamingDecorator); typedef TSegmentationFilter SegmentationFilterType; typedef TImageType InputImageType; typedef typename PersistentImageToOGRLayerSegmentationFilter::LabelPixelType LabelPixelType; typedef typename PersistentImageToOGRLayerSegmentationFilter::LabelImageType LabelImageType; typedef typename PersistentImageToOGRLayerSegmentationFilter::OGRDataSourcePointerType OGRDataSourcePointerType; typedef typename PersistentImageToOGRLayerSegmentationFilter::OGRLayerType OGRLayerType; typedef typename InputImageType::SizeType SizeType; /** Set the input image. */ using Superclass::SetInput; void SetInput(InputImageType * input) { this->GetFilter()->SetInput(input); } const InputImageType * GetInput() { return this->GetFilter()->GetInput(); } /** Set/Get the input mask image. * All pixels in the mask with a value of 0 will not be considered * suitable for vectorization. */ void SetInputMask(LabelImageType * mask) { this->GetFilter()->SetInputMask(mask); } const LabelImageType * GetInputMask() { return this->GetFilter()->GetInputMask(); } /** Set the \c ogr::Layer in which the layer LayerName will be created. */ void SetOGRLayer( const OGRLayerType & ogrLayer ) { this->GetFilter()->SetOGRLayer(ogrLayer); } void SetFieldName( const std::string & fieldName ) { this->GetFilter()->SetFieldName(fieldName); } const std::string & GetFieldName() const { return this->GetFilter()->GetFieldName(); } SegmentationFilterType * GetSegmentationFilter() { return this->GetFilter()->GetSegmentationFilter(); } /** Set the first Label value (default is 1). Incremental step is 1.*/ void SetStartLabel(const LabelPixelType & label) { this->GetFilter()->SetStartLabel(label); } /** Return the first label value*/ const LabelPixelType & GetStartLabel() { return this->GetFilter()->GetStartLabel(); } /** Retrieve the actual streamsize used */ SizeType GetStreamSize() { return this->GetFilter()->GetStreamSize(); } void Initialize() { this->GetFilter()->Initialize(); } /** * Set the value of 8-connected neighborhood option used in \c LabelImageToOGRDataSourceFilter */ void SetUse8Connected(bool flag) { this->GetFilter()->SetUse8Connected(flag); } bool GetUse8Connected() { return this->GetFilter()->GetUse8Connected(); } /** Set the option for filtering small objects. Default to false. */ void SetFilterSmallObject(bool flag) { this->GetFilter()->SetFilterSmallObject(flag); } bool GetFilterSmallObject() { return this->GetFilter()->GetFilterSmallObject(); } /** Set the minimum object size (in pixels) in case FilterSmallObject option is true.*/ void SetMinimumObjectSize(const unsigned int & size) { this->GetFilter()->SetMinimumObjectSize(size); } unsigned int GetMinimumObjectSize() { return this->GetFilter()->GetMinimumObjectSize(); } /** Option for simplifying geometries. Default to false.*/ void SetSimplify(bool flag) { this->GetFilter()->SetSimplify(flag); } bool GetSimplify() { return this->GetFilter()->GetSimplify(); } /** Set the tolerance value for simplifying geometries. * \sa \c OGRGeometry::Simplify() \c OGRGeometry::SimplifyPreserveTopology() */ void SetSimplificationTolerance(const double & tol) { this->GetFilter()->SetSimplificationTolerance(tol); } double GetSimplificationTolerance() { return this->GetFilter()->GetSimplificationTolerance(); } protected: /** Constructor */ StreamingImageToOGRLayerSegmentationFilter() {} /** Destructor */ ~StreamingImageToOGRLayerSegmentationFilter() ITK_OVERRIDE {} private: StreamingImageToOGRLayerSegmentationFilter(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } #ifndef OTB_MANUAL_INSTANTIATION #include "otbStreamingImageToOGRLayerSegmentationFilter.txx" #endif #endif otbStreamingImageToOGRLayerSegmentationFilter.txx000066400000000000000000000154731301006202600352670ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/OGRProcessing/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Some parts of this code are derived from ITK. See ITKCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbStreamingImageToOGRLayerSegmentationFilter_txx #define otbStreamingImageToOGRLayerSegmentationFilter_txx #include "otbStreamingImageToOGRLayerSegmentationFilter.h" #include "otbVectorDataTransformFilter.h" #include "itkAffineTransform.h" #include "itkTimeProbe.h" #include "otbMacro.h" #include namespace otb { template PersistentImageToOGRLayerSegmentationFilter ::PersistentImageToOGRLayerSegmentationFilter() : m_TileMaxLabel(0), m_StartLabel(0), m_SegmentationFilter(), m_FieldName("DN"), m_Use8Connected(false), m_FilterSmallObject(false), m_MinimumObjectSize(1),m_Simplify(false), m_SimplificationTolerance(0.3) { this->SetNumberOfRequiredInputs(2); this->SetNumberOfRequiredInputs(1); m_SegmentationFilter = SegmentationFilterType::New(); m_TileNumber = 1; } template PersistentImageToOGRLayerSegmentationFilter ::~PersistentImageToOGRLayerSegmentationFilter() { } template void PersistentImageToOGRLayerSegmentationFilter ::SetInputMask(const LabelImageType *mask) { this->itk::ProcessObject::SetNthInput(1, const_cast(mask)); } template const typename PersistentImageToOGRLayerSegmentationFilter ::LabelImageType * PersistentImageToOGRLayerSegmentationFilter ::GetInputMask(void) { return static_cast(this->itk::ProcessObject::GetInput(1)); } template typename PersistentImageToOGRLayerSegmentationFilter::OGRDataSourcePointerType PersistentImageToOGRLayerSegmentationFilter ::ProcessTile() { otbMsgDebugMacro(<< "tile number : " << m_TileNumber); ++m_TileNumber; itk::TimeProbe tileChrono; tileChrono.Start(); // Apply an ExtractImageFilter to avoid problems with filters asking for the LargestPossibleRegion typedef itk::ExtractImageFilter ExtractImageFilterType; typename ExtractImageFilterType::Pointer extract = ExtractImageFilterType::New(); extract->SetInput( this->GetInput() ); extract->SetExtractionRegion( this->GetInput()->GetRequestedRegion() ); extract->Update(); // WARNING: itk::ExtractImageFilter does not copy the MetadataDictionary extract->GetOutput()->SetMetaDataDictionary(this->GetInput()->GetMetaDataDictionary()); const unsigned int labelImageIndex = LabeledOutputAccessor::LabeledOutputIndex; typename LabelImageToOGRDataSourceFilterType::Pointer labelImageToOGRDataFilter = LabelImageToOGRDataSourceFilterType::New(); itk::TimeProbe chrono1; chrono1.Start(); m_SegmentationFilter->SetInput(extract->GetOutput()); m_SegmentationFilter->UpdateLargestPossibleRegion(); chrono1.Stop(); otbMsgDebugMacro(<<"segmentation took " << chrono1.GetTotal() << " sec"); itk::TimeProbe chrono2; chrono2.Start(); typename LabelImageType::ConstPointer inputMask = this->GetInputMask(); if (!inputMask.IsNull()) { // Apply an ExtractImageFilter to avoid problems with filters asking for the LargestPossibleRegion typedef itk::ExtractImageFilter ExtractLabelImageFilterType; typename ExtractLabelImageFilterType::Pointer maskExtract = ExtractLabelImageFilterType::New(); maskExtract->SetInput( this->GetInputMask() ); maskExtract->SetExtractionRegion( this->GetInput()->GetRequestedRegion() ); maskExtract->Update(); // WARNING: itk::ExtractImageFilter does not copy the MetadataDictionary maskExtract->GetOutput()->SetMetaDataDictionary(this->GetInputMask()->GetMetaDataDictionary()); labelImageToOGRDataFilter->SetInputMask(maskExtract->GetOutput()); } labelImageToOGRDataFilter->SetInput(dynamic_cast(m_SegmentationFilter->GetOutputs().at(labelImageIndex).GetPointer())); labelImageToOGRDataFilter->SetFieldName(m_FieldName); labelImageToOGRDataFilter->SetUse8Connected(m_Use8Connected); labelImageToOGRDataFilter->Update(); chrono2.Stop(); otbMsgDebugMacro(<< "vectorization took " << chrono2.GetTotal() << " sec"); //Relabeling & simplication of geometries & filtering small objects itk::TimeProbe chrono3; chrono3.Start(); OGRDataSourcePointerType tmpDS = const_cast(labelImageToOGRDataFilter->GetOutput()); OGRLayerType tmpLayer = tmpDS->GetLayer(0); const typename InputImageType::SpacingType inSpacing = this->GetInput()->GetSpacing(); const double tol = m_SimplificationTolerance * std::max(vcl_abs(inSpacing[0]),vcl_abs(inSpacing[1])); typename OGRLayerType::iterator featIt = tmpLayer.begin(); for(featIt = tmpLayer.begin(); featIt!=tmpLayer.end(); ++featIt) { ogr::Field field = (*featIt)[0]; // field.Unset(); field.SetValue(m_TileMaxLabel); m_TileMaxLabel++; //Simplify the geometry if (m_Simplify) { const OGRGeometry * geom = (*featIt).GetGeometry(); assert(geom && "geometry is NULL ! Can't simplify it."); (*featIt).SetGeometryDirectly(ogr::Simplify(*geom,tol)); } //Need to rewrite the feature otherwise changes are not considered. tmpLayer.SetFeature(*featIt); //Filter small objects. if(m_FilterSmallObject) { double area = static_cast((*featIt).GetGeometry())->get_Area(); //convert into pixel coordinates typename InputImageType::SpacingType spacing = this->GetInput()->GetSpacing(); double pixelsArea = area / (vcl_abs(spacing[0]*spacing[1])); otbMsgDebugMacro(<<"DN = "<()<<", area = "< ImageType; typedef otb::OGRLayerStreamStitchingFilter FilterType; typedef otb::ImageFileReader ReaderType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); //first copy the input OGR file as it will be updated with the fusionned polygons itksys::SystemTools::CopyAFile(inOGRfname,tmpOGRfname,true); //Get the base name of the .shp file std::string inPathName = itksys::SystemTools::GetFilenamePath(inOGRfname); std::string inBaseName = itksys::SystemTools::GetFilenameWithoutExtension(inOGRfname); std::string outPathName = itksys::SystemTools::GetFilenamePath(tmpOGRfname); std::string outBaseName = itksys::SystemTools::GetFilenameWithoutExtension(tmpOGRfname); //copy the .shx, .dbf, .prj files std::string in = inPathName+"/"+inBaseName+".shx"; std::string out = outPathName+"/"+outBaseName+".shx"; itksys::SystemTools::CopyAFile(in.c_str(),out.c_str(),true); in = inPathName+"/"+inBaseName+".dbf"; out = outPathName+"/"+outBaseName+".dbf"; itksys::SystemTools::CopyAFile(in.c_str(),out.c_str(),true); in = inPathName+"/"+inBaseName+".prj"; out = outPathName+"/"+outBaseName+".prj"; itksys::SystemTools::CopyAFile(in.c_str(),out.c_str(),true); const std::string layerName = outBaseName; reader->SetFileName(infname); reader->UpdateOutputInformation(); ImageType::SizeType streamSize; streamSize.Fill(size); otb::ogr::DataSource::Pointer ogrDS = otb::ogr::DataSource::New(tmpOGRfname, otb::ogr::DataSource::Modes::Update_LayerUpdate); filter->SetInput(reader->GetOutput()); filter->SetOGRLayer(ogrDS->GetLayer(layerName)); filter->SetStreamSize(streamSize); filter->GenerateData(); //REPACK the layer to remove features marked as deleted in the Shapefile. std::string sql("REPACK "); sql = sql + layerName; ogrDS->ExecuteSQL(sql , ITK_NULLPTR, ITK_NULLPTR); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/OGRProcessing/test/otbOGRProcessingTestDriver.cxx000066400000000000000000000001451301006202600310570ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbOGRLayerStreamStitchingFilter); } OTB-release-5.8/Modules/Segmentation/Watersheds/000077500000000000000000000000001301006202600215745ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Watersheds/CMakeLists.txt000066400000000000000000000000511301006202600243300ustar00rootroot00000000000000project(OTBWatersheds) otb_module_impl() OTB-release-5.8/Modules/Segmentation/Watersheds/include/000077500000000000000000000000001301006202600232175ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Watersheds/include/otbWatershedSegmentationFilter.h000066400000000000000000000063571301006202600315620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWatershedSegmentationFilter_h #define otbWatershedSegmentationFilter_h #include "otbMacro.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "itkWatershedImageFilter.h" namespace otb { /** \class WatershedSegmentationFilter * \brief Watershed composite filter allowing to set output type * * This filter is a composite filter that encapsulates the * itk::WatershedImageFilter and allows setting the type of the output * image (which is not the case in the itk::WatershedImageFilter). * * The composite filter internally casts the output from the * itk::WatershedImageFilter into TOutputLabelImage. * * For more information, please refere to the documentation of the * original itk::WatershedImageFilter . * * * \ingroup OTBWatersheds */ template class WatershedSegmentationFilter : public itk::ImageToImageFilter { public: /** Standard Self typedef */ typedef WatershedSegmentationFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Some convenient typedefs. */ typedef TInputImage InputImageType; typedef TOutputLabelImage OutputLabelImageType; typedef itk::WatershedImageFilter WatershedFilterType; typedef typename WatershedFilterType::OutputImageType InternalOutputImageType; typedef itk::CastImageFilter CastImageFilterType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Runtime information support. */ itkTypeMacro(WatershedSegmentationFilter, ImageToImageFilter); /** ImageDimension constants */ itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension); otbSetObjectMemberMacro(WatershedFilter,Level,float); otbGetObjectMemberMacro(WatershedFilter,Level,float); otbSetObjectMemberMacro(WatershedFilter,Threshold,float); otbGetObjectMemberMacro(WatershedFilter,Threshold,float); protected: WatershedSegmentationFilter(); ~WatershedSegmentationFilter() ITK_OVERRIDE; void GenerateData() ITK_OVERRIDE; private: typename CastImageFilterType::Pointer m_CastFilter; typename WatershedFilterType::Pointer m_WatershedFilter; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbWatershedSegmentationFilter.txx" #endif #endif OTB-release-5.8/Modules/Segmentation/Watersheds/include/otbWatershedSegmentationFilter.txx000066400000000000000000000033771301006202600321550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWatershedSegmentationFilter_txx #define otbWatershedSegmentationFilter_txx #include "otbWatershedSegmentationFilter.h" namespace otb { template WatershedSegmentationFilter ::WatershedSegmentationFilter() { m_WatershedFilter = WatershedFilterType::New(); m_CastFilter = CastImageFilterType::New(); m_CastFilter->SetInput(m_WatershedFilter->GetOutput()); this->SetNthOutput(0,TOutputLabelImage::New()); } template WatershedSegmentationFilter ::~WatershedSegmentationFilter() {} template void WatershedSegmentationFilter ::GenerateData() { this->m_WatershedFilter->SetInput(this->GetInput()); m_CastFilter->GraftOutput(this->GetOutput()); m_CastFilter->Update(); this->GraftOutput(m_CastFilter->GetOutput()); // Since WatershedFilterType outputs an itk::Image, // we loose the additional metadata of OTB like ProjectionRef. // Import them before exiting this->GetOutput()->CopyInformation( this->GetInput() ); } } // end namespace otb #endif OTB-release-5.8/Modules/Segmentation/Watersheds/otb-module.cmake000066400000000000000000000003651301006202600246510ustar00rootroot00000000000000set(DOCUMENTATION "OTB implementation of Watersheds segmentation algorithm.") otb_module(OTBWatersheds DEPENDS OTBCommon OTBITK TEST_DEPENDS OTBTestKernel OTBImageIO OTBImageBase DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Segmentation/Watersheds/test/000077500000000000000000000000001301006202600225535ustar00rootroot00000000000000OTB-release-5.8/Modules/Segmentation/Watersheds/test/CMakeLists.txt000066400000000000000000000012561301006202600253170ustar00rootroot00000000000000otb_module_test() set(OTBWatershedsTests otbWatershedsTestDriver.cxx otbWatershedSegmentationFilter.cxx ) add_executable(otbWatershedsTestDriver ${OTBWatershedsTests}) target_link_libraries(otbWatershedsTestDriver ${OTBWatersheds-Test_LIBRARIES}) otb_module_target_label(otbWatershedsTestDriver) # Tests Declaration otb_add_test(NAME obTuWatershedSegmentationFilter COMMAND otbWatershedsTestDriver --compare-image ${NOTOL} ${BASELINE}/obTuWatershedSegmentationFilterLabelImage.tif ${TEMP}/obTuWatershedSegmentationFilterLabelImage.tif otbWatershedSegmentationFilter ${EXAMPLEDATA}/ROI_QB_PAN_1.tif ${TEMP}/obTuWatershedSegmentationFilterLabelImage.tif 0.01 0.2 ) OTB-release-5.8/Modules/Segmentation/Watersheds/test/otbWatershedSegmentationFilter.cxx000066400000000000000000000047771301006202600314750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWatershedSegmentationFilter.h" #include "itkMacro.h" #include "otbImage.h" #include "otbImageFileReader.h" #include "otbImageFileWriter.h" #include "itkGradientMagnitudeImageFilter.h" int otbWatershedSegmentationFilter(int argc, char * argv[]) { if (argc != 5) { std::cerr << "Usage: " << argv[0] << " inputFileName outputLabelFileName threshold level" << std::endl; return EXIT_FAILURE; } const char * inputFileName = argv[1]; const char * outputLabelFileName = argv[2]; const double threshold = atof(argv[3]); const double level = atof(argv[4]); /* maxit - threshold */ const unsigned int Dimension = 2; typedef float PixelType; typedef otb::Image InputImageType; typedef otb::Image LabelImageType; typedef otb::ImageFileReader ReaderType; typedef otb::ImageFileWriter LabelWriterType; typedef itk::GradientMagnitudeImageFilter GradientMagnitudeFilterType; typedef otb::WatershedSegmentationFilter FilterType; // Instantiating object GradientMagnitudeFilterType::Pointer gradientMagnitudeFilter = GradientMagnitudeFilterType::New(); FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFileName); gradientMagnitudeFilter->SetInput(reader->GetOutput()); // Set filter parameters filter->SetThreshold(threshold); filter->SetLevel(level); filter->SetInput(gradientMagnitudeFilter->GetOutput()); LabelWriterType::Pointer writerLabel = LabelWriterType::New(); writerLabel->SetFileName(outputLabelFileName); writerLabel->SetInput(filter->GetOutput()); writerLabel->Update(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Segmentation/Watersheds/test/otbWatershedsTestDriver.cxx000066400000000000000000000001431301006202600301270ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbWatershedSegmentationFilter); } OTB-release-5.8/Modules/ThirdParty/000077500000000000000000000000001301006202600171205ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/6S/000077500000000000000000000000001301006202600174105ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/6S/CMakeLists.txt000066400000000000000000000002071301006202600221470ustar00rootroot00000000000000project(OTB6S) set(OTB6S_THIRD_PARTY 1) set(OTB6S_LIBRARIES otb6S) set(OTB6S_INCLUDE_DIRS ${OTB6S_SOURCE_DIR}/src) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/6S/otb-module.cmake000066400000000000000000000003721301006202600224630ustar00rootroot00000000000000set(DOCUMENTATION "This module imports 6S to the build system") otb_module(OTB6S DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable 6S radiometric and atmospheric correction module" ON) OTB-release-5.8/Modules/ThirdParty/Boost/000077500000000000000000000000001301006202600202065ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Boost/CMakeLists.txt000066400000000000000000000014601301006202600227470ustar00rootroot00000000000000project(OTBBoost) set(OTBBoost_SYSTEM_INCLUDE_DIRS ${Boost_INCLUDE_DIRS}) set(OTBBoost_INCLUDE_DIRS ${OTBBoost_SOURCE_DIR}/src) # Do not include boost libraries into full list of OTB_LIBRARIES # That will drag them in linking all otb modules and executables which is bad. # OTB uses only header only libraries of boost. A non-header only library # named 'unit_testing_framework' is used in two tests. # why drag a semi-standard c++ library for use in two tests?. # if(Boost_LIBRARIES) # set(OTBBoost_LIBRARIES "${Boost_LIBRARIES}") # endif() set(Boost_VERSION_STRING "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}" CACHE INTERNAL "" FORCE) otb_module_impl() install(DIRECTORY ${OTBBoost_SOURCE_DIR}/src/boost DESTINATION ${OTBBoost_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/ThirdParty/Boost/otb-module-init.cmake000066400000000000000000000010231301006202600242140ustar00rootroot00000000000000 set(Boost_USE_STATIC_LIBS OFF CACHE BOOL "use static libraries from boost") set(Boost_USE_MULTITHREADED ON CACHE BOOL "use multi-threaded libraries from boost") find_package (Boost 1.35.0 REQUIRED) if (BUILD_TESTING) find_package (Boost 1.35.0 QUIET COMPONENTS unit_test_framework) if (NOT Boost_UNIT_TEST_FRAMEWORK_FOUND) message(STATUS "Boost unit_test_framework not found. Hence otbOGRTests will be skipped") else() message(STATUS "Found Boost components: unit_test_framework") endif() endif() #BUILD_TESTING OTB-release-5.8/Modules/ThirdParty/Boost/otb-module.cmake000066400000000000000000000002441301006202600232570ustar00rootroot00000000000000set(DOCUMENTATION "This module imports Boost to the build system") otb_module(OTBBoost DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/Boost/src/000077500000000000000000000000001301006202600207755ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Boost/src/boost/000077500000000000000000000000001301006202600221235ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Boost/src/boost/type_traits/000077500000000000000000000000001301006202600244725ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Boost/src/boost/type_traits/is_contiguous.h000066400000000000000000000057301301006202600275420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef is_contiguous_h #define is_contiguous_h /**\ingroup boost * \file is_contiguous.h * \since OTB v 3.14.0 * * \note This type traits is likelly to appear in boost and in C++ TR2 at some * point in time. It is used in order to (micro-)optimize the interfacing of OTB * and OGR. * \note The filename however does not follow boost naming policy yet. * * \sa http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3350.html about * \c contiguous_iterator_tag. * * \todo What licence to use ? */ #include #include #include // forward declarations // Comment the forward declaration of std::array as it causes compilation errors // on MSVC 10 when the header boost/lexical_cast.hpp is also included //namespace std { //template class array; //} // std namespace namespace boost { template class array; template class ptr_array; template class ptr_vector; } // boost namespace namespace boost { /**\ingroup boost * \brief Type-traits: are the elements contiguous in the range. * \note This type traits is likelly to appear in boost and in C++ TR2 at some * point in time. It is used in order to (micro-)optimize the interfacing of OTB * and OGR. * \note As a consequence, it follows C++ standard and boost naming policy. * * \sa http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3350.html about * \c contiguous_iterator_tag. * \since OTB v 3.14.0 * @{ */ template struct is_contiguous { enum {value = is_array::value || is_pointer::value}; }; // is_contiguous specialisations template struct is_contiguous > { enum {value = true}; }; template struct is_contiguous > { enum {value = true}; }; template struct is_contiguous > { enum {value = true}; }; template struct is_contiguous > { enum {value = true}; }; /** @} */ } // boost namespace #endif // __is_contiguous_h OTB-release-5.8/Modules/ThirdParty/Boost/src/otbBoostDox.h000066400000000000000000000015221301006202600234140ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbBoostDox_h #define otbBoostDox_h /**\defgroup boost Boost alike helpers * \ingroup Thematic * \brief Various helpers that are likelly to end-up in boost by themselves eventually. * \see http://www.boost.org/ * @{ */ namespace boost { } //@} #endif // otbBoostDox_h OTB-release-5.8/Modules/ThirdParty/Curl/000077500000000000000000000000001301006202600200255ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Curl/CMake/000077500000000000000000000000001301006202600210055ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Curl/CMake/otbTestCurlMulti.cxx000066400000000000000000000003671301006202600250240ustar00rootroot00000000000000#include "curl/curl.h" #include int main(int argc,char * argv[]) { CURLM* multiHandle; multiHandle = curl_multi_init(); curl_multi_setopt(multiHandle, CURLMOPT_MAXCONNECTS, 10); curl_multi_cleanup(multiHandle); return 0; } OTB-release-5.8/Modules/ThirdParty/Curl/CMakeLists.txt000066400000000000000000000012511301006202600225640ustar00rootroot00000000000000project(OTBCurl) try_compile(OTB_CURL_MULTI_AVAILABLE ${CMAKE_CURRENT_BINARY_DIR}/CMake ${CMAKE_CURRENT_SOURCE_DIR}/CMake/otbTestCurlMulti.cxx CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:PATH=${CURL_INCLUDE_DIRS}" "-DLINK_LIBRARIES:STRING=${CURL_LIBRARIES}" OUTPUT_VARIABLE OUTPUT) configure_file( src/otb_curl.h.in src/otb_curl.h ) set(OTBCurl_SYSTEM_INCLUDE_DIRS ${CURL_INCLUDE_DIRS}) set(OTBCurl_LIBRARIES "${CURL_LIBRARIES}") set(OTBCurl_INCLUDE_DIRS ${OTBCurl_BINARY_DIR}/src ) otb_module_impl() install(FILES ${OTBCurl_BINARY_DIR}/src/otb_curl.h DESTINATION ${OTBCurl_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/ThirdParty/Curl/otb-module-init.cmake000066400000000000000000000000371301006202600240370ustar00rootroot00000000000000find_package ( CURL REQUIRED ) OTB-release-5.8/Modules/ThirdParty/Curl/otb-module.cmake000066400000000000000000000003521301006202600230760ustar00rootroot00000000000000set(DOCUMENTATION "This module imports Curl to the build system") otb_module(OTBCurl DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable curl based functionnalities" OFF) OTB-release-5.8/Modules/ThirdParty/Curl/src/000077500000000000000000000000001301006202600206145ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Curl/src/otb_curl.h.in000066400000000000000000000012441301006202600232040ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_curl_h #define otb_curl_h #cmakedefine OTB_CURL_MULTI_AVAILABLE #include #endif OTB-release-5.8/Modules/ThirdParty/GDAL/000077500000000000000000000000001301006202600176275ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/GDAL/CMakeLists.txt000066400000000000000000000002061301006202600223650ustar00rootroot00000000000000project(OTBGDAL) set(OTBGDAL_SYSTEM_INCLUDE_DIRS ${GDAL_INCLUDE_DIRS}) set(OTBGDAL_LIBRARIES "${GDAL_LIBRARIES}") otb_module_impl() OTB-release-5.8/Modules/ThirdParty/GDAL/gdalCreateCopyTest.cxx000066400000000000000000000023421301006202600241020ustar00rootroot00000000000000#include #include #include #include #include int main(int argc, char * argv[]) { GDALAllRegister(); const char *pszFormat = argv[3]; GDALDriverH hDriver = GDALGetDriverByName( pszFormat ); if( hDriver == NULL ) { printf ("gdalCreateCopyTest.cxx: hDriver == NULL "); return EXIT_FAILURE; } char **papszCreateOptions = NULL; if( argc == 5 ) { papszCreateOptions = CSLAddString( papszCreateOptions, argv[4] ); } char **papszMetadata; papszMetadata = GDALGetMetadata( hDriver, NULL ); if( CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATECOPY, FALSE ) ) printf( "Driver %s supports CreateCopy() method.\n", pszFormat ); GDALDatasetH hSrcDS = GDALOpen( argv[1], GA_ReadOnly ); if( hSrcDS == NULL ) { printf ("gdalCreateCopyTest.cxx: hSrcDS == NULL "); return EXIT_FAILURE; } GDALDatasetH hDstDS; hDstDS = GDALCreateCopy( hDriver, argv[2], hSrcDS, FALSE, NULL, NULL, NULL ); if( hDstDS == NULL ) { printf ("gdalCreateCopyTest.cxx: hDstDS == NULL "); return EXIT_FAILURE; } /* Once we're done, close properly the dataset */ if( hDstDS != NULL ) GDALClose( hDstDS ); GDALClose(hSrcDS); return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/GDAL/gdalCreateTest.cxx000066400000000000000000000033541301006202600232530ustar00rootroot00000000000000#include #include #include #include #include int main(int argc, char * argv[]) { const char *pszFormat = argv[1]; char **papszMetadata; GDALAllRegister(); // ------------------- step 1 ------------------- GDALDriverH hDriver = GDALGetDriverByName( pszFormat ); if( hDriver == NULL ) { printf("poDriver == NULL\n" ); return EXIT_FAILURE; } papszMetadata = GDALGetMetadata( hDriver, NULL ); if( CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATE, FALSE ) ) printf( "Driver %s supports Create() method.\n", pszFormat ); else { printf( "Driver %s does supports Create() method.\n", pszFormat ); return EXIT_FAILURE; } // ------------------- step 2 ------------------- GDALDatasetH hDstDS; char **papszOptions = NULL; hDstDS = GDALCreate( hDriver, argv[2], 512, 512, 1, GDT_Byte, papszOptions ); // ------------------- step 3 ------------------- double adfGeoTransform[6] = { 444720, 30, 0, 3751320, 0, -30 }; OGRSpatialReferenceH hSRS; char *pszSRS_WKT = NULL; GDALRasterBandH hBand; GByte abyRaster[512*512]; GDALSetGeoTransform( hDstDS, adfGeoTransform ); hSRS = OSRNewSpatialReference( NULL ); OSRSetUTM( hSRS, 11, TRUE ); OSRSetWellKnownGeogCS( hSRS, "NAD27" ); OSRExportToWkt( hSRS, &pszSRS_WKT ); OSRDestroySpatialReference( hSRS ); GDALSetProjection( hDstDS, pszSRS_WKT ); CPLFree( pszSRS_WKT ); hBand = GDALGetRasterBand( hDstDS, 1 ); GDALRasterIO( hBand, GF_Write, 0, 0, 512, 512, abyRaster, 512, 512, GDT_Byte, 0, 0 ); // ------------------- step 4 ------------------- /* Once we're done, close properly the dataset */ GDALClose( hDstDS ); return EXIT_SUCCESS;// SUCCESS } OTB-release-5.8/Modules/ThirdParty/GDAL/gdalFormatsListTest.c000066400000000000000000000017201301006202600237320ustar00rootroot00000000000000#include #include /* http://www.gdal.org/formats_list.html */ int main(int argc, char * argv[]) { int i; int count = 0; FILE *fp = NULL; GDALDriverH driver = NULL; if (argc < 2) { printf( "gdalFormatList.c: incorrect usage.\n"); exit(1); } GDALAllRegister(); count = GDALGetDriverCount(); if( count < 1 ) { printf( "gdalFormatList.c: Driver count zero.\n"); exit(1); } fp = fopen(argv[1], "w"); if (fp == NULL) { printf("gdalFormatList.c: Error opening file!\n"); exit(1); } fprintf(fp, "%s\n", "###############################"); fprintf(fp, "# Nb of drivers: %d\n", count); fprintf(fp, "%s\n", "###############################"); fprintf(fp, "%s\n", "ID,Short name,Long name"); for (i = 0; i < count; i++) { driver = GDALGetDriver(i); fprintf(fp, "%d,%s,%s\n", i, GDALGetDriverShortName(driver), GDALGetDriverLongName(driver)); } fclose(fp); return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/GDAL/gdalFormatsTest.c000066400000000000000000000007041301006202600230770ustar00rootroot00000000000000#include #include /* http://www.gdal.org/formats_list.html */ int main(int argc, char * argv[]) { GDALDriverH hDriver = NULL; if (argc < 2) { printf( "Usage : gdalFormatsTest driverName.\n"); return EXIT_FAILURE;; } GDALAllRegister(); hDriver = GDALGetDriverByName( argv[1] ); if( hDriver == NULL ) { printf( "No driver for input name '%s' ", argv[1]); return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/GDAL/gdalOGRTest.cxx000066400000000000000000000003621301006202600224730ustar00rootroot00000000000000#include "ogr_api.h" int main(int argc,char * argv[]) { OGRDataSourceH hDS; OGRSFDriverH *pahDriver = NULL; OGRRegisterAll(); hDS = OGROpen("null.shp", FALSE, pahDriver ); OGRReleaseDataSource( hDS ); return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/GDAL/gdalSymbolsTest.cxx000066400000000000000000000017571301006202600235050ustar00rootroot00000000000000#include #include #include #include #include using namespace std; //----------------- if internal libtiff/libgeotiff are detected, symbol renaming is mandatory ------------------------- int main(int argc, char * argv[]) { const char * inputFilename = argv[1]; string pattern1("TIFFClose"); string pattern2("gdal_"); ifstream file(inputFilename, ios::in); if(file) { string line; while(getline(file, line)) { if (line.find(pattern1) != string::npos) if (line.find(pattern2) == string::npos) { cout << "Internal versions of libtiff/libgeotiff detected without symbol renaming!" << std::endl; cout << "When configuring GDAL, if options --with-libtiff or --with-geotiff are set to 'internal', then options --with-rename-internal-libtiff-symbols and --with-rename-internal-libgeotiff-symbols should be set to 'yes')" << std::endl; return EXIT_FAILURE; } } file.close(); } return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/GDAL/gdalTest.sh.in000066400000000000000000000005771301006202600223500ustar00rootroot00000000000000#!/bin/sh tempFolder=@TEMP@ gdalLibLocation=@GDAL_LIBRARY@ apple=@APPLE@ mkdir -p ${tempFolder} #TEST 1 : dyn. symbols if [ -z "${apple}" ] then nm -D --defined-only ${gdalLibLocation} | grep TIFFClose > ${tempFolder}/gdalSymbols.txt else nm -U ${gdalLibLocation} | grep TIFFClose > ${tempFolder}/gdalSymbols.txt # -U : don't display undefined syms (same as --defined-only) fi OTB-release-5.8/Modules/ThirdParty/GDAL/gdalVersionTest.cxx000066400000000000000000000024621301006202600234740ustar00rootroot00000000000000#include #include #include #include #include #include #include using namespace std; //----------------- FORMAT ------------------------- int main(int argc, char * argv[]) { int MAJOR = atoi(argv[2]); int MINOR = atoi(argv[3]); string version(GDALVersionInfo("RELEASE_NAME")); // Remember gdal version const char * inputFilename = argv[1]; ofstream file(inputFilename, ios::out | ios::trunc); if(file) { file << version; file.close(); } /*else { cout << "WARNING : Can't open file " << inputFilename << endl; return 2; }*/ //Version check istringstream iss(version); unsigned int pos=0; string sub; unsigned int someUIntVal; vector UIntVect; while ( std::getline( iss, sub, '.' ) ) { istringstream convert(sub); convert >> someUIntVal; //cout << someUIntVal << '\n'; if (pos==0) //Major UIntVect.push_back(someUIntVal); if (pos==1) //Minor UIntVect.push_back(someUIntVal); pos++; } if ( (UIntVect[0]==MAJOR && UIntVect[1]= " << MAJOR << "." << MINOR << " : " << UIntVect[0] << "." << UIntVect[1] << " detected)." << endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/GDAL/otb-module-init.cmake000066400000000000000000000145011301006202600236420ustar00rootroot00000000000000find_package ( GDAL REQUIRED ) mark_as_advanced(GDAL_INCLUDE_DIR) mark_as_advanced(GDAL_LIBRARY) mark_as_advanced(GDAL_CONFIG) if(NOT GDAL_FOUND) message(FATAL_ERROR "Cannot find GDAL. Set GDAL_INCLUDE_DIR and GDAL_LIBRARY") endif() #Check if GDAL is compatible with OTB using a bunch of cmake try_run and try_compile. (Default value is ON.) set(GDAL_CONFIG_CHECKING ON CACHE BOOL "Tests to check gdal config." FORCE) mark_as_advanced(GDAL_CONFIG_CHECKING) if(NOT GDAL_CONFIG_CHECKING) return() endif() set(MIN_MAJOR_VERSION 1) set(MIN_MINOR_VERSION 10) # Ensure that the temporary dir always exists before starting tests if(NOT EXISTS ${TEMP}) FILE(MAKE_DIRECTORY ${TEMP}) endif() #------------------- Helper Macro --------------------- macro(gdal_try_run msg_type var source_file) message(STATUS "Performing Test ${var}") set(${var}) try_run(RUN_${var} COMPILE_${var} ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR}/Modules/ThirdParty/GDAL/${source_file} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:PATH=${GDAL_INCLUDE_DIR}" "-w" "-DLINK_LIBRARIES:STRING=${GDAL_LIBRARY}" COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT_${var} RUN_OUTPUT_VARIABLE RUN_OUTPUT_${var} ARGS ${ARGN} ) if(NOT COMPILE_${var}) message(FATAL_ERROR "Compiling Test ${var} - Failed \n COMPILE_OUTPUT_${var}: '${COMPILE_OUTPUT_${var}}'") endif() if(RUN_${var}) set(${var} FALSE) #if msg_type is STATUS (ie "okay" if test is failing), #then we don't need to give an run-output and exit status. if("${msg_type}" STREQUAL "STATUS") message(${msg_type} "Performing Test ${var} - Failed") else() message(${msg_type} "Performing Test ${var} - Failed \n Exit status: '${RUN_${var}}' \n RUN_OUTPUT_${var}: '${RUN_OUTPUT_${var}}'") endif() else() set(${var} TRUE) message(STATUS "Performing Test ${var} - Success") endif() unset(RUN_OUTPUT_${var}) unset(COMPILE_OUTPUT_${var}) unset(COMPILE_${var}) endmacro() #------------------- TESTS --------------------- # Version of GDAL gdal_try_run(FATAL_ERROR GDAL_VERSION gdalVersionTest.cxx ${TEMP}/gdalVersion.txt ${MIN_MAJOR_VERSION} ${MIN_MINOR_VERSION}) if(EXISTS "${TEMP}/gdalVersion.txt") file(READ "${TEMP}/gdalVersion.txt" _GDAL_VERSION_STRING) #can't we use GDAL_VERSION_NUM ? string(SUBSTRING ${_GDAL_VERSION_STRING} 0 2 VER2) if("${VER2}" STREQUAL "2.") set(OTB_USE_GDAL_20 true CACHE INTERNAL "True if GDAL >= 2.0.0 has been detected" FORCE ) else() set(OTB_USE_GDAL_20 false CACHE INTERNAL "True if GDAL >= 2.0.0 has been detected" FORCE ) endif() set(GDAL_VERSION_STRING "${_GDAL_VERSION_STRING}" CACHE INTERNAL "" FORCE) else() message(FATAL_ERROR "${TEMP}/gdalVersion.txt does not exist. Cannot continue.") endif() #check OGR #gdal_try_run(FATAL_ERROR GDAL_HAS_OGR gdalOGRTest.cxx) try_compile(COMPILE_GDAL_HAS_OGR ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR}/Modules/ThirdParty/GDAL/gdalOGRTest.cxx CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:PATH=${GDAL_INCLUDE_DIR}" "-w" "-DLINK_LIBRARIES:STRING=${GDAL_LIBRARY}" OUTPUT_VARIABLE COMPILE_OUTPUT_GDAL_HAS_OGR ) if(NOT COMPILE_GDAL_HAS_OGR) message(FATAL_ERROR "Performing Test COMPILE_GDAL_HAS_OGR - Failed\n COMPILE_OUTPUT:${COMPILE_OUTPUT_GDAL_HAS_OGR}\n") else() message(STATUS "Performing Test COMPILE_GDAL_HAS_OGR - Success") endif() # check formats TIFF, GeoTIFF, JPEG, JPEG2000, HDF5 # Note : exact format names can be found here http://www.gdal.org/formats_list.html gdal_try_run(STATUS GDAL_FORMATS_LIST gdalFormatsListTest.c ${TEMP}/gdalFormatsList.csv) gdal_try_run(FATAL_ERROR GDAL_HAS_JPEG gdalFormatsTest.c JPEG) gdal_try_run(FATAL_ERROR GDAL_HAS_GTiff gdalFormatsTest.c GTiff) gdal_try_run(FATAL_ERROR GDAL_CAN_CREATE_GTiff gdalCreateTest.cxx GTiff ${TEMP}/testImage.gtif ) gdal_try_run(FATAL_ERROR GDAL_CAN_CREATE_GTiff_BIGTIFF gdalCreateCopyTest.cxx ${TEMP}/testImage.gtif ${TEMP}/testImage.bigtif GTiff "BIGTIFF=YES") gdal_try_run(FATAL_ERROR GDAL_CAN_CREATE_JPEG gdalCreateCopyTest.cxx ${TEMP}/testImage.gtif ${TEMP}/testImage.jpeg JPEG) set(JPEG2000_DRIVER_USED) gdal_try_run(STATUS GDAL_HAS_JP2OpenJPEG gdalFormatsTest.c JP2OpenJPEG) if (GDAL_HAS_JP2OpenJPEG) set(JPEG2000_DRIVER_USED "OpenJPEG") gdal_try_run(STATUS GDAL_CAN_CREATE_JP2OpenJPEG gdalCreateCopyTest.cxx ${TEMP}/testImage.gtif ${TEMP}/testImage.j2k JP2OpenJPEG) endif() gdal_try_run(STATUS GDAL_HAS_JP2KAK gdalFormatsTest.c JP2KAK) if (GDAL_HAS_JP2KAK) set(JPEG2000_DRIVER_USED "Kakadu") gdal_try_run(STATUS GDAL_CAN_CREATE_JP2KAK gdalCreateCopyTest.cxx ${TEMP}/testImage.gtif ${TEMP}/testImage.j2k JP2KAK) endif() gdal_try_run(STATUS GDAL_HAS_JP2ECW gdalFormatsTest.c JP2ECW) if (GDAL_HAS_JP2ECW) set(JPEG2000_DRIVER_USED "ECW") gdal_try_run(STATUS GDAL_CAN_CREATE_JP2ECW gdalCreateCopyTest.cxx ${TEMP}/testImage.gtif ${TEMP}/testImage.j2k JP2ECW) endif() gdal_try_run(STATUS GDAL_HAS_JPEG2000 gdalFormatsTest.c JPEG2000) if (GDAL_HAS_JPEG2000) set(JPEG2000_DRIVER_USED "JPEG2000") gdal_try_run(STATUS GDAL_CAN_CREATE_JPEG2000 gdalCreateCopyTest.cxx ${TEMP}/testImage.gtif ${TEMP}/testImage.j2k JPEG2000) endif() gdal_try_run(STATUS GDAL_HAS_HDF5 gdalFormatsTest.c HDF5) gdal_try_run(STATUS GDAL_HAS_HDF4 gdalFormatsTest.c HDF4) #check some vector formats #TODO: fix gdalFormatsTest.c to work with gdal 1.x and 2.x # gdal_try_run(FATAL_ERROR GDAL_HAS_SQLite gdalFormatsTest.c SQLite) # gdal_try_run(FATAL_ERROR GDAL_HAS_VRT gdalFormatsTest.c VRT) # gdal_try_run(FATAL_ERROR GDAL_HAS_KML gdalFormatsTest.c KML) # gdal_try_run(STATUS GDAL_HAS_LIBKML gdalFormatsTest.c LIBKML) #------------------- TESTS (END)--------------------- #FOR UNIX SYSTEMS ONLY if(UNIX) # Prepare bash script configure_file(${CMAKE_SOURCE_DIR}/Modules/ThirdParty/GDAL/gdalTest.sh.in ${CMAKE_CURRENT_BINARY_DIR}/gdalTest.sh @ONLY) execute_process(COMMAND chmod u+x ${CMAKE_CURRENT_BINARY_DIR}/gdalTest.sh) execute_process(COMMAND ${CMAKE_CURRENT_BINARY_DIR}/gdalTest.sh) gdal_try_run(FATAL_ERROR GDAL_SYMBOLS gdalSymbolsTest.cxx ARGS ${TEMP}/gdalSymbols.txt) endif() if (NOT JPEG2000_DRIVER_USED) message(STATUS "No Jpeg2000 gdal driver found. Supported drivers are : OpenJpeg, Kakadu, ECW.") elseif("${JPEG2000_DRIVER_USED}" STREQUAL "JPEG2000") message(STATUS "Jasper JPEG2000 gdal driver is available. This will be skipped by OTB. supported drivers are OpenJPEG, ECW, Kakadu") unset(JPEG2000_DRIVER_USED) else() message(STATUS "GDAL driver used for JPEG2000 dataset is '${JPEG2000_DRIVER_USED}'") endif()OTB-release-5.8/Modules/ThirdParty/GDAL/otb-module.cmake000066400000000000000000000002421301006202600226760ustar00rootroot00000000000000set(DOCUMENTATION "This module imports GDAL to the build system") otb_module(OTBGDAL DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/GLFW/000077500000000000000000000000001301006202600176575ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/GLFW/CMakeLists.txt000066400000000000000000000002341301006202600224160ustar00rootroot00000000000000project(OTBGLFW) set(OTBGLFW_THIRD_PARTY 1) set(OTBGLFW_SYSTEM_INCLUDE_DIRS ${GLFW_INCLUDE_DIR}) set(OTBGLFW_LIBRARIES ${GLFW_LIBRARY}) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/GLFW/otb-module-init.cmake000066400000000000000000000001371301006202600236720ustar00rootroot00000000000000find_package(GLFW REQUIRED) mark_as_advanced(GLFW_INCLUDE_DIR) mark_as_advanced(GLFW_LIBRARY) OTB-release-5.8/Modules/ThirdParty/GLFW/otb-module.cmake000066400000000000000000000003541301006202600227320ustar00rootroot00000000000000set(DOCUMENTATION "This module imports GLFW to the build system") otb_module(OTBGLFW DEPENDS OTBOpenGL TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable GLFW dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/GeoTIFF/000077500000000000000000000000001301006202600203035ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/GeoTIFF/CMakeLists.txt000066400000000000000000000002251301006202600230420ustar00rootroot00000000000000project(OTBGeoTIFF) set(OTBGeoTIFF_SYSTEM_INCLUDE_DIRS ${GEOTIFF_INCLUDE_DIRS}) set(OTBGeoTIFF_LIBRARIES "${GEOTIFF_LIBRARIES}") otb_module_impl() OTB-release-5.8/Modules/ThirdParty/GeoTIFF/otb-module-init.cmake000066400000000000000000000000421301006202600243110ustar00rootroot00000000000000find_package ( GeoTIFF REQUIRED ) OTB-release-5.8/Modules/ThirdParty/GeoTIFF/otb-module.cmake000066400000000000000000000002501301006202600233510ustar00rootroot00000000000000set(DOCUMENTATION "This module imports GeoTIFF to the build system") otb_module(OTBGeoTIFF DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/Glew/000077500000000000000000000000001301006202600200165ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Glew/CMakeLists.txt000066400000000000000000000002341301006202600225550ustar00rootroot00000000000000project(OTBGlew) set(OTBGlew_THIRD_PARTY 1) set(OTBGlew_SYSTEM_INCLUDE_DIRS ${GLEW_INCLUDE_DIR}) set(OTBGlew_LIBRARIES ${GLEW_LIBRARY}) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/Glew/otb-module-init.cmake000066400000000000000000000003131301006202600240250ustar00rootroot00000000000000find_package(GLEW REQUIRED) mark_as_advanced(GLEW_INCLUDE_DIR) mark_as_advanced(GLEW_LIBRARY) if(NOT GLEW_FOUND) message(FATAL_ERROR "Cannot find Glew. Set GLEW_INCLUDE_DIR and GLEW_LIBRARY") endif() OTB-release-5.8/Modules/ThirdParty/Glew/otb-module.cmake000066400000000000000000000003541301006202600230710ustar00rootroot00000000000000set(DOCUMENTATION "This module imports Glew to the build system") otb_module(OTBGlew DEPENDS OTBOpenGL TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable Glew dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/Glut/000077500000000000000000000000001301006202600200335ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Glut/CMakeLists.txt000066400000000000000000000002411301006202600225700ustar00rootroot00000000000000project(OTBGlut) set(OTBGlut_THIRD_PARTY 1) set(OTBGlut_SYSTEM_INCLUDE_DIRS ${GLUT_INCLUDE_DIR}) set(OTBGlut_LIBRARIES ${GLUT_glut_LIBRARY}) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/Glut/otb-module-init.cmake000066400000000000000000000003131301006202600240420ustar00rootroot00000000000000find_package(GLUT REQUIRED) mark_as_advanced(GLUT_INCLUDE_DIR) mark_as_advanced(GLUT_LIBRARY) if(NOT GLUT_FOUND) message(FATAL_ERROR "Cannot find GLUT. Set GLUT_INCLUDE_DIR and GLUT_LIBRARY") endif() OTB-release-5.8/Modules/ThirdParty/Glut/otb-module.cmake000066400000000000000000000003541301006202600231060ustar00rootroot00000000000000set(DOCUMENTATION "This module imports GLUT to the build system") otb_module(OTBGlut DEPENDS OTBOpenGL TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable GLUT dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/ITK/000077500000000000000000000000001301006202600175475ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/ITK/CMakeLists.txt000066400000000000000000000004671301006202600223160ustar00rootroot00000000000000project(OTBITK) set(OTBITK_SYSTEM_INCLUDE_DIRS ${ITK_INCLUDE_DIRS}) set(OTBITK_LIBRARIES "${ITK_LIBRARIES}") set(OTBITK_EXPORT_CODE_BUILD "find_package(ITK REQUIRED COMPONENTS ${OTBITK_ITK_REQUIRED_MODULE_LIST} HINTS ${ITK_DIR})") set(OTBITK_EXPORT_CODE_INSTALL ${OTBITK_EXPORT_CODE_BUILD}) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/ITK/include/000077500000000000000000000000001301006202600211725ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/ITK/include/itkImageRegionMultidimensionalSplitter.h000066400000000000000000000120721301006202600312300ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef __itkImageRegionMultidimensionalSplitter_h #define __itkImageRegionMultidimensionalSplitter_h #ifndef itkImageRegionMultidimensionalSplitter_h #define itkImageRegionMultidimensionalSplitter_h #include "itkRegion.h" #include "itkIndex.h" #include "itkImageRegionSplitter.h" namespace itk { /** \class ImageRegionMultidimensionalSplitter * \brief Divide a region into several pieces. * * ImageRegionMultidimensionalSplitter divides an ImageRegion into * smaller regions. ImageRegionMultidimensionalSplitter is used by * the StreamingImageFilter to divide a requested output region into a * series of smaller requests of the pipeline. This object has two * basic methods: GetNumberOfSplits() and GetSplit(). * * GetNumberOfSplits() is used to determine how may subregions a given * region can be divided. You call GetNumberOfSplits with an argument * that is the number of subregions you want. If the image region can * support that number of subregions, that number is returned. * Otherwise, the maximum number of splits less then or equal to the * argumen be returned. For example, if a region splitter class only divides * a region into horizontal slabs, then the maximum number of splits * will be the number of rows in the region. * * GetSplit() returns the ith of N subregions (as an ImageRegion object). * * ImageRegionMultidimensionalSplitter class divides a region * into hypercubes (as opposed to the slabs used by the superclass * ImageRegionSplitter). In other words, it splits every dimension of the * region to form ND rectangular prisms. * * \deprecated The new class ImageRegionSplitterMultidimensional can be * used as a drop in replacement for the same functionality as it * implements the same algorithm. * * \ingroup ITKDeprecated * * \ingroup OTBITK */ template< unsigned int VImageDimension > class ITK_EXPORT ImageRegionMultidimensionalSplitter:public ImageRegionSplitter< VImageDimension > { public: /** Standard class typedefs. */ typedef ImageRegionMultidimensionalSplitter Self; typedef ImageRegionSplitter< VImageDimension > Superclass; typedef SmartPointer< Self > Pointer; typedef SmartPointer< const Self > ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageRegionMultidimensionalSplitter, ImageRegionSplitter); /** Dimension of the image available at compile time. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Index typedef support. An index is used to access pixel values. */ typedef Index< VImageDimension > IndexType; /** Size typedef support. A size is used to define region bounds. */ typedef Size< VImageDimension > SizeType; /** Region typedef support. */ typedef ImageRegion< VImageDimension > RegionType; /** How many pieces can the specified region be split? A given region * cannot always be divided into the requested number of pieces. For * instance, if the numberOfPieces exceeds the number of pixels along * a certain dimensions, then some splits will not be possible. This * method returns a number less than or equal to the requested number * of pieces. */ virtual unsigned int GetNumberOfSplits(const RegionType & region, unsigned int requestedNumber); /** Get a region definition that represents the ith piece a specified region. * The "numberOfPieces" must be equal to what * GetNumberOfSplits() returns. */ virtual RegionType GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType & region); protected: ImageRegionMultidimensionalSplitter() {} ~ImageRegionMultidimensionalSplitter() {} void PrintSelf(std::ostream & os, Indent indent) const; private: ImageRegionMultidimensionalSplitter(const Self &); //purposely not implemented void operator=(const Self &); //purposely not implemented static unsigned int ComputeSplits(unsigned int numberOfPieces, const RegionType ®ion, unsigned int splits[]); }; } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION #include "itkImageRegionMultidimensionalSplitter.hxx" #endif #endif #endif OTB-release-5.8/Modules/ThirdParty/ITK/include/itkImageRegionMultidimensionalSplitter.hxx000066400000000000000000000130751301006202600316140ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef itkImageRegionMultidimensionalSplitter_hxx #define itkImageRegionMultidimensionalSplitter_hxx #include "itkImageRegionMultidimensionalSplitter.h" #include namespace itk { /** * */ template< unsigned int VImageDimension > unsigned int ImageRegionMultidimensionalSplitter< VImageDimension > ::GetNumberOfSplits(const RegionType & region, unsigned int requestedNumber) { unsigned int splits[VImageDimension]; // number of splits in each dimension unsigned int numPieces = this->ComputeSplits(requestedNumber, region, splits); return numPieces; } /** * */ template< unsigned int VImageDimension > ImageRegion< VImageDimension > ImageRegionMultidimensionalSplitter< VImageDimension > ::GetSplit(unsigned int splitI, unsigned int numberOfPieces, const RegionType & region) { RegionType splitRegion; IndexType splitIndex; SizeType splitSize, regionSize; // Initialize the splitRegion to the requested region splitRegion = region; splitIndex = splitRegion.GetIndex(); splitSize = splitRegion.GetSize(); regionSize = region.GetSize(); unsigned int splits[VImageDimension]; // number of splits in each // dimension if ( numberOfPieces != this->ComputeSplits(numberOfPieces, region, splits) ) { itkExceptionMacro( "numberOfPieces did not match GetNumberOfSplits. Expected: " << numberOfPieces << " but got" << this->ComputeSplits(numberOfPieces, region, splits) ); } unsigned int splitRegionIndex[VImageDimension]; // index into split // regions unsigned int i; // determine which split region we are in unsigned int offset = splitI; for ( i = VImageDimension - 1; i > 0; i-- ) { unsigned int dimensionOffset = 1; for ( unsigned int j = 0; j < i; ++j ) { dimensionOffset *= splits[j]; } splitRegionIndex[i] = offset / dimensionOffset; offset -= ( splitRegionIndex[i] * dimensionOffset ); } splitRegionIndex[0] = offset; // compute the region size and index for ( i = 0; i < VImageDimension; i++ ) { splitIndex[i] += Math::Floor( ( splitRegionIndex[i] ) * ( regionSize[i] / double(splits[i]) ) ); if ( splitRegionIndex[i] < splits[i] - 1 ) { splitSize[i] = Math::Floor( ( splitRegionIndex[i] + 1 ) * ( regionSize[i] / double(splits[i]) ) ) - splitIndex[i]; } else { // this dimension is falling off the edge of the image splitSize[i] = regionSize[i] - splitIndex[i]; } } // set the split region ivars splitRegion.SetIndex(splitIndex); splitRegion.SetSize(splitSize); itkDebugMacro(" Split Piece: " << std::endl << splitRegion); return splitRegion; } /** * */ template< unsigned int VImageDimension > void ImageRegionMultidimensionalSplitter< VImageDimension > ::PrintSelf(std::ostream & os, Indent indent) const { Superclass::PrintSelf(os, indent); } /** * given the requestedNumber of regions to split the "region" argument * into, it retures the number of split regions in each dimension * as "splits" and returns the total number of split regions */ template< unsigned int VImageDimension > unsigned int ImageRegionMultidimensionalSplitter< VImageDimension > ::ComputeSplits(unsigned int requestedNumber, const RegionType & region, unsigned int splits[]) { const SizeType & regionSize = region.GetSize(); double splitRegionSize[VImageDimension]; // size of each splited // region unsigned int i; unsigned int numPieces = 1; // initialize arrays for ( i = 0; i < VImageDimension; ++i ) { splits[i] = 1; splitRegionSize[i] = regionSize[i]; } while ( true ) { // find the dimension with the largest size unsigned int maxSplitDim = 0; for ( i = 1; i < VImageDimension; ++i ) { if ( splitRegionSize[maxSplitDim] < splitRegionSize[i] ) { maxSplitDim = i; } } // calculate the number of additional pieces this split would add unsigned int additionalNumPieces = 1; for ( i = 0; i < VImageDimension; ++i ) { if ( i != maxSplitDim ) { additionalNumPieces *= splits[i]; } } // check if this would give us too many pieces or // if this would require the subpixel splits if ( numPieces + additionalNumPieces > requestedNumber || splits[maxSplitDim] == regionSize[maxSplitDim] ) { return numPieces; } // update the variable with the new split numPieces += additionalNumPieces; ++splits[maxSplitDim]; splitRegionSize[maxSplitDim] = regionSize[maxSplitDim] / double(splits[maxSplitDim]); } } } // end namespace itk #endif OTB-release-5.8/Modules/ThirdParty/ITK/include/itkImageRegionSplitter.h000066400000000000000000000153451301006202600260000ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef __itkImageRegionSplitter_h #define __itkImageRegionSplitter_h #ifndef itkImageRegionSplitter_h #define itkImageRegionSplitter_h #include "itkImageRegion.h" #include "itkImageRegionSplitterBase.h" namespace itk { /** \class ImageRegionSplitter * \brief Divide a region into several pieces. * * ImageRegionSplitter divides an ImageRegion into smaller regions. * ImageRegionSplitter is used by the StreamingImageFilter to divide a * requested output region into a series of smaller requests of the * pipeline. This object has two basic methods: GetNumberOfSplits() * and GetSplit(). * * GetNumberOfSplits() is used to determine how may subregions a given * region can be divided. You call GetNumberOfSplits with an argument * that is the number of subregions you want. If the image region can * support that number of subregions, that number is returned. * Otherwise, the maximum number of splits less then or equal to the * argumen be returned. For example, if a region splitter class only divides * a region into horizontal slabs, then the maximum number of splits * will be the number of rows in the region. * * GetSplit() returns the ith of N subregions (as an ImageRegion object). * * This ImageRegionSplitter class divides a region along the outermost * dimension. If the outermost dimension has size 1 (i.e. a volume * with a single slice), the ImageRegionSplitter will divide the * region along the next outermost dimension. If that dimension has size 1, * the process continues with the next outermost dimension. * * Other ImageRegionSplitter subclasses could divide an image into * more uniform shaped regions instead of slabs. * * \deprecated The new class ImageRegionSplitterSlowDimension can be * used as a drop in replacement for functionality as it * implements the same algorithm. The ImageRegionSplitterBase is now * the abstract base class for all image splitter. New splitting * object should be derived from that class. * * \sa ImageRegionSplitterSlowDimension * \sa ImageRegionSplitterBase * * \ingroup ITKDeprecated * * \ingroup OTBITK */ template< unsigned int VImageDimension > class ITK_EXPORT ImageRegionSplitter:public ImageRegionSplitterBase { public: /** Standard class typedefs. */ typedef ImageRegionSplitter Self; typedef ImageRegionSplitterBase Superclass; typedef SmartPointer< Self > Pointer; typedef SmartPointer< const Self > ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ImageRegionSplitter, Object); /** Dimension of the image available at compile time. */ itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension); /** Dimension of the image available at run time. */ static unsigned int GetImageDimension() { return VImageDimension; } /** Index typedef support. An index is used to access pixel values. */ typedef Index< VImageDimension > IndexType; /** Size typedef support. A size is used to define region bounds. */ typedef Size< VImageDimension > SizeType; typedef typename SizeType::SizeValueType SizeValueType; /** Region typedef support. */ typedef ImageRegion< VImageDimension > RegionType; /** How many pieces can the specified region be split? A given region * cannot always be divided into the requested number of pieces. For * instance, if the numberOfPieces exceeds the number of pixels along * a certain dimensions, then some splits will not be possible. This * method returns a number less than or equal to the requested number * of pieces. */ virtual unsigned int GetNumberOfSplits(const RegionType & region, unsigned int requestedNumber); /** Get a region definition that represents the ith piece a specified region. * The "numberOfPieces" must be equal to what * GetNumberOfSplits() returns. */ virtual RegionType GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType & region); protected: ImageRegionSplitter() {} ~ImageRegionSplitter() ITK_OVERRIDE {} unsigned int GetNumberOfSplitsInternal(unsigned int, const IndexValueType regionIndex[], const SizeValueType regionSize[], unsigned int requestedNumber) const ITK_OVERRIDE { // this function adapts the legecy method, defined in this class // be used by the ImageRegionSplitterBase. IndexType idx; idx.SetIndex( regionIndex ); SizeType sz; sz.SetSize( regionSize ); RegionType region = RegionType(idx, sz); Self *nonconst_this = const_cast(this); return nonconst_this->GetNumberOfSplits(region, requestedNumber); } unsigned int GetSplitInternal(unsigned int dim, unsigned int i, unsigned int numberOfPieces, IndexValueType regionIndex[], SizeValueType regionSize[]) const ITK_OVERRIDE { // this function adapts the legecy method, defined in this class // be used by the ImageRegionSplitterBase. IndexType idx; idx.SetIndex( regionIndex ); SizeType sz; sz.SetSize( regionSize ); RegionType region = RegionType(idx, sz); Self *nonconst_this = const_cast(this); region = nonconst_this->GetSplit(i, numberOfPieces, region); for (unsigned int d = 0; d < dim; ++d) { regionIndex[d] = region.GetIndex(d); regionSize[d] = region.GetSize(d); } return numberOfPieces; } void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE; private: ImageRegionSplitter(const ImageRegionSplitter &); //purposely not implemented void operator=(const ImageRegionSplitter &); //purposely not implemented }; } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION #include "itkImageRegionSplitter.hxx" #endif #endif #endif OTB-release-5.8/Modules/ThirdParty/ITK/include/itkImageRegionSplitter.hxx000066400000000000000000000070641301006202600263570ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef itkImageRegionSplitter_hxx #define itkImageRegionSplitter_hxx #include "itkImageRegionSplitter.h" #include namespace itk { /** * */ template< unsigned int VImageDimension > unsigned int ImageRegionSplitter< VImageDimension > ::GetNumberOfSplits(const RegionType & region, unsigned int requestedNumber) { const SizeType & regionSize = region.GetSize(); // split on the outermost dimension available int splitAxis = VImageDimension - 1; while ( regionSize[splitAxis] == 1 ) { --splitAxis; if ( splitAxis < 0 ) { // cannot split itkDebugMacro(" Cannot Split"); return 1; } } // determine the actual number of pieces that will be generated const SizeValueType range = regionSize[splitAxis]; const unsigned int valuesPerPiece = Math::Ceil< unsigned int >(range / (double)requestedNumber); const unsigned int maxPieceUsed = Math::Ceil< unsigned int >(range / (double)valuesPerPiece) - 1; return maxPieceUsed + 1; } /** * */ template< unsigned int VImageDimension > ImageRegion< VImageDimension > ImageRegionSplitter< VImageDimension > ::GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType & region) { int splitAxis; RegionType splitRegion; IndexType splitIndex; SizeType splitSize, regionSize; // Initialize the splitRegion to the requested region splitRegion = region; splitIndex = splitRegion.GetIndex(); splitSize = splitRegion.GetSize(); regionSize = region.GetSize(); // split on the outermost dimension available splitAxis = VImageDimension - 1; while ( regionSize[splitAxis] == 1 ) { --splitAxis; if ( splitAxis < 0 ) { // cannot split itkDebugMacro(" Cannot Split"); return splitRegion; } } // determine the actual number of pieces that will be generated SizeValueType range = regionSize[splitAxis]; int valuesPerPiece = Math::Ceil< int >(range / (double)numberOfPieces); int maxPieceUsed = Math::Ceil< int >(range / (double)valuesPerPiece) - 1; // Split the region if ( (int)i < maxPieceUsed ) { splitIndex[splitAxis] += i * valuesPerPiece; splitSize[splitAxis] = valuesPerPiece; } if ( (int)i == maxPieceUsed ) { splitIndex[splitAxis] += i * valuesPerPiece; // last piece needs to process the "rest" dimension being split splitSize[splitAxis] = splitSize[splitAxis] - i * valuesPerPiece; } // set the split region ivars splitRegion.SetIndex(splitIndex); splitRegion.SetSize(splitSize); itkDebugMacro(" Split Piece: " << splitRegion); return splitRegion; } /** * */ template< unsigned int VImageDimension > void ImageRegionSplitter< VImageDimension > ::PrintSelf(std::ostream & os, Indent indent) const { Superclass::PrintSelf(os, indent); } } // end namespace itk #endif OTB-release-5.8/Modules/ThirdParty/ITK/include/itkTransformToDisplacementFieldSource.h000066400000000000000000000211361301006202600310120ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef __itkTransformToDisplacementFieldSource_h #define __itkTransformToDisplacementFieldSource_h #ifndef itkTransformToDisplacementFieldSource_h #define itkTransformToDisplacementFieldSource_h #include "itkTransform.h" #include "itkImageSource.h" namespace itk { /** \class TransformToDisplacementFieldSource * \brief Generate a displacement field from a coordinate transform * * Output information (spacing, size and direction) for the output * image should be set. This information has the normal defaults of * unit spacing, zero origin and identity direction. Optionally, the * output information can be obtained from a reference image. If the * reference image is provided and UseReferenceImage is On, then the * spacing, origin and direction of the reference image will be used. * * Since this filter produces an image which is a different size than * its input, it needs to ITK_OVERRIDE several of the methods defined * in ProcessObject in order to properly manage the pipeline execution model. * In particular, this filter ITK_OVERRIDEs * ProcessObject::GenerateInputRequestedRegion() and * ProcessObject::GenerateOutputInformation(). * * This filter is implemented as a multithreaded filter. It provides a * ThreadedGenerateData() method for its implementation. * * \author Marius Staring, Leiden University Medical Center, The Netherlands. * * This class was taken from the Insight Journal paper: * http://hdl.handle.net/1926/1387 * * \ingroup GeometricTransform * \ingroup ITKReview * * \ingroup OTBITK */ template< class TOutputImage, class TTransformPrecisionType = double > class ITK_EXPORT TransformToDisplacementFieldSource: public ImageSource< TOutputImage > { public: /** Standard class typedefs. */ typedef TransformToDisplacementFieldSource Self; typedef ImageSource< TOutputImage > Superclass; typedef SmartPointer< Self > Pointer; typedef SmartPointer< const Self > ConstPointer; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::ConstPointer OutputImageConstPointer; typedef typename OutputImageType::RegionType OutputImageRegionType; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(TransformToDisplacementFieldSource, ImageSource); /** Number of dimensions. */ itkStaticConstMacro(ImageDimension, unsigned int, TOutputImage::ImageDimension); /** Typedefs for transform. */ typedef Transform< TTransformPrecisionType, itkGetStaticConstMacro(ImageDimension), itkGetStaticConstMacro(ImageDimension) > TransformType; typedef typename TransformType::ConstPointer TransformPointerType; /** Typedefs for output image. */ typedef typename OutputImageType::PixelType PixelType; typedef typename PixelType::ValueType PixelValueType; typedef typename OutputImageType::RegionType RegionType; typedef typename RegionType::SizeType SizeType; typedef typename OutputImageType::IndexType IndexType; typedef typename OutputImageType::PointType PointType; typedef typename OutputImageType::SpacingType SpacingType; typedef typename OutputImageType::PointType OriginType; typedef typename OutputImageType::DirectionType DirectionType; /** Typedefs for base image. */ typedef ImageBase< itkGetStaticConstMacro(ImageDimension) > ImageBaseType; /** Get/Set the coordinate transformation. * Set the coordinate transform to use for resampling. Note that this must * be in physical coordinates and it is the output-to-input transform, NOT * the input-to-output transform that you might naively expect. By default * the filter uses an Identity transform. You must provide a different * transform here, before attempting to run the filter, if you do not want to * use the default Identity transform. */ itkSetConstObjectMacro(Transform, TransformType); itkGetConstObjectMacro(Transform, TransformType); /** Set the size of the output image. */ virtual void SetOutputSize(const SizeType & size); /** Get the size of the output image. */ virtual const SizeType & GetOutputSize(); /** Set the start index of the output largest possible region. * The default is an index of all zeros. */ virtual void SetOutputIndex(const IndexType & index); /** Get the start index of the output largest possible region. */ virtual const IndexType & GetOutputIndex(); /** Set the region of the output image. */ itkSetMacro(OutputRegion, OutputImageRegionType); /** Get the region of the output image. */ itkGetConstReferenceMacro(OutputRegion, OutputImageRegionType); /** Set the output image spacing. */ itkSetMacro(OutputSpacing, SpacingType); virtual void SetOutputSpacing(const double *values); /** Get the output image spacing. */ itkGetConstReferenceMacro(OutputSpacing, SpacingType); /** Set the output image origin. */ itkSetMacro(OutputOrigin, OriginType); virtual void SetOutputOrigin(const double *values); /** Get the output image origin. */ itkGetConstReferenceMacro(OutputOrigin, OriginType); /** Set the output direction cosine matrix. */ itkSetMacro(OutputDirection, DirectionType); itkGetConstReferenceMacro(OutputDirection, DirectionType); /** Helper method to set the output parameters based on this image */ void SetOutputParametersFromImage(const ImageBaseType *image); /** DisplacementFieldImageFilter produces a vector image. */ void GenerateOutputInformation(void) ITK_OVERRIDE; /** Just checking if transform is set. */ void BeforeThreadedGenerateData(void) ITK_OVERRIDE; /** Compute the Modified Time based on changes to the components. */ ModifiedTimeType GetMTime(void) const ITK_OVERRIDE; #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkStaticConstMacro(PixelDimension, unsigned int, PixelType::Dimension); itkConceptMacro( SameDimensionCheck, ( Concept::SameDimension< ImageDimension, PixelDimension > ) ); /** End concept checking */ #endif protected: TransformToDisplacementFieldSource(void); ~TransformToDisplacementFieldSource(void) ITK_OVERRIDE {} void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE; /** TransformToDisplacementFieldSource can be implemented as a multithreaded * filter. */ void ThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) ITK_OVERRIDE; /** Default implementation for resampling that works for any * transformation type. */ void NonlinearThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId); /** Faster implementation for resampling that works for with linear * transformation types. */ void LinearThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId); private: TransformToDisplacementFieldSource(const Self &); //purposely not implemented void operator=(const Self &); //purposely not implemented /** Member variables. */ RegionType m_OutputRegion; // region of the output image TransformPointerType m_Transform; // Coordinate transform to use SpacingType m_OutputSpacing; // output image spacing OriginType m_OutputOrigin; // output image origin DirectionType m_OutputDirection; // output image direction cosines }; // end class // TransformToDisplacementFieldSource } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION #include "itkTransformToDisplacementFieldSource.hxx" #endif #endif #endif // end #ifndef __itkTransformToDisplacementFieldSource_h OTB-release-5.8/Modules/ThirdParty/ITK/include/itkTransformToDisplacementFieldSource.hxx000066400000000000000000000277011301006202600313760ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef itkTransformToDisplacementFieldSource_hxx #define itkTransformToDisplacementFieldSource_hxx #include "itkTransformToDisplacementFieldSource.h" #include "itkIdentityTransform.h" #include "itkProgressReporter.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkImageLinearIteratorWithIndex.h" namespace itk { /** * Constructor */ template< class TOutputImage, class TTransformPrecisionType > TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::TransformToDisplacementFieldSource() { this->m_OutputSpacing.Fill(1.0); this->m_OutputOrigin.Fill(0.0); this->m_OutputDirection.SetIdentity(); SizeType size; size.Fill(0); this->m_OutputRegion.SetSize(size); IndexType index; index.Fill(0); this->m_OutputRegion.SetIndex(index); this->m_Transform = IdentityTransform< TTransformPrecisionType, ImageDimension >::New(); } // end Constructor /** * Print out a description of self * * \todo Add details about this class */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::PrintSelf(std::ostream & os, Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "OutputRegion: " << this->m_OutputRegion << std::endl; os << indent << "OutputSpacing: " << this->m_OutputSpacing << std::endl; os << indent << "OutputOrigin: " << this->m_OutputOrigin << std::endl; os << indent << "OutputDirection: " << this->m_OutputDirection << std::endl; os << indent << "Transform: " << this->m_Transform.GetPointer() << std::endl; } // end PrintSelf() /** * Set the output image size. */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::SetOutputSize(const SizeType & size) { this->m_OutputRegion.SetSize(size); } /** * Get the output image size. */ template< class TOutputImage, class TTransformPrecisionType > const typename TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::SizeType & TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::GetOutputSize() { return this->m_OutputRegion.GetSize(); } /** * Set the output image index. */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::SetOutputIndex(const IndexType & index) { this->m_OutputRegion.SetIndex(index); } /** * Get the output image index. */ template< class TOutputImage, class TTransformPrecisionType > const typename TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::IndexType & TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::GetOutputIndex() { return this->m_OutputRegion.GetIndex(); } /** * Set the output image spacing. */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::SetOutputSpacing(const double *spacing) { SpacingType s(spacing); this->SetOutputSpacing(s); } // end SetOutputSpacing() /** * Set the output image origin. */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::SetOutputOrigin(const double *origin) { OriginType p(origin); this->SetOutputOrigin(p); } /** Helper method to set the output parameters based on this image */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::SetOutputParametersFromImage(const ImageBaseType *image) { if ( !image ) { itkExceptionMacro(<< "Cannot use a null image reference"); } this->SetOutputOrigin( image->GetOrigin() ); this->SetOutputSpacing( image->GetSpacing() ); this->SetOutputDirection( image->GetDirection() ); this->SetOutputRegion( image->GetLargestPossibleRegion() ); } // end SetOutputParametersFromImage() /** * Set up state of filter before multi-threading. * InterpolatorType::SetInputImage is not thread-safe and hence * has to be set up before ThreadedGenerateData */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::BeforeThreadedGenerateData(void) { if ( !this->m_Transform ) { itkExceptionMacro(<< "Transform not set"); } } // end BeforeThreadedGenerateData() /** * ThreadedGenerateData */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::ThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) { // Check whether we can use a fast path for resampling. Fast path // can be used if the transformation is linear. Transform respond // to the IsLinear() call. if ( this->m_Transform->IsLinear() ) { this->LinearThreadedGenerateData(outputRegionForThread, threadId); return; } // Otherwise, we use the normal method where the transform is called // for computing the transformation of every point. this->NonlinearThreadedGenerateData(outputRegionForThread, threadId); } // end ThreadedGenerateData() template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::NonlinearThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) { // Get the output pointer OutputImagePointer outputPtr = this->GetOutput(); // Create an iterator that will walk the output region for this thread. typedef ImageRegionIteratorWithIndex< TOutputImage > OutputIteratorType; OutputIteratorType outIt(outputPtr, outputRegionForThread); // Define a few variables that will be used to translate from an input pixel // to an output pixel PointType outputPoint; // Coordinates of output pixel PointType transformedPoint; // Coordinates of transformed pixel PixelType deformation; // the difference // Support for progress methods/callbacks ProgressReporter progress( this, threadId, outputRegionForThread.GetNumberOfPixels() ); // Walk the output region outIt.GoToBegin(); while ( !outIt.IsAtEnd() ) { // Determine the index of the current output pixel outputPtr->TransformIndexToPhysicalPoint(outIt.GetIndex(), outputPoint); // Compute corresponding input pixel position transformedPoint = this->m_Transform->TransformPoint(outputPoint); // Compute the deformation for ( unsigned int i = 0; i < ImageDimension; ++i ) { deformation[i] = static_cast< PixelValueType >( transformedPoint[i] - outputPoint[i] ); } // Set it outIt.Set(deformation); // Update progress and iterator progress.CompletedPixel(); ++outIt; } } // end NonlinearThreadedGenerateData() template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::LinearThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) { // Get the output pointer OutputImagePointer outputPtr = this->GetOutput(); // Create an iterator that will walk the output region for this thread. typedef ImageLinearIteratorWithIndex< TOutputImage > OutputIteratorType; OutputIteratorType outIt(outputPtr, outputRegionForThread); outIt.SetDirection(0); // Define a few indices that will be used to translate from an input pixel // to an output pixel PointType outputPoint; // Coordinates of current output pixel PointType transformedPoint; // Coordinates of transformed pixel PixelType deformation; // the difference IndexType index; // Support for progress methods/callbacks ProgressReporter progress( this, threadId, outputRegionForThread.GetNumberOfPixels() ); // Determine the position of the first pixel in the scanline outIt.GoToBegin(); index = outIt.GetIndex(); outputPtr->TransformIndexToPhysicalPoint(index, outputPoint); // Compute corresponding transformed pixel position transformedPoint = this->m_Transform->TransformPoint(outputPoint); // Compare with the ResampleImageFilter // Compute delta PointType outputPointNeighbour; PointType transformedPointNeighbour; typedef typename PointType::VectorType VectorType; VectorType delta; ++index[0]; outputPtr->TransformIndexToPhysicalPoint(index, outputPointNeighbour); transformedPointNeighbour = this->m_Transform->TransformPoint( outputPointNeighbour); delta = transformedPointNeighbour - transformedPoint - ( outputPointNeighbour - outputPoint ); // loop over the vector image while ( !outIt.IsAtEnd() ) { // Get current point index = outIt.GetIndex(); outputPtr->TransformIndexToPhysicalPoint(index, outputPoint); // Compute transformed point transformedPoint = this->m_Transform->TransformPoint(outputPoint); while ( !outIt.IsAtEndOfLine() ) { // Compute the deformation for ( unsigned int i = 0; i < ImageDimension; ++i ) { deformation[i] = static_cast< PixelValueType >( transformedPoint[i] - outputPoint[i] ); } // Set it outIt.Set(deformation); // Update stuff progress.CompletedPixel(); ++outIt; transformedPoint += delta; } outIt.NextLine(); } } // end LinearThreadedGenerateData() /** * Inform pipeline of required output region */ template< class TOutputImage, class TTransformPrecisionType > void TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::GenerateOutputInformation(void) { // call the superclass' implementation of this method Superclass::GenerateOutputInformation(); // get pointer to the output OutputImagePointer outputPtr = this->GetOutput(); if ( !outputPtr ) { return; } outputPtr->SetLargestPossibleRegion(m_OutputRegion); outputPtr->SetSpacing(m_OutputSpacing); outputPtr->SetOrigin(m_OutputOrigin); outputPtr->SetDirection(m_OutputDirection); } // end GenerateOutputInformation() /** * Verify if any of the components has been modified. */ template< class TOutputImage, class TTransformPrecisionType > ModifiedTimeType TransformToDisplacementFieldSource< TOutputImage, TTransformPrecisionType > ::GetMTime(void) const { ModifiedTimeType latestTime = Object::GetMTime(); if ( this->m_Transform ) { if ( latestTime < this->m_Transform->GetMTime() ) { latestTime = this->m_Transform->GetMTime(); } } return latestTime; } // end GetMTime() } // end namespace itk #endif // end #ifndef _itkTransformToDisplacementFieldSource_hxx OTB-release-5.8/Modules/ThirdParty/ITK/include/itkUnaryFunctorImageFilter.h000066400000000000000000000127121301006202600266260ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef __itkUnaryFunctorImageFilter_h #define __itkUnaryFunctorImageFilter_h #ifndef itkUnaryFunctorImageFilter_h #define itkUnaryFunctorImageFilter_h #include "itkInPlaceImageFilter.h" #include "itkImageRegionIteratorWithIndex.h" namespace itk { /** \class UnaryFunctorImageFilter * \brief Implements pixel-wise generic operation on one image. * * This class is parameterized over the type of the input image and * the type of the output image. It is also parameterized by the * operation to be applied, using a Functor style. * * UnaryFunctorImageFilter allows the output dimension of the filter * to be larger than the input dimension. Thus subclasses of the * UnaryFunctorImageFilter (like the CastImageFilter) can be used * to promote a 2D image to a 3D image, etc. * * \sa BinaryFunctorImageFilter TernaryFunctorImageFilter * * \ingroup IntensityImageFilters MultiThreaded * \ingroup ITKCommon * * \wiki * \wikiexample{ImageProcessing/UnaryFunctorImageFilter,Apply a custom operation to each pixel in an image} * \endwiki * * \ingroup OTBITK */ template< class TInputImage, class TOutputImage, class TFunction > class ITK_EXPORT UnaryFunctorImageFilter:public InPlaceImageFilter< TInputImage, TOutputImage > { public: /** Standard class typedefs. */ typedef UnaryFunctorImageFilter Self; typedef InPlaceImageFilter< TInputImage, TOutputImage > Superclass; typedef SmartPointer< Self > Pointer; typedef SmartPointer< const Self > ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorImageFilter, InPlaceImageFilter); /** Some typedefs. */ typedef TFunction FunctorType; typedef TInputImage InputImageType; typedef typename InputImageType::ConstPointer InputImagePointer; typedef typename InputImageType::RegionType InputImageRegionType; typedef typename InputImageType::PixelType InputImagePixelType; typedef TOutputImage OutputImageType; typedef typename OutputImageType::Pointer OutputImagePointer; typedef typename OutputImageType::RegionType OutputImageRegionType; typedef typename OutputImageType::PixelType OutputImagePixelType; /** Get the functor object. The functor is returned by reference. * (Functors do not have to derive from itk::LightObject, so they do * not necessarily have a reference count. So we cannot return a * SmartPointer.) */ FunctorType & GetFunctor() { return m_Functor; } const FunctorType & GetFunctor() const { return m_Functor; } /** Set the functor object. This replaces the current Functor with a * copy of the specified Functor. This allows the user to specify a * functor that has ivars set differently than the default functor. * This method requires an operator!=() be defined on the functor * (or the compiler's default implementation of operator!=() being * appropriate). */ void SetFunctor(const FunctorType & functor) { if ( m_Functor != functor ) { m_Functor = functor; this->Modified(); } } protected: UnaryFunctorImageFilter(); ~UnaryFunctorImageFilter() ITK_OVERRIDE {} /** UnaryFunctorImageFilter can produce an image which is a different * resolution than its input image. As such, UnaryFunctorImageFilter * needs to provide an implementation for * GenerateOutputInformation() in order to inform the pipeline * execution model. The original documentation of this method is * below. * * \sa ProcessObject::GenerateOutputInformaton() */ void GenerateOutputInformation() ITK_OVERRIDE; /** UnaryFunctorImageFilter can be implemented as a multithreaded filter. * Therefore, this implementation provides a ThreadedGenerateData() routine * which is called for each processing thread. The output image data is * allocated automatically by the superclass prior to calling * ThreadedGenerateData(). ThreadedGenerateData can only write to the * portion of the output image specified by the parameter * "outputRegionForThread" * * \sa ImageToImageFilter::ThreadedGenerateData(), * ImageToImageFilter::GenerateData() */ void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) ITK_OVERRIDE; private: UnaryFunctorImageFilter(const Self &); //purposely not implemented void operator=(const Self &); //purposely not implemented FunctorType m_Functor; }; } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION #include "itkUnaryFunctorImageFilter.hxx" #endif #endif #endif OTB-release-5.8/Modules/ThirdParty/ITK/include/itkUnaryFunctorImageFilter.hxx000066400000000000000000000151621301006202600272100ustar00rootroot00000000000000/*========================================================================= * * Copyright Insight Software Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0.txt * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *=========================================================================*/ #ifndef itkUnaryFunctorImageFilter_hxx #define itkUnaryFunctorImageFilter_hxx #include "itkUnaryFunctorImageFilter.h" #include "itkImageScanlineIterator.h" #include "itkProgressReporter.h" namespace itk { /** * Constructor */ template< class TInputImage, class TOutputImage, class TFunction > UnaryFunctorImageFilter< TInputImage, TOutputImage, TFunction > ::UnaryFunctorImageFilter() { this->SetNumberOfRequiredInputs(1); this->InPlaceOff(); } /** * UnaryFunctorImageFilter can produce an image which is a different resolution * than its input image. As such, UnaryFunctorImageFilter needs to provide an * implementation for GenerateOutputInformation() in order to inform * the pipeline execution model. The original documentation of this * method is below. * * \sa ProcessObject::GenerateOutputInformaton() */ template< class TInputImage, class TOutputImage, class TFunction > void UnaryFunctorImageFilter< TInputImage, TOutputImage, TFunction > ::GenerateOutputInformation() { // do not call the superclass' implementation of this method since // this filter allows the input the output to be of different dimensions // get pointers to the input and output typename Superclass::OutputImagePointer outputPtr = this->GetOutput(); typename Superclass::InputImageConstPointer inputPtr = this->GetInput(); if ( !outputPtr || !inputPtr ) { return; } // // Copy information from input to output. If input and output are of // different dimensions, Region information will not be copied. outputPtr->CopyInformation(inputPtr); // // Set the output image largest possible region. Use a RegionCopier // so that the input and output images can be different dimensions. OutputImageRegionType outputLargestPossibleRegion; this->CallCopyInputRegionToOutputRegion( outputLargestPossibleRegion, inputPtr->GetLargestPossibleRegion() ); outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion); // Set the output spacing and origin const ImageBase< Superclass::InputImageDimension > *phyData; phyData = dynamic_cast< const ImageBase< Superclass::InputImageDimension > * >( this->GetInput() ); if ( phyData ) { // Copy what we can from the image from spacing and origin of the input // This logic needs to be augmented with logic that select which // dimensions to copy unsigned int i, j; const typename InputImageType::SpacingType & inputSpacing = inputPtr->GetSpacing(); const typename InputImageType::PointType & inputOrigin = inputPtr->GetOrigin(); const typename InputImageType::DirectionType & inputDirection = inputPtr->GetDirection(); typename OutputImageType::SpacingType outputSpacing; typename OutputImageType::PointType outputOrigin; typename OutputImageType::DirectionType outputDirection; // copy the input to the output and fill the rest of the // output with zeros. for ( i = 0; i < Superclass::InputImageDimension; ++i ) { outputSpacing[i] = inputSpacing[i]; outputOrigin[i] = inputOrigin[i]; for ( j = 0; j < Superclass::OutputImageDimension; j++ ) { if ( j < Superclass::InputImageDimension ) { outputDirection[j][i] = inputDirection[j][i]; } else { outputDirection[j][i] = 0.0; } } } for (; i < Superclass::OutputImageDimension; ++i ) { outputSpacing[i] = 1.0; outputOrigin[i] = 0.0; for ( j = 0; j < Superclass::OutputImageDimension; j++ ) { if ( j == i ) { outputDirection[j][i] = 1.0; } else { outputDirection[j][i] = 0.0; } } } // set the spacing and origin outputPtr->SetSpacing(outputSpacing); outputPtr->SetOrigin(outputOrigin); outputPtr->SetDirection(outputDirection); outputPtr->SetNumberOfComponentsPerPixel( // propagate vector length info inputPtr->GetNumberOfComponentsPerPixel() ); } else { // pointer could not be cast back down itkExceptionMacro( << "itk::UnaryFunctorImageFilter::GenerateOutputInformation " << "cannot cast input to " << typeid( ImageBase< Superclass::InputImageDimension > * ).name() ); } } /** * ThreadedGenerateData Performs the pixel-wise addition */ template< class TInputImage, class TOutputImage, class TFunction > void UnaryFunctorImageFilter< TInputImage, TOutputImage, TFunction > ::ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) { const TInputImage *inputPtr = this->GetInput(); TOutputImage *outputPtr = this->GetOutput(0); // Define the portion of the input to walk for this thread, using // the CallCopyOutputRegionToInputRegion method allows for the input // and output images to be different dimensions InputImageRegionType inputRegionForThread; this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread); // Define the iterators ImageScanlineConstIterator< TInputImage > inputIt(inputPtr, inputRegionForThread); ImageScanlineIterator< TOutputImage > outputIt(outputPtr, outputRegionForThread); inputIt.GoToBegin(); outputIt.GoToBegin(); const size_t numberOfLinesToProcess = outputRegionForThread.GetNumberOfPixels() / outputRegionForThread.GetSize(0); ProgressReporter progress( this, threadId, numberOfLinesToProcess ); while ( !inputIt.IsAtEnd() ) { while ( !inputIt.IsAtEndOfLine() ) { outputIt.Set( m_Functor( inputIt.Get() ) ); ++inputIt; ++outputIt; } inputIt.NextLine(); outputIt.NextLine(); progress.CompletedPixel(); // potential exception thrown here } } } // end namespace itk #endif OTB-release-5.8/Modules/ThirdParty/ITK/include/otbWarpImageFilter.h000066400000000000000000000256471301006202600251100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWarpImageFilter_h #define otbWarpImageFilter_h #include "itkImageBase.h" #include "itkImageToImageFilter.h" #include "itkLinearInterpolateImageFunction.h" #include "itkPoint.h" namespace otb { /** \class WarpImageFilter * \brief Warps an image using an input deformation field. * * WarpImageFilter warps an existing image with respect to * a given deformation field. * * A deformation field is represented as a image whose pixel type is some * vector type with at least N elements, where N is the dimension of * the input image. The vector type must support element access via operator * []. * * The output image is produced by inverse mapping: the output pixels * are mapped back onto the input image. This scheme avoids the creation of * any holes and overlaps in the output image. * * Each vector in the deformation field represent the distance between * a geometric point in the input space and a point in the output space such * that: * * \f[ p_{in} = p_{out} + d \f] * * Typically the mapped position does not correspond to an integer pixel * position in the input image. Interpolation via an image function * is used to compute values at non-integer positions. The default * interpolation typed used is the LinearInterpolateImageFunction. * The user can specify a particular interpolation function via * SetInterpolator(). Note that the input interpolator must derive * from base class InterpolateImageFunction. * * Position mapped to outside of the input image buffer are assigned * a edge padding value. * * The LargetPossibleRegion for the output is inherited * from the input deformation field. The output image * spacing, origin and orientation may be set via * SetOutputSpacing, SetOutputOrigin and * SetOutputDirection. The default are respectively a * vector of 1's, a vector of 0's and an identity matrix. * * This class is templated over the type of the input image, the * type of the output image and the type of the deformation field. * * The input image is set via SetInput. The input deformation field * is set via SetDisplacementField. * * This filter is implemented as a multithreaded filter. * * \warning This filter assumes that the input type, output type * and deformation field type all have the same number of dimensions. * * \ingroup GeometricTransforms MultiThreaded Streamed * * \ingroup OTBITK */ template < class TInputImage, class TOutputImage, class TDisplacementField > class ITK_EXPORT WarpImageFilter : public itk::ImageToImageFilter { public: /** Standard class typedefs. */ typedef WarpImageFilter Self; typedef itk::ImageToImageFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); /** Run-time type information (and related methods) */ itkTypeMacro( WarpImageFilter, ImageToImageFilter ); /** Typedef to describe the output image region type. */ typedef typename TOutputImage::RegionType OutputImageRegionType; /** Inherit some types from the superclass. */ typedef typename Superclass::InputImageType InputImageType; typedef typename Superclass::InputImagePointer InputImagePointer; typedef typename Superclass::OutputImageType OutputImageType; typedef typename Superclass::OutputImagePointer OutputImagePointer; typedef typename Superclass::InputImageConstPointer InputImageConstPointer; typedef typename OutputImageType::IndexType IndexType; typedef typename OutputImageType::IndexValueType IndexValueType; typedef typename OutputImageType::SizeType SizeType; typedef typename OutputImageType::PixelType PixelType; typedef typename OutputImageType::SpacingType SpacingType; /** Determine the image dimension. */ itkStaticConstMacro(ImageDimension, unsigned int, TOutputImage::ImageDimension ); itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension ); itkStaticConstMacro(DisplacementFieldDimension, unsigned int, TDisplacementField::ImageDimension ); /** typedef for base image type at the current ImageDimension */ typedef itk::ImageBase ImageBaseType; /** Displacement field typedef support. */ typedef TDisplacementField DisplacementFieldType; typedef typename DisplacementFieldType::Pointer DisplacementFieldPointer; typedef typename DisplacementFieldType::PixelType DisplacementType; /** Interpolator typedef support. */ typedef double CoordRepType; typedef itk::InterpolateImageFunction InterpolatorType; typedef typename InterpolatorType::Pointer InterpolatorPointer; typedef itk::LinearInterpolateImageFunction DefaultInterpolatorType; /** Point type */ typedef itk::Point PointType; /** Type for representing the direction of the output image */ typedef typename TOutputImage::DirectionType DirectionType; /** Set the deformation field. */ void SetDisplacementField( const DisplacementFieldType * field ); /** Get a pointer the deformation field. */ DisplacementFieldType * GetDisplacementField(void); /** Set the interpolator function. */ itkSetObjectMacro( Interpolator, InterpolatorType ); /** Get a pointer to the interpolator function. */ itkGetObjectMacro( Interpolator, InterpolatorType ); /** Set the output image spacing. */ itkSetMacro(OutputSpacing, SpacingType); virtual void SetOutputSpacing( const double* values); /** Get the output image spacing. */ itkGetConstReferenceMacro(OutputSpacing, SpacingType); /** Set the output image origin. */ itkSetMacro(OutputOrigin, PointType); virtual void SetOutputOrigin( const double* values); /** Get the output image origin. */ itkGetConstReferenceMacro(OutputOrigin, PointType); /** Set/Get the direction (orientation) of the output image */ itkSetMacro(OutputDirection, DirectionType ); itkGetConstReferenceMacro(OutputDirection, DirectionType ); /** Helper method to set the output parameters based on this image */ void SetOutputParametersFromImage ( const ImageBaseType *image ); /** Set the start index of the output largest possible region. * The default is an index of all zeros. */ itkSetMacro( OutputStartIndex, IndexType ); /** Get the start index of the output largest possible region. */ itkGetConstReferenceMacro( OutputStartIndex, IndexType ); /** Set the size of the output image. */ itkSetMacro( OutputSize, SizeType ); /** Get the size of the output image. */ itkGetConstReferenceMacro( OutputSize, SizeType ); /** Set the edge padding value */ itkSetMacro( EdgePaddingValue, PixelType ); /** Get the edge padding value */ itkGetConstMacro( EdgePaddingValue, PixelType ); /** WarpImageFilter produces an image which is a different * size than its input image. As such, it needs to provide an * implementation for GenerateOutputInformation() which set * the output information according the OutputSpacing, OutputOrigin * and the deformation field's LargestPossibleRegion. */ void GenerateOutputInformation() ITK_OVERRIDE; /** It is difficult to compute in advance the input image region * required to compute the requested output region. Thus the safest * thing to do is to request for the whole input image. * * For the deformation field, the input requested region * set to be the same as that of the output requested region. */ void GenerateInputRequestedRegion() ITK_OVERRIDE; /** This method is used to set the state of the filter before * multi-threading. */ void BeforeThreadedGenerateData() ITK_OVERRIDE; /** This method is used to set the state of the filter after * multi-threading. */ void AfterThreadedGenerateData() ITK_OVERRIDE; #ifdef ITK_USE_CONCEPT_CHECKING /** Begin concept checking */ itkConceptMacro(SameDimensionCheck1, (itk::Concept::SameDimension)); itkConceptMacro(SameDimensionCheck2, (itk::Concept::SameDimension)); /** itkConceptMacro(InputHasNumericTraitsCheck, (Concept::HasNumericTraits)); */ itkConceptMacro(DisplacementFieldHasNumericTraitsCheck, (itk::Concept::HasNumericTraits)); /** End concept checking */ #endif protected: WarpImageFilter(); ~WarpImageFilter() ITK_OVERRIDE {}; void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE; /** WarpImageFilter is implemented as a multi-threaded filter. * As such, it needs to provide and implementation for * ThreadedGenerateData(). */ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE; /** Override VerifyInputInformation() since this filter's inputs do * not need to occupy the same physical space. * * \sa ProcessObject::VerifyInputInformation */ void VerifyInputInformation() ITK_OVERRIDE {} private: WarpImageFilter(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** This function should be in an interpolator but none of the ITK * interpolators at this point handle edge conditions properly */ DisplacementType EvaluateDisplacementAtPhysicalPoint(const PointType &p, const DisplacementFieldType *fieldPtr); PixelType m_EdgePaddingValue; SpacingType m_OutputSpacing; PointType m_OutputOrigin; DirectionType m_OutputDirection; InterpolatorPointer m_Interpolator; SizeType m_OutputSize; // Size of the output image IndexType m_OutputStartIndex; // output image start index bool m_DefFieldSizeSame; // variables for deffield interpoator IndexType m_StartIndex,m_EndIndex; }; } // end namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbWarpImageFilter.txx" #endif #endif OTB-release-5.8/Modules/ThirdParty/ITK/include/otbWarpImageFilter.txx000066400000000000000000000321241301006202600254700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWarpImageFilter_txx #define otbWarpImageFilter_txx #include "otbWarpImageFilter.h" #include "itkImageRegionIterator.h" #include "itkImageRegionIteratorWithIndex.h" #include "itkProgressReporter.h" #include "itkContinuousIndex.h" #include "vnl/vnl_math.h" #include "itkVariableLengthVector.h" namespace otb { template unsigned int PixelSizeFinder(itk::VariableLengthVector pix) { return pix.Size(); } template unsigned int PixelSizeFinder(PixelType itkNotUsed(pix)) { return PixelType::Dimension; } /** * Default constructor. */ template WarpImageFilter ::WarpImageFilter() { // Setup the number of required inputs this->SetNumberOfRequiredInputs( 2 ); // Setup default values m_OutputSpacing.Fill( 1.0 ); m_OutputOrigin.Fill( 0.0 ); m_OutputDirection.SetIdentity(); m_OutputSize.Fill(0); itk::NumericTraits::SetLength(m_EdgePaddingValue, 1); m_OutputStartIndex.Fill(0); // Setup default interpolator typename DefaultInterpolatorType::Pointer interp = DefaultInterpolatorType::New(); m_Interpolator = static_cast( interp.GetPointer() ); } /** * Standard PrintSelf method. */ template void WarpImageFilter ::PrintSelf(std::ostream& os, itk::Indent indent) const { Superclass::PrintSelf(os, indent); os << indent << "OutputSpacing: " << m_OutputSpacing << std::endl; os << indent << "OutputOrigin: " << m_OutputOrigin << std::endl; os << indent << "OutputDirection: " << m_OutputDirection << std::endl; os << indent << "OutputSize: " << m_OutputSize << std::endl; os << indent << "OutputStartIndex: " << m_OutputStartIndex << std::endl; os << indent << "EdgePaddingValue: " << static_cast::PrintType>(m_EdgePaddingValue) << std::endl; os << indent << "Interpolator: " << m_Interpolator.GetPointer() << std::endl; } /** * Set the output image spacing. * */ template void WarpImageFilter ::SetOutputSpacing( const double* spacing) { SpacingType s(spacing); this->SetOutputSpacing( s ); } /** * Set the output image origin. * */ template void WarpImageFilter ::SetOutputOrigin( const double* origin) { PointType p(origin); this->SetOutputOrigin(p); } /** Helper method to set the output parameters based on this image */ template void WarpImageFilter ::SetOutputParametersFromImage ( const ImageBaseType * image ) { this->SetOutputOrigin ( image->GetOrigin() ); this->SetOutputSpacing ( image->GetSpacing() ); this->SetOutputDirection ( image->GetDirection() ); this->SetOutputStartIndex ( image->GetLargestPossibleRegion().GetIndex() ); this->SetOutputSize ( image->GetLargestPossibleRegion().GetSize() ); } /** * Set deformation field as Inputs[1] for this ProcessObject. * */ template void WarpImageFilter ::SetDisplacementField( const DisplacementFieldType * field ) { // const cast is needed because the pipeline is not const-correct. DisplacementFieldType * input = const_cast< DisplacementFieldType * >( field ); this->itk::ProcessObject::SetNthInput( 1, input ); } /** * Return a pointer to the deformation field. */ template typename WarpImageFilter ::DisplacementFieldType * WarpImageFilter ::GetDisplacementField(void) { return static_cast ( this->itk::ProcessObject::GetInput( 1 )); } /** * Setup state of filter before multi-threading. * InterpolatorType::SetInputImage is not thread-safe and hence * has to be setup before ThreadedGenerateData */ template void WarpImageFilter ::BeforeThreadedGenerateData() { if( !m_Interpolator ) { itkExceptionMacro(<< "Interpolator not set"); } DisplacementFieldPointer fieldPtr = this->GetDisplacementField(); // Connect input image to interpolator m_Interpolator->SetInputImage( this->GetInput() ); typename DisplacementFieldType::RegionType defRegion = fieldPtr->GetLargestPossibleRegion(); typename OutputImageType::RegionType outRegion = this->GetOutput()->GetLargestPossibleRegion(); m_DefFieldSizeSame = outRegion == defRegion; if(!m_DefFieldSizeSame) { m_StartIndex = fieldPtr->GetBufferedRegion().GetIndex(); for(unsigned i = 0; i < ImageDimension; i++) { m_EndIndex[i] = m_StartIndex[i] + fieldPtr->GetBufferedRegion().GetSize()[i] - 1; } } } /** * Setup state of filter after multi-threading. */ template void WarpImageFilter ::AfterThreadedGenerateData() { // Disconnect input image from interpolator m_Interpolator->SetInputImage( ITK_NULLPTR ); } template typename WarpImageFilter::DisplacementType WarpImageFilter ::EvaluateDisplacementAtPhysicalPoint(const PointType &point, const DisplacementFieldType *fieldPtr) { itk::ContinuousIndex index; fieldPtr->TransformPhysicalPointToContinuousIndex(point,index); unsigned int dim; // index over dimension /** * Compute base index = closest index below point * Compute distance from point to base index */ IndexType baseIndex; IndexType neighIndex; double distance[ImageDimension]; for( dim = 0; dim < ImageDimension; dim++ ) { baseIndex[dim] = itk::Math::Floor< IndexValueType >( index[dim] ); if( baseIndex[dim] >= m_StartIndex[dim] ) { if( baseIndex[dim] < m_EndIndex[dim] ) { distance[dim] = index[dim] - static_cast( baseIndex[dim] ); } else { baseIndex[dim] = m_EndIndex[dim]; distance[dim] = 0.0; } } else { baseIndex[dim] = m_StartIndex[dim]; distance[dim] = 0.0; } } /** * Interpolated value is the weight some of each of the surrounding * neighbors. The weight for each neighbour is the fraction overlap * of the neighbor pixel with respect to a pixel centered on point. */ DisplacementType output; output.Fill(0); double totalOverlap = 0.0; unsigned int numNeighbors(1 << TInputImage::ImageDimension); for( unsigned int counter = 0; counter < numNeighbors; counter++ ) { double overlap = 1.0; // fraction overlap unsigned int upper = counter; // each bit indicates upper/lower neighbour // get neighbor index and overlap fraction for( dim = 0; dim < ImageDimension; dim++ ) { if( upper & 1 ) { neighIndex[dim] = baseIndex[dim] + 1; overlap *= distance[dim]; } else { neighIndex[dim] = baseIndex[dim]; overlap *= 1.0 - distance[dim]; } upper >>= 1; } // get neighbor value only if overlap is not zero if( overlap ) { const DisplacementType input = fieldPtr->GetPixel( neighIndex ); for(unsigned int k = 0; k < otb::PixelSizeFinder(input); k++ ) { output[k] += overlap * static_cast( input[k] ); } totalOverlap += overlap; } if( totalOverlap == 1.0 ) { // finished break; } } return ( output ); } /** * Compute the output for the region specified by outputRegionForThread. */ template void WarpImageFilter ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) { InputImageConstPointer inputPtr = this->GetInput(); OutputImagePointer outputPtr = this->GetOutput(); DisplacementFieldPointer fieldPtr = this->GetDisplacementField(); // support progress methods/callbacks itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels()); // iterator for the output image itk::ImageRegionIteratorWithIndex outputIt( outputPtr, outputRegionForThread ); IndexType index; PointType point; DisplacementType displacement; if(this->m_DefFieldSizeSame) { // iterator for the deformation field itk::ImageRegionIterator fieldIt(fieldPtr, outputRegionForThread ); while( !outputIt.IsAtEnd() ) { // get the output image index index = outputIt.GetIndex(); outputPtr->TransformIndexToPhysicalPoint( index, point ); // get the required displacement displacement = fieldIt.Get(); // compute the required input image point for(unsigned int j = 0; j < ImageDimension; j++ ) { point[j] += displacement[j]; } // get the interpolated value if( m_Interpolator->IsInsideBuffer( point ) ) { PixelType value = static_cast(m_Interpolator->Evaluate( point ) ); outputIt.Set( value ); } else { outputIt.Set( m_EdgePaddingValue ); } ++outputIt; ++fieldIt; progress.CompletedPixel(); } } else { while( !outputIt.IsAtEnd() ) { // get the output image index index = outputIt.GetIndex(); outputPtr->TransformIndexToPhysicalPoint( index, point ); displacement = this->EvaluateDisplacementAtPhysicalPoint( point, fieldPtr ); // compute the required input image point for(unsigned int j = 0; j < ImageDimension; j++ ) { point[j] += displacement[j]; } // get the interpolated value if( m_Interpolator->IsInsideBuffer( point ) ) { PixelType value = static_cast(m_Interpolator->Evaluate( point ) ); outputIt.Set( value ); } else { outputIt.Set( m_EdgePaddingValue ); } ++outputIt; progress.CompletedPixel(); } } } template void WarpImageFilter ::GenerateInputRequestedRegion() { // call the superclass's implementation Superclass::GenerateInputRequestedRegion(); // request the largest possible region for the input image InputImagePointer inputPtr = const_cast< InputImageType * >( this->GetInput() ); if( inputPtr ) { inputPtr->SetRequestedRegionToLargestPossibleRegion(); } // just propagate up the output requested region for the // deformation field. DisplacementFieldPointer fieldPtr = this->GetDisplacementField(); OutputImagePointer outputPtr = this->GetOutput(); if(fieldPtr.IsNotNull() ) { fieldPtr->SetRequestedRegion( outputPtr->GetRequestedRegion() ); if(!fieldPtr->VerifyRequestedRegion()) { fieldPtr->SetRequestedRegion(fieldPtr->GetLargestPossibleRegion()); } } } template void WarpImageFilter ::GenerateOutputInformation() { // call the superclass's implementation of this method Superclass::GenerateOutputInformation(); OutputImagePointer outputPtr = this->GetOutput(); outputPtr->SetSpacing( m_OutputSpacing ); outputPtr->SetOrigin( m_OutputOrigin ); outputPtr->SetDirection( m_OutputDirection ); DisplacementFieldPointer fieldPtr = this->GetDisplacementField(); if( this->m_OutputSize[0] == 0 && fieldPtr.IsNotNull()) { outputPtr->SetLargestPossibleRegion( fieldPtr-> GetLargestPossibleRegion() ); } else { OutputImageRegionType region; region.SetSize(this->m_OutputSize); region.SetIndex(this->m_OutputStartIndex); outputPtr->SetLargestPossibleRegion(region); } } } // end namespace otb #endif OTB-release-5.8/Modules/ThirdParty/ITK/otb-module-init.cmake000066400000000000000000000043001301006202600235560ustar00rootroot00000000000000set(OTBITK_ITK_REQUIRED_MODULE_LIST ITKCommon ITKFiniteDifference ITKGPUCommon ITKGPUFiniteDifference ITKImageAdaptors ITKImageFunction ITKMesh ITKQuadEdgeMesh ITKSpatialObjects #ITKTestKernel ITKTransform ITKAnisotropicSmoothing ITKAntiAlias ITKBiasCorrection ITKBinaryMathematicalMorphology ITKColormap ITKConvolution ITKCurvatureFlow ITKDeconvolution ITKDenoising #ITKDiffusionTensorImage ITKDisplacementField ITKDistanceMap ITKFastMarching ITKFFT ITKGPUAnisotropicSmoothing ITKGPUImageFilterBase ITKGPUSmoothing ITKGPUThresholding ITKImageCompare ITKImageCompose ITKImageFeature ITKImageFilterBase ITKImageFusion ITKImageGradient ITKImageGrid ITKImageIntensity ITKImageLabel ITKImageSources ITKImageStatistics ITKLabelMap ITKMathematicalMorphology ITKPath ITKQuadEdgeMeshFiltering ITKSmoothing ITKSpatialFunction ITKThresholding ITKEigen #ITKFEM ITKNarrowBand ITKNeuralNetworks ITKOptimizers ITKOptimizersv4 ITKPolynomials ITKStatistics ITKRegistrationCommon #ITKFEMRegistration ITKGPURegistrationCommon ITKGPUPDEDeformableRegistration ITKMetricsv4 ITKPDEDeformableRegistration ITKRegistrationMethodsv4 #ITKBioCell ITKClassifiers ITKConnectedComponents ITKDeformableMesh ITKKLMRegionGrowing ITKLabelVoting ITKLevelSets ITKLevelSetsv4 #ITKLevelSetsv4Visualization ITKMarkovRandomFieldsClassifiers ITKRegionGrowing ITKSignedDistanceFunction ITKVoronoi ITKWatersheds) find_package(ITK COMPONENTS ${OTBITK_ITK_REQUIRED_MODULE_LIST}) mark_as_advanced(ITK_DIR) # set ( ITK_NO_IO_FACTORY_REGISTER_MANAGER TRUE ) # include (${ITK_USE_FILE}) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ITK_REQUIRED_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ITK_REQUIRED_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}") OTB-release-5.8/Modules/ThirdParty/ITK/otb-module.cmake000066400000000000000000000002401301006202600226140ustar00rootroot00000000000000set(DOCUMENTATION "This module imports ITK to the build system") otb_module(OTBITK DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/LibSVM/000077500000000000000000000000001301006202600202145ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/LibSVM/CMakeLists.txt000066400000000000000000000002501301006202600227510ustar00rootroot00000000000000project(OTBLibSVM) set(OTBLibSVM_THIRD_PARTY 1) set(OTBLibSVM_SYSTEM_INCLUDE_DIRS ${LIBSVM_INCLUDE_DIR}) set(OTBLibSVM_LIBRARIES ${LIBSVM_LIBRARY}) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/LibSVM/otb-module-init.cmake000066400000000000000000000003311301006202600242230ustar00rootroot00000000000000find_package(LibSVM REQUIRED) mark_as_advanced(LIBSVM_INCLUDE_DIR) mark_as_advanced(LIBSVM_LIBRARY) if(NOT LIBSVM_FOUND) message(FATAL_ERROR "Cannot find LibSVM. Set LIBSVM_INCLUDE_DIR and LIBSVM_LIBRARY") endif() OTB-release-5.8/Modules/ThirdParty/LibSVM/otb-module.cmake000066400000000000000000000003531301006202600232660ustar00rootroot00000000000000set(DOCUMENTATION "This module imports libsvm to the build system") otb_module(OTBLibSVM DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable libSVM dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/MPI/000077500000000000000000000000001301006202600175455ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/MPI/CMakeLists.txt000066400000000000000000000002111301006202600222770ustar00rootroot00000000000000project(OTBMPI) set(OTBMPI_SYSTEM_INCLUDE_DIRS ${MPI_CXX_INCLUDE_PATH}) set(OTBMPI_LIBRARIES "${MPI_CXX_LIBRARIES}") otb_module_impl() OTB-release-5.8/Modules/ThirdParty/MPI/otb-module-init.cmake000066400000000000000000000000361301006202600235560ustar00rootroot00000000000000find_package ( MPI REQUIRED ) OTB-release-5.8/Modules/ThirdParty/MPI/otb-module.cmake000066400000000000000000000003421301006202600226150ustar00rootroot00000000000000set(DOCUMENTATION "This module imports MPI to the build system") otb_module(OTBMPI DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable MPI dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/Mapnik/000077500000000000000000000000001301006202600203375ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Mapnik/CMakeLists.txt000066400000000000000000000004741301006202600231040ustar00rootroot00000000000000project(OTBMapnik) set(OTBMapnik_SYSTEM_INCLUDE_DIRS ${MAPNIK_INCLUDE_DIRS} ${ICUUC_INCLUDE_DIRS} ${LTDL_INCLUDE_DIRS} ${FREETYPE_INCLUDE_DIRS} ${AGG_INCLUDE_DIRS} ) set(OTBMapnik_LIBRARIES ${MAPNIK_LIBRARIES} ${ICUUC_LIBRARIES} ${LTDL_LIBRARIES} ${FREETYPE_LIBRARIES} ) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/Mapnik/otb-module-init.cmake000066400000000000000000000002411301006202600243460ustar00rootroot00000000000000find_package ( LTDL REQUIRED ) find_package ( ICUUC REQUIRED ) find_package ( Agg REQUIRED ) find_package ( Freetype REQUIRED ) find_package ( Mapnik REQUIRED ) OTB-release-5.8/Modules/ThirdParty/Mapnik/otb-module.cmake000066400000000000000000000003531301006202600234110ustar00rootroot00000000000000set(DOCUMENTATION "This module imports Mapnik to the build system") otb_module(OTBMapnik DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable Mapnik dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/MuParser/000077500000000000000000000000001301006202600206565ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/MuParser/CMake/000077500000000000000000000000001301006202600216365ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/MuParser/CMake/otbTestMuParserHasCxxLogicalOperators.cxx000066400000000000000000000012331301006202600317750ustar00rootroot00000000000000#include #include "muParser.h" int main(int argc, char *argv[]) { // Test "&&" operator // This will throw an exception if muParser version is < 2.0.0, // which have "and" instead mu::Parser parser; parser.SetExpr("0 && 1"); try { double result = parser.Eval(); } catch( const mu::Parser::exception_type& e ) { std::cerr << "Message: " << e.GetMsg() << std::endl << "Formula: " << e.GetExpr() << std::endl << "Token: " << e.GetToken() << std::endl << "Position: " << e.GetPos() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/MuParser/CMakeLists.txt000066400000000000000000000032761301006202600234260ustar00rootroot00000000000000project(OTBMuParser) set(OTBMuParser_SYSTEM_INCLUDE_DIRS ${MUPARSER_INCLUDE_DIRS}) set(OTBMuParser_LIBRARIES "${MUPARSER_LIBRARIES}") set(OTBMuParser_INCLUDE_DIRS ${OTBMuParser_BINARY_DIR}/src) set(OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS 0) if(NOT MUPARSER_VERSION_NUMBER LESS 20000) set(OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS 1) endif() # Starting with muparser 2.0.0, # intrinsic operators "and", "or", "xor" have been removed # and intrinsic operators "&&" and "||" have been introduced as replacements # include(CheckCXXSourceRuns) # set(CMAKE_REQUIRED_INCLUDES ${OTBMuParser_SYSTEM_INCLUDE_DIRS}) # set(CMAKE_REQUIRED_LIBRARIES ${OTBMuParser_LIBRARIES}) # unset(CMAKE_REQUIRED_FLAGS) # unset(CMAKE_REQUIRED_DEFINES) # file(READ ${OTBMuParser_SOURCE_DIR}/CMake/otbTestMuParserHasCxxLogicalOperators.cxx # OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS_SOURCEFILE) # check_cxx_source_runs( # "${OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS_SOURCEFILE}" # OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS # ) # unset(CMAKE_REQUIRED_INCLUDES) # unset(CMAKE_REQUIRED_LIBRARIES) # unset(CMAKE_REQUIRED_FLAGS) # unset(CMAKE_REQUIRED_DEFINES) if(OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS) message(STATUS "MuParser version is ${MUPARSER_VERSION} >= 2.0.0 : " "uses '&&' and '||' logical operators, and C++ like " "ternary if-then-else operator") else() message(STATUS "MuParser version is ${MUPARSER_VERSION} < 2.0.0 : " "uses 'and' and 'or' logical operators, and ternary " "operator 'if( ; ; )'") endif() configure_file( src/otb_muparser.h.in src/otb_muparser.h ) otb_module_impl() install(FILES ${OTBMuParser_BINARY_DIR}/src/otb_muparser.h DESTINATION ${OTBMuParser_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/ThirdParty/MuParser/otb-module-init.cmake000066400000000000000000000000431301006202600246650ustar00rootroot00000000000000find_package ( MuParser REQUIRED ) OTB-release-5.8/Modules/ThirdParty/MuParser/otb-module.cmake000066400000000000000000000003611301006202600237270ustar00rootroot00000000000000set(DOCUMENTATION "This module imports MuParser to the build system") otb_module(OTBMuParser DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable MuParser dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/MuParser/src/000077500000000000000000000000001301006202600214455ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/MuParser/src/otb_muparser.h.in000066400000000000000000000014551301006202600247320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_muparser_h #define otb_muparser_h /* MuParser has "&&" and "||" operators (version >= 2.0.0), instead of "and" and "or" (version <2.0.0 version) */ #cmakedefine OTB_MUPARSER_HAS_CXX_LOGICAL_OPERATORS #include "muParser.h" #endif OTB-release-5.8/Modules/ThirdParty/MuParserX/000077500000000000000000000000001301006202600210065ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/MuParserX/CMakeLists.txt000066400000000000000000000006301301006202600235450ustar00rootroot00000000000000project(OTBMuParserX) set(OTBMuParserX_SYSTEM_INCLUDE_DIRS ${MUPARSERX_INCLUDE_DIRS}) set(OTBMuParserX_LIBRARIES "${MUPARSERX_LIBRARIES}") set(OTBMuParserX_INCLUDE_DIRS ${OTBMuParserX_BINARY_DIR}/src) configure_file( src/mpCompat.h.in src/mpCompat.h ) otb_module_impl() install(FILES ${OTBMuParserX_BINARY_DIR}/src/mpCompat.h DESTINATION ${OTBMuParserX_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/ThirdParty/MuParserX/otb-module-init.cmake000066400000000000000000000000441301006202600250160ustar00rootroot00000000000000find_package ( MuParserX REQUIRED ) OTB-release-5.8/Modules/ThirdParty/MuParserX/otb-module.cmake000066400000000000000000000003641301006202600240620ustar00rootroot00000000000000set(DOCUMENTATION "This module imports MuParserX to the build system") otb_module(OTBMuParserX DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable MuParserX dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/MuParserX/src/000077500000000000000000000000001301006202600215755ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/MuParserX/src/mpCompat.h.in000066400000000000000000000024271301006202600241400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef MUP_COMPAT_H #define MUP_COMPAT_H /* defined if OTB_CXX_HAS_UNIQUE_PTR cmake check is OK. */ /* See CMake/OTBCheckCpp11Keywords.cmake for more details */ #cmakedefine OTB_CXX_HAS_UNIQUE_PTR #ifndef OTB_CXX_HAS_UNIQUE_PTR #define unique_ptr auto_ptr #endif /* defined if OTB_CXX_HAS_OVERRIDE_SPECIFIER cmake check is OK. */ /* See CMake/OTBCheckCpp11Keywords.cmake for more details */ #cmakedefine OTB_CXX_HAS_OVERRIDE_SPECIFIER #ifndef OTB_CXX_HAS_OVERRIDE_SPECIFIER #define override #endif /* defined if OTB_CXX_HAS_NULLPTR cmake check is OK. */ /* See CMake/OTBCheckCpp11Keywords.cmake for more details */ #cmakedefine OTB_CXX_HAS_NULLPTR #ifndef OTB_CXX_HAS_NULLPTR #define nullptr NULL #endif #endif //MUP_COMPAT_H OTB-release-5.8/Modules/ThirdParty/OpenCV/000077500000000000000000000000001301006202600202525ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OpenCV/CMakeLists.txt000066400000000000000000000004231301006202600230110ustar00rootroot00000000000000project(OTBOpenCV) set(OTBOpenCV_SYSTEM_INCLUDE_DIRS ${OPENCV_INCLUDE_DIRS}) set(OTBOpenCV_LIBRARIES "${OPENCV_LIBRARIES}") set(OTBOpenCV_EXPORT_CODE_BUILD "find_package(OpenCV REQUIRED)") set(OTBOpenCV_EXPORT_CODE_INSTALL ${OTBOpenCV_EXPORT_CODE_BUILD}) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/OpenCV/otb-module-init.cmake000066400000000000000000000003771301006202600242730ustar00rootroot00000000000000find_package ( OpenCV REQUIRED ) mark_as_advanced( OpenCV_DIR ) if("${OpenCV_VERSION}" VERSION_LESS "2.4.0") message(WARNING "The OpenCV version detected (${OpenCV_VERSION}) is older than 2.4.0, " "it may not be fully compatible with OTB") endif() OTB-release-5.8/Modules/ThirdParty/OpenCV/otb-module.cmake000066400000000000000000000003531301006202600233240ustar00rootroot00000000000000set(DOCUMENTATION "This module imports OpenCV to the build system") otb_module(OTBOpenCV DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable OpenCV dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/OpenGL/000077500000000000000000000000001301006202600202445ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OpenGL/CMakeLists.txt000066400000000000000000000002501301006202600230010ustar00rootroot00000000000000project(OTBOpenGL) set(OTBOpenGL_THIRD_PARTY 1) set(OTBOpenGL_SYSTEM_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR}) set(OTBOpenGL_LIBRARIES ${OPENGL_LIBRARY}) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/OpenGL/otb-module-init.cmake000066400000000000000000000032031301006202600242540ustar00rootroot00000000000000#detection of OpenGL is apply is bit tricy as we deactivate #framework on OSX globally. see mantis #1193 if(APPLE) set(OPENGL_FOUND FALSE) find_library( OPENGL_gl_LIBRARY OpenGL PATHS "/System/Library/Frameworks/" DOC "OpenGL lib for OSX" ) find_library( OPENGL_glu_LIBRARY AGL PATHS "/System/Library/Frameworks/" DOC "AGL lib for OSX" ) find_path( OPENGL_INCLUDE_DIR OpenGL/gl.h PATHS "/System/Library/Frameworks/" DOC "Include for OpenGL on OSX" ) if(OPENGL_gl_LIBRARY) set( OPENGL_LIBRARIES ${OPENGL_gl_LIBRARY} ${OPENGL_LIBRARIES}) if(OPENGL_glu_LIBRARY) set( OPENGL_GLU_FOUND "YES" ) set( OPENGL_LIBRARIES ${OPENGL_glu_LIBRARY} ${OPENGL_LIBRARIES} ) else() set( OPENGL_GLU_FOUND "NO" ) endif() # This deprecated setting is for backward compatibility with CMake1.4 set (OPENGL_LIBRARY ${OPENGL_LIBRARIES}) endif() # This deprecated setting is for backward compatibility with CMake1.4 set(OPENGL_INCLUDE_PATH ${OPENGL_INCLUDE_DIR}) mark_as_advanced( OPENGL_INCLUDE_DIR OPENGL_LIBRARY OPENGL_glu_LIBRARY OPENGL_gl_LIBRARY ) if(NOT OPENGL_LIBRARY OR NOT OPENGL_INCLUDE_DIR) message(FATAL_ERROR "Cannot find OpenGL. Set OPENGL_INCLUDE_DIR and OPENGL_LIBRARY") else() message(STATUS "Found OpenGL framework: ${OPENGL_INCLUDE_DIR}") endif() set(OPENGL_FOUND TRUE) else(APPLE) find_package(OpenGL REQUIRED) mark_as_advanced(OPENGL_INCLUDE_DIR) mark_as_advanced(OPENGL_LIBRARY) if(NOT OPENGL_FOUND) message(FATAL_ERROR "Cannot find OpenGL. Set OPENGL_INCLUDE_DIR and OPENGL_LIBRARY") endif() endif(APPLE) OTB-release-5.8/Modules/ThirdParty/OpenGL/otb-module.cmake000066400000000000000000000003531301006202600233160ustar00rootroot00000000000000set(DOCUMENTATION "This module imports OpenGL to the build system") otb_module(OTBOpenGL DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable OpenGL dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/OpenJPEG/000077500000000000000000000000001301006202600204675ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OpenJPEG/CMakeLists.txt000066400000000000000000000030341301006202600232270ustar00rootroot00000000000000project(OTBOpenJPEG) set(OTBOpenJPEG_SYSTEM_INCLUDE_DIRS ${OPENJPEG_INCLUDE_DIRS}) set(OTBOpenJPEG_LIBRARIES "${OPENJPEG_LIBRARIES}") set(OTBOpenJPEG_INCLUDE_DIRS ${OTBOpenJPEG_BINARY_DIR}/src) set(OTBOpenJPEG_EXPORT_CODE_BUILD " if(NOT OpenJPEG_FOUND) find_package(OpenJPEG REQUIRED HINTS ${OpenJPEG_DIR}) endif()") set(OTBOpenJPEG_EXPORT_CODE_INSTALL ${OTBOpenJPEG_EXPORT_CODE_BUILD}) if(OpenJPEG_FOUND) math(EXPR OTBOpenJPEG_VERSION_NUMBER "((${OPENJPEG_MAJOR_VERSION})*100+${OPENJPEG_MINOR_VERSION})*100+${OPENJPEG_BUILD_VERSION}") configure_file( src/otb_openjpeg.h.in src/otb_openjpeg.h ) endif() message(STATUS "Found OpenJPEG : ${OPENJPEG_LIBRARIES} (version ${OPENJPEG_MAJOR_VERSION}.${OPENJPEG_MINOR_VERSION}.${OPENJPEG_BUILD_VERSION})") message(STATUS "Caution : there could be a version conflict if ITK also contains an OpenJPEG version. " "Depending on ITK version and enabled modules, the OpenJPEG headers can be " "present in ITK include folder. Since the include order between modules is " "deterministic, the OpenJPEG header from ITK may be included first. To avoid " "version conflicts, try to use an ITK installed without GDCM nor ITKReview. " "An alternative fix is to simply hide the header openjpeg.h in the ITK " "include directory.") otb_module_impl() install(FILES ${OTBOpenJPEG_BINARY_DIR}/src/otb_openjpeg.h DESTINATION ${OTBOpenJPEG_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/ThirdParty/OpenJPEG/otb-module-init.cmake000066400000000000000000000001031301006202600244730ustar00rootroot00000000000000find_package( OpenJPEG REQUIRED ) mark_as_advanced( OpenJPEG_DIR ) OTB-release-5.8/Modules/ThirdParty/OpenJPEG/otb-module.cmake000066400000000000000000000005171301006202600235430ustar00rootroot00000000000000set(DOCUMENTATION "This module imports OpenJPEG to the build system") otb_module(OTBOpenJPEG DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable OpenJpeg dependent modules. Note that this may not be needed if your GDal has a JPEG2000 compatible driver (other than jasper)" OFF) OTB-release-5.8/Modules/ThirdParty/OpenJPEG/src/000077500000000000000000000000001301006202600212565ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OpenJPEG/src/otb_openjpeg.h.in000066400000000000000000000013751301006202600245150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_openjpeg_h #define otb_openjpeg_h /* different API between 2.0 and 2.1 */ #define OTBOpenJPEG_VERSION_NUMBER @OTBOpenJPEG_VERSION_NUMBER@ extern "C" { #include "openjpeg.h" } #endif OTB-release-5.8/Modules/ThirdParty/OpenThreads/000077500000000000000000000000001301006202600213345ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OpenThreads/CMakeLists.txt000066400000000000000000000002511301006202600240720ustar00rootroot00000000000000project(OTBOpenThreads) set(OTBOpenThreads_SYSTEM_INCLUDE_DIRS ${OPENTHREADS_INCLUDE_DIRS}) set(OTBOpenThreads_LIBRARIES "${OPENTHREADS_LIBRARIES}") otb_module_impl() OTB-release-5.8/Modules/ThirdParty/OpenThreads/otb-module-init.cmake000066400000000000000000000000461301006202600253460ustar00rootroot00000000000000find_package ( OpenThreads REQUIRED ) OTB-release-5.8/Modules/ThirdParty/OpenThreads/otb-module.cmake000066400000000000000000000002601301006202600244030ustar00rootroot00000000000000set(DOCUMENTATION "This module imports OpenThreads to the build system") otb_module(OTBOpenThreads DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/Ossim/000077500000000000000000000000001301006202600202125ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Ossim/CMakeLists.txt000066400000000000000000000002131301006202600227460ustar00rootroot00000000000000project(OTBOssim) set(OTBOssim_SYSTEM_INCLUDE_DIRS ${OSSIM_INCLUDE_DIRS}) set(OTBOssim_LIBRARIES "${OSSIM_LIBRARIES}") otb_module_impl() OTB-release-5.8/Modules/ThirdParty/Ossim/otb-module-init.cmake000066400000000000000000000000401301006202600242160ustar00rootroot00000000000000find_package ( Ossim REQUIRED ) OTB-release-5.8/Modules/ThirdParty/Ossim/otb-module.cmake000066400000000000000000000002371301006202600232650ustar00rootroot00000000000000set(DOCUMENTATION "This module imports Ossim to the build system") otb_module(OTBOssim DEPENDS OTBOpenThreads DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/OssimPlugins/000077500000000000000000000000001301006202600215545ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/CMakeLists.txt000066400000000000000000000003631301006202600243160ustar00rootroot00000000000000project(OTBOssimPlugins) set(OTBOssimPlugins_THIRD_PARTY 1) set(OTBOssimPlugins_LIBRARIES otbossimplugins) set(OTBOssimPlugins_INCLUDE_DIRS ${OTBOssimPlugins_SOURCE_DIR}/src ${OTBOssimPlugins_SOURCE_DIR}/src/ossim ) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/OssimPlugins/otb-module.cmake000066400000000000000000000003201301006202600246200ustar00rootroot00000000000000set(DOCUMENTATION "This module provides Ossim Plugins") otb_module(OTBOssimPlugins DEPENDS OTBBoost OTBGeoTIFF OTBGDAL OTBOssim TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/000077500000000000000000000000001301006202600223435ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/CMakeLists.txt000066400000000000000000000055201301006202600251050ustar00rootroot00000000000000project(otbossimplugins) set(OTB3P_INSTALL_EXPORT_NAME "${OTBOssimPlugins-targets}") set(OTB3P_INSTALL_INCLUDE_DIR "${OTBOssimPlugins_INSTALL_INCLUDE_DIR}") set(OTB3P_INSTALL_RUNTIME_DIR "${OTBOssimPlugins_INSTALL_RUNTIME_DIR}") set(OTB3P_INSTALL_LIBRARY_DIR "${OTBOssimPlugins_INSTALL_LIBRARY_DIR}") set(OTB3P_INSTALL_ARCHIVE_DIR "${OTBOssimPlugins_INSTALL_ARCHIVE_DIR}") set(ossimplugins_VERSION_MAJOR "1") set(ossimplugins_VERSION_MINOR "8") set(ossimplugins_VERSION_PATCH "4") # svn revision number of ossim (used for .so versioning) set(OSSIMPLUGINS_SVN_REVISION "18162") # patch number for OTB modifications applied on top of OSSIM_SVN_REVISION (used for .so versioning) set(OSSIMPLUGINS_OTB_PATCH "1") # Check whether std::snprintf is defined include(CheckCXXSymbolExists) check_cxx_symbol_exists(std::snprintf cstdio HAVE_STD_SNPRINTF) if (NOT HAVE_STD_SNPRINTF) # it would be _snprintf with VC++ check_symbol_exists(_snprintf stdio.h HAVE_MSC_SNPRINTF) if (NOT HAVE_MSC_SNPRINTF) message(FATAL_ERROR "Either std::snprintf or VC++'s _snprintf are required") endif() endif() configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ossim/ossimplugins-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/ossim/ossimplugins-config.h) include_directories(${CMAKE_CURRENT_BINARY_DIR}/ossim) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/gdal) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ossim) file(GLOB_RECURSE ossimplugins_gdal_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/gdal/*.cpp") file(GLOB_RECURSE ossimplugins_ossim_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/ossim/*.cpp") if(NOT WIN32) list(REMOVE_ITEM ossimplugins_ossim_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/ossim/ossimWin32FindFileHandle.cpp" ) endif() set(ossimplugins_SOURCES ${ossimplugins_gdal_SRCS} ${ossimplugins_ossim_SRCS} ) add_library(otbossimplugins SHARED ${ossimplugins_SOURCES}) target_link_libraries(otbossimplugins ${OTBBoost_LIBRARIES} ${OTBGDAL_LIBRARIES} ${OTBOssim_LIBRARIES} ${OTBGeoTIFF_LIBRARIES} ) # Apply user-defined properties to the library target. if(OTB_LIBRARY_PROPERTIES) set_target_properties(otbossimplugins PROPERTIES ${OTB_LIBRARY_PROPERTIES}) endif(OTB_LIBRARY_PROPERTIES) if(MSVC) set_target_properties(otbossimplugins PROPERTIES COMPILE_FLAGS "/DOSSIMPLUGINSMAKINGDLL") elseif(MINGW) set_target_properties(otbossimplugins PROPERTIES COMPILE_FLAGS "-DOSSIMPLUGINSMAKINGDLL") endif() install(TARGETS otbossimplugins EXPORT ${OTB3P_INSTALL_EXPORT_NAME} RUNTIME DESTINATION ${OTB3P_INSTALL_RUNTIME_DIR} COMPONENT RuntimeLibraries LIBRARY DESTINATION ${OTB3P_INSTALL_LIBRARY_DIR} COMPONENT RuntimeLibraries ARCHIVE DESTINATION ${OTB3P_INSTALL_ARCHIVE_DIR} COMPONENT Development ) # purposely do not install headers as OssimAdapters API do not require them. otb_module_target( otbossimplugins NO_INSTALL ) OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/gdal/000077500000000000000000000000001301006202600232525ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/gdal/ossimOgcWktTranslator.cpp000066400000000000000000001072111301006202600303030ustar00rootroot00000000000000//******************************************************************* // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: Frank Warmerdam (warmerda@home.com) // Contributor: David A. Horner // // Description: // // Contains code implementation translation between OGC WKT format, // and OSSIM projection keyword lists. Note that services from // GDAL's OGRSpatialReference class are used via the GDAL bridge to // accomplish the translation. // //******************************************************************* // $Id: ossimOgcWktTranslator.cpp 20724 2012-04-13 21:00:52Z dburken $ #include #include #include #include "ossimOgcWktTranslator.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include static const double SEMI_MAJOR_AXIS_WGS84 = 6378137.0; static const double SEMI_MINOR_AXIS_WGS84 = 6356752.3142; static ossimTrace traceDebug("ossimOgcWktTranslator:debug"); //******************************************************************* // Public Function: //******************************************************************* ossimOgcWktTranslator::ossimOgcWktTranslator() { initializeDatumTable(); initializeProjectionTable(); } #define EPSG_CODE_MAX 32767 #define USER_DEFINED 32767 ossimString ossimOgcWktTranslator::fromOssimKwl(const ossimKeywordlist &kwl, const char *prefix)const { ossimString projType = kwl.find(ossimKeywordNames::TYPE_KW); ossimString datumType = kwl.find(ossimKeywordNames::DATUM_KW); ossimString wktString; OGRSpatialReference oSRS; if(projType == "") { return wktString; } ossimString zone = kwl.find(prefix, ossimKeywordNames::ZONE_KW); ossimString hemisphere = kwl.find(prefix, ossimKeywordNames::HEMISPHERE_KW); ossimString parallel1 = kwl.find(prefix, ossimKeywordNames::STD_PARALLEL_1_KW); ossimString parallel2 = kwl.find(prefix, ossimKeywordNames::STD_PARALLEL_2_KW); ossimString originLat = kwl.find(prefix, ossimKeywordNames::ORIGIN_LATITUDE_KW); ossimString centralMeridian = kwl.find(prefix, ossimKeywordNames::CENTRAL_MERIDIAN_KW); ossimString scale = kwl.find(prefix, ossimKeywordNames::SCALE_FACTOR_KW); ossimString pcsCode = kwl.find(prefix, ossimKeywordNames::PCS_CODE_KW); ossimDpt falseEastingNorthing; // Get the false easting northing. falseEastingNorthing.x = 0.0; falseEastingNorthing.y = 0.0; const char *lookup = kwl.find(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW); if (lookup) { ossimUnitType units = static_cast(ossimUnitTypeLut::instance()-> getEntryNumber(lookup)); lookup = kwl.find(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_KW); if (lookup) { ossimDpt eastingNorthing; eastingNorthing.toPoint(std::string(lookup)); switch (units) { case OSSIM_METERS: { falseEastingNorthing = eastingNorthing; break; } case OSSIM_FEET: case OSSIM_US_SURVEY_FEET: { ossimUnitConversionTool ut; ut.setValue(eastingNorthing.x, units); falseEastingNorthing.x = ut.getValue(OSSIM_METERS); ut.setValue(eastingNorthing.y, units); falseEastingNorthing.y = ut.getValue(OSSIM_METERS); break; } default: { // Unhandled unit type! ossimNotify(ossimNotifyLevel_WARN) << "ossimOgcWktTranslator::fromOssimKwl WARNING!" << "Unhandled unit type for " << ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW << ": " << ( ossimUnitTypeLut::instance()-> getEntryString(units).c_str() ) << endl; break; } } // End of switch (units) } // End of if (FALSE_EASTING_NORTHING_KW) } // End of if (FALSE_EASTING_NORTHING_UNITS_KW) else { // BACKWARDS COMPATIBILITY LOOKUPS... lookup = kwl.find(prefix, ossimKeywordNames::FALSE_EASTING_KW); if(lookup) { falseEastingNorthing.x = fabs(ossimString(lookup).toFloat64()); } lookup = kwl.find(prefix, ossimKeywordNames::FALSE_NORTHING_KW); if(lookup) { falseEastingNorthing.y = fabs(ossimString(lookup).toFloat64()); } } oSRS.SetLinearUnits("Meter", 1.0); int pcsCodeVal = (pcsCode.empty() == false) ? pcsCode.toInt() : EPSG_CODE_MAX; // since approximately ossim version r20036 // kwl.find(prefix, ossimKeywordNames::PCS_CODE_KW) // return 0 instead of "" previously. // the to following lines ensure backward compatibility // Since EPSG:0 is not a valid epsg code, the fix is safe // (ref http://spatialreference.org/ref/epsg/) if(pcsCodeVal == 0) pcsCodeVal = EPSG_CODE_MAX; if(pcsCodeVal < EPSG_CODE_MAX) { // ESH 06/2008 -- HACK!!! // If the PCS code is for a HARN state plane and the implied pcs code's units // is feet (us or intl), we find the equivalent code for units of meters. // We're doing this because ArcMap (9.2 and less) doesn't understand the // non-meters HARN codes. However, the units are left unchanged in this // process, so the units can be different than the user-specified pcs code. // ArcMap 9.2 seems to understand the mixed definition just fine. ossimEpsgProjectionDatabase* proj_db = ossimEpsgProjectionDatabase::instance(); ossimString pcsCodeName = proj_db->findProjectionName(pcsCodeVal); if ( pcsCodeName.contains("HARN") && pcsCodeName.contains("_Feet") ) { ossimString feetStr("_Feet"); ossimString newPcsCodeName( pcsCodeName.before(feetStr).c_str() ); ossimString epsg_spec = proj_db->findProjectionCode(newPcsCodeName); ossim_uint32 new_code = epsg_spec.after(":").toUInt32(); if (new_code) pcsCodeVal = new_code; } oSRS.importFromEPSG( pcsCodeVal ); } if(projType == "ossimUtmProjection") { #if 0 hemisphere = hemisphere.trim().upcase(); if(hemisphere != "") { oSRS.SetUTM(zone.toLong(), hemisphere != "S"); } else { oSRS.SetUTM(zone.toLong(), true); } #else // ESH 09/2008: Adapting code from ossimTiffWriter.cpp for // converting UTM zone,hemisphere to a PCS code. short gcs = USER_DEFINED; if (datumType == "WGE") gcs = GCS_WGS_84; else if (datumType == "WGD") gcs = GCS_WGS_72; else if (datumType == "NAR-C") gcs = GCS_NAD83; else if (datumType == "NAR") gcs = GCS_NAD83; else if (datumType == "NAS-C") gcs = GCS_NAD27; else if (datumType == "NAS") gcs = GCS_NAD27; else if (datumType == "ADI-M") gcs = GCS_Adindan; else if (datumType == "ARF-M") gcs = GCS_Arc_1950; else if (datumType == "ARS-M") gcs = GCS_Arc_1960; else if (datumType == "EUR-7" || datumType == "EUR-M") gcs = GCS_ED50; else if ((datumType == "OGB-7") || (datumType == "OGB-M") || (datumType == "OGB-A") || (datumType == "OGB-B") || (datumType == "OGB-C") || (datumType == "OGB-D")) gcs = GCS_OSGB_1936; else if (datumType == "TOY-M") gcs = GCS_Tokyo; else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DATUM = " << datumType << " tag not written " << std::endl << "Please let us know so we can add it" << std::endl; } } int mapZone = zone.toInt(); hemisphere = hemisphere.trim().upcase(); bool bDoImportFromEPSG = false; switch ( gcs ) { case GCS_WGS_84: { if (hemisphere == "N") // Northern hemisphere. { pcsCodeVal = 32600 + mapZone; } else // Southern hemisphere. { pcsCodeVal = 32700 + mapZone; } bDoImportFromEPSG = true; break; } case GCS_WGS_72: { if (hemisphere == "N") // Northern hemisphere. { pcsCodeVal = 32200 + mapZone; } else // Southern hemisphere. { pcsCodeVal = 32300 + mapZone; } bDoImportFromEPSG = true; break; } case GCS_NAD27: { if (hemisphere == "N") // Northern hemisphere. { pcsCodeVal = 26700 + mapZone; } else // Southern hemisphere. { pcsCodeVal = 32000 + mapZone; } bDoImportFromEPSG = true; break; } case GCS_NAD83: { if (hemisphere == "N") // Northern hemisphere. { pcsCodeVal = 26900 + mapZone; } else // Southern hemisphere. { pcsCodeVal = 32100 + mapZone; } bDoImportFromEPSG = true; break; } default: { //*** // Use a projection code that does not imply a datum. // See section "6.3.3.2 Projection Codes" for definition. //*** if (mapZone > 0) // Northern hemisphere. { pcsCodeVal = 16000 + mapZone; } else if (mapZone < 0) // Southern hemisphere. { hemisphere = "S"; pcsCodeVal = 16100 + abs(mapZone); } break; } } // End of "switch ( gcs )" if ( bDoImportFromEPSG == true ) oSRS.importFromEPSG( pcsCodeVal ); else { if(hemisphere != "") { oSRS.SetUTM(zone.toLong(), hemisphere != "S"); } else { oSRS.SetUTM(zone.toLong(), true); } } #endif } else if(projType == "ossimLlxyProjection") { OGRSpatialReference oGeogCS; oGeogCS.SetEquirectangular(0.0, 0.0, 0.0, 0.0); oGeogCS.SetAngularUnits(SRS_UA_DEGREE, atof(SRS_UA_DEGREE_CONV)); oSRS.CopyGeogCSFrom( &oGeogCS ); } else if(projType == "ossimEquDistCylProjection") { OGRSpatialReference oGeogCS; oGeogCS.SetEquirectangular(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); oGeogCS.SetAngularUnits(SRS_UA_DEGREE, atof(SRS_UA_DEGREE_CONV)); oSRS.CopyGeogCSFrom( &oGeogCS ); } else if(projType == "ossimSinusoidalProjection") { oSRS.SetSinusoidal(centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimCylEquAreaProjection") { oSRS.SetCEA(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimCassiniProjection") { oSRS.SetCS(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimAlbersProjection") { oSRS.SetACEA(parallel1.toDouble(), parallel2.toDouble(), originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimAzimEquDistProjection") { oSRS.SetAE(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimEckert4Projection") { oSRS.SetEckertIV(centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimEckert6Projection") { oSRS.SetEckertVI(centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimGnomonicProjection") { oSRS.SetGnomonic(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimLambertConformalConicProjection") { oSRS.SetLCC(parallel1.toDouble(), parallel2.toDouble(), originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimVanDerGrintenProjection") { oSRS.SetVDG(centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimMillerProjection") { oSRS.SetMC(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimMercatorProjection") { oSRS.SetMercator(originLat.toDouble(), centralMeridian.toDouble(), scale.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimMollweidProjection") { oSRS.SetMollweide(centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimNewZealandMapGridProjection") { oSRS.SetNZMG(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimOrthoGraphicProjection") { oSRS.SetOrthographic(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimPolarStereoProjection") { oSRS.SetPS(originLat.toDouble(), centralMeridian.toDouble(), scale.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimPolyconicProjectio") { oSRS.SetPolyconic(originLat.toDouble(), centralMeridian.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimStereographicProjection") { oSRS.SetStereographic(originLat.toDouble(), centralMeridian.toDouble(), scale.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else if(projType == "ossimTransMercatorProjection") { oSRS.SetTM(originLat.toDouble(), centralMeridian.toDouble(), scale.toDouble(), falseEastingNorthing.x, falseEastingNorthing.y); } else { cerr << "ossimOgcWktTranslator::fromOssimKwl:\n" << "Projection translation for " << projType << " not supported " << endl; } if(pcsCodeVal >= EPSG_CODE_MAX) { datumType = datumType.upcase(); if(datumType == "WGE") { oSRS.SetWellKnownGeogCS("WGS84"); } else if(datumType == "WGD") { oSRS.SetWellKnownGeogCS("WGS72"); } else if(datumType == "NAS-C") //1927 { oSRS.SetWellKnownGeogCS("NAD27"); } else if(datumType == "NAS") //1927 { oSRS.SetWellKnownGeogCS("NAD27"); } else if(datumType == "NAR-C") // 1983 { oSRS.SetWellKnownGeogCS("NAD83"); } else if(datumType == "NAR") // 1983 { oSRS.SetWellKnownGeogCS("NAD83"); } else if(datumType == "NTF") { oSRS.SetWellKnownGeogCS("EPSG:4275"); } else { cerr << "ossimOgcWktTranslator::fromOssimKwl: Datum translation for " << datumType <<" not supported" << endl; } } char* exportString = NULL; oSRS.exportToWkt(&exportString); if(exportString) { wktString = exportString; OGRFree(exportString); } return wktString; } bool ossimOgcWktTranslator::toOssimKwl( const ossimString& wktString, ossimKeywordlist &kwl, const char *prefix)const { static const char MODULE[] = "ossimOgcWktTranslator::toOssimKwl"; if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } const char* wkt = wktString.c_str(); OGRSpatialReferenceH hSRS = NULL; ossimDpt falseEastingNorthing; // Translate the WKT into an OGRSpatialReference. hSRS = OSRNewSpatialReference(NULL); if( OSRImportFromWkt( hSRS, (char **) &wkt ) != OGRERR_NONE ) { OSRDestroySpatialReference( hSRS ); return false; } // Determine if State Plane Coordinate System ossimString ossimProj = ""; const char* epsg_code = OSRGetAttrValue( hSRS, "AUTHORITY", 1 ); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "epsg_code: " << (epsg_code?epsg_code:"null") << "\n"; } //--- // Extract Units // ESH 11/2008: Check for geographic system when setting default units. // If geographic, use degrees. //--- // const char* units = OSRGetAttrValue( hSRS, "UNIT", 0 ); const char* units = NULL; OGR_SRSNode* node = ((OGRSpatialReference *)hSRS)->GetRoot(); int nbChild = node->GetChildCount(); for (int i = 0; i < nbChild; i++) { OGR_SRSNode* curChild = node->GetChild(i); if (strcmp(curChild->GetValue(), "UNIT") == 0) { units = curChild->GetChild(0)->GetValue(); } } if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "units: " << (units?units:"null") << "\n"; } ossimString ossim_units; bool bGeog = OSRIsGeographic(hSRS); if ( bGeog == false ) { ossim_units = "meters"; if ( units != NULL ) { // Down case to avoid case mismatch. ossimString s = units; s.downcase(); if( ( s == ossimString("us survey foot") ) || ( s == ossimString("u.s. foot") ) || ( s == ossimString("foot_us") ) ) { ossim_units = "us_survey_feet"; } else if( s == ossimString("degree") ) { ossim_units = "degrees"; } else if( ( s == ossimString("meter") ) || ( s == ossimString("metre") ) ) { ossim_units = "meters"; } } } else { ossim_units = "degrees"; } if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossim_units: " << ossim_units << "\n"; } // OLK 05/2010 -- ossimProj string was never being set to projection type (except state plane // which is not even a projection type)! This was a bug. Using EPSG factory to attempt to get // proper projection: if (epsg_code) { ossimString epsg_spec ("EPSG:"); epsg_spec += ossimString::toString(ossimString(epsg_code)); ossimProjection* proj = ossimEpsgProjectionFactory::instance()->createProjection(epsg_spec); if (proj) ossimProj = proj->getClassName(); delete proj; } if(ossimProj == "") { // Determine which other Projection System is represented. const char* pszProjection = OSRGetAttrValue( hSRS, "PROJECTION", 0 ); if(pszProjection) { ossimProj = wktToOssimProjection(pszProjection); } else { ossimString localCs = OSRGetAttrValue( hSRS, "LOCAL_CS", 0 ); localCs = localCs.upcase(); if(localCs == "GREATBRITAIN_GRID") { ossimProj = "ossimBngProjection"; } else if (ossim_units.contains("degree")) { // Assumption... ossimProj = "ossimEquDistCylProjection"; } } } // ESH 11/2008: Ticket #479, if we've got a geographic coordsys // make sure the units are set to degrees. if(ossimProj == "ossimEquDistCylProjection" ) ossim_units = "degrees"; // ESH 11/2008: Ticket #479, don't set units until we've checked // whether or not the projection was updated. kwl.add(prefix, ossimKeywordNames::UNITS_KW, ossim_units, true); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "DEBUG:" << "\nossimProj = " << ossimProj << endl; } kwl.add(prefix, ossimKeywordNames::TYPE_KW, ossimProj.c_str(), true); falseEastingNorthing.x = OSRGetProjParm(hSRS, SRS_PP_FALSE_EASTING, 0.0, NULL); falseEastingNorthing.y = OSRGetProjParm(hSRS, SRS_PP_FALSE_NORTHING, 0.0, NULL); if (epsg_code) { kwl.add(prefix, ossimKeywordNames::PCS_CODE_KW, epsg_code, true); } if(ossimProj == "ossimBngProjection") { kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimBngProjection", true); } else if(ossimProj == "ossimCylEquAreaProjection") { kwl.add(prefix, ossimKeywordNames::STD_PARALLEL_1_KW, OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::ORIGIN_LATITUDE_KW, OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL), true); ossimUnitType units = static_cast(ossimUnitTypeLut::instance()-> getEntryNumber(ossim_units.c_str())); if ( units == OSSIM_METERS || units == OSSIM_FEET || units == OSSIM_US_SURVEY_FEET ) { kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_KW, falseEastingNorthing.toString(), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW, ossim_units, true); } } else if(ossimProj == "ossimEquDistCylProjection") { kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimEquDistCylProjection", true); ossimUnitType units = static_cast(ossimUnitTypeLut::instance()-> getEntryNumber(ossim_units.c_str())); if ( units == OSSIM_METERS || units == OSSIM_FEET || units == OSSIM_US_SURVEY_FEET ) { kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_KW, falseEastingNorthing.toString(), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW, ossim_units, true); } kwl.add(prefix, ossimKeywordNames::ORIGIN_LATITUDE_KW, OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::CENTRAL_MERIDIAN_KW, OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL), true); } else if( (ossimProj == "ossimLambertConformalConicProjection") || (ossimProj == "ossimAlbersProjection") ) { kwl.add(prefix, ossimKeywordNames::TYPE_KW, ossimProj.c_str(), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_KW, falseEastingNorthing.toString(), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW, ossim_units, true); kwl.add(prefix, ossimKeywordNames::ORIGIN_LATITUDE_KW, OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::CENTRAL_MERIDIAN_KW, OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::STD_PARALLEL_1_KW, OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::STD_PARALLEL_2_KW, OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_2, 0.0, NULL), true); } else if(ossimProj == "ossimMercatorProjection") { kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimMercatorProjection", true); kwl.add(prefix, ossimKeywordNames::ORIGIN_LATITUDE_KW, OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::CENTRAL_MERIDIAN_KW, OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_KW, falseEastingNorthing.toString(), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW, ossim_units, true); } else if(ossimProj == "ossimSinusoidalProjection") { kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimSinusoidalProjection", true); kwl.add(prefix, ossimKeywordNames::CENTRAL_MERIDIAN_KW, OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_KW, falseEastingNorthing.toString(), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW, ossim_units, true); } else if(ossimProj == "ossimTransMercatorProjection") { int bNorth; int nZone = OSRGetUTMZone( hSRS, &bNorth ); if( nZone != 0 ) { kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimUtmProjection", true); kwl.add(prefix, ossimKeywordNames::ZONE_KW, nZone, true); if( bNorth ) { kwl.add(prefix, ossimKeywordNames::HEMISPHERE_KW, "N", true); } else { kwl.add(prefix, ossimKeywordNames::HEMISPHERE_KW, "S", true); } } else { kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimTransMercatorProjection", true); kwl.add(prefix, ossimKeywordNames::SCALE_FACTOR_KW, OSRGetProjParm(hSRS, SRS_PP_SCALE_FACTOR, 1.0, NULL), true); kwl.add(prefix, ossimKeywordNames::ORIGIN_LATITUDE_KW, OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::CENTRAL_MERIDIAN_KW, OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_KW, falseEastingNorthing.toString(), true); kwl.add(prefix, ossimKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW, ossim_units, true); } } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimOgcWktTranslator::toOssimKwl DEBUG:\n" << "Projection conversion to OSSIM not supported !!!!!!!!!\n" << "Please send the following string to the development staff\n" << "to be added to the transaltion to OSSIM\n" << wkt << endl; } return false; } // extract out the datum // const char *datum = OSRGetAttrValue( hSRS, "DATUM", 0 ); ossimString oDatum = "WGE"; if( datum ) { oDatum = wktToOssimDatum(datum); if(oDatum == "") { oDatum = "WGE"; } } // Trouble with ESPG 3857 // The ellipsoid used by ossim is the WGS84 one with minor and major axis differs. // We need to build our own projection in this case. if( oDatum == "WGE" && ossimString(epsg_code) == "3857" ) { oDatum = "6055"; } kwl.add(prefix, ossimKeywordNames::DATUM_KW, oDatum, true); OSRDestroySpatialReference( hSRS ); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = true" << std::endl; } return true; } void ossimOgcWktTranslator::initializeDatumTable() { // theWktToOssimDatumTranslation.insert(make_pair(ossimString("North_American_Datum_1927"), // ossimString("NAS-C"))); // theWktToOssimDatumTranslation.insert(make_pair(ossimString("North_American_Datum_1983"), // ossimString("NAR-C"))); // theWktToOssimDatumTranslation.insert(make_pair(ossimString("WGS_1984"), // ossimString("WGE"))); // theWktToOssimDatumTranslation.insert(make_pair(ossimString("OSGB_1936"), // ossimString("OSGB_1936"))); theOssimToWktDatumTranslation.insert(make_pair(std::string("NAS-C"), std::string("North_American_Datum_1927"))); theOssimToWktDatumTranslation.insert(make_pair(std::string("NAR-C"), std::string("North_American_Datum_1983"))); theOssimToWktDatumTranslation.insert(make_pair(std::string("NAS"), std::string("North_American_Datum_1927"))); theOssimToWktDatumTranslation.insert(make_pair(std::string("NAR"), std::string("North_American_Datum_1983"))); theOssimToWktDatumTranslation.insert(make_pair(std::string("WGE"), std::string("WGS_1984"))); theWktToOssimDatumTranslation.insert(make_pair(std::string("OSGB_1936"), std::string("OGB-B"))); theWktToOssimDatumTranslation.insert(make_pair(std::string("Nouvelle_Triangulation_Francaise"), std::string("NTF"))); } void ossimOgcWktTranslator::initializeProjectionTable() { theWktToOssimProjectionTranslation.insert(make_pair(std::string(SRS_PT_TRANSVERSE_MERCATOR), std::string("ossimTransMercatorProjection"))); theWktToOssimProjectionTranslation.insert(make_pair(std::string(SRS_PT_EQUIRECTANGULAR), std::string("ossimEquDistCylProjection"))); theWktToOssimProjectionTranslation.insert(make_pair(std::string(SRS_PT_ALBERS_CONIC_EQUAL_AREA), std::string("ossimAlbersProjection"))); theWktToOssimProjectionTranslation.insert(make_pair(std::string(SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP), std::string("ossimLambertConformalConicProjection"))); theWktToOssimProjectionTranslation.insert(make_pair(std::string(SRS_PT_SINUSOIDAL), std::string("ossimSinusoidalProjection"))); theWktToOssimProjectionTranslation.insert(make_pair(std::string(SRS_PT_MERCATOR_1SP), std::string("ossimMercatorProjection"))); theOssimToWktProjectionTranslation.insert(make_pair(std::string("ossimTransMercatorProjection"), std::string(SRS_PT_TRANSVERSE_MERCATOR))); theOssimToWktProjectionTranslation.insert(make_pair(std::string("ossimEquDistCylProjection"), std::string(SRS_PT_EQUIRECTANGULAR))); theOssimToWktProjectionTranslation.insert(make_pair(std::string("ossimAlbersProjection"), std::string(SRS_PT_ALBERS_CONIC_EQUAL_AREA))); theOssimToWktProjectionTranslation.insert(make_pair(std::string("ossimLambertConformalConicProjection"), std::string(SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP))); theOssimToWktProjectionTranslation.insert(make_pair(std::string("ossimSinusoidalProjection"), std::string(SRS_PT_SINUSOIDAL))); theOssimToWktProjectionTranslation.insert(make_pair(std::string("ossimMercatorProjection"), std::string(SRS_PT_MERCATOR_1SP))); } ossimString ossimOgcWktTranslator::wktToOssimDatum(const ossimString& datum)const { if(datum.contains("North_American_Datum_1927")) { return "NAS-C"; } if(datum.contains("North_American_Datum_1983")) { return "NAR-C"; } if(datum.contains("WGS_1984")) { return "WGE"; } if(datum.contains("OSGA")) { return "OGB-A"; } if(datum.contains("OSGB")) { return "OGB-B"; } if(datum.contains("OSGC")) { return "OGB-C"; } if(datum.contains("OSGD")) { return "OGB-D"; } if(datum.contains("Nouvelle_Triangulation_Francaise")) { return "NTF"; } return ""; } ossimString ossimOgcWktTranslator::ossimToWktDatum(const ossimString& datum)const { ossimString result; map::const_iterator i = theOssimToWktDatumTranslation.find(datum); if(i != theOssimToWktDatumTranslation.end()) { result = (*i).second; } return result; } ossimString ossimOgcWktTranslator::wktToOssimProjection(const ossimString& datum)const { std::string result; map::const_iterator i = theWktToOssimProjectionTranslation.find(datum); if(i != theWktToOssimProjectionTranslation.end()) { result = (*i).second; } return result; } ossimString ossimOgcWktTranslator::ossimToWktProjection(const ossimString& datum)const { ossimString result; map::const_iterator i = theOssimToWktProjectionTranslation.find(datum); if(i != theOssimToWktProjectionTranslation.end()) { result = (*i).second; } return result; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/gdal/ossimOgcWktTranslator.h000066400000000000000000000035011301006202600277450ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2000 ImageLinks Inc. // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: Frank Warmerdam (warmerda@home.com) // // Description: // // Contains function declarations for translating between OGC WKT strings, // and OSSIM projection definitions. //******************************************************************* // $Id: ossimOgcWktTranslator.h 20724 2012-04-13 21:00:52Z dburken $ #ifndef ossimOgcWktTranslator_HEADER #define ossimOgcWktTranslator_HEADER #include #include #include #include #include class ossimKeywordlist; class OSSIM_PLUGINS_DLL ossimOgcWktTranslator { public: ossimOgcWktTranslator(); bool toOssimKwl(const ossimString& wktString, ossimKeywordlist& kwl, const char* prefix=NULL)const; ossimString fromOssimKwl(const ossimKeywordlist& kwl, const char* prefix=NULL)const; /*! * Returns the empty string if the datum is not found * */ ossimString wktToOssimDatum(const ossimString& datum)const; ossimString ossimToWktDatum(const ossimString& datum)const; ossimString wktToOssimProjection(const ossimString& projection)const; ossimString ossimToWktProjection(const ossimString& projection)const; protected: std::map theWktToOssimDatumTranslation; std::map theWktToOssimProjectionTranslation; std::map theOssimToWktDatumTranslation; std::map theOssimToWktProjectionTranslation; void initializeDatumTable(); void initializeProjectionTable(); }; #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/000077500000000000000000000000001301006202600234755ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/000077500000000000000000000000001301006202600255365ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarData.cpp000066400000000000000000000106651301006202600311050ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include // Static trace for debugging static ossimTrace traceDebug("ossimAlosPalsarData:debug"); namespace ossimplugins { const int AlosPalsarData::AlosPalsarDataFileDescriptorID = 1; const int AlosPalsarData::AlosPalsarSignalDataID = 2; AlosPalsarData::AlosPalsarData() { } AlosPalsarData::~AlosPalsarData() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const AlosPalsarData& data) { std::map::const_iterator it = data._records.begin(); while (it != data._records.end()) { (*it).second->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, AlosPalsarData& data) { data.ClearRecords(); AlosPalsarRecordHeader header; is >> header; AlosPalsarRecord* record = new AlosPalsarDataFileDescriptor; if (record != NULL) { record->Read(is); data._records[header.get_rec_seq()] = record; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length() - 12); delete buff; } std::streampos filePosition; filePosition = is.tellg(); is >> header; record = new AlosPalsarSignalData; if (record != NULL) { record->Read(is); data._records[header.get_rec_seq()] = record; // std::cout << "Record sequence number = " << header.get_rec_seq() << std::endl; } is.seekg(filePosition); // Rewind file pointer to start of record // Then, advance pointer to next record is.seekg(static_cast(header.get_length()), std::ios::cur); return is; } AlosPalsarData::AlosPalsarData(const AlosPalsarData& rhs) { std::map::const_iterator it = rhs._records.begin(); while (it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } } AlosPalsarData& AlosPalsarData::operator=(const AlosPalsarData& rhs) { ClearRecords(); std::map::const_iterator it = rhs._records.begin(); while (it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } return *this; } void AlosPalsarData::ClearRecords() { std::map::const_iterator it = _records.begin(); while (it != _records.end()) { delete(*it).second; ++it; } _records.clear(); } bool AlosPalsarData::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "AlosPalsarData::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result = true; /* * Adding metadata necessary to the sensor model in the keywordlist */ const AlosPalsarDataFileDescriptor *datafiledesc = get_AlosPalsarDataFileDescriptor(); if (datafiledesc != NULL) { kwl.add(prefix, "num_lines", datafiledesc->get_num_lines(), true); kwl.add(prefix, "num_pix_in_line", datafiledesc->get_num_pix_in_line(), true); } else { result = false; } const AlosPalsarSignalData *signalData = get_AlosPalsarSignalData(); if (datafiledesc != NULL) { kwl.add(prefix, "pulse_repetition_frequency", signalData->get_pulse_repetition_frequency(), true); // slant range to 1st data sample in meters kwl.add(prefix, "slant_range_to_1st_data_sample", signalData->get_slant_range_to_1st_data_sample(), true); } else { result = false; } return result; } const AlosPalsarDataFileDescriptor * AlosPalsarData::get_AlosPalsarDataFileDescriptor() const { return dynamic_cast(_records.find(AlosPalsarDataFileDescriptorID)->second); } const AlosPalsarSignalData * AlosPalsarData::get_AlosPalsarSignalData() const { // TODO: Check if _records[AlosPalsarSignalDataID] works return dynamic_cast(_records.find(AlosPalsarSignalDataID)->second); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarData.h000066400000000000000000000041371301006202600305470ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarData_h #define AlosPalsarData_h #include #include class ossimKeywordlist; namespace ossimplugins { class AlosPalsarRecord; class AlosPalsarDataFileDescriptor; class AlosPalsarSignalData; /** * @ingroup AlosPalsarDataFile * @brief This class is able to read the Leader file of the AlosPalsar file structure */ class AlosPalsarData { public: /** * @brief Constructor */ AlosPalsarData(); /** * @brief Destructor */ virtual ~AlosPalsarData(); /** * @brief This function write the AlosPalsarData in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarData& data); /** * @brief This function read a AlosPalsarData from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarData& data); /** * @brief Copy constructor */ AlosPalsarData(const AlosPalsarData& rhs); /** * @brief Copy operator */ AlosPalsarData& operator=(const AlosPalsarData& rhs); /** * @brief Remove all the previous records from the AlosPalsarData */ void ClearRecords(); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0) const; const AlosPalsarDataFileDescriptor * get_AlosPalsarDataFileDescriptor() const; const AlosPalsarSignalData * get_AlosPalsarSignalData() const; protected: typedef std::map RecordType; RecordType _records; static const int AlosPalsarDataFileDescriptorID; static const int AlosPalsarSignalDataID; private: }; } #endif AlosPalsarDataFileDescriptor.cpp000066400000000000000000000034461301006202600336640ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarDataFileDescriptor::AlosPalsarDataFileDescriptor() : AlosPalsarRecord("sar_desc_rec") { } AlosPalsarDataFileDescriptor::~AlosPalsarDataFileDescriptor() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarDataFileDescriptor& data) { os << "_num_lines:" << data._num_lines << std::endl; os << "_num_pix_in_line:" << data._num_pix_in_line << std::endl; return os; } std::istream& operator>>(std::istream& is, AlosPalsarDataFileDescriptor& data) { char buf6[7]; buf6[6] = '\0'; char buf168[169]; buf168[168] = '\0'; char buf94[95]; buf94[94] = '\0'; char buf8[9]; buf8[8] = '\0'; is.read(buf168, 168); is.read(buf6, 6); data._num_lines = atoi(buf6); is.read(buf94, 94); int tmpval; is.read(buf8, 8); tmpval = atoi(buf8); data._num_pix_in_line = tmpval / 8; // Assume data always in 8-byte complex format char buf432[433]; buf432[432] = '\0'; is.read(buf432, 432); return is; } AlosPalsarDataFileDescriptor::AlosPalsarDataFileDescriptor(const AlosPalsarDataFileDescriptor& rhs): AlosPalsarRecord(rhs), _num_pix_in_line(rhs._num_pix_in_line), _num_lines(rhs._num_lines) { } AlosPalsarDataFileDescriptor& AlosPalsarDataFileDescriptor::operator=(const AlosPalsarDataFileDescriptor& rhs) { _num_lines = rhs._num_lines; _num_pix_in_line = rhs._num_pix_in_line; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarDataFileDescriptor.h000066400000000000000000000046761301006202600334160ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarDataFileDescriptor_h #define AlosPalsarDataFileDescriptor_h #include #include #include #include namespace ossimplugins { /** * @ingroup SARLeaderAlosPalsarDataFileDescriptorRecord * @brief This class is able to read the SAR leader file descriptor record of the leader file */ class AlosPalsarDataFileDescriptor : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarDataFileDescriptor(); /** * @brief Destructor */ ~AlosPalsarDataFileDescriptor(); /** * @brief This function write the AlosPalsarDataFileDescriptor in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarDataFileDescriptor& data); /** * @brief This function read a AlosPalsarDataFileDescriptor from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarDataFileDescriptor& data); /** * @brief Copy constructor */ AlosPalsarDataFileDescriptor(const AlosPalsarDataFileDescriptor& rhs); /** * @brief Copy operator */ AlosPalsarDataFileDescriptor& operator=(const AlosPalsarDataFileDescriptor& rhs); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarDataFileDescriptor(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarDataFileDescriptor(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; int get_num_pix_in_line() const { return _num_pix_in_line; }; int get_num_lines() const { return _num_lines; }; protected: /** * @brief num_pix_in_line */ int _num_pix_in_line; /** * @brief num_lines */ int _num_lines; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarDataSetSummary.cpp000066400000000000000000000446711301006202600331430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarDataSetSummary::AlosPalsarDataSetSummary() : AlosPalsarRecord("dataset_sum_rec") { } AlosPalsarDataSetSummary::~AlosPalsarDataSetSummary() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarDataSetSummary& data) { os << "seq_num:" << data._seq_num << std::endl; os << "sar_chn:" << data._sar_chn << std::endl; os << "scene_id:" << data._scene_id.c_str() << std::endl; os << "scene_des:" << data._scene_des.c_str() << std::endl; os << "inp_sctim:" << data._inp_sctim.c_str() << std::endl; os << "asc_des:" << data._asc_des.c_str() << std::endl; os << "pro_lat:" << data._pro_lat << std::endl; os << "pro_long:" << data._pro_long << std::endl; os << "pro_head:" << data._pro_head << std::endl; os << "ellip_des:" << data._ellip_des.c_str() << std::endl; os << "ellip_maj:" << data._ellip_maj << std::endl; os << "ellip_min:" << data._ellip_min << std::endl; os << "earth_mass:" << data._earth_mass << std::endl; os << "grav_const:" << data._grav_const << std::endl; os << "ellip_j[0]:" << data._ellip_j[0] << std::endl; os << "ellip_j[1]:" << data._ellip_j[1] << std::endl; os << "ellip_j[2]:" << data._ellip_j[2] << std::endl; os << "terrain_h:" << data._terrain_h << std::endl; os << "sc_lin:" << data._sc_lin << std::endl; os << "sc_pix:" << data._sc_pix << std::endl; os << "scene_len:" << data._scene_len << std::endl; os << "scene_wid:" << data._scene_wid << std::endl; os << "nchn:" << data._nchn << std::endl; os << "mission_id:" << data._mission_id.c_str() << std::endl; os << "sensor_id:" << data._sensor_id.c_str() << std::endl; os << "orbit_num:" << data._orbit_num.c_str() << std::endl; os << "plat_lat:" << data._plat_lat << std::endl; os << "plat_long:" << data._plat_long << std::endl; os << "plat_head:" << data._plat_head << std::endl; os << "clock_ang:" << data._clock_ang << std::endl; os << "incident_ang:" << data._incident_ang << std::endl; os << "wave_length:" << data._wave_length << std::endl; os << "motion_comp:" << data._motion_comp.c_str() << std::endl; os << "pulse_code:" << data._pulse_code.c_str() << std::endl; for (int i = 0; i < 5; i++) { os << "ampl_coef[" << i << "]:" << data._ampl_coef[i] << std::endl; } for (int i = 0; i < 5; i++) { os << "phas_coef[" << i << "]:" << data._phas_coef[i] << std::endl; } os << "chirp_ext_ind:" << data._chirp_ext_ind << std::endl; os << "fr:" << data._fr << std::endl; os << "rng_gate:" << data._rng_gate << std::endl; os << "rng_length:" << data._rng_length << std::endl; os << "baseband_f:" << data._baseband_f.c_str() << std::endl; os << "rngcmp_f:" << data._rngcmp_f.c_str() << std::endl; os << "gn_polar:" << data._gn_polar << std::endl; os << "gn_cross:" << data._gn_cross << std::endl; os << "chn_bits:" << data._chn_bits << std::endl; os << "quant_desc:" << data._quant_desc.c_str() << std::endl; os << "i_bias:" << data._i_bias << std::endl; os << "q_bias:" << data._q_bias << std::endl; os << "iq_ratio:" << data._iq_ratio << std::endl; os << "mech_sight:" << data._mech_sight << std::endl; os << "fa:" << data._fa << std::endl; os << "sat_bintim:" << data._sat_bintim.c_str() << std::endl; os << "sat_clktim:" << data._sat_clktim.c_str() << std::endl; os << "sat_clkinc:" << data._sat_clkinc.c_str() << std::endl; os << "fac_id:" << data._fac_id.c_str() << std::endl; os << "sys_id:" << data._sys_id.c_str() << std::endl; os << "ver_id:" << data._ver_id.c_str() << std::endl; os << "prod_type:" << data._prod_type.c_str() << std::endl; os << "algor_id:" << data._algor_id.c_str() << std::endl; os << "n_azilok:" << data._n_azilok << std::endl; os << "n_rnglok:" << data._n_rnglok << std::endl; os << "bnd_azilok:" << data._bnd_azilok << std::endl; os << "bnd_rnglok:" << data._bnd_rnglok << std::endl; os << "bnd_azi:" << data._bnd_azi << std::endl; os << "bnd_rng:" << data._bnd_rng << std::endl; os << "azi_weight:" << data._azi_weight.c_str() << std::endl; os << "rng_weight:" << data._rng_weight.c_str() << std::endl; os << "data_inpsrc:" << data._data_inpsrc.c_str() << std::endl; os << "rng_res:" << data._rng_res << std::endl; os << "azi_res:" << data._azi_res << std::endl; os << "alt_dopcen[0]:" << data._alt_dopcen[0] << std::endl; os << "alt_dopcen[1]:" << data._alt_dopcen[1] << std::endl; os << "alt_dopcen[2]:" << data._alt_dopcen[2] << std::endl; os << "crt_dopcen[0]:" << data._crt_dopcen[0] << std::endl; os << "crt_dopcen[1]:" << data._crt_dopcen[1] << std::endl; os << "crt_dopcen[2]:" << data._crt_dopcen[2] << std::endl; os << "time_dir_pix:" << data._time_dir_pix.c_str() << std::endl; os << "time_dir_lin:" << data._time_dir_lin.c_str() << std::endl; os << "alt_rate[0]:" << data._alt_rate[0] << std::endl; os << "alt_rate[1]:" << data._alt_rate[1] << std::endl; os << "alt_rate[2]:" << data._alt_rate[2] << std::endl; os << "crt_rate[0]:" << data._crt_rate[0] << std::endl; os << "crt_rate[1]:" << data._crt_rate[1] << std::endl; os << "crt_rate[2]:" << data._crt_rate[2] << std::endl; os << "clutter_lock:" << data._line_cont.c_str() << std::endl; os << "clutter_lock:" << data._clutter_lock.c_str() << std::endl; os << "auto_focus:" << data._auto_focus.c_str() << std::endl; os << "line_spacing:" << data._line_spacing << std::endl; os << "pix_spacing:" << data._pix_spacing << std::endl; os << "rngcmp_desg:" << data._rngcmp_desg.c_str() << std::endl; os << "dopcen_range[0]:" << data._dopcen_range[0] << std::endl; os << "dopcen_range[1]:" << data._dopcen_range[1] << std::endl; /** * @Data from 1767 to 4096 to be added */ return os; } std::istream& operator>>(std::istream& is, AlosPalsarDataSetSummary& data) { char buf16[17]; buf16[16] = '\0'; char buf32[33]; buf32[32] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf2330[2331]; //data skip from 1767 to 4096// buf2330[2330] = '\0'; //data skip from 1767 to 4096// is.read(buf4, 4); data._seq_num = atoi(buf4); is.read(buf4, 4); data._sar_chn = atoi(buf4); is.read(buf16, 16); data._scene_id = buf16; is.read(buf32, 32); data._scene_des = buf32; is.read(buf32, 32); data._inp_sctim = buf32; is.read(buf16, 16); data._asc_des = buf16; is.read(buf16, 16); data._pro_lat = atof(buf16); is.read(buf16, 16); data._pro_long = atof(buf16); is.read(buf16, 16); data._pro_head = atof(buf16); is.read(buf16, 16); data._ellip_des = buf16; is.read(buf16, 16); data._ellip_maj = atof(buf16); is.read(buf16, 16); data._ellip_min = atof(buf16); is.read(buf16, 16); data._earth_mass = atof(buf16); is.read(buf16, 16); data._grav_const = atof(buf16); is.read(buf16, 16); data._ellip_j[0] = atof(buf16); is.read(buf16, 16); data._ellip_j[1] = atof(buf16); is.read(buf16, 16); data._ellip_j[2] = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._terrain_h = atof(buf16); is.read(buf8, 8); data._sc_lin = atoi(buf8); is.read(buf8, 8); data._sc_pix = atoi(buf8); is.read(buf16, 16); data._scene_len = atof(buf16); is.read(buf16, 16); data._scene_wid = atof(buf16); is.read(buf16, 16); is.read(buf4, 4); data._nchn = atoi(buf4); is.read(buf4, 4); is.read(buf16, 16); data._mission_id = buf16; is.read(buf32, 32); data._sensor_id = buf32; is.read(buf8, 8); data._orbit_num = buf8; is.read(buf8, 8); data._plat_lat = atof(buf8); is.read(buf8, 8); data._plat_long = atof(buf8); is.read(buf8, 8); data._plat_head = atof(buf8); is.read(buf8, 8); data._clock_ang = atof(buf8); is.read(buf8, 8); data._incident_ang = atof(buf8); is.read(buf8, 8); is.read(buf16, 16); data._wave_length = atof(buf16); is.read(buf8, 2); buf8[2] = '\0'; data._motion_comp = buf8; is.read(buf16, 16); data._pulse_code = buf16; for (int i = 0; i < 5; i++) { is.read(buf16, 16); data._ampl_coef[i] = atof(buf16); } for (int i = 0; i < 5; i++) { is.read(buf16, 16); data._phas_coef[i] = atof(buf16); } is.read(buf8, 8); data._chirp_ext_ind = atoi(buf8); is.read(buf8, 8); is.read(buf16, 16); data._fr = atof(buf16); is.read(buf16, 16); data._rng_gate = atof(buf16); is.read(buf16, 16); data._rng_length = atof(buf16); is.read(buf8, 4); buf8[4] = '\0'; data._baseband_f = buf8; is.read(buf8, 4); buf8[4] = '\0'; data._rngcmp_f = buf8; is.read(buf16, 16); data._gn_polar = atof(buf16); is.read(buf16, 16); data._gn_cross = atof(buf16); is.read(buf8, 8); data._chn_bits = atoi(buf8); is.read(buf16, 12); buf16[12] = '\0'; data._quant_desc = buf16; is.read(buf16, 16); data._i_bias = atof(buf16); is.read(buf16, 16); data._q_bias = atof(buf16); is.read(buf16, 16); data._iq_ratio = atof(buf16); is.read(buf32, 32); is.read(buf16, 16); is.read(buf16, 16); data._mech_sight = atof(buf16); is.read(buf4, 4); is.read(buf16, 16); data._fa = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); is.read(buf16, 16); data._sat_bintim = buf16; is.read(buf32, 32); data._sat_clktim = buf32; is.read(buf8, 8); data._sat_clkinc = buf8; is.read(buf8, 8); is.read(buf16, 16); data._fac_id = buf16; is.read(buf8, 8); data._sys_id = buf8; is.read(buf8, 8); data._ver_id = buf8; is.read(buf32, 32); is.read(buf32, 32); data._prod_type = buf32; is.read(buf32, 32); data._algor_id = buf32; is.read(buf16, 16); data._n_azilok = atof(buf16); is.read(buf16, 16); data._n_rnglok = atof(buf16); is.read(buf16, 16); data._bnd_azilok = atof(buf16); is.read(buf16, 16); data._bnd_rnglok = atof(buf16); is.read(buf16, 16); data._bnd_azi = atof(buf16); is.read(buf16, 16); data._bnd_rng = atof(buf16); is.read(buf32, 32); data._azi_weight = buf32; is.read(buf32, 32); data._rng_weight = buf32; is.read(buf16, 16); data._data_inpsrc = buf16; is.read(buf16, 16); data._rng_res = atof(buf16); is.read(buf16, 16); data._azi_res = atof(buf16); is.read(buf32, 32); is.read(buf16, 16); data._alt_dopcen[0] = atof(buf16); is.read(buf16, 16); data._alt_dopcen[1] = atof(buf16); is.read(buf16, 16); data._alt_dopcen[2] = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._crt_dopcen[0] = atof(buf16); is.read(buf16, 16); data._crt_dopcen[1] = atof(buf16); is.read(buf16, 16); data._crt_dopcen[2] = atof(buf16); is.read(buf8, 8); data._time_dir_pix = buf8; is.read(buf8, 8); data._time_dir_lin = buf8; is.read(buf16, 16); data._alt_rate[0] = atof(buf16); is.read(buf16, 16); data._alt_rate[1] = atof(buf16); is.read(buf16, 16); data._alt_rate[2] = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._crt_rate[0] = atof(buf16); is.read(buf16, 16); data._crt_rate[1] = atof(buf16); is.read(buf16, 16); data._crt_rate[2] = atof(buf16); is.read(buf16, 16); is.read(buf8, 8); data._line_cont = buf8; is.read(buf4, 4); data._clutter_lock = buf4; is.read(buf4, 4); data._auto_focus = buf4; is.read(buf16, 16); data._line_spacing = atof(buf16); is.read(buf16, 16); data._pix_spacing = atof(buf16); is.read(buf16, 16); data._rngcmp_desg = buf16; is.read(buf16, 16); data._dopcen_range[0] = atof(buf16); is.read(buf16, 16); data._dopcen_range[1] = atof(buf16); /** * @Data from 1767 to 4096 to be added */ is.read(buf2330, 2330); return is; } AlosPalsarDataSetSummary::AlosPalsarDataSetSummary(const AlosPalsarDataSetSummary& rhs): AlosPalsarRecord(rhs), _seq_num(rhs._seq_num), _sar_chn(rhs._sar_chn), _scene_id(rhs._scene_id), _scene_des(rhs._scene_des), _inp_sctim(rhs._inp_sctim), _asc_des(rhs._asc_des), _pro_lat(rhs._pro_lat), _pro_long(rhs._pro_long), _pro_head(rhs._pro_head), _ellip_des(rhs._ellip_des), _ellip_maj(rhs._ellip_maj), _ellip_min(rhs._ellip_min), _earth_mass(rhs._earth_mass), _grav_const(rhs._grav_const), _terrain_h(rhs._terrain_h), _sc_lin(rhs._sc_lin), _sc_pix(rhs._sc_pix), _scene_len(rhs._scene_len), _scene_wid(rhs._scene_wid), _nchn(rhs._nchn), _mission_id(rhs._mission_id), _sensor_id(rhs._sensor_id), _orbit_num(rhs._orbit_num), _plat_lat(rhs._plat_lat), _plat_long(rhs._plat_long), _plat_head(rhs._plat_head), _clock_ang(rhs._clock_ang), _incident_ang(rhs._incident_ang), _wave_length(rhs._wave_length), _motion_comp(rhs._motion_comp), _pulse_code(rhs._pulse_code), _chirp_ext_ind(rhs._chirp_ext_ind), _fr(rhs._fr), _rng_gate(rhs._rng_gate), _rng_length(rhs._rng_length), _baseband_f(rhs._baseband_f), _rngcmp_f(rhs._rngcmp_f), _gn_polar(rhs._gn_polar), _gn_cross(rhs._gn_cross), _chn_bits(rhs._chn_bits), _quant_desc(rhs._quant_desc), _i_bias(rhs._i_bias), _q_bias(rhs._q_bias), _iq_ratio(rhs._iq_ratio), _mech_sight(rhs._mech_sight), _fa(rhs._fa), _sat_bintim(rhs._sat_bintim), _sat_clktim(rhs._sat_clktim), _sat_clkinc(rhs._sat_clkinc), _fac_id(rhs._fac_id), _sys_id(rhs._sys_id), _ver_id(rhs._ver_id), _prod_type(rhs._prod_type), _algor_id(rhs._algor_id), _n_azilok(rhs._n_azilok), _n_rnglok(rhs._n_rnglok), _bnd_azilok(rhs._bnd_azilok), _bnd_rnglok(rhs._bnd_rnglok), _bnd_azi(rhs._bnd_azi), _bnd_rng(rhs._bnd_rng), _azi_weight(rhs._azi_weight), _rng_weight(rhs._rng_weight), _data_inpsrc(rhs._data_inpsrc), _rng_res(rhs._rng_res), _azi_res(rhs._azi_res), _time_dir_pix(rhs._time_dir_pix), _time_dir_lin(rhs._time_dir_lin), _line_cont(rhs._line_cont), _clutter_lock(rhs._clutter_lock), _auto_focus(rhs._auto_focus), _line_spacing(rhs._line_spacing), _pix_spacing(rhs._pix_spacing), _rngcmp_desg(rhs._rngcmp_desg) //to be added// { _ellip_j[0] = rhs._ellip_j[0]; _ellip_j[1] = rhs._ellip_j[1]; _ellip_j[2] = rhs._ellip_j[2]; _ampl_coef[0] = rhs._ampl_coef[0]; _ampl_coef[1] = rhs._ampl_coef[1]; _ampl_coef[2] = rhs._ampl_coef[2]; _ampl_coef[3] = rhs._ampl_coef[3]; _ampl_coef[4] = rhs._ampl_coef[4]; _phas_coef[0] = rhs._phas_coef[0]; _phas_coef[1] = rhs._phas_coef[1]; _phas_coef[2] = rhs._phas_coef[2]; _phas_coef[3] = rhs._phas_coef[3]; _phas_coef[4] = rhs._phas_coef[4]; _alt_dopcen[0] = rhs._alt_dopcen[0]; _alt_dopcen[1] = rhs._alt_dopcen[1]; _alt_dopcen[2] = rhs._alt_dopcen[2]; _crt_dopcen[0] = rhs._crt_dopcen[0]; _crt_dopcen[1] = rhs._crt_dopcen[1]; _crt_dopcen[2] = rhs._crt_dopcen[2]; _alt_rate[0] = rhs._alt_rate[0]; _alt_rate[1] = rhs._alt_rate[1]; _alt_rate[2] = rhs._alt_rate[2]; _crt_rate[0] = rhs._crt_rate[0]; _crt_rate[1] = rhs._crt_rate[1]; _crt_rate[2] = rhs._crt_rate[2]; _dopcen_range[0] = rhs._dopcen_range[0]; _dopcen_range[1] = rhs._dopcen_range[1]; } AlosPalsarDataSetSummary& AlosPalsarDataSetSummary::operator=(const AlosPalsarDataSetSummary& rhs) { _seq_num = rhs._seq_num; _sar_chn = rhs._sar_chn; _scene_id = rhs._scene_id; _scene_des = rhs._scene_des; _inp_sctim = rhs._inp_sctim; _asc_des = rhs._asc_des; _pro_lat = rhs._pro_lat; _pro_long = rhs._pro_long; _pro_head = rhs._pro_head; _ellip_des = rhs._ellip_des; _ellip_maj = rhs._ellip_maj; _ellip_min = rhs._ellip_min; _earth_mass = rhs._earth_mass; _grav_const = rhs._grav_const; _terrain_h = rhs._terrain_h; _sc_lin = rhs._sc_lin; _sc_pix = rhs._sc_pix; _scene_len = rhs._scene_len; _scene_wid = rhs._scene_wid; _nchn = rhs._nchn; _mission_id = rhs._mission_id; _sensor_id = rhs._sensor_id; _orbit_num = rhs._orbit_num; _plat_lat = rhs._plat_lat; _plat_long = rhs._plat_long; _plat_head = rhs._plat_head; _clock_ang = rhs._clock_ang; _incident_ang = rhs._incident_ang; _wave_length = rhs._wave_length; _motion_comp = rhs._motion_comp; _pulse_code = rhs._pulse_code; _chirp_ext_ind = rhs._chirp_ext_ind; _fr = rhs._fr; _rng_gate = rhs._rng_gate; _rng_length = rhs._rng_length; _baseband_f = rhs._baseband_f; _rngcmp_f = rhs._rngcmp_f; _gn_polar = rhs._gn_polar; _gn_cross = rhs._gn_cross; _chn_bits = rhs._chn_bits; _quant_desc = rhs._quant_desc; _i_bias = rhs._i_bias; _q_bias = rhs._q_bias; _iq_ratio = rhs._iq_ratio; _mech_sight = rhs._mech_sight; _fa = rhs._fa; _sat_bintim = rhs._sat_bintim; _sat_clktim = rhs._sat_clktim; _sat_clkinc = rhs._sat_clkinc; _fac_id = rhs._fac_id; _sys_id = rhs._sys_id; _ver_id = rhs._ver_id; _prod_type = rhs._prod_type; _algor_id = rhs._algor_id; _n_azilok = rhs._n_azilok; _n_rnglok = rhs._n_rnglok; _bnd_azilok = rhs._bnd_azilok; _bnd_rnglok = rhs._bnd_rnglok; _bnd_azi = rhs._bnd_azi; _bnd_rng = rhs._bnd_rng; _azi_weight = rhs._azi_weight; _rng_weight = rhs._rng_weight; _data_inpsrc = rhs._data_inpsrc; _rng_res = rhs._rng_res; _azi_res = rhs._azi_res; _time_dir_pix = rhs._time_dir_pix; _time_dir_lin = rhs._time_dir_lin; _line_cont = rhs._line_cont; _clutter_lock = rhs._clutter_lock; _auto_focus = rhs._auto_focus; _line_spacing = rhs._line_spacing; _pix_spacing = rhs._pix_spacing; _rngcmp_desg = rhs._rngcmp_desg; _ellip_j[0] = rhs._ellip_j[0]; _ellip_j[1] = rhs._ellip_j[1]; _ellip_j[2] = rhs._ellip_j[2]; _ampl_coef[0] = rhs._ampl_coef[0]; _ampl_coef[1] = rhs._ampl_coef[1]; _ampl_coef[2] = rhs._ampl_coef[2]; _ampl_coef[3] = rhs._ampl_coef[3]; _ampl_coef[4] = rhs._ampl_coef[4]; _phas_coef[0] = rhs._phas_coef[0]; _phas_coef[1] = rhs._phas_coef[1]; _phas_coef[2] = rhs._phas_coef[2]; _phas_coef[3] = rhs._phas_coef[3]; _phas_coef[4] = rhs._phas_coef[4]; _alt_dopcen[0] = rhs._alt_dopcen[0]; _alt_dopcen[1] = rhs._alt_dopcen[1]; _alt_dopcen[2] = rhs._alt_dopcen[2]; _crt_dopcen[0] = rhs._crt_dopcen[0]; _crt_dopcen[1] = rhs._crt_dopcen[1]; _crt_dopcen[2] = rhs._crt_dopcen[2]; _alt_rate[0] = rhs._alt_rate[0]; _alt_rate[1] = rhs._alt_rate[1]; _alt_rate[2] = rhs._alt_rate[2]; _crt_rate[0] = rhs._crt_rate[0]; _crt_rate[1] = rhs._crt_rate[1]; _crt_rate[2] = rhs._crt_rate[2]; _dopcen_range[0] = rhs._dopcen_range[0]; _dopcen_range[1] = rhs._dopcen_range[1]; //to be added// return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarDataSetSummary.h000066400000000000000000000415751301006202600326100ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarDataSetSummary_h #define AlosPalsarDataSetSummary_h #include #include #include #include namespace ossimplugins { /** * @ingroup AlosPalsarDataSetSummaryRecord * @brief This class is able to read the SAR leader data set summary record of the leader file */ class AlosPalsarDataSetSummary : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarDataSetSummary(); /** * @brief Destructor */ virtual ~AlosPalsarDataSetSummary(); /** * @brief This function write the AlosPalsarDataSetSummary in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarDataSetSummary& data); /** * @brief This function read a AlosPalsarDataSetSummary from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarDataSetSummary& data); /** * @brief Copy constructor */ AlosPalsarDataSetSummary(const AlosPalsarDataSetSummary& rhs); /** * @brief Copy operator */ AlosPalsarDataSetSummary& operator=(const AlosPalsarDataSetSummary& rhs); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarDataSetSummary(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarDataSetSummary(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief Sequence number */ int get_seq_num() const { return _seq_num; }; /** * @brief SAR channel indicator */ int get_sar_chn() const { return _sar_chn; }; /** * @brief Scene identifier */ std::string get_scene_id() const { return _scene_id; }; /** * @brief Scene designator */ std::string get_scene_des() const { return _scene_des; }; /** * @brief Input scene centre time */ std::string get_inp_sctim() const { return _inp_sctim; }; /** * @brief Ascending/descending */ std::string get_asc_des() const { return _asc_des; }; /** * @brief Processed scene centre latitude */ double get_pro_lat() const { return _pro_lat; }; /** * @brief Processed scene centre longitude */ double get_pro_long() const { return _pro_long; }; /** * @brief Processed scene centre headng */ double get_pro_head() const { return _pro_head; }; /** * @brief Ellipsoid designator */ std::string get_ellip_des() const { return _ellip_des; }; /** * @brief Ellipsoid semi-major axis, km */ double get_ellip_maj() const { return _ellip_maj; }; /** * @brief Ellipsoid semi_minor axis, km */ double get_ellip_min() const { return _ellip_min; }; /** * @brief Earth's mass */ double get_earth_mass() const { return _earth_mass; }; /** * @brief Gravitational constant */ double get_grav_const() const { return _grav_const; }; /** * @brief Ellipsoid J2-4 parameters */ const double* get_ellip_j() const { return _ellip_j; }; /** * @brief Average terrain height, km */ double get_terrain_h() const { return _terrain_h; }; /** * @brief Scene centre line number */ int get_sc_lin() const { return _sc_lin; }; /** * @brief Scene centre pixel number */ int get_sc_pix() const { return _sc_pix; }; /** * @brief Scene length, km */ double get_scene_len() const { return _scene_len; }; /** * @brief Scene width, km */ double get_scene_wid() const { return _scene_wid; }; /** * @brief Number of SAR channels */ double get_nchn() const { return _nchn; }; /** * @brief Mission identifier */ std::string get_mission_id() const { return _mission_id; }; /** * @brief Sensor identifier */ std::string get_sensor_id() const { return _sensor_id; }; /** * @brief Orbit number */ std::string get_orbit_num() const { return _orbit_num; }; /** * @brief Platform geodetic latitude */ double get_plat_lat() const { return _plat_lat; }; /** * @brief Platform geodetic longitude */ double get_plat_long() const { return _plat_long; }; /** * @brief Platform heading */ double get_plat_head() const { return _plat_head; }; /** * @brief Sensor clock angle */ double get_clock_ang() const { return _clock_ang; }; /** * @brief Incidence angle */ double get_incident_ang() const { return _incident_ang; }; /** * @brief Radar wave length */ double get_wave_length() const { return _wave_length; }; /** * @brief Motion compensation indicator */ std::string get_motion_comp() const { return _motion_comp; }; /** * @brief Range pulse code specifier */ std::string get_pulse_code() const { return _pulse_code; }; /** * @brief Range chirp coefficients */ const double* get_ampl_coef() const { return _ampl_coef; }; /** * @brief Range phase coefficients */ const double* get_phas_coef() const { return _phas_coef; }; /** * @brief Chirp extraction index */ int get_chirp_ext_ind() const { return _chirp_ext_ind; }; /** * @brief Range sampling rate */ double get_fr() const { return _fr; }; /** * @brief Range gate start time */ double get_rng_gate() const { return _rng_gate; }; /** * @brief Range pulse length */ double get_rng_length() const { return _rng_length; }; /** * @brief Baseband conversion flag */ std::string get_baseband_f() const { return _baseband_f; }; /** * @brief Range compressed flag */ std::string get_rngcmp_f() const { return _rngcmp_f; }; /** * @brief Like polarized gain */ double get_gn_polar() const { return _gn_polar; }; /** * @brief Cross polarized gain */ double get_gn_cross() const { return _gn_cross; }; /** * @brief Number of bits per channel */ int get_chn_bits() const { return _chn_bits; }; /** * @brief Quantization descriptor */ std::string get_quant_desc() const { return _quant_desc; }; /** * @brief I channel DC bias */ double get_i_bias() const { return _i_bias; }; /** * @brief Q channel DC bias */ double get_q_bias() const { return _q_bias; }; /** * @brief I/Q channel ratio */ double get_iq_ratio() const { return _iq_ratio; }; /** * @brief Mechanical boresight */ double get_mech_sight() const { return _mech_sight; }; /** * @brief Nominal PRF, Hz */ double get_fa() const { return _fa; }; /** * @brief Satellite binary time */ std::string get_sat_bintim() const { return _sat_bintim; }; /** * @brief Satellite clock time */ std::string get_sat_clktim() const { return _sat_clktim; }; /** * @brief Satellite clock increment */ std::string get_sat_clkinc() const { return _sat_clkinc; }; /** * @brief Processing facility identifier */ std::string get_fac_id() const { return _fac_id; }; /** * @brief Processing system identifier */ std::string get_sys_id() const { return _sys_id; }; /** * @brief Processing version identifier */ std::string get_ver_id() const { return _ver_id; }; /** * @brief Product type specifier */ std::string get_prod_type() const { return _prod_type; }; /** * @brief Processing algorithm identifier */ std::string get_algor_id() const { return _algor_id; }; /** * @brief Number of azimuth looks */ double get_n_azilok() const { return _n_azilok; }; /** * @brief Number of range looks */ double get_n_rnglok() const { return _n_rnglok; }; /** * @brief Bandwidth per look in azimuth,Hz */ double get_bnd_azilok() const { return _bnd_azilok; }; /** * @brief Bandwidth per look in range,Hz */ double get_bnd_rnglok() const { return _bnd_rnglok; }; /** * @brief Total azimuth look bandwidth */ double get_bnd_azi() const { return _bnd_azi; }; /** * @brief Total range look bandwidth */ double get_bnd_rng() const { return _bnd_rng; }; /** * @brief Azimuth weighting designator */ std::string get_azi_weight() const { return _azi_weight; }; /** * @brief Range weighting designator */ std::string get_rng_weight() const { return _rng_weight; }; /** * @brief Data input source */ std::string get_data_inpsrc() const { return _data_inpsrc; }; /** * @brief Range resolution, meter */ double get_rng_res() const { return _rng_res; }; /** * @brief Azimuth resolution, meter */ double get_azi_res() const { return _azi_res; }; /** * @brief Along track Doppler frequency terms */ const double* get_alt_dopcen() const { return _alt_dopcen; }; /** * @brief Cross track Doppler frequency terms */ const double* get_crt_dopcen() const { return _crt_dopcen; }; /** * @brief Pixel time direction indicator */ std::string get_time_dir_pix() const { return _time_dir_pix; }; /** * @brief Line time direction indicator */ std::string get_time_dir_lin() const { return _time_dir_lin; }; /** * @brief Along track Doppler rate term */ const double* get_alt_rate() const { return _alt_rate; }; /** * @brief Cross track Doppler rate term */ const double* get_crt_rate() const { return _crt_rate; }; /** * @brief Line content indicator */ std::string get_line_cont() const { return _line_cont; }; /** * @brief Clutter lock applied flag */ std::string get_clutter_lock() const { return _clutter_lock; }; /** * @brief Auto-focus applied flag */ std::string get_auto_focus() const { return _auto_focus; }; /** * @brief Line spacing, meters */ double get_line_spacing() const { return _line_spacing; }; /** * @brief Pixel spacing, meters */ double get_pix_spacing() const { return _pix_spacing; }; /** * @brief Range compression designator */ std::string get_rngcmp_desg() const { return _rngcmp_desg; }; /** * @brief Along track Doppler frequency terms (in range unit: km) */ const double* get_dopcen_range() const { return _dopcen_range; }; /** * @Data from 1767 to 4096 to be added */ protected: /** * @brief Sequence number */ int _seq_num; /** * @brief SAR channel indicator */ int _sar_chn; /** * @brief Scene identifier */ std::string _scene_id; /** * @brief Scene designator */ std::string _scene_des; /** * @brief Input scene centre time */ std::string _inp_sctim; /** * @brief Ascending/descending */ std::string _asc_des; /** * @brief Processed scene centre latitude */ double _pro_lat; /** * @brief Processed scene centre longitude */ double _pro_long; /** * @brief Processed scene centre headng */ double _pro_head; /** * @brief Ellipsoid designator */ std::string _ellip_des; /** * @brief Ellipsoid semi-major axis, km */ double _ellip_maj; /** * @brief Ellipsoid semi_minor axis, km */ double _ellip_min; /** * @brief Earth's mass */ double _earth_mass; /** * @brief Gravitational constant */ double _grav_const; /** * @brief Ellipsoid J2-4 parameters */ double _ellip_j[3]; /** * @brief Average terrain height, km */ double _terrain_h; /** * @brief Scene centre line number */ int _sc_lin; /** * @brief Scene centre pixel number */ int _sc_pix; /** * @brief Scene length, km */ double _scene_len; /** * @brief Scene width, km */ double _scene_wid; /** * @brief Number of SAR channels */ double _nchn; /** * @brief Mission identifier */ std::string _mission_id; /** * @brief Sensor identifier */ std::string _sensor_id; /** * @brief Orbit number */ std::string _orbit_num; /** * @brief Platform geodetic latitude */ double _plat_lat; /** * @brief Platform geodetic longitude */ double _plat_long; /** * @brief Platform heading */ double _plat_head; /** * @brief Sensor clock angle */ double _clock_ang; /** * @brief Incidence angle */ double _incident_ang; /** * @brief Radar wave length */ double _wave_length; /** * @brief Motion compensation indicator */ std::string _motion_comp; /** * @brief Range pulse code specifier */ std::string _pulse_code; /** * @brief Range chirp coefficients */ double _ampl_coef[5]; /** * @brief Range phase coefficients */ double _phas_coef[5]; /** * @brief Chirp extraction index */ int _chirp_ext_ind; /** * @brief Range sampling rate */ double _fr; /** * @brief Range gate start time */ double _rng_gate; /** * @brief Range pulse length */ double _rng_length; /** * @brief Baseband conversion flag */ std::string _baseband_f; /** * @brief Range compressed flag */ std::string _rngcmp_f; /** * @brief Like polarized gain */ double _gn_polar; /** * @brief Cross polarized gain */ double _gn_cross; /** * @brief Number of bits per channel */ int _chn_bits; /** * @brief Quantization descriptor */ std::string _quant_desc; /** * @brief I channel DC bias */ double _i_bias; /** * @brief Q channel DC bias */ double _q_bias; /** * @brief I/Q channel ratio */ double _iq_ratio; /** * @brief Mechanical boresight */ double _mech_sight; /** * @brief Nominal PRF, Hz */ double _fa; /** * @brief Satellite binary time */ std::string _sat_bintim; /** * @brief Satellite clock time */ std::string _sat_clktim; /** * @brief Satellite clock increment */ std::string _sat_clkinc; /** * @brief Processing facility identifier */ std::string _fac_id; /** * @brief Processing system identifier */ std::string _sys_id; /** * @brief Processing version identifier */ std::string _ver_id; /** * @brief Product type specifier */ std::string _prod_type; /** * @brief Processing algorithm identifier */ std::string _algor_id; /** * @brief Number of azimuth looks */ double _n_azilok; /** * @brief Number of range looks */ double _n_rnglok; /** * @brief Bandwidth per look in azimuth,Hz */ double _bnd_azilok; /** * @brief Bandwidth per look in range,Hz */ double _bnd_rnglok; /** * @brief Total azimuth look bandwidth */ double _bnd_azi; /** * @brief Total range look bandwidth */ double _bnd_rng; /** * @brief Azimuth weighting designator */ std::string _azi_weight; /** * @brief Range weighting designator */ std::string _rng_weight; /** * @brief Data input source */ std::string _data_inpsrc; /** * @brief Range resolution, meter */ double _rng_res; /** * @brief Azimuth resolution, meter */ double _azi_res; /** * @brief Along track Doppler frequency terms */ double _alt_dopcen[3]; /** * @brief Cross track Doppler frequency terms */ double _crt_dopcen[3]; /** * @brief Pixel time direction indicator */ std::string _time_dir_pix; /** * @brief Line time direction indicator */ std::string _time_dir_lin; /** * @brief Along track Doppler rate term */ double _alt_rate[3]; /** * @brief Cross track Doppler rate term */ double _crt_rate[3]; /** * @brief Line content indicator */ std::string _line_cont; /** * @brief Clutter lock applied flag */ std::string _clutter_lock; /** * @brief Auto-focus applied flag */ std::string _auto_focus; /** * @brief Line spacing, meters */ double _line_spacing; /** * @brief Pixel spacing, meters */ double _pix_spacing; /** * @brief Range compression designator */ std::string _rngcmp_desg; /** * @brief Cross track Doppler frequency terms (in range unit: km) */ double _dopcen_range[2]; /** * @Data from 1767 to 4096 to be added */ private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarFacilityData.cpp000066400000000000000000001243101301006202600325630ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarFacilityData::AlosPalsarFacilityData() : AlosPalsarRecord("facility_data_rec") { } AlosPalsarFacilityData::~AlosPalsarFacilityData() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarFacilityData& data) { os << "last_release_qc_date:" << data._last_release_qc_date.c_str() << std::endl; os << "last_release_cal_date:" << data._last_release_cal_date.c_str() << std::endl; os << "qa_summary_flag:" << data._qa_summary_flag << std::endl; os << "prf_code_change_flag:" << data._prf_code_change_flag << std::endl; os << "sampling_win_change_flag:" << data._sampling_win_change_flag << std::endl; os << "cal_gain_change_flag:" << data._cal_gain_change_flag << std::endl; os << "quirp_qu_flag:" << data._quirp_qu_flag << std::endl; os << "inp_data_stat_flag:" << data._inp_data_stat_flag << std::endl; os << "dopp_cent_conf_meas_flag:" << data._dopp_cent_conf_meas_flag << std::endl; os << "dopp_cent_val_flag:" << data._dopp_cent_val_flag << std::endl; os << "dopp_ambig_conf_meas_flag:" << data._dopp_ambig_conf_meas_flag << std::endl; os << "outp_data_mean_flag:" << data._outp_data_mean_flag << std::endl; os << "OGOB_flag:" << data._OGOB_flag << std::endl; os << "PRF_changes:" << data._PRF_changes << std::endl; os << "sampling_win_changes:" << data._sampling_win_changes << std::endl; os << "cal_gain_changes:" << data._cal_gain_changes << std::endl; os << "missing_lines:" << data._missing_lines << std::endl; os << "rec_gain_changes:" << data._rec_gain_changes << std::endl; os << "pulse_width_of_ACF_3db:" << data._pulse_width_of_ACF_3db << std::endl; os << "first_side_lobe_lev_of_ACF:" << data._first_side_lobe_lev_of_ACF << std::endl; os << "ISLR_of_ACF:" << data._ISLR_of_ACF << std::endl; os << "dopp_cent_conf_meas:" << data._dopp_cent_conf_meas << std::endl; os << "dopp_ambig_conf_meas:" << data._dopp_ambig_conf_meas << std::endl; os << "inp_data_I_mean:" << data._inp_data_I_mean << std::endl; os << "inp_data_Q_mean:" << data._inp_data_Q_mean << std::endl; os << "inp_data_I_stddev:" << data._inp_data_I_stddev << std::endl; os << "inp_data_Q_stddev:" << data._inp_data_Q_stddev << std::endl; os << "cal_sys_gain:" << data._cal_sys_gain << std::endl; os << "first_rec_gain_read:" << data._first_rec_gain_read << std::endl; os << "dopp_ambig_num:" << data._dopp_ambig_num << std::endl; os << "I_channel_bias_correction:" << data._I_channel_bias_correction << std::endl; os << "Q_channel_bias_correction:" << data._Q_channel_bias_correction << std::endl; os << "I_channel_gain_correction:" << data._I_channel_gain_correction << std::endl; os << "Q_channel_gain_correction:" << data._Q_channel_gain_correction << std::endl; os << "Q_channel_I_Q_correction:" << data._Q_channel_I_Q_correction << std::endl; os << "noise_power:" << data._noise_power << std::endl; os << "int_cal_utc:" << data._int_cal_utc << std::endl; os << "num_valid_cal_pulses:" << data._num_valid_cal_pulses << std::endl; os << "num_valid_noise_pulses:" << data._num_valid_noise_pulses << std::endl; os << "num_valid_replicas:" << data._num_valid_replicas << std::endl; os << "first_replica_sample:" << data._first_replica_sample << std::endl; os << "mean_cal_pulse_power:" << data._mean_cal_pulse_power << std::endl; os << "mean_noise_power:" << data._mean_noise_power << std::endl; os << "range_comp_norm_fact:" << data._range_comp_norm_fact << std::endl; os << "replica_power:" << data._replica_power << std::endl; os << "first_range_pixel_mid_az_inc:" << data._first_range_pixel_mid_az_inc << std::endl; os << "center_range_pix_mid_az_inc:" << data._center_range_pix_mid_az_inc << std::endl; os << "last_range_pix_mid_az_inc:" << data._last_range_pix_mid_az_inc << std::endl; os << "norm_ref_range_ro:" << data._norm_ref_range_ro << std::endl; os << "antenna_elev_flag:" << data._antenna_elev_flag << std::endl; os << "abs_cal_const_K:" << data._abs_cal_const_K << std::endl; os << "upp_bound_K:" << data._upp_bound_K << std::endl; os << "low_bound_K:" << data._low_bound_K << std::endl; os << "proc_noise_scale_fact:" << data._proc_noise_scale_fact << std::endl; os << "K_gen_date:" << data._K_gen_date.c_str() << std::endl; os << "K_vers_num:" << data._K_vers_num.c_str() << std::endl; os << "num_duplic_input_lines:" << data._num_duplic_input_lines << std::endl; os << "estim_bit_error_rate:" << data._estim_bit_error_rate << std::endl; os << "out_image_mean:" << data._out_image_mean << std::endl; os << "out_image_std_dev:" << data._out_image_std_dev << std::endl; os << "out_image_max_value:" << data._out_image_max_value << std::endl; os << "time_raw_data_first_input:" << data._time_raw_data_first_input.c_str() << std::endl; os << "time_asc_node_state_vectors:" << data._time_asc_node_state_vectors.c_str() << std::endl; os << "asc_node_pos_X_comp:" << data._asc_node_pos_X_comp.c_str() << std::endl; os << "asc_node_pos_Y_comp:" << data._asc_node_pos_Y_comp.c_str() << std::endl; os << "asc_node_pos_Z_comp:" << data._asc_node_pos_Z_comp.c_str() << std::endl; os << "asc_node_vel_X_comp:" << data._asc_node_vel_X_comp.c_str() << std::endl; os << "asc_node_vel_Y_comp:" << data._asc_node_vel_Y_comp.c_str() << std::endl; os << "asc_node_vel_Z_comp:" << data._asc_node_vel_Z_comp.c_str() << std::endl; os << "out_pixel_bit_length:" << data._out_pixel_bit_length << std::endl; os << "proc_gain_param_1:" << data._proc_gain_param_1 << std::endl; os << "proc_gain_param_2:" << data._proc_gain_param_2 << std::endl; os << "proc_gain_param_3:" << data._proc_gain_param_3 << std::endl; os << "peak_loc_cross_correl_fun:" << data._peak_loc_cross_correl_fun << std::endl; os << "3_dB_width_CCF:" << data._3_dB_width_CCF << std::endl; os << "first_side_lobe_level:" << data._first_side_lobe_level << std::endl; os << "ISLR_CCF_between_last:" << data._ISLR_CCF_between_last << std::endl; os << "peak_loc_CCF_betw_last:" << data._peak_loc_CCF_betw_last << std::endl; os << "Roll_Tilt_Mode_flag:" << data._Roll_Tilt_Mode_flag << std::endl; os << "raw_data_correction_flag:" << data._raw_data_correction_flag << std::endl; os << "look_detecion_flag:" << data._look_detecion_flag << std::endl; os << "doppler_ambiguity_estimat_flag:" << data._doppler_ambiguity_estimat_flag << std::endl; os << "azimuth_baseband_convers_flag:" << data._azimuth_baseband_convers_flag << std::endl; os << "samples_per_line_used:" << data._samples_per_line_used << std::endl; os << "range_lines_skip_factor:" << data._range_lines_skip_factor << std::endl; os << "time_of_inp_state_vectors:" << data._time_of_inp_state_vectors.c_str() << std::endl; os << "inp_state_vect_pos_X_comp:" << data._inp_state_vect_pos_X_comp.c_str() << std::endl; os << "inp_state_vect_pos_Y_comp:" << data._inp_state_vect_pos_Y_comp.c_str() << std::endl; os << "inp_state_vect_pos_Z_comp:" << data._inp_state_vect_pos_Z_comp.c_str() << std::endl; os << "inp_state_vect_vel_Vx_comp:" << data._inp_state_vect_vel_Vx_comp.c_str() << std::endl; os << "inp_state_vect_vel_Vy_comp:" << data._inp_state_vect_vel_Vy_comp.c_str() << std::endl; os << "inp_state_vect_vel_Vz_comp:" << data._inp_state_vect_vel_Vz_comp.c_str() << std::endl; os << "inp_state_vector_type_flag:" << data._inp_state_vector_type_flag << std::endl; os << "win_coeff_for_range_match:" << data._win_coeff_for_range_match << std::endl; os << "win_coeff_for_azi_match:" << data._win_coeff_for_azi_match << std::endl; os << "update_period_range_match:" << data._update_period_range_match << std::endl; os << "look_scalar_gain_1:" << data._look_scalar_gain_1 << std::endl; os << "look_scalar_gain_2:" << data._look_scalar_gain_2 << std::endl; os << "look_scalar_gain_3:" << data._look_scalar_gain_3 << std::endl; os << "look_scalar_gain_4:" << data._look_scalar_gain_4 << std::endl; os << "look_scalar_gain_5:" << data._look_scalar_gain_5 << std::endl; os << "look_scalar_gain_6:" << data._look_scalar_gain_6 << std::endl; os << "look_scalar_gain_7:" << data._look_scalar_gain_7 << std::endl; os << "look_scalar_gain_8:" << data._look_scalar_gain_8 << std::endl; os << "samp_window_start_time_bias:" << data._samp_window_start_time_bias << std::endl; os << "doppler_centroid_cubic_coeff:" << data._doppler_centroid_cubic_coeff << std::endl; os << "PRF_code_first_range_line:" << data._PRF_code_first_range_line << std::endl; os << "PRF_code_last_range_line:" << data._PRF_code_last_range_line << std::endl; os << "samp_win_start_first:" << data._samp_win_start_first << std::endl; os << "samp_win_start_last:" << data._samp_win_start_last << std::endl; os << "cal_syst_gain_last_proc:" << data._cal_syst_gain_last_proc << std::endl; os << "receiver_gain_last_proc:" << data._receiver_gain_last_proc << std::endl; os << "first_processed_range_sample:" << data._first_processed_range_sample << std::endl; os << "azimuth_FFT_IFFT_ratio:" << data._azimuth_FFT_IFFT_ratio << std::endl; os << "num_azimuth_blocks_proc:" << data._num_azimuth_blocks_proc << std::endl; os << "num_input_raw_data_lines:" << data._num_input_raw_data_lines << std::endl; os << "initial_doppler_ambiguity_num:" << data._initial_doppler_ambiguity_num << std::endl; os << "thresh_no_1_flag:" << data._thresh_no_1_flag << std::endl; os << "thresh_no_2_flag:" << data._thresh_no_2_flag << std::endl; os << "thresh_no_3_flag:" << data._thresh_no_3_flag << std::endl; os << "thresh_no_4_flag:" << data._thresh_no_4_flag << std::endl; os << "thresh_no_5_flag:" << data._thresh_no_5_flag << std::endl; os << "thresh_no_6_flag:" << data._thresh_no_6_flag << std::endl; os << "thresh_no_7_flag:" << data._thresh_no_7_flag << std::endl; os << "thresh_no_8_flag:" << data._thresh_no_8_flag << std::endl; os << "thresh_no_9_flag:" << data._thresh_no_9_flag << std::endl; os << "thresh_no_10_flag:" << data._thresh_no_10_flag << std::endl; os << "thresh_no_11_flag:" << data._thresh_no_11_flag << std::endl; os << "sat_binary_time_of_first:" << data._sat_binary_time_of_first << std::endl; os << "num_valid_pixels_per_range:" << data._num_valid_pixels_per_range << std::endl; os << "num_range_samp_discarded:" << data._num_range_samp_discarded << std::endl; os << "I_gain_imb_lower_bound:" << data._I_gain_imb_lower_bound << std::endl; os << "I_gain_imb_upper_bound:" << data._I_gain_imb_upper_bound << std::endl; os << "I_Q_quad_depar_lower_bound:" << data._I_Q_quad_depar_lower_bound << std::endl; os << "I_Q_quad_depar_upper_bound:" << data._I_Q_quad_depar_upper_bound << std::endl; os << "3_dB_look_bandwidth:" << data._3_dB_look_bandwidth << std::endl; os << "3_dB_look_proc_dopp_bandw:" << data._3_dB_look_proc_dopp_bandw << std::endl; os << "range_spread_loss_comp_flag:" << data._range_spread_loss_comp_flag << std::endl; os << "datation_flag:" << data._datation_flag << std::endl; os << "max_error_range_line_timing:" << data._max_error_range_line_timing << std::endl; os << "form_num_range_line_used:" << data._form_num_range_line_used << std::endl; os << "autom_look_scal_gain_flag:" << data._autom_look_scal_gain_flag << std::endl; os << "max_value_look_scalar_gain:" << data._max_value_look_scalar_gain << std::endl; os << "replica_norm_method_flag:" << data._replica_norm_method_flag << std::endl; os << "coef_ground_range_1:" << data._coef_ground_range_1 << std::endl; os << "coef_ground_range_2:" << data._coef_ground_range_2 << std::endl; os << "coef_ground_range_3:" << data._coef_ground_range_3 << std::endl; os << "coef_ground_range_4:" << data._coef_ground_range_4 << std::endl; os << "coef_ant_elev_1:" << data._coef_ant_elev_1 << std::endl; os << "coef_ant_elev_2:" << data._coef_ant_elev_2 << std::endl; os << "coef_ant_elev_3:" << data._coef_ant_elev_3 << std::endl; os << "coef_ant_elev_4:" << data._coef_ant_elev_4 << std::endl; os << "coef_ant_elev_5:" << data._coef_ant_elev_5 << std::endl; os << "range_time_origin_ant:" << data._range_time_origin_ant << std::endl; return os; } std::istream& operator>>(std::istream& is, AlosPalsarFacilityData& data) { char buf64[65]; buf64[64] = '\0'; char buf32[33]; buf32[32] = '\0'; char buf24[25]; buf24[24] = '\0'; char buf22[23]; buf22[22] = '\0'; char buf20[21]; buf20[20] = '\0'; char buf16[17]; buf16[16] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf7[8]; buf7[7] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf6[7]; buf6[6] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf2[3]; buf2[2] = '\0'; char buf1[2]; buf1[1] = '\0'; is.read(buf64, 64); data._name_of_facil_rec = buf64; is.read(buf6, 6); data._last_release_qc_date = buf6; is.read(buf2, 2); is.read(buf6, 6); data._last_release_cal_date = buf6; is.read(buf4, 4); data._qa_summary_flag = atoi(buf4); is.read(buf4, 4); data._prf_code_change_flag = atoi(buf4); is.read(buf4, 4); data._sampling_win_change_flag = atoi(buf4); is.read(buf4, 4); data._cal_gain_change_flag = atoi(buf4); is.read(buf4, 4); data._quirp_qu_flag = atoi(buf4); is.read(buf4, 4); data._inp_data_stat_flag = atoi(buf4); is.read(buf4, 4); data._dopp_cent_conf_meas_flag = atoi(buf4); is.read(buf4, 4); data._dopp_cent_val_flag = atoi(buf4); is.read(buf4, 4); data._dopp_ambig_conf_meas_flag = atoi(buf4); is.read(buf4, 4); data._outp_data_mean_flag = atoi(buf4); is.read(buf4, 4); data._OGOB_flag = atoi(buf4); is.read(buf4, 4); data._PRF_changes = atoi(buf4); is.read(buf4, 4); data._sampling_win_changes = atoi(buf4); is.read(buf4, 4); data._cal_gain_changes = atoi(buf4); is.read(buf4, 4); data._missing_lines = atoi(buf4); is.read(buf4, 4); data._rec_gain_changes = atoi(buf4); is.read(buf16, 16); data._pulse_width_of_ACF_3db = atof(buf16); is.read(buf16, 16); data._first_side_lobe_lev_of_ACF = atof(buf16); is.read(buf16, 16); data._ISLR_of_ACF = atof(buf16); is.read(buf16, 16); data._dopp_cent_conf_meas = atof(buf16); is.read(buf16, 16); data._dopp_ambig_conf_meas = atof(buf16); is.read(buf16, 16); data._inp_data_I_mean = atof(buf16); is.read(buf16, 16); data._inp_data_Q_mean = atof(buf16); is.read(buf16, 16); data._inp_data_I_stddev = atof(buf16); is.read(buf16, 16); data._inp_data_Q_stddev = atof(buf16); is.read(buf16, 16); data._cal_sys_gain = atof(buf16); is.read(buf16, 16); data._first_rec_gain_read = atof(buf16); is.read(buf16, 16); data._dopp_ambig_num = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._I_channel_bias_correction = atof(buf16); is.read(buf16, 16); data._Q_channel_bias_correction = atof(buf16); is.read(buf16, 16); data._I_channel_gain_correction = atof(buf16); is.read(buf16, 16); data._Q_channel_gain_correction = atof(buf16); is.read(buf16, 16); data._Q_channel_I_Q_correction = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._noise_power = atof(buf16); is.read(buf16, 16); data._int_cal_utc = atoi(buf16); is.read(buf4, 4); data._num_valid_cal_pulses = atoi(buf4); is.read(buf4, 4); data._num_valid_noise_pulses = atoi(buf4); is.read(buf4, 4); data._num_valid_replicas = atoi(buf4); is.read(buf16, 16); data._first_replica_sample = atof(buf16); is.read(buf16, 16); data._mean_cal_pulse_power = atof(buf16); is.read(buf16, 16); data._mean_noise_power = atof(buf16); is.read(buf16, 16); data._range_comp_norm_fact = atof(buf16); is.read(buf16, 16); data._replica_power = atof(buf16); is.read(buf16, 16); data._first_range_pixel_mid_az_inc = atof(buf16); is.read(buf16, 16); data._center_range_pix_mid_az_inc = atof(buf16); is.read(buf16, 16); data._last_range_pix_mid_az_inc = atof(buf16); is.read(buf16, 16); data._norm_ref_range_ro = atof(buf16); is.read(buf12, 12); is.read(buf4, 4); data._antenna_elev_flag = atoi(buf4); is.read(buf16, 16); data._abs_cal_const_K = atof(buf16); is.read(buf16, 16); data._upp_bound_K = atof(buf16); is.read(buf16, 16); data._low_bound_K = atof(buf16); is.read(buf16, 16); data._proc_noise_scale_fact = atof(buf16); is.read(buf6, 6); data._K_gen_date = buf6; is.read(buf4, 4); data._K_vers_num = buf4; is.read(buf4, 4); data._num_duplic_input_lines = atoi(buf4); is.read(buf16, 16); data._estim_bit_error_rate = atof(buf16); is.read(buf12, 12); is.read(buf16, 16); data._out_image_mean = atof(buf16); is.read(buf16, 16); data._out_image_std_dev = atof(buf16); is.read(buf16, 16); data._out_image_max_value = atof(buf16); is.read(buf24, 24); data._time_raw_data_first_input = buf24; is.read(buf24, 24); data._time_asc_node_state_vectors = buf24; is.read(buf22, 22); data._asc_node_pos_X_comp = buf22; is.read(buf22, 22); data._asc_node_pos_Y_comp = buf22; is.read(buf22, 22); data._asc_node_pos_Z_comp = buf22; is.read(buf22, 22); data._asc_node_vel_X_comp = buf22; is.read(buf22, 22); data._asc_node_vel_Y_comp = buf22; is.read(buf22, 22); data._asc_node_vel_Z_comp = buf22; is.read(buf4, 4); data._out_pixel_bit_length = atoi(buf4); is.read(buf16, 16); data._proc_gain_param_1 = atof(buf16); is.read(buf16, 16); data._proc_gain_param_2 = atof(buf16); is.read(buf16, 16); data._proc_gain_param_3 = atof(buf16); is.read(buf4, 4); data._peak_loc_cross_correl_fun = atoi(buf4); is.read(buf16, 16); data._3_dB_width_CCF = atof(buf16); is.read(buf16, 16); data._first_side_lobe_level = atof(buf16); is.read(buf16, 16); data._ISLR_CCF_between_last = atof(buf16); is.read(buf4, 4); data._peak_loc_CCF_betw_last = atoi(buf4); is.read(buf4, 4); data._Roll_Tilt_Mode_flag = atoi(buf4); is.read(buf4, 4); data._raw_data_correction_flag = atoi(buf4); is.read(buf4, 4); data._look_detecion_flag = atoi(buf4); is.read(buf4, 4); data._doppler_ambiguity_estimat_flag = atoi(buf4); is.read(buf4, 4); data._azimuth_baseband_convers_flag = atoi(buf4); is.read(buf4, 4); data._samples_per_line_used = atoi(buf4); is.read(buf4, 4); data._range_lines_skip_factor = atoi(buf4); is.read(buf24, 24); data._time_of_inp_state_vectors = buf24; is.read(buf22, 22); data._inp_state_vect_pos_X_comp = buf22; is.read(buf22, 22); data._inp_state_vect_pos_Y_comp = buf22; is.read(buf22, 22); data._inp_state_vect_pos_Z_comp = buf22; is.read(buf22, 22); data._inp_state_vect_vel_Vx_comp = buf22; is.read(buf22, 22); data._inp_state_vect_vel_Vy_comp = buf22; is.read(buf22, 22); data._inp_state_vect_vel_Vz_comp = buf22; is.read(buf4, 4); data._inp_state_vector_type_flag = atoi(buf4); is.read(buf16, 16); data._win_coeff_for_range_match = atof(buf16); is.read(buf16, 16); data._win_coeff_for_azi_match = atof(buf16); is.read(buf4, 4); data._update_period_range_match = atoi(buf4); is.read(buf16, 16); data._look_scalar_gain_1 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_2 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_3 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_4 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_5 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_6 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_7 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_8 = atof(buf16); is.read(buf4, 4); data._samp_window_start_time_bias = atoi(buf4); is.read(buf22, 22); data._doppler_centroid_cubic_coeff = atof(buf22); is.read(buf4, 4); data._PRF_code_first_range_line = atoi(buf4); is.read(buf4, 4); data._PRF_code_last_range_line = atoi(buf4); is.read(buf4, 4); data._samp_win_start_first = atoi(buf4); is.read(buf4, 4); data._samp_win_start_last = atoi(buf4); is.read(buf4, 4); data._cal_syst_gain_last_proc = atoi(buf4); is.read(buf4, 4); data._receiver_gain_last_proc = atoi(buf4); is.read(buf4, 4); data._first_processed_range_sample = atoi(buf4); is.read(buf4, 4); data._azimuth_FFT_IFFT_ratio = atoi(buf4); is.read(buf4, 4); data._num_azimuth_blocks_proc = atoi(buf4); is.read(buf8, 8); data._num_input_raw_data_lines = atol(buf8); is.read(buf4, 4); data._initial_doppler_ambiguity_num = atoi(buf4); is.read(buf16, 16); data._thresh_no_1_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_2_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_3_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_4_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_5_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_6_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_7_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_8_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_9_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_10_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_11_flag = atof(buf16); is.read(buf16, 16); data._sat_binary_time_of_first = atol(buf16); is.read(buf4, 4); data._num_valid_pixels_per_range = atoi(buf4); is.read(buf4, 4); data._num_range_samp_discarded = atoi(buf4); is.read(buf16, 16); data._I_gain_imb_lower_bound = atof(buf16); is.read(buf16, 16); data._I_gain_imb_upper_bound = atof(buf16); is.read(buf16, 16); data._I_Q_quad_depar_lower_bound = atof(buf16); is.read(buf16, 16); data._I_Q_quad_depar_upper_bound = atof(buf16); is.read(buf16, 16); data._3_dB_look_bandwidth = atof(buf16); is.read(buf16, 16); data._3_dB_look_proc_dopp_bandw = atof(buf16); is.read(buf4, 4); data._range_spread_loss_comp_flag = atoi(buf4); is.read(buf1, 1); data._datation_flag = atoi(buf1) != 0; is.read(buf7, 7); data._max_error_range_line_timing = atoi(buf7); is.read(buf7, 7); data._form_num_range_line_used = atoi(buf7); is.read(buf1, 1); data._autom_look_scal_gain_flag = atoi(buf1) != 0; is.read(buf4, 4); data._max_value_look_scalar_gain = atoi(buf4); is.read(buf4, 4); data._replica_norm_method_flag = atoi(buf4); is.read(buf20, 20); data._coef_ground_range_1 = atof(buf20); is.read(buf20, 20); data._coef_ground_range_2 = atof(buf20); is.read(buf20, 20); data._coef_ground_range_3 = atof(buf20); is.read(buf20, 20); data._coef_ground_range_4 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_1 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_2 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_3 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_4 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_5 = atof(buf20); is.read(buf16, 16); data._range_time_origin_ant = atof(buf16); char buf10238[10238]; is.read(buf10238, 10238); return is; } AlosPalsarFacilityData::AlosPalsarFacilityData(const AlosPalsarFacilityData& rhs): AlosPalsarRecord(rhs), _last_release_qc_date(rhs._last_release_qc_date), _last_release_cal_date(rhs._last_release_cal_date), _qa_summary_flag(rhs._qa_summary_flag), _prf_code_change_flag(rhs._prf_code_change_flag), _sampling_win_change_flag(rhs._sampling_win_change_flag), _cal_gain_change_flag(rhs._cal_gain_change_flag), _quirp_qu_flag(rhs._quirp_qu_flag), _inp_data_stat_flag(rhs._inp_data_stat_flag), _dopp_cent_conf_meas_flag(rhs._dopp_cent_conf_meas_flag), _dopp_cent_val_flag(rhs._dopp_cent_val_flag), _dopp_ambig_conf_meas_flag(rhs._dopp_ambig_conf_meas_flag), _outp_data_mean_flag(rhs._outp_data_mean_flag), _OGOB_flag(rhs._OGOB_flag), _PRF_changes(rhs._PRF_changes), _sampling_win_changes(rhs._sampling_win_changes), _cal_gain_changes(rhs._cal_gain_changes), _missing_lines(rhs._missing_lines), _rec_gain_changes(rhs._rec_gain_changes), _pulse_width_of_ACF_3db(rhs._pulse_width_of_ACF_3db), _first_side_lobe_lev_of_ACF(rhs._first_side_lobe_lev_of_ACF), _ISLR_of_ACF(rhs._ISLR_of_ACF), _dopp_cent_conf_meas(rhs._dopp_cent_conf_meas), _dopp_ambig_conf_meas(rhs._dopp_ambig_conf_meas), _inp_data_I_mean(rhs._inp_data_I_mean), _inp_data_Q_mean(rhs._inp_data_Q_mean), _inp_data_I_stddev(rhs._inp_data_I_stddev), _inp_data_Q_stddev(rhs._inp_data_Q_stddev), _cal_sys_gain(rhs._cal_sys_gain), _first_rec_gain_read(rhs._first_rec_gain_read), _dopp_ambig_num(rhs._dopp_ambig_num), _I_channel_bias_correction(rhs._I_channel_bias_correction), _Q_channel_bias_correction(rhs._Q_channel_bias_correction), _I_channel_gain_correction(rhs._I_channel_gain_correction), _Q_channel_gain_correction(rhs._Q_channel_gain_correction), _Q_channel_I_Q_correction(rhs._Q_channel_I_Q_correction), _noise_power(rhs._noise_power), _int_cal_utc(rhs._int_cal_utc), _num_valid_cal_pulses(rhs._num_valid_cal_pulses), _num_valid_noise_pulses(rhs._num_valid_noise_pulses), _num_valid_replicas(rhs._num_valid_replicas), _first_replica_sample(rhs._first_replica_sample), _mean_cal_pulse_power(rhs._mean_cal_pulse_power), _mean_noise_power(rhs._mean_noise_power), _range_comp_norm_fact(rhs._range_comp_norm_fact), _replica_power(rhs._replica_power), _first_range_pixel_mid_az_inc(rhs._first_range_pixel_mid_az_inc), _center_range_pix_mid_az_inc(rhs._center_range_pix_mid_az_inc), _last_range_pix_mid_az_inc(rhs._last_range_pix_mid_az_inc), _norm_ref_range_ro(rhs._norm_ref_range_ro), _antenna_elev_flag(rhs._antenna_elev_flag), _abs_cal_const_K(rhs._abs_cal_const_K), _upp_bound_K(rhs._upp_bound_K), _low_bound_K(rhs._low_bound_K), _proc_noise_scale_fact(rhs._proc_noise_scale_fact), _K_gen_date(rhs._K_gen_date), _K_vers_num(rhs._K_vers_num), _num_duplic_input_lines(rhs._num_duplic_input_lines), _estim_bit_error_rate(rhs._estim_bit_error_rate), _out_image_mean(rhs._out_image_mean), _out_image_std_dev(rhs._out_image_std_dev), _out_image_max_value(rhs._out_image_max_value), _time_raw_data_first_input(rhs._time_raw_data_first_input), _time_asc_node_state_vectors(rhs._time_asc_node_state_vectors), _asc_node_pos_X_comp(rhs._asc_node_pos_X_comp), _asc_node_pos_Y_comp(rhs._asc_node_pos_Y_comp), _asc_node_pos_Z_comp(rhs._asc_node_pos_Z_comp), _asc_node_vel_X_comp(rhs._asc_node_vel_X_comp), _asc_node_vel_Y_comp(rhs._asc_node_vel_Y_comp), _asc_node_vel_Z_comp(rhs._asc_node_vel_Z_comp), _out_pixel_bit_length(rhs._out_pixel_bit_length), _proc_gain_param_1(rhs._proc_gain_param_1), _proc_gain_param_2(rhs._proc_gain_param_2), _proc_gain_param_3(rhs._proc_gain_param_3), _peak_loc_cross_correl_fun(rhs._peak_loc_cross_correl_fun), _3_dB_width_CCF(rhs._3_dB_width_CCF), _first_side_lobe_level(rhs._first_side_lobe_level), _ISLR_CCF_between_last(rhs._ISLR_CCF_between_last), _peak_loc_CCF_betw_last(rhs._peak_loc_CCF_betw_last), _Roll_Tilt_Mode_flag(rhs._Roll_Tilt_Mode_flag), _raw_data_correction_flag(rhs._raw_data_correction_flag), _look_detecion_flag(rhs._look_detecion_flag), _doppler_ambiguity_estimat_flag(rhs._doppler_ambiguity_estimat_flag), _azimuth_baseband_convers_flag(rhs._azimuth_baseband_convers_flag), _samples_per_line_used(rhs._samples_per_line_used), _range_lines_skip_factor(rhs._range_lines_skip_factor), _time_of_inp_state_vectors(rhs._time_of_inp_state_vectors), _inp_state_vect_pos_X_comp(rhs._inp_state_vect_pos_X_comp), _inp_state_vect_pos_Y_comp(rhs._inp_state_vect_pos_Y_comp), _inp_state_vect_pos_Z_comp(rhs._inp_state_vect_pos_Z_comp), _inp_state_vect_vel_Vx_comp(rhs._inp_state_vect_vel_Vx_comp), _inp_state_vect_vel_Vy_comp(rhs._inp_state_vect_vel_Vy_comp), _inp_state_vect_vel_Vz_comp(rhs._inp_state_vect_vel_Vz_comp), _inp_state_vector_type_flag(rhs._inp_state_vector_type_flag), _win_coeff_for_range_match(rhs._win_coeff_for_range_match), _win_coeff_for_azi_match(rhs._win_coeff_for_azi_match), _update_period_range_match(rhs._update_period_range_match), _look_scalar_gain_1(rhs._look_scalar_gain_1), _look_scalar_gain_2(rhs._look_scalar_gain_2), _look_scalar_gain_3(rhs._look_scalar_gain_3), _look_scalar_gain_4(rhs._look_scalar_gain_4), _look_scalar_gain_5(rhs._look_scalar_gain_5), _look_scalar_gain_6(rhs._look_scalar_gain_6), _look_scalar_gain_7(rhs._look_scalar_gain_7), _look_scalar_gain_8(rhs._look_scalar_gain_8), _samp_window_start_time_bias(rhs._samp_window_start_time_bias), _doppler_centroid_cubic_coeff(rhs._doppler_centroid_cubic_coeff), _PRF_code_first_range_line(rhs._PRF_code_first_range_line), _PRF_code_last_range_line(rhs._PRF_code_last_range_line), _samp_win_start_first(rhs._samp_win_start_first), _samp_win_start_last(rhs._samp_win_start_last), _cal_syst_gain_last_proc(rhs._cal_syst_gain_last_proc), _receiver_gain_last_proc(rhs._receiver_gain_last_proc), _first_processed_range_sample(rhs._first_processed_range_sample), _azimuth_FFT_IFFT_ratio(rhs._azimuth_FFT_IFFT_ratio), _num_azimuth_blocks_proc(rhs._num_azimuth_blocks_proc), _num_input_raw_data_lines(rhs._num_input_raw_data_lines), _initial_doppler_ambiguity_num(rhs._initial_doppler_ambiguity_num), _thresh_no_1_flag(rhs._thresh_no_1_flag), _thresh_no_2_flag(rhs._thresh_no_2_flag), _thresh_no_3_flag(rhs._thresh_no_3_flag), _thresh_no_4_flag(rhs._thresh_no_4_flag), _thresh_no_5_flag(rhs._thresh_no_5_flag), _thresh_no_6_flag(rhs._thresh_no_6_flag), _thresh_no_7_flag(rhs._thresh_no_7_flag), _thresh_no_8_flag(rhs._thresh_no_8_flag), _thresh_no_9_flag(rhs._thresh_no_9_flag), _thresh_no_10_flag(rhs._thresh_no_10_flag), _thresh_no_11_flag(rhs._thresh_no_11_flag), _sat_binary_time_of_first(rhs._sat_binary_time_of_first), _num_valid_pixels_per_range(rhs._num_valid_pixels_per_range), _num_range_samp_discarded(rhs._num_range_samp_discarded), _I_gain_imb_lower_bound(rhs._I_gain_imb_lower_bound), _I_gain_imb_upper_bound(rhs._I_gain_imb_upper_bound), _I_Q_quad_depar_lower_bound(rhs._I_Q_quad_depar_lower_bound), _I_Q_quad_depar_upper_bound(rhs._I_Q_quad_depar_upper_bound), _3_dB_look_bandwidth(rhs._3_dB_look_bandwidth), _3_dB_look_proc_dopp_bandw(rhs._3_dB_look_proc_dopp_bandw), _range_spread_loss_comp_flag(rhs._range_spread_loss_comp_flag), _datation_flag(rhs._datation_flag), _max_error_range_line_timing(rhs._max_error_range_line_timing), _form_num_range_line_used(rhs._form_num_range_line_used), _autom_look_scal_gain_flag(rhs._autom_look_scal_gain_flag), _max_value_look_scalar_gain(rhs._max_value_look_scalar_gain), _replica_norm_method_flag(rhs._replica_norm_method_flag), _coef_ground_range_1(rhs._coef_ground_range_1), _coef_ground_range_2(rhs._coef_ground_range_2), _coef_ground_range_3(rhs._coef_ground_range_3), _coef_ground_range_4(rhs._coef_ground_range_4), _coef_ant_elev_1(rhs._coef_ant_elev_1), _coef_ant_elev_2(rhs._coef_ant_elev_2), _coef_ant_elev_3(rhs._coef_ant_elev_3), _coef_ant_elev_4(rhs._coef_ant_elev_4), _coef_ant_elev_5(rhs._coef_ant_elev_5), _range_time_origin_ant(rhs._range_time_origin_ant) {} AlosPalsarFacilityData& AlosPalsarFacilityData::operator=(const AlosPalsarFacilityData& rhs) { _last_release_qc_date = rhs._last_release_qc_date; _last_release_cal_date = rhs._last_release_cal_date; _qa_summary_flag = rhs._qa_summary_flag; _prf_code_change_flag = rhs._prf_code_change_flag; _sampling_win_change_flag = rhs._sampling_win_change_flag; _cal_gain_change_flag = rhs._cal_gain_change_flag; _quirp_qu_flag = rhs._quirp_qu_flag; _inp_data_stat_flag = rhs._inp_data_stat_flag; _dopp_cent_conf_meas_flag = rhs._dopp_cent_conf_meas_flag; _dopp_cent_val_flag = rhs._dopp_cent_val_flag; _dopp_ambig_conf_meas_flag = rhs._dopp_ambig_conf_meas_flag; _outp_data_mean_flag = rhs._outp_data_mean_flag; _OGOB_flag = rhs._OGOB_flag; _PRF_changes = rhs._PRF_changes; _sampling_win_changes = rhs._sampling_win_changes; _cal_gain_changes = rhs._cal_gain_changes; _missing_lines = rhs._missing_lines; _rec_gain_changes = rhs._rec_gain_changes; _pulse_width_of_ACF_3db = rhs._pulse_width_of_ACF_3db; _first_side_lobe_lev_of_ACF = rhs._first_side_lobe_lev_of_ACF; _ISLR_of_ACF = rhs._ISLR_of_ACF; _dopp_cent_conf_meas = rhs._dopp_cent_conf_meas; _dopp_ambig_conf_meas = rhs._dopp_ambig_conf_meas; _inp_data_I_mean = rhs._inp_data_I_mean; _inp_data_Q_mean = rhs._inp_data_Q_mean; _inp_data_I_stddev = rhs._inp_data_I_stddev; _inp_data_Q_stddev = rhs._inp_data_Q_stddev; _cal_sys_gain = rhs._cal_sys_gain; _first_rec_gain_read = rhs._first_rec_gain_read; _dopp_ambig_num = rhs._dopp_ambig_num; _I_channel_bias_correction = rhs._I_channel_bias_correction; _Q_channel_bias_correction = rhs._Q_channel_bias_correction; _I_channel_gain_correction = rhs._I_channel_gain_correction; _Q_channel_gain_correction = rhs._Q_channel_gain_correction; _Q_channel_I_Q_correction = rhs._Q_channel_I_Q_correction; _noise_power = rhs._noise_power; _int_cal_utc = rhs._int_cal_utc; _num_valid_cal_pulses = rhs._num_valid_cal_pulses; _num_valid_noise_pulses = rhs._num_valid_noise_pulses; _num_valid_replicas = rhs._num_valid_replicas; _first_replica_sample = rhs._first_replica_sample; _mean_cal_pulse_power = rhs._mean_cal_pulse_power; _mean_noise_power = rhs._mean_noise_power; _range_comp_norm_fact = rhs._range_comp_norm_fact; _replica_power = rhs._replica_power; _first_range_pixel_mid_az_inc = rhs._first_range_pixel_mid_az_inc; _center_range_pix_mid_az_inc = rhs._center_range_pix_mid_az_inc; _last_range_pix_mid_az_inc = rhs._last_range_pix_mid_az_inc; _norm_ref_range_ro = rhs._norm_ref_range_ro; _antenna_elev_flag = rhs._antenna_elev_flag; _abs_cal_const_K = rhs._abs_cal_const_K; _upp_bound_K = rhs._upp_bound_K; _low_bound_K = rhs._low_bound_K; _proc_noise_scale_fact = rhs._proc_noise_scale_fact; _K_gen_date = rhs._K_gen_date; _K_vers_num = rhs._K_vers_num; _num_duplic_input_lines = rhs._num_duplic_input_lines; _estim_bit_error_rate = rhs._estim_bit_error_rate; _out_image_mean = rhs._out_image_mean; _out_image_std_dev = rhs._out_image_std_dev; _out_image_max_value = rhs._out_image_max_value; _time_raw_data_first_input = rhs._time_raw_data_first_input; _time_asc_node_state_vectors = rhs._time_asc_node_state_vectors; _asc_node_pos_X_comp = rhs._asc_node_pos_X_comp; _asc_node_pos_Y_comp = rhs._asc_node_pos_Y_comp; _asc_node_pos_Z_comp = rhs._asc_node_pos_Z_comp; _asc_node_vel_X_comp = rhs._asc_node_vel_X_comp; _asc_node_vel_Y_comp = rhs._asc_node_vel_Y_comp; _asc_node_vel_Z_comp = rhs._asc_node_vel_Z_comp; _out_pixel_bit_length = rhs._out_pixel_bit_length; _proc_gain_param_1 = rhs._proc_gain_param_1; _proc_gain_param_2 = rhs._proc_gain_param_2; _proc_gain_param_3 = rhs._proc_gain_param_3; _peak_loc_cross_correl_fun = rhs._peak_loc_cross_correl_fun; _3_dB_width_CCF = rhs._3_dB_width_CCF; _first_side_lobe_level = rhs._first_side_lobe_level; _ISLR_CCF_between_last = rhs._ISLR_CCF_between_last; _peak_loc_CCF_betw_last = rhs._peak_loc_CCF_betw_last; _Roll_Tilt_Mode_flag = rhs._Roll_Tilt_Mode_flag; _raw_data_correction_flag = rhs._raw_data_correction_flag; _look_detecion_flag = rhs._look_detecion_flag; _doppler_ambiguity_estimat_flag = rhs._doppler_ambiguity_estimat_flag; _azimuth_baseband_convers_flag = rhs._azimuth_baseband_convers_flag; _samples_per_line_used = rhs._samples_per_line_used; _range_lines_skip_factor = rhs._range_lines_skip_factor; _time_of_inp_state_vectors = rhs._time_of_inp_state_vectors; _inp_state_vect_pos_X_comp = rhs._inp_state_vect_pos_X_comp; _inp_state_vect_pos_Y_comp = rhs._inp_state_vect_pos_Y_comp; _inp_state_vect_pos_Z_comp = rhs._inp_state_vect_pos_Z_comp; _inp_state_vect_vel_Vx_comp = rhs._inp_state_vect_vel_Vx_comp; _inp_state_vect_vel_Vy_comp = rhs._inp_state_vect_vel_Vy_comp; _inp_state_vect_vel_Vz_comp = rhs._inp_state_vect_vel_Vz_comp; _inp_state_vector_type_flag = rhs._inp_state_vector_type_flag; _win_coeff_for_range_match = rhs._win_coeff_for_range_match; _win_coeff_for_azi_match = rhs._win_coeff_for_azi_match; _update_period_range_match = rhs._update_period_range_match; _look_scalar_gain_1 = rhs._look_scalar_gain_1; _look_scalar_gain_2 = rhs._look_scalar_gain_2; _look_scalar_gain_3 = rhs._look_scalar_gain_3; _look_scalar_gain_4 = rhs._look_scalar_gain_4; _look_scalar_gain_5 = rhs._look_scalar_gain_5; _look_scalar_gain_6 = rhs._look_scalar_gain_6; _look_scalar_gain_7 = rhs._look_scalar_gain_7; _look_scalar_gain_8 = rhs._look_scalar_gain_8; _samp_window_start_time_bias = rhs._samp_window_start_time_bias; _doppler_centroid_cubic_coeff = rhs._doppler_centroid_cubic_coeff; _PRF_code_first_range_line = rhs._PRF_code_first_range_line; _PRF_code_last_range_line = rhs._PRF_code_last_range_line; _samp_win_start_first = rhs._samp_win_start_first; _samp_win_start_last = rhs._samp_win_start_last; _cal_syst_gain_last_proc = rhs._cal_syst_gain_last_proc; _receiver_gain_last_proc = rhs._receiver_gain_last_proc; _first_processed_range_sample = rhs._first_processed_range_sample; _azimuth_FFT_IFFT_ratio = rhs._azimuth_FFT_IFFT_ratio; _num_azimuth_blocks_proc = rhs._num_azimuth_blocks_proc; _num_input_raw_data_lines = rhs._num_input_raw_data_lines; _initial_doppler_ambiguity_num = rhs._initial_doppler_ambiguity_num; _thresh_no_1_flag = rhs._thresh_no_1_flag; _thresh_no_2_flag = rhs._thresh_no_2_flag; _thresh_no_3_flag = rhs._thresh_no_3_flag; _thresh_no_4_flag = rhs._thresh_no_4_flag; _thresh_no_5_flag = rhs._thresh_no_5_flag; _thresh_no_6_flag = rhs._thresh_no_6_flag; _thresh_no_7_flag = rhs._thresh_no_7_flag; _thresh_no_8_flag = rhs._thresh_no_8_flag; _thresh_no_9_flag = rhs._thresh_no_9_flag; _thresh_no_10_flag = rhs._thresh_no_10_flag; _thresh_no_11_flag = rhs._thresh_no_11_flag; _sat_binary_time_of_first = rhs._sat_binary_time_of_first; _num_valid_pixels_per_range = rhs._num_valid_pixels_per_range; _num_range_samp_discarded = rhs._num_range_samp_discarded; _I_gain_imb_lower_bound = rhs._I_gain_imb_lower_bound; _I_gain_imb_upper_bound = rhs._I_gain_imb_upper_bound; _I_Q_quad_depar_lower_bound = rhs._I_Q_quad_depar_lower_bound; _I_Q_quad_depar_upper_bound = rhs._I_Q_quad_depar_upper_bound; _3_dB_look_bandwidth = rhs._3_dB_look_bandwidth; _3_dB_look_proc_dopp_bandw = rhs._3_dB_look_proc_dopp_bandw; _range_spread_loss_comp_flag = rhs._range_spread_loss_comp_flag; _datation_flag = rhs._datation_flag; _max_error_range_line_timing = rhs._max_error_range_line_timing; _form_num_range_line_used = rhs._form_num_range_line_used; _autom_look_scal_gain_flag = rhs._autom_look_scal_gain_flag; _max_value_look_scalar_gain = rhs._max_value_look_scalar_gain; _replica_norm_method_flag = rhs._replica_norm_method_flag; _coef_ground_range_1 = rhs._coef_ground_range_1; _coef_ground_range_2 = rhs._coef_ground_range_2; _coef_ground_range_3 = rhs._coef_ground_range_3; _coef_ground_range_4 = rhs._coef_ground_range_4; _coef_ant_elev_1 = rhs._coef_ant_elev_1; _coef_ant_elev_2 = rhs._coef_ant_elev_2; _coef_ant_elev_3 = rhs._coef_ant_elev_3; _coef_ant_elev_4 = rhs._coef_ant_elev_4; _coef_ant_elev_5 = rhs._coef_ant_elev_5; _range_time_origin_ant = rhs._range_time_origin_ant; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarFacilityData.h000066400000000000000000001016251301006202600322340ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarFacilityData_h #define AlosPalsarFacilityData_h #include #include #include #include namespace ossimplugins { /** * @ingroup AlosPalsarFacilityDataRecord * @brief This class is able to read the SAR leader data set summary record of the leader file */ class AlosPalsarFacilityData : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarFacilityData(); /** * @brief Destructor */ virtual ~AlosPalsarFacilityData(); /** * @brief This function write the AlosPalsarFacilityData in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarFacilityData& data); /** * @brief This function read a AlosPalsarFacilityData from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarFacilityData& data); /** * @brief Copy constructor */ AlosPalsarFacilityData(const AlosPalsarFacilityData& rhs); /** * @brief Copy operator */ AlosPalsarFacilityData& operator=(const AlosPalsarFacilityData& rhs); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarFacilityData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarFacilityData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief name_of_facil_rec */ std::string get_name_of_facil_rec() const { return _name_of_facil_rec; }; /** * @brief last_release_qc_date */ std::string get_last_release_qc_date() const { return _last_release_qc_date; }; /** * @brief last_release_cal_date */ std::string get_last_release_cal_date() const { return _last_release_cal_date; }; /** * @brief qa_summary_flag */ int get_qa_summary_flag() const { return _qa_summary_flag; }; /** * @brief prf_code_change_flag */ int get_prf_code_change_flag() const { return _prf_code_change_flag; }; /** * @brief sampling_win_change_flag */ int get_sampling_win_change_flag() const { return _sampling_win_change_flag; }; /** * @brief cal_gain_change_flag */ int get_cal_gain_change_flag() const { return _cal_gain_change_flag; }; /** * @brief quirp_qu_flag */ int get_quirp_qu_flag() const { return _quirp_qu_flag; }; /** * @brief inp_data_stat_flag */ int get_inp_data_stat_flag() const { return _inp_data_stat_flag; }; /** * @brief dopp_cent_conf_meas_flag */ int get_dopp_cent_conf_meas_flag() const { return _dopp_cent_conf_meas_flag; }; /** * @brief dopp_cent_val_flag */ int get_dopp_cent_val_flag() const { return _dopp_cent_val_flag; }; /** * @brief dopp_ambig_conf_meas_flag */ int get_dopp_ambig_conf_meas_flag() const { return _dopp_ambig_conf_meas_flag; }; /** * @brief outp_data_mean_flag */ int get_outp_data_mean_flag() const { return _outp_data_mean_flag; }; /** * @brief OGOB_flag */ int get_OGOB_flag() { return _OGOB_flag; }; /** * @brief PRF_changes */ int get_PRF_changes() { return _PRF_changes; }; /** * @brief sampling_win_changes */ int get_sampling_win_changes() const { return _sampling_win_changes; }; /** * @brief cal_gain_changes */ int get_cal_gain_changes() const { return _cal_gain_changes; }; /** * @brief missing_lines */ int get_missing_lines() const { return _missing_lines; }; /** * @brief rec_gain_changes */ int get_rec_gain_changes() const { return _rec_gain_changes; }; /** * @brief pulse_width_of_ACF_3db */ double get_pulse_width_of_ACF_3db() { return _pulse_width_of_ACF_3db; }; /** * @brief first_side_lobe_lev_of_ACF */ double get_first_side_lobe_lev_of_ACF() { return _first_side_lobe_lev_of_ACF; }; /** * @brief ISLR_of_ACF */ double get_ISLR_of_ACF() { return _ISLR_of_ACF; }; /** * @brief dopp_cent_conf_meas */ double get_dopp_cent_conf_meas() const { return _dopp_cent_conf_meas; }; /** * @brief dopp_ambig_conf_meas */ double get_dopp_ambig_conf_meas() const { return _dopp_ambig_conf_meas; }; /** * @brief inp_data_I_mean */ double get_inp_data_I_mean() { return _inp_data_I_mean; }; /** * @brief inp_data_Q_mean */ double get_inp_data_Q_mean() { return _inp_data_Q_mean; }; /** * @brief inp_data_I_stddev */ double get_inp_data_I_stddev() { return _inp_data_I_stddev; }; /** * @brief inp_data_Q_stddev */ double get_inp_data_Q_stddev() { return _inp_data_Q_stddev; }; /** * @brief cal_sys_gain */ double get_cal_sys_gain() const { return _cal_sys_gain; }; /** * @brief first_rec_gain_read */ double get_first_rec_gain_read() const { return _first_rec_gain_read; }; /** * @brief dopp_ambig_num */ double get_dopp_ambig_num() const { return _dopp_ambig_num; }; /** * @brief I_channel_bias_correction */ double get_I_channel_bias_correction() { return _I_channel_bias_correction; }; /** * @brief Q_channel_bias_correction */ double get_Q_channel_bias_correction() { return _Q_channel_bias_correction; }; /** * @brief I_channel_gain_correction */ double get_I_channel_gain_correction() { return _I_channel_gain_correction; }; /** * @brief Q_channel_gain_correction */ double get_Q_channel_gain_correction() { return _Q_channel_gain_correction; }; /** * @brief Q_channel_I_Q_correction */ double get_Q_channel_I_Q_correction() { return _Q_channel_I_Q_correction; }; /** * @brief noise_power */ double get_noise_power() const { return _noise_power; }; /** * @brief int_cal_utc */ int get_int_cal_utc() const { return _int_cal_utc; }; /** * @brief num_valid_cal_pulses */ int get_num_valid_cal_pulses() const { return _num_valid_cal_pulses; }; /** * @brief num_valid_noise_pulses */ int get_num_valid_noise_pulses() const { return _num_valid_noise_pulses; }; /** * @brief num_valid_replicas */ int get_num_valid_replicas() const { return _num_valid_replicas; }; /** * @brief first_replica_sample */ double get_first_replica_sample() const { return _first_replica_sample; }; /** * @brief mean_cal_pulse_power */ double get_mean_cal_pulse_power() const { return _mean_cal_pulse_power; }; /** * @brief mean_noise_power */ double get_mean_noise_power() const { return _mean_noise_power; }; /** * @brief range_comp_norm_fact */ double get_range_comp_norm_fact() const { return _range_comp_norm_fact; }; /** * @brief replica_power */ double get_replica_power() const { return _replica_power; }; /** * @brief first_range_pixel_mid_az_inc */ double get_first_range_pixel_mid_az_inc() const { return _first_range_pixel_mid_az_inc; }; /** * @brief center_range_pix_mid_az_inc */ double get_center_range_pix_mid_az_inc() const { return _center_range_pix_mid_az_inc; }; /** * @brief last_range_pix_mid_az_inc */ double get_last_range_pix_mid_az_inc() const { return _last_range_pix_mid_az_inc; }; /** * @brief norm_ref_range_ro */ double get_norm_ref_range_ro() const { return _norm_ref_range_ro; }; /** * @brief antenna_elev_flag */ int get_antenna_elev_flag() const { return _antenna_elev_flag; }; /** * @brief abs_cal_const_K */ double get_abs_cal_const_K() { return _abs_cal_const_K; }; /** * @brief upp_bound_K */ double get_upp_bound_K() { return _upp_bound_K; }; /** * @brief low_bound_K */ double get_low_bound_K() { return _low_bound_K; }; /** * @brief proc_noise_scale_fact */ double get_proc_noise_scale_fact() const { return _proc_noise_scale_fact; }; /** * @brief K_gen_date */ std::string get_K_gen_date() { return _K_gen_date; }; /** * @brief K_vers_num */ std::string get_K_vers_num() { return _K_vers_num; }; /** * @brief num_duplic_input_lines */ int get_num_duplic_input_lines() const { return _num_duplic_input_lines; }; /** * @brief estim_bit_error_rate */ double get_estim_bit_error_rate() const { return _estim_bit_error_rate; }; /** * @brief out_image_mean */ double get_out_image_mean() const { return _out_image_mean; }; /** * @brief out_image_std_dev */ double get_out_image_std_dev() const { return _out_image_std_dev; }; /** * @brief out_image_max_value */ double get_out_image_max_value() const { return _out_image_max_value; }; /** * @brief time_raw_data_first_input */ std::string get_time_raw_data_first_input() const { return _time_raw_data_first_input; }; /** * @brief time_asc_node_state_vectors */ std::string get_time_asc_node_state_vectors() const { return _time_asc_node_state_vectors; }; /** * @brief asc_node_pos_X_comp */ std::string get_asc_node_pos_X_comp() { return _asc_node_pos_X_comp; }; /** * @brief asc_node_pos_Y_comp */ std::string get_asc_node_pos_Y_comp() { return _asc_node_pos_Y_comp; }; /** * @brief asc_node_pos_Z_comp */ std::string get_asc_node_pos_Z_comp() { return _asc_node_pos_Z_comp; }; /** * @brief asc_node_vel_X_comp */ std::string get_asc_node_vel_X_comp() { return _asc_node_vel_X_comp; }; /** * @brief asc_node_vel_Y_comp */ std::string get_asc_node_vel_Y_comp() { return _asc_node_vel_Y_comp; }; /** * @brief asc_node_vel_Z_comp */ std::string get_asc_node_vel_Z_comp() { return _asc_node_vel_Z_comp; }; /** * @brief out_pixel_bit_length */ int get_out_pixel_bit_length() const { return _out_pixel_bit_length; }; /** * @brief proc_gain_param_1 */ double get_proc_gain_param_1() { return _proc_gain_param_1; }; /** * @brief proc_gain_param_2 */ double get_proc_gain_param_2() { return _proc_gain_param_2; }; /** * @brief proc_gain_param_3 */ double get_proc_gain_param_3() { return _proc_gain_param_3; }; /** * @brief peak_loc_cross_correl_fun */ int get_peak_loc_cross_correl_fun() const { return _peak_loc_cross_correl_fun; }; /** * @brief 3_dB_width_CCF */ double get_3_dB_width_CCF() { return _3_dB_width_CCF; }; /** * @brief first_side_lobe_level */ double get_first_side_lobe_level() const { return _first_side_lobe_level; }; /** * @brief ISLR_CCF_between_last */ double get_ISLR_CCF_between_last() { return _ISLR_CCF_between_last; }; /** * @brief peak_loc_CCF_betw_last */ int get_peak_loc_CCF_betw_last() { return _peak_loc_CCF_betw_last; }; /** * @brief Roll_Tilt_Mode_flag */ int get_Roll_Tilt_Mode_flag() { return _Roll_Tilt_Mode_flag; }; /** * @brief raw_data_correction_flag */ int get_raw_data_correction_flag() const { return _raw_data_correction_flag; }; /** * @brief look_detecion_flag */ int get_look_detecion_flag() const { return _look_detecion_flag; }; /** * @brief doppler_ambiguity_estimat_flag */ int get_doppler_ambiguity_estimat_flag() const { return _doppler_ambiguity_estimat_flag; }; /** * @brief azimuth_baseband_convers_flag */ int get_azimuth_baseband_convers_flag() const { return _azimuth_baseband_convers_flag; }; /** * @brief samples_per_line_used */ int get_samples_per_line_used() const { return _samples_per_line_used; }; /** * @brief range_lines_skip_factor */ int get_range_lines_skip_factor() const { return _range_lines_skip_factor; }; /** * @brief time_of_inp_state_vectors */ std::string get_time_of_inp_state_vectors() const { return _time_of_inp_state_vectors; }; /** * @brief inp_state_vect_pos_X_comp */ std::string get_inp_state_vect_pos_X_comp() { return _inp_state_vect_pos_X_comp; }; /** * @brief inp_state_vect_pos_Y_comp */ std::string get_inp_state_vect_pos_Y_comp() { return _inp_state_vect_pos_Y_comp; }; /** * @brief inp_state_vect_pos_Z_comp */ std::string get_inp_state_vect_pos_Z_comp() { return _inp_state_vect_pos_Z_comp; }; /** * @brief inp_state_vect_vel_Vx_comp */ std::string get_inp_state_vect_vel_Vx_comp() { return _inp_state_vect_vel_Vx_comp; }; /** * @brief inp_state_vect_vel_Vy_comp */ std::string get_inp_state_vect_vel_Vy_comp() { return _inp_state_vect_vel_Vy_comp; }; /** * @brief inp_state_vect_vel_Vz_comp */ std::string get_inp_state_vect_vel_Vz_comp() { return _inp_state_vect_vel_Vz_comp; }; /** * @brief inp_state_vector_type_flag */ int get_inp_state_vector_type_flag() const { return _inp_state_vector_type_flag; }; /** * @brief win_coeff_for_range_match */ double get_win_coeff_for_range_match() const { return _win_coeff_for_range_match; }; /** * @brief win_coeff_for_azi_match */ double get_win_coeff_for_azi_match() const { return _win_coeff_for_azi_match; }; /** * @brief update_period_range_match */ int get_update_period_range_match() const { return _update_period_range_match; }; /** * @brief look_scalar_gain_1 */ double get_look_scalar_gain_1() { return _look_scalar_gain_1; }; /** * @brief look_scalar_gain_2 */ double get_look_scalar_gain_2() { return _look_scalar_gain_2; }; /** * @brief look_scalar_gain_3 */ double get_look_scalar_gain_3() { return _look_scalar_gain_3; }; /** * @brief look_scalar_gain_4 */ double get_look_scalar_gain_4() { return _look_scalar_gain_4; }; /** * @brief look_scalar_gain_5 */ double get_look_scalar_gain_5() { return _look_scalar_gain_5; }; /** * @brief look_scalar_gain_6 */ double get_look_scalar_gain_6() { return _look_scalar_gain_6; }; /** * @brief look_scalar_gain_7 */ double get_look_scalar_gain_7() { return _look_scalar_gain_7; }; /** * @brief look_scalar_gain_8 */ double get_look_scalar_gain_8() { return _look_scalar_gain_8; }; /** * @brief samp_window_start_time_bias */ int get_samp_window_start_time_bias() const { return _samp_window_start_time_bias; }; /** * @brief doppler_centroid_cubic_coeff */ double get_doppler_centroid_cubic_coeff() const { return _doppler_centroid_cubic_coeff; }; /** * @brief PRF_code_first_range_line */ int get_PRF_code_first_range_line() { return _PRF_code_first_range_line; }; /** * @brief PRF_code_last_range_line */ int get_PRF_code_last_range_line() { return _PRF_code_last_range_line; }; /** * @brief samp_win_start_first */ int get_samp_win_start_first() const { return _samp_win_start_first; }; /** * @brief samp_win_start_last */ int get_samp_win_start_last() const { return _samp_win_start_last; }; /** * @brief cal_syst_gain_last_proc */ int get_cal_syst_gain_last_proc() const { return _cal_syst_gain_last_proc; }; /** * @brief receiver_gain_last_proc */ int get_receiver_gain_last_proc() const { return _receiver_gain_last_proc; }; /** * @brief first_processed_range_sample */ int get_first_processed_range_sample() const { return _first_processed_range_sample; }; /** * @brief azimuth_FFT_IFFT_ratio */ int get_azimuth_FFT_IFFT_ratio() { return _azimuth_FFT_IFFT_ratio; }; /** * @brief num_azimuth_blocks_proc */ int get_num_azimuth_blocks_proc() const { return _num_azimuth_blocks_proc; }; /** * @brief num_input_raw_data_lines */ int get_num_input_raw_data_lines() const { return _num_input_raw_data_lines; }; /** * @brief initial_doppler_ambiguity_num */ int get_initial_doppler_ambiguity_num() const { return _initial_doppler_ambiguity_num; }; /** * @brief thresh_no_1_flag */ double get_thresh_no_1_flag() { return _thresh_no_1_flag; }; /** * @brief thresh_no_2_flag */ double get_thresh_no_2_flag() { return _thresh_no_2_flag; }; /** * @brief thresh_no_3_flag */ double get_thresh_no_3_flag() { return _thresh_no_3_flag; }; /** * @brief thresh_no_4_flag */ double get_thresh_no_4_flag() { return _thresh_no_4_flag; }; /** * @brief thresh_no_5_flag */ double get_thresh_no_5_flag() { return _thresh_no_5_flag; }; /** * @brief thresh_no_6_flag */ double get_thresh_no_6_flag() { return _thresh_no_6_flag; }; /** * @brief thresh_no_7_flag */ double get_thresh_no_7_flag() { return _thresh_no_7_flag; }; /** * @brief thresh_no_8_flag */ double get_thresh_no_8_flag() { return _thresh_no_8_flag; }; /** * @brief thresh_no_9_flag */ double get_thresh_no_9_flag() { return _thresh_no_9_flag; }; /** * @brief thresh_no_10_flag */ double get_thresh_no_10_flag() { return _thresh_no_10_flag; }; /** * @brief thresh_no_11_flag */ double get_thresh_no_11_flag() { return _thresh_no_11_flag; }; /** * @brief sat_binary_time_of_first */ int get_sat_binary_time_of_first() const { return _sat_binary_time_of_first; }; /** * @brief num_valid_pixels_per_range */ int get_num_valid_pixels_per_range() const { return _num_valid_pixels_per_range; }; /** * @brief num_range_samp_discarded */ int get_num_range_samp_discarded() const { return _num_range_samp_discarded; }; /** * @brief I_gain_imb_lower_bound */ double get_I_gain_imb_lower_bound() { return _I_gain_imb_lower_bound; }; /** * @brief I_gain_imb_upper_bound */ double get_I_gain_imb_upper_bound() { return _I_gain_imb_upper_bound; }; /** * @brief I_Q_quad_depar_lower_bound */ double get_I_Q_quad_depar_lower_bound() { return _I_Q_quad_depar_lower_bound; }; /** * @brief I_Q_quad_depar_upper_bound */ double get_I_Q_quad_depar_upper_bound() { return _I_Q_quad_depar_upper_bound; }; /** * @brief 3_dB_look_bandwidth */ double get_3_dB_look_bandwidth() { return _3_dB_look_bandwidth; }; /** * @brief 3_dB_look_proc_dopp_bandw */ double get_3_dB_look_proc_dopp_bandw() { return _3_dB_look_proc_dopp_bandw; }; /** * @brief range_spread_loss_comp_flag */ int get_range_spread_loss_comp_flag() const { return _range_spread_loss_comp_flag; }; /** * @brief datation_flag */ bool get_datation_flag() const { return _datation_flag; }; /** * @brief max_error_range_line_timing */ int get_max_error_range_line_timing() const { return _max_error_range_line_timing; }; /** * @brief form_num_range_line_used */ int get_form_num_range_line_used() const { return _form_num_range_line_used; }; /** * @brief autom_look_scal_gain_flag */ bool get_autom_look_scal_gain_flag() const { return _autom_look_scal_gain_flag; }; /** * @brief max_value_look_scalar_gain */ int get_max_value_look_scalar_gain() const { return _max_value_look_scalar_gain; }; /** * @brief replica_norm_method_flag */ int get_replica_norm_method_flag() const { return _replica_norm_method_flag; }; /** * @brief coef_ground_range_1 */ double get_coef_ground_range_1() const { return _coef_ground_range_1; }; /** * @brief coef_ground_range_2 */ double get_coef_ground_range_2() const { return _coef_ground_range_2; }; /** * @brief coef_ground_range_3 */ double get_coef_ground_range_3() const { return _coef_ground_range_3; }; /** * @brief coef_ground_range_4 */ double get_coef_ground_range_4() const { return _coef_ground_range_4; }; /** * @brief coef_ant_elev_1 */ double get_coef_ant_elev_1() const { return _coef_ant_elev_1; }; /** * @brief coef_ant_elev_2 */ double get_coef_ant_elev_2() const { return _coef_ant_elev_2; }; /** * @brief coef_ant_elev_3 */ double get_coef_ant_elev_3() const { return _coef_ant_elev_3; }; /** * @brief coef_ant_elev_4 */ double get_coef_ant_elev_4() const { return _coef_ant_elev_4; }; /** * @brief coef_ant_elev_5 */ double get_coef_ant_elev_5() const { return _coef_ant_elev_5; }; /** * @brief range_time_origin_ant */ double get_range_time_origin_ant() const { return _range_time_origin_ant; }; protected: /** * @brief last_release_qc_date */ std::string _name_of_facil_rec; /** * @brief last_release_qc_date */ std::string _last_release_qc_date; /** * @brief last_release_cal_date */ std::string _last_release_cal_date; /** * @brief qa_summary_flag */ int _qa_summary_flag; /** * @brief prf_code_change_flag */ int _prf_code_change_flag; /** * @brief sampling_win_change_flag */ int _sampling_win_change_flag; /** * @brief cal_gain_change_flag */ int _cal_gain_change_flag; /** * @brief quirp_qu_flag */ int _quirp_qu_flag; /** * @brief inp_data_stat_flag */ int _inp_data_stat_flag; /** * @brief dopp_cent_conf_meas_flag */ int _dopp_cent_conf_meas_flag; /** * @brief dopp_cent_val_flag */ int _dopp_cent_val_flag; /** * @brief dopp_ambig_conf_meas_flag */ int _dopp_ambig_conf_meas_flag; /** * @brief outp_data_mean_flag */ int _outp_data_mean_flag; /** * @brief OGOB_flag */ int _OGOB_flag; /** * @brief PRF_changes */ int _PRF_changes; /** * @brief sampling_win_changes */ int _sampling_win_changes; /** * @brief cal_gain_changes */ int _cal_gain_changes; /** * @brief missing_lines */ int _missing_lines; /** * @brief rec_gain_changes */ int _rec_gain_changes; /** * @brief pulse_width_of_ACF_3db */ double _pulse_width_of_ACF_3db; /** * @brief first_side_lobe_lev_of_ACF */ double _first_side_lobe_lev_of_ACF; /** * @brief ISLR_of_ACF */ double _ISLR_of_ACF; /** * @brief dopp_cent_conf_meas */ double _dopp_cent_conf_meas; /** * @brief dopp_ambig_conf_meas */ double _dopp_ambig_conf_meas; /** * @brief inp_data_I_mean */ double _inp_data_I_mean; /** * @brief inp_data_Q_mean */ double _inp_data_Q_mean; /** * @brief inp_data_I_stddev */ double _inp_data_I_stddev; /** * @brief inp_data_Q_stddev */ double _inp_data_Q_stddev; /** * @brief cal_sys_gain */ double _cal_sys_gain; /** * @brief first_rec_gain_read */ double _first_rec_gain_read; /** * @brief dopp_ambig_num */ double _dopp_ambig_num; /** * @brief I_channel_bias_correction */ double _I_channel_bias_correction; /** * @brief Q_channel_bias_correction */ double _Q_channel_bias_correction; /** * @brief I_channel_gain_correction */ double _I_channel_gain_correction; /** * @brief Q_channel_gain_correction */ double _Q_channel_gain_correction; /** * @brief Q_channel_I_Q_correction */ double _Q_channel_I_Q_correction; /** * @brief noise_power */ double _noise_power; /** * @brief int_cal_utc */ int _int_cal_utc; /** * @brief num_valid_cal_pulses */ int _num_valid_cal_pulses; /** * @brief num_valid_noise_pulses */ int _num_valid_noise_pulses; /** * @brief num_valid_replicas */ int _num_valid_replicas; /** * @brief first_replica_sample */ double _first_replica_sample; /** * @brief mean_cal_pulse_power */ double _mean_cal_pulse_power; /** * @brief mean_noise_power */ double _mean_noise_power; /** * @brief range_comp_norm_fact */ double _range_comp_norm_fact; /** * @brief replica_power */ double _replica_power; /** * @brief first_range_pixel_mid_az_inc */ double _first_range_pixel_mid_az_inc; /** * @brief center_range_pix_mid_az_inc */ double _center_range_pix_mid_az_inc; /** * @brief last_range_pix_mid_az_inc */ double _last_range_pix_mid_az_inc; /** * @brief norm_ref_range_ro */ double _norm_ref_range_ro; /** * @brief antenna_elev_flag */ int _antenna_elev_flag; /** * @brief abs_cal_const_K */ double _abs_cal_const_K; /** * @brief upp_bound_K */ double _upp_bound_K; /** * @brief low_bound_K */ double _low_bound_K; /** * @brief proc_noise_scale_fact */ double _proc_noise_scale_fact; /** * @brief K_gen_date */ std::string _K_gen_date; /** * @brief K_vers_num */ std::string _K_vers_num; /** * @brief num_duplic_input_lines */ int _num_duplic_input_lines; /** * @brief estim_bit_error_rate */ double _estim_bit_error_rate; /** * @brief out_image_mean */ double _out_image_mean; /** * @brief out_image_std_dev */ double _out_image_std_dev; /** * @brief out_image_max_value */ double _out_image_max_value; /** * @brief time_raw_data_first_input */ std::string _time_raw_data_first_input; /** * @brief time_asc_node_state_vectors */ std::string _time_asc_node_state_vectors; /** * @brief asc_node_pos_X_comp */ std::string _asc_node_pos_X_comp; /** * @brief asc_node_pos_Y_comp */ std::string _asc_node_pos_Y_comp; /** * @brief asc_node_pos_Z_comp */ std::string _asc_node_pos_Z_comp; /** * @brief asc_node_vel_X_comp */ std::string _asc_node_vel_X_comp; /** * @brief asc_node_vel_Y_comp */ std::string _asc_node_vel_Y_comp; /** * @brief asc_node_vel_Z_comp */ std::string _asc_node_vel_Z_comp; /** * @brief out_pixel_bit_length */ int _out_pixel_bit_length; /** * @brief proc_gain_param_1 */ double _proc_gain_param_1; /** * @brief proc_gain_param_2 */ double _proc_gain_param_2; /** * @brief proc_gain_param_3 */ double _proc_gain_param_3; /** * @brief peak_loc_cross_correl_fun */ int _peak_loc_cross_correl_fun; /** * @brief 3_dB_width_CCF */ double _3_dB_width_CCF; /** * @brief first_side_lobe_level */ double _first_side_lobe_level; /** * @brief ISLR_CCF_between_last */ double _ISLR_CCF_between_last; /** * @brief peak_loc_CCF_betw_last */ int _peak_loc_CCF_betw_last; /** * @brief Roll_Tilt_Mode_flag */ int _Roll_Tilt_Mode_flag; /** * @brief raw_data_correction_flag */ int _raw_data_correction_flag; /** * @brief look_detecion_flag */ int _look_detecion_flag; /** * @brief doppler_ambiguity_estimat_flag */ int _doppler_ambiguity_estimat_flag; /** * @brief azimuth_baseband_convers_flag */ int _azimuth_baseband_convers_flag; /** * @brief samples_per_line_used */ int _samples_per_line_used; /** * @brief range_lines_skip_factor */ int _range_lines_skip_factor; /** * @brief time_of_inp_state_vectors */ std::string _time_of_inp_state_vectors; /** * @brief inp_state_vect_pos_X_comp */ std::string _inp_state_vect_pos_X_comp; /** * @brief inp_state_vect_pos_Y_comp */ std::string _inp_state_vect_pos_Y_comp; /** * @brief inp_state_vect_pos_Z_comp */ std::string _inp_state_vect_pos_Z_comp; /** * @brief inp_state_vect_vel_Vx_comp */ std::string _inp_state_vect_vel_Vx_comp; /** * @brief inp_state_vect_vel_Vy_comp */ std::string _inp_state_vect_vel_Vy_comp; /** * @brief inp_state_vect_vel_Vz_comp */ std::string _inp_state_vect_vel_Vz_comp; /** * @brief inp_state_vector_type_flag */ int _inp_state_vector_type_flag; /** * @brief win_coeff_for_range_match */ double _win_coeff_for_range_match; /** * @brief win_coeff_for_azi_match */ double _win_coeff_for_azi_match; /** * @brief update_period_range_match */ int _update_period_range_match; /** * @brief look_scalar_gain_1 */ double _look_scalar_gain_1; /** * @brief look_scalar_gain_2 */ double _look_scalar_gain_2; /** * @brief look_scalar_gain_3 */ double _look_scalar_gain_3; /** * @brief look_scalar_gain_4 */ double _look_scalar_gain_4; /** * @brief look_scalar_gain_5 */ double _look_scalar_gain_5; /** * @brief look_scalar_gain_6 */ double _look_scalar_gain_6; /** * @brief look_scalar_gain_7 */ double _look_scalar_gain_7; /** * @brief look_scalar_gain_8 */ double _look_scalar_gain_8; /** * @brief samp_window_start_time_bias */ int _samp_window_start_time_bias; /** * @brief doppler_centroid_cubic_coeff */ double _doppler_centroid_cubic_coeff; /** * @brief PRF_code_first_range_line */ int _PRF_code_first_range_line; /** * @brief PRF_code_last_range_line */ int _PRF_code_last_range_line; /** * @brief samp_win_start_first */ int _samp_win_start_first; /** * @brief samp_win_start_last */ int _samp_win_start_last; /** * @brief cal_syst_gain_last_proc */ int _cal_syst_gain_last_proc; /** * @brief receiver_gain_last_proc */ int _receiver_gain_last_proc; /** * @brief first_processed_range_sample */ int _first_processed_range_sample; /** * @brief azimuth_FFT_IFFT_ratio */ int _azimuth_FFT_IFFT_ratio; /** * @brief num_azimuth_blocks_proc */ int _num_azimuth_blocks_proc; /** * @brief num_input_raw_data_lines */ int _num_input_raw_data_lines; /** * @brief initial_doppler_ambiguity_num */ int _initial_doppler_ambiguity_num; /** * @brief thresh_no_1_flag */ double _thresh_no_1_flag; /** * @brief thresh_no_2_flag */ double _thresh_no_2_flag; /** * @brief thresh_no_3_flag */ double _thresh_no_3_flag; /** * @brief thresh_no_4_flag */ double _thresh_no_4_flag; /** * @brief thresh_no_5_flag */ double _thresh_no_5_flag; /** * @brief thresh_no_6_flag */ double _thresh_no_6_flag; /** * @brief thresh_no_7_flag */ double _thresh_no_7_flag; /** * @brief thresh_no_8_flag */ double _thresh_no_8_flag; /** * @brief thresh_no_9_flag */ double _thresh_no_9_flag; /** * @brief thresh_no_10_flag */ double _thresh_no_10_flag; /** * @brief thresh_no_11_flag */ double _thresh_no_11_flag; /** * @brief sat_binary_time_of_first */ int _sat_binary_time_of_first; /** * @brief num_valid_pixels_per_range */ int _num_valid_pixels_per_range; /** * @brief num_range_samp_discarded */ int _num_range_samp_discarded; /** * @brief I_gain_imb_lower_bound */ double _I_gain_imb_lower_bound; /** * @brief I_gain_imb_upper_bound */ double _I_gain_imb_upper_bound; /** * @brief I_Q_quad_depar_lower_bound */ double _I_Q_quad_depar_lower_bound; /** * @brief I_Q_quad_depar_upper_bound */ double _I_Q_quad_depar_upper_bound; /** * @brief 3_dB_look_bandwidth */ double _3_dB_look_bandwidth; /** * @brief 3_dB_look_proc_dopp_bandw */ double _3_dB_look_proc_dopp_bandw; /** * @brief range_spread_loss_comp_flag */ int _range_spread_loss_comp_flag; /** * @brief datation_flag */ bool _datation_flag; /** * @brief max_error_range_line_timing */ int _max_error_range_line_timing; /** * @brief form_num_range_line_used */ int _form_num_range_line_used; /** * @brief autom_look_scal_gain_flag */ bool _autom_look_scal_gain_flag; /** * @brief max_value_look_scalar_gain */ int _max_value_look_scalar_gain; /** * @brief replica_norm_method_flag */ int _replica_norm_method_flag; /** * @brief coef_ground_range_1 */ double _coef_ground_range_1; /** * @brief coef_ground_range_2 */ double _coef_ground_range_2; /** * @brief coef_ground_range_3 */ double _coef_ground_range_3; /** * @brief coef_ground_range_4 */ double _coef_ground_range_4; /** * @brief coef_ant_elev_1 */ double _coef_ant_elev_1; /** * @brief coef_ant_elev_2 */ double _coef_ant_elev_2; /** * @brief coef_ant_elev_3 */ double _coef_ant_elev_3; /** * @brief coef_ant_elev_4 */ double _coef_ant_elev_4; /** * @brief coef_ant_elev_5 */ double _coef_ant_elev_5; /** * @brief range_time_origin_ant */ double _range_time_origin_ant; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarFileDescriptor.cpp000066400000000000000000000324771301006202600331570ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarFileDescriptor::AlosPalsarFileDescriptor() : AlosPalsarRecord("sar_desc_rec") { } AlosPalsarFileDescriptor::~AlosPalsarFileDescriptor() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarFileDescriptor& data) { os << "ascii_flag:" << data._ascii_flag.c_str() << std::endl; os << "continuation_flag:" << data._continuation_flag.c_str() << std::endl; os << "format_doc:" << data._format_doc.c_str() << std::endl; os << "format_ver:" << data._format_ver.c_str() << std::endl; os << "design_rev:" << data._design_rev.c_str() << std::endl; os << "software_id:" << data._software_id.c_str() << std::endl; os << "file_num:" << data._file_num << std::endl; os << "file_name:" << data._file_name.c_str() << std::endl; os << "rec_seq:" << data._rec_seq.c_str() << std::endl; os << "seq_loc:" << data._seq_loc << std::endl; os << "seq_len:" << data._seq_len << std::endl; os << "rec_code:" << data._rec_code.c_str() << std::endl; os << "code_loc:" << data._code_loc << std::endl; os << "code_len:" << data._code_len << std::endl; os << "rec_len:" << data._rec_len.c_str() << std::endl; os << "rlen_loc:" << data._rlen_loc << std::endl; os << "rlen_len:" << data._rlen_len << std::endl; os << "n_dataset:" << data._n_dataset << std::endl; os << "l_dataset:" << data._l_dataset << std::endl; os << "n_map_proj:" << data._n_map_proj << std::endl; os << "l_map_proj:" << data._l_map_proj << std::endl; os << "n_plat_pos:" << data._n_plat_pos << std::endl; os << "l_plat_pos:" << data._l_plat_pos << std::endl; os << "n_att_data:" << data._n_att_data << std::endl; os << "l_att_data:" << data._l_att_data << std::endl; os << "n_radi_data:" << data._n_radi_data << std::endl; os << "l_radi_data:" << data._l_radi_data << std::endl; os << "n_radi_comp:" << data._n_radi_comp << std::endl; os << "l_radi_comp:" << data._l_radi_comp << std::endl; os << "n_qual_sum:" << data._n_qual_sum << std::endl; os << "l_qual_sum:" << data._l_qual_sum << std::endl; os << "n_data_his:" << data._n_data_his << std::endl; os << "l_data_his:" << data._l_data_his << std::endl; os << "n_rang_spec:" << data._n_rang_spec << std::endl; os << "l_rang_spec:" << data._l_rang_spec << std::endl; os << "n_dem_desc:" << data._n_dem_desc << std::endl; os << "l_dem_desc:" << data._l_dem_desc << std::endl; os << "n_radar_par:" << data._n_radar_par << std::endl; os << "l_radar_par:" << data._l_radar_par << std::endl; os << "n_anno_data:" << data._n_anno_data << std::endl; os << "l_anno_data:" << data._l_anno_data << std::endl; os << "n_det_proc:" << data._n_det_proc << std::endl; os << "l_det_proc:" << data._l_det_proc << std::endl; os << "n_cal:" << data._n_cal << std::endl; os << "l_cal:" << data._l_cal << std::endl; os << "n_gcp:" << data._n_gcp << std::endl; os << "l_gcp:" << data._l_gcp << std::endl; os << "n_fac_data:" << data._n_fac_data << std::endl; os << "l_fac_data:" << data._l_fac_data << std::endl; os << "n_fac_data2:" << data._n_fac_data2 << std::endl; os << "l_fac_data2:" << data._l_fac_data2 << std::endl; os << "n_fac_data3:" << data._n_fac_data3 << std::endl; os << "l_fac_data3:" << data._l_fac_data3 << std::endl; os << "n_fac_data4:" << data._n_fac_data4 << std::endl; os << "l_fac_data4:" << data._l_fac_data4 << std::endl; os << "n_fac_data5:" << data._n_fac_data5 << std::endl; os << "l_fac_data5:" << data._l_fac_data5 << std::endl; os << "n_fac_data6:" << data._n_fac_data6 << std::endl; os << "l_fac_data6:" << data._l_fac_data6 << std::endl; os << "n_fac_data7:" << data._n_fac_data7 << std::endl; os << "l_fac_data7:" << data._l_fac_data7 << std::endl; os << "n_fac_data8:" << data._n_fac_data8 << std::endl; os << "l_fac_data8:" << data._l_fac_data8 << std::endl; os << "n_fac_data9:" << data._n_fac_data9 << std::endl; os << "l_fac_data9:" << data._l_fac_data9 << std::endl; os << "n_fac_data10:" << data._n_fac_data10 << std::endl; os << "l_fac_data10:" << data._l_fac_data10 << std::endl; os << "n_fac_data11:" << data._n_fac_data11 << std::endl; os << "l_fac_data11:" << data._l_fac_data11 << std::endl; return os; } std::istream& operator>>(std::istream& is, AlosPalsarFileDescriptor& data) { char buf2[3]; buf2[2] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf16[17]; buf16[16] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf6[7]; buf6[6] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf64[65]; buf64[64] = '\0'; char buf60[61]; buf60[60] = '\0'; char buf146[147]; buf146[146] = '\0'; is.read(buf2, 2); data._ascii_flag = buf2; is.read(buf2, 2); data._continuation_flag = buf2; is.read(buf12, 12); data._format_doc = buf12; is.read(buf2, 2); data._format_ver = buf2; is.read(buf2, 2); data._design_rev = buf2; is.read(buf12, 12); data._software_id = buf12; is.read(buf4, 4); data._file_num = atoi(buf4); is.read(buf16, 16); data._file_name = buf16; is.read(buf4, 4); data._rec_seq = buf4; is.read(buf8, 8); data._seq_loc = atoi(buf8); is.read(buf4, 4); data._seq_len = atoi(buf4); is.read(buf4, 4); data._rec_code = buf4; is.read(buf8, 8); data._code_loc = atoi(buf8); is.read(buf4, 4); data._code_len = atoi(buf4); is.read(buf4, 4); data._rec_len = buf4; is.read(buf8, 8); data._rlen_loc = atoi(buf8); is.read(buf4, 4); data._rlen_len = atoi(buf4); is.read(buf4, 4); is.read(buf64, 64); is.read(buf6, 6); data._n_dataset = atoi(buf6); is.read(buf6, 6); data._l_dataset = atoi(buf6); is.read(buf6, 6); data._n_map_proj = atoi(buf6); is.read(buf6, 6); data._l_map_proj = atoi(buf6); is.read(buf6, 6); data._n_plat_pos = atoi(buf6); is.read(buf6, 6); data._l_plat_pos = atoi(buf6); is.read(buf6, 6); data._n_att_data = atoi(buf6); is.read(buf6, 6); data._l_att_data = atoi(buf6); is.read(buf6, 6); data._n_radi_data = atoi(buf6); is.read(buf6, 6); data._l_radi_data = atoi(buf6); is.read(buf6, 6); data._n_radi_comp = atoi(buf6); is.read(buf6, 6); data._l_radi_comp = atoi(buf6); is.read(buf6, 6); data._n_qual_sum = atoi(buf6); is.read(buf6, 6); data._l_qual_sum = atoi(buf6); is.read(buf6, 6); data._n_data_his = atoi(buf6); is.read(buf6, 6); data._l_data_his = atoi(buf6); is.read(buf6, 6); data._n_rang_spec = atoi(buf6); is.read(buf6, 6); data._l_rang_spec = atoi(buf6); is.read(buf6, 6); data._n_dem_desc = atoi(buf6); is.read(buf6, 6); data._l_dem_desc = atoi(buf6); is.read(buf6, 6); data._n_radar_par = atoi(buf6); is.read(buf6, 6); data._l_radar_par = atoi(buf6); is.read(buf6, 6); data._n_anno_data = atoi(buf6); is.read(buf6, 6); data._l_anno_data = atoi(buf6); is.read(buf6, 6); data._n_det_proc = atoi(buf6); is.read(buf6, 6); data._l_det_proc = atoi(buf6); is.read(buf6, 6); data._n_cal = atoi(buf6); is.read(buf6, 6); data._l_cal = atoi(buf6); is.read(buf6, 6); data._n_gcp = atoi(buf6); is.read(buf6, 6); data._l_gcp = atoi(buf6); is.read(buf60, 60); is.read(buf6, 6); data._n_fac_data = atoi(buf6); is.read(buf8, 8); data._l_fac_data = atoi(buf8); is.read(buf6, 6); data._n_fac_data2 = atoi(buf6); is.read(buf8, 8); data._l_fac_data2 = atoi(buf8); is.read(buf6, 6); data._n_fac_data3 = atoi(buf6); is.read(buf8, 8); data._l_fac_data3 = atoi(buf8); is.read(buf6, 6); data._n_fac_data4 = atoi(buf6); is.read(buf8, 8); data._l_fac_data4 = atoi(buf8); is.read(buf6, 6); data._n_fac_data5 = atoi(buf6); is.read(buf8, 8); data._l_fac_data5 = atoi(buf8); is.read(buf6, 6); data._n_fac_data6 = atoi(buf6); is.read(buf8, 8); data._l_fac_data6 = atoi(buf8); is.read(buf6, 6); data._n_fac_data7 = atoi(buf6); is.read(buf8, 8); data._l_fac_data7 = atoi(buf8); is.read(buf6, 6); data._n_fac_data8 = atoi(buf6); is.read(buf8, 8); data._l_fac_data8 = atoi(buf8); is.read(buf6, 6); data._n_fac_data9 = atoi(buf6); is.read(buf8, 8); data._l_fac_data9 = atoi(buf8); is.read(buf6, 6); data._n_fac_data10 = atoi(buf6); is.read(buf8, 8); data._l_fac_data10 = atoi(buf8); is.read(buf6, 6); data._n_fac_data11 = atoi(buf6); is.read(buf8, 8); data._l_fac_data11 = atoi(buf8); is.read(buf146, 146); return is; } AlosPalsarFileDescriptor::AlosPalsarFileDescriptor(const AlosPalsarFileDescriptor& rhs): AlosPalsarRecord(rhs), _ascii_flag(rhs._ascii_flag), _continuation_flag(rhs._continuation_flag), _format_doc(rhs._format_doc), _format_ver(rhs._format_ver), _design_rev(rhs._design_rev), _software_id(rhs._software_id), _file_num(rhs._file_num), _file_name(rhs._file_name), _rec_seq(rhs._rec_seq), _seq_loc(rhs._seq_loc), _seq_len(rhs._seq_len), _rec_code(rhs._rec_code), _code_loc(rhs._code_loc), _code_len(rhs._code_len), _rec_len(rhs._rec_len), _rlen_loc(rhs._rlen_loc), _rlen_len(rhs._rlen_len), _n_dataset(rhs._n_dataset), _l_dataset(rhs._l_dataset), _n_map_proj(rhs._n_map_proj), _l_map_proj(rhs._l_map_proj), _n_plat_pos(rhs._n_plat_pos), _l_plat_pos(rhs._l_plat_pos), _n_att_data(rhs._n_att_data), _l_att_data(rhs._l_att_data), _n_radi_data(rhs._n_radi_data), _l_radi_data(rhs._l_radi_data), _n_radi_comp(rhs._n_radi_comp), _l_radi_comp(rhs._l_radi_comp), _n_qual_sum(rhs._n_qual_sum), _l_qual_sum(rhs._l_qual_sum), _n_data_his(rhs._n_data_his), _l_data_his(rhs._l_data_his), _n_rang_spec(rhs._n_rang_spec), _l_rang_spec(rhs._l_rang_spec), _n_dem_desc(rhs._n_dem_desc), _l_dem_desc(rhs._l_dem_desc), _n_radar_par(rhs._n_radar_par), _l_radar_par(rhs._l_radar_par), _n_anno_data(rhs._n_anno_data), _l_anno_data(rhs._l_anno_data), _n_det_proc(rhs._n_det_proc), _l_det_proc(rhs._l_det_proc), _n_cal(rhs._n_cal), _l_cal(rhs._l_cal), _n_gcp(rhs._n_gcp), _l_gcp(rhs._l_gcp), _n_fac_data(rhs._n_fac_data), _l_fac_data(rhs._l_fac_data), _n_fac_data2(rhs._n_fac_data2), _l_fac_data2(rhs._l_fac_data2), _n_fac_data3(rhs._n_fac_data3), _l_fac_data3(rhs._l_fac_data3), _n_fac_data4(rhs._n_fac_data4), _l_fac_data4(rhs._l_fac_data4), _n_fac_data5(rhs._n_fac_data5), _l_fac_data5(rhs._l_fac_data5), _n_fac_data6(rhs._n_fac_data6), _l_fac_data6(rhs._l_fac_data6), _n_fac_data7(rhs._n_fac_data7), _l_fac_data7(rhs._l_fac_data7), _n_fac_data8(rhs._n_fac_data8), _l_fac_data8(rhs._l_fac_data8), _n_fac_data9(rhs._n_fac_data9), _l_fac_data9(rhs._l_fac_data9), _n_fac_data10(rhs._n_fac_data10), _l_fac_data10(rhs._l_fac_data10), _n_fac_data11(rhs._n_fac_data11), _l_fac_data11(rhs._l_fac_data11) { } AlosPalsarFileDescriptor& AlosPalsarFileDescriptor::operator=(const AlosPalsarFileDescriptor& rhs) { _ascii_flag = rhs._ascii_flag; _continuation_flag = rhs._continuation_flag; _format_doc = rhs._format_doc; _format_ver = rhs._format_ver; _design_rev = rhs._design_rev; _software_id = rhs._software_id; _file_num = rhs._file_num; _file_name = rhs._file_name; _rec_seq = rhs._rec_seq; _seq_loc = rhs._seq_loc; _seq_len = rhs._seq_len; _rec_code = rhs._rec_code; _code_loc = rhs._code_loc; _code_len = rhs._code_len; _rec_len = rhs._rec_len; _rlen_loc = rhs._rlen_loc; _rlen_len = rhs._rlen_len; _n_dataset = rhs._n_dataset; _l_dataset = rhs._l_dataset; _n_map_proj = rhs._n_map_proj; _l_map_proj = rhs._l_map_proj; _n_plat_pos = rhs._n_plat_pos; _l_plat_pos = rhs._l_plat_pos; _n_att_data = rhs._n_att_data; _l_att_data = rhs._l_att_data; _n_radi_data = rhs._n_radi_data; _l_radi_data = rhs._l_radi_data; _n_radi_comp = rhs._n_radi_comp; _l_radi_comp = rhs._l_radi_comp; _n_qual_sum = rhs._n_qual_sum ; _l_qual_sum = rhs._l_qual_sum; _n_data_his = rhs._n_data_his; _l_data_his = rhs._l_data_his; _n_rang_spec = rhs._n_rang_spec; _l_rang_spec = rhs._l_rang_spec; _n_dem_desc = rhs._n_dem_desc; _l_dem_desc = rhs._l_dem_desc; _n_radar_par = rhs._n_radar_par; _l_radar_par = rhs._l_radar_par; _n_anno_data = rhs._n_anno_data; _l_anno_data = rhs._l_anno_data; _n_det_proc = rhs._n_det_proc; _l_det_proc = rhs._l_det_proc; _n_cal = rhs._n_cal; _l_cal = rhs._l_cal; _n_gcp = rhs._n_gcp; _l_gcp = rhs._l_gcp; _n_fac_data = rhs._n_fac_data; _l_fac_data = rhs._l_fac_data; _n_fac_data2 = rhs._n_fac_data2; _l_fac_data2 = rhs._l_fac_data2; _n_fac_data3 = rhs._n_fac_data3; _l_fac_data3 = rhs._l_fac_data3; _n_fac_data4 = rhs._n_fac_data4; _l_fac_data4 = rhs._l_fac_data4; _n_fac_data5 = rhs._n_fac_data5; _l_fac_data5 = rhs._l_fac_data5; _n_fac_data6 = rhs._n_fac_data6; _l_fac_data6 = rhs._l_fac_data6; _n_fac_data7 = rhs._n_fac_data7; _l_fac_data7 = rhs._l_fac_data7; _n_fac_data8 = rhs._n_fac_data8; _l_fac_data8 = rhs._l_fac_data8; _n_fac_data9 = rhs._n_fac_data9; _l_fac_data9 = rhs._l_fac_data9; _n_fac_data10 = rhs._n_fac_data10; _l_fac_data10 = rhs._l_fac_data10; _n_fac_data11 = rhs._n_fac_data11; _l_fac_data11 = rhs._l_fac_data11; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarFileDescriptor.h000066400000000000000000000357711301006202600326240ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarFileDescriptor_h #define AlosPalsarFileDescriptor_h // TODO Rename to AlosPalsarLeaderFileDescriptor #include #include #include #include namespace ossimplugins { /** * @ingroup SARLeaderAlosPalsarFileDescriptorRecord * @brief This class is able to read the SAR leader file descriptor record of the leader file */ class AlosPalsarFileDescriptor : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarFileDescriptor(); /** * @brief Destructor */ virtual ~AlosPalsarFileDescriptor(); /** * @brief This function write the AlosPalsarFileDescriptor in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarFileDescriptor& data); /** * @brief This function read a AlosPalsarFileDescriptor from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarFileDescriptor& data); /** * @brief Copy constructor */ AlosPalsarFileDescriptor(const AlosPalsarFileDescriptor& rhs); /** * @brief Copy operator */ AlosPalsarFileDescriptor& operator=(const AlosPalsarFileDescriptor& rhs); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarFileDescriptor(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarFileDescriptor(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief ASCII flag */ std::string get_ascii_flag() const { return _ascii_flag; }; /** * @brief Continuation flag */ std::string get_continuation_flag() const { return _continuation_flag; }; /** * @brief Format control documentation */ std::string get_format_doc() const { return _format_doc; }; /** * @brief Format doc version */ std::string get_format_ver() const { return _format_ver; }; /** * @brief Format doc revision */ std::string get_design_rev() const { return _design_rev; }; /** * @brief Software identifier */ std::string get_software_id() const { return _software_id; }; /** * @brief File number */ int get_file_num() const { return _file_num ; }; /** * @brief File name */ std::string get_file_name() const { return _file_name; }; /** * @brief Record sequence/location flag */ std::string get_rec_seq() const { return _rec_seq; }; /** * @brief Sequence number location */ int get_seq_loc() const { return _seq_loc; }; /** * @brief Sequence number length */ int get_seq_len() const { return _seq_len; }; /** * @brief Record code/location flag */ std::string get_rec_code() const { return _rec_code; }; /** * @brief Record code location */ int get_code_loc() const { return _code_loc; }; /** * @brief Record code length */ int get_code_len() const { return _code_len; }; /** * @brief Record length/location flag */ std::string get_rec_len() const { return _rec_len; }; /** * @brief Record length location */ int get_rlen_loc() const { return _rlen_loc; }; /** * @brief Record length, bytes */ int get_rlen_len() const { return _rlen_len; }; /** * @brief Number of dataset summ records */ int get_n_dataset() const { return _n_dataset; }; /** * @brief Data set summary record length, bytes */ int get_l_dataset() const { return _l_dataset; }; /** * @brief Number of map proj records */ int get_n_map_proj() const { return _n_map_proj; }; /** * @brief Map projection record length, bytes */ int get_l_map_proj() const { return _l_map_proj; }; /** * @brief Number of platform position records */ int get_n_plat_pos() const { return _n_plat_pos; }; /** * @brief Platform position record length, bytes */ int get_l_plat_pos() const { return _l_plat_pos; }; /** * @brief Number of attitude data records */ int get_n_att_data() const { return _n_att_data; }; /** * @brief Attitude data record length, bytes */ int get_l_att_data() const { return _l_att_data; }; /** * @brief Number of radiometric data records */ int get_n_radi_data() const { return _n_radi_data; }; /** * @brief Radiometric data record length, bytes */ int get_l_radi_data() const { return _l_radi_data; }; /** * @brief Number of radiometric compensation records */ int get_n_radi_comp() const { return _n_radi_comp; }; /** * @brief Radiometric compensation record length, bytes */ int get_l_radi_comp() const { return _l_radi_comp; }; /** * @brief Number of data quality summary records */ int get_n_qual_sum() const { return _n_qual_sum; }; /** * @brief Data quality summary record length, bytes */ int get_l_qual_sum() const { return _l_qual_sum; }; /** * @brief Number of data histogram records */ int get_n_data_his() const { return _n_data_his; }; /** * @brief Data histogram record length, bytes */ int get_l_data_his() const { return _l_data_his; }; /** * @brief Number of range spectra records */ int get_n_rang_spec() const { return _n_rang_spec ; }; /** * @brief Range spectra record length, bytes */ int get_l_rang_spec() const { return _l_rang_spec; }; /** * @brief Number of DEM descriptor records */ int get_n_dem_desc() const { return _n_dem_desc; }; /** * @brief DEM desc record length, bytes */ int get_l_dem_desc() const { return _l_dem_desc; }; /** * @brief Number of RADAR par records */ int get_n_radar_par() const { return _n_radar_par; }; /** * @brief RADAR par record length, bytes */ int get_l_radar_par() const { return _l_radar_par; }; /** * @brief Number of annotation data records */ int get_n_anno_data() const { return _n_anno_data; }; /** * @brief Annotation data record length, bytes */ int get_l_anno_data() const { return _l_anno_data; }; /** * @brief Number of processing parameter records */ int get_n_det_proc() const { return _n_det_proc; }; /** * @brief Processing parameter record length, bytes */ int get_l_det_proc() const { return _l_det_proc; }; /** * @brief Number of calibration records */ int get_n_cal() const { return _n_cal; }; /** * @brief Calibration record length, bytes */ int get_l_cal() const { return _l_cal; }; /** * @brief Number of GCP records */ int get_n_gcp() const { return _n_gcp; }; /** * @brief GCP record length, bytes */ int get_l_gcp() const { return _l_gcp; }; /** * @brief Number of facility data records */ int get_n_fac_data() const { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data() const { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data2() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data2() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data3() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data3() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data4() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data4() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data5() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data5() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data6() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data6() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data7() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data7() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data8() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data8() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data9() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data9() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data10() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data10() { return _l_fac_data; }; /** * @brief Number of facility data records */ int get_n_fac_data11() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data11() { return _l_fac_data; }; protected: /** * @brief ASCII flag */ std::string _ascii_flag; /** * @brief Continuation flag */ std::string _continuation_flag; /** * @brief Format control documentation */ std::string _format_doc; /** * @brief Format doc version */ std::string _format_ver; /** * @brief Format doc revision */ std::string _design_rev; /** * @brief Software identifier */ std::string _software_id; /** * @brief File number */ int _file_num; /** * @brief File name */ std::string _file_name; /** * @brief Record sequence/location flag */ std::string _rec_seq; /** * @brief Sequence number location */ int _seq_loc; /** * @brief Sequence number length */ int _seq_len; /** * @brief Record code/location flag */ std::string _rec_code; /** * @brief Record code location */ int _code_loc; /** * @brief Record code length */ int _code_len; /** * @brief Record length/location flag */ std::string _rec_len; /** * @brief Record length location */ int _rlen_loc; /** * @brief Record length, bytes */ int _rlen_len; /** * @brief Number of dataset summ records */ int _n_dataset; /** * @brief Data set summary record length, bytes */ int _l_dataset; /** * @brief Number of map proj records */ int _n_map_proj; /** * @brief Map projection record length, bytes */ int _l_map_proj; /** * @brief Number of platform position records */ int _n_plat_pos; /** * @brief Platform position record length, bytes */ int _l_plat_pos; /** * @brief Number of attitude data records */ int _n_att_data; /** * @brief Attitude data record length, bytes */ int _l_att_data; /** * @brief Number of radiometric data records */ int _n_radi_data; /** * @brief Radiometric data record length, bytes */ int _l_radi_data; /** * @brief Number of radiometric compensation records */ int _n_radi_comp; /** * @brief Radiometric compensation record length, bytes */ int _l_radi_comp; /** * @brief Number of data quality summary records */ int _n_qual_sum; /** * @brief Data quality summary record length, bytes */ int _l_qual_sum; /** * @brief Number of data histogram records */ int _n_data_his; /** * @brief Data histogram record length, bytes */ int _l_data_his; /** * @brief Number of range spectra records */ int _n_rang_spec; /** * @brief Range spectra record length, bytes */ int _l_rang_spec; /** * @brief Number of DEM descriptor records */ int _n_dem_desc; /** * @brief DEM desc record length, bytes */ int _l_dem_desc; /** * @brief Number of RADAR par records */ int _n_radar_par; /** * @brief RADAR par record length, bytes */ int _l_radar_par; /** * @brief Number of annotation data records */ int _n_anno_data; /** * @brief Annotation data record length, bytes */ int _l_anno_data; /** * @brief Number of processing parameter records */ int _n_det_proc; /** * @brief Processing parameter record length, bytes */ int _l_det_proc; /** * @brief Number of calibration records */ int _n_cal; /** * @brief Calibration record length, bytes */ int _l_cal; /** * @brief Number of GCP records */ int _n_gcp; /** * @brief GCP record length, bytes */ int _l_gcp; /** * @brief Number of facility data records */ int _n_fac_data; /** * @brief Fac data record length, bytes */ int _l_fac_data; /** * @brief Number of facility data records */ int _n_fac_data2; /** * @brief Fac data record length, bytes */ int _l_fac_data2; /** * @brief Number of facility data records */ int _n_fac_data3; /** * @brief Fac data record length, bytes */ int _l_fac_data3; /** * @brief Number of facility data records */ int _n_fac_data4; /** * @brief Fac data record length, bytes */ int _l_fac_data4; /** * @brief Number of facility data records */ int _n_fac_data5; /** * @brief Fac data record length, bytes */ int _l_fac_data5; /** * @brief Number of facility data records */ int _n_fac_data6; /** * @brief Fac data record length, bytes */ int _l_fac_data6; /** * @brief Number of facility data records */ int _n_fac_data7; /** * @brief Fac data record length, bytes */ int _l_fac_data7; /** * @brief Number of facility data records */ int _n_fac_data8; /** * @brief Fac data record length, bytes */ int _l_fac_data8; /** * @brief Number of facility data records */ int _n_fac_data9; /** * @brief Fac data record length, bytes */ int _l_fac_data9; /** * @brief Number of facility data records */ int _n_fac_data10; /** * @brief Fac data record length, bytes */ int _l_fac_data10; /** * @brief Number of facility data records */ int _n_fac_data11; /** * @brief Fac data record length, bytes */ int _l_fac_data11; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarLeader.cpp000066400000000000000000000270341301006202600314260ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include // Static trace for debugging static ossimTrace traceDebug("ossimAlosPalsarLeader:debug"); namespace ossimplugins { const int AlosPalsarLeader::AlosPalsarFacilityDataID = 17; const int AlosPalsarLeader::AlosPalsarRadiometricDataID = 5; const int AlosPalsarLeader::AlosPalsarPlatformPositionDataID = 3; // const int AlosPalsarLeader::AlosPalsarMapProjectionDataID = 3; // const int AlosPalsarLeader::AlosPalsarDataSetSummaryID = 2; const int AlosPalsarLeader::AlosPalsarFileDescriptorID = 1; AlosPalsarLeader::AlosPalsarLeader() { } AlosPalsarLeader::~AlosPalsarLeader() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const AlosPalsarLeader& data) { std::map::const_iterator it = data._records.begin(); while (it != data._records.end()) { (*it).second->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, AlosPalsarLeader& data) { AlosPalsarLeaderFactory factory; data.ClearRecords(); AlosPalsarRecordHeader header; bool eof = false; while (!eof) { is >> header; if (is.eof()) { eof = true; } else { AlosPalsarRecord* record = factory.Instantiate(header.get_rec_seq()); if (record != NULL) { record->Read(is); data._records[header.get_rec_seq()] = record; } else { if (header.get_length() > 12) { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length() - 12); delete [] buff; } } } } return is; } AlosPalsarLeader::AlosPalsarLeader(const AlosPalsarLeader& rhs) { std::map::const_iterator it = rhs._records.begin(); while (it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } } AlosPalsarLeader& AlosPalsarLeader::operator=(const AlosPalsarLeader& rhs) { ClearRecords(); std::map::const_iterator it = rhs._records.begin(); while (it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } return *this; } void AlosPalsarLeader::ClearRecords() { std::map::const_iterator it = _records.begin(); while (it != _records.end()) { delete(*it).second; ++it; } _records.clear(); } bool AlosPalsarLeader::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "AlosPalsarLeader::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result = true; char name[64]; //kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimAlosPalsarModel", true); /* * Adding metadata necessary to the sensor model in the keywordlist */ const AlosPalsarFileDescriptor *leaderfiledesc = get_AlosPalsarFileDescriptor(); if (leaderfiledesc != NULL) { kwl.add(prefix, "filename", leaderfiledesc->get_file_name().c_str(), true); } else { result = false; } /* * Adding metadata necessary to the sensor model in the keywordlist */ const AlosPalsarDataSetSummary *datasetSummary = get_AlosPalsarDataSetSummary(); if ((datasetSummary != NULL) && (result == true)) { kwl.add(prefix, "inp_sctim", (datasetSummary->get_inp_sctim()).c_str(), true); kwl.add(prefix, "ellip_maj", datasetSummary->get_ellip_maj(), true); kwl.add(prefix, "ellip_min", datasetSummary->get_ellip_min(), true); kwl.add(prefix, "sc_lin", datasetSummary->get_sc_lin(), true); kwl.add(prefix, "sc_pix", datasetSummary->get_sc_pix(), true); kwl.add(prefix, "wave_length", datasetSummary->get_wave_length(), true); kwl.add(prefix, "fr", datasetSummary->get_fr(), true); kwl.add(prefix, "fa", datasetSummary->get_fa(), true); kwl.add(prefix, "time_dir_pix", (datasetSummary->get_time_dir_pix()).c_str(), true); kwl.add(prefix, "time_dir_lin", (datasetSummary->get_time_dir_lin()).c_str(), true); kwl.add(prefix, "line_spacing", datasetSummary->get_line_spacing(), true); kwl.add(prefix, "pix_spacing", datasetSummary->get_pix_spacing(), true); kwl.add(prefix, "nlooks_az", datasetSummary->get_n_azilok(), true); kwl.add(prefix, "n_rnglok", datasetSummary->get_n_rnglok(), true); kwl.add(prefix, "alt_dopcen[0]", datasetSummary->get_alt_dopcen()[0], true); kwl.add(prefix, "crt_dopcen[0]", datasetSummary->get_crt_dopcen()[0], true); kwl.add(prefix, "crt_dopcen[1]", datasetSummary->get_crt_dopcen()[1], true); kwl.add(prefix, "dopcen_range[0]", datasetSummary->get_dopcen_range()[0], true); kwl.add(prefix, "dopcen_range[1]", datasetSummary->get_dopcen_range()[1], true); //FIXME check if those data are available // kwl.add(prefix, "zero_dop_range_time_f_pixel", datasetSummary->get_zero_dop_range_time_f_pixel(),true); // kwl.add(prefix, "zero_dop_range_time_c_pixel", datasetSummary->get_zero_dop_range_time_c_pixel(),true); // kwl.add(prefix, "zero_dop_range_time_l_pixel", datasetSummary->get_zero_dop_range_time_l_pixel(),true); } else { result = false; } // FIXME do not handle Alos map projection information for now... // const AlosPalsarMapProjectionData *mapprojectiondata = get_AlosPalsarMapProjectionData(); // if ( (mapprojectiondata != NULL) && (result == true) ) // { // kwl.add(prefix, "map_proj_des",(mapprojectiondata->get_map_proj_des()).c_str(),true); // kwl.add(prefix, "num_lines",(double) mapprojectiondata->get_num_lines(),true); // kwl.add(prefix, "num_pix",(double) mapprojectiondata->get_num_pix_in_line(),true); // kwl.add(prefix, "first_line_first_pixel_lat",mapprojectiondata->get_first_line_first_pixel_lat(), true); // kwl.add(prefix, "first_line_first_pixel_lon",mapprojectiondata->get_first_line_first_pixel_lon(), true); // kwl.add(prefix, "first_line_last_pixel_lat",mapprojectiondata->get_first_line_last_pixel_lat(), true); // kwl.add(prefix, "first_line_last_pixel_lon",mapprojectiondata->get_first_line_last_pixel_lon(), true); // kwl.add(prefix, "last_line_first_pixel_lat",mapprojectiondata->get_last_line_first_pixel_lat(), true); // kwl.add(prefix, "last_line_first_pixel_lon",mapprojectiondata->get_last_line_first_pixel_lon(), true); // kwl.add(prefix, "last_line_last_pixel_lat",mapprojectiondata->get_last_line_last_pixel_lat(), true); // kwl.add(prefix, "last_line_last_pixel_lon",mapprojectiondata->get_last_line_last_pixel_lon(), true); // } // else // { // result = false; // } const AlosPalsarPlatformPositionData *platformposition = get_AlosPalsarPlatformPositionData(); if ((platformposition != NULL) && (result == true)) { kwl.add(prefix, "neph", platformposition->get_ndata(), true); kwl.add(prefix, "eph_year", platformposition->get_year(), true); kwl.add(prefix, "eph_month", platformposition->get_month(), true); kwl.add(prefix, "eph_day", platformposition->get_day(), true); kwl.add(prefix, "eph_gmt_day", platformposition->get_gmt_day(), true); kwl.add(prefix, "eph_sec", platformposition->get_gmt_sec(), true); kwl.add(prefix, "eph_hr_angle", platformposition->get_hr_angle(), true); kwl.add(prefix, "eph_int", platformposition->get_data_int(), true); for (int i = 0; i < platformposition->get_ndata(); i++) { sprintf(name, "eph%i_posX", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_pos()[0], true); sprintf(name, "eph%i_posY", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_pos()[1], true); sprintf(name, "eph%i_posZ", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_pos()[2], true); sprintf(name, "eph%i_velX", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_vel()[0], true); sprintf(name, "eph%i_velY", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_vel()[1], true); sprintf(name, "eph%i_velZ", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_vel()[2], true); } } else { result = false; } const AlosPalsarRadiometricData *radiometricdata = get_AlosPalsarRadiometricData(); if ((radiometricdata != NULL) && (result == true)) { kwl.add(prefix, "calibration_factor", radiometricdata->get_calibration_factor(), true); } else { result = false; } // FIXME Do not handle Palsar facility-related data for now... // The current code corresponds to the ERS facility-related data // which is completely different from that for PALSAR /* const AlosPalsarFacilityData *facilitydata = get_AlosPalsarFacilityData(); if ((facilitydata != NULL) && (result == true)) { kwl.add(prefix, "coef_ground_range_1", facilitydata->get_coef_ground_range_1(), true); kwl.add(prefix, "coef_ground_range_2", facilitydata->get_coef_ground_range_2(), true); kwl.add(prefix, "coef_ground_range_3", facilitydata->get_coef_ground_range_3(), true); kwl.add(prefix, "coef_ground_range_4", facilitydata->get_coef_ground_range_4(), true); } else { result = false; } */ if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } return result; } const AlosPalsarFacilityData * AlosPalsarLeader::get_AlosPalsarFacilityData() const { // return const_cast(dynamic_cast(_records[AlosPalsarFacilityDataID])); // RecordType::const_iterator it = _records.find(AlosPalsarFacilityDataID)->second; // return dynamic_cast(it.find(AlosPalsarFacilityDataID)); return dynamic_cast(_records.find(AlosPalsarFacilityDataID)->second); } const AlosPalsarRadiometricData * AlosPalsarLeader::get_AlosPalsarRadiometricData() const { return dynamic_cast(_records.find(AlosPalsarRadiometricDataID)->second); } const AlosPalsarPlatformPositionData * AlosPalsarLeader::get_AlosPalsarPlatformPositionData() const { return dynamic_cast(_records.find(AlosPalsarPlatformPositionDataID)->second); } /* const AlosPalsarMapProjectionData * AlosPalsarLeader::get_AlosPalsarMapProjectionData() const { // return (AlosPalsarMapProjectionData*)_records[AlosPalsarMapProjectionDataID]; return dynamic_cast(_records.find(AlosPalsarMapProjectionDataID)->second); } */ // no map projection data for level 1.1 const AlosPalsarDataSetSummary * AlosPalsarLeader::get_AlosPalsarDataSetSummary() const { return dynamic_cast(_records.find(AlosPalsarDataSetSummaryID)->second); } const AlosPalsarFileDescriptor * AlosPalsarLeader::get_AlosPalsarFileDescriptor() const { return dynamic_cast(_records.find(AlosPalsarFileDescriptorID)->second); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarLeader.h000066400000000000000000000060261301006202600310710ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarLeader_h #define AlosPalsarLeader_h #include #include "AlosPalsar/AlosPalsarFileDescriptor.h" #include "AlosPalsar/AlosPalsarDataSetSummary.h" #include "AlosPalsar/AlosPalsarMapProjectionData.h" #include "AlosPalsar/AlosPalsarPlatformPositionData.h" #include "AlosPalsar/AlosPalsarRadiometricData.h" #include "AlosPalsar/AlosPalsarFacilityData.h" #include class ossimKeywordlist; namespace ossimplugins { class AlosPalsarPlatformPositionData; class AlosPalsarMapProjectionData; class AlosPalsarDataSetSummary; class AlosPalsarFileDescriptor; class AlosPalsarFacilityData; class AlosPalsarRadiometricData; /** * @ingroup AlosPalsarLeaderFile * @brief This class is able to read the Leader file of the AlosPalsar file structure */ class AlosPalsarLeader { public: /** * @brief Constructor */ AlosPalsarLeader(); /** * @brief Destructor */ virtual ~AlosPalsarLeader(); /** * @brief This function write the AlosPalsarLeader in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarLeader& data); /** * @brief This function read a AlosPalsarLeader from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarLeader& data); /** * @brief Copy constructor */ AlosPalsarLeader(const AlosPalsarLeader& rhs); /** * @brief Copy operator */ AlosPalsarLeader& operator=(const AlosPalsarLeader& rhs); /** * @brief Remove all the previous records from the AlosPalsarLeader */ void ClearRecords(); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0) const; const AlosPalsarFacilityData * get_AlosPalsarFacilityData() const; const AlosPalsarRadiometricData * get_AlosPalsarRadiometricData() const; const AlosPalsarPlatformPositionData * get_AlosPalsarPlatformPositionData() const; // const AlosPalsarMapProjectionData * get_AlosPalsarMapProjectionData() const; const AlosPalsarDataSetSummary * get_AlosPalsarDataSetSummary() const; const AlosPalsarFileDescriptor * get_AlosPalsarFileDescriptor() const; protected: typedef std::map RecordType; RecordType _records; static const int AlosPalsarFacilityDataID; static const int AlosPalsarRadiometricDataID; static const int AlosPalsarPlatformPositionDataID; // static const int AlosPalsarMapProjectionDataID; static const int AlosPalsarDataSetSummaryID; static const int AlosPalsarFileDescriptorID; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarLeaderFactory.cpp000066400000000000000000000022021301006202600327440ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include namespace ossimplugins { AlosPalsarLeaderFactory::AlosPalsarLeaderFactory() { RegisterRecord(17, new AlosPalsarFacilityData()); RegisterRecord(5, new AlosPalsarRadiometricData()); RegisterRecord(3, new AlosPalsarPlatformPositionData()); // RegisterRecord(3, new AlosPalsarMapProjectionData());// RegisterRecord(2, new AlosPalsarDataSetSummary()); RegisterRecord(1, new AlosPalsarFileDescriptor()); } AlosPalsarLeaderFactory::~AlosPalsarLeaderFactory() { } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarLeaderFactory.h000066400000000000000000000015751301006202600324250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarLeaderFactory_h #define AlosPalsarLeaderFactory_h #include #include namespace ossimplugins { /** * @ingroup AlosPalsarLeaderFile * @brief This class is a facory able to construct Record base classes */ class AlosPalsarLeaderFactory : public AlosPalsarRecordFactory { public: /** * @brief Contstructor */ AlosPalsarLeaderFactory(); /** * @brief Destructor */ ~AlosPalsarLeaderFactory(); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarMapProjectionData.cpp000066400000000000000000000152201301006202600335700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarMapProjectionData::AlosPalsarMapProjectionData() : AlosPalsarRecord("map_proj_data_rec") { } AlosPalsarMapProjectionData::~AlosPalsarMapProjectionData() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarMapProjectionData& data) { os << "map_proj_des:" << data._map_proj_des.c_str() << std::endl; os << "num_pix_in_line:" << data._num_pix_in_line << std::endl; os << "num_lines:" << data._num_lines << std::endl; os << "nom_interpixel_dist:" << data._nom_interpixel_dist << std::endl; os << "nom_interline_dist:" << data._nom_interline_dist << std::endl; os << "orientation_at_center:" << data._orientation_at_center << std::endl; os << "orbit_incl:" << data._orbit_incl << std::endl; os << "asc_node_long:" << data._asc_node_long << std::endl; os << "platform_heading:" << data._platform_heading << std::endl; os << "name_of_ref_ellipsoid:" << data._name_of_ref_ellipsoid.c_str() << std::endl; os << "semi_maj_axis:" << data._semi_maj_axis << std::endl; os << "semi_min_axis:" << data._semi_min_axis << std::endl; os << "first_line_first_pixel_lat:" << data._first_line_first_pixel_lat << std::endl; os << "first_line_first_pixel_lon:" << data._first_line_first_pixel_lon << std::endl; os << "first_line_last_pixel_lat:" << data._first_line_last_pixel_lat << std::endl; os << "first_line_last_pixel_lon:" << data._first_line_last_pixel_lon << std::endl; os << "last_line_last_pixel_lat:" << data._last_line_last_pixel_lat << std::endl; os << "last_line_last_pixel_lon:" << data._last_line_last_pixel_lon << std::endl; os << "last_line_first_pixel_lat:" << data._last_line_first_pixel_lat << std::endl; os << "last_line_first_pixel_lon:" << data._last_line_first_pixel_lon << std::endl; return os; } std::istream& operator>>(std::istream& is, AlosPalsarMapProjectionData& data) { char buf16[17]; buf16[16] = '\0'; char buf32[33]; buf32[32] = '\0'; // char buf8[9]; // buf8[8] = '\0'; // char buf4[5]; // buf4[4] = '\0'; is.read(buf16, 16); is.read(buf32, 32); data._map_proj_des = buf32; is.read(buf16, 16); data._num_pix_in_line = atoi(buf16); is.read(buf16, 16); data._num_lines = atoi(buf16); is.read(buf16, 16); data._nom_interpixel_dist = atof(buf16); is.read(buf16, 16); data._nom_interline_dist = atof(buf16); is.read(buf16, 16); data._orientation_at_center = atof(buf16); is.read(buf16, 16); data._orbit_incl = atof(buf16); is.read(buf16, 16); data._asc_node_long = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); is.read(buf16, 16); is.read(buf16, 16); data._platform_heading = atof(buf16); is.read(buf32, 32); data._name_of_ref_ellipsoid = buf32; is.read(buf16, 16); data._semi_maj_axis = atof(buf16); is.read(buf16, 16); data._semi_min_axis = atof(buf16); char buf772[772]; is.read(buf772, 772); is.read(buf16, 16); data._first_line_first_pixel_lat = atof(buf16); is.read(buf16, 16); data._first_line_first_pixel_lon = atof(buf16); is.read(buf16, 16); data._first_line_last_pixel_lat = atof(buf16); is.read(buf16, 16); data._first_line_last_pixel_lon = atof(buf16); is.read(buf16, 16); data._last_line_last_pixel_lat = atof(buf16); is.read(buf16, 16); data._last_line_last_pixel_lon = atof(buf16); is.read(buf16, 16); data._last_line_first_pixel_lat = atof(buf16); is.read(buf16, 16); data._last_line_first_pixel_lon = atof(buf16); char buf420[420]; is.read(buf420, 420); return is; } AlosPalsarMapProjectionData::AlosPalsarMapProjectionData(const AlosPalsarMapProjectionData& rhs): AlosPalsarRecord(rhs), _map_proj_des(rhs._map_proj_des), _num_pix_in_line(rhs._num_pix_in_line), _num_lines(rhs._num_lines), _nom_interpixel_dist(rhs._nom_interpixel_dist), _nom_interline_dist(rhs._nom_interline_dist), _orientation_at_center(rhs._orientation_at_center), _orbit_incl(rhs._orbit_incl), _asc_node_long(rhs._asc_node_long), _platform_heading(rhs._platform_heading), _name_of_ref_ellipsoid(rhs._name_of_ref_ellipsoid), _semi_maj_axis(rhs._semi_maj_axis), _semi_min_axis(rhs._semi_min_axis), _first_line_first_pixel_lat(rhs._first_line_first_pixel_lat), _first_line_first_pixel_lon(rhs._first_line_first_pixel_lon), _first_line_last_pixel_lat(rhs._first_line_last_pixel_lat), _first_line_last_pixel_lon(rhs._first_line_last_pixel_lon), _last_line_last_pixel_lat(rhs._last_line_last_pixel_lat), _last_line_last_pixel_lon(rhs._last_line_last_pixel_lon), _last_line_first_pixel_lat(rhs._last_line_first_pixel_lat), _last_line_first_pixel_lon(rhs._last_line_first_pixel_lon) {} AlosPalsarMapProjectionData& AlosPalsarMapProjectionData::operator=(const AlosPalsarMapProjectionData& rhs) { _map_proj_des = rhs._map_proj_des; _num_pix_in_line = rhs._num_pix_in_line; _num_lines = rhs._num_lines; _nom_interpixel_dist = rhs._nom_interpixel_dist; _nom_interline_dist = rhs._nom_interline_dist; _orientation_at_center = rhs._orientation_at_center; _orbit_incl = rhs._orbit_incl; _asc_node_long = rhs._asc_node_long; _platform_heading = rhs._platform_heading; _name_of_ref_ellipsoid = rhs._name_of_ref_ellipsoid; _semi_maj_axis = rhs._semi_maj_axis; _semi_min_axis = rhs._semi_min_axis; _first_line_first_pixel_lat = rhs._first_line_first_pixel_lat; _first_line_first_pixel_lon = rhs._first_line_first_pixel_lon; _first_line_last_pixel_lat = rhs._first_line_last_pixel_lat; _first_line_last_pixel_lon = rhs._first_line_last_pixel_lon; _last_line_last_pixel_lat = rhs._last_line_last_pixel_lat; _last_line_last_pixel_lon = rhs._last_line_last_pixel_lon; _last_line_first_pixel_lat = rhs._last_line_first_pixel_lat; _last_line_first_pixel_lon = rhs._last_line_first_pixel_lon; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarMapProjectionData.h000066400000000000000000000142121301006202600332350ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarMapProjectionData_h #define AlosPalsarMapProjectionData_h #include #include #include #include namespace ossimplugins { /** * @ingroup AlosPalsarMapProjectionDataRecord * @brief This class is able to read the SAR leader data set summary record of the leader file */ class AlosPalsarMapProjectionData : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarMapProjectionData(); /** * @brief Destructor */ virtual ~AlosPalsarMapProjectionData(); /** * @brief This function write the AlosPalsarMapProjectionData in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarMapProjectionData& data); /** * @brief This function read a AlosPalsarMapProjectionData from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarMapProjectionData& data); /** * @brief Copy constructor */ AlosPalsarMapProjectionData(const AlosPalsarMapProjectionData& rhs); /** * @brief Copy operator */ AlosPalsarMapProjectionData& operator=(const AlosPalsarMapProjectionData& rhs); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarMapProjectionData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarMapProjectionData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief map_proj_des */ std::string get_map_proj_des() const { return _map_proj_des; }; /** * @brief num_pix_in_line */ int get_num_pix_in_line() const { return _num_pix_in_line; }; /** * @brief num_lines */ int get_num_lines() const { return _num_lines; }; /** * @brief nom_interpixel_dist */ double get_nom_interpixel_dist() const { return _nom_interpixel_dist; }; /** * @brief nom_interline_dist */ double get_nom_interline_dist() const { return _nom_interline_dist; }; /** * @brief orientation_at_center */ double get_orientation_at_center() const { return _orientation_at_center; }; /** * @brief orbit_incl */ double get_orbit_incl() const { return _orbit_incl; }; /** * @brief asc_node_long */ double get_asc_node_long() const { return _asc_node_long; }; /** * @brief platform_heading */ double get_platform_heading() const { return _platform_heading; }; /** * @brief name_of_ref_ellipsoid */ std::string get_name_of_ref_ellipsoid() const { return _name_of_ref_ellipsoid; }; /** * @brief semi_maj_axis */ double get_semi_maj_axis() const { return _semi_maj_axis; }; /** * @brief semi_min_axis */ double get_semi_min_axis() const { return _semi_min_axis; }; /** * @brief first_line_first_pixel _lat */ double get_first_line_first_pixel_lat() const { return _first_line_first_pixel_lat; }; /** * @brief first_line_first_pixel_lon */ double get_first_line_first_pixel_lon() const { return _first_line_first_pixel_lon; }; /** * @brief first_line_last_pixel _lat */ double get_first_line_last_pixel_lat() const { return _first_line_last_pixel_lat; }; /** * @brief first_line_last_pixel_lon */ double get_first_line_last_pixel_lon() const { return _first_line_last_pixel_lon; }; /** * @brief last_line_last_pixel_lat */ double get_last_line_last_pixel_lat() const { return _last_line_last_pixel_lat; }; /** * @brief last_line_last_pixel_lon */ double get_last_line_last_pixel_lon() const { return _last_line_last_pixel_lon; }; /** * @brief last_line_first_pixel_lat */ double get_last_line_first_pixel_lat() const { return _last_line_first_pixel_lat; }; /** * @brief last_line_first_pixel_lon */ double get_last_line_first_pixel_lon() const { return _last_line_first_pixel_lon; }; protected: /** * @brief map_proj_des */ std::string _map_proj_des; /** * @brief num_pix_in_line */ int _num_pix_in_line; /** * @brief num_lines */ int _num_lines; /** * @brief nom_interpixel_dist */ double _nom_interpixel_dist; /** * @brief nom_interline_dist */ double _nom_interline_dist; /** * @brief orientation_at_center */ double _orientation_at_center; /** * @brief orbit_incl */ double _orbit_incl; /** * @brief asc_node_long */ double _asc_node_long; /** * @brief platform_heading */ double _platform_heading; /** * @brief name_of_ref_ellipsoid */ std::string _name_of_ref_ellipsoid; /** * @brief semi_maj_axis */ double _semi_maj_axis; /** * @brief semi_min_axis */ double _semi_min_axis; /** * @brief first_line_first_pixel_lat */ double _first_line_first_pixel_lat; /** * @brief first_line_first_pixel_lon */ double _first_line_first_pixel_lon; /** * @brief first_line_last_pixel_lat */ double _first_line_last_pixel_lat; /** * @brief first_line_last_pixel_lon */ double _first_line_last_pixel_lon; /** * @brief last_line_last_pixel_lat */ double _last_line_last_pixel_lat; /** * @brief last_line_last_pixel_lon */ double _last_line_last_pixel_lon; /** * @brief last_line_first_pixel_lat */ double _last_line_first_pixel_lat; /** * @brief last_line_first_pixel_lon */ double _last_line_first_pixel_lon; private: }; } #endif AlosPalsarPlatformPositionData.cpp000066400000000000000000000117001301006202600342470ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarPlatformPositionData::AlosPalsarPlatformPositionData() : AlosPalsarRecord("pos_data_rec") { } AlosPalsarPlatformPositionData::~AlosPalsarPlatformPositionData() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarPlatformPositionData& data) { os << "orbit_ele_desg:" << data._orbit_ele_desg.c_str() << std::endl; for (int i = 0; i < 6; i++) { os << "orbit_ele[" << i << "]:" << data._orbit_ele[i] << std::endl; } os << "ndata:" << data._ndata << std::endl; os << "year:" << data._year << std::endl; os << "month:" << data._month << std::endl; os << "day:" << data._day << std::endl; os << "gmt_day:" << data._gmt_day << std::endl; os << "gmt_sec:" << data._gmt_sec << std::endl; os << "data_int:" << data._data_int << std::endl; os << "ref_coord:" << data._ref_coord.c_str() << std::endl; os << "hr_angle:" << data._hr_angle << std::endl; os << "alt_poserr:" << data._alt_poserr << std::endl; os << "crt_poserr:" << data._crt_poserr << std::endl; os << "rad_poserr:" << data._rad_poserr << std::endl; os << "alt_velerr:" << data._alt_velerr << std::endl; os << "crt_velerr:" << data._crt_velerr << std::endl; os << "rad_velerr:" << data._rad_velerr << std::endl; for (int i = 0; i < 64; i++) { os << "pos_vect[" << i << "]:" << data._pos_vect[i] << std::endl; } return os; } std::istream& operator>>(std::istream& is, AlosPalsarPlatformPositionData& data) { char buf[1207]; buf[1206] = '\0'; is.read(buf, 32); buf[32] = '\0'; data._orbit_ele_desg = buf; for (int i = 0; i < 6; i++) { is.read(buf, 16); buf[16] = '\0'; data._orbit_ele[i] = atof(buf); } is.read(buf, 4); buf[4] = '\0'; data._ndata = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._year = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._month = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._day = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._gmt_day = atoi(buf); is.read(buf, 22); buf[22] = '\0'; data._gmt_sec = atof(buf); is.read(buf, 22); buf[22] = '\0'; data._data_int = atof(buf); is.read(buf, 64); buf[64] = '\0'; data._ref_coord = buf; is.read(buf, 22); buf[22] = '\0'; data._hr_angle = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._alt_poserr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._crt_poserr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._rad_poserr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._alt_velerr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._crt_velerr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._rad_velerr = atof(buf); for (int i = 0; i < data._ndata; i++) { is >> data._pos_vect[i]; } is.seekg(598, std::ios::cur); //skip the rest of the platform position data record is.seekg(8192, std::ios::cur); //skip to the radiometric data record //is.seekg(12495744, std::ios::cur); //skip to the 11th facility-related data record return is; } AlosPalsarPlatformPositionData::AlosPalsarPlatformPositionData(const AlosPalsarPlatformPositionData& rhs): AlosPalsarRecord(rhs) { _orbit_ele_desg = rhs._orbit_ele_desg; for (int i = 0; i < 6; i++) { _orbit_ele[i] = rhs._orbit_ele[i]; } _ndata = rhs._ndata; _year = rhs._year; _month = rhs._month; _day = rhs._day; _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _data_int = rhs._data_int; _ref_coord = rhs._ref_coord; _hr_angle = rhs._hr_angle; _alt_poserr = rhs._alt_poserr; _crt_poserr = rhs._crt_poserr; _rad_poserr = rhs._rad_poserr; _alt_velerr = rhs._alt_velerr; _crt_velerr = rhs._crt_velerr; _rad_velerr = rhs._rad_velerr; for (int i = 0; i < 64; i++) { _pos_vect[i] = rhs._pos_vect[i]; } } AlosPalsarPlatformPositionData& AlosPalsarPlatformPositionData::operator=(const AlosPalsarPlatformPositionData& rhs) { _orbit_ele_desg = rhs._orbit_ele_desg; for (int i = 0; i < 6; i++) { _orbit_ele[i] = rhs._orbit_ele[i]; } _ndata = rhs._ndata; _year = rhs._year; _month = rhs._month; _day = rhs._day; _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _data_int = rhs._data_int; _ref_coord = rhs._ref_coord; _hr_angle = rhs._hr_angle; _alt_poserr = rhs._alt_poserr; _crt_poserr = rhs._crt_poserr; _rad_poserr = rhs._rad_poserr; _alt_velerr = rhs._alt_velerr; _crt_velerr = rhs._crt_velerr; _rad_velerr = rhs._rad_velerr; for (int i = 0; i < 64; i++) { _pos_vect[i] = rhs._pos_vect[i]; } return *this; } } AlosPalsarPlatformPositionData.h000066400000000000000000000125761301006202600337300ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarPlatformPositionData_h #define AlosPalsarPlatformPositionData_h #include #include #include #include #include namespace ossimplugins { /** * @ingroup PlatformPositionDataRecord * @brief This class is able to read a Platform position data record */ class AlosPalsarPlatformPositionData : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarPlatformPositionData(); /** * @brief Destructor */ virtual ~AlosPalsarPlatformPositionData(); /** * @brief Copy constructor */ AlosPalsarPlatformPositionData(const AlosPalsarPlatformPositionData& rhs); /** * @brief Copy operator */ AlosPalsarPlatformPositionData& operator=(const AlosPalsarPlatformPositionData& rhs); /** * @brief This function write the AlosPalsar PlatformPositionData in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarPlatformPositionData& data); /** * @brief This function read a AlosPalsar PlatformPositionData from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarPlatformPositionData& data); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarPlatformPositionData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarPlatformPositionData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief Orbital elements designator */ std::string get_orbit_ele_desg() const { return _orbit_ele_desg; }; /** * @brief Orbital elements */ const double* get_orbit_ele() const { return _orbit_ele; }; /** * @brief Number of data points */ int get_ndata() const { return _ndata; }; /** * @brief Year of data point */ int get_year() const { return _year; }; /** * @brief Month of data point */ int get_month() const { return _month; }; /** * @brief Day of data point */ int get_day() const { return _day; }; /** * @brief Day of year */ int get_gmt_day() const { return _gmt_day; }; /** * @brief Seconds of day */ double get_gmt_sec() const { return _gmt_sec; }; /** * @brief Data sampling interval */ double get_data_int() const { return _data_int; }; /** * @brief Reference coordinate system */ std::string get_ref_coord() const { return _ref_coord; }; /** * @brief Greenwich mean hour angle */ double get_hr_angle() const { return _hr_angle; }; /** * @brief Along track position error */ double get_alt_poserr() const { return _alt_poserr; }; /** * @brief Cross track position error */ double get_crt_poserr() const { return _crt_poserr; }; /** * @brief Radial position error */ double get_rad_poserr() const { return _rad_poserr; }; /** * @brief Along track velocity error */ double get_alt_velerr() const { return _alt_velerr; }; /** * @brief Cross track velocity error */ double get_crt_velerr() const { return _crt_velerr; }; /** * @brief Radial velocity error */ double get_rad_velerr() const { return _rad_velerr; }; /** * @brief Data point position/velocity */ const AlosPalsarPositionVectorRecord* get_pos_vect() const { return _pos_vect; }; protected: /** * @brief Orbital elements designator */ std::string _orbit_ele_desg; /** * @brief Orbital elements */ double _orbit_ele[6]; /** * @brief Number of data points */ int _ndata; /** * @brief Year of data point */ int _year; /** * @brief Month of data point */ int _month; /** * @brief Day of data point */ int _day; /** * @brief Day of year */ int _gmt_day; /** * @brief Seconds of day */ double _gmt_sec; /** * @brief Data sampling interval */ double _data_int; /** * @brief Reference coordinate system */ std::string _ref_coord; /** * @brief Greenwich mean hour angle */ double _hr_angle; /** * @brief Along track position error */ double _alt_poserr; /** * @brief Cross track position error */ double _crt_poserr; /** * @brief Radial position error */ double _rad_poserr; /** * @brief Along track velocity error */ double _alt_velerr; /** * @brief Cross track velocity error */ double _crt_velerr; /** * @brief Radial velocity error */ double _rad_velerr; /** * @brief Data point position/velocity */ AlosPalsarPositionVectorRecord _pos_vect[64]; private: }; } #endif AlosPalsarPositionVectorRecord.cpp000066400000000000000000000033071301006202600342760ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarPositionVectorRecord::AlosPalsarPositionVectorRecord() { } AlosPalsarPositionVectorRecord::~AlosPalsarPositionVectorRecord() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarPositionVectorRecord& data) { for (int i = 0; i < 3; i++) { os << "pos[" << i << "]:" << data._pos[i] << std::endl; } for (int i = 0; i < 3; i++) { os << "vel[" << i << "]:" << data._vel[i] << std::endl; } return os; } std::istream& operator>>(std::istream& is, AlosPalsarPositionVectorRecord& data) { char buf[23]; buf[22] = '\0'; for (int i = 0; i < 3; i++) { is.read(buf, 22); data._pos[i] = atof(buf); } for (int i = 0; i < 3; i++) { is.read(buf, 22); data._vel[i] = atof(buf); } return is; } AlosPalsarPositionVectorRecord::AlosPalsarPositionVectorRecord(const AlosPalsarPositionVectorRecord& rhs) { for (int i = 0; i < 3; i++) { _pos[i] = rhs._pos[i]; } for (int i = 0; i < 3; i++) { _vel[i] = rhs._vel[i]; } } AlosPalsarPositionVectorRecord& AlosPalsarPositionVectorRecord::operator=(const AlosPalsarPositionVectorRecord& rhs) { for (int i = 0; i < 3; i++) { _pos[i] = rhs._pos[i]; } for (int i = 0; i < 3; i++) { _vel[i] = rhs._vel[i]; } return *this; } } AlosPalsarPositionVectorRecord.h000066400000000000000000000035251301006202600337450ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarPositionVectorRecord_h #define AlosPalsarPositionVectorRecord_h #include #include #include namespace ossimplugins { /** * @ingroup PlatformPositionDataRecord * @brief This class is able to read a position vector record */ class AlosPalsarPositionVectorRecord { public: /** * @brief Constructor */ AlosPalsarPositionVectorRecord(); /** * @brief Destructor */ ~AlosPalsarPositionVectorRecord(); /** * @brief Copy constructor */ AlosPalsarPositionVectorRecord(const AlosPalsarPositionVectorRecord& rhs); /** * @brief Copy operator */ AlosPalsarPositionVectorRecord& operator=(const AlosPalsarPositionVectorRecord& rhs); /** * @brief This function write the AlosPalsar PositionVectorRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarPositionVectorRecord& data); /** * @brief This function read a AlosPalsar PositionVectorRecord from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarPositionVectorRecord& data); /** * @brief Data point position (m) */ const double* get_pos() const { return _pos; }; /** * @brief Data point velocity (mm/s) */ const double* get_vel() const { return _vel; }; protected: /** * @brief Data point position (m) */ double _pos[3]; /** * @brief Data point velocity (mm/s) */ double _vel[3]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRadiometricData.cpp000066400000000000000000000027641301006202600332710ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarRadiometricData::AlosPalsarRadiometricData() : AlosPalsarRecord("radio_data_rec") { } AlosPalsarRadiometricData::~AlosPalsarRadiometricData() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarRadiometricData& data) { os << "calibration_factor:" << data._calibration_factor << std::endl; return os; } std::istream& operator>>(std::istream& is, AlosPalsarRadiometricData& data) { char buf[9]; is.seekg(8, std::ios::cur); is.read(buf, 8); buf[8] = '\0'; data._calibration_factor = atof(buf); is.seekg(9824, std::ios::cur); //skip the rest of the radiometric data record is.seekg(12477692, std::ios::cur); //skip to the 11th facility-related data record return is; } AlosPalsarRadiometricData::AlosPalsarRadiometricData(const AlosPalsarRadiometricData& rhs): AlosPalsarRecord(rhs) { _calibration_factor = rhs._calibration_factor; } AlosPalsarRadiometricData& AlosPalsarRadiometricData::operator=(const AlosPalsarRadiometricData& rhs) { _calibration_factor = rhs._calibration_factor; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRadiometricData.h000066400000000000000000000044731301006202600327350ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarRadiometricData_h #define AlosPalsarRadiometricData_h #include #include #include #include namespace ossimplugins { /** * @ingroup RadiometricDataRecord * @brief This class is able to read a radiometric data record */ class AlosPalsarRadiometricData : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarRadiometricData(); /** * @brief Destructor */ virtual ~AlosPalsarRadiometricData(); /** * @brief Copy constructor */ AlosPalsarRadiometricData(const AlosPalsarRadiometricData& rhs); /** * @brief Copy operator */ AlosPalsarRadiometricData& operator=(const AlosPalsarRadiometricData& rhs); /** * @brief This function writes the Alos Palsar radiometric data in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarRadiometricData& data); /** * @brief This function reads Alos Palsar radiometric data from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarRadiometricData& data); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarRadiometricData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarRadiometricData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief Calibration factor */ double get_calibration_factor() const { return _calibration_factor; }; protected: /** * @brief Data sampling interval */ double _calibration_factor; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRecord.cpp000066400000000000000000000012741301006202600314460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include namespace ossimplugins { AlosPalsarRecord::AlosPalsarRecord(std::string mnemonic): _mnemonic(mnemonic) { } AlosPalsarRecord::~AlosPalsarRecord() { } AlosPalsarRecord::AlosPalsarRecord(const AlosPalsarRecord& rhs): _mnemonic(rhs._mnemonic) { } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRecord.h000066400000000000000000000030331301006202600311060ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarRecord_h #define AlosPalsarRecord_h #include #include namespace ossimplugins { /** * @ingroup AlosPalsar * @brief This class is the base class of all the record classes */ class AlosPalsarRecord { public: /** * @brief Constructor * @param mnemonic Name of the record */ AlosPalsarRecord(std::string mnemonic); /** * @brief Destructor */ virtual ~AlosPalsarRecord(); /** * @brief Copy constructor */ AlosPalsarRecord(const AlosPalsarRecord& rhs); /** * @brief This function is able to create a new instance of the class */ virtual AlosPalsarRecord* Instantiate() = 0; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ virtual AlosPalsarRecord* Clone() = 0; /** * @brief Read the class data from a stream */ virtual void Read(std::istream& is) = 0; /** * @brief Write the class to a stream */ virtual void Write(std::ostream& os) = 0; std::string get_mnemonic() { return _mnemonic; }; protected: std::string _mnemonic; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRecordFactory.cpp000066400000000000000000000022011301006202600327650ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include // Static trace for debugging static ossimTrace traceDebug("AlosPalsarRecordFactory:debug"); namespace ossimplugins { AlosPalsarRecordFactory::AlosPalsarRecordFactory() { } AlosPalsarRecordFactory::~AlosPalsarRecordFactory() { } AlosPalsarRecord* AlosPalsarRecordFactory::Instantiate(int id) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Intanciate AlosPalsar record:" << id << "\n"; } AlosPalsarRecord* record = _availableRecords[id]; if (record == NULL) { return NULL; } else { return record->Instantiate(); } } void AlosPalsarRecordFactory::RegisterRecord(int id, AlosPalsarRecord * record) { _availableRecords[id] = record; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRecordFactory.h000066400000000000000000000026151301006202600324430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarRecordFactory_h #define AlosPalsarRecordFactory_h #include #include #include namespace ossimplugins { /** * @ingroup AlosPalsar * @brief This class is a facory able to construct Record base classes given the id of the record wanted */ class AlosPalsarRecordFactory { public: /** * @brief Constructor */ AlosPalsarRecordFactory(); /** * @brief Destructor */ ~AlosPalsarRecordFactory(); /** * @brief Add a new Record type available in this factory * @param record Record to add in the factory * @param id Id of the new avalaible Record */ void RegisterRecord(int id, AlosPalsarRecord * record); /** * @brief Instantiate a new Record * @param id Id of the Record we want to instantiate */ AlosPalsarRecord* Instantiate(int id) ; protected: /** * @brief Contain all the available Records for the factory */ std::map _availableRecords; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRecordHeader.cpp000066400000000000000000000043031301006202600325530ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AlosPalsarRecordHeader::AlosPalsarRecordHeader() { } AlosPalsarRecordHeader::~AlosPalsarRecordHeader() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarRecordHeader& data) { os << "record_sequence_number:" << data._rec_seq << std::endl; os << "first_record_sub-type:" << (int)data._rec_sub1 << std::endl; os << "record_type_code:" << (int)data._rec_type << std::endl; os << "second_record_sub-type:" << (int)data._rec_sub2 << std::endl; os << "third_record_sub-type:" << (int)data._rec_sub3 << std::endl; os << "length:" << data._length << std::endl; return os; } std::istream& operator>>(std::istream& is, AlosPalsarRecordHeader& data) { is.read((char*)&(data._rec_seq), 4); // TODO Change dangerous C-style cast to static cast. data.SwitchEndian(data._rec_seq); is.read((char*)&(data._rec_sub1), 1); is.read((char*)&(data._rec_type), 1); is.read((char*)&(data._rec_sub2), 1); is.read((char*)&(data._rec_sub3), 1); is.read((char*)&(data._length), 4); data.SwitchEndian(data._length); return is; } AlosPalsarRecordHeader::AlosPalsarRecordHeader(const AlosPalsarRecordHeader& rhs): _rec_seq(rhs._rec_seq), _rec_sub1(rhs._rec_sub1), _rec_type(rhs._rec_type), _rec_sub2(rhs._rec_sub2), _rec_sub3(rhs._rec_sub3) { } AlosPalsarRecordHeader& AlosPalsarRecordHeader::operator=(const AlosPalsarRecordHeader& rhs) { _rec_seq = rhs._rec_seq; _rec_sub1 = rhs._rec_sub1; _rec_type = rhs._rec_type; _rec_sub2 = rhs._rec_sub2; _rec_sub3 = rhs._rec_sub3; return *this; } void AlosPalsarRecordHeader::SwitchEndian(unsigned int& value) { char buffer[4]; char res[4]; memcpy(buffer, &value, 4); res[0] = buffer[3]; res[1] = buffer[2]; res[2] = buffer[1]; res[3] = buffer[0]; memcpy(&value, res, 4); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarRecordHeader.h000066400000000000000000000050641301006202600322250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarRecordHeader_h #define AlosPalsarRecordHeader_h #include #include namespace ossimplugins { /** * @ingroup AlosPalsar * @brief This class is able to read a record header */ class AlosPalsarRecordHeader { public: /** * @brief Constructor */ AlosPalsarRecordHeader(); /** * @brief Destructor */ ~AlosPalsarRecordHeader(); /** * @brief Copy constructor */ AlosPalsarRecordHeader(const AlosPalsarRecordHeader& rhs); /** * @brief Copy operator */ AlosPalsarRecordHeader& operator=(const AlosPalsarRecordHeader& rhs); /** * @brief This function write the RecordHeader in a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarRecordHeader& data); /** * @brief This function read a RecordHeader from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarRecordHeader& data); /** * @brief Record sequence number */ unsigned int get_rec_seq() { return _rec_seq; }; /** * @brief First record sub-type code */ unsigned char get_rec_sub1() { return _rec_sub1; }; /** * @brief Record type code */ unsigned char get_rec_type() { return _rec_type; }; /** * @brief Second record sub-type code */ unsigned char get_rec_sub2() { return _rec_sub2; }; /** * @brief Third record sub-type code */ unsigned char get_rec_sub3() { return _rec_sub3; }; /** * @brief Length of this record (in bytes) */ unsigned int get_length() { return _length; }; protected: /** * @brief This function switch the LSB value and the MSB value of the parameter */ void SwitchEndian(unsigned int& value); /** * @brief Record sequence number */ unsigned int _rec_seq; /** * @brief First record sub-type code */ unsigned char _rec_sub1; /** * @brief Record type code */ unsigned char _rec_type; /** * @brief Second record sub-type code */ unsigned char _rec_sub2; /** * @brief Third record sub-type code */ unsigned char _rec_sub3; /** * @brief Length of this record (in bytes) */ unsigned int _length; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarSignalData.cpp000066400000000000000000000131471301006202600322410ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace ossimplugins { AlosPalsarSignalData::AlosPalsarSignalData() : AlosPalsarRecord("sar_sig_dat_rec") { } AlosPalsarSignalData::~AlosPalsarSignalData() { } std::ostream& operator<<(std::ostream& os, const AlosPalsarSignalData& data) { os << "_pulse_repetition_frequency:" << data._pulse_repetition_frequency << std::endl; os << "_slant_range_to_1st_data_sample:" << data._slant_range_to_1st_data_sample << std::endl; return os; } std::istream& operator>>(std::istream& is, AlosPalsarSignalData& data) { ossim_uint16 tmpuint16; ossim_uint32 tmpuint32; ossimEndian oe; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Data line number = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Data record index = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Actual count of left-fill pixels = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Actual count of data pixels = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Actual count of right-fill pixels = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Sensor parameters update flag = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Scene start year = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Scene start day of year = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Sensor acquisition milliseconds of day = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint16), 2); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint16); } // std::cout << "SAR channel indicator = " << tmpuint16 << std::endl; is.read(reinterpret_cast(&tmpuint16), 2); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint16); } // std::cout << "SAR channel code = " << tmpuint16 << std::endl; is.read(reinterpret_cast(&tmpuint16), 2); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint16); } // std::cout << "Transmitted polarization = " << tmpuint16 << std::endl; is.read(reinterpret_cast(&tmpuint16), 2); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint16); } // std::cout << "Received polarization = " << tmpuint16 << std::endl; is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "PRF (mHz) = " << tmpuint32 << std::endl; data._pulse_repetition_frequency = static_cast(tmpuint32); is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Scan ID for SCAN SAR mode = " << tmpuint32 << std::endl; is.read(reinterpret_cast(&tmpuint16), 2); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint16); } // std::cout << "Onboard range compressed flag = " << tmpuint16 << std::endl; is.seekg(50, std::ios_base::cur); is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Slant range to 1st data sample (m) = " << tmpuint32 << std::endl; data._slant_range_to_1st_data_sample = static_cast(tmpuint32); is.read(reinterpret_cast(&tmpuint32), 4); if (oe.getSystemEndianType() == OSSIM_LITTLE_ENDIAN) { oe.swap(tmpuint32); } // std::cout << "Data record window position = " << tmpuint32 << std::endl; // std::cout << std::endl << "File pointer location = " << is.tellg() << std::endl; // std::cout << std::endl; return is; } AlosPalsarSignalData::AlosPalsarSignalData(const AlosPalsarSignalData& rhs): AlosPalsarRecord(rhs), _pulse_repetition_frequency(rhs._pulse_repetition_frequency), _slant_range_to_1st_data_sample(rhs._slant_range_to_1st_data_sample) { } AlosPalsarSignalData& AlosPalsarSignalData::operator=(const AlosPalsarSignalData& rhs) { _pulse_repetition_frequency = rhs._pulse_repetition_frequency; _slant_range_to_1st_data_sample = rhs._slant_range_to_1st_data_sample; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/AlosPalsar/AlosPalsarSignalData.h000066400000000000000000000047021301006202600317030ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AlosPalsarSignalData_h #define AlosPalsarSignalData_h #include #include #include #include namespace ossimplugins { /** * @ingroup SARDataAlosPalsarSignalDataRecord * @brief This class is able to read the header of the Signal Data Records of the image file */ class AlosPalsarSignalData : public AlosPalsarRecord { public: /** * @brief Constructor */ AlosPalsarSignalData(); /** * @brief Destructor */ virtual ~AlosPalsarSignalData(); /** * @brief This function writes AlosPalsarSignalData to a stream */ friend std::ostream& operator<<(std::ostream& os, const AlosPalsarSignalData& data); /** * @brief This function reads to AlosPalsarSignalData from a stream */ friend std::istream& operator>>(std::istream& is, AlosPalsarSignalData& data); /** * @brief Copy constructor */ AlosPalsarSignalData(const AlosPalsarSignalData& rhs); /** * @brief Copy operator */ AlosPalsarSignalData& operator=(const AlosPalsarSignalData& rhs); /** * @brief This function is able to create a new instance of the class */ AlosPalsarRecord* Instantiate() { return new AlosPalsarSignalData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ AlosPalsarRecord* Clone() { return new AlosPalsarSignalData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; int get_pulse_repetition_frequency() const { return _pulse_repetition_frequency; }; int get_slant_range_to_1st_data_sample() const { return _slant_range_to_1st_data_sample; }; protected: /** * @brief pulse_repetition_frequency */ int _pulse_repetition_frequency; /** * @brief slant_range_to_1st_data_sample */ int _slant_range_to_1st_data_sample; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/000077500000000000000000000000001301006202600257155ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/AntennaElevationPatterns.cpp000066400000000000000000000045151301006202600334020ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { AntennaElevationPatterns::AntennaElevationPatterns() : EnvisatAsarRecord("AntennaElevationPatterns_rec") { } AntennaElevationPatterns::~AntennaElevationPatterns() { } std::ostream& operator<<(std::ostream& os, const AntennaElevationPatterns& data) { os<<"zero_doppler_time:"<>(std::istream& is, AntennaElevationPatterns& data) { char buf16[17]; buf16[16]='\0'; char buf12[13]; buf12[12] = '\0'; char buf3[4]; buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; // char buf1[1]; // avoid not used warning is.read(buf12,12); data._zero_doppler_time = buf12; is.read((char*)&(data._attach_flag),1); is.read(buf3,3); data._swath = buf3; for (int i = 0; i<33; i++) { is.read((char*)&(data._elevation_pattern[i]),4); data.SwitchEndian(data._elevation_pattern[i]); } is.read(buf16,14); return is; } AntennaElevationPatterns::AntennaElevationPatterns(const AntennaElevationPatterns& rhs): EnvisatAsarRecord(rhs), _zero_doppler_time(rhs._zero_doppler_time), _attach_flag(rhs._attach_flag), _swath(rhs._swath) { for (int i = 0; i<33; i++) { _elevation_pattern[i] = rhs._elevation_pattern[i]; } } AntennaElevationPatterns& AntennaElevationPatterns::operator=(const AntennaElevationPatterns& rhs) { _zero_doppler_time = rhs._zero_doppler_time; _attach_flag = rhs._attach_flag; _swath = rhs._swath; for (int i = 0; i<33; i++) { _elevation_pattern[i] = rhs._elevation_pattern[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/AntennaElevationPatterns.h000066400000000000000000000052231301006202600330440ustar00rootroot00000000000000 //---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AntennaElevationPatterns_h #define AntennaElevationPatterns_h #include #include namespace ossimplugins { /** * @ingroup AntennaElevationPatternsRecord * @brief This class is able to read the ASAR AntennaElevationPatterns record */ class AntennaElevationPatterns : public EnvisatAsarRecord { public: /** * @brief Constructor */ AntennaElevationPatterns(); /** * @brief Destructor */ virtual ~AntennaElevationPatterns(); /** * @brief This function writes the AntennaElevationPatterns in a stream */ friend std::ostream& operator<<(std::ostream& os, const AntennaElevationPatterns& data); /** * @brief This function reads a AntennaElevationPatterns from a stream */ friend std::istream& operator>>(std::istream& is, AntennaElevationPatterns& data); /** * @brief Copy constructor */ AntennaElevationPatterns(const AntennaElevationPatterns& rhs); /** * @brief Copy operator */ AntennaElevationPatterns& operator=(const AntennaElevationPatterns& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new AntennaElevationPatterns(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new AntennaElevationPatterns(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief zero_doppler_time */ std::string get_zero_doppler_time() { return _zero_doppler_time; }; /** * @brief attach_flag */ bool get_attach_flag() { return _attach_flag; }; /** * @brief swath */ std::string get_swath() { return _swath; }; /** * @brief Elevation Pattern */ float * get_elevation_pattern() { return _elevation_pattern; }; /** * @brief zero_doppler_time */ std::string _zero_doppler_time; /** * @brief attach_flag */ bool _attach_flag; /** * @brief swath */ std::string _swath; /** * @brief Elevation Pattern */ float _elevation_pattern[33]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/ChirpParameters.cpp000066400000000000000000000124601301006202600315150ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { ChirpParameters::ChirpParameters() : EnvisatAsarRecord("ChirpParameters_rec") { } ChirpParameters::~ChirpParameters() { } std::ostream& operator<<(std::ostream& os, const ChirpParameters& data) { os<<"zero_doppler_time:"<>(std::istream& is, ChirpParameters& data) { // char buf64[65]; // buf64[64] = '\0'; // char buf32[33]; // buf32[32] = '\0'; // char buf27[28]; // buf27[27] = '\0'; // char buf20[21]; // buf20[20] = '\0'; char buf16[17]; buf16[16]='\0'; // char buf15[16]; // buf15[15] = '\0'; // char buf14[15]; // buf14[14] = '\0'; // char buf13[14]; // buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; // char buf11[12]; // buf11[11] = '\0'; // char buf10[11]; // buf10[10] = '\0'; // char buf9[10]; // buf9[9] = '\0'; // char buf8[9]; // buf8[8] = '\0'; char buf7[8]; buf7[7] = '\0'; // char buf6[7]; // buf6[6] = '\0'; // char buf5[6]; // buf5[5] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf3[4]; buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; // char buf1[1]; // not used avoid warning is.read(buf12,12); data._zero_doppler_time = buf12; is.read((char*)&(data._attach_flag),1); is.read(buf3,3); data._swath = buf3; is.read(buf3,3); data._polar = buf3; is.read((char*)&(data._chirp_width),4); data.SwitchEndian(data._chirp_width); is.read((char*)&(data._chirp_sidelobe),4); data.SwitchEndian(data._chirp_sidelobe); is.read((char*)&(data._chirp_islr),4); data.SwitchEndian(data._chirp_islr); is.read((char*)&(data._chirp_peak_loc),4); data.SwitchEndian(data._chirp_peak_loc); is.read((char*)&(data._re_chirp_power),4); data.SwitchEndian(data._re_chirp_power); is.read((char*)&(data._elev_chirp_power),4); data.SwitchEndian(data._elev_chirp_power); is.read((char*)&(data._chirp_quality_flag),1); data.SwitchEndian(data._chirp_quality_flag); is.read((char*)&(data._ref_chirp_power),4); data.SwitchEndian(data._ref_chirp_power); is.read(buf7,7); data._normalisation_source = buf7; is.read(buf4,4); for (int i = 0; i<352; i++) { is.read((char*)&(data._cal_pulse_info[i]),4); data.SwitchEndian(data._cal_pulse_info[i]); } is.read(buf16,16); return is; } ChirpParameters::ChirpParameters(const ChirpParameters& rhs): EnvisatAsarRecord(rhs), _zero_doppler_time(rhs._zero_doppler_time), _attach_flag(rhs._attach_flag), _swath(rhs._swath), _polar(rhs._polar), _chirp_width(rhs._chirp_width), _chirp_sidelobe(rhs._chirp_sidelobe), _chirp_islr(rhs._chirp_islr), _chirp_peak_loc(rhs._chirp_peak_loc), _re_chirp_power(rhs._re_chirp_power), _elev_chirp_power(rhs._elev_chirp_power), _chirp_quality_flag(rhs._chirp_quality_flag), _ref_chirp_power(rhs._ref_chirp_power), _normalisation_source(rhs._normalisation_source) { for (int i = 0; i<352; i++) { _cal_pulse_info[i] = rhs._cal_pulse_info[i]; } } ChirpParameters& ChirpParameters::operator=(const ChirpParameters& rhs) { _zero_doppler_time = rhs._zero_doppler_time; _attach_flag = rhs._attach_flag; _swath = rhs._swath; _polar = rhs._polar; _chirp_width = rhs._chirp_width; _chirp_sidelobe = rhs._chirp_sidelobe; _chirp_islr = rhs._chirp_islr; _chirp_peak_loc = rhs._chirp_peak_loc; _re_chirp_power = rhs._re_chirp_power; _elev_chirp_power = rhs._elev_chirp_power; _chirp_quality_flag = rhs._chirp_quality_flag; _ref_chirp_power = rhs._ref_chirp_power; _normalisation_source = rhs._normalisation_source; for (int i = 0; i<352; i++) { _cal_pulse_info[i] = rhs._cal_pulse_info[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/ChirpParameters.h000066400000000000000000000102231301006202600311550ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ChirpParameters_h #define ChirpParameters_h #include #include namespace ossimplugins { /** * @ingroup ChirpParametersRecord * @brief This class is able to read the ASAR ChirpParameters record */ class ChirpParameters : public EnvisatAsarRecord { public: /** * @brief Constructor */ ChirpParameters(); /** * @brief Destructor */ virtual ~ChirpParameters(); /** * @brief This function writes the ChirpParameters in a stream */ friend std::ostream& operator<<(std::ostream& os, const ChirpParameters& data); /** * @brief This function reads a ChirpParameters from a stream */ friend std::istream& operator>>(std::istream& is, ChirpParameters& data); /** * @brief Copy constructor */ ChirpParameters(const ChirpParameters& rhs); /** * @brief Copy operator */ ChirpParameters& operator=(const ChirpParameters& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new ChirpParameters(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new ChirpParameters(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief zero_doppler_time */ std::string get_zero_doppler_time() { return _zero_doppler_time; }; /** * @brief attach_flag */ bool get_attach_flag() { return _attach_flag; }; /** * @brief swath */ std::string get_swath() { return _swath; }; /** * @brief polar */ std::string get_polar() { return _polar; }; /** * @brief chirp_width */ float get_chirp_width() { return _chirp_width; }; /** * @brief chirp_sidelobe */ float get_chirp_sidelobe() { return _chirp_sidelobe; }; /** * @brief chirp_islr */ float get_chirp_islr() { return _chirp_islr; }; /** * @brief chirp_peak_loc */ float get_chirp_peak_loc() { return _chirp_peak_loc; }; /** * @brief re_chirp_power */ float get_re_chirp_power() { return _re_chirp_power; }; /** * @brief elev_chirp_power */ float get_elev_chirp_power() { return _elev_chirp_power; }; /** * @brief chirp_quality_flag */ bool get_chirp_quality_flag() { return _chirp_quality_flag; }; /** * @brief ref_chirp_power */ float get_ref_chirp_power() { return _ref_chirp_power; }; /** * @brief normalisation_source */ std::string get_normalisation_source() { return _normalisation_source; }; /** * @brief cal_pulse_info[352] */ float* get_cal_pulse_info() { return _cal_pulse_info; }; /** * @brief zero_doppler_time */ std::string _zero_doppler_time; /** * @brief attach_flag */ bool _attach_flag; /** * @brief swath */ std::string _swath; /** * @brief polar */ std::string _polar; /** * @brief chirp_width */ float _chirp_width; /** * @brief chirp_sidelobe */ float _chirp_sidelobe; /** * @brief chirp_islr */ float _chirp_islr; /** * @brief chirp_peak_loc */ float _chirp_peak_loc; /** * @brief re_chirp_power */ float _re_chirp_power; /** * @brief elev_chirp_power */ float _elev_chirp_power; /** * @brief chirp_quality_flag */ bool _chirp_quality_flag; /** * @brief ref_chirp_power */ float _ref_chirp_power; /** * @brief normalisation_source */ std::string _normalisation_source; /** * @brief cal_pulse_info[352] */ float _cal_pulse_info[352]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/DopplerCentroidParameters.cpp000066400000000000000000000107451301006202600335510ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { DopplerCentroidParameters::DopplerCentroidParameters() : EnvisatAsarRecord("DopplerCentroidParameters_rec") { } DopplerCentroidParameters::~DopplerCentroidParameters() { } std::ostream& operator<<(std::ostream& os, const DopplerCentroidParameters& data) { os<<"zero_doppler_time:"<>(std::istream& is, DopplerCentroidParameters& data) { // char buf64[65]; // buf64[64] = '\0'; // char buf32[33]; // buf32[32] = '\0'; // char buf27[28]; // buf27[27] = '\0'; // char buf20[21]; // buf20[20] = '\0'; // char buf16[17]; // buf16[16]='\0'; // char buf15[16]; // buf15[15] = '\0'; // char buf14[15]; // buf14[14] = '\0'; // char buf13[14]; // buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; // char buf11[12]; // buf11[11] = '\0'; // char buf10[11]; // buf10[10] = '\0'; // char buf9[10]; // buf9[9] = '\0'; // char buf8[9]; // buf8[8] = '\0'; // char buf7[8]; // buf7[7] = '\0'; // char buf6[7]; // buf6[6] = '\0'; // char buf5[6]; // buf5[5] = '\0'; // char buf4[5]; // buf4[4] = '\0'; char buf3[4]; buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; // char buf1[1]; // Not used avoid warning is.read(buf12,12); data._zero_doppler_time = buf12; is.read((char*)&(data._attach_flag),1); is.read((char*)&(data._slant_range_time),4); data.SwitchEndian(data._slant_range_time); for (int i = 0; i <5; i++) { is.read((char*)&(data._dop_coef[i]),4); data.SwitchEndian(data._dop_coef[i]); } is.read((char*)&(data._dop_conf),4); data.SwitchEndian(data._dop_conf); is.read((char*)&(data._dop_conf_below_thresh_flag),1); for (int i = 0; i <5; i++) { is.read((char*)&(data._delta_dopp_coeff[i]),2); data.SwitchEndian(data._delta_dopp_coeff[i]); } is.read(buf3,3); return is; } DopplerCentroidParameters::DopplerCentroidParameters(const DopplerCentroidParameters& rhs): EnvisatAsarRecord(rhs), _zero_doppler_time(rhs._zero_doppler_time), _attach_flag(rhs._attach_flag), _slant_range_time(rhs._slant_range_time), _dop_conf(rhs._dop_conf), _dop_conf_below_thresh_flag(rhs._dop_conf_below_thresh_flag) { for (int i = 0; i <5; i++) { _dop_coef[i] = rhs._dop_coef[i]; } for (int i = 0; i <5; i++) { _delta_dopp_coeff[i] = rhs._delta_dopp_coeff[i]; } } DopplerCentroidParameters& DopplerCentroidParameters::operator=(const DopplerCentroidParameters& rhs) { _zero_doppler_time = rhs._zero_doppler_time; _attach_flag = rhs._attach_flag; _slant_range_time = rhs._slant_range_time; _dop_conf = rhs._dop_conf; _dop_conf_below_thresh_flag = rhs._dop_conf_below_thresh_flag; for (int i = 0; i <5; i++) { _dop_coef[i] = rhs._dop_coef[i]; } for (int i = 0; i <5; i++) { _delta_dopp_coeff[i] = rhs._delta_dopp_coeff[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/DopplerCentroidParameters.h000066400000000000000000000063331301006202600332140ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DopplerCentroidParameters_h #define DopplerCentroidParameters_h #include #include namespace ossimplugins { /** * @ingroup DopplerCentroidParametersRecord * @brief This class is able to read the ASAR DopplerCentroidParameters record */ class DopplerCentroidParameters : public EnvisatAsarRecord { public: /** * @brief Constructor */ DopplerCentroidParameters(); /** * @brief Destructor */ virtual ~DopplerCentroidParameters(); /** * @brief This function writes the DopplerCentroidParameters in a stream */ friend std::ostream& operator<<(std::ostream& os, const DopplerCentroidParameters& data); /** * @brief This function reads a DopplerCentroidParameters from a stream */ friend std::istream& operator>>(std::istream& is, DopplerCentroidParameters& data); /** * @brief Copy constructor */ DopplerCentroidParameters(const DopplerCentroidParameters& rhs); /** * @brief Copy operator */ DopplerCentroidParameters& operator=(const DopplerCentroidParameters& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new DopplerCentroidParameters(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new DopplerCentroidParameters(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief zero_doppler_time */ std::string get_zero_doppler_time() { return _zero_doppler_time; }; /** * @brief attach_flag */ bool get_attach_flag() { return _attach_flag; }; /** * @brief slant_range_time */ float get_slant_range_time() { return _slant_range_time; }; /** * @brief dop_coef[5] */ float* get_dop_coef() { return _dop_coef; }; /** * @brief dop_conf */ float get_dop_conf() { return _dop_conf; }; /** * @brief dop_conf_below_thresh_flag */ bool get_dop_conf_below_thresh_flag() { return _dop_conf_below_thresh_flag; }; /** * @brief delta_dopp_coeff[5] */ signed short * get_delta_dopp_coeff() { return _delta_dopp_coeff; }; /** * @brief zero_doppler_time */ std::string _zero_doppler_time; /** * @brief attach_flag */ bool _attach_flag; /** * @brief slant_range_time */ float _slant_range_time; /** * @brief dop_coef[5] */ float _dop_coef[5]; /** * @brief dop_conf */ float _dop_conf; /** * @brief dop_conf_below_thresh_flag */ bool _dop_conf_below_thresh_flag; /** * @brief delta_dopp_coeff[5] */ signed short _delta_dopp_coeff[5]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/EnvisatAsarData.cpp000066400000000000000000000163331301006202600314410ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { EnvisatAsarData::EnvisatAsarData() { } EnvisatAsarData::~EnvisatAsarData() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const EnvisatAsarData& data) { std::list::const_iterator it = data._records.begin(); while(it != data._records.end()) { (*it)->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, EnvisatAsarData& data) { EnvisatAsarDataFactory factory; if (sizeof(int)!=4) std::cout << "EnvisatAsarData WARNING : (int) not coded over 32 bits, metadata might not be byte swapped correctly"<< std::endl ; if (sizeof(float)!=4) std::cout << "EnvisatAsarData WARNING : (float) not coded over 32 bits, metadata might not be byte swapped correctly"<< std::endl ; if (sizeof(double)!=8) std::cout << "EnvisatAsarData WARNING : (double) not coded over 64 bits, metadata might not be byte swapped correctly"<< std::endl ; data.ClearRecords(); // read the first record (MPH) EnvisatAsarRecord* mph_record = factory.Instantiate("MPH"); mph_record->Read(is); data._records.push_back(mph_record); // read the second record (sph) and update it with the mph (number of dsd) EnvisatAsarRecord* sph_record = factory.Instantiate("SPH"); ((sph*)sph_record)->update_sph_from_mph(*((mph *)mph_record)); sph_record->Read(is); data._records.push_back(sph_record); std::vector dsd_vector = ((sph*)sph_record)->get_dsd_vector(); // For each dsd, check if present in the file and in the record factory. // If true, instantiate it and add to the EnvisatAsarRecord list. std::vector::iterator it = dsd_vector.begin(); while(it != dsd_vector.end()) { std::string str = (it->get_ds_name()); if ( (it->get_ds_size()) != 0) { for (int i = 0; i<(it->get_num_dsr()); i++) { EnvisatAsarRecord* record = factory.Instantiate(str); if (record != NULL) { is.seekg((std::streampos)(it->get_ds_offset())+ (std::streampos)(i*(it->get_dsr_size()))); record->Read(is); data._records.push_back(record); } } } ++it; } return is; } EnvisatAsarData::EnvisatAsarData(const EnvisatAsarData& rhs) { std::list::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records.push_back((*it)->Clone()); ++it; } } EnvisatAsarData& EnvisatAsarData::operator=(const EnvisatAsarData& rhs) { ClearRecords(); std::list::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records.push_back((*it)->Clone()); ++it; } return *this; } void EnvisatAsarData::ClearRecords() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { delete (*it); ++it; } _records.clear(); } mph * EnvisatAsarData::get_mph() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { if ((*it)->get_mnemonic().compare("mph_rec") == 0) return (mph*)(*it); ++it; } return NULL; } sph * EnvisatAsarData::get_sph() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { if ((*it)->get_mnemonic().compare("sph_rec") == 0) return (sph*)(*it); ++it; } return NULL; } SQ_ADSR * EnvisatAsarData::get_SQ_ADSR() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { if ((*it)->get_mnemonic().compare("SQ_ADSR_rec") == 0) return (SQ_ADSR*)(*it); ++it; } return NULL; } MainProcessingParameters * EnvisatAsarData::get_MainProcessingParameters() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { if ((*it)->get_mnemonic().compare("MainProcessingParameters_rec") == 0) return (MainProcessingParameters*)(*it); ++it; } return NULL; } DopplerCentroidParameters * EnvisatAsarData::get_DopplerCentroidParameters() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { if ((*it)->get_mnemonic().compare("DopplerCentroidParameters_rec") == 0) return (DopplerCentroidParameters*)(*it); ++it; } return NULL; } SRGRConversionParameters * EnvisatAsarData::get_SRGRConversionParameters(int pos) { std::list::const_iterator it = _records.begin(); int cpt = 0; while(it != _records.end()) { if ((*it)->get_mnemonic().compare("SRGRConversionParameters_rec") == 0) { if (cpt == pos) { return (SRGRConversionParameters*)(*it); } else cpt++; } ++it; } return NULL; } ChirpParameters * EnvisatAsarData::get_ChirpParameters() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { if ((*it)->get_mnemonic().compare("ChirpParameters_rec") == 0) return (ChirpParameters*)(*it); ++it; } return NULL; } AntennaElevationPatterns * EnvisatAsarData::get_AntennaElevationPatterns() { std::list::const_iterator it = _records.begin(); while(it != _records.end()) { if ((*it)->get_mnemonic().compare("AntennaElevationPatterns_rec") == 0) return (AntennaElevationPatterns*)(*it); ++it; } return NULL; } // Return the first Geolocation Grid Record //GeolocationGrid * EnvisatAsarData::get_GeolocationGrid() //{ // std::list::const_iterator it = _records.begin(); // while(it != _records.end()) // { // std::string str = (*it)->get_mnemonic(); // if ((*it)->get_mnemonic().compare("GeolocationGrid_rec") == 0) // { // return (GeolocationGrid*)(*it); // } // ++it; // } // return NULL; //} // Return the num_ds Geolocation Grid Record GeolocationGrid * EnvisatAsarData::get_GeolocationGrid(int num_ds) { std::list::const_iterator it = _records.begin(); int total_num_ds = 0; while(it != _records.end()) { std::string str = (*it)->get_mnemonic(); if ((*it)->get_mnemonic().compare("GeolocationGrid_rec") == 0) total_num_ds += 1; ++it; } int cpt = 0; it = _records.begin(); while(it != _records.end()) { std::string str = (*it)->get_mnemonic(); if ((*it)->get_mnemonic().compare("GeolocationGrid_rec") == 0) { if ((cpt == num_ds) || (cpt == total_num_ds-1)) return (GeolocationGrid*)(*it); cpt +=1; } ++it; } return NULL; } int EnvisatAsarData::get_num_ds(EnvisatAsarRecord * record) { if (record == NULL) return 0; std::list::const_iterator it = _records.begin(); int cpt = 0; while(it != _records.end()) { std::string str = (*it)->get_mnemonic(); if ((*it)->get_mnemonic().compare(record->get_mnemonic()) == 0) { cpt++; } ++it; } return cpt; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/EnvisatAsarData.h000066400000000000000000000041251301006202600311020ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef EnvisatAsarData_h #define EnvisatAsarData_h #include #include "sph.h" #include "mph.h" #include "SQ_ADSR.h" #include "MainProcessingParameters.h" #include "AntennaElevationPatterns.h" #include "DopplerCentroidParameters.h" #include "SRGRConversionParameters.h" #include "ChirpParameters.h" #include "GeolocationGrid.h" #include #include #include namespace ossimplugins { /** * @ingroup EnvisatAsarDataFile * @brief This class is able to read the Envisat file structure */ class EnvisatAsarData { public: /** * @brief Constructor */ EnvisatAsarData(); /** * @brief Destructor */ ~EnvisatAsarData(); /** * @brief This function writes the EnvisatAsarData in a stream */ friend std::ostream& operator<<(std::ostream& os, const EnvisatAsarData& data); /** * @brief This function reads a EnvisatAsarData from a stream */ friend std::istream& operator>>(std::istream& is, EnvisatAsarData& data); /** * @brief Copy constructor */ EnvisatAsarData(const EnvisatAsarData& rhs); /** * @brief Copy operator */ EnvisatAsarData& operator=(const EnvisatAsarData& rhs); /** * @brief Removes all the previous records from the EnvisatAsarData */ void ClearRecords(); mph * get_mph(); sph * get_sph(); SQ_ADSR * get_SQ_ADSR(); MainProcessingParameters * get_MainProcessingParameters(); AntennaElevationPatterns * get_AntennaElevationPatterns(); DopplerCentroidParameters * get_DopplerCentroidParameters(); SRGRConversionParameters * get_SRGRConversionParameters(int pos = 0); ChirpParameters * get_ChirpParameters(); GeolocationGrid * get_GeolocationGrid(int num_ds = 0); int get_num_ds(EnvisatAsarRecord * record); protected: std::list _records; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/EnvisatAsarDataFactory.cpp000066400000000000000000000032331301006202600327640ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { EnvisatAsarDataFactory::EnvisatAsarDataFactory() { RegisterRecord("MPH" , new mph()); RegisterRecord("SPH" , new sph()); RegisterRecord("MDS1 SQ ADS " , new SQ_ADSR()); RegisterRecord("MDS2 SQ ADS " , new SQ_ADSR()); RegisterRecord("MAIN PROCESSING PARAMS ADS " , new MainProcessingParameters()); RegisterRecord("DOP CENTROID COEFFS ADS " , new DopplerCentroidParameters()); RegisterRecord("SR GR ADS " , new SRGRConversionParameters()); RegisterRecord("CHIRP PARAMS ADS " , new ChirpParameters()); RegisterRecord("MDS1 ANTENNA ELEV PATT ADS " , new AntennaElevationPatterns()); RegisterRecord("MDS2 ANTENNA ELEV PATT ADS " , new AntennaElevationPatterns()); RegisterRecord("GEOLOCATION GRID ADS " , new GeolocationGrid()); } EnvisatAsarDataFactory::~EnvisatAsarDataFactory() { } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/EnvisatAsarDataFactory.h000066400000000000000000000014701301006202600324320ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef EnvisatAsarDataFactory_h #define EnvisatAsarDataFactory_h #include #include namespace ossimplugins { /** * @ingroup EnvisatAsarDataFile * @brief This class is a factory able to construct Record base classes */ class EnvisatAsarDataFactory : public EnvisatAsarRecordFactory { public: /** * @brief Constructor */ EnvisatAsarDataFactory(); /** * @brief Destructor */ ~EnvisatAsarDataFactory(); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/EnvisatAsarRecord.cpp000066400000000000000000000011741301006202600320030ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include namespace ossimplugins { EnvisatAsarRecord::EnvisatAsarRecord(std::string mnemonic): _mnemonic(mnemonic) { } EnvisatAsarRecord::~EnvisatAsarRecord() { } EnvisatAsarRecord::EnvisatAsarRecord(const EnvisatAsarRecord& rhs): _mnemonic(rhs._mnemonic) { } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/EnvisatAsarRecord.h000066400000000000000000000042461301006202600314530ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef EnvisatAsarRecord_h #define EnvisatAsarRecord_h #include #include #include #include namespace ossimplugins { /** * @ingroup EnvisatAsar * @brief This class is the base class of all the Envisat ASAR record classes */ class EnvisatAsarRecord { public: /** * @brief Constructor * @param mnemonic Name of the record */ EnvisatAsarRecord(std::string mnemonic); /** * @brief Destructor */ virtual ~EnvisatAsarRecord(); /** * @brief Copy constructor */ EnvisatAsarRecord(const EnvisatAsarRecord& rhs); /** * @brief This function is able to create a new instance of the class */ virtual EnvisatAsarRecord* Instantiate() =0; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ virtual EnvisatAsarRecord* Clone()=0; /** * @brief Reads the class data from a stream */ virtual void Read(std::istream& is) =0; /** * @brief Writes the class to a stream */ virtual void Write(std::ostream& os)=0; /** * @brief Returns the mnemonic of the record */ std::string get_mnemonic() { return _mnemonic; }; protected: /** * @brief This function switches the LSB value and the MSB value of the parameter */ template void SwitchEndian(T &value) { char *buffer; char *res; int nb_octets = sizeof(T); if (ossim::byteOrder() == OSSIM_LITTLE_ENDIAN) { buffer = (char* )malloc(nb_octets); res = (char* )malloc(nb_octets); memcpy(buffer,&value,nb_octets); for (int i=0; i namespace ossimplugins { EnvisatAsarRecordFactory::EnvisatAsarRecordFactory() { } EnvisatAsarRecordFactory::~EnvisatAsarRecordFactory() { } EnvisatAsarRecord* EnvisatAsarRecordFactory::Instantiate(std::string id) { EnvisatAsarRecord* record = _availableRecords[id]; if(record == NULL) { return NULL; } else { return record->Instantiate(); } } void EnvisatAsarRecordFactory::RegisterRecord(std::string id, EnvisatAsarRecord * record) { _availableRecords[id] = record; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/EnvisatAsarRecordFactory.h000066400000000000000000000025241301006202600330000ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef EnvisatAsarRecordFactory_h #define EnvisatAsarRecordFactory_h #include #include #include namespace ossimplugins { /** * @ingroup EnvisatAsar * @brief This class is a factory able to construct Record base classes given the id of the record wanted */ class EnvisatAsarRecordFactory { public: /** * @brief Constructor */ EnvisatAsarRecordFactory(); /** * @brief Destructor */ ~EnvisatAsarRecordFactory(); /** * @brief Adds a new Record type available in this factory * @param record Record to add in the factory * @param id Id of the new avalaible Record */ void RegisterRecord(std::string id, EnvisatAsarRecord * record); /** * @brief Instanciatse a new Record * @param id Id of the Record we want to instantiate */ EnvisatAsarRecord* Instantiate(std::string id); protected: /** * @brief Contains all the available Records for the factory */ std::map _availableRecords; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/GeolocationGrid.cpp000066400000000000000000000141421301006202600314740ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { GeolocationGrid::GeolocationGrid() : EnvisatAsarRecord("GeolocationGrid_rec") { } GeolocationGrid::~GeolocationGrid() { } std::ostream& operator<<(std::ostream& os, const GeolocationGrid& data) { os<<"first_zero_doppler_time_day:"<>(std::istream& is, GeolocationGrid& data) { char buf220[221]; buf220[220] = '\0'; char buf32[33]; buf32[32] = '\0'; // char buf27[28]; // buf27[27] = '\0'; // char buf20[21]; // buf20[20] = '\0'; // char buf16[17]; // buf16[16]='\0'; // char buf15[16]; // buf15[15] = '\0'; // char buf14[15]; // buf14[14] = '\0'; // char buf13[14]; // buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; // char buf11[12]; // buf11[11] = '\0'; // char buf10[11]; // buf10[10] = '\0'; // char buf9[10]; // buf9[9] = '\0'; // char buf8[9]; // buf8[8] = '\0'; // char buf7[8]; // buf7[7] = '\0'; // char buf6[7]; // buf6[6] = '\0'; // char buf5[6]; // buf5[5] = '\0'; // char buf4[5]; // buf4[4] = '\0'; // char buf3[4]; // buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; // char buf1[1]; // not used avoid warning is.read((char*)&(data._first_zero_doppler_time_day),4); data.SwitchEndian(data._first_zero_doppler_time_day); is.read((char*)&(data._first_zero_doppler_time_sec),4); data.SwitchEndian(data._first_zero_doppler_time_sec); is.read((char*)&(data._first_zero_doppler_time_microsec),4); data.SwitchEndian(data._first_zero_doppler_time_microsec); is.read((char*)&(data._attach_flag),1); is.read((char*)&(data._line_num),4); data.SwitchEndian(data._line_num); is.read((char*)&(data._num_lines),4); data.SwitchEndian(data._num_lines); is.read((char*)&(data._sub_sat_track),4); data.SwitchEndian(data._sub_sat_track); for (int i = 0; i<11; i++) { is.read((char*)&(data._samp_numbers[i]),4); data.SwitchEndian(data._samp_numbers[i]); } for (int i = 0; i<11; i++) { is.read((char*)&(data._slant_range_times[i]),4); data.SwitchEndian(data._slant_range_times[i]); } for (int i = 0; i<11; i++) { is.read((char*)&(data._angles[i]),4); data.SwitchEndian(data._angles[i]); } for (int i = 0; i<11; i++) { is.read((char*)&(data._lats[i]),4); data.SwitchEndian(data._lats[i]); } for (int i = 0; i<11; i++) { is.read((char*)&(data._longs[i]),4); data.SwitchEndian(data._longs[i]); } is.read(buf32,22); is.read(buf12,12); data._last_zero_doppler_time = buf12; is.read(buf220,220); data._last_line_tie_points = buf220; is.read(buf32,22); return is; } GeolocationGrid::GeolocationGrid(const GeolocationGrid& rhs): EnvisatAsarRecord(rhs), _first_zero_doppler_time_day(rhs._first_zero_doppler_time_day), _first_zero_doppler_time_sec(rhs._first_zero_doppler_time_sec), _first_zero_doppler_time_microsec(rhs._first_zero_doppler_time_microsec), _attach_flag(rhs._attach_flag), _line_num(rhs._line_num), _num_lines(rhs._num_lines), _sub_sat_track(rhs._sub_sat_track), _last_zero_doppler_time(rhs._last_zero_doppler_time), _last_line_tie_points(rhs._last_line_tie_points) { for (int i = 0; i<11; i++) { _samp_numbers[i] = rhs._samp_numbers[i]; _slant_range_times[i] = rhs._slant_range_times[i]; _angles[i] = rhs._angles[i]; _lats[i] = rhs._lats[i]; _longs[i] = rhs._longs[i]; } } GeolocationGrid& GeolocationGrid::operator=(const GeolocationGrid& rhs) { _first_zero_doppler_time_day = rhs._first_zero_doppler_time_day; _first_zero_doppler_time_sec = rhs._first_zero_doppler_time_sec; _first_zero_doppler_time_microsec = rhs._first_zero_doppler_time_microsec; _attach_flag = rhs._attach_flag; _line_num = rhs._line_num; _num_lines = rhs._num_lines; _sub_sat_track = rhs._sub_sat_track; _last_zero_doppler_time = rhs._last_zero_doppler_time; _last_line_tie_points = rhs._last_line_tie_points; for (int i = 0; i<11; i++) { _samp_numbers[i] = rhs._samp_numbers[i]; _slant_range_times[i] = rhs._slant_range_times[i]; _angles[i] = rhs._angles[i]; _lats[i] = rhs._lats[i]; _longs[i] = rhs._longs[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/GeolocationGrid.h000066400000000000000000000105361301006202600311440ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef GeolocationGrid_h #define GeolocationGrid_h #include #include namespace ossimplugins { /** * @ingroup GeolocationGridRecord * @brief This class is able to read the ASAR GeolocationGrid record */ class GeolocationGrid : public EnvisatAsarRecord { public: /** * @brief Constructor */ GeolocationGrid(); /** * @brief Destructor */ virtual ~GeolocationGrid(); /** * @brief This function writes the GeolocationGrid in a stream */ friend std::ostream& operator<<(std::ostream& os, const GeolocationGrid& data); /** * @brief This function reads a GeolocationGrid from a stream */ friend std::istream& operator>>(std::istream& is, GeolocationGrid& data); /** * @brief Copy constructor */ GeolocationGrid(const GeolocationGrid& rhs); /** * @brief Copy operator */ GeolocationGrid& operator=(const GeolocationGrid& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new GeolocationGrid(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new GeolocationGrid(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief first_zero_doppler_time day */ int get_first_zero_doppler_time_day() { return _first_zero_doppler_time_day; }; /** * @brief first_zero_doppler_time second */ unsigned int get_first_zero_doppler_time_sec() { return _first_zero_doppler_time_sec; }; /** * @brief first_zero_doppler_time micro sec */ unsigned int get_first_zero_doppler_time_microsec() { return _first_zero_doppler_time_microsec; }; /** * @brief attach_flag */ bool get_attach_flag() { return _attach_flag; }; /** * @brief line_num */ unsigned int get_line_num() { return _line_num; }; /** * @brief num_lines */ unsigned int get_num_lines() { return _num_lines; }; /** * @brief sub_sat_track */ float get_sub_sat_track() { return _sub_sat_track; }; /** * @brief samp_numbvers */ unsigned int * get_samp_numbers() { return _samp_numbers; }; /** * @brief slant_range_times */ float * get_slant_range_times() { return _slant_range_times; }; /** * @brief angles */ float * get_angles() { return _angles; }; /** * @brief lats */ int * get_lats() { return _lats; }; /** * @brief longs */ int * get_longs() { return _longs; }; /** * @brief last_zero_doppler_time */ std::string get_last_zero_doppler_time() { return _last_zero_doppler_time; }; /** * @brief last_line_tie_points */ std::string get_last_line_tie_points() { return _last_line_tie_points; }; /** * @brief first_zero_doppler_time day */ int _first_zero_doppler_time_day; /** * @brief first_zero_doppler_time sec */ unsigned int _first_zero_doppler_time_sec; /** * @brief first_zero_doppler_time microsec */ unsigned int _first_zero_doppler_time_microsec; /** * @brief attach_flag */ bool _attach_flag; /** * @brief line_num */ unsigned int _line_num; /** * @brief num_lines */ unsigned int _num_lines; /** * @brief sub_sat_track */ float _sub_sat_track; /** * @brief samp_numbers */ unsigned int _samp_numbers[11]; /** * @brief slant_range_times[11] */ float _slant_range_times[11]; /** * @brief angles[11] */ float _angles[11]; /** * @brief lats[11] */ int _lats[11]; /** * @brief longs[11] */ int _longs[11]; /** * @brief last_zero_doppler_time */ std::string _last_zero_doppler_time; /** * @brief last_line_tie_points */ std::string _last_line_tie_points; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/MainProcessingParameters.cpp000066400000000000000000000771401301006202600333770ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { MainProcessingParameters::MainProcessingParameters() : EnvisatAsarRecord("MainProcessingParameters_rec") { } MainProcessingParameters::~MainProcessingParameters() { } std::ostream& operator<<(std::ostream& os, const MainProcessingParameters& data) { os<<"first_zero_doppler_time:"<>(std::istream& is, MainProcessingParameters& data) { char buf64[65]; buf64[64] = '\0'; char buf32[33]; buf32[32] = '\0'; // char buf27[28]; // buf27[27] = '\0'; char buf20[21]; buf20[20] = '\0'; char buf16[17]; buf16[16]='\0'; // char buf15[16]; // buf15[15] = '\0'; // char buf14[15]; // buf14[14] = '\0'; // char buf13[14]; // buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; // char buf11[12]; // buf11[11] = '\0'; // char buf10[11]; // buf10[10] = '\0'; // char buf9[10]; // buf9[9] = '\0'; // char buf8[9]; // buf8[8] = '\0'; char buf7[8]; buf7[7] = '\0'; char buf6[7]; buf6[6] = '\0'; char buf5[6]; buf5[5] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf3[4]; buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; // char buf1[1]; // not used avoid warning // int * var_long; // not used avoid warning is.read(buf12,12); data._first_zero_doppler_time = buf12; is.read((char*)&(data._attach_flag),1); is.read(buf12,12); data._last_zero_doppler_time = buf12; is.read(buf12,12); data._work_order_id = buf12; is.read((char*)&(data._time_diff),4); data.SwitchEndian(data._time_diff); is.read(buf3,3); data._swath_num = buf3; is.read((char*)&(data._range_spacing),4); data.SwitchEndian(data._range_spacing); is.read((char*)&(data._azimut_spacing),4); data.SwitchEndian(data._azimut_spacing); is.read((char*)&(data._line_time_interval),4); data.SwitchEndian(data._line_time_interval); is.read((char*)&(data._num_output_lines),4); data.SwitchEndian(data._num_output_lines); is.read((char*)&(data._num_samples_per_line),4); data.SwitchEndian(data._num_samples_per_line); is.read(buf5,5); data._data_type = buf5; is.read((char*)&(data._num_range_lines_per_burst),4); data.SwitchEndian(data._num_range_lines_per_burst); is.read((char*)&(data._time_diff_zero_doppler),4); data.SwitchEndian(data._time_diff_zero_doppler); is.read(buf64,43); is.read((char*)&(data._data_analysis_flag),1); is.read((char*)&(data._ant_elev_coor_flag),1); is.read((char*)&(data._chirp_extract_flag),1); is.read((char*)&(data._srgr_flag),1); is.read((char*)&(data._dop_cen_flag),1); is.read((char*)&(data._dop_amb_flag),1); is.read((char*)&(data._range_spread_comp_flag),1); is.read((char*)&(data._detected_flag),1); is.read((char*)&(data._look_sum_flag),1); is.read((char*)&(data._rms_equal_flag),1); is.read((char*)&(data._ant_scal_flag),1); is.read((char*)&(data._vga_com_echo_flag),1); is.read((char*)&(data._vga_com_cal_flag),1); is.read((char*)&(data._vga_com_nom_time_flag),1); is.read((char*)&(data._gm_rng_comp_inv_filter_flag),1); is.read(buf6,6); char buf184[185]; buf184[184] = '\0'; is.read(buf184,184); data._raw_data_analysis = buf184; is.read(buf32,32); is.read(buf20,20); data._start_time_mds1 = buf20; is.read(buf20,20); data._start_time_mds2 = buf20; char buf120[121]; buf120[120] = '\0'; is.read(buf120,120); data._parameter_code = buf120; is.read(buf64,60); is.read(buf64,40); buf64[40] = '\0'; data._errors_counters = buf64; is.read(buf32,26); is.read(buf64,60); buf64[60] = '\0'; data._image_parameters1 = buf64; for (int i = 0; i<5; i++) { is.read((char*)&(data._prf_values[i]),4); data.SwitchEndian(data._prf_values[i]); } char buf190[191]; buf190[190] = '\0'; is.read(buf190,190); data._image_parameters2 = buf190; is.read(buf64,62); is.read((char*)&(data._first_proc_range_samp),4); data.SwitchEndian(data._first_proc_range_samp); is.read((char*)&(data._range_ref),4); data.SwitchEndian(data._range_ref); is.read((char*)&(data._range_samp_rate),4); data.SwitchEndian(data._range_samp_rate); is.read((char*)&(data._radar_freq),4); data.SwitchEndian(data._radar_freq); is.read((char*)&(data._num_looks_range),2); data.SwitchEndian(data._num_looks_range); is.read(buf7,7); data._filter_range = buf7; is.read((char*)&(data._filter_coef_range),4); data.SwitchEndian(data._filter_coef_range); is.read(buf64,40); buf64[40] = '\0'; data._bandwidth = buf64; char buf160[161]; buf160[160] = '\0'; is.read(buf160,160); data._nominal_chirp = buf160; is.read(buf64,60); is.read((char*)&(data._num_lines_proc),4); data.SwitchEndian(data._num_lines_proc); is.read((char*)&(data._num_look_az),2); data.SwitchEndian(data._num_look_az); is.read((char*)&(data._look_bw_az),4); data.SwitchEndian(data._look_bw_az); is.read((char*)&(data._to_bw_az),4); data.SwitchEndian(data._to_bw_az); is.read(buf7,7); data._filter_az = buf7; is.read((char*)&(data._filter_coef_az),4); data.SwitchEndian(data._filter_coef_az); for (int i = 0; i <3; i++) { is.read((char*)&(data._az_fm_rate[i]),4); data.SwitchEndian(data._az_fm_rate[i]); } is.read((char*)&(data._ax_fm_origin),4); data.SwitchEndian(data._ax_fm_origin); is.read((char*)&(data._dop_amb_coef),4); data.SwitchEndian(data._dop_amb_coef); char buf128[129]; buf128[128] = '\0'; is.read(buf128,68); is.read(buf16,16); data._calibration_factors = buf16; is.read(buf64,40); buf64[40]='\0'; data._noise_estimation = buf64; is.read(buf64,64); is.read(buf12,12); is.read(buf32,32); data._output_statistics = buf32; is.read((char*)&(data._avg_scene_height_ellpsoid),4); data.SwitchEndian(data._avg_scene_height_ellpsoid); is.read(buf64,48); is.read(buf4,4); data._echo_comp = buf4; is.read(buf3,3); data._echo_comp_ratio = buf3; is.read(buf4,4); data._init_cal_comp = buf4; is.read(buf3,3); data._init_cal_ratio = buf3; is.read(buf4,4); data._per_cal_comp = buf4; is.read(buf3,3); data._per_cal_ratio = buf3; is.read(buf4,4); data._noise_comp = buf4; is.read(buf3,3); data._noise_comp_ratio = buf3; is.read(buf64,64); for (int i=0;i<4;i++) { is.read((char*)&(data._beam_overlap[i]),4); data.SwitchEndian(data._beam_overlap[i]); } for (int i=0;i<4;i++) { is.read((char*)&(data._beam_param[i]),4); data.SwitchEndian(data._beam_param[i]); } for (int i=0;i<5;i++) { is.read((char*)&(data._lines_per_burst[i]),4); data.SwitchEndian(data._lines_per_burst[i]); } is.read(buf12,12); data._time_first_SS1_echo = buf12; is.read(buf16,16); is.read((char*)&(data._state_vector_time_1_day),4); data.SwitchEndian(data._state_vector_time_1_day); is.read((char*)&(data._state_vector_time_1_sec),4); data.SwitchEndian(data._state_vector_time_1_sec); is.read((char*)&(data._state_vector_time_1_microsec),4); data.SwitchEndian(data._state_vector_time_1_microsec); is.read((char*)&(data._x_pos_1),4); data.SwitchEndian(data._x_pos_1); is.read((char*)&(data._y_pos_1),4); data.SwitchEndian(data._y_pos_1); is.read((char*)&(data._z_pos_1),4); data.SwitchEndian(data._z_pos_1); is.read((char*)&(data._x_vel_1),4); data.SwitchEndian(data._x_vel_1); is.read((char*)&(data._y_vel_1),4); data.SwitchEndian(data._y_vel_1); is.read((char*)&(data._z_vel_1),4); data.SwitchEndian(data._z_vel_1); is.read((char*)&(data._state_vector_time_2_day),4); data.SwitchEndian(data._state_vector_time_2_day); is.read((char*)&(data._state_vector_time_2_sec),4); data.SwitchEndian(data._state_vector_time_2_sec); is.read((char*)&(data._state_vector_time_2_microsec),4); data.SwitchEndian(data._state_vector_time_2_microsec); is.read((char*)&(data._x_pos_2),4); data.SwitchEndian(data._x_pos_2); is.read((char*)&(data._y_pos_2),4); data.SwitchEndian(data._y_pos_2); is.read((char*)&(data._z_pos_2),4); data.SwitchEndian(data._z_pos_2); is.read((char*)&(data._x_vel_2),4); data.SwitchEndian(data._x_vel_2); is.read((char*)&(data._y_vel_2),4); data.SwitchEndian(data._y_vel_2); is.read((char*)&(data._z_vel_2),4); data.SwitchEndian(data._z_vel_2); is.read((char*)&(data._state_vector_time_3_day),4); data.SwitchEndian(data._state_vector_time_3_day); is.read((char*)&(data._state_vector_time_3_sec),4); data.SwitchEndian(data._state_vector_time_3_sec); is.read((char*)&(data._state_vector_time_3_microsec),4); data.SwitchEndian(data._state_vector_time_3_microsec); is.read((char*)&(data._x_pos_3),4); data.SwitchEndian(data._x_pos_3); is.read((char*)&(data._y_pos_3),4); data.SwitchEndian(data._y_pos_3); is.read((char*)&(data._z_pos_3),4); data.SwitchEndian(data._z_pos_3); is.read((char*)&(data._x_vel_3),4); data.SwitchEndian(data._x_vel_3); is.read((char*)&(data._y_vel_3),4); data.SwitchEndian(data._y_vel_3); is.read((char*)&(data._z_vel_3),4); data.SwitchEndian(data._z_vel_3); is.read((char*)&(data._state_vector_time_4_day),4); data.SwitchEndian(data._state_vector_time_4_day); is.read((char*)&(data._state_vector_time_4_sec),4); data.SwitchEndian(data._state_vector_time_4_sec); is.read((char*)&(data._state_vector_time_4_microsec),4); data.SwitchEndian(data._state_vector_time_4_microsec); is.read((char*)&(data._x_pos_4),4); data.SwitchEndian(data._x_pos_4); is.read((char*)&(data._y_pos_4),4); data.SwitchEndian(data._y_pos_4); is.read((char*)&(data._z_pos_4),4); data.SwitchEndian(data._z_pos_4); is.read((char*)&(data._x_vel_4),4); data.SwitchEndian(data._x_vel_4); is.read((char*)&(data._y_vel_4),4); data.SwitchEndian(data._y_vel_4); is.read((char*)&(data._z_vel_4),4); data.SwitchEndian(data._z_vel_4); is.read((char*)&(data._state_vector_time_5_day),4); data.SwitchEndian(data._state_vector_time_5_day); is.read((char*)&(data._state_vector_time_5_sec),4); data.SwitchEndian(data._state_vector_time_5_sec); is.read((char*)&(data._state_vector_time_5_microsec),4); data.SwitchEndian(data._state_vector_time_5_microsec); is.read((char*)&(data._x_pos_5),4); data.SwitchEndian(data._x_pos_5); is.read((char*)&(data._y_pos_5),4); data.SwitchEndian(data._y_pos_5); is.read((char*)&(data._z_pos_5),4); data.SwitchEndian(data._z_pos_5); is.read((char*)&(data._x_vel_5),4); data.SwitchEndian(data._x_vel_5); is.read((char*)&(data._y_vel_5),4); data.SwitchEndian(data._y_vel_5); is.read((char*)&(data._z_vel_5),4); data.SwitchEndian(data._z_vel_5); is.read(buf64,64); return is; } MainProcessingParameters::MainProcessingParameters(const MainProcessingParameters& rhs): EnvisatAsarRecord(rhs), _first_zero_doppler_time(rhs._first_zero_doppler_time), _attach_flag(rhs._attach_flag), _last_zero_doppler_time(rhs._last_zero_doppler_time), _work_order_id(rhs._work_order_id), _time_diff(rhs._time_diff), _swath_num(rhs._swath_num), _range_spacing(rhs._range_spacing), _azimut_spacing(rhs._azimut_spacing), _line_time_interval(rhs._line_time_interval), _num_output_lines(rhs._num_output_lines), _num_samples_per_line(rhs._num_samples_per_line), _data_type(rhs._data_type), _num_range_lines_per_burst(rhs._num_range_lines_per_burst), _time_diff_zero_doppler(rhs._time_diff_zero_doppler), _data_analysis_flag(rhs._data_analysis_flag), _ant_elev_coor_flag(rhs._ant_elev_coor_flag), _chirp_extract_flag(rhs._chirp_extract_flag), _srgr_flag(rhs._srgr_flag), _dop_cen_flag(rhs._dop_cen_flag), _dop_amb_flag(rhs._dop_amb_flag), _range_spread_comp_flag(rhs._range_spread_comp_flag), _detected_flag(rhs._detected_flag), _look_sum_flag(rhs._look_sum_flag), _rms_equal_flag(rhs._rms_equal_flag), _ant_scal_flag(rhs._ant_scal_flag), _vga_com_echo_flag(rhs._vga_com_echo_flag), _vga_com_cal_flag(rhs._vga_com_cal_flag), _vga_com_nom_time_flag(rhs._vga_com_nom_time_flag), _gm_rng_comp_inv_filter_flag(rhs._gm_rng_comp_inv_filter_flag), _raw_data_analysis(rhs._raw_data_analysis), _start_time_mds1(rhs._start_time_mds1), _start_time_mds2(rhs._start_time_mds2), _parameter_code(rhs._parameter_code), _errors_counters(rhs._errors_counters), _image_parameters1(rhs._image_parameters1), _image_parameters2(rhs._image_parameters2), _first_proc_range_samp(rhs._first_proc_range_samp), _range_ref(rhs._range_ref), _range_samp_rate(rhs._range_samp_rate), _radar_freq(rhs._radar_freq), _num_looks_range(rhs._num_looks_range), _filter_range(rhs._filter_range), _filter_coef_range(rhs._filter_coef_range), _bandwidth(rhs._bandwidth), _nominal_chirp(rhs._nominal_chirp), _num_lines_proc(rhs._num_lines_proc), _num_look_az(rhs._num_look_az), _look_bw_az(rhs._look_bw_az), _to_bw_az(rhs._to_bw_az), _filter_az(rhs._filter_az), _filter_coef_az(rhs._filter_coef_az), _ax_fm_origin(rhs._ax_fm_origin), _dop_amb_coef(rhs._dop_amb_coef), _calibration_factors(rhs._calibration_factors), _noise_estimation(rhs._noise_estimation), _output_statistics(rhs._output_statistics), _avg_scene_height_ellpsoid(rhs._avg_scene_height_ellpsoid), _echo_comp(rhs._echo_comp), _echo_comp_ratio(rhs._echo_comp_ratio), _init_cal_comp(rhs._init_cal_comp), _init_cal_ratio(rhs._init_cal_ratio), _per_cal_comp(rhs._per_cal_comp), _per_cal_ratio(rhs._per_cal_ratio), _noise_comp(rhs._noise_comp), _noise_comp_ratio(rhs._noise_comp_ratio), _time_first_SS1_echo(rhs._time_first_SS1_echo), _state_vector_time_1_day(rhs._state_vector_time_1_day), _state_vector_time_1_sec(rhs._state_vector_time_1_sec), _state_vector_time_1_microsec(rhs._state_vector_time_1_microsec), _x_pos_1(rhs._x_pos_1), _y_pos_1(rhs._y_pos_1), _z_pos_1(rhs._z_pos_1), _x_vel_1(rhs._x_vel_1), _y_vel_1(rhs._y_vel_1), _z_vel_1(rhs._z_vel_1), _state_vector_time_2_day(rhs._state_vector_time_2_day), _state_vector_time_2_sec(rhs._state_vector_time_2_sec), _state_vector_time_2_microsec(rhs._state_vector_time_2_microsec), _x_pos_2(rhs._x_pos_2), _y_pos_2(rhs._y_pos_2), _z_pos_2(rhs._z_pos_2), _x_vel_2(rhs._x_vel_2), _y_vel_2(rhs._y_vel_2), _z_vel_2(rhs._z_vel_2), _state_vector_time_3_day(rhs._state_vector_time_3_day), _state_vector_time_3_sec(rhs._state_vector_time_3_sec), _state_vector_time_3_microsec(rhs._state_vector_time_3_microsec), _x_pos_3(rhs._x_pos_3), _y_pos_3(rhs._y_pos_3), _z_pos_3(rhs._z_pos_3), _x_vel_3(rhs._x_vel_3), _y_vel_3(rhs._y_vel_3), _z_vel_3(rhs._z_vel_3), _state_vector_time_4_day(rhs._state_vector_time_4_day), _state_vector_time_4_sec(rhs._state_vector_time_4_sec), _state_vector_time_4_microsec(rhs._state_vector_time_4_microsec), _x_pos_4(rhs._x_pos_4), _y_pos_4(rhs._y_pos_4), _z_pos_4(rhs._z_pos_4), _x_vel_4(rhs._x_vel_4), _y_vel_4(rhs._y_vel_4), _z_vel_4(rhs._z_vel_4), _state_vector_time_5_day(rhs._state_vector_time_5_day), _state_vector_time_5_sec(rhs._state_vector_time_5_sec), _state_vector_time_5_microsec(rhs._state_vector_time_5_microsec), _x_pos_5(rhs._x_pos_5), _y_pos_5(rhs._y_pos_5), _z_pos_5(rhs._z_pos_5), _x_vel_5(rhs._x_vel_5), _y_vel_5(rhs._y_vel_5), _z_vel_5(rhs._z_vel_5) { _az_fm_rate[0] = rhs._az_fm_rate[0]; _az_fm_rate[1] = rhs._az_fm_rate[1]; _az_fm_rate[2] = rhs._az_fm_rate[2]; _prf_values[0] = rhs._prf_values[0]; _prf_values[1] = rhs._prf_values[1]; _prf_values[2] = rhs._prf_values[2]; _prf_values[3] = rhs._prf_values[3]; _prf_values[4] = rhs._prf_values[4]; _beam_overlap[0]= rhs._beam_overlap[0]; _beam_overlap[1]= rhs._beam_overlap[1]; _beam_overlap[2]= rhs._beam_overlap[2]; _beam_overlap[3]= rhs._beam_overlap[3]; _beam_param[0]= rhs._beam_param[0]; _beam_param[1]= rhs._beam_param[1]; _beam_param[2]= rhs._beam_param[2]; _beam_param[3]= rhs._beam_param[3]; _lines_per_burst[0] =rhs._lines_per_burst[0]; _lines_per_burst[1] =rhs._lines_per_burst[1]; _lines_per_burst[2] =rhs._lines_per_burst[2]; _lines_per_burst[3] =rhs._lines_per_burst[3]; _lines_per_burst[4] =rhs._lines_per_burst[4]; } MainProcessingParameters& MainProcessingParameters::operator=(const MainProcessingParameters& rhs) { _first_zero_doppler_time = rhs._first_zero_doppler_time; _attach_flag = rhs._attach_flag; _last_zero_doppler_time = rhs._last_zero_doppler_time; _work_order_id = rhs._work_order_id; _time_diff = rhs._time_diff; _swath_num = rhs._swath_num; _range_spacing = rhs._range_spacing; _azimut_spacing = rhs._azimut_spacing; _line_time_interval = rhs._line_time_interval; _num_output_lines = rhs._num_output_lines; _num_samples_per_line = rhs._num_samples_per_line; _data_type = rhs._data_type; _num_range_lines_per_burst = rhs._num_range_lines_per_burst; _time_diff_zero_doppler = rhs._time_diff_zero_doppler; _data_analysis_flag = rhs._data_analysis_flag; _ant_elev_coor_flag = rhs._ant_elev_coor_flag; _chirp_extract_flag = rhs._chirp_extract_flag; _srgr_flag = rhs._srgr_flag; _dop_cen_flag = rhs._dop_cen_flag; _dop_amb_flag = rhs._dop_amb_flag; _range_spread_comp_flag = rhs._range_spread_comp_flag; _detected_flag = rhs._detected_flag; _look_sum_flag = rhs._look_sum_flag; _rms_equal_flag = rhs._rms_equal_flag; _ant_scal_flag = rhs._ant_scal_flag; _vga_com_echo_flag = rhs._vga_com_echo_flag; _vga_com_cal_flag = rhs._vga_com_cal_flag; _vga_com_nom_time_flag = rhs._vga_com_nom_time_flag; _gm_rng_comp_inv_filter_flag = rhs._gm_rng_comp_inv_filter_flag; _raw_data_analysis = rhs._raw_data_analysis; _start_time_mds1 = rhs._start_time_mds1; _start_time_mds2 = rhs._start_time_mds2; _parameter_code = rhs._parameter_code; _errors_counters = rhs._errors_counters; _image_parameters1 = rhs._image_parameters1; _image_parameters2 = rhs._image_parameters2; _first_proc_range_samp = rhs._first_proc_range_samp; _range_ref = rhs._range_ref; _range_samp_rate = rhs._range_samp_rate; _radar_freq = rhs._radar_freq; _num_looks_range = rhs._num_looks_range; _filter_range = rhs._filter_range; _filter_coef_range = rhs._filter_coef_range; _bandwidth = rhs._bandwidth; _nominal_chirp = rhs._nominal_chirp; _num_lines_proc = rhs._num_lines_proc; _num_look_az = rhs._num_look_az; _look_bw_az = rhs._look_bw_az; _to_bw_az = rhs._to_bw_az; _filter_az = rhs._filter_az; _filter_coef_az = rhs._filter_coef_az; _ax_fm_origin = rhs._ax_fm_origin; _dop_amb_coef = rhs._dop_amb_coef; _calibration_factors = rhs._calibration_factors; _noise_estimation = rhs._noise_estimation; _output_statistics = rhs._output_statistics; _avg_scene_height_ellpsoid = rhs._avg_scene_height_ellpsoid; _echo_comp = rhs._echo_comp; _echo_comp_ratio = rhs._echo_comp_ratio; _init_cal_comp = rhs._init_cal_comp; _init_cal_ratio = rhs._init_cal_ratio; _per_cal_comp = rhs._per_cal_comp; _per_cal_ratio = rhs._per_cal_ratio; _noise_comp = rhs._noise_comp; _noise_comp_ratio = rhs._noise_comp_ratio; _time_first_SS1_echo = rhs._time_first_SS1_echo; _state_vector_time_1_day = rhs._state_vector_time_1_day; _state_vector_time_1_sec = rhs._state_vector_time_1_sec; _state_vector_time_1_microsec = rhs._state_vector_time_1_microsec; _x_pos_1 = rhs._x_pos_1; _y_pos_1 = rhs._y_pos_1; _z_pos_1 = rhs._z_pos_1; _x_vel_1 = rhs._x_vel_1; _y_vel_1 = rhs._y_vel_1; _z_vel_1 = rhs._z_vel_1; _state_vector_time_2_day = rhs._state_vector_time_2_day; _state_vector_time_2_sec = rhs._state_vector_time_2_sec; _state_vector_time_2_microsec = rhs._state_vector_time_2_microsec; _x_pos_2 = rhs._x_pos_2; _y_pos_2 = rhs._y_pos_2; _z_pos_2 = rhs._z_pos_2; _x_vel_2 = rhs._x_vel_2; _y_vel_2 = rhs._y_vel_2; _z_vel_2 = rhs._z_vel_2; _state_vector_time_3_day = rhs._state_vector_time_3_day; _state_vector_time_3_sec = rhs._state_vector_time_3_sec; _state_vector_time_3_microsec = rhs._state_vector_time_3_microsec; _x_pos_3 = rhs._x_pos_3; _y_pos_3 = rhs._y_pos_3; _z_pos_3 = rhs._z_pos_3; _x_vel_3 = rhs._x_vel_3; _y_vel_3 = rhs._y_vel_3; _z_vel_3 = rhs._z_vel_3; _state_vector_time_4_day = rhs._state_vector_time_4_day; _state_vector_time_4_sec = rhs._state_vector_time_4_sec; _state_vector_time_4_microsec = rhs._state_vector_time_4_microsec; _x_pos_4 = rhs._x_pos_4; _y_pos_4 = rhs._y_pos_4; _z_pos_4 = rhs._z_pos_4; _x_vel_4 = rhs._x_vel_4; _y_vel_4 = rhs._y_vel_4; _z_vel_4 = rhs._z_vel_4; _state_vector_time_5_day = rhs._state_vector_time_5_day; _state_vector_time_5_sec = rhs._state_vector_time_5_sec; _state_vector_time_5_microsec = rhs._state_vector_time_5_microsec; _x_pos_5 = rhs._x_pos_5; _y_pos_5 = rhs._y_pos_5; _z_pos_5 = rhs._z_pos_5; _x_vel_5 = rhs._x_vel_5; _y_vel_5 = rhs._y_vel_5; _z_vel_5 = rhs._z_vel_5; _az_fm_rate[0] = rhs._az_fm_rate[0]; _az_fm_rate[1] = rhs._az_fm_rate[1]; _az_fm_rate[2] = rhs._az_fm_rate[2]; _prf_values[0] = rhs._prf_values[0]; _prf_values[1] = rhs._prf_values[1]; _prf_values[2] = rhs._prf_values[2]; _prf_values[3] = rhs._prf_values[3]; _prf_values[4] = rhs._prf_values[4]; _beam_overlap[0]= rhs._beam_overlap[0]; _beam_overlap[1]= rhs._beam_overlap[1]; _beam_overlap[2]= rhs._beam_overlap[2]; _beam_overlap[3]= rhs._beam_overlap[3]; _beam_param[0]= rhs._beam_param[0]; _beam_param[1]= rhs._beam_param[1]; _beam_param[2]= rhs._beam_param[2]; _beam_param[3]= rhs._beam_param[3]; _lines_per_burst[0] =rhs._lines_per_burst[0]; _lines_per_burst[1] =rhs._lines_per_burst[1]; _lines_per_burst[2] =rhs._lines_per_burst[2]; _lines_per_burst[3] =rhs._lines_per_burst[3]; _lines_per_burst[4] =rhs._lines_per_burst[4]; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/MainProcessingParameters.h000066400000000000000000000532511301006202600330410ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef MainProcessingParameters_h #define MainProcessingParameters_h #include #include #include namespace ossimplugins { /** * @ingroup MainProcessingParametersRecord * @brief This class is able to read the ASAR MainProcessingParameters record */ class MainProcessingParameters : public EnvisatAsarRecord { public: /** * @brief Constructor */ MainProcessingParameters(); /** * @brief Destructor */ virtual ~MainProcessingParameters(); /** * @brief This function writes the MainProcessingParameters in a stream */ friend std::ostream& operator<<(std::ostream& os, const MainProcessingParameters& data); /** * @brief This function reads a MainProcessingParameters from a stream */ friend std::istream& operator>>(std::istream& is, MainProcessingParameters& data); /** * @brief Copy constructor */ MainProcessingParameters(const MainProcessingParameters& rhs); /** * @brief Copy operator */ MainProcessingParameters& operator=(const MainProcessingParameters& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new MainProcessingParameters(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new MainProcessingParameters(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief first_zero_doppler_time */ std::string get_first_zero_doppler_time() { return _first_zero_doppler_time; }; /** * @brief attach_flag */ bool get_attach_flag() { return _attach_flag; }; /** * @brief last_zero_doppler_time */ std::string get_last_zero_doppler_time() { return _last_zero_doppler_time; }; /** * @brief work_order_id */ std::string get_work_order_id() { return _work_order_id; }; /** * @brief time_diff */ float get_time_diff() { return _time_diff; }; /** * @brief swath_num */ std::string get_swath_num() { return _swath_num; }; /** * @brief range_spacing */ float get_range_spacing() { return _range_spacing; }; /** * @brief azimut_spacing */ float get_azimut_spacing() { return _azimut_spacing; }; /** * @brief line_time_interval */ float get_line_time_interval() { return _line_time_interval; }; /** * @brief num_output_lines */ unsigned int get_num_output_lines() { return _num_output_lines; }; /** * @brief num_samples_per_line */ unsigned int get_num_samples_per_line() { return _num_samples_per_line; }; /** * @brief data_type */ std::string get_data_type() { return _data_type; }; /** * @brief num_range_lines_per_burst */ unsigned int get_num_range_lines_per_burst() { return _num_range_lines_per_burst; }; /** * @brief time_diff_zero_doppler */ float get_time_diff_zero_doppler() { return _time_diff_zero_doppler; }; /** * @brief data_analysis_flag */ bool get_data_analysis_flag() { return _data_analysis_flag; }; /** * @brief ant_elev_coor_flag */ bool get_ant_elev_coor_flag() { return _ant_elev_coor_flag; }; /** * @brief chirp_extract_flag */ bool get_chirp_extract_flag() { return _chirp_extract_flag; }; /** * @brief srgr_flag */ bool get_srgr_flag() { return _srgr_flag; }; /** * @brief dop_cen_flag */ bool get_dop_cen_flag() { return _dop_cen_flag; }; /** * @brief dop_amb_flag */ bool get_dop_amb_flag() { return _dop_amb_flag; }; /** * @brief range_spread_comp_flag */ bool get_range_spread_comp_flag() { return _range_spread_comp_flag; }; /** * @brief detected_flag */ bool get_detected_flag() { return _detected_flag; }; /** * @brief look_sum_flag */ bool get_look_sum_flag() { return _look_sum_flag; }; /** * @brief rms_equal_flag */ bool get_rms_equal_flag() { return _rms_equal_flag; }; /** * @brief ant_scal_flag */ bool get_ant_scal_flag() { return _ant_scal_flag; }; /** * @brief vga_com_echo_flag */ bool get_vga_com_echo_flag() { return _vga_com_echo_flag; }; /** * @brief vga_com_cal_flag */ bool get_vga_com_cal_flag() { return _vga_com_cal_flag; }; /** * @brief vga_com_nom_time_flag */ bool get_vga_com_nom_time_flag() { return _vga_com_nom_time_flag; }; /** * @brief gm_rng_comp_inv_filter_flag */ bool get_gm_rng_comp_inv_filter_flag() { return _gm_rng_comp_inv_filter_flag; }; /** * @brief raw_data_analysis */ std::string get_raw_data_analysis() { return _raw_data_analysis; }; /** * @brief start_time_mds1 */ std::string get_start_time_mds1() { return _start_time_mds1; }; /** * @brief start_time_mds2 */ std::string get_start_time_mds2() { return _start_time_mds2; }; /** * @brief parameter_code */ std::string get_parameter_code() { return _parameter_code; }; /** * @brief errors_counters */ std::string get_errors_counters() { return _errors_counters; }; /** * @brief image_parameters block1 */ std::string get_image_parameters1() { return _image_parameters1; }; /** * @brief prf_values[5] */ float* get_prf_values() { return _prf_values; }; /** * @brief prf (i.e prf_values[0]) */ float get_prf() { return _prf_values[0]; }; /** * @brief image_parameters block2 */ std::string get_image_parameters2() { return _image_parameters2; }; /** * @brief first_proc_range_samp */ unsigned int get_first_proc_range_samp() { return _first_proc_range_samp; }; /** * @brief range_ref */ float get_range_ref() { return _range_ref; }; /** * @brief range_samp_rate */ float get_range_samp_rate() { return _range_samp_rate; }; /** * @brief radar_freq */ float get_radar_freq() { return _radar_freq; }; /** * @brief num_looks_range */ unsigned short get_num_looks_range() { return _num_looks_range; }; /** * @brief filter_range */ std::string get_filter_range() { return _filter_range; }; /** * @brief filter_coef_range */ float get_filter_coef_range() { return _filter_coef_range; }; /** * @brief bandwidth */ std::string get_bandwidth() { return _bandwidth; }; /** * @brief nominal_chirp */ std::string get_nominal_chirp() { return _nominal_chirp; }; /** * @brief num_lines_proc */ unsigned int get_num_lines_proc() { return _num_lines_proc; }; /** * @brief num_look_az */ unsigned short get_num_look_az() { return _num_look_az; }; /** * @brief look_bw_az */ float get_look_bw_az() { return _look_bw_az; }; /** * @brief to_bw_az */ float get_to_bw_az() { return _to_bw_az; }; /** * @brief filter_az */ std::string get_filter_az() { return _filter_az; }; /** * @brief filter_coef_az */ float get_filter_coef_az() { return _filter_coef_az; }; /** * @brief az_fm_rate[3] */ float* get_az_fm_rate() { return _az_fm_rate; }; /** * @brief ax_fm_origin */ float get_ax_fm_origin() { return _ax_fm_origin; }; /** * @brief dop_amb_coef */ float get_dop_amb_coef() { return _dop_amb_coef; }; /** * @brief calibration_factors */ std::string get_calibration_factors() { return _calibration_factors; }; /** * @brief noise_estimation */ std::string get_noise_estimation() { return _noise_estimation; }; /** * @brief output_statistics */ std::string get_output_statistics() { return _output_statistics; }; /** * @brief avg_scene_height_ellpsoid */ float get_avg_scene_height_ellpsoid() { return _avg_scene_height_ellpsoid; }; /** * @brief echo_comp */ std::string get_echo_comp() { return _echo_comp; }; /** * @brief echo_comp_ratio */ std::string get_echo_comp_ratio() { return _echo_comp_ratio; }; /** * @brief init_cal_comp */ std::string get_init_cal_comp() { return _init_cal_comp; }; /** * @brief init_cal_ratio */ std::string get_init_cal_ratio() { return _init_cal_ratio; }; /** * @brief per_cal_comp */ std::string get_per_cal_comp() { return _per_cal_comp; }; /** * @brief per_cal_ratio */ std::string get_per_cal_ratio() { return _per_cal_ratio; }; /** * @brief noise_comp */ std::string get_noise_comp() { return _noise_comp; }; /** * @brief noise_comp_ratio */ std::string get_noise_comp_ratio() { return _noise_comp_ratio; }; /** * @brief beam_overlap[4] */ unsigned int* get_beam_overlap() { return _beam_overlap; }; /** * @brief beam_param[4] */ float* get_beam_param() { return _beam_param; }; /** * @brief lines_per_burst[5] */ unsigned int* get_lines_per_burst() { return _lines_per_burst; }; /** * @brief time_first_SS1_echo */ std::string get_time_first_SS1_echo() { return _time_first_SS1_echo; }; /** * @brief state_vector_time_1 day */ int get_state_vector_time_1_day() { return _state_vector_time_1_day; }; /** * @brief state_vector_time_1 sec */ unsigned int get_state_vector_time_1_sec() { return _state_vector_time_1_sec; }; /** * @brief state_vector_time_1 microsec */ unsigned int get_state_vector_time_1_microsec() { return _state_vector_time_1_microsec; }; /** * @brief x_pos_1 */ int get_x_pos_1() { return _x_pos_1; }; /** * @brief y_pos_1 */ int get_y_pos_1() { return _y_pos_1; }; /** * @brief z_pos_1 */ int get_z_pos_1() { return _z_pos_1; }; /** * @brief x_vel_1 */ int get_x_vel_1() { return _x_vel_1; }; /** * @brief y_vel_1 */ int get_y_vel_1() { return _y_vel_1; }; /** * @brief z_vel_1 */ int get_z_vel_1() { return _z_vel_1; }; /** * @brief state_vector_time_2 day */ int get_state_vector_time_2_day() { return _state_vector_time_2_day; }; /** * @brief state_vector_time_2 sec */ unsigned int get_state_vector_time_2_sec() { return _state_vector_time_2_sec; }; /** * @brief state_vector_time_1 microsec */ unsigned int get_state_vector_time_2_microsec() { return _state_vector_time_2_microsec; }; /** * @brief x_pos_2 */ int get_x_pos_2() { return _x_pos_2; }; /** * @brief y_pos_2 */ int get_y_pos_2() { return _y_pos_2; }; /** * @brief z_pos_2 */ int get_z_pos_2() { return _z_pos_2; }; /** * @brief x_vel_2 */ int get_x_vel_2() { return _x_vel_2; }; /** * @brief y_vel_2 */ int get_y_vel_2() { return _y_vel_2; }; /** * @brief z_vel_2 */ int get_z_vel_2() { return _z_vel_2; }; /** * @brief state_vector_time_3 day */ int get_state_vector_time_3_day() { return _state_vector_time_3_day; }; /** * @brief state_vector_time_3 sec */ unsigned int get_state_vector_time_3_sec() { return _state_vector_time_3_sec; }; /** * @brief state_vector_time_3 microsec */ unsigned int get_state_vector_time_3_microsec() { return _state_vector_time_3_microsec; }; /** * @brief x_pos_3 */ int get_x_pos_3() { return _x_pos_3; }; /** * @brief y_pos_3 */ int get_y_pos_3() { return _y_pos_3; }; /** * @brief z_pos_3 */ int get_z_pos_3() { return _z_pos_3; }; /** * @brief x_vel_3 */ int get_x_vel_3() { return _x_vel_3; }; /** * @brief y_vel_3 */ int get_y_vel_3() { return _y_vel_3; }; /** * @brief z_vel_3 */ int get_z_vel_3() { return _z_vel_3; }; /** * @brief state_vector_time_4 day */ int get_state_vector_time_4_day() { return _state_vector_time_4_day; }; /** * @brief state_vector_time_1 sec */ unsigned int get_state_vector_time_4_sec() { return _state_vector_time_4_sec; }; /** * @brief state_vector_time_4 microsec */ unsigned int get_state_vector_time_4_microsec() { return _state_vector_time_4_microsec; }; /** * @brief x_pos_4 */ int get_x_pos_4() { return _x_pos_4; }; /** * @brief y_pos_4 */ int get_y_pos_4() { return _y_pos_4; }; /** * @brief z_pos_4 */ int get_z_pos_4() { return _z_pos_4; }; /** * @brief x_vel_4 */ int get_x_vel_4() { return _x_vel_4; }; /** * @brief y_vel_4 */ int get_y_vel_4() { return _y_vel_4; }; /** * @brief z_vel_4 */ int get_z_vel_4() { return _z_vel_4; }; /** * @brief state_vector_time_5 day */ int get_state_vector_time_5_day() { return _state_vector_time_5_day; }; /** * @brief state_vector_time_5 sec */ unsigned int get_state_vector_time_5_sec() { return _state_vector_time_5_sec; }; /** * @brief state_vector_time_5 microsec */ unsigned int get_state_vector_time_5_microsec() { return _state_vector_time_5_microsec; }; /** * @brief x_pos_5 */ int get_x_pos_5() { return _x_pos_5; }; /** * @brief y_pos_5 */ int get_y_pos_5() { return _y_pos_5; }; /** * @brief z_pos_5 */ int get_z_pos_5() { return _z_pos_5; }; /** * @brief x_vel_5 */ int get_x_vel_5() { return _x_vel_5; }; /** * @brief y_vel_5 */ int get_y_vel_5() { return _y_vel_5; }; /** * @brief z_vel_5 */ int get_z_vel_5() { return _z_vel_5; }; /** * @brief first_zero_doppler_time */ std::string _first_zero_doppler_time; /** * @brief attach_flag */ bool _attach_flag; /** * @brief last_zero_doppler_time */ std::string _last_zero_doppler_time; /** * @brief work_order_id */ std::string _work_order_id; /** * @brief time_diff */ float _time_diff; /** * @brief swath_num */ std::string _swath_num; /** * @brief range_spacing */ float _range_spacing; /** * @brief azimut_spacing */ float _azimut_spacing; /** * @brief line_time_interval */ float _line_time_interval; /** * @brief num_output_lines */ unsigned int _num_output_lines; /** * @brief num_samples_per_line */ unsigned int _num_samples_per_line; /** * @brief data_type */ std::string _data_type; /** * @brief num_range_lines_per_burst */ unsigned int _num_range_lines_per_burst; /** * @brief time_diff_zero_doppler */ float _time_diff_zero_doppler; /** * @brief data_analysis_flag */ bool _data_analysis_flag; /** * @brief ant_elev_coor_flag */ bool _ant_elev_coor_flag; /** * @brief chirp_extract_flag */ bool _chirp_extract_flag; /** * @brief srgr_flag */ bool _srgr_flag; /** * @brief dop_cen_flag */ bool _dop_cen_flag; /** * @brief dop_amb_flag */ bool _dop_amb_flag; /** * @brief range_spread_comp_flag */ bool _range_spread_comp_flag; /** * @brief detected_flag */ bool _detected_flag; /** * @brief look_sum_flag */ bool _look_sum_flag; /** * @brief rms_equal_flag */ bool _rms_equal_flag; /** * @brief ant_scal_flag */ bool _ant_scal_flag; /** * @brief vga_com_echo_flag */ bool _vga_com_echo_flag; /** * @brief vga_com_cal_flag */ bool _vga_com_cal_flag; /** * @brief vga_com_nom_time_flag */ bool _vga_com_nom_time_flag; /** * @brief gm_rng_comp_inv_filter_flag */ bool _gm_rng_comp_inv_filter_flag; /** * @brief raw_data_analysis */ std::string _raw_data_analysis; /** * @brief start_time_mds1 */ std::string _start_time_mds1; /** * @brief start_time_mds2 */ std::string _start_time_mds2; /** * @brief parameter_code */ std::string _parameter_code; /** * @brief errors_counters */ std::string _errors_counters; /** * @brief image_parameters block 1 */ std::string _image_parameters1; /** * @brief PRF */ float _prf_values[5]; /** * @brief image_parameters block 2 */ std::string _image_parameters2; /** * @brief first_proc_range_samp */ unsigned int _first_proc_range_samp; /** * @brief range_ref */ float _range_ref; /** * @brief range_samp_rate */ float _range_samp_rate; /** * @brief radar_freq */ float _radar_freq; /** * @brief num_looks_range */ unsigned short _num_looks_range; /** * @brief filter_range */ std::string _filter_range; /** * @brief filter_coef_range */ float _filter_coef_range; /** * @brief bandwidth */ std::string _bandwidth; /** * @brief nominal_chirp */ std::string _nominal_chirp; /** * @brief num_lines_proc */ unsigned int _num_lines_proc; /** * @brief num_look_az */ unsigned short _num_look_az; /** * @brief look_bw_az */ float _look_bw_az; /** * @brief to_bw_az */ float _to_bw_az; /** * @brief filter_az */ std::string _filter_az; /** * @brief filter_coef_az */ float _filter_coef_az; /** * @brief az_fm_rate[3] */ float _az_fm_rate[3]; /** * @brief ax_fm_origin */ float _ax_fm_origin; /** * @brief dop_amb_coef */ float _dop_amb_coef; /** * @brief calibration_factors */ std::string _calibration_factors; /** * @brief noise_estimation */ std::string _noise_estimation; /** * @brief output_statistics */ std::string _output_statistics; /** * @brief avg_scene_height_ellpsoid */ float _avg_scene_height_ellpsoid; /** * @brief echo_comp */ std::string _echo_comp; /** * @brief echo_comp_ratio */ std::string _echo_comp_ratio; /** * @brief init_cal_comp */ std::string _init_cal_comp; /** * @brief init_cal_ratio */ std::string _init_cal_ratio; /** * @brief per_cal_comp */ std::string _per_cal_comp; /** * @brief per_cal_ratio */ std::string _per_cal_ratio; /** * @brief noise_comp */ std::string _noise_comp; /** * @brief noise_comp_ratio */ std::string _noise_comp_ratio; /** * @brief beam_overlap[4] */ unsigned int _beam_overlap[4]; /** * @brief beam_overlap[4] */ float _beam_param[4]; /** * @brief lines_per_burst[5] */ unsigned int _lines_per_burst[5]; /** * @brief time_first_SS1_echo */ std::string _time_first_SS1_echo; /** * @brief state_vector_time_1_day */ int _state_vector_time_1_day; /** * @brief state_vector_time_1_sec */ unsigned int _state_vector_time_1_sec; /** * @brief state_vector_time_1_microsec */ unsigned int _state_vector_time_1_microsec; /** * @brief x_pos_1 */ int _x_pos_1; /** * @brief y_pos_1 */ int _y_pos_1; /** * @brief z_pos_1 */ int _z_pos_1; /** * @brief x_vel_1 */ int _x_vel_1; /** * @brief y_vel_1 */ int _y_vel_1; /** * @brief z_vel_1 */ int _z_vel_1; /** * @brief state_vector_time_2_day */ int _state_vector_time_2_day; /** * @brief state_vector_time_2_sec */ unsigned int _state_vector_time_2_sec; /** * @brief state_vector_time_2_microsec */ unsigned int _state_vector_time_2_microsec; /** * @brief x_pos_2 */ int _x_pos_2; /** * @brief y_pos_2 */ int _y_pos_2; /** * @brief z_pos_2 */ int _z_pos_2; /** * @brief x_vel_2 */ int _x_vel_2; /** * @brief y_vel_2 */ int _y_vel_2; /** * @brief z_vel_2 */ int _z_vel_2; /** * @brief state_vector_time_3_day */ int _state_vector_time_3_day; /** * @brief state_vector_time_3_sec */ unsigned int _state_vector_time_3_sec; /** * @brief state_vector_time_3_microsec */ unsigned int _state_vector_time_3_microsec; /** * @brief x_pos_3 */ int _x_pos_3; /** * @brief y_pos_3 */ int _y_pos_3; /** * @brief z_pos_3 */ int _z_pos_3; /** * @brief x_vel_3 */ int _x_vel_3; /** * @brief y_vel_3 */ int _y_vel_3; /** * @brief z_vel_3 */ int _z_vel_3; /** * @brief state_vector_time_4_day */ int _state_vector_time_4_day; /** * @brief state_vector_time_4_sec */ unsigned int _state_vector_time_4_sec; /** * @brief state_vector_time_4_microsec */ unsigned int _state_vector_time_4_microsec; /** * @brief x_pos_4 */ int _x_pos_4; /** * @brief y_pos_4 */ int _y_pos_4; /** * @brief z_pos_4 */ int _z_pos_4; /** * @brief x_vel_4 */ int _x_vel_4; /** * @brief y_vel_4 */ int _y_vel_4; /** * @brief z_vel_4 */ int _z_vel_4; /** * @brief state_vector_time_5_day */ int _state_vector_time_5_day; /** * @brief state_vector_time_5_sec */ unsigned int _state_vector_time_5_sec; /** * @brief state_vector_time_5_microsec */ unsigned int _state_vector_time_5_microsec; /** * @brief x_pos_5 */ int _x_pos_5; /** * @brief y_pos_5 */ int _y_pos_5; /** * @brief z_pos_5 */ int _z_pos_5; /** * @brief x_vel_5 */ int _x_vel_5; /** * @brief y_vel_5 */ int _y_vel_5; /** * @brief z_vel_5 */ int _z_vel_5; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/SQ_ADSR.cpp000066400000000000000000000272671301006202600275730ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { SQ_ADSR::SQ_ADSR() : EnvisatAsarRecord("sq_adsr_rec") { } SQ_ADSR::~SQ_ADSR() { } std::ostream& operator<<(std::ostream& os, const SQ_ADSR& data) { os<<"zero_doppler_time:"<>(std::istream& is, SQ_ADSR& data) { // char buf64[65]; // buf64[64] = '\0'; // char buf32[33]; // buf32[32] = '\0'; // char buf27[28]; // buf27[27] = '\0'; // char buf20[21]; // buf20[20] = '\0'; char buf16[17]; buf16[16]='\0'; char buf15[16]; buf15[15] = '\0'; // char buf14[15]; // buf14[14] = '\0'; // char buf13[14]; // buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; // char buf11[12]; // buf11[11] = '\0'; // char buf10[11]; // buf10[10] = '\0'; // char buf9[10]; // buf9[9] = '\0'; // char buf8[9]; // buf8[8] = '\0'; char buf7[8]; buf7[7] = '\0'; // char buf6[7]; // buf6[6] = '\0'; // char buf5[6]; // buf5[5] = '\0'; // char buf4[5]; // buf4[4] = '\0'; // char buf3[4]; // buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; // char buf1[1]; // not used avoid warning is.read(buf12,12); data._zero_doppler_time = buf12; is.read((char*)&(data._attach_flag),1); is.read((char*)&(data._input_mean_flag),1); is.read((char*)&(data._input_std_dev_flag),1); is.read((char*)&(data._input_gaps_flag),1); is.read((char*)&(data._input_missing_lines_flag),1); is.read((char*)&(data._dop_cen_flag),1); is.read((char*)&(data._dop_amb_flag),1); is.read((char*)&(data._output_mean_flag),1); is.read((char*)&(data._output_std_dev_flag),1); is.read((char*)&(data._chirp_flag),1); is.read((char*)&(data._missing_data_set_flag),1); is.read((char*)&(data._invalid_downlink_flag),1); is.read(buf7,7); is.read((char*)&(data._thres_chirp_broadening),4); data.SwitchEndian(data._thres_chirp_broadening); is.read((char*)&(data._thresh_chirp_sidelobe),4); data.SwitchEndian(data._thresh_chirp_sidelobe); is.read((char*)&(data._thresh_chirp_islr),4); data.SwitchEndian(data._thresh_chirp_islr); is.read((char*)&(data._thresh_input_mean),4); data.SwitchEndian(data._thresh_input_mean); is.read((char*)&(data._exp_input_mean),4); data.SwitchEndian(data._exp_input_mean); is.read((char*)&(data._thresh_input_std_dev),4); data.SwitchEndian(data._thresh_input_std_dev); is.read((char*)&(data._exp_input_std_dev),4); data.SwitchEndian(data._exp_input_std_dev); is.read((char*)&(data._thresh_dop_cen),4); data.SwitchEndian(data._thresh_dop_cen); is.read((char*)&(data._thresh_dop_amb),4); data.SwitchEndian(data._thresh_dop_amb); is.read((char*)&(data._thresh_output_mean),4); data.SwitchEndian(data._thresh_output_mean); is.read((char*)&(data._exp_output_mean),4); data.SwitchEndian(data._exp_output_mean); is.read((char*)&(data._thresh_output_std_dev),4); data.SwitchEndian(data._thresh_output_std_dev); is.read((char*)&(data._exp_output_std_dev),4); data.SwitchEndian(data._exp_output_std_dev); is.read((char*)&(data._thresh_input_missing_lines),4); data.SwitchEndian(data._thresh_input_missing_lines); is.read((char*)&(data._thresh_input_gaps),4); data.SwitchEndian(data._thresh_input_gaps); is.read((char*)&(data._lines_per_gaps),4); data.SwitchEndian(data._lines_per_gaps); is.read(buf15,15); is.read((char*)&(data._input_mean[0]),4); data.SwitchEndian(data._input_mean[0]); is.read((char*)&(data._input_mean[1]),4); data.SwitchEndian(data._input_mean[1]); is.read((char*)&(data._input_std_dev[0]),4); data.SwitchEndian(data._input_std_dev[0]); is.read((char*)&(data._input_std_dev[1]),4); data.SwitchEndian(data._input_std_dev[1]); is.read((char*)&(data._num_gaps),4); data.SwitchEndian(data._num_gaps); is.read((char*)&(data._num_missing_lines),4); data.SwitchEndian(data._num_missing_lines); is.read((char*)&(data._output_mean[0]),4); data.SwitchEndian(data._output_mean[0]); is.read((char*)&(data._output_mean[1]),4); data.SwitchEndian(data._output_mean[1]); is.read((char*)&(data._output_std_dev[0]),4); data.SwitchEndian(data._output_std_dev[0]); is.read((char*)&(data._output_std_dev[1]),4); data.SwitchEndian(data._output_std_dev[1]); is.read((char*)&(data._tot_errors),4); data.SwitchEndian(data._tot_errors); is.read(buf16,16); return is; } SQ_ADSR::SQ_ADSR(const SQ_ADSR& rhs): EnvisatAsarRecord(rhs), _zero_doppler_time(rhs._zero_doppler_time), _attach_flag(rhs._attach_flag), _input_mean_flag(rhs._input_mean_flag), _input_std_dev_flag(rhs._input_std_dev_flag), _input_gaps_flag(rhs._input_gaps_flag), _input_missing_lines_flag(rhs._input_missing_lines_flag), _dop_cen_flag(rhs._dop_cen_flag), _dop_amb_flag(rhs._dop_amb_flag), _output_mean_flag(rhs._output_mean_flag), _output_std_dev_flag(rhs._output_std_dev_flag), _chirp_flag(rhs._chirp_flag), _missing_data_set_flag(rhs._missing_data_set_flag), _invalid_downlink_flag(rhs._invalid_downlink_flag), _thres_chirp_broadening(rhs._thres_chirp_broadening), _thresh_chirp_sidelobe(rhs._thresh_chirp_sidelobe), _thresh_chirp_islr(rhs._thresh_chirp_islr), _thresh_input_mean(rhs._thresh_input_mean), _exp_input_mean(rhs._exp_input_mean), _thresh_input_std_dev(rhs._thresh_input_std_dev), _exp_input_std_dev(rhs._exp_input_std_dev), _thresh_dop_cen(rhs._thresh_dop_cen), _thresh_dop_amb(rhs._thresh_dop_amb), _thresh_output_mean(rhs._thresh_output_mean), _exp_output_mean(rhs._exp_output_mean), _thresh_output_std_dev(rhs._thresh_output_std_dev), _exp_output_std_dev(rhs._exp_output_std_dev), _thresh_input_missing_lines(rhs._thresh_input_missing_lines), _thresh_input_gaps(rhs._thresh_input_gaps), _lines_per_gaps(rhs._lines_per_gaps), _num_gaps(rhs._num_gaps), _num_missing_lines(rhs._num_missing_lines), _tot_errors(rhs._tot_errors) { _input_mean[0] = rhs._input_mean[0]; _input_mean[1] = rhs._input_mean[1]; _input_std_dev[0] = rhs._input_std_dev[0]; _input_std_dev[1] = rhs._input_std_dev[1]; _output_mean[0] = rhs._output_mean[0]; _output_mean[1] = rhs._output_mean[1]; _output_std_dev[0] = rhs._output_std_dev[0]; _output_std_dev[1] = rhs._output_std_dev[1]; } SQ_ADSR& SQ_ADSR::operator=(const SQ_ADSR& rhs) { _zero_doppler_time = rhs._zero_doppler_time; _attach_flag = rhs._attach_flag; _input_mean_flag = rhs._input_mean_flag; _input_std_dev_flag = rhs._input_std_dev_flag; _input_gaps_flag = rhs._input_gaps_flag; _input_missing_lines_flag = rhs._input_missing_lines_flag; _dop_cen_flag = rhs._dop_cen_flag; _dop_amb_flag = rhs._dop_amb_flag; _output_mean_flag = rhs._output_mean_flag; _output_std_dev_flag = rhs._output_std_dev_flag; _chirp_flag = rhs._chirp_flag; _missing_data_set_flag = rhs._missing_data_set_flag; _invalid_downlink_flag = rhs._invalid_downlink_flag; _thres_chirp_broadening = rhs._thres_chirp_broadening; _thresh_chirp_sidelobe = rhs._thresh_chirp_sidelobe; _thresh_chirp_islr = rhs._thresh_chirp_islr; _thresh_input_mean = rhs._thresh_input_mean; _exp_input_mean = rhs._exp_input_mean; _thresh_input_std_dev = rhs._thresh_input_std_dev; _exp_input_std_dev = rhs._exp_input_std_dev; _thresh_dop_cen = rhs._thresh_dop_cen; _thresh_dop_amb = rhs._thresh_dop_amb; _thresh_output_mean = rhs._thresh_output_mean; _exp_output_mean = rhs._exp_output_mean; _thresh_output_std_dev = rhs._thresh_output_std_dev; _exp_output_std_dev = rhs._exp_output_std_dev; _thresh_input_missing_lines = rhs._thresh_input_missing_lines; _thresh_input_gaps = rhs._thresh_input_gaps; _lines_per_gaps = rhs._lines_per_gaps; _num_gaps = rhs._num_gaps; _num_missing_lines = rhs._num_missing_lines; _tot_errors = rhs._tot_errors; _input_mean[0] = rhs._input_mean[0]; _input_mean[1] = rhs._input_mean[1]; _input_std_dev[0] = rhs._input_std_dev[0]; _input_std_dev[1] = rhs._input_std_dev[1]; _output_mean[0] = rhs._output_mean[0]; _output_mean[1] = rhs._output_mean[1]; _output_std_dev[0] = rhs._output_std_dev[0]; _output_std_dev[1] = rhs._output_std_dev[1]; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/SQ_ADSR.h000066400000000000000000000202071301006202600272230ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef SQ_ADSR_h #define SQ_ADSR_h #include #include namespace ossimplugins { /** * @ingroup SQ_ADSRRecord * @brief This class is able to read the ASAR SQ_ADSR record */ class SQ_ADSR : public EnvisatAsarRecord { public: /** * @brief Constructor */ SQ_ADSR(); /** * @brief Destructor */ virtual ~SQ_ADSR(); /** * @brief This function write the SQ_ADSR in a stream */ friend std::ostream& operator<<(std::ostream& os, const SQ_ADSR& data); /** * @brief This function read a SQ_ADSR from a stream */ friend std::istream& operator>>(std::istream& is, SQ_ADSR& data); /** * @brief Copy constructor */ SQ_ADSR(const SQ_ADSR& rhs); /** * @brief Copy operator */ SQ_ADSR& operator=(const SQ_ADSR& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new SQ_ADSR(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new SQ_ADSR(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief zero_doppler_time */ std::string get_zero_doppler_time() { return _zero_doppler_time; }; /** * @brief attach_flag */ bool get_attach_flag() { return _attach_flag; }; /** * @brief input_mean_flag */ bool get_input_mean_flag() { return _input_mean_flag; }; /** * @brief input_std_dev_flag */ bool get_input_std_dev_flag() { return _input_std_dev_flag; }; /** * @brief input_gaps_flag */ bool get_input_gaps_flag() { return _input_gaps_flag; }; /** * @brief input_missing_lines_flag */ bool get_input_missing_lines_flag() { return _input_missing_lines_flag; }; /** * @brief dop_cen_flag */ bool get_dop_cen_flag() { return _dop_cen_flag; }; /** * @brief dop_amb_flag */ bool get_dop_amb_flag() { return _dop_amb_flag; }; /** * @brief output_mean_flag */ bool get_output_mean_flag() { return _output_mean_flag; }; /** * @brief output_std_dev_flag */ bool get_output_std_dev_flag() { return _output_std_dev_flag; }; /** * @brief chirp_flag */ bool get_chirp_flag() { return _chirp_flag; }; /** * @brief missing_data_set_flag */ bool get_missing_data_set_flag() { return _missing_data_set_flag; }; /** * @brief invalid_downlink_flag */ bool get_invalid_downlink_flag() { return _invalid_downlink_flag; }; /** * @brief thres_chirp_broadening */ float get_thres_chirp_broadening() { return _thres_chirp_broadening; }; /** * @brief thresh_chirp_sidelobe */ float get_thresh_chirp_sidelobe() { return _thresh_chirp_sidelobe; }; /** * @brief thresh_chirp_islr */ float get_thresh_chirp_islr() { return _thresh_chirp_islr; }; /** * @brief thresh_input_mean */ float get_thresh_input_mean() { return _thresh_input_mean; }; /** * @brief exp_input_mean */ float get_exp_input_mean() { return _exp_input_mean; }; /** * @brief thresh_input_std_dev */ float get_thresh_input_std_dev() { return _thresh_input_std_dev; }; /** * @brief exp_input_std_dev */ float get_exp_input_std_dev() { return _exp_input_std_dev; }; /** * @brief thresh_dop_cen */ float get_thresh_dop_cen() { return _thresh_dop_cen; }; /** * @brief thresh_dop_amb */ float get_thresh_dop_amb() { return _thresh_dop_amb; }; /** * @brief thresh_output_mean */ float get_thresh_output_mean() { return _thresh_output_mean; }; /** * @brief exp_output_mean */ float get_exp_output_mean() { return _exp_output_mean; }; /** * @brief thresh_output_std_dev */ float get_thresh_output_std_dev() { return _thresh_output_std_dev; }; /** * @brief exp_output_std_dev */ float get_exp_output_std_dev() { return _exp_output_std_dev; }; /** * @brief thresh_input_missing_lines */ float get_thresh_input_missing_lines() { return _thresh_input_missing_lines; }; /** * @brief thresh_input_gaps */ float get_thresh_input_gaps() { return _thresh_input_gaps; }; /** * @brief lines_per_gaps */ unsigned int get_lines_per_gaps() { return _lines_per_gaps; }; /** * @brief input_mean[2] */ float* get_input_mean() { return _input_mean; }; /** * @brief input_std_dev[2] */ float* get_input_std_dev() { return _input_std_dev; }; /** * @brief num_gaps */ float get_num_gaps() { return _num_gaps; }; /** * @brief num_missing_lines */ float get_num_missing_lines() { return _num_missing_lines; }; /** * @brief output_mean[2] */ float* get_output_mean() { return _output_mean; }; /** * @brief output_std_dev[2] */ float* get_output_std_dev() { return _output_std_dev; }; /** * @brief tot_errors */ unsigned int get_tot_errors() { return _tot_errors; }; /** * @brief zero_doppler_time */ std::string _zero_doppler_time; /** * @brief attach_flag */ bool _attach_flag; /** * @brief input_mean_flag */ bool _input_mean_flag; /** * @brief input_std_dev_flag */ bool _input_std_dev_flag; /** * @brief input_gaps_flag */ bool _input_gaps_flag; /** * @brief input_missing_lines_flag */ bool _input_missing_lines_flag; /** * @brief dop_cen_flag */ bool _dop_cen_flag; /** * @brief dop_amb_flag */ bool _dop_amb_flag; /** * @brief output_mean_flag */ bool _output_mean_flag; /** * @brief output_std_dev_flag */ bool _output_std_dev_flag; /** * @brief chirp_flag */ bool _chirp_flag; /** * @brief missing_data_set_flag */ bool _missing_data_set_flag; /** * @brief invalid_downlink_flag */ bool _invalid_downlink_flag; /** * @brief thres_chirp_broadening */ float _thres_chirp_broadening; /** * @brief thresh_chirp_sidelobe */ float _thresh_chirp_sidelobe; /** * @brief thresh_chirp_islr */ float _thresh_chirp_islr; /** * @brief thresh_input_mean */ float _thresh_input_mean; /** * @brief exp_input_mean */ float _exp_input_mean; /** * @brief thresh_input_std_dev */ float _thresh_input_std_dev; /** * @brief exp_input_std_dev */ float _exp_input_std_dev; /** * @brief thresh_dop_cen */ float _thresh_dop_cen; /** * @brief thresh_dop_amb */ float _thresh_dop_amb; /** * @brief thresh_output_mean */ float _thresh_output_mean; /** * @brief exp_output_mean */ float _exp_output_mean; /** * @brief thresh_output_std_dev */ float _thresh_output_std_dev; /** * @brief exp_output_std_dev */ float _exp_output_std_dev; /** * @brief thresh_input_missing_lines */ float _thresh_input_missing_lines; /** * @brief thresh_input_gaps */ float _thresh_input_gaps; /** * @brief lines_per_gaps */ unsigned int _lines_per_gaps; /** * @brief input_mean[2] */ float _input_mean[2]; /** * @brief input_std_dev[2] */ float _input_std_dev[2]; /** * @brief num_gaps */ float _num_gaps; /** * @brief num_missing_lines */ float _num_missing_lines; /** * @brief output_mean[2] */ float _output_mean[2]; /** * @brief output_std_dev[2] */ float _output_std_dev[2]; /** * @brief tot_errors */ unsigned int _tot_errors; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/SRGRConversionParameters.cpp000066400000000000000000000065001301006202600332710ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { SRGRConversionParameters::SRGRConversionParameters() : EnvisatAsarRecord("SRGRConversionParameters_rec") { } SRGRConversionParameters::~SRGRConversionParameters() { } std::ostream& operator<<(std::ostream& os, const SRGRConversionParameters& data) { os<<"first_zero_doppler_time_day:"<>(std::istream& is, SRGRConversionParameters& data) { char buf14[15]; buf14[14] = '\0'; // char buf12[13]; // buf12[12] = '\0'; is.read((char*)&(data._first_zero_doppler_time_day),4); data.SwitchEndian(data._first_zero_doppler_time_day); is.read((char*)&(data._first_zero_doppler_time_sec),4); data.SwitchEndian(data._first_zero_doppler_time_sec); is.read((char*)&(data._first_zero_doppler_time_microsec),4); data.SwitchEndian(data._first_zero_doppler_time_microsec); is.read((char*)&(data._attach_flag),1); is.read((char*)&(data._slant_range_time),4); data.SwitchEndian(data._slant_range_time); is.read((char*)&(data._ground_range_origin),4); data.SwitchEndian(data._ground_range_origin); for (int i = 0; i<5; i++) { is.read((char*)&(data._srgr_coef[i]),4); data.SwitchEndian(data._srgr_coef[i]); } is.read(buf14,14); return is; } SRGRConversionParameters::SRGRConversionParameters(const SRGRConversionParameters& rhs): EnvisatAsarRecord(rhs), _first_zero_doppler_time_day(rhs._first_zero_doppler_time_day), _first_zero_doppler_time_sec(rhs._first_zero_doppler_time_sec), _first_zero_doppler_time_microsec(rhs._first_zero_doppler_time_microsec), _attach_flag(rhs._attach_flag), _slant_range_time(rhs._slant_range_time), _ground_range_origin(rhs._ground_range_origin) { for (int i = 0; i<5; i++) { _srgr_coef[i] = rhs._srgr_coef[i]; } } SRGRConversionParameters& SRGRConversionParameters::operator=(const SRGRConversionParameters& rhs) { _first_zero_doppler_time_day = rhs._first_zero_doppler_time_day; _first_zero_doppler_time_sec = rhs._first_zero_doppler_time_sec; _first_zero_doppler_time_microsec = rhs._first_zero_doppler_time_microsec; _attach_flag = rhs._attach_flag; _slant_range_time = rhs._slant_range_time; for (int i = 0; i<5; i++) { _srgr_coef[i] = rhs._srgr_coef[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/SRGRConversionParameters.h000066400000000000000000000066161301006202600327460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef SRGRConversionParameters_h #define SRGRConversionParameters_h #include #include namespace ossimplugins { /** * @ingroup SRGRConversionParametersRecord * @brief This class is able to read the ASAR SRGRConversionParameters record */ class SRGRConversionParameters : public EnvisatAsarRecord { public: /** * @brief Constructor */ SRGRConversionParameters(); /** * @brief Destructor */ virtual ~SRGRConversionParameters(); /** * @brief This function writes the SRGRConversionParameters in a stream */ friend std::ostream& operator<<(std::ostream& os, const SRGRConversionParameters& data); /** * @brief This function reads a SRGRConversionParameters from a stream */ friend std::istream& operator>>(std::istream& is, SRGRConversionParameters& data); /** * @brief Copy constructor */ SRGRConversionParameters(const SRGRConversionParameters& rhs); /** * @brief Copy operator */ SRGRConversionParameters& operator=(const SRGRConversionParameters& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new SRGRConversionParameters(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new SRGRConversionParameters(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief first_zero_doppler_time day */ int get_first_zero_doppler_time_day() { return _first_zero_doppler_time_day; }; /** * @brief first_zero_doppler_time second */ unsigned int get_first_zero_doppler_time_sec() { return _first_zero_doppler_time_sec; }; /** * @brief first_zero_doppler_time micro sec */ unsigned int get_first_zero_doppler_time_microsec() { return _first_zero_doppler_time_microsec; }; /** * @brief attach_flag */ bool get_attach_flag() { return _attach_flag; }; /** * @brief input_mean_flag */ float get_slant_range_time() { return _slant_range_time; }; /** * @brief input_std_dev_flag */ float get_ground_range_origin() { return _ground_range_origin; }; /** * @brief input_gaps_flag */ float* get_srgr_coef() { return _srgr_coef; }; /** * @brief first_zero_doppler_time day */ int _first_zero_doppler_time_day; /** * @brief first_zero_doppler_time sec */ unsigned int _first_zero_doppler_time_sec; /** * @brief first_zero_doppler_time microsec */ unsigned int _first_zero_doppler_time_microsec; /** * @brief attach_flag */ bool _attach_flag; /** * @brief input_mean_flag */ float _slant_range_time; /** * @brief input_std_dev_flag */ float _ground_range_origin; /** * @brief input_gaps_flag */ float _srgr_coef[5]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/dsd.cpp000066400000000000000000000065231301006202600272010ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { dsd::dsd() : EnvisatAsarRecord("dsd_rec") { } dsd::~dsd() { } std::ostream& operator<<(std::ostream& os, const dsd& data) { os<<"ds_name:"<>(std::istream& is, dsd& data) { char buf64[65]; buf64[64] = '\0'; // char buf32[33]; // buf32[32] = '\0'; char buf28[29]; buf28[28] = '\0'; char buf27[28]; buf27[27] = '\0'; // char buf20[21]; // buf20[20] = '\0'; char buf16[17]; buf16[16]='\0'; // char buf15[16]; // buf15[15] = '\0'; // char buf14[15]; // buf14[14] = '\0'; // char buf13[14]; // buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf11[12]; buf11[11] = '\0'; char buf10[11]; buf10[10] = '\0'; char buf9[10]; buf9[9] = '\0'; // char buf8[9]; // buf8[8] = '\0'; // char buf7[8]; // buf7[7] = '\0'; // char buf6[7]; // buf6[6] = '\0'; // char buf5[6]; // buf5[5] = '\0'; // char buf4[5]; // buf4[4] = '\0'; // char buf3[4]; // buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; char buf1[1]; is.read(buf9,9); is.read(buf28,28); data._ds_name = buf28; is.read(buf10,10); is.read(buf1,1); data._ds_type = buf1; is.read(buf11,11); is.read(buf64,62); buf64[62] = '\0'; data._filename = buf64; is.read(buf12,12); is.read(buf27,21); buf27[21] = '\0'; data._ds_offset = atof(buf27); is.read(buf16,16); is.read(buf27,21); buf27[21] = '\0'; data._ds_size = atof(buf27); is.read(buf16,16); is.read(buf11,11); data._num_dsr = atol(buf11); is.read(buf10,10); is.read(buf11,11); data._dsr_size = atol(buf11); is.read(buf64,41); return is; } std::string _ds_name; std::string _ds_type; std::string _filename; double _ds_offset; double _ds_size; int _num_dsr; int _dsr_size; dsd::dsd(const dsd& rhs): EnvisatAsarRecord(rhs), _ds_name(rhs._ds_name), _ds_type(rhs._ds_type), _filename(rhs._filename), _ds_offset(rhs._ds_offset), _ds_size(rhs._ds_size), _num_dsr(rhs._num_dsr), _dsr_size(rhs._dsr_size) { } dsd& dsd::operator=(const dsd& rhs) { _ds_name = rhs._ds_name; _ds_type = rhs._ds_type; _filename = rhs._filename; _ds_offset = rhs._ds_offset; _ds_size = rhs._ds_size; _num_dsr = rhs._num_dsr; _dsr_size = rhs._dsr_size; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/dsd.h000066400000000000000000000053251301006202600266450ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef dsd_h #define dsd_h #include #include namespace ossimplugins { /** * @ingroup dsdRecord * @brief This class is able to read the ASAR dsd record */ class dsd : public EnvisatAsarRecord { public: /** * @brief Constructor */ dsd(); /** * @brief Destructor */ virtual ~dsd(); /** * @brief This function write the dsd in a stream */ friend std::ostream& operator<<(std::ostream& os, const dsd& data); /** * @brief This function read a dsd from a stream */ friend std::istream& operator>>(std::istream& is, dsd& data); /** * @brief Copy constructor */ dsd(const dsd& rhs); /** * @brief Copy operator */ dsd& operator=(const dsd& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new dsd(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new dsd(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Data set Name */ std::string get_ds_name() { return _ds_name; } /** * @brief Data set Type */ std::string get_ds_type() { return _ds_type; } /** * @brief Data set Filename */ std::string get_filename() { return _filename; } /** * @brief Data set Offset */ double get_ds_offset() { return _ds_offset; } /** * @brief Data set Size */ double get_ds_size() { return _ds_size; } /** * @brief Number of data set record */ int get_num_dsr() { return _num_dsr; } /** * @brief Data set record size */ int get_dsr_size() { return _dsr_size; } /** * @brief Data set Name */ std::string _ds_name; /** * @brief Data set Type */ std::string _ds_type; /** * @brief Data set Filename */ std::string _filename; /** * @brief Data set Offset */ double _ds_offset; /** * @brief Data set Size */ double _ds_size; /** * @brief Number of data set record */ int _num_dsr; /** * @brief Data set record size */ int _dsr_size; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/mph.cpp000066400000000000000000000517441301006202600272200ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { mph::mph() : EnvisatAsarRecord("mph_rec") { } mph::~mph() { } std::ostream& operator<<(std::ostream& os, const mph& data) { os<<"product_name:"<>(std::istream& is, mph& data) { char buf64[65]; buf64[64] = '\0'; char buf32[33]; buf32[32] = '\0'; char buf27[28]; buf27[27]='\0'; char buf16[17]; buf16[16]='\0'; // char buf15[16]; // buf15[15] = '\0'; // char buf14[15]; // buf14[14] = '\0'; // char buf13[14]; // buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf11[12]; buf11[11] = '\0'; char buf10[11]; buf10[10] = '\0'; // char buf9[10]; // buf9[9] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf7[8]; buf7[7] = '\0'; char buf6[7]; buf6[6] = '\0'; // char buf5[6]; // buf5[5] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf3[4]; buf3[3] = '\0'; char buf2[3]; buf2[2] = '\0'; char buf1[2]; buf1[0] = '\0'; buf1[1] = '\0'; is.read(buf8,8); data._product_name = buf8; is.read(buf1,1); is.read(buf64,62); buf64[62]='\0'; data._product = buf64; is.read(buf1,1); is.read(buf1,1); is.read(buf16,11); buf16[11]='\0'; data._proc_stage_title = buf16; is.read(buf1,1); data._proc_stage = buf1; is.read(buf1,1); is.read(buf8,8); data._ref_doc_title = buf8; is.read(buf1,1); is.read(buf32,23); buf32[23]='\0'; data._ref_doc = buf32; is.read(buf1,1); is.read(buf1,1); is.read(buf64,40); is.read(buf1,1); is.read(buf32,20); buf32[20]='\0'; data._acq_stat_id_title = buf32; is.read(buf1,1); is.read(buf32,20); buf32[20]='\0'; data._acq_station = buf32; is.read(buf1,1); is.read(buf1,1); is.read(buf16,12); buf16[12]='\0'; data._proc_center_title = buf16; is.read(buf1,1); is.read(buf8,6); buf8[6]='\0'; data._proc_center = buf8; is.read(buf1,1); is.read(buf1,1); is.read(buf16,10); buf16[10]='\0'; data._proc_time_title = buf16; is.read(buf1,1); is.read(buf32,27); buf32[27]='\0'; data._proc_time = buf32; is.read(buf1,1); is.read(buf1,1); is.read(buf16,13); buf16[13]='\0'; data._soft_version_title = buf16; is.read(buf1,1); is.read(buf16,14); buf16[14]='\0'; data._soft_version = buf16; is.read(buf1,1); is.read(buf1,1); is.read(buf64,40); is.read(buf1,1); is.read(buf16,14); buf16[14]='\0'; data._sensing_start_title = buf16; is.read(buf1,1); is.read(buf32,27); buf32[27]='\0'; data._sensing_start = buf32; is.read(buf1,1); is.read(buf1,1); is.read(buf16,13); buf16[13]='\0'; data._sensing_stop_title = buf16; is.read(buf1,1); is.read(buf32,27); buf32[27]='\0'; data._sensing_stop = buf32; is.read(buf1,1); is.read(buf1,1); is.read(buf64,40); is.read(buf1,1); is.read(buf6,6); data._phase_title = buf6; is.read(buf1,1); data._phase = buf1; is.read(buf1,1); is.read(buf6,6); data._cycle_title = buf6; is.read(buf4,4); data._cycle = buf4; is.read(buf1,1); is.read(buf10,10); data._relative_orbit_title = buf10; is.read(buf6,6); data._rel_orbit = buf6; is.read(buf1,1); is.read(buf10,10); data._absolute_orbit_title = buf10; is.read(buf6,6); data._abs_orbit = buf6; is.read(buf1,1); is.read(buf32,18); buf32[18]='\0'; data._state_vector_time_title = buf32; is.read(buf1,1); is.read(buf27,27); data._state_vector_time = buf27; is.read(buf1,1); is.read(buf1,1); is.read(buf10,10); data._delta_ut1_title = buf10; is.read(buf8,8); data._delta_ut1 = buf8; is.read(buf4,3); buf4[3]='\0'; data._delta_ut1_units = buf4; is.read(buf1,1); is.read(buf11,11); data._x_position_title = buf11; is.read(buf12,12); data._x_position = buf12; is.read(buf3,3); data._x_position_units = buf3; is.read(buf1,1); is.read(buf11,11); data._y_position_title = buf11; is.read(buf12,12); data._y_position = buf12; is.read(buf3,3); data._y_position_units = buf3; is.read(buf1,1); is.read(buf11,11); data._z_position_title = buf11; is.read(buf12,12); data._z_position = buf12; is.read(buf3,3); data._z_position_units = buf3; is.read(buf1,1); is.read(buf11,11); data._x_velocity_title = buf11; is.read(buf12,12); data._x_velocity = buf12; is.read(buf8,5); buf8[5] = '\0'; data._x_velocity_units = buf8; is.read(buf1,1); is.read(buf11,11); data._y_velocity_title = buf11; is.read(buf12,12); data._y_velocity = buf12; is.read(buf8,5); buf8[5] = '\0'; data._y_velocity_units = buf8; is.read(buf1,1); is.read(buf11,11); data._z_velocity_title = buf11; is.read(buf12,12); data._z_velocity = buf12; is.read(buf8,5); buf8[5] = '\0'; data._z_velocity_units = buf8; is.read(buf1,1); is.read(buf16,14); buf16[14] = '\0'; data._vector_source_title = buf16; is.read(buf1,1); is.read(buf2,2); data._vector_source = buf2; is.read(buf1,1); is.read(buf1,1); is.read(buf64,40); buf64[40] = '\0'; data._spare_4 = buf64; is.read(buf1,1); is.read(buf16,13); buf16[13] = '\0'; data._utc_sbt_time_title = buf16; is.read(buf1,1); is.read(buf27,27); data._utc_sbt_time = buf27; is.read(buf1,1); is.read(buf1,1); is.read(buf16,16); data._sat_binary_time_title = buf16; is.read(buf11,11); data._sat_binary_time = buf11; is.read(buf1,1); is.read(buf11,11); data._clock_step_title = buf11; is.read(buf11,11); data._clock_step = buf11; is.read(buf4,4); data._clock_step_units = buf4; is.read(buf1,1); is.read(buf32,32); is.read(buf1,1); is.read(buf10,9); buf10[9] = '\0'; data._leap_utc_title = buf10; is.read(buf1,1); is.read(buf27,27); data._leap_utc = buf27; is.read(buf1,1); is.read(buf1,1); is.read(buf10,10); data._leap_sign_title = buf10; is.read(buf4,4); data._leap_sign = buf4; is.read(buf1,1); is.read(buf10,9); buf10[9] = '\0'; data._leap_err_title = buf10; is.read(buf1,1); data._leap_err = buf1; is.read(buf1,1); is.read(buf64,40); is.read(buf1,1); is.read(buf12,12); data._product_err_title = buf12; is.read(buf1,1); data._product_err = buf1; is.read(buf1,1); is.read(buf10,9); buf10[9] = '\0'; data._total_size_title = buf10; is.read(buf32,21); buf32[21] = '\0'; data._tot_size = buf32; is.read(buf7,7); data._total_size_units = buf7; is.read(buf1,1); is.read(buf10,9); buf10[9] = '\0'; data._sph_size_title = buf10; is.read(buf11,11); data._sph_size = buf11; is.read(buf8,7); buf8[7] = '\0'; data._sph_size_units = buf8; is.read(buf1,1); is.read(buf8,8); data._number_of_dsd_title = buf8; is.read(buf11,11); data._num_dsd = atoi(buf11); is.read(buf1,1); is.read(buf10,9); buf10[9] = '\0'; data._size_of_dsd_title = buf10; is.read(buf11,11); data._dsd_size = atoi(buf11); is.read(buf8,7); buf8[7] = '\0'; data._size_of_dsd_units = buf8; is.read(buf1,1); is.read(buf16,14); buf16[14] = '\0'; data._number_of_ds_att_title = buf16; is.read(buf11,11); data._num_data_sets = atoi(buf11); is.read(buf1,1); is.read(buf64,40); is.read(buf1,1); return is; } mph::mph(const mph& rhs): EnvisatAsarRecord(rhs), _product_name(rhs._product_name), _product(rhs._product), _proc_stage_title(rhs._proc_stage_title), _proc_stage(rhs._proc_stage), _ref_doc_title(rhs._ref_doc_title), _ref_doc(rhs._ref_doc), _acq_stat_id_title(rhs._acq_stat_id_title), _acq_station(rhs._acq_station), _proc_center_title(rhs._proc_center_title), _proc_center(rhs._proc_center), _proc_time_title(rhs._proc_time_title), _proc_time(rhs._proc_time), _soft_version_title(rhs._soft_version_title), _soft_version(rhs._soft_version), _sensing_start_title(rhs._sensing_start_title), _sensing_start(rhs._sensing_start), _sensing_stop_title(rhs._sensing_stop_title), _sensing_stop(rhs._sensing_stop), _phase_title(rhs._phase_title), _phase(rhs._phase), _cycle_title(rhs._cycle_title), _cycle(rhs._cycle), _relative_orbit_title(rhs._relative_orbit_title), _rel_orbit(rhs._rel_orbit), _absolute_orbit_title(rhs._absolute_orbit_title), _abs_orbit(rhs._abs_orbit), _state_vector_time_title(rhs._state_vector_time_title), _state_vector_time(rhs._state_vector_time), _delta_ut1_title(rhs._delta_ut1_title), _delta_ut1(rhs._delta_ut1), _delta_ut1_units(rhs._delta_ut1_units), _x_position_title(rhs._x_position_title), _x_position(rhs._x_position), _x_position_units(rhs._x_position_units), _y_position_title(rhs._y_position_title), _y_position(rhs._y_position), _y_position_units(rhs._y_position_units), _z_position_title(rhs._z_position_title), _z_position(rhs._z_position), _z_position_units(rhs._z_position_units), _x_velocity_title(rhs._x_velocity_title), _x_velocity(rhs._x_velocity), _x_velocity_units(rhs._x_velocity_units), _y_velocity_title(rhs._y_velocity_title), _y_velocity(rhs._y_velocity), _y_velocity_units(rhs._y_velocity_units), _z_velocity_title(rhs._z_velocity_title), _z_velocity(rhs._z_velocity), _z_velocity_units(rhs._z_velocity_units), _vector_source_title(rhs._vector_source_title), _vector_source(rhs._vector_source), _spare_4(rhs._spare_4), _utc_sbt_time_title(rhs._utc_sbt_time_title), _utc_sbt_time(rhs._utc_sbt_time), _sat_binary_time_title(rhs._sat_binary_time_title), _sat_binary_time(rhs._sat_binary_time), _clock_step_title(rhs._clock_step_title), _clock_step(rhs._clock_step), _clock_step_units(rhs._clock_step_units), _leap_utc_title(rhs._leap_utc_title), _leap_utc(rhs._leap_utc), _leap_sign_title(rhs._leap_sign_title), _leap_sign(rhs._leap_sign), _leap_err_title(rhs._leap_err_title), _leap_err(rhs._leap_err), _product_err_title(rhs._product_err_title), _product_err(rhs._product_err), _total_size_title(rhs._total_size_title), _tot_size(rhs._tot_size), _total_size_units(rhs._total_size_units), _sph_size_title(rhs._sph_size_title), _sph_size(rhs._sph_size), _sph_size_units(rhs._sph_size_units), _number_of_dsd_title(rhs._number_of_dsd_title), _num_dsd(rhs._num_dsd), _size_of_dsd_title(rhs._size_of_dsd_title), _dsd_size(rhs._dsd_size), _size_of_dsd_units(rhs._size_of_dsd_units), _number_of_ds_att_title(rhs._number_of_ds_att_title), _num_data_sets(rhs._num_data_sets) {} mph& mph::operator=(const mph& rhs) { _product_name = rhs._product_name; _product = rhs._product; _proc_stage_title = rhs._proc_stage_title; _proc_stage = rhs._proc_stage; _ref_doc_title = rhs._ref_doc_title; _ref_doc = rhs._ref_doc; _acq_stat_id_title = rhs._acq_stat_id_title; _acq_station = rhs._acq_station; _proc_center_title = rhs._proc_center_title; _proc_center = rhs._proc_center; _proc_time_title = rhs._proc_time_title; _proc_time = rhs._proc_time; _soft_version_title = rhs._soft_version_title; _soft_version = rhs._soft_version; _sensing_start_title = rhs._sensing_start_title; _sensing_start = rhs._sensing_start; _sensing_stop_title = rhs._sensing_stop_title; _sensing_stop = rhs._sensing_stop; _phase_title = rhs._phase_title; _phase = rhs._phase; _cycle_title = rhs._cycle_title; _cycle = rhs._cycle; _relative_orbit_title = rhs._relative_orbit_title; _rel_orbit = rhs._rel_orbit; _absolute_orbit_title = rhs._absolute_orbit_title; _abs_orbit = rhs._abs_orbit; _state_vector_time_title = rhs._state_vector_time_title; _state_vector_time = rhs._state_vector_time; _delta_ut1_title = rhs._delta_ut1_title; _delta_ut1 = rhs._delta_ut1; _delta_ut1_units = rhs._delta_ut1_units; _x_position_title = rhs._x_position_title; _x_position = rhs._x_position; _x_position_units = rhs._x_position_units; _y_position_title = rhs._y_position_title; _y_position = rhs._y_position; _y_position_units = rhs._y_position_units; _z_position_title = rhs._z_position_title; _z_position = rhs._z_position; _z_position_units = rhs._z_position_units; _x_velocity_title = rhs._x_velocity_title; _x_velocity = rhs._x_velocity; _x_velocity_units = rhs._x_velocity_units; _y_velocity_title = rhs._y_velocity_title; _y_velocity = rhs._y_velocity; _y_velocity_units = rhs._y_velocity_units; _z_velocity_title = rhs._z_velocity_title; _z_velocity = rhs._z_velocity; _z_velocity_units = rhs._z_velocity_units; _vector_source_title = rhs._vector_source_title; _vector_source = rhs._vector_source; _spare_4 = rhs._spare_4; _utc_sbt_time_title = rhs._utc_sbt_time_title; _utc_sbt_time = rhs._utc_sbt_time; _sat_binary_time_title = rhs._sat_binary_time_title; _sat_binary_time = rhs._sat_binary_time; _clock_step_title = rhs._clock_step_title; _clock_step = rhs._clock_step; _clock_step_units = rhs._clock_step_units; _leap_utc_title = rhs._leap_utc_title; _leap_utc = rhs._leap_utc; _leap_sign_title = rhs._leap_sign_title; _leap_sign = rhs._leap_sign; _leap_err_title = rhs._leap_err_title; _leap_err = rhs._leap_err; _product_err_title = rhs._product_err_title; _product_err = rhs._product_err; _total_size_title = rhs._total_size_title; _tot_size = rhs._tot_size; _total_size_units = rhs._total_size_units; _sph_size_title = rhs._sph_size_title; _sph_size = rhs._sph_size; _sph_size_units = rhs._sph_size_units; _number_of_dsd_title = rhs._number_of_dsd_title; _num_dsd = rhs._num_dsd; _size_of_dsd_title = rhs._size_of_dsd_title; _dsd_size = rhs._dsd_size; _size_of_dsd_units = rhs._size_of_dsd_units; _number_of_ds_att_title = rhs._number_of_ds_att_title; _num_data_sets = rhs._num_data_sets; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/mph.h000066400000000000000000000413111301006202600266520ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef mph_h #define mph_h #include #include namespace ossimplugins { /** * @ingroup mphRecord * @brief This class is able to read the ASAR mph record of the leader file * \todo Use the default generated copy- and move-constructors and assignment-operators */ class mph : public EnvisatAsarRecord { public: /** * @brief Constructor */ mph(); /** * @brief Destructor */ virtual ~mph(); /** * @brief This function write the mph in a stream */ friend std::ostream& operator<<(std::ostream& os, const mph& data); /** * @brief This function read a mph from a stream */ friend std::istream& operator>>(std::istream& is, mph& data); /** * @brief Copy constructor */ mph(const mph& rhs); /** * @brief Copy operator */ mph& operator=(const mph& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new mph(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new mph(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief product_name */ std::string const& get_product_name() const { return _product_name; }; /** * @brief product */ std::string const& get_product() const { return _product; }; /** * @brief proc_stage_title */ std::string const& get_proc_stage_title() const { return _proc_stage_title; }; /** * @brief proc_stage */ std::string const& get_proc_stage() const { return _proc_stage; }; /** * @brief ref_doc_title */ std::string const& get_ref_doc_title() const { return _ref_doc_title; }; /** * @brief ref_doc */ std::string const& get_ref_doc() const { return _ref_doc; }; /** * @brief acq_stat_id_title */ std::string const& get_acq_stat_id_title() const { return _acq_stat_id_title; }; /** * @brief acq_station */ std::string const& get_acq_station() const { return _acq_station; }; /** * @brief proc_center_title */ std::string const& get_proc_center_title() const { return _proc_center_title; }; /** * @brief proc_center */ std::string const& get_proc_center() const { return _proc_center; }; /** * @brief proc_time_title */ std::string const& get_proc_time_title() const { return _proc_time_title; }; /** * @brief proc_time */ std::string const& get_proc_time() const { return _proc_time; }; /** * @brief soft_version_title */ std::string const& get_soft_version_title() const { return _soft_version_title; }; /** * @brief soft_version */ std::string const& get_soft_version() const { return _soft_version; }; /** * @brief sensing_start_title */ std::string const& get_sensing_start_title() const { return _sensing_start_title; }; /** * @brief sensing_start */ std::string const& get_sensing_start() const { return _sensing_start; }; /** * @brief sensing_stop_title */ std::string const& get_sensing_stop_title() const { return _sensing_stop_title; }; /** * @brief sensing_stop */ std::string const& get_sensing_stop() const { return _sensing_stop; }; /** * @brief phase_title */ std::string const& get_phase_title() const { return _phase_title; }; /** * @brief phase */ std::string const& get_phase() const { return _phase; }; /** * @brief cycle_title */ std::string const& get_cycle_title() const { return _cycle_title; }; /** * @brief cycle */ std::string const& get_cycle() const { return _cycle; }; /** * @brief relative_orbit_title */ std::string const& get_relative_orbit_title() const { return _relative_orbit_title; }; /** * @brief rel_orbit */ std::string const& get_rel_orbit() const { return _rel_orbit; }; /** * @brief absolute_orbit_title */ std::string const& get_absolute_orbit_title() const { return _absolute_orbit_title; }; /** * @brief abs_orbit */ std::string const& get_abs_orbit() const { return _abs_orbit; }; /** * @brief state_vector_time_title */ std::string const& get_state_vector_time_title() const { return _state_vector_time_title; }; /** * @brief state_vector_time */ std::string const& get_state_vector_time() const { return _state_vector_time; }; /** * @brief delta_ut1_title */ std::string const& get_delta_ut1_title() const { return _delta_ut1_title; }; /** * @brief delta_ut1 */ std::string const& get_delta_ut1() const { return _delta_ut1; }; /** * @brief delta_ut1_units */ std::string const& get_delta_ut1_units() const { return _delta_ut1_units; }; /** * @brief x_position_title */ std::string const& get_x_position_title() const { return _x_position_title; }; /** * @brief x_position */ std::string const& get_x_position() const { return _x_position; }; /** * @brief x_position_units */ std::string const& get_x_position_units() const { return _x_position_units; }; /** * @brief y_position_title */ std::string const& get_y_position_title() const { return _y_position_title; }; /** * @brief y_position */ std::string const& get_y_position() const { return _y_position; }; /** * @brief y_position_units */ std::string const& get_y_position_units() const { return _y_position_units; }; /** * @brief z_position_title */ std::string const& get_z_position_title() const { return _z_position_title; }; /** * @brief z_position */ std::string const& get_z_position() const { return _z_position; }; /** * @brief z_position_units */ std::string const& get_z_position_units() const { return _z_position_units; }; /** * @brief x_velocity_title */ std::string const& get_x_velocity_title() const { return _x_velocity_title; }; /** * @brief x_velocity */ std::string const& get_x_velocity() const { return _x_velocity; }; /** * @brief x_velocity_units */ std::string const& get_x_velocity_units() const { return _x_velocity_units; }; /** * @brief y_velocity_title */ std::string const& get_y_velocity_title() const { return _y_velocity_title; }; /** * @brief y_velocity */ std::string const& get_y_velocity() const { return _y_velocity; }; /** * @brief y_velocity_units */ std::string const& get_y_velocity_units() const { return _y_velocity_units; }; /** * @brief z_velocity_title */ std::string const& get_z_velocity_title() const { return _z_velocity_title; }; /** * @brief z_velocity */ std::string const& get_z_velocity() const { return _z_velocity; }; /** * @brief z_velocity_units */ std::string const& get_z_velocity_units() const { return _z_velocity_units; }; /** * @brief vector_source_title */ std::string const& get_vector_source_title() const { return _vector_source_title; }; /** * @brief vector_source */ std::string const& get_vector_source() const { return _vector_source; }; /** * @brief spare_4 */ std::string const& get_spare_4() const { return _spare_4; }; /** * @brief utc_sbt_time_title */ std::string const& get_utc_sbt_time_title() const { return _utc_sbt_time_title; }; /** * @brief utc_sbt_time */ std::string const& get_utc_sbt_time() const { return _utc_sbt_time; }; /** * @brief sat_binary_time_title */ std::string const& get_sat_binary_time_title() const { return _sat_binary_time_title; }; /** * @brief sat_binary_time */ std::string const& get_sat_binary_time() const { return _sat_binary_time; }; /** * @brief clock_step_title */ std::string const& get_clock_step_title() const { return _clock_step_title; }; /** * @brief clock_step */ std::string const& get_clock_step() const { return _clock_step; }; /** * @brief clock_step_units */ std::string const& get_clock_step_units() const { return _clock_step_units; }; /** * @brief leap_utc_title */ std::string const& get_leap_utc_title() const { return _leap_utc_title; }; /** * @brief leap_utc */ std::string const& get_leap_utc() const { return _leap_utc; }; /** * @brief leap_sign_title */ std::string const& get_leap_sign_title() const { return _leap_sign_title; }; /** * @brief leap_sign */ std::string const& get_leap_sign() const { return _leap_sign; }; /** * @brief leap_err_title */ std::string const& get_leap_err_title() const { return _leap_err_title; }; /** * @brief leap_err */ std::string const& get_leap_err() const { return _leap_err; }; /** * @brief product_err_title */ std::string const& get_product_err_title() const { return _product_err_title; }; /** * @brief product_err */ std::string const& get_product_err() const { return _product_err; }; /** * @brief total_size_title */ std::string const& get_total_size_title() const { return _total_size_title; }; /** * @brief tot_size */ std::string const& get_tot_size() const { return _tot_size; }; /** * @brief total_size_units */ std::string const& get_total_size_units() const { return _total_size_units; }; /** * @brief sph_size_title */ std::string const& get_sph_size_title() const { return _sph_size_title; }; /** * @brief sph_size */ std::string const& get_sph_size() const { return _sph_size; }; /** * @brief sph_size_units */ std::string const& get_sph_size_units() const { return _sph_size_units; }; /** * @brief number_of_dsd_title */ std::string const& get_number_of_dsd_title() const { return _number_of_dsd_title; }; /** * @brief num_dsd */ int get_num_dsd() const { return _num_dsd; }; /** * @brief size_of_dsd_title */ std::string const& get_size_of_dsd_title() const { return _size_of_dsd_title; }; /** * @brief dsd_size */ int get_dsd_size() const { return _dsd_size; }; /** * @brief size_of_dsd_units */ std::string const& get_size_of_dsd_units() const { return _size_of_dsd_units; }; /** * @brief number_of_ds_att_title */ std::string const& get_number_of_ds_att_title() const { return _number_of_ds_att_title; }; /** * @brief num_data_sets */ int get_num_data_sets() const { return _num_data_sets; }; /** * @brief Check mph validity */ bool is_valid() const { if ((_product_name.compare("PRODUCT=") == 0) && (_number_of_dsd_title.compare("NUM_DSD=") == 0)) { return true; } else return false; }; /** * @brief product_name */ std::string _product_name; /** * @brief product */ std::string _product; /** * @brief proc_stage_title */ std::string _proc_stage_title; /** * @brief proc_stage */ std::string _proc_stage; /** * @brief ref_doc_title */ std::string _ref_doc_title; /** * @brief ref_doc */ std::string _ref_doc; /** * @brief acq_stat_id_title */ std::string _acq_stat_id_title; /** * @brief acq_station */ std::string _acq_station; /** * @brief proc_center_title */ std::string _proc_center_title; /** * @brief proc_center */ std::string _proc_center; /** * @brief proc_time_title */ std::string _proc_time_title; /** * @brief proc_time */ std::string _proc_time; /** * @brief soft_version_title */ std::string _soft_version_title; /** * @brief soft_version */ std::string _soft_version; /** * @brief sensing_start_title */ std::string _sensing_start_title; /** * @brief sensing_start */ std::string _sensing_start; /** * @brief sensing_stop_title */ std::string _sensing_stop_title; /** * @brief sensing_stop */ std::string _sensing_stop; /** * @brief phase_title */ std::string _phase_title; /** * @brief phase */ std::string _phase; /** * @brief cycle_title */ std::string _cycle_title; /** * @brief cycle */ std::string _cycle; /** * @brief relative_orbit_title */ std::string _relative_orbit_title; /** * @brief rel_orbit */ std::string _rel_orbit; /** * @brief absolute_orbit_title */ std::string _absolute_orbit_title; /** * @brief abs_orbit */ std::string _abs_orbit; /** * @brief state_vector_time_title */ std::string _state_vector_time_title; /** * @brief state_vector_time */ std::string _state_vector_time; /** * @brief delta_ut1_title */ std::string _delta_ut1_title; /** * @brief delta_ut1 */ std::string _delta_ut1; /** * @brief delta_ut1_units */ std::string _delta_ut1_units; /** * @brief x_position_title */ std::string _x_position_title; /** * @brief x_position */ std::string _x_position; /** * @brief x_position_units */ std::string _x_position_units; /** * @brief y_position_title */ std::string _y_position_title; /** * @brief y_position */ std::string _y_position; /** * @brief y_position_units */ std::string _y_position_units; /** * @brief z_position_title */ std::string _z_position_title; /** * @brief z_position */ std::string _z_position; /** * @brief z_position_units */ std::string _z_position_units; /** * @brief x_velocity_title */ std::string _x_velocity_title; /** * @brief x_velocity */ std::string _x_velocity; /** * @brief x_velocity_units */ std::string _x_velocity_units; /** * @brief y_velocity_title */ std::string _y_velocity_title; /** * @brief y_velocity */ std::string _y_velocity; /** * @brief y_velocity_units */ std::string _y_velocity_units; /** * @brief z_velocity_title */ std::string _z_velocity_title; /** * @brief z_velocity */ std::string _z_velocity; /** * @brief z_velocity_units */ std::string _z_velocity_units; /** * @brief vector_source_title */ std::string _vector_source_title; /** * @brief vector_source */ std::string _vector_source; /** * @brief spare_4 */ std::string _spare_4; /** * @brief utc_sbt_time_title */ std::string _utc_sbt_time_title; /** * @brief utc_sbt_time */ std::string _utc_sbt_time; /** * @brief sat_binary_time_title */ std::string _sat_binary_time_title; /** * @brief sat_binary_time */ std::string _sat_binary_time; /** * @brief clock_step_title */ std::string _clock_step_title; /** * @brief clock_step */ std::string _clock_step; /** * @brief clock_step_units */ std::string _clock_step_units; /** * @brief leap_utc_title */ std::string _leap_utc_title; /** * @brief leap_utc */ std::string _leap_utc; /** * @brief leap_sign_title */ std::string _leap_sign_title; /** * @brief leap_sign */ std::string _leap_sign; /** * @brief leap_err_title */ std::string _leap_err_title; /** * @brief leap_err */ std::string _leap_err; /** * @brief product_err_title */ std::string _product_err_title; /** * @brief product_err */ std::string _product_err; /** * @brief total_size_title */ std::string _total_size_title; /** * @brief tot_size */ std::string _tot_size; /** * @brief total_size_units */ std::string _total_size_units; /** * @brief sph_size_title */ std::string _sph_size_title; /** * @brief sph_size */ std::string _sph_size; /** * @brief sph_size_units */ std::string _sph_size_units; /** * @brief number_of_dsd_title */ std::string _number_of_dsd_title; /** * @brief num_dsd */ int _num_dsd; /** * @brief size_of_dsd_title */ std::string _size_of_dsd_title; /** * @brief dsd_size */ int _dsd_size; /** * @brief size_of_dsd_units */ std::string _size_of_dsd_units; /** * @brief number_of_ds_att_title */ std::string _number_of_ds_att_title; /** * @brief num_data_sets */ int _num_data_sets; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/sph.cpp000066400000000000000000000536701301006202600272260ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include namespace ossimplugins { sph::sph() : EnvisatAsarRecord("sph_rec") { this->_num_dsd = 18; this->_size_dsd = 280; } sph::sph(const mph& data) : EnvisatAsarRecord("sph_rec") { this->_num_dsd = data._num_dsd ; this->_size_dsd = data._dsd_size; } sph::~sph() { } std::ostream& operator<<(std::ostream& os, const sph& data) { os<<"sph_desc_title:"<>(std::istream& is, sph& data) { char buf64[65]; buf64[64] = '\0'; char buf32[33]; buf32[32] = '\0'; char buf27[28]; buf27[27] = '\0'; char buf16[17]; buf16[16]='\0'; char buf15[16]; buf15[15] = '\0'; char buf14[15]; buf14[14] = '\0'; char buf13[14]; buf13[13] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf11[12]; buf11[11] = '\0'; char buf10[11]; buf10[10] = '\0'; char buf9[10]; buf9[9] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf7[8]; buf7[7] = '\0'; char buf6[7]; buf6[6] = '\0'; char buf5[6]; buf5[5] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf3[4]; buf3[3] = '\0'; // char buf2[3]; // buf2[2] = '\0'; char buf1[1]; is.read(buf15,15); data._sph_desc_title = buf15; is.read(buf1,1); is.read(buf32,28); buf32[28] = '\0'; data._sph_desc = buf32; is.read(buf1,1); is.read(buf1,1); is.read(buf32,31); buf32[31] = '\0'; data._strip_cont_ind_title = buf32; is.read(buf4,4); data._strip_cont_ind = buf4; is.read(buf1,1); is.read(buf15,15); data._slice_pos_title = buf15; is.read(buf4,4); data._slice_position = buf4; is.read(buf1,1); is.read(buf11,11); data._num_slices_title = buf11; is.read(buf4,4); data._num_slices = buf4; is.read(buf1,1); is.read(buf16,16); data._first_line_time_title = buf16; is.read(buf1,1); is.read(buf27,27); data._first_line_time = buf27; is.read(buf1,1); is.read(buf1,1); is.read(buf15,15); data._last_line_time_title = buf15; is.read(buf1,1); is.read(buf27,27); data._last_line_time = buf27; is.read(buf1,1); is.read(buf1,1); is.read(buf15,15); data._first_near_lat_title = buf15; is.read(buf11,11); data._first_near_lat = buf11; is.read(buf10,10); data._first_near_lat_units = buf10; is.read(buf1,1); is.read(buf16,16); data._first_near_long_title = buf16; is.read(buf11,11); data._first_near_long = buf11; is.read(buf10,10); data._first_near_long_units = buf10; is.read(buf1,1); is.read(buf14,14); data._first_mid_lat_title = buf14; is.read(buf11,11); data._first_mid_lat = buf11; is.read(buf10,10); data._first_mid_lat_units = buf10; is.read(buf1,1); is.read(buf15,15); data._first_mid_long_title = buf15; is.read(buf11,11); data._first_mid_long = buf11; is.read(buf10,10); data._first_mid_long_units = buf10; is.read(buf1,1); is.read(buf14,14); data._first_far_lat_title = buf14; is.read(buf11,11); data._first_far_lat = buf11; is.read(buf10,10); data._first_far_lat_units = buf10; is.read(buf1,1); is.read(buf15,15); data._first_far_long_title = buf15; is.read(buf11,11); data._first_far_long = buf11; is.read(buf10,10); data._first_far_long_units = buf10; is.read(buf1,1); is.read(buf14,14); data._last_near_lat_title = buf14; is.read(buf11,11); data._last_near_lat = buf11; is.read(buf10,10); data._last_near_lat_units = buf10; is.read(buf1,1); is.read(buf15,15); data._last_near_long_title = buf15; is.read(buf11,11); data._last_near_long = buf11; is.read(buf10,10); data._last_near_long_units = buf10; is.read(buf1,1); is.read(buf13,13); data._last_mid_lat_title = buf13; is.read(buf11,11); data._last_mid_lat = buf11; is.read(buf10,10); data._last_mid_lat_units = buf10; is.read(buf1,1); is.read(buf14,14); data._last_mid_long_title = buf14; is.read(buf11,11); data._last_mid_long = buf11; is.read(buf10,10); data._last_mid_long_units = buf10; is.read(buf1,1); is.read(buf13,13); data._last_far_lat_title = buf13; is.read(buf11,11); data._last_far_lat = buf11; is.read(buf10,10); data._last_far_lat_units = buf10; is.read(buf1,1); is.read(buf14,14); data._last_far_long_title = buf14; is.read(buf11,11); data._last_far_long = buf11; is.read(buf10,10); data._last_far_long_units = buf10; is.read(buf1,1); is.read(buf64,35); is.read(buf1,1); is.read(buf6,6); data._swath_title = buf6; is.read(buf1,1); is.read(buf3,3); data._swath = buf3; is.read(buf1,1); is.read(buf1,1); is.read(buf5,5); data._pass_title = buf5; is.read(buf1,1); is.read(buf10,10); data._pass = buf10; is.read(buf1,1); is.read(buf1,1); is.read(buf12,12); data._sample_type_title = buf12; is.read(buf1,1); is.read(buf8,8); data._sample_type = buf8; is.read(buf1,1); is.read(buf1,1); is.read(buf10,10); data._algo_title = buf10; is.read(buf1,1); is.read(buf7,7); data._algorithm = buf7; is.read(buf1,1); is.read(buf1,1); is.read(buf32,17); buf32[17] = '\0'; data._mds1_tx_rx_polar_title = buf32; is.read(buf1,1); is.read(buf3,3); data._mds1_tx_rx_polar = buf3; is.read(buf1,1); is.read(buf1,1); is.read(buf32,17); buf32[17] = '\0'; data._mds2_tx_rx_polar_title = buf32; is.read(buf1,1); is.read(buf3,3); data._mds2_tx_rx_polar = buf3; is.read(buf1,1); is.read(buf1,1); is.read(buf12,12); data._compression_title = buf12; is.read(buf1,1); is.read(buf5,5); data._compression = buf5; is.read(buf1,1); is.read(buf1,1); is.read(buf14,14); data._azimut_looks_title = buf14; is.read(buf4,4); data._azimut_looks = buf4; is.read(buf1,1); is.read(buf12,12); data._range_looks_title = buf12; is.read(buf4,4); data._range_looks = buf4; is.read(buf1,1); is.read(buf14,14); data._range_spacing_title = buf14; is.read(buf15,15); data._range_spacing = buf15; is.read(buf3,3); data._range_spacing_unit = buf3; is.read(buf1,1); is.read(buf16,16); data._azimut_spacing_title = buf16; is.read(buf15,15); data._azimut_spacing = buf15; is.read(buf3,3); data._azimut_spacing_unit = buf3; is.read(buf1,1); is.read(buf32,19); buf32[19] = '\0'; data._line_time_interval_title = buf32; is.read(buf15,15); data._line_time_interval = buf15; is.read(buf3,3); data._line_time_interv_units = buf3; is.read(buf1,1); is.read(buf12,12); data._line_length_title = buf12; is.read(buf6,6); data._line_length = buf6; is.read(buf9,9); data._line_length_units = buf9; is.read(buf1,1); is.read(buf10,10); data._data_type_title = buf10; is.read(buf1,1); is.read(buf5,5); data._data_type = buf5; is.read(buf1,1); is.read(buf1,1); is.read(buf64,50); is.read(buf1,1); for (int i = 0; i>dsd_rec; data._dsd_vector.push_back(dsd_rec); } //char *buffer = (char* )malloc(data._num_dsd*data._size_dsd); //is.read(buffer, data._num_dsd*data._size_dsd); return is; } sph::sph(const sph& rhs): EnvisatAsarRecord(rhs), _sph_desc_title(rhs._sph_desc_title), _sph_desc(rhs._sph_desc), _strip_cont_ind_title(rhs._strip_cont_ind_title), _strip_cont_ind(rhs._strip_cont_ind), _slice_pos_title(rhs._slice_pos_title), _slice_position(rhs._slice_position), _num_slices_title(rhs._num_slices_title), _num_slices(rhs._num_slices), _first_line_time_title(rhs._first_line_time_title), _first_line_time(rhs._first_line_time), _last_line_time_title(rhs._last_line_time_title), _last_line_time(rhs._last_line_time), _first_near_lat_title(rhs._first_near_lat_title), _first_near_lat(rhs._first_near_lat), _first_near_lat_units(rhs._first_near_lat_units), _first_near_long_title(rhs._first_near_long_title), _first_near_long(rhs._first_near_long), _first_near_long_units(rhs._first_near_long_units), _first_mid_lat_title(rhs._first_mid_lat_title), _first_mid_lat(rhs._first_mid_lat), _first_mid_lat_units(rhs._first_mid_lat_units), _first_mid_long_title(rhs._first_mid_long_title), _first_mid_long(rhs._first_mid_long), _first_mid_long_units(rhs._first_mid_long_units), _first_far_lat_title(rhs._first_far_lat_title), _first_far_lat(rhs._first_far_lat), _first_far_lat_units(rhs._first_far_lat_units), _first_far_long_title(rhs._first_far_long_title), _first_far_long(rhs._first_far_long), _first_far_long_units(rhs._first_far_long_units), _last_near_lat_title(rhs._last_near_lat_title), _last_near_lat(rhs._last_near_lat), _last_near_lat_units(rhs._last_near_lat_units), _last_near_long_title(rhs._last_near_long_title), _last_near_long(rhs._last_near_long), _last_near_long_units(rhs._last_near_long_units), _last_mid_lat_title(rhs._last_mid_lat_title), _last_mid_lat(rhs._last_mid_lat), _last_mid_lat_units(rhs._last_mid_lat_units), _last_mid_long_title(rhs._last_mid_long_title), _last_mid_long(rhs._last_mid_long), _last_mid_long_units(rhs._last_mid_long_units), _last_far_lat_title(rhs._last_far_lat_title), _last_far_lat(rhs._last_far_lat), _last_far_lat_units(rhs._last_far_lat_units), _last_far_long_title(rhs._last_far_long_title), _last_far_long(rhs._last_far_long), _last_far_long_units(rhs._last_far_long_units), _swath_title(rhs._swath_title), _swath(rhs._swath), _pass_title(rhs._pass_title), _pass(rhs._pass), _sample_type_title(rhs._sample_type_title), _sample_type(rhs._sample_type), _algo_title(rhs._algo_title), _algorithm(rhs._algorithm), _mds1_tx_rx_polar_title(rhs._mds1_tx_rx_polar_title), _mds1_tx_rx_polar(rhs._mds1_tx_rx_polar), _mds2_tx_rx_polar_title(rhs._mds2_tx_rx_polar_title), _mds2_tx_rx_polar(rhs._mds2_tx_rx_polar), _compression_title(rhs._compression_title), _compression(rhs._compression), _azimut_looks_title(rhs._azimut_looks_title), _azimut_looks(rhs._azimut_looks), _range_looks_title(rhs._range_looks_title), _range_looks(rhs._range_looks), _range_spacing_title(rhs._range_spacing_title), _range_spacing(rhs._range_spacing), _range_spacing_unit(rhs._range_spacing_unit), _azimut_spacing_title(rhs._azimut_spacing_title), _azimut_spacing(rhs._azimut_spacing), _azimut_spacing_unit(rhs._azimut_spacing_unit), _line_time_interval_title(rhs._line_time_interval_title), _line_time_interval(rhs._line_time_interval), _line_time_interv_units(rhs._line_time_interv_units), _line_length_title(rhs._line_length_title), _line_length(rhs._line_length), _line_length_units(rhs._line_length_units), _data_type_title(rhs._data_type_title), _data_type(rhs._data_type) {} sph& sph::operator=(const sph& rhs) { _sph_desc_title = rhs._sph_desc_title; _sph_desc = rhs._sph_desc; _strip_cont_ind_title = rhs._strip_cont_ind_title; _strip_cont_ind = rhs._strip_cont_ind; _slice_pos_title = rhs._slice_pos_title; _slice_position = rhs._slice_position; _num_slices_title = rhs._num_slices_title; _num_slices = rhs._num_slices; _first_line_time_title = rhs._first_line_time_title; _first_line_time = rhs._first_line_time; _last_line_time_title = rhs._last_line_time_title; _last_line_time = rhs._last_line_time; _first_near_lat_title = rhs._first_near_lat_title; _first_near_lat = rhs._first_near_lat; _first_near_lat_units = rhs._first_near_lat_units; _first_near_long_title = rhs._first_near_long_title; _first_near_long = rhs._first_near_long; _first_near_long_units = rhs._first_near_long_units; _first_mid_lat_title = rhs._first_mid_lat_title; _first_mid_lat = rhs._first_mid_lat; _first_mid_lat_units = rhs._first_mid_lat_units; _first_mid_long_title = rhs._first_mid_long_title; _first_mid_long = rhs._first_mid_long; _first_mid_long_units = rhs._first_mid_long_units; _first_far_lat_title = rhs._first_far_lat_title; _first_far_lat = rhs._first_far_lat; _first_far_lat_units = rhs._first_far_lat_units; _first_far_long_title = rhs._first_far_long_title; _first_far_long = rhs._first_far_long; _first_far_long_units = rhs._first_far_long_units; _last_near_lat_title = rhs._last_near_lat_title; _last_near_lat = rhs._last_near_lat; _last_near_lat_units = rhs._last_near_lat_units; _last_near_long_title = rhs._last_near_long_title; _last_near_long = rhs._last_near_long; _last_near_long_units = rhs._last_near_long_units; _last_mid_lat_title = rhs._last_mid_lat_title; _last_mid_lat = rhs._last_mid_lat; _last_mid_lat_units = rhs._last_mid_lat_units; _last_mid_long_title = rhs._last_mid_long_title; _last_mid_long = rhs._last_mid_long; _last_mid_long_units = rhs._last_mid_long_units; _last_far_lat_title = rhs._last_far_lat_title; _last_far_lat = rhs._last_far_lat; _last_far_lat_units = rhs._last_far_lat_units; _last_far_long_title = rhs._last_far_long_title; _last_far_long = rhs._last_far_long; _last_far_long_units = rhs._last_far_long_units; _swath_title = rhs._swath_title; _swath = rhs._swath; _pass_title = rhs._pass_title; _pass = rhs._pass; _sample_type_title = rhs._sample_type_title; _sample_type = rhs._sample_type; _algo_title = rhs._algo_title; _algorithm = rhs._algorithm; _mds1_tx_rx_polar_title = rhs._mds1_tx_rx_polar_title; _mds1_tx_rx_polar = rhs._mds1_tx_rx_polar; _mds2_tx_rx_polar_title = rhs._mds2_tx_rx_polar_title; _mds2_tx_rx_polar = rhs._mds2_tx_rx_polar; _compression_title = rhs._compression_title; _compression = rhs._compression; _azimut_looks_title = rhs._azimut_looks_title; _azimut_looks = rhs._azimut_looks; _range_looks_title = rhs._range_looks_title; _range_looks = rhs._range_looks; _range_spacing_title = rhs._range_spacing_title; _range_spacing = rhs._range_spacing; _range_spacing_unit = rhs._range_spacing_unit; _azimut_spacing_title = rhs._azimut_spacing_title; _azimut_spacing = rhs._azimut_spacing; _azimut_spacing_unit = rhs._azimut_spacing_unit; _line_time_interval_title = rhs._line_time_interval_title; _line_time_interval = rhs._line_time_interval; _line_time_interv_units = rhs._line_time_interv_units; _line_length_title = rhs._line_length_title; _line_length = rhs._line_length; _line_length_units = rhs._line_length_units; _data_type_title = rhs._data_type_title; _data_type = rhs._data_type; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/EnvisatAsar/sph.h000066400000000000000000000424511301006202600266660ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef sph_h #define sph_h #include #include #include #include #include namespace ossimplugins { /** * @ingroup sphRecord * @brief This class is able to read the SAR sph record of the ASAR file */ class sph : public EnvisatAsarRecord { public: /** * @brief Constructor */ sph(); /** * @brief Constructor Using an mph record to initialize num_dsd and dsd_size */ sph(const mph& data); /** * @brief Destructor */ virtual ~sph(); /** * @brief This function write the sph in a stream */ friend std::ostream& operator<<(std::ostream& os, const sph& data); /** * @brief This function read a sph from a stream */ friend std::istream& operator>>(std::istream& is, sph& data); /** * @brief Copy constructor */ sph(const sph& rhs); /** * @brief Copy operator */ sph& operator=(const sph& rhs); /** * @brief This function is able to create a new instance of the class */ EnvisatAsarRecord* Instantiate() { return new sph(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ EnvisatAsarRecord* Clone() { return new sph(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief sph_desc_title */ std::string get_sph_desc_title() { return _sph_desc_title; }; /** * @brief sph_desc */ std::string get_sph_desc() { return _sph_desc; }; /** * @brief strip_cont_ind_title */ std::string get_strip_cont_ind_title() { return _strip_cont_ind_title; }; /** * @brief strip_cont_ind */ std::string get_strip_cont_ind() { return _strip_cont_ind; }; /** * @brief slice_pos_title */ std::string get_slice_pos_title() { return _slice_pos_title; }; /** * @brief slice_position */ std::string get_slice_position() { return _slice_position; }; /** * @brief num_slices_title */ std::string get_num_slices_title() { return _num_slices_title; }; /** * @brief num_slices */ std::string get_num_slices() { return _num_slices; }; /** * @brief first_line_time_title */ std::string get_first_line_time_title() { return _first_line_time_title; }; /** * @brief first_line_time */ std::string get_first_line_time() { return _first_line_time; }; /** * @brief last_line_time_title */ std::string get_last_line_time_title() { return _last_line_time_title; }; /** * @brief last_line_time */ std::string get_last_line_time() { return _last_line_time; }; /** * @brief first_near_lat_title */ std::string get_first_near_lat_title() { return _first_near_lat_title; }; /** * @brief first_near_lat */ std::string get_first_near_lat() { return _first_near_lat; }; /** * @brief first_near_lat_units */ std::string get_first_near_lat_units() { return _first_near_lat_units; }; /** * @brief first_near_long_title */ std::string get_first_near_long_title() { return _first_near_long_title; }; /** * @brief first_near_long */ std::string get_first_near_long() { return _first_near_long; }; /** * @brief first_near_long_units */ std::string get_first_near_long_units() { return _first_near_long_units; }; /** * @brief first_mid_lat_title */ std::string get_first_mid_lat_title() { return _first_mid_lat_title; }; /** * @brief first_mid_lat */ std::string get_first_mid_lat() { return _first_mid_lat; }; /** * @brief first_mid_lat_units */ std::string get_first_mid_lat_units() { return _first_mid_lat_units; }; /** * @brief first_mid_long_title */ std::string get_first_mid_long_title() { return _first_mid_long_title; }; /** * @brief first_mid_long */ std::string get_first_mid_long() { return _first_mid_long; }; /** * @brief first_mid_long_units */ std::string get_first_mid_long_units() { return _first_mid_long_units; }; /** * @brief first_far_lat_title */ std::string get_first_far_lat_title() { return _first_far_lat_title; }; /** * @brief first_far_lat */ std::string get_first_far_lat() { return _first_far_lat; }; /** * @brief first_far_lat_units */ std::string get_first_far_lat_units() { return _first_far_lat_units; }; /** * @brief first_far_long_title */ std::string get_first_far_long_title() { return _first_far_long_title; }; /** * @brief first_far_long */ std::string get_first_far_long() { return _first_far_long; }; /** * @brief first_far_long_units */ std::string get_first_far_long_units() { return _first_far_long_units; }; /** * @brief last_near_lat_title */ std::string get_last_near_lat_title() { return _last_near_lat_title; }; /** * @brief last_near_lat */ std::string get_last_near_lat() { return _last_near_lat; }; /** * @brief last_near_lat_units */ std::string get_last_near_lat_units() { return _last_near_lat_units; }; /** * @brief last_near_long_title */ std::string get_last_near_long_title() { return _last_near_long_title; }; /** * @brief last_near_long */ std::string get_last_near_long() { return _last_near_long; }; /** * @brief last_near_long_units */ std::string get_last_near_long_units() { return _last_near_long_units; }; /** * @brief last_mid_lat_title */ std::string get_last_mid_lat_title() { return _last_mid_lat_title; }; /** * @brief last_mid_lat */ std::string get_last_mid_lat() { return _last_mid_lat; }; /** * @brief last_mid_lat_units */ std::string get_last_mid_lat_units() { return _last_mid_lat_units; }; /** * @brief last_mid_long_title */ std::string get_last_mid_long_title() { return _last_mid_long_title; }; /** * @brief last_mid_long */ std::string get_last_mid_long() { return _last_mid_long; }; /** * @brief last_mid_long_units */ std::string get_last_mid_long_units() { return _last_mid_long_units; }; /** * @brief last_far_lat_title */ std::string get_last_far_lat_title() { return _last_far_lat_title; }; /** * @brief last_far_lat */ std::string get_last_far_lat() { return _last_far_lat; }; /** * @brief last_far_lat_units */ std::string get_last_far_lat_units() { return _last_far_lat_units; }; /** * @brief last_far_long_title */ std::string get_last_far_long_title() { return _last_far_long_title; }; /** * @brief last_far_long */ std::string get_last_far_long() { return _last_far_long; }; /** * @brief last_far_long_units */ std::string get_last_far_long_units() { return _last_far_long_units; }; /** * @brief swath_title */ std::string get_swath_title() { return _swath_title; }; /** * @brief swath */ std::string get_swath() { return _swath; }; /** * @brief pass_title */ std::string get_pass_title() { return _pass_title; }; /** * @brief pass */ std::string get_pass() { return _pass; }; /** * @brief sample_type_title */ std::string get_sample_type_title() { return _sample_type_title; }; /** * @brief sample_type */ std::string get_sample_type() { return _sample_type; }; /** * @brief algo_title */ std::string get_algo_title() { return _algo_title; }; /** * @brief algorithm */ std::string get_algorithm() { return _algorithm; }; /** * @brief mds1_tx_rx_polar_title */ std::string get_mds1_tx_rx_polar_title() { return _mds1_tx_rx_polar_title; }; /** * @brief mds1_tx_rx_polar */ std::string get_mds1_tx_rx_polar() { return _mds1_tx_rx_polar; }; /** * @brief mds2_tx_rx_polar_title */ std::string get_mds2_tx_rx_polar_title() { return _mds2_tx_rx_polar_title; }; /** * @brief mds2_tx_rx_polar */ std::string get_mds2_tx_rx_polar() { return _mds2_tx_rx_polar; }; /** * @brief compression_title */ std::string get_compression_title() { return _compression_title; }; /** * @brief compression */ std::string get_compression() { return _compression; }; /** * @brief azimut_looks_title */ std::string get_azimut_looks_title() { return _azimut_looks_title; }; /** * @brief azimut_looks */ std::string get_azimut_looks() { return _azimut_looks; }; /** * @brief range_looks_title */ std::string get_range_looks_title() { return _range_looks_title; }; /** * @brief range_looks */ std::string get_range_looks() { return _range_looks; }; /** * @brief range_spacing_title */ std::string get_range_spacing_title() { return _range_spacing_title; }; /** * @brief range_spacing */ std::string get_range_spacing() { return _range_spacing; }; /** * @brief range_spacing_unit */ std::string get_range_spacing_unit() { return _range_spacing_unit; }; /** * @brief azimut_spacing_title */ std::string get_azimut_spacing_title() { return _azimut_spacing_title; }; /** * @brief azimut_spacing */ std::string get_azimut_spacing() { return _azimut_spacing; }; /** * @brief azimut_spacing_unit */ std::string get_azimut_spacing_unit() { return _azimut_spacing_unit; }; /** * @brief line_time_interval_title */ std::string get_line_time_interval_title() { return _line_time_interval_title; }; /** * @brief line_time_interval */ std::string get_line_time_interval() { return _line_time_interval; }; /** * @brief line_time_interv_units */ std::string get_line_time_interv_units() { return _line_time_interv_units; }; /** * @brief line_length_title */ std::string get_line_length_title() { return _line_length_title; }; /** * @brief line_length */ std::string get_line_length() { return _line_length; }; /** * @brief line_length_units */ std::string get_line_length_units() { return _line_length_units; }; /** * @brief data_type_title */ std::string get_data_type_title() { return _data_type_title; }; /** * @brief data_type */ std::string get_data_type() { return _data_type; }; /** * @brief data_type */ std::vector get_dsd_vector() { return _dsd_vector; } /** * @brief update DSD number and dsd size from a mph record */ bool update_sph_from_mph( mph& mph_rec) { _num_dsd = mph_rec._num_dsd; _size_dsd = mph_rec._dsd_size; return 1; }; protected: /** * @brief Number of Data Set Descriptors (DSD) */ long _num_dsd; /** * @brief Size of each Data Set Descriptors (DSD) */ long _size_dsd; /** * @brief sph_desc_title */ std::string _sph_desc_title; /** * @brief sph_desc */ std::string _sph_desc; /** * @brief strip_cont_ind_title */ std::string _strip_cont_ind_title; /** * @brief strip_cont_ind */ std::string _strip_cont_ind; /** * @brief slice_pos_title */ std::string _slice_pos_title; /** * @brief slice_position */ std::string _slice_position; /** * @brief num_slices_title */ std::string _num_slices_title; /** * @brief num_slices */ std::string _num_slices; /** * @brief first_line_time_title */ std::string _first_line_time_title; /** * @brief first_line_time */ std::string _first_line_time; /** * @brief last_line_time_title */ std::string _last_line_time_title; /** * @brief last_line_time */ std::string _last_line_time; /** * @brief first_near_lat_title */ std::string _first_near_lat_title; /** * @brief first_near_lat */ std::string _first_near_lat; /** * @brief first_near_lat_units */ std::string _first_near_lat_units; /** * @brief first_near_long_title */ std::string _first_near_long_title; /** * @brief first_near_long */ std::string _first_near_long; /** * @brief first_near_long_units */ std::string _first_near_long_units; /** * @brief first_mid_lat_title */ std::string _first_mid_lat_title; /** * @brief first_mid_lat */ std::string _first_mid_lat; /** * @brief first_mid_lat_units */ std::string _first_mid_lat_units; /** * @brief first_mid_long_title */ std::string _first_mid_long_title; /** * @brief first_mid_long */ std::string _first_mid_long; /** * @brief first_mid_long_units */ std::string _first_mid_long_units; /** * @brief first_far_lat_title */ std::string _first_far_lat_title; /** * @brief first_far_lat */ std::string _first_far_lat; /** * @brief first_far_lat_units */ std::string _first_far_lat_units; /** * @brief first_far_long_title */ std::string _first_far_long_title; /** * @brief first_far_long */ std::string _first_far_long; /** * @brief first_far_long_units */ std::string _first_far_long_units; /** * @brief last_near_lat_title */ std::string _last_near_lat_title; /** * @brief last_near_lat */ std::string _last_near_lat; /** * @brief last_near_lat_units */ std::string _last_near_lat_units; /** * @brief last_near_long_title */ std::string _last_near_long_title; /** * @brief last_near_long */ std::string _last_near_long; /** * @brief last_near_long_units */ std::string _last_near_long_units; /** * @brief last_mid_lat_title */ std::string _last_mid_lat_title; /** * @brief last_mid_lat */ std::string _last_mid_lat; /** * @brief last_mid_lat_units */ std::string _last_mid_lat_units; /** * @brief last_mid_long_title */ std::string _last_mid_long_title; /** * @brief last_mid_long */ std::string _last_mid_long; /** * @brief last_mid_long_units */ std::string _last_mid_long_units; /** * @brief last_far_lat_title */ std::string _last_far_lat_title; /** * @brief last_far_lat */ std::string _last_far_lat; /** * @brief last_far_lat_units */ std::string _last_far_lat_units; /** * @brief last_far_long_title */ std::string _last_far_long_title; /** * @brief last_far_long */ std::string _last_far_long; /** * @brief last_far_long_units */ std::string _last_far_long_units; /** * @brief swath_title */ std::string _swath_title; /** * @brief swath */ std::string _swath; /** * @brief pass_title */ std::string _pass_title; /** * @brief pass */ std::string _pass; /** * @brief sample_type_title */ std::string _sample_type_title; /** * @brief sample_type */ std::string _sample_type; /** * @brief algo_title */ std::string _algo_title; /** * @brief algorithm */ std::string _algorithm; /** * @brief mds1_tx_rx_polar_title */ std::string _mds1_tx_rx_polar_title; /** * @brief mds1_tx_rx_polar */ std::string _mds1_tx_rx_polar; /** * @brief mds2_tx_rx_polar_title */ std::string _mds2_tx_rx_polar_title; /** * @brief mds2_tx_rx_polar */ std::string _mds2_tx_rx_polar; /** * @brief compression_title */ std::string _compression_title; /** * @brief compression */ std::string _compression; /** * @brief azimut_looks_title */ std::string _azimut_looks_title; /** * @brief azimut_looks */ std::string _azimut_looks; /** * @brief range_looks_title */ std::string _range_looks_title; /** * @brief range_looks */ std::string _range_looks; /** * @brief range_spacing_title */ std::string _range_spacing_title; /** * @brief range_spacing */ std::string _range_spacing; /** * @brief range_spacing_unit */ std::string _range_spacing_unit; /** * @brief azimut_spacing_title */ std::string _azimut_spacing_title; /** * @brief azimut_spacing */ std::string _azimut_spacing; /** * @brief azimut_spacing_unit */ std::string _azimut_spacing_unit; /** * @brief line_time_interval_title */ std::string _line_time_interval_title; /** * @brief line_time_interval */ std::string _line_time_interval; /** * @brief line_time_interv_units */ std::string _line_time_interv_units; /** * @brief line_length_title */ std::string _line_length_title; /** * @brief line_length */ std::string _line_length; /** * @brief line_length_units */ std::string _line_length_units; /** * @brief data_type_title */ std::string _data_type_title; /** * @brief data_type */ std::string _data_type; /** * @brief DSD records */ std::vector _dsd_vector; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/000077500000000000000000000000001301006202600251765ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/000077500000000000000000000000001301006202600275655ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/AttitudeData.cpp000066400000000000000000000034551301006202600326550ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "AttitudeData.h" namespace ossimplugins { AttitudeData::AttitudeData() : RadarSatRecord("att_data_rec") { } AttitudeData::~AttitudeData() { } std::ostream& operator<<(std::ostream& os, const AttitudeData& data) { os<<"npoint:"<>(std::istream& is, AttitudeData& data) { char buf[6503]; buf[6502] = '\0'; is.read(buf,4); buf[4] = '\0'; data._npoint = atoi(buf); for (int i=0;i<20;i++) { is>>data._att_vect[i]; } is.read(buf,14); buf[14] = '\0'; data._pitch_bias = atof(buf); is.read(buf,14); buf[14] = '\0'; data._roll_bias = atof(buf); is.read(buf,14); buf[14] = '\0'; data._yaw_bias = atof(buf); is.read(buf,6502); return is; } AttitudeData::AttitudeData(const AttitudeData& rhs): RadarSatRecord(rhs) { _npoint = rhs._npoint; for (int i=0;i<20;i++) { _att_vect[i] = rhs._att_vect[i]; } _pitch_bias = rhs._pitch_bias; _roll_bias = rhs._roll_bias; _yaw_bias = rhs._yaw_bias; } AttitudeData& AttitudeData::operator=(const AttitudeData& rhs) { _npoint = rhs._npoint; for (int i=0;i<20;i++) { _att_vect[i] = rhs._att_vect[i]; } _pitch_bias = rhs._pitch_bias; _roll_bias = rhs._roll_bias; _yaw_bias = rhs._yaw_bias; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/AttitudeData.h000066400000000000000000000052711301006202600323200ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef AttitudeData_h #define AttitudeData_h #include #include #include #include "DataPointDataRecord.h" namespace ossimplugins { /** * @ingroup AttitudeDataRecord * @brief This class is able to read a Attitude data record */ class AttitudeData : public RadarSatRecord { public: /** * @brief Constructor */ AttitudeData(); /** * @brief Destructor */ ~AttitudeData(); /** * @brief Copy constructor */ AttitudeData(const AttitudeData& rhs); /** * @brief Copy operator */ AttitudeData& operator=(const AttitudeData& rhs); /** * @brief This function writes the AttitudeData in a stream */ friend std::ostream& operator<<(std::ostream& os, const AttitudeData& data); /** * @brief This function reads a AttitudeData from a stream */ friend std::istream& operator>>(std::istream& is, AttitudeData& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new AttitudeData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new AttitudeData(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Number of data points */ int get_npoint() { return _npoint; }; /** * @brief Data points */ DataPointDataRecord* get_att_vect() { return _att_vect; }; /** * @brief Pitch bias (degrees) */ double get_pitch_bias() { return _pitch_bias; }; /** * @brief Roll bias (degrees) */ double get_roll_bias() { return _roll_bias; }; /** * @brief Yaw bias (degrees) */ double get_yaw_bias() { return _yaw_bias; }; protected: /** * @brief Number of data points */ int _npoint; /** * @brief Data points */ DataPointDataRecord _att_vect[20]; /** * @brief Pitch bias (degrees) */ double _pitch_bias; /** * @brief Roll bias (degrees) */ double _roll_bias; /** * @brief Yaw bias (degrees) */ double _yaw_bias; private: }; } #endif BeamInformationRecord.cpp000066400000000000000000000031071301006202600344240ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "BeamInformationRecord.h" namespace ossimplugins { BeamInformationRecord::BeamInformationRecord() { } BeamInformationRecord::~BeamInformationRecord() { } std::ostream& operator<<(std::ostream& os, const BeamInformationRecord& data) { os<<"beam_type:"<>(std::istream& is, BeamInformationRecord& data) { char buf[17]; buf[16] = '\0'; is.read(buf,3); buf[3] = '\0'; data._beam_type = buf; is.read(buf,9); buf[9] = '\0'; data._beam_look_src = buf; is.read(buf,16); buf[16] = '\0'; data._beam_look_ang = atof(buf); is.read(buf,16); buf[16] = '\0'; data._prf = atof(buf); return is; } BeamInformationRecord::BeamInformationRecord(const BeamInformationRecord& rhs): _beam_type(rhs._beam_type), _beam_look_src(rhs._beam_look_src), _beam_look_ang(rhs._beam_look_ang), _prf(rhs._prf) { } BeamInformationRecord& BeamInformationRecord::operator=(const BeamInformationRecord& rhs) { _beam_type = rhs._beam_type; _beam_look_src = rhs._beam_look_src; _beam_look_ang = rhs._beam_look_ang; _prf = rhs._prf; return *this; } } BeamInformationRecord.h000066400000000000000000000040321301006202600340670ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef BeamInformationRecord_h #define BeamInformationRecord_h #include #include namespace ossimplugins { /** * @ingroup ProcessingParametersRecord * @brief This class is able to read a Beam information record */ class BeamInformationRecord { public: /** * @brief Constructor */ BeamInformationRecord(); /** * @brief Destructor */ ~BeamInformationRecord(); /** * @brief Copy constructor */ BeamInformationRecord(const BeamInformationRecord& rhs); /** * @brief Copy operator */ BeamInformationRecord& operator=(const BeamInformationRecord& rhs); /** * @brief This function writes the BeamInformationRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const BeamInformationRecord& data); /** * @brief This function reads a BeamInformationRecord from a stream */ friend std::istream& operator>>(std::istream& is, BeamInformationRecord& data); /** * @brief Beam type */ std::string get_beam_type() { return _beam_type; }; /** * @brief Elevation beam look angle source */ std::string get_beam_look_src() { return _beam_look_src; }; /** * @brief Applied elevation beam look angle (deg) */ double get_beam_look_ang() { return _beam_look_ang; }; /** * @brief Actual PRF (Hz) */ double get_prf() { return _prf; }; protected: /** * @brief Beam type */ std::string _beam_type; /** * @brief Elevation beam look angle source */ std::string _beam_look_src; /** * @brief Applied elevation beam look angle (deg) */ double _beam_look_ang; /** * @brief Actual PRF (Hz) */ double _prf; private: }; } #endif BeamPixelCountRecord.cpp000066400000000000000000000024701301006202600342330ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "BeamPixelCountRecord.h" namespace ossimplugins { BeamPixelCountRecord::BeamPixelCountRecord() { } BeamPixelCountRecord::~BeamPixelCountRecord() { } std::ostream& operator<<(std::ostream& os, const BeamPixelCountRecord& data) { os<<"pix_update:"<>(std::istream& is, BeamPixelCountRecord& data) { char buf[23]; buf[22] = '\0'; is.read(buf,21); data._pix_update = buf; for (int i=0;i<4;i++) { is.read(buf,8); buf[8] = '\0'; data._n_pix[i] = atoi(buf); } return is; } BeamPixelCountRecord::BeamPixelCountRecord(const BeamPixelCountRecord& rhs): _pix_update(rhs._pix_update) { for (int i=0;i<4;i++) { _n_pix[i] = rhs._n_pix[i]; } } BeamPixelCountRecord& BeamPixelCountRecord::operator=(const BeamPixelCountRecord& rhs) { _pix_update = rhs._pix_update; for (int i=0;i<4;i++) { _n_pix[i] = rhs._n_pix[i]; } return *this; } } BeamPixelCountRecord.h000066400000000000000000000032341301006202600336770ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef BeamPixelCountRecord_h #define BeamPixelCountRecord_h #include #include namespace ossimplugins { /** * @ingroup ProcessingParametersRecord * @brief This class is able to read a Beam pixel count record */ class BeamPixelCountRecord { public: /** * @brief Constructor */ BeamPixelCountRecord(); /** * @brief Destructor */ ~BeamPixelCountRecord(); /** * @brief Copy constructor */ BeamPixelCountRecord(const BeamPixelCountRecord& rhs); /** * @brief Copy operator */ BeamPixelCountRecord& operator=(const BeamPixelCountRecord& rhs); /** * @brief This function writes the BeamPixelCountRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const BeamPixelCountRecord& data); /** * @brief This function reads a BeamPixelCountRecord from a stream */ friend std::istream& operator>>(std::istream& is, BeamPixelCountRecord& data); /** * @brief Pixel count update date/time */ std::string get_pix_update() { return _pix_update; }; /** * @brief Count of image pixels in beams */ int* get_n_pix() { return _n_pix; }; protected: /** * @brief Pixel count update date/time */ std::string _pix_update; /** * @brief Count of image pixels in beams */ int _n_pix[4]; private: }; } #endif CompensationDataRecord.cpp000066400000000000000000000053611301006202600346070ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "CompensationDataRecord.h" namespace ossimplugins { CompensationDataRecord::CompensationDataRecord() { } CompensationDataRecord::~CompensationDataRecord() { } std::ostream& operator<<(std::ostream& os, const CompensationDataRecord& data) { os<<"comp_desig:"<>(std::istream& is, CompensationDataRecord& data) { char buf[33]; buf[32] = '\0'; is.read(buf,8); buf[8] = '\0'; data._comp_desig = buf; is.read(buf,32); buf[32] = '\0'; data._comp_descr = buf; is.read(buf,4); buf[4] = '\0'; data._n_comp_rec = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._comp_seq_no = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._beam_tab_size = atoi(buf); for (int i=0;i<256;i++) { is.read(buf,16); buf[16] = '\0'; data._beam_tab[i] = atof(buf); } is.read(buf,16); buf[16] = '\0'; data._beam_type = buf; is.read(buf,16); buf[16] = '\0'; data._look_angle = atof(buf); is.read(buf,16); buf[16] = '\0'; data._beam_tab_inc = atof(buf); return is; } CompensationDataRecord::CompensationDataRecord(const CompensationDataRecord& rhs) { _comp_desig = rhs._comp_desig; _comp_descr = rhs._comp_descr; _n_comp_rec = rhs._n_comp_rec; _comp_seq_no = rhs._comp_seq_no; _beam_tab_size = rhs._beam_tab_size; for (int i=0;i<256;i++) { _beam_tab[i] = rhs._beam_tab[i]; } _beam_type = rhs._beam_type; _look_angle = rhs._look_angle; _beam_tab_inc = rhs._beam_tab_inc; } CompensationDataRecord& CompensationDataRecord::operator=(const CompensationDataRecord& rhs) { _comp_desig = rhs._comp_desig; _comp_descr = rhs._comp_descr; _n_comp_rec = rhs._n_comp_rec; _comp_seq_no = rhs._comp_seq_no; _beam_tab_size = rhs._beam_tab_size; for (int i=0;i<256;i++) { _beam_tab[i] = rhs._beam_tab[i]; } _beam_type = rhs._beam_type; _look_angle = rhs._look_angle; _beam_tab_inc = rhs._beam_tab_inc; return *this; } } CompensationDataRecord.h000066400000000000000000000061301301006202600342470ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef CompensationDataRecord_h #define CompensationDataRecord_h #include #include #include namespace ossimplugins { /** * @ingroup RadiometricCompensationDataRecord * @brief This class is able to read a Compensation data record */ class CompensationDataRecord { public: /** * @brief Constructor */ CompensationDataRecord(); /** * @brief Destructor */ ~CompensationDataRecord(); /** * @brief Copy constructor */ CompensationDataRecord(const CompensationDataRecord& rhs); /** * @brief Copy operator */ CompensationDataRecord& operator=(const CompensationDataRecord& rhs); /** * @brief This function writes the CompensationDataRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const CompensationDataRecord& data); /** * @brief This function reads a CompensationDataRecord from a stream */ friend std::istream& operator>>(std::istream& is, CompensationDataRecord& data); /** * @brief Compensation data designator */ std::string get_comp_desig() { return _comp_desig; }; /** * @brief Compensation data descriptor */ std::string get_comp_descr() { return _comp_descr; }; /** * @brief Number of compensation records */ int get_n_comp_rec() { return _n_comp_rec; }; /** * @brief Compensation record sequence number */ int get_comp_seq_no() { return _comp_seq_no; }; /** * @brief Number of beam table entries */ int get_beam_tab_size() { return _beam_tab_size; }; /** * @brief Elevation gain beam profile */ double* get_beam_tab() { return _beam_tab; }; /** * @brief Beam type */ std::string get_beam_type() { return _beam_type; }; /** * @brief Look angle of beam table centre */ double get_look_angle() { return _look_angle; }; /** * @brief Increment between beam table entries */ double get_beam_tab_inc() { return _beam_tab_inc; }; protected: /** * @brief Compensation data designator */ std::string _comp_desig; /** * @brief Compensation data descriptor */ std::string _comp_descr; /** * @brief Number of compensation records */ int _n_comp_rec; /** * @brief Compensation record sequence number */ int _comp_seq_no; /** * @brief Number of beam table entries */ int _beam_tab_size; /** * @brief Elevation gain beam profile */ double _beam_tab[256]; /** * @brief Beam type */ std::string _beam_type; /** * @brief Look angle of beam table centre */ double _look_angle; /** * @brief Increment between beam table entries */ double _beam_tab_inc; private: }; } #endif DataHistogramRecord.cpp000066400000000000000000000112651301006202600341050ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "DataHistogramRecord.h" namespace ossimplugins { DataHistogramRecord::DataHistogramRecord(): _hist(NULL) { } DataHistogramRecord::~DataHistogramRecord() { if (_hist != NULL) delete[] _hist; } DataHistogramRecord::DataHistogramRecord(const DataHistogramRecord& rhs): _hist_desc(rhs._hist_desc), _nrec(rhs._nrec), _tab_seq(rhs._tab_seq), _nbin(rhs._nbin), _ns_lin(rhs._ns_lin), _ns_pix(rhs._ns_pix), _ngrp_lin(rhs._ngrp_lin), _ngrp_pix(rhs._ngrp_pix), _nsamp_lin(rhs._nsamp_lin), _nsamp_pix(rhs._nsamp_pix), _min_smp(rhs._min_smp), _max_smp(rhs._max_smp), _mean_smp(rhs._mean_smp), _std_smp(rhs._std_smp), _smp_inc(rhs._smp_inc), _min_hist(rhs._min_hist), _max_hist(rhs._max_hist), _mean_hist(rhs._mean_hist), _std_hist(rhs._std_hist), _nhist(rhs._nhist) { _hist = new int[rhs._nhist]; for (int i=0;i>(std::istream& is, DataHistogramRecord& data) { char buff[33]; buff[32] = '\0'; is.read(buff,32); data._hist_desc = buff; is.read(buff,4); buff[4] = '\0'; data._nrec = atoi(buff); is.read(buff,4); buff[4] = '\0'; data._tab_seq = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._nbin = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ns_lin = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ns_pix = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ngrp_lin = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ngrp_pix = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._nsamp_lin = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._nsamp_pix = atoi(buff); is.read(buff,16); buff[16] = '\0'; data._min_smp = atof(buff); is.read(buff,16); buff[16] = '\0'; data._max_smp = atof(buff); is.read(buff,16); buff[16] = '\0'; data._mean_smp = atof(buff); is.read(buff,16); buff[16] = '\0'; data._std_smp = atof(buff); is.read(buff,16); buff[16] = '\0'; data._smp_inc = atof(buff); is.read(buff,16); buff[16] = '\0'; data._min_hist = atof(buff); is.read(buff,16); buff[16] = '\0'; data._max_hist = atof(buff); is.read(buff,16); buff[16] = '\0'; data._mean_hist = atof(buff); is.read(buff,16); buff[16] = '\0'; data._std_hist = atof(buff); is.read(buff,8); buff[8] = '\0'; data._nhist = atoi(buff); if(data._hist != NULL) { delete[] data._hist; } //for (int i=0;i #include #include namespace ossimplugins { /** * @ingroup ProcessedData16bitHistogramRecord * @ingroup SignalDataHistogramRecord * @brief This class is able to read a data histogram record */ class DataHistogramRecord { public: /** * @brief Constructor */ DataHistogramRecord(); /** * @brief Destructor */ ~DataHistogramRecord(); /** * @brief Copy constructor */ DataHistogramRecord(const DataHistogramRecord& rhs); /** * @brief Copy operator */ DataHistogramRecord& operator=(const DataHistogramRecord& rhs); /** * @brief This function writes the DataHistogramRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const DataHistogramRecord& data); /** * @brief This function reads a DataHistogramRecord from a stream */ friend std::istream& operator>>(std::istream& is, DataHistogramRecord& data); /** * @brief Histogram descriptor */ std::string get_hist_desc() { return _hist_desc; }; /** * @brief Records per table */ int get_nrec() { return _nrec; }; /** * @brief Table sequence number */ int get_tab_seq() { return _tab_seq; }; /** * @brief Total number of table bins */ int get_nbin() { return _nbin; }; /** * @brief Total number of lines */ int get_ns_lin() { return _ns_lin; }; /** * @brief Total number of pixels per line */ int get_ns_pix() { return _ns_pix; }; /** * @brief Group size along line axis */ int get_ngrp_lin() { return _ngrp_lin; }; /** * @brief Group size along pixel axis */ int get_ngrp_pix() { return _ngrp_pix; }; /** * @brief Number of samples used per group along line axis */ int get_nsamp_lin() { return _nsamp_lin; }; /** * @brief Number of samples used per group along pixel */ int get_nsamp_pix() { return _nsamp_pix; }; /** * @brief Minimum first bin */ double get_min_smp() { return _min_smp; }; /** * @brief Maximum last bin */ double get_max_smp() { return _max_smp; }; /** * @brief Mean sample value */ double get_mean_smp() { return _mean_smp; }; /** * @brief Sample standard deviation */ double get_std_smp() { return _std_smp; }; /** * @brief Sample value increment */ double get_smp_inc() { return _smp_inc; }; /** * @brief Minimum histogram value */ double get_min_hist() { return _min_hist; }; /** * @brief Maximum histogram value */ double get_max_hist() { return _max_hist; }; /** * @brief Histogram mean value */ double get_mean_hist() { return _mean_hist; }; /** * @brief Histogram standard deviation */ double get_std_hist() { return _std_hist; }; /** * @brief Histogram table size */ int get_nhist() { return _nhist; }; /** * @brief Histogram table values of 16 bins for Ix16 bins for Q */ int* get_hist() { return _hist; }; protected: /** * @brief Histogram descriptor */ std::string _hist_desc; /** * @brief Records per table */ int _nrec; /** * @brief Table sequence number */ int _tab_seq; /** * @brief Total number of table bins */ int _nbin; /** * @brief Total number of lines */ int _ns_lin; /** * @brief Total number of pixels per line */ int _ns_pix; /** * @brief Group size along line axis */ int _ngrp_lin; /** * @brief Group size along pixel axis */ int _ngrp_pix; /** * @brief Number of samples used per group along line axis */ int _nsamp_lin; /** * @brief Number of samples used per group along pixel */ int _nsamp_pix; /** * @brief Minimum first bin */ double _min_smp; /** * @brief Maximum last bin */ double _max_smp; /** * @brief Mean sample value */ double _mean_smp; /** * @brief Sample standard deviation */ double _std_smp; /** * @brief Sample value increment */ double _smp_inc; /** * @brief Minimum histogram value */ double _min_hist; /** * @brief Maximum histogram value */ double _max_hist; /** * @brief Histogram mean value */ double _mean_hist; /** * @brief Histogram standard deviation */ double _std_hist; /** * @brief Histogram table size */ int _nhist; /** * @brief Histogram table values */ int* _hist; private: }; } #endif DataHistogramSignalData.cpp000066400000000000000000000033441301006202600346750ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "DataHistogramSignalData.h" namespace ossimplugins { DataHistogramSignalData::DataHistogramSignalData() : RadarSatRecord("sdr_hist_rec") { } DataHistogramSignalData::~DataHistogramSignalData() { } std::ostream& operator<<(std::ostream& os, const DataHistogramSignalData& data) { os<<"rec_seq:"<>(std::istream& is, DataHistogramSignalData& data) { char buff[33]; buff[32] = '\0'; is.read(buff,4); buff[4] = '\0'; data._rec_seq = atoi(buff); is.read(buff,4); buff[4] = '\0'; data._sar_chn = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ntab = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ltab = atoi(buff); is>>data._histogram; char tmp[14589]; tmp[14588] = '\0'; is.read(tmp, 14588); return is; } DataHistogramSignalData::DataHistogramSignalData(const DataHistogramSignalData& rhs) : RadarSatRecord(rhs), _rec_seq(rhs._rec_seq), _sar_chn(rhs._sar_chn), _ntab(rhs._ntab), _ltab(rhs._ltab), _histogram(rhs._histogram) { } DataHistogramSignalData& DataHistogramSignalData::operator=(const DataHistogramSignalData& rhs) { _histogram = rhs._histogram; _sar_chn = rhs._sar_chn; _rec_seq = rhs._rec_seq; _ntab = rhs._ntab; _ltab = rhs._ltab; return *this; } } DataHistogramSignalData.h000066400000000000000000000057441301006202600343500ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DataHistogramSignalData_h #define DataHistogramSignalData_h #include #include #include #include "DataHistogramRecord.h" namespace ossimplugins { /** * @ingroup SignalDataHistogramRecord * @brief This class is able to read a data histogram record - Signal data */ class DataHistogramSignalData : public RadarSatRecord { public: /** * @brief Constructor */ DataHistogramSignalData(); /** * @brief Destructor */ virtual ~DataHistogramSignalData(); /** * @brief Copy constructor */ DataHistogramSignalData(const DataHistogramSignalData& rhs); /** * @brief Copy operator */ DataHistogramSignalData& operator=(const DataHistogramSignalData& rhs); /** * @brief This function writes the DataHistogramSignalData in a stream */ friend std::ostream& operator<<(std::ostream& os, const DataHistogramSignalData& data); /** * @brief This function reads a DataHistogramSignalData from a stream */ friend std::istream& operator>>(std::istream& is, DataHistogramSignalData& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new DataHistogramSignalData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new DataHistogramSignalData(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Record sequence number */ int get_rec_seq() { return _rec_seq; }; /** * @brief SAR channel indicator */ int get_sar_chn() { return _sar_chn; }; /** * @brief Number of histogram table data sets in this record */ int get_ntab() { return _ntab; }; /** * @brief Histogram table data set size */ int get_ltab() { return _ltab; }; /** * @brief Histogram data record */ DataHistogramRecord get_histogram() { return _histogram; }; protected: /** * @brief Record sequence number */ int _rec_seq; /** * @brief SAR channel indicator */ int _sar_chn; /** * @brief Number of histogram table data sets in this record */ int _ntab; /** * @brief Histogram table data set size */ int _ltab; /** * @brief Histogram data record */ DataHistogramRecord _histogram; private: }; typedef DataHistogramSignalData DataHistogramProcessedData8; } #endif DataPointDataRecord.cpp000066400000000000000000000064761301006202600340430ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "DataPointDataRecord.h" namespace ossimplugins { DataPointDataRecord::DataPointDataRecord() { } DataPointDataRecord::~DataPointDataRecord() { } std::ostream& operator<<(std::ostream& os, const DataPointDataRecord& data) { os<<"gmt_day:"<>(std::istream& is, DataPointDataRecord& data) { char buf[15]; buf[14] = '\0'; is.read(buf,4); buf[4] = '\0'; data._gmt_day = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._gmt_sec = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._pitch_flag = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._roll_flag = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._yaw_flag = atoi(buf); is.read(buf,14); buf[14] = '\0'; data._pitch = atof(buf); is.read(buf,14); buf[14] = '\0'; data._roll = atof(buf); is.read(buf,14); buf[14] = '\0'; data._yaw = atof(buf); is.read(buf,4); buf[4] = '\0'; data._pitch_rate_flag = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._roll_rate_flag = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._yaw_rate_flag = atoi(buf); is.read(buf,14); buf[14] = '\0'; data._pitch_rate = atof(buf); is.read(buf,14); buf[14] = '\0'; data._roll_rate = atof(buf); is.read(buf,14); buf[14] = '\0'; data._yaw_rate = atof(buf); return is; } DataPointDataRecord::DataPointDataRecord(const DataPointDataRecord& rhs) { _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _pitch_flag = rhs._pitch_flag; _roll_flag = rhs._roll_flag; _yaw_flag = rhs._yaw_flag; _pitch = rhs._pitch; _roll = rhs._roll; _yaw = rhs._yaw; _pitch_rate_flag = rhs._pitch_rate_flag; _roll_rate_flag = rhs._roll_rate_flag; _yaw_rate_flag = rhs._yaw_rate_flag; _pitch_rate = rhs._pitch_rate; _roll_rate = rhs._roll_rate; _yaw_rate = rhs._yaw_rate; } DataPointDataRecord& DataPointDataRecord::operator=(const DataPointDataRecord& rhs) { _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _pitch_flag = rhs._pitch_flag; _roll_flag = rhs._roll_flag; _yaw_flag = rhs._yaw_flag; _pitch = rhs._pitch; _roll = rhs._roll; _yaw = rhs._yaw; _pitch_rate_flag = rhs._pitch_rate_flag; _roll_rate_flag = rhs._roll_rate_flag; _yaw_rate_flag = rhs._yaw_rate_flag; _pitch_rate = rhs._pitch_rate; _roll_rate = rhs._roll_rate; _yaw_rate = rhs._yaw_rate; return *this; } } DataPointDataRecord.h000066400000000000000000000073211301006202600334760ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DataPointDataRecord_h #define DataPointDataRecord_h #include #include #include namespace ossimplugins { /** * @ingroup AttitudeDataRecord * @brief This class is able to read a Data point data record */ class DataPointDataRecord { public: /** * @brief Constructor */ DataPointDataRecord(); /** * @brief Destructor */ ~DataPointDataRecord(); /** * @brief Copy constructor */ DataPointDataRecord(const DataPointDataRecord& rhs); /** * @brief Copy operator */ DataPointDataRecord& operator=(const DataPointDataRecord& rhs); /** * @brief This function writes the DataPointDataRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const DataPointDataRecord& data); /** * @brief This function reads a DataPointDataRecord from a stream */ friend std::istream& operator>>(std::istream& is, DataPointDataRecord& data); /** * @brief Day of the year, GMT */ int get_gmt_day() { return _gmt_day; }; /** * @brief Milliseconds of day, GMT */ int get_gmt_sec() { return _gmt_sec; }; /** * @brief Pitch data quality flag */ int get_pitch_flag() { return _pitch_flag; }; /** * @brief Roll data quality flag */ int get_roll_flag() { return _roll_flag; }; /** * @brief Yaw data quality flag */ int get_yaw_flag() { return _yaw_flag; }; /** * @brief Pitch error, degrees */ double get_pitch() { return _pitch; }; /** * @brief Roll error, degrees */ double get_roll() { return _roll; }; /** * @brief Yaw error, degrees */ double get_yaw() { return _yaw; }; /** * @brief Pitch rate data quality flag */ int get_pitch_rate_flag() { return _pitch_rate_flag; }; /** * @brief Roll rate data quality fla */ int get_roll_rate_flag() { return _roll_rate_flag; }; /** * @brief Yaw rate data quality flag */ int get_yaw_rate_flag() { return _yaw_rate_flag; }; /** * @brief Pitch rate, degrees/sec */ double get_pitch_rate() { return _pitch_rate; }; /** * @brief Roll rate, degrees/sec */ double get_roll_rate() { return _roll_rate; }; /** * @brief Yaw rate, degrees/sec */ double get_yaw_rate() { return _yaw_rate; }; protected: /** * @brief Day of the year, GMT */ int _gmt_day; /** * @brief Milliseconds of day, GMT */ int _gmt_sec; /** * @brief Pitch data quality flag */ int _pitch_flag; /** * @brief Roll data quality flag */ int _roll_flag; /** * @brief Yaw data quality flag */ int _yaw_flag; /** * @brief Pitch error, degrees */ double _pitch; /** * @brief Roll error, degrees */ double _roll; /** * @brief Yaw error, degrees */ double _yaw; /** * @brief Pitch rate data quality flag */ int _pitch_rate_flag; /** * @brief Roll rate data quality fla */ int _roll_rate_flag; /** * @brief Yaw rate data quality flag */ int _yaw_rate_flag; /** * @brief Pitch rate, degrees/sec */ double _pitch_rate; /** * @brief Roll rate, degrees/sec */ double _roll_rate; /** * @brief Yaw rate, degrees/sec */ double _yaw_rate; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/DataQuality.cpp000066400000000000000000000127571301006202600325270ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "DataQuality.h" namespace ossimplugins { DataQuality::DataQuality() : RadarSatRecord("qual_sum_rec") { } DataQuality::~DataQuality() { } std::ostream& operator<<(std::ostream& os, const DataQuality& data) { os<<"rec_seq:"<>(std::istream& is, DataQuality& data) { char buf[2149]; buf[2148] = '\0'; is.read(buf,4); buf[4] = '\0'; data._rec_seq = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._sar_chn = buf; is.read(buf,6); buf[6] = '\0'; data._cali_date = buf; is.read(buf,4); buf[4] = '\0'; data._nchn = atoi(buf); is.read(buf,16); buf[16] = '\0'; data._islr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._pslr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._azi_ambig = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rng_ambig = atof(buf); is.read(buf,16); buf[16] = '\0'; data._snr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._ber = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rng_res = atof(buf); is.read(buf,16); buf[16] = '\0'; data._azi_res = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rad_res = atof(buf); is.read(buf,16); buf[16] = '\0'; data._dyn_rng = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rad_unc_db = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rad_unc_deg = atof(buf); for (int i=0;i<16;i++) { is>>data._rad_unc[i]; } is.read(buf,16); buf[16] = '\0'; data._alt_locerr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._crt_locerr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._alt_scale = atof(buf); is.read(buf,16); buf[16] = '\0'; data._crt_scale = atof(buf); is.read(buf,16); buf[16] = '\0'; data._dis_skew = atof(buf); is.read(buf,16); buf[16] = '\0'; data._ori_err = atof(buf); for (int i=0;i<16;i++) { is>>data._misreg[i]; } is.read(buf,16); buf[16] = '\0'; data._nesz = atof(buf); is.read(buf,16); buf[16] = '\0'; data._enl = atof(buf); is.read(buf,8); buf[8] = '\0'; data._tb_update = buf; is.read(buf,238); return is; } DataQuality::DataQuality(const DataQuality& rhs): RadarSatRecord(rhs), _rec_seq(rhs._rec_seq), _sar_chn(rhs._sar_chn), _cali_date(rhs._cali_date), _nchn(rhs._nchn), _islr(rhs._islr), _pslr(rhs._pslr), _azi_ambig(rhs._azi_ambig), _rng_ambig(rhs._rng_ambig), _snr(rhs._snr), _ber(rhs._ber), _rng_res(rhs._rng_res), _azi_res(rhs._azi_res), _rad_res(rhs._rad_res), _dyn_rng(rhs._dyn_rng), _rad_unc_db(rhs._rad_unc_db), _rad_unc_deg(rhs._rad_unc_deg), _alt_locerr(rhs._alt_locerr), _crt_locerr(rhs._crt_locerr), _alt_scale(rhs._alt_scale), _crt_scale(rhs._crt_scale), _dis_skew(rhs._dis_skew), _ori_err(rhs._ori_err), _nesz(rhs._nesz), _enl(rhs._enl), _tb_update(rhs._tb_update) { for (int i=0;i<16;i++) { _rad_unc[i] = rhs._rad_unc[i]; } for (int i=0;i<16;i++) { _misreg[i] = rhs._misreg[i]; } } DataQuality& DataQuality::operator=(const DataQuality& rhs) { _rec_seq = rhs._rec_seq; _sar_chn = rhs._sar_chn; _cali_date = rhs._cali_date; _nchn = rhs._nchn; _islr = rhs._islr; _pslr = rhs._pslr; _azi_ambig = rhs._azi_ambig; _rng_ambig = rhs._rng_ambig; _snr = rhs._snr; _ber = rhs._ber; _rng_res = rhs._rng_res; _azi_res = rhs._azi_res; _rad_res = rhs._rad_res; _dyn_rng = rhs._dyn_rng; _rad_unc_db = rhs._rad_unc_db; _rad_unc_deg = rhs._rad_unc_deg; for (int i=0;i<16;i++) { _rad_unc[i] = rhs._rad_unc[i]; } _alt_locerr = rhs._alt_locerr; _crt_locerr = rhs._crt_locerr; _alt_scale = rhs._alt_scale; _crt_scale = rhs._crt_scale; _dis_skew = rhs._dis_skew; _ori_err = rhs._ori_err; for (int i=0;i<16;i++) { _misreg[i] = rhs._misreg[i]; } _nesz = rhs._nesz; _enl = rhs._enl; _tb_update = rhs._tb_update; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/DataQuality.h000066400000000000000000000156421301006202600321700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DataQuality_h #define DataQuality_h #include #include #include #include "RadiometryUncertaintyRecord.h" #include "MisregistrationRecord.h" namespace ossimplugins { /** * @ingroup DataQualitySummaryRecord * @brief This class is able to read a data quality record */ class DataQuality : public RadarSatRecord { public: /** * @brief Constructor */ DataQuality(); /** * @brief Destructor */ virtual ~DataQuality(); /** * @brief Copy constructor */ DataQuality(const DataQuality& rhs); /** * @brief Copy operator */ DataQuality& operator=(const DataQuality& rhs); /** * @brief This function writes the DataQuality in a stream */ friend std::ostream& operator<<(std::ostream& os, const DataQuality& data); /** * @brief This function reads a DataQuality from a stream */ friend std::istream& operator>>(std::istream& is, DataQuality& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new DataQuality(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new DataQuality(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Record sequence number */ int get_rec_seq() { return _rec_seq; }; /** * @brief SAR channel indicator */ std::string get_sar_chn() { return _sar_chn; }; /** * @brief Calibration update date */ std::string get_cali_date() { return _cali_date; }; /** * @brief Number of channels */ int get_nchn() { return _nchn; }; /** * @brief Nominal integrated side lobe ratio */ double get_islr() { return _islr; }; /** * @brief Nominal peak side lobe ratio */ double get_pslr() { return _pslr; }; /** * @brief Nominal azimuth ambiguity */ double get_azi_ambig() { return _azi_ambig; }; /** * @brief Nominal range ambiguity */ double get_rng_ambig() { return _rng_ambig; }; /** * @brief Nominal signal to noise ratio */ double get_snr() { return _snr; }; /** * @brief Nominal bit error rate */ double get_ber() { return _ber; }; /** * @brief Nominal slant range resolution */ double get_rng_res() { return _rng_res; }; /** * @brief Nominal azimuth resolution,meter */ double get_azi_res() { return _azi_res; }; /** * @brief Nominal radiometric resolution,dB */ double get_rad_res() { return _rad_res; }; /** * @brief Instantaneous dynamic range */ double get_dyn_rng() { return _dyn_rng; }; /** * @brief Nominal radiometric uncertainty,dB */ double get_rad_unc_db() { return _rad_unc_db; }; /** * @brief Nominal Radiometric uncertainty,deg */ double get_rad_unc_deg() { return _rad_unc_deg; }; /** * @brief Radiometric data quality */ RadiometryUncertaintyRecord* get_rad_unc() { return _rad_unc; }; /** * @brief Nominal along track location error */ double get_alt_locerr() { return _alt_locerr; }; /** * @brief Nominal cross track location error */ double get_crt_locerr() { return _crt_locerr; }; /** * @brief Nominal along track distortion scale */ double get_alt_scale() { return _alt_scale; }; /** * @brief Nominal cross track distortion scale */ double get_crt_scale() { return _crt_scale; }; /** * @brief Nominal distortion skew */ double get_dis_skew() { return _dis_skew; }; /** * @brief Nominal Scene orientation error */ double get_ori_err() { return _ori_err; }; /** * @brief Misregistration error */ MisregistrationRecord* get_misreg() { return _misreg; }; /** * @brief Nominal noise equivalent sigma zero */ double get_nesz() { return _nesz; }; /** * @brief Nominal equivalent number of looks */ double get_enl() { return _enl; }; /** * @brief Default parameters table update date */ std::string get_tb_update() { return _tb_update; }; protected: /** * @brief Record sequence number */ int _rec_seq; /** * @brief SAR channel indicator */ std::string _sar_chn; /** * @brief Calibration update date */ std::string _cali_date; /** * @brief Number of channels */ int _nchn; /** * @brief Nominal integrated side lobe ratio */ double _islr; /** * @brief Nominal peak side lobe ratio */ double _pslr; /** * @brief Nominal azimuth ambiguity */ double _azi_ambig; /** * @brief Nominal range ambiguity */ double _rng_ambig; /** * @brief Nominal signal to noise ratio */ double _snr; /** * @brief Nominal bit error rate */ double _ber; /** * @brief Nominal slant range resolution */ double _rng_res; /** * @brief Nominal azimuth resolution,meter */ double _azi_res; /** * @brief Nominal radiometric resolution,dB */ double _rad_res; /** * @brief Instantaneous dynamic range */ double _dyn_rng; /** * @brief Nominal radiometric uncertainty,dB */ double _rad_unc_db; /** * @brief Nominal Radiometric uncertainty,deg */ double _rad_unc_deg; /** * @brief Radiometric data quality */ RadiometryUncertaintyRecord _rad_unc[16]; /** * @brief Nominal along track location error */ double _alt_locerr; /** * @brief Nominal cross track location error */ double _crt_locerr; /** * @brief Nominal along track distortion scale */ double _alt_scale; /** * @brief Nominal cross track distortion scale */ double _crt_scale; /** * @brief Nominal distortion skew */ double _dis_skew; /** * @brief Nominal Scene orientation error */ double _ori_err; /** * @brief Misregistration error */ MisregistrationRecord _misreg[16]; /** * @brief Nominal noise equivalent sigma zero */ double _nesz; /** * @brief Nominal equivalent number of looks */ double _enl; /** * @brief Default parameters table update date */ std::string _tb_update; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/DataSetSummary.cpp000066400000000000000000000445101301006202600332000ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "DataSetSummary.h" namespace ossimplugins { DataSetSummary::DataSetSummary() : RadarSatRecord("dataset_sum_rec") { } DataSetSummary::~DataSetSummary() { } std::ostream& operator<<(std::ostream& os, const DataSetSummary& data) { os<<"seq_num:"<>(std::istream& is, DataSetSummary& data) { char buf16[17]; buf16[16]='\0'; char buf32[33]; buf32[32] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf4[5]; buf4[4] = '\0'; is.read(buf4,4); data._seq_num = atoi(buf4); is.read(buf4,4); data._sar_chn = atoi(buf4); is.read(buf16,16); data._scene_id = buf16; is.read(buf32,32); data._scene_des = buf32; is.read(buf32,32); data._inp_sctim = buf32; is.read(buf16,16); data._asc_des = buf16; is.read(buf16,16); data._pro_lat = atof(buf16); is.read(buf16,16); data._pro_long = atof(buf16); is.read(buf16,16); data._pro_head = atof(buf16); is.read(buf16,16); data._ellip_des = buf16; is.read(buf16,16); data._ellip_maj = atof(buf16); is.read(buf16,16); data._ellip_min = atof(buf16); is.read(buf16,16); data._earth_mass = atof(buf16); is.read(buf16,16); data._grav_const = atof(buf16); is.read(buf16,16); data._ellip_j[0] = atof(buf16); is.read(buf16,16); data._ellip_j[1] = atof(buf16); is.read(buf16,16); data._ellip_j[2] = atof(buf16); is.read(buf16,16); is.read(buf16,16); data._terrain_h = atof(buf16); is.read(buf8,8); data._sc_lin = atoi(buf8); is.read(buf8,8); data._sc_pix = atoi(buf8); is.read(buf16,16); data._scene_len = atof(buf16); is.read(buf16,16); data._scene_wid = atof(buf16); is.read(buf16,16); is.read(buf4,4); data._nchn = atoi(buf4); is.read(buf4,4); is.read(buf16,16); data._mission_id = buf16; is.read(buf32,32); data._sensor_id = buf32; is.read(buf8,8); data._orbit_num = buf8; is.read(buf8,8); data._plat_lat = atof(buf8); is.read(buf8,8); data._plat_long = atof(buf8); is.read(buf8,8); data._plat_head = atof(buf8); is.read(buf8,8); data._clock_ang = atof(buf8); is.read(buf8,8); data._incident_ang = atof(buf8); is.read(buf8,8); is.read(buf16,16); data._wave_length = atof(buf16); is.read(buf8,2); buf8[2] = '\0'; data._motion_comp = buf8; is.read(buf16,16); data._pulse_code = buf16; for (int i=0;i<5;i++) { is.read(buf16,16); data._ampl_coef[i] = atof(buf16); } for (int i=0;i<5;i++) { is.read(buf16,16); data._phas_coef[i] = atof(buf16); } is.read(buf8,8); data._chirp_ext_ind = atoi(buf8); is.read(buf8,8); is.read(buf16,16); data._fr = atof(buf16); is.read(buf16,16); data._rng_gate = atof(buf16); is.read(buf16,16); data._rng_length = atof(buf16); is.read(buf8,4); buf8[4] = '\0'; data._baseband_f = buf8; is.read(buf8,4); buf8[4] = '\0'; data._rngcmp_f = buf8; is.read(buf16,16); data._gn_polar = atof(buf16); is.read(buf16,16); data._gn_cross = atof(buf16); is.read(buf8,8); data._chn_bits = atoi(buf8); is.read(buf16,12); buf16[12] = '\0'; data._quant_desc = buf16; is.read(buf16,16); data._i_bias = atof(buf16); is.read(buf16,16); data._q_bias = atof(buf16); is.read(buf16,16); data._iq_ratio = atof(buf16); is.read(buf16,16); is.read(buf16,16); is.read(buf16,16); data._ele_sight = atof(buf16); is.read(buf16,16); data._mech_sight = atof(buf16); is.read(buf4,4); data._echo_track = buf4; is.read(buf16,16); data._fa = atof(buf16); is.read(buf16,16); data._elev_beam = atof(buf16); is.read(buf16,16); data._azim_beam = atof(buf16); is.read(buf16,16); data._sat_bintim = atoi(buf16); is.read(buf32,32); data._sat_clktim = atoi(buf32); is.read(buf8,8); data._sat_clkinc = atoi(buf8); is.read(buf8,8); is.read(buf16,16); data._fac_id = buf16; is.read(buf8,8); data._sys_id = buf8; is.read(buf8,8); data._ver_id = buf8; is.read(buf16,16); data._fac_code = buf16; is.read(buf16,16); data._lev_code = buf16; is.read(buf32,32); data._prod_type = buf32; is.read(buf32,32); data._algor_id = buf32; is.read(buf16,16); data._n_azilok = atof(buf16); is.read(buf16,16); data._n_rnglok = atof(buf16); is.read(buf16,16); data._bnd_azilok = atof(buf16); is.read(buf16,16); data._bnd_rnglok = atof(buf16); is.read(buf16,16); data._bnd_azi = atof(buf16); is.read(buf16,16); data._bnd_rng = atof(buf16); is.read(buf32,32); data._azi_weight = buf32; is.read(buf32,32); data._rng_weight = buf32; is.read(buf16,16); data._data_inpsrc = buf16; is.read(buf16,16); data._rng_res = atof(buf16); is.read(buf16,16); data._azi_res = atof(buf16); is.read(buf16,16); data._radi_stretch[0] = atof(buf16); is.read(buf16,16); data._radi_stretch[1] = atof(buf16); is.read(buf16,16); data._alt_dopcen[0] = atof(buf16); is.read(buf16,16); data._alt_dopcen[1] = atof(buf16); is.read(buf16,16); data._alt_dopcen[2] = atof(buf16); is.read(buf16,16); is.read(buf16,16); data._crt_dopcen[0] = atof(buf16); is.read(buf16,16); data._crt_dopcen[1] = atof(buf16); is.read(buf16,16); data._crt_dopcen[2] = atof(buf16); is.read(buf8,8); data._time_dir_pix = buf8; is.read(buf8,8); data._time_dir_lin = buf8; is.read(buf16,16); data._alt_rate[0] = atof(buf16); is.read(buf16,16); data._alt_rate[1] = atof(buf16); is.read(buf16,16); data._alt_rate[2] = atof(buf16); is.read(buf16,16); is.read(buf16,16); data._crt_rate[0] = atof(buf16); is.read(buf16,16); data._crt_rate[1] = atof(buf16); is.read(buf16,16); data._crt_rate[2] = atof(buf16); is.read(buf16,16); is.read(buf8,8); data._line_cont = buf8; is.read(buf4,4); data._clutter_lock = buf4; is.read(buf4,4); data._auto_focus = buf4; is.read(buf16,16); data._line_spacing = atof(buf16); is.read(buf16,16); data._pix_spacing = atof(buf16); is.read(buf16,16); data._rngcmp_desg = buf16; char buf[2363]; buf[2362] = '\0'; is.read(buf,2362); return is; } DataSetSummary::DataSetSummary(const DataSetSummary& rhs): RadarSatRecord(rhs), _seq_num(rhs._seq_num), _sar_chn(rhs._sar_chn), _scene_id(rhs._scene_id), _scene_des(rhs._scene_des), _inp_sctim(rhs._inp_sctim), _asc_des(rhs._asc_des), _pro_lat(rhs._pro_lat), _pro_long(rhs._pro_long), _pro_head(rhs._pro_head), _ellip_des(rhs._ellip_des), _ellip_maj(rhs._ellip_maj), _ellip_min(rhs._ellip_min), _earth_mass(rhs._earth_mass), _grav_const(rhs._grav_const), _terrain_h(rhs._terrain_h), _sc_lin(rhs._sc_lin), _sc_pix(rhs._sc_pix), _scene_len(rhs._scene_len), _scene_wid(rhs._scene_wid), _nchn(rhs._nchn), _mission_id(rhs._mission_id), _sensor_id(rhs._sensor_id), _orbit_num(rhs._orbit_num), _plat_lat(rhs._plat_lat), _plat_long(rhs._plat_long), _plat_head(rhs._plat_head), _clock_ang(rhs._clock_ang), _incident_ang(rhs._incident_ang), _wave_length(rhs._wave_length), _motion_comp(rhs._motion_comp), _pulse_code(rhs._pulse_code), _chirp_ext_ind(rhs._chirp_ext_ind), _fr(rhs._fr), _rng_gate(rhs._rng_gate), _rng_length(rhs._rng_length), _baseband_f(rhs._baseband_f), _rngcmp_f(rhs._rngcmp_f), _gn_polar(rhs._gn_polar), _gn_cross(rhs._gn_cross), _chn_bits(rhs._chn_bits), _quant_desc(rhs._quant_desc), _i_bias(rhs._i_bias), _q_bias(rhs._q_bias), _iq_ratio(rhs._iq_ratio), _ele_sight(rhs._ele_sight), _mech_sight(rhs._mech_sight), _echo_track(rhs._echo_track), _fa(rhs._fa), _elev_beam(rhs._elev_beam), _azim_beam(rhs._azim_beam), _sat_bintim(rhs._sat_bintim), _sat_clktim(rhs._sat_clktim), _sat_clkinc(rhs._sat_clkinc), _fac_id(rhs._fac_id), _sys_id(rhs._sys_id), _ver_id(rhs._ver_id), _fac_code(rhs._fac_code), _lev_code(rhs._lev_code), _prod_type(rhs._prod_type), _algor_id(rhs._algor_id), _n_azilok(rhs._n_azilok), _n_rnglok(rhs._n_rnglok), _bnd_azilok(rhs._bnd_azilok), _bnd_rnglok(rhs._bnd_rnglok), _bnd_azi(rhs._bnd_azi), _bnd_rng(rhs._bnd_rng), _azi_weight(rhs._azi_weight), _rng_weight(rhs._rng_weight), _data_inpsrc(rhs._data_inpsrc), _rng_res(rhs._rng_res), _azi_res(rhs._azi_res), _time_dir_pix(rhs._time_dir_pix), _time_dir_lin(rhs._time_dir_lin), _line_cont(rhs._line_cont), _clutter_lock(rhs._clutter_lock), _auto_focus(rhs._auto_focus), _line_spacing(rhs._line_spacing), _pix_spacing(rhs._pix_spacing), _rngcmp_desg(rhs._rngcmp_desg) { _ellip_j[0] = rhs._ellip_j[0]; _ellip_j[1] = rhs._ellip_j[1]; _ellip_j[2] = rhs._ellip_j[2]; _ampl_coef[0] = rhs._ampl_coef[0]; _ampl_coef[1] = rhs._ampl_coef[1]; _ampl_coef[2] = rhs._ampl_coef[2]; _ampl_coef[3] = rhs._ampl_coef[3]; _ampl_coef[4] = rhs._ampl_coef[4]; _phas_coef[0] = rhs._phas_coef[0]; _phas_coef[1] = rhs._phas_coef[1]; _phas_coef[2] = rhs._phas_coef[2]; _phas_coef[3] = rhs._phas_coef[3]; _phas_coef[4] = rhs._phas_coef[4]; _radi_stretch[0] = rhs._radi_stretch[0]; _radi_stretch[1] = rhs._radi_stretch[1]; _alt_dopcen[0] = rhs._alt_dopcen[0]; _alt_dopcen[1] = rhs._alt_dopcen[1]; _alt_dopcen[2] = rhs._alt_dopcen[2]; _crt_dopcen[0] = rhs._crt_dopcen[0]; _crt_dopcen[1] = rhs._crt_dopcen[1]; _crt_dopcen[2] = rhs._crt_dopcen[2]; _alt_rate[0] = rhs._alt_rate[0]; _alt_rate[1] = rhs._alt_rate[1]; _alt_rate[2] = rhs._alt_rate[2]; _crt_rate[0] = rhs._crt_rate[0]; _crt_rate[1] = rhs._crt_rate[1]; _crt_rate[2] = rhs._crt_rate[2]; } DataSetSummary& DataSetSummary::operator=(const DataSetSummary& rhs) { _seq_num = rhs._seq_num; _sar_chn = rhs._sar_chn; _scene_id = rhs._scene_id; _scene_des = rhs._scene_des; _inp_sctim = rhs._inp_sctim; _asc_des = rhs._asc_des; _pro_lat = rhs._pro_lat; _pro_long = rhs._pro_long; _pro_head = rhs._pro_head; _ellip_des = rhs._ellip_des; _ellip_maj = rhs._ellip_maj; _ellip_min = rhs._ellip_min; _earth_mass = rhs._earth_mass; _grav_const = rhs._grav_const; _terrain_h = rhs._terrain_h; _sc_lin = rhs._sc_lin; _sc_pix = rhs._sc_pix; _scene_len = rhs._scene_len; _scene_wid = rhs._scene_wid; _nchn = rhs._nchn; _mission_id = rhs._mission_id; _sensor_id = rhs._sensor_id; _orbit_num = rhs._orbit_num; _plat_lat = rhs._plat_lat; _plat_long = rhs._plat_long; _plat_head = rhs._plat_head; _clock_ang = rhs._clock_ang; _incident_ang = rhs._incident_ang; _wave_length = rhs._wave_length; _motion_comp = rhs._motion_comp; _pulse_code = rhs._pulse_code; _chirp_ext_ind = rhs._chirp_ext_ind; _fr = rhs._fr; _rng_gate = rhs._rng_gate; _rng_length = rhs._rng_length; _baseband_f = rhs._baseband_f; _rngcmp_f = rhs._rngcmp_f; _gn_polar = rhs._gn_polar; _gn_cross = rhs._gn_cross; _chn_bits = rhs._chn_bits; _quant_desc = rhs._quant_desc; _i_bias = rhs._i_bias; _q_bias = rhs._q_bias; _iq_ratio = rhs._iq_ratio; _ele_sight = rhs._ele_sight; _mech_sight = rhs._mech_sight; _echo_track = rhs._echo_track; _fa = rhs._fa; _elev_beam = rhs._elev_beam; _azim_beam = rhs._azim_beam; _sat_bintim = rhs._sat_bintim; _sat_clktim = rhs._sat_clktim; _sat_clkinc = rhs._sat_clkinc; _fac_id = rhs._fac_id; _sys_id = rhs._sys_id; _ver_id = rhs._ver_id; _fac_code = rhs._fac_code; _lev_code = rhs._lev_code; _prod_type = rhs._prod_type; _algor_id = rhs._algor_id; _n_azilok = rhs._n_azilok; _n_rnglok = rhs._n_rnglok; _bnd_azilok = rhs._bnd_azilok; _bnd_rnglok = rhs._bnd_rnglok; _bnd_azi = rhs._bnd_azi; _bnd_rng = rhs._bnd_rng; _azi_weight = rhs._azi_weight; _rng_weight = rhs._rng_weight; _data_inpsrc = rhs._data_inpsrc; _rng_res = rhs._rng_res; _azi_res = rhs._azi_res; _time_dir_pix = rhs._time_dir_pix; _time_dir_lin = rhs._time_dir_lin; _line_cont = rhs._line_cont; _clutter_lock = rhs._clutter_lock; _auto_focus = rhs._auto_focus; _line_spacing = rhs._line_spacing; _pix_spacing = rhs._pix_spacing; _rngcmp_desg = rhs._rngcmp_desg; _ellip_j[0] = rhs._ellip_j[0]; _ellip_j[1] = rhs._ellip_j[1]; _ellip_j[2] = rhs._ellip_j[2]; _ampl_coef[0] = rhs._ampl_coef[0]; _ampl_coef[1] = rhs._ampl_coef[1]; _ampl_coef[2] = rhs._ampl_coef[2]; _ampl_coef[3] = rhs._ampl_coef[3]; _ampl_coef[4] = rhs._ampl_coef[4]; _phas_coef[0] = rhs._phas_coef[0]; _phas_coef[1] = rhs._phas_coef[1]; _phas_coef[2] = rhs._phas_coef[2]; _phas_coef[3] = rhs._phas_coef[3]; _phas_coef[4] = rhs._phas_coef[4]; _radi_stretch[0] = rhs._radi_stretch[0]; _radi_stretch[1] = rhs._radi_stretch[1]; _alt_dopcen[0] = rhs._alt_dopcen[0]; _alt_dopcen[1] = rhs._alt_dopcen[1]; _alt_dopcen[2] = rhs._alt_dopcen[2]; _crt_dopcen[0] = rhs._crt_dopcen[0]; _crt_dopcen[1] = rhs._crt_dopcen[1]; _crt_dopcen[2] = rhs._crt_dopcen[2]; _alt_rate[0] = rhs._alt_rate[0]; _alt_rate[1] = rhs._alt_rate[1]; _alt_rate[2] = rhs._alt_rate[2]; _crt_rate[0] = rhs._crt_rate[0]; _crt_rate[1] = rhs._crt_rate[1]; _crt_rate[2] = rhs._crt_rate[2]; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/DataSetSummary.h000066400000000000000000000434371301006202600326540ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DataSetSummary_h #define DataSetSummary_h #include #include #include namespace ossimplugins { /** * @ingroup DataSetSummaryRecord * @brief This class is able to read the SAR leader data set summary record of the leader file */ class DataSetSummary : public RadarSatRecord { public: /** * @brief Constructor */ DataSetSummary(); /** * @brief Destructor */ virtual ~DataSetSummary(); /** * @brief This function write the DataSetSummary in a stream */ friend std::ostream& operator<<(std::ostream& os, const DataSetSummary& data); /** * @brief This function read a DataSetSummary from a stream */ friend std::istream& operator>>(std::istream& is, DataSetSummary& data); /** * @brief Copy constructor */ DataSetSummary(const DataSetSummary& rhs); /** * @brief Copy operator */ DataSetSummary& operator=(const DataSetSummary& rhs); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new DataSetSummary(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new DataSetSummary(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Sequence number */ int get_seq_num() { return _seq_num; }; /** * @brief SAR channel indicator */ int get_sar_chn() { return _sar_chn; }; /** * @brief Scene identifier */ std::string get_scene_id() { return _scene_id; }; /** * @brief Scene designator */ std::string get_scene_des() { return _scene_des; }; /** * @brief Input scene centre time */ std::string get_inp_sctim() { return _inp_sctim; }; /** * @brief Ascending/descending */ std::string get_asc_des() { return _asc_des; }; /** * @brief Processed scene centre latitude */ double get_pro_lat() { return _pro_lat; }; /** * @brief Processed scene centre longitude */ double get_pro_long() { return _pro_long; }; /** * @brief Processed scene centre headng */ double get_pro_head() { return _pro_head; }; /** * @brief Ellipsoid designator */ std::string get_ellip_des() { return _ellip_des; }; /** * @brief Ellipsoid semi-major axis, km */ double get_ellip_maj() { return _ellip_maj; }; /** * @brief Ellipsoid semi_minor axis, km */ double get_ellip_min() { return _ellip_min; }; /** * @brief Earth's mass */ double get_earth_mass() { return _earth_mass; }; /** * @brief Gravitational constant */ double get_grav_const() { return _grav_const; }; /** * @brief Ellipsoid J2-4 parameters */ double* get_ellip_j() { return _ellip_j; }; /** * @brief Average terrain height, km */ double get_terrain_h() { return _terrain_h; }; /** * @brief Scene centre line number */ int get_sc_lin() { return _sc_lin; }; /** * @brief Scene centre pixel number */ int get_sc_pix() { return _sc_pix; }; /** * @brief Scene length, km */ double get_scene_len() { return _scene_len; }; /** * @brief Scene width, km */ double get_scene_wid() { return _scene_wid; }; /** * @brief Number of SAR channels */ double get_nchn() { return _nchn; }; /** * @brief Mission identifier */ std::string get_mission_id() { return _mission_id; }; /** * @brief Sensor identifier */ std::string get_sensor_id() { return _sensor_id; }; /** * @brief Orbit number */ std::string get_orbit_num() { return _orbit_num; }; /** * @brief Platform geodetic latitude */ double get_plat_lat() { return _plat_lat; }; /** * @brief Platform geodetic longitude */ double get_plat_long() { return _plat_long; }; /** * @brief Platform heading */ double get_plat_head() { return _plat_head; }; /** * @brief Sensor clock angle */ double get_clock_ang() { return _clock_ang; }; /** * @brief Incidence angle */ double get_incident_ang() { return _incident_ang; }; /** * @brief Radar wave length */ double get_wave_length() { return _wave_length; }; /** * @brief Motion compensation indicator */ std::string get_motion_comp() { return _motion_comp; }; /** * @brief Range pulse code specifier */ std::string get_pulse_code() { return _pulse_code; }; /** * @brief Range chirp coefficients */ double* get_ampl_coef() { return _ampl_coef; }; /** * @brief Range phase coefficients */ double* get_phas_coef() { return _phas_coef; }; /** * @brief Chirp extraction index */ int get_chirp_ext_ind() { return _chirp_ext_ind; }; /** * @brief Range sampling rate */ double get_fr() { return _fr; }; /** * @brief Range gate start time */ double get_rng_gate() { return _rng_gate; }; /** * @brief Range pulse length */ double get_rng_length() { return _rng_length; }; /** * @brief Baseband conversion flag */ std::string get_baseband_f() { return _baseband_f; }; /** * @brief Range compressed flag */ std::string get_rngcmp_f() { return _rngcmp_f; }; /** * @brief Like polarized gain */ double get_gn_polar() { return _gn_polar; }; /** * @brief Cross polarized gain */ double get_gn_cross() { return _gn_cross; }; /** * @brief Number of bits per channel */ int get_chn_bits() { return _chn_bits; }; /** * @brief Quantization descriptor */ std::string get_quant_desc() { return _quant_desc; }; /** * @brief I channel DC bias */ double get_i_bias() { return _i_bias; }; /** * @brief Q channel DC bias */ double get_q_bias() { return _q_bias; }; /** * @brief I/Q channel ratio */ double get_iq_ratio() { return _iq_ratio; }; /** * @brief Electronic boresight */ double get_ele_sight() { return _ele_sight; }; /** * @brief Mechanical boresight */ double get_mech_sight() { return _mech_sight; }; /** * @brief Echo tracker on/off flag */ std::string get_echo_track() { return _echo_track; }; /** * @brief Nominal PRF, Hz */ double get_fa() { return _fa; }; /** * @brief Elevation beamwidth */ double get_elev_beam() { return _elev_beam; }; /** * @brief Azimuth beamwidth */ double get_azim_beam() { return _azim_beam; }; /** * @brief Satellite binary time */ int get_sat_bintim() { return _sat_bintim; }; /** * @brief Satellite clock time */ int get_sat_clktim() { return _sat_clktim; }; /** * @brief Satellite clock increment */ int get_sat_clkinc() { return _sat_clkinc; }; /** * @brief Processing facility identifier */ std::string get_fac_id() { return _fac_id; }; /** * @brief Processing system identifier */ std::string get_sys_id() { return _sys_id; }; /** * @brief Processing version identifier */ std::string get_ver_id() { return _ver_id; }; /** * @brief Facility process code */ std::string get_fac_code() { return _fac_code; }; /** * @brief Product level code */ std::string get_lev_code() { return _lev_code; }; /** * @brief Product type specifier */ std::string get_prod_type() { return _prod_type; }; /** * @brief Processing algorithm identifier */ std::string get_algor_id() { return _algor_id; }; /** * @brief Number of azimuth looks */ double get_n_azilok() { return _n_azilok; }; /** * @brief Number of range looks */ double get_n_rnglok() { return _n_rnglok; }; /** * @brief Bandwidth per look in azimuth,Hz */ double get_bnd_azilok() { return _bnd_azilok; }; /** * @brief Bandwidth per look in range,Hz */ double get_bnd_rnglok() { return _bnd_rnglok; }; /** * @brief Total azimuth look bandwidth */ double get_bnd_azi() { return _bnd_azi; }; /** * @brief Total range look bandwidth */ double get_bnd_rng() { return _bnd_rng; }; /** * @brief Azimuth weighting designator */ std::string get_azi_weight() { return _azi_weight; }; /** * @brief Range weighting designator */ std::string get_rng_weight() { return _rng_weight; }; /** * @brief Data input source */ std::string get_data_inpsrc() { return _data_inpsrc; }; /** * @brief Range resolution, meter */ double get_rng_res() { return _rng_res; }; /** * @brief Azimuth resolution, meter */ double get_azi_res() { return _azi_res; }; /** * @brief Radiometric stretch terms */ double* get_radi_stretch() { return _radi_stretch; }; /** * @brief Along track Doppler frequency terms */ double* get_alt_dopcen() { return _alt_dopcen; }; /** * @brief Cross track Doppler frequency terms */ double* get_crt_dopcen() { return _crt_dopcen; }; /** * @brief Pixel time direction indicator */ std::string get_time_dir_pix() { return _time_dir_pix; }; /** * @brief Line time direction indicator */ std::string get_time_dir_lin() { return _time_dir_lin; }; /** * @brief Along track Doppler rate term */ double* get_alt_rate() { return _alt_rate; }; /** * @brief Cross track Doppler rate term */ double* get_crt_rate() { return _crt_rate; }; /** * @brief Line content indicator */ std::string get_line_cont() { return _line_cont; }; /** * @brief Clutter lock applied flag */ std::string get_clutter_lock() { return _clutter_lock; }; /** * @brief Auto-focus applied flag */ std::string get_auto_focus() { return _auto_focus; }; /** * @brief Line spacing, meters */ double get_line_spacing() { return _line_spacing; }; /** * @brief Pixel spacing, meters */ double get_pix_spacing() { return _pix_spacing; }; /** * @brief Range compression designator */ std::string get_rngcmp_desg() { return _rngcmp_desg; }; protected: /** * @brief Sequence number */ int _seq_num; /** * @brief SAR channel indicator */ int _sar_chn; /** * @brief Scene identifier */ std::string _scene_id; /** * @brief Scene designator */ std::string _scene_des; /** * @brief Input scene centre time */ std::string _inp_sctim; /** * @brief Ascending/descending */ std::string _asc_des; /** * @brief Processed scene centre latitude */ double _pro_lat; /** * @brief Processed scene centre longitude */ double _pro_long; /** * @brief Processed scene centre headng */ double _pro_head; /** * @brief Ellipsoid designator */ std::string _ellip_des; /** * @brief Ellipsoid semi-major axis, km */ double _ellip_maj; /** * @brief Ellipsoid semi_minor axis, km */ double _ellip_min; /** * @brief Earth's mass */ double _earth_mass; /** * @brief Gravitational constant */ double _grav_const; /** * @brief Ellipsoid J2-4 parameters */ double _ellip_j[3]; /** * @brief Average terrain height, km */ double _terrain_h; /** * @brief Scene centre line number */ int _sc_lin; /** * @brief Scene centre pixel number */ int _sc_pix; /** * @brief Scene length, km */ double _scene_len; /** * @brief Scene width, km */ double _scene_wid; /** * @brief Number of SAR channels */ double _nchn; /** * @brief Mission identifier */ std::string _mission_id; /** * @brief Sensor identifier */ std::string _sensor_id; /** * @brief Orbit number */ std::string _orbit_num; /** * @brief Platform geodetic latitude */ double _plat_lat; /** * @brief Platform geodetic longitude */ double _plat_long; /** * @brief Platform heading */ double _plat_head; /** * @brief Sensor clock angle */ double _clock_ang; /** * @brief Incidence angle */ double _incident_ang; /** * @brief Radar wave length */ double _wave_length; /** * @brief Motion compensation indicator */ std::string _motion_comp; /** * @brief Range pulse code specifier */ std::string _pulse_code; /** * @brief Range chirp coefficients */ double _ampl_coef[5]; /** * @brief Range phase coefficients */ double _phas_coef[5]; /** * @brief Chirp extraction index */ int _chirp_ext_ind; /** * @brief Range sampling rate */ double _fr; /** * @brief Range gate start time */ double _rng_gate; /** * @brief Range pulse length */ double _rng_length; /** * @brief Baseband conversion flag */ std::string _baseband_f; /** * @brief Range compressed flag */ std::string _rngcmp_f; /** * @brief Like polarized gain */ double _gn_polar; /** * @brief Cross polarized gain */ double _gn_cross; /** * @brief Number of bits per channel */ int _chn_bits; /** * @brief Quantization descriptor */ std::string _quant_desc; /** * @brief I channel DC bias */ double _i_bias; /** * @brief Q channel DC bias */ double _q_bias; /** * @brief I/Q channel ratio */ double _iq_ratio; /** * @brief Electronic boresight */ double _ele_sight; /** * @brief Mechanical boresight */ double _mech_sight; /** * @brief Echo tracker on/off flag */ std::string _echo_track; /** * @brief Nominal PRF, Hz */ double _fa; /** * @brief Elevation beamwidth */ double _elev_beam; /** * @brief Azimuth beamwidth */ double _azim_beam; /** * @brief Satellite binary time */ int _sat_bintim; /** * @brief Satellite clock time */ int _sat_clktim; /** * @brief Satellite clock increment */ int _sat_clkinc; /** * @brief Processing facility identifier */ std::string _fac_id; /** * @brief Processing system identifier */ std::string _sys_id; /** * @brief Processing version identifier */ std::string _ver_id; /** * @brief Facility process code */ std::string _fac_code; /** * @brief Product level code */ std::string _lev_code; /** * @brief Product type specifier */ std::string _prod_type; /** * @brief Processing algorithm identifier */ std::string _algor_id; /** * @brief Number of azimuth looks */ double _n_azilok; /** * @brief Number of range looks */ double _n_rnglok; /** * @brief Bandwidth per look in azimuth,Hz */ double _bnd_azilok; /** * @brief Bandwidth per look in range,Hz */ double _bnd_rnglok; /** * @brief Total azimuth look bandwidth */ double _bnd_azi; /** * @brief Total range look bandwidth */ double _bnd_rng; /** * @brief Azimuth weighting designator */ std::string _azi_weight; /** * @brief Range weighting designator */ std::string _rng_weight; /** * @brief Data input source */ std::string _data_inpsrc; /** * @brief Range resolution, meter */ double _rng_res; /** * @brief Azimuth resolution, meter */ double _azi_res; /** * @brief Radiometric stretch terms */ double _radi_stretch[2]; /** * @brief Along track Doppler frequency terms */ double _alt_dopcen[3]; /** * @brief Cross track Doppler frequency terms */ double _crt_dopcen[3]; /** * @brief Pixel time direction indicator */ std::string _time_dir_pix; /** * @brief Line time direction indicator */ std::string _time_dir_lin; /** * @brief Along track Doppler rate term */ double _alt_rate[3]; /** * @brief Cross track Doppler rate term */ double _crt_rate[3]; /** * @brief Line content indicator */ std::string _line_cont; /** * @brief Clutter lock applied flag */ std::string _clutter_lock; /** * @brief Auto-focus applied flag */ std::string _auto_focus; /** * @brief Line spacing, meters */ double _line_spacing; /** * @brief Pixel spacing, meters */ double _pix_spacing; /** * @brief Range compression designator */ std::string _rngcmp_desg; private: }; } #endif DopplerCentroidEstimateRecord.cpp000066400000000000000000000032771301006202600361530ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "DopplerCentroidEstimateRecord.h" namespace ossimplugins { DopplerCentroidEstimateRecord::DopplerCentroidEstimateRecord() { } DopplerCentroidEstimateRecord::~DopplerCentroidEstimateRecord() { } std::ostream& operator<<(std::ostream& os, const DopplerCentroidEstimateRecord& data) { os<<"dopcen_conf:"<>(std::istream& is, DopplerCentroidEstimateRecord& data) { char buf[17]; buf[16] = '\0'; is.read(buf,16); buf[16] = '\0'; data._dopcen_conf = atof(buf); is.read(buf,16); buf[16] = '\0'; data._dopcen_ref_tim = atof(buf); for (int i=0;i<4;i++) { is.read(buf,16); buf[16] = '\0'; data._dopcen_coef[i] = atof(buf); } return is; } DopplerCentroidEstimateRecord::DopplerCentroidEstimateRecord(const DopplerCentroidEstimateRecord& rhs): _dopcen_conf(rhs._dopcen_conf), _dopcen_ref_tim(rhs._dopcen_ref_tim) { for (int i=0;i<4;i++) { _dopcen_coef[i] = rhs._dopcen_coef[i]; } } DopplerCentroidEstimateRecord& DopplerCentroidEstimateRecord::operator=(const DopplerCentroidEstimateRecord& rhs) { _dopcen_conf = rhs._dopcen_conf; _dopcen_ref_tim = rhs._dopcen_ref_tim; for (int i=0;i<4;i++) { _dopcen_coef[i] = rhs._dopcen_coef[i]; } return *this; } } DopplerCentroidEstimateRecord.h000066400000000000000000000040261301006202600356110ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DopplerCentroidEstimateRecord_h #define DopplerCentroidEstimateRecord_h #include #include namespace ossimplugins { /** * @ingroup ProcessingParametersRecord * @brief This class is able to read a Doppler centroid estimates record */ class DopplerCentroidEstimateRecord { public: /** * @brief Constructor */ DopplerCentroidEstimateRecord(); /** * @brief Destructor */ ~DopplerCentroidEstimateRecord(); /** * @brief Copy constructor */ DopplerCentroidEstimateRecord(const DopplerCentroidEstimateRecord& rhs); /** * @brief Copy operator */ DopplerCentroidEstimateRecord& operator=(const DopplerCentroidEstimateRecord& rhs); /** * @brief This function writes the DopplerCentroidEstimateRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const DopplerCentroidEstimateRecord& data); /** * @brief This function reads a DopplerCentroidEstimateRecord from a stream */ friend std::istream& operator>>(std::istream& is, DopplerCentroidEstimateRecord& data); /** * @brief Doppler centroid confidence measure */ double get_dopcen_conf() { return _dopcen_conf; } /** * @brief Doppler centroid reference time (sec) */ double get_dopcen_ref_tim() { return _dopcen_ref_tim; } /** * @brief Doppler centroid coefficients */ double* get_dopcen_coef() { return _dopcen_coef; } protected: /** * @brief Doppler centroid confidence measure */ double _dopcen_conf; /** * @brief Doppler centroid reference time (sec) */ double _dopcen_ref_tim; /** * @brief Doppler centroid coefficients */ double _dopcen_coef[4]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/FileDescriptor.cpp000066400000000000000000000211601301006202600332070ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "FileDescriptor.h" namespace ossimplugins { FileDescriptor::FileDescriptor() : RadarSatRecord("sar_desc_rec") { } FileDescriptor::~FileDescriptor() { } std::ostream& operator<<(std::ostream& os, const FileDescriptor& data) { os<<"ascii_flag:"<>(std::istream& is, FileDescriptor& data) { char buf2[3]; buf2[2] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf16[17]; buf16[16] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf6[7]; buf6[6] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf64[65]; buf64[64] = '\0'; char buf60[61]; buf60[60] = '\0'; char buf288[289]; buf288[288] = '\0'; is.read(buf2,2); data._ascii_flag = buf2; is.read(buf2,2); is.read(buf12,12); data._format_doc = buf12; is.read(buf2,2); data._format_ver = buf2; is.read(buf2,2); data._design_rev = buf2; is.read(buf12,12); data._software_id = buf12; is.read(buf4,4); data._file_num = atoi(buf4); is.read(buf16,16); data._file_name = buf16; is.read(buf4,4); data._rec_seq = buf4; is.read(buf8,8); data._seq_loc = atoi(buf8); is.read(buf4,4); data._seq_len = atoi(buf4); is.read(buf4,4); data._rec_code = buf4; is.read(buf8,8); data._code_loc = atoi(buf8); is.read(buf4,4); data._code_len = atoi(buf4); is.read(buf4,4); data._rec_len = buf4; is.read(buf8,8); data._rlen_loc = atoi(buf8); is.read(buf4,4); data._rlen_len = atoi(buf4); is.read(buf4,4); is.read(buf64,64); is.read(buf6,6); data._n_dataset = atoi(buf6); is.read(buf6,6); data._l_dataset = atoi(buf6); is.read(buf6,6); data._n_map_proj = atoi(buf6); is.read(buf6,6); data._l_map_proj = atoi(buf6); is.read(buf6,6); data._n_plat_pos = atoi(buf6); is.read(buf6,6); data._l_plat_pos = atoi(buf6); is.read(buf6,6); data._n_att_data = atoi(buf6); is.read(buf6,6); data._l_att_data = atoi(buf6); is.read(buf6,6); data._n_radi_data = atoi(buf6); is.read(buf6,6); data._l_radi_data = atoi(buf6); is.read(buf6,6); data._n_radi_comp = atoi(buf6); is.read(buf6,6); data._l_radi_comp = atoi(buf6); is.read(buf6,6); data._n_qual_sum = atoi(buf6); is.read(buf6,6); data._l_qual_sum = atoi(buf6); is.read(buf6,6); data._n_data_his = atoi(buf6); is.read(buf6,6); data._l_data_his = atoi(buf6); is.read(buf6,6); data._n_rang_spec = atoi(buf6); is.read(buf6,6); data._l_rang_spec = atoi(buf6); is.read(buf6,6); data._n_dem_desc = atoi(buf6); is.read(buf6,6); data._l_dem_desc = atoi(buf6); is.read(buf6,6); data._n_radar_par = atoi(buf6); is.read(buf6,6); data._l_radar_par = atoi(buf6); is.read(buf6,6); data._n_anno_data = atoi(buf6); is.read(buf6,6); data._l_anno_data = atoi(buf6); is.read(buf6,6); data._n_det_proc = atoi(buf6); is.read(buf6,6); data._l_det_proc = atoi(buf6); is.read(buf6,6); data._n_cal = atoi(buf6); is.read(buf6,6); data._l_cal = atoi(buf6); is.read(buf6,6); data._n_gcp = atoi(buf6); is.read(buf6,6); data._l_gcp = atoi(buf6); is.read(buf60,60); is.read(buf6,6); data._n_fac_data = atoi(buf6); is.read(buf6,6); data._l_fac_data = atoi(buf6); is.read(buf288,288); return is; } FileDescriptor::FileDescriptor(const FileDescriptor& rhs): RadarSatRecord(rhs), _ascii_flag(rhs._ascii_flag), _format_doc(rhs._format_doc), _format_ver(rhs._format_ver), _design_rev(rhs._design_rev), _software_id(rhs._software_id), _file_num(rhs._file_num), _file_name(rhs._file_name), _rec_seq(rhs._rec_seq), _seq_loc(rhs._seq_loc), _seq_len(rhs._seq_len), _rec_code(rhs._rec_code), _code_loc(rhs._code_loc), _code_len(rhs._code_len), _rec_len(rhs._rec_len), _rlen_loc(rhs._rlen_loc), _rlen_len(rhs._rlen_len), _n_dataset(rhs._n_dataset), _l_dataset(rhs._l_dataset), _n_map_proj(rhs._n_map_proj), _l_map_proj(rhs._l_map_proj), _n_plat_pos(rhs._n_plat_pos), _l_plat_pos(rhs._l_plat_pos), _n_att_data(rhs._n_att_data), _l_att_data(rhs._l_att_data), _n_radi_data(rhs._n_radi_data), _l_radi_data(rhs._l_radi_data), _n_radi_comp(rhs._n_radi_comp), _l_radi_comp(rhs._l_radi_comp), _n_qual_sum(rhs._n_qual_sum), _l_qual_sum(rhs._l_qual_sum), _n_data_his(rhs._n_data_his), _l_data_his(rhs._l_data_his), _n_rang_spec(rhs._n_rang_spec), _l_rang_spec(rhs._l_rang_spec), _n_dem_desc(rhs._n_dem_desc), _l_dem_desc(rhs._l_dem_desc), _n_radar_par(rhs._n_radar_par), _l_radar_par(rhs._l_radar_par), _n_anno_data(rhs._n_anno_data), _l_anno_data(rhs._l_anno_data), _n_det_proc(rhs._n_det_proc), _l_det_proc(rhs._l_det_proc), _n_cal(rhs._n_cal), _l_cal(rhs._l_cal), _n_gcp(rhs._n_gcp), _l_gcp(rhs._l_gcp), _n_fac_data(rhs._n_fac_data), _l_fac_data(rhs._l_fac_data) { } FileDescriptor& FileDescriptor::operator=(const FileDescriptor& rhs) { _ascii_flag = rhs._ascii_flag; _format_doc = rhs._format_doc; _format_ver = rhs._format_ver; _design_rev = rhs._design_rev; _software_id = rhs._software_id; _file_num = rhs._file_num; _file_name = rhs._file_name; _rec_seq = rhs._rec_seq; _seq_loc = rhs._seq_loc; _seq_len = rhs._seq_len; _rec_code = rhs._rec_code; _code_loc = rhs._code_loc; _code_len = rhs._code_len; _rec_len = rhs._rec_len; _rlen_loc = rhs._rlen_loc; _rlen_len = rhs._rlen_len; _n_dataset = rhs._n_dataset; _l_dataset = rhs._l_dataset; _n_map_proj = rhs._n_map_proj; _l_map_proj = rhs._l_map_proj; _n_plat_pos = rhs._n_plat_pos; _l_plat_pos = rhs._l_plat_pos; _n_att_data = rhs._n_att_data; _l_att_data = rhs._l_att_data; _n_radi_data = rhs._n_radi_data; _l_radi_data = rhs._l_radi_data; _n_radi_comp = rhs._n_radi_comp; _l_radi_comp = rhs._l_radi_comp; _n_qual_sum = rhs._n_qual_sum ; _l_qual_sum = rhs._l_qual_sum; _n_data_his = rhs._n_data_his; _l_data_his = rhs._l_data_his; _n_rang_spec = rhs._n_rang_spec; _l_rang_spec = rhs._l_rang_spec; _n_dem_desc = rhs._n_dem_desc; _l_dem_desc = rhs._l_dem_desc; _n_radar_par = rhs._n_radar_par; _l_radar_par = rhs._l_radar_par; _n_anno_data = rhs._n_anno_data; _l_anno_data = rhs._l_anno_data; _n_det_proc = rhs._n_det_proc; _l_det_proc = rhs._l_det_proc; _n_cal = rhs._n_cal; _l_cal = rhs._l_cal; _n_gcp = rhs._n_gcp; _l_gcp = rhs._l_gcp; _n_fac_data = rhs._n_fac_data; _l_fac_data = rhs._l_fac_data; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/FileDescriptor.h000066400000000000000000000250751301006202600326650ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef FileDescriptor_h #define FileDescriptor_h #include #include #include namespace ossimplugins { /** * @ingroup SARLeaderFileDescriptorRecord * @brief This class is able to read the SAR leader file descriptor record of the leader file */ class FileDescriptor : public RadarSatRecord { public: /** * @brief Constructor */ FileDescriptor(); /** * @brief Destructor */ virtual ~FileDescriptor(); /** * @brief This function writes the FileDescriptor in a stream */ friend std::ostream& operator<<(std::ostream& os, const FileDescriptor& data); /** * @brief This function reads a FileDescriptor from a stream */ friend std::istream& operator>>(std::istream& is, FileDescriptor& data); /** * @brief Copy constructor */ FileDescriptor(const FileDescriptor& rhs); /** * @brief Copy operator */ FileDescriptor& operator=(const FileDescriptor& rhs); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new FileDescriptor(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new FileDescriptor(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief ASCII flag */ std::string get_ascii_flag() { return _ascii_flag; }; /** * @brief Format control documentation */ std::string get_format_doc() { return _format_doc; }; /** * @brief Format doc version */ std::string get_format_ver() { return _format_ver; }; /** * @brief Format doc revision */ std::string get_design_rev() { return _design_rev; }; /** * @brief Software identifier */ std::string get_software_id() { return _software_id; }; /** * @brief File number */ int get_file_num() { return _file_num ; }; /** * @brief File name */ std::string get_file_name() { return _file_name; }; /** * @brief Record sequence/location flag */ std::string get_rec_seq() { return _rec_seq; }; /** * @brief Sequence number location */ int get_seq_loc() { return _seq_loc; }; /** * @brief Sequence number length */ int get_seq_len() { return _seq_len; }; /** * @brief Record code/location flag */ std::string get_rec_code() { return _rec_code; }; /** * @brief Record code location */ int get_code_loc() { return _code_loc; }; /** * @brief Record code length */ int get_code_len() { return _code_len; }; /** * @brief Record length/location flag */ std::string get_rec_len() { return _rec_len; }; /** * @brief Record length location */ int get_rlen_loc() { return _rlen_loc; }; /** * @brief Record length, bytes */ int get_rlen_len() { return _rlen_len; }; /** * @brief Number of dataset summ records */ int get_n_dataset() { return _n_dataset; }; /** * @brief Data set summary record length, bytes */ int get_l_dataset() { return _l_dataset; }; /** * @brief Number of map proj records */ int get_n_map_proj() { return _n_map_proj; }; /** * @brief Map projection record length, bytes */ int get_l_map_proj() { return _l_map_proj; }; /** * @brief Number of platform position records */ int get_n_plat_pos() { return _n_plat_pos; }; /** * @brief Platform position record length, bytes */ int get_l_plat_pos() { return _l_plat_pos; }; /** * @brief Number of attitude data records */ int get_n_att_data() { return _n_att_data; }; /** * @brief Attitude data record length, bytes */ int get_l_att_data() { return _l_att_data; }; /** * @brief Number of radiometric data records */ int get_n_radi_data() { return _n_radi_data; }; /** * @brief Radiometric data record length, bytes */ int get_l_radi_data() { return _l_radi_data; }; /** * @brief Number of radiometric compensation records */ int get_n_radi_comp() { return _n_radi_comp; }; /** * @brief Radiometric compensation record length, bytes */ int get_l_radi_comp() { return _l_radi_comp; }; /** * @brief Number of data quality summary records */ int get_n_qual_sum() { return _n_qual_sum; }; /** * @brief Data quality summary record length, bytes */ int get_l_qual_sum() { return _l_qual_sum; }; /** * @brief Number of data histogram records */ int get_n_data_his() { return _n_data_his; }; /** * @brief Data histogram record length, bytes */ int get_l_data_his() { return _l_data_his; }; /** * @brief Number of range spectra records */ int get_n_rang_spec() { return _n_rang_spec ; }; /** * @brief Range spectra record length, bytes */ int get_l_rang_spec() { return _l_rang_spec; }; /** * @brief Number of DEM descriptor records */ int get_n_dem_desc() { return _n_dem_desc; }; /** * @brief DEM desc record length, bytes */ int get_l_dem_desc() { return _l_dem_desc; }; /** * @brief Number of RADAR par records */ int get_n_radar_par() { return _n_radar_par; }; /** * @brief RADAR par record length, bytes */ int get_l_radar_par() { return _l_radar_par; }; /** * @brief Number of annotation data records */ int get_n_anno_data() { return _n_anno_data; }; /** * @brief Annotation data record length, bytes */ int get_l_anno_data() { return _l_anno_data; }; /** * @brief Number of processing parameter records */ int get_n_det_proc() { return _n_det_proc; }; /** * @brief Processing parameter record length, bytes */ int get_l_det_proc() { return _l_det_proc; }; /** * @brief Number of calibration records */ int get_n_cal() { return _n_cal; }; /** * @brief Calibration record length, bytes */ int get_l_cal() { return _l_cal; }; /** * @brief Number of GCP records */ int get_n_gcp() { return _n_gcp; }; /** * @brief GCP record length, bytes */ int get_l_gcp() { return _l_gcp; }; /** * @brief Number of facility data records */ int get_n_fac_data() { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data() { return _l_fac_data; }; protected: /** * @brief ASCII flag */ std::string _ascii_flag; /** * @brief Format control documentation */ std::string _format_doc; /** * @brief Format doc version */ std::string _format_ver; /** * @brief Format doc revision */ std::string _design_rev; /** * @brief Software identifier */ std::string _software_id; /** * @brief File number */ int _file_num; /** * @brief File name */ std::string _file_name; /** * @brief Record sequence/location flag */ std::string _rec_seq; /** * @brief Sequence number location */ int _seq_loc; /** * @brief Sequence number length */ int _seq_len; /** * @brief Record code/location flag */ std::string _rec_code; /** * @brief Record code location */ int _code_loc; /** * @brief Record code length */ int _code_len; /** * @brief Record length/location flag */ std::string _rec_len; /** * @brief Record length location */ int _rlen_loc; /** * @brief Record length, bytes */ int _rlen_len; /** * @brief Number of dataset summ records */ int _n_dataset; /** * @brief Data set summary record length, bytes */ int _l_dataset; /** * @brief Number of map proj records */ int _n_map_proj; /** * @brief Map projection record length, bytes */ int _l_map_proj; /** * @brief Number of platform position records */ int _n_plat_pos; /** * @brief Platform position record length, bytes */ int _l_plat_pos; /** * @brief Number of attitude data records */ int _n_att_data; /** * @brief Attitude data record length, bytes */ int _l_att_data; /** * @brief Number of radiometric data records */ int _n_radi_data; /** * @brief Radiometric data record length, bytes */ int _l_radi_data; /** * @brief Number of radiometric compensation records */ int _n_radi_comp; /** * @brief Radiometric compensation record length, bytes */ int _l_radi_comp; /** * @brief Number of data quality summary records */ int _n_qual_sum; /** * @brief Data quality summary record length, bytes */ int _l_qual_sum; /** * @brief Number of data histogram records */ int _n_data_his; /** * @brief Data histogram record length, bytes */ int _l_data_his; /** * @brief Number of range spectra records */ int _n_rang_spec; /** * @brief Range spectra record length, bytes */ int _l_rang_spec; /** * @brief Number of DEM descriptor records */ int _n_dem_desc; /** * @brief DEM desc record length, bytes */ int _l_dem_desc; /** * @brief Number of RADAR par records */ int _n_radar_par; /** * @brief RADAR par record length, bytes */ int _l_radar_par; /** * @brief Number of annotation data records */ int _n_anno_data; /** * @brief Annotation data record length, bytes */ int _l_anno_data; /** * @brief Number of processing parameter records */ int _n_det_proc; /** * @brief Processing parameter record length, bytes */ int _l_det_proc; /** * @brief Number of calibration records */ int _n_cal; /** * @brief Calibration record length, bytes */ int _l_cal; /** * @brief Number of GCP records */ int _n_gcp; /** * @brief GCP record length, bytes */ int _l_gcp; /** * @brief Number of facility data records */ int _n_fac_data; /** * @brief Fac data record length, bytes */ int _l_fac_data; private: }; } #endif MisregistrationRecord.cpp000066400000000000000000000022121301006202600345310ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "MisregistrationRecord.h" namespace ossimplugins { MisregistrationRecord::MisregistrationRecord() { } MisregistrationRecord::~MisregistrationRecord() { } std::ostream& operator<<(std::ostream& os, const MisregistrationRecord& data) { os<<"alt_m:"<>(std::istream& is, MisregistrationRecord& data) { char buf16[17]; buf16[16] = '\0'; is.read(buf16,16); data._alt_m = atof(buf16); is.read(buf16,16); data._crt_m = atof(buf16); return is; } MisregistrationRecord::MisregistrationRecord(const MisregistrationRecord& rhs): _alt_m(rhs._alt_m), _crt_m(rhs._crt_m) { } MisregistrationRecord& MisregistrationRecord::operator=(const MisregistrationRecord& rhs) { _alt_m = rhs._alt_m; _crt_m = rhs._crt_m; return *this; } } MisregistrationRecord.h000066400000000000000000000032471301006202600342070ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef MisregistrationRecord_h #define MisregistrationRecord_h #include #include namespace ossimplugins { /** * @ingroup DataQualitySummaryRecord * @brief This class is able to read a misregistration record */ class MisregistrationRecord { public: /** * @brief Constructor */ MisregistrationRecord(); /** * @brief Destructor */ ~MisregistrationRecord(); /** * @brief Copy constructor */ MisregistrationRecord(const MisregistrationRecord& rhs); /** * @brief Copy operator */ MisregistrationRecord& operator=(const MisregistrationRecord& rhs); /** * @brief This function writes the MisregistrationRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const MisregistrationRecord& data); /** * @brief This function reads a MisregistrationRecord from a stream */ friend std::istream& operator>>(std::istream& is, MisregistrationRecord& data); /** * @brief Nominal along track misregistration */ double get_alt_m() { return _alt_m; }; /** * @brief Nominal cross track misregistration */ double get_crt_m() { return _crt_m; }; protected: /** * @brief Nominal along track misregistration */ double _alt_m; /** * @brief Nominal cross track misregistration */ double _crt_m; private: }; } #endif ProcessingParameters.cpp000066400000000000000000000434771301006202600343710ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "ProcessingParameters.h" namespace ossimplugins { ProcessingParameters::ProcessingParameters() : RadarSatRecord("proc_param_rec") { } ProcessingParameters::~ProcessingParameters() { } std::ostream& operator<<(std::ostream& os, const ProcessingParameters& data) { os<<"rec_seq:"<>(std::istream& is, ProcessingParameters& data) { char buf[2407]; buf[2406] = '\0'; is.read(buf,4); buf[4] = '\0'; data._rec_seq = atoi(buf); is.read(buf,4); buf[4] = '\0'; is.read(buf,3); buf[3] = '\0'; data._inp_media = buf; is.read(buf,4); buf[4] = '\0'; data._n_tape_id = atoi(buf); for (int i=0;i<10;i++) { is.read(buf,8); buf[8] = '\0'; data._tape_id[i] = buf; } is.read(buf,21); buf[21] = '\0'; data._exp_ing_start = buf; is.read(buf,21); buf[21] = '\0'; data._exp_ing_stop = buf; is.read(buf,21); buf[21] = '\0'; data._act_ing_start = buf; is.read(buf,21); buf[21] = '\0'; data._act_ing_stop = buf; is.read(buf,21); buf[21] = '\0'; data._proc_start = buf; is.read(buf,21); buf[21] = '\0'; data._proc_stop = buf; for (int i=0;i<10;i++) { is.read(buf,16); buf[16] = '\0'; data._mn_sig_lev[i] = atof(buf); } is.read(buf,4); buf[4] = '\0'; data._scr_data_ind = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._miss_ln = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._rej_ln = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._large_gap = atoi(buf); is.read(buf,16); buf[16] = '\0'; data._bit_err_rate = atof(buf); is.read(buf,16); buf[16] = '\0'; data._fm_crc_err = atof(buf); is.read(buf,8); buf[8] = '\0'; data._date_incons = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._prf_changes = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._delay_changes = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._skipd_frams = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._rej_bf_start = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._rej_few_fram = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._rej_many_fram = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._rej_mchn_err = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._rej_vchn_err = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._rej_rec_type = atoi(buf); is.read(buf,10); buf[10] = '\0'; data._sens_config = buf; is.read(buf,9); buf[9] = '\0'; data._sens_orient = buf; is.read(buf,8); buf[8] = '\0'; data._sych_marker = buf; is.read(buf,12); buf[12] = '\0'; data._rng_ref_src = buf; for (int i=0;i<4;i++) { is.read(buf,16); buf[16] = '\0'; data._rng_amp_coef[i] = atof(buf); } for (int i=0;i<4;i++) { is.read(buf,16); buf[16] = '\0'; data._rng_phas_coef[i] = atof(buf); } for (int i=0;i<4;i++) { is.read(buf,16); buf[16] = '\0'; data._err_amp_coef[i] = atof(buf); } for (int i=0;i<4;i++) { is.read(buf,16); buf[16] = '\0'; data._err_phas_coef[i] = atof(buf); } is.read(buf,4); buf[4] = '\0'; data._pulse_bandw = atoi(buf); is.read(buf,5); buf[5] = '\0'; data._adc_samp_rate = buf; is.read(buf,16); buf[16] = '\0'; data._rep_agc_attn = atof(buf); is.read(buf,16); buf[16] = '\0'; data._gn_corctn_fctr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rep_energy_gn = atof(buf); is.read(buf,11); buf[11] = '\0'; data._orb_data_src = buf; is.read(buf,4); buf[4] = '\0'; data._pulse_cnt_1 = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._pulse_cnt_2 = atoi(buf); is.read(buf,3); buf[3] = '\0'; data._beam_edge_rqd = buf; is.read(buf,16); buf[16] = '\0'; data._beam_edge_conf = atof(buf); is.read(buf,4); buf[4] = '\0'; data._pix_overlap = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._n_beams = atoi(buf); for (int i=0;i<4;i++) { is>>data._beam_info[i]; } is.read(buf,4); buf[4] = '\0'; data._n_pix_updates = atoi(buf); for (int i=0;i<20;i++) { is>>data._pix_count[i]; } is.read(buf,16); buf[16] = '\0'; data._pwin_start = atof(buf); is.read(buf,16); buf[16] = '\0'; data._pwin_end = atof(buf); is.read(buf,9); buf[9] = '\0'; data._recd_type = buf; is.read(buf,16); buf[16] = '\0'; data._temp_set_inc = atof(buf); is.read(buf,4); buf[4] = '\0'; data._n_temp_set = atoi(buf); for (int i=0;i<20;i++) { is>>data._temp[i]; } is.read(buf,8); buf[8] = '\0'; data._n_image_pix = atoi(buf); is.read(buf,16); buf[16] = '\0'; data._prc_zero_pix = atof(buf); is.read(buf,16); buf[16] = '\0'; data._prc_satur_pix = atof(buf); is.read(buf,16); buf[16] = '\0'; data._img_hist_mean = atof(buf); for (int i=0;i<3;i++) { is.read(buf,16); buf[16] = '\0'; data._img_cumu_dist[i] = atof(buf); } is.read(buf,16); buf[16] = '\0'; data._pre_img_gn = atof(buf); is.read(buf,16); buf[16] = '\0'; data._post_img_gn = atof(buf); is.read(buf,16); buf[16] = '\0'; data._dopcen_inc = atof(buf); is.read(buf,4); buf[4] = '\0'; data._n_dopcen = atoi(buf); for (int i=0;i<20;i++) { is>>data._dopcen_est[i]; } is.read(buf,4); buf[4] = '\0'; data._dop_amb_err = atoi(buf); is.read(buf,16); buf[16] = '\0'; data._dopamb_conf = atof(buf); for (int i=0;i<7;i++) { is.read(buf,16); buf[16] = '\0'; data._eph_orb_data[i] = atof(buf); } is.read(buf,12); buf[12] = '\0'; data._appl_type = buf; for (int i=0;i<5;i++) { is.read(buf,22); buf[22] = '\0'; data._slow_time_coef[i] = atof(buf); } is.read(buf,4); buf[4] = '\0'; data._n_srgr = atoi(buf); for (int i=0;i<20;i++) { is>>data._srgr_coefset[i]; } is.read(buf,16); buf[16] = '\0'; data._pixel_spacing = atof(buf); is.read(buf,3); buf[3] = '\0'; data._gics_reqd = buf; is.read(buf,8); buf[8] = '\0'; data._wo_number = buf; is.read(buf,20); buf[20] = '\0'; data._wo_date = buf; is.read(buf,10); buf[10] = '\0'; data._satellite_id = buf; is.read(buf,20); buf[20] = '\0'; data._user_id = buf; is.read(buf,3); buf[3] = '\0'; data._complete_msg = buf; is.read(buf,15); buf[15] = '\0'; data._scene_id = buf; is.read(buf,4); buf[4] = '\0'; data._density_in = buf; is.read(buf,8); buf[8] = '\0'; data._media_id = buf; is.read(buf,16); buf[16] = '\0'; data._angle_first = atof(buf); is.read(buf,16); buf[16] = '\0'; data._angle_last = atof(buf); is.read(buf,3); buf[3] = '\0'; data._prod_type = buf; is.read(buf,16); buf[16] = '\0'; data._map_system = buf; is.read(buf,22); buf[22] = '\0'; data._centre_lat = atof(buf); is.read(buf,22); buf[22] = '\0'; data._centre_long = atof(buf); is.read(buf,22); buf[22] = '\0'; data._span_x = atof(buf); is.read(buf,22); buf[22] = '\0'; data._span_y = atof(buf); is.read(buf,3); buf[3] = '\0'; data._apply_dtm = buf; is.read(buf,4); buf[4] = '\0'; data._density_out = buf; is.read(buf,21); buf[21] = '\0'; data._state_time = buf; is.read(buf,4); buf[4] = '\0'; data._num_state_vectors = atoi(buf); is.read(buf,16); buf[16] = '\0'; data._state_time_inc = atof(buf); is.read(buf,206); buf[206] = '\0'; return is; } ProcessingParameters::ProcessingParameters(const ProcessingParameters& rhs): RadarSatRecord(rhs) { } ProcessingParameters& ProcessingParameters::operator=(const ProcessingParameters& /* rhs */) { /* int _rec_seq std::string _spare1 std::string _inp_media int _n_tape_id std::string _tape_id std::string _exp_ing_start std::string _exp_ing_stop std::string _act_ing_start std::string _act_ing_stop std::string _proc_start std::string _proc_stop double* _mn_sig_lev int _scr_data_ind int _miss_ln int _rej_ln int _large_gap double _bit_err_rate double _fm_crc_err int _date_incons int _prf_changes int _delay_changes int _skipd_frams int _rej_bf_start int _rej_few_fram int _rej_many_fram int _rej_mchn_err int _rej_vchn_err int _rej_rec_type std::string _sens_config std::string _sens_orient int _sych_marker std::string _rng_ref_src double* _rng_amp_coef double* _rng_phas_coef double* _err_amp_coef double* _err_phas_coef int _pulse_bandw int _adc_samp_rate double _rep_agc_attn double _gn_corctn_fctr double _rep_energy_gn std::string _orb_data_src int _pulse_cnt_1 int _pulse_cnt_2 std::string _beam_edge_rqd double _beam_edge_conf int _pix_overlap int _n_beams BeamInformationRecord* _beam_info int _n_pix_updates BeamPixelCountRecord* _pix_count double _pwin_start double _pwin_end std::string _recd_type double _temp_set_inc int* _n_temp_set TemperatureSettingsRecord* _temp int _n_image_pix double _prc_zero_pix double _prc_satur_pix double _img_hist_mean double* _img_cumu_dist double _pre_img_gn double _post_img_gn double _dopcen_inc int _n_dopcen DopplerCentroidEstimateRecord* _dopcen_est int _dop_amb_err double _dopamb_conf double* _eph_orb_data std::string _appl_type double* _slow_time_coef int _n_srgr SRGRCoefficientSetRecord* _srgr_coefset double _pixel_spacing std::string _gics_reqd std::string _wo_number std::string _wo_date std::string _satellite_id std::string _user_id std::string _complete_msg std::string _scene_id std::string _density_in std::string _media_id double _angle_first double _angle_last std::string _prod_type std::string _map_system double _centre_lat double _centre_long double _span_x double _span_y std::string _apply_dtm std::string _density_out std::string _state_time int _num_state_vectors double _state_time_inc std::string _spare2*/ return *this; } } ProcessingParameters.h000066400000000000000000000520461301006202600340260ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ProcessingParameters_h #define ProcessingParameters_h #include #include #include #include "BeamInformationRecord.h" #include "DopplerCentroidEstimateRecord.h" #include "BeamPixelCountRecord.h" #include "SRGRCoefficientSetRecord.h" #include "TemperatureSettingsRecord.h" namespace ossimplugins { /** * @ingroup ProcessingParametersRecord * @brief This class is able to read a Detailed processing parameters record */ class ProcessingParameters : public RadarSatRecord { public: /** * @brief Constructor */ ProcessingParameters(); /** * @brief Destructor */ ~ProcessingParameters(); /** * @brief Copy constructor */ ProcessingParameters(const ProcessingParameters& rhs); /** * @brief Copy operator */ ProcessingParameters& operator=(const ProcessingParameters& rhs); /** * @brief This function writes the ProcessingParameters in a stream */ friend std::ostream& operator<<(std::ostream& os, const ProcessingParameters& data); /** * @brief This function reads a ProcessingParameters from a stream */ friend std::istream& operator>>(std::istream& is, ProcessingParameters& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new ProcessingParameters(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new ProcessingParameters(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Record sequence number */ int get_rec_seq() { return _rec_seq; }; /** * @brief Input media */ std::string get_inp_media() { return _inp_media; }; /** * @brief Number of tape input ids */ int get_n_tape_id() { return _n_tape_id; }; /** * @brief Tape identifiers */ std::string* get_tape_id() { return _tape_id; }; /** * @brief Expected ingest start time */ std::string get_exp_ing_start() { return _exp_ing_start; }; /** * @brief Expected ingest stop time */ std::string get_exp_ing_stop() { return _exp_ing_stop; }; /** * @brief Actual ingest start time */ std::string get_act_ing_start() { return _act_ing_start; }; /** * @brief Actual ingest stop time */ std::string get_act_ing_stop() { return _act_ing_stop; }; /** * @brief Processing start time */ std::string get_proc_start() { return _proc_start; }; /** * @brief Processing stop time */ std::string get_proc_stop() { return _proc_stop; }; /** * @brief Mean signal levels across range */ double* get_mn_sig_lev() { return _mn_sig_lev; }; /** * @brief Source data quality indicator */ int get_scr_data_ind() { return _scr_data_ind; }; /** * @brief Number of missing lines */ int get_miss_ln() { return _miss_ln; }; /** * @brief Number of rejected lines */ int get_rej_ln() { return _rej_ln; }; /** * @brief Number of time inconsistencies (large gaps) */ int get_large_gap() { return _large_gap; }; /** * @brief Measured bit error rate */ double get_bit_err_rate() { return _bit_err_rate; }; /** * @brief Percent of frames with CRC errors */ double get_fm_crc_err() { return _fm_crc_err; }; /** * @brief Number of date inconsistencies */ int get_date_incons() { return _date_incons; }; /** * @brief Number of unexpected PRF changes */ int get_prf_changes() { return _prf_changes; }; /** * @brief Number of delay changes */ int get_delay_changes() { return _delay_changes; }; /** * @brief Number of skipped frames */ int get_skipd_frams() { return _skipd_frams; }; /** * @brief Range lines rejected before start time */ int get_rej_bf_start() { return _rej_bf_start; }; /** * @brief Range lines rejected due to too few frames */ int get_rej_few_fram() { return _rej_few_fram; }; /** * @brief Range lines rejected due to too many frames */ int get_rej_many_fram() { return _rej_many_fram; }; /** * @brief Frames rejected due to master channel error */ int get_rej_mchn_err() { return _rej_mchn_err; }; /** * @brief Frames rejected due to virtual channel error */ int get_rej_vchn_err() { return _rej_vchn_err; }; /** * @brief Frames rejected due to incorrect recording type */ int get_rej_rec_type() { return _rej_rec_type; }; /** * @brief Sensor configuration */ std::string get_sens_config() { return _sens_config; }; /** * @brief Sensor orientation */ std::string get_sens_orient() { return _sens_orient; }; /** * @brief Frame synch marker */ std::string get_sych_marker() { return _sych_marker; }; /** * @brief Range reference function source */ std::string get_rng_ref_src() { return _rng_ref_src; }; /** * @brief Range reference amplitude coefficients */ double* get_rng_amp_coef() { return _rng_amp_coef; }; /** * @brief Range reference phase coefficients */ double* get_rng_phas_coef() { return _rng_phas_coef; }; /** * @brief Error function amplitude coefficients */ double* get_err_amp_coef() { return _err_amp_coef; }; /** * @brief Error function phase coefficients */ double* get_err_phas_coef() { return _err_phas_coef; }; /** * @brief Pulse bandwidth code */ int get_pulse_bandw() { return _pulse_bandw; }; /** * @brief ADC sampling rate */ std::string get_adc_samp_rate() { return _adc_samp_rate; }; /** * @brief Replica AGC attenuation */ double get_rep_agc_attn() { return _rep_agc_attn; }; /** * @brief Gain correction factor (dB) */ double get_gn_corctn_fctr() { return _gn_corctn_fctr; }; /** * @brief Replica energy gain correction */ double get_rep_energy_gn() { return _rep_energy_gn; }; /** * @brief Orbit data source */ std::string get_orb_data_src() { return _orb_data_src; }; /** * @brief Pulse count 1 */ int get_pulse_cnt_1() { return _pulse_cnt_1; }; /** * @brief Pulse count 2 */ int get_pulse_cnt_2() { return _pulse_cnt_2; }; /** * @brief Beam edge detection requested */ std::string get_beam_edge_rqd() { return _beam_edge_rqd; }; /** * @brief Beam edge confidence measure */ double get_beam_edge_conf() { return _beam_edge_conf; }; /** * @brief Number of pixels in beam overlap */ int get_pix_overlap() { return _pix_overlap; }; /** * @brief Number of beams */ int get_n_beams() { return _n_beams; }; /** * @brief Beam info */ BeamInformationRecord* get_beam_info() { return _beam_info; }; /** * @brief Number of pixel count updates */ int get_n_pix_updates() { return _n_pix_updates; }; /** * @brief Beam pixel counts */ BeamPixelCountRecord* get_pix_count() { return _pix_count; }; /** * @brief Processing window start time (sec) */ double get_pwin_start() { return _pwin_start; }; /** * @brief Processing window end time (sec) */ double get_pwin_end() { return _pwin_end; }; /** * @brief Recording type */ std::string get_recd_type() { return _recd_type; }; /** * @brief Time increment between temperature settings (sec) */ double get_temp_set_inc() { return _temp_set_inc; }; /** * @brief Number of temperature settings */ int get_n_temp_set() { return _n_temp_set; }; /** * @brief Temperature settings */ TemperatureSettingsRecord* get_temp() { return _temp; }; /** * @brief Number of image pixels */ int get_n_image_pix() { return _n_image_pix; }; /** * @brief Percent zero pixels */ double get_prc_zero_pix() { return _prc_zero_pix; }; /** * @brief Percent saturated pixels */ double get_prc_satur_pix() { return _prc_satur_pix; }; /** * @brief Image histogram mean intensity */ double get_img_hist_mean() { return _img_hist_mean; }; /** * @brief Image cumulative distribution */ double* get_img_cumu_dist() { return _img_cumu_dist; }; /** * @brief Pre-image calibration gain factor */ double get_pre_img_gn() { return _pre_img_gn; }; /** * @brief Post-image calibration gain factor */ double get_post_img_gn() { return _post_img_gn; }; /** * @brief Time increment between Dopcen estimates (sec) */ double get_dopcen_inc() { return _dopcen_inc; }; /** * @brief Number of Doppler centroid estimates */ int get_n_dopcen() { return _n_dopcen; }; /** * @brief Doppler centroid estimates */ DopplerCentroidEstimateRecord* get_dopcen_est() { return _dopcen_est; }; /** * @brief Doppler ambiguity error */ int get_dop_amb_err() { return _dop_amb_err; }; /** * @brief Doppler ambiguity confidence measure */ double get_dopamb_conf() { return _dopamb_conf; }; /** * @brief Ephemeris orbit data */ double* get_eph_orb_data() { return _eph_orb_data; }; /** * @brief Application type */ std::string get_appl_type() { return _appl_type; }; /** * @brief Slow time coefficients * @todo Verifier le type de la variable lors de la lecture de la donnee */ double* get_slow_time_coef() { return _slow_time_coef; }; /** * @brief Number of SRGR coefficient sets */ int get_n_srgr() { return _n_srgr; }; /** * @brief SRGR coefficient sets */ SRGRCoefficientSetRecord* get_srgr_coefset() { return _srgr_coefset; }; /** * @brief SGF product pixel spacing */ double get_pixel_spacing() { return _pixel_spacing; }; /** * @brief GICS product required */ std::string get_gics_reqd() { return _gics_reqd; }; /** * @brief Work order identifier */ std::string get_wo_number() { return _wo_number; }; /** * @brief Work order entry date */ std::string get_wo_date() { return _wo_date; }; /** * @brief Satellite identifier */ std::string get_satellite_id() { return _satellite_id; }; /** * @brief User id */ std::string get_user_id() { return _user_id; }; /** * @brief Completion message required flag */ std::string get_complete_msg() { return _complete_msg; }; /** * @brief SGF product scene identifier */ std::string get_scene_id() { return _scene_id; }; /** * @brief Density of SGF product media */ std::string get_density_in() { return _density_in; }; /** * @brief SGF product identifier */ std::string get_media_id() { return _media_id; }; /** * @brief Incidence angle of first pixel in SGF product line */ double get_angle_first() { return _angle_first; }; /** * @brief Incidence angle of last pixel in SGF product line */ double get_angle_last() { return _angle_last; }; /** * @brief GICS output product type */ std::string get_prod_type() { return _prod_type; }; /** * @brief Map system identifier */ std::string get_map_system() { return _map_system; }; /** * @brief GICS output product scene centre latitude */ double get_centre_lat() { return _centre_lat; }; /** * @brief GICS output product scene centre longitude */ double get_centre_long() { return _centre_long; }; /** * @brief GICS output product size - map eastings (km) */ double get_span_x() { return _span_x; }; /** * @brief GICS output product size - map northings (km) */ double get_span_y() { return _span_y; }; /** * @brief DTM correction to be applied flag */ std::string get_apply_dtm() { return _apply_dtm; }; /** * @brief GICS output product density */ std::string get_density_out() { return _density_out; }; /** * @brief Time of the first state vector */ std::string get_state_time() { return _state_time; }; /** * @brief Number of state vectors */ int get_num_state_vectors() { return _num_state_vectors; }; /** * @brief Time increment between state vectors */ double get_state_time_inc() { return _state_time_inc; }; protected: /** * @brief Record sequence number */ int _rec_seq; /** * @brief Input media */ std::string _inp_media; /** * @brief Number of tape input ids */ int _n_tape_id; /** * @brief Tape identifiers */ std::string _tape_id[10]; /** * @brief Expected ingest start time */ std::string _exp_ing_start; /** * @brief Expected ingest stop time */ std::string _exp_ing_stop; /** * @brief Actual ingest start time */ std::string _act_ing_start; /** * @brief Actual ingest stop time */ std::string _act_ing_stop; /** * @brief Processing start time */ std::string _proc_start; /** * @brief Processing stop time */ std::string _proc_stop; /** * @brief Mean signal levels across range */ double _mn_sig_lev[10]; /** * @brief Source data quality indicator */ int _scr_data_ind; /** * @brief Number of missing lines */ int _miss_ln; /** * @brief Number of rejected lines */ int _rej_ln; /** * @brief Number of time inconsistencies (large gaps) */ int _large_gap; /** * @brief Measured bit error rate */ double _bit_err_rate; /** * @brief Percent of frames with CRC errors */ double _fm_crc_err; /** * @brief Number of date inconsistencies */ int _date_incons; /** * @brief Number of unexpected PRF changes */ int _prf_changes; /** * @brief Number of delay changes */ int _delay_changes; /** * @brief Number of skipped frames */ int _skipd_frams; /** * @brief Range lines rejected before start time */ int _rej_bf_start; /** * @brief Range lines rejected due to too few frames */ int _rej_few_fram; /** * @brief Range lines rejected due to too many frames */ int _rej_many_fram; /** * @brief Frames rejected due to master channel error */ int _rej_mchn_err; /** * @brief Frames rejected due to virtual channel error */ int _rej_vchn_err; /** * @brief Frames rejected due to incorrect recording type */ int _rej_rec_type; /** * @brief Sensor configuration */ std::string _sens_config; /** * @brief Sensor orientation */ std::string _sens_orient; /** * @brief Frame synch marker */ std::string _sych_marker; /** * @brief Range reference function source */ std::string _rng_ref_src; /** * @brief Range reference amplitude coefficients */ double _rng_amp_coef[4]; /** * @brief Range reference phase coefficients */ double _rng_phas_coef[4]; /** * @brief Error function amplitude coefficients */ double _err_amp_coef[16]; /** * @brief Error function phase coefficients */ double _err_phas_coef[4]; /** * @brief Pulse bandwidth code */ int _pulse_bandw; /** * @brief ADC sampling rate */ std::string _adc_samp_rate; /** * @brief Replica AGC attenuation */ double _rep_agc_attn; /** * @brief Gain correction factor (dB) */ double _gn_corctn_fctr; /** * @brief Replica energy gain correction */ double _rep_energy_gn; /** * @brief Orbit data source */ std::string _orb_data_src; /** * @brief Pulse count 1 */ int _pulse_cnt_1; /** * @brief Pulse count 2 */ int _pulse_cnt_2; /** * @brief Beam edge detection requested */ std::string _beam_edge_rqd; /** * @brief Beam edge confidence measure */ double _beam_edge_conf; /** * @brief Number of pixels in beam overlap */ int _pix_overlap; /** * @brief Number of beams */ int _n_beams; /** * @brief Beam info */ BeamInformationRecord _beam_info[4]; /** * @brief Number of pixel count updates */ int _n_pix_updates; /** * @brief Beam pixel counts */ BeamPixelCountRecord _pix_count[20]; /** * @brief Processing window start time (sec) */ double _pwin_start; /** * @brief Processing window end time (sec) */ double _pwin_end; /** * @brief Recording type */ std::string _recd_type; /** * @brief Time increment between temperature settings (sec) */ double _temp_set_inc; /** * @brief Number of temperature settings */ int _n_temp_set; /** * @brief Temperature settings */ TemperatureSettingsRecord _temp[20]; /** * @brief Number of image pixels */ int _n_image_pix; /** * @brief Percent zero pixels */ double _prc_zero_pix; /** * @brief Percent saturated pixels */ double _prc_satur_pix; /** * @brief Image histogram mean intensity */ double _img_hist_mean; /** * @brief Image cumulative distribution */ double _img_cumu_dist[3]; /** * @brief Pre-image calibration gain factor */ double _pre_img_gn; /** * @brief Post-image calibration gain factor */ double _post_img_gn; /** * @brief Time increment between Dopcen estimates (sec) */ double _dopcen_inc; /** * @brief Number of Doppler centroid estimates */ int _n_dopcen; /** * @brief Doppler centroid estimates */ DopplerCentroidEstimateRecord _dopcen_est[20]; /** * @brief Doppler ambiguity error */ int _dop_amb_err; /** * @brief Doppler ambiguity confidence measure */ double _dopamb_conf; /** * @brief Ephemeris orbit data */ double _eph_orb_data[7]; /** * @brief Application type */ std::string _appl_type; /** * @brief Slow time coefficients * @todo Verifier le type de la variable lors de la lecture de la donnee */ double _slow_time_coef[5]; /** * @brief Number of SRGR coefficient sets */ int _n_srgr; /** * @brief SRGR coefficient sets */ SRGRCoefficientSetRecord _srgr_coefset[20]; /** * @brief SGF product pixel spacing */ double _pixel_spacing; /** * @brief GICS product required */ std::string _gics_reqd; /** * @brief Work order identifier */ std::string _wo_number; /** * @brief Work order entry date */ std::string _wo_date; /** * @brief Satellite identifier */ std::string _satellite_id; /** * @brief User id */ std::string _user_id; /** * @brief Completion message required flag */ std::string _complete_msg; /** * @brief SGF product scene identifier */ std::string _scene_id; /** * @brief Density of SGF product media */ std::string _density_in; /** * @brief SGF product identifier */ std::string _media_id; /** * @brief Incidence angle of first pixel in SGF product line */ double _angle_first; /** * @brief Incidence angle of last pixel in SGF product line */ double _angle_last; /** * @brief GICS output product type */ std::string _prod_type; /** * @brief Map system identifier */ std::string _map_system; /** * @brief GICS output product scene centre latitude */ double _centre_lat; /** * @brief GICS output product scene centre longitude */ double _centre_long; /** * @brief GICS output product size - map eastings (km) */ double _span_x; /** * @brief GICS output product size - map northings (km) */ double _span_y; /** * @brief DTM correction to be applied flag */ std::string _apply_dtm; /** * @brief GICS output product density */ std::string _density_out; /** * @brief Time of the first state vector */ std::string _state_time; /** * @brief Number of state vectors */ int _num_state_vectors; /** * @brief Time increment between state vectors */ double _state_time_inc; private: }; } #endif RadiometricCompensationData.cpp000066400000000000000000000037331301006202600356340ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "RadiometricCompensationData.h" namespace ossimplugins { RadiometricCompensationData::RadiometricCompensationData() : RadarSatRecord("radi_comp_rec") { } RadiometricCompensationData::~RadiometricCompensationData() { } std::ostream& operator<<(std::ostream& os, const RadiometricCompensationData& data) { os<<"seq_num:"<>(std::istream& is, RadiometricCompensationData& data) { char buf[9]; buf[8] = '\0'; is.read(buf,4); buf[4] = '\0'; data._seq_num = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._chan_ind = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._n_dset = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._dset_size = atoi(buf); for (int i=0;i<4;i++) { is>> data._dset[i]; } return is; } RadiometricCompensationData::RadiometricCompensationData(const RadiometricCompensationData& rhs): RadarSatRecord(rhs) { _seq_num = rhs._seq_num; _chan_ind = rhs._chan_ind; _n_dset = rhs._n_dset; _dset_size = rhs._dset_size; for (int i=0;i<4;i++) { _dset[i] = rhs._dset[i]; } } RadiometricCompensationData& RadiometricCompensationData::operator=(const RadiometricCompensationData& /* rhs */) { return *this; } } RadiometricCompensationData.h000066400000000000000000000057321301006202600353020ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RadiometricCompensationData_h #define RadiometricCompensationData_h #include #include #include #include "CompensationDataRecord.h" namespace ossimplugins { /** * @ingroup RadiometricCompensationDataRecord * @brief This class is able to read a Radiometric Compensation data record */ class RadiometricCompensationData : public RadarSatRecord { public: /** * @brief Constructor */ RadiometricCompensationData(); /** * @brief Destructor */ ~RadiometricCompensationData(); /** * @brief Copy constructor */ RadiometricCompensationData(const RadiometricCompensationData& rhs); /** * @brief Copy operator */ RadiometricCompensationData& operator=(const RadiometricCompensationData& rhs); /** * @brief This function writes the RadiometricCompensationData in a stream */ friend std::ostream& operator<<(std::ostream& os, const RadiometricCompensationData& data); /** * @brief This function reads a RadiometricCompensationData from a stream */ friend std::istream& operator>>(std::istream& is, RadiometricCompensationData& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new RadiometricCompensationData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new RadiometricCompensationData(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Record sequence number */ int get_seq_num() { return _seq_num; }; /** * @brief SAR channel indicator */ int get_chan_ind() { return _chan_ind; }; /** * @brief Number of data sets in record */ int get_n_dset() { return _n_dset; }; /** * @brief Compensation data set size */ int get_dset_size() { return _dset_size; }; /** * @brief Compensation data set records */ CompensationDataRecord* get_dset() { return _dset; }; protected: /** * @brief Record sequence number */ int _seq_num; /** * @brief SAR channel indicator */ int _chan_ind; /** * @brief Number of data sets in record */ int _n_dset; /** * @brief Compensation data set size */ int _dset_size; /** * @brief Compensation data set records */ CompensationDataRecord _dset[4]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/RadiometricData.cpp000066400000000000000000000063371301006202600333360ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "RadiometricData.h" namespace ossimplugins { RadiometricData::RadiometricData() : RadarSatRecord("radi_data_rec") { } RadiometricData::~RadiometricData() { } std::ostream& operator<<(std::ostream& os, const RadiometricData& data) { os<<"seq_num:"<>(std::istream& is, RadiometricData& data) { char buf[1513]; buf[1512] = '\0'; is.read(buf,4); buf[4] = '\0'; data._seq_num = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._n_data = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._field_size = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._chan_ind = buf; is.read(buf,4); is.read(buf,24); buf[24] = '\0'; data._table_desig = buf; is.read(buf,8); buf[8] = '\0'; data._n_samp = atoi(buf); is.read(buf,16); buf[16] = '\0'; data._samp_type = buf; is.read(buf,4); buf[4] = '\0'; data._samp_inc = atoi(buf); for (int i=0;i<512;i++) { is.read(buf,16); buf[16] = '\0'; data._lookup_tab[i] = atof(buf); } is.read(buf,4); is.read(buf,16); buf[16] = '\0'; data._noise_scale = atof(buf); is.read(buf,16); is.read(buf,16); buf[16] = '\0'; data._offset = atof(buf); is.read(buf,16); buf[16] = '\0'; data._calib_const = atof(buf); is.read(buf,1512); return is; } RadiometricData::RadiometricData(const RadiometricData& rhs): RadarSatRecord(rhs) { _seq_num = rhs._seq_num; _n_data = rhs._n_data; _field_size = rhs._field_size; _chan_ind = rhs._chan_ind; _table_desig = rhs._table_desig; _n_samp = rhs._n_samp; _samp_type = rhs._samp_type; _samp_inc = rhs._samp_inc; for (int i=0;i<512;i++) { _lookup_tab[i] = rhs._lookup_tab[i]; } _noise_scale = rhs._noise_scale; _offset = rhs._offset; _calib_const = rhs._calib_const; } RadiometricData& RadiometricData::operator=(const RadiometricData& rhs) { _seq_num = rhs._seq_num; _n_data = rhs._n_data; _field_size = _field_size; _chan_ind = rhs._chan_ind; _table_desig = rhs._table_desig; _n_samp = rhs._n_samp; _samp_type = rhs._samp_type; _samp_inc = rhs._samp_inc; for (int i=0;i<512;i++) { _lookup_tab[i] = rhs._lookup_tab[i]; } _noise_scale = rhs._noise_scale; _offset = rhs._offset; _calib_const = rhs._calib_const; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord/RadiometricData.h000066400000000000000000000077721301006202600330070ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RadiometricData_h #define RadiometricData_h #include #include #include namespace ossimplugins { /** * @ingroup RadiometricDataRecord * @brief This class is able to read a radiometric data record */ class RadiometricData : public RadarSatRecord { public: /** * @brief Constructor */ RadiometricData(); /** * @brief Destructor */ ~RadiometricData(); /** * @brief Copy constructor */ RadiometricData(const RadiometricData& rhs); /** * @brief Copy operator */ RadiometricData& operator=(const RadiometricData& rhs); /** * @brief This function writes the RadiometricData in a stream */ friend std::ostream& operator<<(std::ostream& os, const RadiometricData& data); /** * @brief This function reads a RadiometricData from a stream */ friend std::istream& operator>>(std::istream& is, RadiometricData& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new RadiometricData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new RadiometricData(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Record sequence number */ int get_seq_num() { return _seq_num; }; /** * @brief Number of data fields */ int get_n_data() { return _n_data; }; /** * @brief Field size in bytes */ int get_field_size() { return _field_size; }; /** * @brief SAR channel indicator */ std::string get_chan_ind() { return _chan_ind; }; /** * @brief Table designator */ std::string get_table_desig() { return _table_desig; }; /** * @brief Number of lookup table samples */ int get_n_samp() { return _n_samp; }; /** * @brief Sample type designator */ std::string get_samp_type() { return _samp_type; }; /** * @brief Increment between table entries, range samples */ int get_samp_inc() { return _samp_inc; }; /** * @brief Output scaling gain table */ double* get_lookup_tab() { return _lookup_tab; }; /** * @brief Thermal noise reference level */ double get_noise_scale() { return _noise_scale; }; /** * @brief Scaling offset */ double get_offset() { return _offset; }; /** * @brief Calibration constant */ double get_calib_const() { return _calib_const; }; protected: /** * @brief Record sequence number */ int _seq_num; /** * @brief Number of data fields */ int _n_data; /** * @brief Field size in bytes */ int _field_size; /** * @brief SAR channel indicator */ std::string _chan_ind; /** * @brief Table designator */ std::string _table_desig; /** * @brief Number of lookup table samples */ int _n_samp; /** * @brief Sample type designator */ std::string _samp_type; /** * @brief Increment between table entries, range samples */ int _samp_inc; /** * @brief Output scaling gain table */ double _lookup_tab[512]; /** * @brief Thermal noise reference level */ double _noise_scale; /** * @brief Scaling offset */ double _offset; /** * @brief Calibration constant */ double _calib_const; private: }; } #endif RadiometryUncertaintyRecord.cpp000066400000000000000000000022651301006202600357230ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "RadiometryUncertaintyRecord.h" namespace ossimplugins { RadiometryUncertaintyRecord::RadiometryUncertaintyRecord() { } RadiometryUncertaintyRecord::~RadiometryUncertaintyRecord() { } std::ostream& operator<<(std::ostream& os, const RadiometryUncertaintyRecord& data) { os<<"db:"<>(std::istream& is, RadiometryUncertaintyRecord& data) { char buf16[17]; buf16[16] = '\0'; is.read(buf16,16); data._db = atof(buf16); is.read(buf16,16); data._deg = atof(buf16); return is; } RadiometryUncertaintyRecord::RadiometryUncertaintyRecord(const RadiometryUncertaintyRecord& rhs): _db(rhs._db), _deg(rhs._deg) { } RadiometryUncertaintyRecord& RadiometryUncertaintyRecord::operator=(const RadiometryUncertaintyRecord& rhs) { _db = rhs._db; _deg = rhs._deg; return *this; } } RadiometryUncertaintyRecord.h000066400000000000000000000032151301006202600353640ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RadiometryUncertaintyRecord_h #define RadiometryUncertaintyRecord_h #include #include namespace ossimplugins { /** * @ingroup DataQualitySummaryRecord * @brief This class is able to read a radiometry uncertainty record */ class RadiometryUncertaintyRecord { public: /** * @brief Constructor */ RadiometryUncertaintyRecord(); /** * @brief Destructor */ ~RadiometryUncertaintyRecord(); /** * @brief Copy constructor */ RadiometryUncertaintyRecord(const RadiometryUncertaintyRecord& rhs); /** * @brief Copy operator */ RadiometryUncertaintyRecord& operator=(const RadiometryUncertaintyRecord& rhs); /** * @brief This function writes the RadiometryUncertaintyRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const RadiometryUncertaintyRecord& data); /** * @brief This function reads a RadiometryUncertaintyRecord from a stream */ friend std::istream& operator>>(std::istream& is, RadiometryUncertaintyRecord& data); /** * @brief Units of db */ double get_db() { return _db; }; /** * @brief Units of deg */ double get_deg() { return _deg; }; protected: /** * @brief Units of db */ double _db; /** * @brief Units of deg */ double _deg; private: }; } #endif SRGRCoefficientSetRecord.cpp000066400000000000000000000026431301006202600347460ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "SRGRCoefficientSetRecord.h" namespace ossimplugins { SRGRCoefficientSetRecord::SRGRCoefficientSetRecord() { } SRGRCoefficientSetRecord::~SRGRCoefficientSetRecord() { } std::ostream& operator<<(std::ostream& os, const SRGRCoefficientSetRecord& data) { os<<"srgr_update:"<>(std::istream& is, SRGRCoefficientSetRecord& data) { char buf[22]; buf[21] = '\0'; is.read(buf,21); buf[21] = '\0'; data._srgr_update = buf; for (int i=0;i<6;i++) { is.read(buf,16); buf[16] = '\0'; data._srgr_coef[i] = atof(buf); } return is; } SRGRCoefficientSetRecord::SRGRCoefficientSetRecord(const SRGRCoefficientSetRecord& rhs): _srgr_update(rhs._srgr_update) { for (int i=0;i<6;i++) { _srgr_coef[i] = rhs._srgr_coef[i]; } } SRGRCoefficientSetRecord& SRGRCoefficientSetRecord::operator=(const SRGRCoefficientSetRecord& rhs) { _srgr_update = rhs._srgr_update; for (int i=0;i<6;i++) { _srgr_coef[i] = rhs._srgr_coef[i]; } return *this; } } SRGRCoefficientSetRecord.h000066400000000000000000000033011301006202600344030ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef SRGRCoefficientSetRecord_h #define SRGRCoefficientSetRecord_h #include #include namespace ossimplugins { /** * @ingroup ProcessingParametersRecord * @brief This class is able to read a SRGR coefficients set record */ class SRGRCoefficientSetRecord { public: /** * @brief Constructor */ SRGRCoefficientSetRecord(); /** * @brief Destructor */ ~SRGRCoefficientSetRecord(); /** * @brief Copy constructor */ SRGRCoefficientSetRecord(const SRGRCoefficientSetRecord& rhs); /** * @brief Copy operator */ SRGRCoefficientSetRecord& operator=(const SRGRCoefficientSetRecord& rhs); /** * @brief This function writes the SRGRCoefficientSetRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const SRGRCoefficientSetRecord& data); /** * @brief This function reads a SRGRCoefficientSetRecord from a stream */ friend std::istream& operator>>(std::istream& is, SRGRCoefficientSetRecord& data); /** * @brief SRGR update date/time */ std::string get_srgr_update() { return _srgr_update; } /** * @brief SRGR coefficients */ double* get_srgr_coef() { return _srgr_coef; } protected: /** * @brief SRGR update date/time */ std::string _srgr_update; /** * @brief SRGR coefficients */ double _srgr_coef[6]; private: }; } #endif TemperatureSettingsRecord.cpp000066400000000000000000000023511301006202600353700ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "TemperatureSettingsRecord.h" namespace ossimplugins { TemperatureSettingsRecord::TemperatureSettingsRecord() { } TemperatureSettingsRecord::~TemperatureSettingsRecord() { } std::ostream& operator<<(std::ostream& os, const TemperatureSettingsRecord& data) { for (int i=0;i<4;i++) { os<<"temp_set["<>(std::istream& is, TemperatureSettingsRecord& data) { char buf[5]; buf[4] = '\0'; for (int i=0;i<4;i++) { is.read(buf,4); buf[4] = '\0'; data._temp_set[i] = atoi(buf); } return is; } TemperatureSettingsRecord::TemperatureSettingsRecord(const TemperatureSettingsRecord& rhs) { for (int i=0;i<4;i++) { _temp_set[i] = rhs._temp_set[i]; } } TemperatureSettingsRecord& TemperatureSettingsRecord::operator=(const TemperatureSettingsRecord& rhs) { for (int i=0;i<4;i++) { _temp_set[i] = rhs._temp_set[i]; } return *this; } } TemperatureSettingsRecord.h000066400000000000000000000030071301006202600350340ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/CommonRecord//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef TemperatureSettingsRecord_h #define TemperatureSettingsRecord_h #include #include namespace ossimplugins { /** * @ingroup ProcessingParametersRecord * @brief This class is able to read a Temperature Settings record */ class TemperatureSettingsRecord { public: /** * @brief Constructor */ TemperatureSettingsRecord(); /** * @brief Destructor */ ~TemperatureSettingsRecord(); /** * @brief Copy constructor */ TemperatureSettingsRecord(const TemperatureSettingsRecord& rhs); /** * @brief Copy operator */ TemperatureSettingsRecord& operator=(const TemperatureSettingsRecord& rhs); /** * @brief This function writes the TemperatureSettingsRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const TemperatureSettingsRecord& data); /** * @brief This function reads a TemperatureSettingsRecord from a stream */ friend std::istream& operator>>(std::istream& is, TemperatureSettingsRecord& data); /** * @brief Temperature settings */ int* get_temp_set() { return _temp_set; }; protected: /** * @brief Temperature settings */ int _temp_set[4]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/000077500000000000000000000000001301006202600260475ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/Data.cpp000066400000000000000000000140431301006202600274260ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { // Static trace for debugging static ossimTrace traceDebug("Data:debug"); const int Data::ImageOptionsFileDescriptorID = 1; const int Data::FirstProcessedDataRecordID = 2; const int Data::LastProcessedDataRecordID = 3; Data::Data() { } Data::~Data() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const Data& data) { std::map::const_iterator it = data._records.begin(); while(it != data._records.end()) { (*it).second->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, Data& data) { DataFactory factory; data.ClearRecords(); if (sizeof(int)!=4) ossimNotify(ossimNotifyLevel_WARN) << "RadarSat Data WARNING : (int) not coded over 32 bits, metadata might not be byte swapped correctly"<< std::endl ; if (sizeof(float)!=4) ossimNotify(ossimNotifyLevel_WARN) << "RadarSat Data WARNING : (float) not coded over 32 bits, metadata might not be byte swapped correctly"<< std::endl ; if (sizeof(double)!=8) ossimNotify(ossimNotifyLevel_WARN) << "RadarSat Data WARNING : (double) not coded over 64 bits, metadata might not be byte swapped correctly"<< std::endl ; RadarSatRecordHeader header; bool eof = false; int nbLin = 0 ; // number of image lines int lineLength = 0 ; // size of any ProcessedDataRecord is.seekg(0, std::ios::end) ; int lengthOfFile = is.tellg(); // total length of file is.seekg(0, std::ios::beg); while(!eof) { is>>header; if(is.eof()) { eof = true; } else { if (header.get_rec_seq() == 1) { // ImageOptionsFileDescriptor RadarSatRecord* record = factory.Instantiate(header.get_rec_seq()); if (record != NULL) { record->Read(is); data._records[Data::ImageOptionsFileDescriptorID] = record; nbLin = ((ImageOptionsFileDescriptor *) record)->get_nlin() ; if (nbLin == -1) { ossimNotify(ossimNotifyLevel_DEBUG) << "WARNING: nbLin is not read in the file !" << std::endl; } } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length()-12); delete[] buff; } } else if ((header.get_rec_seq() == 2)) { // First line ProcessedDataRecord lineLength = header.get_length() ; RadarSatRecord* record = factory.Instantiate(2); if (record != NULL) { record->Read(is); data._records[Data::FirstProcessedDataRecordID] = record; char* buff = new char[header.get_length()-192]; is.read(buff, header.get_length()-192); // Reads the rest of the line delete[] buff; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length()-12); delete[] buff; } } else if ((header.get_rec_seq() == (1+nbLin))) { // Last line ProcessedDataRecord RadarSatRecord* record = factory.Instantiate(2); if (record != NULL) { record->Read(is); data._records[Data::LastProcessedDataRecordID] = record; char* buff = new char[header.get_length()-192]; is.read(buff, header.get_length()-192); // Reads the rest of the line delete[] buff; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length()-12); delete[] buff; } } else { // all lines between the first and last ones are skipped if (lineLength != 0) { if (nbLin == -1) { // Compute the number of line per dataset from the size of file and current position int nbLines = ( ( lengthOfFile - is.tellg() ) / lineLength ) + 2; ossimNotify(ossimNotifyLevel_DEBUG) << "To move in the dat file we compute the nb of lines = " << nbLines << std::endl; // We move in the file to the last line is.seekg((nbLines - 2) * lineLength - 12, std::ios::cur); // We save the nbLines computed in data nbLin = nbLines; ImageOptionsFileDescriptor* record = data.get_ImageOptionsFileDescriptor(); record->set_nlin(nbLin); data._records[Data::ImageOptionsFileDescriptorID] = record; } else { // We move in the file is.seekg((nbLin - 2) * lineLength - 12, std::ios::cur); } } else { // We move to the end of the file is.seekg(0, std::ios::end) ; } } } } return is; } Data::Data(const Data& rhs) { std::map::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } } Data& Data::operator=(const Data& rhs) { std::map::const_iterator it = _records.begin(); while(it != _records.end()) { delete (*it).second; ++it; } _records.clear(); it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } return *this; } void Data::ClearRecords() { std::map::const_iterator it = _records.begin(); while(it != _records.end()) { delete (*it).second; ++it; } _records.clear(); } void Data::InsertRecord(int id, RadarSatRecord* record) { _records[id] = record; } ImageOptionsFileDescriptor* Data::get_ImageOptionsFileDescriptor() { return (ImageOptionsFileDescriptor*)_records[ImageOptionsFileDescriptorID]; } ProcessedDataRecord* Data::get_FirstProcessedDataRecord() { return (ProcessedDataRecord*)_records[FirstProcessedDataRecordID]; } ProcessedDataRecord* Data::get_LastProcessedDataRecord() { return (ProcessedDataRecord*)_records[LastProcessedDataRecordID]; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/Data.h000066400000000000000000000034361301006202600270770ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Data_h #define Data_h #include #include #include namespace ossimplugins { class ImageOptionsFileDescriptor; class ProcessedDataRecord; /** * @ingroup DataFile * @brief This class is able to read the data file of the RadarSat file structure * @author Magellium, Pacome Dentraygues * @version 1.0 * @date 23-11-07 */ class Data { public: /** * @brief Constructor */ Data(); /** * @brief Destructor */ ~Data(); /** * @brief This function writes the Data in a stream */ friend std::ostream& operator<<(std::ostream& os, const Data& data); /** * @brief This function reads a Data from a stream */ friend std::istream& operator>>(std::istream& is, Data& data); /** * @brief Copy constructor */ Data(const Data& rhs); /** * @brief Copy operator */ Data& operator=(const Data& rhs); /** * @brief Removes all the previous records from the Data */ void ClearRecords(); /** * @brief Inserts an existing record in the Data */ void InsertRecord(int id, RadarSatRecord* record); ImageOptionsFileDescriptor* get_ImageOptionsFileDescriptor(); ProcessedDataRecord* get_FirstProcessedDataRecord(); ProcessedDataRecord* get_LastProcessedDataRecord(); protected: std::map _records; static const int ImageOptionsFileDescriptorID; static const int FirstProcessedDataRecordID; static const int LastProcessedDataRecordID; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/DataFactory.cpp000066400000000000000000000016071301006202600307600ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace ossimplugins { DataFactory::DataFactory() { RegisterRecord(1, new ImageOptionsFileDescriptor()); RegisterRecord(2, new ProcessedDataRecord()); } DataFactory::~DataFactory() { std::map::iterator i = _availableRecords.begin(); while (i != _availableRecords.end()) { if ( (*i).second ) { delete (*i).second; (*i).second = 0; } ++i; } _availableRecords.clear(); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/DataFactory.h000066400000000000000000000013531301006202600304230ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DataFactory_h #define DataFactory_h #include #include namespace ossimplugins { /** * @ingroup DataFile * @brief This class is a factory able to construct Record base classes */ class DataFactory : public RadarSatRecordFactory { public: /** * @brief Contstructor */ DataFactory(); /** * @brief Destructor */ ~DataFactory(); protected: private: }; } #endif ImageOptionsFileDescriptor.cpp000066400000000000000000000203751301006202600337400ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace ossimplugins { static ossimTrace traceDebug("ImageOptionsFileDescriptor:debug"); ImageOptionsFileDescriptor::ImageOptionsFileDescriptor() : RadarSatRecord("imop_desc_rec") { } ImageOptionsFileDescriptor::~ImageOptionsFileDescriptor() { } std::ostream& operator<<(std::ostream& os, const ImageOptionsFileDescriptor& data) { os<<"ascii_flag:"<>(std::istream& is, ImageOptionsFileDescriptor& data) { char buf[15805]; buf[15804] = '\0'; is.read(buf,2); buf[2] = '\0'; data._ascii_flag = buf; is.read(buf,2); is.read(buf,12); buf[12] = '\0'; data._format_doc = buf; is.read(buf,2); buf[2] = '\0'; data._format_rev = buf; is.read(buf,2); buf[2] = '\0'; data._design_rev = buf; is.read(buf,12); buf[12] = '\0'; data._software_id = buf; is.read(buf,4); buf[4] = '\0'; data._file_num = atoi(buf); is.read(buf,16); buf[16] = '\0'; data._file_name = buf; is.read(buf,4); buf[4] = '\0'; data._rec_seq = buf; is.read(buf,8); buf[8] = '\0'; data._seq_loc = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._seq_len = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._rec_code = buf; is.read(buf,8); buf[8] = '\0'; data._code_loc = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._code_len = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._rec_len = buf; is.read(buf,8); buf[8] = '\0'; data._rlen_loc = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._rlen_len = atoi(buf); for (int i=0;i<4;i++) { is.read(buf,1); } is.read(buf,64); is.read(buf,6); buf[6] = '\0'; data._n_dataset = atoi(buf); is.read(buf,6); buf[6] = '\0'; data._l_dataset = atoi(buf); is.read(buf,24); is.read(buf,4); buf[4] = '\0'; data._nbit = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._nsamp = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._nbyte = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._justify = buf; is.read(buf,4); buf[4] = '\0'; data._nchn = atoi(buf); is.read(buf,8); buf[8] = '\0'; // We should use strtol() to avoid wrong conversion with atoi() char* p; int result = strtol(buf, &p, 10); if ( *p != 0 || p == buf) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "WARNING: strtol() try to convert an empty tab of characters. It may be possible in case of SCN and SCW format" << buf << "!" << std::endl; ossimNotify(ossimNotifyLevel_DEBUG) << "=> _nlin = -1" << std::endl; } data._nlin = -1; } else { data._nlin = result; }; is.read(buf,4); buf[4] = '\0'; data._nleft = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._ngrp = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._nright = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._ntop = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._nbott = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._intleav = buf; is.read(buf,2); buf[2] = '\0'; data._nrec_lin = atoi(buf); is.read(buf,2); buf[2] = '\0'; data._nrec_chn = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._n_prefix = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._n_sar = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._n_suffix = atoi(buf); is.read(buf,4); is.read(buf,8); buf[8] = '\0'; data._lin_loc = buf; is.read(buf,8); buf[8] = '\0'; data._chn_loc = buf; is.read(buf,8); buf[8] = '\0'; data._tim_loc = buf; is.read(buf,8); buf[8] = '\0'; data._left_loc = buf; is.read(buf,8); buf[8] = '\0'; data._right_loc = buf; is.read(buf,4); buf[4] = '\0'; data._pad_ind = buf; is.read(buf,28); is.read(buf,8); buf[8] = '\0'; data._qual_loc = buf; is.read(buf,8); buf[8] = '\0'; data._cali_loc = buf; is.read(buf,8); buf[8] = '\0'; data._gain_loc = buf; is.read(buf,8); buf[8] = '\0'; data._bias_loc = buf; is.read(buf,28); buf[28] = '\0'; data._type_id = buf; is.read(buf,4); buf[4] = '\0'; data._type_code = buf; is.read(buf,4); buf[4] = '\0'; data._left_fill = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._right_fill = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._pix_rng = atoi(buf); is.read(buf,15804); return is; } ImageOptionsFileDescriptor::ImageOptionsFileDescriptor(const ImageOptionsFileDescriptor& rhs): RadarSatRecord(rhs) { } ImageOptionsFileDescriptor& ImageOptionsFileDescriptor::operator=(const ImageOptionsFileDescriptor& /* rhs */) { return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/ImageOptionsFileDescriptor.h000066400000000000000000000260041301006202600334570ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ImageOptionsFileDescriptor_h #define ImageOptionsFileDescriptor_h #include #include #include namespace ossimplugins { /** * @ingroup ImageOptionsFileDescriptionRecord * @brief This class is able to read an Image options file descriptor record * @author Magellium, Pacome Dentraygues * @version 1.0 * @date 03-12-07 */ class ImageOptionsFileDescriptor : public RadarSatRecord { public: /** * @brief Constructor */ ImageOptionsFileDescriptor(); /** * @brief Destructor */ ~ImageOptionsFileDescriptor(); /** * @brief Copy constructor */ ImageOptionsFileDescriptor(const ImageOptionsFileDescriptor& rhs); /** * @brief Copy operator */ ImageOptionsFileDescriptor& operator=(const ImageOptionsFileDescriptor& rhs); /** * @brief This function writes the ImageOptionsFileDescriptor in a stream */ friend std::ostream& operator<<(std::ostream& os, const ImageOptionsFileDescriptor& data); /** * @brief This function reads a ImageOptionsFileDescriptor from a stream */ friend std::istream& operator>>(std::istream& is, ImageOptionsFileDescriptor& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new ImageOptionsFileDescriptor(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new ImageOptionsFileDescriptor(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Set the number of lines per data set */ void set_nlin(int inNbLines) { _nlin = inNbLines; }; /** * @brief ASCII flag */ std::string get_ascii_flag() { return _ascii_flag; }; /** * @brief Format control document */ std::string get_format_doc() { return _format_doc; }; /** * @brief Format document revision */ std::string get_format_rev() { return _format_rev; }; /** * @brief File design revision */ std::string get_design_rev() { return _design_rev; }; /** * @brief Software identifier */ std::string get_software_id() { return _software_id; }; /** * @brief File number */ int get_file_num() { return _file_num; }; /** * @brief File name */ std::string get_file_name() { return _file_name; }; /** * @brief Record sequence/location flag */ std::string get_rec_seq() { return _rec_seq; }; /** * @brief Sequence number location */ int get_seq_loc() { return _seq_loc; }; /** * @brief Sequence number length */ int get_seq_len() { return _seq_len; }; /** * @brief Record code/location flag */ std::string get_rec_code() { return _rec_code; }; /** * @brief Record code location */ int get_code_loc() { return _code_loc; }; /** * @brief Record code length */ int get_code_len() { return _code_len; }; /** * @brief Record length/location flag */ std::string get_rec_len() { return _rec_len; }; /** * @brief Record length location */ int get_rlen_loc() { return _rlen_loc; }; /** * @brief Record length length */ int get_rlen_len() { return _rlen_len; }; /** * @brief Number of SAR data records */ int get_n_dataset() { return _n_dataset; }; /** * @brief SAR data record length */ int get_l_dataset() { return _l_dataset; }; /** * @brief Number of bits per sample */ int get_nbit() { return _nbit; }; /** * @brief Samples per data group */ int get_nsamp() { return _nsamp; }; /** * @brief Bytes per data group */ int get_nbyte() { return _nbyte; }; /** * @brief Sample justification and order */ std::string get_justify() { return _justify; }; /** * @brief Number of SAR channels */ int get_nchn() { return _nchn; }; /** * @brief Lines per data set */ int get_nlin() { return _nlin; }; /** * @brief Left border pixels per line */ int get_nleft() { return _nleft; }; /** * @brief Groups per line per channel */ int get_ngrp() { return _ngrp; }; /** * @brief Right border pixels per line */ int get_nright() { return _nright; }; /** * @brief Top border lines */ int get_ntop() { return _ntop; }; /** * @brief Bottom border lines */ int get_nbott() { return _nbott; }; /** * @brief Interleave indicator */ std::string get_intleav() { return _intleav; }; /** * @brief Number of physical records per line */ int get_nrec_lin() { return _nrec_lin; }; /** * @brief Number of physical records per multi-channel line in this file */ int get_nrec_chn() { return _nrec_chn; }; /** * @brief Number of bytes of prefix data per record */ int get_n_prefix() { return _n_prefix; }; /** * @brief Number of bytes of SAR data (or pixel data) per record */ int get_n_sar() { return _n_sar; }; /** * @brief Number of bytes of suffix data per record */ int get_n_suffix() { return _n_suffix; }; /** * @brief Line number locator */ std::string get_lin_loc() { return _lin_loc; }; /** * @brief Channel number locator */ std::string get_chn_loc() { return _chn_loc; }; /** * @brief Time locator */ std::string get_tim_loc() { return _tim_loc; }; /** * @brief Left fill locator */ std::string get_left_loc() { return _left_loc; }; /** * @brief Right fill locator */ std::string get_right_loc() { return _right_loc; }; /** * @brief Pad pixel indicator */ std::string get_pad_ind() { return _pad_ind; }; /** * @brief Quality code locator */ std::string get_qual_loc() { return _qual_loc; }; /** * @brief Calibration info locator */ std::string get_cali_loc() { return _cali_loc; }; /** * @brief Gain value locator */ std::string get_gain_loc() { return _gain_loc; }; /** * @brief Bias value locator */ std::string get_bias_loc() { return _bias_loc; }; /** * @brief Data type identifier */ std::string get_type_id() { return _type_id; }; /** * @brief Data type code */ std::string get_type_code() { return _type_code; }; /** * @brief Number of left fill bits */ int get_left_fill() { return _left_fill; }; /** * @brief Number of right fill bits */ int get_right_fill() { return _right_fill; }; /** * @brief Maximum data range of pixel */ int get_pix_rng() { return _pix_rng; }; protected: /** * @brief ASCII flag */ std::string _ascii_flag; /** * @brief Format control document */ std::string _format_doc; /** * @brief Format document revision */ std::string _format_rev; /** * @brief File design revision */ std::string _design_rev; /** * @brief Software identifier */ std::string _software_id; /** * @brief File number */ int _file_num; /** * @brief File name */ std::string _file_name; /** * @brief Record sequence/location flag */ std::string _rec_seq; /** * @brief Sequence number location */ int _seq_loc; /** * @brief Sequence number length */ int _seq_len; /** * @brief Record code/location flag */ std::string _rec_code; /** * @brief Record code location */ int _code_loc; /** * @brief Record code length */ int _code_len; /** * @brief Record length/location flag */ std::string _rec_len; /** * @brief Record length location */ int _rlen_loc; /** * @brief Record length length */ int _rlen_len; /** * @brief Number of SAR data records */ int _n_dataset; /** * @brief SAR data record length */ int _l_dataset; /** * @brief Number of bits per sample */ int _nbit; /** * @brief Samples per data group */ int _nsamp; /** * @brief Bytes per data group */ int _nbyte; /** * @brief Sample justification and order */ std::string _justify; /** * @brief Number of SAR channels */ int _nchn; /** * @brief Lines per data set */ int _nlin; /** * @brief Left border pixels per line */ int _nleft; /** * @brief Groups per line per channel */ int _ngrp; /** * @brief Right border pixels per line */ int _nright; /** * @brief Top border lines */ int _ntop; /** * @brief Bottom border lines */ int _nbott; /** * @brief Interleave indicator */ std::string _intleav; /** * @brief Number of physical records per line */ int _nrec_lin; /** * @brief Number of physical records per multi-channel line in this file */ int _nrec_chn; /** * @brief Number of bytes of prefix data per record */ int _n_prefix; /** * @brief Number of bytes of SAR data (or pixel data) per record */ int _n_sar; /** * @brief Number of bytes of suffix data per record */ int _n_suffix; /** * @brief Line number locator */ std::string _lin_loc; /** * @brief Channel number locator */ std::string _chn_loc; /** * @brief Time locator */ std::string _tim_loc; /** * @brief Left fill locator */ std::string _left_loc; /** * @brief Right fill locator */ std::string _right_loc; /** * @brief Pad pixel indicator */ std::string _pad_ind; /** * @brief Quality code locator */ std::string _qual_loc; /** * @brief Calibration info locator */ std::string _cali_loc; /** * @brief Gain value locator */ std::string _gain_loc; /** * @brief Bias value locator */ std::string _bias_loc; /** * @brief Data type identifier */ std::string _type_id; /** * @brief Data type code */ std::string _type_code; /** * @brief Number of left fill bits */ int _left_fill; /** * @brief Number of right fill bits */ int _right_fill; /** * @brief Maximum data range of pixel */ int _pix_rng; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/ProcessedDataRecord.cpp000066400000000000000000000145151301006202600324410ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { ProcessedDataRecord::ProcessedDataRecord() : RadarSatRecord("proc_data_rec") { } ProcessedDataRecord::~ProcessedDataRecord() { } std::ostream& operator<<(std::ostream& os, const ProcessedDataRecord& data) { os<<"line_num:"<>(std::istream& is, ProcessedDataRecord& data) { char buf[193]; buf[192] = '\0'; is.read((char*)&(data._line_num),4); data.SwitchEndian(data._line_num); is.read((char*)&(data._rec_num),4); data.SwitchEndian(data._rec_num); is.read((char*)&(data._n_left_pixel),4); data.SwitchEndian(data._n_left_pixel); is.read((char*)&(data._n_data_pixel),4); data.SwitchEndian(data._n_data_pixel); is.read((char*)&(data._n_right_pixel),4); data.SwitchEndian(data._n_right_pixel); is.read((char*)&(data._sensor_updf),4); data.SwitchEndian(data._sensor_updf); is.read((char*)&(data._acq_year),4); data.SwitchEndian(data._acq_year); is.read((char*)&(data._acq_day),4); data.SwitchEndian(data._acq_day); is.read((char*)&(data._acq_msec),4); data.SwitchEndian(data._acq_msec); is.read((char*)&(data._sar_chan_ind),2); data.SwitchEndian(data._sar_chan_ind); is.read((char*)&(data._sar_chan_code),2); data.SwitchEndian(data._sar_chan_code); is.read((char*)&(data._tran_polar),2); data.SwitchEndian(data._tran_polar ); is.read((char*)&(data._recv_polar),2); data.SwitchEndian(data._recv_polar); is.read((char*)&(data._prf),4); data.SwitchEndian(data._prf ); is.read(buf,4); is.read((char*)&(data._sr_first),4); data.SwitchEndian(data._sr_first); is.read((char*)&(data._sr_mid),4); data.SwitchEndian(data._sr_mid); is.read((char*)&(data._sr_last),4); data.SwitchEndian(data._sr_last); is.read((char*)&(data._fdc_first),4); data.SwitchEndian(data._fdc_first); is.read((char*)&(data._fdc_mid),4); data.SwitchEndian(data._fdc_mid); is.read((char*)&(data._fdc_last),4); data.SwitchEndian(data._fdc_last); is.read((char*)&(data._ka_first),4); data.SwitchEndian(data._ka_first); is.read((char*)&(data._ka_mid),4); data.SwitchEndian(data._ka_mid); is.read((char*)&(data._ka_last),4); data.SwitchEndian(data._ka_last); is.read((char*)&(data._nadir_ang),4); data.SwitchEndian(data._nadir_ang); is.read((char*)&(data._squint_ang),4); data.SwitchEndian(data._squint_ang); is.read(buf,4); is.read(buf,16); is.read((char*)&(data._geo_updf),4); data.SwitchEndian(data._geo_updf); is.read((char*)&(data._lat_first),4); data.SwitchEndian(data._lat_first); is.read((char*)&(data._lat_mid),4); data.SwitchEndian(data._lat_mid); is.read((char*)&(data._lat_last),4); data.SwitchEndian(data._lat_last); is.read((char*)&(data._lon_first),4); data.SwitchEndian(data._lon_first); is.read((char*)&(data._lon_mid),4); data.SwitchEndian(data._lon_mid); is.read((char*)&(data._lon_last),4); data.SwitchEndian(data._lon_last); is.read((char*)&(data._north_first),4); data.SwitchEndian(data._north_first); is.read(buf,4); is.read((char*)&(data._north_last),4); data.SwitchEndian(data._north_last); is.read((char*)&(data._east_first),4); data.SwitchEndian(data._east_first); is.read(buf,4); is.read((char*)&(data._east_last),4); data.SwitchEndian(data._east_last); is.read((char*)&(data._heading),4); data.SwitchEndian(data._heading); is.read(buf,8); return is; } ProcessedDataRecord::ProcessedDataRecord(const ProcessedDataRecord& rhs): RadarSatRecord(rhs) { } ProcessedDataRecord& ProcessedDataRecord::operator=(const ProcessedDataRecord& /* rhs */) { return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Data/ProcessedDataRecord.h000066400000000000000000000210471301006202600321040ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ProcessedDataRecord_h #define ProcessedDataRecord_h #include #include #include #include namespace ossimplugins { /** * @ingroup ProcessedDataRecord * @brief This class is able to read an Processed Data Record */ class ProcessedDataRecord : public RadarSatRecord { public: /** * @brief Constructor */ ProcessedDataRecord(); /** * @brief Destructor */ ~ProcessedDataRecord(); /** * @brief Copy constructor */ ProcessedDataRecord(const ProcessedDataRecord& rhs); /** * @brief Copy operator */ ProcessedDataRecord& operator=(const ProcessedDataRecord& rhs); /** * @brief This function writes the ProcessedDataRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const ProcessedDataRecord& data); /** * @brief This function reads a ProcessedDataRecord from a stream */ friend std::istream& operator>>(std::istream& is, ProcessedDataRecord& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new ProcessedDataRecord(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new ProcessedDataRecord(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Image data line number */ int get_line_num() {return _line_num;}; /** * @brief Image data record index */ int get_rec_num() {return _rec_num;}; /** * @brief Left fill pixel count */ int get_n_left_pixel() {return _n_left_pixel;}; /** * @brief Data pixel count */ int get_n_data_pixel() {return _n_data_pixel;}; /** * @brief Right fill pixel count */ int get_n_right_pixel() {return _n_right_pixel;}; /** * @brief Sensor parameter update flag */ int get_sensor_updf() {return _sensor_updf;}; /** * @brief Acquisition year */ int get_acq_year() {return _acq_year;}; /** * @brief Acquisition day */ int get_acq_day() {return _acq_day;}; /** * @brief Acquisition msecs */ int get_acq_msec() {return _acq_msec;}; /** * @brief SAR channel indicator */ int get_sar_chan_ind() {return _sar_chan_ind;}; /** * @brief SAR channel code */ int get_sar_chan_code() {return _sar_chan_code;}; /** * @brief Transmitted polarization */ int get_tran_polar() {return _tran_polar;}; /** * @brief Received polarization */ int get_recv_polar() {return _recv_polar;}; /** * @brief PRF */ int get_prf() {return _prf;}; /** * @brief Slant range to first pixel, m */ int get_sr_first() {return _sr_first;}; /** * @brief Slant range to mid-pixel, m */ int get_sr_mid() {return _sr_mid;}; /** * @brief Slant range to last pixel, m */ int get_sr_last() {return _sr_last;}; /** * @brief First pixel Doppler centroid, Hz */ int get_fdc_first() {return _fdc_first;}; /** * @brief Mid pixel Doppler centroid, Hz */ int get_fdc_mid() {return _fdc_mid;}; /** * @brief Last pixel Doppler centroid, Hz */ int get_fdc_last() {return _fdc_last;}; /** * @brief First pixel azimuth FM rate, Hz */ int get_ka_first() {return _ka_first;}; /** * @brief Mid pixel azimuth FM rate, Hz */ int get_ka_mid() {return _ka_mid;}; /** * @brief Last pixel azimuth FM rate, Hz */ int get_ka_last() {return _ka_last;}; /** * @brief Nadir look angle, 10e-6 deg */ int get_nadir_ang() {return _nadir_ang;}; /** * @brief Azimuth squint angle, 10e-6 deg */ int get_squint_ang() {return _squint_ang;}; /** * @brief Geographic ref parameter update flag */ int get_geo_updf() {return _geo_updf;}; /** * @brief First pixel latitude, 10e-6 deg */ int get_lat_first() {return _lat_first;}; /** * @brief Mid-pixel latitude, 10e-6 deg */ int get_lat_mid() {return _lat_mid;}; /** * @brief Last-pixel latitude, 10e-6 deg */ int get_lat_last() {return _lat_last;}; /** * @brief First pixel longitude, 10e-6 deg */ int get_lon_first() {return _lon_first;}; /** * @brief Mid-pixel longitude, 10e-6 deg */ int get_lon_mid() {return _lon_mid;}; /** * @brief Last-pixel longitude, 10e-6 deg */ int get_lon_last() {return _lon_last;}; /** * @brief Northing of first pixel, m */ int get_north_first() {return _north_first;}; /** * @brief Northing of last pixel, m */ int get_north_last() {return _north_last;}; /** * @brief Easting of first pixel, m */ int get_east_first() {return _east_first;}; /** * @brief Easting of last pixel, m */ int get_east_last() {return _east_last;}; /** * @brief Line heading, 10e-6 deg */ int get_heading() {return _heading;}; protected: /** * @brief Image data line number */ int _line_num; /** * @brief Image data record index */ int _rec_num; /** * @brief Left fill pixel count */ int _n_left_pixel; /** * @brief Data pixel count */ int _n_data_pixel; /** * @brief Right fill pixel count */ int _n_right_pixel; /** * @brief Sensor parameter update flag */ int _sensor_updf; /** * @brief Acquisition year */ int _acq_year; /** * @brief Acquisition day */ int _acq_day; /** * @brief Acquisition msecs */ int _acq_msec; /** * @brief SAR channel indicator */ int _sar_chan_ind; /** * @brief SAR channel code */ int _sar_chan_code; /** * @brief Transmitted polarization */ int _tran_polar; /** * @brief Received polarization */ int _recv_polar; /** * @brief PRF */ int _prf; /** * @brief Slant range to first pixel, m */ int _sr_first; /** * @brief Slant range to mid-pixel, m */ int _sr_mid; /** * @brief Slant range to last pixel, m */ int _sr_last; /** * @brief First pixel Doppler centroid, Hz */ int _fdc_first; /** * @brief Mid pixel Doppler centroid, Hz */ int _fdc_mid; /** * @brief Last pixel Doppler centroid, Hz */ int _fdc_last; /** * @brief First pixel azimuth FM rate, Hz */ int _ka_first; /** * @brief Mid pixel azimuth FM rate, Hz */ int _ka_mid; /** * @brief Last pixel azimuth FM rate, Hz */ int _ka_last; /** * @brief Nadir look angle, 10e-6 deg */ int _nadir_ang; /** * @brief Azimuth squint angle, 10e-6 deg */ int _squint_ang; /** * @brief Geographic ref parameter update flag */ int _geo_updf; /** * @brief First pixel latitude, 10e-6 deg */ int _lat_first; /** * @brief Mid-pixel latitude, 10e-6 deg */ int _lat_mid; /** * @brief Last-pixel latitude, 10e-6 deg */ int _lat_last; /** * @brief First pixel longitude, 10e-6 deg */ int _lon_first; /** * @brief Mid-pixel longitude, 10e-6 deg */ int _lon_mid; /** * @brief Last-pixel longitude, 10e-6 deg */ int _lon_last; /** * @brief Northing of first pixel, m */ int _north_first; /** * @brief Northing of last pixel, m */ int _north_last; /** * @brief Easting of first pixel, m */ int _east_first; /** * @brief Easting of last pixel, m */ int _east_last; /** * @brief Line heading, 10e-6 deg */ int _heading; private: /** * @brief This function switches the LSB value and the MSB value of the parameter */ template void SwitchEndian(T &value) { char *buffer; char *res; int nb_octets = sizeof(T); if (ossim::byteOrder() == OSSIM_LITTLE_ENDIAN) { buffer = (char* )malloc(nb_octets); res = (char* )malloc(nb_octets); memcpy(buffer,&value,nb_octets); for (int i=0; i namespace ossimplugins { DataHistogramProcessedData::DataHistogramProcessedData() : RadarSatRecord("pdr16_hist_rec") { } DataHistogramProcessedData::~DataHistogramProcessedData() { } std::ostream& operator<<(std::ostream& os, const DataHistogramProcessedData& data) { os<<"rec_seq:"<>(std::istream& is, DataHistogramProcessedData& data) { char buff[33]; buff[32] = '\0'; is.read(buff,4); buff[4] = '\0'; data._rec_seq = atoi(buff); is.read(buff,4); buff[4] = '\0'; data._sar_chn = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ntab = atoi(buff); is.read(buff,8); buff[8] = '\0'; data._ltab = atoi(buff); is>>data._histogram1; is>>data._histogram2; char tmp[5]; tmp[4] = '\0'; is.read(tmp, 4); return is; } DataHistogramProcessedData::DataHistogramProcessedData(const DataHistogramProcessedData& rhs) : RadarSatRecord(rhs), _rec_seq(rhs._rec_seq), _sar_chn(rhs._sar_chn), _ntab(rhs._ntab), _ltab(rhs._ltab), _histogram1(rhs._histogram1), _histogram2(rhs._histogram2) { } DataHistogramProcessedData& DataHistogramProcessedData::operator=(const DataHistogramProcessedData& rhs) { _histogram1 = rhs._histogram1; _histogram2 = rhs._histogram2; _sar_chn = rhs._sar_chn; _rec_seq = rhs._rec_seq; _ntab = rhs._ntab; _ltab = rhs._ltab; return *this; } } DataHistogramProcessedData.h000066400000000000000000000067261301006202600336700ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef DataHistogramProcessedData_h #define DataHistogramProcessedData_h #include #include #include #include namespace ossimplugins { /** * @ingroup ProcessedData16bitHistogramRecord * @brief This class is able to read a data histogram record - Processed data * @warning There is an error in the documentation for the spare at the end of the record. * They say 3 bytes (A3) but they also say that the spare is on the bytes 16917, 16918, 16919 and 16920. * In the data files I have, I need to use a spare of 4 bytes. */ class DataHistogramProcessedData : public RadarSatRecord { public: /** * @brief Constructor */ DataHistogramProcessedData(); /** * @brief Destructor */ virtual ~DataHistogramProcessedData(); /** * @brief Copy constructor */ DataHistogramProcessedData(const DataHistogramProcessedData& rhs); /** * @brief Copy operator */ DataHistogramProcessedData& operator=(const DataHistogramProcessedData& rhs); /** * @brief This function writes the DataHistogramProcessedData in a stream */ friend std::ostream& operator<<(std::ostream& os, const DataHistogramProcessedData& data); /** * @brief This function reads a DataHistogramProcessedData from a stream */ friend std::istream& operator>>(std::istream& is, DataHistogramProcessedData& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new DataHistogramProcessedData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new DataHistogramProcessedData(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Record sequence number */ int get_rec_seq() { return _rec_seq; }; /** * @brief SAR channel indicator */ int get_sar_chn() { return _sar_chn; }; /** * @brief Number of histogram table data sets in this record */ int get_ntab() { return _ntab; }; /** * @brief Histogram table data set size */ int get_ltab() { return _ltab; }; /** * @brief Histogram data record #1 */ DataHistogramRecord get_histogram1() { return _histogram1; }; /** * @brief Histogram data record #2 */ DataHistogramRecord get_histogram2() { return _histogram2; }; protected: /** * @brief Record sequence number */ int _rec_seq; /** * @brief SAR channel indicator */ int _sar_chn; /** * @brief Number of histogram table data sets in this record */ int _ntab; /** * @brief Histogram table data set size */ int _ltab; /** * @brief Histogram data record #1 */ DataHistogramRecord _histogram1; /** * @brief Histogram data record #2 */ DataHistogramRecord _histogram2; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/Leader.cpp000066400000000000000000000112321301006202600302710ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { const int Leader::RadiometricDataID = 9; const int Leader::RadiometricCompensationDataID = 10; const int Leader::AttitudeDataID = 8; const int Leader::PlatformPositionDataID = 7; const int Leader::ProcessingParametersID = 6; const int Leader::DataHistogramProcessedDataID = 5; const int Leader::DataHistogramSignalDataID = 4; const int Leader::DataQualityID = 3; const int Leader::DataSetSummaryID = 2; const int Leader::FileDescriptorID = 1; Leader::Leader() { } Leader::~Leader() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const Leader& data) { std::map::const_iterator it = data._records.begin(); while(it != data._records.end()) { (*it).second->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, Leader& data) { LeaderFactory factory; data.ClearRecords(); RadarSatRecordHeader header; bool eof = false; while(!eof) { is>>header; if(is.eof()) { eof = true; } else { RadarSatRecord* record; if ( (header.get_rec_seq() == 2) && (header.get_length() == 8960) ) { record = factory.Instantiate(header.get_rec_seq() + 5); // case of SCN, SCW if (record != NULL) { record->Read(is); data._records[header.get_rec_seq() + 5] = record; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length()-12); delete[] buff; } } else { record = factory.Instantiate(header.get_rec_seq()); if (record != NULL) { record->Read(is); data._records[header.get_rec_seq()] = record; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length()-12); delete[] buff; } } } } return is; } Leader::Leader(const Leader& rhs) { std::map::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } } Leader& Leader::operator=(const Leader& rhs) { ClearRecords(); std::map::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } return *this; } void Leader::ClearRecords() { std::map::const_iterator it = _records.begin(); while(it != _records.end()) { delete (*it).second; ++it; } _records.clear(); } RadiometricData * Leader::get_RadiometricData() { return (RadiometricData*)_records[RadiometricDataID]; } RadiometricCompensationData * Leader::get_RadiometricCompensationData() { return (RadiometricCompensationData*)_records[RadiometricCompensationDataID]; } AttitudeData * Leader::get_AttitudeData() { return (AttitudeData*)_records[AttitudeDataID]; } PlatformPositionData * Leader::get_PlatformPositionData() { return (PlatformPositionData*)_records[PlatformPositionDataID]; } ProcessingParameters * Leader::get_ProcessingParameters() { return (ProcessingParameters*)_records[ProcessingParametersID]; } DataHistogramProcessedData * Leader::get_DataHistogramProcessedData() { return (DataHistogramProcessedData*)_records[DataHistogramProcessedDataID]; } DataHistogramSignalData * Leader::get_DataHistogramSignalData() { return (DataHistogramSignalData*)_records[DataHistogramSignalDataID]; } DataQuality * Leader::get_DataQuality() { return (DataQuality*)_records[DataQualityID]; } DataSetSummary * Leader::get_DataSetSummary() { return (DataSetSummary*)_records[DataSetSummaryID]; } FileDescriptor * Leader::get_FileDescriptor() { return (FileDescriptor*)_records[FileDescriptorID]; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/Leader.h000066400000000000000000000052631301006202600277450ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Leader_h #define Leader_h #include #include #include #include #include #include "DataHistogramProcessedData.h" #include namespace ossimplugins { class RadiometricData; class RadiometricCompensationData; class AttitudeData; class PlatformPositionData; class ProcessingParameters; class DataHistogramProcessedData; class DataHistogramSignalData; class DataQuality; class DataSetSummary; class FileDescriptor; /** * @ingroup LeaderFile * @brief This class is able to read the leader file of the RadarSat file structure * @author Magellium, Pacome Dentraygues * @version 1.0 * @date 23-11-07 */ class Leader { public: /** * @brief Constructor */ Leader(); /** * @brief Destructor */ ~Leader(); /** * @brief This function writes the Leader in a stream */ friend std::ostream& operator<<(std::ostream& os, const Leader& data); /** * @brief This function reads a Leader from a stream */ friend std::istream& operator>>(std::istream& is, Leader& data); /** * @brief Copy constructor */ Leader(const Leader& rhs); /** * @brief Copy operator */ Leader& operator=(const Leader& rhs); /** * @brief Removes all the previous records from the Leader */ void ClearRecords(); RadiometricData * get_RadiometricData(); RadiometricCompensationData * get_RadiometricCompensationData(); AttitudeData * get_AttitudeData(); PlatformPositionData * get_PlatformPositionData(); ProcessingParameters * get_ProcessingParameters(); DataHistogramProcessedData * get_DataHistogramProcessedData(); DataHistogramSignalData * get_DataHistogramSignalData(); DataQuality * get_DataQuality(); DataSetSummary * get_DataSetSummary(); FileDescriptor * get_FileDescriptor(); protected: std::map _records; static const int RadiometricDataID; static const int RadiometricCompensationDataID; static const int AttitudeDataID; static const int PlatformPositionDataID; static const int ProcessingParametersID; static const int DataHistogramProcessedDataID; static const int DataHistogramSignalDataID; static const int DataQualityID; static const int DataSetSummaryID; static const int FileDescriptorID; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/LeaderFactory.cpp000066400000000000000000000032531301006202600316250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { LeaderFactory::LeaderFactory() { RegisterRecord(9, new RadiometricData()); RegisterRecord(10, new RadiometricCompensationData()); RegisterRecord(8, new AttitudeData()); RegisterRecord(7, new PlatformPositionData()); RegisterRecord(6, new ProcessingParameters()); RegisterRecord(5, new DataHistogramProcessedData()); RegisterRecord(4, new DataHistogramSignalData()); RegisterRecord(3, new DataQuality()); RegisterRecord(2, new DataSetSummary()); RegisterRecord(1, new FileDescriptor()); } LeaderFactory::~LeaderFactory() { std::map::iterator i = _availableRecords.begin(); while (i != _availableRecords.end()) { if ( (*i).second ) { delete (*i).second; (*i).second = 0; } ++i; } _availableRecords.clear(); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/LeaderFactory.h000066400000000000000000000013721301006202600312720ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef LeaderFactory_h #define LeaderFactory_h #include #include namespace ossimplugins { /** * @ingroup LeaderFile * @brief This class is a factory able to construct Record base classes */ class LeaderFactory : public RadarSatRecordFactory { public: /** * @brief Contstructor */ LeaderFactory(); /** * @brief Destructor */ ~LeaderFactory(); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/PlatformPositionData.cpp000066400000000000000000000105421301006202600332030ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { PlatformPositionData::PlatformPositionData() : RadarSatRecord("pos_data_rec") { } PlatformPositionData::~PlatformPositionData() { } std::ostream& operator<<(std::ostream& os, const PlatformPositionData& data) { os<<"orbit_ele_desg:"<>(std::istream& is, PlatformPositionData& data) { char buf[1207]; buf[1206] = '\0'; is.read(buf,32); buf[32] = '\0'; data._orbit_ele_desg = buf; for(int i=0;i<6;i++) { is.read(buf,16); buf[16] = '\0'; data._orbit_ele[i] = atof(buf); } is.read(buf,4); buf[4] = '\0'; data._ndata = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._year = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._month = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._day = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._gmt_day = atoi(buf); is.read(buf,22); buf[22] = '\0'; data._gmt_sec = atof(buf); is.read(buf,22); buf[22] = '\0'; data._data_int = atof(buf); is.read(buf,64); buf[64] = '\0'; data._ref_coord = buf; is.read(buf,22); buf[22] = '\0'; data._hr_angle = atof(buf); is.read(buf,16); buf[16] = '\0'; data._alt_poserr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._crt_poserr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rad_poserr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._alt_velerr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._crt_velerr = atof(buf); is.read(buf,16); buf[16] = '\0'; data._rad_velerr = atof(buf); for (int i=0;i<64;i++) { is>>data._pos_vect[i]; } is.read(buf,126); return is; } PlatformPositionData::PlatformPositionData(const PlatformPositionData& rhs): RadarSatRecord(rhs) { _orbit_ele_desg = rhs._orbit_ele_desg; for(int i=0;i<6;i++) { _orbit_ele[i] = rhs._orbit_ele[i]; } _ndata = rhs._ndata; _year = rhs._year; _month = rhs._month; _day = rhs._day; _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _data_int = rhs._data_int; _ref_coord = rhs._ref_coord; _hr_angle = rhs._hr_angle; _alt_poserr = rhs._alt_poserr; _crt_poserr = rhs._crt_poserr; _rad_poserr = rhs._rad_poserr; _alt_velerr = rhs._alt_velerr; _crt_velerr = rhs._crt_velerr; _rad_velerr = rhs._rad_velerr; for (int i=0;i<64;i++) { _pos_vect[i] = rhs._pos_vect[i]; } } PlatformPositionData& PlatformPositionData::operator=(const PlatformPositionData& rhs) { _orbit_ele_desg = rhs._orbit_ele_desg; for(int i=0;i<6;i++) { _orbit_ele[i] = rhs._orbit_ele[i]; } _ndata = rhs._ndata; _year = rhs._year; _month = rhs._month; _day = rhs._day; _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _data_int = rhs._data_int; _ref_coord = rhs._ref_coord; _hr_angle = rhs._hr_angle; _alt_poserr = rhs._alt_poserr; _crt_poserr = rhs._crt_poserr; _rad_poserr = rhs._rad_poserr; _alt_velerr = rhs._alt_velerr; _crt_velerr = rhs._crt_velerr; _rad_velerr = rhs._rad_velerr; for (int i=0;i<64;i++) { _pos_vect[i] = rhs._pos_vect[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/PlatformPositionData.h000066400000000000000000000121621301006202600326500ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef PlatformPositionData_h #define PlatformPositionData_h #include #include #include #include namespace ossimplugins { /** * @ingroup PlatformPositionDataRecord * @brief This class is able to read a Platform position data record */ class PlatformPositionData : public RadarSatRecord { public: /** * @brief Constructor */ PlatformPositionData(); /** * @brief Destructor */ ~PlatformPositionData(); /** * @brief Copy constructor */ PlatformPositionData(const PlatformPositionData& rhs); /** * @brief Copy operator */ PlatformPositionData& operator=(const PlatformPositionData& rhs); /** * @brief This function writes the PlatformPositionData in a stream */ friend std::ostream& operator<<(std::ostream& os, const PlatformPositionData& data); /** * @brief This function reads a PlatformPositionData from a stream */ friend std::istream& operator>>(std::istream& is, PlatformPositionData& data); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new PlatformPositionData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new PlatformPositionData(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief Orbital elements designator */ std::string get_orbit_ele_desg() { return _orbit_ele_desg; }; /** * @brief Orbital elements */ double* get_orbit_ele() { return _orbit_ele; }; /** * @brief Number of data points */ int get_ndata() { return _ndata; }; /** * @brief Year of data point */ int get_year() { return _year; }; /** * @brief Month of data point */ int get_month() { return _month; }; /** * @brief Day of data point */ int get_day() { return _day; }; /** * @brief Day of year */ int get_gmt_day() { return _gmt_day; }; /** * @brief Seconds of day */ double get_gmt_sec() { return _gmt_sec; }; /** * @brief Data sampling interval */ double get_data_int() { return _data_int; }; /** * @brief Reference coordinate system */ std::string get_ref_coord() { return _ref_coord; }; /** * @brief Greenwich mean hour angle */ double get_hr_angle() { return _hr_angle; }; /** * @brief Along track position error */ double get_alt_poserr() { return _alt_poserr; }; /** * @brief Cross track position error */ double get_crt_poserr() { return _crt_poserr; }; /** * @brief Radial position error */ double get_rad_poserr() { return _rad_poserr; }; /** * @brief Along track velocity error */ double get_alt_velerr() { return _alt_velerr; }; /** * @brief Cross track velocity error */ double get_crt_velerr() { return _crt_velerr; }; /** * @brief Radial velocity error */ double get_rad_velerr() { return _rad_velerr; }; /** * @brief Data point position/velocity */ PositionVectorRecord* get_pos_vect() { return _pos_vect; }; protected: /** * @brief Orbital elements designator */ std::string _orbit_ele_desg; /** * @brief Orbital elements */ double _orbit_ele[6]; /** * @brief Number of data points */ int _ndata; /** * @brief Year of data point */ int _year; /** * @brief Month of data point */ int _month; /** * @brief Day of data point */ int _day; /** * @brief Day of year */ int _gmt_day; /** * @brief Seconds of day */ double _gmt_sec; /** * @brief Data sampling interval */ double _data_int; /** * @brief Reference coordinate system */ std::string _ref_coord; /** * @brief Greenwich mean hour angle */ double _hr_angle; /** * @brief Along track position error */ double _alt_poserr; /** * @brief Cross track position error */ double _crt_poserr; /** * @brief Radial position error */ double _rad_poserr; /** * @brief Along track velocity error */ double _alt_velerr; /** * @brief Cross track velocity error */ double _crt_velerr; /** * @brief Radial velocity error */ double _rad_velerr; /** * @brief Data point position/velocity */ PositionVectorRecord _pos_vect[64]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/PositionVectorRecord.cpp000066400000000000000000000026171301006202600332320ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { PositionVectorRecord::PositionVectorRecord() { } PositionVectorRecord::~PositionVectorRecord() { } std::ostream& operator<<(std::ostream& os, const PositionVectorRecord& data) { for (int i=0;i<3;i++) { os<<"pos["<>(std::istream& is, PositionVectorRecord& data) { char buf[23]; buf[22] = '\0'; for (int i=0;i<3;i++) { is.read(buf,22); data._pos[i] = atof(buf); } for (int i=0;i<3;i++) { is.read(buf,22); data._vel[i] = atof(buf); } return is; } PositionVectorRecord::PositionVectorRecord(const PositionVectorRecord& rhs) { for (int i=0;i<3;i++) { _pos[i] = rhs._pos[i]; } for (int i=0;i<3;i++) { _vel[i] = rhs._vel[i]; } } PositionVectorRecord& PositionVectorRecord::operator=(const PositionVectorRecord& rhs) { for (int i=0;i<3;i++) { _pos[i] = rhs._pos[i]; } for (int i=0;i<3;i++) { _vel[i] = rhs._vel[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Leader/PositionVectorRecord.h000066400000000000000000000031411301006202600326700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef PositionVectorRecord_h #define PositionVectorRecord_h #include #include namespace ossimplugins { /** * @ingroup PlatformPositionDataRecord * @brief This class is able to read a position vector record */ class PositionVectorRecord { public: /** * @brief Constructor */ PositionVectorRecord(); /** * @brief Destructor */ ~PositionVectorRecord(); /** * @brief Copy constructor */ PositionVectorRecord(const PositionVectorRecord& rhs); /** * @brief Copy operator */ PositionVectorRecord& operator=(const PositionVectorRecord& rhs); /** * @brief This function writes the PositionVectorRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const PositionVectorRecord& data); /** * @brief This function reads a PositionVectorRecord from a stream */ friend std::istream& operator>>(std::istream& is, PositionVectorRecord& data); /** * @brief Data point position (m) */ double* get_pos() { return _pos; }; /** * @brief Data point velocity (mm/s) */ double* get_vel() { return _vel; }; protected: /** * @brief Data point position (m) */ double _pos[3]; /** * @brief Data point velocity (mm/s) */ double _vel[3]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/RadarSatRecord.cpp000066400000000000000000000011411301006202600305370ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include namespace ossimplugins { RadarSatRecord::RadarSatRecord(std::string mnemonic): _mnemonic(mnemonic) { } RadarSatRecord::~RadarSatRecord() { } RadarSatRecord::RadarSatRecord(const RadarSatRecord& rhs): _mnemonic(rhs._mnemonic) { } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/RadarSatRecord.h000066400000000000000000000027201301006202600302100ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RadarSatRecord_h #define RadarSatRecord_h #include #include #include namespace ossimplugins { /** * @ingroup RadarSat * @brief This class is the base class of all the record classes */ class RadarSatRecord { public: /** * @brief Constructor * @param mnemonic Name of the record */ RadarSatRecord(std::string mnemonic); /** * @brief Destructor */ virtual ~RadarSatRecord(); /** * @brief Copy constructor */ RadarSatRecord(const RadarSatRecord& rhs); /** * @brief This function is able to create a new instance of the class */ virtual RadarSatRecord* Instantiate() =0; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ virtual RadarSatRecord* Clone()=0; /** * @brief Reads the class data from a stream */ virtual void Read(std::istream& is) =0; /** * @brief Writes the class to a stream */ virtual void Write(std::ostream& os)=0; std::string get_mnemonic() { return _mnemonic; }; protected: std::string _mnemonic; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/RadarSatRecordFactory.cpp000066400000000000000000000014441301006202600320750ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { RadarSatRecordFactory::RadarSatRecordFactory() { } RadarSatRecordFactory::~RadarSatRecordFactory() { } RadarSatRecord* RadarSatRecordFactory::Instantiate(int id) { RadarSatRecord* record = _availableRecords[id]; if(record == NULL) { return NULL; } else { return record->Instantiate(); } } void RadarSatRecordFactory::RegisterRecord(int id, RadarSatRecord * record) { _availableRecords[id] = record; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/RadarSatRecordFactory.h000066400000000000000000000024641301006202600315450ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RadarSatRecordFactory_h #define RadarSatRecordFactory_h #include #include #include namespace ossimplugins { /** * @ingroup RadarSat * @brief This class is a factory able to construct Record base classes given the id of the wanted record */ class RadarSatRecordFactory { public: /** * @brief Constructor */ RadarSatRecordFactory(); /** * @brief Destructor */ ~RadarSatRecordFactory(); /** * @brief Add a new Record type available in this factory * @param record Record to add in the factory * @param id Id of the new available Record */ void RegisterRecord(int id, RadarSatRecord * record); /** * @brief Instantiates a new Record * @param id Id of the Record we want to instantiate */ RadarSatRecord* Instantiate(int id) ; protected: /** * @brief Contains all the available Records for the factory */ std::map _availableRecords; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/RadarSatRecordHeader.cpp000066400000000000000000000036761301006202600316670ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { RadarSatRecordHeader::RadarSatRecordHeader() { } RadarSatRecordHeader::~RadarSatRecordHeader() { } std::ostream& operator<<(std::ostream& os, const RadarSatRecordHeader& data) { os<<"record_sequence_number:"<>(std::istream& is, RadarSatRecordHeader& data) { is.read((char*)&(data._rec_seq),4); data.SwitchEndian(data._rec_seq); is.read((char*)&(data._rec_sub1),1); is.read((char*)&(data._rec_type),1); is.read((char*)&(data._rec_sub2),1); is.read((char*)&(data._rec_sub3),1); is.read((char*)&(data._length),4); data.SwitchEndian(data._length); return is; } RadarSatRecordHeader::RadarSatRecordHeader(const RadarSatRecordHeader& rhs): _rec_seq(rhs._rec_seq), _rec_sub1(rhs._rec_sub1), _rec_type(rhs._rec_type), _rec_sub2(rhs._rec_sub2), _rec_sub3(rhs._rec_sub3) { } RadarSatRecordHeader& RadarSatRecordHeader::operator=(const RadarSatRecordHeader& rhs) { _rec_seq=rhs._rec_seq; _rec_sub1=rhs._rec_sub1; _rec_type=rhs._rec_type; _rec_sub2=rhs._rec_sub2; _rec_sub3=rhs._rec_sub3; return *this; } void RadarSatRecordHeader::SwitchEndian(int& value) { char buffer[4]; char res[4]; memcpy(buffer,&value,4); res[0] = buffer[3]; res[1] = buffer[2]; res[2] = buffer[1]; res[3] = buffer[0]; memcpy(&value,res,4); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/RadarSatRecordHeader.h000066400000000000000000000047061301006202600313270ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RadarSatRecordHeader_h #define RadarSatRecordHeader_h #include #include namespace ossimplugins { /** * @ingroup RadarSat * @brief This class is able to read a record header */ class RadarSatRecordHeader { public: /** * @brief Constructor */ RadarSatRecordHeader(); /** * @brief Destructor */ ~RadarSatRecordHeader(); /** * @brief Copy constructor */ RadarSatRecordHeader(const RadarSatRecordHeader& rhs); /** * @brief Copy operator */ RadarSatRecordHeader& operator=(const RadarSatRecordHeader& rhs); /** * @brief This function writes the RecordHeader in a stream */ friend std::ostream& operator<<(std::ostream& os, const RadarSatRecordHeader& data); /** * @brief This function reads a RecordHeader from a stream */ friend std::istream& operator>>(std::istream& is, RadarSatRecordHeader& data); /** * @brief Record sequence number */ int get_rec_seq() { return _rec_seq; }; /** * @brief First record sub-type code */ unsigned char get_rec_sub1() { return _rec_sub1; }; /** * @brief Record type code */ unsigned char get_rec_type() { return _rec_type; }; /** * @brief Second record sub-type code */ unsigned char get_rec_sub2() { return _rec_sub2; }; /** * @brief Third record sub-type code */ unsigned char get_rec_sub3() { return _rec_sub3; }; /** * @brief Length of this record (in bytes) */ int get_length() { return _length; }; protected: /** * @brief This function switches the LSB value and the MSB value of the parameter */ void SwitchEndian(int& value); /** * @brief Record sequence number */ int _rec_seq; /** * @brief First record sub-type code */ unsigned char _rec_sub1; /** * @brief Record type code */ unsigned char _rec_type; /** * @brief Second record sub-type code */ unsigned char _rec_sub2; /** * @brief Third record sub-type code */ unsigned char _rec_sub3; /** * @brief Length of this record (in bytes) */ int _length; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Trailer/000077500000000000000000000000001301006202600266005ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Trailer/Trailer.cpp000066400000000000000000000077011301006202600307130ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { const int Trailer::RadiometricDataID = 8; const int Trailer::RadiometricCompensationDataID = 9; const int Trailer::AttitudeDataID = 7; const int Trailer::ProcessingParametersID = 6; const int Trailer::DataHistogramProcessedData8ID = 5; const int Trailer::DataHistogramSignalDataID = 4; const int Trailer::DataQualityID = 3; const int Trailer::DataSetSummaryID = 2; const int Trailer::FileDescriptorID = 1; Trailer::Trailer() { } Trailer::~Trailer() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const Trailer& data) { std::map::const_iterator it = data._records.begin(); while(it != data._records.end()) { (*it).second->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, Trailer& data) { TrailerFactory factory; data.ClearRecords(); RadarSatRecordHeader header; bool eof = false; while(!eof) { is>>header; if(is.eof()) { eof = true; } else { RadarSatRecord* record = factory.Instantiate(header.get_rec_seq()); if (record != NULL) { record->Read(is); data._records[header.get_rec_seq()] = record; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length()-12); delete[] buff; } } } return is; } Trailer::Trailer(const Trailer& rhs) { std::map::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } } Trailer& Trailer::operator=(const Trailer& rhs) { ClearRecords(); std::map::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } return *this; } void Trailer::ClearRecords() { std::map::const_iterator it = _records.begin(); while(it != _records.end()) { delete (*it).second; ++it; } _records.clear(); } RadiometricData * Trailer::get_RadiometricData() { return (RadiometricData*)_records[RadiometricDataID]; } RadiometricCompensationData * Trailer::get_RadiometricCompensationData() { return (RadiometricCompensationData*)_records[RadiometricCompensationDataID]; } AttitudeData * Trailer::get_AttitudeData() { return (AttitudeData*)_records[AttitudeDataID]; } ProcessingParameters * Trailer::get_ProcessingParameters() { return (ProcessingParameters*)_records[ProcessingParametersID]; } DataHistogramProcessedData8 * Trailer::get_DataHistogramProcessedData8() { return (DataHistogramProcessedData8*)_records[DataHistogramProcessedData8ID]; } DataHistogramSignalData * Trailer::get_DataHistogramSignalData() { return (DataHistogramSignalData*)_records[DataHistogramSignalDataID]; } DataQuality * Trailer::get_DataQuality() { return (DataQuality*)_records[DataQualityID]; } DataSetSummary * Trailer::get_DataSetSummary() { return (DataSetSummary*)_records[DataSetSummaryID]; } FileDescriptor * Trailer::get_FileDescriptor() { return (FileDescriptor*)_records[FileDescriptorID]; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Trailer/Trailer.h000066400000000000000000000047721301006202600303650ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Trailer_h #define Trailer_h #include #include #include #include #include #include namespace ossimplugins { class RadiometricData; class RadiometricCompensationData; class AttitudeData; class ProcessingParameters; class DataHistogramSignalData; class DataQuality; class DataSetSummary; class FileDescriptor; /** * @ingroup TrailerFile * @brief This class is able to read the trailer file of the RadarSat file structure * @author CS, Mickaël Savinaud * @version 1.0 * @date 25-02-2011 */ class Trailer { public: /** * @brief Constructor */ Trailer(); /** * @brief Destructor */ ~Trailer(); /** * @brief This function writes the Trailer in a stream */ friend std::ostream& operator<<(std::ostream& os, const Trailer& data); /** * @brief This function reads a Trailer from a stream */ friend std::istream& operator>>(std::istream& is, Trailer& data); /** * @brief Copy constructor */ Trailer(const Trailer& rhs); /** * @brief Copy operator */ Trailer& operator=(const Trailer& rhs); /** * @brief Removes all the previous records from the Trailer */ void ClearRecords(); RadiometricData * get_RadiometricData(); RadiometricCompensationData * get_RadiometricCompensationData(); AttitudeData * get_AttitudeData(); ProcessingParameters * get_ProcessingParameters(); DataHistogramProcessedData8 * get_DataHistogramProcessedData8(); DataHistogramSignalData * get_DataHistogramSignalData(); DataQuality * get_DataQuality(); DataSetSummary * get_DataSetSummary(); FileDescriptor * get_FileDescriptor(); protected: std::map _records; static const int RadiometricDataID; static const int RadiometricCompensationDataID; static const int AttitudeDataID; static const int ProcessingParametersID; static const int DataHistogramProcessedData8ID; static const int DataHistogramSignalDataID; static const int DataQualityID; static const int DataSetSummaryID; static const int FileDescriptorID; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Trailer/TrailerFactory.cpp000066400000000000000000000031301301006202600322330ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { TrailerFactory::TrailerFactory() { RegisterRecord(8, new RadiometricData()); RegisterRecord(9, new RadiometricCompensationData()); RegisterRecord(7, new AttitudeData()); RegisterRecord(6, new ProcessingParameters()); RegisterRecord(5, new DataHistogramProcessedData8()); RegisterRecord(4, new DataHistogramSignalData()); RegisterRecord(3, new DataQuality()); RegisterRecord(2, new DataSetSummary()); RegisterRecord(1, new FileDescriptor()); } TrailerFactory::~TrailerFactory() { std::map::iterator i = _availableRecords.begin(); while (i != _availableRecords.end()) { if ( (*i).second ) { delete (*i).second; (*i).second = 0; } ++i; } _availableRecords.clear(); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/Trailer/TrailerFactory.h000066400000000000000000000014001301006202600316760ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef TrailerFactory_h #define TrailerFactory_h #include #include namespace ossimplugins { /** * @ingroup TrailerFile * @brief This class is a factory able to construct Record base classes */ class TrailerFactory : public RadarSatRecordFactory { public: /** * @brief Contstructor */ TrailerFactory(); /** * @brief Destructor */ ~TrailerFactory(); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/000077500000000000000000000000001301006202600271045ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/FilePointerRecord.cpp000066400000000000000000000074161301006202600331770ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "FilePointerRecord.h" namespace ossimplugins { FilePointerRecord::FilePointerRecord() : RadarSatRecord("file_pntr_rec") { } FilePointerRecord::~FilePointerRecord() { } std::ostream& operator<<(std::ostream& os, const FilePointerRecord& data) { os<<"ascii_flag:"<>(std::istream& is, FilePointerRecord& data) { char buf[349]; // 361-12 (size of header) buf[348] = '\0'; is.read(buf, 2); buf[2] = '\0'; data._ascii_flag = buf; is.read(buf, 2); // spare1 is.read(buf, 4); buf[4] = '\0'; data._file_num = atoi(buf); is.read(buf, 16); buf[16] = '\0'; data._file_name = buf; is.read(buf, 28); buf[28] = '\0'; data._file_class = buf; is.read(buf, 4); buf[4] = '\0'; data._file_code = buf; is.read(buf, 28); buf[28] = '\0'; data._data_type = buf; is.read(buf, 4); buf[4] = '\0'; data._data_code = buf; is.read(buf, 8); buf[8] = '\0'; data._nrec = atoi(buf); is.read(buf, 8); buf[8] = '\0'; data._first_len = atoi(buf); is.read(buf, 8); buf[8] = '\0'; data._max_len = atoi(buf); is.read(buf, 12); buf[12] = '\0'; data._len_type = buf; is.read(buf, 4); buf[4] = '\0'; data._len_code = buf; is.read(buf, 2); buf[2] = '\0'; data._first_phyvol = atoi(buf); is.read(buf, 2); buf[2] = '\0'; data._last_phyvol = atoi(buf); is.read(buf, 8); buf[8] = '\0'; data._first_rec = atoi(buf); is.read(buf, 8); buf[8] = '\0'; data._last_rec = atoi(buf); is.read(buf, 100); // spare2 is.read(buf, 100); // spare3 return is; } FilePointerRecord::FilePointerRecord(const FilePointerRecord& rhs): RadarSatRecord(rhs), _ascii_flag(rhs._ascii_flag), _file_num(rhs._file_num), _file_name(rhs._file_name), _file_class(rhs._file_class), _file_code(rhs._file_code), _data_type(rhs._data_type), _data_code(rhs._data_code), _nrec(rhs._nrec), _first_len(rhs._first_len), _max_len(rhs._max_len), _len_type(rhs._len_type), _len_code(rhs._len_code), _first_phyvol(rhs._first_phyvol), _last_phyvol(rhs._last_phyvol), _first_rec(rhs._first_rec), _last_rec(rhs._last_rec) { } FilePointerRecord& FilePointerRecord::operator=(const FilePointerRecord& rhs) { _ascii_flag = rhs._ascii_flag; _file_num = rhs._file_num; _file_name = rhs._file_name; _file_class = rhs._file_class; _file_code = rhs._file_code; _data_type = rhs._data_type; _data_code = rhs._data_code; _nrec = rhs._nrec; _first_len = rhs._first_len; _max_len = rhs._max_len; _len_type = rhs._len_type; _len_code = rhs._len_code; _first_phyvol = rhs._first_phyvol; _last_phyvol = rhs._last_phyvol; _first_rec = rhs._first_rec; _last_rec = rhs._last_rec; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/FilePointerRecord.h000066400000000000000000000116601301006202600326400ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef FilePointerRecord_h #define FilePointerRecord_h #include #include #include namespace ossimplugins { /** * @ingroup SARLeaderFilePointerRecordRecord * @brief This class is able to read the SAR leader file descriptor record of the leader file */ class FilePointerRecord : public RadarSatRecord { public: /** * @brief Constructor */ FilePointerRecord(); /** * @brief Destructor */ virtual ~FilePointerRecord(); /** * @brief This function writes the FilePointerRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const FilePointerRecord& data); /** * @brief This function reads a FilePointerRecord from a stream */ friend std::istream& operator>>(std::istream& is, FilePointerRecord& data); /** * @brief Copy constructor */ FilePointerRecord(const FilePointerRecord& rhs); /** * @brief Copy operator */ FilePointerRecord& operator=(const FilePointerRecord& rhs); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new FilePointerRecord(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new FilePointerRecord(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief ASCII flag */ std::string get_ascii_flag() { return _ascii_flag; }; /** * @brief Referenced file number */ int get_file_num() { return _file_num; }; /** * @brief Referenced file name */ std::string get_file_name() { return _file_name; }; /** * @brief Referenced file class */ std::string get_file_class() { return _file_class; }; /** * @brief Referenced file class code */ std::string get_file_code() { return _file_code; }; /** * @brief Referenced file data type */ std::string get_data_type() { return _data_type; }; /** * @brief Referenced file data type code */ std::string get_data_code() { return _data_code; }; /** * @brief Referenced file record count */ int get_nrec() { return _nrec; }; /** * @brief First record length, bytes */ int get_first_len() { return _first_len; }; /** * @brief Maximum record length, bytes */ int get_max_len() { return _max_len; }; /** * @brief Record length type */ std::string get_len_type() { return _len_type; }; /** * @brief Record length type code */ std::string get_len_code() { return _len_code; }; /** * @brief First physical volume */ int get_first_phyvol() { return _first_phyvol; }; /** * @brief Last physical volume */ int get_last_phyvol() { return _last_phyvol; }; /** * @brief First physical volume record */ int get_first_rec() { return _first_rec; }; /** * @brief Last physical volume record */ int get_last_rec() { return _last_rec; }; protected: /** * @brief ASCII flag */ std::string _ascii_flag; /** * @brief Referenced file number */ int _file_num; /** * @brief Referenced file name */ std::string _file_name; /** * @brief Referenced file class */ std::string _file_class; /** * @brief Referenced file class code */ std::string _file_code; /** * @brief Referenced file data type */ std::string _data_type; /** * @brief Referenced file data type code */ std::string _data_code; /** * @brief Referenced file record count */ int _nrec; /** * @brief First record length, bytes */ int _first_len; /** * @brief Maximum record length, bytes */ int _max_len; /** * @brief Record length type */ std::string _len_type; /** * @brief Record length type code */ std::string _len_code; /** * @brief First physical volume */ int _first_phyvol; /** * @brief Last physical volume */ int _last_phyvol; /** * @brief First physical volume record */ int _first_rec; /** * @brief Last physical volume record */ int _last_rec; private: }; typedef FilePointerRecord SARLeaderFilePointerRecord; typedef FilePointerRecord ImageOptionsFilePointerRecord; typedef FilePointerRecord SARTrailerFilePointerRecord; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/TextRecord.cpp000066400000000000000000000045231301006202600316770ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "TextRecord.h" namespace ossimplugins { TextRecord::TextRecord() : RadarSatRecord("text_rec") { } TextRecord::~TextRecord() { } std::ostream& operator<<(std::ostream& os, const TextRecord& data) { os<<"ascii_flag:"<>(std::istream& is, TextRecord& data) { char buf[349]; // 361-12 buf[348] = '\0'; is.read(buf, 2); buf[2] = '\0'; data._ascii_flag = buf; is.read(buf, 2); buf[2] = '\0'; data._cont_flag = buf; is.read(buf, 40); buf[40] = '\0'; data._product_type = buf; is.read(buf, 60); buf[60] = '\0'; data._product_create = buf; is.read(buf, 40); buf[40] = '\0'; data._phyvol_id = buf; is.read(buf, 40); buf[40] = '\0'; data._scene_id = buf; is.read(buf, 40); buf[40] = '\0'; data._scene_loc = buf; is.read(buf, 20); buf[20] = '\0'; data._copyright_info = buf; is.read(buf, 104); // spare1 return is; } TextRecord::TextRecord(const TextRecord& rhs): RadarSatRecord(rhs), _ascii_flag(rhs._ascii_flag), _cont_flag(rhs._cont_flag), _product_type(rhs._product_type), _product_create(rhs._product_create), _phyvol_id(rhs._phyvol_id), _scene_id(rhs._scene_id), _scene_loc(rhs._scene_loc), _copyright_info(rhs._copyright_info) { } TextRecord& TextRecord::operator=(const TextRecord& rhs) { _ascii_flag = rhs._ascii_flag; _cont_flag = rhs._cont_flag; _product_type = rhs._product_type; _product_create = rhs._product_create; _phyvol_id = rhs._phyvol_id; _scene_id = rhs._scene_id; _scene_loc = rhs._scene_loc; _copyright_info = rhs._copyright_info; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/TextRecord.h000066400000000000000000000063121301006202600313420ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef TextRecord_h #define TextRecord_h #include #include #include namespace ossimplugins { /** * @ingroup TextRecordRecord * @brief This class is able to read the Text record of the volume directory file */ class TextRecord : public RadarSatRecord { public: /** * @brief Constructor */ TextRecord(); /** * @brief Destructor */ virtual ~TextRecord(); /** * @brief This function writes the TextRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const TextRecord& data); /** * @brief This function reads a TextRecord from a stream */ friend std::istream& operator>>(std::istream& is, TextRecord& data); /** * @brief Copy constructor */ TextRecord(const TextRecord& rhs); /** * @brief Copy operator */ TextRecord& operator=(const TextRecord& rhs); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new TextRecord(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new TextRecord(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief ASCII flag */ std::string get_ascii_flag() { return _ascii_flag; }; /** * @brief Continuation flag */ std::string get_cont_flag() { return _cont_flag; }; /** * @brief Product type specifier */ std::string get_product_type() { return _product_type; }; /** * @brief Product creation info */ std::string get_product_create() { return _product_create; }; /** * @brief Volume Description Record */ std::string get_phyvol_id() { return _phyvol_id; }; /** * @brief Scene identifier */ std::string get_scene_id() { return _scene_id; }; /** * @brief Scene location */ std::string get_scene_loc() { return _scene_loc; }; /** * @brief Copyright */ std::string get_copyright_info() { return _copyright_info; }; protected: /** * @brief ASCII flag */ std::string _ascii_flag; /** * @brief Continuation flag */ std::string _cont_flag; /** * @brief Product type specifier */ std::string _product_type; /** * @brief Product creation info */ std::string _product_create ; /** * @brief Volume Description Record */ std::string _phyvol_id; /** * @brief Scene identifier */ std::string _scene_id; /** * @brief Scene location */ std::string _scene_loc; /** * @brief Copyright */ std::string _copyright_info; private: }; } #endif VolumeDescriptorRecord.cpp000066400000000000000000000126051301006202600342020ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "VolumeDescriptorRecord.h" namespace ossimplugins { VolumeDescriptorRecord::VolumeDescriptorRecord() : RadarSatRecord("vol_desc_rec") { } VolumeDescriptorRecord::~VolumeDescriptorRecord() { } std::ostream& operator<<(std::ostream& os, const VolumeDescriptorRecord& data) { os<<"ascii_flag:"<>(std::istream& is, VolumeDescriptorRecord& data) { char buf[349]; // 361-12 buf[348] = '\0'; is.read(buf,2); buf[2] = '\0'; data._ascii_flag = buf; is.read(buf,2); // spare1 is.read(buf,12); buf[12] = '\0'; data._format_doc = buf; is.read(buf,2); buf[2] = '\0'; data._format_ver = buf; is.read(buf,2); buf[2] = '\0'; data._format_rev = buf; is.read(buf,12); buf[12] = '\0'; data._software_id = buf; is.read(buf,16); buf[16] = '\0'; data._phyvol_id = buf; is.read(buf,16); buf[16] = '\0'; data._logvol_id = buf; is.read(buf,16); buf[16] = '\0'; data._volset_id = buf; is.read(buf,2); buf[2] = '\0'; data._phyvol_cnt = atoi(buf); is.read(buf,2); buf[2] = '\0'; data._first_phyvol = atoi(buf); is.read(buf,2); buf[2] = '\0'; data._last_phyvol = atoi(buf); is.read(buf,2); buf[2] = '\0'; data._curr_phyvol = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._first_file = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._volset_log = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._phyvol_log = atoi(buf); is.read(buf,8); buf[8] = '\0'; data._logvol_date = buf; is.read(buf,8); buf[8] = '\0'; data._logvol_time = buf; is.read(buf,12); buf[12] = '\0'; data._logvol_country = buf; is.read(buf,8); buf[8] = '\0'; data._logvol_agency = buf; is.read(buf,12); buf[12] = '\0'; data._logvol_facility = buf; is.read(buf,4); buf[4] = '\0'; data._n_filepoint = atoi(buf); is.read(buf,4); buf[4] = '\0'; data._n_voldir = atoi(buf); is.read(buf,92); // spare2 is.read(buf,8); buf[8] = '\0'; data._product_id = buf; is.read(buf,92); // spare3 return is; } VolumeDescriptorRecord::VolumeDescriptorRecord(const VolumeDescriptorRecord& rhs): RadarSatRecord(rhs), _ascii_flag(rhs._ascii_flag), _format_doc(rhs._format_doc), _format_ver(rhs._format_ver), _format_rev(rhs._format_rev), _software_id(rhs._software_id), _phyvol_id(rhs._phyvol_id), _logvol_id(rhs._logvol_id), _volset_id(rhs._volset_id), _phyvol_cnt(rhs._phyvol_cnt), _first_phyvol(rhs._first_phyvol), _last_phyvol(rhs._last_phyvol), _curr_phyvol(rhs._curr_phyvol), _first_file(rhs._first_file), _volset_log(rhs._volset_log), _logvol_date(rhs._logvol_date), _logvol_time(rhs._logvol_time), _logvol_country(rhs._logvol_country), _logvol_agency(rhs._logvol_agency), _logvol_facility(rhs._logvol_facility), _n_filepoint(rhs._n_filepoint), _n_voldir(rhs._n_voldir), _product_id(rhs._product_id) { } VolumeDescriptorRecord& VolumeDescriptorRecord::operator=(const VolumeDescriptorRecord& rhs) { _ascii_flag = rhs._ascii_flag; _format_doc = rhs._format_doc; _format_ver = rhs._format_ver; _format_rev = rhs._format_rev; _software_id = rhs._software_id; _phyvol_id = rhs._phyvol_id; _logvol_id = rhs._logvol_id; _volset_id = rhs._volset_id; _phyvol_cnt = rhs._phyvol_cnt; _first_phyvol = rhs._first_phyvol; _last_phyvol = rhs._last_phyvol; _curr_phyvol = rhs._curr_phyvol; _first_file = rhs._first_file; _volset_log = rhs._volset_log; _logvol_date = rhs._logvol_date; _logvol_time = rhs._logvol_time; _logvol_country = rhs._logvol_country; _logvol_agency = rhs._logvol_agency; _logvol_facility = rhs._logvol_facility; _n_filepoint = rhs._n_filepoint; _n_voldir = rhs._n_voldir; _product_id = rhs._product_id; return *this; } } VolumeDescriptorRecord.h000066400000000000000000000143771301006202600336570ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef VolumeDescriptorRecord_h #define VolumeDescriptorRecord_h #include #include #include namespace ossimplugins { /** * @ingroup SARLeaderVolumeDescriptorRecordRecord * @brief This class is able to read the SAR leader file descriptor record of the leader file */ class VolumeDescriptorRecord : public RadarSatRecord { public: /** * @brief Constructor */ VolumeDescriptorRecord(); /** * @brief Destructor */ virtual ~VolumeDescriptorRecord(); /** * @brief This function writes the VolumeDescriptorRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const VolumeDescriptorRecord& data); /** * @brief This function reads a VolumeDescriptorRecord from a stream */ friend std::istream& operator>>(std::istream& is, VolumeDescriptorRecord& data); /** * @brief Copy constructor */ VolumeDescriptorRecord(const VolumeDescriptorRecord& rhs); /** * @brief Copy operator */ VolumeDescriptorRecord& operator=(const VolumeDescriptorRecord& rhs); /** * @brief This function is able to create a new instance of the class */ RadarSatRecord* Instantiate() { return new VolumeDescriptorRecord(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ RadarSatRecord* Clone() { return new VolumeDescriptorRecord(*this); }; /** * @brief Reads the class data from a stream */ void Read(std::istream& is) { is>>*this; }; /** * @brief Writes the class to a stream */ void Write(std::ostream& os) { os<<*this; }; /** * @brief ASCII flag */ std::string get_ascii_flag() { return _ascii_flag; }; /** * @brief Format control documentation */ std::string get_format_doc() { return _format_doc; }; /** * @brief Format doc version */ std::string get_format_ver() { return _format_ver; }; /** * @brief Format doc revision */ std::string getget_format_rev() { return _format_rev; }; /** * @brief Software identifier */ std::string get_software_id() { return _software_id; }; /** * @brief Physical volume identifier */ std::string get_phyvol_id() { return _phyvol_id; }; /** * @brief Logical volume identifier */ std::string get_logvol_id() { return _logvol_id; }; /** * @brief Volume set identifier */ std::string get_volset_id() { return _volset_id; }; /** * @brief Total physical volume count */ int get_phyvol_cnt() { return _phyvol_cnt; }; /** * @brief Physical volume of first tape */ int get_first_phyvol() { return _first_phyvol; }; /** * @brief Physical volume of last tape */ int get_last_phyvol() { return _last_phyvol; }; /** * @brief Physical volume of current tape */ int get_curr_phyvol() { return _curr_phyvol; }; /** * @brief First file number in physical volume */ int get_first_file() { return _first_file; }; /** * @brief Logical volume within set */ int get_volset_log() { return _volset_log; }; /** * @brief Logical volume within phyvol */ int get_phyvol_log() { return _phyvol_log; }; /** * @brief Logvol creation date */ std::string get_logvol_date() { return _logvol_date; }; /** * @brief Logvol creation time */ std::string get_logvol_time() { return _logvol_time; }; /** * @brief Logvol generation country */ std::string get_logvol_country() { return _logvol_country; }; /** * @brief Logvol generation agency */ std::string get_logvol_agency() { return _logvol_agency; }; /** * @brief Logvol generation facility */ std::string get_logvol_facility() { return _logvol_facility; }; /** * @brief Number of file pointer records */ int get_n_filepoint() { return _n_filepoint; }; /** * @brief Number of records in volume directory file */ int get_n_voldir() { return _n_voldir; }; /** * @brief Product identifier */ std::string get_product_id() { return _product_id; }; protected: /** * @brief ASCII flag */ std::string _ascii_flag; /** * @brief Format control documentation */ std::string _format_doc; /** * @brief Format doc version */ std::string _format_ver; /** * @brief Format doc revision */ std::string _format_rev; /** * @brief Software identifier */ std::string _software_id; /** * @brief Physical volume identifier */ std::string _phyvol_id; /** * @brief Logical volume identifier */ std::string _logvol_id; /** * @brief Volume set identifier */ std::string _volset_id; /** * @brief Total physical volume count */ int _phyvol_cnt; /** * @brief Physical volume of first tape */ int _first_phyvol; /** * @brief Physical volume of last tape */ int _last_phyvol; /** * @brief Physical volume of current tape */ int _curr_phyvol; /** * @brief First file number in physical volume */ int _first_file; /** * @brief Logical volume within set */ int _volset_log; /** * @brief Logical volume within phyvol */ int _phyvol_log; /** * @brief Logvol creation date */ std::string _logvol_date; /** * @brief Logvol creation time */ std::string _logvol_time; /** * @brief Logvol generation country */ std::string _logvol_country; /** * @brief Logvol generation agency */ std::string _logvol_agency; /** * @brief Logvol generation facility */ std::string _logvol_facility; /** * @brief Number of file pointer records */ int _n_filepoint; /** * @brief Number of records in volume directory file */ int _n_voldir; /** * @brief Product identifier */ std::string _product_id; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/VolumeDir.cpp000066400000000000000000000060471301006202600315250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace ossimplugins { const int VolumeDir::TextRecordID = 1; const int VolumeDir::SARLeaderFilePointerRecordID = 2; const int VolumeDir::ImageOptionsFilePointerRecordID = 3; const int VolumeDir::SARTrailerFilePointerRecordID = 4; const int VolumeDir::VolumeDescriptorRecordID = 5; VolumeDir::VolumeDir() { } VolumeDir::~VolumeDir() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const VolumeDir& data) { std::map::const_iterator it = data._records.begin(); while(it != data._records.end()) { (*it).second->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, VolumeDir& data) { VolumeDirFactory factory; data.ClearRecords(); RadarSatRecordHeader header; bool eof = false; while(!eof) { is>>header; if(is.eof()) { eof = true; } else { RadarSatRecord* record = factory.Instantiate(header.get_rec_seq()); if (record != NULL) { record->Read(is); data._records[header.get_rec_seq()] = record; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length()-12); delete[] buff; } } } return is; } VolumeDir::VolumeDir(const VolumeDir& rhs) { std::map::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } } VolumeDir& VolumeDir::operator=(const VolumeDir& rhs) { ClearRecords(); std::map::const_iterator it = rhs._records.begin(); while(it != rhs._records.end()) { _records[(*it).first] = (*it).second->Clone(); ++it; } return *this; } void VolumeDir::ClearRecords() { std::map::const_iterator it = _records.begin(); while(it != _records.end()) { delete (*it).second; ++it; } _records.clear(); } SARLeaderFilePointerRecord * VolumeDir::get_SARLeaderFilePointerRecord() { return (SARLeaderFilePointerRecord*)_records[SARLeaderFilePointerRecordID]; } ImageOptionsFilePointerRecord * VolumeDir::get_ImageOptionsFilePointerRecord() { return (ImageOptionsFilePointerRecord*)_records[ImageOptionsFilePointerRecordID]; } SARTrailerFilePointerRecord * VolumeDir::get_SARTrailerFilePointerRecord() { return (SARTrailerFilePointerRecord*)_records[SARTrailerFilePointerRecordID]; } TextRecord * VolumeDir::get_TextRecord() { return (TextRecord*)_records[TextRecordID]; } VolumeDescriptorRecord * VolumeDir::get_VolumeDescriptorRecord() { return (VolumeDescriptorRecord*)_records[VolumeDescriptorRecordID]; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/VolumeDir.h000066400000000000000000000041071301006202600311650ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef VolumeDir_h #define VolumeDir_h #include #include #include #include #include namespace ossimplugins { class FilePointerRecord; class TextRecord; class VolumeDescriptorRecord; /** * @ingroup VolumeDirFile * @brief This class is able to read the volume directory file of the RadarSat file structure * @author CS, Mickaël Savinaud * @version 1.0 * @date 25-02-2011 */ class VolumeDir { public: /** * @brief Constructor */ VolumeDir(); /** * @brief Destructor */ ~VolumeDir(); /** * @brief This function writes the VolumeDir in a stream */ friend std::ostream& operator<<(std::ostream& os, const VolumeDir& data); /** * @brief This function reads a VolumeDir from a stream */ friend std::istream& operator>>(std::istream& is, VolumeDir& data); /** * @brief Copy constructor */ VolumeDir(const VolumeDir& rhs); /** * @brief Copy operator */ VolumeDir& operator=(const VolumeDir& rhs); /** * @brief Removes all the previous records from the VolumeDir */ void ClearRecords(); VolumeDescriptorRecord * get_VolumeDescriptorRecord(); SARLeaderFilePointerRecord * get_SARLeaderFilePointerRecord(); ImageOptionsFilePointerRecord * get_ImageOptionsFilePointerRecord(); SARTrailerFilePointerRecord * get_SARTrailerFilePointerRecord(); TextRecord * get_TextRecord(); protected: std::map _records; static const int VolumeDescriptorRecordID; static const int SARLeaderFilePointerRecordID; static const int ImageOptionsFilePointerRecordID; static const int SARTrailerFilePointerRecordID; static const int TextRecordID; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/VolumeDirFactory.cpp000066400000000000000000000021641301006202600330510ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include namespace ossimplugins { VolumeDirFactory::VolumeDirFactory() { RegisterRecord(1, new VolumeDescriptorRecord()); RegisterRecord(2, new SARLeaderFilePointerRecord()); RegisterRecord(3, new ImageOptionsFilePointerRecord()); RegisterRecord(4, new SARTrailerFilePointerRecord()); RegisterRecord(5, new TextRecord()); } VolumeDirFactory::~VolumeDirFactory() { std::map::iterator i = _availableRecords.begin(); while (i != _availableRecords.end()) { if ( (*i).second ) { delete (*i).second; (*i).second = 0; } ++i; } _availableRecords.clear(); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/RadarSat/VolumeDir/VolumeDirFactory.h000066400000000000000000000014141301006202600325130ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef VolumeDirFactory_h #define VolumeDirFactory_h #include #include namespace ossimplugins { /** * @ingroup VolumeDirFile * @brief This class is a factory able to construct Record base classes */ class VolumeDirFactory : public RadarSatRecordFactory { public: /** * @brief Contstructor */ VolumeDirFactory(); /** * @brief Destructor */ ~VolumeDirFactory(); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/000077500000000000000000000000001301006202600247745ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarDataSetSummary.cpp000066400000000000000000000466251301006202600315400ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarDataSetSummary.h" namespace ossimplugins { ErsSarDataSetSummary::ErsSarDataSetSummary() : ErsSarRecord("dataset_sum_rec") { } ErsSarDataSetSummary::~ErsSarDataSetSummary() { } std::ostream& operator<<(std::ostream& os, const ErsSarDataSetSummary& data) { os << "seq_num:" << data._seq_num << std::endl; os << "sar_chn:" << data._sar_chn << std::endl; os << "scene_id:" << data._scene_id.c_str() << std::endl; os << "scene_des:" << data._scene_des.c_str() << std::endl; os << "inp_sctim:" << data._inp_sctim.c_str() << std::endl; os << "asc_des:" << data._asc_des.c_str() << std::endl; os << "pro_lat:" << data._pro_lat << std::endl; os << "pro_long:" << data._pro_long << std::endl; os << "pro_head:" << data._pro_head << std::endl; os << "ellip_des:" << data._ellip_des.c_str() << std::endl; os << "ellip_maj:" << data._ellip_maj << std::endl; os << "ellip_min:" << data._ellip_min << std::endl; os << "earth_mass:" << data._earth_mass << std::endl; os << "grav_const:" << data._grav_const << std::endl; os << "ellip_j[0]:" << data._ellip_j[0] << std::endl; os << "ellip_j[1]:" << data._ellip_j[1] << std::endl; os << "ellip_j[2]:" << data._ellip_j[2] << std::endl; os << "terrain_h:" << data._terrain_h << std::endl; os << "sc_lin:" << data._sc_lin << std::endl; os << "sc_pix:" << data._sc_pix << std::endl; os << "scene_len:" << data._scene_len << std::endl; os << "scene_wid:" << data._scene_wid << std::endl; os << "nchn:" << data._nchn << std::endl; os << "mission_id:" << data._mission_id.c_str() << std::endl; os << "sensor_id:" << data._sensor_id.c_str() << std::endl; os << "orbit_num:" << data._orbit_num.c_str() << std::endl; os << "plat_lat:" << data._plat_lat << std::endl; os << "plat_long:" << data._plat_long << std::endl; os << "plat_head:" << data._plat_head << std::endl; os << "clock_ang:" << data._clock_ang << std::endl; os << "incident_ang:" << data._incident_ang << std::endl; os << "wave_length:" << data._wave_length << std::endl; os << "motion_comp:" << data._motion_comp.c_str() << std::endl; os << "pulse_code:" << data._pulse_code.c_str() << std::endl; for (int i = 0; i < 5; i++) { os << "ampl_coef[" << i << "]:" << data._ampl_coef[i] << std::endl; } for (int i = 0; i < 5; i++) { os << "phas_coef[" << i << "]:" << data._phas_coef[i] << std::endl; } os << "chirp_ext_ind:" << data._chirp_ext_ind << std::endl; os << "fr:" << data._fr << std::endl; os << "rng_gate:" << data._rng_gate << std::endl; os << "rng_length:" << data._rng_length << std::endl; os << "baseband_f:" << data._baseband_f.c_str() << std::endl; os << "rngcmp_f:" << data._rngcmp_f.c_str() << std::endl; os << "gn_polar:" << data._gn_polar << std::endl; os << "gn_cross:" << data._gn_cross << std::endl; os << "chn_bits:" << data._chn_bits << std::endl; os << "quant_desc:" << data._quant_desc.c_str() << std::endl; os << "i_bias:" << data._i_bias << std::endl; os << "q_bias:" << data._q_bias << std::endl; os << "iq_ratio:" << data._iq_ratio << std::endl; os << "mech_sight:" << data._mech_sight << std::endl; os << "fa:" << data._fa << std::endl; os << "sat_bintim:" << data._sat_bintim.c_str() << std::endl; os << "sat_clktim:" << data._sat_clktim.c_str() << std::endl; os << "sat_clkinc:" << data._sat_clkinc.c_str() << std::endl; os << "fac_id:" << data._fac_id.c_str() << std::endl; os << "sys_id:" << data._sys_id.c_str() << std::endl; os << "ver_id:" << data._ver_id.c_str() << std::endl; os << "prod_type:" << data._prod_type.c_str() << std::endl; os << "algor_id:" << data._algor_id.c_str() << std::endl; os << "n_azilok:" << data._n_azilok << std::endl; os << "n_rnglok:" << data._n_rnglok << std::endl; os << "bnd_azilok:" << data._bnd_azilok << std::endl; os << "bnd_rnglok:" << data._bnd_rnglok << std::endl; os << "bnd_azi:" << data._bnd_azi << std::endl; os << "bnd_rng:" << data._bnd_rng << std::endl; os << "azi_weight:" << data._azi_weight.c_str() << std::endl; os << "rng_weight:" << data._rng_weight.c_str() << std::endl; os << "data_inpsrc:" << data._data_inpsrc.c_str() << std::endl; os << "rng_res:" << data._rng_res << std::endl; os << "azi_res:" << data._azi_res << std::endl; os << "alt_dopcen[0]:" << data._alt_dopcen[0] << std::endl; os << "alt_dopcen[1]:" << data._alt_dopcen[1] << std::endl; os << "alt_dopcen[2]:" << data._alt_dopcen[2] << std::endl; os << "crt_dopcen[0]:" << data._crt_dopcen[0] << std::endl; os << "crt_dopcen[1]:" << data._crt_dopcen[1] << std::endl; os << "crt_dopcen[2]:" << data._crt_dopcen[2] << std::endl; os << "time_dir_pix:" << data._time_dir_pix.c_str() << std::endl; os << "time_dir_lin:" << data._time_dir_lin.c_str() << std::endl; os << "alt_rate[0]:" << data._alt_rate[0] << std::endl; os << "alt_rate[1]:" << data._alt_rate[1] << std::endl; os << "alt_rate[2]:" << data._alt_rate[2] << std::endl; os << "crt_rate[0]:" << data._crt_rate[0] << std::endl; os << "crt_rate[1]:" << data._crt_rate[1] << std::endl; os << "crt_rate[2]:" << data._crt_rate[2] << std::endl; os << "clutter_lock:" << data._line_cont.c_str() << std::endl; os << "clutter_lock:" << data._clutter_lock.c_str() << std::endl; os << "auto_focus:" << data._auto_focus.c_str() << std::endl; os << "line_spacing:" << data._line_spacing << std::endl; os << "pix_spacing:" << data._pix_spacing << std::endl; os << "rngcmp_desg:" << data._rngcmp_desg.c_str() << std::endl; os << "zero_dop_range_time_f_pixel:" << data._zero_dop_range_time_f_pixel << std::endl; os << "zero_dop_range_time_c_pixel:" << data._zero_dop_range_time_c_pixel << std::endl; os << "zero_dop_range_time_l_pixel:" << data._zero_dop_range_time_l_pixel << std::endl; os << "zero_dop_az_time_f_pixel :" << data._zero_dop_az_time_f_pixel.c_str() << std::endl; os << " zero_dop_az_time_c_pixel:" << data._zero_dop_az_time_c_pixel.c_str() << std::endl; os << " zero_dop_az_time_l_pixel:" << data._zero_dop_az_time_l_pixel.c_str() << std::endl; return os; } std::istream& operator>>(std::istream& is, ErsSarDataSetSummary& data) { char buf16[17]; buf16[16] = '\0'; char buf32[33]; buf32[32] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf4[5]; buf4[4] = '\0'; is.read(buf4, 4); data._seq_num = atoi(buf4); is.read(buf4, 4); data._sar_chn = atoi(buf4); is.read(buf16, 16); data._scene_id = buf16; is.read(buf32, 32); data._scene_des = buf32; is.read(buf32, 32); data._inp_sctim = buf32; is.read(buf16, 16); data._asc_des = buf16; is.read(buf16, 16); data._pro_lat = atof(buf16); is.read(buf16, 16); data._pro_long = atof(buf16); is.read(buf16, 16); data._pro_head = atof(buf16); is.read(buf16, 16); data._ellip_des = buf16; is.read(buf16, 16); data._ellip_maj = atof(buf16); is.read(buf16, 16); data._ellip_min = atof(buf16); is.read(buf16, 16); data._earth_mass = atof(buf16); is.read(buf16, 16); data._grav_const = atof(buf16); is.read(buf16, 16); data._ellip_j[0] = atof(buf16); is.read(buf16, 16); data._ellip_j[1] = atof(buf16); is.read(buf16, 16); data._ellip_j[2] = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._terrain_h = atof(buf16); is.read(buf8, 8); data._sc_lin = atoi(buf8); is.read(buf8, 8); data._sc_pix = atoi(buf8); is.read(buf16, 16); data._scene_len = atof(buf16); is.read(buf16, 16); data._scene_wid = atof(buf16); is.read(buf16, 16); is.read(buf4, 4); data._nchn = atoi(buf4); is.read(buf4, 4); is.read(buf16, 16); data._mission_id = buf16; is.read(buf32, 32); data._sensor_id = buf32; is.read(buf8, 8); data._orbit_num = buf8; is.read(buf8, 8); data._plat_lat = atof(buf8); is.read(buf8, 8); data._plat_long = atof(buf8); is.read(buf8, 8); data._plat_head = atof(buf8); is.read(buf8, 8); data._clock_ang = atof(buf8); is.read(buf8, 8); data._incident_ang = atof(buf8); is.read(buf8, 8); is.read(buf16, 16); data._wave_length = atof(buf16); is.read(buf8, 2); buf8[2] = '\0'; data._motion_comp = buf8; is.read(buf16, 16); data._pulse_code = buf16; for (int i = 0; i < 5; i++) { is.read(buf16, 16); data._ampl_coef[i] = atof(buf16); } for (int i = 0; i < 5; i++) { is.read(buf16, 16); data._phas_coef[i] = atof(buf16); } is.read(buf8, 8); data._chirp_ext_ind = atoi(buf8); is.read(buf8, 8); is.read(buf16, 16); data._fr = atof(buf16); is.read(buf16, 16); data._rng_gate = atof(buf16); is.read(buf16, 16); data._rng_length = atof(buf16); is.read(buf8, 4); buf8[4] = '\0'; data._baseband_f = buf8; is.read(buf8, 4); buf8[4] = '\0'; data._rngcmp_f = buf8; is.read(buf16, 16); data._gn_polar = atof(buf16); is.read(buf16, 16); data._gn_cross = atof(buf16); is.read(buf8, 8); data._chn_bits = atoi(buf8); is.read(buf16, 12); buf16[12] = '\0'; data._quant_desc = buf16; is.read(buf16, 16); data._i_bias = atof(buf16); is.read(buf16, 16); data._q_bias = atof(buf16); is.read(buf16, 16); data._iq_ratio = atof(buf16); is.read(buf32, 32); is.read(buf16, 16); is.read(buf16, 16); data._mech_sight = atof(buf16); is.read(buf4, 4); is.read(buf16, 16); data._fa = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); is.read(buf16, 16); data._sat_bintim = buf16; is.read(buf32, 32); data._sat_clktim = buf32; is.read(buf8, 8); data._sat_clkinc = buf8; is.read(buf8, 8); is.read(buf16, 16); data._fac_id = buf16; is.read(buf8, 8); data._sys_id = buf8; is.read(buf8, 8); data._ver_id = buf8; is.read(buf32, 32); is.read(buf32, 32); data._prod_type = buf32; is.read(buf32, 32); data._algor_id = buf32; is.read(buf16, 16); data._n_azilok = atof(buf16); is.read(buf16, 16); data._n_rnglok = atof(buf16); is.read(buf16, 16); data._bnd_azilok = atof(buf16); is.read(buf16, 16); data._bnd_rnglok = atof(buf16); is.read(buf16, 16); data._bnd_azi = atof(buf16); is.read(buf16, 16); data._bnd_rng = atof(buf16); is.read(buf32, 32); data._azi_weight = buf32; is.read(buf32, 32); data._rng_weight = buf32; is.read(buf16, 16); data._data_inpsrc = buf16; is.read(buf16, 16); data._rng_res = atof(buf16); is.read(buf16, 16); data._azi_res = atof(buf16); is.read(buf32, 32); is.read(buf16, 16); data._alt_dopcen[0] = atof(buf16); is.read(buf16, 16); data._alt_dopcen[1] = atof(buf16); is.read(buf16, 16); data._alt_dopcen[2] = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._crt_dopcen[0] = atof(buf16); is.read(buf16, 16); data._crt_dopcen[1] = atof(buf16); is.read(buf16, 16); data._crt_dopcen[2] = atof(buf16); is.read(buf8, 8); data._time_dir_pix = buf8; is.read(buf8, 8); data._time_dir_lin = buf8; is.read(buf16, 16); data._alt_rate[0] = atof(buf16); is.read(buf16, 16); data._alt_rate[1] = atof(buf16); is.read(buf16, 16); data._alt_rate[2] = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._crt_rate[0] = atof(buf16); is.read(buf16, 16); data._crt_rate[1] = atof(buf16); is.read(buf16, 16); data._crt_rate[2] = atof(buf16); is.read(buf16, 16); is.read(buf8, 8); data._line_cont = buf8; is.read(buf4, 4); data._clutter_lock = buf4; is.read(buf4, 4); data._auto_focus = buf4; is.read(buf16, 16); data._line_spacing = atof(buf16); is.read(buf16, 16); data._pix_spacing = atof(buf16); is.read(buf16, 16); data._rngcmp_desg = buf16; is.read(buf32, 32); is.read(buf16, 16); data._zero_dop_range_time_f_pixel = atof(buf16); is.read(buf16, 16); data._zero_dop_range_time_c_pixel = atof(buf16); is.read(buf16, 16); data._zero_dop_range_time_l_pixel = atof(buf16); is.read(buf32, 24); buf32[24] = '\0'; data._zero_dop_az_time_f_pixel = buf32; is.read(buf32, 24); buf32[24] = '\0'; data._zero_dop_az_time_c_pixel = buf32; is.read(buf32, 24); buf32[24] = '\0'; data._zero_dop_az_time_l_pixel = buf32; return is; } ErsSarDataSetSummary::ErsSarDataSetSummary(const ErsSarDataSetSummary& rhs): ErsSarRecord(rhs), _seq_num(rhs._seq_num), _sar_chn(rhs._sar_chn), _scene_id(rhs._scene_id), _scene_des(rhs._scene_des), _inp_sctim(rhs._inp_sctim), _asc_des(rhs._asc_des), _pro_lat(rhs._pro_lat), _pro_long(rhs._pro_long), _pro_head(rhs._pro_head), _ellip_des(rhs._ellip_des), _ellip_maj(rhs._ellip_maj), _ellip_min(rhs._ellip_min), _earth_mass(rhs._earth_mass), _grav_const(rhs._grav_const), _terrain_h(rhs._terrain_h), _sc_lin(rhs._sc_lin), _sc_pix(rhs._sc_pix), _scene_len(rhs._scene_len), _scene_wid(rhs._scene_wid), _nchn(rhs._nchn), _mission_id(rhs._mission_id), _sensor_id(rhs._sensor_id), _orbit_num(rhs._orbit_num), _plat_lat(rhs._plat_lat), _plat_long(rhs._plat_long), _plat_head(rhs._plat_head), _clock_ang(rhs._clock_ang), _incident_ang(rhs._incident_ang), _wave_length(rhs._wave_length), _motion_comp(rhs._motion_comp), _pulse_code(rhs._pulse_code), _chirp_ext_ind(rhs._chirp_ext_ind), _fr(rhs._fr), _rng_gate(rhs._rng_gate), _rng_length(rhs._rng_length), _baseband_f(rhs._baseband_f), _rngcmp_f(rhs._rngcmp_f), _gn_polar(rhs._gn_polar), _gn_cross(rhs._gn_cross), _chn_bits(rhs._chn_bits), _quant_desc(rhs._quant_desc), _i_bias(rhs._i_bias), _q_bias(rhs._q_bias), _iq_ratio(rhs._iq_ratio), _mech_sight(rhs._mech_sight), _fa(rhs._fa), _sat_bintim(rhs._sat_bintim), _sat_clktim(rhs._sat_clktim), _sat_clkinc(rhs._sat_clkinc), _fac_id(rhs._fac_id), _sys_id(rhs._sys_id), _ver_id(rhs._ver_id), _prod_type(rhs._prod_type), _algor_id(rhs._algor_id), _n_azilok(rhs._n_azilok), _n_rnglok(rhs._n_rnglok), _bnd_azilok(rhs._bnd_azilok), _bnd_rnglok(rhs._bnd_rnglok), _bnd_azi(rhs._bnd_azi), _bnd_rng(rhs._bnd_rng), _azi_weight(rhs._azi_weight), _rng_weight(rhs._rng_weight), _data_inpsrc(rhs._data_inpsrc), _rng_res(rhs._rng_res), _azi_res(rhs._azi_res), _time_dir_pix(rhs._time_dir_pix), _time_dir_lin(rhs._time_dir_lin), _line_cont(rhs._line_cont), _clutter_lock(rhs._clutter_lock), _auto_focus(rhs._auto_focus), _line_spacing(rhs._line_spacing), _pix_spacing(rhs._pix_spacing), _rngcmp_desg(rhs._rngcmp_desg), _zero_dop_range_time_f_pixel(rhs._zero_dop_range_time_f_pixel), _zero_dop_range_time_c_pixel(rhs._zero_dop_range_time_c_pixel), _zero_dop_range_time_l_pixel(rhs._zero_dop_range_time_l_pixel), _zero_dop_az_time_f_pixel(rhs._zero_dop_az_time_f_pixel), _zero_dop_az_time_c_pixel(rhs._zero_dop_az_time_c_pixel), _zero_dop_az_time_l_pixel(rhs._zero_dop_az_time_l_pixel) { _ellip_j[0] = rhs._ellip_j[0]; _ellip_j[1] = rhs._ellip_j[1]; _ellip_j[2] = rhs._ellip_j[2]; _ampl_coef[0] = rhs._ampl_coef[0]; _ampl_coef[1] = rhs._ampl_coef[1]; _ampl_coef[2] = rhs._ampl_coef[2]; _ampl_coef[3] = rhs._ampl_coef[3]; _ampl_coef[4] = rhs._ampl_coef[4]; _phas_coef[0] = rhs._phas_coef[0]; _phas_coef[1] = rhs._phas_coef[1]; _phas_coef[2] = rhs._phas_coef[2]; _phas_coef[3] = rhs._phas_coef[3]; _phas_coef[4] = rhs._phas_coef[4]; _alt_dopcen[0] = rhs._alt_dopcen[0]; _alt_dopcen[1] = rhs._alt_dopcen[1]; _alt_dopcen[2] = rhs._alt_dopcen[2]; _crt_dopcen[0] = rhs._crt_dopcen[0]; _crt_dopcen[1] = rhs._crt_dopcen[1]; _crt_dopcen[2] = rhs._crt_dopcen[2]; _alt_rate[0] = rhs._alt_rate[0]; _alt_rate[1] = rhs._alt_rate[1]; _alt_rate[2] = rhs._alt_rate[2]; _crt_rate[0] = rhs._crt_rate[0]; _crt_rate[1] = rhs._crt_rate[1]; _crt_rate[2] = rhs._crt_rate[2]; } ErsSarDataSetSummary& ErsSarDataSetSummary::operator=(const ErsSarDataSetSummary& rhs) { _seq_num = rhs._seq_num; _sar_chn = rhs._sar_chn; _scene_id = rhs._scene_id; _scene_des = rhs._scene_des; _inp_sctim = rhs._inp_sctim; _asc_des = rhs._asc_des; _pro_lat = rhs._pro_lat; _pro_long = rhs._pro_long; _pro_head = rhs._pro_head; _ellip_des = rhs._ellip_des; _ellip_maj = rhs._ellip_maj; _ellip_min = rhs._ellip_min; _earth_mass = rhs._earth_mass; _grav_const = rhs._grav_const; _terrain_h = rhs._terrain_h; _sc_lin = rhs._sc_lin; _sc_pix = rhs._sc_pix; _scene_len = rhs._scene_len; _scene_wid = rhs._scene_wid; _nchn = rhs._nchn; _mission_id = rhs._mission_id; _sensor_id = rhs._sensor_id; _orbit_num = rhs._orbit_num; _plat_lat = rhs._plat_lat; _plat_long = rhs._plat_long; _plat_head = rhs._plat_head; _clock_ang = rhs._clock_ang; _incident_ang = rhs._incident_ang; _wave_length = rhs._wave_length; _motion_comp = rhs._motion_comp; _pulse_code = rhs._pulse_code; _chirp_ext_ind = rhs._chirp_ext_ind; _fr = rhs._fr; _rng_gate = rhs._rng_gate; _rng_length = rhs._rng_length; _baseband_f = rhs._baseband_f; _rngcmp_f = rhs._rngcmp_f; _gn_polar = rhs._gn_polar; _gn_cross = rhs._gn_cross; _chn_bits = rhs._chn_bits; _quant_desc = rhs._quant_desc; _i_bias = rhs._i_bias; _q_bias = rhs._q_bias; _iq_ratio = rhs._iq_ratio; _mech_sight = rhs._mech_sight; _fa = rhs._fa; _sat_bintim = rhs._sat_bintim; _sat_clktim = rhs._sat_clktim; _sat_clkinc = rhs._sat_clkinc; _fac_id = rhs._fac_id; _sys_id = rhs._sys_id; _ver_id = rhs._ver_id; _prod_type = rhs._prod_type; _algor_id = rhs._algor_id; _n_azilok = rhs._n_azilok; _n_rnglok = rhs._n_rnglok; _bnd_azilok = rhs._bnd_azilok; _bnd_rnglok = rhs._bnd_rnglok; _bnd_azi = rhs._bnd_azi; _bnd_rng = rhs._bnd_rng; _azi_weight = rhs._azi_weight; _rng_weight = rhs._rng_weight; _data_inpsrc = rhs._data_inpsrc; _rng_res = rhs._rng_res; _azi_res = rhs._azi_res; _time_dir_pix = rhs._time_dir_pix; _time_dir_lin = rhs._time_dir_lin; _line_cont = rhs._line_cont; _clutter_lock = rhs._clutter_lock; _auto_focus = rhs._auto_focus; _line_spacing = rhs._line_spacing; _pix_spacing = rhs._pix_spacing; _rngcmp_desg = rhs._rngcmp_desg; _ellip_j[0] = rhs._ellip_j[0]; _ellip_j[1] = rhs._ellip_j[1]; _ellip_j[2] = rhs._ellip_j[2]; _ampl_coef[0] = rhs._ampl_coef[0]; _ampl_coef[1] = rhs._ampl_coef[1]; _ampl_coef[2] = rhs._ampl_coef[2]; _ampl_coef[3] = rhs._ampl_coef[3]; _ampl_coef[4] = rhs._ampl_coef[4]; _phas_coef[0] = rhs._phas_coef[0]; _phas_coef[1] = rhs._phas_coef[1]; _phas_coef[2] = rhs._phas_coef[2]; _phas_coef[3] = rhs._phas_coef[3]; _phas_coef[4] = rhs._phas_coef[4]; _alt_dopcen[0] = rhs._alt_dopcen[0]; _alt_dopcen[1] = rhs._alt_dopcen[1]; _alt_dopcen[2] = rhs._alt_dopcen[2]; _crt_dopcen[0] = rhs._crt_dopcen[0]; _crt_dopcen[1] = rhs._crt_dopcen[1]; _crt_dopcen[2] = rhs._crt_dopcen[2]; _alt_rate[0] = rhs._alt_rate[0]; _alt_rate[1] = rhs._alt_rate[1]; _alt_rate[2] = rhs._alt_rate[2]; _crt_rate[0] = rhs._crt_rate[0]; _crt_rate[1] = rhs._crt_rate[1]; _crt_rate[2] = rhs._crt_rate[2]; _zero_dop_range_time_f_pixel = rhs._zero_dop_range_time_f_pixel; _zero_dop_range_time_c_pixel = rhs._zero_dop_range_time_c_pixel; _zero_dop_range_time_l_pixel = rhs._zero_dop_range_time_l_pixel; _zero_dop_az_time_f_pixel = rhs._zero_dop_az_time_f_pixel; _zero_dop_az_time_c_pixel = rhs._zero_dop_az_time_c_pixel; _zero_dop_az_time_l_pixel = rhs._zero_dop_az_time_l_pixel; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarDataSetSummary.h000066400000000000000000000440031301006202600311710ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarDataSetSummary_h #define ErsSarDataSetSummary_h #include #include #include "erssar/ErsSarRecordHeader.h" #include "erssar/ErsSarRecord.h" namespace ossimplugins { /** * @ingroup ErsSarDataSetSummaryRecord * @brief This class is able to read the SAR leader data set summary record of the leader file * */ class ErsSarDataSetSummary : public ErsSarRecord { public: /** * @brief Constructor */ ErsSarDataSetSummary(); /** * @brief Destructor */ virtual ~ErsSarDataSetSummary(); /** * @brief This function write the ErsSarDataSetSummary in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarDataSetSummary& data); /** * @brief This function read a ErsSarDataSetSummary from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarDataSetSummary& data); /** * @brief Copy constructor */ ErsSarDataSetSummary(const ErsSarDataSetSummary& rhs); /** * @brief Copy operator */ ErsSarDataSetSummary& operator=(const ErsSarDataSetSummary& rhs); /** * @brief This function is able to create a new instance of the class */ ErsSarRecord* Instantiate() { return new ErsSarDataSetSummary(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ ErsSarRecord* Clone() { return new ErsSarDataSetSummary(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief Sequence number */ int get_seq_num() const { return _seq_num; }; /** * @brief SAR channel indicator */ int get_sar_chn() const { return _sar_chn; }; /** * @brief Scene identifier */ std::string get_scene_id() const { return _scene_id; }; /** * @brief Scene designator */ std::string get_scene_des() const { return _scene_des; }; /** * @brief Input scene centre time */ std::string get_inp_sctim() const { return _inp_sctim; }; /** * @brief Ascending/descending */ std::string get_asc_des() const { return _asc_des; }; /** * @brief Processed scene centre latitude */ double get_pro_lat() const { return _pro_lat; }; /** * @brief Processed scene centre longitude */ double get_pro_long() const { return _pro_long; }; /** * @brief Processed scene centre headng */ double get_pro_head() const { return _pro_head; }; /** * @brief Ellipsoid designator */ std::string get_ellip_des() const { return _ellip_des; }; /** * @brief Ellipsoid semi-major axis, km */ double get_ellip_maj() const { return _ellip_maj; }; /** * @brief Ellipsoid semi_minor axis, km */ double get_ellip_min() const { return _ellip_min; }; /** * @brief Earth's mass */ double get_earth_mass() const { return _earth_mass; }; /** * @brief Gravitational constant */ double get_grav_const() const { return _grav_const; }; /** * @brief Ellipsoid J2-4 parameters */ const double* get_ellip_j() const { return _ellip_j; }; /** * @brief Average terrain height, km */ double get_terrain_h() const { return _terrain_h; }; /** * @brief Scene centre line number */ int get_sc_lin() const { return _sc_lin; }; /** * @brief Scene centre pixel number */ int get_sc_pix() const { return _sc_pix; }; /** * @brief Scene length, km */ double get_scene_len() const { return _scene_len; }; /** * @brief Scene width, km */ double get_scene_wid() const { return _scene_wid; }; /** * @brief Number of SAR channels */ double get_nchn() const { return _nchn; }; /** * @brief Mission identifier */ std::string get_mission_id() const { return _mission_id; }; /** * @brief Sensor identifier */ std::string get_sensor_id() const { return _sensor_id; }; /** * @brief Orbit number */ std::string get_orbit_num() const { return _orbit_num; }; /** * @brief Platform geodetic latitude */ double get_plat_lat() const { return _plat_lat; }; /** * @brief Platform geodetic longitude */ double get_plat_long() const { return _plat_long; }; /** * @brief Platform heading */ double get_plat_head() const { return _plat_head; }; /** * @brief Sensor clock angle */ double get_clock_ang() const { return _clock_ang; }; /** * @brief Incidence angle */ double get_incident_ang() const { return _incident_ang; }; /** * @brief Radar wave length */ double get_wave_length() const { return _wave_length; }; /** * @brief Motion compensation indicator */ std::string get_motion_comp() const { return _motion_comp; }; /** * @brief Range pulse code specifier */ std::string get_pulse_code() const { return _pulse_code; }; /** * @brief Range chirp coefficients */ const double* get_ampl_coef() const { return _ampl_coef; }; /** * @brief Range phase coefficients */ const double* get_phas_coef() const { return _phas_coef; }; /** * @brief Chirp extraction index */ int get_chirp_ext_ind() const { return _chirp_ext_ind; }; /** * @brief Range sampling rate */ double get_fr() const { return _fr; }; /** * @brief Range gate start time */ double get_rng_gate() const { return _rng_gate; }; /** * @brief Range pulse length */ double get_rng_length() const { return _rng_length; }; /** * @brief Baseband conversion flag */ std::string get_baseband_f() const { return _baseband_f; }; /** * @brief Range compressed flag */ std::string get_rngcmp_f() const { return _rngcmp_f; }; /** * @brief Like polarized gain */ double get_gn_polar() const { return _gn_polar; }; /** * @brief Cross polarized gain */ double get_gn_cross() const { return _gn_cross; }; /** * @brief Number of bits per channel */ int get_chn_bits() const { return _chn_bits; }; /** * @brief Quantization descriptor */ std::string get_quant_desc() const { return _quant_desc; }; /** * @brief I channel DC bias */ double get_i_bias() const { return _i_bias; }; /** * @brief Q channel DC bias */ double get_q_bias() const { return _q_bias; }; /** * @brief I/Q channel ratio */ double get_iq_ratio() const { return _iq_ratio; }; /** * @brief Mechanical boresight */ double get_mech_sight() const { return _mech_sight; }; /** * @brief Nominal PRF, Hz */ double get_fa() const { return _fa; }; /** * @brief Satellite binary time */ std::string get_sat_bintim() const { return _sat_bintim; }; /** * @brief Satellite clock time */ std::string get_sat_clktim() const { return _sat_clktim; }; /** * @brief Satellite clock increment */ std::string get_sat_clkinc() const { return _sat_clkinc; }; /** * @brief Processing facility identifier */ std::string get_fac_id() const { return _fac_id; }; /** * @brief Processing system identifier */ std::string get_sys_id() const { return _sys_id; }; /** * @brief Processing version identifier */ std::string get_ver_id() const { return _ver_id; }; /** * @brief Product type specifier */ std::string get_prod_type() const { return _prod_type; }; /** * @brief Processing algorithm identifier */ std::string get_algor_id() const { return _algor_id; }; /** * @brief Number of azimuth looks */ double get_n_azilok() const { return _n_azilok; }; /** * @brief Number of range looks */ double get_n_rnglok() const { return _n_rnglok; }; /** * @brief Bandwidth per look in azimuth,Hz */ double get_bnd_azilok() const { return _bnd_azilok; }; /** * @brief Bandwidth per look in range,Hz */ double get_bnd_rnglok() const { return _bnd_rnglok; }; /** * @brief Total azimuth look bandwidth */ double get_bnd_azi() const { return _bnd_azi; }; /** * @brief Total range look bandwidth */ double get_bnd_rng() const { return _bnd_rng; }; /** * @brief Azimuth weighting designator */ std::string get_azi_weight() const { return _azi_weight; }; /** * @brief Range weighting designator */ std::string get_rng_weight() const { return _rng_weight; }; /** * @brief Data input source */ std::string get_data_inpsrc() const { return _data_inpsrc; }; /** * @brief Range resolution, meter */ double get_rng_res() const { return _rng_res; }; /** * @brief Azimuth resolution, meter */ double get_azi_res() const { return _azi_res; }; /** * @brief Along track Doppler frequency terms */ const double* get_alt_dopcen() const { return _alt_dopcen; }; /** * @brief Cross track Doppler frequency terms */ const double* get_crt_dopcen() const { return _crt_dopcen; }; /** * @brief Pixel time direction indicator */ std::string get_time_dir_pix() const { return _time_dir_pix; }; /** * @brief Line time direction indicator */ std::string get_time_dir_lin() const { return _time_dir_lin; }; /** * @brief Along track Doppler rate term */ const double* get_alt_rate() const { return _alt_rate; }; /** * @brief Cross track Doppler rate term */ const double* get_crt_rate() const { return _crt_rate; }; /** * @brief Line content indicator */ std::string get_line_cont() const { return _line_cont; }; /** * @brief Clutter lock applied flag */ std::string get_clutter_lock() const { return _clutter_lock; }; /** * @brief Auto-focus applied flag */ std::string get_auto_focus() const { return _auto_focus; }; /** * @brief Line spacing, meters */ double get_line_spacing() const { return _line_spacing; }; /** * @brief Pixel spacing, meters */ double get_pix_spacing() const { return _pix_spacing; }; /** * @brief Range compression designator */ std::string get_rngcmp_desg() const { return _rngcmp_desg; }; /** * @brief zero doppler range time (two way) of first pixel */ double get_zero_dop_range_time_f_pixel() const { return _zero_dop_range_time_f_pixel; } /** * @brief zero doppler range time (two way) of mid pixel */ double get_zero_dop_range_time_c_pixel() const { return _zero_dop_range_time_c_pixel; } /** * @brief zero doppler range time (two way) of last pixel */ double get_zero_dop_range_time_l_pixel() const { return _zero_dop_range_time_l_pixel; } /** * @brief zero doppler azimut time (UTC) of first pixel */ std::string get_zero_dop_az_time_f_pixel() const { return _zero_dop_az_time_f_pixel; } /** * @brief zero doppler azimut time (UTC) of mid pixel */ std::string get_zero_dop_az_time_c_pixel() const { return _zero_dop_az_time_c_pixel; } /** * @brief zero doppler azimut time (UTC) of last pixel */ std::string get_zero_dop_az_time_l_pixel() const { return _zero_dop_az_time_l_pixel; } protected: /** * @brief Sequence number */ int _seq_num; /** * @brief SAR channel indicator */ int _sar_chn; /** * @brief Scene identifier */ std::string _scene_id; /** * @brief Scene designator */ std::string _scene_des; /** * @brief Input scene centre time */ std::string _inp_sctim; /** * @brief Ascending/descending */ std::string _asc_des; /** * @brief Processed scene centre latitude */ double _pro_lat; /** * @brief Processed scene centre longitude */ double _pro_long; /** * @brief Processed scene centre headng */ double _pro_head; /** * @brief Ellipsoid designator */ std::string _ellip_des; /** * @brief Ellipsoid semi-major axis, km */ double _ellip_maj; /** * @brief Ellipsoid semi_minor axis, km */ double _ellip_min; /** * @brief Earth's mass */ double _earth_mass; /** * @brief Gravitational constant */ double _grav_const; /** * @brief Ellipsoid J2-4 parameters */ double _ellip_j[3]; /** * @brief Average terrain height, km */ double _terrain_h; /** * @brief Scene centre line number */ int _sc_lin; /** * @brief Scene centre pixel number */ int _sc_pix; /** * @brief Scene length, km */ double _scene_len; /** * @brief Scene width, km */ double _scene_wid; /** * @brief Number of SAR channels */ double _nchn; /** * @brief Mission identifier */ std::string _mission_id; /** * @brief Sensor identifier */ std::string _sensor_id; /** * @brief Orbit number */ std::string _orbit_num; /** * @brief Platform geodetic latitude */ double _plat_lat; /** * @brief Platform geodetic longitude */ double _plat_long; /** * @brief Platform heading */ double _plat_head; /** * @brief Sensor clock angle */ double _clock_ang; /** * @brief Incidence angle */ double _incident_ang; /** * @brief Radar wave length */ double _wave_length; /** * @brief Motion compensation indicator */ std::string _motion_comp; /** * @brief Range pulse code specifier */ std::string _pulse_code; /** * @brief Range chirp coefficients */ double _ampl_coef[5]; /** * @brief Range phase coefficients */ double _phas_coef[5]; /** * @brief Chirp extraction index */ int _chirp_ext_ind; /** * @brief Range sampling rate */ double _fr; /** * @brief Range gate start time */ double _rng_gate; /** * @brief Range pulse length */ double _rng_length; /** * @brief Baseband conversion flag */ std::string _baseband_f; /** * @brief Range compressed flag */ std::string _rngcmp_f; /** * @brief Like polarized gain */ double _gn_polar; /** * @brief Cross polarized gain */ double _gn_cross; /** * @brief Number of bits per channel */ int _chn_bits; /** * @brief Quantization descriptor */ std::string _quant_desc; /** * @brief I channel DC bias */ double _i_bias; /** * @brief Q channel DC bias */ double _q_bias; /** * @brief I/Q channel ratio */ double _iq_ratio; /** * @brief Mechanical boresight */ double _mech_sight; /** * @brief Nominal PRF, Hz */ double _fa; /** * @brief Satellite binary time */ std::string _sat_bintim; /** * @brief Satellite clock time */ std::string _sat_clktim; /** * @brief Satellite clock increment */ std::string _sat_clkinc; /** * @brief Processing facility identifier */ std::string _fac_id; /** * @brief Processing system identifier */ std::string _sys_id; /** * @brief Processing version identifier */ std::string _ver_id; /** * @brief Product type specifier */ std::string _prod_type; /** * @brief Processing algorithm identifier */ std::string _algor_id; /** * @brief Number of azimuth looks */ double _n_azilok; /** * @brief Number of range looks */ double _n_rnglok; /** * @brief Bandwidth per look in azimuth,Hz */ double _bnd_azilok; /** * @brief Bandwidth per look in range,Hz */ double _bnd_rnglok; /** * @brief Total azimuth look bandwidth */ double _bnd_azi; /** * @brief Total range look bandwidth */ double _bnd_rng; /** * @brief Azimuth weighting designator */ std::string _azi_weight; /** * @brief Range weighting designator */ std::string _rng_weight; /** * @brief Data input source */ std::string _data_inpsrc; /** * @brief Range resolution, meter */ double _rng_res; /** * @brief Azimuth resolution, meter */ double _azi_res; /** * @brief Along track Doppler frequency terms */ double _alt_dopcen[3]; /** * @brief Cross track Doppler frequency terms */ double _crt_dopcen[3]; /** * @brief Pixel time direction indicator */ std::string _time_dir_pix; /** * @brief Line time direction indicator */ std::string _time_dir_lin; /** * @brief Along track Doppler rate term */ double _alt_rate[3]; /** * @brief Cross track Doppler rate term */ double _crt_rate[3]; /** * @brief Line content indicator */ std::string _line_cont; /** * @brief Clutter lock applied flag */ std::string _clutter_lock; /** * @brief Auto-focus applied flag */ std::string _auto_focus; /** * @brief Line spacing, meters */ double _line_spacing; /** * @brief Pixel spacing, meters */ double _pix_spacing; /** * @brief Range compression designator */ std::string _rngcmp_desg; /** * @brief zero doppler range time (two way) of first pixel */ double _zero_dop_range_time_f_pixel; /** * @brief zero doppler range time (two way) of mid pixel */ double _zero_dop_range_time_c_pixel; /** * @brief zero doppler range time (two way) of last pixel */ double _zero_dop_range_time_l_pixel ; /** * @brief zero doppler azimut time (UTC) of first pixel */ std::string _zero_dop_az_time_f_pixel ; /** * @brief zero doppler azimut time (UTC) of mid pixel */ std::string _zero_dop_az_time_c_pixel; /** * @brief zero doppler azimut time (UTC) of last pixel */ std::string _zero_dop_az_time_l_pixel; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarFacilityData.cpp000066400000000000000000001241571301006202600311700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarFacilityData.h" namespace ossimplugins { ErsSarFacilityData::ErsSarFacilityData() : ErsSarRecord("facility_data_rec") { } ErsSarFacilityData::~ErsSarFacilityData() { } std::ostream& operator<<(std::ostream& os, const ErsSarFacilityData& data) { os << "last_release_qc_date:" << data._last_release_qc_date.c_str() << std::endl; os << "last_release_cal_date:" << data._last_release_cal_date.c_str() << std::endl; os << "qa_summary_flag:" << data._qa_summary_flag << std::endl; os << "prf_code_change_flag:" << data._prf_code_change_flag << std::endl; os << "sampling_win_change_flag:" << data._sampling_win_change_flag << std::endl; os << "cal_gain_change_flag:" << data._cal_gain_change_flag << std::endl; os << "quirp_qu_flag:" << data._quirp_qu_flag << std::endl; os << "inp_data_stat_flag:" << data._inp_data_stat_flag << std::endl; os << "dopp_cent_conf_meas_flag:" << data._dopp_cent_conf_meas_flag << std::endl; os << "dopp_cent_val_flag:" << data._dopp_cent_val_flag << std::endl; os << "dopp_ambig_conf_meas_flag:" << data._dopp_ambig_conf_meas_flag << std::endl; os << "outp_data_mean_flag:" << data._outp_data_mean_flag << std::endl; os << "OGOB_flag:" << data._OGOB_flag << std::endl; os << "PRF_changes:" << data._PRF_changes << std::endl; os << "sampling_win_changes:" << data._sampling_win_changes << std::endl; os << "cal_gain_changes:" << data._cal_gain_changes << std::endl; os << "missing_lines:" << data._missing_lines << std::endl; os << "rec_gain_changes:" << data._rec_gain_changes << std::endl; os << "pulse_width_of_ACF_3db:" << data._pulse_width_of_ACF_3db << std::endl; os << "first_side_lobe_lev_of_ACF:" << data._first_side_lobe_lev_of_ACF << std::endl; os << "ISLR_of_ACF:" << data._ISLR_of_ACF << std::endl; os << "dopp_cent_conf_meas:" << data._dopp_cent_conf_meas << std::endl; os << "dopp_ambig_conf_meas:" << data._dopp_ambig_conf_meas << std::endl; os << "inp_data_I_mean:" << data._inp_data_I_mean << std::endl; os << "inp_data_Q_mean:" << data._inp_data_Q_mean << std::endl; os << "inp_data_I_stddev:" << data._inp_data_I_stddev << std::endl; os << "inp_data_Q_stddev:" << data._inp_data_Q_stddev << std::endl; os << "cal_sys_gain:" << data._cal_sys_gain << std::endl; os << "first_rec_gain_read:" << data._first_rec_gain_read << std::endl; os << "dopp_ambig_num:" << data._dopp_ambig_num << std::endl; os << "I_channel_bias_correction:" << data._I_channel_bias_correction << std::endl; os << "Q_channel_bias_correction:" << data._Q_channel_bias_correction << std::endl; os << "I_channel_gain_correction:" << data._I_channel_gain_correction << std::endl; os << "Q_channel_gain_correction:" << data._Q_channel_gain_correction << std::endl; os << "Q_channel_I_Q_correction:" << data._Q_channel_I_Q_correction << std::endl; os << "noise_power:" << data._noise_power << std::endl; os << "int_cal_utc:" << data._int_cal_utc << std::endl; os << "num_valid_cal_pulses:" << data._num_valid_cal_pulses << std::endl; os << "num_valid_noise_pulses:" << data._num_valid_noise_pulses << std::endl; os << "num_valid_replicas:" << data._num_valid_replicas << std::endl; os << "first_replica_sample:" << data._first_replica_sample << std::endl; os << "mean_cal_pulse_power:" << data._mean_cal_pulse_power << std::endl; os << "mean_noise_power:" << data._mean_noise_power << std::endl; os << "range_comp_norm_fact:" << data._range_comp_norm_fact << std::endl; os << "replica_power:" << data._replica_power << std::endl; os << "first_range_pixel_mid_az_inc:" << data._first_range_pixel_mid_az_inc << std::endl; os << "center_range_pix_mid_az_inc:" << data._center_range_pix_mid_az_inc << std::endl; os << "last_range_pix_mid_az_inc:" << data._last_range_pix_mid_az_inc << std::endl; os << "norm_ref_range_ro:" << data._norm_ref_range_ro << std::endl; os << "antenna_elev_flag:" << data._antenna_elev_flag << std::endl; os << "abs_cal_const_K:" << data._abs_cal_const_K << std::endl; os << "upp_bound_K:" << data._upp_bound_K << std::endl; os << "low_bound_K:" << data._low_bound_K << std::endl; os << "proc_noise_scale_fact:" << data._proc_noise_scale_fact << std::endl; os << "K_gen_date:" << data._K_gen_date.c_str() << std::endl; os << "K_vers_num:" << data._K_vers_num.c_str() << std::endl; os << "num_duplic_input_lines:" << data._num_duplic_input_lines << std::endl; os << "estim_bit_error_rate:" << data._estim_bit_error_rate << std::endl; os << "out_image_mean:" << data._out_image_mean << std::endl; os << "out_image_std_dev:" << data._out_image_std_dev << std::endl; os << "out_image_max_value:" << data._out_image_max_value << std::endl; os << "time_raw_data_first_input:" << data._time_raw_data_first_input.c_str() << std::endl; os << "time_asc_node_state_vectors:" << data._time_asc_node_state_vectors.c_str() << std::endl; os << "asc_node_pos_X_comp:" << data._asc_node_pos_X_comp.c_str() << std::endl; os << "asc_node_pos_Y_comp:" << data._asc_node_pos_Y_comp.c_str() << std::endl; os << "asc_node_pos_Z_comp:" << data._asc_node_pos_Z_comp.c_str() << std::endl; os << "asc_node_vel_X_comp:" << data._asc_node_vel_X_comp.c_str() << std::endl; os << "asc_node_vel_Y_comp:" << data._asc_node_vel_Y_comp.c_str() << std::endl; os << "asc_node_vel_Z_comp:" << data._asc_node_vel_Z_comp.c_str() << std::endl; os << "out_pixel_bit_length:" << data._out_pixel_bit_length << std::endl; os << "proc_gain_param_1:" << data._proc_gain_param_1 << std::endl; os << "proc_gain_param_2:" << data._proc_gain_param_2 << std::endl; os << "proc_gain_param_3:" << data._proc_gain_param_3 << std::endl; os << "peak_loc_cross_correl_fun:" << data._peak_loc_cross_correl_fun << std::endl; os << "3_dB_width_CCF:" << data._3_dB_width_CCF << std::endl; os << "first_side_lobe_level:" << data._first_side_lobe_level << std::endl; os << "ISLR_CCF_between_last:" << data._ISLR_CCF_between_last << std::endl; os << "peak_loc_CCF_betw_last:" << data._peak_loc_CCF_betw_last << std::endl; os << "Roll_Tilt_Mode_flag:" << data._Roll_Tilt_Mode_flag << std::endl; os << "raw_data_correction_flag:" << data._raw_data_correction_flag << std::endl; os << "look_detecion_flag:" << data._look_detecion_flag << std::endl; os << "doppler_ambiguity_estimat_flag:" << data._doppler_ambiguity_estimat_flag << std::endl; os << "azimuth_baseband_convers_flag:" << data._azimuth_baseband_convers_flag << std::endl; os << "samples_per_line_used:" << data._samples_per_line_used << std::endl; os << "range_lines_skip_factor:" << data._range_lines_skip_factor << std::endl; os << "time_of_inp_state_vectors:" << data._time_of_inp_state_vectors.c_str() << std::endl; os << "inp_state_vect_pos_X_comp:" << data._inp_state_vect_pos_X_comp.c_str() << std::endl; os << "inp_state_vect_pos_Y_comp:" << data._inp_state_vect_pos_Y_comp.c_str() << std::endl; os << "inp_state_vect_pos_Z_comp:" << data._inp_state_vect_pos_Z_comp.c_str() << std::endl; os << "inp_state_vect_vel_Vx_comp:" << data._inp_state_vect_vel_Vx_comp.c_str() << std::endl; os << "inp_state_vect_vel_Vy_comp:" << data._inp_state_vect_vel_Vy_comp.c_str() << std::endl; os << "inp_state_vect_vel_Vz_comp:" << data._inp_state_vect_vel_Vz_comp.c_str() << std::endl; os << "inp_state_vector_type_flag:" << data._inp_state_vector_type_flag << std::endl; os << "win_coeff_for_range_match:" << data._win_coeff_for_range_match << std::endl; os << "win_coeff_for_azi_match:" << data._win_coeff_for_azi_match << std::endl; os << "update_period_range_match:" << data._update_period_range_match << std::endl; os << "look_scalar_gain_1:" << data._look_scalar_gain_1 << std::endl; os << "look_scalar_gain_2:" << data._look_scalar_gain_2 << std::endl; os << "look_scalar_gain_3:" << data._look_scalar_gain_3 << std::endl; os << "look_scalar_gain_4:" << data._look_scalar_gain_4 << std::endl; os << "look_scalar_gain_5:" << data._look_scalar_gain_5 << std::endl; os << "look_scalar_gain_6:" << data._look_scalar_gain_6 << std::endl; os << "look_scalar_gain_7:" << data._look_scalar_gain_7 << std::endl; os << "look_scalar_gain_8:" << data._look_scalar_gain_8 << std::endl; os << "samp_window_start_time_bias:" << data._samp_window_start_time_bias << std::endl; os << "doppler_centroid_cubic_coeff:" << data._doppler_centroid_cubic_coeff << std::endl; os << "PRF_code_first_range_line:" << data._PRF_code_first_range_line << std::endl; os << "PRF_code_last_range_line:" << data._PRF_code_last_range_line << std::endl; os << "samp_win_start_first:" << data._samp_win_start_first << std::endl; os << "samp_win_start_last:" << data._samp_win_start_last << std::endl; os << "cal_syst_gain_last_proc:" << data._cal_syst_gain_last_proc << std::endl; os << "receiver_gain_last_proc:" << data._receiver_gain_last_proc << std::endl; os << "first_processed_range_sample:" << data._first_processed_range_sample << std::endl; os << "azimuth_FFT_IFFT_ratio:" << data._azimuth_FFT_IFFT_ratio << std::endl; os << "num_azimuth_blocks_proc:" << data._num_azimuth_blocks_proc << std::endl; os << "num_input_raw_data_lines:" << data._num_input_raw_data_lines << std::endl; os << "initial_doppler_ambiguity_num:" << data._initial_doppler_ambiguity_num << std::endl; os << "thresh_no_1_flag:" << data._thresh_no_1_flag << std::endl; os << "thresh_no_2_flag:" << data._thresh_no_2_flag << std::endl; os << "thresh_no_3_flag:" << data._thresh_no_3_flag << std::endl; os << "thresh_no_4_flag:" << data._thresh_no_4_flag << std::endl; os << "thresh_no_5_flag:" << data._thresh_no_5_flag << std::endl; os << "thresh_no_6_flag:" << data._thresh_no_6_flag << std::endl; os << "thresh_no_7_flag:" << data._thresh_no_7_flag << std::endl; os << "thresh_no_8_flag:" << data._thresh_no_8_flag << std::endl; os << "thresh_no_9_flag:" << data._thresh_no_9_flag << std::endl; os << "thresh_no_10_flag:" << data._thresh_no_10_flag << std::endl; os << "thresh_no_11_flag:" << data._thresh_no_11_flag << std::endl; os << "sat_binary_time_of_first:" << data._sat_binary_time_of_first << std::endl; os << "num_valid_pixels_per_range:" << data._num_valid_pixels_per_range << std::endl; os << "num_range_samp_discarded:" << data._num_range_samp_discarded << std::endl; os << "I_gain_imb_lower_bound:" << data._I_gain_imb_lower_bound << std::endl; os << "I_gain_imb_upper_bound:" << data._I_gain_imb_upper_bound << std::endl; os << "I_Q_quad_depar_lower_bound:" << data._I_Q_quad_depar_lower_bound << std::endl; os << "I_Q_quad_depar_upper_bound:" << data._I_Q_quad_depar_upper_bound << std::endl; os << "3_dB_look_bandwidth:" << data._3_dB_look_bandwidth << std::endl; os << "3_dB_look_proc_dopp_bandw:" << data._3_dB_look_proc_dopp_bandw << std::endl; os << "range_spread_loss_comp_flag:" << data._range_spread_loss_comp_flag << std::endl; os << "datation_flag:" << data._datation_flag << std::endl; os << "max_error_range_line_timing:" << data._max_error_range_line_timing << std::endl; os << "form_num_range_line_used:" << data._form_num_range_line_used << std::endl; os << "autom_look_scal_gain_flag:" << data._autom_look_scal_gain_flag << std::endl; os << "max_value_look_scalar_gain:" << data._max_value_look_scalar_gain << std::endl; os << "replica_norm_method_flag:" << data._replica_norm_method_flag << std::endl; os << "coef_ground_range_1:" << data._coef_ground_range_1 << std::endl; os << "coef_ground_range_2:" << data._coef_ground_range_2 << std::endl; os << "coef_ground_range_3:" << data._coef_ground_range_3 << std::endl; os << "coef_ground_range_4:" << data._coef_ground_range_4 << std::endl; os << "coef_ant_elev_1:" << data._coef_ant_elev_1 << std::endl; os << "coef_ant_elev_2:" << data._coef_ant_elev_2 << std::endl; os << "coef_ant_elev_3:" << data._coef_ant_elev_3 << std::endl; os << "coef_ant_elev_4:" << data._coef_ant_elev_4 << std::endl; os << "coef_ant_elev_5:" << data._coef_ant_elev_5 << std::endl; os << "range_time_origin_ant:" << data._range_time_origin_ant << std::endl; return os; } std::istream& operator>>(std::istream& is, ErsSarFacilityData& data) { char buf64[65]; buf64[64] = '\0'; // char buf32[33]; // buf32[32] = '\0'; char buf24[25]; buf24[24] = '\0'; char buf22[23]; buf22[22] = '\0'; char buf20[21]; buf20[20] = '\0'; char buf16[17]; buf16[16] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf7[8]; buf7[7] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf6[7]; buf6[6] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf2[3]; buf2[2] = '\0'; char buf1[2]; buf1[1] = '\0'; is.read(buf64, 64); data._name_of_facil_rec = buf64; is.read(buf6, 6); data._last_release_qc_date = buf6; is.read(buf2, 2); is.read(buf6, 6); data._last_release_cal_date = buf6; is.read(buf4, 4); data._qa_summary_flag = atoi(buf4); is.read(buf4, 4); data._prf_code_change_flag = atoi(buf4); is.read(buf4, 4); data._sampling_win_change_flag = atoi(buf4); is.read(buf4, 4); data._cal_gain_change_flag = atoi(buf4); is.read(buf4, 4); data._quirp_qu_flag = atoi(buf4); is.read(buf4, 4); data._inp_data_stat_flag = atoi(buf4); is.read(buf4, 4); data._dopp_cent_conf_meas_flag = atoi(buf4); is.read(buf4, 4); data._dopp_cent_val_flag = atoi(buf4); is.read(buf4, 4); data._dopp_ambig_conf_meas_flag = atoi(buf4); is.read(buf4, 4); data._outp_data_mean_flag = atoi(buf4); is.read(buf4, 4); data._OGOB_flag = atoi(buf4); is.read(buf4, 4); data._PRF_changes = atoi(buf4); is.read(buf4, 4); data._sampling_win_changes = atoi(buf4); is.read(buf4, 4); data._cal_gain_changes = atoi(buf4); is.read(buf4, 4); data._missing_lines = atoi(buf4); is.read(buf4, 4); data._rec_gain_changes = atoi(buf4); is.read(buf16, 16); data._pulse_width_of_ACF_3db = atof(buf16); is.read(buf16, 16); data._first_side_lobe_lev_of_ACF = atof(buf16); is.read(buf16, 16); data._ISLR_of_ACF = atof(buf16); is.read(buf16, 16); data._dopp_cent_conf_meas = atof(buf16); is.read(buf16, 16); data._dopp_ambig_conf_meas = atof(buf16); is.read(buf16, 16); data._inp_data_I_mean = atof(buf16); is.read(buf16, 16); data._inp_data_Q_mean = atof(buf16); is.read(buf16, 16); data._inp_data_I_stddev = atof(buf16); is.read(buf16, 16); data._inp_data_Q_stddev = atof(buf16); is.read(buf16, 16); data._cal_sys_gain = atof(buf16); is.read(buf16, 16); data._first_rec_gain_read = atof(buf16); is.read(buf16, 16); data._dopp_ambig_num = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._I_channel_bias_correction = atof(buf16); is.read(buf16, 16); data._Q_channel_bias_correction = atof(buf16); is.read(buf16, 16); data._I_channel_gain_correction = atof(buf16); is.read(buf16, 16); data._Q_channel_gain_correction = atof(buf16); is.read(buf16, 16); data._Q_channel_I_Q_correction = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); data._noise_power = atof(buf16); is.read(buf16, 16); data._int_cal_utc = atoi(buf16); is.read(buf4, 4); data._num_valid_cal_pulses = atoi(buf4); is.read(buf4, 4); data._num_valid_noise_pulses = atoi(buf4); is.read(buf4, 4); data._num_valid_replicas = atoi(buf4); is.read(buf16, 16); data._first_replica_sample = atof(buf16); is.read(buf16, 16); data._mean_cal_pulse_power = atof(buf16); is.read(buf16, 16); data._mean_noise_power = atof(buf16); is.read(buf16, 16); data._range_comp_norm_fact = atof(buf16); is.read(buf16, 16); data._replica_power = atof(buf16); is.read(buf16, 16); data._first_range_pixel_mid_az_inc = atof(buf16); is.read(buf16, 16); data._center_range_pix_mid_az_inc = atof(buf16); is.read(buf16, 16); data._last_range_pix_mid_az_inc = atof(buf16); is.read(buf16, 16); data._norm_ref_range_ro = atof(buf16); is.read(buf12, 12); is.read(buf4, 4); data._antenna_elev_flag = atoi(buf4); is.read(buf16, 16); data._abs_cal_const_K = atof(buf16); is.read(buf16, 16); data._upp_bound_K = atof(buf16); is.read(buf16, 16); data._low_bound_K = atof(buf16); is.read(buf16, 16); data._proc_noise_scale_fact = atof(buf16); is.read(buf6, 6); data._K_gen_date = buf6; is.read(buf4, 4); data._K_vers_num = buf4; is.read(buf4, 4); data._num_duplic_input_lines = atoi(buf4); is.read(buf16, 16); data._estim_bit_error_rate = atof(buf16); is.read(buf12, 12); is.read(buf16, 16); data._out_image_mean = atof(buf16); is.read(buf16, 16); data._out_image_std_dev = atof(buf16); is.read(buf16, 16); data._out_image_max_value = atof(buf16); is.read(buf24, 24); data._time_raw_data_first_input = buf24; is.read(buf24, 24); data._time_asc_node_state_vectors = buf24; is.read(buf22, 22); data._asc_node_pos_X_comp = buf22; is.read(buf22, 22); data._asc_node_pos_Y_comp = buf22; is.read(buf22, 22); data._asc_node_pos_Z_comp = buf22; is.read(buf22, 22); data._asc_node_vel_X_comp = buf22; is.read(buf22, 22); data._asc_node_vel_Y_comp = buf22; is.read(buf22, 22); data._asc_node_vel_Z_comp = buf22; is.read(buf4, 4); data._out_pixel_bit_length = atoi(buf4); is.read(buf16, 16); data._proc_gain_param_1 = atof(buf16); is.read(buf16, 16); data._proc_gain_param_2 = atof(buf16); is.read(buf16, 16); data._proc_gain_param_3 = atof(buf16); is.read(buf4, 4); data._peak_loc_cross_correl_fun = atoi(buf4); is.read(buf16, 16); data._3_dB_width_CCF = atof(buf16); is.read(buf16, 16); data._first_side_lobe_level = atof(buf16); is.read(buf16, 16); data._ISLR_CCF_between_last = atof(buf16); is.read(buf4, 4); data._peak_loc_CCF_betw_last = atoi(buf4); is.read(buf4, 4); data._Roll_Tilt_Mode_flag = atoi(buf4); is.read(buf4, 4); data._raw_data_correction_flag = atoi(buf4); is.read(buf4, 4); data._look_detecion_flag = atoi(buf4); is.read(buf4, 4); data._doppler_ambiguity_estimat_flag = atoi(buf4); is.read(buf4, 4); data._azimuth_baseband_convers_flag = atoi(buf4); is.read(buf4, 4); data._samples_per_line_used = atoi(buf4); is.read(buf4, 4); data._range_lines_skip_factor = atoi(buf4); is.read(buf24, 24); data._time_of_inp_state_vectors = buf24; is.read(buf22, 22); data._inp_state_vect_pos_X_comp = buf22; is.read(buf22, 22); data._inp_state_vect_pos_Y_comp = buf22; is.read(buf22, 22); data._inp_state_vect_pos_Z_comp = buf22; is.read(buf22, 22); data._inp_state_vect_vel_Vx_comp = buf22; is.read(buf22, 22); data._inp_state_vect_vel_Vy_comp = buf22; is.read(buf22, 22); data._inp_state_vect_vel_Vz_comp = buf22; is.read(buf4, 4); data._inp_state_vector_type_flag = atoi(buf4); is.read(buf16, 16); data._win_coeff_for_range_match = atof(buf16); is.read(buf16, 16); data._win_coeff_for_azi_match = atof(buf16); is.read(buf4, 4); data._update_period_range_match = atoi(buf4); is.read(buf16, 16); data._look_scalar_gain_1 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_2 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_3 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_4 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_5 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_6 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_7 = atof(buf16); is.read(buf16, 16); data._look_scalar_gain_8 = atof(buf16); is.read(buf4, 4); data._samp_window_start_time_bias = atoi(buf4); is.read(buf22, 22); data._doppler_centroid_cubic_coeff = atof(buf22); is.read(buf4, 4); data._PRF_code_first_range_line = atoi(buf4); is.read(buf4, 4); data._PRF_code_last_range_line = atoi(buf4); is.read(buf4, 4); data._samp_win_start_first = atoi(buf4); is.read(buf4, 4); data._samp_win_start_last = atoi(buf4); is.read(buf4, 4); data._cal_syst_gain_last_proc = atoi(buf4); is.read(buf4, 4); data._receiver_gain_last_proc = atoi(buf4); is.read(buf4, 4); data._first_processed_range_sample = atoi(buf4); is.read(buf4, 4); data._azimuth_FFT_IFFT_ratio = atoi(buf4); is.read(buf4, 4); data._num_azimuth_blocks_proc = atoi(buf4); is.read(buf8, 8); data._num_input_raw_data_lines = atol(buf8); is.read(buf4, 4); data._initial_doppler_ambiguity_num = atoi(buf4); is.read(buf16, 16); data._thresh_no_1_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_2_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_3_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_4_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_5_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_6_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_7_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_8_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_9_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_10_flag = atof(buf16); is.read(buf16, 16); data._thresh_no_11_flag = atof(buf16); is.read(buf16, 16); data._sat_binary_time_of_first = atol(buf16); is.read(buf4, 4); data._num_valid_pixels_per_range = atoi(buf4); is.read(buf4, 4); data._num_range_samp_discarded = atoi(buf4); is.read(buf16, 16); data._I_gain_imb_lower_bound = atof(buf16); is.read(buf16, 16); data._I_gain_imb_upper_bound = atof(buf16); is.read(buf16, 16); data._I_Q_quad_depar_lower_bound = atof(buf16); is.read(buf16, 16); data._I_Q_quad_depar_upper_bound = atof(buf16); is.read(buf16, 16); data._3_dB_look_bandwidth = atof(buf16); is.read(buf16, 16); data._3_dB_look_proc_dopp_bandw = atof(buf16); is.read(buf4, 4); data._range_spread_loss_comp_flag = atoi(buf4); is.read(buf1, 1); data._datation_flag = (atoi(buf1) == 0) ? false : true; is.read(buf7, 7); data._max_error_range_line_timing = atoi(buf7); is.read(buf7, 7); data._form_num_range_line_used = atoi(buf7); is.read(buf1, 1); data._autom_look_scal_gain_flag = (atoi(buf1) == 0) ? false : true; is.read(buf4, 4); data._max_value_look_scalar_gain = atoi(buf4); is.read(buf4, 4); data._replica_norm_method_flag = atoi(buf4); is.read(buf20, 20); data._coef_ground_range_1 = atof(buf20); is.read(buf20, 20); data._coef_ground_range_2 = atof(buf20); is.read(buf20, 20); data._coef_ground_range_3 = atof(buf20); is.read(buf20, 20); data._coef_ground_range_4 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_1 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_2 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_3 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_4 = atof(buf20); is.read(buf20, 20); data._coef_ant_elev_5 = atof(buf20); is.read(buf16, 16); data._range_time_origin_ant = atof(buf16); char buf10238[10238]; is.read(buf10238, 10238); return is; } ErsSarFacilityData::ErsSarFacilityData(const ErsSarFacilityData& rhs): ErsSarRecord(rhs), _last_release_qc_date(rhs._last_release_qc_date), _last_release_cal_date(rhs._last_release_cal_date), _qa_summary_flag(rhs._qa_summary_flag), _prf_code_change_flag(rhs._prf_code_change_flag), _sampling_win_change_flag(rhs._sampling_win_change_flag), _cal_gain_change_flag(rhs._cal_gain_change_flag), _quirp_qu_flag(rhs._quirp_qu_flag), _inp_data_stat_flag(rhs._inp_data_stat_flag), _dopp_cent_conf_meas_flag(rhs._dopp_cent_conf_meas_flag), _dopp_cent_val_flag(rhs._dopp_cent_val_flag), _dopp_ambig_conf_meas_flag(rhs._dopp_ambig_conf_meas_flag), _outp_data_mean_flag(rhs._outp_data_mean_flag), _OGOB_flag(rhs._OGOB_flag), _PRF_changes(rhs._PRF_changes), _sampling_win_changes(rhs._sampling_win_changes), _cal_gain_changes(rhs._cal_gain_changes), _missing_lines(rhs._missing_lines), _rec_gain_changes(rhs._rec_gain_changes), _pulse_width_of_ACF_3db(rhs._pulse_width_of_ACF_3db), _first_side_lobe_lev_of_ACF(rhs._first_side_lobe_lev_of_ACF), _ISLR_of_ACF(rhs._ISLR_of_ACF), _dopp_cent_conf_meas(rhs._dopp_cent_conf_meas), _dopp_ambig_conf_meas(rhs._dopp_ambig_conf_meas), _inp_data_I_mean(rhs._inp_data_I_mean), _inp_data_Q_mean(rhs._inp_data_Q_mean), _inp_data_I_stddev(rhs._inp_data_I_stddev), _inp_data_Q_stddev(rhs._inp_data_Q_stddev), _cal_sys_gain(rhs._cal_sys_gain), _first_rec_gain_read(rhs._first_rec_gain_read), _dopp_ambig_num(rhs._dopp_ambig_num), _I_channel_bias_correction(rhs._I_channel_bias_correction), _Q_channel_bias_correction(rhs._Q_channel_bias_correction), _I_channel_gain_correction(rhs._I_channel_gain_correction), _Q_channel_gain_correction(rhs._Q_channel_gain_correction), _Q_channel_I_Q_correction(rhs._Q_channel_I_Q_correction), _noise_power(rhs._noise_power), _int_cal_utc(rhs._int_cal_utc), _num_valid_cal_pulses(rhs._num_valid_cal_pulses), _num_valid_noise_pulses(rhs._num_valid_noise_pulses), _num_valid_replicas(rhs._num_valid_replicas), _first_replica_sample(rhs._first_replica_sample), _mean_cal_pulse_power(rhs._mean_cal_pulse_power), _mean_noise_power(rhs._mean_noise_power), _range_comp_norm_fact(rhs._range_comp_norm_fact), _replica_power(rhs._replica_power), _first_range_pixel_mid_az_inc(rhs._first_range_pixel_mid_az_inc), _center_range_pix_mid_az_inc(rhs._center_range_pix_mid_az_inc), _last_range_pix_mid_az_inc(rhs._last_range_pix_mid_az_inc), _norm_ref_range_ro(rhs._norm_ref_range_ro), _antenna_elev_flag(rhs._antenna_elev_flag), _abs_cal_const_K(rhs._abs_cal_const_K), _upp_bound_K(rhs._upp_bound_K), _low_bound_K(rhs._low_bound_K), _proc_noise_scale_fact(rhs._proc_noise_scale_fact), _K_gen_date(rhs._K_gen_date), _K_vers_num(rhs._K_vers_num), _num_duplic_input_lines(rhs._num_duplic_input_lines), _estim_bit_error_rate(rhs._estim_bit_error_rate), _out_image_mean(rhs._out_image_mean), _out_image_std_dev(rhs._out_image_std_dev), _out_image_max_value(rhs._out_image_max_value), _time_raw_data_first_input(rhs._time_raw_data_first_input), _time_asc_node_state_vectors(rhs._time_asc_node_state_vectors), _asc_node_pos_X_comp(rhs._asc_node_pos_X_comp), _asc_node_pos_Y_comp(rhs._asc_node_pos_Y_comp), _asc_node_pos_Z_comp(rhs._asc_node_pos_Z_comp), _asc_node_vel_X_comp(rhs._asc_node_vel_X_comp), _asc_node_vel_Y_comp(rhs._asc_node_vel_Y_comp), _asc_node_vel_Z_comp(rhs._asc_node_vel_Z_comp), _out_pixel_bit_length(rhs._out_pixel_bit_length), _proc_gain_param_1(rhs._proc_gain_param_1), _proc_gain_param_2(rhs._proc_gain_param_2), _proc_gain_param_3(rhs._proc_gain_param_3), _peak_loc_cross_correl_fun(rhs._peak_loc_cross_correl_fun), _3_dB_width_CCF(rhs._3_dB_width_CCF), _first_side_lobe_level(rhs._first_side_lobe_level), _ISLR_CCF_between_last(rhs._ISLR_CCF_between_last), _peak_loc_CCF_betw_last(rhs._peak_loc_CCF_betw_last), _Roll_Tilt_Mode_flag(rhs._Roll_Tilt_Mode_flag), _raw_data_correction_flag(rhs._raw_data_correction_flag), _look_detecion_flag(rhs._look_detecion_flag), _doppler_ambiguity_estimat_flag(rhs._doppler_ambiguity_estimat_flag), _azimuth_baseband_convers_flag(rhs._azimuth_baseband_convers_flag), _samples_per_line_used(rhs._samples_per_line_used), _range_lines_skip_factor(rhs._range_lines_skip_factor), _time_of_inp_state_vectors(rhs._time_of_inp_state_vectors), _inp_state_vect_pos_X_comp(rhs._inp_state_vect_pos_X_comp), _inp_state_vect_pos_Y_comp(rhs._inp_state_vect_pos_Y_comp), _inp_state_vect_pos_Z_comp(rhs._inp_state_vect_pos_Z_comp), _inp_state_vect_vel_Vx_comp(rhs._inp_state_vect_vel_Vx_comp), _inp_state_vect_vel_Vy_comp(rhs._inp_state_vect_vel_Vy_comp), _inp_state_vect_vel_Vz_comp(rhs._inp_state_vect_vel_Vz_comp), _inp_state_vector_type_flag(rhs._inp_state_vector_type_flag), _win_coeff_for_range_match(rhs._win_coeff_for_range_match), _win_coeff_for_azi_match(rhs._win_coeff_for_azi_match), _update_period_range_match(rhs._update_period_range_match), _look_scalar_gain_1(rhs._look_scalar_gain_1), _look_scalar_gain_2(rhs._look_scalar_gain_2), _look_scalar_gain_3(rhs._look_scalar_gain_3), _look_scalar_gain_4(rhs._look_scalar_gain_4), _look_scalar_gain_5(rhs._look_scalar_gain_5), _look_scalar_gain_6(rhs._look_scalar_gain_6), _look_scalar_gain_7(rhs._look_scalar_gain_7), _look_scalar_gain_8(rhs._look_scalar_gain_8), _samp_window_start_time_bias(rhs._samp_window_start_time_bias), _doppler_centroid_cubic_coeff(rhs._doppler_centroid_cubic_coeff), _PRF_code_first_range_line(rhs._PRF_code_first_range_line), _PRF_code_last_range_line(rhs._PRF_code_last_range_line), _samp_win_start_first(rhs._samp_win_start_first), _samp_win_start_last(rhs._samp_win_start_last), _cal_syst_gain_last_proc(rhs._cal_syst_gain_last_proc), _receiver_gain_last_proc(rhs._receiver_gain_last_proc), _first_processed_range_sample(rhs._first_processed_range_sample), _azimuth_FFT_IFFT_ratio(rhs._azimuth_FFT_IFFT_ratio), _num_azimuth_blocks_proc(rhs._num_azimuth_blocks_proc), _num_input_raw_data_lines(rhs._num_input_raw_data_lines), _initial_doppler_ambiguity_num(rhs._initial_doppler_ambiguity_num), _thresh_no_1_flag(rhs._thresh_no_1_flag), _thresh_no_2_flag(rhs._thresh_no_2_flag), _thresh_no_3_flag(rhs._thresh_no_3_flag), _thresh_no_4_flag(rhs._thresh_no_4_flag), _thresh_no_5_flag(rhs._thresh_no_5_flag), _thresh_no_6_flag(rhs._thresh_no_6_flag), _thresh_no_7_flag(rhs._thresh_no_7_flag), _thresh_no_8_flag(rhs._thresh_no_8_flag), _thresh_no_9_flag(rhs._thresh_no_9_flag), _thresh_no_10_flag(rhs._thresh_no_10_flag), _thresh_no_11_flag(rhs._thresh_no_11_flag), _sat_binary_time_of_first(rhs._sat_binary_time_of_first), _num_valid_pixels_per_range(rhs._num_valid_pixels_per_range), _num_range_samp_discarded(rhs._num_range_samp_discarded), _I_gain_imb_lower_bound(rhs._I_gain_imb_lower_bound), _I_gain_imb_upper_bound(rhs._I_gain_imb_upper_bound), _I_Q_quad_depar_lower_bound(rhs._I_Q_quad_depar_lower_bound), _I_Q_quad_depar_upper_bound(rhs._I_Q_quad_depar_upper_bound), _3_dB_look_bandwidth(rhs._3_dB_look_bandwidth), _3_dB_look_proc_dopp_bandw(rhs._3_dB_look_proc_dopp_bandw), _range_spread_loss_comp_flag(rhs._range_spread_loss_comp_flag), _datation_flag(rhs._datation_flag), _max_error_range_line_timing(rhs._max_error_range_line_timing), _form_num_range_line_used(rhs._form_num_range_line_used), _autom_look_scal_gain_flag(rhs._autom_look_scal_gain_flag), _max_value_look_scalar_gain(rhs._max_value_look_scalar_gain), _replica_norm_method_flag(rhs._replica_norm_method_flag), _coef_ground_range_1(rhs._coef_ground_range_1), _coef_ground_range_2(rhs._coef_ground_range_2), _coef_ground_range_3(rhs._coef_ground_range_3), _coef_ground_range_4(rhs._coef_ground_range_4), _coef_ant_elev_1(rhs._coef_ant_elev_1), _coef_ant_elev_2(rhs._coef_ant_elev_2), _coef_ant_elev_3(rhs._coef_ant_elev_3), _coef_ant_elev_4(rhs._coef_ant_elev_4), _coef_ant_elev_5(rhs._coef_ant_elev_5), _range_time_origin_ant(rhs._range_time_origin_ant) {} ErsSarFacilityData& ErsSarFacilityData::operator=(const ErsSarFacilityData& rhs) { _last_release_qc_date = rhs._last_release_qc_date; _last_release_cal_date = rhs._last_release_cal_date; _qa_summary_flag = rhs._qa_summary_flag; _prf_code_change_flag = rhs._prf_code_change_flag; _sampling_win_change_flag = rhs._sampling_win_change_flag; _cal_gain_change_flag = rhs._cal_gain_change_flag; _quirp_qu_flag = rhs._quirp_qu_flag; _inp_data_stat_flag = rhs._inp_data_stat_flag; _dopp_cent_conf_meas_flag = rhs._dopp_cent_conf_meas_flag; _dopp_cent_val_flag = rhs._dopp_cent_val_flag; _dopp_ambig_conf_meas_flag = rhs._dopp_ambig_conf_meas_flag; _outp_data_mean_flag = rhs._outp_data_mean_flag; _OGOB_flag = rhs._OGOB_flag; _PRF_changes = rhs._PRF_changes; _sampling_win_changes = rhs._sampling_win_changes; _cal_gain_changes = rhs._cal_gain_changes; _missing_lines = rhs._missing_lines; _rec_gain_changes = rhs._rec_gain_changes; _pulse_width_of_ACF_3db = rhs._pulse_width_of_ACF_3db; _first_side_lobe_lev_of_ACF = rhs._first_side_lobe_lev_of_ACF; _ISLR_of_ACF = rhs._ISLR_of_ACF; _dopp_cent_conf_meas = rhs._dopp_cent_conf_meas; _dopp_ambig_conf_meas = rhs._dopp_ambig_conf_meas; _inp_data_I_mean = rhs._inp_data_I_mean; _inp_data_Q_mean = rhs._inp_data_Q_mean; _inp_data_I_stddev = rhs._inp_data_I_stddev; _inp_data_Q_stddev = rhs._inp_data_Q_stddev; _cal_sys_gain = rhs._cal_sys_gain; _first_rec_gain_read = rhs._first_rec_gain_read; _dopp_ambig_num = rhs._dopp_ambig_num; _I_channel_bias_correction = rhs._I_channel_bias_correction; _Q_channel_bias_correction = rhs._Q_channel_bias_correction; _I_channel_gain_correction = rhs._I_channel_gain_correction; _Q_channel_gain_correction = rhs._Q_channel_gain_correction; _Q_channel_I_Q_correction = rhs._Q_channel_I_Q_correction; _noise_power = rhs._noise_power; _int_cal_utc = rhs._int_cal_utc; _num_valid_cal_pulses = rhs._num_valid_cal_pulses; _num_valid_noise_pulses = rhs._num_valid_noise_pulses; _num_valid_replicas = rhs._num_valid_replicas; _first_replica_sample = rhs._first_replica_sample; _mean_cal_pulse_power = rhs._mean_cal_pulse_power; _mean_noise_power = rhs._mean_noise_power; _range_comp_norm_fact = rhs._range_comp_norm_fact; _replica_power = rhs._replica_power; _first_range_pixel_mid_az_inc = rhs._first_range_pixel_mid_az_inc; _center_range_pix_mid_az_inc = rhs._center_range_pix_mid_az_inc; _last_range_pix_mid_az_inc = rhs._last_range_pix_mid_az_inc; _norm_ref_range_ro = rhs._norm_ref_range_ro; _antenna_elev_flag = rhs._antenna_elev_flag; _abs_cal_const_K = rhs._abs_cal_const_K; _upp_bound_K = rhs._upp_bound_K; _low_bound_K = rhs._low_bound_K; _proc_noise_scale_fact = rhs._proc_noise_scale_fact; _K_gen_date = rhs._K_gen_date; _K_vers_num = rhs._K_vers_num; _num_duplic_input_lines = rhs._num_duplic_input_lines; _estim_bit_error_rate = rhs._estim_bit_error_rate; _out_image_mean = rhs._out_image_mean; _out_image_std_dev = rhs._out_image_std_dev; _out_image_max_value = rhs._out_image_max_value; _time_raw_data_first_input = rhs._time_raw_data_first_input; _time_asc_node_state_vectors = rhs._time_asc_node_state_vectors; _asc_node_pos_X_comp = rhs._asc_node_pos_X_comp; _asc_node_pos_Y_comp = rhs._asc_node_pos_Y_comp; _asc_node_pos_Z_comp = rhs._asc_node_pos_Z_comp; _asc_node_vel_X_comp = rhs._asc_node_vel_X_comp; _asc_node_vel_Y_comp = rhs._asc_node_vel_Y_comp; _asc_node_vel_Z_comp = rhs._asc_node_vel_Z_comp; _out_pixel_bit_length = rhs._out_pixel_bit_length; _proc_gain_param_1 = rhs._proc_gain_param_1; _proc_gain_param_2 = rhs._proc_gain_param_2; _proc_gain_param_3 = rhs._proc_gain_param_3; _peak_loc_cross_correl_fun = rhs._peak_loc_cross_correl_fun; _3_dB_width_CCF = rhs._3_dB_width_CCF; _first_side_lobe_level = rhs._first_side_lobe_level; _ISLR_CCF_between_last = rhs._ISLR_CCF_between_last; _peak_loc_CCF_betw_last = rhs._peak_loc_CCF_betw_last; _Roll_Tilt_Mode_flag = rhs._Roll_Tilt_Mode_flag; _raw_data_correction_flag = rhs._raw_data_correction_flag; _look_detecion_flag = rhs._look_detecion_flag; _doppler_ambiguity_estimat_flag = rhs._doppler_ambiguity_estimat_flag; _azimuth_baseband_convers_flag = rhs._azimuth_baseband_convers_flag; _samples_per_line_used = rhs._samples_per_line_used; _range_lines_skip_factor = rhs._range_lines_skip_factor; _time_of_inp_state_vectors = rhs._time_of_inp_state_vectors; _inp_state_vect_pos_X_comp = rhs._inp_state_vect_pos_X_comp; _inp_state_vect_pos_Y_comp = rhs._inp_state_vect_pos_Y_comp; _inp_state_vect_pos_Z_comp = rhs._inp_state_vect_pos_Z_comp; _inp_state_vect_vel_Vx_comp = rhs._inp_state_vect_vel_Vx_comp; _inp_state_vect_vel_Vy_comp = rhs._inp_state_vect_vel_Vy_comp; _inp_state_vect_vel_Vz_comp = rhs._inp_state_vect_vel_Vz_comp; _inp_state_vector_type_flag = rhs._inp_state_vector_type_flag; _win_coeff_for_range_match = rhs._win_coeff_for_range_match; _win_coeff_for_azi_match = rhs._win_coeff_for_azi_match; _update_period_range_match = rhs._update_period_range_match; _look_scalar_gain_1 = rhs._look_scalar_gain_1; _look_scalar_gain_2 = rhs._look_scalar_gain_2; _look_scalar_gain_3 = rhs._look_scalar_gain_3; _look_scalar_gain_4 = rhs._look_scalar_gain_4; _look_scalar_gain_5 = rhs._look_scalar_gain_5; _look_scalar_gain_6 = rhs._look_scalar_gain_6; _look_scalar_gain_7 = rhs._look_scalar_gain_7; _look_scalar_gain_8 = rhs._look_scalar_gain_8; _samp_window_start_time_bias = rhs._samp_window_start_time_bias; _doppler_centroid_cubic_coeff = rhs._doppler_centroid_cubic_coeff; _PRF_code_first_range_line = rhs._PRF_code_first_range_line; _PRF_code_last_range_line = rhs._PRF_code_last_range_line; _samp_win_start_first = rhs._samp_win_start_first; _samp_win_start_last = rhs._samp_win_start_last; _cal_syst_gain_last_proc = rhs._cal_syst_gain_last_proc; _receiver_gain_last_proc = rhs._receiver_gain_last_proc; _first_processed_range_sample = rhs._first_processed_range_sample; _azimuth_FFT_IFFT_ratio = rhs._azimuth_FFT_IFFT_ratio; _num_azimuth_blocks_proc = rhs._num_azimuth_blocks_proc; _num_input_raw_data_lines = rhs._num_input_raw_data_lines; _initial_doppler_ambiguity_num = rhs._initial_doppler_ambiguity_num; _thresh_no_1_flag = rhs._thresh_no_1_flag; _thresh_no_2_flag = rhs._thresh_no_2_flag; _thresh_no_3_flag = rhs._thresh_no_3_flag; _thresh_no_4_flag = rhs._thresh_no_4_flag; _thresh_no_5_flag = rhs._thresh_no_5_flag; _thresh_no_6_flag = rhs._thresh_no_6_flag; _thresh_no_7_flag = rhs._thresh_no_7_flag; _thresh_no_8_flag = rhs._thresh_no_8_flag; _thresh_no_9_flag = rhs._thresh_no_9_flag; _thresh_no_10_flag = rhs._thresh_no_10_flag; _thresh_no_11_flag = rhs._thresh_no_11_flag; _sat_binary_time_of_first = rhs._sat_binary_time_of_first; _num_valid_pixels_per_range = rhs._num_valid_pixels_per_range; _num_range_samp_discarded = rhs._num_range_samp_discarded; _I_gain_imb_lower_bound = rhs._I_gain_imb_lower_bound; _I_gain_imb_upper_bound = rhs._I_gain_imb_upper_bound; _I_Q_quad_depar_lower_bound = rhs._I_Q_quad_depar_lower_bound; _I_Q_quad_depar_upper_bound = rhs._I_Q_quad_depar_upper_bound; _3_dB_look_bandwidth = rhs._3_dB_look_bandwidth; _3_dB_look_proc_dopp_bandw = rhs._3_dB_look_proc_dopp_bandw; _range_spread_loss_comp_flag = rhs._range_spread_loss_comp_flag; _datation_flag = rhs._datation_flag; _max_error_range_line_timing = rhs._max_error_range_line_timing; _form_num_range_line_used = rhs._form_num_range_line_used; _autom_look_scal_gain_flag = rhs._autom_look_scal_gain_flag; _max_value_look_scalar_gain = rhs._max_value_look_scalar_gain; _replica_norm_method_flag = rhs._replica_norm_method_flag; _coef_ground_range_1 = rhs._coef_ground_range_1; _coef_ground_range_2 = rhs._coef_ground_range_2; _coef_ground_range_3 = rhs._coef_ground_range_3; _coef_ground_range_4 = rhs._coef_ground_range_4; _coef_ant_elev_1 = rhs._coef_ant_elev_1; _coef_ant_elev_2 = rhs._coef_ant_elev_2; _coef_ant_elev_3 = rhs._coef_ant_elev_3; _coef_ant_elev_4 = rhs._coef_ant_elev_4; _coef_ant_elev_5 = rhs._coef_ant_elev_5; _range_time_origin_ant = rhs._range_time_origin_ant; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarFacilityData.h000066400000000000000000001022101301006202600306170ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarFacilityData_h #define ErsSarFacilityData_h #include #include #include "erssar/ErsSarRecordHeader.h" #include "erssar/ErsSarRecord.h" namespace ossimplugins { /** * @ingroup ErsSarFacilityDataRecord * @brief This class is able to read the SAR leader data set summary record of the leader file * */ class ErsSarFacilityData : public ErsSarRecord { public: /** * @brief Constructor */ ErsSarFacilityData(); /** * @brief Destructor */ virtual ~ErsSarFacilityData(); /** * @brief This function write the ErsSarFacilityData in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarFacilityData& data); /** * @brief This function read a ErsSarFacilityData from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarFacilityData& data); /** * @brief Copy constructor */ ErsSarFacilityData(const ErsSarFacilityData& rhs); /** * @brief Copy operator */ ErsSarFacilityData& operator=(const ErsSarFacilityData& rhs); /** * @brief This function is able to create a new instance of the class */ ErsSarRecord* Instantiate() { return new ErsSarFacilityData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ ErsSarRecord* Clone() { return new ErsSarFacilityData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief name_of_facil_rec */ std::string get_name_of_facil_rec() const { return _name_of_facil_rec; }; /** * @brief last_release_qc_date */ std::string get_last_release_qc_date() const { return _last_release_qc_date; }; /** * @brief last_release_cal_date */ std::string get_last_release_cal_date() const { return _last_release_cal_date; }; /** * @brief qa_summary_flag */ int get_qa_summary_flag() const { return _qa_summary_flag; }; /** * @brief prf_code_change_flag */ int get_prf_code_change_flag() const { return _prf_code_change_flag; }; /** * @brief sampling_win_change_flag */ int get_sampling_win_change_flag() const { return _sampling_win_change_flag; }; /** * @brief cal_gain_change_flag */ int get_cal_gain_change_flag() const { return _cal_gain_change_flag; }; /** * @brief quirp_qu_flag */ int get_quirp_qu_flag() const { return _quirp_qu_flag; }; /** * @brief inp_data_stat_flag */ int get_inp_data_stat_flag() const { return _inp_data_stat_flag; }; /** * @brief dopp_cent_conf_meas_flag */ int get_dopp_cent_conf_meas_flag() const { return _dopp_cent_conf_meas_flag; }; /** * @brief dopp_cent_val_flag */ int get_dopp_cent_val_flag() const { return _dopp_cent_val_flag; }; /** * @brief dopp_ambig_conf_meas_flag */ int get_dopp_ambig_conf_meas_flag() const { return _dopp_ambig_conf_meas_flag; }; /** * @brief outp_data_mean_flag */ int get_outp_data_mean_flag() const { return _outp_data_mean_flag; }; /** * @brief OGOB_flag */ int get_OGOB_flag() const { return _OGOB_flag; }; /** * @brief PRF_changes */ int get_PRF_changes() const { return _PRF_changes; }; /** * @brief sampling_win_changes */ int get_sampling_win_changes() const { return _sampling_win_changes; }; /** * @brief cal_gain_changes */ int get_cal_gain_changes() const { return _cal_gain_changes; }; /** * @brief missing_lines */ int get_missing_lines() const { return _missing_lines; }; /** * @brief rec_gain_changes */ int get_rec_gain_changes() const { return _rec_gain_changes; }; /** * @brief pulse_width_of_ACF_3db */ double get_pulse_width_of_ACF_3db() const { return _pulse_width_of_ACF_3db; }; /** * @brief first_side_lobe_lev_of_ACF */ double get_first_side_lobe_lev_of_ACF() const { return _first_side_lobe_lev_of_ACF; }; /** * @brief ISLR_of_ACF */ double get_ISLR_of_ACF() const { return _ISLR_of_ACF; }; /** * @brief dopp_cent_conf_meas */ double get_dopp_cent_conf_meas() const { return _dopp_cent_conf_meas; }; /** * @brief dopp_ambig_conf_meas */ double get_dopp_ambig_conf_meas() const { return _dopp_ambig_conf_meas; }; /** * @brief inp_data_I_mean */ double get_inp_data_I_mean() const { return _inp_data_I_mean; }; /** * @brief inp_data_Q_mean */ double get_inp_data_Q_mean() const { return _inp_data_Q_mean; }; /** * @brief inp_data_I_stddev */ double get_inp_data_I_stddev() const { return _inp_data_I_stddev; }; /** * @brief inp_data_Q_stddev */ double get_inp_data_Q_stddev() const { return _inp_data_Q_stddev; }; /** * @brief cal_sys_gain */ double get_cal_sys_gain() const { return _cal_sys_gain; }; /** * @brief first_rec_gain_read */ double get_first_rec_gain_read() const { return _first_rec_gain_read; }; /** * @brief dopp_ambig_num */ double get_dopp_ambig_num() const { return _dopp_ambig_num; }; /** * @brief I_channel_bias_correction */ double get_I_channel_bias_correction() const { return _I_channel_bias_correction; }; /** * @brief Q_channel_bias_correction */ double get_Q_channel_bias_correction() const { return _Q_channel_bias_correction; }; /** * @brief I_channel_gain_correction */ double get_I_channel_gain_correction() const { return _I_channel_gain_correction; }; /** * @brief Q_channel_gain_correction */ double get_Q_channel_gain_correction() const { return _Q_channel_gain_correction; }; /** * @brief Q_channel_I_Q_correction */ double get_Q_channel_I_Q_correction() const { return _Q_channel_I_Q_correction; }; /** * @brief noise_power */ double get_noise_power() const { return _noise_power; }; /** * @brief int_cal_utc */ int get_int_cal_utc() const { return _int_cal_utc; }; /** * @brief num_valid_cal_pulses */ int get_num_valid_cal_pulses() const { return _num_valid_cal_pulses; }; /** * @brief num_valid_noise_pulses */ int get_num_valid_noise_pulses() const { return _num_valid_noise_pulses; }; /** * @brief num_valid_replicas */ int get_num_valid_replicas() const { return _num_valid_replicas; }; /** * @brief first_replica_sample */ double get_first_replica_sample() const { return _first_replica_sample; }; /** * @brief mean_cal_pulse_power */ double get_mean_cal_pulse_power() const { return _mean_cal_pulse_power; }; /** * @brief mean_noise_power */ double get_mean_noise_power() const { return _mean_noise_power; }; /** * @brief range_comp_norm_fact */ double get_range_comp_norm_fact() const { return _range_comp_norm_fact; }; /** * @brief replica_power */ double get_replica_power() const { return _replica_power; }; /** * @brief first_range_pixel_mid_az_inc */ double get_first_range_pixel_mid_az_inc() const { return _first_range_pixel_mid_az_inc; }; /** * @brief center_range_pix_mid_az_inc */ double get_center_range_pix_mid_az_inc() const { return _center_range_pix_mid_az_inc; }; /** * @brief last_range_pix_mid_az_inc */ double get_last_range_pix_mid_az_inc() const { return _last_range_pix_mid_az_inc; }; /** * @brief norm_ref_range_ro */ double get_norm_ref_range_ro() const { return _norm_ref_range_ro; }; /** * @brief antenna_elev_flag */ int get_antenna_elev_flag() const { return _antenna_elev_flag; }; /** * @brief abs_cal_const_K */ double get_abs_cal_const_K() const { return _abs_cal_const_K; }; /** * @brief upp_bound_K */ double get_upp_bound_K() const { return _upp_bound_K; }; /** * @brief low_bound_K */ double get_low_bound_K() const { return _low_bound_K; }; /** * @brief proc_noise_scale_fact */ double get_proc_noise_scale_fact() const { return _proc_noise_scale_fact; }; /** * @brief K_gen_date */ std::string get_K_gen_date() const { return _K_gen_date; }; /** * @brief K_vers_num */ std::string get_K_vers_num() const { return _K_vers_num; }; /** * @brief num_duplic_input_lines */ int get_num_duplic_input_lines() const { return _num_duplic_input_lines; }; /** * @brief estim_bit_error_rate */ double get_estim_bit_error_rate() const { return _estim_bit_error_rate; }; /** * @brief out_image_mean */ double get_out_image_mean() const { return _out_image_mean; }; /** * @brief out_image_std_dev */ double get_out_image_std_dev() const { return _out_image_std_dev; }; /** * @brief out_image_max_value */ double get_out_image_max_value() const { return _out_image_max_value; }; /** * @brief time_raw_data_first_input */ std::string get_time_raw_data_first_input() const { return _time_raw_data_first_input; }; /** * @brief time_asc_node_state_vectors */ std::string get_time_asc_node_state_vectors() const { return _time_asc_node_state_vectors; }; /** * @brief asc_node_pos_X_comp */ std::string get_asc_node_pos_X_comp() const { return _asc_node_pos_X_comp; }; /** * @brief asc_node_pos_Y_comp */ std::string get_asc_node_pos_Y_comp() const { return _asc_node_pos_Y_comp; }; /** * @brief asc_node_pos_Z_comp */ std::string get_asc_node_pos_Z_comp() const { return _asc_node_pos_Z_comp; }; /** * @brief asc_node_vel_X_comp */ std::string get_asc_node_vel_X_comp() const { return _asc_node_vel_X_comp; }; /** * @brief asc_node_vel_Y_comp */ std::string get_asc_node_vel_Y_comp() const { return _asc_node_vel_Y_comp; }; /** * @brief asc_node_vel_Z_comp */ std::string get_asc_node_vel_Z_comp() const { return _asc_node_vel_Z_comp; }; /** * @brief out_pixel_bit_length */ int get_out_pixel_bit_length() const { return _out_pixel_bit_length; }; /** * @brief proc_gain_param_1 */ double get_proc_gain_param_1() const { return _proc_gain_param_1; }; /** * @brief proc_gain_param_2 */ double get_proc_gain_param_2() const { return _proc_gain_param_2; }; /** * @brief proc_gain_param_3 */ double get_proc_gain_param_3() const { return _proc_gain_param_3; }; /** * @brief peak_loc_cross_correl_fun */ int get_peak_loc_cross_correl_fun() const { return _peak_loc_cross_correl_fun; }; /** * @brief 3_dB_width_CCF */ double get_3_dB_width_CCF() const { return _3_dB_width_CCF; }; /** * @brief first_side_lobe_level */ double get_first_side_lobe_level() const { return _first_side_lobe_level; }; /** * @brief ISLR_CCF_between_last */ double get_ISLR_CCF_between_last() const { return _ISLR_CCF_between_last; }; /** * @brief peak_loc_CCF_betw_last */ int get_peak_loc_CCF_betw_last() const { return _peak_loc_CCF_betw_last; }; /** * @brief Roll_Tilt_Mode_flag */ int get_Roll_Tilt_Mode_flag() const { return _Roll_Tilt_Mode_flag; }; /** * @brief raw_data_correction_flag */ int get_raw_data_correction_flag() const { return _raw_data_correction_flag; }; /** * @brief look_detecion_flag */ int get_look_detecion_flag() const { return _look_detecion_flag; }; /** * @brief doppler_ambiguity_estimat_flag */ int get_doppler_ambiguity_estimat_flag() const { return _doppler_ambiguity_estimat_flag; }; /** * @brief azimuth_baseband_convers_flag */ int get_azimuth_baseband_convers_flag() const { return _azimuth_baseband_convers_flag; }; /** * @brief samples_per_line_used */ int get_samples_per_line_used() const { return _samples_per_line_used; }; /** * @brief range_lines_skip_factor */ int get_range_lines_skip_factor() const { return _range_lines_skip_factor; }; /** * @brief time_of_inp_state_vectors */ std::string get_time_of_inp_state_vectors() const { return _time_of_inp_state_vectors; }; /** * @brief inp_state_vect_pos_X_comp */ std::string get_inp_state_vect_pos_X_comp() const { return _inp_state_vect_pos_X_comp; }; /** * @brief inp_state_vect_pos_Y_comp */ std::string get_inp_state_vect_pos_Y_comp() const { return _inp_state_vect_pos_Y_comp; }; /** * @brief inp_state_vect_pos_Z_comp */ std::string get_inp_state_vect_pos_Z_comp() const { return _inp_state_vect_pos_Z_comp; }; /** * @brief inp_state_vect_vel_Vx_comp */ std::string get_inp_state_vect_vel_Vx_comp() const { return _inp_state_vect_vel_Vx_comp; }; /** * @brief inp_state_vect_vel_Vy_comp */ std::string get_inp_state_vect_vel_Vy_comp() const { return _inp_state_vect_vel_Vy_comp; }; /** * @brief inp_state_vect_vel_Vz_comp */ std::string get_inp_state_vect_vel_Vz_comp() const { return _inp_state_vect_vel_Vz_comp; }; /** * @brief inp_state_vector_type_flag */ int get_inp_state_vector_type_flag() const { return _inp_state_vector_type_flag; }; /** * @brief win_coeff_for_range_match */ double get_win_coeff_for_range_match() const { return _win_coeff_for_range_match; }; /** * @brief win_coeff_for_azi_match */ double get_win_coeff_for_azi_match() const { return _win_coeff_for_azi_match; }; /** * @brief update_period_range_match */ int get_update_period_range_match() const { return _update_period_range_match; }; /** * @brief look_scalar_gain_1 */ double get_look_scalar_gain_1() const { return _look_scalar_gain_1; }; /** * @brief look_scalar_gain_2 */ double get_look_scalar_gain_2() const { return _look_scalar_gain_2; }; /** * @brief look_scalar_gain_3 */ double get_look_scalar_gain_3() const { return _look_scalar_gain_3; }; /** * @brief look_scalar_gain_4 */ double get_look_scalar_gain_4() const { return _look_scalar_gain_4; }; /** * @brief look_scalar_gain_5 */ double get_look_scalar_gain_5() const { return _look_scalar_gain_5; }; /** * @brief look_scalar_gain_6 */ double get_look_scalar_gain_6() const { return _look_scalar_gain_6; }; /** * @brief look_scalar_gain_7 */ double get_look_scalar_gain_7() const { return _look_scalar_gain_7; }; /** * @brief look_scalar_gain_8 */ double get_look_scalar_gain_8() const { return _look_scalar_gain_8; }; /** * @brief samp_window_start_time_bias */ int get_samp_window_start_time_bias() const { return _samp_window_start_time_bias; }; /** * @brief doppler_centroid_cubic_coeff */ double get_doppler_centroid_cubic_coeff() const { return _doppler_centroid_cubic_coeff; }; /** * @brief PRF_code_first_range_line */ int get_PRF_code_first_range_line() const { return _PRF_code_first_range_line; }; /** * @brief PRF_code_last_range_line */ int get_PRF_code_last_range_line() const { return _PRF_code_last_range_line; }; /** * @brief samp_win_start_first */ int get_samp_win_start_first() const { return _samp_win_start_first; }; /** * @brief samp_win_start_last */ int get_samp_win_start_last() const { return _samp_win_start_last; }; /** * @brief cal_syst_gain_last_proc */ int get_cal_syst_gain_last_proc() const { return _cal_syst_gain_last_proc; }; /** * @brief receiver_gain_last_proc */ int get_receiver_gain_last_proc() const { return _receiver_gain_last_proc; }; /** * @brief first_processed_range_sample */ int get_first_processed_range_sample() const { return _first_processed_range_sample; }; /** * @brief azimuth_FFT_IFFT_ratio */ int get_azimuth_FFT_IFFT_ratio() const { return _azimuth_FFT_IFFT_ratio; }; /** * @brief num_azimuth_blocks_proc */ int get_num_azimuth_blocks_proc() const { return _num_azimuth_blocks_proc; }; /** * @brief num_input_raw_data_lines */ int get_num_input_raw_data_lines() const { return _num_input_raw_data_lines; }; /** * @brief initial_doppler_ambiguity_num */ int get_initial_doppler_ambiguity_num() const { return _initial_doppler_ambiguity_num; }; /** * @brief thresh_no_1_flag */ double get_thresh_no_1_flag() const { return _thresh_no_1_flag; }; /** * @brief thresh_no_2_flag */ double get_thresh_no_2_flag() const { return _thresh_no_2_flag; }; /** * @brief thresh_no_3_flag */ double get_thresh_no_3_flag() const { return _thresh_no_3_flag; }; /** * @brief thresh_no_4_flag */ double get_thresh_no_4_flag() const { return _thresh_no_4_flag; }; /** * @brief thresh_no_5_flag */ double get_thresh_no_5_flag() const { return _thresh_no_5_flag; }; /** * @brief thresh_no_6_flag */ double get_thresh_no_6_flag() const { return _thresh_no_6_flag; }; /** * @brief thresh_no_7_flag */ double get_thresh_no_7_flag() const { return _thresh_no_7_flag; }; /** * @brief thresh_no_8_flag */ double get_thresh_no_8_flag() const { return _thresh_no_8_flag; }; /** * @brief thresh_no_9_flag */ double get_thresh_no_9_flag() const { return _thresh_no_9_flag; }; /** * @brief thresh_no_10_flag */ double get_thresh_no_10_flag() const { return _thresh_no_10_flag; }; /** * @brief thresh_no_11_flag */ double get_thresh_no_11_flag() const { return _thresh_no_11_flag; }; /** * @brief sat_binary_time_of_first */ int get_sat_binary_time_of_first() const { return _sat_binary_time_of_first; }; /** * @brief num_valid_pixels_per_range */ int get_num_valid_pixels_per_range() const { return _num_valid_pixels_per_range; }; /** * @brief num_range_samp_discarded */ int get_num_range_samp_discarded() const { return _num_range_samp_discarded; }; /** * @brief I_gain_imb_lower_bound */ double get_I_gain_imb_lower_bound() const { return _I_gain_imb_lower_bound; }; /** * @brief I_gain_imb_upper_bound */ double get_I_gain_imb_upper_bound() const { return _I_gain_imb_upper_bound; }; /** * @brief I_Q_quad_depar_lower_bound */ double get_I_Q_quad_depar_lower_bound() const { return _I_Q_quad_depar_lower_bound; }; /** * @brief I_Q_quad_depar_upper_bound */ double get_I_Q_quad_depar_upper_bound() const { return _I_Q_quad_depar_upper_bound; }; /** * @brief 3_dB_look_bandwidth */ double get_3_dB_look_bandwidth() const { return _3_dB_look_bandwidth; }; /** * @brief 3_dB_look_proc_dopp_bandw */ double get_3_dB_look_proc_dopp_bandw() const { return _3_dB_look_proc_dopp_bandw; }; /** * @brief range_spread_loss_comp_flag */ int get_range_spread_loss_comp_flag() const { return _range_spread_loss_comp_flag; }; /** * @brief datation_flag */ bool get_datation_flag() const { return _datation_flag; }; /** * @brief max_error_range_line_timing */ int get_max_error_range_line_timing() const { return _max_error_range_line_timing; }; /** * @brief form_num_range_line_used */ int get_form_num_range_line_used() const { return _form_num_range_line_used; }; /** * @brief autom_look_scal_gain_flag */ bool get_autom_look_scal_gain_flag() const { return _autom_look_scal_gain_flag; }; /** * @brief max_value_look_scalar_gain */ int get_max_value_look_scalar_gain() const { return _max_value_look_scalar_gain; }; /** * @brief replica_norm_method_flag */ int get_replica_norm_method_flag() const { return _replica_norm_method_flag; }; /** * @brief coef_ground_range_1 */ double get_coef_ground_range_1() const { return _coef_ground_range_1; }; /** * @brief coef_ground_range_2 */ double get_coef_ground_range_2() const { return _coef_ground_range_2; }; /** * @brief coef_ground_range_3 */ double get_coef_ground_range_3() const { return _coef_ground_range_3; }; /** * @brief coef_ground_range_4 */ double get_coef_ground_range_4() const { return _coef_ground_range_4; }; /** * @brief coef_ant_elev_1 */ double get_coef_ant_elev_1() const { return _coef_ant_elev_1; }; /** * @brief coef_ant_elev_2 */ double get_coef_ant_elev_2() const { return _coef_ant_elev_2; }; /** * @brief coef_ant_elev_3 */ double get_coef_ant_elev_3() const { return _coef_ant_elev_3; }; /** * @brief coef_ant_elev_4 */ double get_coef_ant_elev_4() const { return _coef_ant_elev_4; }; /** * @brief coef_ant_elev_5 */ double get_coef_ant_elev_5() const { return _coef_ant_elev_5; }; /** * @brief range_time_origin_ant */ double get_range_time_origin_ant() const { return _range_time_origin_ant; }; protected: /** * @brief last_release_qc_date */ std::string _name_of_facil_rec; /** * @brief last_release_qc_date */ std::string _last_release_qc_date; /** * @brief last_release_cal_date */ std::string _last_release_cal_date; /** * @brief qa_summary_flag */ int _qa_summary_flag; /** * @brief prf_code_change_flag */ int _prf_code_change_flag; /** * @brief sampling_win_change_flag */ int _sampling_win_change_flag; /** * @brief cal_gain_change_flag */ int _cal_gain_change_flag; /** * @brief quirp_qu_flag */ int _quirp_qu_flag; /** * @brief inp_data_stat_flag */ int _inp_data_stat_flag; /** * @brief dopp_cent_conf_meas_flag */ int _dopp_cent_conf_meas_flag; /** * @brief dopp_cent_val_flag */ int _dopp_cent_val_flag; /** * @brief dopp_ambig_conf_meas_flag */ int _dopp_ambig_conf_meas_flag; /** * @brief outp_data_mean_flag */ int _outp_data_mean_flag; /** * @brief OGOB_flag */ int _OGOB_flag; /** * @brief PRF_changes */ int _PRF_changes; /** * @brief sampling_win_changes */ int _sampling_win_changes; /** * @brief cal_gain_changes */ int _cal_gain_changes; /** * @brief missing_lines */ int _missing_lines; /** * @brief rec_gain_changes */ int _rec_gain_changes; /** * @brief pulse_width_of_ACF_3db */ double _pulse_width_of_ACF_3db; /** * @brief first_side_lobe_lev_of_ACF */ double _first_side_lobe_lev_of_ACF; /** * @brief ISLR_of_ACF */ double _ISLR_of_ACF; /** * @brief dopp_cent_conf_meas */ double _dopp_cent_conf_meas; /** * @brief dopp_ambig_conf_meas */ double _dopp_ambig_conf_meas; /** * @brief inp_data_I_mean */ double _inp_data_I_mean; /** * @brief inp_data_Q_mean */ double _inp_data_Q_mean; /** * @brief inp_data_I_stddev */ double _inp_data_I_stddev; /** * @brief inp_data_Q_stddev */ double _inp_data_Q_stddev; /** * @brief cal_sys_gain */ double _cal_sys_gain; /** * @brief first_rec_gain_read */ double _first_rec_gain_read; /** * @brief dopp_ambig_num */ double _dopp_ambig_num; /** * @brief I_channel_bias_correction */ double _I_channel_bias_correction; /** * @brief Q_channel_bias_correction */ double _Q_channel_bias_correction; /** * @brief I_channel_gain_correction */ double _I_channel_gain_correction; /** * @brief Q_channel_gain_correction */ double _Q_channel_gain_correction; /** * @brief Q_channel_I_Q_correction */ double _Q_channel_I_Q_correction; /** * @brief noise_power */ double _noise_power; /** * @brief int_cal_utc */ int _int_cal_utc; /** * @brief num_valid_cal_pulses */ int _num_valid_cal_pulses; /** * @brief num_valid_noise_pulses */ int _num_valid_noise_pulses; /** * @brief num_valid_replicas */ int _num_valid_replicas; /** * @brief first_replica_sample */ double _first_replica_sample; /** * @brief mean_cal_pulse_power */ double _mean_cal_pulse_power; /** * @brief mean_noise_power */ double _mean_noise_power; /** * @brief range_comp_norm_fact */ double _range_comp_norm_fact; /** * @brief replica_power */ double _replica_power; /** * @brief first_range_pixel_mid_az_inc */ double _first_range_pixel_mid_az_inc; /** * @brief center_range_pix_mid_az_inc */ double _center_range_pix_mid_az_inc; /** * @brief last_range_pix_mid_az_inc */ double _last_range_pix_mid_az_inc; /** * @brief norm_ref_range_ro */ double _norm_ref_range_ro; /** * @brief antenna_elev_flag */ int _antenna_elev_flag; /** * @brief abs_cal_const_K */ double _abs_cal_const_K; /** * @brief upp_bound_K */ double _upp_bound_K; /** * @brief low_bound_K */ double _low_bound_K; /** * @brief proc_noise_scale_fact */ double _proc_noise_scale_fact; /** * @brief K_gen_date */ std::string _K_gen_date; /** * @brief K_vers_num */ std::string _K_vers_num; /** * @brief num_duplic_input_lines */ int _num_duplic_input_lines; /** * @brief estim_bit_error_rate */ double _estim_bit_error_rate; /** * @brief out_image_mean */ double _out_image_mean; /** * @brief out_image_std_dev */ double _out_image_std_dev; /** * @brief out_image_max_value */ double _out_image_max_value; /** * @brief time_raw_data_first_input */ std::string _time_raw_data_first_input; /** * @brief time_asc_node_state_vectors */ std::string _time_asc_node_state_vectors; /** * @brief asc_node_pos_X_comp */ std::string _asc_node_pos_X_comp; /** * @brief asc_node_pos_Y_comp */ std::string _asc_node_pos_Y_comp; /** * @brief asc_node_pos_Z_comp */ std::string _asc_node_pos_Z_comp; /** * @brief asc_node_vel_X_comp */ std::string _asc_node_vel_X_comp; /** * @brief asc_node_vel_Y_comp */ std::string _asc_node_vel_Y_comp; /** * @brief asc_node_vel_Z_comp */ std::string _asc_node_vel_Z_comp; /** * @brief out_pixel_bit_length */ int _out_pixel_bit_length; /** * @brief proc_gain_param_1 */ double _proc_gain_param_1; /** * @brief proc_gain_param_2 */ double _proc_gain_param_2; /** * @brief proc_gain_param_3 */ double _proc_gain_param_3; /** * @brief peak_loc_cross_correl_fun */ int _peak_loc_cross_correl_fun; /** * @brief 3_dB_width_CCF */ double _3_dB_width_CCF; /** * @brief first_side_lobe_level */ double _first_side_lobe_level; /** * @brief ISLR_CCF_between_last */ double _ISLR_CCF_between_last; /** * @brief peak_loc_CCF_betw_last */ int _peak_loc_CCF_betw_last; /** * @brief Roll_Tilt_Mode_flag */ int _Roll_Tilt_Mode_flag; /** * @brief raw_data_correction_flag */ int _raw_data_correction_flag; /** * @brief look_detecion_flag */ int _look_detecion_flag; /** * @brief doppler_ambiguity_estimat_flag */ int _doppler_ambiguity_estimat_flag; /** * @brief azimuth_baseband_convers_flag */ int _azimuth_baseband_convers_flag; /** * @brief samples_per_line_used */ int _samples_per_line_used; /** * @brief range_lines_skip_factor */ int _range_lines_skip_factor; /** * @brief time_of_inp_state_vectors */ std::string _time_of_inp_state_vectors; /** * @brief inp_state_vect_pos_X_comp */ std::string _inp_state_vect_pos_X_comp; /** * @brief inp_state_vect_pos_Y_comp */ std::string _inp_state_vect_pos_Y_comp; /** * @brief inp_state_vect_pos_Z_comp */ std::string _inp_state_vect_pos_Z_comp; /** * @brief inp_state_vect_vel_Vx_comp */ std::string _inp_state_vect_vel_Vx_comp; /** * @brief inp_state_vect_vel_Vy_comp */ std::string _inp_state_vect_vel_Vy_comp; /** * @brief inp_state_vect_vel_Vz_comp */ std::string _inp_state_vect_vel_Vz_comp; /** * @brief inp_state_vector_type_flag */ int _inp_state_vector_type_flag; /** * @brief win_coeff_for_range_match */ double _win_coeff_for_range_match; /** * @brief win_coeff_for_azi_match */ double _win_coeff_for_azi_match; /** * @brief update_period_range_match */ int _update_period_range_match; /** * @brief look_scalar_gain_1 */ double _look_scalar_gain_1; /** * @brief look_scalar_gain_2 */ double _look_scalar_gain_2; /** * @brief look_scalar_gain_3 */ double _look_scalar_gain_3; /** * @brief look_scalar_gain_4 */ double _look_scalar_gain_4; /** * @brief look_scalar_gain_5 */ double _look_scalar_gain_5; /** * @brief look_scalar_gain_6 */ double _look_scalar_gain_6; /** * @brief look_scalar_gain_7 */ double _look_scalar_gain_7; /** * @brief look_scalar_gain_8 */ double _look_scalar_gain_8; /** * @brief samp_window_start_time_bias */ int _samp_window_start_time_bias; /** * @brief doppler_centroid_cubic_coeff */ double _doppler_centroid_cubic_coeff; /** * @brief PRF_code_first_range_line */ int _PRF_code_first_range_line; /** * @brief PRF_code_last_range_line */ int _PRF_code_last_range_line; /** * @brief samp_win_start_first */ int _samp_win_start_first; /** * @brief samp_win_start_last */ int _samp_win_start_last; /** * @brief cal_syst_gain_last_proc */ int _cal_syst_gain_last_proc; /** * @brief receiver_gain_last_proc */ int _receiver_gain_last_proc; /** * @brief first_processed_range_sample */ int _first_processed_range_sample; /** * @brief azimuth_FFT_IFFT_ratio */ int _azimuth_FFT_IFFT_ratio; /** * @brief num_azimuth_blocks_proc */ int _num_azimuth_blocks_proc; /** * @brief num_input_raw_data_lines */ int _num_input_raw_data_lines; /** * @brief initial_doppler_ambiguity_num */ int _initial_doppler_ambiguity_num; /** * @brief thresh_no_1_flag */ double _thresh_no_1_flag; /** * @brief thresh_no_2_flag */ double _thresh_no_2_flag; /** * @brief thresh_no_3_flag */ double _thresh_no_3_flag; /** * @brief thresh_no_4_flag */ double _thresh_no_4_flag; /** * @brief thresh_no_5_flag */ double _thresh_no_5_flag; /** * @brief thresh_no_6_flag */ double _thresh_no_6_flag; /** * @brief thresh_no_7_flag */ double _thresh_no_7_flag; /** * @brief thresh_no_8_flag */ double _thresh_no_8_flag; /** * @brief thresh_no_9_flag */ double _thresh_no_9_flag; /** * @brief thresh_no_10_flag */ double _thresh_no_10_flag; /** * @brief thresh_no_11_flag */ double _thresh_no_11_flag; /** * @brief sat_binary_time_of_first */ int _sat_binary_time_of_first; /** * @brief num_valid_pixels_per_range */ int _num_valid_pixels_per_range; /** * @brief num_range_samp_discarded */ int _num_range_samp_discarded; /** * @brief I_gain_imb_lower_bound */ double _I_gain_imb_lower_bound; /** * @brief I_gain_imb_upper_bound */ double _I_gain_imb_upper_bound; /** * @brief I_Q_quad_depar_lower_bound */ double _I_Q_quad_depar_lower_bound; /** * @brief I_Q_quad_depar_upper_bound */ double _I_Q_quad_depar_upper_bound; /** * @brief 3_dB_look_bandwidth */ double _3_dB_look_bandwidth; /** * @brief 3_dB_look_proc_dopp_bandw */ double _3_dB_look_proc_dopp_bandw; /** * @brief range_spread_loss_comp_flag */ int _range_spread_loss_comp_flag; /** * @brief datation_flag */ bool _datation_flag; /** * @brief max_error_range_line_timing */ int _max_error_range_line_timing; /** * @brief form_num_range_line_used */ int _form_num_range_line_used; /** * @brief autom_look_scal_gain_flag */ bool _autom_look_scal_gain_flag; /** * @brief max_value_look_scalar_gain */ int _max_value_look_scalar_gain; /** * @brief replica_norm_method_flag */ int _replica_norm_method_flag; /** * @brief coef_ground_range_1 */ double _coef_ground_range_1; /** * @brief coef_ground_range_2 */ double _coef_ground_range_2; /** * @brief coef_ground_range_3 */ double _coef_ground_range_3; /** * @brief coef_ground_range_4 */ double _coef_ground_range_4; /** * @brief coef_ant_elev_1 */ double _coef_ant_elev_1; /** * @brief coef_ant_elev_2 */ double _coef_ant_elev_2; /** * @brief coef_ant_elev_3 */ double _coef_ant_elev_3; /** * @brief coef_ant_elev_4 */ double _coef_ant_elev_4; /** * @brief coef_ant_elev_5 */ double _coef_ant_elev_5; /** * @brief range_time_origin_ant */ double _range_time_origin_ant; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarFileDescriptor.cpp000066400000000000000000000226051301006202600315430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarFileDescriptor.h" namespace ossimplugins { ErsSarFileDescriptor::ErsSarFileDescriptor() : ErsSarRecord("sar_desc_rec") { } ErsSarFileDescriptor::~ErsSarFileDescriptor() { } std::ostream& operator<<(std::ostream& os, const ErsSarFileDescriptor& data) { os << "ascii_flag:" << data._ascii_flag.c_str() << std::endl; os << "format_doc:" << data._format_doc.c_str() << std::endl; os << "format_ver:" << data._format_ver.c_str() << std::endl; os << "design_rev:" << data._design_rev.c_str() << std::endl; os << "software_id:" << data._software_id.c_str() << std::endl; os << "file_num:" << data._file_num << std::endl; os << "file_name:" << data._file_name.c_str() << std::endl; os << "rec_seq:" << data._rec_seq.c_str() << std::endl; os << "seq_loc:" << data._seq_loc << std::endl; os << "seq_len:" << data._seq_len << std::endl; os << "rec_code:" << data._rec_code.c_str() << std::endl; os << "code_loc:" << data._code_loc << std::endl; os << "code_len:" << data._code_len << std::endl; os << "rec_len:" << data._rec_len.c_str() << std::endl; os << "rlen_loc:" << data._rlen_loc << std::endl; os << "rlen_len:" << data._rlen_len << std::endl; os << "n_dataset:" << data._n_dataset << std::endl; os << "l_dataset:" << data._l_dataset << std::endl; os << "n_map_proj:" << data._n_map_proj << std::endl; os << "l_map_proj:" << data._l_map_proj << std::endl; os << "n_plat_pos:" << data._n_plat_pos << std::endl; os << "l_plat_pos:" << data._l_plat_pos << std::endl; os << "n_att_data:" << data._n_att_data << std::endl; os << "l_att_data:" << data._l_att_data << std::endl; os << "n_radi_data:" << data._n_radi_data << std::endl; os << "l_radi_data:" << data._l_radi_data << std::endl; os << "n_radi_comp:" << data._n_radi_comp << std::endl; os << "l_radi_comp:" << data._l_radi_comp << std::endl; os << "n_qual_sum:" << data._n_qual_sum << std::endl; os << "l_qual_sum:" << data._l_qual_sum << std::endl; os << "n_data_his:" << data._n_data_his << std::endl; os << "l_data_his:" << data._l_data_his << std::endl; os << "n_rang_spec:" << data._n_rang_spec << std::endl; os << "l_rang_spec:" << data._l_rang_spec << std::endl; os << "n_dem_desc:" << data._n_dem_desc << std::endl; os << "l_dem_desc:" << data._l_dem_desc << std::endl; os << "n_radar_par:" << data._n_radar_par << std::endl; os << "l_radar_par:" << data._l_radar_par << std::endl; os << "n_anno_data:" << data._n_anno_data << std::endl; os << "l_anno_data:" << data._l_anno_data << std::endl; os << "n_det_proc:" << data._n_det_proc << std::endl; os << "l_det_proc:" << data._l_det_proc << std::endl; os << "n_cal:" << data._n_cal << std::endl; os << "l_cal:" << data._l_cal << std::endl; os << "n_gcp:" << data._n_gcp << std::endl; os << "l_gcp:" << data._l_gcp << std::endl; os << "n_fac_data:" << data._n_fac_data << std::endl; os << "l_fac_data:" << data._l_fac_data << std::endl; return os; } std::istream& operator>>(std::istream& is, ErsSarFileDescriptor& data) { char buf2[3]; buf2[2] = '\0'; char buf12[13]; buf12[12] = '\0'; char buf16[17]; buf16[16] = '\0'; char buf4[5]; buf4[4] = '\0'; char buf6[7]; buf6[6] = '\0'; char buf8[9]; buf8[8] = '\0'; char buf64[65]; buf64[64] = '\0'; char buf60[61]; buf60[60] = '\0'; char buf288[289]; buf288[288] = '\0'; is.read(buf2, 2); data._ascii_flag = buf2; is.read(buf2, 2); is.read(buf12, 12); data._format_doc = buf12; is.read(buf2, 2); data._format_ver = buf2; is.read(buf2, 2); data._design_rev = buf2; is.read(buf12, 12); data._software_id = buf12; is.read(buf4, 4); data._file_num = atoi(buf4); is.read(buf16, 16); data._file_name = buf16; is.read(buf4, 4); data._rec_seq = buf4; is.read(buf8, 8); data._seq_loc = atoi(buf8); is.read(buf4, 4); data._seq_len = atoi(buf4); is.read(buf4, 4); data._rec_code = buf4; is.read(buf8, 8); data._code_loc = atoi(buf8); is.read(buf4, 4); data._code_len = atoi(buf4); is.read(buf4, 4); data._rec_len = buf4; is.read(buf8, 8); data._rlen_loc = atoi(buf8); is.read(buf4, 4); data._rlen_len = atoi(buf4); is.read(buf4, 4); is.read(buf64, 64); is.read(buf6, 6); data._n_dataset = atoi(buf6); is.read(buf6, 6); data._l_dataset = atoi(buf6); is.read(buf6, 6); data._n_map_proj = atoi(buf6); is.read(buf6, 6); data._l_map_proj = atoi(buf6); is.read(buf6, 6); data._n_plat_pos = atoi(buf6); is.read(buf6, 6); data._l_plat_pos = atoi(buf6); is.read(buf6, 6); data._n_att_data = atoi(buf6); is.read(buf6, 6); data._l_att_data = atoi(buf6); is.read(buf6, 6); data._n_radi_data = atoi(buf6); is.read(buf6, 6); data._l_radi_data = atoi(buf6); is.read(buf6, 6); data._n_radi_comp = atoi(buf6); is.read(buf6, 6); data._l_radi_comp = atoi(buf6); is.read(buf6, 6); data._n_qual_sum = atoi(buf6); is.read(buf6, 6); data._l_qual_sum = atoi(buf6); is.read(buf6, 6); data._n_data_his = atoi(buf6); is.read(buf6, 6); data._l_data_his = atoi(buf6); is.read(buf6, 6); data._n_rang_spec = atoi(buf6); is.read(buf6, 6); data._l_rang_spec = atoi(buf6); is.read(buf6, 6); data._n_dem_desc = atoi(buf6); is.read(buf6, 6); data._l_dem_desc = atoi(buf6); is.read(buf6, 6); data._n_radar_par = atoi(buf6); is.read(buf6, 6); data._l_radar_par = atoi(buf6); is.read(buf6, 6); data._n_anno_data = atoi(buf6); is.read(buf6, 6); data._l_anno_data = atoi(buf6); is.read(buf6, 6); data._n_det_proc = atoi(buf6); is.read(buf6, 6); data._l_det_proc = atoi(buf6); is.read(buf6, 6); data._n_cal = atoi(buf6); is.read(buf6, 6); data._l_cal = atoi(buf6); is.read(buf6, 6); data._n_gcp = atoi(buf6); is.read(buf6, 6); data._l_gcp = atoi(buf6); is.read(buf60, 60); is.read(buf6, 6); data._n_fac_data = atoi(buf6); is.read(buf6, 6); data._l_fac_data = atoi(buf6); is.read(buf288, 288); return is; } ErsSarFileDescriptor::ErsSarFileDescriptor(const ErsSarFileDescriptor& rhs): ErsSarRecord(rhs), _ascii_flag(rhs._ascii_flag), _format_doc(rhs._format_doc), _format_ver(rhs._format_ver), _design_rev(rhs._design_rev), _software_id(rhs._software_id), _file_num(rhs._file_num), _file_name(rhs._file_name), _rec_seq(rhs._rec_seq), _seq_loc(rhs._seq_loc), _seq_len(rhs._seq_len), _rec_code(rhs._rec_code), _code_loc(rhs._code_loc), _code_len(rhs._code_len), _rec_len(rhs._rec_len), _rlen_loc(rhs._rlen_loc), _rlen_len(rhs._rlen_len), _n_dataset(rhs._n_dataset), _l_dataset(rhs._l_dataset), _n_map_proj(rhs._n_map_proj), _l_map_proj(rhs._l_map_proj), _n_plat_pos(rhs._n_plat_pos), _l_plat_pos(rhs._l_plat_pos), _n_att_data(rhs._n_att_data), _l_att_data(rhs._l_att_data), _n_radi_data(rhs._n_radi_data), _l_radi_data(rhs._l_radi_data), _n_radi_comp(rhs._n_radi_comp), _l_radi_comp(rhs._l_radi_comp), _n_qual_sum(rhs._n_qual_sum), _l_qual_sum(rhs._l_qual_sum), _n_data_his(rhs._n_data_his), _l_data_his(rhs._l_data_his), _n_rang_spec(rhs._n_rang_spec), _l_rang_spec(rhs._l_rang_spec), _n_dem_desc(rhs._n_dem_desc), _l_dem_desc(rhs._l_dem_desc), _n_radar_par(rhs._n_radar_par), _l_radar_par(rhs._l_radar_par), _n_anno_data(rhs._n_anno_data), _l_anno_data(rhs._l_anno_data), _n_det_proc(rhs._n_det_proc), _l_det_proc(rhs._l_det_proc), _n_cal(rhs._n_cal), _l_cal(rhs._l_cal), _n_gcp(rhs._n_gcp), _l_gcp(rhs._l_gcp), _n_fac_data(rhs._n_fac_data), _l_fac_data(rhs._l_fac_data) { } ErsSarFileDescriptor& ErsSarFileDescriptor::operator=(const ErsSarFileDescriptor& rhs) { _ascii_flag = rhs._ascii_flag; _format_doc = rhs._format_doc; _format_ver = rhs._format_ver; _design_rev = rhs._design_rev; _software_id = rhs._software_id; _file_num = rhs._file_num; _file_name = rhs._file_name; _rec_seq = rhs._rec_seq; _seq_loc = rhs._seq_loc; _seq_len = rhs._seq_len; _rec_code = rhs._rec_code; _code_loc = rhs._code_loc; _code_len = rhs._code_len; _rec_len = rhs._rec_len; _rlen_loc = rhs._rlen_loc; _rlen_len = rhs._rlen_len; _n_dataset = rhs._n_dataset; _l_dataset = rhs._l_dataset; _n_map_proj = rhs._n_map_proj; _l_map_proj = rhs._l_map_proj; _n_plat_pos = rhs._n_plat_pos; _l_plat_pos = rhs._l_plat_pos; _n_att_data = rhs._n_att_data; _l_att_data = rhs._l_att_data; _n_radi_data = rhs._n_radi_data; _l_radi_data = rhs._l_radi_data; _n_radi_comp = rhs._n_radi_comp; _l_radi_comp = rhs._l_radi_comp; _n_qual_sum = rhs._n_qual_sum ; _l_qual_sum = rhs._l_qual_sum; _n_data_his = rhs._n_data_his; _l_data_his = rhs._l_data_his; _n_rang_spec = rhs._n_rang_spec; _l_rang_spec = rhs._l_rang_spec; _n_dem_desc = rhs._n_dem_desc; _l_dem_desc = rhs._l_dem_desc; _n_radar_par = rhs._n_radar_par; _l_radar_par = rhs._l_radar_par; _n_anno_data = rhs._n_anno_data; _l_anno_data = rhs._l_anno_data; _n_det_proc = rhs._n_det_proc; _l_det_proc = rhs._l_det_proc; _n_cal = rhs._n_cal; _l_cal = rhs._l_cal; _n_gcp = rhs._n_gcp; _l_gcp = rhs._l_gcp; _n_fac_data = rhs._n_fac_data; _l_fac_data = rhs._l_fac_data; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarFileDescriptor.h000066400000000000000000000256641301006202600312200ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarFileDescriptor_h #define ErsSarFileDescriptor_h #include #include #include "erssar/ErsSarRecordHeader.h" #include "erssar/ErsSarRecord.h" namespace ossimplugins { /** * @ingroup SARLeaderErsSarFileDescriptorRecord * @brief This class is able to read the SAR leader file descriptor record of the leader file * */ class ErsSarFileDescriptor : public ErsSarRecord { public: /** * @brief Constructor */ ErsSarFileDescriptor(); /** * @brief Destructor */ virtual ~ErsSarFileDescriptor(); /** * @brief This function write the ErsSarFileDescriptor in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarFileDescriptor& data); /** * @brief This function read a ErsSarFileDescriptor from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarFileDescriptor& data); /** * @brief Copy constructor */ ErsSarFileDescriptor(const ErsSarFileDescriptor& rhs); /** * @brief Copy operator */ ErsSarFileDescriptor& operator=(const ErsSarFileDescriptor& rhs); /** * @brief This function is able to create a new instance of the class */ ErsSarRecord* Instantiate() { return new ErsSarFileDescriptor(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ ErsSarRecord* Clone() { return new ErsSarFileDescriptor(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief ASCII flag */ std::string get_ascii_flag() const { return _ascii_flag; }; /** * @brief Format control documentation */ std::string get_format_doc() const { return _format_doc; }; /** * @brief Format doc version */ std::string get_format_ver() const { return _format_ver; }; /** * @brief Format doc revision */ std::string get_design_rev() const { return _design_rev; }; /** * @brief Software identifier */ std::string get_software_id() const { return _software_id; }; /** * @brief File number */ int get_file_num() const { return _file_num ; }; /** * @brief File name */ std::string get_file_name() const { return _file_name; }; /** * @brief Record sequence/location flag */ std::string get_rec_seq() const { return _rec_seq; }; /** * @brief Sequence number location */ int get_seq_loc() const { return _seq_loc; }; /** * @brief Sequence number length */ int get_seq_len() const { return _seq_len; }; /** * @brief Record code/location flag */ std::string get_rec_code() const { return _rec_code; }; /** * @brief Record code location */ int get_code_loc() const { return _code_loc; }; /** * @brief Record code length */ int get_code_len() const { return _code_len; }; /** * @brief Record length/location flag */ std::string get_rec_len() const { return _rec_len; }; /** * @brief Record length location */ int get_rlen_loc() const { return _rlen_loc; }; /** * @brief Record length, bytes */ int get_rlen_len() const { return _rlen_len; }; /** * @brief Number of dataset summ records */ int get_n_dataset() const { return _n_dataset; }; /** * @brief Data set summary record length, bytes */ int get_l_dataset() const { return _l_dataset; }; /** * @brief Number of map proj records */ int get_n_map_proj() const { return _n_map_proj; }; /** * @brief Map projection record length, bytes */ int get_l_map_proj() const { return _l_map_proj; }; /** * @brief Number of platform position records */ int get_n_plat_pos() const { return _n_plat_pos; }; /** * @brief Platform position record length, bytes */ int get_l_plat_pos() const { return _l_plat_pos; }; /** * @brief Number of attitude data records */ int get_n_att_data() const { return _n_att_data; }; /** * @brief Attitude data record length, bytes */ int get_l_att_data() const { return _l_att_data; }; /** * @brief Number of radiometric data records */ int get_n_radi_data() const { return _n_radi_data; }; /** * @brief Radiometric data record length, bytes */ int get_l_radi_data() const { return _l_radi_data; }; /** * @brief Number of radiometric compensation records */ int get_n_radi_comp() const { return _n_radi_comp; }; /** * @brief Radiometric compensation record length, bytes */ int get_l_radi_comp() const { return _l_radi_comp; }; /** * @brief Number of data quality summary records */ int get_n_qual_sum() const { return _n_qual_sum; }; /** * @brief Data quality summary record length, bytes */ int get_l_qual_sum() const { return _l_qual_sum; }; /** * @brief Number of data histogram records */ int get_n_data_his() const { return _n_data_his; }; /** * @brief Data histogram record length, bytes */ int get_l_data_his() const { return _l_data_his; }; /** * @brief Number of range spectra records */ int get_n_rang_spec() const { return _n_rang_spec ; }; /** * @brief Range spectra record length, bytes */ int get_l_rang_spec() const { return _l_rang_spec; }; /** * @brief Number of DEM descriptor records */ int get_n_dem_desc() const { return _n_dem_desc; }; /** * @brief DEM desc record length, bytes */ int get_l_dem_desc() const { return _l_dem_desc; }; /** * @brief Number of RADAR par records */ int get_n_radar_par() const { return _n_radar_par; }; /** * @brief RADAR par record length, bytes */ int get_l_radar_par() const { return _l_radar_par; }; /** * @brief Number of annotation data records */ int get_n_anno_data() const { return _n_anno_data; }; /** * @brief Annotation data record length, bytes */ int get_l_anno_data() const { return _l_anno_data; }; /** * @brief Number of processing parameter records */ int get_n_det_proc() const { return _n_det_proc; }; /** * @brief Processing parameter record length, bytes */ int get_l_det_proc() const { return _l_det_proc; }; /** * @brief Number of calibration records */ int get_n_cal() const { return _n_cal; }; /** * @brief Calibration record length, bytes */ int get_l_cal() const { return _l_cal; }; /** * @brief Number of GCP records */ int get_n_gcp() const { return _n_gcp; }; /** * @brief GCP record length, bytes */ int get_l_gcp() const { return _l_gcp; }; /** * @brief Number of facility data records */ int get_n_fac_data() const { return _n_fac_data; }; /** * @brief Fac data record length, bytes */ int get_l_fac_data() const { return _l_fac_data; }; protected: /** * @brief ASCII flag */ std::string _ascii_flag; /** * @brief Format control documentation */ std::string _format_doc; /** * @brief Format doc version */ std::string _format_ver; /** * @brief Format doc revision */ std::string _design_rev; /** * @brief Software identifier */ std::string _software_id; /** * @brief File number */ int _file_num; /** * @brief File name */ std::string _file_name; /** * @brief Record sequence/location flag */ std::string _rec_seq; /** * @brief Sequence number location */ int _seq_loc; /** * @brief Sequence number length */ int _seq_len; /** * @brief Record code/location flag */ std::string _rec_code; /** * @brief Record code location */ int _code_loc; /** * @brief Record code length */ int _code_len; /** * @brief Record length/location flag */ std::string _rec_len; /** * @brief Record length location */ int _rlen_loc; /** * @brief Record length, bytes */ int _rlen_len; /** * @brief Number of dataset summ records */ int _n_dataset; /** * @brief Data set summary record length, bytes */ int _l_dataset; /** * @brief Number of map proj records */ int _n_map_proj; /** * @brief Map projection record length, bytes */ int _l_map_proj; /** * @brief Number of platform position records */ int _n_plat_pos; /** * @brief Platform position record length, bytes */ int _l_plat_pos; /** * @brief Number of attitude data records */ int _n_att_data; /** * @brief Attitude data record length, bytes */ int _l_att_data; /** * @brief Number of radiometric data records */ int _n_radi_data; /** * @brief Radiometric data record length, bytes */ int _l_radi_data; /** * @brief Number of radiometric compensation records */ int _n_radi_comp; /** * @brief Radiometric compensation record length, bytes */ int _l_radi_comp; /** * @brief Number of data quality summary records */ int _n_qual_sum; /** * @brief Data quality summary record length, bytes */ int _l_qual_sum; /** * @brief Number of data histogram records */ int _n_data_his; /** * @brief Data histogram record length, bytes */ int _l_data_his; /** * @brief Number of range spectra records */ int _n_rang_spec; /** * @brief Range spectra record length, bytes */ int _l_rang_spec; /** * @brief Number of DEM descriptor records */ int _n_dem_desc; /** * @brief DEM desc record length, bytes */ int _l_dem_desc; /** * @brief Number of RADAR par records */ int _n_radar_par; /** * @brief RADAR par record length, bytes */ int _l_radar_par; /** * @brief Number of annotation data records */ int _n_anno_data; /** * @brief Annotation data record length, bytes */ int _l_anno_data; /** * @brief Number of processing parameter records */ int _n_det_proc; /** * @brief Processing parameter record length, bytes */ int _l_det_proc; /** * @brief Number of calibration records */ int _n_cal; /** * @brief Calibration record length, bytes */ int _l_cal; /** * @brief Number of GCP records */ int _n_gcp; /** * @brief GCP record length, bytes */ int _l_gcp; /** * @brief Number of facility data records */ int _n_fac_data; /** * @brief Fac data record length, bytes */ int _l_fac_data; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarLeader.cpp000066400000000000000000000230331301006202600300150ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include "erssar/ErsSarLeader.h" #include "erssar/ErsSarLeaderFactory.h" #include "erssar/ErsSarRecordHeader.h" #include "erssar/ErsSarFileDescriptor.h" #include "erssar/ErsSarDataSetSummary.h" #include "erssar/ErsSarMapProjectionData.h" #include "erssar/ErsSarFacilityData.h" #include #include #include // Static trace for debugging static ossimTrace traceDebug("ossimErsSarLeader:debug"); namespace ossimplugins { const int ErsSarLeader::ErsSarFacilityDataID = 5; const int ErsSarLeader::ErsSarPlatformPositionDataID = 4; const int ErsSarLeader::ErsSarMapProjectionDataID = 3; const int ErsSarLeader::ErsSarDataSetSummaryID = 2; const int ErsSarLeader::ErsSarFileDescriptorID = 1; ErsSarLeader::ErsSarLeader() { } ErsSarLeader::~ErsSarLeader() { ClearRecords(); } std::ostream& operator<<(std::ostream& os, const ErsSarLeader& data) { std::map::const_iterator it = data.theRecords.begin(); while (it != data.theRecords.end()) { (*it).second->Write(os); ++it; } return os; } std::istream& operator>>(std::istream& is, ErsSarLeader& data) { ErsSarLeaderFactory factory; data.ClearRecords(); ErsSarRecordHeader header; bool eof = false; while (!eof) { is >> header; if (is.eof()) { eof = true; } else { ErsSarRecord* record = factory.Instantiate(header.get_rec_seq()); if (record != NULL) { record->Read(is); data.theRecords[header.get_rec_seq()] = record; } else { char* buff = new char[header.get_length()-12]; is.read(buff, header.get_length() - 12); delete [] buff; } } } return is; } ErsSarLeader::ErsSarLeader(const ErsSarLeader& rhs) { std::map::const_iterator it = rhs.theRecords.begin(); while (it != rhs.theRecords.end()) { theRecords[(*it).first] = (*it).second->Clone(); ++it; } } ErsSarLeader& ErsSarLeader::operator=(const ErsSarLeader& rhs) { ClearRecords(); std::map::const_iterator it = rhs.theRecords.begin(); while (it != rhs.theRecords.end()) { theRecords[(*it).first] = (*it).second->Clone(); ++it; } return *this; } void ErsSarLeader::ClearRecords() { std::map::const_iterator it = theRecords.begin(); while (it != theRecords.end()) { delete(*it).second; ++it; } theRecords.clear(); } bool ErsSarLeader::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ErsSarLeader::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result = true; char name[64]; kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimErsSarModel", true); /* * Adding metadata necessary to the sensor model in the keywordlist */ const ErsSarFileDescriptor *leaderfiledesc = get_ErsSarFileDescriptor(); if (leaderfiledesc != NULL) { kwl.add(prefix, "filename", leaderfiledesc->get_file_name().c_str(), true); } else { result = false; } /* * Adding metadata necessary to the sensor model in the keywordlist */ const ErsSarDataSetSummary *datasetSummary = get_ErsSarDataSetSummary(); if ((datasetSummary != NULL) && (result == true)) { kwl.add(prefix, "inp_sctim", (datasetSummary->get_inp_sctim()).c_str(), true); kwl.add(prefix, "ellip_maj", datasetSummary->get_ellip_maj(), true); kwl.add(prefix, "ellip_min", datasetSummary->get_ellip_min(), true); kwl.add(prefix, "sc_lin", datasetSummary->get_sc_lin(), true); kwl.add(prefix, "sc_pix", datasetSummary->get_sc_pix(), true); kwl.add(prefix, "wave_length", datasetSummary->get_wave_length(), true); kwl.add(prefix, "fr", datasetSummary->get_fr(), true); kwl.add(prefix, "fa", datasetSummary->get_fa(), true); kwl.add(prefix, "time_dir_pix", (datasetSummary->get_time_dir_pix()).c_str(), true); kwl.add(prefix, "time_dir_lin", (datasetSummary->get_time_dir_lin()).c_str(), true); kwl.add(prefix, "line_spacing", datasetSummary->get_line_spacing(), true); kwl.add(prefix, "pix_spacing", datasetSummary->get_pix_spacing(), true); kwl.add(prefix, "nlooks_az", datasetSummary->get_n_azilok(), true); kwl.add(prefix, "n_rnglok", datasetSummary->get_n_rnglok(), true); kwl.add(prefix, "zero_dop_range_time_f_pixel", datasetSummary->get_zero_dop_range_time_f_pixel(), true); kwl.add(prefix, "zero_dop_range_time_c_pixel", datasetSummary->get_zero_dop_range_time_c_pixel(), true); kwl.add(prefix, "zero_dop_range_time_l_pixel", datasetSummary->get_zero_dop_range_time_l_pixel(), true); } else { result = false; } const ErsSarMapProjectionData *mapprojectiondata = get_ErsSarMapProjectionData(); if ((mapprojectiondata != NULL) && (result == true)) { kwl.add(prefix, "map_proj_des", (mapprojectiondata->get_map_proj_des()).c_str(), true); kwl.add(prefix, "num_lines", (double) mapprojectiondata->get_num_lines(), true); kwl.add(prefix, "num_pix", (double) mapprojectiondata->get_num_pix_in_line(), true); kwl.add(prefix, "first_line_first_pixel_lat", mapprojectiondata->get_first_line_first_pixel_lat(), true); kwl.add(prefix, "first_line_first_pixel_lon", mapprojectiondata->get_first_line_first_pixel_lon(), true); kwl.add(prefix, "first_line_last_pixel_lat", mapprojectiondata->get_first_line_last_pixel_lat(), true); kwl.add(prefix, "first_line_last_pixel_lon", mapprojectiondata->get_first_line_last_pixel_lon(), true); kwl.add(prefix, "last_line_first_pixel_lat", mapprojectiondata->get_last_line_first_pixel_lat(), true); kwl.add(prefix, "last_line_first_pixel_lon", mapprojectiondata->get_last_line_first_pixel_lon(), true); kwl.add(prefix, "last_line_last_pixel_lat", mapprojectiondata->get_last_line_last_pixel_lat(), true); kwl.add(prefix, "last_line_last_pixel_lon", mapprojectiondata->get_last_line_last_pixel_lon(), true); } else { result = false; } const ErsSarPlatformPositionData *platformposition = get_ErsSarPlatformPositionData(); if ((platformposition != NULL) && (result == true)) { kwl.add(prefix, "neph", platformposition->get_ndata(), true); kwl.add(prefix, "eph_year", platformposition->get_year(), true); kwl.add(prefix, "eph_month", platformposition->get_month(), true); kwl.add(prefix, "eph_day", platformposition->get_day(), true); kwl.add(prefix, "eph_gmt_day", platformposition->get_gmt_day(), true); kwl.add(prefix, "eph_sec", platformposition->get_gmt_sec(), true); kwl.add(prefix, "eph_hr_angle", platformposition->get_hr_angle(), true); kwl.add(prefix, "eph_int", platformposition->get_data_int(), true); for (int i = 0; i < platformposition->get_ndata(); i++) { sprintf(name, "eph%i_posX", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_pos()[0], true); sprintf(name, "eph%i_posY", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_pos()[1], true); sprintf(name, "eph%i_posZ", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_pos()[2], true); sprintf(name, "eph%i_velX", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_vel()[0], true); sprintf(name, "eph%i_velY", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_vel()[1], true); sprintf(name, "eph%i_velZ", i); kwl.add(prefix, name, (platformposition->get_pos_vect()[i]).get_vel()[2], true); } } else { result = false; } /* * Adding metadata necessary to the sensor model in the keywordlist */ const ErsSarFacilityData *facilitydata = get_ErsSarFacilityData(); if ((facilitydata != NULL) && (result == true)) { kwl.add(prefix, "coef_ground_range_1", facilitydata->get_coef_ground_range_1(), true); kwl.add(prefix, "coef_ground_range_2", facilitydata->get_coef_ground_range_2(), true); kwl.add(prefix, "coef_ground_range_3", facilitydata->get_coef_ground_range_3(), true); kwl.add(prefix, "coef_ground_range_4", facilitydata->get_coef_ground_range_4(), true); } else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } return result; } const ErsSarFacilityData * ErsSarLeader::get_ErsSarFacilityData() const { return dynamic_cast(theRecords.find(ErsSarFacilityDataID)->second); } const ErsSarPlatformPositionData * ErsSarLeader::get_ErsSarPlatformPositionData() const { return dynamic_cast(theRecords.find(ErsSarPlatformPositionDataID)->second); } const ErsSarMapProjectionData * ErsSarLeader::get_ErsSarMapProjectionData() const { return dynamic_cast(theRecords.find(ErsSarMapProjectionDataID)->second); } const ErsSarDataSetSummary * ErsSarLeader::get_ErsSarDataSetSummary() const { return dynamic_cast(theRecords.find(ErsSarDataSetSummaryID)->second); } const ErsSarFileDescriptor * ErsSarLeader::get_ErsSarFileDescriptor() const { return dynamic_cast(theRecords.find(ErsSarFileDescriptorID)->second); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarLeader.h000066400000000000000000000052241301006202600274640ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarLeader_h #define ErsSarLeader_h #include #include "ErsSarFileDescriptor.h" #include "ErsSarDataSetSummary.h" #include "ErsSarMapProjectionData.h" #include "ErsSarPlatformPositionData.h" #include "ErsSarFacilityData.h" #include class ossimKeywordlist; namespace ossimplugins { class ErsSarPlatformPositionData; class ErsSarMapProjectionData; class ErsSarDataSetSummary; class ErsSarFileDescriptor; class ErsSarFacilityData; /** * @ingroup ErsSarLeaderFile * @brief This class is able to read the Leader file of the ErsSar file structure * */ class ErsSarLeader { public: /** * @brief Constructor */ ErsSarLeader(); /** * @brief Destructor */ virtual ~ErsSarLeader(); /** * @brief This function write the ErsSarLeader in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarLeader& data); /** * @brief This function read a ErsSarLeader from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarLeader& data); /** * @brief Copy constructor */ ErsSarLeader(const ErsSarLeader& rhs); /** * @brief Copy operator */ ErsSarLeader& operator=(const ErsSarLeader& rhs); /** * @brief Remove all the previous records from the ErsSarLeader */ void ClearRecords(); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0) const; const ErsSarFacilityData * get_ErsSarFacilityData() const; const ErsSarPlatformPositionData * get_ErsSarPlatformPositionData() const; const ErsSarMapProjectionData * get_ErsSarMapProjectionData() const; const ErsSarDataSetSummary * get_ErsSarDataSetSummary() const; const ErsSarFileDescriptor * get_ErsSarFileDescriptor() const; protected: // Made mutable because the get_* methods need to access it. // (modifying the definition of the map might be another solution) mutable std::map theRecords; static const int ErsSarFacilityDataID; static const int ErsSarPlatformPositionDataID; static const int ErsSarMapProjectionDataID; static const int ErsSarDataSetSummaryID; static const int ErsSarFileDescriptorID; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarLeaderFactory.cpp000066400000000000000000000022411301006202600313430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarLeaderFactory.h" #include "erssar/ErsSarDataSetSummary.h" #include "erssar/ErsSarFileDescriptor.h" #include "erssar/ErsSarMapProjectionData.h" #include "erssar/ErsSarPlatformPositionData.h" #include "erssar/ErsSarFacilityData.h" namespace ossimplugins { ErsSarLeaderFactory::ErsSarLeaderFactory() { RegisterRecord(5, new ErsSarFacilityData()); RegisterRecord(4, new ErsSarPlatformPositionData()); RegisterRecord(3, new ErsSarMapProjectionData()); RegisterRecord(2, new ErsSarDataSetSummary()); RegisterRecord(1, new ErsSarFileDescriptor()); } ErsSarLeaderFactory::~ErsSarLeaderFactory() { std::map::iterator i = _availableRecords.begin(); while (i != _availableRecords.end()) { if ((*i).second) { delete(*i).second; (*i).second = 0; } ++i; } _availableRecords.clear(); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarLeaderFactory.h000066400000000000000000000014451301006202600310150ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarLeaderFactory_h #define ErsSarLeaderFactory_h #include "erssar/ErsSarRecordFactory.h" #include namespace ossimplugins { /** * @ingroup ErsSarLeaderFile * @brief This class is a facory able to construct Record base classes * */ class ErsSarLeaderFactory : public ErsSarRecordFactory { public: /** * @brief Contstructor */ ErsSarLeaderFactory(); /** * @brief Destructor */ virtual ~ErsSarLeaderFactory(); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarMapProjectionData.cpp000066400000000000000000000150171301006202600321700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarMapProjectionData.h" namespace ossimplugins { ErsSarMapProjectionData::ErsSarMapProjectionData() : ErsSarRecord("map_proj_data_rec") { } ErsSarMapProjectionData::~ErsSarMapProjectionData() { } std::ostream& operator<<(std::ostream& os, const ErsSarMapProjectionData& data) { os << "map_proj_des:" << data._map_proj_des.c_str() << std::endl; os << "num_pix_in_line:" << data._num_pix_in_line << std::endl; os << "num_lines:" << data._num_lines << std::endl; os << "nom_interpixel_dist:" << data._nom_interpixel_dist << std::endl; os << "nom_interline_dist:" << data._nom_interline_dist << std::endl; os << "orientation_at_center:" << data._orientation_at_center << std::endl; os << "orbit_incl:" << data._orbit_incl << std::endl; os << "asc_node_long:" << data._asc_node_long << std::endl; os << "platform_heading:" << data._platform_heading << std::endl; os << "name_of_ref_ellipsoid:" << data._name_of_ref_ellipsoid.c_str() << std::endl; os << "semi_maj_axis:" << data._semi_maj_axis << std::endl; os << "semi_min_axis:" << data._semi_min_axis << std::endl; os << "first_line_first_pixel_lat:" << data._first_line_first_pixel_lat << std::endl; os << "first_line_first_pixel_lon:" << data._first_line_first_pixel_lon << std::endl; os << "first_line_last_pixel_lat:" << data._first_line_last_pixel_lat << std::endl; os << "first_line_last_pixel_lon:" << data._first_line_last_pixel_lon << std::endl; os << "last_line_last_pixel_lat:" << data._last_line_last_pixel_lat << std::endl; os << "last_line_last_pixel_lon:" << data._last_line_last_pixel_lon << std::endl; os << "last_line_first_pixel_lat:" << data._last_line_first_pixel_lat << std::endl; os << "last_line_first_pixel_lon:" << data._last_line_first_pixel_lon << std::endl; return os; } std::istream& operator>>(std::istream& is, ErsSarMapProjectionData& data) { char buf16[17]; buf16[16] = '\0'; char buf32[33]; buf32[32] = '\0'; // char buf8[9]; // buf8[8] = '\0'; // char buf4[5]; // buf4[4] = '\0'; is.read(buf16, 16); is.read(buf32, 32); data._map_proj_des = buf32; is.read(buf16, 16); data._num_pix_in_line = atoi(buf16); is.read(buf16, 16); data._num_lines = atoi(buf16); is.read(buf16, 16); data._nom_interpixel_dist = atof(buf16); is.read(buf16, 16); data._nom_interline_dist = atof(buf16); is.read(buf16, 16); data._orientation_at_center = atof(buf16); is.read(buf16, 16); data._orbit_incl = atof(buf16); is.read(buf16, 16); data._asc_node_long = atof(buf16); is.read(buf16, 16); is.read(buf16, 16); is.read(buf16, 16); is.read(buf16, 16); data._platform_heading = atof(buf16); is.read(buf32, 32); data._name_of_ref_ellipsoid = buf32; is.read(buf16, 16); data._semi_maj_axis = atof(buf16); is.read(buf16, 16); data._semi_min_axis = atof(buf16); char buf772[772]; is.read(buf772, 772); is.read(buf16, 16); data._first_line_first_pixel_lat = atof(buf16); is.read(buf16, 16); data._first_line_first_pixel_lon = atof(buf16); is.read(buf16, 16); data._first_line_last_pixel_lat = atof(buf16); is.read(buf16, 16); data._first_line_last_pixel_lon = atof(buf16); is.read(buf16, 16); data._last_line_last_pixel_lat = atof(buf16); is.read(buf16, 16); data._last_line_last_pixel_lon = atof(buf16); is.read(buf16, 16); data._last_line_first_pixel_lat = atof(buf16); is.read(buf16, 16); data._last_line_first_pixel_lon = atof(buf16); char buf420[420]; is.read(buf420, 420); return is; } ErsSarMapProjectionData::ErsSarMapProjectionData(const ErsSarMapProjectionData& rhs): ErsSarRecord(rhs), _map_proj_des(rhs._map_proj_des), _num_pix_in_line(rhs._num_pix_in_line), _num_lines(rhs._num_lines), _nom_interpixel_dist(rhs._nom_interpixel_dist), _nom_interline_dist(rhs._nom_interline_dist), _orientation_at_center(rhs._orientation_at_center), _orbit_incl(rhs._orbit_incl), _asc_node_long(rhs._asc_node_long), _platform_heading(rhs._platform_heading), _name_of_ref_ellipsoid(rhs._name_of_ref_ellipsoid), _semi_maj_axis(rhs._semi_maj_axis), _semi_min_axis(rhs._semi_min_axis), _first_line_first_pixel_lat(rhs._first_line_first_pixel_lat), _first_line_first_pixel_lon(rhs._first_line_first_pixel_lon), _first_line_last_pixel_lat(rhs._first_line_last_pixel_lat), _first_line_last_pixel_lon(rhs._first_line_last_pixel_lon), _last_line_last_pixel_lat(rhs._last_line_last_pixel_lat), _last_line_last_pixel_lon(rhs._last_line_last_pixel_lon), _last_line_first_pixel_lat(rhs._last_line_first_pixel_lat), _last_line_first_pixel_lon(rhs._last_line_first_pixel_lon) {} ErsSarMapProjectionData& ErsSarMapProjectionData::operator=(const ErsSarMapProjectionData& rhs) { _map_proj_des = rhs._map_proj_des; _num_pix_in_line = rhs._num_pix_in_line; _num_lines = rhs._num_lines; _nom_interpixel_dist = rhs._nom_interpixel_dist; _nom_interline_dist = rhs._nom_interline_dist; _orientation_at_center = rhs._orientation_at_center; _orbit_incl = rhs._orbit_incl; _asc_node_long = rhs._asc_node_long; _platform_heading = rhs._platform_heading; _name_of_ref_ellipsoid = rhs._name_of_ref_ellipsoid; _semi_maj_axis = rhs._semi_maj_axis; _semi_min_axis = rhs._semi_min_axis; _first_line_first_pixel_lat = rhs._first_line_first_pixel_lat; _first_line_first_pixel_lon = rhs._first_line_first_pixel_lon; _first_line_last_pixel_lat = rhs._first_line_last_pixel_lat; _first_line_last_pixel_lon = rhs._first_line_last_pixel_lon; _last_line_last_pixel_lat = rhs._last_line_last_pixel_lat; _last_line_last_pixel_lon = rhs._last_line_last_pixel_lon; _last_line_first_pixel_lat = rhs._last_line_first_pixel_lat; _last_line_first_pixel_lon = rhs._last_line_first_pixel_lon; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarMapProjectionData.h000066400000000000000000000137621301006202600316420ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarMapProjectionData_h #define ErsSarMapProjectionData_h #include #include #include "erssar/ErsSarRecordHeader.h" #include "erssar/ErsSarRecord.h" namespace ossimplugins { /** * @ingroup ErsSarMapProjectionDataRecord * @brief This class is able to read the SAR leader data set summary record of the leader file * */ class ErsSarMapProjectionData : public ErsSarRecord { public: /** * @brief Constructor */ ErsSarMapProjectionData(); /** * @brief Destructor */ virtual ~ErsSarMapProjectionData(); /** * @brief This function write the ErsSarMapProjectionData in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarMapProjectionData& data); /** * @brief This function read a ErsSarMapProjectionData from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarMapProjectionData& data); /** * @brief Copy constructor */ ErsSarMapProjectionData(const ErsSarMapProjectionData& rhs); /** * @brief Copy operator */ ErsSarMapProjectionData& operator=(const ErsSarMapProjectionData& rhs); /** * @brief This function is able to create a new instance of the class */ ErsSarRecord* Instantiate() { return new ErsSarMapProjectionData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ ErsSarRecord* Clone() { return new ErsSarMapProjectionData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief map_proj_des */ std::string get_map_proj_des() const { return _map_proj_des; }; /** * @brief num_pix_in_line */ int get_num_pix_in_line() const { return _num_pix_in_line; }; /** * @brief num_lines */ int get_num_lines() const { return _num_lines; }; /** * @brief nom_interpixel_dist */ double get_nom_interpixel_dist() const { return _nom_interpixel_dist; }; /** * @brief nom_interline_dist */ double get_nom_interline_dist() const { return _nom_interline_dist; }; /** * @brief orientation_at_center */ double get_orientation_at_center() const { return _orientation_at_center; }; /** * @brief orbit_incl */ double get_orbit_incl() const { return _orbit_incl; }; /** * @brief asc_node_long */ double get_asc_node_long() const { return _asc_node_long; }; /** * @brief platform_heading */ double get_platform_heading() const { return _platform_heading; }; /** * @brief name_of_ref_ellipsoid */ std::string get_name_of_ref_ellipsoid() const { return _name_of_ref_ellipsoid; }; /** * @brief semi_maj_axis */ double get_semi_maj_axis() const { return _semi_maj_axis; }; /** * @brief semi_min_axis */ double get_semi_min_axis() const { return _semi_min_axis; }; /** * @brief first_line_first_pixel _lat */ double get_first_line_first_pixel_lat() const { return _first_line_first_pixel_lat; }; /** * @brief first_line_first_pixel_lon */ double get_first_line_first_pixel_lon() const { return _first_line_first_pixel_lon; }; /** * @brief first_line_last_pixel _lat */ double get_first_line_last_pixel_lat() const { return _first_line_last_pixel_lat; }; /** * @brief first_line_last_pixel_lon */ double get_first_line_last_pixel_lon() const { return _first_line_last_pixel_lon; }; /** * @brief last_line_last_pixel_lat */ double get_last_line_last_pixel_lat() const { return _last_line_last_pixel_lat; }; /** * @brief last_line_last_pixel_lon */ double get_last_line_last_pixel_lon() const { return _last_line_last_pixel_lon; }; /** * @brief last_line_first_pixel_lat */ double get_last_line_first_pixel_lat() const { return _last_line_first_pixel_lat; }; /** * @brief last_line_first_pixel_lon */ double get_last_line_first_pixel_lon() const { return _last_line_first_pixel_lon; }; protected: /** * @brief map_proj_des */ std::string _map_proj_des; /** * @brief num_pix_in_line */ int _num_pix_in_line; /** * @brief num_lines */ int _num_lines; /** * @brief nom_interpixel_dist */ double _nom_interpixel_dist; /** * @brief nom_interline_dist */ double _nom_interline_dist; /** * @brief orientation_at_center */ double _orientation_at_center; /** * @brief orbit_incl */ double _orbit_incl; /** * @brief asc_node_long */ double _asc_node_long; /** * @brief platform_heading */ double _platform_heading; /** * @brief name_of_ref_ellipsoid */ std::string _name_of_ref_ellipsoid; /** * @brief semi_maj_axis */ double _semi_maj_axis; /** * @brief semi_min_axis */ double _semi_min_axis; /** * @brief first_line_first_pixel_lat */ double _first_line_first_pixel_lat; /** * @brief first_line_first_pixel_lon */ double _first_line_first_pixel_lon; /** * @brief first_line_last_pixel_lat */ double _first_line_last_pixel_lat; /** * @brief first_line_last_pixel_lon */ double _first_line_last_pixel_lon; /** * @brief last_line_last_pixel_lat */ double _last_line_last_pixel_lat; /** * @brief last_line_last_pixel_lon */ double _last_line_last_pixel_lon; /** * @brief last_line_first_pixel_lat */ double _last_line_first_pixel_lat; /** * @brief last_line_first_pixel_lon */ double _last_line_first_pixel_lon; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarPlatformPositionData.cpp000066400000000000000000000111051301006202600327210ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarPlatformPositionData.h" namespace ossimplugins { ErsSarPlatformPositionData::ErsSarPlatformPositionData() : ErsSarRecord("pos_data_rec") { } ErsSarPlatformPositionData::~ErsSarPlatformPositionData() { } std::ostream& operator<<(std::ostream& os, const ErsSarPlatformPositionData& data) { os << "orbit_ele_desg:" << data._orbit_ele_desg.c_str() << std::endl; for (int i = 0; i < 6; i++) { os << "orbit_ele[" << i << "]:" << data._orbit_ele[i] << std::endl; } os << "ndata:" << data._ndata << std::endl; os << "year:" << data._year << std::endl; os << "month:" << data._month << std::endl; os << "day:" << data._day << std::endl; os << "gmt_day:" << data._gmt_day << std::endl; os << "gmt_sec:" << data._gmt_sec << std::endl; os << "data_int:" << data._data_int << std::endl; os << "ref_coord:" << data._ref_coord.c_str() << std::endl; os << "hr_angle:" << data._hr_angle << std::endl; os << "alt_poserr:" << data._alt_poserr << std::endl; os << "crt_poserr:" << data._crt_poserr << std::endl; os << "rad_poserr:" << data._rad_poserr << std::endl; os << "alt_velerr:" << data._alt_velerr << std::endl; os << "crt_velerr:" << data._crt_velerr << std::endl; os << "rad_velerr:" << data._rad_velerr << std::endl; for (int i = 0; i < 64; i++) { os << "pos_vect[" << i << "]:" << data._pos_vect[i] << std::endl; } return os; } std::istream& operator>>(std::istream& is, ErsSarPlatformPositionData& data) { char buf[1207]; buf[1206] = '\0'; is.read(buf, 32); buf[32] = '\0'; data._orbit_ele_desg = buf; for (int i = 0; i < 6; i++) { is.read(buf, 16); buf[16] = '\0'; data._orbit_ele[i] = atof(buf); } is.read(buf, 4); buf[4] = '\0'; data._ndata = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._year = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._month = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._day = atoi(buf); is.read(buf, 4); buf[4] = '\0'; data._gmt_day = atoi(buf); is.read(buf, 22); buf[22] = '\0'; data._gmt_sec = atof(buf); is.read(buf, 22); buf[22] = '\0'; data._data_int = atof(buf); is.read(buf, 64); buf[64] = '\0'; data._ref_coord = buf; is.read(buf, 22); buf[22] = '\0'; data._hr_angle = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._alt_poserr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._crt_poserr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._rad_poserr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._alt_velerr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._crt_velerr = atof(buf); is.read(buf, 16); buf[16] = '\0'; data._rad_velerr = atof(buf); for (int i = 0; i < data._ndata; i++) { is >> data._pos_vect[i]; } return is; } ErsSarPlatformPositionData::ErsSarPlatformPositionData(const ErsSarPlatformPositionData& rhs): ErsSarRecord(rhs) { _orbit_ele_desg = rhs._orbit_ele_desg; for (int i = 0; i < 6; i++) { _orbit_ele[i] = rhs._orbit_ele[i]; } _ndata = rhs._ndata; _year = rhs._year; _month = rhs._month; _day = rhs._day; _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _data_int = rhs._data_int; _ref_coord = rhs._ref_coord; _hr_angle = rhs._hr_angle; _alt_poserr = rhs._alt_poserr; _crt_poserr = rhs._crt_poserr; _rad_poserr = rhs._rad_poserr; _alt_velerr = rhs._alt_velerr; _crt_velerr = rhs._crt_velerr; _rad_velerr = rhs._rad_velerr; for (int i = 0; i < 64; i++) { _pos_vect[i] = rhs._pos_vect[i]; } } ErsSarPlatformPositionData& ErsSarPlatformPositionData::operator=(const ErsSarPlatformPositionData& rhs) { _orbit_ele_desg = rhs._orbit_ele_desg; for (int i = 0; i < 6; i++) { _orbit_ele[i] = rhs._orbit_ele[i]; } _ndata = rhs._ndata; _year = rhs._year; _month = rhs._month; _day = rhs._day; _gmt_day = rhs._gmt_day; _gmt_sec = rhs._gmt_sec; _data_int = rhs._data_int; _ref_coord = rhs._ref_coord; _hr_angle = rhs._hr_angle; _alt_poserr = rhs._alt_poserr; _crt_poserr = rhs._crt_poserr; _rad_poserr = rhs._rad_poserr; _alt_velerr = rhs._alt_velerr; _crt_velerr = rhs._crt_velerr; _rad_velerr = rhs._rad_velerr; for (int i = 0; i < 64; i++) { _pos_vect[i] = rhs._pos_vect[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarPlatformPositionData.h000066400000000000000000000123061301006202600323720ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarPlatformPositionData_h #define ErsSarPlatformPositionData_h #include #include "erssar/ErsSarRecord.h" #include "erssar/ErsSarRecordHeader.h" #include "erssar/ErsSarPositionVectorRecord.h" namespace ossimplugins { /** * @ingroup PlatformPositionDataRecord * @brief This class is able to read a Platform position data record * */ class ErsSarPlatformPositionData : public ErsSarRecord { public: /** * @brief Constructor */ ErsSarPlatformPositionData(); /** * @brief Destructor */ virtual ~ErsSarPlatformPositionData(); /** * @brief Copy constructor */ ErsSarPlatformPositionData(const ErsSarPlatformPositionData& rhs); /** * @brief Copy operator */ ErsSarPlatformPositionData& operator=(const ErsSarPlatformPositionData& rhs); /** * @brief This function write the ErsSar PlatformPositionData in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarPlatformPositionData& data); /** * @brief This function read a ErsSar PlatformPositionData from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarPlatformPositionData& data); /** * @brief This function is able to create a new instance of the class */ ErsSarRecord* Instantiate() { return new ErsSarPlatformPositionData(); }; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ ErsSarRecord* Clone() { return new ErsSarPlatformPositionData(*this); }; /** * @brief Read the class data from a stream */ void Read(std::istream& is) { is >> *this; }; /** * @brief Write the class to a stream */ void Write(std::ostream& os) { os << *this; }; /** * @brief Orbital elements designator */ std::string get_orbit_ele_desg() const { return _orbit_ele_desg; }; /** * @brief Orbital elements */ const double* get_orbit_ele() const { return _orbit_ele; }; /** * @brief Number of data points */ int get_ndata() const { return _ndata; }; /** * @brief Year of data point */ int get_year() const { return _year; }; /** * @brief Month of data point */ int get_month() const { return _month; }; /** * @brief Day of data point */ int get_day() const { return _day; }; /** * @brief Day of year */ int get_gmt_day() const { return _gmt_day; }; /** * @brief Seconds of day */ double get_gmt_sec() const { return _gmt_sec; }; /** * @brief Data sampling interval */ double get_data_int() const { return _data_int; }; /** * @brief Reference coordinate system */ std::string get_ref_coord() const { return _ref_coord; }; /** * @brief Greenwich mean hour angle */ double get_hr_angle() const { return _hr_angle; }; /** * @brief Along track position error */ double get_alt_poserr() const { return _alt_poserr; }; /** * @brief Cross track position error */ double get_crt_poserr() const { return _crt_poserr; }; /** * @brief Radial position error */ double get_rad_poserr() const { return _rad_poserr; }; /** * @brief Along track velocity error */ double get_alt_velerr() const { return _alt_velerr; }; /** * @brief Cross track velocity error */ double get_crt_velerr() const { return _crt_velerr; }; /** * @brief Radial velocity error */ double get_rad_velerr() const { return _rad_velerr; }; /** * @brief Data point position/velocity */ const ErsSarPositionVectorRecord* get_pos_vect() const { return _pos_vect; }; protected: /** * @brief Orbital elements designator */ std::string _orbit_ele_desg; /** * @brief Orbital elements */ double _orbit_ele[6]; /** * @brief Number of data points */ int _ndata; /** * @brief Year of data point */ int _year; /** * @brief Month of data point */ int _month; /** * @brief Day of data point */ int _day; /** * @brief Day of year */ int _gmt_day; /** * @brief Seconds of day */ double _gmt_sec; /** * @brief Data sampling interval */ double _data_int; /** * @brief Reference coordinate system */ std::string _ref_coord; /** * @brief Greenwich mean hour angle */ double _hr_angle; /** * @brief Along track position error */ double _alt_poserr; /** * @brief Cross track position error */ double _crt_poserr; /** * @brief Radial position error */ double _rad_poserr; /** * @brief Along track velocity error */ double _alt_velerr; /** * @brief Cross track velocity error */ double _crt_velerr; /** * @brief Radial velocity error */ double _rad_velerr; /** * @brief Data point position/velocity */ ErsSarPositionVectorRecord _pos_vect[64]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarPositionVectorRecord.cpp000066400000000000000000000031151301006202600327460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarPositionVectorRecord.h" namespace ossimplugins { ErsSarPositionVectorRecord::ErsSarPositionVectorRecord() { } ErsSarPositionVectorRecord::~ErsSarPositionVectorRecord() { } std::ostream& operator<<(std::ostream& os, const ErsSarPositionVectorRecord& data) { for (int i = 0; i < 3; i++) { os << "pos[" << i << "]:" << data._pos[i] << std::endl; } for (int i = 0; i < 3; i++) { os << "vel[" << i << "]:" << data._vel[i] << std::endl; } return os; } std::istream& operator>>(std::istream& is, ErsSarPositionVectorRecord& data) { char buf[23]; buf[22] = '\0'; for (int i = 0; i < 3; i++) { is.read(buf, 22); data._pos[i] = atof(buf); } for (int i = 0; i < 3; i++) { is.read(buf, 22); data._vel[i] = atof(buf); } return is; } ErsSarPositionVectorRecord::ErsSarPositionVectorRecord(const ErsSarPositionVectorRecord& rhs) { for (int i = 0; i < 3; i++) { _pos[i] = rhs._pos[i]; } for (int i = 0; i < 3; i++) { _vel[i] = rhs._vel[i]; } } ErsSarPositionVectorRecord& ErsSarPositionVectorRecord::operator=(const ErsSarPositionVectorRecord& rhs) { for (int i = 0; i < 3; i++) { _pos[i] = rhs._pos[i]; } for (int i = 0; i < 3; i++) { _vel[i] = rhs._vel[i]; } return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarPositionVectorRecord.h000066400000000000000000000033431301006202600324160ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarPositionVectorRecord_h #define ErsSarPositionVectorRecord_h #include #include #include "erssar/ErsSarRecord.h" namespace ossimplugins { /** * @ingroup PlatformPositionDataRecord * @brief This class is able to read a position vector record * */ class ErsSarPositionVectorRecord { public: /** * @brief Constructor */ ErsSarPositionVectorRecord(); /** * @brief Destructor */ virtual ~ErsSarPositionVectorRecord(); /** * @brief Copy constructor */ ErsSarPositionVectorRecord(const ErsSarPositionVectorRecord& rhs); /** * @brief Copy operator */ ErsSarPositionVectorRecord& operator=(const ErsSarPositionVectorRecord& rhs); /** * @brief This function write the ErsSar PositionVectorRecord in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarPositionVectorRecord& data); /** * @brief This function read a ErsSar PositionVectorRecord from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarPositionVectorRecord& data); /** * @brief Data point position (m) */ const double* get_pos() const { return _pos; }; /** * @brief Data point velocity (mm/s) */ const double* get_vel() const { return _vel; }; protected: /** * @brief Data point position (m) */ double _pos[3]; /** * @brief Data point velocity (mm/s) */ double _vel[3]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarRecord.cpp000066400000000000000000000011261301006202600300360ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarRecord.h" #include namespace ossimplugins { ErsSarRecord::ErsSarRecord(std::string mnemonic): _mnemonic(mnemonic) { } ErsSarRecord::~ErsSarRecord() { } ErsSarRecord::ErsSarRecord(const ErsSarRecord& rhs): _mnemonic(rhs._mnemonic) { } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarRecord.h000066400000000000000000000026561301006202600275140ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarRecord_h #define ErsSarRecord_h #include "erssar/ErsSarRecordHeader.h" #include namespace ossimplugins { /** * @ingroup ErsSar * @brief This class is the base class of all the record classes * */ class ErsSarRecord { public: /** * @brief Constructor * @param mnemonic Name of the record */ ErsSarRecord(std::string mnemonic); /** * @brief Destructor */ virtual ~ErsSarRecord(); /** * @brief Copy constructor */ ErsSarRecord(const ErsSarRecord& rhs); /** * @brief This function is able to create a new instance of the class */ virtual ErsSarRecord* Instantiate() = 0; /** * @brief This function is able to create a new instance of the class initialised with the data of the calling instance */ virtual ErsSarRecord* Clone() = 0; /** * @brief Read the class data from a stream */ virtual void Read(std::istream& is) = 0; /** * @brief Write the class to a stream */ virtual void Write(std::ostream& os) = 0; std::string get_mnemonic() { return _mnemonic; }; protected: std::string _mnemonic; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarRecordFactory.cpp000066400000000000000000000014341301006202600313700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarRecordFactory.h" namespace ossimplugins { ErsSarRecordFactory::ErsSarRecordFactory() { } ErsSarRecordFactory::~ErsSarRecordFactory() { } ErsSarRecord* ErsSarRecordFactory::Instantiate(int id) { ErsSarRecord* record = _availableRecords[id]; if (record == NULL) { return NULL; } else { return record->Instantiate(); } } void ErsSarRecordFactory::RegisterRecord(int id, ErsSarRecord * record) { _availableRecords[id] = record; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarRecordFactory.h000066400000000000000000000024471301006202600310420ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarRecordFactory_h #define ErsSarRecordFactory_h #include "erssar/ErsSarRecordHeader.h" #include "erssar/ErsSarRecord.h" #include namespace ossimplugins { /** * @ingroup ErsSar * @brief This class is a facory able to construct Record base classes given the id of the record wanted * */ class ErsSarRecordFactory { public: /** * @brief Constructor */ ErsSarRecordFactory(); /** * @brief Destructor */ virtual ~ErsSarRecordFactory(); /** * @brief Add a new Record type available in this factory * @param record Record to add in the factory * @param id Id of the new avalaible Record */ void RegisterRecord(int id, ErsSarRecord * record); /** * @brief Instantiate a new Record * @param id Id of the Record we want to instantiate */ ErsSarRecord* Instantiate(int id) ; protected: /** * @brief Contain all the available Records for the factory */ std::map _availableRecords; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarRecordHeader.cpp000066400000000000000000000040201301006202600311430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "erssar/ErsSarRecordHeader.h" namespace ossimplugins { ErsSarRecordHeader::ErsSarRecordHeader() { } ErsSarRecordHeader::~ErsSarRecordHeader() { } std::ostream& operator<<(std::ostream& os, const ErsSarRecordHeader& data) { os << "record_sequence_number:" << data._rec_seq << std::endl; os << "first_record_sub-type:" << (int)data._rec_sub1 << std::endl; os << "record_type_code:" << (int)data._rec_type << std::endl; os << "second_record_sub-type:" << (int)data._rec_sub2 << std::endl; os << "third_record_sub-type:" << (int)data._rec_sub3 << std::endl; os << "length:" << data._length << std::endl; return os; } std::istream& operator>>(std::istream& is, ErsSarRecordHeader& data) { is.read((char*)&(data._rec_seq), 4); data.SwitchEndian(data._rec_seq); is.read((char*)&(data._rec_sub1), 1); is.read((char*)&(data._rec_type), 1); is.read((char*)&(data._rec_sub2), 1); is.read((char*)&(data._rec_sub3), 1); is.read((char*)&(data._length), 4); data.SwitchEndian(data._length); return is; } ErsSarRecordHeader::ErsSarRecordHeader(const ErsSarRecordHeader& rhs): _rec_seq(rhs._rec_seq), _rec_sub1(rhs._rec_sub1), _rec_type(rhs._rec_type), _rec_sub2(rhs._rec_sub2), _rec_sub3(rhs._rec_sub3) { } ErsSarRecordHeader& ErsSarRecordHeader::operator=(const ErsSarRecordHeader& rhs) { _rec_seq = rhs._rec_seq; _rec_sub1 = rhs._rec_sub1; _rec_type = rhs._rec_type; _rec_sub2 = rhs._rec_sub2; _rec_sub3 = rhs._rec_sub3; return *this; } void ErsSarRecordHeader::SwitchEndian(unsigned int& value) { char buffer[4]; char res[4]; memcpy(buffer, &value, 4); res[0] = buffer[3]; res[1] = buffer[2]; res[2] = buffer[1]; res[3] = buffer[0]; memcpy(&value, res, 4); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/erssar/ErsSarRecordHeader.h000066400000000000000000000047171301006202600306250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ErsSarRecordHeader_h #define ErsSarRecordHeader_h #include #include namespace ossimplugins { /** * @ingroup ErsSar * @brief This class is able to read a record header * */ class ErsSarRecordHeader { public: /** * @brief Constructor */ ErsSarRecordHeader(); /** * @brief Destructor */ virtual ~ErsSarRecordHeader(); /** * @brief Copy constructor */ ErsSarRecordHeader(const ErsSarRecordHeader& rhs); /** * @brief Copy operator */ ErsSarRecordHeader& operator=(const ErsSarRecordHeader& rhs); /** * @brief This function write the RecordHeader in a stream */ friend std::ostream& operator<<(std::ostream& os, const ErsSarRecordHeader& data); /** * @brief This function read a RecordHeader from a stream */ friend std::istream& operator>>(std::istream& is, ErsSarRecordHeader& data); /** * @brief Record sequence number */ unsigned int get_rec_seq() { return _rec_seq; }; /** * @brief First record sub-type code */ unsigned char get_rec_sub1() { return _rec_sub1; }; /** * @brief Record type code */ unsigned char get_rec_type() { return _rec_type; }; /** * @brief Second record sub-type code */ unsigned char get_rec_sub2() { return _rec_sub2; }; /** * @brief Third record sub-type code */ unsigned char get_rec_sub3() { return _rec_sub3; }; /** * @brief Length of this record (in bytes) */ unsigned int get_length() { return _length; }; protected: /** * @brief This function switch the LSB value and the MSB value of the parameter */ void SwitchEndian(unsigned int& value); /** * @brief Record sequence number */ unsigned int _rec_seq; /** * @brief First record sub-type code */ unsigned char _rec_sub1; /** * @brief Record type code */ unsigned char _rec_type; /** * @brief Second record sub-type code */ unsigned char _rec_sub2; /** * @brief Third record sub-type code */ unsigned char _rec_sub3; /** * @brief Length of this record (in bytes) */ unsigned int _length; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimAlosPalsarModel.cpp000066400000000000000000000543611301006202600303070ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include // Static trace for debugging static ossimTrace traceDebug("ossimAlosPalsarModel:debug"); #include #include namespace ossimplugins { RTTI_DEF1(ossimAlosPalsarModel, "ossimAlosPalsarModel", ossimGeometricSarSensorModel); ossimAlosPalsarModel::ossimAlosPalsarModel(): thePixelSpacing(0), theAlosPalsarLeader(NULL), theAlosPalsarData(NULL) { } ossimAlosPalsarModel::~ossimAlosPalsarModel() { if (theAlosPalsarLeader != NULL) { delete theAlosPalsarLeader; theAlosPalsarLeader = NULL; } if (theAlosPalsarData != NULL) { delete theAlosPalsarData; theAlosPalsarData = NULL; } } ossimString ossimAlosPalsarModel::getClassName() const { return ossimString("ossimAlosPalsarModel"); } ossimObject* ossimAlosPalsarModel::dup() const { return new ossimAlosPalsarModel(*this); } double ossimAlosPalsarModel::getSlantRangeFromGeoreferenced(double /* col */) const { std::cout << "WARNING: getSlantRangeFromGeoreferenced not implemented for AlosPalsar" << std::endl; return 0.0; } bool ossimAlosPalsarModel::InitSensorParams(const ossimKeywordlist &kwl, const char *prefix) { const char* wave_length_str = kwl.find(prefix, "wave_length"); double wave_length = atof(wave_length_str); const char* fr_str = kwl.find(prefix, "fr"); double fr = atof(fr_str) * 1e6; const char* fa_str = kwl.find(prefix, "fa"); double fa = atof(fa_str); ossimString time_dir_pix = kwl.find(prefix, "time_dir_pix"); time_dir_pix.upcase(); //std::transform(time_dir_pix.begin(), time_dir_pix.end(), time_dir_pix.begin(), toupper); ossimString time_dir_lin = kwl.find(prefix, "time_dir_lin"); time_dir_lin.upcase(); //std::transform(time_dir_lin.begin(), time_dir_lin.end(), time_dir_lin.begin(), toupper); //ellipsoid parameters const char* ellip_maj_str = kwl.find(prefix, "ellip_maj"); double ellip_maj = atof(ellip_maj_str) * 1000.0; // km -> m const char* ellip_min_str = kwl.find(prefix, "ellip_min"); double ellip_min = atof(ellip_min_str) * 1000.0; // km -> m const char* dopcen_str = kwl.find(prefix, "dopcen_range[0]"); double dopcen = atof(dopcen_str); const char* dopcenLinear_str = kwl.find(prefix, "dopcen_range[1]"); double dopcenLinear = atof(dopcenLinear_str); if (_sensor != NULL) { delete _sensor; } _sensor = new SensorParams(); /* if(strcmp(time_dir_pix.c_str(), "INCREASE") == 0) { _sensor->set_col_direction(1); } else { _sensor->set_col_direction(-1); } */ // WARNING: _col_direction hard-coded to 1, as level 1.0 image is not flipped. _sensor->set_col_direction(1); // TODO: Have to verify whether the time direction indicator should be always positive /* if(strcmp(time_dir_lin.c_str(), "INCREASE") == 0) { _sensor->set_lin_direction(1); } else { _sensor->set_lin_direction(-1); } */ _sensor->set_lin_direction(1); _sensor->set_sightDirection(SensorParams::Right) ; double nlooks_az = atof(kwl.find(prefix, "nlooks_az")); _sensor->set_nAzimuthLook(nlooks_az); double n_rnglok = atof(kwl.find(prefix, "n_rnglok")); _sensor->set_nRangeLook(n_rnglok); _sensor->set_prf(fa / 1000.); // For ALOS, the fa value in the leader file is in units of mHz _sensor->set_sf(fr); _sensor->set_rwl(wave_length); _sensor->set_semiMajorAxis(ellip_maj) ; _sensor->set_semiMinorAxis(ellip_min) ; _sensor->set_dopcen(dopcen); _sensor->set_dopcenLinear(dopcenLinear); return true; } bool ossimAlosPalsarModel::open(const ossimFilename& file) { static const char MODULE[] = "ossimAlosPalsarModel::open"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n" << "file: " << file << "\n"; } bool result = false; ossimFilename leaFilename = file; ossimFilename datFilename; /* * Creation of the class allowing to store Leader file metadata */ if (theAlosPalsarLeader != NULL) { delete theAlosPalsarLeader; theAlosPalsarLeader = NULL; } theAlosPalsarLeader = new AlosPalsarLeader(); theAlosPalsarData = new AlosPalsarData(); if (leaFilename.exists()) { result = isAlosPalsarLeader(leaFilename); if (result == false) { leaFilename = findAlosPalsarLeader(file); } result = isAlosPalsarLeader(leaFilename); if (result == true) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << leaFilename << " is AlosPalsar leader file..." << std::endl << "Begin reading Leader file" << std::endl; } /* * Leader file data reading */ std::ifstream leaderFile(leaFilename.c_str(), ios::in | ios::binary); leaderFile >> *theAlosPalsarLeader; leaderFile.close(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading Leader file" << std::endl; } datFilename = findAlosPalsarData(leaFilename); result = isAlosPalsarData(datFilename); if (result == true) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << datFilename << " is AlosPalsar data file..." << std::endl << "Begin reading Data file header" << std::endl; } /* * Read header of data file for image size info */ std::ifstream dataFile(datFilename.c_str(), ios::in | ios::binary); dataFile >> *theAlosPalsarData; dataFile.close(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading Data file header" << std::endl; } } // matches: if ( result=isAlosPalsarData(datFilename) == true ) //To initialize the whole state, reusing saveState/loadState //FIXME: This could be at the superclass level instead ossimKeywordlist kwl; saveState(kwl); loadState(kwl); } // matches: if ( result=isAlosPalsarLeader(file) == True ) } // matches: if ( file.exists() ) if (traceDebug()) { this->print(ossimNotify(ossimNotifyLevel_DEBUG)); ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } return result; } bool ossimAlosPalsarModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimAlosPalsarModel::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result; kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimAlosPalsarModel", true); if (theAlosPalsarLeader == NULL) { std::cout << "Error: AlosPalsarLeader is NULL" << std::endl; return false; } result = theAlosPalsarLeader->saveState(kwl); if (result == true) { if (theAlosPalsarData == NULL) { std::cout << "Error: AlosPalsarData is NULL" << std::endl; return false; } result = theAlosPalsarData->saveState(kwl); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } return result; } bool ossimAlosPalsarModel::loadState(const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimAlosPalsarModel::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } const char* lookup = 0; ossimString s; // Check the type first. lookup = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (lookup) { s = lookup; if (s != getClassName()) { return false; } } // Load the base class. // bool result = ossimGeometricSarSensorModel::loadState(kwl, prefix); bool result = false; result = InitPlatformPosition(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init platform position \n"; } } if (result) { result = InitSensorParams(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init sensor parameters \n"; } } } if (result) { result = InitRefPoint(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init ref point \n"; } } } // Products georeferenced to ground range are not handled in AlosPalsarModel _isProductGeoreferenced = false; /* if (result) { result = InitSRGR(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init ref point \n"; } } } */ return result; } bool ossimAlosPalsarModel::InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix) { // const double PI = 3.14159265358979323846 ; CivilDateTime ref_civil_date; /* * Ephemerisis reference date retrieval */ const char* eph_year_str = kwl.find(prefix, "eph_year"); int eph_year = atoi(eph_year_str); const char* eph_month_str = kwl.find(prefix, "eph_month"); int eph_month = atoi(eph_month_str); const char* eph_day_str = kwl.find(prefix, "eph_day"); int eph_day = atoi(eph_day_str); const char* eph_sec_str = kwl.find(prefix, "eph_sec"); double eph_sec = atof(eph_sec_str); ref_civil_date.set_year(eph_year); ref_civil_date.set_month(eph_month); ref_civil_date.set_day(eph_day); ref_civil_date.set_second((int)eph_sec); ref_civil_date.set_decimal(eph_sec - (double)((int)eph_sec)); JSDDateTime ref_jsd_date(ref_civil_date); /* * Ephemerisis time interval retrieval */ const char* eph_int_str = kwl.find(prefix, "eph_int"); double eph_int = atof(eph_int_str); /* * Ephemerisis number retrieval */ const char* neph_str = kwl.find(prefix, "neph"); int neph = atoi(neph_str); Ephemeris** ephemeris = new Ephemeris*[neph]; /* * Ephemerisis retrieval */ for (int i = 0; i < neph; i++) { double pos[3]; double vit[3]; char name[64]; sprintf(name, "eph%i_posX", i); const char* px_str = kwl.find(prefix, name); pos[0] = atof(px_str); sprintf(name, "eph%i_posY", i); const char* py_str = kwl.find(prefix, name); pos[1] = atof(py_str); sprintf(name, "eph%i_posZ", i); const char* pz_str = kwl.find(prefix, name); pos[2] = atof(pz_str); sprintf(name, "eph%i_velX", i); const char* vx_str = kwl.find(prefix, name); vit[0] = atof(vx_str); sprintf(name, "eph%i_velY", i); const char* vy_str = kwl.find(prefix, name); vit[1] = atof(vy_str); sprintf(name, "eph%i_velZ", i); const char* vz_str = kwl.find(prefix, name); vit[2] = atof(vz_str); /* * Ephemerisis date */ JSDDateTime date(ref_jsd_date); date.set_second(date.get_second() + i * eph_int); date.NormDate(); GeographicEphemeris* eph = new GeographicEphemeris(date, pos, vit); ephemeris[i] = eph; } /* * Antenna position interpolator creation */ if (_platformPosition != NULL) { delete _platformPosition; } _platformPosition = new PlatformPosition(ephemeris, neph); /* * Free of memory used by the ephemerisis list */ for (int i = 0; i < neph; i++) { delete ephemeris[i]; } delete[] ephemeris; return true; } bool ossimAlosPalsarModel::InitRefPoint(const ossimKeywordlist &kwl, const char *prefix) { const char* sc_lin_str = kwl.find(prefix, "sc_lin"); double sc_lin = atof(sc_lin_str); const char* sc_pix_str = kwl.find(prefix, "sc_pix"); double sc_pix = atof(sc_pix_str); const char* inp_sctim_str = kwl.find(prefix, "inp_sctim"); // Not available for ALOS //const char* rng_gate_str = kwl.find(prefix,"zero_dop_range_time_f_pixel"); //double rng_gate = atof(rng_gate_str); if (_refPoint == NULL) { _refPoint = new RefPoint(); } _refPoint->set_pix_col(sc_pix); _refPoint->set_pix_line(sc_lin); char year_str[5]; for (int i = 0; i < 4; i++) { year_str[i] = inp_sctim_str[i]; } year_str[4] = '\0'; char month_str[3]; for (int i = 4; i < 6; i++) { month_str[i-4] = inp_sctim_str[i]; } month_str[2] = '\0'; char day_str[3]; for (int i = 6; i < 8; i++) { day_str[i-6] = inp_sctim_str[i]; } day_str[2] = '\0'; char hour_str[3]; for (int i = 8; i < 10; i++) { hour_str[i-8] = inp_sctim_str[i]; } hour_str[2] = '\0'; char min_str[3]; for (int i = 10; i < 12; i++) { min_str[i-10] = inp_sctim_str[i]; } min_str[2] = '\0'; char sec_str[3]; for (int i = 12; i < 14; i++) { sec_str[i-12] = inp_sctim_str[i]; } sec_str[2] = '\0'; char mili_str[4]; for (int i = 14; i < 17; i++) { mili_str[i-14] = inp_sctim_str[i]; } mili_str[3] = '\0'; int year = atoi(year_str); int month = atoi(month_str); int day = atoi(day_str); int hour = atoi(hour_str); int min = atoi(min_str); int sec = atoi(sec_str); double mili = atof(mili_str); CivilDateTime date(year, month, day, hour * 3600 + min * 60 + sec, mili / 1000.0); if (_platformPosition != NULL) { Ephemeris * ephemeris = _platformPosition->Interpolate((JSDDateTime)date); if (ephemeris == NULL) return false ; _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else { return false; } const double c = 2.99792458e+8; const char* slantRange = kwl.find(prefix, "slant_range_to_1st_data_sample"); double distance = atof(slantRange) + static_cast(sc_pix) * _sensor->get_nRangeLook() / _sensor->get_sf() * c / 2.0; _refPoint->set_distance(distance); // in order to use ossimSensorModel::lineSampleToWorld const char* nbCol_str = kwl.find(prefix, "num_pix_in_line"); const char* nbLin_str = kwl.find(prefix, "num_lines"); theImageSize.x = atoi(nbCol_str); theImageSize.y = atoi(nbLin_str); theImageClipRect = ossimDrect(0, 0, theImageSize.x - 1, theImageSize.y - 1); // AlosPalsarModel currently does not handle GCPs /* Do not use GCPs for now // Ground Control Points extracted from the model : corner points std::list groundGcpCoordinates ; std::list imageGcpCoordinates ; // first line first pix const char* lon_str = kwl.find("first_line_first_pixel_lon"); double lon = atof(lon_str); const char* lat_str = kwl.find("first_line_first_pixel_lat"); double lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP1(0,0); ossimGpt groundGCP1(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP1) ; imageGcpCoordinates.push_back(imageGCP1) ; // first line last pix lon_str = kwl.find("first_line_last_pixel_lon"); lon = atof(lon_str); lat_str = kwl.find("first_line_last_pixel_lat"); lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP2(theImageSize.x-1, 0); ossimGpt groundGCP2(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP2) ; imageGcpCoordinates.push_back(imageGCP2) ; // last line last pix lon_str = kwl.find("last_line_last_pixel_lon"); lon = atof(lon_str); lat_str = kwl.find("last_line_last_pixel_lat"); lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP3(theImageSize.x-1,theImageSize.y-1); ossimGpt groundGCP3(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP3) ; imageGcpCoordinates.push_back(imageGCP3) ; // last line first pix lon_str = kwl.find("last_line_first_pixel_lon"); lon = atof(lon_str); lat_str = kwl.find("last_line_first_pixel_lat"); lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP4(0,theImageSize.y-1); ossimGpt groundGCP4(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP4) ; imageGcpCoordinates.push_back(imageGCP4) ; // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates) ; */ return true; } // Note: Products georeferenced to ground range are not handled in AlosPalsarModel // therefore the following method will not be used bool ossimAlosPalsarModel::InitSRGR(const ossimKeywordlist& /* kwl */, const char* /* prefix */) { // TODO Add user warning and reference to ERS Model return false; } bool ossimAlosPalsarModel::isAlosPalsarLeader(const ossimFilename& file) const { std::ifstream candidate(file.c_str(), ios::in | ios::binary); char alosFileName[16]; candidate.seekg(48); if (candidate.bad() || candidate.eof()) { return false; } candidate.read(alosFileName, 16); if (candidate.bad() || candidate.eof()) { return false; } candidate.close(); ossimString ersString(alosFileName); if ((ersString.find("AL1 ") == 0) && (ersString.find("PSR") == 4) && (ersString.find("SARL") == 8)) { return true; } else { return false; } return true; } ossimFilename ossimAlosPalsarModel::findAlosPalsarLeader(const ossimFilename& file) const { ossimFilename leaFile = file; ossimString imgPrefix("IMG"); ossimString trlPrefix("TRL"); ossimString volPrefix("VOL"); ossimString leaPrefix("LED"); ossimString filename = file.fileNoExtension(); ossimString prefix = filename.substr(0, 3); if ((prefix == imgPrefix) || (prefix == trlPrefix) || (prefix == volPrefix)) { // Find the 2nd dash from the end of the string // since ALOS files are of the form // -ALPSRP-H__A filename.replace(0, prefix.size(), leaPrefix); leaFile.setFile(filename); if (leaFile.exists()) { return leaFile; } } return file; } bool ossimAlosPalsarModel::isAlosPalsarData(const ossimFilename& file) const { std::ifstream candidate(file.c_str(), ios::in | ios::binary); char alosFileName[16]; candidate.seekg(48); if (candidate.bad() || candidate.eof()) { return false; } candidate.read(alosFileName, 16); if (candidate.bad() || candidate.eof()) { return false; } candidate.close(); ossimString ersString(alosFileName); if ((ersString.find("AL1 ") == 0) && (ersString.find("PSR") == 4) && (ersString.find("IMOP") == 8)) { return true; } else { return false; } return true; } ossimFilename ossimAlosPalsarModel::findAlosPalsarData(const ossimFilename& file) const { ossimFilename dataFile = file; ossimString imgPrefix("IMG-HH"); // Assume the ALOS data always has at least the HH ossimString trlPrefix("TRL"); ossimString volPrefix("VOL"); ossimString leaPrefix("LED"); ossimString filename = file.fileNoExtension(); ossimString prefix = filename.substr(0, 3); if ((prefix == leaPrefix) || (prefix == trlPrefix) || (prefix == volPrefix)) { // Find the 2nd dash from the end of the string // since ALOS files are of the form // -ALPSRP-H__A filename.replace(0, prefix.size(), imgPrefix); dataFile.setFile(filename); if (dataFile.exists()) { return dataFile; } } return file; } } // namespace ossimplugins OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimAlosPalsarModel.h000066400000000000000000000070511301006202600277460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // "Copyright Centre for Remote Imaging, Sensing and Processing" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimAlosPalsarModel_H #define ossimAlosPalsarModel_H 1 #include #include #include #include #include #include #include #include namespace ossimplugins { class PlatformPosition; class SensorParams; class RefPoint; class AlosPalsarLeader; class AlosPalsarData; /** * @brief This class is able to direct localisation and indirect * localisation using the AlosPalsar sensor model. It support at least * level 1.1 data (SLC). * */ class OSSIM_PLUGINS_DLL ossimAlosPalsarModel : public ossimGeometricSarSensorModel { public: /** * @brief Constructor */ ossimAlosPalsarModel(); /** * @brief Destructor */ virtual ~ossimAlosPalsarModel(); /** * @brief Method to return the class name. * @return The name of this class. */ virtual ossimString getClassName() const; /** * @brief Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /** * @brief This function associates an image column number to a slant range when the image is georeferenced (ground projected) * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const; /** * @brief Method to instantiate model from the leader file. * @param file * @return true on success, false on error. */ bool open(const ossimFilename& file); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState(const ossimKeywordlist &kwl, const char *prefix = 0); protected: virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Initializes the Slant Range for each Ground Range data sets : theNumberSRGR,theSRGRCoeffset,_srgr_update,thePixelSpacing,_isProductGeoreferenced */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix); private: /** * @brief Pixel spacing */ double thePixelSpacing; /** * @brief List of metadata contained in the Leader file */ AlosPalsarLeader *theAlosPalsarLeader; /** * @brief List of metadata contained in the Data file */ AlosPalsarData *theAlosPalsarData; virtual bool isAlosPalsarLeader(const ossimFilename& file) const; virtual ossimFilename findAlosPalsarLeader(const ossimFilename& file) const; virtual bool isAlosPalsarData(const ossimFilename& file) const; virtual ossimFilename findAlosPalsarData(const ossimFilename& file) const; TYPE_DATA }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimCosmoSkymedModel.cpp000066400000000000000000000264011301006202600304750ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { RTTI_DEF1(ossimCosmoSkymedModel, "ossimCosmoSkymedModel", ossimGeometricSarSensorModel); ossimCosmoSkymedModel::ossimCosmoSkymedModel(): _nbCol(0), _SrGr_R0(0), _sceneCenterRangeTime(0), _pixel_spacing(0) { } ossimCosmoSkymedModel::~ossimCosmoSkymedModel() { } double ossimCosmoSkymedModel::getSlantRangeFromGeoreferenced(double col) const { // in the case of Georeferenced images, _refPoint->get_distance() contains the ground range double relativeGroundRange = _refPoint->get_distance() + _sensor->get_col_direction() * (col-_refPoint->get_pix_col())* _pixel_spacing ; double slantRange = _SrGr_coeffs[0] + _SrGr_coeffs[1]*(relativeGroundRange-_SrGr_R0) + _SrGr_coeffs[2]*(pow(relativeGroundRange,2)-_SrGr_R0) + _SrGr_coeffs[3]*(pow(relativeGroundRange,3)-_SrGr_R0) + _SrGr_coeffs[4]*(pow(relativeGroundRange,4)-_SrGr_R0) + _SrGr_coeffs[5]*(pow(relativeGroundRange,5)-_SrGr_R0); return slantRange ; } bool ossimCosmoSkymedModel::InitSensorParams(const ossimKeywordlist &kwl, const char *prefix) { const char* central_freq_str = kwl.find(prefix,"central_freq"); double central_freq = atof(central_freq_str); const char* fr_str = kwl.find(prefix,"fr"); double fr = atof(fr_str); const char* fa_str = kwl.find(prefix,"fa"); double fa = atof(fa_str); //number of different looks const char* n_azilok_str = kwl.find(prefix,"n_azilok"); double n_azilok = atof(n_azilok_str); const char* n_rnglok_str = kwl.find(prefix,"n_rnglok"); double n_rnglok = atof(n_rnglok_str); //ellipsoid parameters const char* ellip_maj_str = kwl.find(prefix,"ellip_maj"); double ellip_maj = atof(ellip_maj_str) * 1000.0; // km -> m const char* ellip_min_str = kwl.find(prefix,"ellip_min"); double ellip_min = atof(ellip_min_str) * 1000.0; // km -> m if(_sensor != NULL) { delete _sensor; } _sensor = new SensorParams(); /** * @todo : � voir sur de vrais produits (exemples de DESCENDING et ASCENDING) */ const char* orbitDirection_str = kwl.find(prefix,"orbitDirection"); std::string orbitDirection(orbitDirection_str) ; int orbitDirectionSign ; if (orbitDirection=="DESCENDING") orbitDirectionSign = 1 ; else orbitDirectionSign = - 1 ; const char* lookDirection_str = kwl.find(prefix,"lookDirection"); std::string lookDirection(lookDirection_str) ; if ((lookDirection == "Right")||(lookDirection == "RIGHT")) _sensor->set_sightDirection(SensorParams::Right) ; else _sensor->set_sightDirection(SensorParams::Left) ; const char* colsOrder_str = kwl.find(prefix,"colsOrder"); std::string colsOrder(colsOrder_str) ; const char* linsOrder_str = kwl.find(prefix,"linsOrder"); std::string linsOrder(linsOrder_str) ; if (colsOrder=="NEAR-FAR") _sensor->set_col_direction(orbitDirectionSign); else _sensor->set_col_direction(-orbitDirectionSign); if (linsOrder=="NEAR-FAR") _sensor->set_lin_direction(orbitDirectionSign); else _sensor->set_lin_direction(-orbitDirectionSign); _sensor->set_sf(fr); const double CLUM = 2.99792458e+8 ; double wave_length = CLUM / central_freq ; _sensor->set_rwl(wave_length); _sensor->set_nAzimuthLook(n_azilok); _sensor->set_nRangeLook(n_rnglok); // fa is the processing PRF _sensor->set_prf(fa * n_azilok); _sensor->set_semiMajorAxis(ellip_maj) ; _sensor->set_semiMinorAxis(ellip_min) ; return true; } bool ossimCosmoSkymedModel::InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix) { /* * Retrieval of ephemerisis number */ const char* neph_str = kwl.find(prefix,"neph"); int neph = atoi(neph_str); Ephemeris** ephemeris = new Ephemeris*[neph]; /* * Retrieval of reference date */ const char* referenceUTC_str = kwl.find(prefix,"referenceUTC"); std::string referenceUTC(referenceUTC_str) ; CivilDateTime ref_civil_date; if (! UtcDateTimeStringToCivilDate(referenceUTC, ref_civil_date)) return false; /* * Retrieval of ephemerisis */ for (int i=0;iset_pix_col(sc_pix); _refPoint->set_pix_line(sc_lin); double relative_date = (azimuthStartTime + sc_lin/_sensor->get_prf()); int second = (int) relative_date ; double decimal = relative_date - second ; CivilDateTime * date = new CivilDateTime(ref_civil_date.get_year(), ref_civil_date.get_month(), ref_civil_date.get_day(), second, decimal); if(_platformPosition != NULL) { Ephemeris * ephemeris = _platformPosition->Interpolate((JSDDateTime)*date); if (ephemeris == NULL) return false ; _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else { return false; } double c = 2.99792458e+8; double distance = (rng_gate + sc_pix*_sensor->get_nRangeLook()/_sensor->get_sf()) * (c/2.0); // in the case of Georeferenced images, the "relative" ground range is stored in place of the slant range // (used for SlantRange computation relative to reference point, necessary for optimization) // here, the pixelDirection is ignored since the CSKS reference point is always at the scene centre if (_isProductGeoreferenced) { distance = _refPoint->get_pix_col() * _pixel_spacing ; } _refPoint->set_distance(distance); // in order to use ossimSensorModel::lineSampleToWorld const char* nbCol_str = kwl.find(prefix,"nbCol"); const char* nbLin_str = kwl.find(prefix,"nbLin"); theImageSize.x = atoi(nbCol_str); theImageSize.y = atoi(nbLin_str); theImageClipRect = ossimDrect(0, 0, theImageSize.x-1, theImageSize.y-1); // Ground Control Points extracted from the model : scene center and corners std::list groundGcpCoordinates ; std::list imageGcpCoordinates ; char name[64]; for (int k=0 ; k<5 ; k++) { sprintf(name,"cornersCol%i",k); const char* i_str = kwl.find(name); int i = atoi(i_str); sprintf(name,"cornersLin%i",k); const char* j_str = kwl.find(name); int j = atoi(j_str); sprintf(name,"cornersLon%i",k); const char* lon_str = kwl.find(name); double lon = atof(lon_str); sprintf(name,"cornersLat%i",k); const char* lat_str = kwl.find(name); double lat = atof(lat_str); sprintf(name,"cornersHeight%i",k); const char* height_str = kwl.find(name); double height = atof(height_str) ; ossimDpt imageGCP(i,j); ossimGpt groundGCP(lat, lon, height); groundGcpCoordinates.push_back(groundGCP) ; imageGcpCoordinates.push_back(imageGCP) ; } // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates) ; return true; } bool ossimCosmoSkymedModel::InitSRGR(const ossimKeywordlist &kwl, const char *prefix) { const char* rangeProjectionType_str = kwl.find(prefix,"rangeProjectionType"); std::string rangeProjectionType(rangeProjectionType_str); const char* pixel_spacing_str = kwl.find(prefix,"pixel_spacing"); _pixel_spacing= atof(pixel_spacing_str); _isProductGeoreferenced = (rangeProjectionType=="GROUNDRANGE") ; // Number of columns const char* nbCol_str = kwl.find(prefix,"nbCol"); _nbCol = atoi(nbCol_str); // SRGR polynomial reference const char* SrGr_R0_str = kwl.find(prefix,"SrGr_R0"); _SrGr_R0 = atof(SrGr_R0_str); // SRGR coefficients char name[64]; double coeff ; for(int i=0;i<6;i++) { sprintf(name,"SrToGr_coeffs_%i",i); const char* coeff_str = kwl.find(prefix,name); coeff = atof(coeff_str); _SrGr_coeffs.push_back(coeff); } return true; } bool ossimCosmoSkymedModel::UtcDateTimeStringToCivilDate(const std::string &utcString, CivilDateTime &outputDate) { // conversion : // try with date format yyyymmdd if (utcString.size() < 8) return false ; const char* stringUTCDate = utcString.c_str() ; char year_str[5]; for (int i=0;i<4;i++) { year_str[i] = stringUTCDate[i]; } year_str[4] = '\0'; char month_str[3]; for (int i=4;i<6;i++) { month_str[i-4] = stringUTCDate[i]; } month_str[2] = '\0'; char day_str[3]; for (int i=6;i<8;i++) { day_str[i-6] = stringUTCDate[i]; } day_str[2] = '\0'; outputDate.set_year(atoi(year_str)); outputDate.set_month(atoi(month_str)); outputDate.set_day(atoi(day_str)); outputDate.set_second(0); outputDate.set_decimal(0.0); return true ; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimCosmoSkymedModel.h000066400000000000000000000045441301006202600301460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimCosmoSkymedModel_H #define ossimCosmoSkymedModel_H #include #include #include #include #include #include #include #include #include namespace ossimplugins { class PlatformPosition; class SensorParams; class RefPoint; /** * @brief This class allows for direct localisation and indirect localisation * using the CosmoSkymed sensor model */ class ossimCosmoSkymedModel : public ossimGeometricSarSensorModel { public: /** * @brief Constructor */ ossimCosmoSkymedModel(); /** * @brief Destructor */ ~ossimCosmoSkymedModel(); /** * @brief This function associates an image column number to a slant range when the image is georeferenced (ground projected) * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const; protected: /** * @brief Number of columns */ double _nbCol; /** * @brief Slant Range for each Ground Range Projection reference point */ double _SrGr_R0 ; /** * @brief Slant Range for each Ground Range Projection coefficients */ std::vector _SrGr_coeffs ; /** * @brief Scene Center range time */ double _sceneCenterRangeTime; /** * @brief Pixel spacing */ double _pixel_spacing ; private: virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Initializes the Slant Range to Ground Range data sets : * _SrToGr_R0,_SrToGr_coeffs_number,_SrToGr_exponent,_SrToGr_coeffs,_nbCol */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix); bool UtcDateTimeStringToCivilDate(const std::string &utcString, CivilDateTime &outputDate); TYPE_DATA }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimEnvisatAsarModel.cpp000066400000000000000000000611251301006202600304620ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { RTTI_DEF1(ossimEnvisatAsarModel, "ossimEnvisatAsarModel", ossimGeometricSarSensorModel); // Static trace for debugging static ossimTrace traceDebug("ossimEnvisatAsarModel:debug"); ossimEnvisatAsarModel::ossimEnvisatAsarModel(): _n_srgr(0), _pixel_spacing(0), _EnvisatAsarData(NULL) { } ossimEnvisatAsarModel::~ossimEnvisatAsarModel() { if(_EnvisatAsarData != NULL) { delete _EnvisatAsarData; } } ossimString ossimEnvisatAsarModel::getClassName() const { return ossimString("ossimEnvisatAsarModel"); } ossimObject* ossimEnvisatAsarModel::dup() const { return new ossimEnvisatAsarModel(*this); } double ossimEnvisatAsarModel::getSlantRangeFromGeoreferenced(double col) const { const double CLUM = 2.99792458e+8 ; double GR, GR0, relativeGroundRange, slantRange, slantrangetime; if (_n_srgr==0) return(-1) ; std::vector coefset = FindSRGRSetNumber((_refPoint->get_ephemeris())->get_date()) ; GR = _sensor->get_col_direction() * (col)* _pixel_spacing ; GR0 = coefset[0]; relativeGroundRange = GR-GR0; slantRange = coefset[1] + coefset[2]*relativeGroundRange + coefset[3]*pow(relativeGroundRange,2) + coefset[4]*pow(relativeGroundRange,3) + coefset[5]*pow(relativeGroundRange,4); slantrangetime = 2.0*slantRange / (CLUM); return slantRange ; } bool ossimEnvisatAsarModel::open(const ossimFilename& file) { bool retValue = true; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimEnvisatAsarTileSource::open(filename) DEBUG: entered..." << std::endl << "Attempting to open file " << file << std::endl; } /* * Creation of the class allowing to store EnvisatAsarData file metadata */ if (_EnvisatAsarData != NULL) { delete _EnvisatAsarData; _EnvisatAsarData = NULL; } /* * Opening and test of the file */ ossimFilename Filename = file; ifstream dataFile(Filename.c_str(), ios::in | ios::binary); if (dataFile.eof()) { dataFile.close(); retValue = false; } else { mph mph_rec; // test if it is an ENVISAT Data file if (dataFile >> mph_rec && mph_rec.is_valid()) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Begin reading EnvisatAsar file" << std::endl; } /* * Reading EnvisatAsarData file data */ dataFile.seekg(0); _EnvisatAsarData = new EnvisatAsarData(); dataFile >> *_EnvisatAsarData; dataFile.close(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading EnvisatAsar file" << std::endl; } } else { dataFile.close(); retValue = false; } } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimEnvisatAsarTileSource::open() DEBUG: returning..." << std::endl; } return retValue; } bool ossimEnvisatAsarModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { char name[64]; kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimEnvisatAsarModel", true); /* * Adding metadata necessary to the sensor model into the keywordlist * Data derived from the SPH record */ sph* sph_rec = _EnvisatAsarData->get_sph(); if(sph_rec != NULL) { kwl.add(prefix, "pixel_spacing", sph_rec->get_range_spacing().c_str(), true ); kwl.add(prefix, "line_time_interval", sph_rec->get_line_time_interval().c_str(), true ); } else { return false; } /* * Adding metadata necessary to the sensor model into the keywordlist * Data derived from the Main Processing Parameters record */ MainProcessingParameters* MPP_rec = _EnvisatAsarData->get_MainProcessingParameters(); if(MPP_rec != NULL) { kwl.add(prefix, "num_pix", (double)MPP_rec->get_num_samples_per_line(), true ); kwl.add(prefix, "num_lines", (double)MPP_rec->get_num_output_lines(), true ); kwl.add(prefix, "wave_length", MPP_rec->get_radar_freq(), true ); kwl.add(prefix, "range_sampling_rate", MPP_rec->get_range_samp_rate(), true ); kwl.add(prefix, "prf", MPP_rec->get_prf(), true ); kwl.add(prefix, "avg_scene_height", MPP_rec->get_avg_scene_height_ellpsoid(), true ); kwl.add(prefix, "is_groundrange", MPP_rec->get_srgr_flag(), true ); kwl.add(prefix, "state_vector_time_1_day", (double)MPP_rec->get_state_vector_time_1_day(), true ); kwl.add(prefix, "state_vector_time_1_sec", (double)MPP_rec->get_state_vector_time_1_sec(), true ); kwl.add(prefix, "state_vector_time_1_microsec", (double)MPP_rec->get_state_vector_time_1_microsec(), true ); kwl.add(prefix, "x_pos_1", (double)MPP_rec->get_x_pos_1(), true ); kwl.add(prefix, "y_pos_1", (double)MPP_rec->get_y_pos_1(), true ); kwl.add(prefix, "z_pos_1", (double)MPP_rec->get_z_pos_1(), true ); kwl.add(prefix, "x_vel_1", (double)MPP_rec->get_x_vel_1(), true ); kwl.add(prefix, "y_vel_1", (double)MPP_rec->get_y_vel_1(), true ); kwl.add(prefix, "z_vel_1", (double)MPP_rec->get_z_vel_1(), true ); kwl.add(prefix, "state_vector_time_2_day",(double) MPP_rec->get_state_vector_time_2_day(), true ); kwl.add(prefix, "state_vector_time_2_sec", (double)MPP_rec->get_state_vector_time_2_sec(), true ); kwl.add(prefix, "state_vector_time_2_microsec", (double)MPP_rec->get_state_vector_time_2_microsec(), true ); kwl.add(prefix, "x_pos_2", (double)MPP_rec->get_x_pos_2(), true ); kwl.add(prefix, "y_pos_2", (double)MPP_rec->get_y_pos_2(), true ); kwl.add(prefix, "z_pos_2", (double)MPP_rec->get_z_pos_2(), true ); kwl.add(prefix, "x_vel_2", (double)MPP_rec->get_x_vel_2(), true ); kwl.add(prefix, "y_vel_2", (double)MPP_rec->get_y_vel_2(), true ); kwl.add(prefix, "z_vel_2", (double)MPP_rec->get_z_vel_2(), true ); kwl.add(prefix, "state_vector_time_3_day", (double)MPP_rec->get_state_vector_time_3_day(), true ); kwl.add(prefix, "state_vector_time_3_sec", (double)MPP_rec->get_state_vector_time_3_sec(), true ); kwl.add(prefix, "state_vector_time_3_microsec", (double)MPP_rec->get_state_vector_time_3_microsec(), true ); kwl.add(prefix, "x_pos_3", (double)MPP_rec->get_x_pos_3(), true ); kwl.add(prefix, "y_pos_3", (double)MPP_rec->get_y_pos_3(), true ); kwl.add(prefix, "z_pos_3", (double)MPP_rec->get_z_pos_3(), true ); kwl.add(prefix, "x_vel_3", (double)MPP_rec->get_x_vel_3(), true ); kwl.add(prefix, "y_vel_3", (double)MPP_rec->get_y_vel_3(), true ); kwl.add(prefix, "z_vel_3", (double)MPP_rec->get_z_vel_3(), true ); kwl.add(prefix, "state_vector_time_4_day", (double)MPP_rec->get_state_vector_time_4_day(), true ); kwl.add(prefix, "state_vector_time_4_sec", (double)MPP_rec->get_state_vector_time_4_sec(), true ); kwl.add(prefix, "state_vector_time_4_microsec", (double)MPP_rec->get_state_vector_time_4_microsec(), true ); kwl.add(prefix, "x_pos_4", (double)MPP_rec->get_x_pos_4(), true ); kwl.add(prefix, "y_pos_4", (double)MPP_rec->get_y_pos_4(), true ); kwl.add(prefix, "z_pos_4", (double)MPP_rec->get_z_pos_4(), true ); kwl.add(prefix, "x_vel_4", (double)MPP_rec->get_x_vel_4(), true ); kwl.add(prefix, "y_vel_4", (double)MPP_rec->get_y_vel_4(), true ); kwl.add(prefix, "z_vel_4", (double)MPP_rec->get_z_vel_4(), true ); kwl.add(prefix, "state_vector_time_5_day", (double)MPP_rec->get_state_vector_time_5_day(), true ); kwl.add(prefix, "state_vector_time_5_sec", (double)MPP_rec->get_state_vector_time_5_sec(), true ); kwl.add(prefix, "state_vector_time_5_microsec", (double)MPP_rec->get_state_vector_time_5_microsec(), true ); kwl.add(prefix, "x_pos_5", (double)MPP_rec->get_x_pos_5(), true ); kwl.add(prefix, "y_pos_5",(double) MPP_rec->get_y_pos_5(), true ); kwl.add(prefix, "z_pos_5", (double)MPP_rec->get_z_pos_5(), true ); kwl.add(prefix, "x_vel_5", (double)MPP_rec->get_x_vel_5(), true ); kwl.add(prefix, "y_vel_5", (double)MPP_rec->get_y_vel_5(), true ); kwl.add(prefix, "z_vel_5", (double)MPP_rec->get_z_vel_5(), true ); } else { return false; } /* * Adding metadata necessary to the sensor model into the keywordlist * Data derived from the Geolocation Grid record - Reference Point */ GeolocationGrid* GG_rec = _EnvisatAsarData->get_GeolocationGrid(0); if(GG_rec != NULL) { kwl.add(prefix, "first_zero_doppler_time_day", (double)GG_rec->get_first_zero_doppler_time_day(), true ); kwl.add(prefix, "first_zero_doppler_time_sec", (double)GG_rec->get_first_zero_doppler_time_sec(), true ); kwl.add(prefix, "first_zero_doppler_time_microsec", (double)GG_rec->get_first_zero_doppler_time_microsec(), true ); kwl.add(prefix, "line_num", (double)GG_rec->get_line_num(), true ); kwl.add(prefix, "samp_num", (double)(GG_rec->get_samp_numbers())[0], true ); kwl.add(prefix, "slant_range_time", (double)(GG_rec->get_slant_range_times())[0], true ); } else { return false; } /* * Adding metadata necessary to the sensor model into the keywordlist * Data derived from the Geolocation Grid record - Corners */ GG_rec = _EnvisatAsarData->get_GeolocationGrid(0); if(GG_rec != NULL) { kwl.add(prefix, "UL_line", (double)GG_rec->get_line_num(), true ); kwl.add(prefix, "UL_col", (double)(GG_rec->get_samp_numbers())[0], true ); kwl.add(prefix, "UL_lat", (double)(GG_rec->get_lats())[0], true ); kwl.add(prefix, "UL_lon", (double)(GG_rec->get_longs())[0], true ); kwl.add(prefix, "UR_line", (double)GG_rec->get_line_num(), true ); kwl.add(prefix, "UR_col", (double)(GG_rec->get_samp_numbers())[10], true ); kwl.add(prefix, "UR_lat", (double)(GG_rec->get_lats())[10], true ); kwl.add(prefix, "UR_lon", (double)(GG_rec->get_longs())[10], true ); } else { return false; } GG_rec = _EnvisatAsarData->get_GeolocationGrid(10); if(GG_rec != NULL) { kwl.add(prefix, "LL_line", (double)GG_rec->get_line_num(), true ); kwl.add(prefix, "LL_col", (double)(GG_rec->get_samp_numbers())[0], true ); kwl.add(prefix, "LL_lat", (double)(GG_rec->get_lats())[0], true ); kwl.add(prefix, "LL_lon", (double)(GG_rec->get_longs())[0], true ); kwl.add(prefix, "LR_line", (double)GG_rec->get_line_num(), true ); kwl.add(prefix, "LR_col", (double)(GG_rec->get_samp_numbers())[10], true ); kwl.add(prefix, "LR_lat", (double)(GG_rec->get_lats())[10], true ); kwl.add(prefix, "LR_lon", (double)(GG_rec->get_longs())[10], true ); } else { return false; } /* * Adding metadata necessary to the sensor model into the keywordlist */ int n_srgr = 0; SRGRConversionParameters * SRGRParameters = _EnvisatAsarData->get_SRGRConversionParameters(0); if(SRGRParameters != NULL) { n_srgr = _EnvisatAsarData->get_num_ds(SRGRParameters); for (int i=0;iget_SRGRConversionParameters(i); sprintf(name,"srgr_update_day%i",i); kwl.add(prefix, name, (double)SRGR->get_first_zero_doppler_time_day(),true); sprintf(name,"srgr_update_sec%i",i); kwl.add(prefix, name, (double)SRGR->get_first_zero_doppler_time_sec(),true); sprintf(name,"srgr_update_microsec%i",i); kwl.add(prefix, name, (double)SRGR->get_first_zero_doppler_time_microsec(),true); sprintf(name,"srgr_coef%iA",i); kwl.add(prefix, name,(double)SRGR->get_ground_range_origin(),true); sprintf(name,"srgr_coef%iB",i); kwl.add(prefix, name,(double)SRGR->get_srgr_coef()[0],true); sprintf(name,"srgr_coef%iC",i); kwl.add(prefix, name,(double)SRGR->get_srgr_coef()[1],true); sprintf(name,"srgr_coef%iD",i); kwl.add(prefix, name,(double)SRGR->get_srgr_coef()[2],true); sprintf(name,"srgr_coef%iE",i); kwl.add(prefix, name,(double)SRGR->get_srgr_coef()[3]*1e10,true); sprintf(name,"srgr_coef%iF",i); kwl.add(prefix, name,(double)SRGR->get_srgr_coef()[4]*1e10,true); } } kwl.add(prefix, "n_srgr" , n_srgr,true); return true; } bool ossimEnvisatAsarModel::loadState (const ossimKeywordlist &kwl, const char *prefix) { InitSensorParams(kwl, prefix); InitPlatformPosition(kwl, prefix); InitRefPoint(kwl, prefix); InitSRGR(kwl, prefix); return true; } std::ostream& ossimEnvisatAsarModel::print(std::ostream& out) const { // Capture the original flags. std::ios_base::fmtflags f = out.flags(); out << setprecision(15) << setiosflags(ios::fixed) << "\nossimEnvisatAsarModel data members:\n" << "_pixel_spacing: " << _pixel_spacing << "\n" << "_n_srgr: " << _n_srgr << "\n"; ossimGeometricSarSensorModel::print(out); // Reset flags. out.setf(f); return out; } bool ossimEnvisatAsarModel::InitSensorParams(const ossimKeywordlist &kwl, const char *prefix) { const double CLUM = 2.99792458e+8; const char* wave_length_str = kwl.find(prefix,"wave_length"); double wave_length = CLUM / atof(wave_length_str); const char* fr_str = kwl.find(prefix,"range_sampling_rate"); double fr = atof(fr_str); // product type : Slant Range or Ground Range _isProductGeoreferenced = atoi(kwl.find(prefix,"is_groundrange")); double fa; if (!_isProductGeoreferenced) { const char* fa_str = kwl.find(prefix,"prf"); fa = atof(fa_str); } else { const char* fa_str = kwl.find(prefix,"line_time_interval"); fa = 1.0/atof(fa_str); } // TODO : v�rifier que ceci est ok pour les produits IMP const char* time_dir_pix = "INCREASE"; const char* time_dir_lin = "INCREASE"; if(_sensor != NULL) { delete _sensor; } _sensor = new SensorParams(); if(strcmp(time_dir_pix, "INCREASE") == 0) { _sensor->set_col_direction(1); } else { _sensor->set_col_direction(-1); } if(strcmp(time_dir_lin, "INCREASE") == 0) { _sensor->set_lin_direction(1); } else { _sensor->set_lin_direction(-1); } _sensor->set_prf(fa); _sensor->set_sf(fr); _sensor->set_rwl(wave_length); return true; } bool ossimEnvisatAsarModel::InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix) { const int neph = 5; // long val_long; // unsigned long val_ulong1; // unsigned long val_ulong2; CivilDateTime ref_civil_date; Ephemeris** ephemeris = new Ephemeris*[neph]; for (int i=1;i<=neph;i++) { double pos[3]; double vel[3]; char name[64]; /* * Date de l'ephemeride */ sprintf(name,"state_vector_time_%i_day",i); long day = (long) atof(kwl.find(prefix,name)); sprintf(name,"state_vector_time_%i_sec",i); unsigned long sec = (unsigned long) atof(kwl.find(prefix,name)); sprintf(name,"state_vector_time_%i_microsec",i); unsigned long microsec = (unsigned long) atof(kwl.find(prefix,name)); MJDDateTime mjdDate(day, sec, microsec); JSDDateTime jsd_date(mjdDate); /* * Position de l'ephemeride */ sprintf(name,"x_pos_%i",i); pos[0] = (double) atoi(kwl.find(prefix,name)) * 1.0e-2; sprintf(name,"y_pos_%i",i); pos[1] = (double) atoi(kwl.find(prefix,name)) * 1.0e-2; sprintf(name,"z_pos_%i",i); pos[2] = (double) atoi(kwl.find(prefix,name)) * 1.0e-2; /* * Vitesse de l'ephemeride */ sprintf(name,"x_vel_%i",i); vel[0] = (double) atoi(kwl.find(prefix,name)) * 1.0e-5; sprintf(name,"y_vel_%i",i); vel[1] = (double) atoi(kwl.find(prefix,name)) * 1.0e-5; sprintf(name,"z_vel_%i",i); vel[2] = (double) atoi(kwl.find(prefix,name)) * 1.0e-5; GeographicEphemeris* eph = new GeographicEphemeris(jsd_date, pos, vel); ephemeris[i-1] = eph; } if (_platformPosition != NULL) { delete _platformPosition; } _platformPosition = new PlatformPosition(ephemeris,neph); /* * Liberation de la memoire utilis�e par la liste des ephemerides * ->Le constructeur effectue une copie des ephemerides */ for (int i=0;iset_pix_col(sc_pix); double sc_lin = atof(kwl.find(prefix,"line_num")) - 1.0; _refPoint->set_pix_line(sc_lin); // Reference Point distance double c = 2.99792458e+8; double distance = atof(kwl.find(prefix,"slant_range_time")) * (c/2.0) * 1.0e-9; _refPoint->set_distance(distance); // Reference Point Ephemeris long day_ref = (long)atof(kwl.find(prefix,"first_zero_doppler_time_day")); unsigned long sec_ref = (unsigned long)atof(kwl.find(prefix,"first_zero_doppler_time_sec")); unsigned long microsec_ref = (unsigned long)atof(kwl.find(prefix,"first_zero_doppler_time_microsec")); MJDDateTime mjdDate_ref(day_ref, sec_ref, microsec_ref); JSDDateTime jsd_date_ref(mjdDate_ref); if(_platformPosition != NULL) { Ephemeris * ephemeris = _platformPosition->Interpolate(jsd_date_ref); if (ephemeris == NULL) return false ; _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else return false; // Adjustement of the model using the four corner points // in order to use ossimSensorModel::lineSampleToWorld const char* nbCol_str = kwl.find(prefix,"num_pix"); const char* nbLin_str = kwl.find(prefix,"num_lines"); theImageSize.x = atoi(nbCol_str); theImageSize.y = atoi(nbLin_str); theImageClipRect = ossimDrect(0, 0, theImageSize.x-1, theImageSize.y-1); // Ground Control Points extracted from the model : corner points std::list groundGcpCoordinates ; std::list imageGcpCoordinates ; double h = atof(kwl.find("avg_scene_height")); // first line first pix double line = atof(kwl.find("UL_line")) - 1; double col = atof(kwl.find("UL_col")) - 1; double lon = atof(kwl.find("UL_lon")) * 1e-6; double lat = atof(kwl.find("UL_lat")) * 1e-6; if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP1(col,line); ossimGpt groundGCP1(lat, lon, h); groundGcpCoordinates.push_back(groundGCP1) ; imageGcpCoordinates.push_back(imageGCP1) ; // first line last pix line = atof(kwl.find("UR_line")) - 1; col = atof(kwl.find("UR_col")) - 1; lon = atof(kwl.find("UR_lon")) * 1e-6; lat = atof(kwl.find("UR_lat")) * 1e-6; if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP2(col,line); ossimGpt groundGCP2(lat, lon, h); groundGcpCoordinates.push_back(groundGCP2) ; imageGcpCoordinates.push_back(imageGCP2) ; // last line last pix line = atof(kwl.find("LR_line")) - 1; col = atof(kwl.find("LR_col")) - 1; lon = atof(kwl.find("LR_lon")) * 1e-6; lat = atof(kwl.find("LR_lat")) * 1e-6; if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP3(col,line); ossimGpt groundGCP3(lat, lon, h); groundGcpCoordinates.push_back(groundGCP3) ; imageGcpCoordinates.push_back(imageGCP3) ; // last line first pix line = atof(kwl.find("LL_line")) - 1; col = atof(kwl.find("LL_col")) - 1; lon = atof(kwl.find("LL_lon")) * 1e-6; lat = atof(kwl.find("LL_lat")) * 1e-6; if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP4(col,line); ossimGpt groundGCP4(lat, lon, h); groundGcpCoordinates.push_back(groundGCP4) ; imageGcpCoordinates.push_back(imageGCP4) ; // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates) ; return true; } bool ossimEnvisatAsarModel::InitSRGR(const ossimKeywordlist &kwl, const char *prefix) { // product type : Slant Range or Ground Range _isProductGeoreferenced = atoi(kwl.find(prefix,"is_groundrange")); // pixel spacing _pixel_spacing = atof(kwl.find(prefix,"pixel_spacing")); // number of SRGR sets _n_srgr = atoi(kwl.find(prefix,"n_srgr")); char name[64]; for (int i=0;i<_n_srgr;i++) { // SRGR update time sprintf(name,"srgr_update_day%i",i); long day_ref = (long)atof(kwl.find(prefix,name)); sprintf(name,"srgr_update_sec%i",i); unsigned long sec_ref = (unsigned long)atof(kwl.find(prefix,name)); sprintf(name,"srgr_update_microsec%i",i); unsigned long microsec_ref = (unsigned long)atof(kwl.find(prefix,name)); MJDDateTime mjdDate_ref(day_ref, sec_ref, microsec_ref); JSDDateTime jsd_date_ref(mjdDate_ref); _srgr_update.push_back(jsd_date_ref); std::vector srgr_set; // SRGR coefficients sprintf(name,"srgr_coef%iA",i); const char* srgr_coef_strA = kwl.find(prefix,name); srgr_set.push_back(atof(srgr_coef_strA)); sprintf(name,"srgr_coef%iB",i); const char* srgr_coef_strB = kwl.find(prefix,name); srgr_set.push_back(atof(srgr_coef_strB)); sprintf(name,"srgr_coef%iC",i); const char* srgr_coef_strC = kwl.find(prefix,name); srgr_set.push_back(atof(srgr_coef_strC)); sprintf(name,"srgr_coef%iD",i); const char* srgr_coef_strD = kwl.find(prefix,name); srgr_set.push_back(atof(srgr_coef_strD)); sprintf(name,"srgr_coef%iE",i); const char* srgr_coef_strE = kwl.find(prefix,name); srgr_set.push_back(atof(srgr_coef_strE)*1e-10); sprintf(name,"srgr_coef%iF",i); const char* srgr_coef_strF = kwl.find(prefix,name); srgr_set.push_back(atof(srgr_coef_strF)*1e-10); _srgr_coefset.push_back(srgr_set); } return true; } std::vector ossimEnvisatAsarModel::FindSRGRSetNumber(JSDDateTime date) const { //if (_n_srgr==0) return NULL ; std::vector delays; double delay; for (int i=0;i<_n_srgr;i++) { JSDDateTime datetmp(_srgr_update.at(i)); delay = date.get_second()+date.get_decimal() - (datetmp.get_second() + datetmp.get_decimal()); delays.push_back( fabs(delay) ); } int setNumber = 0 ; double min_delay = delays[0] ; for (int i=1;i<_n_srgr;i++) { if (delays[i] #include #include #include #include #include #include #include #include namespace ossimplugins { class PlatformPosition; class SensorParams; class RefPoint; /** * @brief This class is able to direct localisation and indirect localisation * using the EnvisatAsar sensor model */ class ossimEnvisatAsarModel : public ossimGeometricSarSensorModel { public: /** * @brief Constructor */ ossimEnvisatAsarModel(); /** * @brief Destructor */ virtual ~ossimEnvisatAsarModel(); /** * @brief Method to return the class name. * @return The name of this class. */ virtual ossimString getClassName() const; /** * @brief Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /** * @brief This function associates an image column number to a slant range when the image is georeferenced (ground projected) * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const; /** * @brief Method to intantial model from a file. * * @param file * * @return true on success, false on error. */ bool open(const ossimFilename& file); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; protected: /** * @brief Slant Range to Ground Range (SRGR) number of coefficients sets */ int _n_srgr; /** * @brief SRGR coefficient sets */ std::vector< std::vector > _srgr_coefset; /** * @brief SRGR coefficient sets update times */ std::vector _srgr_update; /** * @brief Pixel spacing */ double _pixel_spacing; private: virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Initializes the Slant Range for each Ground Range data sets : _n_srgr,_srgr_coefset,_srgr_update,_pixel_spacing,_isProductGeoreferenced */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Finds the SRGR data set which update time is the closest to the center scene time */ std::vector FindSRGRSetNumber(JSDDateTime date) const; TYPE_DATA /** * @brief List of metadata contained in the Data file */ EnvisatAsarData * _EnvisatAsarData; }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimErsSarModel.cpp000066400000000000000000000453131301006202600274420ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include // Static trace for debugging static ossimTrace traceDebug("ossimErsSarModel:debug"); #include #include namespace ossimplugins { RTTI_DEF1(ossimErsSarModel, "ossimErsSarModel", ossimGeometricSarSensorModel); ossimErsSarModel::ossimErsSarModel(): theNumberSRGR(0), thePixelSpacing(0), theErsSarleader(NULL) { theSRGRCoeffset[0][0] = 0.0; theSRGRCoeffset[0][1] = 0.0; theSRGRCoeffset[0][2] = 0.0; } ossimErsSarModel::~ossimErsSarModel() { if (theErsSarleader != NULL) { delete theErsSarleader; theErsSarleader = NULL; } } ossimString ossimErsSarModel::getClassName() const { return ossimString("ossimErsSarModel"); } ossimObject* ossimErsSarModel::dup() const { return new ossimErsSarModel(*this); } double ossimErsSarModel::getSlantRangeFromGeoreferenced(double col) const { const double c = 2.99792458e+8; double tn = theSRGRCoeffset[0][0] + theSRGRCoeffset[0][1] * col + theSRGRCoeffset[0][2] * col * col ; return tn *(c / 2.0); } bool ossimErsSarModel::InitSensorParams(const ossimKeywordlist &kwl, const char *prefix) { const char* wave_length_str = kwl.find(prefix, "wave_length"); double wave_length = atof(wave_length_str); const char* fr_str = kwl.find(prefix, "fr"); double fr = atof(fr_str) * 1e6; const char* fa_str = kwl.find(prefix, "fa"); double fa = atof(fa_str); ossimString time_dir_pix = kwl.find(prefix, "time_dir_pix"); time_dir_pix.upcase(); //std::transform(time_dir_pix.begin(), time_dir_pix.end(), time_dir_pix.begin(), toupper); ossimString time_dir_lin = kwl.find(prefix, "time_dir_lin"); time_dir_lin.upcase(); //std::transform(time_dir_lin.begin(), time_dir_lin.end(), time_dir_lin.begin(), toupper); //ellipsoid parameters const char* ellip_maj_str = kwl.find(prefix, "ellip_maj"); double ellip_maj = atof(ellip_maj_str) * 1000.0; // km -> m const char* ellip_min_str = kwl.find(prefix, "ellip_min"); double ellip_min = atof(ellip_min_str) * 1000.0; // km -> m if (_sensor != NULL) { delete _sensor; } _sensor = new SensorParams(); if (strcmp(time_dir_pix.c_str(), "INCREASE") == 0) { _sensor->set_col_direction(1); } else { _sensor->set_col_direction(-1); } if (strcmp(time_dir_lin.c_str(), "INCREASE") == 0) { _sensor->set_lin_direction(1); } else { _sensor->set_lin_direction(-1); } _sensor->set_sightDirection(SensorParams::Right) ; double nlooks_az = atof(kwl.find(prefix, "nlooks_az")); _sensor->set_nAzimuthLook(nlooks_az); double n_rnglok = atof(kwl.find(prefix, "n_rnglok")); _sensor->set_nRangeLook(n_rnglok); _sensor->set_prf(fa); _sensor->set_sf(fr); _sensor->set_rwl(wave_length); _sensor->set_semiMajorAxis(ellip_maj) ; _sensor->set_semiMinorAxis(ellip_min) ; return true; } bool ossimErsSarModel::open(const ossimFilename& file) { static const char MODULE[] = "ossimErsSarModel::open"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n" << "file: " << file << "\n"; } bool result = false; ossimFilename leaFilename = file; /* * Creation of the class allowing to store Leader file metadata */ if (theErsSarleader != NULL) { delete theErsSarleader; theErsSarleader = NULL; } theErsSarleader = new ErsSarLeader(); if (leaFilename.exists()) { result = isErsLeader(leaFilename); if (result == false) { leaFilename = findErsLeader(file); } result = isErsLeader(leaFilename); if (result == true) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "is ERS leader file..." << "Begin reading Leader file" << std::endl; } /* * Leader file data reading */ std::ifstream leaderFile(leaFilename.c_str(), ios::in | ios::binary); leaderFile >> *theErsSarleader; leaderFile.close(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading Leader file" << std::endl; } //To initialize the whole state, reusing saveState/loadState //FIXME: This could be at the superclass level instead ossimKeywordlist kwl; saveState(kwl); loadState(kwl); } // matches: if ( result=isErsLeader(file) == True ) } // matches: if ( file.exists() ) if (traceDebug()) { this->print(ossimNotify(ossimNotifyLevel_DEBUG)); ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } return result; } bool ossimErsSarModel::saveState(ossimKeywordlist& kwl, const char* /* prefix */) const { static const char MODULE[] = "ossimErsSarModel::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result(false); //kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimErsSarModel", true); if (theErsSarleader == NULL) { std::cout << "Error: ErsSarleader is NULL" << std::endl; return false; } result = theErsSarleader->saveState(kwl); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } return result; } bool ossimErsSarModel::loadState(const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimErsSarModel::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } const char* lookup = 0; ossimString s; // Check the type first. lookup = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (lookup) { s = lookup; if (s != getClassName()) { return false; } } // Load the base class. // bool result = ossimGeometricSarSensorModel::loadState(kwl, prefix); bool result = false; result = InitPlatformPosition(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init platform position \n"; } } if (result) { result = InitSensorParams(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init sensor parameters \n"; } } } if (result) { result = InitRefPoint(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init ref point \n"; } } } if (result) { result = InitSRGR(kwl, prefix); if (!result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nCan't init ref point \n"; } } } return result; } bool ossimErsSarModel::InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix) { // const double PI = 3.14159265358979323846 ; CivilDateTime ref_civil_date; /* * Ephemerisis reference date retrieval */ const char* eph_year_str = kwl.find(prefix, "eph_year"); int eph_year = atoi(eph_year_str); const char* eph_month_str = kwl.find(prefix, "eph_month"); int eph_month = atoi(eph_month_str); const char* eph_day_str = kwl.find(prefix, "eph_day"); int eph_day = atoi(eph_day_str); const char* eph_sec_str = kwl.find(prefix, "eph_sec"); double eph_sec = atof(eph_sec_str); ref_civil_date.set_year(eph_year); ref_civil_date.set_month(eph_month); ref_civil_date.set_day(eph_day); ref_civil_date.set_second((int)eph_sec); ref_civil_date.set_decimal(eph_sec - (double)((int)eph_sec)); JSDDateTime ref_jsd_date(ref_civil_date); /* * Ephemerisis time interval retrieval */ const char* eph_int_str = kwl.find(prefix, "eph_int"); double eph_int = atof(eph_int_str); /* * Ephemerisis number retrieval */ const char* neph_str = kwl.find(prefix, "neph"); int neph = atoi(neph_str); Ephemeris** ephemeris = new Ephemeris*[neph]; /* * Ephemerisis retrieval */ for (int i = 0; i < neph; i++) { double pos[3]; double vit[3]; char name[64]; sprintf(name, "eph%i_posX", i); const char* px_str = kwl.find(prefix, name); pos[0] = atof(px_str); sprintf(name, "eph%i_posY", i); const char* py_str = kwl.find(prefix, name); pos[1] = atof(py_str); sprintf(name, "eph%i_posZ", i); const char* pz_str = kwl.find(prefix, name); pos[2] = atof(pz_str); sprintf(name, "eph%i_velX", i); const char* vx_str = kwl.find(prefix, name); vit[0] = atof(vx_str); sprintf(name, "eph%i_velY", i); const char* vy_str = kwl.find(prefix, name); vit[1] = atof(vy_str); sprintf(name, "eph%i_velZ", i); const char* vz_str = kwl.find(prefix, name); vit[2] = atof(vz_str); /* * Ephemerisis date */ JSDDateTime date(ref_jsd_date); date.set_second(date.get_second() + i * eph_int); date.NormDate(); GeographicEphemeris* eph = new GeographicEphemeris(date, pos, vit); ephemeris[i] = eph; } /* * Antenna position interpolator creation */ if (_platformPosition != NULL) { delete _platformPosition; } _platformPosition = new PlatformPosition(ephemeris, neph); /* * Free of memory used by the ephemerisis list */ for (int i = 0; i < neph; i++) { delete ephemeris[i]; } delete[] ephemeris; return true; } bool ossimErsSarModel::InitRefPoint(const ossimKeywordlist &kwl, const char *prefix) { const char* sc_lin_str = kwl.find(prefix, "sc_lin"); double sc_lin = atof(sc_lin_str); const char* sc_pix_str = kwl.find(prefix, "sc_pix"); double sc_pix = atof(sc_pix_str); const char* inp_sctim_str = kwl.find(prefix, "inp_sctim"); const char* rng_gate_str = kwl.find(prefix, "zero_dop_range_time_f_pixel"); double rng_gate = atof(rng_gate_str); if (_refPoint == NULL) { _refPoint = new RefPoint(); } _refPoint->set_pix_col(sc_pix); _refPoint->set_pix_line(sc_lin); char year_str[5]; for (int i = 0; i < 4; i++) { year_str[i] = inp_sctim_str[i]; } year_str[4] = '\0'; char month_str[3]; for (int i = 4; i < 6; i++) { month_str[i-4] = inp_sctim_str[i]; } month_str[2] = '\0'; char day_str[3]; for (int i = 6; i < 8; i++) { day_str[i-6] = inp_sctim_str[i]; } day_str[2] = '\0'; char hour_str[3]; for (int i = 8; i < 10; i++) { hour_str[i-8] = inp_sctim_str[i]; } hour_str[2] = '\0'; char min_str[3]; for (int i = 10; i < 12; i++) { min_str[i-10] = inp_sctim_str[i]; } min_str[2] = '\0'; char sec_str[3]; for (int i = 12; i < 14; i++) { sec_str[i-12] = inp_sctim_str[i]; } sec_str[2] = '\0'; char mili_str[4]; for (int i = 14; i < 17; i++) { mili_str[i-14] = inp_sctim_str[i]; } mili_str[3] = '\0'; int year = atoi(year_str); int month = atoi(month_str); int day = atoi(day_str); int hour = atoi(hour_str); int min = atoi(min_str); int sec = atoi(sec_str); double mili = atof(mili_str); CivilDateTime date(year, month, day, hour * 3600 + min * 60 + sec, mili / 1000.0); if (_platformPosition != NULL) { Ephemeris * ephemeris = _platformPosition->Interpolate((JSDDateTime)date); if (ephemeris == NULL) return false ; _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else { return false; } double c = 2.99792458e+8; double distance = (rng_gate * 1e-3 + ((double)sc_pix) * _sensor->get_nRangeLook() / _sensor->get_sf()) * (c / 2.0); _refPoint->set_distance(distance); // in order to use ossimSensorModel::lineSampleToWorld const char* nbCol_str = kwl.find(prefix, "num_pix"); const char* nbLin_str = kwl.find(prefix, "num_lines"); theImageSize.x = atoi(nbCol_str); theImageSize.y = atoi(nbLin_str); theImageClipRect = ossimDrect(0, 0, theImageSize.x - 1, theImageSize.y - 1); // Ground Control Points extracted from the model : corner points std::list groundGcpCoordinates ; std::list imageGcpCoordinates ; // first line first pix const char* lon_str = kwl.find("first_line_first_pixel_lon"); double lon = atof(lon_str); const char* lat_str = kwl.find("first_line_first_pixel_lat"); double lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP1(0, 0); ossimGpt groundGCP1(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP1) ; imageGcpCoordinates.push_back(imageGCP1) ; // first line last pix lon_str = kwl.find("first_line_last_pixel_lon"); lon = atof(lon_str); lat_str = kwl.find("first_line_last_pixel_lat"); lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP2(theImageSize.x - 1, 0); ossimGpt groundGCP2(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP2) ; imageGcpCoordinates.push_back(imageGCP2) ; // last line last pix lon_str = kwl.find("last_line_last_pixel_lon"); lon = atof(lon_str); lat_str = kwl.find("last_line_last_pixel_lat"); lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP3(theImageSize.x - 1, theImageSize.y - 1); ossimGpt groundGCP3(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP3) ; imageGcpCoordinates.push_back(imageGCP3) ; // last line first pix lon_str = kwl.find("last_line_first_pixel_lon"); lon = atof(lon_str); lat_str = kwl.find("last_line_first_pixel_lat"); lat = atof(lat_str); if (lon > 180.0) lon -= 360.0; ossimDpt imageGCP4(0, theImageSize.y - 1); ossimGpt groundGCP4(lat, lon, 0.0); groundGcpCoordinates.push_back(groundGCP4) ; imageGcpCoordinates.push_back(imageGCP4) ; // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates) ; return true; } bool ossimErsSarModel::InitSRGR(const ossimKeywordlist &kwl, const char* /* prefix */) { // Product type = PRI ossimString filename(kwl.find("filename")); filename.upcase(); //std::transform(filename.begin(), filename.end(), filename.begin(), toupper); string::size_type loc = filename.find("PRI"); if (loc != string::npos) { _isProductGeoreferenced = true; } else { _isProductGeoreferenced = false; } // Number of SRGR Coef theNumberSRGR = 3; // Range time for first mid and last pixel double t1 = atof(kwl.find("zero_dop_range_time_f_pixel")) * 1e-3; double t2 = atof(kwl.find("zero_dop_range_time_c_pixel")) * 1e-3; double t3 = atof(kwl.find("zero_dop_range_time_l_pixel")) * 1e-3; // Range pixels numbers corresponding // Todo : check if it works with "DECREASING LINE TIME" // double x1 = 0.0; double x2 = atof(kwl.find("sc_pix")) - 1.0; double x3 = 2.0 * (x2 + 1.0) - 1.0 ; theSRGRCoeffset[0][0] = t1; theSRGRCoeffset[0][1] = ((t2 - t1) / (x2 * x2) + (t1 - t3) / (x3 * x3)) / ((1.0 / x2) - (1.0 / x3)); theSRGRCoeffset[0][2] = ((t2 - t1) / x2 + (t1 - t3) / x3) / (x2 - x3); return true; } bool ossimErsSarModel::isErsLeader(const ossimFilename& file) const { std::ifstream candidate(file.c_str(), ios::in | ios::binary); char ersFileName[16]; candidate.seekg(48); if (candidate.bad() || candidate.eof()) { return false; } candidate.read(ersFileName, 16); if (candidate.bad() || candidate.eof()) { return false; } candidate.close(); ossimString ersString(ersFileName); if ((ersString.find("ERS") == 0) && (ersString.find(".SAR.") == 4) && (ersString.find("LEAD") == 12)) { return true; } else { return false; } } ossimFilename ossimErsSarModel::findErsLeader(const ossimFilename& file) const { ossimFilename leaFile = file; ossimString datString("DAT_01"); ossimString nulString("NUL_DAT"); ossimString vdfString("VDF_DAT"); ossimString leaString("LEA_01"); if ((file.fileNoExtension() == datString) || (file.fileNoExtension() == nulString) || (file.fileNoExtension() == leaString)) { leaFile.setFile(leaString); if (leaFile.exists()) { return leaFile; } } return file; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimErsSarModel.h000066400000000000000000000064711301006202600271110ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimErsSarModel_H #define ossimErsSarModel_H 1 #include #include #include #include #include #include #include #include namespace ossimplugins { class PlatformPosition; class SensorParams; class RefPoint; class ErsSarLeader; /** * @brief This class is able to direct localisation and indirect localisation using the ErsSar sensor model * */ class OSSIM_PLUGINS_DLL ossimErsSarModel : public ossimGeometricSarSensorModel { public: /** * @brief Constructor */ ossimErsSarModel(); /** * @brief Destructor */ virtual ~ossimErsSarModel(); /** * @brief Method to return the class name. * @return The name of this class. */ virtual ossimString getClassName() const; /** * @brief Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /** * @brief This function associates an image column number to a slant range when the image is georeferenced (ground projected) * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const; /** * @brief Method to instantiate model from the leader file. * @param file * @return true on success, false on error. */ bool open(const ossimFilename& file); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState(const ossimKeywordlist &kwl, const char *prefix = 0); protected: virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Initializes the Slant Range for each Ground Range data sets : theNumberSRGR,theSRGRCoeffset,_srgr_update,thePixelSpacing,_isProductGeoreferenced */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix); private: /** * @brief Slant Range for each Ground Range (SRGR) number of coefficients sets */ int theNumberSRGR; /** * @brief SRGR coefficient sets */ double theSRGRCoeffset[1][3]; /** * @brief Pixel spacing */ double thePixelSpacing; /** * @brief List of metadata contained in the Leader file */ ErsSarLeader *theErsSarleader; virtual bool isErsLeader(const ossimFilename& file) const; virtual ossimFilename findErsLeader(const ossimFilename& file) const; TYPE_DATA }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimFormosatDimapSupportData.cpp000066400000000000000000002200661301006202600322160ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Define Trace flags for use within this file: static ossimTrace traceDebug ("ossimFormosatDimapSupportData:debug"); static const ossim_uint32 LAGRANGE_FILTER_SIZE = 8; // num samples considered ossimFormosatDimapSupportData::ossimFormosatDimapSupportData () : ossimErrorStatusInterface(), theMetadataVersion(OSSIM_FORMOSAT_METADATA_VERSION_UNKNOWN), theImageID(), theMetadataFile(), theProductionDate(), theSoftwareVersion(), theInstrument(), theInstrumentIndex(0), theSunAzimuth(0.0), theSunElevation(0.0), theSatAzimuth(0.0), theIncidenceAngle(0.0), theViewingAngle(0.0), theViewingAngleAlongTrack(0.0), theViewingAngleAcrossTrack(0.0), theSceneOrientation(0.0), theImageSize(0.0, 0.0), theRefGroundPoint(0.0, 0.0, 0.0), theRefImagePoint(0.0, 0.0), theSubImageOffset(0.0, 0.0), theRefLineTime(0.0), theRefLineTimeLine(0.0), theLineSamplingPeriod(0.0), thePolynomialLookAngleX(), thePolynomialLookAngleY(), theAttitudeSamples(), theAttSampTimes(), thePosEcfSamples(), theVelEcfSamples(), theEphSampTimes(), theStarTrackerUsed(false), theNumBands(0), theAcquisitionDate(), theFrameVertexPosImagePoints(), theFrameVertexPosGroundPoints(), theGeoPosImagePoints(), theGeoPosGroundPoints() { } ossimFormosatDimapSupportData::ossimFormosatDimapSupportData(const ossimFormosatDimapSupportData& rhs) :ossimErrorStatusInterface(rhs), theMetadataVersion(rhs.theMetadataVersion), theImageID(rhs.theImageID), theMetadataFile (rhs.theMetadataFile), theProductionDate(rhs.theProductionDate), theSoftwareVersion(rhs.theSoftwareVersion), theInstrument(rhs.theInstrument), theInstrumentIndex(rhs.theInstrumentIndex), theSunAzimuth(rhs.theSunAzimuth), theSunElevation(rhs.theSunElevation), theSatAzimuth(rhs.theSatAzimuth), theIncidenceAngle(rhs.theIncidenceAngle), theViewingAngle(rhs.theViewingAngle), theViewingAngleAlongTrack(rhs.theViewingAngle), theViewingAngleAcrossTrack(rhs.theViewingAngle), theSceneOrientation(rhs.theSceneOrientation), theImageSize(rhs.theImageSize), theRefGroundPoint(rhs.theRefGroundPoint), theRefImagePoint(rhs.theRefImagePoint), theSubImageOffset(rhs.theSubImageOffset), theRefLineTime(rhs.theRefLineTime), theRefLineTimeLine(rhs.theRefLineTimeLine), theLineSamplingPeriod(rhs.theLineSamplingPeriod), thePolynomialLookAngleX(rhs.thePolynomialLookAngleX), thePolynomialLookAngleY(rhs.thePolynomialLookAngleY), theAttitudeSamples(rhs.theAttitudeSamples), theAttSampTimes(rhs.theAttSampTimes), thePosEcfSamples(rhs.thePosEcfSamples), theVelEcfSamples(rhs.theVelEcfSamples), theEphSampTimes(rhs.theEphSampTimes), theStarTrackerUsed(rhs.theStarTrackerUsed), theNumBands(rhs.theNumBands), theAcquisitionDate(rhs.theAcquisitionDate), theFrameVertexPosImagePoints(rhs.theFrameVertexPosImagePoints), theFrameVertexPosGroundPoints(rhs.theFrameVertexPosGroundPoints), theGeoPosImagePoints(rhs.theGeoPosImagePoints), theGeoPosGroundPoints(rhs.theGeoPosGroundPoints) { } ossimFormosatDimapSupportData::ossimFormosatDimapSupportData (const ossimFilename& dimapFile) : ossimErrorStatusInterface(), theMetadataVersion(OSSIM_FORMOSAT_METADATA_VERSION_UNKNOWN), theImageID(), theMetadataFile (dimapFile), theProductionDate(), theSoftwareVersion(), theInstrument(), theInstrumentIndex(0), theSunAzimuth(0.0), theSunElevation(0.0), theSatAzimuth(0.0), theIncidenceAngle(0.0), theViewingAngle(0.0), theViewingAngleAlongTrack(0.0), theViewingAngleAcrossTrack(0.0), theSceneOrientation(0.0), theImageSize(0.0, 0.0), theRefGroundPoint(0.0, 0.0, 0.0), theRefImagePoint(0.0, 0.0), theSubImageOffset(0.0, 0.0), theRefLineTime(0.0), theRefLineTimeLine(0.0), theLineSamplingPeriod(0.0), thePolynomialLookAngleX(), thePolynomialLookAngleY(), theAttitudeSamples(), theAttSampTimes(), thePosEcfSamples(), theVelEcfSamples(), theEphSampTimes(), theStarTrackerUsed(false), theNumBands(0), theAcquisitionDate(), theFrameVertexPosImagePoints(), theFrameVertexPosGroundPoints(), theGeoPosImagePoints(), theGeoPosGroundPoints() { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimFormosatDimapSupportData::ossimFormosatDimapSupportData: entering..." << std::endl; } loadXmlFile(dimapFile); // Finished successful parse: if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimFormosatDimapSupportData::ossimFormosatDimapSupportData: leaving..." << std::endl; } } ossimFormosatDimapSupportData::~ossimFormosatDimapSupportData () { } ossimObject* ossimFormosatDimapSupportData::dup()const { return new ossimFormosatDimapSupportData(*this); } void ossimFormosatDimapSupportData::clearFields() { clearErrorStatus(); theSensorID=""; theMetadataVersion = OSSIM_FORMOSAT_METADATA_VERSION_UNKNOWN; theImageID = ""; theMetadataFile = ""; theProductionDate = ""; theSoftwareVersion = ""; theInstrument = ""; theInstrumentIndex = 0; theSunAzimuth = 0.0; theSunElevation = 0.0; theSatAzimuth = 0.0; theIncidenceAngle = 0.0; theViewingAngle = 0.0; theViewingAngleAlongTrack = 0.0; theViewingAngleAcrossTrack = 0.0; theSceneOrientation = 0.0; theImageSize.makeNan(); theRefGroundPoint.makeNan(); theRefImagePoint.makeNan(); theSubImageOffset.makeNan(); theRefLineTime = ossim::nan(); theRefLineTimeLine = ossim::nan(); theLineSamplingPeriod = ossim::nan(); thePolynomialLookAngleX.clear(); thePolynomialLookAngleY.clear(); theAttitudeSamples.clear(); // x=pitch, y=roll, z=yaw theAttSampTimes.clear(); thePosEcfSamples.clear(); theVelEcfSamples.clear(); theEphSampTimes.clear(); theStarTrackerUsed = false; theNumBands = 0; theAcquisitionDate = ""; //--- // Corner points: //--- theFrameVertexPosImagePoints.clear(); theFrameVertexPosGroundPoints.clear(); //--- // Geoposition Points: //--- theGeoPosImagePoints.clear(); theGeoPosGroundPoints.clear(); } bool ossimFormosatDimapSupportData::loadXmlFile(const ossimFilename& file) { static const char MODULE[] = "ossimFormosatDimapSupportData::loadXmlFile"; if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:Entering ..." << "\nFile: " << file << std::endl; } clearFields(); theMetadataFile = file; ossim_int64 fileSize = file.fileSize(); std::ifstream in(file.c_str(), std::ios::binary|std::ios::in); std::vector fullBuffer; ossimString bufferedIo; if(in.good()&&(fileSize > 0)) { char buf[100]; fullBuffer.resize(fileSize); in.read(buf, ossim::min((ossim_int64)100, fileSize)); if(!in.fail()) { ossimString testString = ossimString(buf, buf + in.gcount()); if(testString.contains("xml")) { in.seekg(0); in.read(&fullBuffer.front(), (std::streamsize)fullBuffer.size()); if(!in.fail()) { bufferedIo = ossimString(fullBuffer.begin(), fullBuffer.begin()+in.gcount()); } } } } else { return false; } //--- // Instantiate the XML parser: //--- ossimRefPtr xmlDocument; if(bufferedIo.empty()) { xmlDocument = new ossimXmlDocument(file); } else { xmlDocument = new ossimXmlDocument; std::istringstream inStringStream(bufferedIo); if(!xmlDocument->read(inStringStream)) { return false; } } if (xmlDocument->getErrorStatus()) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nUnable to parse xml file" << std::endl; } setErrorStatus(); return false; } //--- // Check that it is a FORMOSAT DIMAP file format //--- vector > xml_nodes; xml_nodes.clear(); ossimString xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/MISSION"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n Not a FORMOSAT DIMAP file format."<< std::endl; } return false; } if ( xml_nodes[0]->getText() != "FORMOSAT" && xml_nodes[0]->getText() != "Formosat" && xml_nodes[0]->getText() != "formosat" ) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n Not a FORMOSAT DIMAP file format."<< std::endl; } return false; } //--- // Get the version string. This must be performed first as it is used // as a key for parsing different versions. //--- if (initMetadataVersion(xmlDocument) == false) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nMetadata initialization failed. Returning false" << std::endl; } return false; } // Get the image id. if (initImageId(xmlDocument) == false) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nImageId initialization failed. Returning false" << std::endl; } return false; } // Get data from "Scene_Source" section. if (initSceneSource(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nScene source initialization failed. Returning false" << std::endl; return false; } if (initFramePoints(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nFrame point initialization failed. Returning false" << std::endl; return false; } if (parsePart1(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nPart 1 initialization failed. Returning false" << std::endl; return false; } if (parsePart2(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nPart 2 initialization failed. Returning false" << std::endl; return false; } if (parsePart3(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nPart 3 initialization failed. Returning false" << std::endl; return false; } if (parsePart4(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimFormosatDimapSupportData::loadXmlFile:" << "\nPart 4 initialization failed. Returning false" << std::endl; return false; } if (traceDebug()) { printInfo(ossimNotify(ossimNotifyLevel_DEBUG)); ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: leaving..." << std::endl; } return true; } void ossimFormosatDimapSupportData::getPositionEcf(ossim_uint32 sample, ossimEcefPoint& pe) const { pe.makeNan(); pe = ossimEcefPoint(thePosEcfSamples[sample].x, thePosEcfSamples[sample].y, thePosEcfSamples[sample].z); } void ossimFormosatDimapSupportData::getPositionEcf(const ossim_float64& time, ossimEcefPoint& pe) const { ossimDpt3d tempPt; if((thePosEcfSamples.size() < 8)|| (theEphSampTimes.size() < 8)) { getBilinearInterpolation(time, thePosEcfSamples, theEphSampTimes, tempPt); } else { getLagrangeInterpolation(time, thePosEcfSamples, theEphSampTimes, tempPt); } pe = ossimEcefPoint(tempPt.x, tempPt.y, tempPt.z); } void ossimFormosatDimapSupportData::getVelocityEcf(ossim_uint32 sample, ossimEcefPoint& ve) const { ve.makeNan(); ve = ossimEcefPoint(theVelEcfSamples[sample].x, theVelEcfSamples[sample].y, theVelEcfSamples[sample].z); } void ossimFormosatDimapSupportData::getVelocityEcf(const ossim_float64& time, ossimEcefPoint& ve) const { ossimDpt3d tempPt; if((theVelEcfSamples.size() < 8) || (theEphSampTimes.size() < 8)) { getBilinearInterpolation (time, theVelEcfSamples, theEphSampTimes, tempPt); } else { getLagrangeInterpolation (time, theVelEcfSamples, theEphSampTimes, tempPt); } ve = ossimEcefPoint(tempPt.x, tempPt.y, tempPt.z); } void ossimFormosatDimapSupportData::getEphSampTime(ossim_uint32 sample, ossim_float64& et) const { et = ossim::nan(); if(theEphSampTimes.size() < theImageSize.samp) { if(theImageSize.samp > 0) { double t = 0.0; double tempIdx = 0.0; double tempIdxFraction = 0.0; t = (double)sample/(double)(theImageSize.samp-1); tempIdx = (theEphSampTimes.size()-1)*t; tempIdxFraction = tempIdx - (ossim_int32)tempIdx; ossim_uint32 idxStart = (ossim_uint32)tempIdx; ossim_uint32 idxEnd = (ossim_uint32)ceil(tempIdx); if(idxEnd >= theEphSampTimes.size()) { idxEnd = (ossim_uint32)theEphSampTimes.size()-1; } if(idxStart > idxEnd) { idxStart = idxEnd; } et = (theEphSampTimes[idxStart] +tempIdxFraction*(theEphSampTimes[idxEnd] - theEphSampTimes[idxStart])); } } else if(theEphSampTimes.size() == theImageSize.samp) { et = theEphSampTimes[sample]; } } void ossimFormosatDimapSupportData::getAttitude(ossim_uint32 sample, ossimDpt3d& at) const { if (sample >= theAttitudeSamples.size()) { at.makeNan(); return; } at = theAttitudeSamples[sample]; } void ossimFormosatDimapSupportData::getAttitude(const ossim_float64& time, ossimDpt3d& at) const { if (theAttSampTimes.empty()) { at.makeNan(); return; } if ((time < theAttSampTimes.front()) || (time >= theAttSampTimes.back() )) { at.makeNan(); return; } //*** // Search the attitude sampling time array for surrounding samples: //*** int i=0; while ((i < (int)theAttSampTimes.size()) && (theAttSampTimes[i] < time)) ++i; --i; //*** // Linearly interpolate attitudes angles: //*** ossim_float64 dt1 = time - theAttSampTimes[i]; ossim_float64 dt0 = theAttSampTimes[i+1] - time; ossim_float64 dt = theAttSampTimes[i+1] - theAttSampTimes[i]; at = (theAttitudeSamples[i+1]*dt1 + theAttitudeSamples[i]*dt0)/dt; } void ossimFormosatDimapSupportData::getAttSampTime(ossim_uint32 sample, ossim_float64& at) const { if (sample >= theAttSampTimes.size()) { at = ossim::nan(); return; } at = theAttSampTimes[sample]; } void ossimFormosatDimapSupportData::getPixelLookAngleX(ossim_uint32 sample, ossim_float64& pa) const { getInterpolatedLookAngle(sample, thePolynomialLookAngleX, pa); } void ossimFormosatDimapSupportData::getPixelLookAngleX(const ossim_float64& sample, ossim_float64& pa) const { ossim_uint32 s = static_cast(sample); getInterpolatedLookAngle(s, thePolynomialLookAngleX, pa); } void ossimFormosatDimapSupportData::getPixelLookAngleY(ossim_uint32 sample, ossim_float64& pa) const { getInterpolatedLookAngle(sample, thePolynomialLookAngleY, pa); } void ossimFormosatDimapSupportData::getPixelLookAngleY(const ossim_float64& sample, ossim_float64& pa) const { ossim_uint32 s = static_cast(sample); getInterpolatedLookAngle(s, thePolynomialLookAngleY, pa); } void ossimFormosatDimapSupportData::getInterpolatedLookAngle( const ossim_float64& p, const std::vector& angles, ossim_float64& la) const { la = ossim::nan(); if (angles.size() != 4 ) { setErrorStatus(); return; } la = angles[0] + angles[1] * p + angles[2] * p * p + angles[3] * p * p * p ; } void ossimFormosatDimapSupportData::getBilinearInterpolation( const ossim_float64& time, const std::vector& V, const std::vector& T, ossimDpt3d& li) const { ossim_uint32 samp0 = 0; while ((samp0 < T.size()) && (T[samp0] < time)) ++samp0; if(samp0==0) { li = V[0]; } else if(samp0 == T.size()) { li = V[1]; } else { double t = (T[samp0-1]-time)/(T[samp0-1] - T[samp0]); li = V[samp0-1] + (V[samp0]-V[samp0-1])*t; } } void ossimFormosatDimapSupportData::getLagrangeInterpolation( const ossim_float64& time, const std::vector& V, const std::vector& T, ossimDpt3d& li) const { // std::cout << "V size = " << V.size() << std::endl // << "T size = " << T.size() << std::endl; ossim_uint32 filter_size = 8; // // Verify that t is within allowable range: // ossim_uint32 lagrange_half_filter = 4; if(T.size() <= filter_size) { filter_size = (ossim_uint32)T.size()/2; lagrange_half_filter = filter_size/2; } if ((time < T[lagrange_half_filter]) || (time >= T[T.size()-lagrange_half_filter] )) { setErrorStatus(); li.makeNan(); return; } //*** // Search the sampling time array for surrounding samples: //*** ossim_uint32 samp0 = lagrange_half_filter; while ((samp0 < T.size()) && (T[samp0] < time)) ++samp0; //*** // Do not use sample if it falls in neighborhood of desired time: //*** ossim_uint32 bump = 0; if (fabs(T[samp0] - time) < theLineSamplingPeriod/2.0) bump = 1; samp0 -= lagrange_half_filter; // adjust to first sample in window //*** // Outer summation loop: //*** ossimDpt3d S (0, 0, 0); for (ossim_uint32 j=samp0; j<(samp0+filter_size+bump); ++j) { ossim_float64 numerator = 1.0; ossim_float64 denominator = 1.0; //*** // Skip this sample if too close to desired time: //*** if (bump && (j == (samp0+lagrange_half_filter) )) ++j; //*** // Inner loop for product series: //*** for (ossim_uint32 i=samp0; i<(samp0+filter_size+bump); ++i) { //*** // Skip this sample if too close to desired time: //*** if (bump && (i == (samp0+lagrange_half_filter) )) ++i; if (i != j) { numerator *= time - T[i]; denominator *= T[j] - T[i]; } } ossimDpt3d p = V[j]; p = p * numerator; p = p / denominator; S += p; } li = S; } ossim_float64 ossimFormosatDimapSupportData::convertTimeStamp(const ossimString& time_stamp) const { double ti; convertTimeStamp(time_stamp, ti); return ti; } void ossimFormosatDimapSupportData::convertTimeStamp(const ossimString& time_stamp, ossim_float64& ti) const { int year, month, day, hour, minute; double second; //*** // Time stamps are in the format: "yyyy-mm-ddThh:mm:ss.ssssss" //*** int converted = sscanf(time_stamp, "%4d-%2d-%2d %2d:%2d:%9lf", &year, &month, &day, &hour, &minute, &second); if (converted != 6) { setErrorStatus(); ti = ossim::nan(); } else { ti = (((((year-2002.0)*12.0 + month - 1.0)*365.0 + day - 1.0)*24.0 + hour)*60.0 + minute)*60.0 + second; } } void ossimFormosatDimapSupportData::getGeoPosPoint (ossim_uint32 point, ossimDpt& ip, ossimGpt& gp) const { if (point < theGeoPosImagePoints.size()) { ip = theGeoPosImagePoints [point]; gp = theGeoPosGroundPoints[point]; } } void ossimFormosatDimapSupportData::printInfo(ostream& os) const { ossimString corr_att = "NO"; if (theStarTrackerUsed) corr_att = "YES"; os << "\n----------------- Info on Formosat Image -------------------" << "\n " << "\n Job Number (ID): " << theImageID << "\n Acquisition Date: " << theAcquisitionDate << "\n Instrument: " << theInstrument << "\n Instrument Index: " << theInstrumentIndex << "\n Production Date: " << theProductionDate << "\n Production Softwrae version: " << theSoftwareVersion << "\n Number of Bands: " << theNumBands << "\n Geo Center Point: " << theRefGroundPoint << "\n Image Size: " << theImageSize << "\n Incidence Angle: " << theIncidenceAngle << "\n Viewing Angle: " << theViewingAngle << "\n Viewing Angle Along Track: " << theViewingAngleAlongTrack << "\n Viewing Angle Across Track: " << theViewingAngleAcrossTrack << "\n Scene Orientation: " << theSceneOrientation << "\n Corrected Attitude: " << corr_att << "\n Sun Azimuth: " << theSunAzimuth << "\n Sun Elevation: " << theSunElevation << "\n Sat Azimuth: " << theSatAzimuth << "\n Sub image offset: " << theSubImageOffset << "\n PolynomialLookAngleX size: " << thePolynomialLookAngleX.size() << "\n thePosEcfSamples size: " << thePosEcfSamples.size() << "\n theFrameVertexPosImagePoints size : " << theFrameVertexPosImagePoints.size() << "\n" << "\n---------------------------------------------------------" << "\n " << std::endl; } ossimString ossimFormosatDimapSupportData::getSensorID() const { return theSensorID; } ossimString ossimFormosatDimapSupportData::getMetadataVersionString() const { if (theMetadataVersion == OSSIM_FORMOSAT_METADATA_VERSION_1_1) { return ossimString("1.1"); } else if (theMetadataVersion == OSSIM_FORMOSAT_METADATA_VERSION_1_0) { return ossimString("1.0"); } return ossimString("unknown"); } ossimString ossimFormosatDimapSupportData::getAcquisitionDate() const { return theAcquisitionDate; } ossimString ossimFormosatDimapSupportData::getProductionDate() const { return theProductionDate; } ossimString ossimFormosatDimapSupportData::getSoftwareVersion() const { return theSoftwareVersion; } ossimString ossimFormosatDimapSupportData::getImageID() const { return theImageID; } ossimFilename ossimFormosatDimapSupportData::getMetadataFile() const { return theMetadataFile; } ossimString ossimFormosatDimapSupportData::getInstrument() const { return theInstrument; } ossim_uint32 ossimFormosatDimapSupportData::getInstrumentIndex() const { return theInstrumentIndex; } void ossimFormosatDimapSupportData::getSunAzimuth(ossim_float64& az) const { az = theSunAzimuth; } void ossimFormosatDimapSupportData::getSunElevation(ossim_float64& el) const { el = theSunElevation; } void ossimFormosatDimapSupportData::getSatAzimuth(ossim_float64& az) const { az = theSatAzimuth; } void ossimFormosatDimapSupportData::getImageSize(ossimDpt& sz) const { sz = theImageSize; } void ossimFormosatDimapSupportData::getLineSamplingPeriod(ossim_float64& pe) const { pe = theLineSamplingPeriod; } bool ossimFormosatDimapSupportData::isStarTrackerUsed() const { return theStarTrackerUsed; } ossim_uint32 ossimFormosatDimapSupportData::getNumberOfBands() const { return theNumBands; } void ossimFormosatDimapSupportData::getIncidenceAngle(ossim_float64& ia) const { ia = theIncidenceAngle; } void ossimFormosatDimapSupportData::getViewingAngle(ossim_float64& va) const { va = theViewingAngle; } void ossimFormosatDimapSupportData::getViewingAngleAlongTrack(ossim_float64& va) const { va = theViewingAngleAlongTrack; } void ossimFormosatDimapSupportData::getViewingAngleAcrossTrack(ossim_float64& va) const { va = theViewingAngleAcrossTrack; } void ossimFormosatDimapSupportData::getSceneOrientation(ossim_float64& so) const { so = theSceneOrientation; } void ossimFormosatDimapSupportData::getRefGroundPoint(ossimGpt& gp) const { gp = theRefGroundPoint; } void ossimFormosatDimapSupportData::getRefImagePoint(ossimDpt& rp) const { rp = theRefImagePoint; } void ossimFormosatDimapSupportData::getRefLineTime(ossim_float64& rt) const { rt = theRefLineTime; } void ossimFormosatDimapSupportData::getRefLineTimeLine(ossim_float64& rtl) const { rtl = theRefLineTimeLine; } ossim_uint32 ossimFormosatDimapSupportData::getNumEphSamples() const { return (ossim_uint32)theEphSampTimes.size(); } ossim_uint32 ossimFormosatDimapSupportData::getNumAttSamples() const { return (ossim_uint32)theAttSampTimes.size(); } ossim_uint32 ossimFormosatDimapSupportData::getNumGeoPosPoints() const { return (ossim_uint32)theGeoPosImagePoints.size(); } void ossimFormosatDimapSupportData::getImageRect(ossimDrect& rect)const { rect = ossimDrect(0.0, 0.0, theImageSize.x-1.0, theImageSize.y-1.0); } void ossimFormosatDimapSupportData::getSubImageOffset(ossimDpt& offset) const { offset = theSubImageOffset; } bool ossimFormosatDimapSupportData::saveState(ossimKeywordlist& kwl, const char* prefix)const { kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimFormosatDimapSupportData", true); kwl.add(prefix, "metadata_file", theMetadataFile, true); kwl.add(prefix, ossimKeywordNames::AZIMUTH_ANGLE_KW, theSunAzimuth, true); kwl.add(prefix, ossimKeywordNames::ELEVATION_ANGLE_KW, theSunElevation, true); kwl.add(prefix, "sat_azimuth_angle", theSatAzimuth, true); //--- // Note: since this is a new keyword, use the point.toString as there is // no backwards compatibility issues. //--- kwl.add(prefix, "image_size", ossimString::toString(theImageSize.x) + " " + ossimString::toString(theImageSize.y), true); kwl.add(prefix, "reference_ground_point", ossimString::toString(theRefGroundPoint.latd()) + " " + ossimString::toString(theRefGroundPoint.lond()) + " " + ossimString::toString(theRefGroundPoint.height()) + " " + theRefGroundPoint.datum()->code(), true); kwl.add(prefix, "reference_image_point", ossimString::toString(theRefImagePoint.x) + " " + ossimString::toString(theRefImagePoint.y), true); kwl.add(prefix, "sub_image_offset", ossimString::toString(theSubImageOffset.x) + " " + ossimString::toString(theSubImageOffset.y), true); kwl.add(prefix, "reference_line_time", theRefLineTime, true); kwl.add(prefix, "reference_line_time_line", theRefLineTimeLine, true); kwl.add(prefix, "line_sampling_period", theLineSamplingPeriod, true); ossimString tempString; ossim_uint32 idx = 0; tempString = ""; for(idx = 0; idx < thePolynomialLookAngleX.size(); ++idx) { tempString += (ossimString::toString(thePolynomialLookAngleX[idx]) + " "); } kwl.add(prefix, "pixel_lookat_angle_x", tempString, true); kwl.add(prefix, "number_of_pixel_lookat_angle_x", static_cast(thePolynomialLookAngleX.size()), true); tempString = ""; for(idx = 0; idx < thePolynomialLookAngleY.size(); ++idx) { tempString += (ossimString::toString(thePolynomialLookAngleY[idx]) + " "); } kwl.add(prefix, "pixel_lookat_angle_y", tempString, true); kwl.add(prefix, "number_of_pixel_lookat_angle_y", static_cast(thePolynomialLookAngleY.size()), true); tempString = ""; for(idx = 0; idx < theAttitudeSamples.size(); ++idx) { tempString += (ossimString::toString(theAttitudeSamples[idx].x) + " " + ossimString::toString(theAttitudeSamples[idx].y) + " " + ossimString::toString(theAttitudeSamples[idx].z) + " "); } kwl.add(prefix, "attitude_samples", tempString, true); kwl.add(prefix, "number_of_attitude_samples", static_cast(theAttitudeSamples.size()), true); tempString = ""; for(idx = 0; idx < theAttSampTimes.size(); ++idx) { tempString += (ossimString::toString(theAttSampTimes[idx]) + " "); } kwl.add(prefix, "attitude_sample_times", tempString, true); kwl.add(prefix, "number_of_attitude_sample_times", static_cast(theAttSampTimes.size()), true); tempString = ""; for(idx = 0; idx < thePosEcfSamples.size(); ++idx) { tempString += (ossimString::toString(thePosEcfSamples[idx].x) + " " + ossimString::toString(thePosEcfSamples[idx].y) + " " + ossimString::toString(thePosEcfSamples[idx].z) + " "); } kwl.add(prefix, "position_ecf_samples", tempString, true); kwl.add(prefix, "number_of_position_ecf_samples", static_cast(thePosEcfSamples.size()), true); tempString = ""; for(idx = 0; idx < theVelEcfSamples.size(); ++idx) { tempString += (ossimString::toString(theVelEcfSamples[idx].x) + " " + ossimString::toString(theVelEcfSamples[idx].y) + " " + ossimString::toString(theVelEcfSamples[idx].z) + " "); } kwl.add(prefix, "velocity_ecf_samples", tempString, true); kwl.add(prefix, "number_of_velocity_ecf_samples", static_cast(thePosEcfSamples.size()), true); tempString = ""; for(idx = 0; idx < theEphSampTimes.size(); ++idx) { tempString += (ossimString::toString(theEphSampTimes[idx]) + " "); } kwl.add(prefix, "ephemeris_sample_times", tempString, true); kwl.add(prefix, "number_of_ephemeris_sample_times", static_cast(theEphSampTimes.size()), true); kwl.add(prefix, "star_tracker_used_flag", static_cast(theStarTrackerUsed), true); kwl.add(prefix, ossimKeywordNames::NUMBER_BANDS_KW, theNumBands, true); kwl.add(prefix, "image_id", theImageID, true); kwl.add(prefix, "instrument", theInstrument, true); kwl.add(prefix, "instrument_index", theInstrumentIndex, true); kwl.add(prefix, ossimKeywordNames::IMAGE_DATE_KW, theAcquisitionDate, true); kwl.add(prefix, "production_date", theProductionDate, true); kwl.add(prefix, "software_version", theSoftwareVersion, true); kwl.add(prefix, "incident_angle", theIncidenceAngle, true); kwl.add(prefix, "viewing_angle", theViewingAngle, true); kwl.add(prefix, "viewing_angle_along_track", theViewingAngleAlongTrack, true); kwl.add(prefix, "viewing_angle_across_track", theViewingAngleAcrossTrack, true); kwl.add(prefix, "scene_orientation", theSceneOrientation, true); kwl.add(prefix, "sensorID", theSensorID, true); tempString = ""; for(idx = 0; idx < thePhysicalBias.size(); ++idx) { tempString += (ossimString::toString(thePhysicalBias[idx]) + " "); } kwl.add(prefix, "physical_bias", tempString, true); tempString = ""; for(idx = 0; idx < thePhysicalGain.size(); ++idx) { tempString += (ossimString::toString(thePhysicalGain[idx]) + " "); } kwl.add(prefix, "physical_gain", tempString, true); tempString = ""; for(idx = 0; idx < theSolarIrradiance.size(); ++idx) { tempString += (ossimString::toString(theSolarIrradiance[idx]) + " "); } kwl.add(prefix, "solar_irradiance", tempString, true); return true; } bool ossimFormosatDimapSupportData::loadState(const ossimKeywordlist& kwl, const char* prefix) { clearFields(); ossimString type = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if(type != "ossimFormosatDimapSupportData") { return false; } theMetadataFile = kwl.find(prefix, "metadata_file"); theSunAzimuth = ossimString(kwl.find(prefix, ossimKeywordNames::AZIMUTH_ANGLE_KW)).toDouble(); theSunElevation = ossimString(kwl.find(prefix, ossimKeywordNames::ELEVATION_ANGLE_KW)).toDouble(); theSatAzimuth = ossimString(kwl.find(prefix, "sat_azimuth_angle")).toDouble(); theImageSize = createDpt(kwl.find(prefix, "image_size")); theRefGroundPoint = createGround(kwl.find(prefix, "reference_ground_point")); theRefImagePoint = createDpt(kwl.find(prefix, "reference_image_point")); theSubImageOffset = createDpt(kwl.find(prefix, "sub_image_offset")); theRefLineTime = ossimString(kwl.find(prefix, "reference_line_time")).toDouble(); const char* lookup = kwl.find(prefix, "reference_line_time_line"); if (lookup) { theRefLineTimeLine = ossimString(lookup).toDouble(); } theLineSamplingPeriod = ossimString(kwl.find(prefix, "line_sampling_period")).toDouble(); ossim_uint32 idx = 0; ossim_uint32 total = ossimString(kwl.find(prefix,"number_of_pixel_lookat_angle_x")).toUInt32(); ossimString tempString; thePolynomialLookAngleX.resize(total); tempString = kwl.find(prefix,"pixel_lookat_angle_x"); if(tempString != "") { std::istringstream in(tempString); ossimString tempValue; for(idx = 0; idx < thePolynomialLookAngleX.size();++idx) { in >> tempValue; thePolynomialLookAngleX[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_pixel_lookat_angle_y")).toUInt32(); thePolynomialLookAngleY.resize(total); tempString = kwl.find(prefix,"pixel_lookat_angle_y"); if(tempString != "") { std::istringstream in(tempString); ossimString tempValue; for(idx = 0; idx < thePolynomialLookAngleY.size();++idx) { in >> tempValue; thePolynomialLookAngleY[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_attitude_samples")).toUInt32(); theAttitudeSamples.resize(total); tempString = kwl.find(prefix,"attitude_samples"); if(tempString != "") { std::istringstream in(tempString); ossimString x, y, z; for(idx = 0; idx < theAttitudeSamples.size();++idx) { in >> x >> y >> z; theAttitudeSamples[idx] =ossimDpt3d(x.toDouble(), y.toDouble(), z.toDouble()); } } total = ossimString(kwl.find(prefix,"number_of_attitude_sample_times")).toUInt32(); theAttSampTimes.resize(total); tempString = kwl.find(prefix,"attitude_sample_times"); if(tempString != "") { std::istringstream in(tempString); ossimString tempValue; for(idx = 0; idx < theAttSampTimes.size();++idx) { in >> tempValue; theAttSampTimes[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_position_ecf_samples")).toUInt32(); thePosEcfSamples.resize(total); tempString = kwl.find(prefix,"position_ecf_samples"); if(tempString != "") { std::istringstream in(tempString); ossimString x, y, z; for(idx = 0; idx < thePosEcfSamples.size();++idx) { in >> x >> y >> z; thePosEcfSamples[idx] = ossimDpt3d(x.toDouble(), y.toDouble(), z.toDouble()); } } total = ossimString(kwl.find(prefix,"number_of_velocity_ecf_samples")).toUInt32(); theVelEcfSamples.resize(total); tempString = kwl.find(prefix,"velocity_ecf_samples"); if(tempString != "") { std::istringstream in(tempString); ossimString x, y, z; for(idx = 0; idx < theVelEcfSamples.size();++idx) { in >> x >> y >> z; theVelEcfSamples[idx] = ossimDpt3d(x.toDouble(), y.toDouble(), z.toDouble()); } } total = ossimString(kwl.find(prefix,"number_of_ephemeris_sample_times")).toUInt32(); theEphSampTimes.resize(total); tempString = kwl.find(prefix,"ephemeris_sample_times"); if(tempString != "") { std::istringstream in(tempString); ossimString tempValue; for(idx = 0; idx < theEphSampTimes.size();++idx) { in >> tempValue; theEphSampTimes[idx] = tempValue.toDouble(); } } tempString = ""; for(idx = 0; idx < theEphSampTimes.size(); ++idx) { tempString += (ossimString::toString(theEphSampTimes[idx]) + " "); } theStarTrackerUsed = ossimString(kwl.find(prefix, "star_tracker_used_flag")).toBool(); theNumBands = ossimString(kwl.find(prefix, ossimKeywordNames::NUMBER_BANDS_KW)).toUInt32(); theAcquisitionDate = kwl.find(prefix, ossimKeywordNames::IMAGE_DATE_KW); theProductionDate = kwl.find(prefix, "production_date"); theSoftwareVersion = kwl.find(prefix, "software_version"); theImageID = kwl.find(prefix, "image_id"); theInstrument = kwl.find(prefix, "instrument"); theInstrumentIndex = ossimString(kwl.find(prefix, "instrument_index")).toUInt32(); theIncidenceAngle = ossimString(kwl.find(prefix, "incident_angle")).toDouble(); theViewingAngle = ossimString(kwl.find(prefix, "viewing_angle")).toDouble(); theViewingAngleAlongTrack = ossimString(kwl.find(prefix, "viewing_angle_along_track")).toDouble(); theViewingAngleAcrossTrack = ossimString(kwl.find(prefix, "viewing_angle_across_track")).toDouble(); theSceneOrientation = ossimString(kwl.find(prefix, "scene_orientation")).toDouble(); /* TODO add reading FrameVertex point */ theSensorID = ossimString(kwl.find(prefix, "sensorID")); thePhysicalBias.resize(theNumBands); tempString = kwl.find(prefix,"physical_bias"); if(tempString != "") { std::istringstream in(tempString); ossimString tempValue; for(idx = 0; idx < thePhysicalBias.size();++idx) { in >> tempValue; thePhysicalBias[idx] = tempValue.toDouble(); } } thePhysicalGain.resize(theNumBands); tempString = kwl.find(prefix,"physical_gain"); if(tempString != "") { std::istringstream in(tempString); ossimString tempValue; for(idx = 0; idx < thePhysicalGain.size();++idx) { in >> tempValue; thePhysicalGain[idx] = tempValue.toDouble(); } } theSolarIrradiance.resize(theNumBands); tempString = kwl.find(prefix,"solar_irradiance"); if(tempString != "") { std::istringstream in(tempString); ossimString tempValue; for(idx = 0; idx < theSolarIrradiance.size();++idx) { in >> tempValue; theSolarIrradiance[idx] = tempValue.toDouble(); } } return true; } ossimGpt ossimFormosatDimapSupportData::createGround(const ossimString& s)const { std::istringstream in(s); ossimString lat, lon, height; ossimString code; in >> lat >> lon >> height >> code; return ossimGpt(lat.toDouble(), lon.toDouble(), height.toDouble(), ossimDatumFactory::instance()->create(code)); } ossimDpt ossimFormosatDimapSupportData::createDpt(const ossimString& s)const { std::istringstream in(s); ossimString x, y; ossimString code; in >> x >> y; return ossimDpt(x.toDouble(), y.toDouble()); } bool ossimFormosatDimapSupportData::parsePart1( ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimFormosatDimapSupportData::parsePart1"; ossimString xpath; vector > xml_nodes; //--- // Fetch the ImageSize: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Raster_Dimensions/NCOLS"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theImageSize.samp = xml_nodes[0]->getText().toDouble(); xml_nodes.clear(); xpath = "/Dimap_Document/Raster_Dimensions/NROWS"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theImageSize.line = xml_nodes[0]->getText().toDouble(); //--- // We will make the RefImagePoint the zero base center of the image. This // is used by the ossimSensorModel::worldToLineSample iterative loop as // the starting point. Since the ossimSensorModel does not know of the // sub image we make it zero base. //--- theRefImagePoint.line = theImageSize.line / 2.0; theRefImagePoint.samp = theImageSize.samp / 2.0; xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Time_Stamp/REFERENCE_LINE"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } // Relative to full image frame. theRefLineTimeLine = xml_nodes[0]->getText().toDouble() - 1.0; // See if there's a sub image offset... xml_nodes.clear(); xpath = "/Dimap_Document/Data_Processing/Regions_Of_Interest/Region_Of_Interest/COL_MIN"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { theSubImageOffset.samp = 0.0; } else { theSubImageOffset.samp = xml_nodes[0]->getText().toDouble() - 1.0; } xml_nodes.clear(); xpath = "/Dimap_Document/Data_Processing/Regions_Of_Interest/Region_Of_Interest/ROW_MIN"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { theSubImageOffset.line = 0.0; } else { theSubImageOffset.line = xml_nodes[0]->getText().toDouble() - 1.0; } //--- // Fetch the RefLineTime: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Time_Stamp/REFERENCE_TIME"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theAcquisitionDate = xml_nodes[0]->getText(); convertTimeStamp(theAcquisitionDate, theRefLineTime); //--- // Fetch the ProductionDate: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Production/DATASET_PRODUCTION_DATE"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theProductionDate = xml_nodes[0]->getText(); //--- // Fetch the SoftwareVersion: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Production/Production_Facility/SOFTWARE_VERSION"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theSoftwareVersion = xml_nodes[0]->getText(); //--- // Fetch the Instrument: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/INSTRUMENT"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theInstrument = xml_nodes[0]->getText(); //--- // Fetch the Instrument Index: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/INSTRUMENT_INDEX"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theInstrumentIndex = xml_nodes[0]->getText().toUInt32(); return true; } bool ossimFormosatDimapSupportData::parsePart2( ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimFormosatDimapSupportData::parsePart2"; ossimString xpath; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; ossim_int32 band_index; //--- // Fetch the LineSamplingPeriod: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Time_Stamp/LINE_PERIOD"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theLineSamplingPeriod = xml_nodes[0]->getText().toDouble(); //--- // Fetch number of bands //--- xml_nodes.clear(); xpath = "/Dimap_Document/Raster_Dimensions/NBANDS"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theNumBands = atoi(xml_nodes[0]->getText()); if (theNumBands == 1) { band_index = 0; } else if (theNumBands == 4) { band_index = 1; // using green band for Polynomial Look angles } else { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nBand ERROR!" << std::endl; } return false; } //--- // Fetch the PolynomialLookAngleX and PolynomialLookAngleY arrays. //--- thePolynomialLookAngleX.clear(); thePolynomialLookAngleY.clear(); xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Sensor_Configuration/" "Instrument_Look_Angles_List/Instrument_Look_Angles/"; xmlDocument->findNodes(xpath, xml_nodes); // if (xml_nodes.size() != theNumBands) // { if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "BAND_INDEX"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ossim_int32 bandIndex = sub_nodes[0]->getText().toInt32() - 1; if( (bandIndex >= static_cast(theNumBands) ) || (bandIndex<0) ) { ossimNotify(ossimNotifyLevel_WARN) << "ossimFormosatDimapSupportData: ERROR: Band index outside of range\n"; return false; } if(bandIndex == band_index) { sub_nodes.clear(); xpath = "Polynomial_Look_Angles/XLOS_0"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleX.push_back(sub_nodes[0]->getText().toDouble()); sub_nodes.clear(); xpath = "Polynomial_Look_Angles/XLOS_1"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleX.push_back(sub_nodes[0]->getText().toDouble()); sub_nodes.clear(); xpath = "Polynomial_Look_Angles/XLOS_2"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleX.push_back(sub_nodes[0]->getText().toDouble()); sub_nodes.clear(); xpath = "Polynomial_Look_Angles/XLOS_3"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleX.push_back(sub_nodes[0]->getText().toDouble()); sub_nodes.clear(); xpath = "Polynomial_Look_Angles/YLOS_0"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleY.push_back(sub_nodes[0]->getText().toDouble()); sub_nodes.clear(); xpath = "Polynomial_Look_Angles/YLOS_1"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleY.push_back(sub_nodes[0]->getText().toDouble()); sub_nodes.clear(); xpath = "Polynomial_Look_Angles/YLOS_2"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleY.push_back(sub_nodes[0]->getText().toDouble()); sub_nodes.clear(); xpath = "Polynomial_Look_Angles/YLOS_3"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePolynomialLookAngleY.push_back(sub_nodes[0]->getText().toDouble()); } ++node; } //--- // Fetch the Attitude Samples: //--- theAttitudeSamples.clear(); theAttSampTimes.clear(); xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Attitudes/Corrected_Attitudes/ECF_Attitude/Angle_List/Angle"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { ossimDpt3d V; sub_nodes.clear(); xpath = "PITCH"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } V.x = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "ROLL"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } V.y = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "YAW"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } V.z = sub_nodes[0]->getText().toDouble(); theAttitudeSamples.push_back(V); sub_nodes.clear(); xpath = "TIME"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } theAttSampTimes.push_back(convertTimeStamp(sub_nodes[0]->getText())); ++node; } return true; } bool ossimFormosatDimapSupportData::parsePart3( ossimRefPtr xmlDocument) { ossimString xpath; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; static const char MODULE[] = "ossimFormosatDimapSupportData::parsePart3"; //--- // Fetch the ephemeris samples: //--- thePosEcfSamples.clear(); theVelEcfSamples.clear(); theEphSampTimes.clear(); xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Ephemeris/Raw_Ephemeris/Point_List/Point"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { ossimDpt3d VP; sub_nodes.clear(); xpath = "Location/X"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } VP.x = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "Location/Y"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } VP.y = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "Location/Z"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } VP.z = sub_nodes[0]->getText().toDouble(); thePosEcfSamples.push_back(VP); ossimDpt3d VV; sub_nodes.clear(); xpath = "Velocity/X"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } VV.x = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "Velocity/Y"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } VV.y = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "Velocity/Z"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } VV.z = sub_nodes[0]->getText().toDouble(); theVelEcfSamples.push_back(VV); sub_nodes.clear(); xpath = "TIME"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } theEphSampTimes.push_back(convertTimeStamp(sub_nodes[0]->getText())); ++node; } //--- // Fetch the star tracker flag: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Satellite_Attitudes/Corrected_Attitudes/" "STAR_TRACKER_USED"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { theStarTrackerUsed = false; // setErrorStatus(); // return false; } else { if (xml_nodes[0]->getText() == "Y") theStarTrackerUsed = true; else theStarTrackerUsed = false; } //--- // Geoposition points: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Geoposition/Geoposition_Points/Tie_Point"; xmlDocument->findNodes(xpath, xml_nodes); node = xml_nodes.begin(); while (node != xml_nodes.end()) { ossimGpt gpt; ossimDpt ipt; sub_nodes.clear(); xpath = "TIE_POINT_DATA_Y"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.line = sub_nodes[0]->getText().toDouble() - 1.0; sub_nodes.clear(); xpath = "TIE_POINT_DATA_X"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.samp = sub_nodes[0]->getText().toDouble() - 1.0; sub_nodes.clear(); xpath = "TIE_POINT_CRS_Y"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lat = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "TIE_POINT_CRS_X"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lon = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "TIE_POINT_CRS_Z"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() != 0) { gpt.hgt = sub_nodes[0]->getText().toDouble(); } theGeoPosImagePoints.push_back(ipt); theGeoPosGroundPoints.push_back(gpt); ++node; } return true; } bool ossimFormosatDimapSupportData::parsePart4( ossimRefPtr xmlDocument) { ossimString xpath; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; static const char MODULE[] = "ossimFormosatDimapSupportData::parsePart4"; //--- // Fetch the gain and bias for each spectral band: //--- thePhysicalGain.assign(theNumBands, 1.000); thePhysicalBias.assign(theNumBands, 0.000); xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Sensor_Calibration/Calibration/Band_Parameters/"; xmlDocument->findNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "BAND_INDEX"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ossim_int32 bandIndex = sub_nodes[0]->getText().toInt32() - 1; if( (bandIndex >= static_cast(theNumBands) ) || (bandIndex<0) ) { ossimNotify(ossimNotifyLevel_WARN) << "ossimFormosatDimapSupportData: ERROR: Band index outside of range\n"; return false; } sub_nodes.clear(); xpath = "Gain_Section_List/Gain_Section/PHYSICAL_BIAS"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePhysicalBias[bandIndex] = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "Gain_Section_List/Gain_Section/PHYSICAL_GAIN"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePhysicalGain[bandIndex] = sub_nodes[0]->getText().toDouble(); ++node; } theSolarIrradiance.assign(theNumBands, 0.000); xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Sensor_Calibration/Solar_Irradiance/Band_Solar_Irradiance"; xmlDocument->findNodes(xpath, xml_nodes); node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "BAND_INDEX"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ossim_int32 bandIndex = sub_nodes[0]->getText().toInt32() - 1; if((bandIndex >= static_cast(theNumBands) ) || (bandIndex<0)) { ossimNotify(ossimNotifyLevel_WARN) << "ossimFormosatDimapSupportData::parsePart4 ERROR: Band index outside of range\n"; return false; } sub_nodes.clear(); xpath = "SOLAR_IRRADIANCE_VALUE"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } theSolarIrradiance[bandIndex] = sub_nodes[0]->getText().toDouble(); ++node; } return true; } bool ossimFormosatDimapSupportData::initMetadataVersion(ossimRefPtr xmlDocument) { ossimString xpath; std::vector > xml_nodes; //--- // Get the version string which can be used as a key for parsing. //--- xpath = "/Dimap_Document/Metadata_Id/METADATA_FORMAT"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << endl; } return false; } ossimString attribute = "version"; ossimString value; xml_nodes[0]->getAttributeValue(value, attribute); if (value == "1.0") { theMetadataVersion = OSSIM_FORMOSAT_METADATA_VERSION_1_0; } else if (value == "1.1") { theMetadataVersion = OSSIM_FORMOSAT_METADATA_VERSION_1_1; } if (theMetadataVersion == OSSIM_FORMOSAT_METADATA_VERSION_UNKNOWN) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "WARNING: metadata version not found!" << std::endl; } return false; } return true; } bool ossimFormosatDimapSupportData::initImageId( ossimRefPtr xmlDocument) { ossimString xpath; vector > xml_nodes; //--- // Fetch the Image ID: //--- xpath = "/Dimap_Document/Production/JOB_ID"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << endl; } return false; } theImageID = xml_nodes[0]->getText(); return true; } bool ossimFormosatDimapSupportData::initSceneSource( ossimRefPtr xmlDocument) { ossimString xpath; vector > xml_nodes; //--- // Fetch the mission index (Formosat 1 or 2): // and generate theSensorID //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/MISSION_INDEX"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } if (xml_nodes[0]->getText() == "1") theSensorID = "Formosat 1"; if (xml_nodes[0]->getText() == "2") theSensorID = "Formosat 2"; //--- // Fetch the Viewing Angle Along Track: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/SUN_AZIMUTH"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSunAzimuth = xml_nodes[0]->getText().toDouble(); //--- // Fetch the Viewing Angle Across Track: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/VIEWING_ANGLE_ALONG_TRACK"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theViewingAngleAlongTrack = xml_nodes[0]->getText().toDouble(); //--- // Fetch the Sun Azimuth: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/VIEWING_ANGLE_ACROSS_TRACK"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theViewingAngleAcrossTrack = xml_nodes[0]->getText().toDouble(); //--- // Fetch the Sun Elevation: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/SUN_ELEVATION"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSunElevation = xml_nodes[0]->getText().toDouble(); //--- // Fetch incidence angle: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/SATELLITE_INCIDENCE_ANGLE"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theIncidenceAngle = xml_nodes[0]->getText().toDouble(); //--- // Fetch incidence angle: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Sources/Source_Information/Scene_Source/SATELLITE_AZIMUTH_ANGLE"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSatAzimuth = xml_nodes[0]->getText().toDouble(); //--- // Fetch viewing angle: /* * FROM FORMOSAT: You can use use incidence angle to calculate viewing angle * (called look direction as well). * FIX (see below): need theSatelliteAltitude and theIncidenceAngle. The * equation is shown below where RT is the mean value of WGS84 ellipsoid * semi-axis. * * */ //--- xml_nodes.clear(); xpath = "/Dimap_Document/Data_Strip/Ephemeris/SATELLITE_ALTITUDE"; theViewingAngle = -1.0; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } //compute VIEWING_ANGLE double theSatelliteAltitude = xml_nodes[0]->getText().toDouble(); double RT = 63710087714.0; theViewingAngle = asin((RT/(RT+theSatelliteAltitude))*sin(theIncidenceAngle)); return true; } bool ossimFormosatDimapSupportData::initFramePoints( ossimRefPtr xmlDocument) { ossimString xpath; vector > xml_nodes; //--- // Corner points: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Frame/Vertex"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() != 4) { setErrorStatus(); return false; } std::vector >::iterator node = xml_nodes.begin(); while (node != xml_nodes.end()) { ossimGpt gpt; ossimDpt ipt; std::vector > sub_nodes; xpath = "FRAME_LAT"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lat = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "FRAME_LON"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lon = sub_nodes[0]->getText().toDouble(); gpt.hgt = 0.0; // assumed sub_nodes.clear(); xpath = "FRAME_ROW"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.line = sub_nodes[0]->getText().toDouble() - 1.0; sub_nodes.clear(); xpath = "FRAME_COL"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.samp = sub_nodes[0]->getText().toDouble() - 1.0; theFrameVertexPosImagePoints.push_back(ipt); theFrameVertexPosGroundPoints.push_back(gpt); ++node; } //--- // Center of frame. //--- theRefGroundPoint.hgt = 0.0; // needs to be looked up xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Frame/Scene_Center/FRAME_LON"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() != 1) { setErrorStatus(); return false; } theRefGroundPoint.lon = xml_nodes[0]->getText().toDouble(); xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Frame/Scene_Center/FRAME_LAT"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() != 1) { setErrorStatus(); return false; } theRefGroundPoint.lat = xml_nodes[0]->getText().toDouble(); //--- // Fetch scene orientation: //--- xml_nodes.clear(); xpath = "/Dimap_Document/Dataset_Frame/SCENE_ORIENTATION"; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSceneOrientation = xml_nodes[0]->getText().toDouble(); return true; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimFormosatDimapSupportData.h000066400000000000000000000257761301006202600316760ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimFormosatDimapSupportData_HEADER #define ossimFormosatDimapSupportData_HEADER 1 #include #include #include #include #include #include #include #include #include #include #include #include #include #include class ossimKeywordlist; // class ossimRefPtr; class ossimXmlDocument; class OSSIM_PLUGINS_DLL ossimFormosatDimapSupportData : public ossimObject, public ossimErrorStatusInterface { public: /** metadata.dim format version */ enum ossimFormosatMetadataVersion { OSSIM_FORMOSAT_METADATA_VERSION_UNKNOWN = 0, OSSIM_FORMOSAT_METADATA_VERSION_1_0 = 1, OSSIM_FORMOSAT_METADATA_VERSION_1_1 = 2 }; ossimFormosatDimapSupportData(); ossimFormosatDimapSupportData(const ossimFormosatDimapSupportData& rhs); ossimFormosatDimapSupportData(const ossimFilename& dimapFile); virtual ossimObject* dup()const; void clearFields(); bool loadXmlFile(const ossimFilename& file); ossimString getSensorID() const; ossimString getMetadataVersionString() const; ossimString getAcquisitionDate() const; ossimString getProductionDate() const; ossimString getSoftwareVersion() const; ossimString getImageID() const; ossimString getInstrument() const; ossim_uint32 getInstrumentIndex() const; ossimFilename getMetadataFile() const; void getSunAzimuth(ossim_float64& az) const; void getSunElevation(ossim_float64& el) const; void getSatAzimuth(ossim_float64& az) const; void getImageSize(ossimDpt& sz) const; void getLineSamplingPeriod(ossim_float64& pe) const; void getIncidenceAngle(ossim_float64& ia) const; void getViewingAngle(ossim_float64& va) const; void getViewingAngleAlongTrack(ossim_float64& va) const; void getViewingAngleAcrossTrack(ossim_float64& va) const; void getSceneOrientation(ossim_float64& so) const; ossim_uint32 getNumberOfBands() const; bool isStarTrackerUsed() const; bool isSwirDataUsed() const; //--- // Image center point: //--- /** Center of frame, sub image if there is one. */ void getRefGroundPoint(ossimGpt& gp) const; /** zero base center point */ void getRefImagePoint(ossimDpt& rp) const; void getRefLineTime(ossim_float64& rt) const; /** relative to full frame. */ void getRefLineTimeLine(ossim_float64& rtl) const; /** Zero based image rectangle, sub image if there is one. */ void getImageRect(ossimDrect& rect)const; //--- // Sub image offset: //--- void getSubImageOffset(ossimDpt& offset) const; //--- // Ephemeris (m & m/s): //--- void getPositionEcf(ossim_uint32 sample, ossimEcefPoint& pe) const; void getPositionEcf(const ossim_float64& time, ossimEcefPoint& pe) const; void getVelocityEcf(ossim_uint32 sample, ossimEcefPoint& ve) const; void getVelocityEcf(const ossim_float64& time, ossimEcefPoint& ve) const; void getEphSampTime(ossim_uint32 sample, ossim_float64& et) const; ossim_uint32 getNumEphSamples() const; //--- // Attitude Angles in RADIANS: //--- void getAttitude(ossim_uint32 sample, ossimDpt3d& at) const; void getAttitude(const ossim_float64& time, ossimDpt3d& at) const; void getAttSampTime(ossim_uint32 sample, ossim_float64& at) const; ossim_uint32 getNumAttSamples() const; //--- // Polynomial instrument look angle in RADIANS: //--- void getPixelLookAngleX (ossim_uint32 sample, ossim_float64& pa) const; void getPixelLookAngleX (const ossim_float64& sample, ossim_float64& pa) const; void getPixelLookAngleY (ossim_uint32 sample, ossim_float64& pa) const; void getPixelLookAngleY (const ossim_float64& sample, ossim_float64& pa) const; //--- // Geoposition points provided in the file (most likely just corner points): //--- ossim_uint32 getNumGeoPosPoints() const; void getGeoPosPoint (ossim_uint32 point, ossimDpt& ip, ossimGpt& gp) const; //--- // Corner points: //--- void getUlCorner(ossimGpt& pt) const; void getUrCorner(ossimGpt& pt) const; void getLrCorner(ossimGpt& pt) const; void getLlCorner(ossimGpt& pt) const; //--- // Convenient method to print important image info: //--- void printInfo (ostream& os) const; virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0)const; virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix = 0); protected: virtual ~ossimFormosatDimapSupportData(); private: void getLagrangeInterpolation(const ossim_float64& t, const std::vector& V, const std::vector& T, ossimDpt3d& li )const; void getBilinearInterpolation(const ossim_float64& t, const std::vector& V, const std::vector& T, ossimDpt3d& li )const; void getInterpolatedLookAngle(const ossim_float64& p, const std::vector& angles, ossim_float64& la) const; ossim_float64 convertTimeStamp(const ossimString& time_stamp) const; void convertTimeStamp(const ossimString& time_stamp, ossim_float64& ti) const; /** * Initializes theMetadataVersion. * @return true on success, false if not found. */ bool initMetadataVersion(ossimRefPtr xmlDocument); /** * Initializes theImageId. * @return true on success, false if not found. */ bool initImageId(ossimRefPtr xmlDocument); /** * From xml section: * /Dimap_Document/Dataset_Sources/Source_Information/Scene_Source * * Initializes: * theSunAzimuth * theSunElevation * theSatAzimuth; * theIncidenceAngle * @return true on success, false if not found. */ bool initSceneSource(ossimRefPtr xmlDocument); /** * Frame points: * * From xml section: * /Dimap_Document/Dataset_Frame/ * * Initializes: * theRefGroundPoint * theViewingAngle * theViewingAngleAlongTrack * theViewingAngleAcrossTrack * * Note that the theRefImagePoint will be the zero based center of the * frame. * @return true on success, false if not found. */ bool initFramePoints(ossimRefPtr xmlDocument); ossimString theSensorID; ossimFormosatMetadataVersion theMetadataVersion; ossimString theImageID; ossimFilename theMetadataFile; ossimString theProductionDate; ossimString theSoftwareVersion; ossimString theInstrument; ossim_uint32 theInstrumentIndex; /* * From xml section: * /Dimap_Document/Dataset_Sources/Source_Information/ * Scene_Source */ ossim_float64 theSunAzimuth; ossim_float64 theSunElevation; ossim_float64 theSatAzimuth; ossim_float64 theIncidenceAngle; ossim_float64 theViewingAngle; ossim_float64 theViewingAngleAlongTrack; ossim_float64 theViewingAngleAcrossTrack; ossim_float64 theSceneOrientation; ossimDpt theImageSize; /** Center of frame on ground, if sub image it's the center of that. */ ossimGpt theRefGroundPoint; /** Zero based center of frame. */ ossimDpt theRefImagePoint; ossimDpt theSubImageOffset; /** relative to full image */ ossim_float64 theRefLineTime; /** relative to full image */ ossim_float64 theRefLineTimeLine; ossim_float64 theLineSamplingPeriod; /** holds the size of thePixelLookAngleX/Y */ std::vector thePolynomialLookAngleX; std::vector thePolynomialLookAngleY; std::vector theAttitudeSamples; // x=pitch, y=roll, z=yaw std::vector theAttSampTimes; std::vector thePosEcfSamples; std::vector theVelEcfSamples; std::vector theEphSampTimes; bool theStarTrackerUsed; ossim_uint32 theNumBands; ossimString theAcquisitionDate; //--- // Corner points: //--- //ossimGpt theUlCorner; //ossimGpt theUrCorner; //ossimGpt theLrCorner; //ossimGpt theLlCorner; std::vector theFrameVertexPosImagePoints; std::vector theFrameVertexPosGroundPoints; //--- // Geoposition Points: //--- std::vector theGeoPosImagePoints; std::vector theGeoPosGroundPoints; ossimGpt createGround(const ossimString& s)const; ossimDpt createDpt(const ossimString& s)const; /** callibration information for radiometric corrections*/ std::vector thePhysicalBias; std::vector thePhysicalGain; std::vector theSolarIrradiance; /** * Private parse methods called by loadXml. * * These "parse" methods were made simply to split the loadXmlMethod * into pieces. This was an attempt to troubleshoot what was thought to * be a compiler issue, which turned out to be changed metadata and bad * error handling within this code. Since there were lots of debug * statements added I am committing this to cvs. * DRB 16 Oct. 2005 */ bool parsePart1(ossimRefPtr xmlDocument); bool parsePart2(ossimRefPtr xmlDocument); bool parsePart3(ossimRefPtr xmlDocument); bool parsePart4(ossimRefPtr xmlDocument); }; #endif /* #ifndef ossimFormosatDimapSupportData_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimFormosatModel.cpp000066400000000000000000000624121301006202600300340ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include using namespace std; #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { RTTI_DEF1(ossimFormosatModel, "ossimFormosatModel", ossimSensorModel); } //--- // Define Trace flags for use within this file: //--- #include static ossimTrace traceExec ("ossimFormosatModel:exec"); static ossimTrace traceDebug ("ossimFormosatModel:debug"); static const ossim_int32 MODEL_VERSION_NUMBER = 1; static const char* PARAM_NAMES[] = { "roll_offset", "pitch_offset", "yaw_offset", "roll_rate", "pitch_rate", "yaw_rate", "focal_length_offset" }; static const char* PARAM_UNITS[] = { "degrees", // degrees "degrees", // degrees "degrees", // degrees "degrees", // degrees/sec "degrees", // degrees/sec "degrees", // degrees/sec "unknown" }; // percent deviation from nominal static const ossim_float64 SIGMA[] = { 0.0001, // degrees 0.0001, // degrees 0.0003, // degrees 0.00002, // delta degrees 0.00002, // delta degrees 0.00005, // delta degrees 0.0001 }; // percent ossimplugins::ossimFormosatModel::ossimFormosatModel() : ossimSensorModel (), theSupportData (NULL), theMetaDataFile ("NOT ASSIGNED"), theIllumAzimuth (0.0), theIllumElevation (0.0), theSatAzimuth (0.0), thePositionError (0.0), theRefImagingTime (0.0), theRefImagingTimeLine (0.0), theLineSamplingPeriod (0.0), // theSatToOrbRotation (3, 3), // theOrbToEcfRotation (3, 3), theRollOffset (0.0), thePitchOffset (0.0), theYawOffset (0.0), theRollRate (0.0), thePitchRate (0.0), theYawRate (0.0), theFocalLenOffset (0.0) { initAdjustableParameters(); } ossimplugins::ossimFormosatModel::ossimFormosatModel(ossimFormosatDimapSupportData* sd) : ossimSensorModel (), theSupportData (sd), theMetaDataFile ("NOT ASSIGNED"), theIllumAzimuth (0.0), theIllumElevation (0.0), theSatAzimuth (0.0), thePositionError (0.0), theRefImagingTime (0.0), theRefImagingTimeLine (0.0), theLineSamplingPeriod (0.0), // theSatToOrbRotation (3, 3), // theOrbToEcfRotation (3, 3), theRollOffset (0.0), thePitchOffset (0.0), theYawOffset (0.0), theRollRate (0.0), thePitchRate (0.0), theYawRate (0.0), theFocalLenOffset (0.0) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel(dimap_file) Constructor: entering..." << std::endl; //--- // Instantiate the support data classes after establishing the filenames: //--- loadSupportData(); if (getErrorStatus() != ossimErrorCodes::OSSIM_OK) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel(dimap_file) Constructor: returning with error..." << std::endl; return; } //--- // initialize remaining data members: //--- initAdjustableParameters(); updateModel(); if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel(dimap_file) Constructor: returning..." << std::endl; } //***************************************************************************** // DESTRUCTOR: ~ossimFormosatModel() // //***************************************************************************** ossimplugins::ossimFormosatModel::~ossimFormosatModel() { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG DESTRUCTOR: ~ossimFormosatModel(): entering..." << std::endl; theSupportData = 0; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG DESTRUCTOR: ~ossimFormosatModel(): returning..." << std::endl; } ossimplugins::ossimFormosatModel::ossimFormosatModel(const ossimFormosatModel& rhs) :ossimSensorModel(rhs) { if(rhs.theSupportData.valid()) { theSupportData = (ossimFormosatDimapSupportData*)rhs.theSupportData->dup(); } loadSupportData(); updateModel(); } void ossimplugins::ossimFormosatModel::computeSatToOrbRotation(NEWMAT::Matrix& result, ossim_float64 t)const { if (traceExec()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::computeSatToOrbRotation(): entering..." << std::endl; } //--- // Linearly interpolate attitudes angles: //--- ossimDpt3d att; theSupportData->getAttitude(t, att); //--- // Apply the attitude adjustable parameters: //--- double dt = theRefImagingTime - t; att.x += thePitchOffset + dt*thePitchRate; att.y += theRollOffset + dt*theRollRate; att.z += theYawOffset + dt*theYawRate; //--- // Compute trig functions to populate rotation matrices: ANGLES IN RADIANS //--- double cp = cos(att.x); double sp = sin(att.x); double cr = cos(att.y); double sr = sin(att.y); double cy = cos(att.z); double sy = sin(att.z); //--- // Populate rotation matrix: //--- result = NEWMAT::Matrix(3,3); result << (cr*cy) << (-cr*sy) << (-sr) << (cp*sy+sp*sr*cy) << (cp*cy-sp*sr*sy) << (sp*cr) << (-sp*sy+cp*sr*cy) << (-sp*cy-cp*sr*sy) << cp*cr; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::computeSatToOrbRotation(): returning..." << std::endl; } #if 0 //***************************************************************************** // METHOD //***************************************************************************** void ossimplugins::ossimFormosatModel::computeSatToOrbRotation(ossim_float64 t)const { if (traceExec()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::computeSatToOrbRotation(): entering..." << std::endl; } //--- // Linearly interpolate attitudes angles: //--- ossimDpt3d att; theSupportData->getAttitude(t, att); //--- // Apply the attitude adjustable parameters: //--- double dt = theRefImagingTime - t; att.x += thePitchOffset + dt*thePitchRate; att.y += theRollOffset + dt*theRollRate; att.z += theYawOffset + dt*theYawRate; //--- // Compute trig functions to populate rotation matrices: ANGLES IN RADIANS //--- double cp = cos(att.x); double sp = sin(att.x); double cr = cos(att.y); double sr = sin(att.y); double cy = cos(att.z); double sy = sin(att.z); //--- // Populate rotation matrix: //--- theSatToOrbRotation = NEWMAT::Matrix(3,3); theSatToOrbRotation << (cr*cy) << (-cr*sy) << (-sr) << (cp*sy+sp*sr*cy) << (cp*cy-sp*sr*sy) << (sp*cr) << (-sp*sy+cp*sr*cy) << (-sp*cy-cp*sr*sy) << cp*cr; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::computeSatToOrbRotation(): returning..." << std::endl; } #endif //***************************************************************************** // PUBLIC METHOD: ossimFormosatModel::updateModel() // // Updates the model parameters given the normalized adjustable parameter // array. // //***************************************************************************** void ossimplugins::ossimFormosatModel::updateModel() { clearErrorStatus(); try { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::updateModel(): entering..." << std::endl; if(getNumberOfAdjustableParameters() < 1) { theRollOffset = 0; thePitchOffset = 0; theYawOffset = 0; theRollRate = 0; thePitchRate = 0; theYawRate = 0; theFocalLenOffset = 0; } else { theRollOffset = computeParameterOffset(0); thePitchOffset = computeParameterOffset(1); theYawOffset = computeParameterOffset(2); theRollRate = computeParameterOffset(3); thePitchRate = computeParameterOffset(4); theYawRate = computeParameterOffset(5); theFocalLenOffset = computeParameterOffset(6); } theSeedFunction = 0; ossimGpt ulg, urg, lrg, llg; lineSampleToWorld(theImageClipRect.ul(), ulg); lineSampleToWorld(theImageClipRect.ur(), urg); lineSampleToWorld(theImageClipRect.lr(), lrg); lineSampleToWorld(theImageClipRect.ll(), llg); theSeedFunction = new ossimBilinearProjection(theImageClipRect.ul(), theImageClipRect.ur(), theImageClipRect.lr(), theImageClipRect.ll(), ulg, urg, lrg, llg); if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::updateModel(): returning..." << std::endl; } catch(...) { setErrorStatus(ossimErrorCodes::OSSIM_ERROR); } } void ossimplugins::ossimFormosatModel::initAdjustableParameters() { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::initAdjustableParameters(): entering..." << std::endl; //--- // Allocate storage for adjustables and assign their names and units // strings. //--- resizeAdjustableParameterArray(7); ossim_uint32 numParams = getNumberOfAdjustableParameters(); //--- // Initialize base-class adjustable parameter array: //--- for (ossim_uint32 i=0; igetErrorStatus(): " << theSupportData->getErrorStatus() <getErrorStatus() != ossimErrorCodes::OSSIM_OK) { setErrorStatus(); ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimFormosatModel::loadSupportData(): Bad FormosatDimapSupportData detected. Aborting..." << std::endl; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::loadSupportData(): returning..." << std::endl; return; } //--- // Initialize some member variables from the support data: //--- theSensorID = theSupportData->getSensorID(); theImageID = theSupportData->getImageID(); theMetaDataFile = theSupportData->getMetadataFile(); // Center of frame, sub image if we have one. theSupportData->getRefGroundPoint(theRefGndPt); theSupportData->getSunAzimuth(theIllumAzimuth); theSupportData->getSunElevation(theIllumElevation); theSupportData->getSatAzimuth(theSatAzimuth); ossimDpt sz; theSupportData->getImageSize(sz); theImageSize = sz; theSupportData->getRefLineTime(theRefImagingTime); theSupportData->getRefLineTimeLine(theRefImagingTimeLine); theSupportData->getLineSamplingPeriod(theLineSamplingPeriod); theSupportData->getSubImageOffset(theSpotSubImageOffset); //--- // We make this zero base as the base ossimSensorModel does not know about // any sub image we have. //--- theSupportData->getImageRect(theImageClipRect); theSupportData->getRefImagePoint(theRefImgPt); ossimGpt p1; ossimGpt p2; ossimGpt p3; ossimGpt p4; // I need to find the nominal scale of the spot 5 dataset //--- // Position error is a function of whether star tracker information was // available: //--- if (theSupportData->isStarTrackerUsed()) { thePositionError = 50.0; } else { thePositionError = 200.0; // meters } updateModel(); lineSampleToWorld(theImageClipRect.ul(), p1); lineSampleToWorld(theImageClipRect.ur(), p2); lineSampleToWorld(theImageClipRect.lr(), p3); lineSampleToWorld(theImageClipRect.ll(), p4); ossimDpt v[4]; // temporarily holds vertices for ground polygon v[0] = p1; v[1] = p2; v[2] = p3; v[3] = p4; theBoundGndPolygon = ossimPolygon(4, v); ossimGpt cgpt, hgpt, vgpt; // ossimEcefPoint hVector, vVector; ossimDpt midpt = theImageClipRect.midPoint(); lineSampleToWorld(midpt, cgpt); lineSampleToWorld(midpt + ossimDpt(1,0), hgpt); lineSampleToWorld(midpt + ossimDpt(0,1), vgpt); theGSD = ossimDpt((ossimEcefPoint(cgpt) - ossimEcefPoint(hgpt)).magnitude(), (ossimEcefPoint(cgpt) - ossimEcefPoint(vgpt)).magnitude()); theMeanGSD = (theGSD.x+theGSD.y)/2.0; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::loadSupportData(): returning..." << std::endl; } ossimObject* ossimplugins::ossimFormosatModel::dup() const { return new ossimFormosatModel(*this); } std::ostream& ossimplugins::ossimFormosatModel::print(std::ostream& out) const { // Capture stream flags since we are going to mess with them. std::ios_base::fmtflags f = out.flags(); out << "\nDump of ossimFormosatModel at address " << (hex) << this << (dec) << "\n------------------------------------------------" << "\n theImageID = " << theImageID << "\n theMetadataFile = " << theMetaDataFile << "\n theIllumAzimuth = " << theIllumAzimuth << "\n theIllumElevation = " << theIllumElevation << "\n theSatAzimuth = " << theSatAzimuth << "\n thePositionError = " << thePositionError << "\n theImageSize = " << theImageSize << "\n theRefGndPt = " << theRefGndPt << "\n theRefImgPt = " << theRefImgPt << "\n theRefImagingTime = " << theRefImagingTime << "\n theRefImagingTimeLine = " << theRefImagingTimeLine << "\n theLineSamplingPeriod = " << theLineSamplingPeriod << "\n theRollOffset = " << theRollOffset << "\n thePitchOffset = " << thePitchOffset << "\n theYawOffset = " << theYawOffset << "\n theRollRate = " << theRollRate << "\n thePitchRate = " << thePitchRate << "\n theYawRate = " << theYawRate << "\n theFocalLenOffset = " << theFocalLenOffset << "\n------------------------------------------------" << "\n " << endl; // Set the flags back. out.flags(f); return ossimSensorModel::print(out); } bool ossimplugins::ossimFormosatModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { if(theSupportData.valid()) { ossimString supportPrefix = ossimString(prefix) + "support_data."; theSupportData->saveState(kwl, supportPrefix); } else { return false; } return ossimSensorModel::saveState(kwl, prefix); } bool ossimplugins::ossimFormosatModel::loadState(const ossimKeywordlist& kwl, const char* prefix) { ossimString supportPrefix = ossimString(prefix) + "support_data."; if(!theSupportData) { theSupportData = new ossimFormosatDimapSupportData; } if(theSupportData->loadState(kwl, supportPrefix)) { if(!ossimSensorModel::loadState(kwl, prefix)) { return false; } } else { return false; } loadSupportData(); updateModel(); return (getErrorStatus()==ossimErrorCodes::OSSIM_OK); } void ossimplugins::ossimFormosatModel::imagingRay(const ossimDpt& image_point, ossimEcefRay& image_ray) const { bool runtime_dbflag = 0; NEWMAT::Matrix satToOrbit; ossimDpt iPt = image_point; iPt.samp += theSpotSubImageOffset.samp; iPt.line += theSpotSubImageOffset.line; // // 1. Establish time of line imaging: // double t_line = theRefImagingTime + theLineSamplingPeriod*(iPt.line - theRefImagingTimeLine); if (traceDebug() || runtime_dbflag) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG FormosatModel::imagingRay():------------ BEGIN DEBUG PASS ---------------" << std::endl; ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG FormosatModel::imagingRay(): t_line = " << t_line << std::endl; } // // 2. Interpolate ephemeris position and velocity (in ECF): // ossimEcefPoint tempEcefPoint; ossimEcefPoint P_ecf; theSupportData->getPositionEcf(t_line, P_ecf); theSupportData->getVelocityEcf(t_line, tempEcefPoint); ossimEcefVector V_ecf(tempEcefPoint.x(), tempEcefPoint.y(), tempEcefPoint.z()); if (traceDebug() || runtime_dbflag) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n\tP_ecf = " << P_ecf << "\n\t V_ecf = " << V_ecf << std::endl; } // // 3. Establish the look direction in Vehicle LSR space (S_sat). // ANGLES IN RADIANS // ossim_float64 Psi_x; theSupportData->getPixelLookAngleX(iPt.samp, Psi_x); ossim_float64 Psi_y; theSupportData->getPixelLookAngleY(iPt.samp, Psi_y); if (traceDebug() || runtime_dbflag) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n\t Psi_x = " << Psi_x << "\n\t Psi_y = " << Psi_y << endl; } ossimColumnVector3d u_sat (-tan(Psi_y), tan(Psi_x), -(1.0 + theFocalLenOffset)); if (traceDebug() || runtime_dbflag) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG \n\t u_sat = " << u_sat << endl; } // // 4. Transform vehicle LSR space look direction vector to orbital LSR space // (S_orb): // computeSatToOrbRotation(satToOrbit, t_line); ossimColumnVector3d u_orb = (satToOrbit*u_sat).unit(); if (traceDebug() || runtime_dbflag) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n\t theSatToOrbRotation = " << satToOrbit << "\n\t u_orb = " << u_orb << endl; } // // 5. Transform orbital LSR space look direction vector to ECF. // // a. S_orb space Z-axis (Z_orb) is || to the ECF radial vector (P_ecf), // b. X_orb axis is computed as cross-product between velocity and radial, // c. Y_orb completes the orthogonal S_orb coordinate system. // ossimColumnVector3d Z_orb (P_ecf.x(), P_ecf.y(), P_ecf.z()); Z_orb = Z_orb.unit(); ossimColumnVector3d X_orb = ossimColumnVector3d(V_ecf.x(), V_ecf.y(), V_ecf.z()).cross(Z_orb).unit(); ossimColumnVector3d Y_orb = Z_orb.cross(X_orb); NEWMAT::Matrix orbToEcfRotation = NEWMAT::Matrix(3, 3); orbToEcfRotation << X_orb[0] << Y_orb[0] << Z_orb[0] << X_orb[1] << Y_orb[1] << Z_orb[1] << X_orb[2] << Y_orb[2] << Z_orb[2]; ossimColumnVector3d u_ecf = (orbToEcfRotation*u_orb); if (traceDebug() || runtime_dbflag) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n\t orbToEcfRotation = " << orbToEcfRotation << "\n\t u_ecf = " << u_ecf << endl; } // // Establish the imaging ray given direction and origin: // image_ray = ossimEcefRay(P_ecf, ossimEcefVector(u_ecf[0], u_ecf[1], u_ecf[2])); if (traceExec()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG FormosatModel::imagingRay(): returning..." << std::endl; } } void ossimplugins::ossimFormosatModel::lineSampleHeightToWorld(const ossimDpt& image_point, const ossim_float64& heightEllipsoid, ossimGpt& worldPoint) const { if (!insideImage(image_point)) { if(theSeedFunction.valid()) { theSeedFunction->lineSampleToWorld(image_point, worldPoint); } else { worldPoint = extrapolate(image_point, heightEllipsoid); } if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimFormosatModel::lineSampleHeightToWorld(): returning..." << std::endl; return; } //*** // First establish imaging ray from image point: //*** ossimEcefRay imaging_ray; imagingRay(image_point, imaging_ray); ossimEcefPoint Pecf (imaging_ray.intersectAboveEarthEllipsoid(heightEllipsoid)); worldPoint = ossimGpt(Pecf); } // ossimDpt ossimplugins::ossimFormosatModel::extrapolate (const ossimGpt& gp) const // { // ossimDpt temp; // temp.makeNan(); // return temp; // ossimDpt tempGpt = gp; // ossimDpt dest; // theGroundToImageMap.map(tempGpt, dest); // return dest; // } // ossimGpt ossimplugins::ossimFormosatModel::extrapolate (const ossimDpt& ip, // const double& height) const // { // return ossimGpt(ossim::nan(), ossim::nan(), ossim::nan(), 0); // ossimDpt dest; // theImageToGroundMap.map(ip, dest); // return ossimGpt(dest.lat, dest.lon, ossim::nan(), origin().datum()); // } bool ossimplugins::ossimFormosatModel::setupOptimizer(const ossimString& init_file) { ossimFilename FormosatTest = init_file; ossimFilename geomFile = init_file; geomFile = geomFile.setExtension("geom"); bool tryKwl = false; if(!FormosatTest.exists()) { FormosatTest = geomFile.path(); FormosatTest = FormosatTest.dirCat(ossimFilename("METADATA.DIM")); if(FormosatTest.exists() == false) { FormosatTest = geomFile.path(); FormosatTest = FormosatTest.dirCat(ossimFilename("metadata.dim")); } } if(FormosatTest.exists()) { ossimRefPtr meta = new ossimFormosatDimapSupportData; if(meta->loadXmlFile(FormosatTest)) { initFromMetadata(meta.get()); if (getErrorStatus()) { tryKwl = true; meta=0; } else { return true; } } else { meta=0; tryKwl = true; } } if(tryKwl) { ossimKeywordlist kwl; if(kwl.addFile(init_file.c_str())) { return loadState(kwl); } } return false; } bool ossimplugins::ossimFormosatModel::initFromMetadata(ossimFormosatDimapSupportData* sd) { // init parms theSupportData = sd; theMetaDataFile = "NOT ASSIGNED"; theIllumAzimuth = 0.0; theIllumElevation = 0.0; theSatAzimuth = 0.0; thePositionError = 0.0; theRefImagingTime = 0.0; theLineSamplingPeriod = 0.0; // theSatToOrbRotation = 0.0; //matrix // theOrbToEcfRotation = 0.0; //matrix theRollOffset = 0.0; thePitchOffset = 0.0; theYawOffset = 0.0; theRollRate = 0.0; thePitchRate = 0.0; theYawRate = 0.0; theFocalLenOffset = 0.0; //--- // Instantiate the support data classes after establishing the filenames: //--- loadSupportData(); if (getErrorStatus() != ossimErrorCodes::OSSIM_OK) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimplugins::ossimFormosatModel::initFromMetadata(dimap_file): returning with error..." << std::endl; return false; } //--- // initialize remaining data members: //--- initAdjustableParameters(); updateModel(); return true; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimFormosatModel.h000066400000000000000000000114271301006202600275010ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimFormosatModel_HEADER #define ossimFormosatModel_HEADER #include #include #include #include #include #include #include #include #include #include class ossimFormosatDimapSupportData; namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimFormosatModel : public ossimSensorModel { public: /*! * CONSTRUCTORS: */ ossimFormosatModel(); ossimFormosatModel(ossimFormosatDimapSupportData* sd); ossimFormosatModel(const ossimFilename& init_file); ossimFormosatModel(const ossimKeywordlist& geom_kwl); ossimFormosatModel(const ossimFormosatModel& rhs); virtual ~ossimFormosatModel(); enum AdjustParamIndex { ROLL_OFFSET = 0, PITCH_OFFSET, YAW_OFFSET, ROLL_RATE, PITCH_RATE, YAW_RATE, FOCAL_LEN_OFFSET, NUM_ADJUSTABLE_PARAMS // not an index }; /*! * Returns pointer to a new instance, copy of this. * Not implemented yet! Returns NULL... */ virtual ossimObject* dup() const; /*! * Extends base-class implementation. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; /*! * Fulfills ossimObject base-class pure virtuals. Loads and saves geometry * KWL files. Returns true if successful. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=NULL) const; virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=NULL); /*! * Writes a template of geom keywords processed by loadState and saveState * to output stream. */ static void writeGeomTemplate(ostream& os); /*! * Given an image point and height, initializes worldPoint. */ virtual void lineSampleHeightToWorld(const ossimDpt& image_point, const ossim_float64& heightEllipsoid, ossimGpt& worldPoint) const; /*! * Given an image point, returns a ray originating at some arbitrarily high * point (ideally at the sensor position) and pointing towards the target. */ virtual void imagingRay(const ossimDpt& image_point, ossimEcefRay& image_ray) const; /*! * Following a change to the adjustable parameter set, this virtual * is called to permit instances to compute derived quantities after * parameter change. */ virtual void updateModel(); /*! * ossimOptimizableProjection */ inline virtual bool useForward()const {return false;} //!image to ground faster virtual bool setupOptimizer(const ossimString& init_file); //!uses file path to init model bool initFromMetadata(ossimFormosatDimapSupportData* sd); protected: /*! * Sets adjustables to default values. */ void initAdjustableParameters(); void loadGeometry(FILE*); void loadSupportData(); //void computeSatToOrbRotation(ossim_float64 t)const; void computeSatToOrbRotation(NEWMAT::Matrix& result, ossim_float64 t)const; /* virtual ossimDpt extrapolate (const ossimGpt& gp) const; */ /* virtual ossimGpt extrapolate (const ossimDpt& ip, */ /* const double& height=ossim::nan()) const; */ ossimRefPtr theSupportData; //--- // Image constant parameters: //--- ossimFilename theMetaDataFile; ossim_float64 theIllumAzimuth; ossim_float64 theIllumElevation; ossim_float64 theSatAzimuth; ossim_float64 thePositionError; ossim_float64 theRefImagingTime; /** relative to full image */ ossim_float64 theRefImagingTimeLine; ossim_float64 theLineSamplingPeriod; ossimDpt theSpotSubImageOffset; // mutable NEWMAT::Matrix theSatToOrbRotation; // mutable NEWMAT::Matrix theOrbToEcfRotation; //--- // Adjustable parameters: //--- ossim_float64 theRollOffset; // degrees ossim_float64 thePitchOffset; // degrees ossim_float64 theYawOffset; // degrees ossim_float64 theRollRate; // degrees/sec ossim_float64 thePitchRate; // degrees/sec ossim_float64 theYawRate; // degrees/sec ossim_float64 theFocalLenOffset; // percent deviation from nominal TYPE_DATA }; } #endif /* #ifndef ossimFormosatModel_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimGeometricSarSensorModel.cpp000066400000000000000000000611301301006202600320140ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { static const char PRODUCT_GEOREFERENCED_FLAG_KW[] = "product_georeferenced_flag"; static const char OPTIMIZATION_FACTOR_X_KW[] = "optimization_factor_x"; static const char OPTIMIZATION_FACTOR_Y_KW[] = "optimization_factor_y"; static const char OPTIMIZATION_BIAS_X_KW[] = "optimization_bias_x"; static const char OPTIMIZATION_BIAS_Y_KW[] = "optimization_bias_y"; const char* ossimGeometricSarSensorModel::CREATE_OCG_PREF_KW = "geometric_sar_sensor_model.create_ocg"; RTTI_DEF1(ossimGeometricSarSensorModel, "ossimGeometricSarSensorModel", ossimSensorModel); static ossimTrace traceDebug("ossimGeometricSarSensorModel:debug"); ossimGeometricSarSensorModel::ossimGeometricSarSensorModel() : ossimSensorModel(), _platformPosition(0), _sensor(0), _refPoint(0), _sarSensor(0), _isProductGeoreferenced(false), _optimizationFactorX(0.0), _optimizationFactorY(0.0), _optimizationBiasX(0.0), _optimizationBiasY(0.0) { } ossimGeometricSarSensorModel::ossimGeometricSarSensorModel( const ossimGeometricSarSensorModel& rhs) : ossimSensorModel(rhs), _platformPosition(rhs._platformPosition?rhs._platformPosition->Clone():(PlatformPosition*)0), _sensor(rhs._sensor?rhs._sensor->Clone():(SensorParams*)0), _refPoint(rhs._refPoint?rhs._refPoint->Clone():( RefPoint *)0), _isProductGeoreferenced(rhs._isProductGeoreferenced), _optimizationFactorX(rhs._optimizationFactorX), _optimizationFactorY(rhs._optimizationFactorY), _optimizationBiasX(rhs._optimizationBiasX), _optimizationBiasY(rhs._optimizationBiasY), _imageFilename(rhs._imageFilename), _productXmlFile(rhs._productXmlFile) { _sarSensor = new SarSensor(_sensor,_platformPosition); } ossimGeometricSarSensorModel::~ossimGeometricSarSensorModel() { if (_platformPosition != 0) { delete _platformPosition; _platformPosition = 0; } if(_sensor != 0) { delete _sensor; _sensor = 0; } if (_sarSensor != 0) { delete _sarSensor; _sarSensor = 0; } if(_refPoint != 0) { delete _refPoint; _refPoint = 0; } } double ossimGeometricSarSensorModel::getSlantRange(double col) const { const double CLUM = 2.99792458e+8 ; double dist = _refPoint->get_distance() + _sensor->get_col_direction() * (col - (_refPoint->get_pix_col())) * ((CLUM / 2.0) * _sensor->get_nRangeLook() / _sensor->get_sf()) ; return dist; } JSDDateTime ossimGeometricSarSensorModel::getTime(double line) const { double dt = _sensor->get_lin_direction() * (line - _refPoint->get_pix_line()) * _sensor->get_nAzimuthLook() / _sensor->get_prf() ; JSDDateTime time = _refPoint->get_ephemeris()->get_date(); time.set_second(time.get_second() + dt); time.NormDate(); return time; } bool ossimGeometricSarSensorModel::getPlatformPositionAtLine(double line, vector& position, vector& speed) { JSDDateTime time = getTime(line); return _platformPosition->getPlatformPositionAtTime(time,position,speed); } void ossimGeometricSarSensorModel::lineSampleHeightToWorld( const ossimDpt& image_point, const double& heightEllipsoid, ossimGpt& worldPoint) const { if (!_sarSensor) { // bad design consequence, should be fixed. _sarSensor = new SarSensor(_sensor, _platformPosition); } double lon, lat; // const double CLUM = 2.99792458e+8 ; // optimization double col = image_point.x - (image_point.x * _optimizationFactorX + _optimizationBiasX) ; double line = image_point.y - (image_point.y * _optimizationFactorY + _optimizationBiasY) ; JSDDateTime azimuthTime = getTime(line) ; // Slant range computation, depending on the product type double slantRange; if (_isProductGeoreferenced) { slantRange = getSlantRangeFromGeoreferenced(col) ; } else { slantRange = getSlantRange(col) ; } int etatLoc = _sarSensor->ImageToWorld(slantRange, azimuthTime, heightEllipsoid, lon, lat); if(traceDebug()) { switch (etatLoc) { case 0: ossimNotify(ossimNotifyLevel_DEBUG) << "successful call to lineSampleHeightToWorld" << std::endl; break; case 1: ossimNotify(ossimNotifyLevel_DEBUG) << "lineSampleHeightToWorld : no real root to the equation belongs to the imaging ray" << std::endl; break; case 2: ossimNotify(ossimNotifyLevel_DEBUG) << "lineSampleHeightToWorld : no real root to the equation" << std::endl; break; default : ossimNotify(ossimNotifyLevel_DEBUG) << "lineSampleHeightToWorld : unknown error case" << std::endl; break; } } worldPoint.lat = lat; worldPoint.lon = lon; worldPoint.hgt = heightEllipsoid ; } void ossimGeometricSarSensorModel::clearGCPlist() { _optimizationGCPsGroundCoordinates.clear(); _optimizationGCPsImageCoordinates.clear(); // optimization model update optimizeModel(_optimizationGCPsGroundCoordinates, _optimizationGCPsImageCoordinates) ; } void ossimGeometricSarSensorModel::getGCPlist(std::list & groundCoordinates, std::list & imageCoordinates) { groundCoordinates = _optimizationGCPsGroundCoordinates ; imageCoordinates = _optimizationGCPsImageCoordinates ; } bool ossimGeometricSarSensorModel::optimizeModel(const std::list & groundCoordinates, const std::list & imageCoordinates) { if (groundCoordinates.size() != imageCoordinates.size()) return false ; // no optimization is used during the GCP localization error computation _optimizationFactorX = 0.0 ; _optimizationFactorY = 0.0 ; _optimizationBiasX = 0.0 ; _optimizationBiasY = 0.0 ; // appends the user input GCPs to the GCPs already present _optimizationGCPsGroundCoordinates.insert(_optimizationGCPsGroundCoordinates.end(), groundCoordinates.begin(), groundCoordinates.end()) ; _optimizationGCPsImageCoordinates.insert(_optimizationGCPsImageCoordinates.end(), imageCoordinates.begin(), imageCoordinates.end()) ; // no GCP : no optimization if (groundCoordinates.size() == 0) return true ; // Inverse projection of each Ground Control Point std::list::iterator itGround = _optimizationGCPsGroundCoordinates.begin() ; std::list inverseLocResults ; while (itGround != _optimizationGCPsGroundCoordinates.end()) { ossimDpt itLoc ; this->worldToLineSample(*itGround,itLoc); inverseLocResults.push_back(itLoc) ; itGround++; } // error computation int nbPoints = _optimizationGCPsGroundCoordinates.size() ; double xErrorMean = 0.0, yErrorMean = 0.0, xActualPow = 0.0, yActualPow = 0.0, xActualMean = 0.0, yActualMean = 0.0, xErrorByActualMean = 0.0, yErrorByActualMean = 0.0 ; double xLocalError, yLocalError ; std::list::iterator itActualCoords = _optimizationGCPsImageCoordinates.begin() ; std::list::iterator itEstimatedCoords = inverseLocResults.begin() ; while ((itActualCoords != _optimizationGCPsImageCoordinates.end())&&(itEstimatedCoords != inverseLocResults.end())) { xLocalError = itActualCoords->x - itEstimatedCoords->x ; yLocalError = itActualCoords->y - itEstimatedCoords->y ; xErrorMean += xLocalError ; yErrorMean += yLocalError ; xActualMean += itActualCoords->x ; yActualMean += itActualCoords->y ; xActualPow += itActualCoords->x * itActualCoords->x ; yActualPow += itActualCoords->y * itActualCoords->y ; xErrorByActualMean += xLocalError * itActualCoords->x ; yErrorByActualMean += yLocalError * itActualCoords->y ; ++itActualCoords; ++itEstimatedCoords; } xErrorMean /= nbPoints ; yErrorMean /= nbPoints ; xActualMean /= nbPoints ; yActualMean /= nbPoints ; xActualPow /= nbPoints ; yActualPow /= nbPoints ; xErrorByActualMean /= nbPoints ; yErrorByActualMean /= nbPoints ; // linear regression if (fabs(xActualPow - xActualMean*xActualMean) > FLT_EPSILON) _optimizationFactorX = (xErrorByActualMean - xErrorMean * xActualMean) / (xActualPow - xActualMean*xActualMean) ; if (fabs(yActualPow - yActualMean*yActualMean) > FLT_EPSILON) _optimizationFactorY = (yErrorByActualMean - yErrorMean * yActualMean) / (yActualPow - yActualMean*yActualMean) ; _optimizationBiasX = xErrorMean - _optimizationFactorX * xActualMean ; _optimizationBiasY = yErrorMean - _optimizationFactorY * yActualMean ; //// Comparison between the estimated image coordinates of each GCP and its actual image coordinates //double lineBias = 0.0, columnBias = 0.0 ; //int nbPtsUsed = 0; //std::list::iterator itActualCoords = imageCoordinates.begin() ; //std::list::iterator itEstimatedCoords = inverseLocResults.begin() ; //while ((itActualCoords != imageCoordinates.end())&&(itEstimatedCoords != inverseLocResults.end())) { // // columnBias += (itActualCoords->x - itEstimatedCoords->x ) ; // lineBias += (itActualCoords->y - itEstimatedCoords->y ) ; // // nbPtsUsed++; // itActualCoords++; // itEstimatedCoords++; //} //// Computation of bias in line and column : mean deviations //lineBias /= nbPtsUsed ; //columnBias /= nbPtsUsed ; //// Update of the model Reference Point //_refPoint->set_pix_col(_refPoint->get_pix_col() - columnBias); //_refPoint->set_pix_line(_refPoint->get_pix_line() - lineBias); return true ; } bool ossimGeometricSarSensorModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimGeometricSarSensorModel::saveState"; bool result = false; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } if (_platformPosition && _sensor && _refPoint) { if ( _platformPosition->saveState(kwl, prefix) ) { if ( _sensor->saveState(kwl, prefix) ) { result = _refPoint->saveState(kwl, prefix); if (result) { kwl.add(prefix, PRODUCT_GEOREFERENCED_FLAG_KW, (_isProductGeoreferenced?"true":"false")); kwl.add(prefix, OPTIMIZATION_FACTOR_X_KW, _optimizationFactorX); kwl.add(prefix, OPTIMIZATION_FACTOR_Y_KW, _optimizationFactorY); kwl.add(prefix, OPTIMIZATION_BIAS_X_KW, _optimizationBiasX); kwl.add(prefix, OPTIMIZATION_BIAS_Y_KW, _optimizationBiasY); result = ossimSensorModel::saveState(kwl, prefix); } } } } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimGeometricSarSensorModel::loadState(const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimGeometricSarSensorModel::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result = true; // Load the base class; if ( ossimSensorModel::loadState(kwl, prefix) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nossimSensorModel::loadState failed!\n"; } result = false; } // Load the platform position state. if ( !_platformPosition) { _platformPosition = new PlatformPosition(); } if ( _platformPosition->loadState(kwl, prefix) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n_platformPosition->loadState failed!\n"; } result = false; } // Load the sensor position state. if ( !_sensor) { _sensor = new SensorParams(); } if ( _sensor->loadState(kwl, prefix) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n_sensor->loadState failed!\n"; } result = false; } _sarSensor = new SarSensor(_sensor, _platformPosition); // Load the ref point. if ( !_refPoint) { _refPoint = new RefPoint(); } if ( _refPoint->loadState(kwl, prefix) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n_refPoint->loadState failed!\n"; } result = false; } const char* lookup = 0; ossimString s; lookup = kwl.find(prefix, PRODUCT_GEOREFERENCED_FLAG_KW); if (lookup) { s = lookup; _isProductGeoreferenced = s.toBool(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << PRODUCT_GEOREFERENCED_FLAG_KW << "\n"; } result = false; } lookup = kwl.find(prefix, OPTIMIZATION_FACTOR_X_KW); if (lookup) { s = lookup; _optimizationFactorX = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << OPTIMIZATION_FACTOR_X_KW << "\n"; } result = false; } lookup = kwl.find(prefix, OPTIMIZATION_FACTOR_Y_KW); if (lookup) { s = lookup; _optimizationFactorY = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << OPTIMIZATION_FACTOR_Y_KW << "\n"; } result = false; } lookup = kwl.find(prefix,OPTIMIZATION_BIAS_X_KW); if (lookup) { s = lookup; _optimizationBiasX= s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << OPTIMIZATION_BIAS_X_KW << "\n"; } result = false; } lookup = kwl.find(prefix,OPTIMIZATION_BIAS_Y_KW); if (lookup) { s = lookup; _optimizationBiasY = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << OPTIMIZATION_BIAS_X_KW << "\n"; } result = false; } // if (result && traceDebug()) // if (result) // { // ossimNotify(ossimNotifyLevel_DEBUG) // << "calling saveState to verify loadState..." << endl; // ossimKeywordlist kwl2; // saveState(kwl2, 0); // ossimNotify(ossimNotifyLevel_DEBUG) // << "saveState result after loadState:" << kwl2 << endl; // } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } #if 0 if(!InitSRGR(kwl, prefix)) { return false; } if(!InitPlatformPosition(kwl, prefix)) { return false; } if(!InitSensorParams(kwl, prefix)) { return false; } if(!InitRefPoint(kwl, prefix)) { return false; } return true; } #endif std::ostream& ossimGeometricSarSensorModel::print(std::ostream& out) const { out << setprecision(15) << setiosflags(ios::fixed) << "\nossimGeometricSarSensorModel class data members:\n"; const char* prefix = 0; ossimKeywordlist kwl; if (_platformPosition) { _platformPosition->saveState(kwl, prefix); } if (_sensor) { _sensor->saveState(kwl, prefix); } if (_refPoint) { _refPoint->saveState(kwl, prefix); } kwl.add(prefix, PRODUCT_GEOREFERENCED_FLAG_KW, (_isProductGeoreferenced?"true":"false")); kwl.add(prefix, OPTIMIZATION_FACTOR_X_KW, _optimizationFactorX); kwl.add(prefix, OPTIMIZATION_FACTOR_Y_KW, _optimizationFactorY); kwl.add(prefix, OPTIMIZATION_BIAS_X_KW, _optimizationBiasX); kwl.add(prefix, OPTIMIZATION_BIAS_Y_KW, _optimizationBiasY); out << kwl; return ossimSensorModel::print(out); } //************************************************************************************************* // Creates replacement coarse grid model if user requested via ossim preferences keyword. // Returns true if load OK, false on error //************************************************************************************************* bool ossimGeometricSarSensorModel::createReplacementOCG() { // Read the preferences to determine if we need to do this: ossimString str (ossimPreferences::instance()->findPreference(CREATE_OCG_PREF_KW)); if (!str.toBool()) return true; // this is not an error condition // Compute the coarse grid: _replacementOcgModel = new ossimCoarseGridModel; _replacementOcgModel->setInterpolationError(0.1); _replacementOcgModel->setMinGridSpacing(50); if (traceDebug()) { ossimNotify(ossimNotifyLevel_NOTICE)<<"\nComputing coarse grid..."<buildGrid(theImageClipRect, this, 500.00, true, false); // Save the coarse grid to appropriate location given image filename: bool status = _replacementOcgModel->saveCoarseGrid(_imageFilename); // this saves geom file as well return status; } //***************************************************************************** // METHOD: ossimGeometricSarSensorModel::lineSampleToWorld(image_pt, &gpt) // // Intersects the ray associated with image_pt with the available elevation // model. Returns ground point // //***************************************************************************** void ossimGeometricSarSensorModel::lineSampleToWorld(const ossimDpt& image_point, ossimGpt& gpt) const { bool debug = false; // setable via interactive debugger if (traceDebug() || debug) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimSensorModel::lineSampleToWorld:entering..." << std::endl; if(image_point.hasNans()) { gpt.makeNan(); return; } //*** // Extrapolate if image point is outside image: //*** if (!insideImage(image_point)&&(!theExtrapolateImageFlag)) { gpt = extrapolate(image_point); return; } //*** // Determine imaging ray and invoke elevation source object's services to // intersect ray with terrain model: //*** // ossimEcefRay ray; In the case of SAR sensors, ray intersection does not have meaning anymore... // imagingRay(image_point, ray); // ossimElevManager::instance()->intersectRay(ray, gpt); static const double LON_LAT_THRESHOLD = .00001; // acceptable lon lat error (degrees) static const int MAX_NUM_ITERATIONS = 30; static const double LON_LAT_STEP = .00001; int iters = 0; // // Utilize iterative scheme for arriving at ground point. Begin with guess // at RefGndPt: // gpt.lond(theRefGndPt.lond()); gpt.latd(theRefGndPt.latd()); gpt.height(ossimElevManager::instance()->getHeightAboveEllipsoid(gpt)); ossimGpt gpt_dlat; ossimGpt gpt_dlon; ossimDpt ip, ip_dlat, ip_dlon; double du_dlat, du_dlon, dv_dlat, dv_dlon; double delta_lat, delta_lon, delta_u, delta_v; double inverse_norm; bool done = false; //*** // Begin iterations: //*** do { //*** // establish perturbed ground points about the guessed point: //*** gpt_dlat.latd(gpt.latd() + LON_LAT_STEP); gpt_dlat.lond(gpt.lond()); gpt_dlat.height(ossimElevManager::instance()->getHeightAboveEllipsoid(gpt_dlat)); gpt_dlon.latd(gpt.latd()); gpt_dlon.lond(gpt.lond() + LON_LAT_STEP); gpt_dlon.height(ossimElevManager::instance()->getHeightAboveEllipsoid(gpt_dlon)); //*** // Compute numerical partials at current guessed point: //*** worldToLineSample(gpt, ip); worldToLineSample(gpt_dlat, ip_dlat); worldToLineSample(gpt_dlon, ip_dlon); if(ip.hasNans() || ip_dlat.hasNans() || ip_dlon.hasNans()) { gpt.makeNan(); return; } du_dlat = (ip_dlat.u - ip.u) / LON_LAT_STEP; du_dlon = (ip_dlon.u - ip.u) / LON_LAT_STEP; dv_dlat = (ip_dlat.v - ip.v) / LON_LAT_STEP; dv_dlon = (ip_dlon.v - ip.v) / LON_LAT_STEP; // // Test for convergence: // delta_u = image_point.u - ip.u; delta_v = image_point.v - ip.v; // // Compute linearized estimate of ground point given ip delta: // inverse_norm = du_dlon*dv_dlat - dv_dlon*du_dlat; // fg-eh if (!ossim::almostEqual(inverse_norm, 0.0, DBL_EPSILON)) { delta_lon = (delta_u*dv_dlat - delta_v*du_dlat)/inverse_norm; delta_lat = (delta_v*du_dlon - delta_u*dv_dlon)/inverse_norm; gpt.latd(gpt.latd() + delta_lat); gpt.lond(gpt.lond() + delta_lon); gpt.height(ossimElevManager::instance()->getHeightAboveEllipsoid(gpt)); } else { delta_lon = 0; delta_lat = 0; } done = ((fabs(delta_lon) < LON_LAT_THRESHOLD) && (fabs(delta_lat) < LON_LAT_THRESHOLD)); iters++; } while ((!done) && (iters < MAX_NUM_ITERATIONS)); if (traceDebug() || debug) { ossimNotify(ossimNotifyLevel_DEBUG) << "image_point = " << image_point << std::endl; // ossimNotify(ossimNotifyLevel_DEBUG) << "ray = " << ray << std::endl; ossimNotify(ossimNotifyLevel_DEBUG) << "gpt = " << gpt << std::endl; } if (traceDebug() || debug) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimSensorModel::lineSampleToWorld: returning..." << std::endl; return; } void ossimGeometricSarSensorModel::set_platformPosition(PlatformPosition* platformPosition) { if(_platformPosition != 0) { delete _platformPosition; _platformPosition = 0; } _platformPosition = platformPosition->Clone(); } void ossimGeometricSarSensorModel::set_sensorParams(SensorParams* sensorParams) { if(_sensor != 0) { delete _sensor; _sensor = 0; } _sensor = sensorParams->Clone(); } void ossimGeometricSarSensorModel::set_refPoint(RefPoint* refPoint) { if(_refPoint != 0) { delete _refPoint; _refPoint = 0; } _refPoint = refPoint->Clone(); } PlatformPosition* ossimGeometricSarSensorModel::get_platformPosition() const { return _platformPosition; } SensorParams* ossimGeometricSarSensorModel::get_sensorParams() const { return _sensor; } RefPoint* ossimGeometricSarSensorModel::get_refPoint() const { return _refPoint; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimGeometricSarSensorModel.h000066400000000000000000000223471301006202600314700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimGeometricSarSensorModel_H #define ossimGeometricSarSensorModel_H 1 #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #include #include #include #pragma GCC diagnostic pop #else #include #include #include #endif #include #include namespace ossimplugins { class PlatformPosition; class SensorParams; class RefPoint; class SarSensor; class JSDDateTime; /** * @brief This class allows for direct localisation and indirect localisation * using the geometric model of SAR sensors. * This class must be specified for each sensor. */ class OSSIM_PLUGINS_DLL ossimGeometricSarSensorModel : public ossimSensorModel { public: static const char* CREATE_OCG_PREF_KW; using ossimOptimizableProjection::operator=; /** @brief default constructor */ ossimGeometricSarSensorModel(); /** @brief copy constructor */ ossimGeometricSarSensorModel(const ossimGeometricSarSensorModel& rhs); /** @brief Destructor */ virtual ~ossimGeometricSarSensorModel(); // ossimRefPtr thePlatformPosition; // SensorParams* theSensorParams; // SensorParams2 theSensorParams; void finalize(const ossimKeywordlist& /*kwl*/) { // ossimKeywordlist ppKwl; // kwl.extractKeysThatMatch(ppKwl, "orbitList.*"); // size_t ppcount = atoi(ppKwl.find("orbitList.count")); // thePlatformPosition = new PlatformPosition2(ppcount); // thePlatformPosition->loadState(ppKwl, "orbitList."); // // ossimKeywordlist sensorKwl; // kwl.extractKeysThatMatch(sensorKwl, "sensor_params.*"); // theSensorParams = new SensorParams(); // theSensorParams->loadState(sensorKwl, "sensor_params."); } /** * @brief This function associates an image column number to a slant range when the image is georeferenced (ground projected) * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const=0; /** * @brief This function associates an image column number to a slant range * @param col Column coordinate of the image point */ virtual double getSlantRange(double col) const; /** * @brief This function associates an image line number to an azimuth time * @param line Line coordinate of the image point */ virtual JSDDateTime getTime(double line) const; /** * @brief This function associates an image line number to a platform position and speed * @param line Line coordinate of the image point * @param position Position of the sensor at line line * @param speed Speed of the sensor at line line */ virtual bool getPlatformPositionAtLine(double line, vector& position, vector& speed); /** * @brief This function is able to convert image coordinates into world * coordinates the geometric model of SAR sensors. * @param image_point Coordinates of the image point * @param heightEllipsoid Altitude of the world point * @param worldPoint Coordinates of the world point (OUT) */ virtual void lineSampleHeightToWorld(const ossimDpt& image_point, const double& heightEllipsoid, ossimGpt& worldPoint) const; /** * @brief This function optimizes the model according to a list of Ground * Control Points. * * The input list of GCPs is appended to the one present in memory. * An inverse localization of each ground GCP is performed. * The error between localized GCPs and actual image coordinates is then * computed and modeled by a linear model on each dimension. * The time and range estimations are updated accordingly. * * @param groundCoordinates : input GCP ground coordinates * @param imageCoordinates : actual image coordinates corresponding to * input groundCoordinates * */ virtual bool optimizeModel(const std::list & groundCoordinates, const std::list & imageCoordinates) ; /** * @brief Clears _optimizationGCPsGroundCoordinates and * _optimizationGCPsImageCoordinates attributes * Updates the optimisation factors and bias */ virtual void clearGCPlist() ; /** * @brief Returns _optimizationGCPsGroundCoordinates and * _optimizationGCPsImageCoordinates attributes * * @retval groundCoordinates : GCP ground coordinates * @retval imageCoordinates : actual image coordinates corresponding to * groundCoordinates */ virtual void getGCPlist(std::list &groundCoordinates, std::list & imageCoordinates) ; /** * @brief * @return true when it's better (more accurate / fast) to use forward * (from ground to image) than inverse(from image to ground) * @remark This function always return false */ inline virtual bool useForward() const {return false;} /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; /** * @brief Accessors to the optimization parameters. */ double get_optimizationFactorX() const { return _optimizationFactorX; } double get_optimizationFactorY() const { return _optimizationFactorY; } double get_optimizationBiasX() const { return _optimizationBiasX; } double get_optimizationBiasY() const { return _optimizationBiasY; } ossimRefPtr getReplacementOcgModel() { return _replacementOcgModel; } virtual void lineSampleToWorld(const ossimDpt& image_point, ossimGpt& gpt) const; /** * @brief Accessors to the plateform, sensor parameters and reference point. */ void set_platformPosition(PlatformPosition* platformPosition); void set_sensorParams(SensorParams* sensorParams); void set_refPoint(RefPoint* refPoint); PlatformPosition* get_platformPosition() const; SensorParams* get_sensorParams() const; RefPoint* get_refPoint() const; protected: /** * @brief Creates replacement coarse grid model if user requested via ossim preferences * keyword "geometric_sar_sensor_model.create_ocg: " * @return true if load OK, false on error */ bool createReplacementOCG(); /** * @brief Handle the position of the platform */ PlatformPosition *_platformPosition; SensorParams * _sensor; RefPoint * _refPoint; // Note that this is only mutable because of bad design of the // classes, with a bunch of classes initializing the variables of // the base class directly, the 3 variable above must be made // private. mutable SarSensor* _sarSensor; /** * @brief True iff the product is ground range */ bool _isProductGeoreferenced ; /** * @brief List Ground Control Points used by the optimization */ std::list _optimizationGCPsGroundCoordinates ; std::list _optimizationGCPsImageCoordinates ; /** * @brief Optimization result : linear error correction in both dimensions */ double _optimizationFactorX ; double _optimizationFactorY ; double _optimizationBiasX ; double _optimizationBiasY ; ossimFilename _imageFilename; ossimFilename _productXmlFile; ossimRefPtr _replacementOcgModel; private: /** * @brief Initializes the Platform Position from a projection keywordlist */ virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix)=0; /** * @brief Initializes the Sensor Params from a projection keywordlist */ virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix)=0; /** * @brief Initializes the Reference Point from a projection keywordlist */ virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix)=0; /** * @brief Initializes the Slant Range to/for each Ground Range data sets from a projection keywordlist */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix)=0; TYPE_DATA }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimKeyWordListUtilities.h000066400000000000000000000216231301006202600310410ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- #ifndef ossimKeyWordListUtilities_h #define ossimKeyWordListUtilities_h #include "ossimStringUtilities.h" #include "ossimXmlTools.h" #include #include #include #include namespace ossimplugins { class kw_runtime_error : public std::runtime_error { public: explicit kw_runtime_error(std::string const& msg) : std::runtime_error(msg) {} }; class empty_keyword_data : public kw_runtime_error { public: explicit empty_keyword_data(std::string const& keyword) : kw_runtime_error("Data associated to '"+keyword+"' keyword is empty.") {} }; class missing_keyword : public kw_runtime_error { public: explicit missing_keyword(std::string const& keyword) : kw_runtime_error("Cannot find '"+keyword+"' keyword in keyword list.") {} }; inline void addOptional(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, ossimXmlNode const& parentNode, ossimString const& xpath) { ossimRefPtr const& wh = parentNode.findFirstNode(xpath); if (wh.valid()) { ossimString const& value = wh->getText(); kwl.addPair(prefix, key, value, true); } } inline void addOptional(ossimKeywordlist & kwl, std::string const& key, ossimXmlNode const& parentNode, ossimString const& xpath) { ossimRefPtr const& wh = parentNode.findFirstNode(xpath); if (wh.valid()) { ossimString const& value = wh->getText(); kwl.addPair(key, value, true); } } inline ossimString const& addMandatory(ossimKeywordlist & kwl, std::string const& prefix, char const* key, ossimXmlNode const& parentNode, ossimString const& xpath) { ossimXmlNode const& childNode = getExpectedFirstNode(parentNode, xpath); ossimString const& value = childNode.getText(); kwl.addPair(prefix, key, value, true); return value; } inline ossimString const& addMandatory(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, ossimXmlNode const& parentNode, ossimString const& xpath) { ossimXmlNode const& childNode = getExpectedFirstNode(parentNode, xpath); ossimString const& value = childNode.getText(); kwl.addPair(prefix, key, value, true); return value; } inline ossimString const& addMandatory(ossimKeywordlist & kwl, std::string const& prefix, ossimString const& key, ossimXmlNode const& parentNode, ossimString const& xpath) { ossimXmlNode const& childNode = getExpectedFirstNode(parentNode, xpath); ossimString const& value = childNode.getText(); kwl.addPair(prefix, key.string(), value, true); return value; } inline ossimString const& addMandatory(ossimKeywordlist & kwl, std::string const& key, ossimXmlNode const& parentNode, ossimString const& xpath) { ossimXmlNode const& childNode = getExpectedFirstNode(parentNode, xpath); ossimString const& value = childNode.getText(); kwl.addPair(key, value, true); return value; } struct ShallOverwrite { enum type { no, yes}; ShallOverwrite(type o) : m_o(o) {} explicit ShallOverwrite(bool o) : m_o(o ? yes : no) {} bool shall_we() const { return m_o == yes; } private: type m_o; }; inline std::size_t add(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, std::size_t v, ShallOverwrite overwrite = ShallOverwrite::yes) { const ossimString s = ossimString::toString(static_cast(v)); kwl.addPair(prefix, key, s.string(), overwrite.shall_we()); return v; } inline std::size_t add(ossimKeywordlist & kwl, std::string const& key, std::size_t v, ShallOverwrite overwrite = ShallOverwrite::yes) { const ossimString s = ossimString::toString(static_cast(v)); kwl.addPair(key, s.string(), overwrite.shall_we()); return v; } inline std::string const& add(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, std::string const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { kwl.addPair(prefix, key, v, overwrite.shall_we()); return v; } inline std::string const& add(ossimKeywordlist & kwl, std::string const& key, std::string const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { kwl.addPair(key, v, overwrite.shall_we()); return v; } template inline DataType const& add(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, DataType const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { const ossimString s = ossimString::toString(v); kwl.addPair(prefix, key, s.string(), overwrite.shall_we()); return v; } template inline DataType const& add(ossimKeywordlist & kwl, std::string const& key, DataType const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { const ossimString s = ossimString::toString(v); kwl.addPair(key, s.string(), overwrite.shall_we()); return v; } inline ossimString const& add(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, ossimString const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { kwl.addPair(prefix, key, v.string(), overwrite.shall_we()); return v; } inline ossimString const& add(ossimKeywordlist & kwl, std::string const& prefix, ossimString const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { kwl.addPair(prefix, v, overwrite.shall_we()); return v; } inline time::ModifiedJulianDate const& add(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, time::ModifiedJulianDate const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { add(kwl, prefix, key, to_simple_string(v), overwrite); return v; } inline time::ModifiedJulianDate const& add(ossimKeywordlist & kwl, std::string const& key, time::ModifiedJulianDate const& v, ShallOverwrite overwrite = ShallOverwrite::yes) { add(kwl, key, to_simple_string(v), overwrite); return v; } #if defined(USE_BOOST_TIME) inline boost::posix_time::ptime const& add(ossimKeywordlist & kwl, std::string const& key, boost::posix_time::ptime const& v) { add(kwl, key, to_iso_extended_string(v)); return v; } inline boost::posix_time::ptime const& add(ossimKeywordlist & kwl, std::string const& prefix, std::string const& key, boost::posix_time::ptime const& v) { return add(kwl, prefix+key, v); } inline void get(ossimKeywordlist const& kwl, std::string const& key, boost::posix_time::ptime & v) { std::string str = kwl.findKey(key); assert(&str != &ossimKeywordlist::NULL_KW); assert(!str.empty()); std::replace(str.begin(), str.end(), 'T', ' '); v = boost::posix_time::time_from_string(str); } inline void get(ossimKeywordlist const& kwl, std::string const& prefix, std::string const& key, boost::posix_time::ptime & v) { get(kwl, prefix+key, v); } #endif template inline void get(ossimKeywordlist const& kwl, std::string const& key, T & v) { std::string const& str = kwl.findKey(key); if (&str == &ossimKeywordlist::NULL_KW) { throw missing_keyword(key); } if (str.empty()) { throw empty_keyword_data(key); } assert(&str != &ossimKeywordlist::NULL_KW); assert(!str.empty()); v = to(str, " extracting " + key + "from KWL"); } template inline void get(ossimKeywordlist const& kwl, std::string const& prefix, std::string const& key, T & v) { return get(kwl, prefix+key, v); } inline void get(ossimKeywordlist const& kwl, std::string const& key, time::ModifiedJulianDate & v) { std::string const& str = kwl.findKey(key); assert(&str != &ossimKeywordlist::NULL_KW); assert(!str.empty()); v = time::toModifiedJulianDate(str); } inline void get(ossimKeywordlist const& kwl, std::string const& prefix, std::string const& key, time::ModifiedJulianDate & v) { get(kwl, prefix + key, v); } } // ossimplugins namespace #endif // ossimKeyWordListUtilities_h OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimOperatorUtilities.h000066400000000000000000000074421301006202600304170ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimOperatorUtilities_h #define ossimOperatorUtilities_h namespace ossimplugins { // Uses Barton-Nackman trick to help implement operator on classes // Strongly inspired by boost.operators interface // See ossimTimeUtilities.h and ossimTimeUtilitiesTest.cpp for example of // use #define DEFINE_OPERATORS(name, compound, op) \ template struct name ## 1 \ { \ friend T operator op(T lhs, T const& rhs) { \ lhs compound rhs; \ return lhs; \ } \ }; \ template struct name ## 2 \ { \ friend T operator op(T lhs, U const& rhs) { \ lhs compound rhs; \ return lhs; \ } \ friend T operator op(U const& lhs, T rhs) { \ rhs compound lhs; \ return rhs; \ } \ }; \ template struct name : name ## 2 {}; \ template struct name : name ## 1 {}; template struct substractable_asym { friend U operator-(V const& lhs, V const& rhs) { return V::template diff(lhs, rhs); } }; DEFINE_OPERATORS(addable, +=, +); DEFINE_OPERATORS(substractable, -=, -); DEFINE_OPERATORS(multipliable, *=, *); #undef DEFINE_OPERATORS template struct dividable { typedef R scalar_type; friend T operator/(T lhs, scalar_type const& rhs) { lhs /= rhs; return lhs; } friend scalar_type operator/(T const& lhs, T const& rhs) { return ratio_(lhs, rhs); } }; template struct streamable { friend std::ostream & operator<<(std::ostream & os, const T & v) { return v.display(os); } friend std::istream & operator>>(std::istream & is, T & v) { return v.read(is); } }; template struct less_than_comparable { friend bool operator>(T const& lhs, T const& rhs) { return rhs < lhs; } friend bool operator>=(T const& lhs, T const& rhs) { return !(lhs < rhs); } friend bool operator<=(T const& lhs, T const& rhs) { return !(rhs < lhs); } }; template struct equality_comparable { friend bool operator!=(T const& lhs, T const& rhs) { return !(rhs == lhs); } }; }// namespace ossimplugins #endif // ossimOperatorUtilities_h OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPleiadesDimapSupportData.cpp000066400000000000000000002606631301006202600321610ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2012 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Mickael Savinaud (mickael.savinaud@c-s.fr) // // Description: // // Contains declaration of class ossimPleiadesDimapSupportData // //***************************************************************************** #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Define Trace flags for use within this file: static ossimTrace traceExec ("ossimPleiadesDimapSupportData:exec"); static ossimTrace traceDebug ("ossimPleiadesDimapSupportData:debug"); static std::string getVectorFloat64AsString(std::vector in) { std::vector::iterator it; std::stringstream strTmp; for ( it=in.begin() ; it < in.end(); it++ ) { strTmp << " " << (*it); } return strTmp.str(); } static std::string getVectorDoubleAsString(std::vector in) { std::vector::iterator it; std::stringstream strTmp; for ( it=in.begin() ; it < in.end(); it++ ) { strTmp << " " << (*it); } return strTmp.str(); } static std::string getVectorStringAsString(std::vector in) { std::vector::iterator it; std::stringstream strTmp; for ( it=in.begin() ; it < in.end(); it++ ) { strTmp << " " << (*it); } return strTmp.str(); } namespace ossimplugins { static bool readOneXmlNode(ossimRefPtr xmlDocument, ossimString xpath, ossimString& nodeValue) { vector > xml_nodes; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } if (xml_nodes.size() != 1) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << " DEBUG:" << "\nMore than one node value with " << xpath << std::endl; } return false; } nodeValue = xml_nodes[0]->getText(); return true; } ossimPleiadesDimapSupportData::ossimPleiadesDimapSupportData () :ossimErrorStatusInterface(), theDIMAPVersion(OSSIM_PLEIADES_UNKNOWN), theMetadataSubProfile(OSSIM_PLEIADES_METADATA_SUBPROFILE_UNKNOWN), theProductIsOk(false), theRpcIsOk(false), theXmlDocumentRoot(), theSensorID(), theImageID(), theProductionDate(), theAcquisitionDate(), theInstrument(), theInstrumentIndex(), theProcessingLevelString(), theSpectralProcessingString(), theSunAzimuth(), theSunElevation(), theIncidenceAngle(), theViewingAngle(), theAzimuthAngle(), theAlongTrackIncidenceAngle(), theAcrossTrackIncidenceAngle(), theImageSize(0, 0), theTileSize(0, 0), theNumberOfMegaTilesInRow(0), theNumberOfMegaTilesInCol(0), theNumberOfMegaTiles(0), theMultiDataFile(), theNumBands(0), theBandOrder(), thePhysicalBias(), thePhysicalGain(), theSolarIrradiance(), theUlCorner(), theUrCorner(), theLrCorner(), theLlCorner(), theSpecId(), theErrBias(0), theErrBiasX(0), theErrBiasY(0), theErrRand(0), theLineOffset(0), theSampOffset(0), theLatOffset(0), theLonOffset(0), theHeightOffset(0), theLineScale(0), theSampScale(0), theLatScale(0), theLonScale(0), theHeightScale(0), theLineNumCoeff(), theLineDenCoeff(), theSampNumCoeff(), theSampDenCoeff(), theTimeRangeStart(), theTimeRangeEnd(), theLinePeriod(0.0), theSwathFirstCol(0), theSwathLastCol(0), theRefGroundPoint(0.0, 0.0, 0.0), theRefImagePoint(0.0, 0.0) { } ossimPleiadesDimapSupportData::~ossimPleiadesDimapSupportData () { } void ossimPleiadesDimapSupportData::clearFields() { clearErrorStatus(); theDIMAPVersion = OSSIM_PLEIADES_UNKNOWN; theMetadataSubProfile = OSSIM_PLEIADES_METADATA_SUBPROFILE_UNKNOWN; theProductIsOk = false; theRpcIsOk = false; theXmlDocumentRoot = ""; theImageID = ""; theSensorID=""; theProductionDate = ""; theAcquisitionDate = ""; theInstrument = ""; theInstrumentIndex = ""; theProcessingLevelString = ""; theSpectralProcessingString = ""; theSunAzimuth.clear(); theSunElevation.clear(); theIncidenceAngle.clear(); theViewingAngle.clear(); theAzimuthAngle.clear(); theAlongTrackIncidenceAngle.clear(); theAcrossTrackIncidenceAngle.clear(); theImageSize.makeNan(); theTileSize.makeNan(); theNumberOfMegaTilesInRow = 0; theNumberOfMegaTilesInCol = 0; theNumberOfMegaTiles = 0; ossimString msg = ""; theMultiDataFile.setBooleanValue(false, msg); theNumBands = 0; theBandOrder.clear(); thePhysicalBias.clear(); thePhysicalGain.clear(); theSolarIrradiance.clear(); //--- // Corner points: //--- theUlCorner.makeNan(); theUrCorner.makeNan(); theLrCorner.makeNan(); theLlCorner.makeNan(); theRefGroundPoint.makeNan(); theRefImagePoint.makeNan(); //--- // RPC model parameters //--- theErrBias = 0.0; theErrBiasX = 0.0; theErrBiasY = 0.0; theErrRand = 0.0; theLineOffset = 0.0; theSampOffset = 0.0; theLatOffset = 0.0; theLonOffset = 0.0; theHeightOffset = 0.0; theLineScale = 0.0; theSampScale = 0.0; theLatScale = 0.0; theLonScale = 0.0; theHeightScale = 0.0; theLineNumCoeff.clear(); theLineDenCoeff.clear(); theSampNumCoeff.clear(); theSampDenCoeff.clear(); theSpecId = ""; theTimeRangeStart = ""; theTimeRangeEnd = ""; theLinePeriod = 0.0; theSwathFirstCol = 0; theSwathLastCol = 0; } void ossimPleiadesDimapSupportData::printInfo(ostream& os) const { os << "\n----------------- Info on Pleiades Image -------------------" << "\n " << "\n Job Number (ID): " << theImageID << "\n Acquisition Date: " << theAcquisitionDate << "\n Instrument: " << theInstrument << "\n Instrument Index: " << theInstrumentIndex << "\n Production Date: " << theProductionDate << "\n Processing Level: " << theProcessingLevelString << "\n Spectral Processing: " << theSpectralProcessingString << "\n Number of Bands: " << theNumBands << "\n Bands Display Order: " << getVectorStringAsString(theBandOrder) << "\n Image Size: " << theImageSize << "\n Tile Size: " << theTileSize << "\n Number Of Tiles (Row, Col): " << theNumberOfMegaTiles << " (" << theNumberOfMegaTilesInRow << ", " << theNumberOfMegaTilesInCol << ")" << "\n Incidence Angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theIncidenceAngle) << "\n Viewing Angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theViewingAngle) << "\n Azimuth Angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theAzimuthAngle) << "\n Along track incidence angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theAlongTrackIncidenceAngle) << "\n Across track incidence angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theAcrossTrackIncidenceAngle) << "\n Sun Azimuth (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theSunAzimuth) << "\n Sun Elevation (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theSunElevation) << "\n Physical Bias (for each band): " << getVectorFloat64AsString(thePhysicalBias) << "\n Physical Gain (for each band): " << getVectorFloat64AsString(thePhysicalGain) << "\n Solar Irradiance (for each band): " << getVectorFloat64AsString(theSolarIrradiance) << "\n Geo Center Point: " << theRefGroundPoint // TODO add RefImagePoint if necessary << "\n Corner Points:" << "\n UL: " << theUlCorner << "\n UR: " << theUrCorner << "\n LR: " << theLrCorner << "\n LL: " << theLlCorner << "\n" << "\n RPC model parameters:" << "\n RPC ID: " << theSpecId << "\n SampNumCoeff: " << getVectorDoubleAsString(theSampNumCoeff) << "\n SampDenCoeff: " << getVectorDoubleAsString(theSampDenCoeff) << "\n LineNumCoeff: " << getVectorDoubleAsString(theLineNumCoeff) << "\n LineDenCoeff: " << getVectorDoubleAsString(theLineDenCoeff) << "\n LonScale: " << theLonScale << "\n LonOffset: " << theLonOffset << "\n LatScale: " << theLatScale << "\n LonScale: " << theLonScale << "\n HeightScale: " << theHeightScale << "\n HeightOffset: " << theHeightOffset << "\n SampScale: " << theSampScale << "\n SampOffset: " << theSampOffset << "\n LineScale: " << theLineScale << "\n LineOffset: " << theLineOffset << "\n theErrBias: " << theErrBias << "\n theErrBiasX: " << theErrBiasX << "\n theErrBiasY: " << theErrBiasY << "\n theErrRand: " << theErrRand << "\n" << "\n Acquisition time parameters (only valid for SENSOR product):" << "\n TimeRangeStart: "<< theTimeRangeStart << "\n TimeRangeEnd: "<< theTimeRangeEnd << "\n LinePeriod: "<< theLinePeriod << "\n SwathFirstCol: "<< theSwathFirstCol << "\n SwathLastCol: "<< theSwathLastCol << "\n" << "\n---------------------------------------------------------" << "\n " << std::endl; } bool ossimPleiadesDimapSupportData::parseXmlFile(const ossimFilename& file) { static const char MODULE[] = "ossimPleiadesDimapSupportData::parseXmlFile"; //traceDebug.setTraceFlag(true); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nFile: " << file << std::endl; } if (allMetadataRead()) clearFields(); //--- // Instantiate the file reading: //--- ossim_int64 fileSize = file.fileSize(); std::ifstream in(file.c_str(), std::ios::binary|std::ios::in); std::vector fullBuffer; ossimString bufferedIo; if(in.good()&&(fileSize > 0)) { char buf[100]; fullBuffer.resize(fileSize); in.read(buf, std::min((ossim_int64)100, fileSize)); if(!in.fail()) { ossimString testString = ossimString(buf, buf + in.gcount()); if(testString.contains("xml")) { in.seekg(0); in.read(&fullBuffer.front(), (std::streamsize)fullBuffer.size()); if(!in.fail()) { bufferedIo = ossimString(fullBuffer.begin(), fullBuffer.begin()+in.gcount()); } } } } else { return false; } //--- // Instantiate the XML parser: //--- ossimRefPtr xmlDocument; if(bufferedIo.empty()) { xmlDocument = new ossimXmlDocument(file); } else { xmlDocument = new ossimXmlDocument; std::istringstream inStringStream(bufferedIo.string()); if(!xmlDocument->read(inStringStream)) { return false; } } if (xmlDocument->getErrorStatus()) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nUnable to parse xml file" << std::endl; } setErrorStatus(); return false; } if (!parseMetadataIdentificationDIMAPv2(xmlDocument) && !parseMetadataIdentificationDIMAPv1(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseMetadataIdentification failed. Returning false" << std::endl; } return false; } if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1 || theMetadataSubProfile == OSSIM_PLEIADES_METADATA_SUBPROFILE_PRODUCT) { if (theProductIsOk) clearFields(); if (!parseDatasetIdentification(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseDatasetdentification failed. Returning false" << std::endl; } return false; } if (!parseDatasetContent(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseDatasetContent failed. Returning false" << std::endl; return false; } if (!parseProductInformation(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseProductInformation failed. Returning false" << std::endl; } return false; } if (!parseCoordinateReferenceSystem(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseCoordinateReferenceSystem failed. Returning false" << std::endl; } return false; } if (!parseGeoposition(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseGeoposition failed. Returning false" << std::endl; } return false; } if (!parseProcessingInformation(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseProcessingInformation failed. Returning false" << std::endl; } return false; } if (!parseRasterData(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseRasterData failed. Returning false" << std::endl; } return false; } if (!parseRadiometricData(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseRadiometricData failed. Returning false" << std::endl; return false; } if (!parseGeometricData(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseGeometricData failed. Returning false" << std::endl; return false; } if (!parseQualityAssessment(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseQualityAssessment failed. Returning false" << std::endl; return false; } if (!parseDatasetSources(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseDatasetSources failed. Returning false" << std::endl; return false; } theProductIsOk = true; } if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1 || theMetadataSubProfile == OSSIM_PLEIADES_METADATA_SUBPROFILE_RPC) { // Parse RPC file if (theProcessingLevelString == "SENSOR") { if (parseRPCMetadata(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimPleiadesDimapSupportData::parseXmlFile:" << "\nparseRPCMetadata initialization failed. Returning false" << std::endl; return false; } theRpcIsOk = true; } else theRpcIsOk = true; } if (theProcessingLevelString != "SENSOR") theRpcIsOk = true; if (traceDebug() && allMetadataRead()) { printInfo(ossimNotify(ossimNotifyLevel_DEBUG)); ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: exited..." << std::endl; } return true; } ossimString ossimPleiadesDimapSupportData::getProcessingLevel() const { return theProcessingLevelString; } ossimString ossimPleiadesDimapSupportData::getSensorID() const { return theSensorID; } ossimString ossimPleiadesDimapSupportData::getAcquisitionDate() const { return theAcquisitionDate; } ossimString ossimPleiadesDimapSupportData::getProductionDate() const { return theProductionDate; } ossimString ossimPleiadesDimapSupportData::getImageID() const { return theImageID; } ossimString ossimPleiadesDimapSupportData::getInstrument() const { return theInstrument; } ossimString ossimPleiadesDimapSupportData::getInstrumentIndex() const { return theInstrumentIndex; } void ossimPleiadesDimapSupportData::getSunAzimuth(std::vector& az) const { az = theSunAzimuth; } void ossimPleiadesDimapSupportData::getSunElevation(std::vector& el) const { el = theSunElevation; } void ossimPleiadesDimapSupportData::getImageSize(ossimIpt& sz) const { sz = theImageSize; } ossim_uint32 ossimPleiadesDimapSupportData::getNumberOfBands() const { return theNumBands; } void ossimPleiadesDimapSupportData::getIncidenceAngle(std::vector& ia) const { ia = theIncidenceAngle; } void ossimPleiadesDimapSupportData::getViewingAngle(std::vector& va) const { va = theViewingAngle; } void ossimPleiadesDimapSupportData::getAcrossTrackIncidenceAngle(std::vector& act) const { act = theAcrossTrackIncidenceAngle; } void ossimPleiadesDimapSupportData::getAlongTrackIncidenceAngle(std::vector& alt) const { alt = theAlongTrackIncidenceAngle; } void ossimPleiadesDimapSupportData::getRefGroundPoint(ossimGpt& gp) const { gp = theRefGroundPoint; } void ossimPleiadesDimapSupportData::getRefImagePoint(ossimDpt& rp) const { rp = theRefImagePoint; } void ossimPleiadesDimapSupportData::getUlCorner(ossimGpt& pt) const { pt = theUlCorner; } void ossimPleiadesDimapSupportData::getUrCorner(ossimGpt& pt) const { pt = theUrCorner; } void ossimPleiadesDimapSupportData::getLrCorner(ossimGpt& pt) const { pt = theLrCorner; } void ossimPleiadesDimapSupportData::getLlCorner(ossimGpt& pt) const { pt = theLlCorner; } void ossimPleiadesDimapSupportData::getImageRect(ossimDrect& rect)const { rect = ossimDrect(0.0, 0.0, theImageSize.x-1.0, theImageSize.y-1.0); } bool ossimPleiadesDimapSupportData::saveState(ossimKeywordlist& kwl, const char* prefix)const { ossimString tempString; ossim_uint32 idx = 0; kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimPleiadesDimapSupportData", true); tempString = ""; for(idx = 0; idx < theSunAzimuth.size(); ++idx) { tempString += (ossimString::toString(theSunAzimuth[idx]) + " "); } kwl.add(prefix, ossimKeywordNames::AZIMUTH_ANGLE_KW, tempString, true); kwl.add(prefix, "number_of_azimuth_angle", static_cast(theSunAzimuth.size()), true); tempString = ""; for(idx = 0; idx < theSunElevation.size(); ++idx) { tempString += (ossimString::toString(theSunElevation[idx]) + " "); } kwl.add(prefix, ossimKeywordNames::ELEVATION_ANGLE_KW, tempString, true); kwl.add(prefix, "number_of_elevation_angle", static_cast(theSunElevation.size()), true); //--- // Note: since this is a new keyword, use the point.toString as there is // no backwards compatibility issues. //--- kwl.add(prefix, "image_size", ossimString::toString(theImageSize.x) + " " + ossimString::toString(theImageSize.y), true); kwl.add(prefix, "reference_ground_point", ossimString::toString(theRefGroundPoint.latd()) + " " + ossimString::toString(theRefGroundPoint.lond()) + " " + ossimString::toString(theRefGroundPoint.height()) + " " + theRefGroundPoint.datum()->code(), true); kwl.add(prefix, "reference_image_point", ossimString::toString(theRefImagePoint.x) + " " + ossimString::toString(theRefImagePoint.y), true); kwl.add(prefix, ossimKeywordNames::NUMBER_BANDS_KW, theNumBands, true); tempString = ""; for(idx = 0; idx < theBandOrder.size(); ++idx) { tempString += (theBandOrder[idx] + " "); } kwl.add(prefix, "band_name_list", tempString, true); kwl.add(prefix, "image_id", theImageID, true); kwl.add(prefix, "processing_level", theProcessingLevelString, true); kwl.add(prefix, "instrument", theInstrument, true); kwl.add(prefix, "instrument_index", theInstrumentIndex, true); kwl.add(prefix, ossimKeywordNames::IMAGE_DATE_KW, theAcquisitionDate, true); kwl.add(prefix, "production_date", theProductionDate, true); tempString = ""; for(idx = 0; idx < theIncidenceAngle.size(); ++idx) { tempString += (ossimString::toString(theIncidenceAngle[idx]) + " "); } kwl.add(prefix, "incident_angle", tempString, true); kwl.add(prefix, "number_of_incident_angle", static_cast(theIncidenceAngle.size()), true); tempString = ""; for(idx = 0; idx < theViewingAngle.size(); ++idx) { tempString += (ossimString::toString(theViewingAngle[idx]) + " "); } kwl.add(prefix, "viewing_angle", tempString, true); kwl.add(prefix, "number_of_viewing_angle", static_cast(theViewingAngle.size()), true); tempString = ""; for(idx = 0; idx < theAzimuthAngle.size(); ++idx) { tempString += (ossimString::toString(theAzimuthAngle[idx]) + " "); } kwl.add(prefix, "scene_orientation", tempString, true); kwl.add(prefix, "number_of_scene_orientation", static_cast(theAzimuthAngle.size()), true); tempString = ""; for(idx = 0; idx < theAlongTrackIncidenceAngle.size(); ++idx) { tempString += (ossimString::toString(theAlongTrackIncidenceAngle[idx]) + " "); } kwl.add(prefix, "along_track_incidence_angle", tempString, true); kwl.add(prefix, "number_of_along_track_incidence_angle", static_cast(theAlongTrackIncidenceAngle.size()), true); tempString = ""; for(idx = 0; idx < theAcrossTrackIncidenceAngle.size(); ++idx) { tempString += (ossimString::toString(theAcrossTrackIncidenceAngle[idx]) + " "); } kwl.add(prefix, "across_track_incidence_angle", tempString, true); kwl.add(prefix, "number_of_across_track_incidence_angle", static_cast(theAcrossTrackIncidenceAngle.size()), true); kwl.add(prefix, "ul_ground_point", ossimString::toString(theUlCorner.latd()) + " " + ossimString::toString(theUlCorner.lond()) + " " + ossimString::toString(theUlCorner.height()) + " " + theUlCorner.datum()->code(), true); kwl.add(prefix, "ur_ground_point", ossimString::toString(theUrCorner.latd()) + " " + ossimString::toString(theUrCorner.lond()) + " " + ossimString::toString(theUrCorner.height()) + " " + theUrCorner.datum()->code(), true); kwl.add(prefix, "lr_ground_point", ossimString::toString(theLrCorner.latd()) + " " + ossimString::toString(theLrCorner.lond()) + " " + ossimString::toString(theLrCorner.height()) + " " + theLrCorner.datum()->code(), true); kwl.add(prefix, "ll_ground_point", ossimString::toString(theLlCorner.latd()) + " " + ossimString::toString(theLlCorner.lond()) + " " + ossimString::toString(theLlCorner.height()) + " " + theLlCorner.datum()->code(), true); kwl.add(prefix, "sensorID", theSensorID, true); tempString = ""; for(idx = 0; idx < thePhysicalBias.size(); ++idx) { tempString += (ossimString::toString(thePhysicalBias[idx]) + " "); } kwl.add(prefix, "physical_bias", tempString, true); tempString = ""; for(idx = 0; idx < thePhysicalGain.size(); ++idx) { tempString += (ossimString::toString(thePhysicalGain[idx]) + " "); } kwl.add(prefix, "physical_gain", tempString, true); tempString = ""; for(idx = 0; idx < theSolarIrradiance.size(); ++idx) { tempString += (ossimString::toString(theSolarIrradiance[idx]) + " "); } kwl.add(prefix, "solar_irradiance", tempString, true); // Some geometric parameters exist only in the case of a SENSOR image if (theProcessingLevelString == "SENSOR") { kwl.add(prefix, "time_range_start", theTimeRangeStart, true); kwl.add(prefix, "time_range_end", theTimeRangeEnd, true); kwl.add(prefix, "line_period", ossimString::toString(theLinePeriod), true); kwl.add(prefix, "swath_first_col", theSwathFirstCol, true); kwl.add(prefix, "swath_last_col", theSwathLastCol, true); } return true; } bool ossimPleiadesDimapSupportData::loadState(const ossimKeywordlist& kwl, const char* prefix) { ossim_uint32 idx = 0; ossim_uint32 total; ossimString tempString; clearFields(); ossimString type = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if(type != "ossimPleiadesDimapSupportData") { return false; } total = ossimString(kwl.find(prefix,"number_of_azimuth_angle")).toUInt32(); theSunAzimuth.resize(total); tempString = kwl.find(prefix,ossimKeywordNames::AZIMUTH_ANGLE_KW); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theSunAzimuth.size();++idx) { in >> tempValue.string(); theSunAzimuth[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_elevation_angle")).toUInt32(); theSunElevation.resize(total); tempString = kwl.find(prefix,ossimKeywordNames::ELEVATION_ANGLE_KW); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theSunElevation.size();++idx) { in >> tempValue.string(); theSunElevation[idx] = tempValue.toDouble(); } } // const char* lookup; theImageSize = createIpt(kwl.find(prefix, "image_size")); theRefGroundPoint = createGround(kwl.find(prefix, "reference_ground_point")); theRefImagePoint = createDpt(kwl.find(prefix, "reference_image_point")); theNumBands = ossimString(kwl.find(prefix, ossimKeywordNames::NUMBER_BANDS_KW)).toUInt32(); theBandOrder.resize(theNumBands); tempString = kwl.find(prefix,"band_name_list"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theBandOrder.size();++idx) { in >> tempValue.string(); theBandOrder[idx] = tempValue; } } theAcquisitionDate = kwl.find(prefix, ossimKeywordNames::IMAGE_DATE_KW); theProductionDate = kwl.find(prefix, "production_date"); theImageID = kwl.find(prefix, "image_id"); theInstrument = kwl.find(prefix, "instrument"); theInstrumentIndex = kwl.find(prefix, "instrument_index"); total = ossimString(kwl.find(prefix,"number_of_incident_angle")).toUInt32(); theIncidenceAngle.resize(total); tempString = kwl.find(prefix,"incident_angle"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theIncidenceAngle.size();++idx) { in >> tempValue.string(); theIncidenceAngle[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_viewing_angle")).toUInt32(); theViewingAngle.resize(total); tempString = kwl.find(prefix,"viewing_angle"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theViewingAngle.size();++idx) { in >> tempValue.string(); theViewingAngle[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_scene_orientation")).toUInt32(); theAzimuthAngle.resize(total); tempString = kwl.find(prefix,"scene_orientation"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theAzimuthAngle.size();++idx) { in >> tempValue.string(); theAzimuthAngle[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_along_track_incidence_angle")).toUInt32(); theAlongTrackIncidenceAngle.resize(total); tempString = kwl.find(prefix,"along_track_incidence_angle"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theAlongTrackIncidenceAngle.size();++idx) { in >> tempValue.string(); theAlongTrackIncidenceAngle[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_across_track_incidence_angle")).toUInt32(); theAcrossTrackIncidenceAngle.resize(total); tempString = kwl.find(prefix,"across_track_incidence_angle"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theAcrossTrackIncidenceAngle.size();++idx) { in >> tempValue.string(); theAcrossTrackIncidenceAngle[idx] = tempValue.toDouble(); } } theUlCorner =createGround( kwl.find(prefix, "ul_ground_point")); theUrCorner =createGround( kwl.find(prefix, "ur_ground_point")); theLrCorner =createGround( kwl.find(prefix, "lr_ground_point")); theLlCorner =createGround( kwl.find(prefix, "ll_ground_point")); theSensorID = ossimString(kwl.find(prefix, "sensorID")); theProcessingLevelString = ossimString(kwl.find(prefix, "processing_level")); thePhysicalBias.resize(theNumBands); tempString = kwl.find(prefix,"physical_bias"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < thePhysicalBias.size();++idx) { in >> tempValue.string(); thePhysicalBias[idx] = tempValue.toDouble(); } } thePhysicalGain.resize(theNumBands); tempString = kwl.find(prefix,"physical_gain"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < thePhysicalGain.size();++idx) { in >> tempValue.string(); thePhysicalGain[idx] = tempValue.toDouble(); } } theSolarIrradiance.resize(theNumBands); tempString = kwl.find(prefix,"solar_irradiance"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theSolarIrradiance.size();++idx) { in >> tempValue.string(); theSolarIrradiance[idx] = tempValue.toDouble(); } } // Some geometric parameters exist only in the case of a SENSOR image if (theProcessingLevelString == "SENSOR") { theTimeRangeStart = ossimString(kwl.find(prefix,"time_range_start")); theTimeRangeEnd = ossimString(kwl.find(prefix,"time_range_end")); theLinePeriod = ossimString(kwl.find(prefix,"line_period")).toDouble(); theSwathFirstCol = ossimString(kwl.find(prefix,"swath_first_col")).toInt32(); theSwathLastCol = ossimString(kwl.find(prefix,"swath_last_col")).toInt32(); } return true; } ossimGpt ossimPleiadesDimapSupportData::createGround(const ossimString& s)const { std::istringstream in(s.string()); ossimString lat, lon, height; ossimString code; in >> lat.string() >> lon.string() >> height.string() >> code.string(); return ossimGpt(lat.toDouble(), lon.toDouble(), height.toDouble(), ossimDatumFactory::instance()->create(code)); } ossimDpt ossimPleiadesDimapSupportData::createDpt(const ossimString& s)const { std::istringstream in(s.string()); ossimString x, y; ossimString code; in >> x.string() >> y.string(); return ossimDpt(x.toDouble(), y.toDouble()); } ossimIpt ossimPleiadesDimapSupportData::createIpt(const ossimString& s)const { std::istringstream in(s.string()); ossimString x, y; ossimString code; in >> x.string() >> y.string(); return ossimIpt(x.toInt(), y.toInt()); } bool ossimPleiadesDimapSupportData::parseProductInformation( ossimRefPtr xmlDocument) { ossimString xpath; vector > xml_nodes; //--- // Fetch the Image ID: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Production/JOB_ID"; } else { xpath = "/Product_Information/Delivery_Identification/JOB_ID"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theImageID)) { return false; } //--- // Fetch the ProductionDate: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Production/DATASET_PRODUCTION_DATE"; } else { xpath = "/Product_Information/Delivery_Identification/PRODUCTION_DATE"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theProductionDate)) { return false; } return true; } bool ossimPleiadesDimapSupportData::parseDatasetContent( ossimRefPtr xmlDocument) { ossimString xpath, nodeValue; vector > xml_nodes; //--- // Corner points: //--- xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Frame/Dataset_Frame/Vertex"; } else { xpath = "/Dataset_Content/Dataset_Extent/Vertex"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() != 4) { setErrorStatus(); return false; } std::vector >::iterator node = xml_nodes.begin(); while (node != xml_nodes.end()) { ossimGpt gpt; ossimDpt ipt; std::vector > sub_nodes; xpath = "LAT"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lat = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "LON"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lon = sub_nodes[0]->getText().toDouble(); gpt.hgt = 0.0; // assumed sub_nodes.clear(); xpath = "ROW"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.line = sub_nodes[0]->getText().toDouble() - 1.0; sub_nodes.clear(); xpath = "COL"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.samp = sub_nodes[0]->getText().toDouble() - 1.0; if (ipt.line < 1.0) if (ipt.samp < 1.0) theUlCorner = gpt; else theUrCorner = gpt; else if (ipt.samp < 1.0) theLlCorner = gpt; else theLrCorner = gpt; ++node; } //--- // Center of frame. //--- theRefGroundPoint.hgt = 0.0; // TODO needs to be looked up if (!readOneXmlNode(xmlDocument, theXmlDocumentRoot + "/Product_Frame/Dataset_Frame/Center/LON", // DIMAPv1 nodeValue)) { if (!readOneXmlNode(xmlDocument, theXmlDocumentRoot + "/Dataset_Content/Dataset_Extent/Center/LON", // DIMAPv2 nodeValue)) { return false; } } theRefGroundPoint.lon = nodeValue.toDouble(); if (!readOneXmlNode(xmlDocument, theXmlDocumentRoot + "/Dataset_Content/Dataset_Extent/Center/LAT", nodeValue)) { if (!readOneXmlNode(xmlDocument, theXmlDocumentRoot + "/Product_Frame/Dataset_Frame/Center/LAT", nodeValue)) { return false; } } theRefGroundPoint.lat = nodeValue.toDouble(); return true; } bool ossimPleiadesDimapSupportData::parseRadiometricData( ossimRefPtr xmlDocument) { ossimString xpath; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; //--- // Fetch the gain and bias for each spectral band: //--- thePhysicalGain.assign(theNumBands, 1.000); thePhysicalBias.assign(theNumBands, 0.000); xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Image_Interpretation/Spectral_Band_Info"; } else { xpath = "/Radiometric_Data/Radiometric_Calibration/Instrument_Calibration/Band_Measurement_List/Band_Radiance"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "BAND_ID"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ossimString bandName = sub_nodes[0]->getText(); ossim_uint32 bandIndex = 99999; // Bogus index... if ( (bandName == "B0") || (bandName == "P") || (bandName == "PA") || (theNumBands == 1) ) { bandIndex = 0; } else if ( (bandName == "B1") && (theNumBands > 1) ) { bandIndex = 1; } else if ( (bandName == "B2") && (theNumBands > 2) ) { bandIndex = 2; } else if ( (bandName == "B3") && (theNumBands > 3) ) { bandIndex = 3; } else { ossimNotify(ossimNotifyLevel_WARN) << "ossimPleiadesDimapSupportData::parseRadiometricMetadata ERROR: Band ID is incorrect\n"; } if (bandIndex >= theNumBands ) { ossimNotify(ossimNotifyLevel_WARN) << "ossimPleiadesDimapSupportData::parseRadiometricMetadata ERROR: Band index outside of range\n"; return false; } sub_nodes.clear(); xpath = (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1 ? "PHYSICAL_BIAS" : "BIAS"); (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePhysicalBias[bandIndex] = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1 ? "PHYSICAL_GAIN" : "GAIN"); (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePhysicalGain[bandIndex] = sub_nodes[0]->getText().toDouble(); ++node; } // Initialize to 999 : we find this value in some DIMAPv2 file // and there is no such tag in DIMAPv1 file theSolarIrradiance.assign(theNumBands, 999.000); xml_nodes.clear(); xpath = "/Radiometric_Data/Radiometric_Calibration/Instrument_Calibration/Band_Measurement_List/Band_Solar_Irradiance"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "BAND_ID"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ossimString bandName = sub_nodes[0]->getText(); ossim_uint32 bandIndex = 99999; // Bogus index... if ( (bandName == "B0") || (bandName == "P") || (bandName == "PA") || (theNumBands == 1) ) { bandIndex = 0; } else if ( (bandName == "B1") && (theNumBands > 1) ) { bandIndex = 1; } else if ( (bandName == "B2") && (theNumBands > 2) ) { bandIndex = 2; } else if ( (bandName == "B3") && (theNumBands > 3) ) { bandIndex = 3; } else { ossimNotify(ossimNotifyLevel_WARN) << "ossimPleiadesDimapSupportData::parseRadiometricMetadata ERROR: Band ID is incorrect\n"; } if ((bandIndex >= theNumBands)) { ossimNotify(ossimNotifyLevel_WARN) << "ossimPleiadesDimapSupportData::parseRadiometricMetadata ERROR: Band index outside of range 2\n"; return false; } sub_nodes.clear(); xpath = "VALUE"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } theSolarIrradiance[bandIndex] = sub_nodes[0]->getText().toDouble(); ++node; } return true; } bool ossimPleiadesDimapSupportData::parseRPCMetadata( ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimPleiadesDimapSupportData::parseRPCMetadata"; ossimString xpath, nodeValue; vector > xml_nodes; //--- // Fetch the Global RFM - Direct Model - Bias: //--- // RESOURCE_ID does not exists in DIMAPv1 file if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv2) { xpath = "/Rational_Function_Model/Resource_Reference/RESOURCE_ID"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Could not find: " << xpath << std::endl; return false; } theSpecId = nodeValue; } //--- // Fetch the Global RFM - Inverse Model: //--- xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/Inverse_Model"; } else { xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.empty()) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Could not find: " << xpath << std::endl; } return false; } if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { std::vector coeffs; xml_nodes.clear(); xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/Inverse_Model/F_ROW"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); coeffs = xml_nodes[0]->getText().split(" ", true); const size_t nRow = coeffs.size() / 2; for (size_t i = 0; i < nRow; i++) { theLineNumCoeff.push_back(coeffs[i].toDouble()); theLineDenCoeff.push_back(coeffs[i + nRow].toDouble()); } xml_nodes.clear(); xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/Inverse_Model/F_COL"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); coeffs = xml_nodes[0]->getText().split(" ", true); const size_t nCol = coeffs.size() / 2; for (size_t i = 0; i < nCol; i++) { theSampNumCoeff.push_back(coeffs[i].toDouble()); theSampDenCoeff.push_back(coeffs[i + nCol].toDouble()); } } else { for (ossim_uint32 it = 1; it < 21; it ++) { std::ostringstream valueStr; valueStr << it; xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/LINE_NUM_COEFF_"; xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theLineNumCoeff.push_back(xml_nodes[0]->getText().toDouble()); xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/LINE_DEN_COEFF_"; xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theLineDenCoeff.push_back(xml_nodes[0]->getText().toDouble()); xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/SAMP_NUM_COEFF_"; xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theSampNumCoeff.push_back(xml_nodes[0]->getText().toDouble()); xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/SAMP_DEN_COEFF_"; xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theSampDenCoeff.push_back(xml_nodes[0]->getText().toDouble()); } } //--- // Fetch the Global RFM - Inverse Model - Bias: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/Inverse_Model/MODEL_PRECISION_ROW"; } else { xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/ERR_BIAS_ROW"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theErrBiasX = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/Inverse_Model/MODEL_PRECISION_COL"; } else { xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/ERR_BIAS_COL"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theErrBiasY = nodeValue.toDouble(); //--- // Fetch the Global RFM validity parameters : //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Lon/A"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LONG_SCALE"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLonScale = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Lon/B"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LONG_OFF"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLonOffset = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Lat/A"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LAT_SCALE"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLatScale = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Lat/B"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LAT_OFF"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLatOffset = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Alt/A"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/HEIGHT_SCALE"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theHeightScale = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Alt/B"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/HEIGHT_OFF"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theHeightOffset = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Col/A"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/SAMP_SCALE"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theSampScale = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Col/B"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/SAMP_OFF"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } // Pleiades metadata assume that the coordinate of the center of // the upper-left pixel is (1,1), so we remove 1 to get back to // OSSIM convention. theSampOffset = nodeValue.toDouble()-1; if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Row/A"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LINE_SCALE"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLineScale = nodeValue.toDouble(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geoposition/Rational_Sensor_Model/Global_RFM/RFM_Validity/Row/B"; } else { xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LINE_OFF"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } // Pleiades metadata assume that the coordinate of the center of // the upper-left pixel is (1,1), so we remove 1 to get back to // OSSIM convention. theLineOffset = nodeValue.toDouble()-1; return true; } bool ossimPleiadesDimapSupportData::parseMetadataIdentificationDIMAPv1(ossimRefPtr xmlDocument) { // static const char MODULE[] = "ossimPleiadesDimapSupportData::parseMetadataIdentification"; vector > xml_nodes; ossimString xpath, nodeValue; theXmlDocumentRoot = "/PHR_Dimap_Document"; //--- // Get the version string which can be used as a key for parsing. //--- xml_nodes.clear(); xpath = "/Metadata_Identification/METADATA_FORMAT"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } if (nodeValue != "DIMAP_PHR") { return false; } //--- // Check that it is a valid PHR DIMAPv2 file //--- xpath = "/Metadata_Identification/METADATA_PROFILE"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } ossimString metadataProfile; if ( nodeValue != "PHR_SYSTEM_RECTIFIED_PRODUCT" ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n Not a PLEIADES DIMAPv1 file: METADATA_PROFILE is incorrect!" << std::endl; } return false; } // DIMAPv1 -> no subprofile theMetadataSubProfile = OSSIM_PLEIADES_METADATA_SUBPROFILE_UNKNOWN; theDIMAPVersion = OSSIM_PLEIADES_DIMAPv1; return true; } bool ossimPleiadesDimapSupportData::parseMetadataIdentificationDIMAPv2(ossimRefPtr xmlDocument) { // static const char MODULE[] = "ossimPleiadesDimapSupportData::parseMetadataIdentification"; vector > xml_nodes; ossimString xpath, nodeValue; theXmlDocumentRoot = "/DIMAP_Document"; //--- // Get the version string which can be used as a key for parsing. //--- xml_nodes.clear(); xpath = "/Metadata_Identification/METADATA_FORMAT"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { // FIXME MSD: used to support Pleiades samples from SPOT-IMAGES website which are not coherent // with the specification (28/09/2012). Should be remove when first data will be available and sample // replaced. theXmlDocumentRoot = "/PHR_DIMAP_Document"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nTry to use the old root: " << theXmlDocumentRoot << endl; } xml_nodes.clear(); xpath = "/Metadata_Identification/METADATA_FORMAT"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { // FIXME MSD: used to support peiades samples from SPOT-IMAGES website which are not coherent // with the specification (28/09/2012). Should be remove when first data will be available and sample // replaced. theXmlDocumentRoot = "/Dimap_Document"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nTry to use the new root: " << theXmlDocumentRoot << endl; } xml_nodes.clear(); xpath = "/Metadata_Identification/METADATA_FORMAT"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << endl; } return false; } } } ossimString attribute = "version"; ossimString value; xml_nodes[0]->getAttributeValue(value, attribute); if (value != "2.0") { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "WARNING: DIMAP metadata version is not correct!" << std::endl; } return false; } //--- // Check that it is a valid PHR DIMAPv2 file //--- xpath = "/Metadata_Identification/METADATA_PROFILE"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } ossimString metadataProfile; if ( (nodeValue != "PHR_SENSOR") && (nodeValue != "PHR_ORTHO") && (nodeValue != "PHR_MOSAIC") ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n Not a PLEIADES DIMAPv2 file: metadata profile is incorrect!" << std::endl; } return false; } else metadataProfile = nodeValue; //--- // Get the subprofile //--- xpath = "/Metadata_Identification/METADATA_SUBPROFILE"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } if ((nodeValue == "PRODUCT")) theMetadataSubProfile = OSSIM_PLEIADES_METADATA_SUBPROFILE_PRODUCT; else if ( (nodeValue == "RPC") && (metadataProfile == "PHR_SENSOR") ) theMetadataSubProfile = OSSIM_PLEIADES_METADATA_SUBPROFILE_RPC; else { theMetadataSubProfile = OSSIM_PLEIADES_METADATA_SUBPROFILE_UNKNOWN; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n Not a PLEIADES DIMAPv2 file: metadata subprofile is incorrect !" << std::endl; } return false; } theDIMAPVersion = OSSIM_PLEIADES_DIMAPv2; return true; } bool ossimPleiadesDimapSupportData::parseDatasetIdentification(ossimRefPtr /* xmlDocument */ ) { return true; } bool ossimPleiadesDimapSupportData::parseCoordinateReferenceSystem(ossimRefPtr /* xmlDocument */ ) { return true; } bool ossimPleiadesDimapSupportData::parseGeoposition(ossimRefPtr /* xmlDocument */ ) { return true; } bool ossimPleiadesDimapSupportData::parseProcessingInformation(ossimRefPtr xmlDocument) { // static const char MODULE[] = "ossimPleiadesDimapSupportData::parseProcessingInformation"; vector > xml_nodes; ossimString xpath, nodeValue; //--- // Fetch the Processing Level: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Characteristics/PROCESSING_LEVEL"; } else { xpath = "/Processing_Information/Product_Settings/PROCESSING_LEVEL"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theProcessingLevelString)) { return false; } //--- // Fetch the Spectral Processing: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Characteristics/Product_Image_Characteristics/SPECTRAL_PROCESSING"; } else { xpath = "/Processing_Information/Product_Settings/SPECTRAL_PROCESSING"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theSpectralProcessingString)) { return false; } return true; } bool ossimPleiadesDimapSupportData::parseRasterData(ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimPleiadesDimapSupportData::parseRasterData"; vector > xml_nodes; ossimString xpath, nodeValue; //--- // Fetch if the product file is linked to one or many JP2 files: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Characteristics/Product_Image_Characteristics/Data_Access/Data_File/DATA_FILE_PATH"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() > 1) { theMultiDataFile.setValue(true); } } else { xpath = "/Raster_Data/Data_Access/DATA_FILE_TILES"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theMultiDataFile.setValue(nodeValue); } //--- // Fetch the MegaImageSize: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Raster_Dimensions/NCOLS"; } else { xpath = "/Raster_Data/Raster_Dimensions/NCOLS"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theImageSize.samp = nodeValue.toInt(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Raster_Dimensions/NROWS"; } else { xpath = "/Raster_Data/Raster_Dimensions/NROWS"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theImageSize.line = nodeValue.toInt(); if (theMultiDataFile.getBoolean()) { //--- // Fetch the Number of MegaTiles: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Raster_Dimensions/Raster_Tiles/NTILES"; } else { xpath = "/Raster_Data/Raster_Dimensions/Tile_Set/NTILES"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theNumberOfMegaTiles = nodeValue.toUInt32(); //--- // Fetch the Number of MegaTiles in X and Y: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Raster_Dimensions/Raster_Tiles/RX_NB_OF_TILES"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theNumberOfMegaTilesInRow = nodeValue.toUInt32(); xpath = "/Raster_Dimensions/Raster_Tiles/CY_NB_OF_TILES"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theNumberOfMegaTilesInCol = nodeValue.toUInt32(); } else { xml_nodes.clear(); xpath = "/Raster_Data/Raster_Dimensions/Tile_Set/Regular_Tiling/NTILES_COUNT"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: \nCould not find: " << xpath << std::endl; } return false; } ossimString value; ossimString attribute = "ntiles_x"; if (!xml_nodes[0]->getAttributeValue(value, attribute)) { attribute = "ntiles_R"; xml_nodes[0]->getAttributeValue(value, attribute); } theNumberOfMegaTilesInRow = value.toUInt32(); attribute = "ntiles_y"; if (!xml_nodes[0]->getAttributeValue(value, attribute)) { attribute = "ntiles_C"; xml_nodes[0]->getAttributeValue(value, attribute); } theNumberOfMegaTilesInCol = value.toUInt32(); } if (theNumberOfMegaTilesInRow * theNumberOfMegaTilesInCol != theNumberOfMegaTiles) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: \nIncoherent number of tiles: " << xpath << std::endl; } return false; } if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv2) { //--- // Fetch the size of MegaTiles: //--- xml_nodes.clear(); xpath = "/Raster_Data/Raster_Dimensions/Tile_Set/Regular_Tiling/NTILES_SIZE"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ossimString attribute; ossimString value; attribute = "nrows"; xml_nodes[0]->getAttributeValue(value, attribute); theTileSize.line = value.toUInt32(); attribute = "ncols"; xml_nodes[0]->getAttributeValue(value, attribute); theTileSize.samp = value.toUInt32(); } } //--- TODO_MSD is it useful in the case of RPC model ??? // We will make the RefImagePoint the zero base center of the image. This // is used by the ossimSensorModel::worldToLineSample iterative loop as // the starting point. Since the ossimSensorModel does not know of the // sub image we make it zero base. (comments from spot) //--- theRefImagePoint.line = theImageSize.line / 2.0; theRefImagePoint.samp = theImageSize.samp / 2.0; //--- // Fetch number of bands //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Raster_Dimensions/NBANDS"; } else { xpath = "/Raster_Data/Raster_Dimensions/NBANDS"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theNumBands = nodeValue.toUInt32(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nNumber of bands: " << theNumBands << std::endl; } //--- // Fetch Band Display Order //--- xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Characteristics/Product_Image_Characteristics/Image_Display_Order/RED_CHANNEL"; } else { xpath = "/Raster_Data/Raster_Display/Band_Display_Order/RED_CHANNEL"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); if (theNumBands > 1) { xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Characteristics/Product_Image_Characteristics/Image_Display_Order/GREEN_CHANNEL"; } else { xpath = "/Raster_Data/Raster_Display/Band_Display_Order/GREEN_CHANNEL"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Characteristics/Product_Image_Characteristics/Image_Display_Order/BLUE_CHANNEL"; } else { xpath = "/Raster_Data/Raster_Display/Band_Display_Order/BLUE_CHANNEL"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); if (theNumBands > 3) { xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Product_Characteristics/Product_Image_Characteristics/Image_Display_Order/ALPHA_CHANNEL"; } else { xpath = "/Raster_Data/Raster_Display/Band_Display_Order/ALPHA_CHANNEL"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); } } return true; } bool ossimPleiadesDimapSupportData::parseGeometricData(ossimRefPtr xmlDocument) { ossimString xpath, nodeValue; vector > xml_nodes; xml_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Data_Strip/Geometric_Header_List/Located_Geometric_Header"; } else { xpath = "/Geometric_Data/Use_Area/Located_Geometric_Values"; } xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() != 3 ) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } std::vector >::iterator node = xml_nodes.begin(); while (node != xml_nodes.end()) { std::vector > sub_nodes; //--- // Fetch the Sun Azimuth: //--- xpath = "Solar_Incidences/SUN_AZIMUTH"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSunAzimuth.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Sun Elevation: //--- sub_nodes.clear(); xpath = "Solar_Incidences/SUN_ELEVATION"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSunElevation.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Incidence Angle: //--- sub_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "Incidences/GLOBAL_INCIDENCE"; } else { xpath = "Acquisition_Angles/INCIDENCE_ANGLE"; } (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theIncidenceAngle.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Viewing Angle: //--- sub_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "Pointing_Angles/PSI_XY"; } else { xpath = "Acquisition_Angles/VIEWING_ANGLE"; } (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theViewingAngle.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Azimuth Angle: //--- sub_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "ORIENTATION"; } else { xpath = "Acquisition_Angles/AZIMUTH_ANGLE"; } (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theAzimuthAngle.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the along track incidence angle : //--- sub_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "Incidences/ALONG_TRACK_INCIDENCE"; } else { xpath = "Acquisition_Angles/INCIDENCE_ANGLE_ALONG_TRACK"; } (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theAlongTrackIncidenceAngle.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the across track incidence angle : //--- sub_nodes.clear(); if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "Incidences/ORTHO_TRACK_INCIDENCE"; } else { xpath = "Acquisition_Angles/INCIDENCE_ANGLE_ACROSS_TRACK"; } (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theAcrossTrackIncidenceAngle.push_back(sub_nodes[0]->getText().toDouble()); ++node; } if (theProcessingLevelString == "SENSOR") { // check that this product is SENSOR (some tags are not present in ORTHO) //--- // Fetch the time stamp of the first line: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geometric_Data/Sensor_Model_Characteristics/UTC_Sensor_Model_Range/START"; } else { xpath = "/Geometric_Data/Refined_Model/Time/Time_Range/START"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theTimeRangeStart)) { return false; } //--- // Fetch the time stamp of the last line: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geometric_Data/Sensor_Model_Characteristics/UTC_Sensor_Model_Range/END"; } else { xpath = "/Geometric_Data/Refined_Model/Time/Time_Range/END"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theTimeRangeEnd)) { return false; } //--- // Fetch the line period: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geometric_Data/Sensor_Model_Characteristics/SENSOR_LINE_PERIOD"; } else { xpath = "/Geometric_Data/Refined_Model/Time/Time_Stamp/LINE_PERIOD"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLinePeriod = nodeValue.toDouble(); //--- // Fetch the swath first col: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geometric_Data/Sensor_Model_Characteristics/Sensor_Viewing_Model/Position_In_Retina/FIRST_COL"; } else { xpath = "/Geometric_Data/Refined_Model/Geometric_Calibration/Instrument_Calibration/Swath_Range/FIRST_COL"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theSwathFirstCol = nodeValue.toInt32(); //--- // Fetch the swath last col: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Geometric_Data/Sensor_Model_Characteristics/Sensor_Viewing_Model/Position_In_Retina/LAST_COL"; } else { xpath = "/Geometric_Data/Refined_Model/Geometric_Calibration/Instrument_Calibration/Swath_Range/LAST_COL"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theSwathLastCol = nodeValue.toInt32(); } return true; } bool ossimPleiadesDimapSupportData::parseQualityAssessment(ossimRefPtr /* xmlDocument */ ) { return true; } bool ossimPleiadesDimapSupportData::parseDatasetSources(ossimRefPtr xmlDocument) { // static const char MODULE[] = "ossimPleiadesDimapSupportData::parseDatasetSources"; ossimString xpath, nodeValue; vector > xml_nodes; //--- // Fetch the mission index (1A ou 1B) ? // and generate theSensorID //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Data_Strip/Data_Strip_Identification/PLATFORM_NAME"; } else { xpath = "/Dataset_Sources/Source_Identification/Strip_Source/MISSION"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } if (nodeValue != "PHR") { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nNot a PHR mission!"<< std::endl; } return false; } //--- // Fetch the mission index (1A ou 1B) ? // and generate theSensorID //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Data_Strip/Data_Strip_Identification/PLATFORM_SERIAL_NUMBER"; } else { xpath = "/Dataset_Sources/Source_Identification/Strip_Source/MISSION_INDEX"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } if (nodeValue == "1A") theSensorID = "PHR 1A"; else if (nodeValue == "1B") theSensorID = "PHR 1B"; else { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nNot a valid sensorID!"<< std::endl; } return false; } //--- // Fetch the Instrument: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Data_Strip/Data_Strip_Identification/PLATFORM_NAME"; } else { xpath = "/Dataset_Sources/Source_Identification/Strip_Source/INSTRUMENT"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theInstrument)) { return false; } //--- // Fetch the Instrument Index: //--- if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { xpath = "/Data_Strip/Data_Strip_Identification/PLATFORM_SERIAL_NUMBER"; } else { xpath = "/Dataset_Sources/Source_Identification/Strip_Source/INSTRUMENT_INDEX"; } xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theInstrumentIndex)) { return false; } if (theDIMAPVersion == OSSIM_PLEIADES_DIMAPv1) { //--- // Fetch the Imaging Date: //--- xpath = "/Data_Strip/UTC_Acquisition_Range/START"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theAcquisitionDate)) { return false; } // TODO : fetch (if any in v1) the other acquisition time parameters } else { //--- // Fetch the Imaging Date: //--- ossimString firstLineImagingDate; xpath = "/Dataset_Sources/Source_Identification/Strip_Source/IMAGING_DATE"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, firstLineImagingDate)) { return false; } //--- // Fetch the Imaging Time: //--- ossimString firstLineImagingTime; xpath = "/Dataset_Sources/Source_Identification/Strip_Source/IMAGING_TIME"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, firstLineImagingTime)) { return false; } theAcquisitionDate = firstLineImagingDate + "T" + firstLineImagingTime; } return true; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPleiadesDimapSupportData.h000066400000000000000000000320531301006202600316140ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2012 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Mickael Savinaud (mickael.savinaud@c-s.fr) // // Description: // // Contains declaration of class ossimPleiadesDimapSupportData // //***************************************************************************** #ifndef ossimPleiadesDimapSupportData_HEADER #define ossimPleiadesDimapSupportData_HEADER #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include class ossimKeywordlist; class ossimXmlDocument; namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimPleiadesDimapSupportData : public ossimObject, public ossimErrorStatusInterface { public: enum ossimPleiadesDIMAPVersion { OSSIM_PLEIADES_UNKNOWN, OSSIM_PLEIADES_DIMAPv1, OSSIM_PLEIADES_DIMAPv2 }; /** metadata subprofile type */ enum ossimPleiadesMetadataSubProfile { OSSIM_PLEIADES_METADATA_SUBPROFILE_UNKNOWN = 0, OSSIM_PLEIADES_METADATA_SUBPROFILE_PRODUCT = 1, OSSIM_PLEIADES_METADATA_SUBPROFILE_RPC = 2 }; ossimPleiadesDimapSupportData(); virtual ~ossimPleiadesDimapSupportData(); void clearFields(); bool parseXmlFile(const ossimFilename& file); //--- // Convenient method to print important image info: //--- void printInfo (ostream& os) const; /** * Method to save the state of the object to a keyword list. * Return true if ok or false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0)const; /** * Method to the load (recreate) the state of the object from a keyword * list. Return true if ok or false on error. */ virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix = 0); ossimString getSensorID() const; ossimString getProcessingLevel() const; ossimString getAcquisitionDate() const; ossimString getProductionDate() const; ossimString getImageID() const; ossimString getInstrument() const; ossimString getInstrumentIndex() const; ossim_uint32 getNumberOfBands() const; void getSunAzimuth(std::vector& az) const; void getSunElevation(std::vector& el) const; void getImageSize(ossimIpt& sz) const; void getIncidenceAngle(std::vector& ia) const; void getViewingAngle(std::vector& va) const; //Along and across track incidence angle void getAcrossTrackIncidenceAngle(std::vector& act) const; void getAlongTrackIncidenceAngle(std::vector& alt) const; //--- // Corner points: //--- void getUlCorner(ossimGpt& pt) const; void getUrCorner(ossimGpt& pt) const; void getLrCorner(ossimGpt& pt) const; void getLlCorner(ossimGpt& pt) const; //--- // Image center point: //--- /** Center of frame, sub image if there is one. */ void getRefGroundPoint(ossimGpt& gp) const; /** zero base center point */ void getRefImagePoint(ossimDpt& rp) const; /** Zero based image rectangle, sub image if there is one. */ void getImageRect(ossimDrect& rect)const; bool allMetadataRead(){return (theProductIsOk && theRpcIsOk);}; std::vector getLineNumCoeff() const {return theLineNumCoeff;}; std::vector getLineDenCoeff() const {return theLineDenCoeff;}; std::vector getSampNumCoeff() const {return theSampNumCoeff;}; std::vector getSampDenCoeff() const {return theSampDenCoeff;}; ossim_int32 getLineOffset() const {return theLineOffset;}; ossim_int32 getSampOffset() const {return theSampOffset;}; double getLatOffset() const {return theLatOffset;}; double getLonOffset() const {return theLonOffset;}; double getHeightOffset() const {return theHeightOffset;}; double getLineScale() const {return theLineScale;}; double getSampScale() const {return theSampScale;}; double getLatScale() const {return theLatScale;}; double getLonScale() const {return theLonScale;}; double getHeightScale() const {return theHeightScale;}; ossimString getTimeRangeStart() const {return theTimeRangeStart;}; ossimString getTimeRangeEnd() const {return theTimeRangeEnd;}; ossim_float64 getLinePeriod() const {return theLinePeriod;}; ossim_int32 getSwathFirstCol() const {return theSwathFirstCol;}; ossim_int32 getSwathLastCol() const {return theSwathLastCol;}; private: ossimPleiadesDIMAPVersion theDIMAPVersion; ossimPleiadesMetadataSubProfile theMetadataSubProfile; // only for DIMAPv2 bool theProductIsOk; bool theRpcIsOk; ossimString theXmlDocumentRoot; ossimString theSensorID; ossimString theImageID; ossimString theProductionDate; ossimString theAcquisitionDate; ossimString theInstrument; ossimString theInstrumentIndex; ossimString theProcessingLevelString; ossimString theSpectralProcessingString; std::vector theSunAzimuth; std::vector theSunElevation; std::vector theIncidenceAngle; std::vector theViewingAngle; std::vector theAzimuthAngle; std::vector theAlongTrackIncidenceAngle; std::vector theAcrossTrackIncidenceAngle; ossimIpt theImageSize; ossimIpt theTileSize; ossim_uint32 theNumberOfMegaTilesInRow; ossim_uint32 theNumberOfMegaTilesInCol; ossim_uint32 theNumberOfMegaTiles; ossimBooleanProperty theMultiDataFile; ossim_uint32 theNumBands; std::vector theBandOrder; /** Calibration information for radiometric corrections*/ std::vector thePhysicalBias; std::vector thePhysicalGain; std::vector theSolarIrradiance; //--- // Corner points: //--- ossimGpt theUlCorner; ossimGpt theUrCorner; ossimGpt theLrCorner; ossimGpt theLlCorner; // RPC parameters ossimString theSpecId; double theErrBias; double theErrBiasX; double theErrBiasY; double theErrRand; double theLineOffset; double theSampOffset; double theLatOffset; double theLonOffset; double theHeightOffset; double theLineScale; double theSampScale; double theLatScale; double theLonScale; double theHeightScale; std::vector theLineNumCoeff; std::vector theLineDenCoeff; std::vector theSampNumCoeff; std::vector theSampDenCoeff; // Additional metadata used to enhance pansharpening ossimString theTimeRangeStart; ossimString theTimeRangeEnd; ossim_float64 theLinePeriod; ossim_int32 theSwathFirstCol; ossim_int32 theSwathLastCol; //--- TODO MSD Check if it is necessary to keep that /** Center of frame on ground, if sub image it's the center of that. */ ossimGpt theRefGroundPoint; /** Zero based center of frame. */ ossimDpt theRefImagePoint; ossimGpt createGround(const ossimString& s)const; ossimDpt createDpt(const ossimString& s)const; ossimIpt createIpt(const ossimString& s)const; //--- bool parseRPCMetadata(ossimRefPtr xmlDocument); bool parseMetadataIdentificationDIMAPv1(ossimRefPtr xmlDocument); bool parseMetadataIdentificationDIMAPv2(ossimRefPtr xmlDocument); /** * Dataset Identification: * * From xml section: * /Dimap_Document/Dataset_Identification/ * * NOT YET USED * * @return true. */ bool parseDatasetIdentification(ossimRefPtr xmlDocument); /** * Dataset Content: * * From xml section: * /Dimap_Document/Dataset_Content/ * * Initializes: * theRefGroundPoint * theUlCorner * theUrCorner * theLrCorner * theLlCorner * * Note that the theRefGroundPoint will be the zero based center of * the whole mega image. * Note that the corners will be the corners of the whole mega image. * @return true on success, false if not found. */ bool parseDatasetContent(ossimRefPtr xmlDocument); /** * Product Information: * * From xml section: * /Dimap_Document/Product_Information/ * * Initializes: * theImageID * theProductionDate * * @return true on success, false if not found. */ bool parseProductInformation(ossimRefPtr xmlDocument); /** * Coordinate Reference System: * * From xml section: * /Dimap_Document/Coordinate_Reference_System/ * * NOT YET USED * * @return true. */ bool parseCoordinateReferenceSystem(ossimRefPtr xmlDocument); /** * Geoposition: * * From xml section: * /Dimap_Document/Geoposition/ * * NOT YET USED * * @return true. */ bool parseGeoposition(ossimRefPtr xmlDocument); /** * Processing Information: * * From xml section: * /Dimap_Document/Processing_Information/ * * Initializes: * theProcessingLevel * theSpectralProcessing * * @return true on success, false if not found. */ bool parseProcessingInformation(ossimRefPtr xmlDocument); bool parseRasterData(ossimRefPtr xmlDocument); bool parseRadiometricData(ossimRefPtr xmlDocument); bool parseGeometricData(ossimRefPtr xmlDocument); /** * QualityAssessment: * * From xml section: * /Dimap_Document/Quality_Assessment/ * * NOT YET USED * * @return true. */ bool parseQualityAssessment(ossimRefPtr xmlDocument); bool parseDatasetSources(ossimRefPtr xmlDocument); }; } #endif /* #ifndef ossimPleiadesDimapSupportData_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPleiadesModel.cpp000066400000000000000000000325471301006202600277760ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2012 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Mickael Savinaud (mickael.savinaud@c-s.fr) // // Description: // // Contains definition of class ossimPleiadesModel // //***************************************************************************** #include "ossimPleiadesModel.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { // Define Trace flags for use within this file: static ossimTrace traceExec ("ossimPleiadesModel:exec"); static ossimTrace traceDebug ("ossimPleiadesModel:debug"); RTTI_DEF1(ossimPleiadesModel, "ossimPleiadesModel", ossimRpcModel); //************************************************************************************************* // Constructor //************************************************************************************************* ossimPleiadesModel::ossimPleiadesModel() :ossimRpcModel (), theSupportData (0) { for (unsigned int i = 0; i < 20; i++) { theLineDenCoef[i] = 0.0; theLineNumCoef[i] = 0.0; theSampNumCoef[i] = 0.0; theSampDenCoef[i] = 0.0; } } //************************************************************************************************* // Constructor //************************************************************************************************* ossimPleiadesModel::ossimPleiadesModel(const ossimPleiadesModel& rhs) :ossimRpcModel (rhs), theSupportData (0) { } //************************************************************************************************* // Destructor //************************************************************************************************* ossimPleiadesModel::~ossimPleiadesModel() { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG DESTRUCTOR: ~ossimPleiadesModel(): entering..." << std::endl; theSupportData = 0; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG DESTRUCTOR: ~ossimPleiadesModel(): returning..." << std::endl; } //************************************************************************************************* // Infamous DUP //************************************************************************************************* ossimObject* ossimPleiadesModel::dup() const { return new ossimPleiadesModel(*this); } //************************************************************************************************* // Print //************************************************************************************************* std::ostream& ossimPleiadesModel::print(std::ostream& out) const { // Capture stream flags since we are going to mess with them. std::ios_base::fmtflags f = out.flags(); out << "\nDump of ossimPleiadesModel at address " << (hex) << this << (dec) << "\n------------------------------------------------" << "\n theImageID = " << theImageID << "\n theImageSize = " << theImageSize << "\n theRefGndPt = " << theRefGndPt << "\n theRefImgPt = " << theRefImgPt << "\n theProcessingLevel = " << theSupportData->getProcessingLevel() << "\n------------------------------------------------" << "\n " << endl; // Set the flags back. out.flags(f); if (theSupportData->getProcessingLevel() == "SENSOR") return ossimRpcModel::print(out); else return out; } //************************************************************************************************* // Save State //************************************************************************************************* bool ossimPleiadesModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { if(theSupportData.valid()) { ossimString supportPrefix = ossimString(prefix) + "support_data."; theSupportData->saveState(kwl, supportPrefix); } // If only it is a sensor product we save parameters from RPC model, its avoid to // propagate a empty RPC model if (theSupportData->getProcessingLevel() == "SENSOR") { ossimRpcModel::saveState(kwl, prefix); return true; } else { kwl.add(prefix, "sensor", theSensorID, true); return true; } } //************************************************************************************************* // Load State //************************************************************************************************* bool ossimPleiadesModel::loadState(const ossimKeywordlist& kwl, const char* prefix) { if(!theSupportData) { theSupportData = new ossimPleiadesDimapSupportData; } ossimString supportPrefix = ossimString(prefix) + "support_data."; theSupportData->loadState(kwl, supportPrefix); // If only it is a sensor product we load parameters from RPC model only, its avoid to // add a empty RPC model if (theSupportData->getProcessingLevel() == "SENSOR") { ossimRpcModel::loadState(kwl, prefix); return true; } else { return true; } } bool ossimPleiadesModel::open(const ossimFilename& file) { static const char MODULE[] = "ossimPleiadesModel::open"; //traceDebug.setTraceFlag(true); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } // Make the gsd nan so it gets computed. theGSD.makeNan(); bool result = false; // Filename used. ossimFilename DIMxmlFile; ossimFilename RPCxmlFile; // Generate metadata and rpc filename if ( (file.ext().downcase() != "jp2" && file.ext().downcase() != "tif") || !file.exists()) { //not a valid file return false; } else { // DIMAPv1 ossimFilename DIMv1xmlFileTmp = file; DIMv1xmlFileTmp.setFile("PHRDIMAP"); DIMv1xmlFileTmp.setExtension("XML"); if (DIMv1xmlFileTmp.exists()) { DIMxmlFile = DIMv1xmlFileTmp; RPCxmlFile = DIMv1xmlFileTmp; } else { // DIMAPv2 DIMxmlFile = file.path(); RPCxmlFile = file.path(); ossimFilename DIMxmlFileTmp = file.file(); ossimFilename RPCxmlFileTmp; DIMxmlFileTmp = DIMxmlFileTmp.file().replaceStrThatMatch("^IMG_", "DIM_"); DIMxmlFileTmp = DIMxmlFileTmp.replaceStrThatMatch("_R[0-9]+C[0-9]+\\.(JP2|TIF)$", ".XML"); // Check if it is an XML extension if( DIMxmlFileTmp.ext() != "XML") return false; RPCxmlFileTmp = DIMxmlFileTmp.file().replaceStrThatMatch("^DIM_", "RPC_"); DIMxmlFile = DIMxmlFile.dirCat(DIMxmlFileTmp); RPCxmlFile = RPCxmlFile.dirCat(RPCxmlFileTmp); } if (!DIMxmlFile.exists()) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "PHR main DIMAP file " << DIMxmlFile << " doesn't exist ...\n"; } return false; } } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Metadata xml file: " << DIMxmlFile << "\n"; ossimNotify(ossimNotifyLevel_DEBUG) << "RPC xml file: " << RPCxmlFile << "\n"; } ossimString processingLevel; // Parse the metadata xml file if ( !theSupportData.valid() ) theSupportData = new ossimPleiadesDimapSupportData(); if(!theSupportData->parseXmlFile(DIMxmlFile)) { theSupportData = 0; // ossimRefPtr if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimPleiadesModel::open DEBUG:" << "\nCould not open correctly DIMAP file" << std::endl; } return false; } theSensorID = theSupportData->getSensorID(); theImageID = theSupportData->getImageID(); // Get the processing level (ORTHO or SENSOR or perhaps MOSAIC ?) processingLevel = theSupportData->getProcessingLevel(); // Parse the RPC xml file if necessary if (RPCxmlFile.exists() && processingLevel == "SENSOR") { if (!theSupportData->parseXmlFile(RPCxmlFile)) { theSupportData = 0; // ossimRefPtr ossimNotify(ossimNotifyLevel_WARN) << "ossimPleiadesModel::open WARNING:" << "\nCould not open correctly RPC file" << std::endl; return false; } thePolyType = B; for (unsigned int i = 0 ; i < 20; i++ ) { theLineNumCoef[i] = theSupportData->getLineNumCoeff()[i]; theLineDenCoef[i] = theSupportData->getLineDenCoeff()[i]; theSampNumCoef[i] = theSupportData->getSampNumCoeff()[i]; theSampDenCoef[i] = theSupportData->getSampDenCoeff()[i]; } theLineScale = theSupportData->getLineScale(); theSampScale = theSupportData->getSampScale(); theLatScale = theSupportData->getLatScale(); theLonScale = theSupportData->getLonScale(); theHgtScale = theSupportData->getHeightScale(); theLineOffset = theSupportData->getLineOffset(); theSampOffset = theSupportData->getSampOffset(); theLatOffset = theSupportData->getLatOffset(); theLonOffset = theSupportData->getLonOffset(); theHgtOffset = theSupportData->getHeightOffset(); } // TODO MSD Check if this part is necessary _productXmlFile = DIMxmlFile; ossimSupportFilesList::instance()->add(_productXmlFile); // TODO MSD WARNING File with multi tiles are not well managed theSupportData->getImageRect(theImageClipRect); theSupportData->getImageSize(theImageSize); finishConstruction(); clearErrorStatus(); result = true; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } /*std::cout << "---------------------------" << std::endl; print(std::cout); std::cout << "---------------------------" << std::endl;*/ return result; } //************************************************************************************************* //! Collects common code among all parsers //************************************************************************************************* void ossimPleiadesModel::finishConstruction() { theImageSize.line = theImageClipRect.height(); theImageSize.samp = theImageClipRect.width(); theRefImgPt.line = theImageClipRect.midPoint().y; theRefImgPt.samp = theImageClipRect.midPoint().x; theRefGndPt.lat = theLatOffset; theRefGndPt.lon = theLonOffset; theRefGndPt.hgt = theHgtOffset; //--- // NOTE: We must call "updateModel()" to set parameter used by base // ossimRpcModel prior to calling lineSampleHeightToWorld or all // the world points will be same. //--- updateModel(); ossimGpt v0, v1, v2, v3; lineSampleHeightToWorld(theImageClipRect.ul(), theHgtOffset, v0); lineSampleHeightToWorld(theImageClipRect.ur(), theHgtOffset, v1); lineSampleHeightToWorld(theImageClipRect.lr(), theHgtOffset, v2); lineSampleHeightToWorld(theImageClipRect.ll(), theHgtOffset, v3); theBoundGndPolygon = ossimPolygon (ossimDpt(v0), ossimDpt(v1), ossimDpt(v2), ossimDpt(v3)); // Set the ground reference point using the model. lineSampleHeightToWorld(theRefImgPt, theHgtOffset, theRefGndPt); if( theGSD.hasNans() ) { try { // This will set theGSD and theMeanGSD. Method throws ossimException. computeGsd(); } catch (const ossimException& e) { ossimNotify(ossimNotifyLevel_WARN) << "ossimPleiadesModel::finishConstruction -- caught exception:\n" << e.what() << std::endl; } } } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPleiadesModel.h000066400000000000000000000064321301006202600274350ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2012 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Mickael Savinaud (mickael.savinaud@c-s.fr) // // Description: // // Contains declaration of class ossimPleiadesModel. // //***************************************************************************** // FIXME $Id: ossimSpot5Model.h 15766 2009-10-20 12:37:09Z gpotts $ #ifndef ossimPleiadesModel_HEADER #define ossimPleiadesModel_HEADER #include #include #include "ossimPleiadesDimapSupportData.h" #include #include namespace ossimplugins { class ossimPleiadesDimapSupportData; class OSSIM_PLUGINS_DLL ossimPleiadesModel : public ossimRpcModel { public: /*! * CONSTRUCTORS: */ /** @brief default constructor */ ossimPleiadesModel(); /** @brief copy constructor */ ossimPleiadesModel(const ossimPleiadesModel& rhs); /** @brief Destructor */ virtual ~ossimPleiadesModel(); bool open(const ossimFilename& file); /*! * Returns pointer to a new instance, copy of this. * Not implemented yet! Returns NULL... */ virtual ossimObject* dup() const; /*! * Extends base-class implementation. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; /*! * Fulfills ossimObject base-class pure virtuals. Loads and saves geometry * KWL files. Returns true if successful. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=NULL) const; virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=NULL); void setSupportData(ossimPleiadesDimapSupportData* supportData) { theSupportData = supportData; } ossimPleiadesDimapSupportData* getSupportData() { return theSupportData.get(); } const ossimPleiadesDimapSupportData* getSupportData()const { return theSupportData.get(); } protected: bool parseMetaData(const ossimFilename& file); bool parseRpcData (const ossimFilename& file); // In the future //bool parseJP2File (const ossimFilename& file); void finishConstruction(); ossimRefPtr theSupportData; ossimFilename _productXmlFile; TYPE_DATA }; } #endif /* #ifndef ossimPleiadesModel_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPluginCommon.cpp000066400000000000000000000105421301006202600276650ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: David Burken // // Description: Common code for this plugin. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include static ossimTrace traceDebug("ossimPluginCommon:debug"); namespace ossimplugins { bool ossim::iso8601TimeStringToCivilDate(const std::string& dateString, CivilDateTime& outputDate) { bool result = true; ossimLocalTm otm; if ( otm.setIso8601(dateString) ) { outputDate.set_year( otm.getYear() ); outputDate.set_month( otm.getMonth() ); outputDate.set_day( otm.getDay() ); int second = otm.tm_hour * 3600 + otm.tm_min * 60 + otm.tm_sec; outputDate.set_second( second ); outputDate.set_decimal( otm.getFractionalSecond() ); } else { result = false; } return result; } bool ossim::getPath(const ossimString& path, const ossimXmlDocument* xdoc, ossimString& s) { bool result = false; if (xdoc) { std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() == 1 ) // Error if more than one. { if ( xnodes[0].valid() ) { s = xnodes[0]->getText(); result = true; } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "ossim::getPath ERROR:\n" << "Node not found: " << path << std::endl; } } } else if ( xnodes.size() == 0 ) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "ossim::getPath ERROR:\n" << "Node not found: " << path << std::endl; } } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "ossim::getPath ERROR:\n" << "Multiple nodes found: " << path << std::endl; } } } if (!result) { s.clear(); } return result; } bool ossim::getPath(const ossimString& path, const ossimXmlDocument* xdoc, std::vector& v) { bool result = false; if (xdoc) { std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { std::vector >::const_iterator i = xnodes.begin(); while ( i != xnodes.end() ) { v.push_back( (*i)->getText() ); ++i; } result = true; } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "ossim::getPath ERROR:\n" << "Nodes not found: " << path << std::endl; } } } if (!result) { v.clear(); } return result; } bool ossim::findFirstNode(const ossimString& path, ossimRefPtr node, ossimString& s) { bool result = false; if ( node.valid() ) { ossimRefPtr n = node->findFirstNode(path); if ( n.valid() ) { s = n->getText(); if ( s.size() ) { result = true; } else { if(!traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "ossim::findFirstNode ERROR:\n" << "Node empty: " << path << std::endl; } } } else { if(!traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "ossim::findFirstNode ERROR:\n" << "Node not found: " << path << std::endl; } } } return result; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPluginCommon.h000066400000000000000000000047211301006202600273340ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: David Burken // // Description: Common code for this plugin. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimPluginCommon_HEADER #define ossimPluginCommon_HEADER 1 #include #include #include class ossimString; class ossimXmlDocument; class ossimXmlNode; namespace ossimplugins { class CivilDateTime; namespace ossim { /** * @note This code was moved out of ossimRadarSat2Model. * * @brief Converts date string from ISO 8601 format to CivilDateTime. * * @param dateString Input date string. * * @param outputDate Output date object to initialize. * * @return true on success false on error. */ bool iso8601TimeStringToCivilDate(const std::string& dataString, CivilDateTime& outputDate); /** * @brief Gets path from doc and initializes string. * @param path Xml path to look for. * @param xdoc Xml doc to look in. * @param s String to initialize. * @return true on success and false if path is not found or if there * are more than one of path. * @note You should call getPath that takes a vector for things that are * repetitive. */ bool getPath(const ossimString& path, const ossimXmlDocument* xdoc, ossimString& s); /** * @brief Gets path from doc and initializes string. * @param path Xml path to look for. * @param xdoc Xml doc to look in. * @param v Vector to initialize. * @return true on success and false if path is not found. */ bool getPath(const ossimString& path, const ossimXmlDocument* xdoc, std::vector& v); /** * @brief Finds from node with path from node and initializes string. * * @param path Xml path to look for. * * @param node Xml node to look in. * * @param s String to initialize. * * @return true on success and false if path is not found or if text is * empty from found node.. */ bool findFirstNode(const ossimString& path, ossimRefPtr node, ossimString& s); } // matches: namespace ossim } #endif /* matches: #ifndef ossimPluginCommon_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPluginInit.cpp000066400000000000000000000054421301006202600273430ustar00rootroot00000000000000//******************************************************************* // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: Garrett Potts //******************************************************************* // $Id$ #include #include #include #include #include #include #include namespace ossimplugins { static void setDescription(ossimString& description) { description = "OSSIM Plugin\n\n"; std::vector projectionTypes; ossimPluginProjectionFactory::instance()->getTypeNameList(projectionTypes); ossim_uint32 idx = 0; description = "Projecitons Supported:\n\n"; for(idx = 0; idx < projectionTypes.size();++idx) { description += projectionTypes[idx] + "\n"; } } extern "C" { ossimSharedObjectInfo myInfo; ossimString theDescription; std::vector theObjList; const char* getDescription() { return theDescription.c_str(); } int getNumberOfClassNames() { return (int)theObjList.size(); } const char* getClassName(int idx) { if(idx < (int)theObjList.size()) { return theObjList[0].c_str(); } return (const char*)0; } /* Note symbols need to be exported on windoze... */ OSSIM_PLUGINS_DLL void ossimSharedLibraryInitialize( ossimSharedObjectInfo** info) { myInfo.getDescription = getDescription; myInfo.getNumberOfClassNames = getNumberOfClassNames; myInfo.getClassName = getClassName; *info = &myInfo; /** Register the readers... */ ossimImageHandlerRegistry::instance()-> registerFactory(ossimPluginReaderFactory::instance()); /** * Register the projection factory. * Note that this must be pushed to the front of the factory or bilinear * projection will be picked up. */ ossimProjectionFactoryRegistry::instance()-> registerFactoryToFront(ossimPluginProjectionFactory::instance()); setDescription(theDescription); } /* Note symbols need to be exported on windoze... */ OSSIM_PLUGINS_DLL void ossimSharedLibraryFinalize() { ossimImageHandlerRegistry::instance()-> unregisterFactory(ossimPluginReaderFactory::instance()); ossimProjectionFactoryRegistry::instance()-> unregisterFactory(ossimPluginProjectionFactory::instance()); } } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPluginProjectionFactory.cpp000066400000000000000000000342071301006202600321050ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ //*** // Note to programmer: To add a new model, search this file for "ADD_MODEL" // to locate places requiring editing. Functional example below... // // ADD_MODEL: Include all sensor model headers here: //*** #include "ossimPluginProjectionFactory.h" #include "ossimRadarSatModel.h" #include "ossimEnvisatAsarModel.h" #include "ossimTerraSarModel.h" #include "ossimRadarSat2Model.h" #include "ossimErsSarModel.h" #include "ossimAlosPalsarModel.h" #include "ossimPleiadesModel.h" #include "ossimTileMapModel.h" #include "ossimSpot6Model.h" #include "ossimSentinel1Model.h" #include "ossimStringUtilities.h" #include "ossimTraceHelpers.h" #include #include #include //#include //*** // Define Trace flags for use within this file: //*** #include #include static ossimTrace traceExec = ossimTrace("ossimPluginProjectionFactory:exec"); static ossimTrace traceDebug = ossimTrace("ossimPluginProjectionFactory:debug"); #include #include #ifndef _WIN32 #include //PATH_MAX #include //realpath #include #endif namespace ossimplugins { bool ossimPluginProjectionFactory::initialized_; ossimPluginProjectionFactory ossimPluginProjectionFactory::factoryInstance; ossimPluginProjectionFactory* ossimPluginProjectionFactory::instance() { return initialized_ ? &factoryInstance : 0; } template inline ossimRefPtr doUpcastModelToProjection(ossimRefPtr model) { return model.get(); } template inline ossimRefPtr doUpcastModelToProjectionWhenOCG(ossimRefPtr model) { ossimRefPtr projection = model->getReplacementOcgModel().get(); #if 0 if (projection.valid()) model = 0; // Have OCG, don't need this one anymore else projection = model.get(); #else if (!projection) { projection = model.get(); } #endif return projection; } template <> inline ossimRefPtr doUpcastModelToProjection(ossimRefPtr model) { return doUpcastModelToProjectionWhenOCG(model); } template <> inline ossimRefPtr doUpcastModelToProjection(ossimRefPtr model) { return doUpcastModelToProjectionWhenOCG(model); } template inline ossimRefPtr doBuildProjection(ossimFilename const& filename) { static const char MODULE[] = "ossimPluginProjectionFactory::createProjection(ossimFilename& filename)"; if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: testing " << STATIC_TYPE_NAME(ProjectionType) << "\n"; } ossimRefPtr model = new ProjectionType(); if ( model->open(filename) ) { return model.get(); } else { return 0; } } ossimProjection* ossimPluginProjectionFactory::createProjection( const ossimFilename& file_name, ossim_uint32 /*entryIdx*/)const { static const char MODULE[] = "ossimPluginProjectionFactory::createProjection(ossimFilename& filename)"; ossimRefPtr projection = 0; //traceDebug.setTraceFlag(true); #ifndef _WIN32 char real_path[PATH_MAX + 1]; char *ret_path = NULL; ret_path = realpath(file_name, real_path); if( ret_path == NULL) { if(traceExec()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " error calling realpath(" << file_name << "). errno " << strerror(errno) << std::endl; } return NULL; } const ossimFilename abs_file_name( real_path ); #else //GetFullPathName function is not thread safe. better use absolute path on windows //https://msdn.microsoft.com/en-us/library/windows/desktop/aa364963%28v=vs.85%29.aspx const ossimFilename abs_file_name( file_name ); #endif // TODO: use a type-list to simplify this chain factory. // Sentinel1 if ( !projection ) { projection = doBuildProjection(abs_file_name); } if ( !projection ) { #if 1 projection = doBuildProjection(abs_file_name); #else if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: testing ossimRadarSat2Model" << std::endl; } ossimRefPtr model = new ossimRadarSat2Model(); if ( model->open(abs_file_name) ) { // Check if a coarse grid was generated, and use it instead: projection = model->getReplacementOcgModel().get(); if (projection.valid()) model = 0; // Have OCG, don't need this one anymore else projection = model.get(); } else { model = 0; } #endif } // Pleiades if ( !projection ) { projection = doBuildProjection(abs_file_name); } if ( !projection ) { #if 0 if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: testing ossimTerraSarModel" << std::endl; } ossimRefPtr model = new ossimTerraSarModel(); if ( model->open(abs_file_name) ) { // Check if a coarse grid was generated, and use it instead: projection = model->getReplacementOcgModel().get(); if (projection.valid()) model = 0; // Have OCG, don't need this one anymore else projection = model.get(); } else { model = 0; } #else projection = doBuildProjection(abs_file_name); #endif } // ErsSar if ( !projection ) { projection = doBuildProjection(abs_file_name); } if (!projection) { projection = doBuildProjection(abs_file_name); } if (!projection) { projection = doBuildProjection(abs_file_name); } if (!projection) { projection = doBuildProjection(abs_file_name); } if (!projection) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: testing ossimFormosatModel" << std::endl; } ossimFilename formosatTest = abs_file_name; formosatTest = formosatTest.setExtension("geom"); if(!formosatTest.exists()) { formosatTest = abs_file_name.path(); formosatTest = formosatTest.dirCat(ossimFilename("METADATA.DIM")); if (formosatTest.exists() == false) { formosatTest = abs_file_name.path(); formosatTest = formosatTest.dirCat(ossimFilename("metadata.dim")); } } if(formosatTest.exists()) { ossimRefPtr meta = new ossimFormosatDimapSupportData; if(meta->loadXmlFile(formosatTest)) { ossimRefPtr model = new ossimFormosatModel(meta.get()); if(!model->getErrorStatus()) { projection = model.get(); } model = 0; } } } if (!projection) { projection = doBuildProjection(abs_file_name); } // Spot6 if ( !projection ) { projection = doBuildProjection(abs_file_name); } //*** // ADD_MODEL: (Please leave this comment for the next programmer) // Or, use doBuildProjection(filename); //*** //if(traceDebug()) //{ // ossimNotify(ossimNotifyLevel_DEBUG) // << MODULE << " DEBUG: testing MY_NEW_MODEL" << std::endl; //} // MY_NEW_MODEL //if ( !projection ) //{ // ossimRefPtr model = new MY_NEW_MODEL(); // if ( model->open(filename) ) //{ // projection = model.get(); //} // else // { // model = 0; // } //} return projection.release(); } ossimProjection* ossimPluginProjectionFactory::createProjection( const ossimString& name)const { static const char MODULE[] = "ossimPluginProjectionFactory::createProjection(ossimString& name)"; if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Entering ...." << std::endl; } // else if (name == STATIC_TYPE_NAME(ossimCosmoSkymedModel)) // { // return new ossimCosmoSkymedModel; // } // TOTO: use type list/map if (name == STATIC_TYPE_NAME(ossimRadarSat2Model)) { return new ossimRadarSat2Model(); } else if (name == STATIC_TYPE_NAME(ossimTerraSarModel)) { return new ossimTerraSarModel(); } else if (name == STATIC_TYPE_NAME(ossimErsSarModel)) { return new ossimErsSarModel; } else if (name == STATIC_TYPE_NAME(ossimEnvisatAsarModel)) { return new ossimEnvisatAsarModel; } else if (name == STATIC_TYPE_NAME(ossimRadarSatModel)) { return new ossimRadarSatModel; } else if (name == STATIC_TYPE_NAME(ossimAlosPalsarModel)) { return new ossimAlosPalsarModel; } else if (name == STATIC_TYPE_NAME(ossimFormosatModel)) { return new ossimFormosatModel; } else if (name == STATIC_TYPE_NAME(ossimTileMapModel)) { return new ossimTileMapModel; } else if (name == STATIC_TYPE_NAME(ossimPleiadesModel)) { return new ossimPleiadesModel; } else if (name == STATIC_TYPE_NAME(ossimSpot6Model)) { return new ossimSpot6Model; } else if (name == STATIC_TYPE_NAME(ossimSentinel1Model)) { return new ossimSentinel1Model; } //*** // ADD_MODEL: (Please leave this comment for the next programmer) //*** // if(name == MY_NEW_MODEL) // return new myNewModel; if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Leaving ...." << std::endl; } return 0; } ossimProjection* ossimPluginProjectionFactory::createProjection( const ossimKeywordlist& kwl, const char* prefix)const { ossimRefPtr result = 0; static const char MODULE[] = "ossimPluginProjectionFactory::createProjection(ossimKeywordlist& kwl)"; SCOPED_LOG(traceDebug, MODULE); const char* lookup = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (lookup) { const std::string type = lookup; if (type == "ossimRadarSat2Model") { result = new ossimRadarSat2Model(); } else if (type == "ossimTerraSarModel") { result = new ossimTerraSarModel(); } else if (type == "ossimErsSarModel") { result = new ossimErsSarModel(); } else if (type == "ossimEnvisatAsarModel") { result = new ossimEnvisatAsarModel(); } else if (type == "ossimRadarSatModel") { result = new ossimRadarSatModel(); } else if (type == "ossimAlosPalsarModel") { result = new ossimAlosPalsarModel(); } else if (type == "ossimFormosatModel") { result = new ossimFormosatModel(); } else if (type == "ossimTileMapModel") { result = new ossimTileMapModel(); } else if (type == "ossimPleiadesModel") { result = new ossimPleiadesModel(); } else if (type == "ossimSpot6Model") { result = new ossimSpot6Model(); } else if (type == "ossimSentinel1Model") { result = new ossimSentinel1Model(); } //*** // ADD_MODEL: (Please leave this comment for the next programmer) //*** // else if (type == "ossimSpot6Model") // { // result = new ossimSpot6Model(); // } // Then, try to load the keyword list if ( result.get() && !result->loadState(kwl, prefix) ) { result = 0; } } return result.release(); } ossimObject* ossimPluginProjectionFactory::createObject( const ossimString& typeName)const { return createProjection(typeName); } ossimObject* ossimPluginProjectionFactory::createObject( const ossimKeywordlist& kwl, const char* prefix)const { return createProjection(kwl, prefix); } void ossimPluginProjectionFactory::getTypeNameList(std::vector& typeList)const { typeList.push_back(STATIC_TYPE_NAME(ossimRadarSatModel)); typeList.push_back(STATIC_TYPE_NAME(ossimRadarSat2Model)); typeList.push_back(STATIC_TYPE_NAME(ossimTerraSarModel)); // typeList.push_back(STATIC_TYPE_NAME(ossimCosmoSkymedModel)); typeList.push_back(STATIC_TYPE_NAME(ossimEnvisatAsarModel)); typeList.push_back(STATIC_TYPE_NAME(ossimErsSarModel)); typeList.push_back(STATIC_TYPE_NAME(ossimAlosPalsarModel)); typeList.push_back(STATIC_TYPE_NAME(ossimFormosatModel)); typeList.push_back(STATIC_TYPE_NAME(ossimTileMapModel)); typeList.push_back(STATIC_TYPE_NAME(ossimPleiadesModel)); typeList.push_back(STATIC_TYPE_NAME(ossimSentinel1Model)); typeList.push_back(STATIC_TYPE_NAME(ossimSpot6Model)); //*** // ADD_MODEL: Please leave this comment for the next programmer. Add above. //*** //typeList.push_back(STATIC_TYPE_NAME(MY_NEW_MODEL)); } bool ossimPluginProjectionFactory::isTileMap(ossimFilename filename)const { filename.downcase(); // Incorrect inheritance, some string services have been lost std::string const& sFilename = filename; const bool res = ends_with(sFilename, ".otb") || starts_with(sFilename, "http") ; return res; } } // ossimplugins namespace OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPluginProjectionFactory.h000066400000000000000000000045141301006202600315500ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimPluginProjectionFactory_HEADER #define ossimPluginProjectionFactory_HEADER #include #include namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimPluginProjectionFactory : public ossimProjectionFactoryBase { public: static ossimPluginProjectionFactory* instance(); /** * takes a filename. This filename can be an image file or * it can also be a ossim .geom file. It could be other * forms of geom files as well. The factories job will be to * determine what parser to use and return a projection if * successful. */ virtual ossimProjection* createProjection(const ossimFilename& filename, ossim_uint32 entryIdx)const; using ossimProjectionFactoryBase::createProjection; /** * Take a projection type name. */ virtual ossimProjection* createProjection(const ossimString& name)const; /** * Take a keywordlist. */ virtual ossimProjection* createProjection(const ossimKeywordlist& kwl, const char* prefix=0)const; virtual ossimObject* createObject(const ossimString& typeName)const; /*! * Creates and object given a keyword list. */ virtual ossimObject* createObject(const ossimKeywordlist& kwl, const char* prefix=0)const; virtual void getTypeNameList(std::vector& typeList)const; protected: // Taken by copy -> copy elision bool isTileMap(ossimFilename filename) const; private: ossimPluginProjectionFactory() { initialized_ = true; } ~ossimPluginProjectionFactory() { initialized_ = false; } static bool initialized_; static ossimPluginProjectionFactory factoryInstance; ossimPluginProjectionFactory(ossimPluginProjectionFactory const&); // Don't // Implement void operator=(ossimPluginProjectionFactory const&); // Don't implement }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPluginReaderFactory.cpp000066400000000000000000000114321301006202600311660ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: David Burken // // Description: Image handler factory for ossim plugins plugin. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include namespace ossimplugins { static const ossimTrace traceDebug("ossimPluginReaderFactory:debug"); RTTI_DEF1(ossimPluginReaderFactory, "ossimPluginReaderFactory", ossimImageHandlerFactoryBase); ossimPluginReaderFactory* ossimPluginReaderFactory::theInstance = 0; ossimPluginReaderFactory::~ossimPluginReaderFactory() { theInstance = 0; } ossimPluginReaderFactory* ossimPluginReaderFactory::instance() { if(!theInstance) { theInstance = new ossimPluginReaderFactory; } return theInstance; } ossimImageHandler* ossimPluginReaderFactory::open( const ossimFilename& fileName, bool openOverview)const { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimPluginReaderFactory::open(filename) DEBUG: entered..." << "\ntrying ossimRadarSat2TiffReader" << std::endl; } ossimRefPtr reader = new ossimRadarSat2TiffReader(); if(reader->open(fileName) == false) { reader = 0; } if ( !reader.valid() ) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "\ntrying ossimTerraSarTiffReader" << std::endl; } reader = new ossimTerraSarTiffReader(); if(reader->open(fileName) == false) { reader = 0; } } if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimPluginReaderFactory::open(filename) DEBUG: leaving..." << std::endl; } return reader.release(); } ossimImageHandler* ossimPluginReaderFactory::open(const ossimKeywordlist& kwl, const char* prefix)const { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimPluginReaderFactory::open(kwl, prefix) DEBUG: entered..." << "Trying ossimRadarSat2TiffReader" << std::endl; } ossimRefPtr reader = new ossimRadarSat2TiffReader; if(reader->loadState(kwl, prefix) == false) { reader = 0; } if ( !reader.valid() ) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimPluginReaderFactory::open(kwl, prefix) DEBUG: entered..." << "Trying ossimTerraSarTiffReader" << std::endl; } reader = new ossimTerraSarTiffReader; if(reader->loadState(kwl, prefix) == false) { reader = 0; } } if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimPluginReaderFactory::open(kwl, prefix) DEBUG: leaving..." << std::endl; } return reader.release(); } ossimObject* ossimPluginReaderFactory::createObject( const ossimString& typeName)const { ossimRefPtr result = 0; if(typeName == "ossimRadarSat2TiffReader") { result = new ossimRadarSat2TiffReader; } else if(typeName == "ossimTerraSarTiffReader") { result = new ossimTerraSarTiffReader; } return result.release(); } ossimObject* ossimPluginReaderFactory::createObject( const ossimKeywordlist& kwl, const char* prefix)const { return this->open(kwl, prefix); } void ossimPluginReaderFactory::getTypeNameList( std::vector& typeList)const { typeList.push_back(ossimString("ossimRadarSat2TiffReader")); typeList.push_back(ossimString("ossimTerraSarTiffReader")); } void ossimPluginReaderFactory::getSupportedExtensions( ossimImageHandlerFactoryBase::UniqueStringList& extensionList)const { extensionList.push_back(ossimString("xml")); } ossimPluginReaderFactory::ossimPluginReaderFactory(){} ossimPluginReaderFactory::ossimPluginReaderFactory(const ossimPluginReaderFactory&){} void ossimPluginReaderFactory::operator=(const ossimPluginReaderFactory&){} } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimPluginReaderFactory.h000066400000000000000000000065041301006202600306370ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: David Burken // // Description: Image handler factory for ossim plugins plugin. //---------------------------------------------------------------------------- // $Id$ #ifndef ossimPluginReaderFactory_HEADER #define ossimPluginReaderFactory_HEADER 1 #include #include class ossimString; class ossimFilename; class ossimKeywordlist; namespace ossimplugins { /** @brief Image handler factory for ossim plugins plugin. */ class OSSIM_PLUGINS_DLL ossimPluginReaderFactory : public ossimImageHandlerFactoryBase { public: /** @brief virtual destructor */ virtual ~ossimPluginReaderFactory(); /** * @brief static method to return instance (the only one) of this class. * @return pointer to instance of this class. */ static ossimPluginReaderFactory* instance(); /** * @brief open that takes a file name. * @param file The file to open. * @return pointer to image handler on success, 0 on failure. */ virtual ossimImageHandler* open(const ossimFilename& fileName, bool openOverview=true) const; /** * @brief open that takes a keyword list and prefix. * @param kwl The keyword list. * @param prefix the keyword list prefix. * @return pointer to image handler on success, 0 on failure. */ virtual ossimImageHandler* open(const ossimKeywordlist& kwl, const char* prefix=0)const; /** * @brief createObject that takes a class name. * @param typeName The name of the class.. * @return pointer to image writer on success, 0 on failure. */ virtual ossimObject* createObject(const ossimString& typeName)const; /** * @brief Creates and object given a keyword list and prefix. * @param kwl The keyword list. * @param prefix the keyword list prefix. * @return pointer to image handler on success, 0 on failure. */ virtual ossimObject* createObject(const ossimKeywordlist& kwl, const char* prefix=0)const; /** * @brief Adds ossimTerraSarTiffReader to the typeList. * @param typeList List to add to. */ virtual void getTypeNameList(std::vector& typeList)const; /** * @brief Method to add supported extension to the list, like "png". * * @param extensionList The list to add to. */ virtual void getSupportedExtensions( ossimImageHandlerFactoryBase::UniqueStringList& extensionList)const; protected: /** @brief hidden from use default constructor */ ossimPluginReaderFactory(); /** @brief hidden from use copy constructor */ ossimPluginReaderFactory(const ossimPluginReaderFactory&); /** @brief hidden from use copy constructor */ void operator=(const ossimPluginReaderFactory&); /** static instance of this class */ static ossimPluginReaderFactory* theInstance; TYPE_DATA }; } #endif /* end of #ifndef ossimPluginReaderFactory_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2Model.cpp000066400000000000000000001247311301006202600300300ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { // Keyword constants: static const char NUMBER_SRGR_COEFFICIENTS_KW[] = "sr_gr_coeffs_count"; static const char LOAD_FROM_PRODUCT_FILE_KW[] = "load_from_product_file_flag"; static const char PRODUCT_XML_FILE_KW[] = "product_xml_filename"; // Static trace for debugging static ossimTrace traceDebug("ossimRadarSat2Model:debug"); RTTI_DEF1(ossimRadarSat2Model, "ossimRadarSat2Model", ossimGeometricSarSensorModel); ossimRadarSat2Model::ossimRadarSat2Model() : ossimGeometricSarSensorModel() , _n_srgr(0) , _srgr_update() , _SrGr_R0() , theAcquisitionDateUTCString("") , theProductionDateUTCString("") { } ossimRadarSat2Model::ossimRadarSat2Model(const ossimRadarSat2Model& rhs) : ossimGeometricSarSensorModel(rhs) , _n_srgr(rhs._n_srgr) , _srgr_update(rhs._srgr_update) , _SrGr_R0(rhs._SrGr_R0) , theProductionDateUTCString(rhs.theProductionDateUTCString) , theAcquisitionDateUTCString(rhs.theAcquisitionDateUTCString) { } ossimRadarSat2Model::~ossimRadarSat2Model() { } ossimString ossimRadarSat2Model::getClassName() const { return ossimString("ossimRadarSat2Model"); } ossimObject* ossimRadarSat2Model::dup() const { return new ossimRadarSat2Model(*this); } double ossimRadarSat2Model::getSlantRangeFromGeoreferenced(double col) const { if (_n_srgr==0) return(-1) ; double relativeGroundRange, slantRange = 0.0 ; // in the case of Georeferenced images, _refPoint->get_distance() // contains the ground range relativeGroundRange = _refPoint->get_distance() + _sensor->get_col_direction() * (col-_refPoint->get_pix_col())* theGSD.x; //relativeGroundRange = 1 + _sensor->get_col_direction() * (col-_refPoint->get_pix_col())* theGSD.x; //relativeGroundRange = (8.78400000e+03)*theGSD.x; if ( traceDebug() ) { ossimNotify(ossimNotifyLevel_DEBUG) << "_refPoint->get_distance(): " << _refPoint->get_distance() << "\n_sensor->get_col_direction() " << _sensor->get_col_direction() << "\n(col-_refPoint->get_pix_col()) " << (col-_refPoint->get_pix_col()) << "\n_refPoint->get_pix_col() : " << _refPoint->get_pix_col() << "\n relativeGroundRange : " << relativeGroundRange << endl; } int numSet = FindSRGRSetNumber((_refPoint->get_ephemeris())->get_date()) ; /** * @todo : could be improved (date choice) */ for (int i=0 ; i < static_cast(_SrGr_coeffs[numSet].size()); i++) { slantRange += _SrGr_coeffs[numSet][i]*pow(relativeGroundRange,i) ; } return slantRange ; } bool ossimRadarSat2Model::open(const ossimFilename& file) { static const char MODULE[] = "ossimRadarSat2Model::open"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = false; // Get the xml file. ossimFilename xmlFile; _imageFilename = file.expand(); if (file.ext().downcase() == "xml") { xmlFile = file; } else if (file.isFile()) { xmlFile = file.expand().path().dirCat("product.xml"); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "product xml file: " << xmlFile << "\n"; } if ( xmlFile.exists() ) { //--- // Instantiate the XML parser: //--- ossimXmlDocument* xdoc = new ossimXmlDocument(); if ( xdoc->openFile(xmlFile) ) { ossimRadarSat2ProductDoc rsDoc; result = rsDoc.isRadarSat2(xdoc); if (result) { _productXmlFile = xmlFile; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "isRadarSat2...\n"; ossimString s; if ( rsDoc.getBeamModeMnemonic(xdoc, s) ) { ossimNotify(ossimNotifyLevel_DEBUG) << "beam_mode_mnemonic: " << s << "\n"; } if ( rsDoc.getAcquisitionType(xdoc, s) ) { ossimNotify(ossimNotifyLevel_DEBUG) << "acquisition_type: " << s << "\n"; } } // Set the base class number of lines and samples result = rsDoc.initImageSize(xdoc, theImageSize); if (result) { // Set the base class clip rect. theImageClipRect = ossimDrect( 0, 0, theImageSize.x-1, theImageSize.y-1); } // Set the sub image offset. tmp hard coded (drb). theSubImageOffset.x = 0.0; theSubImageOffset.y = 0.0; // Set the image id. if (result) { result = rsDoc.getImageId(xdoc, theImageID); } // Set the sensor ID. if (result) { result = rsDoc.getSatellite(xdoc, theSensorID); } if (result) { // Set the base class gsd: result = rsDoc.initGsd(xdoc, theGSD); } if (result) { theMeanGSD = (theGSD.x + theGSD.y)/2.0; } if (result) { result = rsDoc.getAcquistionDate(xdoc, theAcquisitionDateUTCString); } if (result) { result = rsDoc.getProductionDate(xdoc, theProductionDateUTCString); } if (result) { result = initSRGR(xdoc, rsDoc); if (result) { result = initPlatformPosition(xdoc, rsDoc); if (result) { result = initSensorParams(xdoc, rsDoc); if (result) { result = initRefPoint(xdoc, rsDoc); if (result) { result = InitRefNoiseLevel(xdoc); } } } } } } } // matches: if ( xdoc->openFile(xmlFile) ) delete xdoc; xdoc = 0; } // matches: if ( xmlFile.exists() ) if (result) { ossimSupportFilesList::instance()->add(_productXmlFile); } else { _productXmlFile = ossimFilename::NIL; } if (result) { // Assign the ossimSensorModel::theBoundGndPolygon ossimGpt ul; ossimGpt ur; ossimGpt lr; ossimGpt ll; lineSampleToWorld(theImageClipRect.ul(), ul); lineSampleToWorld(theImageClipRect.ur(), ur); lineSampleToWorld(theImageClipRect.lr(), lr); lineSampleToWorld(theImageClipRect.ll(), ll); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "theImageClipRect : " << theImageClipRect << "ul, ur, lr, ll " << ul << ", " << ur << ", " << lr << " , " << ll << endl; } setGroundRect(ul, ur, lr, ll); // ossimSensorModel method. // OSSIM preferences specifies whether a coarse grid needs to be generated: if (!createReplacementOCG()) result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } std::ostream& ossimRadarSat2Model::print(std::ostream& out) const { // Capture the original flags. std::ios_base::fmtflags f = out.flags(); out << setprecision(15) << setiosflags(ios::fixed) << "\nossimRadarSat2Model class data members:\n" << "_n_srgr: " << _n_srgr << "\n"; ossim_uint32 idx = 0; std::vector::const_iterator i = _srgr_update.begin(); while ( i != _srgr_update.end() ) { out << "sr_gr_update_" << idx << ": " << (*i) << "\n"; ++i; ++idx; } idx = 0; i = _SrGr_R0.begin(); while ( i != _SrGr_R0.end() ) { out << "sr_gr_r0_" << idx << ": " << (*i) << "\n"; ++i; ++idx; } idx = 0; std::vector< std::vector >::const_iterator i2 = _SrGr_coeffs.begin(); while ( i2 != _SrGr_coeffs.end() ) { ossim_uint32 idx2 = 0; i = (*i2).begin(); while ( i != (*i2).end() ) { out << "sr_gr_coeffs_" << idx << "_" << idx2 << ": " << (*i) << "\n"; ++i; ++idx2; } ++i2; ++idx; } ossimGeometricSarSensorModel::print(out); // Reset flags. out.setf(f); return out; } bool ossimRadarSat2Model::InitSensorParams(const ossimKeywordlist &kwl, const char *prefix) { // sensor frequencies const char* central_freq_str = kwl.find(prefix,"central_freq"); double central_freq = atof(central_freq_str); const char* fr_str = kwl.find(prefix,"fr"); double fr = atof(fr_str); const char* fa_str = kwl.find(prefix,"fa"); double fa = atof(fa_str); //number of different looks const char* n_azilok_str = kwl.find(prefix,"n_azilok"); double n_azilok = atof(n_azilok_str); const char* n_rnglok_str = kwl.find(prefix,"n_rnglok"); double n_rnglok = atof(n_rnglok_str); //ellipsoid parameters const char* ellip_maj_str = kwl.find(prefix,"ellip_maj"); double ellip_maj = atof(ellip_maj_str) * 1000.0; // km -> m const char* ellip_min_str = kwl.find(prefix,"ellip_min"); double ellip_min = atof(ellip_min_str) * 1000.0; // km -> m if(_sensor != 0) { delete _sensor; } _sensor = new SensorParams(); const char* lineTimeOrdering_str = kwl.find(prefix,"lineTimeOrdering"); std::string lineTimeOrdering(lineTimeOrdering_str) ; const char* pixelTimeOrdering_str = kwl.find(prefix,"pixelTimeOrdering"); std::string pixelTimeOrdering(pixelTimeOrdering_str) ; if (pixelTimeOrdering == "Increasing") _sensor->set_col_direction(1); else _sensor->set_col_direction(- 1); if (lineTimeOrdering == "Increasing") _sensor->set_lin_direction(1); else _sensor->set_lin_direction(- 1); const char* lookDirection_str = kwl.find(prefix,"lookDirection"); std::string lookDirection(lookDirection_str) ; if ((lookDirection == "Right")||(lookDirection == "RIGHT")) _sensor->set_sightDirection(SensorParams::Right) ; else _sensor->set_sightDirection(SensorParams::Left) ; _sensor->set_sf(fr); const double CLUM = 2.99792458e+8 ; double wave_length = CLUM / central_freq ; _sensor->set_rwl(wave_length); _sensor->set_nAzimuthLook(n_azilok); _sensor->set_nRangeLook(n_rnglok); // fa is the processing PRF _sensor->set_prf(fa * n_azilok); _sensor->set_semiMajorAxis(ellip_maj) ; _sensor->set_semiMinorAxis(ellip_min) ; return true; } bool ossimRadarSat2Model::InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix) { /* * Retrieval of ephemerisis number */ const char* neph_str = kwl.find(prefix,"neph"); int neph = atoi(neph_str); Ephemeris** ephemeris = new Ephemeris*[neph]; /* * Retrieval of ephemerisis */ for (int i=0;iset_pix_col(0); // upper left corner _refPoint->set_pix_line(0); // upper left corner const char* zeroDopplerTimeFirstLine_str = kwl.find(prefix,"zeroDopplerTimeFirstLine"); std::string zeroDopplerTimeFirstLine(zeroDopplerTimeFirstLine_str); CivilDateTime * date = new CivilDateTime() ; if (! ossim::iso8601TimeStringToCivilDate(zeroDopplerTimeFirstLine, *date)) return false ; if (_sensor->get_lin_direction() == -1) { double time = (double) date->get_second() + date->get_decimal() ; // upper left corner time += theImageSize.y / _sensor->get_prf() ; date->set_second((int) floor(time)) ; date->set_decimal(time - floor(time)) ; } delete date;//FIXME to confirm if(_platformPosition != 0) { Ephemeris * ephemeris = _platformPosition->Interpolate((JSDDateTime)*date); if (ephemeris == 0) return false ; _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else { return false; } const char* slantRangeNearEdge_str = kwl.find(prefix,"slantRangeNearEdge"); double distance = atof(slantRangeNearEdge_str); //--- // NOTE: initSRGR method must be called before this method. // in the case of Georeferenced images, the ground range is stored in // place of the slant range // (used for SlantRange computation relative to reference point, necessary // for optimization) //--- if (_isProductGeoreferenced) { if (_sensor->get_col_direction() == 1) { distance += 0.0; // upper left corner } else { distance += theImageSize.x * theGSD.x; } } _refPoint->set_distance(distance); // Ground Control Points extracted from the model std::list groundGcpCoordinates ; std::list imageGcpCoordinates ; const char* nTiePoints_str = kwl.find(prefix,"nTiePoints"); int nTiePoints = atoi(nTiePoints_str); char name[64]; for (int k=0 ; k srgr_set ; for(int j=0;j<4;j++) { sprintf(name,"SrGr_coeffs_%i_%i",i,j); const char* coeff_str = kwl.find(prefix,name); double coeff = atof(coeff_str); srgr_set.push_back(coeff); } _SrGr_coeffs.push_back(srgr_set); // SRGR polynomial reference sprintf(name,"SrGr_R0_%i",i); const char* SrGr_R0_str = kwl.find(prefix,name); _SrGr_R0.push_back(atof(SrGr_R0_str)); // SRGR update time sprintf(name,"SrGr_update_%i",i); const char* SrGr_update_str = kwl.find(prefix,name); CivilDateTime SrGr_update_date ; ossim::iso8601TimeStringToCivilDate(std::string(SrGr_update_str), SrGr_update_date) ; _srgr_update.push_back((double) SrGr_update_date.get_second()+ SrGr_update_date.get_decimal()); } return true; } int ossimRadarSat2Model::FindSRGRSetNumber(JSDDateTime date) const { if (_n_srgr==0) return(-1) ; double delays[20]; for (int i=0;i<_n_srgr;i++) { delays[i] = fabs(date.get_second()+date.get_decimal()-_srgr_update[i]) ; } int setNumber = 0 ; double min_delay = delays[0] ; for (int i=1;i<_n_srgr;i++) { if (delays[i] > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { //--- // Set the number of slant range for each ground range (srgs) // coefficients. //--- _n_srgr = static_cast(xnodes.size()); for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { ossimRefPtr node = 0; node = xnodes[i]->findFirstNode( ossimString("zeroDopplerAzimuthTime")); if (node.valid()) { CivilDateTime date; ossim::iso8601TimeStringToCivilDate(node->getText(), date); _srgr_update.push_back((double) date.get_second()+ date.get_decimal()); } node = xnodes[i]->findFirstNode( ossimString("groundRangeOrigin")); if (node.valid()) { _SrGr_R0.push_back(node->getText().toDouble()); } node = xnodes[i]->findFirstNode( ossimString("groundToSlantRangeCoefficients")); if (node.valid()) { std::vector vs; node->getText().split(vs, ' '); std::vector vd; for (ossim_uint32 idx = 0; idx < vs.size(); ++idx) { vd.push_back(vs[idx].toDouble()); } _SrGr_coeffs.push_back(vd); } } } } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimRadarSat2Model::initPlatformPosition( const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc) { static const char MODULE[] = "ossimRadarSat2Model::initPlatformPosition"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } // Initialize the platform position interpolator. if (_platformPosition) { delete _platformPosition; } _platformPosition = new PlatformPosition(); bool result = rsDoc.initPlatformPosition(xdoc, _platformPosition); if (!result) { delete _platformPosition; _platformPosition = 0; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimRadarSat2Model::initSensorParams( const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc) { static const char MODULE[] = "ossimRadarSat2Model::initSensorParams"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } if (_sensor ) { delete _sensor; } _sensor = new SensorParams(); bool result = rsDoc.initSensorParams(xdoc, _sensor); if (!result) { delete _sensor; _sensor = 0; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimRadarSat2Model::initRefPoint(const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc) { static const char MODULE[] = "ossimRadarSat2Model::initRefPoint"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } if ( !_sensor || !_platformPosition ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "null pointer error! exiting\n"; } return false; } // Reference point. if (_refPoint) { delete _refPoint; } _refPoint = new RefPoint(); // Ground Control Points extracted from the model. std::list groundGcpCoordinates; std::list imageGcpCoordinates; if ( rsDoc.initTiePoints(xdoc, groundGcpCoordinates, imageGcpCoordinates) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "initTiePoint error! exiting\n"; } return false; } if ( setModelRefPoint(groundGcpCoordinates, imageGcpCoordinates) ) { _refPoint->set_pix_col(theRefImgPt.x); _refPoint->set_pix_line(theRefImgPt.y); } else { // no reference point (e.g. scene center) is given in the annotation file // we choose to use the upper left corner as reference point _refPoint->set_pix_col(0); // upper left corner _refPoint->set_pix_line(0); // upper left corner } ossimString s; CivilDateTime date; if ( rsDoc.getZeroDopplerTimeFirstLine(xdoc, s) ) { if (! ossim::iso8601TimeStringToCivilDate(s, date)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "getZeroDopplerTimeFirstLine error! exiting\n"; } return false; } } if (_sensor->get_lin_direction() == -1) { // upper left corner double time = (double) date.get_second() + date.get_decimal(); time += theImageSize.y / _sensor->get_prf() ; date.set_second((int) floor(time)) ; date.set_decimal(time - floor(time)); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "date:\n" << date << "\n"; } JSDDateTime jsdate(date); // Ephemeris * ephemeris = _platformPosition->Interpolate((JSDDateTime)date); Ephemeris * ephemeris = _platformPosition->Interpolate(jsdate); if (ephemeris == 0) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " Interpolate error! exiting\n"; } return false; } _refPoint->set_ephemeris(ephemeris); delete ephemeris; ephemeris = 0; double distance = 1; // Only set distance to if (!_isProductGeoreferenced) { if ( !rsDoc.getSlantRangeNearEdge(xdoc, s) ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "getSlantRangeNearEdge error! exiting\n"; } return false; } distance = s.toDouble(); } //--- // in the case of Georeferenced images, the ground range is stored in // place of the slant range // (used for SlantRange computation relative to reference point, // necessary for optimization) //--- if (_isProductGeoreferenced) { if (_sensor->get_col_direction() == 1) { distance += 0 ; // upper left corner } else { distance += theImageSize.x * theGSD.x; } } _refPoint->set_distance(distance); // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates) ; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = true\n"; } return true; } bool ossimRadarSat2Model::InitLut( const ossimXmlDocument* xmlDocument, RadarSat2NoiseLevel& noise) { static const char MODULE[] = "ossimRadarSat2Model::InitLut"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } ossimString xpath; ossimString incidenceAngleCorrectionName; std::vector > xml_nodes; std::vector >::iterator node; ossimFilename lutXmlFile; incidenceAngleCorrectionName = noise.get_incidenceAngleCorrectionName(); xpath = "/product/imageAttributes/lookupTable"; xml_nodes.clear(); xmlDocument->findNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { if( (*node)->getAttributeValue("incidenceAngleCorrection") == incidenceAngleCorrectionName ) { // Get the xml file. lutXmlFile = _productXmlFile.expand().path().dirCat((*node)->getText()); if ( lutXmlFile.exists() ) { //--- // Instantiate the XML parser: //--- ossimRefPtr xmlLutDocument; xmlLutDocument = new ossimXmlDocument(); if ( xmlLutDocument.get()->openFile(lutXmlFile) ) { const ossimRefPtr lutRoot = xmlLutDocument.get()->getRoot(); //->findFirstNode("lut"); if(! lutRoot.get()) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: lut" << std::endl; } return false; } ossimString offsetVal = lutRoot->getChildTextValue("offset"); if( !offsetVal.empty()) { noise.set_offset(offsetVal.toFloat64()); } else { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: offset" << std::endl; } return false; } ossimString gainVal = lutRoot->getChildTextValue("gains"); if( !gainVal.empty()) { noise.set_gain(gainVal); } else { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: gains" << std::endl; } return false; } } } } ++node; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " leaving...\n"; } return true; } bool ossimRadarSat2Model::InitRefNoiseLevel( const ossimXmlDocument* xmlDocument) { static const char MODULE[] = "ossimRadarSat2Model::initRefNoiseLevel"; ossimString xpath; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; RadarSat2NoiseLevel ev; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } _noiseLevel.clear(); xpath = "/product/sourceAttributes/radarParameters/referenceNoiseLevel"; xml_nodes.clear(); xmlDocument->findNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { ev.set_incidenceAngleCorrectionName( (*node)->getAttributeValue("incidenceAngleCorrection") ); sub_nodes.clear(); xpath = "pixelFirstNoiseValue"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_pixelFirstNoiseValue(sub_nodes[0]->getText().toUInt32()); sub_nodes.clear(); xpath = "stepSize"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_stepSize(sub_nodes[0]->getText().toUInt32()); sub_nodes.clear(); xpath = "numberOfNoiseLevelValues"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_numberOfNoiseLevelValues(sub_nodes[0]->getText().toUInt32()); sub_nodes.clear(); xpath = "noiseLevelValues"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_units( sub_nodes[0]->getAttributeValue("units") ); std::vector s2; std::vector noiseLevelValues; s2.clear(); noiseLevelValues.clear(); s2 = sub_nodes[0]->getText().split(" "); for(ossim_uint32 i = 0; i < s2.size(); ++i) { noiseLevelValues.push_back( s2[i].toFloat64() ); } ev.set_noiseLevelValues( noiseLevelValues ); InitLut(xmlDocument, ev); _noiseLevel.push_back(ev); ++node; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " leaving...\n"; } return true; } bool ossimRadarSat2Model::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimRadarSat2Model::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = true; // Save our state: kwl.add(prefix, PRODUCT_XML_FILE_KW, _productXmlFile.c_str()); kwl.add(prefix, NUMBER_SRGR_COEFFICIENTS_KW, _n_srgr); kwl.add("support_data.", "calibration_lookup_flag", "true", true); if(! theProductionDateUTCString.empty()) kwl.add("support_data.", ossimKeywordNames::DATE_KW, theProductionDateUTCString.c_str(), true); if(! theAcquisitionDateUTCString.empty()) kwl.add("support_data.", ossimKeywordNames::IMAGE_DATE_KW, theAcquisitionDateUTCString.c_str(), true); //RK ...fix this part as part of refractoring //if(theSLC)// numBands*=2; // real and imaginary kwl.add("support_data.", ossimKeywordNames::NUMBER_BANDS_KW, 2, true); // Make sure all the arrays are equal in size. const ossim_uint32 COUNT = static_cast(_n_srgr); if ( (_srgr_update.size() == COUNT) && (_SrGr_R0.size() == COUNT) && (_SrGr_coeffs.size() == COUNT) ) { ossimString kw1 = "sr_gr_update_"; ossimString kw2 = "sr_gr_r0_"; ossimString kw3 = "sr_gr_coeffs_"; for(ossim_uint32 i = 0; i < COUNT; ++i) { ossimString iStr = ossimString::toString(i); ossimString kw = kw1; kw += iStr; kwl.add(prefix, kw, _srgr_update[i]); kw = kw2; kw += iStr; kwl.add(prefix, kw, _SrGr_R0[i]); for (ossim_uint32 j = 0; j < _SrGr_coeffs[i].size(); ++j) { ossimString jStr = ossimString::toString(j); kw = kw3; kw += iStr; kw += "_"; kw += jStr; kwl.add(prefix, kw,_SrGr_coeffs[i][j]); } } } else { result = false; } if (result) { // Call base save state: result = ossimGeometricSarSensorModel::saveState(kwl, prefix); } if (result) { for(ossim_uint32 i = 0; i < _noiseLevel.size(); ++i) { _noiseLevel[i].saveState(kwl, prefix); } } //--- // Uncomment to force load from product file instead of loadState. //--- //if (result) //{ // kwl.add(prefix, LOAD_FROM_PRODUCT_FILE_KW, "true"); //} if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimRadarSat2Model::loadState (const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimRadarSat2Model::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } const char* lookup = 0; ossimString s; // Check the type first. lookup = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (lookup) { s = lookup; if (s != getClassName()) { return false; } } // Get the product.xml file name. lookup = kwl.find(prefix, PRODUCT_XML_FILE_KW); if (lookup) { _productXmlFile = lookup; // See if caller wants to load from xml vice keyword list. lookup = kwl.find(prefix, LOAD_FROM_PRODUCT_FILE_KW); if (lookup) { s = lookup; if ( s.toBool() ) { // Loading from product.xml file. return open(_productXmlFile); } } } //--- // Temp: This must be cleared or you end up with a bounding rect of all // zero's. //--- theBoundGndPolygon.clear(); // Load the base class. bool result = ossimGeometricSarSensorModel::loadState(kwl, prefix); if (result) { lookup = kwl.find(prefix, NUMBER_SRGR_COEFFICIENTS_KW); if (lookup) { s = lookup; _n_srgr = s.toInt(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << NUMBER_SRGR_COEFFICIENTS_KW << "\n"; } result = false; } if (result && _n_srgr) { const ossim_uint32 COUNT = static_cast(_n_srgr); _srgr_update.resize(COUNT); _SrGr_R0.resize(COUNT); _SrGr_coeffs.resize(COUNT); ossimString kw1 = "sr_gr_update_"; ossimString kw2 = "sr_gr_r0_"; ossimString kw3 = "sr_gr_coeffs_"; for(ossim_uint32 i = 0; i < COUNT; ++i) { ossimString kw; ossimString iStr = ossimString::toString(i); // Get the _srgr_update's. kw = kw1; kw += iStr; lookup = kwl.find(prefix, kw); if (lookup) { s = lookup; _srgr_update[i] = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << kw << "\n"; } result = false; } // Get the sr_gr_r0_'s. kw = kw2; kw += iStr; lookup = kwl.find(prefix, kw); if (lookup) { s = lookup; _SrGr_R0[i] = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << kw << "\n"; } result = false; } //--- // Get the _SrGr_coeffs. // Note we are assuming a count of 6. //--- const ossim_uint32 COEFFS_COUNT = 6; _SrGr_coeffs[i].resize(COEFFS_COUNT); for (ossim_uint32 j = 0; j < COEFFS_COUNT; ++j) { ossimString jStr = ossimString::toString(j); kw = kw3; kw += iStr; kw += "_"; kw += jStr; lookup = kwl.find(prefix, kw); if (lookup) { s = lookup; _SrGr_coeffs[i][j] = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << kw << "\n"; } result = false; } } } // matches: for(ossim_uint32 i = 0; i < COUNT; ++i) } // matches: if (_n_srgr) else { result = false; } } // matches: if (result) if(result) { for(ossim_uint32 i = 0; i < _noiseLevel.size(); ++i) { _noiseLevel[i].loadState(kwl, prefix); } } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimRadarSat2Model::setModelRefPoint( const std::list& groundGcpCoordinates, const std::list& imageGcpCoordinates) { static const char MODULE[] = "ossimRadarSat2Model::setModelRefPoint"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = false; if ( !theImageSize.hasNans() && (groundGcpCoordinates.size() == imageGcpCoordinates.size()) ) { const ossim_float64 THRESHOLD = 1.0; ossimDpt center; center.x = theImageSize.x / 2.0; center.y = theImageSize.y / 2.0; std::list::const_iterator gi = groundGcpCoordinates.begin(); std::list::const_iterator di = imageGcpCoordinates.begin(); while( gi != groundGcpCoordinates.end() ) { // Find the image point within one pixel of center. ossim_float64 deltaX = std::fabs( (*di).x - center.x); ossim_float64 deltaY = std::fabs( (*di).y - center.y); if ( (deltaX <= THRESHOLD) && (deltaY <= THRESHOLD) ) { theRefImgPt = (*di); theRefGndPt = (*gi); result = true; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "image reference point: " << theRefImgPt << "\nground reference point: " << theRefGndPt << "\n"; } break; } ++gi; ++di; } // matches: while( gi != groundGcpCoordinates.end() ) } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2Model.h000066400000000000000000000131771301006202600274760ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimRadarSat2Model_H #define ossimRadarSat2Model_H 1 #include #include #include #include #include #include #include #include #include #include #include class ossimFilename; class ossimString; class ossimXmlDocument; namespace ossimplugins { class ossimRadarSat2ProductDoc; class PlatformPosition; class SensorParams; class RefPoint; /** * @brief This class allows for direct localisation and indirect localisation * using the RadarSat2 sensor model */ class OSSIM_PLUGINS_DLL ossimRadarSat2Model : public ossimGeometricSarSensorModel { public: /** @brief default constructor */ ossimRadarSat2Model(); /** @brief copy constructor */ ossimRadarSat2Model(const ossimRadarSat2Model& rhs); /** @brief Destructor */ virtual ~ossimRadarSat2Model(); /** * @brief Method to return the class name. * @return The name of this class. */ virtual ossimString getClassName() const; /** * @brief Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /** * @brief This function associates an image column number to a slant range * when the image is georeferenced (ground projected) * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const; /** * @brief Method to intantial model from a file. Attempts to find the * required xml file. * * @param file * * @return true on success, false on error. */ bool open(const ossimFilename& file); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; private: virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefNoiseLevel(const ossimXmlDocument* xmlDocument); virtual bool InitLut( const ossimXmlDocument* xmlDocument, RadarSat2NoiseLevel& noise); /** * @brief Initializes the Slant Range to Ground Range data sets : * _srgr_update,_SrGr_R0,_SrGr_coeffs_number,_SrGr_coeffs,_nbCol, * _pixel_spacing */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Finds the SRGR data set which update time is the closest * to the center scene time */ int FindSRGRSetNumber(JSDDateTime date) const; /** * @note This method must be called before initRefPoint. */ bool initSRGR(const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc); bool initPlatformPosition(const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc); bool initSensorParams(const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc); /** * @brief Method to initialize RefPoint object from * RadarSat "product.xml" file. * @param xdoc Opened product.xml file. * @return true on success, false on error. */ bool initRefPoint(const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc); /** * @brief Sets ossimSensorModel members theRefImgPt and theRefGndPt from * tie points. * @param groundGcpCoordinates Ground tie points. * @param imageGcpCoordinates Image tie points. * @return true on success, false on error. */ bool setModelRefPoint(const std::list& groundGcpCoordinates, const std::list& imageGcpCoordinates); /** * @brief Slant Range FOR EACH Ground Range (SRGR) number of coefficients * sets */ int _n_srgr; //RK remove this part soon and use kwl directly. ossimString theAcquisitionDateUTCString; ossimString theProductionDateUTCString; /** * @brief Slant Range FOR EACH Ground Range coefficient sets update times */ std::vector _srgr_update; /** * @brief Slant Range FOR EACH Ground Range Projection reference point */ std::vector _SrGr_R0 ; /** * @brief Slant Range FOR EACH Ground Range Projection coefficients */ std::vector< std::vector > _SrGr_coeffs ; /** * @brief noise level values */ std::vector< RadarSat2NoiseLevel > _noiseLevel ; TYPE_DATA }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2ProductDoc.cpp000066400000000000000000001070271301006202600310350ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Description: Utility class to encapsulate parsing RadarSat2 product.xml // file. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; namespace ossimplugins { // Static trace for debugging static ossimTrace traceDebug("ossimRadarSat2ProductDoc:debug"); ossimRadarSat2ProductDoc::ossimRadarSat2ProductDoc() { } ossimRadarSat2ProductDoc::~ossimRadarSat2ProductDoc() { } bool ossimRadarSat2ProductDoc::isRadarSat2(const ossimXmlDocument* xdoc) const { bool result = false; if (xdoc) { ossimString s; getSatellite(xdoc, s); if (s.upcase() == "RADARSAT-2") { result = true; } } return result; } bool ossimRadarSat2ProductDoc::initPlatformPosition( const ossimXmlDocument* xdoc, PlatformPosition* pos) const { static const char MODULE[] = "ossimRadarSat2ProductDoc::initPlatformPosition"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = true; if ( xdoc && pos ) { // Get all the stateVector nodes. ossimString path = "/product/sourceAttributes/orbitAndAttitude/orbitInformation/stateVector"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { const std::vector >::size_type COUNT = xnodes.size(); Ephemeris** ephemeris = new Ephemeris*[COUNT]; int nbrData = 0; // to keep track of good stateVector count. ossimRefPtr svNode = 0; // stateVector node for (ossim_uint32 i = 0 ; i < COUNT; ++i) { svNode = xnodes[i]; if ( !svNode ) { result = false; break; } double pos[3]; double vit[3]; CivilDateTime eph_civil_date; ossimString s; path = "timeStamp"; result = ossim::findFirstNode(path, svNode, s); if (result) { ossim::iso8601TimeStringToCivilDate(s, eph_civil_date); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "xPosition"; result = ossim::findFirstNode(path, svNode, s); if (result) { pos[0] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "yPosition"; result = ossim::findFirstNode(path, svNode, s); if (result) { pos[1] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "zPosition"; result = ossim::findFirstNode(path, svNode, s); if (result) { pos[2] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "xVelocity"; result = ossim::findFirstNode(path, svNode, s); if (result) { vit[0] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "yVelocity"; result = ossim::findFirstNode(path, svNode, s); if (result) { vit[1] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "zVelocity"; result = ossim::findFirstNode(path, svNode, s); if (result) { vit[2] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } JSDDateTime eph_jsd_date(eph_civil_date); GeographicEphemeris* eph = new GeographicEphemeris(eph_jsd_date, pos, vit); ephemeris[i] = eph; ++nbrData; } // matches: for (int i = 0 ; i < nbrData; ++i) if (result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << " DEBUG\nnbrData: " << nbrData << "\n"; } pos->setData(ephemeris, nbrData); } else { for (int idx = 0; idx < nbrData; ++idx) { delete ephemeris[idx]; } delete [] ephemeris; ephemeris = 0; } } // matches: if ( xnodes.size() ) else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNodes not found: " << path << std::endl; } } // matches: if (xdoc && pos) else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true\n":"false\n"); } return result; } bool ossimRadarSat2ProductDoc::initSensorParams(const ossimXmlDocument* xdoc, SensorParams* sp) const { bool result = true; if (xdoc && sp) { ossimString s; // Get the number of azimuth looks. if ( getNumberOfAzimuthLooks(xdoc, s) ) { sp->set_nAzimuthLook(s.toDouble()); } else { result = false; } //--- // drb ??? // Get the nominal PRF //--- double prf; if ( getNominalPrf(xdoc, prf) ) { //sp->set_prf(prf * sp->get_nAzimuthLook() ); sp->set_prf(prf); } else { result = false; } // Get the Sampling frequency. if ( getAdcSamplingRate(xdoc, s) ) { sp->set_sf(s.toDouble()); } else { result = false; } // Get the radar wave length. if ( getRadarCenterFrequency(xdoc, s) ) { const double CLUM = 2.99792458e+8 ; double waveLength = CLUM / s.toDouble(); sp->set_rwl(waveLength); } else { result = false; } // Get columns direction (1=increasing, -1=decreasing). if ( getLineTimeOrdering(xdoc, s) ) { if (s.downcase() == "increasing") { sp->set_col_direction(1); } else { sp->set_col_direction(-1); } } else { result = false; } // Get lines direction (1=increasing, -1=decreasing). if ( getPixelTimeOrdering(xdoc, s) ) { if (s.downcase() == "increasing") { sp->set_lin_direction(1); } else { sp->set_lin_direction(-1); } } else { result = false; } // Get the antenna pointing direction. if ( getAntennaPointing(xdoc, s) ) { if ( s.downcase() == "right") { sp->set_sightDirection(SensorParams::Right); } else { sp->set_sightDirection(SensorParams::Left); } } else { result = false; } // Get the ellipsoid semi_major axis, m, Default : WGS84 if ( getSemiMajorAxis(xdoc, s) ) { sp->set_semiMajorAxis(s.toDouble()); } else { result = false; } // Get the ellipsoid semi_minor axis, m, Default : WGS84 if ( getSemiMinorAxis(xdoc, s) ) { sp->set_semiMinorAxis(s.toDouble()); } else { result = false; } // Get the number of range looks. if ( getNumberOfRangeLooks(xdoc, s) ) { sp->set_nRangeLook(s.toDouble()); } else { result = false; } } // matches: if (xdoc && sp) else { result = false; } return result; } bool ossimRadarSat2ProductDoc::initImageSize(const ossimXmlDocument* xdoc, ossimIpt& imageSize) const { bool result = true; if (xdoc) { ossimString s; if ( getNumberOfSamplesPerLine(xdoc, s) ) { imageSize.x = static_cast(s.toFloat64()); } else { result = false; } if ( getNumberOfLines(xdoc, s) ) { imageSize.y = static_cast(s.toFloat64()); } else { result = false; } } else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRadarSat2ProductDoc::initImageSize DEBUG:\nimage size: " << imageSize << "\nexit status = " << (result?"true":"false") << std::endl; } return result; } bool ossimRadarSat2ProductDoc::initGsd(const ossimXmlDocument* xdoc, ossimDpt& gsd) const { bool result = true; if (xdoc) { ossimString s; if ( getSampledPixelSpacing(xdoc, s) ) { gsd.x = ossimString::toFloat64(s); } else { result = false; } if ( getSampledLineSpacing(xdoc, s) ) { gsd.y = ossimString::toFloat64(s); } else { result = false; } } else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRadarSat2ProductDoc::initGsd DEBUG:\ngsd: " << gsd << "\nexit status = " << (result?"true":"false") << std::endl; } return result; } bool ossimRadarSat2ProductDoc::getAcquistionDate(const ossimXmlDocument* xdoc, ossimString& adate) { ossimString path = "/product/sourceAttributes/rawDataStartTime"; return ossim::getPath(path, xdoc, adate); } bool ossimRadarSat2ProductDoc::getProductionDate(const ossimXmlDocument* xdoc, ossimString& pdate) { ossimString path = "/product/imageGenerationParameters/generalProcessingInformation/processingTime"; return ossim::getPath(path, xdoc, pdate); } bool ossimRadarSat2ProductDoc::initTiePoints(const ossimXmlDocument* xdoc, std::list& gcp, std::list& icp) const { static const char MODULE[] = "ossimRadarSat2ProductDoc::initTiePoints"; bool result = true; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:\n"; } if (xdoc) { ossimString path = "/product/imageAttributes/geographicInformation/geolocationGrid/imageTiePoint"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { ossimRefPtr icNode = 0; // imageCoordinate icNode = xnodes[i]->findFirstNode(ossimString("imageCoordinate")); if (icNode.valid()) { ossimString s; ossimDpt dpt; result = ossim::findFirstNode(ossimString("line"), icNode, s); if (result) { dpt.y = s.toDouble(); } result = ossim::findFirstNode(ossimString("pixel"), icNode, s); if (result) { dpt.x = s.toDouble(); } icp.push_back(dpt); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "dpt" << i << ": " << dpt << "\n"; } } else { result = false; } ossimRefPtr gcNode = 0; // geodeticCoordinate gcNode = xnodes[i]->findFirstNode( ossimString("geodeticCoordinate")); if (gcNode.valid()) { ossimString s; ossimGpt gpt; result = ossim::findFirstNode(ossimString("latitude"), gcNode, s); if (result) { gpt.lat = s.toDouble(); } result = ossim::findFirstNode(ossimString("longitude"), gcNode, s); if (result) { gpt.lon = s.toDouble(); } result = ossim::findFirstNode(ossimString("height"), gcNode, s); if (result) { gpt.hgt = s.toDouble(); } gcp.push_back(gpt); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "gpt" << i << ": " << gpt << "\n"; } } // matches: if (gcNode.valid()) else { result = false; } } // if (xnodes[i].valid()) } // mathches: for (ossim_uint32 i = 0; i < xnodes.size(); ++i) } // matches: if ( xnodes.size() ) else { result = false; // No nodes found. } } // matches: if (xdoc) else { result = false; // Null pointer passed in. } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: exit status = " << (result?"true":"false") << std::endl; } return result; } RPCModel ossimRadarSat2ProductDoc::getRpcData(const ossimXmlDocument* xdoc) const { ossimString path = "/product/imageAttributes/geographicInformation/rationalFunctions/satellite"; RPCModel model; ossimString searchbiasError = "/product/imageAttributes/geographicInformation/rationalFunctions/biasError"; //the line (y-coordinate) ossimString searchrandomError = "/product/imageAttributes/geographicInformation/rationalFunctions/randomError"; //the line (y-coordinate) ossimString searchlineFitQuality = "/product/imageAttributes/geographicInformation/rationalFunctions/lineFitQuality"; //the line (y-coordinate) ossimString searchpixelFitQuality = "/product/imageAttributes/geographicInformation/rationalFunctions/pixelFitQuality"; //the line (y-coordinate) ossimString searchlineOffset = "/product/imageAttributes/geographicInformation/rationalFunctions/lineOffset"; //the line (y-coordinate) ossimString searchpixelOffset = "/product/imageAttributes/geographicInformation/rationalFunctions/pixelOffset"; //the line (y-coordinate) ossimString searchlatitudeOffset = "/product/imageAttributes/geographicInformation/rationalFunctions/latitudeOffset"; //the line (y-coordinate) ossimString searchlongitudeOffset = "/product/imageAttributes/geographicInformation/rationalFunctions/longitudeOffset"; //the line (y-coordinate) ossimString searchheightOffset = "/product/imageAttributes/geographicInformation/rationalFunctions/heightOffset"; //the line (y-coordinate) ossimString searchlineScale = "/product/imageAttributes/geographicInformation/rationalFunctions/lineScale"; //the line (y-coordinate) ossimString searchpixelScale = "/product/imageAttributes/geographicInformation/rationalFunctions/pixelScale"; //the line (y-coordinate) ossimString searchlatitudeScale = "/product/imageAttributes/geographicInformation/rationalFunctions/latitudeScale"; //the line (y-coordinate) ossimString searchlongitudeScale = "/product/imageAttributes/geographicInformation/rationalFunctions/longitudeScale"; //the line (y-coordinate) ossimString searchheightScale = "/product/imageAttributes/geographicInformation/rationalFunctions/heightScale"; //the line (y-coordinate) ossimString searchlineNumeratorCoefficients = "/product/imageAttributes/geographicInformation/rationalFunctions/lineNumeratorCoefficients"; //the line (y-coordinate) ossimString searchlineDenominatorCoefficients = "/product/imageAttributes/geographicInformation/rationalFunctions/lineDenominatorCoefficients"; //the line (y-coordinate) ossimString searchpixelNumeratorCoefficients = "/product/imageAttributes/geographicInformation/rationalFunctions/pixelNumeratorCoefficients"; //the line (y-coordinate) ossimString searchpixelDenominatorCoefficients = "/product/imageAttributes/geographicInformation/rationalFunctions/pixelDenominatorCoefficients"; //the line (y-coordinate) // strings to hold values found ossimString biasErrorStr;; ossimString randomErrorStr; ossimString lineFitQualityStr; ossimString pixelFitQualityStr; ossimString lineOffsetStr; ossimString pixelOffsetStr; ossimString latitudeOffsetStr; ossimString longitudeOffsetStr; ossimString heightOffsetStr; ossimString lineScaleStr; ossimString pixelScaleStr; ossimString latitudeScaleStr; ossimString longitudeScaleStr; ossimString heightScaleStr; std::vector lineNumeratorCoefficientsStr; std::vector lineDenominatorCoefficientsStr; std::vector pixelNumeratorCoefficientsStr; std::vector pixelDenominatorCoefficientsStr; // doubles to hold values found double biasError = 0; double randomError = 0; double lineFitQuality = 0; double pixelFitQuality = 0; double lineOffset = 0; double pixelOffset = 0; double latitudeOffset = 0; double longitudeOffset = 0; double heightOffset = 0; double lineScale = 0; double pixelScale = 0; double latitudeScale = 0; double longitudeScale = 0; double heightScale = 0; vector lineNumeratorCoefficients = vector(20,0); vector lineDenominatorCoefficients = vector(20,0); vector pixelNumeratorCoefficients = vector(20,0); vector pixelDenominatorCoefficients = vector(20,0); //the final string outputs to the text file //check if this function is being called on the correct SAR data type //function is only applicable for RS2 product.xml files bool rs2Check = isRadarSat2(xdoc); if (rs2Check) { if (!ossim::getPath(searchbiasError, xdoc, biasErrorStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; biasError = biasErrorStr.toDouble(); if (!ossim::getPath(searchrandomError, xdoc, randomErrorStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; randomError = randomErrorStr.toDouble(); if (!ossim::getPath(searchlineFitQuality, xdoc, lineFitQualityStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; lineFitQuality = lineFitQualityStr.toDouble(); if (!ossim::getPath(searchpixelFitQuality, xdoc, pixelFitQualityStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; pixelFitQuality = pixelFitQualityStr.toDouble(); if (!ossim::getPath(searchlineOffset, xdoc, lineOffsetStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; lineOffset = lineOffsetStr.toDouble(); if (!ossim::getPath(searchpixelOffset, xdoc, pixelOffsetStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; pixelOffset = pixelOffsetStr.toDouble(); if (!ossim::getPath(searchlatitudeOffset, xdoc, latitudeOffsetStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; latitudeOffset = latitudeOffsetStr.toDouble(); if (!ossim::getPath(searchlongitudeOffset, xdoc, longitudeOffsetStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; longitudeOffset = longitudeOffsetStr.toDouble(); if (!ossim::getPath(searchheightOffset, xdoc, heightOffsetStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; heightOffset = heightOffsetStr.toDouble(); // -------------- if (!ossim::getPath(searchlineScale, xdoc, lineScaleStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; lineScale = lineScaleStr.toDouble(); if (!ossim::getPath(searchpixelScale, xdoc, pixelScaleStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; pixelScale = pixelScaleStr.toDouble(); if (!ossim::getPath(searchlatitudeScale, xdoc, latitudeScaleStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; latitudeScale = latitudeScaleStr.toDouble(); // ----------------------- if (!ossim::getPath(searchlongitudeScale, xdoc, longitudeScaleStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; longitudeScale = longitudeScaleStr.toDouble(); if (!ossim::getPath(searchheightScale, xdoc, heightScaleStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; heightScale = heightScaleStr.toDouble(); // ---- parameters for reading in coeefs ------------ double val=0; // ------------------------------------- if (!ossim::getPath(searchlineNumeratorCoefficients, xdoc, lineNumeratorCoefficientsStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; string lineNumeratorCoefficientsStr_N = lineNumeratorCoefficientsStr[0]; // place into a stream std::stringstream LNstream(lineNumeratorCoefficientsStr_N); for (int i=0; i < 20; i ++) { LNstream >> val; lineNumeratorCoefficients[i] = val; } // ------------------ if (!ossim::getPath(searchlineDenominatorCoefficients, xdoc, lineDenominatorCoefficientsStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; string lineDenominatorCoefficientsStr_N = lineDenominatorCoefficientsStr[0]; // place into a stream std::stringstream LDstream(lineDenominatorCoefficientsStr_N); for (int i=0; i < 20; i ++) { LDstream >> val; lineDenominatorCoefficients[i] = val; } // ------------------ if (!ossim::getPath(searchpixelNumeratorCoefficients, xdoc, pixelNumeratorCoefficientsStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; string pixelNumeratorCoefficientsStr_N = pixelNumeratorCoefficientsStr[0]; // place into a stream std::stringstream PNstream(pixelNumeratorCoefficientsStr_N); for (int i=0; i < 20; i ++) { PNstream >> val; pixelNumeratorCoefficients[i] = val; } // ------------------ if (!ossim::getPath(searchpixelDenominatorCoefficients, xdoc, pixelDenominatorCoefficientsStr)) ossimNotify(ossimNotifyLevel_WARN) << "ERROR: UNABLE TO FIND RS2 RPC COEFFICIENT INFORMATION" << endl; string pixelDenominatorCoefficientsStr_N = pixelDenominatorCoefficientsStr[0]; // place into a stream std::stringstream PDstream(pixelDenominatorCoefficientsStr_N); for (int i=0; i < 20; i ++) { PDstream >> val; pixelDenominatorCoefficients[i] = val; } // end character search term model.biasError = biasError; model.randomError = randomError; model.lineFitQuality = lineFitQuality; model.pixelFitQuality = pixelFitQuality; model.lineOffset = lineOffset; model.pixelOffset = pixelOffset; model.latitudeOffset = latitudeOffset; model.longitudeOffset = longitudeOffset; model.heightOffset = heightOffset; model.lineScale = lineScale; model.pixelScale = pixelScale; model.latitudeScale = latitudeScale; model.longitudeScale = longitudeScale; model.heightScale = heightScale; model.lineNumeratorCoefficients = lineNumeratorCoefficients; model.lineDenominatorCoefficients = lineDenominatorCoefficients; model.pixelNumeratorCoefficients = pixelNumeratorCoefficients; model.pixelDenominatorCoefficients = pixelDenominatorCoefficients; } return model; } bool ossimRadarSat2ProductDoc::getSatellite(const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/satellite"; // The saved File is an ossimKeywordlist return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getSensor(const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/sensor"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getBeamModeMnemonic( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/beamModeMnemonic"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getImageId(const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/imageId"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getImageFile(const ossimXmlDocument* xdoc, ossimString& s) const { bool result = false; ossimString fileName; ossimString path = "/product/imageAttributes/fullResolutionImageData"; if ( ossim::getPath(path, xdoc, fileName) ) { result = true; s = fileName; } return result; } bool ossimRadarSat2ProductDoc::getAcquisitionType( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/radarParameters/acquisitionType"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getRadarCenterFrequency( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/radarParameters/radarCenterFrequency"; return ossim::getPath(path, xdoc, s); } //--- // drb ??? // // Temporary until we decide how to get nominal prf from multiple nodes. // drb - 15 April 2009 //--- bool ossimRadarSat2ProductDoc::getNominalPrf(const ossimXmlDocument* xdoc, double& prf) const { bool result = false; std::vector v; if ( getPulseRepetitionFrequency(xdoc, v) ) { if (v.size()) { double d = 0; std::vector::const_iterator i = v.begin(); while (i < v.end()) { d += (*i).toDouble(); ++i; } prf = d / v.size(); result = true; } } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRadarSat2ProductDoc::getNominalPrf DEBUG:\nprf = " << prf << "\nexit status = " << (result?"true":"false") << std::endl; } return result; } bool ossimRadarSat2ProductDoc::getPulseRepetitionFrequency( const ossimXmlDocument* xdoc, std::vector& v) const { ossimString path = "/product/sourceAttributes/radarParameters/pulseRepetitionFrequency"; return ossim::getPath(path, xdoc, v); } bool ossimRadarSat2ProductDoc::getAntennaPointing( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/radarParameters/antennaPointing"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getAdcSamplingRate( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/radarParameters/adcSamplingRate"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getPassDirection( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/sourceAttributes/orbitAndAttitude/orbitInformation/passDirection"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getProductType( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/generalProcessingInformation/productType"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getZeroDopplerTimeFirstLine( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/sarProcessingInformation/zeroDopplerTimeFirstLine"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getNumberOfRangeLooks( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/sarProcessingInformation/numberOfRangeLooks"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getNumberOfAzimuthLooks( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/sarProcessingInformation/numberOfAzimuthLooks"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getSlantRangeNearEdge( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/sarProcessingInformation/slantRangeNearEdge"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getZeroDopplerAzimuthTime( const ossimXmlDocument* xdoc, std::vector& v) const { ossimString path = "/product/imageGenerationParameters/slantRangeToGroundRange/zeroDopplerAzimuthTime"; return ossim::getPath(path, xdoc, v); } bool ossimRadarSat2ProductDoc::getGroundRangeOrigin( const ossimXmlDocument* xdoc, std::vector& v) const { ossimString path = "/product/imageGenerationParameters/slantRangeToGroundRange/groundRangeOrigin"; return ossim::getPath(path, xdoc, v); } bool ossimRadarSat2ProductDoc::getGroundToSlantRangeCoefficients( const ossimXmlDocument* xdoc, std::vector& v) const { ossimString path = "/product/imageGenerationParameters/slantRangeToGroundRange/groundToSlantRangeCoefficients"; return ossim::getPath(path, xdoc, v); } bool ossimRadarSat2ProductDoc::getSemiMajorAxis( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/geographicInformation/referenceEllipsoidParameters/semiMajorAxis"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getSemiMinorAxis( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/geographicInformation/referenceEllipsoidParameters/semiMinorAxis"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getNumberOfSamplesPerLine( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/rasterAttributes/numberOfSamplesPerLine"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getNumberOfLines( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/rasterAttributes/numberOfLines"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getSampledPixelSpacing( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/rasterAttributes/sampledPixelSpacing"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getSampledLineSpacing( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/rasterAttributes/sampledLineSpacing"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getLineTimeOrdering( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/rasterAttributes/lineTimeOrdering"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getPixelTimeOrdering( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/rasterAttributes/pixelTimeOrdering"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getIncidenceAngleNearRange( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/sarProcessingInformation/incidenceAngleNearRange"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getIncidenceAngleFarRange( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/sarProcessingInformation/incidenceAngleFarRange "; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getSatelliteHeight( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageGenerationParameters/sarProcessingInformation/satelliteHeight"; return ossim::getPath(path, xdoc, s); } bool ossimRadarSat2ProductDoc::getGeodeticTerrainHeight( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/product/imageAttributes/geographicInformation/referenceEllipsoidParameters/geodeticTerrainHeight"; return ossim::getPath(path, xdoc, s); } } // matches: namespace ossimplugins OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2ProductDoc.h000066400000000000000000000166631301006202600305070ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Description: Utility class to encapsulate parsing RadarSat2 product.xml // file. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimRadarSat2ProductDoc_HEADER #define ossimRadarSat2ProductDoc_HEADER 1 #include #include #include #include #include #include #include class ossimDpt; class ossimGpt; class ossimIpt; class ossimXmlDocument; class ossimXmlNode; class ossimString; typedef struct { double biasError; double randomError; double lineFitQuality; double pixelFitQuality; double lineOffset; double pixelOffset; double latitudeOffset; double longitudeOffset; double heightOffset; double lineScale; double pixelScale; double latitudeScale; double longitudeScale; double heightScale; std::vector lineNumeratorCoefficients; std::vector lineDenominatorCoefficients; std::vector pixelNumeratorCoefficients; std::vector pixelDenominatorCoefficients; }RPCModel; namespace ossimplugins { class PlatformPosition; class RefPoint; class SensorParams; /** @brief Class to encapsulate parsing RadarSat2 product.xml file. */ class OSSIM_PLUGINS_DLL ossimRadarSat2ProductDoc { public: /** @brief default constructor */ ossimRadarSat2ProductDoc(); /** @brief destructor */ ~ossimRadarSat2ProductDoc(); /** * @brief Checks for node /product/sourceAttributes/satellite containing * RADARSAT-2. * * @return true if present, false if not. */ bool isRadarSat2(const ossimXmlDocument* xdoc) const; RPCModel getRpcData(const ossimXmlDocument* xdoc) const; /** * @brief Method to initialize PlatformPosition object from * RadarSat "product.xml" file. * @param xdoc Opened product.xml file. * @param pos Pointer to PlatformPosition object. * @return true on success, false on error. */ bool initPlatformPosition(const ossimXmlDocument* xdoc, PlatformPosition* pos) const; /** * @brief Method to initialize SensorParams object from * RadarSat "product.xml" file. * @param xdoc Opened product.xml file. * @param sp Pointer to SensorParams object. * @return true on success, false on error. */ bool initSensorParams(const ossimXmlDocument* xdoc, SensorParams* sp) const; /** * @brief Method to initialize image size from * RadarSat "product.xml" file. * @param xdoc Opened product.xml file. * @param imageSize The point to initialize. * @return true on success, false on error. */ bool initImageSize(const ossimXmlDocument* xdoc, ossimIpt& imageSize) const; /** * @brief Method to initialize gsd from * RadarSat "product.xml" file. * @param xdoc Opened product.xml file. * @param gsd The point to initialize. * @return true on success, false on error. */ bool initGsd(const ossimXmlDocument* xdoc, ossimDpt& gsd) const; bool getAcquistionDate(const ossimXmlDocument* xdoc, ossimString& adate); bool getProductionDate(const ossimXmlDocument* xdoc, ossimString& pdate); /** * @brief Method to initialize image tie points from * RadarSat "product.xml" file. * @param xdoc Opened product.xml file. * @param imageSize The point to initialize. * @return true on success, false on error. */ bool initTiePoints(const ossimXmlDocument* xdoc, std::list& gcp, std::list& icp) const; bool getSatellite(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSensor(const ossimXmlDocument* xdoc, ossimString& s) const; /** /product/sourceAttributes/beamModeMnemonic */ bool getBeamModeMnemonic(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageId(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageFile(const ossimXmlDocument* xdoc, ossimString& s) const; /** /product/sourceAttributes/radarParameters/acquisitionType */ bool getAcquisitionType(const ossimXmlDocument* xdoc, ossimString& s) const; bool getRadarCenterFrequency(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNominalPrf(const ossimXmlDocument* xdoc, double& prf) const; bool getPulseRepetitionFrequency(const ossimXmlDocument* xdoc, std::vector& v) const; bool getAntennaPointing(const ossimXmlDocument* xdoc, ossimString& s) const; bool getAdcSamplingRate(const ossimXmlDocument* xdoc, ossimString& s) const; bool getPassDirection(const ossimXmlDocument* xdoc, ossimString& s) const; bool getProductType(const ossimXmlDocument* xdoc, ossimString& s) const; bool getZeroDopplerTimeFirstLine(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfRangeLooks(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfAzimuthLooks(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSlantRangeNearEdge(const ossimXmlDocument* xdoc, ossimString& s) const; bool getZeroDopplerAzimuthTime(const ossimXmlDocument* xdoc, std::vector& v) const; bool getGroundRangeOrigin(const ossimXmlDocument* xdoc, std::vector& v) const; bool getGroundToSlantRangeCoefficients(const ossimXmlDocument* xdoc, std::vector& v) const; bool getSemiMajorAxis(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSemiMinorAxis(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfSamplesPerLine(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfLines(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSampledPixelSpacing(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSampledLineSpacing(const ossimXmlDocument* xdoc, ossimString& s) const; bool getLineTimeOrdering(const ossimXmlDocument* xdoc, ossimString& s) const; bool getPixelTimeOrdering(const ossimXmlDocument* xdoc, ossimString& s) const; bool getGeodeticTerrainHeight(const ossimXmlDocument* xdoc, ossimString& s) const; bool getIncidenceAngleNearRange(const ossimXmlDocument* xdoc, ossimString& s) const; bool getIncidenceAngleFarRange(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSatelliteHeight(const ossimXmlDocument* xdoc, ossimString& s) const; }; } #endif /* matches: #ifndef ossimRadarSat2ProductDoc_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2RPCModel.cpp000066400000000000000000000422001301006202600303630ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { // Keyword constants: static const char LOAD_FROM_PRODUCT_FILE_KW[] = "load_from_product_file_flag"; static const char PRODUCT_XML_FILE_KW[] = "product_xml_filename"; // Static trace for debugging static ossimTrace traceDebug("ossimRadarSat2RPCModel:debug"); RTTI_DEF1(ossimRadarSat2RPCModel, "ossimRadarSat2RPCModel", ossimRpcModel); ossimRadarSat2RPCModel::ossimRadarSat2RPCModel() : ossimRpcModel(), theDecimation(1.0), theProductXmlFile(ossimFilename::NIL) { } ossimRadarSat2RPCModel::ossimRadarSat2RPCModel(const ossimRadarSat2RPCModel& rhs) : ossimRpcModel(rhs), theDecimation(1.0), theProductXmlFile(rhs.theProductXmlFile) { } //***************************************************************************** // CONSTRUCTOR: ossimRadarSat2RPCModel // // Constructs given filename for RS2 product.xml file // //***************************************************************************** ossimRadarSat2RPCModel::ossimRadarSat2RPCModel(const ossimFilename& RS2File) :ossimRpcModel(), theDecimation(1.0) { // Open the XML file, and read the RPC values in. if (!open(RS2File)) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRadarSat2RPCModel::ossimRadarSat2RPCModel(RS2File): Unable to parse file " << RS2File << std::endl; } } ossimRadarSat2RPCModel::~ossimRadarSat2RPCModel() { } ossimString ossimRadarSat2RPCModel::getClassName() const { return ossimString("ossimRadarSat2RPCModel"); } // ------ DUPLICATE RS2 MODEL OBJECT ---------- ossimObject* ossimRadarSat2RPCModel::dup() const { return new ossimRadarSat2RPCModel(*this); } bool ossimRadarSat2RPCModel::open(const ossimFilename& file) { static const char MODULE[] = "ossimRadarSat2RPCModel::open"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = false; // Get the xml file. ossimFilename xmlFile; if (file.ext().downcase() == "xml") { xmlFile = file; } else if (file.isFile()) { xmlFile = file.expand().path().dirCat("product.xml"); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "product xml file: " << xmlFile << "\n"; } if ( xmlFile.exists() ) { //--- // Instantiate the XML parser: //--- ossimXmlDocument* xdoc = new ossimXmlDocument(); if ( xdoc->openFile(xmlFile) ) { ossimRadarSat2ProductDoc rsDoc; result = rsDoc.isRadarSat2(xdoc); if (result) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "isRadarSat2...\n"; ossimString s; if ( rsDoc.getBeamModeMnemonic(xdoc, s) ) { ossimNotify(ossimNotifyLevel_DEBUG) << "beam_mode_mnemonic: " << s << "\n"; } if ( rsDoc.getAcquisitionType(xdoc, s) ) { ossimNotify(ossimNotifyLevel_DEBUG) << "acquisition_type: " << s << "\n"; } } // Set the base class number of lines and samples result = rsDoc.initImageSize(xdoc, theImageSize); //--- // Fetch Image Size: //--- theImageSize.line = theImageSize.x; theImageSize.samp =theImageSize.y; //*** // Assign the bounding image space rectangle: //*** if (result) { // Set the base class clip rect. theImageClipRect = ossimDrect( 0, 0, theImageSize.x-1, theImageSize.y-1); } // Set the sub image offset. tmp hard coded (drb). theSubImageOffset.x = 0.0; theSubImageOffset.y = 0.0; // Set the image id. if (result) { result = rsDoc.getImageId(xdoc, theImageID); } // Set the sensor ID. if (result) { result = rsDoc.getSatellite(xdoc, theSensorID); } // Set the base class gsd: result = rsDoc.initGsd(xdoc, theGSD); if (result) { theMeanGSD = (theGSD.x + theGSD.y)/2.0; } } thePolyType = B; RPCModel model; model = rsDoc.getRpcData(xdoc); theBiasError = model.biasError; theRandError = model.randomError; theLineOffset = model.lineOffset; theSampOffset = model.pixelOffset; theLatOffset = model.latitudeOffset; theLonOffset = model.longitudeOffset; theHgtOffset = model.heightOffset; theLineScale = model.lineScale; theSampScale = model.pixelScale; theLatScale = model.latitudeScale; theLonScale = model.longitudeScale; theHgtScale = model.heightScale; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "All parameters RPC : " << theBiasError << ", " << theRandError << ", " << theLineOffset << ", " << theSampOffset << ", " << theLatOffset << ", " << theLonOffset << ", " << theHgtOffset << ", " << theLineScale << ", " << theSampScale << ", " << theLatScale << ", " << theLonScale << ", " << theHgtScale << ", " << std::endl; } // Parse coefficients: ossim_uint32 i; for (i=0; i<20; ++i) { theLineNumCoef[i] = model.lineNumeratorCoefficients[i]; theLineDenCoef[i] = model.lineDenominatorCoefficients[i]; theSampNumCoef[i] = model.pixelNumeratorCoefficients[i]; theSampDenCoef[i] = model.pixelDenominatorCoefficients[i]; } // Assign other data members to default values: theNominalPosError = sqrt(theBiasError*theBiasError + theRandError*theRandError); // meters } // matches: if ( xdoc->openFile(xmlFile) ) delete xdoc; xdoc = 0; } // matches: if ( xmlFile.exists() ) if (result) { theProductXmlFile = xmlFile; } else { theProductXmlFile = ossimFilename::NIL; } if (result) { theProductXmlFile = xmlFile; } else { theProductXmlFile = ossimFilename::NIL; } if (result) { // Assign the ossimSensorModel::theBoundGndPolygon ossimGpt ul; ossimGpt ur; ossimGpt lr; ossimGpt ll; lineSampleToWorld(theImageClipRect.ul(), ul); lineSampleToWorld(theImageClipRect.ur(), ur); lineSampleToWorld(theImageClipRect.lr(), lr); lineSampleToWorld(theImageClipRect.ll(), ll); setGroundRect(ul, ur, lr, ll); // ossimSensorModel method. } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } //--- // Get the decimation if any from the header "IMAG" field. // // Look for string like: // "/2" = 1/2 // "/4 = 1/4 // ... // "/16 = 1/16 // If it is full resolution it should be "1.0" //--- theDecimation = 1.0; //*** // Assign other data members: //*** thePolyType = B; // This may not be true for early RPC imagery theRefImgPt.line = theImageSize.line/2.0; theRefImgPt.samp = theImageSize.samp/2.0; theRefGndPt.lat = theLatOffset; theRefGndPt.lon = theLonOffset; theRefGndPt.hgt = theHgtOffset; //--- // Assign the bounding ground polygon: // // NOTE: We will use the base ossimRpcModel for transformation since all // of our calls are in full image space (not decimated). //--- ossimGpt v0, v1, v2, v3; ossimDpt ip0 (0.0, 0.0); ossimRpcModel::lineSampleHeightToWorld(ip0, theHgtOffset, v0); ossimDpt ip1 (theImageSize.samp-1.0, 0.0); ossimRpcModel::lineSampleHeightToWorld(ip1, theHgtOffset, v1); ossimDpt ip2 (theImageSize.samp-1.0, theImageSize.line-1.0); ossimRpcModel::lineSampleHeightToWorld(ip2, theHgtOffset, v2); ossimDpt ip3 (0.0, theImageSize.line-1.0); ossimRpcModel::lineSampleHeightToWorld(ip3, theHgtOffset, v3); theBoundGndPolygon = ossimPolygon (ossimDpt(v0), ossimDpt(v1), ossimDpt(v2), ossimDpt(v3)); updateModel(); // Set the ground reference point. ossimRpcModel::lineSampleHeightToWorld(theRefImgPt, theHgtOffset, theRefGndPt); if ( theRefGndPt.isLatNan() || theRefGndPt.isLonNan() ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimNitfRpcModel::ossimNitfRpcModel DEBUG:" << "\nGround Reference Point not valid." << " Aborting with error..." << std::endl; } setErrorStatus(); return false; } return true; } void ossimRadarSat2RPCModel::worldToLineSample(const ossimGpt& world_point, ossimDpt& image_point) const { // Get the full res (not decimated) point. ossimRpcModel::worldToLineSample(world_point, image_point); // Apply decimation. image_point.x = image_point.x * theDecimation; image_point.y = image_point.y * theDecimation; } void ossimRadarSat2RPCModel::lineSampleHeightToWorld( const ossimDpt& image_point, const double& heightEllipsoid, ossimGpt& worldPoint) const { // Convert image point to full res (not decimated) point. ossimDpt pt; pt.x = image_point.x / theDecimation; pt.y = image_point.y / theDecimation; // Call base... ossimRpcModel::lineSampleHeightToWorld(pt, heightEllipsoid, worldPoint); } std::ostream& ossimRadarSat2RPCModel::print(std::ostream& out) const { // Capture the original flags. std::ios_base::fmtflags f = out.flags(); ossimRpcModel::print(out); // Reset flags. out.setf(f); return out; } bool ossimRadarSat2RPCModel::InitSensorParams(const ossimKeywordlist &kwl, const char *prefix) { // sensor frequencies const char* central_freq_str = kwl.find(prefix,"central_freq"); double central_freq = 0.0; if (central_freq_str) { central_freq = ossimString::toDouble(central_freq_str); } const char* fr_str = kwl.find(prefix,"fr"); double fr = 0.0; if (fr_str) { fr = ossimString::toDouble(fr_str); } const char* fa_str = kwl.find(prefix,"fa"); double fa = 0.0; if (fa_str) { fa = ossimString::toDouble(fa_str); } //number of different looks const char* n_azilok_str = kwl.find(prefix,"n_azilok"); double n_azilok = 0.0; if (n_azilok_str) { n_azilok = ossimString::toDouble(n_azilok_str); } const char* n_rnglok_str = kwl.find(prefix,"n_rnglok"); double n_rnglok = 0.0; if (n_rnglok_str) { n_rnglok = ossimString::toDouble(n_rnglok_str); } //ellipsoid parameters const char* ellip_maj_str = kwl.find(prefix,"ellip_maj"); double ellip_maj = 0.0; if (ellip_maj_str) { ellip_maj = ossimString::toDouble(ellip_maj_str) * 1000.0;// km -> m } const char* ellip_min_str = kwl.find(prefix,"ellip_min"); double ellip_min = 0.0; if (ellip_min_str) { ellip_min = ossimString::toDouble(ellip_min_str) * 1000.0;// km -> m } if(_sensor != 0) { delete _sensor; } _sensor = new SensorParams(); const char* lineTimeOrdering_str = kwl.find(prefix,"lineTimeOrdering"); std::string lineTimeOrdering(lineTimeOrdering_str) ; const char* pixelTimeOrdering_str = kwl.find(prefix,"pixelTimeOrdering"); std::string pixelTimeOrdering(pixelTimeOrdering_str) ; if (pixelTimeOrdering == "Increasing") _sensor->set_col_direction(1); else _sensor->set_col_direction(- 1); if (lineTimeOrdering == "Increasing") _sensor->set_lin_direction(1); else _sensor->set_lin_direction(- 1); const char* lookDirection_str = kwl.find(prefix,"lookDirection"); std::string lookDirection(lookDirection_str) ; if ((lookDirection == "Right")||(lookDirection == "RIGHT")) _sensor->set_sightDirection(SensorParams::Right) ; else _sensor->set_sightDirection(SensorParams::Left) ; _sensor->set_sf(fr); const double CLUM = 2.99792458e+8 ; double wave_length = CLUM / central_freq ; _sensor->set_rwl(wave_length); _sensor->set_nAzimuthLook(n_azilok); _sensor->set_nRangeLook(n_rnglok); // fa is the processing PRF _sensor->set_prf(fa * n_azilok); _sensor->set_semiMajorAxis(ellip_maj) ; _sensor->set_semiMinorAxis(ellip_min) ; return true; } bool ossimRadarSat2RPCModel::initSensorParams( const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc) { static const char MODULE[] = "ossimRadarSat2RPCModel::initSensorParams"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } if (_sensor ) { delete _sensor; } _sensor = new SensorParams(); bool result = rsDoc.initSensorParams(xdoc, _sensor); if (!result) { delete _sensor; _sensor = 0; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimRadarSat2RPCModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimRadarSat2RPCModel::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = true; kwl.add(prefix, "decimation", theDecimation); // Save our state: kwl.add(prefix, PRODUCT_XML_FILE_KW, theProductXmlFile.c_str()); if (result) { // Call base save state: result = ossimRpcModel::saveState(kwl, prefix); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimRadarSat2RPCModel::loadState (const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimRadarSat2RPCModel::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } const char* lookup = 0; ossimString s; // Check the type first. lookup = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (lookup) { s = lookup; if (s != getClassName()) { return false; } } // Get the product.xml file name. lookup = kwl.find(prefix, PRODUCT_XML_FILE_KW); if (lookup) { theProductXmlFile = lookup; // See if caller wants to load from xml vice keyword list. lookup = kwl.find(prefix, LOAD_FROM_PRODUCT_FILE_KW); if (lookup) { s = lookup; if ( s.toBool() ) { // Loading from product.xml file. return open(theProductXmlFile); } } } // Call base. bool result = ossimRpcModel::loadState(kwl, prefix); // Lookup decimation. const char* value = kwl.find(prefix, "decimation"); if (value) { theDecimation = ossimString(value).toFloat64(); if (theDecimation <= 0.0) { // Do not allow negative or "0.0"(divide by zero). theDecimation = 1.0; } } //--- // Temp: This must be cleared or you end up with a bounding rect of all // zero's. //--- theBoundGndPolygon.clear(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2RPCModel.h000066400000000000000000000077361301006202600300470ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimRadarSat2RPCModel_H #define ossimRadarSat2RPCModel_H 1 #include #include #include #include #include #include #include #include #include #include #include #include #include #include class ossimFilename; class ossimString; class ossimXmlDocument; namespace ossimplugins { class ossimRadarSat2ProductDoc; class SensorParams; /** * @brief This class allows for direct localisation and indirect localisation * using the RadarSat2 sensor model */ class OSSIM_PLUGINS_DLL ossimRadarSat2RPCModel : public ossimRpcModel { public: /** @brief default constructor */ ossimRadarSat2RPCModel(); /** @brief copy constructor */ ossimRadarSat2RPCModel(const ossimRadarSat2RPCModel& rhs); ossimRadarSat2RPCModel(const ossimFilename& RS2File); /** @brief Destructor */ virtual ~ossimRadarSat2RPCModel(); /** * @brief Method to return the class name. * @return The name of this class. */ virtual ossimString getClassName() const; /** * @brief Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /** * @brief Method to parse an nitf file and initialize model. * @param entryIndex The entry to get model for. Note the nitf's can have * multiple entries; each with a different projection. * @return true on success, false on error. */ bool open(const ossimFilename& file); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; /** * @brief worldToLineSample() * Calls ossimRpcModel::worldToLineSample(), then applies (if needed) * decimation. * This is a temp work around for decimation RPC NITFs. */ virtual void worldToLineSample(const ossimGpt& world_point, ossimDpt& image_point) const; /** * @brief lineSampleHeightToWorld() * Backs out decimation of image_point (if needed) then calls: * ossimRpcModel::lineSampleHeightToWorld * This is a temp work around for decimation RPC NITFs. */ virtual void lineSampleHeightToWorld(const ossimDpt& image_point, const double& heightEllipsoid, ossimGpt& worldPoint) const; private: bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); bool initSensorParams(const ossimXmlDocument* xdoc, const ossimRadarSat2ProductDoc& rsDoc); /** * Stored from header field "IMAG". This is a temp work around to handle * decimated rpc nitf's. */ ossim_float64 theDecimation; SensorParams * _sensor; ossimFilename theProductXmlFile; TYPE_DATA }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2TiffReader.cpp000066400000000000000000000177351301006202600310100ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: See top level LICENSE.txt file // // Author: John Stastny // // Description: Image handelr for RadarSAT-2 data that is TIFF based. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Keyword constants: static const char PRODUCT_XML_FILE_KW[] = "product_xml_filename"; namespace ossimplugins { RTTI_DEF1(ossimRadarSat2TiffReader, "ossimRadarSat2TiffReader", ossimTiffTileSource) } #ifdef OSSIM_ID_ENABLED static const char OSSIM_ID[] = "$Id$"; #endif static ossimTrace traceDebug("ossimRadarSat2TiffReader:degug"); ossimplugins::ossimRadarSat2TiffReader::ossimRadarSat2TiffReader() : ossimTiffTileSource() { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimplugins::ossimRadarSat2TiffReader::ossimRadarSat2TiffReader entered...\n"; #ifdef OSSIM_ID_ENABLED ossimNotify(ossimNotifyLevel_DEBUG) << "OSSIM_ID: " << OSSIM_ID << std::endl; #endif } } ossimplugins::ossimRadarSat2TiffReader::~ossimRadarSat2TiffReader() { } bool ossimplugins::ossimRadarSat2TiffReader::saveState( ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimplugins::ossimRadarSat2TiffReader::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } // Save our state: kwl.add(prefix, PRODUCT_XML_FILE_KW, theProductXmlFile.c_str()); // Save the base: return ossimTiffTileSource::saveState(kwl, prefix); } bool ossimplugins::ossimRadarSat2TiffReader::loadState( const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "ossimplugins::ossimRadarSat2TiffReader::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result = false; // Get the product.xml file name. const char* lookup = kwl.find(prefix, PRODUCT_XML_FILE_KW); if (lookup) { theProductXmlFile = lookup; if ( isRadarSat2ProductFile(theProductXmlFile) ) { //--- // Although we can open any tiff here we only do if we have matching // RS2 product.xml. //--- result = ossimTiffTileSource::loadState(kwl, prefix); } } if (!result) { theProductXmlFile.clear(); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } ossimString ossimplugins::ossimRadarSat2TiffReader::getShortName()const { return ossimString("ossim_radarsat2_tiff_reader"); } ossimString ossimplugins::ossimRadarSat2TiffReader::getLongName()const { return ossimString("ossim RadarSAT-2 tiff reader"); } bool ossimplugins::ossimRadarSat2TiffReader::open(const ossimFilename& file) { static const char MODULE[] = "ossimplugins::ossimRadarSat2TiffReader::open"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n" << "file: " << file << "\n"; } bool result = false; if ( isOpen() ) { close(); } // Check extension to see if it's xml. if ( file.ext().downcase() == "xml" ) { ossimXmlDocument* xdoc = new ossimXmlDocument(); if ( xdoc->openFile(file) ) { // See if it's a TerraSAR-X product xml file. if ( isRadarSat2ProductFile(xdoc) ) { ossimString s; ossimRadarSat2ProductDoc helper; if ( helper.getImageFile(xdoc, s) ) { ossimFilename imageFile = file.expand().path(); imageFile = imageFile.dirCat(s); setFilename(imageFile); result = ossimTiffTileSource::open(); if (result) { theProductXmlFile = file; completeOpen(); } } } } delete xdoc; xdoc = 0; } // matches: if ( file.ext().downcase() == "xml" ) if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } void ossimplugins::ossimRadarSat2TiffReader::close() { theProductXmlFile.clear(); ossimTiffTileSource::close(); } ossimRefPtr ossimplugins::ossimRadarSat2TiffReader::getImageGeometry() { if ( !theGeometry ) { //--- // Check for external geom: //--- theGeometry = getExternalImageGeometry(); if ( !theGeometry ) { // Check the internal geometry first to avoid a factory call. theGeometry = getInternalImageGeometry(); // At this point it is assured theGeometry is set. //--- // WARNING: // Must create/set theGeometry at this point or the next call to // ossimImageGeometryRegistry::extendGeometry will put us in an infinite loop // as it does a recursive call back to ossimImageHandler::getImageGeometry(). //--- // Check for set projection. if ( !theGeometry->getProjection() ) { // Try factories for projection. ossimImageGeometryRegistry::instance()->extendGeometry(this); } } // Set image things the geometry object should know about. initImageParameters( theGeometry.get() ); } return theGeometry; } ossimRefPtr ossimplugins::ossimRadarSat2TiffReader::getInternalImageGeometry() const { static const char MODULE[] = "ossimplugins::ossimRadarSat2TiffReader::getInternalImageGeometry"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } ossimRefPtr geom = new ossimImageGeometry(); ossimXmlDocument* xdoc = new ossimXmlDocument(); if ( xdoc->openFile(theProductXmlFile) ) { ossimRefPtr model = new ossimRadarSat2Model(); if ( model->open(theProductXmlFile) ) { // Assign the model to our ossimImageGeometry object. geom->setProjection( model.get() ); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "WARNING: Unhandled projection: " << std::endl; } } } // matches: if ( xdoc->openFile(theProductXmlFile) ) delete xdoc; xdoc = 0; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exited..." << std::endl; } return geom; } bool ossimplugins::ossimRadarSat2TiffReader::isRadarSat2ProductFile( const ossimFilename& file) const { bool result = false; // Check extension to see if it's xml. if ( file.ext().downcase() == "xml" ) { ossimXmlDocument* xdoc = new ossimXmlDocument(); if ( xdoc->openFile(file) ) { result = isRadarSat2ProductFile(xdoc); } delete xdoc; xdoc = 0; } return result; } bool ossimplugins::ossimRadarSat2TiffReader::isRadarSat2ProductFile( const ossimXmlDocument* xdoc) const { bool result = false; if (xdoc) { ossimRadarSat2ProductDoc helper; // See if it's a TerraSAR-X product xml file. result = helper.isRadarSat2(xdoc); } return result; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSat2TiffReader.h000066400000000000000000000061231301006202600304420ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: John Stastny // // Description: Image handelr for RadarSAT-2 data that is TIFF based. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimRadarSat2TiffReader_HEADER #define ossimRadarSat2TiffReader_HEADER 1 #include #include // Forward class declarations outside of namespace ossimplugins. class ossimXmlDocument; namespace ossimplugins { class ossimRadarSat2TiffReader : public ossimTiffTileSource { public: /** default constructor */ ossimRadarSat2TiffReader(); /** virtual destructor */ virtual ~ossimRadarSat2TiffReader(); /** @return "ossim_radarsat2_tiff_reader" */ virtual ossimString getShortName() const; /** @return "ossim RadarSAT-2 tiff reader" */ virtual ossimString getLongName() const; /** * This open take the product xml file. * * @param file File to open. * * @return true on success, false on error. */ virtual bool open(const ossimFilename& file); /** * Method to save the state of an object to a keyword list. * Return true if ok or false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0)const; /** * Method to the load (recreate) the state of an object from a keyword * list. Return true if ok or false on error. */ virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=0); /** Close method. */ virtual void close(); /** * Returns the image geometry object associated with this tile source or * NULL if non defined. The geometry contains full-to-local image * transform as well as projection (image-to-world). */ virtual ossimRefPtr getImageGeometry(); /** * @param Method to get geometry from the xml file or internal geotiff * tags. */ virtual ossimRefPtr getInternalImageGeometry() const; private: /** * @brief Method to check file to see if it's a RS2 product * xml file. * @param file The file to check. * @return true on success, false on error. */ bool isRadarSat2ProductFile(const ossimFilename& file) const; /** * @brief Method to check file to see if it's a RS2 product * xml file. * @param xdoc XML document opened up to product.xml file. * @return true on success, false on error. */ bool isRadarSat2ProductFile(const ossimXmlDocument* xdoc) const; ossimFilename theProductXmlFile; TYPE_DATA }; } // End: namespace ossimplugins #endif /* #ifndef ossimRadarSat2TiffReader_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRadarSatModel.cpp000066400000000000000000001137471301006202600277530ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { RTTI_DEF1(ossimRadarSatModel, "ossimRadarSatModel", ossimGeometricSarSensorModel); // Static trace for debugging static ossimTrace traceDebug("ossimRadarSatModel:debug"); ossimRadarSatModel::ossimRadarSatModel(): ossimGeometricSarSensorModel(), _n_srgr(0), _pixel_spacing(0), _data(NULL), _leader(NULL), _trailer(NULL), _volumeDir(NULL) { } ossimRadarSatModel::ossimRadarSatModel(const ossimRadarSatModel& rhs): ossimGeometricSarSensorModel(rhs), _n_srgr(rhs._n_srgr), _pixel_spacing(rhs._pixel_spacing), _data(new Data(*(rhs._data))), _leader(new Leader(*(rhs._leader))), _trailer(new Trailer(*(rhs._trailer))), _volumeDir(new VolumeDir(*(rhs._volumeDir))) { } ossimRadarSatModel::~ossimRadarSatModel() { if (_data != 0) { delete _data; } if (_leader != 0) { delete _leader; } if (_trailer != 0) { delete _trailer; } if (_volumeDir != 0) { delete _volumeDir; } } ossimObject* ossimRadarSatModel::dup() const { return new ossimRadarSatModel(*this); } ossimString ossimRadarSatModel::getClassName() const { return ossimString("ossimRadarSatModel"); } double ossimRadarSatModel::getSlantRangeFromGeoreferenced(double col) const { if (_n_srgr==0) return(-1) ; double relativeGroundRange ; // in the case of Georeferenced images, _refPoint->get_distance() contains the ground range relativeGroundRange = _refPoint->get_distance() + _sensor->get_col_direction() * (col-_refPoint->get_pix_col())* _pixel_spacing ; int numSet = FindSRGRSetNumber((_refPoint->get_ephemeris())->get_date()) ; /** * @todo : could be improved (date choice) */ double slantRange = _srgr_coefset[numSet][0] + _srgr_coefset[numSet][1]*relativeGroundRange + _srgr_coefset[numSet][2]*pow(relativeGroundRange,2) + _srgr_coefset[numSet][3]*pow(relativeGroundRange,3) + _srgr_coefset[numSet][4]*pow(relativeGroundRange,4) + _srgr_coefset[numSet][5]*pow(relativeGroundRange,5); return slantRange ; } bool ossimRadarSatModel::open(const ossimFilename& file) { //traceDebug.setTraceFlag(true); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRadarSatTileSource::open(filename) DEBUG: entered..." << std::endl << "Attempting to open file " << file << std::endl; } bool retValue = true; ossimFilename tempFilename = file; /* * Detect if we use vdf file or dat file */ ossimFilename dataFilePath; ossimFilename volumeDirectoryFilePath; std::string input_file = file; string::size_type loc_DAT = input_file.find( "DAT_01", 0 ); string::size_type loc_dat = input_file.find( "dat_01", 0 ); if ( (loc_DAT != string::npos ) || ( loc_dat != string::npos ) ) { dataFilePath = input_file.c_str(); if (loc_DAT != string::npos ) input_file.replace(loc_DAT, 6, "VDF_DAT"); if (loc_dat != string::npos ) input_file.replace(loc_dat, 6, "vdf_dat"); volumeDirectoryFilePath = input_file.c_str(); } else { string::size_type loc_VDF = input_file.find( "VDF_DAT", 0 ); string::size_type loc_vdf = input_file.find( "vdf_dat", 0 ); if ( (loc_VDF != string::npos ) || ( loc_vdf != string::npos ) ) { volumeDirectoryFilePath = input_file.c_str(); if (loc_VDF != string::npos ) input_file.replace(loc_VDF, 7, "DAT_01"); if (loc_vdf != string::npos ) input_file.replace(loc_vdf, 7, "dat_01"); dataFilePath = input_file.c_str(); } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "File Name not coherent (searching for *DAT_01* or *dat_01* or *vdf_dat* or *VDF_DAT* ) : " << file << std::endl; } return false; } } //Creation of the class allowing to store the metadata from the Volume Directory File if (_volumeDir != NULL) { delete _volumeDir; _volumeDir = NULL; } _volumeDir = new VolumeDir(); //Creation of the class allowing to store the metadata from the Data file if (_data != NULL) { delete _data; _data = NULL; } _data = new Data(); //Creation of the class allowing to store the metadata from the Leader file if(_leader != NULL) { delete _leader; _leader = NULL; } _leader = new Leader(); // Creation of the class allowing to store the metadata from the Trailer file if(_trailer != NULL) { delete _trailer; _trailer = NULL; } _trailer = new Trailer(); RadarSatRecordHeader headerVDF; VolumeDirFactory factoryVDF; ifstream volumeDirFile (volumeDirectoryFilePath.c_str(), ios::in|ios::binary); volumeDirFile>>headerVDF; if(volumeDirFile.eof()) { volumeDirFile.close(); retValue = false; } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Begin reading VDF file" << std::endl; } RadarSatRecord* recordVDF = factoryVDF.Instantiate(headerVDF.get_rec_seq()); if (recordVDF != NULL && headerVDF.get_rec_seq() == 1) { recordVDF->Read(volumeDirFile); //Test if the input File is a valid Radarsat VDF file if ((((VolumeDescriptorRecord*) recordVDF)->get_logvol_id()).substr(0, 10) == "RSAT-1-SAR") { std::string subProduct = (((VolumeDescriptorRecord*) recordVDF)->get_logvol_id()).substr(11, 3); if ( (subProduct == "RAW") || (subProduct == "SPG") || (subProduct == "SSG") ) { if(traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "RAW, SPG and SSG format are not supported" <> *_volumeDir; volumeDirFile.close(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading VDF file" << std::endl; } RadarSatRecordHeader headerDAT; DataFactory factoryDAT; ifstream dataFile (dataFilePath.c_str(), ios::in|ios::binary); dataFile>>headerDAT; if(dataFile.eof()) { dataFile.close(); retValue = false; } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< "Begin reading DAT file" << std::endl; } RadarSatRecord* recordDAT = factoryDAT.Instantiate(headerDAT.get_rec_seq()); if (recordDAT != NULL && headerDAT.get_rec_seq() == 1) { recordDAT->Read(dataFile); dataFile.close(); /* * Reading the remaining of the data file */ dataFile.open(dataFilePath.c_str(), ios::in|ios::binary); dataFile>>*_data; dataFile.close(); /* * Commenting this line : * With SARDEGNA file (a corrupted file without number of lines) * this line makes disappear the auto-computation of number of lines * by file seeking. * It does not seem to add any information either (same keywordlist) * * TODO : investigate : what is it supposed to do ? */ //_data->InsertRecord(headerDAT.get_rec_seq(), recordDAT); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading DAT file" << std::endl; } } // TODO move to end }// TODO move to end /* * Leader file path construction from the DAT file path * Warning : the filename case has to be homogenous */ std::string leader_file = dataFilePath; string::size_type loc = leader_file.find( "DAT_01", 0 ); if( loc != string::npos ) leader_file.replace(loc, 6, "LEA_01" ); // upper case test else { loc = leader_file.find( "dat_01", 0 ); if( loc != string::npos ) leader_file.replace(loc, 6, "lea_01" ); // lower case test else { ossimNotify(ossimNotifyLevel_DEBUG) << "File Name not coherent (searching for *DAT_01* or *dat_01*) : " << file << std::endl; } } ossimFilename leaderFilePath(leader_file); if (!leaderFilePath.exists()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Leader file not found (searching for *lea_01* coherent with *dat_01*) : " << file << std::endl; retValue = false; } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Begin reading Leader file" << std::endl; } /* * Leader file data reading */ ifstream leaderFile (leaderFilePath.c_str(), ios::in|ios::binary); leaderFile>>*_leader; leaderFile.close(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading Leader file" << std::endl; } } /* * Trailer file path construction from the DAT file path * Warning : the filename case has to be homogenous */ std::string trailer_file = dataFilePath; loc = trailer_file.find( "DAT_01", 0 ); if( loc != string::npos ) trailer_file.replace(loc, 6, "TRA_01" ); // upper case test else { loc = trailer_file.find( "dat_01", 0 ); if( loc != string::npos ) trailer_file.replace(loc, 6, "tra_01" ); // lower case test else { ossimNotify(ossimNotifyLevel_DEBUG) << "File Name not coherent (searching for *DAT_01* or *dat_01*) : " << file << std::endl; } } ossimFilename trailerFilePath(trailer_file); if (!trailerFilePath.exists()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Trailer file not found (searching for *tra_01* coherent with *dat_01*) : " << file << std::endl; retValue = false; } else { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Begin reading Trailer file" << std::endl; } /* * Trailer file data reading */ ifstream trailerFile (trailerFilePath.c_str(), ios::in|ios::binary); trailerFile>>*_trailer; trailerFile.close(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "End reading Trailer file" << std::endl; } } } else { volumeDirFile.close(); retValue = false; } } else { volumeDirFile.close(); retValue = false; } } ossimKeywordlist geom_kwl; this->internalSaveState(geom_kwl); this->internalLoadState(geom_kwl); // Assign the ossimSensorModel::theBoundGndPolygon ossimGpt ul; ossimGpt ur; ossimGpt lr; ossimGpt ll; lineSampleToWorld(theImageClipRect.ul(), ul); lineSampleToWorld(theImageClipRect.ur(), ur); lineSampleToWorld(theImageClipRect.lr(), lr); lineSampleToWorld(theImageClipRect.ll(), ll); setGroundRect(ul, ur, lr, ll); // ossimSensorModel method. if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRadarSatModel::open() DEBUG: returning..." << std::endl; } return retValue; } bool ossimRadarSatModel::internalSaveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimRadarSatModel::internalSaveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } char name[64]; kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimRadarSatModel", true); FileDescriptor * fileDescriptor = _leader->get_FileDescriptor() ; if(fileDescriptor != NULL) { kwl.add(prefix, "file_name",fileDescriptor->get_file_name().c_str(),true); } else { return false; } DataSetSummary * datasetSummary = _leader->get_DataSetSummary(); if(datasetSummary == NULL) { delete datasetSummary; datasetSummary = _trailer->get_DataSetSummary(); } if(datasetSummary != NULL) { kwl.add(prefix, "inp_sctim",datasetSummary->get_inp_sctim().c_str(),true); kwl.add(prefix, "asc_des",datasetSummary->get_asc_des().c_str(),true); kwl.add(prefix, "pro_lat",datasetSummary->get_pro_lat(),true); kwl.add(prefix, "pro_long",datasetSummary->get_pro_long(),true); kwl.add(prefix, "pro_head",datasetSummary->get_pro_head(),true); kwl.add(prefix, "ellip_des",datasetSummary->get_ellip_des().c_str(),true); kwl.add(prefix, "ellip_maj",datasetSummary->get_ellip_maj(),true); kwl.add(prefix, "ellip_min",datasetSummary->get_ellip_min(),true); kwl.add(prefix, "sc_lin",datasetSummary->get_sc_lin(),true); kwl.add(prefix, "sc_pix",datasetSummary->get_sc_pix(),true); kwl.add(prefix, "plat_lat",datasetSummary->get_plat_lat(),true); kwl.add(prefix, "plat_long",datasetSummary->get_plat_long(),true); kwl.add(prefix, "plat_head",datasetSummary->get_plat_head(),true); kwl.add(prefix, "wave_length",datasetSummary->get_wave_length(),true); kwl.add(prefix, "fr",datasetSummary->get_fr(),true); kwl.add(prefix, "rng_gate",datasetSummary->get_rng_gate(),true); kwl.add(prefix, "fa",datasetSummary->get_fa(),true); kwl.add(prefix, "n_azilok",datasetSummary->get_n_azilok(),true); kwl.add(prefix, "n_rnglok",datasetSummary->get_n_rnglok(),true); kwl.add(prefix, "bnd_azilok",datasetSummary->get_bnd_azilok(),true); kwl.add(prefix, "bnd_rnglok",datasetSummary->get_bnd_rnglok(),true); kwl.add(prefix, "bnd_azi",datasetSummary->get_bnd_azi(),true); kwl.add(prefix, "bnd_rng",datasetSummary->get_bnd_rng(),true); kwl.add(prefix, "alt_dopcen0",datasetSummary->get_alt_dopcen()[0],true); kwl.add(prefix, "alt_dopcen1",datasetSummary->get_alt_dopcen()[1],true); kwl.add(prefix, "alt_dopcen2",datasetSummary->get_alt_dopcen()[2],true); kwl.add(prefix, "crt_dopcen0",datasetSummary->get_crt_dopcen()[0],true); kwl.add(prefix, "crt_dopcen1",datasetSummary->get_crt_dopcen()[1],true); kwl.add(prefix, "crt_dopcen2",datasetSummary->get_crt_dopcen()[2],true); kwl.add(prefix, "time_dir_pix",datasetSummary->get_time_dir_pix().c_str(),true); kwl.add(prefix, "time_dir_lin",datasetSummary->get_time_dir_lin().c_str(),true); kwl.add(prefix, "terrain_height",datasetSummary->get_terrain_h(),true); kwl.add(prefix, "line_spacing",datasetSummary->get_line_spacing(),true); } else { ossimNotify(ossimNotifyLevel_DEBUG) << "It is not possible to add dataSetSummary from _leader or _trailer file" <get_ProcessingParameters(); if(processingParameters == NULL) { delete processingParameters; processingParameters = _trailer->get_ProcessingParameters(); } if(processingParameters != NULL) { kwl.add(prefix, "n_srgr",processingParameters->get_n_srgr(),true); for (int i=0;iget_n_srgr();i++) { sprintf(name,"srgr_update%i",i); kwl.add(prefix, name,((processingParameters->get_srgr_coefset()[i]).get_srgr_update()).c_str(),true); sprintf(name,"srgr_coef%iA",i); kwl.add(prefix, name,(processingParameters->get_srgr_coefset()[i]).get_srgr_coef()[0],true); sprintf(name,"srgr_coef%iB",i); kwl.add(prefix, name,(processingParameters->get_srgr_coefset()[i]).get_srgr_coef()[1],true); sprintf(name,"srgr_coef%iC",i); kwl.add(prefix, name,(processingParameters->get_srgr_coefset()[i]).get_srgr_coef()[2],true); sprintf(name,"srgr_coef%iD",i); kwl.add(prefix, name,(processingParameters->get_srgr_coefset()[i]).get_srgr_coef()[3],true); sprintf(name,"srgr_coef%iE",i); kwl.add(prefix, name,(processingParameters->get_srgr_coefset()[i]).get_srgr_coef()[4],true); sprintf(name,"srgr_coef%iF",i); kwl.add(prefix, name,(processingParameters->get_srgr_coefset()[i]).get_srgr_coef()[5],true); } kwl.add(prefix, "pixel_spacing",processingParameters->get_pixel_spacing(),true); kwl.add(prefix, "lookDirection",(processingParameters->get_sens_orient()).c_str(),true); } else { ossimNotify(ossimNotifyLevel_DEBUG) << "It is not possible to add processingParameters from _leader or _trailer file" <get_PlatformPositionData(); if(platformPositionData != NULL) { kwl.add(prefix, "neph",platformPositionData->get_ndata(),true); kwl.add(prefix, "eph_int",platformPositionData->get_data_int(),true); kwl.add(prefix, "eph_year",platformPositionData->get_year(),true); kwl.add(prefix, "eph_month",platformPositionData->get_month(),true); kwl.add(prefix, "eph_day",platformPositionData->get_day(),true); kwl.add(prefix, "eph_sec",platformPositionData->get_gmt_sec(),true); kwl.add(prefix, "hr_angle",platformPositionData->get_hr_angle(),true); for(int i=0;iget_ndata();i++) { sprintf(name,"eph%i_posX",i); kwl.add(prefix, name,(platformPositionData->get_pos_vect()[i]).get_pos()[0],true); sprintf(name,"eph%i_posY",i); kwl.add(prefix, name,(platformPositionData->get_pos_vect()[i]).get_pos()[1],true); sprintf(name,"eph%i_posZ",i); kwl.add(prefix, name,(platformPositionData->get_pos_vect()[i]).get_pos()[2],true); sprintf(name,"eph%i_velX",i); kwl.add(prefix, name,(platformPositionData->get_pos_vect()[i]).get_vel()[0],true); sprintf(name,"eph%i_velY",i); kwl.add(prefix, name,(platformPositionData->get_pos_vect()[i]).get_vel()[1],true); sprintf(name,"eph%i_velZ",i); kwl.add(prefix, name,(platformPositionData->get_pos_vect()[i]).get_vel()[2],true); } } else { ossimNotify(ossimNotifyLevel_DEBUG) << "It is not possible to add platformPositionData from _leader file" <get_ImageOptionsFileDescriptor(); if(imageOptionsFileDescriptor != NULL) { kwl.add(prefix, "nbLin",imageOptionsFileDescriptor->get_nlin(),true); kwl.add(prefix, "nbCol",imageOptionsFileDescriptor->get_ngrp(),true); } else { ossimNotify(ossimNotifyLevel_DEBUG) << "It is not possible to add imageOptionsFileDescriptor from _data file" <get_FirstProcessedDataRecord(); if(firstProcessedDataRecord != NULL) { sprintf(name,"cornersLon%i",0); kwl.add(prefix, name,((float) (firstProcessedDataRecord->get_lon_first()))/1000000.0,true); sprintf(name,"cornersLat%i",0); kwl.add(prefix, name,((float) (firstProcessedDataRecord->get_lat_first()))/1000000.0,true); sprintf(name,"cornersLon%i",1); kwl.add(prefix, name,((float) (firstProcessedDataRecord->get_lon_last()))/1000000.0,true); sprintf(name,"cornersLat%i",1); kwl.add(prefix, name,((float) (firstProcessedDataRecord->get_lat_last()))/1000000.0,true); kwl.add(prefix, "acq_msec_first",firstProcessedDataRecord->get_acq_msec(),true); } else { ossimNotify(ossimNotifyLevel_DEBUG) << "It is not possible to add firstProcessedDataRecord from _data file" <get_LastProcessedDataRecord(); if(lastProcessedDataRecord != NULL) { sprintf(name,"cornersLon%i",2); kwl.add(prefix, name,((float) (lastProcessedDataRecord->get_lon_first()))/1000000.0,true); sprintf(name,"cornersLat%i",2); kwl.add(prefix, name,((float) (lastProcessedDataRecord->get_lat_first()))/1000000.0,true); sprintf(name,"cornersLon%i",3); kwl.add(prefix, name,(((float) lastProcessedDataRecord->get_lon_last()))/1000000.0,true); sprintf(name,"cornersLat%i",3); kwl.add(prefix, name,((float) (lastProcessedDataRecord->get_lat_last()))/1000000.0,true); kwl.add(prefix, "acq_msec_last",lastProcessedDataRecord->get_acq_msec(),true); } else { ossimNotify(ossimNotifyLevel_DEBUG) << "It is not possible to add lastProcessedDataRecord from _data file" <internalSaveState(kwl, prefix); if (result) { result = ossimGeometricSarSensorModel::saveState(kwl, prefix); } return result; } bool ossimRadarSatModel::internalLoadState (const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimRadarSatModel::internalLoadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } this->InitSRGR(kwl, prefix); this->InitSensorParams(kwl, prefix); this->InitPlatformPosition(kwl, prefix); this->InitRefPoint(kwl, prefix); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit...\n"; } return true; } bool ossimRadarSatModel::loadState (const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimRadarSatModel::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } const char* lookup = 0; ossimString s; // Check the type first. lookup = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (lookup) { s = lookup; if (s != getClassName()) { return false; } } //bool result = ossimGeometricSarSensorModel::loadState(kwl, prefix); bool result = true; if (result) { result = this->internalLoadState(kwl, prefix); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit...\n"; } return result; } bool ossimRadarSatModel::InitSensorParams(const ossimKeywordlist &kwl, const char *prefix) { const char* wave_length_str = kwl.find(prefix,"wave_length"); double wave_length = atof(wave_length_str); const char* fr_str = kwl.find(prefix,"fr"); double fr = atof(fr_str); const char* fa_str = kwl.find(prefix,"fa"); double fa = atof(fa_str); /* //number of different looks const char* n_azilok_str = kwl.find(prefix,"n_azilok"); double n_azilok = atof(n_azilok_str); const char* n_rnglok_str = kwl.find(prefix,"n_rnglok"); double n_rnglok = atof(n_rnglok_str); */ // look bandwidth rate (for localisation purpose) const char* bnd_azilok_str = kwl.find(prefix,"bnd_azilok"); double bnd_azilok = atof(bnd_azilok_str); const char* bnd_rnglok_str = kwl.find(prefix,"bnd_rnglok"); double bnd_rnglok = atof(bnd_rnglok_str); const char* bnd_azi_str = kwl.find(prefix,"bnd_azi"); double bnd_azi = atof(bnd_azi_str); const char* bnd_rng_str = kwl.find(prefix,"bnd_rng"); double bnd_rng = atof(bnd_rng_str); double n_azilok = bnd_azi/bnd_azilok; double n_rnglok = bnd_rng/bnd_rnglok; const char* time_dir_pix = kwl.find(prefix,"time_dir_pix"); const char* time_dir_lin = kwl.find(prefix,"time_dir_lin"); //ellipsoid parameters const char* ellip_maj_str = kwl.find(prefix,"ellip_maj"); double ellip_maj = atof(ellip_maj_str) * 1000.0; // km -> m const char* ellip_min_str = kwl.find(prefix,"ellip_min"); double ellip_min = atof(ellip_min_str) * 1000.0; // km -> m if(_sensor != NULL) { delete _sensor; } _sensor = new SensorParams(); if(strcmp(time_dir_pix, "INCREASE") == 0) { _sensor->set_col_direction(1); } else { _sensor->set_col_direction(-1); } if(strcmp(time_dir_lin, "INCREASE") == 0) { _sensor->set_lin_direction(1); } else { _sensor->set_lin_direction(-1); } const char* lookDirection_str = kwl.find(prefix,"lookDirection"); ossimString lookDirection(lookDirection_str) ; lookDirection.trim(" ") ; // eliminates trailing blanks if (lookDirection == "NORMAL") _sensor->set_sightDirection(SensorParams::Right) ; else _sensor->set_sightDirection(SensorParams::Left) ; _sensor->set_prf(fa); _sensor->set_sf(fr); _sensor->set_rwl(wave_length); _sensor->set_nAzimuthLook(n_azilok); _sensor->set_nRangeLook(n_rnglok); _sensor->set_semiMajorAxis(ellip_maj) ; _sensor->set_semiMinorAxis(ellip_min) ; return true; } bool ossimRadarSatModel::InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix) { const double _PI = 3.14159265358979323846 ; CivilDateTime ref_civil_date; /* * Ephemerisis reference date retrieval */ const char* eph_year_str = kwl.find(prefix,"eph_year"); int eph_year = atoi(eph_year_str); const char* eph_month_str = kwl.find(prefix,"eph_month"); int eph_month = atoi(eph_month_str); const char* eph_day_str = kwl.find(prefix,"eph_day"); int eph_day = atoi(eph_day_str); const char* eph_sec_str = kwl.find(prefix,"eph_sec"); double eph_sec = atof(eph_sec_str); ref_civil_date.set_year(eph_year); ref_civil_date.set_month(eph_month); ref_civil_date.set_day(eph_day); ref_civil_date.set_second((int)eph_sec); ref_civil_date.set_decimal( eph_sec-(double)((int)eph_sec)); JSDDateTime ref_jsd_date(ref_civil_date); const char* eph_int_str = kwl.find(prefix, "eph_int"); double eph_int = atof(eph_int_str); /* * Ephemerisis number retrieval */ const char* neph_str = kwl.find(prefix,"neph"); int neph = atoi(neph_str); Ephemeris** ephemeris = new Ephemeris*[neph]; const char* hr_angle_str = kwl.find(prefix,"hr_angle"); double greenwich_mha_ref = atof(hr_angle_str); GMSTDateTime * greenwich_mha_ref2000 = new GMSTDateTime(); greenwich_mha_ref2000->set_origine(GMSTDateTime::AN2000); ref_civil_date.AsGMSTDateTime(greenwich_mha_ref2000); /* * Ephemerisis retrieval */ for (int i=0;iset_origine(GMSTDateTime::AN2000); date.AsGMSTDateTime(greenwich_mha); double angle = greenwich_mha_ref+(greenwich_mha->get_tms()-greenwich_mha_ref2000->get_tms())*180.0/_PI; angle = fmod(angle,360.0); /* * Referential change */ GalileanEphemeris * tmpEphemeris = new GalileanEphemeris(date,pos,vit); GeographicEphemeris* eph = new GeographicEphemeris(); tmpEphemeris->ToGeographic(angle,eph); ephemeris[i] = eph; delete tmpEphemeris; delete greenwich_mha; } delete greenwich_mha_ref2000; /* * Antenna position interpolator creation */ if (_platformPosition != NULL) { delete _platformPosition; } _platformPosition = new PlatformPosition(ephemeris,neph); /* * Free of memory used by the ephemerisis list */ for (int i=0;iset_pix_col(sc_pix); _refPoint->set_pix_line(sc_lin); char year_str[5]; for (int i=0;i<4;i++) { year_str[i] = inp_sctim_str[i]; } year_str[4] = '\0'; char month_str[3]; for (int i=4;i<6;i++) { month_str[i-4] = inp_sctim_str[i]; } month_str[2] = '\0'; char day_str[3]; for (int i=6;i<8;i++) { day_str[i-6] = inp_sctim_str[i]; } day_str[2] = '\0'; char hour_str[3]; for (int i=8;i<10;i++) { hour_str[i-8] = inp_sctim_str[i]; } hour_str[2] = '\0'; char min_str[3]; for (int i=10;i<12;i++) { min_str[i-10] = inp_sctim_str[i]; } min_str[2] = '\0'; char sec_str[3]; for (int i=12;i<14;i++) { sec_str[i-12] = inp_sctim_str[i]; } sec_str[2] = '\0'; char mili_str[4]; for (int i=14;i<17;i++) { mili_str[i-14] = inp_sctim_str[i]; } mili_str[3] = '\0'; int year = atoi(year_str); int month = atoi(month_str); int day = atoi(day_str); int hour = atoi(hour_str); int min = atoi(min_str); int sec = atoi(sec_str); double mili = atof(mili_str); CivilDateTime date(year, month, day, hour * 3600 + min * 60 + sec, mili/1000.0); if(_platformPosition != NULL) { Ephemeris * ephemeris = _platformPosition->Interpolate((JSDDateTime)date); if (ephemeris == NULL) return false ; _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else { return false; } double c = 2.99792458e+8; double distance = (rng_gate + ((double)sc_pix)*_sensor->get_nRangeLook()/_sensor->get_sf()) * (c/2.0); // in the case of Georeferenced images, the "relative" ground range is stored in place of the slant range // (used for SlantRange computation relative to reference point, necessary for optimization) // here, the pixelDirection is ignored since the RDS reference point is always at the scene centre if (_isProductGeoreferenced) { distance = _refPoint->get_pix_col() * _pixel_spacing ; } _refPoint->set_distance(distance); //// essai : line spacing et speed satellite // const char* line_spacing_str = kwl.find(prefix,"line_spacing"); // double line_spacing = atof(line_spacing_str); // Ephemeris * ephemeris = _refPoint->get_ephemeris() ; // double velSat = sqrt(pow(ephemeris->get_speed()[0], 2)+ pow(ephemeris->get_speed()[1], 2)+ pow(ephemeris->get_speed()[2], 2)); // double prfeq = velSat / line_spacing ; // _sensor->set_prf(prfeq); // _sensor->set_nAzimuthLook(1.0); ///** // * @todo : effacer // */ // in order to use ossimSensorModel::lineSampleToWorld const char* nbCol_str = kwl.find(prefix,"nbCol"); const char* nbLin_str = kwl.find(prefix,"nbLin"); theImageSize.x = atoi(nbCol_str); theImageSize.y = atoi(nbLin_str); theImageClipRect = ossimDrect(0, 0, theImageSize.x-1, theImageSize.y-1); // sensor PRF update in the case of ground projected products if (_isProductGeoreferenced) { const char* acq_msec_first_str = kwl.find("acq_msec_first"); double acq_msec_first = atof(acq_msec_first_str); const char* acq_msec_last_str = kwl.find("acq_msec_last"); double acq_msec_last = atof(acq_msec_last_str); double actualPRF = 1000.0*theImageSize.y/(acq_msec_last-acq_msec_first) ; _sensor->set_nAzimuthLook(_sensor->get_prf()/actualPRF); } // Ground Control Points extracted from the model : scene center std::list groundGcpCoordinates ; std::list imageGcpCoordinates ; const char* lon_str = kwl.find("pro_long"); double lon = atof(lon_str); const char* lat_str = kwl.find("pro_lat"); double lat = atof(lat_str); //const char* height_str = kwl.find("terrain_height"); double height = 0 ; //atof(height_str) ; ossimDpt imageGCP(sc_pix,sc_lin); ossimGpt groundGCP(lat, lon, height); groundGcpCoordinates.push_back(groundGCP) ; imageGcpCoordinates.push_back(imageGCP) ; // Ground Control Points extracted from the model : scene corners // upper left corner lon = atof(kwl.find("cornersLon0")); lat = atof(kwl.find("cornersLat0")); ossimDpt imageGCP0(0,0); ossimGpt groundGCP0(lat, lon, height); groundGcpCoordinates.push_back(groundGCP0) ; imageGcpCoordinates.push_back(imageGCP0) ; // upper right corner lon = atof(kwl.find("cornersLon1")); lat = atof(kwl.find("cornersLat1")); ossimDpt imageGCP1(theImageSize.x-1,0); ossimGpt groundGCP1(lat, lon, height); groundGcpCoordinates.push_back(groundGCP1) ; imageGcpCoordinates.push_back(imageGCP1) ; // lower left corner lon = atof(kwl.find("cornersLon2")); lat = atof(kwl.find("cornersLat2")); ossimDpt imageGCP2(0,theImageSize.y-1); ossimGpt groundGCP2(lat, lon, height); groundGcpCoordinates.push_back(groundGCP2) ; imageGcpCoordinates.push_back(imageGCP2) ; // lower right corner lon = atof(kwl.find("cornersLon3")); lat = atof(kwl.find("cornersLat3")); ossimDpt imageGCP3(theImageSize.x-1,theImageSize.y-1); ossimGpt groundGCP3(lat, lon, height); groundGcpCoordinates.push_back(groundGCP3) ; imageGcpCoordinates.push_back(imageGCP3) ; // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates) ; return true; } bool ossimRadarSatModel::InitSRGR(const ossimKeywordlist &kwl, const char *prefix) { // product type : format "RSAT-1-SAR-{SLC,SGG,SGC,...}-..." const char* file_name_str = kwl.find(prefix,"file_name"); char format[4] ; // product type (SLC,SGG,SGC,...) extraction for (int j=11;j<14;j++) { format[j-11] = file_name_str[j]; } format[3] = '\0'; std::string format_str(format); _isProductGeoreferenced = (format_str=="SGX") || (format_str=="SGF") || (format_str=="SCW"); // pixel spacing const char* pixel_spacing_str = kwl.find(prefix,"pixel_spacing"); _pixel_spacing = atof(pixel_spacing_str); // number of SRGR sets const char* n_srgr_str = kwl.find(prefix,"n_srgr"); _n_srgr = atoi(n_srgr_str); char name[64]; for (int i=0;i<_n_srgr;i++) { // SRGR update time, format : YYYY-DDD-HH:MM:SS.SSS sprintf(name,"srgr_update%i",i); const char* srgr_update_str = kwl.find(prefix,name); // years and days are ignored in the following (conversion from CivilDate to JSDDate requires a YYYY-MM-DD format) // could be improved char hour_str[3]; for (int j=9;j<11;j++) { hour_str[j-9] = srgr_update_str[j]; } hour_str[2] = '\0'; char min_str[3]; for (int j=12;j<14;j++) { min_str[j-12] = srgr_update_str[j]; } min_str[2] = '\0'; char sec_str[3]; for (int j=15;j<17;j++) { sec_str[j-15] = srgr_update_str[j]; } sec_str[2] = '\0'; char mili_str[4]; for (int j=18;j<21;j++) { mili_str[j-18] = srgr_update_str[j]; } mili_str[3] = '\0'; int hour = atoi(hour_str); int min = atoi(min_str); int sec = atoi(sec_str); double mili = atof(mili_str); _srgr_update[i] = hour * 3600 + min * 60 + sec + mili/1000.0 ; // SRGR coefficients sprintf(name,"srgr_coef%iA",i); const char* srgr_coef_strA = kwl.find(prefix,name); _srgr_coefset[i][0] = atof(srgr_coef_strA); sprintf(name,"srgr_coef%iB",i); const char* srgr_coef_strB = kwl.find(prefix,name); _srgr_coefset[i][1] = atof(srgr_coef_strB); sprintf(name,"srgr_coef%iC",i); const char* srgr_coef_strC = kwl.find(prefix,name); _srgr_coefset[i][2] = atof(srgr_coef_strC); sprintf(name,"srgr_coef%iD",i); const char* srgr_coef_strD = kwl.find(prefix,name); _srgr_coefset[i][3] = atof(srgr_coef_strD); sprintf(name,"srgr_coef%iE",i); const char* srgr_coef_strE = kwl.find(prefix,name); _srgr_coefset[i][4] = atof(srgr_coef_strE); sprintf(name,"srgr_coef%iF",i); const char* srgr_coef_strF = kwl.find(prefix,name); _srgr_coefset[i][5] = atof(srgr_coef_strF); } return true; } int ossimRadarSatModel::FindSRGRSetNumber(JSDDateTime date) const { if (_n_srgr==0) return(-1) ; double delays[20]; for (int i=0;i<_n_srgr;i++) { delays[i] = fabs(date.get_second()+date.get_decimal()-_srgr_update[i]) ; } int setNumber = 0 ; double min_delay = delays[0] ; for (int i=1;i<_n_srgr;i++) { if (delays[i] #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { class PlatformPosition; class SensorParams; class RefPoint; /** * @brief This class is able to direct localisation and indirect localisation using the RadarSat sensor model */ class ossimRadarSatModel : public ossimGeometricSarSensorModel { public: /** @brief Constructor */ ossimRadarSatModel(); /** @brief copy constructor */ ossimRadarSatModel(const ossimRadarSatModel& rhs); /** @brief Destructor */ virtual ~ossimRadarSatModel(); /** * @brief Method to return the class name. * @return The name of this class. */ virtual ossimString getClassName() const; /** * @brief Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /** * @brief This function associates an image column number to a slant range when the image is georeferenced (ground projected) * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const; /** * @brief Method to intantial model from a file. * * @param file * * @return true on success, false on error. */ bool open(const ossimFilename& file); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); protected: /** * @brief Slant Range for each Ground Range (SRGR) number of coefficients sets */ int _n_srgr; /** * @brief SRGR coefficient sets */ double _srgr_coefset[20][6]; /** * @brief SRGR coefficient sets update times */ double _srgr_update[20]; /** * @brief Pixel spacing */ double _pixel_spacing; /** * @brief List of metadata contained in the Data file */ Data * _data; /** * @brief List of metadata contained in the Leader file */ Leader * _leader; /** * @brief List of metadata contained in the Trailer file */ Trailer * _trailer; /** * @brief List of metadata contained in the Volume Directory file */ VolumeDir * _volumeDir; private: virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Initializes the Slant Range for each Ground Range data sets : _n_srgr,_srgr_coefset,_srgr_update,_pixel_spacing,_isProductGeoreferenced */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool internalSaveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool internalLoadState (const ossimKeywordlist &kwl, const char *prefix=0); /** * @brief Finds the SRGR data set which update time is the closest to the center scene time */ int FindSRGRSetNumber(JSDDateTime date) const; TYPE_DATA }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimRangeUtilities.h000066400000000000000000000046311301006202600276550ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimRangeUtilities_h #define ossimRangeUtilities_h namespace ossimplugins { template inline std::size_t size(T (&)[N]) { return N; } template inline typename T::size_type size(T const& cont) { return cont.size(); } template inline T* begin(T (&array)[N]) { return &array[0]; } template inline typename T::iterator begin(T & cont) {return begin(cont);} template inline typename T::const_iterator begin(T const& cont) {return begin(cont);} template inline std::reverse_iterator rbegin(T (&array)[N]) { return std::reverse_iterator(&array[N]); } template inline typename T::reverse_iterator rbegin(T & cont) {return rbegin(cont);} template inline typename T::const_reverse_iterator rbegin(T const& cont) {return rbegin(cont);} template inline T* end(T (&array)[N]) { return &array[N]; } template inline typename T::iterator end(T & cont) {return end(cont);} template inline typename T::const_iterator end(T const& cont) {return end(cont);} template inline std::reverse_iterator rend(T (&array)[N]) { return std::reverse_iterator(&array[0]); } template inline typename T::reverse_iterator rend(T & cont) {return rend(cont);} template inline typename T::const_reverse_iterator rend(T const& cont) {return rend(cont);} namespace details { template char (&array_size_helper(T (&)[N]))[N]; #define array_size(array) (sizeof ::ossimplugins::details::array_size_helper(array)) } // details namespace } // ossimplugins namespace #endif // ossimRangeUtilities_h OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSarSensorModel.cpp000066400000000000000000001324461301006202600301660ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "ossimSarSensorModel.h" #include "ossimKeyWordListUtilities.h" #include "ossimTraceHelpers.h" #include "ossimRangeUtilities.h" #include "ossimSarSensorModelPathsAndKeys.h" #include #include #include #include #include #include #if defined(USE_BOOST_TIME) using boost::posix_time::microseconds; using boost::posix_time::seconds; #else using ossimplugins::time::microseconds; using ossimplugins::time::seconds; #endif namespace {// Anonymous namespace const bool k_verbose = false; // global verbose constant; TODO: use an option const unsigned int k_version = 2; // Sometimes, we don't need to compare the actual distance, its square value is // more than enough. inline double squareDistance(ossimDpt const& lhs, ossimDpt const& rhs) { const double dx = lhs.x - rhs.x; const double dy = lhs.y - rhs.y; return dx*dx + dy*dy; } inline double squareDistance(ossimGpt const& lhs, ossimGpt const& rhs) { const ossimEcefPoint l(lhs); const ossimEcefPoint r(rhs); return (l-r).norm2(); } template inline void unzip(Container const& in, Container& out_even, Container& out_odd) { typedef typename Container::const_iterator const_iterator; typedef typename Container::size_type size_type; const size_type size = in.size(); const bool has_a_odd_number_of_elements = size % 2 == 1; out_even.reserve(size/2+1); out_odd.reserve(size/2); const_iterator end = in.end(); if (has_a_odd_number_of_elements) { std::advance(end, -1); } for (const_iterator it=in.begin(); it != end ; ) { out_even.push_back(*it++); out_odd.push_back(*it++); } if (has_a_odd_number_of_elements) { assert(end != in.end()); out_even.push_back(*end); } assert(out_even.size() >= out_odd.size()); assert(out_odd.capacity() == size/2); // The correct number of element have been reserved assert(out_even.capacity() == size/2+1); // The correct number of element have been reserved assert(out_odd.size() + out_even.size() == size); } ossimTrace traceExec ("ossimSarSensorModel:exec"); ossimTrace traceDebug ("ossimSarSensorModel:debug"); typedef char const* const* strings_iterator; static char const* const PRODUCTTYPE_STRINGS[] = { "SLC", "GRD", "MGD", "GEC", "EEC" }; }// Anonymous namespace namespace ossimplugins { const double ossimSarSensorModel::C = 299792458; ossimSarSensorModel::ProductType::ProductType(string_view const& s) { using ossimplugins::begin; using ossimplugins::end; strings_iterator const ProductType_it = std::find(begin(::PRODUCTTYPE_STRINGS),end(::PRODUCTTYPE_STRINGS), s); if (ProductType_it == end(::PRODUCTTYPE_STRINGS)) { throw std::runtime_error("Invalid Sar Sensor Product type: `"+s+"'"); } m_value = Type(std::distance(begin(::PRODUCTTYPE_STRINGS), ProductType_it)); assert(m_value < MAX__); } string_view ossimSarSensorModel::ProductType::ToString() const { BOOST_STATIC_ASSERT((MAX__ == array_size(::PRODUCTTYPE_STRINGS))); assert(m_value != UNDEFINED__); // Yes, I know UNDEFINED__ > MAX__ assert(m_value < MAX__); return PRODUCTTYPE_STRINGS[m_value]; } ossimSarSensorModel::ossimSarSensorModel() : theRadarFrequency(0.), theAzimuthTimeInterval(seconds(0)), theNearRangeTime(0.), theRangeSamplingRate(0.), theRangeResolution(0.), theBistaticCorrectionNeeded(false), theAzimuthTimeOffset(seconds(0)), theRangeTimeOffset(0.) {} ossimSarSensorModel::GCPRecordType const& ossimSarSensorModel::findClosestGCP(ossimDpt const& imPt) const { assert(!theGCPRecords.empty()&&"theGCPRecords is empty."); // Find the closest GCP double distance2 = squareDistance(imPt, theGCPRecords.front().imPt); std::vector::const_iterator refGcp = theGCPRecords.begin(); std::vector::const_iterator gcpIt = theGCPRecords.begin(); std::vector::const_iterator gcpEnd = theGCPRecords.end(); for(++gcpIt ; gcpIt!=gcpEnd ; ++gcpIt) { const double currentDistance2 = squareDistance(imPt, gcpIt->imPt); if(currentDistance2 < distance2) { distance2 = currentDistance2; refGcp = gcpIt; } } assert(refGcp != theGCPRecords.end() && "A GCP record shall have been found!"); return *refGcp; } void ossimSarSensorModel::lineSampleHeightToWorld(const ossimDpt& imPt, const double & heightAboveEllipsoid, ossimGpt& worldPt) const { // std::clog << "ossimSarSensorModel::lineSampleHeightToWorld()\n"; assert(!theGCPRecords.empty()&&"theGCPRecords is empty."); GCPRecordType const& refGcp = findClosestGCP(imPt); // Set the height reference ossim_float64 hgtSet; if ( ossim::isnan(heightAboveEllipsoid) ) { hgtSet = refGcp.worldPt.height(); } else { hgtSet = heightAboveEllipsoid; } const ossimHgtRef hgtRef(AT_HGT, hgtSet); ossimEcefPoint ellPt; // Simple iterative inversion of inverse model starting at closest gcp projToSurface(refGcp,imPt,hgtRef,ellPt); worldPt = ossimGpt(ellPt); } void ossimSarSensorModel::lineSampleToWorld(ossimDpt const& imPt, ossimGpt& worldPt) const { // std::clog << "ossimSarSensorModel::lineSampleToWorld()\n"; assert(!theGCPRecords.empty()&&"theGCPRecords is empty."); GCPRecordType const& refGcp = findClosestGCP(imPt); ossimGpt const& refPt = refGcp.worldPt; const ossimHgtRef hgtRef(AT_DEM); ossimEcefPoint ellPt; // Simple iterative inversion of inverse model starting at closest gcp projToSurface(refGcp,imPt,hgtRef,ellPt); worldPt = ossimGpt(ellPt); } void ossimSarSensorModel::worldToLineSample(const ossimGpt& worldPt, ossimDpt & imPt) const { // std::clog << "ossimSarSensorModel::worldToLineSample()\n"; assert(theRangeResolution>0&&"theRangeResolution is null."); // First compute azimuth and range time TimeType azimuthTime; double rangeTime; const bool success = worldToAzimuthRangeTime(worldPt, azimuthTime, rangeTime); if(!success) { imPt.makeNan(); return; } // std::clog << "AzimuthTime: " << azimuthTime << "\n"; // std::clog << "RangeTime: " << rangeTime << "\n"; // std::clog << "GRD: " << isGRD() << "\n"; // Convert azimuth time to line azimuthTimeToLine(azimuthTime,imPt.y); if(isGRD()) { // GRD case double groundRange(0); slantRangeToGroundRange(rangeTime*C/2,azimuthTime,groundRange); // std::clog << "GroundRange: " << groundRange << "\n"; // std::clog << "TheRangeResolution: " << theRangeResolution << "\n"; // Eq 32 p. 31 // TODO: possible micro-optimization: precompute 1/theRangeResolution, and // use * imPt.x = groundRange/theRangeResolution; } else { // std::clog << "TheNearRangeTime: " << theNearRangeTime << "\n"; // std::clog << "TheRangeSamplingRate: " << theRangeSamplingRate << "\n"; // SLC case // Eq 23 and 24 p. 28 imPt.x = (rangeTime - theNearRangeTime)*theRangeSamplingRate; } } bool ossimSarSensorModel::worldToAzimuthRangeTime(const ossimGpt& worldPt, TimeType & azimuthTime, double & rangeTime) const { // std::clog << "ossimSarSensorModel::worldToAzimuthRangeTime()\n"; // First convert lat/lon to ECEF ossimEcefPoint inputPt(worldPt); // Compute zero doppler time TimeType interpTime; ossimEcefPoint interpSensorPos; ossimEcefVector interpSensorVel; const bool success = zeroDopplerLookup(inputPt,azimuthTime,interpSensorPos,interpSensorVel); if(!success) { // TODO: check whether we could throw instead return false; } if(theBistaticCorrectionNeeded) { // Compute bistatic correction if needed DurationType bistaticCorrection; computeBistaticCorrection(inputPt,interpSensorPos,bistaticCorrection); // Update interpolated azimuth time azimuthTime += bistaticCorrection; // Update sensor position and velocity interpolateSensorPosVel(interpTime,interpSensorPos,interpSensorVel); } // rangeTime is the round-tripping time to target const double rangeDistance = (interpSensorPos-inputPt).magnitude(); rangeTime = theRangeTimeOffset + 2*rangeDistance/C; return true; } void ossimSarSensorModel::lineSampleToAzimuthRangeTime(const ossimDpt & imPt, TimeType & azimuthTime, double & rangeTime) const { // std::clog << "ossimSarSensorModel::lineSampleToAzimuthRangeTime()\n"; // First compute azimuth time here lineToAzimuthTime(imPt.y,azimuthTime); // Then compute range time if(isGRD()) { // Handle grd case here double slantRange; groundRangeToSlantRange(imPt.x*theRangeResolution,azimuthTime, slantRange); rangeTime = theRangeTimeOffset + 2*slantRange/C; } else { rangeTime = theRangeTimeOffset + theNearRangeTime + imPt.x*(1/theRangeSamplingRate); } } void ossimSarSensorModel::computeRangeDoppler(const ossimEcefPoint & inputPt, const ossimEcefPoint & sensorPos, const ossimEcefVector sensorVel, double & range, double & doppler) const { // std::clog << "ossimSarSensorModel::computeRangeDoppler()\n"; assert(theRadarFrequency>0&&"theRadarFrequency is null"); // eq. 19, p. 25 const ossimEcefVector s2gVec = inputPt - sensorPos; range = s2gVec.magnitude(); const double coef = -2*C/(theRadarFrequency*range); doppler = coef * sensorVel.dot(s2gVec); } void ossimSarSensorModel::interpolateSensorPosVel(const TimeType & azimuthTime, ossimEcefPoint& sensorPos, ossimEcefVector& sensorVel, unsigned int deg) const { assert(!theOrbitRecords.empty()&&"The orbit records vector is empty"); // Lagrangian interpolation of sensor position and velocity unsigned int nBegin(0), nEnd(0); sensorPos[0] = 0; sensorPos[1] = 0; sensorPos[2] = 0; sensorVel[0] = 0; sensorVel[1] = 0; sensorVel[2] = 0; // First, we search for the correct set of record to use during // interpolation // If there are less records than degrees, use them all if(theOrbitRecords.size()::const_iterator it = theOrbitRecords.begin();it!=theOrbitRecords.end();++it,++count) { const DurationType current_time = abs(azimuthTime-it->azimuthTime); if(t_min > current_time) { t_min_idx = count; t_min = current_time; } } // TODO: see if these expressions can be simplified nBegin = std::max((int)t_min_idx-(int)deg/2+1,(int)0); nEnd = std::min(nBegin+deg-1,(unsigned int)theOrbitRecords.size()); nBegin = nEnd & records, double & out) const { assert(!records.empty()&&"The records vector is empty."); // std::clog << "conv coord(" << in << ", az="<::const_iterator it = records.begin(); CoordinateConversionRecordType srgrRecord; std::vector::const_iterator previousRecord = it; ++it; std::vector::const_iterator nextRecord = it; // Look for the correct record // std::clog << "Looking for " << azimuthTime << " within records:\n"; while(it!=records.end()) { // std::clog << "- record: " << it->azimuthTime << "..."; // nextRecord = it; if(azimuthTime >= previousRecord->azimuthTime && azimuthTime < nextRecord->azimuthTime) { // std::clog << " found!\n"; break; } else { previousRecord = nextRecord; ++it; nextRecord = it; // std::clog << " NOT found => next!\n"; } } assert(nextRecord == it); if(it == records.end()) { if(azimuthTime < records.front().azimuthTime) { srgrRecord = records.front(); // std::clog << "Not found, but before first => srgrRecord: " << srgrRecord.azimuthTime << "\n"; } else if(azimuthTime >= records.back().azimuthTime) { srgrRecord = records.back(); // std::clog << "Not found, but after last => srgrRecord: " << srgrRecord.azimuthTime << "\n"; } } else { assert(nextRecord != records.end()); assert(!previousRecord->coefs.empty()&&"previousRecord coefficients vector is empty."); assert(!nextRecord->coefs.empty()&&"nextRecord coefficients vector is empty."); // If azimuth time is between 2 records, interpolate const double interp = DurationType(azimuthTime - previousRecord->azimuthTime) / (nextRecord->azimuthTime - previousRecord->azimuthTime) ; // std::clog << "interp: " << interp << " =" // << " (" << azimuthTime << " - " << previousRecord->azimuthTime << " (="<< (azimuthTime - previousRecord->azimuthTime)<< ") )" // << "/(" << nextRecord->azimuthTime << " - " << previousRecord->azimuthTime << " (="<< (nextRecord->azimuthTime - previousRecord->azimuthTime)<< ") )" // << "\n"; srgrRecord.rg0 = (1-interp) * previousRecord->rg0 + interp*nextRecord->rg0; srgrRecord.coefs.clear(); std::vector::const_iterator pIt = previousRecord->coefs.begin(); std::vector::const_iterator nIt = nextRecord->coefs.begin(); for(;pIt != previousRecord->coefs.end() && nIt != nextRecord->coefs.end();++pIt,++nIt) { srgrRecord.coefs.push_back(interp*(*nIt)+(1-interp)*(*pIt)); } assert(!srgrRecord.coefs.empty()&&"Slant range to ground range interpolated coefficients vector is empty."); } // Now that we have the interpolated coefs, compute ground range // from slant range const double sr_minus_sr0 = in-srgrRecord.rg0; assert(!srgrRecord.coefs.empty()&&"Slant range to ground range coefficients vector is empty."); out = 0; for(std::vector::const_reverse_iterator cIt = srgrRecord.coefs.rbegin();cIt!=srgrRecord.coefs.rend();++cIt) { out = *cIt + sr_minus_sr0*out; } } bool ossimSarSensorModel::zeroDopplerLookup(const ossimEcefPoint & inputPt, TimeType & interpAzimuthTime, ossimEcefPoint & interpSensorPos, ossimEcefVector & interpSensorVel) const { assert((theOrbitRecords.size()>=2) && "Orbit records vector contains less than 2 elements"); std::vector::const_iterator it = theOrbitRecords.begin(); double doppler2(0.); // Compute range and doppler of first record // NOTE: here we only use the scalar product with vel and discard // the constant coef as it has no impact on doppler sign double doppler1 = (inputPt-it->position).dot(it->velocity); bool dopplerSign1 = doppler1 < 0; ++it; // -> it != begin // Look for the consecutive records where doppler freq changes sign // Note: implementing a bisection algorithm here might be faster for ( ; it!=theOrbitRecords.end() ; ++it) { // compute range and doppler of current record doppler2 = (inputPt-it->position).dot(it->velocity); const bool dopplerSign2 = doppler2 <0; // If a change of sign is detected if(dopplerSign1 != dopplerSign2) { break; } else { doppler1 = doppler2; } } // In this case, we need to extrapolate if(it == theOrbitRecords.end()) { std::vector::const_iterator record1 = theOrbitRecords.begin(); std::vector::const_iterator record2 = record1 + theOrbitRecords.size()-1; doppler1 = (inputPt-record1->position).dot(record1->velocity); doppler2 = (inputPt-record2->position).dot(record2->velocity); const DurationType delta_td = record2->azimuthTime - record1->azimuthTime; interpAzimuthTime = record1->azimuthTime - doppler1 / (doppler2 - doppler1) * delta_td; } else { assert(it != theOrbitRecords.begin()); assert(it != theOrbitRecords.end()); std::vector::const_iterator record2 = it; std::vector::const_iterator record1 = --it; // now interpolate time and sensor position const double abs_doppler1 = std::abs(doppler1); const double interpDenom = abs_doppler1+std::abs(doppler2); assert(interpDenom>0&&"Both doppler frequency are null in interpolation weight computation"); const double interp = abs_doppler1/interpDenom; // std::clog << "interp: " << interp << "\n"; const DurationType delta_td = record2->azimuthTime - record1->azimuthTime; // std::clog << "delta_td: " << delta_td << " = " << record2->azimuthTime <<" - " <azimuthTime<< "\n"; // Compute interpolated time offset wrt record1 // (No need for that many computations (day-frac -> ms -> day frac)) const DurationType td = delta_td * interp; // std::clog << "td: " << td << "(" << td.total_microseconds() << "us)\n"; // Compute interpolated azimuth time interpAzimuthTime = record1->azimuthTime + td + theAzimuthTimeOffset; } // std::clog << "interpAzimuthTime: " << interpAzimuthTime << "\n"; // Interpolate sensor position and velocity interpolateSensorPosVel(interpAzimuthTime,interpSensorPos, interpSensorVel); return true; } void ossimSarSensorModel::computeBistaticCorrection(const ossimEcefPoint & inputPt, const ossimEcefPoint & sensorPos, DurationType & bistaticCorrection) const { // Bistatic correction (eq 25, p 28) double halftrange = 1000000. * (sensorPos-inputPt).magnitude()/C; bistaticCorrection= microseconds(static_cast(floor(halftrange+0.5))); } void ossimSarSensorModel::azimuthTimeToLine(const TimeType & azimuthTime, double & line) const { assert(!theBurstRecords.empty()&&"Burst records are empty (at least one burst should be available)"); std::vector::const_iterator currentBurst = theBurstRecords.begin(); // Look for the correct burst. In most cases the number of burst // records will be 1 (except for TOPSAR Sentinel1 products) std::vector::const_iterator it = theBurstRecords.begin(); std::vector::const_iterator itend = theBurstRecords.end(); for(; it!= itend ; ++it) { if(azimuthTime >= it->azimuthStartTime && azimuthTime < it->azimuthStopTime) { currentBurst = it; break; } } // If no burst is found, we will use the first (resp. last burst to // extrapolate line if(it == itend) { if(! theBurstRecords.empty()) { if(azimuthTime < theBurstRecords.front().azimuthStartTime) { currentBurst = theBurstRecords.begin(); } else if (azimuthTime > theBurstRecords.back().azimuthStopTime) { currentBurst = theBurstRecords.end()-1; } } else { // Fall back to the only record currentBurst = theBurstRecords.begin(); } } const DurationType timeSinceStart = azimuthTime - currentBurst->azimuthStartTime; // Eq 22 p 27 line = (timeSinceStart/theAzimuthTimeInterval) + currentBurst->startLine; // std::clog << "line = " << line << " <- " << timeSinceStart << "/" << theAzimuthTimeInterval << "+" << currentBurst->startLine << "\n"; } void ossimSarSensorModel::lineToAzimuthTime(const double & line, TimeType & azimuthTime) const { assert(!theBurstRecords.empty()&&"Burst records are empty (at least one burst should be available)"); std::vector::const_iterator currentBurst = theBurstRecords.begin(); if(theBurstRecords.size() != 1) { // Look for the correct burst. In most cases the number of burst // records will be 1 (except for TOPSAR Sentinel1 products) std::vector::const_iterator it = theBurstRecords.begin(); std::vector::const_iterator itend = theBurstRecords.end(); for( ; it!= itend; ++it) { if(line >= it->startLine && line < it->endLine) { currentBurst = it; break; } } if(it == itend) { if(line < theBurstRecords.front().startLine) { currentBurst = theBurstRecords.begin(); } else if (line >= theBurstRecords.back().endLine) { currentBurst = theBurstRecords.end()-1; } } } const DurationType timeSinceStart = (line - currentBurst->startLine)*theAzimuthTimeInterval; // std::clog << "timeSinceStart: " << timeSinceStart.total_microseconds() << "us\n"; // Eq 22 p 27 azimuthTime = currentBurst->azimuthStartTime + timeSinceStart + theAzimuthTimeOffset; // std::clog << "offset: " << theAzimuthTimeOffset << "\n"; // std::clog << "->azimuthTime: " << azimuthTime << "\n"; } bool ossimSarSensorModel::projToSurface(const GCPRecordType & initGcp, const ossimDpt & target, const ossimHgtRef & hgtRef, ossimEcefPoint & ellPt) const { // Initialize current estimation ossimEcefPoint currentEstimation(initGcp.worldPt); // Compute corresponding image position // std::clog << "initGCP: " << initGcp.imPt << "\n"; ossimDpt currentImPoint(initGcp.imPt); ossim_float64 currentImSquareResidual = squareDistance(target,currentImPoint); double currentHeightResidual = initGcp.worldPt.height() - hgtRef.getRefHeight(initGcp.worldPt); bool init = true; unsigned int iter = 0; // TODO: Every time the function is called, an allocation (+a free) is done. // This is not efficient. => Find a static matrix of 3x3 elements // Moreover, NEWMAT implies a lot of objet creations, hence allocations NEWMAT::SymmetricMatrix BtB(3); NEWMAT::ColumnVector BtF(3); NEWMAT::ColumnVector F(3); NEWMAT::ColumnVector dR(3); // Stop condition: img residual < 1e-2 pixels, height residual² < // 0.01² m, nb iter < 50. init ensure that loop runs at least once. while((init || (currentImSquareResidual > (0.01*0.01) || std::abs(currentHeightResidual) > 0.01)) && iter < 50) { if(init) init =false; // std::clog<<"Iter: "<::const_iterator gcpIt = theGCPRecords.begin(); gcpIt!=theGCPRecords.end();++gcpIt,++gcpId) { ossimDpt estimatedImPt; TimeType estimatedAzimuthTime; double estimatedRangeTime; // Estimate times const bool s1 = this->worldToAzimuthRangeTime(gcpIt->worldPt,estimatedAzimuthTime,estimatedRangeTime); this->worldToLineSample(gcpIt->worldPt,estimatedImPt); const bool thisSuccess = s1 && (std::abs(estimatedImPt.x - gcpIt->imPt.x) <= xtol) && (std::abs(estimatedImPt.y - gcpIt->imPt.y) <= ytol) && (std::abs((estimatedAzimuthTime-gcpIt->azimuthTime).total_microseconds()) <= azTimeTol) && (std::abs(estimatedRangeTime - gcpIt->slantRangeTime) <= rangeTimeTol) ; const bool verbose = k_verbose; success = success && thisSuccess; if(verbose) { std::clog<<"GCP #"< gcpRecordSave, testGcps; gcpRecordSave.swap(theGCPRecords); // steal the data; `gcpRecordSave = move(theGCPRecords);` in C++11 unsigned int count = 0; unzip(gcpRecordSave, theGCPRecords, testGcps); assert(theGCPRecords.size() >= testGcps.size()); bool success = true; const bool verbose = k_verbose; unsigned int gcpId = 1; // std::clog << testGcps.size() << " GCPS\n"; for(std::vector::const_iterator gcpIt = testGcps.begin(); gcpIt!=testGcps.end();++gcpIt,++gcpId) { ossimGpt estimatedWorldPt; ossimGpt const& refPt = gcpIt->worldPt; double estimatedRangeTime; TimeType estimatedAzimuthTime; lineSampleToAzimuthRangeTime(gcpIt->imPt,estimatedAzimuthTime,estimatedRangeTime); lineSampleHeightToWorld(gcpIt->imPt,refPt.height(),estimatedWorldPt); const double res = squareDistance(refPt, estimatedWorldPt); if(res>resTol || estimatedWorldPt.hasNans()) { success = false; if(verbose) { std::clog<<"GCP #"<imPt<<'\n'; std::clog<<"World point: ref="<::const_iterator gcpIt = theGCPRecords.begin(); gcpIt!=theGCPRecords.end();++gcpIt) { ossimDpt estimatedImPt; TimeType estimatedAzimuthTime; double estimatedRangeTime; // Estimate times const bool s1 = this->worldToAzimuthRangeTime(gcpIt->worldPt,estimatedAzimuthTime,estimatedRangeTime); if(s1) { cumulAzimuthTime -= (estimatedAzimuthTime-gcpIt->azimuthTime); ++count; } } theAzimuthTimeOffset = count > 0 ? cumulAzimuthTime / count : DurationType(0); // Then, fix the range time count=0; for(std::vector::const_iterator gcpIt = theGCPRecords.begin(); gcpIt!=theGCPRecords.end();++gcpIt) { ossimDpt estimatedImPt; TimeType estimatedAzimuthTime; double estimatedRangeTime; // Estimate times const bool s1 = this->worldToAzimuthRangeTime(gcpIt->worldPt,estimatedAzimuthTime,estimatedRangeTime); if(s1) { cumulRangeTime+=-estimatedRangeTime+gcpIt->slantRangeTime; ++count; } } theRangeTimeOffset = count > 0 ? cumulRangeTime/count : 0; } void get( ossimKeywordlist const& kwl, std::vector & orbitRecords) { char orbit_prefix_[256]; std::size_t nbOrbits; try { get(kwl, "orbitList.nb_orbits", nbOrbits); } catch (kw_runtime_error const& e) { nbOrbits = 0; ossimRegExp regExp; regExp.compile("orbitList\\.orbit\\[.*\\]\\.time"); ossimKeywordlist::KeywordMap::const_iterator i = kwl.getMap().begin(); for(; i != kwl.getMap().end(); ++i) { if(regExp.find( (*i).first.c_str())) { ++nbOrbits; } } // Method getNumberOfKeysThatMatch not available in ossim 1.8.16 //nbOrbits = kwl.getNumberOfKeysThatMatch("orbitList\\.orbit\\[.*\\]\\.time"); ossimNotify(ossimNotifyLevel_WARN) << "WARNING: " << e.what() << "\n\tNumber of orbits manually counted to " << nbOrbits << ".\n\tPlease update your geom file.\n"; } for (std::size_t i=0; i!=nbOrbits ; ++i) { const int pos = s_printf(orbit_prefix_, "orbitList.orbit[%d].", int(i)); assert(pos > 0 && pos < 256); const std::string orbit_prefix(orbit_prefix_, pos); ossimSarSensorModel::OrbitRecordType orbitRecord; get(kwl, orbit_prefix + keyTime, orbitRecord.azimuthTime); get(kwl, orbit_prefix + keyPosX, orbitRecord.position[0]); get(kwl, orbit_prefix + keyPosY, orbitRecord.position[1]); get(kwl, orbit_prefix + keyPosZ, orbitRecord.position[2]); get(kwl, orbit_prefix + keyVelX, orbitRecord.velocity[0]); get(kwl, orbit_prefix + keyVelY, orbitRecord.velocity[1]); get(kwl, orbit_prefix + keyVelZ, orbitRecord.velocity[2]); orbitRecords.push_back(orbitRecord); } } void get( ossimKeywordlist const& kwl, std::vector & burstRecords) { char burstPrefix_[1024]; std::size_t nbBursts ; get(kwl, BURST_NUMBER_KEY, nbBursts); for (std::size_t burstId=0; burstId!=nbBursts ; ++burstId) { const int pos = s_printf(burstPrefix_, "%s[%d].", BURST_PREFIX.c_str(), burstId); assert(pos > 0 && pos < sizeof(burstPrefix_)); const std::string burstPrefix(burstPrefix_, pos); ossimSarSensorModel::BurstRecordType burstRecord; get(kwl, burstPrefix + keyStartLine, burstRecord.startLine); get(kwl, burstPrefix + keyEndLine, burstRecord.endLine); get(kwl, burstPrefix + keyAzimuthStartTime, burstRecord.azimuthStartTime); get(kwl, burstPrefix + keyAzimuthStopTime, burstRecord.azimuthStopTime); burstRecords.push_back(burstRecord); } } void get( ossimKeywordlist const& kwl, std::vector & gcpRecords) { char prefix_[1024]; std::size_t nbGCPs ; get(kwl, GCP_NUMBER_KEY, nbGCPs); for (std::size_t gcpId=0; gcpId!=nbGCPs ; ++gcpId) { const int pos = s_printf(prefix_, "%s[%d].", GCP_PREFIX.c_str(), gcpId); assert(pos > 0 && pos < sizeof(prefix_)); const std::string prefix(prefix_, pos); ossimSarSensorModel::GCPRecordType gcpRecord; get(kwl, prefix, keyAzimuthTime, gcpRecord.azimuthTime); get(kwl, prefix, keySlantRangeTime, gcpRecord.slantRangeTime); get(kwl, prefix, keyImPtX, gcpRecord.imPt.x); get(kwl, prefix, keyImPtY, gcpRecord.imPt.y); get(kwl, prefix, keyWorldPtLat, gcpRecord.worldPt.lat); get(kwl, prefix, keyWorldPtLon, gcpRecord.worldPt.lon); get(kwl, prefix, keyWorldPtHgt, gcpRecord.worldPt.hgt); gcpRecords.push_back(gcpRecord); } } void get( ossimKeywordlist const& kwl, std::string const& sr_gr_prefix, std::string const& rg0, std::vector & outputRecords) { char prefix_[1024]; std::size_t nbCoords ; get(kwl, sr_gr_prefix +"."+ NUMBER_KEY, nbCoords); for (std::size_t idx=0 ; idx!=nbCoords ; ++idx) { const int pos = s_printf(prefix_, "%s[%d].", sr_gr_prefix.c_str(), idx); assert(pos >= sizeof(SR_PREFIX)+4 && pos < sizeof(prefix_)); std::string prefix(prefix_, pos); ossimSarSensorModel::CoordinateConversionRecordType coordRecord; get(kwl, prefix + keyAzimuthTime, coordRecord.azimuthTime); get(kwl, prefix + rg0, coordRecord.rg0); std::size_t nbCoeffs; get(kwl, prefix + NUMBER_KEY, nbCoeffs); for (std::size_t coeff_idx=0; coeff_idx!=nbCoeffs ; ++coeff_idx) { const int pos2 = s_printf(prefix_+pos, sizeof(prefix_)-pos, "coeff[%d]", coeff_idx); assert(pos2 > 0 && pos+pos2 < sizeof(prefix_)); prefix.assign(prefix_, pos+pos2); double coeff; get(kwl, prefix, coeff); coordRecord.coefs.push_back(coeff); } outputRecords.push_back(coordRecord); } } bool ossimSarSensorModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { SCOPED_LOG(traceDebug, "ossimplugins::ossimSarSensorModel::loadState"); add(kwl, HEADER_PREFIX, "version", k_version); return ossimSensorModel::saveState(kwl, prefix); } bool ossimSarSensorModel::loadState(ossimKeywordlist const& kwl, const char* prefix) { // std::clog << "ossimSarSensorModel::loadState()\n"; static const char MODULE[] = "ossimplugins::ossimSarSensorModel::loadState"; SCOPED_LOG(traceDebug, MODULE); try { const bool success = ossimSensorModel::loadState(kwl, prefix); if (!success) { return false; } // And finally, extract data into fields std::string product_type_string; get(kwl, SUPPORT_DATA_PREFIX + "product_type", product_type_string); theProductType = ProductType(product_type_string); get(kwl, SUPPORT_DATA_PREFIX, "slant_range_to_first_pixel", theNearRangeTime ); get(kwl, SUPPORT_DATA_PREFIX, "range_sampling_rate" , theRangeSamplingRate ); get(kwl, SUPPORT_DATA_PREFIX, "range_spacing" , theRangeResolution ); get(kwl, SUPPORT_DATA_PREFIX, "radar_frequency" , theRadarFrequency ); double azimuthTimeInterval = 0.; // in seconds get(kwl, SUPPORT_DATA_PREFIX, "line_time_interval" , azimuthTimeInterval); #if defined(USE_BOOST_TIME) theAzimuthTimeInterval = boost::posix_time::precise_duration(azimuthTimeInterval * 1000000.); #else theAzimuthTimeInterval = seconds(azimuthTimeInterval); #endif get(kwl, theOrbitRecords); // TODO: don't fetch burst records if already read thanks to xml loading // that required them theBurstRecords.clear(); get(kwl, theBurstRecords); if (isGRD()) { get(kwl, SR_PREFIX, keySr0, theSlantRangeToGroundRangeRecords); get(kwl, GR_PREFIX, keyGr0, theGroundRangeToSlantRangeRecords); } get(kwl, theGCPRecords); try { unsigned int version; get(kwl, HEADER_PREFIX, "version", version); if (version < k_version) { throw std::runtime_error("Geom file generated with previous version of ossim plugins"); } } catch (...) { throw std::runtime_error("Geom file generated with previous version of ossim plugins"); } optimizeTimeOffsetsFromGcps(); return true; } catch (std::runtime_error const& e) { ossimNotify(ossimNotifyLevel_WARN) << "WARNING: " << e.what() << "\n\tIt won't be possible to orthorectify the associated images!" << "\n\tPlease upgrade your geom file.\n"; } return false; } } namespace ossimplugins { template inline std::ostream & operator<<(std::ostream & os, const std::vector & v) { for (typename std::vector::const_iterator b = v.begin(), e = v.end() ; b != e ; ++b ) { os << "- " << *b << "\n"; } return os; } } // ossimplugins namespace /*virtual*/ std::ostream& ossimplugins::ossimSarSensorModel::print(std::ostream& out) const { return ossimSensorModel::print(out) << "\n ossimSarSensorModel data-members:\n" << "\n theRadarFrequency: " << theRadarFrequency << "Hz" << "\n theAzimuthTimeInterval: " << theAzimuthTimeInterval.total_microseconds() << "us" << "\n theNearRangeTime: " << theNearRangeTime << "s" << "\n theRangeSamplingRate: " << theRangeSamplingRate << "Hz" << "\n theRangeResolution: " << theRangeResolution << "m" << "\n theBistaticCorrectionNeeded: " << theBistaticCorrectionNeeded << "\n theProductType: " << theProductType << "\n theAzimuthTimeOffset: " << theAzimuthTimeOffset.total_microseconds() << "us offset" << "\n theRangeTimeOffset: " << theRangeTimeOffset << "s offset" << "\n theGCPRecords: " << "\n" << theGCPRecords << "\n theOrbitRecords: " << "\n" << theOrbitRecords << "\n theBurstRecords: " << "\n" << theBurstRecords << "\n theSlantRangeToGroundRangeRecords: " << "\n" << theSlantRangeToGroundRangeRecords << "\n theGroundRangeToSlantRangeRecords: " << "\n" << theGroundRangeToSlantRangeRecords << "\n" ; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSarSensorModel.h000066400000000000000000000326711301006202600276320ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimSarSensorModel_HEADER #define ossimSarSensorModel_HEADER #include #include #include #include #if defined(__GNUC__) || defined(__clang__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wunused-parameter" # pragma GCC diagnostic ignored "-Woverloaded-virtual" # pragma GCC diagnostic ignored "-Wshadow" # include # include # include "ossimTimeUtilities.h" # pragma GCC diagnostic pop #else # include # include # include "ossimTimeUtilities.h" #endif #if defined(USE_BOOST_TIME) # include #include #endif namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimSarSensorModel : public ossimSensorModel { public: struct ProductType : private equality_comparable , private less_than_comparable { enum Type { SLC, GRD, MGD, GEC, EEC, MAX__, UNDEFINED__, FIRST__=0 }; explicit ProductType(unsigned char value) : m_value(Type(value)) { if (value >= MAX__) throw std::runtime_error("Invalid Sar Sensor Product Type id"); } ProductType(Type value) : m_value(Type(value)) { assert(m_value < MAX__); } ProductType() : m_value(UNDEFINED__) {} ProductType(string_view const& s); ProductType& operator++() { assert(m_value < MAX__); m_value = ProductType::Type(m_value+1); return *this; } ProductType operator++(int) { ProductType tmp = *this; ++*this; return tmp; } string_view ToString() const; Type ToInternal() const { return m_value; } friend bool operator< (ProductType lhs, ProductType rhs) { return lhs.m_value < rhs.m_value; } friend bool operator==(ProductType lhs, ProductType rhs) { return lhs.m_value == rhs.m_value; } friend std::ostream & operator<<(std::ostream & os, const ossimSarSensorModel::ProductType & v) { return os << v.ToString(); } static ProductType Max () { return ProductType(build_max()); } static ProductType begin() { return FIRST__; } static ProductType end () { return ProductType(build_max()); } private: struct build_max {}; ProductType(build_max) : m_value(MAX__) {} Type m_value; }; #if defined(USE_BOOST_TIME) typedef boost::posix_time::ptime TimeType; typedef boost::posix_time::precise_duration DurationType; #else typedef time::ModifiedJulianDate TimeType; typedef time::Duration DurationType; #endif struct OrbitRecordType { TimeType azimuthTime; ossimEcefPoint position; ossimEcefVector velocity; friend std::ostream & operator<<(std::ostream & os, const OrbitRecordType & v) { return os << "{ azimuthTime: " << v.azimuthTime << ", position: " << v.position << ", velocity: " << v.velocity << "}"; } }; struct GCPRecordType { TimeType azimuthTime; double slantRangeTime; ossimDpt imPt; ossimGpt worldPt; friend std::ostream & operator<<(std::ostream & os, const GCPRecordType & v) { return os << "{ azimuthTime: " << v.azimuthTime << ", imPt: " << v.imPt << ", worldPt: " << v.worldPt << "}"; } }; struct BurstRecordType { TimeType azimuthStartTime; unsigned long startLine; TimeType azimuthStopTime; unsigned long endLine; friend std::ostream & operator<<(std::ostream & os, const BurstRecordType & v) { return os << "{ azimuthStartTime: " << v.azimuthStartTime << ", azimuthStopTime: " << v.azimuthStopTime << ", startLine: " << v.startLine << ", stopLine: " << v.endLine << "}"; } }; struct IsWithin { IsWithin(BurstRecordType const& br) : m_start(br.azimuthStartTime) , m_stop(br.azimuthStartTime) {} bool operator()(TimeType v) const { return m_start <= v && v < m_stop; } private: TimeType m_start; TimeType m_stop; }; struct DoesContain { DoesContain(TimeType value) : m_value(value) {} bool operator()(BurstRecordType const& br) const { return br.azimuthStartTime <= m_value && m_value < br.azimuthStopTime; } private: TimeType m_value; }; struct CoordinateConversionRecordType { TimeType azimuthTime; double rg0; std::vector coefs; friend std::ostream & operator<<(std::ostream & os, const CoordinateConversionRecordType & v) { return os << "{ azimuthTime: " << v.azimuthTime << ", rg0: " << v.rg0 << ", coeffs: " << v.coefs.size() << "}"; } }; /** Constructor */ ossimSarSensorModel(); #if ! (defined(BOOST_NO_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX1_DEFAULTED_FUNCTIONS)) /** Copy constructor */ ossimSarSensorModel(ossimSarSensorModel const& m) = default; /** Move constructor */ ossimSarSensorModel(ossimSarSensorModel && m) = default; /** Destructor */ virtual ~ossimSarSensorModel() = default; #endif virtual void lineSampleHeightToWorld(const ossimDpt& imPt, const double & heightEllipsoid, ossimGpt& worldPt) const; virtual void lineSampleToWorld(const ossimDpt& imPt, ossimGpt& worldPt) const; /** This method implement inverse sar geolocation using method found * in ESA document "Guide to ASAR geocoding" (ref * RSL-ASAR-GC-AD). Equation numbers can be found in source code * comments. * * \param[in] worldPt World point to geocode * \param[out] imPt Corresponding estimated image point */ virtual void worldToLineSample(const ossimGpt& worldPt, ossimDpt & imPt) const; /** * Sub-routine of lineSampleToWorld that computes azimuthTime and * slant range time from worldPoint * * \param[in] worldPoint World point to geocode * \param[out] azimuthTime Estimated zero-doppler azimuth time * \param[out] rangeTime Estimated range time * \return True if success, false otherwise. In this case, * azimuthTime and rangeTime will not be modified. */ /*virtual*/ bool worldToAzimuthRangeTime(const ossimGpt& worldPt, TimeType & azimuthTime, double & rangeTime) const; // TODO: document me /*virtual*/ void lineSampleToAzimuthRangeTime(const ossimDpt & imPt, TimeType & azimuthTime, double & rangeTime) const; // TODO: document me bool autovalidateInverseModelFromGCPs(const double & xtol = 1, const double & ytol = 1, const double azTimeTol = 500, const double &rangeTimeTo=0.0000000001) const; // TODO: document me bool autovalidateForwardModelFromGCPs(double resTol = 25); //Pure virtual in base class bool useForward() const; void optimizeTimeOffsetsFromGcps(); /** * Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; //TODO: Add virtual method readAnnotationFile? virtual bool saveState(ossimKeywordlist & kwl, const char* prefix=NULL) const; virtual bool loadState(ossimKeywordlist const& kwl, const char* prefix=NULL); bool isGRD() const { switch (theProductType.ToInternal()) { case ProductType::GRD: case ProductType::MGD: case ProductType::GEC: case ProductType::EEC: return true; default: return false; } } virtual std::ostream& print(std::ostream& out) const; protected: /** * Compute range and doppler frequency from an input point, sensor * position and velocity. * * \param[in] inputPt The target point * \param[in] sensorPos The sensor position * \param[in] sensorvel The sensor velocity * \param[out] range Estimated range * \param[out] doppler Estimated doppler frequency */ virtual void computeRangeDoppler(const ossimEcefPoint & inputPt, const ossimEcefPoint & sensorPos, const ossimEcefVector sensorVel, double & range, double & doppler) const; /** * Interpolate sensor position and velocity at given azimuth time * using lagragian interpolation of orbital records. * * \param[in] azimuthTime The time at which to interpolate * \param[out] sensorPos Interpolated sensor position * \param[out] sensorvel Interpolated sensor velocity * \param[in] deg Degree of lagragian interpolation */ /*virtual*/ void interpolateSensorPosVel(const TimeType & azimuthTime, ossimEcefPoint& sensorPos, ossimEcefVector& sensorVel, unsigned int deg = 8) const; /** * Convert slant range to ground range by interpolating slant range * to ground range coefficients. * * \param[in] slantRangeTime The slantRange to convert (meters) * \param[in] azimuthTime The corresponding azimuth time * \param[out] groundRange The estimated ground range (meters) */ /*virtual*/ void slantRangeToGroundRange(const double & slantRange, const TimeType & azimuthTime, double & groundRange) const; // TODO: Document me /*virtual*/ void groundRangeToSlantRange(const double & groundRange, const TimeType & azimuthTime, double & slantRange) const; // TODO: Document me /*virtual*/ void applyCoordinateConversion(const double & in, const TimeType& azimuthTime, const std::vector & records, double & out) const; /** * Estimate the zero-doppler azimuth time and corresponding sensor * position and velocity from the inputPt. * * \param[in] inputPt The point to estimated zero-doppler time on * \param[out] interpAzimuthTime Interpolated azimuth time * \param[out] interpSensorPos Interpolated sensor position * \param[out] interpSensorVel Interpolated sensor velocity * \return True if success, false otherwise. In this case, output * parameters are left untouched. */ /*virtual*/ bool zeroDopplerLookup(const ossimEcefPoint & inputPt, TimeType & interpAzimuthTime, ossimEcefPoint & interpSensorPos, ossimEcefVector & interpSensorVel) const; /** * Compute the bistatic correction to apply. * * \param[in] inputPt The point to compute bistatic correction on * \param[in] sensorPos The corresponding sensor position * \param[out] bistaticCorrection The estimated bistatic correction */ /*virtual*/ void computeBistaticCorrection(const ossimEcefPoint & inputPt, const ossimEcefPoint & sensorPos, DurationType & bistaticCorrection) const; /** * Convert azimuth time to fractional line. * * \param[in] azimuthTime The azimuth time to convert * \param[out] The estimated fractional line */ /*virtual*/ // TODO: check why virtual void azimuthTimeToLine(const TimeType & azimuthTime, double & line) const; // TODO: document me /*virtual*/ // TODO: check why virtual void lineToAzimuthTime(const double & line, TimeType & azimuthTime) const; // TODO: document me /*virtual*/ // TODO: check why virtual bool projToSurface(const GCPRecordType & initGcp, const ossimDpt & target, const ossimHgtRef & hgtRef, ossimEcefPoint & ellpt) const; /** * Finds closest GCP. * * \param[in] imPt «imPt-explanations» * \return the closest GCP record to \c imPt. * \throw None * \pre `theGCPRecords` shall not be empty. */ GCPRecordType const& findClosestGCP(ossimDpt const& imPt) const; std::vector theOrbitRecords; std::vector theGCPRecords; std::vector theBurstRecords; std::vector theSlantRangeToGroundRangeRecords; std::vector theGroundRangeToSlantRangeRecords; double theRadarFrequency; // in Hz DurationType theAzimuthTimeInterval; double theNearRangeTime; // in seconds double theRangeSamplingRate; // in Hz double theRangeResolution; // in meters bool theBistaticCorrectionNeeded; // Do we need to compute // bistatic correction ? ProductType theProductType; // GRD/SLC DurationType theAzimuthTimeOffset; // Offset computed double theRangeTimeOffset; // Offset in seconds, computed static const double C; private: /** Disabled assignment operator. */ ossimSarSensorModel& operator=(ossimSarSensorModel const& rhs); // Disable a warning, and disable inherited buggy assignment (buggy because // value semantics are incompatible with public inheritance thanks to // slicing) using ossimSensorModel::operator=; using ossimOptimizableProjection::operator=; }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSarSensorModelPathsAndKeys.cpp000066400000000000000000000043421301006202600324360ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- #include "ossimSarSensorModelPathsAndKeys.h" namespace ossimplugins { const std::string HEADER_PREFIX = "header."; const std::string SUPPORT_DATA_PREFIX = "support_data."; const std::string GEOM_PREFIX = "support_data.geom"; const std::string SRD_PREFIX = "support_data.geom.srd"; const std::string SR_PREFIX = "support_data.geom.srd.coords.sr"; const std::string GR_PREFIX = "support_data.geom.srd.coords.gr"; const std::string BURST_PREFIX = "support_data.geom.bursts.burst"; const std::string BURST_NUMBER_KEY = "support_data.geom.bursts.number"; const std::string GCP_PREFIX = "support_data.geom.gcp"; const std::string GCP_NUMBER_KEY = "support_data.geom.gcp.number"; const std::string NUMBER_KEY = "number"; const std::string keySr0 = "sr0"; const std::string keyGr0 = "gr0"; const std::string keyAzimuthTime = "azimuthTime"; const std::string keySlantRangeTime = "slant_range_time"; const std::string keyImPtX = "im_pt.x"; const std::string keyImPtY = "im_pt.y"; const std::string keyWorldPtLat = "world_pt.lat"; const std::string keyWorldPtLon = "world_pt.lon"; const std::string keyWorldPtHgt = "world_pt.hgt"; const std::string keyTime = "time"; const std::string keyPosX = "x_pos"; const std::string keyPosY = "y_pos"; const std::string keyPosZ = "z_pos"; const std::string keyVelX = "x_vel"; const std::string keyVelY = "y_vel"; const std::string keyVelZ = "z_vel"; const std::string keyStartLine = "start_line"; const std::string keyEndLine = "end_line"; const std::string keyAzimuthStartTime = "azimuth_start_time"; const std::string keyAzimuthStopTime = "azimuth_stop_time"; } // ossimplugins namespace OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSarSensorModelPathsAndKeys.h000066400000000000000000000040201301006202600320740ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- #ifndef ossimSarSensorModelPathsAndKeys_h #define ossimSarSensorModelPathsAndKeys_h #include namespace ossimplugins { extern const std::string HEADER_PREFIX ; extern const std::string SUPPORT_DATA_PREFIX ; extern const std::string GEOM_PREFIX ; extern const std::string SRD_PREFIX ; extern const std::string SR_PREFIX ; extern const std::string GR_PREFIX ; extern const std::string BURST_PREFIX ; extern const std::string BURST_NUMBER_KEY ; extern const std::string GCP_PREFIX ; extern const std::string GCP_NUMBER_KEY ; extern const std::string NUMBER_KEY ; extern const std::string keySr0 ; extern const std::string keyGr0 ; extern const std::string keyAzimuthTime ; extern const std::string keySlantRangeTime ; extern const std::string keyImPtX ; extern const std::string keyImPtY ; extern const std::string keyWorldPtLat ; extern const std::string keyWorldPtLon ; extern const std::string keyWorldPtHgt ; extern const std::string keyTime ; extern const std::string keyPosX ; extern const std::string keyPosY ; extern const std::string keyPosZ ; extern const std::string keyVelX ; extern const std::string keyVelY ; extern const std::string keyVelZ ; extern const std::string keyStartLine ; extern const std::string keyEndLine ; extern const std::string keyAzimuthStartTime ; extern const std::string keyAzimuthStopTime ; } // ossimplugins namespace #endif // ossimSarSensorModelPathsAndKeys_h OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSentinel1Model.cpp000066400000000000000000001413311301006202600301020ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "ossimSentinel1Model.h" #include "ossimTraceHelpers.h" #include "ossimXmlTools.h" #include "ossimKeyWordListUtilities.h" #include "ossimSarSensorModelPathsAndKeys.h" #include #include #include #include #include #if defined(_MSC_VER) #include "ossimWin32FindFileHandle.h" #endif #if defined(USE_BOOST_TIME) using boost::posix_time::microseconds; using boost::posix_time::seconds; #else using ossimplugins::time::microseconds; using ossimplugins::time::seconds; #endif namespace {// Anonymous namespace ossimTrace traceExec ("ossimSentinel1Model:exec"); ossimTrace traceDebug ("ossimSentinel1Model:debug"); const ossimString attAdsHeader = "adsHeader"; const ossimString attAzimuthTime = "azimuthTime"; const ossimString attFirstValidSample = "firstValidSample"; const ossimString attGr0 = "gr0"; const ossimString attGrsrCoefficients = "grsrCoefficients"; const ossimString attHeight = "height"; const ossimString attLatitude = "latitude"; const ossimString attLine = "line"; const ossimString attLongitude = "longitude"; const ossimString attPixel = "pixel"; const ossimString attPosition = "position"; const ossimString attSlantRangeTime = "slantRangeTime"; const ossimString attSr0 = "sr0"; const ossimString attSrgrCoefficients = "srgrCoefficients"; const ossimString attTime = "time"; const ossimString attVelocity = "velocity"; const ossimString attX = "x"; const ossimString attY = "y"; const ossimString attZ = "z"; // const char LOAD_FROM_PRODUCT_FILE_KW[] = "load_from_product_file_flag"; // const char PRODUCT_XML_FILE_KW[] = "product_xml_filename"; }// Anonymous namespace namespace ossimplugins { RTTI_DEF1(ossimSentinel1Model, "ossimSentinel1Model", ossimSarSensorModel); //************************************************************************************************* // Constructor //************************************************************************************************* ossimSentinel1Model::ossimSentinel1Model() : ossimSarSensorModel() , theOCN(false) , theSLC(false) , theTOPSAR(false) { // theManifestDoc = new ossimXmlDocument(); } void ossimSentinel1Model::clearFields() { theOCN = false; theSLC = false; theTOPSAR = false; theManifestKwl.clear(); theProductKwl.clear(); // theManifestFile = ossimFilename::NIL; theProductXmlFile = ossimFilename::NIL; } //************************************************************************************************* // Infamous DUP //************************************************************************************************* ossimObject* ossimSentinel1Model::dup() const { return new ossimSentinel1Model(*this); } //************************************************************************************************* // Print //************************************************************************************************* std::ostream& ossimSentinel1Model::print(std::ostream& out) const { // Capture stream flags since we are going to mess with them. std::ios_base::fmtflags f = out.flags(); out << "\nDump of ossimSentinel1Model at address " << hex << this << dec << "\n------------------------------------------------" << "\n theImageID = " << theImageID << "\n theImageSize = " << theImageSize << "\n------------------------------------------------" << "\n " << endl; // Set the flags back. out.flags(f); return ossimSarSensorModel::print(out); } //************************************************************************************************* // Save State //************************************************************************************************* bool ossimSentinel1Model::saveState(ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimplugins::ossimSentinel1Model::saveState"; SCOPED_LOG(traceDebug, MODULE); kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimSentinel1Model", true); kwl.add("support_data.", "calibration_lookup_flag", "true", true); kwl.addList(theManifestKwl, true); kwl.addList(theProductKwl, true); return ossimSarSensorModel::saveState(kwl, prefix); } //************************************************************************************************* // Load State //************************************************************************************************* bool ossimSentinel1Model::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "ossimplugins::ossimSentinel1Model::loadState"; SCOPED_LOG(traceDebug, MODULE); theManifestKwl.addList(kwl, true); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "theManifestKwl.getSize()" << theManifestKwl.getSize() << "\n"; } return ossimSarSensorModel::loadState(kwl, prefix); } ossimFilename ossimSentinel1Model::searchManifestFile(const ossimFilename& file) const { #ifndef _WIN32 const ossimFilename manifestFile = ossimFilename(file.path().path() + "/manifest.safe"); #else const ossimFilename manifestFile = ossimFilename(file.path().path() + "\\manifest.safe"); #endif if(!manifestFile.exists()) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << " manifest.safe " << manifestFile << " doesn't exist...\n"; } return ""; } return manifestFile; } bool ossimSentinel1Model::open(const ossimFilename& file) { static const char MODULE[] = "ossimplugins::ossimSentinel1Model::open"; //traceDebug.setTraceFlag(true); SCOPED_LOG(traceDebug, MODULE); bool result = false; const ossimString ext = file.ext().downcase(); if ( !file.exists() || (ext != "tiff" && ext != "xml" )) { return false; } theGSD.makeNan(); // -----[ Read manifest file const ossimFilename safeFile = searchManifestFile(file); if ( !safeFile.empty() ) { theManifestDirectory = safeFile.path(); if ( !this->isSentinel1(safeFile)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Not a Sentinel 1 manifest file " << safeFile << "\n"; return false; } ossimXmlDocument manifestDoc; if (!manifestDoc.openFile(safeFile)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Invalid Manifest file " << safeFile << "\n"; return false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "Manifest file " << safeFile << " opened\n"; } theImageID = getImageId(manifestDoc); if (theImageID.empty()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Image ID not found in manifest file " << safeFile << "\n"; return false; } if (! standAloneProductInformation(manifestDoc)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Cannot load product information from " << safeFile << "\n"; return false; } theSensorID = initSensorID(manifestDoc); if (theSensorID.empty()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Cannot load sensor ID from " << safeFile << "\n"; return false; } } else { /* Keep this notify as WARN. code should not reach here. If manifest.safe is not found then we are not loading a valid S1 dataset. If the input is tiff or annotation xml, then also there must exists a manifest.safe. However, we are forced to read only annotaion xml and make ossimSentinel1Model out of it for the sake of "ossimSentinel1ModelTest". This is not a very good idea to allow reading a fake dataset. So user must be warned! */ ossimNotify(ossimNotifyLevel_WARN) << MODULE << " manifest.safe not found. but checking if xml file is valid" << "\n"; } // -----[ Read product file ossimFilename xmlFileName = file; // If this is tiff file, look for corresponding annotation file if(ext != "xml") { const ossimFilename fileNameWihtoutExtension = file.fileNoExtension(); const ossimFilename path = file.path().path(); xmlFileName = ossimFilename(path+"/annotation/"+fileNameWihtoutExtension+".xml"); } if ( !xmlFileName.exists() || !this->readProduct(xmlFileName) ) { /* Must be a FATAL error. Because when you reach here there are three possibilities. 1. manifest.safe file exists, but annotation xml does not 2. manifest.safe and annotation xmlexists, readProduct() returns false. 3. manifest.safe does not exists and annotation file is not a valid S1 dataset. (case when loading a different product xml file (eg: terrasarx). All these cases should not go slient on error message. It must be FATAL errors. */ ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " !xmlFileName.exists() || !this->readProduct(xmlFileName) fails \n"; return false; } if ( !this->initImageSize( theImageSize ) ) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " this->initImageSize( theImageSize ) fails \n"; return false; } theImageClipRect = ossimDrect( 0, 0, theImageSize.x-1, theImageSize.y-1 ); theSubImageOffset.x = 0.0; theSubImageOffset.y = 0.0; // automatically loaded/saved into ossimSensorModel theMeanGSD = (theGSD.x + theGSD.y)/2.0; #if 0 if ( !this->initSRGR( ) ) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " this->initSRGR( )\n"; return false; } #endif // Commit the operation theProductXmlFile = file; return true; } ossimString const& ossimSentinel1Model::getImageId(ossimXmlDocument const& manifestDoc) const { ossimString xpath = "/xfdu:XFDU/metadataSection/metadataObject/metadataWrap/xmlData/s1sarl1:standAloneProductInformation/s1sarl1:missionDataTakeID"; return getOnlyText(manifestDoc, xpath); } ossimString ossimSentinel1Model::initSensorID(ossimXmlDocument const& manifestDoc) { const ossimRefPtr safePlatform = manifestDoc.getRoot()->findFirstNode("metadataSection/metadataObject/metadataWrap/xmlData/safe:platform"); ossimString familyName, instrumentId; const bool ret1 = safePlatform->getChildTextValue(familyName, "safe:familyName"); const bool ret2 = safePlatform->getChildTextValue(instrumentId, "safe:number"); if (ret1 && ret2) { theManifestKwl.add("support_data.", "instrument", "S1" + instrumentId, true); return familyName + instrumentId; } throw std::runtime_error("Cannot obtain Sensor ID"); } #if 0 bool ossimSentinel1Model::getAnnotationFileLocation(const ossimFilename &manifestFile, const char* pattern) { static const char MODULE[] = "ossimSentinel1SafeManifest::getAnnotationFileLocation"; //traceDebug.setTraceFlag(true); const ossimString prefix = "support_data."; const ossimString xpath = "/xfdu:XFDU/dataObjectSection/dataObject"; vector > xml_nodes; theManifestDoc->findNodes(xpath, xml_nodes); ossimRefPtr dataObjectNode = xml_nodes[0]; ossimString dataObjectId; dataObjectNode->getAttributeValue(dataObjectId , "ID"); if ( dataObjectId.match(pattern) ) { ossim::getPath(xpath + "/byteStream/fileLocation", theManifestDoc.get(), theProductXmlFile); xml_nodes.clear(); theManifestDoc->findNodes(xpath + "/byteStream/fileLocation", xml_nodes); if(xml_nodes.empty()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " getAnnotationFileLocation( )\n"; return false; } xml_nodes[0]->getAttributeValue(theProductXmlFile , "href"); theProductXmlFile.setPath(manifestFile.path() + "/annotation"); } return true; } #endif bool ossimSentinel1Model::standAloneProductInformation(ossimXmlDocument const& manifestDoc) { static const char MODULE[] = "ossimSentinel1ProductDoc::parseSafe"; const ossimString prefix = "support_data."; const ossimRefPtr safeProcessing = manifestDoc.getRoot()->findFirstNode("metadataSection/metadataObject/metadataWrap/xmlData/safe:processing"); const ossimRefPtr facility = safeProcessing->findFirstNode("safe:facility"); const ossimRefPtr software = facility->findFirstNode("safe:software"); const ossimString org = facility->getAttributeValue("organisation"); const ossimString name = software->getAttributeValue("name"); const ossimString version = software->getAttributeValue("version"); theManifestKwl.add(prefix, "Processing_system_identifier", org + " " + name + " " + version, true); theManifestKwl.add(prefix, ossimKeywordNames::DATE_KW, safeProcessing->getAttributeValue("start"), true); const ossimRefPtr acquisitionPeriod = manifestDoc.getRoot()->findFirstNode("metadataSection/metadataObject/metadataWrap/xmlData/safe:acquisitionPeriod"); ossimString acqStartTime = acquisitionPeriod->getChildTextValue("safe:startTime"); theManifestKwl.add(prefix, "first_line_time", acqStartTime, true); theManifestKwl.add(prefix, "last_line_time", acquisitionPeriod->getChildTextValue("safe:stopTime"), true); //RK theManifestKwl.add(prefix, ossimKeywordNames::IMAGE_DATE_KW, acqStartTime, true); const ossimRefPtr instrumentNode = manifestDoc.getRoot()->findFirstNode("metadataSection/metadataObject/metadataWrap/xmlData/safe:platform/safe:instrument"); ossimString swath = instrumentNode->getChildTextValue("s1sarl1:swath"); ossimString acquisition_mode = instrumentNode->getChildTextValue("s1sarl1:mode"); if( acquisition_mode.empty()) { ossimRefPtr instrumentModeNode = instrumentNode->findFirstNode("safe:extension/s1sarl1:instrumentMode"); if(instrumentModeNode.get()) { acquisition_mode = instrumentModeNode->getChildTextValue("s1sarl1:mode"); swath = instrumentModeNode->getChildTextValue("s1sarl1:swath"); } } theManifestKwl.add(prefix, "acquisition_mode", acquisition_mode, true); theManifestKwl.add(prefix, "swath", swath, true); if (acquisition_mode == "IW" || acquisition_mode == "EW") theTOPSAR = true; const ossimRefPtr orbitReference = manifestDoc.getRoot()->findFirstNode("metadataSection/metadataObject/metadataWrap/xmlData/safe:orbitReference"); std::vector > orbitNumberNodes; const ossimString orbitReference_xpath = "/xfdu:XFDU/metadataSection/metadataObject/metadataWrap/xmlData/safe:orbitReference"; manifestDoc.findNodes(orbitReference_xpath + "/safe:orbitNumber", orbitNumberNodes); std::vector >::const_iterator it = orbitNumberNodes.begin(); while( it != orbitNumberNodes.end()) { const ossimRefPtr attribute = (*it)->findAttribute("type"); if( attribute.get() ) { if( attribute->getValue() == "start" ) { theManifestKwl.add(prefix, "abs_orbit", (*it)->getText(), true); break; } } ++it; } orbitNumberNodes.clear(); manifestDoc.findNodes(orbitReference_xpath + "/safe:relativeOrbitNumber", orbitNumberNodes); std::vector >::const_iterator it2 = orbitNumberNodes.begin(); while( it2 != orbitNumberNodes.end()) { const ossimRefPtr attribute = (*it2)->findAttribute("start"); if( attribute.get() ) { if( attribute->getValue() == "start" ) { theManifestKwl.add(prefix, "rel_orbit", (*it2)->getText(), true); break; } } ++it2; } theManifestKwl.add(prefix, "orbit_cycle", orbitReference->getChildTextValue("safe:cycleNumber"), true); ossimString orbit_pass = ""; orbit_pass = orbitReference->getChildTextValue("s1:pass"); if( orbit_pass.empty() ) { orbit_pass = orbitReference->getChildTextValue("safe:extension/s1:orbitProperties/s1:pass"); } theManifestKwl.add(prefix, "orbit_pass", orbit_pass, true); ossimString productType = "unknown"; const ossimRefPtr standAloneProductInformation = manifestDoc.getRoot()->findFirstNode("metadataSection/metadataObject/metadataWrap/xmlData/s1sarl1:standAloneProductInformation"); if (theOCN) { productType = "OCN"; } else { if (standAloneProductInformation.get()) productType = standAloneProductInformation->getChildTextValue("s1sarl1:productType"); } theManifestKwl.add(prefix, "product_type", productType, true); if( productType.contains("SLC" ) ) { //ossimKeywordNames::PIXEL_TYPE_KW; RK theManifestKwl.add("sample_type", "COMPLEX", true); theSLC = true; } else { theManifestKwl.add("sample_type", "DETECTED", true); theManifestKwl.add(prefix, "srgr_flag", "true", true); } return true; } bool ossimSentinel1Model::isSentinel1(const ossimFilename &manifestFile ) { theOCN = isLevel2(manifestFile); return isLevel1(manifestFile) || theOCN || isLevel0(manifestFile); } bool ossimSentinel1Model::isLevel1(const ossimFilename& file) const { bool productXmlCheck = checkDirectory(file, "annotation", ".xml"); return productXmlCheck && checkDirectory(file, "measurement", ".tiff"); } bool ossimSentinel1Model::isLevel2(const ossimFilename& file) const { return checkDirectory(file, "measurement",".nc"); } bool ossimSentinel1Model::isLevel0(const ossimFilename& file) const { return checkDirectory(file, "measurement",".dat"); } bool ossimSentinel1Model::checkDirectory(const ossimFilename& file, const char* d, const char* ext) const { std::stringstream strm; std::vector result; #if defined(_WIN32) const char pathsep = '\\'; #else const char pathsep = '/'; #endif #if defined(_MSC_VER) strm << file.path() << pathsep << d << pathsep << "*" << ext; ossimWin32FindFileHandle handle(strm.str()); if (handle.is_valid()) { do { result.push_back(handle.crt_filename()); } while (handle.next()); } #else strm << file.path() << pathsep << d << pathsep; ossimDirectory dir( strm.str() ); dir.findAllFilesThatMatch(result, ext); #endif if ( result.empty() ) { if (traceExec()) { ossimNotify(ossimNotifyLevel_FATAL) << " DEBUG:" << " checkDirectory failed for: " << strm.str() << " with ext ="<< ext << "\n"; } return false; } return true; } bool ossimSentinel1Model::readProduct(const ossimFilename &productXmlFile) { try { const bool ret = read(productXmlFile); if ( ret ) { readCalibrationMetadata(); readNoiseMetadata(); return true; } } catch (std::exception const& e) { if (traceExec()) ossimNotify(ossimNotifyLevel_INFO) << "Error while reading " << productXmlFile << " as Sentinel1 model: " << e.what() << "\n"; } if (traceExec()) ossimNotify(ossimNotifyLevel_FATAL) << "Cannot read " << productXmlFile << " as Sentinel1 model.\n"; return false; } bool ossimSentinel1Model::read(ossimFilename const& annotationXml) { ossimXmlDocument productXmlDocument; if (! openMetadataFile(productXmlDocument, annotationXml)) { ossimNotify(ossimNotifyLevel_FATAL) << "Cannot open Sar Sentinel1 model from XML file: "<getManifestPrefix() add(theProductKwl, SUPPORT_DATA_PREFIX, "mds1_tx_rx_polar", polarisation); const ossimXmlNode & imageInformation = getExpectedFirstNode(*productRoot, "imageAnnotation/imageInformation"); const ossimXmlNode & productInformation = getExpectedFirstNode(*productRoot, "generalAnnotation/productInformation"); addOptional (theProductKwl, SUPPORT_DATA_PREFIX, "data_take_id", adsHeader, "missionDataTakeId"); addOptional (theProductKwl, SUPPORT_DATA_PREFIX, "slice_num", imageInformation, "sliceNumber"); ossimXmlNode const& xAzimutTimeInterval = getExpectedFirstNode(imageInformation, "azimuthTimeInterval"); const double azimuthTimeInterval = to(xAzimutTimeInterval.getText(), "decoding imageInformation/azimuthTimeInterval"); #if defined(USE_BOOST_TIME) theAzimuthTimeInterval = boost::posix_time::precise_duration(azimuthTimeInterval * 1000000.); #else theAzimuthTimeInterval = seconds(azimuthTimeInterval); #endif // std::clog << "theAzimuthTimeInterval " << theAzimuthTimeInterval.total_microseconds() << "\n"; add(theProductKwl, SUPPORT_DATA_PREFIX, "line_time_interval", xAzimutTimeInterval.getText()); // addMandatory(theProductKwl, SUPPORT_DATA_PREFIX, "line_time_interval", imageInformation, "azimuthTimeInterval"); const double rangeSpacing = getDoubleFromFirstNode(imageInformation, "rangePixelSpacing"); add(theProductKwl, SUPPORT_DATA_PREFIX, "range_spacing", rangeSpacing); theGSD.x = rangeSpacing; const double azimuthSpacing = getDoubleFromFirstNode(imageInformation, "azimuthPixelSpacing"); add(theProductKwl, SUPPORT_DATA_PREFIX, "azimuth_spacing", azimuthSpacing); theGSD.y = azimuthSpacing; // theGSD and theMeanGSD will be saved and reloaded automatically in // ossimSensorModel::load/saveState() // TODO: Why duplicting these two information elsewhere? they're already // under root prefix addOptional(theProductKwl, ossimKeywordNames::NUMBER_SAMPLES_KW, imageInformation, "numberOfSamples"); addOptional(theProductKwl, ossimKeywordNames::NUMBER_LINES_KW, imageInformation, "numberOfLines"); add(theProductKwl, "sample_type" /*ossimKeywordNames::PIXEL_TYPE_KW*/, getOptionalTextFromFirstNode(imageInformation, "pixelValue").upcase()); // TODO: check if it makes sense when only one file is considered const double heightSum = getBandTerrainHeight(productXmlDocument); add(theProductKwl, SUPPORT_DATA_PREFIX, "avg_scene_height", heightSum); // these should be the same for all swaths //RK div by oneMillion taken from S1tlbx addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "range_sampling_rate", productInformation, "rangeSamplingRate"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "radar_frequency", productInformation, "radarFrequency"); // TODO: store the line_time_interval * 1000000 addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "line_time_interval", imageInformation, "azimuthTimeInterval"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "slant_range_to_first_pixel", imageInformation, "slantRangeTime"); const ossimXmlNode & downlinkInformation = getExpectedFirstNode(*productRoot, "generalAnnotation/downlinkInformationList/downlinkInformation"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "pulse_repetition_frequency", downlinkInformation, "prf"); ossimXmlNode const& swathProcParams = getExpectedFirstNode(*productRoot, "imageAnnotation/processingInformation/swathProcParamsList/swathProcParams"); ossimXmlNode const& rangeProcessingNode = getExpectedFirstNode(swathProcParams, "rangeProcessing"); ossimXmlNode const& azimuthProcessingNode = getExpectedFirstNode(swathProcParams, "azimuthProcessing"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "azimuth_bandwidth", azimuthProcessingNode, "processingBandwidth"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "range_bandwidth", rangeProcessingNode, "processingBandwidth"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "range_looks", rangeProcessingNode, "numberOfLooks"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, "azimuth_looks", azimuthProcessingNode, "numberOfLooks"); if(!theTOPSAR || !theSLC) { addOptional(theProductKwl, SUPPORT_DATA_PREFIX, ossimKeywordNames::NUMBER_SAMPLES_KW, imageInformation, "numberOfSamples"); addOptional(theProductKwl, SUPPORT_DATA_PREFIX, ossimKeywordNames::NUMBER_LINES_KW, imageInformation, "numberOfLines"); } ossimXmlNodePtr const& orbitList = productRoot->findFirstNode("generalAnnotation/orbitList"); if (!orbitList) { ossimNotify(ossimNotifyLevel_DEBUG) << "No orbitVectorList info available in metadata!!\n"; } else { addOrbitStateVectors(*orbitList); } if (isGRD()) { ossimXmlNodePtr const& coordinateConversionList = productRoot->findFirstNode("coordinateConversion/coordinateConversionList"); if (!coordinateConversionList) { ossimNotify(ossimNotifyLevel_WARN) << "No coordinate conversion info available in metadata!!\n"; } else { addSRGRCoefficients(*coordinateConversionList); } } ossimXmlNodePtr const& dcEstimateList = productRoot->findFirstNode("dopplerCentroid/dcEstimateList"); if (!dcEstimateList) { ossimNotify(ossimNotifyLevel_DEBUG) << "No doppler centroid coefficients available in metadata!!\n"; } else { addDopplerCentroidCoefficients(*dcEstimateList); } readBurstRecords(*productRoot, imageInformation); readGeoLocationGrid(*productRoot); #if 0 add(theProductKwl, SUPPORT_DATA_PREFIX, ossimKeywordNames::NUMBER_BANDS_KW, numBands, true); #endif return true; } void ossimSentinel1Model::readCalibrationMetadata() { ossimDirectory calibrationDir( theManifestDirectory.dirCat( "annotation/calibration") ); std::vector files; if (calibrationDir.isOpened()) { calibrationDir.findAllFilesThatMatch(files, "calibration*"); } std::vector::const_iterator it = files.begin(); ossimNotify(ossimNotifyLevel_DEBUG) << files.size() << " calibration files found in " << theManifestDirectory << "\n"; std::stringstream strm; for (; it != files.end(); ++it) { ossimXmlDocument calibrationDoc; openMetadataFile(calibrationDoc, *it ); const ossimXmlNodePtr & calibrationRoot = calibrationDoc.getRoot(); assert(calibrationRoot.get()); ossimXmlNode const& adsHeader = getExpectedFirstNode(*calibrationRoot, "adsHeader"); ossimXmlNode const& calibrationInformation = getExpectedFirstNode(*calibrationRoot, "calibrationInformation"); ossimXmlNode const& calibrationVectorList = getExpectedFirstNode(*calibrationRoot, "calibrationVectorList"); char const calibrationPrefix[] = "calibration."; addMandatory(theProductKwl, calibrationPrefix, "swath", adsHeader, "swath"); addMandatory(theProductKwl, calibrationPrefix, "polarisation", adsHeader, "polarisation"); // store as a string addMandatory(theProductKwl, calibrationPrefix, "startTime", adsHeader, "startTime"); addMandatory(theProductKwl, calibrationPrefix, "stopTime", adsHeader, "stopTime"); addMandatory(theProductKwl, calibrationPrefix, "absoluteCalibrationConstant", calibrationInformation, "absoluteCalibrationConstant"); add(theProductKwl, calibrationPrefix, "count", calibrationVectorList.getAttributeValue("count").string()); std::vector< ossimXmlNodePtr > calibrationVectors; calibrationRoot->findChildNodes("calibrationVectorList/calibrationVector", calibrationVectors); int idx = 0; for (std::vector< ossimXmlNodePtr >::const_iterator b_calibVector = calibrationVectors.begin(), e_calibVector = calibrationVectors.end() ; b_calibVector != e_calibVector ; ++b_calibVector, ++idx ) { char calibrationVectorPrefix[256]; s_printf(calibrationVectorPrefix, "%scalibrationVector[%d].", calibrationPrefix, idx); assert(b_calibVector->get()); ossimXmlNode const& calibrationVector = **b_calibVector; const ossimXmlNodePtr & node = calibrationVector.findFirstNode("pixel"); add(theProductKwl, calibrationVectorPrefix, "pixel_count", node->getAttributeValue("count").string()); // store as a string addMandatory(theProductKwl, calibrationVectorPrefix, keyAzimuthTime, calibrationVector, "azimuthTime"); addMandatory(theProductKwl, calibrationVectorPrefix, "line", calibrationVector, "line"); addMandatory(theProductKwl, calibrationVectorPrefix, "pixel", calibrationVector, "pixel"); addMandatory(theProductKwl, calibrationVectorPrefix, "sigmaNought", calibrationVector, "sigmaNought"); addMandatory(theProductKwl, calibrationVectorPrefix, "betaNought", calibrationVector, "betaNought"); addMandatory(theProductKwl, calibrationVectorPrefix, "gamma", calibrationVector, "gamma"); addMandatory(theProductKwl, calibrationVectorPrefix, "dn", calibrationVector, "dn"); // calibrationVectors[idx]->toKwl(theProductKwl, "calibrationVectorList_" + ossimString::toString(idx+1) + "."); } } } void ossimSentinel1Model::readNoiseMetadata() { ossimDirectory calibrationDir( theManifestDirectory.dirCat( "annotation/calibration") ); std::vector files; if (calibrationDir.isOpened()) { calibrationDir.findAllFilesThatMatch(files, "noise*"); } std::vector::const_iterator it = files.begin(); const char noisePrefix[] = "noise."; for (; it != files.end(); ++it) { ossimXmlDocument noiseDoc; openMetadataFile(noiseDoc, *it ); const ossimXmlNodePtr noiseRoot = noiseDoc.getRoot(); std::vector< ossimXmlNodePtr > noiseVectors; noiseRoot->findChildNodes("noiseVectorList/noiseVector", noiseVectors); int idx = 0; for (std::vector< ossimXmlNodePtr >::const_iterator b_noiseVector = noiseVectors.begin(), e_noiseVector = noiseVectors.end() ; b_noiseVector != e_noiseVector ; ++b_noiseVector, ++idx ) { char noiseVectorPrefix [256]; s_printf(noiseVectorPrefix, "%snoiseVector[%d].", noisePrefix, idx); assert(b_noiseVector->get()); ossimXmlNode const& noiseVector = **b_noiseVector; const ossimXmlNodePtr & node = noiseVector.findFirstNode("pixel"); add(theProductKwl, noiseVectorPrefix, "pixel_count", node->getAttributeValue("count"), ShallOverwrite::no); // store as a string addMandatory(theProductKwl, noiseVectorPrefix, keyAzimuthTime, noiseVector, "azimuthTime"); addMandatory(theProductKwl, noiseVectorPrefix, "line", noiseVector, "line"); addMandatory(theProductKwl, noiseVectorPrefix, "pixel", noiseVector, "pixel"); addMandatory(theProductKwl, noiseVectorPrefix, "noiseLut", noiseVector, "noiseLut"); //noiseVectorList[idx]->toKwl(theProductKwl, "noiseVectorList_" + ossimString::toString(idx+1) + "."); } } } void ossimSentinel1Model::readBurstRecords(ossimXmlNode const& productRoot, ossimXmlNode const& imageInformation) { std::vector > xnodes; productRoot.findChildNodes("swathTiming/burstList/burst",xnodes); if (xnodes.empty()) { // Apart from TopSAR products, there won't be any burst //records, so this warning is unnecessary //ossimNotify(ossimNotifyLevel_DEBUG) << "No burst records available in metadata!!\n"; add(theProductKwl, BURST_NUMBER_KEY, ossimString("1")); BurstRecordType burstRecord; burstRecord.startLine = add(theProductKwl, BURST_PREFIX, "[0].start_line", 0); burstRecord.azimuthStartTime = add(theProductKwl, BURST_PREFIX, "[0].azimuth_start_time", getTimeFromFirstNode(imageInformation, "productFirstLineUtcTime")); burstRecord.azimuthStopTime = add(theProductKwl, BURST_PREFIX, "[0].azimuth_stop_time", getTimeFromFirstNode(imageInformation, "productLastLineUtcTime")); burstRecord.endLine = add(theProductKwl, BURST_PREFIX, "[0].end_line", getFromFirstNode(imageInformation, "numberOfLines")-1); theBurstRecords.push_back(burstRecord); } else { char burstPrefix[1024]; const unsigned int linesPerBurst = getFromFirstNode(productRoot, "swathTiming/linesPerBurst"); unsigned int burstId(0); for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode,++burstId) { BurstRecordType burstRecord; const TimeType azTime = getTimeFromFirstNode(**itNode, attAzimuthTime); ossimString const& s = getTextFromFirstNode(**itNode, attFirstValidSample); ossim_int64 first_valid(0), last_valid(0); bool begin_found(false), end_found(false); std::vector ssp = s.split(" "); for (std::vector::const_iterator sIt = ssp.begin(), e = ssp.end() ; sIt != e && !end_found ; ++sIt ) { if(!begin_found) { if(*sIt!="-1") { begin_found = true; } else { ++first_valid; } ++last_valid; } else { if(!end_found && *sIt=="-1") { end_found = true; } else { ++last_valid; } } } s_printf(burstPrefix, "%s[%d].", BURST_PREFIX.c_str(), burstId); burstRecord.startLine = add(theProductKwl,burstPrefix + keyStartLine, burstId*linesPerBurst + first_valid); burstRecord.endLine = add(theProductKwl,burstPrefix + keyEndLine, burstId*linesPerBurst + last_valid); // TODO: check units. burstRecord.azimuthStartTime = add(theProductKwl,burstPrefix + keyAzimuthStartTime, azTime + (first_valid*theAzimuthTimeInterval)); burstRecord.azimuthStopTime = add(theProductKwl,burstPrefix + keyAzimuthStopTime, azTime + (last_valid*theAzimuthTimeInterval)); theBurstRecords.push_back(burstRecord); } add(theProductKwl, BURST_NUMBER_KEY, burstId); } } void ossimSentinel1Model::addSRGRCoefficients(ossimXmlNode const& coordinateConversionList) { readCoordinates(coordinateConversionList, attSr0, attSrgrCoefficients, SR_PREFIX); readCoordinates(coordinateConversionList, attGr0, attGrsrCoefficients, GR_PREFIX); } void ossimSentinel1Model::readCoordinates( ossimXmlNode const& node, ossimString const& rg0_xpath, ossimString const& coeffs_xpath, std::string const& sr_gr_prefix) { char prefix[1024]; std::vector > xnodes; node.findChildNodes("coordinateConversion", xnodes); add(theProductKwl,sr_gr_prefix+"."+NUMBER_KEY, static_cast(xnodes.size())); unsigned int idx = 0; for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode, ++idx) { int pos = s_printf(prefix, "%s[%d].", sr_gr_prefix.c_str(), idx); assert(pos >= sizeof(SR_PREFIX)+4 && pos < sizeof(prefix)); addMandatory(theProductKwl, prefix + keyAzimuthTime,**itNode, attAzimuthTime); addMandatory(theProductKwl, prefix + rg0_xpath, **itNode, rg0_xpath); ossimString const& s = getTextFromFirstNode(**itNode, coeffs_xpath); std::vector ssplit = s.split(" "); if (ssplit.empty()) { throw std::runtime_error("The "+rg0_xpath.string()+" record has an empty coef vector"); } add(theProductKwl,prefix+ NUMBER_KEY, ssplit.size()); unsigned int coeff_idx = 0; for (std::vector::const_iterator cIt = ssplit.begin(), e = ssplit.end() ; cIt != e ; ++cIt, ++coeff_idx ) { // append to current prefix s_printf(prefix+pos, sizeof(prefix)-pos, "coeff[%d]", coeff_idx); add(theProductKwl, prefix, *cIt); // Don't check this is really a double. } assert(coeff_idx>0 &&"The rg0 record has empty coefs vector."); } } void ossimSentinel1Model::readGeoLocationGrid(ossimXmlNode const& productRoot) { SCOPED_LOG(traceDebug, "ossimSentinel1Model::readGeoLocationGrid"); char prefix[1024]; std::vector > xnodes; productRoot.findChildNodes("geolocationGrid/geolocationGridPointList/geolocationGridPoint", xnodes); unsigned int idx = 0; for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode,++idx) { int pos = s_printf(prefix, "%s[%d].", GCP_PREFIX.c_str(), idx); assert(pos >= sizeof(SR_PREFIX)+4 && pos < 1024); #if defined(USE_BOOST_TIME) const TimeType azimuthTime = getTimeFromFirstNode(**itNode, attAzimuthTime); add(theProductKwl, prefix, attAzimuthTime, azimuthTime); #else const TimeType azimuthTime = time::toModifiedJulianDate( addMandatory(theProductKwl, prefix, attAzimuthTime, **itNode, attAzimuthTime)); // acquisition time #endif addMandatory(theProductKwl, prefix, keySlantRangeTime, **itNode, attSlantRangeTime); addMandatory(theProductKwl, prefix, keyImPtX, **itNode, attPixel); // In TOPSAR products, GCPs are weird (they fall in black lines // between burst. This code allows moving them to a valid area of // the image. if(theBurstRecords.size()>2) { #if defined(USE_BOOST_TIME) TimeType acqStart; #else TimeType acqStart(0); #endif unsigned long acqStartLine(0); const std::vector::const_reverse_iterator bIt = std::find_if(theBurstRecords.rbegin(), theBurstRecords.rend(), DoesContain(azimuthTime)); if (bIt != theBurstRecords.rend()) { acqStart = bIt->azimuthStartTime; acqStartLine = bIt->startLine; } else if(azimuthTime < theBurstRecords.front().azimuthStartTime) { acqStart = theBurstRecords.front().azimuthStartTime; acqStartLine = theBurstRecords.front().startLine; } else if (azimuthTime >= theBurstRecords.front().azimuthStopTime) { acqStart = theBurstRecords.back().azimuthStartTime; acqStartLine = theBurstRecords.back().startLine; } else { assert(!"unexpected case"); } const DurationType timeSinceStart = azimuthTime - acqStart; // in day frac const double imPt_y= timeSinceStart/theAzimuthTimeInterval + acqStartLine; // std::clog << "timeSinceStart: " << timeSinceStart << "(" << timeSinceStart.total_microseconds() << "us) = " << azimuthTime << " - " << acqStart << " (azTime-acqStart)"<< "\n"; // std::clog << "imPt_y: " << imPt_y << " = " << timeSinceStart.total_microseconds() << "/" << theAzimuthTimeInterval.total_microseconds() << "+" << acqStartLine << "\n"; add(theProductKwl, prefix, keyImPtY, imPt_y); } else { addMandatory(theProductKwl, prefix, keyImPtY, **itNode, attLine); } addMandatory(theProductKwl, prefix, keyWorldPtLat, **itNode, attLatitude); addMandatory(theProductKwl, prefix, keyWorldPtLon, **itNode, attLongitude); addMandatory(theProductKwl, prefix, keyWorldPtHgt, **itNode, attHeight); } add(theProductKwl, GCP_NUMBER_KEY, static_cast(idx)); } void ossimSentinel1Model::addOrbitStateVectors(ossimXmlNode const& orbitList) { ossimXmlNode::ChildListType stateVectorList; orbitList.findChildNodes("orbit", stateVectorList); if(stateVectorList.empty()) { ossimNotify(ossimNotifyLevel_DEBUG) << "No orbitVectorList info available in metadata!!\n"; return; } std::size_t stateVectorList_size = stateVectorList.size(); char orbit_prefix_[256]; for (std::size_t i = 0; i != stateVectorList_size ; ++i) { //orbit_state_vectors const int pos = s_printf(orbit_prefix_, "orbitList.orbit[%d].", int(i)); assert(pos > 0 && pos < 256); const std::string orbit_prefix(orbit_prefix_, pos); addMandatory(theProductKwl, orbit_prefix + keyTime, *stateVectorList[i], "time"); addMandatory(theProductKwl, orbit_prefix + keyPosX, *stateVectorList[i], "position/x"); addMandatory(theProductKwl, orbit_prefix + keyPosY, *stateVectorList[i], "position/y"); addMandatory(theProductKwl, orbit_prefix + keyPosZ, *stateVectorList[i], "position/z"); addMandatory(theProductKwl, orbit_prefix + keyVelX, *stateVectorList[i], "velocity/x"); addMandatory(theProductKwl, orbit_prefix + keyVelY, *stateVectorList[i], "velocity/y"); addMandatory(theProductKwl, orbit_prefix + keyVelZ, *stateVectorList[i], "velocity/z"); } add(theProductKwl,"orbitList.nb_orbits", static_cast(stateVectorList_size)); } bool ossimSentinel1Model::initImageSize(ossimIpt& imageSize) const { std::string const& samples_cstr = theProductKwl.findKey(SUPPORT_DATA_PREFIX, ossimKeywordNames::NUMBER_SAMPLES_KW); std::string const& lines_cstr = theProductKwl.findKey(SUPPORT_DATA_PREFIX, ossimKeywordNames::NUMBER_LINES_KW); imageSize.samp = to(samples_cstr, "decoding sample number from KWL"); imageSize.line = to(lines_cstr, "decoding line number from KWL"); return true; } double ossimSentinel1Model::getBandTerrainHeight(ossimXmlDocument const& productXmlDocument) { double heightSum = 0.0; vector< ossimXmlNodePtr > heightList; productXmlDocument.findNodes("/product/generalAnnotation/terrainHeightList/terrainHeight", heightList); vector::const_iterator it = heightList.begin(); for ( ; it != heightList.end() ; ++it) { heightSum += getOptionalTextFromFirstNode(**it, "value").toFloat64(); } return heightSum / heightList.size(); } void ossimSentinel1Model::addDopplerCentroidCoefficients(ossimXmlNode const& dcEstimateList) { ossimString count_str; dcEstimateList.getAttributeValue(count_str, "count"); const int count = count_str.toInt(); if( count < 1) { ossimNotify(ossimNotifyLevel_DEBUG) << "No doppler centroid coefficients available in metadata!!\n"; return; } else { ossimXmlNode::ChildListType dcEstimates; dcEstimateList.findChildNodes("dcEstimate", dcEstimates); ossimXmlNode::ChildListType::const_iterator it = dcEstimates.begin(); for (int index = 1 ; it != dcEstimates.end() ; ++it, ++index) { char prefix[256]; //Doppler_Centroid_Coefficients.dop_coef_list; s_printf(prefix, "dopplerCentroid.dop_coef_list%d.", index); const ossimXmlNodePtr & dcEstimate = *it; assert(dcEstimate.get()); addOptional(theProductKwl, prefix, "dop_coef_time", *dcEstimate, "azimuthTime"); //RK const double ref_time = getOptionalTextFromFirstNode(*dcEstimate, "t0").toFloat64() * 1e9; // s to ns add(theProductKwl, prefix, keySlantRangeTime, ref_time); ossimString const& ns = getOptionalTextFromFirstNode(*dcEstimate, "ns"); if( !ns.empty() ) add(theProductKwl, prefix, keySlantRangeTime, ns); ossimString const& coeffStr = getOptionalTextFromFirstNode(*dcEstimate, "geometryDcPolynomial"); if (!coeffStr.empty()) { const ossimString separatorList = " "; std::vector result; coeffStr.split(result, separatorList, true); std::vector::const_iterator coeff = result.begin(); for (int count = 1 ; coeff != result.end() ; ++count, ++coeff) { char coeff_prefix[256]; s_printf(coeff_prefix, "%s%d.dop_coef", prefix, count); add(theProductKwl, coeff_prefix, coeff->string()); } } //if (!coeffStr.empty()) } // for each dcEstimate } // else count < 1 } bool ossimSentinel1Model::openMetadataFile(ossimXmlDocument& doc, ossimString const& file) const { if ( !doc.openFile( file ) ) { ossimNotify(ossimNotifyLevel_FATAL) << "Cannot open metadata file `" << file << "`\n"; return false; } return true; } void ossimSentinel1Model::imagingRay(const ossimDpt& image_point, ossimEcefRay& image_ray) const { // NOT YET IMPLEMENTED setErrorStatus(); } } //end namespace OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSentinel1Model.h000066400000000000000000000116101301006202600275430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimSentinel1Model_HEADER #define ossimSentinel1Model_HEADER #include #include #include #include #include #include #include #include //#include //#include #include "ossimSarSensorModel.h" #include "ossimPluginConstants.h" // OSSIM_PLUGINS_DLL #include //#include "ossimGeometricSarSensorModel.h" class OSSIMDLLEXPORT ossimXmlNode; class OSSIMDLLEXPORT ossimString; namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimSentinel1Model : public ossimSarSensorModel { public: typedef ossimRefPtr ossimXmlNodePtr; typedef ossimRefPtr ossimXmlDocumentPtr; /** * CONSTRUCTORS. * @{ */ /** @brief Default constructor */ ossimSentinel1Model(); #if ! (defined(BOOST_NO_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX1_DEFAULTED_FUNCTIONS)) /** @brief Copy constructor */ ossimSentinel1Model(ossimSentinel1Model const& rhs) = default; /** @brief Move constructor */ ossimSentinel1Model(ossimSentinel1Model && rhs) = default; /** @brief Destructor */ virtual ~ossimSentinel1Model() = default; #endif //@} bool open(const ossimFilename& file); /*! * Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /*! * Extends base-class implementation. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; /*! * Fulfills ossimObject base-class pure virtuals. Loads and saves geometry * KWL files. Returns true if successful. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=NULL) const; virtual bool loadState(ossimKeywordlist const& kwl, const char* prefix=NULL); bool checkDirectory(const ossimFilename& file, const char* d, const char *ext) const; bool isLevel0(ossimFilename const& file) const; bool isLevel2(ossimFilename const& file) const; bool isLevel1(ossimFilename const& file) const; bool isSentinel1(ossimFilename const &manifestFile); bool readProduct(ossimFilename const &productXmlFile); ossimString const& getImageId(ossimXmlDocument const& manifestDoc) const; ossimString initSensorID(ossimXmlDocument const& manifestDoc); bool standAloneProductInformation(ossimXmlDocument const& manifestDoc); // bool getAnnotationFileLocation(const ossimFilename &manifestFile, const char* pattern); bool initImageSize(ossimIpt& imageSize) const; virtual void imagingRay(ossimDpt const& image_point, ossimEcefRay& image_ray) const; bool isSLC() const { return theSLC; } bool isOCN() const { return theOCN; } #if 0 bool initSRGR(); #endif ossimFilename searchManifestFile(const ossimFilename& file) const; void clearFields(); double getBandTerrainHeight(ossimXmlDocument const& theProductXmlDocument); void setMetadataDirectory(ossimFilename const& d) { theManifestDirectory = d; } protected: TYPE_DATA; private: bool read(ossimFilename const& annotationXml); void readCalibrationMetadata(); void readNoiseMetadata(); void readBurstRecords(ossimXmlNode const& productRoot, ossimXmlNode const& imageInformation); void addSRGRCoefficients(ossimXmlNode const& coordinateConversion); void readCoordinates( ossimXmlNode const& node, ossimString const& rg0_xpath, ossimString const& coeffs_xpath, std::string const& sr_gr_prefix); void readGeoLocationGrid(ossimXmlNode const& productRoot); void addOrbitStateVectors(ossimXmlNode const& orbitList); void addDopplerCentroidCoefficients(ossimXmlNode const& dcEstimateList); bool openMetadataFile(ossimXmlDocument& doc, ossimString const& file) const; ossimFilename theManifestDirectory; ossimFilename theProductXmlFile; // ossimFilename theManifestFile; ossimKeywordlist theManifestKwl; ossimKeywordlist theProductKwl; bool theOCN; bool theSLC; bool theTOPSAR; }; //end class ossimSentinel1Model } //end namespace ossimplugins #endif /* #ifndef ossimSentinel1Model_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSentinel1SarSensorModel.cpp000066400000000000000000000302271301006202600317430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace {// Anonymous namespace const ossimString attAzimuthTime = "azimuthTime"; const ossimString attFirstValidSample = "firstValidSample"; const ossimString attGr0 = "gr0"; const ossimString attGrsrCoefficients = "grsrCoefficients"; const ossimString attHeight = "height"; const ossimString attLatitude = "latitude"; const ossimString attLine = "line"; const ossimString attLongitude = "longitude"; const ossimString attPixel = "pixel"; const ossimString attPosition = "position"; const ossimString attSlantRangeTime = "slantRangeTime"; const ossimString attSr0 = "sr0"; const ossimString attSrgrCoefficients = "srgrCoefficients"; const ossimString attTime = "time"; const ossimString attVelocity = "velocity"; const ossimString attX = "x"; const ossimString attY = "y"; const ossimString attZ = "z"; }// Anonymous namespace #if defined(USE_BOOST_TIME) using boost::posix_time::microseconds; using boost::posix_time::seconds; #else using ossimplugins::time::microseconds; using ossimplugins::time::seconds; #endif void ossimplugins::ossimSentinel1SarSensorModel::readCoordinates( ossimXmlDocument const& xmlDoc, ossimString const& xpath, ossimString const& rg0_xpath, ossimString const& coeffs_xpath, std::vector & outputRecords) { std::vector > xnodes; xmlDoc.findNodes(xpath, xnodes); for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode) { CoordinateConversionRecordType coordRecord; coordRecord.azimuthTime = getTimeFromFirstNode(**itNode, attAzimuthTime); coordRecord.rg0 = getDoubleFromFirstNode(**itNode, rg0_xpath);; ossimString const& s = getTextFromFirstNode(**itNode, coeffs_xpath); std::vector ssplit = s.split(" "); if (ssplit.empty()) { throw std::runtime_error(("The "+rg0_xpath+" record has an empty coef vector").string()); } for (std::vector::const_iterator cIt = ssplit.begin(), e = ssplit.end() ; cIt != e ; ++cIt ) { coordRecord.coefs.push_back(cIt->toDouble()); } assert(!coordRecord.coefs.empty()&&"The rg0 record has empty coefs vector."); outputRecords.push_back(coordRecord); } } namespace ossimplugins { void ossimSentinel1SarSensorModel::readAnnotationFile(const std::string & annotationXml) { ossimRefPtr xmlDoc = new ossimXmlDocument(annotationXml); const ossimXmlNode & xmlRoot = *xmlDoc->getRoot(); //Parse specific metadata for Sentinel1 //TODO add as members to the Sentinel1SarSensorModel const std::string & product_type = getTextFromFirstNode(xmlRoot, "adsHeader/productType"); const std::string & mode = getTextFromFirstNode(xmlRoot, "adsHeader/mode"); const std::string & swath = getTextFromFirstNode(xmlRoot, "adsHeader/swath"); const std::string & polarisation = getTextFromFirstNode(xmlRoot, "adsHeader/polarisation"); theProductType = ProductType(product_type); // First, lookup position/velocity records std::vector > xnodes; xmlDoc->findNodes("/product/generalAnnotation/orbitList/orbit",xnodes); //TODO uncomment and adapt following code from s1_inverse to fill //SarSensorModel structure for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode) { OrbitRecordType orbitRecord; // Retrieve acquisition time orbitRecord.azimuthTime = getTimeFromFirstNode(**itNode, attTime); // Retrieve ECEF position ossimXmlNode const& positionNode = getExpectedFirstNode(**itNode, attPosition); orbitRecord.position[0] = getDoubleFromFirstNode(positionNode, attX); orbitRecord.position[1] = getDoubleFromFirstNode(positionNode, attY); orbitRecord.position[2] = getDoubleFromFirstNode(positionNode, attZ); // Retrieve ECEF velocity ossimXmlNode const& velocityNode = getExpectedFirstNode(**itNode, attVelocity); orbitRecord.velocity[0] = getDoubleFromFirstNode(velocityNode, attX); orbitRecord.velocity[1] = getDoubleFromFirstNode(velocityNode, attY); orbitRecord.velocity[2] = getDoubleFromFirstNode(velocityNode, attZ); //Add one orbits record theOrbitRecords.push_back(orbitRecord); } //Parse the near range time (in seconds) theNearRangeTime = getDoubleFromFirstNode(xmlRoot, "imageAnnotation/imageInformation/slantRangeTime"); //Parse the range sampling rate theRangeSamplingRate = getDoubleFromFirstNode(xmlRoot, "generalAnnotation/productInformation/rangeSamplingRate"); //Parse the range resolution theRangeResolution = getDoubleFromFirstNode(xmlRoot, "imageAnnotation/imageInformation/rangePixelSpacing"); //Parse the radar frequency theRadarFrequency = getDoubleFromFirstNode(xmlRoot, "generalAnnotation/productInformation/radarFrequency"); //Parse azimuth time interval const double azimuthTimeInterval = getDoubleFromFirstNode(xmlRoot, "imageAnnotation/imageInformation/azimuthTimeInterval"); #if defined(USE_BOOST_TIME) theAzimuthTimeInterval = boost::posix_time::precise_duration(azimuthTimeInterval * 1000000.); #else theAzimuthTimeInterval = seconds(azimuthTimeInterval); #endif ossimNotify(ossimNotifyLevel_DEBUG) << "theAzimuthTimeInterval " << theAzimuthTimeInterval.total_microseconds() << "us\n"; // Now read burst records as well xnodes.clear(); xmlDoc->findNodes("/product/swathTiming/burstList/burst",xnodes); if(xnodes.empty()) { BurstRecordType burstRecord; burstRecord.startLine = 0; burstRecord.azimuthStartTime = getTimeFromFirstNode(xmlRoot,"imageAnnotation/imageInformation/productFirstLineUtcTime"); ossimNotify(ossimNotifyLevel_DEBUG)<< burstRecord.azimuthStartTime<<'\n'; burstRecord.azimuthStopTime = getTimeFromFirstNode(xmlRoot,"imageAnnotation/imageInformation/productLastLineUtcTime"); burstRecord.endLine = getTextFromFirstNode(xmlRoot, "imageAnnotation/imageInformation/numberOfLines").toUInt16()-1; theBurstRecords.push_back(burstRecord); } else { const unsigned int linesPerBurst = xmlRoot.findFirstNode("swathTiming/linesPerBurst")->getText().toUInt16(); unsigned int burstId(0); for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode,++burstId) { BurstRecordType burstRecord; const ossimSarSensorModel::TimeType azTime = getTimeFromFirstNode(**itNode, attAzimuthTime); ossimString const& s = getTextFromFirstNode(**itNode, attFirstValidSample); long first_valid(0), last_valid(0); bool begin_found(false), end_found(false); std::vector ssp = s.split(" "); for (std::vector::const_iterator sIt = ssp.begin(), e = ssp.end() ; sIt != e && !end_found ; ++sIt ) { if(!begin_found) { if(*sIt!="-1") { begin_found = true; } else { ++first_valid; } ++last_valid; } else { if(!end_found && *sIt=="-1") { end_found = true; } else { ++last_valid; } } } burstRecord.startLine = burstId*linesPerBurst + first_valid; burstRecord.endLine = burstId*linesPerBurst + last_valid; burstRecord.azimuthStartTime = azTime + (first_valid*theAzimuthTimeInterval); burstRecord.azimuthStopTime = azTime + (last_valid*theAzimuthTimeInterval); theBurstRecords.push_back(burstRecord); } } if(isGRD()) { readCoordinates(*xmlDoc, "/product/coordinateConversion/coordinateConversionList/coordinateConversion", attSr0, attSrgrCoefficients, theSlantRangeToGroundRangeRecords); readCoordinates(*xmlDoc, "/product/coordinateConversion/coordinateConversionList/coordinateConversion", attGr0, attGrsrCoefficients, theGroundRangeToSlantRangeRecords); } xnodes.clear(); xmlDoc->findNodes("/product/geolocationGrid/geolocationGridPointList/geolocationGridPoint",xnodes); for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode) { GCPRecordType gcpRecord; // Retrieve acquisition time gcpRecord.azimuthTime = getTimeFromFirstNode(**itNode, attAzimuthTime); gcpRecord.slantRangeTime = getDoubleFromFirstNode(**itNode, attSlantRangeTime); gcpRecord.imPt.x = getDoubleFromFirstNode(**itNode, attPixel); // In TOPSAR products, GCPs are weird (they fall in black lines // between burst. This code allows moving them to a valid area of // the image. if(theBurstRecords.size()>2) { ossimSarSensorModel::TimeType acqStart; bool burstFound(false); unsigned long acqStartLine(0); for(std::vector::reverse_iterator bIt = theBurstRecords.rbegin();bIt!=theBurstRecords.rend() && !burstFound;++bIt) { if(gcpRecord.azimuthTime >= bIt->azimuthStartTime && gcpRecord.azimuthTime < bIt->azimuthStopTime) { burstFound = true; acqStart = bIt->azimuthStartTime; acqStartLine = bIt->startLine; } } if(!burstFound) { if(gcpRecord.azimuthTime < theBurstRecords.front().azimuthStartTime) { acqStart = theBurstRecords.front().azimuthStartTime; acqStartLine = theBurstRecords.front().startLine; } else if (gcpRecord.azimuthTime >= theBurstRecords.front().azimuthStopTime) { acqStart = theBurstRecords.back().azimuthStartTime; acqStartLine = theBurstRecords.back().startLine; } } const DurationType timeSinceStart = gcpRecord.azimuthTime - acqStart; gcpRecord.imPt.y= timeSinceStart/theAzimuthTimeInterval + acqStartLine; ossimNotify(ossimNotifyLevel_DEBUG) << "timeSinceStart: " << timeSinceStart << " = " << gcpRecord.azimuthTime << " - " << acqStart << " (azTime-acqStart)"<< "\n"; ossimNotify(ossimNotifyLevel_DEBUG) << "imPt_y: " << gcpRecord.imPt.y << " = " << timeSinceStart.total_microseconds() << "/" << theAzimuthTimeInterval.total_microseconds() << "+" << acqStartLine << "\n"; } else { gcpRecord.imPt.y = getDoubleFromFirstNode(**itNode, attLine);; } ossimGpt geoPoint; gcpRecord.worldPt.lat = getDoubleFromFirstNode(**itNode, attLatitude); gcpRecord.worldPt.lon = getDoubleFromFirstNode(**itNode, attLongitude); gcpRecord.worldPt.hgt = getDoubleFromFirstNode(**itNode, attHeight); theGCPRecords.push_back(gcpRecord); } this->optimizeTimeOffsetsFromGcps(); } } // namespace ossimplugins OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSentinel1SarSensorModel.h000066400000000000000000000031411301006202600314030ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimSentinel1SarSensorModel_HEADER #define ossimSentinel1SarSensorModel_HEADER #include #include "ossimSarSensorModel.h" class ossimXmlDocument; class ossimString; namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimSentinel1SarSensorModel : public ossimSarSensorModel { public: #if ! (defined(BOOST_NO_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX1_DEFAULTED_FUNCTIONS)) /** Constructor */ ossimSentinel1SarSensorModel()=default; /** Copy constructor */ ossimSentinel1SarSensorModel(ossimSentinel1SarSensorModel const& m)=default; /** Move constructor */ ossimSentinel1SarSensorModel(ossimSentinel1SarSensorModel && m)=default; /** Destructor */ virtual ~ossimSentinel1SarSensorModel()=default; #endif void readAnnotationFile(const std::string & annotationXml); private: void readCoordinates( ossimXmlDocument const& xmlDoc, ossimString const& xpath, ossimString const& rg0_xpath, ossimString const& coeffs_xpath, std::vector & outputRecords ); protected: /* std::string theProductType; std::string theMode; std::string theSwath; std::string thePolarisation; */ }; } // end namespace #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSpot6DimapSupportData.cpp000066400000000000000000002100541301006202600314330ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2014 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Christophe Palmann (christophe.palmann@c-s.fr) // // Description: // // Contains declaration of class ossimSpot6DimapSupportData // //***************************************************************************** #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Define Trace flags for use within this file: static ossimTrace traceExec ("ossimSpot6DimapSupportData:exec"); static ossimTrace traceDebug ("ossimSpot6DimapSupportData:debug"); static std::string getVectorFloat64AsString(std::vector in) { std::vector::iterator it; std::stringstream strTmp; for ( it=in.begin() ; it < in.end(); it++ ) { strTmp << " " << (*it); } return strTmp.str(); } static std::string getVectorDoubleAsString(std::vector in) { std::vector::iterator it; std::stringstream strTmp; for ( it=in.begin() ; it < in.end(); it++ ) { strTmp << " " << (*it); } return strTmp.str(); } static std::string getVectorStringAsString(std::vector in) { std::vector::iterator it; std::stringstream strTmp; for ( it=in.begin() ; it < in.end(); it++ ) { strTmp << " " << (*it); } return strTmp.str(); } namespace ossimplugins { static bool readOneXmlNode(ossimRefPtr xmlDocument, ossimString xpath, ossimString& nodeValue) { vector > xml_nodes; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } if (xml_nodes.size() != 1) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << " DEBUG:" << "\nMore than one node value with " << xpath << std::endl; } return false; } nodeValue = xml_nodes[0]->getText(); return true; } ossimSpot6DimapSupportData::ossimSpot6DimapSupportData () :ossimErrorStatusInterface(), theDIMAPVersion(OSSIM_Spot6_UNKNOWN), theMetadataSubProfile(OSSIM_Spot6_METADATA_SUBPROFILE_UNKNOWN), theProductIsOk(false), theRpcIsOk(false), theXmlDocumentRoot(), theSensorID(), theImageID(), theProductionDate(), theAcquisitionDate(), theInstrument(), theInstrumentIndex(), theProcessingLevelString(), theSpectralProcessingString(), theSunAzimuth(), theSunElevation(), theIncidenceAngle(), theViewingAngle(), theAzimuthAngle(), theImageSize(0, 0), theTileSize(0, 0), theNumberOfMegaTilesInRow(0), theNumberOfMegaTilesInCol(0), theNumberOfMegaTiles(0), theMultiDataFile(), theNumBands(0), theBandOrder(), thePhysicalBias(), thePhysicalGain(), theSolarIrradiance(), theUlCorner(), theUrCorner(), theLrCorner(), theLlCorner(), theSpecId(), theErrBias(0), theErrBiasX(0), theErrBiasY(0), theErrRand(0), theLineOffset(0), theSampOffset(0), theLatOffset(0), theLonOffset(0), theHeightOffset(0), theLineScale(0), theSampScale(0), theLatScale(0), theLonScale(0), theHeightScale(0), theLineNumCoeff(), theLineDenCoeff(), theSampNumCoeff(), theSampDenCoeff(), theRefGroundPoint(0.0, 0.0, 0.0), theRefImagePoint(0.0, 0.0) { } ossimSpot6DimapSupportData::~ossimSpot6DimapSupportData () { } void ossimSpot6DimapSupportData::clearFields() { clearErrorStatus(); theDIMAPVersion = OSSIM_Spot6_UNKNOWN; theMetadataSubProfile = OSSIM_Spot6_METADATA_SUBPROFILE_UNKNOWN; theProductIsOk = false; theRpcIsOk = false; theXmlDocumentRoot = ""; theImageID = ""; theSensorID=""; theProductionDate = ""; theAcquisitionDate = ""; theInstrument = ""; theInstrumentIndex = ""; theProcessingLevelString = ""; theSpectralProcessingString = ""; theSunAzimuth.clear(); theSunElevation.clear(); theIncidenceAngle.clear(); theViewingAngle.clear(); theAzimuthAngle.clear(); theImageSize.makeNan(); theTileSize.makeNan(); theNumberOfMegaTilesInRow = 0; theNumberOfMegaTilesInCol = 0; theNumberOfMegaTiles = 0; ossimString msg = ""; theMultiDataFile.setBooleanValue(false, msg); theNumBands = 0; theBandOrder.clear(); thePhysicalBias.clear(); thePhysicalGain.clear(); theSolarIrradiance.clear(); //--- // Corner points: //--- theUlCorner.makeNan(); theUrCorner.makeNan(); theLrCorner.makeNan(); theLlCorner.makeNan(); theRefGroundPoint.makeNan(); theRefImagePoint.makeNan(); //--- // RPC model parameters //--- theErrBias = 0.0; theErrBiasX = 0.0; theErrBiasY = 0.0; theErrRand = 0.0; theLineOffset = 0; theSampOffset = 0; theLatOffset = 0.0; theLonOffset = 0.0; theHeightOffset = 0.0; theLineScale = 0.0; theSampScale = 0.0; theLatScale = 0.0; theLonScale = 0.0; theHeightScale = 0.0; theLineNumCoeff.clear(); theLineDenCoeff.clear(); theSampNumCoeff.clear(); theSampDenCoeff.clear(); theSpecId = ""; } void ossimSpot6DimapSupportData::printInfo(ostream& os) const { os << "\n----------------- Info on Spot6 Image -------------------" << "\n " << "\n Job Number (ID): " << theImageID << "\n Acquisition Date: " << theAcquisitionDate << "\n Instrument: " << theInstrument << "\n Instrument Index: " << theInstrumentIndex << "\n Production Date: " << theProductionDate << "\n Processing Level: " << theProcessingLevelString << "\n Spectral Processing: " << theSpectralProcessingString << "\n Number of Bands: " << theNumBands << "\n Bands Display Order: " << getVectorStringAsString(theBandOrder) << "\n Image Size: " << theImageSize << "\n Tile Size: " << theTileSize << "\n Number Of Tiles (Row, Col): " << theNumberOfMegaTiles << " (" << theNumberOfMegaTilesInRow << ", " << theNumberOfMegaTilesInCol << ")" << "\n Incidence Angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theIncidenceAngle) << "\n Viewing Angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theViewingAngle) << "\n Azimuth Angle (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theAzimuthAngle) << "\n Sun Azimuth (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theSunAzimuth) << "\n Sun Elevation (TopCenter, Center, BottomCenter): " << getVectorFloat64AsString(theSunElevation) << "\n Physical Bias (for each band): " << getVectorFloat64AsString(thePhysicalBias) << "\n Physical Gain (for each band): " << getVectorFloat64AsString(thePhysicalGain) << "\n Solar Irradiance (for each band): " << getVectorFloat64AsString(theSolarIrradiance) << "\n Geo Center Point: " << theRefGroundPoint // TODO add RefImagePoint if necessary << "\n Corner Points:" << "\n UL: " << theUlCorner << "\n UR: " << theUrCorner << "\n LR: " << theLrCorner << "\n LL: " << theLlCorner << "\n" << "\n RPC model parameters:" << "\n RPC ID: " << theSpecId << "\n SampNumCoeff: " << getVectorDoubleAsString(theSampNumCoeff) << "\n SampDenCoeff: " << getVectorDoubleAsString(theSampDenCoeff) << "\n LineNumCoeff: " << getVectorDoubleAsString(theLineNumCoeff) << "\n LineDenCoeff: " << getVectorDoubleAsString(theLineDenCoeff) << "\n LonScale: " << theLonScale << "\n LonOffset: " << theLonOffset << "\n LatScale: " << theLatScale << "\n LonScale: " << theLonScale << "\n HeightScale: " << theHeightScale << "\n HeightOffset: " << theHeightOffset << "\n SampScale: " << theSampScale << "\n SampOffset: " << theSampOffset << "\n LineScale: " << theLineScale << "\n LineOffset: " << theLineOffset << "\n theErrBias: " << theErrBias << "\n theErrBiasX: " << theErrBiasX << "\n theErrBiasY: " << theErrBiasY << "\n theErrRand: " << theErrRand << "\n" << "\n---------------------------------------------------------" << "\n " << std::endl; } bool ossimSpot6DimapSupportData::parseXmlFile(const ossimFilename& file) { static const char MODULE[] = "ossimSpot6DimapSupportData::parseXmlFile"; //traceDebug.setTraceFlag(true); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nFile: " << file << std::endl; } if (allMetadataRead()) clearFields(); //--- // Instantiate the file reading: //--- ossim_int64 fileSize = file.fileSize(); std::ifstream in(file.c_str(), std::ios::binary|std::ios::in); std::vector fullBuffer; ossimString bufferedIo; if(in.good()&&(fileSize > 0)) { char buf[100]; fullBuffer.resize(fileSize); in.read(buf, std::min((ossim_int64)100, fileSize)); if(!in.fail()) { ossimString testString = ossimString(buf, buf + in.gcount()); if(testString.contains("xml")) { in.seekg(0); in.read(&fullBuffer.front(), (std::streamsize)fullBuffer.size()); if(!in.fail()) { bufferedIo = ossimString(fullBuffer.begin(), fullBuffer.begin()+in.gcount()); } } } } else { return false; } //--- // Instantiate the XML parser: //--- ossimRefPtr xmlDocument; if(bufferedIo.empty()) { xmlDocument = new ossimXmlDocument(file); } else { xmlDocument = new ossimXmlDocument; std::istringstream inStringStream(bufferedIo.string()); if(!xmlDocument->read(inStringStream)) { return false; } } if (xmlDocument->getErrorStatus()) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nUnable to parse xml file" << std::endl; } setErrorStatus(); return false; } if (!parseMetadataIdentificationDIMAPv2(xmlDocument) ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseMetadataIdentification failed. Returning false" << std::endl; } return false; } if (theMetadataSubProfile == OSSIM_Spot6_METADATA_SUBPROFILE_PRODUCT) { if (theProductIsOk) clearFields(); if (!parseDatasetIdentification(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseDatasetdentification failed. Returning false" << std::endl; } return false; } if (!parseDatasetContent(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseDatasetContent failed. Returning false" << std::endl; return false; } if (!parseProductInformation(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseProductInformation failed. Returning false" << std::endl; } return false; } if (!parseCoordinateReferenceSystem(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseCoordinateReferenceSystem failed. Returning false" << std::endl; } return false; } if (!parseGeoposition(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseGeoposition failed. Returning false" << std::endl; } return false; } if (!parseProcessingInformation(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseProcessingInformation failed. Returning false" << std::endl; } return false; } if (!parseRasterData(xmlDocument)) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseRasterData failed. Returning false" << std::endl; } return false; } if (!parseRadiometricData(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseRadiometricData failed. Returning false" << std::endl; return false; } if (!parseGeometricData(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseGeometricData failed. Returning false" << std::endl; return false; } if (!parseQualityAssessment(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseQualityAssessment failed. Returning false" << std::endl; return false; } if (!parseDatasetSources(xmlDocument)) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseDatasetSources failed. Returning false" << std::endl; return false; } theProductIsOk = true; } if (theMetadataSubProfile == OSSIM_Spot6_METADATA_SUBPROFILE_RPC) { // Parse RPC file if (theProcessingLevelString == "SENSOR") { if (parseRPCMetadata(xmlDocument) == false) { ossimNotify(ossimNotifyLevel_FATAL) << MODULE << " DEBUG:" << "ossimSpot6DimapSupportData::parseXmlFile:" << "\nparseRPCMetadata initialization failed. Returning false" << std::endl; return false; } theRpcIsOk = true; } else theRpcIsOk = true; } if (theProcessingLevelString != "SENSOR") theRpcIsOk = true; if (traceDebug() && allMetadataRead()) { printInfo(ossimNotify(ossimNotifyLevel_DEBUG)); ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: exited..." << std::endl; } return true; } ossimString ossimSpot6DimapSupportData::getProcessingLevel() const { return theProcessingLevelString; } ossimString ossimSpot6DimapSupportData::getSensorID() const { return theSensorID; } ossimString ossimSpot6DimapSupportData::getAcquisitionDate() const { return theAcquisitionDate; } ossimString ossimSpot6DimapSupportData::getProductionDate() const { return theProductionDate; } ossimString ossimSpot6DimapSupportData::getImageID() const { return theImageID; } ossimString ossimSpot6DimapSupportData::getInstrument() const { return theInstrument; } ossimString ossimSpot6DimapSupportData::getInstrumentIndex() const { return theInstrumentIndex; } void ossimSpot6DimapSupportData::getSunAzimuth(std::vector& az) const { az = theSunAzimuth; } void ossimSpot6DimapSupportData::getSunElevation(std::vector& el) const { el = theSunElevation; } void ossimSpot6DimapSupportData::getImageSize(ossimIpt& sz) const { sz = theImageSize; } ossim_uint32 ossimSpot6DimapSupportData::getNumberOfBands() const { return theNumBands; } void ossimSpot6DimapSupportData::getIncidenceAngle(std::vector& ia) const { ia = theIncidenceAngle; } void ossimSpot6DimapSupportData::getViewingAngle(std::vector& va) const { va = theViewingAngle; } void ossimSpot6DimapSupportData::getRefGroundPoint(ossimGpt& gp) const { gp = theRefGroundPoint; } void ossimSpot6DimapSupportData::getRefImagePoint(ossimDpt& rp) const { rp = theRefImagePoint; } void ossimSpot6DimapSupportData::getUlCorner(ossimGpt& pt) const { pt = theUlCorner; } void ossimSpot6DimapSupportData::getUrCorner(ossimGpt& pt) const { pt = theUrCorner; } void ossimSpot6DimapSupportData::getLrCorner(ossimGpt& pt) const { pt = theLrCorner; } void ossimSpot6DimapSupportData::getLlCorner(ossimGpt& pt) const { pt = theLlCorner; } void ossimSpot6DimapSupportData::getImageRect(ossimDrect& rect)const { rect = ossimDrect(0.0, 0.0, theImageSize.x-1.0, theImageSize.y-1.0); } bool ossimSpot6DimapSupportData::saveState(ossimKeywordlist& kwl, const char* prefix)const { ossimString tempString; ossim_uint32 idx = 0; kwl.add(prefix, ossimKeywordNames::TYPE_KW, "ossimSpot6DimapSupportData", true); tempString = ""; for(idx = 0; idx < theSunAzimuth.size(); ++idx) { tempString += (ossimString::toString(theSunAzimuth[idx]) + " "); } kwl.add(prefix, ossimKeywordNames::AZIMUTH_ANGLE_KW, tempString, true); kwl.add(prefix, "number_of_azimuth_angle", static_cast(theSunAzimuth.size()), true); tempString = ""; for(idx = 0; idx < theSunElevation.size(); ++idx) { tempString += (ossimString::toString(theSunElevation[idx]) + " "); } kwl.add(prefix, ossimKeywordNames::ELEVATION_ANGLE_KW, tempString, true); kwl.add(prefix, "number_of_elevation_angle", static_cast(theSunElevation.size()), true); //--- // Note: since this is a new keyword, use the point.toString as there is // no backwards compatibility issues. //--- kwl.add(prefix, "image_size", ossimString::toString(theImageSize.x) + " " + ossimString::toString(theImageSize.y), true); kwl.add(prefix, "reference_ground_point", ossimString::toString(theRefGroundPoint.latd()) + " " + ossimString::toString(theRefGroundPoint.lond()) + " " + ossimString::toString(theRefGroundPoint.height()) + " " + theRefGroundPoint.datum()->code(), true); kwl.add(prefix, "reference_image_point", ossimString::toString(theRefImagePoint.x) + " " + ossimString::toString(theRefImagePoint.y), true); kwl.add(prefix, ossimKeywordNames::NUMBER_BANDS_KW, theNumBands, true); tempString = ""; for(idx = 0; idx < theBandOrder.size(); ++idx) { tempString += (theBandOrder[idx] + " "); } kwl.add(prefix, "band_name_list", tempString, true); kwl.add(prefix, "image_id", theImageID, true); kwl.add(prefix, "processing_level", theProcessingLevelString, true); kwl.add(prefix, "instrument", theInstrument, true); kwl.add(prefix, "instrument_index", theInstrumentIndex, true); kwl.add(prefix, ossimKeywordNames::IMAGE_DATE_KW, theAcquisitionDate, true); kwl.add(prefix, "production_date", theProductionDate, true); tempString = ""; for(idx = 0; idx < theIncidenceAngle.size(); ++idx) { tempString += (ossimString::toString(theIncidenceAngle[idx]) + " "); } kwl.add(prefix, "incident_angle", tempString, true); kwl.add(prefix, "number_of_incident_angle", static_cast(theIncidenceAngle.size()), true); tempString = ""; for(idx = 0; idx < theViewingAngle.size(); ++idx) { tempString += (ossimString::toString(theViewingAngle[idx]) + " "); } kwl.add(prefix, "viewing_angle", tempString, true); kwl.add(prefix, "number_of_viewing_angle", static_cast(theViewingAngle.size()), true); tempString = ""; for(idx = 0; idx < theAzimuthAngle.size(); ++idx) { tempString += (ossimString::toString(theAzimuthAngle[idx]) + " "); } kwl.add(prefix, "scene_orientation", tempString, true); kwl.add(prefix, "number_of_scene_orientation", static_cast(theAzimuthAngle.size()), true); kwl.add(prefix, "ul_ground_point", ossimString::toString(theUlCorner.latd()) + " " + ossimString::toString(theUlCorner.lond()) + " " + ossimString::toString(theUlCorner.height()) + " " + theUlCorner.datum()->code(), true); kwl.add(prefix, "ur_ground_point", ossimString::toString(theUrCorner.latd()) + " " + ossimString::toString(theUrCorner.lond()) + " " + ossimString::toString(theUrCorner.height()) + " " + theUrCorner.datum()->code(), true); kwl.add(prefix, "lr_ground_point", ossimString::toString(theLrCorner.latd()) + " " + ossimString::toString(theLrCorner.lond()) + " " + ossimString::toString(theLrCorner.height()) + " " + theLrCorner.datum()->code(), true); kwl.add(prefix, "ll_ground_point", ossimString::toString(theLlCorner.latd()) + " " + ossimString::toString(theLlCorner.lond()) + " " + ossimString::toString(theLlCorner.height()) + " " + theLlCorner.datum()->code(), true); kwl.add(prefix, "sensorID", theSensorID, true); tempString = ""; for(idx = 0; idx < thePhysicalBias.size(); ++idx) { tempString += (ossimString::toString(thePhysicalBias[idx]) + " "); } kwl.add(prefix, "physical_bias", tempString, true); tempString = ""; for(idx = 0; idx < thePhysicalGain.size(); ++idx) { tempString += (ossimString::toString(thePhysicalGain[idx]) + " "); } kwl.add(prefix, "physical_gain", tempString, true); tempString = ""; for(idx = 0; idx < theSolarIrradiance.size(); ++idx) { tempString += (ossimString::toString(theSolarIrradiance[idx]) + " "); } kwl.add(prefix, "solar_irradiance", tempString, true); return true; } bool ossimSpot6DimapSupportData::loadState(const ossimKeywordlist& kwl, const char* prefix) { ossim_uint32 idx = 0; ossim_uint32 total; ossimString tempString; clearFields(); ossimString type = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if(type != "ossimSpot6DimapSupportData") { return false; } total = ossimString(kwl.find(prefix,"number_of_azimuth_angle")).toUInt32(); theSunAzimuth.resize(total); tempString = kwl.find(prefix,ossimKeywordNames::AZIMUTH_ANGLE_KW); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theSunAzimuth.size();++idx) { in >> tempValue.string(); theSunAzimuth[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_elevation_angle")).toUInt32(); theSunElevation.resize(total); tempString = kwl.find(prefix,ossimKeywordNames::ELEVATION_ANGLE_KW); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theSunElevation.size();++idx) { in >> tempValue.string(); theSunElevation[idx] = tempValue.toDouble(); } } theImageSize = createIpt(kwl.find(prefix, "image_size")); theRefGroundPoint = createGround(kwl.find(prefix, "reference_ground_point")); theRefImagePoint = createDpt(kwl.find(prefix, "reference_image_point")); theNumBands = ossimString(kwl.find(prefix, ossimKeywordNames::NUMBER_BANDS_KW)).toUInt32(); theBandOrder.resize(theNumBands); tempString = kwl.find(prefix,"band_name_list"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theBandOrder.size();++idx) { in >> tempValue.string(); theBandOrder[idx] = tempValue; } } theAcquisitionDate = kwl.find(prefix, ossimKeywordNames::IMAGE_DATE_KW); theProductionDate = kwl.find(prefix, "production_date"); theImageID = kwl.find(prefix, "image_id"); theInstrument = kwl.find(prefix, "instrument"); theInstrumentIndex = kwl.find(prefix, "instrument_index"); total = ossimString(kwl.find(prefix,"number_of_incident_angle")).toUInt32(); theIncidenceAngle.resize(total); tempString = kwl.find(prefix,"incident_angle"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theIncidenceAngle.size();++idx) { in >> tempValue.string(); theIncidenceAngle[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_viewing_angle")).toUInt32(); theViewingAngle.resize(total); tempString = kwl.find(prefix,"viewing_angle"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theViewingAngle.size();++idx) { in >> tempValue.string(); theViewingAngle[idx] = tempValue.toDouble(); } } total = ossimString(kwl.find(prefix,"number_of_scene_orientation")).toUInt32(); theAzimuthAngle.resize(total); tempString = kwl.find(prefix,"scene_orientation"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theAzimuthAngle.size();++idx) { in >> tempValue.string(); theAzimuthAngle[idx] = tempValue.toDouble(); } } theUlCorner =createGround( kwl.find(prefix, "ul_ground_point")); theUrCorner =createGround( kwl.find(prefix, "ur_ground_point")); theLrCorner =createGround( kwl.find(prefix, "lr_ground_point")); theLlCorner =createGround( kwl.find(prefix, "ll_ground_point")); theSensorID = ossimString(kwl.find(prefix, "sensorID")); theProcessingLevelString = ossimString(kwl.find(prefix, "processing_level")); thePhysicalBias.resize(theNumBands); tempString = kwl.find(prefix,"physical_bias"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < thePhysicalBias.size();++idx) { in >> tempValue.string(); thePhysicalBias[idx] = tempValue.toDouble(); } } thePhysicalGain.resize(theNumBands); tempString = kwl.find(prefix,"physical_gain"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < thePhysicalGain.size();++idx) { in >> tempValue.string(); thePhysicalGain[idx] = tempValue.toDouble(); } } theSolarIrradiance.resize(theNumBands); tempString = kwl.find(prefix,"solar_irradiance"); if(tempString != "") { std::istringstream in(tempString.string()); ossimString tempValue; for(idx = 0; idx < theSolarIrradiance.size();++idx) { in >> tempValue.string(); theSolarIrradiance[idx] = tempValue.toDouble(); } } return true; } ossimGpt ossimSpot6DimapSupportData::createGround(const ossimString& s)const { std::istringstream in(s.string()); ossimString lat, lon, height; ossimString code; in >> lat.string() >> lon.string() >> height.string() >> code.string(); return ossimGpt(lat.toDouble(), lon.toDouble(), height.toDouble(), ossimDatumFactory::instance()->create(code)); } ossimDpt ossimSpot6DimapSupportData::createDpt(const ossimString& s)const { std::istringstream in(s.string()); ossimString x, y; ossimString code; in >> x.string() >> y.string(); return ossimDpt(x.toDouble(), y.toDouble()); } ossimIpt ossimSpot6DimapSupportData::createIpt(const ossimString& s)const { std::istringstream in(s.string()); ossimString x, y; ossimString code; in >> x.string() >> y.string(); return ossimIpt(x.toInt(), y.toInt()); } bool ossimSpot6DimapSupportData::parseProductInformation( ossimRefPtr xmlDocument) { ossimString xpath; vector > xml_nodes; //--- // Fetch the Image ID: //--- xpath = "/Product_Information/Delivery_Identification/JOB_ID"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theImageID)) { return false; } //--- // Fetch the ProductionDate: //--- xpath = "/Product_Information/Delivery_Identification/PRODUCTION_DATE"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theProductionDate)) { return false; } return true; } bool ossimSpot6DimapSupportData::parseDatasetContent( ossimRefPtr xmlDocument) { ossimString xpath, nodeValue; vector > xml_nodes; //--- // Corner points: //--- xml_nodes.clear(); xpath = "/Dataset_Content/Dataset_Extent/Vertex"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() != 4) { setErrorStatus(); return false; } std::vector >::iterator node = xml_nodes.begin(); while (node != xml_nodes.end()) { ossimGpt gpt; ossimDpt ipt; std::vector > sub_nodes; xpath = "LAT"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lat = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "LON"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } gpt.lon = sub_nodes[0]->getText().toDouble(); gpt.hgt = 0.0; // assumed sub_nodes.clear(); xpath = "ROW"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.line = sub_nodes[0]->getText().toDouble() - 1.0; sub_nodes.clear(); xpath = "COL"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ipt.samp = sub_nodes[0]->getText().toDouble() - 1.0; if (ipt.line < 1.0) if (ipt.samp < 1.0) theUlCorner = gpt; else theUrCorner = gpt; else if (ipt.samp < 1.0) theLlCorner = gpt; else theLrCorner = gpt; ++node; } //--- // Center of frame. //--- theRefGroundPoint.hgt = 0.0; // TODO needs to be looked up if (!readOneXmlNode(xmlDocument, theXmlDocumentRoot + "/Dataset_Content/Dataset_Extent/Center/LON", // DIMAPv2 nodeValue)) { return false; } theRefGroundPoint.lon = nodeValue.toDouble(); if (!readOneXmlNode(xmlDocument, theXmlDocumentRoot + "/Dataset_Content/Dataset_Extent/Center/LAT", nodeValue)) // DIMAPv2 { return false; } theRefGroundPoint.lat = nodeValue.toDouble(); return true; } bool ossimSpot6DimapSupportData::parseRadiometricData( ossimRefPtr xmlDocument) { ossimString xpath; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; //--- // Fetch the gain and bias for each spectral band: //--- thePhysicalGain.assign(theNumBands, 1.000); thePhysicalBias.assign(theNumBands, 0.000); xml_nodes.clear(); xpath = "/Radiometric_Data/Radiometric_Calibration/Instrument_Calibration/Band_Measurement_List/Band_Radiance"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "BAND_ID"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ossimString bandName = sub_nodes[0]->getText(); ossim_uint32 bandIndex; if (bandName == "B0") bandIndex = 0; else if (bandName == "B1") bandIndex = 1; else if (bandName == "B2") bandIndex = 2; else if (bandName == "B3") bandIndex = 3; else if (bandName == "P") bandIndex = 0; else { ossimNotify(ossimNotifyLevel_WARN) << "ossimSpot6DimapSupportData::parseRadiometricMetadata ERROR: Band ID is incorrect\n"; } if ((bandIndex >= theNumBands ) ) { ossimNotify(ossimNotifyLevel_WARN) << "ossimSpot6DimapSupportData::parseRadiometricMetadata ERROR: Band index outside of range\n"; return false; } sub_nodes.clear(); xpath = "BIAS"; //DIMAPv2 (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePhysicalBias[bandIndex] = sub_nodes[0]->getText().toDouble(); sub_nodes.clear(); xpath = "GAIN"; //DIMAPv2 (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } thePhysicalGain[bandIndex] = sub_nodes[0]->getText().toDouble(); ++node; } // Initialize to 999 : we find this value in some DIMAPv2 file // and there is no such tag in DIMAPv1 file theSolarIrradiance.assign(theNumBands, 999.000); xml_nodes.clear(); xpath = "/Radiometric_Data/Radiometric_Calibration/Instrument_Calibration/Band_Measurement_List/Band_Solar_Irradiance"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "BAND_ID"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } ossimString bandName = sub_nodes[0]->getText(); ossim_uint32 bandIndex; if (bandName == "B0") bandIndex = 0; else if (bandName == "B1") if (theNumBands != 1) bandIndex = 1; else bandIndex = 0; else if (bandName == "B2") if (theNumBands != 1) bandIndex = 2; else bandIndex = 0; else if (bandName == "B3") if (theNumBands != 1) bandIndex = 3; else bandIndex = 0; else if (bandName == "P") bandIndex = 0; else { ossimNotify(ossimNotifyLevel_WARN) << "ossimSpot6DimapSupportData::parseRadiometricMetadata ERROR: Band ID is incorrect\n"; } if ((bandIndex >= theNumBands)) { ossimNotify(ossimNotifyLevel_WARN) << "ossimSpot6DimapSupportData::parseRadiometricMetadata ERROR: Band index outside of range 2\n"; return false; } sub_nodes.clear(); xpath = "VALUE"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); return false; } theSolarIrradiance[bandIndex] = sub_nodes[0]->getText().toDouble(); ++node; } return true; } bool ossimSpot6DimapSupportData::parseRPCMetadata( ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimSpot6DimapSupportData::parseRPCMetadata"; ossimString xpath, nodeValue; vector > xml_nodes; //--- // Fetch the Global RFM - Direct Model - Bias: //--- xpath = "/Rational_Function_Model/Resource_Reference/RESOURCE_ID"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Could not find: " << xpath << std::endl; return false; } theSpecId = nodeValue; //--- // Fetch the Global RFM - Inverse Model: //--- xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.empty()) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Could not find: " << xpath << std::endl; } return false; } for (ossim_uint32 it = 1; it < 21; it ++) { std::ostringstream valueStr; valueStr << it; xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/LINE_NUM_COEFF_"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theLineNumCoeff.push_back(xml_nodes[0]->getText().toDouble()); xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/LINE_DEN_COEFF_"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theLineDenCoeff.push_back(xml_nodes[0]->getText().toDouble()); xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/SAMP_NUM_COEFF_"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theSampNumCoeff.push_back(xml_nodes[0]->getText().toDouble()); xml_nodes.clear(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/SAMP_DEN_COEFF_"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xpath = xpath + valueStr.str(); xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theSampDenCoeff.push_back(xml_nodes[0]->getText().toDouble()); } //--- // Fetch the Global RFM - Inverse Model - Bias: //--- xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/ERR_BIAS_ROW"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theErrBiasX = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/Inverse_Model/ERR_BIAS_COL"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theErrBiasY = nodeValue.toDouble(); //--- // Fetch the Global RFM validity parameters : //--- xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LONG_SCALE"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLonScale = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LONG_OFF"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLonOffset = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LAT_SCALE"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLatScale = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LAT_OFF"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLatOffset = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/HEIGHT_SCALE"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theHeightScale = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/HEIGHT_OFF"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theHeightOffset = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/SAMP_SCALE"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theSampScale = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/SAMP_OFF"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theSampOffset = nodeValue.toInt32(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LINE_SCALE"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLineScale = nodeValue.toDouble(); xpath = "/Rational_Function_Model/Global_RFM/RFM_Validity/LINE_OFF"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theLineOffset = nodeValue.toInt32(); return true; } bool ossimSpot6DimapSupportData::parseMetadataIdentificationDIMAPv2(ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimSpot6DimapSupportData::parseMetadataIdentification"; vector > xml_nodes; ossimString xpath, nodeValue; theXmlDocumentRoot = "/DIMAP_Document"; //--- // Get the version string which can be used as a key for parsing. //--- xml_nodes.clear(); xpath = "/Metadata_Identification/METADATA_FORMAT"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { // FIXME MSD: used to support Spot6/Pleiades samples from SPOT-IMAGES website which are not coherent // with the specification (28/09/2012). Should be remove when first data will be available and sample // replaced. theXmlDocumentRoot = "/SPOT_DIMAP_Document"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nTry to use the old root: " << theXmlDocumentRoot << endl; } xml_nodes.clear(); xpath = "/Metadata_Identification/METADATA_FORMAT"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { // FIXME MSD: used to support spot6/peiades samples from SPOT-IMAGES website which are not coherent // with the specification (28/09/2012). Should be remove when first data will be available and sample // replaced. theXmlDocumentRoot = "/Dimap_Document"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nTry to use the new root: " << theXmlDocumentRoot << endl; } xml_nodes.clear(); xpath = "/Metadata_Identification/METADATA_FORMAT"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << endl; } return false; } } } ossimString attribute = "version"; ossimString value; xml_nodes[0]->getAttributeValue(value, attribute); if (value != "2.0") { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << "WARNING: DIMAP metadata version is not correct!" << std::endl; } return false; } //--- // Check that it is a valid SPOT DIMAPv2 file //--- xpath = "/Metadata_Identification/METADATA_PROFILE"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } ossimString metadataProfile; if ( (nodeValue != "S6_SENSOR") && (nodeValue != "S6_ORTHO") && (nodeValue != "S6_MOSAIC") && (nodeValue != "S7_SENSOR") && (nodeValue != "S7_ORTHO") && (nodeValue != "S7_MOSAIC") ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n Not a Spot6 DIMAPv2 file: metadata profile is incorrect!" << std::endl; } return false; } else metadataProfile = nodeValue; //--- // Get the subprofile //--- xpath = "/Metadata_Identification/METADATA_SUBPROFILE"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } if ((nodeValue == "PRODUCT")) theMetadataSubProfile = OSSIM_Spot6_METADATA_SUBPROFILE_PRODUCT; else if ( (nodeValue == "RPC") && ((metadataProfile == "S6_SENSOR") || (metadataProfile == "S7_SENSOR")) ) theMetadataSubProfile = OSSIM_Spot6_METADATA_SUBPROFILE_RPC; else { theMetadataSubProfile = OSSIM_Spot6_METADATA_SUBPROFILE_UNKNOWN; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\n Not a Spot6 DIMAPv2 file: metadata subprofile is incorrect !" << std::endl; } return false; } theDIMAPVersion = OSSIM_Spot6_DIMAPv2; return true; } bool ossimSpot6DimapSupportData::parseDatasetIdentification(ossimRefPtr xmlDocument) { return true; } bool ossimSpot6DimapSupportData::parseCoordinateReferenceSystem(ossimRefPtr xmlDocument) { return true; } bool ossimSpot6DimapSupportData::parseGeoposition(ossimRefPtr xmlDocument) { return true; } bool ossimSpot6DimapSupportData::parseProcessingInformation(ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimSpot6DimapSupportData::parseProcessingInformation"; vector > xml_nodes; ossimString xpath, nodeValue; //--- // Fetch the Processing Level: //--- xpath = "/Processing_Information/Product_Settings/PROCESSING_LEVEL"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theProcessingLevelString)) { return false; } //--- // Fetch the Spectral Processing: //--- xpath = "/Processing_Information/Product_Settings/PROCESSING_LEVEL"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theSpectralProcessingString)) { return false; } return true; } bool ossimSpot6DimapSupportData::parseRasterData(ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimSpot6DimapSupportData::parseRasterData"; vector > xml_nodes; ossimString xpath, nodeValue; //--- // Fetch if the product file is linked to one or many JP2 files: //--- xpath = "/Raster_Data/Data_Access/DATA_FILE_TILES"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theMultiDataFile.setValue(nodeValue); //--- // Fetch the MegaImageSize: //--- xpath = "/Raster_Data/Raster_Dimensions/NCOLS"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theImageSize.samp = nodeValue.toInt(); xpath = "/Raster_Data/Raster_Dimensions/NROWS"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theImageSize.line = nodeValue.toInt(); if (theMultiDataFile.getBoolean()) { //--- // Fetch the Number of MegaTiles: //--- xpath = "/Raster_Data/Raster_Dimensions/Tile_Set/NTILES"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theNumberOfMegaTiles = nodeValue.toUInt32(); //--- // Fetch the Number of MegaTiles in X and Y: //--- xml_nodes.clear(); xpath = "/Raster_Data/Raster_Dimensions/Tile_Set/Regular_Tiling/NTILES_COUNT"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: \nCould not find: " << xpath << std::endl; } return false; } ossimString value; ossimString attribute = "ntiles_x"; if (!xml_nodes[0]->getAttributeValue(value, attribute)) { attribute = "ntiles_R"; xml_nodes[0]->getAttributeValue(value, attribute); } theNumberOfMegaTilesInRow = value.toUInt32(); attribute = "ntiles_y"; if (!xml_nodes[0]->getAttributeValue(value, attribute)) { attribute = "ntiles_C"; xml_nodes[0]->getAttributeValue(value, attribute); } theNumberOfMegaTilesInCol = value.toUInt32(); if (theNumberOfMegaTilesInRow * theNumberOfMegaTilesInCol != theNumberOfMegaTiles) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: \nIncoherent number of tiles: " << xpath << std::endl; } return false; } //--- // Fetch the size of MegaTiles: //--- xml_nodes.clear(); xpath = "/Raster_Data/Raster_Dimensions/Tile_Set/Regular_Tiling/NTILES_SIZE"; xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } attribute = "nrows"; xml_nodes[0]->getAttributeValue(value, attribute); theTileSize.line = value.toUInt32(); attribute = "ncols"; xml_nodes[0]->getAttributeValue(value, attribute); theTileSize.samp = value.toUInt32(); } //--- TODO_MSD is it useful in the case of RPC model ??? // We will make the RefImagePoint the zero base center of the image. This // is used by the ossimSensorModel::worldToLineSample iterative loop as // the starting point. Since the ossimSensorModel does not know of the // sub image we make it zero base. (comments from spot) //--- theRefImagePoint.line = theImageSize.line / 2.0; theRefImagePoint.samp = theImageSize.samp / 2.0; //--- // Fetch number of bands //--- xpath = "/Raster_Data/Raster_Dimensions/NBANDS"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } theNumBands = nodeValue.toUInt32(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nNumber of bands: " << theNumBands << std::endl; } //--- // Fetch Band Display Order //--- xml_nodes.clear(); xpath = "/Raster_Data/Raster_Display/Band_Display_Order/RED_CHANNEL"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); if (theNumBands > 1) { xml_nodes.clear(); xpath = "/Raster_Data/Raster_Display/Band_Display_Order/GREEN_CHANNEL"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); xml_nodes.clear(); xpath = "/Raster_Data/Raster_Display/Band_Display_Order/BLUE_CHANNEL"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); if (theNumBands > 3) { xml_nodes.clear(); xpath = "/Raster_Data/Raster_Display/Band_Display_Order/ALPHA_CHANNEL"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() == 0) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } theBandOrder.push_back(xml_nodes[0]->getText()); } } return true; } bool ossimSpot6DimapSupportData::parseGeometricData(ossimRefPtr xmlDocument) { ossimString xpath; vector > xml_nodes; xml_nodes.clear(); xpath = "/Geometric_Data/Use_Area/Located_Geometric_Values"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; xmlDocument->findNodes(xpath, xml_nodes); if (xml_nodes.size() != 9 ) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } std::vector >::iterator node = xml_nodes.begin(); while (node != xml_nodes.end()) { std::vector > sub_nodes; //--- // Fetch the Sun Azimuth: //--- xpath = "Solar_Incidences/SUN_AZIMUTH"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSunAzimuth.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Sun Elevation: //--- sub_nodes.clear(); xpath = "Solar_Incidences/SUN_ELEVATION"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theSunElevation.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Incidence Angle: //--- sub_nodes.clear(); xpath = "Acquisition_Angles/INCIDENCE_ANGLE"; //DIMAPv2 (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theIncidenceAngle.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Viewing Angle: //--- sub_nodes.clear(); xpath = "Acquisition_Angles/VIEWING_ANGLE"; //DIMAPv2 (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theViewingAngle.push_back(sub_nodes[0]->getText().toDouble()); //--- // Fetch the Azimuth Angle: //--- sub_nodes.clear(); xpath = "Acquisition_Angles/AZIMUTH_ANGLE"; //DIMAPv2 (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nCould not find: " << xpath << std::endl; } return false; } theAzimuthAngle.push_back(sub_nodes[0]->getText().toDouble()); ++node; } return true; } bool ossimSpot6DimapSupportData::parseQualityAssessment(ossimRefPtr xmlDocument) { return true; } bool ossimSpot6DimapSupportData::parseDatasetSources(ossimRefPtr xmlDocument) { static const char MODULE[] = "ossimSpot6DimapSupportData::parseDatasetSources"; ossimString xpath, nodeValue; vector > xml_nodes; //--- // Fetch the mission index (1A ou 1B) ? // and generate theSensorID //--- xpath = "/Dataset_Sources/Source_Identification/Strip_Source/MISSION"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } if (nodeValue != "SPOT") { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nNot a SPOT mission!"<< std::endl; } return false; } //--- // Fetch the mission index (1A ou 1B) ? // and generate theSensorID //--- xpath = "/Dataset_Sources/Source_Identification/Strip_Source/MISSION_INDEX"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, nodeValue)) { return false; } if (nodeValue == "6") theSensorID = "SPOT 6"; else if (nodeValue == "7") theSensorID = "SPOT 7"; else { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG:\nNot a valid sensorID!"<< std::endl; } return false; } //--- // Fetch the Instrument: //--- xpath = "/Dataset_Sources/Source_Identification/Strip_Source/INSTRUMENT"; xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theInstrument)) { return false; } //--- // Fetch the Instrument Index: //--- xpath = "/Dataset_Sources/Source_Identification/Strip_Source/INSTRUMENT_INDEX"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, theInstrumentIndex)) { return false; } //--- // Fetch the Imaging Date: //--- ossimString firstLineImagingDate; xpath = "/Dataset_Sources/Source_Identification/Strip_Source/IMAGING_DATE"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, firstLineImagingDate)) { return false; } //--- // Fetch the Imaging Time: //--- ossimString firstLineImagingTime; xpath = "/Dataset_Sources/Source_Identification/Strip_Source/IMAGING_TIME"; //DIMAPv2 xpath = theXmlDocumentRoot + xpath; if (!readOneXmlNode(xmlDocument, xpath, firstLineImagingTime)) { return false; } theAcquisitionDate = firstLineImagingDate + "T" + firstLineImagingTime; return true; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSpot6DimapSupportData.h000066400000000000000000000275571301006202600311160ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2014 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Christophe Palmann (christophe.palmann@c-s.fr) // // Description: // // Contains declaration of class ossimSpot6DimapSupportData // //***************************************************************************** #ifndef ossimSpot6DimapSupportData_HEADER #define ossimSpot6DimapSupportData_HEADER #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include class ossimKeywordlist; class ossimXmlDocument; namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimSpot6DimapSupportData : public ossimObject, public ossimErrorStatusInterface { public: enum ossimSpot6DIMAPVersion { OSSIM_Spot6_UNKNOWN, OSSIM_Spot6_DIMAPv2 }; /** metadata subprofile type */ enum ossimSpot6MetadataSubProfile { OSSIM_Spot6_METADATA_SUBPROFILE_UNKNOWN = 0, OSSIM_Spot6_METADATA_SUBPROFILE_PRODUCT = 1, OSSIM_Spot6_METADATA_SUBPROFILE_RPC = 2 }; ossimSpot6DimapSupportData(); virtual ~ossimSpot6DimapSupportData(); void clearFields(); bool parseXmlFile(const ossimFilename& file); //--- // Convenient method to print important image info: //--- void printInfo (ostream& os) const; /** * Method to save the state of the object to a keyword list. * Return true if ok or false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix = 0)const; /** * Method to the load (recreate) the state of the object from a keyword * list. Return true if ok or false on error. */ virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix = 0); ossimString getSensorID() const; ossimString getProcessingLevel() const; ossimString getAcquisitionDate() const; ossimString getProductionDate() const; ossimString getImageID() const; ossimString getInstrument() const; ossimString getInstrumentIndex() const; ossim_uint32 getNumberOfBands() const; void getSunAzimuth(std::vector& az) const; void getSunElevation(std::vector& el) const; void getImageSize(ossimIpt& sz) const; void getIncidenceAngle(std::vector& ia) const; void getViewingAngle(std::vector& va) const; //--- // Corner points: //--- void getUlCorner(ossimGpt& pt) const; void getUrCorner(ossimGpt& pt) const; void getLrCorner(ossimGpt& pt) const; void getLlCorner(ossimGpt& pt) const; //--- // Image center point: //--- /** Center of frame, sub image if there is one. */ void getRefGroundPoint(ossimGpt& gp) const; /** zero base center point */ void getRefImagePoint(ossimDpt& rp) const; /** Zero based image rectangle, sub image if there is one. */ void getImageRect(ossimDrect& rect)const; bool allMetadataRead(){return (theProductIsOk && theRpcIsOk);}; std::vector getLineNumCoeff() const {return theLineNumCoeff;}; std::vector getLineDenCoeff() const {return theLineDenCoeff;}; std::vector getSampNumCoeff() const {return theSampNumCoeff;}; std::vector getSampDenCoeff() const {return theSampDenCoeff;}; ossim_int32 getLineOffset() const {return theLineOffset;}; ossim_int32 getSampOffset() const {return theSampOffset;}; double getLatOffset() const {return theLatOffset;}; double getLonOffset() const {return theLonOffset;}; double getHeightOffset() const {return theHeightOffset;}; double getLineScale() const {return theLineScale;}; double getSampScale() const {return theSampScale;}; double getLatScale() const {return theLatScale;}; double getLonScale() const {return theLonScale;}; double getHeightScale() const {return theHeightScale;}; private: ossimSpot6DIMAPVersion theDIMAPVersion; ossimSpot6MetadataSubProfile theMetadataSubProfile; // only for DIMAPv2 bool theProductIsOk; bool theRpcIsOk; ossimString theXmlDocumentRoot; ossimString theSensorID; ossimString theImageID; ossimString theProductionDate; ossimString theAcquisitionDate; ossimString theInstrument; ossimString theInstrumentIndex; ossimString theProcessingLevelString; ossimString theSpectralProcessingString; std::vector theSunAzimuth; std::vector theSunElevation; std::vector theIncidenceAngle; std::vector theViewingAngle; std::vector theAzimuthAngle; ossimIpt theImageSize; ossimIpt theTileSize; ossim_uint32 theNumberOfMegaTilesInRow; ossim_uint32 theNumberOfMegaTilesInCol; ossim_uint32 theNumberOfMegaTiles; ossimBooleanProperty theMultiDataFile; ossim_uint32 theNumBands; std::vector theBandOrder; /** Calibration information for radiometric corrections*/ std::vector thePhysicalBias; std::vector thePhysicalGain; std::vector theSolarIrradiance; //--- // Corner points: //--- ossimGpt theUlCorner; ossimGpt theUrCorner; ossimGpt theLrCorner; ossimGpt theLlCorner; // RPC parameters ossimString theSpecId; double theErrBias; double theErrBiasX; double theErrBiasY; double theErrRand; ossim_int32 theLineOffset; ossim_int32 theSampOffset; double theLatOffset; double theLonOffset; double theHeightOffset; double theLineScale; double theSampScale; double theLatScale; double theLonScale; double theHeightScale; std::vector theLineNumCoeff; std::vector theLineDenCoeff; std::vector theSampNumCoeff; std::vector theSampDenCoeff; //--- TODO MSD Check if it is necessary to keep that /** Center of frame on ground, if sub image it's the center of that. */ ossimGpt theRefGroundPoint; /** Zero based center of frame. */ ossimDpt theRefImagePoint; ossimGpt createGround(const ossimString& s)const; ossimDpt createDpt(const ossimString& s)const; ossimIpt createIpt(const ossimString& s)const; //--- bool parseRPCMetadata(ossimRefPtr xmlDocument); bool parseMetadataIdentificationDIMAPv2(ossimRefPtr xmlDocument); /** * Dataset Identification: * * From xml section: * /Dimap_Document/Dataset_Identification/ * * NOT YET USED * * @return true. */ bool parseDatasetIdentification(ossimRefPtr xmlDocument); /** * Dataset Content: * * From xml section: * /Dimap_Document/Dataset_Content/ * * Initializes: * theRefGroundPoint * theUlCorner * theUrCorner * theLrCorner * theLlCorner * * Note that the theRefGroundPoint will be the zero based center of * the whole mega image. * Note that the corners will be the corners of the whole mega image. * @return true on success, false if not found. */ bool parseDatasetContent(ossimRefPtr xmlDocument); /** * Product Information: * * From xml section: * /Dimap_Document/Product_Information/ * * Initializes: * theImageID * theProductionDate * * @return true on success, false if not found. */ bool parseProductInformation(ossimRefPtr xmlDocument); /** * Coordinate Reference System: * * From xml section: * /Dimap_Document/Coordinate_Reference_System/ * * NOT YET USED * * @return true. */ bool parseCoordinateReferenceSystem(ossimRefPtr xmlDocument); /** * Geoposition: * * From xml section: * /Dimap_Document/Geoposition/ * * NOT YET USED * * @return true. */ bool parseGeoposition(ossimRefPtr xmlDocument); /** * Processing Information: * * From xml section: * /Dimap_Document/Processing_Information/ * * Initializes: * theProcessingLevel * theSpectralProcessing * * @return true on success, false if not found. */ bool parseProcessingInformation(ossimRefPtr xmlDocument); bool parseRasterData(ossimRefPtr xmlDocument); bool parseRadiometricData(ossimRefPtr xmlDocument); bool parseGeometricData(ossimRefPtr xmlDocument); /** * QualityAssessment: * * From xml section: * /Dimap_Document/Quality_Assessment/ * * NOT YET USED * * @return true. */ bool parseQualityAssessment(ossimRefPtr xmlDocument); bool parseDatasetSources(ossimRefPtr xmlDocument); }; } #endif /* #ifndef ossimSpot6DimapSupportData_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSpot6Model.cpp000066400000000000000000000316461301006202600272620ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2014 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Christophe Palmann (christophe.palmann@c-s.fr) // // Description: // // Contains definition of class ossimSpot6Model // //***************************************************************************** #include "ossimSpot6Model.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { // Define Trace flags for use within this file: static ossimTrace traceExec ("ossimSpot6Model:exec"); static ossimTrace traceDebug ("ossimSpot6Model:debug"); RTTI_DEF1(ossimSpot6Model, "ossimSpot6Model", ossimRpcModel); //************************************************************************************************* // Constructor //************************************************************************************************* ossimSpot6Model::ossimSpot6Model() :ossimRpcModel (), theSupportData (0) { for (unsigned int i = 0; i < 20; i++) { theLineDenCoef[i] = 0.0; theLineNumCoef[i] = 0.0; theSampNumCoef[i] = 0.0; theSampDenCoef[i] = 0.0; } } //************************************************************************************************* // Constructor //************************************************************************************************* ossimSpot6Model::ossimSpot6Model(const ossimSpot6Model& rhs) :ossimRpcModel (rhs), theSupportData (0) { } //************************************************************************************************* // Destructor //************************************************************************************************* ossimSpot6Model::~ossimSpot6Model() { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG DESTRUCTOR: ~ossimSpot6Model(): entering..." << std::endl; theSupportData = 0; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG DESTRUCTOR: ~ossimSpot6Model(): returning..." << std::endl; } //************************************************************************************************* // Infamous DUP //************************************************************************************************* ossimObject* ossimSpot6Model::dup() const { return new ossimSpot6Model(*this); } //************************************************************************************************* // Print //************************************************************************************************* std::ostream& ossimSpot6Model::print(std::ostream& out) const { // Capture stream flags since we are going to mess with them. std::ios_base::fmtflags f = out.flags(); out << "\nDump of ossimSpot6Model at address " << (hex) << this << (dec) << "\n------------------------------------------------" << "\n theImageID = " << theImageID << "\n theImageSize = " << theImageSize << "\n theRefGndPt = " << theRefGndPt << "\n theRefImgPt = " << theRefImgPt << "\n theProcessingLevel = " << theSupportData->getProcessingLevel() << "\n------------------------------------------------" << "\n " << endl; // Set the flags back. out.flags(f); if (theSupportData->getProcessingLevel() == "SENSOR") return ossimRpcModel::print(out); else return out; } //************************************************************************************************* // Save State //************************************************************************************************* bool ossimSpot6Model::saveState(ossimKeywordlist& kwl, const char* prefix) const { if(theSupportData.valid()) { ossimString supportPrefix = ossimString(prefix) + "support_data."; theSupportData->saveState(kwl, supportPrefix); } // If only it is a sensor product we save parameters from RPC model, its avoid to // propagate a empty RPC model if (theSupportData->getProcessingLevel() == "SENSOR") { ossimRpcModel::saveState(kwl, prefix); return true; } else { kwl.add(prefix, "sensor", theSensorID, true); return true; } } //************************************************************************************************* // Load State //************************************************************************************************* bool ossimSpot6Model::loadState(const ossimKeywordlist& kwl, const char* prefix) { if(!theSupportData) { theSupportData = new ossimSpot6DimapSupportData; } ossimString supportPrefix = ossimString(prefix) + "support_data."; theSupportData->loadState(kwl, supportPrefix); // If only it is a sensor product we load parameters from RPC model only, its avoid to // add a empty RPC model if (theSupportData->getProcessingLevel() == "SENSOR") { ossimRpcModel::loadState(kwl, prefix); return true; } else { return true; } } bool ossimSpot6Model::open(const ossimFilename& file) { static const char MODULE[] = "ossimSpot6Model::open"; //traceDebug.setTraceFlag(true); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } // Make the gsd nan so it gets computed. theGSD.makeNan(); bool result = false; // Filename used. ossimFilename DIMxmlFile; ossimFilename RPCxmlFile; // Generate metadata and rpc filename if ( (file.ext().downcase() != "jp2" && file.ext().downcase() != "tif") || !file.exists()) { //not a valid file return false; } else { // DIMAPv2 DIMxmlFile = file.path(); RPCxmlFile = file.path(); ossimFilename DIMxmlFileTmp = file.file(); ossimFilename RPCxmlFileTmp; DIMxmlFileTmp = DIMxmlFileTmp.file().replaceStrThatMatch("^IMG_", "DIM_"); DIMxmlFileTmp = DIMxmlFileTmp.replaceStrThatMatch("_R[0-9]+C[0-9]+\\.(JP2|TIF)$", ".XML"); // Check if it is an XML extension if( DIMxmlFileTmp.ext() != "XML") return false; RPCxmlFileTmp = DIMxmlFileTmp.file().replaceStrThatMatch("^DIM_", "RPC_"); DIMxmlFile = DIMxmlFile.dirCat(DIMxmlFileTmp); RPCxmlFile = RPCxmlFile.dirCat(RPCxmlFileTmp); if (!DIMxmlFile.exists()) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "SPOT main DIMAP file " << DIMxmlFile << " doesn't exist ...\n"; } return false; } } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "Metadata xml file: " << DIMxmlFile << "\n"; ossimNotify(ossimNotifyLevel_DEBUG) << "RPC xml file: " << RPCxmlFile << "\n"; } ossimString processingLevel; // Parse the metadata xml file if ( !theSupportData.valid() ) theSupportData = new ossimSpot6DimapSupportData(); if(!theSupportData->parseXmlFile(DIMxmlFile)) { theSupportData = 0; // ossimRefPtr if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimSpot6Model::open DEBUG:" << "\nCould not open correctly DIMAP file" << std::endl; } return false; } theSensorID = theSupportData->getSensorID(); theImageID = theSupportData->getImageID(); // Get the processing level (ORTHO or SENSOR or perhaps MOSAIC ?) processingLevel = theSupportData->getProcessingLevel(); // Parse the RPC xml file if necessary if (RPCxmlFile.exists() && processingLevel == "SENSOR") { if (!theSupportData->parseXmlFile(RPCxmlFile)) { theSupportData = 0; // ossimRefPtr ossimNotify(ossimNotifyLevel_WARN) << "ossimSpot6Model::open WARNING:" << "\nCould not open correctly RPC file" << std::endl; return false; } thePolyType = B; for (unsigned int i = 0 ; i < 20; i++ ) { theLineNumCoef[i] = theSupportData->getLineNumCoeff()[i]; theLineDenCoef[i] = theSupportData->getLineDenCoeff()[i]; theSampNumCoef[i] = theSupportData->getSampNumCoeff()[i]; theSampDenCoef[i] = theSupportData->getSampDenCoeff()[i]; } theLineScale = theSupportData->getLineScale(); theSampScale = theSupportData->getSampScale(); theLatScale = theSupportData->getLatScale(); theLonScale = theSupportData->getLonScale(); theHgtScale = theSupportData->getHeightScale(); theLineOffset = theSupportData->getLineOffset(); theSampOffset = theSupportData->getSampOffset(); theLatOffset = theSupportData->getLatOffset(); theLonOffset = theSupportData->getLonOffset(); theHgtOffset = theSupportData->getHeightOffset(); } // TODO MSD Check if this part is necessary _productXmlFile = DIMxmlFile; ossimSupportFilesList::instance()->add(_productXmlFile); // TODO MSD WARNING File with multi tiles are not well managed theSupportData->getImageRect(theImageClipRect); theSupportData->getImageSize(theImageSize); finishConstruction(); clearErrorStatus(); result = true; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result ? "true" : "false\n") << std::endl; } /*std::cout << "---------------------------" << std::endl; print(std::cout); std::cout << "---------------------------" << std::endl;*/ return result; } //************************************************************************************************* //! Collects common code among all parsers //************************************************************************************************* void ossimSpot6Model::finishConstruction() { theImageSize.line = theImageClipRect.height(); theImageSize.samp = theImageClipRect.width(); theRefImgPt.line = theImageClipRect.midPoint().y; theRefImgPt.samp = theImageClipRect.midPoint().x; theRefGndPt.lat = theLatOffset; theRefGndPt.lon = theLonOffset; theRefGndPt.hgt = theHgtOffset; //--- // NOTE: We must call "updateModel()" to set parameter used by base // ossimRpcModel prior to calling lineSampleHeightToWorld or all // the world points will be same. //--- updateModel(); ossimGpt v0, v1, v2, v3; lineSampleHeightToWorld(theImageClipRect.ul(), theHgtOffset, v0); lineSampleHeightToWorld(theImageClipRect.ur(), theHgtOffset, v1); lineSampleHeightToWorld(theImageClipRect.lr(), theHgtOffset, v2); lineSampleHeightToWorld(theImageClipRect.ll(), theHgtOffset, v3); theBoundGndPolygon = ossimPolygon (ossimDpt(v0), ossimDpt(v1), ossimDpt(v2), ossimDpt(v3)); // Set the ground reference point using the model. lineSampleHeightToWorld(theRefImgPt, theHgtOffset, theRefGndPt); if( theGSD.hasNans() ) { try { // This will set theGSD and theMeanGSD. Method throws ossimException. computeGsd(); } catch (const ossimException& e) { ossimNotify(ossimNotifyLevel_WARN) << "ossimSpot6Model::finishConstruction -- caught exception:\n" << e.what() << std::endl; } } } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimSpot6Model.h000066400000000000000000000063611301006202600267230ustar00rootroot00000000000000//******************************************************************* // Copyright (C) 2014 Centre National Etudes Spatiales // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // Author : Christophe Palmann (christophe.palmann@c-s.fr) // // Description: // // Contains declaration of class ossimSpot6Model. // //***************************************************************************** // FIXME $Id: ossimSpot5Model.h 15766 2009-10-20 12:37:09Z gpotts $ #ifndef ossimSpot6Model_HEADER #define ossimSpot6Model_HEADER #include #include #include "ossimSpot6DimapSupportData.h" #include #include namespace ossimplugins { class ossimSpot6DimapSupportData; class OSSIM_PLUGINS_DLL ossimSpot6Model : public ossimRpcModel { public: /*! * CONSTRUCTORS: */ /** @brief default constructor */ ossimSpot6Model(); /** @brief copy constructor */ ossimSpot6Model(const ossimSpot6Model& rhs); /** @brief Destructor */ virtual ~ossimSpot6Model(); bool open(const ossimFilename& file); /*! * Returns pointer to a new instance, copy of this. * Not implemented yet! Returns NULL... */ virtual ossimObject* dup() const; /*! * Extends base-class implementation. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; /*! * Fulfills ossimObject base-class pure virtuals. Loads and saves geometry * KWL files. Returns true if successful. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=NULL) const; virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=NULL); void setSupportData(ossimSpot6DimapSupportData* supportData) { theSupportData = supportData; } ossimSpot6DimapSupportData* getSupportData() { return theSupportData.get(); } const ossimSpot6DimapSupportData* getSupportData()const { return theSupportData.get(); } protected: bool parseMetaData(const ossimFilename& file); bool parseRpcData (const ossimFilename& file); // In the future //bool parseJP2File (const ossimFilename& file); void finishConstruction(); ossimRefPtr theSupportData; ossimFilename _productXmlFile; TYPE_DATA }; } #endif /* #ifndef ossimSpot6Model_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimStringUtilities.cpp000066400000000000000000000023201301006202600304130ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "ossimStringUtilities.h" #include "ossimplugins-config.h" #if defined(HAVE_STD_SNPRINTF) # include #elif defined(HAVE_MSC_SNPRINTF) # include #else # error "Don't know how to perform snprintf" #endif int ossimplugins::vs_printf(char * str, std::size_t size, const char * format, std::va_list ap) { #if defined(HAVE_STD_SNPRINTF) const int res = std::vsnprintf(str, size, format, ap); return res; #elif defined(HAVE_MSC_SNPRINTF) const int res = _vsnprintf(str, size, format, ap); // force 0x0 on the last possible character at worst str[size-1] = '\0'; return res; #else # error "Don't know how to perform snprintf" #endif } int ossimplugins::s_printf(char *str, std::size_t size, const char *format, ...) { std::va_list ap; va_start(ap, format); const int res = ossimplugins::vs_printf(str, size, format, ap); va_end(ap); return res; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimStringUtilities.h000066400000000000000000000704061301006202600300720ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimStringUtilities_h #define ossimStringUtilities_h #include "ossimPluginConstants.h" #include #include #include #include #include // #include #include #include #include #include #include #include #include #ifdef nan #undef nan #endif #include // nan namespace ossimplugins { /**\name String view + functions */ //@{ /** String view class. * Class inspired by C++17 `std::string_view` and `gsl::string_span`. * * This idea is to bring efficiency and correctness to C++ functions that take * strings. A function that receives a `string_view` can receive any kind of * string flavour and guarantee 0-copy. * * The only side effect to be aware of: no terminal-0 is to be expected. i.e. a * `string_view` data cannot be passed freely to a function with a C API that * expect a null-terminated string. * * @invariant there is no guarantee `data()[size()] == '\0'`. It may happen * though depending on the constructor used. */ struct string_view { typedef char const value_type; typedef char const& reference; typedef char const& const_reference; typedef char const* const_pointer; typedef char const* pointer; typedef std::size_t size_type; private: /** Strict view iterator.*/ struct char_iterator { typedef char const value_type; typedef char const& reference; typedef char const* pointer; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; explicit char_iterator(const_pointer p) : m_ptr(p) {} char_iterator & operator++() { ++m_ptr; return *this; } char_iterator operator++(int) { char_iterator tmp(*this); ++m_ptr; return tmp; } char_iterator & operator--() { --m_ptr; return *this; } char_iterator operator--(int) { char_iterator tmp(*this); --m_ptr; return tmp; } const_reference operator*() const { return *m_ptr; } char_iterator & operator+=(difference_type off) { m_ptr += off; return *this; } char_iterator & operator-=(difference_type off) { m_ptr -= off; return *this; } friend char_iterator operator+(char_iterator lhs, difference_type off) { return lhs += off; } friend char_iterator operator+(difference_type off, char_iterator rhs) { return rhs += off; } friend char_iterator operator-(char_iterator lhs, difference_type off) { return lhs -= off; } friend char_iterator operator-(difference_type off, char_iterator rhs) { return rhs -= off; } friend difference_type operator-(char_iterator lhs, char_iterator rhs) { return lhs.m_ptr - rhs.m_ptr; } friend bool operator==(char_iterator lhs, char_iterator rhs) { return lhs.m_ptr == rhs.m_ptr; } friend bool operator!=(char_iterator lhs, char_iterator rhs) { return lhs.m_ptr != rhs.m_ptr; } friend bool operator<(char_iterator lhs, char_iterator rhs) { return lhs.m_ptr < rhs.m_ptr; } private: friend bool operator<=(char_iterator lhs, char_iterator rhs) { return lhs.m_ptr <= rhs.m_ptr; } private: const_pointer m_ptr; }; public: // typedef char_iterator iterator; typedef char_iterator const_iterator; // typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; /** Constructor from a standard string. *@post `data()[size()] == '\0'` */ string_view(std::string const& s) : m_size(s.size()), m_first(s.c_str()) {} /** Constructor from an ossim string. *@post `data()[size()] == '\0'` */ string_view(ossimString const& s) : m_size(s.size()), m_first(s.c_str()) {} /** Constructor from an array of characters. * @post `data()[size()] == '\0'` <= the array is built with this kind of * syntax: `char const a[]="foobar";` */ template string_view(char const (&array)[N]) : m_size(N), m_first(&array[0]) {} /** Constructor from a pointer to a 0-terminated raw string. * @post `data()[size()] == '\0'` */ string_view(char const* ptr) : m_size(std::strlen(ptr)), m_first(ptr) {} #if 0 string_view(char const* first, char const* last) : m_size(last-first), m_first(first) { assert(first <= last); } #endif /** Constructor from an input iterator and a size. * @post there is no guarantee `data()[size()] == '\0'`. */ template string_view(II first, size_type size_) : m_size(size_), m_first(first) {} /** Constructor from a pair of input iterators. * @post there is no guarantee `data()[size()] == '\0'`. */ template string_view(II first, II last) : m_size(last-first), m_first(first) { assert(first <= last); } /** Builds a peculiar empty view to points to nullptr. */ static string_view null() { return string_view(build_empty());} /** Tells whether a view is within another view. * This functions doesn't test whether the characters from a view are found * in the same relative positions in another view. */ bool belongs_to(char const* first, char const* last) const { return first <= &*begin() && &*end() <= last; } template bool belongs_to(char const (&array)[N]) const { // N-1 because of terminal 0 return belongs_to(&array[0], &array[N-1]); } bool belongs_to(char const* ptr) const { return belongs_to(&ptr[0], &ptr[std::strlen(ptr)]); } template bool belongs_to(String const& s) const{ return belongs_to(s.data(), s.data() + s.size()); } size_type size () const { return m_size; } bool empty () const { return m_size == 0; } // iterator begin () { return iterator(m_first); } // iterator end () { return iterator(m_first+m_size); } const_iterator begin () const { return m_first; } const_iterator end () const { return m_first+m_size; } const_iterator cbegin () const { return m_first; } const_iterator cend () const { return m_first+m_size; } // reverse_iterator rbegin () { return reverse_iterator(m_first+m_size); } // reverse_iterator rend () { return reverse_iterator(m_first); } const_reverse_iterator rbegin () const { return const_reverse_iterator(m_first+m_size); } const_reverse_iterator rend () const { return const_reverse_iterator(m_first); } const_reverse_iterator crbegin() const { return const_reverse_iterator(m_first+m_size); } const_reverse_iterator crend () const { return const_reverse_iterator(m_first); } /** Indexed access. * @pre `p < size(),` checked with an assertion. */ const_reference operator[](size_type p) { assert(p < size()); return *(m_first+p); } /** Returns first character of the view. * @pre `!empty()`, checked with an assertion. */ const_reference front() const { assert(!empty()); return *begin(); } /** Returns last character of the view. * @pre `!empty()`, checked with an assertion. */ const_reference back () const { assert(!empty()); return *(end()-1); } /** Returns a pointer to the first character of the view. * @warning there is no guarantee `data()[size()] == '\0'` */ const_pointer data () const { return &*m_first; } /** Removes the n first characters. * @pre `n <= size()`, checked with an assertion * @post size is n characters more little * @post `begin()` iterator is n characters right. */ void remove_prefix(std::size_t n) { assert(n <= m_size); m_first += n; m_size -= n; } /** Removes the n last characters. * @pre `n <= size()`, checked with an assertion * @post size is n characters more little * @post `end()` iterator is n characters left. */ void remove_suffix(std::size_t n) { assert(n <= m_size); m_size -= n; } private: struct build_empty{}; string_view(build_empty) : m_size(0), m_first(NULL) {} std::size_t m_size; const_iterator m_first; }; inline bool operator==(string_view const& lhs, string_view const& rhs) { return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); } inline bool operator!=(string_view const& lhs, string_view const& rhs) { return ! (lhs == rhs); } inline std::ostream & operator<<(std::ostream & os, const string_view & v) { std::copy(v.begin(), v.end(), std::ostream_iterator(os)); return os ; } inline std::string operator+(string_view const& lhs, string_view const& rhs) { std::string res(lhs.begin(), lhs.end()); res.append(rhs.begin(), rhs.end()); return res; } /** Tells whether two views are exactly identical. */ inline bool is_same_view(string_view const& lhs, string_view const& rhs) { return lhs.begin() == rhs.begin() && lhs.size() == rhs.size(); } /** Tells whether the haystack string starts with the needle string. */ inline bool starts_with(string_view const& haystack, string_view const& needle) { return needle.size() <= haystack.size() && std::equal(needle.begin(), needle.end(), haystack.begin()); } /** Tells whether the haystack string starts with the needle string. */ inline bool ends_with(string_view const& haystack, string_view const& needle) { return needle.size() <= haystack.size() && std::equal(needle.rbegin(), needle.rend(), haystack.rbegin()); } /** Searches needle string within the haystack string. */ inline string_view find(string_view const& haystack, string_view const& needle) { assert(!haystack.empty()); assert(!needle.empty()); const string_view::size_type size = needle.size(); if (haystack.size() < size) { // std::cout << "haystack size < needle size!!!"; return string_view::null(); } string_view::const_iterator const end = haystack.end() - size +1; // std::cout << "comp up to:" // << static_cast(&*end) << "(" << (*end) << ")" // ; string_view::const_iterator it = haystack.begin(); for ( ; it != end ; ++it) { string_view v(it, size); assert(v.size() == size); assert(v.belongs_to(haystack)); // std::cout << " check " // << static_cast(v.data())<<"["<(needle.data())<<"["< struct part_iterator { typedef string_view & reference; typedef string_view const& const_reference; typedef string_view const* const_pointer; typedef std::forward_iterator_tag iterator_category; // build last part_iterator(string_view const& global_string, Splitter s) : m_global(global_string) , m_splitter(s) , m_crt(m_splitter(global_string)) {} struct theend {}; part_iterator(string_view const& global_string, Splitter s, theend) : m_global(global_string) , m_splitter(s) , m_crt(string_view::null()) {} part_iterator & operator++() { assert(m_crt.belongs_to(m_global) && "Invariant check failure"); assert(! is_same_view(m_crt, string_view::null()) && "Don't iterate past end"); if (m_crt.end() == m_global.end()) { m_crt = string_view::null(); } else { string_view within(m_crt.end()+m_splitter.next_start(), m_global.end()); m_crt = m_splitter(within); } return *this; } part_iterator operator++(int) { part_iterator tmp(*this); ++(*this); return *this; } const_reference operator*() const { return m_crt; } const_pointer operator->() const { return &m_crt; } friend bool operator==(part_iterator const& lhs, part_iterator const& rhs) { // std::cout << "<<"<> ==?== <<"<>" << std::endl; assert(is_same_view(lhs.m_global, rhs.m_global)); return is_same_view(lhs.m_crt, rhs.m_crt); // TODO: too many tests } friend bool operator!=(part_iterator const& lhs, part_iterator const& rhs) { return ! (lhs == rhs); } #if defined(BOOST_TEST_MODULE) friend std::ostream & operator<<(std::ostream & os, const part_iterator & v) { return os << "split iterator on `" << v.m_crt << "'("<(&*v.m_crt.begin()) <<"-"< inline std::size_t len(char const (&)[N]) { assert(N>0); return N-1; } inline std::size_t len(char const* ptr) { return std::strlen(ptr); } template inline std::size_t len(String const& s) { return s.length(); } } // details namespace /** Split parts range. * Not meant to be used directly. * @tparam Splitter split algorithm used. * @see `part_iterator` * @see `split_on()` */ template struct part_range { part_range(string_view const& global_string, Splitter s) : m_first(global_string, s) , m_last(global_string, s, typename const_iterator::theend()) {} typedef part_iterator const_iterator; const_iterator const& begin() const { return m_first; } const_iterator const& end () const { return m_last; } private: const_iterator const m_first; const_iterator const m_last; }; /** Split algorithm that splits on single characters. * Not meant to be used directly * @see `split_on()` */ struct splitter_on_delim { splitter_on_delim(char delim) : m_delimiter(delim) {} string_view operator()(string_view const& within) const { string_view res(within.begin(), std::find(within.begin(), within.end(), m_delimiter) ); return res ; } std::size_t next_start() const { return details::len(m_delimiter); } private: char m_delimiter; }; /** Split entry point. * @tparam String Type of the string split (`ossimString`, `std::string`, * `string_view`, ...) * @param[in] str string to be split * @param[in] delim character delimiter used to split. * @return a range of the parts found in `str`. * * Example of use: * \code typedef part_range range_type; typedef typename range_type::const_iterator const_iterator; const range_type parts = split_on(",abc,z,,,def,xy,,", ',') const_iterator it = parts.begin(); const_iterator end = parts.end(); for ( ; it != end ; ++it) { doStuff(*it); } * \endcode */ template part_range split_on(String const& str, char delim) { return part_range(str, splitter_on_delim(delim)); } //@} /**\name string to number conversion */ //@{ /** * \brief Generic string to whatever conversion -- failure means exception. * Tries to decode a value from a string. * \tparam T Type of the value decoded from the input string * \param[in] v input string to convert * \param[in] context context message for the exception thrown * * \return The value decoded * \throw std::runtime_error if a value of type `T` cannot be decoded from the * string. * \note For efficiency reasons, the function has been specialized for integral * floating point, and string types. * \note That alternative to `ossimString::toXxxx()` function has been defined * to support generic programming in `get()` and `add()` helper functions for * keyword list. * \see `to_with_default()` for the version that never fails, but returns a * default value otherwise (being `T()` by default). * */ template inline T to(string_view const& v, string_view const& context) { T res ; std::stringstream ss; if (ss << v && (ss >> res >> std::ws).eof()) { return res; } throw std::runtime_error("Cannot decode "+v+" as "+ typeid(T).name() + " while " + context); } /** * \brief Generic string to whatever conversion -- failure is hidden. * Tries to decode a value from a string. * \tparam T Type of the value decoded from the input string * \param[in] v input string to convert * \param[in] def default value returned in the conversion isn't possible * * \return The value decoded * \return `def` if no value of type `T` can be decoded from `v`. * \throw None * \note For efficiency reasons, the function has been specialized for integral * floating point, and string types. * \note That alternative to `ossimString::toXxxx()` function has been defined * to support generic programming in `get()` and `add()` helper functions for * keyword list. * \see `to()` for the version that fails by throwing exceptions. */ template inline T to_with_default(string_view const& v, T const& def = T()) { T res = def; std::stringstream ss; if (ss << v && (ss >> res >> std::ws).eof()) { return res; } return def; } namespace details { /** * \brief Internal generic string to integer conversion (w/ exception). * Tries to convert the input string into a integer type. If the * string doesn't represent an integer value, an exception is thrown. * \tparam Int Integral type (In a perfect world, we'd used `enable_if` & * co to restrict the code to integral types) * \param[in] v input string * \param[in] context context message for the exception thrown * * \return The string as an integer. * \throw std::runtime_error is the number cannot be converted. * \todo Use a failure_policy in order to factorize code flavour (returns * default value or throw an exception) */ template inline Int to_integer(string_view const& v, string_view const& context) { // string_view::data() isn't compatible with strtol => we emulate it // TODO: handle HEX, OCT, BIN, locales? string_view::const_iterator it = v.begin(); string_view::const_iterator end = v.end(); bool is_negative = false; Int res = 0; if (it != end) { switch (*it) { case '-': is_negative = true; /*[[fallthrough]]*/ case '+': ++it; } for ( ; it != end ; ++it) { // only support arabic digits if (!std::isdigit(*it)) { throw std::runtime_error("Cannot decode "+v+" as integer while " + context); } res = 10 * res + *it - '0'; } } return is_negative ? -res : res; } /** * \brief Internal generic string to integer conversion (w/o exception). * Tries to convert the input string into a integer type. If the * string doesn't represent an integer value, the default value will be * returned. * \tparam Int Integral type (In a perfect world, we'd used `enable_if` & * co to restrict the code to integral types) * \param[in] v input string * \param[in] def default value returned in the conversion isn't possible * * \return The string as an integer. * \return `def` if the string cannot be converted to an integer value. * \throw None */ template inline Int to_integer(string_view const& v, Int const def) { // string_view::data() isn't compatible with strtol => we emulate it // TODO: handle HEX, OCT, BIN, locales? string_view::const_iterator it = v.begin(); string_view::const_iterator end = v.end(); bool is_negative = false; Int res = 0; if (it != end) { switch (*it) { case '-': is_negative = true; /*[[fallthrough]]*/ case '+': ++it; } for ( ; it != end ; ++it) { // only support arabic digits if (!std::isdigit(*it)) { return def; } res = 10 * res + *it - '0'; } } return is_negative ? -res : res; } /** * \brief Internal generic string to unsigned integer conversion (w/ exception). * Tries to convert the input string into a integer type. If the * string doesn't represent an integer value, an exception is thrown. * \tparam Int Integral type (In a perfect world, we'd used `enable_if` & * co to restrict the code to integral types) * \param[in] v input string * \param[in] context context message for the exception thrown * * \return The string as an integer. * \throw std::runtime_error is the number cannot be converted. */ template inline Int to_uinteger(string_view const& v, string_view const& context) { // string_view::data() isn't compatible with strtol => we emulate it // TODO: handle HEX, OCT, BIN, locales? string_view::const_iterator it = v.begin(); string_view::const_iterator end = v.end(); Int res = 0; if (it != end) { for ( ; it != end ; ++it) { // only support arabic digits if (!std::isdigit(*it)) { throw std::runtime_error("Cannot decode "+v+" as integer while " + context); } res = 10 * res + *it - '0'; } } return res; } /** * \brief Internal generic string to unsigned integer conversion (w/o exception). * Tries to convert the input string into a integer type. If the * string doesn't represent an integer value, the default value will be * returned. * \tparam Int Integral type (In a perfect world, we'd used `enable_if` & * co to restrict the code to integral types) * \param[in] v input string * \param[in] def default value returned in the conversion isn't possible * * \return The string as an integer. * \return `def` if the string cannot be converted to an integer value. * \throw None */ template inline Int to_uinteger(string_view const& v, Int const def) { // string_view::data() isn't compatible with strtol => we emulate it // TODO: handle HEX, OCT, BIN, locales? string_view::const_iterator it = v.begin(); string_view::const_iterator end = v.end(); Int res = 0; if (it != end) { for ( ; it != end ; ++it) { // only support arabic digits if (!std::isdigit(*it)) { return def; } res = 10 * res + *it - '0'; } } return res; } /** * \brief Internal generic string to float conversion (w/ exception). * Tries to convert the input string into a floating point type. If the * string doesn't represent a floating point value, an exception is thrown. * \tparam FloatType floating point type (`float`, `double`, `long double`) * \param[in] v input string * \param[in] context context message for the exception thrown * * \return The string as a float. The special `"nan"` string is converted to * `ossim::nan()`. * \throw std::runtime_error is the number cannot be converted. */ template inline FloatType to_float(string_view const& v, string_view const& context) { if (contains(v, "nan")) { return ::ossim::nan(); } FloatType res = FloatType(); // 0-construction if (!v.empty()) { std::stringstream ss; if (! (ss << v && (ss >> res >> std::ws).eof())) { throw std::runtime_error("Cannot decode "+v+" as float value while " + context); } } return res; } /** * \brief Internal generic string to float conversion (w/o exception). * Tries to convert the input string into a floating point type. If the * string doesn't represent a floating point value, the default value will * be returned. * \tparam FloatType floating point type (`float`, `double`, `long double`) * \param[in] v input string * \param[in] def default value returned in the conversion isn't possible * * \return The string as a float. The special `"nan"` string is converted * to `ossim::nan()`. * \return `def` if the string cannot be converted to a floating point * value. * \throw None */ template inline FloatType to_float(string_view const& v, FloatType const def) { if (contains(v, "nan")) { return ::ossim::nan(); } FloatType res = FloatType(); // 0-construction if (!v.empty()) { std::stringstream ss; if (! (ss << v && (ss >> res >> std::ws).eof())) { return def; } } return res; } inline unsigned int decode_uint(string_view & v) { unsigned int res = 0; for ( ; !v.empty() ; v.remove_prefix(1)) { // only support arabic digits if (!std::isdigit(v.front())) break; res = 10 * res + v.front() - '0'; } return res; } } // ossimplugins::details namespace #define OSSIM_GENERATE_CONV(internal_to, type) \ template <> inline type to(string_view const& v, string_view const& context) \ { return details::internal_to(v, context); } \ template <> inline type to_with_default(string_view const& v, type const& def) \ { return details::internal_to(v, def); } // Note: specialization doesn't support default arguments, but default argument // T() will still work. OSSIM_GENERATE_CONV(to_integer, char); OSSIM_GENERATE_CONV(to_uinteger, unsigned char); OSSIM_GENERATE_CONV(to_integer, signed char); OSSIM_GENERATE_CONV(to_uinteger, unsigned short); OSSIM_GENERATE_CONV(to_integer, short); OSSIM_GENERATE_CONV(to_integer, int); OSSIM_GENERATE_CONV(to_uinteger, unsigned int); OSSIM_GENERATE_CONV(to_integer, long); OSSIM_GENERATE_CONV(to_uinteger, unsigned long); #if defined(HAS_LONG_LONG) // TODO: add this configure option OSSIM_GENERATE_CONV(to_integer, long long); OSSIM_GENERATE_CONV(to_uinteger, unsigned long long); #endif OSSIM_GENERATE_CONV(to_float, float); OSSIM_GENERATE_CONV(to_float, double); OSSIM_GENERATE_CONV(to_float, long double); #undef OSSIM_GENERATE_CONV template <> inline std::string to(string_view const& v, string_view const& /*context*/) { return std::string(v.begin(), v.end()); } template inline T const& to(T const& v, string_view const& /*context*/) { return v; } template inline T const& to_with_default(T const& v, T const& /* default*/) { return v; } // template <> inline double to(ossimplugins::string_view const& v) // { return details::to_float(v); } //@} OSSIM_PLUGINS_DLL int s_printf(char *str, std::size_t size, const char *format, ...); OSSIM_PLUGINS_DLL int vs_printf(char *str, std::size_t size, const char *format, std::va_list ap); template inline int s_printf(char (&str)[size], const char *format, ...) { std::va_list ap; va_start(ap, format); const int res = vs_printf(str, size, format, ap); va_end(ap); return res; } } // ossimplugins namespace #endif // ossimStringUtilities_h OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarModel.cpp000066400000000000000000002056121301006202600277660ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Keyword constants: static const char NUMBER_SRGR_COEFFICIENTS_KW[] = "sr_gr_coeffs_count"; static const char LOAD_FROM_PRODUCT_FILE_KW[] = "load_from_product_file_flag"; static const char PRODUCT_XML_FILE_KW[] = "product_xml_filename"; static const char SR_GR_R0_KW[] = "sr_gr_r0"; static const char SC_RT_KW[] = "sc_rt"; static const char SR_GR_SF_KW[] = "sc_gr_sf"; static const char ALT_SR_GR_COEFFICIENT0_KW[] = "alt_sr_gr_coeff0"; static const char ALT_SR_GR_COEFFICIENT1_KW[] = "alt_sr_gr_coeff1"; static const char ALT_SR_GR_COEFFICIENT2_KW[] = "alt_sr_gr_coeff2"; static const char PRODUCT_TYPE[] = "product_type"; static const char RADIOMETRIC_CORRECTION[] = "radiometricCorrection"; static const char AZ_START_TIME[] = "azimuth_start_time"; static const char AZ_STOP_TIME[] = "azimuth_stop_time"; static const char RG_FIRST_TIME[] = "range_first_time"; static const char RG_LAST_TIME[] = "range_last_time"; static const char GENERATION_TIME[] = "generation_time"; static const char ACQUISITION_INFO[] = "acquisitionInfo."; static const char IMAGING_MODE[] = "imagingMode"; static const char SENSOR[] = "sensor"; static const char LOOK_DIRECTION[] = "lookDirection"; static const char POLARISATION_MODE[] = "polarisationMode"; static const char POLARISATION_LIST[] = "polarisationList"; static const char NUMBER_LAYERS[] = "numberOfLayers"; static const char CALIBRATION_CALFACTOR[] = "calibration.calibrationConstant.calFactor"; static const char RADAR_FREQUENCY[] = "radarFrequency"; // Static trace for debugging static ossimTrace traceDebug("ossimTerraSarModel:debug"); namespace ossimplugins { RTTI_DEF1(ossimTerraSarModel, "ossimTerraSarModel", ossimGeometricSarSensorModel); } ossimplugins::ossimTerraSarModel::ossimTerraSarModel() : ossimGeometricSarSensorModel(), _SrToGr_R0(0.0), _SrToGr_exponent(), _SrToGr_coeffs(), _sceneCenterRangeTime(0.0), _SrToGr_scaling_factor(0.0), _alt_srgr_coefset(3), _productType(), _radiometricCorrection(), _imagingMode(), _acquisitionSensor(), _lookDirection(), _polarisationMode(), _polLayer("UNDEFINED"), _polLayerList(), _noise(0), _sceneCoord(0), _calFactor(0.), _radarFrequency(0.), _numberOfLayers(0), _azStartTime(), _azStopTime(), _rgFirstPixelTime(), _rgLastPixelTime(), _generationTime() { } ossimplugins::ossimTerraSarModel::ossimTerraSarModel( const ossimTerraSarModel& rhs) : ossimGeometricSarSensorModel(rhs), _SrToGr_R0(rhs._SrToGr_R0), _SrToGr_exponent(rhs._SrToGr_exponent), _SrToGr_coeffs(rhs._SrToGr_coeffs), _sceneCenterRangeTime(rhs._sceneCenterRangeTime), _SrToGr_scaling_factor(rhs._SrToGr_scaling_factor), _alt_srgr_coefset(rhs._alt_srgr_coefset), _productType(rhs._productType), _radiometricCorrection(rhs._radiometricCorrection), _imagingMode(rhs._imagingMode), _acquisitionSensor(rhs._acquisitionSensor), _lookDirection(rhs._lookDirection), _polarisationMode(rhs._polarisationMode), _polLayer(rhs._polLayer), _polLayerList(rhs._polLayerList), _noise(rhs._noise), _sceneCoord( 0 ), _calFactor(rhs._calFactor), _radarFrequency(rhs._radarFrequency), _numberOfLayers(rhs._numberOfLayers), _azStartTime(rhs._azStartTime), _azStopTime(rhs._azStopTime), _rgFirstPixelTime(rhs._rgFirstPixelTime), _rgLastPixelTime(rhs._rgLastPixelTime), _generationTime(rhs._generationTime) { if ( rhs._sceneCoord ) { _sceneCoord = new SceneCoord( *(rhs._sceneCoord) ); } } ossimplugins::ossimTerraSarModel::~ossimTerraSarModel() { _noise.clear(); /* * if (_noise != 0) { delete _noise; } */ if (_sceneCoord) { delete _sceneCoord; _sceneCoord = 0; } } ossimString ossimplugins::ossimTerraSarModel::getClassName() const { return ossimString("ossimTerraSarModel"); } ossimObject* ossimplugins::ossimTerraSarModel::dup() const { return new ossimTerraSarModel(*this); } // Note : ground range to slant range coputation could be performed in three ways : // (1) Slant Range to Ground Range polynomial inversion (coefficients given at mid-scene) // (2) use of a parabolic model from three geolocated points // (3) interpolation from the geolocation grid (separate file, most precise technique) // In this version, (1) and (2) were implemented but (1) is imprecise on the test products. double ossimplugins::ossimTerraSarModel::getSlantRangeFromGeoreferenced(double col) const { const double c = 2.99792458e+8; double tn = _alt_srgr_coefset[0] + _alt_srgr_coefset[1] * col + _alt_srgr_coefset[2] * col*col ; return tn * (c/2.0); } bool ossimplugins::ossimTerraSarModel::open(const ossimFilename& file) { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::open() -- "; _imageFilename = file.expand(); _productXmlFile = ossimFilename::NIL; ossimFilename xmlfile; bool foundMetadataFile = findTSXLeader(file, xmlfile); while (foundMetadataFile) // use of while allows use of "break" { //--- // Instantiate the XML parser: //--- ossimRefPtr xdoc = new ossimXmlDocument(); if ( !xdoc->openFile(xmlfile) ) break; ossimTerraSarProductDoc tsDoc; if (!tsDoc.isTerraSarX(xdoc.get())) break; ossimString s; if ( tsDoc.getProjection(xdoc.get(), s) ) { if ( s.upcase() == "MAP" ) break; } // Set the base class number of lines and samples // Set the base class clip rect. // Set the sub image offset. tmp hard coded (drb). if (!tsDoc.initImageSize(xdoc.get(), theImageSize)) break; theImageClipRect = ossimDrect(0, 0, theImageSize.x-1, theImageSize.y-1); theSubImageOffset.x = 0.0; theSubImageOffset.y = 0.0; // Set the image ID to the scene ID. if (!tsDoc.getSceneId(xdoc.get(), theImageID)) break; // Set the sensor ID to the mission ID. if (!tsDoc.getMission(xdoc.get(), theSensorID)) break; // Set the base class gsd: if (!tsDoc.initGsd(xdoc.get(), theGSD)) break; theMeanGSD = (theGSD.x + theGSD.y)/2.0; initSRGR(xdoc.get(), tsDoc); if (!initPlatformPosition(xdoc.get(), tsDoc)) break; if (!initSensorParams(xdoc.get(), tsDoc)) break; if (!initRefPoint(xdoc.get(), tsDoc)) break; if (!tsDoc.getProductType(xdoc.get(), _productType)) break; if (!tsDoc.getRadiometricCorrection(xdoc.get(), _radiometricCorrection)) break; if (!initAcquisitionInfo(xdoc.get(), tsDoc)) break; if (!initNoise(xdoc.get(), tsDoc)) break; if (!getPolLayerFromImageFile(xdoc.get(), file)) break; if (!initCalibration(xdoc.get(), tsDoc)) break; // replaced by OTB by the initCalibration above // if (!tsDoc.getCalFactor(xdoc.get(), s)) break; // _calFactor = s.toFloat64(); if (!tsDoc.getRadarFrequency(xdoc.get(), s)) break; _radarFrequency= s.toFloat64(); if (!tsDoc.getAzimuthStartTime(xdoc.get(), _azStartTime)) break; if (!tsDoc.getAzimuthStopTime(xdoc.get(), _azStopTime)) break; if (!tsDoc.getRangeFirstPixelTime(xdoc.get(), _rgFirstPixelTime)) break; if (!tsDoc.getRangeLastPixelTime(xdoc.get(), _rgLastPixelTime)) break; if (!tsDoc.getGenerationTime(xdoc.get(), _generationTime)) break; // removed by OTB // if (!initIncidenceAngles(xdoc.get(), tsDoc)) break; if (!initSceneCoord(xdoc.get(), tsDoc)) break; xdoc = 0; _productXmlFile = xmlfile; ossimSupportFilesList::instance()->add(_productXmlFile); // Assign the ossimSensorModel::theBoundGndPolygon ossimGpt ul; ossimGpt ur; ossimGpt lr; ossimGpt ll; lineSampleToWorld(theImageClipRect.ul(), ul); lineSampleToWorld(theImageClipRect.ur(), ur); lineSampleToWorld(theImageClipRect.lr(), lr); lineSampleToWorld(theImageClipRect.ll(), ll); setGroundRect(ul, ur, lr, ll); // ossimSensorModel method. if (traceDebug()) { ossimNotify(ossimNotifyLevel_NOTICE) << MODULE << "Loaded support data file <"< for image <"<."<saveState(kwl,prefix); for(ossim_uint32 i = 0; i < _numberOfLayers; ++i) { kwl.add(prefix, CALIBRATION_CALFACTOR, ossimString::toString(_calFactor[i]).c_str()); } kwl.add(prefix, RADAR_FREQUENCY, ossimString::toString(_radarFrequency).c_str()); kwl.add(prefix, AZ_START_TIME, _azStartTime.c_str()); kwl.add(prefix, AZ_STOP_TIME, _azStopTime.c_str()); kwl.add(prefix, RG_FIRST_TIME, _rgFirstPixelTime.c_str()); kwl.add(prefix, RG_LAST_TIME, _rgLastPixelTime.c_str()); kwl.add(prefix, GENERATION_TIME, _generationTime.c_str()); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimplugins::ossimTerraSarModel::loadState (const ossimKeywordlist &kwl, const char *prefix) { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } const char* lookup = 0; ossimString s; // Check the type first. lookup = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (lookup) { s = lookup; if (s != getClassName()) { return false; } } // Get the product.xml file name. lookup = kwl.find(prefix, PRODUCT_XML_FILE_KW); if (lookup) { _productXmlFile = lookup; // See if caller wants to load from xml vice keyword list. lookup = kwl.find(prefix, LOAD_FROM_PRODUCT_FILE_KW); if (lookup) { s = lookup; if ( s.toBool() ) { // Loading from product.xml file. return open(_productXmlFile); } } } //--- // Temp: This must be cleared or you end up with a bounding rect of all // zero's. //--- theBoundGndPolygon.clear(); // Load the base class. bool result = ossimGeometricSarSensorModel::loadState(kwl, prefix); if (result) { lookup = kwl.find(prefix,SR_GR_R0_KW); if (lookup) { s = lookup; _SrToGr_R0 = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << SR_GR_R0_KW << "\n"; } result = false; } ossim_uint32 count = 0; lookup = kwl.find(prefix, NUMBER_SRGR_COEFFICIENTS_KW); if (lookup) { s = lookup; count = s.toUInt32(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << NUMBER_SRGR_COEFFICIENTS_KW << "\n"; } result = false; } //////////////////////////////////////////////////// if (result && count) { _SrToGr_exponent.resize(count); _SrToGr_coeffs.resize(count); ossimString kw1 = "sr_gr_exponent_"; ossimString kw2 = "sr_gr_coeffs_"; for(ossim_uint32 i = 0; i < count; ++i) { ossimString kw; ossimString iStr = ossimString::toString(i); // sr_gr_exponents kw = kw1; kw += iStr; lookup = kwl.find(prefix, kw); if (lookup) { s = lookup; _SrToGr_exponent[i] = s.toInt(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << kw << "\n"; } result = false; } // _SrToGr_coeffs kw = kw2; kw += iStr; lookup = kwl.find(prefix, kw); if (lookup) { s = lookup; _SrToGr_coeffs[i] = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << kw << "\n"; } result = false; } } } // matches: if (result && count) lookup = kwl.find(prefix, SC_RT_KW); if (lookup) { s = lookup; _sceneCenterRangeTime = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << SC_RT_KW << "\n"; } result = false; } lookup = kwl.find(prefix, SR_GR_SF_KW); if (lookup) { s = lookup; _SrToGr_scaling_factor = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << SR_GR_SF_KW << "\n"; } result = false; } lookup = kwl.find(prefix, ALT_SR_GR_COEFFICIENT0_KW); if (lookup) { s = lookup; _alt_srgr_coefset[0] = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << ALT_SR_GR_COEFFICIENT0_KW << "\n"; } result = false; } lookup = kwl.find(prefix, ALT_SR_GR_COEFFICIENT1_KW); if (lookup) { s = lookup; _alt_srgr_coefset[1] = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << ALT_SR_GR_COEFFICIENT1_KW << "\n"; } result = false; } lookup = kwl.find(prefix, ALT_SR_GR_COEFFICIENT2_KW); if (lookup) { s = lookup; _alt_srgr_coefset[2] = s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << ALT_SR_GR_COEFFICIENT2_KW << "\n"; } result = false; } lookup = kwl.find(prefix, PRODUCT_XML_FILE_KW); if (lookup) { _productXmlFile = lookup; } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << PRODUCT_XML_FILE_KW << "\n"; } result = false; } } // matches: if (result) // Load the base class. /* * TODO correct loadState */ #if 0 if ( !_noise) { _noise = new Noise(); } if ( _noise->loadState(kwl, prefix) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n_noise->loadState failed!\n"; } result = false; } #endif // Load the base class. if ( !_sceneCoord) { _sceneCoord = new SceneCoord(); } if ( _sceneCoord->loadState(kwl,prefix) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n__sceneCoord->loadState failed!\n"; } result = false; } lookup = kwl.find(prefix, CALIBRATION_CALFACTOR); if (lookup) { std::istringstream in(lookup); ossimString tempValue; for(ossim_uint32 idx = 0; idx < _numberOfLayers; ++idx) { in >> tempValue; _calFactor[idx] = tempValue.toDouble(); } } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << CALIBRATION_CALFACTOR << "\n"; } result = false; } lookup = kwl.find(prefix, RADAR_FREQUENCY); if (lookup) { s = lookup; _radarFrequency= s.toDouble(); } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << RADAR_FREQUENCY << "\n"; } result = false; } lookup = kwl.find(prefix, AZ_START_TIME); if (lookup) { _azStartTime = lookup; } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << AZ_START_TIME << "\n"; } result = false; } lookup = kwl.find(prefix, AZ_STOP_TIME); if (lookup) { _azStopTime = lookup; } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << AZ_STOP_TIME << "\n"; } result = false; } lookup = kwl.find(prefix, RG_FIRST_TIME); if (lookup) { _rgFirstPixelTime = lookup; } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << RG_FIRST_TIME << "\n"; } result = false; } lookup = kwl.find(prefix, RG_LAST_TIME); if (lookup) { _rgLastPixelTime = lookup; } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << RG_LAST_TIME << "\n"; } result = false; } lookup = kwl.find(prefix, GENERATION_TIME); if (lookup) { _generationTime = lookup; } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\nRequired keyword not found: " << GENERATION_TIME << "\n"; } result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } std::ostream& ossimplugins::ossimTerraSarModel::print(std::ostream& out) const { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::print"; // Capture the original flags. std::ios_base::fmtflags f = out.flags(); out << setprecision(15) << setiosflags(ios::fixed) << "\nossimTerraSarModelclass data members:\n" << SR_GR_R0_KW << _SrToGr_R0 << "\n"; ossim_uint32 i; ossimString kw1 = "sr_gr_exponent_"; for(i = 0; i < _SrToGr_exponent.size(); ++i) { ossimString iStr = ossimString::toString(i); ossimString kw = kw1; kw += iStr; kw += ": "; out << kw << _SrToGr_exponent[i] << "\n"; } kw1 = "sr_gr_coeffs_"; for(i = 0; i < _SrToGr_coeffs.size(); ++i) { ossimString iStr = ossimString::toString(i); ossimString kw = kw1; kw += iStr; kw += ": "; out << kw << _SrToGr_coeffs[i] << "\n"; } out << SC_RT_KW << ": " << _sceneCenterRangeTime << "\n" << SR_GR_SF_KW << ": " << _SrToGr_scaling_factor << "\n" << ALT_SR_GR_COEFFICIENT0_KW << ": " << _alt_srgr_coefset[0] << "\n" << ALT_SR_GR_COEFFICIENT1_KW << ": " <<_alt_srgr_coefset[1] << "\n" << ALT_SR_GR_COEFFICIENT2_KW << ": " <<_alt_srgr_coefset[2] << "\n" << PRODUCT_XML_FILE_KW << ": " << _productXmlFile.c_str() << "\n"; ossimGeometricSarSensorModel::print(out); for(ossim_uint32 i = 0; i < _numberOfLayers; ++i) { if ( !_noise[i].print(out) ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n_noise->print failed!\n"; } } } if ( !_sceneCoord->print(out) ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n_sceneCoord->print failed!\n"; } } out << NUMBER_LAYERS << ": " << _numberOfLayers << "\n"; for(ossim_uint32 idx = 0; idx < _numberOfLayers; ++idx) { out << CALIBRATION_CALFACTOR << "["<< idx << "]: " << _calFactor[idx] << "\n"; } out << RADAR_FREQUENCY << ": " << _radarFrequency<< "\n"; out << AZ_START_TIME << ": " << _azStartTime << "\n"; out << AZ_STOP_TIME << ": " << _azStopTime << "\n"; out << RG_FIRST_TIME << ": " << _rgFirstPixelTime << "\n"; out << RG_LAST_TIME << ": " << _rgLastPixelTime << "\n"; out << GENERATION_TIME << ": " << _generationTime << "\n"; // Reset flags. ossimString kw = ACQUISITION_INFO; ossimString kw2 = kw + IMAGING_MODE; out << kw2 << ": " << _imagingMode.c_str()<< "\n"; kw2 = kw + SENSOR; out << kw2<< ": " << _acquisitionSensor.c_str()<< "\n"; kw2 = kw + LOOK_DIRECTION; out << kw2<< ": " << _lookDirection.c_str()<< "\n"; kw2 = kw + POLARISATION_MODE; out << kw2<< ": " << _polarisationMode.c_str()<< "\n"; /* kw2 = kw + POLARISATION_LIST; for(ossim_uint32 i = 0; i < _numberOfLayers; ++i) { out << kw2 << "["<< i <<"] : " << _polLayer[i].c_str()<< "\n"; if ( _noise[i]->print(out) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << "\n_noise->print failed!\n"; } } } */ out.setf(f); return out; } /* // Version (1) double ossimplugins::ossimTerraSarModel::getSlantRangeFromGeoreferenced(double col) const { // iterative polynomial inversion const double CLUM = 2.99792458e+8 ; double EPSILON = 0.0000001 ; double iterError = 1.0 ; int maxIter = 50, nIter=0 ; double estimatedGroundRange, estimatedSlantRangeTime, actualGroundRange, estimatedSlantRange ; // actual ground range computation relative to the image near side // in the case of Georeferenced images, _refPoint->get_distance() contains the ground range actualGroundRange = _refPoint->get_distance() - _sensor->get_col_direction() * (col-_refPoint->get_pix_col()) * _SrToGr_scaling_factor ; estimatedSlantRangeTime = _sceneCenterRangeTime ; while ((fabs(iterError)>EPSILON)&& (nIter m const char* ellip_min_str = kwl.find(prefix,"ellip_min"); double ellip_min = atof(ellip_min_str) * 1000.0; // km -> m if(_sensor != NULL) { delete _sensor; } _sensor = new SensorParams(); if (_isProductGeoreferenced) { const char* orbitDirection_str = kwl.find(prefix,"orbitDirection"); std::string orbitDirection(orbitDirection_str) ; int orbitDirectionSign ; if (orbitDirection=="DESCENDING") orbitDirectionSign = 1 ; else orbitDirectionSign = - 1 ; const char* imageDataStartWith_str = kwl.find(prefix,"imageDataStartWith"); std::string imageDataStartWith(imageDataStartWith_str) ; if (imageDataStartWith=="EARLYAZNEARRG") { _sensor->set_col_direction(orbitDirectionSign); _sensor->set_lin_direction(orbitDirectionSign); } else if (imageDataStartWith=="EARLYAZFARRG") { _sensor->set_col_direction(-orbitDirectionSign); _sensor->set_lin_direction(orbitDirectionSign); } else if (imageDataStartWith=="LATEAZNEARRG") { _sensor->set_col_direction(orbitDirectionSign); _sensor->set_lin_direction(-orbitDirectionSign); } else if (imageDataStartWith=="LATEAZFARRG") { _sensor->set_col_direction(-orbitDirectionSign); _sensor->set_lin_direction(-orbitDirectionSign); } else { // COSAR Files are stored starting with early azimuth, near range _sensor->set_col_direction(orbitDirectionSign); _sensor->set_lin_direction(orbitDirectionSign); } } else { _sensor->set_col_direction(1); _sensor->set_lin_direction(1); } const char* lookDirection_str = kwl.find(prefix,"lookDirection"); std::string lookDirection(lookDirection_str) ; if ((lookDirection == "Right")||(lookDirection == "RIGHT")) _sensor->set_sightDirection(SensorParams::Right) ; else _sensor->set_sightDirection(SensorParams::Left) ; _sensor->set_sf(fr); const double CLUM = 2.99792458e+8 ; double wave_length = CLUM / central_freq ; _sensor->set_rwl(wave_length); _sensor->set_nRangeLook(n_rnglok); _sensor->set_prf(fa) ; // fa is the processing PRF //_sensor->set_prf(fa * n_azilok); // number of looks disabled _sensor->set_semiMajorAxis(ellip_maj) ; _sensor->set_semiMinorAxis(ellip_min) ; return true; } bool ossimplugins::ossimTerraSarModel::InitPlatformPosition( const ossimKeywordlist &kwl, const char *prefix) { /* * Retrieval of ephemerisis number */ const char* neph_str = kwl.find(prefix,"neph"); int neph = atoi(neph_str); Ephemeris** ephemeris = new Ephemeris*[neph]; /* * Retrieval of ephemerisis */ for (int i=0;iset_pix_col(sc_pix); _refPoint->set_pix_line(sc_lin); CivilDateTime * date = new CivilDateTime() ; if (! ossim::iso8601TimeStringToCivilDate(inp_sctim_string, *date)) return false ; if(_platformPosition != NULL) { Ephemeris * ephemeris = _platformPosition->Interpolate((JSDDateTime)*date); if (ephemeris == NULL) return false ; _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else { return false; } const double CLUM = 2.99792458e+8 ; double sceneCenterSlantRange = _sceneCenterRangeTime * CLUM / 2.0 ; _refPoint->set_distance(sceneCenterSlantRange); // in the case of Georeferenced images, the ground range is stored in place of the slant range // (used for SlantRange computation relative to reference point, necessary for optimization) if (_isProductGeoreferenced) { double estimatedGroundRange = 0.0 ; for (int i=0; i(_SrToGr_coeffs.size()); i++) { estimatedGroundRange += _SrToGr_coeffs[i]*pow(_sceneCenterRangeTime-_SrToGr_R0,_SrToGr_exponent[i]); } // SrToGr update : estimatedGroundRange = sc_pix * scaling_factor _SrToGr_scaling_factor = estimatedGroundRange / sc_pix ; _refPoint->set_distance(estimatedGroundRange); } // in order to use ossimSensorModel::lineSampleToWorld const char* nbCol_str = kwl.find(prefix,"nbCol"); const char* nbLin_str = kwl.find(prefix,"nbLin"); theImageSize.x = atoi(nbCol_str); theImageSize.y = atoi(nbLin_str); theImageClipRect = ossimDrect(0, 0, theImageSize.x-1, theImageSize.y-1); if (_isProductGeoreferenced) { std::string azimuthStartTime(kwl.find("azimuthStartTime")); std::string azimuthStopTime(kwl.find("azimuthStopTime")); CivilDateTime * dateStart = new CivilDateTime() ; if (! ossim::iso8601TimeStringToCivilDate(azimuthStartTime, *dateStart)) return false ; CivilDateTime * dateStop = new CivilDateTime() ; if (! ossim::iso8601TimeStringToCivilDate(azimuthStopTime, *dateStop)) return false ; double acq_msec_first = (double) dateStart->get_second()+dateStart->get_decimal(); double acq_msec_last = (double) dateStop->get_second()+dateStop->get_decimal(); double actualPRF = theImageSize.y/(acq_msec_last-acq_msec_first) ; _sensor->set_nAzimuthLook(_sensor->get_prf()/actualPRF); } else _sensor->set_nAzimuthLook(1.0); // Ground Control Points extracted from the model : scene center and corners std::list groundGcpCoordinates ; std::list imageGcpCoordinates ; char name[64]; for (int k=0 ; k<5 ; k++) { sprintf(name,"cornersCol%i",k); const char* i_str = kwl.find(name); int i = atoi(i_str); sprintf(name,"cornersLin%i",k); const char* j_str = kwl.find(name); int j = atoi(j_str); sprintf(name,"cornersLon%i",k); const char* lon_str = kwl.find(name); double lon = atof(lon_str); sprintf(name,"cornersLat%i",k); const char* lat_str = kwl.find(name); double lat = atof(lat_str); const char* height_str = kwl.find("terrain_h"); double height = atof(height_str) ; ossimDpt imageGCP(i,j); ossimGpt groundGCP(lat ,lon , height); groundGcpCoordinates.push_back(groundGCP) ; imageGcpCoordinates.push_back(imageGCP) ; } // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates) ; return true; } bool ossimplugins::ossimTerraSarModel::InitSRGR(const ossimKeywordlist &kwl, const char *prefix) { const char* rangeProjectionType_str = kwl.find(prefix,"rangeProjectionType"); std::string rangeProjectionType(rangeProjectionType_str); _isProductGeoreferenced = (rangeProjectionType=="GROUNDRANGE") ; // SRtoGR polynomial reference const char* SrToGr_R0_str = kwl.find(prefix,"SrToGr_R0"); _SrToGr_R0 = atof(SrToGr_R0_str); // number of SRtoGR coefficients const char* SrToGr_coeffs_number_str = kwl.find(prefix,"SrToGr_coeffs_number"); int srToGr_coeffs_number = atoi(SrToGr_coeffs_number_str); // SRtoGR coefficients and exponents char name[64]; double coeff ; int exponent ; for(int i=0;i nodes; ossimString path = "/level1Product/productSpecific/projectedImageInfo/slantToGroundRangeProjection/coefficient"; std::vector > xnodes; const ossimString EXP = "exponent"; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { xnodes[i]->getAttributeValue(s, EXP); _SrToGr_exponent.push_back(s.toInt32()); _SrToGr_coeffs.push_back(xnodes[i]->getText().toDouble()); } } } else { result = false; } // Range time for first mid and last pixel if ( tsDoc.getOrbitDirection(xdoc, s) ) { bool desendingFlag = (s == "DESCENDING"); double startRng = 0.0; double endRng = 0.0; double scRng = 0.0; double t1 = 0.0; double t2 = 0.0; double t3 = 0.0; double x2 = 0.0; if ( tsDoc.getRangeGateFirstPixel(xdoc, s) ) { startRng = s.toDouble(); } else { result = false; } if ( tsDoc.getRangeGateLastPixel(xdoc, s) ) { endRng = s.toDouble(); } else { result = false; } if ( tsDoc.getSceneCenterRangeTime(xdoc, s) ) { scRng = s.toDouble(); } else { result = false; } t2 = scRng; if (desendingFlag) { t3 = startRng; t1 = endRng; } else { t1 = startRng; t3 = endRng; } // Range pixels numbers corresponding if ( tsDoc.getSceneCenterRefColumn(xdoc, s) ) { //--- // TSX image coordinates start at (1,1), // while OSSIM image coordinates start at (0,0) //--- x2 = s.toDouble() - 1.0; } else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "startRng: " << startRng << "\nscRng: " << scRng << "\nendRng: " << endRng << "\nx2: " << x2 << "\n"; } double x3 = 2.0*(x2+1.0) -1.0 ; _alt_srgr_coefset[0] = t1; _alt_srgr_coefset[1] = ((t2-t1)/(x2*x2)+(t1-t3)/(x3*x3))/((1.0/x2)-(1.0/x3)); _alt_srgr_coefset[2] = ((t2-t1)/x2 + (t1-t3)/x3)/(x2-x3); } else { result = false; } return result; } bool ossimplugins::ossimTerraSarModel::initPlatformPosition(const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& tsDoc) { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::initPlatformPosition"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } // Initialize the platform position interpolator. if (_platformPosition) { delete _platformPosition; } _platformPosition = new PlatformPosition(); bool result = tsDoc.initPlatformPosition(xdoc, _platformPosition); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimplugins::ossimTerraSarModel::initSensorParams(const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& tsDoc) { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::initSensorParams"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } if (_sensor ) { delete _sensor; } _sensor = new SensorParams(); bool result = tsDoc.initSensorParams(xdoc, _sensor); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "result for tsDoc.initSensorParams " << result << endl; } if (!result) { delete _sensor; _sensor = 0; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimplugins::ossimTerraSarModel::initRefPoint( const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& tsDoc) { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::initRefPoint"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } if ( !_platformPosition ) { return false; } bool result = true; ossimString s; // used throughout //--- // Set the base class reference points. // Note the "ONE BASED" image points from xml doc. //--- // Get the center sample. if ( tsDoc.getSceneCenterRefColumn(xdoc, s) ) { theRefImgPt.x = s.toFloat64() - 1.0; } else { result = false; } // Get the center line. if ( tsDoc.getSceneCenterRefRow(xdoc, s) ) { theRefImgPt.y = s.toFloat64() - 1.0; } else { result = false; } // Get the center latitude. if ( tsDoc.getSceneCenterLat(xdoc, s) ) { theRefGndPt.lat = s.toFloat64(); } else { result = false; } // Get the center longitude. if ( tsDoc.getSceneCenterLon(xdoc, s) ) { theRefGndPt.lon = s.toFloat64(); } else { result = false; } // Reference point. if (_refPoint) { delete _refPoint; } _refPoint = new RefPoint(); _refPoint->set_pix_col(theRefImgPt.x); _refPoint->set_pix_line(theRefImgPt.y); if ( tsDoc.getSceneCenterAzimuthTime(xdoc, s) ) { CivilDateTime date; if ( ossim::iso8601TimeStringToCivilDate(s, date) ) { JSDDateTime jdate(date); Ephemeris * ephemeris = _platformPosition->Interpolate(jdate); if (ephemeris) { _refPoint->set_ephemeris(ephemeris); delete ephemeris; } else { result = false; } } else { result = false; } } else { result = false; } if ( tsDoc.getSceneCenterRangeTime(xdoc, s) ) { _sceneCenterRangeTime = s.toDouble(); const double CLUM = 2.99792458e+8; double sceneCenterSlantRange = _sceneCenterRangeTime * CLUM / 2.0; _refPoint->set_distance(sceneCenterSlantRange); } else { result = false; } //--- // In the case of Georeferenced images, the ground range is stored in // place of the slant range // (used for SlantRange computation relative to reference point, necessary // for optimization) //--- if (_isProductGeoreferenced) { double estimatedGroundRange = 0.0 ; for (int i=0; i(_SrToGr_coeffs.size()); i++) { estimatedGroundRange += _SrToGr_coeffs[i]* pow(_sceneCenterRangeTime - _SrToGr_R0, _SrToGr_exponent[i]); } // SrToGr update : estimatedGroundRange = sc_pix * scaling_factor _SrToGr_scaling_factor = estimatedGroundRange / theRefImgPt.x; _refPoint->set_distance(estimatedGroundRange); CivilDateTime dateStart; CivilDateTime dateStop; if (tsDoc.getAzimuthStartTime(xdoc, s) ) { if (! ossim::iso8601TimeStringToCivilDate(s, dateStart) ) { result = false; } } else { result = false; } if (tsDoc.getAzimuthStopTime(xdoc, s) ) { if (! ossim::iso8601TimeStringToCivilDate(s, dateStop) ) { result = false; } } else { result = false; } double acq_msec_first = (double) dateStart.get_second() + dateStart.get_decimal(); double acq_msec_last = (double) dateStop.get_second() + dateStop.get_decimal(); double actualPRF = theImageSize.y/(acq_msec_last - acq_msec_first) ; _sensor->set_nAzimuthLook(_sensor->get_prf()/actualPRF); } else { _sensor->set_nAzimuthLook(1.0); } // Ground Control Points extracted from the model. std::list groundGcpCoordinates; std::list imageGcpCoordinates; if ( tsDoc.initTiePoints(xdoc, groundGcpCoordinates, imageGcpCoordinates) == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "initTiePoint error! exiting\n"; } return false; } if (result) { // Default optimization optimizeModel(groundGcpCoordinates, imageGcpCoordinates); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = true\n"; } return true; } bool ossimplugins::ossimTerraSarModel::initAcquisitionInfo( const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& tsDoc) { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::initAcquisitionInfo"; bool result; ossimString s; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entering...\n"; } result = tsDoc.geNumberOfLayers(xdoc, s); if ( result == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "unable to get Number Of Layers \n"; } setErrorStatus(); return false; } _numberOfLayers = ossimString(s).toUInt32(); result = tsDoc.getMission(xdoc, theSensorID); if ( result == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "unable to get theSensorID \n"; } setErrorStatus(); return false; } result = tsDoc.getImagingMode(xdoc, _imagingMode); if ( result == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "unable to get Imaging Mode \n"; } setErrorStatus(); return false; } result = tsDoc.getAcquisitionSensor(xdoc, _acquisitionSensor); if ( result == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "unable to get Acquisition Sensor \n"; } setErrorStatus(); return false; } result = tsDoc.getLookDirection(xdoc, _lookDirection); if ( result == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "unable to get Look direction \n"; } setErrorStatus(); return false; } result = tsDoc.getPolarisationMode(xdoc, _polarisationMode); if ( result == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "unable to get Polarisation Mode \n"; } setErrorStatus(); return false; } result = tsDoc.getPolLayerList(xdoc, _polLayerList); if ( result == false ) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "unable to get Polarisation Layer list \n"; } setErrorStatus(); return false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " leaving...\n"; } return result; } bool ossimplugins::ossimTerraSarModel::initSceneCoord( const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& tsDoc) { static const char MODULE[] = "ossimplugins::ossimTerraSarModel::initSceneCoord"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } if (_sceneCoord) { delete _sceneCoord; } _sceneCoord = new SceneCoord(); bool result = tsDoc.initSceneCoord(xdoc, _sceneCoord); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } bool ossimplugins::ossimTerraSarModel::getNoiseAtGivenNode( const ossimRefPtr xmlDocument, ossimplugins::Noise& noise) { ossimString xpath; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; std::vector tabImageNoise; ImageNoise ev; tabImageNoise.clear(); static const char MODULE[] = "ossimplugins::ossimTerraSarModel::getNoise"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } if ( !xmlDocument ) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: one of the getNoise parameter of the method is NULL" << std::endl; } return false; } xml_nodes.clear(); xpath = "numberOfNoiseRecords"; xmlDocument->findChildNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } noise.set_numberOfNoiseRecords( xml_nodes[0]->getText().toInt32() ); xml_nodes.clear(); xpath = "imageNoise"; xmlDocument->findChildNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "timeUTC"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_timeUTC(sub_nodes[0]->getText()); sub_nodes.clear(); xpath = "noiseEstimate/validityRangeMin"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_validityRangeMin( sub_nodes[0]->getText().toDouble() ); sub_nodes.clear(); xpath = "noiseEstimate/validityRangeMax"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_validityRangeMax( sub_nodes[0]->getText().toDouble() ); sub_nodes.clear(); xpath = "noiseEstimate/referencePoint"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_referencePoint( sub_nodes[0]->getText().toDouble() ); sub_nodes.clear(); xpath = "noiseEstimate/polynomialDegree"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } ev.set_polynomialDegree( sub_nodes[0]->getText().toInt32() ); sub_nodes.clear(); ossimXmlNode::ChildListType nodelist; (*node)->findChildNodes("noiseEstimate/coefficient",nodelist); ossimXmlNode::ChildListType::const_iterator child_iter = nodelist.begin(); std::vector polynomialCoefficients; while(child_iter != nodelist.end()) { double coefficient = ((*child_iter)->getText()).toDouble() ; polynomialCoefficients.push_back(coefficient); ++child_iter; } ev.set_polynomialCoefficients( polynomialCoefficients ); tabImageNoise.push_back(ev); ++node; } noise.set_imageNoise(tabImageNoise); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " leaving...\n"; } return true; } bool ossimplugins::ossimTerraSarModel::initNoise( const ossimXmlDocument* xmlDocument, const ossimTerraSarProductDoc& /* tsDoc */ ) { ossimString xpath; ossimString polLayerName; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; bool result; static const char MODULE[] = "ossimplugins::ossimTerraSarModel::initNoise"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entering...\n"; } _noise.resize(_numberOfLayers); xml_nodes.clear(); xpath = "/level1Product/noise"; xmlDocument->findNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "polLayer"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } polLayerName = sub_nodes[0]->getText(); ossim_uint32 polLayerIdx = 0; bool polLayerIdxFound = false; for(ossim_uint32 idx = 0 ; idx < _polLayerList.size(); ++idx) { if(_polLayerList[idx] == polLayerName) { polLayerIdx = idx; polLayerIdxFound = true; } } if (!polLayerIdxFound) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Unable to find polLayer in polLayer List" << std::endl; } return false; } sub_nodes.clear(); //_noise[polLayerIdx] = new Noise(); _noise[polLayerIdx].set_imagePolarisation(polLayerName); result = getNoiseAtGivenNode( (*node),_noise[polLayerIdx]); if(!result) { setErrorStatus(); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Unable to getNoise for the " << polLayerName << " layer image" << std::endl; } return false; } ++node; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " leaving...\n"; } return true; } bool ossimplugins::ossimTerraSarModel::getPolLayerFromImageFile( const ossimXmlDocument* xmlDocument, const ossimFilename& imageFilename) { ossimString xpath; ossimString polLayerName; ossimString polLayerFileName; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; static const char MODULE[] = "ossimplugins::ossimTerraSarModel::getPolLayerFromImageFile"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entering...\n"; } xml_nodes.clear(); xpath = "/level1Product/productComponents/imageData"; xmlDocument->findNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "polLayer"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } polLayerName = sub_nodes[0]->getText(); sub_nodes.clear(); xpath = "file/location/filename"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } polLayerFileName = sub_nodes[0]->getText(); if (polLayerFileName == imageFilename.file()) { _polLayer = polLayerName; } ++node; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " leaving...\n"; } return true; } bool ossimplugins::ossimTerraSarModel::initCalibration( const ossimXmlDocument* xmlDocument, const ossimTerraSarProductDoc& /* tsDoc */ ) { ossimString xpath; ossimString polLayerName; std::vector > xml_nodes; std::vector > sub_nodes; std::vector >::iterator node; static const char MODULE[] = "ossimplugins::ossimTerraSarModel::initCalibration"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entering...\n"; } _calFactor.resize(_numberOfLayers); xml_nodes.clear(); xpath = "/level1Product/calibration/calibrationConstant"; xmlDocument->findNodes(xpath, xml_nodes); if(xml_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } node = xml_nodes.begin(); while (node != xml_nodes.end()) { sub_nodes.clear(); xpath = "polLayer"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } polLayerName = sub_nodes[0]->getText(); ossim_uint32 polLayerIdx = 0; bool polLayerIdxFound = false; for(ossim_uint32 idx = 0 ; idx < _polLayerList.size(); ++idx) { if(_polLayerList[idx] == polLayerName) { polLayerIdx = idx; polLayerIdxFound = true; } } if(!polLayerIdxFound) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: Unable to found polLayer in polLayer List" << std::endl; } return false; } sub_nodes.clear(); xpath = "calFactor"; (*node)->findChildNodes(xpath, sub_nodes); if (sub_nodes.size() == 0) { setErrorStatus(); if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:" << "\nCould not find: " << xpath << std::endl; } return false; } _calFactor[polLayerIdx] = sub_nodes[0]->getText().toDouble(); ++node; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " leaving...\n"; } return true; } bool ossimplugins::ossimTerraSarModel::findTSXLeader(const ossimFilename& file, ossimFilename& metadataFile) { bool res = false; if ( file.exists() && (file.ext().downcase() == "xml") ) { metadataFile = file; res = true; } else if (!file.exists()) { res = false; } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimplugins::ossimTerraSarModel::findTSXLeader " << " directory scan turned off. This is killing the factory open." << " We should never scan a directory. Need to resolve. " << std::endl; } //#if 0 ossimFilename imagePath = file.path(); if (imagePath.empty()) imagePath = ossimEnvironmentUtility::instance()->getCurrentWorkingDir(); ossimDirectory directory = ossimDirectory(imagePath.path()); std::vector vectName; ossimString reg = ".xml"; directory.findAllFilesThatMatch( vectName, reg, 1 ); bool goodFileFound = false; unsigned int loop = 0; while(loopprint(ossimNotify(ossimNotifyLevel_DEBUG)); } ossimNotify(ossimNotifyLevel_DEBUG) << "ossimplugins::ossimTerraSarModel::findTSXLeader " << " exit status = " << (res?"true":"false\n") << std::endl; } } //#endif } return res; } void ossimplugins::ossimTerraSarModel::printInfo(ostream& os) const { os << "\n----------------- General Info on TSX-1 Image -------------------" << "\n " << "\n Sensor ID : " << theSensorID << "\n Imaging Mode : " << _imagingMode << "\n Acquisition Sensor : " << _acquisitionSensor << "\n Look direction : " << _lookDirection << "\n Polarisation Mode : " << _polarisationMode << "\n Number of Layers : " << _numberOfLayers << "\n Polarisation List Size : " << _polLayerList.size() << "\n" << "\n------------------------------------------------------------------"; for(ossim_uint32 idx = 0 ; idx < _polLayerList.size(); ++idx) { os << "\n----------------- Info on " << _polLayerList[idx] <<" Layer Image -------------------" << "\n calFactor : " << _calFactor[idx] // << "\n Image Noise size : " << _noise[idx].get_imageNoise().size() << "\n------------------------------------------------------------"; } os << std::endl; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarModel.h000066400000000000000000000231221301006202600274250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimTerraSarModel_H #define ossimTerraSarModel_H #include #include #include #include #include #include #include #include #include #include #include #include #include // Forward class declarations outside of namespace ossimplugins. class ossimXmlDocument; namespace ossimplugins { // Forward class declarations inside of namespace ossimplugins. class ossimTerraSarProductDoc; /** * @brief This class allows for direct localisation and indirect localisation * using the TerraSar sensor model */ class OSSIM_PLUGINS_DLL ossimTerraSarModel : public ossimplugins::ossimGeometricSarSensorModel { public: /** @brief default constructor */ ossimTerraSarModel(); /** @brief copy constructor */ ossimTerraSarModel(const ossimTerraSarModel& rhs); /** @brief Destructor */ virtual ~ossimTerraSarModel(); /** * @brief Method to return the class name. * @return The name of this class. */ virtual ossimString getClassName() const; /** * @brief Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const; /** * @brief This function associates an image column number to a slant * range when the image is georeferenced (ground projected). * @param col Column coordinate of the image point */ virtual double getSlantRangeFromGeoreferenced(double col) const; /** * @brief Method to intantial model from a file. Attempts to find the * required xml file. * * @param file * * @return true on success, false on error. */ bool open(const ossimFilename& file); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ virtual bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; //--- // Convenient method to print important image info: //--- void printInfo (ostream& os) const; private: virtual bool InitPlatformPosition(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitSensorParams(const ossimKeywordlist &kwl, const char *prefix); virtual bool InitRefPoint(const ossimKeywordlist &kwl, const char *prefix); /** * @brief Initializes the Slant Range to Ground Range data sets : * _SrToGr_R0,_SrToGr_coeffs_number,_SrToGr_exponent,_SrToGr_coeffs,_nbCol */ virtual bool InitSRGR(const ossimKeywordlist &kwl, const char *prefix); /** * @note This method must be called before initRefPoint. */ bool initSRGR(const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& rsDoc); bool initPlatformPosition(const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& rsDoc); bool initSensorParams(const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& rsDoc); /** * @brief Method to initialize RefPoint object from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @return true on success, false on error. */ bool initRefPoint(const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& rsDoc); /** * @brief Method to initialize AcquisitionInfo parameters from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @return true on success, false on error. */ bool initAcquisitionInfo( const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& tsDoc); /** * @brief Method to initialize Calibration parameters from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @return true on success, false on error. */ bool initCalibration( const ossimXmlDocument* xmlDocument, const ossimTerraSarProductDoc& tsDoc); /** * @brief Method to initialize InfoIncidenceAngle parameters from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @return true on success, false on error. */ bool initSceneCoord( const ossimXmlDocument* xdoc, const ossimTerraSarProductDoc& tsDoc); /** * @brief Method to initialize ImageNoise parameters from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @return true on success, false on error. */ bool initNoise( const ossimXmlDocument* xmlDocument, const ossimTerraSarProductDoc& tsDoc); /** * @brief Method to get ImageNoise parameters from * TerraSAR product xml file at a given node. * @param xdoc Opened product xml file. * @return true on success, false on error. */ bool getNoiseAtGivenNode( const ossimRefPtr xmlDocument, ossimplugins::Noise& noise); /** * @brief Method to find the metadata file * TerraSAR file (image or xml). * @param file image or metadata path. * @param metadataFile matadata path. * @return ture if mateadata found, false otherwise. */ bool findTSXLeader(const ossimFilename& file, ossimFilename& metadataFile); /** * @brief Method to find the polLayer from the image file * @param xdoc Opened product xml file. * @param file image or metadata path. * @return true on success, false on error. */ bool getPolLayerFromImageFile( const ossimXmlDocument* xmlDocument, const ossimFilename& imageFilename); /** * @brief Slant Range TO Ground Range Projection reference point */ double _SrToGr_R0; /** * @brief Slant Range TO Ground Range Projection exponents */ std::vector _SrToGr_exponent; /** * @brief Slant Range TO Ground Range Projection coefficients */ std::vector _SrToGr_coeffs; /** * @brief Scene Center range time */ double _sceneCenterRangeTime; /** * @brief Slant Range TO Ground Range scaling factor at scene center */ double _SrToGr_scaling_factor; /** * @brief alternative SRGR computation coefficients. Three doubles. */ std::vector _alt_srgr_coefset; /** * @brief ProductType. */ ossimString _productType; /** * @brief RadiometricCorrection. */ ossimString _radiometricCorrection; /** * @brief ImagingMode (AcquisitionInfo node). */ ossimString _imagingMode; /** * @brief Sensor (AcquisitionInfo node). */ ossimString _acquisitionSensor; /** * @brief LookDirection (AcquisitionInfo node). */ ossimString _lookDirection; /** * @brief PolarisationMode (AcquisitionInfo node). */ ossimString _polarisationMode; /** * @brief PolLayer (AcquisitionInfo node). */ ossimString _polLayer; std::vector _polLayerList; /** * @brief Noise (Noise node). */ std::vector _noise; /** * @brief SceneCoord (SceneInfo node) */ SceneCoord *_sceneCoord; /** * @brief CalFactor (Calibration node). */ std::vector _calFactor; /** * @brief centerFrequency (instrument node). */ double _radarFrequency; /** * @brief number of layer (ImageDataInfo node). */ ossim_uint32 _numberOfLayers; /** * @brief Azimuthal Start Time (Start acquisition time). */ ossimString _azStartTime; /** * @brief Azimuthal Stop Time (Start acquisition time). */ ossimString _azStopTime; /** * @brief First pixel Range Time (Start acquisition time in range direction). */ ossimString _rgFirstPixelTime; /** * @brief Last pixel Range Time (Start acquisition time in range direction). */ ossimString _rgLastPixelTime; /** * @brief Generation time. */ ossimString _generationTime; ossimFilename theProductXmlFile; TYPE_DATA }; } // End: namespace ossimplugins #endif /* #ifndef ossimTerraSarModel_H */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarProductDoc.cpp000066400000000000000000001217641301006202600310010ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Description: Utility class to encapsulate parsing TerraSAR-X product.xml // file. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Static trace for debugging static ossimTrace traceDebug("ossimTerraSarProductDoc:debug"); ossimplugins::ossimTerraSarProductDoc::ossimTerraSarProductDoc() { } ossimplugins::ossimTerraSarProductDoc::~ossimTerraSarProductDoc() { } bool ossimplugins::ossimTerraSarProductDoc::isTerraSarX( const ossimXmlDocument* xdoc) const { bool result = false; if (xdoc) { ossimString s; getMission(xdoc, s); s.upcase(); if ( (s == "TSX-1") || (s == "TDX-1") ) { result = true; } } return result; } bool ossimplugins::ossimTerraSarProductDoc::initPlatformPosition( const ossimXmlDocument* xdoc, ossimplugins::PlatformPosition* pos) const { static const char MODULE[] = "ossimplugins::ossimTerraSarProductDoc::initPlatformPosition"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = true; if ( xdoc && pos ) { // Get all the stateVector nodes. ossimString path = "/level1Product/platform/orbit/stateVec"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { const std::vector >::size_type COUNT = xnodes.size(); std::vector ev; int nbrData = 0; // to keep track of good stateVector count. ossimRefPtr svNode = 0; // stateVector node for (ossim_uint32 i = 0 ; i < COUNT; ++i) { svNode = xnodes[i]; if ( !svNode ) { result = false; break; } ossimString s; // TSX ephemerisis quality indicator (1:good, 0: wrong) svNode->getAttributeValue(s, "qualInd"); if (s == "1") { double pos[3]; double vit[3]; CivilDateTime eph_civil_date; path = "timeUTC"; result = ossim::findFirstNode(path, svNode, s); if (result) { ossim::iso8601TimeStringToCivilDate(s, eph_civil_date); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "posX"; result = ossim::findFirstNode(path, svNode, s); if (result) { pos[0] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "posY"; result = ossim::findFirstNode(path, svNode, s); if (result) { pos[1] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "posZ"; result = ossim::findFirstNode(path, svNode, s); if (result) { pos[2] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "velX"; result = ossim::findFirstNode(path, svNode, s); if (result) { vit[0] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "velY"; result = ossim::findFirstNode(path, svNode, s); if (result) { vit[1] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "velZ"; result = ossim::findFirstNode(path, svNode, s); if (result) { vit[2] = s.toDouble(); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } JSDDateTime eph_jsd_date(eph_civil_date); GeographicEphemeris* eph = new GeographicEphemeris(eph_jsd_date, pos, vit); ev.push_back(eph); ++nbrData; } // matches: if (s == "1") } // matches: for (ossim_uint32 i = 0 ; i < COUNT; ++i) if (result && ev.size()) { Ephemeris** ephemeris = new Ephemeris*[ev.size()]; for ( std::vector::size_type evIdx = 0; evIdx < ev.size(); ++evIdx ) { ephemeris[evIdx] = ev[evIdx]; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << " DEBUG\nnbrData: " << nbrData << "\n"; } pos->setData(ephemeris, nbrData); } else { std::vector::iterator evIdx = ev.begin(); while (evIdx != ev.end()) { delete (*evIdx); (*evIdx) = 0; } ev.clear(); } } // matches: if ( xnodes.size() ) else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNodes not found: " << path << std::endl; } } // matches: if (xdoc && pos) else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true\n":"false\n"); } return result; } bool ossimplugins::ossimTerraSarProductDoc::initSensorParams( const ossimXmlDocument* xdoc, SensorParams* sp) const { bool result = true; if (xdoc && sp) { ossimString s; // Get the number of azimuth looks. if ( getNumberOfAzimuthLooks(xdoc, s) ) { sp->set_nAzimuthLook(s.toDouble()); } else { result = false; } // Get the number of range looks. if ( getNumberOfRangeLooks(xdoc, s) ) { sp->set_nRangeLook(s.toDouble()); } else { result = false; } // Get the nominal PRF if ( getCommonPrf(xdoc, s) ) { sp->set_prf(s.toDouble()); } else { result = false; } // Get the radar wave length. if ( getRadarCenterFrequency(xdoc, s) ) { const double CLUM = 2.99792458e+8 ; double waveLength = CLUM / s.toDouble(); sp->set_rwl(waveLength); } else { result = false; } if ( getLookDirection(xdoc, s) ) { if (s.upcase() == "RIGHT") { sp->set_sightDirection(SensorParams::Right); } else { sp->set_sightDirection(SensorParams::Left); } } else { result = false; } // Get the Sampling frequency. if ( getCommonRsf(xdoc, s) ) { sp->set_sf(s.toDouble()); } else { result = false; } // Ellipsoid hard coded to WGS84. const double SEMI_MAJOR = 6378137.0; const double SEMI_MINOR = 6356752.3142; sp->set_semiMajorAxis(SEMI_MAJOR); sp->set_semiMinorAxis(SEMI_MINOR); if ( isProductGeoreferenced(xdoc) ) { if ( getOrbitDirection(xdoc, s) ) { int orbitDirectionSign; if ( s.upcase() == "DESCENDING" ) { orbitDirectionSign = 1 ; } else { orbitDirectionSign = -1 ; } if ( getImageDataStrartWith(xdoc, s) ) { if (s=="EARLYAZNEARRG") { sp->set_col_direction(orbitDirectionSign); sp->set_lin_direction(orbitDirectionSign); } else if (s=="EARLYAZFARRG") { sp->set_col_direction(-orbitDirectionSign); sp->set_lin_direction(orbitDirectionSign); } else if (s=="LATEAZNEARRG") { sp->set_col_direction(orbitDirectionSign); sp->set_lin_direction(-orbitDirectionSign); } else if (s=="LATEAZFARRG") { sp->set_col_direction(-orbitDirectionSign); sp->set_lin_direction(-orbitDirectionSign); } else { //--- // COSAR Files are stored ing with early azimuth, // near range //--- sp->set_col_direction(orbitDirectionSign); sp->set_lin_direction(orbitDirectionSign); } } else { result = false; } } else { result = false; } } // matches: if ( isProductGeoreferenced(xdoc) ) else { sp->set_col_direction(1); sp->set_lin_direction(1); } } // matches: if (xdoc && sp) else { result = false; } return result; } bool ossimplugins::ossimTerraSarProductDoc::initImageSize( const ossimXmlDocument* xdoc, ossimIpt& imageSize) const { bool result = true; if (xdoc) { ossimString s; if ( getNumberOfColumns(xdoc, s) ) { imageSize.x = static_cast(s.toFloat64()); } else { result = false; } if ( getNumberOfRows(xdoc, s) ) { imageSize.y = static_cast(s.toFloat64()); } else { result = false; } } else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimplugins::ossimTerraSarProductDoc::initImageSize DEBUG:\nimage size: " << imageSize << "\nexit status = " << (result?"true":"false") << std::endl; } return result; } bool ossimplugins::ossimTerraSarProductDoc::initGsd( const ossimXmlDocument* xdoc, ossimDpt& gsd) const { bool result = true; if (xdoc) { ossimString s; if ( getProductVariant(xdoc, s) ) { if (s == "SSC") { if ( getProjectedSpacingSlantRange(xdoc, s) ) { gsd.x = s.toFloat64(); } else { result = false; } if ( getProjectedSpacingAzimuth(xdoc, s) ) { gsd.y = s.toFloat64(); } else { result = false; } } else { if ( getRowSpacing(xdoc, s) ) { gsd.x = s.toFloat64(s); } else { result = false; } if ( getColumnSpacing(xdoc, s) ) { gsd.y = s.toFloat64(); } else { result = false; } } } else { result = false; } } else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimplugins::ossimTerraSarProductDoc::initGsd DEBUG:\ngsd: " << gsd << "\nexit status = " << (result?"true":"false") << std::endl; } return result; } bool ossimplugins::ossimTerraSarProductDoc::initTiePoints( const ossimXmlDocument* xdoc, std::list& gcp, std::list& icp) const { static const char MODULE[] = "ossimplugins::ossimTerraSarProductDoc::initTiePoints"; bool result = true; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG:\n"; } if (xdoc) { ossimString s; ossimDpt dpt; ossimGpt gpt; // Get the height. result = getSceneAverageHeight(xdoc, s); if (result) { gpt.hgt = s.toFloat64(); } // Get the scene center. result = getSceneCenterRefColumn(xdoc, s); if (result) { dpt.x = s.toFloat64() - 1.0; } result = getSceneCenterRefRow(xdoc, s); if (result) { dpt.y = s.toFloat64() - 1.0; } icp.push_back(dpt); result = getSceneCenterLat(xdoc, s); if (result) { gpt.lat = s.toFloat64(); } result = getSceneCenterLon(xdoc, s); if (result) { gpt.lon = s.toFloat64(); } gcp.push_back(gpt); ossimString path = "/level1Product/productInfo/sceneInfo/sceneCornerCoord"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { result = ossim::findFirstNode(ossimString("refRow"), xnodes[i], s); if (result) { dpt.y = s.toDouble() - 1.0; } result = ossim::findFirstNode(ossimString("refColumn"), xnodes[i], s); if (result) { dpt.x = s.toDouble() - 1.0; } icp.push_back(dpt); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "dpt" << i << ": " << dpt << "\n"; } result = ossim::findFirstNode(ossimString("lat"), xnodes[i], s); if (result) { gpt.lat = s.toFloat64(); } result = ossim::findFirstNode(ossimString("lon"), xnodes[i], s); if (result) { gpt.lon = s.toDouble(); } gcp.push_back(gpt); if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "gpt" << i << ": " << gpt << "\n"; } } // matches: if (xnodes[i].valid()) else { result = false; } } // mathches: for (ossim_uint32 i = 0; i < xnodes.size(); ++i) } // matches: if ( xnodes.size() ) else { result = false; // No nodes found. } } // matches: if (xdoc) else { result = false; // Null pointer passed in. } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " DEBUG: exit status = " << (result?"true":"false") << std::endl; } return result; } bool ossimplugins::ossimTerraSarProductDoc::isProductGeoreferenced( const ossimXmlDocument* xdoc) const { bool result = false; ossimString s; if ( getProjection(xdoc, s) ) { result = (s == "GROUNDRANGE"); } return result; } bool ossimplugins::ossimTerraSarProductDoc::getMission( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/generalHeader/mission"; ossim::getPath(path, xdoc, s); return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::geNumberOfLayers( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/imageDataInfo/numberOfLayers"; ossim::getPath(path, xdoc, s); return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getImageFile( const ossimXmlDocument* xdoc, ossimString& s) const { bool result = false; ossimString subDir; ossimString fileName; ossimString path = "/level1Product/productComponents/imageData/file/location/path"; if ( ossim::getPath(path, xdoc, subDir) ) { path = "/level1Product/productComponents/imageData/file/location/filename"; if ( ossim::getPath(path, xdoc, fileName) ) { result = true; s = subDir; s += "/"; s += fileName; } } return result; } bool ossimplugins::ossimTerraSarProductDoc::getSceneId( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneID"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getProjection( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/productVariantInfo/projection"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getProductType( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/productVariantInfo/productType"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getProductVariant( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/productVariantInfo/productVariant"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getRadiometricCorrection( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/productVariantInfo/radiometricCorrection"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getReferencePoint( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productSpecific/projectedImageInfo/slantToGroundRangeProjection/referencePoint"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getImageDataStrartWith( const ossimXmlDocument* xdoc, ossimString& s) const { bool result = true; ossimString path = "/level1Product/productSpecific/complexImageInfo"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { result = ossim::findFirstNode(ossimString("imageDataStartWith"), xnodes[i], s); } } } else { result=false; } return result; } bool ossimplugins::ossimTerraSarProductDoc::getOrbitDirection( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/missionInfo/orbitDirection"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getLookDirection( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/acquisitionInfo/lookDirection"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getGenerationTime( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/generalHeader/generationTime"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getRangeGateFirstPixel( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/rangeTime/firstPixel"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getRangeGateLastPixel( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/rangeTime/lastPixel"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getSceneCenterAzimuthTime( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord/azimuthTimeUTC"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getSceneCenterRangeTime( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord/rangeTime"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getSceneCenterRefColumn( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord/refColumn"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getSceneCenterRefRow( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord/refRow"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getSceneCenterLat( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord/lat"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getSceneCenterLon( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord/lon"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getSceneAverageHeight( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneAverageHeight"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getRadarCenterFrequency( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/instrument/radarParameters/centerFrequency"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getAzimuthStartTime( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/start/timeUTC"; bool res = ossim::getPath(path, xdoc, s); if(!res) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< "Node \"/level1Product/productInfo/sceneInfo/start/timeUTC\" invalid, trying \"/level1Product/instrument/settings/rxGainSetting/startTimeUTC\"...\n"; } path = "/level1Product/instrument/settings/rxGainSetting/startTimeUTC"; res = ossim::getPath(path, xdoc, s); } return res; } bool ossimplugins::ossimTerraSarProductDoc::getAzimuthStopTime( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/stop/timeUTC"; bool res = ossim::getPath(path, xdoc, s); if(!res) { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< "Node \"/level1Product/productInfo/sceneInfo/stop/timeUTC\" invalid, trying \"/level1Product/instrument/settings/rxGainSetting/stopTimeUTC\"...\n"; } path = "/level1Product/instrument/settings/settingRecord/dataSegment segmentID/stopTimeUTC"; res = ossim::getPath(path, xdoc, s); } return res; } bool ossimplugins::ossimTerraSarProductDoc::getRangeFirstPixelTime( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/rangeTime/firstPixel"; bool res = ossim::getPath(path, xdoc, s); return res; } bool ossimplugins::ossimTerraSarProductDoc::getRangeLastPixelTime( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/rangeTime/lastPixel"; bool res = ossim::getPath(path, xdoc, s); return res; } bool ossimplugins::ossimTerraSarProductDoc::getCommonPrf( const ossimXmlDocument* xdoc, ossimString& s) const { bool result = true; ossimString path = "/level1Product/productSpecific/complexImageInfo"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { result = ossim::findFirstNode(ossimString("commonPRF"), xnodes[i], s); } } } else { result=false; } return result; } bool ossimplugins::ossimTerraSarProductDoc::getCommonRsf( const ossimXmlDocument* xdoc, ossimString& s) const { bool result = true; ossimString path = "/level1Product/productSpecific/complexImageInfo"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { result = ossim::findFirstNode(ossimString("commonRSF"), xnodes[i], s); } } } else { result=false; } return result; } bool ossimplugins::ossimTerraSarProductDoc::getNumberOfRangeLooks( const ossimXmlDocument* xdoc, ossimString& s) const { bool result = true; ossimString path = "/level1Product/processing/processingParameter"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { result = ossim::findFirstNode(ossimString("rangeLooks"), xnodes[i], s); } } } else { result=false; } return result; } bool ossimplugins::ossimTerraSarProductDoc::getNumberOfAzimuthLooks( const ossimXmlDocument* xdoc, ossimString& s) const { bool result = true; ossimString path = "/level1Product/processing/processingParameter"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { result = ossim::findFirstNode(ossimString("azimuthLooks"), xnodes[i], s); } } } else { result=false; } return result; } bool ossimplugins::ossimTerraSarProductDoc::getNumberOfColumns( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/imageDataInfo/imageRaster/numberOfColumns"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getNumberOfRows( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/imageDataInfo/imageRaster/numberOfRows"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getColumnSpacing( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/imageDataInfo/imageRaster/columnSpacing"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getRowSpacing( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/imageDataInfo/imageRaster/rowSpacing"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getProjectedSpacingSlantRange( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productSpecific/complexImageInfo/projectedSpacingRange/slantRange"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getProjectedSpacingAzimuth( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productSpecific/complexImageInfo/projectedSpacingAzimuth"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getImagingMode( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/acquisitionInfo/imagingMode"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getAcquisitionSensor( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/acquisitionInfo/sensor"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getPolarisationMode( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/acquisitionInfo/polarisationMode"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getPolLayerList( const ossimXmlDocument* xdoc, std::vector& s) const { ossimString path = "/level1Product/productInfo/acquisitionInfo/polarisationList/polLayer"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getCalFactor( const ossimXmlDocument* xdoc, std::vector& s) const { ossimString path = "/level1Product/calibration/calibrationConstant/calFactor"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getRadarFrequency( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/instrument/radarParameters/centerFrequency"; return ossim::getPath(path, xdoc, s); } /*bool ossimplugins::ossimTerraSarProductDoc::getCenterIncidenceAngle( const ossimXmlDocument* xdoc, ossimString& s) const { ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord/incidenceAngle"; return ossim::getPath(path, xdoc, s); } bool ossimplugins::ossimTerraSarProductDoc::getCornerIncidenceAngles( const ossimXmlDocument* xdoc, std::vector& s) const { bool result = true; ossim_uint32 refRow = 0; ossim_uint32 refColumn = 0; double incidenceAngle = 0.; ossimString stmp; ossimString path = "/level1Product/productInfo/sceneInfo/sceneCornerCoord"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if (( xnodes.size() ) && (xnodes.size() == 4)) { for (ossim_uint32 i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { result = ossim::findFirstNode(ossimString("refRow"), xnodes[i], stmp); refRow = stmp.toUInt32(); result = ossim::findFirstNode(ossimString("refColumn"), xnodes[i], stmp); refColumn = stmp.toUInt32(); result = ossim::findFirstNode(ossimString("incidenceAngle"), xnodes[i], stmp); // values in vector are indexed with this order // 0 -> lower left // 1 -> upper left // 2 -> upper right // 3 -> lower right if (refRow == 1) { if (refColumn == 1) { s[0] = stmp; } else { s[3] = stmp; } } else { if (refColumn == 1) { s[1] = stmp; } else { s[2] = stmp; } } } } } else { result = false; } return result; }*/ bool ossimplugins::ossimTerraSarProductDoc::initSceneCoord(const ossimXmlDocument* xdoc, ossimplugins::SceneCoord* sceneCoord) const { static const char MODULE[] = "ossimplugins::ossimTerraSarProductDoc::initSceneCoord"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = true; if ( xdoc && sceneCoord ) { ossimString stmp; ossimString path = "/level1Product/productInfo/sceneInfo/sceneCenterCoord"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( (xnodes.size() == 1) && (xnodes[0].valid()) ) { InfoSceneCoord isc; result = ossim::findFirstNode(ossimString("refRow"), xnodes[0], stmp); isc.set_refRow( stmp.toUInt32() ); result = ossim::findFirstNode(ossimString("refColumn"), xnodes[0], stmp); isc.set_refColumn( stmp.toUInt32() ); result = ossim::findFirstNode(ossimString("lat"), xnodes[0], stmp); isc.set_lat( stmp.toDouble() ); result = ossim::findFirstNode(ossimString("lon"), xnodes[0], stmp); isc.set_lon( stmp.toDouble() ); result = ossim::findFirstNode(ossimString("azimuthTimeUTC"), xnodes[0], stmp); isc.set_azimuthTimeUTC( stmp ); result = ossim::findFirstNode(ossimString("rangeTime"), xnodes[0], stmp); isc.set_rangeTime( stmp.toDouble() ); result = ossim::findFirstNode(ossimString("incidenceAngle"), xnodes[0], stmp); isc.set_incidenceAngle( stmp.toDouble() ); sceneCoord->set_centerSceneCoord(isc); ossimString path2 = "/level1Product/productInfo/sceneInfo/sceneCornerCoord"; std::vector > xnodes2; xdoc->findNodes(path2, xnodes2); if ( xnodes2.size() ) { std::vector tabIsc; for (ossim_uint32 i = 0; i < xnodes2.size(); ++i) { if (xnodes2[i].valid()) { InfoSceneCoord isc2; result = ossim::findFirstNode(ossimString("refRow"), xnodes2[i], stmp); isc2.set_refRow( stmp.toUInt32() ); result = ossim::findFirstNode(ossimString("refColumn"), xnodes2[i], stmp); isc2.set_refColumn( stmp.toUInt32() ); result = ossim::findFirstNode(ossimString("lat"), xnodes[0], stmp); isc2.set_lat( stmp.toDouble() ); result = ossim::findFirstNode(ossimString("lon"), xnodes[0], stmp); isc2.set_lon( stmp.toDouble() ); result = ossim::findFirstNode(ossimString("azimuthTimeUTC"), xnodes[0], stmp); isc2.set_azimuthTimeUTC( stmp ); result = ossim::findFirstNode(ossimString("rangeTime"), xnodes[0], stmp); isc2.set_rangeTime( stmp.toDouble() ); result = ossim::findFirstNode(ossimString("incidenceAngle"), xnodes2[i], stmp); isc2.set_incidenceAngle( stmp.toDouble() ); tabIsc.push_back(isc2); } } sceneCoord->set_cornersSceneCoord( tabIsc ); sceneCoord->set_numberOfSceneCoord( tabIsc.size() ); } } else { result = false; } } return result; } bool ossimplugins::ossimTerraSarProductDoc::initNoise( const ossimXmlDocument* xdoc, ossimplugins::Noise* noise) const { static const char MODULE[] = "ossimplugins::ossimTerraSarProductDoc::initImageNoise"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG)<< MODULE << " entered...\n"; } bool result = true; if ( xdoc && noise ) { ossimString path = "/level1Product/noise/numberOfNoiseRecords"; ossimString s; ossim::getPath(path, xdoc, s); std::vector tabImageNoise; tabImageNoise.clear(); noise->set_numberOfNoiseRecords(s.toInt32()); // Get all the stateVector nodes. path = "/level1Product/noise/imageNoise"; std::vector > xnodes; xdoc->findNodes(path, xnodes); if ( xnodes.size() ) { const std::vector >::size_type COUNT = xnodes.size(); // ossim::iso8601TimeStringToCivilDate( int nbrData = 0; // to keep track of good stateVector count. ossimRefPtr svNode = 0; // stateVector node for (ossim_uint32 i = 0 ; i < COUNT; ++i) { ImageNoise ev; svNode = xnodes[i]; if ( !svNode ) { result = false; break; } ossimString s; path = "timeUTC"; result = ossim::findFirstNode(path, svNode, s); if (result) { ev.set_timeUTC(s); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "noiseEstimate/validityRangeMin"; result = ossim::findFirstNode(path, svNode, s); if (result) { ev.set_validityRangeMin( s.toDouble() ); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "noiseEstimate/validityRangeMax"; result = ossim::findFirstNode(path, svNode, s); if (result) { ev.set_validityRangeMax( s.toDouble() ); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "noiseEstimate/referencePoint"; result = ossim::findFirstNode(path, svNode, s); if (result) { ev.set_referencePoint( s.toDouble() ); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } path = "noiseEstimate/polynomialDegree"; result = ossim::findFirstNode(path, svNode, s); if (result) { ev.set_polynomialDegree( s.toInt32() ); } else { result = false; ossimNotify(ossimNotifyLevel_WARN) << MODULE << " ERROR:\nNode not found: " << path << std::endl; break; } //Read Coefficient ossimXmlNode::ChildListType nodelist; svNode->findChildNodes("noiseEstimate/coefficient",nodelist); ossimXmlNode::ChildListType::const_iterator child_iter = nodelist.begin(); std::vector polynomialCoefficients; while(child_iter != nodelist.end()) { double coefficient = ((*child_iter)->getText()).toDouble() ; polynomialCoefficients.push_back(coefficient); ++child_iter; } ev.set_polynomialCoefficients( polynomialCoefficients ); tabImageNoise.push_back(ev); ++nbrData; } // matches: for (ossim_uint32 i = 0 ; i < COUNT; ++i) noise->set_imageNoise(tabImageNoise); } // matches: if ( xnodes.size() ) } // matches: if (xdoc && pos) else { result = false; } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true\n":"false\n"); } return result; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarProductDoc.h000066400000000000000000000244561301006202600304460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: David Burken // // Description: Utility class to encapsulate parsing TerraSAR-X product.xml // file. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimTerraSarProductDoc_HEADER #define ossimTerraSarProductDoc_HEADER 1 #include #include #include #include #include // Forward class declarations outside of namespace ossimplugins. class ossimDpt; class ossimGpt; class ossimIpt; class ossimXmlDocument; class ossimXmlNode; class ossimString; namespace ossimplugins { // Forward class declarations inside of namespace ossimplugins. class CivilDateTime; class PlatformPosition; class RefPoint; class SensorParams; class Noise; class SceneCoord; /** @brief Class to encapsulate parsing TerraSAR product xml file. */ class ossimTerraSarProductDoc { public: /** @brief default constructor */ ossimTerraSarProductDoc(); /** @brief destructor */ ~ossimTerraSarProductDoc(); /** * @brief Checks for node /level1Product/generalHeader/mission containing * "TSX-1". * * @return true if present, false if not. */ bool isTerraSarX(const ossimXmlDocument* xdoc) const; /** * @brief Method to initialize PlatformPosition object from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @param pos Pointer to PlatformPosition object. * @return true on success, false on error. */ bool initPlatformPosition(const ossimXmlDocument* xdoc, PlatformPosition* pos) const; /** * @brief Method to initialize SensorParams object from * TerraSAR product xml file. * @param xdoc Opened product.xml file. * @param sp Pointer to SensorParams object. * @return true on success, false on error. */ bool initSensorParams(const ossimXmlDocument* xdoc, SensorParams* sp) const; /** * @brief Method to initialize image size from * TerraSAR product xml file. * @param xdoc Opened product.xml file. * @param imageSize The point to initialize. * @return true on success, false on error. */ bool initImageSize(const ossimXmlDocument* xdoc, ossimIpt& imageSize) const; /** * @brief Method to initialize gsd from * TerraSAR product xml file. * @param xdoc Opened product.xml file. * @param gsd The point to initialize. * @return true on success, false on error. */ bool initGsd(const ossimXmlDocument* xdoc, ossimDpt& gsd) const; /** * @brief Method to initialize image tie points from * TerraSAR product xml file. * @param xdoc Opened product.xml file. * @param imageSize The point to initialize. * @return true on success, false on error. */ bool initTiePoints(const ossimXmlDocument* xdoc, std::list& gcp, std::list& icp) const; bool isProductGeoreferenced(const ossimXmlDocument* xdoc) const; bool getMission(const ossimXmlDocument* xdoc, ossimString& s) const; bool geNumberOfLayers(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageFile(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSceneId(const ossimXmlDocument* xdoc, ossimString& s) const; bool getProjection(const ossimXmlDocument* xdoc, ossimString& s) const; bool getReferencePoint(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageDataStrartWith(const ossimXmlDocument* xdoc, ossimString& s) const; bool getOrbitDirection(const ossimXmlDocument* xdoc, ossimString& s) const; bool getLookDirection(const ossimXmlDocument* xdoc, ossimString& s) const; bool getGenerationTime(const ossimXmlDocument* xdoc, ossimString& s) const; /** one based??? */ bool getRangeGateFirstPixel(const ossimXmlDocument* xdoc, ossimString& s) const; /** one based??? */ bool getRangeGateLastPixel(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSceneCenterAzimuthTime(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSceneCenterRangeTime(const ossimXmlDocument* xdoc, ossimString& s) const; /** one based */ bool getSceneCenterRefColumn(const ossimXmlDocument* xdoc, ossimString& s) const; /** one based */ bool getSceneCenterRefRow(const ossimXmlDocument* xdoc, ossimString& s) const; /** latitude */ bool getSceneCenterLat(const ossimXmlDocument* xdoc, ossimString& s) const; /** longitude */ bool getSceneCenterLon(const ossimXmlDocument* xdoc, ossimString& s) const; bool getSceneAverageHeight(const ossimXmlDocument* xdoc, ossimString& s) const; bool getRadarCenterFrequency(const ossimXmlDocument* xdoc, ossimString& s) const; bool getAzimuthStartTime(const ossimXmlDocument* xdoc, ossimString& s) const; bool getAzimuthStopTime(const ossimXmlDocument* xdoc, ossimString& s) const; bool getRangeFirstPixelTime(const ossimXmlDocument* xdoc, ossimString& s) const; bool getRangeLastPixelTime(const ossimXmlDocument* xdoc, ossimString& s) const; bool getCommonPrf(const ossimXmlDocument* xdoc, ossimString& s) const; /** range sampling rate */ bool getCommonRsf(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfRangeLooks(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfAzimuthLooks(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfColumns(const ossimXmlDocument* xdoc, ossimString& s) const; bool getNumberOfRows(const ossimXmlDocument* xdoc, ossimString& s) const; bool getColumnSpacing(const ossimXmlDocument* xdoc, ossimString& s) const; bool getRowSpacing(const ossimXmlDocument* xdoc, ossimString& s) const; bool getProjectedSpacingSlantRange(const ossimXmlDocument* xdoc, ossimString& s) const; bool getProjectedSpacingAzimuth(const ossimXmlDocument* xdoc, ossimString& s) const; bool getGeodeticTerrainHeight(const ossimXmlDocument* xdoc, ossimString& s) const; bool getProductType(const ossimXmlDocument* xdoc, ossimString& s) const; bool getProductVariant(const ossimXmlDocument* xdoc, ossimString& s) const; bool getRadiometricCorrection(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImagingMode(const ossimXmlDocument* xdoc, ossimString& s) const; bool getAcquisitionSensor(const ossimXmlDocument* xdoc, ossimString& s) const; bool getPolarisationMode(const ossimXmlDocument* xdoc, ossimString& s) const; bool getPolLayerList(const ossimXmlDocument* xdoc, std::vector& s) const; bool getCalFactor(const ossimXmlDocument* xdoc, std::vector& s) const; bool getRadarFrequency(const ossimXmlDocument* xdoc, ossimString& s) const; /* bool getCenterIncidenceAngle(const ossimXmlDocument* xdoc, ossimString& s) const; bool getCornerIncidenceAngles(const ossimXmlDocument* xdoc, std::vector& s) const; */ /** * @brief Method to initialize IncidenceAngles object from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @param pos Pointer to PlatformPosition object. * @return true on success, false on error. */ bool initSceneCoord(const ossimXmlDocument* xdoc, SceneCoord* pos) const; /** * @brief Method to initialize Noise object from * TerraSAR product xml file. * @param xdoc Opened product xml file. * @param pos Pointer to PlatformPosition object. * @return true on success, false on error. */ bool initNoise(const ossimXmlDocument* xdoc, Noise* pos) const; /* bool getImageNoiseTimeUTC(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageNoiseValidityRangeMin(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageNoiseValidityRangeMax(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageNoiseReferencePoint(const ossimXmlDocument* xdoc, ossimString& s) const; bool getImageNoisePolynomialCoefficient( const ossimXmlDocument* xdoc, std::vector& polynomialCoefficient) const; */ }; } // End: namespace ossimplugins #endif /* matches: #ifndef ossimTerraSarProductDoc_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarTiffReader.cpp000066400000000000000000000220531301006202600307350ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: See top level LICENSE.txt file // // Author: David Burken // // Description: Image handelr for TerraSar-X data that is TIFF based. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Keyword constants: static const char PRODUCT_XML_FILE_KW[] = "product_xml_filename"; namespace ossimplugins { RTTI_DEF1(ossimTerraSarTiffReader, "ossimTerraSarTiffReader", ossimTiffTileSource) } #ifdef OSSIM_ID_ENABLED static const char OSSIM_ID[] = "$Id$"; #endif static ossimTrace traceDebug("ossimTerraSarTiffReader:degug"); ossimplugins::ossimTerraSarTiffReader::ossimTerraSarTiffReader() : ossimTiffTileSource() { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimplugins::ossimTerraSarTiffReader::ossimTerraSarTiffReader entered...\n"; #ifdef OSSIM_ID_ENABLED ossimNotify(ossimNotifyLevel_DEBUG) << "OSSIM_ID: " << OSSIM_ID << std::endl; #endif } } ossimplugins::ossimTerraSarTiffReader::~ossimTerraSarTiffReader() { } bool ossimplugins::ossimTerraSarTiffReader::saveState( ossimKeywordlist& kwl, const char* prefix) const { static const char MODULE[] = "ossimplugins::ossimTerraSarTiffReader::saveState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } // Save our state: kwl.add(prefix, PRODUCT_XML_FILE_KW, theProductXmlFile.c_str()); // Save the base: return ossimTiffTileSource::saveState(kwl, prefix); } bool ossimplugins::ossimTerraSarTiffReader::loadState( const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "ossimplugins::ossimTerraSarTiffReader::loadState"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } bool result = false; // Get the product.xml file name. const char* lookup = kwl.find(prefix, PRODUCT_XML_FILE_KW); if (lookup) { theProductXmlFile = lookup; if ( isTerraSarProductFile(theProductXmlFile) ) { //--- // Although we can open any tiff here we only do if we have matching // TerraSAR-X product.xml. //--- result = ossimTiffTileSource::loadState(kwl, prefix); } } if (!result) { theProductXmlFile.clear(); } if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } ossimString ossimplugins::ossimTerraSarTiffReader::getShortName()const { return ossimString("ossim_terrasar_tiff_reader"); } ossimString ossimplugins::ossimTerraSarTiffReader::getLongName()const { return ossimString("ossim TerraSAR-X tiff reader"); } ossimString ossimplugins::ossimTerraSarTiffReader::getClassName()const { return ossimString("ossimTerraSarTiffReader"); } bool ossimplugins::ossimTerraSarTiffReader::open(const ossimFilename& file) { static const char MODULE[] = "ossimplugins::ossimTerraSarTiffReader::open"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n" << "file: " << file << "\n"; } bool result = false; if ( isOpen() ) { close(); } // Check extension to see if it's xml. if ( file.ext().downcase() == "xml" ) { ossimRefPtr xdoc = new ossimXmlDocument(); if ( xdoc->openFile(file) ) { // See if it's a TerraSAR-X product xml file. if ( isTerraSarProductFile( xdoc.get() ) ) { ossimString s; ossimTerraSarProductDoc helper; if ( helper.getImageFile(xdoc.get(), s) ) { ossimFilename imageFile = file.expand().path(); imageFile = imageFile.dirCat(s); setFilename(imageFile); result = ossimTiffTileSource::open(); if (result) { theProductXmlFile = file; completeOpen(); } } } } } // matches: if ( file.ext().downcase() == "xml" ) if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exit status = " << (result?"true":"false\n") << std::endl; } return result; } void ossimplugins::ossimTerraSarTiffReader::close() { theProductXmlFile.clear(); ossimTiffTileSource::close(); } ossimRefPtr ossimplugins::ossimTerraSarTiffReader::getImageGeometry() { if ( !theGeometry ) { // Check for external geom: theGeometry = getExternalImageGeometry(); if ( !theGeometry ) { // Check the internal geometry first to avoid a factory call. theGeometry = getInternalImageGeometry(); // At this point it is assured theGeometry is set. //--- // WARNING: // Must create/set theGeometry at this point or the next call to // ossimImageGeometryRegistry::extendGeometry will put us in an infinite loop // as it does a recursive call back to ossimImageHandler::getImageGeometry(). //--- // Check for set projection. if ( !theGeometry->getProjection() ) { // Try factories for projection. ossimImageGeometryRegistry::instance()->extendGeometry(this); } } // Set image things the geometry object should know about. initImageParameters( theGeometry.get() ); } return theGeometry; } ossimRefPtr ossimplugins::ossimTerraSarTiffReader::getInternalImageGeometry() const { static const char MODULE[] = "ossimplugins::ossimTerraSarTiffReader::getInternalImageGeometry"; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } ossimRefPtr geom = new ossimImageGeometry(); ossimRefPtr xdoc = new ossimXmlDocument(); if ( xdoc->openFile(theProductXmlFile) ) { ossimTerraSarProductDoc helper; ossimString s; if ( helper.getProjection(xdoc.get(), s) ) { s.upcase(); if ( s == "GROUNDRANGE" ) { ossimRefPtr model = new ossimTerraSarModel(); if ( model->open(theProductXmlFile) ) { // Assign the model to our ossimImageGeometry object. geom->setProjection( model.get() ); } } else if ( (s == "MAP") && theTiffPtr ) { ossimGeoTiff geotiff; //--- // Note: must pass false to readTags so it doesn't close our // tiff pointer. //--- geotiff.readTags(theTiffPtr, getCurrentEntry(), false); ossimKeywordlist kwl; if(geotiff.addImageGeometry(kwl)) { ossimRefPtr proj = ossimProjectionFactoryRegistry::instance()-> createProjection(kwl); if ( proj.valid() ) { // Assign projection to our ossimImageGeometry object. geom->setProjection( proj.get() ); } } } else { if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "WARNING: Unhandled projection: " << s << std::endl; } } } } // matches: if ( xdoc->openFile(theProductXmlFile) ) if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " exited..." << std::endl; } return geom; } bool ossimplugins::ossimTerraSarTiffReader::isTerraSarProductFile( const ossimFilename& file) const { bool result = false; // Check extension to see if it's xml. if ( file.ext().downcase() == "xml" ) { ossimRefPtr xdoc = new ossimXmlDocument(); if ( xdoc->openFile(file) ) { result = isTerraSarProductFile( xdoc.get() ); } } return result; } bool ossimplugins::ossimTerraSarTiffReader::isTerraSarProductFile( const ossimXmlDocument* xdoc) const { bool result = false; if (xdoc) { ossimTerraSarProductDoc helper; // See if it's a TerraSAR-X product xml file. result = helper.isTerraSarX(xdoc); } return result; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarTiffReader.h000066400000000000000000000062531301006202600304060ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: David Burken // // Description: Image handelr for TerraSar-X data that is TIFF based. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimTerraSarTiffReader_HEADER #define ossimTerraSarTiffReader_HEADER 1 #include #include // Forward class declarations outside of namespace ossimplugins. class ossimXmlDocument; namespace ossimplugins { class ossimTerraSarTiffReader : public ossimTiffTileSource { public: /** default constructor */ ossimTerraSarTiffReader(); /** virtual destructor */ virtual ~ossimTerraSarTiffReader(); /** @return "terrasarx" */ virtual ossimString getShortName() const; /** @return "ossim TerraSAR-X reader" */ virtual ossimString getLongName() const; /** @return "ossimTerraSarTiffReader" */ virtual ossimString getClassName() const; /** * This open take the product xml file. * * @param file File to open. * * @return true on success, false on error. */ virtual bool open(const ossimFilename& file); /** * Method to save the state of an object to a keyword list. * Return true if ok or false on error. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0)const; /** * Method to the load (recreate) the state of an object from a keyword * list. Return true if ok or false on error. */ virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=0); /** Close method. */ virtual void close(); /** * Returns the image geometry object associated with this tile source or * NULL if non defined. The geometry contains full-to-local image * transform as well as projection (image-to-world). */ virtual ossimRefPtr getImageGeometry(); /** * @param Method to get geometry from the xml file or internal geotiff * tags. */ virtual ossimRefPtr getInternalImageGeometry() const; private: /** * @brief Method to check file to see if it's a TerraSAR-X product * xml file. * @param file The file to check. * @return true on success, false on error. */ bool isTerraSarProductFile(const ossimFilename& file) const; /** * @brief Method to check file to see if it's a TerraSAR-X product * xml file. * @param xdoc XML document opened up to product.xml file. * @return true on success, false on error. */ bool isTerraSarProductFile(const ossimXmlDocument* xdoc) const; ossimFilename theProductXmlFile; TYPE_DATA }; } // End: namespace ossimplugins #endif /* #ifndef ossimTerraSarTiffReader_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarXSarSensorModel.cpp000066400000000000000000000171531301006202600317570ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace {// Anonymous namespace const ossimString attTimeUTC = "timeUTC"; const ossimString attPosX = "posX"; const ossimString attPosY = "posY"; const ossimString attPosZ = "posZ"; const ossimString attVelX = "velX"; const ossimString attVelY = "velY"; const ossimString attVelZ = "velZ"; const ossimString attT = "t"; const ossimString attTau = "tau"; const ossimString attCol = "col"; const ossimString attRow = "row"; const ossimString attLat = "lat"; const ossimString attLon = "lon"; const ossimString attHeight = "height"; }// Anonymous namespace void ossimplugins::ossimTerraSarXSarSensorModel::readAnnotationFile(const std::string & annotationXml, const std::string & geoXml) { ossimRefPtr xmlDoc = new ossimXmlDocument(annotationXml); const ossimXmlNode & xmlRoot = *xmlDoc->getRoot(); //isGRD parse variant? std::string const& product_type = getTextFromFirstNode(xmlRoot, "productInfo/productVariantInfo/productVariant"); std::cout << "type " << product_type << '\n'; theProductType = ProductType(product_type); // First, lookup position/velocity records std::vector > xnodes; xmlDoc->findNodes("/level1Product/platform/orbit/stateVec",xnodes); std::cout << "Number of states " << xnodes.size() << '\n'; for(std::vector >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode) { OrbitRecordType orbitRecord; // Retrieve acquisition time orbitRecord.azimuthTime = getTimeFromFirstNode(**itNode, attTimeUTC); // Retrieve ECEF position orbitRecord.position[0] = getDoubleFromFirstNode(**itNode, attPosX); orbitRecord.position[1] = getDoubleFromFirstNode(**itNode, attPosY); orbitRecord.position[2] = getDoubleFromFirstNode(**itNode, attPosZ); // Retrieve ECEF velocity orbitRecord.velocity[0] = getDoubleFromFirstNode(**itNode, attVelX); orbitRecord.velocity[1] = getDoubleFromFirstNode(**itNode, attVelY); orbitRecord.velocity[2] = getDoubleFromFirstNode(**itNode, attVelZ); //Add one orbits record std::cout << "Add theOrbitRecords\n"; theOrbitRecords.push_back(orbitRecord); } //Parse the near range time (in seconds) theNearRangeTime = getDoubleFromFirstNode(xmlRoot, "productInfo/sceneInfo/rangeTime/firstPixel"); std::cout << "theNearRangeTime " << theNearRangeTime << '\n'; //Parse the range sampling rate theRangeSamplingRate = getDoubleFromFirstNode(xmlRoot, "instrument/settings/RSF"); std::cout << "theRangeSamplingRate " << theRangeSamplingRate << '\n'; //Parse the range resolution theRangeResolution = getDoubleFromFirstNode(xmlRoot, "productSpecific/complexImageInfo/slantRangeResolution"); std::cout << "theRangeResolution " << theRangeResolution << '\n'; //Parse the radar frequency theRadarFrequency = getDoubleFromFirstNode(xmlRoot, "instrument/settings/settingRecord/PRF"); std::cout << "theRadarFrequency " << theRadarFrequency << '\n'; //Manage only strip map product for now (one burst) //Parse azimuth time start/stop const TimeType azimuthTimeStart = getTimeFromFirstNode(xmlRoot, "productInfo/sceneInfo/start/timeUTC"); std::cout << "azimuthTimeStart " << azimuthTimeStart << '\n'; const TimeType azimuthTimeStop = getTimeFromFirstNode(xmlRoot, "productInfo/sceneInfo/stop/timeUTC"); std::cout << "azimuthTimeStop " << azimuthTimeStop << '\n'; const DurationType td = azimuthTimeStop - azimuthTimeStart; // numberOfRows unsigned int numberOfRows = xmlRoot.findFirstNode("productInfo/imageDataInfo/imageRaster/numberOfRows")->getText().toUInt16(); std::cout << "numberOfRows " << numberOfRows << '\n'; //Compute azimuth time interval theAzimuthTimeInterval = td / static_cast (numberOfRows); std::cout << "theAzimuthTimeInterval " << theAzimuthTimeInterval.total_microseconds() << " and 1/prf: " << (1 / theRadarFrequency) * 1000000 << '\n'; //For Terrasar-X only 1 burst is supported for now BurstRecordType burstRecord; burstRecord.startLine = 0; burstRecord.azimuthStartTime = azimuthTimeStart; burstRecord.azimuthStopTime = azimuthTimeStop; burstRecord.endLine = numberOfRows - 1; theBurstRecords.push_back(burstRecord); //GRD (detected product) if(isGRD()) { //Retrieve Slant Range to Ground range coeddifcients CoordinateConversionRecordType coordRecord; //Get azimuth time start (again) coordRecord.azimuthTime = azimuthTimeStart; //Set ground range origin to 0 (FIXME?) coordRecord.rg0 = 0.; //Read coefficients xnodes.clear(); const unsigned int polynomialDegree = xmlRoot.findFirstNode("productSpecific/projectedImageInfo/slantToGroundRangeProjection/polynomialDegree")->getText().toUInt16(); std::cout << "Number of coefficients " << polynomialDegree << '\n'; ossimString path = "/level1Product/productSpecific/projectedImageInfo/slantToGroundRangeProjection/coefficient"; const ossimString EXP = "exponent"; ossimString s; xmlDoc->findNodes(path, xnodes); if ( xnodes.size() ) { for (unsigned int i = 0; i < xnodes.size(); ++i) { if (xnodes[i].valid()) { xnodes[i]->getAttributeValue(s, EXP); const double coeff = xnodes[i]->getText().toDouble(); coordRecord.coefs.push_back(coeff); std::cout << "Coef number " << i << " value: " << coeff << '\n'; } } } assert(!coordRecord.coefs.empty()&&"The srgr record has empty coefs vector."); theSlantRangeToGroundRangeRecords.push_back(coordRecord); } //Parse GCPs ossimRefPtr xmlGeo = new ossimXmlDocument(geoXml); xnodes.clear(); xmlGeo->findNodes("/geoReference/geolocationGrid/gridPoint",xnodes); std::cout<<"Found "< >::iterator itNode = xnodes.begin(); itNode!=xnodes.end();++itNode) { GCPRecordType gcpRecord; // Get delta acquisition time const double deltaAzimuth = getDoubleFromFirstNode(**itNode, attT); #if defined(USE_BOOST_TIME) using boost::posix_time::microseconds; #else using ossimplugins::time::microseconds; #endif gcpRecord.azimuthTime = azimuthTimeStart + microseconds(deltaAzimuth * 1000000); //Get delta range time gcpRecord.slantRangeTime = theNearRangeTime + getDoubleFromFirstNode(**itNode, attTau); gcpRecord.imPt.x = getDoubleFromFirstNode(**itNode, attCol) - 1.; gcpRecord.imPt.y = getDoubleFromFirstNode(**itNode, attRow) - 1.; ossimGpt geoPoint; gcpRecord.worldPt.lat = getDoubleFromFirstNode(**itNode, attLat); gcpRecord.worldPt.lon = getDoubleFromFirstNode(**itNode, attLon); gcpRecord.worldPt.hgt = getDoubleFromFirstNode(**itNode, attHeight); theGCPRecords.push_back(gcpRecord); } this->optimizeTimeOffsetsFromGcps(); } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTerraSarXSarSensorModel.h000066400000000000000000000026501301006202600314200ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimTerraSarXSarSensorModel_HEADER #define ossimTerraSarXSarSensorModel_HEADER #include "ossimSarSensorModel.h" namespace ossimplugins { class OSSIM_PLUGINS_DLL ossimTerraSarXSarSensorModel : public ossimSarSensorModel { public: #if ! (defined(BOOST_NO_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX1_DEFAULTED_FUNCTIONS)) /** Constructor */ ossimTerraSarXSarSensorModel() = default; /** Copy constructor */ ossimTerraSarXSarSensorModel(ossimTerraSarXSarSensorModel const& m) = default; /** Move constructor */ ossimTerraSarXSarSensorModel(ossimTerraSarXSarSensorModel && m) = default; /** Destructor */ virtual ~ossimTerraSarXSarSensorModel() = default; #endif //Not implemented yet /** References * TerraSAR-X Image Product Guide * SNAP source code (s1tbx-io/src/main/java/org/esa/s1tbx/io/terrasarx/TerraSarXProductDirectory.java) */ void readAnnotationFile(const std::string & annotationXml, const std::string & geoXml); protected: /* std::string theProductType; std::string theMode; std::string theSwath; std::string thePolarisation; */ }; } // end namespace #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTileMapModel.cpp000066400000000000000000000230451301006202600275740ustar00rootroot00000000000000//******************************************************************* // // License: See top level LICENSE.txt file. // // AUTHOR: Jordi Inglada // // DESCRIPTION: // // SOFTWARE HISTORY: // 23JAN2008 Jordi Inglada, CNES // Initial coding. // //***************************************************************************** #include "ossimTileMapModel.h" #include #include #include #include //*** // Define Trace flags for use within this file: //*** #include static ossimTrace traceExec ("ossimTileMapModel:exec"); static ossimTrace traceDebug ("ossimTileMapModel:debug"); namespace ossimplugins { RTTI_DEF1(ossimTileMapModel, "ossimTileMapModel", ossimSensorModel); //***************************************************************************** // DEFAULT CONSTRUCTOR: ossimTileMapModel() // //***************************************************************************** ossimTileMapModel::ossimTileMapModel() : ossimSensorModel(), qDepth (1) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::ossimTileMapModel: entering..." << std::endl; // initAdjustableParameters(); // std::cout << "TileMapModel constructor" << std::endl; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::ossimTileMapModel: returning..." << std::endl; } bool ossimTileMapModel::open(const ossimFilename& file) { static const char MODULE[] = "ossimTileMapModel::open"; ossimString os = file.beforePos(4); if (traceDebug()) { CLOG << " Entered..." << std::endl << " trying to open file " << file << std::endl; } if(os == "http" || file.ext() == "otb") { return true; } return false; } //***************************************************************************** // CONSTRUCTOR: ossimTileMapModel(kwl) // // Constructs model from keywordlist geometry file // //***************************************************************************** ossimTileMapModel::ossimTileMapModel(const ossimKeywordlist& geom_kwl) : ossimSensorModel(), qDepth (1) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::ossimTileMapModel(geom_kwl): entering..." << std::endl; //*** // Parse keywordlist for geometry: //*** loadState(geom_kwl); if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::ossimTileMapModel(geom_kwl): Exited..." << std::endl; } //***************************************************************************** // COPY CONSTRUCTOR: //***************************************************************************** ossimTileMapModel::ossimTileMapModel(const ossimTileMapModel& rhs) : ossimSensorModel (rhs), qDepth (rhs.qDepth) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::ossimTileMapModel(rhs): entering..." << std::endl; //initAdjustableParameters(); if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::ossimTileMapModel(rhs): returning..." << std::endl; } //***************************************************************************** // METHOD: ossimTileMapModel::lineSampleHeightToWorld() // // Performs the line/sample to groundpoint projection given an elevation. // //***************************************************************************** void ossimTileMapModel::lineSampleToWorld(const ossimDpt& image_point, ossimGpt& gpt) const { lineSampleHeightToWorld(image_point, 0.0, gpt); } void ossimTileMapModel::lineSampleHeightToWorld(const ossimDpt& image_point, const double& /* height */, ossimGpt& gpt) const { if(!image_point.hasNans()) { gpt.lon = static_cast(image_point.samp)/(1 << qDepth)/256 *360.0-180.0; double y = static_cast(image_point.line)/(1 << qDepth)/256; double ex = exp(4*M_PI*(y-0.5)); gpt.lat = -180.0/M_PI*asin((ex-1)/(ex+1)); } else { gpt.makeNan(); } return; } void ossimTileMapModel::worldToLineSample(const ossimGpt& ground_point, ossimDpt& img_pt) const { // if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::worldToLineSample(): entering..." << std::endl; if(ground_point.isLatNan() || ground_point.isLonNan() ) { img_pt.makeNan(); return; } double x = (180.0 + ground_point.lon) / 360.0; double y = - ground_point.lat * M_PI / 180; // convert to radians y = 0.5 * log((1+sin(y)) / (1 - sin(y))); y *= 1.0/(2 * M_PI); // scale factor from radians to normalized y += 0.5; // and make y range from 0 - 1 img_pt.samp = floor(x*pow(2.,static_cast(qDepth))*256); img_pt.line = floor(y*pow(2.,static_cast(qDepth))*256); return; } //***************************************************************************** // METHOD: ossimTileMapModel::print() // // Formatted dump of data members. // //***************************************************************************** std::ostream& ossimTileMapModel::print(std::ostream& os) const { os << "\nDump of ossimTileMapModel object at " << hex << this << ":\n" << "\nTileMapModel -- Dump of all data members: " << "\n theImageID: " << theImageID.chars() << "\n theImageSize: " << theImageSize << "\n theRefImgPt: " << theRefImgPt << "\n theRefGndPt: " << theRefGndPt << "\n theGSD.line: " << theGSD.line << "\n theGSD.samp: " << theGSD.samp << "\n qDepth: " << qDepth << endl; return ossimSensorModel::print(os); } //***************************************************************************** // METHOD: ossimTileMapModel::saveState() // // Saves the model state to the KWL. This KWL also serves as a geometry file. // //***************************************************************************** bool ossimTileMapModel::saveState(ossimKeywordlist& kwl, const char* prefix) const { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::saveState: entering..." << std::endl; kwl.add(prefix, ossimKeywordNames::TYPE_KW, TYPE_NAME(this)); kwl.add(prefix, "depth", qDepth); //*** // Hand off to base class for common stuff: //*** ossimSensorModel::saveState(kwl, prefix); if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::saveState: returning..." << std::endl; return true; } //***************************************************************************** // METHOD: ossimTileMapModel::loadState() // // Restores the model's state from the KWL. This KWL also serves as a // geometry file. // //***************************************************************************** bool ossimTileMapModel::loadState(const ossimKeywordlist& kwl, const char* prefix) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::loadState: entering..." << std::endl; if (traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::loadState:" << "\nInput kwl: " << kwl << std::endl; } const char* value = NULL; //const char* keyword =NULL; bool success; //*** // Assure this keywordlist contains correct type info: //*** value = kwl.find(prefix, ossimKeywordNames::TYPE_KW); if (!value || (strcmp(value, TYPE_NAME(this)))) { theErrorStatus = 1; return false; } value = kwl.find(prefix, "depth"); qDepth = atoi(value); //*** // Pass on to the base-class for parsing first: //*** success = ossimSensorModel::loadState(kwl, prefix); if (!success) { theErrorStatus++; return false; } updateModel(); if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::loadState: returning..." << std::endl; return true; } //***************************************************************************** // STATIC METHOD: ossimTileMapModel::writeGeomTemplate // // Writes a sample kwl to output stream. // //***************************************************************************** void ossimTileMapModel::writeGeomTemplate(ostream& os) { if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::writeGeomTemplate: entering..." << std::endl; os << "//**************************************************************\n" "// Template for TileMap model keywordlist\n" "//**************************************************************\n" << ossimKeywordNames::TYPE_KW << ": " << "ossimTileMapModel" << endl; if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::writeGeomTemplate: returning..." << std::endl; return; } } // End: namespace ossimplugins OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTileMapModel.h000066400000000000000000000104111301006202600272320ustar00rootroot00000000000000//******************************************************************* // // License: See top level LICENSE.txt file. // // DESCRIPTION: Contains declaration of TileMap sensor model class. // // SOFTWARE HISTORY: // 23JAN2008 Jordi Inglada, CNES // Initial coding. // //***************************************************************************** // $Id: ossimTileMapModel.h 10384 2007-01-26 20:32:12Z gpotts $ #ifndef ossimTileMapModel_HEADER #define ossimTileMapModel_HEADER #include #include #include #include #include #include #include class ossimMapProjection; namespace ossimplugins { //****************************************************************************** //* //* CLASS: ossimTileMapModel //* //******************************************************************************* class OSSIM_PLUGINS_DLL ossimTileMapModel : public ossimSensorModel { public: /*! * CONSTRUCTORS: */ using ossimOptimizableProjection::operator=; ossimTileMapModel(); ossimTileMapModel(const ossimKeywordlist& geom_kwl); ossimTileMapModel(const ossimTileMapModel& rhs); virtual ~ossimTileMapModel(){}; enum ProjectionType { UNKNOWN_PROJECTION = 0, UTM_MAP, UTM_ORBIT, SOM_MAP, SOM_ORBIT }; /*! * Returns pointer to a new instance, copy of this. */ virtual ossimObject* dup() const { return 0; } // TBR /*! * Extends base-class implementation. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; bool open(const ossimFilename& file); /*! * Fulfills ossimObject base-class pure virtuals. Loads and saves geometry * KWL files. Returns true if successful. */ virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=0); /*! * Writes a template of geom keywords processed by loadState and saveState * to output stream. */ static void writeGeomTemplate(ostream& os); //*** // Overrides base class pure virtual. //*** virtual void worldToLineSample(const ossimGpt& ground_point, ossimDpt& img_pt) const; virtual void lineSampleHeightToWorld(const ossimDpt& image_point, const double& heightEllipsoid, ossimGpt& worldPoint) const; virtual void lineSampleToWorld(const ossimDpt& image_point, ossimGpt& worldPoint) const; /*! * Set/Get the depth of the quadtree decomposition * */ void setDepth(unsigned int depth){ qDepth = depth; } unsigned int getDepth() { return qDepth; } /*! * ossimOptimizableProjection */ inline virtual bool useForward()const {return true;} //!image to ground faster protected: //*** // Image constant parameters: //*** double theIllumAzimuth; double theIllumElevation; double theOrbitAltitude; double theOrbitInclination; int theMapZone; ossimDpt theMapOffset; int theWrsPathNumber; int theWrsRowNumber; double theMeridianalAngle; double thePositionError; ProjectionType theProjectionType; ossimRefPtr theMapProjection; double theMapAzimAngle; double theMapAzimCos; double theMapAzimSin; double theMap2IcRotAngle; double theMap2IcRotCos; double theMap2IcRotSin; // // //*** // // Adjustable parameters: // //*** double theIntrackOffset; double theCrtrackOffset; double theLineGsdCorr; double theSampGsdCorr; double theRollOffset; double theYawOffset; double theYawRate; double theMapRotation; // // //*** // // Quantities derived from the adjustable parameters: // //*** NEWMAT::Matrix theRollRotMat; unsigned int qDepth; TYPE_DATA }; } // End: namespace ossimplugins #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTimeUtilities.cpp000066400000000000000000000121061301006202600300460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "ossimTimeUtilities.h" #include // #include #include #include #include #include #include "ossimStringUtilities.h" #include // #include ossimDate ossimplugins::time::details::strptime(string_view const& format, string_view const& date) { using namespace ossimplugins::details; //[[pre: format doesn't end with a odd number of '%']] string_view fmt = format; string_view d = date; unsigned int year = 0; unsigned int month = 0; unsigned int day = 0; unsigned int hours = 0; unsigned int minutes = 0; unsigned int seconds = 0; double ssecs = 0.0; for ( ; !fmt.empty() ; fmt.remove_prefix(1)) { switch (fmt.front()) { case '%': // std::cout << "found ("< error fmt.remove_prefix(1); switch (fmt.front()) { case '%': // std::cout << "% -> just a %" << std::endl; assert(!d.empty()); // invalid format => error if (fmt.front() != d.front()) { throw std::runtime_error("Date "+date+" doesn't match format (" + format + ")"); } d.remove_prefix(1); break; case 'Y': year = decode_uint(d); break; case 'm': month = decode_uint(d); break; case 'd': day = decode_uint(d); break; case 'H': hours = decode_uint(d); break; case 'M': minutes = decode_uint(d); break; case 'S': seconds = decode_uint(d); break; case '.': // subseconds if (!d.empty() && d.front() == '.') { d.remove_prefix(1); std::size_t nsecs_nb_digits = d.size(); ssecs = decode_uint(d); nsecs_nb_digits -= d.size(); ssecs /= std::pow((double)10.0, (int)nsecs_nb_digits); } else { // std::cout << "No subfraction in source date" << std::endl; } break; default: throw std::logic_error("Unsupported date format speficier (in "+format+": "+fmt.front()+")"); } break; default: // std::cout << "found char: `" << fmt.front() << "`. Does it match `" << d.front() << "`?" << std::endl; if (fmt.front() != d.front()) { throw std::runtime_error("Date "+date+" doesn't match format (" + format + ")"); } d.remove_prefix(1); } } // while fmt // std::cout << std::endl; ossimDate res(month, day, year); res.setHour(hours); res.setMin(minutes); res.setSec(seconds); res.setFractionalSecond(ssecs); // fmt = format; return res; } ossimplugins::time::ModifiedJulianDate ossimplugins::time::toModifiedJulianDate(string_view const& utcTimeString) { const ossimDate date = details::strptime("%Y-%m-%dT%H:%M:%S%.", utcTimeString); return ModifiedJulianDate(date.getModifiedJulian()); } std::string ossimplugins::time::to_simple_string(ModifiedJulianDate const& d) { ossimDate date ; date.setDateFromModifiedJulian(d.as_day_frac()); char buffer[1024] = {0}; size_t s = std::strftime(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%S", &date); if (s == 0) { // TODO d.as_day_frac() -> string throw std::runtime_error("Cannot encode date into a string"); } assert(s < 1000); // should be more than enough typedef unsigned long ulong; const double frac_sec = date.getFractionalSecond(); // const double fs2 = fmod(d.as_day_frac() * 24ULL*60*60, 1); // assert(fs2==frac_sec); // std::cout << "From: " << d.as_day_frac() << " -> frac_sec: " << fs2 // << " --> *10^6: " << fs2*1000ULL*1000 // << " --> %10^6: " << ulong(fs2*1000ULL*1000)%(1000ULL*1000) // << "\n"; s += s_printf(&buffer[s], sizeof(buffer)-s, ".%06ld", ulong(frac_sec * 1000ULL * 1000) % (1000ULL*1000)); return std::string(buffer, s); } std::string ossimplugins::time::to_simple_string(Duration const& d) { typedef unsigned long ulong; const double fs = d.as_day_frac() * 24 * 60 * 60; // in seconds const ulong ls = std::abs(fs); const ulong us = ulong(std::abs(fs * 1000ULL*1000)) % (1000ULL*1000); const ulong s = ls % 60; const ulong m = (ls/60) % 60; const ulong h = (ls/60/60); char buffer[1024]; const std::size_t N = s_printf(buffer, "%s%02d:%02d:%02d.%06ld", fs < 0 ? "-" : "", h, m, s, us); assert(N); return std::string(buffer, N); } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTimeUtilities.h000066400000000000000000000254261301006202600275240ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimTimeUtilities_h #define ossimTimeUtilities_h #include "ossimStringUtilities.h" #include "ossimOperatorUtilities.h" #include "ossimPluginConstants.h" #include #include class ossimDate; namespace ossimplugins { namespace time { // class ModifiedJulianDate; // class Duration; namespace details { class DayFrac { public: typedef double scalar_type; // DayFrac(DayFrac const&) = default; // DayFrac(DayFrac &&) = default; // DayFrac& operator=(DayFrac const&) = default; // DayFrac& operator=(DayFrac &&) = default; double as_day_frac() const { return m_day_frac; } std::ostream & display(std::ostream & os) const { return os << m_day_frac; } std::istream & read (std::istream & is) { return is >> m_day_frac; } protected: /**@name Construction/destruction */ //@{ /** Initialization constructor. */ explicit DayFrac() {} // = default; explicit DayFrac(double day_frac) : m_day_frac(day_frac) {} /** Protected destructor. */ ~DayFrac() {}// = default; //@} /**@name Operations */ //@{ void add(DayFrac const& rhs) { m_day_frac += rhs.m_day_frac; } void sub(DayFrac const& rhs) { m_day_frac -= rhs.m_day_frac; } void mult(scalar_type coeff) { m_day_frac *= coeff; } void div(scalar_type coeff) { assert(coeff && "Cannot divide by 0"); m_day_frac /= coeff; } template friend scalar_type ratio_(V const& lhs, V const& rhs) { return lhs.as_day_frac() / rhs.as_day_frac(); } template friend U& operator+=(U & u, V const& v) { u.add(v); return u; } template friend U& operator-=(U & u, V const& v) { u.sub(v); return u; } template static U diff(V const& lhs, V const& rhs) { U const res(lhs.as_day_frac() - rhs.as_day_frac()); return res; } template friend U& operator*=(U & u, scalar_type const& v) { u.mult(v); return u; } template friend U& operator/=(U & u, scalar_type const& v) { u.div(v); return u; } template friend bool operator<(T const& lhs, T const& rhs) { return lhs.as_day_frac() < rhs.as_day_frac(); } template friend bool operator==(T const& lhs, T const& rhs) { return lhs.as_day_frac() == rhs.as_day_frac(); } //@} private: double m_day_frac; }; } /** * Duration abstraction. * * Values of this class represent time interval. * *

Semantics
*

  • Value, mathematical: it's relative position *
  • Time interval * * @see \c std::duration<> */ class Duration : public details::DayFrac , private addable , private substractable , private streamable , private multipliable2 , private dividable , private equality_comparable , private less_than_comparable { public: typedef details::DayFrac::scalar_type scalar_type; /**@name Construction/destruction */ //@{ /** Initialization constructor. */ Duration() {} // = default; explicit Duration(double day_frac) : details::DayFrac(day_frac) {} //@} double total_seconds() const { return as_day_frac() * 24 * 60 * 60; } double total_microseconds() const { return total_seconds() * 1000 * 1000; } bool is_negative() const { return as_day_frac() < 0.0; } Duration invert_sign() { return Duration(- as_day_frac()); } friend Duration abs(Duration const& d) { return Duration(std::abs(d.as_day_frac())); } }; /** * Modified JulianDate abstraction. * * Objects of this class represent points in time. * *

    Semantics
    *

  • Value, mathematical: it's an absolute position *
  • Point in time * @see \c std::time_point<> */ class ModifiedJulianDate : public details::DayFrac , private addable , private substractable , private substractable_asym , private streamable , private equality_comparable , private less_than_comparable { public: typedef details::DayFrac::scalar_type scalar_type; /**@name Construction/destruction */ //@{ /** Initialization constructor. */ ModifiedJulianDate() {} // = default; explicit ModifiedJulianDate(double day_frac) : details::DayFrac(day_frac) {} //@} using details::DayFrac::diff; }; OSSIM_PLUGINS_DLL ModifiedJulianDate toModifiedJulianDate(string_view const& utcTimeString); inline Duration microseconds(double us) { return Duration(us / (24ULL * 60 * 60 * 1000 * 1000)); } inline Duration seconds(double us) { return Duration(us / (24ULL * 60 * 60)); } OSSIM_PLUGINS_DLL std::string to_simple_string(ModifiedJulianDate const& d); OSSIM_PLUGINS_DLL std::string to_simple_string(Duration const& d); namespace details { // strptime is not portable, hence this simplified emulation OSSIM_PLUGINS_DLL ossimDate strptime(string_view const& format, string_view const& date); } // details namespace } } // ossimplugins namespace::time #if defined(USE_BOOST_TIME) # include # include // boost::posix_time::time_duration doesn't have a sufficient precision to // store things such an azimuth time interval, and yet, this IS a duration. // Hence this new class injected into boost namespace to emulate a duration // with precision behind the microsecond. // TODO: // - check whether we could have used another boost date // - move this elsewhere // - move this into another namespace namespace boost { namespace posix_time { class precise_duration; double ratio_(precise_duration const& lhs, precise_duration const& rhs); class precise_duration : private ossimplugins::addable , private ossimplugins::substractable , private ossimplugins::streamable , private ossimplugins::multipliable2 , private ossimplugins::dividable , private ossimplugins::equality_comparable , private ossimplugins::less_than_comparable , private ossimplugins::addable , private ossimplugins::substractable { public: typedef double scalar_type; /**@name Construction/destruction */ //@{ /** Initialization constructor. */ precise_duration() {} // = default; explicit precise_duration(double usec_frac) : m_usec_frac(usec_frac) {} precise_duration(time_duration const& d) : m_usec_frac(d.total_microseconds()) {} //@} double total_seconds() const { return total_microseconds() / 1000000.; } double total_microseconds() const { return m_usec_frac; } bool is_negative() const { return total_microseconds() < 0.0; } precise_duration invert_sign() { return precise_duration(- total_seconds()); } std::ostream & display(std::ostream & os) const { return os << m_usec_frac; } std::istream & read (std::istream & is) { return is >> m_usec_frac; } protected: /**@name Operations */ //@{ void add(precise_duration const& rhs) { m_usec_frac += rhs.total_microseconds(); } void sub(precise_duration const& rhs) { m_usec_frac -= rhs.total_microseconds(); } void mult(scalar_type coeff) { m_usec_frac *= coeff; } void div(scalar_type coeff) { assert(coeff && "Cannot divide by 0"); m_usec_frac /= coeff; } friend precise_duration& operator+=(precise_duration & u, precise_duration const& v) { u.add(v); return u; } friend ptime& operator+=(ptime & u, precise_duration const& v) { const time_duration d = microseconds(floor(v.total_microseconds()+0.5)); u += d; return u; } friend precise_duration& operator-=(precise_duration & u, precise_duration const& v) { u.sub(v); return u; } friend ptime& operator-=(ptime & u, precise_duration const& v) { const time_duration d = microseconds(floor(v.total_microseconds()+0.5)); u -= d; return u; } template static U diff(V const& lhs, V const& rhs) { U const res(lhs.total_microseconds() - rhs.total_microseconds()); return res; } friend precise_duration& operator*=(precise_duration & u, scalar_type const& v) { u.mult(v); return u; } friend precise_duration& operator/=(precise_duration & u, scalar_type const& v) { u.div(v); return u; } friend bool operator<(precise_duration const& lhs, precise_duration const& rhs) { return lhs.total_microseconds() < rhs.total_microseconds(); } friend bool operator==(precise_duration const& lhs, precise_duration const& rhs) { return lhs.total_microseconds() == rhs.total_microseconds(); } public: friend scalar_type ratio_(precise_duration const& lhs, precise_duration const& rhs) { return lhs.total_microseconds() / rhs.total_microseconds(); } //@} private: double m_usec_frac; }; time_duration abs(time_duration d) { if(d.is_negative()) d = d.invert_sign(); return d; } } } // boost::time namespaces #endif #endif // ossimTimeUtilities_h OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimTraceHelpers.h000066400000000000000000000030101301006202600272740ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef ossimTraceHelpers_h #define ossimTraceHelpers_h #include #include namespace ossimplugins { /** Helper class to log automatically entering and leaving scopes. * @warning Not meant to be used directly. Use \c SCOPED_LOG instead. */ struct ScopedLogger { ScopedLogger(ossimTrace & channel, char const* module, ossimNotifyLevel level = ossimNotifyLevel_DEBUG) : m_channel(channel) , MODULE(module) { if (m_channel()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entered...\n"; } } ~ScopedLogger() { if (m_channel()) { ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " left...\n"; } } private: ScopedLogger(ScopedLogger const&); ScopedLogger& operator=(ScopedLogger const&); ossimTrace & m_channel; char const* MODULE; }; #define SCOPED_LOG(channel, msg) \ SCOPED_LOG_NAME(__LINE__)(channel, msg) #define SCOPED_LOG_NAME(x) \ SCOPED_LOG_NAME0(x) #define SCOPED_LOG_NAME0(x) \ ossimplugins::ScopedLogger slog ## x } // ossimplugins namespace #endif // ossimTraceHelpers_h OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimWin32FindFileHandle.cpp000066400000000000000000000017721301006202600307020ustar00rootroot00000000000000 #include #include "ossimStringUtilities.h" #include "ossimWin32FindFileHandle.h" namespace ossimplugins { ossimWin32FindFileHandle::ossimWin32FindFileHandle(std::string const& path) { memset(&m_search_data, 0, sizeof(WIN32_FIND_DATA)); m_h = FindFirstFile(path.c_str(), &m_search_data); if (!is_valid() && (GetLastError() != ERROR_FILE_NOT_FOUND)) { char err_msg[1024]; s_printf( err_msg, "ossimSentinel1Model: cannot list files in directory '%s' : '%d'", path.c_str(), GetLastError() ); throw std::runtime_error( err_msg ); } } bool ossimWin32FindFileHandle::is_valid() const { return m_h != INVALID_HANDLE_VALUE; } ossimWin32FindFileHandle::~ossimWin32FindFileHandle() { if (is_valid()) FindClose(m_h); } bool ossimWin32FindFileHandle::next() { assert(is_valid()); return (FindNextFile(m_h, &m_search_data) == true); } std::string ossimWin32FindFileHandle::crt_filename() const { return m_search_data.cFileName; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimWin32FindFileHandle.h000066400000000000000000000006601301006202600303420ustar00rootroot00000000000000#ifndef ossimWin32FindFileHandle_HEADER #define ossimWin32FindFileHandle_HEADER #include #include namespace ossimplugins { struct ossimWin32FindFileHandle { explicit ossimWin32FindFileHandle(std::string const& path); bool is_valid() const; ~ossimWin32FindFileHandle(); bool next(); std::string crt_filename() const; private: HANDLE m_h; WIN32_FIND_DATA m_search_data; }; } #endifOTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimXmlTools.cpp000066400000000000000000000053171301006202600270430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- #include "ossimXmlTools.h" #include "ossimTimeUtilities.h" #include #include #include // #include ossimXmlNode const& ossimplugins::getExpectedFirstNode(ossimXmlNode const& node, ossimString const& xpath) { ossimRefPtr const& wh = node.findFirstNode(xpath); if (!wh) { throw std::runtime_error("No '" + xpath.string() + "' subnode found"); } return *wh; } ossimString const& ossimplugins::getTextFromFirstNode(ossimXmlNode const& node, ossimString const& xpath) { ossimString const& s = getExpectedFirstNode(node, xpath).getText(); return s; } ossimplugins::TimeType ossimplugins::getTimeFromFirstNode(ossimXmlNode const& node, ossimString const& xpath) { #if defined(USE_BOOST_TIME) ossimString s = getTextFromFirstNode(node, xpath); std::replace(s.begin(), s.end(), 'T', ' '); return boost::posix_time::time_from_string(s); #else return getModifiedJulianDateFromFirstNode(node, xpath); #endif } ossimplugins::time::ModifiedJulianDate ossimplugins::getModifiedJulianDateFromFirstNode(ossimXmlNode const& node, ossimString const& xpath) { ossimString const& s = getTextFromFirstNode(node, xpath); return time::toModifiedJulianDate(s); } double ossimplugins::getDoubleFromFirstNode(ossimXmlNode const& node, ossimString const& xpath) { const ossimString & s = getTextFromFirstNode(node, xpath); return s.toDouble(); } ossimString const& ossimplugins::getOptionalTextFromFirstNode(ossimXmlNode const& node, ossimString const& xpath) { static const ossimString empty; ossimRefPtr const& wh = node.findFirstNode(xpath); return wh.valid() ? wh->getText() : empty; } ossimString const& ossimplugins::getOnlyText(ossimXmlDocument const& doc, ossimString const& xpath) { static const ossimString empty; std::vector > xnodes; doc.findNodes(xpath, xnodes); switch (xnodes.size()) { case 1: // perfect if (xnodes[0].valid()) { return xnodes[0]->getText(); } case 0: ossimNotify(ossimNotifyLevel_WARN) << "No node found with the name: " << xpath << "\n"; break; default: ossimNotify(ossimNotifyLevel_WARN) << xnodes.size() << " (too many) nodes found with the name: " << xpath << "\n"; break; } return empty; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimXmlTools.h000066400000000000000000000037041301006202600265060ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- #ifndef OSSIM_XMLTOOLS_H__ #define OSSIM_XMLTOOLS_H__ class ossimString; class ossimXmlDocument; // class ossimXmlNode; #if defined(USE_BOOST_TIME) # include #endif #include "ossimStringUtilities.h" #include "ossimTimeUtilities.h" #include namespace ossimplugins { namespace time { class ModifiedJulianDate; }// time namespace #if defined(USE_BOOST_TIME) typedef boost::posix_time::ptime TimeType; #else typedef time::ModifiedJulianDate TimeType; #endif ossimXmlNode const& getExpectedFirstNode(ossimXmlNode const& node, ossimString const& xpath); ossimString const& getTextFromFirstNode(ossimXmlNode const& node, ossimString const& xpath); ossimString const& getOptionalTextFromFirstNode(ossimXmlNode const& node, ossimString const& xpath); TimeType getTimeFromFirstNode(ossimXmlNode const& node, ossimString const& xpath); time::ModifiedJulianDate getModifiedJulianDateFromFirstNode(ossimXmlNode const& node, ossimString const& xpath); double getDoubleFromFirstNode(ossimXmlNode const& node, ossimString const& xpath); template inline DataType getFromFirstNode(ossimXmlNode const& node, ossimString const& xpath) { ossimXmlNode const& childNode = getExpectedFirstNode(node, xpath); ossimString const& sValue = childNode.getText(); DataType const& value = to(sValue, "decoding " + xpath + " node"); return value; } ossimString const& getOnlyText(ossimXmlDocument const& doc, ossimString const& xpath); } // ossimplugins namespace #endif // OSSIM_XMLTOOLS_H__ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/ossimplugins-config.h.in000066400000000000000000000005711301006202600302550ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #cmakedefine HAVE_STD_SNPRINTF #cmakedefine HAVE_MSC_SNPRINTF OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/000077500000000000000000000000001301006202600242615ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Arithmetic.h000066400000000000000000000022101301006202600265160ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Arithmetic_h #define Arithmetic_h #include #include namespace ossimplugins { /*-------------------------------------------------------------------------*/ /* "closest integer" function, returns long */ /*-------------------------------------------------------------------------*/ long inint (double x) { return (x >= 0.0) ? (long)(x + 0.5) : (long)(x-0.5) ; } /*-------------------------------------------------------------------------*/ /* "closest integer" function, returns double */ /*-------------------------------------------------------------------------*/ double fnint (double x) { return (x >= 0.0) ? (double)((long)(x + 0.5)) : (double)((long)(x - 0.5)); } } // End: namespace ossimplugins #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/CivilDateTime.cpp000066400000000000000000000223151301006202600274530ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include namespace ossimplugins { const double CivilDateTime::JOURCIVIL_LENGTH = 86400.0 ; CivilDateTime::CivilDateTime(): _year(0), _month(0), _day(0), _second(0), _decimal(0.0) { } CivilDateTime::CivilDateTime(int year, int month, int day, int second, double decimal): _year(year), _month(month), _day(day), _second(second), _decimal(decimal) { } CivilDateTime::CivilDateTime(char* Utc) { SetUtcDateTime(Utc); } CivilDateTime::CivilDateTime(const char* Utc) { SetUtcDateTime(Utc); } CivilDateTime::~CivilDateTime() { } CivilDateTime::CivilDateTime(const CivilDateTime& rhs): _year(rhs._year), _month(rhs._month), _day(rhs._day), _second(rhs._second), _decimal(rhs._decimal) { } CivilDateTime& CivilDateTime::operator=(const CivilDateTime& rhs) { _year = rhs._year; _month = rhs._month; _day = rhs._day; _second = rhs._second; _decimal = rhs._decimal; return *this; } int CivilDateTime::AsJulianDate(JulianDate* julianDate) { int etat , test ; int an , mois , i , j ; double b , d ; if (_month > 2) { an = _year ; mois = _month ; } else { an = _year - 1 ; mois = _month + 12 ; } test = _year * 10000 + _month * 100 + _day ; if ((test > 15821004) && (test < 15821015)) etat = 1 ; else { etat = 0 ; d = (an < 0) ? 0.75 : 0.0 ; if (test >= 15821015) { i = an / 100 ; j = 2 - i + i/4 ; b = (double)j + 1720994.5 ; } else b = 1720994.5 ; i = (int) (365.25 * (double)an - d) ; j = (int) (30.6001 * (double)(mois + 1)) ; double jourJulien = (double)(i + j) + (double)_day + ((double)_second + _decimal) / JOURCIVIL_LENGTH + b ; julianDate->set_julianDate(jourJulien); } return etat; } int CivilDateTime::SetUtcDateTime(char* Utc) { char str_an[5]; char str_day[3]; char str_month[4]; char str_hour[3]; char str_min[3]; char str_sec[3]; char str_micro[7]; int i; double exposant; /* * year extraction */ for (i = 0; i < 4; i++) { str_an[i] = Utc[i+7]; } str_an[4] = '\0'; _year = atoi(str_an); if ( (_year > 2050) || (_year < 1950) ) { return 1; } /* * month extraction */ for (i = 0; i < 3; i++) { str_month[i] = Utc[i+3]; } str_month[3] = '\0'; if (!strcmp(str_month, "JAN")) _month = 1; else if (!strcmp(str_month, "FEV")) _month = 2; else if (!strcmp(str_month, "MAR")) _month = 3; else if (!strcmp(str_month, "APR")) _month = 4; else if (!strcmp(str_month, "MAY")) _month = 5; else if (!strcmp(str_month, "JUN")) _month = 6; else if (!strcmp(str_month, "JUL")) _month = 7; else if (!strcmp(str_month, "AUG")) _month = 8; else if (!strcmp(str_month, "SEP")) _month = 9; else if (!strcmp(str_month, "OCT")) _month = 10; else if (!strcmp(str_month, "NOV")) _month = 11; else if (!strcmp(str_month, "DEC")) _month = 12; else { return 1; } /* * day extraction */ for (i = 0; i < 2; i++) { str_day[i] = Utc[i]; } str_day[2] = '\0'; _day = atoi(str_day); if ( (_day < 1) || (_day > 31) ) { return 1; } /* * seconds extraction */ for (i = 0; i < 2; i++) { str_hour[i] = Utc[i+12]; str_min[i] = Utc[i+15]; str_sec[i] = Utc[i+18]; } str_hour[2] = '\0';if ( (atoi(str_hour) < 0) || (atoi(str_hour) > 23) ) { return 1; } str_min[2] = '\0';if ( (atoi(str_min) < 0) || (atoi(str_hour) > 59) ) { return 1; } str_sec[2] = '\0';if ( (atoi(str_sec) < 0) || (atoi(str_hour) > 59) ) { return 1; } _second = 3600*atoi(str_hour) + 60*atoi(str_min) + atoi(str_sec); /* * microseconds extraction */ for (i = 0; i < 6; i++) { str_micro[i] = Utc[i+21]; } str_micro[6] = '\0'; i = 0; exposant = 10e-6; while ((unsigned int)i < strlen(str_micro) ) { if (str_micro[i] == '0') exposant = exposant * 0.1; i++; } _decimal = exposant * (double) atoi(str_micro); if ( (_decimal < 0) || (_decimal >= 1) ) { return 1; } return 0; } int CivilDateTime::SetUtcDateTime(const char* Utc) { char str_an[5]; char str_day[3]; char str_month[4]; char str_hour[3]; char str_min[3]; char str_sec[3]; char str_micro[7]; int i; double exposant; /* * year extraction */ for (i = 0; i < 4; i++) { str_an[i] = Utc[i+7]; } str_an[4] = '\0'; _year = atoi(str_an); if ( (_year > 2050) || (_year < 1950) ) { return 1; } /* * month extraction */ for (i = 0; i < 3; i++) { str_month[i] = Utc[i+3]; } str_month[3] = '\0'; if (!strcmp(str_month, "JAN")) _month = 1; else if (!strcmp(str_month, "FEV")) _month = 2; else if (!strcmp(str_month, "MAR")) _month = 3; else if (!strcmp(str_month, "APR")) _month = 4; else if (!strcmp(str_month, "MAY")) _month = 5; else if (!strcmp(str_month, "JUN")) _month = 6; else if (!strcmp(str_month, "JUL")) _month = 7; else if (!strcmp(str_month, "AUG")) _month = 8; else if (!strcmp(str_month, "SEP")) _month = 9; else if (!strcmp(str_month, "OCT")) _month = 10; else if (!strcmp(str_month, "NOV")) _month = 11; else if (!strcmp(str_month, "DEC")) _month = 12; else { return 1; } /* * day extraction */ for (i = 0; i < 2; i++) { str_day[i] = Utc[i]; } str_day[2] = '\0'; _day = atoi(str_day); if ( (_day < 1) || (_day > 31) ) { return 1; } /* * seconds extraction */ for (i = 0; i < 2; i++) { str_hour[i] = Utc[i+12]; str_min[i] = Utc[i+15]; str_sec[i] = Utc[i+18]; } str_hour[2] = '\0';if ( (atoi(str_hour) < 0) || (atoi(str_hour) > 23) ) { return 1; } str_min[2] = '\0';if ( (atoi(str_min) < 0) || (atoi(str_hour) > 59) ) { return 1; } str_sec[2] = '\0';if ( (atoi(str_sec) < 0) || (atoi(str_hour) > 59) ) { return 1; } _second = 3600*atoi(str_hour) + 60*atoi(str_min) + atoi(str_sec); /* * microseconds extraction */ for (i = 0; i < 6; i++) { str_micro[i] = Utc[i+21]; } str_micro[6] = '\0'; i = 0; exposant = 10e-6; while ((unsigned int)i < strlen(str_micro) ) { if (str_micro[i] == '0') exposant = exposant * 0.1; i++; } _decimal = exposant * (double) atoi(str_micro); if ( (_decimal < 0) || (_decimal >= 1) ) { return 1; } return 0; } int CivilDateTime::AsJSDDateTime(JSDDateTime* JSDdate) { int etat , k ; JulianDate jourJulien; double r ; etat = AsJulianDate(&jourJulien ); if (etat == 0) { k = (int)(jourJulien.get_julianDate() - 0.5) ; double day0hTU = (double)k + 0.5; JSDdate->set_day0hTU(JulianDate(day0hTU)); r = (jourJulien.get_julianDate() - day0hTU) * JOURCIVIL_LENGTH ; JSDdate->set_second(floor (r)) ; JSDdate->set_decimal(r - JSDdate->get_second()) ; } return etat ; } int CivilDateTime::AsGMSTDateTime(GMSTDateTime* GMST) { const double TWOPI = 6.28318530717958647693 ; const double OMEGATERRE = 6.28318530717958647693 / 86164.09054 ; int etat ; JulianDate jourJulien; double t=0.0; double tsm0hTU=0.0; double tsm; CivilDateTime date0hTU(_year, _month, _day, 0, 0.0); etat = date0hTU.AsJulianDate(&jourJulien ); if (etat == 0) { if (GMST->get_origine() == GMSTDateTime::AN1900) { t = (jourJulien.get_julianDate() - 2415020.0) / 36525.0 ; tsm0hTU = 23925.836 + t * (8640184.542 + t * 0.0929) ; tsm0hTU = tsm0hTU * TWOPI / JOURCIVIL_LENGTH ; } else if (GMST->get_origine() == GMSTDateTime::AN1950) { t = jourJulien.get_julianDate() - 2433281.5 ; tsm0hTU = 1.72944494 + t * 6.3003880987 ; } else if (GMST->get_origine() == GMSTDateTime::AN2000) { t = (jourJulien.get_julianDate() - 2451545.0) / 36525.0 ; tsm0hTU = 24110.54841 + t * (8640184.812866 + t * (0.093103 - t * 6.210e-6)) ; tsm0hTU = tsm0hTU * TWOPI / JOURCIVIL_LENGTH ; } t = tsm0hTU + ((double)_second + _decimal) * OMEGATERRE ; tsm = fmod (t, TWOPI) ; if (tsm < 0.0) { tsm = tsm + TWOPI ; } GMST->set_tms(tsm); } return etat ; } CivilDateTime::operator JulianDate() { JulianDate date; AsJulianDate(&date); return date; } CivilDateTime::operator JSDDateTime() { JSDDateTime date; AsJSDDateTime(&date); return date; } CivilDateTime::operator GMSTDateTime() { GMSTDateTime date; AsGMSTDateTime(&date); return date; } std::ostream& CivilDateTime::print(std::ostream& out) const { out << "CivilDateTime:" << "\nyear: " << _year << "\nmonth: " << _month << "\nday: " << _day << "\nsecond: " << _second << "\ndecimal: " << _decimal << std::endl; return out; } std::ostream& operator<<(std::ostream& out, const CivilDateTime& obj) { return obj.print(out); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/CivilDateTime.h000066400000000000000000000072741301006202600271270ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef CivilDateTime_h #define CivilDateTime_h #include #include namespace ossimplugins { class JulianDate; class JSDDateTime; class GMSTDateTime; /** * @brief This class represents a date and time in the civil format */ class OSSIM_PLUGINS_DLL CivilDateTime { public: /** * @brief Constructor */ CivilDateTime(); /** * @brief Constructor with date and time initialization */ CivilDateTime(int year, int month, int day, int second, double decimal); /** * @brief Constructor with date and time initialization using an utc string */ CivilDateTime(char* Utc); CivilDateTime(const char* Utc); /** * @brief Destructor */ ~CivilDateTime(); /** * @brief Copy constructor */ CivilDateTime(const CivilDateTime& rhs); /** * @brief Affectation operator */ CivilDateTime& operator=(const CivilDateTime& rhs); /** * @brief This function converts the current CivilDateTime into Julian Date * @return 0 if no error or an int greater than 0 indicating the error * @param julianDate [out] The classe that receives the result of the conversion of the current CivilDateTime into JulianDate */ int AsJulianDate(JulianDate* julianDate); /** * @brief This function converts the current CivilDateTime into JSDDateTime * @return 0 if no error or an int greater than 0 indicating the error * @param JSDdate [out] The classe that receives the result of the conversion of the current CivilDateTime into JSDDateTime */ int AsJSDDateTime(JSDDateTime* JSDdate); /** * @brief This function converts the current CivilDateTime into GMSTDateTime * @return 0 if no error or an int greater than 0 indicating the error * @param GMSTdate [out] The classe that receives the result of the conversion of the current CivilDateTime into GMSTDateTime */ int AsGMSTDateTime(GMSTDateTime* GMSTdate); int get_year() { return _year; }; int get_month() { return _month; }; int get_day() { return _day; }; int get_second() { return _second; }; double get_decimal() { return _decimal; }; void set_year(int year) { _year = year; }; void set_month(int month) { _month = month; }; void set_day(int day) { _day = day; }; void set_second(int second) { _second = second; }; void set_decimal(double decimal) { _decimal = decimal; }; /** * @brief This function initialize the date and the the time of the class using an utc string * @param Utc Utc string containing the date and time * @return 0 if no error or an int gretter than 0 indiquating the error */ int SetUtcDateTime(char* Utc); int SetUtcDateTime(const char* Utc); operator JulianDate() ; operator JSDDateTime() ; operator GMSTDateTime() ; std::ostream& print(std::ostream& out) const; friend std::ostream& operator<<(std::ostream& out, const CivilDateTime& obj); static const double JOURCIVIL_LENGTH; protected: /** * @brief */ int _year; /** * @brief */ int _month; /** * @brief */ int _day; /** * @brief Number of secondes since the beginning of the day */ int _second; /** * @brief */ double _decimal; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Coordinate.cpp000066400000000000000000000015461301006202600270620ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { Coordinate::Coordinate(): _x(0.0), _y(0.0), _z(0.0) { } Coordinate::~Coordinate() { } Coordinate::Coordinate(double x, double y, double z): _x(x), _y(y), _z(z) { } Coordinate::Coordinate(const Coordinate& rhs): _x(rhs._x), _y(rhs._y), _z(rhs._z) { } Coordinate& Coordinate::operator=(const Coordinate& rhs) { _x = rhs._x; _y = rhs._y; _z = rhs._z; return *this; } void Coordinate::set_coordinates(double x, double y, double z) { _x = x; _y = y; _z = z; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Coordinate.h000066400000000000000000000022451301006202600265240ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Coordinate_h #define Coordinate_h #include namespace ossimplugins { /** * @brief This class represents a coordinate */ class OSSIM_PLUGINS_DLL Coordinate { public: /** * @brief Constructor */ Coordinate(); /** * @brief Destructor */ ~Coordinate(); /** * @brief Constructor with initializations */ Coordinate(double x, double y, double z); /** * @brief Copy constructor */ Coordinate(const Coordinate& rhs); /** * @brief Affectation operator */ Coordinate& operator=(const Coordinate& rhs); void set_coordinates(double x, double y, double z); double get_x() { return _x; }; double get_y() { return _y; }; double get_z() { return _z; }; protected: double _x; double _y; double _z; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Ephemeris.cpp000066400000000000000000000105631301006202600267130ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char PREFIX[] = "ephemeris."; static const char DATE_JULIAN_KW[] = "date.julian"; static const char DATE_SECOND_KW[] = "date.second"; static const char DATE_DECIMAL_KW[] = "date.decimal"; static const char POSITION_KW[] = "position"; static const char VELOCITY_KW[] = "velocity"; Ephemeris::Ephemeris() { _position[0] = 0.0; _position[1] = 0.0; _position[2] = 0.0; _speed[0] = 0.0; _speed[1] = 0.0; _speed[2] = 0.0; } Ephemeris::~Ephemeris() { } Ephemeris::Ephemeris(JSDDateTime date, double pos[3], double speed[3]): _date(date) { _position[0] = pos[0]; _position[1] = pos[1]; _position[2] = pos[2]; _speed[0] = speed[0]; _speed[1] = speed[1]; _speed[2] = speed[2]; } Ephemeris::Ephemeris(const Ephemeris& rhs): _date(rhs._date) { _position[0] = rhs._position[0]; _position[1] = rhs._position[1]; _position[2] = rhs._position[2]; _speed[0] = rhs._speed[0]; _speed[1] = rhs._speed[1]; _speed[2] = rhs._speed[2]; } Ephemeris& Ephemeris::operator=(const Ephemeris& rhs) { _position[0] = rhs._position[0]; _position[1] = rhs._position[1]; _position[2] = rhs._position[2]; _speed[0] = rhs._speed[0]; _speed[1] = rhs._speed[1]; _speed[2] = rhs._speed[2]; _date = rhs._date; return *this; } bool Ephemeris::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx; if (prefix) { pfx = prefix; } pfx += PREFIX; ossimDpt3d pos(_position[0], _position[1], _position[2]); ossimDpt3d vit(_speed[0], _speed[1], _speed[2]); JulianDate jd = _date.get_day0hTU(); kwl.add(pfx.c_str(), DATE_JULIAN_KW, jd.get_julianDate()); kwl.add(pfx.c_str(), DATE_SECOND_KW, _date.get_second()); kwl.add(pfx.c_str(), DATE_DECIMAL_KW, _date.get_decimal()); kwl.add(pfx.c_str(), POSITION_KW, pos.toString(15).c_str()); kwl.add(pfx.c_str(), VELOCITY_KW, vit.toString(15).c_str()); return true; } bool Ephemeris::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "Ephemeris::loadState"; bool result = true; std::string pfx; if (prefix) { pfx = prefix; } pfx += "ephemeris."; const char* lookup = 0; ossimString s; double d; lookup = kwl.find(pfx.c_str(), DATE_JULIAN_KW); if (lookup) { s = lookup; d = s.toDouble(); JulianDate jd(d); _date.set_day0hTU(jd); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << DATE_JULIAN_KW << "\n"; result = false; } lookup = kwl.find(pfx.c_str(), DATE_SECOND_KW); if (lookup) { s = lookup; d = s.toDouble(); _date.set_second(d); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << DATE_SECOND_KW << "\n"; result = false; } lookup = kwl.find(pfx.c_str(), DATE_DECIMAL_KW); if (lookup) { s = lookup; d = s.toDouble(); _date.set_decimal(d); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << DATE_DECIMAL_KW << "\n"; result = false; } lookup = kwl.find(pfx.c_str(), POSITION_KW); if (lookup) { std::string ps = lookup; ossimDpt3d pt; pt.toPoint(ps); _position[0] = pt.x; _position[1] = pt.y; _position[2] = pt.z; } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << POSITION_KW << "\n"; result = false; } lookup = kwl.find(pfx.c_str(), VELOCITY_KW); if (lookup) { std::string ps = lookup; ossimDpt3d pt; pt.toPoint(ps); _speed[0] = pt.x; _speed[1] = pt.y; _speed[2] = pt.z; } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << VELOCITY_KW << "\n"; result = false; } return result; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Ephemeris.h000066400000000000000000000046611301006202600263620ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Ephemeride_h #define Ephemeride_h #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup Ephemeris * @brief This class represents an ephemeris */ class OSSIM_PLUGINS_DLL Ephemeris { public: /** * @brief Constructor */ Ephemeris(); /** * @brief Destructor */ virtual ~Ephemeris(); /** * @brief Constructor with initialisations */ Ephemeris(JSDDateTime date, double pos[3], double speed[3]); /** * @brief Copy constructor */ Ephemeris(const Ephemeris& rhs); /** * @brief Affectation operator */ Ephemeris& operator=(const Ephemeris& rhs); /** * @brief This function creatse a copy of the current class */ virtual Ephemeris* Clone() { return new Ephemeris(*this); } JSDDateTime get_date() const { return _date; } double* get_position() { return _position; } const double* get_position() const { return _position; } double* get_speed() { return _speed; } const double* get_speed() const { return _speed; } void set_date(JSDDateTime date) { _date = date; } void set_position(double position[3]) { _position[0] = position[0]; _position[1] = position[1]; _position[2] = position[2]; } void set_speed(double speed[3]) { _speed[0] = speed[0]; _speed[1] = speed[1]; _speed[2] = speed[2]; } /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); protected: JSDDateTime _date; double _position[3]; double _speed[3]; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Equation.cpp000066400000000000000000000557061301006202600265670ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { const double Equation::Epsilon = 1.e-12; Equation::Equation(): _coefficients(NULL), _degree(0), _nbrSol(0), _solutions(NULL) { _order.clear(); } Equation::~Equation() { if (_coefficients != NULL) delete [] _coefficients; if(_solutions != NULL) delete [] _solutions; } Equation::Equation(int degree, std::complex* coefficients): _coefficients(NULL), _degree(0), _nbrSol(0), _solutions(NULL) { _order.clear(); CreateEquation(degree, coefficients); } void Equation::CreateEquation(int degree, std::complex* coefficients) { if (_coefficients != NULL) { delete [] _coefficients; } if(_order.size() != 0) _order.clear(); if(_solutions != NULL) delete [] _solutions; _coefficients = new std::complex[degree+1]; _degree = degree; for (int i=0;i<=degree;i++) { _coefficients[i] = coefficients[i]; } } Equation::Equation(const Equation& rhs) { CreateEquation(rhs._degree, rhs._coefficients); } Equation& Equation::operator=(const Equation& rhs) { CreateEquation(rhs._degree, rhs._coefficients); return *this; } void Equation::ComputeTrueDegree() { double r = 0.0; _trueDegree = _degree +1; while (r <= Epsilon && _trueDegree > 0) { _trueDegree = _trueDegree - 1 ; r = abs(_coefficients[_trueDegree]); } } void Equation::Normalisation() { for (int i=0;i<_trueDegree;i++) { _coefficients[i] = _coefficients[i] / _coefficients[_trueDegree]; } _coefficients[_trueDegree] = std::complex(1.0,0.0); int eMax = 0; int eMin = 0; int e; double r; /* * Normalisation by a power of 10 */ for (int i = 0 ; i < _trueDegree ; i++) { double rr = std::abs(_coefficients[i]) ; if (rr >= Epsilon) { rr = log10(rr) ; e = static_cast(rr) / static_cast(_trueDegree - i) ; if (e > eMax) eMax = e ; if (e < eMin) eMin = e ; } } /* * Normalisation for big values */ if (eMax > 0) { /* Normalisation of the unknown for big values */ _normalisationType = GreatValues; _normalisationCoefficient = pow (10.0, (double)eMax) ; r = 1.0 ; for (int i = _trueDegree-1 ; i >= 0 ; i--) { r = r * _normalisationCoefficient ; _coefficients[i] = _coefficients[i] / std::complex(r,0.0); } } else if (eMin < 0) { /* Normalisation of the unknown for small */ _normalisationType = SmallValues; _normalisationCoefficient = pow(10.0,(double)(-eMin)) ; r = 1.0 ; for (int i = _trueDegree-1 ; i >= 0 ; i--) { r = r * _normalisationCoefficient ; _coefficients[i] = _coefficients[i] * std::complex(r,0.0); } } } void Equation::DeNormalisation() { if (_normalisationType == GreatValues) { for (int i=0;i<_nbrSol;i++) { _solutions[i] = _solutions[i] * std::complex(_normalisationCoefficient,0.0); } } else { for (int i=0;i<_nbrSol;i++) { _solutions[i] = _solutions[i] / std::complex(_normalisationCoefficient,0.0); } } } std::complex Equation::Proche(std::complex z, double epsilon) { double x, y, ax, ay ; std::complex result ; x = z.real(); y = z.imag(); ax = fabs(x); ay = fabs(y); if (ax < epsilon && ay < epsilon) result = std::complex(0.0, 0.0) ; else if (ay < epsilon) result = std::complex(x, 0.0) ; else if (ax < epsilon) result = std::complex(0.0, y) ; else { if ((ay / ax) < epsilon) result = std::complex(x, 0.0) ; else if ((ax / ay) < epsilon) result = std::complex(0.0,y) ; else result = z ; } return result ; } void Equation::Solve() { ComputeTrueDegree(); Normalisation(); if(_trueDegree == 1) { Solve1(); } else if(_trueDegree == 2) { Solve2(); } else if(_trueDegree == 3) { Solve3(); } else if(_trueDegree == 4) { Solve4(); } DeNormalisation(); } void Equation::Solve1() { _nbrSol = 1; if(_order.size() != 0) _order.clear(); _order.push_back(1); if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[1]; _solutions[0] = Proche(-_coefficients[0], Epsilon); } void Equation::Solve2() { double r1, r2 ; // double epsilon = 1.e-12 ; std::complex t1, t2, d, z ; std::complex aa[2] ; aa[0] = _coefficients[0]/ _coefficients[2]; aa[1] = _coefficients[1]/ _coefficients[2]; t1 = aa[1]* aa[1] ; t2 = aa[0]* std::complex(4.0, 0.0) ; r1 = abs(t1) ; r2 = abs(t2) ; if (r2 > r1) r1 = r2 ; if (r1 > Epsilon) { d = t1- t2 ; t1 = d/std::complex(r1, 0.0) ; } else { d = std::complex(0.0, 0.0) ; t1 = std::complex(0.0, 0.0) ; } r1 = abs (t1) ; if (r1 <= Epsilon) { /* 1 double root */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[1]; if(_order.size() != 0) _order.clear(); _nbrSol = 1 ; z = aa[1]/std::complex(-2.0, 0.0); _solutions[0] = Proche (z, Epsilon) ; _order.push_back(2); } else { /* 2 simple roots */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[2]; if(_order.size() != 0) _order.clear(); _nbrSol = 2 ; d = sqrt(d) ; z = (d-aa[1])/std::complex(2.0, 0.0) ; _solutions[0] = Proche (z, Epsilon) ; z = (d+aa[1])/std::complex(-2.0, 0.0); _solutions[1] = Proche (z, Epsilon) ; _order.push_back(1); _order.push_back(1); } } void Equation::Solve3(int d4) { int d3_1r3 , d3_1r2_1r1 ; double r1, r2, ra[3] ; // double epsilon = 1.e-12 ; std::complex j, j2 ; std::complex d, q, r, s, t, u, v, w ; std::complex aa[3], zProv[3][3] ; j = std::complex(-0.5, sqrt (3.0) / 2.0) ; j2 = std::complex(-0.5, -sqrt (3.0) / 2.0) ; /* Normalisation of coefficients */ for (int i1 = 0; i1 < 3; i1++) aa[i1] = _coefficients[i1]/_coefficients[3]; if ( d4 == 0 ) { /* Test of existence of a triple root */ d3_1r3 = TestDegree3Triple(aa, Epsilon) ; /* Test of existence of 1 doubleroot + 1 simple root */ d3_1r2_1r1 = TestDegree3SimpleDouble(aa, Epsilon) ; } else { d3_1r3 = 0 ; d3_1r2_1r1 = 0 ; } if (d3_1r3 == 1) { /* 1 triple root */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[1]; if(_order.size() != 0) _order.clear(); _nbrSol = 1 ; _solutions[0] = Proche (aa[2]/std::complex(-3.0, 0.0) , Epsilon) ; _order.push_back(3); } else if (d3_1r2_1r1 == 1) { /* 1 simple root + 1 double root */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[2]; if(_order.size() != 0) _order.clear(); u = (aa[1]* aa[2])/ std::complex(6.0, 0.0) ; v = aa[0]/ std::complex (2.0, 0.0); w = pow(aa[2], 3.0)/ std::complex(27.0, 0.0); r = (u-v)- w ; u = pow (r, 1.0 / 3.0) ; w = aa[2]/ std::complex(3.0, 0.0); zProv[0][0] = -u; zProv[0][1] = u * std::complex(2.0,0.0); zProv[1][0] = u * (j + std::complex(1.0, 0.0)); zProv[1][1] = u * (j2* std::complex(2.0, 0.0)); zProv[2][0] = u * (j2+ std::complex(1.0, 0.0)); zProv[2][1] = u * (j * std::complex(2.0, 0.0)); for (int i1 = 0; i1 <= 2; i1++) { zProv[i1][0] = zProv[i1][0]- w; zProv[i1][1] = zProv[i1][1]- w; } for (int i2 = 0; i2 < 3; i2++) { u = std::complex(1.0, 0.0) ; for (int i1 = 2; i1 >= 0; i1--) u = u*zProv[i2][0]+aa[i1] ; r1 = abs (u) ; u = std::complex(1.0, 0.0) ; for (int i1 = 2; i1 >= 0; i1--) u = u*zProv[i2][1]+ aa[i1] ; r2 = abs (u) ; ra[i2] = r1 * r1 + r2 * r2 ; } int i3 = IndiceMin(3, ra) ; _solutions[0] = Proche ( zProv[i3][0] , Epsilon ) ; _solutions[1] = Proche ( zProv[i3][1] , Epsilon ) ; _nbrSol = 2 ; _order.push_back(2); _order.push_back(1); } else { /* 3 simple roots */ u = aa[1]/ std::complex(3.0, 0.0); v = (aa[2]* aa[2]) / std::complex(9.0, 0.0) ; q = u- v ; u = (aa[1]* aa[2]) / std::complex(6.0, 0.0) ; v = aa[0]/ std::complex(2.0, 0.0) ; w = pow(aa[2], 3.0) / std::complex(27.0, 0.0); r = (u-v) - w ; d = sqrt(pow(q, 3.0) + pow(r, 2.0)) ; s = pow ((r + d) , 1.0 / 3.0) ; t = pow ((r - d) , 1.0 / 3.0) ; w = aa[2]/ std::complex(3.0, 0.0); zProv[0][0] = s+ t; zProv[0][1] = (j* s) + (j2* t) ; zProv[0][2] = (j2* s) + (j* t) ; zProv[1][0] = s + (j* t); zProv[1][1] = (j* s) + t; zProv[1][2] = j2 * (s+ t) ; zProv[2][0] = s + (j2* t) ; zProv[2][1] = j * (s+ t); zProv[2][2] = (j2* s) + t; for (int i1 = 0; i1 < 3; i1++) { for (int i2 = 0; i2 < 3; i2++) zProv[i1][i2] = zProv[i1][i2]- w; } for (int i3 = 0; i3 < 3; i3++) { ra[i3] = 0.0 ; for (int i2 = 0; i2 < 3; i2++) { u = std::complex(1.0, 0.0) ; for (int i1 = 2; i1 >= 0; i1--) u = (u* zProv[i3][i2]) + aa[i1] ; r1 = abs (u) ; ra[i3] = ra[i3] + r1 * r1 ; } } int i1 = IndiceMin(3, ra) ; if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[3]; if(_order.size() != 0) _order.clear(); _nbrSol = 3 ; for (int i3 = 0; i3 < 3; i3++) _solutions[i3] = Proche (zProv[i1][i3] , Epsilon) ; _order.push_back(1); _order.push_back(1); _order.push_back(1); } } void Equation::Solve4() { int d4_1r4, d4_2r2, d4_1r3_1r1, d4_1r2_2r1 ; int d4 = 1 ; double epsilon = 1.e-12 ; double r, h[4] ; std::complex d, u, v, w, x, y ; std::complex aa[4], k[4], b[4], zProv[2][4] ; /* Normalisation of coefficients */ for (int i1 = 0; i1 < 4; i1++) aa[i1] = _coefficients[i1]/ _coefficients[4]; /* Equation reduction : on the form */ /* (x-s)**4 + p(x-s)**2 + q(x-s) + r = 0 */ /* these coefficients are inserted into table k : */ /* k[0] = s */ /* k[1] = p */ /* k[2] = q */ /* k[3] = r */ k[0] = aa[3]/ std::complex(-4.0, 0.0) ; u = aa[2] ; v = ((aa[3]* std::complex(3.0, 0.0)) * (aa[3]/ std::complex(8.0, 0.0))) ; h[0] = abs (u) ; h[1] = abs (v) ; if (h[0] < h[1]) h[0] = h[1] ; if (h[0] > Epsilon) k[1] = u- v; else k[1] = std::complex(0.0, 0.0) ; u = aa[1] ; v = (aa[2]* aa[3]) / std::complex(2.0, 0.0) ; w = pow (aa[3], 3.0) / std::complex(8.0, 0.0) ; h[0] = abs (u) ; h[1] = abs (v) ; h[2] = abs (w) ; h[0] = h[IndiceMax(3, h)] ; if (h[0] > Epsilon) k[2] = (u- v)+ w ; else k[2] = std::complex(0.0, 0.0) ; u = aa[0] ; v = (aa[1]* aa[3]) / std::complex(4.0, 0.0); w = (aa[2]* aa[3]) * (aa[3]/ std::complex(16.0, 0.0)) ; x = pow (aa[3], 4.0) * std::complex(3.0 / 256.0, 0.0) ; h[0] = abs (u) ; h[1] = abs (v) ; h[2] = abs (w) ; h[3] = abs (x) ; h[0] = h[IndiceMax(4, h)] ; if (h[0]>Epsilon) k[3] = (u- v) + (w- x) ; else k[3] = std::complex(0.0, 0.0) ; /* Test of existence of a quadruple root */ d4_1r4 = TestDegree4Quad (k, epsilon) ; /* Test of existence of 2 double roots */ d4_2r2 = TestDegree4DoubleDouble (aa, k, epsilon) ; /* Test of existence of 1 triple root + 1 simple root */ d4_1r3_1r1 = TestDegree4SimpleTriple (aa, k, epsilon) ; /* Test of existence of 1 double root + 2 simple roots */ d4_1r2_2r1 = TestDegreeSimpleSimpleDouble (k, epsilon) ; if (d4_1r4 == 1) { /* 1 quadruple root */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[1]; if(_order.size() != 0) _order.clear(); _nbrSol = 1 ; _solutions[0] = Proche (k[0], Epsilon) ; _order.push_back(4); } else if (d4_2r2 == 1) { /* 2 double roots */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[2]; if(_order.size() != 0) _order.clear(); u = sqrt (k[1]/ std::complex(-2.0, 0.0)) ; _solutions[0] = Proche ((k[0]+ u) , Epsilon) ; _solutions[1] = Proche ((k[0]- u) , Epsilon) ; _nbrSol = 2 ; _order.push_back(2); _order.push_back(2); } else if (d4_1r3_1r1 == 1) { /* 1 triple root + 1 simple root */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[2]; if(_order.size() != 0) _order.clear(); u = (k[2]* std::complex(-3.0, 0.0)) / (k[1]* std::complex(4.0, 0.0)) ; v = u * std::complex(-3.0, 0.0); _solutions[0] = Proche ((k[0]+ u) , Epsilon) ; _solutions[1] = Proche ((k[0]+ v) , Epsilon) ; _nbrSol = 2 ; _order.push_back(3); _order.push_back(1); } else if (d4_1r2_2r1 == 1) { /* 1 double root + 2 simple roots */ if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[3]; if(_order.size() != 0) _order.clear(); if (abs (k[1]) <= Epsilon) { u = (k[3]* std::complex(-4.0, 0.0)) / (k[2]* std::complex(3.0, 0.0)); v = sqrt ((u* std::complex(-2.0, 0.0)) * u) ; _solutions[0] = Proche ((k[0]+ u) , Epsilon) ; _solutions[1] = Proche ((k[0] + (v- u)) , Epsilon) ; _solutions[2] = Proche ((k[0] - (v+ u)) , Epsilon) ; } else { v = (k[2]* k[2]) * std::complex(9.0, 0.0) ; w = (k[1]* k[3]) * std::complex(32.0, 0.0) ; u = sqrt((v- w)) ; v = (k[2] * std::complex(-3.0, 0.0)) ; w = (k[1] * std::complex(4.0, 0.0)) ; x = ((v+ u) / w) ; y = ((v- u) / w) ; u = ((x* x) * std::complex(-2.0, 0.0)) ; u = sqrt((u- k[1])) ; v = ((y* y) * std::complex(-2.0, 0.0)) ; v = sqrt((v- k[1])) ; zProv[0][0] = (k[0]+ x) ; zProv[0][1] = (k[0] - (x- u)) ; zProv[0][2] = (k[0] - (x+ u)) ; zProv[1][0] = (k[0]+ y) ; zProv[1][1] = (k[0] - (y- v)) ; zProv[1][2] = (k[0] - (y+ v)) ; h[0] = 0.0 ; h[1] = 0.0 ; for (int i1 = 0; i1 < 3; i1++) { u = std::complex(1.0, 0.0) ; for (int i2 = 3; i2 >= 0; i2--) u = ((u* zProv[0][i1])+ aa[i2]) ; r = abs (u) ; h[0] = h[0] + r * r ; u = std::complex(1.0, 0.0) ; for (int i2 = 3; i2 >= 0; i2--) u = ((u* zProv[1][i1])+ aa[i2]) ; r = abs (u) ; h[1] = h[1] + r * r ; } int i1 = IndiceMin (2, h) ; for (int i2 = 0; i2 < 3; i2++) _solutions[i2] = Proche (zProv[i1][i2] , Epsilon) ; } _nbrSol = 3 ; _order.push_back(2); _order.push_back(1); _order.push_back(1); } else { /* 4 simple roots */ u = ((aa[0]* aa[2]) * std::complex(4.0, 0.0)) ; v = (aa[1] * aa[1]) ; w = ((aa[0]* aa[3]) * aa[3]) ; b[0] = (u - (v+ w)) ; b[1] = ((aa[1]* aa[3]) - (aa[0]* std::complex(4.0, 0.0))) ; b[2] = -aa[2] ; b[3] = std::complex(1.0, 0.0) ; /* The third degree equation is solved by forcing 3 distinct roots (computation precision problem) */ Equation eq(3,b); eq.Solve3(d4); //Solve3(d4); h[0] = abs ((eq.get_solutions()[1]- eq.get_solutions()[2])) ; /* the root the most distant to */ h[1] = abs ((eq.get_solutions()[0]- eq.get_solutions()[2])) ; /* the 2 others is selected */ h[2] = abs ((eq.get_solutions()[0]- eq.get_solutions()[1])) ; int i1 = IndiceMin (3, h) ; u = eq.get_solutions()[i1] ; v = ((aa[2]- u) * std::complex(4.0, 0.0)) ; v = sqrt(((aa[3]* aa[3]) - v)) ; w = sqrt(((u* u) - (aa[0]* std::complex(4.0, 0.0)))) ; x = ((aa[3]+ v) / std::complex(2.0, 0.0)) ; y = ((u+ w) / std::complex(2.0, 0.0)) ; d = sqrt(((x* x) - (y* std::complex(4.0, 0.0)))) ; zProv[0][0] = ((x- d) / std::complex(-2.0, 0.0)) ; zProv[0][1] = ((x+ d) / std::complex(-2.0, 0.0)) ; x = ((aa[3]- v) / std::complex(2.0, 0.0)) ; y = ((u- w) / std::complex(2.0, 0.0)) ; d = sqrt((x*x) - (y* std::complex(4.0, 0.0))) ; zProv[0][2] = ((x- d) / std::complex(-2.0, 0.0)) ; zProv[0][3] = ((x+ d) / std::complex(-2.0, 0.0)) ; x = ((aa[3]+ v) / std::complex(2.0, 0.0)) ; y = ((u- w) / std::complex(2.0, 0.0)) ; d = sqrt(((x*x) - (y* std::complex(4.0, 0.0)))) ; zProv[1][0] = ((x- d) / std::complex(-2.0, 0.0)) ; zProv[1][1] = ((x+ d) / std::complex(-2.0, 0.0)) ; x = ((aa[3]- v) / std::complex(2.0, 0.0)) ; y = ((u+ w) / std::complex(2.0, 0.0)) ; d = sqrt((x*x) - (y* std::complex(4.0, 0.0))) ; zProv[1][2] = ((x- d) / std::complex(-2.0, 0.0)) ; zProv[1][3] = ((x+ d) / std::complex(-2.0, 0.0)) ; h[0] = 0.0 ; h[1] = 0.0 ; for (int i1 = 0; i1 < 4; i1++) { u = std::complex(1.0, 0.0) ; for (int i2 = 3; i2 >= 0; i2--) u = ((u* zProv[0][i1])+ aa[i2]) ; r = abs (u) ; h[0] = h[0] + r * r ; u = std::complex(1.0, 0.0) ; for (int i2 = 3; i2 >= 0; i2--) u = ((u* zProv[1][i1])+ aa[i2]) ; r = abs(u) ; h[1] = h[1] + r * r ; } i1 = IndiceMin (2, h) ; if(_solutions != NULL) delete [] _solutions; _solutions = new std::complex[4]; if(_order.size() != 0) _order.clear(); for (int i2 = 0; i2 < 4; i2++) { _solutions[i2] = Proche (zProv[i1][i2] , Epsilon) ; _order.push_back(1); } _nbrSol = 4 ; } } int Equation::TestDegree3Triple(std::complex* a, double epsilon) { double d, dp[2], q, r ; std::complex u, v ; u = a[2]* a[2] ; v = a[1]*std::complex(3.0, 0.0) ; dp[0] = abs (u) ; dp[1] = abs (v) ; d = (dp[0] > dp[1]) ? dp[0] : dp[1] ; q = (d > epsilon) ? abs((u- v)/ std::complex (d, 0.0)) : 0.0 ; u = a[1]* a[2]; v = a[0]* std::complex(9.0, 0.0) ; dp[0] = abs (u) ; dp[1] = abs (v) ; d = (dp[0] > dp[1]) ? dp[0] : dp[1] ; r = (d > epsilon) ? abs ((u-v)/std::complex(d, 0.0)) : 0.0 ; return ((q <= epsilon) && (r <= epsilon)) ? 1 : 0 ; } int Equation::TestDegree3SimpleDouble(std::complex* a, double epsilon) { double d, k, r[5] ; std::complex u, t[5] ; u = a[1]*a[2] ; t[0] = pow (a[1], 3.0)*std::complex(4.0, 0.0) ; t[1] = a[0]*a[0]* std::complex(27.0, 0.0); t[2] = a[0]* std::complex(4.0, 0.0)*pow (a[2], 3.0) ; t[3] = -(u* u) ; t[4] = std::complex(-18.0, 0.0)* a[0] * u; for (int i = 0 ; i < 5 ; i++) r[i] = abs (t[i]) ; k = r[IndiceMax(5, r)] ; for (int i = 1 ; i < 5 ; i++) t[0] = t[0]+t[i]; d = (k > epsilon) ? abs (t[0]/std::complex(k,0.0)) : 0.0 ; return (d <= epsilon) ? 1 : 0 ; } int Equation::IndiceMin ( int n , double *list ) { int iMin ; double xMin ; iMin = 0 ; xMin = list[0] ; for (int i = 1; i < n; i++) { if ( list[i] < xMin ) { iMin = i ; xMin = list[i] ; } } return iMin ; } int Equation::IndiceMax ( int n , double *list) { int iMax ; double xMax ; iMax = 0 ; xMax = list[0] ; for (int i = 1; i < n; i++) { if ( list[i] > xMax ) { iMax = i ; xMax = list[i] ; } } return iMax ; } int Equation::TestDegree4Quad ( std::complex *a , double epsilon ) { double r1, r2, r3 ; r1 = abs (a[1]) ; r2 = abs (a[2]) ; r3 = abs (a[3]) ; return ((r1 < epsilon) && (r2 < epsilon) && (r3 < epsilon)) ? 1 : 0 ; } int Equation::TestDegree4DoubleDouble ( std::complex *a , std::complex *k , double epsilon ) { int d4 ; double r0, r1, r2, h[5] ; std::complex u, t[5] ; u = (a[3]* a[3]) ; t[0] = (u* u) * std::complex(3.0 / 16.0, 0.0); t[1] = a[0] * std::complex(4.0,0.0); t[2] = a[3] * a[1]; t[3] = u * a[2]; t[4] = a[2] * a[2]; for (int i = 0 ; i < 5 ; i++) h[i] = abs (t[i]) ; r1 = h[IndiceMax(5, h)] ; u = (t[0]- t[1]) + t[2]; u = u - (t[3]- t[4]) ; r2 = (r1 > epsilon) ? abs (u) / r1 : 0.0 ; r1 = abs (k[2]) ; r0 = abs (k[1]) ; if ((r0 >= epsilon) && (r1 < epsilon) && (r2 < epsilon)) d4 = 1 ; else d4 = 0 ; return d4 ; } int Equation::TestDegree4SimpleTriple ( std::complex *a , std::complex *k , double epsilon ) { int d4 ; double r, r0, r1, r2, h[4] ; std::complex u, t[4] ; t[0] = a[2] * a[2] ; t[1] = a[0] * std::complex(12.0, 0.0); t[2] = (a[1]* a[3]) * std::complex(3.0, 0.0) ; for (int i = 0 ; i < 3 ; i++) h[i] = abs (t[i]) ; r = h[IndiceMax(3, h)] ; u = t[0] + (t[1]- t[2]) ; r1 = (r > epsilon) ? abs (u) / r : 0.0 ; t[0] = a[1] * a[1]; t[1] = (a[0]* a[2]) * std::complex(4.0, 0.0) ; u = a[3]* std::complex(3.0, 0.0) ; t[2] = (u* u) * (a[0]* std::complex(3.0, 0.0)) ; t[3] = (a[2]* a[2]) * a[2] ; for (int i = 0 ; i < 4 ; i++) h[i] = abs (t[i]) ; r = h[IndiceMax(4, h)] ; u = ((t[0]- t[1])* std::complex(27.0, 0.0))+ (t[2]- t[3]) ; r2 = (r > epsilon) ? abs (u) / r : 0.0 ; r0 = abs (k[1]) ; if ((r0 >= epsilon) && (r1 < epsilon) && (r2 < epsilon)) d4 = 1 ; else d4 = 0 ; return d4 ; } int Equation::TestDegreeSimpleSimpleDouble( std::complex *a , double epsilon ) { double r[3] ; std::complex u, v, w ; u = (a[1]* a[1]) - (a[3]* std::complex(4.0, 0.0)) ; u = u* a[3] * u * std::complex(16.0, 0.0); r[0] = abs (u) ; w = pow (a[1], 3.0) * std::complex(4.0, 0.0) ; v = (a[2]* a[2]) * std::complex(27.0, 0.0) , v = (w+ v) * (a[2]* a[2]) ; r[1] = abs (v) ; w = (a[1]* a[2]) * (a[2]* a[3]) ; w = w * std::complex(144.0, 0.0) ; r[2] = abs (w) ; r[1] = r[IndiceMax(3, r)] ; if (r[1] < epsilon) r[0] = 0.0 ; else if (r[1] <= 1.0) r[0] = abs ((u- v)+ w) ; else r[0] = abs (((u- v)+ w)/ std::complex(r[1], 0.0)) ; return (r[0] < (2.0 * epsilon)) ? 1 : 0 ; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Equation.h000066400000000000000000000062121301006202600262200ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Equation_h #define Equation_h #include #include #include namespace ossimplugins { /** * @brief This class manages and solves an equation of the fourth degree */ class OSSIM_PLUGINS_DLL Equation { public: /** * @brief Constructor */ Equation(); /** * @brief Destructor */ ~Equation(); Equation(const Equation& rhs); Equation& operator=(const Equation& rhs); Equation(int degree, std::complex* coefficients); void CreateEquation(int degree, std::complex* coefficients); void Solve(); int get_nbrSol() const { return _nbrSol; }; const std::complex* get_solutions() const { return _solutions; }; std::vector get_order() const { return _order; }; protected: /** * @brief Equation coefficients */ std::complex* _coefficients; /** * @brief Equation degree */ int _degree; void ComputeTrueDegree(); void Normalisation(); void DeNormalisation(); static const double Epsilon; int _nbrSol; std::vector _order; std::complex* _solutions; private: enum NormalisationType { GreatValues, SmallValues }; NormalisationType _normalisationType; double _normalisationCoefficient; int _trueDegree; void Solve1(); void Solve2(); void Solve3(int d4 =0); void Solve4(); /** * ?? */ std::complex Proche(std::complex z, double epsilon); /** * @brief Tests whether a triple root exists in a third degree equation */ int TestDegree3Triple(std::complex* a, double epsilon); /** * @brief Tests whether a double root and a simple root exist in a third degree equation */ int TestDegree3SimpleDouble(std::complex* a, double epsilon); /** * @brief Returns the index of the smaller list element */ int IndiceMin ( int n , double *list); /** * @brief Returns the index of the greater list element */ int IndiceMax ( int n , double *list); /** * @brief Tests whether a quadruple root exists in a fourth degree equation */ int TestDegree4Quad ( std::complex *a , double epsilon ); /** * @brief Tests whether two double roots exist in a fourth degree equation */ int TestDegree4DoubleDouble ( std::complex *a , std::complex *k , double epsilon ); /** * @brief Tests whether one simple root and one triple root exist in a fourth degree equation */ int TestDegree4SimpleTriple ( std::complex *a , std::complex *k , double epsilon ); /** * @brief Tests whether two simple root and one double root exist in a fourth degree equation */ int TestDegreeSimpleSimpleDouble( std::complex *a , double epsilon ); ; }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GMSTDateTime.cpp000066400000000000000000000016021301006202600271530ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include namespace ossimplugins { GMSTDateTime::GMSTDateTime(): _tms(0) { } GMSTDateTime::~GMSTDateTime() { } GMSTDateTime::GMSTDateTime(const GMSTDateTime& rhs): _tms(rhs._tms), _origine(rhs._origine) { } GMSTDateTime::GMSTDateTime(double tms, Ori_TSM_Green origine): _tms(tms), _origine(origine) { } GMSTDateTime::GMSTDateTime(CivilDateTime& rhs) { rhs.AsGMSTDateTime(this); } GMSTDateTime& GMSTDateTime::operator=(const GMSTDateTime& rhs) { _tms = rhs._tms; _origine = rhs._origine; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GMSTDateTime.h000066400000000000000000000027231301006202600266250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef GMSTDateTime_h #define GMSTDateTime_h #include #include namespace ossimplugins { class CivilDateTime; class JulianDate; /** * @ingroup Date * @brief This class represents a date */ class OSSIM_PLUGINS_DLL GMSTDateTime { public: enum Ori_TSM_Green { AN1900 , AN1950 , AN2000 } ; /** * @brief constructor */ GMSTDateTime(); /** * @brief Destructor */ ~GMSTDateTime(); /** * @brief Copy constructor */ GMSTDateTime(const GMSTDateTime& rhs); /** * @brief Constructor with date initialization */ GMSTDateTime(double tsm, Ori_TSM_Green origine); /** * @brief Constructor with date initialization using a CivilDateTime */ GMSTDateTime(CivilDateTime& rhs); /** * @brief Affectation operator */ GMSTDateTime& operator=(const GMSTDateTime& rhs); double get_tms() { return _tms; }; void set_tms(double tms) { _tms = tms; }; Ori_TSM_Green get_origine() { return _origine; }; void set_origine(Ori_TSM_Green origine) { _origine = origine; } protected: double _tms; Ori_TSM_Green _origine; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GalileanEphemeris.cpp000066400000000000000000000206511301006202600303470ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include namespace ossimplugins { GalileanEphemeris::GalileanEphemeris() { } GalileanEphemeris::~GalileanEphemeris() { } GalileanEphemeris::GalileanEphemeris(JSDDateTime date, double pos[3], double speed[3]) : Ephemeris(date, pos, speed) { } GalileanEphemeris::GalileanEphemeris(const GalileanEphemeris& rhs) : Ephemeris(rhs) { } GalileanEphemeris& GalileanEphemeris::operator=(const GalileanEphemeris& rhs) { ((Ephemeris)*this) = ((Ephemeris)rhs); return *this; } void GalileanEphemeris::ToGeographic(GeographicEphemeris* vGeo) { const double OMEGATERRE = 6.28318530717958647693 / 86164.09054 ; GMSTDateTime h; h.set_origine(GMSTDateTime::AN1950); double s,c; double pos[3]; double speed[3]; _date.AsGMSTDateTime(&h) ; c = cos (h.get_tms()) ; s = sin (h.get_tms()) ; vGeo->set_date(_date); pos[0] = _position[0] * c + _position[1] * s ; pos[1] = - _position[0] * s + _position[1] * c ; pos[2] = _position[2] ; speed[0] = _speed[0] * c + _speed[1] * s - OMEGATERRE * (_position[0] * s - _position[1] * c) ; speed[1] = - _speed[0] * s + _speed[1] * c - OMEGATERRE * (_position[0] * c + _position[1] * s) ; speed[2] = _speed[2] ; vGeo->set_position(pos); vGeo->set_speed(speed); } void GalileanEphemeris::ToGeographic(double greenwich,GeographicEphemeris* vGeo) { const double OMEGATERRE = 6.28318530717958647693 / 86164.09054 ; // int etat, int ierr ; double p[10],pd[10]; double day; // etat = 0 ; vGeo->set_date(this->_date); day= this->_date.get_day0hTU().get_julianDate(); ierr = p2nutt( 2, greenwich, day, p, pd ) ; double position[3]; double speed[3]; position[0] = _position[0]*p[1] + _position[1]*p[4] + _position[2]*p[7] ; position[1] = _position[0]*p[2] + _position[1]*p[5] + _position[2]*p[8] ; position[2] = _position[0]*p[3] + _position[1]*p[6] + _position[2]*p[9] ; speed[0] = _speed[0]*p[1] +_speed[1]*p[4] + _speed[2]*p[7] + OMEGATERRE * (_position[0]*pd[1] + _position[1]*pd[4] + _position[2]*pd[7] ); speed[1] = _speed[0]*p[2] + _speed[1]*p[5] + _speed[2] *p[8] + OMEGATERRE * (_position[0]*pd[2] + _position[1]*pd[5] + _position[2]*pd[8] ); speed[2] = _speed[0]*p[3] + _speed[1]*p[6] + _speed[2]*p[9] + OMEGATERRE * (_position[0]*pd[3] + _position[1]*pd[6] + _position[2]*pd[9] ); vGeo->set_position(position); vGeo->set_speed(speed); } GalileanEphemeris::operator GeographicEphemeris() { GeographicEphemeris rhs; ToGeographic(&rhs); return rhs; } GalileanEphemeris::GalileanEphemeris(GeographicEphemeris& rhs) { rhs.ToGalilean(this); } int GalileanEphemeris::p2nutt(int newcmb, double greenwich, double day, double p[], double pd[] ) { const double PI = 3.14159265358979323846 ; const double TWOPI = 6.28318530717958647693 ; // const double MU = 3.9860047e+14 ; // const double JOURCIVIL_LENGTH = 86400.0 ; // const double JOURSIDERAL = 86164.09054 ; // const double OMEGATERRE = 6.28318530717958647693 / 86164.09054 ; // const double CLUM = 2.99792458e+8 ; // const double A_WGS84 = 6378137.0 ; // const double B_WGS84 = 6356752.3141 ; /* GIVES TRANSFORMATION MATRIX P(3,3) FROM QUASI-INERTIAL MEAN SYSTEM OF DATE TO TRUE SYSTEM OF DATE OR EARTH-FIXED ROTATING SYSTEM BY ROTATION (OPTIONAL) AND NUTATION. USES SIMPLIFIED ANALYTICAL MODEL DERIVED FROM THE 1980 IAU WAHR THEORY OF NUTATION (REF: ASTRONOMICAL ALMANAC 1984, PP. S23-S26) BY SKIPPING MOST TERMS BELOW 0.03 ARCSEC. ACCURACY = 0.5D-6 RADIANS. DAY = Julian Day newcmb =-1 => TO TRUE SYSTEM OF DATE = 0 => INTERMEDIATE TRANSFORMATION TO EARTH-FIXED ROTATING SYSTEM BUT WITHOUT NEWCOMB'S ANGLE. (NOT TRUE-OF-DATE) = 1 => TO EARTH-FIXED ROTATING SYSTEM P(3,3) = ROTATION MATRIX SUCH THAT THE TRANSFORMATION IS R(TRANSF) = P * R(INERT) COMMON BLOCKS FROM PEPSOC SUBROUTINE 'P2COOT' ARE USED. */ double arg[10] ; double t, ff, dd, dpsi, deps; double ecl, cecl, secl, dnu, srang; double sra, cra, snu, cnu, sde, cde; double facsin[10],faccos[10]; int i; /* DATA FOR NUTATION MODELLING */ facsin[0]=0.e0; facsin[1]=-0.8338601e-04; facsin[2]=-0.6393238e-05; facsin[3]=-0.1102466e-05; facsin[4]=0.9996858e-06; facsin[5]=0.6913443e-06; facsin[6]=0.3451873e-06; facsin[7]=-0.2506487e-06; facsin[8]=-0.1871381e-06; facsin[9]=-0.1459289e-06; faccos[0]=0.e0; faccos[1]=0.4461498e-04; faccos[2]=0.2780891e-05; faccos[3]=0.4736630e-06; faccos[4]=-0.4339082e-06; faccos[5]=0.2617994e-07; faccos[6]=-0.3393696e-08; faccos[7]=0.1085983e-06; faccos[8]=0.9696274e-07; faccos[9]=0.6254096e-07; /* ECL = OBLIQUITY OF ECLIPTIC AT EPOCH J2000.0 ECL CHANGES BY -0.01300 DEG/CENTURY. ECL = 23 DEG + 26 ' + 21.4119 " */ ecl = PI/180.e0*(23.e0 + (26.e0 + 21.4119e0/6.e1)/6.e1); cecl = cos(ecl); secl = sin(ecl); /*t= Julian day relative to year 2000 at 12:00:00 */ t = day-2451540. - 0.5 ; /* L = MEAN ANOMALY OF THE MOON */ arg[6] = fmod( 0.2355548394e+01 + t*( 0.2280271437e+00 + t* 0.1137830e-12 ),TWOPI); /*C L-PRIME = MEAN ANOMALY OF THE SUN (EARTH) */ arg[5] = fmod( 0.6240035939e+01 + t*( 0.1720197005e-01 - t* 0.2096864e-14 ),TWOPI); /* F = L - OMEGA (SEE ABOVE AND BELOW) */ ff = fmod( 0.1627901934e+01 + t*( 0.2308957196e+00 - t* 0.4817699e-13 ),TWOPI); /* D = MEAN ELONGATION OF THE MOON FROM THE SUN */ dd = fmod( 0.5198469514e+01 + t*( 0.2127687104e+00 - t* 0.2504244e-13 ),TWOPI); /* OMEGA = LONGITUDE OF MOON'S ASCENDING NODE FROM MEAN EQUINOX OF DATE */ arg[0]=0.e0; arg[1] = fmod( 0.2182438624e+01 - t*( 0.9242175478e-03 - t* 0.2709206e-13 ),TWOPI); arg[3] = 2.e0*(ff + arg[1]); arg[2] = arg[3] - 2.e0*dd ; arg[4] = 2.e0*arg[1] ; arg[7] = arg[5] + arg[2] ; arg[8] = 2.e0*ff + arg[1] ; arg[9] = arg[6] + arg[3] ; dpsi = 0.e0; deps = 0.e0; for ( i=1 ; i<=9; i++ ) { dpsi = dpsi + facsin[i] * sin(arg[i]); deps = deps + faccos[i] * cos(arg[i]); } /* ROTATION OF -deps AROUND THE X-AXIS */ cde=cos(deps); sde=sin(deps); /* ROTATION OF DNU = dpsi*SIN(ECLIPT) AROUND THE Y-AXIS */ dnu = dpsi*secl; cnu=cos(dnu); snu=sin(dnu); /* SELECT WHICH ROTATION IS WANTED FOR THE Z-AXIS */ srang=0.e0; if (newcmb == -1) { /* ROTATION OF SRANG = -DMU = -dpsi*COS(ECLIPT) AROUND THE Z-AXIS */ srang = -dpsi*cecl; } else if ( newcmb == 0) { srang = 0.e0; } else if ( newcmb == 1 ) { /* SIDEREAL ANGLE, FROM 'COOT20' WITH NEWCOMB'S FORMULA:*/ /*srang = fmod(STD20R+(OMT20R+OMQ20R*day)*day,TWOPI);*/ } else if ( newcmb == 2 ) { /* SIDEREAL ANGLE, FROM INPUT */ srang = fmod(greenwich*PI/180.e0,TWOPI) ; /*printf("srang dans p2nutt %g",greenwich);*/ } else { return -1;; } sra=sin(srang); cra=cos(srang); /* ROTATION MATRIX = RZ(SRANG)*RX(-deps)*RY(DNU) */ p[0] = 0.e0; p[1] = cra*cnu - sra*sde*snu ; p[2] = -sra*cnu - cra*sde*snu ; p[3] = cde*snu ; p[4] = sra*cde ; p[5] = cra*cde ; p[6] = sde ; p[7] = -cra*snu - sra*sde*cnu ; p[8] = sra*snu - cra*sde*cnu ; p[9] = cde*cnu ; pd[0] = 0.e0; pd[1] = -sra*cnu - cra*sde*snu ; pd[2] = -cra*cnu + sra*sde*snu ; pd[3] = 0. ; pd[4] = cra*cde ; pd[5] = -sra*cde ; pd[6] = 0. ; pd[7] = sra*snu - cra*sde*cnu ; pd[8] = cra*snu + sra*sde*cnu ; pd[9] = 0. ; return 1; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GalileanEphemeris.h000066400000000000000000000032341301006202600300120ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef GalileanEphemeride_h #define GalileanEphemeride_h #include #include namespace ossimplugins { class GeographicEphemeris; /** * @ingroup Ephemeris * @brief This class represents an ephemeris in Galilean coordinates system */ class OSSIM_PLUGINS_DLL GalileanEphemeris : public Ephemeris { public: /** * @brief Constructor */ GalileanEphemeris(); /** * @brief Destructor */ ~GalileanEphemeris(); /** * @brief Constructor with initialisations */ GalileanEphemeris(JSDDateTime date, double pos[3], double speed[3]); /** * @brief Copy constructor */ GalileanEphemeris(const GalileanEphemeris& rhs); GalileanEphemeris(GeographicEphemeris& rhs); /** * @brief Affectation operator */ GalileanEphemeris& operator=(const GalileanEphemeris& rhs); /** * @brief This fonction converts the current ephemeris in the Geographic coordinates syst�m */ void ToGeographic(GeographicEphemeris* vGeo); void ToGeographic(double greenwich,GeographicEphemeris* vGeo); operator GeographicEphemeris(); /** * @brief This function creates a copy of the current class */ virtual Ephemeris* Clone() { return new GalileanEphemeris(*this); }; protected: int p2nutt(int newcmb, double greenwich, double day, double p[], double pd[] ); private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GeodesicCoordinate.cpp000066400000000000000000000014651301006202600305250ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { GeodesicCoordinate::GeodesicCoordinate() { } GeodesicCoordinate::~GeodesicCoordinate() { } GeodesicCoordinate::GeodesicCoordinate(double x, double y, double z): Coordinate(x,y,z) { } GeodesicCoordinate::GeodesicCoordinate(const GeodesicCoordinate& rhs): Coordinate((Coordinate)rhs) { } GeodesicCoordinate& GeodesicCoordinate::operator=(const GeodesicCoordinate& rhs) { _x = rhs._x; _y = rhs._x; _z = rhs._x; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GeodesicCoordinate.h000066400000000000000000000021231301006202600301620ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef GeodesicCoordinate_h #define GeodesicCoordinate_h #include #include namespace ossimplugins { /** * @ingroup Date * @brief This class represents a coordinate in a geodesic reference */ class OSSIM_PLUGINS_DLL GeodesicCoordinate : public Coordinate { public: /** * @brief Constructor */ GeodesicCoordinate(); /** * @brief Destructor */ ~GeodesicCoordinate(); /** * @brief Cosntructor with initializations */ GeodesicCoordinate(double x, double y, double z); /** * @brief Copy constructor */ GeodesicCoordinate(const GeodesicCoordinate& rhs); /** * @brief Affectation operator */ GeodesicCoordinate& operator=(const GeodesicCoordinate& rhs); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GeographicEphemeris.cpp000066400000000000000000000036161301006202600307050ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include namespace ossimplugins { GeographicEphemeris::GeographicEphemeris() : Ephemeris() { } GeographicEphemeris::~GeographicEphemeris() { } GeographicEphemeris::GeographicEphemeris(JSDDateTime date, double pos[3], double speed[3]) : Ephemeris(date, pos, speed) { } GeographicEphemeris::GeographicEphemeris(const GeographicEphemeris& rhs) : Ephemeris(rhs) { } GeographicEphemeris& GeographicEphemeris::operator=(const GeographicEphemeris& rhs) { ((Ephemeris)*this) = ((Ephemeris)rhs); return *this; } void GeographicEphemeris::ToGalilean(GalileanEphemeris* vGal) { const double OMEGATERRE = 6.28318530717958647693 / 86164.09054 ; GMSTDateTime h; h.set_origine(GMSTDateTime::AN1950); double s,c; _date.AsGMSTDateTime(&h) ; c = cos (h.get_tms()) ; s = sin (h.get_tms()) ; vGal->set_date(_date); double pos[3]; double speed[3]; pos[0] = _position[0] * c - _position[1] * s ; pos[1] = _position[0] * s + _position[1] * c ; pos[2] = _position[2] ; speed[0] = _speed[0] * c - _speed[1] * s - OMEGATERRE * (_position[0] * s + _position[1] * c) ; speed[1] = _speed[0] * s + _speed[1] * c + OMEGATERRE * (_position[0] * c - _position[1] * s) ; speed[2] = _speed[2] ; vGal->set_position(pos); vGal->set_speed(speed); } GeographicEphemeris::operator GalileanEphemeris() { GalileanEphemeris rhs; ToGalilean(&rhs); return rhs; } GeographicEphemeris::GeographicEphemeris(GalileanEphemeris& rhs) { rhs.ToGeographic(this); } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/GeographicEphemeris.h000066400000000000000000000030331301006202600303430ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef GeographicEphemeride_h #define GeographicEphemeride_h #include #include namespace ossimplugins { class GalileanEphemeris; /** * @ingroup Ephemeris * @brief This class represent an ephemeris in Geographic coordinates system */ class OSSIM_PLUGINS_DLL GeographicEphemeris : public Ephemeris { public: /** * @brief Constructor */ GeographicEphemeris(); /** * @brief Destructor */ virtual ~GeographicEphemeris(); /** * @brief Constructor with initialisations */ GeographicEphemeris(JSDDateTime date, double pos[3], double speed[3]); /** * @brief Copy constructor */ GeographicEphemeris(const GeographicEphemeris& rhs); GeographicEphemeris(GalileanEphemeris& rhs); /** * @brief Affectation operator */ GeographicEphemeris& operator=(const GeographicEphemeris& rhs); /** * @brief This fonction converts the current ephemeris in the Galilean coordinates system */ void ToGalilean(GalileanEphemeris* vGal); operator GalileanEphemeris(); /** * @brief This function creates a copy of the current class */ virtual Ephemeris* Clone() { return new GeographicEphemeris(*this); }; protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/HermiteInterpolator.cpp000066400000000000000000000151741301006202600307750ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include namespace ossimplugins { HermiteInterpolator::HermiteInterpolator(): theNPointsAvailable(0), theXValues(NULL), theYValues(NULL), thedYValues(NULL), prodC(NULL), sumC(NULL), isComputed(false) { } HermiteInterpolator::HermiteInterpolator(int nbrPoints, double* x, double* y, double* dy): theNPointsAvailable(nbrPoints), prodC(NULL), sumC(NULL), isComputed(false) { if(x != NULL) { theXValues = new double[theNPointsAvailable]; for (int i=0;i theXValues[i-1]); } } HermiteInterpolator::~HermiteInterpolator() { Clear(); } HermiteInterpolator::HermiteInterpolator(const HermiteInterpolator& rhs): theNPointsAvailable(rhs.theNPointsAvailable), prodC(NULL), sumC(NULL), isComputed(false) { if(rhs.theXValues != NULL) { theXValues = new double[theNPointsAvailable]; for (int i=0;i namespace ossimplugins { /** * @brief Abstract interpolator * @see Interpolate */ class OSSIM_PLUGINS_DLL HermiteInterpolator { public: /** * @brief Constructor */ HermiteInterpolator(); /** * @brief Constructor with initializations * @param nbrPoints Number of points used to perform the interpolation * @param x Values of the points abscissa * @param y Values of the points * @param dy Values of the differential coefficients */ HermiteInterpolator(int nbrPoints, double* x, double* y, double* dy); /** * @brief Destructor */ ~HermiteInterpolator(); /** * @brief Copy constructor */ HermiteInterpolator(const HermiteInterpolator& rhs); /** * @brief Affectation operator */ HermiteInterpolator& operator =(const HermiteInterpolator& rhs); /** * @brief This function performs the interpolation for the abscissa x * @param x Abscissa of the interpolation * @param y [out] value of the point at the abscissa x * @param dy [out] value of the differential coefficient at abscissa x * @return Different of 0 if an error occurs */ int Interpolate(double x, double& y, double& dy) const; /** * @brief This function performs the interpolation for the abscissa x * @param x Abscissa of the interpolation * @param y [out] value of the point at the abscissa x * @return Different of 0 if an error occurs */ int Interpolate(double x, double& y) const; protected: void Clear(); int theNPointsAvailable; double* theXValues; double* theYValues; double* thedYValues; mutable double* prodC; mutable double* sumC; mutable bool isComputed; int Precompute() const; // const in a semantic way private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/ImageNoise.cpp000066400000000000000000000154051301006202600270120ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char PREFIX[] = "imageNoise."; // static const char TIME_UTC[] = "timeUTC"; static const char UTC_TIME[] = "timeUTC"; static const char NOISE_ESTIMATE[] = "noiseEstimate."; static const char REFERENCE_POINT[] = "referencePoint"; static const char VALIDITY_RANGE_MIN[] = "validityRangeMin"; static const char VALIDITY_RANGE_MAX[] = "validityRangeMax"; static const char POLYNOMIAL_DEGREE[] = "polynomialDegree"; static const char COEFFICIENT[] = "coefficient"; static const char NOISE_ESTIMATE_CONFIDENCE[] = "noiseEstimateConfidence"; ImageNoise::ImageNoise(): _timeUTC(), _validityRangeMin(0.), _validityRangeMax(0.), _referencePoint(0.), _polynomialDegree(0), _polynomialCoefficients(0) { } ImageNoise::~ImageNoise() { } ImageNoise::ImageNoise(const ImageNoise& rhs): _timeUTC(rhs._timeUTC), _validityRangeMin(rhs._validityRangeMin), _validityRangeMax(rhs._validityRangeMax), _referencePoint(rhs._referencePoint), _polynomialDegree(rhs._polynomialDegree), _polynomialCoefficients(rhs._polynomialCoefficients) { } ImageNoise& ImageNoise::operator=(const ImageNoise& rhs) { _timeUTC = rhs._timeUTC; _validityRangeMin = rhs._validityRangeMin; _validityRangeMax = rhs._validityRangeMax; _referencePoint = rhs._referencePoint; _polynomialDegree = rhs._polynomialDegree; _polynomialCoefficients = rhs._polynomialCoefficients; return *this; } bool ImageNoise::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx; std::string pfx2; if (prefix) { pfx = prefix; } pfx += PREFIX; kwl.add(pfx.c_str(), UTC_TIME, _timeUTC); pfx2 = pfx + NOISE_ESTIMATE; kwl.add(pfx2.c_str(), VALIDITY_RANGE_MIN, _validityRangeMin); kwl.add(pfx2.c_str(), VALIDITY_RANGE_MAX, _validityRangeMax); kwl.add(pfx2.c_str(), REFERENCE_POINT, _referencePoint); kwl.add(pfx2.c_str(), POLYNOMIAL_DEGREE, _polynomialDegree); for(unsigned int i=0 ; i<_polynomialCoefficients.size();i++) { ossimString iStr = ossimString::toString(i); ossimString kw = ossimString(COEFFICIENT) + "["+iStr+ "]"; kwl.add(pfx2.c_str(), kw.c_str(), _polynomialCoefficients[i]); } return true; } bool ImageNoise::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "ImageNoise::loadState"; bool result = true; std::string pfx; std::string pfx2; if (prefix) { pfx = prefix; } ossimString s; const char* lookup = 0; pfx += PREFIX; lookup = kwl.find(pfx.c_str(), UTC_TIME); if (lookup) { s = lookup; _timeUTC = s; } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << UTC_TIME << " in "< #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup ImageNoise * @brief This class represents an ImageNoise */ class OSSIM_PLUGINS_DLL ImageNoise { public: /** * @brief Constructor */ ImageNoise(); /** * @brief Destructor */ virtual ~ImageNoise(); /** * @brief Copy constructor */ ImageNoise(const ImageNoise& rhs); /** * @brief Affectation operator */ ImageNoise& operator=(const ImageNoise& rhs); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); void set_timeUTC(const ossimString& value) { _timeUTC = value; } const ossimString & get_timeUTC(void) const { return _timeUTC; } void set_validityRangeMin(double value) { _validityRangeMin = value; } double get_validityRangeMin(void) const { return _validityRangeMin; } void set_validityRangeMax(double value) { _validityRangeMax = value; } double get_validityRangeMax(void) const { return _validityRangeMax; } void set_referencePoint(double value) { _referencePoint = value; } double get_referencePoint(void) const { return _referencePoint; } void set_polynomialDegree(unsigned int value) { _polynomialDegree = value; } unsigned int get_polynomialDegree() const { return _polynomialDegree; } void set_polynomialCoefficients(const std::vector& value) { _polynomialCoefficients = value; } const std::vector & get_polynomialCoefficients(void) const { return _polynomialCoefficients; } protected: /** * @brief TimeUTC (Noise/ImageNoise node). */ ossimString _timeUTC; /** * @brief ValidityRangeMin (Noise/ImageNoise node). */ double _validityRangeMin; /** * @brief ValidityRangeMax (Noise/ImageNoise node). */ double _validityRangeMax; /** * @brief Reference point (Noise/ImageNoise node). */ double _referencePoint; /** * @brief Polynomial degree (Noise/ImageNoise node). */ unsigned int _polynomialDegree; /** * @brief Polynomial coefficients (Noise/ImageNoise node). */ std::vector _polynomialCoefficients; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/IncidenceAngles.cpp000066400000000000000000000110001301006202600277700ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char INCIDENCE_ANGLES[] = "incidenceAngles"; static const char NUMBER_OF_CORNER_INCIDENCE_ANGLES[] = "numberOfCornerIncidenceAngles"; static const char CENTER_INCIDENCE_ANGLE[] = "centerInfoIncidenceAngle"; static const char CORNERS_INCIDENCE_ANGLE[] = "cornersInfoIncidenceAngle"; IncidenceAngles::IncidenceAngles(): _numberOfCornerIncidenceAngles(0), _centerInfoIncidenceAngle(), _tabCornersInfoIncidenceAngle() { } IncidenceAngles::~IncidenceAngles() { } IncidenceAngles::IncidenceAngles(const IncidenceAngles& rhs): _numberOfCornerIncidenceAngles(rhs._numberOfCornerIncidenceAngles), _centerInfoIncidenceAngle(rhs._centerInfoIncidenceAngle), _tabCornersInfoIncidenceAngle(rhs._tabCornersInfoIncidenceAngle) { } IncidenceAngles& IncidenceAngles::operator=(const IncidenceAngles& rhs) { _numberOfCornerIncidenceAngles = rhs._numberOfCornerIncidenceAngles; _centerInfoIncidenceAngle = rhs._centerInfoIncidenceAngle; _tabCornersInfoIncidenceAngle = rhs._tabCornersInfoIncidenceAngle; return *this; } bool IncidenceAngles::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx(""); std::string pfx2(""); if (prefix) { pfx = prefix; } pfx += INCIDENCE_ANGLES; pfx2 = pfx; pfx2 += "."; kwl.add(pfx2.c_str(), NUMBER_OF_CORNER_INCIDENCE_ANGLES, _numberOfCornerIncidenceAngles); std::string s = pfx + "." + CENTER_INCIDENCE_ANGLE; _centerInfoIncidenceAngle.saveState(kwl, s.c_str()); std::string s2 =pfx + "." + CORNERS_INCIDENCE_ANGLE; for (unsigned int i = 0; i < _tabCornersInfoIncidenceAngle.size(); ++i) { std::string s3 = s2 + "[" + ossimString::toString(i).c_str() + "]"; _tabCornersInfoIncidenceAngle[i].saveState(kwl, s3.c_str()); } return true; } bool IncidenceAngles::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "IncidenceAngles::loadState"; bool result = true; ossimString s; const char* lookup = 0; std::string pfx(""); if (prefix) { pfx = prefix; } pfx += INCIDENCE_ANGLES; pfx += "."; lookup = kwl.find(pfx.c_str(), NUMBER_OF_CORNER_INCIDENCE_ANGLES); if (lookup) { s = lookup; _numberOfCornerIncidenceAngles = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << NUMBER_OF_CORNER_INCIDENCE_ANGLES << " in "< #include #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup IncidenceAngles * @brief This class represents Incidence Angles */ class OSSIM_PLUGINS_DLL IncidenceAngles { public: /** * @brief Constructor */ IncidenceAngles(); /** * @brief Destructor */ virtual ~IncidenceAngles(); /** * @brief Copy constructor */ IncidenceAngles(const IncidenceAngles& rhs); /** * @brief Affectation operator */ IncidenceAngles& operator=(const IncidenceAngles& rhs); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; void set_numberOfCornerIncidenceAngles(const ossim_uint32& numberOfCornerIncidenceAngles) { _numberOfCornerIncidenceAngles = numberOfCornerIncidenceAngles; } void set_centerInfoIncidenceAngle(const InfoIncidenceAngle& centerInfoIncidenceAngle) { _centerInfoIncidenceAngle = centerInfoIncidenceAngle; } void set_cornersInfoIncidenceAngle(const std::vector& cornersInfoIncidenceAngle) { _tabCornersInfoIncidenceAngle = cornersInfoIncidenceAngle; } protected: /** * @brief Number of incidence angles */ ossim_uint32 _numberOfCornerIncidenceAngles; /** * @brief Center InfoIncidenceAngle. */ InfoIncidenceAngle _centerInfoIncidenceAngle; /** * @brief Corners InfoIncidenceAngle. */ std::vector _tabCornersInfoIncidenceAngle; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/InfoIncidenceAngle.cpp000066400000000000000000000053411301006202600304340ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char PREFIX[] = ".infoIncidenceAngle."; static const char REF_ROW[] = "refRow"; static const char REF_COLUMN[] = "refColumn"; static const char INCIDENCE_ANGLE[] = "incidenceAngle"; InfoIncidenceAngle::InfoIncidenceAngle(): _refRow(0), _refColumn(0), _incidenceAngle(0.) { } InfoIncidenceAngle::~InfoIncidenceAngle() { } InfoIncidenceAngle::InfoIncidenceAngle(const InfoIncidenceAngle& rhs): _refRow(rhs._refRow), _refColumn(rhs._refColumn), _incidenceAngle(rhs._incidenceAngle) { } InfoIncidenceAngle& InfoIncidenceAngle::operator=(const InfoIncidenceAngle& rhs) { _refRow = rhs._refRow; _refColumn = rhs._refColumn; _incidenceAngle = rhs._incidenceAngle; return *this; } bool InfoIncidenceAngle::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx; if (prefix) { pfx = prefix; } pfx += PREFIX; kwl.add(pfx.c_str(), REF_ROW, _refRow); kwl.add(pfx.c_str(), REF_COLUMN, _refColumn); kwl.add(pfx.c_str(), INCIDENCE_ANGLE, _incidenceAngle); return true; } bool InfoIncidenceAngle::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "InfoIncidenceAngle::loadState"; bool result = true; std::string pfx; if (prefix) { pfx = prefix; } ossimString s; const char* lookup = 0; pfx += PREFIX; lookup = kwl.find(pfx.c_str(), REF_ROW); if (lookup) { s = lookup; _refRow = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << REF_ROW << " in "< #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup InfoIncidenceAngle * @brief This class represents an InfoIncidenceAngle */ class OSSIM_PLUGINS_DLL InfoIncidenceAngle { public: /** * @brief Constructor */ InfoIncidenceAngle(); /** * @brief Destructor */ virtual ~InfoIncidenceAngle(); /** * @brief Copy constructor */ InfoIncidenceAngle(const InfoIncidenceAngle& rhs); /** * @brief Affectation operator */ InfoIncidenceAngle& operator=(const InfoIncidenceAngle& rhs); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); void set_refRow(ossim_uint32 value) { _refRow = value; } void set_refColumn(ossim_uint32 value) { _refColumn = value; } void set_incidenceAngle(double value) { _incidenceAngle = value; } protected: /** * @brief Reference Row (refRow node). */ ossim_uint32 _refRow; /** * @brief Reference Column (refColumn node). */ ossim_uint32 _refColumn; /** * @brief IncidenceAngle (incidenceAngle node). */ double _incidenceAngle; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/InfoSceneCoord.cpp000066400000000000000000000105551301006202600276330ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char PREFIX[] = "."; static const char REF_ROW[] = "refRow"; static const char REF_COLUMN[] = "refColumn"; static const char LAT[] = "lat"; static const char LON[] = "lon"; static const char AZIMUTH_TIME[] = "azimuthTimeUTC"; static const char RANGE_TIME[] = "rangeTime"; static const char INCIDENCE_ANGLE[] = "incidenceAngle"; InfoSceneCoord::InfoSceneCoord(): _refRow(0), _refColumn(0), _lat(0.0), _lon(0.0), _azimuthTimeUTC(), _rangeTime(0.0), _incidenceAngle(0.) { } InfoSceneCoord::~InfoSceneCoord() { } InfoSceneCoord::InfoSceneCoord(const InfoSceneCoord& rhs): _refRow(rhs._refRow), _refColumn(rhs._refColumn), _lat(rhs._lat), _lon(rhs._lon), _azimuthTimeUTC(rhs._azimuthTimeUTC), _rangeTime(rhs._rangeTime), _incidenceAngle(rhs._incidenceAngle) { } InfoSceneCoord& InfoSceneCoord::operator=(const InfoSceneCoord& rhs) { _refRow = rhs._refRow; _refColumn = rhs._refColumn; _lat = rhs._lat; _lon = rhs._lon; _azimuthTimeUTC = rhs._azimuthTimeUTC; _rangeTime =rhs._rangeTime; _incidenceAngle = rhs._incidenceAngle; return *this; } bool InfoSceneCoord::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx; if (prefix) { pfx = prefix; } pfx += PREFIX; kwl.add(pfx.c_str(), REF_ROW, _refRow); kwl.add(pfx.c_str(), REF_COLUMN, _refColumn); kwl.add(pfx.c_str(), LAT, _lat); kwl.add(pfx.c_str(), LON, _lon); kwl.add(pfx.c_str(), AZIMUTH_TIME, _azimuthTimeUTC); kwl.add(pfx.c_str(), RANGE_TIME, _rangeTime); kwl.add(pfx.c_str(), INCIDENCE_ANGLE, _incidenceAngle); return true; } bool InfoSceneCoord::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "InfoSceneCoord::loadState"; bool result = true; std::string pfx; if (prefix) { pfx = prefix; } ossimString s; const char* lookup = 0; pfx += PREFIX; lookup = kwl.find(pfx.c_str(), REF_ROW); if (lookup) { s = lookup; _refRow = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << REF_ROW << " in "< #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup InfoSceneCoord * @brief This class represents an InfoSceneCoord */ class OSSIM_PLUGINS_DLL InfoSceneCoord { public: /** * @brief Constructor */ InfoSceneCoord(); /** * @brief Destructor */ virtual ~InfoSceneCoord(); /** * @brief Copy constructor */ InfoSceneCoord(const InfoSceneCoord& rhs); /** * @brief Affectation operator */ InfoSceneCoord& operator=(const InfoSceneCoord& rhs); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); void set_refRow(ossim_uint32 value) { _refRow = value; } void set_refColumn(ossim_uint32 value) { _refColumn = value; } void set_lat(double value) { _lat = value; } void set_lon(double value) { _lon = value; } void set_azimuthTimeUTC(ossimString value) { _azimuthTimeUTC = value; } void set_rangeTime(double value) { _rangeTime = value; } void set_incidenceAngle(double value) { _incidenceAngle = value; } protected: /** * @brief Reference Row (refRow node). */ ossim_uint32 _refRow; /** * @brief Reference Column (refColumn node). */ ossim_uint32 _refColumn; /** * @brief Latitude (lat node). */ double _lat; /** * @brief Longitude (lon node). */ double _lon; /** * @brief azimuth time (azimuthTimeUTC node). */ ossimString _azimuthTimeUTC; /** * @brief range time (rangeTime node). */ double _rangeTime; /** * @brief IncidenceAngle (incidenceAngle node). */ double _incidenceAngle; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/JSDDateTime.cpp000066400000000000000000000115001301006202600270170ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include namespace ossimplugins { JSDDateTime::JSDDateTime(): _day0hTU(0), _second(0.0), _decimal(0.0) { } JSDDateTime::~JSDDateTime() { } JSDDateTime::JSDDateTime(const JSDDateTime& rhs): _day0hTU(rhs._day0hTU), _second(rhs._second), _decimal(rhs._decimal) { } JSDDateTime::JSDDateTime(JulianDate day0hTU, double second, double decimal): _day0hTU(day0hTU), _second(second), _decimal(decimal) { } JSDDateTime::JSDDateTime(CivilDateTime& rhs) { rhs.AsJSDDateTime(this); } JSDDateTime::JSDDateTime(JulianDate& rhs) { rhs.AsJSDDateTime(this); } JSDDateTime::JSDDateTime(MJDDateTime& rhs) { CivilDateTime referenceCiv; /* Initialization of the MJD reference day (01/01/2000, 0h00) */ referenceCiv.set_year(2000); referenceCiv.set_month(01); referenceCiv.set_day(01); referenceCiv.set_second(0); referenceCiv.set_decimal(0.0); /* JSD day of the ref. MJD date */ JSDDateTime referenceJSD(referenceCiv); /* JSD day computation */ JulianDate JD((double) rhs.get_day()); _day0hTU = referenceJSD.get_day0hTU() + JD; _second = referenceJSD.get_second() + (double) rhs.get_second(); _decimal = referenceJSD.get_decimal() + 0.000001 * (double) rhs.get_microsecond(); this->NormDate(); } JSDDateTime& JSDDateTime::operator=(const JSDDateTime& rhs) { _day0hTU = rhs._day0hTU; _second = rhs._second; _decimal = rhs._decimal; return *this; } int JSDDateTime::AsJulianDate(JulianDate* julian) { double jourJulien = _day0hTU.get_julianDate() + (_second + _decimal) / CivilDateTime::JOURCIVIL_LENGTH ; julian->set_julianDate(jourJulien); return 0 ; } int JSDDateTime::AsGMSTDateTime(GMSTDateTime* GMST) { const double TWOPI = 6.28318530717958647693 ; const double OMEGATERRE = 6.28318530717958647693 / 86164.09054 ; int etat ; JulianDate jourJulien; double t = 0.0; double tsm0hTU = 0.0; double tsm = 0.0; JSDDateTime date0hTU ; date0hTU = *this ; date0hTU.set_second(0); date0hTU.set_decimal(0.0); etat = date0hTU.AsJulianDate(&jourJulien ) ; if (etat == 0) { if (GMST->get_origine() == GMSTDateTime::AN1900) { t = (jourJulien.get_julianDate() - 2415020.0) / 36525.0 ; tsm0hTU = 23925.836 + t * (8640184.542 + t * 0.0929) ; tsm0hTU = tsm0hTU * TWOPI / CivilDateTime::JOURCIVIL_LENGTH ; } else if (GMST->get_origine() == GMSTDateTime::AN1950) { t = jourJulien.get_julianDate() - 2433281.5 ; tsm0hTU = 1.72944494 + t * 6.3003880987 ; } else if (GMST->get_origine() == GMSTDateTime::AN2000) { t = (jourJulien.get_julianDate() - 2451545.0) / 36525.0 ; tsm0hTU = 24110.54841 + t * (8640184.812866 + t * (0.093103 - t * 6.210e-6)) ; tsm0hTU = tsm0hTU * TWOPI / CivilDateTime::JOURCIVIL_LENGTH ; } t = tsm0hTU + (_second + _decimal) * OMEGATERRE ; tsm = fmod (t,TWOPI) ; if (tsm < 0.0) { tsm = tsm + TWOPI ; } GMST->set_tms(tsm); } return etat ; } void JSDDateTime::NormDate() { const double epsilon = 1.0e-12 ; int k, iu, iv, iw ; double u, v, w, ru, rv, rw ; w = _day0hTU.get_julianDate() - 0.5 ; if (fabs (w - fnint (w)) < epsilon) { iw = (int)inint(w) ; rw = 0.0 ; } else { iw = (int)w ; rw = w - (double)iw ; if ((iw < 0) && (rw != 0.0)) { iw = iw - 1 ; rw = rw + 1.0 ; } } v = _second + rw * CivilDateTime::JOURCIVIL_LENGTH ; if (fabs(v - fnint (v)) < epsilon) { iv = (int)inint (v) ; rv = 0.0 ; } else { iv = (int)v ; rv = v - (double)iv ; if ((iv < 0) && (rv != 0.0)) { iv = iv - 1 ; rv = rv + 1.0 ; } } u = _decimal + rv ; iu = (int)u ; ru = u - (double)iu ; if ((iu < 0) && (ru != 0.0)) { iu = iu - 1 ; ru = ru + 1.0 ; } iv = iv + iu ; k = iv / ((int)inint(CivilDateTime::JOURCIVIL_LENGTH)) ; iw = iw + k ; iv = iv - k * ((int)inint(CivilDateTime::JOURCIVIL_LENGTH)) ; if (iv < 0) { iw = iw - 1 ; iv = iv + (int)inint(CivilDateTime::JOURCIVIL_LENGTH) ; } _decimal = ru ; _second = (double)iv ; _day0hTU = (double)iw + 0.5 ; } JSDDateTime::operator JulianDate() { JulianDate date; this->AsJulianDate(&date); return date; } JSDDateTime::operator GMSTDateTime() { GMSTDateTime date; this->AsGMSTDateTime(&date); return date; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/JSDDateTime.h000066400000000000000000000053151301006202600264730ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef JSDDateTime_h #define JSDDateTime_h #include #include #include namespace ossimplugins { class CivilDateTime; class GMSTDateTime; class JulianDate; /** * @brief This class represents a date */ class OSSIM_PLUGINS_DLL JSDDateTime { public: /** * @brief constructor */ JSDDateTime(); /** * @brief Destructor */ ~JSDDateTime(); /** * @brief Copy constructor */ JSDDateTime(const JSDDateTime& rhs); /** * @brief Constructor with date initialization */ JSDDateTime(JulianDate day0hTU, double second, double decimal); /** * @brief Constructor with date initialization using a CivilDateTime */ JSDDateTime(CivilDateTime& rhs); /** * @brief Constructor with date initialization using a CivilDateTime */ JSDDateTime(JulianDate& rhs); /** * @brief Constructor with date initialization using a MJDDateTime (Modified Julian Date - Used for ENVISAT) */ JSDDateTime(MJDDateTime& rhs); /** * @brief Affectation operator */ JSDDateTime& operator=(const JSDDateTime& rhs); JulianDate get_day0hTU() const { return _day0hTU; } double get_second() const { return _second; } double get_decimal() const { return _decimal; } void set_day0hTU(JulianDate day) { _day0hTU = day; } void set_second(double second) { _second = second; } void set_decimal(double decimal) { _decimal = decimal; } void NormDate() ; /** * @brief This function converts the current JSDDateTime into Julian Date * @return 0 if no error or an int greater than 0 indicating the error * @param julianDate [out] The classe that receives the result of the conversion of the current JSDDateTime in JulianDate */ int AsJulianDate(JulianDate* julian); /** * @brief This function converts the current JSDDateTime into GMST Date * @return 0 if no error or an int greater than 0 indicating the error * @param julianDate [out] The class that receives the result of the conversion of the current JSDDateTime into GMST Date */ int AsGMSTDateTime(GMSTDateTime* GMST); operator JulianDate() ; operator GMSTDateTime() ; protected: /** * @brief Julian day at 0h00 UT */ JulianDate _day0hTU; double _second; double _decimal; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/JulianDate.cpp000066400000000000000000000057041301006202600270130ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include namespace ossimplugins { JulianDate::JulianDate(): _julianDate(0.0) { } JulianDate::JulianDate(CivilDateTime& rhs) { rhs.AsJulianDate(this); } JulianDate::JulianDate(double julianDate): _julianDate(julianDate) { } JulianDate::JulianDate(JSDDateTime& rhs) { rhs.AsJulianDate(this); } JulianDate::~JulianDate() { } JulianDate::JulianDate(const JulianDate& rhs): _julianDate(rhs._julianDate) { } JulianDate& JulianDate::operator=(const JulianDate& rhs) { _julianDate = rhs._julianDate; return *this; } JulianDate& JulianDate::operator+(const JulianDate& rhs) { _julianDate += rhs._julianDate; return *this; } int JulianDate::AsJSDDateTime(JSDDateTime* JSDdate) { int k ; double r ; k = (int)(_julianDate - 0.5) ; double jJul0hTU = (double)k + 0.5; JSDdate->set_day0hTU (jJul0hTU); r = (_julianDate - jJul0hTU) * CivilDateTime::JOURCIVIL_LENGTH ; JSDdate->set_second(floor (r)); JSDdate->set_decimal(r - JSDdate->get_second()) ; return 0 ; } int JulianDate::AsGMSTDateTime(GMSTDateTime* GMST) { const double TWOPI = 6.28318530717958647693 ; const double OMEGATERRE = 6.28318530717958647693 / 86164.09054 ; int etat=0 , n ; double j0hTU = 0.0; double tsm0hTU = 0.0; double t = 0.0; double d = 0.0; double tsm = 0.0; n = (int)(_julianDate - 0.5) ; j0hTU = (double)n + 0.5 ; d = _julianDate - j0hTU ; if (etat == 0) { if (GMST->get_origine() == GMSTDateTime::AN1900) { t = (j0hTU - 2415020.0) / 36525.0 ; tsm0hTU = 23925.836 + t * (8640184.542 + t * 0.0929) ; tsm0hTU = tsm0hTU * TWOPI / CivilDateTime::JOURCIVIL_LENGTH ; } else if (GMST->get_origine() == GMSTDateTime::AN1950) { t = j0hTU - 2433281.5 ; tsm0hTU = 1.72944494 + t * 6.3003880987 ; } else if (GMST->get_origine() == GMSTDateTime::AN2000) { t = (j0hTU - 2451545.0) / 36525.0 ; tsm0hTU = 24110.54841 + t * (8640184.812866 + t * (0.093103 - t * 6.210e-6)) ; tsm0hTU = tsm0hTU * TWOPI / CivilDateTime::JOURCIVIL_LENGTH ; } t = tsm0hTU + d * CivilDateTime::JOURCIVIL_LENGTH * OMEGATERRE ; tsm = fmod (t,TWOPI) ; if (tsm < 0.0) { tsm = tsm + TWOPI ; } GMST->set_tms(tsm); } return etat ; } JulianDate::operator JSDDateTime() { JSDDateTime date; AsJSDDateTime(&date); return date; } JulianDate::operator GMSTDateTime() { GMSTDateTime date; AsGMSTDateTime(&date); return date; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/JulianDate.h000066400000000000000000000042371301006202600264600ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef JulianData_h #define JulianData_h #include namespace ossimplugins { class CivilDateTime; class GMSTDateTime; class JSDDateTime; /** * @brief This class represents a date in the julian referential */ class OSSIM_PLUGINS_DLL JulianDate { public: /** * @brief constructor */ JulianDate(); /** * @brief Destructor */ ~JulianDate(); /** * @brief Copy constructor */ JulianDate(const JulianDate& rhs); /** * @brief Constructor with date initialization using a CivilDateTime */ JulianDate(CivilDateTime& rhs); /** * @brief Constructor with date initialization using a JSDDateTime */ JulianDate(JSDDateTime& rhs); /** * @brief Constructor with date initialization */ JulianDate(double julianDate); /** * @brief Affectation operator */ JulianDate& operator=(const JulianDate& rhs); /** * @brief Summation operator */ JulianDate& operator+(const JulianDate& rhs); void set_julianDate(double julianDate) { _julianDate = julianDate; } double get_julianDate() const { return _julianDate; } /** * @brief This function converts the current JulianDate in JSDDateTime * @return 0 if no error or an int greater than 0 indicating the error * @param JSDdate [out] The classe that receives the result of the conversion of the current JulianDate in JSDDateTime */ int AsJSDDateTime(JSDDateTime* JSDdate); /** * @brief This function converts the current JulianDate into GMSTDateTime * @return 0 if no error or an int greater than 0 indicating the error * @param GMSTDateTime [out] The class that receives the result of the conversion of the current JulianDate into GMSTDateTime */ int AsGMSTDateTime(GMSTDateTime* GMST); operator JSDDateTime() ; operator GMSTDateTime() ; protected: double _julianDate; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/MJDDateTime.cpp000066400000000000000000000016341301006202600270200ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include namespace ossimplugins { MJDDateTime::MJDDateTime(): _day(0), _second(0), _microsecond(0) { } MJDDateTime::~MJDDateTime() { } MJDDateTime::MJDDateTime(const MJDDateTime& rhs): _day(rhs._day), _second(rhs._second), _microsecond(rhs._microsecond) { } MJDDateTime::MJDDateTime(long day, unsigned long second, unsigned long microsecond): _day(day), _second(second), _microsecond(microsecond) { } MJDDateTime& MJDDateTime::operator=(const MJDDateTime& rhs) { _day = rhs._day; _second = rhs._second; _microsecond = rhs._microsecond; return *this; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/MJDDateTime.h000066400000000000000000000027051301006202600264650ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef MJDDateTime_h #define MJDDateTime_h #include namespace ossimplugins { class CivilDateTime; /** * @brief This class represents an MJD date (Modified Julian date) */ class OSSIM_PLUGINS_DLL MJDDateTime { public: /** * @brief constructor */ MJDDateTime(); /** * @brief Destructor */ ~MJDDateTime(); /** * @brief Copy constructor */ MJDDateTime(const MJDDateTime& rhs); /** * @brief Constructor with date initialization */ MJDDateTime(long day, unsigned long second, unsigned long microsecond); /** * @brief Affectation operator */ MJDDateTime& operator=(const MJDDateTime& rhs); long get_day() { return _day; }; unsigned long get_second() { return _second; }; unsigned long get_microsecond() { return _microsecond; }; void set_day(long day) { _day = day; }; void set_second(unsigned long second) { _second = second; }; void set_microsecond(unsigned long microsecond) { _microsecond = microsecond; }; protected: long _day; unsigned long _second; unsigned long _microsecond; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Noise.cpp000066400000000000000000000074371301006202600260550ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char NOISE[] = "noise"; static const char NUMBER_OF_NOISE_RECORDS_KW[] = "numberOfNoiseRecords"; static const char NAME_OF_NOISE_POLARISATION_KW[] = "nameOfNoisePolarisation"; Noise::Noise(): _numberOfNoiseRecords(0), _tabImageNoise(), _polarisation("UNDEFINED") { } Noise::~Noise() { } Noise::Noise(const Noise& rhs): _numberOfNoiseRecords(rhs._numberOfNoiseRecords), _tabImageNoise(rhs._tabImageNoise), _polarisation(rhs._polarisation) { } Noise& Noise::operator=(const Noise& rhs) { _numberOfNoiseRecords = rhs._numberOfNoiseRecords; _tabImageNoise = rhs._tabImageNoise; _polarisation = rhs._polarisation; return *this; } bool Noise::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx; if (prefix) { pfx = prefix; } pfx += NOISE; std::string s = pfx + "." + NAME_OF_NOISE_POLARISATION_KW; kwl.add(prefix, s.c_str(), _polarisation); s = pfx + "." + NUMBER_OF_NOISE_RECORDS_KW; kwl.add(prefix, s.c_str(), _numberOfNoiseRecords); for (unsigned int i = 0; i < _tabImageNoise.size(); ++i) { ossimString s2 = pfx + "[" + ossimString::toString(i).c_str() + "]"; _tabImageNoise[i].saveState(kwl, s2.c_str()); } return true; } bool Noise::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "Noise::loadState"; bool result = true; std::string pfx(""); if (prefix) { pfx = prefix; } pfx += NOISE; ossimString s; const char* lookup = 0; std::string s1 = pfx + "."; lookup = kwl.find(s1.c_str(), NAME_OF_NOISE_POLARISATION_KW); if (lookup) { _polarisation = lookup; } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << NAME_OF_NOISE_POLARISATION_KW << "\n"; result = false; } lookup = kwl.find(s1.c_str(), NUMBER_OF_NOISE_RECORDS_KW); if (lookup) { s = lookup; _numberOfNoiseRecords = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << NUMBER_OF_NOISE_RECORDS_KW << "\n"; result = false; } _tabImageNoise.clear(); for (unsigned int i = 0; i < _numberOfNoiseRecords; ++i) { std::string s2 = pfx + "[" + ossimString::toString(i).c_str() + "]"; ImageNoise in; result = in.loadState(kwl, s2.c_str()); _tabImageNoise.push_back(in); } if( _numberOfNoiseRecords != _tabImageNoise.size() ) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword " << NUMBER_OF_NOISE_RECORDS_KW << " is different with the number of ImageNoise nodes \n"; } return result; } std::ostream& Noise::print(std::ostream& out) const { out << setprecision(15) << setiosflags(ios::fixed) << "\n Noise class data members:\n"; const char* prefix = 0; ossimKeywordlist kwl; ossimString pfx; pfx += NOISE; ossimString s = pfx + "." + NUMBER_OF_NOISE_RECORDS_KW; kwl.add(prefix, s.c_str(), _numberOfNoiseRecords); s = pfx + "." + NAME_OF_NOISE_POLARISATION_KW; kwl.add(prefix, s.chars(), _polarisation); for (unsigned int i = 0; i < _tabImageNoise.size(); ++i) { ossimString s2 = pfx + "[" + ossimString::toString(i).c_str() + "]"; _tabImageNoise[i].saveState(kwl, s2.c_str()); } out << kwl; return out; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Noise.h000066400000000000000000000046351301006202600255170ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Noise_h #define Noise_h #include #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup Noise * @brief This class represents an Noise */ class OSSIM_PLUGINS_DLL Noise { public: /** * @brief Constructor */ Noise(); /** * @brief Destructor */ virtual ~Noise(); /** * @brief Copy constructor */ Noise(const Noise& rhs); /** * @brief Affectation operator */ Noise& operator=(const Noise& rhs); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; void set_numberOfNoiseRecords(const ossim_int32& numberOfNoiseRecords) { _numberOfNoiseRecords = numberOfNoiseRecords; } void set_imageNoise(const std::vector& image_noise) { _tabImageNoise = image_noise; } const std::vector & get_imageNoise() const { return _tabImageNoise; } void set_imagePolarisation(const ossimString& polarisation) { _polarisation = polarisation; } const ossimString & get_imagePolarisation() const { return _polarisation; } protected: /** * @brief Image Noise. */ ossim_uint32 _numberOfNoiseRecords; /** * @brief Image Noise. */ std::vector _tabImageNoise; /** * @brief Noise Polarisation Layer. */ ossimString _polarisation; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/PlatformPosition.cpp000066400000000000000000000157561301006202600303140ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include namespace ossimplugins { static const char NUMBER_PLATFORM_POSITIONS_KW[] = "platform_positions_count"; PlatformPosition::PlatformPosition(): _nbrData(0), _data(NULL), _t(NULL), _p(NULL), _dp(NULL), _interpolator(NULL) { } PlatformPosition::~PlatformPosition() { Clear(); } void PlatformPosition::Clear() { if(_data != NULL) { for (int i=0;i<_nbrData;i++) { delete _data[i]; } delete [] _data; } _data = NULL; _nbrData = 0; delete[] _t; if ((_p != NULL) && (_dp != NULL)) { for (int j=0; j<3; ++j) { delete[] _p[j]; delete[] _dp[j]; delete _interpolator[j]; } } delete[] _p; delete[] _dp; delete[] _interpolator; } PlatformPosition::PlatformPosition(const PlatformPosition& rhs) { InitData(rhs._data, rhs._nbrData); } PlatformPosition& PlatformPosition::operator=(const PlatformPosition& rhs) { Clear(); InitData(rhs._data, rhs._nbrData); return *this; } PlatformPosition::PlatformPosition(Ephemeris** data, int nbrData) { InitData(data, nbrData); } void PlatformPosition::InitData(Ephemeris** data, int nbrData) { _nbrData = nbrData; _data = new Ephemeris*[_nbrData]; for (int i=0; i<_nbrData; i++) { _data[i] = data[i]->Clone(); } InitAuxiliaryData(); } void PlatformPosition::InitAuxiliaryData() { const double JOURCIVIL_LENGTH = 86400.0; _t = new double[_nbrData]; _p = new double*[3]; _dp = new double*[3]; _interpolator = new HermiteInterpolator*[3]; for (int j=0; j<3; ++j) { _p[j] = new double[_nbrData]; _dp[j] = new double[_nbrData]; } _t[0] = 0.0; for (int i = 1; i < _nbrData; i++) { _t[i] = (_data[i]->get_date().get_day0hTU().get_julianDate() - _data[0]->get_date().get_day0hTU().get_julianDate()) * JOURCIVIL_LENGTH + _data[i]->get_date().get_second() - _data[0]->get_date().get_second() + _data[i]->get_date().get_decimal() - _data[0]->get_date().get_decimal(); } for (int j = 0; j < 3; j++) { for (int i = 0; i < _nbrData; i++) { _p[j][i] = _data[i]->get_position()[j]; _dp[j][i] = _data[i]->get_speed()[j]; } _interpolator[j] = new HermiteInterpolator(_nbrData, _t, _p[j], _dp[j]); } } Ephemeris* PlatformPosition::Interpolate(JSDDateTime date) const { const double JOURCIVIL_LENGTH = 86400.0; Ephemeris* ephem = NULL; if (_nbrData <= 1) { return NULL; } /* * The first element of the list is cloned to ensure that the * output ephemeris is expressed in the same coordinate system as * input ones */ ephem = _data[0]->Clone(); /* NORMAL CASE */ /*------------*/ double dt = 0.0; if (ephem != NULL) { ephem->set_date(date); dt = (date.get_day0hTU().get_julianDate() - _data[0]->get_date().get_day0hTU().get_julianDate()) * JOURCIVIL_LENGTH + date.get_second() - _data[0]->get_date().get_second() + date.get_decimal() - _data[0]->get_date().get_decimal(); /* Computation by Everett */ /*---------------------*/ double pos[3]; double speed[3]; for (int j = 0; j < 3; j++) { _interpolator[j]->Interpolate(dt, pos[j], speed[j]); } ephem->set_position(pos); ephem->set_speed(speed); } return ephem; } bool PlatformPosition::getPlatformPositionAtTime(JSDDateTime time, std::vector& position, std::vector& speed) { Ephemeris* ephemeris = this->Interpolate(time); double* position_ptr = ephemeris->get_position(); double* speed_ptr = ephemeris->get_speed(); if (position.size() != 3) position.resize(3); if (speed.size() != 3) speed.resize(3); position[0] = position_ptr[0]; position[1] = position_ptr[1]; position[2] = position_ptr[2]; speed[0] = speed_ptr[0]; speed[1] = speed_ptr[1]; speed[2] = speed_ptr[2]; return true; } void PlatformPosition::setData(Ephemeris** data, int nbrData) { Clear(); InitData(data, nbrData); } Ephemeris* PlatformPosition::getData(int noData) const { if(noData >=0 && noData < _nbrData) { return _data[noData]; } return NULL; } int PlatformPosition::getNbrData() const { return _nbrData; } bool PlatformPosition::saveState(ossimKeywordlist& kwl, const char* prefix) const { kwl.add(prefix, NUMBER_PLATFORM_POSITIONS_KW, _nbrData); std::string s1; if (prefix) { s1 = prefix; } for (int i = 0; i < _nbrData; ++i) { std::string s2 = s1; s2 += "platform_position["; s2 += ossimString::toString(i).chars(); s2+= "]"; _data[i]->saveState(kwl, s2.c_str()); } return true; } bool PlatformPosition::loadState(const ossimKeywordlist& kwl, const char* prefix) { bool result = true; Clear(); const char* lookup = 0; lookup = kwl.find(prefix, NUMBER_PLATFORM_POSITIONS_KW); if (!lookup) { return false; } ossimString s = lookup; _nbrData = s.toInt(); if (_nbrData) { std::string s1; if (prefix) { s1 = prefix; } _data = new Ephemeris*[_nbrData]; for (int i = 0; i < _nbrData; ++i) { std::string s2 = s1; s2 += "platform_position["; s2 += ossimString::toString(i).chars(); s2+= "]"; _data[i] = new Ephemeris(); _data[i]->loadState(kwl, s2.c_str()); } } InitAuxiliaryData(); return result; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/PlatformPosition.h000066400000000000000000000071041301006202600277450ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef PlatformPosition_h #define PlatformPosition_h #include #include #include class ossimKeywordlist; namespace ossimplugins { class Ephemeris; class HermiteInterpolator; /** * @ingroup SARModel * @brief This class handles the platform position */ class OSSIM_PLUGINS_DLL PlatformPosition { public: /** * @brief Constructor */ PlatformPosition(); /** * @brief Destructor */ ~PlatformPosition(); /** * @brief Copy constructor */ PlatformPosition(const PlatformPosition& rhs); /** * @brief Constructor with initialization * @param data Ephemeris * @param nbrData Number of Ephemeris in data * @remarks All the ephemeris have to be in the same coordinates system * @remarks This constructor copy the content of data, so it's the * calling fonction that have to manage the memory of data. */ PlatformPosition(Ephemeris** data, int nbrData); /** * @brief Affectation operator */ PlatformPosition& operator=(const PlatformPosition& rhs); /** * @brief This function interpolates its ephemeris to create a new ephemeris at the given date and time * @param date Date and time at which the interpolation have to be done * @return The ephemeris at the given date, or NULL if an error occurs */ Ephemeris* Interpolate(JSDDateTime date) const; /** * @brief This function interpolates its ephemeris to create and extract platform's position and speed * @param date Date and time at which the interpolation have to be done * @return true, or false if an error occurs */ bool getPlatformPositionAtTime(JSDDateTime time, std::vector& position, std::vector& speed); PlatformPosition* Clone() const { return new PlatformPosition(*this); }; void setData(Ephemeris** data, int nbrData); Ephemeris* getData(int noData) const; int getNbrData() const; /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState(const ossimKeywordlist &kwl, const char *prefix=0); protected: /** * @brief Internal method to initialize data structures */ void InitData(Ephemeris** data, int nbrData); void InitAuxiliaryData(); /** * @brief Number of platform positions * @see _data */ int _nbrData; /** * @brief Platform positions */ Ephemeris** _data; /** * @brief This function deletes all the contents of the class */ void Clear(); private: double * _t; double ** _p; double ** _dp; HermiteInterpolator ** _interpolator; }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/RadarSat2NoiseLevel.cpp000066400000000000000000000172551301006202600305500ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char NOISE[] = "referenceNoiseLevel"; static const char BETA_NOUGHT[] ="BetaNought"; static const char SIGMA_NOUGHT[] ="SigmaNought"; static const char GAMMA[] ="Gamma"; static const char INCIDENCE_ANGLE_CORRECTION_NAME_KW[] = "incidenceAngleCorrectionName"; static const char PIXEL_FIRST_NOISE_VALUE_KW[] = "pixelFirstNoiseValue"; static const char STEP_SIZE_KW[] = "stepSize"; static const char NUMBER_OF_NOISE_LEVEL_VALUE_KW[] = "numberOfNoiseLevelValues"; static const char NOISE_LEVEL_VALUES_KW[] = "noiseLevelValues"; static const char UNITS_KW[] = "units"; static const char OFFSET_KW[] = "offset"; static const char GAIN_KW[] = "gain"; static const char SIZE_KW[] = "size"; RadarSat2NoiseLevel::RadarSat2NoiseLevel(): _incidenceAngleCorrectionName("Unknown"), _pixelFirstNoiseValue(0), _stepSize(0), _numberOfNoiseLevelValues(0), _noiseLevelValues(), _units("Unknown"), _offset(0.0), _gain() { } RadarSat2NoiseLevel::~RadarSat2NoiseLevel() { } RadarSat2NoiseLevel::RadarSat2NoiseLevel(const RadarSat2NoiseLevel& rhs): _incidenceAngleCorrectionName(rhs._incidenceAngleCorrectionName), _pixelFirstNoiseValue(rhs._pixelFirstNoiseValue), _stepSize(rhs._stepSize), _numberOfNoiseLevelValues(rhs._numberOfNoiseLevelValues), _noiseLevelValues(rhs._noiseLevelValues), _units(rhs._units), _offset(rhs._offset), _gain(rhs._gain) { } RadarSat2NoiseLevel& RadarSat2NoiseLevel::operator=(const RadarSat2NoiseLevel& rhs) { _incidenceAngleCorrectionName = rhs._incidenceAngleCorrectionName; _pixelFirstNoiseValue = rhs._pixelFirstNoiseValue; _stepSize = rhs._stepSize; _numberOfNoiseLevelValues = rhs._numberOfNoiseLevelValues; _noiseLevelValues = rhs._noiseLevelValues; _units = rhs._units; _offset = rhs._offset; _gain = rhs._gain; return *this; } bool RadarSat2NoiseLevel::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx; if (prefix) { pfx = prefix; } pfx += NOISE; if(_incidenceAngleCorrectionName == "Gamma") { pfx = pfx + "["+ GAMMA +"]"; } if(_incidenceAngleCorrectionName == "Sigma Nought") { pfx = pfx + "["+ SIGMA_NOUGHT +"]"; } if(_incidenceAngleCorrectionName == "Beta Nought") { pfx = pfx + "["+ BETA_NOUGHT +"]"; } pfx +="."; std::string s = pfx + INCIDENCE_ANGLE_CORRECTION_NAME_KW; kwl.add(prefix, s.c_str(), _incidenceAngleCorrectionName); s = pfx + PIXEL_FIRST_NOISE_VALUE_KW; kwl.add(prefix, s.c_str(), _pixelFirstNoiseValue); s = pfx + STEP_SIZE_KW; kwl.add(prefix, s.c_str(), _stepSize); s = pfx + NUMBER_OF_NOISE_LEVEL_VALUE_KW; kwl.add(prefix, s.c_str(), _numberOfNoiseLevelValues); s = pfx + UNITS_KW; kwl.add(prefix, s.c_str(), _units); for (unsigned int i = 0; i < _noiseLevelValues.size(); ++i) { s = pfx + NOISE_LEVEL_VALUES_KW + "[" + ossimString::toString(i).chars() + "]"; kwl.add(prefix, s.c_str(), _noiseLevelValues[i]); } s = pfx + OFFSET_KW; kwl.add(prefix, s.c_str(), _offset); s = pfx + GAIN_KW; kwl.add(prefix, s.c_str(), _gain); return true; } bool RadarSat2NoiseLevel::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "RadarSat2NoiseLevel::loadState"; //bool result = true; ossimString s; const char* lookup = 0; std::string pfx(""); if (prefix) { pfx = prefix; } pfx += NOISE; if(_incidenceAngleCorrectionName == "Gamma") { pfx = pfx + "["+ GAMMA +"]"; } if(_incidenceAngleCorrectionName == "Sigma Nought") { pfx = pfx + "["+ SIGMA_NOUGHT +"]"; } if(_incidenceAngleCorrectionName == "Beta Nought") { pfx = pfx + "["+ BETA_NOUGHT +"]"; } std::string s1 = pfx + "["+ GAMMA +"]"; lookup = kwl.find(s1.c_str(), INCIDENCE_ANGLE_CORRECTION_NAME_KW); if (!lookup) { std::string s1 = pfx + "["+ SIGMA_NOUGHT +"]"; lookup = kwl.find(s1.c_str(), INCIDENCE_ANGLE_CORRECTION_NAME_KW); if (!lookup) { std::string s1 = pfx + "["+ BETA_NOUGHT +"]"; lookup = kwl.find(s1.c_str(), INCIDENCE_ANGLE_CORRECTION_NAME_KW); if (!lookup) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << INCIDENCE_ANGLE_CORRECTION_NAME_KW << "\n"; return false; } } } _incidenceAngleCorrectionName = lookup; pfx= s1; lookup = kwl.find(s1.c_str(), PIXEL_FIRST_NOISE_VALUE_KW); if (lookup) { s = lookup; _pixelFirstNoiseValue = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << PIXEL_FIRST_NOISE_VALUE_KW << "\n"; return false; } lookup = kwl.find(s1.c_str(), STEP_SIZE_KW); if (lookup) { s = lookup; _stepSize = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << STEP_SIZE_KW << "\n"; return false; } lookup = kwl.find(s1.c_str(), NUMBER_OF_NOISE_LEVEL_VALUE_KW); if (lookup) { s = lookup; _numberOfNoiseLevelValues = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << NUMBER_OF_NOISE_LEVEL_VALUE_KW << "\n"; return false; } lookup = kwl.find(s1.c_str(), UNITS_KW); if (lookup) { _units = lookup; } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << UNITS_KW << "\n"; return false; } _noiseLevelValues.clear(); for (unsigned int i = 0; i < _numberOfNoiseLevelValues; ++i) { s = pfx + NOISE_LEVEL_VALUES_KW + "[" + ossimString::toString(i) + "]"; lookup = kwl.find(s.c_str(), ""); if (lookup) { s = lookup; _noiseLevelValues.push_back( s.toDouble() ); } } if( _numberOfNoiseLevelValues != _noiseLevelValues.size() ) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword " << NOISE_LEVEL_VALUES_KW << " is different with the number of noise level values" << std::endl; return false; } lookup = kwl.find(s1.c_str(), GAIN_KW); if (lookup) { _gain = lookup;; } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << GAIN_KW << "\n"; return false; } lookup = kwl.find(s1.c_str(), OFFSET_KW); if (lookup) { s = lookup; _offset = s.toFloat64(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << OFFSET_KW << "\n"; return false; } if( _numberOfNoiseLevelValues != _noiseLevelValues.size() ) { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword " << NOISE_LEVEL_VALUES_KW << " is different with the number of noise level values" << std::endl; return false; } return true; } std::ostream& RadarSat2NoiseLevel::print(std::ostream& out) const { out << setprecision(15) << setiosflags(ios::fixed) << "\n RadarSat2NoiseLevel class data members:\n"; //const char* prefix = 0; //ossimKeywordlist kwl; //ossimString pfx; /* TODO Add print method*/ //out << kwl; return out; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/RadarSat2NoiseLevel.h000066400000000000000000000070401301006202600302040ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RadarSat2NoiseLevel_h #define RadarSat2NoiseLevel_h #include #include #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup RadarSat2NoiseLevel * @brief This class represents an Noise */ class OSSIM_PLUGINS_DLL RadarSat2NoiseLevel { public: /** * @brief Constructor */ RadarSat2NoiseLevel(); /** * @brief Destructor */ virtual ~RadarSat2NoiseLevel(); /** * @brief Copy constructor */ RadarSat2NoiseLevel(const RadarSat2NoiseLevel& rhs); /** * @brief Affectation operator */ RadarSat2NoiseLevel& operator=(const RadarSat2NoiseLevel& rhs); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; void set_incidenceAngleCorrectionName(const ossimString& value) { _incidenceAngleCorrectionName = value; } void set_pixelFirstNoiseValue(const ossim_uint32& value) { _pixelFirstNoiseValue = value; } void set_stepSize(const ossim_uint32& value) { _stepSize = value; } void set_numberOfNoiseLevelValues(const ossim_uint32& value) { _numberOfNoiseLevelValues = value; } void set_noiseLevelValues(const std::vector& value) { _noiseLevelValues = value; } void set_units(const ossimString& value) { _units = value; } void set_offset(const ossim_float64& value) { _offset = value; } void set_gain(const ossimString& value) { _gain = value; } const ossimString & get_incidenceAngleCorrectionName() const { return _incidenceAngleCorrectionName; } const ossimString & get_gain() const { return _gain; } protected: /** * @brief Incidence Angle correction Name */ ossimString _incidenceAngleCorrectionName; /** * @brief pixel First Noise Value */ ossim_uint32 _pixelFirstNoiseValue; /** * @brief step Size */ ossim_uint32 _stepSize; /** * @brief number Of Noise Level Values */ ossim_uint32 _numberOfNoiseLevelValues; /** * @brief noise Level Values */ std::vector _noiseLevelValues; /** * @brief noise Level units */ ossimString _units; /** * @brief offset value */ ossim_float64 _offset; /** * @brief lookup table */ ossimString _gain; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/RectangularCoordinate.cpp000066400000000000000000000047651301006202600312600ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace ossimplugins { RectangularCoordinate::RectangularCoordinate() { } RectangularCoordinate::~RectangularCoordinate() { } RectangularCoordinate::RectangularCoordinate(double x, double y, double z): Coordinate(x,y,z) { } RectangularCoordinate::RectangularCoordinate(const RectangularCoordinate& rhs): Coordinate((Coordinate)rhs) { } RectangularCoordinate& RectangularCoordinate::operator=(const RectangularCoordinate& rhs) { _x = rhs._x; _y = rhs._x; _z = rhs._x; return *this; } void RectangularCoordinate::AsGeodesicCoordinates(double demiGdAxe, double demiPtAxe, GeodesicCoordinate* geod) { const double PI = 3.14159265358979323846 ; const int itmax = 40 ; const double epsilon = 1.0e-6 ; int fin , iter ; double u, a2_b2, d, e, f, df, c, s, p, q ; double coordCart[3]; double coordGeod[3]; coordCart[0] = _x; coordCart[1] = _y; coordCart[2] = _z; u = sqrt (coordCart[0] * coordCart[0] + coordCart[1] * coordCart[1]) ; if (u < epsilon) { coordGeod[0] = 0.0 ; if (coordCart[2] >= 0.0) coordGeod[1] = PI / 2.0 ; else coordGeod[1] = - PI / 2.0 ; coordGeod[2] = fabs (coordCart[2]) - demiPtAxe ; } else { coordGeod[0] = atan2 (coordCart[1] , coordCart[0]) ; a2_b2 = demiGdAxe * demiGdAxe - demiPtAxe * demiPtAxe ; e = atan (coordCart[2] / u) ; fin = 0 ; iter = 0 ; while (fin == 0) { iter++ ; d = e ; c = cos (e) ; s = sin (e) ; p = demiGdAxe * u ; q = demiPtAxe * coordCart[2] ; f = p * s - q * c - a2_b2 * s * c ; df = p * c + q * s - a2_b2 * (c * c - s * s) ; e = e - f / df ; d = fabs (e - d) ; if ((d < epsilon) || (iter >= itmax)) fin = 1 ; } coordGeod[1] = atan (tan (e) * demiGdAxe / demiPtAxe) ; p = cos(coordGeod[1]) ; if (fabs(coordGeod[1]) <= (PI * 0.5)) coordGeod[2] = (u - demiGdAxe * cos(e)) / cos(coordGeod[1]) ; else coordGeod[2] = (coordCart[2] - demiPtAxe * sin(e)) / sin(coordGeod[1]) ; geod->set_coordinates(coordGeod[0],coordGeod[1], coordGeod[2]); } //return 0 ; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/RectangularCoordinate.h000066400000000000000000000023531301006202600307140ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RectangularCoordinate_h #define RectangularCoordinate_h #include #include namespace ossimplugins { class GeodesicCoordinate; /** * @ingroup Date * @brief This class represents a coordinate in a rectangular reference */ class OSSIM_PLUGINS_DLL RectangularCoordinate : public Coordinate { public: /** * @brief Constructor */ RectangularCoordinate(); /** * @brief Destructor */ ~RectangularCoordinate(); /** * @brief Cosntructor with initializations */ RectangularCoordinate(double x, double y, double z); /** * @brief Copy constructor */ RectangularCoordinate(const RectangularCoordinate& rhs); /** * @brief Affectation operator */ RectangularCoordinate& operator=(const RectangularCoordinate& rhs); void AsGeodesicCoordinates(double demiGdAxe, double demiPtAxe, GeodesicCoordinate* geod); protected: private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/RefPoint.cpp000066400000000000000000000066611301006202600265240ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include namespace ossimplugins { static const char PREFIX[] = "ref_point."; static const char DISTANCE_KW[] = "distance"; static const char LINE_KW[] = "line"; static const char COL_KW[] = "col"; RefPoint::RefPoint(): _ephemeris(0), _distance(0.0), _pix_line(0.0), _pix_col(0.0) { } RefPoint::~RefPoint() { if(_ephemeris != 0) { delete _ephemeris; } } RefPoint::RefPoint(const RefPoint& rhs): _distance(rhs._distance), _pix_line(rhs._pix_line), _pix_col(rhs._pix_col) { _ephemeris = rhs._ephemeris->Clone(); } RefPoint& RefPoint::operator=(const RefPoint& rhs) { _distance = rhs._distance; _pix_line = rhs._pix_line; _pix_col = rhs._pix_col; if(_ephemeris != 0) { delete _ephemeris; _ephemeris = 0; } _ephemeris = rhs._ephemeris->Clone(); return *this; } void RefPoint::set_ephemeris(Ephemeris* ephemeris) { if(_ephemeris != 0) { delete _ephemeris; _ephemeris = 0; } _ephemeris = ephemeris->Clone(); } void RefPoint::set_distance(double distance) { _distance = distance; } void RefPoint::set_pix_line(double pix_line) { _pix_line = pix_line; } void RefPoint::set_pix_col(double pix_col) { _pix_col = pix_col; } Ephemeris* RefPoint::get_ephemeris() { return _ephemeris; } double RefPoint::get_distance() const { return _distance; } double RefPoint::get_pix_line() const { return _pix_line; } double RefPoint::get_pix_col() const { return _pix_col; } bool RefPoint::saveState(ossimKeywordlist& kwl, const char* prefix) const { bool result = true; std::string pfx; if (prefix) { pfx = prefix; } pfx += PREFIX; if (_ephemeris) { result = _ephemeris->saveState(kwl, pfx.c_str()); } else { result = false; } kwl.add(pfx.c_str(), DISTANCE_KW, _distance); kwl.add(pfx.c_str(), LINE_KW, _pix_line); kwl.add(pfx.c_str(), COL_KW, _pix_col); return result; } bool RefPoint::loadState(const ossimKeywordlist& kwl, const char* prefix) { bool result = true; std::string pfx; if (prefix) { pfx = prefix; } pfx += PREFIX; if (!_ephemeris) { _ephemeris = new Ephemeris(); } result = _ephemeris->loadState(kwl, pfx.c_str()); const char* lookup = 0; ossimString s; double d; lookup = kwl.find(pfx.c_str(), DISTANCE_KW); if (lookup) { s = lookup; d = s.toDouble(); _distance = d; } else { result = false; } lookup = kwl.find(pfx.c_str(), LINE_KW); if (lookup) { s = lookup; d = s.toDouble(); _pix_line = d; } else { result = false; } lookup = kwl.find(pfx.c_str(), COL_KW); if (lookup) { s = lookup; d = s.toDouble(); _pix_col = d; } else { result = false; } return result; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/RefPoint.h000066400000000000000000000035061301006202600261640ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef RefPoint_h #define RefPoint_h #include class ossimKeywordlist; namespace ossimplugins { class Ephemeris; /** * @brief This class handles the referential point */ class OSSIM_PLUGINS_DLL RefPoint { public: /** * @brief Constructor */ RefPoint(); /** * @brief Destructor */ ~RefPoint(); /** * @brief Copy constructor */ RefPoint(const RefPoint& rhs); /** * @brief Affectation operator */ RefPoint& operator=(const RefPoint& rhs); void set_ephemeris(Ephemeris* ephemeris); void set_distance(double distance); void set_pix_line(double pix_line); void set_pix_col(double pix_col); Ephemeris* get_ephemeris(); double get_distance() const; double get_pix_line() const; double get_pix_col() const; RefPoint* Clone() { return new RefPoint(*this); }; /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); protected: Ephemeris* _ephemeris; double _distance; double _pix_line; double _pix_col; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/SarSensor.cpp000066400000000000000000000162541301006202600267140ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include #include #include #include #include #include #include namespace ossimplugins { SarSensor::SarSensor(SensorParams* params, PlatformPosition* position) : Sensor(params, position) { } SarSensor::~SarSensor() { } int SarSensor::ImageToWorld(double distance, JSDDateTime time, double height, double& lon, double& lat) const { const double TWOPI = 6.28318530717958647693 ; double semiMajorAxis = _params->get_semiMajorAxis() ; // default : WGS84 double semiMinorAxis = _params->get_semiMinorAxis() ; // default : WGS84 double lambda = _params->get_rwl(); int sensVisee ; if (_params->get_sightDirection() == SensorParams::Right) sensVisee = 1 ; else sensVisee = -1 ; Ephemeris* satPosition = _position->Interpolate(time); GeographicEphemeris *geoEph = (GeographicEphemeris*)satPosition; RectangularCoordinate cart; double dopplerCentroid = _params->get_dopcen(); double dopcenLinear = _params->get_dopcenLinear(); if (dopcenLinear != 0.0) { dopplerCentroid += dopcenLinear * distance/1000; // Hz/km } // note : the Doppler frequency is set to zero int etatLoc = localisationSAR(*geoEph, lambda, distance, dopplerCentroid, sensVisee, semiMajorAxis , semiMinorAxis , height, &cart); GeodesicCoordinate geo; cart.AsGeodesicCoordinates(semiMajorAxis , semiMinorAxis, &geo); lon = (geo.get_x())*360.0/TWOPI; lat = (geo.get_y())*360.0/TWOPI; delete satPosition; return etatLoc ; } int SarSensor::localisationSAR ( GeographicEphemeris posSpeed , double lambda , double dist , double fDop , int sensVisee , double equRadius , double polRadius , double h , RectangularCoordinate* cart ) const { double coordCart[3]; coordCart[0]=0.0; coordCart[1]=0.0; coordCart[2]=0.0; double rho2 , k , a , b , c , d , u , v , w ; double x[4] , y[4] , z[4] , r[4] ; bool isEnd; /* Initialization of characteristical values */ /* note : for precise computation : */ /* - ranges are processed in mm */ /* - velocities are processed in km/s */ /* - frequencies are processed in kHz */ const double KILO = 1.0e-3 ; const double MEGA = 1.0e-6 ; const double EPSILON = 1.0e-12 ; double dist1 = dist * MEGA ; double fDop1 = fDop * KILO ; double he = (equRadius + h) * MEGA ; /* Equatorial radius + h */ double hp = (polRadius + h) * MEGA ; /* Polar radius + h */ double posX = posSpeed.get_position()[0] * MEGA ; double posY = posSpeed.get_position()[1] * MEGA ; double posZ = posSpeed.get_position()[2] * MEGA ; double speedX = - posSpeed.get_speed()[0] * KILO ; double speedY = - posSpeed.get_speed()[1] * KILO ; double speedZ = - posSpeed.get_speed()[2] * KILO ; /* Coefficients computation and equation solving */ int state = 0; u = speedX * posY - speedY * posX ; a = (speedX / u) * (1.0 - (he / hp) * (he / hp)) / 2.0 ; b = (speedX * posZ - speedZ * posX) / u ; rho2 = posX * posX + posY * posY + posZ * posZ ; k = posX * speedX + posY * speedY + posZ * speedZ - lambda * dist1 * fDop1 / 2.0 ; c = (speedX * (he * he + rho2 - dist1 * dist1) - 2.0 * k * posX) / (2.0 * u); u = speedZ - b * speedY ; v = c * speedY - k ; w = v * v - (speedX * speedX) * (he * he - c * c) ; std::complex aa[5]; aa[0] = std::complex(w,0.0); /* Constant coefficient */ w = 2.0 * (u * v - (b * c) * (speedX * speedX)) ; aa[1] = std::complex(w,0.0) ; /* First order coefficient */ w = u * u + 2.0 * a * v * speedY + (speedX * speedX) * ((he / hp) * (he / hp) + b * b + 2.0 * a * c) ; aa[2] = std::complex(w,0.0) ; /* Second order coefficient */ w = 2.0 * a * (u * speedY - b * speedX * speedX) ; aa[3] = std::complex(w,0.0) ; /* Third order coefficient */ w = (speedX * speedX + speedY * speedY) * a * a ; aa[4] = std::complex(w,0.0) ; /* Fourth order coefficient */ Equation eq(4,aa); /* Equation solving */ eq.Solve(); int n = eq.get_nbrSol(); const std::complex *root = eq.get_solutions(); int nRoot = 0 ; for (int i = 0 ; i < n ; i++) /* Real root selection */ { d = fabs(root[i].imag()) ; if (d < EPSILON) { z[nRoot] = root[i].real(); y[nRoot] = (a * z[nRoot] - b) * z[nRoot] + c ; x[nRoot] = (k - (speedY * y[nRoot] + speedZ * z[nRoot])) / speedX ; nRoot = nRoot + 1 ; } } if (nRoot == 0) state = 2 ; /* No root */ /* Computed roots sort */ if (state == 0) { int indice[4] ; for (int i = 0 ; i < nRoot ; i++) { /* Computation of the "distance" between roots images and equation values */ u = x[i] - posX ; v = y[i] - posY ; w = z[i] - posZ ; r[i] = fabs ((u * u + v * v + w * w) / (dist1 * dist1) - 1.0 ) ; u = u * speedX ; v = v * speedY ; w = w * speedZ ; if (fabs (fDop) > EPSILON) r[i] = r[i] + fabs (1.0 + 2.0 * (u + v + w) / (lambda * dist1 * fDop1)); else r[i] = r[i] + fabs (2.0 * (u + v + w) / (lambda * dist1)) ; u = x[i] / he ; v = y[i] / he ; w = z[i] / hp ; r[i] = r[i] + fabs (u * u + v * v + w * w - 1.0) ; indice[i] = i ; } /* Roots sort by increasing differences */ isEnd = false ; while (!isEnd) { isEnd = true; for (int i = 0 ; i < (nRoot - 1) ; i++) { int i1 = indice[i] ; int i2 = indice[i+1] ; if (r[i2] < r[i1]) { indice[i] = i2 ; indice[i+1] = i1 ; isEnd = false ; } } } /* Selection of the correct root (corresponding to the imaging direction) */ isEnd = false ; int i = 0 ; while (!isEnd && (i < nRoot)) { int i1 = indice[i] ; u = posY * speedZ - posZ * speedY ; v = posZ * speedX - posX * speedZ ; w = posX * speedY - posY * speedX ; a = x[i1] - posX ; b = y[i1] - posY ; c = z[i1] - posZ ; d = (a * u + b * v + c * w) * sensVisee; if (d >= 0.0) { coordCart[0] = x[i1] / MEGA ; /* Coordinates in the */ coordCart[1] = y[i1] / MEGA ; /* geographic referential, */ coordCart[2] = z[i1] / MEGA ; /* in legal units (m) */ isEnd = true; } i++ ; } if (!isEnd) state = 1 ; /* No root in the imaging direction */ } cart->set_coordinates(coordCart[0], coordCart[1], coordCart[2]); return state ; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/SarSensor.h000066400000000000000000000036511301006202600263560ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef SarSensor_h #define SarSensor_h #include #include namespace ossimplugins { class SensorParams; class PlatformPosition; class GeographicEphemeris; class RectangularCoordinate; class JSDDateTime; /** * @ingroup SARModel * @brief This class provides basic location services for SAR sensors */ class OSSIM_PLUGINS_DLL SarSensor : Sensor { public: /** * @brief Constructor * * @remarks This constructor creates a copy of params and position */ SarSensor(SensorParams* params, PlatformPosition* position); /** * @brief Destructor */ virtual ~SarSensor(); /** * @brief This function is able to convert image coordinates into geodetic world coordinates using a geometric SAR sensor model * * @param distance : Slant range of the image point * @param time : Azimuth time of the image point * @param height : Altitude of the world point * @retval lon : Longitude of the world point * @retval lat : Latitude of the world point * * @remark : the doppler frequency is set to zero in this implementation */ virtual int ImageToWorld(double distance, JSDDateTime time, double height, double& lon, double& lat) const; protected: /** * @brief This function is able to convert image coordinates into rectangular world coordinates */ int localisationSAR ( GeographicEphemeris posSpeed , double lambda , double dist , double fDop , int sensVisee , double equRadius , double polRadius , double h , RectangularCoordinate* cart ) const; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/SceneCoord.cpp000066400000000000000000000101731301006202600270130ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include #include namespace ossimplugins { static const char SCENE_COORD[] = "sceneCoord"; static const char NUMBER_OF_SCENE_CORNER_COORD[] = "numberOfSceneCornerCoord"; static const char SCENE_CENTER_COORD[] = "sceneCenterCoord"; static const char SCENE_CORNER_COORD[] = "sceneCornerCoord"; SceneCoord::SceneCoord() : _numberOfSceneCoord(0), _centerSceneCoord(), _tabCornersSceneCoord() { } SceneCoord::~SceneCoord() { } SceneCoord::SceneCoord(const SceneCoord& rhs) : _numberOfSceneCoord(rhs._numberOfSceneCoord), _centerSceneCoord(rhs._centerSceneCoord), _tabCornersSceneCoord(rhs._tabCornersSceneCoord) { } SceneCoord& SceneCoord::operator=(const SceneCoord& rhs) { if ( this != &rhs ) { _numberOfSceneCoord = rhs._numberOfSceneCoord; _centerSceneCoord = rhs._centerSceneCoord; _tabCornersSceneCoord = rhs._tabCornersSceneCoord; } return *this; } bool SceneCoord::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx(""); std::string pfx2(""); if (prefix) { pfx = prefix; } pfx += SCENE_COORD; pfx2 = pfx; pfx2 += "."; kwl.add(pfx2.c_str(), NUMBER_OF_SCENE_CORNER_COORD, _numberOfSceneCoord); std::string s = pfx + "." + SCENE_CENTER_COORD; _centerSceneCoord.saveState(kwl, s.c_str()); std::string s2 =pfx + "." + SCENE_CORNER_COORD; for (unsigned int i = 0; i < _tabCornersSceneCoord.size(); ++i) { std::string s3 = s2 + "[" + ossimString::toString(i).c_str() + "]"; _tabCornersSceneCoord[i].saveState(kwl, s3.c_str()); } return true; } bool SceneCoord::loadState(const ossimKeywordlist& kwl, const char* prefix) { static const char MODULE[] = "SceneCoord::loadState"; bool result = true; ossimString s; const char* lookup = 0; std::string pfx(""); if (prefix) { pfx = prefix; } pfx += SCENE_COORD; pfx += "."; lookup = kwl.find(pfx.c_str(), NUMBER_OF_SCENE_CORNER_COORD); if (lookup) { s = lookup; _numberOfSceneCoord = s.toUInt32(); } else { ossimNotify(ossimNotifyLevel_WARN) << MODULE << " Keyword not found: " << NUMBER_OF_SCENE_CORNER_COORD << " in "< #include #include #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup SceneCoord * @brief This class represents Scence coordinate */ class OSSIM_PLUGINS_DLL SceneCoord { public: /** * @brief Constructor */ SceneCoord(); /** * @brief Destructor */ virtual ~SceneCoord(); /** * @brief Copy constructor */ SceneCoord(const SceneCoord& rhs); /** * @brief Affectation operator */ SceneCoord& operator=(const SceneCoord& rhs); /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); /*! * METHOD: print() * Fulfills base-class pure virtual. Dumps contents of object to ostream. */ virtual std::ostream& print(std::ostream& out) const; void set_numberOfSceneCoord(const ossim_uint32& numberOfSceneCoord) { _numberOfSceneCoord = numberOfSceneCoord; } void set_centerSceneCoord(const InfoSceneCoord& centerSceneCoord) { _centerSceneCoord = centerSceneCoord; } void set_cornersSceneCoord(const std::vector& cornersSceneCoord) { _tabCornersSceneCoord = cornersSceneCoord; } protected: /** * @brief Number of scene coordinate */ ossim_uint32 _numberOfSceneCoord; /** * @brief Center scene coordinate. */ InfoSceneCoord _centerSceneCoord; /** * @brief Corners InfoIncidenceAngle. */ std::vector _tabCornersSceneCoord; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Sensor.cpp000066400000000000000000000013111301006202600262320ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include #include namespace ossimplugins { Sensor::Sensor(SensorParams* params, PlatformPosition* position) { _params = params->Clone(); _position = position->Clone(); } Sensor::~Sensor() { if(_params != NULL) { delete _params; } if(_position != NULL) { delete _position; } } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/Sensor.h000066400000000000000000000026501301006202600257060ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef Services_h #define Services_h #include namespace ossimplugins { class SensorParams; class PlatformPosition; class JSDDateTime; /** * @ingroup SARModel * @brief This class provides basic location services */ class OSSIM_PLUGINS_DLL Sensor { public: /** * @brief Constructor * * @remarks This constructor creates a copy of the sensor model (params and position) */ Sensor(SensorParams* params, PlatformPosition* position); /** * @brief Destructor */ virtual ~Sensor(); /** * @brief This function is able to convert image coordinates into geodetic world coordinates using a sensor model * * @param distance : Slant range of the image point * @param time : Azimuth time of the image point * @param height : Altitude of the world point * @retval lon : Longitude of the world point * @retval lat : Latitude of the world point */ virtual int ImageToWorld(double distance, JSDDateTime time, double height, double& lon, double& lat) const = 0; protected: SensorParams * _params; PlatformPosition* _position; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/SensorParams.cpp000066400000000000000000000134031301006202600274030ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include #include #include namespace ossimplugins { static const char PREFIX[] = "sensor_params."; static const char PRF_KW[] = "prf"; static const char SF_KW[] = "sampling_frequency"; static const char RWL_KW[] = "radar_wave_length"; static const char COL_DIR_KW[] = "column_direction"; static const char LIN_DIR_KW[] = "line_direction"; static const char SIGHT_DIR_KW[] = "sight_direction"; static const char SEMI_MAJOR_AXIS_KW[] = "semi_major_axis"; static const char SEMI_MINOR_AXIS_KW[] = "semi_minor_axis"; static const char NUM_AZIMUTH_LOOKS_KW[] = "number_azimuth_looks"; static const char NUM_RANGE_LOOKS_KW[] = "number_range_looks"; static const char DOPCEN_KW[] = "doppler_centroid"; static const char DOPCENLINEAR_KW[] = "doppler_centroid_linear_term"; static const char RANGETOFIRSTDATA_KW[] = "range_to_first_data_sample"; SensorParams::SensorParams(): _prf(0.0), _sf(0.0), _rwl(0.0), _col_direction(1), _lin_direction(1), _sightDirection(Right), _semiMajorAxis(6378137.0), _semiMinorAxis(6356752.3141), _nAzimuthLook(1), _nRangeLook(1), _dopcen(0.0), _dopcenLinear(0.0) { } SensorParams::~SensorParams() { } SensorParams::SensorParams(const SensorParams& rhs): _prf(rhs._prf), _sf(rhs._sf), _rwl(rhs._rwl), _col_direction(rhs._col_direction), _lin_direction(rhs._lin_direction), _sightDirection(rhs._sightDirection), _semiMajorAxis(rhs._semiMajorAxis), _semiMinorAxis(rhs._semiMinorAxis), _nAzimuthLook(rhs._nAzimuthLook), _nRangeLook(rhs._nRangeLook), _dopcen(rhs._dopcen), _dopcenLinear(rhs._dopcenLinear) { } SensorParams& SensorParams::operator=(const SensorParams& rhs) { _prf = rhs._prf; _sf = rhs._sf; _rwl = rhs._rwl; _col_direction = rhs._col_direction; _lin_direction = rhs._lin_direction; _sightDirection = rhs._sightDirection; _semiMajorAxis = rhs._semiMajorAxis; _semiMinorAxis = rhs._semiMinorAxis; _nAzimuthLook = rhs._nAzimuthLook; _nRangeLook = rhs._nRangeLook; _semiMajorAxis = rhs._semiMajorAxis; _semiMinorAxis = rhs._semiMinorAxis; _dopcen = rhs._dopcen; _dopcenLinear = rhs._dopcenLinear; return *this; } bool SensorParams::saveState(ossimKeywordlist& kwl, const char* prefix) const { std::string pfx; if (prefix) { pfx = prefix; } pfx += PREFIX; kwl.add(pfx.c_str(), PRF_KW, _prf); kwl.add(pfx.c_str(), SF_KW, _sf); kwl.add(pfx.c_str(), RWL_KW, _rwl); kwl.add(pfx.c_str(), COL_DIR_KW, _col_direction); kwl.add(pfx.c_str(), LIN_DIR_KW, _lin_direction); kwl.add(pfx.c_str(), SIGHT_DIR_KW, static_cast(_sightDirection)); kwl.add(pfx.c_str(), SEMI_MAJOR_AXIS_KW, _semiMajorAxis); kwl.add(pfx.c_str(), SEMI_MINOR_AXIS_KW, _semiMinorAxis); kwl.add(pfx.c_str(), NUM_AZIMUTH_LOOKS_KW, _nAzimuthLook); kwl.add(pfx.c_str(), NUM_RANGE_LOOKS_KW, _nRangeLook); kwl.add(pfx.c_str(), DOPCEN_KW, _dopcen); kwl.add(pfx.c_str(), DOPCENLINEAR_KW, _dopcenLinear); return true; } bool SensorParams::loadState(const ossimKeywordlist& kwl, const char* prefix) { bool result = true; std::string pfx; if (prefix) { pfx = prefix; } pfx += PREFIX; ossimString s; const char* lookup = 0; lookup = kwl.find(pfx.c_str(), PRF_KW); if (lookup) { s = lookup; _prf = s.toDouble(); } else { result = false; } lookup = kwl.find(pfx.c_str(), SF_KW); if (lookup) { s = lookup; _sf = s.toDouble(); } else { result = false; } lookup = kwl.find(pfx.c_str(), RWL_KW); if (lookup) { s = lookup; _rwl = s.toDouble(); } else { result = false; } lookup = kwl.find(pfx.c_str(), COL_DIR_KW); if (lookup) { s = lookup; _col_direction = s.toInt(); } else { result = false; } lookup = kwl.find(pfx.c_str(), LIN_DIR_KW); if (lookup) { s = lookup; _lin_direction = s.toInt(); } else { result = false; } lookup = kwl.find(pfx.c_str(), SIGHT_DIR_KW); if (lookup) { s = lookup; if ( s.toInt() == 0 ) { _sightDirection = SensorParams::Left; } else { _sightDirection = SensorParams::Right; } } else { result = false; } lookup = kwl.find(pfx.c_str(), SEMI_MAJOR_AXIS_KW); if (lookup) { s = lookup; _semiMajorAxis = s.toDouble(); } else { result = false; } lookup = kwl.find(pfx.c_str(), SEMI_MINOR_AXIS_KW); if (lookup) { s = lookup; _semiMinorAxis = s.toDouble(); } else { result = false; } lookup = kwl.find(pfx.c_str(), NUM_AZIMUTH_LOOKS_KW); if (lookup) { s = lookup; _nAzimuthLook = s.toDouble(); } else { result = false; } lookup = kwl.find(pfx.c_str(), NUM_RANGE_LOOKS_KW); if (lookup) { s = lookup; _nRangeLook = s.toDouble(); } else { result = false; } lookup = kwl.find(pfx.c_str(), DOPCEN_KW); if (lookup) { s = lookup; _dopcen = s.toDouble(); } else { result = false; } return result; lookup = kwl.find(pfx.c_str(), DOPCENLINEAR_KW); if (lookup) { s = lookup; _dopcenLinear = s.toDouble(); } else { result = false; } return result; } } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossim/otb/SensorParams.h000066400000000000000000000103571301006202600270550ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #ifndef SensorParams_h #define SensorParams_h #include class ossimKeywordlist; namespace ossimplugins { /** * @ingroup SARModel * @brief This class handles the sensor parameters */ class OSSIM_PLUGINS_DLL SensorParams { public: enum SightDirection { Left = 0, Right = 1 }; /** * @brief Constructor */ SensorParams(); /** * @brief Destructor */ virtual ~SensorParams(); /** *@brief Copy constructor */ SensorParams(const SensorParams& rhs); /** * @brief Affectation operator */ SensorParams& operator=(const SensorParams& rhs); double get_prf() const { return _prf; } double get_sf() const { return _sf; } double get_rwl() const { return _rwl; } void set_prf(double prf) { _prf = prf; } void set_sf(double sf) { _sf = sf; } void set_rwl(double rwl) { _rwl = rwl; } SightDirection get_sightDirection() const { return _sightDirection; } void set_sightDirection(SightDirection sight) { _sightDirection = sight; } virtual SensorParams* Clone() { return new SensorParams(*this); } int get_col_direction() const { return _col_direction; } int get_lin_direction() const { return _lin_direction; } double get_nAzimuthLook() const { return _nAzimuthLook ; } double get_nRangeLook() const { return _nRangeLook ; } void set_col_direction(int dir) { _col_direction = dir; } void set_lin_direction(int dir) { _lin_direction = dir; } void set_nAzimuthLook(double look) { _nAzimuthLook = look; } void set_nRangeLook(double look) { _nRangeLook = look; } double get_semiMajorAxis() const { return _semiMajorAxis ; } double get_semiMinorAxis() const { return _semiMinorAxis ; } void set_semiMajorAxis(double value) { _semiMajorAxis = value; } void set_semiMinorAxis(double value) { _semiMinorAxis = value; } double get_dopcen() const { return _dopcen; } double get_dopcenLinear() const { return _dopcenLinear; } void set_dopcen(double value) { _dopcen = value; } void set_dopcenLinear(double value) { _dopcenLinear = value; } /** * @brief Method to save object state to a keyword list. * @param kwl Keyword list to save to. * @param prefix added to keys when saved. * @return true on success, false on error. */ bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const; /** * @brief Method to the load (recreate) the state of the object from a * keyword list. Return true if ok or false on error. * @return true if load OK, false on error */ bool loadState (const ossimKeywordlist &kwl, const char *prefix=0); protected: /** * @brief Nominal PRF, Hz */ double _prf; /** * @brief Sampling frequency */ double _sf; /** * @brief Radar wave length */ double _rwl; /** * @brief Columns direction (1=increasing, -1=decreasing) */ int _col_direction; /** * @brief Lines direction (1=increasing, -1=decreasing) */ int _lin_direction; /** * @brief Antenna pointing direction */ SightDirection _sightDirection; /** * @brief Ellipsoid semi_major axis, m * Default : WGS84 */ double _semiMajorAxis; /** * @brief Ellipsoid semi_minor axis, m * Default : WGS84 */ double _semiMinorAxis; /** * @brief Number of azimuth looks */ double _nAzimuthLook ; /** * @brief Number of range looks */ double _nRangeLook ; /** * @brief Doppler centroid (at range 0) */ double _dopcen; /** * @brief Doppler centroid linear term (wrt range in km) */ double _dopcenLinear; private: }; } #endif OTB-release-5.8/Modules/ThirdParty/OssimPlugins/src/ossimPluginConstants.h000066400000000000000000000026701301006202600267270ustar00rootroot00000000000000//---------------------------------------------------------------------------- // Copyright (c) 2005, David Burken, all rights reserved. // // License: LGPL // // See LICENSE.txt file in the top level directory for more details. // // Author: David Burken // // Description: Constants file for ossim plugins. // // $Id: ossimPluginConstants.h 7530 2005-05-23 17:21:24Z dburken $ //---------------------------------------------------------------------------- #ifndef ossimPluginConstants_HEADER #define ossimPluginConstants_HEADER /** * DLL IMPORT/EXORT SECTION */ #if defined(OSSIM_STATIC) # define OSSIMPLUGINSEXPORT # define OSSIMPLUGINSIMPORT # define OSSIMPLUGINSDLLEXPORT # define OSSIM_PLUGINS_DLL #elif defined(__MINGW32__) || defined(__CYGWIN__) || defined(_MSC_VER) || defined(__VISUALC__) || defined(__BORLANDC__) || defined(__WATCOMC__) # define OSSIMPLUGINSEXPORT __declspec(dllexport) # define OSSIMPLUGINSIMPORT __declspec(dllimport) # ifdef OSSIMPLUGINSMAKINGDLL # define OSSIMPLUGINSDLLEXPORT OSSIMPLUGINSEXPORT # define OSSIM_PLUGINS_DLL OSSIMPLUGINSEXPORT # else # define OSSIMPLUGINSDLLEXPORT OSSIMPLUGINSIMPORT # define OSSIM_PLUGINS_DLL OSSIMPLUGINSIMPORT # endif #else /* not #if defined(_MSC_VER) */ # define OSSIMPLUGINSEXPORT # define OSSIMPLUGINSIMPORT # define OSSIMPLUGINSDLLEXPORT # define OSSIM_PLUGINS_DLL #endif /* #if defined(_MSC_VER) */ #endif /* #ifndef ossimPluginConstants_HEADER */ OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/000077500000000000000000000000001301006202600225335ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/CMakeLists.txt000066400000000000000000000076201301006202600253000ustar00rootroot00000000000000otb_module_test() # Common dirs #include_directories(${PROJECT_SOURCE_DIR}/Modules/ThirdParty/OssimPlugins/src/ossim ${OSSIM_INCLUDE_DIR}) #==== UT for utilities if (Boost_UNIT_TEST_FRAMEWORK_FOUND) #this test is failing on osx due to a bug in AppleClang stdc++ (Luc Hermitte) if(NOT APPLE) add_executable(ossimStringUtilitiesTest ossimStringUtilitiesTest.cpp) target_link_libraries(ossimStringUtilitiesTest otbossimplugins ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}) otb_module_target_label(ossimStringUtilitiesTest) otb_add_test(NAME ossimStringUtilitiesTest COMMAND ossimStringUtilitiesTest ) endif() add_executable(ossimTimeUtilitiesTest ossimTimeUtilitiesTest.cpp) target_link_libraries(ossimTimeUtilitiesTest # ${OTBOssim_LIBRARIES} otbossimplugins ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}) otb_module_target_label(ossimTimeUtilitiesTest) otb_add_test(NAME ossimTimeUtilitiesTest COMMAND ossimTimeUtilitiesTest ) else() message(STATUS "Boost unit test framework not found, ossimStringUtilitiesTest and ossimTimeUtilitiesTest will be skipped.") endif() #==== Benchmarking Time conversion # (requires google.benchmark) find_package(GBenchmark) if (GBENCHMARK_FOUND) add_executable(ossimTimeUtilitiesBench ossimTimeUtilitiesBench.cpp) include_directories(${GBENCHMARK_INCLUDE_DIRS}) target_link_libraries(ossimTimeUtilitiesBench otbossimplugins ${GBENCHMARK_LIBRARIES}) otb_module_target_label(ossimTimeUtilitiesBench) else() message(STATUS "Google.benchmark not found, ossimTimeUtilitiesBench will be skipped.") endif() #===== Domain tests #Test executables add_executable(ossimSarSensorModelTest ossimSarSensorModelTest.cpp) target_link_libraries(ossimSarSensorModelTest otbossimplugins) otb_module_target_label(ossimSarSensorModelTest) # S1 add_executable(ossimSentinel1ModelTest ossimSentinel1ModelTest.cpp) target_link_libraries(ossimSentinel1ModelTest otbossimplugins) otb_module_target_label(ossimSentinel1ModelTest) # TSX (old) add_executable(ossimTerraSarXSarSensorModelTest ossimTerraSarXSarSensorModelTest.cpp) target_link_libraries(ossimTerraSarXSarSensorModelTest otbossimplugins) otb_module_target_label(ossimTerraSarXSarSensorModelTest) otb_add_test(NAME ossimSarSensorModelTest COMMAND ossimSarSensorModelTest ) #S1 tests file(GLOB s1_files ${INPUTDATA}/ossimPlugins/s1/*.xml) #Loop over all S1 annotation files foreach(entry ${s1_files}) get_filename_component(name ${entry} NAME_WE) otb_add_test( NAME s1_inverse_${name} COMMAND ossimSentinel1ModelTest 1 ${entry}) otb_add_test( NAME s1_forward_${name} COMMAND ossimSentinel1ModelTest 0 ${entry}) endforeach() # #TSX tests # file(GLOB tsx_files ${CMAKE_SOURCE_DIR}/data/tsx/*) # #Loop over all S1 annotation files # foreach(entry ${tsx_files}) # file(GLOB tsx_files ${CMAKE_SOURCE_DIR}/data/tsx/*) # get_filename_component(name ${entry} NAME_WE) # add_test( tsx_inverse_${name} ossimTerraSarXSarSensorModelTest ${entry} ) # add_test( tsx_forward_${name} ossimSentinel1SarSensorModelTest 0 ${entry}) # endforeach() # otb_add_test( NAME tsx_inverse_PANGKALANBUUN COMMAND ossimTerraSarXSarSensorModelTest 1 ${CMAKE_SOURCE_DIR}/data/tsx/PANGKALANBUUN/TSX1_SAR__SSC______SM_D_SRA_20080313T221955_20080313T222003.xml ${CMAKE_SOURCE_DIR}/data/tsx/PANGKALANBUUN/GEOREF.xml) # otb_add_test( NAME tsx_forward_PANGKALANBUUN COMMAND ossimTerraSarXSarSensorModelTest 0 ${CMAKE_SOURCE_DIR}/data/tsx/PANGKALANBUUN/TSX1_SAR__SSC______SM_D_SRA_20080313T221955_20080313T222003.xml ${CMAKE_SOURCE_DIR}/data/tsx/PANGKALANBUUN/GEOREF.xml) # otb_add_test( NAME tsx_inverse_UPSALA COMMAND ossimTerraSarXSarSensorModelTest 1 ${CMAKE_SOURCE_DIR}/data/tsx/UPSALA_GLACIER/TSX1_SAR__MGD.xml ${CMAKE_SOURCE_DIR}/data/tsx/UPSALA_GLACIER/GEOREF.xml) # otb_add_test( NAME tsx_forward_UPSALA COMMAND ossimTerraSarXSarSensorModelTest 0 ${CMAKE_SOURCE_DIR}/data/tsx/UPSALA_GLACIER/TSX1_SAR__MGD.xml ${CMAKE_SOURCE_DIR}/data/tsx/UPSALA_GLACIER/GEOREF.xml) OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/ossimSarSensorModelTest.cpp000066400000000000000000000007011301006202600300500ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #include "ossimSarSensorModel.h" int main(int, char *[]) { ossimplugins::ossimSarSensorModel sensor; return EXIT_SUCCESS; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/ossimSentinel1ModelTest.cpp000066400000000000000000000056061301006202600300040ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #if defined(__GNUC__) || defined(__clang__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wunused-parameter" # pragma GCC diagnostic ignored "-Woverloaded-virtual" # pragma GCC diagnostic ignored "-Wshadow" #include "ossimSentinel1Model.h" #include "ossimPluginProjectionFactory.h" # pragma GCC diagnostic pop #else #include "ossimSentinel1Model.h" #include "ossimPluginProjectionFactory.h" #endif #include #include #include #include using namespace ossimplugins; enum Inverse { fwd, inv, undef}; int main(int argc, char * argv[]) { std::clog.precision(20); string annotationXml; Inverse inverse = undef; bool verbose = false; for (int i=1; i!=argc ; ++i) { std::string const a(argv[i]); if (a == "-v" || a == "-verbose") { verbose = true; } else if (inverse == undef) { inverse = atoi(argv[i]) == 1 ? inv : fwd; } else if (annotationXml.empty()) { annotationXml = a; } else { std::cerr << "Too many arguments\n" << argv[0] << "[-v|--verbose] \n"; return EXIT_FAILURE; } } if(annotationXml.empty()) { std::cerr << "Not enough arguments\n" << argv[0] << "[-v|--verbose] \n"; return EXIT_FAILURE; } if (!verbose) { std::clog.setstate(std::ios_base::badbit); } try { std::auto_ptr projection (ossimPluginProjectionFactory::instance()->createProjection(annotationXml, 42)); if (!projection.get()) { throw std::runtime_error("Cannot read annotation file ("+annotationXml+"). Cannot create a projection from it."); } ossimSentinel1Model * sensor = dynamic_cast(projection.get()); if (!sensor) { throw std::runtime_error( "Unlike Expectations, the annotation file ("+annotationXml+") is not a Sentinel Annotation File"); } if (verbose) { sensor->print(std::clog); } ossimKeywordlist kwl; sensor->saveState(kwl, "S1."); sensor->loadState(kwl, "S1."); if (verbose) { sensor->print(std::clog); } const bool validate = inverse == inv ? sensor->autovalidateInverseModelFromGCPs() : sensor->autovalidateForwardModelFromGCPs() ; std::cout << "Validate: " << validate << "\n"; return validate ? EXIT_SUCCESS : EXIT_FAILURE; } catch (std::exception const& e) { std::cerr << "Error: " << e.what() << "\n"; } return EXIT_FAILURE; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/ossimStringUtilitiesTest.cpp000066400000000000000000000200131301006202600303100ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" // #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #endif #define BOOST_TEST_MODULE "ossim String Utilities unit testing" #define BOOST_TEST_DYN_LINK #include "ossimStringUtilities.h" #include #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic pop #endif using namespace ossimplugins; #if 0 BOOST_AUTO_TEST_CASE(begin_end) { char const t[] = "123456789"; std::string const s = "123456789"; BOOST_REQUIRE_EQUAL(*rbegin(t), 0); BOOST_REQUIRE_EQUAL(size(s), 9u); BOOST_REQUIRE_EQUAL(size(t), 10u); } #endif BOOST_AUTO_TEST_CASE(string_view_array) { char const t[] = "123456789"; string_view v(t); BOOST_CHECK_EQUAL(v.size() , 9u); BOOST_CHECK(! v.empty()); BOOST_CHECK_EQUAL(*v.begin() , '1'); BOOST_CHECK_EQUAL(*(v.end()-1), '9'); BOOST_CHECK_EQUAL(v.front() , '1'); BOOST_CHECK_EQUAL(v.back() , '9'); BOOST_CHECK(v.belongs_to(t)); for (std::size_t i = 0; i!= sizeof(t) ; ++i) { for (std::size_t j=i+1; j!=sizeof(t) ; ++j) { string_view tmp(&t[i], &t[j]); // std::cout << t << "[" << i << ":" << j << "[ -> " << tmp ; BOOST_CHECK(tmp.belongs_to(t)); string_view wh = find(t, tmp); // std::cout << " -> found: " << static_cast(wh.data()) << ", " << wh.size() << " chars\n"; BOOST_CHECK_EQUAL(wh.data(), &t[i]); BOOST_CHECK(contains(t,tmp)); } } BOOST_CHECK(contains(t, "345")); BOOST_CHECK(!contains(t, "35")); } BOOST_AUTO_TEST_CASE(string_view_string) { std::string const s = "123456789"; string_view v(s); BOOST_CHECK_EQUAL(v.size() , 9u); BOOST_CHECK(! v.empty()); BOOST_CHECK_EQUAL(*v.begin() , '1'); BOOST_CHECK_EQUAL(*(v.end()-1), '9'); BOOST_CHECK_EQUAL(v.front() , '1'); BOOST_CHECK_EQUAL(v.back() , '9'); const std::size_t len = s.length(); BOOST_CHECK(v.belongs_to(s)); for (std::size_t i = 0; i!= len ; ++i) { for (std::size_t j=i; j!=len ; ++j) { BOOST_CHECK(string_view(&s[i], &s[j]).belongs_to(s)); } } BOOST_CHECK(string_view(&s[0], &s[len]).belongs_to(s)); BOOST_CHECK(!string_view(&s[0], &s[len+1]).belongs_to(s)); BOOST_CHECK(!string_view(&s[-1], &s[len]).belongs_to(s)); } BOOST_AUTO_TEST_CASE(string_view_ptr) { char const *ptr = "123456789"; string_view v(ptr); BOOST_CHECK_EQUAL(v.size() , 9u); BOOST_CHECK(! v.empty()); BOOST_CHECK_EQUAL(*v.begin() , '1'); BOOST_CHECK_EQUAL(*(v.end()-1), '9'); BOOST_CHECK_EQUAL(v.front() , '1'); BOOST_CHECK_EQUAL(v.back() , '9'); const std::size_t len = std::strlen(ptr); BOOST_CHECK(v.belongs_to(ptr)); for (std::size_t i = 0; i!= len ; ++i) { for (std::size_t j=i; j!=len ; ++j) { BOOST_CHECK(string_view(&ptr[i], &ptr[j]).belongs_to(ptr)); } } } BOOST_AUTO_TEST_CASE(tests) { char const t[] = "123456789"; std::string const s = "123456789"; string_view v(t); BOOST_CHECK_EQUAL(v, t); BOOST_CHECK_EQUAL(v, s); BOOST_CHECK(starts_with(v, t)); BOOST_CHECK(starts_with(v, s)); BOOST_CHECK(starts_with(s, t)); BOOST_CHECK(starts_with(t, s)); BOOST_CHECK(starts_with(t, v)); BOOST_CHECK(starts_with(s, v)); BOOST_CHECK(ends_with(v, t)); BOOST_CHECK(ends_with(v, s)); BOOST_CHECK(ends_with(s, t)); BOOST_CHECK(ends_with(t, s)); BOOST_CHECK(ends_with(t, v)); BOOST_CHECK(ends_with(s, v)); BOOST_CHECK(starts_with(s, "1")); BOOST_CHECK(starts_with(s, "12")); BOOST_CHECK(starts_with(s, "123")); BOOST_CHECK(!starts_with(s, "23")); BOOST_CHECK(ends_with(s, "9")); BOOST_CHECK(ends_with(s, "89")); BOOST_CHECK(ends_with(s, "789")); BOOST_CHECK(!ends_with(s, "23")); } template void check_split(RangeType const& parts, char const* (&expected)[NbParts]) { typedef RangeType range_type; typedef typename range_type::const_iterator const_iterator; const_iterator it = parts.begin(); const_iterator end = parts.end(); std::size_t n=0; for (; it != end && n!=NbParts ; ++it, ++n) { // std::cout << "iteration #" << n << " -> " << it << std::endl; BOOST_CHECK(it->begin() <= it->end()); BOOST_CHECK_EQUAL(*it, expected[n]); } // std::cout << "End reached: " << it << std::endl; BOOST_CHECK_EQUAL(n, NbParts); BOOST_CHECK_EQUAL(it, end); } BOOST_AUTO_TEST_CASE(split1) { { char const* expected[] = { "abc", "def", "xy" }; check_split(split_on( "abc,def,xy", ','), expected); } { char const* expected[] = { "", "abc", "z", "", "", "def", "xy", "", "" }; check_split(split_on( ",abc,z,,,def,xy,,", ','), expected); } } BOOST_AUTO_TEST_CASE(to_int) { BOOST_CHECK_EQUAL(to("12", "UT"), 12); BOOST_CHECK_EQUAL(to("0", "UT"), 0); BOOST_CHECK_EQUAL(to("13576", "UT"), 13576); BOOST_CHECK_EQUAL(to("+12", "UT"), 12); BOOST_CHECK_EQUAL(to("+0", "UT"), 0); BOOST_CHECK_EQUAL(to("+13576", "UT"), 13576); BOOST_CHECK_EQUAL(to("-12", "UT"), -12); BOOST_CHECK_EQUAL(to("-0", "UT"), 0); BOOST_CHECK_EQUAL(to("-13576", "UT"), -13576); BOOST_CHECK_EQUAL(to_with_default("abc", 42), 42); BOOST_CHECK_EQUAL(to_with_default("12h", 42), 42); BOOST_CHECK_EQUAL(to_with_default("0x12", 42), 42); BOOST_CHECK_THROW(to("abc", "UT"), std::runtime_error); BOOST_CHECK_THROW(to("12h", "UT"), std::runtime_error); BOOST_CHECK_THROW(to("0x12", "UT"), std::runtime_error); BOOST_CHECK_EQUAL(to("12", "UT"), 12u); BOOST_CHECK_EQUAL(to("-1", "UT"), -1); BOOST_CHECK_THROW(to("-1", "UT"), std::runtime_error); } BOOST_AUTO_TEST_CASE(to_double) { BOOST_CHECK_CLOSE(to("12", "UT"), 12, 0.00001); BOOST_CHECK_CLOSE(to("0", "UT"), 0, 0.00001); BOOST_CHECK_CLOSE(to("13576", "UT"), 13576, 0.00001); BOOST_CHECK_CLOSE(to("+12", "UT"), 12, 0.00001); BOOST_CHECK_CLOSE(to("+0", "UT"), 0, 0.00001); BOOST_CHECK_CLOSE(to("+13576", "UT"), 13576, 0.00001); BOOST_CHECK_CLOSE(to("-12", "UT"), -12, 0.00001); BOOST_CHECK_CLOSE(to("-0", "UT"), 0, 0.00001); BOOST_CHECK_CLOSE(to("-13576", "UT"), -13576, 0.00001); BOOST_CHECK_CLOSE(to("12.1", "UT"), 12.1, 0.00001); BOOST_CHECK_CLOSE(to("0.1", "UT"), 0.1, 0.00001); BOOST_CHECK_CLOSE(to("13576.1", "UT"), 13576.1, 0.00001); BOOST_CHECK_CLOSE(to("+12.1", "UT"), 12.1, 0.00001); BOOST_CHECK_CLOSE(to("+0.1", "UT"), 0.1, 0.00001); BOOST_CHECK_CLOSE(to("+13576.1", "UT"), 13576.1, 0.00001); BOOST_CHECK_CLOSE(to("-12.1", "UT"), -12.1, 0.00001); BOOST_CHECK_CLOSE(to("-0.1", "UT"), -0.1, 0.00001); BOOST_CHECK_CLOSE(to("-13576.1", "UT"), -13576.1, 0.00001); // invalid double conversions return 0 as per ossim way of doind things BOOST_CHECK_THROW(to("abc", "UT"), std::runtime_error); BOOST_CHECK_THROW(to("12h", "UT"), std::runtime_error); BOOST_CHECK_THROW(to("0x12", "UT"), std::runtime_error); BOOST_CHECK_CLOSE(to_with_default("abc", 42), 42, 0.00001); BOOST_CHECK_CLOSE(to_with_default("12h", 42), 42, 0.00001); BOOST_CHECK_CLOSE(to_with_default("0x12", 42), 42, 0.00001); BOOST_CHECK(ossim::isnan(to("nan", "UT"))); } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/ossimTerraSarXSarSensorModelTest.cpp000066400000000000000000000022771301006202600316560ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #if defined(__GNUC__) || defined(__clang__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Woverloaded-virtual" #include "ossimTerraSarXSarSensorModel.h" # pragma GCC diagnostic pop #else #include "ossimTerraSarXSarSensorModel.h" #endif int main(int argc, char * argv[]) { std::cout.precision(9); if(argc != 4) return EXIT_FAILURE; std::string annotationXml = argv[2]; std::string geoXml = argv[3]; bool inverse = atoi(argv[1]); ossimplugins::ossimTerraSarXSarSensorModel * sensor = new ossimplugins::ossimTerraSarXSarSensorModel(); sensor->readAnnotationFile(annotationXml, geoXml); bool validate(false); if(inverse) { validate = sensor->autovalidateInverseModelFromGCPs(); } else { validate = sensor->autovalidateForwardModelFromGCPs(); } delete sensor; if(validate) return EXIT_SUCCESS; return EXIT_FAILURE; } OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/ossimTimeUtilitiesBench.cpp000066400000000000000000000145451301006202600300550ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ // // Typical results are: // Run on (8 X 1998 MHz CPU s) // 2016-05-19 18:55:03 // ***WARNING*** CPU scaling is enabled, the benchmark real time measurements may be noisy and will incur extra overhead. // Benchmark Time CPU Iterations // -------------------------------------------------------------------------------- // BM_decode_string_view/697.936M 1927 ns 1923 ns 372340 // BM_decode_string_view/1.36316G 1906 ns 1904 ns 357143 // BM_decode_split/697.936M 4421 ns 4415 ns 157658 // BM_decode_split/1.36316G 4404 ns 4400 ns 159091 // BM_decode_iso/697.936M 11417 ns 11456 ns 62500 // BM_decode_iso/1.36316G 11418 ns 11456 ns 62500 // BM_decode_strptime_manual_julian/697.936M 1977 ns 1982 ns 357143 // BM_decode_strptime_manual_julian/1.36316G 1938 ns 1942 ns 364583 // BM_decode_strptime_ossim_julian/697.936M 2018 ns 2011 ns 350000 // BM_decode_strptime_ossim_julian/1.36316G 1982 ns 1977 ns 350000 //---------------------------------------------------------------------------- // #include "ossimTimeUtilities.h" #include #include #include #include #include "ossimStringUtilities.h" #include #include using namespace ossimplugins; static void clobber() { asm volatile("" : : : "memory"); } double getModifiedJulianDate(ossimString const& utcTimeString) { std::vector date_time; std::vector output; utcTimeString.split(date_time, "T"); date_time[0].split(output, "-"); if (output.size () != 3) { throw std::runtime_error("Invalid date" + utcTimeString); } char* stop; int year = std::strtol( output[0].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error("Invalid year" + utcTimeString); } stop = 0; int month = std::strtol( output[1].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error("Invalid month" + utcTimeString); } stop = 0; int day = std::strtol( output[2].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error("Invalid day" + utcTimeString); } /* Parse time */ output.clear(); date_time[1].split(output, ":"); if (output.size () != 3) { throw std::runtime_error("Invalid time" + utcTimeString); } stop = 0; int hours = std::strtol( output[0].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error("Invalid hour" + utcTimeString); } stop = 0; int minutes = std::strtol( output[1].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error("Invalid minutes" + utcTimeString); } stop = 0; double seconds = std::strtod( output[2].c_str(), &stop); if ( *stop != 0 ) { throw std::runtime_error("Invalid seconds" + utcTimeString); } /* Below method could replace all above split and convert. But there is a lot of checks done in ossimLocalTm::setIso8601( ) which slows us down. And I don't want that. */ /* ossimLocalTm otm; if ( !otm.setIso8601(utcString) ) { } ossimDate ossimdate(otm); */ ossimDate ossimdate(month, day, year); ossimdate.setHour(hours); ossimdate.setMin(minutes); ossimdate.setFloatSec(seconds); return ossimdate.getModifiedJulian(); } static const char format[] = "%Y-%m-%dT%H:%M:%S"; static const std::time_t now = std::time(NULL); template void build_date_string(char (&date)[N], std::time_t t) { std::tm tm; localtime_r(&t, &tm); std::strftime(date, N, format, &tm); } static void BM_decode_string_view(benchmark::State & state) { char date[1024]; // more than enough build_date_string(date, state.range_x()); while (state.KeepRunning()) { const time::ModifiedJulianDate d = time::toModifiedJulianDate(date); benchmark::DoNotOptimize(d); clobber(); } } BENCHMARK(BM_decode_string_view)->Range(now/2, now); static void BM_decode_split(benchmark::State & state) { char date[1024]; // more than enough build_date_string(date, state.range_x()); while (state.KeepRunning()) { const double d = getModifiedJulianDate(date); benchmark::DoNotOptimize(d); clobber(); } } BENCHMARK(BM_decode_split)->Range(now/2, now); static void BM_decode_iso(benchmark::State & state) { char date[1024]; // more than enough build_date_string(date, state.range_x()); while (state.KeepRunning()) { ossimLocalTm iso; iso.setIso8601(date); const double d = iso.getModifiedJulian(); benchmark::DoNotOptimize(d); clobber(); } } BENCHMARK(BM_decode_iso)->Range(now/2, now); static void BM_decode_strptime_manual_julian(benchmark::State & state) { char date[1024]; // more than enough build_date_string(date, state.range_x()); while (state.KeepRunning()) { // std::tm tm; ossimDate tm; strptime(date, format, &tm); int J = tm.tm_mon + 1; int K = tm.tm_mday; int I = tm.tm_year + 1900; double d = (K-32075+1461*(I+4800+(J-14)/12)/4+367*(J-2-(J-14)/12*12) /12-3*((I+4900+(J-14)/12)/100)/4+ (tm.tm_hour/24.0)+ (tm.tm_min/1440.0)+ ((tm.tm_sec+0.0)/86400.0)) - 2400000.5; benchmark::DoNotOptimize(d); clobber(); } } BENCHMARK(BM_decode_strptime_manual_julian)->Range(now/2, now); static void BM_decode_strptime_ossim_julian(benchmark::State & state) { char date[1024]; // more than enough build_date_string(date, state.range_x()); while (state.KeepRunning()) { ossimDate tm; strptime(date, format, &tm); const double d = tm.getModifiedJulian(); benchmark::DoNotOptimize(d); clobber(); } } BENCHMARK(BM_decode_strptime_ossim_julian)->Range(now/2, now); BENCHMARK_MAIN(); OTB-release-5.8/Modules/ThirdParty/OssimPlugins/test/ossimTimeUtilitiesTest.cpp000066400000000000000000000141511301006202600277460ustar00rootroot00000000000000//---------------------------------------------------------------------------- // // "Copyright Centre National d'Etudes Spatiales" // // License: LGPL-2 // // See LICENSE.txt file in the top level directory for more details. // //---------------------------------------------------------------------------- // $Id$ #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" // #pragma GCC diagnostic ignored "-Woverloaded-virtual" #pragma GCC diagnostic ignored "-Wshadow" #endif #define BOOST_TEST_MODULE "ossim Time Utilities unit testing" #define BOOST_TEST_DYN_LINK #include "ossimTimeUtilities.h" #include "ossimStringUtilities.h" #include #include #include #include #include #include #include #include #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic pop #endif double getModifiedJulianDate(ossimString const& utcTimeString) { std::vector date_time; std::vector output; utcTimeString.split(date_time, "T"); date_time[0].split(output, "-"); if (output.size () != 3) { throw std::runtime_error(("Invalid date" + utcTimeString).string()); } char* stop; int year = std::strtol( output[0].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error(("Invalid year" + utcTimeString).string()); } stop = 0; int month = std::strtol( output[1].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error(("Invalid month" + utcTimeString).string()); } stop = 0; int day = std::strtol( output[2].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error(("Invalid day" + utcTimeString).string()); } /* Parse time */ output.clear(); date_time[1].split(output, ":"); if (output.size () != 3) { throw std::runtime_error(("Invalid time" + utcTimeString).string()); } stop = 0; int hours = std::strtol( output[0].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error(("Invalid hour" + utcTimeString).string()); } stop = 0; int minutes = std::strtol( output[1].c_str(), &stop, 10); if ( *stop != 0 ) { throw std::runtime_error(("Invalid minutes" + utcTimeString).string()); } stop = 0; double seconds = std::strtod( output[2].c_str(), &stop); if ( *stop != 0 ) { throw std::runtime_error(("Invalid seconds" + utcTimeString).string()); } /* Below method could replace all above split and convert. But there is a lot of checks done in ossimLocalTm::setIso8601( ) which slows us down. And I don't want that. */ /* ossimLocalTm otm; if ( !otm.setIso8601(utcString) ) { } ossimDate ossimdate(otm); */ ossimDate ossimdate(month, day, year); ossimdate.setHour(hours); ossimdate.setMin(minutes); ossimdate.setFloatSec(seconds); return ossimdate.getModifiedJulian(); } typedef unsigned int uint; void check_time(char const* format, char const* sDate, int year, int month, int day, int hour, int min, int sec, double fsec) { // std::cout << "Test " << sDate << " against " << format << std::endl; const ossimDate d = ossimplugins::time::details::strptime(format, sDate); BOOST_CHECK_EQUAL(d.getYear(), year); BOOST_CHECK_EQUAL(d.getMonth(), month); BOOST_CHECK_EQUAL(d.getDay(), day); BOOST_CHECK_EQUAL(d.getHour(), hour); BOOST_CHECK_EQUAL(d.getMin(), min); BOOST_CHECK_EQUAL(d.getSec(), sec); BOOST_CHECK_EQUAL(d.getFractionalSecond(), fsec); // Reference ossimLocalTm iso; iso.setIso8601(sDate); BOOST_CHECK_EQUAL(d.getModifiedJulian(), iso.getModifiedJulian()); // Is ossimDate |--> MJD bijective ? const double dMJD = d.getModifiedJulian(); ossimDate d2; d2.setDateFromModifiedJulian(dMJD); BOOST_CHECK_EQUAL(d2.getYear(), year); BOOST_CHECK_EQUAL(d2.getMonth(), month); BOOST_CHECK_EQUAL(d2.getDay(), day); BOOST_CHECK_EQUAL(d2.getHour(), hour); BOOST_CHECK_EQUAL(d2.getMin(), min); BOOST_CHECK_CLOSE_FRACTION(d2.getSec()+d2.getFractionalSecond(), sec+fsec, 1e-6); // Alternative implementation BOOST_CHECK_CLOSE_FRACTION(d.getModifiedJulian(), getModifiedJulianDate(sDate), 1e-12); // Check string conversion // Yes, this is likelly to fail du to double imprecisions // - official ossimDate string conversion ossimplugins::time::ModifiedJulianDate mjd = ossimplugins::time::toModifiedJulianDate(sDate); // std::cout << "MJD("< 0) { oss << '.' << std::setw(6) << (d.getFractionalSecond() * 1000*1000); } BOOST_CHECK_EQUAL(oss.str(), sDate); // - our string conversion // std::cout << std::setprecision(20) ; // std::cout << mjd.as_day_frac() << " -> " << to_simple_string(mjd) << " / " << d.getModifiedJulian() << "\n"; // std::cout << oss.str() << "\n"; // We know this test will fail because of float rounding => just display std::cout.precision(16); std::cout << mjd << " as a simple string (" << ossimplugins::time::to_simple_string(mjd) << ") is expected to differ from " << sDate << "\n"; // BOOST_CHECK_EQUAL(to_simple_string(mjd), sDate); } BOOST_AUTO_TEST_CASE(check_strptime) { check_time( "%Y-%m-%dT%H:%M:%S", "2016-01-12T13:42:52", 2016, 1, 12, 13, 42, 52, 0.0); check_time( "%Y-%m-%dT%H:%M:%S", "1970-12-31T00:42:52", 1970, 12, 31, 0, 42, 52, 0.0); check_time( "%Y-%m-%dT%H:%M:%S%.", "1970-12-31T00:42:52", 1970, 12, 31, 0, 42, 52, 0.0); check_time( "%Y-%m-%dT%H:%M:%S%.", "1970-12-31T00:42:52.156000", 1970, 12, 31, 0, 42, 52, 0.156); check_time( "%Y-%m-%dT%H:%M:%S%.", "2015-06-19T19:50:44.223221", 2015, 6, 19, 19, 50, 44, 0.223221); } OTB-release-5.8/Modules/ThirdParty/Qt4/000077500000000000000000000000001301006202600175705ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Qt4/CMakeLists.txt000066400000000000000000000002761301006202600223350ustar00rootroot00000000000000project( OTBQt4 ) set( OTBQt4_SYSTEM_INCLUDE_DIRS ${QT_INCLUDE_DIRS} ) set( OTBQt4_LIBRARIES "${QT_LIBRARIES}" ) set( QT_VERSION "${QTVERSION}" CACHE INTERNAL "" FORCE ) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/Qt4/otb-module-init.cmake000066400000000000000000000002211301006202600235750ustar00rootroot00000000000000find_package( Qt4 REQUIRED QtCore QtGui QtOpenGL QtXml ) mark_as_advanced( QT_QMAKE_EXECUTABLE ) set( QT_USE_QTXML 1 ) include( ${QT_USE_FILE} ) OTB-release-5.8/Modules/ThirdParty/Qt4/otb-module.cmake000066400000000000000000000003421301006202600226400ustar00rootroot00000000000000set(DOCUMENTATION "This module imports Qt4 to the build system") otb_module(OTBQt4 DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable Qt4 dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/Qwt/000077500000000000000000000000001301006202600176735ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Qwt/CMakeLists.txt000066400000000000000000000002011301006202600224240ustar00rootroot00000000000000project(OTBQwt) set(OTBQwt_SYSTEM_INCLUDE_DIRS ${QWT_INCLUDE_DIRS}) set(OTBQwt_LIBRARIES "${QWT_LIBRARIES}") otb_module_impl() OTB-release-5.8/Modules/ThirdParty/Qwt/otb-module-init.cmake000066400000000000000000000003211301006202600237010ustar00rootroot00000000000000find_package(Qwt REQUIRED) if(NOT QWT_MAJOR_VERSION EQUAL 5) message(FATAL_ERROR "Only Qwt 5 is supported. Found version ${QWT_VERSION_STRING}") endif() if(WIN32) add_definitions(-DQWT_DLL) endif(WIN32) OTB-release-5.8/Modules/ThirdParty/Qwt/otb-module.cmake000066400000000000000000000003551301006202600227470ustar00rootroot00000000000000set(DOCUMENTATION "This module imports Qwt to the build system") otb_module(OTBQwt DEPENDS OTBQt4 TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable Qwt dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/SPTW/000077500000000000000000000000001301006202600177155ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/SPTW/CMakeLists.txt000066400000000000000000000002241301006202600224530ustar00rootroot00000000000000project(OTBSPTW) set(OTBSPTW_THIRD_PARTY 1) set(OTBSPTW_INCLUDE_DIRS ${OTBSPTW_SOURCE_DIR}/src) set(OTBSPTW_LIBRARIES otbSPTW) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/SPTW/otb-module.cmake000066400000000000000000000003641301006202600227710ustar00rootroot00000000000000set(DOCUMENTATION "This module imports SPTW to the build system") otb_module(OTBSPTW DEPENDS OTBMPI OTBGDAL TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable SPTW dependent modules" OFF) OTB-release-5.8/Modules/ThirdParty/SPTW/src/000077500000000000000000000000001301006202600205045ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/SPTW/src/CMakeLists.txt000066400000000000000000000020721301006202600232450ustar00rootroot00000000000000set(OTB3P_INSTALL_EXPORT_NAME "${OTBSPTW-targets}") set(OTB3P_INSTALL_INCLUDE_DIR "${OTBSPTW_INSTALL_INCLUDE_DIR}") set(OTB3P_INSTALL_RUNTIME_DIR "${OTBSPTW_INSTALL_RUNTIME_DIR}") set(OTB3P_INSTALL_LIBRARY_DIR "${OTBSPTW_INSTALL_LIBRARY_DIR}") set(OTB3P_INSTALL_ARCHIVE_DIR "${OTBSPTW_INSTALL_ARCHIVE_DIR}") set(OTBSPTW_MAIN_SRCS sptw.cc) add_library(otbSPTW ${OTBSPTW_MAIN_SRCS}) target_link_libraries(otbSPTW) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) #Install TARGET & FILES for otb-lib if(OTB_LIBRARY_PROPERTIES) set_target_properties(otbSPTW PROPERTIES ${OTB_LIBRARY_PROPERTIES}) endif() install(FILES sptw.h utils.h DESTINATION ${OTB3P_INSTALL_INCLUDE_DIR}/SPTW COMPONENT Development ) install(TARGETS otbSPTW EXPORT ${OTB3P_INSTALL_EXPORT_NAME} RUNTIME DESTINATION ${OTB3P_INSTALL_RUNTIME_DIR} COMPONENT RuntimeLibraries LIBRARY DESTINATION ${OTB3P_INSTALL_LIBRARY_DIR} COMPONENT RuntimeLibraries ARCHIVE DESTINATION ${OTB3P_INSTALL_ARCHIVE_DIR} COMPONENT Development ) otb_module_target( otbSPTW NO_INSTALL ) OTB-release-5.8/Modules/ThirdParty/SPTW/src/LICENSE000066400000000000000000000002461301006202600215130ustar00rootroot00000000000000This software is in the public domain, furnished "as is", without technical support, and with no warranty, express or implied, as to its usefulness for any purpose. OTB-release-5.8/Modules/ThirdParty/SPTW/src/README.md000066400000000000000000000031451301006202600217660ustar00rootroot00000000000000SPTW - Simple Parallel TIFF Writer ================================== The Simple Parallel TIFF Writer (SPTW) provides a useful interface for writing GeoTIFF files using MPI-IO. In traditional parallel processing applications, individual output rasters are created per processor because GDAL does not support parallel operation. This adds unnecessary complexity since these rasters must be recombined at the end. SPTW provides sequential consistency only when all write operations are nonconflicting, that is, each write operation accesses a distinct section of the raster file. In the [prasterblater-pio](https://github.com/dmm/prasterblaster/blob/master/src/demos/prasterblaster-pio.cc) demo program, each pixel of the output raster is contained in only one partition and each partition is only assigned to one process. This ensures all write accesses are nonconflicting and that sequential consistency is maintained. ### API * open_raster * populate_tile_offsets * write_area * close_raster Example usage can be found in examples/test.cpp ### Possible improvements SPTW achieves sequential consistency but it is almost certainly not optimal. Possble improvements include: #### Collective Operations Currently all file writes are done with non-collective operations. MPI I/O supports collective calls in which use a shared file pointer and file accesses are coordinated among processes. #### Using MPI I/O for read operations SPTW is only used to write the output file in the prasterblasterpio demo program. The file reads are done with the standard I/O functions. The use of collective reads may be more efficient. OTB-release-5.8/Modules/ThirdParty/SPTW/src/examples/000077500000000000000000000000001301006202600223225ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/SPTW/src/examples/test.cpp000066400000000000000000000054221301006202600240100ustar00rootroot00000000000000#include #include #include #include #include "../sptw.h" int main(int argc, char *argv[]) { const int TILE_SIZE = 16; const int RASTER_WIDTH = 1234; const int RASTER_HEIGHT = 5566; MPI_Init(&argc, &argv); if (argc < 2) { std::cout << "usage: " << argv[0] << " raster.tiff" << std::endl; return -1; } int rank = 0, process_count = 1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &process_count); string raster_fn = argv[1]; if (rank == 0) { std::cout << "Creating raster " << raster_fn << std::endl; OGRSpatialReference srs; char *wkt; srs.SetFromUserInput("EPSG:4326"); srs.exportToPrettyWkt(&wkt); double geotransform[6] = {1.0, 0.1, 0, 40, 0, 0.1}; sptw::SPTW_ERROR err = sptw::create_tiled_raster(raster_fn, RASTER_WIDTH, RASTER_HEIGHT, 1, GDT_Byte, geotransform, wkt, TILE_SIZE); if (err != sptw::SP_None) { std::cout << "Error creating raster" << std::endl; } } MPI_Barrier(MPI_COMM_WORLD); // We must open the raster in all the ranks // since it is a collective operation std::cout << "Opening raster" << std::endl; sptw::PTIFF* tmp = sptw::open_raster(raster_fn); if (rank == 0) { std::cout << "Populating tile offsets" << std::endl; sptw::SPTW_ERROR err = sptw::populate_tile_offsets(tmp, TILE_SIZE); if (err != sptw::SP_None) { std::cout << "Error populating tile offsets" << std::endl; } } sptw::close_raster(tmp); MPI_Barrier(MPI_COMM_WORLD); sptw::PTIFF* raster = sptw::open_raster(raster_fn); uint8_t tile_data[TILE_SIZE*TILE_SIZE]; memset(tile_data, rank * 255 / process_count, TILE_SIZE*TILE_SIZE); int horizontal_tiles = std::ceil((double) RASTER_WIDTH / TILE_SIZE); int vertical_tiles = std::ceil((double) RASTER_HEIGHT / TILE_SIZE); int num_tiles = horizontal_tiles * vertical_tiles; int tiles_per_rank = std::ceil((double)num_tiles / process_count); std::cout << "Rank " << rank << " writing raster (" << tiles_per_rank << " tiles)" << std::endl; for(int i = 0; i < tiles_per_rank; i++) { int tile = i*process_count + rank; int x = tile % horizontal_tiles; int y = tile / horizontal_tiles; x *= TILE_SIZE; y *= TILE_SIZE; int w = std::min(TILE_SIZE, RASTER_WIDTH - x) - 1; int h = std::min(TILE_SIZE, RASTER_HEIGHT - y) - 1; //printf("Writing (%d,%d) -> (%d, %d)\n", x, y, x+w, y+h); sptw::write_area(raster, tile_data, x, y, x+w, y+h); } MPI_Barrier(MPI_COMM_WORLD); sptw::close_raster(raster); MPI_Finalize(); return 0; } OTB-release-5.8/Modules/ThirdParty/SPTW/src/sptw.cc000066400000000000000000000520731301006202600220170ustar00rootroot00000000000000/*! * Copyright 0000 * @file * @author David Matthew Mattli * * @section LICENSE * * This software is in the public domain, furnished "as is", without * technical support, and with no warranty, express or implied, as to * its usefulness for any purpose. * * @section DESCRIPTION * * Implementation of the Simple Parallel Tiff Writer * */ #include #include #include #include #include #include #include #include #include #include #include #include #include "sptw.h" #include "utils.h" using std::string; using sptw::Area; namespace sptw { /* * Return size of TIFFDataType in bytes */ int get_type_size(TIFFDataType type) { switch (type) { case 0: case TIFF_BYTE: case TIFF_ASCII: case TIFF_SBYTE: case TIFF_UNDEFINED: return 1; case TIFF_SHORT: case TIFF_SSHORT: return 2; case TIFF_LONG: case TIFF_SLONG: case TIFF_FLOAT: case TIFF_IFD: return 4; case TIFF_RATIONAL: case TIFF_SRATIONAL: case TIFF_DOUBLE: case TIFF_LONG8: case TIFF_SLONG8: case TIFF_IFD8: return 8; default: return 0; /* unknown type */ } } int64_t parse_int64(uint8_t *buffer, bool big_endian) { int64_t result = 0; int64_t temp = 0; if (big_endian) { temp = buffer[0]; result |= temp<<56; temp = buffer[1]; result |= temp<<48; temp = buffer[2]; result |= temp<<40; temp = buffer[3]; result |= temp<<32; temp = buffer[4]; result |= temp<<24; temp = buffer[5]; result |= temp<<16; temp = buffer[6]; result |= temp<<8; temp = buffer[7]; result |= temp<<0; } else { temp = buffer[7]; result |= temp<<56; temp = buffer[6]; result |= temp<<48; temp = buffer[5]; result |= temp<<40; temp = buffer[4]; result |= temp<<32; temp = buffer[3]; result |= temp<<24; temp = buffer[2]; result |= temp<<16; temp = buffer[1]; result |= temp<<8; temp = buffer[0]; result |= temp<<0; } return result; } int export_int64(int64_t num, uint8_t *buffer, bool big_endian) { if (big_endian) { buffer[0] = (num>>56); buffer[1] = (num>>48); buffer[2] = (num>>40); buffer[3] = (num>>32); buffer[4] = (num>>24); buffer[5] = (num>>16); buffer[6] = (num>>8); buffer[7] = (num>>0); } else { buffer[7] = (num>>56); buffer[6] = (num>>48); buffer[5] = (num>>40); buffer[4] = (num>>32); buffer[3] = (num>>24); buffer[2] = (num>>16); buffer[1] = (num>>8); buffer[0] = (num>>0); } return 0; } int16_t parse_int16(uint8_t *buffer, bool big_endian) { if (big_endian) return (buffer[1]<<0 | buffer[0]<<8); else return (buffer[0]<<0 | buffer[1]<<8); } int64_t read_int64(PTIFF *tiff_file, int64_t offset, bool big_endian) { uint8_t read_buffer[8]; MPI_File_read_at(tiff_file->fh, offset, read_buffer, sizeof(int64_t), MPI_BYTE, MPI_STATUS_IGNORE); return parse_int64(read_buffer, big_endian); } int write_int64(PTIFF *tiff_file, int64_t offset, int64_t value, bool big_endian) { uint8_t buffer[8]; export_int64(value, buffer, big_endian); MPI_File_write_at(tiff_file->fh, offset, buffer, sizeof(int64_t), MPI_BYTE, MPI_STATUS_IGNORE); return 0; } SPTW_ERROR populate_tile_offsets(PTIFF *tiff_file, int64_t tile_size, bool tiled = true) { MPI_Status status; bool big_endian = false; // Is tiff file big endian? // Read endianess of file uint8_t endian_flag[2] = { 0x49, 0x49 }; MPI_File_read_at(tiff_file->fh, 0, endian_flag, 2, MPI_BYTE, &status); if (endian_flag[0] == 0x4d) { big_endian = true; } // Check tiff version, should be 0x002b for BigTiff uint8_t version_data[2]; int16_t version = 0; MPI_File_read_at(tiff_file->fh, 2, version_data, 2, MPI_BYTE, &status); version = parse_int16(version_data, big_endian); if (version != 0x002b) { // Wrong Tiff version ! return SP_BadArg; } // Read offset to first directory int64_t doffset = 0; doffset = read_int64(tiff_file, 8, big_endian); // Read number of directory entries int64_t entry_count = read_int64(tiff_file, doffset, big_endian); // directory offset + sizeof directory count int64_t entry_offset = doffset + sizeof(int64_t); int64_t tile_count = 0; int64_t tile_size_bytes = tile_size * tiff_file->band_count * tiff_file->band_type_size; if (tiled) { tile_size_bytes *= tile_size; } int64_t first_tile_offset = 0; for (int64_t i = 0; i < entry_count; ++i) { // Read identifying tag of directory entry uint8_t tag_buffer[2]; MPI_File_read_at(tiff_file->fh, entry_offset, tag_buffer, 2, MPI_BYTE, &status); int16_t entry_tag = parse_int16(tag_buffer, big_endian); // Read count of elements in entry int64_t element_count = read_int64(tiff_file, entry_offset+4, big_endian); // Read entry data int64_t entry_data = read_int64(tiff_file, entry_offset+12, big_endian); // Check if directory type is TIFFTAG_TILEOFFSETS if (entry_tag == TIFFTAG_TILEOFFSETS || entry_tag == TIFFTAG_STRIPOFFSETS) { // Read location of first_offset int64_t first_offset = read_int64(tiff_file, entry_data, big_endian); first_tile_offset = first_offset; tile_count = element_count; for (int64_t j = 1; j < element_count; ++j) { write_int64(tiff_file, entry_data+(sizeof(int64_t)*j), first_offset+(tile_size_bytes*j), big_endian); } } else if (entry_tag == TIFFTAG_TILEBYTECOUNTS || entry_tag == TIFFTAG_STRIPBYTECOUNTS) { for (int64_t j = 1; j < element_count; ++j) { write_int64(tiff_file, entry_data+(sizeof(int64_t)*j), tile_size_bytes, big_endian); } } entry_offset += 20; } // Calculate end of file and write to it uint8_t buffer[10]; buffer[0] = 0; int64_t file_size = (tile_count * tile_size_bytes) + first_tile_offset; MPI_File_write_at(tiff_file->fh, file_size-1, buffer, 1, MPI_BYTE, &status); return SP_None; } SPTW_ERROR create_generic_raster(string filename, int64_t x_size, int64_t y_size, int band_count, GDALDataType band_type, double *geotransform, string projection_srs, int block_size_x, bool tiled_mode) { GDALAllRegister(); // Get GeoTiff driver GDALDriver *driver = GetGDALDriverManager()->GetDriverByName("GTiff"); if (driver == NULL) { return SP_CreateError; } // Set driver options char **options = NULL; options = CSLSetNameValue(options, "INTERLEAVE", "PIXEL"); options = CSLSetNameValue(options, "BIGTIFF", "YES"); options = CSLSetNameValue(options, "COMPRESS", "NONE"); options = CSLSetNameValue(options, "SPARSE_OK", "YES"); if (tiled_mode) { std::stringstream ts; ts << block_size_x; options = CSLSetNameValue(options, "TILED", "YES"); options = CSLSetNameValue(options, "BLOCKXSIZE", ts.str().c_str()); options = CSLSetNameValue(options, "BLOCKYSIZE", ts.str().c_str()); } // Create output raster GDALDataset *output = driver->Create(filename.c_str(), x_size, y_size, band_count, band_type, options); if (output == NULL) { fprintf(stderr, "driver->Create call failed.\n"); return SP_CreateError; } // Set GeoTransform output->SetGeoTransform(geotransform); // Set projection OGRSpatialReference out_sr; char *wkt = NULL; out_sr.SetFromUserInput(projection_srs.c_str()); out_sr.exportToWkt(&wkt); output->SetProjection(wkt); // Write first and last pixel in the raster double *data = new double(sizeof(*data) * 4 * output->GetRasterCount()); CPLErr rcode = output->RasterIO(GF_Write, 0, 0, 1, 1, data, 1, 1, output->GetRasterBand(1)->GetRasterDataType(), output->GetRasterCount(), NULL, 0, 0, 0); if(rcode != CE_None) { delete data; // Clean stuff OGRFree(wkt); CSLDestroy(options); GDALClose(output); fprintf(stderr, "Error while writing first pixel in the raster with GDAL\n"); return SP_CreateError; } rcode = output->RasterIO(GF_Write, x_size-1, y_size-1, 1, 1, data, 1, 1, output->GetRasterBand(1)->GetRasterDataType(), output->GetRasterCount(), NULL, 0, 0, 0); if(rcode != CE_None) { delete data; // Clean stuff OGRFree(wkt); CSLDestroy(options); GDALClose(output); fprintf(stderr, "Error while writing last pixel in the raster with GDAL\n"); return SP_CreateError; } delete data; // Clean stuff OGRFree(wkt); CSLDestroy(options); GDALClose(output); return SP_None; } SPTW_ERROR create_raster(string filename, int64_t x_size, int64_t y_size, int band_count, GDALDataType band_type, double *geotransform, string projection_srs) { GDALDriver *gtiff_driver = NULL; GDALDataset *ds = NULL; char **options = NULL; OGRSpatialReference srs; const char *format = "GTiff"; GDALAllRegister(); gtiff_driver = GetGDALDriverManager()->GetDriverByName(format); if (gtiff_driver == NULL) { return SP_CreateError; } options = CSLSetNameValue(options, "BIGTIFF", "YES"); options = CSLSetNameValue(options, "INTERLEAVE", "PIXEL"); options = CSLSetNameValue(options, "COMPRESS", "NONE"); ds = gtiff_driver->Create(filename.c_str(), x_size, y_size, band_count, band_type, options); // Clean up options CSLDestroy(options); CPLErr err = ds->SetProjection(projection_srs.c_str()); if (err != CE_None) { return SP_BadArg; } ds->SetGeoTransform(geotransform); // Close dataset GDALClose((GDALDatasetH) ds); return SP_None; } SPTW_ERROR create_tiled_raster(string filename, int64_t x_size, int64_t y_size, int band_count, GDALDataType band_type, double *geotransform, string projection_srs, int64_t tile_size) { GDALDriver *gtiff_driver = NULL; GDALDataset *ds = NULL; char **options = NULL; GDALAllRegister(); gtiff_driver = GetGDALDriverManager()->GetDriverByName("GTiff"); if (gtiff_driver == NULL) { return SP_CreateError; } std::stringstream ts; ts << tile_size; options = CSLSetNameValue(options, "BIGTIFF", "YES"); options = CSLSetNameValue(options, "INTERLEAVE", "PIXEL"); options = CSLSetNameValue(options, "COMPRESS", "NONE"); options = CSLSetNameValue(options, "TILED", "YES"); options = CSLSetNameValue(options, "BLOCKXSIZE", ts.str().c_str()); options = CSLSetNameValue(options, "BLOCKYSIZE", ts.str().c_str()); ds = gtiff_driver->Create(filename.c_str(), x_size, y_size, band_count, band_type, options); // Clean up options CSLDestroy(options); CPLErr err = ds->SetProjection(projection_srs.c_str()); if (err != CE_None) { return SP_BadArg; } ds->SetGeoTransform(geotransform); // Close dataset GDALClose((GDALDatasetH) ds); return SP_None; } PTIFF* open_raster(string filename) { PTIFF *ptiff = new PTIFF(); char *c_filename = strdup(filename.c_str()); GDALAllRegister(); GDALDataset *ds = static_cast(GDALOpen(filename.c_str(), GA_Update)); if (ds == NULL) { free(c_filename); return NULL; } ptiff->x_size = ds->GetRasterXSize(); ptiff->y_size = ds->GetRasterYSize(); ptiff->band_count = ds->GetRasterCount(); ptiff->band_type = ds->GetRasterBand(1)->GetRasterDataType(); ptiff->band_type_size = GDALGetDataTypeSize(ptiff->band_type)/8; ptiff->first_strip_offset = -1; ptiff->block_x_size = ptiff->x_size; ptiff->block_y_size = ptiff->y_size; GDALClose(ds); TIFF *tiffds = TIFFOpen(c_filename, "r"); free(c_filename); if (tiffds == NULL) { fprintf(stderr, "Couldn't open tiff file\n"); return NULL; } // Attempt to read TileWidth tag. If not found we assume file to have strips // instead. int64_t *offset = NULL; int64_t tiles_per_image = -1; int64_t *tiff_offsets = NULL; int ret = 1; ret &= TIFFGetField(tiffds, TIFFTAG_TILEWIDTH, &(ptiff->block_x_size)); ret &= TIFFGetField(tiffds, TIFFTAG_TILELENGTH, &(ptiff->block_y_size)); ret &= TIFFGetField(tiffds, TIFFTAG_TILEOFFSETS, &offset); if (ret == 1) { /* for tiled tiff */ ptiff->tiles_across = (ptiff->x_size + ptiff->block_x_size - 1) / ptiff->block_x_size; ptiff->tiles_down = (ptiff->y_size + ptiff->block_y_size - 1) / ptiff->block_y_size; tiles_per_image = ptiff->tiles_across * ptiff->tiles_down; ptiff->tile_offsets = new int64_t[tiles_per_image]; if (ptiff->tile_offsets == NULL) { // Allocation Fail! return NULL; } ret = TIFFGetField(tiffds, TIFFTAG_TILEOFFSETS, &tiff_offsets); memcpy(ptiff->tile_offsets, tiff_offsets, sizeof(int64_t) * tiles_per_image); } else if (ret != 1) { /* for striped tiff */ ret = TIFFGetField(tiffds, TIFFTAG_STRIPOFFSETS, &offset); if (ret != 1) { fprintf(stderr, "Error reading strip offsets!\n"); return NULL; } ptiff->first_strip_offset = *offset; ptiff->tiles_across = 1; ptiff->tiles_down = ptiff->y_size; ptiff->block_y_size = 1; // add by Remi for striped images tiles_per_image = ptiff->tiles_across * ptiff->tiles_down; ptiff->tile_offsets = new int64_t[tiles_per_image]; for (int i = 0 ; i < ptiff->y_size ; i++) { ptiff->tile_offsets[i] = offset[0] + i*(ptiff->band_count)*(ptiff->band_type_size)*ptiff->block_x_size; } } ptiff->first_strip_offset = *offset; TIFFClose(tiffds); c_filename = strdup(filename.c_str()); int rc = MPI_File_open(MPI_COMM_WORLD, c_filename, MPI_MODE_RDWR, MPI_INFO_NULL, &(ptiff->fh)); if (rc != MPI_SUCCESS) { char *errstr = static_cast(malloc(5000)); int errlen = 0; MPI_Error_string(rc, errstr, &errlen); fprintf(stderr, "MPI_File: Error opening file: %s: %s\n", c_filename, errstr); free(c_filename); free(errstr); return NULL; } MPI_File_set_atomicity(ptiff->fh, 0); if (c_filename != NULL) { free(c_filename); } return ptiff; } SPTW_ERROR close_raster(PTIFF *ptiff) { MPI_File_close(&(ptiff->fh)); delete ptiff; return SP_None; } SPTW_ERROR fill_stack(std::vector *write_stack, Area old_area, Area written_subset) { const double size_below = old_area.lr.y - written_subset.lr.y; const double size_right = old_area.lr.x - written_subset.lr.x; if (size_right > 0.0) { write_stack->push_back(Area(written_subset.lr.x + 1, old_area.ul.y, old_area.lr.x, old_area.lr.y)); } if (size_below > 0.0) { write_stack->push_back(Area(old_area.ul.x, written_subset.lr.y + 1, written_subset.lr.x, old_area.lr.y)); } return SP_None; } Area calculate_tile_intersection(PTIFF *tiff_file, Area subset) { const double tile_x_beginning = (static_cast(subset.ul.x) / tiff_file->block_x_size) * tiff_file->block_x_size; const double tile_y_beginning = (static_cast(subset.ul.y) / tiff_file->block_y_size) * tiff_file->block_y_size; const double tile_x_end = tile_x_beginning + tiff_file->block_x_size - 1; const double tile_y_end = tile_y_beginning + tiff_file->block_y_size - 1; const double subset_lr_x = std::min(tile_x_end, subset.lr.x); const double subset_lr_y = std::min(tile_y_end, subset.lr.y); return Area(subset.ul.x, subset.ul.y, subset_lr_x, subset_lr_y); } int64_t calculate_file_offset(PTIFF *tiff, const int64_t raster_x, const int64_t raster_y) { const int64_t tile_x = raster_x % tiff->block_x_size; const int64_t tile_y = raster_y % tiff->block_y_size; const int64_t offset_into_tile = (tile_x + (tile_y * tiff->block_x_size)) * tiff->band_type_size * tiff->band_count; const int64_t tile_index = (raster_x / tiff->block_x_size) + (raster_y / tiff->block_y_size) * tiff->tiles_across; const int64_t tiles_per_image = tiff->tiles_across * tiff->tiles_down; if (tile_index > tiles_per_image) { std::cerr << "SPTW: Writing outside of file bounds! Corruption will occur." << std::endl; } return tiff->tile_offsets[tile_index] + offset_into_tile; } SPTW_ERROR write_subset(PTIFF *tiff_file, void *data, int64_t buffer_ul_x, int64_t buffer_ul_y, int64_t buffer_lr_x, int64_t buffer_lr_y, int64_t write_ul_x, int64_t write_ul_y, int64_t write_lr_x, int64_t write_lr_y) { const double tile_x_beginning = (write_ul_x / tiff_file->block_x_size) * tiff_file->block_x_size; const double tile_x_end = tile_x_beginning + tiff_file->block_x_size - 1; int count = 0; MPI_Status status; if (write_ul_x == tile_x_beginning && write_lr_x == tile_x_end) { // Area to be written is same width as tile, write area with single // operation count = ((write_lr_x - write_ul_x + 1) * (write_lr_y - write_ul_y + 1) * tiff_file->band_type_size * tiff_file->band_count); // Size in bytes of a row of the section of buffer being output const int sub_row_size = (write_lr_x - write_ul_x + 1) * tiff_file->band_type_size * tiff_file->band_count; char *buffer = new(std::nothrow) char[count]; for (int y = write_ul_y; y <= write_lr_y; ++y) { int pixel_offset = ((y - buffer_ul_y) * (buffer_lr_x - buffer_ul_x + 1) + (write_ul_x - buffer_ul_x)) * tiff_file->band_type_size * tiff_file->band_count; memcpy(buffer+((y-write_ul_y)*sub_row_size), static_cast(data)+pixel_offset, sub_row_size); } MPI_File_write_at(tiff_file->fh, calculate_file_offset(tiff_file, write_ul_x, write_ul_y), buffer, count, MPI_BYTE, &status); delete[] buffer; } else { // Subset of the buffer must be written row by row count = (write_lr_x - write_ul_x + 1) * tiff_file->band_type_size * tiff_file->band_count; for (int y = write_ul_y; y <= write_lr_y; ++y) { int pixel_offset = ((y - buffer_ul_y) * (buffer_lr_x - buffer_ul_x + 1) + (write_ul_x - buffer_ul_x)) * tiff_file->band_type_size * tiff_file->band_count; MPI_File_write_at(tiff_file->fh, calculate_file_offset(tiff_file, write_ul_x, y), (static_cast(data)) + pixel_offset, count, MPI_BYTE, &status); } } return SP_None; } SPTW_ERROR write_area(PTIFF *ptiff, void *data, int64_t ul_x, int64_t ul_y, int64_t lr_x, int64_t lr_y) { std::vector write_stack; Area write_area; write_area.ul = sptw::Coordinate(ul_x, ul_y, sptw::UNDEF); write_area.lr = sptw::Coordinate(lr_x, lr_y, sptw::UNDEF); write_stack.push_back(write_area); while (!write_stack.empty()) { // Pop area needing write from top of stack Area top = write_stack.back(); write_stack.pop_back(); // Calculate subset of write area that is within the UL tile Area subset = calculate_tile_intersection(ptiff, top); // Fill the stack with any leftover areas fill_stack(&write_stack, top, subset); // Finally write the tile-bound subset write_subset(ptiff, data, ul_x, ul_y, lr_x, lr_y, subset.ul.x, subset.ul.y, subset.lr.x, subset.lr.y); } return SP_None; } } OTB-release-5.8/Modules/ThirdParty/SPTW/src/sptw.h000066400000000000000000000113111301006202600216470ustar00rootroot00000000000000/*! * Copyright 0000 * @file * @author David Matthew Mattli * * @section LICENSE * * This software is in the public domain, furnished "as is", without * technical support, and with no warranty, express or implied, as to * its usefulness for any purpose. * * @section DESCRIPTION * * Header for the Simple Parallel Tiff Writer * */ #ifndef SRC_DEMOS_SPTW_H_ #define SRC_DEMOS_SPTW_H_ #include #include #include #if HAVE_STDINT_H == 0 #include #else #include #endif using std::string; /*! Simple parallel tiff writer namespace * * The functions declared here allow certain tiff files to be written to in * parallel by multiple processors by MPI-IO. * * Sequential consistency is guaranteed if the tiff file being written to is * stored row-wise, uses pixel interleaving and has its strips store * sequentially in the file, and no process writes to the same pixel * values. Files created with the create_raster function or with the * librasterblaster::ProjectedRaster::CreateRaster function should have the * required attributes. * * Two functions are provided to write to tiff files: write_rows and * ::write_subrow . write_rows allows multiple rows to be written at * once. ::write_subrows writes a portion of a row. * */ namespace sptw { /*! * This enum lists the possible errors used by sptw. */ enum SPTW_ERROR { SP_None, /*!< No Error occurred */ SP_CreateError, /*!< Error creating the file */ SP_WriteError, /*!< Error Writing to the file */ SP_BadArg, /*!< A bad argument was provided */ }; /** * @struct PTIFF sptw.h * @brief PTIFF struct represents an open parallel tiff file * * * */ struct PTIFF { /*! MPI-IO file handle. This should be changed with open_raster or * close_raster */ MPI_File fh; /*! Size of the opened raster in the x dimension */ int64_t x_size; /*! Size of the opened raster in the y dimension */ int64_t y_size; /*! Number of bands in the raster */ int band_count; /*! Datatype of the band values */ GDALDataType band_type; /*! Size in bytes of the band_type */ int band_type_size; /*! Byte offset to the first strip of the tiff file */ int64_t first_strip_offset; int64_t *tile_offsets; /*! Width of each tile */ int64_t block_x_size; /* Height of each tile or strip */ int64_t block_y_size; /* Number of tiles across raster */ int64_t tiles_across; /* Number of tiles down raster */ int64_t tiles_down; }; SPTW_ERROR populate_tile_offsets(PTIFF *tiff_file, int64_t tile_size, bool tiled); SPTW_ERROR create_generic_raster(string filename, int64_t x_size, int64_t y_size, int band_count, GDALDataType band_type, double *geotransform, string projection_srs, int block_size_x, bool tiled_mode); SPTW_ERROR create_raster(string filename, int64_t x_size, int64_t y_size, int band_count, GDALDataType band_type, double *geotransform, string projection_srs); SPTW_ERROR create_tiled_raster(string filename, int64_t x_size, int64_t y_size, int band_count, GDALDataType band_type, double *geotransform, string projection_srs, int64_t tile_size); PTIFF* open_raster(string filename); SPTW_ERROR close_raster(PTIFF *ptiff); /** * @brief * This function writes the given buffer to the open PTIFF. The * area to be written is specified by the bounding box, in y-down, * raster coordinates. The bounding box coordinates are inclusive, * the point (lr_x, lr_y) will be written. * * @param ptiff The open PTIFF file to be written to * @param data buffer containing, row-wise, pixel interleaved data to be * written to the file * @param ul_x Upper-left, inclusive, y-down, x coordinate of the area to be * written * @param ul_y Upper-left, inclusive, y-down, y coordinate of the area to be * written * @param lr_x Lower-right, inclusive, y-down, x coordinate of the area to be * written * @param _y Lower-right, inclusive, y-down, y coordinate of the area to be * written * */ SPTW_ERROR write_area(PTIFF *ptiff, void *data, int64_t ul_x, int64_t ul_y, int64_t lr_x, int64_t lr_y); } #endif // SRC_DEMOS_SPTW_H_ OTB-release-5.8/Modules/ThirdParty/SPTW/src/utils.h000066400000000000000000000054331301006202600220220ustar00rootroot00000000000000/** * Copyright 0000 * @file * @author David Matthew Mattli * * @section LICENSE * * This software is in the public domain, furnished "as is", without * technical support, and with no warranty, express or implied, as to * its usefulness for any purpose. * * @section DESCRIPTION * * Helper utilities and definitions * */ #ifndef _UTILS_H_ #define _UTILS_H_ #include namespace sptw { /** An enum of possible return values */ enum PRB_ERROR { PRB_NOERROR, /*!< No error occurred */ PRB_IOERROR, /*!< Error communicating or performing file I/O */ PRB_BADARG, /*!< Bad argument provided */ PRB_PROJERROR, /*!< Error with projection specification */ }; enum ProjUnit { UNDEF = -1, RADIAN = 0, // Radians FEET, // Feet METER, // Meters SECOND, // Seconds DEGREE, // Decimal Degrees INT_FEET // International Feet }; /*! Coordinate struct This class provides a more readable way of storing and passing coordinate parameters for the Transformer class. It stores x and y as doubles and units corresponds to the GCTP enumeration as defined in constants.h */ struct Coordinate { /*! Default Constructor 0's all attributes. */ Coordinate():x(0.0), y(0.0), units(UNDEF) {} /*! Full Constructor Sets all attributes in the Coordinate according to the parameters. */ Coordinate(double xx, double yy, ProjUnit uunits) : x(xx), y(yy), units(uunits) {} /*! Copy Constructor Sets all attributes to equal those in Coordinate c. */ Coordinate(const Coordinate &c): x(c.x), y(c.y), units(c.units) {} double x; double y; ProjUnit units; }; /** * @class */ struct Area { /// A constructor /** * @brief This constructor initializes points to zero. */ Area():ul(), lr(), units(UNDEF) {} /// A constructor /** * @brief This constructor allows both coordinates to be given initial values. * @param ulx Value for the upper-left x * @param uly Value for the upper-left y * @param ulx Value for the lower-right x * @param ulx Value for the lower-right y */ Area(double ulx, double uly, double lrx, double lry) : ul(ulx, uly, UNDEF), lr(lrx, lry, UNDEF), units(UNDEF) {} /// Upper-left coordinate of area Coordinate ul; /// Lower-right coordinate of area Coordinate lr; /// Units used in ul and lr coordinates ProjUnit units; }; } #endif// _UTILS_H_ OTB-release-5.8/Modules/ThirdParty/Shark/000077500000000000000000000000001301006202600201705ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Shark/CMakeLists.txt000066400000000000000000000005741301006202600227360ustar00rootroot00000000000000project(OTBShark) configure_file( src/otb_shark.h.in src/otb_shark.h ) set(OTBShark_SYSTEM_INCLUDE_DIRS ${SHARK_INCLUDE_DIRS}) set(OTBShark_LIBRARIES "${SHARK_LIBRARIES}") set(OTBShark_INCLUDE_DIRS ${OTBShark_BINARY_DIR}/src ) otb_module_impl() install(FILES ${OTBShark_BINARY_DIR}/src/otb_shark.h DESTINATION ${OTBShark_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/ThirdParty/Shark/otb-module-init.cmake000066400000000000000000000000771301006202600242060ustar00rootroot00000000000000find_package ( Shark REQUIRED ) mark_as_advanced( Shark_DIR ) OTB-release-5.8/Modules/ThirdParty/Shark/otb-module.cmake000066400000000000000000000004061301006202600232410ustar00rootroot00000000000000set(DOCUMENTATION "This module imports SHARK to the build system") otb_module(OTBShark DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable SHARK dependent modules" OFF) otb_module_requires_cxx11() OTB-release-5.8/Modules/ThirdParty/Shark/src/000077500000000000000000000000001301006202600207575ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/Shark/src/otb_shark.h.in000077500000000000000000000041541301006202600235200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_shark_h #define otb_shark_h #include "otbConfigure.h" #ifndef OTB_USE_SHARK # error "You need to enable Shark to compile this file" #endif /* These defines are taken from shark CMakeLists.txt. * I am not sure they are required when linking shark which * link with boost. But the fact that they are not optional * in shark puts them here. */ #define BOOST_PARAMETER_MAX_ARITY 15 #define BOOST_FILESYSTEM_VERSION 3 /* without having a compile defintion will give an linker error * when build otbapp_TrainImagesClassifier or this header test. * So define them depending on wheather you have static or shared * build of boost. * * Below is an error message if you don't have define * LINK : fatal error LNK1104: cannot open file 'libboost_serialization-vc140-mt-1_60.lib' * and in the install directory there is no libboost_serialization-vc140-mt-1_60.lib * but only boost_serialization-vc140-mt-1_60.lib and this is the cause of boost's * auto-linking. */ #cmakedefine Boost_USE_STATIC_LIBS #if !defined(Boost_USE_STATIC_LIBS) && !defined(BOOST_ALL_DYN_LINK) #define BOOST_ALL_DYN_LINK #endif /* disable autolinking in boost on windows */ #if defined(_WIN32) && !defined(BOOST_ALL_NO_LIB) #define BOOST_ALL_NO_LIB #endif /* see which libraries are being linked in case of auto-linking, * BOOST_LIB_DIAGNOSTIC will emit a #pragma message each time * a library is selected for linking. * * #if defined(_MSC_VER) && defined(OTB_DEBUG) && !defined(BOOST_LIB_DIAGNOSTIC) * #define BOOST_LIB_DIAGNOSTIC * #endif * */ #endif /* otb_shark_h */ OTB-release-5.8/Modules/ThirdParty/SiftFast/000077500000000000000000000000001301006202600206435ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/SiftFast/CMakeLists.txt000066400000000000000000000002531301006202600234030ustar00rootroot00000000000000project(OTBSiftFast) set(OTBSiftFast_THIRD_PARTY 1) set(OTBSiftFast_INCLUDE_DIRS ${OTBSiftFast_SOURCE_DIR}/src) set(OTBSiftFast_LIBRARIES otbsiftfast) otb_module_impl() OTB-release-5.8/Modules/ThirdParty/SiftFast/otb-module.cmake000066400000000000000000000003601301006202600237130ustar00rootroot00000000000000set(DOCUMENTATION "This module imports SiftFast to the build system") otb_module(OTBSiftFast DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable SiftFast dependent modules" ON) OTB-release-5.8/Modules/ThirdParty/SiftFast/src/000077500000000000000000000000001301006202600214325ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/SiftFast/src/AUTHORS000066400000000000000000000000241301006202600224760ustar00rootroot00000000000000zerofrog(@gmail.com)OTB-release-5.8/Modules/ThirdParty/SiftFast/src/CMakeLists.txt000066400000000000000000000145371301006202600242040ustar00rootroot00000000000000set(OTB3P_INSTALL_EXPORT_NAME "${OTBSiftFast-targets}") set(OTB3P_INSTALL_INCLUDE_DIR "${OTBSiftFast_INSTALL_INCLUDE_DIR}") set(OTB3P_INSTALL_RUNTIME_DIR "${OTBSiftFast_INSTALL_RUNTIME_DIR}") set(OTB3P_INSTALL_LIBRARY_DIR "${OTBSiftFast_INSTALL_LIBRARY_DIR}") set(OTB3P_INSTALL_ARCHIVE_DIR "${OTBSiftFast_INSTALL_ARCHIVE_DIR}") #set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}") include(CheckCXXSourceRuns) if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) # TRY COMPILE libsiftfast.cpp (depend of gcc version) set(IS_SIFTFAST_COMPILE 0) try_compile(IS_SIFTFAST_COMPILE ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/test_try_compile_libsiftfast.cpp OUTPUT_VARIABLE OUTPUT) if(IS_SIFTFAST_COMPILE) message(STATUS "Try to compile libsiftfast.cpp -- yes.") else() message(STATUS "Try to compile libsiftfast.cpp -- no.") try_compile(IS_SIFTFAST_COMPILE2 ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/test_try_compile_libsiftfast.cpp COMPILE_DEFINITIONS -DOTB_DISABLE_FAST_FUNCTIONS OUTPUT_VARIABLE OUTPUT) if(IS_SIFTFAST_COMPILE2) message(STATUS "Try to compile libsiftfast.cpp with disabling fast functions (add CFLAGS -DOTB_DISABLE_FAST_FUNCTIONS) -- yes.") else() message(STATUS "Try to compile libsiftfast.cpp with disabling fast functions (add CFLAGS -DOTB_DISABLE_FAST_FUNCTIONS) -- no.") message(FATAL_ERROR "Impossible to compile libsiftfast. Contact OTB development team") endif() set(OTB_DISABLE_FAST_FUNCTIONS_VALUE 1) else() message(STATUS "Try to compile libsiftfast.cpp done.") endif() set(CMAKE_CXX_FLAGS_RELEASE "-O3 -g") add_definitions(" -Wall -fPIC ") # check for x86-64 system check_cxx_source_runs(" int main() { int a = 0; int*pa = &a; asm(\".intel_syntax\\\\n\" \"mov %%rax, %0\\\\n\" \"mov %%eax, [%%rax]\\\\n\" \".att_syntax\\\\n\" : : \"r\"(pa) : \"%rax\"); return 0; }" IS_X86_64) if( IS_X86_64 ) add_definitions("-D__x86_64__") endif() else() set(IS_X86_64 0) endif() if(OTB_DISABLE_FAST_FUNCTIONS_VALUE) add_definitions(-DOTB_DISABLE_FAST_FUNCTIONS) endif() include(CheckIncludeFile) include(CheckLibraryExists) include(CheckCXXSourceRuns) include(CheckCXXCompilerFlag) # if( UNIX OR CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) # set(STDC_LIBRARY stdc++) # else() # set(STDC_LIBRARY) # endif() # check for SSE extensions if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) set(SSE_FLAGS) set(CMAKE_REQUIRED_FLAGS "-msse2") check_cxx_source_runs(" #include int main() { __m128d a, b; double vals[2] = {0}; a = _mm_loadu_pd(vals); b = _mm_add_pd(a,a); _mm_storeu_pd(vals,b); return 0; }" HAS_SSE2_EXTENSIONS) set(CMAKE_REQUIRED_FLAGS "-msse") check_cxx_source_runs(" #include int main() { __m128 a, b; float vals[4] = {0}; a = _mm_loadu_ps(vals); b = a; b = _mm_add_ps(a,b); _mm_storeu_ps(vals,b); return 0; }" HAS_SSE_EXTENSIONS) set(CMAKE_REQUIRED_FLAGS) if(HAS_SSE2_EXTENSIONS) message(STATUS "Using SSE2 extensions") set(SSE_FLAGS "-msse2 -mfpmath=sse") elseif(HAS_SSE_EXTENSIONS) message(STATUS "Using SSE extensions") set(SSE_FLAGS "-msse -mfpmath=sse") endif() add_definitions(${SSE_FLAGS}) elseif(MSVC) if(CMAKE_SIZEOF_VOID_P EQUAL 8) message(STATUS "Not using SSE2 extensions on x64") else() check_cxx_source_runs(" #include int main() { __m128d a, b; double vals[2] = {0}; a = _mm_loadu_pd(vals); b = _mm_add_pd(a,a); _mm_storeu_pd(vals,b); return 0; }" HAS_SSE2_EXTENSIONS) if( HAS_SSE2_EXTENSIONS ) message(STATUS "Using SSE2 extensions") add_definitions( "/arch:SSE2 /fp:fast -D__SSE__ -D__SSE2__" ) endif() endif() endif() #set(Boost_ADDITIONAL_VERSIONS "1.40" "1.39" "1.38" "1.37.0" "1.37" "1.35.0" "1.34.1" "1.34.0" "1.34" "1.33.1" "1.33.0" "1.33") #if( NOT $ENV{BOOST_INCLUDEDIR} STREQUAL "" ) # set(Boost_INCLUDE_DIR $ENV{BOOST_INCLUDEDIR}) #endif() #if( NOT $ENV{BOOST_LIBRARYDIR} STREQUAL "" ) # set(Boost_LIBRARY_DIRS $ENV{BOOST_LIBRARYDIR}) #endif() #find_package(Boost COMPONENTS python) #if( Boost_FOUND ) # message(STATUS "found boost version: ${Boost_VERSION}") #else() # message(STATUS "Could not find boost libraries!") #endif() add_library(otbsiftfast libsiftfast.cpp) if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) # target_link_libraries(otbsiftfast m stdc++) target_link_libraries(otbsiftfast m) endif() #set_target_properties(otbsiftfast PROPERTIES OUTPUT_NAME siftfast CLEAN_DIRECT_OUTPUT 1) # compile without depending on libsiftfast include_directories(${CMAKE_CURRENT_SOURCE_DIR}) #set_target_properties(siftfast PROPERTIES COMPILE_FLAGS "-DDVPROFILE") #target_link_libraries(siftfast libsiftfast) # check for OpenMP find_package(OpenMP) if(OPENMP_FOUND) message(STATUS "Enabling OpenMP support") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}") else() message(STATUS "Disabling OpenMP support") endif() #Install TARGET & FILES for otb-lib if(OTB_LIBRARY_PROPERTIES) set_target_properties(otbsiftfast PROPERTIES ${OTB_LIBRARY_PROPERTIES}) endif() install(TARGETS otbsiftfast EXPORT ${OTB3P_INSTALL_EXPORT_NAME} RUNTIME DESTINATION ${OTB3P_INSTALL_RUNTIME_DIR} COMPONENT RuntimeLibraries LIBRARY DESTINATION ${OTB3P_INSTALL_LIBRARY_DIR} COMPONENT RuntimeLibraries ARCHIVE DESTINATION ${OTB3P_INSTALL_ARCHIVE_DIR} COMPONENT Development ) install(FILES siftfast.h DESTINATION ${OTB3P_INSTALL_INCLUDE_DIR}/otbsiftfast COMPONENT Development ) install(FILES otb_siftfast.h DESTINATION ${OTB3P_INSTALL_INCLUDE_DIR} COMPONENT Development ) otb_module_target( otbsiftfast NO_INSTALL )OTB-release-5.8/Modules/ThirdParty/SiftFast/src/FindBoost.cmake000066400000000000000000000660441301006202600243350ustar00rootroot00000000000000# - Try to find Boost include dirs and libraries # Usage of this module as follows: # # set(Boost_USE_STATIC_LIBS ON) # set(Boost_USE_MULTITHREAD OFF) # find_package( Boost 1.34.1 COMPONENTS date_time filesystem iostreams ... ) # # The Boost_ADDITIONAL_VERSIONS variable can be used to specify a list of # boost version numbers that should be taken into account when searching # for the libraries. Unfortunately boost puts the version number into the # actual filename for the libraries, so this might be needed in the future # when new Boost versions are released. # # Currently this module searches for the following version numbers: # 1.33, 1.33.0, 1.33.1, 1.34, 1.34.0, 1.34.1, 1.35, 1.35.0, 1.35.1, 1.36, # 1.36.0, 1.36.1 # # The components list needs to be the actual names of boost libraries, that is # the part of the actual library files that differ on different libraries. So # its "date_time" for "libboost_date_time...". Anything else will result in # errors # # You can provide a minimum version number that should be used. If you provide this # version number and specify the REQUIRED attribute, this module will fail if it # can't find the specified or a later version. If you specify a version number this is # automatically put into the considered list of version numbers and thus doesn't need # to be specified in the Boost_ADDITIONAL_VERSIONS variable # # Variables used by this module, they can change the default behaviour and need to be set # before calling find_package: # Boost_USE_MULTITHREAD Can be set to OFF to use the non-multithreaded # boost libraries. Defaults to ON. # Boost_USE_STATIC_LIBS Can be set to ON to force the use of the static # boost libraries. Defaults to OFF. # Boost_ADDITIONAL_VERSIONS A list of version numbers to use for searching # the boost include directory. The default list # of version numbers is: # 1.33, 1.33.0, 1.33.1, 1.34, 1.34.0, 1.34.1, # 1.35, 1.35.0, 1.35.1, 1.36, 1.36.0, 1.36.1 # If you want to look for an older or newer # version set this variable to a list of # strings, where each string contains a number, i.e. # set(Boost_ADDITIONAL_VERSIONS "0.99.0" "1.35.0") # BOOST_ROOT or BOOSTROOT Preferred installation prefix for searching for Boost, # set this if the module has problems finding the proper Boost installation # BOOST_INCLUDEDIR Set this to the include directory of Boost, if the # module has problems finding the proper Boost installation # BOOST_LIBRARYDIR Set this to the lib directory of Boost, if the # module has problems finding the proper Boost installation # # The last three variables are available also as environment variables # # # Variables defined by this module: # # Boost_FOUND System has Boost, this means the include dir was found, # as well as all the libraries specified in the COMPONENTS list # Boost_INCLUDE_DIRS Boost include directories, not cached # Boost_INCLUDE_DIR This is almost the same as above, but this one is cached and may be # modified by advanced users # Boost_LIBRARIES Link these to use the Boost libraries that you specified, not cached # Boost_LIBRARY_DIRS The path to where the Boost library files are. # Boost_VERSION The version number of the boost libraries that have been found, # same as in version.hpp from Boost # Boost_LIB_VERSION The version number in filename form as its appended to the library filenames # Boost_MAJOR_VERSION major version number of boost # Boost_MINOR_VERSION minor version number of boost # Boost_SUBMINOR_VERSION subminor version number of boost # Boost_LIB_DIAGNOSTIC_DEFINITIONS Only set on windows. Can be used with add_definitions # to print diagnostic information about the automatic # linking done on windows. # For each component you list the following variables are set. # ATTENTION: The component names need to be in lower case, just as the boost # library names however the cmake variables use upper case for the component # part. So you'd get Boost_SERIALIZATION_FOUND for example. # # Boost_${COMPONENT}_FOUND True IF the Boost library "component" was found. # Boost_${COMPONENT}_LIBRARY The absolute path of the Boost library "component". # Boost_${COMPONENT}_LIBRARY_DEBUG The absolute path of the debug version of the # Boost library "component". # Boost_${COMPONENT}_LIBRARY_RELEASE The absolute path of the release version of the # Boost library "component" # # Copyright (c) 2006-2008 Andreas Schneider # Copyright (c) 2007 Wengo # Copyright (c) 2007 Mike Jackson # Copyright (c) 2008 Andreas Pakulat # # Redistribution AND use is allowed according to the terms of the New # BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. # option(Boost_USE_MULTITHREADED "Use the multithreaded versions of the Boost libraries" ON) if (Boost_FIND_VERSION_EXACT) if (Boost_FIND_VERSION_PATCH) set( _boost_TEST_VERSIONS "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.${Boost_FIND_VERSION_PATCH}") else () set( _boost_TEST_VERSIONS "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.0" "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}") endif () else () set( _boost_TEST_VERSIONS ${Boost_ADDITIONAL_VERSIONS} "1.49.0" "1.49" "1.48.0" "1.48" "1.47.0" "1.47" "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42" "1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37" "1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0" "1.34" "1.33.1" "1.33.0" "1.33" ) endif () # The reason that we failed to find Boost. This will be set to a # user-friendly message when we fail to find some necessary piece of # Boost. set(Boost_ERROR_REASON) ############################################ # # Check the existence of the libraries. # ############################################ # This macro was taken directly from the FindQt4.cmake file that is included # with the CMake distribution. This is NOT my work. All work was done by the # original authors of the FindQt4.cmake file. Only minor modifications were # made to remove references to Qt and make this file more generally applicable ######################################################################### macro(_Boost_ADJUST_LIB_VARS basename) if(Boost_INCLUDE_DIR ) if(Boost_${basename}_LIBRARY_DEBUG AND Boost_${basename}_LIBRARY_RELEASE) # if the generator supports configuration types then set # optimized and debug libraries, or if the CMAKE_BUILD_TYPE has a value if(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE) set(Boost_${basename}_LIBRARY optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG}) else() # if there are no configuration types and CMAKE_BUILD_TYPE has no value # then just use the release libraries set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE} ) endif() set(Boost_${basename}_LIBRARIES optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG}) endif() # if only the release version was found, set the debug variable also to the release version if(Boost_${basename}_LIBRARY_RELEASE AND NOT Boost_${basename}_LIBRARY_DEBUG) set(Boost_${basename}_LIBRARY_DEBUG ${Boost_${basename}_LIBRARY_RELEASE}) set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE}) set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_RELEASE}) endif() # if only the debug version was found, set the release variable also to the debug version if(Boost_${basename}_LIBRARY_DEBUG AND NOT Boost_${basename}_LIBRARY_RELEASE) set(Boost_${basename}_LIBRARY_RELEASE ${Boost_${basename}_LIBRARY_DEBUG}) set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_DEBUG}) set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_DEBUG}) endif() if(Boost_${basename}_LIBRARY) set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY} CACHE FILEPATH "The Boost ${basename} library") get_filename_component(Boost_LIBRARY_DIRS "${Boost_${basename}_LIBRARY}" PATH) set(Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIRS} CACHE FILEPATH "Boost library directory") set(Boost_${basename}_FOUND ON CACHE INTERNAL "Whether the Boost ${basename} library found") endif() endif() # Make variables changeble to the advanced user mark_as_advanced( Boost_${basename}_LIBRARY Boost_${basename}_LIBRARY_RELEASE Boost_${basename}_LIBRARY_DEBUG ) endmacro() #------------------------------------------------------------------------------- set( _boost_IN_CACHE TRUE) if(Boost_INCLUDE_DIR) foreach(COMPONENT ${Boost_FIND_COMPONENTS}) string(TOUPPER ${COMPONENT} COMPONENT) if(NOT Boost_${COMPONENT}_FOUND) set( _boost_IN_CACHE FALSE) endif() endforeach() else() set( _boost_IN_CACHE FALSE) endif() if(_boost_IN_CACHE) # in cache already set(Boost_FOUND TRUE) foreach(COMPONENT ${Boost_FIND_COMPONENTS}) string(TOUPPER ${COMPONENT} COMPONENT) _Boost_ADJUST_LIB_VARS( ${COMPONENT} ) set(Boost_LIBRARIES ${Boost_LIBRARIES} ${Boost_${COMPONENT}_LIBRARY}) endforeach() set(Boost_INCLUDE_DIRS ${Boost_INCLUDE_DIR}) if(Boost_VERSION AND NOT "${Boost_VERSION}" STREQUAL "0") math(EXPR Boost_MAJOR_VERSION "${Boost_VERSION} / 100000") math(EXPR Boost_MINOR_VERSION "${Boost_VERSION} / 100 % 1000") math(EXPR Boost_SUBMINOR_VERSION "${Boost_VERSION} % 100") endif() else() # Need to search for boost if(WIN32) # In windows, automatic linking is performed, so you do not have # to specify the libraries. If you are linking to a dynamic # runtime, then you can choose to link to either a static or a # dynamic Boost library, the default is to do a static link. You # can alter this for a specific library "whatever" by defining # BOOST_WHATEVER_DYN_LINK to force Boost library "whatever" to be # linked dynamically. Alternatively you can force all Boost # libraries to dynamic link by defining BOOST_ALL_DYN_LINK. # This feature can be disabled for Boost library "whatever" by # defining BOOST_WHATEVER_NO_LIB, or for all of Boost by defining # BOOST_ALL_NO_LIB. # If you want to observe which libraries are being linked against # then defining BOOST_LIB_DIAGNOSTIC will cause the auto-linking # code to emit a #pragma message each time a library is selected # for linking. set(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC" CACHE STRING "Boost diagnostic define") endif() set(_boost_INCLUDE_SEARCH_DIRS C:/boost/include "C:/boost" "$ENV{ProgramFiles}/boost/boost_${Boost_FIND_VERSION_MAJOR}_${Boost_FIND_VERSION_MINOR}_${Boost_FIND_VERSION_PATCH}" "$ENV{ProgramFiles}/Boost" /sw/local/include ) set(_boost_LIBRARIES_SEARCH_DIRS C:/boost/lib "C:/boost" "$ENV{ProgramFiles}/boost/boost_${Boost_FIND_VERSION_MAJOR}_${Boost_FIND_VERSION_MINOR}_${Boost_FIND_VERSION_PATCH}/lib" "$ENV{ProgramFiles}/Boost" /sw/local/lib ) # If BOOST_ROOT was defined in the environment, use it. if (NOT BOOST_ROOT AND NOT $ENV{BOOST_ROOT} STREQUAL "") set(BOOST_ROOT $ENV{BOOST_ROOT}) endif() # If BOOSTROOT was defined in the environment, use it. if (NOT BOOST_ROOT AND NOT $ENV{BOOSTROOT} STREQUAL "") set(BOOST_ROOT $ENV{BOOSTROOT}) endif() # If BOOST_INCLUDEDIR was defined in the environment, use it. if( NOT $ENV{BOOST_INCLUDEDIR} STREQUAL "" ) set(BOOST_INCLUDEDIR $ENV{BOOST_INCLUDEDIR}) endif() # If BOOST_LIBRARYDIR was defined in the environment, use it. if( NOT $ENV{BOOST_LIBRARYDIR} STREQUAL "" ) set(BOOST_LIBRARYDIR $ENV{BOOST_LIBRARYDIR}) endif() if( BOOST_ROOT ) file(TO_CMAKE_PATH ${BOOST_ROOT} BOOST_ROOT) set(_boost_INCLUDE_SEARCH_DIRS ${BOOST_ROOT}/include ${BOOST_ROOT} ${_boost_INCLUDE_SEARCH_DIRS}) set(_boost_LIBRARIES_SEARCH_DIRS ${BOOST_ROOT}/lib ${BOOST_ROOT}/stage/lib ${_boost_LIBRARIES_SEARCH_DIRS}) endif() if( BOOST_INCLUDEDIR ) file(TO_CMAKE_PATH ${BOOST_INCLUDEDIR} BOOST_INCLUDEDIR) set(_boost_INCLUDE_SEARCH_DIRS ${BOOST_INCLUDEDIR} ${_boost_INCLUDE_SEARCH_DIRS}) endif() if( BOOST_LIBRARYDIR ) file(TO_CMAKE_PATH ${BOOST_LIBRARYDIR} BOOST_LIBRARYDIR) set(_boost_LIBRARIES_SEARCH_DIRS ${BOOST_LIBRARYDIR} ${_boost_LIBRARIES_SEARCH_DIRS}) endif() # Try to find Boost by stepping backwards through the Boost versions # we know about. if( NOT Boost_INCLUDE_DIR ) # Build a list of path suffixes for each version. set(_boost_PATH_SUFFIXES) foreach(_boost_VER ${_boost_TEST_VERSIONS}) # Add in a path suffix, based on the required version, ideally # we could read this from version.hpp, but for that to work we'd # need to know the include dir already if (WIN32 AND NOT CYGWIN) set(_boost_PATH_SUFFIX boost_${_boost_VER}) else () set(_boost_PATH_SUFFIX boost-${_boost_VER}) endif () if(_boost_PATH_SUFFIX MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1_\\2_\\3" _boost_PATH_SUFFIX ${_boost_PATH_SUFFIX}) elseif(_boost_PATH_SUFFIX MATCHES "[0-9]+\\.[0-9]+") string(REGEX REPLACE "([0-9]+)\\.([0-9]+)" "\\1_\\2" _boost_PATH_SUFFIX ${_boost_PATH_SUFFIX}) endif() list(APPEND _boost_PATH_SUFFIXES "${_boost_PATH_SUFFIX}") endforeach() # Look for a standard boost header file. find_path(Boost_INCLUDE_DIR NAMES boost/config.hpp HINTS ${_boost_INCLUDE_SEARCH_DIRS} PATH_SUFFIXES ${_boost_PATH_SUFFIXES} ) endif() if(Boost_INCLUDE_DIR) # Extract Boost_VERSION and Boost_LIB_VERSION from version.hpp # Read the whole file: # set(BOOST_VERSION 0) set(BOOST_LIB_VERSION "") file(READ "${Boost_INCLUDE_DIR}/boost/version.hpp" _boost_VERSION_HPP_CONTENTS) string(REGEX REPLACE ".*#define BOOST_VERSION ([0-9]+).*" "\\1" Boost_VERSION "${_boost_VERSION_HPP_CONTENTS}") string(REGEX REPLACE ".*#define BOOST_LIB_VERSION \"([0-9_]+)\".*" "\\1" Boost_LIB_VERSION "${_boost_VERSION_HPP_CONTENTS}") set(Boost_LIB_VERSION ${Boost_LIB_VERSION} CACHE INTERNAL "The library version string for boost libraries") set(Boost_VERSION ${Boost_VERSION} CACHE INTERNAL "The version number for boost libraries") if(NOT "${Boost_VERSION}" STREQUAL "0") math(EXPR Boost_MAJOR_VERSION "${Boost_VERSION} / 100000") math(EXPR Boost_MINOR_VERSION "${Boost_VERSION} / 100 % 1000") math(EXPR Boost_SUBMINOR_VERSION "${Boost_VERSION} % 100") set(Boost_ERROR_REASON "${Boost_ERROR_REASON}Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}\nBoost include path: ${Boost_INCLUDE_DIR}") endif() else() set(Boost_ERROR_REASON "${Boost_ERROR_REASON}Unable to find the Boost header files. Please set BOOST_ROOT to the root directory containing Boost or BOOST_INCLUDEDIR to the directory containing Boost's headers.") endif() # Setting some more suffixes for the library set(Boost_LIB_PREFIX "") if( WIN32 AND Boost_USE_STATIC_LIBS ) set(Boost_LIB_PREFIX "lib") endif() set(_boost_COMPILER "-gcc") if(MSVC90) set(_boost_COMPILER "-vc90") elseif(MSVC80) set(_boost_COMPILER "-vc80") elseif(MSVC71) set(_boost_COMPILER "-vc71") endif() if(MINGW) exec_program(${CMAKE_CXX_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE _boost_COMPILER_VERSION ) string(REGEX REPLACE "([0-9])\\.([0-9])\\.[0-9]" "\\1\\2" _boost_COMPILER_VERSION ${_boost_COMPILER_VERSION}) set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION}") endif() if(UNIX) if(NOT CMAKE_COMPILER_IS_GNUCC) # We assume that we have the Intel compiler. set(_boost_COMPILER "-il") else() # Determine which version of GCC we have. exec_program(${CMAKE_CXX_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE _boost_COMPILER_VERSION ) string(REGEX REPLACE "([0-9])\\.([0-9])\\.[0-9]" "\\1\\2" _boost_COMPILER_VERSION ${_boost_COMPILER_VERSION}) if(APPLE) if(Boost_MINOR_VERSION) if(${Boost_MINOR_VERSION} GREATER 35) # In Boost 1.36.0 and newer, the mangled compiler name used # on Mac OS X/Darwin is "xgcc". set(_boost_COMPILER "-xgcc${_boost_COMPILER_VERSION}") else() # In Boost <= 1.35.0, there is no mangled compiler name for # the Mac OS X/Darwin version of GCC. set(_boost_COMPILER "") endif() else() # We don't know the Boost version, so assume it's # pre-1.36.0. set(_boost_COMPILER "") endif() else() set(_boost_COMPILER "-gcc${_boost_COMPILER_VERSION}") endif() endif() endif() set(_boost_MULTITHREADED "-mt") if( NOT Boost_USE_MULTITHREADED ) set(_boost_MULTITHREADED "") endif() set( _boost_STATIC_TAG "") if(WIN32) if(MSVC) set(_boost_ABI_TAG "g") endif() if( Boost_USE_STATIC_LIBS ) set( _boost_STATIC_TAG "-s") endif() endif() set(_boost_ABI_TAG "${_boost_ABI_TAG}d") # ------------------------------------------------------------------------ # Begin finding boost libraries # ------------------------------------------------------------------------ foreach(COMPONENT ${Boost_FIND_COMPONENTS}) string(TOUPPER ${COMPONENT} UPPERCOMPONENT) set( Boost_${UPPERCOMPONENT}_LIBRARY "Boost_${UPPERCOMPONENT}_LIBRARY-NOTFOUND" ) set( Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE "Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE-NOTFOUND" ) set( Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG "Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG-NOTFOUND") # Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES if( Boost_USE_STATIC_LIBS ) set( _boost_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) if(WIN32) set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) else() set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) endif() endif() find_library(Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE NAMES ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_COMPILER}${_boost_MULTITHREADED}-${Boost_LIB_VERSION} ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_COMPILER}${_boost_MULTITHREADED}${_boost_STATIC_TAG}-${Boost_LIB_VERSION} ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_MULTITHREADED} ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_MULTITHREADED}${_boost_STATIC_TAG} ${Boost_LIB_PREFIX}boost_${COMPONENT} HINTS ${_boost_LIBRARIES_SEARCH_DIRS} PATHS ${_boost_LIBRARIES_SEARCH_DIRS} ) find_library(Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG NAMES ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_COMPILER}${_boost_MULTITHREADED}-${_boost_ABI_TAG}-${Boost_LIB_VERSION} ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_COMPILER}${_boost_MULTITHREADED}${_boost_STATIC_TAG}${_boost_ABI_TAG}-${Boost_LIB_VERSION} ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_MULTITHREADED}-${_boost_ABI_TAG} ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_MULTITHREADED}${_boost_STATIC_TAG}${_boost_ABI_TAG} ${Boost_LIB_PREFIX}boost_${COMPONENT}-${_boost_ABI_TAG} HINTS ${_boost_LIBRARIES_SEARCH_DIRS} ) _Boost_ADJUST_LIB_VARS(${UPPERCOMPONENT}) if( Boost_USE_STATIC_LIBS ) set(CMAKE_FIND_LIBRARY_SUFFIXES ${_boost_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) endif() endforeach() # ------------------------------------------------------------------------ # End finding boost libraries # ------------------------------------------------------------------------ set(Boost_INCLUDE_DIRS ${Boost_INCLUDE_DIR} ) set(Boost_FOUND FALSE) if(Boost_INCLUDE_DIR) set( Boost_FOUND TRUE ) # Check the version of Boost against the requested version. if (Boost_FIND_VERSION AND NOT Boost_FIND_VERSION_MINOR) message(SEND_ERROR "When requesting a specific version of Boost, you must provide at least the major and minor version numbers, e.g., 1.34") endif () if(Boost_MAJOR_VERSION LESS "${Boost_FIND_VERSION_MAJOR}" ) set( Boost_FOUND FALSE ) set(_Boost_VERSION_AGE "old") elseif(Boost_MAJOR_VERSION EQUAL "${Boost_FIND_VERSION_MAJOR}" ) if(Boost_MINOR_VERSION LESS "${Boost_FIND_VERSION_MINOR}" ) set( Boost_FOUND FALSE ) set(_Boost_VERSION_AGE "old") elseif(Boost_MINOR_VERSION EQUAL "${Boost_FIND_VERSION_MINOR}" ) if( Boost_FIND_VERSION_PATCH AND Boost_SUBMINOR_VERSION LESS "${Boost_FIND_VERSION_PATCH}" ) set( Boost_FOUND FALSE ) set(_Boost_VERSION_AGE "old") endif() endif() endif() if (Boost_FOUND AND Boost_FIND_VERSION_EXACT) # If the user requested an exact version of Boost, check # that. We already know that the Boost version we have is >= the # requested version. set(_Boost_VERSION_AGE "new") # If the user didn't specify a patchlevel, it's 0. if (NOT Boost_FIND_VERSION_PATCH) set(Boost_FIND_VERSION_PATCH 0) endif () # We'll set Boost_FOUND true again if we have an exact version match. set(Boost_FOUND FALSE) if(Boost_MAJOR_VERSION EQUAL "${Boost_FIND_VERSION_MAJOR}" ) if(Boost_MINOR_VERSION EQUAL "${Boost_FIND_VERSION_MINOR}" ) if(Boost_SUBMINOR_VERSION EQUAL "${Boost_FIND_VERSION_PATCH}" ) set( Boost_FOUND TRUE ) endif() endif() endif() endif () if(NOT Boost_FOUND) # State that we found a version of Boost that is too new or too old. set(Boost_ERROR_REASON "${Boost_ERROR_REASON}\nDetected version of Boost is too ${_Boost_VERSION_AGE}. Requested version was ${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}") if (Boost_FIND_VERSION_PATCH) set(Boost_ERROR_REASON "${Boost_ERROR_REASON}.${Boost_FIND_VERSION_PATCH}") endif () if (NOT Boost_FIND_VERSION_EXACT) set(Boost_ERROR_REASON "${Boost_ERROR_REASON} (or newer)") endif () set(Boost_ERROR_REASON "${Boost_ERROR_REASON}.") endif () if (Boost_FOUND) set(_boost_CHECKED_COMPONENT FALSE) set(_Boost_MISSING_COMPONENTS) foreach(COMPONENT ${Boost_FIND_COMPONENTS}) string(TOUPPER ${COMPONENT} COMPONENT) set(_boost_CHECKED_COMPONENT TRUE) if(NOT Boost_${COMPONENT}_FOUND) string(TOLOWER ${COMPONENT} COMPONENT) list(APPEND _Boost_MISSING_COMPONENTS ${COMPONENT}) set( Boost_FOUND FALSE) endif() endforeach() endif () if (_Boost_MISSING_COMPONENTS) # We were unable to find some libraries, so generate a sensible # error message that lists the libraries we were unable to find. set(Boost_ERROR_REASON "${Boost_ERROR_REASON}\nThe following Boost libraries could not be found:\n") foreach(COMPONENT ${_Boost_MISSING_COMPONENTS}) set(Boost_ERROR_REASON "${Boost_ERROR_REASON} boost_${COMPONENT}\n") endforeach() list(LENGTH Boost_FIND_COMPONENTS Boost_NUM_COMPONENTS_WANTED) list(LENGTH _Boost_MISSING_COMPONENTS Boost_NUM_MISSING_COMPONENTS) if (${Boost_NUM_COMPONENTS_WANTED} EQUAL ${Boost_NUM_MISSING_COMPONENTS}) set(Boost_ERROR_REASON "${Boost_ERROR_REASON}No Boost libraries were found. You may need to set Boost_LIBRARYDIR to the directory containing Boost libraries or BOOST_ROOT to the location of Boost.") else () set(Boost_ERROR_REASON "${Boost_ERROR_REASON}Some (but not all) of the required Boost libraries were found. You may need to install these additional Boost libraries. Alternatively, set Boost_LIBRARYDIR to the directory containing Boost libraries or BOOST_ROOT to the location of Boost.") endif () endif () if( NOT Boost_LIBRARY_DIRS AND NOT _boost_CHECKED_COMPONENT ) # Compatibility Code for backwards compatibility with CMake # 2.4's FindBoost module. # Look for the boost library path. # Note that the user may not have installed any libraries # so it is quite possible the Boost_LIBRARY_PATH may not exist. set(_boost_LIB_DIR ${Boost_INCLUDE_DIR}) if("${_boost_LIB_DIR}" MATCHES "boost-[0-9]+") get_filename_component(_boost_LIB_DIR ${_boost_LIB_DIR} PATH) endif() if("${_boost_LIB_DIR}" MATCHES "/include$") # Strip off the trailing "/include" in the path. get_filename_component(_boost_LIB_DIR ${_boost_LIB_DIR} PATH) endif() if(EXISTS "${_boost_LIB_DIR}/lib") set(_boost_LIB_DIR ${_boost_LIB_DIR}/lib) else() if(EXISTS "${_boost_LIB_DIR}/stage/lib") set(_boost_LIB_DIR ${_boost_LIB_DIR}/stage/lib) else() set(_boost_LIB_DIR "") endif() endif() if(_boost_LIB_DIR AND EXISTS "${_boost_LIB_DIR}") set(Boost_LIBRARY_DIRS ${_boost_LIB_DIR} CACHE FILEPATH "Boost library directory") endif() endif() else() set( Boost_FOUND FALSE) endif() if(Boost_FOUND) if(NOT Boost_FIND_QUIETLY) message(STATUS "Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}") endif() if(NOT Boost_FIND_QUIETLY) message(STATUS "Found the following Boost libraries:") endif() foreach( COMPONENT ${Boost_FIND_COMPONENTS} ) string( TOUPPER ${COMPONENT} UPPERCOMPONENT ) if( Boost_${UPPERCOMPONENT}_FOUND ) if(NOT Boost_FIND_QUIETLY) message(STATUS " ${COMPONENT}") endif() set(Boost_LIBRARIES ${Boost_LIBRARIES} ${Boost_${UPPERCOMPONENT}_LIBRARY}) endif() endforeach() else() if(Boost_FIND_REQUIRED) message(SEND_ERROR "Unable to find the requested Boost libraries.\n${Boost_ERROR_REASON}") endif() endif() # Under Windows, automatic linking is performed, so no need to specify the libraries. if(WIN32) if(NOT MINGW) set(Boost_LIBRARIES "") endif() endif() # show the Boost_INCLUDE_DIRS AND Boost_LIBRARIES variables only in the advanced view mark_as_advanced(Boost_INCLUDE_DIR Boost_INCLUDE_DIRS Boost_LIBRARY_DIRS Boost_USE_MULTITHREADED ) endif() OTB-release-5.8/Modules/ThirdParty/SiftFast/src/FindOctave.cmake000066400000000000000000000063021301006202600244570ustar00rootroot00000000000000# Try to find the build flags to compile octave shared objects (oct and mex files) # Once done this will define # # OCTAVE_FOUND - if Coin3d is found # OCTAVE_CXXFLAGS - extra flags # OCTAVE_INCLUDE_DIRS - include directories # OCTAVE_LINK_DIRS - link directories # OCTAVE_LIBRARY_RELEASE - the relase version # OCTAVE_LIBRARY_DEBUG - the debug version # OCTAVE_LIBRARY - a default library, with priority debug. # use mkoctfile set(MKOCTFILE_EXECUTABLE MKOCTFILE_EXECUTABLE-NOTFOUND) find_program(MKOCTFILE_EXECUTABLE NAME mkoctfile PATHS) mark_as_advanced(MKOCTFILE_EXECUTABLE) if(MKOCTFILE_EXECUTABLE) set(OCTAVE_FOUND 1) execute_process( COMMAND ${MKOCTFILE_EXECUTABLE} -p ALL_CXXFLAGS OUTPUT_VARIABLE _mkoctfile_cppflags RESULT_VARIABLE _mkoctfile_failed) string(REGEX REPLACE "[\r\n]" " " _mkoctfile_cppflags "${_mkoctfile_cppflags}") execute_process( COMMAND ${MKOCTFILE_EXECUTABLE} -p INCFLAGS OUTPUT_VARIABLE _mkoctfile_includedir RESULT_VARIABLE _mkoctfile_failed) string(REGEX REPLACE "[\r\n]" " " _mkoctfile_includedir "${_mkoctfile_includedir}") execute_process( COMMAND ${MKOCTFILE_EXECUTABLE} -p ALL_LDFLAGS OUTPUT_VARIABLE _mkoctfile_ldflags RESULT_VARIABLE _mkoctfile_failed) string(REGEX REPLACE "[\r\n]" " " _mkoctfile_ldflags "${_mkoctfile_ldflags}") execute_process( COMMAND ${MKOCTFILE_EXECUTABLE} -p LFLAGS OUTPUT_VARIABLE _mkoctfile_lflags RESULT_VARIABLE _mkoctfile_failed) string(REGEX REPLACE "[\r\n]" " " _mkoctfile_lflags "${_mkoctfile_lflags}") execute_process( COMMAND ${MKOCTFILE_EXECUTABLE} -p LIBS OUTPUT_VARIABLE _mkoctfile_libs RESULT_VARIABLE _mkoctfile_failed) string(REGEX REPLACE "[\r\n]" " " _mkoctfile_libs "${_mkoctfile_libs}") execute_process( COMMAND ${MKOCTFILE_EXECUTABLE} -p OCTAVE_LIBS OUTPUT_VARIABLE _mkoctfile_octlibs RESULT_VARIABLE _mkoctfile_failed) string(REGEX REPLACE "[\r\n]" " " _mkoctfile_octlibs "${_mkoctfile_octlibs}") set(_mkoctfile_libs "${_mkoctfile_libs} ${_mkoctfile_octlibs}") string(REGEX MATCHALL "(^| )-l([./+-_\\a-zA-Z]*)" _mkoctfile_libs "${_mkoctfile_libs}") string(REGEX REPLACE "(^| )-l" "" _mkoctfile_libs "${_mkoctfile_libs}") string(REGEX MATCHALL "(^| )-L([./+-_\\a-zA-Z]*)" _mkoctfile_ldirs "${_mkoctfile_lflags}") string(REGEX REPLACE "(^| )-L" "" _mkoctfile_ldirs "${_mkoctfile_ldirs}") string(REGEX REPLACE "(^| )-l([./+-_\\a-zA-Z]*)" " " _mkoctfile_ldflags "${_mkoctfile_ldflags}") string(REGEX REPLACE "(^| )-L([./+-_\\a-zA-Z]*)" " " _mkoctfile_ldflags "${_mkoctfile_ldflags}") string(REGEX REPLACE "(^| )-I" " " _mkoctfile_includedir "${_mkoctfile_includedir}") separate_arguments(_mkoctfile_includedir) set( OCTAVE_CXXFLAGS "${_mkoctfile_cppflags}" ) set( OCTAVE_LINK_FLAGS "${_mkoctfile_ldflags}" ) set( OCTAVE_INCLUDE_DIRS ${_mkoctfile_includedir}) set( OCTAVE_LINK_DIRS ${_mkoctfile_ldirs}) set( OCTAVE_LIBRARY ${_mkoctfile_libs}) set( OCTAVE_LIBRARY_RELEASE ${OCTAVE_LIBRARY}) set( OCTAVE_LIBRARY_DEBUG ${OCTAVE_LIBRARY}) endif() mark_as_advanced( OCTAVE_LIBRARY_FOUND OCTAVE_CXXFLAGS OCTAVE_LINK_FLAGS OCTAVE_INCLUDE_DIRS OCTAVE_LINK_DIRS OCTAVE_LIBRARY OCTAVE_LIBRARY_RELEASE OCTAVE_LIBRARY_DEBUG ) OTB-release-5.8/Modules/ThirdParty/SiftFast/src/INSTALL000066400000000000000000000037611301006202600224720ustar00rootroot00000000000000libsiftfast: author zerofrog(@gmail.com) ---------------------------------------- The compilation system uses a cross-platform tool called cmake. Linux/Mac OSX Instructions: --------------------------- Just type > make This will set the project to be installed in /usr/local. To change the install directory type > make prefix=/my/new/dir To change other environment variables that cmake uses after initially making, type "cmake build" OpenMP: cmake will use OpenMP if it exists in your system. Note that OpenMP is available only on gcc versions >= 4.2. CMake checks this automatically, but you can force usage or disabling of it by adding "-DUSE_OPENMP=OFF" when manually running cmake. Use ON to force enabling. Sometimes siftfast might fail to compile with OpenMP because libgomp.so is not setup properly to be used by shared objects. Checkout this tutorial here on how to compile the correct libgomp: http://openrave.programmingvision.com/index.php?title=Misc:MatlabOpenMP Basically the problem is that the default libgomp might be compiled with nodlopen flag refusing it to be dynamically loaded. The only way around this is to compile your own libgomp library and make sure libsiftfast is linking to it. Matlab: Read this if you are interested in using siftfast.m for matlab on Linux. When compiling a matlab mex file, you might get a message saying the gcc version is too high. If so, matlab will have a hard time locating the correct libstdc++.so file. In this case, go into /usr/local/share/sys/os/glnx86 and make libgcc_s and libstdc++ point to the /usr/lib versions sudo mv libgcc_s.so.1 libgcc_s.so.1.back sudo ln -s /lib/libgcc_s.so.1 libgcc_s.so.1 sudo rm libstdc++.so.6 (this was already a symbolic link) sudo ln -s /usr/lib/libstdc++.so.6.0.9 libstdc++.so.6 Windows Instructions: --------------------- Download cmake (http://www.cmake.org/), make sure to install it in the PATH. Then run runcmake.bat, that should generate visual studio files in the build folder. Open libsiftfast.sln and compile. OTB-release-5.8/Modules/ThirdParty/SiftFast/src/LICENSE000066400000000000000000000164551301006202600224520ustar00rootroot00000000000000GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, “this License” refers to version 3 of the GNU Lesser General Public License, and the “GNU GPL” refers to version 3 of the GNU General Public License. “The Library” refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An “Application” is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A “Combined Work” is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the “Linked Version”. The “Minimal Corresponding Source” for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The “Corresponding Application Code” for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: * a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or * b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: * a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. * b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: * a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. * b) Accompany the Combined Work with a copy of the GNU GPL and this license document. * c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. * d) Do one of the following: o 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. o 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. * e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: * a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. * b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License “or any later version” applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. OTB-release-5.8/Modules/ThirdParty/SiftFast/src/Makefile-upstream000066400000000000000000000007041301006202600247310ustar00rootroot00000000000000all: @mkdir -p build @if [ $(prefix) ]; then \ cd build && cmake -DCMAKE_INSTALL_PREFIX=$(prefix) -DCMAKE_BUILD_TYPE=Release ..; \ else \ cd build && cmake -DCMAKE_VERBOSE_MAKEFILE=OFF -DCMAKE_BUILD_TYPE=Release ..; \ fi cd build && make install: cd build && make install uninstall: cd build && make uninstall test: all cd build && make test test-future: all cd build && make test-future clean: -cd build && make clean rm -rf build OTB-release-5.8/Modules/ThirdParty/SiftFast/src/README000066400000000000000000000040741301006202600223170ustar00rootroot00000000000000libsiftfast: author zerofrog(@gmail.com) ---------------------------------------- Various utilities to compute the SIFT features of a greyscale image. Packages offered: *libsiftfast.so - main library that contains the sift code *siftfast - really fast SIFT implementation using SSE and OpenMP (also fixes some bugs from lowe's code, so outputs are similar, but not exact). The usage is very similar to David Lowe's sift program. To input a greyscale image test.pgm and get the SIFT keys test.key use > siftfast < test.pgm > test.key The format of test.key is pretty self explanatory: #keys #key_dimension (for #keys) [x y scale orientation (for #key_dimension)[value] ] *siftfast.m - matlab/octave mex file that uses sift_fast, just do [frames,descr]=sift_mex(grayscale_image); frames is a 4xN matrix of [X,Y,scale,orientation], descr is a 128xN matrix of normalized descriptors To use the mex files, libsift_fast.so, Octave/Matlab need to be able to load it. A way to do it is to add its path to your LD_LIBRARY_PATH in your ~/.bashrc file, or in matlab with: setenv('LD_LIBRARY_PATH',[getenv('LD_LIBRARY_PATH') ':' libsift_directory]); SIFT is based on David G. Lowe, "Distinctive image features from scale-invariant keypoints, "International Journal of Computer Vision, 60, 2 (2004), pp. 91-110. Using the Octave/Matlab mex files --------------------------------- the octave and matlab mex files are installed in $prefix/share/siftfast/octave and $prefix/share/siftfast/matlab where $prefix is the installation directory you've provided (via CMAKE_INSTALL_PREFIX). The default value for $prefix is /usr/local Add the path via addpath('$prefix/share/siftfast/matlab'), and then in octave/matlab type: > help siftfast this should give a help file on how to use it. Comparisons with other SIFT Code -------------------------------- The default setting of siftfast produce the same output as Lowe's free sift program. On a quad-core Core2Duo machine with OpenMP, siftfast goes about 6x faster than lowe's sift program for 640x480 images. OTB-release-5.8/Modules/ThirdParty/SiftFast/src/cmake_uninstall.cmake.in000066400000000000000000000014251301006202600262140ustar00rootroot00000000000000if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"") endif() file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) string(REGEX REPLACE "\n" ";" files "${files}") foreach(file ${files}) message(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"") if(EXISTS "$ENV{DESTDIR}${file}") exec_program( "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" OUTPUT_VARIABLE rm_out RETURN_VALUE rm_retval ) if(NOT "${rm_retval}" STREQUAL 0) message(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"") endif() else() message(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.") endif() endforeach() OTB-release-5.8/Modules/ThirdParty/SiftFast/src/libsiftfast.cpp000066400000000000000000001677531301006202600244730ustar00rootroot00000000000000// exact C++ implementation of lowe's sift program // Copyright (C) zerofrog(@gmail.com), 2008-2009 // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // at your option) any later version. // //This program is distributed in the hope that it will be useful, //but WITHOUT ANY WARRANTY; without even the implied warranty of //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //Lesser GNU General Public License for more details. // //You should have received a copy of the GNU Lesser General Public License //along with this program. If not, see . // This source code was carefully calibrated to match David Lowe's SIFT features program #include #include #include #include #include #include #include #include #include #include #include #include // ftime(), struct timeb #ifndef _MSC_VER #include #else #define WIN32_LEAN_AND_MEAN #include #endif #if defined(__SSE3__) #include #elif defined(__SSE2__) #include #elif defined(__SSE__) #include #else #ifndef _MSC_VER #warning "Not compiling with SSE extenions" #endif #endif #ifdef _OPENMP #include #else #ifndef _MSC_VER #warning "OpenMP not enabled. Use -fopenmp (>=gcc-4.2) or -openmp (icc) for speed enhancements on SMP machines." #endif #endif //using namespace std; #include #define PI 3.141592654f #define SQRT2 1.4142136f // if defined, will profile the critical functions and write results to prof.txt //#define DVPROFILE // if defined will align all image rows to 16 bytes // usually aligning is faster (can save ~100ms), however for 1024x768 // cache misses with the enlarged rows make it ~400-500ms slower //#define ALIGNED_IMAGE_ROWS #ifdef ALIGNED_IMAGE_ROWS #define _MM_LOAD_ALIGNED _mm_load_ps #define _MM_STORE_ALIGNED _mm_store_ps #else #define _MM_LOAD_ALIGNED _mm_loadu_ps #define _MM_STORE_ALIGNED _mm_storeu_ps #endif #ifdef DVPROFILE #include "profiler.h" #else #define DVSTARTPROFILE() #endif typedef struct ImageSt { int rows, cols; // Dimensions of image. float *pixels; // 2D array of image pixels. int stride; // how many floats until the next row // (used to add padding to make rows aligned to 16 bytes) } *Image; // Data structure for a keypoint. Lists of keypoints are linked by the "next" field. typedef struct KeypointSt { float row, col; // Subpixel location of keypoint. float scale, ori; // Scale and orientation (range [-PI,PI]) float descrip[128]; // Vector of descriptor values struct KeypointSt *next; // Pointer to next keypoint in list. } *Keypoint; int DoubleImSize = 1; int Scales = 3; float InitSigma = 1.6f; float PeakThresh; static std::list s_listKeypoints; typedef unsigned short u16; typedef unsigned int u32; typedef unsigned long long u64; #if defined(__SSE__) && !defined(SIMDMATH_H) #ifdef _MSC_VER typedef __m128 vec_int4; typedef __m128 vec_float4; #else // need an implementation of atan2 in SSE typedef int vec_int4 __attribute__ ((vector_size (16))); typedef float vec_float4 __attribute__ ((vector_size (16))); #endif inline vec_float4 atanf4( vec_float4 x ); inline vec_float4 atan2f4( vec_float4 y, vec_float4 x ); #endif inline u64 GetMicroTime() { #ifdef _MSC_VER LARGE_INTEGER count, freq; QueryPerformanceCounter(&count); QueryPerformanceFrequency(&freq); return (count.QuadPart * 1000000) / freq.QuadPart; #else struct timeval t; gettimeofday(&t, NULL); return (u64)t.tv_sec*1000000+t.tv_usec; #endif } // aligned malloc and free inline void* sift_aligned_malloc(size_t size, size_t align) { assert( align < 0x10000 ); char* p = (char*)malloc(size+align); int off = 2+align - ((int)(size_t)(p+2) % align); p += off; *(u16*)(p-2) = off; return p; } void sift_aligned_free(void* pmem) { if( pmem != NULL ) { char* p = (char*)pmem; free(p - (int)*(u16*)(p-2)); } } #if defined(_MSC_VER) #define SIFT_ALIGNED16(x) __declspec(align(16)) x #else #define SIFT_ALIGNED16(x) x __attribute((aligned(16))) #endif extern "C" { Image CreateImage(int rows, int cols); Image CreateImageFromMatlabData(double* pdata, int rows, int cols); void DestroyAllImages(); Keypoint GetKeypoints(Image porgimage, unsigned int nbScales); Image SiftDoubleSize(Image p); Image SiftCopyImage(Image p); Image HalfImageSize(Image curimage); Keypoint OctaveKeypoints(Image pimage, Image* phalfimage, float fscale, Keypoint prevkeypts, unsigned int nbScales); void SubtractImage(Image imgdst, Image img0, Image img1); void GaussianBlur(Image imgdst, Image image, float fblur); void ConvHorizontal(Image imgdst, Image image, float* kernel, int ksize); void ConvHorizontalFast(Image imgdst, Image image, float* kernel, int ksize); void ConvVertical(Image image, float* kernel, int ksize); void ConvVerticalFast(Image image, float* kernel, int ksize); void ConvBuffer(float* buf, float* kernel, int cols, int ksize); Keypoint FindMaxMin(Image* imdiff, Image* imgaus, float fscale, Keypoint prevkeypts,unsigned int nbScales); void GradOriImages(Image imgaus, Image imgrad, Image imorient); void GradOriImagesFast(Image imgaus, Image imgrad, Image imorient); int LocalMaxMin(float fval, Image imdiff, int row, int col); int NotOnEdge(Image imdiff, int row, int col); Keypoint InterpKeyPoint(Image* imdiff, int index, int rowstart, int colstart, Image imgrad, Image imorient, char* pMaxMinArray, float fscale,Keypoint keypts, int steps, unsigned int nbScales); float FitQuadratic(float* X, Image* imdiff, int index, int rowstart, int colstart); void SolveLinearSystem(float* Y, float* H, int dim); Keypoint AssignOriHist(Image imgrad, Image imorient, float fscale, float fSize, float frowstart, float fcolstart, Keypoint keypts); float InterpPeak(float f0, float f1, float f2); void SmoothHistogram(float* phist, int numbins); Keypoint MakeKeypoint(Image imgrad, Image imorient, float fscale, float fSize, float frowstart,float fcolstart,float forient, Keypoint keypts); void MakeKeypointSample(Keypoint pnewkeypt, Image imgrad, Image imorient, float fSize, float frowstart, float fcolstart); void NormalizeVec(float* pf, int num); void KeySample(float* fdesc, Keypoint pnewkeypt, Image imgrad, Image imorient, float fSize, float frowstart, float fcolstart); void AddSample(float* fdesc, Keypoint pkeypt, Image imgrad, Image imorient, int r, int c, float rpos, float cpos, float rx, float cx); void PlaceInIndex(float* fdesc, float fgrad, float forient, float fnewrow, float fnewcol); void FreeKeypoints(Keypoint keypt); void DestroyAllResources(); } static std::list s_listImages; Image CreateImage(int rows, int cols) { Image im; im = (Image) sift_aligned_malloc(sizeof(struct ImageSt),16); im->rows = rows; im->cols = cols; // cannot make 16 byte aligned since 1024x768 images #if defined(ALIGNED_IMAGE_ROWS) && defined(__SSE__) im->stride = (cols+3)&~3; #else im->stride = cols; #endif im->pixels = (float*)sift_aligned_malloc(rows*im->stride*sizeof(float)+16,128); // add padding (for sse) s_listImages.push_back(im); return im; } void DestroyAllImages() { for(std::list::iterator it = s_listImages.begin(); it != s_listImages.end(); ++it) { sift_aligned_free((*it)->pixels); sift_aligned_free(*it); } s_listImages.clear(); } Image CreateImageFromMatlabData(double* pdata, int rows, int cols) { Image image = CreateImage(rows,cols); float* pixels = image->pixels; int stride = image->stride; #ifdef __SSE2__ for(int i = 0; i < (rows&~1); i += 2, pixels+=2*stride) { for(int j = 0; j < (cols&~3); j += 4) { double* pf = &pdata[i+j*rows]; #ifdef ALIGNED_IMAGE_ROWS __m128d m0 = _mm_load_pd(pf); __m128d m1 = _mm_load_pd(pf+rows); __m128d m2 = _mm_load_pd(pf+2*rows); __m128d m3 = _mm_load_pd(pf+3*rows); #else __m128d m0 = _mm_loadu_pd(pf); __m128d m1 = _mm_loadu_pd(pf+rows); __m128d m2 = _mm_loadu_pd(pf+2*rows); __m128d m3 = _mm_loadu_pd(pf+3*rows); #endif __m128 mrows0 = _mm_shuffle_ps(_mm_cvtpd_ps(m0),_mm_cvtpd_ps(m1),0x44); __m128 mrows1 = _mm_shuffle_ps(_mm_cvtpd_ps(m2),_mm_cvtpd_ps(m3),0x44); _mm_storeu_ps(pixels+j,_mm_shuffle_ps(mrows0,mrows1,0x88)); _mm_storeu_ps(pixels+j+stride,_mm_shuffle_ps(mrows0,mrows1,0xdd)); } for(int j = (cols&~3); j < cols; j++) { pixels[j] = (float) pdata[i+j*rows]; pixels[j+stride] = (float) pdata[i+j*rows+1]; } } if( rows & 1 ) { for(int j = 0; j < cols; ++j) pixels[j] = (float)pdata[rows-1+j*rows]; } #else for(int i = 0; i < rows; ++i, pixels+=stride) { for(int j = 0; j < cols; ++j) pixels[j] = (float)pdata[i+j*rows]; } #endif return image; } static Image* s_imgaus = NULL, *s_imdiff = NULL; static Image s_imgrad = NULL, s_imorient = NULL; static char* s_MaxMinArray = NULL; Keypoint GetKeypoints(Image porgimage, unsigned int nbScales) { #ifdef DVPROFILE DVProfClear(); #endif Image pimage = NULL; float fscale = 1.0f; Image halfimage = NULL; Keypoint keypts = 0; { DVSTARTPROFILE(); PeakThresh = 0.04f/(float)nbScales; s_imgaus = new Image[((27 + 4*nbScales)&0xfffffff0)/4]; s_imdiff = new Image[((23 + 4*nbScales)&0xfffffff0)/4]; if( DoubleImSize ) { pimage = SiftDoubleSize(porgimage); fscale = 0.5f; } else pimage = SiftCopyImage(porgimage); float fnewscale = 1.0f; if( !DoubleImSize ) fnewscale = 0.5f; if( InitSigma > fnewscale ) { GaussianBlur(pimage, pimage, sqrtf(InitSigma*InitSigma - fnewscale*fnewscale)); // { // FILE* f = fopen("test.txt","w"); // int rows = pimage->rows, cols = pimage->cols, stride = pimage->stride; // float *_pdst = pimage->pixels; // for(int j = 0; j < rows; ++j, _pdst += stride ) { // for(int k = 0; k < cols; ++k) { // fprintf(f,"%f ",_pdst[k]); // } // fprintf(f,"\n"); // } // fclose(f); // } } // create the images s_imgaus[0] = pimage; for(int i = 1; i < (int)nbScales+3; ++i) s_imgaus[i] = CreateImage(pimage->rows,pimage->cols); for(int i = 0; i < (int)nbScales+2; ++i) s_imdiff[i] = CreateImage(pimage->rows,pimage->cols); s_imgrad = CreateImage(pimage->rows,pimage->cols); s_imorient = CreateImage(pimage->rows,pimage->cols); s_MaxMinArray = (char*)sift_aligned_malloc(pimage->rows*pimage->cols,16); while( pimage->rows > 12 && pimage->cols > 12 ) { keypts = OctaveKeypoints(pimage, &halfimage, fscale, keypts,nbScales); pimage = HalfImageSize(halfimage); fscale += fscale; } delete[] s_imgaus; delete[] s_imdiff; sift_aligned_free(s_MaxMinArray); } #ifdef DVPROFILE DVProfWrite("prof.txt"); #endif return keypts; } Image SiftDoubleSize(Image im) { int rows = im->rows, cols = im->cols; int newrows = 2*rows-2, newcols = 2*cols-2; Image newim = CreateImage(newrows, newcols); float* psrc = im->pixels, *pdst = newim->pixels; int stride = im->stride, newstride = newim->stride; for(int i = 0; i < rows-1; ++i, psrc += stride, pdst += 2*newstride) { for(int j = 0; j < cols-1; ++j) { pdst[2*j] = psrc[j]; pdst[newstride+2*j] = 0.5f*(psrc[j] + psrc[stride+j]); pdst[2*j+1] = 0.5f*(psrc[j] + psrc[j+1]); pdst[newstride+2*j+1] = 0.25f*(psrc[j] + psrc[j+1] + psrc[stride+j] + psrc[stride+j+1]); } } return newim; } Image SiftCopyImage(Image im) { DVSTARTPROFILE(); Image newim = CreateImage(im->rows,im->cols); memcpy(newim->pixels, im->pixels, sizeof(float)*im->rows*im->stride); return newim; } Image HalfImageSize(Image curimage) { int cols = curimage->cols; int newrows = (curimage->rows+(curimage->rows<0))>>1; int newcols = (cols+(curimage->cols<0))>>1; Image halfimage = CreateImage(newrows, newcols); float* psrc = curimage->pixels, *pdst = halfimage->pixels; int stride = curimage->stride, newstride = halfimage->stride; for(int halfrow = 0; halfrow < newrows; ++halfrow, pdst += newstride, psrc += 2*stride ) { for(int halfcol = 0; halfcol < newcols; ++halfcol) { pdst[halfcol] = psrc[halfcol*2]; } } return halfimage; } Keypoint OctaveKeypoints(Image pimage, Image* phalfimage, float fscale, Keypoint prevkeypts,unsigned int nbScales) { DVSTARTPROFILE(); float fwidth = powf(2.0f,1.0f / (float)nbScales); float fincsigma = sqrtf(fwidth * fwidth - 1.0f); int rows = pimage->rows, cols = pimage->cols, stride = pimage->stride; s_imgaus[0] = pimage; float sigma = InitSigma; for(int i = 1; i < (int)nbScales+3; ++i) { s_imgaus[i]->rows = rows; s_imgaus[i]->cols = cols; s_imgaus[i]->stride = stride; GaussianBlur(s_imgaus[i], s_imgaus[i-1], fincsigma * sigma); s_imdiff[i-1]->rows = rows; s_imdiff[i-1]->cols = cols; s_imdiff[i-1]->stride = stride; SubtractImage(s_imdiff[i-1],s_imgaus[i-1],s_imgaus[i]); sigma *= fwidth; } s_imgrad->rows = rows; s_imgrad->cols = cols; s_imgrad->stride = stride; s_imorient->rows = rows; s_imorient->cols = cols; s_imorient->stride = stride; *phalfimage = s_imgaus[nbScales]; return FindMaxMin(s_imdiff, s_imgaus, fscale, prevkeypts,nbScales); } // imgdst = img0 - img1 void SubtractImage(Image imgdst, Image img0, Image img1) { int rows = imgdst->rows, cols = imgdst->cols, stride = imgdst->stride; float* _pixels0 = img0->pixels, *_pixels1 = img1->pixels, *_pdst = imgdst->pixels; #ifdef __SSE__ #pragma omp parallel for schedule(dynamic,32) for(int j = 0; j < rows; ++j ) { float* pixels0 = _pixels0+j*stride; float* pixels1 = _pixels1+j*stride; float* pdst = _pdst + j*stride; for(int k = 0; k < (cols&~7); k += 8) { _MM_STORE_ALIGNED(pdst+k,_mm_sub_ps(_MM_LOAD_ALIGNED(pixels0+k), _MM_LOAD_ALIGNED(pixels1+k))); _MM_STORE_ALIGNED(pdst+k+4,_mm_sub_ps(_MM_LOAD_ALIGNED(pixels0+k+4), _MM_LOAD_ALIGNED(pixels1+k+4))); } for(int k = (cols&~7); k < cols; ++k) pdst[k] = pixels0[k]-pixels1[k]; } #else for(int j = 0; j < rows; ++j, _pixels0 += stride, _pixels1 += stride, _pdst += stride ) { for(int k = 0; k < cols; ++k) { _pdst[k] = _pixels0[k]-_pixels1[k]; } } #endif } static std::map s_mapkernel; // assumes GaussTruncate doesn't change!, if freeing second, subtract 4 bytes void GaussianBlur(Image imgdst, Image image, float fblur) { DVSTARTPROFILE(); const float GaussTruncate = 4.0f; int ksize = (int)(2.0f * GaussTruncate * fblur + 1.0f); if( ksize < 3 ) ksize = 3; ksize += !(ksize&1); // make it odd float* kernel = NULL; for( std::map::iterator it = s_mapkernel.begin(); it != s_mapkernel.end(); ++it) { if( fabsf(fblur-it->first) < 0.001f ) { kernel = it->second; break; } } if( kernel == NULL ) { // have to create a new one double faccum = 0; // +4 for alignment and padding issues with sse kernel = (float*)sift_aligned_malloc((ksize+9)*sizeof(float),16)+1; int width = (ksize >= 0 ? ksize : ksize-1)>>1; for(int i = 0; i <= ksize; ++i) { float fweight = expf( - (float)(i-width)*(i-width) / (2.0f*fblur*fblur) ); faccum += (double)fweight; kernel[i] = fweight; } for(int i = 0; i < ksize; ++i) // shouldn't it be <=? kernel[i] /= (float)faccum; memset(kernel+ksize,0,sizeof(float)*8); s_mapkernel[fblur] = kernel; } #ifdef __SSE__ if( image->cols < 12 ) ConvHorizontal(imgdst, image,kernel,ksize); else ConvHorizontalFast(imgdst, image,kernel,ksize); ConvVerticalFast(imgdst,kernel,ksize); #else ConvHorizontal(imgdst, image,kernel,ksize); ConvVertical(imgdst,kernel,ksize); #endif } void ConvHorizontal(Image imgdst, Image image, float* kernel, int ksize) { DVSTARTPROFILE(); static std::vector _buf; //TODO, make 16 byte aligned _buf.resize(image->cols + ksize); float* buf = &_buf[0]; int rows = image->rows, cols = image->cols, stride = image->stride; int width = (ksize >= 0 ? ksize : ksize-1)>>1; float* pixels = image->pixels; float* pdst = imgdst->pixels; for(int i = 0; i < rows; ++i, pixels += stride, pdst += stride) { for(int j = 0; j < width; ++j) buf[j] = pixels[0]; for(int j = 0; j < cols; ++j) buf[width+j] = pixels[j]; for(int j = 0; j < width; ++j) buf[cols+width+j] = pixels[cols-1]; ConvBuffer(buf,kernel,cols,ksize); memcpy(pdst,buf,sizeof(float)*cols); } } void ConvVertical(Image image, float* kernel, int ksize) { DVSTARTPROFILE(); static std::vector _buf; //TODO, make 16 byte aligned _buf.resize(image->rows + ksize); float* buf = &_buf[0]; int rows = image->rows, cols = image->cols, stride = image->stride; int width = (ksize >= 0 ? ksize : ksize-1)>>1; float* pixels = image->pixels; for(int j = 0; j < cols; ++j, pixels += 1) { for(int i = 0; i < width; ++i) buf[i] = pixels[0]; for(int i = 0; i < rows; ++i) buf[width+i] = pixels[i*stride]; for(int i = 0; i < width; ++i) buf[rows+width+i] = pixels[(rows-1)*stride]; ConvBuffer(buf,kernel,rows,ksize); for(int i = 0; i < rows; ++i) pixels[i*stride] = buf[i]; } } void ConvBuffer(float* buf, float* kernel, int bufsize, int ksize) { for(int i = 0; i < bufsize; ++i) { float faccum = 0; for(int j = 0; j < ksize; ++j) faccum += buf[i+j]*kernel[j]; buf[i] = (float)faccum; } } #ifdef __SSE__ typedef std::vector LISTBUF; static LISTBUF s_listconvbuf; //TODO, make 16 byte aligned static int s_convbufsize = 0; // the size of all the buffers in s_listconvbuf static int SIFT_ALIGNED16(s_convmask[4]) = {static_cast(0xffffffff),static_cast(0xffffffff),static_cast(0xffffffff),0}; struct myaccum { float SIFT_ALIGNED16(faccum[2][4]); }; void ConvHorizontalFast(Image imgdst, Image image, float* kernel, int ksize) { int rows = image->rows, cols = image->cols, stride = image->stride; assert( ksize >= 3 && cols >= 3 ); // 3 is cutting it close #ifdef ALIGNED_IMAGE_ROWS assert( !(image->stride&3) ); #endif DVSTARTPROFILE(); int width = (ksize >= 0 ? ksize : ksize-1)>>1; float* _pixels = image->pixels, *_pdst = imgdst->pixels; int convsize = (std::max)(100000,4*(cols + ksize)+36); if( s_listconvbuf.size() == 0 || s_convbufsize < convsize ) { for(LISTBUF::iterator it = s_listconvbuf.begin(); it != s_listconvbuf.end(); ++it) sift_aligned_free(*it); s_listconvbuf.clear(); // create at least one s_listconvbuf.push_back((float*)sift_aligned_malloc(convsize,16)); s_convbufsize = convsize; } #ifdef _OPENMP else { for(LISTBUF::iterator it = s_listconvbuf.begin(); it != s_listconvbuf.end(); ++it) memset(*it+cols+ksize+1,0,32); } #endif #ifdef _OPENMP for(int i = s_listconvbuf.size(); i < omp_get_max_threads(); ++i) { s_listconvbuf.push_back((float*)sift_aligned_malloc(convsize,16)); memset(s_listconvbuf.back()+cols+ksize+1,0,32); } #else float* pconvbuf = s_listconvbuf.back(); memset(pconvbuf+cols+ksize+1,0,32); #endif #pragma omp parallel for schedule(dynamic,16) for(int i = 0; i < rows; i++) { #ifdef _OPENMP float* pconvbuf; // need to get a free buffer #pragma omp critical { if( s_listconvbuf.size() == 0 ) { // for some reason, crashes if this is ever executed.... pconvbuf = (float*)sift_aligned_malloc(convsize,16); memset(pconvbuf+cols+ksize+1,0,32); } else { pconvbuf = s_listconvbuf.back(); s_listconvbuf.pop_back(); } } #endif // get 16 byte aligned array myaccum ac; float* pixels = _pixels+i*stride; float* pdst = _pdst + i*stride; float* buf = pconvbuf+1; float f0 = pixels[0], f0e = pixels[cols-1]; for(int j = 0; j < width; ++j) buf[j] = f0; memcpy(buf+width,pixels,cols*sizeof(float)); for(int j = 0; j < width; ++j) buf[cols+width+j] = f0e; __m128 mkerbase = _mm_and_ps(_mm_loadu_ps(kernel), _mm_load_ps((float*)s_convmask)); for(int j = 0; j < 2*(cols>>2); ++j) { int off = 2*j-(j&1); buf = pconvbuf+1+off; __m128 maccum0 = _mm_mul_ps(_mm_loadu_ps(buf), mkerbase); __m128 maccum1 = _mm_mul_ps(_mm_loadu_ps(buf+2), mkerbase); __m128 mbufprev = _mm_loadu_ps(buf+3); for(int k = 3; k < ksize; k += 8) { __m128 mbuf0 = mbufprev; __m128 mker0 = _mm_load_ps(kernel+k); __m128 mbuf1 = _mm_loadu_ps(buf+k+4); __m128 mker1 = _mm_load_ps(kernel+k+4); // accumulate the first row maccum0 = _mm_add_ps(maccum0,_mm_mul_ps(mbuf0,mker0)); maccum0 = _mm_add_ps(maccum0,_mm_mul_ps(mbuf1,mker1)); mbufprev = _mm_loadu_ps(buf+k+8); // load new mbuf0 = _mm_shuffle_ps(mbufprev,mbuf0,0xe4); // remove first 2 elts // arrange kernel to match mbuf0 and mbuf1 for second row __m128 mkertemp = mker0; mker0 = _mm_shuffle_ps(mker1,mker0,0x4e); mker1 = _mm_shuffle_ps(mkertemp,mker1,0x4e); // accumulate the second row maccum1 = _mm_add_ps(maccum1,_mm_mul_ps(mbuf0,mker0)); maccum1 = _mm_add_ps(maccum1,_mm_mul_ps(mbuf1,mker1)); } #ifdef __SSE3__ maccum0 = _mm_hadd_ps(maccum0,maccum1); maccum0 = _mm_hadd_ps(maccum0,maccum0); _mm_storel_pi((__m64*)ac.faccum[0],maccum0); pdst[off] = ac.faccum[0][0]; pdst[off+2] = ac.faccum[0][1]; #else _mm_store_ps(ac.faccum[0],maccum0); _mm_store_ps(ac.faccum[1],maccum1); pdst[off] = ac.faccum[0][0]+ac.faccum[0][1]+ac.faccum[0][2]+ac.faccum[0][3]; pdst[off+2] = ac.faccum[1][0]+ac.faccum[1][1]+ac.faccum[1][2]+ac.faccum[1][3]; #endif } // take care of the left over columns for(int j=(cols&~3); j < cols; ++j) { buf = pconvbuf+j+1; __m128 maccum0 = _mm_mul_ps(_mm_loadu_ps(buf), mkerbase); for(int k = 3; k < ksize; k += 4) { __m128 mbuf0 = _mm_loadu_ps(buf+k); __m128 mker0 = _mm_load_ps(kernel+k); maccum0 = _mm_add_ps(maccum0,_mm_mul_ps(mbuf0,mker0)); } #ifdef __SSE3__ maccum0 = _mm_hadd_ps(maccum0,maccum0); maccum0 = _mm_hadd_ps(maccum0,maccum0); _mm_store_ss(&pdst[j],maccum0); #else _mm_store_ps(ac.faccum[0],maccum0); pdst[j] = ac.faccum[0][0]+ac.faccum[0][1]+ac.faccum[0][2]+ac.faccum[0][3]; #endif } #ifdef _OPENMP #pragma omp critical { s_listconvbuf.push_back(pconvbuf); } #endif } } void ConvVerticalFast(Image image, float* kernel, int ksize) { int rows = image->rows, stride = image->stride; assert( ksize >= 3); // 3 is cutting it close #ifdef ALIGNED_IMAGE_ROWS assert( !(image->stride&3) ); #endif DVSTARTPROFILE(); int convsize = (std::max)(100000,32*(image->rows + ksize+4)); if( s_listconvbuf.size() == 0 || s_convbufsize < convsize ) { for(LISTBUF::iterator it = s_listconvbuf.begin(); it != s_listconvbuf.end(); ++it) sift_aligned_free(*it); s_listconvbuf.clear(); // create at least one s_listconvbuf.push_back((float*)sift_aligned_malloc(convsize,16)); s_convbufsize = convsize; } #ifdef _OPENMP for(int i = s_listconvbuf.size(); i < omp_get_max_threads(); ++i) { s_listconvbuf.push_back((float*)sift_aligned_malloc(convsize,16)); } #else float* pconvbuf = s_listconvbuf.back(); #endif int width = (ksize >= 0 ? ksize : ksize-1)>>1; float* _pixels = image->pixels; #pragma omp parallel for for(int j = 0; j < stride; j += 4) { float* pixels = _pixels+j; #ifndef ALIGNED_IMAGE_ROWS myaccum ac; #endif #ifdef _OPENMP float* pconvbuf; // need to get a free buffer #pragma omp critical { if( s_listconvbuf.size() == 0 ) { pconvbuf = (float*)sift_aligned_malloc(convsize,16); } else { pconvbuf = s_listconvbuf.back(); s_listconvbuf.pop_back(); } } #endif __m128 mpprev = _MM_LOAD_ALIGNED(pixels); __m128 mprev = mpprev; __m128 mker0 = _mm_load1_ps(kernel); __m128 mker1 = _mm_load1_ps(kernel+1); __m128 mker2 = _mm_load1_ps(kernel+2); float* buf = pconvbuf; for(int i = 2; i <= width; ++i) { _mm_store_ps(buf,mpprev); __m128 maccum = _mm_add_ps(_mm_mul_ps(mpprev,mker0), _mm_mul_ps(mprev,mker1)); maccum = _mm_add_ps(maccum,_mm_mul_ps(mprev,mker2)); _mm_store_ps(buf+4,maccum); buf += 8; } for(int i = 1; i < rows-width+2; ++i) { __m128 mnew = _MM_LOAD_ALIGNED(pixels+i*stride); _mm_store_ps(buf,mpprev); __m128 maccum = _mm_add_ps(_mm_mul_ps(mpprev,mker0), _mm_mul_ps(mprev,mker1)); maccum = _mm_add_ps(maccum,_mm_mul_ps(mnew,mker2)); mpprev = mprev; _mm_store_ps(buf+4,maccum); mprev = mnew; buf += 8; } _mm_store_ps(buf,mpprev); buf += 8; for(int i = rows-width+2; i < rows; ++i) { __m128 mnew = _mm_loadu_ps(pixels+i*stride); _mm_store_ps(buf,mprev); mprev = mnew; buf += 8; } // mprev points to the last row for(int i = 0; i < width; ++i) { _mm_store_ps(buf,mprev); buf += 8; } // have to pad rest with zeros memset(buf,0,convsize-((char*)buf-(char*)pconvbuf)); //// finally convolve buf = pconvbuf; for(int i = 0; i < rows; ++i, buf += 8) { __m128 maccum = _mm_load_ps(buf+4); if( ksize > 3 ) { for(int k = 3; k < ksize; k += 4) { float* psrc = buf + 8*k; __m128 mkerall = _mm_load_ps(kernel+k); __m128 mnew0 = _mm_load_ps(psrc); mker0 = _mm_shuffle_ps(mkerall,mkerall,0); __m128 mnew1 = _mm_load_ps(psrc + 8); mker1 = _mm_shuffle_ps(mkerall,mkerall,0x55); __m128 mnew2 = _mm_load_ps(psrc + 16); maccum = _mm_add_ps(maccum,_mm_mul_ps(mker0,mnew0)); maccum = _mm_add_ps(maccum,_mm_mul_ps(mker1,mnew1)); __m128 mnew3 = _mm_load_ps(psrc + 24); mker2 = _mm_shuffle_ps(mkerall,mkerall,0xaa); maccum = _mm_add_ps(maccum,_mm_mul_ps(mker2,mnew2)); maccum = _mm_add_ps(maccum,_mm_mul_ps(_mm_shuffle_ps(mkerall,mkerall,0xff),mnew3)); } } #ifdef ALIGNED_IMAGE_ROWS _mm_store_ps(pixels+i*stride,maccum); #else if( j <= stride-4 ) _mm_storeu_ps(pixels+i*stride,maccum); else { _mm_store_ps(ac.faccum[0],maccum); for(int k = 0; k < ((stride-j)&3); ++k) pixels[i*stride+k] = ac.faccum[0][k]; } #endif } #ifdef _OPENMP #pragma omp critical { s_listconvbuf.push_back(pconvbuf); } #endif } } #endif Keypoint FindMaxMin(Image* imdiff, Image* imgaus, float fscale, Keypoint keypts, unsigned int nbScales) { DVSTARTPROFILE(); int rows = imdiff[0]->rows, cols = imdiff[0]->cols, stride = imdiff[0]->stride; memset(s_MaxMinArray,0,rows*cols); for( int index = 1; index < (int)nbScales+1; ++index) { #if !defined(OTB_DISABLE_FAST_FUNCTIONS) && !defined(_MSC_VER) && defined(__SSE__) GradOriImagesFast(imgaus[index],s_imgrad,s_imorient); #else GradOriImages(imgaus[index],s_imgrad,s_imorient); #endif assert( imdiff[index]->stride == stride ); float* _diffpixels = imdiff[index]->pixels; // for(int i = 0; i < rows; ++i) { // for(int j = 0; j < cols; ++j) { // if( isnan(imgaus[index]->pixels[i*cols+j]) ) { // fprintf(stderr, "gaus: %d %d %d %d %d %f %f\n", index,i,j,rows,cols,s_imgrad->pixels[i*cols+j],s_imorient->pixels[i*cols+j]); // //exit(0); // } //// if( isnan(s_imorient->pixels[i*cols+j]) ) { //// //GradOriImagesFast(imgaus[index],s_imgrad,s_imorient); //// fprintf(stderr,"rc %d %d\n",rows,cols); //// fprintf(stderr,"wtf %d %d %f %f %f %f\n",i,j, s_imgrad->pixels[i*cols+j], imgaus[index]->pixels[i*cols+j], imgaus[index]->pixels[i*cols+j-1], imgaus[index]->pixels[i*cols+j+1]); //// fprintf(stderr,"%f %f\n",imgaus[index]->pixels[(i-1)*cols+j], imgaus[index]->pixels[(i+1)*cols+j]); //// exit(0); //// } // } // } #pragma omp parallel for schedule(dynamic,8) for( int rowstart = 5; rowstart < rows-5; ++rowstart ) { Keypoint newkeypts = NULL; float* diffpixels = _diffpixels + rowstart*stride; for( int colstart = 5; colstart < cols-5; ++colstart ) { float fval = diffpixels[colstart]; if( fabsf(fval) > PeakThresh*0.8f ) { if( LocalMaxMin(fval, imdiff[index],rowstart,colstart) && LocalMaxMin(fval, imdiff[index-1],rowstart,colstart) && LocalMaxMin(fval, imdiff[index+1],rowstart,colstart) && NotOnEdge(imdiff[index],rowstart,colstart) ) { newkeypts = InterpKeyPoint(imdiff,index,rowstart,colstart,s_imgrad,s_imorient,s_MaxMinArray,fscale,newkeypts,5,nbScales); } } } if( newkeypts != NULL ) { // find the last keypoint Keypoint lastkeypt = newkeypts; while(lastkeypt->next) lastkeypt = lastkeypt->next;; #pragma omp critical { lastkeypt->next = keypts; keypts = newkeypts; } } } } return keypts; } void GradOriImages(Image image, Image imgrad, Image imorient) { DVSTARTPROFILE(); int rows = image->rows, cols = image->cols, stride = image->stride; float* _pixels = image->pixels, *_pfgrad = imgrad->pixels, *_pforient = imorient->pixels; float fdiffc, fdiffr; #pragma omp parallel for schedule(dynamic,16) // might crash Matlab mex files for(int i = 0; i < rows; ++i) { float* pixels = _pixels + i*stride; float* pfgrad = _pfgrad + i*stride; float* pforient = _pforient + i*stride; for(int j = 0; j < cols; ++j) { if( j == 0 ) fdiffc = 2.0f*(pixels[1]-pixels[0]); else if( j == cols-1 ) fdiffc = 2.0f*(pixels[j]-pixels[j-1]); else fdiffc = pixels[j+1] - pixels[j-1]; if( i == 0 ) fdiffr = 2.0f*(pixels[j] - pixels[stride+j]); else if( i == rows-1 ) fdiffr = 2.0f*(pixels[-stride+j] - pixels[j]); else fdiffr = pixels[-stride+j] - pixels[stride+j]; pfgrad[j] = sqrtf(fdiffc*fdiffc + fdiffr*fdiffr); pforient[j] = atan2f(fdiffr,fdiffc); } } } #if !defined(OTB_DISABLE_FAST_FUNCTIONS) && !defined(_MSC_VER) && defined(__SSE__) void GradOriImagesFast(Image image, Image imgrad, Image imorient) { DVSTARTPROFILE(); int rows = image->rows, cols = image->cols, stride = image->stride; float* _pixels = image->pixels, *_pfgrad = imgrad->pixels, *_pforient = imorient->pixels; int endcol = ((cols-1)&~3); { // first row is special 2*(_pixels[0]-_pixels[stride]) float fdiffc, fdiffr; // first and last elt is 2*([1]-[0]), have to improvise for sse __m128 mprevj = _mm_set_ps(_pixels[2],_pixels[1],_pixels[0],2.0f*_pixels[0]-_pixels[1]); for(int j = 0; j < endcol; j += 4) { float* pf = _pixels+j; __m128 mnewj = _mm_loadu_ps(pf+3); __m128 mgradr = _MM_LOAD_ALIGNED(pf); __m128 mgradc = _mm_sub_ps(_mm_shuffle_ps(mprevj,mnewj,0x4e),mprevj); mgradr = _mm_sub_ps(mgradr, _MM_LOAD_ALIGNED(pf+stride)); mgradr = _mm_add_ps(mgradr,mgradr); __m128 mrad = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(mgradr,mgradr),_mm_mul_ps(mgradc,mgradc))); __m128 morient = atan2f4(mgradr,mgradc); _MM_STORE_ALIGNED(_pfgrad+j,mrad); mprevj = mnewj; _MM_STORE_ALIGNED(_pforient+j,morient); } // compute the rest the old way for(int j = endcol; j < cols; ++j) { if( j == 0 ) fdiffc = 2.0f*(_pixels[1]-_pixels[0]); else if( j == cols-1 ) fdiffc = 2.0f*(_pixels[j]-_pixels[j-1]); else fdiffc = _pixels[j+1] - _pixels[j-1]; fdiffr = 2.0f*(_pixels[j] - _pixels[stride+j]); _pfgrad[j] = sqrtf(fdiffc*fdiffc + fdiffr*fdiffr); _pforient[j] = atan2f(fdiffr,fdiffc); } } #pragma omp parallel for schedule(dynamic,16) // might crash Matlab mex files for(int i = 1; i < rows-1; ++i) { float fdiffc, fdiffr; float* pixels = _pixels + i*stride; float* pfgrad = _pfgrad + i*stride; float* pforient = _pforient + i*stride; // first and last elt is 2*([1]-[0]), have to improvise for sse __m128 mprevj = _mm_set_ps(pixels[2],pixels[1],pixels[0],2.0f*pixels[0]-pixels[1]); for(int j = 0; j < endcol; j += 4) { float* pf = pixels+j; __m128 mnewj = _mm_loadu_ps(pf+3); __m128 mgradr = _MM_LOAD_ALIGNED(pf-stride); __m128 mgradc = _mm_sub_ps(_mm_shuffle_ps(mprevj,mnewj,0x4e),mprevj); mgradr = _mm_sub_ps(mgradr,_MM_LOAD_ALIGNED(pf+stride)); __m128 mrad = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(mgradr,mgradr),_mm_mul_ps(mgradc,mgradc))); __m128 morient = atan2f4(mgradr,mgradc); _MM_STORE_ALIGNED(pfgrad+j,mrad); mprevj = mnewj; _MM_STORE_ALIGNED(pforient+j,morient); } assert( i != 0 && i != rows-1 ); // compute the rest the old way for(int j = endcol; j < cols; ++j) { if( j == cols-1 ) fdiffc = 2.0f*(pixels[j]-pixels[j-1]); else fdiffc = pixels[j+1] - pixels[j-1]; fdiffr = pixels[-stride+j] - pixels[stride+j]; pfgrad[j] = sqrtf(fdiffc*fdiffc + fdiffr*fdiffr); pforient[j] = atan2f(fdiffr,fdiffc); } } { float fdiffc, fdiffr; float* pixels = _pixels + (rows-1)*stride; float* pfgrad = _pfgrad + (rows-1)*stride; float* pforient = _pforient + (rows-1)*stride; // last row is special 2*(pixels[stride*(cols-1)]-pixels[stride*(cols-2)]) // first and last elt is 2*([1]-[0]), have to improvise for sse __m128 mprevj = _mm_set_ps(pixels[2],pixels[1],pixels[0],2.0f*pixels[0]-pixels[1]); for(int j = 0; j < endcol; j += 4) { float* pf = pixels+j; __m128 mnewj = _mm_loadu_ps(pf+3); __m128 mgradr = _MM_LOAD_ALIGNED(pf-stride); __m128 mgradc = _mm_sub_ps(_mm_shuffle_ps(mprevj,mnewj,0x4e),mprevj); mgradr = _mm_sub_ps(mgradr,_MM_LOAD_ALIGNED(pf)); mgradr = _mm_add_ps(mgradr,mgradr); __m128 mrad = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(mgradr,mgradr),_mm_mul_ps(mgradc,mgradc))); __m128 morient = atan2f4(mgradr,mgradc); _MM_STORE_ALIGNED(pfgrad+j,mrad); mprevj = mnewj; _MM_STORE_ALIGNED(pforient+j,morient); } // compute the rest the old way for(int j = endcol; j < cols; ++j) { if( j == cols-1 ) fdiffc = 2.0f*(pixels[j]-pixels[j-1]); else fdiffc = pixels[j+1] - pixels[j-1]; fdiffr = 2.0f*(pixels[-stride+j] - pixels[j]); pfgrad[j] = sqrtf(fdiffc*fdiffc + fdiffr*fdiffr); pforient[j] = atan2f(fdiffr,fdiffc); } } } #endif int LocalMaxMin(float fval, Image imdiff, int rowstart, int colstart) { int stride = imdiff->stride; float* pixels = imdiff->pixels; if( fval > 0 ) { for( int row = rowstart-1; row <= rowstart+1; ++row) { float* pf = pixels + row*stride + colstart - 1; if( pf[0] > fval || pf[1] > fval || pf[2] > fval ) return 0; } } else { for( int row = rowstart-1; row <= rowstart+1; ++row) { float* pf = pixels + row*stride + colstart-1; if( fval > pf[0] || fval > pf[1] || fval > pf[2] ) return 0; } } return 1; } int NotOnEdge(Image imdiff, int row, int col) { // probably wrong, something to do with plane normals? int stride = imdiff->stride; float* pixels = imdiff->pixels + row*stride; float f1 = pixels[-stride+col] - pixels[col]*2 + pixels[stride+col]; float f2 = pixels[col-1] - pixels[col]*2 + pixels[col+1]; float f3 = pixels[stride+col+1] - pixels[stride+col-1]; float f4 = pixels[-stride+col+1] - pixels[-stride+col-1]; float f5 = (f3 - f4)*0.25f; float f6 = f1*f2 - f5*f5; float f8 = f1+f2; return f6*11*11 > f8*f8*10; } Keypoint InterpKeyPoint(Image* imdiff, int index, int rowstart, int colstart, Image imgrad, Image imorient, char* pMaxMinArray, float fscale,Keypoint keypts, int steps, unsigned int nbScales) { float X[3]; float fquadvalue = FitQuadratic(X, imdiff, index, rowstart, colstart); int newrow = rowstart; int newcol = colstart; if( X[1] > 0.6f && rowstart < imdiff[0]->rows-3 ) newrow++; if( X[1] < -0.6f && rowstart>3 ) newrow--; if( X[2] > 0.6f && colstart < imdiff[0]->cols-3 ) newcol++; if( X[2] < -0.6f && colstart>3 ) newcol--; // check if local min/max is stable at (newrow,newcol). If not and steps haven't surprassed, // recompute at new location if( steps > 0 && (newrow != rowstart || newcol != colstart) ) return InterpKeyPoint(imdiff,index,newrow,newcol,imgrad,imorient,pMaxMinArray,fscale,keypts,steps-1,nbScales); if(fabsf(X[0]) <= 1.5f && fabsf(X[1]) <= 1.5f && fabsf(X[2]) <= 1.5f && fabsf(fquadvalue) >= PeakThresh ) { char* pmaxmin = pMaxMinArray + rowstart*imgrad->cols+colstart; bool bgetkeypts = false; #pragma omp critical { if( !pmaxmin[0] ) { bgetkeypts = true; pmaxmin[0] = 1; } } if( bgetkeypts ) { float fSize = InitSigma * powf(2.0f,((float)index + X[0])/(float)nbScales); return AssignOriHist(imgrad,imorient,fscale,fSize,(float)rowstart+X[1],(float)colstart+X[2],keypts); } } return keypts; } // fits a quadratic to a 3x3x3 box, returns the value of the quadratic at the center float FitQuadratic(float* X, Image* imdiff, int index, int r, int c) { float H[9]; int stride = imdiff[index-1]->stride; assert( stride == imdiff[index]->stride && stride == imdiff[index+1]->stride ); float* pixels0 = imdiff[index-1]->pixels + r*stride; float* pixels1 = imdiff[index]->pixels + r*stride; float* pixels2 = imdiff[index+1]->pixels + r*stride; float Y[3]; Y[0] = 0.5f*(pixels2[c] - pixels0[c]); Y[1] = 0.5f*(pixels1[stride+c] - pixels1[-stride+c]); Y[2] = 0.5f*(pixels1[c+1] - pixels1[c-1]); H[0] = pixels0[c] - 2.0f*pixels1[c] + pixels2[c]; H[4] = pixels1[-stride+c] - 2.0f*pixels1[c] + pixels1[stride+c]; H[8] = pixels1[c-1] - 2.0f*pixels1[c] + pixels1[c+1]; H[3] = H[1] = 0.25f*((pixels2[stride+c] - pixels2[-stride+c]) - (pixels0[stride+c] - pixels0[-stride+c])); H[6] = H[2] = 0.25f*((pixels2[c+1] - pixels2[c-1]) - (pixels0[c+1] - pixels0[c-1])); H[7] = H[5] = 0.25f*((pixels1[stride+c+1] - pixels1[stride+c-1]) - (pixels1[-stride+c+1] - pixels1[-stride+c-1])); X[0] = -Y[0]; X[1] = -Y[1]; X[2] = -Y[2]; SolveLinearSystem(X,H,3); // writes answer to X? return pixels1[c] + 0.5f * (X[0]*Y[0] + X[1]*Y[1] + X[2]*Y[2]); } // solve for X in H*X = Y using Gauss-Jordan method // write the result back in Y void SolveLinearSystem(float* Y, float* H, int dim) { float fmax; int bestj = 0; for(int i = 0; i < dim-1; ++i) { fmax = -1; for(int j = i; j < dim; ++j) { //if( i < dim ) { float f = H[j*dim+i]; if( f < 0 ) f = -f; if( f > fmax ) { fmax = f; bestj = j; } } if( bestj != i ) { for(int j = 0; j < dim; ++j) std::swap(H[bestj*dim+j], H[i*dim+j]); std::swap(Y[bestj],Y[i]); } for(int j = i+1; j < dim; ++j) { float f = H[j*dim+i]/H[i*dim+i]; for(int k = i; k < dim; ++k) H[j*dim+k] -= f*H[i*dim+k]; Y[j] -= Y[i]*f; } } // extract solution for(int i = dim-1; i >= 0; --i) { for(int j = dim-1; j > i; --j) Y[i] -= Y[j]*H[i*dim+j]; Y[i] /= H[i*dim+i]; } } Keypoint AssignOriHist(Image imgrad, Image imorient, float fscale, float fSize, float frowstart, float fcolstart, Keypoint keypts) { int rowstart = (int)(frowstart+0.5f); int colstart = (int)(fcolstart+0.5f); int rows = imgrad->rows, cols = imgrad->cols, stride = imgrad->stride; float SIFT_ALIGNED16(hists[36]); float fexpmult = -1.0f / (2.0f*1.5f*1.5f*fSize*fSize); memset(hists,0,sizeof(hists)); const float fbinmult = 36.0f/(2*PI); const float fbinadd = (float)(PI+0.001f)*fbinmult; // gather votes for orientation int windowsize = (int)(fSize*1.5f*3.0f); float* pfgrad = imgrad->pixels + (rowstart-windowsize)*stride, *pforient = imorient->pixels; for( int rowcur = rowstart-windowsize; rowcur <= rowstart+windowsize; ++rowcur, pfgrad += stride ) { if( rowcur < 0 || rowcur >= rows-2 ) continue; for( int colcur = colstart-windowsize; colcur <= colstart+windowsize; ++colcur ) { if( colcur < 0 || colcur >= cols-2 ) continue; float fdx = pfgrad[colcur]; if( fdx > 0 ) { float fdrow = (float)rowcur-frowstart, fdcol = (float)colcur-fcolstart; float fradius2 = fdrow*fdrow+fdcol*fdcol; if( (float)(windowsize*windowsize) + 0.5f > fradius2 ) { float fweight = expf(fradius2*fexpmult); int binindex = (int)(pforient[rowcur*stride+colcur]*fbinmult+fbinadd); // there is a bug in pforient where it could be 2*PI sometimes if( binindex > 36 ) { //if( binindex != 54 ) fprintf(stderr,"bin %d\n",binindex); binindex = 0; } assert( binindex >= 0 && binindex <= 36 ); if( binindex == 36 ) binindex = 35; hists[binindex] += fdx*fweight; } } } } // pick an orientation with the highest votes for(int i = 0; i < 6; ++i) SmoothHistogram(hists,36); #ifdef __SSE__ float SIFT_ALIGNED16(fmaxval); __m128 m0 = _mm_load_ps(&hists[0]); __m128 m1 = _mm_load_ps(&hists[4]); __m128 m2 = _mm_load_ps(&hists[8]); __m128 m3 = _mm_load_ps(&hists[12]); m0 = _mm_max_ps(m0,m1); m2 = _mm_max_ps(m2,m3); __m128 m4 = _mm_load_ps(&hists[16]); __m128 m5 = _mm_load_ps(&hists[20]); __m128 m6 = _mm_load_ps(&hists[24]); __m128 m7 = _mm_load_ps(&hists[28]); m4 = _mm_max_ps(m4,m5); m6 = _mm_max_ps(m6,m7); m0 = _mm_max_ps(m0,_mm_load_ps(&hists[32])); m2 = _mm_max_ps(m2,_mm_max_ps(m4,m6)); m0 = _mm_max_ps(m0,m2); m0 = _mm_max_ps(m0, _mm_shuffle_ps(m0,m0,0x4e)); _mm_store_ss(&fmaxval,_mm_max_ps(m0, _mm_shuffle_ps(m0,m0,0x11))); #else float fmaxval = 0; for(int i = 0; i < 36; ++i) { if( hists[i] > fmaxval ) fmaxval = hists[i]; } #endif fmaxval *= 0.8f; const float foriadd = 0.5f*2*PI/36.0f - PI, forimult = 2*PI/36.0f; int previndex = 35; for(int index = 0; index < 36; ++index) { if( index != 0 ) previndex = index-1; int nextindex = 0; if( index != 35 ) nextindex = index+1; if( hists[index] <= hists[previndex] || hists[index] <= hists[nextindex] || hists[index] < fmaxval ) continue; float fpeak = InterpPeak(hists[previndex],hists[index],hists[nextindex]); float forient = (index + fpeak)*forimult + foriadd; assert( forient >= -PI && forient <= PI ); // error, bad orientation keypts = MakeKeypoint(imgrad,imorient,fscale,fSize,frowstart,fcolstart,forient,keypts); } return keypts; } float InterpPeak(float f0, float f1, float f2) { if( f1 < 0 ) { f0 = -f0; f1 = -f1; f2 = -f2; } assert( f1 >= f0 && f1 > f2 ); return 0.5f*(f0 - f2) / (f0 - 2.0f*f1 + f2); } void SmoothHistogram(float* phist, int numbins) { float ffirst = phist[0]; float fprev = phist[numbins-1]; for(int i = 0; i < numbins-1; ++i) { float forg = phist[i]; phist[i] = (fprev + forg + phist[i+1])*0.33333333f; fprev = forg; } // TODO: replace phist[0] with ffirst phist[numbins-1] = (fprev+phist[numbins-1]+ffirst)*0.3333333f; } Keypoint MakeKeypoint(Image imgrad, Image imorient, float fscale, float fSize, float frowstart,float fcolstart,float forient, Keypoint keypts) { Keypoint pnewkeypt; #pragma omp critical { if( s_listKeypoints.size() > 0 ) { pnewkeypt = s_listKeypoints.back(); s_listKeypoints.pop_back(); } else pnewkeypt = (Keypoint)sift_aligned_malloc(sizeof(KeypointSt),16); } pnewkeypt->next = keypts; pnewkeypt->ori = forient; pnewkeypt->row = fscale*frowstart; pnewkeypt->col = fscale*fcolstart; pnewkeypt->scale = fscale*fSize; MakeKeypointSample(pnewkeypt,imgrad,imorient,fSize,frowstart,fcolstart); return pnewkeypt; } void MakeKeypointSample(Keypoint pkeypt, Image imgrad, Image imorient, float fSize, float frowstart, float fcolstart) { float* fdesc = pkeypt->descrip; memset(fdesc,0,sizeof(float)*128); KeySample(fdesc, pkeypt, imgrad, imorient, fSize, frowstart, fcolstart); #ifdef __SSE__ __m128 maccum0 = _mm_load_ps(fdesc); __m128 maccum1 = _mm_load_ps(fdesc+4); maccum0 = _mm_mul_ps(maccum0,maccum0); maccum1 = _mm_mul_ps(maccum1,maccum1); for(int i = 8; i < 128; i += 8 ) { __m128 m0 = _mm_load_ps(fdesc+i); __m128 m1 = _mm_load_ps(fdesc+i+4); maccum0 = _mm_add_ps(maccum0,_mm_mul_ps(m0,m0)); maccum1 = _mm_add_ps(maccum1,_mm_mul_ps(m1,m1)); } maccum0 = _mm_add_ps(maccum0,maccum1); #ifdef __SSE3__ maccum0 = _mm_hadd_ps(maccum0,maccum0); maccum0 = _mm_hadd_ps(maccum0,maccum0); #else maccum0 = _mm_add_ps(maccum0,_mm_shuffle_ps(maccum0,maccum0,0x4e)); maccum0 = _mm_add_ss(maccum0,_mm_shuffle_ps(maccum0,maccum0,0x55)); #endif float fthresh; float SIFT_ALIGNED16(flength2); _mm_store_ss(&flength2, maccum0); fthresh = 0.2f*sqrtf(flength2); for(int i = 0; i < 128; ++i) { if( fdesc[i] > fthresh ) { flength2 += fthresh*fthresh-fdesc[i]*fdesc[i]; fdesc[i] = fthresh; } } // normalizing float flength = 1.0f/sqrtf(flength2); maccum0 = _mm_load1_ps(&flength); for(int i = 0; i < 128; i += 16 ) { __m128 m0 = _mm_load_ps(fdesc+i); __m128 m1 = _mm_load_ps(fdesc+i+4); __m128 m2 = _mm_load_ps(fdesc+i+8); __m128 m3 = _mm_load_ps(fdesc+i+12); _mm_store_ps(fdesc+i,_mm_mul_ps(m0,maccum0)); _mm_store_ps(fdesc+i+4,_mm_mul_ps(m1,maccum0)); _mm_store_ps(fdesc+i+8,_mm_mul_ps(m2,maccum0)); _mm_store_ps(fdesc+i+12,_mm_mul_ps(m3,maccum0)); } // converting to unsigned char // float flength = 512.0f/sqrtf(flength2); // maccum0 = _mm_load1_ps(&flength); // unsigned char* pkeydesc = pkeypt->descrip; // // for(int i = 0; i < 128; i += 16 ) { // __m128 m0 = _mm_load_ps(fdesc+i); // __m128 m1 = _mm_load_ps(fdesc+i+4); // __m128 m2 = _mm_load_ps(fdesc+i+8); // __m128 m3 = _mm_load_ps(fdesc+i+12); // __m128i mi0 = _mm_cvttps_epi32(_mm_mul_ps(m0,maccum0)); // __m128i mi1 = _mm_cvttps_epi32(_mm_mul_ps(m1,maccum0)); // __m128i mi2 = _mm_cvttps_epi32(_mm_mul_ps(m2,maccum0)); // __m128i mi3 = _mm_cvttps_epi32(_mm_mul_ps(m3,maccum0)); // _mm_store_si128((__m128i*)(pkeydesc+i), _mm_packus_epi16(_mm_packs_epi32(mi0,mi1),_mm_packs_epi32(mi2,mi3))); // } #else NormalizeVec(fdesc,128); bool brenormalize = false; for(int i = 0; i < 128; ++i) { if( fdesc[i] > 0.2f ) { fdesc[i] = 0.2f; brenormalize = true; } } if( brenormalize ) NormalizeVec(fdesc,128); #endif } void NormalizeVec(float* pf, int num) { assert( (num&3) == 0 ); float faccum = 0; for(int i = 0; i < num; ++i) faccum += pf[i]*pf[i]; faccum = 1/sqrtf(faccum); for(int i = 0; i < num; ++i) pf[i] *= faccum; } void KeySample(float* fdesc, Keypoint pkeypt, Image imgrad, Image imorient, float fSize, float frowstart, float fcolstart) { int rowstart = (int)(frowstart+0.5f); int colstart = (int)(fcolstart+0.5f); float sinang = sinf(pkeypt->ori), cosang = cosf(pkeypt->ori); float fdrow = frowstart-(float)rowstart; float fdcol = fcolstart-(float)colstart; float frealsize = 3.0f*fSize; float firealsize = 1.0f/(3.0f*fSize); int windowsize = (int)(frealsize*SQRT2*5.0f*0.5f+0.5f); float fsr = sinang*firealsize, fcr = cosang*firealsize, fdrr = -fdrow*firealsize, fdcr = -fdcol*firealsize; for(int row = -windowsize; row <= windowsize; ++row) { //#ifdef _OPENMP // float SIFT_ALIGNED16(fnewdesc[128]) = {0}; // bool badd = false; //#else float* fnewdesc = fdesc; //#endif float frow = (float)row; float fcol = -(float)windowsize; for(int col = -windowsize; col <= windowsize; ++col, fcol += 1) { float rpos = fsr*fcol + fcr*frow + fdrr; float cpos = fcr*fcol - fsr*frow + fdcr; float rx = rpos + (2.0f - 0.5f); float cx = cpos + (2.0f - 0.5f); if( rx > -0.9999f && rx < 3.9999f && cx > -0.9999f && cx < 3.9999f ) { AddSample(fnewdesc, pkeypt, imgrad, imorient, rowstart+row, colstart+col, rpos, cpos, rx, cx); //#ifdef _OPENMP // badd = true; //#endif } } //#ifdef _OPENMP // if( badd ) { // #pragma omp critical // { //#ifdef __SSE__ // for(int j = 0; j < 128; j += 16) { // _mm_store_ps(&fdesc[j], _mm_add_ps(_mm_load_ps(&fdesc[j]), _mm_load_ps(&fnewdesc[j]))); // _mm_store_ps(&fdesc[j+4], _mm_add_ps(_mm_load_ps(&fdesc[j+4]), _mm_load_ps(&fnewdesc[j+4]))); // _mm_store_ps(&fdesc[j+8], _mm_add_ps(_mm_load_ps(&fdesc[j+8]), _mm_load_ps(&fnewdesc[j+8]))); // _mm_store_ps(&fdesc[j+12], _mm_add_ps(_mm_load_ps(&fdesc[j+12]), _mm_load_ps(&fnewdesc[j+12]))); // } //#else // for(int j = 0; j < 128; ++j) // fdesc[j] += fnewdesc[j]; //#endif // } // } //#endif } } void AddSample(float* fdesc, Keypoint pkeypt, Image imgrad, Image imorient, int r, int c, float rpos, float cpos, float rx, float cx) { int rows = imgrad->rows, cols = imgrad->cols, stride = imgrad->stride; if( r < 0 || r >= rows || c < 0 || c >= cols ) return; float fgrad = imgrad->pixels[r*stride+c] * expf(-0.125f*(rpos*rpos+cpos*cpos)); float forient = imorient->pixels[r*stride+c] - pkeypt->ori; while( forient > 2*PI ) forient -= 2*PI; while( forient < 0 ) forient += 2*PI; // if( isnan(forient) ) // fprintf(stderr,"%f %f (%d,%d,%d,%d)\n", imorient->pixels[r*stride+c],pkeypt->ori,r,c,rows,cols); PlaceInIndex(fdesc, fgrad, forient, rx, cx); } void PlaceInIndex(float* fdesc, float mag, float ori, float rx, float cx) { float oribin = ori*(8.0f/(2*(float)PI)); int newrow, newcol, neworient; float rfrac, cfrac, ofrac; if( rx < 0 ) { newrow = (int)(rx-1); } else { newrow = (int)rx; } rfrac = rx-(float)newrow; if( cx < 0 ) newcol = (int)(cx-1); else newcol = (int)cx; cfrac = cx - (float)newcol; if( oribin < 0 ) neworient = (int)(oribin-1); else neworient = (int)oribin; ofrac = oribin-(float)neworient; assert( newrow >= -1 && newrow < 4 && neworient >= 0 && neworient <= 8 && rfrac >= 0 && rfrac < 1); for(int i = 0; i < 2; ++i) { if( (unsigned int)(i+newrow) >= 4 ) continue; float frowgrad; if( i == 0 ) frowgrad = mag*(1-rfrac); else frowgrad = mag*rfrac; for(int j = 0; j < 2; ++j) { if( (unsigned int)(j+newcol) >= 4 ) continue; float fcolgrad; if( j == 0 ) fcolgrad = frowgrad*(1-cfrac); else fcolgrad = frowgrad*cfrac; float* pfdescorient = fdesc + 8*(4*(i+newrow)+j+newcol); for(int k = 0; k < 2; ++k) { float forigrad; if( k == 0 ) forigrad = fcolgrad*(1-ofrac); else forigrad = fcolgrad*ofrac; pfdescorient[(neworient+k)&7] += forigrad; } } } } void FreeKeypoints(Keypoint keypt) { while(keypt != NULL) { s_listKeypoints.push_back(keypt); keypt = keypt->next; } } void DestroyAllResources() { DestroyAllImages(); for( std::map::iterator it = s_mapkernel.begin(); it != s_mapkernel.end(); ++it) sift_aligned_free(it->second-1); s_mapkernel.clear(); #ifdef __SSE__ for(LISTBUF::iterator it = s_listconvbuf.begin(); it != s_listconvbuf.end(); ++it) sift_aligned_free(*it); s_listconvbuf.clear(); s_convbufsize = 0; #endif for(std::list::iterator it = s_listKeypoints.begin(); it != s_listKeypoints.end(); ++it) sift_aligned_free(*it); s_listKeypoints.clear(); } #if !defined(OTB_DISABLE_FAST_FUNCTIONS) && !defined(_MSC_VER) && defined(__SSE__) && !defined(SIMDMATH_H) // copied from libsimdmath #define DEF_CONST(a,b) static const vec_float4 a = {b,b,b,b}; #define DEI_CONST(a,b) static const vec_int4 a = {b,b,b,b}; DEF_CONST(CF4_2414213562373095, 2.414213562373095f) DEF_CONST(CF4_04142135623730950, 0.4142135623730950f) DEF_CONST(CF4_805374449538e_2, 8.05374449538e-2f) DEF_CONST(CF4_138776856032E_1, 1.38776856032E-1f) DEF_CONST(CF4_199777106478E_1, 1.99777106478E-1f) DEF_CONST(CF4_333329491539E_1, 3.33329491539E-1f) #define VEC_F2I(a,b) asm("cvttps2dq %1, %0":"=x" (a) :"x" (b)) #define VEC_I2F(a,b) asm("cvtdq2ps %1, %0":"=x" (a) :"x" (b)) /* definitions for a &= b; etc gcc generates very slow code for corresponding vec_float4 C-style expressions */ #define VEC_AND(a,b) asm ("andps %2, %1":"=x" (a) :"0" (a),"x" (b)) #define VEC_NAND(a,b) asm ("andnps %2, %1":"=x" (a) :"0" (a),"x" (b)) #define VEC_NAND3(a,b,c) a=(typeof(a))_mm_andnot_ps((vec_float4)(c),(vec_float4)(b)) #define VEC_OR(a,b) asm ("orps %2, %1":"=x" (a) :"0" (a),"x" (b)) #define VEC_XOR(a,b) asm ("xorps %2, %1":"=x" (a) :"0" (a),"x" (b)) #define VEC_SUB(a,b) asm ("subps %2, %1":"=x" (a) :"0" (a),"x" (b)) #define VEC_GT(a,b) _mm_cmpgt_ps((vec_float4)a,(vec_float4)b) #define VEC_LT(a,b) _mm_cmplt_ps(a,b) #define VEC_EQ(a,b) _mm_cmpeq_ps(a,b) #define VEC_NE(a,b) _mm_cmpneq_ps(a,b) #define VEC_GE(a,b) _mm_cmpge_ps(a,b) #define VEC_SR(v,n) _mm_srli_epi32(v,n) #define VEC_SL(v,n) _mm_slli_epi32(v,n) #define vec_re(x) _mm_rcp_ps(x) #define vec_sr(x,y) _mm_srli_epi32(x,y) #define vec_sl(x,y) _mm_slli_epi32(x,y) #define vec_or(a,b) ((a)|(b)) #define vec_and(a,b) ((a)&(b)) #define vec_add(a,b) ((a)+(b)) #define vec_madd(a,b,c) ((a)*(b)+(c)) #define vec_nmsub(a,b,c) ((c)-(a)*(b)) #define vec_splat(x,n) (typeof(x))_mm_shuffle_ps(x,x,_MM_SHUFFLE(n,n,n,n)) DEF_CONST(CF4_0, 0.0f) DEF_CONST(CF4_2, 2.0f) DEI_CONST(CI4_SIGN, static_cast(0x80000000u)) DEF_CONST(CF4__1, -1.0f) DEF_CONST(CF4_1, 1.0f) DEF_CONST(CF4_SMALL, 1.0E-35f) DEF_CONST(CF4_PIO2F, 1.570796326794896619f) DEF_CONST(CF4_PIO4F, 0.7853981633974483096f) DEF_CONST(CF4_PIF, 3.14159265358979323846f) inline vec_int4 __attribute__((__always_inline__)) _signf4( vec_float4 x ){ vec_int4 a = CI4_SIGN; VEC_AND(a, x); return a; } inline vec_float4 __attribute__((__always_inline__)) _atanf4( vec_float4 x ){ vec_float4 y, z,z1,z2; vec_int4 a1, a2, a3; /* make argument positive and save the sign */ vec_int4 sign = _signf4( x ); VEC_XOR(x, sign); /* range reduction */ a1 = (vec_int4)VEC_GT (x , CF4_2414213562373095 ); a2 = (vec_int4)VEC_GT (x , CF4_04142135623730950 ); a3 = ~a2; a2 ^= a1; z1 = CF4__1 / (x+CF4_SMALL); z2 = (x-CF4_1)/(x+CF4_1); VEC_AND(z1, a1); VEC_AND(z2, a2); VEC_AND(x, a3); VEC_OR(x, z1); VEC_OR(x, z2); y = CF4_PIO2F; z1 = CF4_PIO4F; VEC_AND(y, a1); VEC_AND(z1, a2); VEC_OR(y, z1); z = x * x; y += ((( CF4_805374449538e_2 * z - CF4_138776856032E_1) * z + CF4_199777106478E_1) * z - CF4_333329491539E_1) * z * x + x; VEC_XOR(y, sign); return y; } inline vec_float4 __attribute__((__always_inline__)) atan2f4( vec_float4 y, vec_float4 x ){ vec_float4 z, w; vec_float4 x_neg_PI = CF4_PIF; VEC_AND(x_neg_PI, VEC_GT( CF4_0, x )); vec_float4 y_negativ_2 = CF4_2; VEC_AND(y_negativ_2, VEC_GT( CF4_0, y )); vec_int4 i_x_zero = (vec_int4)VEC_EQ ( CF4_0, x ); vec_int4 i_y_zero = (vec_int4)VEC_EQ ( CF4_0, y ); vec_float4 x_zero_PIO2 = CF4_PIO2F; VEC_AND(x_zero_PIO2, i_x_zero); vec_float4 y_zero = CF4_1; VEC_AND(y_zero, i_y_zero); w = x_neg_PI * ( CF4_1 - y_negativ_2 ); z = _atanf4( y / (x+x_zero_PIO2)); VEC_AND(z, ~(i_x_zero|i_y_zero)); return w + z + x_zero_PIO2 * ( CF4_1 - y_zero - y_negativ_2 ); } #endif OTB-release-5.8/Modules/ThirdParty/SiftFast/src/makerelease.sh000066400000000000000000000005701301006202600242460ustar00rootroot00000000000000version=1.2 rm -rf libsiftfast-$version libsiftfast-$version-src make prefix=`pwd`/libsiftfast-$version make install cp README LICENSE libsiftfast-$version/ tar czf libsiftfast-$version-linux-i386.tgz libsiftfast-$version svn export . libsiftfast-$version-src/ tar czf libsiftfast-$version-src.tgz libsiftfast-$version-src rm -rf libsiftfast-$version libsiftfast-$version-src OTB-release-5.8/Modules/ThirdParty/SiftFast/src/otb_siftfast.h000066400000000000000000000011721301006202600242730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_siftfast_h #include "otbsiftfast/siftfast.h" #endif OTB-release-5.8/Modules/ThirdParty/SiftFast/src/profiler.cpp000066400000000000000000000176101301006202600237650ustar00rootroot00000000000000// exact C++ implementation of lowe's sift program // author: zerofrog(@gmail.com), Sep 2008 // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // at your option) any later version. // //This program is distributed in the hope that it will be useful, //but WITHOUT ANY WARRANTY; without even the implied warranty of //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //Lesser GNU General Public License for more details. // //You should have received a copy of the GNU Lesser General Public License //along with this program. If not, see . // This source code was carefully calibrated to match David Lowe's SIFT features program #include "profiler.h" //////////////////// // Small profiler // //////////////////// #include #include #include #include // ftime(), struct timeb #include using namespace std; int g_bWriteProfile=1; static u64 luPerfFreq = 1000000; inline u64 GET_PROFILE_TIME() { struct timeval t; gettimeofday(&t, NULL); return (u64)t.tv_sec*1000000+t.tv_usec; } struct DVPROFSTRUCT; struct DVPROFSTRUCT { struct DATA { DATA(u64 time, u32 user = 0) : dwTime(time), dwUserData(user) {} DATA() : dwTime(0), dwUserData(0) {} u64 dwTime; u32 dwUserData; }; ~DVPROFSTRUCT() { list::iterator it = listpChild.begin(); while(it != listpChild.end() ) { delete *it; *it = NULL; ++it; } } list listTimes; // before DVProfEnd is called, contains the global time it started // after DVProfEnd is called, contains the time it lasted // the list contains all the tracked times char pname[256]; list listpChild; // other profilers called during this profiler period }; struct DVPROFTRACK { u32 dwUserData; DVPROFSTRUCT::DATA* pdwTime; DVPROFSTRUCT* pprof; }; list g_listCurTracking; // the current profiling functions, the back element is the // one that will first get popped off the list when DVProfEnd is called // the pointer is an element in DVPROFSTRUCT::listTimes list g_listProfilers; // the current profilers, note that these are the parents // any profiler started during the time of another is held in // DVPROFSTRUCT::listpChild list g_listAllProfilers; // ignores the hierarchy, pointer to elements in g_listProfilers void DVProfRegister(const char* pname) { if( !g_bWriteProfile ) return; list::iterator it = g_listAllProfilers.begin(); // while(it != g_listAllProfilers.end() ) { // // if( _tcscmp(pname, (*it)->pname) == 0 ) { // (*it)->listTimes.push_back(timeGetTime()); // DVPROFTRACK dvtrack; // dvtrack.pdwTime = &(*it)->listTimes.back(); // dvtrack.pprof = *it; // g_listCurTracking.push_back(dvtrack); // return; // } // // ++it; // } // else add in a new profiler to the appropriate parent profiler DVPROFSTRUCT* pprof = NULL; if( g_listCurTracking.size() > 0 ) { assert( g_listCurTracking.back().pprof != NULL ); g_listCurTracking.back().pprof->listpChild.push_back(new DVPROFSTRUCT()); pprof = g_listCurTracking.back().pprof->listpChild.back(); } else { g_listProfilers.push_back(DVPROFSTRUCT()); pprof = &g_listProfilers.back(); } strncpy(pprof->pname, pname, 256); // setup the profiler for tracking pprof->listTimes.push_back(DVPROFSTRUCT::DATA(GET_PROFILE_TIME())); DVPROFTRACK dvtrack; dvtrack.pdwTime = &pprof->listTimes.back(); dvtrack.pprof = pprof; dvtrack.dwUserData = 0; g_listCurTracking.push_back(dvtrack); // add to all profiler list g_listAllProfilers.push_back(pprof); } void DVProfEnd(u32 dwUserData) { if( !g_bWriteProfile ) return; if( g_listCurTracking.size() == 0 ) return; DVPROFTRACK dvtrack = g_listCurTracking.back(); assert( dvtrack.pdwTime != NULL && dvtrack.pprof != NULL ); dvtrack.pdwTime->dwTime = GET_PROFILE_TIME()- dvtrack.pdwTime->dwTime; dvtrack.pdwTime->dwUserData= dwUserData; g_listCurTracking.pop_back(); } struct DVTIMEINFO { DVTIMEINFO() : uInclusive(0), uExclusive(0) {} u64 uInclusive, uExclusive; }; map mapAggregateTimes; u64 DVProfWriteStruct(FILE* f, DVPROFSTRUCT* p, int ident) { fprintf(f, "%*s%s - ", ident, "", p->pname); list::iterator ittime = p->listTimes.begin(); u64 utime = 0; while(ittime != p->listTimes.end() ) { // if( ittime->dwTime > luPerfFreq*10 ) { // ++ittime; // continue; // } utime += ittime->dwTime; if( ittime->dwUserData ) fprintf(f, "time: %d, user: 0x%8.8x", (u32)ittime->dwTime, ittime->dwUserData); else fprintf(f, "time: %d", (u32)ittime->dwTime); ++ittime; } // yes this is necessary, maps have problems with constructors on their type map::iterator ittimes = mapAggregateTimes.find(p->pname); if( ittimes == mapAggregateTimes.end() ) { ittimes = mapAggregateTimes.insert(map::value_type(p->pname, DVTIMEINFO())).first; ittimes->second.uExclusive = 0; ittimes->second.uInclusive = 0; } ittimes->second.uInclusive += utime; fprintf(f, "\n"); list::iterator itprof = p->listpChild.begin(); u64 uex = utime; while(itprof != p->listpChild.end() ) { uex -= DVProfWriteStruct(f, *itprof, ident+4); ++itprof; } if( uex > utime ) { uex = 0; //RAVEPRINT(L"profiling precision error!\n"); } ittimes->second.uExclusive += uex; return utime; } void DVProfWrite(const char* pfilename, u32 frames) { assert( pfilename != NULL ); FILE* f = fopen(pfilename, "w"); // pop back any unused mapAggregateTimes.clear(); list::iterator it = g_listProfilers.begin(); while(it != g_listProfilers.end() ) { DVProfWriteStruct(f, &(*it), 0); ++it; } { map::iterator it; fprintf(f, "\n\n--------------------------------------------------------------\n\n"); u64 uTotal[2]; uTotal[0] = uTotal[1] = 0; double fiTotalTime[2]; fiTotalTime[0] = fiTotalTime[1] = 0; for(it = mapAggregateTimes.begin(); it != mapAggregateTimes.end(); ++it) { uTotal[0] += it->second.uExclusive; uTotal[1] += it->second.uInclusive; } fprintf(f, "total times (%d): ex: %Lu ", frames, 1000000*uTotal[0]/(luPerfFreq*(u64)frames)); fprintf(f, "inc: %Lu\n", 1000000 * uTotal[1]/(luPerfFreq*(u64)frames)); if( uTotal[0] > 0 ) fiTotalTime[0] = 1.0 / (double)uTotal[0]; if( uTotal[1] > 0 ) fiTotalTime[1] = 1.0 / (double)uTotal[1]; // output the combined times for(it = mapAggregateTimes.begin(); it != mapAggregateTimes.end(); ++it) { fprintf(f, "%s - ex: %f%% (%fs) inc: %f%%\n", it->first.c_str(), 100.0f*(float)((double)it->second.uExclusive * fiTotalTime[0]), (double)it->second.uExclusive/(double)luPerfFreq, 100.0f*(float)((double)it->second.uInclusive * fiTotalTime[1])); } } fclose(f); } void DVProfClear() { g_listCurTracking.clear(); g_listProfilers.clear(); g_listAllProfilers.clear(); } OTB-release-5.8/Modules/ThirdParty/SiftFast/src/profiler.h000066400000000000000000000041111301006202600234220ustar00rootroot00000000000000// exact C++ implementation of lowe's sift program // author: zerofrog(@gmail.com), Sep 2008 // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // at your option) any later version. // //This program is distributed in the hope that it will be useful, //but WITHOUT ANY WARRANTY; without even the implied warranty of //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //Lesser GNU General Public License for more details. // //You should have received a copy of the GNU Lesser General Public License //along with this program. If not, see . // This source code was carefully calibrated to match David Lowe's SIFT features program #ifndef SMALL_PROFILER_H #define SMALL_PROFILER_H typedef unsigned int u32; typedef unsigned long long u64; typedef signed long long s64; #include //// // profiling /// extern int g_bWriteProfile; // global variable to enable/disable profiling (if DVPROFILE is defined) // IMPORTANT: For every Reigster there must be an End void DVProfRegister(const char* pname); // first checks if this profiler exists in g_listProfilers void DVProfEnd(u32 dwUserData); void DVProfWrite(const char* pfilename, u32 frames = 1); void DVProfClear(); // clears all the profilers #if defined(DVPROFILE) #ifdef _MSC_VER #ifndef __PRETTY_FUNCTION__ #define __PRETTY_FUNCTION__ __FUNCTION__ #endif #endif #define DVSTARTPROFILE() DVProfileFunc _pf(__FUNCTION__); class DVProfileFunc { public: u32 dwUserData; DVProfileFunc(const char* pname) { DVProfRegister(pname); dwUserData = 0; } DVProfileFunc(const char* pname, u32 dwUserData) : dwUserData(dwUserData) { DVProfRegister(pname); } ~DVProfileFunc() { DVProfEnd(dwUserData); } }; #else #define DVSTARTPROFILE() class DVProfileFunc { public: u32 dwUserData; inline DVProfileFunc(const char* pname) {} inline DVProfileFunc(const char* pname, u32 dwUserData) { } ~DVProfileFunc() {} }; #endif #endif OTB-release-5.8/Modules/ThirdParty/SiftFast/src/runcmake.bat000066400000000000000000000000411301006202600237220ustar00rootroot00000000000000mkdir build cd build cmake .. OTB-release-5.8/Modules/ThirdParty/SiftFast/src/siftfast.cpp000066400000000000000000000110141301006202600237560ustar00rootroot00000000000000// exact C++ implementation of lowe's sift program // Copyright (C) zerofrog(@gmail.com), 2008-2009 // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // at your option) any later version. // //This program is distributed in the hope that it will be useful, //but WITHOUT ANY WARRANTY; without even the implied warranty of //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //Lesser GNU General Public License for more details. // //You should have received a copy of the GNU Lesser General Public License //along with this program. If not, see . // This source code was carefully calibrated to match David Lowe's SIFT features program #include "siftfast.h" #include #ifdef __FreeBSD__ # include #else # include // ftime(), struct timeb #endif #ifdef _WIN32 #include #include #endif #include #include #include using namespace std; typedef unsigned short u16; typedef unsigned int u32; typedef unsigned long long u64; inline u32 timeGetTime() { u32 millisec = 0; #ifdef _WIN32 _timeb t; _ftime(&t); millisec = (u32)(t.time*1000+t.millitm); #else # ifdef __FreeBSD__ // tv_sec is multiplied by 1000 to maintain same result as above // tv_usec is in micro-seconds, so multiply by 1000 to maintain same // result as above timeval t; gettimeofday(&t, NULL); millisec = (u32)(t.tv_sec*1000+t.tv_usec/1000); # else timeb t; ftime(&t); millisec = (u32)(t.time*1000+t.millitm); # endif #endif return millisec; } // code from david lowe void SkipComments(FILE *fp) { int ch; fscanf(fp," "); // Skip white space. while ((ch = fgetc(fp)) == '#') { while ((ch = fgetc(fp)) != '\n' && ch != EOF) ; fscanf(fp," "); } ungetc(ch, fp); // Replace last character read. } // code from david lowe Image ReadPGM(FILE *fp) { int char1, char2, width, height, max, c1, c2, c3, r, c; Image image, nextimage; char1 = fgetc(fp); char2 = fgetc(fp); SkipComments(fp); c1 = fscanf(fp, "%d", &width); SkipComments(fp); c2 = fscanf(fp, "%d", &height); SkipComments(fp); c3 = fscanf(fp, "%d", &max); if (char1 != 'P' || char2 != '5' || c1 != 1 || c2 != 1 || c3 != 1 || max > 255) { cerr << "Input is not a standard raw 8-bit PGM file." << endl << "Use xv or pnmdepth to convert file to 8-bit PGM format." << endl; exit(1); } fgetc(fp); // Discard exactly one byte after header. // Create floating point image with pixels in range [0,1]. image = CreateImage(height, width); for (r = 0; r < height; r++) for (c = 0; c < width; c++) image->pixels[r*image->stride+c] = ((float) fgetc(fp)) / 255.0; //Check if there is another image in this file, as the latest PGM // standard allows for multiple images. SkipComments(fp); if (getc(fp) == 'P') { cerr << "ignoring other images" << endl; ungetc('P', fp); nextimage = ReadPGM(fp); //image->next = nextimage; } return image; } int main(int argc, char **argv) { #ifdef _WIN32 // have to set to binary _setmode(_fileno(stdin),_O_BINARY); #endif Image image = ReadPGM(stdin); Keypoint keypts; float fproctime; cerr << "Finding keypoints (image " << image->cols << "x" << image->rows << ")..." << endl; { u32 basetime = timeGetTime(); keypts = GetKeypoints(image); fproctime = (timeGetTime()-basetime)*0.001f; } // write the keys to the output int numkeys = 0; Keypoint key = keypts; while(key) { numkeys++; key = key->next; } cerr << numkeys << " keypoints found in " << fproctime << " seconds." << endl; cout << numkeys << " " << 128 << endl; key = keypts; while(key) { cout << key->row << " " << key->col << " " << key->scale << " " << key->ori << endl; for(int i = 0; i < 128; ++i) { int intdesc = (int)(key->descrip[i]*512.0f); assert( intdesc >= 0 ); if( intdesc > 255 ) intdesc = 255; cout << intdesc << " "; if( (i&15)==15 ) cout << endl; } cout << endl; key = key->next; } FreeKeypoints(keypts); DestroyAllResources(); return 0; } OTB-release-5.8/Modules/ThirdParty/SiftFast/src/siftfast.h000066400000000000000000000033011301006202600234230ustar00rootroot00000000000000// Copyright (C) zerofrog(@gmail.com), 2008-2009 // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // at your option) any later version. // //This program is distributed in the hope that it will be useful, //but WITHOUT ANY WARRANTY; without even the implied warranty of //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //Lesser GNU General Public License for more details. // //You should have received a copy of the GNU Lesser General Public License //along with this program. If not, see . #ifndef SIFT_FAST_H #define SIFT_FAST_H typedef struct ImageSt { int rows, cols; // Dimensions of image. float *pixels; // 2D array of image pixels. int stride; // how many floats until the next row // (used to add padding to make rows aligned to 16 bytes) } *SiftFastImage; typedef struct KeypointSt { float row, col; // Subpixel location of keypoint. float scale, ori; // Scale and orientation (range [-PI,PI]) float descrip[128]; // Vector of descriptor values struct KeypointSt *next; // Pointer to next keypoint in list. } *Keypoint; #ifdef __cplusplus extern "C" { #endif Keypoint GetKeypoints(SiftFastImage porgimage, unsigned int nbScales); SiftFastImage CreateImage(int rows, int cols); SiftFastImage CreateImageFromMatlabData(double* pdata, int rows, int cols); void DestroyAllImages(); void DestroyAllResources(); void FreeKeypoints(Keypoint keypt); #ifdef __cplusplus } #endif #endif OTB-release-5.8/Modules/ThirdParty/SiftFast/src/siftfast.m000066400000000000000000000005321301006202600234330ustar00rootroot00000000000000% [frames, descriptors] = siftfast(I) % % Returns the sift feature of a grayscale image % I - grayscale in real format, all values have to be in [0,1] % frames - 4xN matrix of the sift locations each column is (X,Y,Scale,Orientation) % descriptors - KxN matrix (usually K=128) of the sift descriptors function [frames, descriptors] = siftfast(I) OTB-release-5.8/Modules/ThirdParty/SiftFast/src/siftfastpy.cpp000066400000000000000000000233421301006202600243360ustar00rootroot00000000000000// exact C++ implementation of lowe's sift program // Copyright (C) zerofrog(@gmail.com), 2008-2009 // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // at your option) any later version. // //This program is distributed in the hope that it will be useful, //but WITHOUT ANY WARRANTY; without even the implied warranty of //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //Lesser GNU General Public License for more details. // //You should have received a copy of the GNU Lesser General Public License //along with this program. If not, see . #define BOOST_ENABLE_ASSERT_HANDLER #include #include #define PY_ARRAY_UNIQUE_SYMBOL PyArrayHandle #include #include #include #include #include #include "siftfast.h" #define CHECK_POINTER(p) { \ if( (p) == NULL ) throw siftfast_exception("invalid pointer"); \ } using namespace boost::python; using namespace std; extern int DoubleImSize; extern int Scales; extern float InitSigma; extern float PeakThresh; struct siftfast_exception : std::exception { siftfast_exception() : std::exception(), _s("unknown exception") {} siftfast_exception(const string& s) : std::exception() { _s = "siftfast: " + s; } virtual ~siftfast_exception() throw() {} char const* what() const throw() { return _s.c_str(); } string _s; }; #if defined(BOOST_ENABLE_ASSERT_HANDLER) namespace boost { inline void assertion_failed(char const * expr, char const * function, char const * file, long line) { throw siftfast_exception(str(boost::format("[%s:%d] -> %s, expr: %s")%file%line%function%expr)); } } #endif void translate_siftfast_exception(siftfast_exception const& e) { // Use the Python 'C' API to set up an exception object PyErr_SetString(PyExc_RuntimeError, e.what()); } inline object toPyArrayN(const float* pvalues, int N) { npy_intp dims[] = {N}; PyObject *pyvalues = PyArray_SimpleNew(1,dims, PyArray_FLOAT); if( pvalues != NULL ) memcpy(PyArray_DATA(pyvalues),pvalues,N*sizeof(float)); return static_cast(handle<>(pyvalues)); } template inline vector ExtractArray(object o) { vector v(len(o)); for(size_t i = 0; i < v.size(); ++i) v[i] = extract(o[i]); return v; } inline vector ExtractFloatArray(object oraw) { object o = oraw.attr("flat"); // check the types of o extract xr(o[0]); if( xr.check() ) return ExtractArray(o); vector v(len(o)); object onew = ((numeric::array)oraw).astype("f8").attr("flat"); for(size_t i = 0; i < v.size(); ++i) v[i] = (float)(extract(onew[i])); return v; } class PyImage { public: PyImage(int width, int height) : width(width), height(height) { BOOST_ASSERT(width>0&&height>0); stride = (width+3)&~3; vimage.resize(height*stride); } PyImage(object oimage) { object shape = oimage.attr("shape"); BOOST_ASSERT(len(shape)==2); width = extract(shape[1]); height = extract(shape[0]); stride = (width+3)&~3; vimage.resize(height*stride); SetData(oimage); } void SetData(object arr) { object shape = arr.attr("shape"); if( len(shape) != 2 ) throw siftfast_exception("array needs 2 dimensions"); if( height != extract(shape[0]) ) throw siftfast_exception("array rows do not match height"); if( width != extract(shape[1]) ) throw siftfast_exception("array columns do not match width"); string dtype = extract(arr.attr("dtype").attr("name")); if( (dtype.size() >= 3 && dtype[0] == 'i' && dtype[1] == 'n' && dtype[2] == 't') || (dtype.size() >= 4 && dtype[1] == 'i' && dtype[2] == 'n' && dtype[3] == 't') ) { extract xi(arr[0][0]); if( xi.check() ) { for(int i = 0; i < height; ++i) for(int j = 0; j < width; ++j) vimage[i*stride+j] = extract(arr[i][j])*(1.0f/255.0f); return; } } extract xr(arr[0][0]); if( xr.check() ) { for(int i = 0; i < height; ++i) for(int j = 0; j < width; ++j) vimage[i*stride+j] = extract(arr[i][j]); return; } extract xd(arr[0][0]); if( xd.check() ) { for(int i = 0; i < height; ++i) for(int j = 0; j < width; ++j) vimage[i*stride+j] = extract(arr[i][j]); return; } throw siftfast_exception("array not in correct format"); } int width,height,stride; vector vimage; }; class Image_pickle_suite : public pickle_suite { public: static tuple getinitargs(const PyImage& im) { return make_tuple(im.width,im.height,im.stride,toPyArrayN(&im.vimage[0],im.vimage.size())); } }; object PyGetKeypoints(PyImage& im) { struct ImageSt siftimage; siftimage.rows = im.height; siftimage.cols = im.width; siftimage.pixels = &im.vimage[0]; siftimage.stride = im.stride; Keypoint keypts = GetKeypoints(&siftimage); int numkeys = 0; Keypoint key = keypts; while(key) { numkeys++; key = key->next; } npy_intp dims[2] = {numkeys,4}; PyObject *pyframes = PyArray_SimpleNew(2,dims, PyArray_FLOAT); float* pframes = (float*)PyArray_DATA(pyframes); dims[1] = 128; PyObject *pydesc = PyArray_SimpleNew(2,dims, PyArray_FLOAT); float* pdesc = (float*)PyArray_DATA(pydesc); int index = 0; key = keypts; while(key) { for(int j = 0; j < 128; ++j) pdesc[128*index+j] = key->descrip[j]; pframes[4*index+0] = key->col; pframes[4*index+1] = key->row; pframes[4*index+2] = key->ori; pframes[4*index+3] = key->scale; key = key->next; ++index; } FreeKeypoints(keypts); DestroyAllImages(); return make_tuple(static_cast(handle<>(pyframes)),static_cast(handle<>(pydesc))); } object PyGetKeypoints(numeric::array oarray) { PyImage pimage(oarray); return PyGetKeypoints(pimage); } struct DummyStruct {}; struct int_from_int { int_from_int() { converter::registry::push_back(&convertible, &construct, type_id()); } static void* convertible( PyObject* obj) { PyObject* newobj = PyNumber_Int(obj); if (!PyString_Check(obj) && newobj) { Py_DECREF(newobj); return obj; } else { if (newobj) { Py_DECREF(newobj); } PyErr_Clear(); return 0; } } static void construct(PyObject* _obj, converter::rvalue_from_python_stage1_data* data) { PyObject* newobj = PyNumber_Int(_obj); int* storage = (int*)((converter::rvalue_from_python_storage*)data)->storage.bytes; *storage = extract(newobj); Py_DECREF(newobj); data->convertible = storage; } }; template struct T_from_number { T_from_number() { converter::registry::push_back(&convertible, &construct, type_id()); } static void* convertible( PyObject* obj) { PyObject* newobj = PyNumber_Float(obj); if (!PyString_Check(obj) && newobj) { Py_DECREF(newobj); return obj; } else { if (newobj) { Py_DECREF(newobj); } PyErr_Clear(); return 0; } } static void construct(PyObject* _obj, converter::rvalue_from_python_stage1_data* data) { PyObject* newobj = PyNumber_Float(_obj); T* storage = (T*)((converter::rvalue_from_python_storage*)data)->storage.bytes; *storage = extract(newobj); Py_DECREF(newobj); data->convertible = storage; } }; int GetDoubleImSize() { return DoubleImSize; } void SetDoubleImSize(int i) { DoubleImSize = i; } int GetScales() { return Scales; } void SetScales(int i) { Scales = i; } float GetInitSigma() { return InitSigma; } void SetInitSigma(float f) { InitSigma = f; } float GetPeakThresh() { return PeakThresh; } void SetPeakThresh(float f) { PeakThresh = f; } BOOST_PYTHON_MODULE(siftfastpy) { import_array(); numeric::array::set_module_and_type("numpy", "ndarray"); register_exception_translator(&translate_siftfast_exception); int_from_int(); T_from_number(); T_from_number(); def("DestroyAllResources",DestroyAllResources); object (*pkeypoints1)(PyImage&) = PyGetKeypoints; object (*pkeypoints2)(numeric::array) = PyGetKeypoints; def("GetKeypoints",pkeypoints1,args("image")); def("GetKeypoints",pkeypoints2,args("array")); class_("Image", no_init) .def(init()) .def(init()) .def_readonly("width",&PyImage::width) .def_readonly("height",&PyImage::height) .def("SetData",&PyImage::SetData,args("array")) .def_pickle(Image_pickle_suite()) ; { scope options = class_("options") .add_property("DoubleImSize",GetDoubleImSize,SetDoubleImSize) .add_property("Scales",GetScales,SetScales) .add_property("InitSigma",GetInitSigma,SetInitSigma) .add_property("PeakThresh",GetPeakThresh,SetPeakThresh) ; } } OTB-release-5.8/Modules/ThirdParty/SiftFast/src/siftmex.cpp000066400000000000000000000045031301006202600236170ustar00rootroot00000000000000// Copyright (C) zerofrog(@gmail.com), 2008-2009 // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // at your option) any later version. // //This program is distributed in the hope that it will be useful, //but WITHOUT ANY WARRANTY; without even the implied warranty of //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //Lesser GNU General Public License for more details. // //You should have received a copy of the GNU Lesser General Public License //along with this program. If not, see . #include "mex.h" #include #include #include #include using namespace std; #ifdef DVPROFILE #include "profiler.h" #endif #include "siftfast.h" typedef unsigned long long u64; // [frames,descr]=sift_mex(I,...) // takes an image and outputs frames and a descriptor void mexFunction(int nout, mxArray *out[], int nin, const mxArray *in[]) { if(nin == 0 || !mxIsDouble(in[0]) ) mexErrMsgTxt("sift_fast takes 1 argument: a grayscale image in real format "); const int* dimensions = mxGetDimensions(in[0]); Image image = CreateImageFromMatlabData(mxGetPr(in[0]), dimensions[0], dimensions[1]); Keypoint keypts = GetKeypoints(image); // write the keys to the output int numkeys = 0; Keypoint key = keypts; while(key) { numkeys++; key = key->next; } double* frames = NULL, *descr = NULL; if( nout > 0 ) { out[0] = mxCreateDoubleMatrix(4,numkeys,mxREAL); frames = mxGetPr(out[0]); } if( nout > 1 ) { out[1] = mxCreateDoubleMatrix(128,numkeys,mxREAL); descr = mxGetPr(out[1]); } key = keypts; while(key) { if( frames != NULL ) { frames[0] = key->col; frames[1] = key->row; frames[2] = key->scale; frames[3] = key->ori; frames += 4; } if( descr != NULL ) { for(int i = 0; i < 128; ++i) descr[i] = (double)key->descrip[i]; descr += 128; } key = key->next; } FreeKeypoints(keypts); #ifdef DVPROFILE DVProfWrite("prof.txt"); DVProfClear(); #endif DestroyAllImages(); } OTB-release-5.8/Modules/ThirdParty/SiftFast/src/test_try_compile_libsiftfast.cpp000066400000000000000000000001211301006202600301070ustar00rootroot00000000000000#include "libsiftfast.cpp" int main (int argc, char * argv[]) { return 0; } OTB-release-5.8/Modules/ThirdParty/TinyXML/000077500000000000000000000000001301006202600204245ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/TinyXML/CMake/000077500000000000000000000000001301006202600214045ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/TinyXML/CMake/otbTestTinyXMLUseSTL.cxx000066400000000000000000000002001301006202600260310ustar00rootroot00000000000000#include #include int main(int argc, char* argv[]) { TiXmlDocument doc( NULL ); std::cout << doc; } OTB-release-5.8/Modules/ThirdParty/TinyXML/CMakeLists.txt000066400000000000000000000014611301006202600231660ustar00rootroot00000000000000project(OTBTinyXML) # Check if we need to define TIXML_USE_STL try_compile( TIXML_USE_STL ${CMAKE_CURRENT_BINARY_DIR}/CMake ${CMAKE_CURRENT_SOURCE_DIR}/CMake/otbTestTinyXMLUseSTL.cxx CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:PATH=${TINYXML_INCLUDE_DIRS}" "-DLINK_LIBRARIES:STRING=${TINYXML_LIBRARIES}" COMPILE_DEFINITIONS "-DTIXML_USE_STL" OUTPUT_VARIABLE OUTPUT) configure_file( src/otb_tinyxml.h.in src/otb_tinyxml.h ) set(OTBTinyXML_SYSTEM_INCLUDE_DIRS ${TINYXML_INCLUDE_DIRS} ) set(OTBTinyXML_INCLUDE_DIRS ${OTBTinyXML_BINARY_DIR}/src ) set(OTBTinyXML_LIBRARIES "${TINYXML_LIBRARIES}" ) otb_module_impl() install(FILES ${OTBTinyXML_BINARY_DIR}/src/otb_tinyxml.h DESTINATION ${OTBTinyXML_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/ThirdParty/TinyXML/otb-module-init.cmake000066400000000000000000000000421301006202600244320ustar00rootroot00000000000000find_package ( TinyXML REQUIRED ) OTB-release-5.8/Modules/ThirdParty/TinyXML/otb-module.cmake000066400000000000000000000002501301006202600234720ustar00rootroot00000000000000set(DOCUMENTATION "This module imports TinyXML to the build system") otb_module(OTBTinyXML DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/ThirdParty/TinyXML/src/000077500000000000000000000000001301006202600212135ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/TinyXML/src/otb_tinyxml.h.in000066400000000000000000000012741301006202600243450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_tinyxml_h #define otb_tinyxml_h #ifndef TIXML_USE_STL #cmakedefine TIXML_USE_STL #endif #include "tinyxml.h" #endif OTB-release-5.8/Modules/ThirdParty/libkml/000077500000000000000000000000001301006202600203725ustar00rootroot00000000000000OTB-release-5.8/Modules/ThirdParty/libkml/CMakeLists.txt000066400000000000000000000002201301006202600231240ustar00rootroot00000000000000project(OTBlibkml) set(OTBlibkml_SYSTEM_INCLUDE_DIRS ${LIBKML_INCLUDE_DIRS}) set(OTBlibkml_LIBRARIES "${LIBKML_LIBRARIES}") otb_module_impl() OTB-release-5.8/Modules/ThirdParty/libkml/otb-module-init.cmake000066400000000000000000000000411301006202600243770ustar00rootroot00000000000000find_package ( LibKML REQUIRED ) OTB-release-5.8/Modules/ThirdParty/libkml/otb-module.cmake000066400000000000000000000003531301006202600234440ustar00rootroot00000000000000set(DOCUMENTATION "This module imports libkml to the build system") otb_module(OTBlibkml DEPENDS TEST_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) otb_module_activation_option("Enable libkml dependent modules" OFF) OTB-release-5.8/Modules/Visualization/000077500000000000000000000000001301006202600176675ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Ice/000077500000000000000000000000001301006202600203675ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Ice/CMakeLists.txt000066400000000000000000000001011301006202600231170ustar00rootroot00000000000000project(OTBIce) set(OTBIce_LIBRARIES OTBIce) otb_module_impl() OTB-release-5.8/Modules/Visualization/Ice/README000066400000000000000000000022561301006202600212540ustar00rootroot00000000000000--------------------- Ice in a nuttshell ---------------------- ICE is a fast OpenGl rendering API for remote sensing images. This small piece of code decomposes into an OTB/OpenGl only library with an API for simple rendering of remote sensing images and a GLFW3 example of how to use the API. --------------------- Installation ---------------------- Dependencies: - OTB (>= 4.0) - OpenGl - GLFW (>= 3.0) ------------------------- Platform specific issues ------------------------- OSX (10.9) Mavericks Requires: XQuartz (http://xquartz.macosforge.org/landing/) because it includes freeGLUT. Therefore in cmake, the following variables need to point to the correct places: GLUT_INCLUDE_DIR=/usr/X11R6/include GLUT_glut_LIBRARY=/usr/X11R6/lib/libglut.dylib ---------------------- Command Line Arguments ---------------------- Usage: ./otbIce img1 ... imgN Press F1 for help ---------------------- Acknowledgement ---------------------- The authors would like to thank Gabriele Facciolo (CMLA) and the authors of pvflip (https://github.com/gfacciol/pvflip/) for the seed discussion about float32 OpenGl textures and OpenGl Shading Language which greatly contributed to the dawn of Ice. OTB-release-5.8/Modules/Visualization/Ice/RELEASE_NOTES.txt000066400000000000000000000012611301006202600231600ustar00rootroot00000000000000Ice v.0.4.0 - Changes since version 0.3.0 (2015/12/22) ------------------------------------------ * Features; * Split otb::GlImageActor::GetPixelFromView() in two methods * Added new otb::GlImageView::ZoomTo*() methods * Various code optimizations * Various fixes of coverity detected issues * Adding optimization user entry points in otb::GlImageActor: * Choice of resolution look-up algorithm * Allow for tile size tuning * Add a software rendering mode (based on OTB filters, disabled by default) * Bug fixed: * Fixed bug in resolution reading, that prevented the last overview to be read * 0001078: Fixed initialization of transforms in otb::GlImageActor ( OTB-release-5.8/Modules/Visualization/Ice/include/000077500000000000000000000000001301006202600220125ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Ice/include/otbFragmentShader.h000066400000000000000000000035651301006202600255730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_FragmentShader_h #define otb_FragmentShader_h #include "OTBIceExport.h" #include #include namespace otb { class OTBIce_EXPORT FragmentShader : public itk::Object { public: typedef FragmentShader Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Point PointType; void LoadShader(); virtual void SetupShader(); void UnloadShader(); itkSetMacro(UL,PointType); itkSetMacro(UR,PointType); itkSetMacro(LL,PointType); itkSetMacro(LR,PointType); itkGetConstReferenceMacro(UL,PointType); itkGetConstReferenceMacro(UR,PointType); itkGetConstReferenceMacro(LL,PointType); itkGetConstReferenceMacro(LR,PointType); protected: FragmentShader(); ~FragmentShader() ITK_OVERRIDE; void BuildShader(); virtual std::string GetSource() const = 0; virtual std::string GetName() const = 0; private: // prevent implementation FragmentShader(const Self&); void operator=(const Self&); PointType m_UL; PointType m_UR; PointType m_LL; PointType m_LR; }; // End class FragmentShader } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbFragmentShaderRegistry.h000066400000000000000000000034711301006202600273200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_FragmentShaderRegistry_h #define otb_FragmentShaderRegistry_h #include "itkObject.h" #include "itkObjectFactory.h" namespace otb { class FragmentShaderRegistry : public itk::Object { public: typedef FragmentShaderRegistry Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; static Pointer Instance(); void RegisterShader(const std::string& name, const std::string& source); bool UnregisterShader(const std::string& name); bool IsShaderRegistered(const std::string& name) const; bool LoadShader(const std::string& name); void UnloadShader(); void ClearShaders(); unsigned int GetShaderProgram(const std::string& name); protected: FragmentShaderRegistry(); ~FragmentShaderRegistry() ITK_OVERRIDE; private: typedef std::map > ShaderMapType; itkNewMacro(Self); // prevent implementation FragmentShaderRegistry(const Self&); void operator=(const Self&); static Pointer m_Instance; ShaderMapType m_ShaderMap; }; // End class FragmentShaderRegistry } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbGeoInterface.h000066400000000000000000000063531301006202600252320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_GeoInterface_h #define otb_GeoInterface_h #include #include #include "OTBIceExport.h" namespace otb { class ImageKeywordlist; /** * @class This class is the abstract interface for actors which need * geo-referenced methods. * * Use multiple inheritance to provide geo-referenced interface to * specialized actors. * * Example: Derive otb::GlMyActor : public otb::GlActor, public * otb::GeoInterface {}; * * By default, single-prevision methods are implemented as conversion * method from otb::GeoInterface::Point2f to * otb::GeoInterface::Point2d. Derived otb::GlActor classes must * implement double-prevision methods. */ class OTBIce_EXPORT GeoInterface { public: /** */ typedef itk::Point< itk::SpacePrecisionType, 2 > Point2; /** * Double precision point-type. */ typedef itk::Point< double, 2 > Point2d; /** * Spacing-type based on ITK floating-point prevision. */ typedef itk::Vector< itk::SpacePrecisionType, 2 > Spacing2; /** * Transform given point from viewport coordinate-system to this * actor coordinate-system. * * By default this method return false. It should be implemented in * derived classes if needed. * * @param out The transformed point (in this actor coordinate-system). * @param in The given point (in viewport coordinate-system). * @param isPhysical Indicate physical coordates are desired. * * @return true if the operation has succeeded; false otherwise. */ virtual bool TransformFromViewport( Point2d & out, const Point2d & in, bool isPhysical = true ) const; /** * Transform given point from viewport coordinate-system to this * actor coordinate-system. * * By default this method return false. It should be implemented in * derived classes if needed. * * @param out The transformed point (in this actor coordinate-system). * @param in The given point (in viewport coordinate-system). * @param isPhysical Indicate physical coordates are desired. * * @return true if the operation has succeeded; false otherwise. */ virtual bool TransformToViewport( Point2d & out, const Point2d & in, bool isPhysical = true ) const; /** */ virtual const Spacing2 & GetSpacing() const; /** */ virtual std::string GetWkt() const; /** */ virtual bool HasKwl() const; /** */ virtual bool GetKwl( ImageKeywordlist & ) const; protected: GeoInterface(); virtual ~GeoInterface(); private: }; // End class GeoInterface } // End namespace otb #endif // otb_GeoInterface_h OTB-release-5.8/Modules/Visualization/Ice/include/otbGlActor.h000066400000000000000000000044201301006202600242230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_GlActor_h #define otb_GlActor_h #include #include "otbViewSettings.h" #include "OTBIceExport.h" namespace otb { class OTBIce_EXPORT GlActor : public itk::Object { public: typedef GlActor Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkSetObjectMacro(Settings,ViewSettings); itkGetObjectMacro(Settings,ViewSettings); itkGetConstObjectMacro(Settings,ViewSettings); itkSetMacro(Visible,bool); itkGetMacro(Visible,bool); itkBooleanMacro(Visible); itkSetStringMacro(Name); itkGetStringMacro(Name); itkSetMacro( GeometryChanged, bool ); itkGetMacro( GeometryChanged, bool ); itkBooleanMacro( GeometryChanged ); itkSetMacro( Overlay, bool ); itkGetMacro( Overlay, bool ); itkBooleanMacro( Overlay ); // Retrieve the full extent of the actor virtual void GetExtent(double & ulx, double & uly, double & lrx, double & lry) const = 0; // Update internal actor state with respect to ViewSettings virtual void ProcessViewSettings() = 0; // Heavy load/unload operations of data virtual void UpdateData() = 0; // Gl rendering of current state virtual void Render() = 0; protected: GlActor(); ~GlActor() ITK_OVERRIDE; private: // prevent implementation GlActor(const Self&); void operator=(const Self&); ViewSettings::Pointer m_Settings; // Name field std::string m_Name; // Visibility flag bool m_Visible: 1; /** */ bool m_GeometryChanged: 1; /** */ bool m_Overlay: 1; }; // End class GlActor } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbGlImageActor.h000066400000000000000000000222001301006202600251620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_GlImageActor_h #define otb_GlImageActor_h #include #include "itkCenteredRigid2DTransform.h" #include "otbFragmentShader.h" #include "otbGenericRSTransform.h" #include "otbGeoInterface.h" #include "otbGlActor.h" #include "otbImageFileReader.h" #include "otbImageSettings.h" #include "otbMultiChannelExtractROI.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbVectorImage.h" namespace otb { class OTBIce_EXPORT GlImageActor : public GlActor, public GeoInterface { public: typedef GlImageActor Self; typedef GlActor Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); typedef VectorImage VectorImageType; typedef VectorImage UCharVectorImageType; typedef VectorImageType::PixelType PixelType; typedef VectorImageType::ImageKeywordlistType ImageKeywordlistType; typedef itk::MetaDataDictionary MetaDataDictionaryType; typedef VectorImageType::SizeType SizeType; typedef VectorImageType::IndexType IndexType; typedef VectorImageType::RegionType RegionType; typedef VectorImageType::SpacingType SpacingType; typedef VectorImageType::PointType PointType; typedef VectorRescaleIntensityImageFilter RescaleFilterType; struct ResolutionAlgorithm { enum type { Invalid, Nearest, ///m_RedIdx != idx ) { this->m_RedIdx = vcl_min(this->GetNumberOfComponents(),idx); this->Modified(); } } virtual void SetGreenIdx(const unsigned int idx) { if ( this->m_GreenIdx != idx ) { this->m_GreenIdx = vcl_min(this->GetNumberOfComponents(),idx); this->Modified(); } } virtual void SetBlueIdx(const unsigned int idx) { if ( this->m_BlueIdx != idx ) { this->m_BlueIdx = vcl_min(this->GetNumberOfComponents(),idx); this->Modified(); } } PointType ViewportToImageTransform(const PointType & in, bool physical = true) const; PointType ImageToViewportTransform(const PointType & in, bool physical = true) const; bool GetPixelFromViewport( const PointType & in, PixelType & pixel ) const; bool GetPixelFromViewport( const PointType & view, PixelType & pixel, PointType & physical, IndexType & index ) const; bool GetPixel( const PointType & physical, PixelType & pixel, IndexType & index ) const; itkGetObjectMacro(Shader,FragmentShader); itkSetObjectMacro(Shader,FragmentShader); itkGetObjectMacro( ImageSettings, ImageSettings ); // // otb::GlActor overloads. // bool TransformFromViewport( Point2d & out, const Point2d & in, bool isPhysical = true ) const ITK_OVERRIDE; bool TransformToViewport( Point2d & out, const Point2d & in, bool isPhysical = true ) const ITK_OVERRIDE; void UpdateTransforms(); protected: GlImageActor(); ~GlImageActor() ITK_OVERRIDE; typedef ImageFileReader ReaderType; typedef MultiChannelExtractROI ExtractROIFilterType; typedef otb::GenericRSTransform<> RSTransformType; typedef itk::CenteredRigid2DTransform<> RigidTransformType; typedef std::vector ResolutionVectorType; // Internal class to hold tiles class Tile { public: Tile() : m_Loaded(false), m_TextureId(0), m_ImageRegion(), m_TileSize(0), m_Image(), m_UL(), m_UR(), m_LL(), m_LR(), m_Resolution(1), m_RedIdx(1), m_GreenIdx(2), m_BlueIdx(3), m_RescaleFilter(ITK_NULLPTR) { m_UL.Fill(0); m_UR.Fill(0); m_LL.Fill(0); m_LR.Fill(0); } bool m_Loaded; unsigned int m_TextureId; RegionType m_ImageRegion; unsigned int m_TileSize; VectorImageType::Pointer m_Image; PointType m_UL; PointType m_UR; PointType m_LL; PointType m_LR; unsigned int m_Resolution; unsigned int m_RedIdx; unsigned int m_GreenIdx; unsigned int m_BlueIdx; RescaleFilterType::Pointer m_RescaleFilter; }; typedef std::vector TileVectorType; private: // prevent implementation GlImageActor(const Self&); void operator=(const Self&); // Load tile to GPU void LoadTile(Tile& tile); // Unload tile from GPU void UnloadTile(Tile& tile); // Clean the loaded tiles, getting rid of unnecessary ones void CleanLoadedTiles(); // Clear all loaded tiles void ClearLoadedTiles(); // Is tile loaded ? bool TileAlreadyLoaded(const Tile& tile); void ImageRegionToViewportExtent(const RegionType& region, double & ulx, double & uly, double & lrx, double& lry) const; void ImageRegionToViewportQuad(const RegionType & region, PointType & ul, PointType & ur, PointType & ll, PointType & lr, bool rotate = true) const; void ViewportExtentToImageRegion(const double& ulx, const double & uly, const double & lrx, const double & lry, RegionType & region) const; void UpdateResolution(); unsigned int m_TileSize; std::string m_FileName; ReaderType::Pointer m_FileReader; TileVectorType m_LoadedTiles; unsigned int m_RedIdx; unsigned int m_GreenIdx; unsigned int m_BlueIdx; unsigned int m_CurrentResolution; ResolutionVectorType m_AvailableResolutions; PointType m_Origin; SpacingType m_Spacing; RegionType m_LargestRegion; unsigned int m_NumberOfComponents; ImageSettings::Pointer m_ImageSettings; FragmentShader::Pointer m_Shader; RSTransformType::Pointer m_ViewportToImageTransform; RSTransformType::Pointer m_ImageToViewportTransform; RigidTransformType::Pointer m_ViewportForwardRotationTransform; RigidTransformType::Pointer m_ViewportBackwardRotationTransform; ResolutionAlgorithm::type m_ResolutionAlgorithm; bool m_SoftwareRendering; }; // End class GlImageActor } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbGlROIActor.h000066400000000000000000000061401301006202600245760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_GlROIActor_h #define otb_GlROIActor_h #include "otbGlActor.h" #include "otbGenericRSTransform.h" #include "otbFragmentShader.h" #include "otbImageKeywordlist.h" #include "itkImageRegion.h" #include "itkVector.h" namespace otb { class OTBIce_EXPORT GlROIActor : public GlActor { public: typedef GlROIActor Self; typedef GlActor Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef ImageKeywordlist ImageKeywordlistType; typedef itk::ImageRegion<2> ImageRegionType; typedef otb::GenericRSTransform<> RSTransformType; typedef RSTransformType::InputPointType PointType; typedef itk::Vector ColorType; itkNewMacro(Self); // Retrieve the full extent of the actor void GetExtent(double & ulx, double & uly, double & lrx, double & lry) const ITK_OVERRIDE; // Update internal actor state with respect to ViewSettings void ProcessViewSettings() ITK_OVERRIDE; // Heavy load/unload operations of data void UpdateData() ITK_OVERRIDE; // Gl rendering of current state void Render() ITK_OVERRIDE; void SetUL( const PointType & ); itkGetConstReferenceMacro(UL,PointType); void SetLR( const PointType & ); itkGetConstReferenceMacro(LR,PointType); itkSetStringMacro(Wkt); itkGetStringMacro(Wkt); void SetKwl(const ImageKeywordlistType & kwl); itkGetConstReferenceMacro(Kwl,ImageKeywordlistType); itkSetMacro(Color,ColorType); itkGetConstReferenceMacro(Color,ColorType); itkSetMacro(Alpha,double); itkGetConstReferenceMacro(Alpha,double); itkSetMacro(Fill,bool); itkGetMacro(Fill,bool); itkBooleanMacro(Fill); protected: GlROIActor(); ~GlROIActor() ITK_OVERRIDE; private: // prevent implementation GlROIActor(const Self&); void operator=(const Self&); void UpdateTransforms(); PointType m_UL; PointType m_LR; std::string m_Wkt; ImageKeywordlistType m_Kwl; ColorType m_Color; double m_Alpha; bool m_Fill; RSTransformType::Pointer m_ViewportToImageTransform; RSTransformType::Pointer m_ImageToViewportTransform; PointType m_VpUL; PointType m_VpUR; PointType m_VpLL; PointType m_VpLR; }; // End class GlROIActor } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbGlVectorActor.h000066400000000000000000000114351301006202600254120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_GlVectorActor_h #define otb_GlVectorActor_h #include "otbGenericRSTransform.h" #include "otbGeoInterface.h" #include "otbGlActor.h" #include "otbOGRDataSourceWrapper.h" #include "otbOGRFeatureWrapper.h" #include "otbOGRLayerWrapper.h" #include "itkCenteredRigid2DTransform.h" #include "itkVector.h" // Forward declaration of GLUtesselator class GLUtesselator; namespace otb { class OTBIce_EXPORT GlVectorActor : public GlActor, public GeoInterface { public: typedef GlVectorActor Self; typedef GlActor Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::GenericRSTransform<> RSTransformType; typedef RSTransformType::InputPointType PointType; typedef itk::Vector ColorType; typedef itk::CenteredRigid2DTransform<> RigidTransformType; itkNewMacro(Self); // Initialize with a new file void Initialize(const std::string & filename, const std::string & layername = ""); // Get all available layers std::vector GetAvailableLayers() const; // Get layer name std::string GetCurrentLayer() const; // Set layer name void SetCurrentLayer(const std::string & layername); // Retrieve the full extent of the actor void GetExtent(double & ulx, double & uly, double & lrx, double & lry) const ITK_OVERRIDE; // Return actor extent in its own geometry void GetBoundingBox(double & ulx, double & uly, double & lrx, double & lry) const; // Update internal actor state with respect to ViewSettings void ProcessViewSettings() ITK_OVERRIDE; // Heavy load/unload operations of data void UpdateData() ITK_OVERRIDE; // Gl rendering of current state void Render() ITK_OVERRIDE; PointType ViewportToVectorTransform(const PointType & point) const; itkSetMacro(Color,ColorType); itkGetConstReferenceMacro(Color,ColorType); itkSetMacro(Alpha,double); itkGetConstReferenceMacro(Alpha,double); void SetFill(bool flag); itkGetMacro(Fill,bool); itkBooleanMacro(Fill); void SetSolidBorder(bool flag); itkGetMacro(SolidBorder,bool); itkBooleanMacro(SolidBorder); void SetOptimizedRendering(bool flag); itkGetMacro(OptimizedRendering,bool); itkBooleanMacro(OptimizedRendering); itkGetMacro(OptimizedRenderingActive,bool); itkSetMacro(LineWidth,double); itkGetConstReferenceMacro(LineWidth,double); std::string GetWkt() const ITK_OVERRIDE; // // otb::GlActor overloads. // bool TransformFromViewport( Point2d & out, const Point2d & in, bool isPhysical = true ) const ITK_OVERRIDE; protected: GlVectorActor(); ~GlVectorActor() ITK_OVERRIDE; // Internal class to hold tiles class InternalFeature { public: InternalFeature(OGRFeatureDefn & definition) : m_SourceFeature(definition), m_RenderedFeature(definition) {} otb::ogr::Feature m_SourceFeature; otb::ogr::Feature m_RenderedFeature; }; private: // prevent implementation GlVectorActor(const Self&); void operator=(const Self&); void InternalFeaturesTransform(); void UpdateTransforms(); void UpdateDisplayList(); ColorType m_Color; double m_Alpha; bool m_Fill; bool m_SolidBorder; double m_LineWidth; RSTransformType::Pointer m_ViewportToVectorTransform; RSTransformType::Pointer m_VectorToViewportTransform; otb::ogr::DataSource::Pointer m_OGRDataSource; std::string m_CurrentLayer; std::vector m_InternalFeatures; GLUtesselator * m_GluTesselator; unsigned int m_DisplayList; bool m_DisplayListNeedsRebuild; double m_ExtentULX; double m_ExtentULY; double m_ExtentLRX; double m_ExtentLRY; bool m_OptimizedRendering; bool m_OptimizedRenderingActive; unsigned int m_PointMarkerSize; RigidTransformType::Pointer m_ViewportForwardRotationTransform; RigidTransformType::Pointer m_ViewportBackwardRotationTransform; }; // End class GlVectorActor } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbGlVersionChecker.h000066400000000000000000000073171301006202600260750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_GlVersionChecker_h #define otb_GlVersionChecker_h #include "OTBIceExport.h" namespace otb { class OTBIce_EXPORT GlVersionChecker { public: /** * Constant containing required OpenGL version for * client-application feedback messages. */ static const char * REQUIRED_GL_VERSION; /** * Constant containing required shading-language version for * client-application feedback messages. */ static const char * REQUIRED_GLSL_VERSION; /** * \return The OpenGL version used at runtime. The call to this * method requires a valid OpenGL rendering context. An * std::runtime_error() is thrown when glGetError() is different * than GL_NO_ERROR. */ static const char * GLVersion(); /** * \return The OpenGL Shading-Language version used at runtime. The * call to this method requires a valid OpenGL rendering context. An * std::runtime_error() is thrown when glGetError() is different * than GL_NO_ERROR. This method uses GL_SHADING_LANGUAGE_VERSION * which is available only if the OpenGL version is greater than * 2.0. (@see * http://www.opengl.org/sdk/docs/man2/xhtml/glGetString.xml). */ static const char * GLSLVersion(); /** * \brief Check that OpenGL required capabilities have been reached. * * \param glVersion The returned OpenGL version or NULL * if its query has failed. * * \param glslVersion The returned OpenGL Shading-Language version * or NULL if its query has failed. * * \return true if OpengGL capabilities of running platform meets * the needs of the library. */ static bool CheckGLCapabilities( const char * & glVersion, const char * & glslVersion ); /** * \brief Compares to version-strings on the model of strcmp(). * * \param Left hand-side version string (runtime). If * NULL, version-string is considered 0.0.0. (\see * GlVersionChecker::SplitVersion()). * * \param Right hande-side version string (required). If * NULL, version-string is considered 0.0.0. (\see * GlVersionChecker::SplitVersion()). * * \return -1 if version0 if * version==required; +1 if version>=required. */ static int VerCmp( const char * version, const char * required ); private: // Prevent instantiation GlVersionChecker(); ~GlVersionChecker(); GlVersionChecker(const GlVersionChecker&); void operator=(const GlVersionChecker&); /** * \brief Split version string into Major.minor.release triplet. * * \param version String to split into triplet. If NULL * or empty, triplet is 0.0.0. * \param major Major number of resulting version triplet. * \param minor Minor number of resulting version triplet. * \param release Release number of resulting version triplet. * * \return true if operation has succeeded, * false otherwise. */ static bool SplitVersion( const char * version, int& major, int& minor, int& release ); }; } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbGlView.h000066400000000000000000000450211301006202600240670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_GlView_h #define otb_GlView_h #include "otbGeoInterface.h" #include "otbGlActor.h" #include "otbViewSettings.h" #include #include #include namespace otb { template< typename T > void assert_quiet_NaN( T val ) { assert( !std::numeric_limits< T >::has_quiet_NaN || ( std::numeric_limits< T >::has_quiet_NaN && val!=std::numeric_limits< T >::quiet_NaN() ) ); // make production build happy ((void)val); } template< typename T > void assert_signaling_NaN( T val ) { assert( !std::numeric_limits< T >::has_signaling_NaN || ( std::numeric_limits< T >::has_signaling_NaN && val!=std::numeric_limits< T >::signaling_NaN() ) ); // make production build happy ((void)val); } template< typename T > void assert_NaN( T val ) { assert_quiet_NaN( val ); assert_signaling_NaN( val ); // make production build happy ((void)val); } /** * The GlView class acts like an OpenGl scene where actors deriving * from the GlActor class can be rendered. The GlView class contains the * OpenGl viewport and manages: * - The size of the viewport, * - The entire refresh loop, including light or heavy rendering of * all actors and all OpenGl specific stuff needed before and after * the actors update, * - The actors stack (order in which actors are rendered). * * All parameters related to scene description (origin, spacing, angle * ...) are stored and managed by the ViewSettings class. */ class OTBIce_EXPORT GlView : public itk::Object { public: typedef GlView Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::GlActor ActorType; typedef std::map ActorMapType; typedef std::vector StringVectorType; /** * Type definition for otb::GlActor storage key. */ typedef StringVectorType::value_type KeyType; itkNewMacro(Self); /** * The Initialize method will reset the OpenGl viewport to the given * size, clear view settings and remove any existing actor. * \param sx Width of the viewport * \param sy Height of the viewport */ void Initialize(unsigned int sx, unsigned int sy); /** * This method allows adding a new actor (deriving from GlActor) to * the GlView. The actor can be identified by an optional key. If * not provided, and the default value is used, the method will * generate a key to identify the actor. In both case, the key is * returned by the method. * \param actor The actor to be added * \param key The key to be used to identify the actor (default to * empty string) * \return The key identifying the actor (either passed to the * method or generated by it). */ std::string AddActor(ActorType * actor, const std::string & key = ""); /** * This method will try to remove the actor identified by the given * key. * \param key The key identifying the actor to remove * \return True if the actor has been found and removed, false * otherwise */ bool RemoveActor(const std::string & key); /** * This method will remove all existing actors at once. */ void ClearActors(); /** * This method allows retrieving a pointer to the actor identified * by the given key. * \param key The key identifying the actor to retrieve * \return A pointer to the retrieved actor. This pointer will be * null if no actor could be found with this key. */ ActorType::Pointer GetActor(const std::string & key) const; /** * Tells whether an otb::GlActor is contained given its storage key. * * @param key otb::GlActor storage key. * * @return true if an otb::GlActor is contained given storage key. */ bool ContainsActor( const KeyType & key ) const; /** * This method will return a vector containing the keys of all * actors. * \return A vector of string containing the keys of all actors. */ std::vector GetActorsKeys() const; /** * This method handles all the things that should be done before * rendering. */ void BeforeRendering(); /** * This method handles all the things that should be after before * rendering. */ void AfterRendering(); /** * This method will update the rendering of the OpenGl viewport, * taking into account all parameters in the ViewSettings, without * fetching any missing data from disk or RAM. It is therefore very * fast. */ void LightRender(); /** * This method will update the rendering of the OpenGl viewport, * taking into account all parameters in the ViewSettings, but will * first compute and load any missing data for a complete * rendering. As such, this update routine can be time consuming. */ void HeavyRender(); // Resize viewport void Resize(unsigned int sx, unsigned int sy); itkSetObjectMacro(Settings,ViewSettings); itkGetObjectMacro(Settings,ViewSettings); itkGetConstObjectMacro(Settings,ViewSettings); //comment this macro (not compiling with OTB 3.X) // Get Rendering order const StringVectorType & GetRenderingOrder() const { return m_RenderingOrder; }; /** * Arbitrary set the rendering order of some or all of contained * otb::GlActor instances. * * Keys which are not contained will be ignored. * * @param keys The ordered sequence of keys. * @param front true to order selected otb::GlActor * instances in front of non-selected ones. */ void SetRenderingOrder( const StringVectorType & keys, bool front ); // This will rotate the rendering order (without modifying the order) void RotateRenderingOrder(bool down = false); // Move actor in rendering order void MoveActorInRenderingOrder(std::string key, bool down = false); // Move actor to the end of rendering order (either front if front // is set to true or back if front is set to false) void MoveActorToEndOfRenderingOrder(std::string key, bool front = false); /** * Reproject point and spacing expressed in viewport coordinate * system into given actor coordinate system. */ template< typename P, typename S, typename P2, typename S2 > bool ReprojectFromView( P & center, S & spacing, const KeyType & key, const P2 & vcenter, const S2 & vspacing, double norm = 1000.0 ) const; /** */ template< typename P > size_t GetExtent( P & origin, P & extent, bool isOverlay =false ) const; /** */ template< typename Point, typename Spacing > bool ZoomToExtent( const Spacing & native, Point & center, Spacing & spacing ) const; /** */ template< typename Point, typename Spacing > bool ZoomToLayer( const KeyType & key, const Spacing & native, Point & center, Spacing & spacing ) const; /** */ template< typename Point, typename Spacing > bool ZoomToRegion( const Point & origin, const Point & extent, const Spacing & native, Point & center, Spacing & spacing ) const; /** */ template< typename Point, typename Spacing > bool ZoomToFull( const KeyType & key, Point & center, Spacing & spacing, double units = 1000.0 ) const; /** */ void SaveScreenshot( const std::string & filename ) const; protected: GlView(); ~GlView() ITK_OVERRIDE; private: // prevent implementation GlView(const Self&); void operator=(const Self&); ViewSettings::Pointer m_Settings; ActorMapType m_Actors; StringVectorType m_RenderingOrder; }; // End class GlView template< typename P, typename S, typename P2, typename S2 > bool GlView ::ReprojectFromView( P & center, S & spacing, const KeyType & key, const P2 & vcenter, const S2 & vspacing, double norm ) const { // std::cout << "otb::GlView@" << std::hex << this << std::endl << "{" << std::endl; assert_NaN( vcenter[ 0 ] ); assert_NaN( vcenter[ 1 ] ); assert_NaN( vspacing[ 0 ] ); assert_NaN( vspacing[ 1 ] ); // // Reference actor has not been found. otb::GlActor::Pointer actor( GetActor( key ) ); if( actor.IsNull() ) return false; // // Reference actor does not implement geo-interface. const otb::GeoInterface * geo = dynamic_cast< const GeoInterface * >( actor.GetPointer() ); if( geo==ITK_NULLPTR ) return false; // // Compute transform origin. if( !geo->TransformFromViewport( center, vcenter, true ) ) return false; // // Compute transformed X-axis extremity. GeoInterface::Point2d x( vcenter ); x[ 0 ] += norm * vspacing[ 0 ]; // std::cout << "X {" << std::endl; if( !geo->TransformFromViewport( x, x, true ) ) return false; // std::cout << "x: " << x[ 0 ] << ", " << x[ 1 ] << std::endl; // assert_NaN( x[ 0 ] ); // assert_NaN( x[ 1 ] ); // std::cout << "}" << std::endl; // // Compute transformed Y-axis extremity. GeoInterface::Point2d y( vcenter ); y[ 1 ] += norm * vspacing[ 1 ]; // std::cout << "Y {" << std::endl; if( !geo->TransformFromViewport( y, y, true ) ) return false; // std::cout << "y: " << y[ 0 ] << ", " << y[ 1 ] << std::endl; // assert_NaN( y[ 0 ] ); // assert_NaN( y[ 1 ] ); // std::cout << "}" << std::endl; // // Compute transformed spacing. // // Note SAT: // Formula has been taken from IceViewer::key_callback(). I think // that the norm of the transformed X and Y axises is not // the new spacing if transform contains a rotation. // To correct this, transformed X and Y vectors should be // projected against reference actor X and Y axises (using vectorial // dot product). x[ 0 ] -= center[ 0 ]; x[ 1 ] -= center[ 1 ]; y[ 0 ] -= center[ 0 ]; y[ 1 ] -= center[ 1 ]; spacing[ 0 ] = vcl_sqrt( x[ 0 ] * x[ 0 ] + x[ 1 ] * x[ 1 ] ) / norm; spacing[ 1 ] = vcl_sqrt( y[ 0 ] * y[ 0 ] + y[ 1 ] * y[ 1 ] ) / norm; // Sign of x-spacing is done by sign( x . (1, 0) ) which is sign( x[ 0 ] ) // Sign of y-spacing is done by sign( y . (0, 1) ) which is sign[ y[ 1 ] ) if( x[ 0 ]<0.0 ) spacing[ 0 ] = -spacing[ 0 ]; if( y[ 1 ]<0.0 ) spacing[ 1 ] = -spacing[ 1 ]; // // Chech outputs. assert_NaN( center[ 0 ] ); assert_NaN( center[ 1 ] ); assert_NaN( spacing[ 0 ] ); assert_NaN( spacing[ 1 ] ); // std::cout << "} otb::GlView@" << std::hex << this << std::endl; // // Ok. return true; } template< typename P > size_t GlView ::GetExtent( P & origin, P & extent, bool isOverlay ) const { if( m_Actors.empty() ) { origin.Fill( 0 ); extent.Fill( 0 ); return 0; } origin[ 0 ] = std::numeric_limits< typename P::ValueType >::infinity(); origin[ 1 ] = std::numeric_limits< typename P::ValueType >::infinity(); extent[ 0 ] = -std::numeric_limits< typename P::ValueType >::infinity(); extent[ 1 ] = -std::numeric_limits< typename P::ValueType >::infinity(); size_t count = 0; for( ActorMapType::const_iterator it( m_Actors.begin() ); it!=m_Actors.end(); ++it ) { assert( !it->second.IsNull() ); if( it->second->GetOverlay()==isOverlay ) { P o; P e; o.Fill( 0 ); e.Fill( 0 ); it->second->GetExtent( o[ 0 ], o[ 1 ], e[ 0 ], e[ 1 ] ); if( o[ 0 ]extent[ 0 ] ) extent[ 0 ] = o[ 0 ]; if( o[ 1 ]>extent[ 1 ] ) extent[ 1 ] = o[ 1 ]; if( e[ 0 ]extent[ 0 ] ) extent[ 0 ] = e[ 0 ]; if( e[ 1 ]>extent[ 1 ] ) extent[ 1 ] = e[ 1 ]; ++ count; } } if( count==0 ) { origin.Fill( 0 ); extent.Fill( 0 ); } return count; } template< typename Point, typename Spacing > bool GlView ::ZoomToExtent( const Spacing & native, Point & center, Spacing & spacing ) const { Point o; Point e; o.Fill( 0 ); e.Fill( 0 ); // Get origin and extent of all layers in viewport system. if( GetExtent( o, e )==0 ) return false; // std::cout << "origin: [ " << o[ 0 ] << ", " << o[ 1 ] << " ]" << std::endl; // std::cout << "extent: [ " << e[ 0 ] << ", " << e[ 1 ] << " ]" << std::endl; // Zoom to overall region. return ZoomToRegion( o, e, native, center, spacing ); } template< typename Point, typename Spacing > bool GlView ::ZoomToLayer( const KeyType & key, const Spacing & native, Point & center, Spacing & spacing ) const { Point o; Point e; // Get layer actor. GlActor::Pointer actor( GetActor( key ) ); // If not found... if( actor.IsNull() ) return false; // Get origin and extent of layer. actor->GetExtent( o[ 0 ], o[ 1 ], e[ 0 ], e[ 1 ] ); // Zoom layer region. return ZoomToRegion( o, e, native, center, spacing ); } template< typename Point, typename Spacing > bool GlView ::ZoomToRegion( const Point & origin, const Point & extent, const Spacing & native, Point & center, Spacing & spacing ) const { // std::cout // << std::hex << this << std::dec // << "::ZoomToRegion( " // << "[" << origin[ 0 ] << ", " << origin[ 1 ] << "], " // << "[" << extent[ 0 ] << ", " << extent[ 1 ] << "], " // << "[" << native[ 0 ] << ", " << native[ 1 ] << "] )" // << std::endl; // Compute center point. center.SetToMidPoint( origin, extent ); // std::cout << "-> center: " << center[ 0 ] << ", " << center[ 1 ] << std::endl; // Get scale of (o, e) in viewport. assert( !m_Settings.IsNull() ); double scale = m_Settings->GetScale( origin, extent, true ); // std::cout << "-> scale: " << scale << std::endl; /* assert( !std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() || ( std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() && native[ 0 ]!=std::numeric_limits< typename Spacing::ValueType >::quiet_NaN() ) ); assert( !std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() || ( std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() && native[ 1 ]!=std::numeric_limits< typename Spacing::ValueType >::quiet_NaN() ) ); assert( !std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() || ( std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() && native[ 0 ]!=std::numeric_limits< typename Spacing::ValueType >::quiet_NaN() ) ); assert( !std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() || ( std::numeric_limits< typename Spacing::ValueType >::has_quiet_NaN() && native[ 1 ]!=std::numeric_limits< typename Spacing::ValueType >::quiet_NaN() ) ); */ // Apply signed scale. spacing[ 0 ] = ( native[ 0 ]<0.0 ? -1 : +1 ) * scale; spacing[ 1 ] = ( native[ 1 ]<0.0 ? -1 : +1 ) * scale; // std::cout << "-> spacing: " << spacing[ 0 ] << ", " << spacing[ 1 ] << std::endl; // Ok. return true; } template< typename Point, typename Spacing > bool GlView ::ZoomToFull( const KeyType & key, Point & center, Spacing & spacing, double units ) const { // std::cout // << std::hex << this << std::dec // << "::ZoomToFull();" // << std::endl; // Get layer actor. GlActor::Pointer actor( GetActor( key ) ); // If not found... if( actor.IsNull() ) return false; // Get geo-interface. const GeoInterface * geo = dynamic_cast< const GeoInterface * >( actor.GetPointer() ); if( geo==ITK_NULLPTR ) return false; // Get viewport current center and spacing. assert( !m_Settings.IsNull() ); center = m_Settings->GetViewportCenter(); spacing = m_Settings->GetSpacing(); // std::cout << "-> spacing: " << spacing[ 0 ] << ", " << spacing[ 1 ] << std::endl; // Get native spacing. GeoInterface::Spacing2 n_spacing( geo->GetSpacing() ); // std::cout << "-> n_spacing: " << n_spacing[ 0 ] << ", " << n_spacing[ 1 ] << std::endl; // Transform center point to image space. Point o; if( !geo->TransformFromViewport( o, center, true ) ) return false; // // Consider arbitrary point on the X-axis. Point e; e[ 0 ] = center[ 0 ] + units * spacing[ 0 ]; e[ 1 ] = center[ 1 ]; // Transform considered point. if( !geo->TransformFromViewport( e, e, true ) ) return false; // Compute extent vector. e[ 0 ] -= o[ 0 ]; e[ 1 ] -= o[ 1 ]; // Apply extent vector length to view spacing. // // MANTIS-1178: Length of vector e must be divided by native // spacing. // // MANTIS-1203: absolute value of native spacing should be // considered (to avoid flipping effects). spacing[ 0 ] = vcl_abs( n_spacing[ 0 ] ) * units * spacing[ 0 ] / vcl_sqrt( e[ 0 ] * e[ 0 ] + e[ 1 ] * e[ 1 ] ); // // Consider arbitrary point on the Y-axis. e[ 0 ] = center[ 0 ]; e[ 1 ] = center[ 1 ] + units * spacing[ 1 ]; // Transform considered point. if( !geo->TransformFromViewport( e, e, true ) ) return false; // Compute extent vector. e[ 0 ] -= o[ 0 ]; e[ 1 ] -= o[ 1 ]; // Apply extent vector length to view spacing. // // MANTIS-1178: Length of vector e must be divided by native // spacing. // // MANTIS-1203: absolute value of native spacing should be // considered (to avoid flipping effects). spacing[ 1 ] = vcl_abs( n_spacing[ 1 ] ) * units * spacing[ 1 ] / vcl_sqrt( e[ 0 ] * e[ 0 ] + e[ 1 ] * e[ 1 ] ); // std::cout << "-> spacing: " << spacing[ 0 ] << ", " << spacing[ 1 ] << std::endl; // // Compute aspect-ratio corrected spacing (smallest pixel is chosen // as 1:1 reference). // // MANTIS-1202 // // MANTIS-1203: restore sign of axis when applying isotrop spacing. // { if( vcl_abs( spacing[ 0 ] ) < vcl_abs( spacing[ 1 ] ) ) spacing[ 1 ] = ( spacing[ 1 ]<0.0 ? -1 : +1 ) * vcl_abs( spacing[ 0 ] ); else spacing[ 0 ] = ( spacing[ 0 ]<0.0 ? -1 : +1 ) * vcl_abs( spacing[ 1 ] ); // } // MANTIS-1202 // std::cout << "-> spacing: " << spacing[ 0 ] << ", " << spacing[ 1 ] << std::endl; // // Ok. return true; } } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbImageSettings.h000066400000000000000000000044661301006202600254450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_ImageSettings_h #define otb_ImageSettings_h #include "itkObject.h" #include "itkObjectFactory.h" namespace otb { class ImageSettings : public itk::Object { public: typedef ImageSettings Self; typedef itk::Object Superclass; typedef itk::SmartPointer< Self > Pointer; typedef itk::SmartPointer< const Self > ConstPointer; itkSetMacro( MinRed, double ); itkSetMacro( MinGreen, double ); itkSetMacro( MinBlue, double ); itkGetMacro( MinRed, double ); itkGetMacro( MinGreen, double ); itkGetMacro( MinBlue, double ); itkSetMacro( MaxRed, double ); itkSetMacro( MaxGreen, double ); itkSetMacro( MaxBlue, double); itkGetMacro( MaxRed, double); itkGetMacro( MaxGreen, double); itkGetMacro( MaxBlue, double); itkSetMacro( UseNoData, bool ); itkGetMacro( UseNoData, bool ); itkSetMacro( NoData, double ); itkGetMacro( NoData, double ); itkSetMacro( CurrentRed, double ); itkSetMacro( CurrentGreen, double ); itkSetMacro( CurrentBlue, double ); itkGetMacro( CurrentRed, double ); itkGetMacro( CurrentGreen, double ); itkGetMacro( CurrentBlue, double ); itkSetMacro( Gamma, double ); itkGetMacro( Gamma, double ); itkSetMacro( Alpha, double ); itkGetMacro( Alpha, double ); itkNewMacro( Self ); protected: ImageSettings(); ~ImageSettings() ITK_OVERRIDE; private: // prevent implementation ImageSettings( const Self & ); void operator = ( const Self & ); double m_MinRed; double m_MaxRed; double m_MinGreen; double m_MaxGreen; double m_MinBlue; double m_MaxBlue; bool m_UseNoData; double m_NoData; double m_Gamma; double m_Alpha; double m_CurrentRed; double m_CurrentGreen; double m_CurrentBlue; }; // End class ImageSettings } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbNonOptGlImageActor.h000066400000000000000000000134751301006202600263360ustar00rootroot00000000000000#ifndef otb_NonOptGlImageActor_h #define otb_NonOptGlImageActor_h #include "otbVectorImage.h" #include "otbMultiChannelExtractROI.h" #include "otbVectorRescaleIntensityImageFilter.h" #include "otbImageFileReader.h" #include "otbGenericRSTransform.h" #include "otbGlActor.h" namespace otb { class OTBIce_EXPORT NonOptGlImageActor : public GlActor { public: typedef NonOptGlImageActor Self; typedef GlActor Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); typedef VectorImage VectorImageType; typedef VectorImageType::ImageKeywordlistType ImageKeywordlistType; typedef VectorImageType::SizeType SizeType; typedef VectorImageType::IndexType IndexType; typedef VectorImageType::RegionType RegionType; typedef VectorImageType::SpacingType SpacingType; typedef VectorImageType::PointType PointType; // Initialize with a new image void Initialize(const std::string & filename); // Retrieve the full extent of the actor virtual void GetExtent(double & ulx, double & uly, double & lrx, double & lry) const; // Update internal actor state with respect to ViewSettings virtual void ProcessViewSettings(); // Heavy load/unload operations of data virtual void UpdateData(); // Gl rendering of current state virtual void Render(); const PointType & GetOrigin() const; const SpacingType & GetSpacing() const; std::string GetWkt() const; ImageKeywordlistType GetKwl() const; itkSetMacro(UseShader,bool); itkGetConstReferenceMacro(UseShader,bool); itkBooleanMacro(UseShader); itkSetMacro(MinRed,double); itkSetMacro(MinGreen,double); itkSetMacro(MinBlue,double); itkGetMacro(MinRed,double); itkGetMacro(MinGreen,double); itkGetMacro(MinBlue,double); itkSetMacro(MaxRed,double); itkSetMacro(MaxGreen,double); itkSetMacro(MaxBlue,double); itkGetMacro(MaxRed,double); itkGetMacro(MaxGreen,double); itkGetMacro(MaxBlue,double); itkSetMacro(RedIdx,unsigned int); itkGetMacro(RedIdx,unsigned int); itkSetMacro(GreenIdx,unsigned int); itkGetMacro(GreenIdx,unsigned int); itkSetMacro(BlueIdx,unsigned int); itkGetMacro(BlueIdx,unsigned int); itkGetMacro(NumberOfComponents,unsigned int); protected: NonOptGlImageActor(); virtual ~NonOptGlImageActor(); typedef ImageFileReader ReaderType; typedef MultiChannelExtractROI ExtractROIFilterType; typedef VectorRescaleIntensityImageFilter RescaleFilterType; typedef otb::GenericRSTransform<> RSTransformType; typedef std::vector ResolutionVectorType; // Internal class to hold tiles class Tile { public: Tile() : m_Loaded(false), m_TextureId(0), m_ImageRegion(), m_UL(), m_UR(), m_LL(), m_LR(), m_Resolution(1), m_RedIdx(1), m_GreenIdx(2), m_BlueIdx(3), m_UseShader(false), m_MinRed(0), m_MaxRed(0), m_MinGreen(0), m_MaxGreen(0), m_MinBlue(0), m_MaxBlue(0) { m_UL.Fill(0); m_UR.Fill(0); m_LL.Fill(0); m_LR.Fill(0); } bool m_Loaded; unsigned int m_TextureId; RegionType m_ImageRegion; PointType m_UL; PointType m_UR; PointType m_LL; PointType m_LR; unsigned int m_Resolution; unsigned int m_RedIdx; unsigned int m_GreenIdx; unsigned int m_BlueIdx; bool m_UseShader; double m_MinRed; double m_MaxRed; double m_MinGreen; double m_MaxGreen; double m_MinBlue; double m_MaxBlue; }; typedef std::vector TileVectorType; private: // prevent implementation NonOptGlImageActor(const Self&); void operator=(const Self&); // Load tile to GPU void LoadTile(Tile& tile); // Unload tile from GPU void UnloadTile(Tile& tile); // Clean the loaded tiles, getting rid of unnecessary ones void CleanLoadedTiles(); // Clear all loaded tiles void ClearLoadedTiles(); // Is tile loaded ? bool TileAlreadyLoaded(const Tile& tile); void ImageRegionToViewportExtent(const RegionType& region, double & ulx, double & uly, double & lrx, double& lry) const; void ImageRegionToViewportQuad(const RegionType & region, PointType & ul, PointType & ur, PointType & ll, PointType & lr) const; void ViewportExtentToImageRegion(const double& ulx, const double & uly, const double & lrx, const double & lry, RegionType & region) const; void UpdateResolution(); void UpdateTransforms(); static void InitShaders(); unsigned int m_TileSize; std::string m_FileName; ReaderType::Pointer m_FileReader; TileVectorType m_LoadedTiles; unsigned int m_RedIdx; unsigned int m_GreenIdx; unsigned int m_BlueIdx; double m_MinRed; double m_MaxRed; double m_MinGreen; double m_MaxGreen; double m_MinBlue; double m_MaxBlue; unsigned int m_CurrentResolution; ResolutionVectorType m_AvailableResolutions; PointType m_Origin; SpacingType m_Spacing; RegionType m_LargestRegion; unsigned int m_NumberOfComponents; bool m_UseShader; static unsigned int m_StandardShader; static unsigned int m_StandardShaderProgram; static bool m_ShaderInitialized; RSTransformType::Pointer m_ViewportToImageTransform; RSTransformType::Pointer m_ImageToViewportTransform; }; // End class NonOptGlImageActor } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbStandardShader.h000066400000000000000000000053521301006202600255640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_StandardShader_h #define otb_StandardShader_h #include #include "otbFragmentShader.h" #include "otbImageSettings.h" namespace otb { typedef enum { SHADER_STANDARD, SHADER_LOCAL_CONTRAST, SHADER_LOCAL_ALPHA, SHADER_ALPHA_GRID, SHADER_ALPHA_SLIDER, SHADER_SPECTRAL_ANGLE, SHADER_GRADIENT } ShaderType; class OTBIce_EXPORT StandardShader : public FragmentShader { public: typedef StandardShader Self; typedef FragmentShader Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Point PointType; itkSetObjectMacro( ImageSettings, ImageSettings ); itkGetObjectMacro( ImageSettings, ImageSettings ); itkGetConstObjectMacro( ImageSettings, ImageSettings ); itkSetMacro(LocalContrastRange,double); itkGetMacro(LocalContrastRange,double); itkSetMacro(SpectralAngleRange,double); itkGetMacro(SpectralAngleRange,double); itkSetMacro(ShaderType,ShaderType); itkGetMacro(ShaderType,ShaderType); itkSetMacro(Radius,double); itkGetConstReferenceMacro(Radius,double); itkSetMacro(ChessboardSize,double); itkGetConstReferenceMacro(ChessboardSize,double); itkSetMacro(SliderPosition,double); itkGetConstReferenceMacro(SliderPosition,double); itkSetMacro(VerticalSlider,bool); itkGetMacro(VerticalSlider,bool); itkSetMacro(Center,PointType); itkGetConstReferenceMacro(Center,PointType); void SetupShader() ITK_OVERRIDE; itkNewMacro(Self); protected: StandardShader(); ~StandardShader() ITK_OVERRIDE; std::string GetSource() const ITK_OVERRIDE; std::string GetName() const ITK_OVERRIDE; private: // prevent implementation StandardShader(const Self&); void operator=(const Self&); ImageSettings::Pointer m_ImageSettings; double m_LocalContrastRange; double m_SpectralAngleRange; PointType m_Center; double m_Radius; double m_ChessboardSize; double m_SliderPosition; bool m_VerticalSlider; ShaderType m_ShaderType; }; // End class StandardShader } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/include/otbViewSettings.h000066400000000000000000000107451301006202600253320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_ViewSettings_h #define otb_ViewSettings_h #include "itkObject.h" #include "itkSmartPointer.h" #include "itkPoint.h" #include "itkVector.h" #include "itkSize.h" #include "otbImageKeywordlist.h" #include "OTBIceExport.h" namespace otb { class OTBIce_EXPORT ViewSettings : public itk::Object { public: typedef ViewSettings Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::Point PointType; typedef itk::Vector SpacingType; typedef itk::Size<2> SizeType; typedef otb::ImageKeywordlist KeywordListType; itkNewMacro(Self); itkSetMacro(Origin,PointType); itkGetConstReferenceMacro(Origin,PointType); itkSetMacro(Spacing,SpacingType); itkGetConstReferenceMacro(Spacing,SpacingType); itkSetMacro(ViewportSize,SizeType); itkGetConstReferenceMacro(ViewportSize,SizeType); void Reset(); void SetRotationCenter(const PointType & center) { m_RotationCenter = center; } itkGetConstReferenceMacro(RotationCenter,PointType); void SetRotationAngle(const double & angle) { m_RotationAngle = angle; } itkGetConstReferenceMacro(RotationAngle,double); // Order of priority is Wkt, then keywordlist, then unknown void SetWkt(const std::string & wkt) { // std::cout << "Wkt: '" << m_Wkt << "' -> '" << wkt << "'" << std::endl; // std::cout << std::hex << this << "::SetWkt(" << (m_Wkt!=wkt) << ")" << std::endl; if(m_Wkt != wkt) { // std::cout << "geometry-changed: TRUE" << std::endl; m_Wkt = wkt; m_GeometryChanged = true; } } itkGetConstReferenceMacro( Wkt, std::string ); void SetUseProjection(bool usep) { // std::cout << std::hex << this << "::SetUseProjection(" << usep << ")" << std::endl; if(m_UseProjection != usep) { // std::cout << "geometry-changed: TRUE " << std::endl; m_UseProjection = usep; m_GeometryChanged = true; } } itkGetConstMacro(UseProjection, bool); itkBooleanMacro(UseProjection); itkSetMacro(GeometryChanged,bool); itkGetConstMacro(GeometryChanged,bool); void SetKeywordList(const KeywordListType& kwl) { // std::cout << std::hex << this << "::SetKeywordList()" << std::endl; if(!(m_KeywordList==kwl)) { // std::cout << "geometry-changed: TRUE" << std::endl; m_KeywordList = kwl; m_GeometryChanged = true; } } itkGetConstReferenceMacro(KeywordList,KeywordListType); // Retrieve the current Viewport extent void GetViewportExtent(double & ulx, double & uly, double & lrx, double & lry) const; PointType GetViewportCenter() const; void ScreenToViewPortTransform(const double & xscreen, const double & yscreen, double & xvp, double & yvp) const; void ViewportToScreenTransform(const double & xvp, const double & yvp, double & xscreen, double & yscreen) const; void Zoom(const PointType & zoomCenter,double scale = 1.1); void Center(const PointType & center); void SetPersepectiveAngle(); void SetNorthUpAngle(); void UpdateRotation(const PointType & newCenter, double newAngle); double GetScale( const PointType & origin, const PointType & extent, bool isSigned ) const; protected: ViewSettings(); ~ViewSettings() ITK_OVERRIDE; private: // prevent implementation ViewSettings(const Self&); void operator=(const Self&); PointType m_Origin; SpacingType m_Spacing; SizeType m_ViewportSize; std::string m_Wkt; KeywordListType m_KeywordList; PointType m_RotationCenter; double m_RotationAngle; bool m_UseProjection : 1; bool m_GeometryChanged : 1; }; // End class ViewSettings } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/Ice/otb-module.cmake000066400000000000000000000006631301006202600234450ustar00rootroot00000000000000set(DOCUMENTATION "This module provides Ice, a ligthweight efficient visualization framework for remote sensing images.") otb_module(OTBIce ENABLE_SHARED DEPENDS OTBCommon OTBStatistics OTBGdalAdapters OTBImageIO OTBTransform OTBImageManipulation OTBOSSIMAdapters OTBProjection OTBImageBase OTBITK OTBGlew OTBOpenGL OPTIONAL_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Visualization/Ice/src/000077500000000000000000000000001301006202600211565ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Ice/src/CMakeLists.txt000066400000000000000000000012701301006202600237160ustar00rootroot00000000000000set(OTBICE_SRCS otbFragmentShader.cxx otbFragmentShaderRegistry.cxx otbGeoInterface.cxx otbGlActor.cxx otbGlImageActor.cxx otbGlROIActor.cxx otbGlVectorActor.cxx otbGlVersionChecker.cxx otbGlView.cxx otbImageSettings.cxx otbStandardShader.cxx otbViewSettings.cxx ) add_library(OTBIce ${OTBICE_SRCS}) target_link_libraries(OTBIce ${OTBCommon_LIBRARIES} ${OTBStatistics_LIBRARIES} ${OTBGdalAdapters_LIBRARIES} ${OTBImageIO_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBOpenGL_LIBRARIES} ${OTBGlew_LIBRARIES}) otb_module_target(OTBIce) OTB-release-5.8/Modules/Visualization/Ice/src/otbFragmentShader.cxx000066400000000000000000000042561301006202600253100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFragmentShader.h" #include "otbFragmentShaderRegistry.h" namespace otb { FragmentShader::FragmentShader() {} FragmentShader::~FragmentShader() {} void FragmentShader::BuildShader() { std::string source = this->GetSource(); std::string name = this->GetName(); try { // Assumption here is that each shader has its unique name if(!otb::FragmentShaderRegistry::Instance()->IsShaderRegistered(name)) { otb::FragmentShaderRegistry::Instance()->RegisterShader(name,source); } } catch(itk::ExceptionObject& err) { // Log compilation errors if any std::cerr<LoadShader(GetName()); } void FragmentShader::UnloadShader() { otb::FragmentShaderRegistry::Instance()->UnloadShader(); } void FragmentShader::SetupShader() { // // Default always report corners // GLint shader_ul = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_ul"); // glUniform2f(shader_ul,m_UL[0],m_UL[1]); // GLint shader_ur = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_ur"); // glUniform2f(shader_ur,m_UR[0],m_UR[1]); // GLint shader_ll = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_ll"); // glUniform2f(shader_ll,m_LL[0],m_LL[1]); // GLint shader_lr = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_lr"); // glUniform2f(shader_lr,m_LR[0],m_LR[1]); } } OTB-release-5.8/Modules/Visualization/Ice/src/otbFragmentShaderRegistry.cxx000066400000000000000000000070021301006202600270310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbFragmentShaderRegistry.h" #include namespace otb { FragmentShaderRegistry::Pointer FragmentShaderRegistry::m_Instance; FragmentShaderRegistry::FragmentShaderRegistry() : m_ShaderMap() {} FragmentShaderRegistry::~FragmentShaderRegistry() { this->ClearShaders(); } FragmentShaderRegistry::Pointer FragmentShaderRegistry::Instance() { if(m_Instance.IsNull()) { m_Instance = FragmentShaderRegistry::New(); glewInit(); } return m_Instance; } void FragmentShaderRegistry::RegisterShader(const std::string& name, const std::string& source) { if(m_ShaderMap.count(name) != 0) { itkExceptionMacro(<<"A shader with name "< keys; for(ShaderMapType::iterator it = m_ShaderMap.begin(); it!=m_ShaderMap.end();++it) { keys.push_back(it->first); } for(std::vector::iterator it = keys.begin(); it!=keys.end();++it) { UnregisterShader(*it); } m_ShaderMap.clear(); } unsigned int FragmentShaderRegistry::GetShaderProgram(const std::string& name) { if(m_ShaderMap.count(name) == 0) { itkExceptionMacro(<<"No shader with name "< #endif #include #include "otbStandardShader.h" #include "itkListSample.h" #include "otbListSampleToHistogramListGenerator.h" namespace otb { GlImageActor::GlImageActor() : m_TileSize(256), m_FileName(), m_FileReader(), m_LoadedTiles(), m_RedIdx(1), m_GreenIdx(2), m_BlueIdx(3), m_CurrentResolution(1), m_AvailableResolutions(), m_Origin(), m_Spacing(), m_NumberOfComponents(0), m_ImageSettings( ImageSettings::New() ), m_Shader(), m_ViewportToImageTransform(), m_ImageToViewportTransform(), m_ViewportForwardRotationTransform(RigidTransformType::New()), m_ViewportBackwardRotationTransform(RigidTransformType::New()), m_ResolutionAlgorithm(ResolutionAlgorithm::Nearest), m_SoftwareRendering(false) {} GlImageActor ::~GlImageActor() { // Release OpenGL texture names. for( TileVectorType::iterator it( m_LoadedTiles.begin() ); it!=m_LoadedTiles.end(); ++it ) UnloadTile( *it ); m_LoadedTiles.clear(); } void GlImageActor ::CreateShader() { StandardShader::Pointer shader( StandardShader::New() ); shader->SetImageSettings( m_ImageSettings ); m_Shader = shader; } const GlImageActor::PointType & GlImageActor::GetOrigin() const { return m_Origin; } const GeoInterface::Spacing2 & GlImageActor ::GetSpacing() const { return m_Spacing; } std::string GlImageActor::GetWkt() const { return m_FileReader->GetOutput()->GetProjectionRef(); } GlImageActor::ImageKeywordlistType GlImageActor::GetKwl() const { return m_FileReader->GetOutput()->GetImageKeywordlist(); } bool GlImageActor ::HasKwl() const { return true; } bool GlImageActor ::GetKwl( ImageKeywordlist & kwl ) const { assert( !m_FileReader.IsNull() ); assert( m_FileReader->GetOutput()!=NULL ); kwl = m_FileReader->GetOutput()->GetImageKeywordlist(); return true; } GlImageActor::MetaDataDictionaryType & GlImageActor::GetMetaDataDictionary() const { return m_FileReader->GetOutput()->GetMetaDataDictionary(); } void GlImageActor::Initialize(const std::string & filename) { // std::cout // << std::hex << this << "::Initialize( '" << filename << "' )" << std::endl; // First, clean up any previous data this->ClearLoadedTiles(); m_FileName = filename; m_FileReader = ReaderType::New(); m_FileReader->SetFileName(m_FileName); m_FileReader->GetOutput()->UpdateOutputInformation(); m_LargestRegion = m_FileReader->GetOutput()->GetLargestPossibleRegion(); if(m_FileReader->GetOutput()->GetNumberOfComponentsPerPixel() < 3) { m_RedIdx = 1; m_GreenIdx = 1; m_BlueIdx = 1; } m_Origin = m_FileReader->GetOutput()->GetOrigin(); m_Spacing = m_FileReader->GetOutput()->GetSpacing(); m_NumberOfComponents = m_FileReader->GetOutput()->GetNumberOfComponentsPerPixel(); unsigned int ovrCount = m_FileReader->GetOverviewsCount(); // std::cout << "overview-count: " << ovrCount << std::endl; assert( ovrCount>0 ); // { // typedef std::vector< std::string > StringVector; // StringVector info( // m_FileReader->GetOverviewsInfo() // ); // for( StringVector::const_iterator it( info.begin() ); // it!=info.end(); // ++it ) // std::cout << *it << std::endl; // } m_AvailableResolutions.clear(); for( unsigned int i=0; iGetOutput()->GetLargestPossibleRegion(); const_cast< GlImageActor * >( this )->UpdateTransforms(); ImageRegionToViewportExtent(largest,ulx,uly,lrx,lry); } void GlImageActor::ProcessViewSettings() { // Is there anything to do ? ViewSettings::ConstPointer settings = this->GetSettings(); RigidTransformType::ParametersType rigidParameters(5); rigidParameters.Fill(0); rigidParameters[0]=settings->GetRotationAngle(); rigidParameters[1]=settings->GetRotationCenter()[0]; rigidParameters[2]=settings->GetRotationCenter()[1]; m_ViewportForwardRotationTransform->SetParameters(rigidParameters); rigidParameters[0]=-settings->GetRotationAngle(); m_ViewportBackwardRotationTransform->SetParameters(rigidParameters); UpdateTransforms(); for (TileVectorType::iterator it = m_LoadedTiles.begin(); it!=m_LoadedTiles.end(); ++it) { // Do not rotate here, handled by opengl this->ImageRegionToViewportQuad(it->m_ImageRegion,it->m_UL,it->m_UR,it->m_LL,it->m_LR,false); } } void GlImageActor::UpdateData() { // Update resolution needed UpdateResolution(); // First, clean existing tiles CleanLoadedTiles(); // Retrieve settings ViewSettings::ConstPointer settings = GetSettings(); RegionType largest( m_FileReader->GetOutput()->GetLargestPossibleRegion() ); double ulx, uly, lrx, lry; settings->GetViewportExtent(ulx,uly,lrx,lry); // std::cout<<"Viewport extent: "<(requested.GetIndex()[0] + requested.GetSize()[0])/m_TileSize) -vcl_floor(static_cast(requested.GetIndex()[0])/m_TileSize); unsigned int nbTilesY = vcl_ceil(static_cast(requested.GetIndex()[1] + requested.GetSize()[1])/m_TileSize) -vcl_floor(static_cast(requested.GetIndex()[1])/m_TileSize); //unsigned int nbTilesY = vcl_ceil(static_cast(requested.GetSize()[1])/m_TileSize); unsigned int tileStartX = m_TileSize*(requested.GetIndex()[0]/m_TileSize); unsigned int tileStartY = m_TileSize*(requested.GetIndex()[1]/m_TileSize); SizeType tileSize; tileSize.Fill(m_TileSize); Tile newTile; for(unsigned int i = 0; i < nbTilesX; ++i) { for(unsigned int j = 0; j(tileStartX+i*m_TileSize); tileIndex[1] = static_cast(tileStartY+j*m_TileSize); newTile.m_ImageRegion.SetSize(tileSize); newTile.m_ImageRegion.SetIndex(tileIndex); newTile.m_ImageRegion.Crop( largest ); ImageRegionToViewportQuad(newTile.m_ImageRegion,newTile.m_UL,newTile.m_UR,newTile.m_LL,newTile.m_LR,false); newTile.m_RedIdx = m_RedIdx; newTile.m_GreenIdx = m_GreenIdx; newTile.m_BlueIdx = m_BlueIdx; newTile.m_Resolution = m_CurrentResolution; newTile.m_TileSize = m_TileSize; if(!TileAlreadyLoaded(newTile)) { LoadTile(newTile); } } } } bool GlImageActor::TileAlreadyLoaded(const Tile& tile) { for(TileVectorType::iterator it = m_LoadedTiles.begin(); it!=m_LoadedTiles.end(); ++it) { if(it->m_ImageRegion == tile.m_ImageRegion) { return (tile.m_Resolution == it->m_Resolution && tile.m_RedIdx == it->m_RedIdx && tile.m_GreenIdx == it->m_GreenIdx && tile.m_BlueIdx == it->m_BlueIdx); } } return false; } void GlImageActor::Render() { // std::cout // << "otb::GlImageActor@" << std::hex << this << std::dec << std::endl // << "\tresolution: " << m_ResolutionAlgorithm << std::endl // << "\tpixel: " << m_SoftwareRendering << std::endl // << "\ttile: " << m_TileSize << std::endl; if( !m_SoftwareRendering && !m_Shader.IsNull() ) { // std::cout << "\tGLSL" << std::endl; m_Shader->LoadShader(); m_Shader->SetupShader(); } else { // std::cout << "\tOTB" << std::endl; for(TileVectorType::iterator it = m_LoadedTiles.begin(); it != m_LoadedTiles.end(); ++it) { if(!it->m_RescaleFilter) { it->m_RescaleFilter = RescaleFilterType::New(); it->m_RescaleFilter->AutomaticInputMinMaxComputationOff(); it->m_RescaleFilter->SetInput(it->m_Image); } VectorImageType::PixelType mins(3),maxs(3),omins(3),omaxs(3); mins.Fill(0); maxs.Fill(255); double noData(0.); assert( !m_ImageSettings.IsNull() ); mins[ 0 ] = m_ImageSettings->GetMinRed(); mins[ 1 ] = m_ImageSettings->GetMinGreen(); mins[ 2 ] = m_ImageSettings->GetMinBlue(); maxs[ 0 ] = m_ImageSettings->GetMaxRed(); maxs[ 1 ] = m_ImageSettings->GetMaxGreen(); maxs[ 2 ] = m_ImageSettings->GetMaxBlue(); // MANTIS-1204 // { double gamma = m_ImageSettings->GetGamma(); gamma = gamma == 0.0 ? std::numeric_limits< double >::max() : 1.0 / gamma; // } if( m_ImageSettings->GetUseNoData() ) noData = m_ImageSettings->GetNoData(); omins.Fill( 0 ); omaxs.Fill( 255 ); it->m_RescaleFilter->SetInputMinimum(mins); it->m_RescaleFilter->SetInputMaximum(maxs); it->m_RescaleFilter->SetOutputMinimum(omins); it->m_RescaleFilter->SetOutputMaximum(omaxs); it->m_RescaleFilter->SetGamma(gamma); it->m_RescaleFilter->Update(); itk::ImageRegionConstIterator imIt(it->m_RescaleFilter->GetOutput(),it->m_RescaleFilter->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionConstIterator inIt(it->m_Image,it->m_Image->GetLargestPossibleRegion()); unsigned char * buffer = new unsigned char[4*it->m_RescaleFilter->GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels()]; unsigned int idx = 0; for(imIt.GoToBegin(),inIt.GoToBegin();!imIt.IsAtEnd()&&!inIt.IsAtEnd();++imIt,++inIt) { buffer[idx] = static_cast(imIt.Get()[2]); ++idx; buffer[idx] = static_cast(imIt.Get()[1]); ++idx; buffer[idx] = static_cast(imIt.Get()[0]); ++idx; buffer[idx] = 255; if(m_ImageSettings->GetUseNoData() && (inIt.Get()[0] == noData ||inIt.Get()[1] == noData ||inIt.Get()[2] == noData)) { buffer[idx] = 0; } ++idx; } if(!it->m_TextureId) { glGenTextures(1, &(it->m_TextureId)); } glBindTexture(GL_TEXTURE_2D, it->m_TextureId); #if defined(GL_TEXTURE_BASE_LEVEL) && defined(GL_TEXTURE_MAX_LEVEL) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); #endif glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); // #if defined(GL_CLAMP_TO_BORDER) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER); // #elif defined (GL_CLAMP_TO_BORDER_EXT) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER_EXT); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER_EXT); // #elif defined (GL_MIRRORED_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT); // #endif glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, it->m_RescaleFilter->GetOutput()->GetLargestPossibleRegion().GetSize()[0], it->m_RescaleFilter->GetOutput()->GetLargestPossibleRegion().GetSize()[1], 0, GL_BGRA, GL_UNSIGNED_BYTE, buffer); it->m_Loaded = true; delete [] buffer; } } for(TileVectorType::iterator it = m_LoadedTiles.begin(); it != m_LoadedTiles.end(); ++it) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,it->m_TextureId); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); if(m_CurrentResolution == 0) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } // Reset color before rendering glColor3d(1.0f,1.0f,1.0f); glBegin (GL_QUADS); glTexCoord2f (0.0, 1.0); glVertex2f(it->m_LL[0], it->m_LL[1]); glTexCoord2f (1.0, 1.0); glVertex2f(it->m_LR[0], it->m_LR[1]); glTexCoord2f (1.0, 0.0); glVertex2f(it->m_UR[0], it->m_UR[1]); glTexCoord2f (0.0, 0.0); glVertex2f(it->m_UL[0], it->m_UL[1]); glEnd (); glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); } if( !m_SoftwareRendering && !m_Shader.IsNull() ) { m_Shader->UnloadShader(); } } void GlImageActor::LoadTile(Tile& tile) { // std::cout // << std::hex << this // << "::LoadTile(" << &tile << ")" // << std::dec << std::endl; // std::cout // << "[ " << tile.m_ImageRegion.GetIndex()[ 0 ] // << ", " << tile.m_ImageRegion.GetIndex()[ 1 ] // << " ]-[ " << tile.m_ImageRegion.GetSize()[ 0 ] // << ", " << tile.m_ImageRegion.GetSize()[ 1 ] // << "]" // << std::endl; ExtractROIFilterType::Pointer extract = ExtractROIFilterType::New(); extract->SetInput(m_FileReader->GetOutput()); extract->SetExtractionRegion(tile.m_ImageRegion); extract->SetChannel(tile.m_RedIdx); extract->SetChannel(tile.m_GreenIdx); extract->SetChannel(tile.m_BlueIdx); // std::cout << "ExtractROIFilter::Update()..."; extract->Update(); // std::cout << "\tDONE\n"; tile.m_Image = extract->GetOutput(); if(!m_SoftwareRendering) { itk::ImageRegionConstIterator it(extract->GetOutput(),extract->GetOutput()->GetLargestPossibleRegion()); float * buffer = new float[4*extract->GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels()]; unsigned int idx = 0; for(it.GoToBegin();!it.IsAtEnd();++it) { buffer[idx] = static_cast(it.Get()[2]); ++idx; buffer[idx] = static_cast(it.Get()[1]); ++idx; buffer[idx] = static_cast(it.Get()[0]); ++idx; buffer[idx] = 255.; ++idx; } // Now load the texture assert( tile.m_TextureId==0 ); glGenTextures( 1, &tile.m_TextureId ); // Following assert is sometimes false on some OpenGL systems for // some unknown reason even though the glGenTexture() call has // succeeded. // assert( glGetError()==GL_NO_ERROR ); assert( tile.m_TextureId!=0 ); // std::cout << "Generated texture #" << tile.m_TextureId << std::endl; glBindTexture(GL_TEXTURE_2D, tile.m_TextureId); #if defined(GL_TEXTURE_BASE_LEVEL) && defined(GL_TEXTURE_MAX_LEVEL) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); #endif //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); // #if defined(GL_CLAMP_TO_BORDER) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER); // #elif defined (GL_CLAMP_TO_BORDER_EXT) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER_EXT); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER_EXT); // #elif defined (GL_MIRRORED_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT); // #endif glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB32F, extract->GetOutput()->GetLargestPossibleRegion().GetSize()[0], extract->GetOutput()->GetLargestPossibleRegion().GetSize()[1], 0, GL_BGRA, GL_FLOAT, buffer); tile.m_Loaded = true; delete [] buffer; } // And push to loaded texture m_LoadedTiles.push_back(tile); } void GlImageActor::UnloadTile(Tile& tile) { // std::cout << std::hex << this << std::dec << "::UnloadTile()" << std::endl; if( tile.m_Loaded ) { assert( tile.m_TextureId>0 ); glDeleteTextures( 1, &tile.m_TextureId ); // std::cout << "Deleted texture #" << tile.m_TextureId << std::endl; tile.m_TextureId = 0; tile.m_Image = VectorImageType::Pointer(); tile.m_RescaleFilter = RescaleFilterType::Pointer(); tile.m_Loaded = false; } } void GlImageActor::CleanLoadedTiles() { TileVectorType newLoadedTiles; // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); double ulx, uly, lrx, lry; settings->GetViewportExtent(ulx,uly,lrx,lry); RegionType requested; this->ViewportExtentToImageRegion(ulx,uly,lrx,lry,requested); for(TileVectorType::iterator it = m_LoadedTiles.begin(); it!=m_LoadedTiles.end();++it) { RegionType tileRegion = it->m_ImageRegion; // Test if tileRegion intersects requested region if(!tileRegion.Crop(requested) || it->m_Resolution != m_CurrentResolution || it->m_RedIdx != m_RedIdx || it->m_GreenIdx != m_GreenIdx || it->m_BlueIdx != m_BlueIdx // We need to compare with theoretical tile size as actual tile // size might be smaller at images borders || it->m_TileSize!=m_TileSize) { // Tile will not be used anymore, unload it from GPU UnloadTile(*it); } else { newLoadedTiles.push_back(*it); } } // std::cout<<"GPU memory cleanup: removing "<GetSettings(); itk::ContinuousIndex cul,cur,cll,clr; cul[0] = region.GetIndex()[0]; cul[1] = region.GetIndex()[1]; cur = cul; cur[0]+=region.GetSize()[0]-1; cll = cul; cll[1]+=region.GetSize()[1]-1; clr = cur; clr[1]+=region.GetSize()[1]-1; PointType iul, iur,ill,ilr; m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(cul,iul); m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(cur,iur); m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(cll,ill); m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(clr,ilr); // Take into account that Origin refers to center of first pixel SpacingType spacing = m_FileReader->GetOutput()->GetSpacing(); iul[0]-=0.5*spacing[0]; iul[1]-=0.5*spacing[1]; iur[0]+=0.5*spacing[0]; iur[1]-=0.5*spacing[1]; ill[0]-=0.5*spacing[0]; ill[1]+=0.5*spacing[1]; ilr[0]+=0.5*spacing[0]; ilr[1]+=0.5*spacing[1]; PointType pul = m_ImageToViewportTransform->TransformPoint(iul); PointType pur = m_ImageToViewportTransform->TransformPoint(iur); PointType pll = m_ImageToViewportTransform->TransformPoint(ill); PointType plr = m_ImageToViewportTransform->TransformPoint(ilr); if(rotate) { pul = m_ViewportBackwardRotationTransform->TransformPoint(pul); pur = m_ViewportBackwardRotationTransform->TransformPoint(pur); pll = m_ViewportBackwardRotationTransform->TransformPoint(pll); plr = m_ViewportBackwardRotationTransform->TransformPoint(plr); } ul[0] = pul[0]; ul[1] = pul[1]; ur[0] = pur[0]; ur[1] = pur[1]; ll[0] = pll[0]; ll[1] = pll[1]; lr[0] = plr[0]; lr[1] = plr[1]; } void GlImageActor::ViewportExtentToImageRegion(const double& ulx, const double & uly, const double & lrx, const double & lry, RegionType & region) const { // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); RegionType largest = m_FileReader->GetOutput()->GetLargestPossibleRegion(); PointType ul,ur,ll,lr,tul,tur,tll,tlr; ul[0]=ulx; ul[1]=uly; ur[0]=lrx; ur[1]=uly; ll[0]=ulx; ll[1]=lry; lr[0]=lrx; lr[1]=lry; tul = m_ViewportToImageTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(ul)); tur = m_ViewportToImageTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(ur)); tll = m_ViewportToImageTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(ll)); tlr = m_ViewportToImageTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(lr)); itk::ContinuousIndex cul,cur,cll,clr; m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tul,cul); m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tur,cur); m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tll,cll); m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tlr,clr); // TODO: Take into account origin/scaling/rotation here ? // TODO: Screen to image / image to screen transform calls here ? double iulx, iuly, ilrx, ilry; iulx = std::max(std::min(std::min(cul[0],cur[0]),std::min(cll[0],clr[0])),0.); iuly = std::max(std::min(std::min(cul[1],cur[1]),std::min(cll[1],clr[1])),0.); ilrx = std::min(std::max(std::max(cul[0],cur[0]),std::max(cll[0],clr[0])),static_cast(largest.GetSize()[0])); ilry = std::min(std::max(std::max(cul[1],cur[1]),std::max(cll[1],clr[1])),static_cast(largest.GetSize()[1])); // Now we have the requested part of image, we need to find the // corresponding tiles IndexType index; index[0] = static_cast(iulx); index[1] = static_cast(iuly); SizeType size; size[0] = static_cast(ilrx-iulx); size[1] = static_cast(ilry-iuly); region.SetSize(size); region.SetIndex(index); region.Crop(m_FileReader->GetOutput()->GetLargestPossibleRegion()); } GlImageActor::PointType GlImageActor::ViewportToImageTransform(const PointType & in, bool physical) const { PointType inRotated = m_ViewportForwardRotationTransform->TransformPoint(in); PointType imgPoint = m_ViewportToImageTransform->TransformPoint(inRotated); if(!physical) { imgPoint[0]=(imgPoint[0]-m_Origin[0])/m_Spacing[0]; imgPoint[1]=(imgPoint[1]-m_Origin[1])/m_Spacing[1]; } return imgPoint; } GlImageActor::PointType GlImageActor::ImageToViewportTransform(const PointType & in, bool physical) const { PointType imgPoint = in; if(!physical) { imgPoint[0]=imgPoint[0]*m_Spacing[0]+m_Origin[0]; imgPoint[1]=imgPoint[1]*m_Spacing[1]+m_Origin[1]; } PointType out = m_ImageToViewportTransform->TransformPoint(imgPoint); return m_ViewportBackwardRotationTransform->TransformPoint(out); } bool GlImageActor ::GetPixelFromViewport( const PointType & in, PixelType & pixel ) const { PointType p; IndexType i; return GetPixelFromViewport( in, pixel, p, i ); } bool GlImageActor ::GetPixelFromViewport( const PointType & ptView, PixelType & pixel, PointType & ptPhysical, IndexType & index ) const { ptPhysical = ViewportToImageTransform( ptView ); return GetPixel( ptPhysical, pixel, index ); } bool GlImageActor ::GetPixel( const PointType & physical, PixelType & pixel, IndexType & index ) const { // std::cout << std::endl; // std::cout << "O: (" << m_Origin[ 0 ] << ", " << m_Origin[ 1 ] << ")"; // std::cout << "\tS: (" << m_Spacing[ 1 ] << ", " << m_Spacing[ 1 ] << ")"; // std::cout << std::endl; // std::cout << "P: (" << physical[ 0 ] << ", " << physical[ 1 ] << ")"; // std::cout << std::endl; // First, we need to return index in full img (not in overviews) #if 0 index[ 0 ] = static_cast((physical[0]-m_Origin[0])/m_Spacing[0]); index[ 1 ] = static_cast((physical[1]-m_Origin[1])/m_Spacing[1]); #else index[ 0 ] = static_cast< IndexType::IndexValueType >( ( physical[ 0 ] - m_Origin[ 0 ] ) / m_Spacing[ 0 ] ); index[ 1 ] = static_cast< IndexType::IndexValueType >( ( physical[ 1 ]- m_Origin[ 1 ] ) / m_Spacing[ 1 ] ); #endif // std::cout << "I: (" << index[ 0 ] << ", " << index[ 1 ] << ")"; // std::cout // << "\tI: (" // << ( ( physical[ 0 ] - m_Origin[ 0 ] ) / m_Spacing[ 0 ] ) // << ", " // << ( ( physical[ 1 ] - m_Origin[ 1 ] ) / m_Spacing[ 1 ] ) // << ")"; // std::cout << std::endl; // Then, we need to find the index in the currently loaded overview IndexType ovrIndex; m_FileReader->GetOutput()->TransformPhysicalPointToIndex( physical, ovrIndex ); // std::cout << "O: (" << ovrIndex[ 0 ] << ", " << ovrIndex[ 1 ] << ")"; // std::cout << std::endl; // And look it up in loaded tiles for (TileVectorType::const_iterator it = m_LoadedTiles.begin(); it!=m_LoadedTiles.end(); ++it) { // std::cout // << "R: (" // << it->m_ImageRegion.GetIndex()[ 0 ] // << ", " // << it->m_ImageRegion.GetIndex()[ 1 ] // << ")-(" // << it->m_ImageRegion.GetSize()[ 0 ] // << ", " // << it->m_ImageRegion.GetSize()[ 1 ] // << ")"; if(it->m_ImageRegion.IsInside(ovrIndex)) { IndexType idx; idx[ 0 ] = ovrIndex[ 0 ] - it->m_ImageRegion.GetIndex()[ 0 ]; idx[ 1 ] = ovrIndex[ 1 ] - it->m_ImageRegion.GetIndex()[ 1 ]; // std::cout << "\tIr: (" << idx[ 0 ] << ", " << idx[ 1 ] << ")"; pixel = it->m_Image->GetPixel( idx ); return true; } // std::cout << std::endl; } return false; } void GlImageActor::UpdateResolution() { // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); // Retrieve viewport spacing ViewSettings::SpacingType spacing = settings->GetSpacing(); // 100 screen pixels PointType pointA, pointB, pointC; pointA = settings->GetOrigin(); pointB = pointA; pointC = pointA; pointB[0]+=100*spacing[0]; pointC[1]+=100*spacing[1]; // Transform the spacing vector pointA = m_ViewportForwardRotationTransform->TransformPoint(pointA); pointA = m_ViewportToImageTransform->TransformPoint(pointA); pointB = m_ViewportForwardRotationTransform->TransformPoint(pointB); pointB = m_ViewportToImageTransform->TransformPoint(pointB); pointC = m_ViewportForwardRotationTransform->TransformPoint(pointC); pointC = m_ViewportToImageTransform->TransformPoint(pointC); // Equivalence in image pixels pointA[0] = (pointA[0] - m_Origin[0])/m_Spacing[0]; pointA[1] = (pointA[1] - m_Origin[1])/m_Spacing[1]; pointB[0] = (pointB[0] - m_Origin[0])/m_Spacing[0]; pointB[1] = (pointB[1] - m_Origin[1])/m_Spacing[1]; pointC[0] = (pointC[0] - m_Origin[0])/m_Spacing[0]; pointC[1] = (pointC[1] - m_Origin[1])/m_Spacing[1]; double distAB = vcl_sqrt((pointA[0]-pointB[0])*(pointA[0]-pointB[0])+(pointA[1]-pointB[1])*(pointA[1]-pointB[1])); double distAC = vcl_sqrt((pointA[0]-pointC[0])*(pointA[0]-pointC[0])+(pointA[1]-pointC[1])*(pointA[1]-pointC[1])); double resolution = std::min(100/distAB,100/distAC); // std::cout << std::endl; // std::cout << "resolution: " << resolution << std::endl; // Arbitrary higher than any distance we will compute here double minDist = 50000.; unsigned int newResolution = 0; // OTB always include full resolution level in available resolutions. assert( !m_AvailableResolutions.empty() ); // MANTIS-1179: resolution>1 <=> zooming in past 1:1 scale. So, cap // resolution to index 0. if( resolution<1.0 ) { bool isFound = false; // Compute the diff and keep the index that minimize the distance for (ResolutionVectorType::iterator it = m_AvailableResolutions.begin(); it != m_AvailableResolutions.end(); ++it) { double diff = 1/((double)(1<<(*it))) - resolution; // std::cout << "diff: " << diff << std::endl; if( ( ( m_ResolutionAlgorithm == ResolutionAlgorithm::Nearest_Lower && diff <= 0 ) || ( m_ResolutionAlgorithm == ResolutionAlgorithm::Nearest_Upper && diff >= 0 ) || ( m_ResolutionAlgorithm == ResolutionAlgorithm::Nearest ) ) && vcl_abs(diff) < minDist ) { isFound = true; minDist = vcl_abs(diff); newResolution = std::distance(m_AvailableResolutions.begin(),it); // std::cout << "found: " << newResolution << std::endl; } } // MANTIS-1147: Cap current-resolution. if( !isFound ) { assert( m_AvailableResolutions.size() > 0 ); newResolution = m_AvailableResolutions.size() - 1; // std::cout << "not found: " << m_CurrentResolution << std::endl; } } if(newResolution != m_CurrentResolution) { m_CurrentResolution = newResolution; std::ostringstream extFilename; extFilename<GetSettings(); bool hasChanged = false; bool geometryChanged = settings->GetGeometryChanged(); if( ( !settings->GetUseProjection() && geometryChanged ) || m_ViewportToImageTransform.IsNull() || m_ImageToViewportTransform.IsNull()) { // std::cout // << "otb::GlImageActor@" << std::hex << this // << " Proj: OFF" << std::endl; m_ViewportToImageTransform = RSTransformType::New(); m_ImageToViewportTransform = RSTransformType::New(); hasChanged = true; } // std::cout // << std::hex << this << std::dec // << " geometry-changed: " << geometryChanged << std::endl; // bool isEqualOrNot = // m_ViewportToImageTransform->GetInputProjectionRef() != settings->GetWkt(); // std::cout // << std::hex << this << std::dec // << " WKT-changed: " << isEqualOrNot << std::endl; geometryChanged = geometryChanged || (m_ViewportToImageTransform.IsNotNull() && m_ViewportToImageTransform->GetInputProjectionRef() != settings->GetWkt()) || (m_ImageToViewportTransform.IsNotNull() && m_ImageToViewportTransform->GetOutputProjectionRef() != settings->GetWkt()) || (m_ViewportToImageTransform.IsNotNull() && !(m_ViewportToImageTransform->GetInputKeywordList() == settings->GetKeywordList())) || (m_ImageToViewportTransform.IsNotNull() && !(m_ImageToViewportTransform->GetOutputKeywordList() == settings->GetKeywordList())); if(settings->GetUseProjection() && geometryChanged) { // std::cout // << "otb::GlImageActor@" << std::hex << this << std::dec // << " Proj: ON" << std::endl; m_ViewportToImageTransform = RSTransformType::New(); m_ImageToViewportTransform = RSTransformType::New(); m_ViewportToImageTransform->SetInputProjectionRef(settings->GetWkt()); m_ViewportToImageTransform->SetInputKeywordList(settings->GetKeywordList()); m_ViewportToImageTransform->SetOutputProjectionRef(m_FileReader->GetOutput()->GetProjectionRef()); m_ViewportToImageTransform->SetOutputKeywordList(m_FileReader->GetOutput()->GetImageKeywordlist()); m_ImageToViewportTransform->SetOutputProjectionRef(settings->GetWkt()); m_ImageToViewportTransform->SetOutputKeywordList(settings->GetKeywordList()); m_ImageToViewportTransform->SetInputProjectionRef(m_FileReader->GetOutput()->GetProjectionRef()); m_ImageToViewportTransform->SetInputKeywordList(m_FileReader->GetOutput()->GetImageKeywordlist()); hasChanged = true; } if( hasChanged ) { // std::cout << std::hex << this << " -> InstantiateTransform()" << std::endl; m_ViewportToImageTransform->InstantiateTransform(); m_ImageToViewportTransform->InstantiateTransform(); } // std::cout << "}" << std::endl; } void GlImageActor::AutoColorAdjustment( double & minRed, double & maxRed, double & minGreen, double & maxGreen, double & minBlue, double & maxBlue, bool full, unsigned int refSize, double lcp, double hcp ) { typedef itk::Statistics::ListSample ListSampleType; typedef itk::Statistics::DenseFrequencyContainer2 DFContainerType; typedef ListSampleToHistogramListGenerator HistogramsGeneratorType; assert( refSize>0 ); ListSampleType::Pointer listSample = ListSampleType::New(); listSample->SetMeasurementVectorSize(3); if(full) { // Retrieve the lowest resolution ReaderType::Pointer reader = ReaderType::New(); std::ostringstream extFilename; unsigned int nb_pixel_ref = refSize * refSize; // Compute the diff and keep the index that minimize the distance unsigned int resol = 0; bool found = false; for (ResolutionVectorType::iterator it = m_AvailableResolutions.begin(); it != m_AvailableResolutions.end() && !found; ++it,++resol) { unsigned int factor = 1<<(*it); unsigned int sizex = m_LargestRegion.GetSize()[0]/factor; unsigned int sizey = m_LargestRegion.GetSize()[1]/factor; unsigned int nb_pixel = sizex * sizey; if(nb_pixel #endif #include namespace otb { GlROIActor::GlROIActor() : m_UL(), m_LR(), m_Wkt(), m_Kwl(), m_Color(), m_Alpha(1.0), m_Fill(false), m_ViewportToImageTransform(), m_ImageToViewportTransform(), m_VpUL(), m_VpUR(), m_VpLL(), m_VpLR() { m_UL.Fill( 0 ); m_LR.Fill( 0 ); m_Color.Fill(0); m_Color[0]=1.0; m_VpUL.Fill( 0 ); m_VpUR.Fill( 0 ); m_VpLL.Fill( 0 ); m_VpLR.Fill( 0 ); } GlROIActor::~GlROIActor() {} void GlROIActor ::SetUL( const PointType & p ) { if( p!=m_UL ) GeometryChangedOn(); m_UL = p; } void GlROIActor ::SetLR( const PointType & p ) { if( p!=m_LR ) GeometryChangedOn(); m_LR = p; } void GlROIActor::SetKwl(const ImageKeywordlistType & kwl) { m_Kwl = kwl; } void GlROIActor::GetExtent(double & ulx, double & uly, double & lrx, double & lry) const { //TODO: Fixme (should handle rotation as well) lrx = std::max(std::max(m_VpUL[0],m_VpUR[0]),std::max(m_VpLL[0],m_VpLR[0])); lry = std::max(std::max(m_VpUL[1],m_VpUR[1]),std::max(m_VpLL[1],m_VpLR[1])); ulx = std::min(std::min(m_VpUL[0],m_VpUR[0]),std::min(m_VpLL[0],m_VpLR[0])); uly = std::min(std::min(m_VpUL[1],m_VpUR[1]),std::min(m_VpLL[1],m_VpLR[1])); } void GlROIActor::ProcessViewSettings() { // std::cout << std::hex << this << "::ProcessViewSettings()" << std::endl; UpdateTransforms(); assert( GetSettings()!=NULL ); if( GetGeometryChanged() || GetSettings()->GetGeometryChanged() ) { // std::cout << "otb::GlRoiActor@" << std::hex << this << " -> ROI" << std::endl; PointType ur; PointType ll; ur = m_UL; ur[ 0 ] = m_LR[ 0 ]; ll = m_LR; ll[ 0 ] = m_UL[ 0 ]; assert( !m_ImageToViewportTransform.IsNull() ); assert( !m_ViewportToImageTransform.IsNull() ); m_VpUL = m_ImageToViewportTransform->TransformPoint( m_UL ); m_VpUR = m_ImageToViewportTransform->TransformPoint( ur ); m_VpLL = m_ImageToViewportTransform->TransformPoint( ll ); m_VpLR = m_ImageToViewportTransform->TransformPoint( m_LR ); } } void GlROIActor::UpdateData() { // Nothing to do here } void GlROIActor::Render() { glColor3d(m_Color[0],m_Color[1],m_Color[2]); glBegin(GL_LINE_LOOP); glVertex2d(m_VpUL[0],m_VpUL[1]); glVertex2d(m_VpUR[0],m_VpUR[1]); glVertex2d(m_VpLR[0],m_VpLR[1]); glVertex2d(m_VpLL[0],m_VpLL[1]); glEnd(); if(m_Fill) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4d(m_Color[0],m_Color[1],m_Color[2],m_Alpha); glBegin(GL_QUADS); glVertex2d(m_VpUL[0],m_VpUL[1]); glVertex2d(m_VpUR[0],m_VpUR[1]); glVertex2d(m_VpLR[0],m_VpLR[1]); glVertex2d(m_VpLL[0],m_VpLL[1]); glEnd(); glDisable(GL_BLEND); } } void GlROIActor::UpdateTransforms() { // std::cout << std::hex << this << "::UpdateTransforms()" << std::endl; // Retrieve settings ViewSettings::ConstPointer settings( this->GetSettings() ); if( settings->GetUseProjection() ) { if( settings->GetGeometryChanged() || m_ImageToViewportTransform.IsNull() || m_ViewportToImageTransform.IsNull() ) { // std::cout // << "otb::GlROIActor@" << std::hex << this // << " Proj: ON" << std::endl; m_ImageToViewportTransform = RSTransformType::New(); m_ViewportToImageTransform = RSTransformType::New(); m_ViewportToImageTransform->SetInputProjectionRef( settings->GetWkt() ); m_ViewportToImageTransform->SetInputKeywordList( settings->GetKeywordList() ); m_ViewportToImageTransform->SetOutputProjectionRef( m_Wkt ); m_ViewportToImageTransform->SetOutputKeywordList( m_Kwl ); m_ImageToViewportTransform->SetInputProjectionRef( m_Wkt ); m_ImageToViewportTransform->SetInputKeywordList( m_Kwl ); m_ImageToViewportTransform->SetOutputProjectionRef( settings->GetWkt() ); m_ImageToViewportTransform->SetOutputKeywordList( settings->GetKeywordList() ); m_ViewportToImageTransform->InstantiateTransform(); m_ImageToViewportTransform->InstantiateTransform(); } } else { if( settings->GetGeometryChanged() || m_ImageToViewportTransform.IsNull() || m_ViewportToImageTransform.IsNull() ) { // std::cout // << "otb::GlROIActor@" << std::hex << this // << " Proj: OFF" << std::endl; m_ImageToViewportTransform = RSTransformType::New(); m_ViewportToImageTransform = RSTransformType::New(); m_ImageToViewportTransform->InstantiateTransform(); m_ViewportToImageTransform->InstantiateTransform(); } } } } OTB-release-5.8/Modules/Visualization/Ice/src/otbGlVectorActor.cxx000066400000000000000000000576731301006202600251470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGlVectorActor.h" #include "otbViewSettings.h" #ifdef _WIN32 #include #endif #include /* #ifdef APPLE__ #include #else #include #endif */ namespace otb { // Function pointer typedef #ifdef WIN32 typedef void (CALLBACK *FunctionPointerType)(); # define ICE_CALLBACK CALLBACK #else typedef GLvoid (* FunctionPointerType)(); # define ICE_CALLBACK #endif // Static Combine callback for tesselation static void ICE_CALLBACK TesselationCombineCallback(GLdouble coords[3], GLdouble * /*data*/[4], GLfloat /*weights*/[4], GLdouble **dataOut) { GLdouble * vertex = new GLdouble[3]; vertex[0] = coords[0]; vertex[1] = coords[1]; vertex[2] = 0; *dataOut = vertex; } // Static error callback fir tesselation static void ICE_CALLBACK TesselationErrorCallback(GLenum errorCode) { const GLubyte * estring = gluErrorString(errorCode); otbMsgDevMacro(<< "Glu Tesselation error: " << estring); (void)estring; } // Static begin callback for tesselation static void ICE_CALLBACK BeginCallback(GLenum prim) { glBegin(prim); } // Static end callback for tesselation static void ICE_CALLBACK EndCallback() { glEnd(); } // static vertex callback for tesselation static void ICE_CALLBACK VertexCallback(void * data) { glVertex3dv((GLdouble*) data); } GlVectorActor::GlVectorActor() : m_Color(), m_Alpha(1.0), m_Fill(true), m_SolidBorder(true), m_LineWidth(1.0), m_ViewportToVectorTransform(), m_VectorToViewportTransform(), m_OGRDataSource(), m_CurrentLayer(""), m_InternalFeatures(), m_DisplayList(0), m_DisplayListNeedsRebuild(true), m_ExtentULX(0), m_ExtentULY(0), m_ExtentLRX(0), m_ExtentLRY(0), m_OptimizedRendering(true), m_OptimizedRenderingActive(false), m_PointMarkerSize(5), m_ViewportForwardRotationTransform(RigidTransformType::New()), m_ViewportBackwardRotationTransform(RigidTransformType::New()) { m_Color.Fill(0); m_Color[0]=1.0; // Create tesselator m_GluTesselator = gluNewTess(); // Setting up the tesselator callbacks gluTessCallback(m_GluTesselator, GLU_TESS_BEGIN, (FunctionPointerType) BeginCallback); gluTessCallback(m_GluTesselator, GLU_TESS_END, (FunctionPointerType) EndCallback); gluTessCallback(m_GluTesselator, GLU_TESS_ERROR, (FunctionPointerType) TesselationErrorCallback); gluTessCallback(m_GluTesselator, GLU_TESS_VERTEX, (FunctionPointerType) VertexCallback); gluTessCallback(m_GluTesselator, GLU_TESS_COMBINE, (FunctionPointerType) TesselationCombineCallback); } GlVectorActor::~GlVectorActor() { // Delete tesselator gluDeleteTess(m_GluTesselator); // Free the display list if(m_DisplayList) { glDeleteLists(m_DisplayList,1); } } void GlVectorActor::SetFill(bool flag) { if(m_Fill != flag) { m_DisplayListNeedsRebuild = true; m_Fill = flag; } } void GlVectorActor::SetOptimizedRendering(bool flag) { if(m_OptimizedRendering != flag) { m_DisplayListNeedsRebuild = true; m_InternalFeatures.clear(); m_OptimizedRendering = flag; } } void GlVectorActor::SetSolidBorder(bool flag) { if(m_SolidBorder != flag) { m_DisplayListNeedsRebuild = true; m_SolidBorder = flag; } } void GlVectorActor::Initialize(const std::string & filename, const std::string & layername) { // Open the data source m_OGRDataSource = otb::ogr::DataSource::New(filename,otb::ogr::DataSource::Modes::Read); if(m_OGRDataSource->GetLayersCount() == 0) { itkExceptionMacro(<<"No layers found in OGR dataset."); } // If no layer specified, get the first one if(layername == "") { m_CurrentLayer = m_OGRDataSource->GetLayer(0).GetName(); } else { m_CurrentLayer = m_OGRDataSource->GetLayerChecked(layername).GetName(); } UpdateTransforms(); } std::vector GlVectorActor::GetAvailableLayers() const { std::vector resp; for(int i = 0; iGetLayersCount();++i) { resp.push_back(m_OGRDataSource->GetLayer(i).GetName()); } return resp; } std::string GlVectorActor::GetCurrentLayer() const { return m_CurrentLayer; } void GlVectorActor::SetCurrentLayer(const std::string & layername) { m_CurrentLayer = m_OGRDataSource->GetLayerChecked(layername).GetName(); // Clear transforms m_VectorToViewportTransform = ITK_NULLPTR; m_ViewportToVectorTransform = ITK_NULLPTR; // Clear features m_InternalFeatures.clear(); // Force display list rebuild m_DisplayListNeedsRebuild = true; } void GlVectorActor::GetBoundingBox(double & ulx, double & uly, double & lrx, double & lry) const { m_OGRDataSource->GetLayerChecked(m_CurrentLayer).GetExtent(ulx,uly,lrx,lry,true); } void GlVectorActor::GetExtent(double & ulx, double & uly, double & lrx, double & lry) const { PointType ul,lr,ur,ll, vpul,vplr, vpll, vpur; m_OGRDataSource->GetLayerChecked(m_CurrentLayer).GetExtent(ul[0],ul[1],lr[0],lr[1],true); ur=ul; ur[0]=lr[0]; ll=lr; ll[0]=ul[0]; vpul = m_ViewportBackwardRotationTransform->TransformPoint(m_VectorToViewportTransform->TransformPoint(ul)); vpur = m_ViewportBackwardRotationTransform->TransformPoint(m_VectorToViewportTransform->TransformPoint(ur)); vplr = m_ViewportBackwardRotationTransform->TransformPoint(m_VectorToViewportTransform->TransformPoint(lr)); vpll = m_ViewportBackwardRotationTransform->TransformPoint(m_VectorToViewportTransform->TransformPoint(ll)); ulx = std::min(std::min(vpul[0],vplr[0]),std::min(vpur[0],vpll[0])); uly = std::min(std::min(vpul[1],vplr[1]),std::min(vpur[1],vpll[1])); lrx = std::max(std::max(vpul[0],vplr[0]),std::max(vpur[0],vpll[0])); lry = std::max(std::max(vpul[1],vplr[1]),std::max(vpur[1],vpll[1])); } GlVectorActor::PointType GlVectorActor ::ViewportToVectorTransform(const PointType & vpPoint) const { /* // Because this method should be const, UpdateTransforms() should // not be called here. But, if this causes a buggy behaviour, // another solution must be thought about. if(m_ViewportToVectorTransform.IsNull()) { UpdateTransforms(); } */ // Actor should have been initialized before calling this method! assert( !m_ViewportToVectorTransform.IsNull() ); return m_ViewportToVectorTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(vpPoint)); } std::string GlVectorActor::GetWkt() const { if(m_OGRDataSource.IsNotNull()) { return m_OGRDataSource->GetLayerChecked(m_CurrentLayer).GetProjectionRef(); } return ""; } void GlVectorActor::ProcessViewSettings() { // Is there anything to do ? ViewSettings::ConstPointer settings = this->GetSettings(); RigidTransformType::ParametersType rigidParameters(5); rigidParameters.Fill(0); rigidParameters[0]=settings->GetRotationAngle(); rigidParameters[1]=settings->GetRotationCenter()[0]; rigidParameters[2]=settings->GetRotationCenter()[1]; m_ViewportForwardRotationTransform->SetParameters(rigidParameters); rigidParameters[0]=-settings->GetRotationAngle(); m_ViewportBackwardRotationTransform->SetParameters(rigidParameters); if((m_ViewportToVectorTransform.IsNull() || m_VectorToViewportTransform.IsNull()) || (settings->GetUseProjection() && settings->GetGeometryChanged())) { UpdateTransforms(); InternalFeaturesTransform(); UpdateDisplayList(); } } void GlVectorActor::UpdateData() { ViewSettings::ConstPointer settings = this->GetSettings(); // Retrieve the viewport extent PointType vpul,vplr,vpur,vpll, ul, lr, ll, ur; double ulx,uly,lrx,lry; settings->GetViewportExtent(vpul[0],vpul[1],vplr[0],vplr[1]); vpur = vpul; vpur[0] = vplr[0]; vpll = vplr; vpll[0] = vpul[0]; // Convert to layer extent ul = m_ViewportToVectorTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(vpul)); ur = m_ViewportToVectorTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(vpur)); ll = m_ViewportToVectorTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(vpll)); lr = m_ViewportToVectorTransform->TransformPoint(m_ViewportForwardRotationTransform->TransformPoint(vplr)); ulx = std::min(std::min(ul[0],lr[0]),std::min(ur[0],ll[0])); uly = std::min(std::min(ul[1],lr[1]),std::min(ur[1],ll[1])); lrx = std::max(std::max(ul[0],lr[0]),std::max(ur[0],ll[0])); lry = std::max(std::max(ul[1],lr[1]),std::max(ur[1],ll[1])); if(m_ExtentULX != ulx || m_ExtentULY != uly || m_ExtentLRX != lrx || m_ExtentLRY != lry || m_InternalFeatures.empty()) { m_ExtentULX = ulx; m_ExtentULY = uly; m_ExtentLRX = lrx; m_ExtentLRY = lry; double areaOfScreenPixel = vcl_abs(lrx-ulx)*vcl_abs(lry-uly) /(settings->GetViewportSize()[0]*settings->GetViewportSize()[1]); OGRPolygon spatialFilter; OGRLinearRing spatialFilterRing; OGRPoint pul,pur,plr,pll; pul.setX(ulx); pul.setY(uly); pur.setX(lrx); pur.setY(uly); plr.setX(lrx); plr.setY(lry); pll.setX(ulx); pll.setY(lry); spatialFilterRing.addPoint(&pul); spatialFilterRing.addPoint(&pur); spatialFilterRing.addPoint(&plr); spatialFilterRing.addPoint(&pll); spatialFilterRing.closeRings(); spatialFilter.addRing(&spatialFilterRing); otb::ogr::Layer filtered = m_OGRDataSource->GetLayerChecked(m_CurrentLayer); filtered.SetSpatialFilterRect(ulx,uly,lrx,lry); m_OptimizedRenderingActive = m_OptimizedRendering && filtered.GetFeatureCount(true)>static_cast(settings->GetViewportSize()[0]*settings->GetViewportSize()[1]/100); if(m_OptimizedRenderingActive) { std::ostringstream oss; oss<<"SELECT * FROM "<"<<100*areaOfScreenPixel; filtered = m_OGRDataSource->ExecuteSQL(oss.str(), &spatialFilter,ITK_NULLPTR); } m_InternalFeatures.clear(); otb::ogr::Layer::const_iterator featIt = filtered.begin(); for(; featIt!=filtered.end(); ++featIt) { otb::ogr::Feature srcFeature(m_OGRDataSource->GetLayerChecked(m_CurrentLayer).GetLayerDefn()); srcFeature.SetFrom( *featIt, TRUE ); InternalFeature newInternalFeature(m_OGRDataSource->GetLayerChecked(m_CurrentLayer).GetLayerDefn()); newInternalFeature.m_SourceFeature = srcFeature.Clone(); if(m_OptimizedRenderingActive) { newInternalFeature.m_SourceFeature.SetGeometry(srcFeature.GetGeometry()->SimplifyPreserveTopology(vcl_sqrt(areaOfScreenPixel))); } m_InternalFeatures.push_back(newInternalFeature); } InternalFeaturesTransform(); UpdateDisplayList(); } } // Inner helper functions namespace ice_internal { void GeometryRender(const OGRPoint * inPoint,const ViewSettings * settings, const unsigned int& size) { glBegin(GL_LINES); glVertex2d(inPoint->getX()-size*settings->GetSpacing()[0],inPoint->getY()); glVertex2d(inPoint->getX()+size*settings->GetSpacing()[0],inPoint->getY()); glVertex2d(inPoint->getX(),inPoint->getY()-size*settings->GetSpacing()[1]); glVertex2d(inPoint->getX(),inPoint->getY()+size*settings->GetSpacing()[1]); glEnd(); } void GeometryRender(const OGRLineString * in) { glBegin(GL_LINE_STRIP); for(int i = 0; i < in->getNumPoints();++i) { glVertex2d(in->getX(i),in->getY(i)); } glEnd(); } void GeometryRender(const OGRPolygon * in, GLUtesselator * tesselator, bool fill, bool solid) { std::vector vertices; gluTessProperty(tesselator, GLU_TESS_BOUNDARY_ONLY, !fill); // Begin a new polygon gluTessBeginPolygon(tesselator, ITK_NULLPTR); // Render the outer boundary gluTessBeginContour(tesselator); for(int i = 0; i < in->getExteriorRing()->getNumPoints();++i) { GLdouble * glp = new GLdouble[3]; glp[0] = in->getExteriorRing()->getX(i); glp[1] = in->getExteriorRing()->getY(i); glp[2] = 0; vertices.push_back(glp); gluTessVertex(tesselator,glp,glp); } // End the outer boundary contour gluTessEndContour(tesselator); for(int j = 0; j < in->getNumInteriorRings();++j) { gluTessBeginContour(tesselator); for(int i = 0; i < in->getInteriorRing(j)->getNumPoints();++i) { GLdouble * glp = new GLdouble[3]; glp[0] = in->getInteriorRing(j)->getX(i); glp[1] = in->getInteriorRing(j)->getY(i); glp[2] = 0; vertices.push_back(glp); gluTessVertex(tesselator,glp,glp); } gluTessEndContour(tesselator); } // End the polygon gluTessEndPolygon(tesselator); if(solid) { glDisable(GL_BLEND); gluTessProperty(tesselator, GLU_TESS_BOUNDARY_ONLY, true); // Begin a new polygon gluTessBeginPolygon(tesselator, ITK_NULLPTR); // Render the outer boundary gluTessBeginContour(tesselator); for(int i = 0; i < in->getExteriorRing()->getNumPoints();++i) { GLdouble * glp = new GLdouble[3]; glp[0] = in->getExteriorRing()->getX(i); glp[1] = in->getExteriorRing()->getY(i); glp[2] = 0; vertices.push_back(glp); gluTessVertex(tesselator,glp,glp); } // End the outer boundary contour gluTessEndContour(tesselator); for(int j = 0; j < in->getNumInteriorRings();++j) { gluTessBeginContour(tesselator); for(int i = 0; i < in->getInteriorRing(j)->getNumPoints();++i) { GLdouble * glp = new GLdouble[3]; glp[0] = in->getInteriorRing(j)->getX(i); glp[1] = in->getInteriorRing(j)->getY(i); glp[2] = 0; vertices.push_back(glp); gluTessVertex(tesselator,glp,glp); } gluTessEndContour(tesselator); } // End the polygon gluTessEndPolygon(tesselator); glEnable(GL_BLEND); } // free vertices for(std::vector::iterator it = vertices.begin();it!=vertices.end();++it) { delete[] (*it); } } void GeometryRender(const OGRMultiPoint * in, const ViewSettings * settings, const unsigned int & size) { for(int i = 0; i < in->getNumGeometries();++i) { const OGRPoint * p = dynamic_cast(in->getGeometryRef(i)); if(p) { GeometryRender(p,settings,size); } } } void GeometryRender(const OGRMultiLineString * in) { for(int i = 0; i < in->getNumGeometries();++i) { const OGRLineString * ls = dynamic_cast(in->getGeometryRef(i)); if(ls) { GeometryRender(ls); } } } void GeometryRender(const OGRMultiPolygon * in, GLUtesselator * tesselator, bool fill, bool solid) { for(int i = 0; i < in->getNumGeometries();++i) { const OGRPolygon * pol = dynamic_cast(in->getGeometryRef(i)); if(pol) { GeometryRender(pol,tesselator,fill,solid); } } } } // end namespace ice_internal void GlVectorActor::UpdateDisplayList() { // Build display list if(m_DisplayList == 0) { m_DisplayList = glGenLists (1); } glNewList(m_DisplayList, GL_COMPILE); for(std::vector::iterator it = m_InternalFeatures.begin(); it!=m_InternalFeatures.end();++it) { const OGRGeometry * geom = it->m_RenderedFeature.GetGeometry(); const OGRPoint * inPoint = dynamic_cast(geom); const OGRLineString * inLineString = dynamic_cast(geom); const OGRPolygon * inPolygon = dynamic_cast(geom); const OGRMultiPoint * inMPoints = dynamic_cast(geom); const OGRMultiLineString * inMLineStrings = dynamic_cast(geom); const OGRMultiPolygon * inMPolygons = dynamic_cast(geom); if(inPoint) { ice_internal::GeometryRender(const_cast(inPoint),this->GetSettings(),m_PointMarkerSize); } else if(inLineString) { ice_internal::GeometryRender(inLineString); } else if(inPolygon) { ice_internal::GeometryRender(inPolygon,m_GluTesselator,m_Fill, m_SolidBorder); } else if(inMPoints) { ice_internal::GeometryRender(inMPoints,this->GetSettings(),m_PointMarkerSize); } else if(inMLineStrings) { ice_internal::GeometryRender(inMLineStrings); } else if(inMPolygons) { ice_internal::GeometryRender(inMPolygons,m_GluTesselator,m_Fill, m_SolidBorder); } } glEndList(); m_DisplayListNeedsRebuild = false; } void GlVectorActor::Render() { if(m_DisplayListNeedsRebuild) { UpdateDisplayList(); } glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_LINE_SMOOTH); glLineWidth(m_LineWidth); glColor4d(m_Color[0],m_Color[1],m_Color[2],m_Alpha); glCallList(m_DisplayList); glDisable(GL_LINE_SMOOTH); glDisable(GL_BLEND); } void GlVectorActor::UpdateTransforms() { // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); m_ViewportToVectorTransform = RSTransformType::New(); m_VectorToViewportTransform = RSTransformType::New(); if(settings->GetUseProjection()) { m_ViewportToVectorTransform->SetInputProjectionRef(settings->GetWkt()); m_ViewportToVectorTransform->SetInputKeywordList(settings->GetKeywordList()); m_ViewportToVectorTransform->SetOutputProjectionRef((m_OGRDataSource->GetLayerChecked(m_CurrentLayer).GetProjectionRef())); m_VectorToViewportTransform->SetOutputProjectionRef(settings->GetWkt()); m_VectorToViewportTransform->SetOutputKeywordList(settings->GetKeywordList()); m_VectorToViewportTransform->SetInputProjectionRef((m_OGRDataSource->GetLayerChecked(m_CurrentLayer).GetProjectionRef())); } m_ViewportToVectorTransform->InstantiateTransform(); m_VectorToViewportTransform->InstantiateTransform(); } // Inner helper functions namespace ice_internal { OGRPoint GeometryTransform(const OGRPoint * inPoint, otb::GenericRSTransform<> * transform) { OGRPoint outPoint; otb::GenericRSTransform<>::InputPointType in,out; in[0] = inPoint->getX(); in[1] = inPoint->getY(); out = transform->TransformPoint(in); outPoint.setX(out[0]); outPoint.setY(out[1]); return outPoint; } OGRPoint GeometryTransform(OGRPoint * inPoint,otb::GenericRSTransform<> * transform) { return GeometryTransform(const_cast(inPoint),transform); } OGRLineString GeometryTransform(const OGRLineString * in,otb::GenericRSTransform<> * transform) { OGRLineString outLineString; for(int i = 0; igetNumPoints();++i) { OGRPoint p,op; in->getPoint(i,&p); op = GeometryTransform(&p,transform); outLineString.addPoint(&op); } return outLineString; } OGRPolygon GeometryTransform(const OGRPolygon * in,otb::GenericRSTransform<> * transform) { OGRPolygon outPolygon; // First process external ring const OGRLinearRing * inExtRing = in->getExteriorRing(); OGRLinearRing outExtRing; for(int i = 0; igetNumPoints();++i) { OGRPoint p,op; inExtRing->getPoint(i,&p); op = GeometryTransform(&p,transform); outExtRing.addPoint(&op); } outPolygon.addRing(&outExtRing); // Then process any interior ring for(int j = 0; jgetNumInteriorRings();++j) { const OGRLinearRing * inIntRing = in->getInteriorRing(j); OGRLinearRing outIntRing; for(int i = 0; igetNumPoints();++i) { OGRPoint p,op; inIntRing->getPoint(i,&p); op = GeometryTransform(&p,transform); outIntRing.addPoint(&op); } outPolygon.addRing(&outIntRing); } return outPolygon; } OGRMultiPoint GeometryTransform(const OGRMultiPoint * in, otb::GenericRSTransform<> * transform) { OGRMultiPoint outMultiPoint; for(int i = 0; i < in->getNumGeometries();++i) { const OGRPoint * inp = dynamic_cast(in->getGeometryRef(i)); if(inp) { OGRPoint p = GeometryTransform(inp,transform); outMultiPoint.addGeometry(&p); } } return outMultiPoint; } OGRMultiLineString GeometryTransform(const OGRMultiLineString * in, otb::GenericRSTransform<> * transform) { OGRMultiLineString outMultiLineString; for(int i = 0; i < in->getNumGeometries();++i) { const OGRLineString * inl = dynamic_cast(in->getGeometryRef(i)); if(inl) { OGRLineString l = GeometryTransform(inl,transform); outMultiLineString.addGeometry(&l); } } return outMultiLineString; } OGRMultiPolygon GeometryTransform(const OGRMultiPolygon * in, otb::GenericRSTransform<> * transform) { OGRMultiPolygon outMultiPolygon; for(int i = 0; i < in->getNumGeometries();++i) { const OGRPolygon * inp = dynamic_cast(in->getGeometryRef(i)); if(inp) { OGRPolygon p = GeometryTransform(inp,transform); outMultiPolygon.addGeometry(&p); } } return outMultiPolygon; } } // end namespace ice_internal void GlVectorActor::InternalFeaturesTransform() { for(std::vector::iterator it = m_InternalFeatures.begin(); it!=m_InternalFeatures.end();++it) { const OGRGeometry * geom = it->m_SourceFeature.GetGeometry(); const OGRPoint * inPoint = dynamic_cast(geom); const OGRLineString * inLineString = dynamic_cast(geom); const OGRPolygon * inPolygon = dynamic_cast(geom); const OGRMultiPoint * inMPoints = dynamic_cast(geom); const OGRMultiLineString * inMLineStrings = dynamic_cast(geom); const OGRMultiPolygon * inMPolygons = dynamic_cast(geom); if(inPoint) { OGRPoint outPoint = ice_internal::GeometryTransform(const_cast(inPoint),m_VectorToViewportTransform); it->m_RenderedFeature.SetGeometry(&outPoint); } else if(inLineString) { OGRLineString outLineString = ice_internal::GeometryTransform(inLineString,m_VectorToViewportTransform); it->m_RenderedFeature.SetGeometry(&outLineString); } else if(inPolygon) { OGRPolygon outPolygon = ice_internal::GeometryTransform(inPolygon,m_VectorToViewportTransform); it->m_RenderedFeature.SetGeometry(&outPolygon); } else if(inMPoints) { OGRMultiPoint outMPoints = ice_internal::GeometryTransform(inMPoints,m_VectorToViewportTransform); it->m_RenderedFeature.SetGeometry(&outMPoints); } else if(inMLineStrings) { OGRMultiLineString outMLineStrings = ice_internal::GeometryTransform(inMLineStrings,m_VectorToViewportTransform); it->m_RenderedFeature.SetGeometry(&outMLineStrings); } else if(inMPolygons) { OGRMultiPolygon outMPolygons = ice_internal::GeometryTransform(inMPolygons,m_VectorToViewportTransform); it->m_RenderedFeature.SetGeometry(&outMPolygons); } } } bool GlVectorActor ::TransformFromViewport( Point2d & out, const Point2d & in, bool isPhysical ) const { if( !isPhysical ) return false; out = ViewportToVectorTransform( in ); return true; } } // End of namespace 'otb'. OTB-release-5.8/Modules/Visualization/Ice/src/otbGlVersionChecker.cxx000066400000000000000000000105701301006202600256070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGlVersionChecker.h" #ifdef _WIN32 #include #endif #include #include #include #include #include #include "itkMacro.h" namespace otb { const char * GlVersionChecker::REQUIRED_GL_VERSION = "2.0.0"; const char * GlVersionChecker::REQUIRED_GLSL_VERSION = "1.20"; const char * GlVersionChecker ::GLVersion() { const GLubyte * glVersionStr = glGetString( GL_VERSION ); if( glVersionStr==ITK_NULLPTR ) { std::ostringstream oss; oss << "Failed to query OpenGL version string (error: " << glGetError() << ")."; throw std::runtime_error( oss.str() ); } return reinterpret_cast< const char * >( glVersionStr ); } const char * GlVersionChecker ::GLSLVersion() { const GLubyte * slVersionStr = glGetString( GL_SHADING_LANGUAGE_VERSION ); if( slVersionStr==ITK_NULLPTR ) { std::ostringstream oss; oss << "Failed to query OpenGL shading language version string (error: " << glGetError() << ")."; throw std::runtime_error( oss.str() ); } return reinterpret_cast< const char * >( slVersionStr ); } bool GlVersionChecker ::CheckGLCapabilities( const char * & glVersion, const char * & glslVersion ) { // Get OpenGL version. glVersion = GlVersionChecker::GLVersion(); // If OpenGL version is at least 2.0, get (and return) GLSL version // (before checking against OpenGL required version). if( GlVersionChecker::VerCmp( glVersion, "2.0" )<0 ) glslVersion = ITK_NULLPTR; else glslVersion = GlVersionChecker::GLSLVersion(); // Now, Check OpenGL version against required version. if( GlVersionChecker::VerCmp( glVersion, GlVersionChecker::REQUIRED_GL_VERSION )<0 ) return false; // // Then, check OpenGL SL version against required version. if( GlVersionChecker::VerCmp( glslVersion, GlVersionChecker::REQUIRED_GLSL_VERSION )<0 ) return false; // // Finally, Ok. return true; } bool GlVersionChecker ::SplitVersion( const char * version, int& major, int& minor, int& release ) { // // Special case: empty strings returns 0.0.0 and true. if( version==ITK_NULLPTR || strlen( version )==0 ) { major = 0; minor = 0; release = 0; return true; } // // Parse major part. major = atoi( version ); if( major<1 ) { major = 0; return false; } // // Parse minor part. minor = 0; const char * minorStr = strchr( version, '.' ); if( minorStr==ITK_NULLPTR ) return false; minor = atoi( ++minorStr ); // // Parse release part. release = 0; const char * releaseStr = strchr( minorStr, '.' ); // In this case, it is Ok to return because version of the form // Major.minor are handled. if( releaseStr==ITK_NULLPTR ) return true; release = atoi( ++releaseStr ); // // Ok. return true; } int GlVersionChecker ::VerCmp( const char * version, const char * required ) { // // Split version. int verMaj = -1; int verMin = -1; int verRel = -1; if( !GlVersionChecker::SplitVersion( version, verMaj, verMin, verRel ) ) throw std::invalid_argument( version ); // // Split required version. int reqMaj = -1; int reqMin = -1; int reqRel = -1; if( !GlVersionChecker::SplitVersion( required, reqMaj, reqMin, reqRel ) ) throw std::runtime_error( required ); // // Compare split versions. if( verMajreqMaj ) return 1; else // if( verMaj==reqMaj ) { if( verMinreqMin ) return 1; else // if( verMin==reqMin ) { if( verRelreqRel ) return 1; else // if( verRel==reqRel ) return 0; } } } } // End namespace otb OTB-release-5.8/Modules/Visualization/Ice/src/otbGlView.cxx000066400000000000000000000256211301006202600236120ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbGlView.h" #ifdef _WIN32 #include #endif #include #include #include #include #include "itkRGBAPixel.h" #include "otbGeoInterface.h" #include "otbImage.h" #include "otbImageFileWriter.h" #include "otbImportImageFilter.h" namespace otb { GlView::GlView() : m_Settings(ViewSettings::New()), m_Actors(), m_RenderingOrder() {} GlView::~GlView() {} void GlView::Initialize(unsigned int sx, unsigned int sy) { m_Settings = ViewSettings::New(); this->ClearActors(); this->Resize(sx,sy); } void GlView::Resize(unsigned int sx, unsigned int sy) { ViewSettings::SizeType size; size[0] = sx; size[1] = sy; m_Settings->SetViewportSize(size); } void GlView::BeforeRendering() { // First, get all actors informed of new settings for(ActorMapType::iterator it = m_Actors.begin(); it!=m_Actors.end();++it) { if(it->second->GetVisible()) { it->second->ProcessViewSettings(); } } // Second, get opengl ready // Reset viewport glViewport(0, 0, (GLint)m_Settings->GetViewportSize()[0], (GLint)m_Settings->GetViewportSize()[1]); // Clear back-buffer(s) before rendering glClear( GL_COLOR_BUFFER_BIT ); // Setup projection according to view settings glMatrixMode(GL_PROJECTION); glLoadIdentity(); double ulx = -1.0; double uly = -1.0; double lrx = 1.0; double lry = 1.0; m_Settings->GetViewportExtent(ulx,uly,lrx,lry); glOrtho(ulx, lrx, lry, uly, -1, 1); // std::cout // << "glOrtho( " // << ulx << ", " << lrx << ", " // << lry << ", " << uly // << ", -1, 1 )" // << std::endl; glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glPushMatrix(); glTranslatef(m_Settings->GetRotationCenter()[0],m_Settings->GetRotationCenter()[1],0); glRotatef(-m_Settings->GetRotationAngle()*180/M_PI,0,0,1); glTranslatef(-m_Settings->GetRotationCenter()[0],-m_Settings->GetRotationCenter()[1],0); // glScalef(m_Settings->GetSpacing()[0],m_Settings->GetSpacing()[1],1); } void GlView::AfterRendering() { // std::cout << "geometry-changed: FALSE" << std::endl; m_Settings->SetGeometryChanged(false); glPopMatrix(); } std::string GlView::AddActor(ActorType * actor, const std::string& key) { std::string newKey = key; if(newKey == "") { std::ostringstream oss; oss<<"Actor"<SetSettings(m_Settings); m_Actors[newKey] = actor; m_RenderingOrder.push_back(newKey); return newKey; } bool GlView::RemoveActor(const std::string & key) { if(m_Actors.count(key) == 0) { return false; } m_Actors.erase(key); StringVectorType::iterator it = std::find(m_RenderingOrder.begin(),m_RenderingOrder.end(),key); if(it!=m_RenderingOrder.end()) { m_RenderingOrder.erase(it); } return true; } void GlView::ClearActors() { m_Actors.clear(); m_RenderingOrder.clear(); } GlView::ActorType::Pointer GlView::GetActor(const std::string & key) const { // if(m_Actors.count(key)==0) // { // itkExceptionMacro(<<"No actor found with key"<first==key ); return it->second; } bool GlView ::ContainsActor( const KeyType & key ) const { return ActorMapType::const_iterator( m_Actors.find( key ) )!=m_Actors.end(); } std::vector GlView::GetActorsKeys() const { std::vector resp; for(ActorMapType::const_iterator it = m_Actors.begin(); it!=m_Actors.end();++it) { resp.push_back(it->first); } return resp; } void GlView::LightRender() { // std::cout // << "otb::GlView@" << std::hex << this << std::dec // << "::LightRender()" << std::endl; // std::cout << "{" << std::endl; // { // double ulx = 0.0; // double uly = 0.0; // double lrx = 0.0; // double lry = 0.0; // m_Settings->GetViewportExtent( ulx, uly, lrx, lry ); // std::cout << "v-origin: " << ulx << ", " << uly << std::endl; // std::cout << "v-extent: " << lrx << ", " << lry << std::endl; // } // std::cout // << "v-spacing: " // << m_Settings->GetSpacing()[ 0 ] << ", " // << m_Settings->GetSpacing()[ 1 ] << std::endl; // std::cout // << "v-size: " // << m_Settings->GetViewportSize()[ 0 ] << ", " // << m_Settings->GetViewportSize()[ 1 ] << std::endl; for(StringVectorType::reverse_iterator it = m_RenderingOrder.rbegin(); it!=m_RenderingOrder.rend();++it) { ActorMapType::iterator actIt = m_Actors.find(*it); if(actIt != m_Actors.end() && actIt->second->GetVisible()) { actIt->second->Render(); actIt->second->GeometryChangedOff(); } } // std::cout << "}" << std::endl; } void GlView::HeavyRender() { // TODO: Light render/ heavy render could be optimized for(StringVectorType::reverse_iterator it = m_RenderingOrder.rbegin(); it!=m_RenderingOrder.rend();++it) { ActorMapType::iterator actIt = m_Actors.find(*it); if(actIt != m_Actors.end() && actIt->second->GetVisible()) { actIt->second->UpdateData(); } } this->LightRender(); } void GlView::RotateRenderingOrder(bool down) { if(m_RenderingOrder.size()>1) { if(down) { std::rotate(m_RenderingOrder.rbegin(),m_RenderingOrder.rbegin()+1,m_RenderingOrder.rend()); } else { std::rotate(m_RenderingOrder.begin(),m_RenderingOrder.begin()+1,m_RenderingOrder.end()); } } } // Move actor in rendering order void GlView::MoveActorInRenderingOrder(std::string key, bool down) { StringVectorType::iterator it = std::find(m_RenderingOrder.begin(),m_RenderingOrder.end(),key); if(it!=m_RenderingOrder.end()) { if(down && it+1 != m_RenderingOrder.end()) { std::swap(*it,*(it+1)); } else if(!down && it != m_RenderingOrder.begin()) { std::swap((*it),*(it-1)); } } } // Move actor to the end of rendering order (either front if front // is set to true or back if front is set to false) void GlView::MoveActorToEndOfRenderingOrder(std::string key, bool front) { StringVectorType::iterator it = std::find(m_RenderingOrder.begin(),m_RenderingOrder.end(),key); if(it!=m_RenderingOrder.end()) { if(front) { m_RenderingOrder.erase(it); m_RenderingOrder.insert(m_RenderingOrder.begin(),key); } else { m_RenderingOrder.erase(it); m_RenderingOrder.push_back(key); } } } void GlView ::SetRenderingOrder( const StringVectorType & keys, bool front ) { StringVectorType thisKeys( m_RenderingOrder ); m_RenderingOrder.clear(); for( StringVectorType::const_iterator it( keys.begin() ); it!=keys.end(); ++it ) if( ContainsActor( *it ) ) { m_RenderingOrder.push_back( *it ); StringVectorType::iterator pos = find(thisKeys.begin(),thisKeys.end(),*it); if(pos!=thisKeys.end()) { thisKeys.erase(pos); } } m_RenderingOrder.insert( front ? m_RenderingOrder.end() : m_RenderingOrder.begin(), thisKeys.begin(), thisKeys.end() ); } void GlView ::SaveScreenshot( const std::string & filename ) const { // // Check input(s). assert( !filename.empty() ); // // Get size of viewport. assert( !m_Settings.IsNull() ); ViewSettings::SizeType size( m_Settings->GetViewportSize() ); assert( size[ 0 ]>0 && size[ 1 ]>0 ); // // Define types. typedef itk::RGBPixel< GLubyte > RgbPixel; typedef otb::Image< RgbPixel > RgbImage; typedef otb::ImportImageFilter< RgbImage > ImportRgbImageFilter; typedef otb::ImageFileWriter< RgbImage > RgbImageFileWriter; // // Setup OpenGL pixel storage. glPixelStorei( GL_PACK_ALIGNMENT, 1 ); // // Check against OpenGL error and throw exception if any. assert( glGetError()==GL_NO_ERROR ); if( glGetError()!=GL_NO_ERROR ) throw std::runtime_error( std::string( reinterpret_cast< const char * >( gluErrorString( glGetError() ) ) ) ); // // Read OpenGL pixel buffer. unsigned long count = size[ 0 ] * size[ 1 ]; assert( RgbPixel::Length==3 ); assert( sizeof( GLubyte )==1 ); RgbPixel::ValueType * glBuffer = new RgbPixel::ValueType[ RgbPixel::Length * count ]; assert( glBuffer!=NULL ); glReadPixels( 0, 0, size[ 0 ], size[ 1 ], GL_RGB, GL_UNSIGNED_BYTE, glBuffer ); // // Check against OpenGL error and throw exception if any. assert( glGetError()==GL_NO_ERROR ); if( glGetError()!=GL_NO_ERROR ) throw std::runtime_error( std::string( reinterpret_cast< const char * >( gluErrorString( glGetError() ) ) ) ); // // Copy & flip OpenGL pixel buffer into itk::RGBAPixel<> buffer. RgbPixel * itkBuffer = new RgbPixel[ count ]; assert( itkBuffer ); for( unsigned long j=0; jSetRegion( ImportRgbImageFilter::RegionType( index, size ) ); // Pass ownership of allocated buffer to ImportRgbImageFilter. So, // it will be deleted automatically in case an exception is thrown. filter->SetImportPointer( itkBuffer, count, true ); // // Setup RGBA-image file-writer. RgbImageFileWriter::Pointer writer( RgbImageFileWriter::New() ); assert( !writer.IsNull() ); writer->SetInput( filter->GetOutput() ); writer->SetFileName( filename ); // // Run. writer->Update(); // // Allocated buffer will be freed by RgbImportImageFilter. // delete[] itkBuffer; // itkBuffer = NULL; } } OTB-release-5.8/Modules/Visualization/Ice/src/otbImageSettings.cxx000066400000000000000000000020751301006202600251560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbImageSettings.h" #include "otbFragmentShaderRegistry.h" #include "otbGlVersionChecker.h" #include namespace otb { ImageSettings::ImageSettings() : m_MinRed( 0 ), m_MaxRed( 255 ), m_MinGreen( 0 ), m_MaxGreen( 255 ), m_MinBlue( 0 ), m_MaxBlue( 255 ), m_UseNoData( false ), m_NoData( 0 ), m_Gamma( 1. ), m_Alpha( 1. ), m_CurrentRed( 0 ), m_CurrentGreen( 0 ), m_CurrentBlue( 0 ) { } ImageSettings::~ImageSettings() { } } // End namespace otb OTB-release-5.8/Modules/Visualization/Ice/src/otbNonOptGlImageActor.cxx000066400000000000000000000604441301006202600260530ustar00rootroot00000000000000#include "otbNonOptGlImageActor.h" #include "otbViewSettings.h" #include "otbMath.h" #include namespace otb { // Shaders section unsigned int NonOptGlImageActor::m_StandardShader = 0; unsigned int NonOptGlImageActor::m_StandardShaderProgram = 0; bool NonOptGlImageActor::m_ShaderInitialized = false; NonOptGlImageActor::NonOptGlImageActor() : m_TileSize(256), m_FileName(), m_FileReader(), m_LoadedTiles(), m_RedIdx(1), m_GreenIdx(2), m_BlueIdx(3), m_MinRed(200), m_MaxRed(1200), m_MinGreen(200), m_MaxGreen(1200), m_MinBlue(200), m_MaxBlue(1200), m_CurrentResolution(1), m_AvailableResolutions(), m_Origin(), m_Spacing(), m_NumberOfComponents(0), m_UseShader(false), m_ViewportToImageTransform(RSTransformType::New()), m_ImageToViewportTransform(RSTransformType::New()) {} NonOptGlImageActor::~NonOptGlImageActor() {} const NonOptGlImageActor::PointType & NonOptGlImageActor::GetOrigin() const { return m_Origin; } const NonOptGlImageActor::SpacingType & NonOptGlImageActor::GetSpacing() const { return m_Spacing; } std::string NonOptGlImageActor::GetWkt() const { return m_FileReader->GetOutput()->GetProjectionRef(); } NonOptGlImageActor::ImageKeywordlistType NonOptGlImageActor::GetKwl() const { return m_FileReader->GetOutput()->GetImageKeywordlist(); } void NonOptGlImageActor::Initialize(const std::string & filename) { // Initialize shaders InitShaders(); // First, clean up any previous data this->ClearLoadedTiles(); m_FileName = filename; m_FileReader = ReaderType::New(); m_FileReader->SetFileName(m_FileName); m_FileReader->UpdateOutputInformation(); if(m_FileReader->GetOutput()->GetNumberOfComponentsPerPixel() < 3) { m_RedIdx = 1; m_GreenIdx = 1; m_BlueIdx = 1; } m_Origin = m_FileReader->GetOutput()->GetOrigin(); m_Spacing = m_FileReader->GetOutput()->GetSpacing(); m_NumberOfComponents = m_FileReader->GetOutput()->GetNumberOfComponentsPerPixel(); unsigned int ovrCount = m_FileReader->GetOverviewsCount(); m_AvailableResolutions.clear(); for(unsigned int i =1; i <= ovrCount;++i) { m_AvailableResolutions.push_back(ovrCount); } m_CurrentResolution = m_AvailableResolutions.front(); // Update transforms once data is read UpdateTransforms(); // std::cout<<"Number of resolutions in file: "<GetOutput()->GetLargestPossibleRegion(); ImageRegionToViewportExtent(largest,ulx,uly,lrx,lry); } void NonOptGlImageActor::ProcessViewSettings() { // Is there anything to do ? ViewSettings::ConstPointer settings = this->GetSettings(); if(settings->GetUseProjection() && settings->GetGeometryChanged()) { UpdateTransforms(); for (TileVectorType::iterator it = m_LoadedTiles.begin(); it!=m_LoadedTiles.end(); ++it) { this->ImageRegionToViewportQuad(it->m_ImageRegion,it->m_UL,it->m_UR,it->m_LL,it->m_LR); } } } void NonOptGlImageActor::UpdateData() { // Update resolution needed UpdateResolution(); // First, clean existing tiles CleanLoadedTiles(); // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); RegionType largest = m_FileReader->GetOutput()->GetLargestPossibleRegion(); double ulx, uly, lrx, lry; settings->GetViewportExtent(ulx,uly,lrx,lry); // std::cout<<"Viewport extent: "<ViewportExtentToImageRegion(ulx,uly,lrx,lry,requested); // std::cout<<"Corresponding image region: "<(requested.GetIndex()[0] + requested.GetSize()[0])/m_TileSize) -vcl_floor(static_cast(requested.GetIndex()[0])/m_TileSize); unsigned int nbTilesY = vcl_ceil(static_cast(requested.GetIndex()[1] + requested.GetSize()[1])/m_TileSize) -vcl_floor(static_cast(requested.GetIndex()[1])/m_TileSize); //unsigned int nbTilesY = vcl_ceil(static_cast(requested.GetSize()[1])/m_TileSize); unsigned int tileStartX = m_TileSize*(requested.GetIndex()[0]/m_TileSize); unsigned int tileStartY = m_TileSize*(requested.GetIndex()[1]/m_TileSize); // std::cout<<"Required tiles: "<(tileStartX+i*m_TileSize); tileIndex[1] = static_cast(tileStartY+j*m_TileSize); newTile.m_ImageRegion.SetSize(tileSize); newTile.m_ImageRegion.SetIndex(tileIndex); newTile.m_ImageRegion.Crop(m_FileReader->GetOutput()->GetLargestPossibleRegion()); ImageRegionToViewportQuad(newTile.m_ImageRegion,newTile.m_UL,newTile.m_UR,newTile.m_LL,newTile.m_LR); // std::cout<<"Loading tile "<m_ImageRegion == tile.m_ImageRegion) { bool resp = (tile.m_Resolution == it->m_Resolution && tile.m_RedIdx == it->m_RedIdx && tile.m_GreenIdx == it->m_GreenIdx && tile.m_BlueIdx == it->m_BlueIdx && (tile.m_UseShader == m_UseShader)); if(!m_UseShader) { return resp &&tile.m_MinRed == m_MinRed &&tile.m_MinGreen == m_MinGreen &&tile.m_MinBlue == m_MinBlue &&tile.m_MaxRed == m_MaxRed &&tile.m_MaxGreen == m_MaxGreen &&tile.m_MaxBlue == m_MaxBlue; } else { return resp; } } } return false; } void NonOptGlImageActor::Render() { // std::cout<<"Render: "<m_TextureId); // Reset color before rendering glColor3d(1.0f,1.0f,1.0f); glBegin (GL_QUADS); glTexCoord2f (0.0, 1.0); glVertex2f(it->m_LL[0], it->m_LL[1]); glTexCoord2f (1.0, 1.0); glVertex2f(it->m_LR[0], it->m_LR[1]); glTexCoord2f (1.0, 0.0); glVertex2f(it->m_UR[0], it->m_UR[1]); glTexCoord2f (0.0, 0.0); glVertex2f(it->m_UL[0], it->m_UL[1]); glEnd (); glDisable(GL_TEXTURE_2D); } if(m_UseShader) { glUseProgramObjectARB(0); } } void NonOptGlImageActor::LoadTile(Tile& tile) { ExtractROIFilterType::Pointer extract = ExtractROIFilterType::New(); extract->SetInput(m_FileReader->GetOutput()); extract->SetExtractionRegion(tile.m_ImageRegion); extract->SetChannel(tile.m_RedIdx); extract->SetChannel(tile.m_GreenIdx); extract->SetChannel(tile.m_BlueIdx); if(!tile.m_UseShader) { RescaleFilterType::Pointer rescale = RescaleFilterType::New(); rescale->SetInput(extract->GetOutput()); rescale->AutomaticInputMinMaxComputationOff(); VectorImageType::PixelType mins(3),maxs(3),omins(3),omaxs(3); mins[0] = m_MinRed; mins[1] = m_MinGreen; mins[2] = m_MinBlue; maxs[0] = m_MaxRed; maxs[1] = m_MaxGreen; maxs[2] = m_MaxBlue; omins.Fill(0); omaxs.Fill(255); rescale->SetInputMinimum(mins); rescale->SetInputMaximum(maxs); rescale->SetOutputMinimum(omins); rescale->SetOutputMaximum(omaxs); rescale->Update(); itk::ImageRegionConstIterator it(rescale->GetOutput(),rescale->GetOutput()->GetLargestPossibleRegion()); unsigned char * buffer = new unsigned char[4*rescale->GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels()]; unsigned int idx = 0; for(it.GoToBegin();!it.IsAtEnd();++it) { buffer[idx] = static_cast(it.Get()[2]); ++idx; buffer[idx] = static_cast(it.Get()[1]); ++idx; buffer[idx] = static_cast(it.Get()[0]); ++idx; buffer[idx] = 255; ++idx; } // Now load the texture glGenTextures(1, &(tile.m_TextureId)); glBindTexture(GL_TEXTURE_2D, tile.m_TextureId); #if defined(GL_TEXTURE_BASE_LEVEL) && defined(GL_TEXTURE_MAX_LEVEL) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); #endif glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); // #if defined(GL_CLAMP_TO_BORDER) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER); // #elif defined (GL_CLAMP_TO_BORDER_EXT) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER_EXT); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER_EXT); // #elif defined (GL_MIRRORED_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT); // #endif glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, rescale->GetOutput()->GetLargestPossibleRegion().GetSize()[0], rescale->GetOutput()->GetLargestPossibleRegion().GetSize()[1], 0, GL_BGRA, GL_UNSIGNED_BYTE, buffer); tile.m_Loaded = true; tile.m_UseShader = false; delete [] buffer; } // else !m_UseShader else { extract->Update(); itk::ImageRegionConstIterator it(extract->GetOutput(),extract->GetOutput()->GetLargestPossibleRegion()); float * buffer = new float[4*extract->GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels()]; unsigned int idx = 0; for(it.GoToBegin();!it.IsAtEnd();++it) { buffer[idx] = static_cast(it.Get()[2]); ++idx; buffer[idx] = static_cast(it.Get()[1]); ++idx; buffer[idx] = static_cast(it.Get()[0]); ++idx; buffer[idx] = 255.; ++idx; } // Now load the texture glGenTextures(1, &(tile.m_TextureId)); glBindTexture(GL_TEXTURE_2D, tile.m_TextureId); #if defined(GL_TEXTURE_BASE_LEVEL) && defined(GL_TEXTURE_MAX_LEVEL) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); #endif glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); // #if defined(GL_CLAMP_TO_BORDER) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER); // #elif defined (GL_CLAMP_TO_BORDER_EXT) // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER_EXT); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER_EXT); // #elif defined (GL_MIRRORED_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT); // #endif glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB32F, extract->GetOutput()->GetLargestPossibleRegion().GetSize()[0], extract->GetOutput()->GetLargestPossibleRegion().GetSize()[1], 0, GL_BGRA, GL_FLOAT, buffer); tile.m_Loaded = true; tile.m_UseShader = true; delete [] buffer; } // And push to loaded texture m_LoadedTiles.push_back(tile); } void NonOptGlImageActor::UnloadTile(Tile& tile) { if(tile.m_Loaded) { glDeleteTextures(1,&tile.m_TextureId); tile.m_Loaded = false; } } void NonOptGlImageActor::CleanLoadedTiles() { TileVectorType newLoadedTiles; // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); double ulx, uly, lrx, lry; settings->GetViewportExtent(ulx,uly,lrx,lry); RegionType requested; this->ViewportExtentToImageRegion(ulx,uly,lrx,lry,requested); for(TileVectorType::iterator it = m_LoadedTiles.begin(); it!=m_LoadedTiles.end();++it) { RegionType tileRegion = it->m_ImageRegion; // Test if tileRegion intersects requested region if(!tileRegion.Crop(requested) || it->m_Resolution != m_CurrentResolution || it->m_RedIdx != m_RedIdx || it->m_GreenIdx != m_GreenIdx || it->m_BlueIdx != m_BlueIdx || (it->m_UseShader != m_UseShader) || (!m_UseShader && it->m_MinRed != m_MinRed) || (!m_UseShader &&it->m_MinGreen != m_MinGreen) || (!m_UseShader &&it->m_MinBlue != m_MinBlue) || (!m_UseShader &&it->m_MaxRed != m_MaxRed) || (!m_UseShader &&it->m_MaxGreen != m_MaxGreen) || (!m_UseShader &&it->m_MaxBlue != m_MaxBlue)) { // Tile will not be used anymore, unload it from GPU UnloadTile(*it); } else { newLoadedTiles.push_back(*it); } } // std::cout<<"GPU memory cleanup: removing "<GetSettings(); itk::ContinuousIndex cul,cur,cll,clr; cul[0] = region.GetIndex()[0]; cul[1] = region.GetIndex()[1]; cur = cul; cur[0]+=region.GetSize()[0]; cll = cul; cll[1]+=region.GetSize()[1]; clr = cur; clr[1]+=region.GetSize()[1]; PointType iul, iur,ill,ilr; m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(cul,iul); m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(cur,iur); m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(cll,ill); m_FileReader->GetOutput()->TransformContinuousIndexToPhysicalPoint(clr,ilr); PointType pul = m_ImageToViewportTransform->TransformPoint(iul); PointType pur = m_ImageToViewportTransform->TransformPoint(iur); PointType pll = m_ImageToViewportTransform->TransformPoint(ill); PointType plr = m_ImageToViewportTransform->TransformPoint(ilr); ul[0] = pul[0]; ul[1] = pul[1]; ur[0] = pur[0]; ur[1] = pur[1]; ll[0] = pll[0]; ll[1] = pll[1]; lr[0] = plr[0]; lr[1] = plr[1]; } void NonOptGlImageActor::ViewportExtentToImageRegion(const double& ulx, const double & uly, const double & lrx, const double & lry, RegionType & region) const { // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); RegionType largest = m_FileReader->GetOutput()->GetLargestPossibleRegion(); PointType ul,ur,ll,lr,tul,tur,tll,tlr; ul[0]=ulx; ul[1]=uly; ur[0]=lrx; ur[1]=uly; ll[0]=ulx; ll[1]=lry; lr[0]=lrx; lr[1]=lry; tul = m_ViewportToImageTransform->TransformPoint(ul); tur = m_ViewportToImageTransform->TransformPoint(ur); tll = m_ViewportToImageTransform->TransformPoint(ll); tlr = m_ViewportToImageTransform->TransformPoint(lr); itk::ContinuousIndex cul,cur,cll,clr; m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tul,cul); m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tur,cur); m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tll,cll); m_FileReader->GetOutput()->TransformPhysicalPointToContinuousIndex(tlr,clr); // TODO: Take into account origin/scaling/rotation here ? // TODO: Screen to image / image to screen transform calls here ? double iulx, iuly, ilrx, ilry; iulx = std::max(std::min(std::min(cul[0],cur[0]),std::min(cll[0],clr[0])),0.); iuly = std::max(std::min(std::min(cul[1],cur[1]),std::min(cll[1],clr[1])),0.); ilrx = std::min(std::max(std::max(cul[0],cur[0]),std::max(cll[0],clr[0])),static_cast(largest.GetSize()[0])); ilry = std::min(std::max(std::max(cul[1],cur[1]),std::max(cll[1],clr[1])),static_cast(largest.GetSize()[1])); // Now we have the requested part of image, we need to find the // corresponding tiles IndexType index; index[0] = static_cast(iulx); index[1] = static_cast(iuly); SizeType size; size[0] = static_cast(ilrx-iulx); size[1] = static_cast(ilry-iuly); region.SetSize(size); region.SetIndex(index); region.Crop(m_FileReader->GetOutput()->GetLargestPossibleRegion()); } void NonOptGlImageActor::UpdateResolution() { // Retrieve settings ViewSettings::ConstPointer settings = this->GetSettings(); // Retrieve viewport spacing ViewSettings::SpacingType spacing = settings->GetSpacing(); PointType pointA, pointB; pointA = settings->GetOrigin(); pointB = pointA; pointB[0]+=100*spacing[0]; pointB[1]+=100*spacing[1]; // TODO: This part needs a review // Transform the spacing vector pointA = m_ViewportToImageTransform->TransformPoint(pointA); pointB = m_ViewportToImageTransform->TransformPoint(pointB); SpacingType outSpacing; outSpacing[0] = (pointB[0]-pointA[0])/100; outSpacing[1] = (pointB[1]-pointA[1])/100; // std::cout<<"Estimated spacing: "<GetSettings(); m_ViewportToImageTransform = RSTransformType::New(); m_ImageToViewportTransform = RSTransformType::New(); if(settings->GetUseProjection()) { m_ViewportToImageTransform->SetInputProjectionRef(settings->GetWkt()); m_ViewportToImageTransform->SetInputKeywordList(settings->GetKeywordList()); m_ViewportToImageTransform->SetOutputProjectionRef(m_FileReader->GetOutput()->GetProjectionRef()); m_ViewportToImageTransform->SetOutputKeywordList(m_FileReader->GetOutput()->GetImageKeywordlist()); m_ImageToViewportTransform->SetOutputProjectionRef(settings->GetWkt()); m_ImageToViewportTransform->SetOutputKeywordList(settings->GetKeywordList()); m_ImageToViewportTransform->SetInputProjectionRef(m_FileReader->GetOutput()->GetProjectionRef()); m_ImageToViewportTransform->SetInputKeywordList(m_FileReader->GetOutput()->GetImageKeywordlist()); } m_ViewportToImageTransform->InstantiateTransform(); m_ImageToViewportTransform->InstantiateTransform(); } void NonOptGlImageActor::InitShaders() { if(!NonOptGlImageActor::m_ShaderInitialized) { std::string source = "#version 120 \n"\ "uniform sampler2D src;\n"\ "uniform vec4 shader_a;\n"\ "uniform vec4 shader_b;\n"\ "void main (void) {\n"\ "vec4 p = texture2D(src, gl_TexCoord[0].xy);\n"\ "gl_FragColor = clamp((p + shader_b)*shader_a, 0.0, 1.0);\n"\ "}"; // std::string source = "in vec4 Color;\nvoid main()\n{\ngl_FragColor = Color;\n}\0"; // std::cout<<"Shader source: "< #include #include "otbFragmentShaderRegistry.h" #include "otbGlVersionChecker.h" namespace otb { StandardShader::StandardShader() : m_LocalContrastRange( 50 ), m_SpectralAngleRange( 10 ), m_Center(), m_Radius( 200 ), m_ChessboardSize( 256 ), m_SliderPosition( 500 ), m_VerticalSlider( false ), m_ShaderType( SHADER_STANDARD ) { m_Center.Fill( 0 ); BuildShader(); } StandardShader::~StandardShader() {} std::string StandardShader::GetSource() const { const char * glVersion = ITK_NULLPTR; const char * glslVersion = ITK_NULLPTR; if(!otb::GlVersionChecker::CheckGLCapabilities( glVersion, glslVersion)) { itkExceptionMacro(<<" Required GL and GLSL versions were not found (GL version is "<=0; std::string shader_source = ""; if(isGLSLS140Available) { shader_source+="#version 140 \n"; } else { shader_source+="#version 130 \n"; } shader_source = "uniform sampler2D src;\n" \ "uniform vec4 shader_a;\n" \ "uniform vec4 shader_b;\n" \ "uniform int shader_use_no_data;\n" \ "uniform float shader_no_data;\n" \ "uniform vec3 shader_current;\n" \ "uniform vec4 shader_gamma;\n" \ "uniform float shader_alpha;\n" \ "uniform vec2 shader_center;\n" \ "uniform int shader_type;\n" \ "uniform float shader_radius;\n" \ "uniform float shader_localc_range;\n" \ "uniform float shader_spectral_angle_range;\n" \ "uniform float shader_chessboard_size;\n" \ "uniform float shader_slider_pos;\n" \ "uniform int shader_vertical_slider_flag;\n" \ "void main (void) {\n" \ "vec4 p = texture2D(src, gl_TexCoord[0].xy);\n" \ "gl_FragColor = pow( clamp( ( p+shader_b ) * shader_a, 0.0, 1.0 ), shader_gamma );\n" \ "gl_FragColor[3] = clamp(shader_alpha,0.0,1.0);\n" \ "if(shader_use_no_data > 0 && vec3(p) == vec3(shader_no_data)){\n" \ "gl_FragColor[3] = 0.;\n" \ "}\n" \ "float alpha = gl_FragColor[3];\n" \ "float dist = distance(gl_FragCoord.xy,shader_center);\n" \ "if(shader_type == 1)\n" \ "{\n" \ "if(dist < shader_radius)\n" \ "{\n" \ "vec3 tmp = clamp((vec3(p)-vec3(shader_current)+vec3(shader_localc_range))/(2.*vec3(shader_localc_range)),0.0,1.0);\n" \ "gl_FragColor[0] = tmp[0];\n" \ "gl_FragColor[1] = tmp[1];\n" \ "gl_FragColor[2] = tmp[2];\n" \ "gl_FragColor[3] = alpha;\n" \ "}\n" \ "}\n" \ "else if(shader_type == 2)" \ "{\n" \ "gl_FragColor[3] = dist > shader_radius ? 1.0 : 0.0; \n" \ "}\n" \ "else if(shader_type == 3)\n" \ "{\n" \ "float alpha = (mod(floor(gl_FragCoord.x / shader_chessboard_size), 2.0) == 0.) != (mod(floor(gl_FragCoord.y / shader_chessboard_size), 2.0) == 1.) ? shader_alpha : 0.0;\n" \ "gl_FragColor[3] = clamp(alpha,0.0,1.0);\n" \ "}\n" \ "else if(shader_type == 4)\n" \ "{\n" \ "float alpha = (shader_vertical_slider_flag == 0 && gl_FragCoord.x > shader_slider_pos) || (shader_vertical_slider_flag == 1 && gl_FragCoord.y > shader_slider_pos) ? 1.0 : 0.0;\n" \ "gl_FragColor[3] = clamp(alpha,0.0,1.0);\n" \ "}\n" \ "else if(shader_type == 5)\n" \ "{\n" \ "if(dist < shader_radius)\n" \ "{\n" \ "float angle = acos(clamp(dot(vec3(p),shader_current)/(length(vec3(p))*length(shader_current)),-1.0,1.0));\n" \ "vec3 tmp = clamp(vec3(1.-shader_spectral_angle_range*abs(angle)/3.142),0.0,1.0);\n" \ "gl_FragColor[0] = tmp[0];\n" \ "gl_FragColor[1] = tmp[1];\n" \ "gl_FragColor[2] = tmp[2];\n" \ "gl_FragColor[3] = alpha;\n" \ "}\n" \ "}\n"; if(isGLSLS140Available) { shader_source+= "else if(shader_type == 6)\n" \ "{\n" \ "if(dist < shader_radius)\n" \ "{\n" \ "vec2 size = vec2(textureSize(src,0));\n" \ "vec2 dx = vec2(gl_TexCoord[0].xy);\n" \ "dx[0]+=1.0/size[0];\n" \ "vec2 dy = vec2(gl_TexCoord[0].xy);\n" \ "dy[1]+=1.0/size[1];\n" \ "vec4 pdx = texture2D(src, dx);\n" \ "vec4 pdy = texture2D(src, dy);\n" \ "gl_FragColor = clamp(pow(5*shader_a*(0.5*abs((pdx-p))+ 0.5*abs((pdy-p))),shader_gamma),0.0,1.0);\n" \ "gl_FragColor[3] = alpha;\n" \ "}\n" \ "}\n"; } shader_source+="}"; return shader_source; } std::string StandardShader::GetName() const { return "StandardShader"; } void StandardShader::SetupShader() { assert( !m_ImageSettings.IsNull() ); // // Compute shifts. double shr = -m_ImageSettings->GetMinRed(); double shg = -m_ImageSettings->GetMinGreen(); double shb = -m_ImageSettings->GetMinBlue(); // // Compute scales. double scr = 1.0 / ( m_ImageSettings->GetMaxRed()+shr ); double scg = 1.0 / ( m_ImageSettings->GetMaxGreen()+shg ); double scb = 1.0 / ( m_ImageSettings->GetMaxBlue()+shb ); double gamma = m_ImageSettings->GetGamma(); GLint shader_a = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_a"); glUniform4f(shader_a,scr,scg,scb,1.); GLint shader_b = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_b"); glUniform4f(shader_b,shr,shg,shb,0); GLint shader_use_no_data = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_use_no_data"); glUniform1i(shader_use_no_data, m_ImageSettings->GetUseNoData() ); GLint shader_no_data = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_no_data"); glUniform1f( shader_no_data, m_ImageSettings->GetNoData() ); GLint shader_gamma = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_gamma"); glUniform4f( shader_gamma, gamma, gamma, gamma, gamma ); GLint shader_alpha = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_alpha"); glUniform1f( shader_alpha, m_ImageSettings->GetAlpha() ); GLint shader_radius = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_radius"); glUniform1f(shader_radius,m_Radius); GLint shader_center = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_center"); glUniform2f(shader_center,m_Center[0],m_Center[1]); GLint shader_type = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_type"); glUniform1i(shader_type,m_ShaderType); // std::cout // << "r: " << m_ImageSettings->GetCurrentRed() // << " g: " << m_ImageSettings->GetCurrentGreen() // << " b: " << m_ImageSettings->GetCurrentBlue() // << std::endl; GLint shader_current = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_current"); glUniform3f( shader_current, m_ImageSettings->GetCurrentRed(), m_ImageSettings->GetCurrentGreen(), m_ImageSettings->GetCurrentBlue() ); GLint shader_localc_range = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_localc_range"); glUniform1f(shader_localc_range,m_LocalContrastRange); GLint shader_spectral_angle_range = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_spectral_angle_range"); glUniform1f(shader_spectral_angle_range,m_SpectralAngleRange); GLint shader_chessboard_size = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_chessboard_size"); glUniform1f(shader_chessboard_size,m_ChessboardSize); GLint shader_slider_pos = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_slider_pos"); glUniform1f(shader_slider_pos,m_SliderPosition); GLint shader_vertical_slider_flag = glGetUniformLocation(otb::FragmentShaderRegistry::Instance()->GetShaderProgram("StandardShader"), "shader_vertical_slider_flag"); glUniform1i(shader_vertical_slider_flag,m_VerticalSlider); } } // End namespace otb OTB-release-5.8/Modules/Visualization/Ice/src/otbViewSettings.cxx000066400000000000000000000144341301006202600250500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbViewSettings.h" #include "otbGenericRSTransform.h" #include "otbImageToGenericRSOutputParameters.h" #include "otbMapProjections.h" namespace otb { ViewSettings::ViewSettings() : m_Wkt( "" ), m_RotationAngle( 0.0 ), m_UseProjection( true ), m_GeometryChanged( false ) { m_Origin.Fill( 0 ); m_Spacing.Fill( 1 ); m_ViewportSize.Fill( 0 ); m_RotationCenter.Fill( 0 ); } ViewSettings::~ViewSettings() {} void ViewSettings ::Reset() { m_Origin.Fill( 0 ); m_Spacing.Fill( 1 ); m_ViewportSize.Fill( 0 ); m_Wkt = ""; m_KeywordList = KeywordListType(); m_UseProjection = true; m_GeometryChanged = false; m_RotationCenter.Fill( 0 ); m_RotationAngle = 0.0; } void ViewSettings::GetViewportExtent(double & ulx, double & uly, double & lrx, double & lry) const { ulx = m_Origin[0]; uly = m_Origin[1]; lrx = m_Origin[0] + m_Spacing[0]*m_ViewportSize[0]; lry = m_Origin[1] + m_Spacing[1]*m_ViewportSize[1]; } void ViewSettings::ScreenToViewPortTransform(const double & xscreen, const double & yscreen, double & xvp, double & yvp) const { xvp = m_Origin[0] + xscreen * m_Spacing[0]; yvp = m_Origin[1] + yscreen * m_Spacing[1]; } void ViewSettings::ViewportToScreenTransform(const double & xvp, const double & yvp, double & xscreen, double & yscreen) const { xscreen = (xvp - m_Origin[0]) / m_Spacing[0]; yscreen = (yvp - m_Origin[1]) / m_Spacing[1]; } void ViewSettings::Zoom(const PointType & zoomCenter,double scale) { m_Origin[0] = m_Origin[0] + (zoomCenter[0]-m_Origin[0])*(1-scale); m_Origin[1] = m_Origin[1] + (zoomCenter[1]-m_Origin[1])*(1-scale); m_Spacing[0]*=scale; m_Spacing[1]*=scale; } void ViewSettings::Center(const PointType & center) { m_Origin[0] = center[0] - 0.5*m_Spacing[0]*m_ViewportSize[0]; m_Origin[1] = center[1] - 0.5*m_Spacing[1]*m_ViewportSize[1]; } ViewSettings::PointType ViewSettings::GetViewportCenter() const { PointType center = m_Origin; center[0]+=0.5*m_Spacing[0]*m_ViewportSize[0]; center[1]+=0.5*m_Spacing[1]*m_ViewportSize[1]; return center; } void ViewSettings::UpdateRotation(const PointType & newCenter, double newAngle) { std::complex theta1 = std::polar(1.0,-m_RotationAngle); std::complex theta2 = std::polar(1.0,-newAngle+m_RotationAngle); m_RotationAngle = -std::arg(theta1*theta2); if(vcl_abs(m_RotationAngle) > 1e-9) { // Compute new center std::complex c1(m_RotationCenter[0],m_RotationCenter[1]); std::complex c2(newCenter[0],newCenter[1]); std::complex one(1.0,0.0); std::complex finalCenter = (theta2*(c1-c2)+c2-theta1*theta2*c1)/(one-theta1*theta2); m_RotationCenter[0] = finalCenter.real(); m_RotationCenter[1] = finalCenter.imag(); } } void ViewSettings::SetPersepectiveAngle() { typedef otb::GenericRSTransform RSTransformType; // Build the RS transform RSTransformType::Pointer forwardTransform = RSTransformType::New(); forwardTransform->SetInputKeywordList(m_KeywordList); forwardTransform->SetInputProjectionRef(m_Wkt); forwardTransform->InstantiateTransform(); RSTransformType::Pointer inverseTransform = RSTransformType::New(); inverseTransform->SetOutputProjectionRef(m_Wkt); inverseTransform->SetOutputKeywordList(m_KeywordList); inverseTransform->InstantiateTransform(); PointType centerPoint = GetViewportCenter(); // Find the rotation to apply RSTransformType::InputPointType centerPoint3d; centerPoint3d[0] = centerPoint[0]; centerPoint3d[1] = centerPoint[1]; centerPoint3d[2] = 0; RSTransformType::OutputPointType groundPoint3d1 = forwardTransform->TransformPoint(centerPoint3d); groundPoint3d1[2] = 1000; RSTransformType::InputPointType centerPoint3d2 = inverseTransform->TransformPoint(groundPoint3d1); double angle = -vcl_atan2(centerPoint3d2[1]-centerPoint3d[1],centerPoint3d2[0]-centerPoint3d[0]); this->UpdateRotation(centerPoint,M_PI/2 - angle); } void ViewSettings::SetNorthUpAngle() { typedef otb::GenericRSTransform RSTransformType; // Build the RS transform RSTransformType::Pointer forwardTransform = RSTransformType::New(); forwardTransform->SetInputKeywordList(m_KeywordList); forwardTransform->SetInputProjectionRef(m_Wkt); forwardTransform->InstantiateTransform(); RSTransformType::Pointer inverseTransform = RSTransformType::New(); inverseTransform->SetOutputProjectionRef(m_Wkt); inverseTransform->SetOutputKeywordList(m_KeywordList); inverseTransform->InstantiateTransform(); PointType centerPoint = GetViewportCenter(); // Find the rotation to apply RSTransformType::InputPointType centerPoint3d; centerPoint3d[0] = centerPoint[0]; centerPoint3d[1] = centerPoint[1]; centerPoint3d[2] = 0; RSTransformType::OutputPointType groundPoint3d1 = forwardTransform->TransformPoint(centerPoint3d); groundPoint3d1[1] += 0.01; RSTransformType::InputPointType centerPoint3d2 = inverseTransform->TransformPoint(groundPoint3d1); double angle = -vcl_atan2(centerPoint3d2[1]-centerPoint3d[1],centerPoint3d2[0]-centerPoint3d[0]); this->UpdateRotation(centerPoint, M_PI/2 - angle); } double ViewSettings ::GetScale( const PointType & origin, const PointType & extent, bool isSigned ) const { SpacingType spacing; assert( m_ViewportSize[ 0 ]!=0 ); assert( m_ViewportSize[ 1 ]!=0 ); spacing[ 0 ] = ( extent[ 0 ] - origin[ 0 ] ) / m_ViewportSize[ 0 ]; spacing[ 1 ] = ( extent[ 1 ] - origin[ 1 ] ) / m_ViewportSize[ 1 ]; SpacingType scale( spacing ); scale[ 0 ] = vcl_abs( scale[ 0 ] ); scale[ 1 ] = vcl_abs( scale[ 1 ] ); if( scale[ 0 ]>scale[ 1 ] ) return isSigned ? spacing[ 0 ] : scale[ 0 ]; return isSigned ? spacing[ 1 ] : scale[ 1 ]; } } // end of 'otb' namespace. OTB-release-5.8/Modules/Visualization/IceViewer/000077500000000000000000000000001301006202600215515ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/IceViewer/CMakeLists.txt000066400000000000000000000001231301006202600243050ustar00rootroot00000000000000project(OTBIceViewer) set(OTBIceViewer_LIBRARIES OTBIceViewer) otb_module_impl() OTB-release-5.8/Modules/Visualization/IceViewer/include/000077500000000000000000000000001301006202600231745ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/IceViewer/include/otbIceViewer.h000066400000000000000000000107761301006202600257470ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otb_IceViewer_h #define otb_IceViewer_h /* Include windows.h before glfw, * since GLFW redefines APIENTRY if not already defined, * while windef.h unconditionnally defines it */ #if defined (WIN32) # include #endif #include #include #include "otbGlView.h" #include "otbGlImageActor.h" #include "otbGlVectorActor.h" #include "otbViewSettings.h" #include "otbDEMHandler.h" #include "otbStandardShader.h" #include #include "OTBIceViewerExport.h" namespace otb { class OTBIceViewer_EXPORT IceViewer : public itk::Object { public: typedef IceViewer Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); void AddImage(const std::string & fname, const std::string & key, const std::string & name = ""); void AddVector(const std::string & fname, const std::string & key, const std::string & name = ""); void Initialize(unsigned int w, unsigned int h, const std::string & name = "OTB viewer for geeks"); void Refresh(); virtual void Start(); void ClearActors(); void SetActorName(const std::string & key, const std::string & name); itkSetMacro(DisplayHud,bool); itkGetMacro(DisplayHud,bool); protected: IceViewer(); ~IceViewer() ITK_OVERRIDE; // Non-static callbacks virtual void scroll_callback(GLFWwindow * window, double xoffset, double yoffset); virtual bool scroll_callback_image(GLFWwindow * window, double xoffset, double yoffset); virtual bool scroll_callback_vector(GLFWwindow * window, double xoffset, double yoffset); virtual void cursor_pos_callback(GLFWwindow * window, double xpos, double ypos); virtual void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods); virtual bool key_callback_image(GLFWwindow* window, int key, int scancode, int action, int mods); virtual bool key_callback_vector(GLFWwindow* window, int key, int scancode, int action, int mods); virtual void mouse_button_callback(GLFWwindow * window, int button, int action, int mode); virtual void framebuffer_size_callback(GLFWwindow* window, int width, int height); otb::GlActor::Pointer GetActor(const std::string& key); void CopyActorStyle(otb::GlActor::Pointer srcActor, otb::GlActor::Pointer dstActor); // Update all shaders with current color and position void UpdateShaderColorAndPosition(); private: // Static callbacks static void static_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods); static void static_framebuffer_size_callback(GLFWwindow* window, int width, int height); static void static_mouse_button_callback(GLFWwindow * window, int button, int action, int mode); static void static_cursor_pos_callback(GLFWwindow * window, double xpos, double ypos); static void static_scroll_callback(GLFWwindow * window, double xoffset, double yoffset); static void error_callback(int error, const char* description); // Render Hud void DrawHud(); // Render help void DrawHelp(); // Update shader with current color and position void UpdateShaderColorAndPosition(double vpx, double vpy,otb::GlImageActor * currentActor); // prevent implementation IceViewer(const Self&); void operator=(const Self&); GLFWwindow * m_Window; otb::GlView::Pointer m_View; bool m_FastRendering; std::string m_SelectedActor; std::string m_ReferenceActor; double m_Factor; bool m_Dragging; ViewSettings::PointType m_StartDrag; ViewSettings::PointType m_DeltaDrag; ViewSettings::PointType m_OriginDrag; double m_StartAngle; bool m_DisplayHud; bool m_DisplayHelp; std::map m_ColorMap; std::map::const_iterator m_ColorMapIterator; }; // End class IceViewer } // End namespace otb #endif OTB-release-5.8/Modules/Visualization/IceViewer/otb-module.cmake000066400000000000000000000004341301006202600246230ustar00rootroot00000000000000set(DOCUMENTATION "This module provides IceViewer, the ligthweight GLFW viewer based on Ice.") otb_module(OTBIceViewer ENABLE_SHARED DEPENDS OTBIce OTBMetadata OTBOSSIMAdapters OTBGlut OTBGLFW OPTIONAL_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Visualization/IceViewer/src/000077500000000000000000000000001301006202600223405ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/IceViewer/src/CMakeLists.txt000066400000000000000000000006171301006202600251040ustar00rootroot00000000000000set(OTBICEVIEWER_SRCS otbIceViewer.cxx) add_library(OTBIceViewer ${OTBICEVIEWER_SRCS}) target_link_libraries(OTBIceViewer ${OTBIce_LIBRARIES} ${OTBMetadata_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBGLFW_LIBRARIES} ${OTBGlut_LIBRARIES}) otb_module_target(OTBIceViewer) add_executable(iceViewer otbIce.cxx) target_link_libraries(iceViewer OTBIceViewer) otb_module_target(iceViewer) OTB-release-5.8/Modules/Visualization/IceViewer/src/otbIce.cxx000066400000000000000000000045441301006202600243000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbIceViewer.h" #include "otbDEMHandler.h" void error_callback(int, const char* description) { std::cerr<OpenDEMDirectory(demdir); } if(geoidfile != ITK_NULLPTR) { std::cout<<"Configuring geoid file: "<OpenGeoidFile(geoidfile); } otb::IceViewer::Pointer viewer = otb::IceViewer::New(); // Initialize viewer try { viewer->Initialize(800,600); } catch(itk::ExceptionObject& err) { std::cerr<<"Failed to initialized viewer: "<AddImage(argv[i],argv[i]); } catch(itk::ExceptionObject & err) { std::cerr<<"Failed to open object as image: "<AddVector(argv[i],argv[i]); } catch(itk::ExceptionObject & err2) { std::cerr << "Failed to open object as vector: " << err2 << std::endl; std::cerr << "Could not open file " << argv[i] << " as an image or a vector, skipping." << std::endl; } } catch(std::runtime_error & err) { std::cerr<<"Runtime error: "<< err.what() <Start(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Visualization/IceViewer/src/otbIceViewer.cxx000066400000000000000000001500271301006202600254600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include #include "otbGlROIActor.h" #include "otbGlVectorActor.h" #include "otbGlVersionChecker.h" #include "otbIceViewer.h" namespace otb { GlVectorActor::ColorType BuildColor(double r, double g, double b) { GlVectorActor::ColorType color; color[0] = r; color[1] = g; color[2] = b; return color; } IceViewer::IceViewer() : m_Window(ITK_NULLPTR), m_View(), m_FastRendering(false), m_SelectedActor(""), m_ReferenceActor(""), m_Factor(1.1), m_Dragging(false), m_StartDrag(), m_DeltaDrag(), m_OriginDrag(), m_StartAngle(0), m_DisplayHud(true), m_DisplayHelp(false), m_ColorMap(), m_ColorMapIterator() { // Fill color map // Sources for some colors value: http://prideout.net/archive/colors.php" m_ColorMap["red"] = BuildColor(1,0,0); m_ColorMap["green"] = BuildColor(0,1,0); m_ColorMap["blue"] = BuildColor(0,0,1); m_ColorMap["light red"] = BuildColor(0.941, 0.502, 0.502); m_ColorMap["pink"] = BuildColor(1.000, 0.078, 0.576); m_ColorMap["yellow"] = BuildColor(1.000, 1.000, 0.000); m_ColorMap["light green"] = BuildColor(0.565, 0.933, 0.565); m_ColorMap["cyan"] = BuildColor(0.000, 1.000, 1.000); m_ColorMap["purple"] = BuildColor(0.502, 0.000, 0.502); m_ColorMapIterator = m_ColorMap.begin(); } IceViewer::~IceViewer() { if(m_Window != ITK_NULLPTR) { glfwDestroyWindow(m_Window); } glfwTerminate(); } void IceViewer::AddImage(const std::string & fname, const std::string & key, const std::string & name) { if(m_View.IsNull()) { itkExceptionMacro("Viewer has not been initialized. Call Initialize method first."); } otb::GlImageActor::Pointer actor = otb::GlImageActor::New(); const char * glVersion = ITK_NULLPTR; const char * glslVersion = ITK_NULLPTR; if( GlVersionChecker::CheckGLCapabilities( glVersion, glslVersion ) ) actor->CreateShader(); actor->Initialize(fname); actor->SetVisible(true); if(name == "") { actor->SetName(key); } else { actor->SetName(name); } // Get advised colors ImageMetadataInterfaceBase::Pointer imi = ImageMetadataInterfaceFactory::CreateIMI(actor->GetMetaDataDictionary()); actor->SetRedIdx(std::min(imi->GetDefaultDisplay()[0]+1,actor->GetNumberOfComponents())); actor->SetGreenIdx(std::min(imi->GetDefaultDisplay()[1]+1,actor->GetNumberOfComponents())); actor->SetBlueIdx(std::min(imi->GetDefaultDisplay()[2]+1,actor->GetNumberOfComponents())); otb::ImageSettings::Pointer imageSettings( actor->GetImageSettings() ); assert( !imageSettings.IsNull() ); double minRed = 0.0; double maxRed = 1.0; double minGreen = 0.0; double maxGreen = 1.0; double minBlue = 0.0; double maxBlue = 1.0; actor->AutoColorAdjustment( minRed, maxRed, minGreen, maxGreen, minBlue, maxBlue ); imageSettings->SetMinRed( minRed ); imageSettings->SetMinGreen( minGreen ); imageSettings->SetMinBlue( minBlue ); imageSettings->SetMaxRed( maxRed ); imageSettings->SetMaxGreen( maxGreen ); imageSettings->SetMaxBlue( maxBlue ); // TODO: Implement this // actor->UpdateColorBalance(); m_View->AddActor(actor,key); } void IceViewer::AddVector(const std::string & fname, const std::string & key, const std::string & name) { if(m_View.IsNull()) { itkExceptionMacro("Viewer has not been initialized. Call Initialize method first."); } otb::GlVectorActor::Pointer actor = otb::GlVectorActor::New(); actor->Initialize(fname); actor->SetVisible(true); actor->SetAlpha(0.5); actor->SetColor(m_ColorMapIterator->second); if(name == "") { actor->SetName(key); } else { actor->SetName(name); } ++m_ColorMapIterator; if(m_ColorMapIterator == m_ColorMap.end()) { m_ColorMapIterator = m_ColorMap.begin(); } m_View->AddActor(actor,key); // Add other layers if the dataset contains some std::vector layers = actor->GetAvailableLayers(); if(layers.size() > 1) { for(std::vector::const_iterator it = layers.begin()+1; it!=layers.end();++it) { otb::GlVectorActor::Pointer additionalActor = otb::GlVectorActor::New(); additionalActor->Initialize(fname,*it); additionalActor->SetVisible(true); additionalActor->SetAlpha(0.5); additionalActor->SetColor(m_ColorMapIterator->second); if(name == "") { additionalActor->SetName(key+"_"+(*it)); } else { additionalActor->SetName(name+"_"+(*it)); } ++m_ColorMapIterator; if(m_ColorMapIterator == m_ColorMap.end()) { m_ColorMapIterator = m_ColorMap.begin(); } m_View->AddActor(additionalActor,key+"_"+(*it)); } } } void IceViewer::ClearActors() { m_View->ClearActors(); } void IceViewer::Initialize(unsigned int w, unsigned int h, const std::string & name) { // Initialize glfw if(!glfwInit()) { itkExceptionMacro(<<"Could not initialize glfw!"); } // Initialize glut (ugly workaround) int fake_argc = 1; char fake_name[] = "fake"; char * fake_argv[] = {fake_name,ITK_NULLPTR}; glutInit(&fake_argc,fake_argv); // Set glfw errors callback glfwSetErrorCallback(error_callback); // Create the window if(m_Window != ITK_NULLPTR) { glfwDestroyWindow(m_Window); } m_Window = glfwCreateWindow(w, h,name.c_str(), ITK_NULLPTR, ITK_NULLPTR); if (!m_Window) { itkExceptionMacro(<<"Could not create glfw window."); } glfwMakeContextCurrent(m_Window); glfwSetWindowUserPointer(m_Window,this); glfwSetKeyCallback(m_Window, &IceViewer::static_key_callback); glfwSetFramebufferSizeCallback(m_Window,&IceViewer::static_framebuffer_size_callback); glfwSetMouseButtonCallback(m_Window,&IceViewer::static_mouse_button_callback); glfwSetCursorPosCallback(m_Window,&IceViewer::static_cursor_pos_callback); glfwSetScrollCallback(m_Window,&IceViewer::static_scroll_callback); // Create view m_View = GlView::New(); m_View->Initialize(w,h); } void IceViewer::Refresh() { int width, height; glfwGetFramebufferSize(m_Window, &width, &height); m_View->BeforeRendering(); if(m_FastRendering || m_Dragging) { m_View->LightRender(); } else { m_View->HeavyRender(); } m_View->AfterRendering(); if(m_DisplayHelp) { DrawHelp(); } else if(m_DisplayHud) { DrawHud(); } } void IceViewer::Start() { // Define viewport geometry as first actor geometry std::vector renderingOrder = m_View->GetRenderingOrder(); if(renderingOrder.empty()) { itkExceptionMacro(<<"No actors have been loaded to the application."); } std::string firstActorKey = renderingOrder.front(); otb::GlImageActor::Pointer firstActor = dynamic_cast(m_View->GetActor(firstActorKey).GetPointer()); otb::GlVectorActor::Pointer firstVectorActor = dynamic_cast(m_View->GetActor(firstActorKey).GetPointer()); double ulx(0),uly(0),lrx(0),lry(0); bool shouldHaveNegativeSpacing = false; if(firstActor.IsNotNull()) { m_View->GetSettings()->SetOrigin(firstActor->GetOrigin()); m_View->GetSettings()->SetSpacing(firstActor->GetSpacing()); m_View->GetSettings()->SetWkt(firstActor->GetWkt()); m_View->GetSettings()->SetKeywordList(firstActor->GetKwl()); m_View->GetSettings()->UseProjectionOn(); firstActor->ProcessViewSettings(); firstActor->GetExtent(ulx,uly,lrx,lry); if(firstActor->GetSpacing()[1] < 0) { shouldHaveNegativeSpacing = true; } } else if(firstVectorActor.IsNotNull()) { m_View->GetSettings()->SetWkt(firstVectorActor->GetWkt()); m_View->GetSettings()->UseProjectionOn(); firstVectorActor->ProcessViewSettings(); firstVectorActor->GetExtent(ulx,uly,lrx,lry); if(firstVectorActor->GetWkt() != "") { shouldHaveNegativeSpacing = true; } } m_SelectedActor = firstActorKey; m_ReferenceActor = firstActorKey; otb::ViewSettings::PointType center; center[0] = 0.5*(ulx+lrx); center[1] = 0.5*(uly+lry); double spacingx = (lrx-ulx)/m_View->GetSettings()->GetViewportSize()[0]; double spacingy = (lry-uly)/m_View->GetSettings()->GetViewportSize()[1]; otb::ViewSettings::SpacingType spacing; spacing.Fill(std::min(vcl_abs(spacingx),vcl_abs(spacingy))); if(shouldHaveNegativeSpacing) { spacing[1]*=-1; } m_View->GetSettings()->SetSpacing(spacing); m_View->GetSettings()->Center(center); // Start events loop while (!glfwWindowShouldClose(m_Window)) { this->Refresh(); // Swap buffers glfwSwapBuffers(m_Window); glfwWaitEvents(); } } void IceViewer::DrawHud() { double posx, posy, vpx, vpy,hudposx,hudposy,hudvpx,hudvpy; glfwGetCursorPos(m_Window,&posx,&posy); m_View->GetSettings()->ScreenToViewPortTransform(posx,posy,vpx,vpy); std::vector renderingOrder = m_View->GetRenderingOrder(); std::ostringstream oss; double ulx, uly, lrx, lry; m_View->GetSettings()->GetViewportExtent(ulx,uly,lrx,lry); oss<<"Viewport: x:["<GetSettings()->GetSpacing()[0]<<", "<GetSettings()->GetSpacing()[1]<<")"<<", orientation: "<<(static_cast(static_cast((m_View->GetSettings()->GetRotationAngle()*1800/M_PI))%3600))/10<<" deg"<::iterator it = renderingOrder.begin(); it!=renderingOrder.end();++it) { // Retrieve actor information otb::GlImageActor::Pointer currentActor = dynamic_cast(m_View->GetActor(*it).GetPointer()); otb::GlVectorActor::Pointer currentVectorActor = dynamic_cast(m_View->GetActor(*it).GetPointer()); // Image part if(currentActor.IsNotNull()) { otb::GlImageActor::PointType pin,poutphys,poutidx; pin[0]=vpx; pin[1]=vpy; poutphys = currentActor->ViewportToImageTransform(pin,true); poutidx = currentActor->ViewportToImageTransform(pin,false); otb::GlImageActor::PixelType pixel; bool pixelAvail = currentActor->GetPixelFromViewport(pin,pixel); oss<<(currentActor->GetVisible()?"+ ":"- "); oss<<((*it)==m_ReferenceActor?"*":" "); oss<<((*it)==m_SelectedActor?"[":" "); oss<<"(image) "<GetActor(*it)->GetName(); oss<<((*it)==m_SelectedActor?"]":" "); oss<<((*it)==m_ReferenceActor?"*":" "); oss<GetImageSettings() ); assert( !imageSettings.IsNull() ); oss <<" Rendering: " << "R=" << currentActor->GetRedIdx() << ":[" << imageSettings->GetMinRed() << ", "<< imageSettings->GetMaxRed() << "] G=" << currentActor->GetGreenIdx() << ":[" << imageSettings->GetMinGreen() << ", " << imageSettings->GetMaxGreen() << "] B=" << currentActor->GetBlueIdx() << ":[" << imageSettings->GetMinBlue() << ", " << imageSettings->GetMaxBlue() << "]" << ", gam=" << imageSettings->GetGamma() << ", al=" << imageSettings->GetAlpha() << ", nodata="; imageSettings->GetUseNoData() ? oss << "y" : oss << "n"; oss << "\n"; oss << " Shader: "; otb::StandardShader::Pointer shader( dynamic_cast< otb::StandardShader * >( currentActor->GetShader() ) ); if( !shader.IsNull() ) { switch(shader->GetShaderType()) { case SHADER_STANDARD: oss<<" standard"; break; case SHADER_LOCAL_CONTRAST: oss<<" local contrast - radius="<GetRadius()<<", range=["<<-shader->GetLocalContrastRange()<<", "<GetLocalContrastRange()<<"]"; break; case SHADER_LOCAL_ALPHA: oss<<" local transparency - radius="<GetRadius(); break; case SHADER_ALPHA_GRID: oss<<" chessboard transparency - grid="<GetChessboardSize(); break; case SHADER_ALPHA_SLIDER: oss<<" swipe transparency - "<<(shader->GetVerticalSlider()?"vertical":"horizontal")<<", position="<GetSliderPosition(); break; case SHADER_SPECTRAL_ANGLE: oss<<" spectral angle: - gain="<GetSpectralAngleRange(); // Do nothing break; case SHADER_GRADIENT: oss<<" gradient"; break; } } oss<<"\n"; oss<<" Position - index: ("<GetCurrentResolution()<<"\n"; if(pixelAvail) { oss<<" Pixel value: ["<GetVisible()?"+ ":"- "); oss<<((*it)==m_ReferenceActor?"*":" "); oss<<((*it)==m_SelectedActor?"[":" "); oss<<"(vector) "<GetActor(*it)->GetName()<<", layer: "<GetCurrentLayer(); oss<<((*it)==m_SelectedActor?"]":" "); oss<<((*it)==m_ReferenceActor?"*":" "); oss<GetFill()?"On":"Off")<<", Solid border: "<<(currentVectorActor->GetSolidBorder()?"On":"Off")<<", al="<GetAlpha()<<", lw="<GetLineWidth()<<"\n"; std::map::const_iterator cIt = m_ColorMap.begin(); while(cIt!=m_ColorMap.end() && cIt->second!=currentVectorActor->GetColor()) { ++cIt; } oss<<" Color: "<<(cIt!=m_ColorMap.end()?cIt->first:"custom"); oss<<", optimized rendering (large vector): "<<(currentVectorActor->GetOptimizedRendering()?"On":"Off")<<" ("<<(currentVectorActor->GetOptimizedRenderingActive()?"active":"inactive")<<")"; oss<<"\n"<<"\n"; } else { oss<<(m_View->GetActor(*it)->GetVisible()?"+ ":"- "); oss<<((*it)==m_ReferenceActor?"*":" "); oss<<((*it)==m_SelectedActor?"[":" "); oss<<"(roi) "<<(*it); oss<<((*it)==m_SelectedActor?"]":" "); oss<<((*it)==m_ReferenceActor?"*":" "); oss<<"\n"<<"\n"; } } // Find the size of the hud std::string hud_string = oss.str(); unsigned int nbline = 0; unsigned int max_line_widh = 0; unsigned int char_count = 0; for(std::string::iterator sit = hud_string.begin(); sit!=hud_string.end();++sit) { if((*sit)=='\n') { nbline+=1; if(char_count>max_line_widh) { max_line_widh = char_count; } char_count = 0; } char_count+=1; } double hud_width = 8*max_line_widh; double hud_height = 14*nbline; hudposx = 10; hudposy = m_View->GetSettings()->GetViewportSize()[1]-hud_height-10; double x,y; glEnable(GL_BLEND); glColor4f(0.,0.,0.,0.75); glBegin (GL_QUADS); m_View->GetSettings()->ScreenToViewPortTransform(hudposx- 5,hudposy-5-13,x,y); glVertex2f(x,y); m_View->GetSettings()->ScreenToViewPortTransform(hudposx + 5 + hud_width,hudposy-5-13,x,y); glVertex2f(x,y); m_View->GetSettings()->ScreenToViewPortTransform(hudposx + 5 + hud_width, hudposy + hud_height + 5,x,y); glVertex2f(x,y); m_View->GetSettings()->ScreenToViewPortTransform(hudposx - 5, hudposy + hud_height + 5,x,y); glVertex2f(x,y); glEnd (); glDisable(GL_BLEND); glColor3f(1.0f,1.0f,1.0f); m_View->GetSettings()->ScreenToViewPortTransform(hudposx,hudposy,hudvpx,hudvpy); glRasterPos2f(hudvpx,hudvpy); glutBitmapString(GLUT_BITMAP_8_BY_13,(unsigned char *) oss.str().c_str()); } void IceViewer::DrawHelp() { std::ostringstream oss; oss<<"This is ice viewer help page. Press ESC key to exit."<max_line_widh) { max_line_widh = char_count; } char_count = 0; } char_count+=1; } double help_width = 8*max_line_widh; double help_height = 14*nbline; double helpposx = 10; double helpposy = 20; double helpvpx,helpvpy; double x,y; glEnable(GL_BLEND); glColor4f(0.,0.,0.,0.75); glBegin (GL_QUADS); m_View->GetSettings()->ScreenToViewPortTransform(helpposx- 5,helpposy-5-13,x,y); glVertex2f(x,y); m_View->GetSettings()->ScreenToViewPortTransform(helpposx + 5 + help_width,helpposy-5-13,x,y); glVertex2f(x,y); m_View->GetSettings()->ScreenToViewPortTransform(helpposx + 5 + help_width, helpposy + help_height + 5,x,y); glVertex2f(x,y); m_View->GetSettings()->ScreenToViewPortTransform(helpposx - 5, helpposy + help_height + 5,x,y); glVertex2f(x,y); glEnd (); glDisable(GL_BLEND); glColor3f(1.0f,1.0f,1.0f); m_View->GetSettings()->ScreenToViewPortTransform(helpposx,helpposy,helpvpx,helpvpy); glRasterPos2f(helpvpx,helpvpy); glutBitmapString(GLUT_BITMAP_8_BY_13,(unsigned char *) oss.str().c_str()); } void IceViewer ::UpdateShaderColorAndPosition( double vpx, double vpy, otb::GlImageActor * currentActor ) { otb::GlImageActor::PointType pin; pin[ 0 ] = vpx; pin[ 1 ] = vpy; otb::GlImageActor::PixelType pixel; if( currentActor->GetPixelFromViewport( pin, pixel ) ) { ImageSettings::Pointer imageSettings( currentActor->GetImageSettings() ); assert( !imageSettings.IsNull() ); imageSettings->SetCurrentRed( pixel[ 0 ] ); imageSettings->SetCurrentGreen( pixel[ 1 ] ); imageSettings->SetCurrentBlue( pixel[ 2 ] ); } int width = 0; int height = 0; double posx = 0.0; double posy = 0.0; glfwGetFramebufferSize( m_Window, &width, &height ); glfwGetCursorPos( m_Window, &posx, &posy ); pin[ 0 ] = posx; pin[ 1 ]= height - posy; otb::StandardShader::Pointer shader( dynamic_cast< otb::StandardShader * >( currentActor->GetShader() ) ); if( !shader.IsNull() ) shader->SetCenter( pin ); } // Static callbacks void IceViewer::static_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) { Self * instance = static_cast(glfwGetWindowUserPointer(window)); instance->key_callback(window, key, scancode, action, mods); } void IceViewer::static_framebuffer_size_callback(GLFWwindow* window, int width, int height) { Self * instance = static_cast(glfwGetWindowUserPointer(window)); instance->framebuffer_size_callback(window, width, height); } void IceViewer::static_mouse_button_callback(GLFWwindow * window, int button, int action, int mode) { Self * instance = static_cast(glfwGetWindowUserPointer(window)); instance->mouse_button_callback(window,button,action,mode); } void IceViewer::static_cursor_pos_callback(GLFWwindow * window, double xpos, double ypos) { Self * instance = static_cast(glfwGetWindowUserPointer(window)); instance->cursor_pos_callback(window, xpos, ypos); } void IceViewer::static_scroll_callback(GLFWwindow * window, double xoffset, double yoffset) { Self * instance = static_cast(glfwGetWindowUserPointer(window)); instance->scroll_callback(window,xoffset,yoffset); } void IceViewer::error_callback(int, const char* description) { itkGenericExceptionMacro(<0) ? 1/m_Factor : m_Factor; otb::GlImageActor::Pointer currentImageActor = dynamic_cast(m_View->GetActor(m_SelectedActor).GetPointer()); otb::GlVectorActor::Pointer currentVectorActor = dynamic_cast(m_View->GetActor(m_SelectedActor).GetPointer()); // Handle zoom if(glfwGetKey(window,GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS) { double posx, posy,vpx,vpy; glfwGetCursorPos(m_Window,&posx,&posy); m_View->GetSettings()->ScreenToViewPortTransform(posx,posy,vpx,vpy); otb::ViewSettings::PointType zoomCenter; zoomCenter[0] = vpx; zoomCenter[1] = vpy; m_View->GetSettings()->Zoom(zoomCenter,factor); } else if(currentImageActor.IsNotNull() && this->scroll_callback_image(window, xoffset, yoffset)) {} else if(currentVectorActor.IsNotNull() && this->scroll_callback_vector(window, xoffset, yoffset)) {} else { m_View->RotateRenderingOrder(yoffset>0); } } bool IceViewer::scroll_callback_image(GLFWwindow * window, double, double yoffset) { double factor = (yoffset>0) ? 1/m_Factor : m_Factor; otb::GlImageActor::Pointer currentActor( dynamic_cast< otb::GlImageActor * >( m_View->GetActor( m_SelectedActor ).GetPointer() ) ); if( currentActor.IsNull() ) return false; otb::StandardShader::Pointer shader( dynamic_cast< otb::StandardShader * >( currentActor->GetShader() ) ); if( shader.IsNull() ) return false; ImageSettings::Pointer imageSettings( currentActor->GetImageSettings() ); assert( !imageSettings.IsNull() ); if(glfwGetKey(window,GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) { if(shader->GetShaderType() == SHADER_STANDARD || shader->GetShaderType() == SHADER_GRADIENT) { imageSettings->SetMinRed( imageSettings->GetMinRed() * factor ); imageSettings->SetMinGreen( imageSettings->GetMinGreen() * factor ); imageSettings->SetMinBlue( imageSettings->GetMinBlue() * factor ); imageSettings->SetMaxRed( imageSettings->GetMaxRed() * factor ); imageSettings->SetMaxGreen( imageSettings->GetMaxGreen() * factor ); imageSettings->SetMaxBlue( imageSettings->GetMaxBlue() * factor ); return true; } else if(shader->GetShaderType() == SHADER_LOCAL_CONTRAST) { shader->SetLocalContrastRange(shader->GetLocalContrastRange()*factor); return true; } else if(shader->GetShaderType() == SHADER_SPECTRAL_ANGLE) { shader->SetSpectralAngleRange(shader->GetSpectralAngleRange()*factor); return true; } } else if(glfwGetKey(window,GLFW_KEY_LEFT_ALT) == GLFW_PRESS) { switch(shader->GetShaderType()) { case SHADER_STANDARD: imageSettings->SetMinRed( imageSettings->GetMinRed() / factor ); imageSettings->SetMinGreen( imageSettings->GetMinGreen() / factor ); imageSettings->SetMinBlue( imageSettings->GetMinBlue() / factor ); imageSettings->SetMaxRed( imageSettings->GetMaxRed() * factor ); imageSettings->SetMaxGreen( imageSettings->GetMaxGreen() * factor ); imageSettings->SetMaxBlue( imageSettings->GetMaxBlue() * factor ); break; case SHADER_LOCAL_CONTRAST: shader->SetRadius(shader->GetRadius()/factor); break; case SHADER_SPECTRAL_ANGLE: shader->SetRadius(shader->GetRadius()/factor); break; case SHADER_LOCAL_ALPHA: shader->SetRadius(shader->GetRadius()/factor); break; case SHADER_GRADIENT: shader->SetRadius(shader->GetRadius()/factor); break; case SHADER_ALPHA_GRID: shader->SetChessboardSize(shader->GetChessboardSize()/factor); break; // case SHADER_ALPHA_SLIDER: // shader->SetSliderPosition(shader->GetSliderPosition()+(yoffset>0?-25:-25)); // break; default: break; } return true; } else if(glfwGetKey(window,GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS) { imageSettings->SetGamma( imageSettings->GetGamma() / factor ); return true; } else if(glfwGetKey(window,GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS) { imageSettings->SetAlpha( imageSettings->GetAlpha() / factor ); return true; } return false; } bool IceViewer::scroll_callback_vector(GLFWwindow * window, double, double yoffset) { double factor = (yoffset>0) ? 1/m_Factor : m_Factor; otb::GlVectorActor::Pointer currentVectorActor = dynamic_cast(m_View->GetActor(m_SelectedActor).GetPointer()); if(currentVectorActor.IsNull()) { return false; } if(glfwGetKey(window,GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS) { currentVectorActor->SetAlpha(currentVectorActor->GetAlpha()/factor); return true; } if(glfwGetKey(window,GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) { currentVectorActor->SetLineWidth(currentVectorActor->GetLineWidth()/factor); return true; } if(glfwGetKey(window, GLFW_KEY_LEFT_ALT) == GLFW_PRESS) { std::map::const_iterator it = m_ColorMap.begin(); for(;it!=m_ColorMap.end();++it) { if(it->second == currentVectorActor->GetColor()) { if(yoffset<0) { ++it; if(it == m_ColorMap.end()) { it = m_ColorMap.begin(); } currentVectorActor->SetColor(it->second); } else { if(it == m_ColorMap.begin()) { it = m_ColorMap.begin(); for(unsigned int i = 0; i < m_ColorMap.size()-1;++i) { ++it; } } else { --it; } currentVectorActor->SetColor(it->second); } return true; } } } return false; } void IceViewer::cursor_pos_callback(GLFWwindow * window, double, double) { double posx, posy,vpx,vpy; glfwGetCursorPos(m_Window,&posx,&posy); m_View->GetSettings()->ScreenToViewPortTransform(posx,posy,vpx,vpy); if(m_Dragging) { if(glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS) { double startx, starty; m_View->GetSettings()->ScreenToViewPortTransform(m_StartDrag[0],m_StartDrag[1],startx,starty); double angle1 = vcl_atan2(vpy - m_View->GetSettings()->GetViewportCenter()[1],vpx - m_View->GetSettings()->GetViewportCenter()[0]); double angle2 = vcl_atan2(starty - m_View->GetSettings()->GetViewportCenter()[1], startx - m_View->GetSettings()->GetViewportCenter()[0]); m_View->GetSettings()->UpdateRotation(m_View->GetSettings()->GetViewportCenter(),m_StartAngle+angle2-angle1); } else { m_DeltaDrag[0] = posx - m_StartDrag[0]; m_DeltaDrag[1] = m_StartDrag[1]-posy; otb::ViewSettings::PointType origin; origin[0]=m_OriginDrag[0]-m_DeltaDrag[0]*m_View->GetSettings()->GetSpacing()[0]; origin[1]=m_OriginDrag[1]+m_DeltaDrag[1]*m_View->GetSettings()->GetSpacing()[1]; m_View->GetSettings()->SetOrigin(origin); } } this->UpdateShaderColorAndPosition(); } void IceViewer::UpdateShaderColorAndPosition() { int width, height; glfwGetFramebufferSize(m_Window, &width, &height); double posx, posy,vpx,vpy; glfwGetCursorPos(m_Window,&posx,&posy); m_View->GetSettings()->ScreenToViewPortTransform(posx,posy,vpx,vpy); std::vector renderingOrder = m_View->GetRenderingOrder(); // Inform all shaders of current color and position for(std::vector::iterator it = renderingOrder.begin(); it!=renderingOrder.end();++it) { // Retrieve actor information otb::GlImageActor::Pointer currentActor = dynamic_cast(m_View->GetActor(*it).GetPointer()); if(currentActor.IsNotNull()) { otb::StandardShader::Pointer currentShader( dynamic_cast< otb::StandardShader * >( currentActor->GetShader() ) ); if( !currentShader.IsNull() ) { UpdateShaderColorAndPosition( vpx, vpy, currentActor ); if(currentShader->GetShaderType() == SHADER_ALPHA_SLIDER) { if( currentShader->GetVerticalSlider() ) currentShader->SetSliderPosition( height - posy ); else currentShader->SetSliderPosition( posx ); } } } } } void IceViewer::key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) { // Exit on escape if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) { if(m_DisplayHelp) { m_DisplayHelp = false; } else { glfwSetWindowShouldClose(m_Window, GL_TRUE); } } // Fast rendering if(key == GLFW_KEY_LEFT_CONTROL && action == GLFW_PRESS) { m_FastRendering = true; } else if(key == GLFW_KEY_LEFT_CONTROL && action == GLFW_RELEASE) { m_FastRendering = false; } // Arrows moves double ulx,uly,lrx,lry; m_View->GetSettings()->GetViewportExtent(ulx,uly,lrx,lry); double deltax = (lrx-ulx)/4; double deltay = (lry-uly)/4; otb::ViewSettings::PointType origin = m_View->GetSettings()->GetOrigin(); if(key == GLFW_KEY_UP && action == GLFW_PRESS) { origin[1]-=deltay; m_View->GetSettings()->SetOrigin(origin); } if(key == GLFW_KEY_DOWN && action == GLFW_PRESS) { origin[1]+=deltay; m_View->GetSettings()->SetOrigin(origin); } else if(key == GLFW_KEY_LEFT && action == GLFW_REPEAT) { origin[0]-=deltax; m_View->GetSettings()->SetOrigin(origin); } if(key == GLFW_KEY_RIGHT && action == GLFW_REPEAT) { origin[0]+=deltax; m_View->GetSettings()->SetOrigin(origin); } // Change selected actor if(key == GLFW_KEY_PAGE_UP && action == GLFW_PRESS) { std::vector renderingOrder = m_View->GetRenderingOrder(); std::vector::iterator it = std::find(renderingOrder.begin(),renderingOrder.end(),m_SelectedActor); if(it!=renderingOrder.end()) { unsigned int idx = std::distance(renderingOrder.begin(),it); if(idx == 0) { idx+=renderingOrder.size(); } m_SelectedActor = renderingOrder.at((idx-1)%renderingOrder.size()); } } if(key == GLFW_KEY_PAGE_DOWN && action == GLFW_PRESS) { std::vector renderingOrder = m_View->GetRenderingOrder(); std::vector::iterator it = std::find(renderingOrder.begin(),renderingOrder.end(),m_SelectedActor); if(it!=renderingOrder.end()) { unsigned int idx = std::distance(renderingOrder.begin(),it); m_SelectedActor = renderingOrder.at((idx+1)%renderingOrder.size()); } } // Move actors if(key == GLFW_KEY_KP_ADD && action == GLFW_PRESS ) { m_View->MoveActorInRenderingOrder(m_SelectedActor,false); } if(key == GLFW_KEY_KP_SUBTRACT && action == GLFW_PRESS) { m_View->MoveActorInRenderingOrder(m_SelectedActor,true); } if(key == GLFW_KEY_SPACE && action == GLFW_PRESS) { otb::GlActor::Pointer currentActor = m_View->GetActor(m_SelectedActor); currentActor->SetVisible(!currentActor->GetVisible()); } if(key == GLFW_KEY_D && action == GLFW_PRESS) { m_DisplayHud = !m_DisplayHud; } otb::GlImageActor::Pointer currentImageActor = dynamic_cast(m_View->GetActor(m_SelectedActor).GetPointer()); otb::GlVectorActor::Pointer currentVectorActor = dynamic_cast(m_View->GetActor(m_SelectedActor).GetPointer()); if(key == GLFW_KEY_BACKSPACE) { std::string tmpKey = "Current data outline"; if(action == GLFW_PRESS) { double aulx(0),auly(0),alrx(0),alry(0); otb::GlROIActor::Pointer roiActor = GlROIActor::New(); if(currentVectorActor.IsNotNull()) { currentVectorActor->GetBoundingBox(aulx,auly,alrx,alry); roiActor->SetWkt(currentVectorActor->GetWkt()); } else if(currentImageActor.IsNotNull()) { aulx = currentImageActor->GetOrigin()[0]; auly = currentImageActor->GetOrigin()[1]; alrx = aulx + currentImageActor->GetLargestRegion().GetSize()[0] * currentImageActor->GetSpacing()[0]; alry = auly + currentImageActor->GetLargestRegion().GetSize()[1] * currentImageActor->GetSpacing()[1]; roiActor->SetWkt(currentImageActor->GetWkt()); roiActor->SetKwl(currentImageActor->GetKwl()); } otb::GlROIActor::PointType ul,lr; ul[0]=aulx; ul[1]=auly; lr[0]=alrx; lr[1]=alry; roiActor->SetUL(ul); roiActor->SetLR(lr); roiActor->SetFill(true); roiActor->SetAlpha(0.2); m_View->AddActor(roiActor,tmpKey); m_View->MoveActorToEndOfRenderingOrder(tmpKey,true); } else if(action == GLFW_RELEASE) { m_View->RemoveActor(tmpKey); } } // Change viewport geometry to current actor if(key == GLFW_KEY_P && action == GLFW_PRESS) { // First, transform the center GlImageActor::PointType vpCenter = m_View->GetSettings()->GetViewportCenter(); GlImageActor::PointType imCenter; GlImageActor::PointType tmpImPtX, tmpImPtY; if(currentImageActor.IsNotNull()) { imCenter = currentImageActor->ViewportToImageTransform(vpCenter); // Next, transform the spacing vpCenter[0]+=1000 * m_View->GetSettings()->GetSpacing()[0]; tmpImPtX = currentImageActor->ViewportToImageTransform(vpCenter); vpCenter = m_View->GetSettings()->GetViewportCenter(); vpCenter[1]+=1000 * m_View->GetSettings()->GetSpacing()[1]; tmpImPtY = currentImageActor->ViewportToImageTransform(vpCenter); m_View->GetSettings()->SetWkt(currentImageActor->GetWkt()); m_View->GetSettings()->SetKeywordList(currentImageActor->GetKwl()); } else if(currentVectorActor.IsNotNull()) { imCenter = currentVectorActor->ViewportToVectorTransform(vpCenter); // Next, transform the spacing vpCenter[0]+=1000 * m_View->GetSettings()->GetSpacing()[0]; tmpImPtX = currentVectorActor->ViewportToVectorTransform(vpCenter); vpCenter = m_View->GetSettings()->GetViewportCenter(); vpCenter[1]+=1000 * m_View->GetSettings()->GetSpacing()[1]; tmpImPtY = currentVectorActor->ViewportToVectorTransform(vpCenter); m_View->GetSettings()->SetWkt(currentVectorActor->GetWkt()); } else { itkExceptionMacro(<<"Wrong actor type encountered!"); } GlImageActor::SpacingType spacing; spacing[0]=vcl_sqrt((tmpImPtX[0]-imCenter[0])*(tmpImPtX[0]-imCenter[0])+(tmpImPtX[1]-imCenter[1])*(tmpImPtX[1]-imCenter[1]))/1000; spacing[1]=vcl_sqrt((tmpImPtY[0]-imCenter[0])*(tmpImPtY[0]-imCenter[0])+(tmpImPtY[1]-imCenter[1])*(tmpImPtY[1]-imCenter[1]))/1000; m_View->GetSettings()->SetSpacing(spacing); m_View->GetSettings()->UseProjectionOn(); m_View->GetSettings()->Center(imCenter); m_View->GetSettings()->UpdateRotation(m_View->GetSettings()->GetViewportCenter(),0); m_ReferenceActor = m_SelectedActor; } if(key == GLFW_KEY_Z && action == GLFW_PRESS) { // double ulx(0),uly(0),lrx(0),lry(0); // if(currentVectorActor.IsNotNull()) // { // currentVectorActor->GetExtent(ulx,uly,lrx,lry); // } // else if(currentImageActor.IsNotNull()) // { // currentImageActor->GetExtent(ulx,uly,lrx,lry); // } // otb::ViewSettings::PointType center; // center[0] = 0.5*(ulx+lrx); // center[1] = 0.5*(uly+lry); // double spacingx = (lrx-ulx)/m_View->GetSettings()->GetViewportSize()[0]; // double spacingy = (lry-uly)/m_View->GetSettings()->GetViewportSize()[1]; // otb::ViewSettings::SpacingType spacing; // spacing.Fill(std::max(spacingx,spacingy)); // spacing[1] *= (m_View->GetSettings()->GetSpacing()[1]>0?1:-1); assert( !m_View.IsNull() ); otb::ViewSettings::PointType center; otb::ViewSettings::SpacingType spacing; if( m_View->ZoomToLayer( m_SelectedActor, m_View->GetSettings()->GetSpacing(), center, spacing ) ) { m_View->GetSettings()->SetSpacing( spacing ); m_View->GetSettings()->Center( center ); } } if(key == GLFW_KEY_A && action == GLFW_PRESS) { assert( !m_View.IsNull() ); otb::ViewSettings::PointType center; otb::ViewSettings::SpacingType spacing; if( m_View->ZoomToFull( m_SelectedActor, center, spacing ) ) { m_View->GetSettings()->SetSpacing( spacing ); m_View->GetSettings()->Center( center ); } } if(key == GLFW_KEY_Q && action == GLFW_PRESS) { assert( !m_View.IsNull() ); otb::ViewSettings::PointType center; otb::ViewSettings::SpacingType spacing; if( m_View->ZoomToExtent( m_View->GetSettings()->GetSpacing(), center, spacing ) ) { m_View->GetSettings()->SetSpacing( spacing ); m_View->GetSettings()->Center( center ); } } if(key == GLFW_KEY_F1 && action == GLFW_PRESS) { m_DisplayHelp = true; } if(key == GLFW_KEY_Y && action == GLFW_PRESS) { m_View->GetSettings()->SetPersepectiveAngle(); } if(key == GLFW_KEY_J && action == GLFW_PRESS) { m_View->GetSettings()->SetNorthUpAngle(); } if(key == GLFW_KEY_I && action == GLFW_PRESS) { m_View->GetSettings()->UpdateRotation(m_View->GetSettings()->GetViewportCenter(),0); } if(currentImageActor.IsNotNull()) { this->key_callback_image(window,key,scancode,action,mods); } if(currentVectorActor.IsNotNull()) { this->key_callback_vector(window,key,scancode,action,mods); } } bool IceViewer::key_callback_image(GLFWwindow* window, int key, int, int action, int) { double posx,posy,vpx,vpy; glfwGetCursorPos(m_Window,&posx,&posy); m_View->GetSettings()->ScreenToViewPortTransform(posx,posy,vpx,vpy); otb::GlImageActor::Pointer actor( dynamic_cast< otb::GlImageActor * >( m_View->GetActor( m_SelectedActor ).GetPointer() ) ); if( actor.IsNull() ) return false; otb::StandardShader::Pointer shader( dynamic_cast< otb::StandardShader * >( actor->GetShader() ) ); if( shader.IsNull() ) return false; ImageSettings::Pointer imageSettings( actor->GetImageSettings() ); assert( !imageSettings.IsNull() ); // Switch shader mode if(key == GLFW_KEY_L && action == GLFW_PRESS) { UpdateShaderColorAndPosition(vpx,vpy,actor); shader->SetShaderType(SHADER_LOCAL_CONTRAST); } if(key == GLFW_KEY_T && action == GLFW_PRESS) { UpdateShaderColorAndPosition(vpx,vpy,actor); shader->SetShaderType(SHADER_SPECTRAL_ANGLE); } if(key == GLFW_KEY_M && action == GLFW_PRESS) { shader->SetShaderType(SHADER_GRADIENT); } if(key == GLFW_KEY_U && action == GLFW_PRESS) { shader->SetShaderType(SHADER_LOCAL_ALPHA); } if(key == GLFW_KEY_C && action == GLFW_PRESS) { shader->SetShaderType(SHADER_ALPHA_GRID); } if(key == GLFW_KEY_S && action == GLFW_PRESS) { if(shader->GetShaderType() == SHADER_ALPHA_SLIDER) { shader->SetVerticalSlider(!shader->GetVerticalSlider()); } shader->SetShaderType(SHADER_ALPHA_SLIDER); int width, height; glfwGetFramebufferSize(window, &width, &height); if(shader->GetVerticalSlider()) { shader->SetSliderPosition(height-posy); } else { shader->SetSliderPosition(posx); } } if(key == GLFW_KEY_X && action == GLFW_PRESS) { shader->SetShaderType(SHADER_STANDARD); } if(key == GLFW_KEY_R && action == GLFW_PRESS) { actor->SetRedIdx(1+(actor->GetRedIdx())%actor->GetNumberOfComponents()); UpdateShaderColorAndPosition(vpx,vpy,actor); } if(key == GLFW_KEY_G && action == GLFW_PRESS) { actor->SetGreenIdx(1+(actor->GetGreenIdx())%actor->GetNumberOfComponents()); UpdateShaderColorAndPosition(vpx,vpy,actor); } if(key == GLFW_KEY_B && action == GLFW_PRESS) { actor->SetBlueIdx(1+(actor->GetBlueIdx())%actor->GetNumberOfComponents()); UpdateShaderColorAndPosition(vpx,vpy,actor); } if(key == GLFW_KEY_F && action == GLFW_PRESS) { double minRed,maxRed,minGreen,maxGreen,minBlue,maxBlue; actor->AutoColorAdjustment(minRed,maxRed,minGreen,maxGreen,minBlue,maxBlue); imageSettings->SetMinRed( minRed ); imageSettings->SetMinGreen( minGreen ); imageSettings->SetMinBlue( minBlue ); imageSettings->SetMaxRed( maxRed ); imageSettings->SetMaxGreen( maxGreen ); imageSettings->SetMaxBlue( maxBlue ); } if(key == GLFW_KEY_E && action == GLFW_PRESS) { std::vector actorsKeys = m_View->GetActorsKeys(); for(std::vector::const_iterator it = actorsKeys.begin(); it!=actorsKeys.end();++it) { this->CopyActorStyle(m_View->GetActor(m_SelectedActor),m_View->GetActor(*it)); } } if(key == GLFW_KEY_V && action == GLFW_PRESS) { double minRed,maxRed,minGreen,maxGreen,minBlue,maxBlue; actor->AutoColorAdjustment(minRed,maxRed,minGreen,maxGreen,minBlue,maxBlue,false); imageSettings->SetMinRed( minRed ); imageSettings->SetMinGreen( minGreen ); imageSettings->SetMinBlue( minBlue ); imageSettings->SetMaxRed( maxRed ); imageSettings->SetMaxGreen( maxGreen ); imageSettings->SetMaxBlue( maxBlue ); } #if 0 // Zoom to full resolution of an image if(key == GLFW_KEY_A && action == GLFW_PRESS) { // Estimate the correct spacing GlImageActor::PointType vpCenter = m_View->GetSettings()->GetViewportCenter(); GlImageActor::PointType imCenter = actor->ViewportToImageTransform(vpCenter,false); vpCenter[0]+=1000*m_View->GetSettings()->GetSpacing()[0]; GlImageActor::PointType imCenter2 = actor->ViewportToImageTransform(vpCenter,false); double length = vcl_sqrt((imCenter[0]-imCenter2[0])*(imCenter[0]-imCenter2[0])+(imCenter[1]-imCenter2[1])*(imCenter[1]-imCenter2[1])); GlImageActor::SpacingType spacing = m_View->GetSettings()->GetSpacing(); std::cout << "vp:" << vpCenter[ 0 ] << ", " << vpCenter[ 1 ] << std::endl; std::cout << "im-1:" << imCenter[ 0 ] << ", " << imCenter[ 1 ] << std::endl; std::cout << "im-2:" << imCenter2[ 0 ] << ", " << imCenter2[ 1 ] << std::endl << std::endl; spacing[0]=spacing[0]/(length/1000); vpCenter = m_View->GetSettings()->GetViewportCenter(); imCenter = actor->ViewportToImageTransform(vpCenter,false); vpCenter[1]+=1000*m_View->GetSettings()->GetSpacing()[1]; imCenter2 = actor->ViewportToImageTransform(vpCenter,false); length = vcl_sqrt((imCenter[0]-imCenter2[0])*(imCenter[0]-imCenter2[0])+(imCenter[1]-imCenter2[1])*(imCenter[1]-imCenter2[1])); std::cout << "vp:" << vpCenter[ 0 ] << ", " << vpCenter[ 1 ] << std::endl; std::cout << "im-1:" << imCenter[ 0 ] << ", " << imCenter[ 1 ] << std::endl; std::cout << "im-2:" << imCenter2[ 0 ] << ", " << imCenter2[ 1 ] << std::endl << std::endl; spacing[1]=spacing[1]/(length/1000); vpCenter = m_View->GetSettings()->GetViewportCenter(); m_View->GetSettings()->SetSpacing(spacing); m_View->GetSettings()->Center(vpCenter); } #endif //Activate/Deactivate the use no-data if(key == GLFW_KEY_N && action == GLFW_PRESS) { imageSettings->SetUseNoData( !imageSettings->GetUseNoData() ); } return true; } bool IceViewer::key_callback_vector(GLFWwindow*, int key, int, int action, int) { otb::GlVectorActor::Pointer currentActor = dynamic_cast(m_View->GetActor(m_SelectedActor).GetPointer()); if(currentActor.IsNull()) { return false; } if(key == GLFW_KEY_F && action == GLFW_PRESS) { currentActor->SetFill(!currentActor->GetFill()); return true; } if(key == GLFW_KEY_S && action == GLFW_PRESS) { currentActor->SetSolidBorder(!currentActor->GetSolidBorder()); return true; } if(key == GLFW_KEY_O && action == GLFW_PRESS) { currentActor->SetOptimizedRendering(!currentActor->GetOptimizedRendering()); return true; } return false; } void IceViewer::mouse_button_callback(GLFWwindow *, int button, int action, int) { if(button == GLFW_MOUSE_BUTTON_1) { if(action == GLFW_PRESS) { m_Dragging = true; m_FastRendering = true; glfwGetCursorPos(m_Window,&m_StartDrag[0],&m_StartDrag[1]); // TODO: Move drag to dedicated method in ViewSettings m_OriginDrag = m_View->GetSettings()->GetOrigin(); m_StartAngle = m_View->GetSettings()->GetRotationAngle(); } else if(action == GLFW_RELEASE) { m_Dragging = false; m_FastRendering = false; otb::ViewSettings::PointType origin; origin[0]=m_OriginDrag[0]-m_DeltaDrag[0]*m_View->GetSettings()->GetSpacing()[0]; origin[1]=m_OriginDrag[1]+m_DeltaDrag[1]*m_View->GetSettings()->GetSpacing()[1]; m_View->GetSettings()->SetOrigin(origin); m_StartDrag.Fill(0); m_DeltaDrag.Fill(0); m_OriginDrag.Fill(0); m_StartAngle = 0; } } else if(button == GLFW_MOUSE_BUTTON_2) { otb::GlActor::Pointer currentActor = m_View->GetActor(m_SelectedActor); if(action == GLFW_PRESS) { currentActor->SetVisible(!currentActor->GetVisible()); } else if(action == GLFW_RELEASE) { currentActor->SetVisible(!currentActor->GetVisible()); } } } void IceViewer::framebuffer_size_callback(GLFWwindow*, int width, int height) { otb::ViewSettings::PointType center = m_View->GetSettings()->GetViewportCenter(); otb::ViewSettings::SizeType size; size[0] = width; size[1] = height; m_View->GetSettings()->SetViewportSize(size); m_View->GetSettings()->Center(center); } otb::GlActor::Pointer IceViewer::GetActor(const std::string & key) { return m_View->GetActor(key); } void IceViewer::CopyActorStyle(otb::GlActor::Pointer srcActor, otb::GlActor::Pointer dstActor) { otb::GlImageActor::Pointer srcImgActor = dynamic_cast(srcActor.GetPointer()); otb::GlImageActor::Pointer dstImgActor = dynamic_cast(dstActor.GetPointer()); if(srcImgActor.IsNotNull() && srcActor->GetVisible() && dstImgActor.IsNotNull() && dstActor->GetVisible()) { ImageSettings::Pointer srcImageSettings( srcImgActor->GetImageSettings() ); assert( !srcImageSettings.IsNull() ); ImageSettings::Pointer dstImageSettings( dstImgActor->GetImageSettings() ); assert( !dstImageSettings.IsNull() ); otb::StandardShader::Pointer srcShader = dynamic_cast(srcImgActor->GetShader()); otb::StandardShader::Pointer dstShader = dynamic_cast(dstImgActor->GetShader()); if( srcShader.IsNotNull() && dstShader.IsNotNull() ) { // Apply same parameters to all image actors dstImgActor->SetRedIdx( srcImgActor->GetRedIdx() ); dstImgActor->SetGreenIdx( srcImgActor->GetGreenIdx() ); dstImgActor->SetBlueIdx( srcImgActor->GetBlueIdx() ); dstImageSettings->SetMinRed( srcImageSettings->GetMinRed() ); dstImageSettings->SetMinGreen( srcImageSettings->GetMinGreen() ); dstImageSettings->SetMinBlue( srcImageSettings->GetMinBlue() ); dstImageSettings->SetMaxRed( srcImageSettings->GetMaxRed() ); dstImageSettings->SetMaxGreen( srcImageSettings->GetMaxGreen() ); dstImageSettings->SetMaxBlue( srcImageSettings->GetMaxBlue() ); dstImageSettings->SetGamma( srcImageSettings->GetGamma() ); if(srcShader->GetShaderType() == SHADER_STANDARD || srcShader->GetShaderType() == SHADER_LOCAL_CONTRAST || srcShader->GetShaderType() == SHADER_SPECTRAL_ANGLE || srcShader->GetShaderType() == SHADER_GRADIENT) { dstShader->SetShaderType(srcShader->GetShaderType()); dstShader->SetRadius(srcShader->GetRadius()); if(srcShader->GetShaderType() == SHADER_LOCAL_CONTRAST) { dstShader->SetLocalContrastRange(srcShader->GetLocalContrastRange()); } if(srcShader->GetShaderType() == SHADER_SPECTRAL_ANGLE) { dstShader->SetSpectralAngleRange(srcShader->GetSpectralAngleRange()); } } } } } void IceViewer::SetActorName(const std::string & key, const std::string & name) { // Should be more careful here m_View->GetActor(key)->SetName(name); } } OTB-release-5.8/Modules/Visualization/Mapla/000077500000000000000000000000001301006202600207215ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Mapla/CMakeLists.txt000066400000000000000000000002561301006202600234640ustar00rootroot00000000000000project( OTBMapla ) set(OTBMapla_LIBRARIES OTBMapla) # folder where ui headers are generated set( OTBMapla_INCLUDE_DIRS ${OTBMapla_BINARY_DIR}/src ) otb_module_impl() OTB-release-5.8/Modules/Visualization/Mapla/include/000077500000000000000000000000001301006202600223445ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Mapla/include/mvdMaplaApplication.h000066400000000000000000000102211301006202600264360ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMaplaApplication_h #define mvdMaplaApplication_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdI18nApplication.h" #include "OTBMaplaExport.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { class OTBApplicationsModel; // // Class declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class MaplaApplication * * \ingroup OTBMapla * */ class OTBMapla_EXPORT MaplaApplication : public I18nApplication { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public constants/types. public: // // Public methods. public: /** * \brief Constructor. * * \param qtApp The parent Qt application (\see I18nApplication). */ MaplaApplication( QApplication* qtApp ); /** \brief Destructor. */ ~MaplaApplication() ITK_OVERRIDE; // // STATIC METHODS. /** * \brief Access the const instance of application singleton. * \return The const instance to the singleton MaplaApplication. */ inline static const MaplaApplication* ConstInstance(); /** * \brief Access the non-const instance of application singleton. * \return The non-const instance to the singleton MaplaApplication. */ inline static MaplaApplication* Instance(); /** */ void Foo(); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: void virtual_InitializeCore() ITK_OVERRIDE; /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ inline const MaplaApplication* MaplaApplication ::ConstInstance() { return I18nCoreApplication::ConstInstance< MaplaApplication >(); } /*****************************************************************************/ inline MaplaApplication* MaplaApplication ::Instance() { return I18nCoreApplication::Instance< MaplaApplication >(); } } // end namespace 'mvd' #endif // maplaApplication_h OTB-release-5.8/Modules/Visualization/Mapla/include/mvdMaplaMainWindow.h000066400000000000000000000114241301006202600262550ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMaplaMainWindow_h #define mvdMaplaMainWindow_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" // #include "mvdI18nMainWindow.h" #include "OTBMaplaExport.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External class pre-declaration. namespace { } namespace mvd { // // Internal class pre-declaration. // Core // Gui class ApplicationsToolBoxController; namespace Ui { class MaplaMainWindow; } /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class MaplaMainWindow * * \ingroup OTBMapla * * \brief The application main-widow widget. */ class OTBMapla_EXPORT MaplaMainWindow : public I18nMainWindow { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: // // Public methods. public: /** \brief Constructor. */ MaplaMainWindow( QWidget* Parent =0, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~MaplaMainWindow() ITK_OVERRIDE; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // QMainWindow methods. void closeEvent( QCloseEvent* event ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PROTECTED SLOTS SECTION ]---------------------------------------------*/ // // Protected slots. protected slots: /** */ void OnAboutToChangeModel( const AbstractModel* ) ITK_OVERRIDE; /** */ void OnModelChanged( AbstractModel* ) ITK_OVERRIDE; /** */ void OnApplicationToLaunchSelected( const QString & name, const QString & doc ); /** */ #if 0 void OnOTBApplicationOutputImageChanged( const QString & name, const QString & filename); #endif /** */ void OnExecutionDone( int status ); /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: /** */ void InitializeDockWidgets(); /** */ void InitializeCentralWidget(); // // I18nMainWindow methods. void virtual_SetupUI() ITK_OVERRIDE; void virtual_ConnectUI() ITK_OVERRIDE; // // Private attributes. private: /** * \brief uic generated. */ Ui::MaplaMainWindow* m_UI; #ifdef OTB_USE_QT4 /** * \brief OTB-applications tool-box controller. */ ApplicationsToolBoxController * m_ApplicationsToolBoxController; #endif /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Private slots. private slots: /** * \brief Qt auto-connected slot which is called when * 'File/Preferences' menu action is trigerred. */ void on_action_Preferences_triggered(); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdImageViewWidget.h" // // Some constants. namespace mvd { } // end namespace 'mvd' #endif // maplaMainWindow_h OTB-release-5.8/Modules/Visualization/Mapla/otb-module.cmake000066400000000000000000000004071301006202600237730ustar00rootroot00000000000000set(DOCUMENTATION "This module provides the Monteverdi Application Launcher (Mapla) program." ) otb_module( OTBMapla ENABLE_SHARED DEPENDS OTBMonteverdiCore OTBMonteverdiGUI OTBQt4 OPTIONAL_DEPENDS DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Visualization/Mapla/src/000077500000000000000000000000001301006202600215105ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Mapla/src/CMakeLists.txt000066400000000000000000000043321301006202600242520ustar00rootroot00000000000000############################################################################# set( OTBMapla_SRCS mvdMaplaApplication.cxx mvdMaplaMainWindow.cxx ) ############################################################################# set( OTBMapla_HEADERS_MOC ../include/mvdMaplaApplication.h ../include/mvdMaplaMainWindow.h # mvdPreferencesDialog.h ) ############################################################################# set( OTBMapla_FORMS mvdMaplaMainWindow.ui # mvdPreferencesDialog.ui ) ############################################################################# set( OTBMapla_RESOURCES mvdMaplaMainWindow.qrc ) if (WIN32) # Windows Resource file need to have the full path to icon # if the .ico is not in the current dir set( Mapla_App_WIN32_ICON ${OTB_SOURCE_DIR}/Utilities/Data/Icons/monteverdi.ico) configure_file( mvdMaplaWin32.rc.in mvdMaplaWin32.rc @ONLY ) if (MINGW) set(CMAKE_RC_COMPILE_OBJECT " -O coff -i -o ") endif() # The RC file to be added to source list set( Mapla_App_WIN32_RC_FILE ${CMAKE_CURRENT_BINARY_DIR}/mvdMaplaWin32.rc ) endif() ############################################################################# qt4_wrap_cpp( OTBMapla_SRC_MOC ${OTBMapla_HEADERS_MOC} ) qt4_wrap_ui( OTBMapla_FORMS_HEADERS ${OTBMapla_FORMS} ) qt4_add_resources( OTBMapla_RESOURCES_RCC ${OTBMapla_RESOURCES} ) ############################################################################# add_to_qt4_i18n_sources( ${OTBMapla_SRCS} ) add_to_qt4_i18n_headers( "../include" ${OTBMapla_SRCS} ) add_to_qt4_i18n_forms( ${OTBMapla_FORMS} ) ##########################[Mapla library]#################################### add_library( OTBMapla STATIC ${OTBMapla_SRCS} ${OTBMapla_FORMS_HEADERS} ${OTBMapla_SRC_MOC} ) target_link_libraries( OTBMapla ${OTBMonteverdiCore_LIBRARIES} ${OTBMonteverdiGUI_LIBRARIES} ${OTBQt4_LIBRARIES} ) otb_module_target( OTBMapla ) ############################[Mapla executable]############################### add_executable( mapla main.cxx ${Mapla_App_WIN32_RC_FILE} ${OTBMapla_RESOURCES_RCC} ) target_link_libraries( mapla OTBMapla ) otb_module_target( mapla ) OTB-release-5.8/Modules/Visualization/Mapla/src/main.cxx000066400000000000000000000101331301006202600231560ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include #include // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) #include "itksys/SystemTools.hxx" // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdMaplaApplication.h" #include "mvdMaplaMainWindow.h" enum ERROR_CODE { ERROR_CODE_I18N = -1, ERROR_CODE_CACHE_DIR = -2, ERROR_CODE_DATABASE = -3, ERROR_CODE_GL_VERSION = -4, }; /*****************************************************************************/ /* FUNCTIONS DECLARATION */ /*****************************************************************************/ /* MAIN */ int main( int argc, char* argv[] ) { QApplication qtApp( argc, argv ); // // 0. Splash-screen. #if !defined( OTB_DEBUG ) QPixmap pixmap(QLatin1String( ":/images/application_splash" )); QSplashScreen splash(pixmap); splash.show(); qtApp.processEvents();//This is used to accept a click on the screen so that user can cancel the screen #endif // // 1. Initialize application and sync settings. // // Coverity-14835 // { mvd::MaplaApplication * application = NULL; try { application = new mvd::MaplaApplication( &qtApp ); assert( application!=NULL ); application->Initialize(); } catch( std::exception & exc ) { QMessageBox::StandardButton button = QMessageBox::question( NULL, QCoreApplication::translate( "Mapla", "Question!" ), QCoreApplication::translate( "Mapla", "The following exception has been caught while initializing the software:\n\n" "%1\n\n" "The application may not function as expected. Do you want to continue?" ) .arg( exc.what() ), QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes ); if( button==QMessageBox::No ) return ERROR_CODE_I18N; } // } // Coverity-14835 // // 2. Initialize main-window (UI). mvd::MaplaMainWindow mainWindow; mainWindow.Initialize(); application->Foo(); // // 3. Initialize cache directory. // // N/A // // 4. Initialize database. // // N.A. // // 5. Show window. #if defined( OTB_DEBUG ) #else // OTB_DEBUG splash.finish(&mainWindow); #endif // OTB_DEBUG // Useful when developping/debugging to avoid overlapping other windows. mainWindow.show(); // // 6. Check OpenGL capabilities /* if( !mainWindow.CheckGLCapabilities() ) return ERROR_CODE_GL_VERSION; */ // // 7. Let's go: run the application and return exit code. int result = QCoreApplication::instance()->exec(); // application->CloseDatabase(); // Coverity-14835 // { delete application; application = NULL; // } // Coverity-14835 return result; } /*****************************************************************************/ /* FUNCTIONS IMPLEMENTATION */ /*****************************************************************************/ OTB-release-5.8/Modules/Visualization/Mapla/src/mvdMaplaApplication.cxx000066400000000000000000000055241301006202600261670ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdMaplaApplication.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) // #ifdef OTB_USE_QT4 #include "mvdOTBApplicationsModel.h" #endif // // Class implementation. namespace mvd { /* TRANSLATOR mvd::MaplaApplication Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ MaplaApplication ::MaplaApplication( QApplication* qtApp ) : I18nApplication( qtApp ) { } /*******************************************************************************/ MaplaApplication ::~MaplaApplication() { } /*******************************************************************************/ void MaplaApplication ::virtual_InitializeCore() { I18nApplication::virtual_InitializeCore(); setObjectName( "MaplaApplication" ); InitializeCore( "Monteverdi Application Launcher", QString( "OTB %1" ).arg( OTB_VERSION_STRING ), "OrfeoToolBox", "orfeo-toolbox.org" ); } /*******************************************************************************/ void MaplaApplication ::Foo() { SetModel( new OTBApplicationsModel( this ) ); } /*******************************************************************************/ /* SLOTS */ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/Mapla/src/mvdMaplaMainWindow.cxx000066400000000000000000000140521301006202600257740ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdMaplaMainWindow.h" #include "ui_mvdMaplaMainWindow.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifdef OTB_USE_QT4 # include "mvdApplicationLauncher.h" # include "mvdApplicationsToolBoxController.h" # include "mvdOTBApplicationsModel.h" # if 1 # include "mvdQtWidgetView.h" # else # include "otbWrappperQtWidgetView.h" # endif #endif // #include "mvdApplicationsToolBox.h" // #include "mvdMaplaApplication.h" // #include "mvdPreferencesDialog.h" namespace mvd { /* TRANSLATOR mvd::MaplaMainWindow Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ MaplaMainWindow ::MaplaMainWindow( QWidget * p, Qt::WindowFlags flags ) : I18nMainWindow( p, flags ), m_UI( new mvd::Ui::MaplaMainWindow() ) #ifdef OTB_USE_QT4 , m_ApplicationsToolBoxController( NULL ) #endif { m_UI->setupUi( this ); } /*****************************************************************************/ MaplaMainWindow ::~MaplaMainWindow() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ void MaplaMainWindow ::virtual_SetupUI() { setObjectName( "Mapla" ); setWindowTitle( PROJECT_NAME " Application Launcher" ); #ifdef OTB_USE_QT4 assert( m_ApplicationsToolBoxController==NULL ); m_ApplicationsToolBoxController = new ApplicationsToolBoxController( new ApplicationsToolBox( this ), this ); assert( MaplaApplication::Instance() ); setCentralWidget( m_ApplicationsToolBoxController->GetWidget() ); #else // OTB_USE_QT4 setCentralWidget( new QLabel( tr( "Enable OTB_USE_QT4 preprocessor definition at compile time!" ), this ) ); #endif // OTB_USE_QT4 if( !RestoreLayout( Monteverdi_UI_VERSION ) ) { qWarning() << "Failed to restore window layout!"; } } /*****************************************************************************/ void MaplaMainWindow ::virtual_ConnectUI() { // // OTB application support. #ifdef OTB_USE_QT4 QObject::connect( m_ApplicationsToolBoxController->GetWidget(), SIGNAL( ApplicationToLaunchSelected( const QString &, const QString & ) ), // to: this, SLOT( OnApplicationToLaunchSelected(const QString &, const QString & ) ) ); #endif } /*****************************************************************************/ void MaplaMainWindow ::closeEvent( QCloseEvent* e ) { assert( MaplaApplication::Instance() ); assert( MaplaApplication::Instance()->GetModel()== MaplaApplication::Instance()->GetModel< OTBApplicationsModel >() ); SaveLayout( Monteverdi_UI_VERSION ); I18nMainWindow::closeEvent( e ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void MaplaMainWindow ::on_action_Preferences_triggered() { #if 0 PreferencesDialog prefDialog( this ); prefDialog.exec(); #endif } /*****************************************************************************/ void MaplaMainWindow ::OnAboutToChangeModel( const AbstractModel * ) { // qDebug() << this << "::OnAboutToChangeModel(" << model << ")"; m_ApplicationsToolBoxController->SetModel( NULL ); } /*****************************************************************************/ void MaplaMainWindow ::OnModelChanged( AbstractModel* model ) { // qDebug() << this << "::OnModelChanged(" << model << ")"; m_ApplicationsToolBoxController->SetModel( model ); } /*****************************************************************************/ void MaplaMainWindow ::OnApplicationToLaunchSelected( const QString & appName, const QString & ) { #ifdef OTB_USE_QT4 assert( MaplaApplication::ConstInstance()!=NULL ); assert( MaplaApplication::ConstInstance()->GetModel()!=NULL ); assert( MaplaApplication::ConstInstance()->GetModel()== MaplaApplication::ConstInstance()->GetModel< OTBApplicationsModel >() ); assert( MaplaApplication::ConstInstance() ->GetModel< OTBApplicationsModel >() ->GetLauncher()!=NULL ); QWidget * appWindow = MaplaApplication::ConstInstance() ->GetModel< OTBApplicationsModel >() ->GetLauncher() ->NewOtbApplicationWindow( appName, true, this ); assert( appWindow!=NULL ); appWindow->show(); #endif // OTB_USE_QT4 } /*****************************************************************************/ void MaplaMainWindow ::OnExecutionDone( int status ) { if( status<0 ) return; } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/Mapla/src/mvdMaplaMainWindow.qrc000066400000000000000000000024521301006202600257600ustar00rootroot00000000000000 ../../../../Utilities/Data/Icons/zoom-1to1.png ../../../../Utilities/Data/Icons/monteverdi-32x32.png ../../../../Utilities/Data/Icons/alg.png ../../../../Utilities/Data/Icons/execute.png ../../../../Utilities/Data/Icons/locked.png ../../../../Utilities/Data/Icons/unlocked.png ../../../../Utilities/Data/Icons/forbidden-128x128.png ../../../../Utilities/Data/Icons/action-zoomin_24x24.png ../../../../Utilities/Data/Icons/action-zoomfullextent_24x24.png ../../../../Utilities/Data/Icons/action-zoomout_24x24.png ../../../../Utilities/Data/Icons/action-zoomtolayer_24x24.png ../../../../Utilities/Data/Icons/document-open_32x32.png ../../../../Utilities/Data/Icons/monteverdi-128x128.png ../../../../Utilities/Data/Icons/monteverdi-splash.png OTB-release-5.8/Modules/Visualization/Mapla/src/mvdMaplaMainWindow.ui000066400000000000000000000053701301006202600256120ustar00rootroot00000000000000 mvd::MaplaMainWindow 0 0 400 600 Main window 0 0 400 27 &File &Help &Edit &Quit Quit application. Ctrl+Q true :/icons/action_Open_Icon:/icons/action_Open_Icon &Import image... Import image... Import image-file. Ctrl+O &About... About... About... false Prefere&nces OTB-release-5.8/Modules/Visualization/Mapla/src/mvdMaplaWin32.rc.in000066400000000000000000000022421301006202600250270ustar00rootroot00000000000000#include "winver.h" IDI_ICON1 ICON DISCARDABLE "@Mapla_App_WIN32_ICON@" VS_VERSION_INFO VERSIONINFO FILEVERSION @Monteverdi_VERSION_MAJOR@,@Monteverdi_VERSION_MINOR@,@Monteverdi_VERSION_PATCH@,0 PRODUCTVERSION @Monteverdi_VERSION_MAJOR@,@Monteverdi_VERSION_MINOR@,@Monteverdi_VERSION_PATCH@,0 FILEFLAGS 0x0L FILEFLAGSMASK 0x3fL FILEOS 0x00040004L FILETYPE 0x1L FILESUBTYPE 0x0L BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "000004b0" BEGIN VALUE "CompanyName", "OrfeoToolbox" VALUE "FileDescription", "Monteverdi 2" VALUE "FileVersion", "@Monteverdi_VERSION_MAJOR@.@Monteverdi_VERSION_MINOR@.@Monteverdi_VERSION_PATCH@.0" VALUE "LegalCopyright", "Copyright (c) 2012-2013 Centre National d'Etudes Spatiales. All rights reserved." VALUE "InternalName", "mapla" VALUE "OriginalFilename", "mapla.exe" VALUE "ProductName", "Mapla" VALUE "ProductVersion", "@Monteverdi_VERSION_MAJOR@.@Monteverdi_VERSION_MINOR@.@Monteverdi_VERSION_PATCH@.0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x0, 1200 END END OTB-release-5.8/Modules/Visualization/Monteverdi/000077500000000000000000000000001301006202600220035ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Monteverdi/CMakeLists.txt000066400000000000000000000003111301006202600245360ustar00rootroot00000000000000project( OTBMonteverdi ) set( OTBMonteverdi_LIBRARIES OTBMonteverdi ) # folder where ui headers are generated set( OTBMonteverdi_INCLUDE_DIRS ${OTBMonteverdi_BINARY_DIR}/src ) otb_module_impl() OTB-release-5.8/Modules/Visualization/Monteverdi/README.txt000066400000000000000000000036121301006202600235030ustar00rootroot00000000000000Monteverdi was developed 4 years ago in order to provide an integrated application for capacity building activities (teaching, simple image manipulation, etc.). Its success went far beyond this initial scope since it opened the OTB world to a wide range of users who needed a ready to use graphical tool more than a library of components to write their own processing chain. With this 4 years of lifetime, we have a lot of feedbacks regarding how useful the tool was, but also regarding what should be improved to move toward greater usability and operationnality. We therefore decided to rework the Monteverdi concept into a brand new software, enlightened by this experience. Here are suggested steps for the Monteverdi beginner. 1) Get the software. http://orfeo-toolbox.org/otb/download.html 2) The software is compiled using CMake http://www.cmake.org. CMake generates Makefiles on Unix platforms, and Windows workspaces (or appropriate) build files according to your compiler, operating system, and other system variables. Create a binary directory, and then run cmake. Provide to CMake the source directory of Monteverdi and the binary directory that you just created. Monteverdi depends on OTB. You have to fill up the OTB_DIR variable with the location of the compiled OTB. If you use ccmake or cmake-gui, you have an interface to enter the value. Please submit bug reports using the OTB bug tracker at: http://bugs.orfeo-toolbox.org You can get support : 1. Using the OTB community site at http://orfeo-toolbox.org/ 2. Joining the otb-users mailing list at http://groups.google.com/group/otb-users Monteverdi source code is available at http://hg.orfeo-toolbox.org/Monteverdi There is many ways to join us in the OTB adventure and the more people contribute, the better the library is for everybody! See at http://www.orfeo-toolbox.org/otb/contribute.html OTB-release-5.8/Modules/Visualization/Monteverdi/RELEASE_NOTES_MVD.txt000066400000000000000000000307021301006202600253040ustar00rootroot00000000000000========================= Monteverdi Release Note ========================= Monteverdi 3.4.0 - Changes since version 3.2.0 (July 28th, 2016) ================================================================= * Bug fixes: * MANTIS-1256: elete-All button not disabled after layer-stack has been cleared * MANTIS-1250: Main-window always show maximized * MANTIS-1245: Monteverdi: no projection mode display problem * MANTIS-1244: Emptying layer stack does not reset viewport state * MANTIS-1235: Monteverdi is not able to open S1 product (SLC SM product) * MANTIS-1232: Layer stack disappear after opening an image (gnome 3) * MANTIS-1231: Monteverdi: shader effect does not follow the mouse cursor when moving * MANTIS-1221: Error build Monteverdi2 3.2.0 in Arch Linux * MANTIS-1205: Gamma slider effect inverted between full and quicklook view * MANTIS-1204: Zoom to full extent and zoom to layer extent does not preserve aspect ratio * RFC: * Request for Changes-44: Improve OTB-applications display & search in Monteverd & Mapla Monteverdi 3.2.0 - Changes since version 3.0.0 (March 30th, 2016) ================================================================= * Bug fixes: * MANTIS-1203: Clicking on 1:1 button several time result in strange cycling behaviour * MANTIS-1202: Wrong aspect ratio at loading * MANTIS-1197: Clicking on minimap to navigate result in monteverdi crashing * MANTIS-1196: OTB-application Quit button closes widget but not window when using Mapla * MANTIS-1179: Using the Upper Bound mode for resolution lookup in preferences result in wrong resolution used * MANTIS-1178: Zoom to full resolution does not zoom to 1 image pixel = 1 screen pixel for georeferenced data * MANTIS-1159: TrainImageClassifier sample.vtr parameter is sometime ignored * MANTIS-1157: Monteverdi crashes when trying to move the view without any images * MANTIS-1156: Linux standalone package doesn't work on Fedora 22 * MANTIS-1154: Exception raised when opening LUM or LUM+HDR * MANTIS-1153: Superimpose app in PHR mode reports wrong origin/spacing/keywordlist * MANTIS-1152: Maximum number of class in KMean application limited to 255 * MANTIS-1148: OTB-applications not loaded * MANTIS-1147: With Monteverdi develop branch of today : opening large images with overview file leads to eating all available memory * MANTIS-1144: Unable to keep unconstrained dynamic mode * MANTIS-1140: Lost pixel position information in layer stack * MANTIS-1138: Numeric value editing hell * MANTIS-1136: Unable to open sensor products (with RPC) in Monteverdi * MANTIS-1131: Non projected visualization mode seems slow * MANTIS-1125: Use OTB_APPLICATION_PATH in startup files * MANTIS-1122: Black screen after Zoom-to-extent (MinGW) * MANTIS-1120: Unwanted zoom-to-extent when loading second image * MANTIS-1118: Crash when restoring UI layout if quicklook view is visible at startup. * MANTIS-1111: Geoid-file (); } /*****************************************************************************/ inline Application* Application ::Instance() { return I18nCoreApplication::Instance< Application >(); } /*****************************************************************************/ inline const OTBApplicationsModel* Application ::GetOTBApplicationsModel() const { return m_OTBApplicationsModel; } /*****************************************************************************/ inline OTBApplicationsModel* Application ::GetOTBApplicationsModel() { return m_OTBApplicationsModel; } } // end namespace 'mvd' #endif // mvdApplication_h OTB-release-5.8/Modules/Visualization/Monteverdi/include/mvdMainWindow.h000066400000000000000000000247131301006202600263710ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMainWindow_h #define mvdMainWindow_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" #define USE_TABBED_VIEW 0 #define USE_PIXEL_DESCRIPTION ( ( defined( OTB_DEBUG ) && 0 ) || 0 ) #define RENDER_IMAGE_VIEW_DISABLED 0 #define RENDER_QUICKLOOK_VIEW_DISABLED 0 /*****************************************************************************/ /* INCLUDE SECTION */ #ifndef USE_OTB_APPS # define USE_OTB_APPS ( ( defined( OTB_DEBUG ) && 0 ) || 1 ) #endif // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" #include "mvdStackedLayerModel.h" // #include "mvdI18nMainWindow.h" #include "OTBMonteverdiExport.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External class pre-declaration. namespace { } namespace mvd { // // Internal class pre-declaration. // Core class AbstractLayerModel; // Gui class FilenameDragAndDropEventFilter; class ImageViewWidget; class KeymapDialog; class LayerStackWidget; class ShaderWidget; class StatusBarWidget; namespace Ui { class MainWindow; } /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class MainWindow * * \ingroup OTBMonteverdi * * \brief The application main-widow widget. */ class OTBMonteverdi_EXPORT MainWindow : public I18nMainWindow { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: // // Public methods. public: /** \brief Constructor. */ MainWindow( QWidget* p =0, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~MainWindow() ITK_OVERRIDE; /** */ bool CheckGLCapabilities(); /** */ #if USE_OTB_APPS void SetupOTBApplications(); #endif // USE_OTB_APPS /*-[ PROTECTED SLOTS SECTION ]---------------------------------------------*/ // // Public slots. public slots: /** */ CountType ImportImage( const QString & filename, StackedLayerModel::SizeType index ); /** */ void ImportImages( const QStringList & filenames ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: void UserCoordinatesEditingFinished(const QString&); void UserScaleEditingFinished(const QString &); void UserZoomIn(); void UserZoomOut(); void UserZoomExtent(); void UserZoomFull(); void UserZoomLayer(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: using I18nMainWindow::ImportImage; // // QMainWindow methods. void closeEvent( QCloseEvent* event ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PROTECTED SLOTS SECTION ]---------------------------------------------*/ // // Protected slots. protected slots: /** */ void OnAboutToChangeModel( const AbstractModel * ) ITK_OVERRIDE; /** */ void OnModelChanged( AbstractModel * ) ITK_OVERRIDE; /** */ // void OnAboutToChangeSelectedDatasetModel( const DatasetModel* ); /** */ // void OnSelectedDatasetModelChanged( DatasetModel* ); /** */ void OnAboutToChangeSelectedLayerModel( const StackedLayerModel::KeyType & ); /** */ void OnSelectedLayerModelChanged( const StackedLayerModel::KeyType & ); /** */ #if defined( OTB_USE_QT4 ) && USE_OTB_APPS void OnApplicationToLaunchSelected( const QString & appName, const QString & docName ); #endif // defined( OTB_USE_QT4 ) && USE_OTB_APPS /** */ #if USE_TABBED_VIEW void OnTabCloseRequested( int index ); #endif /** */ #if USE_TABBED_VIEW void OnTabCloseRequested(); #endif /** */ void OnOTBApplicationOutputImageChanged( const QString & appName, const QString & outfname); /** */ void OnExecutionDone( int status ); /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: /** */ ImageViewWidget* CreateImageViewWidget( QGLWidget* sharedGlWidget =NULL ); /** */ ImageViewWidget* CreateQuicklookViewWidget( QGLWidget* sharedGlWidget =NULL ); /** */ void InitializeDockWidgets(); /** */ void InitializeCentralWidget(); /** */ void InitializeRenderToolBar(); /** */ void InitializeShaderToolBar(); /** */ void InitializeStatusBarWidgets(); /** */ inline const ImageViewWidget* GetQuicklookView() const; /** */ inline ImageViewWidget* GetQuicklookView(); /** */ void ConnectImageViews(); /** */ void ConnectViewMenu(); /** */ void ConnectReferenceLayerComboBox( StackedLayerModel * ); /** */ void DisconnectReferenceLayerComboBox( StackedLayerModel * ); /** */ void SetupReferenceLayerComboBox( StackedLayerModel * ); /** */ void ConnectStatusBar(); #if USE_PIXEL_DESCRIPTION /** */ void ConnectPixelDescriptionWidget( AbstractLayerModel * model); /** */ void DisconnectPixelDescriptionWidget( const AbstractLayerModel * model ); #endif // USE_PIXEL_DESCRIPTION // // I18nMainWindow methods. void virtual_SetupUI() ITK_OVERRIDE; void virtual_ConnectUI() ITK_OVERRIDE; void virtual_InitializeUI() ITK_OVERRIDE; // // Private attributes. private: /** * \brief uic generated. */ Ui::MainWindow* m_UI; /** * \brief Color dynamicsk-view dock-widget. */ QDockWidget* m_ColorDynamicsDock; /** * \brief Color setup dock-widget. */ QDockWidget* m_ColorSetupDock; /** * \brief Database-browser dock-widget. */ // QDockWidget* m_DatabaseBrowserDock; /** * \brief Dataset-properties dock-widget. */ // QDockWidget* m_DatasetPropertiesDock; /** * \brief Layer-stack dock-widget. */ QDockWidget * m_LayerStackDock; /** * \brief Current Pixel Description dock-widget. */ #if USE_PIXEL_DESCRIPTION QDockWidget* m_PixelDescriptionDock; #endif // USE_PIXEL_DESCRIPTION /** * \brief Histogram dock-widget. */ QDockWidget* m_HistogramDock; #ifdef OTB_USE_QT4 /** * \brief OTB-applications browser dock-widget. */ QDockWidget* m_OtbApplicationsBrowserDock; #endif /** * \brief Image-view page. */ ImageViewWidget* m_ImageView; /** * \brief Quicklook-view dock. */ QDockWidget* m_QuicklookViewDock; /** */ #if USE_TABBED_VIEW QTabWidget* m_CentralTabWidget; #endif // USE_TABBED_VIEW /** */ StatusBarWidget* m_StatusBarWidget; /** */ ShaderWidget * m_ShaderWidget; /** */ FilenameDragAndDropEventFilter* m_FilenameDragAndDropEventFilter; /** */ KeymapDialog * m_KeymapDialog; /** */ int m_GLSL140; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Private slots. private slots: /** * \brief Qt auto-connected slot which is called when Help/About * menu action is activated. */ void on_action_Keymap_triggered(); /** */ void on_action_LoadOTBApplications_triggered(); /** * \brief Qt auto-connected slot which is called when 'File/Open * image' menu action is triggered. */ void on_action_OpenImage_triggered(); /** * \brief Qt auto-connected slot which is called when * 'File/Preferences' menu action is trigerred. */ void on_action_Preferences_triggered(); /** */ void on_action_SaveScreenshot_triggered(); /** * \brief Qt auto-connected slot which is called when zoom-in button * is pressed. */ void on_action_ZoomIn_triggered(); /** * \brief Qt auto-connected slot which is called when zoom-out button * is pressed. */ void on_action_ZoomOut_triggered(); /** * \brief Qt auto-connected slot which is called when zoom-extent button * is pressed. */ void on_action_ZoomExtent_triggered(); /** * \brief Qt auto-connected slot which is called when zoom-full button * is pressed. */ void on_action_ZoomFull_triggered(); /** * \brief Qt auto-connected slot which is called when zoom-layer button * is pressed. */ void on_action_ZoomLayer_triggered(); /** */ void OnReferenceLayerCurrentIndexChanged( int ); /** */ void OnReferenceLayerChanged( size_t ); /** */ void OnSettingsUpdated(); /** */ void RefreshReferenceLayerComboBox(); /** */ void OnPixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdImageViewWidget.h" // // Some constants. namespace mvd { /*****************************************************************************/ inline const ImageViewWidget* MainWindow ::GetQuicklookView() const { return qobject_cast< const ImageViewWidget* >( m_QuicklookViewDock->widget() ); } /*****************************************************************************/ inline ImageViewWidget* MainWindow ::GetQuicklookView() { return qobject_cast< ImageViewWidget* >( m_QuicklookViewDock->widget() ); } } // end namespace 'mvd' #endif // mvdMainWindow_h OTB-release-5.8/Modules/Visualization/Monteverdi/include/mvdPreferencesDialog.h000066400000000000000000000071771301006202600277030ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdPreferencesDialog_h #define mvdPreferencesDialog_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" #include "OTBMonteverdiExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class PreferencesDialog; } /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class PreferencesDialog * * \ingroup OTBMonteverdi * */ class OTBMonteverdi_EXPORT PreferencesDialog : public QDialog { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** Constructor */ PreferencesDialog( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** Destructor */ ~PreferencesDialog() ITK_OVERRIDE; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /** */ Ui::PreferencesDialog* m_UI; bool m_ResultsDirModified: 1; bool m_GeoidFileModified: 1; bool m_SrtmDirModified: 1; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** * \brief Qt auto-connected slot which is called when datasetPathButton menu * action is pushed. */ void on_buttonBox_accepted(); void on_srtmCheckbox_toggled( bool ); void on_geoidCheckbox_toggled( bool ); void on_srtmButton_clicked(); void on_geoidButton_clicked(); void on_srtmLineEdit_textChanged( const QString & ); void on_geoidLineEdit_textChanged( const QString & ); void on_resultDirButton_clicked(); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdAboutDialog_h OTB-release-5.8/Modules/Visualization/Monteverdi/otb-module.cmake000066400000000000000000000004431301006202600250550ustar00rootroot00000000000000set( DOCUMENTATION "This module provides the Monteverdi program." ) otb_module( OTBMonteverdi ENABLE_SHARED DEPENDS OTBMonteverdiCore OTBMonteverdiGUI OTBQt4 OTBQtAdapters OPTIONAL_DEPENDS TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Visualization/Monteverdi/src/000077500000000000000000000000001301006202600225725ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Monteverdi/src/CMakeLists.txt000066400000000000000000000044441301006202600253400ustar00rootroot00000000000000set( OTBMonteverdi_SRCS mvdApplication.cxx mvdMainWindow.cxx mvdPreferencesDialog.cxx ) ############################################################################# set( OTBMonteverdi_HEADERS_MOC ../include/mvdApplication.h ../include/mvdMainWindow.h ../include/mvdPreferencesDialog.h ) ############################################################################# # Qt designer UI files set( OTBMonteverdi_FORMS mvdMainWindow.ui mvdPreferencesDialog.ui ) ############################################################################# set( OTBMonteverdi_RESOURCES mvdMainWindow.qrc ) ############################################################################# qt4_wrap_cpp( OTBMonteverdi_SRC_MOC ${OTBMonteverdi_HEADERS_MOC} ) qt4_wrap_ui( OTBMonteverdi_FORMS_HEADERS ${OTBMonteverdi_FORMS} ) qt4_add_resources( OTBMonteverdi_RESOURCES_RCC ${OTBMonteverdi_RESOURCES} ) ############################################################################# add_to_qt4_i18n_sources( ${OTBMonteverdi_SRCS} ) add_to_qt4_i18n_headers( "../include" ${OTBMonteverdi_SRCS} ) add_to_qt4_i18n_forms( ${OTBMonteverdi_FORMS} ) ############################################################################# add_library( OTBMonteverdi STATIC ${OTBMonteverdi_SRCS} ${OTBMonteverdi_FORMS_HEADERS} ${OTBMonteverdi_SRC_MOC} ) target_link_libraries( OTBMonteverdi ${OTBMonteverdiCore_LIBRARIES} ${OTBMonteverdiGUI_LIBRARIES} ${OTBQt4_LIBRARIES} ${OTBQtAdapters_LIBRARIES} ) otb_module_target( OTBMonteverdi ) #######################[ Monteverdi executable ]############################# if (WIN32) # Windows Resource file need to have the full path to icon # if the .ico is not in the current dir set( Monteverdi_App_WIN32_ICON ${OTB_SOURCE_DIR}/Utilities/Data/Icons/monteverdi.ico) configure_file( mvdWin32.rc.in mvdWin32.rc @ONLY ) if (MINGW) set(CMAKE_RC_COMPILE_OBJECT " -O coff -i -o ") endif() # The RC file to be added to source list set( Monteverdi_App_WIN32_RC_FILE ${CMAKE_CURRENT_BINARY_DIR}/mvdWin32.rc ) endif() add_executable( monteverdi main.cxx ${Monteverdi_App_WIN32_RC_FILE} ${OTBMonteverdi_RESOURCES_RCC} ) target_link_libraries( monteverdi OTBMonteverdi ) otb_module_target( monteverdi ) OTB-release-5.8/Modules/Visualization/Monteverdi/src/main.cxx000066400000000000000000000122641301006202600242470ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include #include #define USE_SPLASH_SCREEN ( ( !defined( OTB_DEBUG ) && 0 ) || 0 ) // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // #include "itksys/SystemTools.hxx" // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdApplication.h" #include "mvdMainWindow.h" enum ERROR_CODE { ERROR_CODE_I18N = -1, ERROR_CODE_CACHE_DIR = -2, ERROR_CODE_DATABASE = -3, ERROR_CODE_GL_VERSION = -4, ERROR_CODE_USAGE = -5, }; /*****************************************************************************/ /* FUNCTIONS DECLARATION */ /*****************************************************************************/ /* MAIN */ int main( int argc, char* argv[] ) { QApplication qtApp( argc, argv ); // // 0. Splash-screen. #if USE_SPLASH_SCREEN QPixmap pixmap(QLatin1String( ":/images/application_splash" )); QSplashScreen splash(pixmap); splash.show(); qtApp.processEvents();//This is used to accept a click on the screen so that user can cancel the screen #endif // // 0bis. Parse pre-initialization command-line arguments. QStringList args( qtApp.arguments() ); { for( QStringList::iterator it( args.begin() ); it!=args.end(); ) if( it->compare( "-h" )==0 || it->compare( "--help" )==0 ) { std::cout << mvd::ToLocalStdString( QCoreApplication::translate( PROJECT_NAME, "Usage: %1 [-h|--help] [-a|--applications] [...]\n" " -h, --help display this help message.\n" " -a, --applications load OTB-applications from OTB_APPLICATIONS_PATH." ) .arg( QFileInfo( argv[ 0 ] ).baseName() ) ) << std::endl; return ERROR_CODE_USAGE; } else { ++ it; } } // // 1. Initialize application and sync settings. // // Coverity-14835 // { mvd::Application * application = NULL; try { application = new mvd::Application( &qtApp ); assert( application!=NULL ); application->Initialize(); } catch( std::exception & exc ) { QMessageBox::StandardButton button = QMessageBox::question( NULL, QCoreApplication::translate( PROJECT_NAME, "Question!" ), QCoreApplication::translate( PROJECT_NAME, "The following exception has been caught while initializing the software:\n\n" "%1\n\n" "The application may not function as expected. Do you want to continue?" ) .arg( exc.what() ), QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes ); if( button==QMessageBox::No ) return ERROR_CODE_I18N; } // } // Coverity-14835 // // 2. Initialize main-window (UI). mvd::MainWindow mainWindow; mainWindow.Initialize(); // // 3. Show window. mainWindow.show(); #if USE_SPLASH_SCREEN splash.finish( &mainWindow ); #endif // USE_SPLASH_SCREEN // // 4. Check OpenGL capabilities if( !mainWindow.CheckGLCapabilities() ) return ERROR_CODE_GL_VERSION; // // 5. Parse command-line filenames. args.pop_front(); { bool otbApplications = false; for( QStringList::iterator it( args.begin() ); it!=args.end(); ) if( it->compare( "-a" )==0 || it->compare( "--applications" )==0 ) { if( !otbApplications ) { #if USE_OTB_APPS mainWindow.SetupOTBApplications(); #else // USE_OTB_APPS qWarning() << "OTB-applications support is not included in this build."; #endif // USE_OTB_APPS it = args.erase( it ); } } else { ++ it; } } mainWindow.ImportImages( args ); // // 6. Let's go: run the application and return exit code. int result = QCoreApplication::instance()->exec(); /* application->CloseDatabase(); */ // Coverity-14835 // { delete application; application = NULL; // } // Coverity-14835 return result; } /*****************************************************************************/ /* FUNCTIONS IMPLEMENTATION */ /*****************************************************************************/ OTB-release-5.8/Modules/Visualization/Monteverdi/src/mvdApplication.cxx000066400000000000000000000070271301006202600262760ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdApplication.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdStackedLayerModel.h" // #ifdef OTB_USE_QT4 # include "mvdOTBApplicationsModel.h" #endif // // Class implementation. namespace mvd { /* TRANSLATOR mvd::Application Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ Application ::Application( QApplication* qtApp ) : I18nApplication( qtApp ), m_OTBApplicationsModel( NULL ) { } /*******************************************************************************/ Application ::~Application() { } /*******************************************************************************/ /* CountType Application ::OpenDatabase() { DatabaseModel* databaseModel = new DatabaseModel( this ); DatabaseModel::BuildContext context; databaseModel->BuildModel( &context ); SetModel( databaseModel ); return context.m_NbOutdatedDatasetModels; } */ /*******************************************************************************/ /* void Application ::CloseDatabase() { // Delete model and release resources. SetModel( NULL ); } */ /*******************************************************************************/ void Application ::OpenApplicationsBrowser() { #ifdef OTB_USE_QT4 m_OTBApplicationsModel = new OTBApplicationsModel( this ); m_OTBApplicationsModel->BuildModel(); #endif } /*******************************************************************************/ void Application ::virtual_InitializeCore() { I18nApplication::virtual_InitializeCore(); setObjectName( "Application" ); InitializeCore( PROJECT_NAME, QString( "OTB %1" ).arg( OTB_VERSION_STRING ), "OrfeoToolBox", "orfeo-toolbox.org" ); // // Create the OTBApplications model OpenApplicationsBrowser(); } /*******************************************************************************/ /* SLOTS */ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/Monteverdi/src/mvdMainWindow.cxx000066400000000000000000001645251301006202600261160ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdMainWindow.h" #include "ui_mvdMainWindow.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include // // Monteverdi includes (sorted by alphabetic order) #if defined( OTB_USE_QT4 ) && USE_OTB_APPS # include "mvdApplicationLauncher.h" # include "mvdApplicationsToolBoxController.h" # include "mvdOTBApplicationsModel.h" # include "mvdQtWidgetView.h" #endif // // #include "mvdDatabaseModel.h" // #include "mvdDatasetModel.h" #include "mvdQuicklookModel.h" #include "mvdVectorImageModel.h" // #include "mvdApplicationsToolBox.h" #include "mvdColorSetupController.h" #include "mvdColorSetupWidget.h" #include "mvdColorDynamicsController.h" #include "mvdColorDynamicsWidget.h" // #include "mvdDatabaseBrowserController.h" #if ENABLE_TREE_WIDGET_TEST // #include "mvdDatabaseBrowserWidgetTest.h" #else // ENABLE_TREE_WIDGET_TEST // #include "mvdDatabaseBrowserWidget.h" #endif // ENABLE_TREE_WIDGET_TEST // #include "mvdDatasetPropertiesController.h" // #include "mvdDatasetPropertiesWidget.h" #include "mvdFilenameDragAndDropEventFilter.h" #include "mvdHistogramController.h" #include "mvdHistogramWidget.h" #include "mvdImageViewManipulator.h" #include "mvdImageViewRenderer.h" #include "mvdImageViewWidget.h" #include "mvdImportSubDatasetDialog.h" #include "mvdKeymapDialog.h" #include "mvdLayerStackController.h" #include "mvdLayerStackWidget.h" #if USE_PIXEL_DESCRIPTION # include "mvdPixelDescriptionWidget.h" #endif // USE_PIXEL_DESCRIPTION #include "mvdQuicklookViewManipulator.h" #include "mvdQuicklookViewRenderer.h" #include "mvdShaderWidget.h" #include "mvdStatusBarWidget.h" // #include "mvdApplication.h" #include "mvdPreferencesDialog.h" namespace mvd { /* TRANSLATOR mvd::MainWindow Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ #define REFERENCE_LAYER_COMBOBOX_NAME "referenceLayerComboBox" #define FORCE_NO_GLSL ( ( defined( OTB_DEBUG ) && 0 ) || 0 ) /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ MainWindow ::MainWindow( QWidget* p, Qt::WindowFlags flags ) : I18nMainWindow( p, flags ), m_UI( new mvd::Ui::MainWindow() ), m_ColorDynamicsDock( NULL ), m_ColorSetupDock( NULL ), // m_DatabaseBrowserDock( NULL ), // m_DatasetPropertiesDock(NULL), m_LayerStackDock( NULL ), #if USE_PIXEL_DESCRIPTION m_PixelDescriptionDock(NULL), #endif // USE_PIXEL_DESCRIPTION m_HistogramDock( NULL ), #if defined( OTB_USE_QT4 ) && USE_OTB_APPS m_OtbApplicationsBrowserDock(NULL), #endif m_ImageView( NULL ), m_QuicklookViewDock( NULL ), #if USE_TABBED_VIEW m_CentralTabWidget( NULL ), #endif // USE_TABBED_VIEW m_StatusBarWidget( NULL ), m_ShaderWidget( NULL ), m_FilenameDragAndDropEventFilter( NULL ), m_KeymapDialog( NULL ), m_GLSL140( -2 ) { m_UI->setupUi( this ); // // m_KeymapDialog = new KeymapDialog( this ); // // Event filters. m_FilenameDragAndDropEventFilter = new FilenameDragAndDropEventFilter( this ); QObject::connect( m_FilenameDragAndDropEventFilter, SIGNAL( FilenamesDropped( const QStringList & ) ), // to: this, SLOT( ImportImages( const QStringList & ) ) ); } /*****************************************************************************/ MainWindow ::~MainWindow() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ bool MainWindow ::CheckGLCapabilities() { assert( m_ImageView!=NULL ); assert( m_ImageView->GetRenderer()!=NULL ); // Coverity-19845 // // if( m_ImageView==NULL || // m_ImageView->GetRenderer()==NULL ) // return false; bool isGLSL = m_ImageView->GetRenderer()->CheckGLCapabilities( &m_GLSL140 ); #if FORCE_NO_GLSL m_ImageView->GetRenderer()->SetGLSLEnabled( false ); isGLSL = false; #endif // FORCE_NO_GLSL // MANTIS-1204 // { // // Forward GLSL state to quicklook view. assert( GetQuicklookView()!=NULL ); assert( GetQuicklookView()->GetRenderer()!=NULL ); GetQuicklookView()->GetRenderer()->SetGLSLEnabled( isGLSL ); // } assert( m_ShaderWidget!=NULL ); m_ShaderWidget->SetGLSLEnabled( isGLSL ); m_ShaderWidget->SetGLSL140Enabled( m_GLSL140>=0 ); assert( m_StatusBarWidget!=NULL ); m_StatusBarWidget->SetGLSLEnabled( isGLSL ); return true; } /*****************************************************************************/ void MainWindow ::virtual_SetupUI() { assert( m_UI!=NULL ); setObjectName( PROJECT_NAME ); #ifdef OTB_DEBUG setWindowTitle( PROJECT_NAME " (Debug)" ); #else // OTB_DEBUG setWindowTitle( PROJECT_NAME ); #endif // OTB_DEBUG InitializeCentralWidget(); InitializeDockWidgets(); InitializeStatusBarWidgets(); InitializeRenderToolBar(); InitializeShaderToolBar(); if( !RestoreLayout( Monteverdi_UI_VERSION ) ) { qWarning() << "Failed to restore window layout!"; } } /*****************************************************************************/ void MainWindow ::virtual_ConnectUI() { ConnectViewMenu(); // // CHAIN CONTROLLERS. // Forward model update signals of color-setup controller... QObject::connect( m_ColorSetupDock->findChild< AbstractModelController* >(), SIGNAL( RgbChannelIndexChanged( RgbwChannel, int ) ), // to: ...color-dynamics controller model update signal. m_ColorDynamicsDock->findChild< AbstractModelController* >(), SLOT( OnRgbChannelIndexChanged( RgbwChannel, int ) ) ); QObject::connect( m_ColorSetupDock->findChild< AbstractModelController* >(), SIGNAL( GrayChannelIndexChanged( int ) ), // to: ...color-dynamics controller model update signal. m_ColorDynamicsDock->findChild< AbstractModelController* >(), SLOT( OnGrayChannelIndexChanged( int ) ) ); QObject::connect( m_ColorSetupDock->findChild< AbstractModelController* >(), SIGNAL( GrayscaleActivated( bool ) ), // to: ...color-dynamics controller model update signal. m_ColorDynamicsDock->findChild< AbstractModelController* >(), SLOT( OnGrayscaleActivated( bool ) ) ); QObject::connect( m_ColorSetupDock->findChild< AbstractModelController* >(), SIGNAL( RgbChannelIndexChanged( RgbwChannel, int ) ), // to: ...color-dynamics controller model update signal. m_HistogramDock->findChild< AbstractModelController* >(), SLOT( OnRgbChannelIndexChanged( RgbwChannel, int ) ) ); QObject::connect( m_ColorSetupDock->findChild< AbstractModelController* >(), SIGNAL( GrayChannelIndexChanged( int ) ), // to: ...color-dynamics controller model update signal. m_HistogramDock->findChild< AbstractModelController* >(), SLOT( OnGrayChannelIndexChanged( int ) ) ); QObject::connect( m_ColorSetupDock->findChild< AbstractModelController* >(), SIGNAL( GrayscaleActivated( bool ) ), // to: ...color-dynamics controller model update signal. m_HistogramDock->findChild< AbstractModelController* >(), SLOT( OnGrayscaleActivated( bool ) ) ); QObject::connect( m_ColorDynamicsDock->findChild< AbstractModelController* >(), SIGNAL( LowIntensityChanged( RgbwChannel, double, bool ) ), // to: ...histogram controller model update signal. m_HistogramDock->findChild< AbstractModelController* >(), SLOT( OnLowIntensityChanged( RgbwChannel, double, bool ) ) ); QObject::connect( m_ColorDynamicsDock->findChild< AbstractModelController* >(), SIGNAL( HighIntensityChanged( RgbwChannel, double, bool ) ), // to: ...histogram controller model update signal. m_HistogramDock->findChild< AbstractModelController* >(), SLOT( OnHighIntensityChanged( RgbwChannel, double, bool ) ) ); QObject::connect( m_ColorDynamicsDock->findChild< AbstractModelController* >(), SIGNAL( HistogramRefreshed() ), // to: ...histogram controller model update signal. m_HistogramDock->findChild< AbstractModelController* >(), SLOT( OnHistogramRefreshed() ) ); // // close tabs handling #if USE_TABBED_VIEW QObject::connect( m_CentralTabWidget, SIGNAL( tabCloseRequested( int ) ), this, SLOT( OnTabCloseRequested( int ) ) ); #endif // USE_TABBED_VIEW // // Other connections. ConnectImageViews(); ConnectStatusBar(); // // When everything is connected, install event-filter. assert( m_ImageView!=NULL ); m_ImageView->installEventFilter( m_FilenameDragAndDropEventFilter ); { assert( GetController( m_LayerStackDock )!=NULL ); LayerStackWidget * layerStackWidget = GetController( m_LayerStackDock )->GetWidget< LayerStackWidget >(); assert( layerStackWidget!=NULL ); layerStackWidget->InstallEventFilter( m_FilenameDragAndDropEventFilter ); } } /*****************************************************************************/ void MainWindow ::ConnectImageViews() { assert( m_ImageView!=NULL ); QObject::connect( this, SIGNAL( UserZoomIn() ), // to: m_ImageView, SLOT( ZoomIn() ) ); QObject::connect( this, SIGNAL( UserZoomOut() ), // to: m_ImageView, SLOT( ZoomOut() ) ); QObject::connect( this, SIGNAL( UserZoomExtent() ), m_ImageView, SLOT( ZoomToExtent() ) ); QObject::connect( this, SIGNAL( UserZoomFull() ), m_ImageView, SLOT( ZoomToFullResolution() ) ); QObject::connect( this, SIGNAL( UserZoomLayer() ), m_ImageView, SLOT( ZoomToLayerExtent() ) ); // // Connect image-views for ROI-changed events. const AbstractImageViewManipulator* imageViewManipulator = m_ImageView->GetManipulator(); assert( imageViewManipulator!=NULL ); ImageViewWidget* quicklookView = GetQuicklookView(); assert( quicklookView!=NULL ); const AbstractImageViewManipulator* quicklookManipulator = quicklookView->GetManipulator(); assert( quicklookManipulator!=NULL ); QObject::connect( m_ImageView, SIGNAL( RoiChanged( const PointType &, const SizeType &, const SpacingType &, const PointType & ) ), // to: quicklookManipulator, SLOT( OnRoiChanged( const PointType &, const SizeType &, const SpacingType &, const PointType & ) ) ); QObject::connect( quicklookView, SIGNAL( CenterRoiRequested( const PointType& ) ), // to: imageViewManipulator, SLOT( CenterOn( const PointType& ) ) ); // Not needed anymore becaure already done in ImageViewWidget. // QObject::connect( // quicklookManipulator, // SIGNAL( RefreshViewRequested() ), // // to: // m_ImageView, // SLOT( updateGL() ) // ); // // Connect controllers to image-views. // { assert( m_LayerStackDock!=NULL ); AbstractModelController * controller = GetController( m_LayerStackDock ); assert( controller!=NULL ); QObject::connect( controller, SIGNAL( ApplyAllRequested() ), // to: m_ImageView, SLOT( OnApplyAllRequested() ) ); QObject::connect( controller, SIGNAL( ApplyAllRequested() ), // to: quicklookView, SLOT( OnApplyAllRequested() ) ); } } /*****************************************************************************/ void MainWindow ::ConnectViewMenu() { m_UI->menu_View->addAction( m_UI->m_ToolBar->toggleViewAction() ); m_UI->menu_View->addAction( m_UI->m_RenderToolBar->toggleViewAction() ); m_UI->menu_View->addAction( m_UI->m_ShaderToolBar->toggleViewAction() ); m_UI->menu_View->addSeparator(); m_UI->menu_View->addAction( m_ColorSetupDock->toggleViewAction() ); m_UI->menu_View->addAction( m_ColorDynamicsDock->toggleViewAction() ); m_UI->menu_View->addAction( m_HistogramDock->toggleViewAction() ); m_UI->menu_View->addAction( m_LayerStackDock->toggleViewAction() ); m_UI->menu_View->addAction( m_QuicklookViewDock->toggleViewAction() ); m_UI->menu_View->addSeparator(); m_UI->menu_View->addAction( m_UI->action_LoadOTBApplications ); #if USE_PIXEL_DESCRIPTION m_UI->menu_View->addAction( m_PixelDescriptionDock->toggleViewAction() ); #endif // USE_PIXEL_DESCRIPTION } /*****************************************************************************/ void MainWindow ::ConnectStatusBar() { assert( m_StatusBarWidget!=NULL ); assert( m_ImageView!=NULL ); QObject::connect( m_ImageView, SIGNAL( ScaleChanged( double, double ) ), // to: m_StatusBarWidget, SLOT( SetScale( double, double ) ) ); QObject::connect( m_StatusBarWidget, SIGNAL( ScaleChanged( double ) ), // to: m_ImageView->GetManipulator(), SLOT( ZoomTo( double ) ) ); QObject::connect( m_StatusBarWidget, SIGNAL( PixelIndexChanged( const IndexType& ) ), // to: m_ImageView, SLOT( CenterOnSelected( const IndexType& ) ) ); QObject::connect( m_ImageView, SIGNAL( PixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ) ), // to: this, SLOT( OnPixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ) ) ); } /*****************************************************************************/ #if USE_PIXEL_DESCRIPTION void MainWindow ::ConnectPixelDescriptionWidget( AbstractLayerModel * model ) { if( model==NULL || !model->inherits( VectorImageModel::staticMetaObject.className() ) ) return; // Access vector-image model. VectorImageModel * vectorImageModel = qobject_cast< VectorImageModel * >( model ); assert( vectorImageModel==qobject_cast< VectorImageModel * >( model ) ); assert( vectorImageModel!=NULL ); // // send the physical point of the clicked point in screen // vectorImageModel is in charge of pixel information computation QObject::connect( m_ImageView, SIGNAL( PhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType & ) ), // to: vectorImageModel, SLOT( OnPhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType& ) ) ); QObject::connect( GetQuicklookView(), SIGNAL( PhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType& ) ), // to: vectorImageModel, SLOT( OnPhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType& ) ) ); // get the PixelDescription widget // TODO: Make a widget controller! PixelDescriptionWidget * pixelDescriptionWidget = qobject_cast< PixelDescriptionWidget * >( m_PixelDescriptionDock->findChild< PixelDescriptionWidget * >() ); assert( pixelDescriptionWidget!=NULL ); QObject::connect( vectorImageModel, SIGNAL( CurrentPhysicalUpdated( const QStringList & ) ), // to: pixelDescriptionWidget, SLOT( OnCurrentPhysicalUpdated( const QStringList & ) ) ); QObject::connect( vectorImageModel, SIGNAL( CurrentGeographicUpdated( const QStringList & ) ), // to: pixelDescriptionWidget, SLOT( OnCurrentGeographicUpdated( const QStringList & ) ) ); QObject::connect( vectorImageModel, SIGNAL( CurrentPixelValueUpdated(const VectorImageType::PixelType &, const QStringList & ) ), // to: pixelDescriptionWidget, SLOT( OnCurrentPixelValueUpdated(const VectorImageType::PixelType &, const QStringList & ) ) ); } #endif // USE_PIXEL_DESCRIPTION /*****************************************************************************/ #if USE_PIXEL_DESCRIPTION void MainWindow ::DisconnectPixelDescriptionWidget( const AbstractLayerModel * model ) { if( model==NULL || !model->inherits( VectorImageModel::staticMetaObject.className() ) ) return; // Access vector-image model. const VectorImageModel * vectorImageModel = qobject_cast< const VectorImageModel * >( model ); assert( vectorImageModel==qobject_cast< const VectorImageModel * >( model ) ); assert( vectorImageModel!=NULL ); // // send the physical point of the clicked point in screen // vectorImageModel is in charge of pixel information computation QObject::disconnect( m_ImageView, SIGNAL( PhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType & ) ), // to: vectorImageModel, SLOT( OnPhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType & ) ) ); QObject::disconnect( GetQuicklookView(), SIGNAL( PhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType & ) ), // to: vectorImageModel, SLOT( OnPhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType& ) ) ); // get the PixelDescription widget // TODO: Make a widget controller! PixelDescriptionWidget * pixelDescriptionWidget = qobject_cast< PixelDescriptionWidget * >( m_PixelDescriptionDock->findChild< PixelDescriptionWidget * >() ); assert( pixelDescriptionWidget!=NULL ); QObject::disconnect( vectorImageModel, SIGNAL( CurrentPhysicalUpdated( const QStringList & ) ), // to: pixelDescriptionWidget, SLOT( OnCurrentPhysicalUpdated( const QStringList & ) ) ); QObject::disconnect( vectorImageModel, SIGNAL( CurrentGeographicUpdated( const QStringList & ) ), // to: pixelDescriptionWidget, SLOT( OnCurrentGeographicUpdated( const QStringList & ) ) ); QObject::connect( vectorImageModel, SIGNAL( CurrentPixelValueUpdated( const VectorImageType::PixelType &, const QStringList & ) ), // to: pixelDescriptionWidget, SLOT( OnCurrentPixelValueUpdated( const VectorImageType::PixelType &, const QStringList & ) ) ); } #endif // USE_PIXEL_DESCRIPTION /*****************************************************************************/ void MainWindow ::InitializeDockWidgets() { #define ENABLE_QTOOLBAR_TEST 0 #if ENABLE_QTOOLBAR_TEST // XP: QToolBar test. QDockWidget* dock = AddWidgetToDock( m_UI->m_ToolBar, "TOOL_BAR", tr( "Tool bar" ), Qt::TopDockWidgetArea ); m_UI->menu_View->addAction( dock->toggleViewAction() ); #endif // // Left pane. // // Right pane. // Quicklook-view dock-widget assert( m_QuicklookViewDock==NULL ); assert( m_ImageView!=NULL ); m_QuicklookViewDock = AddWidgetToDock( CreateQuicklookViewWidget( m_ImageView ), "QUICKLOOK_VIEW", tr( "Quicklook view" ), Qt::RightDockWidgetArea ); // Histogram-view. assert( m_HistogramDock==NULL ); m_HistogramDock = AddDockWidget < HistogramWidget, HistogramController, QDockWidget > ( "HISTOGRAM", tr( "Histogram" ), Qt::RightDockWidgetArea ); tabifyDockWidget( m_QuicklookViewDock, m_HistogramDock ); #if USE_PIXEL_DESCRIPTION // Pixel Description (no controller needed here / direct update of // the pixel description through signals from VectorImageModel) assert( m_PixelDescriptionDock==NULL ); m_PixelDescriptionDock = AddDockWidget < PixelDescriptionWidget, QDockWidget > ( "CURRENT_PIXEL_DESCRIPTION", tr( "Pixel Description" ), Qt::RightDockWidgetArea ); tabifyDockWidget( m_PixelDescriptionDock, m_HistogramDock ); #endif // USE_PIXEL_DESCRIPTION // Color-setup. assert( m_ColorSetupDock==NULL ); m_ColorSetupDock = AddDockWidget < ColorSetupWidget, ColorSetupController, QDockWidget > ( "COLOR_SETUP", tr( "Color setup" ), Qt::RightDockWidgetArea ); // Color-dynamics. assert( m_ColorDynamicsDock==NULL ); m_ColorDynamicsDock = AddDockWidget < ColorDynamicsWidget, ColorDynamicsController, QDockWidget > ( "COLOR_DYNAMICS", tr( "Color dynamics" ), Qt::RightDockWidgetArea, I18nMainWindow::DOCK_LAYOUT_SCROLLABLE ); // Tabify dock-widgets. tabifyDockWidget( m_ColorSetupDock, m_ColorDynamicsDock ); // // Bottom pane // // Layer-stack editor. assert( m_LayerStackDock==NULL ); m_LayerStackDock = AddDockWidget< LayerStackWidget, LayerStackController, QDockWidget >( "LAYER_STACK", tr( "Layer stack" ), Qt::BottomDockWidgetArea ); } /*****************************************************************************/ void MainWindow ::InitializeCentralWidget() { #if USE_TABBED_VIEW // Create central tab-widget for multi-view support. assert( m_CentralTabWidget==NULL ); m_CentralTabWidget = new QTabWidget( this ); // Customize it. m_CentralTabWidget->setTabsClosable( true ); // Set-it up as central widget. setCentralWidget( m_CentralTabWidget ); // // access to the quicklook tabBar to remove the close button QTabBar* tabBar = m_CentralTabWidget->findChild< QTabBar* >(); #endif // USE_TABBED_VIEW // Initialize image-view. assert( m_ImageView==NULL ); m_ImageView = CreateImageViewWidget(); #if USE_TABBED_VIEW // Add first tab: image-view. int index = m_CentralTabWidget->addTab( m_ImageView, tr( "Image view" ) ); tabBar->setTabButton( index, QTabBar::RightSide, 0); tabBar->setTabButton( index, QTabBar::LeftSide, 0); #else // USE_TABBED_VIEW setCentralWidget( m_ImageView ); #endif // USE_TABBED_VIEW } /*****************************************************************************/ void MainWindow ::InitializeRenderToolBar() { m_UI->m_RenderToolBar->addSeparator(); { m_UI->m_RenderToolBar->addWidget( new QLabel( tr( "Proj" ) ) ); QComboBox * comboBox = new QComboBox( m_UI->m_RenderToolBar ); comboBox->setToolTip( tr( "Select projection used as reference for the view." ) ); assert( comboBox!=NULL ); comboBox->setObjectName( "referenceLayerComboBox" ); comboBox->setMinimumSize( QSize( #ifdef OTB_DEBUG 116, #else 128, #endif 0 ) ); m_UI->m_RenderToolBar->addWidget( comboBox ); } } /*****************************************************************************/ void MainWindow ::InitializeShaderToolBar() { assert( m_ShaderWidget==NULL ); { m_UI->m_ShaderToolBar->addWidget( new QLabel( tr( "Layer FX" ) ) ); m_ShaderWidget = new ShaderWidget( m_UI->m_ShaderToolBar ); m_UI->m_ShaderToolBar->addWidget( m_ShaderWidget ); } } /*****************************************************************************/ void MainWindow ::InitializeStatusBarWidgets() { // MANTIS- assert( m_StatusBarWidget==NULL ); m_StatusBarWidget = new StatusBarWidget( statusBar() ); statusBar()->addPermanentWidget( m_StatusBarWidget, 1 ); m_StatusBarWidget->setEnabled( false ); } /*****************************************************************************/ ImageViewWidget* MainWindow ::CreateImageViewWidget( QGLWidget* sharedGlWidget ) { ImageViewRenderer* renderer = new ImageViewRenderer( this ); ImageViewManipulator* manipulator = new ImageViewManipulator( #if USE_VIEW_SETTINGS_SIDE_EFFECT renderer->GetViewSettings(), #endif // USE_VIEW_SETTINGS_SIDE_EFFECT this ); ImageViewWidget* imageView = new ImageViewWidget( manipulator, // (will be reparented.) renderer, // (will be reparented.) this, sharedGlWidget ); imageView->setMinimumWidth( 256 ); return imageView; } /*****************************************************************************/ ImageViewWidget* MainWindow ::CreateQuicklookViewWidget( QGLWidget* sharedGlWidget ) { QuicklookViewRenderer* renderer = new QuicklookViewRenderer( this ); QuicklookViewManipulator* manipulator = new QuicklookViewManipulator( #if USE_VIEW_SETTINGS_SIDE_EFFECT renderer->GetViewSettings(), #endif // USE_VIEW_SETTINGS_SIDE_EFFECT this ); ImageViewWidget* quicklookView = new ImageViewWidget( manipulator, // (will be reparented.) renderer, // (will be reparented.) this, sharedGlWidget ); quicklookView->SetPickingEnabled( false ); quicklookView->SetPickingDefaultStatus( false ); quicklookView->setMinimumSize( 64, 64 ); quicklookView->setMaximumSize( 512, 512 ); quicklookView->setSizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum ); return quicklookView; } /*****************************************************************************/ CountType MainWindow ::ImportImage( const QString& filename, StackedLayerModel::SizeType index ) { // qDebug() << this << "::ImportImage(" << filename << "," << index << ")"; // // Get stacked-layer. assert( Application::Instance() ); assert( Application::Instance()->GetModel()== Application::Instance()->GetModel< StackedLayerModel >() ); StackedLayerModel* stackedLayerModel = Application::Instance()->GetModel< StackedLayerModel >(); assert( stackedLayerModel!=NULL ); // // CDS import { ImportSubDatasetDialog * importDialog = new ImportSubDatasetDialog( filename, this ); assert( importDialog!=NULL ); if( importDialog->HasSubDatasets() ) { if( importDialog->exec()==QDialog::Rejected ) { delete importDialog; return 0; } IntVector::size_type count = 0; IntVector indices; importDialog->GetSubDatasets( indices ); for( IntVector::size_type i=0; iCountSRT( unk, gcs, gcs, gcs ); // // // Coverity-112757 // { SpatialReferenceType srt = SRT_UNKNOWN; try { // qDebug() // << this << "\n" // << "\tQString:" << filename; // std::cout // << "\tstd::string: " << QFile::encodeName( filename ).constData() // << std::endl; srt = GetSpatialReferenceType( QFile::encodeName( filename ).constData() ); } catch( const std::exception & exception ) { QMessageBox::warning( this, "Warning!", tr( "Exception caught while checking Spatial Reference Type of image-file '%1':\n\n%2" ) .arg( filename ) .arg( exception.what() ) ); } // } // Coverity-112757. QMessageBox::StandardButton button = QMessageBox::NoButton; if( unk==0 && gcs>0 && srt==SRT_UNKNOWN ) { button = QMessageBox::warning( this, tr( "Warning!" ), tr( "No projection information (geographical or cartographical coordinate-system or sensor model) has been found for image. While already loaded images all have some, they are displayed in a geo-referenced view.\n\nLoading '%1' will cause the display to switch to a non geo-referenced view (where images are displayed relatively regarding their origin and spacing)." ) .arg( filename ), QMessageBox::Ok | QMessageBox::Cancel ); } if( button==QMessageBox::Cancel ) return 0; /* switch( button ) { case QMessageBox::Cancel: return; break; case QMessageBox::Ok: // Disable reference-layer combo-box. // Disable layer-stack projection-button. break; default: assert( false && "Unhandled QMessageBox::StandardButton value!" ); break; } */ // // Import image file. VectorImageModel * imageModel = ImportImage( filename, -1, -1 ); if( imageModel==NULL ) return 0; // // Bypass rendering of image-views. assert( m_ImageView!=NULL ); bool bypassImageView = m_ImageView->SetBypassRenderingEnabled( true ); ImageViewWidget * quicklookView = GetQuicklookView(); assert( quicklookView!=NULL ); bool bypassQuicklookView = quicklookView->SetBypassRenderingEnabled( true ); // // Block some signals. // // BUGFIX: MANTIS-1120 // { assert( m_UI!=NULL ); assert( m_UI->m_RenderToolBar!=NULL ); QComboBox * referenceLayerComboBox = m_UI->m_RenderToolBar->findChild< QComboBox * >( REFERENCE_LAYER_COMBOBOX_NAME ); assert( referenceLayerComboBox!=NULL ); bool blocked = referenceLayerComboBox->blockSignals( true ); // } // // Store image-mode in layer-stack. stackedLayerModel->Insert( imageModel, index ); imageModel->setParent( stackedLayerModel ); stackedLayerModel->SetCurrent( imageModel ); if( gcs==0 ) { if( unk==0 ) { if( srt!=SRT_UNKNOWN ) stackedLayerModel->SetReference( imageModel ); UserZoomExtent(); } } else if( unk==0 && srt==SRT_UNKNOWN ) stackedLayerModel->SetReference( StackedLayerModel::NIL_INDEX ); // // Re-activate rendering of image-views. m_ImageView->SetBypassRenderingEnabled( bypassImageView ); quicklookView->SetBypassRenderingEnabled( bypassQuicklookView ); // // Un-block some signals. // // BUGFIX: MANTIS-1120 // { referenceLayerComboBox->blockSignals( blocked ); // } // return 1; } /*****************************************************************************/ void MainWindow ::ImportImages( const QStringList & filenames ) { if( filenames.isEmpty() ) return; assert( I18nCoreApplication::Instance()!=NULL ); { QVariant value( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_OVERVIEWS_ENABLED ) ); if( !( value.isValid() ? value.toBool() : OVERVIEWS_ENABLED_DEFAULT ) || !BuildGDALOverviews( filenames ) ) return; } if( filenames.count()==1 ) ImportImage( filenames.front(), 0 ); else { StackedLayerModel::SizeType i = 0; for( QStringList::const_iterator it( filenames.constBegin() ); it!=filenames.end(); ++it ) { ImportImage( *it, i ++ ); } } assert( m_ImageView!=NULL ); m_ImageView->updateGL(); ImageViewWidget * quicklookView = GetQuicklookView(); assert( quicklookView!=NULL ); quicklookView->updateGL(); } /*****************************************************************************/ void MainWindow ::closeEvent( QCloseEvent * e ) { assert( e!=NULL ); { // // List OTB-application widgets. typedef QList< mvd::Wrapper::QtWidgetView * > QtWidgetViewList; QtWidgetViewList c( findChildren< mvd::Wrapper::QtWidgetView * >() ); QStringList names; // // Find out which OTB-applications are running. for( QtWidgetViewList::iterator it( c.begin() ); it!=c.end(); ++ it ) { assert( *it ); if( !( *it )->IsClosable() ) { assert( !( *it )->GetApplication().IsNull() ); // qDebug() << "OTB-application:" << ( *it )->GetApplication()->GetDocName(); names.push_back( ( *it )->GetApplication()->GetDocName() ); } } // // If some OTB-application is running, display warning, names and // prevent to close. if( !names.isEmpty() ) { QMessageBox::warning( this, tr( "Warning!" ), tr( PROJECT_NAME " cannot exit while some OTB-application is running!\n\n" "Please wait for following OTB-applicatio(s) to exit:\n- %1" ) .arg( names.join( "\n- " ) ) ); e->ignore(); return; } } { assert( I18nCoreApplication::Instance()!=NULL ); assert( I18nCoreApplication::Instance()->GetModel()== I18nCoreApplication::Instance()->GetModel< StackedLayerModel >() ); StackedLayerModel * stackedLayerModel = I18nCoreApplication::Instance()->GetModel< StackedLayerModel >(); if( stackedLayerModel!=NULL && !stackedLayerModel->IsEmpty() ) { QMessageBox::StandardButton button = QMessageBox::question( this, PROJECT_NAME, tr( "Some files have been loaded. Are you sure you want to quit?" ), QMessageBox::Yes | QMessageBox::No ); if( button==QMessageBox::No ) { e->ignore(); return; } } } SaveLayout( Monteverdi_UI_VERSION ); // // Otherwise, close. I18nMainWindow::closeEvent( e ); } /*****************************************************************************/ void MainWindow ::virtual_InitializeUI() { assert( Application::Instance() ); Application::Instance()->SetModel( new StackedLayerModel() ); } /*****************************************************************************/ void MainWindow ::ConnectReferenceLayerComboBox( StackedLayerModel * model ) { assert( model!=NULL ); QComboBox * comboBox = m_UI->m_RenderToolBar->findChild< QComboBox * >( REFERENCE_LAYER_COMBOBOX_NAME ); assert( comboBox!=NULL ); QObject::connect( comboBox, SIGNAL( currentIndexChanged( int ) ), // to: this, SLOT( OnReferenceLayerCurrentIndexChanged( int ) ) ); QObject::connect( model, SIGNAL( ContentChanged() ), // to: this, SLOT( RefreshReferenceLayerComboBox() ) ); QObject::connect( model, SIGNAL( ContentReset() ), // to: this, SLOT( RefreshReferenceLayerComboBox() ) ); QObject::connect( model, SIGNAL( OrderChanged() ), // to: this, SLOT( RefreshReferenceLayerComboBox() ) ); QObject::connect( model, SIGNAL( ReferenceChanged( size_t ) ), // to: this, SLOT( OnReferenceLayerChanged( size_t ) ) ); } /*****************************************************************************/ void MainWindow ::SetupReferenceLayerComboBox( StackedLayerModel * model ) { QComboBox * comboBox = m_UI->m_RenderToolBar->findChild< QComboBox * >( REFERENCE_LAYER_COMBOBOX_NAME ); assert( comboBox!=NULL ); bool blocked = comboBox->blockSignals( true ); { comboBox->clear(); comboBox->addItem( "None" ); } comboBox->blockSignals( blocked ); if( model==NULL ) return; for( StackedLayerModel::SizeType i=0; iGetCount(); ++i ) { AbstractLayerModel * layer = model->At( i ); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { const VectorImageModel * vectorImageModel = qobject_cast< const VectorImageModel * >( layer ); assert( vectorImageModel!=NULL ); comboBox->addItem( QString( "%1 (%2)" ) .arg( layer->GetAuthorityCode( true ).c_str() ) .arg( QFileInfo( vectorImageModel->GetFilename() ).fileName() ) ); } else qDebug() << "Unhandled AbstractLayerModel subclass."; } { size_t gcs = 0; // Geo/Carto/Sensor size_t unk = 0; // Unknown model->CountSRT( unk, gcs, gcs, gcs ); comboBox->setEnabled( model->GetCount()>0 && unk==0 ); } comboBox->setCurrentIndex( model->GetReferenceIndex()>=model->GetCount() ? 0 // comboBox->count() - 1 : model->GetReferenceIndex() + 1 ); } /*****************************************************************************/ void MainWindow ::DisconnectReferenceLayerComboBox( StackedLayerModel * model ) { QComboBox * comboBox = m_UI->m_RenderToolBar->findChild< QComboBox * >( REFERENCE_LAYER_COMBOBOX_NAME ); assert( comboBox!=NULL ); QObject::disconnect( comboBox, SIGNAL( currentIndexChanged( int ) ), // to: this, SLOT( OnReferenceLayerCurrentIndexChanged( int ) ) ); if( model!=NULL ) { QObject::disconnect( model, SIGNAL( ContentChanged() ), // to: this, SLOT( RefreshReferenceLayerComboBox() ) ); QObject::disconnect( model, SIGNAL( ContentReset() ), // to: this, SLOT( RefreshReferenceLayerComboBox() ) ); QObject::disconnect( model, SIGNAL( OrderChanged() ), // to: this, SLOT( RefreshReferenceLayerComboBox() ) ); QObject::disconnect( model, SIGNAL( ReferenceChanged( size_t ) ), // to: this, SLOT( OnReferenceLayerChanged( size_t ) ) ); } comboBox->clear(); comboBox->setEnabled( false ); } /****************************************************************************/ #if USE_OTB_APPS void MainWindow ::SetupOTBApplications() { // qDebug() << this << "::SetupOTBApplications()"; // qDebug() << "{"; assert( m_OtbApplicationsBrowserDock==NULL ); // // Load OTB-applications and create browser in dock-widget . m_OtbApplicationsBrowserDock = AddDockWidget < ApplicationsToolBox, ApplicationsToolBoxController, QDockWidget > ( "APPLICATIONS_BROWSER", tr( "OTB-Applications browser" ), Qt::RightDockWidgetArea ); tabifyDockWidget( m_HistogramDock, m_OtbApplicationsBrowserDock ); SetControllerModel( m_OtbApplicationsBrowserDock, Application::Instance()->GetOTBApplicationsModel() ); // // Connect signals. // // need to get the ApplicationToolBox widget to setup connections. // a double click on the tree widget should trigger a signal connected // to this MainWindow slot. this slot will be in charge of getting the // widget of the application selected, and show it in the // MainWindow centralView. // # Step 1 : get the ApplicationToolBoxWidget ApplicationsToolBox* appWidget = qobject_cast< ApplicationsToolBox * >( m_OtbApplicationsBrowserDock->findChild< ApplicationsToolBox* >() ); assert( appWidget!=NULL ); // # Step 2 : setup connections QObject::connect( appWidget, SIGNAL( ApplicationToLaunchSelected(const QString &, const QString &) ), this, SLOT( OnApplicationToLaunchSelected(const QString &, const QString &) ) ); // # Step 3 : connect close slots // TODO // // Update main-window UI. m_UI->action_LoadOTBApplications->setEnabled( false ); m_UI->action_LoadOTBApplications->setVisible( false ); m_UI->menu_View->addAction( m_OtbApplicationsBrowserDock->toggleViewAction() ); // qDebug() << "}"; } #endif // USE_OTB_APPS /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void MainWindow ::on_action_Keymap_triggered() { assert( m_KeymapDialog!=NULL ); if( m_KeymapDialog->isVisible() ) return; m_KeymapDialog->show(); } /****************************************************************************/ void MainWindow ::on_action_LoadOTBApplications_triggered() { #if USE_OTB_APPS SetupOTBApplications(); #endif // USE_OTB_APPS } /*****************************************************************************/ void MainWindow ::on_action_OpenImage_triggered() { // // Select filename. ImportImages( otb::GetOpenFileNames( this, tr( "Open file..." ) ) ); } /*****************************************************************************/ void MainWindow ::on_action_Preferences_triggered() { PreferencesDialog prefDialog( this ); prefDialog.exec(); } /*****************************************************************************/ void MainWindow ::on_action_SaveScreenshot_triggered() { assert( m_ImageView!=NULL ); m_ImageView->SaveScreenshot( false ); } /*****************************************************************************/ void MainWindow ::on_action_ZoomIn_triggered() { emit UserZoomIn(); } /*****************************************************************************/ void MainWindow ::on_action_ZoomOut_triggered() { emit UserZoomOut(); } /*****************************************************************************/ void MainWindow ::on_action_ZoomExtent_triggered() { emit UserZoomExtent(); } /*****************************************************************************/ void MainWindow ::on_action_ZoomFull_triggered() { emit UserZoomFull(); } /*****************************************************************************/ void MainWindow ::on_action_ZoomLayer_triggered() { emit UserZoomLayer(); } /*****************************************************************************/ void MainWindow ::OnAboutToChangeModel( const AbstractModel * ) { // qDebug() << this << "::OnAboutToChangeModel(" << model << ")"; // Force to disconnect previously selected layer-model before // stacked-layer model is disconnected. // // If there was no previously set layer-model, this will cause GUI // views to be disabled. // // N.B.: This will cause UI controllers to disable widgets. OnAboutToChangeSelectedLayerModel( StackedLayerModel::KeyType() ); // Assign stacked-layer model controller. SetControllerModel( m_LayerStackDock, NULL ); assert( Application::Instance() ); assert( Application::Instance()->GetModel()== Application::Instance()->GetModel< StackedLayerModel >() ); StackedLayerModel * stackedLayerModel = Application::Instance()->GetModel< StackedLayerModel >(); DisconnectReferenceLayerComboBox( stackedLayerModel ); // Exit, if there were no previously set database model. if( stackedLayerModel==NULL ) return; // Disonnect stacked-layer model from main-window when selected // layer-model is about to change. QObject::disconnect( stackedLayerModel, SIGNAL( AboutToChangeSelectedLayerModel( const StackedLayerModel::KeyType & ) ), // from: this, SLOT( OnAboutToChangeSelectedLayerModel( const StackedLayerModel::KeyType & ) ) ); // Disconnect stacked-layer model to main-window when selected // layer-model has been changed. QObject::disconnect( stackedLayerModel, SIGNAL( SelectedLayerModelChanged( const StackedLayerModel::KeyType & ) ), // from: this, SLOT( OnSelectedLayerModelChanged( const StackedLayerModel:KeyType & ) ) ); } /*****************************************************************************/ void MainWindow ::OnModelChanged( AbstractModel * model ) { // qDebug() << this << "::OnModelChanged(" << model << ")"; assert( model==qobject_cast< StackedLayerModel * >( model ) ); StackedLayerModel * stackedLayerModel = qobject_cast< StackedLayerModel * >( model ); SetupReferenceLayerComboBox( stackedLayerModel ); ConnectReferenceLayerComboBox( stackedLayerModel ); // Assign stacked-layer model controller. SetControllerModel( m_LayerStackDock, model ); #if !RENDER_IMAGE_VIEW_DISABLED m_ImageView->SetLayerStack( stackedLayerModel ); #endif #if !RENDER_QUICKLOOK_VIEW_DISABLED assert( GetQuicklookView()!=NULL ); GetQuicklookView()->SetLayerStack( stackedLayerModel ); #endif if( stackedLayerModel==NULL ) return; // Connect stacked-layer model to main-window when selected layer-model // is about to change. QObject::connect( stackedLayerModel, SIGNAL( AboutToChangeSelectedLayerModel( const StackedLayerModel::KeyType & ) ), // to: this, SLOT( OnAboutToChangeSelectedLayerModel( const StackedLayerModel::KeyType & ) ) ); // Connect stacked-layer -model to main-window when selected layer-model // has been changed. QObject::connect( stackedLayerModel, SIGNAL( SelectedLayerModelChanged( const StackedLayerModel::KeyType & ) ), // to: this, SLOT( OnSelectedLayerModelChanged( const StackedLayerModel::KeyType & ) ) ); // Force to connect selected layer-model after stacked-layer model // is connected. // // N.B.: This will cause UI controllers to disable widgets. OnSelectedLayerModelChanged( stackedLayerModel->GetCurrentKey() ); } /*****************************************************************************/ void MainWindow ::OnAboutToChangeSelectedLayerModel( const StackedLayerModel::KeyType & ) { // qDebug() // << this // << "::OnAboutToChangeSelectedDatasetModel(" << FromStdString( key ) << ")"; // // CONTROLLERS. // // // Unset model from controllers. // // N.B.: This step must be done *before* disconnecting signals & // slots between model(s) and view(s). // // See also, ::OnSelectedLayerModel() changed. // Unset image-model from color-dynamics controller. SetControllerModel( m_ColorDynamicsDock, NULL ); // Unset image-model from color-setup controller. SetControllerModel( m_ColorSetupDock, NULL ); // Unset histogram-model from histogram controller. SetControllerModel( m_HistogramDock, NULL ); // Unset stacked-layer model from stacked-layer controller. // SetControllerModel( m_StackedLayerDock, NULL ); // // VIEWS. // // // MODEL(s). // assert( Application::Instance() ); assert( Application::Instance()->GetModel()== Application::Instance()->GetModel< StackedLayerModel >() ); const StackedLayerModel * stackedLayerModel = Application::Instance()->GetModel< StackedLayerModel >(); if( !stackedLayerModel ) return; const AbstractLayerModel * layerModel = stackedLayerModel->GetCurrent(); if( !layerModel ) return; if( layerModel->inherits( VectorImageModel::staticMetaObject.className() ) ) { m_ShaderWidget->SetSettings( NULL ); // Disconnect previously selected image-model from view. QObject::disconnect( layerModel, SIGNAL( SettingsUpdated() ), // from: this, SLOT( OnSettingsUpdated() ) ); // // Disconnect shader-widget from model-updated slot. QObject::disconnect( m_ShaderWidget, SIGNAL( SettingsChanged() ), // from: layerModel, SLOT( OnModelUpdated() ) ); } else { assert( false && "Unhandled AbstractLayerModel derived-type." ); } #if USE_PIXEL_DESCRIPTION DisconnectPixelDescriptionWidget( layerModel ); #endif // USE_PIXEL_DESCRIPTION } /*****************************************************************************/ void MainWindow ::OnSelectedLayerModelChanged( const StackedLayerModel::KeyType & key ) { // qDebug() // << this << "::OnLayerModelChanged( " << FromStdString( key ) << ")"; assert( Application::Instance() ); assert( Application::Instance()->GetModel()== Application::Instance()->GetModel< StackedLayerModel >() ); StackedLayerModel * stackedLayerModel = Application::Instance()->GetModel< StackedLayerModel >(); assert( stackedLayerModel==Application::Instance()->GetModel() ); if( stackedLayerModel==NULL ) return; // // VIEWS. // // // MODEL(s). // AbstractLayerModel * layerModel = stackedLayerModel->Get( key ); assert( m_StatusBarWidget!=NULL ); if( !layerModel ) { m_StatusBarWidget->setEnabled( false ); return; } m_StatusBarWidget->setEnabled( true ); if( layerModel->inherits( VectorImageModel::staticMetaObject.className() ) ) { // // SAT: Using m_TabWidget->index( 0 ) or m_ImageView is equivalent // since Qt may use signal & slot names to connect (see MOC .cxx // files). Thus, using m_ImageView saves one indirection call. QObject::connect( layerModel, SIGNAL( SettingsUpdated() ), // to: this, SLOT( OnSettingsUpdated() ) ); // // Connect shader-widget to model-updated slot. QObject::connect( m_ShaderWidget, SIGNAL( SettingsChanged() ), // to: layerModel, SLOT( OnModelUpdated() ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layerModel ); assert( imageModel!=NULL ); setWindowTitle( #ifdef OTB_DEBUG QString( PROJECT_NAME " (Debug) - %1" ) #else // OTB_DEBUG QString( PROJECT_NAME " - %1" ) #endif // OTB_DEBUG .arg( QFileInfo( imageModel->GetFilename() ).fileName() ) ); m_ShaderWidget->SetSettings( &imageModel->GetSettings() ); } else { assert( false && "Unhandled AbstractLayerModel derived-type." ); } #if USE_PIXEL_DESCRIPTION ConnectPixelDescriptionWidget( layerModel ); #endif // USE_PIXEL_DESCRIPTION // // CONTROLLERS. // // // Connect image-model controllers. // // N.B.: This step *must* be done after signals and slots between // model(s) and view(s) have been connected (because when model is // assigned to controller, widgets/view are reset and emit // refreshing signals). // // See also: OnAboutToChangeLayerModel(). // Assign dataset-model to dataset-properties controller. // Assign image-model to color-dynamics controller. SetControllerModel( m_ColorDynamicsDock, layerModel ); // Assign image-model to color-setup controller. SetControllerModel( m_ColorSetupDock, layerModel ); // Assign histogram-model to histogram controller. SetControllerModel( m_HistogramDock, layerModel ); // // TOOLBAR. // m_UI->action_ZoomIn->setEnabled( layerModel!=NULL ); m_UI->action_ZoomOut->setEnabled( layerModel!=NULL ); m_UI->action_ZoomExtent->setEnabled( layerModel!=NULL ); m_UI->action_ZoomFull->setEnabled( layerModel!=NULL ); m_UI->action_ZoomLayer->setEnabled( layerModel!=NULL ); } /*****************************************************************************/ #if defined( OTB_USE_QT4 ) && USE_OTB_APPS void MainWindow ::OnApplicationToLaunchSelected( const QString & appName, const QString & /**docName*/ ) { assert( Application::ConstInstance()!=NULL ); assert( Application::ConstInstance()->GetOTBApplicationsModel()!=NULL ); assert( Application::ConstInstance()->GetOTBApplicationsModel()->GetLauncher()!=NULL ); #if USE_TABBED_VIEW Wrapper::QtWidgetView * appWidget = Application::ConstInstance() ->GetOTBApplicationsModel() ->GetLauncher() ->NewOtbApplicationWidget( appName, true ); assert( appWidget!=NULL ); // // add the application in a tab // TODO : check if this application is already opened ??? int tabIndex = m_CentralTabWidget->addTab( appWidget, QIcon( ":/icons/process" ), docName ); // no checking needed here, if index is not available nothing is // done. Focus on the newly added tab m_CentralTabWidget->setCurrentIndex( tabIndex ); // // on quit widget signal, close its tab QObject::connect( appWidget, SIGNAL( QuitSignal() ), // to: this, SLOT( OnTabCloseRequested() ) ); #else // USE_TABBED_VIEW QWidget * appWidget = Application::ConstInstance() ->GetOTBApplicationsModel() ->GetLauncher() ->NewOtbApplicationWindow( appName, true, this ); assert( appWidget!=NULL ); appWidget->show(); #endif // USE_TABBED_VIEW // // connections. not using m_CentralTabWidget->currentWidget() leads // to a wrong connection!!!! QObject::connect( appWidget, SIGNAL( OTBApplicationOutputImageChanged( const QString&, const QString& ) ), // to: this, SLOT( OnOTBApplicationOutputImageChanged( const QString&, const QString& ) ) ); QObject::connect( appWidget, SIGNAL( ExecutionDone( int ) ), // to: this, SLOT( OnExecutionDone( int ) ) ); } #endif // defined( OTB_USE_QT4 ) && USE_OTB_APPS /*****************************************************************************/ #if USE_TABBED_VIEW void MainWindow ::OnTabCloseRequested() { // get current tab index int currentIndex = m_CentralTabWidget->currentIndex(); // close tab and delete its widget OnTabCloseRequested( currentIndex ); } #endif // USE_TABBED_VIEW /*****************************************************************************/ #if USE_TABBED_VIEW void MainWindow ::OnTabCloseRequested( int index ) { assert( index >= 1 ); QWidget* appWidget = m_CentralTabWidget->widget( index ); assert( appWidget!=NULL ); #if defined( OTB_USE_QT4 ) && USE_OTB_APPS assert( appWidget==qobject_cast< Wrapper::QtWidgetView* >( appWidget ) ); Wrapper::QtWidgetView* appWidgetView = qobject_cast< Wrapper::QtWidgetView* >( appWidget ); assert( appWidgetView!=NULL ); if( !appWidgetView->IsClosable() ) { QMessageBox::warning( this, tr( "Warning!" ), tr( "Tab cannot be closed while OTB application is running." ) ); return; } #endif m_CentralTabWidget->removeTab( index ); delete appWidget; appWidget = NULL; } #endif // USE_TABBED_VIEW /*****************************************************************************/ void MainWindow ::OnOTBApplicationOutputImageChanged( const QString &, const QString & outfname ) { // // If this slot is called, it means that an application has finished // its process and has an output image parameter. The 'outfname' in // parameters is the output filename. This slot may launch or not, // depending on the app settings, the import of the 'outfname' to the // catalog database. // import the result image into the database ImportImage( outfname, false ); } /*****************************************************************************/ void MainWindow ::OnExecutionDone( int status ) { if( status<0 ) return; } /*****************************************************************************/ void MainWindow ::OnReferenceLayerChanged( size_t index ) { // qDebug() << this << "::OnReferenceLayerChanged(" << index << ")"; // // Access widget. QComboBox * comboBox = m_UI->m_RenderToolBar->findChild< QComboBox * >( REFERENCE_LAYER_COMBOBOX_NAME ); assert( comboBox!=NULL ); // // Access model. assert( I18nCoreApplication::Instance()!=NULL ); assert( I18nCoreApplication::Instance()->GetModel()== I18nCoreApplication::Instance()->GetModel< StackedLayerModel >() ); StackedLayerModel * model = I18nCoreApplication::Instance()->GetModel< StackedLayerModel >(); // assert( model!=NULL ); // // Update widget from model. // comboBox->setCurrentIndex( // model->GetReferenceIndex()>=model->GetCount() // ? 0 // comboBox->count() - 1 // : model->GetReferenceIndex() + 1 // ); comboBox->setCurrentIndex( index>=model->GetCount() ? 0 : index + 1 ); } /*****************************************************************************/ void MainWindow ::OnReferenceLayerCurrentIndexChanged( int index ) { // qDebug() << this << "::OnReferenceLayerCurrentIndexChanged(" << index << ")"; // // Access widget. QComboBox * comboBox = m_UI->m_RenderToolBar->findChild< QComboBox * >( REFERENCE_LAYER_COMBOBOX_NAME ); assert( comboBox!=NULL ); // // Access model. assert( I18nCoreApplication::Instance()!=NULL ); assert( I18nCoreApplication::Instance()->GetModel()== I18nCoreApplication::Instance()->GetModel< StackedLayerModel >() ); StackedLayerModel * model = I18nCoreApplication::Instance()->GetModel< StackedLayerModel >(); assert( model!=NULL ); // // Update model. model->SetReference( index<=0 // index>=comboBox->count() - 1 ? StackedLayerModel::NIL_INDEX : comboBox->currentIndex() - 1 ); } /*****************************************************************************/ void MainWindow ::OnSettingsUpdated() { assert( m_ShaderWidget!=NULL ); m_ShaderWidget->UpdateSettings(); // { assert( m_ColorSetupDock!=NULL ); AbstractModelController * controller = GetController( m_ColorSetupDock ); assert( controller!=NULL ); if( controller->GetModel()!=NULL ) controller->ResetWidget(); } // { assert( m_ColorDynamicsDock!=NULL ); AbstractModelController * controller = GetController( m_ColorDynamicsDock ); assert( controller!=NULL ); if( controller->GetModel()!=NULL ) controller->ResetWidget(); } // assert( m_ImageView!=NULL ); m_ImageView->updateGL(); // ImageViewWidget * quicklookView = GetQuicklookView(); assert( quicklookView!=NULL ); quicklookView->updateGL(); } /****************************************************************************/ void MainWindow ::RefreshReferenceLayerComboBox() { // qDebug() << this << "::RefreshReferenceLayerComboBox()"; assert( I18nCoreApplication::Instance()!=NULL ); assert( I18nCoreApplication::Instance()->GetModel()== I18nCoreApplication::Instance()->GetModel< StackedLayerModel >() ); SetupReferenceLayerComboBox( I18nCoreApplication::Instance()->GetModel< StackedLayerModel >() ); } /****************************************************************************/ void MainWindow ::OnPixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & pixels ) { // // Get stacked-layer. assert( Application::Instance() ); assert( Application::Instance()->GetModel()== Application::Instance()->GetModel< StackedLayerModel >() ); const StackedLayerModel * stackedLayerModel = Application::Instance()->GetModel< StackedLayerModel >(); assert( stackedLayerModel!=NULL ); if( !stackedLayerModel->HasCurrent() ) { m_StatusBarWidget->SetPixelIndex( IndexType(), false ); m_StatusBarWidget->SetText( tr( "Select layer..." ) ); return; } StackedLayerModel::SizeType current = stackedLayerModel->GetCurrentIndex(); assert( current!=StackedLayerModel::NIL_INDEX ); m_StatusBarWidget->SetPixelIndex( pixels[ current ].m_Index, pixels[ current ].m_HasIndex ); QString text; if( pixels[ current ].m_HasPoint && stackedLayerModel->HasReference() ) { assert( stackedLayerModel->GetCurrent()!=NULL ); PointType wgs84; double alt = std::numeric_limits< double >::quiet_NaN(); stackedLayerModel->GetCurrent()->ToWgs84( pixels[ current ].m_Point, wgs84, alt ); text = tr( "(%1 %2 ; %3 %4 ; %5)" ) .arg( wgs84[ 0 ]>=0.0 ? "N" : "S" ).arg( fabs( wgs84[ 1 ] ) ) .arg( wgs84[ 1 ]>=0.0 ? "E" : "W" ).arg( fabs( wgs84[ 0 ] ) ) .arg( alt ); } if( pixels[ current ].m_HasPixel ) { if( !text.isEmpty() ) text.append( " " ); text.append( tr( "[ R: %1 ; G: %2 ; B: %3 ]" ) .arg( pixels[ current ].m_Pixel[ 0 ] ) .arg( pixels[ current ].m_Pixel[ 1 ] ) .arg( pixels[ current ].m_Pixel[ 2 ] ) ); } m_StatusBarWidget->SetText( text ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/Monteverdi/src/mvdMainWindow.qrc000066400000000000000000000045041301006202600260670ustar00rootroot00000000000000 ../../../../Utilities/Data/Icons/image-export_24x24.png ../../../../Utilities/Data/Icons/layers-remove_24x24.png ../../../../Utilities/Data/Icons/reload_24x24.png ../../../../Utilities/Data/Icons/check_24x24.png ../../../../Utilities/Data/Icons/projection_24x24.png ../../../../Utilities/Data/Icons/layer-up_24x24.png ../../../../Utilities/Data/Icons/layer-bottom_24x24.png ../../../../Utilities/Data/Icons/layer-delete_24x24.png ../../../../Utilities/Data/Icons/layer-down_24x24.png ../../../../Utilities/Data/Icons/layer-top_24x24.png ../../../../Utilities/Data/Icons/zoom-1to1.png ../../../../Utilities/Data/Icons/monteverdi-32x32.png ../../../../Utilities/Data/Icons/alg.png ../../../../Utilities/Data/Icons/execute.png ../../../../Utilities/Data/Icons/locked.png ../../../../Utilities/Data/Icons/unlocked.png ../../../../Utilities/Data/Icons/forbidden-128x128.png ../../../../Utilities/Data/Icons/action-zoomin_24x24.png ../../../../Utilities/Data/Icons/action-zoomfullextent_24x24.png ../../../../Utilities/Data/Icons/action-zoomout_24x24.png ../../../../Utilities/Data/Icons/action-zoomtolayer_24x24.png ../../../../Utilities/Data/Icons/document-open_32x32.png ../../../../Utilities/Data/Icons/monteverdi-128x128.png ../../../../Utilities/Data/Icons/monteverdi-splash.png OTB-release-5.8/Modules/Visualization/Monteverdi/src/mvdMainWindow.ui000066400000000000000000000174301301006202600257210ustar00rootroot00000000000000 mvd::MainWindow 0 0 800 600 Main window 0 0 800 27 &File &Help &View &Edit true Main toolbar Import image-file. TopToolBarArea false Render-mode toolbar TopToolBarArea false Selected layer effect toolbar TopToolBarArea false &Quit Quit application. Ctrl+Q true :/icons/action_Open_Icon:/icons/action_Open_Icon &Open image(s)... Open image(s)... Open image file(s). Ctrl+O &About... About... About... true Prefere&nces false :/icons/action_ZoomIn_Icon:/icons/action_ZoomIn_Icon Zoom in Ctrl++ false :/icons/action_ZoomOut_Icon:/icons/action_ZoomOut_Icon Zoom out Ctrl+- false :/icons/action_ZoomExtent_Icon:/icons/action_ZoomExtent_Icon Zoom to full extent 3 false :/icons/action_ZoomFull_Icon:/icons/action_ZoomFull_Icon Zoom to full resolution (1:1) 1 false :/icons/action_ZoomLayer_Icon:/icons/action_ZoomLayer_Icon Zoom to layer extent Zoom to layer extent 2 &Keymap... Display keyboard and mouse key mapping OTB-Applications browser Ctrl+A :/icons/action_SaveScreenshot_Icon:/icons/action_SaveScreenshot_Icon Save screenshot Take screenshot of image-view and save it into file Ctrl+P OTB-release-5.8/Modules/Visualization/Monteverdi/src/mvdPreferencesDialog.cxx000066400000000000000000000275631301006202600274230ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdPreferencesDialog.h" #include "ui_mvdPreferencesDialog.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" #include "mvdGui.h" #include "mvdI18nApplication.h" #include "mvdI18nMainWindow.h" namespace mvd { /* TRANSLATOR mvd::PreferencesDialog Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ bool IsPathModified( I18nCoreApplication::SettingsKey, bool, I18nCoreApplication::SettingsKey, const QString & ); /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ bool IsPathModified( I18nCoreApplication::SettingsKey enabledKey, bool isEnabled, I18nCoreApplication::SettingsKey pathKey, const QString & pathname ) { // qDebug() // << "::IsPathModified(" // << I18nApplication::Instance()->RetrieveSettingsKey( enabledKey ).toBool() // << "," // << isEnabled // << "," // << I18nApplication::Instance()->RetrieveSettingsKey( // pathKey // ).toString() // << "," // << pathname // << ")"; return I18nApplication::Instance()->RetrieveSettingsKey( enabledKey ).toBool() != isEnabled || QDir( I18nApplication::Instance()->RetrieveSettingsKey( pathKey ).toString() ) != QDir( pathname ); } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ PreferencesDialog ::PreferencesDialog( QWidget* p, Qt::WindowFlags flags ) : QDialog( p, flags ), m_UI( new mvd::Ui::PreferencesDialog() ), m_ResultsDirModified( false ), m_GeoidFileModified( false ), m_SrtmDirModified( false ) { assert( m_UI!=NULL ); assert( I18nApplication::Instance()!=NULL ); m_UI->setupUi( this ); // // Runtime UI initialization. m_UI->settingsGroupBox->setVisible( false ); AddItemsInto( m_UI->resolutionComboBox, "mvd", RESOLUTION_NAMES, RESOLUTION_COUNT ); AddItemsInto( m_UI->tileSizeComboBox, "mvd", TILE_SIZE_NAMES, TILE_SIZE_COUNT ); // // General settings. m_UI->resultDirPathLineEdit->setText( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_RESULTS_DIR ) .toString() ); // // GDAL overviews. { QVariant value( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_OVERVIEWS_ENABLED ) ); m_UI->overviewsCheckBox->setChecked( !value.isValid() ? OVERVIEWS_ENABLED_DEFAULT : value.toBool() ); } { QVariant value( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_OVERVIEWS_SIZE ) ); m_UI->overviewsSpinBox->setValue( !value.isValid() ? OVERVIEWS_SIZE_DEFAULT : value.toInt() ); } // // Rendering settings. { QVariant value( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_RESOLUTION ) ); m_UI->resolutionComboBox->setCurrentIndex( !value.isValid() ? RESOLUTION_DEFAULT : value.toInt() ); } { QVariant value( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_TILE_SIZE ) ); m_UI->tileSizeComboBox->setCurrentIndex( TILE_SIZE_DEFAULT ); int val = value.toInt(); for( int i=0; itileSizeComboBox->setCurrentIndex( i ); break; } } // // Elevation management settings. m_UI->srtmLineEdit->setText( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR ) .toString() ); m_UI->srtmCheckbox->setChecked( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE ) .toBool() ); m_UI->srtmLineEdit->setEnabled( m_UI->srtmCheckbox->isChecked() ); m_UI->srtmButton->setEnabled( m_UI->srtmCheckbox->isChecked() ); m_UI->geoidLineEdit->setText( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH ) .toString() ); m_UI->geoidCheckbox->setChecked( I18nApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE ) .toBool() ); m_UI->geoidLineEdit->setEnabled( m_UI->geoidCheckbox->isChecked() ); m_UI->geoidButton->setEnabled( m_UI->geoidCheckbox->isChecked() ); // Connect centralWidget manipulator to Ql renderer when viewportRegionChanged QObject::connect( m_UI->buttonBox, SIGNAL( rejected() ), this, SLOT( close() ) ); assert( !m_ResultsDirModified ); assert( !m_GeoidFileModified ); assert( !m_SrtmDirModified ); // qDebug() << "results-dir:" << m_ResultsDirModified; // qDebug() << "geoid-file:" << m_GeoidFileModified; // qDebug() << "srtm-dir:" << m_SrtmDirModified; } /*****************************************************************************/ PreferencesDialog ::~PreferencesDialog() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void PreferencesDialog ::on_buttonBox_accepted() { // // General settings. if( m_ResultsDirModified ) { // Set the result dir I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_RESULTS_DIR, QDir::cleanPath( m_UI->resultDirPathLineEdit->text() ) ); } I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE, m_UI->srtmCheckbox->isChecked() ); I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR, QDir::cleanPath( m_UI->srtmLineEdit->text() ) ); I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE, m_UI->geoidCheckbox->isChecked() ); I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH, m_UI->geoidLineEdit->text() ); // // Overview settings. I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_OVERVIEWS_ENABLED, m_UI->overviewsCheckBox->isChecked() ); I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_OVERVIEWS_SIZE, m_UI->overviewsSpinBox->value() ); // // Rendering settings. I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_RESOLUTION, m_UI->resolutionComboBox->currentIndex() ); { bool isOk = true; int value = m_UI->tileSizeComboBox->currentText().toInt( &isOk ); assert( isOk ); if( !isOk ) value = TILE_SIZE_VALUE[ TILE_SIZE_DEFAULT ]; I18nApplication::Instance()->StoreSettingsKey( I18nCoreApplication::SETTINGS_KEY_TILE_SIZE, value ); } // // Elevation management settings. if( m_GeoidFileModified ) { try { if( I18nApplication::Instance()->ElevationSetup() ) { QMessageBox::warning( this, "Warning!", tr( "Geoid file has changed since application has been started. This setting needs the application to be restarted to be taken into account." ) ); } } catch( const std::exception & exception ) { QMessageBox::warning( this, "Warning!", tr( "The following exception has been caught when setting up Elevation Settings:\n\n%1" ).arg( exception.what() ) ); } } m_ResultsDirModified = false; m_GeoidFileModified = false; m_SrtmDirModified = false; close(); } /*****************************************************************************/ void PreferencesDialog ::on_srtmCheckbox_toggled( bool checked ) { assert( m_UI!=NULL ); m_UI->srtmLineEdit->setEnabled( checked ); m_UI->srtmButton->setEnabled( checked ); m_SrtmDirModified = IsPathModified( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE, checked, I18nCoreApplication::SETTINGS_KEY_SRTM_DIR, m_UI->srtmLineEdit->text() ); } /***************************************************************************/ void PreferencesDialog ::on_srtmLineEdit_textChanged( const QString & text ) { assert( m_UI!=NULL ); m_SrtmDirModified = IsPathModified( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE, m_UI->srtmCheckbox->isChecked(), I18nCoreApplication::SETTINGS_KEY_SRTM_DIR, text ); } /***************************************************************************/ void PreferencesDialog ::on_geoidCheckbox_toggled( bool checked ) { m_UI->geoidLineEdit->setEnabled( checked ); m_UI->geoidButton->setEnabled( checked ); m_GeoidFileModified = IsPathModified( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE, checked, I18nCoreApplication::SETTINGS_KEY_GEOID_PATH, m_UI->geoidLineEdit->text() ); } /***************************************************************************/ void PreferencesDialog ::on_geoidLineEdit_textChanged( const QString & text ) { m_GeoidFileModified = IsPathModified( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE, m_UI->geoidCheckbox->isChecked(), I18nCoreApplication::SETTINGS_KEY_GEOID_PATH, text ); } /***************************************************************************/ void PreferencesDialog ::on_srtmButton_clicked() { QString srtmDir( otb::GetExistingDirectory( this, tr( "Select the directory containing DEM files." ) ) ); if( srtmDir.isEmpty() ) return; m_UI->srtmLineEdit->setText( QDir( srtmDir ).absolutePath() ); } /***************************************************************************/ void PreferencesDialog ::on_geoidButton_clicked() { QString geoidFile( otb::GetOpenFileName( this, tr( "Select a geoid file." ) ) ); if( geoidFile.isEmpty() ) return; m_UI->geoidLineEdit->setText( QDir( geoidFile ).absolutePath() ); } /***************************************************************************/ void PreferencesDialog ::on_resultDirButton_clicked() { QString resultsDir( otb::GetExistingDirectory( this, tr( "Select the default directory for results data: " ) ) ); if( resultsDir.isEmpty() ) return; m_UI->resultDirPathLineEdit->setText( QDir( resultsDir ).absolutePath() ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/Monteverdi/src/mvdPreferencesDialog.ui000066400000000000000000000277341301006202600272360ustar00rootroot00000000000000 mvd::PreferencesDialog Qt::ApplicationModal 0 0 445 397 0 0 Preferences 0 0 General Settings 0 0 Results directory true 0 0 200 0 Default directory for results data true true 0 0 ... 0 0 GDAL Overviews 0 0 Minimum size: 999999999 0 0 Generate true 0 0 pixel(s) 0 0 Rendering 0 0 Size of the image-tile which is loaded when view shifts to an unloaded area. Image tile size 0 0 Method to choose level of resolution pyramid when scale is between two levels Level of resolution pyramid Method to choose level of resolution pyramid when scale is between two levels Elevation Management false 0 0 ... false 0 0 false 0 0 ... 0 0 Geoid File false 0 0 0 0 DEM directory Qt::Horizontal 228 20 0 0 QDialogButtonBox::Cancel|QDialogButtonBox::Ok Qt::Vertical 0 0 overviewsCheckBox toggled(bool) overviewsSpinBox setEnabled(bool) 69 116 319 117 OTB-release-5.8/Modules/Visualization/Monteverdi/src/mvdWin32.rc.in000066400000000000000000000022701301006202600251370ustar00rootroot00000000000000#include "winver.h" IDI_ICON1 ICON DISCARDABLE "@Monteverdi_App_WIN32_ICON@" VS_VERSION_INFO VERSIONINFO FILEVERSION @Monteverdi_VERSION_MAJOR@,@Monteverdi_VERSION_MINOR@,@Monteverdi_VERSION_PATCH@,0 PRODUCTVERSION @Monteverdi_VERSION_MAJOR@,@Monteverdi_VERSION_MINOR@,@Monteverdi_VERSION_PATCH@,0 FILEFLAGS 0x0L FILEFLAGSMASK 0x3fL FILEOS 0x00040004L FILETYPE 0x1L FILESUBTYPE 0x0L BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "000004b0" BEGIN VALUE "CompanyName", "OrfeoToolbox" VALUE "FileDescription", "Monteverdi 2" VALUE "FileVersion", "@Monteverdi_VERSION_MAJOR@.@Monteverdi_VERSION_MINOR@.@Monteverdi_VERSION_PATCH@.0" VALUE "LegalCopyright", "Copyright (c) 2012-2013 Centre National d'Etudes Spatiales. All rights reserved." VALUE "InternalName", "monteverdi" VALUE "OriginalFilename", "monteverdi.exe" VALUE "ProductName", "Monteverdi 2" VALUE "ProductVersion", "@Monteverdi_VERSION_MAJOR@.@Monteverdi_VERSION_MINOR@.@Monteverdi_VERSION_PATCH@.0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x0, 1200 END END OTB-release-5.8/Modules/Visualization/Monteverdi/test/000077500000000000000000000000001301006202600227625ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/Monteverdi/test/CMakeLists.txt000066400000000000000000000005041301006202600255210ustar00rootroot00000000000000otb_module_test() set(OTBMonteverdiTests mvdMonteverdiApplicationTest.cxx mvdMonteverdiTestDriver.cxx ) add_executable(mvdMonteverdiTestDriver ${OTBMonteverdiTests}) target_link_libraries(mvdMonteverdiTestDriver ${OTBMonteverdi-Test_LIBRARIES}) otb_module_target_label(mvdMonteverdiTestDriver) # Tests Declaration # TODO OTB-release-5.8/Modules/Visualization/Monteverdi/test/mvdMonteverdiApplicationTest.cxx000066400000000000000000000022761301006202600313640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // Monteverdi includes (sorted by alphabetic order) #include "mvdApplication.h" #include "mvdMainWindow.h" int mvdMonteverdiApplicationTest(int argc, char* argv[]) { QApplication qtApp( argc, argv ); mvd::Application application( &qtApp ); mvd::MainWindow main_window; main_window.show(); QTimer::singleShot(1000, &qtApp, SLOT(quit())); return qtApp.exec(); } OTB-release-5.8/Modules/Visualization/Monteverdi/test/mvdMonteverdiTestDriver.cxx000066400000000000000000000015571301006202600303550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // this file defines the otbCommonTest for the test driver // and all it expects is that you have a function called RegisterTests #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include #include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(mvdMonteverdiApplicationTest); } OTB-release-5.8/Modules/Visualization/MonteverdiCore/000077500000000000000000000000001301006202600226145ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiCore/CMakeLists.txt000066400000000000000000000022701301006202600253550ustar00rootroot00000000000000############################################################################# project( OTBMonteverdiCore ) ############################################################################# set( Monteverdi_FLOATING_TYPE "float" CACHE STRING "The type of data in which input images are read (double/float)." ) set(Monteverdi_UI_VERSION "1") set(Monteverdi_CONFIGURE_FILE "ConfigureMonteverdi.h" ) set(Monteverdi_PROJECT_NAME "Monteverdi") ############################################################################# configure_file( src/ConfigureMonteverdi.h.in ConfigureMonteverdi.h ) ############################################################################# set( OTBMonteverdiCore_INCLUDE_DIRS ${OTBMonteverdiCore_BINARY_DIR} ) ############################################################################# set( OTBMonteverdiCore_LIBRARIES OTBMonteverdiCore ) ############################################################################# otb_module_impl() ############################################################################# install(FILES ${OTBMonteverdiCore_BINARY_DIR}/ConfigureMonteverdi.h DESTINATION ${OTBMonteverdiCore_INSTALL_INCLUDE_DIR} COMPONENT Development ) OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/000077500000000000000000000000001301006202600242375ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdAbstractImageModel.h000066400000000000000000000324161301006202600306140ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractImageModel_h #define mvdAbstractImageModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbImageMetadataInterfaceBase.h" #endif //tag=QT4-boost-compatibility // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractLayerModel.h" #include "mvdImageProperties.h" #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class HistogramModel; class ImageProperties; class QuicklookModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class AbstractImageModel * \ingroup OTBMonteverdiCore * */ class OTBMonteverdiCore_EXPORT AbstractImageModel : public AbstractLayerModel { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: /** * \class BuildContext * \brief WIP. * \ingroup OTBMonteverdiCore */ class BuildContext { // // Public methods. public: /** \brief Contrustor (testing consistency). */ BuildContext() : m_Id( -1 ), m_Filename(), m_Quicklook(), m_Histogram(), m_Settings( NULL ), m_Properties( NULL ), m_IsBeingStored( false ) { } /** \brief Constructor (importing image). */ BuildContext( const QString& filename ) : m_Id( -1 ), m_Filename( filename ), m_Quicklook(), m_Histogram(), m_Settings( NULL ), m_Properties( NULL ), m_IsBeingStored( true ) { assert( !filename.isEmpty() ); } /** \brief Constructor (loading image). */ BuildContext( void* const settings, ImageProperties* const properties ) : m_Id( -1 ), m_Filename(), m_Quicklook(), m_Histogram(), m_Settings( settings ), m_Properties( properties ), m_IsBeingStored( false ) { } /** */ inline bool IsBeingStored() const { return m_IsBeingStored; } // // Public attributes public: int m_Id; QString m_Filename; QString m_Quicklook; QString m_Histogram; void * const m_Settings; ImageProperties * const m_Properties; private: bool m_IsBeingStored; }; // // Public methods. public: /** Destructor */ ~AbstractImageModel() ITK_OVERRIDE; /** */ inline int GetId() const; /** * \return This image properties. */ inline const ImageProperties* GetProperties() const; /** * \return This image properties. */ inline ImageProperties* GetProperties(); /** * \brief Copy external properties data to this image properties. * * \param properties External properties. */ inline void SetProperties( const ImageProperties& properties ); /** */ const QuicklookModel* GetQuicklookModel() const; /** */ QuicklookModel* GetQuicklookModel(); /** */ inline const HistogramModel* GetHistogramModel() const; /** */ inline HistogramModel* GetHistogramModel(); /** * Get a smart-pointer to the current LOD image-base. */ virtual ImageBaseType::ConstPointer ToImageBase() const =0; /** * Get a smart-pointer to the current LOD image-base. */ virtual ImageBaseType::Pointer ToImageBase() =0; /** * \return The largest possible region of the current LOD level. */ inline const ImageRegionType& GetLodLargestRegion() const; /** * \return The largest possible region of the native image, which * is, by default, LOD level zero. */ inline const ImageRegionType& GetNativeLargestRegion() const; /** * \return The spacing of the native image, which * is, by default, LOD level zero. */ inline const SpacingType& GetNativeSpacing() const; /** * \return The estimated spacing of the native image at full resolution * */ inline const SpacingType& GetEstimatedGroundSpacing() const; /** */ inline CountType GetNbComponents() const; /** */ QStringList GetBandNames( bool enhanced =false ) const; /** * Get the number of available LOD. */ virtual CountType GetNbLod() const =0; /** * Set the current LOD index (which may causes disk IOs, * decompressing and buffering etc.) */ inline void SetCurrentLod( CountType lod ); /** * Get the current LOD index. */ inline CountType GetCurrentLod() const; /** */ inline const SpacingType& GetSpacing() const; /** */ inline const PointType& GetOrigin() const; /** */ inline PointType GetCenter() const; // // Public SLOTS. public slots: /** * \brief Refresh histogram-model based on no-data properties. */ inline void RefreshHistogram(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void SpacingChanged( const SpacingType& ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** Constructor */ AbstractImageModel( QObject* p =NULL ); /** * \brief Set image properties pointer. * * \param properties The new properties instance. */ inline void SetProperties( ImageProperties* properties ); /** * \brief Refresh histogram-model based on no-data settings. * * \param context Pointer to a histogram build-context. */ void RefreshHistogram( void* const context ); /** */ inline otb::ImageMetadataInterfaceBase::ConstPointer GetMetaDataInterface() const; // // AbstractModel methods. void virtual_BuildModel( void* context ) ITK_OVERRIDE; // // Protected attributes. protected: /** * The largest possible region of the native image, which is, by * default, LOD level zero. */ ImageRegionType m_NativeLargestRegion; /** * The spacing of the native image, which is, by * default, LOD level zero. */ SpacingType m_NativeSpacing; /** * The estimated spacing of the native image at full resolution which is, by * default, display in image info. */ SpacingType m_EstimatedGroundSpacing; /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ virtual void virtual_SetCurrentLod( CountType lod ) =0; /** * \brief Private virtual implementation of RefreshHistogram. * * Implement this method in subclass to construct a valid * HistogramModel::BuildContext and call RefreshHistogram(void* * const). */ virtual void virtual_RefreshHistogram() {}; // // Private attributes. private: /** */ int m_Id; /** */ CountType m_CurrentLod; /** */ ImageProperties* m_Properties; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdHistogramModel.h" #endif //tag=QT4-boost-compatibility namespace mvd { /*****************************************************************************/ int AbstractImageModel ::GetId() const { return m_Id; } /*****************************************************************************/ inline const ImageProperties* AbstractImageModel ::GetProperties() const { return m_Properties; } /*****************************************************************************/ inline ImageProperties* AbstractImageModel ::GetProperties() { return m_Properties; } /*****************************************************************************/ inline void AbstractImageModel ::SetProperties( const ImageProperties& properties ) { assert( m_Properties!=NULL ); *m_Properties = properties; } /*****************************************************************************/ const HistogramModel* AbstractImageModel ::GetHistogramModel() const { return findChild< const HistogramModel* >(); } /*****************************************************************************/ HistogramModel* AbstractImageModel ::GetHistogramModel() { return findChild< HistogramModel* >(); } /*****************************************************************************/ CountType AbstractImageModel ::GetCurrentLod() const { return m_CurrentLod; } /*****************************************************************************/ void AbstractImageModel ::SetCurrentLod( CountType lod ) { assert( lodGetSpacing()); } /*****************************************************************************/ inline const ImageRegionType& AbstractImageModel ::GetLodLargestRegion() const { return ToImageBase()->GetLargestPossibleRegion(); } /*****************************************************************************/ inline const ImageRegionType& AbstractImageModel ::GetNativeLargestRegion() const { return m_NativeLargestRegion; } /*****************************************************************************/ inline const SpacingType& AbstractImageModel ::GetNativeSpacing() const { return m_NativeSpacing; } /*****************************************************************************/ inline const SpacingType& AbstractImageModel ::GetEstimatedGroundSpacing() const { return m_EstimatedGroundSpacing; } /*****************************************************************************/ inline CountType AbstractImageModel ::GetNbComponents() const { return ToImageBase()->GetNumberOfComponentsPerPixel(); } /*****************************************************************************/ inline otb::ImageMetadataInterfaceBase::ConstPointer AbstractImageModel ::GetMetaDataInterface() const { return otb::ConstCast< const otb::ImageMetadataInterfaceBase >( otb::ImageMetadataInterfaceFactory::CreateIMI( ToImageBase()->GetMetaDataDictionary() ) ); } /*****************************************************************************/ inline const PointType& AbstractImageModel ::GetOrigin() const { assert( !ToImageBase().IsNull() ); return ToImageBase()->GetOrigin(); } /*****************************************************************************/ inline const SpacingType& AbstractImageModel ::GetSpacing() const { assert( !ToImageBase().IsNull() ); return ToImageBase()->GetSpacing(); } /*****************************************************************************/ inline PointType AbstractImageModel ::GetCenter() const { PointType center( GetOrigin() ); SpacingType spacing( GetSpacing() ); SizeType size( GetNativeLargestRegion().GetSize() ); center[ 0 ] += 0.5 * spacing[ 0 ] * static_cast< double >( size[ 0 ] ); center[ 1 ] += 0.5 * spacing[ 1 ] * static_cast< double >( size[ 1 ] ); return center; } /*****************************************************************************/ inline void AbstractImageModel ::RefreshHistogram() { virtual_RefreshHistogram(); } /*****************************************************************************/ inline void AbstractImageModel ::SetProperties( ImageProperties* properties ) { if( m_Properties==properties ) return; delete m_Properties; m_Properties = properties; } } // end namespace 'mvd' #endif // mvdAbstractImageModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdAbstractLayerModel.h000066400000000000000000000117061301006202600306450ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractLayerModel_h #define mvdAbstractLayerModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractModel.h" #include "mvdTypes.h" #include "mvdVisibleInterface.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. // // Global types. /** */ enum SpatialReferenceType { SRT_UNKNOWN =0, SRT_CARTO, SRT_GEO, SRT_SENSOR, }; // // Global functions. /** */ OTBMonteverdiCore_EXPORT SpatialReferenceType GetSpatialReferenceType( const std::string & filename ); /** */ OTBMonteverdiCore_EXPORT SpatialReferenceType GetSpatialReferenceType( const std::string & wkt, bool hasKwl ); /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class AbstractLayerModel * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT AbstractLayerModel : public AbstractModel, public VisibleInterface { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Destructor. */ ~AbstractLayerModel() ITK_OVERRIDE; /** */ SpatialReferenceType GetSpatialReferenceType() const; /** */ std::string GetWkt() const; /** */ std::string GetAuthorityCode( bool ) const; /** */ void ToWgs84( const PointType &, PointType & wgs84, double & alt ) const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void VisibilityChanged( bool =true ); void VisibilityChanged( AbstractLayerModel *, bool ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ AbstractLayerModel( QObject* p =NULL ); /** */ bool HasKwl() const; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ virtual std::string virtual_GetWkt() const =0; /** */ virtual bool virtual_HasKwl() const; /** */ virtual void virtual_ToWgs84( const PointType &, PointType & wgs84, double & alt ) const =0; // // VisibleInterface overloads. void virtual_SignalVisibilityChanged( bool ) ITK_OVERRIDE; // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdAbstractLayerModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdAbstractModel.h000066400000000000000000000125221301006202600276450ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractModel_h #define mvdAbstractModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include #endif //tag=QT4-boost-compatibility // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiCoreExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class AbstractModel * * \ingroup OTBMonteverdiCore * */ class OTBMonteverdiCore_EXPORT AbstractModel : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** Destructor */ ~AbstractModel() ITK_OVERRIDE; /** */ template< typename TModel > inline const TModel* GetParentModel() const; /** */ template< typename TModel > inline TModel* GetParentModel(); /** */ template< typename TModel > TModel* newChildModel( void* context =NULL ); /** */ inline void attachChildModel( AbstractModel* model, void* context =NULL ); /** */ inline void BuildModel( void* context =NULL ); /** */ virtual bool IsModified() const; /** */ virtual void ClearModified(); /** */ inline void Save(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** Constructor */ AbstractModel( QObject* p =NULL ); /** */ virtual void virtual_BuildModel( void* context =NULL ); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ virtual void virtual_Save(); // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ template< typename TModel > const TModel* AbstractModel ::GetParentModel() const { return qobject_cast< const TModel* >( parent() ); } /*****************************************************************************/ template< typename TModel > TModel* AbstractModel ::GetParentModel() { // qDebug() // << "parent:" << parent() // << ";" << qobject_cast< TModel* >( parent() ); return qobject_cast< TModel* >( parent() ); } /*****************************************************************************/ template< typename T > T * AbstractModel ::newChildModel( void * context ) { T* model = new T( this ); try { attachChildModel( model, context ); } catch( ... ) { delete model; model = NULL; throw; } return model; } /*****************************************************************************/ inline void AbstractModel ::attachChildModel( AbstractModel* model, void* context ) { assert( model!=NULL ); model->setParent( this ); model->BuildModel( context ); } /*****************************************************************************/ inline void AbstractModel ::BuildModel( void* context ) { virtual_BuildModel( context ); } /*****************************************************************************/ inline void AbstractModel ::Save() { virtual_Save(); ClearModified(); } } // end namespace 'mvd' #endif // mvdAbstractModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdAbstractWorker.h000066400000000000000000000124311301006202600300550ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractWorker_h #define mvdAbstractWorker_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class AbstractWorker * * \ingroup OTBMonteverdiCore * * \brief Abstract worker object used as a base-class for threaded tasks. */ class OTBMonteverdiCore_EXPORT AbstractWorker : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Destructor. */ ~AbstractWorker() ITK_OVERRIDE; /** */ inline QString GetFirstProgressText() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /** * \brief Call the implemented do job/task routine. */ void Do() throw(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** * \brief Signal emitted when progress text has changed. * * \param text New progress text to display; */ void ProgressTextChanged( const QString& text ); /** * \brief Signal emitted when progress value has changed. * * \param value New progress value to display. */ void ProgressValueChanged( int value ); /** * \brief Signal emitted when progress range has changed. * * \param min Minimum progress value. * \param max Maximum progress value. */ void ProgressRangeChanged( int min, int max ); /** * \brief Signal emitted when job has correctly been done. * * Use this signal to get resulting object when job has been done. * * \param result Resulting QObject instance of NULL if none. */ void Done( QObject* result =NULL ); /** * \brief Signal emitted when task (i.e. thread) has finished * correctly or incorrectly. * * Use this signal to forward to thead quit() slot when job has * finished. */ void Finished(); /** * \brief Signal emitted when an exception has been caught by this worker. * * \param */ void ExceptionRaised( QString what ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ AbstractWorker( QObject* p =NULL ); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** * \brief Do job/task abstract method to implement. */ virtual QObject* virtual_Do() =0; /** */ virtual QString virtual_GetFirstProgressText() const =0; // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline QString AbstractWorker::GetFirstProgressText() const { return virtual_GetFirstProgressText(); } } // end namespace 'mvd' #endif // mvdAbstractWorker_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdAlgorithm.h000066400000000000000000000433041301006202600270510ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAlgorithm_h #define mvdAlgorithm_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include #endif //tag=QT4-boost-compatibility // // ITK includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkFixedArray.h" #include "itkExceptionObject.h" #include "itkVariableLengthVector.h" #endif //tag=QT4-boost-compatibility // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. } // end of namespace 'mvd'. /*****************************************************************************/ /* FUNCTIONS DECLARATION. */ namespace otb { /** * Convert an itk::VariableLengthVector< T2 > into a * itk::FixedArray< T1, N >. * * Elements of type T1 are (safely) statically casted into T2. * * An itk::RangeError exception instance is thrown if lengths/sizes of * both the containers are not equal. * * N.B.: Caller must ensure to that size N of itk::FixedArray< T1, N > * to match the variable size of the itk::VariableLengthVector< T1 >. */ template< typename T2, unsigned int N, typename T1 > inline itk::FixedArray< T2, N > ToFixedArray( const itk::VariableLengthVector< T1 >& v ); /** * Convert an itk::VariableLengthVector< T2 > into a * itk::FixedArray< T1, N >. * * Elements of type T1 are (safely) statically casted into T2. * * An itk::RangeError exception instance is thrown if lengths/sizes of * both the containers are not equal. * * N.B.: Caller must ensure to that size N of itk::FixedArray< T1, N > * to match the variable size of the itk::VariableLengthVector< T1 >. */ template< typename T2, unsigned int N, typename T1 > inline itk::FixedArray< T2, N >& ToFixedArray( itk::FixedArray< T2, N >& a, const itk::VariableLengthVector< T1 >& v ); /** * Convert an itk::FixedArray< T2, N > into a * itk::VariableLengthVector< T1 >. * * Elements of type T1 are (safely) statically casted into T2. * * An itk::RangeError exception instance is thrown if lengths/sizes of * both the containers are not equal. */ template< typename T2, typename T1, unsigned int N > inline itk::VariableLengthVector< T2 > ToVariableLengthVector( const itk::FixedArray< T1, N >& a ); /** * Convert an itk::FixedArray< T2, N > into a * itk::VariableLengthVector< T1 >. * * Elements of type T1 are (safely) statically casted into T2. * * An itk::RangeError exception instance is thrown if lengths/sizes of * both the containers are not equal. */ template< typename T2, typename T1, unsigned int N > inline itk::VariableLengthVector< T2 >& ToVariableLengthVector( itk::FixedArray< T1, N >& a, const itk::VariableLengthVector< T1 >& v ); } // end namespace 'otb' /*****************************************************************************/ namespace mvd { /** * \brief Write an itk::VariableLengthVector< T > into a QTextStream. * * \param stream QTextStream into which to write data. * \param vector itk::VariableLengthVector< T > data to write. * * \return stream instance. */ template< typename T > inline QTextStream& operator << ( QTextStream& stream, const itk::VariableLengthVector< T >& vector ); /** * \brief Write an itk::VariableLengthVector< T > into a QTextStream. * * \param stream QTextStream into which to write data. * \param vector itk::VariableLengthVector< T > data to write. * * \return stream instance. */ template< typename T > inline QTextStream& operator >> ( QTextStream& stream, itk::VariableLengthVector< T >& vector ); /** * \brief Write an itk::VariableLengthVector< T > into a QDataStream. * * \param stream QDataStream into which to write data. * \param vector itk::VariableLengthVector< T > data to write. * * \return stream instance. */ template< typename T > inline QDataStream& operator << ( QDataStream& stream, const itk::VariableLengthVector< T >& vector ); /** * \brief Write an itk::VariableLengthVector< T > into a QDataStream. * * \param stream QDataStream into which to write data. * \param vector itk::VariableLengthVector< T > data to write. * * \return stream instance. */ template< typename T > inline QDataStream& operator >> ( QDataStream& stream, itk::VariableLengthVector< T >& vector ); /** * \brief Convert a StringVector object to a QStringList object. * * Because Qt uses a shallow mechanism to copy containers, the returned * QStringList is shallow-copied. */ inline QStringList ToQStringList( const StringVector& sv ); /** * \brief Append the content of a StringVector object to the content * of a QStringList object. * * Because Qt uses a shallow mechanism to copy containers, the returned * QStringList is shallow-copied. */ inline QStringList& AppendToQStringList( QStringList& qsl, const StringVector& sv ); /** * \brief Convert and copy an STL std::string to a QString. * * The 8-bit data is converted to Unicode using the * QString::fromAscii() method. * * \param str The 8-bit STL string to convert. * * \return The Unicode converted QString. */ inline QString FromStdString( const std::string& str ); /** */ inline std::string ToLocalStdString( const QString & ); /** */ inline const char * ToLocalString( const QString & ); /** * \brief Convert and copy a QString to a STL std::string. * * The Unicode data is converted to 8-bit using the QString::toAscii() * method. * * \param str The Unicode string to convert. * * \return The 8-bit converted STL std::string. */ inline std::string ToStdString( const QString& str ); /** */ inline const char* ToString( const QString& str ); /** * \return a std::string form various types. */ inline std::string ToStdString( unsigned int val ); inline std::string ToStdString( const SpacingType & spacing); inline std::string ToStdString( const SizeType & size); inline std::string ToStdString( const PointType & point); template< typename T> std::string ToStdString( const std::vector & vec); /** */ template< typename T > inline QString ToQString( const T& val ); /** */ template<> inline QString ToQString< float >( const float& ); /** */ template<> inline QString ToQString< double >( const double& ); /** */ inline QString ToHumanReadableSize( qint64 fize, bool isInBits =true ); } // end namespace 'mvd'. /*****************************************************************************/ namespace mvd { /** * \brief Test condition on all elements in range. * * \param first First element of range to test. * \param last Upper (external) boundary of range to test. * \param pred Predicate testing element in range. * * \return true if predicate is true on all elements in the range * [first, last[ or if range is empty. */ template< typename TInputIterator, typename TUnaryPredicate > inline bool AllOf( TInputIterator first, TInputIterator last, TUnaryPredicate pred ); /** * \brief Test if any of element in range fulfills condition. * * \param first First element of range to test. * \param last Upper (external) boundary of range to test. * \param pred Predicate testing element in range. * * \return true if predicated is true for, at least, one element in range * [first, last[. If range is empty, this function returns false. */ template< typename TInputIterator, typename TUnaryPredicate > inline bool AnyOf( TInputIterator first, TInputIterator last, TUnaryPredicate pred ); /** * \brief Test if no element in range fulfills condition. * * \param first First element of range to test. * \param last Upper (external) boundary of range to test. * \param pred Predicate testing element in range. * * \return true if predicated is false for all elements in range [first, last[. If range is empty, this function returns true. */ template< typename TInputIterator, typename TUnaryPredicate > inline bool NoneOf( TInputIterator first, TInputIterator last, TUnaryPredicate pred ); } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace otb { /*******************************************************************************/ template< typename T2, unsigned int N, typename T1 > inline itk::FixedArray< T2, N > ToFixedArray( const itk::VariableLengthVector< T1 >& v ) { assert( v.Size()==N ); throw itk::RangeError( __FILE__, __LINE__ ); itk::FixedArray< T2, N > a; for( unsigned int i=0; i( v[ i ] ); return a; } /*******************************************************************************/ template< typename T2, unsigned int N, typename T1 > inline itk::FixedArray< T2, N >& ToFixedArray( itk::FixedArray< T2, N >& a, const itk::VariableLengthVector< T1 >& v ) { assert( v.Size()==N && v.Size()==a.Size() ); throw itk::RangeError( __FILE__, __LINE__ ); for( unsigned int i=0; i( v[ i ] ); return a; } /*******************************************************************************/ template< typename T2, typename T1, unsigned int N > inline itk::VariableLengthVector< T2 > ToVariableLengthVector( const itk::FixedArray< T1, N >& a ) { assert( a.Size()==N ); throw itk::RangeError( __FILE__, __LINE__ ); itk::VariableLengthVector< T2 > v; v.Reserve( N ); for( unsigned int i=0; i( a[ i ] ); return v; } /*******************************************************************************/ template< typename T2, typename T1, unsigned int N > inline itk::VariableLengthVector< T2 >& ToVariableLengthVector( itk::VariableLengthVector< T2 >& v, const itk::FixedArray< T1, N >& a ) { assert( a.Size()==N ); throw itk::RangeError( __FILE__, __LINE__ ); v.Reserve( N ); for( unsigned int i=0; i( a[ i ] ); return v; } } // end namespace 'otb'. namespace mvd { /*******************************************************************************/ inline QStringList ToQStringList( const StringVector& sv ) { QStringList qsl; return AppendToQStringList( qsl, sv ); } /*******************************************************************************/ inline QStringList& AppendToQStringList( QStringList& qsl, const StringVector& sv ) { for( StringVector::const_iterator it( sv.begin() ); it!=sv.end(); ++ it ) { qsl.append( QString(it->c_str()) ); } return qsl; } /*******************************************************************************/ inline std::string ToLocalStdString( const QString & str ) { return std::string( str.toLocal8Bit().constData() ); } /*******************************************************************************/ inline const char * ToLocalString( const QString & str ) { return str.toLocal8Bit().constData(); } /*******************************************************************************/ inline QString FromStdString( const std::string& str ) { return QString( str.c_str() ); } /*******************************************************************************/ inline std::string ToStdString( const QString& str ) { return std::string( str.toAscii().constData() ); } /*******************************************************************************/ inline const char* ToString( const QString& str ) { return str.toAscii().constData(); } /*******************************************************************************/ inline std::string ToStdString( unsigned int val ) { std::ostringstream oss; oss << val; return oss.str(); } /*******************************************************************************/ inline std::string ToStdString( const SpacingType & spacing) { std::ostringstream oss; oss << spacing[0] << " , " << spacing[1]; return oss.str(); } /*******************************************************************************/ inline std::string ToStdString( const SizeType & size) { std::ostringstream oss; oss << size[0] << " , " << size[1]; return oss.str(); } /*******************************************************************************/ inline std::string ToStdString( const PointType & point) { std::ostringstream oss; oss << point[0] << " , " << point[1]; return oss.str(); } /*******************************************************************************/ template< typename T> inline std::string ToStdString( const std::vector & vec) { std::ostringstream oss; typename std::vector::const_iterator it = vec.begin(); while( it != vec.end() ) { oss<<*it<< " "; ++it; } return oss.str(); } /*******************************************************************************/ template< typename T > inline QString ToQString( const T& val ) { return QString( "%1" ).arg( val ); } /*****************************************************************************/ template<> inline QString ToQString< float >( const float& val ) { assert( !std::isnan( val ) ); QString valf; // See IEEE-754 // Ref. http://en.wikipedia.org/wiki/Single-precision_floating-point_format valf.sprintf( "%.9g", val ); #if 0 std::cout << "ToString< float >(" << val << "): " << ToStdString( valf ) << "\t" << valf.toFloat() << std::endl; #endif if( valf.toFloat()!=val ) throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::DatasetDescritor", "Accuracy loss when converting float (%1) to string." ) .arg( valf ) ) ); return valf; } /*****************************************************************************/ template<> inline QString ToQString< double >( const double& val ) { assert( !std::isnan( val ) ); QString vald; // See IEEE-754 // Ref. http://en.wikipedia.org/wiki/Double_precision vald.sprintf( "%.17g", val ); #if 0 std::cout << "ToString< double >(" << val << "): " << ToStdString( vald ) << "\t" << vald.toDouble() << std::endl; #endif if( vald.toDouble()!=val ) throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::DatasetDescriptor", "Accuracy loss when converting double (%1) to string." ) .arg( vald ) ) ); return vald; } } // end namespace 'mvd' namespace mvd { /*******************************************************************************/ template< typename TInputIterator, typename TUnaryPredicate > inline bool AllOf( TInputIterator first, TInputIterator last, TUnaryPredicate pred ) { while( first!=last ) { if( !pred( *first ) ) return false; ++first; } return true; } /*******************************************************************************/ template< typename TInputIterator, typename TUnaryPredicate > inline bool AnyOf( TInputIterator first, TInputIterator last, TUnaryPredicate pred ) { while( first!=last ) { if( pred( *first ) ) return true; ++first; } return false; } /*******************************************************************************/ template< typename TInputIterator, typename TUnaryPredicate > inline bool NoneOf( TInputIterator first, TInputIterator last, TUnaryPredicate pred ) { while( first!=last ) { if( pred( *first ) ) return false; ++first; } return true; } /*******************************************************************************/ inline QString ToHumanReadableSize( qint64 size, bool isInBits ) { double thousand = isInBits ? 1024.0 : 1000.0; double remainder = static_cast< double >( size ); if( size < thousand ) return QString::number( size ); remainder /= thousand; if( remainder < thousand ) return QString("%1 KiB" ).arg( QString::number( remainder, 'g', 3 ) ); remainder /= thousand; if( remainder < thousand ) return QString("%1 MiB" ).arg( QString::number( remainder, 'g', 3 ) ); remainder /= thousand; if( remainder < thousand ) return QString("%1 GiB" ).arg( QString::number( remainder, 'g', 3 ) ); remainder /= thousand; return QString("%1 TiB" ).arg( QString::number( remainder, 'g', 3 ) ); } } // end namespace 'mvd' #endif // mvdAlgorithm_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdApplicationsBrowser.h000066400000000000000000000120401301006202600311060ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdApplicationsBrowser_h #define mvdApplicationsBrowser_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ApplicationsBrowser * * \ingroup OTBMonteverdiCore * * \brief Search for available applications in a directory. * * This class provides the functionnalities to look for * otbWrapperApplication apps in a given directory. The method used to * set the directory is SetAutoLoadPath(const std::string &). * * If applications are available in the directory set by the user, * tags of each application are extracted. * * An association application-tags is then setup and stored in a * std::vector to be sent (via a signal) to the * mvd::ApplicationsToolBox or any widget or class connected to this * signal. * */ class OTBMonteverdiCore_EXPORT ApplicationsBrowser : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** typedef */ /** \brief Constructor. */ ApplicationsBrowser( QObject* p =NULL ); /** \brief Destructor. */ ~ApplicationsBrowser() ITK_OVERRIDE; /** set the path where to look for applications */ void SetAutoLoadPath(const std::string & itk_auto_load_path); /** get available applications in the search path */ StringVector GetAvailableApplications(); /** return the list applications <->tags */ StringVector GetApplicationTags(const std::string& appName); /** return std::map storing tag/apps association for all the * applications in the search path */ void SearchAvailableApplicationsTags(); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: void AvailableApplicationsTagsChanged(const ApplicationsTagContainer &, const ApplicationDocNameToNameMap &); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: std::string m_AutoLoadPath; ApplicationDocNameToNameMap m_DocNameToNameMap; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdApplicationsBrowser_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdBackgroundTask.h000066400000000000000000000077671301006202600300420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdBackgroundTask_h #define mvdBackgroundTask_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractWorker; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class BackgroundTask * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT BackgroundTask : public QThread { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor. */ BackgroundTask( AbstractWorker* worker, bool autoDestroy =true, QObject* p =NULL ); /** * \brief Destructor. */ ~BackgroundTask() ITK_OVERRIDE; /** */ inline const AbstractWorker* GetWorker() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /** */ AbstractWorker* m_Worker; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void OnObjectDestroyed( QObject* object ); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline const AbstractWorker* BackgroundTask::GetWorker() const { return m_Worker; } } // end namespace 'mvd' #endif // mvdBackgroundTask_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdCore.h000066400000000000000000000230501301006202600260070ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdCore_h #define mvdCore_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } // // Internal classes pre-declaration. namespace mvd { } // end namespace 'mvd' /*****************************************************************************/ /* TYPE DEFINITION SECTION */ namespace mvd { /** * Constants identifying the video-channels. */ enum RgbwChannel { RGBW_CHANNEL_NONE = -1, RGBW_CHANNEL_RED = 0, RGBW_CHANNEL_GREEN, RGBW_CHANNEL_BLUE, RGBW_CHANNEL_WHITE, RGBW_CHANNEL_RGB, RGBW_CHANNEL_ALL, RGBW_CHANNEL_COUNT, }; /** * Constant naming video-channels. */ extern OTBMonteverdiCore_EXPORT const char* RGBW_CHANNEL_NAMES[ RGBW_CHANNEL_COUNT ]; /** */ enum Bound { BOUND_LOWER = 0, BOUND_UPPER, BOUND_COUNT }; /** * Constant naming bound values. */ extern const char* BOUND_NAMES[ BOUND_COUNT ]; /** */ enum Effect { EFFECT_NONE = -1, // EFFECT_CHESSBOARD = 0, EFFECT_GRADIENT, EFFECT_LOCAL_CONTRAST, EFFECT_LOCAL_TRANSLUCENCY, EFFECT_NORMAL, EFFECT_SPECTRAL_ANGLE, EFFECT_SWIPE_H, EFFECT_SWIPE_V, // EFFECT_COUNT }; /** * Constant naming effect values. */ OTBMonteverdiCore_EXPORT extern char const * const EFFECT_NAMES[ EFFECT_COUNT ]; /** */ OTBMonteverdiCore_EXPORT extern bool OVERVIEWS_ENABLED_DEFAULT; /** */ OTBMonteverdiCore_EXPORT extern int OVERVIEWS_SIZE_DEFAULT; } // end of namespace mvd. /*****************************************************************************/ /* FUNCTION DECLARATION SECTION */ namespace mvd { /** * \brief Convenience method used to compute integer indices in order * to iterate through RGB channels such as, for example: * \code * for( i=begin; i=3 ); QStringList V1List( v1.split( "." ) ); assert( V1List.size()>=3 ); return V0List[ 0 ].toInt() < V1List[ 0 ].toInt() || ( V0List[ 0 ].toInt() == V1List[ 0 ].toInt() && V0List[ 1 ].toInt() < V1List[ 1 ].toInt() ) || ( V0List[ 1 ].toInt() == V1List[ 1 ].toInt() && V0List[ 2 ].toInt() < V1List[ 2 ].toInt() ); } /*****************************************************************************/ inline bool IsVersionEqual( const QString& v0, const QString& v1 ) { QStringList V0List( v0.split( "." ) ); assert( V0List.size()>=3 ); QStringList V1List( v1.split( "." ) ); assert( V1List.size()>=3 ); return V0List[ 0 ].toInt() == V1List[ 0 ].toInt() && V0List[ 1 ].toInt() == V1List[ 1 ].toInt() && V0List[ 2 ].toInt() == V1List[ 2 ].toInt(); } /*****************************************************************************/ inline bool IsVersionGreaterEqual( const QString& v0, const QString& v1 ) { QStringList V0List( v0.split( "." ) ); assert( V0List.size()>=3 ); QStringList V1List( v1.split( "." ) ); assert( V1List.size()>=3 ); return V0List[ 0 ].toInt() > V1List[ 0 ].toInt() || ( V0List[ 0 ].toInt() == V1List[ 0 ].toInt() && V0List[ 1 ].toInt() > V1List[ 1 ].toInt() ) || ( V0List[ 1 ].toInt() == V1List[ 1 ].toInt() && V0List[ 2 ].toInt() >= V1List[ 2 ].toInt() ); } } // end namespace 'mvd'. #endif // mvdCore_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdDataStream.h000066400000000000000000000161221301006202600271460ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdDataStream_h #define mvdDataStream_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include #endif //tag=QT4-boost-compatibility // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAlgorithm.h" #include "mvdSystemError.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace mvd { // // Internal classes pre-declaration. } // end of namespace 'mvd'. /** */ #define DATA_STREAM_OUT( ostream, T, pointer ) \ { \ size_t size = sizeof( T const * ); \ \ int count = \ ostream.writeRawData( \ reinterpret_cast< char const * >( &pointer ), \ size \ ); \ \ if( false ) \ qDebug() \ << "Written" << count << "byte(s) as" << typeid( T ).name() \ << "address" << pointer << "size" << size; \ \ if( static_cast< size_t >( count )!=size ) \ throw \ mvd::SystemError( \ mvd::ToStdString( \ QString( "Error when writing %1 pointer to QDataStream." ) \ .arg( typeid( T ).name() ) \ ) \ ); \ } /** */ #define DATA_STREAM_IN( istream, T, pointer ) \ { \ size_t size = sizeof( T * ); \ \ int count = \ istream.readRawData( \ reinterpret_cast< char * >( &pointer ), size ); \ \ if( false ) \ qDebug() \ << "Read" << count << "byte(s) as" << typeid( T ).name() \ << "address" << pointer << "size" << size; \ \ if( static_cast< size_t >( count )!=size ) \ throw \ mvd::SystemError( \ mvd::ToStdString( \ QString( "Error when reading %1 pointer from QDataStream." ) \ .arg( typeid( T ).name() ) \ ) \ ); \ } /*****************************************************************************/ /* FUNCTIONS DECLARATION. */ /** */ QDataStream& operator << ( QDataStream& out, void const * & pointer ); /** */ QDataStream& operator >>( QDataStream& in, void * & pointer ); /** */ #define DATA_STREAM_USE_TEMPLATE_OPERATORS 1 #if DATA_STREAM_USE_TEMPLATE_OPERATORS /** */ template< typename T > inline QDataStream& operator << ( QDataStream& out, T const * & pointer ); /** */ template< typename T > inline QDataStream& operator >>( QDataStream& in, T * & pointer ); #endif // DATA_STREAM_USE_TEMPLATE_OPERATORS namespace mvd { } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ #if DATA_STREAM_USE_TEMPLATE_OPERATORS /*****************************************************************************/ template< typename T > inline QDataStream& operator << ( QDataStream& out, T const * & pointer ) { /* qDebug() << "template< T > " "QDataStream& operator << ( QDataStream&, T const * & ); " "with [ T =" << typeid( T ).name() << "]"; */ DATA_STREAM_OUT( out, T, pointer ); return out; } /*****************************************************************************/ template< typename T > inline QDataStream& operator >>( QDataStream& in, T * & pointer ) { /* qDebug() << "template< T > " "QDataStream& operator >> ( QDataStream&, T * & ); " "with [ T =" << typeid( T ).name() << "]"; */ DATA_STREAM_IN( in, T, pointer ); return in; } #endif // DATA_STREAM_USE_TEMPLATE_OPERATORS namespace mvd { } // end namespace 'mvd' #endif // mvdDataStream_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdFilenameInterface.h000066400000000000000000000065761301006202600304760ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdFilenameInterface_h #define mvdFilenameInterface_h #include "OTBMonteverdiCoreExport.h" // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class FilenameInterface * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT FilenameInterface { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Destructor. */ virtual ~FilenameInterface(); /** */ const QString & GetFilename() const; /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ FilenameInterface(); /** */ void SetFilename( const QString & ); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ void virtual_SetFilename( const QString & ) {} // // Private attributes. private: /** */ QString m_Filename; }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdFilenameInterface_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdHistogramModel.h000066400000000000000000000460201301006202600300370ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdHistogramModel_h #define mvdHistogramModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkHistogram.h" #endif //tag=QT4-boost-compatibility // // OTB includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbObjectList.h" #endif //tag=QT4-boost-compatibility // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractModel.h" #include "mvdAlgorithm.h" #include "mvdCore.h" #include "mvdSerializableInterface.h" #endif //tag=QT4-boost-compatibility #define HISTOGRAM_CURVE_TYPE 2 #define USE_FULL_IMAGE_FOR_PASS_1 0 /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { namespace { } // // Internal classes pre-declaration. class AbstractImageModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class HistogramModel * * \ingroup OTBMonteverdiCore */ class OTBMonteverdiCore_EXPORT HistogramModel : public AbstractModel, private SerializableInterface { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types & constants. public: /** */ static const int PRECISION = 4; /** */ typedef // itk::NumericTraits< T >::FloatType and // itk::NumericTraits< T >::RealType do not depend on template // parameter T. They are always typedef, respectively, as float // and double. // // So, itk::NumericTraits< DefaultImageType::InternalPixelType // >::RealType is equivalent to itk::NumericTraits< float // >::RealType which is always an alias of double. // // This typedef is used for compatibility with // itk::Histogram<>::MeasurementType. itk::NumericTraits< DefaultImageType::InternalPixelType >::RealType RealType; /** */ typedef RealType MeasurementType; /** * \class BuildContext * \brief WIP. * \ingroup OTBMonteverdiCore */ class BuildContext { // // Public methods. public: /** \brief Constructor. */ BuildContext( bool isBeingStored, const QString& filename =QString() ) : m_Filename( filename ), m_IsBeingStored( isBeingStored ) { } /** */ inline bool IsBeingStored() const { return m_IsBeingStored; } // // Public attributes public: QString m_Filename; private: bool m_IsBeingStored; }; // // Public methods. public: /** */ static RealType GetEpsilon(); /** \brief Constructor. */ HistogramModel( QObject* p =NULL ); /** \brief Destructor. */ ~HistogramModel() ITK_OVERRIDE; /** */ bool IsValid() const; /** */ bool IsMonoValue() const; /** */ MeasurementType Quantile( CountType band, double p ) const; /** */ MeasurementType Quantile( CountType band, double p, Bound bound ) const; /** */ double Percentile( CountType band, MeasurementType intensity, Bound bound ) const; /** */ inline VectorPixelType GetMinPixel() const; /** */ inline VectorPixelType GetMaxPixel() const; /** */ inline size_t GetDataCount( CountType band ) const; /** */ void GetData( CountType band, double * const x, double * const y, double& xMin, double& xMax, double& yMin, double& yMax ) const; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // AbstractModel methods. /** */ void virtual_BuildModel( void* context =NULL ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private constants. private: // // Private types. private: /** */ typedef itk::Statistics::Histogram< MeasurementType > Histogram; /** */ typedef otb::ObjectList< Histogram > HistogramList; // // Private methods. private: /** */ /* template< typename TImage > void template_BuildModel_I(); */ /** */ template< typename TImageModel > void template_BuildModel_M( BuildContext * =NULL ); // // SerializableInterface methods. // void virtual_Read( QIODevice* device ) ITK_OVERRIDE; void virtual_Write( QIODevice& device ) const ITK_OVERRIDE; // // Private attributes. private: /** */ HistogramList::Pointer m_Histograms; /** */ DefaultImageType::PixelType m_MinPixel; /** */ DefaultImageType::PixelType m_MaxPixel; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbStreamingHistogramVectorImageFilter.h" #include "otbStreamingMinMaxVectorImageFilter.h" #include "otbStreamingStatisticsVectorImageFilter.h" #endif //tag=QT4-boost-compatibility // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractImageModel.h" #endif //tag=QT4-boost-compatibility namespace mvd { /*******************************************************************************/ inline DefaultImageType::PixelType HistogramModel ::GetMinPixel() const { return m_MinPixel; } /*******************************************************************************/ inline DefaultImageType::PixelType HistogramModel ::GetMaxPixel() const { return m_MaxPixel; } /*******************************************************************************/ inline size_t HistogramModel ::GetDataCount( CountType band ) const { // Get histogram of band. Histogram::Pointer histogram( m_Histograms->GetNthElement( band ) ); assert( !histogram.IsNull() ); // Get number of bins for each dimension. Histogram::SizeType size( histogram->GetSize() ); // Ensure dimension is 1. assert( histogram->GetMeasurementVectorSize()==1 ); // There are twince number of points than number of bins. #if HISTOGRAM_CURVE_TYPE==0 return 2 * size[ 0 ]; #elif HISTOGRAM_CURVE_TYPE==1 return size[ 0 ]; #elif HISTOGRAM_CURVE_TYPE==2 return 4 * size[ 0 ]; #else assert( false && "Unknown HISTOGRAM_CURVE_TYPE value" ); #endif } /*******************************************************************************/ /* template< typename TImage > void HistogramModel ::template_BuildModel_I() { QTime lMain; QTime lPass1; QTime lPass2; lMain.start(); qDebug() << tr( "%1: Generating histogram (I)..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); AbstractImageModel* imageModel = qobject_cast< AbstractImageModel* >( parent() ); assert( imageModel!=NULL ); // // 1st pass: process min/MAX for each band. qDebug() << tr( "%1: Pass #1 - finding pixel min/maxes..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); lPass1.start(); // Connect min/MAX pipe-section. typedef otb::StreamingMinMaxVectorImageFilter< TImage > MinMaxFilter; typename MinMaxFilter::Pointer filterMinMax( MinMaxFilter::New() ); filterMinMax->SetInput( // otb::DynamicCast< TImage >( imageModel->ToImageBase() ) imageModel->ToImageBase() ); filterMinMax->Update(); // Extract-convert-remember min/MAX intensities for each band. m_MinPixel = filterMinMax->GetMinimum(); m_MaxPixel = filterMinMax->GetMaximum(); qDebug() << tr( "%1: Pass #1 - done (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lPass1.elapsed() ); // // 2nd pass: compute histogram. qDebug() << tr( "%1: Pass #2 - computing histogram..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); lPass2.start(); // Connect histogram-generator pipe-section. typedef otb::StreamingHistogramVectorImageFilter< TImage > HistogramFilter; typename HistogramFilter::Pointer histogramFilter( HistogramFilter::New() ); histogramFilter->SetInput( // otb::DynamicCast< TImage >( imageModel->ToImageBase() ) imageModel->ToImageBase() ); // Setup histogram filter. histogramFilter->GetFilter()->SetHistogramMin( m_MinPixel ); histogramFilter->GetFilter()->SetHistogramMax( m_MaxPixel ); histogramFilter->SetNumberOfBins( HistogramModel::BINS_OVERSAMPLING_RATE * 256 ); histogramFilter->GetFilter()->SetSubSamplingRate( 1 ); // Go. histogramFilter->Update(); qDebug() << tr( "%1: Pass #2 - done (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lPass2.elapsed() ); // // Reference result. m_Histograms = histogramFilter->GetHistogramList(); qDebug() << tr( "%1: Histogram (I) generated (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lMain.elapsed() ); } */ /*******************************************************************************/ template< typename TImageModel > void HistogramModel ::template_BuildModel_M( BuildContext * ) { QTime lMain; QTime lPass1; QTime lPass2; lMain.start(); qDebug() << tr( "%1: Generating histogram (M)..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); #if USE_FULL_IMAGE_FOR_PASS_1 TImageModel * parentImageModel = qobject_cast< TImageModel * >( parent() ); #else // USE_FULL_IMAGE_FOR_PASS_1 AbstractImageModel * parentImageModel = qobject_cast< AbstractImageModel* >( parent() ); #endif // USE_FULL_IMAGE_FOR_PASS_1 assert( parentImageModel!=NULL ); ImageProperties * imageProperties = parentImageModel->GetProperties(); assert( imageProperties!=NULL ); TImageModel * imageModel = parentImageModel->GetQuicklookModel(); if( imageModel==NULL ) imageModel = qobject_cast< TImageModel * >( parentImageModel ); assert( imageModel!=NULL ); CountType components = imageModel->ToImage()->GetNumberOfComponentsPerPixel(); assert( components>0 ); // Always initialize min and Max pixels. m_MinPixel = DefaultImageType::PixelType( components ); m_MaxPixel = DefaultImageType::PixelType( components ); m_MinPixel.Fill( 0 ); m_MaxPixel.Fill( 1 ); try { // 1st pass: process min/MAX for each band. qDebug() << QString( "%1: Pass #1 - finding pixel min/maxes..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); lPass1.start(); // Define histogram-filter type. typedef otb::StreamingHistogramVectorImageFilter< typename TImageModel::SourceImageType > HistogramFilter; // Connect statistics pipe-section. typedef otb::StreamingStatisticsVectorImageFilter< typename TImageModel::SourceImageType > StatisticsFilter; typename StatisticsFilter::Pointer filterStats( StatisticsFilter::New() ); #if USE_FULL_IMAGE_FOR_PASS_1 filterStats->SetInput( parentImageModel->ToImage() ); #else // USE_FULL_IMAGE_FOR_PASS_1 filterStats->SetInput( imageModel->ToImage() ); #endif // USE_FULL_IMAGE_FOR_PASS_1 filterStats->SetEnableMinMax( true ); filterStats->SetIgnoreUserDefinedValue( imageProperties->IsNoDataEnabled() ); filterStats->SetUserIgnoredValue( imageProperties->GetNoData() ); // Connect statistics pipe-section. filterStats->Update(); // qDebug() << "min:" << m_MinPixel << "max:" << m_MaxPixel; // std::cout << "min:" << m_MinPixel << "\tmax:" << m_MaxPixel << std::endl; // Extract-convert-remember min/MAX intensities for each band. m_MinPixel = filterStats->GetMinimum(); m_MaxPixel = filterStats->GetMaximum(); // Define corrected min/MAX pixels. DefaultImageType::PixelType minPixel( m_MinPixel ); DefaultImageType::PixelType maxPixel( m_MaxPixel ); // Extract sigmas for each band from covariance matrix. typename StatisticsFilter::MatrixType covariance( filterStats->GetFilter()->GetCovariance() ); typename HistogramFilter::FilterType::CountVectorType bins( components ); typename StatisticsFilter::RealPixelType sums( filterStats->GetSum() ); typename StatisticsFilter::RealPixelType means( filterStats->GetMean() ); for( CountType i=0; i= 0.0 ); if( sigma<=0.0 ) { bins[ i ] = 1; } else { // Scott's formula // See http://en.wikipedia.org/wiki/Histogram#Number_of_bins_and_width RealType h = 3.5 * sigma / pow( n, 1.0 / 3.0 ); /* qDebug() << "#" << i << ": h = pow(" << n << "," << 1.0 / 3.0 << ") =" << h; qDebug() << "#" << i << ": bins[" << i << "] = ceil( (" << m_MaxPixel[ i ] << "-" << m_MinPixel[ i ] << ") / " << h << ") =" << ceil( ( m_MaxPixel[ i ] - m_MinPixel[ i ] ) / h ); */ bins[ i ] = ceil( ( maxPixel[ i ] - minPixel[ i ] ) / h ); // at least 1 bin is needed bins[i] = std::max(bins[i],1U); } } // MANTIS-1275 // { if( minPixel[ i ]==maxPixel[ i ] ) { double epsilon = HistogramModel::GetEpsilon(); // make sure the epsilon is not hidden when using large values if( boost::is_floating_point< DefaultImageType::PixelType::ValueType >::value ) { double absValue = vcl_abs(minPixel[i]); // compute smallest epsilon for absolute pixel value (1.5 factor is for safety) double limitEpsilon = absValue * (double)std::numeric_limits::epsilon() * 1.5; epsilon = std::max(epsilon,limitEpsilon); } double lowerBound; // With C++11, we can use std::numeric_limits<>::lowest() if( boost::is_floating_point< DefaultImageType::PixelType::ValueType >::value ) { lowerBound = epsilon - std::numeric_limits< DefaultImageType::PixelType::ValueType >::max(); } else { lowerBound = std::numeric_limits< DefaultImageType::PixelType::ValueType >::min() + epsilon; } double upperBound = std::numeric_limits< DefaultImageType::PixelType::ValueType >::max() - epsilon; if( minPixel[ i ] >= lowerBound ) minPixel[ i ] -= epsilon; if( maxPixel[ i ] <= upperBound ) maxPixel[ i ] += epsilon; } // } // } // std::cout << "Number of bins : "<< bins << std::endl; qDebug() << QString( "%1: Pass #1 - done (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lPass1.elapsed() ); // // 2nd pass: compute histogram. qDebug() << QString( "%1: Pass #2 - computing histogram..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); lPass2.start(); // Connect histogram-generator pipe-section. typename HistogramFilter::Pointer histogramFilter( HistogramFilter::New() ); histogramFilter->SetInput( imageModel->ToImage() ); // Setup histogram filter. histogramFilter->GetFilter()->SetHistogramMin( minPixel ); histogramFilter->GetFilter()->SetHistogramMax( maxPixel ); histogramFilter->GetFilter()->SetNumberOfBins( bins ); histogramFilter->GetFilter()->SetSubSamplingRate( 1 ); histogramFilter->GetFilter()->SetNoDataFlag( imageProperties->IsNoDataEnabled() ); histogramFilter->GetFilter()->SetNoDataValue( imageProperties->GetNoData() ); // Go. histogramFilter->Update(); qDebug() << QString( "%1: Pass #2 - done (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lPass2.elapsed() ); // // Reference result. m_Histograms = histogramFilter->GetHistogramList(); qDebug() << QString( "%1: Histogram (M) generated (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lMain.elapsed() ); } catch( const std::exception & ) { qWarning() << tr( "Zero relevant pixels found when computing histogram (probably because of no-data settings)" ); if( imageProperties->IsNoDataEnabled() ) { DefaultImageType::PixelType::ValueType value( imageProperties->GetNoData() ); m_MinPixel.Fill( value ); m_MaxPixel.Fill( value ); } qDebug() << QString( "%1: Pass #1 - aborted (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lPass1.elapsed() ); qDebug() << QString( "%1: Pass #2 - aborted (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lPass2.elapsed() ); qDebug() << QString( "%1: No Histogram (M) has been generated (%2 ms)." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( lMain.elapsed() ); } } } // end namespace 'mvd' #endif // mvdHistogramModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdI18nCoreApplication.h000066400000000000000000000407311301006202600306400ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdI18nCoreApplication_h #define mvdI18nCoreApplication_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAlgorithm.h" #include "mvdSystemError.h" #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility // // Macros. /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // Classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractModel; class DatasetModel; class VectorImageModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class I18nCoreApplication * * \ingroup OTBMonteverdiCore * * \brief The MVD2 core-application (which is different from * QCoreApplication). * * I18nCoreApplication do not derive from QCoreApplication to * prevent a dread diamong multiple inheritance scheme which could not * be resolved using virtual inheritance (because Qt is not designed * for). * * I18nCoreApplication does not derive from QApplication to * prevent package .../Common/Core to depend on QtGui package (which * would have broken the Common/Core-Common/Gui package layout). * * The dread diamond multiple inheritance scheme is solved using * aggregation. * * QCoreApplication is passed as argument of I18nCoreApplication * constructor. So, is user application must derive QApplication (to, * for example, provide sessio management), the specialized instance * can be passed as argument of constructor. */ class OTBMonteverdiCore_EXPORT I18nCoreApplication : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public constants & types. public: enum SettingsKey { SETTINGS_KEY_GEOID_PATH, SETTINGS_KEY_GEOID_PATH_ACTIVE, SETTINGS_KEY_OVERVIEWS_ENABLED, SETTINGS_KEY_OVERVIEWS_SIZE, SETTINGS_KEY_RESOLUTION, SETTINGS_KEY_RESULTS_DIR, SETTINGS_KEY_SRTM_DIR, SETTINGS_KEY_SRTM_DIR_ACTIVE, SETTINGS_KEY_TILE_SIZE, // SETTINGS_KEY_COUNT }; // // Public methods. public: /** * \brief Constructor. * * \param qtApp The parent Qt application of this MVD2 application. */ I18nCoreApplication( QCoreApplication* qtApp ); /** \brief Destructor. */ ~I18nCoreApplication() ITK_OVERRIDE; /** */ void Initialize(); // // APPLICATION SINGLETON. // /** * \brief Get the singleton instance of application as a * I18Application pointer. * * \return The singleton instance of I18nCoreApplication. */ inline static I18nCoreApplication* Instance(); /** * \brief Get the singleton constant instance of application as a * I18Application pointer. * * \return The singleton constant instance of I18nCoreApplication. */ inline static const I18nCoreApplication* ConstInstance(); // // APPLICATION MODEL. // /** * \brief Access the AbstractModel of the MVC which is managed by the * application. * * \return The managed AbstractModel. */ inline const AbstractModel* GetModel() const; /** * \brief Access the AbstractModel of the MVC which is managed by the * application. * * \return The managed AbstractModel. */ inline AbstractModel* GetModel(); /** * \brief Access the AbstractModel of the MVC which is managed by the * application and cast it into the given dynamic type. * * \return The managed TModel typename instance. */ template< typename TModel > inline const TModel* GetModel() const; /** * \brief Access the AbstractModel of the MVC which is managed by the * application and cast it into the given dynamic type. * * \return The managed TModel typename instance. */ template< typename TModel > inline TModel* GetModel(); // // APPLICATION CACHE-DIRECTORY. // /** * \brief setup elevation management * */ bool ElevationSetup(); // // APPLICATION SETTINGS. // /** */ // TODO: Move method into ApplicationSettings class. inline bool HasSettingsKey( SettingsKey ) const; /** */ // TODO: Move method into ApplicationSettings class. inline void StoreSettingsKey( SettingsKey, const QVariant& value ); /** */ // TODO: Move method into Application class. inline QVariant RetrieveSettingsKey( SettingsKey ) const; /** */ // TODO: Move method into ApplicationSettings class. inline bool HasSettingsKey( const QString & key ) const; /** */ // TODO: Move method into ApplicationSettings class. inline void StoreSettingsKey( const QString & key, const QVariant& value ); /** */ // TODO: Move method into Application class. inline QVariant RetrieveSettingsKey( const QString & key ) const; // // STATIC methods. // /** */ static bool IsResultsDirValid( const QString& path ); /** */ static bool IsDirValid( const QString& path ); /** * \brief Make directory tree in given path. * * Throws mvd::SystemError exception if sub-directory tree could not * have been created. * * \param path Location where to create sub-directory tree. * \param tree Sub-directory tree path. E.g.: 'level_1/level_2'. * \param dir resulting directory, if non-NULL. * * \return true if sub-directory tree is newly created or false if * it is already existing. */ static bool MakeDirTree( const QString& path, const QString& tree, QDir* dir =NULL ); /** * \brief Construct a consistent Dataset path-name. * * \param path Resulting path where the Dataset will be stored. * \param name Resulting name of the given Dataset. * \param imageFilename The image filename used to compute the path * and name of the Dataset. * * \return The MD5 hash-code generated from to full absolute * pathname of image file. */ static QString DatasetPathName( QString& name, const QString& imageFilename ); /** */ static VectorImageModel * LoadImageModel( const QString & filename, int width, int height, QObject * p =NULL ); /** */ static void DeleteDatasetModel( const QString & path, const QString & hash ); // // NON-STATIC methods. // /** * \brief Get the results directory (where output from * OTBApplicaitons are stored). * * \return Return the cache directory. */ inline const QDir& GetResultsDir() const; /** */ // TODO: Remove method when Viewer/Application is updated to reuse factorized code of I18nCoreApplication. inline QDir& GetResultsDir(); // // Public attributes. public: /** * Name of the cache directory */ static const char* DEFAULT_CACHE_DIR_NAME; /** * Name of the result cache directory */ static const char* DEFAULT_CACHE_RESULT_DIR_NAME; /** */ static const char* DATASET_EXT; /*-[ PUBLIC SLOTS SECTION ]-----------------------------------------------**/ public slots: /** * \brief Accessor used to changed model which is managed by the * Application. * * This method emits the AboutToChangeModel() and ModelChanged() * signals respectively, before and after, the model is changed. * * \param model The newly managed model. */ // Method could be inline but it's better not new/delete in inline // methods (heap and memory-alignment contexts). void SetModel( AbstractModel* model ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /** * \brief Signal emitted when the AbstractModel of the MVC is about * to be changed. * * This signal could be slotted in order to disconnect previously * managed model. * * \param model The newly managed model (previous model can still * be accessed using the GetModel() methods). */ void AboutToChangeModel( const AbstractModel* model ); /** * \brief Signal emitted when the AbstractModel of the MVC has been * changed. * * This signal coulb be slotted in order to connect newly managed * model. * * \param model The newly selected model. */ void ModelChanged( AbstractModel* model ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** * \brief Get the singleton instance of application (safe) casted * into the TApplication type. * * \return The singleton instance of application (safely) casted * into TApplication type. */ template< typename TApplication > inline static TApplication* Instance(); /** * \brief Get the constant singleton instance of application (safe) * casted into the TApplication type. * * \return The constant singleton instance of application (safely) * casted into TApplication type. */ template< typename TApplication > inline static const TApplication* ConstInstance(); /** */ void InitializeCore( const QString& appName, const QString& appVersion, const QString& orgName, const QString& orgDomain ); /** */ inline void SynchronizeSettings() const; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Static methods. // /** * \brief Handles Qt messages thrown by calls to qDebug(), * qWarning(), qCritical(), qFatal(). * * This is a callback method registered into Qt message handling * system. * * \param type Type of caught message. * \param message Content of caught message. */ static void HandleQtMessage( QtMsgType type, const char* message ); /** */ virtual void virtual_InitializeCore() =0; /** */ void InitializeLocale(); /** */ void InitializeSettings(); /** */ void LoadAndInstallTranslator( const QString& filename, const QString& directory =QString(), const QString& searchDelimiters =QString(), const QString& suffix =QString() ); // // Private attributes. private: /** */ static const char* SETTINGS_KEYS[ SETTINGS_KEY_COUNT ]; /** * \brief I18nCoreApplication singleton instance. */ static I18nCoreApplication* m_Instance; /** * \brief Directory where all result files from OTB applications are * stored */ QDir m_ResultsDir; /** * \brief Application settings */ QSettings * m_Settings; /** * \brief AbstractModel of the Model-View-Controller design pattern * which is managed by the application. */ AbstractModel* m_Model; /** */ bool m_IsRunningFromBuildDir; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // SLOTS private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ I18nCoreApplication* I18nCoreApplication ::Instance() { return I18nCoreApplication::m_Instance; } /*****************************************************************************/ const I18nCoreApplication* I18nCoreApplication ::ConstInstance() { return I18nCoreApplication::m_Instance; } /*****************************************************************************/ template< typename T > inline T* I18nCoreApplication ::Instance() { return qobject_cast< T* >( I18nCoreApplication::Instance() ); } /*****************************************************************************/ template< typename T > inline const T* I18nCoreApplication ::ConstInstance() { return qobject_cast< const T* >( I18nCoreApplication::ConstInstance() ); } /*****************************************************************************/ inline const AbstractModel* I18nCoreApplication ::GetModel() const { return m_Model; } /*****************************************************************************/ inline AbstractModel* I18nCoreApplication ::GetModel() { return m_Model; } /*****************************************************************************/ template< typename TModel > inline const TModel* I18nCoreApplication ::GetModel() const { return qobject_cast< const TModel* >( m_Model ); } /*****************************************************************************/ template< typename TModel > inline TModel* I18nCoreApplication ::GetModel() { return qobject_cast< TModel* >( m_Model ); } /*****************************************************************************/ const QDir& I18nCoreApplication ::GetResultsDir() const { return m_ResultsDir; } /*****************************************************************************/ QDir& I18nCoreApplication ::GetResultsDir() { return m_ResultsDir; } /*****************************************************************************/ inline bool I18nCoreApplication ::HasSettingsKey( SettingsKey key ) const { return HasSettingsKey( I18nCoreApplication::SETTINGS_KEYS[ key ] ); } /*****************************************************************************/ inline void I18nCoreApplication ::StoreSettingsKey( SettingsKey key, const QVariant & value ) { StoreSettingsKey( I18nCoreApplication::SETTINGS_KEYS[ key ], value ); } /*****************************************************************************/ inline QVariant I18nCoreApplication ::RetrieveSettingsKey( SettingsKey key ) const { return RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEYS[ key ] ); } /*****************************************************************************/ inline bool I18nCoreApplication ::HasSettingsKey( const QString & key ) const { assert( m_Settings!=NULL ); SynchronizeSettings(); return m_Settings->contains( key ); } /*****************************************************************************/ inline void I18nCoreApplication ::StoreSettingsKey( const QString & key, const QVariant& value ) { assert( m_Settings!=NULL ); // qDebug() << this << "::StoreSettingsKey(" << key << ", " << value << ")"; m_Settings->setValue( key, value ); SynchronizeSettings(); } /*****************************************************************************/ inline QVariant I18nCoreApplication ::RetrieveSettingsKey( const QString & key ) const { assert( m_Settings!=NULL ); SynchronizeSettings(); return m_Settings->value( key ); } /*****************************************************************************/ inline void I18nCoreApplication ::SynchronizeSettings() const { assert( m_Settings!=NULL ); m_Settings->sync(); switch( m_Settings->status() ) { case QSettings::NoError: // Ok. break; case QSettings::AccessError: throw SystemError( ToStdString( tr( "Cannot access settings file." ) ) ); break; case QSettings::FormatError: throw SystemError( ToStdString( tr( "Bad settings file format." ) ) ); break; default: // In case when a new enum value if added in the API. assert( false ); break; } } } // end namespace 'mvd' #endif // I18nCoreApplication_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdImageImporter.h000066400000000000000000000126001301006202600276620ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImageImporter_h #define mvdImageImporter_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractWorker.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImageImporter * * \ingroup OTBMonteverdiCore * * \brief Import image worker. It is parametrized by the image * filename and the desired (width, height) best-fit size. */ class OTBMonteverdiCore_EXPORT ImageImporter : public AbstractWorker { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor (dataset-model). * * \param filename Filename of image to import. * \param width Width of the best-fit size or -1 if none. * \param height Height of the best-fit size or -1 if none. * \param isForceCreateEnabled true to force creation of dataset. */ ImageImporter( const QString& filename, bool isForceCreateEnabled, int width =-1, int height =-1, QObject* p =NULL ); /** * \brief Constructor (image-model). * * \param filename Filename of image to import. * \param width Width of the best-fit size or -1 if none. * \param height Height of the best-fit size or -1 if none. * \param isForceCreateEnabled true to force creation of dataset. */ ImageImporter( const QString& filename, int width =-1, int height =-1, QObject* p =NULL ); /** * \brief Destructor. */ ~ImageImporter() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** * \brief Signal emitted when job/task has correctly been done. * * \param result Resulting QObject instance of NULL if none. */ //void Done( QObject* result =NULL ); /** * \brief Signal emitted when an exception has been caught by this worker. * * \param exc The copy (thread safety) exception which has been caught. */ //void ExceptionRaised( std::exception exc ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: enum ModelType { IMAGE, }; // // Private methods. private: // // AbstractWorker oveloads. QObject* virtual_Do() ITK_OVERRIDE; QString virtual_GetFirstProgressText() const ITK_OVERRIDE; // // Private attributes. private: /** */ QString m_Filename; /** */ ModelType m_ModelType; /** */ int m_Width; /** */ int m_Height; /** */ bool m_IsForceCreateEnabled: 1; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdImageImporter_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdImagePlacenameLoader.h000066400000000000000000000043711301006202600311030ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImagePlacenameLoader_h #define mvdImagePlacenameLoader_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include #include "OTBMonteverdiCoreExport.h" // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) // // External classes pre-declaration. namespace { } namespace mvd { // // Internal class pre-declaration. class VectorImageModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImagePlacenameLoader * * \ingroup OTBMonteverdiCore * * \brief * */ class OTBMonteverdiCore_EXPORT ImagePlacenameLoader : public QObject { Q_OBJECT; public: /** \brief Constructor */ ImagePlacenameLoader(VectorImageModel* model); public slots: /** \brief load the placename */ void LoadPlacename(); signals: /** \brief Triggered after a non empty placename was loaded */ void PlacenameLoaded( const QString& ); /** \brief Triggered when processing is finished */ void Finished(); private: VectorImageModel* m_Model; }; } // end namespace 'mvd' #endif // mvdImageModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdImageProperties.h000066400000000000000000000140421301006202600302170ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImageProperties_h #define mvdImageProperties_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImageProperties * * \ingroup OTBMonteverdiCore * * \brief WIP. */ #define IMAGE_PROPERTIES_IS_QOBJECT 0 class OTBMonteverdiCore_EXPORT ImageProperties #if IMAGE_PROPERTIES_IS_QOBJECT : public QObject #endif { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ #if IMAGE_PROPERTIES_IS_QOBJECT Q_OBJECT; Q_PROPERTY( bool isNoDataEnabled READ IsNoDataEnabled WRITE SetNoDataEnabled ); Q_PROPERTY( ComponentType NoData READ GetNoData WRITE SetNoData ); #endif /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ #if IMAGE_PROPERTIES_IS_QOBJECT ImageProperties( QObject* p =NULL ); #else ImageProperties(); #endif /** \brief Destructor. */ virtual ~ImageProperties(); /** */ inline bool IsModified() const; /** */ inline void ClearModified(); /* */ bool IsNoDataEnabled() const; /** */ inline void SetNoDataEnabled( bool enabled ); /** */ void SetNoData( ComponentType value = ComponentType( 0 ) ); /** */ inline ComponentType GetNoData() const; /** */ bool operator == ( const ImageProperties & ) const; /** */ bool operator != ( const ImageProperties & ) const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ inline void SetModified(); // // Private attributes. private: // // Group bitfield bool flags together. struct Flags { Flags() : m_IsModified( false ), m_NoData( false ) { } public: bool m_IsModified : 1; bool m_NoData : 1; }; /** */ Flags m_Flags; /** */ ComponentType m_NoData; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline bool ImageProperties ::IsModified() const { return m_Flags.m_IsModified; } /*****************************************************************************/ inline void ImageProperties ::SetModified() { m_Flags.m_IsModified = true; } /*****************************************************************************/ inline void ImageProperties ::ClearModified() { m_Flags.m_IsModified = false; } /*****************************************************************************/ inline void ImageProperties ::SetNoDataEnabled( bool enabled ) { m_Flags.m_NoData = enabled; SetModified(); } /*****************************************************************************/ inline void ImageProperties ::SetNoData( ComponentType value ) { m_NoData = value; SetModified(); } /*****************************************************************************/ inline bool ImageProperties ::IsNoDataEnabled() const { return m_Flags.m_NoData; } /*****************************************************************************/ inline ComponentType ImageProperties ::GetNoData() const { return m_NoData; } } // end namespace 'mvd' #endif // mvdImageProperties_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdImageSettings.h000066400000000000000000000165471301006202600276770ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImageSettings_h #define mvdImageSettings_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImageSettings * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT ImageSettings { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types & constants. public: /** */ typedef unsigned int SizeType; /** */ typedef double ValueType; // // Public methods. public: /** \brief Constructor. */ ImageSettings(); /** \brief Destructor. */ virtual ~ImageSettings(); /** */ inline bool IsApplied() const; /** */ inline bool IsModified() const; /** */ inline void ClearModified(); /** */ inline void SetApplied(); /** */ inline void SetEffect( Effect ); /** */ inline Effect GetEffect() const; /** */ const char * GetEffectName() const; /** */ inline bool HasSize() const; /** */ inline bool HasValue() const; /** */ inline void SetSize( unsigned int ); /** */ inline unsigned int GetSize() const; /** */ void SetValue( double ); /** */ double GetValue() const; /** */ inline const char * GetValueName() const; /** */ inline void SetAlpha( double ); /** */ inline double GetAlpha() const; /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** */ inline void SetModified(); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /** */ static char const * const EFFECT_VALUE_NAME[ EFFECT_COUNT ]; /** * \brief Flag which notices that rendering settings have been * edited. */ // TODO: Optimize using C++ bitset bool foo:1; bool m_IsModified: 1; /** * \brief Flag which notices that rendering settings have been * applied to display. */ // TODO: Optimize using C++ bitset bool foo:1; bool m_IsApplied: 1; /** */ Effect m_Effect; /** */ unsigned int m_Size; /** */ double m_Range; double m_Angle; /** */ double m_Alpha; }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline bool ImageSettings ::IsApplied() const { return m_IsApplied; } /*****************************************************************************/ inline bool ImageSettings ::IsModified() const { return m_IsModified; } /*****************************************************************************/ inline void ImageSettings ::SetModified() { // qDebug() << this << "::SetModified()"; m_IsModified = true; m_IsApplied = false; } /*****************************************************************************/ inline void ImageSettings ::ClearModified() { // qDebug() << this << "::ClearModified()"; m_IsModified = false; } /*****************************************************************************/ inline void ImageSettings ::SetApplied() { // qDebug() << this << "::SetApplied()"; m_IsApplied = true; } /*****************************************************************************/ inline void ImageSettings ::SetEffect( Effect effect ) { m_Effect = effect; SetModified(); } /*****************************************************************************/ inline Effect ImageSettings ::GetEffect() const { return m_Effect; } /*****************************************************************************/ inline const char * ImageSettings ::GetValueName() const { assert( qApp!=NULL ); return qApp->translate( "mvd::ImageSettings", ImageSettings::EFFECT_VALUE_NAME[ m_Effect ] ) .toLocal8Bit().constData(); } /*****************************************************************************/ inline bool ImageSettings ::HasSize() const { return m_Effect==EFFECT_CHESSBOARD || m_Effect==EFFECT_GRADIENT || m_Effect==EFFECT_LOCAL_CONTRAST || m_Effect==EFFECT_LOCAL_TRANSLUCENCY || m_Effect==EFFECT_SPECTRAL_ANGLE; } /*****************************************************************************/ inline bool ImageSettings ::HasValue() const { return m_Effect==EFFECT_LOCAL_CONTRAST || m_Effect==EFFECT_SPECTRAL_ANGLE; } /*****************************************************************************/ inline void ImageSettings ::SetSize( unsigned int size ) { m_Size = size; SetModified(); } /*****************************************************************************/ inline unsigned int ImageSettings ::GetSize() const { return m_Size; } /*****************************************************************************/ inline void ImageSettings ::SetAlpha( double alpha ) { m_Alpha = alpha; if( m_Alpha>1.0 ) m_Alpha = 1.0; if( m_Alpha<0.0 ) m_Alpha = 0.0; SetModified(); } /*****************************************************************************/ inline double ImageSettings ::GetAlpha() const { return m_Alpha; } } // end namespace 'mvd' #endif // mvdImageSettings_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdImageSettingsInterface.h000066400000000000000000000106331301006202600315060ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImageSettingsInterface_h #define mvdImageSettingsInterface_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class ImageSettings; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImageSettingsInterface * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT ImageSettingsInterface { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Destructor. */ virtual ~ImageSettingsInterface(); /** */ inline const ImageSettings * GetSettings() const; /** */ inline ImageSettings * GetSettings(); /** */ inline bool HasSettings() const; /** */ #if 0 inline template< typename T > const T * GetSettings() const; #endif /** */ void UpdateSettings(); /** */ void SetSettings( ImageSettings * ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ ImageSettingsInterface(); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ virtual void virtual_UpdateSettings(); /** */ virtual void virtual_SetSettings( ImageSettings * ); // // Private attributes. private: /** */ ImageSettings * m_Settings; }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline const ImageSettings * ImageSettingsInterface ::GetSettings() const { return m_Settings; } /*****************************************************************************/ inline ImageSettings * ImageSettingsInterface ::GetSettings() { return m_Settings; } /*****************************************************************************/ #if 0 template< typename T > inline const ImageSettings * ImageSettingsInterface ::GetSettings() const { return dynamic_cast< T >( m_Settings ); } #endif /*****************************************************************************/ inline bool ImageSettingsInterface ::HasSettings() const { return m_Settings!=0; } } // end namespace 'mvd' #endif // mvdImageSettingsInterface_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdMath.h000066400000000000000000000107661301006202600260220ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMath_h #define mvdMath_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ #define USE_VNL 0 // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) #if USE_VNL #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "vnl_vector.h" #endif //tag=QT4-boost-compatibility #endif // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. } // end of namespace 'mvd'. /*****************************************************************************/ /* FUNCTIONS DECLARATION. */ namespace otb { } // end namespace 'otb' namespace mvd { /** */ template< typename X, typename Y, typename K > void Lerp2( X& x, Y& y, const K& k, const X& x0, const Y& y0, const X& x1, const Y& y1 ); /** */ template< typename X, typename Y > const Y& Lerp2( const X& x, const X& x0, const Y& y0, const X& x1, const Y& y1 ); /** */ #if USE_VNL template< typename T, unsigned int N > inline const vnl_vector< T, N >& Lerp( const T& k, const vnl_vector< T, N >& v0, const vnl_vector< T, N >& v1 ); #endif // USE_VNL /** */ #if USE_VNL template< typename T > inline const T& Lerp( const T& k, const T& x0, const T& x1, const T& y0, const T& y1 ); #endif // USE_VNL } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace otb { } // end namespace 'otb'. namespace mvd { /*******************************************************************************/ template< typename X, typename Y, typename K > void Lerp2( X& x, Y& y, const K& k, const X& x0, const Y& y0, const X& x1, const Y& y1 ) { const K& _1_minus_k( 1 - k ); x = k * x1 + _1_minus_k * x0; y = k * y1 + _1_minus_k * y0; } /*******************************************************************************/ template< typename X, typename Y, typename K > const Y& Lerp2( const X& x, const X& x0, const Y& y0, const X& x1, const Y& y1 ) { return y0 + (x - x0) * (y1 - y0) / (x1 - x0); } /*******************************************************************************/ #if USE_VNL template< typename T > inline const vnl_vector< T, N >& Lerp( const T& k, const vnl_vector< T, N >& v0, const vnl_vector< T, N >& v1 ) { return k * v1 + ( T( 1 ) - k ) * v2; } #endif // USE_VNL /*******************************************************************************/ #if USE_VNL template< typename T > inline const T& Lerp( const T& k, const T& x0, const T& x1, const T& y0, const T& y1 ) { return Lerp( k, vnl_vector< T, 2 >( x0, x1 ), vnl_vector< T, 2 >( y0, y1 ) ); } #endif // USE_VNL } // end namespace 'mvd' #endif // mvdMath_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdModifiableInterface.h000066400000000000000000000056351301006202600310040ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdModifiableInterface_h #define mvdModifiableInterface_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class ModifiableInterface * * \ingroup OTBMonteverdiCore * */ class OTBMonteverdiCore_EXPORT ModifiableInterface { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** Destructor */ virtual ~ModifiableInterface(); /** */ virtual bool IsModified() const =0; /** */ virtual void ClearModified() =0; /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** Constructor */ ModifiableInterface(); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdModifiableInterface_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdMyClass.h000066400000000000000000000070421301006202600264750ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMyClass_h #define mvdMyClass_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class MyClass * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT MyClass : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ MyClass( QObject* p =NULL ); /** \brief Destructor. */ ~MyClass() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdMyClass_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdOverviewBuilder.h000066400000000000000000000116441301006202600302420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdOverviewBuilder_h #define mvdOverviewBuilder_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGDALOverviewsBuilder.h" // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractWorker.h" #include "mvdProgressInterface.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class OverviewBuilder * * \ingroup OTBMonteverdiCore * * \brief Import image worker. It is parametrized by the image * filename and the desired (width, height) best-fit size. */ class OTBMonteverdiCore_EXPORT OverviewBuilder : public AbstractWorker, public ProgressInterface { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types public: typedef std::vector< otb::GDALOverviewsBuilder::Pointer > GDALOverviewsBuilderVector; // // Public methods. public: /** * \brief Constructor. */ OverviewBuilder( const GDALOverviewsBuilderVector & builders, QObject * p =NULL ); /** * \brief Destructor. */ ~OverviewBuilder() ITK_OVERRIDE; // // ProgressInterface overloads. void SetProgress( double ) ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** * \brief Signal emitted when job/task has correctly been done. * * \param result Resulting QObject instance of NULL if none. */ //void Done( QObject* result =NULL ); /** * \brief Signal emitted when an exception has been caught by this worker. * * \param exc The copy (thread safety) exception which has been caught. */ //void ExceptionRaised( std::exception exc ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: // // AbstractWorker oveloads. QObject * virtual_Do() ITK_OVERRIDE; QString virtual_GetFirstProgressText() const ITK_OVERRIDE; // // Private attributes. private: /** */ GDALOverviewsBuilderVector m_GDALOverviewsBuilders; /** */ int m_Index; /** */ int m_Count; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdOverviewBuilder_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdProcessObjectObserver.h000066400000000000000000000103701301006202600313750ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdProcessObjectObserver_h #define mvdProcessObjectObserver_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) #include // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class ProgressInterface; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ProcessObjectObserver * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT ProcessObjectObserver : public itk::Command { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ // Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: typedef ProcessObjectObserver Self; typedef itk::Command Superclass; typedef itk::SmartPointer< Self > Pointer; itkNewMacro( Self ); // // Public methods. public: /** \brief Destructor. */ ~ProcessObjectObserver() ITK_OVERRIDE; const ProgressInterface * GetProgressInterface() const; ProgressInterface * GetProgressInterface(); void SetProgressInterface( ProgressInterface * ); // // itk::Command overloads. void Execute( itk::Object * caller, const itk::EventObject & event ) ITK_OVERRIDE; void Execute( const itk::Object * caller, const itk::EventObject & event ) ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ ProcessObjectObserver(); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: ProgressInterface * m_ProgressInterface; // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdProcessObjectObserver_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdProgressInterface.h000066400000000000000000000062651301006202600305550ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdProgressInterface_h #define mvdProgressInterface_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ProgressInterface * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT ProgressInterface { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Destructor. */ virtual ~ProgressInterface(); /** */ virtual void SetProgress( double ) = 0; /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ ProgressInterface(); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdProgressInterface_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdQuicklookModel.h000066400000000000000000000126021301006202600300420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdQuicklookModel_h #define mvdQuicklookModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdTypes.h" #include "mvdVectorImageModel.h" #endif //tag=QT4-boost-compatibility // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class QuicklookModel * * \ingroup OTBMonteverdiCore * */ class OTBMonteverdiCore_EXPORT QuicklookModel : public VectorImageModel { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: // // Public methods. public: /** Constructor */ QuicklookModel( QObject* p =NULL ); /** Destructor */ ~QuicklookModel() ITK_OVERRIDE; /** * \brief Get the parent image-model of this quicklook image as an * AbstractImageModel. * * \return The parent image-model of this quicklook image. */ inline const AbstractImageModel* GetImageModel() const; /** * \brief Get the parent image-model of this quicklook image as an * AbstractImageModel. * * \return The parent image-model of this quicklook image. */ inline AbstractImageModel* GetImageModel(); /** * \brief Get the parent image-model of this quicklook image as a * TImageModel. * * \return The parent image-model of this quicklook image. */ template< typename TImageModel > inline const TImageModel* GetImageModel() const; /** * \brief Get the parent image-model of this quicklook image as a * TImageModel. * * \return The parent image-model of this quicklook image. */ template< typename TImageModel > inline TImageModel* GetImageModel(); // // VectorImageModel overloads. /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public slots. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void SettingsUpdated(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** */ void virtual_BuildModel( void* context =NULL ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ const AbstractImageModel* QuicklookModel ::GetImageModel() const { return GetImageModel< AbstractImageModel >(); } /*****************************************************************************/ AbstractImageModel* QuicklookModel ::GetImageModel() { return GetImageModel< AbstractImageModel >(); } /*****************************************************************************/ template< typename TImageModel > const TImageModel* QuicklookModel ::GetImageModel() const { return qobject_cast< const TImageModel* >( parent() ); } /*****************************************************************************/ template< typename TImageModel > TImageModel* QuicklookModel ::GetImageModel() { return qobject_cast< TImageModel* >( parent() ); } } // end namespace 'mvd' #endif // mvdQuicklookModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdSerializableInterface.h000066400000000000000000000064521301006202600313550ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdSerializableInterface_h #define mvdSerializableInterface_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class SerializableInterface * * \ingroup OTBMonteverdiCore * * \brief 'Template method' pattern applied to serializable objects. */ class OTBMonteverdiCore_EXPORT SerializableInterface { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: /** */ enum Mode { MODE_BINARY = 0, MODE_TEXT = 1, }; // // Public methods. public: /** \brief Destructor. */ virtual ~SerializableInterface(); /** */ void Write( const QString& filename, Mode mode ) const; /** */ void Read( const QString& filename, Mode mode ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ SerializableInterface(); /** */ virtual void virtual_Read( QIODevice* device ) =0; /** */ virtual void virtual_Write( QIODevice& device ) const =0; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdSerializableInterface_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdStackedLayerModel.h000066400000000000000000000515651301006202600304670ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdStackedLayerModel_h #define mvdStackedLayerModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractModel.h" #endif //tag=QT4-boost-compatibility #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractLayerModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class StackedLayerModel * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT StackedLayerModel : public AbstractModel { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; // // Private types private: // typedef std::vector< AbstractLayerModel * > LayerModelVector; typedef std::map< std::string, AbstractLayerModel * > LayerModelMap; // typedef std::pair< AbstractLayerModel *, void * > LayerModelPair; // typedef std::map< std::string, LayerDataPair > LayerModelPairMap; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: typedef std::vector< LayerModelMap::key_type > KeyVector; typedef LayerModelMap::size_type SizeType; typedef LayerModelMap::key_type KeyType; typedef LayerModelMap::const_iterator ConstIterator; static const SizeType NIL_INDEX; // // Public methods. public: /** \brief Constructor. */ StackedLayerModel( QObject* p =NULL ); /** \brief Destructor. */ ~StackedLayerModel() ITK_OVERRIDE; inline const AbstractLayerModel * operator[]( SizeType ) const; inline AbstractLayerModel * operator[]( SizeType ); KeyType Add( AbstractLayerModel * ); inline const AbstractLayerModel * At( SizeType ) const; inline AbstractLayerModel * At( SizeType ); inline ConstIterator Begin() const; inline void BeginEditPixelInfo() {}; void BeginEditResolutions() {}; inline bool Contains( const KeyType & key ) const; bool Contains( const AbstractLayerModel * ) const; void CountSRT( size_t & unknown, size_t & carto, size_t & geo, size_t & sensor ) const; inline ConstIterator End() const; inline void EndEditPixelInfo( const QPoint &, const PointType & ); void EndEditResolutions(); /* inline const AbstractLayerModel * Front() const; inline AbstractLayerModel * Front(); */ inline ConstIterator Find( const AbstractLayerModel * ) const; inline const AbstractLayerModel * Get( const KeyType & ) const; inline AbstractLayerModel * Get( const KeyType & ); inline SizeType GetCount() const; inline const KeyType & GetKey( SizeType ) const; inline const KeyVector & GetKeys() const; template< typename T > T * GetCurrent() const; template< typename T > T * GetCurrent(); AbstractLayerModel * GetCurrent() const; AbstractLayerModel * GetCurrent(); inline SizeType GetCurrentIndex() const; inline const KeyType & GetCurrentKey() const; template< typename T > T * GetReference() const; template< typename T > T * GetReference(); AbstractLayerModel * GetReference() const; AbstractLayerModel * GetReference(); inline SizeType GetReferenceIndex() const; inline bool HasCurrent() const; inline bool HasReference() const; inline SizeType IndexOf( const AbstractLayerModel * ) const; KeyType Insert( AbstractLayerModel *, SizeType index ); inline bool IsEmpty() const; inline const PixelInfo::Vector & PixelInfos() const; inline PixelInfo::Vector & PixelInfos(); inline void SetCurrent( SizeType, bool =false ); void SetCurrent( const KeyType & ); void SetCurrent( const AbstractLayerModel * ); inline void SetReference( SizeType, bool =false ); void SetReference( const KeyType & ); void SetReference( const AbstractLayerModel * ); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: void Clear(); inline void Delete( const KeyType & ); inline void DeleteCurrent(); inline void LowerCurrent(); inline void MoveCurrentToBottom(); inline void MoveCurrentToTop(); inline void RaiseCurrent(); inline void RotateLayers( int ); inline void SelectFirst(); inline void SelectLast(); inline void SelectPrevious(); inline void SelectNext(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: void AboutToChangeSelectedLayerModel( const StackedLayerModel::KeyType & ); void SelectedLayerModelChanged( const StackedLayerModel::KeyType & ); void ContentAboutToBeChanged(); void ContentAboutToBeReset(); void ContentChanged(); void ContentReset(); void CurrentAboutToBeChanged( size_t ); void CurrentChanged( size_t ); void LayerAboutToBeDeleted( size_t index ); void LayerAdded( size_t index ); void LayerDeleted( size_t index ); void OrderAboutToBeChanged(); void OrderChanged(); void PixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ); void ReferenceAboutToBeChanged( size_t ); void ReferenceChanged( size_t ); void ResolutionsChanged( const PixelInfo::Vector & ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: static KeyType GenerateKey( AbstractLayerModel * ); inline void ClearPixelInfos(); void Delete( SizeType ); inline SizeType FindKey( const KeyType & ) const; inline SizeType Next( SizeType ); inline SizeType Prev( SizeType ); void RaiseLayer( SizeType ); void LowerLayer( SizeType ); void RotateLayerUp( SizeType ); void RotateLayerDown( SizeType ); void MoveTo( SizeType index, SizeType position ); void MoveToTop( SizeType ); void MoveToBottom( SizeType ); // inline void Swap( SizeType, SizeType ); inline const KeyType & KeyOf( const AbstractLayerModel * ) const; // // Private attributes. private: static const KeyType NIL_KEY; static SizeType m_LayerCount; LayerModelMap m_LayerModels; KeyVector m_Keys; SizeType m_Current; SizeType m_Reference; // Usually, information is a singular term which denotes a // plural. Since there's a container of several pixel-infos and we // usually name container variables by using the plural form, an 's' // is appended to PixelInfo. PixelInfo::Vector m_PixelInfos; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; #if OTB_DEBUG inline void trace( const StringVector & ); #endif } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline const AbstractLayerModel * StackedLayerModel ::operator[]( SizeType i ) const { return At( i ); } /*****************************************************************************/ inline AbstractLayerModel * StackedLayerModel ::operator[]( SizeType i ) { return At( i ); } /*****************************************************************************/ inline const AbstractLayerModel * StackedLayerModel ::At( SizeType i ) const { return const_cast< StackedLayerModel * >( this )->At( i ); } /*****************************************************************************/ inline AbstractLayerModel * StackedLayerModel ::At( SizeType i ) { if( i>=GetCount() ) return NULL; assert( !GetKey( i ).empty() ); LayerModelMap::const_iterator it( m_LayerModels.find( GetKey( i ) ) ); assert( it!=m_LayerModels.end() ); return it->second; } /*****************************************************************************/ inline StackedLayerModel::ConstIterator StackedLayerModel ::Begin() const { return m_LayerModels.begin(); } /*****************************************************************************/ inline void StackedLayerModel ::ClearPixelInfos() { m_PixelInfos.reserve( 0 ); } /*****************************************************************************/ inline bool StackedLayerModel ::Contains( const KeyType & key ) const { return m_LayerModels.find( key )!=m_LayerModels.end(); } /*****************************************************************************/ inline void StackedLayerModel ::Delete( const KeyType & key ) { // qDebug() << this << "::Delete(" << key << ")"; Delete( FindKey( key ) ); } /*****************************************************************************/ inline void StackedLayerModel ::DeleteCurrent() { // qDebug() << this << "::DeleteCurrent()"; Delete( m_Current ); } /*****************************************************************************/ inline StackedLayerModel::SizeType StackedLayerModel ::FindKey( const KeyType & key ) const { KeyVector::const_iterator it( std::find( m_Keys.begin(), m_Keys.end(), key ) ); if( it==m_Keys.end() ) return StackedLayerModel::NIL_INDEX; return std::distance( m_Keys.begin(), it ); } /*****************************************************************************/ inline StackedLayerModel::SizeType StackedLayerModel ::GetCount() const { return m_LayerModels.size(); } /*****************************************************************************/ inline const StackedLayerModel::KeyVector & StackedLayerModel ::GetKeys() const { return m_Keys; } /*****************************************************************************/ inline bool StackedLayerModel ::HasCurrent() const { return m_Currentsecond==layer ) return it; return m_LayerModels.end(); } /*****************************************************************************/ const AbstractLayerModel * StackedLayerModel ::Get( const KeyType & key ) const { return const_cast< StackedLayerModel * >( this )->Get( key ); } /*****************************************************************************/ AbstractLayerModel * StackedLayerModel ::Get( const KeyType & key ) { ConstIterator it( m_LayerModels.find( key ) ); return it==m_LayerModels.end() ? NULL : it->second; } /*****************************************************************************/ template< typename T > inline T * StackedLayerModel ::GetCurrent() { return dynamic_cast< T * >( GetCurrent() ); } /*****************************************************************************/ template< typename T > inline T * StackedLayerModel ::GetCurrent() const { return dynamic_cast< T * >( GetCurrent() ); } /*****************************************************************************/ inline AbstractLayerModel * StackedLayerModel ::GetCurrent() { if( m_Current>=GetCount() ) return NULL; LayerModelMap::const_iterator it( m_LayerModels.find( m_Keys[ m_Current ] ) ); if( it==m_LayerModels.end() ) return NULL; return it->second; } /*****************************************************************************/ inline AbstractLayerModel * StackedLayerModel ::GetCurrent() const { return const_cast< StackedLayerModel * >( this )->GetCurrent(); } /*****************************************************************************/ inline StackedLayerModel::SizeType StackedLayerModel ::GetCurrentIndex() const { return m_Current; } /*****************************************************************************/ inline const StackedLayerModel::KeyType & StackedLayerModel ::GetCurrentKey() const { return GetKey( m_Current ); } /*****************************************************************************/ inline const StackedLayerModel::KeyType & StackedLayerModel ::GetKey( SizeType index ) const { if( index>=GetCount() ) return StackedLayerModel::NIL_KEY; return m_Keys[ index ]; } /*****************************************************************************/ template< typename T > inline T * StackedLayerModel ::GetReference() { return dynamic_cast< T * >( GetReference() ); } /*****************************************************************************/ template< typename T > inline T * StackedLayerModel ::GetReference() const { return dynamic_cast< T * >( GetReference() ); } /*****************************************************************************/ inline AbstractLayerModel * StackedLayerModel ::GetReference() { if( m_Reference>=GetCount() ) return NULL; LayerModelMap::const_iterator it( m_LayerModels.find( m_Keys[ m_Reference ] ) ); if( it==m_LayerModels.end() ) return NULL; return it->second; } /*****************************************************************************/ inline AbstractLayerModel * StackedLayerModel ::GetReference() const { return const_cast< StackedLayerModel * >( this )->GetReference(); } /*****************************************************************************/ inline StackedLayerModel::SizeType StackedLayerModel ::GetReferenceIndex() const { return m_Reference; } /*****************************************************************************/ inline StackedLayerModel::SizeType StackedLayerModel ::IndexOf( const AbstractLayerModel * layer ) const { KeyType key( KeyOf( layer ) ); if( key==StackedLayerModel::NIL_KEY ) return StackedLayerModel::NIL_INDEX; for( KeyVector::size_type i=0; isecond==layerModel ) return it->first; return StackedLayerModel::NIL_KEY; } /*****************************************************************************/ inline void StackedLayerModel ::LowerCurrent() { if( GetCount()<2 ) return; assert( m_Current=GetCount() ) return; MoveToBottom( m_Current ); } /*****************************************************************************/ void StackedLayerModel ::MoveCurrentToTop() { if( m_Current>=GetCount() ) return; MoveToTop( m_Current ); } /*****************************************************************************/ inline StackedLayerModel::SizeType StackedLayerModel ::Next( SizeType index ) { return index>=GetCount() ? 0 : ( index + 1 ) % GetCount(); } /*****************************************************************************/ inline const PixelInfo::Vector & StackedLayerModel ::PixelInfos() const { return m_PixelInfos; } /*****************************************************************************/ inline PixelInfo::Vector & StackedLayerModel ::PixelInfos() { return m_PixelInfos; } /*****************************************************************************/ inline StackedLayerModel::SizeType StackedLayerModel ::Prev( SizeType index ) { return index>=GetCount() || index==0 ? GetCount() - 1 : index - 1; } /*****************************************************************************/ inline void StackedLayerModel ::RaiseCurrent() { if( GetCount()<2 ) return; assert( m_Current=0 ) RotateLayerUp( steps % GetCount() ); else RotateLayerDown( ( -steps ) % GetCount() ); } /*****************************************************************************/ inline void StackedLayerModel ::SelectFirst() { if( GetCount()<1 ) return; SetCurrent( SizeType( 0 ) ); } /*****************************************************************************/ inline void StackedLayerModel ::SelectLast() { if( GetCount()<1 ) return; SetCurrent( m_Keys.size() - 1 ); } /*****************************************************************************/ inline void StackedLayerModel ::SelectNext() { if( IsEmpty() ) return; SetCurrent( Next( m_Current ) ); } /*****************************************************************************/ inline void StackedLayerModel ::SelectPrevious() { if( IsEmpty() ) return; SetCurrent( Prev( m_Current ) ); } /*****************************************************************************/ inline void StackedLayerModel ::SetCurrent( SizeType index, bool force ) { // qDebug() << this << "::SetCurrent(" << index << ")"; if( index==m_Current && !force ) return; KeyType key( GetKey( index ) ); // qDebug() // << QString( "'%1'" ).arg( GetCurrentKey().c_str() ) // << "->" // << QString( "'%1'" ).arg( key.c_str() ); emit CurrentAboutToBeChanged( index ); emit AboutToChangeSelectedLayerModel( key ); m_Current = index; emit CurrentChanged( index ); emit SelectedLayerModelChanged( key ); } /*****************************************************************************/ inline void StackedLayerModel ::SetReference( SizeType index, bool force ) { // qDebug() << this << "::SetReference(" << index << ")"; if( index==m_Reference && !force ) return; emit ReferenceAboutToBeChanged( index ); m_Reference = index; emit ReferenceChanged( index ); } /*****************************************************************************/ #if OTB_DEBUG inline void trace( const StringVector & strv ) { qDebug() << "{"; for( StringVector::const_iterator it( strv.begin() ); it!=strv.end(); ++it ) qDebug() << QString( "%1" ).arg( it->c_str() ); qDebug() << "}"; } #endif } // end namespace 'mvd' #endif // mvdStackedLayerModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdSystemError.h000066400000000000000000000064401301006202600274210ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdSystemError_h #define mvdSystemError_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include #endif //tag=QT4-boost-compatibility // // ITK includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itksys/SystemTools.hxx" #endif //tag=QT4-boost-compatibility // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class SystemError * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT SystemError : public std::runtime_error { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ SystemError( const std::string& message =std::string() ) : std::runtime_error( itksys::SystemTools::GetLastSystemError() + ": " + message) {}; /** \brief Destructor. */ ~SystemError() throw() ITK_OVERRIDE {}; /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ // // Private attributes. private: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ #endif // mvdSystemError_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdTextStream.h000066400000000000000000000552121301006202600272240ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdStream_h #define mvdStream_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkHistogram.h" #include "itkSize.h" #endif //tag=QT4-boost-compatibility // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAlgorithm.h" #include "mvdSystemError.h" #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { /** * \brief TODO. */ enum StreamTag { STREAM_TAG_SIZE = 0, STREAM_TAG_VECTOR, STREAM_TAG_VARIABLE_LENGTH_VECTOR, // STREAM_TAG_COUNT }; /** * \brief TODO. */ extern const char* STREAM_TAG_NAMES[ STREAM_TAG_COUNT ]; // // Internal classes pre-declaration. } // end of namespace 'mvd'. /*****************************************************************************/ /* FUNCTIONS DECLARATION. */ /*****************************************************************************/ namespace mvd { /** * \brief Check status Qt stream and throw SystemError exception if * status is not Ok. */ inline void CheckStreamStatus( QTextStream& stream ); /** * \brief Write a text tag followed by a white space to the stream. * * \param stream Stream to write into. * \param name Tag name to write. * \param enqueueWS Enqueue a whitespace following the tag name. * * \return stream instance. */ inline QTextStream& WriteStreamTag( QTextStream& stream, const QString& name, bool enqueueWS =true ); /** * \brief Read a text tag followed by a whitespace from the stream and * check it against an expected value. * * \param stream Stream to read from. * \param tag Text tag which has been read. * \param expected The expected tag name. If non-empty, value read * from stream is checked against expected value; an * std::runtime_exception is thrown if both values doest not match. * \param skipWS Skip whitespace following tag name. * * \return stream instance. */ inline QTextStream& ReadStreamTag( QTextStream& stream, QString& tag, const QString& expected =QString(), bool skipWS =true ); /*****************************************************************************/ /** * \brief Write an StreamTag followed by a whitespace separator into a * QTextStream. * * \param stream QTextStream into which to write data. * \param tag StreamTag data to write. * * \return stream instance. */ inline QTextStream& operator << ( QTextStream& stream, StreamTag tag ); /** * \brief Read a StreamTag followed by a whitespace from a * QTextStream. * * \param stream QTextStream from which to read data. * \param tag StreamTag to data read. * * \return stream instance. */ inline QTextStream& operator >> ( QTextStream& stream, StreamTag& tag ); /*****************************************************************************/ /** * \brief Write an std::vector< T, std::allocator< T > > into a QTextStream. * * \param stream QTextStream into which to write data. * \param vector std::vector< T, std::allocator< T > > data to write. * * \return stream instance. */ template< typename T > inline QTextStream& operator << ( QTextStream& stream, const std::vector< T, std::allocator< T > >& vector ); /** * \brief */ template<> inline QTextStream& operator << < double >( QTextStream& stream, const std::vector< double >& vector ); /** * \brief */ template<> inline QTextStream& operator << < float >( QTextStream& stream, const std::vector< float >& vector ); /** * \brief Read an std::vector< T, Alloc > from a QTextStream. * * \param stream QTextStream from which to read data. * \param vector std::vector< T, Alloc > container to read data into. * * \return stream instance. */ template< typename T, typename Alloc > inline QTextStream& operator >> ( QTextStream& stream, std::vector< T, Alloc >& vector ); /*****************************************************************************/ /** * \brief Write an itk::Array< T > into a QTextStream. * * \param stream QTextStream into which to write data. * \param array itk::Array< T > data to write. * * \return stream instance. */ template< typename T > inline QTextStream& operator << ( QTextStream& stream, const itk::Array< T >& array ); /** * \brief Read an itk::Array< T > from a QTextStream. * * \param stream QTextStream from which to read data. * \param array itk::Array< T > container to read data into. * * \return stream instance. */ template< typename T > inline QTextStream& operator >> ( QTextStream& stream, itk::Array< T >& array ); /*****************************************************************************/ /** * \brief Write an itk::VariableLengthVector< T > into a QTextStream. * * \param stream QTextStream into which to write data. * \param vector itk::VariableLengthVector< T > data to write. * * \return stream instance. */ template< typename T > inline QTextStream& operator << ( QTextStream& stream, const itk::VariableLengthVector< T >& vector ); /** */ template<> inline QTextStream& operator << ( QTextStream& stream, const itk::VariableLengthVector< float >& vector ); /** */ template<> inline QTextStream& operator << ( QTextStream& stream, const itk::VariableLengthVector< double >& vector ); /** * \brief Read an itk::VariableLengthVector< T > from a QTextStream. * * \param stream QTextStream from which to read data. * \param vector itk::VariableLengthVector< T > container to read data into. * * \return stream instance. */ template< typename T > inline QTextStream& operator >> ( QTextStream& stream, itk::VariableLengthVector< T >& vector ); /*****************************************************************************/ /** * \brief Write an itk::statistics::Histogram< T, FC > into a QTextStream. * * \param stream QTextStream into which to write data. * \param histogram itk::statistics::Histogram< T, FC > data to write. * * \return stream instance. */ template< typename T, typename FC > inline QTextStream& operator << ( QTextStream& stream, const itk::Statistics::Histogram< T, FC >& histogram ); /** * \brief Read an itk::statistics::Histogram< T, FC > from a QTextStream. * * \param stream QTextStream from which to read data. * \param histogram itk::statistics::Histogram< T, FC > container to * read data into. * * \return stream instance. */ template< typename T, typename FC > inline QTextStream& operator >> ( QTextStream& stream, itk::Statistics::Histogram< T, FC >& histogram ); } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*******************************************************************************/ inline void CheckStreamStatus( QTextStream& stream ) { if( stream.status()!=QTextStream::Ok ) throw SystemError(); } /*******************************************************************************/ inline QTextStream& WriteStreamTag( QTextStream& stream, const QString& name, bool queueWhiteSpace ) { stream << name; if( queueWhiteSpace ) stream << " "; CheckStreamStatus( stream ); return stream; } /*******************************************************************************/ inline QTextStream& ReadStreamTag( QTextStream& stream, QString& name, const QString& expected, bool skipWhiteSpace ) { stream >> name; if( skipWhiteSpace ) stream >> ws; CheckStreamStatus( stream ); if( !expected.isEmpty() && expected.compare( name, Qt::CaseInsensitive )!=0 ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Read tag '%1' does not match expected tag '%2'." ) .arg( name ) .arg( expected ) ) ); } return stream; } /*******************************************************************************/ inline QTextStream& operator << ( QTextStream& stream, StreamTag tag ) { WriteStreamTag( stream, STREAM_TAG_NAMES[ tag ] ); return stream; } /*******************************************************************************/ inline QTextStream& operator >> ( QTextStream& stream, StreamTag& tag ) { QString name; ReadStreamTag( stream, name ); bool found = false; for( int i=0; i( i ); } } if( !found ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Invalid tag name '%1'." ) .arg( name ) ) ); } return stream; } /*******************************************************************************/ template< typename T > inline QTextStream& operator << ( QTextStream& stream, const std::vector< T, std::allocator< T > >& vector ) { typedef std::vector< T, std::allocator< T > > Vector; stream << STREAM_TAG_VECTOR << vector.size(); for( typename Vector::const_iterator it( vector.begin() ); it!=vector.end(); ++it ) { stream << " " << *it; } return stream; } /*******************************************************************************/ template<> inline QTextStream& operator << < float >( QTextStream& stream, const std::vector< float >& vector ) { typedef std::vector< float, std::allocator< float > > Vector; stream << STREAM_TAG_VECTOR << vector.size(); for( Vector::const_iterator it( vector.begin() ); it!=vector.end(); ++it ) { stream << " " << ToQString( *it ); } return stream; } /*******************************************************************************/ template<> inline QTextStream& operator << < double >( QTextStream& stream, const std::vector< double >& vector ) { typedef std::vector< double, std::allocator< double > > Vector; stream << STREAM_TAG_VECTOR << vector.size(); for( Vector::const_iterator it( vector.begin() ); it!=vector.end(); ++it ) { stream << " " << ToQString( *it ); } return stream; } /*******************************************************************************/ template< typename T, typename Alloc > inline QTextStream& operator >> ( QTextStream& stream, std::vector< T, Alloc >& vector ) { typedef std::vector< T, Alloc > Vector; QString type; ReadStreamTag( stream, type, STREAM_TAG_NAMES[ STREAM_TAG_VECTOR ] ); typename Vector::size_type size = 0; stream >> size; vector.resize( size ); for( typename Vector::iterator it( vector.begin() ); it!=vector.end(); ++it ) { stream >> ws >> *it; } return stream; } /*****************************************************************************/ template< typename T > inline QTextStream& operator << ( QTextStream& stream, const itk::Array< T >& array ) { stream << STREAM_TAG_SIZE << array.GetSize(); CheckStreamStatus( stream ); for( CountType i=0; i inline QTextStream& operator >> ( QTextStream& stream, itk::Array< T >& array ) { CountType dimension = 0; QString type; ReadStreamTag( stream, type, STREAM_TAG_NAMES[ STREAM_TAG_SIZE ] ); stream >> dimension; if( dimension!=array.GetSize() ) { throw std::length_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Array dimension (%1) does not match " "expected dimension (%2)." ) .arg( dimension ) .arg( array.GetSize() ) ) ); } for( CountType i=0; i> ws >> array[ i ]; CheckStreamStatus( stream ); } return stream; } /*******************************************************************************/ template< typename T > inline QTextStream& operator << ( QTextStream& stream, const itk::VariableLengthVector< T >& vector ) { typedef typename itk::VariableLengthVector< T > Vector; // Write number of elements. stream << STREAM_TAG_VARIABLE_LENGTH_VECTOR << vector.Size(); CheckStreamStatus( stream ); // Write each element prefixed by a delimitting whitespace. for( typename Vector::ElementIdentifier i=0; i inline QTextStream& operator << ( QTextStream& stream, const itk::VariableLengthVector< double >& vector ) { typedef itk::VariableLengthVector< double > Vector; // Write number of elements. stream << STREAM_TAG_VARIABLE_LENGTH_VECTOR << vector.Size(); CheckStreamStatus( stream ); // Write each element prefixed by a delimitting whitespace. for( Vector::ElementIdentifier i=0; i inline QTextStream& operator << ( QTextStream& stream, const itk::VariableLengthVector< float >& vector ) { typedef itk::VariableLengthVector< float > Vector; // Write number of elements. stream << STREAM_TAG_VARIABLE_LENGTH_VECTOR << vector.Size(); CheckStreamStatus( stream ); // Write each element prefixed by a delimitting whitespace. for( Vector::ElementIdentifier i=0; i inline QTextStream& operator >> ( QTextStream& stream, itk::VariableLengthVector< T >& vector ) { typedef typename itk::VariableLengthVector< T > Vector; QString type; ReadStreamTag( stream, type, STREAM_TAG_NAMES[ STREAM_TAG_VARIABLE_LENGTH_VECTOR ] ); // Read number of elements. typename Vector::ElementIdentifier size = 0; stream >> size; CheckStreamStatus( stream ); // Allocates vector elements. vector.SetSize( size ); // Read each element prefixed by a delimitting whitespace. for( typename Vector::ElementIdentifier i=0; i> ws >> vector[ i ]; CheckStreamStatus( stream ); } return stream; } /*******************************************************************************/ template< typename T, typename FC > inline QTextStream& operator << ( QTextStream& stream, const itk::Statistics::Histogram< T, FC >& histogram ) { typedef typename itk::Statistics::Histogram< T, FC > Histogram; WriteStreamTag( stream, "HISTOGRAM", false ); stream << endl; WriteStreamTag( stream, "MEASUREMENT" ); stream << histogram.GetSize() << endl; #if 1 WriteStreamTag( stream, "MINS" ); stream << histogram.GetMins() << endl; WriteStreamTag( stream, "MAXS" ); stream << histogram.GetMaxs() << endl; #endif #if 0 typename Histogram::SizeType size( histogram.GetSize() ); for( unsigned int dim=0; dim inline QTextStream& operator >> ( QTextStream& stream, itk::Statistics::Histogram< T, FC >& histogram ) { typedef itk::Statistics::Histogram< T, FC > Histogram; QString string; unsigned int N = histogram.GetMeasurementVectorSize(); // // Histogram section. ReadStreamTag( stream, string, "HISTOGRAM" ); // // Measurement-size section. ReadStreamTag( stream, string, "MEASUREMENT" ); typename Histogram::SizeType size; size.SetSize(N); stream >> size; // Dimension of size is checked in operator >> ( QTextStream&, // itk::Size< T > ). histogram.Initialize( size ); #if 1 // // Bin mins. ReadStreamTag( stream, string, "MINS" ); typename Histogram::BinMinContainerType mins; stream >> mins; // // Bin maxes. ReadStreamTag( stream, string, "MAXS" ); typename Histogram::BinMaxContainerType maxs; stream >> maxs; if( mins.size()!=N ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Histogram mins dimension (%1) does not match " "expected dimension (%2)." ) .arg( mins.size() ) .arg( N ) ) ); } if( maxs.size()!=N ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Histogram maxs dimension (%1) does not match " "expected dimension (%2)." ) .arg( maxs.size() ) .arg( N ) ) ); } // // Initialize histogram mins & maxs within single pass. for( typename Histogram::BinMaxContainerType::size_type dim=0; dim> d >> ws; CheckStreamStatus( stream ); if( d!=dim ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Histogram dimension (%1) does not match " "expected dimension (%2)." ) .arg( d ) .arg( dim ) ) ); } // Bin. unsigned long b = 0; stream >> b >> ws; CheckStreamStatus( stream ); if( b!=bin ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Histogram bin count (%1) does not match " "expected bin count (%2)." ) .arg( b ) .arg( bin ) ) ); } // Min. typename Histogram::BinMinContainerType::value_type::value_type min; stream >> min >> ws; CheckStreamStatus( stream ); histogram.SetBinMin( dim, bin, min ); // Max. typename Histogram::BinMaxContainerType::value_type::value_type max; stream >> max >> ws; CheckStreamStatus( stream ); histogram.SetBinMax( dim, bin, max ); // Frequency. typename Histogram::AbsoluteFrequencyType freq( 0 ); stream >> freq; CheckStreamStatus( stream ); typename Histogram::MeasurementType measurement( histogram.GetMeasurement( b, d ) ); typename Histogram::IndexType index( histogram.GetIndex( measurement ) ); histogram.SetFrequency( index, freq ); } } #else CountType samples = 0; ReadStreamTag( stream, string, "SAMPLES" ); stream >> samples; CheckStreamStatus( stream ); CountType space = histogram.Size(); if( samples!=space ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Histogram sample count (%1) does not match " "expected sample count (%2)." ) .arg( samples ) .arg( space ) ) ); } CountType i = 0; for( ; i> id >> ws >> freq; CheckStreamStatus( stream ); histogram.SetFrequency( id, freq ); } CountType count = 0; ReadStreamTag( stream, string, "COUNT" ); stream >> count; CheckStreamStatus( stream ); if( count!=i ) { throw std::runtime_error( ToStdString( QCoreApplication::translate( "mvd::TextStream", "Read sample count (histogram) (%1) does not match " "written sample count (%2)." ) .arg( i ) .arg( count ) ) ); } #endif return stream; } } // end namespace 'mvd' #endif // mvdStream_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdTypes.h000066400000000000000000000163561301006202600262360ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdTypes_h #define mvdTypes_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include #endif //tag=QT4-boost-compatibility // // ITK includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include #include #endif //tag=QT4-boost-compatibility // // OTB includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: // https://bugreports.qt-project.org/browse/QTBUG-22829 // //tag=QT4-boost-compatibility #include #include #include #include #include #endif //tag=QT4-boost-compatibility // // Monteverdi includes (sorted by alphabetic order) // // External classes pre-declaration. namespace { } // // Type definitions. namespace mvd { /*******************************************************************************/ /* Enumerations */ /*******************************************************************************/ /* Type definitions of scalar values. */ /** */ typedef unsigned int CountType; /** */ typedef Monteverdi_FLOATING_TYPE RealType; /** */ typedef RealType ComponentType; /** */ typedef itk::VariableLengthVector< RealType > VectorPixelType; /*******************************************************************************/ /* Type definitions of STL realization. */ /** */ typedef std::vector< std::string > StringVector; /** */ typedef std::vector< int > IntVector; /** */ typedef std::vector< unsigned int > UIntVector; /** */ typedef std::list< std::string > StringList; /** */ typedef std::vector< double > DoubleVector; /*******************************************************************************/ /* Type definitions of ITK realization. */ /** */ typedef itk::Array< double > ParametersType; /*******************************************************************************/ /* Type definitions depending on dimension. */ /** */ typedef itk::ImageRegion< Monteverdi_DIMENSION > ImageRegionType; /** */ typedef itk::Index< Monteverdi_DIMENSION > IndexType; /** */ typedef itk::Size< Monteverdi_DIMENSION > SizeType; /** */ typedef itk::ImageBase< Monteverdi_DIMENSION > ImageBaseType; /*******************************************************************************/ /* Type definitions for scalar/mono-band images. */ /** */ typedef otb::Image< ComponentType, Monteverdi_DIMENSION > ScalarImageType; /** */ typedef otb::ImageFileReader< ScalarImageType > ScalarImageFileReaderType; /** */ typedef otb::ImageFileWriter< ScalarImageType > ScalarImageFileWriterType; /*******************************************************************************/ /* Type definitions for vector/multi-band images (generic internal data). */ /** */ typedef otb::VectorImage< ComponentType, Monteverdi_DIMENSION > VectorImageType; /** */ typedef otb::ImageFileReader< VectorImageType > VectorImageFileReaderType; /** */ typedef otb::ImageFileWriter< VectorImageType > VectorImageFileWriterType; /** */ typedef VectorImageType::SpacingType SpacingType; /** */ typedef VectorImageType::SizeType SizeType; /** */ typedef VectorImageType::PointType PointType; /*******************************************************************************/ /* Type definitions for application defaults. */ /** */ typedef mvd::VectorImageType DefaultImageType; /** */ typedef mvd::VectorImageFileReaderType DefaultImageFileReaderType; /** */ struct PixelInfo { typedef std::vector< PixelInfo > Vector; PixelInfo() : m_Key(), m_Point(), m_Index(), m_Pixel(), m_HasPoint( false ), m_HasIndex( false ), m_HasPixel( false ), m_HasResolution( false ) { } std::string m_Key; DefaultImageType::PointType m_Point; DefaultImageType::IndexType m_Index; DefaultImageType::PixelType m_Pixel; unsigned int m_Resolution; bool m_HasPoint: 1; bool m_HasIndex: 1; bool m_HasPixel: 1; bool m_HasResolution: 1; }; /*******************************************************************************/ /* Type definitions for wrapped applications */ /** */ typedef std::map< std::string, std::string > ApplicationDocNameToNameMap; /** */ typedef std::map< std::string, StringVector > ApplicationsTagContainer; /*******************************************************************************/ /* Type definitions for dataset properties */ /** */ typedef qlonglong SqlId; /** */ // typedef SqlId DatasetId; typedef QString DatasetHash; /** */ typedef std::pair< std::string, std::string > PropertyType; /** */ typedef std::vector< PropertyType > PropertiesVector; /** */ typedef std::pair< std::string, std::vector< PropertyType > > PropertiesVectorByCategory; /** */ typedef std::map< std::string, PropertiesVector > PropertiesContainer; /*******************************************************************************/ /* Type definitions for Dataset list */ /** */ typedef QPair< QString, QString > StringPairType; /** */ typedef QList< StringPairType > StringPairListType; /*******************************************************************************/ template< typename T > inline T QObjectCast( QObject * object, const QString & string = QString() ) { T model = qobject_cast< T >( object ); if( model!=object ) { if( !string.isNull() ) qWarning() << string; throw std::bad_cast(); } return model; } /*******************************************************************************/ } // end namespace 'mvd' #endif // mvdTypes_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdVectorImageModel.h000066400000000000000000000227701301006202600303150ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdVectorImageModel_h #define mvdVectorImageModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiCoreExport.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkExtractImageFilter.h" #endif //tag=QT4-boost-compatibility // // OTB includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbGenericRSTransform.h" #endif //tag=QT4-boost-compatibility // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractImageModel.h" #include "mvdFilenameInterface.h" #include "mvdVectorImageSettings.h" #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class DatasetModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class VectorImageModel * * \ingroup OTBMonteverdiCore * */ class OTBMonteverdiCore_EXPORT VectorImageModel : public AbstractImageModel, public FilenameInterface { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: /** * In-memory storage type of source image (from file). */ typedef DefaultImageType SourceImageType; // // Public methods. public: /** */ static const unsigned int DEFAULT_LOD_SIZE; /** Constructor */ VectorImageModel( QObject* p =NULL ); /** Destructor */ ~VectorImageModel() ITK_OVERRIDE; /** */ static void EnsureValidImage( const QString& filename ); /** */ // TODO: Move into template wrapper base-class. SourceImageType::ConstPointer ToImage() const; /** */ // TODO: Move into template wrapper base-class. const SourceImageType::Pointer& ToImage(); /** */ inline const VectorImageSettings & GetSettings() const; /** */ inline VectorImageSettings & GetSettings(); /** */ inline void SetSettings( const VectorImageSettings & settings ); /** */ inline const otb::GenericRSTransform<> * GetGenericRSTransform() const; /** * Width and height are added to compute the best level of detail to * load from the image if multi-resolution image. */ void SetFilename( const QString& filename, int width, int height ); /** * Following the zoom factor, get the best level of detail */ CountType ComputeBestLod( double ZoomFactor ) const; /** * Following the zoom factor, get the best level of detail */ CountType ComputeBestLod( int width, int height ) const; // // AbstractImageModel methods. /** * Get the number of available LOD. */ CountType GetNbLod() const ITK_OVERRIDE; /** * Get a smart-pointer to the current LOD image-base. */ ImageBaseType::ConstPointer ToImageBase() const ITK_OVERRIDE; /** * Get a smart-pointer to the current LOD image-base. */ ImageBaseType::Pointer ToImageBase() ITK_OVERRIDE; /** * Get the placename from the center pixel */ std::string GetCenterPixelPlaceName(); // // AbstractModel methods. bool IsModified() const ITK_OVERRIDE; void ClearModified() ITK_OVERRIDE; // get image size in byte std::streamoff GetImageSizeInBytes() { return m_ImageFileReader->GetImageIO()->GetImageSizeInBytes(); } /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public slots. public slots: /** */ void OnPhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType &, const DefaultImageType::PixelType & ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void SettingsUpdated( AbstractImageModel* imageModel =NULL ); /** */ void PropertiesUpdated( AbstractImageModel* imageModel =NULL ); /** */ void ViewportRegionChanged(double, double); /** */ void CurrentIndexUpdated( const IndexType&, bool isInside ); void CurrentIndexUpdated(const QString&); void CurrentPhysicalUpdated(const QStringList&); void CurrentGeographicUpdated(const QStringList&); void CurrentRadioUpdated(const QString&); void CurrentPixelValueUpdated(const VectorImageType::PixelType &, const QStringList& ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // AbstractModel methods. void virtual_BuildModel( void* context =NULL ) ITK_OVERRIDE; // // AbstractImageModel methods. void InitializeColorSetupSettings(); void InitializeColorDynamicsSettings(); // // Protected attributes. protected: /** */ SourceImageType::Pointer m_Image; /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: /** * Helper method to get the best closest Jpeg2K level of detail. */ static unsigned int Closest( double invZoomfactor, unsigned int lodCount ); /** * helper to setup the lod image using a width/height or a zoom factor */ void SetupCurrentLodImage(int w, int h); /** */ void ApplySettings(); /** */ void BuildGdalOverviews(); // // AbstractLayerModel methods. std::string virtual_GetWkt() const ITK_OVERRIDE; bool virtual_HasKwl() const ITK_OVERRIDE; void virtual_ToWgs84( const PointType &, PointType &, double & alt ) const ITK_OVERRIDE; // // AbstractImageModel methods. void virtual_SetCurrentLod( CountType lod ) ITK_OVERRIDE; void virtual_RefreshHistogram() ITK_OVERRIDE; // // Private attributes. private: // Default image reader DefaultImageFileReaderType::Pointer m_ImageFileReader; /** * User-configurable settings of image-model. */ VectorImageSettings m_Settings; /** List of all Level of detail (Resolution) available from the file */ CountType m_LodCount; // Generic RS Transform to get lat/long coordinates otb::GenericRSTransform<>::Pointer m_ToWgs84; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void OnModelUpdated(); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline VectorImageModel::SourceImageType::ConstPointer VectorImageModel ::ToImage() const { // TODO: Fix unsafe weak-pointer dereferencing. return otb::ConstCast< VectorImageModel::SourceImageType >( m_Image ); } /*****************************************************************************/ inline const VectorImageModel::SourceImageType::Pointer& VectorImageModel ::ToImage() { return m_Image; } /*****************************************************************************/ inline void VectorImageModel ::SetSettings( const VectorImageSettings & settings ) { m_Settings = settings; } /*****************************************************************************/ inline const VectorImageSettings & VectorImageModel ::GetSettings() const { return m_Settings; } /*****************************************************************************/ inline VectorImageSettings & VectorImageModel ::GetSettings() { return m_Settings; } /*****************************************************************************/ inline const otb::GenericRSTransform<> * VectorImageModel ::GetGenericRSTransform() const { return m_ToWgs84; } /*****************************************************************************/ } // end namespace 'mvd' #endif // mvdVectorImageModel_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdVectorImageSettings.h000066400000000000000000000343161301006202600310540ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdVectorImageSettings_h #define mvdVectorImageSettings_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdCore.h" #include "mvdImageSettings.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class VectorImageSettings * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT VectorImageSettings : public ImageSettings { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types and attributes. public: /** */ typedef UIntVector ChannelVector; // // Public methods. public: /** * \brief Constructor. */ VectorImageSettings(); /** * \brief Copy constructor. * * \param other * * Copy settings POD content without the modified flag. */ VectorImageSettings( const VectorImageSettings & other ); /** * \brief Destructor. */ ~VectorImageSettings() ITK_OVERRIDE; /** * \brief Assignment operator. * * \param other */ #if 0 VectorImageSettings & operator = ( const VectorImageSettings & other ); #endif // // COLOR COMPOSITION. // /** */ inline void SetRgbChannels( const ChannelVector& rgb ); /** */ inline const ChannelVector& GetRgbChannels() const; /** */ inline void SetRgbChannel( ChannelVector::size_type i, const ChannelVector::value_type& channel ); /** */ inline const ChannelVector::value_type& GetRgbChannel( ChannelVector::size_type i ) const; /** * \return the band-index for the given component taking the * grayscale-mode activation state flag into account. */ inline ChannelVector::value_type GetSmartChannel( RgbwChannel channel ) const; /** * \return the band-index for the given component not taking the * grayscale-mode activation state flag into account. */ ChannelVector::value_type GetRgbwChannel( RgbwChannel channel ) const; /** * \return the channels band-index vector taking the * grayscale-mode activation state flag into account. */ inline void GetSmartChannels( ChannelVector& channels ) const; // // COLOR DYNAMICS. // /** */ inline void SetRgbDynamicsParams( const ParametersType& params ); /** */ inline const ParametersType& GetRgbDynamicsParams() const; /** */ inline ParametersType GetSmartDynamicsParams() const; /** * Set low-intensity dynamics parameter for given channel. If * channel is RGBW_CHANNEL_WHITE, this method sets all RGB * channels. * * \param channel The RGB/W channel to set low-intensity dynamics for. * \param intensity low-intensity value. */ void SetLowIntensity( RgbwChannel channel, ParametersType::ValueType intensity ); /** */ ParametersType::ValueType GetLowIntensity( RgbwChannel channel ) const; /** * Set high-intensity dynamics parameter for given channel. If * channel is RGBW_CHANNEL_WHITE, this method sets all RGB * channels. * * \param channel The RGB/W channel to set high-intensity dynamics for. * \param intensity high-intensity value. */ void SetHighIntensity( RgbwChannel channel, ParametersType::ValueType intensity ); /** */ ParametersType::ValueType GetHighIntensity( RgbwChannel channel ) const; // // GRAYSCALE MODE. // /** * \brief Set/clear grayscale-mode activation-state flag for image. */ inline void SetGrayscaleActivated( bool activated ); /** * \return Grayscale-mode activation state flag. */ inline bool IsGrayscaleActivated() const; /** * \brief Set white (gray) channel index. * * \param index The new index of white (gray) channel. */ inline void SetGrayChannel( unsigned int ); /** * \return White (gray) channel index. */ inline unsigned int GetGrayChannel() const; /** */ inline void SetGrayDynamicsParams( const ParametersType& params ); /** */ inline const ParametersType& GetGrayDynamicsParams() const; /** */ inline void SetGamma( double gamma ); /** */ inline double GetGamma() const; /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ inline const ParametersType::ValueType& GetRgbDynamicsParam( CountType i ) const; /** */ inline void SetRgbDynamicsParam( CountType i, const ParametersType::ValueType& param ); /** */ inline const ParametersType::ValueType& GetGrayDynamicsParam( bool high ) const; /** */ inline void SetGrayDynamicsParam( bool high, const ParametersType::ValueType& param ); // // Private attributes. private: /** * \brief Color-composition setup (file-component to video * RGB-components). */ ChannelVector m_RgbChannels; /** * \brief Color-dynamics parameters (\sa * HistogramModel::Quantile()). */ ParametersType m_RgbDynamicsParams; /** * \brief Grayscale-mode activation state. */ bool m_IsGrayscaleActivated; /** * \brief Grayscale-mode band-index. */ ChannelVector::value_type m_GrayChannel; /** * \brief Color-dynamics parameters (\sa * HistogramModel::Quantile()). */ ParametersType m_GrayDynamicsParams; /** */ double m_Gamma; }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ #if 0 inline VectorImageSettings & VectorImageSettings ::operator = ( const VectorImageSettings & other ) { if( &other==this ) return *this; m_RgbChannels = other.m_RgbChannels; m_RgbDynamicsParams = other.m_RgbDynamicsParams; m_IsGrayscaleActivated = other.m_IsGrayscaleActivated; m_GrayChannel = other.m_GrayChannel; m_GrayDynamicsParams = other.m_GrayDynamicsParams; m_Gamma = other.m_Gamma; return *this; } #endif /*****************************************************************************/ inline void VectorImageSettings ::SetRgbChannels( const ChannelVector& rgb ) { // qDebug() << "setRgbChannels()"; assert( m_RgbChannels.empty() || m_RgbChannels.size()==rgb.size() ); if( !m_RgbChannels.empty() && std::equal( m_RgbChannels.begin(), m_RgbChannels.end(), rgb.begin() ) ) return; m_RgbChannels = rgb; SetModified(); } /*****************************************************************************/ inline const VectorImageSettings::ChannelVector& VectorImageSettings ::GetRgbChannels() const { return m_RgbChannels; } /*****************************************************************************/ inline void VectorImageSettings ::GetSmartChannels( VectorImageSettings::ChannelVector& channels ) const { if( IsGrayscaleActivated() ) { channels.resize( m_RgbChannels.size() ); std::fill( channels.begin(), channels.end(), m_GrayChannel ); } else { channels = m_RgbChannels; } } /*****************************************************************************/ inline void VectorImageSettings ::SetRgbChannel( ChannelVector::size_type i, const ChannelVector::value_type& channel ) { // qDebug() << "SetRgbChannel()"; if( m_RgbChannels[ i ]==channel ) return; SetModified(); m_RgbChannels[ i ] = channel; } /*****************************************************************************/ inline const VectorImageSettings::ChannelVector::value_type& VectorImageSettings ::GetRgbChannel( ChannelVector::size_type i ) const { return m_RgbChannels[ i ]; } /*****************************************************************************/ inline VectorImageSettings::ChannelVector::value_type VectorImageSettings ::GetSmartChannel( RgbwChannel channel ) const { return GetRgbwChannel( m_IsGrayscaleActivated ? RGBW_CHANNEL_WHITE : channel ); /* if( m_IsGrayscaleActivated ) { return m_GrayChannel; } else { return GetRgbwChannel( channel ); } */ } /*****************************************************************************/ inline void VectorImageSettings ::SetRgbDynamicsParams( const ParametersType& params ) { // qDebug() << "SetDynamicsParams()"; assert( m_RgbDynamicsParams.size()==params.size() ); if( std::equal( m_RgbDynamicsParams.begin(), m_RgbDynamicsParams.end(), params.begin() ) ) return; m_RgbDynamicsParams = params; SetModified(); } /*****************************************************************************/ inline const ParametersType& VectorImageSettings ::GetRgbDynamicsParams() const { return m_RgbDynamicsParams; } /*****************************************************************************/ inline ParametersType VectorImageSettings ::GetSmartDynamicsParams() const { return m_IsGrayscaleActivated ? m_GrayDynamicsParams : m_RgbDynamicsParams; } /*****************************************************************************/ inline const ParametersType::ValueType& VectorImageSettings ::GetRgbDynamicsParam( CountType i ) const { return m_RgbDynamicsParams[ i ]; } /*****************************************************************************/ inline void VectorImageSettings ::SetRgbDynamicsParam( CountType i, const ParametersType::ValueType& param ) { // qDebug() << "SetDynamicsParam()"; if( m_RgbDynamicsParams[ i ]==param ) return; SetModified(); m_RgbDynamicsParams[ i ] = param; } /*****************************************************************************/ inline bool VectorImageSettings ::IsGrayscaleActivated() const { return m_IsGrayscaleActivated; } /*****************************************************************************/ inline void VectorImageSettings ::SetGrayscaleActivated( bool activated ) { m_IsGrayscaleActivated = activated; SetModified(); } /*****************************************************************************/ inline unsigned int VectorImageSettings ::GetGrayChannel() const { return m_GrayChannel; } /*****************************************************************************/ inline void VectorImageSettings ::SetGrayChannel( unsigned int index ) { m_GrayChannel = index; SetModified(); } /*****************************************************************************/ inline void VectorImageSettings ::SetGrayDynamicsParams( const ParametersType& params ) { // qDebug() << "SetDynamicsParams()"; assert( m_GrayDynamicsParams.size()==params.size() ); if( std::equal( m_GrayDynamicsParams.begin(), m_GrayDynamicsParams.end(), params.begin() ) ) { assert( false ); return; } m_GrayDynamicsParams = params; SetModified(); } /*****************************************************************************/ inline const ParametersType& VectorImageSettings ::GetGrayDynamicsParams() const { return m_GrayDynamicsParams; } /*****************************************************************************/ inline const ParametersType::ValueType& VectorImageSettings ::GetGrayDynamicsParam( bool high ) const { return m_GrayDynamicsParams[ high ? 1 : 0 ]; } /*****************************************************************************/ inline void VectorImageSettings ::SetGrayDynamicsParam( bool high, const ParametersType::ValueType& param ) { // qDebug() << "SetDynamicsParam()"; CountType ofs = high ? 1 : 0; if( m_GrayDynamicsParams[ 0 * 2 + ofs ]==param ) return; SetModified(); // Indices are detailed for better readability since the compiler // will optimize constants. m_GrayDynamicsParams[ 0 * 2 + ofs ] = param; m_GrayDynamicsParams[ 1 * 2 + ofs ] = param; m_GrayDynamicsParams[ 2 * 2 + ofs ] = param; } /*****************************************************************************/ inline void VectorImageSettings ::SetGamma( double value ) { m_Gamma = value; SetModified(); } /*****************************************************************************/ inline double VectorImageSettings ::GetGamma() const { return m_Gamma; } } // end namespace 'mvd' #endif // mvdVectorImageSettings_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/include/mvdVisibleInterface.h000066400000000000000000000072511301006202600303420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdVisibleInterface_h #define mvdVisibleInterface_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiCoreExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class VisibleInterface * * \ingroup OTBMonteverdiCore * * \brief WIP. */ class OTBMonteverdiCore_EXPORT VisibleInterface { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ VisibleInterface( bool =true ); /** \brief Destructor. */ virtual ~VisibleInterface(); /** */ inline void SetVisible( bool ); /** */ inline bool IsVisible() const; /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ virtual void virtual_SignalVisibilityChanged( bool ); // // Private attributes. private: bool m_IsVisible: 1; }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline bool VisibleInterface ::IsVisible() const { return m_IsVisible; } /*****************************************************************************/ inline void VisibleInterface ::SetVisible( bool state ) { m_IsVisible = state; virtual_SignalVisibilityChanged( state ); } } // end namespace 'mvd' #endif // mvdVisibleInterface_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/otb-module.cmake000066400000000000000000000007441301006202600256720ustar00rootroot00000000000000set(DOCUMENTATION "This module provides MonteverdiCore, the core library of the Monteverdi applications." ) otb_module( OTBMonteverdiCore ENABLE_SHARED DEPENDS OTBBoost OTBCarto OTBCommon OTBImageBase OTBImageIO OTBImageManipulation OTBIOGDAL OTBMetadata OTBObjectList OTBOSSIMAdapters OTBProjection OTBQt4 OTBStatistics OTBTransform OPTIONAL_DEPENDS OTBApplicationEngine DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/000077500000000000000000000000001301006202600234035ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/CMakeLists.txt000066400000000000000000000060051301006202600261440ustar00rootroot00000000000000############################################################################# set( OTBMonteverdiCore_SRCS mvdAbstractWorker.cxx mvdAbstractModel.cxx mvdAbstractImageModel.cxx mvdAbstractLayerModel.cxx mvdBackgroundTask.cxx mvdCore.cxx mvdDataStream.cxx mvdFilenameInterface.cxx mvdHistogramModel.cxx mvdI18nCoreApplication.cxx mvdImageImporter.cxx mvdImagePlacenameLoader.cxx mvdImageProperties.cxx mvdImageSettings.cxx mvdImageSettingsInterface.cxx mvdModifiableInterface.cxx mvdMyClass.cxx mvdOverviewBuilder.cxx mvdProcessObjectObserver.cxx mvdProgressInterface.cxx mvdQuicklookModel.cxx mvdSerializableInterface.cxx mvdStackedLayerModel.cxx mvdTextStream.cxx mvdTypes.cxx mvdVectorImageModel.cxx mvdVectorImageSettings.cxx mvdVisibleInterface.cxx ) set( OTBMonteverdiCore_HEADERS_MOC ../include/mvdAbstractImageModel.h ../include/mvdAbstractLayerModel.h ../include/mvdAbstractModel.h ../include/mvdAbstractWorker.h # ../include/mvdAlgorithm.h ../include/mvdBackgroundTask.h # ../include/mvdCore.h # ../include/mvdDatabaseConnection.h # ../include/mvdDatabaseError.h # ../include/mvdDatabaseModel.h # ../include/mvdDatabaseQueries.h # ../include/mvdDatasetDescriptor.h # ../include/mvdDatasetModel.h ../include/mvdHistogramModel.h ../include/mvdI18nCoreApplication.h ../include/mvdImageImporter.h ../include/mvdImagePlacenameLoader.h # ../include/mvdImageProperties.h # ../include/mvdMath.h ../include/mvdMyClass.h ../include/mvdOverviewBuilder.h ../include/mvdQuicklookModel.h ../include/mvdStackedLayerModel.h # ../include/mvdSystemError.h # ../include/mvdTypes.h ../include/mvdVectorImageModel.h ) ############################################################################# if( OTBApplicationEngine_ENABLED ) list( APPEND OTBMonteverdiCore_SRCS mvdApplicationsBrowser.cxx ) list( APPEND OTBMonteverdiCore_HEADERS_MOC ../include/mvdApplicationsBrowser.h ) endif() ############################################################################# add_to_qt4_i18n_sources( ${OTBMonteverdiCore_SRCS} ) add_to_qt4_i18n_headers( "../include" ${OTBMonteverdiCore_SRCS} ) ############################################################################# qt4_wrap_cpp( OTBMonteverdiCore_SRC_MOC ${OTBMonteverdiCore_HEADERS_MOC} ) add_library( OTBMonteverdiCore ${OTBMonteverdiCore_SRCS} ${OTBMonteverdiCore_SRC_MOC}) ############################################################################# target_link_libraries( OTBMonteverdiCore ${OTBApplicationEngine_LIBRARIES} ${OTBCarto_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBImageIO_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBIOGDAL_LIBRARIES} ${OTBMetadata_LIBRARIES} ${OTBObjectList_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBQt4_LIBRARIES} ${OTBStatistics_LIBRARIES} ${OTBTransform_LIBRARIES} ) ############################################################################# otb_module_target( OTBMonteverdiCore ) OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/ConfigureMonteverdi.h.in000066400000000000000000000062721301006202600301460ustar00rootroot00000000000000#ifndef ConfigureMonteverdi_h #define ConfigureMonteverdi_h // // Monteverdi project #define PROJECT_NAME "@Monteverdi_PROJECT_NAME@" // // Monteverdi version. #define Monteverdi_VERSION_MAJOR @Monteverdi_VERSION_MAJOR@ #define Monteverdi_VERSION_MINOR @Monteverdi_VERSION_MINOR@ #define Monteverdi_VERSION_PATCH @Monteverdi_VERSION_PATCH@ #define Monteverdi_VERSION_SUFFIX @Monteverdi_VERSION_SUFFIX@ #define Monteverdi_VERSION_STRING "@Monteverdi_VERSION_STRING@" // // Monteverdi data version. #define Monteverdi_DATA_VERSION_MAJOR @Monteverdi_DATA_VERSION_MAJOR@ #define Monteverdi_DATA_VERSION_MINOR @Monteverdi_DATA_VERSION_MINOR@ #define Monteverdi_DATA_VERSION_PATCH @Monteverdi_DATA_VERSION_PATCH@ #define Monteverdi_DATA_VERSION_STRING "@Monteverdi_DATA_VERSION_STRING@" // // Monteverdi data version. #define Monteverdi_UI_VERSION @Monteverdi_UI_VERSION@ // // Directories #define Monteverdi_INSTALL_BIN_DIR "@OTB_INSTALL_BIN_DIR@" #define Monteverdi_INSTALL_INCLUDE_DIR "@OTB_INSTALL_INCLUDE_DIR@" #define Monteverdi_INSTALL_LIB_DIR "@OTB_INSTALL_LIB_DIR@" #define Monteverdi_INSTALL_DATA_DIR "@OTB_INSTALL_DATA_DIR@" // #define OTB_VERSION_CHECK( M, m, p ) \ (OTB_VERSION_MAJOR>(M) || \ (OTB_VERSION_MAJOR==(M) && (OTB_VERSION_MINOR>(m) || \ OTB_VERSION_MINOR==(m) && OTB_VERSION_PATH>=(p)))) // // Sub-directories #define Monteverdi_INSTALL_DATA_I18N_DIR Monteverdi_INSTALL_DATA_DIR "/i18n" // // Files #define Monteverdi_CONFIGURE_FILE "@Monteverdi_CONFIGURE_FILE@" #define Monteverdi_BUILD_DIR_FILE "CMakeCache.txt" // // Miscellaneous #define Monteverdi_FLOATING_TYPE @Monteverdi_FLOATING_TYPE@ #define Monteverdi_DIMENSION int( 2 ) // // Qt Message handling and logging. #ifndef NO_QECHO #define NO_QECHO 0 #endif #ifndef NO_QDEBUG #define NO_QDEBUG 0 #endif #ifndef NO_QWARNING #define NO_QWARNING 0 #endif #ifndef NO_QCRITICAL #define NO_QCRITICAL 0 #endif #ifndef NO_QFATAL #define NO_QFATAL 0 #endif #ifndef NO_QLOG #define NO_QLOG 0 #endif #ifndef NO_QTHROW #define NO_QTHROW 0 #endif #ifndef ECHO_QDEBUG #define ECHO_QDEBUG ( ( !NO_QECHO && !NO_QDEBUG && defined( OTB_DEBUG ) && 1 ) || 0 ) #endif #ifndef ECHO_QWARNING #define ECHO_QWARNING ( !NO_QECHO && !NO_QWARNING && 1 ) #endif #ifndef ECHO_QCRITICAL #define ECHO_QCRITICAL ( !NO_QECHO && !NO_QCRITICAL && 1 ) #endif #ifndef ECHO_QFATAL #define ECHO_QFATAL ( !NO_QECHO && !NO_QFATAL && 1 ) #endif #ifndef LOG_QDEBUG #define LOG_QDEBUG ( !NO_QLOG && !NO_QDEBUG && defined( OTB_DEBUG ) && 0 ) #endif #ifndef LOG_QWARNING #define LOG_QWARNING ( !NO_QLOG && !NO_QWARNING && 0 ) #endif #ifndef LOG_QCRITICAL #define LOG_QCRITICAL ( !NO_QLOG && !NO_QCRITICAL && 0 ) #endif #ifndef LOG_QFATAL #define LOG_QFATAL ( !NO_QLOG && !NO_QFATAL && 0 ) #endif #ifndef THROW_QCRITICAL #define THROW_QCRITICAL ( !NO_QTHROW && !NO_QCRITICAL && 1 ) #endif #ifndef THROW_QFATAL #define THROW_QFATAL ( !NO_QTHROW && !NO_QFATAL && 1 ) #endif #include "otbConfigure.h" #include "otbMacro.h" // // Options // #if (defined( OTB_DEBUG ) && FORCE_DISABLE) || FORCE_ENABLE #define USE_OPTION_SAMPLE ((defined( OTB_DEBUG ) && 0) || 0) // // Macros #endif // ConfigureMonteverdi_h OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdAbstractImageModel.cxx000066400000000000000000000204571301006202600303350ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdAbstractImageModel.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. /*****************************************************************************/ /* INCLUDE SECTION */ // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdQuicklookModel.h" namespace mvd { /* TRANSLATOR mvd::AbstractImageModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { /** * \brief Array of enhanced band names that OTB can return. * * It is defined (statically) as a constant for translation purposes. */ char const * const ENHANCED_BAND_NAMES[ 10 ] = { QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "Red" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "Green" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "Blue" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "Yellow" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "RedEdge" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "Coastal" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "NIR" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "NIR1" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "NIR2" ), QT_TRANSLATE_NOOP( "mvd::AbstractImageModel", "PAN" ), }; } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ namespace hidden { // Do never call this private hidden function. void fix_unused_variable_warning() { // This variable is used to declare OTB band names to the Qt I18N // translation process. // // The translated string are used by side effect to the // QObject::translate() function which searches the translated // strings from the .qm files loaded at runtime. (void)ENHANCED_BAND_NAMES; } }; /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ AbstractImageModel ::AbstractImageModel( QObject* p ) : AbstractLayerModel( p ), m_NativeLargestRegion(), m_Id( -1 ), m_CurrentLod( 0 ), m_Properties( NULL ) { } /*******************************************************************************/ AbstractImageModel ::~AbstractImageModel() { SetProperties( NULL ); } /*****************************************************************************/ const QuicklookModel* AbstractImageModel ::GetQuicklookModel() const { return findChild< const QuicklookModel* >(); } /*****************************************************************************/ QuicklookModel* AbstractImageModel ::GetQuicklookModel() { return findChild< QuicklookModel* >(); } /*******************************************************************************/ QStringList AbstractImageModel ::GetBandNames( bool enhanced ) const { ImageBaseType::ConstPointer output( ToImageBase() ); otb::ImageMetadataInterfaceBase::ConstPointer metaDataInterface( GetMetaDataInterface() ); // // Basic band names. StringVector stdBandNames1( metaDataInterface->GetBandName() ); // output band name list QStringList qBandNames1( QString("") ); // // PS: need to handle images with extracted channels and a geom file // storing the original image band names. if (stdBandNames1.empty() || stdBandNames1.size()!=output->GetNumberOfComponentsPerPixel()) { // output stringVector StringVector outputBandNames; // // Fill the output std::vector with default values for( unsigned int count = 0; count < output->GetNumberOfComponentsPerPixel(); count++) { std::ostringstream oss; oss <GetNumberOfComponentsPerPixel() ); if( stdBandNames1.size()!=output->GetNumberOfComponentsPerPixel() ) { stdBandNames1.resize( output->GetNumberOfComponentsPerPixel() ); } // // Enhanced band names. StringVector stdBandNames2; if( enhanced ) { try { stdBandNames2 = metaDataInterface->GetEnhancedBandNames(); } catch( std::exception& exc ) { qWarning() << exc.what(); } } assert( stdBandNames2.empty() || stdBandNames2.size()==output->GetNumberOfComponentsPerPixel() ); if( stdBandNames2.size()!=output->GetNumberOfComponentsPerPixel() ) { stdBandNames2.resize( output->GetNumberOfComponentsPerPixel() ); } // // Join basic and enhanced band-name lists. assert( stdBandNames1.size()==stdBandNames2.size() ); qBandNames1 = ToQStringList( stdBandNames1 ); QStringList qBandNames2( ToQStringList( stdBandNames2 ) ); assert( qApp!=NULL ); QStringList::iterator it1( qBandNames1.begin() ); QStringList::const_iterator it2( qBandNames2.begin() ); for( ; it1!=qBandNames1.end(); ++it1, ++it2 ) { if( !it2->isEmpty() ) it1->append( " (" + qApp->translate( "mvd::AbstractImageModel", it2->toAscii().constData() ) + ")" ); } } // // Return joined band-name list. return qBandNames1; } /*******************************************************************************/ void AbstractImageModel ::RefreshHistogram( void* const context ) { // qDebug() << this << "::RefreshHistogram(" << context << ")"; // Remember existing child histogram. HistogramModel* currentHistogramModel = GetHistogramModel(); #if 0 // Access histogram-model build-context. HistogramModel::BuildContext* const buildContext = static_cast< HistogramModel::BuildContext* const >( context ); // Force writing histgram file by setting IsBeingStored flag. buildContext->m_IsBeingStored = true; #endif // Create new child histogram providing build-context. newChildModel< HistogramModel >( context ); // Delete (and remove) previous child histogram. delete currentHistogramModel; currentHistogramModel = NULL; } /*******************************************************************************/ void AbstractImageModel ::virtual_BuildModel( void* context ) { // // Retrieve proper build-context. assert( context!=NULL ); BuildContext* buildContext = static_cast< BuildContext* >( context ); // // ID. m_Id = buildContext->m_Id; // // QUICKLOOK. // // Build quicklook before histogram because histogram calculation is // based on quicklook image. newChildModel< QuicklookModel >( context ); // // HISTOGRAM. if( buildContext->m_Histogram.isEmpty() ) newChildModel< HistogramModel >(); else { HistogramModel::BuildContext histogramContext( buildContext->IsBeingStored(), buildContext->m_Histogram ); newChildModel< HistogramModel >( &histogramContext ); } } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdAbstractLayerModel.cxx000066400000000000000000000130231301006202600303560ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdAbstractLayerModel.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include "ogr_spatialref.h" // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdTypes.h" namespace mvd { /* TRANSLATOR mvd::AbstractLayerModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { char const * const STR_SENSOR = QT_TRANSLATE_NOOP( "mvd::AbstractLayerModel", "Sensor" ); char const * const STR_UNKNOWN = QT_TRANSLATE_NOOP( "mvd::AbstractLayerModel", "Unknown" ); } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ SpatialReferenceType GetSpatialReferenceType( const std::string & filename ) { DefaultImageFileReaderType::Pointer reader( DefaultImageFileReaderType::New() ); assert( !reader.IsNull() ); reader->SetFileName( filename ); reader->UpdateOutputInformation(); DefaultImageType * image = reader->GetOutput(); assert( image!=NULL ); return GetSpatialReferenceType( image->GetProjectionRef(), image->GetImageKeywordlist().GetSize()>0 ); } /*****************************************************************************/ SpatialReferenceType GetSpatialReferenceType( const std::string & wkt, bool hasKwl ) { if( wkt.empty() ) return hasKwl ? SRT_SENSOR : SRT_UNKNOWN; OGRSpatialReference ogr_sr( wkt.c_str() ); const char * epsg = ogr_sr.GetAuthorityCode( "PROJCS" ); if( epsg!=NULL && strcmp( epsg, "" )!=0 ) return SRT_CARTO; epsg = ogr_sr.GetAuthorityCode( "GEOGCS" ); if( epsg!=NULL && strcmp( epsg, "" )!=0 ) return SRT_GEO; return SRT_UNKNOWN; } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ AbstractLayerModel ::AbstractLayerModel( QObject* p ) : AbstractModel( p ), VisibleInterface() { } /*******************************************************************************/ AbstractLayerModel ::~AbstractLayerModel() { } /*******************************************************************************/ SpatialReferenceType AbstractLayerModel ::GetSpatialReferenceType() const { return mvd::GetSpatialReferenceType( GetWkt(), HasKwl() ); } /*******************************************************************************/ std::string AbstractLayerModel ::GetWkt() const { return virtual_GetWkt(); } /*******************************************************************************/ std::string AbstractLayerModel ::GetAuthorityCode( bool isEnhanced ) const { std::string wkt( GetWkt() ); if( wkt.empty() ) return !isEnhanced ? std::string() : ( HasKwl() ? ToStdString( tr( STR_SENSOR ) ) : ToStdString( tr( STR_UNKNOWN ) ) ); OGRSpatialReference ogr_sr( wkt.c_str() ); const char * epsg = ogr_sr.GetAuthorityCode( "PROJCS" ); if( epsg!=NULL && strcmp( epsg, "" )!=0 ) return epsg; epsg = ogr_sr.GetAuthorityCode( "GEOGCS" ); if( epsg==NULL || strcmp( epsg, "" )==0 ) return ToStdString( tr( STR_UNKNOWN ) ); return epsg; } /*******************************************************************************/ bool AbstractLayerModel ::HasKwl() const { return virtual_HasKwl(); } /*****************************************************************************/ void AbstractLayerModel ::ToWgs84( const PointType & p, PointType & wgs84, double & alt) const { virtual_ToWgs84( p, wgs84, alt ); } /*******************************************************************************/ bool AbstractLayerModel ::virtual_HasKwl() const { return false; } /*******************************************************************************/ void AbstractLayerModel ::virtual_SignalVisibilityChanged( bool isVisible ) { emit VisibilityChanged( isVisible ); emit VisibilityChanged( this, isVisible ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdAbstractModel.cxx000066400000000000000000000052701301006202600273660ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdAbstractModel.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::AbstractModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ AbstractModel ::AbstractModel( QObject* p ) : QObject( p ) { } /*******************************************************************************/ AbstractModel ::~AbstractModel() { } /*******************************************************************************/ bool AbstractModel ::IsModified() const { return false; } /*******************************************************************************/ void AbstractModel ::ClearModified() { } /*******************************************************************************/ void AbstractModel ::virtual_Save() { qDebug() << this << "::Save()"; } /*******************************************************************************/ void AbstractModel ::virtual_BuildModel( void * model ) { qDebug() << this << "::virtual_BuildModel(" << model << ")"; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdAbstractWorker.cxx000066400000000000000000000067611301006202600276050ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdAbstractWorker.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdI18nCoreApplication.h" namespace mvd { /* TRANSLATOR mvd::AbstractWorker Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ AbstractWorker ::AbstractWorker( QObject* p ) : QObject( p ) { } /*******************************************************************************/ AbstractWorker ::~AbstractWorker() { } /*****************************************************************************/ void AbstractWorker ::Do() throw() { QObject* result = NULL; try { // Just do it and get resulting QObject. result = virtual_Do(); // Access application. const QCoreApplication* app = QCoreApplication::instance(); assert( app!=NULL ); // Move object into application's main thread. // // We can only push to another thread, // so thread affinity must be set here, // and not in the slot that receives the object. if( result!=NULL && result->thread()!=app->thread() ) result->moveToThread( app->thread() ); // Emit task/job has correctly been done giving resulting object // to main thread. emit Done( result ); } catch( std::exception& exc ) { // Delete allocated object. delete result; result = NULL; // Emit task/job has incorrectly been done giving clone of // exception to main thread. emit ExceptionRaised( FromStdString( exc.what() ) ); } // Emit task/job has finished (thread can be signal to quit()). emit Finished(); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdApplicationsBrowser.cxx000066400000000000000000000135341301006202600306360ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdApplicationsBrowser.h" #include "mvdAlgorithm.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbWrapperApplicationRegistry.h" #include "otbWrapperApplication.h" // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::ApplicationsBrowser Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ApplicationsBrowser ::ApplicationsBrowser( QObject* p ) : QObject( p ), m_AutoLoadPath("") { } /*******************************************************************************/ ApplicationsBrowser ::~ApplicationsBrowser() { } /*******************************************************************************/ void ApplicationsBrowser ::SetAutoLoadPath(const std::string & itk_auto_load_path) { m_AutoLoadPath = itk_auto_load_path; // // add the path otb::Wrapper::ApplicationRegistry::AddApplicationPath(m_AutoLoadPath); } /*******************************************************************************/ StringVector ApplicationsBrowser ::GetAvailableApplications() { // // get available application in search path StringVector appList( otb::Wrapper::ApplicationRegistry::GetAvailableApplications() ); // // some verbosity // TODO : remove this verbosity later if ( appList.size() == 0 ) { qWarning() << "Available OTB applications: NONE!"; } else { qDebug() << "Available OTB applications:"; for( StringVector::const_iterator it( appList.begin() ); it!=appList.end(); ++it ) { qDebug() << "- " << it->c_str(); } } return appList; } /*******************************************************************************/ StringVector ApplicationsBrowser ::GetApplicationTags( const std::string& appName ) { // // instantiate the application using the factory otb::Wrapper::Application::Pointer application( otb::Wrapper::ApplicationRegistry::CreateApplication( appName ) ); if( application.IsNull() ) return StringVector(); // // get tags StringVector vtags( application->GetDocTags() ); // // fill the OTBApps 'docName <-> name' map m_DocNameToNameMap[ application->GetDocName() ] = appName; return vtags; } /*******************************************************************************/ void ApplicationsBrowser ::SearchAvailableApplicationsTags() { // // clear previously filled map m_DocNameToNameMap.clear(); // // get all the applications in the search path StringVector vapp( GetAvailableApplications() ); // // Fill the map as following // - key -> tag // - value -> list of applications having this tag ApplicationsTagContainer outputContainer; StringVector::const_iterator it = vapp.begin(); while ( it != vapp.end() ) { // get tags of current app StringVector ctags = GetApplicationTags( *it ); // case applications has no tag associated if (ctags.size() == 0 ) { // add a default tag 'unknown'. The processing after remains // unchanged ctags.push_back( ToStdString(tr("Uncategorized")) ); } // key will be the tag (easier for tree origanisation in ) StringVector::const_iterator itTag = ctags.begin(); while ( itTag != ctags.end() ) { // search for this tag in the output container ApplicationsTagContainer::iterator pos = outputContainer.find( *itTag ); if ( pos != outputContainer.end() ) // key found { // // append the application name (*it) (*pos).second.push_back(*it); } else { // // if tag not found in the container, add it std::pair< std::string, StringVector > currentAppTags; currentAppTags.first = *itTag; currentAppTags.second.push_back( *it ); outputContainer.insert( currentAppTags ); } ++itTag; } ++it; } // // emit a signal with the ApplicationsTagContainer as // parameter emit AvailableApplicationsTagsChanged(outputContainer, m_DocNameToNameMap); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdBackgroundTask.cxx000066400000000000000000000125401301006202600275420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdBackgroundTask.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractWorker.h" #include "mvdAlgorithm.h" namespace mvd { /* TRANSLATOR mvd::BackgroundTask Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ BackgroundTask ::BackgroundTask( AbstractWorker* worker, bool autoDestroy, QObject* p ) : QThread( p ), m_Worker( worker ) { // Check worker argument. assert( m_Worker!=NULL ); assert( m_Worker->parent()==NULL ); if( m_Worker->parent()!=NULL ) throw std::invalid_argument( ToStdString( tr( "Worker must not be parented in order to be moved to another thread." ) ) ); // Change thread affinity and take ownership of managed worker. m_Worker->moveToThread( this ); // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // Do not re-parent worker to background-task thread here since it // will generate a 'WARNG> QObject::setParent: Cannot set parent, // new parent is in a different thread' warning message from Qt. // // m_Worker->setParent( this ); // When thread is started, start doing worker job. QObject::connect( this, SIGNAL( started() ), // to: worker, SLOT( Do() ) ); // When worker has finished its job, quit thread. QObject::connect( worker, SIGNAL( Finished() ), // to: this, SLOT( quit() ) ); // Keep informed When some object is destroyed. QObject::connect( worker, SIGNAL( destroyed( QObject* ) ), // to: this, SLOT( OnObjectDestroyed( QObject* ) ) ); // Conditionally auto-destroy this background task. if( autoDestroy ) { // When thread has finished. QObject::connect( this, SIGNAL( finished() ), // to: this, SLOT( deleteLater() ) ); // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // NEVER deleteLater() (i.e. asynchronously) worker instance. // // QObject::connect( // this, SIGNAL( finished() ), // // to: // worker, SLOT( deleteLater() ) // ); } } /*******************************************************************************/ BackgroundTask ::~BackgroundTask() { // Trace. // qDebug() << this << "is being destroyed."; // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // Warns if this background-task thread is still running while // destroying instance. // // Thread cannot be forced to quit() & wait() nor terminate() // because it would emit signal while execution of instance // destructor. This could be DANGEROUS. assert( isFinished() ); if( isRunning() ) qWarning() << this << "is being destroyed while still running!"; // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // Synchronously delete owned worker instance when this // background-task is being destroyed. delete m_Worker; m_Worker = NULL; // Trace. // qDebug() << this << "has been destroyed."; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void BackgroundTask ::OnObjectDestroyed( QObject* object ) { // NOTE: Won't be called if deleteLater() is used!? // qDebug() << this << "::OnObjectDestryed(" << object << ")"; // // If worker instance is destroyed before this instance, simply // forget worker instance. assert( object==m_Worker ); if( object==m_Worker ) { // qDebug() << this << "forgetting" << m_Worker; m_Worker = NULL; } } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdCore.cxx000066400000000000000000000052701301006202600255320ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdCore.h" // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::Core Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. ITK_EXPORT const char* RGBW_CHANNEL_NAMES[ RGBW_CHANNEL_COUNT ] = { "RGBW_CHANNEL_RED", "RGBW_CHANNEL_GREEN", "RGBW_CHANNEL_BLUE", "RGBW_CHANNEL_WHITE", "RGBW_CHANNEL_RGB", "RGBW_CHANNEL_ALL" }; const char* BOUND_NAMES[ BOUND_COUNT ] = { "BOUND_LOWER", "BOUND_UPPER" }; char const * const EFFECT_NAMES[ EFFECT_COUNT ] = { // QT_TRANSLATE_NOOP( "mvd", "None" ), QT_TRANSLATE_NOOP( "mvd", "Chessboard" ), QT_TRANSLATE_NOOP( "mvd", "Gradient" ), QT_TRANSLATE_NOOP( "mvd", "Local contrast" ), QT_TRANSLATE_NOOP( "mvd", "Local translucency" ), QT_TRANSLATE_NOOP( "mvd", "Normal" ), QT_TRANSLATE_NOOP( "mvd", "Spectral angle" ), QT_TRANSLATE_NOOP( "mvd", "Swipe (horizontal)" ), QT_TRANSLATE_NOOP( "mvd", "Swipe (vertical)" ), }; bool OVERVIEWS_ENABLED_DEFAULT = true; int OVERVIEWS_SIZE_DEFAULT = 4096; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdDataStream.cxx000066400000000000000000000057751301006202600267010ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdDataStream.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::DataStream Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ class StaticInitializer { public: StaticInitializer() { Initialize(); } ~StaticInitializer() { Finalize(); } private: inline void Initialize() { // // Call qRegisterMetaType<>() to make type available in // non-template signatures and serialization. // // Register serialization operators for custom meta-types. } inline void Finalize() { } }; namespace { static const StaticInitializer STATIC_INITIALIZER; } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ } // end namespace 'mvd' /*****************************************************************************/ /* GLOBAL FUNCTION IMPLEMENTATION SECTION */ /*****************************************************************************/ QDataStream& operator << ( QDataStream& out, void const * & pointer ) { /* qDebug() << "QDataStream& operator << ( QDataStream&, void const * & );"; */ DATA_STREAM_OUT( out, void, pointer ); return out; } /*****************************************************************************/ QDataStream& operator >>( QDataStream& in, void * & pointer ) { /* qDebug() << "QDataStream& operator >> ( QDataStream&, void * & );"; */ DATA_STREAM_IN( in, void, pointer ); return in; } OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdFilenameInterface.cxx000066400000000000000000000053271301006202600302060ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdFilenameInterface.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::FilenameInterface Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ FilenameInterface ::FilenameInterface() : m_Filename() { } /*****************************************************************************/ FilenameInterface ::~FilenameInterface() { } /*****************************************************************************/ void FilenameInterface ::SetFilename( const QString & filename ) { m_Filename = filename; virtual_SetFilename( filename ); } /*****************************************************************************/ const QString & FilenameInterface ::GetFilename() const { return m_Filename; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdHistogramModel.cxx000066400000000000000000000310151301006202600275540ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdHistogramModel.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdTextStream.h" #include "mvdQuicklookModel.h" namespace mvd { /* TRANSLATOR mvd::HistogramModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ HistogramModel::RealType HistogramModel ::GetEpsilon() { if( boost::is_floating_point< DefaultImageType::PixelType::ValueType >::value ) return std::pow( 10.0, -HistogramModel::PRECISION - 1 ); else return 1; } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ HistogramModel ::HistogramModel( QObject* p ) : AbstractModel( p ), m_Histograms(), m_MinPixel(), m_MaxPixel() { m_MinPixel.Fill( 0 ); m_MaxPixel.Fill( 0 ); } /*******************************************************************************/ HistogramModel ::~HistogramModel() { } /*******************************************************************************/ bool HistogramModel ::IsValid() const { // qDebug() << this << "::IsValid() ->" << ( !m_Histograms.IsNull() && m_Histograms->Size()>0 ); return !m_Histograms.IsNull() && m_Histograms->Size()>0; } /*******************************************************************************/ bool HistogramModel ::IsMonoValue() const { // qDebug() << this << "::IsMonoValue() ->" << m_MinPixel==m_MaxPixel; return m_MinPixel==m_MaxPixel; } /*******************************************************************************/ HistogramModel::MeasurementType HistogramModel ::Quantile( unsigned int band, double p ) const { assert( bandSize() ); // qDebug() // << "Quantile" << p << ":" << // ( IsMonoValue() // ? m_MinPixel[ band ] // : m_Histograms->GetNthElement( band )->Quantile( 0, p ) ); return IsMonoValue() ? m_MinPixel[ band ] : m_Histograms->GetNthElement( band )->Quantile( 0, p ); } /*******************************************************************************/ HistogramModel::MeasurementType HistogramModel ::Quantile( unsigned int band, double p, Bound bound ) const { return Quantile( band, bound==BOUND_UPPER ? 1.0 - p : p ); } /*******************************************************************************/ double HistogramModel ::Percentile( CountType band, MeasurementType intensity, Bound bound ) const { // Get histogram of band. Histogram::Pointer histogram( m_Histograms->GetNthElement( band ) ); // Construct 1D measurement vector. assert( histogram->GetMeasurementVectorSize()==1 ); Histogram::MeasurementVectorType measurement( 1 ); { assert( histogram->GetSize( 0 ) > 0 ); Histogram::MeasurementType binMin( histogram->GetBinMin( 0, 0 ) ); Histogram::MeasurementType binMax( histogram->GetBinMax( 0, histogram->GetSize( 0 ) - 1 ) ); // Due to float/double conversion, it can happen // that the minimum or maximum value go slightly outside the histogram // Clamping the value solves the issue and avoid RangeError // itk::NumericsTraits<>::Clamp(...) was removed // TODO : when otb::Clamp will be developed, use this function measurement[ 0 ] = intensity < binMin ? binMin : ( intensity > binMax ? binMax : intensity ); } // Get the index of measurement in 1D-histogram. Histogram::IndexType index; if( !histogram->GetIndex( measurement, index ) ) throw itk::RangeError( __FILE__, __LINE__ ); assert( index.GetSize()==1 ); // Min/max intensities of bin. MeasurementType minI = histogram->GetBinMin( 0, index[ 0 ] ); MeasurementType maxI = histogram->GetBinMax( 0, index[ 0 ] ); assert( minI <= maxI ); MeasurementType rangeI = vcl_abs( maxI - minI ); // Frequency of current bin Histogram::AbsoluteFrequencyType frequency( histogram->GetFrequency( index ) ); double percent = ( IsMonoValue() || rangeI <= std::numeric_limits< MeasurementType >::epsilon() ) ? 0.0 : frequency * ( bound == BOUND_LOWER ? ( intensity - minI ) : ( maxI - intensity ) ) / rangeI; // Number of bins of histogram. Histogram::SizeType::SizeValueType binCount = histogram->Size(); // Initialize bound indices. assert( index[ 0 ]>=0 ); Histogram::SizeType::SizeValueType index0 = index[ 0 ]; Histogram::SizeType::SizeValueType i0 = 0; Histogram::SizeType::SizeValueType iN = binCount; switch( bound ) { case BOUND_LOWER: i0 = 0; iN = index[ 0 ]; break; case BOUND_UPPER: i0 = index0 < binCount ? index0 + 1 : binCount; iN = binCount; break; default: assert( false && "Implement case statement of switch instruction." ); break; }; // Traverse lower/upper bound (contribution of other bins) Histogram::SizeType::SizeValueType i; for( i=i0; iGetFrequency( i, 0 ); // Calculate frequency rate. percent /= histogram->GetTotalFrequency(); // Return frequency rate. return percent; } /*******************************************************************************/ void HistogramModel ::GetData( CountType band, double * const x, double * const y, double& xMin, double& xMax, double& yMin, double& yMax ) const { assert( x!=NULL ); assert( y!=NULL ); // Get histogram of band. Histogram::Pointer histogram( m_Histograms->GetNthElement( band ) ); assert( !histogram.IsNull() ); // Get number of bins for each dimension. Histogram::SizeType size( histogram->GetSize() ); // Ensure dimension is 1. assert( histogram->GetMeasurementVectorSize()==1 ); // Initialize bounds. assert( std::numeric_limits< double >::has_infinity ); yMax = -std::numeric_limits< double >::infinity(); yMin = 0; xMin = histogram->GetBinMin( 0, 0 ); xMax = histogram->GetBinMax( 0, size[ 0 ] - 1 ); // Traverse samples. for( unsigned long bin=0; binGetFrequency( bin, 0 ) ); if( f>yMax ) yMax = f; if( fGetBinMin( 0, bin ); y[ i ] = f; ++ i; x[ i ] = histogram->GetBinMax( 0, bin ); y[ i ] = f; // Warning: // coordinates for (x, y) curve will cause graphical artifacts if // max[ bin ]!=min[ bin + 1]. #elif HISTOGRAM_CURVE_TYPE==1 x[ bin ] = histogram->GetBinMin( 0, bin ); y[ bin ] = f; #elif HISTOGRAM_CURVE_TYPE==2 CountType i = 4 * bin; x[ i ] = histogram->GetBinMin( 0, bin ); y[ i ] = 0; x[ i + 1 ] = x[ i ]; y[ i + 1 ] = f; x[ i + 2 ] = histogram->GetBinMax( 0, bin ); y[ i + 2 ] = f; x[ i + 3 ] = x[ i + 2 ]; y[ i + 3 ] = 0; #else assert( false && "Unknown HISTOGRAM_CURVE_TYPE value" ); #endif } } /*******************************************************************************/ void HistogramModel ::virtual_BuildModel( void* context ) { if( context==NULL ) { template_BuildModel_M< VectorImageModel >(); // template_BuildModel_I< VectorImageModel::SourceImageType >(); // template_BuildModel< otb::Image< FixedArray< double, 4 >, 2 > >(); // template_BuildModel< otb::Image< itk::FixedArray< float, 4 >, 2 > >(); /* template_BuildModel< otb::VectorImage< float, 2 > >(); template_BuildModel< otb::Image< float, 2 > >(); */ } else { // Retrieve proper build-context. BuildContext* buildContext = static_cast< BuildContext* >( context ); if( buildContext->IsBeingStored() ) { template_BuildModel_M< VectorImageModel >( buildContext ); Write( buildContext->m_Filename, SerializableInterface::MODE_TEXT ); } else { if( buildContext->m_Filename.isEmpty() ) { template_BuildModel_M< VectorImageModel >( buildContext ); } else { Read( buildContext->m_Filename, SerializableInterface::MODE_TEXT ); } } } } /*******************************************************************************/ void HistogramModel ::virtual_Read( QIODevice* device ) { // qDebug() << this << "::virtual_Read(" << device << ")"; qDebug() << tr( "%1: Reading histogram..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); QTime time; time.start(); QTextStream stream( device ); QString string; QString version; ReadStreamTag( stream, string, PROJECT_NAME, false ); ReadStreamTag( stream, version, QString(), false ); ReadStreamTag( stream, string, "HISTOGRAM-MODEL", false ); ReadStreamTag( stream, string, "MIN-PIXEL" ); stream >> m_MinPixel; ReadStreamTag( stream, string, "MAX-PIXEL" ); stream >> m_MaxPixel; ReadStreamTag( stream, string, "BANDS" ); CountType size = 0; stream >> size; CheckStreamStatus( stream ); HistogramList::Pointer histograms( HistogramList::New() ); histograms->Initialize(); histograms->Resize( size ); for( CountType i=0; iSetMeasurementVectorSize(1); stream >> *histogram; histograms->SetNthElement( i, histogram ); } m_Histograms = histograms; qDebug() << tr( "%1: Histogram read (%2 ms)..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( time.elapsed() ); } /*******************************************************************************/ void HistogramModel ::virtual_Write( QIODevice& device ) const { // qDebug() << this << "::virtual_Write(" << &device << ")"; qDebug() << tr( "%1: Writing histogram..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ); QTime time; time.start(); #if 0 QByteArray byteArray; QTextStream stream( &byteArray, device.openMode() ); #else QTextStream stream( &device ); #endif stream << PROJECT_NAME << endl; stream << Monteverdi_DATA_VERSION_STRING << endl; stream << "HISTOGRAM-MODEL" << endl; WriteStreamTag( stream, "MIN-PIXEL" ); stream << m_MinPixel << endl; WriteStreamTag( stream, "MAX-PIXEL" ); stream << m_MaxPixel << endl; WriteStreamTag( stream, "BANDS" ); stream << m_Histograms->Size() << endl; for( HistogramList::ConstIterator it( m_Histograms->Begin() ); it!=m_Histograms->End(); ++it ) { stream << *it.Get(); } stream << flush; CheckStreamStatus( stream ); qDebug() << tr( "%1: Histogram written (%2 ms)..." ) .arg( QDateTime::currentDateTime().toString( Qt::ISODate ) ) .arg( time.elapsed() ); #if 0 qDebug() << byteArray; if( device.write( byteArray )!=byteArray.size() ) throw SystemError(); #else #endif } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdI18nCoreApplication.cxx000066400000000000000000000451541301006202600303630ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdI18nCoreApplication.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #ifdef _WIN32 #include #endif #include // // OTB includes (sorted by alphabetic order) #include "otbDEMHandler.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdSystemError.h" #include "mvdVectorImageModel.h" #define FORCE_QDEBUG 0 #define FORCE_QWARNING 0 #define FORCE_QCRITICAL 0 #define FORCE_QFATAL 0 namespace mvd { /* TRANSLATOR mvd::I18nCoreApplication Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ const char* I18nCoreApplication::DEFAULT_CACHE_DIR_NAME = "mvd2"; const char* I18nCoreApplication::DEFAULT_CACHE_RESULT_DIR_NAME = "result"; const char* I18nCoreApplication::DATASET_EXT = ".ds"; const char* I18nCoreApplication::SETTINGS_KEYS[ SETTINGS_KEY_COUNT ] = { "geoidPath", "geoidPathActive", "overviewsEnabled", "overviewsSize", "resolutionAlgorithm", "resultsDir", "srtmDir", "srtmDirActive", "tileSize", }; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ I18nCoreApplication* I18nCoreApplication::m_Instance = NULL; /*******************************************************************************/ bool I18nCoreApplication ::IsResultsDirValid( const QString& path ) { QDir dir( path ); QFileInfo fileInfo( path ); return fileInfo.exists() && fileInfo.isDir() && fileInfo.isReadable() && fileInfo.isWritable(); } /*******************************************************************************/ bool I18nCoreApplication ::MakeDirTree( const QString& path, const QString& tree, QDir* dir ) { QDir pathDir( path ); if( !pathDir.exists() ) throw SystemError( ToStdString( QString( "('%1')" ).arg( path ) ) ); QDir treeDir( pathDir.filePath( tree ) ); if( treeDir.exists() ) { if( dir!=NULL ) { *dir = treeDir; } return false; } if( !pathDir.mkpath( tree ) ) throw SystemError( ToStdString( QString( "('%1')" ).arg( pathDir.filePath( tree ) ) ) ); if( !pathDir.cd( tree ) ) throw SystemError( ToStdString( QString( "('%1')" ).arg( pathDir.filePath( tree ) ) ) ); if( dir!=NULL ) { *dir = pathDir; } return true; } /*****************************************************************************/ QString I18nCoreApplication ::DatasetPathName( QString& name, const QString& imageFilename ) { // convenient QFileInfo QFileInfo fileInfo( imageFilename ); // get the md5 of the filename QByteArray result = QCryptographicHash::hash( fileInfo.absoluteFilePath().toAscii(), QCryptographicHash::Md5 ); // MD5 hash-code. QString hash( result.toHex() ); // store the md5 + the dataset extension at the end name = hash + I18nCoreApplication::DATASET_EXT; // Return hash-code for further use. return hash; } /*****************************************************************************/ VectorImageModel * I18nCoreApplication ::LoadImageModel( const QString & filename, int width, int height, QObject * p ) { try { VectorImageModel::EnsureValidImage( filename ); } catch( ... ) { throw; } VectorImageModel * imageModel = NULL; try { AbstractImageModel::BuildContext context( filename ); imageModel = new VectorImageModel( p ); imageModel->SetFilename( filename, width, height ); imageModel->BuildModel( &context ); } catch( ... ) { delete imageModel; imageModel = NULL; throw; } return imageModel; } /*****************************************************************************/ void I18nCoreApplication ::DeleteDatasetModel( const QString & path, const QString & hash ) { QFileInfo finfo( path, hash ); QDir dir( finfo.filePath() ); QFileInfoList fileInfos( dir.entryInfoList( QDir::NoDotAndDotDot | QDir::Files ) ); for( QFileInfoList::const_iterator it( fileInfos.begin() ); it!=fileInfos.end(); ++it ) { if( !dir.remove( it->fileName() ) ) throw SystemError( ToStdString( tr( "Failed to remove file '%1'." ).arg( it->filePath() ) ) ); } QDir parentDir( dir ); if( !parentDir.cdUp() ) throw SystemError( ToStdString( tr( "Failed to access parent directory of '%1'." ).arg( dir.path() ) ) ); if( !parentDir.rmdir( hash ) ) throw SystemError( ToStdString( tr( "Failed to remove dataset directory '%1'." ).arg( dir.path() ) ) ); } /*****************************************************************************/ void I18nCoreApplication ::HandleQtMessage( QtMsgType type, const char* message ) { switch( type ) { // // DEBUG case QtDebugMsg: #if ECHO_QDEBUG || FORCE_QDEBUG #if _WIN32 OutputDebugString( message ); OutputDebugString( "\n" ); #endif fprintf( stderr, "%s\n", message ); #endif #if LOG_QDEBUG assert( false && "Not yet implemented!" ); #endif break; // // WARNING case QtWarningMsg: #if ECHO_QWARNING || FORCE_QWARNING #if _WIN32 OutputDebugString( "WARNG> " ); OutputDebugString( message ); OutputDebugString( "\n" ); #endif fprintf( stderr, tr( "WARNG> %s\n" ).toLatin1().constData(), message ); #endif #if LOG_QWARNING assert( false && "Not yet implemented!" ); #endif break; // // CRITICAL case QtCriticalMsg: #if ECHO_QCRITICAL || FORCE_QCRITICAL #if _WIN32 OutputDebugString( "ERROR> " ); OutputDebugString( message ); OutputDebugString( "\n" ); #endif fprintf( stderr, tr( "ERROR> %s\n" ).toLatin1().constData(), message ); #endif #if LOG_QCRITICAL assert( false && "Not yet implemented!" ); #endif #if THROW_QCRITICAL throw std::runtime_error( ToStdString( tr( "Error: " ) .arg( message ) ) ); #endif break; // // FATAL case QtFatalMsg: #if ECHO_QFATAL || FORCE_QFATAL #if _WIN32 OutputDebugString( "FATAL> " ); OutputDebugString( message ); OutputDebugString( "\n" ); #endif fprintf( stderr, tr( "FATAL> %s\n" ).toLatin1().constData(), message ); #endif #if LOG_QFATAL assert( false && "Not yet implemented!" ); #endif #if THROW_QFATAL throw std::runtime_error( ToStdString( tr( "Fatal error: " ) .arg( message ) ) ); #endif abort(); break; default: assert( false && "Unhandled message QtMsgType!" ); break; } } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ I18nCoreApplication ::I18nCoreApplication( QCoreApplication* qtApp ) : QObject( qtApp ), m_Settings( NULL ), m_Model( NULL ), m_IsRunningFromBuildDir( false ) { if( m_Instance!=NULL ) { throw std::runtime_error( ToStdString( tr( "I18nCoreApplication is a singleton class!" ) ) ); } if( qtApp==NULL ) { throw std::invalid_argument( ToStdString( tr( "Class 'I18nCoreApplication' instance must be provided a " "QCoreApplication' pointer at construction time!" ) ) ); } qInstallMsgHandler( I18nCoreApplication::HandleQtMessage ); m_Instance = this; } /*******************************************************************************/ I18nCoreApplication ::~I18nCoreApplication() { } /*******************************************************************************/ void I18nCoreApplication ::Initialize() { // Initialize internationlization. InitializeLocale(); // // Force numeric options of locale to "C" // See issue #635 // // TODO: Check it is still needed here! setlocale( LC_NUMERIC, "C" ); // Initialize QCoreApplication. virtual_InitializeCore(); // Initialize settings. InitializeSettings(); // Elevation setup ElevationSetup(); } /*******************************************************************************/ void I18nCoreApplication ::SetModel( AbstractModel* model ) { emit AboutToChangeModel( model ); delete m_Model; m_Model = model; if( model!=NULL ) m_Model->setParent( this ); emit ModelChanged( m_Model ); } /*******************************************************************************/ bool I18nCoreApplication ::ElevationSetup() { assert( !otb::DEMHandler::Instance().IsNull() ); otb::DEMHandler::Pointer demHandlerInstance( otb::DEMHandler::Instance() ); bool geoidUpdated = false; if( I18nCoreApplication::HasSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE ) && I18nCoreApplication::RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE ).toBool() ) { qDebug() << "Settings/GeoidFile:" << I18nCoreApplication::RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH ).toString(); try { QString filename( I18nCoreApplication::RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH ).toString() ); geoidUpdated = demHandlerInstance->OpenGeoidFile( QFile::encodeName( filename ) ); // BUGFIX: When geoid file has not been updated by // otb::DEMHandler, the filename may be erroneous and unchecked // so, add a check, in this case, to report input error to the // user. if( !geoidUpdated ) { QFileInfo finfo( filename ); if( !finfo.exists() ) throw std::runtime_error( ToStdString( tr( "Geoid file '%1' not found!" ) .arg( filename ) ) ); } } catch( const std::exception & err ) { qWarning() << ToStdString( tr( "An error occurred while loading the geoid file, " "no geoid file will be used:" ) ).c_str() << err.what(); throw; } } else geoidUpdated = true; if( I18nCoreApplication::HasSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE ) && I18nCoreApplication::RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE ).toBool() ) { qDebug() << "Settings/DEMDir:" << I18nCoreApplication::RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR ).toString(); try { demHandlerInstance->ClearDEMs(); demHandlerInstance->OpenDEMDirectory( QFile::encodeName( I18nCoreApplication::RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR ) .toString() ) ); } catch( const std::exception & err ) { qWarning() << ToStdString( tr( "An error occurred while loading the DEM directory, " "no DEM will be used:" ) ).c_str() << err.what(); throw; } } else { otb::DEMHandler::Instance()->ClearDEMs(); } return geoidUpdated; } /*******************************************************************************/ void I18nCoreApplication ::InitializeLocale() { { typedef QList< QByteArray > ByteArrayList; ByteArrayList codecs( QTextCodec::availableCodecs() ); qDebug() << "Available codecs:"; foreach( const QByteArray & codec, codecs ) qDebug() << "\t" << codec; } // Literal strings to be translated are UTF-8 encoded because source // files are UTF-8 encoded. QTextCodec::setCodecForTr( QTextCodec::codecForName( "UTF-8" ) ); // QTextCodec::setCodecForLocale( QTextCodec::codecForName("UTF-8") ); // QTextCodec::setCodecForCStrings( QTextCodec::codecForName("System") ); qWarning() << "Codec for C-strings:" << ( QTextCodec::codecForCStrings()!=NULL ? QTextCodec::codecForCStrings()->name() : "none" ); qWarning() << "Codec for Locale:" << ( QTextCodec::codecForLocale()!=NULL ? QTextCodec::codecForLocale()->name() : "none" ); qWarning() << "Codec for Tr:" << ( QTextCodec::codecForTr()!=NULL ? QTextCodec::codecForTr()->name() : "none" ); // // 1. default UI language is english (no translation). QLocale sys_lc( QLocale::system() ); // Trace system locale. qWarning() << "Language:" << QLocale::languageToString( sys_lc.language() ); qWarning() << "Country:" << QLocale::countryToString( sys_lc.country() ); // Check system locale. if( sys_lc.language() == QLocale::C || ( sys_lc.language() == QLocale::English && sys_lc.country() == QLocale::UnitedStates ) ) { return; } // // 2. Choose i18n path between build dir and install dir. // Begin from the executable path QDir bin_dir( QDir::cleanPath(QCoreApplication::applicationDirPath()) ); // Go up in the directory hierarchy until we have a candidate install prefix bool prefixFound = false; QDir prefix( bin_dir ); while ( prefix.cdUp() ) { if ( QDir(prefix).cd( Monteverdi_INSTALL_BIN_DIR) ) { prefixFound = true; break; } } if( !prefixFound ) throw std::runtime_error( ToStdString( tr( "Failed to locate translation files directory 'i18n' in '%1'." ) .arg( prefix.path() ) ) ); QDir i18n_dir( prefix ); // At this point the candidate install prefix can also be the build dir root if ( prefix.exists( Monteverdi_BUILD_DIR_FILE ) && i18n_dir.cd( "i18n" ) ) { m_IsRunningFromBuildDir = true; // Report found build dir root qDebug() << tr( "Running from build directory '%1'." ) .arg( prefix.path() ); qDebug() << tr( "Loading translation files from directory '%1'." ) .arg( i18n_dir.path() ); } else { m_IsRunningFromBuildDir = false; // Report found install prefix qDebug() << tr( "Running from install directory '%1'." ) .arg( prefix.path() ); if ( i18n_dir.cd( Monteverdi_INSTALL_DATA_I18N_DIR ) ) { qDebug() << tr( "Loading translation files from directory '%1'." ) .arg( i18n_dir.path() ); } else { throw std::runtime_error( ToStdString( tr( "Failed to access translation-files directory '%1'" ) .arg( QDir::cleanPath( prefix.path() + QDir::separator() + Monteverdi_INSTALL_DATA_I18N_DIR ) ) ) ); } } try { // // 3.1 Stack Qt translator. LoadAndInstallTranslator( "qt_" + sys_lc.name(), QLibraryInfo::location( QLibraryInfo::TranslationsPath ) ); } catch( std::exception& exc ) { qWarning() << exc.what(); } try { // // 3.2 Stack Monteverdi translator as prioritary over Qt translator. LoadAndInstallTranslator( sys_lc.name(), i18n_dir.path() ); } catch( std::exception& exc ) { qWarning() << exc.what(); } // TODO: Record locale translation filename(s) used in UI component (e.g. // AboutDialog, Settings dialog, Information dialog etc.) } /*******************************************************************************/ void I18nCoreApplication ::InitializeCore( const QString& appName, const QString& appVersion, const QString& orgName, const QString& orgDomain ) { setObjectName( "Application" ); // // Setup application tags. // QCoreApplication::setApplicationName( appName ); QCoreApplication::setApplicationVersion( appVersion ); // // Setup organization tags. // QCoreApplication::setOrganizationName( orgName ); QCoreApplication::setOrganizationDomain( orgDomain ); #if 0 #ifndef Q_WS_MAC setWindowIcon( QIcon( QLatin1String( ":/images/application_icon" ) ) ); #endif #endif } /*******************************************************************************/ void I18nCoreApplication ::InitializeSettings() { // // Create settings proxy. m_Settings = new QSettings( QSettings::IniFormat, QSettings::UserScope, QCoreApplication::organizationName(), QCoreApplication::applicationName(), this ); // // Restore result directory. QVariant resultDir( RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_RESULTS_DIR ) ); if( !resultDir.isNull() ) { QString resultPath( resultDir.toString() ); qDebug() << "Settings/resultsDir:" << resultPath; if( I18nCoreApplication::IsResultsDirValid( resultPath ) ) { m_ResultsDir.setPath( resultPath ); } } } /*******************************************************************************/ void I18nCoreApplication ::LoadAndInstallTranslator( const QString& filename, const QString& directory, const QString& searchDelimiters, const QString& suffix ) { QString filename_ext( filename + ( suffix.isNull() ? ".qm" : suffix ) ); // (a) Do need to new QTranslator() here! QTranslator* lc_translator = new QTranslator( this ); if( !lc_translator->load( filename, directory, searchDelimiters, suffix ) ) { delete lc_translator; lc_translator = NULL; throw std::runtime_error( ToStdString( tr( "Failed to load '%1' translation file from '%2'." ) .arg( filename_ext ) .arg( directory ) ) ); } // (a) ...because QTranslator needs to be alive during the whole // lifespan of the application. QCoreApplication::installTranslator( lc_translator ); QString message( tr( "Successfully loaded '%1' translation file from '%2'." ) .arg( filename_ext ) .arg( directory ) ); // TODO: Log locale translation filename used. qDebug() << message; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdImageImporter.cxx000066400000000000000000000074461301006202600274150ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImageImporter.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdI18nCoreApplication.h" #include "mvdVectorImageModel.h" namespace mvd { /* TRANSLATOR mvd::ImageImporter Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ImageImporter ::ImageImporter( const QString& filename, int width, int height, QObject* p ) : AbstractWorker( p ), m_Filename( filename ), m_ModelType( IMAGE ), m_Width( width ), m_Height( height ), m_IsForceCreateEnabled( false ) { } /*******************************************************************************/ ImageImporter ::~ImageImporter() { // qDebug() << this << "destroyed."; } /*******************************************************************************/ QObject* ImageImporter ::virtual_Do() { /* emit ProgressTextChanged( tr( "Importing image '%1' as dataset into cache directory..." ) .arg( QFileInfo( m_Filename ).fileName() ) ); */ // emit ProgressTextChanged( GetFirstProgressText() ); emit ProgressValueChanged( -1 ); emit ProgressRangeChanged( 0, 0 ); // Load model. switch( m_ModelType ) { case IMAGE: return I18nCoreApplication::LoadImageModel( m_Filename, m_Width, m_Height ); break; default: assert( false && "Unhandled ImageImporter::ModelType value." ); break; } return NULL; } /*******************************************************************************/ QString ImageImporter ::virtual_GetFirstProgressText() const { switch( m_ModelType ) { case IMAGE: return tr( "Loading image '%1'..." ) .arg( QFileInfo( m_Filename ).fileName() ); break; default: assert( false && "Unhandled ImageImporter::ModelType value." ); break; } return QString(); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdImagePlacenameLoader.cxx000066400000000000000000000030351301006202600306160ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImagePlacenameLoader.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdVectorImageModel.h" namespace mvd { /*****************************************************************************/ ImagePlacenameLoader ::ImagePlacenameLoader(VectorImageModel* model): m_Model(model) { } /*****************************************************************************/ void ImagePlacenameLoader ::LoadPlacename() { // This method is executed in a separate thread // get the placename if any std::string placename = m_Model->GetCenterPixelPlaceName(); if (!placename.empty()) { // emit a signal to emit PlacenameLoaded( FromStdString( placename) ); } emit Finished(); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdImageProperties.cxx000066400000000000000000000056661301006202600277520ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImageProperties.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::ImageProperties Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ImageProperties #if IMAGE_PROPERTIES_IS_QOBJECT ::ImageProperties( QObject* p ) : QObject( p ), #else ::ImageProperties() : #endif m_Flags(), m_NoData( ComponentType( 0 ) ) { m_Flags.m_NoData = false; } /*******************************************************************************/ ImageProperties ::~ImageProperties() { } /*******************************************************************************/ bool ImageProperties ::operator == ( const ImageProperties & other ) const { return other.m_Flags.m_NoData==m_Flags.m_NoData && other.m_NoData==m_NoData; } /*******************************************************************************/ bool ImageProperties ::operator != ( const ImageProperties & other ) const { return !operator == ( other ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdImageSettings.cxx000066400000000000000000000076261301006202600274140ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImageSettings.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::ImageSettings Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. char const * const ImageSettings ::EFFECT_VALUE_NAME[ EFFECT_COUNT ] = { NULL, NULL, QT_TRANSLATE_NOOP( "mvd::ImageSettings", "Range" ), NULL, NULL, QT_TRANSLATE_NOOP( "mvd::ImageSettings", "Angle" ), NULL, NULL, }; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ImageSettings ::ImageSettings() : m_IsModified( false ), m_IsApplied( false ), m_Effect( EFFECT_NORMAL ), m_Size( 256 ), m_Range( 50.0 ), m_Angle( 10.0 ), m_Alpha( 1.0 ) { } /*****************************************************************************/ ImageSettings ::~ImageSettings() { } /*****************************************************************************/ const char * ImageSettings ::GetEffectName() const { assert( m_Effect>=0 && m_Effecttranslate( "mvd", EFFECT_NAMES[ m_Effect ] ) .toLatin1().constData(); } /*****************************************************************************/ double ImageSettings ::GetValue() const { switch( m_Effect ) { case EFFECT_LOCAL_CONTRAST: // qDebug() << "Range:" << m_Range; return m_Range; break; case EFFECT_SPECTRAL_ANGLE : // qDebug() << "Angle:" << m_Angle; return m_Angle; break; default: break; } return std::numeric_limits< double >::signaling_NaN(); } /*****************************************************************************/ void ImageSettings ::SetValue( double value ) { switch( m_Effect ) { case EFFECT_LOCAL_CONTRAST: // qDebug() << "Range = " << value; m_Range = value; break; case EFFECT_SPECTRAL_ANGLE : // qDebug() << "Angle = " << value; m_Angle = value; break; default: break; } SetModified(); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdImageSettingsInterface.cxx000066400000000000000000000063011301006202600312220ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImageSettingsInterface.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdImageSettings.h" namespace mvd { /* TRANSLATOR mvd::ImageSettingsInterface Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ImageSettingsInterface ::ImageSettingsInterface() : m_Settings( NULL ) { } /*****************************************************************************/ ImageSettingsInterface ::~ImageSettingsInterface() { #if 0 delete m_Settings; m_Settings = NULL; #endif } /*****************************************************************************/ void ImageSettingsInterface ::SetSettings( ImageSettings * settings ) { #if 0 delete m_Settings; #endif m_Settings = settings; virtual_SetSettings( settings ); } /*****************************************************************************/ void ImageSettingsInterface ::UpdateSettings() { virtual_UpdateSettings(); } /*****************************************************************************/ void ImageSettingsInterface ::virtual_SetSettings( ImageSettings * ) { } /*****************************************************************************/ void ImageSettingsInterface ::virtual_UpdateSettings() { virtual_SetSettings( m_Settings ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdModifiableInterface.cxx000066400000000000000000000035221301006202600305140ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdModifiableInterface.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::ModifiableInterface Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ModifiableInterface ::ModifiableInterface() { } /*******************************************************************************/ ModifiableInterface ::~ModifiableInterface() { } /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdMyClass.cxx000066400000000000000000000044741301006202600262220ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdMyClass.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::MyClass Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ MyClass ::MyClass( QObject* p ) : QObject( p ) { } /*******************************************************************************/ MyClass ::~MyClass() { } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdOverviewBuilder.cxx000066400000000000000000000115321301006202600277550ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdOverviewBuilder.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) #include // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdI18nCoreApplication.h" #include "mvdProcessObjectObserver.h" #include "mvdVectorImageModel.h" namespace mvd { /* TRANSLATOR mvd::OverviewBuilder Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ OverviewBuilder ::OverviewBuilder( const GDALOverviewsBuilderVector & builders, QObject * p ) : AbstractWorker( p ), ProgressInterface(), m_GDALOverviewsBuilders( builders ), m_Index( 0 ), m_Count( 0 ) { } /*******************************************************************************/ OverviewBuilder ::~OverviewBuilder() { // qDebug() << this << "destroyed."; } /*******************************************************************************/ void OverviewBuilder ::SetProgress( double value ) { assert( m_Count>0 ); assert( m_Index>=0 && m_Index=0.0 && value<=1.0 ); // qDebug() // << m_Index << "/" << m_Count // << value << "\t" // << ( 100 * m_Index + static_cast< int >( 100.0 * value ) ); emit ProgressValueChanged( 100 * m_Index + static_cast< int >( 100.0 * value ) ); } /*******************************************************************************/ QObject * OverviewBuilder ::virtual_Do() { /* emit ProgressTextChanged( tr( "Importing image '%1' as dataset into cache directory..." ) .arg( QFileInfo( m_Filename ).fileName() ) ); */ // emit ProgressTextChanged( GetFirstProgressText() ); // // Count elements to process. m_Count = 0; for( GDALOverviewsBuilderVector::const_iterator it( m_GDALOverviewsBuilders.begin() ); it!=m_GDALOverviewsBuilders.end(); ++ it ) if( !it->IsNull() && ( *it )->GetNbResolutions()>0 ) ++ m_Count; emit ProgressRangeChanged( 0, 100 * m_Count ); // // Process elements. m_Index = 0; { ProcessObjectObserver::Pointer observer( ProcessObjectObserver::New() ); observer->SetProgressInterface( this ); for( GDALOverviewsBuilderVector::const_iterator it( m_GDALOverviewsBuilders.begin() ); it!=m_GDALOverviewsBuilders.end(); ++ it, ++ m_Index ) if( !it->IsNull() && ( *it )->GetNbResolutions()>0 ) { unsigned long id = ( *it )->AddObserver( itk::ProgressEvent(), observer ); ( *it )->Update(); ( *it )->RemoveObserver( id ); emit ProgressTextChanged( QString( tr( "Generting overviews for file %1/%2 '%3'." ) ) .arg( m_Index + 1 ) .arg( m_Count ) .arg( QFile::decodeName( ( *it )->GetInputFileName().c_str() ) ) ); } } emit ProgressValueChanged( 100 * m_Count ); return NULL; } /*******************************************************************************/ QString OverviewBuilder ::virtual_GetFirstProgressText() const { return QString( tr( "Preparing to build GDAL overviews..." ) ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdProcessObjectObserver.cxx000066400000000000000000000100771301006202600311200ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdProcessObjectObserver.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) #include #include // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdProgressInterface.h" namespace mvd { /* TRANSLATOR mvd::ProcessObjectObserver Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ProcessObjectObserver ::ProcessObjectObserver() : itk::Command(), m_ProgressInterface( NULL ) { } /*******************************************************************************/ ProcessObjectObserver ::~ProcessObjectObserver() { } /*******************************************************************************/ void ProcessObjectObserver ::SetProgressInterface( ProgressInterface * interface ) { m_ProgressInterface = interface; } /*******************************************************************************/ void ProcessObjectObserver ::Execute( itk::Object * caller, const itk::EventObject & event ) { Execute( const_cast< const itk::Object * >( caller ), event ); } /*******************************************************************************/ void ProcessObjectObserver ::Execute( const itk::Object * caller, const itk::EventObject & event ) { assert( caller!=NULL ); if( typeid( event )==typeid( itk::ProgressEvent ) ) { assert( m_ProgressInterface!=NULL ); // itk::LightProcessObject and itk::ProcessObject don't have any // common ::GetProgress() interface (because there is no common // super-class providing this interface). So, itk::Object must be // dynamically casted to both types in order to get progress. assert( dynamic_cast< const itk::LightProcessObject * >( caller )!=NULL || dynamic_cast< const itk::ProcessObject * >( caller )!=NULL ); const itk::LightProcessObject * lpo = dynamic_cast< const itk::LightProcessObject * >( caller ); if( lpo!=NULL ) m_ProgressInterface->SetProgress( lpo->GetProgress() ); else { const itk::ProcessObject * po = dynamic_cast< const itk::ProcessObject * >( caller ); m_ProgressInterface->SetProgress( po->GetProgress() ); } } } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdProgressInterface.cxx000066400000000000000000000045331301006202600302700ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdProgressInterface.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::ProgressInterface Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ProgressInterface ::ProgressInterface() { } /*******************************************************************************/ ProgressInterface ::~ProgressInterface() { } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdQuicklookModel.cxx000066400000000000000000000103671301006202600275670ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdQuicklookModel.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbStreamingShrinkImageFilter.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" namespace mvd { /* TRANSLATOR mvd::QuicklookModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ QuicklookModel ::QuicklookModel( QObject* p ) : VectorImageModel( p ) { } /*******************************************************************************/ QuicklookModel ::~QuicklookModel() { } /*******************************************************************************/ void QuicklookModel ::virtual_BuildModel( void* context ) { // // Get build-context. assert( context ); BuildContext* buildContext = static_cast< BuildContext* >( context ); // // Access rendering settings. // TODO: Remove temporary hack (Quicklook rendering settings). if( buildContext->m_Settings!=NULL ) { VectorImageSettings * const settings = static_cast< VectorImageSettings * const >( buildContext->m_Settings ); SetSettings( *settings ); } // // Quicklook file. // Quicklook file information. bool inMemory = buildContext->m_Quicklook.isEmpty(); QFileInfo quicklookFileInfo( inMemory ? buildContext->m_Filename : buildContext->m_Quicklook ); // Quicklook filename. QString quicklookFilename( quicklookFileInfo.filePath() ); // First time? if( buildContext->IsBeingStored() && !inMemory ) { // Instantiate a quicklook file writer. VectorImageFileWriterType::Pointer fileWriter( VectorImageFileWriterType::New() ); // Access parent image-model. VectorImageModel* viModel = GetImageModel< VectorImageModel >(); assert( viModel!=NULL ); CountType currentLod = viModel->GetCurrentLod(); CountType bestLod = viModel->ComputeBestLod( 512, 512 ); if( bestLod!=currentLod ) viModel->SetCurrentLod( bestLod ); // Write quicklook file on the disk. fileWriter->SetFileName( QFile::encodeName( quicklookFilename ).constData() ); fileWriter->SetInput( viModel->ToImage() ); fileWriter->Update(); if( currentLod!=bestLod ) viModel->SetCurrentLod( currentLod ); } // Source stored quicklook image-file. // Best fit to 512x512 px² size. SetFilename( quicklookFilename, VectorImageModel::DEFAULT_LOD_SIZE, VectorImageModel::DEFAULT_LOD_SIZE ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdSerializableInterface.cxx000066400000000000000000000074551301006202600311000ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdSerializableInterface.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdSystemError.h" namespace mvd { /* TRANSLATOR mvd::SerializableInterface Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ SerializableInterface ::SerializableInterface() { } /*******************************************************************************/ SerializableInterface ::~SerializableInterface() { } /*******************************************************************************/ void SerializableInterface ::Read( const QString& filename, Mode mode ) { // File instance. QFile file( filename ); // Setup open-mode. QIODevice::OpenMode openMode( QIODevice::ReadOnly ); if( mode==MODE_TEXT ) openMode |= QIODevice::Text; // Open file on device. if( !file.open( openMode ) ) throw SystemError( ToStdString( QString( "('%1')" ).arg( filename ) ) ); try { // Read file context. virtual_Read( &file ); } catch( SystemError& syserr ) { // Catch any SystemError thrown by DatasetDescriptor::Write() and // morph it into the same SystemError containing filename // information. syserr = SystemError( ToStdString( QString( "('%1')" ).arg( filename ) ) ); // Throw morphed SystemError. throw syserr; } // File is closed by automatic scope detruction of QFile instance. } /*******************************************************************************/ void SerializableInterface ::Write( const QString& filename, Mode mode ) const { // File instance. QFile file( filename ); // Setup open-mode. QIODevice::OpenMode openMode( QIODevice::WriteOnly ); if( mode==MODE_TEXT ) openMode |= QIODevice::Text; // Open file on device. if( !file.open( openMode ) ) throw SystemError( ToStdString( QString( "('%1')" ).arg( filename ) ) ); try { // Write file context. virtual_Write( file ); } catch( SystemError& syserr ) { // Catch any SystemError thrown by DatasetDescriptor::Write() and // morph it into the same SystemError containing filename // information. syserr = SystemError( ToStdString( QString( "('%1')" ).arg( filename ) ) ); // Throw morphed SystemError. throw syserr; } // File is closed by automatic scope detruction of QFile instance. } /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdStackedLayerModel.cxx000066400000000000000000000364301301006202600302000ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdStackedLayerModel.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractLayerModel.h" #include "mvdAlgorithm.h" namespace mvd { /* TRANSLATOR mvd::StackedLayerModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ StackedLayerModel::SizeType StackedLayerModel::m_LayerCount = 0; const StackedLayerModel::KeyType StackedLayerModel::NIL_KEY; const StackedLayerModel::SizeType StackedLayerModel::NIL_INDEX = -1; /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ StackedLayerModel ::StackedLayerModel( QObject* p ) : AbstractModel( p ), m_LayerModels(), m_Keys(), m_Current( StackedLayerModel::NIL_INDEX ), m_Reference( StackedLayerModel::NIL_INDEX ) { } /*******************************************************************************/ StackedLayerModel ::~StackedLayerModel() { } /*****************************************************************************/ StackedLayerModel::KeyType StackedLayerModel ::Add( AbstractLayerModel * model ) { return Insert( model, StackedLayerModel::NIL_INDEX ); } /*****************************************************************************/ void StackedLayerModel ::Clear() { bool emitSignal0 = !IsEmpty(); bool emitSignal1 = !IsEmpty() && m_Currentsecond!=NULL ); if( it->second->parent()==this ) { delete it->second; it->second = NULL; } } m_LayerModels.clear(); m_Keys.clear(); if( emitSignal0 ) emit ContentReset(); } /*****************************************************************************/ bool StackedLayerModel ::Contains( const AbstractLayerModel * layerModel ) const { for( LayerModelMap::const_iterator it( m_LayerModels.begin() ); it!=m_LayerModels.end(); ++it ) if( it->second==layerModel ) return true; return false; } /*****************************************************************************/ void StackedLayerModel ::CountSRT( SizeType & unk, SizeType & crt, SizeType & geo, SizeType & ssr ) const { for( LayerModelMap::const_iterator it( m_LayerModels.begin() ); it!=m_LayerModels.end(); ++it ) { assert( it->second!=NULL ); switch( it->second->GetSpatialReferenceType() ) { case SRT_UNKNOWN: ++ unk; break; case SRT_CARTO: ++ crt; break; case SRT_GEO: ++ geo; break; case SRT_SENSOR: ++ ssr; break; } } } /*****************************************************************************/ void StackedLayerModel ::Delete( SizeType index ) { // qDebug() << this << "::Delete(" << index << ")"; // // Check content. if( IsEmpty() ) return; if( index>=GetCount() ) return; assert( !m_Keys[ index ].empty() ); // // Find item. LayerModelMap::iterator it( m_LayerModels.find( m_Keys[ index ] ) ); assert( it!=m_LayerModels.end() ); // // Check if signals have to be emitted. bool emitCurrentChanged = m_Currentm_Current ? m_Current : ( m_Current>0 ? m_Current - 1 : StackedLayerModel::NIL_INDEX ); // // Emit signals. emit ContentAboutToBeChanged(); emit LayerAboutToBeDeleted( index ); // // Clear satellite date. ClearPixelInfos(); // // Remove layer-model. AbstractLayerModel * layer = it->second; m_LayerModels.erase( it ); m_Keys.erase( m_Keys.begin() + index ); it = m_LayerModels.end(); // // Update pointer to current. if( emitCurrentChanged ) SetCurrent( current, true ); // // Update reference pointer. if( emitReferenceChanged ) SetReference( index>m_Reference ? m_Reference : ( m_Reference > 0 ? m_Reference - 1 : StackedLayerModel::NIL_INDEX ), true ); // // Eventually delete layer. if( layer->parent()==this ) { delete layer; layer = NULL; } // // Emit signals. emit LayerDeleted( index ); emit ContentChanged(); } /*****************************************************************************/ void StackedLayerModel ::EndEditResolutions() { // qDebug() << this << "::EndEditResolutions()"; emit ResolutionsChanged( m_PixelInfos ); } /*******************************************************************************/ std::string StackedLayerModel ::GenerateKey( AbstractLayerModel * otbUseInDebug( layerModel ) ) { std::ostringstream oss; oss << "Layer #" << m_LayerCount++; #ifdef OTB_DEBUG oss << " (" << layerModel->metaObject()->className() << "@" << std::hex << layerModel << ")"; #endif return oss.str(); } /*****************************************************************************/ StackedLayerModel::KeyType StackedLayerModel ::Insert( AbstractLayerModel * model, SizeType index ) { // qDebug() << this << "::Insert(" << model << "," << index << ")"; // // Check given model. assert( model!=NULL ); if( model==NULL ) { throw std::runtime_error( ToStdString( tr( "Cannot insert NULL AbstractLayerModel." ) ) ); } // // Generate key for new layer. std::string key( StackedLayerModel::GenerateKey( model ) ); assert( !key.empty() ); if( key.empty() ) { throw std::runtime_error( ToStdString( tr( "Failed to generate string key for '%1'." ) .arg( model->metaObject()->className() ) ) ); } // // Clamp index. If out of bounds, insert model at the end of stack. if( index>GetCount() ) index = GetCount(); // // Check if signals have to be emitted. bool emitCurrentChanged = m_Current1 ); assert( index1 ); assert( indexm_Current && position<=m_Current ) ++ current; else if( index=m_Current ) -- current; // // Signal new current element. SetCurrent( current ); // // Compute new reference element. SizeType reference( m_Reference ); if( index==m_Reference ) reference = position; if( index>m_Reference && position<=m_Reference ) ++ reference; else if( index=m_Reference ) -- reference; SetReference( reference ); } /*****************************************************************************/ void StackedLayerModel ::MoveToBottom( SizeType index ) { MoveTo( index, m_Keys.size() - 1 ); } /*****************************************************************************/ void StackedLayerModel ::MoveToTop( SizeType index ) { MoveTo( index, 0 ); } /*****************************************************************************/ void StackedLayerModel ::RaiseLayer( SizeType index ) { assert( GetCount()>1 ); assert( index=GetCount() ) return; KeyType currentKey( GetKey( m_Current ) ); KeyType referenceKey( GetKey( m_Reference ) ); emit OrderAboutToBeChanged(); { ClearPixelInfos(); std::rotate( m_Keys.begin(), m_Keys.begin() + index, m_Keys.end() ); } emit OrderChanged(); if( !currentKey.empty() ) { SizeType current = FindKey( currentKey ); assert( current!=StackedLayerModel::NIL_INDEX ); emit CurrentAboutToBeChanged( current ); { m_Current = current; } emit CurrentChanged( m_Current ); } if( !referenceKey.empty() ) { SizeType reference = FindKey( referenceKey ); assert( reference!=StackedLayerModel::NIL_INDEX ); emit ReferenceAboutToBeChanged( reference ); { m_Reference = reference; } emit ReferenceChanged( m_Reference ); } // qDebug() << "current:" << index; } /*****************************************************************************/ void StackedLayerModel ::RotateLayerDown( SizeType index ) { if( GetCount()<2 ) return; if( index>=GetCount() ) return; KeyType currentKey( GetKey( m_Current ) ); KeyType referenceKey( GetKey( m_Reference ) ); emit OrderAboutToBeChanged(); { ClearPixelInfos(); std::rotate( m_Keys.rbegin(), m_Keys.rbegin() + index, m_Keys.rend() ); } emit OrderChanged(); if( !currentKey.empty() ) { SizeType current = FindKey( currentKey ); assert( current!=StackedLayerModel::NIL_INDEX ); emit CurrentAboutToBeChanged( current ); { m_Current = current; } emit CurrentChanged( current ); } if( !referenceKey.empty() ) { SizeType reference = FindKey( referenceKey ); assert( reference!=StackedLayerModel::NIL_INDEX ); emit ReferenceAboutToBeChanged( reference ); { m_Reference = reference; } emit ReferenceChanged( reference ); } // qDebug() << "current:" << index; } /*****************************************************************************/ void StackedLayerModel ::SetCurrent( const AbstractLayerModel * layerModel ) { SetCurrent( KeyOf( layerModel ) ); } /*****************************************************************************/ void StackedLayerModel ::SetCurrent( const KeyType & key ) { if( key==GetCurrentKey() ) return; if( key==StackedLayerModel::NIL_KEY ) { SetCurrent( StackedLayerModel::NIL_INDEX ); return; } for( SizeType i=0; iSetFileName( QFile::encodeName( GetFilename() ) ); m_ImageFileReader->GetOutput()->UpdateOutputInformation(); // Retrieve the list of Lod from file m_LodCount = m_ImageFileReader->GetOverviewsCount(); // Remember native largest region. m_NativeLargestRegion = m_ImageFileReader->GetOutput()->GetLargestPossibleRegion(); // Remember native spacing m_NativeSpacing = m_ImageFileReader->GetOutput()->GetSpacing(); // qDebug() // << filename // << "\norigin:" // << m_ImageFileReader->GetOutput()->GetOrigin()[ 0 ] // << m_ImageFileReader->GetOutput()->GetOrigin()[ 1 ] // << "\nspacing:" << m_NativeSpacing[ 0 ] << m_NativeSpacing[ 1 ]; // Setup GenericRSTransform m_ToWgs84 = otb::GenericRSTransform<>::New(); m_ToWgs84->SetInputDictionary(m_ImageFileReader->GetOutput()->GetMetaDataDictionary()); m_ToWgs84->SetOutputProjectionRef(otb::GeoInformationConversion::ToWKT(4326)); m_ToWgs84->InstantiateTransform(); //Compute estimated spacing here //m_EstimatedGroundSpacing m_EstimatedGroundSpacing = m_NativeSpacing; typedef otb::GroundSpacingImageFunction GroundSpacingImageType; GroundSpacingImageType::Pointer GroundSpacing = GroundSpacingImageType::New(); GroundSpacing->SetInputImage(m_ImageFileReader->GetOutput()); if (m_ToWgs84->IsUpToDate()) { if (m_ToWgs84->GetTransformAccuracy() != otb::Projection::UNKNOWN) { IndexType index; vnl_random rand; index[0] = static_cast(rand.lrand32(0, m_ImageFileReader->GetOutput()->GetLargestPossibleRegion().GetSize()[0])); index[1] = static_cast(rand.lrand32(0, m_ImageFileReader->GetOutput()->GetLargestPossibleRegion().GetSize()[1])); m_EstimatedGroundSpacing = GroundSpacing->EvaluateAtIndex(index); } } // // 2. Setup file-reader. SetupCurrentLodImage(w, h); } /*****************************************************************************/ void VectorImageModel ::EnsureValidImage( const QString& filename ) { try { DefaultImageFileReaderType::Pointer imageFileReader( DefaultImageFileReaderType::New() ); QString fname = filename; if (!filename.contains(QChar('?'))) { fname.append(QChar('?')); } imageFileReader->SetFileName( QFile::encodeName( fname.append(QString("&skipgeom=true"))).constData()); imageFileReader->GetOutput()->UpdateOutputInformation(); } catch( std::exception& exc ) { // TODO manage the message returned by OTB qWarning() << ToStdString( tr( "Exception caught when validating file '%1': ") .arg( filename ) ).c_str() << exc.what(); throw // std::runtime_error( SystemError( ToStdString( tr( "File '%1' cannot be read by OTB." ) .arg( filename ) ) ); } } /*****************************************************************************/ void VectorImageModel ::BuildGdalOverviews() { // Build overviews if necessary // bool hasOverviewsSupport = (m_ImageFileReader->GetOverviewsCount()>0); int nbOfAvailableOvw = m_ImageFileReader->GetOverviewsCount(); // TODO: this choice should be done by the user during the import of the file bool forceToCacheOvw = true; qWarning() << tr( "The ImageIO used to read this file supports overviews." ); if( nbOfAvailableOvw>0 ) { // qDebug() << tr("The file already has overviews!"); return; } // TODO MSD: how to manage case of JPEG2000 with no overviews ? : wait GDAL support OpenJPEG ... // The current file don't have overviews available qWarning() << tr( "The file doesn't have overviews." ); if( !forceToCacheOvw ) { // the user doesn't want to cache the overviews, GDAL will virtually compute the ovw on demand qWarning() << tr("Letting GDAL decimate the file on-the-fly !"); return; } // the user want to cache the overviews // qDebug() << tr("Caching of overviews."); typedef otb::GDALOverviewsBuilder FilterType; FilterType::Pointer filter = FilterType::New(); assert( m_LodCount!=static_cast< unsigned int >( -1 ) ); // m_ImageFileReader->GetAvailableResolutions(m_AvailableLod); std::string tempfilename( QFile::encodeName( GetFilename() ) ); filter->SetInputFileName(tempfilename); filter->SetResamplingMethod( otb::GDAL_RESAMPLING_AVERAGE ); filter->SetResolutionFactor(4); assert( m_ImageFileReader->GetOverviewsCount()==m_LodCount ); filter->SetNbResolutions( GetNbLod() > 1 ? GetNbLod() / 2 : 1 ); try { otb::StandardOneLineFilterWatcher watcher( filter, ToStdString( tr( "Overviews creation: " ) ) ); filter->Update(); std::cout << std::endl; } catch( std::exception& /*exc*/ ) { // The user can continue to use the file so we return a warning message // TODO MSD return the message to the log widget qWarning() << ToStdString( tr( "The overviews creation failed.\n" "Navigation in resolution will be slower." ) ).c_str(); // throw exc; } } /*****************************************************************************/ void VectorImageModel ::virtual_BuildModel( void* context ) { SetProperties( new ImageProperties() ); // Get build-context. assert( context!=NULL ); BuildContext* buildContext = static_cast< BuildContext* >( context ); // Build image overview. if( buildContext->IsBeingStored() ) BuildGdalOverviews(); // Get build-context settings. VectorImageSettings * const settings = static_cast< VectorImageSettings * const >( buildContext->m_Settings ); // Fetch the no data flags if any otb::ImageMetadataInterfaceBase::ConstPointer metaData( GetMetaDataInterface() ); std::vector values; std::vector flags; bool ret = metaData->GetNoDataFlags(flags,values); if(ret && !values.empty() && !flags.empty() && flags[0]) { GetProperties()->SetNoDataEnabled(true); GetProperties()->SetNoData(values[0]); } // // Step #1: Perform pre-process of AbstractModel::BuildModel() // pattern. // Store default display settings in the pre-process stage // i.e. before histogram is generated by the standard // AbstractImageModel::BuildModel(). if( settings==NULL ) InitializeColorSetupSettings(); // // Step #2: Perform standard AbstractModel::BuildModel() // pattern. Call parent virtual method. // The call to the parent BuildModel() method will, for example, // generate the histogram. AbstractImageModel::virtual_BuildModel( context ); // // Step #3: Post-process of the BuildModel() pattern. // Remember min/max pixel for color-dynamics once histogram has been // generated. if( settings==NULL ) InitializeColorDynamicsSettings(); else SetSettings( *settings ); // Remember image properties. if( buildContext->m_Properties!=NULL ) SetProperties( *buildContext->m_Properties ); // Apply settings to child QuicklookModel. ApplySettings(); } /*****************************************************************************/ void VectorImageModel ::InitializeColorSetupSettings() { // Remember meta-data interface. otb::ImageMetadataInterfaceBase::ConstPointer metaData( GetMetaDataInterface() ); // Ensure default display returns valid band indices (see OTB bug). assert( metaData->GetDefaultDisplay().size()==3 ); #if 0 assert( metaData->GetDefaultDisplay()[ 0 ] < m_Image->GetNumberOfComponentsPerPixel() ); assert( metaData->GetDefaultDisplay()[ 1 ] < m_Image->GetNumberOfComponentsPerPixel() ); assert( metaData->GetDefaultDisplay()[ 2 ] < m_Image->GetNumberOfComponentsPerPixel() ); #endif // Patch invalid band indices of default-display (see OTB bug). VectorImageSettings::ChannelVector rgb( metaData->GetDefaultDisplay() ); if( rgb[ 0 ]>=m_Image->GetNumberOfComponentsPerPixel() ) { rgb[ 0 ] = 0; } if( rgb[ 1 ]>=m_Image->GetNumberOfComponentsPerPixel() ) { rgb[ 1 ] = 0; } if( rgb[ 2 ]>=m_Image->GetNumberOfComponentsPerPixel() ) { rgb[ 2 ] = 0; } // Store default display settings. GetSettings().SetRgbChannels( rgb ); // Store default grayscale-mode. if( m_Image->GetNumberOfComponentsPerPixel()<3 ) { GetSettings().SetGrayscaleActivated( true ); GetSettings().SetGrayChannel( rgb[ 0 ] ); } } /*****************************************************************************/ void VectorImageModel ::InitializeColorDynamicsSettings() { // Get the histogram-model. HistogramModel* histogramModel = GetHistogramModel(); assert( histogramModel!=NULL ); // Remember min/max pixels. DefaultImageType::PixelType min( histogramModel->GetMinPixel() ); DefaultImageType::PixelType max( histogramModel->GetMaxPixel() ); CountType begin = -1; CountType end = -1; mvd::RgbwBounds( begin, end, RGBW_CHANNEL_ALL ); // Store min/max intensities of default-display channels. for( CountType i=begin; i( i ); VectorImageSettings::ChannelVector::value_type band = GetSettings().GetRgbwChannel( channel ); bool isInvalid = !histogramModel->IsValid() /* || histogramModel->IsMonoValue() */; GetSettings().SetLowIntensity( channel, isInvalid ? min[ band ] : histogramModel->Quantile( band , 0.02, BOUND_LOWER ) ); GetSettings().SetHighIntensity( channel, isInvalid ? max[ band ] : histogramModel->Quantile( band , 0.02, BOUND_UPPER ) ); } } /*****************************************************************************/ CountType VectorImageModel::ComputeBestLod( int width, int height ) const { if( width<=0 || height<=0 ) return 0; ImageRegionType nativeLargestRegion( GetNativeLargestRegion() ); double factorX = double( width ) / double( nativeLargestRegion.GetSize()[ 0 ] ); double factorY = double( height ) / double( nativeLargestRegion.GetSize()[ 1 ] ); double initialZoomFactor = std::min(factorX, factorY); // Compute the best lod from the initialZoomFactor return ComputeBestLod( initialZoomFactor ); } /*****************************************************************************/ unsigned int VectorImageModel::ComputeBestLod( double zoomFactor ) const { return this->Closest( static_cast< int >( (1 / zoomFactor + 0.5) ), m_LodCount ); } /*****************************************************************************/ unsigned int VectorImageModel::Closest( double invZoomfactor, unsigned int lodCount ) { double minDist = 50000.; unsigned int closest = 0; // Compute the diff and keep the index that minimize the distance for (unsigned int idx = 0; idx < lodCount; idx++) { double diff = vcl_abs( static_cast< double >( 1 << idx ) - invZoomfactor ); if( diff < minDist ) { minDist = diff; closest = idx; } } return closest; } /*****************************************************************************/ void VectorImageModel ::SetupCurrentLodImage( int width, int height ) { CountType bestInitialLod = 0; // Compute the initial zoom factor and the best LOD. if( width>0 && height>0 ) { ImageRegionType nativeLargestRegion( GetNativeLargestRegion() ); double factorX = double( width ) / double( nativeLargestRegion.GetSize()[ 0 ] ); double factorY = double( height ) / double( nativeLargestRegion.GetSize()[ 1 ] ); double initialZoomFactor = std::min(factorX, factorY); // Compute the best lod from the initialZoomFactor bestInitialLod = ComputeBestLod(initialZoomFactor); } this->SetCurrentLod( bestInitialLod ); } /*****************************************************************************/ CountType VectorImageModel ::GetNbLod() const { return m_LodCount; } /*****************************************************************************/ void VectorImageModel ::virtual_SetCurrentLod( CountType lod ) { // new filename if lod is not 0 QString lodFilename( GetFilename() ); // If model is a multi-resolution image. if (lodFilename.count(QChar('?')) == 0) { // the filename is not an extended filename yet lodFilename.append( QChar('?') ); } lodFilename.append( QString( "&resol=%1" ).arg( lod ) ); // Update m_ImageFileReader m_ImageFileReader->SetFileName( QFile::encodeName( lodFilename ).constData() ); m_ImageFileReader->GetOutput()->UpdateOutputInformation(); // (Always) Update m_Image reference. m_Image = m_ImageFileReader->GetOutput(); } /*****************************************************************************/ void VectorImageModel ::virtual_RefreshHistogram() { assert( GetProperties()!=NULL ); RefreshHistogram( NULL ); } /*****************************************************************************/ ImageBaseType::ConstPointer VectorImageModel ::ToImageBase() const { return ImageBaseType::ConstPointer( m_Image ); } /*****************************************************************************/ ImageBaseType::Pointer VectorImageModel ::ToImageBase() { return ImageBaseType::Pointer( m_Image ); } /*****************************************************************************/ std::string VectorImageModel ::GetCenterPixelPlaceName() { // center index IndexType centerIndex; centerIndex[0] = GetNativeLargestRegion().GetIndex()[0] + GetNativeLargestRegion().GetSize(0)/2; centerIndex[1] = GetNativeLargestRegion().GetIndex()[1] + GetNativeLargestRegion().GetSize(1)/2; // // Compute the physical coordinates of the center pixel PointType centerPoint; centerPoint[0] = (centerIndex[0] * GetNativeSpacing()[0] ) + GetOrigin()[0]; centerPoint[1] = (centerIndex[1] * GetNativeSpacing()[1] ) + GetOrigin()[1]; // lat / long PointType wgs84; wgs84 = GetGenericRSTransform()->TransformPoint(centerPoint); // get placename otb::CoordinateToName::Pointer coordinateToName = otb::CoordinateToName::New(); coordinateToName->SetLonLat(wgs84); coordinateToName->Evaluate(); // get the placename - Country (if any) std::ostringstream oss; std::string placeName = coordinateToName->GetPlaceName(); std::string countryName = coordinateToName->GetCountryName(); if (placeName != "") oss << placeName; if (countryName != "") oss << " - "<< countryName; return oss.str(); } /*****************************************************************************/ bool VectorImageModel ::IsModified() const { return GetSettings().IsModified() || ( GetProperties()!=NULL && GetProperties()->IsModified() ); } /*****************************************************************************/ void VectorImageModel ::ClearModified() { GetSettings().ClearModified(); if( GetProperties()!=NULL ) GetProperties()->ClearModified(); // TODO: Remove temporary hack (Quicklook modified flag). QuicklookModel* quicklookModel = GetQuicklookModel(); // If image-model is not quicklook-model. if( quicklookModel!=NULL ) quicklookModel->ClearModified(); } /*****************************************************************************/ void VectorImageModel ::ApplySettings() { // qDebug() << this << "::ApplySettings()"; // TODO: Remove temporary hack (Quicklook rendering settings). QuicklookModel* quicklookModel = GetQuicklookModel(); // If image-model is not quicklook-model. if( quicklookModel!=NULL ) { // Update quicklook rendering-settings. quicklookModel->SetSettings( GetSettings() ); quicklookModel->ApplySettings(); } } /*****************************************************************************/ std::string VectorImageModel ::virtual_GetWkt() const { assert( !m_Image.IsNull() ); return m_Image->GetProjectionRef(); } /*****************************************************************************/ bool VectorImageModel ::virtual_HasKwl() const { assert( !m_Image.IsNull() ); return m_Image->GetImageKeywordlist().GetSize()>0; } /*****************************************************************************/ void VectorImageModel ::virtual_ToWgs84( const PointType & physical, PointType & wgs84, double & alt ) const { assert( !m_ToWgs84.IsNull() ); assert( m_ToWgs84->IsUpToDate() ); wgs84 = m_ToWgs84->TransformPoint( physical ); alt = otb::DEMHandler::Instance()->GetHeightAboveEllipsoid( wgs84[ 0 ], wgs84[ 1 ] ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void VectorImageModel ::OnModelUpdated() { // qDebug() << this << "::OnModelUpdated()"; // Apply settings to rendering pipeline. ApplySettings(); // Emit settings update to notify display refresh. emit SettingsUpdated( this ); // Emit properties update. emit PropertiesUpdated( this ); } /*****************************************************************************/ void VectorImageModel ::OnPhysicalCursorPositionChanged( const QPoint &, const PointType &, const PointType & point, const DefaultImageType::PixelType& pixel ) { // Pixel is read from otb::GlImageActor (inside ImageViewRender) // which does only components contain red, green and blue channel components. // Only read, green and blue channel related component are // present. #define USE_RGB_CHANNELS_LIMIT 1 // stream to fill std::ostringstream ossPhysicalX; std::ostringstream ossPhysicalY; std::ostringstream ossGeographicLong; std::ostringstream ossGeographicLat; std::ostringstream ossGeographicElevation; std::ostringstream ossRadio; // emitted current pixel QStringList bandNames; #if USE_RGB_CHANNELS_LIMIT QStringList stringList; #endif //emitted current geography StringVector geoVector; QStringList geoList; //emitted current geography StringVector cartoVector; QStringList cartoList; SpacingType nativeSpacing( GetNativeSpacing() ); // physical coordinates to index (at resol 0) IndexType currentIndex; currentIndex[ 0 ] = static_cast< unsigned int >( ( point[ 0 ] - GetOrigin()[ 0 ] ) / nativeSpacing[ 0 ] ); currentIndex[ 1 ] = static_cast< unsigned int >( ( point[ 1 ] - GetOrigin()[ 1 ] ) / nativeSpacing[ 1 ] ); bool isInsideNativeLargestRegion = GetNativeLargestRegion().IsInside( currentIndex ); emit CurrentIndexUpdated( currentIndex, isInsideNativeLargestRegion ); // // Display the radiometry of the displayed channels VectorImageSettings::ChannelVector rgb; GetSettings().GetSmartChannels( rgb ); // show the current pixel description only if the mouse cursor is // under the image if( isInsideNativeLargestRegion || 1 ) { // // get the physical coordinates if (!ToImage()->GetProjectionRef().empty()) { cartoVector.push_back(ToStdString(tr("Cartographic"))); } else { //No cartographic info available cartoVector.push_back(ToStdString(tr("Physical"))); } ossPhysicalX << point[ 0 ]; ossPhysicalY << point[ 1 ]; cartoVector.push_back(ossPhysicalX.str()); cartoVector.push_back(ossPhysicalY.str()); // index in current Lod image IndexType currentLodIndex; currentLodIndex[0] = (point[ 0 ] - ToImage()->GetOrigin()[0]) / ToImage()->GetSpacing()[0]; currentLodIndex[1] = (point[ 1 ] - ToImage()->GetOrigin()[1]) / ToImage()->GetSpacing()[1]; // // get the LatLong if (!ToImage()->GetProjectionRef().empty()) { geoVector.push_back(ToStdString(tr("Geographic(exact)"))); } else if (ToImage()->GetImageKeywordlist().GetSize() != 0) { geoVector.push_back(ToStdString(tr("Geographic(sensor model)"))); } else { geoVector.push_back(ToStdString(tr("No geoinfo"))); } if( ToImage()->GetLargestPossibleRegion().IsInside(currentLodIndex) || 1 ) { // TODO : Is there a better method to detect no geoinfo available ? if (!ToImage()->GetProjectionRef().empty() || ToImage()->GetImageKeywordlist().GetSize() != 0) { assert( !m_ToWgs84.IsNull() ); PointType wgs84; wgs84 = m_ToWgs84->TransformPoint( point ); ossGeographicLong.precision(6); ossGeographicLat.precision(6); ossGeographicLong << std::fixed << wgs84[0]; ossGeographicLat << std::fixed << wgs84[1]; geoVector.push_back(ossGeographicLong.str()); geoVector.push_back(ossGeographicLat.str()); double elev = otb::DEMHandler::Instance()->GetHeightAboveEllipsoid(wgs84[0],wgs84[1]); if(elev > -32768) { ossGeographicElevation << elev; geoVector.push_back(ossGeographicElevation.str()); } else geoVector.push_back( "" ); } else { //No geoinfo available geoVector.push_back(""); geoVector.push_back(""); geoVector.push_back(""); } } /* else { //handle here the case of QL information display. It //displays geographic info when the user is scrolling over the QL // // compute the current ql index if (!ToImage()->GetProjectionRef().empty() || ToImage()->GetImageKeywordlist().GetSize() != 0) { currentLodIndex[0] = (Xpc - GetQuicklookModel()->ToImage()->GetOrigin()[0]) / GetQuicklookModel()->ToImage()->GetSpacing()[0]; currentLodIndex[1] = (Ypc - GetQuicklookModel()->ToImage()->GetOrigin()[1]) / GetQuicklookModel()->ToImage()->GetSpacing()[1]; PointType wgs84; PointType currentLodPoint; GetQuicklookModel()->ToImage()->TransformIndexToPhysicalPoint(currentLodIndex, currentLodPoint); wgs84 = GetGenericRSTransform()->TransformPoint(currentLodPoint); ossGeographicLong.precision(6); ossGeographicLat.precision(6); ossGeographicLong << std::fixed << wgs84[0]; ossGeographicLat << std::fixed << wgs84[1]; //Update geovector with location over QL index geoVector.push_back(ossGeographicLong.str()); geoVector.push_back(ossGeographicLat.str()); double elev = otb::DEMHandler::Instance()->GetHeightAboveEllipsoid(wgs84[0],wgs84[1]); if(elev > -32768) { ossGeographicElevation << elev; geoVector.push_back(ossGeographicElevation.str()); } } else { //No geoinfo available geoVector.push_back(""); geoVector.push_back(""); geoVector.push_back(""); } } */ cartoList = ToQStringList( cartoVector ); geoList = ToQStringList( geoVector ); if( true /* ToImage()->GetBufferedRegion().IsInside(currentLodIndex) */ ) { /* // // get the pixel at current index currentPixel = ToImage()->GetPixel(currentLodIndex); */ ossRadio << ToStdString( tr( "Radiometry: [ " ) ); #if USE_RGB_CHANNELS_LIMIT for( unsigned int i=0; iToImage()->GetOrigin()[0]) / GetQuicklookModel()->ToImage()->GetSpacing()[0]; currentLodIndex[1] = (Ypc - GetQuicklookModel()->ToImage()->GetOrigin()[1]) / GetQuicklookModel()->ToImage()->GetSpacing()[1]; // // Get the radiometry form the Ql if ( GetQuicklookModel()->ToImage()->GetBufferedRegion().IsInside(currentLodIndex) ) { currentPixel = GetQuicklookModel()->ToImage()->GetPixel(currentLodIndex); ossRadio <<"Ql [ "; for (unsigned int idx = 0; idx < rgb.size(); idx++) { ossRadio < // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdTextStream.h" namespace mvd { /* TRANSLATOR mvd::VectorImageSettings Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ VectorImageSettings ::VectorImageSettings() : m_RgbChannels(), m_RgbDynamicsParams( 6 ), m_IsGrayscaleActivated( false ), m_GrayChannel( 0 ), m_GrayDynamicsParams( 6 ), m_Gamma( 1.0 ) { m_RgbDynamicsParams.Fill( 0 ); m_GrayDynamicsParams.Fill( 0 ); } /***************************************************************************/ VectorImageSettings ::VectorImageSettings( const VectorImageSettings & other ) : m_RgbChannels( other.m_RgbChannels ), m_RgbDynamicsParams( other.m_RgbDynamicsParams ), m_IsGrayscaleActivated( other.m_IsGrayscaleActivated ), m_GrayChannel( other.m_GrayChannel ), m_GrayDynamicsParams( 6 ), m_Gamma( other.m_Gamma ) { } /*****************************************************************************/ VectorImageSettings ::~VectorImageSettings() { } /*****************************************************************************/ VectorImageSettings::ChannelVector::value_type VectorImageSettings ::GetRgbwChannel( RgbwChannel channel ) const { switch( channel ) { case RGBW_CHANNEL_RED: case RGBW_CHANNEL_GREEN: case RGBW_CHANNEL_BLUE: return m_RgbChannels[ channel ]; break; case RGBW_CHANNEL_WHITE: return m_GrayChannel; break; default: throw std::invalid_argument( ToStdString( QCoreApplication::translate( "mvd::VectorImageSettings", "Invalid argument: %1 ('%2')" ) .arg( channel ) .arg( RGBW_CHANNEL_NAMES[ channel ] ) ) ); break; } } /*****************************************************************************/ void VectorImageSettings ::SetLowIntensity( RgbwChannel channel, ParametersType::ValueType intensity ) { switch( channel ) { case RGBW_CHANNEL_RGB: SetRgbDynamicsParam( 2 * RGBW_CHANNEL_RED, intensity ); SetRgbDynamicsParam( 2 * RGBW_CHANNEL_GREEN, intensity ); SetRgbDynamicsParam( 2 * RGBW_CHANNEL_BLUE, intensity ); break; case RGBW_CHANNEL_WHITE: SetGrayDynamicsParam( 0, intensity ); break; case RGBW_CHANNEL_RED: case RGBW_CHANNEL_GREEN: case RGBW_CHANNEL_BLUE: SetRgbDynamicsParam( 2 * channel, intensity ); break; default: throw std::invalid_argument( ToStdString( QCoreApplication::translate( "mvd::VectorImageSettings", "Invalid argument: %1 ('%2')" ) .arg( channel ) .arg( RGBW_CHANNEL_NAMES[ channel ] ) ) ); break; } } /*****************************************************************************/ ParametersType::ValueType VectorImageSettings ::GetLowIntensity( RgbwChannel channel ) const { switch( channel ) { case RGBW_CHANNEL_RGB: { ParametersType::ValueType r = GetRgbDynamicsParam( 2 * RGBW_CHANNEL_RED ); ParametersType::ValueType g = GetRgbDynamicsParam( 2 * RGBW_CHANNEL_GREEN ); ParametersType::ValueType b = GetRgbDynamicsParam( 2 * RGBW_CHANNEL_BLUE ); return (r + g + b) / 3; } break; case RGBW_CHANNEL_WHITE: return GetGrayDynamicsParam( false ); break; case RGBW_CHANNEL_RED: case RGBW_CHANNEL_GREEN: case RGBW_CHANNEL_BLUE: return GetRgbDynamicsParam( 2 * channel ); break; default: throw std::invalid_argument( ToStdString( QCoreApplication::translate( "mvd::VectorImageSettings", "Invalid argument: %1 ('%2')" ) .arg( channel ) .arg( RGBW_CHANNEL_NAMES[ channel ] ) ) ); break; } } /*****************************************************************************/ void VectorImageSettings ::SetHighIntensity( RgbwChannel channel, ParametersType::ValueType intensity ) { switch( channel ) { case RGBW_CHANNEL_RGB: SetRgbDynamicsParam( 1 + 2 * RGBW_CHANNEL_RED, intensity ); SetRgbDynamicsParam( 1 + 2 * RGBW_CHANNEL_GREEN, intensity ); SetRgbDynamicsParam( 1 + 2 * RGBW_CHANNEL_BLUE, intensity ); break; case RGBW_CHANNEL_WHITE: SetGrayDynamicsParam( 1, intensity ); break; case RGBW_CHANNEL_RED: case RGBW_CHANNEL_GREEN: case RGBW_CHANNEL_BLUE: SetRgbDynamicsParam( 1 + 2 * channel, intensity ); break; default: assert( false ); break; } } /*****************************************************************************/ ParametersType::ValueType VectorImageSettings ::GetHighIntensity( RgbwChannel channel ) const { switch( channel ) { case RGBW_CHANNEL_RGB: { ParametersType::ValueType r = GetRgbDynamicsParam( 1+ 2*RGBW_CHANNEL_RED ); ParametersType::ValueType g = GetRgbDynamicsParam( 1+ 2*RGBW_CHANNEL_GREEN ); ParametersType::ValueType b = GetRgbDynamicsParam( 1+ 2*RGBW_CHANNEL_BLUE ); return (r + g + b) / 3; } break; case RGBW_CHANNEL_WHITE: return GetGrayDynamicsParam( 1 ); break; case RGBW_CHANNEL_RED: case RGBW_CHANNEL_GREEN: case RGBW_CHANNEL_BLUE: return GetRgbDynamicsParam( 1 + 2 * channel ); break; default: throw std::invalid_argument( ToStdString( QCoreApplication::translate( "mvd::VectorImageSettings", "Invalid argument: %1 ('%2')" ) .arg( channel ) .arg( RGBW_CHANNEL_NAMES[ channel ] ) ) ); break; } } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiCore/src/mvdVisibleInterface.cxx000066400000000000000000000050311301006202600300530ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdVisibleInterface.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::VisibleInterface Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ VisibleInterface ::VisibleInterface( bool isVisible ) : m_IsVisible( isVisible ) { } /*******************************************************************************/ VisibleInterface ::~VisibleInterface() { } /*******************************************************************************/ void VisibleInterface ::virtual_SignalVisibilityChanged( bool ) { } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/000077500000000000000000000000001301006202600224505ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiGui/CMakeLists.txt000066400000000000000000000003301301006202600252040ustar00rootroot00000000000000project( OTBMonteverdiGUI ) set( OTBMonteverdiGUI_LIBRARIES OTBMonteverdiGUI ) # folder where ui headers are generated set( OTBMonteverdiGUI_INCLUDE_DIRS ${OTBMonteverdiGUI_BINARY_DIR}/src ) otb_module_impl() OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/000077500000000000000000000000001301006202600240735ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdAboutDialog.h000066400000000000000000000036471301006202600271570ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAboutDialog_h #define mvdAboutDialog_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class AboutDialog; } /** \class AboutDialog * * \ingroup OTBMonteverdiGUI * */ class OTBMonteverdiGUI_EXPORT AboutDialog : public QDialog { Q_OBJECT; // // Public methods. public: /** Constructor */ AboutDialog( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** Destructor */ ~AboutDialog() ITK_OVERRIDE; // // SIGNALS. signals: // // Protected methods. protected: // // Protected attributes. protected: // // Private methods. private: // // Private attributes. private: /** */ Ui::AboutDialog* m_UI; // // SLOTS. private slots: }; } // end namespace 'mvd' #endif // mvdAboutDialog_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdAbstractDragAndDropEventFilter.h000066400000000000000000000101401301006202600327300ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractDragAndDropEventFilter_h #define mvdAbstractDragAndDropEventFilter_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class AbstractDragAndDropEventFilter * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT AbstractDragAndDropEventFilter : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Destructor. */ ~AbstractDragAndDropEventFilter() ITK_OVERRIDE; // // QObject overloads. /** * \see http://qt-project.org/doc/qt-4.8/qobject.html#eventFilter */ bool eventFilter( QObject* watched, QEvent* event ) ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ AbstractDragAndDropEventFilter( QObject* p =NULL ); /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragEnterEvent */ virtual bool DragEnterEvent( QObject* object, QDragEnterEvent* event ) =0; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragLeaveEvent */ virtual bool DragLeaveEvent( QObject* object, QDragLeaveEvent* event ) =0; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragMoveEvent */ virtual bool DragMoveEvent( QObject* object, QDragMoveEvent* event ) =0; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dropEvent */ virtual bool DropEvent( QObject* object, QDropEvent* event ) =0; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdAbstractDragAndDropEventFilter_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdAbstractImageViewManipulator.h000066400000000000000000000137421301006202600325370ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractImageViewManipulator_h #define mvdAbstractImageViewManipulator_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" #include "mvdAbstractImageViewRenderer.h" #include "mvdGui.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class AbstractImageViewManipulator * * \ingroup OTBMonteverdiGUI * * \brief Base class for QWidget manipulation */ class OTBMonteverdiGUI_EXPORT AbstractImageViewManipulator : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Destructor. */ ~AbstractImageViewManipulator() ITK_OVERRIDE {}; // // Accessors /** */ virtual void SetViewportSize( int width, int height ) =0; /** */ virtual SizeType GetViewportSize() const =0; /** */ virtual void SetOrigin( const PointType& origin ) =0; /** */ virtual PointType GetOrigin() const =0; /** */ virtual void SetSpacing( const SpacingType& spacing ) =0; /** */ virtual SpacingType GetSpacing() const =0; /** */ virtual void SetNativeSpacing( const SpacingType& spacing ) =0; /** */ virtual void SetWkt( const std::string& wkt ) =0; /** */ virtual void SetKeywordList( const DefaultImageType::ImageKeywordlistType& kwl ) =0; /** */ virtual PointType GetCenter() const =0; /** */ virtual ZoomType GetFixedZoomType() const =0; // // Controls /** */ virtual void SetupRenderingContext( AbstractImageViewRenderer::RenderingContext * const ) const =0; /** */ virtual void ZoomIn() =0; /** */ virtual void ZoomOut() =0; /** */ virtual const PointType& Transform( PointType&, const QPoint& ) const =0; // // Events /** */ virtual void MouseMoveEvent( QMouseEvent* event ) =0; /** */ virtual void MousePressEvent( QMouseEvent* event ) =0; /** */ virtual void MouseReleaseEvent( QMouseEvent* event ) =0; /** */ virtual void MouseDoubleClickEvent( QMouseEvent * ) {}; /** */ virtual void WheelEvent( QWheelEvent* event) =0; /** */ virtual void KeyPressEvent( QKeyEvent* event ) =0; /** */ virtual void KeyReleaseEvent( QKeyEvent* event ) =0; /** */ virtual void ResizeEvent( QResizeEvent* event ) =0; /** */ virtual void ResetViewport() =0; // // Public SLOTS. public slots: /** */ virtual void CenterOn( const PointType& point ) =0; /** */ virtual void ZoomTo( double scale ) =0; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /** */ void RefreshViewRequested(); /** */ void ZoomToExtentRequested(); /** */ void ZoomToFullResolutionRequested(); /** */ void CenterRoiRequested( const PointType& center ); /** */ void RoiChanged( const PointType& origin, const SizeType& size, const SpacingType& spacing, const PointType& center ); // Signal for DatasetModel // void RenderingContextChanged(const PointType& center, double zoom); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected types. protected: /** Navigation context */ struct NavigationContext { /** * \brief Constructor. * * Default constructor (safely) initializes POD (Plain Old Data) * structure. */ NavigationContext() { } }; /** Mouse context */ struct MouseContext { /** * \brief Default constructor. */ MouseContext() { } }; // // Protected methods. protected: /** \brief Constructor. */ AbstractImageViewManipulator( QObject* p =NULL ):QObject( p ){}; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // SLOTS. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdAbstractImageViewManipulator_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdAbstractImageViewRenderer.h000066400000000000000000000260601301006202600320070ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractImageViewRenderer_h #define mvdAbstractImageViewRenderer_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdStackedLayerModel.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractLayerModel; class StackedLayerModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class AbstractImageViewRenderer * * \ingroup OTBMonteverdiGUI * * \brief TODO. */ class OTBMonteverdiGUI_EXPORT AbstractImageViewRenderer : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: /** */ struct RenderingContext { /** */ inline RenderingContext() : m_RenderMode( RENDER_MODE_FULL ) { } /** */ virtual ~RenderingContext() {} /** */ enum RenderMode { RENDER_MODE_LIGHT = 0, RENDER_MODE_FULL }; RenderMode m_RenderMode; }; // // Public methods. public: /** * Destructor. */ ~AbstractImageViewRenderer() ITK_OVERRIDE{}; /** */ inline void SetLayerStack( StackedLayerModel * ); /** */ inline const StackedLayerModel * GetLayerStack() const; /** */ inline StackedLayerModel * GetLayerStack(); /** */ virtual bool CheckGLCapabilities( int * ) =0; template< typename T > const T * GetReferenceModel() const; template< typename T > T * GetReferenceModel(); /** */ virtual const AbstractLayerModel * GetReferenceModel() const =0; /** */ virtual AbstractLayerModel * GetReferenceModel() =0; /** */ virtual void GetLayerExtent( const StackedLayerModel::KeyType & key, PointType& origin, PointType& extent ) const =0; /** */ virtual void GetReferenceExtent( PointType& origin, PointType& extent ) const =0; /** */ virtual void GetViewExtent( PointType& origin, PointType& extent ) const =0; /** */ virtual bool GetLayerDynamics( const StackedLayerModel::KeyType & key, ParametersType & params, bool isGlobal ) const =0; /** */ virtual AbstractImageViewRenderer::RenderingContext* NewRenderingContext() const =0; /** */ virtual void InitializeGL() =0; /** */ virtual void ResizeGL( int width, int height ) =0; /** */ virtual void PaintGL( RenderingContext const * context ) =0; /** */ virtual void Pick( const PointType & view, PixelInfo::Vector & pixels ) const = 0; /** */ virtual void GetResolutions( PixelInfo::Vector & pixels ) const =0; /** */ virtual bool TransformToView( PointType & point, const StackedLayerModel::KeyType &, const IndexType &, bool isPhysical ) const =0; /** */ virtual void SaveScreenshot( const QString & ) const =0; /** */ inline bool SetBypassRenderingEnabled( bool ); /** */ inline bool IsBypassRenderingEnabled() const; /** */ inline bool SetGLSLEnabled( bool ); /** */ inline bool IsGLSLEnabled() const; /** */ virtual bool IsEffectsEnabled() const = 0; /** */ inline bool ZoomToRegion( const PointType & origin, const PointType & extent, PointType & center, SpacingType & spacing ) const; /** */ inline bool ZoomToExtent( PointType & center, SpacingType & spacing ) const; /** */ inline bool ZoomToLayer( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing ) const; /** */ inline bool ZoomToFull( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing ) const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // public slots public slots: inline void UpdateScene(); inline void RefreshScene(); virtual void UpdatePixelInfo( const QPoint & point, const PointType & view, const PixelInfo::Vector & pixels ) =0; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** * Constructor. */ AbstractImageViewRenderer( QObject* p = NULL ) : QObject( p ), m_StackedLayerModel( NULL ), m_BypassRenderingEnabled( false ), m_GLSLEnabled( true ) { } // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ // virtual void virtual_ClearScene() {}; /** */ virtual void virtual_PrepareScene() {}; /** */ virtual void virtual_UpdateScene() {}; /** */ virtual void virtual_RefreshScene() {}; /** */ // virtual void virtual_SetLayerStack( const StackedLayerModel & ) =0; /** */ virtual void virtual_FinishScene() {}; /** */ virtual bool virtual_ZoomToRegion( const PointType &, const PointType &, PointType &, SpacingType & ) const { return false; } /** */ virtual bool virtual_ZoomToExtent( PointType &, SpacingType & ) const { return false; } /** */ virtual bool virtual_ZoomToLayer( const StackedLayerModel::KeyType &, PointType &, SpacingType & ) const { return false; } /** */ virtual bool virtual_ZoomToFull( const StackedLayerModel::KeyType &, PointType &, SpacingType & ) const { return false; } // // Private attributes. private: /** */ StackedLayerModel * m_StackedLayerModel; /** */ bool m_BypassRenderingEnabled: 1; /** */ bool m_GLSLEnabled: 1; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // SLOTS. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ template< typename T > const T * AbstractImageViewRenderer ::GetReferenceModel() const { return dynamic_cast< const T * >( GetReferenceModel() ); } /*****************************************************************************/ template< typename T > T * AbstractImageViewRenderer ::GetReferenceModel() { return dynamic_cast< T * >( GetReferenceModel() ); } /*****************************************************************************/ inline StackedLayerModel * AbstractImageViewRenderer ::GetLayerStack() { return m_StackedLayerModel; } /*****************************************************************************/ inline const StackedLayerModel * AbstractImageViewRenderer ::GetLayerStack() const { return m_StackedLayerModel; } /*****************************************************************************/ inline void AbstractImageViewRenderer ::SetLayerStack( StackedLayerModel * stackedLayerModel ) { virtual_PrepareScene(); m_StackedLayerModel = stackedLayerModel; virtual_UpdateScene(); virtual_FinishScene(); } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::IsBypassRenderingEnabled() const { return m_BypassRenderingEnabled; } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::SetBypassRenderingEnabled( bool isEnabled ) { bool bypass = m_BypassRenderingEnabled; m_BypassRenderingEnabled = isEnabled; return bypass; } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::IsGLSLEnabled() const { return m_GLSLEnabled; } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::SetGLSLEnabled( bool isEnabled ) { bool wasEnabled = m_GLSLEnabled; m_GLSLEnabled = isEnabled; return wasEnabled; } /*****************************************************************************/ inline void AbstractImageViewRenderer ::UpdateScene() { virtual_PrepareScene(); virtual_UpdateScene(); virtual_FinishScene(); } /*****************************************************************************/ inline void AbstractImageViewRenderer ::RefreshScene() { virtual_RefreshScene(); } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::ZoomToExtent( PointType & center, SpacingType & spacing ) const { return virtual_ZoomToExtent( center, spacing ); } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::ZoomToLayer( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing) const { return virtual_ZoomToLayer( key, center, spacing ); } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::ZoomToRegion( const PointType & origin, const PointType & extent, PointType & center, SpacingType & spacing ) const { return virtual_ZoomToRegion( origin, extent, center, spacing ); } /*****************************************************************************/ inline bool AbstractImageViewRenderer ::ZoomToFull( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing ) const { return virtual_ZoomToFull( key, center, spacing ); } } // end namespace 'mvd' #endif // mvdAbstractImageViewRenderer_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdAbstractModelController.h000066400000000000000000000145141301006202600315500ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdAbstractModelController_h #define mvdAbstractModelController_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class AbstractModelController * * \ingroup OTBMonteverdiGUI */ class OTBMonteverdiGUI_EXPORT AbstractModelController : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: // // Public methods. public: /** Destructor */ ~AbstractModelController() ITK_OVERRIDE; /** */ void SetModel( AbstractModel* ); /** */ inline const AbstractModel* GetModel() const; /** */ inline AbstractModel* GetModel(); /** */ template< typename TModel > inline const TModel* GetModel() const; /** */ template< typename TModel > inline TModel* GetModel(); /** */ inline const QWidget* GetWidget() const; /** */ inline QWidget* GetWidget(); /** */ template< typename TWidget > inline const TWidget* GetWidget() const; /** */ template< typename TWidget > inline TWidget* GetWidget(); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Slots. public slots: /** */ void ResetWidget(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void AboutToDisconnectModel( AbstractModel* ); /** */ void ModelDisconnected( AbstractModel* ); /** */ void AboutToConnectModel( AbstractModel* ); /** */ void ModelConnected( AbstractModel* ); /** */ void ModelUpdated(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** Constructor */ AbstractModelController( QWidget* widget, QObject* p =NULL ); // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ void private_Connect( AbstractModel* ); /** */ void private_Disconnect( AbstractModel* ); /** */ void private_ClearWidget(); /** */ virtual void Connect( AbstractModel* ) =0; /** */ virtual void Disconnect( AbstractModel* ) =0; /** */ virtual void ClearWidget() =0; /** */ virtual void virtual_ResetWidget( bool ) =0; // // Private attributes. private: /** */ QWidget* m_Widget; /** */ AbstractModel* m_Model; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** * Slot called before object is destroyed. * It is used to disconnect model from controller when controller is * destroyed. This prevents the indirect call the virtual * Disconnect() method (which is dangerous in destructor). */ void OnDestroyed( QObject* =0 ); /** */ virtual void RefreshWidget(); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ inline const AbstractModel* AbstractModelController ::GetModel() const { return m_Model; } /*****************************************************************************/ inline AbstractModel* AbstractModelController ::GetModel() { return m_Model; } /*****************************************************************************/ template< typename TModel > inline const TModel* AbstractModelController ::GetModel() const { return qobject_cast< const TModel* >( m_Model ); } /*****************************************************************************/ template< typename TModel > inline TModel* AbstractModelController ::GetModel() { return qobject_cast< TModel* >( m_Model ); } /*****************************************************************************/ inline const QWidget* AbstractModelController ::GetWidget() const { return m_Widget; } /*****************************************************************************/ inline QWidget* AbstractModelController ::GetWidget() { return m_Widget; } /*****************************************************************************/ template< typename TWidget > inline const TWidget* AbstractModelController ::GetWidget() const { return qobject_cast< const TWidget* >( m_Widget ); } /*****************************************************************************/ template< typename TWidget > inline TWidget* AbstractModelController ::GetWidget() { return qobject_cast< TWidget* >( m_Widget ); } } // end namespace 'mvd' #endif // mvdAbstractModelController_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdApplicationLauncher.h000066400000000000000000000102011301006202600306720ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdApplicationLauncher_h #define mvdApplicationLauncher_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Wrapper { class QtWidgetView; } /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ApplicationLauncher * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OTBMonteverdiGUI_EXPORT ApplicationLauncher : public QObject { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ ApplicationLauncher( QObject* p =NULL ); /** \brief Destructor. */ ~ApplicationLauncher() ITK_OVERRIDE; /** * \return A new instance of the automatically-generated widget of * the given OTB application. */ Wrapper::QtWidgetView * NewOtbApplicationWidget( const QString & appName, bool isStandalone =false, QWidget * p =NULL, Qt::WindowFlags =0 ) const; /** */ QWidget * NewOtbApplicationWindow( const QString & appName, bool isStandalone =false, QWidget * p =NULL, Qt::WindowFlags =0 ) const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdApplicationLauncher_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdApplicationsToolBox.h000066400000000000000000000113461301006202600307150ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdApplicationsToolBox_h #define mvdApplicationsToolBox_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" #define USE_ALGORITHM_ROOT_NODE 0 /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class ApplicationsToolBox; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ApplicationsToolBox * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT ApplicationsToolBox : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ ApplicationsToolBox( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~ApplicationsToolBox() ITK_OVERRIDE; /** Get TreeWidget */ // QTreeWidget * GetAlgorithmsTree(); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: void OnAvailableApplicationsTagsChanged( const ApplicationsTagContainer& appsTags, const ApplicationDocNameToNameMap& docNameToNameMap); void OnSearchBoxChanged( const QString & search ); void OnAlgorithmTreeDoubleClick( QTreeWidgetItem * item , int column ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: void ApplicationToLaunchSelected(const QString &, const QString &); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: /** * \brief fill the widget tree using the tags map */ void FillTreeUsingTags(); /** * \brief Launch the appName algorithm */ void LaunchApplication( const QString& appName ); /** * \brief Helper method to check if searchText matches any of the * algorithms string contained in the map */ bool IsSearchTextMatchAnyAlgorithm( const QString & tagName, const QString & search ); /** * \brief Helper method to get the DocName of an application from an * application name */ QString GetApplicationDocNameByApplicationName( const QString & appName ); // // Private attributes. private: /** * \brief uic generated. */ Ui::ApplicationsToolBox* m_UI; /** * \brief map storing applications and its tags */ ApplicationsTagContainer m_AppTags; /** * \brief map storing applications docName and appName association */ ApplicationDocNameToNameMap m_AppsDocNameToNameMap; /** * \brief text to search in the widget tree */ QString m_SearchText; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; /*****************************************************************************/ /* INLINE SECTION */ } // end namespace 'mvd' #endif // mvdApplicationsToolBox_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdApplicationsToolBoxController.h000066400000000000000000000101051301006202600327510ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdApplicationsToolBoxController_h #define mvdApplicationsToolBoxController_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractModelController.h" #endif //tag=QT4-boost-compatibility //#include "mvdGui.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class ApplicationsToolBox; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ApplicationsToolBoxController * * \ingroup OTBMonteverdiGUI * * \brief Color-setup widget controller for VectorImageModel objects. */ class OTBMonteverdiGUI_EXPORT ApplicationsToolBoxController : public AbstractModelController { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor. * * \param widget Controlled widget. * \param parent Parent QObject of this QObject. */ ApplicationsToolBoxController( ApplicationsToolBox* widget, QObject* p =NULL ); /** * \brief Destructor. */ ~ApplicationsToolBoxController() ITK_OVERRIDE; /** Get the seleceted application Gui */ // QWidget * GetSelectedApplicationWidget(const QString& appName); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // AbstractModelController methods. void Connect( AbstractModel* ) ITK_OVERRIDE; void ClearWidget() ITK_OVERRIDE; void virtual_ResetWidget( bool ) ITK_OVERRIDE; void Disconnect( AbstractModel* ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ void ResetDatasetTree(); // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdApplicationsToolBoxController_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdColorBandDynamicsWidget.h000066400000000000000000000131411301006202600314520ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdColorBandDynamicsWidget_h #define mvdColorBandDynamicsWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { class DoubleValidator; // // Internal classes pre-declaration. namespace Ui { class ColorBandDynamicsWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ColorBandDynamicsWidget * * \ingroup OTBMonteverdiGUI */ class OTBMonteverdiGUI_EXPORT ColorBandDynamicsWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /** */ Q_PROPERTY( RgbwChannel channelLabel READ GetChannelLabel WRITE SetChannelLabel ); /** */ Q_PROPERTY( double minIntensity READ GetMinIntensity WRITE SetMinIntensity ); /** */ Q_PROPERTY( double maxIntensity READ GetMaxIntensity WRITE SetMaxIntensity ); /** */ Q_PROPERTY( double lowIntensity READ GetLowIntensity WRITE SetLowIntensity ); /** */ Q_PROPERTY( double highIntensity READ GetHighIntensity WRITE SetHighIntensity ); /** */ Q_PROPERTY( double lowQuantile READ GetLowQuantile WRITE SetLowQuantile ); /** */ Q_PROPERTY( double highQuantile READ GetHighQuantile WRITE SetHighQuantile ); /** */ Q_PROPERTY( bool isBounded READ IsBounded() WRITE SetBounded() ); /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** Constructor */ ColorBandDynamicsWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** Destructor */ ~ColorBandDynamicsWidget() ITK_OVERRIDE; /** */ RgbwChannel GetChannelLabel() const; /** */ void SetChannelLabel( RgbwChannel ); /** */ double GetMinIntensity() const; /** */ void SetMinIntensity( double ); /** */ double GetMaxIntensity() const; /** */ void SetMaxIntensity( double ); /** */ double GetLowIntensity() const; /** */ void SetLowIntensity( double ); /** */ double GetHighIntensity() const; /** */ void SetHighIntensity( double ); /** */ double GetLowQuantile() const; /** */ void SetLowQuantile( double ); /** */ double GetHighQuantile() const; /** */ void SetHighQuantile( double ); /** */ bool IsBounded() const; /** */ void SetBounded( bool enabled ); /** */ void SetLinkButtonEnabled( bool ); /** */ void SetDefaultsButtonEnabled( bool ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void LowQuantileChanged( RgbwChannel, double ); /** */ void HighQuantileChanged( RgbwChannel, double ); /** */ void LowIntensityChanged( RgbwChannel, double ); /** */ void HighIntensityChanged( RgbwChannel, double ); /** */ void ResetIntensityClicked( RgbwChannel ); /** */ void ResetQuantileClicked( RgbwChannel ); /** */ void ApplyAllClicked( RgbwChannel, double, double); /** */ void LinkToggled( RgbwChannel, bool ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /** * uic generated. */ Ui::ColorBandDynamicsWidget* m_UI; /** */ DoubleValidator* m_LowIntensityValidator; /** */ DoubleValidator* m_HighIntensityValidator; /** */ RgbwChannel m_Channel; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: void on_lowIntensityLineEdit_editingFinished(); void on_highIntensityLineEdit_editingFinished(); void on_lowQuantileSpinBox_valueChanged( double ); void on_highQuantileSpinBox_valueChanged( double ); void on_minMaxButton_clicked(); void on_defaultsButton_clicked(); void on_applyAllButton_clicked(); void on_linkButton_toggled( bool ); }; } // end namespace 'mvd'. #endif // mvdColorBandDynamicsWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdColorDynamicsController.h000066400000000000000000000243261301006202600315740ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdColorDynamicsController_h #define mvdColorDynamicsController_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" // #include "mvdAbstractModelController.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class ColorDynamicsWidget; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ColorDynamicsController * * \ingroup OTBMonteverdiGUI * * \brief Color-dynamics widget controller for VectorImageModel objects. */ class OTBMonteverdiGUI_EXPORT ColorDynamicsController : public AbstractModelController { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor. * * \param widget Controlled widget. * \param parent Parent QObject of this QObject. */ ColorDynamicsController( ColorDynamicsWidget* widget, QObject* p =NULL ); /** \brief Destructor. */ ~ColorDynamicsController() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]-----------------------------------------------**/ // // Slots. public slots: /** * \brief Slot called when the band-index of a RGB channel has * changed. * * \param channel The RGB channel for which the band-index has changed. * \param band The new band-index of the RGB channel. */ void OnRgbChannelIndexChanged( RgbwChannel channel, int band ); /** * \brief Slot called when the band-index of the white (gray) * channel has changed. * * \param band The new band-index of the white (gray) channel. */ void OnGrayChannelIndexChanged( int band ); /** * \brief Slot called when the activation-state of the * grayscale-mode has changed. * * \param activated The new grayscale-mode activation state. */ void OnGrayscaleActivated( bool activated ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** * \brief */ void LowIntensityChanged( RgbwChannel channel, double value, bool refresh ); /** * \brief */ void HighIntensityChanged( RgbwChannel channel, double value, bool refresh ); /** */ void HistogramRefreshed(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // AbstractModelController methods. void Connect( AbstractModel* ) ITK_OVERRIDE; void ClearWidget() ITK_OVERRIDE; void virtual_ResetWidget( bool ) ITK_OVERRIDE; void Disconnect( AbstractModel* ) ITK_OVERRIDE; /** * \brief Reset intensity ranges to default values for given RGB * channels. * * \param channels Given channels for which to reset current-band * index. \see RgbBound() for valid values. */ void ResetIntensityRanges( RgbwChannel ); /** * \brief Reset low and high intensities to default values for given * RGB channels. * * \param channels Given channels for which to reset current-band * index. \see RgbBound() for valid values. */ void ResetIntensities( RgbwChannel ); /** * \brief Set low and high intensitied of controlled widget based on * the values stored in the model settings. * * \param channels RGB/W channels for which to set low and hight intensities. */ void SetIntensities( RgbwChannel channels ); /** * \brief Reset low and high quantiles to default values for given * RGB channels. * * \param channels Given channels for which to reset current-band * index. \see RgbBound() for valid values. */ void ResetQuantiles( RgbwChannel channels ); /** * \brief Restore low and high intensities from quantile values * stored in widget when enabling intensity-range bounds again. * * \param channels Channels for which to reset intensities. */ void RestoreQuantiles( RgbwChannel channels ); /** * \brief Convenience method used to compute integer indices in order * to iterate through RGB channels such as, for example: * \code * for( i=begin; i // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdColorBandDynamicsWidget.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class ColorDynamicsWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ColorDynamicsWidget * * \ingroup OTBMonteverdiGUI */ class OTBMonteverdiGUI_EXPORT ColorDynamicsWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; Q_PROPERTY( bool isNoDataChecked READ IsNoDataChecked WRITE SetNoDataChecked ); Q_PROPERTY( double NoDataValue READ GetNoDataValue WRITE SetNoDataValue ); Q_PROPERTY( int GammaCursorPosition READ GetGammaCursorPosition WRITE SetGammaCursorPosition ); Q_PROPERTY( int MinGamma READ GetMinGamma WRITE SetMinGamma ); Q_PROPERTY( int MaxGamma READ GetMaxGamma WRITE SetMaxGamma ); Q_PROPERTY( int GammaStep READ GetGammaStep WRITE SetGammaStep ); Q_PROPERTY( double Gamma READ GetGamma WRITE SetGamma ); /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** Constructor. */ ColorDynamicsWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** Destructor. */ ~ColorDynamicsWidget() ITK_OVERRIDE; /** */ inline const ColorBandDynamicsWidget* GetChannel( RgbwChannel ) const; /** */ inline ColorBandDynamicsWidget* GetChannel( RgbwChannel ); /** */ void SetGrayscaleActivated( bool activated ); /** */ bool IsGrayscaleActivated() const; /** */ void SetNoDataChecked( bool checked ); /** */ bool IsNoDataChecked() const; /** */ void SetNoDataValue( double value ); /** */ double GetNoDataValue() const; /** */ void SetGamma( double value ); /** */ double GetGamma() const; /** */ void SetGammaCursorPosition( int value ); /** */ int GetGammaCursorPosition() const; /** */ void SetMinGamma( int value ); /** */ int GetMinGamma() const; /** */ void SetMaxGamma( int value ); /** */ int GetMaxGamma() const; /** */ void SetGammaStep( int value ); /** */ int GetGammaStep() const; // // Public slots. public slots: /** */ void SetNoDataButtonChecked( bool checked ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void LowQuantileChanged( RgbwChannel, double ); /** */ void HighQuantileChanged( RgbwChannel, double ); /** */ void LowIntensityChanged( RgbwChannel, double ); /** */ void HighIntensityChanged( RgbwChannel, double ); /** */ void ResetIntensityClicked( RgbwChannel ); /** */ void ResetQuantileClicked( RgbwChannel ); /** */ void ApplyAllClicked( RgbwChannel, double, double ); /** */ void LinkToggled( RgbwChannel, bool ); /** */ void NoDataFlagToggled( bool enabled ); /** */ void NoDataValueChanged( double value ); /** */ void NoDataButtonPressed(); /** */ void GammaCursorPositionChanged( int value ); /** */ void GammaValueChanged( double value ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** * \brief Connect signals of color-band dynamics child widget to * slots of this widget. * * \param child Color-band dynamics child widget. * \param channel RGBAW channel setup of child widget. */ void ConnectChild( ColorBandDynamicsWidget* child, RgbwChannel channel ); // // Private attributes. private: /** */ static const char* COLOR_BAND_DYNAMICS_WIDGET_NAMES[]; /** * uic generated. */ Ui::ColorDynamicsWidget* m_UI; /** */ QDoubleValidator* m_NoDataValidator; /** */ bool m_IsGrayscaleActivated; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void on_noDataLineEdit_textChanged( const QString& text ); /** */ void on_noDataCheckBox_toggled( bool enabled ); /** */ void on_noDataButton_toggled( bool checked ); /** */ void on_gammaSlider_valueChanged( int gamma ); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ inline const ColorBandDynamicsWidget* ColorDynamicsWidget ::GetChannel( RgbwChannel channel ) const { return findChild< const ColorBandDynamicsWidget* >( ColorDynamicsWidget::COLOR_BAND_DYNAMICS_WIDGET_NAMES[ channel ] ); } /*****************************************************************************/ inline ColorBandDynamicsWidget* ColorDynamicsWidget ::GetChannel( RgbwChannel channel ) { return findChild< ColorBandDynamicsWidget* >( ColorDynamicsWidget::COLOR_BAND_DYNAMICS_WIDGET_NAMES[ channel ] ); } /*****************************************************************************/ inline bool ColorDynamicsWidget ::IsGrayscaleActivated() const { return m_IsGrayscaleActivated; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' #endif // mvdColorDynamicsWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdColorSetupController.h000066400000000000000000000132741301006202600311250ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdColorSetupController_h #define mvdColorSetupController_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" // #include "mvdAbstractModelController.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class ColorSetupWidget; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ColorSetupController * * \ingroup OTBMonteverdiGUI * * \brief Color-setup widget controller for VectorImageModel objects. */ class OTBMonteverdiGUI_EXPORT ColorSetupController : public AbstractModelController { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor. * * \param widget Controlled widget. * \param parent Parent QObject of this QObject. */ ColorSetupController( ColorSetupWidget* widget, QObject* p =NULL ); /** * \brief Destructor. */ ~ColorSetupController() ITK_OVERRIDE; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** * \brief Signal emitted when the band-index of a RGB channel has * been changed. This signal is used to forward events to other * controllers such as ColorDynamicsController. * * \param channel The RGB channel for which the band-index has changed. * \param band The new band-index of the RGB channel. */ void RgbChannelIndexChanged( RgbwChannel channel, int band ); /** * \brief Signal emitted when the band-index of a white (gray) * channel has been changed. This signal is used to forward events * to other controllers such as ColorDynamicsController. * * \param band The new band-index of the white (gray) channel. */ void GrayChannelIndexChanged( int band ); /** * \brief Signal emitted when the grayscale-mode activation-state * has changed. This signal is used to forward events to other * controllers such as ColorDynamicsController. * * \param activated The new grayscale-mode activation-state. */ void GrayscaleActivated( bool activated ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** * \brief Reset current band-index to default values for given RGB * channels. * * \param channels Given channels for which to reset current-band * index. \see RgbBound() for valid values. */ void ResetIndices( RgbwChannel channels ); /** */ void ResetAlpha(); // // AbstractModelController methods. void Connect( AbstractModel* ) ITK_OVERRIDE; void ClearWidget() ITK_OVERRIDE; void virtual_ResetWidget( bool ) ITK_OVERRIDE; void Disconnect( AbstractModel* ) ITK_OVERRIDE; // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** * \brief Slot called when the current index of a RGB channel of the * controlled widget has changed. * * \param channel The RGB video-channel for which the current * band-index has changed. * * \param index The new band-index of the RGB video-channel. */ void OnCurrentRgbIndexChanged( RgbwChannel channel, int index ); /** * \brief Slot called when the current index of the white (gray) * channel of the controlled widget has changed. * * \param index The new band-index of the white (gray) * video-channel. */ void OnCurrentGrayIndexChanged( int index ); /** * \brief Slot called when the grayscale-mode has been * activated/deactivated. * * \param activated The new activation state. */ void OnGrayscaleActivated( bool activated ); /** */ void OnAlphaValueChanged( double ); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdColorSetupController_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdColorSetupWidget.h000066400000000000000000000171721301006202600302260ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdColorSetupWidget_h #define mvdColorSetupWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class ColorSetupWidget; } /** * \class ColorSetupWidget * * \ingroup OTBMonteverdiGUI */ class OTBMonteverdiGUI_EXPORT ColorSetupWidget : public QWidget { Q_OBJECT; /** * \brief The list of (user) component names. * \sa ColorSetupWidget::m_Components member. */ Q_PROPERTY( QStringList components READ GetComponents WRITE SetComponents ); // // Public types. public: // // Public methods. public: /** \brief Constructor. */ ColorSetupWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~ColorSetupWidget() ITK_OVERRIDE; /** * \brief Set the component-name list. * * This sets up the content of the red, green and blue combo * boxes. Each component name is prepended with its index * (e.g. ': NAME'), if non-empty. Otherwise, 'BAND ' is * inserted into the combo-box. * * Calling SetComponents() resets the current-index of each * combo-box to the first entry of the list, which causes the * CurrentIndexChanged() signal to be emitted for each component. * * Example: The user { "Red", "Green", "Blue", "" } component-name * list will be displayed as the { "0: Red", "1: Green", "2: Blue", * "BAND 3" } combo-box list. * * \param component component-name list. */ void SetComponents( const QStringList& component ); /** * \brief Get the component-name list. * * Example: The user { "Red", "Green", "Blue", "" } list as it were * set and not the displayed { "0: Red", "1: Green", "2: Blue", * "BAND 3" } combo-box list. * * \return the component-name list. */ inline QStringList GetComponents() const { return m_Components; } /** * \brief Set the current (selected) index of a RGB video channel. * * Calling SetCurrentRgbIndex() let the CurrentRgbIndexChanged() * signal to be emitted. * * \param channel The video channel for which to set the current * index. * \param index The index in the component-name list. * * Example: If the { "Red", "Green", "Blue", "" } component-name * list has been set, index 1 set "1: Green" as the current select * combo-box item. */ void SetCurrentRgbIndex( RgbwChannel channel, int index ); /** * \return the current (selected) index of a RGB video-channel in * the component-name list. */ int GetCurrentRgbIndex( RgbwChannel channel ) const; /** * \brief Enable/disable the grayscale-mode check-box. * * \param enabled true to enable the grayscale-mode check-box. */ void SetGrayscaleEnabled( bool enabled ); /** * \brief Activate/deactivate the gray-scale mode. * * \param activated true to enable the grayscale-model. */ void SetGrayscaleActivated( bool activated ); /** * \brief Set the current (selected) index of the white (gray) * channel. * * Calling SetCurrentGrayIndex() let the CurrentGrayIndexChanged() * signal to be emitted. * * \param index The index in the component-name list. */ void SetCurrentGrayIndex( int index ); /** * \return the current (selected) index of the white (gray) channel * in the component-name list. */ int GetCurrentGrayIndex() const; /** */ void SetAlpha( double ); /** */ double GetAlpha() const; // // SIGNALS. signals: /** * \brief Signal emitted when the current-index of a RGB * video-channel has been modified. * * \param channel The RGB video-channel which has been modified. * \param index The curren-index in the component-list. */ void CurrentRgbIndexChanged( RgbwChannel channel, int index ); /** * \brief Signal emitted when the current-index of the white (gray) * channel has been modified. * * \param index The curren-index in the component-list. */ void CurrentGrayIndexChanged( int index ); /** * \brief Signal emitted when the activation-state of the * grayscale-mode has been modified. * * \param activated The new activation-state. */ void GrayscaleActivated( bool activated ); /** */ void AlphaValueChanged( double ); // // Protected methods. protected: // // Protected attributes. protected: // // Private methods. private: /** */ double ToAlpha( int ) const; /** */ int FromAlpha( double ) const; // // Private attributes. private: /** * \brief uic generated. */ Ui::ColorSetupWidget* m_UI; /** * \brief The list of (user) component names. * \sa ColorSetupWidget::component Q_PROPERTY. */ QStringList m_Components; // // SLOTS. private slots: /** * \brief Slot called when the current-index of the red * video-channel has been modified. * * \param index The new current-index of the red combo-box. */ inline void on_rComboBox_currentIndexChanged( int index ) { emit CurrentRgbIndexChanged( RGBW_CHANNEL_RED, index ); } /** * \brief Slot called when the current-index of the green * video-channel has been modified. * * \param index The new current-index of the green combo-box. */ inline void on_gComboBox_currentIndexChanged( int index ) { emit CurrentRgbIndexChanged( RGBW_CHANNEL_GREEN, index ); } /** * \brief Slot called when the current-index of the blue * video-channel has been modified. * * \param index The new current-index of the blue combo-box. */ inline void on_bComboBox_currentIndexChanged( int index ) { emit CurrentRgbIndexChanged( RGBW_CHANNEL_BLUE, index ); } /** * \brief Slot called when the current-index of the white (gray) * channel has been modified. * * \param index The new current-index of the white (gray) combo-box. */ inline void on_wComboBox_currentIndexChanged( int index ) { emit CurrentGrayIndexChanged( index ); } /** * \brief Slot called when the grayscale-mode is activated/deactivated. * * \param activated The new activation-state of the grayscale-mode. */ inline void on_wCheckBox_toggled( bool activated ) { emit GrayscaleActivated( activated ); } /** */ void on_alphaSlider_valueChanged( int ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdColorSetupWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdDoubleValidator.h000066400000000000000000000072501301006202600300370ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdDoubleValidator_h #define mvdDoubleValidator_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class DoubleValidator * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OTBMonteverdiGUI_EXPORT DoubleValidator : public QDoubleValidator { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ DoubleValidator( QObject* p =NULL ); /** * \brief Constructor. */ DoubleValidator( double bottom, double top, int decimals, QObject *p = 0 ); /** \brief Destructor. */ ~DoubleValidator() ITK_OVERRIDE; // // QDoubleValidator overloads. void fixup( QString& input ) const ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdDoubleValidator_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdDropLineEdit.h000066400000000000000000000070601301006202600273000ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdDropLineEdit_h #define mvdDropLineEdit_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { // class DropLineEdit; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class DropLineEdit * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT DropLineEdit : public QLineEdit { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ DropLineEdit( QWidget* p =0 ); /** \brief Constructor. */ DropLineEdit( const QString& contents, QWidget* p =0 ); /** \brief Destructor. */ ~DropLineEdit() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: void dragEnterEvent( QDragEnterEvent* event ) ITK_OVERRIDE; void dragMoveEvent( QDragMoveEvent* event ) ITK_OVERRIDE; void dropEvent( QDropEvent* event ) ITK_OVERRIDE; /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: // // Private attributes. private: /** * \brief uic generated. */ // Ui::DropLineEdit* m_UI; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdDropLineEdit_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdFilenameDragAndDropEventFilter.h000066400000000000000000000101701301006202600327100ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdFilenameDragAndDropEventFilter_h #define mvdFilenameDragAndDropEventFilter_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractDragAndDropEventFilter.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class FilenameDragAndDropEventFilter * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT FilenameDragAndDropEventFilter : public AbstractDragAndDropEventFilter { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ FilenameDragAndDropEventFilter( QObject* p =NULL ); /** \brief Destructor. */ ~FilenameDragAndDropEventFilter() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void FilenameDropped( const QString& filename ); /** */ void FilenamesDropped( const QStringList & ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragEnterEvent */ bool DragEnterEvent( QObject* object, QDragEnterEvent* event ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragLeaveEvent */ bool DragLeaveEvent( QObject* object, QDragLeaveEvent* event ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragMoveEvent */ bool DragMoveEvent( QObject* object, QDragMoveEvent* event ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dropEvent */ bool DropEvent( QObject* object, QDropEvent* event ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdFilenameDragAndDropEventFilter_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdGui.h000066400000000000000000000072761301006202600255130ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdGui_h #define mvdGui_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } // // Internal classes pre-declaration. namespace mvd { } // end namespace 'mvd' /*****************************************************************************/ /* CONSTANTS SECTION */ /** */ namespace mvd { /** */ extern const int MOUSE_WHEEL_STEP_DEGREES; /** */ extern const int MOUSE_WHEEL_STEP_FACTOR; } // end of namespace 'mvd'. /*****************************************************************************/ /* TYPE DEFINITION SECTION */ namespace mvd { /** */ enum Resolution { RESOLUTION_NONE = -1, // RESOLUTION_NEAREST = 0, RESOLUTION_LOWER, RESOLUTION_UPPER, // RESOLUTION_COUNT, // RESOLUTION_DEFAULT = RESOLUTION_NEAREST, }; /** * Constant naming effect values. */ OTBMonteverdiGUI_EXPORT extern char const * const RESOLUTION_NAMES[ RESOLUTION_COUNT ]; /** */ enum TileSize { TILE_SIZE_NONE = -1, // TILE_SIZE_64 = 0, TILE_SIZE_128, TILE_SIZE_256, TILE_SIZE_512, // TILE_SIZE_COUNT, // TILE_SIZE_DEFAULT = TILE_SIZE_256, }; /** * Constant naming effect values. */ OTBMonteverdiGUI_EXPORT extern char const * const TILE_SIZE_NAMES[ TILE_SIZE_COUNT ]; /** */ OTBMonteverdiGUI_EXPORT extern int TILE_SIZE_VALUE[ TILE_SIZE_COUNT ]; /** */ enum ZoomType { ZOOM_TYPE_NONE = -1, // ZOOM_TYPE_EXTENT, ZOOM_TYPE_FULL, ZOOM_TYPE_LAYER, // ZOOM_TYPE_COUNT }; } // End of namespace 'mvd'. /*****************************************************************************/ /* COMMON DECLARATION SECTION */ namespace mvd { /** */ OTBMonteverdiGUI_EXPORT void AddItemsInto( QComboBox * comboBox, const char * context, char const * const names[], size_t count ); /** */ QMessageBox & CustomizeMessageBox( QMessageBox & messageBox, QWidget * widget ); } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd'. #endif // mvdGui_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdHistogramController.h000066400000000000000000000111251301006202600307540ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdHistogramController_h #define mvdHistogramController_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" // #include "mvdAbstractModelController.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class HistogramWidget; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class HistogramController * * \ingroup OTBMonteverdiGUI * * \brief Color-setup widget controller for VectorImageModel objects. */ class OTBMonteverdiGUI_EXPORT HistogramController : public AbstractModelController { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor. * * \param widget Controlled widget. * \param parent Parent QObject of this QObject. */ HistogramController( HistogramWidget* widget, QObject* p =NULL ); /** * \brief Destructor. */ ~HistogramController() ITK_OVERRIDE; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** * \brief */ void ResetWidget( RgbwChannel channel ); // // AbstractModelController methods. void Connect( AbstractModel* ) ITK_OVERRIDE; void ClearWidget() ITK_OVERRIDE; void virtual_ResetWidget( bool = false ) ITK_OVERRIDE; void Disconnect( AbstractModel* ) ITK_OVERRIDE; // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** * \brief Slot called when the band-index of a RGB channel has * changed. * * \param channel The RGB channel for which the band-index has changed. * \param band The new band-index of the RGB channel. */ void OnRgbChannelIndexChanged( RgbwChannel channel, int band ); /** * \brief Slot called when the band-index of the white (gray) * channel has changed. * * \param band The new band-index of the white (gray) channel. */ void OnGrayChannelIndexChanged( int band ); /** * \brief Slot called when the activation-state of the * grayscale-mode has changed. * * \param activated The new grayscale-mode activation state. */ void OnGrayscaleActivated( bool activated ); /** * \brief */ void OnLowIntensityChanged( RgbwChannel channel, double value, bool refresh ); /** * \brief */ void OnHighIntensityChanged( RgbwChannel channel, double value, bool refresh ); /** */ void OnHistogramRefreshed(); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdHistogramController_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdHistogramPlotPicker.h000066400000000000000000000112001301006202600306770ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdHistogramPlotPicker_h #define mvdHistogramPlotPicker_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } class QwtPlotCanvas; class QwtPlotCurve; namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class HistogramPlotPicker * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT HistogramPlotPicker : public QwtPlotPicker { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types and constants. public: /** * \brief */ typedef std::vector< QwtPlotCurve* > PlotCurveVector; // // Public methods. public: /** \brief Constructor. */ HistogramPlotPicker( const PlotCurveVector& curves, QwtPlotCanvas* canvas ); /** \brief Constructor. */ HistogramPlotPicker( const PlotCurveVector& curves, int xAxis, int yAxis, QwtPlotCanvas* canvas ); /** \brief Constructor. */ HistogramPlotPicker( const PlotCurveVector& curves, int xAxis, int yAxis, DisplayMode trackerMode, QwtPlotCanvas* canvas ); /** \brief Destructor. */ ~HistogramPlotPicker() ITK_OVERRIDE; /** */ void SetRubberBandPen( RgbwChannel channel, const QPen& pen ); /** */ void SetGrayscaleActivated( bool activated ); // // QwtPlotPicker methods. void drawRubberBand( QPainter* painter ) const ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // QwtPlotPicker methods. using QwtPlotPicker::trackerText; QwtText trackerText( const QwtDoublePoint & ) const ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ double Find( const QwtPlotCurve* curve, double x ) const; /** */ CountType Find( const QwtPlotCurve* curve, double x, double& xmin, double& xmax, double& y ) const; // // Private attributes. private: /** * \brief */ static const CountType CURVE_COUNT = 4; /** * \brief */ PlotCurveVector m_PlotCurves; /** */ QPen m_RubberBandPens[ CURVE_COUNT ]; /** */ bool m_IsGrayscaleActivated : 1; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdHistogramPlotPicker_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdHistogramWidget.h000066400000000000000000000147521301006202600300650ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdHistogramWidget_h #define mvdHistogramWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // Qwt includes. #include #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } class QwtPlot; class QwtPlotGrid; class QwtPlotCurve; class QwtPlotMagnifier; class QwtPlotMarker; class QwtPlotPanner; // class QwtPlotZoomer; namespace mvd { class HistogramPlotPicker; // // Internal classes pre-declaration. namespace Ui { class HistogramWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class HistogramWidget * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT HistogramWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public constants // // Public methods. public: /** \brief Constructor. */ HistogramWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~HistogramWidget() ITK_OVERRIDE; /** * \brief */ void SetBounds( RgbwChannel channel, double xMin, double xMax, double yMin, double yMax ); /** * \brief */ void SetData( RgbwChannel channel, double * const x, double * const y, size_t size, double xMin, double yMin, double xMax, double yMax ); /** */ void SetLowMarker( RgbwChannel channel, double low ); /** */ void SetHighMarker( RgbwChannel channel, double high ); /** * \brief */ void SetGrayscaleActivated( bool activated ); /** * \brief */ // bool IsGrayscaleActivated() const; /** * \brief */ void RefreshScale( bool iqr ); /** */ void Clear(); /** */ void SetPrecision( double ); /** */ double GetPrecision() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /** * \brief */ void Replot(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: struct Bounds { Bounds( double xMin =0.0, double xMax =1.0, double yMin =0.0, double yMax =1.0, double qMin =0.0, double qMax =1.0 ) : m_XMin( xMin ), m_XMax( xMax ), m_YMin( yMin ), m_YMax( yMax ), m_QMin( qMin ), m_QMax( qMax ) { } double m_XMin; double m_XMax; double m_YMin; double m_YMax; double m_QMin; double m_QMax; }; // // Private methods. private: /** */ void UpdateCurvesVisibility( CountType index ); // // Private attributes. private: /** * \brief */ static const CountType CURVE_COUNT = 4; /** */ static const char* CURVE_NAMES[ HistogramWidget::CURVE_COUNT ]; /** */ static const QColor CURVE_COLORS[ HistogramWidget::CURVE_COUNT ]; /** */ static const QColor BAR_COLORS[ HistogramWidget::CURVE_COUNT ]; /** */ static const QColor MARKER_COLORS[ HistogramWidget::CURVE_COUNT ]; /** */ static const QColor RUBBER_BAND_COLORS[ HistogramWidget::CURVE_COUNT ]; /** * \brief uic generated. */ Ui::HistogramWidget* m_UI; /** */ QwtPlotGrid* m_PlotGrid; /** */ HistogramPlotPicker* m_PlotPicker; /** */ // QwtPlotZoomer* m_PlotZoomer; /** */ QwtPlotMagnifier* m_PlotMagnifier; /** */ QwtPlotPanner* m_PlotPanner; /** * \brief */ QwtPlotCurve* m_PlotCurves[ CURVE_COUNT ]; /** */ QwtPlotMarker* m_LowPlotMarkers[ CURVE_COUNT ]; /** */ QwtPlotMarker* m_HighPlotMarkers[ CURVE_COUNT ]; /** */ Bounds m_Bounds[ CURVE_COUNT ]; /** */ double m_Precision; /** */ bool m_IsGrayscaleActivated; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void on_zoom1Button_clicked(); /** */ void on_zoomQButton_clicked(); /** */ void on_channelComboBox_currentIndexChanged( int index ); /** */ void OnAppended( const QwtDoublePoint& pos ); void OnAppended( const QPoint& pos ); void OnChanged( const QwtPolygon& pa ); void OnMoved( const QwtDoublePoint&pos ); void OnMoved( const QPoint& pos ); void OnSelected( const QwtDoublePoint& pos ); void OnSelected( const QwtDoubleRect& rect ); void OnSelected( const QwtPolygon& pa ); void OnSelected( const QwtArray< QwtDoublePoint >& pa ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdHistogramWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdI18nApplication.h000066400000000000000000000106721301006202600276640ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdI18nApplication_h #define mvdI18nApplication_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdI18nCoreApplication.h" // // Macros. /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // Classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class I18nApplication * * \ingroup OTBMonteverdiGUI * * \brief The MVD2 application (which is different from * QApplication). * * I18nApplication do not derive from QApplication to prevent a dread * diamong multiple inheritance scheme which could not be resolved * using virtual inheritance (because Qt is not designed for). * * * \see I18nCoreApplication. */ class OTBMonteverdiGUI_EXPORT I18nApplication : public I18nCoreApplication { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor. * * \param qtApp The parent Qt application of this MVD2 application. */ I18nApplication( QApplication* qtApp ); /** \brief Destructor. */ ~I18nApplication() ITK_OVERRIDE; // // APPLICATION SINGLETON. // /** * \brief Get the singleton instance of application as a * I18Application pointer. * * \return The singleton instance of I18nApplication. */ inline static I18nApplication* Instance(); /** * \brief Get the singleton constant instance of application as a * I18Application pointer. * * \return The singleton constant instance of I18nApplication. */ inline static const I18nApplication* ConstInstance(); // // Public attributes. public: /*-[ PUBLIC SLOTS SECTION ]-----------------------------------------------**/ public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: void virtual_InitializeCore() ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // SLOTS private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ I18nApplication* I18nApplication ::Instance() { return I18nCoreApplication::Instance< I18nApplication >(); } /*****************************************************************************/ const I18nApplication* I18nApplication ::ConstInstance() { return I18nCoreApplication::ConstInstance< I18nApplication >(); } } // end namespace 'mvd' #endif // I18nApplication_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdI18nMainWindow.h000066400000000000000000000204671301006202600275000ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdI18nMainWindow_h #define mvdI18nMainWindow_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External class pre-declaration. namespace { } namespace mvd { // // Internal class pre-declaration. class AbstractModel; class AbstractModelController; class AbstractWorker; class DatasetModel; class VectorImageModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class I18nMainWindow * * \ingroup OTBMonteverdiGUI * * \brief Main-window widget base for the i18n application. */ class OTBMonteverdiGUI_EXPORT I18nMainWindow : public QMainWindow { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: enum DockLayout { DOCK_LAYOUT_NONE = 0, DOCK_LAYOUT_FLOATING = 1, DOCK_LAYOUT_SCROLLABLE = 2, }; typedef QFlags< DockLayout > DockLayoutFlags; // // Public methods. public: /** \brief Destructor. */ ~I18nMainWindow() ITK_OVERRIDE; /** */ void Initialize(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** \brief Constructor. */ I18nMainWindow( QWidget* Parent =0, Qt::WindowFlags flags =0 ); /** */ QDockWidget* AddWidgetToDock( QWidget* widget, const QString& dockName, const QString& dockTitle, Qt::DockWidgetArea dockArea, DockLayoutFlags flags = DOCK_LAYOUT_NONE ); /** */ template< typename TWidget, typename TDockWidget > inline TDockWidget* AddDockWidget( const QString& dockName, const QString& dockTitle, Qt::DockWidgetArea dockArea, DockLayoutFlags flags = DOCK_LAYOUT_NONE ); /** */ template< typename TWidget, typename TController, typename TDockWidget > inline TDockWidget* AddDockWidget( const QString& dockName, const QString& dockTitle, Qt::DockWidgetArea dockArea, DockLayoutFlags flags = DOCK_LAYOUT_NONE ); /** */ const AbstractModelController * GetController( const QDockWidget * ) const; /** */ AbstractModelController * GetController( const QDockWidget * ); /** * \brief Assign model to the controller which is child of given * dock-widget. * * \param dock The dock-widget which is parent of the controller to * assign model to. * * \param model The model to assign to the controller. */ inline void SetControllerModel( QDockWidget* dock, AbstractModel* model ); /** */ VectorImageModel * ImportImage( const QString & filename, int width, int height ); /** */ bool BuildGDALOverviews( const QStringList & filenames ); /** */ void SaveLayout( int version ) const; /** */ bool RestoreLayout( int version ); // // QMainWindow methods. void closeEvent( QCloseEvent* event ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PROTECTED SLOTS SECTION ]---------------------------------------------*/ // // Protected slots. protected slots: /** */ virtual void OnAboutToChangeModel( const AbstractModel* ) =0; /** */ virtual void OnModelChanged( AbstractModel* ) =0; /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private nested classes. private: // // Private methods. private: /** */ QObject * Import( AbstractWorker * ); /** */ virtual void virtual_SetupUI() =0; /** */ virtual void virtual_ConnectUI() =0; /** */ virtual void virtual_InitializeUI(); /** */ // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Private slots. private slots: /** * \brief Qt auto-connected slot which is called when File/Quit menu * action is activated. */ void on_action_Quit_triggered(); /** * \brief Qt auto-connected slot which is called when Help/About * menu action is activated. */ virtual void on_action_About_triggered(); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractModelController.h" namespace mvd { /*****************************************************************************/ inline const AbstractModelController * I18nMainWindow ::GetController( const QDockWidget * dock ) const { assert( dock!=NULL ); return dock->findChild< const AbstractModelController * >(); } /*****************************************************************************/ inline AbstractModelController * I18nMainWindow ::GetController( const QDockWidget * dock ) { assert( dock!=NULL ); return dock->findChild< AbstractModelController * >(); } /*****************************************************************************/ inline void I18nMainWindow ::SetControllerModel( QDockWidget* dock, AbstractModel* model ) { assert( dock ); AbstractModelController* controller = dock->findChild< AbstractModelController* >(); assert( controller!=NULL ); controller->SetModel( model ); } /*****************************************************************************/ template< typename TWidget, typename TDockWidget > inline TDockWidget* I18nMainWindow ::AddDockWidget( const QString & dockName, const QString & dockTitle, Qt::DockWidgetArea dockArea, DockLayoutFlags flags ) { TWidget * widget = new TWidget( this ); TDockWidget * dockWidget = AddWidgetToDock( widget, dockName, dockTitle, dockArea, flags ); return dockWidget; } /*****************************************************************************/ template< typename TWidget, typename TController, typename TDockWidget > inline TDockWidget* I18nMainWindow ::AddDockWidget( const QString & dockName, const QString & dockTitle, Qt::DockWidgetArea dockArea, DockLayoutFlags flags ) { TWidget * widget = new TWidget( this ); QWidget * pannel = widget; if( flags.testFlag( DOCK_LAYOUT_SCROLLABLE ) ) { QScrollArea * scrollArea = new QScrollArea( this ); scrollArea->setWidgetResizable( true ); scrollArea->setWidget( widget ); pannel = scrollArea; } TDockWidget * dockWidget = AddWidgetToDock( pannel, dockName, dockTitle, dockArea, flags ); new TController( // wraps: widget, // as chid of: dockWidget ); return dockWidget; } } // end namespace 'mvd' #endif // I18nMainWindow_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdImageViewManipulator.h000066400000000000000000000240341301006202600310470ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImageViewManipulator_h #define mvdImageViewManipulator_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbViewSettings.h" #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" #include "mvdAbstractImageViewManipulator.h" #include "mvdImageViewRenderer.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImageViewManipulator * * \ingroup OTBMonteverdiGUI * * \brief TODO. */ class OTBMonteverdiGUI_EXPORT ImageViewManipulator : public AbstractImageViewManipulator { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Constants public: /** */ static const double DEFAULT_DELTA; /** */ static const int DEFAULT_GRANULARITY; /** */ static const int DEFAULT_ALPHA_GRANULARITY; /** */ static const double DEFAULT_DYNAMICS_SHIFT_GRANULARITY; /** */ static const int DEFAULT_SCROLL_GRANULARITY; /** */ static const int DEFAULT_ZOOM_GRANULARITY; // // Public methods. public: /** \brief Constructor. */ #if USE_VIEW_SETTINGS_SIDE_EFFECT ImageViewManipulator( const otb::ViewSettings::Pointer& viewSettings, QObject* p =NULL ); #else // USE_VIEW_SETTINGS_SIDE_EFFECT ImageViewManipulator( QObject* p =NULL ); #endif // USE_VIEW_SETTINGS_SIDE_EFFECT /** \brief Destructor. */ ~ImageViewManipulator() ITK_OVERRIDE; // // AbstractImageViewManipulator overloads. // // // Accessors. void SetViewportSize( int width, int height ) ITK_OVERRIDE; SizeType GetViewportSize() const ITK_OVERRIDE; void SetOrigin( const PointType& origin ) ITK_OVERRIDE; PointType GetOrigin() const ITK_OVERRIDE; void SetSpacing( const SpacingType& spacing ) ITK_OVERRIDE; SpacingType GetSpacing() const ITK_OVERRIDE; void SetNativeSpacing( const SpacingType& ) ITK_OVERRIDE; void SetWkt( const std::string& wkt ) ITK_OVERRIDE; void SetKeywordList( const DefaultImageType::ImageKeywordlistType& kwl ) ITK_OVERRIDE; PointType GetCenter() const ITK_OVERRIDE; ZoomType GetFixedZoomType() const ITK_OVERRIDE; // // Controls. void SetupRenderingContext( AbstractImageViewRenderer::RenderingContext * const ) const ITK_OVERRIDE; void ZoomIn() ITK_OVERRIDE; void ZoomOut() ITK_OVERRIDE; const PointType& Transform( PointType&, const QPoint& ) const ITK_OVERRIDE; void ResetViewport() ITK_OVERRIDE; // // Events. void MouseMoveEvent( QMouseEvent* event ) ITK_OVERRIDE; void MousePressEvent( QMouseEvent* event ) ITK_OVERRIDE; void MouseReleaseEvent( QMouseEvent* event ) ITK_OVERRIDE; void MouseDoubleClickEvent( QMouseEvent * ) ITK_OVERRIDE; void WheelEvent( QWheelEvent* event) ITK_OVERRIDE; void ResizeEvent( QResizeEvent* event ) ITK_OVERRIDE; void KeyPressEvent( QKeyEvent* event ) ITK_OVERRIDE; void KeyReleaseEvent( QKeyEvent* event ) ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]-----------------------------------------------**/ // // Public SLOTS. public slots: // // AbstractImageViewManipulator overloads. void CenterOn( const PointType& point ) ITK_OVERRIDE; void ZoomTo( double scale ) ITK_OVERRIDE; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void RaiseLayerRequested(); /** */ void LowerLayerRequested(); /** */ void LayerToTopRequested(); /** */ void LayerToBottomRequested(); /** */ void SelectNextLayerRequested(); /** */ void SelectPreviousLayerRequested(); /** */ void SelectFirstLayerRequested(); /** */ void SelectLastLayerRequested(); /** */ void DeleteAllRequested(); /** */ // TODO: Rename signal into DeleteLayerRequested(). void DeleteSelectedRequested(); /** */ void ToggleLayerVisibilityRequested( bool ); /** */ void RotateLayersRequested( int ); /** */ void ZoomToFullResolutionRequested(); /** */ void ZoomToLayerExtentRequested(); /** */ void ZoomToFullExtentRequested(); /** */ void ShiftAlphaRequested( double ); /** */ void UpdateGammaRequested( double ); /** */ void ResizeShaderRequested( double ); /** */ void ReparamShaderRequested( double ); /** */ void ShiftDynamicsRequested( double ); /** */ void ScaleDynamicsRequested( double ); /** */ void ResetQuantilesRequested( bool ); /** */ void ShaderEffectRequested( Effect ); /** */ void ApplyAllRequested(); /** */ void SetReferenceRequested(); /** */ void TakeScreenshotRequested( bool isQuickMode ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** */ static PointType Translate( const QPoint& vector, const PointType& origin, const SpacingType& spacing ); // // Protected attributes. protected: /** */ QPoint m_MousePressPosition; /** */ otb::ViewSettings::Pointer m_ViewSettings; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Private types. private: // // Private methods. private: /** */ template< typename T1, typename T2, typename T3, typename T4 > inline static double Factor( T1 wheel, T2 degrees, T3 delta, T4 granularity ); /** */ template< typename T1, typename T2 > inline static double Factor( T1 wheel, T2 degrees ); /** */ void Translate( const QPoint& vector ); /** */ void Scale( const QPoint& center, int degrees, PointType* centerPoint =NULL ); /** */ // inline void SetRenderMode( const QInputEvent* event ); /** */ inline void SetFastRenderMode( bool isEnabled ); // // Private attributes. private: /** */ QTimer * m_Timer; /** */ SpacingType m_NativeSpacing; /** */ otb::ViewSettings::PointType m_MousePressOrigin; /** */ AbstractImageViewRenderer::RenderingContext::RenderMode m_RenderMode; /** */ double m_ZoomFactor; /** */ int m_AlphaGranularity; /** */ double m_DynamicsShiftGranularity; /** */ int m_ScrollGranularity; /** */ int m_ZoomGranularity; /** */ bool m_IsMouseDragging : 1; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void OnTimeout(); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ template< typename T1, typename T2, typename T3, typename T4 > inline double ImageViewManipulator ::Factor( T1 wheel, T2 degrees, T3 delta, T4 granularity ) { // qDebug() << "wheel:" << wheel; // qDebug() << "degrees:" << degrees; // qDebug() << "delta:" << delta; // qDebug() << "granularity:" << granularity; if( abs( granularity )<=std::numeric_limits< T1 >::min() ) granularity = 1; return pow( ( 1.0 + static_cast< double >( delta ) ), static_cast< double >( wheel ) / ( static_cast< double >( granularity ) * static_cast< double >( degrees ) ) ); } /*****************************************************************************/ template< typename T1, typename T2 > inline double ImageViewManipulator ::Factor( T1 wheel, T2 degrees ) { return ImageViewManipulator::Factor( wheel, degrees, ImageViewManipulator::DEFAULT_DELTA, ImageViewManipulator::DEFAULT_GRANULARITY ); } /*****************************************************************************/ /* inline void ImageViewManipulator ::SetRenderMode( const QInputEvent* event ) { m_RenderMode = ( event!=NULL && ( event->modifiers() & Qt::ControlModifier )==Qt::ControlModifier ) ? AbstractImageViewRenderer::RenderingContext::RENDER_MODE_LIGHT : AbstractImageViewRenderer::RenderingContext::RENDER_MODE_FULL; qDebug() << "Render-mode:" << m_RenderMode; } */ /*****************************************************************************/ inline void ImageViewManipulator ::SetFastRenderMode( bool isEnabled ) { m_RenderMode = isEnabled ? AbstractImageViewRenderer::RenderingContext::RENDER_MODE_LIGHT : AbstractImageViewRenderer::RenderingContext::RENDER_MODE_FULL; // qDebug() << "Render-mode:" << m_RenderMode; } } // end namespace 'mvd' #endif // mvdImageViewManipulator_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdImageViewRenderer.h000066400000000000000000000207661301006202600303320ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImageViewRenderer_h #define mvdImageViewRenderer_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // #define USE_VIEW_SETTINGS_SIDE_EFFECT 1 // #define USE_REMOTE_DESKTOP_DISABLED_RENDERING ((defined( OTB_DEBUG ) && 0) || 0) // #define DISABLE_QUICKLOOK_VIEW ( ( defined( OTB_DEBUG ) && 0 ) || 0 ) /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGlActor.h" #include "otbGlView.h" #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractImageViewRenderer.h" #include "mvdGui.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace otb { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImageViewRenderer * * \ingroup OTBMonteverdiGUI */ class OTBMonteverdiGUI_EXPORT ImageViewRenderer : public AbstractImageViewRenderer { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: /** */ struct RenderingContext : public AbstractImageViewRenderer::RenderingContext { /** */ RenderingContext(); /** */ ~RenderingContext() ITK_OVERRIDE; /** */ Resolution m_Resolution; /** */ int m_TileSize; #if USE_VIEW_SETTINGS_SIDE_EFFECT #else // USE_VIEW_SETTINGS_SIDE_EFFECT /** */ otb::ViewSettings::Pointer m_ViewSettings; #endif // USE_VIEW_SETTINGS_SIDE_EFFECT }; // // Public methods. public: /** Constructor */ ImageViewRenderer( QObject* p = NULL ); /** Destructor */ ~ImageViewRenderer() ITK_OVERRIDE; /** */ bool CheckGLCapabilities( int * ) ITK_OVERRIDE; /** */ inline const otb::ViewSettings::Pointer GetViewSettings() const; /** */ inline otb::ViewSettings::Pointer GetViewSettings(); // // AbstractImageViewRenderer overloads. bool GetLayerDynamics( const StackedLayerModel::KeyType & key, ParametersType & params, bool isGlobal ) const ITK_OVERRIDE; const AbstractLayerModel* GetReferenceModel() const ITK_OVERRIDE; AbstractLayerModel * GetReferenceModel() ITK_OVERRIDE; void GetLayerExtent( const StackedLayerModel::KeyType & key, PointType& origin, PointType& extent ) const ITK_OVERRIDE; void GetReferenceExtent( PointType& origin, PointType& extent ) const ITK_OVERRIDE; void GetViewExtent( PointType& origin, PointType& extent ) const ITK_OVERRIDE; AbstractImageViewRenderer::RenderingContext* NewRenderingContext() const ITK_OVERRIDE; void InitializeGL() ITK_OVERRIDE; void ResizeGL( int width, int height ) ITK_OVERRIDE; void PaintGL( const AbstractImageViewRenderer::RenderingContext* context ) ITK_OVERRIDE; void Pick( const PointType & view, PixelInfo::Vector & pixels ) const ITK_OVERRIDE; void GetResolutions( PixelInfo::Vector & pixels ) const ITK_OVERRIDE; bool TransformToView( PointType & point, const StackedLayerModel::KeyType &, const IndexType &, bool isPhysical ) const ITK_OVERRIDE; void SaveScreenshot( const QString & ) const ITK_OVERRIDE; bool Reproject( PointType & center, SpacingType & spacing, const PointType & vcenter, const SpacingType & vspacing ) const; bool IsEffectsEnabled() const ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // public slots public slots: void UpdatePixelInfo( const QPoint & screen, const PointType & view, const PixelInfo::Vector & pixels ) ITK_OVERRIDE; /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: void ClearProjectionRequired(); void SetProjectionRequired(); void UpdateProjectionRequired(); void ResetViewport(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** */ inline otb::GlActor::Pointer GetReferenceActor(); /** */ template< typename T > inline typename T::Pointer GetReferenceActor(); /** */ template< typename T > inline typename T::ConstPointer GetReferenceActor() const; /** */ virtual void UpdateActors( const AbstractImageViewRenderer::RenderingContext * ); // // Protected attributes. protected: /** */ otb::GlView::Pointer m_GlView; /** */ bool m_EffectsEnabled: 1; /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types private: /** */ typedef std::pair< AbstractLayerModel *, otb::GlActor::Pointer > ModelActorPair; // // Private methods. private: virtual void virtual_ClearProjection() {}; virtual void virtual_SetProjection() {}; virtual void virtual_UpdateProjection() {}; // // AbstractImageViewRenderer overloads. void virtual_UpdateScene() ITK_OVERRIDE; void virtual_RefreshScene() ITK_OVERRIDE; bool virtual_ZoomToRegion( const PointType & origin, const PointType & extent, PointType & center, SpacingType & spacing ) const ITK_OVERRIDE; bool virtual_ZoomToExtent( PointType & center, SpacingType & spacing ) const ITK_OVERRIDE; bool virtual_ZoomToLayer( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing ) const ITK_OVERRIDE; bool virtual_ZoomToFull( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing ) const ITK_OVERRIDE; // // Private attributes. private: /** */ ModelActorPair m_ReferencePair; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // SLOTS. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ inline const otb::ViewSettings::Pointer ImageViewRenderer ::GetViewSettings() const { assert( !m_GlView.IsNull() ); return m_GlView->GetSettings(); } /*****************************************************************************/ inline otb::ViewSettings::Pointer ImageViewRenderer ::GetViewSettings() { assert( !m_GlView.IsNull() ); return m_GlView->GetSettings(); } /*****************************************************************************/ inline otb::GlActor::Pointer ImageViewRenderer ::GetReferenceActor() { return m_ReferencePair.second; } /*****************************************************************************/ template< typename T > inline typename T::Pointer ImageViewRenderer ::GetReferenceActor() { return otb::DynamicCast< T >( m_ReferencePair.second ); } /*****************************************************************************/ template< typename T > inline typename T::ConstPointer ImageViewRenderer ::GetReferenceActor() const { return otb::DynamicCast< const T >( m_ReferencePair.second ); } } // end namespace 'mvd' #endif // mvdImageViewRenderer_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdImageViewWidget.h000066400000000000000000000253641301006202600300060ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImageViewWidget_h #define mvdImageViewWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" #include "mvdAbstractImageViewRenderer.h" #include "mvdGui.h" #define USE_XP_REGION_OPTIM 0 /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractImageViewManipulator; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class ImageViewWidget * * \ingroup OTBMonteverdiGUI * */ class OTBMonteverdiGUI_EXPORT ImageViewWidget : public QGLWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: // // Public methods. public: /** \brief Constructor. */ ImageViewWidget( AbstractImageViewManipulator* manipulator, AbstractImageViewRenderer* renderer, QWidget* p =NULL, const QGLWidget* shareWidget =NULL, Qt::WindowFlags f =0 ); /** \brief Constructor. */ ImageViewWidget( AbstractImageViewManipulator* manipulator, AbstractImageViewRenderer* renderer, QGLContext* context, QWidget* p =NULL, const QGLWidget* shareWidget =NULL, Qt::WindowFlags f =0 ); /** \brief Constructor. */ ImageViewWidget( AbstractImageViewManipulator* manipulator, AbstractImageViewRenderer* renderer, const QGLFormat& format, QWidget* p =NULL, const QGLWidget *shareWidget =NULL, Qt::WindowFlags f =0 ); /** \brief Destructor. */ ~ImageViewWidget() ITK_OVERRIDE; /** */ void SetLayerStack( StackedLayerModel * stackedLayerModel, const PointType& center, double scale ); /** */ void SetLayerStack( StackedLayerModel * ); /** */ inline const StackedLayerModel * GetLayerStack() const; /** */ inline StackedLayerModel * GetLayerStack(); /** * \brief Access the abstract view-manipualtor of this image-view. * * \return A pointer to the abstract view-manipulator of this image-view. */ inline const AbstractImageViewManipulator* GetManipulator() const; /** * \brief Access the abstract model-renderer of this image-view. * * \return A pointer to the abstract model-renderer of this image-view. */ inline const AbstractImageViewRenderer * GetRenderer() const; inline AbstractImageViewRenderer * GetRenderer(); /** */ bool SetBypassRenderingEnabled( bool ); /** */ bool IsBypassRenderingEnabled() const; /** */ void SetPickingEnabled( bool ); /** * This allows to set the fallback behaviour for picking */ void SetPickingDefaultStatus( bool ); /** */ bool IsPickingEnabled() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /** */ void UpdateScene(); /** */ void CenterOnSelected( const IndexType& index ); /** */ void CenterOn( const PointType& center, double scale ); /** */ void SaveScreenshot( bool ); /** */ void ZoomToExtent(); /** */ void ZoomToFullResolution(); /** */ void ZoomToLayerExtent(); /** */ void ZoomIn(); /** */ void ZoomOut(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /** */ void PhysicalCursorPositionChanged( const QPoint & screen, const PointType & view, const PointType & physical, const DefaultImageType::PixelType & ); /** */ void PixelInfoChanged( const QPoint & screen, const PointType & view, const PixelInfo::Vector & pixels ); /** */ void ReferenceActorShaderModeChanged(const std::string & mode); /** */ void CenterRoiRequested( const PointType& center ); /** */ void RoiChanged( const PointType& origin, const SizeType& size, const SpacingType& spacing, const PointType& center ); /** */ void RoiChanged( const PointType& center, double sx, double sy ); /** */ void CenterChanged( const PointType& center ); /** */ void ScaleChanged( double sx, double sy ); /** */ void ModelUpdated(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Qt overloads. void initializeGL() ITK_OVERRIDE; void resizeGL( int widgth, int height ) ITK_OVERRIDE; void paintGL() ITK_OVERRIDE; void mouseMoveEvent( QMouseEvent* event ) ITK_OVERRIDE; void mouseReleaseEvent( QMouseEvent* event ) ITK_OVERRIDE; void mousePressEvent( QMouseEvent* event ) ITK_OVERRIDE; void mouseDoubleClickEvent( QMouseEvent * event ) ITK_OVERRIDE; void wheelEvent( QWheelEvent* event) ITK_OVERRIDE; void keyPressEvent( QKeyEvent* event ) ITK_OVERRIDE; void keyReleaseEvent( QKeyEvent* event ) ITK_OVERRIDE; void resizeEvent( QResizeEvent* event ) ITK_OVERRIDE; // // Protected attributes. protected: /** */ bool m_IsPickingEnabled : 1; bool m_PickingDefaultStatus : 1; /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: /** Construction code (factorizes constructors initializations). */ void Initialize( AbstractImageViewManipulator* manipulator, AbstractImageViewRenderer* renderer ); /** */ void ListGlVersions() const; /** */ void Center( const PointType& point, double sx, double sy ); /** */ void Center( ZoomType zoom =ZOOM_TYPE_NONE ); /** */ void Connect( AbstractLayerModel * ); /** */ void Disconnect( AbstractLayerModel * ); /** */ bool ApplyFixedZoomType(); // // Private attributes. private: /** Event handler pointer */ AbstractImageViewManipulator* m_Manipulator; /** Model Renderer pointer */ AbstractImageViewRenderer* m_Renderer; /** */ #if USE_XP_REGION_OPTIM PointType m_Position; #endif // USE_XP_REGION_OPTIM /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ private slots: /** */ void OnRoiChanged( const PointType&, const SizeType&, const SpacingType&, const PointType& ); /** */ void OnSelectFirstLayerRequested(); /** */ void OnSelectLastLayerRequested(); /** */ void OnSelectPreviousLayerRequested(); /** */ void OnSelectNextLayerRequested(); /** */ void OnLowerLayerRequested(); /** */ void OnRaiseLayerRequested(); /** */ void OnDeleteAllRequested(); /** */ void OnDeleteSelectedRequested(); /** */ void OnReferenceChanged( size_t ); /** */ void OnClearProjectionRequired(); /** */ void OnSetProjectionRequired(); /** */ void OnUpdateProjectionRequired(); /** */ void OnLayerAdded( size_t ); /** */ void OnLayerAboutToBeDeleted( size_t ); /** */ void OnToggleLayerVisibilityRequested( bool ); /** */ void OnResizeShaderRequested( double ); /** */ void OnReparamShaderRequested( double ); /** */ void OnShiftAlphaRequested( double ); /** */ void OnUpdateGammaRequested( double ); /** */ void OnShiftDynamicsRequested( double ); /** */ void OnScaleDynamicsRequested( double ); /** */ void OnResetQuantilesRequested( bool ); /** */ void OnShaderEffectRequested( Effect ); /** */ void OnApplyAllRequested(); /** */ void OnSetReferenceRequested(); /** */ void OnContentChanged(); /** */ void OnContentReset(); /** */ void OnRefreshViewRequested(); /** */ void OnResetViewport(); }; }// end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdHistogramModel.h" #include "mvdAbstractImageViewManipulator.h" namespace mvd { /*****************************************************************************/ inline const AbstractImageViewManipulator* ImageViewWidget ::GetManipulator() const { return m_Manipulator; } /*****************************************************************************/ inline const AbstractImageViewRenderer* ImageViewWidget ::GetRenderer() const { return m_Renderer; } /*****************************************************************************/ inline AbstractImageViewRenderer* ImageViewWidget ::GetRenderer() { return m_Renderer; } /*****************************************************************************/ inline const StackedLayerModel * ImageViewWidget ::GetLayerStack() const { assert( m_Renderer!=NULL ); return m_Renderer->GetLayerStack(); } /*****************************************************************************/ inline StackedLayerModel * ImageViewWidget ::GetLayerStack() { assert( m_Renderer!=NULL ); return m_Renderer->GetLayerStack(); } } // End of namespace 'mvd' #endif // mvdImageViewWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdImportImagesDialog.h000066400000000000000000000106601301006202600304760ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImportImagesDialog_h #define mvdImportImagesDialog_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGDALOverviewsBuilder.h" #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class ImportImagesDialog; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImportImagesDialog * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT ImportImagesDialog : public QDialog { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Private types. public: typedef std::vector< otb::GDALOverviewsBuilder::Pointer > GDALOverviewsBuilderVector; // // Public methods. public: /** \brief Constructor. */ ImportImagesDialog( const QStringList & filename, QWidget * p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~ImportImagesDialog() ITK_OVERRIDE; /** */ int GetEffectiveCount() const; /** */ const GDALOverviewsBuilderVector & GetGDALOverviewsBuilders() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types private: // // Private methods. private: /** */ const otb::GDALOverviewsBuilder::Pointer & GetBuilder( const QModelIndex & ) const; /** */ void SetFilenames( const QStringList & ); /** */ void SetHeaders(); /** */ void UpdateFileSize( size_t row ); // // Private attributes. private: /** * \brief uic generated. */ Ui::ImportImagesDialog * m_UI; /** */ QPushButton * m_IgnoreButton; /** */ GDALOverviewsBuilderVector m_GDALOverviewsBuilders; /** */ int m_EffectiveCount; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: void on_buttonBox_clicked( QAbstractButton * ); void on_pyramidWidget_BaseValueChanged( int ); void on_pyramidWidget_LevelsValueChanged( int ); void on_pyramidWidget_SizeValueChanged( int ); /** */ void OnCurrentChanged( const QModelIndex & , const QModelIndex & ); /** */ void OnItemChanged( QStandardItem * ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdImportImagesDialog_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdImportSubDatasetDialog.h000066400000000000000000000102101301006202600313170ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdImportSubDatasetDialog_h #define mvdImportSubDatasetDialog_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class ImportSubDatasetDialog; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ImportSubDatasetDialog * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT ImportSubDatasetDialog : public QDialog { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: // // Public methods. public: /** \brief Constructor. */ ImportSubDatasetDialog( const QString & filename, QWidget* p = NULL, Qt::WindowFlags flags = 0 ); /** \brief Destructor. */ ~ImportSubDatasetDialog() ITK_OVERRIDE; /** */ void GetSubDatasets( IntVector & ) const; /** */ bool HasSubDatasets() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: /** */ void Setup( const QString & filename ); /** */ void SetSubDatasetsCheckState( Qt::CheckState ); // // Private types. private: enum DatasetColumns { DATASET_COLUMN_INDEX = 0, DATASET_COLUMN_DESC, DATASET_COLUMN_NAME, // DATASET_COLUMN_COUNT }; // // Private attributes. private: /** */ static char const * const DATASET_COLUMN_NAMES[ DATASET_COLUMN_COUNT ]; /** * \brief uic generated. */ Ui::ImportSubDatasetDialog * m_UI; /** */ bool m_HasSubDatasets : 1; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void on_allButton_clicked(); /** */ void on_invertButton_clicked(); /** */ void on_noneButton_clicked(); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdImportSubDatasetDialog_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdKeymapDialog.h000066400000000000000000000036601301006202600273260ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdKeymapDialog_h #define mvdKeymapDialog_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class KeymapDialog; } /** \class KeymapDialog * * \ingroup OTBMonteverdiGUI * */ class OTBMonteverdiGUI_EXPORT KeymapDialog : public QDialog { Q_OBJECT; // // Public methods. public: /** Constructor */ KeymapDialog( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** Destructor */ ~KeymapDialog() ITK_OVERRIDE; // // SIGNALS. signals: // // Protected methods. protected: // // Protected attributes. protected: // // Private methods. private: // // Private attributes. private: /** */ Ui::KeymapDialog* m_UI; // // SLOTS. private slots: }; } // end namespace 'mvd' #endif // mvdKeymapDialog_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdLayerStackController.h000066400000000000000000000105041301006202600310610ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdLayerStackController_h #define mvdLayerStackController_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractModelController.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractLayerModel; class LayerStackWidget; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class LayerStackController * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OTBMonteverdiGUI_EXPORT LayerStackController : public AbstractModelController { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ LayerStackController( LayerStackWidget * widget, QObject * p =NULL ); /** \brief Destructor. */ ~LayerStackController() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void ApplyAllRequested(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ void UpdateButtonsState(); // // AbstractModelController overloads. /** */ void Connect( AbstractModel * ) ITK_OVERRIDE; /** */ void Disconnect( AbstractModel * ) ITK_OVERRIDE; /** */ void ClearWidget() ITK_OVERRIDE; /** */ void virtual_ResetWidget( bool ) ITK_OVERRIDE; // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void OnCurrentChanged( int ); /** */ void OnSelectionChanged( int ); /** */ void OnStackedLayerCurrentChanged( size_t ); /** */ void OnProjectionButtonClicked(); /** */ void OnStackedLayerContentChanged(); /** */ void OnStackedLayerContentReset(); /** */ void OnCopyLayerRequested( const AbstractLayerModel * ); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdLayerStackController_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdLayerStackItemModel.h000066400000000000000000000175741301006202600306330ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdLayerStackItemModel_h #define mvdLayerStackItemModel_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class AbstractImageModel; class AbstractLayerModel; class StackedLayerModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class LayerStackItemModel * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OTBMonteverdiGUI_EXPORT LayerStackItemModel : public QAbstractItemModel { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: enum Columns { COLUMN_NONE = -1, // COLUMN_PROJ = 0, COLUMN_RESOLUTION, COLUMN_NAME, COLUMN_EFFECT, COLUMN_I, COLUMN_J, COLUMN_R, COLUMN_G, COLUMN_B, COLUMN_X, COLUMN_Y, // COLUMN_COUNT, }; /* enum ItemRole { ITEM_ROLE_INDEX = Qt::UserRole + 1 ITEM_ROLE_NAME, ITEM_ROLE_I, ITEM_ROLE_J, ITEM_ROLE_R, ITEM_ROLE_G, ITEM_ROLE_B, ITEM_ROLE_X, ITEM_ROLE_Y, // ITEM_ROLE_NONE, // ITEM_ROLE_COUNT = ITEM_ROLE_NONE - Qt::UserRole, }; */ // // Public methods. public: /** \brief Constructor. */ LayerStackItemModel( QObject* p =NULL ); /** \brief Destructor. */ ~LayerStackItemModel() ITK_OVERRIDE; /** */ static const AbstractLayerModel * GetLayer( const QModelIndex & ); /** */ void SetStack( StackedLayerModel * ); // // QAbstractItemModel overloads. /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#columnCount */ int columnCount( const QModelIndex & p = QModelIndex() ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#data */ QVariant data( const QModelIndex & index, int role = Qt::DisplayRole ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#dropMimeData */ bool dropMimeData( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & p ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#flags */ Qt::ItemFlags flags( const QModelIndex & index ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#hasChildren */ bool hasChildren( const QModelIndex & p = QModelIndex() ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#headerData */ QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#index */ QModelIndex index( int row, int column, const QModelIndex & p = QModelIndex() ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#insertRows */ bool insertRows( int row, int count, const QModelIndex & p = QModelIndex() ) ITK_OVERRIDE; /** * \see http://doc.qt.io/qt-4.8/qabstractitemmodel.html#mimeData */ QMimeData * mimeData( const QModelIndexList & indexes ) const ITK_OVERRIDE; /** * \see http://doc.qt.io/qt-4.8/qabstractitemmodel.html#mimeTypes */ QStringList mimeTypes() const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#parent */ QModelIndex parent( const QModelIndex & index ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#removeRows */ bool removeRows( int row, int count, const QModelIndex & p = QModelIndex() ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#rowCount */ int rowCount( const QModelIndex & p = QModelIndex() ) const ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#setData */ bool setData( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#supportedDropActions */ Qt::DropActions supportedDropActions() const ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: /** */ void Connect( AbstractLayerModel * ); /** */ void Disconnect( AbstractLayerModel * ); // // Private attributes. private: /** */ StackedLayerModel * m_StackedLayerModel; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ // void OnContentAboutToBeChanged(); // void OnContentChanged(); // void OnModelAboutToBeReset(); // void OnModelReset(); void OnLayerAboutToBeDeleted( size_t ); void OnLayerAdded( size_t ); void OnLayerDeleted( size_t ); void OnLayerVisibilityChanged( AbstractLayerModel *, bool ); void OnReferenceChanged( size_t ); void OnPixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ); void OnImageSettingsUpdated( AbstractImageModel * ); void OnResolutionsChanged( const PixelInfo::Vector & ); }; } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { } // end namespace 'mvd' #endif // mvdLayerStackItemModel_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdLayerStackWidget.h000066400000000000000000000121001301006202600301530ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdLayerStackWidget_h #define mvdLayerStackWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { class AbstractLayerModel; class LayerStackItemModel; // // Internal classes pre-declaration. namespace Ui { class LayerStackWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class LayerStackWidget * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT LayerStackWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ LayerStackWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~LayerStackWidget() ITK_OVERRIDE; /** */ const LayerStackItemModel * GetItemModel() const; /** */ LayerStackItemModel * GetItemModel(); /** */ void SetCurrent( int ); /** */ void SetApplyEnabled( bool ); /** */ void SetDeleteEnabled( bool ); /** */ void SetMoveEnabled( bool ); /** */ void SetProjectionEnabled( bool ); /** */ void SetReloadEnabled( bool ); /** */ void InstallEventFilter( QObject * filter ); // // QObject overloads. // /** * \see http://qt-project.org/doc/qt-4.8/qobject.html#eventFilter */ bool eventFilter( QObject * watched, QEvent * event ) ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void CurrentChanged( int ); /** */ void SelectionChanged( int ); /** */ void TopButtonClicked(); /** */ void BottomButtonClicked(); /** */ void UpButtonClicked(); /** */ void DownButtonClicked(); /** */ void DeleteLayerRequested(); /** */ void DeleteAllLayersRequested(); /** */ void RotateLayersRequested( int ); /** */ void ProjectionButtonClicked(); /** */ void ApplyButtonClicked(); /** */ void CopyLayerRequested( const AbstractLayerModel * ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: /** * \see http://qt-project.org/doc/qt-4.8/qabstractitemview.html#dropEvent */ // virtual void dopEvent( QDropEvent * event ); // // Private methods. private: // // Private attributes. private: /** * \brief uic generated. */ Ui::LayerStackWidget * m_UI; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** * \see http://qt-project.org/doc/qt-4.8/qitemselectionmodel.html#currentRowChanged */ void OnCurrentRowChanged( const QModelIndex &, const QModelIndex & ); /** * \see http://qt-project.org/doc/qt-4.8/qitemselectionmodel.html#selectionChanged */ void OnSelectionChanged( const QItemSelection & selected, const QItemSelection & deselected ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdLayerStackWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdMainWindowTitleLoader.h000066400000000000000000000043151301006202600311630ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMainWindowTitleLoader_h #define mvdMainWindowTitleLoader_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) // // External classes pre-declaration. namespace { } namespace mvd { // // Internal class pre-declaration. class VectorImageModel; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class MainWindowTitleLoader * * \ingroup OTBMonteverdiGUI * * \brief Imports an image into a Monteverdi dataset * * This class is used to deport the dataset creation * in a separate thread */ class OTBMonteverdiGUI_EXPORT MainWindowTitleLoader : public QObject { Q_OBJECT; public: /** \brief Constructor */ MainWindowTitleLoader(VectorImageModel* model); public slots: /** \brief Trigger the dataset creation */ void LoadTitle(); signals: /** \brief Triggered after model is ready */ void TitleLoaded( const QString& ); /** \brief Triggered when processing is finished */ void Finished(); private: VectorImageModel* m_Model; }; } // end namespace 'mvd' #endif // mvdImageModel_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdMultiResolutionPyramidWidget.h000066400000000000000000000077471301006202600326420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMultiResolutionPyramidWidget_h #define mvdMultiResolutionPyramidWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGDALOverviewsBuilder.h" #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class MultiResolutionPyramidWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class MultiResolutionPyramidWidget * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT MultiResolutionPyramidWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ MultiResolutionPyramidWidget( QWidget * p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~MultiResolutionPyramidWidget() ITK_OVERRIDE; /** */ void SetBuilder( const otb::GDALOverviewsBuilder::Pointer & ); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: void BaseValueChanged( int ); void LevelsValueChanged( int ); void SizeValueChanged( int ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: /** */ void ClearResolutions(); /** */ void UpdateResolutions(); /** */ void UpdateSize(); // // Private attributes. private: /** * \brief uic generated. */ Ui::MultiResolutionPyramidWidget * m_UI; /** */ otb::GDALOverviewsBuilder::Pointer m_GDALOverviewsBuilder; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: void on_baseSpinBox_valueChanged( int ); void on_levelsSpinBox_valueChanged( int ); void on_sizeSpinBox_valueChanged( int ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdMultiResolutionPyramidWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdMyWidget.h000066400000000000000000000064251301006202600265130ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdMyWidget_h #define mvdMyWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class MyWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class MyWidget * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT MyWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ MyWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ virtual ~MyWidget(); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: // // Private attributes. private: /** * \brief uic generated. */ Ui::MyWidget* m_UI; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdMyWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdOTBApplicationsModel.h000066400000000000000000000114171301006202600307330ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdOTBApplicationsModel_h #define mvdOTBApplicationsModel_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdAbstractModel.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class ApplicationsBrowser; class ApplicationLauncher; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** \class OTBApplicationsModel * * \ingroup OTBMonteverdiGUI * */ class OTBMonteverdiGUI_EXPORT OTBApplicationsModel : public AbstractModel { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: // // Public methods. public: /** \brief Constructor. */ OTBApplicationsModel( QObject* p =NULL ); /** \brief Destructor. */ ~OTBApplicationsModel() ITK_OVERRIDE; /** \brief Fill Widget Tree */ void FillTree(); /** */ inline const ApplicationsBrowser* GetBrowser() const; /** */ inline ApplicationsBrowser* GetBrowser(); /** */ inline const ApplicationLauncher* GetLauncher() const; /** */ inline ApplicationLauncher* GetLauncher(); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // AbstractModel methods. void virtual_BuildModel( void* context =NULL ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: // // Private attributes. private: /** */ ApplicationsBrowser* m_ApplicationsBrowser; /** */ ApplicationLauncher* m_ApplicationLauncher; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // Monteverdi deferred includes (sorted by alphabetic order) namespace mvd { /*****************************************************************************/ inline const ApplicationsBrowser* OTBApplicationsModel ::GetBrowser() const { return m_ApplicationsBrowser; } /*****************************************************************************/ inline ApplicationsBrowser* OTBApplicationsModel ::GetBrowser() { return m_ApplicationsBrowser; } /*****************************************************************************/ inline const ApplicationLauncher* OTBApplicationsModel ::GetLauncher() const { return m_ApplicationLauncher; } /*****************************************************************************/ inline ApplicationLauncher* OTBApplicationsModel ::GetLauncher() { return m_ApplicationLauncher; } } // end namespace 'mvd' #endif // mvdOTBApplicationsModel_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdPixelDescriptionWidget.h000066400000000000000000000105401301006202600314040ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdPixelDescriptionWidget_h #define mvdPixelDescriptionWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class PixelDescriptionWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class PixelDescriptionWidget * * \ingroup OTBMonteverdiGUI * * \brief Widget to show current pixel under cursor description */ class OTBMonteverdiGUI_EXPORT PixelDescriptionWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ PixelDescriptionWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~PixelDescriptionWidget() ITK_OVERRIDE; /** Get TreeWidget */ QTreeWidget * GetDescriptionTree(); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: void OnCurrentPhysicalUpdated(const QStringList&); void OnCurrentGeographicUpdated(const QStringList& /*currentGeo const QString &*/); void OnCurrentPixelValueUpdated(const VectorImageType::PixelType &, const QStringList& bandNames); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: void SetupUI(); /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: // // Private attributes. private: /** * \brief uic generated. */ Ui::PixelDescriptionWidget* m_UI; // /** // * \brief map storing applications and its tags // */ // ApplicationsTagContainer m_AppTags; // /** // * \brief map storing applications docName and appName association // */ // ApplicationDocNameToNameMap m_AppsDocNameToNameMap; /** * \brief text to search in the widget tree */ QString m_SearchText; /** * \brief Root items */ QTreeWidgetItem* m_CartographicRootItem; QTreeWidgetItem* m_GeographicRootItem; QTreeWidgetItem* m_PixelValueRootItem; /** * \brief child items */ QTreeWidgetItem* m_CartographicItem; QTreeWidgetItem* m_GeographicItem; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; /*****************************************************************************/ /* INLINE SECTION */ } // end namespace 'mvd' #endif // mvdPixelDescriptionWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdQtWidgetParameterInitializers.h000066400000000000000000000412371301006202600327420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdQtWidgetParameterInitializers_h #define mvdQtWidgetParameterInitializers_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbMacro.h" #include "otbQtFileSelectionWidget.h" #include "otbWrapperQtWidgetInputFilenameParameter.h" #include "otbWrapperQtWidgetInputFilenameListParameter.h" #include "otbWrapperQtWidgetInputImageParameter.h" #include "otbWrapperQtWidgetInputImageListParameter.h" #include "otbWrapperQtWidgetInputProcessXMLParameter.h" #include "otbWrapperQtWidgetInputVectorDataParameter.h" #include "otbWrapperQtWidgetInputVectorDataListParameter.h" #include "otbWrapperQtWidgetOutputFilenameParameter.h" #include "otbWrapperQtWidgetOutputImageParameter.h" #include "otbWrapperQtWidgetOutputProcessXMLParameter.h" #include "otbWrapperQtWidgetOutputVectorDataParameter.h" #include "otbWrapperQtWidgetParameterFactory.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { namespace Wrapper { // // Internal classes pre-declaration. /*****************************************************************************/ /* FUNCTIONS DEFINITION SECTION */ /** */ template< typename W > void SetupForFilenameDrop( W* widget, const char* text =NULL ); /** */ template< typename W > void SetupOutputFilename( W* widget, const QDir& dir, const QString& prefix, const QString& extension ); /** */ template< typename W > void SetupOutputFilename( W * widget, const QDir & =QDir::current() ); /** */ template< typename F > inline void SetupWidget( QWidget * widget, const F& functor ); /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class FileSelectionInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class FileSelectionInitializer : public std::unary_function< otb::Wrapper::QtFileSelectionWidget*, void > { public: inline FileSelectionInitializer(); inline result_type operator () ( argument_type widget ) const; }; /** * \class InputImageInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class InputImageInitializer : public std::unary_function< otb::Wrapper::QtWidgetInputImageParameter*, void > { public: inline InputImageInitializer(); inline result_type operator () ( argument_type widget ) const; }; /** * \class InputImageListInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class InputImageListInitializer : public std::unary_function< otb::Wrapper::QtWidgetInputImageListParameter*, void > { public: inline InputImageListInitializer( QWidget * view ); inline result_type operator () ( argument_type widget ) const; private: QWidget * m_View; }; /** * \class InputVectorDataInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class InputVectorDataInitializer : public std::unary_function< otb::Wrapper::QtWidgetInputVectorDataParameter*, void > { public: inline result_type operator () ( argument_type widget ) const; }; /** * \class InputVectorDataListInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class InputVectorDataListInitializer : public std::unary_function< otb::Wrapper::QtWidgetInputVectorDataListParameter*, void > { public: inline InputVectorDataListInitializer( QWidget * view ); inline result_type operator () ( argument_type widget ) const; private: QWidget * m_View; }; /** * \class InputFilenameInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class InputFilenameInitializer : public std::unary_function< otb::Wrapper::QtWidgetInputFilenameParameter*, void > { public: inline result_type operator () ( argument_type widget ) const; }; /** * \class InputFilenameListInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class InputFilenameListInitializer : public std::unary_function< otb::Wrapper::QtWidgetInputFilenameListParameter*, void > { public: inline InputFilenameListInitializer( QWidget * view ); inline result_type operator () ( argument_type widget ) const; private: QWidget * m_View; }; /** * \class InputProcessXMLInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class InputProcessXMLInitializer : public std::unary_function< otb::Wrapper::QtWidgetInputProcessXMLParameter *, void > { public: inline result_type operator () ( argument_type widget ) const; }; /** * \class OutputImageInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OutputImageInitializer : public std::unary_function< otb::Wrapper::QtWidgetOutputImageParameter*, void > { public: inline OutputImageInitializer( const QString & prefix ); inline result_type operator () ( argument_type widget ) const; private: QString m_Prefix; }; /** * \class OutputVectorDataInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OutputVectorDataInitializer : public std::unary_function< otb::Wrapper::QtWidgetOutputVectorDataParameter*, void > { public: inline result_type operator () ( argument_type widget ) const; private: }; /** * \class OutputFilenameInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OutputFilenameInitializer : public std::unary_function< otb::Wrapper::QtWidgetOutputFilenameParameter*, void > { public: inline result_type operator () ( argument_type widget ) const; private: }; /** * \class OutputProcessXMLInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OutputProcessXMLInitializer : public std::unary_function< otb::Wrapper::QtWidgetOutputProcessXMLParameter *, void > { public: inline result_type operator () ( argument_type widget ) const; private: }; /** * \class ToolTipInitializer * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class ToolTipInitializer : public std::unary_function< QWidget*, void > { public: inline result_type operator () ( argument_type widget ) const; }; } // end namespace 'Wrapper'. } // end namespace 'mvd'. /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdI18nCoreApplication.h" #include "mvdFilenameDragAndDropEventFilter.h" #endif //tag=QT4-boost-compatibility namespace mvd { namespace Wrapper { /*****************************************************************************/ inline FileSelectionInitializer ::FileSelectionInitializer() { } /*****************************************************************************/ inline FileSelectionInitializer::result_type FileSelectionInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); } /*****************************************************************************/ inline InputImageInitializer ::InputImageInitializer() { } /*****************************************************************************/ inline InputImageInitializer::result_type InputImageInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); } /*****************************************************************************/ inline InputImageListInitializer ::InputImageListInitializer( QWidget * view ) : m_View( view ) { } /*****************************************************************************/ inline InputImageListInitializer::result_type InputImageListInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); QObject::connect( widget, SIGNAL( FileSelectionWidgetAdded( QWidget * ) ), m_View, SLOT( OnFileSelectionWidgetAdded0( QWidget * ) ) ); SetupWidget( widget, FileSelectionInitializer() ); } /*****************************************************************************/ inline InputFilenameInitializer::result_type InputFilenameInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); } /*****************************************************************************/ inline InputFilenameListInitializer ::InputFilenameListInitializer( QWidget * view ) : m_View( view ) { } /*****************************************************************************/ inline InputFilenameListInitializer::result_type InputFilenameListInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); QObject::connect( widget, SIGNAL( FileSelectionWidgetAdded( QWidget * ) ), m_View, SLOT( OnFileSelectionWidgetAdded0( QWidget * ) ) ); SetupWidget( widget, FileSelectionInitializer() ); } /*****************************************************************************/ inline InputVectorDataInitializer::result_type InputVectorDataInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); } /*****************************************************************************/ inline InputVectorDataListInitializer ::InputVectorDataListInitializer( QWidget * view ) : m_View( view ) { } /*****************************************************************************/ inline InputVectorDataListInitializer::result_type InputVectorDataListInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); QObject::connect( widget, SIGNAL( FileSelectionWidgetAdded( QWidget * ) ), m_View, SLOT( OnFileSelectionWidgetAdded0( QWidget * ) ) ); SetupWidget( widget, FileSelectionInitializer() ); } /*****************************************************************************/ inline InputProcessXMLInitializer::result_type InputProcessXMLInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); } /*****************************************************************************/ inline ToolTipInitializer::result_type ToolTipInitializer ::operator () ( argument_type otbUseInDebug( widget ) ) const { #if defined( OTB_DEBUG ) assert( widget!=NULL ); widget->setToolTip( widget->toolTip() + "\n(" + widget->metaObject()->className() + ")" ); #endif // defined( OTB_DEBUG ) } /*****************************************************************************/ inline OutputImageInitializer ::OutputImageInitializer( const QString& prefix ) : m_Prefix( prefix ) { } /*****************************************************************************/ inline OutputImageInitializer::result_type OutputImageInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); assert( I18nCoreApplication::ConstInstance()!=NULL ); if( m_Prefix.isEmpty() ) { SetupForFilenameDrop( widget, "You can drop filename here." ); assert( qApp!=NULL ); assert( !qApp->arguments().empty() ); SetupOutputFilename( widget ); } else SetupOutputFilename( widget, I18nCoreApplication::ConstInstance()->GetResultsDir(), m_Prefix, ".tif" ); } /*****************************************************************************/ inline OutputVectorDataInitializer::result_type OutputVectorDataInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); assert( qApp!=NULL ); assert( !qApp->arguments().empty() ); SetupOutputFilename( widget ); } /*****************************************************************************/ inline OutputFilenameInitializer::result_type OutputFilenameInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); assert( qApp!=NULL ); assert( !qApp->arguments().empty() ); SetupOutputFilename( widget ); } /*****************************************************************************/ inline OutputProcessXMLInitializer::result_type OutputProcessXMLInitializer ::operator () ( argument_type widget ) const { assert( widget!=NULL ); SetupForFilenameDrop( widget, "You can drop filename here." ); assert( qApp!=NULL ); assert( !qApp->arguments().empty() ); // MANTIS-1103 // { // SetupOutputFilename( widget ); // } } /*****************************************************************************/ template< typename W > void SetupForFilenameDrop( W* widget, const char* text ) { assert( widget!=NULL ); QLineEdit * lineEdit = widget->GetInput(); // // Setup widget. bool signalsBlocked = lineEdit->blockSignals( true ); { if( text!=NULL ) { lineEdit->setPlaceholderText( QCoreApplication::translate( "mvd::Wrapper::QtWidgetView", text ) ); } // lineEdit->setReadOnly( true ); lineEdit->setToolTip( lineEdit->toolTip() + "\n" + QCoreApplication::translate( "mvd::Wrapper::QtWidgetView", "You can drag filename from file-manager and drop it here." ) ); } lineEdit->blockSignals( signalsBlocked ); // // Install event-filters. QObject* eventFilter = new FilenameDragAndDropEventFilter( lineEdit ); lineEdit->installEventFilter( eventFilter ); QObject::connect( eventFilter, SIGNAL( FilenameDropped( const QString& ) ), // to: lineEdit, SLOT( setText( const QString& ) ) ); } /*****************************************************************************/ template< typename W > void SetupOutputFilename( W* widget, const QDir& dir, const QString& prefix, const QString& extension ) { QString id( QUuid::createUuid().toString() ); id.replace( QRegExp( "[\\{|\\}]" ), "" ); if( prefix!=NULL ) id.prepend( "_" ); widget->SetFileName( dir.absoluteFilePath( prefix + id + extension ) ); widget->UpdateGUI(); } /*****************************************************************************/ template< typename W > void SetupOutputFilename( W * widget, const QDir & dir ) { widget->SetFileName( dir.path() ); widget->UpdateGUI(); } /*******************************************************************************/ template< typename F > inline void SetupWidget( QWidget * widget, const F & functor ) { typedef typename F::argument_type Widget; typedef QList< Widget > WidgetList; WidgetList list( widget->findChildren< Widget >() ); for( typename WidgetList::iterator it( list.begin() ); it!=list.end(); ++it ) { functor( *it ); } } } // end namespace 'Wrapper'. } // end namespace 'mvd' #endif // mvdQtWidgetParameterInitializers_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdQtWidgetView.h000066400000000000000000000156451301006202600273510ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdWrapperQtWidgetView_h #define mvdWrapperQtWidgetView_h // // Configuration include. //// Included at first position before any other ones. #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "ConfigureMonteverdi.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperApplication.h" #include "otbWrapperQtWidgetModel.h" #endif //tag=QT4-boost-compatibility #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "mvdTypes.h" #endif //tag=QT4-boost-compatibility /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { namespace Wrapper { /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ApplicationLauncher * * \ingroup OTBMonteverdiGUI * * \brief WIP. */ class OTBMonteverdiGUI_EXPORT QtWidgetView : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT Q_PROPERTY( bool isClosable READ IsClosable WRITE SetClosable ); /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** */ static char const * const OBJECT_NAME; /** \brief Constructor. */ QtWidgetView( const otb::Wrapper::Application::Pointer & otbApp, QWidget* p =0, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~QtWidgetView() ITK_OVERRIDE; /** \brief Gui Creation. */ void CreateGui(); /** \brief Model Accessor */ inline otb::Wrapper::QtWidgetModel* GetModel() { return m_Model; } /** * \return The OTB-application pointer of this view. */ otb::Wrapper::Application::ConstPointer GetApplication() const { return otb::ConstCast< otb::Wrapper::Application >( m_Application ); } /** */ inline bool IsClosable() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: void QuitSignal(); void OTBApplicationOutputImageChanged( const QString &, const QString &); void ExecuteAndWriteOutput(); void ExecutionDone( int nbOutputs ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // QWidget overloads. void closeEvent( QCloseEvent * event ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: QtWidgetView(const QtWidgetView&); //purposely not implemented void operator=(const QtWidgetView&); //purposely not implemented QWidget* CreateFooter(); QWidget* CreateInputWidgets(); QWidget* CreateDoc(); /** */ void SetupParameterWidgets( QWidget* widget ); /** */ void SetupFileSelectionWidget( QWidget * ); // // Private attributes. private: otb::Wrapper::Application::Pointer m_Application; otb::Wrapper::QtWidgetModel* m_Model; QPushButton* m_ExecButton; QPushButton* m_QuitButton; QLabel* m_Message; bool m_IsClosable : 1; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: // slot in charge of emitting a signal to the catalogue mainWindow. // when received, the main application need to get the output // image filename{s} set by the user in this OTB application (if any). void OnApplicationExecutionDone( int ); void UpdateMessageAfterApplicationReady(bool val); /** */ void OnExecButtonClicked(); /** */ inline void OnProgressReportBegin(); /** */ inline void OnProgressReportEnd( int status ); /** */ void OnExceptionRaised( QString what ); /** */ inline void SetClosable( bool ); /** */ inline void OnFileSelectionWidgetAdded0( QWidget * ); /** */ inline void OnFileSelectionWidgetAdded1( QWidget * ); }; } // end namespace 'Wrapper' } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { namespace Wrapper { /*****************************************************************************/ inline bool QtWidgetView ::IsClosable() const { return m_IsClosable; } /*****************************************************************************/ inline void QtWidgetView ::SetClosable( bool enabled ) { m_IsClosable = enabled; setEnabled( true ); if( m_QuitButton!=NULL ) m_QuitButton->setEnabled( m_IsClosable ); } /*******************************************************************************/ inline void QtWidgetView ::OnProgressReportBegin() { SetClosable( false ); } /*******************************************************************************/ inline void QtWidgetView ::OnProgressReportEnd( int ) { SetClosable( true ); } /*******************************************************************************/ inline void QtWidgetView ::OnFileSelectionWidgetAdded0( QWidget * widget ) { SetupFileSelectionWidget( widget ); } /*******************************************************************************/ inline void QtWidgetView ::OnFileSelectionWidgetAdded1( QWidget * widget ) { SetupFileSelectionWidget( widget ); } } // end namespace 'Wrapper' } // end namespace 'mvd' #endif OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdQuicklookViewManipulator.h000066400000000000000000000110471301006202600317660ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdQuicklookViewManipulator_h #define mvdQuicklookViewManipulator_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdImageViewManipulator.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class QuicklookViewManipulator * * \ingroup OTBMonteverdiGUI * * \brief TODO. */ class OTBMonteverdiGUI_EXPORT QuicklookViewManipulator : public ImageViewManipulator { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ #if USE_VIEW_SETTINGS_SIDE_EFFECT QuicklookViewManipulator( const otb::ViewSettings::Pointer& viewSettings, QObject* p =NULL ); #else // USE_VIEW_SETTINGS_SIDE_EFFECT QuicklookViewManipulator( QObject* p =NULL ); #endif // USE_VIEW_SETTINGS_SIDE_EFFECT /** \brief Destructor. */ ~QuicklookViewManipulator() ITK_OVERRIDE; // // ImageViewManipulator overloads. ZoomType GetFixedZoomType() const ITK_OVERRIDE; void SetupRenderingContext( AbstractImageViewRenderer::RenderingContext * const ) const ITK_OVERRIDE; void MousePressEvent( QMouseEvent* event ) ITK_OVERRIDE; void MouseMoveEvent( QMouseEvent* event ) ITK_OVERRIDE; // virtual void MousePressEvent( QMouseEvent* event ); // virtual void MouseReleaseEvent( QMouseEvent* event ); void MouseDoubleClickEvent( QMouseEvent * ) ITK_OVERRIDE {}; void WheelEvent( QWheelEvent* event) ITK_OVERRIDE; void ResizeEvent( QResizeEvent * event ) ITK_OVERRIDE; void KeyPressEvent( QKeyEvent* event ) ITK_OVERRIDE; void KeyReleaseEvent( QKeyEvent* event ) ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]-----------------------------------------------**/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: // // Private methods. private: // // Private attributes. private: /** */ PointType m_RoiOrigin; /** */ SpacingType m_RoiSpacing; /** */ SizeType m_RoiSize; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void OnRoiChanged( const PointType& origin, const SizeType& size, const SpacingType& spacing, const PointType& center ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdQuicklookViewManipulator_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdQuicklookViewRenderer.h000066400000000000000000000104551301006202600312430ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdQuicklookViewRenderer_h #define mvdQuicklookViewRenderer_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGlROIActor.h" #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdImageViewRenderer.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace otb { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class QuicklookViewRenderer * * \ingroup OTBMonteverdiGUI */ class OTBMonteverdiGUI_EXPORT QuicklookViewRenderer : public ImageViewRenderer { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: /** */ struct RenderingContext : public ImageViewRenderer::RenderingContext { /** */ inline RenderingContext() : ImageViewRenderer::RenderingContext(), m_RoiOrigin(), m_RoiExtent() { m_RoiOrigin.Fill( 0 ); m_RoiOrigin.Fill( 0 ); } ~RenderingContext() ITK_OVERRIDE {} PointType m_RoiOrigin; PointType m_RoiExtent; }; // // Public methods. public: /** Constructor */ QuicklookViewRenderer( QObject* p = NULL ); /** Destructor */ ~QuicklookViewRenderer() ITK_OVERRIDE; // // ImageViewRenderer overloads. AbstractImageViewRenderer::RenderingContext* NewRenderingContext() const ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // public slots public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // SIGNALS. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // ImageViewRenderer overloads. void UpdateActors( const AbstractImageViewRenderer::RenderingContext* c ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types private: // // Private methods. private: void SetWktAndKwl(); // // ImageViewRenderer methods. void virtual_SetProjection() ITK_OVERRIDE; void virtual_UpdateProjection() ITK_OVERRIDE; // // AbstractImageViewRenderer overloads. // TODO: Move virtual_*Scene() methods to protected section. void virtual_FinishScene() ITK_OVERRIDE; // // Private attributes. private: /** */ otb::GlROIActor::Pointer m_GlRoiActor; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // SLOTS. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdQuicklookViewRenderer_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdSearchableTreeWidget.h000066400000000000000000000101041301006202600307640ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdSearchableTreeWidget_h #define mvdSearchableTreeWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) // #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class SearchableTreeWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class SearchableTreeWidget * * \ingroup OTBMonteverdiGUI * * \brief Database content browser. Presents: * - Cached datasets. */ class OTBMonteverdiGUI_EXPORT SearchableTreeWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: // // Public methods. public: /** \brief Constructor. */ SearchableTreeWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~SearchableTreeWidget() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private types. private: /** * \brief List of dataset item names displayed under the 'dataset' * root item. */ QList< QTreeWidgetItem* > TreeWidgetItemList; // // Private methods. private: /** * \brief Setup UI sub-items. */ void SetupUI(); // // Private attributes. private: /** * \brief uic generated. */ Ui::SearchableTreeWidget* m_UI; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** * \brief Slot called when the current item of the QWidgetTree has * changed. * * \param current The newly selected DatasetTreeWidgetItem. * \param previous The previously selected QTreeWidgetItem. */ /* void on_databaseTreeWidget_currentItemChanged( QTreeWidgetItem* current, QTreeWidgetItem* previous ); */ /** */ // void on_searchLineEdit_textChanged( const QString& text ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdSearchableTreeWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdShaderWidget.h000066400000000000000000000073561301006202600273400ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdShaderWidget_h #define mvdShaderWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdImageSettingsInterface.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class ShaderWidget; }; class ImageSettings; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class ShaderWidget * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT ShaderWidget : public QWidget, public ImageSettingsInterface { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ ShaderWidget( QWidget * p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~ShaderWidget() ITK_OVERRIDE; /** */ void SetGLSLEnabled( bool ); /** */ void SetGLSL140Enabled( bool ); /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: void SettingsChanged(); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: /** */ void virtual_SetSettings( ImageSettings * ) ITK_OVERRIDE; // // Private attributes. private: /** * \brief uic generated. */ Ui::ShaderWidget * m_UI; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: void on_effectComboBox_currentIndexChanged( const QString & ); void on_sizeSpinBox_valueChanged( int ); void on_valueLineEdit_editingFinished(); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdShaderWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdStatusBarWidget.h000066400000000000000000000102721301006202600300310ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdStatusBarWidget_h #define mvdStatusBarWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdTypes.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. namespace Ui { class StatusBarWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class StatusBarWidget * * \ingroup OTBMonteverdiGUI * * \brief Status Bar widget * widget class. */ class OTBMonteverdiGUI_EXPORT StatusBarWidget : public QWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ StatusBarWidget( QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** \brief Destructor. */ ~StatusBarWidget() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /** */ void SetPixelIndex( const IndexType &, bool isInside ); /** */ void SetText( const QString & ); /** */ void SetScale( double sx, double sy ); /** */ void SetGLSLEnabled( bool ); /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void ScaleChanged( double ); /** */ void PixelIndexChanged( const IndexType & ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: /** */ static QString ZoomLevel( double scale ); // // Private attributes. private: /** * \brief uic generated. */ Ui::StatusBarWidget * m_UI; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ // void SetPixelIndexText( const QString& ); /** */ void on_scaleLineEdit_editingFinished(); /** */ void on_pixelIndexLineEdit_returnPressed(); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" namespace mvd { } // end namespace 'mvd' #endif // mvdStatusBarWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdTaskProgressDialog.h000066400000000000000000000104011301006202600305160ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdTaskProgressDialog_h #define mvdTaskProgressDialog_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class BackgroundTask; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class TaskProgressDialog * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT TaskProgressDialog : public QProgressDialog { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** * \brief Constructor. */ TaskProgressDialog( BackgroundTask* task, QWidget* p =NULL, Qt::WindowFlags flags =0 ); /** * \brief Destructor. */ ~TaskProgressDialog() ITK_OVERRIDE; /** */ int Exec(); /** */ inline QObject * GetObject() const; /** */ template< typename T > inline T* GetObject() const; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: // Mask Qt native dialogue exec to be replaced by custom Exec() // method. Reason: QDialog::exec() is not virtual. using QProgressDialog::exec; // // Private attributes. private: /** */ BackgroundTask* m_BackgroundTask; /** */ QObject* m_Object; /** */ std::exception m_Exception; /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: /** */ void OnDone( QObject* result ); /** */ void OnExceptionRaised( QString what ); /** */ void OnObjectDestroyed( QObject* object ); }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ inline QObject * TaskProgressDialog ::GetObject() const { return m_Object; } /*****************************************************************************/ template< typename T > inline T* TaskProgressDialog ::GetObject() const { return qobject_cast< T* >( m_Object ); } } // end namespace 'mvd' #endif // mvdTaskProgressDialog_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdTreeWidget.h000066400000000000000000000117561301006202600270300ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdTreeWidget_h #define mvdTreeWidget_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #define USE_CUSTOM_MIME_DATA 1 /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { /*****************************************************************************/ /* FUNCTIONS DEFINITION SECTION */ /** */ QMimeData* EncodeMimeData( QMimeData* mimeData, const QList< QTreeWidgetItem* >& items ); /** */ int DecodeMimeData( QList< QTreeWidgetItem* >& items, const QMimeData* mimeData ); // // Internal classes pre-declaration. namespace Ui { //class TreeWidget; }; /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class TreeWidget * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT TreeWidget : public QTreeWidget { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types and constants. public: /** */ static const char* ITEM_MIME_TYPE; /** */ typedef QList< QTreeWidgetItem* > QTreeWidgetItemList; // // Public methods. public: /** \brief Constructor. */ TreeWidget( QWidget* p =NULL ); /** \brief Destructor. */ ~TreeWidget() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void ItemMoved( QTreeWidgetItem * item, QTreeWidgetItem * target ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: // // QTreeWidget overloads. QStringList mimeTypes() const ITK_OVERRIDE; QMimeData* mimeData( const QList< QTreeWidgetItem* > items ) const ITK_OVERRIDE; void dragEnterEvent( QDragEnterEvent* event ) ITK_OVERRIDE; void dragMoveEvent( QDragMoveEvent* event ) ITK_OVERRIDE; void dragLeaveEvent( QDragLeaveEvent* event ) ITK_OVERRIDE; void dropEvent( QDropEvent* event ) ITK_OVERRIDE; Qt::DropActions supportedDropActions() const ITK_OVERRIDE; void startDrag( Qt::DropActions supportedActions ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* GLOBAL FUNCTIONS DECLARATION */ #if USE_CUSTOM_MIME_DATA // // Declare Qt tree-widget item pointer types so they can be wrapped by // QVariant. Q_DECLARE_METATYPE( QTreeWidgetItem* ); #define TREE_WIDGET_ITEM_USE_STREAM_OPERATORS 1 #if TREE_WIDGET_ITEM_USE_STREAM_OPERATORS /** */ QDataStream& operator << ( QDataStream& out, QTreeWidgetItem const * item ); /** */ QDataStream& operator >>( QDataStream& in, QTreeWidgetItem * & item ); #endif // !DATASTREAM_USE_TEMPLATE_OPERATORS #endif // USE_CUSTOM_MIME_DATA /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdTreeWidget_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/mvdTreeWidgetItem.h000066400000000000000000000130141301006202600276340ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdTreeWidgetItem_h #define mvdTreeWidgetItem_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. class TreeWidgetItem; // // Functions declarations. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class TreeWidgetItem * * \ingroup OTBMonteverdiGUI * * \brief */ class OTBMonteverdiGUI_EXPORT TreeWidgetItem : public QTreeWidgetItem // not a QObject { /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public types. public: enum ColumnIndex { COLUMN_INDEX_TEXT = 0, COLUMN_INDEX_ID = 1, COLUMN_INDEX_HASH = 2, }; enum ItemType { ITEM_TYPE_NONE = QTreeWidgetItem::UserType, ITEM_TYPE_NODE = QTreeWidgetItem::UserType + 1, ITEM_TYPE_LEAF = QTreeWidgetItem::UserType + 2, }; enum ItemRole { ITEM_ROLE_ID = Qt::UserRole + 1, }; // // Public methods. public: /** * \brief Constructor. */ TreeWidgetItem( QTreeWidgetItem* p =NULL, const QString& text =QString(), const QVariant& id =QVariant(), const QStringList& columns = QStringList(), TreeWidgetItem::ItemType type =TreeWidgetItem::ITEM_TYPE_LEAF ); /** * \brief Destructor. */ ~TreeWidgetItem() ITK_OVERRIDE; /** */ inline TreeWidgetItem::ItemType GetType() const; /** */ inline QVariant GetId() const; /** */ inline QString GetText() const; /** * \brief Get the datasetID */ inline QString GetHash() const; // // QTreeWidgetItem overloads. /** * \see http://qt-project.org/doc/qt-4.8/qtreewidgetitem.html#clone */ QTreeWidgetItem* clone() const ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Protected attributes. protected: // // Private methods. private: /** */ static const int m_MetaTypeId; /** */ static const int m_PointerMetaTypeId; /** */ static const int m_ConstPointerMetaTypeId; /** */ inline void SetId( const QVariant& id ); // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /* // // Declare TreeWidgetItem meta-type so it can be used for drag-and-drop // operations. Q_DECLARE_METATYPE( mvd::TreeWidgetItem ); */ /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { /*****************************************************************************/ inline TreeWidgetItem::ItemType TreeWidgetItem ::GetType() const { return type() < QTreeWidgetItem::UserType ? TreeWidgetItem::ITEM_TYPE_NONE : TreeWidgetItem::ItemType( type() ); } /*****************************************************************************/ inline QVariant TreeWidgetItem ::GetId() const { return data( COLUMN_INDEX_ID, TreeWidgetItem::ITEM_ROLE_ID ); } /*****************************************************************************/ inline void TreeWidgetItem ::SetId( const QVariant& id ) { setData( COLUMN_INDEX_ID, TreeWidgetItem::ITEM_ROLE_ID, id ); setText( COLUMN_INDEX_ID, id.toString() ); } /*****************************************************************************/ inline QString TreeWidgetItem ::GetText() const { return text( COLUMN_INDEX_TEXT ); } /*****************************************************************************/ inline QString TreeWidgetItem ::GetHash() const { return text( COLUMN_INDEX_HASH ); } } // end namespace 'mvd' #endif // mvdTreeWidgetItem_h mvdTreeWidgetItemDragAndDropEventFilter.h000066400000000000000000000101371301006202600337760ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiGui/include/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef mvdTreeWidgetItemDragAndDropEventFilter_h #define mvdTreeWidgetItemDragAndDropEventFilter_h // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "OTBMonteverdiGUIExport.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractDragAndDropEventFilter.h" /*****************************************************************************/ /* PRE-DECLARATION SECTION */ // // External classes pre-declaration. namespace { } namespace mvd { // // Internal classes pre-declaration. /*****************************************************************************/ /* CLASS DEFINITION SECTION */ /** * \class TreeWidgetItemDragAndDropEventFilter * * \ingroup OTBMonteverdiGUI * * \brief Widget template skeleton to copy-paste when adding a new * widget class. */ class OTBMonteverdiGUI_EXPORT TreeWidgetItemDragAndDropEventFilter : public AbstractDragAndDropEventFilter { /*-[ QOBJECT SECTION ]-----------------------------------------------------*/ Q_OBJECT; /*-[ PUBLIC SECTION ]------------------------------------------------------*/ // // Public methods. public: /** \brief Constructor. */ TreeWidgetItemDragAndDropEventFilter( QObject* p =NULL ); /** \brief Destructor. */ ~TreeWidgetItemDragAndDropEventFilter() ITK_OVERRIDE; /*-[ PUBLIC SLOTS SECTION ]------------------------------------------------*/ // // Public SLOTS. public slots: /*-[ SIGNALS SECTION ]-----------------------------------------------------*/ // // Signals. signals: /** */ void ItemDropped( QTreeWidgetItem* item ); /*-[ PROTECTED SECTION ]---------------------------------------------------*/ // // Protected methods. protected: /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragEnterEvent */ bool DragEnterEvent( QObject* object, QDragEnterEvent* event ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragLeaveEvent */ bool DragLeaveEvent( QObject* object, QDragLeaveEvent* event ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dragMoveEvent */ bool DragMoveEvent( QObject* object, QDragMoveEvent* event ) ITK_OVERRIDE; /** * \see http://qt-project.org/doc/qt-4.8/qwidget.html#dropEvent */ bool DropEvent( QObject* object, QDropEvent* event ) ITK_OVERRIDE; // // Protected attributes. protected: /*-[ PRIVATE SECTION ]-----------------------------------------------------*/ // // Private methods. private: // // Private attributes. private: /*-[ PRIVATE SLOTS SECTION ]-----------------------------------------------*/ // // Slots. private slots: }; } // end namespace 'mvd' /*****************************************************************************/ /* INLINE SECTION */ namespace mvd { } // end namespace 'mvd' #endif // mvdTreeWidgetItemDragAndDropEventFilter_h OTB-release-5.8/Modules/Visualization/MonteverdiGui/otb-module.cmake000066400000000000000000000005471301006202600255270ustar00rootroot00000000000000set(DOCUMENTATION "This module provides MonteverdiGui, the GUI library of the Monteverdi applications." ) otb_module( OTBMonteverdiGUI ENABLE_SHARED DEPENDS OTBCommon OTBIce OTBIOGDAL OTBMonteverdiCore OTBQt4 OTBQwt OPTIONAL_DEPENDS OTBQtWidget TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/000077500000000000000000000000001301006202600232375ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/CMakeLists.txt000066400000000000000000000134271301006202600260060ustar00rootroot00000000000000############################################################################# set( OTBMonteverdiGUI_SRCS mvdAboutDialog.cxx mvdAbstractDragAndDropEventFilter.cxx mvdAbstractModelController.cxx mvdColorBandDynamicsWidget.cxx mvdColorDynamicsController.cxx mvdColorDynamicsWidget.cxx mvdColorSetupController.cxx mvdColorSetupWidget.cxx mvdDoubleValidator.cxx mvdDropLineEdit.cxx mvdFilenameDragAndDropEventFilter.cxx mvdGui.cxx mvdHistogramController.cxx mvdHistogramPlotPicker.cxx mvdHistogramWidget.cxx mvdI18nApplication.cxx mvdI18nMainWindow.cxx mvdImageViewRenderer.cxx mvdImageViewManipulator.cxx mvdImageViewWidget.cxx mvdImportImagesDialog.cxx mvdImportSubDatasetDialog.cxx mvdKeymapDialog.cxx mvdLayerStackController.cxx mvdLayerStackItemModel.cxx mvdLayerStackWidget.cxx mvdMainWindowTitleLoader.cxx mvdMultiResolutionPyramidWidget.cxx #mvdMyWidget.cxx mvdPixelDescriptionWidget.cxx mvdQuicklookViewManipulator.cxx mvdQuicklookViewRenderer.cxx mvdSearchableTreeWidget.cxx mvdShaderWidget.cxx mvdStatusBarWidget.cxx mvdTaskProgressDialog.cxx mvdTreeWidget.cxx mvdTreeWidgetItem.cxx mvdTreeWidgetItemDragAndDropEventFilter.cxx ) ############################################################################# set( OTBMonteverdiGUI_HEADERS_MOC ../include/mvdAboutDialog.h ../include/mvdAbstractDragAndDropEventFilter.h ../include/mvdAbstractImageViewManipulator.h ../include/mvdAbstractImageViewRenderer.h ../include/mvdAbstractModelController.h ../include/mvdColorBandDynamicsWidget.h ../include/mvdColorDynamicsController.h ../include/mvdColorDynamicsWidget.h ../include/mvdColorSetupController.h ../include/mvdColorSetupWidget.h #../include/mvdDatabaseBrowserController.h #../include/mvdDatabaseBrowserWidget.h #../include/mvdDatabaseBrowserWidgetTest.h #../include/mvdDatabaseTreeWidget.h #../include/mvdDatasetCreationProgressDialog.h #../include/mvdDatasetDragAndDropEventFilter.h #../include/mvdDatasetPropertiesController.h #../include/mvdDatasetPropertiesWidget.h ../include/mvdDoubleValidator.h ../include/mvdDropLineEdit.h ../include/mvdFilenameDragAndDropEventFilter.h #mvdGui.h ../include/mvdHistogramController.h ../include/mvdHistogramPlotPicker.h ../include/mvdHistogramWidget.h ../include/mvdI18nApplication.h ../include/mvdI18nMainWindow.h ../include/mvdImageViewManipulator.h ../include/mvdImageViewRenderer.h ../include/mvdImageViewWidget.h ../include/mvdImportImagesDialog.h ../include/mvdImportSubDatasetDialog.h ../include/mvdKeymapDialog.h ../include/mvdLayerStackController.h ../include/mvdLayerStackItemModel.h ../include/mvdLayerStackWidget.h ../include/mvdMainWindowTitleLoader.h ../include/mvdMultiResolutionPyramidWidget.h #mvdMyWidget.h ../include/mvdPixelDescriptionWidget.h ../include/mvdQuicklookViewManipulator.h ../include/mvdQuicklookViewRenderer.h ../include/mvdSearchableTreeWidget.h ../include/mvdStatusBarWidget.h ../include/mvdTaskProgressDialog.h ../include/mvdTreeWidget.h #mvdTreeWidgetItem.h ../include/mvdTreeWidgetItemDragAndDropEventFilter.h ../include/mvdShaderWidget.h ) ############################################################################# set( OTBMonteverdiGUI_FORMS mvdAboutDialog.ui mvdColorBandDynamicsWidget.ui mvdColorDynamicsWidget.ui mvdColorSetupWidget.ui #mvdDatabaseBrowserWidget.ui #mvdDatabaseBrowserWidgetTest.ui #mvdDatasetCreationProgressDialog.ui #mvdDatasetPropertiesWidget.ui mvdHistogramWidget.ui mvdImportImagesDialog.ui mvdImportSubDatasetDialog.ui mvdKeymapDialog.ui mvdLayerStackWidget.ui mvdMultiResolutionPyramidWidget.ui #mvdMyWidget.ui mvdPixelDescriptionWidget.ui mvdSearchableTreeWidget.ui mvdShaderWidget.ui mvdStatusBarWidget.ui mvdVideoColorToolBox.ui ) ############################################################################# set( OTBMonteverdiGUI_RESOURCES # mvdIcons.qrc ) ############################################################################# if( OTBQtWidget_ENABLED ) list( APPEND OTBMonteverdiGUI_SRCS mvdApplicationLauncher.cxx mvdApplicationsToolBox.cxx mvdApplicationsToolBoxController.cxx mvdOTBApplicationsModel.cxx mvdQtWidgetView.cxx ) list( APPEND OTBMonteverdiGUI_HEADERS_MOC ../include/mvdApplicationLauncher.h ../include/mvdApplicationsToolBox.h ../include/mvdApplicationsToolBoxController.h ../include/mvdOTBApplicationsModel.h ../include/mvdQtWidgetView.h ) list( APPEND OTBMonteverdiGUI_FORMS mvdApplicationsToolBox.ui ) list( APPEND OTBMonteverdiGUI_RESOURCES # mvdApplicationsToolBox.qrc ) endif() ############################################################################# qt4_wrap_cpp( OTBMonteverdiGUI_SRC_MOC ${OTBMonteverdiGUI_HEADERS_MOC} ) qt4_wrap_ui( OTBMonteverdiGUI_FORMS_HEADERS ${OTBMonteverdiGUI_FORMS} ) qt4_add_resources( OTBMonteverdiGUI_RESOURCES_RCC ${OTBMonteverdiGUI_RESOURCES} ) ############################################################################# add_to_qt4_i18n_sources( ${OTBMonteverdiGUI_SRCS} ) add_to_qt4_i18n_headers( "../include" ${OTBMonteverdiGUI_SRCS} ) add_to_qt4_i18n_forms( ${OTBMonteverdiGUI_FORMS} ) ############################################################################# add_library( OTBMonteverdiGUI ${OTBMonteverdiGUI_SRCS} ${OTBMonteverdiGUI_FORMS_HEADERS} ${OTBMonteverdiGUI_SRC_MOC} ${OTBMonteverdiGUI_RESOURCES_RCC} ) ############################################################################# target_link_libraries( OTBMonteverdiGUI ${OTBCommon_LIBRARIES} ${OTBIce_LIBRARIES} ${OTBIOGDAL_LIBRARIES} ${OTBMonteverdiCore_LIBRARIES} ${OTBQtWidget_LIBRARIES} ${OTBQwt_LIBRARIES} ) ############################################################################# otb_module_target( OTBMonteverdiGUI ) OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdAboutDialog.cxx000066400000000000000000000040101301006202600266570ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdAboutDialog.h" #include "ui_mvdAboutDialog.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::AboutDialog Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*******************************************************************************/ AboutDialog ::AboutDialog( QWidget* p, Qt::WindowFlags flags ) : QDialog( p, flags ), m_UI( new mvd::Ui::AboutDialog() ) { m_UI->setupUi( this ); m_UI->m_ProjectLabel->setText( qApp->applicationName() ); m_UI->m_VersionLabel->setText( qApp->applicationVersion() ); } /*******************************************************************************/ AboutDialog ::~AboutDialog() { delete m_UI; m_UI = NULL; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdAboutDialog.ui000066400000000000000000000114611301006202600265020ustar00rootroot00000000000000 mvd::AboutDialog Qt::ApplicationModal 0 0 464 487 0 0 About... 0 0 10 75 true Monteverdi false Qt::Horizontal 40 20 0 0 true OTB version M.m.pl (codename) 0 0 QFrame::NoFrame <br /><p>Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.</p><p>See Copyright.txt for details.</p><br /><p>Monteverdi is distributed under the CeCILL licence version 2. See</p><p>Licence_CeCILL_V2-en.txt or</p><p><a href="http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt">http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt</a> for more details.</p><br /><p>This software is distributed WITHOUT ANY WARRANTY; without even</p><p>the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR</p><p>PURPOSE. See the above copyright notices for more information</a>.</p><br /> Qt::Horizontal 40 20 &Close m_CloseButton m_CloseButton clicked() mvd::AboutDialog close() 359 398 206 211 OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdAbstractDragAndDropEventFilter.cxx000066400000000000000000000061541301006202600324610ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdAbstractDragAndDropEventFilter.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::AbstractDragAndDropEventFilter Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ AbstractDragAndDropEventFilter ::AbstractDragAndDropEventFilter( QObject* p ) : QObject( p ) { } /*****************************************************************************/ AbstractDragAndDropEventFilter ::~AbstractDragAndDropEventFilter() { } /*****************************************************************************/ bool AbstractDragAndDropEventFilter ::eventFilter( QObject* object, QEvent* e ) { switch( e->type() ) { case QEvent::DragEnter: return DragEnterEvent( object, dynamic_cast< QDragEnterEvent* >( e ) ); break; case QEvent::DragMove: return DragMoveEvent( object, dynamic_cast< QDragMoveEvent* >( e ) ); break; case QEvent::DragLeave: return DragLeaveEvent( object, dynamic_cast< QDragLeaveEvent* >( e ) ); break; case QEvent::Drop: return DropEvent( object, dynamic_cast< QDropEvent* >( e ) ); break; default: break; } return QObject::eventFilter( object, e ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdAbstractModelController.cxx000066400000000000000000000127141301006202600312670ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdAbstractModelController.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractModel.h" namespace mvd { /* TRANSLATOR mvd::AbstractModelController Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*******************************************************************************/ AbstractModelController ::AbstractModelController( QWidget* widget, QObject* p ): QObject( p ), m_Widget( widget ), m_Model( NULL ) { assert( widget!=NULL ); QObject::connect( this, SIGNAL( destroyed( QObject* ) ), this, SLOT( OnDestroyed( QObject* ) ) ); QObject::connect( widget, SIGNAL( destroyed( QObject* ) ), this, SLOT( OnDestroyed( QObject* ) ) ); } /*******************************************************************************/ AbstractModelController ::~AbstractModelController() { /* assert( m_Model==NULL && "AbstractModelController::m_Model should be disconnected before destroying controller instance." ); */ } /*****************************************************************************/ void AbstractModelController ::SetModel( AbstractModel* model ) { // Disconnect previously connected model and signal listeners. private_Disconnect( m_Model ); // Disable GUI widget while there is no model. GetWidget()->setEnabled( false ); // Clear widget from previous values. private_ClearWidget(); // Forget previously disconnected model before new model is // connected. This is done in order to stay in a consistent internal // state whenever the connection is aborted (e.g. by an exception). m_Model = NULL; // Connect new model and signal listeners. private_Connect( model ); // Remember newly connected model. m_Model = model; // Enable GUI widget when there is a model. if( m_Model!=NULL ) { virtual_ResetWidget( true ); GetWidget()->setEnabled( true ); } } /*****************************************************************************/ void AbstractModelController ::private_Connect( AbstractModel* model ) { if( model==NULL ) return; emit AboutToConnectModel( model ); QObject::connect( model, SIGNAL( destroyed( QObject* ) ), this, SLOT( OnDestroyed( QObject* ) ) ); Connect( model ); emit ModelConnected( model ); } /*****************************************************************************/ void AbstractModelController ::private_Disconnect( AbstractModel* model ) { if( model==NULL ) return; emit AboutToDisconnectModel( model ); Disconnect( model ); QObject::disconnect( model, SIGNAL( destroyed( QObject* ) ), this, SLOT( OnDestroyed( QObject* ) ) ); emit ModelDisconnected( model ); } /*****************************************************************************/ void AbstractModelController ::private_ClearWidget() { // Reset UI from model. ClearWidget(); } /*****************************************************************************/ void AbstractModelController ::ResetWidget() { // Reset UI from model. virtual_ResetWidget( false ); #if 0 // Signal model has been updated. // When resetting widget, data is read from model and set into // widget so, there's no need to signal back model update. emit ModelUpdated(); #endif } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void AbstractModelController ::RefreshWidget() { } /*******************************************************************************/ void AbstractModelController ::OnDestroyed( QObject* object ) { assert( object!=NULL ); if( object==m_Widget ) { // qDebug() << "Disconnect (widget) on destroy."; // When wrapped widget is destroyed, auto-destroy controller which // has no other reason to live than to wrap the widget. // // N.B.: Qt will automatically disconnect all signals from deleted // object. deleteLater(); } else if( object==m_Model ) { #if 0 qDebug() << "Disconnect (model" << object << ") on destroy."; // When model is destroyed, safely disconnect-it from controller // if no previous call to SetModel( NULL ) has been made from // client. // // N.B.: This is quite equivalent to SetModel( NULL ) but is // quite bit faster. private_Disconnect( m_Model ); #endif } } /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdApplicationLauncher.cxx000066400000000000000000000160571301006202600304300ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdApplicationLauncher.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbWrapperApplicationRegistry.h" #include "otbWrapperApplication.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdI18nCoreApplication.h" //#include "mvdTextStream.h" #include "mvdQtWidgetView.h" namespace mvd { /* TRANSLATOR mvd::ApplicationLauncher Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ApplicationLauncher ::ApplicationLauncher( QObject* p ) : QObject( p ) { } /*******************************************************************************/ ApplicationLauncher ::~ApplicationLauncher() { } /*******************************************************************************/ Wrapper::QtWidgetView * ApplicationLauncher ::NewOtbApplicationWidget( const QString & appName, bool isStandalone, QWidget * p, Qt::WindowFlags flags ) const { // Create module otb::Wrapper::Application::Pointer otbApp( otb::Wrapper::ApplicationRegistry::CreateApplication( ToStdString( appName ) ) ); if( otbApp.IsNull() ) { throw std::runtime_error( ToStdString( tr( "Failed to instantiate OTB-application '%1'." ) .arg( appName ) ) ); } if( !isStandalone ) { // Search for elev parameters typedef std::vector< std::string > ParametersKeys; const ParametersKeys parameters( otbApp->GetParametersKeys() ); // Little flag structure with bool operator to optimize look // scanning parameter keys. struct Flags { Flags() : m_HasDem( false ), m_HasGeoid( false ) { } inline operator bool () const { return m_HasDem && m_HasGeoid; } bool m_HasDem : 1; bool m_HasGeoid : 1; }; Flags found; for( ParametersKeys::const_iterator it( parameters.begin() ); it!=parameters.end() && !found; ++it ) { std::size_t lastDot = it->find_last_of('.'); assert( I18nCoreApplication::ConstInstance()!=NULL ); const I18nCoreApplication* i18nApp = I18nCoreApplication::ConstInstance(); if( lastDot != std::string::npos ) { std::string lastKey( it->substr( lastDot + 1, it->size() - lastDot - 1 ) ); if( lastKey=="dem" ) { found.m_HasDem = true; if( i18nApp->HasSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE ) && i18nApp->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR_ACTIVE ).toBool() ) { otbApp->EnableParameter( *it ); otbApp->SetParameterString( *it, ToStdString( i18nApp->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_SRTM_DIR ) .toString() ) ); } } else if( lastKey=="geoid" ) { found.m_HasGeoid = true; if( i18nApp->HasSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE ) && i18nApp->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH_ACTIVE ) .toBool() ) { otbApp->EnableParameter( *it ); otbApp->SetParameterString( *it, ToStdString( i18nApp->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_GEOID_PATH ) .toString() ) ); } } } } } // Create GUI based on module Wrapper::QtWidgetView * gui = new Wrapper::QtWidgetView( otbApp, p, flags ); gui->CreateGui(); return gui; } /*******************************************************************************/ QWidget * ApplicationLauncher ::NewOtbApplicationWindow( const QString & appName, bool isStandalone, QWidget * p, Qt::WindowFlags flags ) const { #if 0 Wrapper::QtWidgetView * appWidget = ApplicationLauncher::NewOtbApplicationWidget( appName, isStandalone ); assert( appWidget!=NULL ); assert( appWidget->GetApplication() ); QMainWindow * mainWindow = new QMainWindow( p, flags ); mainWindow->setWindowTitle( QString( "%1 (OTB-" OTB_VERSION_STRING ")" ) .arg( appWidget->GetApplication()->GetDocName() ) ); mainWindow->setWindowIcon( QIcon( ":/otb_small.png" ) ); mainWindow->setCentralWidget( appWidget ); // Connect OTB-app widget quit signal, to the mainWindow close slot. QObject::connect( appWidget, SIGNAL( QuitSignal() ), // to: mainWindow, SLOT( close() ) ); return mainWindow; #else Wrapper::QtWidgetView * appWidget = ApplicationLauncher::NewOtbApplicationWidget( appName, isStandalone, p, flags | Qt::Window ); assert( appWidget!=NULL ); assert( appWidget->GetApplication() ); appWidget->setWindowTitle( QString( "%1 (OTB-" OTB_VERSION_STRING ")" ) .arg( appWidget->GetApplication()->GetDocName() ) ); appWidget->setWindowIcon( QIcon( ":/icons/process" ) ); QObject::connect( appWidget, SIGNAL( QuitSignal() ), // to: appWidget, SLOT( close() ) ); return appWidget; #endif } /*******************************************************************************/ /* SLOTS */ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdApplicationsToolBox.cxx000066400000000000000000000235111301006202600304310ustar00rootroot00000000000000 /*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdApplicationsToolBox.h" #include "ui_mvdApplicationsToolBox.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" namespace mvd { /* TRANSLATOR mvd::ApplicationsToolBox Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ enum COLUMN { COLUMN_NAME = 0, COLUMN_TITLE, // COLUMN_COUNT, }; enum ItemType { ITEM_TYPE_ROOT = 0, ITEM_TYPE_TAG, ITEM_TYPE_APPLICATION, // TYPE_COUNT, }; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ApplicationsToolBox ::ApplicationsToolBox( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::ApplicationsToolBox() ), m_AppTags(), m_AppsDocNameToNameMap(), m_SearchText() { m_UI->setupUi( this ); // // connect search box changed QObject::connect(m_UI->m_SearchLine, SIGNAL( textChanged(const QString &) ), this, SLOT( OnSearchBoxChanged(const QString &) ) ); // // connect double click on the tree Widget QObject::connect( m_UI->m_AlgorithmsTree, SIGNAL( itemDoubleClicked(QTreeWidgetItem* ,int) ), this, SLOT( OnAlgorithmTreeDoubleClick(QTreeWidgetItem* ,int) ) ); // put a place holder text in search area #if (QT_VERSION >= 0x407000) m_UI->m_SearchLine->setPlaceholderText( tr("Search Application ...") ); #endif } /*******************************************************************************/ ApplicationsToolBox ::~ApplicationsToolBox() { delete m_UI; m_UI = NULL; } /*******************************************************************************/ // QTreeWidget * // ApplicationsToolBox // ::GetAlgorithmsTree() // { // return m_UI->m_AlgorithmsTree; // } /*******************************************************************************/ void ApplicationsToolBox ::FillTreeUsingTags() { assert( m_UI->m_AlgorithmsTree!=NULL ); // // clear algorithms tree m_UI->m_AlgorithmsTree->clear(); if( m_AppTags.empty() ) return; // // main item (title) #if USE_ALGORITHM_ROOT_NODE QTreeWidgetItem * mainItem = new QTreeWidgetItem( m_UI->m_AlgorithmsTree, ITEM_TYPE_ROOT ); mainItem->setText( COLUMN_NAME, tr( "Orfeo Toolbox Algorithms" ) ); mainItem->setExpanded( !m_SearchText.isEmpty() ); mainItem->setFlags( Qt::NoItemFlags | Qt::ItemIsEnabled ); #endif // USE_ALGORITHME_ROOT_NODE QString search( m_SearchText.simplified() ); // // iterate on map: key as high-level item / algorithms as lower-level items for( ApplicationsTagContainer::const_iterator itTag( m_AppTags.begin() ); itTag!=m_AppTags.end(); ++itTag ) { // // current Doctag name QString qcurrentTag( (*itTag).first.c_str() ); // If a current tag applicaton name match the searchText, add the // tag as an item to the tree if (m_SearchText.isEmpty() || IsSearchTextMatchAnyAlgorithm( qcurrentTag, search ) || qcurrentTag.contains( search, Qt::CaseInsensitive ) ) { // // step #1 -> DocTag is a main item QTreeWidgetItem * cmainItem = new QTreeWidgetItem( #if USE_ALGORITHM_ROOT_NODE mainItem, #else // USE_ALGORITHM_ROOT_NODE m_UI->m_AlgorithmsTree, #endif // USE_ALGORITHM_ROOT_NODE ITEM_TYPE_TAG ); cmainItem->setText( COLUMN_NAME, qcurrentTag ); cmainItem->setExpanded( !m_SearchText.isEmpty() ); cmainItem->setFlags( Qt::NoItemFlags | Qt::ItemIsEnabled ); // // add category icon cmainItem->setIcon( COLUMN_NAME, QIcon( ":/icons/otb" ) ); // // step #2 -> Add algorithms name if matching the search label for( StringVector::const_iterator itApps( itTag->second.begin() ); itApps != itTag->second.end(); ++itApps ) { // get current app name QString name( itApps->c_str() ); // get current app DocName QString title( GetApplicationDocNameByApplicationName( name ) ); assert( !name.isEmpty() ); assert( !title.isEmpty() ); // does the current algorithm DocName match the search text if ( m_SearchText.isEmpty() || title.contains( search, Qt::CaseInsensitive ) || name.contains( search, Qt::CaseInsensitive ) ) { // // set current application name as secondary item QTreeWidgetItem * secItem = new QTreeWidgetItem( cmainItem, ITEM_TYPE_APPLICATION ); secItem->setText( COLUMN_NAME, name ); secItem->setText( COLUMN_TITLE, title ); secItem->setToolTip( COLUMN_NAME, title ); secItem->setIcon( COLUMN_NAME, QIcon( ":/icons/process" ) ); } } } } // Expand algorithms tree by default m_UI->m_AlgorithmsTree->expandAll(); m_UI->m_AlgorithmsTree->resizeColumnToContents( COLUMN_NAME ); m_UI->m_AlgorithmsTree->resizeColumnToContents( COLUMN_TITLE ); } /*******************************************************************************/ bool ApplicationsToolBox ::IsSearchTextMatchAnyAlgorithm( const QString & tagName, const QString & search ) { // find the pair corresponding to the tagName ApplicationsTagContainer::const_iterator itTag( m_AppTags.find( ToStdString( tagName ) ) ); if( itTag==m_AppTags.end() ) return false; for( StringVector::const_iterator itApps( itTag->second.begin() ); itApps != itTag->second.end(); ++itApps ) { QString name( FromStdString( *itApps ) ); if( name.contains( search, Qt::CaseInsensitive ) || GetApplicationDocNameByApplicationName( name ) .contains( search, Qt::CaseInsensitive ) ) return true; } return false; } /*******************************************************************************/ void ApplicationsToolBox ::LaunchApplication( const QString& appName ) { assert( !appName.isEmpty() ); emit ApplicationToLaunchSelected( appName, GetApplicationDocNameByApplicationName( appName ) ); } /*******************************************************************************/ QString ApplicationsToolBox ::GetApplicationDocNameByApplicationName( const QString & appName ) { QString docName(""); // find the pair corresponding to the tagName ApplicationDocNameToNameMap::const_iterator itDocNames = m_AppsDocNameToNameMap.begin(); while( itDocNames != m_AppsDocNameToNameMap.end() ) { // retrieve the appName in the map if ( appName == QString( (*itDocNames).second.c_str() ) ) { // // return the relative docName return QString ( (*itDocNames).first.c_str() ); } ++itDocNames; } return docName; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void ApplicationsToolBox ::OnAvailableApplicationsTagsChanged(const ApplicationsTagContainer& appsTags, const ApplicationDocNameToNameMap& docNameToNameMap) { // rememeber the map m_AppTags = appsTags; // remember the OTB applications docName <-> Name association m_AppsDocNameToNameMap = docNameToNameMap; // fill the tree with the application FillTreeUsingTags(); } /*******************************************************************************/ void ApplicationsToolBox ::OnSearchBoxChanged(const QString & search) { // // get the search text m_SearchText = search; // fill the tree with the application FillTreeUsingTags(); } /*******************************************************************************/ void ApplicationsToolBox ::OnAlgorithmTreeDoubleClick( QTreeWidgetItem * item , int column ) { // qDebug() << item << column; if( item->type()!=ITEM_TYPE_APPLICATION ) return; QString text( item->text( column ) ); if( text.isEmpty() ) return; switch( column ) { case COLUMN_NAME: break; case COLUMN_TITLE: { ApplicationDocNameToNameMap::const_iterator it( m_AppsDocNameToNameMap.find( ToStdString( text ) ) ); assert( it!=m_AppsDocNameToNameMap.end() ); assert( it->second.empty() ); text = FromStdString( it->second ); } break; default: assert( false && "Unexpected enum value." ); break; } LaunchApplication( text ); } /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdApplicationsToolBox.qrc000066400000000000000000000003571301006202600304170ustar00rootroot00000000000000 ../../../../Utilities/Data/Icons/alg.png ../../../../Utilities/Data/Icons/monteverdi-32x32.png OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdApplicationsToolBox.ui000066400000000000000000000032151301006202600302430ustar00rootroot00000000000000 mvd::ApplicationsToolBox 0 0 363 116 0 0 OTB Applications 3 2 Qt::CustomContextMenu false true true Name Title OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdApplicationsToolBoxController.cxx000066400000000000000000000112611301006202600324740ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdApplicationsToolBoxController.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) // #include "mvdTypes.h" // #include "mvdApplicationsToolBox.h" // #include "mvdApplicationLauncher.h" #include "mvdApplicationsBrowser.h" #include "mvdOTBApplicationsModel.h" namespace mvd { /* TRANSLATOR mvd::ApplicationsToolBoxController Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ApplicationsToolBoxController ::ApplicationsToolBoxController( ApplicationsToolBox* widget, QObject* p ) : AbstractModelController( widget, p ) { } /*******************************************************************************/ ApplicationsToolBoxController ::~ApplicationsToolBoxController() { } /*******************************************************************************/ void ApplicationsToolBoxController ::Connect( AbstractModel* model ) { // // Access widget ApplicationsToolBox* widget = GetWidget< ApplicationsToolBox >(); // // Access model. OTBApplicationsModel* appModel = qobject_cast< OTBApplicationsModel* >(model); assert( appModel!=NULL ); // // connections QObject::connect( appModel->GetBrowser(), SIGNAL( AvailableApplicationsTagsChanged( const ApplicationsTagContainer&, const ApplicationDocNameToNameMap& ) ), widget, SLOT( OnAvailableApplicationsTagsChanged( const ApplicationsTagContainer&, const ApplicationDocNameToNameMap& ) ) ); } /*******************************************************************************/ void ApplicationsToolBoxController ::Disconnect( AbstractModel* model ) { // // Access widget ApplicationsToolBox* widget = GetWidget< ApplicationsToolBox >(); // // Access model. OTBApplicationsModel* appModel = qobject_cast< OTBApplicationsModel* >(model); assert( appModel!=NULL ); // // disconnect app browser QObject::disconnect( appModel->GetBrowser(), SIGNAL( AvailableApplicationsTagsChanged( const ApplicationsTagContainer&, const ApplicationDocNameToNameMap& ) ), widget, SLOT( OnAvailableApplicationsTagsChanged( const ApplicationsTagContainer&, const ApplicationDocNameToNameMap& ) ) ); } /*******************************************************************************/ void ApplicationsToolBoxController ::ClearWidget() { } /*******************************************************************************/ void ApplicationsToolBoxController ::virtual_ResetWidget( bool ) { // Reset widget. ResetDatasetTree(); // NOTE : no signal to emit here. Done in the class ApplicationsBrowser // aggregated in the model } /*******************************************************************************/ void ApplicationsToolBoxController ::ResetDatasetTree() { // // Access model. OTBApplicationsModel* model = GetModel< OTBApplicationsModel >(); assert( model!=NULL ); // // Fill the widget. It also reset the datatree before filling the // tree... model->FillTree(); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorBandDynamicsWidget.cxx000066400000000000000000000232441301006202600311760ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdColorBandDynamicsWidget.h" #include "ui_mvdColorBandDynamicsWidget.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdDoubleValidator.h" // Used for QString::number() calls. By default, QString::number() // uses a 6 digit precision. #define MAX_SIGNIFICANT_DIGITS 17 namespace mvd { /* TRANSLATOR mvd::ColorBandDynamicsWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*******************************************************************************/ ColorBandDynamicsWidget ::ColorBandDynamicsWidget( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::ColorBandDynamicsWidget() ), m_LowIntensityValidator( NULL ), m_HighIntensityValidator( NULL ), m_Channel( RGBW_CHANNEL_RGB ) { m_UI->setupUi( this ); m_LowIntensityValidator = new DoubleValidator( m_UI->lowIntensityLineEdit ); m_UI->lowIntensityLineEdit->setValidator( m_LowIntensityValidator ); m_HighIntensityValidator = new DoubleValidator( m_UI->highIntensityLineEdit ); m_UI->highIntensityLineEdit->setValidator( m_HighIntensityValidator ); } /*******************************************************************************/ ColorBandDynamicsWidget ::~ColorBandDynamicsWidget() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ double ColorBandDynamicsWidget ::GetMinIntensity() const { return m_UI->lowIntensityLineEdit->text().toDouble(); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetMinIntensity( double value ) { m_LowIntensityValidator->setBottom( value ); m_HighIntensityValidator->setBottom( value ); } /*****************************************************************************/ double ColorBandDynamicsWidget ::GetMaxIntensity() const { return m_LowIntensityValidator->bottom(); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetMaxIntensity( double value ) { m_LowIntensityValidator->setTop( value ); m_HighIntensityValidator->setTop( value ); } /*****************************************************************************/ double ColorBandDynamicsWidget ::GetLowIntensity() const { return m_HighIntensityValidator->top(); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetLowIntensity( double value ) { // qDebug() << this << "::SetLowIntensity(" << value << ")"; QString number( QString::number( value, 'g', MAX_SIGNIFICANT_DIGITS ) ); assert( !number.isEmpty() ); m_UI->lowIntensityLineEdit->setText( number ); m_UI->lowIntensityLineEdit->setCursorPosition( 0 ); } /*****************************************************************************/ double ColorBandDynamicsWidget ::GetHighIntensity() const { return m_UI->highIntensityLineEdit->text().toDouble(); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetHighIntensity( double value ) { // qDebug() << this << "::SetHighIntensity(" << value << ")"; QString number( QString::number( value, 'g', MAX_SIGNIFICANT_DIGITS ) ); assert( !number.isEmpty() ); m_UI->highIntensityLineEdit->setText( number ); m_UI->highIntensityLineEdit->setCursorPosition( 0 ); } /*****************************************************************************/ double ColorBandDynamicsWidget ::GetLowQuantile() const { return m_UI->lowQuantileSpinBox->value(); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetLowQuantile( double value ) { m_UI->lowQuantileSpinBox->setValue( value ); } /*****************************************************************************/ double ColorBandDynamicsWidget ::GetHighQuantile() const { return m_UI->highQuantileSpinBox->value(); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetHighQuantile( double value ) { m_UI->highQuantileSpinBox->setValue( value ); } /*****************************************************************************/ bool ColorBandDynamicsWidget ::IsBounded() const { return m_UI->linkButton->isChecked(); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetBounded( bool enabled ) { return m_UI->linkButton->setChecked( enabled ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetLinkButtonEnabled( bool enabled ) { return m_UI->linkButton->setEnabled( enabled ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetDefaultsButtonEnabled( bool enabled ) { return m_UI->defaultsButton->setEnabled( enabled ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::SetChannelLabel( RgbwChannel channel ) { m_Channel = channel; m_UI->rLabel->setVisible( channel==RGBW_CHANNEL_RED || channel==RGBW_CHANNEL_RGB || channel==RGBW_CHANNEL_ALL ); m_UI->gLabel->setVisible( channel==RGBW_CHANNEL_GREEN || channel==RGBW_CHANNEL_RGB || channel==RGBW_CHANNEL_ALL ); m_UI->bLabel->setVisible( channel==RGBW_CHANNEL_BLUE || channel==RGBW_CHANNEL_RGB || channel==RGBW_CHANNEL_ALL ); m_UI->wLabel->setVisible( channel==RGBW_CHANNEL_WHITE ); m_UI->applyAllButton->setEnabled( channel==RGBW_CHANNEL_RED || channel==RGBW_CHANNEL_GREEN || channel==RGBW_CHANNEL_BLUE || channel==RGBW_CHANNEL_RGB ); } /*****************************************************************************/ RgbwChannel ColorBandDynamicsWidget ::GetChannelLabel() const { return m_Channel; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void ColorBandDynamicsWidget ::on_lowIntensityLineEdit_editingFinished() { // qDebug() << this << "::on_lowIntensityLineEdit_editingFinished()"; assert( m_UI!=NULL ); assert( m_UI->lowIntensityLineEdit!=NULL ); bool isOk = true; double value = m_UI->lowIntensityLineEdit->text().toDouble( &isOk ); if( !isOk ) { #if 0 throw std::invalid_argument( ToStdString( tr( "Invalid argument '%1'." ).arg( text ) ) ); #else return; #endif } emit LowIntensityChanged( m_Channel, value ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::on_highIntensityLineEdit_editingFinished() { // qDebug() << this << "::on_highIntensityLineEdit_editingFinished()"; assert( m_UI!=NULL ); assert( m_UI->highIntensityLineEdit!=NULL ); bool isOk = true; double value = m_UI->highIntensityLineEdit->text().toDouble( &isOk ); if( !isOk ) { #if 0 throw std::invalid_argument( ToStdString( tr( "Invalid argument '%1'." ).arg( text ) ) ); #else return; #endif } emit HighIntensityChanged( m_Channel, value ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::on_lowQuantileSpinBox_valueChanged( double value ) { emit LowQuantileChanged( m_Channel, value ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::on_highQuantileSpinBox_valueChanged( double value ) { emit HighQuantileChanged( m_Channel, value ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::on_minMaxButton_clicked() { emit ResetIntensityClicked( m_Channel ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::on_defaultsButton_clicked() { emit ResetQuantileClicked( m_Channel ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::on_applyAllButton_clicked() { emit ApplyAllClicked( m_Channel, m_UI->lowQuantileSpinBox->value(), m_UI->highQuantileSpinBox->value() ); } /*****************************************************************************/ void ColorBandDynamicsWidget ::on_linkButton_toggled( bool checked ) { /* if( checked ) { QString text( m_UI->lowIntensityLineEdit->text() ); m_LowIntensityValidator->fixup( text ); m_UI->lowIntensityLineEdit->setText( text ); text = m_UI->lowIntensityLineEdit->text(); m_HighIntensityValidator->fixup( text ); m_UI->highIntensityLineEdit->setText( text ); } */ emit LinkToggled( m_Channel, checked ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorBandDynamicsWidget.ui000066400000000000000000000327311301006202600310120ustar00rootroot00000000000000 mvd::ColorBandDynamicsWidget 0 0 270 88 0 0 Form QLayout::SetDefaultConstraint 3 2 0 0 Low Qt::AlignCenter 0 0 High Qt::AlignCenter 0 0 Quantile percentile. Q: Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter 0 0 Pixel value on band. V: Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter true 0 0 Percentage of the band histogram ending clipped to obtain higher intensity threshold. true % 100.000000000000000 0.100000000000000 2.000000000000000 0 0 60 0 0 QLayout::SetDefaultConstraint 0 0 Red channel. <span style="color:#000000;background-color:#FF4444">&nbsp;<b>R</b>&nbsp;</span> Qt::AlignCenter 0 0 Green channel. <span style="color:#000000;background-color:#44FF44">&nbsp;<b>G</b>&nbsp;</span> Qt::AlignCenter 0 0 Blue channel. <span style="color:#CCCCCC;background-color:#4444FF">&nbsp;<b>B</b>&nbsp;</span> Qt::AlignCenter 0 0 White (gray) channel. <span style="color:#EEEEEE;background-color:#111111">&nbsp;<b>W</b>&nbsp;</span> Qt::AlignCenter true 0 0 Percentage of the band histogram beginning clipped to obtain lower intensity threshold. true % 100.000000000000000 0.100000000000000 2.000000000000000 3 QLayout::SetDefaultConstraint <p>&lceil;</p> Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter 0 0 true false :/icons/Utilities/Data/Icons/unlocked.png :/icons/Utilities/Data/Icons/locked.png:/icons/Utilities/Data/Icons/unlocked.png 12 12 true true true 0 0 Apply quantiles to all channels. :/icons/Data/Icons/execute.png:/icons/Data/Icons/execute.png 16 16 true 0 0 Set the intensity low and high thresholds to the minimum and maximum values of the current band. min/Max true 0 0 Reset to default quantiles. 2% 0 0 60 0 true lowQuantileSpinBox highQuantileSpinBox lowIntensityLineEdit highIntensityLineEdit applyAllButton minMaxButton defaultsButton linkButton toggled(bool) lowQuantileSpinBox setEnabled(bool) 19 70 107 71 linkButton toggled(bool) highQuantileSpinBox setEnabled(bool) 19 70 174 71 OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorDynamicsController.cxx000066400000000000000000001157241301006202600313160ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdColorDynamicsController.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdVectorImageModel.h" #include "mvdColorDynamicsWidget.h" namespace mvd { /* TRANSLATOR mvd::ColorDynamicsController Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ColorDynamicsController ::ColorDynamicsController( ColorDynamicsWidget* widget, QObject* p ) : AbstractModelController( widget, p ) { } /*****************************************************************************/ ColorDynamicsController ::~ColorDynamicsController() { } /*****************************************************************************/ void ColorDynamicsController ::Connect( AbstractModel* model ) { ColorDynamicsWidget* colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); // // Connect GUI to controller. QObject::connect( colorDynamicsWidget, SIGNAL( LowQuantileChanged( RgbwChannel, double ) ), // to: this, SLOT( OnLowQuantileChanged( RgbwChannel, double ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( HighQuantileChanged( RgbwChannel, double ) ), // to: this, SLOT( OnHighQuantileChanged( RgbwChannel, double ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( LowIntensityChanged( RgbwChannel, double ) ), // to: this, SLOT( OnLowIntensityChanged( RgbwChannel, double ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( HighIntensityChanged( RgbwChannel, double ) ), // to: this, SLOT( OnHighIntensityChanged( RgbwChannel, double ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( ResetQuantileClicked( RgbwChannel ) ), // to: this, SLOT( OnResetQuantileClicked( RgbwChannel ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( ResetIntensityClicked( RgbwChannel ) ), // to: this, SLOT( OnResetIntensityClicked( RgbwChannel ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( ApplyAllClicked( RgbwChannel, double, double ) ), // to: this, SLOT( OnApplyAllClicked( RgbwChannel, double, double ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( LinkToggled( RgbwChannel, bool ) ), // to: this, SLOT( OnLinkToggled( RgbwChannel, bool ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( NoDataFlagToggled( bool ) ), // to: this, SLOT( OnNoDataFlagToggled( bool ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( NoDataValueChanged( double ) ), // to: this, SLOT( OnNoDataValueChanged( double ) ) ); QObject::connect( colorDynamicsWidget, SIGNAL( NoDataButtonPressed() ), // to: this, SLOT( RefreshHistogram() ) ); QObject::connect( colorDynamicsWidget, SIGNAL(GammaValueChanged( double ) ), // to: this, SLOT( OnGammaValueChanged( double )) ); // // Connect controller to model. QObject::connect( this, SIGNAL( ModelUpdated() ), // to: model, SLOT( OnModelUpdated() ) ); } /*****************************************************************************/ void ColorDynamicsController ::virtual_ResetWidget( bool isSettingModel ) { // // Reset color-dynamics widget mode (grayscale/RGB). assert( GetModel()!=NULL && GetModel()==GetModel< VectorImageModel >() ); const VectorImageModel* model = GetModel< VectorImageModel >(); assert( GetWidget()!=NULL && GetWidget()==GetWidget< ColorDynamicsWidget >() ); ColorDynamicsWidget* widget = GetWidget< ColorDynamicsWidget >(); widget->SetGrayscaleActivated( model->GetSettings().IsGrayscaleActivated() ); RgbwChannel channels = RGBW_CHANNEL_ALL; /* model->GetSettings().IsGrayscaleActivated() ? RGBW_CHANNEL_WHITE : RGBW_CHANNEL_RGB; */ // // Reset color-dynamics widget. // Set constrained editing ON/OFF. // (must be called before settings intensity/quantiles) SetBoundsEnabled( channels, isSettingModel ); // Set ranges. ResetIntensityRanges( channels ); // Set intensities based on applied quantiles (restoring // dataset-descriptor settings). SetIntensities( channels ); // Setup no-data state. SetNoData(); SetGamma(); } /*****************************************************************************/ void ColorDynamicsController ::ClearWidget() { // qDebug() << this << "::ClearWidget()"; assert( GetWidget()!=NULL && GetWidget()==GetWidget< ColorDynamicsWidget >() ); ColorDynamicsWidget* widget = GetWidget< ColorDynamicsWidget >(); widget->SetGrayscaleActivated( true ); CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, RGBW_CHANNEL_ALL ) ) return; // Block this controller's signals to prevent display refreshes // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { for( CountType i=begin; i( i ); ColorBandDynamicsWidget* colorBandDynWgt = widget->GetChannel( channel ); // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { colorBandDynWgt->SetBounded( true ); colorBandDynWgt->SetLinkButtonEnabled( true ); colorBandDynWgt->SetMinIntensity( 0.0 ); colorBandDynWgt->SetMaxIntensity( 1.0 ); colorBandDynWgt->SetLowIntensity( 0.0 ); colorBandDynWgt->SetHighIntensity( 1.0 ); colorBandDynWgt->SetLowQuantile( 2.0 ); colorBandDynWgt->SetHighQuantile( 2.0 ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } } this->blockSignals( thisSignalsBlocked ); } /*****************************************************************************/ void ColorDynamicsController ::Disconnect( AbstractModel* model ) { ColorDynamicsWidget* colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); // // Disconnect controller to model. QObject::disconnect( this, SIGNAL( ModelUpdated() ), // to: model, SLOT( OnModelUpdated() ) ); // // Disconnect GUI from controller. QObject::disconnect( colorDynamicsWidget, SIGNAL( LowQuantileChanged( RgbwChannel, double ) ), // from: this, SLOT( OnLowQuantileChanged( RgbwChannel, double ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( HighQuantileChanged( RgbwChannel, double ) ), // from: this, SLOT( OnHighQuantileChanged( RgbwChannel, double ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( LowIntensityChanged( RgbwChannel, double ) ), // from: this, SLOT( OnLowIntensityChanged( RgbwChannel, double ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( HighIntensityChanged( RgbwChannel, double ) ), // from: this, SLOT( OnHighIntensityChanged( RgbwChannel, double ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( ResetQuantileClicked( RgbwChannel ) ), // from: this, SLOT( OnResetQuantileClicked( RgbwChannel ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( ResetIntensityClicked( RgbwChannel ) ), // from: this, SLOT( OnResetIntensityClicked( RgbwChannel ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( ApplyAllClicked( RgbwChannel, double, double ) ), // from: this, SLOT( OnApplyAllClicked( RgbwChannel, double, double ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( LinkToggled( RgbwChannel, bool ) ), // to: this, SLOT( OnLinkToggled( RgbwChannel, bool ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( NoDataFlagToggled( bool ) ), // to: this, SLOT( OnNoDataFlagToggled( bool ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( NoDataValueChanged( double ) ), // to: this, SLOT( OnNoDataValueChanged( double ) ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( NoDataButtonPressed() ), // to: this, SLOT( RefreshHistogram() ) ); QObject::disconnect( colorDynamicsWidget, SIGNAL( GammaValueChanged( double ) ), // to: this, SLOT( OnGammaValueChanged( double ) ) ); } /*****************************************************************************/ void ColorDynamicsController ::ResetIntensityRanges( RgbwChannel channels ) { // Trace. // qDebug() // << this // << "::ResetIntensityRanges(" << RGBW_CHANNEL_NAMES[ channels ] << ")"; // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channels ) ) return; // // Access color-dynamics widget. ColorDynamicsWidget* colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); // // Access image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // // Access histogram from generic image-model. const HistogramModel * histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); // if( !histogramModel->IsValid() ) // return; // Get min/max pixels. DefaultImageType::PixelType minPx( histogramModel->GetMinPixel() ); DefaultImageType::PixelType maxPx( histogramModel->GetMaxPixel() ); // Get image rengering settings. const VectorImageSettings & settings = imageModel->GetSettings(); // Block this controller's signals to prevent display refreshes // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { for( CountType i=begin; i( i ); ColorBandDynamicsWidget* colorBandDynWgt = colorDynamicsWidget->GetChannel( channel ); assert( std::numeric_limits< DefaultImageType::PixelType::ValueType >::has_infinity ); DefaultImageType::PixelType::ValueType min( -std::numeric_limits< DefaultImageType::PixelType::ValueType >::infinity() ); DefaultImageType::PixelType::ValueType max( +std::numeric_limits< DefaultImageType::PixelType::ValueType >::infinity() ); if( colorBandDynWgt->IsBounded() ) { min = minPx[ settings.GetRgbwChannel( channel ) ]; max = maxPx[ settings.GetRgbwChannel( channel ) ]; } // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Set min/max intensity bounds. colorBandDynWgt->SetMinIntensity( min ); colorBandDynWgt->SetMaxIntensity( max ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } } this->blockSignals( thisSignalsBlocked ); } /*****************************************************************************/ void ColorDynamicsController ::ResetIntensities( RgbwChannel channels ) { // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channels ) ) return; // // Access color-dynamics widget. ColorDynamicsWidget* colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); // // Access image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // // Access histogram from generic image-model. const HistogramModel* histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); // Get min/max pixels. DefaultImageType::PixelType minPx( histogramModel->GetMinPixel() ); DefaultImageType::PixelType maxPx( histogramModel->GetMaxPixel() ); // Get image rengering settings. const VectorImageSettings & settings = imageModel->GetSettings(); // Assign values to controlled widget. for( CountType i=begin; i( i ); ColorBandDynamicsWidget* colorBandDynWgt = colorDynamicsWidget->GetChannel( channel ); DefaultImageType::PixelType::ValueType min( minPx[ settings.GetRgbwChannel( channel ) ] ); DefaultImageType::PixelType::ValueType max( maxPx[ settings.GetRgbwChannel( channel ) ] ); // Block this controller's signals to prevent display refreshes // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocks = this->blockSignals( true ); { // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Set low & high intensities. colorBandDynWgt->SetLowIntensity( min ); OnLowIntensityChanged( channel, min ); colorBandDynWgt->SetHighIntensity( max ); OnHighIntensityChanged( channel, max ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } this->blockSignals( thisSignalsBlocks ); emit LowIntensityChanged( channel, min, false ); emit HighIntensityChanged( channel, max, false ); } } /*****************************************************************************/ void ColorDynamicsController ::SetIntensities( RgbwChannel channels ) { // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channels ) ) return; // // Access color-dynamics widget. ColorDynamicsWidget* colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); // // Access image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Get image rengering settings. const VectorImageSettings & settings = imageModel->GetSettings(); // Assign values to controlled widget. for( CountType i=begin; i( i ); ColorBandDynamicsWidget* colorBandDynWgt = colorDynamicsWidget->GetChannel( channel ); ParametersType::ValueType low = settings.GetLowIntensity( channel ); ParametersType::ValueType hi = settings.GetHighIntensity( channel ); // Block this controller's signals to prevent display refreshes // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Set low & high intensities. colorBandDynWgt->SetLowIntensity( low ); OnLowIntensityChanged( channel, low ); colorBandDynWgt->SetHighIntensity( hi ); OnHighIntensityChanged( channel, hi ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } this->blockSignals( thisSignalsBlocked ); emit LowIntensityChanged( channel, low, true ); emit HighIntensityChanged( channel, hi, true ); } } /*****************************************************************************/ void ColorDynamicsController ::SetNoData() { assert( GetModel()==GetModel< VectorImageModel >() ); const VectorImageModel* imageModel = GetModel< VectorImageModel >(); if( imageModel==NULL ) return; const ImageProperties* imageProperties = imageModel->GetProperties(); assert( imageProperties!=NULL ); assert( GetWidget()==GetWidget< ColorDynamicsWidget >() ); ColorDynamicsWidget* widget = GetWidget< ColorDynamicsWidget >(); assert( widget!=NULL ); bool thisSignalsBlocked = this->blockSignals( true ); { bool widgetSignalsBlocked = widget->blockSignals( true ); { widget->SetNoDataButtonChecked( true ); widget->SetNoDataChecked( imageProperties->IsNoDataEnabled() ); widget->SetNoDataValue( imageProperties->GetNoData() ); } widget->blockSignals( widgetSignalsBlocked ); } this->blockSignals( thisSignalsBlocked ); } /*****************************************************************************/ void ColorDynamicsController ::SetGamma() { assert( GetModel()==GetModel< VectorImageModel >() ); const VectorImageModel* imageModel = GetModel< VectorImageModel >(); if( imageModel==NULL ) return; assert( GetWidget()==GetWidget< ColorDynamicsWidget >() ); ColorDynamicsWidget* widget = GetWidget< ColorDynamicsWidget >(); assert( widget!=NULL ); bool thisSignalsBlocked = this->blockSignals( true ); { bool widgetSignalsBlocked = widget->blockSignals( true ); { widget->SetGamma( imageModel->GetSettings().GetGamma() ); } widget->blockSignals( widgetSignalsBlocked ); } this->blockSignals( thisSignalsBlocked ); } /*****************************************************************************/ void ColorDynamicsController ::SetBoundsEnabled( RgbwChannel channels, bool isSettingModel ) { // qDebug() // << this // << "::SetBoundsEnabled(" << channels << "," << isSettingModel << ")"; // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channels ) ) return; // // Access color-dynamics widget. ColorDynamicsWidget * colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); assert( colorDynamicsWidget!=NULL ); // // Access image-model. const VectorImageModel * imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // // Access histogram-model. const HistogramModel * histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); bool hasValidHistogram = histogramModel->IsValid() && !histogramModel->IsMonoValue(); // Block this controller's signals to prevent display refreshed // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { // Assign values to controlled widget. for( CountType i=begin; i( i ); ColorBandDynamicsWidget * colorBandDynWgt = colorDynamicsWidget->GetChannel( channel ); // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // MANTIS-1144: // // SetBoundsEnabled() must keep track of previous state because it // is also called (circular loop) when editing quantile and/or // intensity is finished. // // { colorBandDynWgt->SetBounded( ( !isSettingModel ? colorBandDynWgt->IsBounded() : true ) && hasValidHistogram ); // } colorBandDynWgt->SetLinkButtonEnabled( hasValidHistogram ); colorBandDynWgt->SetDefaultsButtonEnabled( hasValidHistogram ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } } this->blockSignals( thisSignalsBlocked ); } /*****************************************************************************/ void ColorDynamicsController ::ResetQuantiles( RgbwChannel channels ) { // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channels ) ) return; // // Access color-dynamics widget. ColorDynamicsWidget* colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); assert( colorDynamicsWidget!=NULL ); // Block this controller's signals to prevent display refreshed // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { // Assign values to controlled widget. for( CountType i=begin; i( i ); ColorBandDynamicsWidget * colorBandDynWgt = colorDynamicsWidget->GetChannel( channel ); // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { colorBandDynWgt->SetLowQuantile( 2.0 ); OnLowQuantileChanged( channel, 2.0 ); colorBandDynWgt->SetHighQuantile( 2.0 ); OnHighQuantileChanged( channel, 2.0 ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } } this->blockSignals( thisSignalsBlocked ); } /*****************************************************************************/ void ColorDynamicsController ::RestoreQuantiles( RgbwChannel channels ) { // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channels ) ) return; // // Access color-dynamics widget. ColorDynamicsWidget* colorDynamicsWidget = GetWidget< ColorDynamicsWidget >(); // Block this controller's signals to prevent display refreshed // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { // Assign values to controlled widget. for( CountType i=begin; i( i ); ColorBandDynamicsWidget* colorBandDynWgt = colorDynamicsWidget->GetChannel( channel ); // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { OnLowQuantileChanged( channel, colorBandDynWgt->GetLowQuantile() ); OnHighQuantileChanged( channel, colorBandDynWgt->GetHighQuantile() ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } } this->blockSignals( thisSignalsBlocked ); } /*****************************************************************************/ void ColorDynamicsController ::RefreshHistogram() { // Trace. // qDebug() // << this // << "::RefreshHistogram()"; // Get image-model. assert( GetModel()==GetModel< VectorImageModel>() ); VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Refresh histogram-model. imageModel->RefreshHistogram(); // Refresh color-dynamics. { assert( imageModel->GetHistogramModel()!=NULL ); SetBoundsEnabled( RGBW_CHANNEL_ALL, true ); if( imageModel->GetHistogramModel()->IsValid() ) ResetQuantiles( RGBW_CHANNEL_ALL ); else ResetIntensities( RGBW_CHANNEL_ALL ); } // Signal histogram has been refreshed. emit HistogramRefreshed(); // Signal model has been updated. emit ModelUpdated(); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void ColorDynamicsController ::OnRgbChannelIndexChanged( RgbwChannel channel, int ) { // qDebug() // << this // << "::OnRgbChannelIndexChanged(" // << RGBW_CHANNEL_NAMES[ channel ] << ", " << band << // ")"; // // Reset color-dynamics widget. ResetQuantiles( channel ); // Signal model has been updated. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnGrayChannelIndexChanged( int ) { // qDebug() // << this // << "::OnGrayChannelIndexChanged(" << band << ")"; // // Reset color-dynamics widget. ResetQuantiles( RGBW_CHANNEL_WHITE ); // Signal model has been updated. emit ModelUpdated(); } /*******************************************************************************/ void ColorDynamicsController ::OnGrayscaleActivated( bool activated ) { // qDebug() // << this // << "::OnGrayscaleActivated(" << activated << ")"; // // Toggle grayscale-mode activation-state of controlled widget. GetWidget< ColorDynamicsWidget >()->SetGrayscaleActivated( activated ); // // Reset color-dynamics widget. ResetQuantiles( activated ? RGBW_CHANNEL_WHITE : RGBW_CHANNEL_RGB ); // Signal model has been updated. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnLowQuantileChanged( RgbwChannel channel, double value ) { // qDebug() // << this // << "::OnLowQuantileChanged(" // << RGBW_CHANNEL_NAMES[ channel ] << ", " << value // << ")"; // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channel ) ) return; // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); const HistogramModel * histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); if( !histogramModel->IsValid() ) return; // Reference settings. VectorImageSettings & settings = imageModel->GetSettings(); // Get color-dynamics widgets. ColorDynamicsWidget* colorDynWgt = GetWidget< ColorDynamicsWidget >(); assert( colorDynWgt!=NULL ); // Update quantile intensity in model. for( CountType i=begin; i( i ); // Calculate quantile intensity. HistogramModel::MeasurementType intensity = histogramModel->Quantile( settings.GetRgbwChannel( chan ), 0.01 * value, BOUND_LOWER ); // Set intensity. settings.SetLowIntensity( chan, intensity ); // Access color-band widget. ColorBandDynamicsWidget* colorBandDynWgt = colorDynWgt->GetChannel( chan ); // check pointer. assert( colorBandDynWgt!=NULL ); // Block widget signals to prevent recursive signal/slot loops. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Refresh low-intensity display. colorBandDynWgt->SetLowIntensity( intensity ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); emit LowIntensityChanged( chan, intensity, true ); } // Signal model has been updated. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnHighQuantileChanged( RgbwChannel channel, double value ) { // qDebug() // << this // << "::OnHighQuantileChanged(" // << RGBW_CHANNEL_NAMES[ channel ] << ", " << value // << ")"; // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channel ) ) return; // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); const HistogramModel * histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); if( !histogramModel->IsValid() ) return; // Reference settings. VectorImageSettings & settings = imageModel->GetSettings(); // Get color-dynamics widgets. ColorDynamicsWidget* colorDynWgt = GetWidget< ColorDynamicsWidget >(); assert( colorDynWgt!=NULL ); // Update quantile intensity in model. for( CountType i=begin; i( i ); // Calculate quantile intensity. HistogramModel::MeasurementType intensity = histogramModel->Quantile( settings.GetRgbwChannel( chan ), 0.01 * value, BOUND_UPPER ); // Set intensity. settings.SetHighIntensity( chan, intensity ); // Access color-band widget. ColorBandDynamicsWidget* colorBandDynWgt = colorDynWgt->GetChannel( chan ); // check pointer. assert( colorBandDynWgt!=NULL ); // Block widget signals to prevent recursive signal/slot loops. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Refresh high-intensity display. colorBandDynWgt->SetHighIntensity( intensity ); } widgetSignalsBlocked = colorBandDynWgt->blockSignals( widgetSignalsBlocked ); emit HighIntensityChanged( chan, intensity, true ); } // Signal model has been updated. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnLowIntensityChanged( RgbwChannel channel, double value ) { // qDebug() // << this // << "::OnLowIntensityChanged(" // << RGBW_CHANNEL_NAMES[ channel ] << ", " << value // << ")"; // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channel ) ) return; // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); const HistogramModel * histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); // if( !histogramModel->IsValid() ) // return; // Get color-dynamics widgets. ColorDynamicsWidget* colorDynWgt = GetWidget< ColorDynamicsWidget >(); assert( colorDynWgt ); // Update parameter value. for( CountType i=begin; i( i ); imageModel->GetSettings().SetLowIntensity( chan, value ); ColorBandDynamicsWidget* colorBandDynWgt = colorDynWgt->GetChannel( chan ); if( colorBandDynWgt->IsBounded() && histogramModel->IsValid() ) { // Block widget signals to prevent recursive signal/slot loops. bool wgtSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Refresh quantile display. colorBandDynWgt->SetLowQuantile( 100.0 * histogramModel->Percentile( imageModel->GetSettings().GetRgbwChannel( chan ), value, BOUND_LOWER ) ); } wgtSignalsBlocked = colorBandDynWgt->blockSignals( wgtSignalsBlocked ); } emit LowIntensityChanged( chan, value, true ); } // Signal model has been updated. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnHighIntensityChanged( RgbwChannel channel, double value ) { // qDebug() // << this // << "::OnHighIntensityChanged(" // << RGBW_CHANNEL_NAMES[ channel ] << ", " << value // << ")"; // // Calculate loop bounds. Return if nothing to do. CountType begin = -1; CountType end = -1; if( !RgbwBounds( begin, end, channel ) ) return; // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); const HistogramModel * histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); // if( !histogramModel->IsValid() ) // return; // Get color-dynamics widgets. ColorDynamicsWidget* colorDynWgt = GetWidget< ColorDynamicsWidget >(); assert( colorDynWgt ); // Update parameter value. for( CountType i=begin; i( i ); imageModel->GetSettings().SetHighIntensity( chan, value ); ColorBandDynamicsWidget* colorBandDynWgt = colorDynWgt->GetChannel( chan ); if( colorBandDynWgt->IsBounded() && histogramModel->IsValid() ) { // Block widget signals to prevent recursive signal/slot loops. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Refresh quantile display. colorBandDynWgt->SetHighQuantile( 100.0 * imageModel->GetHistogramModel()->Percentile( imageModel->GetSettings().GetRgbwChannel( chan ), value, BOUND_UPPER ) ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); } emit HighIntensityChanged( chan, value, true ); } // Signal model has been updated. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnResetIntensityClicked( RgbwChannel channel ) { // qDebug() // << this // << "::OnResetIntensityClicked(" << RGBW_CHANNEL_NAMES[ channel ] << ")"; ResetIntensities( channel ); // Emit signal to force histogram refresh. emit HistogramRefreshed(); // Now, emit this controller's signal to cause display refresh. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnResetQuantileClicked( RgbwChannel channel ) { // qDebug() // << this // << "::OnResetQuantileChanged(" << RGBW_CHANNEL_NAMES[ channel ] << ")"; ResetQuantiles( channel ); // Emit signal to force histogram refresh. emit HistogramRefreshed(); // Now, emit this controller's signal to cause display refresh. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnApplyAllClicked( RgbwChannel, double low, double high ) { // qDebug() // << this // << "::OnApplyAllChanged(" // << RGBW_CHANNEL_NAMES[ channel ] << "," << low << "," << high << ")"; // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); const HistogramModel * histogramModel = imageModel->GetHistogramModel(); assert( histogramModel!=NULL ); if( !histogramModel->IsValid() ) return; // Reference settings. VectorImageSettings & settings = imageModel->GetSettings(); CountType begin; CountType end; if( !RgbBounds( begin, end, settings.IsGrayscaleActivated() ? RGBW_CHANNEL_WHITE : RGBW_CHANNEL_RGB ) ) return; // Get color-dynamics widgets. ColorDynamicsWidget* colorDynWgt = GetWidget< ColorDynamicsWidget >(); assert( colorDynWgt!=NULL ); for( CountType i=begin; i( i ); VectorImageSettings::ChannelVector::value_type band( settings.GetRgbwChannel( chan ) ); HistogramModel::MeasurementType lintensity = histogramModel->Quantile( band, 0.01 * low, BOUND_LOWER ); // Calculate quantile intensity. HistogramModel::MeasurementType uintensity = histogramModel->Quantile( band, 0.01 * high, BOUND_UPPER ); // Update quantile intensity in model. settings.SetLowIntensity( chan, lintensity ); settings.SetHighIntensity( chan, uintensity ); ColorBandDynamicsWidget* colorBandDynWgt = colorDynWgt->GetChannel( chan ); assert( colorBandDynWgt!=NULL ); // Block widget signals to prevent recursive signal/slot loops. bool widgetSignalsBlocked = colorBandDynWgt->blockSignals( true ); { // Refresh intensities display. // TODO: Remove SetLow/HighIntensity(): overwrite by SetLow/HighQuantiles(). colorBandDynWgt->SetHighIntensity( uintensity ); colorBandDynWgt->SetLowIntensity( lintensity ); // Regresh quantile display. colorBandDynWgt->SetLowQuantile( low ); colorBandDynWgt->SetHighQuantile( high ); } colorBandDynWgt->blockSignals( widgetSignalsBlocked ); emit LowIntensityChanged( chan, lintensity, false ); emit HighIntensityChanged( chan, uintensity, false ); } // Force histogram refresh. emit HistogramRefreshed(); // Now, emit this controller's signal to cause display refresh. emit ModelUpdated(); } /*****************************************************************************/ void ColorDynamicsController ::OnNoDataFlagToggled( bool enabled ) { // Trace. // qDebug() // << this // << "::OnNoDataFlagToggled(" << enabled << ")"; // Get image-model. assert( GetModel()==GetModel< VectorImageModel>() ); VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Reference settings. ImageProperties* properties = imageModel->GetProperties(); // Get color-dynamics widgets. assert( GetWidget()==GetWidget< ColorDynamicsWidget >() ); ColorDynamicsWidget* colorDynWgt = GetWidget< ColorDynamicsWidget >(); assert( colorDynWgt!=NULL ); // Store property. // properties->SetNoDataEnabled( colorDynWgt->IsNoDataChecked() ); properties->SetNoDataEnabled( enabled ); // colorDynWgt->SetNoDataButtonChecked( false ); } /*****************************************************************************/ void ColorDynamicsController ::OnNoDataValueChanged( double value ) { // Trace. // qDebug() // << this // << "::OnNoDataValueChanged(" << value << ")"; // Get image-model. assert( GetModel()==GetModel< VectorImageModel>() ); VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Reference settings. ImageProperties* properties = imageModel->GetProperties(); // Get color-dynamics widgets. assert( GetWidget()==GetWidget< ColorDynamicsWidget >() ); ColorDynamicsWidget* colorDynWgt = GetWidget< ColorDynamicsWidget >(); assert( colorDynWgt!=NULL ); // Store property. // properties->SetNoData( colorDynWgt->GetNoDataValue() ); properties->SetNoData( value ); // colorDynWgt->SetNoDataButtonChecked( false ); } /*****************************************************************************/ void ColorDynamicsController ::OnLinkToggled( RgbwChannel channel, bool checked ) { // Trace. // qDebug() // << this // << "::OnLinkToggled(" // << RGBW_CHANNEL_NAMES[ channel ] << ", " << checked // << ")"; ResetIntensityRanges( channel ); if( checked ) { RestoreQuantiles( channel ); emit ModelUpdated(); } } /*****************************************************************************/ void ColorDynamicsController ::OnGammaValueChanged( double value ) { // qDebug() // << this // << "::OnGammaValueChanged(" // << value // <<")"; // Get image-model. assert( GetModel()==GetModel< VectorImageModel>() ); VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Get widget. // assert( GetWidget()==GetWidget< ColorDynamicsWidget >() ); // ColorDynamicsWidget* widget = GetWidget< ColorDynamicsWidget >(); // assert( widget!=NULL ); // Store gamma into settings. // imageModel->GetSettings().SetGamma( widget->GetGamma() ); imageModel->GetSettings().SetGamma( value ); // Emit refresh signal. emit ModelUpdated(); } /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorDynamicsWidget.cxx000066400000000000000000000252451301006202600304140ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdColorDynamicsWidget.h" #include "ui_mvdColorDynamicsWidget.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::ColorDynamicsWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ const char* ColorDynamicsWidget::COLOR_BAND_DYNAMICS_WIDGET_NAMES[] = { "redWidget", "greenWidget", "blueWidget", "whiteWidget" }; const double GAMMA_FACTOR = -0.25; const double GAMMA_POWER = 1.1; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ColorDynamicsWidget ::ColorDynamicsWidget( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::ColorDynamicsWidget() ), m_NoDataValidator( NULL ), m_IsGrayscaleActivated( false ) { // // Qt setup. m_UI->setupUi( this ); // // Colors. CountType begin; CountType end; RgbwBounds( begin, end, RGBW_CHANNEL_ALL ); for( CountType i=begin; i( i ) ); ConnectChild( GetChannel( channel ), channel ); } SetGrayscaleActivated( false ); // // No-data. m_NoDataValidator = new QDoubleValidator( m_UI->noDataLineEdit ); m_UI->noDataLineEdit->setValidator( m_NoDataValidator ); } /*******************************************************************************/ ColorDynamicsWidget ::~ColorDynamicsWidget() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ void ColorDynamicsWidget ::SetGrayscaleActivated( bool activated ) { m_IsGrayscaleActivated = activated; // // First, force WHITE channel to be invisible. // // Cause: prevent layout re-calculation to be resized taking RGB+W // into account when switching from grayscale-mode activated to // non-activated. if( !activated ) { GetChannel( RGBW_CHANNEL_WHITE )->setVisible( false ); } // // Then, show/hide relevant components. CountType begin; CountType end; RgbwBounds( begin, end, RGBW_CHANNEL_RGB ); for( CountType i=begin; i( i ) ); GetChannel( channel )->setVisible( !activated ); } GetChannel( RGBW_CHANNEL_WHITE )->setVisible( activated ); m_UI->bwLine->setVisible( false ); m_UI->rgLine->setVisible( !activated ); m_UI->gbLine->setVisible( !activated ); } /*******************************************************************************/ bool ColorDynamicsWidget ::IsNoDataChecked() const { return m_UI->noDataCheckBox->isChecked(); } /*******************************************************************************/ void ColorDynamicsWidget ::SetNoDataChecked( bool checked ) { m_UI->noDataCheckBox->setChecked( checked ); } /*******************************************************************************/ double ColorDynamicsWidget ::GetNoDataValue() const { bool isOk = true; double value = m_UI->noDataLineEdit->text().toDouble( &isOk ); if( !isOk ) { } return value; } /*******************************************************************************/ void ColorDynamicsWidget ::SetNoDataValue( double value ) { QString number( QString::number( value, 'g', m_NoDataValidator->decimals() ) ); m_UI->noDataLineEdit->setText( number ); } /*******************************************************************************/ void ColorDynamicsWidget ::SetGamma( double value ) { int gamma = itk::Math::Round< int, double >( vcl_log( value ) / (GAMMA_FACTOR * vcl_log( GAMMA_POWER ) ) ); int min = GetMinGamma(); if( gammamax ) gamma = max; // qDebug() << "::SetGamma(" << value << "): " << gamma; SetGammaCursorPosition( gamma ); } /*******************************************************************************/ double ColorDynamicsWidget ::GetGamma() const { // qDebug() << // "::GetGamma(" << GetGammaCursorPosition() << "): " << // vcl_pow( // GAMMA_POWER, // GAMMA_FACTOR * static_cast< double >( GetGammaCursorPosition() ) // ); return vcl_pow( GAMMA_POWER, GAMMA_FACTOR * static_cast< double >( GetGammaCursorPosition() ) ); } /*******************************************************************************/ void ColorDynamicsWidget ::SetGammaCursorPosition( int value ) { m_UI->gammaSlider->setValue( value ); } /*******************************************************************************/ int ColorDynamicsWidget ::GetGammaCursorPosition() const { return m_UI->gammaSlider->value(); } /*******************************************************************************/ void ColorDynamicsWidget ::SetMinGamma( int value ) { m_UI->gammaSlider->setMinimum( value ); } /*******************************************************************************/ int ColorDynamicsWidget ::GetMinGamma() const { return m_UI->gammaSlider->minimum(); } /*******************************************************************************/ void ColorDynamicsWidget ::SetMaxGamma( int value ) { m_UI->gammaSlider->setMaximum( value ); } /*******************************************************************************/ int ColorDynamicsWidget ::GetMaxGamma() const { return m_UI->gammaSlider->maximum(); } /*******************************************************************************/ void ColorDynamicsWidget ::SetGammaStep( int value ) { m_UI->gammaSlider->setPageStep( value ); } /*******************************************************************************/ int ColorDynamicsWidget ::GetGammaStep() const { return m_UI->gammaSlider->pageStep(); } /*******************************************************************************/ void ColorDynamicsWidget ::ConnectChild( ColorBandDynamicsWidget* child, RgbwChannel channel ) { child->SetChannelLabel( channel ); // // Concentrate and forward signals of each channels. QObject::connect( child, SIGNAL( LowQuantileChanged( RgbwChannel, double ) ), // TO: this, SIGNAL( LowQuantileChanged( RgbwChannel, double ) ) ); QObject::connect( child, SIGNAL( HighQuantileChanged( RgbwChannel, double ) ), // TO: this, SIGNAL( HighQuantileChanged( RgbwChannel, double ) ) ); QObject::connect( child, SIGNAL( LowIntensityChanged( RgbwChannel, double ) ), // TO: this, SIGNAL( LowIntensityChanged( RgbwChannel, double ) ) ); QObject::connect( child, SIGNAL( HighIntensityChanged( RgbwChannel, double ) ), // TO: this, SIGNAL( HighIntensityChanged( RgbwChannel, double ) ) ); QObject::connect( child, SIGNAL( ResetQuantileClicked( RgbwChannel ) ), // TO: this, SIGNAL( ResetQuantileClicked( RgbwChannel ) ) ); QObject::connect( child, SIGNAL( ResetIntensityClicked( RgbwChannel ) ), // TO: this, SIGNAL( ResetIntensityClicked( RgbwChannel ) ) ); QObject::connect( child, SIGNAL( ApplyAllClicked( RgbwChannel, double, double ) ), // TO: this, SIGNAL( ApplyAllClicked( RgbwChannel, double, double ) ) ); QObject::connect( child, SIGNAL( LinkToggled( RgbwChannel, bool ) ), // TO: this, SIGNAL( LinkToggled( RgbwChannel, bool ) ) ); } /*****************************************************************************/ /* PUBLIC SLOTS */ /*****************************************************************************/ void ColorDynamicsWidget ::SetNoDataButtonChecked( bool checked ) { if( checked ) { m_UI->noDataButton->setEnabled( false ); m_UI->noDataButton->setChecked( true ); // m_UI->noDataButton->setText( tr( "Done" ) ); } else { m_UI->noDataButton->setEnabled( true ); m_UI->noDataButton->setChecked( false ); // m_UI->noDataButton->setText( tr( "GO" ) ); } } /*******************************************************************************/ /* SLOTS */ /*****************************************************************************/ void ColorDynamicsWidget ::on_noDataCheckBox_toggled( bool enabled ) { emit NoDataFlagToggled( enabled ); } /*****************************************************************************/ void ColorDynamicsWidget ::on_noDataLineEdit_textChanged( const QString& text ) { bool isOk = true; double value = text.toDouble( &isOk ); if( !isOk ) { } emit NoDataValueChanged( value ); } /*****************************************************************************/ void ColorDynamicsWidget ::on_noDataButton_toggled( bool checked ) { bool thisSB = this->blockSignals( true ); { bool uiSB = m_UI->noDataButton->blockSignals( true ); { SetNoDataButtonChecked( checked ); } m_UI->noDataButton->blockSignals( uiSB ); } this->blockSignals( thisSB ); if( checked ) { emit NoDataButtonPressed(); } } /*****************************************************************************/ void ColorDynamicsWidget ::on_gammaSlider_valueChanged( int value ) { emit GammaCursorPositionChanged( value ); emit GammaValueChanged( GetGamma() ); //Display Gamma value as a tooltip when value changed QToolTip::showText(mapToGlobal(m_UI->gammaSlider->pos()),tr("Gamma: ") % QString::number(GetGamma()) ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorDynamicsWidget.ui000066400000000000000000000216561301006202600302310ustar00rootroot00000000000000 mvd::ColorDynamicsWidget 0 0 221 175 0 0 Form 0 0 QFrame::Panel QFrame::Raised 1 QLayout::SetDefaultConstraint 6 1 1 1 0 0 No data: false 0 0 true Apply true true 0 0 QFrame::Panel QFrame::Raised 0 0 Gamma: -50 100 1 1 0 Qt::Horizontal 0 0 QFrame::StyledPanel QFrame::Plain 1 QLayout::SetDefaultConstraint 1 0 0 0 0 0 0 Qt::Horizontal 0 0 0 0 Qt::Horizontal 0 0 0 0 Qt::Horizontal 0 0 0 0 Qt::Vertical 20 0 ColorBandDynamicsWidget QWidget
    mvdColorBandDynamicsWidget.h
    1     noDataCheckBox noDataLineEdit noDataButton noDataCheckBox toggled(bool) noDataLineEdit setEnabled(bool) 49 23 100 24     OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorSetupController.cxx000066400000000000000000000263771301006202600306540ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdColorSetupController.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdVectorImageModel.h" #include "mvdColorSetupWidget.h" namespace mvd { /* TRANSLATOR mvd::ColorSetupController Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ColorSetupController ::ColorSetupController( ColorSetupWidget* widget, QObject* p ) : AbstractModelController( widget, p ) { } /*******************************************************************************/ ColorSetupController ::~ColorSetupController() { } /*******************************************************************************/ void ColorSetupController ::Connect( AbstractModel* model ) { ColorSetupWidget* colorSetupWidget = GetWidget< ColorSetupWidget >(); // // Connect GUI to controller. QObject::connect( colorSetupWidget, SIGNAL( CurrentRgbIndexChanged( RgbwChannel, int ) ), // to: this, SLOT( OnCurrentRgbIndexChanged( RgbwChannel, int ) ) ); QObject::connect( colorSetupWidget, SIGNAL( CurrentGrayIndexChanged( int ) ), // to: this, SLOT( OnCurrentGrayIndexChanged( int ) ) ); QObject::connect( colorSetupWidget, SIGNAL( GrayscaleActivated( bool ) ), // to: this, SLOT( OnGrayscaleActivated( bool ) ) ); QObject::connect( colorSetupWidget, SIGNAL( AlphaValueChanged( double ) ), // to: this, SLOT( OnAlphaValueChanged( double ) ) ); // // Connect controller to model. QObject::connect( this, SIGNAL( ModelUpdated() ), // to: model, SLOT( OnModelUpdated() ) ); } /*******************************************************************************/ void ColorSetupController ::Disconnect( AbstractModel* model ) { ColorSetupWidget* colorSetupWidget = GetWidget< ColorSetupWidget >(); // // Disconnect controller to model. QObject::disconnect( this, SIGNAL( ModelUpdated() ), // from: model, SLOT( OnModelUpdated() ) ); // // Disconnect GUI from controller. QObject::disconnect( colorSetupWidget, SIGNAL( CurrentRgbIndexChanged( RgbwChannel, int ) ), // from: this, SLOT( OnCurrentRgbIndexChanged( RgbwChannel, int ) ) ); QObject::disconnect( colorSetupWidget, SIGNAL( CurrentGrayIndexChanged( int ) ), // from: this, SLOT( OnCurrentGrayIndexChanged( int ) ) ); QObject::disconnect( colorSetupWidget, SIGNAL( GrayscaleActivated( bool ) ), // from: this, SLOT( OnGrayscaleActivated( bool ) ) ); QObject::disconnect( colorSetupWidget, SIGNAL( AlphaValueChanged( double ) ), // from: this, SLOT( OnAlphaValueChanged( double ) ) ); } /*******************************************************************************/ void ColorSetupController ::ClearWidget() { // // Calculate loop bounds. Return if nothing to do. CountType begin = 0; CountType end = 0; if( !mvd::RgbwBounds( begin, end, RGBW_CHANNEL_ALL ) ) return; // // Access color-dynamics widget. ColorSetupWidget* colorSetupWidget = GetWidget< ColorSetupWidget >(); // Block this controller's signals to prevent display refreshes // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorSetupWidget->blockSignals( true ); { // Reset list of component names. colorSetupWidget->SetComponents( QStringList( tr( "BAND 0" ) ) ); // // RGBW-mode. // Reset current-indices of RGB channels widgets. for( CountType i=begin; i( i ); // Set current-index of channel. colorSetupWidget->SetCurrentRgbIndex( channel, 0 ); } // // Grayscale-mode. colorSetupWidget->SetGrayscaleActivated( true ); // Allow user-selectable grayscale-mode. colorSetupWidget->SetGrayscaleEnabled( false ); // Set current-index of white (gray). colorSetupWidget->SetCurrentGrayIndex( 0 ); // // Alpha colorSetupWidget->SetAlpha( 1.0 ); } colorSetupWidget->blockSignals( widgetSignalsBlocked ); } this->blockSignals( thisSignalsBlocked ); } /*******************************************************************************/ void ColorSetupController ::virtual_ResetWidget( bool ) { // Reset color-setup widget. ResetIndices( RGBW_CHANNEL_RGB ); // Reset alpha. ResetAlpha(); } /*******************************************************************************/ void ColorSetupController ::ResetIndices( RgbwChannel channels ) { // // Calculate loop bounds. Return if nothing to do. CountType begin = 0; CountType end = 0; if( !mvd::RgbBounds( begin, end, channels ) ) return; // // Access color-dynamics widget. ColorSetupWidget* colorSetupWidget = GetWidget< ColorSetupWidget >(); // // Access image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Block this controller's signals to prevent display refreshes // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorSetupWidget->blockSignals( true ); { // Reset list of component names. colorSetupWidget->SetComponents( imageModel->GetBandNames( true ) ); // // RGB-mode. // Reset current-indices of RGB channels widgets. for( CountType i=begin; i( i ); VectorImageSettings::ChannelVector::value_type band = imageModel->GetSettings().GetRgbChannel( i ); // Set current-index of channel. colorSetupWidget->SetCurrentRgbIndex( channel, band ); #if 0 OnCurrentRgbIndexChanged( channel, band ); #endif } // // Grayscale-mode. if( channels==RGBW_CHANNEL_RGB ) { // Activated grayscale-mode. colorSetupWidget->SetGrayscaleActivated( imageModel->GetSettings().IsGrayscaleActivated() ); // Allow user-selectable grayscale-mode. colorSetupWidget->SetGrayscaleEnabled( imageModel->GetNbComponents()>1 ); // Set current-index of white (gray). colorSetupWidget->SetCurrentGrayIndex( imageModel->GetSettings().GetGrayChannel() ); } } colorSetupWidget->blockSignals( widgetSignalsBlocked ); } this->blockSignals( thisSignalsBlocked ); } /*******************************************************************************/ void ColorSetupController ::ResetAlpha() { // // Access color-dynamics widget. ColorSetupWidget* colorSetupWidget = GetWidget< ColorSetupWidget >(); // // Access image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Block this controller's signals to prevent display refreshes // but let let widget(s) signal their changes so linked values // will be correctly updated. bool thisSignalsBlocked = this->blockSignals( true ); { // Block widget's signals... //...but force call to valueChanged() slot to force refresh. bool widgetSignalsBlocked = colorSetupWidget->blockSignals( true ); { colorSetupWidget->SetAlpha( imageModel->GetSettings().GetAlpha() ); } colorSetupWidget->blockSignals( widgetSignalsBlocked ); } this->blockSignals( thisSignalsBlocked ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void ColorSetupController ::OnCurrentRgbIndexChanged( RgbwChannel channel, int index ) { /* qDebug() << this << "::OnCurrentRgbIndexChanged(" << RGBW_CHANNEL_NAMES[ channel ] << ", " << index << ")"; */ // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Update channel index. imageModel->GetSettings().SetRgbChannel( channel, index ); // Signal band-index of RGB channel has changed to other // controllers. emit RgbChannelIndexChanged( channel, index ); // Signal model has been updated. emit ModelUpdated(); } /*******************************************************************************/ void ColorSetupController ::OnCurrentGrayIndexChanged( int index ) { // qDebug() << this << "::OnCurrentGrayIndexChanged(" << index << ")"; // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Update channel indices. imageModel->GetSettings().SetGrayChannel( index ); // Signal band-index of gray channel has changed to other // controllers. emit GrayChannelIndexChanged( index ); // Signal model has been updated. emit ModelUpdated(); } /*******************************************************************************/ void ColorSetupController ::OnGrayscaleActivated( bool activated ) { // qDebug() << this << "::OnGrayscaleActivated(" << activated << ")"; // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Change grayscale-mode activation state. imageModel->GetSettings().SetGrayscaleActivated( activated ); // Signal grayscale-mode activation-state has changed to other // controllers. emit GrayscaleActivated( activated ); // Signal model has been updated. emit ModelUpdated(); } /*******************************************************************************/ void ColorSetupController ::OnAlphaValueChanged( double alpha ) { // Get image-model. VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); // Change grayscale-mode activation state. imageModel->GetSettings().SetAlpha( alpha ); // Signal model has been updated. emit ModelUpdated(); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorSetupWidget.cxx000066400000000000000000000146651301006202600277510ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdColorSetupWidget.h" #include "ui_mvdColorSetupWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::ColorSetupWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { /** */ const char* QCOMBOBOX_NAMES[] = { "rComboBox", "gComboBox", "bComboBox", "wComboBox" }; } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ColorSetupWidget ::ColorSetupWidget( QWidget* p, Qt::WindowFlags flags ) : QWidget( p, flags ), m_UI( new mvd::Ui::ColorSetupWidget() ) { m_UI->setupUi( this ); } /*******************************************************************************/ ColorSetupWidget ::~ColorSetupWidget() { delete m_UI; m_UI = NULL; } /*******************************************************************************/ void ColorSetupWidget ::SetComponents( const QStringList& components ) { m_Components = components; m_UI->rComboBox->clear(); m_UI->gComboBox->clear(); m_UI->bComboBox->clear(); m_UI->wComboBox->clear(); QStringList itemTexts( components ); // TODO: Move to mvd::core::AbstractImageModel (see ENHANCED_BAND_NAMES[]). for( int i=0; irComboBox->addItems( itemTexts ); m_UI->gComboBox->addItems( itemTexts ); m_UI->bComboBox->addItems( itemTexts ); m_UI->wComboBox->addItems( itemTexts ); // Black screen. m_UI->rComboBox->setCurrentIndex( 0 ); m_UI->gComboBox->setCurrentIndex( 0 ); m_UI->bComboBox->setCurrentIndex( 0 ); m_UI->wComboBox->setCurrentIndex( 0 ); } /*******************************************************************************/ void ColorSetupWidget ::SetCurrentRgbIndex( RgbwChannel channel, int index ) { QComboBox* comboBox = findChild< QComboBox* >( QCOMBOBOX_NAMES[ channel ] ); comboBox->setCurrentIndex( index ); } /*******************************************************************************/ int ColorSetupWidget ::GetCurrentRgbIndex( RgbwChannel channel ) const { QComboBox* comboBox = findChild< QComboBox* >( QCOMBOBOX_NAMES[ channel ] ); return comboBox->currentIndex(); } /*****************************************************************************/ void ColorSetupWidget ::SetGrayscaleEnabled( bool enable ) { m_UI->wCheckBox->setEnabled( enable ); } /*****************************************************************************/ void ColorSetupWidget ::SetGrayscaleActivated( bool activated ) { m_UI->wCheckBox->setChecked( activated ); } /*******************************************************************************/ void ColorSetupWidget ::SetCurrentGrayIndex( int index ) { m_UI->wComboBox->setCurrentIndex( index ); } /*******************************************************************************/ int ColorSetupWidget ::GetCurrentGrayIndex() const { return m_UI->wComboBox->currentIndex(); } /*****************************************************************************/ void ColorSetupWidget ::SetAlpha( double value ) { assert( m_UI!=NULL ); m_UI->alphaSlider->setValue( FromAlpha( value ) ); } /*****************************************************************************/ double ColorSetupWidget ::GetAlpha() const { assert( m_UI!=NULL ); return ToAlpha( m_UI->alphaSlider->value() ); } /*****************************************************************************/ double ColorSetupWidget ::ToAlpha( int value ) const { assert( m_UI!=NULL ); return static_cast< double >( value - m_UI->alphaSlider->minimum() ) / static_cast< double >( m_UI->alphaSlider->maximum() - m_UI->alphaSlider->minimum() ); } /*******************************************************************************/ int ColorSetupWidget ::FromAlpha( double alpha ) const { assert( m_UI!=NULL ); if( alpha>=1.0 ) alpha = m_UI->alphaSlider->maximum(); else if( alpha<=0.0 ) alpha = m_UI->alphaSlider->minimum(); else alpha = static_cast< double >( m_UI->alphaSlider->minimum() ) + alpha * static_cast< double >( m_UI->alphaSlider->maximum() - m_UI->alphaSlider->minimum() ); return static_cast< int >( alpha ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void ColorSetupWidget ::on_alphaSlider_valueChanged( int value ) { // qDebug() << "on_alphaSlider_valueChanged(" << value << ")"; emit AlphaValueChanged( ToAlpha( value ) ); } /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdColorSetupWidget.ui000066400000000000000000000374571301006202600275700ustar00rootroot00000000000000 mvd::ColorSetupWidget 0 0 145 195 0 0 Form 1 1 Qt::Vertical QSizePolicy::Expanding 20 0 3 1 QLayout::SetMaximumSize false 0 0 White (gray) channel. <span style="color:#EEEEEE;background-color:#111111">&nbsp;<b>W</b>&nbsp;</span> false 0 0 <span><b>&larr;</b>&nbsp;</span> false 0 0 BAND 0 BAND 1 BAND 2 0 0 <html><head/><body><p align="center">Image bands<br/>↓</p></body></html> Qt::AlignCenter 1 QLayout::SetMaximumSize 0 0 Red channel. <span style="color:#000000;background-color:#FF4444">&nbsp;<b>R</b>&nbsp;</span> 0 0 <span><b>&larr;</b>&nbsp;</span> 0 0 BAND 0 BAND 1 BAND 2 1 QLayout::SetMaximumSize 0 0 Green channel. <span style="color:#000000;background-color:#44FF44">&nbsp;<b>G</b>&nbsp;</span> 0 0 <span><b>&larr;</b>&nbsp;</span> 0 0 BAND 0 BAND 1 BAND 2 1 QLayout::SetMaximumSize 0 0 Blue channel. <span style="color:#CCCCCC;background-color:#4444FF">&nbsp;<b>B</b>&nbsp;</span> 0 0 <span><b>&larr;</b>&nbsp;</span> 0 0 BAND 0 BAND 1 BAND 2 Enable/disable gray-scale mode. Alpha: 10000 500 10000 Qt::Horizontal QSlider::TicksBothSides 1000 Qt::Horizontal rComboBox gComboBox bComboBox wCheckBox wComboBox wCheckBox toggled(bool) wComboBox setEnabled(bool) 150 161 95 162 wCheckBox toggled(bool) wLeftArrow setEnabled(bool) 150 161 41 162 wCheckBox toggled(bool) wLabel setEnabled(bool) 150 161 19 162 wCheckBox toggled(bool) bLabel setDisabled(bool) 150 161 18 129 wCheckBox toggled(bool) bLeftArrow setDisabled(bool) 150 161 40 129 wCheckBox toggled(bool) bComboBox setDisabled(bool) 150 161 95 129 wCheckBox toggled(bool) gLabel setDisabled(bool) 150 161 19 96 wCheckBox toggled(bool) gLeftArrow setDisabled(bool) 150 161 41 96 wCheckBox toggled(bool) gComboBox setDisabled(bool) 150 161 95 96 wCheckBox toggled(bool) rLabel setDisabled(bool) 150 161 18 63 wCheckBox toggled(bool) rLeftArrow setDisabled(bool) 150 161 40 63 wCheckBox toggled(bool) rComboBox setDisabled(bool) 150 161 95 63 OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdDoubleValidator.cxx000066400000000000000000000061001301006202600275470ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdDoubleValidator.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::DoubleValidator Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ DoubleValidator ::DoubleValidator( QObject* p ) : QDoubleValidator( p ) { } /*******************************************************************************/ DoubleValidator ::DoubleValidator( double bottomVal, double topVal, int decim, QObject* p ) : QDoubleValidator( bottomVal, topVal, decim, p ) { } /*******************************************************************************/ DoubleValidator ::~DoubleValidator() { } /*******************************************************************************/ void DoubleValidator ::fixup( QString& input ) const { int pos = input.length(); if( validate( input, pos )!=QValidator::Intermediate ) return; bool isOk; double value = input.toDouble( &isOk ); if( !isOk ) { } if( valuetop() ) input = QString::number( top(), 'g', decimals() ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdDropLineEdit.cxx000066400000000000000000000077101301006202600270210ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdDropLineEdit.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::DropLineEdit Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ DropLineEdit ::DropLineEdit( QWidget* p ) : QLineEdit( p ) { setReadOnly( true ); setAcceptDrops( true ); } /*******************************************************************************/ DropLineEdit ::DropLineEdit( const QString& contents, QWidget* p ) : QLineEdit( contents, p ) { setReadOnly( true ); setAcceptDrops( true ); } /*******************************************************************************/ DropLineEdit ::~DropLineEdit() { } /*******************************************************************************/ void DropLineEdit ::dragEnterEvent( QDragEnterEvent* e ) { assert( e!=NULL ); // Accepts all proposed actions: check will be made in // dragMoveEvent(). e->acceptProposedAction(); } /*******************************************************************************/ void DropLineEdit ::dragMoveEvent( QDragMoveEvent* e ) { assert( e!=NULL ); /* if( ( e->mimeData()->hasText() && QUrl( e->mimeData()->text() ).isLocalFile() ) || ( e->mimeData()->hasFormat( "application/x-qabstractitemmodeldatalist" ) ) ) */ if( e->mimeData()->hasText() || e->mimeData()->hasFormat( "application/x-qabstractitemmodeldatalist" ) ) { e->acceptProposedAction(); } else { e->ignore(); } } /*******************************************************************************/ void DropLineEdit ::dropEvent( QDropEvent *e ) { assert( e!=NULL ); if( e->mimeData()->hasText() ) { QUrl url( e->mimeData()->text() ); /* if( url.isLocalFile() ) { */ setText( url.toLocalFile() ); /* } */ } else if( e->mimeData()->hasFormat( "application/x-qabstractitemmodeldatalist" ) ) { // TODO: use simpler mime type setText( e->mimeData()->data( "application/x-qabstractitemmodeldatalist" ) ); } } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdFilenameDragAndDropEventFilter.cxx000066400000000000000000000130771301006202600324400ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdFilenameDragAndDropEventFilter.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::FilenameDragAndDropEventFilter Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ FilenameDragAndDropEventFilter ::FilenameDragAndDropEventFilter( QObject* p ) : AbstractDragAndDropEventFilter( p ) { } /*****************************************************************************/ FilenameDragAndDropEventFilter ::~FilenameDragAndDropEventFilter() { } /*****************************************************************************/ bool FilenameDragAndDropEventFilter ::DragEnterEvent( QObject * watched, QDragEnterEvent* e ) { // qDebug() << this << "::DragEnterEvent(" << object << "," << e << ")"; // qDebug() << e->mimeData()->formats(); // // Bypass event its MIME data does not contain any URL(s). if( !e->mimeData()->hasUrls() ) return false; // // Bypass event if MIME data URL(s) are not all local filenames. typedef QList< QUrl > QUrlList; QUrlList urls( e->mimeData()->urls() ); for( QUrlList::const_iterator it( urls.begin() ); it!=urls.end(); ++it ) { // qDebug() << *it; // qDebug() << it->scheme() // << it->scheme().compare( "file", Qt::CaseInsensitive ); if( #if QT_VERSION < QT_VERSION_CHECK( 4, 8, 0 ) it->scheme().compare( "file", Qt::CaseInsensitive )!=0 #else // QT_VERSION < QT_VERSION_CHECK( 4, 8, 0 ) !it->isLocalFile() #endif // QT_VERSION < QT_VERSION_CHECK( 4, 8, 0 ) || e->source()==watched ) { return false; } } // // Accept event if its MIME data contains some URL(s) and they are // all local filenames. e->acceptProposedAction(); // // Eatup event. return true; } /*****************************************************************************/ bool FilenameDragAndDropEventFilter ::DragLeaveEvent( QObject * /* object */, QDragLeaveEvent * /* e */ ) { // qDebug() << this << "::DragLeaveEvent(" << object << "," << event << ")"; // // Nothing to do: bypass event & let default behaviour occur. return false; } /*****************************************************************************/ bool FilenameDragAndDropEventFilter ::DragMoveEvent( QObject *, QDragMoveEvent * ) { // qDebug() << this << "::DragMoveEvent(" << object << "," << event << ");"; // Nothing to do: bypass event & let default behaviour occur. return false; } /*****************************************************************************/ bool FilenameDragAndDropEventFilter ::DropEvent( QObject * watched, QDropEvent * e ) { // qDebug() << this << "::DropEvent(" << object << "," << e << ")"; assert( e!=NULL ); assert( e->mimeData()!=NULL ); // // Bypass event its MIME data does not contain not URL(s). if( !e->mimeData()->hasUrls() ) return false; // // Bypass event if MIME data URL(s) are not all local filenames. typedef QList< QUrl > QUrlList; QUrlList urls( e->mimeData()->urls() ); QStringList filenames; for( QUrlList::const_iterator it( urls.begin() ); it!=urls.end(); ++it ) { #if QT_VERSION < QT_VERSION_CHECK( 4, 8, 0 ) if( it->scheme().compare( "file", Qt::CaseInsensitive )==0 ) #else // QT_VERSION < QT_VERSION_CHECK( 4, 8, 0 ) if( it->isLocalFile() ) #endif // QT_VERSION < QT_VERSION_CHECK( 4, 8, 0 ) { if( e->source()!=watched ) { filenames.push_back( it->toLocalFile() ); emit FilenameDropped( filenames.back() ); } } else { qWarning() << "Dropped URL is not a local filename:" << *it; } } emit FilenamesDropped( filenames ); // // Eatup event. return true; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdGui.cxx000066400000000000000000000071571301006202600252300ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdGui.h" // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::Gui Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. const int MOUSE_WHEEL_STEP_DEGREES = 15; const int MOUSE_WHEEL_STEP_FACTOR = 8; char const * const RESOLUTION_NAMES[ RESOLUTION_COUNT ] = { // QT_TRANSLATE_NOOP( "mvd", "None" ), QT_TRANSLATE_NOOP( "mvd", "Nearest" ), QT_TRANSLATE_NOOP( "mvd", "Lower bound" ), QT_TRANSLATE_NOOP( "mvd", "Upper bound" ), }; char const * const TILE_SIZE_NAMES[ TILE_SIZE_COUNT ] = { // QT_TRANSLATE_NOOP( "mvd", "None" ), QT_TRANSLATE_NOOP( "mvd", "64" ), QT_TRANSLATE_NOOP( "mvd", "128" ), QT_TRANSLATE_NOOP( "mvd", "256" ), QT_TRANSLATE_NOOP( "mvd", "512" ), }; int TILE_SIZE_VALUE[ TILE_SIZE_COUNT ] = { 64, 128, 256, 512, }; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ void AddItemsInto( QComboBox * comboBox, const char * context, char const * const names[], size_t count ) { assert( comboBox!=NULL ); assert( names!=NULL ); for( size_t i=0; iaddItem( qApp->translate( context, names[ i ] ) ); } /*****************************************************************************/ QMessageBox & CustomizeMessageBox( QMessageBox & messageBox, QWidget * widget ) { assert( widget!=NULL ); assert( messageBox.layout()==qobject_cast< QGridLayout * >( messageBox.layout() ) ); QGridLayout * gridLayout = qobject_cast< QGridLayout * >( messageBox.layout() ); assert( gridLayout!=NULL ); /* qDebug() << layout; qDebug() << layout->itemAt( layout->count() - 2 )->widget()->layout(); qDebug() << layout->itemAt( layout->count() - 1 )->widget()->layout(); */ // Add custom widget into message-box layout. gridLayout->addWidget( widget, 1, 1 ); // Return input message-box to chain function calls, if needed. return messageBox; } /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdHistogramController.cxx000066400000000000000000000160001301006202600304700ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdHistogramController.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdVectorImageModel.h" #include "mvdHistogramWidget.h" namespace mvd { /* TRANSLATOR mvd::HistogramController Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ HistogramController ::HistogramController( HistogramWidget* widget, QObject* p ) : AbstractModelController( widget, p ) { } /*******************************************************************************/ HistogramController ::~HistogramController() { } /*******************************************************************************/ void HistogramController ::Connect( AbstractModel * ) { // HistogramWidget* widget = GetWidget< HistogramWidget >(); // // Connect GUI to controller. // // Connect controller to model. } /*******************************************************************************/ void HistogramController ::Disconnect( AbstractModel * ) { // HistogramWidget* widget = GetWidget< HistogramWidget >(); // // Disconnect controller to model. // // Disconnect GUI from controller. } /*******************************************************************************/ void HistogramController ::ClearWidget() { assert( GetWidget()==GetWidget< HistogramWidget >() ); HistogramWidget* widget = GetWidget< HistogramWidget >(); assert( widget!=NULL ); widget->Clear(); } /*******************************************************************************/ void HistogramController ::virtual_ResetWidget( bool ) { ResetWidget( RGBW_CHANNEL_ALL ); } /*******************************************************************************/ void HistogramController ::ResetWidget( RgbwChannel channel ) { assert( GetModel()==GetModel< VectorImageModel >() ); VectorImageModel* imageModel = GetModel< VectorImageModel >(); assert( imageModel!=NULL ); HistogramModel* model = imageModel->GetHistogramModel(); assert( model!=NULL ); if( !model->IsValid() ) return; assert( GetWidget()==GetWidget< HistogramWidget >() ); HistogramWidget* widget = GetWidget< HistogramWidget >(); assert( widget!=NULL ); CountType begin = 0; CountType end = 0; if( !RgbwBounds( begin, end, channel ) ) return; const VectorImageSettings & settings = imageModel->GetSettings(); widget->SetGrayscaleActivated( settings.IsGrayscaleActivated() ); assert( std::numeric_limits< double >::has_quiet_NaN ); for( CountType i=begin; i( i ); VectorImageSettings::ChannelVector::value_type band = settings.GetRgbwChannel( chan ); size_t size = model->GetDataCount( band ); double* x = new double[ size ]; double* y = new double[ size ]; double xMin = std::numeric_limits< double >::quiet_NaN(); double yMin = std::numeric_limits< double >::quiet_NaN(); double xMax = std::numeric_limits< double >::quiet_NaN(); double yMax = std::numeric_limits< double >::quiet_NaN(); model->GetData( band, x, y, xMin, xMax, yMin, yMax ); widget->SetData( chan, x, y, size, xMin, yMin, xMax, yMax ); widget->SetPrecision( HistogramModel::GetEpsilon() ); widget->SetLowMarker( chan, settings.GetLowIntensity( chan ) ); widget->SetHighMarker( chan, settings.GetHighIntensity( chan ) ); delete[] x; x = NULL; delete[] y; y = NULL; } widget->RefreshScale( true ); widget->Replot(); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void HistogramController ::OnRgbChannelIndexChanged( RgbwChannel channel, int ) { /* qDebug() << this << "::OnRgbChannelIndexChanged(" << RGBW_CHANNEL_NAMES[ channel ] << ", " << band << ")"; */ ResetWidget( channel ); } /*****************************************************************************/ void HistogramController ::OnGrayChannelIndexChanged( int ) { /* qDebug() << this << "::OnGrayChannelIndexChanged(" << band << ")"; */ ResetWidget( RGBW_CHANNEL_WHITE ); } /*****************************************************************************/ void HistogramController ::OnGrayscaleActivated( bool activated ) { /* qDebug() << this << "::OnGrayscaleActivated(" << activated << ")"; */ assert( GetWidget()==GetWidget< HistogramWidget >() ); HistogramWidget* widget = GetWidget< HistogramWidget >(); assert( widget!=NULL ); widget->SetGrayscaleActivated( activated ); widget->RefreshScale( true ); widget->Replot(); } /*****************************************************************************/ void HistogramController ::OnLowIntensityChanged( RgbwChannel channel, double value, bool refresh ) { assert( GetWidget()==GetWidget< HistogramWidget >() ); HistogramWidget* widget = GetWidget< HistogramWidget >(); assert( widget!=NULL ); widget->SetLowMarker( channel, value ); if( refresh ) widget->Replot(); } /*****************************************************************************/ void HistogramController ::OnHighIntensityChanged( RgbwChannel channel, double value, bool refresh ) { assert( GetWidget()==GetWidget< HistogramWidget >() ); HistogramWidget* widget = GetWidget< HistogramWidget >(); assert( widget!=NULL ); widget->SetHighMarker( channel, value ); if( refresh ) widget->Replot(); } /*****************************************************************************/ void HistogramController ::OnHistogramRefreshed() { ResetWidget( RGBW_CHANNEL_ALL ); } /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdHistogramPlotPicker.cxx000066400000000000000000000245401301006202600304310ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdHistogramPlotPicker.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // Qwt includes. #include #include #include #include #include // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdHistogramWidget.h" namespace mvd { /* TRANSLATOR mvd::HistogramPlotPicker Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ HistogramPlotPicker ::HistogramPlotPicker( const PlotCurveVector& curves, QwtPlotCanvas* can ) : QwtPlotPicker( can ), m_PlotCurves( curves ), m_RubberBandPens(), m_IsGrayscaleActivated( false ) { assert( m_PlotCurves.size()==HistogramPlotPicker::CURVE_COUNT ); setSelectionFlags( QwtPicker::PointSelection ); setRubberBand( QwtPicker::UserRubberBand ); } /*******************************************************************************/ HistogramPlotPicker ::HistogramPlotPicker( const PlotCurveVector& curves, int xA, int yA, QwtPlotCanvas* can ) : QwtPlotPicker( xA, yA, can ), m_PlotCurves( curves ), m_RubberBandPens(), m_IsGrayscaleActivated( false ) { assert( m_PlotCurves.size()==HistogramPlotPicker::CURVE_COUNT ); setSelectionFlags( QwtPicker::PointSelection ); setRubberBand( QwtPicker::UserRubberBand ); } /*******************************************************************************/ HistogramPlotPicker ::HistogramPlotPicker( const PlotCurveVector& curves, int xA, int yA, DisplayMode tracker, QwtPlotCanvas* can ) : QwtPlotPicker( xA, yA, QwtPicker::PointSelection, QwtPicker::UserRubberBand, tracker, can ), m_PlotCurves( curves ), m_RubberBandPens(), m_IsGrayscaleActivated( false ) { assert( m_PlotCurves.size()==HistogramPlotPicker::CURVE_COUNT ); } /*******************************************************************************/ HistogramPlotPicker ::~HistogramPlotPicker() { } /*******************************************************************************/ void HistogramPlotPicker ::SetRubberBandPen( RgbwChannel channel, const QPen& pen ) { CountType start = 0; CountType stop = 0; if( !RgbwBounds( start, stop, channel ) ) return; for( CountType i=start; i= 1 ) { const QRect& rect = pickRect(); const QPoint& pos = pa[ 0 ]; QwtPainter::drawLine( painter, pos.x(), rect.bottom(), pos.x(), rect.top() ); CountType start = 0; CountType stop = 0; if( !RgbwBounds( start, stop, RGBW_CHANNEL_ALL ) ) return; QwtDoublePoint p( invTransform( pos ) ); for( CountType i=start; iisVisible() ) { // RgbwChannel channel = static_cast< RgbwChannel >( i ); p.setY( Find( m_PlotCurves[ i ], p.x() ) ); QPoint pos2( transform( p ) ); /* QPen pen( m_RubberBandPens[ i ] ); painter->setPen( rubberBandPen() ); */ QwtPainter::drawLine( painter, rect.left(), pos2.y(), rect.right(), pos2.y() ); // painter->setPen( pen ); } } } /*******************************************************************************/ QwtText HistogramPlotPicker ::trackerText( const QwtDoublePoint& point ) const { if( rubberBand()!=QwtPicker::UserRubberBand ) return QwtPlotPicker::trackerText( point ); if( !isActive() ) return QwtText( QString().sprintf( "%.4f, %.4f", point.x(), point.y() ) ); QString text; text.sprintf( "%.4f", point.x() ); CountType start = 0; CountType stop = 0; if( RgbwBounds( start, stop, RGBW_CHANNEL_ALL ) ) for( CountType i=start; iisVisible() ) { double c0 = 0.0; double c1 = 0.0; double cf = 0.0; Find( m_PlotCurves[ i ], point.x(), c0, c1, cf ); text.append( QString().sprintf( "\n[%.4f; %.4f[, %.0f", c0, c1, cf ) ); } return text; } /*******************************************************************************/ double HistogramPlotPicker ::Find( const QwtPlotCurve* curve, double x ) const { const QwtData& data = curve->data(); /* #if HISTOGRAM_CURVE_TYPE==0 assert( false && "Not yet implemented!" ); #elif HISTOGRAM_CURVE_TYPE==1 assert( false && "Not yet implemented!" ); #elif HISTOGRAM_CURVE_TYPE==2 */ assert( data.size() % 4 == 0 ); CountType steps = 0; if( data.size()==0 ) return -1.0; CountType i0 = 0; CountType i1 = data.size() / 4 - 1; // assert( x>=data.x( 4 * i0 ) && x<=data.x( 4 * i1 + 3 ) ); if( xdata.x( 4 * i1 + 3 ) ) return -1.0; while( i0!=i1 ) { assert( data.x( 4 * i0 )==data.x( 4 * i0 + 1 ) ); assert( data.x( 4 * i0 + 2 )==data.x( 4 * i0 + 3 ) ); assert( data.y( 4 * i0 + 1 )==data.y( 4 * i0 + 2 ) ); assert( data.y( 4 * i0 )==data.y( 4 * i0 + 3 ) ); assert( data.x( 4 * i1 )==data.x( 4 * i1 + 1 ) ); assert( data.x( 4 * i1 + 2 )==data.x( 4 * i1 + 3 ) ); assert( data.y( 4 * i1 + 1 )==data.y( 4 * i1 + 2 ) ); assert( data.y( 4 * i1 )==data.y( 4 * i1 + 3 ) ); CountType i = (i0 + i1 + 1) / 2; #if 0 qDebug() << i0 << " (" << data.x( 4*i0 ) << ", " << data.x( 4*i0+2 ) << ") " << i << " (" << data.x( 4*i ) << ", " << data.x( 4*i+2 ) << ") " << i1 << " (" << data.x( 4*i1 ) << ", " << data.x( 4*i1+2 ) << ")"; #endif if( x=data.x( 4 * i0 ) && x<=data.x( 4 * i0 + 2 ) ); assert( x>=data.x( 4 * i0 + 1 ) && x<=data.x( 4 * i0 + 3 ) ); #if 0 qDebug() << steps << ":" << x << "in [" << data.x( 4 * i0 ) << "; " << data.x( 4 * i0 + 2 ) << "] ->" << data.y( 4 * i0 + 1 ); #endif return data.y( 4 * i0 + 1 ); /* #else assert( false && "Unknown HISTOGRAM_CURVE_TYPE value" ); #endif */ } /*******************************************************************************/ CountType HistogramPlotPicker ::Find( const QwtPlotCurve* curve, double x, double& xmin, double& xmax, double& y ) const { const QwtData& data = curve->data(); /* #if HISTOGRAM_CURVE_TYPE==0 assert( false && "Not yet implemented!" ); #elif HISTOGRAM_CURVE_TYPE==1 assert( false && "Not yet implemented!" ); #elif HISTOGRAM_CURVE_TYPE==2 */ assert( data.size() % 4 == 0 ); CountType steps = 0; if( data.size()==0 ) return 0; CountType i0 = 0; CountType i1 = data.size() / 4 - 1; if( xdata.x( 4 * i1 + 3 ) ) return 0; while( i0!=i1 ) { assert( data.x( 4 * i0 )==data.x( 4 * i0 + 1 ) ); assert( data.x( 4 * i0 + 2 )==data.x( 4 * i0 + 3 ) ); assert( data.y( 4 * i0 + 1 )==data.y( 4 * i0 + 2 ) ); assert( data.y( 4 * i0 )==data.y( 4 * i0 + 3 ) ); assert( data.x( 4 * i1 )==data.x( 4 * i1 + 1 ) ); assert( data.x( 4 * i1 + 2 )==data.x( 4 * i1 + 3 ) ); assert( data.y( 4 * i1 + 1 )==data.y( 4 * i1 + 2 ) ); assert( data.y( 4 * i1 )==data.y( 4 * i1 + 3 ) ); CountType i = (i0 + i1 + 1) / 2; #if 0 qDebug() << i0 << " (" << data.x( 4*i0 ) << ", " << data.x( 4*i0+2 ) << ") " << i << " (" << data.x( 4*i ) << ", " << data.x( 4*i+2 ) << ") " << i1 << " (" << data.x( 4*i1 ) << ", " << data.x( 4*i1+2 ) << ")"; #endif if( x=data.x( 4 * i0 ) && x<=data.x( 4 * i0 + 2 ) ); assert( x>=data.x( 4 * i0 + 1 ) && x<=data.x( 4 * i0 + 3 ) ); #if 0 qDebug() << steps << ":" << x << "in [" << data.x( 4 * i0 ) << "; " << data.x( 4 * i0 + 2 ) << "] ->" << data.y( 4 * i0 + 1 ); #endif xmin = data.x( 4 * i0 ); xmax = data.x( 4 * i0 + 2 ); y = data.y( 4 * i0 + 1 ); return steps; /* #else assert( false && "Unknown HISTOGRAM_CURVE_TYPE value" ); #endif */ } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdHistogramWidget.cxx000066400000000000000000000456741301006202600276130ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdHistogramWidget.h" #include "ui_mvdHistogramWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // Qwt includes #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Wshadow" #include #include #include #include #include // #include #include #pragma GCC diagnostic pop #else #include #include #include #include #include // #include #include #endif // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdHistogramPlotPicker.h" namespace mvd { /* TRANSLATOR mvd::HistogramWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ #define PRECISION_MARGIN 4 /** * \brief Array of enhanced band names that OTB can return. * * It is defined (statically) as a constant for translation purposes. */ const char* HistogramWidget::CURVE_NAMES[ HistogramWidget::CURVE_COUNT ] = { QT_TRANSLATE_NOOP( "mvd::HistogramWidget", "Red" ), QT_TRANSLATE_NOOP( "mvd::HistogramWidget", "Green" ), QT_TRANSLATE_NOOP( "mvd::HistogramWidget", "Blue" ), QT_TRANSLATE_NOOP( "mvd::HistogramWidget", "Gray" ), }; const QColor HistogramWidget::CURVE_COLORS[ HistogramWidget::CURVE_COUNT ] = { QColor( 0xFF, 0x44, 0x44/*, 0x66*/ ), QColor( 0x44, 0xFF, 0x44/*, 0x66*/ ), QColor( 0x44, 0x44, 0xFF/*, 0x66*/ ), QColor( 0xBB, 0xBB, 0xBB/*, 0x66*/ ), }; const QColor HistogramWidget::BAR_COLORS[ HistogramWidget::CURVE_COUNT ] = { QColor( 0xFF, 0x44, 0x44, 0x66 ), QColor( 0x44, 0xFF, 0x44, 0x66 ), QColor( 0x44, 0x44, 0xFF, 0x66 ), QColor( 0xBB, 0xBB, 0xBB, 0x66 ), }; const QColor HistogramWidget::MARKER_COLORS[ HistogramWidget::CURVE_COUNT ] = { QColor( 0xFF, 0x77, 0x77/*, 0x00*/ ), QColor( 0x77, 0xFF, 0x77/*, 0x77*/ ), QColor( 0x77, 0x77, 0xFF/*, 0x00*/ ), QColor( 0xFF, 0xFF, 0xFF/*, 0x00*/ ), }; const QColor HistogramWidget::RUBBER_BAND_COLORS[ HistogramWidget::CURVE_COUNT ] = { QColor( 0xFF, 0x77, 0x77/*, 0xAA */ ), QColor( 0x77, 0xFF, 0x77/*, 0xAA */ ), QColor( 0x77, 0x77, 0xFF/*, 0xAA */ ), QColor( 0xFF, 0xFF, 0xFF/*, 0xAA */ ), }; namespace { const QColor CANVAS_BACKGROUND( 0x33, 0x33, 0x33 ); const QColor GRID_MAJ_PEN_COLOR( 0x66, 0x66, 0x66 ); const QColor GRID_MIN_PEN_COLOR( 0x44, 0x44, 0x44 ); const QColor RUBBER_BAND_COLOR( 0xFF, 0xFF, 0x00, 0xAA ); } /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ HistogramWidget ::HistogramWidget( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::HistogramWidget() ), m_PlotGrid( NULL ), m_PlotPicker( NULL ), // m_PlotZoomer( NULL ), m_PlotMagnifier( NULL ), m_PlotPanner( NULL ), // m_PlotCurves(), // m_LowPlotMarkers(), // m_HighPlotMarkers(), m_Bounds(), m_Precision( 0.0 ), m_IsGrayscaleActivated( false ) { m_UI->setupUi( this ); m_UI->histogramPlot->setCanvasBackground( CANVAS_BACKGROUND ); // // GRID. m_PlotGrid = new QwtPlotGrid(); m_PlotGrid->attach( m_UI->histogramPlot ); m_PlotGrid->setMajPen( GRID_MAJ_PEN_COLOR ); m_PlotGrid->setMinPen( GRID_MIN_PEN_COLOR ); // // ZOOMER. /* m_PlotZoomer = new QwtPlotZoomer( m_UI->histogramPlot->canvas() ); m_PlotZoomer->setTrackerMode( QwtPicker::AlwaysOff ); m_PlotZoomer->setSelectionFlags( QwtPicker::RectSelection | QwtPicker::DragSelection ); m_PlotZoomer->setRubberBandPen( QPen( QColor( 0xFF, 0x44, 0xFF ) ) ); m_PlotZoomer->setTrackerPen( QPen( QColor( 0xFF, 0x44, 0xFF ) ) ); */ m_PlotMagnifier = new QwtPlotMagnifier( m_UI->histogramPlot->canvas() ); m_PlotMagnifier->setAxisEnabled( QwtPlot::yLeft, false ); m_PlotMagnifier->setWheelFactor( 1.0 / m_PlotMagnifier->wheelFactor() ); m_PlotMagnifier->setMouseButton( Qt::MidButton ); // m_PlotMagnifier->setZoomInKey( Qt::Key_Plus, Qt::NoModifier ); // m_PlotMagnifier->setZoomOutKey( Qt::Key_Minus, Qt::NoModifier ); m_PlotPanner = new QwtPlotPanner( m_UI->histogramPlot->canvas() ); // m_PlotPanner->setAxisEnabled( QwtPlot::yLeft, false ); m_PlotPanner->setMouseButton( Qt::RightButton ); m_PlotPanner->setOrientations( Qt::Horizontal ); // // CURVES. HistogramPlotPicker::PlotCurveVector curves( HistogramWidget::CURVE_COUNT ); for( CountType i=0; isetStyle( QwtPlotCurve::Steps ); #elif HISTOGRAM_CURVE_TYPE==2 #else #endif m_PlotCurves[ i ]->setPen( QPen( CURVE_COLORS[ i ] ) ); m_PlotCurves[ i ]->setBrush( QBrush( BAR_COLORS[ i ] ) ); m_PlotCurves[ i ]->attach( m_UI->histogramPlot ); // // Markers m_LowPlotMarkers[ i ] = new QwtPlotMarker(); m_LowPlotMarkers[ i ]->setLineStyle( QwtPlotMarker::VLine ); m_LowPlotMarkers[ i ]->setLinePen( QPen( HistogramWidget::MARKER_COLORS[ i ] ) ); m_LowPlotMarkers[ i ]->attach( m_UI->histogramPlot ); m_HighPlotMarkers[ i ] = new QwtPlotMarker(); m_HighPlotMarkers[ i ]->setLineStyle( QwtPlotMarker::VLine ); m_HighPlotMarkers[ i ]->setLinePen( QPen( HistogramWidget::MARKER_COLORS[ i ] ) ); m_HighPlotMarkers[ i ]->attach( m_UI->histogramPlot ); } // // PICKER. m_PlotPicker = new HistogramPlotPicker( curves, m_UI->histogramPlot->canvas() ); m_PlotPicker->setTrackerMode( QwtPicker::ActiveOnly ); m_PlotPicker->setRubberBandPen( RUBBER_BAND_COLOR ); m_PlotPicker->setTrackerPen( QColor( Qt::yellow ) ); for( CountType i=0; iSetRubberBandPen( static_cast< RgbwChannel >( i ), QPen( HistogramWidget::RUBBER_BAND_COLORS[ i ] ) ); } // // CONNECTIONS. // // QObject::connect( m_PlotPicker, SIGNAL( appended( const QwtDoublePoint& ) ), this, SLOT( OnAppended( const QwtDoublePoint& ) ) ); QObject::connect( m_PlotPicker, SIGNAL( appended( const QPoint& ) ), this, SLOT( OnAppended( const QPoint& ) ) ); // QObject::connect( m_PlotPicker, SIGNAL( changed( const QwtPolygon& ) ), this, SLOT( OnChanged( const QwtPolygon& ) ) ); // QObject::connect( m_PlotPicker, SIGNAL( selected( const QwtDoublePoint& ) ), this, SLOT( OnSelected( const QwtDoublePoint& ) ) ); QObject::connect( m_PlotPicker, SIGNAL( selected( const QwtDoubleRect& ) ), this, SLOT( OnSelected( const QwtDoubleRect& ) ) ); QObject::connect( m_PlotPicker, SIGNAL( selected( const QwtPolygon& ) ), this, SLOT( OnSelected( const QwtPolygon& ) ) ); QObject::connect( m_PlotPicker, SIGNAL( selected( const QwtArray< QwtDoublePoint >& ) ), this, SLOT( OnSelected( const QwtArray< QwtDoublePoint >& ) ) ); } /*******************************************************************************/ HistogramWidget ::~HistogramWidget() { delete m_PlotPicker; m_PlotPicker = NULL; for( CountType i=0; isetData( xVal, yVal, sizeVal ); if( xVal==NULL && yVal==NULL ) m_PlotCurves[ i ]->setVisible( false ); /* qDebug() << RGBW_CHANNEL_NAMES[ i ] << "[" << xMin << "; " << xMax << "]" << "xVal [" << yMin << "; " << yMax << "]"; */ m_Bounds[ i ].m_XMin = xMin; m_Bounds[ i ].m_XMax = xMax; m_Bounds[ i ].m_YMin = yMin; m_Bounds[ i ].m_YMax = yMax; } } /*******************************************************************************/ void HistogramWidget ::SetLowMarker( RgbwChannel channel, double low ) { /* qDebug() << this << "::SetLowMarker(" << RGBW_CHANNEL_NAMES[ channel ] << ", " << low << ")"; */ CountType begin = 0; CountType end = 0; if( !RgbwBounds( begin, end, channel ) ) return; for( CountType i=begin; isetXValue( low ); m_Bounds[ i ].m_QMin = low; } } /*******************************************************************************/ void HistogramWidget ::SetHighMarker( RgbwChannel channel, double high ) { /* qDebug() << this << "::SetLowMarker(" << RGBW_CHANNEL_NAMES[ channel ] << ", " << high << ")"; */ CountType begin = 0; CountType end = 0; if( !RgbwBounds( begin, end, channel ) ) return; for( CountType i=begin; isetXValue( high ); m_Bounds[ i ].m_QMax = high; } } /*****************************************************************************/ void HistogramWidget ::SetGrayscaleActivated( bool activated ) { m_IsGrayscaleActivated = activated; /* for( CountType i=0; isetVisible( isVisible ); m_LowPlotMarkers[ i ]->setVisible( isVisible ); m_HighPlotMarkers[ i ]->setVisible( isVisible ); } */ m_UI->channelComboBox->setEnabled( !activated ); bool areSignalsBlocked = m_UI->channelComboBox->blockSignals( true ); { m_UI->channelComboBox->setItemText( 3, activated ? tr( "White" ) : tr( "RGB" ) ); m_UI->channelComboBox->setCurrentIndex( 3 ); UpdateCurvesVisibility( 3 ); } m_UI->channelComboBox->blockSignals( areSignalsBlocked ); m_PlotPicker->SetGrayscaleActivated( activated ); } /*****************************************************************************/ /* bool HistogramWidget ::IsGrayscaleActivated() const { assert( m_PlotCurves[ RGBW_CHANNEL_WHITE ]!=NULL ); return m_PlotCurves[ RGBW_CHANNEL_WHITE ]->isVisible(); } */ /*******************************************************************************/ void HistogramWidget ::Replot() { // RefreshScale( true ); m_UI->histogramPlot->replot(); } /*******************************************************************************/ void HistogramWidget ::UpdateCurvesVisibility( CountType index ) { CountType begin = 0; CountType end = 0; if( !RgbwBounds( begin, end, RGBW_CHANNEL_ALL ) ) return; for( CountType i=begin; isetVisible( isCurveVisible ); m_LowPlotMarkers[ i ]->setVisible( isCurveVisible ); m_HighPlotMarkers[ i ]->setVisible( isCurveVisible ); } } /*******************************************************************************/ void HistogramWidget ::RefreshScale( bool iqr ) { assert( std::numeric_limits< double >::has_infinity ); double xMin = +std::numeric_limits< double >::infinity(); double xMax = -std::numeric_limits< double >::infinity(); double yMin = +std::numeric_limits< double >::infinity(); double yMax = -std::numeric_limits< double >::infinity(); CountType begin = 0; CountType end = 0; if( !RgbwBounds( begin, end, RGBW_CHANNEL_ALL ) ) return; for( CountType i=begin; ixMax ) xMax = m_Bounds[ i ].m_QMax; } else { if( m_Bounds[ i ].m_XMinxMax ) xMax = m_Bounds[ i ].m_XMax; } if( m_Bounds[ i ].m_YMinyMax ) yMax = m_Bounds[ i ].m_YMax; } if( xMin==xMax ) { double epsilon = PRECISION_MARGIN * m_Precision; if( xMin >= std::numeric_limits< double >::min() + epsilon ) xMin -= epsilon; if( xMax <= std::numeric_limits< double >::max() - epsilon ) xMax += epsilon; } // qDebug() // << "[" << xMin << "; " << xMax << "]" // << "x [" << yMin << "; " << yMax << "]"; m_UI->histogramPlot->setAxisScale( QwtPlot::xBottom, xMin, xMax ); m_UI->histogramPlot->setAxisScale( QwtPlot::yLeft, yMin, yMax ); } /*******************************************************************************/ void HistogramWidget ::Clear() { CountType begin = 0; CountType end = 0; if( !RgbwBounds( begin, end, RGBW_CHANNEL_ALL ) ) return; for( CountType i=begin; isetVisible( false ); m_LowPlotMarkers[ i ]->setVisible( false ); m_HighPlotMarkers[ i ]->setVisible( false ); /* qDebug() << RGBW_CHANNEL_NAMES[ i ] << "[" << xMin << "; " << xMax << "]" << "x [" << yMin << "; " << yMax << "]"; */ m_Bounds[ i ].m_XMin = 0.0; m_Bounds[ i ].m_XMax = 1000.0; m_Bounds[ i ].m_YMin = 0.0; m_Bounds[ i ].m_YMax = 1000.0; m_Bounds[ i ].m_QMin = 0.0; m_Bounds[ i ].m_QMax = 1000.0; } RefreshScale( false ); Replot(); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void HistogramWidget ::on_zoom1Button_clicked() { RefreshScale( false ); Replot(); } /*******************************************************************************/ void HistogramWidget ::on_zoomQButton_clicked() { RefreshScale( true ); Replot(); } /*******************************************************************************/ void HistogramWidget ::on_channelComboBox_currentIndexChanged( int /*index*/ ) { UpdateCurvesVisibility( m_UI->channelComboBox->currentIndex() ); Replot(); } /*******************************************************************************/ void HistogramWidget ::OnAppended( const QwtDoublePoint & ) { // qDebug() << this << "::OnAppended(" << pos.x() << ", " << pos.y() << ")"; } /*******************************************************************************/ void HistogramWidget ::OnAppended( const QPoint & ) { // qDebug() << this << "::OnAppended(" << pos << ")"; } /*******************************************************************************/ void HistogramWidget ::OnChanged( const QwtPolygon & ) { // qDebug() << this << "::OnChanged(" << pa << ")"; } /*******************************************************************************/ void HistogramWidget ::OnMoved( const QwtDoublePoint & ) { // qDebug() << this << "::OnMoved(" << pos.x() << ", " << pos.y() << ")"; } /*******************************************************************************/ void HistogramWidget ::OnMoved( const QPoint & ) { // qDebug() << this << "::OnMoved(" << pos << ")"; } /*******************************************************************************/ void HistogramWidget ::OnSelected( const QwtDoublePoint & ) { // qDebug() << this << "::OnSelected(" << pos.x() << ", " << pos.y() << ")"; } /*******************************************************************************/ void HistogramWidget ::OnSelected( const QwtDoubleRect & ) { // qDebug() << this << "::OnSelected(" << rect.x() << ", " << rect.y() << ")"; } /*******************************************************************************/ void HistogramWidget ::OnSelected( const QwtPolygon & ) { // qDebug() << this << "::OnSelected(" << pa << ")"; } /*******************************************************************************/ void HistogramWidget ::OnSelected( const QwtArray< QwtDoublePoint > & ) { // qDebug() << this << "::OnSelected(" << pa << ")"; } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdHistogramWidget.ui000066400000000000000000000065121301006202600274120ustar00rootroot00000000000000 mvd::HistogramWidget 0 0 218 158 Form Zoom to full intensity range. :/icons/action_ZoomFull_Icon:/icons/action_ZoomFull_Icon Zoom to quantile ranges. :/icons/action_ZoomExtent_Icon:/icons/action_ZoomExtent_Icon Qt::Horizontal 40 20 Select channel(s) to display. Red Green Blue RGB 0 0 200 100 Histogram estimated on Quicklook. QwtPlot QFrame
    qwt_plot.h
         OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdI18nApplication.cxx000066400000000000000000000050541301006202600274010ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdI18nApplication.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGlView.h" // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::I18nApplication Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ I18nApplication ::I18nApplication( QApplication* qtApp ) : I18nCoreApplication( qtApp ) { } /*******************************************************************************/ I18nApplication ::~I18nApplication() { } /*******************************************************************************/ void I18nApplication ::virtual_InitializeCore() { #ifndef Q_WS_MAC qApp->setWindowIcon( QIcon( QLatin1String( ":/images/application_icon" ) ) ); #endif } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdI18nMainWindow.cxx000066400000000000000000000206041301006202600272100ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdI18nMainWindow.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbSystem.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdBackgroundTask.h" #include "mvdImageImporter.h" #include "mvdOverviewBuilder.h" #include "mvdVectorImageModel.h" #include "mvdAboutDialog.h" #include "mvdI18nApplication.h" #include "mvdImportImagesDialog.h" #include "mvdTaskProgressDialog.h" namespace mvd { /* TRANSLATOR mvd::I18nMainWindow Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ I18nMainWindow ::I18nMainWindow( QWidget* p, Qt::WindowFlags flags ) : QMainWindow( p, flags ) { } /*****************************************************************************/ I18nMainWindow ::~I18nMainWindow() { } /*****************************************************************************/ void I18nMainWindow ::Initialize() { /* // Default setup. setObjectName( "mvd::I18nMainWindow" ); setWindowTitle( PROJECT_NAME ); */ virtual_SetupUI(); // Connect Appllication and MainWindow when selected model is about // to change. QObject::connect( I18nApplication::Instance(), SIGNAL( AboutToChangeModel( const AbstractModel* ) ), this, SLOT( OnAboutToChangeModel( const AbstractModel* ) ) ); // Connect Application and MainWindow when selected model has been // changed. QObject::connect( I18nApplication::Instance(), SIGNAL( ModelChanged( AbstractModel* ) ), this, SLOT( OnModelChanged( AbstractModel* ) ) ); virtual_ConnectUI(); virtual_InitializeUI(); } /*****************************************************************************/ QDockWidget* I18nMainWindow ::AddWidgetToDock( QWidget* widget, const QString& dockName, const QString& dockTitle, Qt::DockWidgetArea dockArea, DockLayoutFlags flags ) { // New dock. QDockWidget* dockWidget = new QDockWidget( dockTitle, this ); // You can use findChild( dockName ) to get dock-widget. dockWidget->setObjectName( dockName ); dockWidget->setWidget( widget ); // Features. dockWidget->setFloating( flags.testFlag( DOCK_LAYOUT_FLOATING ) ); dockWidget->setFeatures( QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable ); // dockWidget->setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum ); // dockWidget->adjustSize(); // Add dock. addDockWidget( dockArea, dockWidget ); // return dockWidget; } /*****************************************************************************/ VectorImageModel * I18nMainWindow ::ImportImage( const QString& filename, int widthVal, int heightVal ) { return QObjectCast< VectorImageModel * >( Import( // New dataset-importer worker. // It will be auto-deleted by background-task. new ImageImporter( filename, widthVal, heightVal ) ), "QObject is not a VectorImageModel." ); } /*****************************************************************************/ bool I18nMainWindow ::BuildGDALOverviews( const QStringList & filenames ) { ImportImagesDialog * importDialog = new ImportImagesDialog( filenames, this ); if( importDialog->GetEffectiveCount()<1 ) return true; int result = importDialog->exec(); if( result== QDialog::Rejected ) return false; if( result==QDialog::Accepted ) { // AbstractWorker will be automatically deleted by BackgroundTask in // ::Import(). OverviewBuilder * builder = new OverviewBuilder( importDialog->GetGDALOverviewsBuilders() ); delete importDialog; importDialog = NULL; Import( builder ); } return true; } /*****************************************************************************/ QObject * I18nMainWindow ::Import( AbstractWorker * importer ) { assert( importer ); // // Background task. // New background-task running worker. // Will be self auto-deleted when worker has finished. BackgroundTask* task = new BackgroundTask( importer, false, this ); // // Progress dialog. TaskProgressDialog progress( task, this, Qt::CustomizeWindowHint | Qt::WindowTitleHint ); progress.setWindowModality( Qt::WindowModal ); progress.setAutoReset( false ); progress.setAutoClose( false ); progress.setCancelButton( NULL ); progress.setMinimumDuration( 0 ); // // Result. int button = progress.Exec(); // MANTIS-921 (synchronize deletion of BackgroungTask). task->wait(); delete task; task = NULL; // MANTIS-921 (then, process result). if( button!=QDialog::Accepted ) { assert( progress.GetObject()==NULL ); return NULL; } // qDebug() << "object:" << progress.GetObject< DatasetModel >(); // assert( progress.GetObject()!=NULL ); return progress.GetObject(); } /*****************************************************************************/ void I18nMainWindow ::closeEvent( QCloseEvent * e ) { QMainWindow::closeEvent( e ); } /*****************************************************************************/ void I18nMainWindow ::virtual_InitializeUI() { // Change to NULL model to force emitting GUI signals when GUI is // instantiated. So, GUI will be initialized and controller-widgets // disabled. I18nApplication::Instance()->SetModel( NULL ); } /*****************************************************************************/ void I18nMainWindow ::SaveLayout( int version ) const { // qDebug() << this << "::SaveLayout()"; assert( I18nCoreApplication::Instance()!=NULL ); QString name( objectName() ); I18nCoreApplication::Instance() ->StoreSettingsKey( name + "Geometry", saveGeometry() ); I18nCoreApplication::Instance() ->StoreSettingsKey( name + "State", saveState( version ) ); } /*****************************************************************************/ bool I18nMainWindow ::RestoreLayout( int version ) { // qDebug() << this << "::RestoreLayout()"; I18nCoreApplication * application = I18nCoreApplication::Instance(); assert( application!=NULL ); QString name( objectName() ); assert( !name.isEmpty() ); if( !restoreGeometry( application->RetrieveSettingsKey( name + "Geometry" ).toByteArray() ) ) return false; return restoreState( application->RetrieveSettingsKey( name + "State" ).toByteArray(), version ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void I18nMainWindow ::on_action_Quit_triggered() { close(); } /*****************************************************************************/ void I18nMainWindow ::on_action_About_triggered() { AboutDialog aboutDialog( this ); aboutDialog.exec(); } /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdIcons.qrc000066400000000000000000000003571301006202600255350ustar00rootroot00000000000000 ../../../../Utilities/Data/Icons/execute.png ../../../../Utilities/Data/Icons/locked.png ../../../../Utilities/Data/Icons/unlocked.png OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdImageViewManipulator.cxx000066400000000000000000000606231301006202600305720ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImageViewManipulator.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdGui.h" #include "mvdImageViewRenderer.h" namespace mvd { /* TRANSLATOR mvd::ImageViewManipulator Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ const int ImageViewManipulator::DEFAULT_GRANULARITY = 1; const int ImageViewManipulator::DEFAULT_ALPHA_GRANULARITY = 10; const double ImageViewManipulator::DEFAULT_DYNAMICS_SHIFT_GRANULARITY = 0.01; const int ImageViewManipulator::DEFAULT_SCROLL_GRANULARITY = 4; const int ImageViewManipulator::DEFAULT_ZOOM_GRANULARITY = 2; const double ImageViewManipulator::DEFAULT_DELTA = 0.1; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ #if USE_VIEW_SETTINGS_SIDE_EFFECT ImageViewManipulator ::ImageViewManipulator( const otb::ViewSettings::Pointer& viewSettings, QObject* p ) : AbstractImageViewManipulator( p ), m_MousePressPosition(), m_ViewSettings( viewSettings ), m_Timer( NULL ), m_NativeSpacing(), m_MousePressOrigin(), m_RenderMode( AbstractImageViewRenderer::RenderingContext::RENDER_MODE_FULL ), m_ZoomFactor( 1.0 ), m_AlphaGranularity( ImageViewManipulator::DEFAULT_ALPHA_GRANULARITY ), m_DynamicsShiftGranularity( ImageViewManipulator::DEFAULT_DYNAMICS_SHIFT_GRANULARITY ), m_ScrollGranularity( ImageViewManipulator::DEFAULT_SCROLL_GRANULARITY ), m_ZoomGranularity( ImageViewManipulator::DEFAULT_ZOOM_GRANULARITY ), m_IsMouseDragging( false ) { m_NativeSpacing.Fill( 1.0 ); } #else // USE_VIEW_SETTINGS_SIDE_EFFECT ImageViewManipulator ::ImageViewManipulator( QObject* p ) : AbstractImageViewManipulator( p ), m_MousePressPosition(), m_ViewSettings( otb::ViewSettings::New() ), m_Timer( NULL ), m_NativeSpacing(), m_MousePressOrigin(), m_RenderMode( AbstractImageViewRenderer::RenderingContext::RENDER_MODE_FULL ), m_ZoomFactor( 1.0 ), m_AlphaGranularity( ImageViewManipulator::DEFAULT_ALPHA_GRANULARITY ), m_DynamicsShiftGranularity( ImageViewManipulator::DEFAULT_DYNAMICS_GRANULARITY ), m_ScrollGranularity( ImageViewManipulator::DEFAULT_SCROLL_GRANULARITY ), m_ZoomGranularity( ImageViewManipulator::DEFAULT_ZOOM_GRANULARITY ), m_IsMouseDragging( false ) { m_NativeSpacing.Fill( 1.0 ); } #endif // USE_VIEW_SETTINGS_SIDE_EFFECT /*****************************************************************************/ ImageViewManipulator ::~ImageViewManipulator() { } /******************************************************************************/ void ImageViewManipulator ::SetViewportSize( int width, int height ) { SizeType size; size[ 0 ] = width; size[ 1 ] = height; assert( !m_ViewSettings.IsNull() ); m_ViewSettings->SetViewportSize( size ); } /******************************************************************************/ SizeType ImageViewManipulator ::GetViewportSize() const { assert( !m_ViewSettings.IsNull() ); return m_ViewSettings->GetViewportSize(); } /******************************************************************************/ void ImageViewManipulator ::SetOrigin( const PointType& origin ) { assert( !m_ViewSettings.IsNull() ); m_ViewSettings->SetOrigin( origin ); } /******************************************************************************/ PointType ImageViewManipulator ::GetOrigin() const { assert( !m_ViewSettings.IsNull() ); return m_ViewSettings->GetOrigin(); } /******************************************************************************/ void ImageViewManipulator ::SetSpacing( const SpacingType& spacing ) { assert( !m_ViewSettings.IsNull() ); m_ViewSettings->SetSpacing( spacing ); } /******************************************************************************/ SpacingType ImageViewManipulator ::GetSpacing() const { assert( !m_ViewSettings.IsNull() ); return m_ViewSettings->GetSpacing(); } /******************************************************************************/ void ImageViewManipulator ::SetNativeSpacing( const SpacingType& spacing ) { m_NativeSpacing = spacing; } /******************************************************************************/ void ImageViewManipulator ::SetWkt( const std::string& wkt ) { assert( !m_ViewSettings.IsNull() ); m_ViewSettings->SetWkt( wkt ); } /******************************************************************************/ void ImageViewManipulator ::SetKeywordList( const DefaultImageType::ImageKeywordlistType& kwl ) { assert( !m_ViewSettings.IsNull() ); m_ViewSettings->SetKeywordList( kwl ); } /******************************************************************************/ PointType ImageViewManipulator ::GetCenter() const { assert( !m_ViewSettings.IsNull() ); return m_ViewSettings->GetViewportCenter(); } /******************************************************************************/ void ImageViewManipulator ::SetupRenderingContext( AbstractImageViewRenderer::RenderingContext * const c ) const { assert( c==dynamic_cast< ImageViewRenderer::RenderingContext const * >( c ) ); ImageViewRenderer::RenderingContext * const context = dynamic_cast< ImageViewRenderer::RenderingContext * const >( c ); // Coverity-19840 // { assert( context!=NULL ); // } context->m_RenderMode = m_IsMouseDragging ? AbstractImageViewRenderer::RenderingContext::RENDER_MODE_LIGHT : m_RenderMode; #if USE_VIEW_SETTINGS_SIDE_EFFECT #else // USE_VIEW_SETTINGS_SIDE_EFFECT context->m_ViewSettings->SetOrigin( m_ViewSettings->GetOrigin() ); context->m_ViewSettings->SetSpacing( m_ViewSettings->GetSpacing() ); context->m_ViewSettings->SetViewportSize( m_ViewSettings->GetViewportSize() ); context->m_ViewSettings->SetWkt( m_ViewSettings->GetWkt() ); context->m_ViewSettings->SetKeywordList( m_ViewSettings->GetKeywordList() ); context->m_ViewSettings->SetUseProjection( m_ViewSettings->GetUseProjection() ); context->m_ViewSettings->SetGeometryChanged( m_ViewSettings->GetGeometryChanged() ); #endif // USE_VIEW_SETTINGS_SIDE_EFFECT } /******************************************************************************/ void ImageViewManipulator ::CenterOn( const PointType& point ) { assert( !m_ViewSettings.IsNull() ); m_ViewSettings->Center( point ); emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), point ); } /******************************************************************************/ void ImageViewManipulator ::ZoomTo( double scale ) { // qDebug() << this << "::ZoomTo(" << scale << ")"; assert( scale!=0.0 ); assert( !m_ViewSettings.IsNull() ); // Remember center of viewport. otb::ViewSettings::PointType center( m_ViewSettings->GetViewportCenter() ); // Calculate spacing based on scale. #if 0 otb::ViewSettings::SpacingType spacing( m_ViewSettings->GetSpacing() ); spacing[ 0 ] = ( spacing[ 0 ]>0.0 ? 1.0 : -1.0 ) / scale; spacing[ 1 ] = ( spacing[ 1 ]>0.0 ? 1.0 : -1.0 ) / scale; #else otb::ViewSettings::SpacingType spacing( m_NativeSpacing ); // Here, zoom to arbitrary scale-factor relative to // viewport spacing. // // If viewport spacing has previously been set to // image-spacing, it zooms to arbitrary scale-factor. // // This is especially useful to set user-arbitrary scale level // such as when editing scale-level in status-bar. spacing[ 0 ] /= scale; spacing[ 1 ] /= scale; #endif // Change spacing and center. m_ViewSettings->SetSpacing( spacing ); m_ViewSettings->Center( center ); // Emit ROI changed. emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), center ); // emit RenderingContextChanged(center,GetSpacing()[0]); } /******************************************************************************/ void ImageViewManipulator ::ZoomIn() { otb::ViewSettings::SizeType size( GetViewportSize() ); PointType point; Scale( QPoint( size[ 0 ] / 2, size[ 1 ] / 2 ), m_ZoomGranularity * MOUSE_WHEEL_STEP_DEGREES, &point ); emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), point ); } /******************************************************************************/ void ImageViewManipulator ::ZoomOut() { otb::ViewSettings::SizeType size( GetViewportSize() ); PointType point; Scale( QPoint( size[ 0 ] / 2, size[ 1 ] / 2 ), -m_ZoomGranularity * MOUSE_WHEEL_STEP_DEGREES, &point ); emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), point ); } /******************************************************************************/ const PointType& ImageViewManipulator ::Transform( PointType& viewport, const QPoint& screen ) const { assert( !m_ViewSettings.IsNull() ); m_ViewSettings->ScreenToViewPortTransform( static_cast< double >( screen.x() ), static_cast< double >( screen.y() ), viewport[ 0 ], viewport[ 1 ] ); return viewport; } /******************************************************************************/ void ImageViewManipulator ::ResetViewport() { assert( !m_ViewSettings.IsNull() ); otb::ViewSettings::SizeType size( m_ViewSettings->GetViewportSize() ); m_ViewSettings->Reset(); m_ViewSettings->SetViewportSize( size ); m_NativeSpacing.Fill( 1.0 ); m_ZoomFactor = 1.0; emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), m_ViewSettings->GetViewportCenter() ); } /******************************************************************************/ void ImageViewManipulator ::MousePressEvent( QMouseEvent* e ) { // qDebug() << this << "::MousePressEvent(" << e << ")"; assert( e!=NULL ); switch( e->button() ) { case Qt::NoButton: break; case Qt::LeftButton: m_MousePressPosition = e->pos(); m_MousePressOrigin = m_ViewSettings->GetOrigin(); m_IsMouseDragging = true; break; case Qt::RightButton: emit ToggleLayerVisibilityRequested( false ); break; case Qt::MidButton: break; case Qt::XButton1: break; case Qt::XButton2: break; default: assert( false && "Unhandled Qt::MouseButton." ); break; } /* Qt::NoModifier 0x00000000 No modifier key is pressed. Qt::ShiftModifier 0x02000000 A Shift key on the keyboard is pressed. Qt::ControlModifier 0x04000000 A Ctrl key on the keyboard is pressed. Qt::AltModifier 0x08000000 An Alt key on the keyboard is pressed. Qt::MetaModifier 0x10000000 A Meta key on the keyboard is pressed. Qt::KeypadModifier 0x20000000 A keypad button is pressed. Qt::GroupSwitchModifier */ } /******************************************************************************/ void ImageViewManipulator ::MouseMoveEvent( QMouseEvent* e ) { // qDebug() << this << "::MouseMoveEvent(" << e << ")"; assert( e!=NULL ); /* qDebug() << "------------------------------------------------"; qDebug() << this << ":" << e; */ Qt::MouseButtons buttons = e->buttons(); Qt::KeyboardModifiers modifiers = e->modifiers(); if( buttons==Qt::LeftButton && ( modifiers==Qt::NoModifier || modifiers== Qt::ControlModifier ) ) { // Cursor moves from press position to current position; // Image moves the same direction, so apply the negative translation. Translate( m_MousePressPosition - e->pos() ); m_MousePressPosition = e->pos(); emit RefreshViewRequested(); emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), m_ViewSettings->GetViewportCenter() ); } } /******************************************************************************/ void ImageViewManipulator ::MouseReleaseEvent( QMouseEvent* e) { // qDebug() << this << "::MouseReleaseEvent(" << e << ")"; assert( e!=NULL ); /* qDebug() << this << ":" << e; */ /* Qt::MouseButtons buttons = e->buttons(); Qt::KeyboardModifiers modifiers = e->modifiers(); */ // PointType center; switch( e->button() ) { case Qt::NoButton: break; case Qt::LeftButton: m_MousePressPosition = QPoint(); m_MousePressOrigin = PointType(); m_IsMouseDragging = false; emit RefreshViewRequested(); break; case Qt::RightButton: emit ToggleLayerVisibilityRequested( true ); break; case Qt::MidButton: break; case Qt::XButton1: break; case Qt::XButton2: break; default: assert( false && "Unhandled Qt::MouseButton." ); break; } } /******************************************************************************/ void ImageViewManipulator ::MouseDoubleClickEvent( QMouseEvent * e ) { // qDebug() << this << "::MouseDoubleClickEvent(" << e << ")"; assert( e!=NULL ); if( e->button()==Qt::LeftButton && e->modifiers()==Qt::NoModifier ) { PointType center; assert( !m_ViewSettings.IsNull() ); const QPoint & p = e->pos(); m_ViewSettings->ScreenToViewPortTransform( p.x(), p.y(), center[ 0 ], center[ 1 ] ); CenterOn( center ); } } /******************************************************************************/ void ImageViewManipulator #if USE_VIEW_SETTINGS_SIDE_EFFECT ::ResizeEvent( QResizeEvent * ) #else // USE_VIEW_SETTINGS_SIDE_EFFECT ::ResizeEvent( QResizeEvent * e ) #endif // USE_VIEW_SETTINGS_SIDE_EFFECT { // assert( e!=NULL ); // qDebug() << this << "::ResizeEvent(" << e << ")"; /* qDebug() << m_ViewSettings.GetPointer(); otb::ViewSettings::SizeType size( m_ViewSettings->GetViewportSize() ); qDebug() << size[ 0 ] << "," << size[ 1 ] << "\t" << e->size(); */ #if USE_VIEW_SETTINGS_SIDE_EFFECT #else // USE_VIEW_SETTINGS_SIDE_EFFECT assert( e!=NULL ); SetViewportSize( e->size().width(), e->size().height() ); #endif // USE_VIEW_SETTINGS_SIDE_EFFECT } /******************************************************************************/ void ImageViewManipulator ::WheelEvent( QWheelEvent * e ) { assert( e!=NULL ); Qt::MouseButtons buttons = e->buttons(); Qt::KeyboardModifiers modifiers = e->modifiers(); if( buttons!=Qt::NoButton ) return; // Delta is rotation distance in number of 8th of degrees (see // http://qt-project.org/doc/qt-4.8/qwheelevent.html#delta). assert( e->delta()!=0 ); int degrees = e->delta() / MOUSE_WHEEL_STEP_FACTOR; if( modifiers==Qt::ControlModifier ) emit RotateLayersRequested( e->delta() / (MOUSE_WHEEL_STEP_FACTOR * MOUSE_WHEEL_STEP_DEGREES) ); // else if( modifiers==Qt::MetaModifier ) { // qDebug() << "META+Wheel" << e->delta(); emit ShiftAlphaRequested( static_cast< double >( m_AlphaGranularity * e->delta() / ( MOUSE_WHEEL_STEP_FACTOR * MOUSE_WHEEL_STEP_DEGREES ) ) / 100.0 ); } else if( modifiers==(Qt::MetaModifier | Qt::ShiftModifier) ) { // qDebug() << "META+SHIFT+Wheel" << e->delta(); emit UpdateGammaRequested( ImageViewManipulator::Factor( degrees, MOUSE_WHEEL_STEP_DEGREES ) ); } // else if( modifiers==Qt::AltModifier ) { // qDebug() << "ALT+Wheel" << e->delta(); emit ResizeShaderRequested( ImageViewManipulator::Factor( degrees, MOUSE_WHEEL_STEP_DEGREES ) ); } else if( modifiers==(Qt::AltModifier | Qt::ShiftModifier) ) { // qDebug() << "ALT+SHIFT+Wheel" << e->delta(); emit ReparamShaderRequested( ImageViewManipulator::Factor( degrees, MOUSE_WHEEL_STEP_DEGREES ) ); } // else if( modifiers==(Qt::ControlModifier | Qt::AltModifier) ) { // qDebug() << "CTRL+ALT+Wheel" << e->delta(); emit ShiftDynamicsRequested( m_DynamicsShiftGranularity * static_cast< double >( e->delta() / ( MOUSE_WHEEL_STEP_FACTOR * MOUSE_WHEEL_STEP_DEGREES ) ) ); } else if( modifiers==(Qt::ControlModifier | Qt::AltModifier | Qt::ShiftModifier) ) { // qDebug() << "CTRL+ALT+SHIFT+Wheel" << e->delta(); emit ScaleDynamicsRequested( ImageViewManipulator::Factor( degrees, MOUSE_WHEEL_STEP_DEGREES ) ); } // else if( modifiers==Qt::NoModifier ) { if( m_Timer==NULL ) { m_Timer = new QTimer(); QObject::connect( m_Timer, SIGNAL( timeout() ), // to: this, SLOT( OnTimeout() ) ); } m_Timer->start( 500 ); SetFastRenderMode( true ); PointType point; Scale( e->pos(), degrees, &point ); emit RefreshViewRequested(); emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), point ); } } /******************************************************************************/ void ImageViewManipulator ::KeyPressEvent( QKeyEvent* e ) { assert( e!=NULL ); // qDebug() << this << "::KeyPressEvent(" << e << ")"; QPoint vector( 0, 0 ); int steps = 0; int key = e->key(); Qt::KeyboardModifiers modifiers = e->modifiers(); switch( key ) { case Qt::Key_Up: vector.setY( -1 ); break; case Qt::Key_Down: vector.setY( +1 ); break; case Qt::Key_Left: vector.setX( -1 ); break; case Qt::Key_Right: vector.setX( +1 ); break; case Qt::Key_Plus: steps = m_ZoomGranularity; break; case Qt::Key_Minus: steps = -m_ZoomGranularity; break; case Qt::Key_PageUp: if( e->modifiers()==Qt::ShiftModifier ) emit LayerToTopRequested(); else emit RaiseLayerRequested(); break; case Qt::Key_PageDown: if( e->modifiers()==Qt::ShiftModifier ) emit LayerToBottomRequested(); else emit LowerLayerRequested(); break; case Qt::Key_Home: if( e->modifiers()==Qt::ShiftModifier ) emit SelectFirstLayerRequested(); else emit SelectPreviousLayerRequested(); break; case Qt::Key_End: if( e->modifiers()==Qt::ShiftModifier ) emit SelectLastLayerRequested(); else emit SelectNextLayerRequested(); break; case Qt::Key_Delete: if( modifiers.testFlag( Qt::ShiftModifier ) ) emit DeleteAllRequested(); else emit DeleteSelectedRequested(); break; case Qt::Key_1: emit ZoomToFullResolutionRequested(); break; case Qt::Key_2: emit ZoomToLayerExtentRequested(); break; case Qt::Key_3: emit ZoomToFullExtentRequested(); break; case Qt::Key_A: emit ApplyAllRequested(); break; case Qt::Key_C: emit ShaderEffectRequested( EFFECT_CHESSBOARD ); break; case Qt::Key_G: emit ShaderEffectRequested( EFFECT_GRADIENT ); break; case Qt::Key_D: emit ShaderEffectRequested( EFFECT_LOCAL_CONTRAST ); break; case Qt::Key_H: emit ShaderEffectRequested( EFFECT_SWIPE_H ); break; case Qt::Key_N: emit ShaderEffectRequested( EFFECT_NORMAL ); break; case Qt::Key_P: if( modifiers.testFlag( Qt::ControlModifier ) ) emit TakeScreenshotRequested( modifiers.testFlag( Qt::ShiftModifier ) ); else emit SetReferenceRequested(); break; case Qt::Key_Q: emit ResetQuantilesRequested( modifiers.testFlag( Qt::ShiftModifier ) ); break; case Qt::Key_S: emit ShaderEffectRequested( EFFECT_SPECTRAL_ANGLE ); break; case Qt::Key_T: emit ShaderEffectRequested( EFFECT_LOCAL_TRANSLUCENCY ); break; case Qt::Key_V: emit ShaderEffectRequested( EFFECT_SWIPE_V ); break; default: break; } assert( !m_ViewSettings.IsNull() ); bool needsRefresh = false; // // Translate if( !vector.isNull() ) { otb::ViewSettings::SizeType size( m_ViewSettings->GetViewportSize() ); if( modifiers==Qt::NoModifier ) { size[ 0 ] /= m_ScrollGranularity; size[ 1 ] /= m_ScrollGranularity; } else if( modifiers==Qt::ControlModifier ) { size[ 0 ] /= m_ScrollGranularity * 2; size[ 1 ] /= m_ScrollGranularity * 2; } vector.rx() *= size[ 0 ]; vector.ry() *= size[ 1 ]; Translate( vector ); needsRefresh = true; } // // Scale if( steps!=0 ) { // Qt::ControlModifier doest not work with keypard Qt::Key_Plus/Minus keys. otb::ViewSettings::SizeType size( m_ViewSettings->GetViewportSize() ); Scale( QPoint( size[ 0 ] / 2.0, size[ 1 ] / 2.0 ), steps * MOUSE_WHEEL_STEP_DEGREES ); needsRefresh = true; } // // Refresh if( needsRefresh ) { emit RefreshViewRequested(); emit RoiChanged( GetOrigin(), GetViewportSize(), GetSpacing(), m_ViewSettings->GetViewportCenter() ); } } /******************************************************************************/ void ImageViewManipulator ::KeyReleaseEvent( QKeyEvent * ) { // assert( e!=NULL ); // qDebug() << this << "::KeyPressEvent(" << e << ")"; } /******************************************************************************/ void ImageViewManipulator ::Translate( const QPoint& vector ) { // qDebug() << this << "::Translate(" << vector << ")"; m_ViewSettings->SetOrigin( ImageViewManipulator::Translate( vector, m_ViewSettings->GetOrigin(), m_ViewSettings->GetSpacing() ) ); } /******************************************************************************/ PointType ImageViewManipulator ::Translate( const QPoint& vector, const PointType& origin, const SpacingType& spacing ) { // qDebug() << this << "::Translate(...)"; otb::ViewSettings::PointType origin2( origin ); origin2[ 0 ] += static_cast< double >( vector.x() ) * spacing[ 0 ]; origin2[ 1 ] += static_cast< double >( vector.y() ) * spacing[ 1 ]; /* qDebug() << "(" << m_MousePressOrigin[ 0 ] << "," << m_MousePressOrigin[ 1 ] << ")" << "(" << spacing[ 0 ] << "," << spacing[ 1 ] << ")" << "(" << origin[ 0 ] << "," << origin[ 1 ] << ")"; */ return origin2; } /******************************************************************************/ void ImageViewManipulator ::Scale( const QPoint& center, int degrees, PointType* centerPoint ) { assert( degrees!=0 ); if( degrees==0 ) return; otb::ViewSettings::PointType point; Transform( point, center ); if( centerPoint!=NULL ) *centerPoint = point; // See http://qt-project.org/doc/qt-4.8/qwheelevent.html#delta . assert( m_ZoomGranularity!=0 ); int granularity = m_ZoomGranularity; if( granularity==0 ) granularity = 1; double factor = pow( 2.0, -static_cast< double >( degrees ) / static_cast< double >( granularity * MOUSE_WHEEL_STEP_DEGREES ) ); m_ZoomFactor *= factor; /* qDebug() << "(" << point[ 0 ] << "," << point[ 1 ] << ")" << "g:" << granularity << "d:" << degrees << "s:" << (static_cast< double >( degrees ) / 15.0) << "f:" << factor << "z:" << m_ZoomFactor; */ m_ViewSettings->Zoom( point, factor ); } /*****************************************************************************/ ZoomType ImageViewManipulator ::GetFixedZoomType() const { return ZOOM_TYPE_NONE; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void ImageViewManipulator ::OnTimeout() { assert( m_Timer!=NULL ); SetFastRenderMode( false ); emit RefreshViewRequested(); delete m_Timer; m_Timer = NULL; } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdImageViewRenderer.cxx000066400000000000000000001005201301006202600300340ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImageViewRenderer.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // necessary for the opengl variables and methods // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbStandardShader.h" #include "otbGlImageActor.h" #include "otbGlVersionChecker.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractLayerModel.h" #include "mvdAlgorithm.h" #include "mvdI18nCoreApplication.h" #include "mvdTypes.h" #include "mvdVectorImageModel.h" namespace mvd { /* TRANSLATOR mvd::ImageViewRenderer Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ImageViewRenderer::RenderingContext ::RenderingContext() : AbstractImageViewRenderer::RenderingContext(), m_Resolution( RESOLUTION_NEAREST ), m_TileSize( 256 ) #if USE_VIEW_SETTINGS_SIDE_EFFECT #else // USE_VIEW_SETTINGS_SIDE_EFFECT ,m_ViewSettings() #endif // USE_VIEW_SETTINGS_SIDE_EFFECT { assert( I18nCoreApplication::ConstInstance()!=NULL ); // // Rendering settings. { QVariant value( I18nCoreApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_RESOLUTION ) ); m_Resolution = !value.isValid() ? RESOLUTION_DEFAULT : static_cast< Resolution >( value.toInt() ); } { QVariant value( I18nCoreApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_TILE_SIZE ) ); m_TileSize = !value.isValid() ? TILE_SIZE_VALUE[ TILE_SIZE_DEFAULT ] : value.toInt(); } } /*****************************************************************************/ ImageViewRenderer::RenderingContext ::~RenderingContext() { } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ImageViewRenderer ::ImageViewRenderer( QObject* p ) : AbstractImageViewRenderer( p ), m_GlView( otb::GlView::New() ), m_EffectsEnabled( true ) #ifdef _WIN32 #else // _WIN32 , m_ReferencePair( NULL, otb::GlActor::Pointer() ) #endif // _WIN32 // m_ModelActorPairs(), { #ifdef _WIN32 m_ReferencePair.first = NULL; // m_ReferencePair.second is initialized by otb::GlActor::Pointer default constructor. #else // _WIN32 #endif // _WIN32 } /*****************************************************************************/ ImageViewRenderer ::~ImageViewRenderer() { } /*****************************************************************************/ bool ImageViewRenderer ::CheckGLCapabilities( int * glsl140 ) { #if USE_REMOTE_DESKTOP_DISABLED_RENDERING return true; #else // USE_REMOTE_DESKTOP_DISABLED_RENDERING // // Trace required OpenGL and GLSL versions. qWarning() << ToStdString( tr( "Required OpenGL version '%1' with GLSL version '%2'." ) .arg( otb::GlVersionChecker::REQUIRED_GL_VERSION ) .arg( otb::GlVersionChecker::REQUIRED_GLSL_VERSION ) ).c_str(); // // Get and check OpenGL and GLSL versions. const char * glVersion = NULL; const char * glslVersion = NULL; bool isOk = false; try { isOk = otb::GlVersionChecker::CheckGLCapabilities( glVersion, glslVersion ); if( glsl140!=NULL ) *glsl140 = otb::GlVersionChecker::VerCmp( glslVersion, "1.40" ); // // Trace runtime OpenGL and GLSL versions. qWarning() << ToStdString( tr( "Runtime OpenGL version '%1' with GLSL version '%2'." ) .arg( glVersion ) .arg( glslVersion ) ).c_str(); } catch( std::exception& exc ) { QMessageBox::critical( qobject_cast< QWidget* >( parent() ), tr( "Critical error!"), ToQString( exc.what() ) ); } // // Set GLSL effects state. SetGLSLEnabled( isOk ); // // Return if check has succeeded. if( isOk ) return true; // // Construct message. QString message( tr( "Current OpenGL version is '%1' supporting OpenGL Shading-Language (GLSL) version '%2'.\nTo run at best performances, this application needs, at least, OpenGL version '%3' with GLSL version '%4'.\nThe application will automatically switch to a rendering mode which does not make use of OpenGL shaders and GLSL.\nIf you are running this application under some remote-desktop service, runtime OpenGL and GLSL versions may differ from those running directly on remote platform." ) .arg( glVersion ) .arg( glslVersion ) .arg( otb::GlVersionChecker::REQUIRED_GL_VERSION ) .arg( otb::GlVersionChecker::REQUIRED_GLSL_VERSION ) ); // // Warn user is check has failed. qWarning() << ToStdString( message ).c_str(); #if 0 QMessageBox::critical( qobject_cast< QWidget* >( parent() ), tr( "Critical error!" ), message ); #endif // // KO. return false; #endif // USE_REMOTE_DESKTOP_DISABLED_RENDERING } /*****************************************************************************/ AbstractImageViewRenderer::RenderingContext* ImageViewRenderer ::NewRenderingContext() const { RenderingContext* context = new ImageViewRenderer::RenderingContext(); #if USE_VIEW_SETTINGS_SIDE_EFFECT #else assert( !m_GlView.IsNull() ); // // Share otb::GlViewRendering settings with manipulator using // RenderingContext. Manipulator can then setup otb::ViewSettings // directly by side-effect. context->m_ViewSettings = m_GlView->GetSettings(); #endif return context; } /*****************************************************************************/ const AbstractLayerModel * ImageViewRenderer ::GetReferenceModel() const { return m_ReferencePair.first; } /*****************************************************************************/ AbstractLayerModel* ImageViewRenderer ::GetReferenceModel() { return m_ReferencePair.first; } /*****************************************************************************/ void ImageViewRenderer ::GetLayerExtent( const StackedLayerModel::KeyType & key, PointType & origin, PointType & extent ) const { assert( !m_GlView.IsNull() ); otb::GlActor::Pointer actor( m_GlView->GetActor( key ) ); if( actor.IsNull() ) { origin[ 0 ] = origin[ 1 ] = 0; extent[ 0 ] = extent[ 1 ] = 0; return; } actor->GetExtent( origin[ 0 ], origin[ 1 ], extent[ 0 ], extent[ 1 ] ); } /*****************************************************************************/ void ImageViewRenderer ::GetReferenceExtent( PointType& origin, PointType& extent ) const { assert( GetLayerStack()!=NULL ); GetLayerExtent( GetLayerStack()->GetKey( GetLayerStack()->GetReferenceIndex() ), origin, extent ); } /*****************************************************************************/ void ImageViewRenderer ::GetViewExtent( PointType & origin, PointType & extent ) const { assert( !m_GlView.IsNull() ); m_GlView->GetExtent( origin, extent ); } /*****************************************************************************/ void ImageViewRenderer ::InitializeGL() { assert( !m_GlView.IsNull() ); // // WARNING: This call to otb::GlView::Initialize() allocates a new // otb::ViewSettings() instance. So, the shared pointer between // renderer and manipulator may be unshated depending on order of // calls. // m_GlView->Initialize( 0, 0 ); } /*****************************************************************************/ void ImageViewRenderer ::ResizeGL( int width, int height ) { // qDebug() << this << "::ResizeGL(" << width << "," << height << ")"; assert( !m_GlView.IsNull() ); // qDebug() << m_GlView.GetPointer(); m_GlView->Resize( width, height ); } /*****************************************************************************/ void ImageViewRenderer ::PaintGL( const AbstractImageViewRenderer::RenderingContext* c ) { assert( !m_GlView.IsNull() ); // qDebug() << this << "::PaintGL(" << c << ")"; // qDebug() << m_GlView.GetPointer(); #if USE_REMOTE_DESKTOP_DISABLED_RENDERING && 0 #else // USE_REMOTE_DESKTOP_DISABLED_RENDERING // // Apply VectorImageSettings to otb::GlImageActor. UpdateActors( c ); // // Bypass rendering if needed. if( IsBypassRenderingEnabled() ) { // qDebug() << "}\n"; return; } // qDebug() << m_GlView.GetPointer() << "::BeforeRendering()"; // qDebug() << "{"; // // Pre-render scene. m_GlView->BeforeRendering(); { // // Render scene. switch( c->m_RenderMode ) { case RenderingContext::RENDER_MODE_LIGHT: // qDebug() << "otb::GlView::LightRender()"; m_GlView->LightRender(); break; case RenderingContext::RENDER_MODE_FULL: // qDebug() << "otb::GlView::HeavyRender()"; m_GlView->HeavyRender(); break; default: assert( false && "Unhandled RenderingContext::RenderModel value!" ); break; } } // // Post-render scene. m_GlView->AfterRendering(); // qDebug() << "}"; // qDebug() << m_GlView.GetPointer() << "::AfterRendering()"; #endif // USE_REMOTE_DESKTOP_DISABLED_RENDERING } /*****************************************************************************/ void ImageViewRenderer ::Pick( const PointType & ptView, PixelInfo::Vector & pixels ) const { // qDebug() // << this << "::Pick(" // << ptView[ 0 ] << "," << ptView[ 1 ] // << ")"; assert( !m_GlView.IsNull() ); // // Get actor keys. otb::GlView::StringVectorType keys( m_GlView->GetRenderingOrder() ); // Prepare picked pixels container. pixels.resize( keys.size() ); // Pick each layer. size_t i = 0; for( otb::GlView::StringVectorType::const_iterator it( keys.begin() ); it != keys.end(); ++ it, ++ i ) { // Register layer key. pixels[ i ].m_Key = *it; // Get actor. otb::GlActor::Pointer actor( m_GlView->GetActor( *it ) ); assert( !actor.IsNull() ); // Get geo-interface. const otb::GeoInterface * geoInterface = dynamic_cast< const otb::GeoInterface * >( actor.GetPointer() ); // If geo-interface... if( geoInterface!=NULL ) { // ...compute physical point. pixels[ i ].m_HasPoint = geoInterface->TransformFromViewport( pixels[ i ].m_Point, ptView, true ); } else { pixels[ i ].m_HasPoint = false; pixels[ i ].m_Point = PointType(); } // If image-actor... otb::GlImageActor::Pointer imageActor( otb::DynamicCast< otb::GlImageActor >( actor ) ); if( !imageActor.IsNull() ) { // ...get pixel and it's index... pixels[ i ].m_HasIndex = pixels[ i ].m_HasPixel = imageActor->GetPixel( pixels[ i ].m_Point, pixels[ i ].m_Pixel, pixels[ i ].m_Index ); // ...and get resolutions. pixels[ i ].m_HasResolution = true; pixels[ i ].m_Resolution = imageActor->GetCurrentResolution(); } } } /*****************************************************************************/ void ImageViewRenderer ::GetResolutions( PixelInfo::Vector & pixels ) const { // qDebug() << this << "::GetResolutions()"; assert( !m_GlView.IsNull() ); // // Get actor keys. otb::GlView::StringVectorType keys( m_GlView->GetRenderingOrder() ); if( keys.empty() ) return; // Resize pixels container, if needed. if( keys.size()!=pixels.size() ) pixels.resize( keys.size() ); // Pick each layer. size_t i = 0; for( otb::GlView::StringVectorType::const_iterator it( keys.begin() ); it != keys.end(); ++ it, ++ i ) { // Check layer key. pixels[ i ].m_Key = *it; // Get actor. otb::GlActor::Pointer actor( m_GlView->GetActor( *it ) ); assert( !actor.IsNull() ); // If image-actor... otb::GlImageActor::Pointer imageActor( otb::DynamicCast< otb::GlImageActor >( actor ) ); if( !imageActor.IsNull() ) { pixels[ i ].m_HasResolution = true; pixels[ i ].m_Resolution = imageActor->GetCurrentResolution(); } else { pixels[ i ].m_HasResolution = false; } } } /*****************************************************************************/ bool ImageViewRenderer ::TransformToView( PointType & point, const StackedLayerModel::KeyType & key, const IndexType & index, bool isPhysical ) const { assert( !m_GlView.IsNull() ); assert( !key.empty() ); otb::GlActor::Pointer actor( m_GlView->GetActor( key ) ); assert( !actor.IsNull() ); const otb::GeoInterface * geo = dynamic_cast< const otb::GeoInterface * >( actor.GetPointer() ); if( geo==NULL ) return false; point[ 0 ] = static_cast< double >( index[ 0 ] ); point[ 1 ] = static_cast< double >( index[ 1 ] ); return geo->TransformToViewport( point, point, isPhysical ); } /*****************************************************************************/ void ImageViewRenderer ::UpdateActors( const AbstractImageViewRenderer::RenderingContext * context ) { // qDebug() << this << "::virtual_UpdateActors()"; assert( !m_GlView.IsNull() ); assert( context!=NULL ); StackedLayerModel * stackedLayerModel = GetLayerStack(); if( stackedLayerModel==NULL ) return; for( StackedLayerModel::ConstIterator it( stackedLayerModel->Begin() ); it!=stackedLayerModel->End(); ++it ) { assert( !it->first.empty() ); assert( it->second!=NULL ); if( m_GlView->ContainsActor( it->first ) ) { if( it->second->inherits( VectorImageModel::staticMetaObject.className() ) ) { // // Get vector image-model. VectorImageModel * vectorImageModel = dynamic_cast< VectorImageModel * >( it->second ); assert( vectorImageModel!=NULL ); // // Get vector image-model data. const VectorImageSettings & settings = vectorImageModel->GetSettings(); const ImageProperties * properties = vectorImageModel->GetProperties(); // // Get GL image-actor. assert( m_GlView->GetActor( it->first )== otb::DynamicCast< otb::GlImageActor >( m_GlView->GetActor( it->first ) ) ); otb::GlImageActor::Pointer imageActor( otb::DynamicCast< otb::GlImageActor >( m_GlView->GetActor( it->first ) ) ); assert( !imageActor.IsNull() ); // // Apply rendering parameters. { const RenderingContext * ctxt = static_cast< const RenderingContext * >( context ); // Resolution switch( ctxt->m_Resolution ) { case RESOLUTION_NEAREST: imageActor->SetResolutionAlgorithm( otb::GlImageActor::ResolutionAlgorithm::Nearest ); break; case RESOLUTION_LOWER: imageActor->SetResolutionAlgorithm( otb::GlImageActor::ResolutionAlgorithm::Nearest_Lower ); break; case RESOLUTION_UPPER: imageActor->SetResolutionAlgorithm( otb::GlImageActor::ResolutionAlgorithm::Nearest_Upper ); break; default: assert( false && "Unexpected Resolution enum value." ); break; } // Tile-size imageActor->SetTileSize( ctxt->m_TileSize ); } // // Apply visibility. imageActor->SetVisible( vectorImageModel->IsVisible() ); // // Apply color-setup. VectorImageSettings::ChannelVector channels; settings.GetSmartChannels( channels ); imageActor->SetRedIdx( channels[ RGBW_CHANNEL_RED ] + 1 ); imageActor->SetGreenIdx( channels[ RGBW_CHANNEL_GREEN ] + 1 ); imageActor->SetBlueIdx( channels[ RGBW_CHANNEL_BLUE ] + 1 ); // // Apply color-dynamics. otb::ImageSettings::Pointer imageSettings( imageActor->GetImageSettings() ); assert( !imageSettings.IsNull() ); if( settings.IsGrayscaleActivated() ) { imageSettings->SetMinRed( settings.GetLowIntensity( RGBW_CHANNEL_WHITE ) ); imageSettings->SetMaxRed( settings.GetHighIntensity(RGBW_CHANNEL_WHITE ) ); imageSettings->SetMinGreen( settings.GetLowIntensity( RGBW_CHANNEL_WHITE ) ); imageSettings->SetMaxGreen( settings.GetHighIntensity(RGBW_CHANNEL_WHITE ) ); imageSettings->SetMinBlue( settings.GetLowIntensity( RGBW_CHANNEL_WHITE ) ); imageSettings->SetMaxBlue( settings.GetHighIntensity(RGBW_CHANNEL_WHITE ) ); } else { imageSettings->SetMinRed( settings.GetLowIntensity( RGBW_CHANNEL_RED ) ); imageSettings->SetMaxRed( settings.GetHighIntensity(RGBW_CHANNEL_RED ) ); imageSettings->SetMinGreen( settings.GetLowIntensity( RGBW_CHANNEL_GREEN ) ); imageSettings->SetMaxGreen( settings.GetHighIntensity(RGBW_CHANNEL_GREEN ) ); imageSettings->SetMinBlue( settings.GetLowIntensity( RGBW_CHANNEL_BLUE ) ); imageSettings->SetMaxBlue( settings.GetHighIntensity(RGBW_CHANNEL_BLUE ) ); } // qDebug() << this << " gamma: " << settings.GetGamma(); imageSettings->SetGamma( settings.GetGamma() ); if( properties==NULL ) imageSettings->SetUseNoData( false ); else { imageSettings->SetUseNoData( properties->IsNoDataEnabled() ); imageSettings->SetNoData( properties->GetNoData() ); } // // qDebug() // << "alpha:" << settings.GetAlpha() // << "'" << it->first.c_str() << "'"; imageSettings->SetAlpha( settings.GetAlpha() ); // // Apply shader properties. // // Must use local variable to cast from T* to T::Pointer because // of ITK set/get macros... otb::FragmentShader::Pointer fragmentShader( imageActor->GetShader() ); if( !fragmentShader.IsNull() ) { // If this point is reached, shader is not null which means // that isGLSLEnabled() is true. assert( IsGLSLEnabled() ); otb::StandardShader::Pointer shader( otb::DynamicCast< otb::StandardShader >( fragmentShader ) ); assert( !shader.IsNull() ); if( m_EffectsEnabled ) switch( settings.GetEffect() ) { case EFFECT_CHESSBOARD: shader->SetShaderType( otb::SHADER_ALPHA_GRID ); shader->SetChessboardSize( settings.GetSize() ); break; case EFFECT_GRADIENT: shader->SetShaderType( otb::SHADER_GRADIENT ); shader->SetRadius( settings.GetSize() ); break; case EFFECT_LOCAL_CONTRAST: shader->SetShaderType( otb::SHADER_LOCAL_CONTRAST ); shader->SetRadius( settings.GetSize() ); shader->SetLocalContrastRange( #if 0 settings.GetValue() * std::max( std::max( shader->GetMaxRed() - shader->GetMinRed(), shader->GetMaxGreen() - shader->GetMinGreen() ), shader->GetMaxBlue() - shader->GetMinBlue() ) #else settings.GetValue() #endif ); break; case EFFECT_LOCAL_TRANSLUCENCY: shader->SetShaderType( otb::SHADER_LOCAL_ALPHA ); shader->SetRadius( settings.GetSize() ); break; case EFFECT_NONE: case EFFECT_NORMAL: shader->SetShaderType( otb::SHADER_STANDARD ); break; case EFFECT_SPECTRAL_ANGLE: shader->SetShaderType( otb::SHADER_SPECTRAL_ANGLE ); shader->SetRadius( settings.GetSize() ); shader->SetSpectralAngleRange( settings.GetValue() ); break; case EFFECT_SWIPE_H: shader->SetShaderType( otb::SHADER_ALPHA_SLIDER ); shader->SetVerticalSlider( false ); break; case EFFECT_SWIPE_V: shader->SetShaderType( otb::SHADER_ALPHA_SLIDER ); shader->SetVerticalSlider( true ); break; default: assert( false && "Unhandled mvd::Effect value!" ); break; } } } // else { qDebug() << __FILE__ << ":" << __LINE__ << ": Unhandled AbstractLayerModel derived class."; } } } m_GlView->SetRenderingOrder( stackedLayerModel->GetKeys(), false ); } /*******************************************************************************/ void ImageViewRenderer ::virtual_UpdateScene() { // qDebug() << this << "::virtual_UpdateScene()"; assert( !m_GlView.IsNull() ); #if DISABLE_QUICKLOOK_VIEW if( objectName()=="QuicklookViewRenderer" ) return; #endif StackedLayerModel * stackedLayerModel = GetLayerStack(); if( stackedLayerModel==NULL || stackedLayerModel->IsEmpty() ) { m_GlView->ClearActors(); // // MANTIS-1244: image-view not reset when layer-stack is cleared. // { emit ResetViewport(); // } } else { { otb::GlView::StringVectorType keys( m_GlView->GetActorsKeys() ); for( otb::GlView::StringVectorType::const_iterator it( keys.begin() ); it!=keys.end(); ++it ) if( !stackedLayerModel->Contains( *it ) ) { // qDebug() // << QString( "Removing image-actor '%1'..." ).arg( it->c_str() ); m_GlView->RemoveActor( *it ); } } #if USE_REMOTE_DESKTOP_DISABLED_RENDERING #else // USE_REMOTE_DESKTOP_DISABLED_RENDERING for( StackedLayerModel::ConstIterator it( stackedLayerModel->Begin() ); it!=stackedLayerModel->End(); ++it ) if( !m_GlView->ContainsActor( it->first ) ) { assert( it->second!=NULL ); if( it->second->inherits( VectorImageModel::staticMetaObject.className())) { otb::GlImageActor::Pointer glImageActor( otb::GlImageActor::New() ); // Should all AbstractLayerModel have a ::GetFilename() // method? // -> Not sure: AbstractImageModel coud be derived as a // in-memory image-model. VectorImageModel * vectorImageModel = dynamic_cast< VectorImageModel * >( it->second ); // Coverity-19839 // { assert( vectorImageModel!=NULL ); // } // qDebug() // << QString( "Adding image-actor from file '%1'..." ) // .arg( vectorImageModel->GetFilename() ); // qDebug() // << this << "\n" // << "\tQString:" << vectorImageModel->GetFilename() // << "\tstd::string" << QFile::encodeName( vectorImageModel->GetFilename() ); if( IsGLSLEnabled() ) { // qDebug() << "Created shader for" << FromStdString( it->first ); glImageActor->CreateShader(); } glImageActor->Initialize( QFile::encodeName( vectorImageModel->GetFilename() ) .constData() ); m_GlView->AddActor( glImageActor, it->first ); // glImageActor->SetVisible( vectorImageModel->IsVisible() ); // qDebug() << // QString( "Added image-actor '%1' from file '%2'" ) // .arg( FromStdString( it->first ) ) // .arg( vectorImageModel->GetFilename() ); } else { assert( false && "Unhandled AbstractLayerModel derived type." ); } } #endif // USE_REMOTE_DESKTOP_DISABLED_RENDERING } RefreshScene(); } /*******************************************************************************/ void ImageViewRenderer ::virtual_RefreshScene() { // qDebug() << this << "::virtual_RefreshScene()"; // // Get layer-stack. StackedLayerModel * stackedLayerModel = GetLayerStack(); // // Check if empty. if( stackedLayerModel==NULL || stackedLayerModel->IsEmpty() ) { m_ReferencePair.first = NULL; m_ReferencePair.second = otb::GlActor::Pointer(); // virtual_ClearProjection(); // assert( !m_GlView.IsNull() ); // assert( m_GlView->GetSettings() ); // m_GlView->GetSettings()->SetUseProjection( false ); // emit ClearProjectionRequired(); return; } // // Check if non-projected mode. if( !stackedLayerModel->HasReference() ) { m_ReferencePair.first = NULL; m_ReferencePair.second = otb::GlActor::Pointer(); virtual_ClearProjection(); assert( !m_GlView.IsNull() ); assert( m_GlView->GetSettings() ); m_GlView->GetSettings()->SetUseProjection( false ); emit ClearProjectionRequired(); return; } // // Otherwise, it's projected mode. assert( !m_GlView.IsNull() ); assert( m_GlView->GetSettings()!=NULL ); m_GlView->GetSettings()->SetUseProjection( true ); // // Store reference-pair. ModelActorPair referencePair( m_ReferencePair ); // // Remember first layer-model as projection reference. m_ReferencePair.first = stackedLayerModel->GetReference(); StackedLayerModel::KeyType referenceKey( stackedLayerModel->GetKey( stackedLayerModel->GetReferenceIndex() ) ); #if USE_REMOTE_DESKTOP_DISABLED_RENDERING m_ReferencePair.second = otb::GlActor::Pointer(); #else // USE_REMOTE_DESKTOP_DISABLED_RENDERING // // Remember reference actor. { otb::GlActor::Pointer glActor( m_GlView->GetActor( referenceKey ) ); // assert( !glActor.IsNull() ); assert( glActor==otb::DynamicCast< otb::GlImageActor >( glActor ) ); m_ReferencePair.second = otb::DynamicCast< otb::GlImageActor >( glActor ); // assert( !m_ReferencePair.second.IsNull() ); } if( m_ReferencePair.first!=NULL ) { if( referencePair.first==NULL ) { virtual_SetProjection(); emit SetProjectionRequired(); } else if( m_ReferencePair.first!=referencePair.first ) { virtual_UpdateProjection(); emit UpdateProjectionRequired(); } } #endif // USE_REMOTE_DESKTOP_DISABLED_RENDERING } /*****************************************************************************/ bool ImageViewRenderer ::Reproject( PointType & center, SpacingType & spacing, const PointType & vcenter, const SpacingType & vspacing ) const { assert( !m_GlView.IsNull() ); const StackedLayerModel * stackedLayerModel = GetLayerStack(); if( stackedLayerModel==NULL ) return false; return m_GlView->ReprojectFromView( center, spacing, stackedLayerModel->GetKey( stackedLayerModel->GetReferenceIndex() ), vcenter, vspacing ); } /*****************************************************************************/ bool ImageViewRenderer ::GetLayerDynamics( const StackedLayerModel::KeyType & key, ParametersType & params, bool isGlobal ) const { assert( !m_GlView.IsNull() ); // Get actor. otb::GlImageActor::Pointer imageActor( otb::DynamicCast< otb::GlImageActor >( m_GlView->GetActor( key ) ) ); if( imageActor.IsNull() ) return false; // Get dynamics. imageActor->AutoColorAdjustment( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ], params[ 4 ], params[ 5 ], isGlobal, VectorImageModel::DEFAULT_LOD_SIZE, 0.02, 0.02 ); return true; } /*****************************************************************************/ void ImageViewRenderer ::SaveScreenshot( const QString & filename ) const { assert( !m_GlView.IsNull() ); m_GlView->SaveScreenshot( QFile::encodeName( filename ).constData() ); } /*****************************************************************************/ bool ImageViewRenderer ::IsEffectsEnabled() const { return m_EffectsEnabled; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void ImageViewRenderer ::UpdatePixelInfo( const QPoint & screen, const PointType & /* view */, const PixelInfo::Vector & pixels ) { // qDebug() // << this << "::UpdatePixelInfo(" // << screen << ", [" << view[ 0 ] << ";" << view[ 1 ] // << "] )"; assert( !m_GlView.IsNull() ); if( !m_EffectsEnabled ) return; for( PixelInfo::Vector::const_iterator it( pixels.begin() ); it != pixels.end(); ++ it ) { assert( !it->m_Key.empty() ); // // Check GL-view. assert( m_GlView->ContainsActor( it->m_Key ) ); // // Get GL image-actor. otb::GlImageActor::Pointer glImageActor( otb::DynamicCast< otb::GlImageActor >( m_GlView->GetActor( it->m_Key ) ) ); if( !glImageActor.IsNull() ) { // // Get image-settings. otb::ImageSettings::Pointer imageSettings( glImageActor->GetImageSettings() ); assert( !imageSettings.IsNull() ); // // Update pixel-info of shader. if( it->m_HasPixel ) { assert( it->m_Pixel.Size()>0 ); // qDebug() // << "R:" << it->m_Pixel[ 0 ] // << "G:" << it->m_Pixel[ 1 ] // << "B:" << it->m_Pixel[ 2 ]; imageSettings->SetCurrentRed( it->m_Pixel[ 0 ] ); imageSettings->SetCurrentGreen( it->m_Pixel[ 1 ] ); imageSettings->SetCurrentBlue( it->m_Pixel[ 2 ] ); } // // Get shader. otb::FragmentShader::Pointer fshader( glImageActor->GetShader() ); if( !fshader.IsNull() ) { otb::StandardShader::Pointer shader( otb::DynamicCast< otb::StandardShader >( fshader ) ); assert( !shader.IsNull() ); // // Update cursor position of shader. PointType p_screen; assert( m_GlView->GetSettings()!=NULL ); p_screen[ 0 ] = screen.x(); p_screen[ 1 ] = m_GlView->GetSettings()->GetViewportSize()[ 1 ] - screen.y(); // qDebug() // << "otb::StandardShader::SetCenter(" // << p_screen[ 0 ] << "," << p_screen[ 1 ] // << ")"; shader->SetCenter( p_screen ); if( shader->GetShaderType()==otb::SHADER_ALPHA_SLIDER ) shader->SetSliderPosition( p_screen[ shader->GetVerticalSlider() ? 1 : 0 ] ); } } } } /******************************************************************************/ bool ImageViewRenderer ::virtual_ZoomToRegion( const PointType & origin, const PointType & extent, PointType & center, SpacingType & spacing ) const { assert( !m_GlView.IsNull() ); // Use spacing of viewport as native spacing of reference layer // because it has already been set for projection. // // Same as of Ice-viewer. return m_GlView->ZoomToRegion( origin, extent, m_GlView->GetSettings()->GetSpacing(), center, spacing ); } /******************************************************************************/ bool ImageViewRenderer ::virtual_ZoomToExtent( PointType & center, SpacingType & spacing ) const { // qDebug() << this << "::virtual_ZoomToExtent()"; assert( !m_GlView.IsNull() ); // Use spacing of viewport as native spacing of reference layer // because it has already been set for projection. // // Same as of Ice-viewer. return m_GlView->ZoomToExtent( m_GlView->GetSettings()->GetSpacing(), center, spacing ); } /******************************************************************************/ bool ImageViewRenderer ::virtual_ZoomToLayer( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing ) const { assert( !m_GlView.IsNull() ); // Use spacing of viewport as native spacing of reference layer // because it has already been set for projection. // // Same as of Ice-viewer. return m_GlView->ZoomToLayer( key, m_GlView->GetSettings()->GetSpacing(), center, spacing ); } /******************************************************************************/ bool ImageViewRenderer ::virtual_ZoomToFull( const StackedLayerModel::KeyType & key, PointType & center, SpacingType & spacing ) const { assert( !m_GlView.IsNull() ); return m_GlView->ZoomToFull( key, center, spacing ); } /******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdImageViewWidget.cxx000066400000000000000000001612711301006202600275230ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImageViewWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdStackedLayerModel.h" #include "mvdVectorImageModel.h" #include "mvdAbstractImageViewManipulator.h" // See ::OnUpdateProjectionRequired() #include "mvdImageViewRenderer.h" namespace mvd { /* TRANSLATOR mvd::ImageViewWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ImageViewWidget ::ImageViewWidget( AbstractImageViewManipulator* manipulator, AbstractImageViewRenderer* renderer, QWidget* p, const QGLWidget* shareWidget, Qt::WindowFlags flags ) : QGLWidget( p, shareWidget, flags ), m_IsPickingEnabled( true ), m_PickingDefaultStatus( true ), m_Manipulator( NULL ), m_Renderer( NULL ) #if USE_XP_REGION_OPTIM ,m_Position() #endif // USE_XP_REGION_OPTION { Initialize( manipulator, renderer ); } /*******************************************************************************/ ImageViewWidget ::ImageViewWidget( AbstractImageViewManipulator * manipulator, AbstractImageViewRenderer * renderer, QGLContext* glcontext, QWidget* p, const QGLWidget* shareWidget, Qt::WindowFlags flags ) : QGLWidget( glcontext, p, shareWidget, flags ), m_Manipulator( NULL ), m_Renderer( NULL ) #if USE_XP_REGION_OPTION ,m_Position() #endif // USE_XP_REGION_OPTION { Initialize( manipulator, renderer ); } /*******************************************************************************/ ImageViewWidget ::ImageViewWidget( AbstractImageViewManipulator * manipulator, AbstractImageViewRenderer * renderer, const QGLFormat& glformat, QWidget* p, const QGLWidget* shareWidget, Qt::WindowFlags flags ) : QGLWidget( glformat, p, shareWidget, flags ), m_Manipulator( NULL ), m_Renderer( NULL ) #if USE_XP_REGION_OPTION ,m_Position() #endif // USE_XP_REGION_OPTION { Initialize( manipulator, renderer ); } /*******************************************************************************/ ImageViewWidget ::~ImageViewWidget() { // m_Manipulator (deleted as a child of a QObjet parent). // m_Renderer (deleted as a child of a QObjet parent). } /*******************************************************************************/ void ImageViewWidget ::CenterOn( const PointType & center, double scale ) { Center( center, scale, scale ); } /*******************************************************************************/ void ImageViewWidget ::SetLayerStack( StackedLayerModel * stackedLayerModel ) { assert( m_Renderer!=NULL ); { StackedLayerModel * model = m_Renderer->GetLayerStack(); if( model!=NULL ) { for( StackedLayerModel::ConstIterator it( model->Begin() ); it!=model->End(); ++it ) Disconnect( it->second ); // // Disconnect stacked-layer model from this image-view. QObject::disconnect( model, SIGNAL( LayerAdded( size_t ) ), // from: this, SLOT( OnLayerAdded( size_t ) ) ); QObject::disconnect( model, SIGNAL( LayerAboutToBeDeleted( size_t ) ), // from: this, SLOT( LayerAboutToBeDeleted( size_t ) ) ); QObject::disconnect( model, SIGNAL( ReferenceChanged( size_t ) ), // from: this, SLOT( OnReferenceChanged( size_t ) ) ); QObject::disconnect( model, SIGNAL( ContentChanged() ), // from: this, SLOT( OnContentChanged() ) ); QObject::disconnect( model, SIGNAL( ContentReset() ), // from: this, SLOT( OnContentReset() ) ); QObject::disconnect( model, SIGNAL( OrderChanged() ), // from: this, SLOT( updateGL() ) ); // // Disconnect layer-stack model from this widget manipulator. QObject::disconnect( GetManipulator(), SIGNAL( RotateLayersRequested( int ) ), // from: model, SLOT( RotateLayers( int ) ) ); QObject::disconnect( m_Manipulator, SIGNAL( LayerToTopRequested() ), // from: model, SLOT( MoveCurrentToTop() ) ); QObject::disconnect( m_Manipulator, SIGNAL( LayerToBottomRequested() ), // from: model, SLOT( MoveCurrentToBottom() ) ); } } // Set projection parameters of manipulator from layer data. OnSetProjectionRequired(); // Insert image-models into image-view renderer. m_Renderer->SetLayerStack( stackedLayerModel ); // Coverity-19846. if( stackedLayerModel==NULL ) return; // // Connect layer-stack model to this widget manipulator. QObject::connect( GetManipulator(), SIGNAL( RotateLayersRequested( int ) ), // to: stackedLayerModel, SLOT( RotateLayers( int ) ) ); QObject::connect( m_Manipulator, SIGNAL( LayerToTopRequested() ), // to: stackedLayerModel, SLOT( MoveCurrentToTop() ) ); QObject::connect( m_Manipulator, SIGNAL( LayerToBottomRequested() ), // to: stackedLayerModel, SLOT( MoveCurrentToBottom() ) ); // // Connect stacked layer-model to image-view manipulator. QObject::connect( stackedLayerModel, SIGNAL( LayerAdded( size_t ) ), // to: this, SLOT( OnLayerAdded( size_t ) ) ); // // Connect stacked layer-model to this image-view QObject::connect( stackedLayerModel, SIGNAL( LayerAboutToBeDeleted( size_t ) ), // to: this, SLOT( OnLayerAboutToBeDeleted( size_t ) ) ); QObject::connect( stackedLayerModel, SIGNAL( OrderChanged() ), // to: this, SLOT( updateGL() ) ); QObject::connect( stackedLayerModel, SIGNAL( ContentChanged() ), // to: this, SLOT( OnContentChanged() ) ); QObject::connect( stackedLayerModel, SIGNAL( ContentReset() ), // to: this, SLOT( OnContentReset() ) ); QObject::connect( stackedLayerModel, SIGNAL( ReferenceChanged( size_t ) ), // to this, SLOT( OnReferenceChanged( size_t ) ) ); for( StackedLayerModel::ConstIterator it( stackedLayerModel->Begin() ); it!=stackedLayerModel->End(); ++it ) Connect( it->second ); } /*******************************************************************************/ void ImageViewWidget ::Initialize( AbstractImageViewManipulator* manipulator, AbstractImageViewRenderer* renderer ) { // Test OpenGL. ListGlVersions(); // Accept drops setAcceptDrops( true ); // Set focus policy so that the widget gets the focus if it is clicked setMouseTracking( true ); setFocusPolicy( Qt::WheelFocus ); assert( manipulator!=NULL ); m_Manipulator = manipulator; m_Manipulator->setParent( this ); m_Manipulator->SetViewportSize( width(), height() ); assert( renderer!=NULL ); m_Renderer = renderer; m_Renderer->setParent( this ); #if USE_XP_REGION_OPTION m_Position[ 0 ] = m_Position[ 1 ] = 0; #endif // USE_XP_REGION_OPTION // // Manipulator -> this // QObject::connect( m_Manipulator, SIGNAL( RefreshViewRequested() ), // to: this, SLOT( OnRefreshViewRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( CenterRoiRequested( const PointType& ) ), // to: this, SIGNAL( CenterRoiRequested( const PointType& ) ) ); QObject::connect( m_Manipulator, SIGNAL( RoiChanged( const PointType &, const SizeType &, const SpacingType &, const PointType & ) ), // to: this, SIGNAL( RoiChanged( const PointType&, const SizeType&, const SpacingType&, const PointType& ) ) ); QObject::connect( m_Manipulator, SIGNAL( RoiChanged( const PointType &, const SizeType &, const SpacingType &, const PointType & ) ), // to: this, SLOT( OnRoiChanged( const PointType &, const SizeType &, const SpacingType &, const PointType & ) ) ); QObject::connect( m_Manipulator, SIGNAL( ZoomToExtentRequested() ), // to: this, SLOT( ZoomToExtent() ) ); QObject::connect( m_Manipulator, SIGNAL( ZoomToFullResolutionRequested() ), // to: this, SLOT( ZoomToFullResolution() ) ); QObject::connect( m_Manipulator, SIGNAL( LowerLayerRequested() ), // to: this, SLOT( OnLowerLayerRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( RaiseLayerRequested() ), // to: this, SLOT( OnRaiseLayerRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( SelectPreviousLayerRequested() ), // to: this, SLOT( OnSelectPreviousLayerRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( SelectNextLayerRequested() ), // to: this, SLOT( OnSelectNextLayerRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( SelectFirstLayerRequested() ), // to: this, SLOT( OnSelectFirstLayerRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( SelectLastLayerRequested() ), // to: this, SLOT( OnSelectLastLayerRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( DeleteAllRequested() ), // to: this, SLOT( OnDeleteAllRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( DeleteSelectedRequested() ), // to: this, SLOT( OnDeleteSelectedRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( ToggleLayerVisibilityRequested( bool ) ), // to: this, SLOT( OnToggleLayerVisibilityRequested( bool ) ) ); QObject::connect( m_Manipulator, SIGNAL( ZoomToFullResolutionRequested() ), // to: this, SLOT( ZoomToFullResolution() ) ); QObject::connect( m_Manipulator, SIGNAL( ZoomToLayerExtentRequested() ), // to: this, SLOT( ZoomToLayerExtent() ) ); QObject::connect( m_Manipulator, SIGNAL( ZoomToExtentRequested() ), // to: this, SLOT( ZoomToExtent() ) ); QObject::connect( m_Manipulator, SIGNAL( ResizeShaderRequested( double ) ), // to: this, SLOT( OnResizeShaderRequested( double ) ) ); QObject::connect( m_Manipulator, SIGNAL( ReparamShaderRequested( double ) ), // to: this, SLOT( OnReparamShaderRequested( double ) ) ); QObject::connect( m_Manipulator, SIGNAL( ShiftAlphaRequested( double ) ), // to: this, SLOT( OnShiftAlphaRequested( double ) ) ); QObject::connect( m_Manipulator, SIGNAL( UpdateGammaRequested( double ) ), // to: this, SLOT( OnUpdateGammaRequested( double ) ) ); QObject::connect( m_Manipulator, SIGNAL( ShiftDynamicsRequested( double ) ), // to: this, SLOT( OnShiftDynamicsRequested( double ) ) ); QObject::connect( m_Manipulator, SIGNAL( ScaleDynamicsRequested( double ) ), // to: this, SLOT( OnScaleDynamicsRequested( double ) ) ); QObject::connect( m_Manipulator, SIGNAL( ResetQuantilesRequested( bool ) ), // to: this, SLOT( OnResetQuantilesRequested( bool ) ) ); QObject::connect( m_Manipulator, SIGNAL( ShaderEffectRequested( Effect ) ), // to: this, SLOT( OnShaderEffectRequested( Effect ) ) ); QObject::connect( m_Manipulator, SIGNAL( ApplyAllRequested() ), // to: this, SLOT( OnApplyAllRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( SetReferenceRequested() ), // to: this, SLOT( OnSetReferenceRequested() ) ); QObject::connect( m_Manipulator, SIGNAL( TakeScreenshotRequested( bool ) ), // to: this, SLOT( SaveScreenshot( bool ) ) ); // // Renderer -> this // QObject::connect( m_Renderer, SIGNAL( ClearProjectionRequired() ), // to: this, SLOT( OnClearProjectionRequired() ) ); QObject::connect( m_Renderer, SIGNAL( SetProjectionRequired() ), // to: this, SLOT( OnSetProjectionRequired() ) ); QObject::connect( m_Renderer, SIGNAL( UpdateProjectionRequired() ), // to: this, SLOT( OnUpdateProjectionRequired() ) ); QObject::connect( m_Renderer, SIGNAL( ResetViewport() ), // to: this, SLOT( OnResetViewport() ) ); } /*******************************************************************************/ void ImageViewWidget ::initializeGL() { } /*******************************************************************************/ void ImageViewWidget ::resizeGL( int w, int h ) { QGLWidget::resizeGL( w, h ); assert( m_Renderer!=NULL ); m_Renderer->ResizeGL( w, h ); } /*******************************************************************************/ void ImageViewWidget ::paintGL() { QGLWidget::paintGL(); // qDebug() << this << "::paintGL()"; // // Get new rendering-context. assert( m_Renderer!=NULL ); AbstractImageViewRenderer::RenderingContext* c = m_Renderer->NewRenderingContext(); assert( c!=NULL ); // // Setup new rendering-context. assert( m_Manipulator!=NULL ); m_Manipulator->SetupRenderingContext( c ); // // OpenGL paint using new rendering-context. m_Renderer->PaintGL( c ); // // Post-rendering tasks. if( !m_Renderer->IsBypassRenderingEnabled() && m_IsPickingEnabled ) { StackedLayerModel * layerStack = GetLayerStack(); // assert( layerStack!=NULL ); if( layerStack!=NULL ) { layerStack->BeginEditResolutions(); m_Renderer->GetResolutions( layerStack->PixelInfos() ); layerStack->EndEditResolutions(); } } // // Release rendering-context. delete c; c = NULL; } /*******************************************************************************/ void ImageViewWidget ::mousePressEvent( QMouseEvent* e ) { assert( e!=NULL ); QGLWidget::mousePressEvent( e ); m_Manipulator->MousePressEvent( e ); // Deactivate pixel picking during drag m_IsPickingEnabled = false; } /*******************************************************************************/ void ImageViewWidget ::mouseMoveEvent( QMouseEvent* e ) { assert( e!=NULL ); // qDebug() << this << "::mouseMove(" << event << ")"; // Superclass default behaviour. QGLWidget::mouseMoveEvent( e ); // // Get layer-stack. StackedLayerModel * stackedLayerModel = GetLayerStack(); assert( stackedLayerModel!=NULL ); // // Update view depending on shader status special behaviour. // bool isAnyEffectActive = false; if( m_Renderer->IsEffectsEnabled() ) { for( StackedLayerModel::ConstIterator it( stackedLayerModel->Begin() ); it!=stackedLayerModel->End(); ++ it ) { assert( it->second!=NULL ); if( it->second->inherits( AbstractImageModel::staticMetaObject.className() ) ) { VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( it->second ); assert( imageModel!=NULL ); if( imageModel->GetSettings().GetEffect()!=EFFECT_NONE && imageModel->GetSettings().GetEffect()!=EFFECT_NORMAL ) { #if USE_XP_REGION_OPTIM PointType origin; PointType extent; m_Renderer->GetLayerExtent( it->first, origin, extent ); if( ( origin[ 0 ]<=ptView[ 0 ] && ptView[ 0 ]<=extent[ 0 ] && origin[ 1 ]<=ptView[ 1 ] && ptView[ 1 ]<=extent[ 1 ] ) || ( origin[ 0 ]<=m_Position[ 0 ] && m_Position[ 0 ]<=extent[ 0 ] && origin[ 1 ]<=m_Position[ 1 ] && m_Position[ 1 ]<=extent[ 1 ] ) ) { qDebug() << FromStdString( it->first ); // qDebug() // << "x:" << origin[ 0 ] << ptView[ 0 ] << m_Position[ 0 ] << extent[ 0 ]; // qDebug() // << "y:" << origin[ 1 ] << ptView[ 1 ] << m_Position[ 1 ] << extent[ 1 ]; // qDebug() // << "x:" << ptView[ 0 ] << m_Position[ 0 ]; // qDebug() // << "y:" << ptView[ 1 ] << m_Position[ 1 ]; #endif // USE_XP_REGION_OPTIM // qDebug() << "updateGL(" << in[ 0 ] << "," << in[ 1 ] << ")"; isAnyEffectActive = true; break; } #if USE_XP_REGION_OPTIM } #endif // USE_XP_REGION_OPTIM } } #if USE_XP_REGION_OPTIM m_Position = ptView; #endif // USE_XP_REGION_OPTION } // Delegate behaviour. if( isAnyEffectActive ) { bool bypass = m_Renderer->SetBypassRenderingEnabled( true ); m_Manipulator->MouseMoveEvent( e ); m_Renderer->SetBypassRenderingEnabled( bypass ); } else m_Manipulator->MouseMoveEvent( e ); // // Pixel-picking special behaviour. // if( m_IsPickingEnabled ) { // Transform coordinates from widget space to viewport space. assert( m_Manipulator!=NULL ); PointType ptView; m_Manipulator->Transform( ptView, e->pos() ); // // Pick pixel of point in viewport space and return point in image // space. assert( m_Renderer!=NULL ); stackedLayerModel->BeginEditPixelInfo(); PixelInfo::Vector & pixels = stackedLayerModel->PixelInfos(); m_Renderer->Pick( ptView, pixels ); m_Renderer->UpdatePixelInfo( e->pos(), ptView, pixels ); stackedLayerModel->EndEditPixelInfo( e->pos(), ptView ); // // Emit reference-layer pixel data. emit PixelInfoChanged( e->pos(), ptView, stackedLayerModel->PixelInfos() ); if( stackedLayerModel->HasCurrent() ) emit PhysicalCursorPositionChanged( e->pos(), ptView, pixels[ stackedLayerModel->GetCurrentIndex() ].m_Point, pixels[ stackedLayerModel->GetCurrentIndex() ].m_Pixel ); else emit PhysicalCursorPositionChanged( e->pos(), ptView, PointType(), DefaultImageType::PixelType() ); } else if( isAnyEffectActive ) { // Transform coordinates from widget space to viewport space. assert( m_Manipulator!=NULL ); PointType ptView; m_Manipulator->Transform( ptView, e->pos() ); // // Pick pixel of point in viewport space and return point in image // space. assert( m_Renderer!=NULL ); const PixelInfo::Vector & pixels = stackedLayerModel->PixelInfos(); m_Renderer->UpdatePixelInfo( e->pos(), ptView, pixels ); } if( isAnyEffectActive ) updateGL(); } /*******************************************************************************/ void ImageViewWidget ::mouseReleaseEvent( QMouseEvent* e ) { assert( e!=NULL ); QGLWidget::mouseReleaseEvent( e ); m_Manipulator->MouseReleaseEvent(e); // Reactivate picking after drag m_IsPickingEnabled = m_PickingDefaultStatus; } /*******************************************************************************/ void ImageViewWidget ::mouseDoubleClickEvent( QMouseEvent* e ) { assert( e!=NULL ); QGLWidget::mouseDoubleClickEvent( e ); m_Manipulator->MouseDoubleClickEvent( e ); } /*******************************************************************************/ void ImageViewWidget ::wheelEvent( QWheelEvent* e ) { assert( e!=NULL ); QGLWidget::wheelEvent( e ); m_Manipulator->WheelEvent(e); } /*******************************************************************************/ void ImageViewWidget ::resizeEvent( QResizeEvent* e ) { assert( e!=NULL ); // qDebug() << this << "::resizeEvent(" << e << ")"; // First, call superclass implementation QGLWidget::resizeEvent( e ); m_Manipulator->ResizeEvent( e ); } /*******************************************************************************/ void ImageViewWidget ::keyPressEvent( QKeyEvent* e ) { assert( e!=NULL ); QGLWidget::keyPressEvent( e ); m_Manipulator->KeyPressEvent( e ); } /*******************************************************************************/ void ImageViewWidget ::keyReleaseEvent( QKeyEvent* e ) { assert( e!=NULL ); QGLWidget::keyReleaseEvent( e ); m_Manipulator->KeyReleaseEvent( e ); } /*******************************************************************************/ void ImageViewWidget ::ListGlVersions() const { #if QT_VERSION < QT_VERSION_CHECK( 4, 7, 0 ) qWarning() << tr( "Unable to list supported OpenGL versions using QGLFormat. " "Qt version is %1. Please upgrade to Qt 4.7.0 or newer." ) .arg( qVersion() ) .toLatin1() .constData(); #else qWarning() << tr( "Runtime version of OpenGL used by Qt %1: %2.%3." ) .arg( qVersion() ) .arg( format().majorVersion() ) .arg( format().minorVersion() ) .toLatin1() .constData(); QGLFormat::OpenGLVersionFlags glVersionFlags( QGLFormat::openGLVersionFlags() ); qWarning() << tr( "Version(s) of OpenGL supported by Qt %1:" ) .arg( qVersion() ) .toLatin1() .constData(); if( glVersionFlags & QGLFormat::OpenGL_Version_4_0 ) qWarning() << "QGLFormat::OpenGL_Version_4_0"; if( glVersionFlags & QGLFormat::OpenGL_Version_3_3 ) qWarning() << "- QGLFormat::OpenGL_Version_3_3"; if( glVersionFlags & QGLFormat::OpenGL_Version_3_2 ) qWarning() << "- QGLFormat::OpenGL_Version_3_2"; if( glVersionFlags & QGLFormat::OpenGL_Version_3_1 ) qWarning() << "- QGLFormat::OpenGL_Version_3_1"; if( glVersionFlags & QGLFormat::OpenGL_Version_3_0 ) qWarning() << "- QGLFormat::OpenGL_Version_3_0"; if( glVersionFlags & QGLFormat::OpenGL_Version_2_1 ) qWarning() << "- QGLFormat::OpenGL_Version_2_1"; if( glVersionFlags & QGLFormat::OpenGL_Version_2_0 ) qWarning() << "- QGLFormat::OpenGL_Version_2_0"; if( glVersionFlags & QGLFormat::OpenGL_Version_1_5 ) qWarning() << "- QGLFormat::OpenGL_Version_1_5"; if( glVersionFlags & QGLFormat::OpenGL_Version_1_4 ) qWarning() << "- QGLFormat::OpenGL_Version_1_4"; if( glVersionFlags & QGLFormat::OpenGL_Version_1_3 ) qWarning() << "- QGLFormat::OpenGL_Version_1_3"; if( glVersionFlags & QGLFormat::OpenGL_Version_1_2 ) qWarning() << "- QGLFormat::OpenGL_Version_1_2"; if( glVersionFlags & QGLFormat::OpenGL_Version_1_1 ) qWarning() << "- QGLFormat::OpenGL_Version_1_1"; if( glVersionFlags & QGLFormat::OpenGL_Version_None ) qWarning() << "- QGLFormat::OpenGL_Version_None"; #endif } /*****************************************************************************/ void ImageViewWidget ::Center( const PointType& center, double sx, double sy ) { /* qDebug() << this << "::Center(" << center[ 0 ] << "," << center[ 1 ] << "," << sx << "," << sy << ")"; */ assert( m_Renderer!=NULL ); assert( m_Manipulator!=NULL ); // // Get reference image-model. AbstractImageModel* imageModel = m_Renderer->GetReferenceModel< AbstractImageModel >(); assert( imageModel!=NULL ); // Scale spacing. SpacingType spacing( imageModel->GetSpacing() ); spacing[ 0 ] /= sx; spacing[ 1 ] /= sy; m_Manipulator->SetSpacing( spacing ); // Center view. m_Manipulator->CenterOn( center ); } /*****************************************************************************/ void ImageViewWidget ::Center( ZoomType zoom ) { // if( zoom==ZOOM_TYPE_EXTENT ) // qDebug() << this << "::Center( ZOOM_TYPE_EXTENT );"; assert( zoom==ZOOM_TYPE_EXTENT || zoom==ZOOM_TYPE_FULL || zoom==ZOOM_TYPE_LAYER ); assert( m_Renderer!=NULL ); assert( m_Manipulator!=NULL ); PointType center; SpacingType spacing; center[ 0 ] = center[ 1 ] = 0.0; spacing[ 0 ] = spacing[ 1 ] = 1.0; bool result = false; switch( zoom ) { case ZOOM_TYPE_EXTENT: result = m_Renderer->ZoomToExtent( center, spacing ); break; case ZOOM_TYPE_FULL: assert( GetLayerStack()!=NULL ); result = m_Renderer->ZoomToFull( GetLayerStack()->GetCurrentKey(), center, spacing ); break; case ZOOM_TYPE_LAYER: assert( GetLayerStack()!=NULL ); result = m_Renderer->ZoomToLayer( GetLayerStack()->GetCurrentKey(), center, spacing ); break; default: assert( false && "Unhandled ImageViewWidget::ZoomType value!" ); break; } // // Center on middle point. if( result ) { m_Manipulator->SetSpacing( spacing ); m_Manipulator->CenterOn( center ); } } /*******************************************************************************/ void ImageViewWidget ::Connect( AbstractLayerModel * layer ) { assert( layer!=NULL ); QObject::connect( layer, SIGNAL( VisibilityChanged() ), // to: this, SLOT( updateGL() ) ); QObject::connect( this, SIGNAL( ModelUpdated() ), // to: layer, SLOT( OnModelUpdated() ) ); } /*******************************************************************************/ void ImageViewWidget ::Disconnect( AbstractLayerModel * layer ) { assert( layer!=NULL ); QObject::disconnect( layer, SIGNAL( VisibilityChanged() ), // from: this, SLOT( updateGL() ) ); QObject::disconnect( this, SIGNAL( ModelUpdated() ), // from: layer, SLOT( OnModelUpdated() ) ); } /*****************************************************************************/ bool ImageViewWidget ::IsBypassRenderingEnabled() const { assert( m_Renderer!=NULL ); return m_Renderer->IsBypassRenderingEnabled(); } /*****************************************************************************/ bool ImageViewWidget ::SetBypassRenderingEnabled( bool enabled ) { assert( m_Renderer!=NULL ); return m_Renderer->SetBypassRenderingEnabled( enabled ); } /*****************************************************************************/ bool ImageViewWidget ::IsPickingEnabled() const { return m_IsPickingEnabled; } /*****************************************************************************/ void ImageViewWidget ::SetPickingEnabled( bool enabled ) { m_IsPickingEnabled = enabled; } /*****************************************************************************/ void ImageViewWidget ::SetPickingDefaultStatus( bool defaultStatus ) { m_PickingDefaultStatus = defaultStatus; } /*******************************************************************************/ bool ImageViewWidget ::ApplyFixedZoomType() { assert( m_Manipulator!=NULL ); ZoomType zoom = m_Manipulator->GetFixedZoomType(); if( zoom==ZOOM_TYPE_NONE || zoom>=ZOOM_TYPE_COUNT ) return false; Center( zoom ); return true; } /*******************************************************************************/ /* SLOTS */ /******************************************************************************/ void ImageViewWidget ::CenterOnSelected( const IndexType & index ) { /* assert( m_Renderer!=NULL ); AbstractImageModel* imageModel = m_Render->GetReferenceImageModel(); if( imageModel==NULL ) return; ImageBaseType::Pointer image( imageModel->ToImageBase() ); assert( !image.IsNull() ); PointType point; image->TransformIndexToPhysicalPoint( index, point ); m_Renderer->GetReferenceActor(); assert( m_Manipulator!=NULL ); m_Manipulator->CenterOn( point ); */ assert( m_Renderer!=NULL ); const StackedLayerModel * layerStack = m_Renderer->GetLayerStack(); assert( layerStack!=NULL ); if( !layerStack->HasCurrent() ) return; PointType point; if( !m_Renderer->TransformToView( point, layerStack->GetCurrentKey(), index, false ) ) return; assert( m_Manipulator!=NULL ); m_Manipulator->CenterOn( point ); } /******************************************************************************/ void ImageViewWidget ::OnApplyAllRequested() { // qDebug() << this << "::OnApplyAllRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * layerStack = m_Renderer->GetLayerStack(); assert( layerStack!=NULL ); AbstractLayerModel * layer = layerStack->GetCurrent(); if( layer==NULL ) return; if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); assert( imageModel!=NULL ); const VectorImageSettings & settings = imageModel->GetSettings(); const ImageProperties * properties = imageModel->GetProperties(); for( StackedLayerModel::ConstIterator it( layerStack->Begin() ); it!=layerStack->End(); ++it ) if( it->second!=layer ) { if( it->second->inherits( VectorImageModel::staticMetaObject.className() ) ) { VectorImageModel * vim = qobject_cast< VectorImageModel * >( it->second ); // // Properties. { bool needsRefresh = *vim->GetProperties() != *properties; vim->SetProperties( *properties ); if( needsRefresh ) { // qDebug() << "Refreshing histogram..."; vim->RefreshHistogram(); } } // // Settings { // Find RGB-channels max component. VectorImageSettings::ChannelVector::value_type rgbChannel = 0; { const VectorImageSettings::ChannelVector & rgb( settings.GetRgbChannels() ); for( VectorImageSettings::ChannelVector::const_iterator vis( rgb.begin() ); vis!=rgb.end(); ++vis ) if( *vis > rgbChannel ) rgbChannel = *vis; } CountType nbComponents = vim->GetNbComponents(); // qDebug() // << vim->GetFilename() // << nbComponents // << rgbChannel // << settings.GetGrayChannel() // << ( settings.GetGrayChannel()SetSettings( settings ); } } } emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::OnClearProjectionRequired() { // qDebug() << this << "::OnClearProjectionRequested()"; assert( m_Manipulator!=NULL ); m_Manipulator->SetWkt( std::string() ); m_Manipulator->SetKeywordList( otb::ViewSettings::KeywordListType() ); // m_Manipulator->SetOrigin( imageModel->GetOrigin() ); // m_Manipulator->SetSpacing( imageModel->GetSpacing() ); // m_Manipulator->SetNativeSpacing( imageModel->GetNativeSpacing() ); assert( m_Renderer!=NULL ); if( m_Renderer->IsBypassRenderingEnabled() ) return; ZoomToExtent(); // Done in ::ZoomToExtent(). // updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnContentChanged() { // qDebug() << this << "::OnContentChanged()"; UpdateScene(); if( !ApplyFixedZoomType() ) updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnContentReset() { // qDebug() << this << "::OnContentReset()"; UpdateScene(); if( !ApplyFixedZoomType() ) updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnDeleteAllRequested() { // qDebug() << this << "::OnDeleteAllRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->Clear(); } /******************************************************************************/ void ImageViewWidget ::OnDeleteSelectedRequested() { // qDebug() << this << "::OnDeleteSelectedRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->DeleteCurrent(); } /******************************************************************************/ void ImageViewWidget ::OnLayerAboutToBeDeleted( size_t index ) { assert( GetLayerStack()!=NULL ); Disconnect( GetLayerStack()->At( index ) ); } /******************************************************************************/ void ImageViewWidget ::OnLayerAdded( size_t index ) { assert( GetLayerStack()!=NULL ); Connect( GetLayerStack()->At( index ) ); } /******************************************************************************/ void ImageViewWidget ::OnLowerLayerRequested() { // qDebug() << this << "::OnLowerLayerRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->LowerCurrent(); } /******************************************************************************/ void ImageViewWidget ::OnRaiseLayerRequested() { // qDebug() << this << "::OnRaiseLayerRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->RaiseCurrent(); } /******************************************************************************/ void ImageViewWidget ::OnReferenceChanged( size_t ) { // qDebug() << this << "::OnReferenceChanged(" << index << ")"; assert( m_Renderer!=NULL ); m_Renderer->RefreshScene(); updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnRefreshViewRequested() { // qDebug() << this << "::OnRefreshViewRequested()"; updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnResetQuantilesRequested( bool isGlobal ) { // qDebug() << this << "::OnResetQuantilesRequested(" << isGlobal << ")"; // // Get layer-stack. StackedLayerModel * layerStack = m_Renderer->GetLayerStack(); assert( layerStack!=NULL ); if( !layerStack->HasCurrent() ) return; // qDebug() << "current:" << FromStdString( layerStack->GetCurrentKey() ); // // Get dynamics of current layer. assert( m_Renderer!=NULL ); ParametersType params( 6 ); if( !m_Renderer->GetLayerDynamics( layerStack->GetCurrentKey(), params, isGlobal ) ) return; // qDebug() << "R: [" << params[ 0 ] << "," << params[ 1 ] << "]"; // qDebug() << "G: [" << params[ 2 ] << "," << params[ 3 ] << "]"; // qDebug() << "B: [" << params[ 4 ] << "," << params[ 5 ] << "]"; // // Apply dynamics to current layer. AbstractLayerModel * layer = layerStack->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); VectorImageSettings & settings = imageModel->GetSettings(); if( settings.IsGrayscaleActivated() ) settings.SetGrayDynamicsParams( params ); else settings.SetRgbDynamicsParams( params ); /* HistogramModel * histogram = imageModel->GetHistogramModel(); assert( histogram!=NULL ); // Get min/max pixels. DefaultImageType::PixelType minPx( histogram->GetMinPixel() ); DefaultImageType::PixelType maxPx( histogram->GetMaxPixel() ); // Iterator bounds. CountType begin = -1; CountType end = -1; // Shift intensity for each channel. if( RgbwBounds( begin, end, settings.IsGrayscaleActivated() ? RGBW_CHANNEL_WHITE : RGBW_CHANNEL_RGB ) ) for( CountType i=begin; i( i ); // Band. VectorImageSettings::ChannelVector::value_type b = settings.GetSmartChannel( c ); // Compute step. DefaultImageType::PixelType::ValueType step = static_cast< DefaultImageType::PixelType::ValueType >( delta * ( maxPx[ b ] - minPx[ b ] ) ); // Apply step shift. settings.SetLowIntensity( c, settings.GetLowIntensity( c ) + step ); settings.SetHighIntensity( c, settings.GetHighIntensity( c ) + step ); } */ emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::OnResizeShaderRequested( double factor ) { // qDebug() << this << "::OnResizeShaderRequested(" << factor << ")"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); assert( imageModel!=NULL ); imageModel->GetSettings().SetSize( static_cast< double >( imageModel->GetSettings().GetSize() ) * factor ); emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::OnReparamShaderRequested( double factor ) { // qDebug() << this << "::OnReparamShaderRequested(" << factor << ")"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); assert( imageModel!=NULL ); imageModel->GetSettings().SetValue( static_cast< double >( imageModel->GetSettings().GetValue() ) * factor ); emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::OnRoiChanged( const PointType &, const SizeType &, const SpacingType & spacing, const PointType & center ) { assert( m_Renderer!=NULL ); // qDebug() // << this << "::OnRoiChanged(" // << "[" << point[ 0 ] << "," << point[ 1 ] << "]" // << "[" << center[ 0 ] << "," << center[ 1 ] << "]"; emit CenterChanged( center ); AbstractImageModel* imageModel = m_Renderer->GetReferenceModel< AbstractImageModel >(); SpacingType nativeSpacing; // MANTIS-970: Fixed crash when no dataset is selected. // { if( imageModel==NULL ) { nativeSpacing[ 0 ] = 1.0; nativeSpacing[ 1 ] = 1.0; } else nativeSpacing = imageModel->GetNativeSpacing(); // } double rsx = nativeSpacing[ 0 ] / spacing[ 0 ]; double rsy = nativeSpacing[ 1 ] / spacing[ 1 ]; #if 0 double sx = ( spacing[ 0 ]>0.0 ? 1.0 : -1.0 ) / spacing[ 0 ]; double sy = ( spacing[ 1 ]>0.0 ? 1.0 : -1.0 ) / spacing[ 1 ]; #endif // qDebug() << "sx:" << sx << "; sy:" << sy; // qDebug() << "rsx:" << rsx << "; rsy:" << rsy; // qDebug() << this << "::updateGL()"; // Refresh view. updateGL(); // Emit absolute scale. emit ScaleChanged( rsx, rsy ); // Emit zooming scale-factor. emit RoiChanged( center, rsx, rsy ); } /******************************************************************************/ void ImageViewWidget ::OnScaleDynamicsRequested( double factor ) { // qDebug() << this << "::OnScaleDynamicsRequested(" << factor << ")"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); VectorImageSettings & settings = imageModel->GetSettings(); CountType begin = -1; CountType end = -1; // Shift intensity for each channel. if( RgbwBounds( begin, end, settings.IsGrayscaleActivated() ? RGBW_CHANNEL_WHITE : RGBW_CHANNEL_RGB ) ) for( CountType i=begin; i( i ); ParametersType::ValueType lo = settings.GetLowIntensity( c ); ParametersType::ValueType hi = settings.GetHighIntensity( c ); ParametersType::ValueType o = ( lo + hi ) / 2; settings.SetLowIntensity( c, factor * ( lo - o ) + o ); settings.SetHighIntensity( c, factor * ( hi - o ) + o ); } /* // Grayscale if( settings.IsGrayscaleActivated() ) { // Get color-dynamics. ParametersType params( settings.GetGrayDynamicsParams() ); // Compute center value. ParametersType::ValueType center = ( params[ 0 ] + params[ 1 ] ) / 2; // Scale color-dynamics around center value. params[ 0 ] = factor * ( params[ 0 ] - center ) + center; params[ 1 ] = factor * ( params[ 1 ] - center ) + center; // Set color-dynamics. settings.SetLowIntensity( RGBW_CHANNEL_WHITE, params[ 0 ] ); settings.SetHighIntensity( RGBW_CHANNEL_WHITE, params[ 1 ] ); } // RGB else { // Get color-setup. VectorImageSettings::ChannelVector channels( settings.GetRgbChannels() ); // Get color-dynamics. ParametersType params( settings.GetRgbDynamicsParams() ); CountType begin = -1; CountType end = -1; // Shift intensity for each channel. if( RgbBounds( begin, end, RGBW_CHANNEL_RGB ) ) for( CountType i=begin; iGetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->SelectFirst(); updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnSelectLastLayerRequested() { // qDebug() << this << "::OnSelectLastLayerRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->SelectLast(); updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnSelectPreviousLayerRequested() { // qDebug() << this << "::OnSelectPreviousLayerRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->SelectPrevious(); updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnSelectNextLayerRequested() { // qDebug() << this << "::OnSelectNextLayerRequested()"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); stackedLayerModel->SelectNext(); updateGL(); } /******************************************************************************/ void ImageViewWidget ::OnSetProjectionRequired() { // qDebug() << this << "::OnSetProjection()"; StackedLayerModel * stackedLayerModel = GetLayerStack(); if( stackedLayerModel==NULL ) return; const AbstractLayerModel * layer = stackedLayerModel->GetReference(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); const VectorImageModel * imageModel = qobject_cast< const VectorImageModel * >( layer ); assert( imageModel!=NULL ); DefaultImageType::ConstPointer image( imageModel->ToImage() ); assert( !image.IsNull() ); assert( m_Manipulator!=NULL ); m_Manipulator->SetWkt( image->GetProjectionRef() ); m_Manipulator->SetKeywordList( image->GetImageKeywordlist() ); m_Manipulator->SetOrigin( imageModel->GetOrigin() ); m_Manipulator->SetSpacing( imageModel->GetSpacing() ); m_Manipulator->SetNativeSpacing( imageModel->GetNativeSpacing() ); } else { assert( false && "Unhandled AbstractLayerModel derived type." ); } ApplyFixedZoomType(); } /******************************************************************************/ void ImageViewWidget ::OnSetReferenceRequested() { // qDebug() << this << "::OnSetReferenceRequested()"; StackedLayerModel * stackedLayerModel = GetLayerStack(); if( stackedLayerModel==NULL ) return; if( !stackedLayerModel->HasCurrent() ) return; size_t unk = 0; size_t gcs = 0; stackedLayerModel->CountSRT( unk, gcs, gcs, gcs ); if( unk==0 ) stackedLayerModel->SetReference( stackedLayerModel->GetCurrentKey() ); } /******************************************************************************/ void ImageViewWidget ::OnShaderEffectRequested( Effect effect ) { // qDebug() // << this // << "::OnShaderEffectRequested(" << QString( EFFECT_NAME[ effect ] ) << ")"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); assert( imageModel!=NULL ); imageModel->GetSettings().SetEffect( effect ); emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::OnShiftAlphaRequested( double delta ) { // qDebug() << this << "::OnShiftAlphaRequested(" << delta << ")"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); imageModel->GetSettings().SetAlpha( imageModel->GetSettings().GetAlpha() + delta ); emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::OnShiftDynamicsRequested( double delta ) { // qDebug() << this << "::OnShiftDynamicsRequested(" << delta << ")"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); VectorImageSettings & settings = imageModel->GetSettings(); HistogramModel * histogram = imageModel->GetHistogramModel(); assert( histogram!=NULL ); // Get min/max pixels. DefaultImageType::PixelType minPx( histogram->GetMinPixel() ); DefaultImageType::PixelType maxPx( histogram->GetMaxPixel() ); // Iterator bounds. CountType begin = -1; CountType end = -1; // Shift intensity for each channel. if( RgbwBounds( begin, end, settings.IsGrayscaleActivated() ? RGBW_CHANNEL_WHITE : RGBW_CHANNEL_RGB ) ) for( CountType i=begin; i( i ); // Band. VectorImageSettings::ChannelVector::value_type b = settings.GetSmartChannel( c ); // Compute step. DefaultImageType::PixelType::ValueType step = static_cast< DefaultImageType::PixelType::ValueType >( delta * ( maxPx[ b ] - minPx[ b ] ) ); // Apply step shift. settings.SetLowIntensity( c, settings.GetLowIntensity( c ) + step ); settings.SetHighIntensity( c, settings.GetHighIntensity( c ) + step ); } /* // Grayscale if( settings.IsGrayscaleActivated() ) { // Get color-setup. unsigned int channel = settings.GetGrayChannel(); // Get color-dynamics. ParametersType params( settings.GetGrayDynamicsParams() ); // Compute step. DefaultImageType::PixelType::ValueType step = static_cast< DefaultImageType::PixelType::ValueType >( delta * ( maxPx[ channel ] - minPx[ channel ] ) ); // Shift min & max intensities of channel. params[ 0 ] += step; params[ 1 ] += step; // Set color-dynamics. settings.SetLowIntensity( RGBW_CHANNEL_WHITE, params[ 0 ] ); settings.SetHighIntensity( RGBW_CHANNEL_WHITE, params[ 1 ] ); } // RGB else { // Get color-setup. VectorImageSettings::ChannelVector channels( settings.GetRgbChannels() ); // Get color-dynamics. ParametersType params( settings.GetRgbDynamicsParams() ); // Shift intensity for each channel. for( VectorImageSettings::ChannelVector::const_iterator it( channels.begin() ); it!=channels.end(); ++it ) params[ *it ] += static_cast< DefaultImageType::PixelType::ValueType >( delta * ( maxPx[ *it ] - minPx[ *it ] ) ); // Set shifted intensities. settings.SetRgbDynamicsParams( params ); } */ emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::SaveScreenshot( bool isQuickMode ) { QString filename( QString( "monteverdi-%1-%2.png" ) .arg( Monteverdi_VERSION_STRING ) .arg( QDateTime::currentDateTime().toString( "yyyyMMdd-hhmm-ss-zzz" ) ) ); QString selectedFilter; if( isQuickMode ) filename = QDir::home().filePath( filename ); else filename = QFileDialog::getSaveFileName( this, tr( "Save screenshot..." ), QDir::current().filePath( filename ), tr( "PNG File (*.png);;JPEG File (*.jpg);;TIFF file (*tif)" ), &selectedFilter ); if( filename.isEmpty() ) return; // If no correct extension is found if(!filename.endsWith(".png",Qt::CaseInsensitive) &&!filename.endsWith(".jpg",Qt::CaseInsensitive) &&!filename.endsWith(".tif",Qt::CaseInsensitive)) { if(selectedFilter.startsWith("PNG")) { filename+=".png"; } else if(selectedFilter.startsWith("JPEG")) { filename+=".jpg"; } else if(selectedFilter.startsWith("TIFF")) { filename+=".tif"; } } assert( m_Renderer!=NULL ); try { m_Renderer->SaveScreenshot( filename ); } catch( const std::exception & exception ) { QMessageBox::warning( this, "Warning!", tr( "Exception caught while saving screenshot into file '%1':\n\n%2" ) .arg( filename ) .arg( exception.what() ) ); } } /******************************************************************************/ void ImageViewWidget ::OnResetViewport() { // qDebug() << this << "::OnResetViewport()"; assert( m_Manipulator!=NULL ); m_Manipulator->ResetViewport(); } /******************************************************************************/ void ImageViewWidget ::OnToggleLayerVisibilityRequested( bool ) { assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); if( layer==NULL ) return; layer->SetVisible( !layer->IsVisible() ); } /******************************************************************************/ void ImageViewWidget ::OnUpdateGammaRequested( double factor ) { // qDebug() << this << "::OnUpdateGammaRequested(" << factor << ")"; assert( m_Renderer!=NULL ); StackedLayerModel * stackedLayerModel = m_Renderer->GetLayerStack(); assert( stackedLayerModel!=NULL ); AbstractLayerModel * layer = stackedLayerModel->GetCurrent(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); VectorImageModel * imageModel = qobject_cast< VectorImageModel * >( layer ); imageModel->GetSettings().SetGamma( imageModel->GetSettings().GetGamma() * factor ); emit ModelUpdated(); } } /******************************************************************************/ void ImageViewWidget ::OnUpdateProjectionRequired() { // qDebug() << this << "::OnUpdateProjectionRequired()"; // Reminder: specific #include "mvdImageViewRenderer.h" assert( m_Manipulator!=NULL ); assert( m_Renderer==qobject_cast< const ImageViewRenderer * >( m_Renderer ) ); // // ImageViewRenderer specific code (as opposing to // AbstractImageViewRenderer). // // Could be moved in derived class if necessary. // { const ImageViewRenderer * renderer = qobject_cast< const ImageViewRenderer * >( m_Renderer ); assert( m_Renderer!=NULL ); PointType center; SpacingType spacing; renderer->Reproject( center, spacing, m_Manipulator->GetCenter(), m_Manipulator->GetSpacing() ); // } // Projection WKT and KWL must preferably be set before changing center/spacing const AbstractLayerModel * layer = GetLayerStack()->GetReference(); assert( layer!=NULL ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { assert( layer==qobject_cast< const VectorImageModel * >( layer ) ); const VectorImageModel * imageModel = qobject_cast< const VectorImageModel * >( layer ); assert( imageModel!=NULL ); DefaultImageType::ConstPointer image( imageModel->ToImage() ); assert( !image.IsNull() ); assert( m_Manipulator!=NULL ); m_Manipulator->SetWkt( image->GetProjectionRef() ); m_Manipulator->SetKeywordList( image->GetImageKeywordlist() ); } else { assert( false && "Unhandled AbstractLayerModel derived type." ); } // Spacing must be set before centering. m_Manipulator->SetSpacing( spacing ); // Centering must be done at the last step. m_Manipulator->CenterOn( center ); } /******************************************************************************/ void ImageViewWidget ::UpdateScene() { assert( m_Renderer!=NULL ); m_Renderer->UpdateScene(); } /******************************************************************************/ void ImageViewWidget ::ZoomToExtent() { assert( m_Renderer!=NULL ); // if( m_Renderer->GetReferenceModel< AbstractImageModel >()==NULL ) // return; // Scale and center. Center( ZOOM_TYPE_EXTENT ); // Refresh view. updateGL(); } /******************************************************************************/ void ImageViewWidget ::ZoomToLayerExtent() { assert( m_Renderer!=NULL ); // Scale and center. Center( ZOOM_TYPE_LAYER ); // Refresh view. updateGL(); } /******************************************************************************/ void ImageViewWidget ::ZoomToFullResolution() { assert( m_Renderer!=NULL ); // if( m_Renderer->GetReferenceModel< AbstractImageModel >()==NULL ) // return; // Scale and center. Center( ZOOM_TYPE_FULL ); // Refresh view. updateGL(); } /******************************************************************************/ void ImageViewWidget ::ZoomIn() { assert( m_Manipulator!=NULL ); m_Manipulator->ZoomIn(); // Refresh view. updateGL(); } /******************************************************************************/ void ImageViewWidget ::ZoomOut() { assert( m_Manipulator!=NULL ); m_Manipulator->ZoomOut(); // Refresh view. updateGL(); } } OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdImportImagesDialog.cxx000066400000000000000000000314541301006202600302210ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImportImagesDialog.h" #include "ui_mvdImportImagesDialog.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdCore.h" #include "mvdI18nCoreApplication.h" namespace mvd { /* TRANSLATOR mvd::ImportImagesDialog Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { /** */ enum Columns { COLUMN_NONE = -1, // COLUMN_IMAGE_SIZE = 0, COLUMN_OVERVIEW_SIZE, COLUMN_FILENAME, // COLUMN_COUNT, }; const char * const HEADERS[ COLUMN_COUNT ] = { QT_TRANSLATE_NOOP( "mvd::ImportImagesDialog", "Img Size" ), QT_TRANSLATE_NOOP( "mvd::ImportImagesDialog", "Ovr Size" ), QT_TRANSLATE_NOOP( "mvd::ImportImagesDialog", "Filename" ), }; } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ImportImagesDialog ::ImportImagesDialog( const QStringList & filenames, QWidget * p, Qt::WindowFlags flags ) : QDialog( p, flags ), m_UI( new Ui::ImportImagesDialog() ), m_EffectiveCount( 0 ) { m_UI->setupUi( this ); { QItemSelectionModel * ism = m_UI->filenamesTreeView->selectionModel(); m_UI->filenamesTreeView->setModel( new QStandardItemModel( 0, COLUMN_COUNT, m_UI->filenamesTreeView ) ); delete ism; ism = NULL; } QObject::connect( m_UI->filenamesTreeView->model(), SIGNAL( itemChanged( QStandardItem * ) ), // to: this, SLOT( OnItemChanged( QStandardItem * ) ) ); QObject::connect( m_UI->filenamesTreeView->selectionModel(), SIGNAL( currentChanged( const QModelIndex &, const QModelIndex & ) ), // to: this, SLOT( OnCurrentChanged( const QModelIndex &, const QModelIndex & ) ) ); SetFilenames( filenames ); } /*****************************************************************************/ ImportImagesDialog ::~ImportImagesDialog() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ const otb::GDALOverviewsBuilder::Pointer & ImportImagesDialog ::GetBuilder( const QModelIndex & index ) const { assert( index.isValid() ); assert( index.row()>=0 && static_cast< size_t >( index.row() )filenamesTreeView!=NULL ); m_GDALOverviewsBuilders.clear(); QStandardItemModel * itemModel = qobject_cast< QStandardItemModel * >( m_UI->filenamesTreeView->model() ); assert( itemModel!=NULL ); itemModel->clear(); SetHeaders(); m_EffectiveCount = 0; for( int i=0; iSetInputFileName( filename ); flags |= Qt::ItemIsSelectable; unsigned int count = 0; { assert( I18nCoreApplication::Instance()!=NULL ); QVariant value( I18nCoreApplication::Instance()->RetrieveSettingsKey( I18nCoreApplication::SETTINGS_KEY_OVERVIEWS_SIZE ) ); count = builder->CountResolutions( 2, value.isValid() ? value.toInt() : OVERVIEWS_SIZE_DEFAULT ); } if( builder->GetOverviewsCount()>0 ) builder->SetBypassEnabled( true ); else { flags |= Qt::ItemIsEnabled; builder->SetBypassEnabled( count<=1 ); ++ m_EffectiveCount; } builder->SetResolutionFactor( 2 ); builder->SetNbResolutions( count ); builder->SetResamplingMethod( otb::GDAL_RESAMPLING_AVERAGE ); builder->SetCompressionMethod( otb::GDAL_COMPRESSION_NONE ); builder->SetFormat( otb::GDAL_FORMAT_GEOTIFF ); } catch( const std::exception & e ) { QMessageBox::warning( this, PROJECT_NAME, tr( "The following exception has raised when scanning file '%1' for GDAL overview settings:\n\n%2" ) .arg( filenames[ i ] ) .arg( e.what() ) ); builder = otb::GDALOverviewsBuilder::Pointer(); } m_GDALOverviewsBuilders.push_back( builder ); typedef QList< QStandardItem * > ItemList; ItemList items; // // COLUMN_IMAGE_SIZE if( !builder.IsNull() ) { items.push_back( new QStandardItem( QString( "%1x%2" ) .arg( builder->GetWidth() ) .arg( builder->GetHeight() ) ) ); items.back()->setFlags( flags ); } // // COLUMN_FILE_SIZE items.push_back( new QStandardItem( ToHumanReadableSize( builder->GetOverviewsCount() > 0 ? QFileInfo( filenames[ i ] + ".ovr" ) .size() : builder->GetEstimatedSize() ) ) ); items.back()->setFlags( flags ); // // COLUMN_FILENAME items.push_back( new QStandardItem( filenames[ i ] ) ); if( flags.testFlag( Qt::ItemIsEnabled ) ) { items.back()->setFlags( flags | Qt::ItemIsUserCheckable ); items.back()->setCheckState( builder->IsBypassEnabled() ? Qt::Unchecked : Qt::Checked ); } else items.back()->setFlags( flags ); // // Append items. itemModel->appendRow( items ); } #if ( defined( OTB_DEBUG ) && 1 ) || 0 else qDebug() << "Skipped:" << filenames[ i ]; #endif } } /*****************************************************************************/ void ImportImagesDialog ::SetHeaders() { assert( m_UI!=NULL ); assert( m_UI->filenamesTreeView->model()== qobject_cast< QStandardItemModel * >( m_UI->filenamesTreeView->model() ) ); QStandardItemModel * model = qobject_cast< QStandardItemModel * >( m_UI->filenamesTreeView->model() ); assert( model!=NULL ); for( int i=0; itranslate( // "mvd::ImportImagesDialog", // HEADERS[ i ] // ); // labels << // qApp->translate( // "mvd::ImportImagesDialog", // HEADERS[ i ] // ); // model->horizontalHeaderItem( i )->setText( // qApp->translate( // "mvd::ImportImagesDialog", // HEADERS[ i ] // ) // ); model->setHorizontalHeaderItem( i, new QStandardItem( qApp->translate( "mvd::ImportImagesDialog", HEADERS[ i ] ) ) ); } // qDebug() << labels; // model->setHorizontalHeaderLabels( labels ); } /*****************************************************************************/ void ImportImagesDialog ::UpdateFileSize( size_t row ) { assert( rowGetOverviewsCount()<=0 ); // // Get item-model. assert( m_UI!=NULL ); assert( m_UI->filenamesTreeView!=NULL ); QStandardItemModel * model = qobject_cast< QStandardItemModel * >( m_UI->filenamesTreeView->model() ); assert( model!=NULL ); // // Create index. QModelIndex index( model->index( row, COLUMN_OVERVIEW_SIZE ) ); // // Get GDAL overview builder. otb::GDALOverviewsBuilder::Pointer builder( m_GDALOverviewsBuilders[ index.row() ] ); assert( !builder.IsNull() ); // // Update file size. model->setData( index, ToHumanReadableSize( builder->GetEstimatedSize() ) ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void ImportImagesDialog ::on_buttonBox_clicked( QAbstractButton * button ) { // qDebug() << this << "::on_buttonBox_clicked(" << button << ")"; assert( m_UI!=NULL ); assert( button!=NULL ); switch( m_UI->buttonBox->standardButton( button ) ) { case QDialogButtonBox::Ok: accept(); break; case QDialogButtonBox::Cancel: reject(); break; case QDialogButtonBox::Ignore: done( -1 ); break; default: assert( false && "Unhandled QDialogButtonBox::StandardButton enum value!" ); reject(); break; } } /*****************************************************************************/ void ImportImagesDialog ::on_pyramidWidget_BaseValueChanged( int ) { assert( m_UI!=NULL ); assert( m_UI->filenamesTreeView!=NULL ); assert( m_UI->filenamesTreeView->selectionModel()!=NULL ); UpdateFileSize( m_UI->filenamesTreeView->selectionModel()->currentIndex().row() ); } /*****************************************************************************/ void ImportImagesDialog ::on_pyramidWidget_LevelsValueChanged( int ) { assert( m_UI!=NULL ); assert( m_UI->filenamesTreeView!=NULL ); assert( m_UI->filenamesTreeView->selectionModel()!=NULL ); UpdateFileSize( m_UI->filenamesTreeView->selectionModel()->currentIndex().row() ); } /*****************************************************************************/ void ImportImagesDialog ::on_pyramidWidget_SizeValueChanged( int ) { assert( m_UI!=NULL ); assert( m_UI->filenamesTreeView!=NULL ); assert( m_UI->filenamesTreeView->selectionModel()!=NULL ); UpdateFileSize( m_UI->filenamesTreeView->selectionModel()->currentIndex().row() ); } /*****************************************************************************/ void ImportImagesDialog ::OnCurrentChanged( const QModelIndex & current, const QModelIndex & ) { // qDebug() << this << "::OnCurrentChanged(" << current << "," << previous << ")"; // const QStandardItemModel * itemModel = // qobject_cast< const QStandardItemModel * >( // m_UI->filenamesTreeView->model() // ); // assert( itemModel!=NULL ); const otb::GDALOverviewsBuilder::Pointer & builder = GetBuilder( current ); m_UI->pyramidWidget->setEnabled( !builder.IsNull() && !builder->IsBypassEnabled() ); m_UI->pyramidWidget->SetBuilder( builder ); } /*****************************************************************************/ void ImportImagesDialog ::OnItemChanged( QStandardItem * item ) { // qDebug() << this << "::OnItemChanged(" << item << ")"; assert( item!=NULL ); QModelIndex index( item->index() ); if( index.column()!=COLUMN_FILENAME ) return; const otb::GDALOverviewsBuilder::Pointer & builder = GetBuilder( item->index() ); if( !builder.IsNull() ) { builder->SetBypassEnabled( item->checkState()!=Qt::Checked ); UpdateFileSize( index.row() ); } assert( m_UI!=NULL ); assert( m_UI->filenamesTreeView->selectionModel()!=NULL ); if( m_UI->filenamesTreeView->selectionModel()->currentIndex()!=index ) return; m_UI->pyramidWidget->setEnabled( !builder.IsNull() && !builder->IsBypassEnabled() ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdImportImagesDialog.ui000066400000000000000000000027641301006202600300360ustar00rootroot00000000000000 mvd::ImportImagesDialog 0 0 275 134 Configure multi-resolution pyramid 4 4 Qt::Horizontal QDialogButtonBox::Cancel|QDialogButtonBox::Ignore|QDialogButtonBox::Ok mvd::MultiResolutionPyramidWidget QWidget
    mvdMultiResolutionPyramidWidget.h
    1     OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdImportSubDatasetDialog.cxx000066400000000000000000000176131301006202600310540ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdImportSubDatasetDialog.h" #include "ui_mvdImportSubDatasetDialog.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGDALImageIO.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" namespace mvd { /* TRANSLATOR mvd::ImportSubDatasetDialog Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ char const * const ImportSubDatasetDialog ::DATASET_COLUMN_NAMES[ ImportSubDatasetDialog::DATASET_COLUMN_COUNT ] = { QT_TRANSLATE_NOOP( "mvd::ImportSubDatasetDialog", "Index" ), QT_TRANSLATE_NOOP( "mvd::ImportSubDatasetDialog", "Desc" ), QT_TRANSLATE_NOOP( "mvd::ImportSubDatasetDialog", "Name" ), }; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ ImportSubDatasetDialog ::ImportSubDatasetDialog( const QString & filename, QWidget * p, Qt::WindowFlags flags ): QDialog( p, flags ), m_UI( new mvd::Ui::ImportSubDatasetDialog() ), m_HasSubDatasets( false ) { m_UI->setupUi( this ); Setup( filename ); } /*****************************************************************************/ ImportSubDatasetDialog ::~ImportSubDatasetDialog() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ void ImportSubDatasetDialog ::GetSubDatasets( IntVector & dataset ) const { assert( m_UI!=NULL ); assert( m_UI->datasetTreeView!=NULL ); assert( m_UI->datasetTreeView->model()== qobject_cast< QStandardItemModel * >( m_UI->datasetTreeView->model() ) ); QStandardItemModel * itemModel = qobject_cast< QStandardItemModel * >( m_UI->datasetTreeView->model() ); assert( itemModel!=NULL ); for( int i=0; irowCount(); ++i ) { assert( itemModel->item( i, DATASET_COLUMN_DESC )!=NULL ); if( itemModel->item( i, DATASET_COLUMN_DESC ) ->checkState()==Qt::Checked ) dataset.push_back( i ); } } /*****************************************************************************/ bool ImportSubDatasetDialog ::HasSubDatasets() const { return m_HasSubDatasets; } /*****************************************************************************/ void ImportSubDatasetDialog ::Setup( const QString & filename ) { assert( m_UI!=NULL ); assert( m_UI->datasetTreeView!=NULL ); QStandardItemModel * itemModel = NULL; // // Create item-model. { QItemSelectionModel * ism = m_UI->datasetTreeView->selectionModel(); itemModel = new QStandardItemModel( m_UI->datasetTreeView ); m_UI->datasetTreeView->setModel( itemModel ); delete ism; ism = NULL; } // // Setup item-model assert( itemModel!=NULL ); itemModel->setColumnCount( DATASET_COLUMN_COUNT ); { QStringList headers; for( int i=0; isetHorizontalHeaderLabels( headers ); } // // Fill item-model. otb::GDALImageIO::Pointer gdalIO( otb::GDALImageIO::New() ); // Check for existing options other than sdataidx int posOptions = filename.indexOf(QChar('?')); int posSubDataIdx = filename.indexOf(QString("sdataidx")); QString cleanFilename(filename); if (posOptions > 0 && posSubDataIdx <= posOptions) { cleanFilename = filename.section('?',0,0); } std::string fname( QFile::encodeName( cleanFilename ).constData() ); if( gdalIO->CanReadFile( fname.c_str() ) ) { gdalIO->SetFileName( fname ); StringVector names; StringVector descs; m_HasSubDatasets = gdalIO->GetSubDatasetInfo( names, descs ); assert( names.size()==descs.size() ); typedef QList< QStandardItem * > StandardItemList; for( std::string::size_type i=0; isetCheckable( true ); items.back()->setCheckState( Qt::Checked ); items << new QStandardItem( FromStdString( names[ i ] ) ); itemModel->appendRow( items ); } } // // Fit tree-view to item-model content. { for( int i=0; icolumnCount(); ++i ) m_UI->datasetTreeView->resizeColumnToContents( i ); } } /*****************************************************************************/ void ImportSubDatasetDialog ::SetSubDatasetsCheckState( Qt::CheckState state ) { assert( m_UI!=NULL ); assert( m_UI->datasetTreeView!=NULL ); assert( m_UI->datasetTreeView->model()== qobject_cast< QStandardItemModel * >( m_UI->datasetTreeView->model() ) ); QStandardItemModel * itemModel = qobject_cast< QStandardItemModel * >( m_UI->datasetTreeView->model() ); assert( itemModel!=NULL ); for( int i=0; irowCount(); ++i ) { assert( itemModel->item( i, DATASET_COLUMN_DESC )!=NULL ); itemModel->item( i, DATASET_COLUMN_DESC )->setCheckState( state ); } } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void ImportSubDatasetDialog ::on_allButton_clicked() { SetSubDatasetsCheckState( Qt::Checked ); } /*****************************************************************************/ void ImportSubDatasetDialog ::on_invertButton_clicked() { assert( m_UI!=NULL ); assert( m_UI->datasetTreeView!=NULL ); assert( m_UI->datasetTreeView->model()== qobject_cast< QStandardItemModel * >( m_UI->datasetTreeView->model() ) ); QStandardItemModel * itemModel = qobject_cast< QStandardItemModel * >( m_UI->datasetTreeView->model() ); assert( itemModel!=NULL ); for( int i=0; irowCount(); ++i ) { QStandardItem * item = itemModel->item( i, DATASET_COLUMN_DESC ); assert( item!=NULL ); item->setCheckState( item->checkState()==Qt::Unchecked ? Qt::Checked : Qt::Unchecked ); } } /*****************************************************************************/ void ImportSubDatasetDialog ::on_noneButton_clicked() { SetSubDatasetsCheckState( Qt::Unchecked ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdImportSubDatasetDialog.ui000066400000000000000000000063031301006202600306610ustar00rootroot00000000000000 mvd::ImportSubDatasetDialog 0 0 640 480 Import image 4 4 Dataset 0 0 All None Invert Qt::Horizontal 320 20 Qt::Horizontal QDialogButtonBox::Cancel|QDialogButtonBox::Ok buttonBox accepted() mvd::ImportSubDatasetDialog accept() 248 254 157 274 buttonBox rejected() mvd::ImportSubDatasetDialog reject() 316 260 286 274 OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdKeymapDialog.cxx000066400000000000000000000040041301006202600270360ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdKeymapDialog.h" #include "ui_mvdKeymapDialog.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::KeymapDialog Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*******************************************************************************/ KeymapDialog ::KeymapDialog( QWidget* p, Qt::WindowFlags flags ) : QDialog( p, flags ), m_UI( new mvd::Ui::KeymapDialog() ) { m_UI->setupUi( this ); m_UI->m_ProjectLabel->setText( PROJECT_NAME ); m_UI->m_VersionLabel->setText( Monteverdi_VERSION_STRING ); } /*******************************************************************************/ KeymapDialog ::~KeymapDialog() { delete m_UI; m_UI = NULL; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdKeymapDialog.html000066400000000000000000000135361301006202600272120ustar00rootroot00000000000000

    Keyboard and mouse shortcut mappings

    Main window
    Key Action
    CTRL+ O Open file(s)
    CTRL+ Q Quit application
    Histogram view
    Key Action
    Left-button horizontal-drag Read histogram values
    Middle-button vertical-drag Scale histogram view
    Right-button horizontal-drag Shift histogram-view towards lo high
    Wheel Scale histogram-view
    Image View
    (Click in to set focus)
    Key Action
    CTRL+ P Print image-view (screenshot)
    SHIFT+ CTRL+ P Quick Print image-view (quick screenshot)
    ALT+ Mouse wheel Adjust effect brush size
    SHIFT+ ALT+ Mouse wheel Adjust effect parameter value
    Mouse wheel Zoom in out
    CTRL+ Mouse wheel Rotate layers
    CTRL+ALT+ Mouse wheel Shift dynamics range towards low/high
    SHIFT+ CTRL+ALT+ Mouse wheel Scale dynamics range around it's mean value
    META+ Mouse wheel Adjust translucency
    SHIFT+ META+ Mouse wheel Adjust gamma correction
    Key Action
    Mouse drag Scroll view
    CTRL+ Mouse drag Quick scroll view
    ↑ Scroll up
    ↓ Scroll down
    ← Scroll left
    → Scroll right
    CTRL+ ↑ Quick scroll up
    CTRL+ ↓ Quick scroll down
    CTRL+ ← Quick scroll left
    CTRL+ → Quick scroll right
    + Zoom in
    - Zoom out
    1 Zoom to full resolution (1:1)
    2 Zoom to selected layer extent
    3 Zoom to all layers extent
    Key Action
    Delete Delete selected layer
    SHIFT+ Delete Delete all layers
    Home Select previous layer
    End Select next layer
    SHIFT+ Home Select first layer
    SHIFT+ End Select last layer
    Page Up Move layer up within stack
    Page Down Move layer down within stack
    SHIFT+ Page Up Move layer to top of stack
    SHIFT+ Page Down Move layer to bottom of stack
    A Apply selected layer settings to All layers
    P Use selected layer Projection as reference projection
    Q Apply 2% Quantiles to viewed area of selected image layer
    SHIFT+ Q Apply 2% Quantiles to full area of selected image layer
    Key Action
    C Switch to Chessboard effect
    D Switch to local Dynamics or local contrast effect
    G Switch to Gradient effect
    H Switch to Horizontal swipe effect
    N Switch to No effect
    S Switch to Spectral angle effect
    T Switch to local Translucency effect
    V Switch to Vertical swipe effect
    Layer Stack
    Key Action
    Delete Delete selected layer
    SHIFT+ Delete Delete all layers
    CTRL+ Mouse wheel Rotate layers up/down
    OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdKeymapDialog.ui000066400000000000000000001157461301006202600266710ustar00rootroot00000000000000 mvd::KeymapDialog Qt::NonModal 0 0 606 879 0 0 About... 0 0 10 75 true Monteverdi false Qt::Horizontal 40 20 0 0 true Version M.m.pl (codename) true <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd"> <html><head><meta name="qrichtext" content="1" /><style type="text/css"> p, li { white-space: pre-wrap; } </style></head><body style=" font-family:'Droid Sans'; font-size:10pt; font-weight:400; font-style:normal;"> <p style=" margin-top:18px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:xx-large; font-weight:600;">Keyboard and mouse shortcut mappings</span></p> <table border="0" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px;" cellspacing="2" cellpadding="0"> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Main window</span></p></td> <td></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Key</span></p></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Action</span></p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">O</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Open file(s)</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Q</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Quit application</p></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Histogram view</span></p></td> <td></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Key</span></p></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Action</span></p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Left-button horizontal-drag</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Read histogram values</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Middle-button vertical-drag</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scale histogram view</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Right-button horizontal-drag</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Shift histogram-view towards lo high</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scale histogram-view</p></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Image View</span></p></td> <td></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">(Click in to set focus)</p></td> <td></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Key</span></p></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Action</span></p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">P</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">P</span>rint image-view (screenshot)</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">P</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Quick <span style=" font-weight:600;">P</span>rint image-view (quick screenshot)</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">ALT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Adjust effect brush size</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">ALT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Adjust effect parameter value</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Zoom in out</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Rotate layers</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+ALT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Shift dynamics range towards low/high</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+ALT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scale dynamics range around it's mean value</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">META+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Adjust translucency</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">META+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Adjust gamma correction</p></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Key</span></p></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Action</span></p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse drag</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scroll view</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse drag</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Quick scroll view</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">↑</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scroll up</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">↓</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scroll down</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">←</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scroll left</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">→</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Scroll right</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">↑</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Quick scroll up</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">↓</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Quick scroll down</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">←</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Quick scroll left</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">→</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Quick scroll right</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Zoom in</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">-</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Zoom out</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">1</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Zoom to full resolution (1:1)</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">2</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Zoom to selected layer extent</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">3</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Zoom to all layers extent</p></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Key</span></p></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Action</span></p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete selected layer</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete all layers</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Home</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Select previous layer</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">End</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Select next layer</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Home</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Select first layer</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">End</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Select last layer</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Page Up</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Move layer up within stack</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Page Down</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Move layer down within stack</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Page Up</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Move layer to top of stack</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Page Down</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Move layer to bottom of stack</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">A</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Apply selected layer settings to <span style=" font-weight:600;">A</span>ll layers</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">P</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Use selected layer <span style=" font-weight:600;">P</span>rojection as reference projection</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Q</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Apply 2% <span style=" font-weight:600;">Q</span>uantiles to viewed area of selected image layer</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Q</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Apply 2% <span style=" font-weight:600;">Q</span>uantiles to full area of selected image layer</p></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Key</span></p></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Action</span></p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">C</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to <span style=" font-weight:600;">C</span>hessboard effect</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">D</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to local <span style=" font-weight:600;">D</span>ynamics or local contrast effect</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">G</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to <span style=" font-weight:600;">G</span>radient effect</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">H</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to <span style=" font-weight:600;">H</span>orizontal swipe effect</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">N</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to <span style=" font-weight:600;">N</span>o effect</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">S</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to <span style=" font-weight:600;">S</span>pectral angle effect</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">T</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to local <span style=" font-weight:600;">T</span>ranslucency effect</p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">V</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Switch to <span style=" font-weight:600;">V</span>ertical swipe effect</p></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Layer Stack</span></p></td> <td></td></tr> <tr> <td></td> <td></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Key</span></p></td> <td> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-weight:600;">Action</span></p></td></tr> <tr> <td></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete selected layer</p></td></tr> <tr> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">SHIFT+</p></td> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Delete all layers</p></td></tr> <tr> <td></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">CTRL+</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Mouse wheel</p></td> <td> <p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Rotate layers up/down</p></td></tr></table></body></html> Qt::Horizontal 40 20 &Close m_CloseButton m_CloseButton clicked() mvd::KeymapDialog close() 359 398 206 211 OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdLayerStackController.cxx000066400000000000000000000260051301006202600306030ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdLayerStackController.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractLayerModel.h" #include "mvdFilenameInterface.h" #include "mvdStackedLayerModel.h" #include "mvdLayerStackItemModel.h" #include "mvdLayerStackWidget.h" namespace mvd { /* TRANSLATOR mvd::LayerStackController Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ LayerStackController ::LayerStackController( LayerStackWidget * widget, QObject * p ) : AbstractModelController( widget, p ) { } /*******************************************************************************/ LayerStackController ::~LayerStackController() { } /*******************************************************************************/ void LayerStackController ::ClearWidget() { } /*******************************************************************************/ void LayerStackController ::Connect( AbstractModel * model ) { assert( model==qobject_cast< StackedLayerModel * >( model ) ); QObject::connect( model, SIGNAL( CurrentChanged( size_t ) ), // to: this, SLOT( OnStackedLayerCurrentChanged( size_t ) ) ); QObject::connect( model, SIGNAL( ContentChanged() ), // to: this, SLOT( OnStackedLayerContentChanged() ) ); QObject::connect( model, SIGNAL( ContentReset() ), // to: this, SLOT( OnStackedLayerContentReset() ) ); LayerStackWidget * widget = GetWidget< LayerStackWidget >(); assert( widget!=NULL ); assert( widget->GetItemModel()!=NULL ); widget->GetItemModel()->SetStack( qobject_cast< StackedLayerModel * >( model ) ); QObject::connect( widget, SIGNAL( SelectionChanged( int ) ), // to: this, SLOT( OnSelectionChanged( int ) ) ); QObject::connect( widget, SIGNAL( ProjectionButtonClicked() ), // to: this, SLOT( OnProjectionButtonClicked() ) ); QObject::connect( widget, SIGNAL( TopButtonClicked() ), // to: model, SLOT( MoveCurrentToTop() ) ); QObject::connect( widget, SIGNAL( BottomButtonClicked() ), // to: model, SLOT( MoveCurrentToBottom() ) ); QObject::connect( widget, SIGNAL( UpButtonClicked() ), // to: model, SLOT( RaiseCurrent() ) ); QObject::connect( widget, SIGNAL( DownButtonClicked() ), // to: model, SLOT( LowerCurrent() ) ); QObject::connect( widget, SIGNAL( DeleteLayerRequested() ), // to: model, SLOT( DeleteCurrent() ) ); QObject::connect( widget, SIGNAL( DeleteAllLayersRequested() ), // to: model, SLOT( Clear() ) ); QObject::connect( widget, SIGNAL( CopyLayerRequested( const AbstractLayerModel * ) ), // to: this, SLOT( OnCopyLayerRequested( const AbstractLayerModel * ) ) ); QObject::connect( widget, SIGNAL( RotateLayersRequested( int ) ), // to: model, SLOT( RotateLayers( int ) ) ); QObject::connect( widget, SIGNAL( ApplyButtonClicked() ), // to: this, SIGNAL( ApplyAllRequested() ) ); } /*******************************************************************************/ void LayerStackController ::Disconnect( AbstractModel * model ) { // assert( model==qobject_cast< StackedLayerModel * >( model ) ); QObject::disconnect( model, SIGNAL( CurrentChanged( size_t ) ), // from: this, SLOT( OnStackedLayerCurrentChanged( size_t ) ) ); QObject::disconnect( model, SIGNAL( ContentChanged() ), // from: this, SLOT( OnStackedLayerContentChanged() ) ); QObject::disconnect( model, SIGNAL( ContentReset() ), // from: this, SLOT( OnStackedLayerContentReset() ) ); LayerStackWidget * widget = GetWidget< LayerStackWidget >(); assert( widget!=NULL ); assert( widget->GetItemModel()!=NULL ); widget->GetItemModel()->SetStack( NULL ); QObject::disconnect( widget, SIGNAL( SelectionChanged( int ) ), // from: this, SLOT( OnSelectionChanged( int ) ) ); QObject::disconnect( widget, SIGNAL( ProjectionButtonClicked() ), // from: this, SLOT( OnProjectionButtonClicked() ) ); QObject::disconnect( widget, SIGNAL( TopButtonClicked() ), // from: model, SLOT( MoveCurrentToTop() ) ); QObject::disconnect( widget, SIGNAL( BottomButtonClicked() ), // from: model, SLOT( MoveCurrentToBottom() ) ); QObject::disconnect( widget, SIGNAL( UpButtonClicked() ), // from: model, SLOT( RaiseCurrent() ) ); QObject::disconnect( widget, SIGNAL( DownButtonClicked() ), // from: model, SLOT( LowerCurrent() ) ); QObject::disconnect( widget, SIGNAL( DeleteLayerRequested() ), // from: model, SLOT( DeleteCurrent() ) ); QObject::disconnect( widget, SIGNAL( DeleteAllLayersRequested() ), // from: model, SLOT( Clear() ) ); QObject::disconnect( widget, SIGNAL( CopyLayerRequested( const AbstractLayerModel * ) ), // from: this, SLOT( OnCopyLayerRequested( const AbstractLayerModel * ) ) ); QObject::disconnect( widget, SIGNAL( RotateLayersRequested( int ) ), // from: model, SLOT( RotateLayers( int ) ) ); QObject::disconnect( widget, SIGNAL( ApplyButtonClicked() ), // to: this, SIGNAL( ApplyAllRequested() ) ); } /*******************************************************************************/ void LayerStackController ::virtual_ResetWidget( bool ) { } /*******************************************************************************/ void LayerStackController ::UpdateButtonsState() { assert( GetModel()==GetModel< StackedLayerModel >() ); StackedLayerModel * model = GetModel< StackedLayerModel >(); assert( model!=NULL ); assert( GetWidget()==GetWidget< LayerStackWidget >() ); LayerStackWidget * widget = GetWidget< LayerStackWidget >(); assert( widget!=NULL ); { size_t unk = 0; size_t gcs = 0; model->CountSRT( unk, gcs, gcs, gcs ); widget->SetProjectionEnabled( unk==0 && !model->IsEmpty() ); } widget->SetDeleteEnabled( !model->IsEmpty() ); widget->SetReloadEnabled( !model->IsEmpty() ); widget->SetMoveEnabled( model->GetCount()>1 ); widget->SetApplyEnabled( model->GetCount()>1 ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void LayerStackController ::OnCopyLayerRequested( const AbstractLayerModel * layer ) { // qDebug() << this << "::OnCopyLayerRequested(" << layer << ")"; assert( layer!=NULL ); const FilenameInterface * interface = dynamic_cast< const FilenameInterface * >( layer ); if( interface==NULL ) return; assert( qApp!=NULL ); assert( qApp->clipboard()!=NULL ); assert( qApp->clipboard()->mimeData()!=NULL ); QList< QUrl > urls; urls << QUrl::fromLocalFile( interface->GetFilename() ); qDebug() << "URLs:" << urls; QMimeData * mimeData = new QMimeData(); mimeData->setUrls( urls ); mimeData->setText( interface->GetFilename() ); qApp->clipboard()->setMimeData( mimeData ); } /*******************************************************************************/ void LayerStackController ::OnCurrentChanged( int index ) { // qDebug() << this << "::OnCurrentChanged(" << index << ")"; assert( GetModel()==GetModel< StackedLayerModel >() ); StackedLayerModel * model = GetModel< StackedLayerModel >(); assert( model!=NULL ); model->SetCurrent( index ); } /*******************************************************************************/ void LayerStackController ::OnProjectionButtonClicked() { // qDebug() << this << "::OnProjectionButtonClicked()"; assert( GetModel()==GetModel< StackedLayerModel >() ); StackedLayerModel * model = GetModel< StackedLayerModel >(); assert( model!=NULL ); model->SetReference( model->GetCurrentIndex() ); } /*******************************************************************************/ void LayerStackController ::OnSelectionChanged( int index ) { // qDebug() << this << "::OnSelectionChanged(" << index << ")"; assert( GetModel()==GetModel< StackedLayerModel >() ); StackedLayerModel * model = GetModel< StackedLayerModel >(); assert( model!=NULL ); model->SetCurrent( index ); } /*******************************************************************************/ void LayerStackController ::OnStackedLayerCurrentChanged( size_t index ) { // qDebug() << this << "::OnStackedLayerCurrentChanged(" << index << ")"; LayerStackWidget * widget = GetWidget< LayerStackWidget >(); assert( widget!=NULL ); assert( widget->GetItemModel()!=NULL ); bool prevSignalsBlocked = widget->blockSignals( true ); { widget->SetCurrent( index ); } widget->blockSignals( prevSignalsBlocked ); } /*******************************************************************************/ void LayerStackController ::OnStackedLayerContentChanged() { // qDebug() << this << "::OnStackedLayerContentChanged()"; UpdateButtonsState(); } /*******************************************************************************/ void LayerStackController ::OnStackedLayerContentReset() { // qDebug() << this << "::OnStackedLayerContentChanged()"; UpdateButtonsState(); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdLayerStackItemModel.cxx000066400000000000000000000625641301006202600303510ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdLayerStackItemModel.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractLayerModel.h" #include "mvdStackedLayerModel.h" #include "mvdVectorImageModel.h" #include "mvdVisibleInterface.h" namespace mvd { /* TRANSLATOR mvd::LayerStackItemModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { const char * const HEADERS[ LayerStackItemModel::COLUMN_COUNT ] = { QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Proj" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Res" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Name" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Effect" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "I" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "J" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Red" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Green" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Blue" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "X" ), QT_TRANSLATE_NOOP( "mvd::LayerStackItemModel", "Y" ), }; } // end of anonymous namespace. /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ const AbstractLayerModel * LayerStackItemModel ::GetLayer( const QModelIndex & index ) { assert( index.isValid() ); assert( !index.parent().isValid() ); assert( index.internalPointer()== static_cast< const AbstractLayerModel * >( index.internalPointer() ) ); return static_cast< const AbstractLayerModel * >( index.internalPointer() ); } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ LayerStackItemModel ::LayerStackItemModel( QObject* p ) : QAbstractItemModel( p ), m_StackedLayerModel( NULL ) { // QObject::connect( // this, // SIGNAL( modelAboutToBeReset() ), // // to: // this, // SLOT( OnModelAboutToBeReset() ) // ); // QObject::connect( // this, // SIGNAL( modelReset() ), // // to: // this, // SLOT( OnModelReset() ) // ); } /*****************************************************************************/ LayerStackItemModel ::~LayerStackItemModel() { } /*****************************************************************************/ void LayerStackItemModel ::Connect( AbstractLayerModel * layer ) { assert( layer!=NULL ); QObject::connect( layer, SIGNAL( VisibilityChanged( AbstractLayerModel *, bool ) ), // to:* this, SLOT( OnLayerVisibilityChanged( AbstractLayerModel *, bool ) ) ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { QObject::connect( layer, SIGNAL( SettingsUpdated( AbstractImageModel * ) ), // to: this, SLOT( OnImageSettingsUpdated( AbstractImageModel * ) ) ); } } /*****************************************************************************/ void LayerStackItemModel ::Disconnect( AbstractLayerModel * layer ) { assert( layer!=NULL ); QObject::disconnect( layer, SIGNAL( VisibilityChanged( AbstractLayerModel *, bool ) ), // from: this, SLOT( OnLayerVisibilityChanged( AbstractLayerModel *, bool ) ) ); if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { QObject::disconnect( layer, SIGNAL( SettingsUpdated( AbstractImageModel * ) ), // from: this, SLOT( OnImageSettingsUpdated( AbstractImageModel * ) ) ); } } /*****************************************************************************/ void LayerStackItemModel ::SetStack( StackedLayerModel * model ) { // emit layoutAboutToBeChanged(); if( m_StackedLayerModel!=NULL ) { for( StackedLayerModel::ConstIterator it( m_StackedLayerModel->Begin() ); it!=m_StackedLayerModel->End(); ++it ) Disconnect( it->second ); QObject::disconnect( m_StackedLayerModel, SIGNAL( ContentAboutToBeReset() ), // from: this, SIGNAL( modelAboutToBeReset() ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( ContentReset() ), // from: this, SIGNAL( modelReset() ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( LayerAdded( size_t ) ), // from: this, SLOT( OnLayerAdded( size_t ) ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( LayerAboutToBeDeleted( size_t ) ), // from: this, SLOT( OnLayerAboutToBeDeleted( size_t ) ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( LayerDeleted( size_t ) ), // from: this, SLOT( OnLayerDeleted( size_t ) ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( OrderAboutToBeChanged() ), // from: this, SIGNAL( layoutAboutToBeChanged() ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( OrderChanged() ), // from: this, SIGNAL( layoutChanged() ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( ReferenceChanged( size_t ) ), // from: this, SLOT( OnReferenceChanged( size_t ) ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( PixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ) ), // from: this, SLOT( OnPixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ) ) ); QObject::disconnect( m_StackedLayerModel, SIGNAL( ResolutionsChanged( const PixelInfo::Vector & ) ), // from: this, SLOT( ResolutionsChanged( const PixelInfo::Vector & ) ) ); } m_StackedLayerModel = model; QObject::connect( m_StackedLayerModel, SIGNAL( ContentAboutToBeReset() ), // to: this, SIGNAL( modelAboutToBeReset() ) ); QObject::connect( m_StackedLayerModel, SIGNAL( ContentReset() ), // to: this, SIGNAL( modelReset() ) ); QObject::connect( m_StackedLayerModel, SIGNAL( LayerAdded( size_t ) ), // to: this, SLOT( OnLayerAdded( size_t ) ) ); QObject::connect( m_StackedLayerModel, SIGNAL( LayerAboutToBeDeleted( size_t ) ), // to: this, SLOT( OnLayerAboutToBeDeleted( size_t ) ) ); QObject::connect( m_StackedLayerModel, SIGNAL( LayerDeleted( size_t ) ), // to: this, SLOT( OnLayerDeleted( size_t ) ) ); QObject::connect( m_StackedLayerModel, SIGNAL( OrderAboutToBeChanged() ), // to: this, SIGNAL( layoutAboutToBeChanged() ) ); QObject::connect( m_StackedLayerModel, SIGNAL( OrderChanged() ), // to: this, SIGNAL( layoutChanged() ) ); QObject::connect( m_StackedLayerModel, SIGNAL( ReferenceChanged( size_t ) ), // to: this, SLOT( OnReferenceChanged( size_t ) ) ); QObject::connect( m_StackedLayerModel, SIGNAL( PixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ) ), // to: this, SLOT( OnPixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & ) ) ); QObject::connect( m_StackedLayerModel, SIGNAL( ResolutionsChanged( const PixelInfo::Vector & ) ), // to: this, SLOT( OnResolutionsChanged( const PixelInfo::Vector & ) ) ); for( StackedLayerModel::ConstIterator it( m_StackedLayerModel->Begin() ); it!=m_StackedLayerModel->End(); ++it ) Connect( it->second ); // emit layoutChanged(); } /*****************************************************************************/ /* QAbstractItemModel overloads */ /*****************************************************************************/ int LayerStackItemModel ::columnCount( const QModelIndex & ) const { // qDebug() << this << "::columnCount(" << parent << ")"; return COLUMN_COUNT; } /*****************************************************************************/ QVariant LayerStackItemModel ::data( const QModelIndex & idx, int role ) const { // qDebug() << this << "::data(" << idx << "," << role << ")"; // Get layer. assert( m_StackedLayerModel!=NULL ); assert( idx.isValid() ); assert( !idx.parent().isValid() ); assert( idx.internalPointer()!=NULL ); const AbstractLayerModel * layer = static_cast< const AbstractLayerModel * >( idx.internalPointer() ); assert( layer!=NULL ); // Return data given role. switch( role ) { case Qt::CheckStateRole: if( idx.column()!=COLUMN_NAME ) return QVariant(); else { assert( layer==dynamic_cast< const VisibleInterface * >( layer ) ); const VisibleInterface * interface = dynamic_cast< const VisibleInterface * >( layer ); assert( interface!=NULL ); return interface->IsVisible() ? Qt::Checked : Qt::Unchecked; } break; case Qt::DisplayRole: switch( idx.column() ) { case COLUMN_PROJ: return FromStdString( layer->GetAuthorityCode( true ) ); break; case COLUMN_RESOLUTION: { const PixelInfo::Vector & pixels = m_StackedLayerModel->PixelInfos(); assert( idx.row()>=0 ); if( idx.row()>=0 && static_cast< size_t >( idx.row() )( pixels[ idx.row() ].m_Resolution ); else return QVariant(); } break; case COLUMN_NAME: if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { const VectorImageModel * vectorImageModel = qobject_cast< const VectorImageModel * >( layer ); assert( vectorImageModel!=NULL ); // qDebug() << "filename:" << vectorImageModel->GetFilename(); return QFileInfo( vectorImageModel->GetFilename() ).fileName(); } else { qDebug() << "Unhandled AbstractLayerModel subclass."; } break; case COLUMN_EFFECT: if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { const VectorImageModel * vectorImageModel = qobject_cast< const VectorImageModel * >( layer ); assert( vectorImageModel!=NULL ); return vectorImageModel->GetSettings().GetEffectName(); } else { qDebug() << "Unhandled AbstractLayerModel subclass."; } break; case COLUMN_I: case COLUMN_J: { const PixelInfo::Vector & pixels = m_StackedLayerModel->PixelInfos(); assert( idx.row()>=0 ); if( idx.row()>=0 && static_cast< size_t >( idx.row() )( pixels[ idx.row() ].m_Index[ idx.column() - COLUMN_I ] ); else return QVariant(); } break; case COLUMN_R: case COLUMN_G: case COLUMN_B: { const PixelInfo::Vector & pixels = m_StackedLayerModel->PixelInfos(); assert( idx.row()>=0 ); if( idx.row()>=0 && static_cast< size_t >( idx.row() )PixelInfos(); assert( idx.row()>=0 ); if( idx.row()>=0 && static_cast< size_t >( idx.row() )=0 ); if( static_cast< StackedLayerModel::SizeType >( idx.row() )== m_StackedLayerModel->GetReferenceIndex() ) { QFont font; font.setBold( true ); return font; } break; case Qt::ToolTipRole: switch( idx.column() ) { case COLUMN_NAME: if( layer->inherits( VectorImageModel::staticMetaObject.className() ) ) { const VectorImageModel * vectorImageModel = qobject_cast< const VectorImageModel * >( layer ); assert( vectorImageModel!=NULL ); // qDebug() << "filename:" << vectorImageModel->GetFilename(); return vectorImageModel->GetFilename(); } break; } break; default: break; } return QVariant(); } /*****************************************************************************/ bool LayerStackItemModel ::dropMimeData( const QMimeData * dat, Qt::DropAction action, int row, int column, const QModelIndex & p ) { // qDebug() // << this // << "::dropMimeData(" // << dat << "," << action << "," << row << "," << column << "," << parent // << ")"; // qDebug() << "QMimeData::formats():" << dat->formats(); return QAbstractItemModel::dropMimeData( dat, action, row, column, p ); } /*****************************************************************************/ Qt::ItemFlags LayerStackItemModel ::flags( const QModelIndex & idx ) const { if( !idx.isValid() ) return QAbstractItemModel::flags( idx ); Qt::ItemFlags iflags = QAbstractItemModel::flags( idx ) // | Qt::ItemIsDragEnabled // | Qt::ItemIsDropEnabled ; if( idx.column()==COLUMN_NAME ) iflags |= Qt::ItemIsUserCheckable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled; return iflags; } /*****************************************************************************/ bool LayerStackItemModel ::hasChildren( const QModelIndex & idx ) const { return !idx.isValid(); } /*****************************************************************************/ QVariant LayerStackItemModel ::headerData( int section, Qt::Orientation /**orientation*/, int role ) const { // qDebug() // << this << "::headerData(" // << section << "," << orientation << "," << role // << ")"; // assert( orientation==Qt::Horizontal ); switch( role ) { case Qt::DisplayRole: assert( section>=0 && section=0 && sectionAt( row ); assert( row>=0 && column>=0 ); #if 1 AbstractLayerModel * layer = m_StackedLayerModel->At( row ); if( layer==NULL || p.isValid() ) return QModelIndex(); #endif return createIndex( row, column, p.isValid() ? NULL : m_StackedLayerModel->At( row ) ); } /*****************************************************************************/ bool LayerStackItemModel ::insertRows( int row, int count, const QModelIndex & p ) { assert( !p.isValid() ); assert( count==1 ); if( p.isValid() || count!=1 ) return false; beginInsertRows( p, row, row + count - 1 ); { // StackedLayerModel has already been grown. // TODO: Allocate additional row data here. } endInsertRows(); // emit dataChanged( index( row, 0 ), index( last, columnCount() - 1 ) ); return true; } /*****************************************************************************/ QMimeData * LayerStackItemModel ::mimeData( const QModelIndexList & indexes ) const { QMimeData * mData = QAbstractItemModel::mimeData( indexes ); assert( mData!=NULL ); typedef QList< QUrl > UrlList; UrlList urls; foreach( const QModelIndex & idx, indexes ) if( idx.isValid() ) { assert( idx.internalPointer()!=NULL ); AbstractLayerModel * layer = static_cast< AbstractLayerModel * >( idx.internalPointer() ); FilenameInterface * interface = dynamic_cast< FilenameInterface * >( layer ); urls << QUrl::fromLocalFile( interface->GetFilename() ); } mData->setUrls( urls ); // qDebug() << this << "mime-data:" << mData; return mData; } /*****************************************************************************/ QStringList LayerStackItemModel ::mimeTypes() const { QStringList mTypes( QAbstractItemModel::mimeTypes() ); mTypes << "text/uri-list"; // qDebug() << this << "mime-types:" << mTypes; return mTypes; } /*****************************************************************************/ QModelIndex LayerStackItemModel ::parent( const QModelIndex & ) const { // qDebug() << this << "::parent(" << index << ")"; return QModelIndex(); } /*****************************************************************************/ bool LayerStackItemModel ::removeRows( int row, int count, const QModelIndex & p ) { assert( !p.isValid() ); assert( count==1 ); if( p.isValid() || count!=1 ) return false; beginRemoveRows( p, row, row + count - 1 ); { // StackedLayerModel has already been shortened. // TODO: Release additional row data here. } endRemoveRows(); return true; } /*****************************************************************************/ int LayerStackItemModel ::rowCount( const QModelIndex & p ) const { // qDebug() << this << "::rowCount(" << p << ")"; // qDebug() << "row-count:" << // ( ( m_StackedLayerModel==NULL || p.isValid() ) // ? 0 // : m_StackedLayerModel->GetCount() // ); return ( m_StackedLayerModel==NULL || p.isValid() ) ? 0 : m_StackedLayerModel->GetCount(); } /*****************************************************************************/ bool LayerStackItemModel ::setData( const QModelIndex & idx, const QVariant & value, int role ) { // qDebug() // << this << "::setData(" << idx << "," << value << "," << role << ")"; if( idx.column()==COLUMN_NAME && role==Qt::CheckStateRole ) { // qDebug() << idx.row() << "check-state:" << value; assert( !idx.parent().isValid() ); assert( idx.internalPointer()!=NULL ); assert( idx.internalPointer()!=NULL ); AbstractLayerModel * layer = static_cast< AbstractLayerModel * >( idx.internalPointer() ); assert( layer!=NULL ); assert( layer==dynamic_cast< VisibleInterface * >( layer ) ); VisibleInterface * interface = dynamic_cast< VisibleInterface * >( layer ); assert( interface!=NULL ); switch( value.toInt() ) { case Qt::Checked: interface->SetVisible( true ); break; case Qt::Unchecked: interface->SetVisible( false ); break; default: assert( false && "Unhandled Qt::CheckedState value." ); break; } emit dataChanged( idx, idx ); return true; } return false; } /*****************************************************************************/ Qt::DropActions LayerStackItemModel ::supportedDropActions() const { // qDebug() << this << "::supportedDropActions()"; // return Qt::MoveAction; return QAbstractItemModel::supportedDropActions(); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ // void // LayerStackItemModel // ::OnContentAboutToBeChanged() // { // qDebug() << this << "::OnAboutContentChanged()"; // emit layoutAboutToBeChanged(); // } /*****************************************************************************/ // void // LayerStackItemModel // ::OnContentChanged() // { // qDebug() << this << "::OnContentChanged()"; // // assert( m_StackedLayerModel!=NULL ); // // beginResetModel(); // // { // // } // // endResetModel(); // // if( m_StackedLayerModel->GetCount()>0 ) // // emit dataChanged( // // index( 0, 0 ), // // index( m_StackedLayerModel->GetCount() - 1, COLUMN_COUNT -1 ) // // ); // emit layoutChanged(); // } /*****************************************************************************/ void LayerStackItemModel ::OnImageSettingsUpdated( AbstractImageModel * image ) { // qDebug() << this << "::OnImageSettingsUpdated(" << image << ")"; assert( m_StackedLayerModel!=NULL ); StackedLayerModel::SizeType row = m_StackedLayerModel->IndexOf( image ); assert( row!=StackedLayerModel::NIL_INDEX ); emit dataChanged( createIndex( row, LayerStackItemModel::COLUMN_EFFECT, image ), createIndex( row, LayerStackItemModel::COLUMN_EFFECT, image ) ); } /*****************************************************************************/ void LayerStackItemModel ::OnLayerAboutToBeDeleted( size_t idx ) { assert( m_StackedLayerModel!=NULL ); Disconnect( m_StackedLayerModel->At( idx ) ); } /*****************************************************************************/ void LayerStackItemModel ::OnLayerAdded( size_t idx ) { if( !insertRow( idx ) ) { assert( false && "QAbstractItemModel::insertRow() failed!" ); return; } assert( m_StackedLayerModel!=NULL ); Connect( m_StackedLayerModel->At( idx ) ); } /*****************************************************************************/ void LayerStackItemModel ::OnLayerDeleted( size_t idx ) { #ifdef OTB_DEBUG bool isRowRemoved = #endif removeRow( idx ); #ifdef OTB_DEBUG assert( isRowRemoved && "QAbstractItemModel::removeRow() failed!" ); #endif } /*****************************************************************************/ void LayerStackItemModel ::OnLayerVisibilityChanged( AbstractLayerModel * layer, bool ) { // qDebug() << this << "::OnLayerVisibilityChanged(" << layer << "," << isVisible << ")"; assert( m_StackedLayerModel!=NULL ); assert( m_StackedLayerModel->IndexOf( layer )!=StackedLayerModel::NIL_INDEX ); QModelIndex idx( createIndex( m_StackedLayerModel->IndexOf( layer ), COLUMN_NAME, layer ) ); emit dataChanged( idx, idx ); } /*****************************************************************************/ void LayerStackItemModel ::OnPixelInfoChanged( const QPoint &, const PointType &, const PixelInfo::Vector & pixels ) { if( pixels.empty() ) return; emit dataChanged( index( 0, COLUMN_I ), index( pixels.size() - 1, COLUMN_COUNT - 1 ) ); } /*****************************************************************************/ // void // LayerStackItemModel // ::OnModelAboutToBeReset() // { // qDebug() << this << "::OnModelAboutToBeReset()"; // } /*****************************************************************************/ // void // LayerStackItemModel // ::OnModelReset() // { // qDebug() << this << "::OnModelReset()"; // } /*****************************************************************************/ void LayerStackItemModel ::OnReferenceChanged( size_t idx ) { // qDebug() << this << "::OnReferenceChanged(" << idx << ")"; assert( m_StackedLayerModel!=NULL ); AbstractLayerModel * layer = m_StackedLayerModel->GetReference(); assert( LayerStackItemModel::COLUMN_COUNT>0 ); emit dataChanged( createIndex( idx, 0, layer ), createIndex( idx, LayerStackItemModel::COLUMN_COUNT - 1, layer ) ); } /*****************************************************************************/ void LayerStackItemModel ::OnResolutionsChanged( const PixelInfo::Vector & pixels ) { if( pixels.empty() ) return; emit dataChanged( index( 0, COLUMN_RESOLUTION ), index( pixels.size() - 1, COLUMN_RESOLUTION ) ); } /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdLayerStackWidget.cxx000066400000000000000000000241451301006202600277060ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdLayerStackWidget.h" #include "ui_mvdLayerStackWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdGui.h" #include "mvdLayerStackItemModel.h" namespace mvd { /* TRANSLATOR mvd::LayerStackWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ LayerStackWidget ::LayerStackWidget( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::LayerStackWidget() ) { m_UI->setupUi( this ); m_UI->reloadButton->setVisible( false ); m_UI->treeView->setDragEnabled( true ); { QItemSelectionModel * ism = m_UI->treeView->selectionModel(); m_UI->treeView->setModel( new LayerStackItemModel( m_UI->treeView ) ); delete ism; ism = NULL; } InstallEventFilter( this ); QObject::connect( m_UI->treeView->selectionModel(), SIGNAL( currentRowChanged( const QModelIndex &, const QModelIndex & ) ), // to: this, SLOT( OnCurrentRowChanged( const QModelIndex &, const QModelIndex & ) ) ); QObject::connect( m_UI->treeView->selectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection & ) ), // to: this, SLOT( OnSelectionChanged( const QItemSelection &, const QItemSelection & ) ) ); QObject::connect( m_UI->topButton, SIGNAL( clicked() ), // to: this, SIGNAL( TopButtonClicked() ) ); QObject::connect( m_UI->bottomButton, SIGNAL( clicked() ), // to: this, SIGNAL( BottomButtonClicked() ) ); QObject::connect( m_UI->upButton, SIGNAL( clicked() ), // to: this, SIGNAL( UpButtonClicked() ) ); QObject::connect( m_UI->downButton, SIGNAL( clicked() ), // to: this, SIGNAL( DownButtonClicked() ) ); QObject::connect( m_UI->deleteButton, SIGNAL( clicked() ), // to: this, SIGNAL( DeleteLayerRequested() ) ); QObject::connect( m_UI->deleteAllButton, SIGNAL( clicked() ), // to: this, SIGNAL( DeleteAllLayersRequested() ) ); QObject::connect( m_UI->projectionButton, SIGNAL( clicked() ), // to: this, SIGNAL( ProjectionButtonClicked() ) ); QObject::connect( m_UI->applyButton, SIGNAL( clicked() ), // to: this, SIGNAL( ApplyButtonClicked() ) ); } /*******************************************************************************/ LayerStackWidget ::~LayerStackWidget() { delete m_UI; m_UI = NULL; } /*******************************************************************************/ bool LayerStackWidget ::eventFilter( QObject * object, QEvent * e ) { assert( object==m_UI->treeView ); assert( e!=NULL ); if( object!=m_UI->treeView ) return false; switch( e->type() ) { // // KEY RELEASE case QEvent::KeyRelease : { QKeyEvent * keyEvent = dynamic_cast< QKeyEvent * >( e ); assert( keyEvent!=NULL ); switch( keyEvent->key() ) { case Qt::Key_C: if( keyEvent->modifiers()==Qt::ControlModifier && m_UI->treeView->currentIndex().isValid() ) { emit CopyLayerRequested( LayerStackItemModel::GetLayer( m_UI->treeView->currentIndex() ) ); return true; } break; // case Qt::Key_Delete: if( keyEvent->modifiers()==Qt::NoModifier ) { emit DeleteLayerRequested(); return true; } else if( keyEvent->modifiers()==Qt::ShiftModifier ) { emit DeleteAllLayersRequested(); return true; } break; } } break; // // MOUSE-WHEEL case QEvent::Wheel : { QWheelEvent * wEvent = dynamic_cast< QWheelEvent * >( e ); assert( wEvent!=NULL ); if( wEvent->modifiers()==Qt::ControlModifier ) { emit RotateLayersRequested( wEvent->delta() / (MOUSE_WHEEL_STEP_FACTOR * MOUSE_WHEEL_STEP_DEGREES) ); return true; } } break; // // other. default: break; } return false; } /*******************************************************************************/ const LayerStackItemModel * LayerStackWidget ::GetItemModel() const { return const_cast< LayerStackWidget * >( this )->GetItemModel(); } /*******************************************************************************/ LayerStackItemModel * LayerStackWidget ::GetItemModel() { assert( m_UI->treeView->model()== qobject_cast< LayerStackItemModel * >( m_UI->treeView->model() ) ); return qobject_cast< LayerStackItemModel * >( m_UI->treeView->model() ); } /*******************************************************************************/ void LayerStackWidget ::InstallEventFilter( QObject * filter ) { assert( m_UI!=NULL ); assert( m_UI->treeView!=NULL ); m_UI->treeView->installEventFilter( filter ); } /*******************************************************************************/ // void // LayerStackWidget // ::SetModel( LayerStackItemModel * itemModel ) // { // // See http://qt-project.org/doc/qt-4.8/qabstractitemview.html#setModel . // QItemSelectionModel * itemSelectionModel = m_UI->treeView->selectionModel(); // m_UI->treeView->setModel( itemModel ); // itemModel->setParent( m_UI->treeView ); // delete itemSelectionModel; // itemSelectionModel = NULL; // } /*******************************************************************************/ void LayerStackWidget ::SetApplyEnabled( bool enabled ) { assert( m_UI->applyButton!=NULL ); m_UI->applyButton->setEnabled( enabled ); } /*******************************************************************************/ void LayerStackWidget ::SetCurrent( int row ) { assert( m_UI->treeView->selectionModel()!=NULL ); // if( m_UI->treeView->selectionModel()->currentIndex().row()==row ) // return; if( row<0 ) m_UI->treeView->selectionModel()->clearSelection(); else m_UI->treeView->selectionModel()->select( m_UI->treeView->model()->index( row, 1 ), QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows ); /* m_UI->treeView->selectionModel()->setCurrentIndex( m_UI->treeView->model()->index( row, 1 ), QItemSelectionModel::ClearAndSelect | // QItemSelectionModel::Current | QItemSelectionModel::Rows ); */ } /*******************************************************************************/ void LayerStackWidget ::SetDeleteEnabled( bool enabled ) { assert( m_UI!=NULL ); assert( m_UI->deleteButton!=NULL ); m_UI->deleteButton->setEnabled( enabled ); assert( m_UI->deleteAllButton!=NULL ); m_UI->deleteAllButton->setEnabled( enabled ); } /*******************************************************************************/ void LayerStackWidget ::SetMoveEnabled( bool enabled ) { assert( m_UI!=NULL ); assert( m_UI->upButton!=NULL ); assert( m_UI->downButton!=NULL ); assert( m_UI->topButton!=NULL ); assert( m_UI->bottomButton!=NULL ); m_UI->upButton->setEnabled( enabled ); m_UI->downButton->setEnabled( enabled ); m_UI->topButton->setEnabled( enabled ); m_UI->bottomButton->setEnabled( enabled ); } /*******************************************************************************/ void LayerStackWidget ::SetProjectionEnabled( bool enabled ) { assert( m_UI!=NULL ); assert( m_UI->projectionButton!=NULL ); m_UI->projectionButton->setEnabled( enabled ); } /*******************************************************************************/ void LayerStackWidget ::SetReloadEnabled( bool enabled ) { assert( m_UI!=NULL ); assert( m_UI->reloadButton!=NULL ); m_UI->reloadButton->setEnabled( enabled ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void LayerStackWidget ::OnCurrentRowChanged( const QModelIndex & current, const QModelIndex & ) { // qDebug() // << this // << "::OnCurrentRowChange(" << current.row() << "," << previous.row() << ")"; emit CurrentChanged( current.row() ); } /*******************************************************************************/ void LayerStackWidget ::OnSelectionChanged( const QItemSelection & selected, const QItemSelection & ) { // qDebug() // << this // << "::OnSelectionChanged(" << selected << "," << deselected << ")"; QModelIndexList indexes( selected.indexes() ); // assert( indexes.empty() || indexes.size()==1 ); emit SelectionChanged( indexes.empty() ? -1 : indexes.front().row() ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdLayerStackWidget.ui000066400000000000000000000162661301006202600275260ustar00rootroot00000000000000 mvd::LayerStackWidget 0 0 305 124 Form 3 3 false QAbstractItemView::InternalMove Qt::CopyAction true 3 Move selected layer to top of stack :/icons/action_LayerTop_Icon:/icons/action_LayerTop_Icon Move selected layer up within the stack :/icons/action_LayerUp_Icon:/icons/action_LayerUp_Icon Move selected layer down within the stack :/icons/action_LayerDown_Icon:/icons/action_LayerDown_Icon Move selected layer to bottom of stack :/icons/action_LayerBottom_Icon:/icons/action_LayerBottom_Icon Use selected layer as projection reference :/icons/action_LayerProjection_Icon:/icons/action_LayerProjection_Icon Apply all display settings (color-setup, color-dynamics, shader etc.) of selected layer to all other layers :/icons/action_ApplyAll_Icon:/icons/action_ApplyAll_Icon Reload data file :/icons/action_Reload_Icon:/icons/action_Reload_Icon Qt::Horizontal 40 20 Delete all layers :/icons/action_LayerDeleteAll_Icon:/icons/action_LayerDeleteAll_Icon Delete selected layer :/icons/action_LayerDelete_Icon:/icons/action_LayerDelete_Icon OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdMainWindowTitleLoader.cxx000066400000000000000000000045571301006202600307120ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdMainWindowTitleLoader.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdVectorImageModel.h" namespace mvd { MainWindowTitleLoader ::MainWindowTitleLoader(VectorImageModel* model): m_Model(model) { } void MainWindowTitleLoader ::LoadTitle() { // This method is executed in a separate thread assert( m_Model!=NULL ); #if 0 std::ostringstream oss; oss<GetFilename() )); oss<<" ("<GetNbComponents()<GetNativeLargestRegion().GetSize()[0]; oss<<"x"<GetNativeLargestRegion().GetSize()[1]<GetCenterPixelPlaceName(); if (!placename.empty()) { oss <<" - " <GetNativeLargestRegion().GetSize() ); QString placename( FromStdString( m_Model->GetCenterPixelPlaceName() ) ); QString title( tr( PROJECT_NAME " - %1 (%2 bands, %3x%4 pixels)%5" ) .arg( QFileInfo( m_Model->GetFilename() ).fileName() ) .arg( m_Model->GetNbComponents() ) .arg( size[ 0 ] ) .arg( size[ 1 ] ) .arg( placename.isEmpty() ? "" : placename.prepend( " " ) ) ); qDebug() << "Title:" << title; emit TitleLoaded( title ); #endif emit Finished(); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdMultiResolutionPyramidWidget.cxx000066400000000000000000000257721301006202600323570ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdMultiResolutionPyramidWidget.h" #include "ui_mvdMultiResolutionPyramidWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdCore.h" #include "mvdGui.h" #include "mvdI18nCoreApplication.h" namespace mvd { /* TRANSLATOR mvd::MultiResolutionPyramidWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ char const * const GDAL_RESAMPLING_NAMES[ otb::GDAL_RESAMPLING_COUNT ] = { QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "None" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "Nearest" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "Gauss" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "Cubic" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "Average" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "Mode" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "Average Mag/Phase" ), }; char const * const GDAL_COMPRESSION_NAMES[ otb::GDAL_COMPRESSION_COUNT ] = { QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "None" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "JPEG" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "LZW" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "PACKBITS" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "DEFLATE" ), }; char const * const GDAL_FORMAT_NAMES[ otb::GDAL_FORMAT_COUNT ] = { QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "ERDAS" ), QT_TRANSLATE_NOOP( "mvd::MultiResolutionPyramidWidget", "GeoTIFF" ), }; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ MultiResolutionPyramidWidget ::MultiResolutionPyramidWidget( QWidget * p, Qt::WindowFlags flags ) : QWidget( p, flags ), m_UI( new mvd::Ui::MultiResolutionPyramidWidget() ) { m_UI->setupUi( this ); { QItemSelectionModel * ism = m_UI->resolutionsListView->selectionModel(); m_UI->resolutionsListView->setModel( new QStandardItemModel( m_UI->resolutionsListView ) ); delete ism; ism = NULL; } AddItemsInto( m_UI->formatComboBox, "mvd::MultiResolutionPyramidWidget", GDAL_FORMAT_NAMES, otb::GDAL_FORMAT_COUNT ); AddItemsInto( m_UI->algorithmComboBox, "mvd::MultiResolutionPyramidWidget", GDAL_RESAMPLING_NAMES, otb::GDAL_RESAMPLING_COUNT ); AddItemsInto( m_UI->compressionComboBox, "mvd::MultiResolutionPyramidWidget", GDAL_COMPRESSION_NAMES, otb::GDAL_COMPRESSION_COUNT ); m_UI->baseSpinBox->setValue( 2 ); m_UI->levelsSpinBox->setValue( 1 ); m_UI->sizeSpinBox->setValue( 2 ); } /*****************************************************************************/ MultiResolutionPyramidWidget ::~MultiResolutionPyramidWidget() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ void MultiResolutionPyramidWidget ::ClearResolutions() { QStandardItemModel * itemModel = qobject_cast< QStandardItemModel * >( m_UI->resolutionsListView->model() ); assert( itemModel!=NULL ); itemModel->clear(); } /*****************************************************************************/ void MultiResolutionPyramidWidget ::SetBuilder( const otb::GDALOverviewsBuilder::Pointer & p ) { m_UI->formatComboBox->setCurrentIndex( otb::GDAL_FORMAT_GEOTIFF ); m_UI->algorithmComboBox->setCurrentIndex( otb::GDAL_RESAMPLING_AVERAGE ); m_UI->compressionComboBox->setCurrentIndex( otb::GDAL_COMPRESSION_NONE ); { bool prevSignalsBlocked = m_UI->baseSpinBox->blockSignals( true ); m_UI->baseSpinBox->setValue( 2 ); m_UI->baseSpinBox->blockSignals( prevSignalsBlocked ); } { bool prevSignalsBlocked = m_UI->levelsSpinBox->blockSignals( true ); m_UI->levelsSpinBox->setValue( 1 ); m_UI->levelsSpinBox->blockSignals( prevSignalsBlocked ); } { bool prevSignalsBlocked = m_UI->sizeSpinBox->blockSignals( true ); m_UI->sizeSpinBox->setRange( 1, std::numeric_limits< int >::max() ); m_UI->sizeSpinBox->setValue( 1 ); m_UI->sizeSpinBox->blockSignals( prevSignalsBlocked ); } ClearResolutions(); m_GDALOverviewsBuilder = p; if( p.IsNull() ) return; assert( !m_GDALOverviewsBuilder.IsNull() ); m_UI->formatComboBox->setCurrentIndex( m_GDALOverviewsBuilder->GetFormat() ); m_UI->algorithmComboBox->setCurrentIndex( m_GDALOverviewsBuilder->GetResamplingMethod() ); m_UI->compressionComboBox->setCurrentIndex( m_GDALOverviewsBuilder->GetCompressionMethod() ); unsigned int minSize = std::min( m_GDALOverviewsBuilder->GetWidth(), m_GDALOverviewsBuilder->GetHeight() ); { bool prevSignalsBlocked = m_UI->baseSpinBox->blockSignals( true ); m_UI->baseSpinBox->setRange( 2, minSize ); m_UI->baseSpinBox->setValue( m_GDALOverviewsBuilder->GetResolutionFactor() ); m_UI->baseSpinBox->blockSignals( prevSignalsBlocked ); } unsigned int maxResolutions = m_GDALOverviewsBuilder->CountResolutions(); { bool prevSignalsBlocked = m_UI->levelsSpinBox->blockSignals( true ); m_UI->levelsSpinBox->setRange( 0, maxResolutions ); m_UI->levelsSpinBox->setValue( m_GDALOverviewsBuilder->GetNbResolutions() ); m_UI->levelsSpinBox->blockSignals( prevSignalsBlocked ); } { bool prevSignalsBlocked = m_UI->sizeSpinBox->blockSignals( true ); m_UI->sizeSpinBox->setRange( 1, minSize ); assert( maxResolutions >= m_GDALOverviewsBuilder->GetNbResolutions() ); // Force C++ implicit cast by declaring local variables to force compiler // to find correct std::pow() signature. // // It fixes compile-time: // error: call of pow(unsigned int, unsigned int) is ambiguous double rf = m_GDALOverviewsBuilder->GetResolutionFactor(); int m = maxResolutions - m_GDALOverviewsBuilder->GetNbResolutions(); m_UI->sizeSpinBox->setValue( static_cast< int >( std::pow( rf, m ) ) ); m_UI->sizeSpinBox->blockSignals( prevSignalsBlocked ); } UpdateResolutions(); } /*****************************************************************************/ void MultiResolutionPyramidWidget ::UpdateResolutions() { assert( !m_GDALOverviewsBuilder.IsNull() ); QStandardItemModel * itemModel = qobject_cast< QStandardItemModel * >( m_UI->resolutionsListView->model() ); assert( itemModel!=NULL ); otb::GDALOverviewsBuilder::SizeVector resolutions; m_GDALOverviewsBuilder->ListResolutions( resolutions ); for( otb::GDALOverviewsBuilder::SizeVector::const_iterator it( resolutions.begin() ); it!=resolutions.end(); ++ it ) itemModel->appendRow( new QStandardItem( QString( "%1x%2" ) .arg( ( *it )[ 0 ] ) .arg( ( *it )[ 1 ] ) ) ); } /*****************************************************************************/ void MultiResolutionPyramidWidget ::UpdateSize() { assert( !m_GDALOverviewsBuilder.IsNull() ); bool prevSignalsBlocked = m_UI->sizeSpinBox->blockSignals( true ); unsigned int count = m_GDALOverviewsBuilder->CountResolutions(); // Force C++ implicit cast by declaring local variables to force compiler // to find correct std::pow() signature. // // It fixes compile-time: // error: call of pow(unsigned int, unsigned int) is ambiguous double rf = m_GDALOverviewsBuilder->GetResolutionFactor(); int m = count - std::min( m_GDALOverviewsBuilder->GetNbResolutions(), count ); m_UI->sizeSpinBox->setValue( static_cast< int >( std::pow( rf, m ) ) ); m_UI->sizeSpinBox->blockSignals( prevSignalsBlocked ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void MultiResolutionPyramidWidget ::on_baseSpinBox_valueChanged( int value ) { // qDebug() << this << "::on_baseSpinBox_valueChanged(" << value << ")"; ClearResolutions(); if( m_GDALOverviewsBuilder.IsNull() ) return; m_GDALOverviewsBuilder->SetResolutionFactor( value ); m_UI->levelsSpinBox->setRange( 0, m_GDALOverviewsBuilder->CountResolutions() ); UpdateResolutions(); UpdateSize(); emit BaseValueChanged( value ); } /*****************************************************************************/ void MultiResolutionPyramidWidget ::on_levelsSpinBox_valueChanged( int value ) { // qDebug() << this << "::on_levelsSpinBox_valueChanged(" << value << ")"; ClearResolutions(); if( m_GDALOverviewsBuilder.IsNull() ) return; m_GDALOverviewsBuilder->SetNbResolutions( value ); UpdateResolutions(); UpdateSize(); emit LevelsValueChanged( value ); } /*****************************************************************************/ void MultiResolutionPyramidWidget ::on_sizeSpinBox_valueChanged( int value ) { // qDebug() << this << "::on_sizeSpinBox_valueChanged(" << value << ")"; if( m_GDALOverviewsBuilder.IsNull() ) return; unsigned int count = m_GDALOverviewsBuilder->CountResolutions( m_GDALOverviewsBuilder->GetResolutionFactor(), value ); if( static_cast< unsigned int >( m_UI->levelsSpinBox->value() )<=count ) return; { bool prevSignalsBlocked = m_UI->levelsSpinBox->blockSignals( true ); m_UI->levelsSpinBox->setValue( count ); m_GDALOverviewsBuilder->SetNbResolutions( count ); m_UI->levelsSpinBox->blockSignals( prevSignalsBlocked ); } ClearResolutions(); UpdateResolutions(); emit SizeValueChanged( value ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdMultiResolutionPyramidWidget.ui000066400000000000000000000131231301006202600321550ustar00rootroot00000000000000 mvd::MultiResolutionPyramidWidget 0 0 359 101 Form 4 4 0 0 File format used for overview file Format: File format used for overview file 0 0 Decimation factor = Base power Level Base: Decimation factor = Base power Level 2 Size list of all overview levels 0 0 Algorithm used when resampling image to compute overview level Algorithm: Algorithm used when resampling image to compute overview level 0 0 Decimation factor = Base power Level Levels: Decimation factor = Base power Level 0 0 Algorithm used to compress overview level data Compression: Algorithm used to compress overview level data 0 0 Minimal size (in pixels) of smallest overview level Size: Minimal size (in pixels) of smallest overview level 1 Qt::Vertical 20 40 OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdMyWidget.cxx000066400000000000000000000046511301006202600262310ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdMyWidget.h" #include "ui_mvdMyWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::MyWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ MyWidget ::MyWidget( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::MyWidget() ) { m_UI->setupUi( this ); } /*******************************************************************************/ MyWidget ::~MyWidget() { delete m_UI; m_UI = NULL; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdMyWidget.ui000066400000000000000000000007371301006202600260450ustar00rootroot00000000000000 mvd::MyWidget 0 0 400 300 Form OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdOTBApplicationsModel.cxx000066400000000000000000000065541301006202600304600ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdOTBApplicationsModel.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdApplicationsBrowser.h" #include "mvdApplicationLauncher.h" namespace mvd { /* TRANSLATOR mvd::OTBApplicationsModel Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ OTBApplicationsModel ::OTBApplicationsModel( QObject* p ) : AbstractModel( p ), m_ApplicationsBrowser( NULL ), m_ApplicationLauncher( NULL ) { // // instantiate apps browser m_ApplicationsBrowser = new ApplicationsBrowser( this ); // // instantiate app launcher m_ApplicationLauncher = new ApplicationLauncher( this ); // initialize the app browser with empty string. The default // behavior use the env ITK_AUTOLOAD_PATH //m_ApplicationsBrowser->SetAutoLoadPath(""); } /*******************************************************************************/ OTBApplicationsModel ::~OTBApplicationsModel() { } /*******************************************************************************/ void OTBApplicationsModel ::virtual_BuildModel( void * ) { // nothing to do } /*******************************************************************************/ void OTBApplicationsModel ::FillTree( ) { // // this method is connected to the widget via a signal. In // ApplicationBrowser, when the map is filled with tags/Apps, a // signal is emitted and received by the widget to fill its tree. m_ApplicationsBrowser->SearchAvailableApplicationsTags(); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdPixelDescriptionWidget.cxx000066400000000000000000000174041301006202600311310ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdPixelDescriptionWidget.h" #include "ui_mvdPixelDescriptionWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" namespace mvd { /* TRANSLATOR mvd::PixelDescriptionWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ PixelDescriptionWidget ::PixelDescriptionWidget( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::PixelDescriptionWidget() ), m_CartographicRootItem( NULL ), m_GeographicRootItem( NULL ), m_PixelValueRootItem( NULL ), m_CartographicItem( NULL ), m_GeographicItem( NULL ) { m_UI->setupUi( this ); SetupUI(); } /*******************************************************************************/ PixelDescriptionWidget ::~PixelDescriptionWidget() { delete m_UI; m_UI = NULL; } /*******************************************************************************/ void PixelDescriptionWidget ::SetupUI() { // // Cartographic coordiantes m_CartographicRootItem = new QTreeWidgetItem( GetDescriptionTree() ); //m_CartographicRootItem->setText(0, tr("Cartographic")); m_CartographicRootItem->setExpanded(true); // m_CartographicItem = new QTreeWidgetItem( m_CartographicRootItem ); // m_CartographicItem->setText(0, tr("Coordinates")); // // Geographic coordinates m_GeographicRootItem = new QTreeWidgetItem( GetDescriptionTree() ); m_GeographicRootItem->setText(0, tr("Geographic")); m_GeographicRootItem->setExpanded(true); //m_GeographicItem = new QTreeWidgetItem( m_GeographicRootItem ); //m_GeographicItem->setText(0, tr("Coordinates")); // // Child items will be created + updated in a dedicated slot m_PixelValueRootItem = new QTreeWidgetItem( GetDescriptionTree() ); m_PixelValueRootItem->setText(0, tr("Pixel Values")); m_PixelValueRootItem->setExpanded(true); } /*******************************************************************************/ QTreeWidget * PixelDescriptionWidget ::GetDescriptionTree() { return m_UI->m_DescriptionTree; } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void PixelDescriptionWidget ::OnCurrentPhysicalUpdated(const QStringList & currentPhysical) { // qDebug() << this << "::OnCurrentPhysicalUpdated(" << currentPhysical << ")"; //m_CartographicItem->setText(1, currentPhysical); if (!currentPhysical.empty()) { // remove the previous QTreeWidgetItem of m_GeographicRootItem while( m_CartographicRootItem->childCount()>0 ) { // Remove QTreeWidgetItem QTreeWidgetItem* child = m_CartographicRootItem->takeChild( 0 ); // Delete it from memory. delete child; child = NULL; } m_CartographicRootItem->setText( 0, currentPhysical[ 0 ] ); // fill with the new values QTreeWidgetItem * iCartoXItem = new QTreeWidgetItem( m_CartographicRootItem ); iCartoXItem->setText( 0, tr( "X" ) ); iCartoXItem->setText( 1, currentPhysical[ 1 ] ); QTreeWidgetItem * iCartoYItem = new QTreeWidgetItem( m_CartographicRootItem ); iCartoYItem->setText( 0, tr( "Y" ) ); iCartoYItem->setText( 1, currentPhysical[ 2 ] ); } } /*******************************************************************************/ void PixelDescriptionWidget ::OnCurrentGeographicUpdated(const QStringList&/*const QString &*/ currentGeo) { // qDebug() << this << "::OnCurrentGeographicUpdated(" << currentGeo << ")"; if (!currentGeo.empty()) { // remove the previous QTreeWidgetItem of m_GeographicRootItem while( m_GeographicRootItem->childCount()>0 ) { // Remove QTreeWidgetItem QTreeWidgetItem* child = m_GeographicRootItem->takeChild( 0 ); // Delete it from memory. delete child; child = NULL; } m_GeographicRootItem->setText( 0, currentGeo[ 0 ] ); // fill with the new values QTreeWidgetItem * iGeoLongItem = new QTreeWidgetItem( m_GeographicRootItem ); iGeoLongItem->setText( 0, tr( "Long" ) ); iGeoLongItem->setText( 1, currentGeo[ 1 ] ); QTreeWidgetItem * iGeoLatItem = new QTreeWidgetItem( m_GeographicRootItem ); iGeoLatItem->setText( 0, tr( "Lat" ) ); iGeoLatItem->setText( 1, currentGeo[ 2 ] ); QTreeWidgetItem * iGeoElevationItem = new QTreeWidgetItem( m_GeographicRootItem ); iGeoElevationItem->setText( 0, tr( "Elevation" ) ); iGeoElevationItem->setText( 1, currentGeo.size() > 3 ? currentGeo[ 3 ] : tr( "Not available" ) ); } } /*******************************************************************************/ void PixelDescriptionWidget ::OnCurrentPixelValueUpdated(const VectorImageType::PixelType & currentPixel, const QStringList& bandNames) { // qDebug() << this << "::OnCurrentPixelValueUpdated(" << bandNames << ")"; if (!bandNames.empty() || currentPixel.GetSize() != 0) { // // remove the previous QTreeWidgetItem of m_PixelValueRootItem while( m_PixelValueRootItem->childCount()>0 ) { // Remove QTreeWidgetItem QTreeWidgetItem* child = m_PixelValueRootItem->takeChild( 0 ); // Delete it from memory. delete child; child = NULL; } // qDebug() << "Bands:" << bandNames; // assert( bandNames.size()==currentPixel.GetSize() ); // fill with the new values for (unsigned int idx = 0; idx < currentPixel.GetSize(); idx++) { QTreeWidgetItem * iBandItem = new QTreeWidgetItem( m_PixelValueRootItem ); // figure out if a band name is available, if not use Band idx if( !bandNames[ idx ].isEmpty() && static_cast< unsigned int >( bandNames.size() )==currentPixel.GetSize() ) { iBandItem->setText(0, bandNames[ idx ] ); } else { iBandItem->setText( 0, tr( "Band %1" ).arg( idx+1 ) ); } // set the value iBandItem->setText(1, QString("%1").arg(currentPixel.GetElement( idx )) ); } } } /*******************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdPixelDescriptionWidget.ui000066400000000000000000000033541301006202600307430ustar00rootroot00000000000000 mvd::PixelDescriptionWidget 0 0 94 87 0 0 Pixel Description QLayout::SetDefaultConstraint 3 2 0 0 Qt::CustomContextMenu false 2 true Description Value OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdQtWidgetView.cxx000066400000000000000000000443311301006202600270620ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdQtWidgetView.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbWrapperApplicationHtmlDocGenerator.h" // #include "otbWrapperComplexOutputImageParameter.h" #include "otbWrapperOutputFilenameParameter.h" // #include "otbWrapperOutputImageParameter.h" #include "otbWrapperOutputVectorDataParameter.h" // #include "otbWrapperQtWidgetOutputImageParameter.h" // #include "otbWrapperQtWidgetProgressReport.h" #include "otbWrapperQtWidgetSimpleProgressReport.h" // #include "otbWrapperTypes.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractLayerModel.h" #include "mvdFilenameInterface.h" #include "mvdI18nCoreApplication.h" #include "mvdStackedLayerModel.h" #include "mvdQtWidgetParameterInitializers.h" namespace mvd { namespace Wrapper { /* TRANSLATOR mvd::Wrapper::QtWidgetView Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* INTERNAL TYPES */ class KeyLayerAccumulator : public std::unary_function< StackedLayerModel::ConstIterator::value_type, void > { public: typedef std::unary_function< StackedLayerModel::ConstIterator::value_type, void > SuperType; typedef std::list< SuperType::argument_type > KeyLayerPairList; KeyLayerAccumulator( const std::string & filename, KeyLayerPairList & klp ) : m_KeyLayerPairs( klp ), m_Filename( FromStdString( filename ) ), m_Count( 0 ) { } void operator () ( const SuperType::argument_type & pair ) { const FilenameInterface * interface = dynamic_cast< const FilenameInterface * >( pair.second ); if( interface!=NULL && m_Filename.compare( interface->GetFilename() )==0 ) { qDebug() << m_Filename << "==" << interface->GetFilename(); m_KeyLayerPairs.push_back( pair ); ++ m_Count; } } std::size_t GetCount() const { return m_Count; } public: KeyLayerPairList & m_KeyLayerPairs; private: QString m_Filename; std::size_t m_Count; }; /*****************************************************************************/ /* CONSTANTS */ char const * const QtWidgetView ::OBJECT_NAME = "mvd::Wrapper::QtWidgetView"; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ QtWidgetView ::QtWidgetView( const otb::Wrapper::Application::Pointer & otbApp, QWidget* p, Qt::WindowFlags flags ) : QWidget( p, flags ), m_Application( otbApp ), m_Model( NULL ), m_ExecButton( NULL ), m_QuitButton( NULL ), m_Message( NULL ), m_IsClosable( true ) { setObjectName( QtWidgetView::OBJECT_NAME ); m_Model = new otb::Wrapper::QtWidgetModel( otbApp ); QObject::connect( m_Model, SIGNAL( SetProgressReportBegin() ), this, SLOT( OnProgressReportBegin() ) ); QObject::connect( m_Model, SIGNAL( SetProgressReportDone( int ) ), this, SLOT( OnProgressReportEnd( int ) ) ); QObject::connect( m_Model, SIGNAL( ExceptionRaised( QString ) ), this, SLOT( OnExceptionRaised( QString ) ) ); } /*******************************************************************************/ QtWidgetView ::~QtWidgetView() { // m_Application is smart-pointed and will be automatically deleted. delete m_Model; m_Model = NULL; } /*******************************************************************************/ void QtWidgetView ::CreateGui() { // Create a VBoxLayout with the header, the input widgets, and the footer QVBoxLayout *mainLayout = new QVBoxLayout(); QTabWidget *tab = new QTabWidget(); tab->addTab(CreateInputWidgets(), "Parameters"); //otb::Wrapper::QtWidgetProgressReport* prog = new otb::Wrapper::QtWidgetProgressReport(m_Model); //prog->SetApplication(m_Application); //tab->addTab(prog, "Progress"); tab->addTab(CreateDoc(), "Documentation"); mainLayout->addWidget(tab); QTextEdit *log = new QTextEdit(); connect( m_Model->GetLogOutput(), SIGNAL(NewContentLog(QString)), log, SLOT(append(QString) ) ); tab->addTab(log, "Logs"); m_Message = new QLabel("
    Select parameters
    "); connect( m_Model, SIGNAL( SetApplicationReady( bool ) ), this, SLOT( UpdateMessageAfterApplicationReady( bool ) ) ); mainLayout->addWidget(m_Message); otb::Wrapper::QtWidgetSimpleProgressReport* progressReport = new otb::Wrapper::QtWidgetSimpleProgressReport(m_Model); progressReport->SetApplication(m_Application); QHBoxLayout *footLayout = new QHBoxLayout; footLayout->addWidget(progressReport); footLayout->addWidget(CreateFooter()); mainLayout->addLayout(footLayout); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(mainLayout); QVBoxLayout *finalLayout = new QVBoxLayout(); finalLayout->addWidget(mainGroup); // Make the final layout to the widget this->setLayout(finalLayout); } /*******************************************************************************/ QWidget* QtWidgetView ::CreateInputWidgets() { QScrollArea *scrollArea = new QScrollArea; QWidget * widget = otb::Wrapper::QtWidgetParameterFactory::CreateQtWidget( m_Model->GetApplication()->GetParameterList(), m_Model ); scrollArea->setWidget( widget ); scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded); scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); scrollArea->setWidgetResizable(true); // // need to be connected to the end of a process QObject::connect( m_Model, SIGNAL( SetProgressReportDone( int ) ), // to: this, SLOT ( OnApplicationExecutionDone( int ) ) ); SetupParameterWidgets( widget ); return scrollArea; } /*******************************************************************************/ QWidget* QtWidgetView ::CreateFooter() { // an HLayout with two buttons : Execute and Quit QGroupBox *footerGroup = new QGroupBox; QHBoxLayout *footerLayout = new QHBoxLayout; footerGroup->setFixedHeight(40); footerGroup->setContentsMargins(0, 0, 0, 0); footerLayout->setContentsMargins(5, 5, 5, 5); m_ExecButton = new QPushButton(footerGroup); m_ExecButton->setDefault(true); m_ExecButton->setEnabled(false); m_ExecButton->setText(QObject::tr("Execute")); connect( m_Model, SIGNAL( SetApplicationReady( bool ) ), m_ExecButton, SLOT( setEnabled( bool ) ) ); QObject::connect( m_ExecButton, SIGNAL( clicked() ), // to: this, SLOT( OnExecButtonClicked() ) ); QObject::connect( this, SIGNAL( ExecuteAndWriteOutput() ), // to: m_Model, SLOT( ExecuteAndWriteOutputSlot() ) ); m_QuitButton = new QPushButton(footerGroup); m_QuitButton->setText(QObject::tr("Quit")); connect( m_QuitButton, SIGNAL( clicked() ), // to: this, SLOT( close() ) ); // Put the buttons on the right footerLayout->addStretch(); footerLayout->addWidget(m_ExecButton); footerLayout->addWidget(m_QuitButton); footerGroup->setLayout(footerLayout); return footerGroup; } /*******************************************************************************/ QWidget* QtWidgetView ::CreateDoc() { QTextEdit *text = new QTextEdit; text->setReadOnly(true); QTextDocument * doc = new QTextDocument(); std::string docContain; otb::Wrapper::ApplicationHtmlDocGenerator::GenerateDoc( m_Application, docContain); doc->setHtml(docContain.c_str()); text->setDocument(doc); return text; } /*******************************************************************************/ void QtWidgetView ::SetupParameterWidgets( QWidget * widget ) { assert( widget!=NULL ); SetupWidget( widget, InputFilenameInitializer() ); SetupWidget( widget, InputFilenameListInitializer( this ) ); SetupWidget( widget, InputImageInitializer() ); SetupWidget( widget, InputImageListInitializer( this ) ); SetupWidget( widget, InputProcessXMLInitializer() ); SetupWidget( widget, InputVectorDataInitializer() ); SetupWidget( widget, InputVectorDataListInitializer( this ) ); #if defined( OTB_DEBUG ) SetupWidget( widget, ToolTipInitializer() ); #endif SetupWidget( widget, OutputFilenameInitializer() ); SetupWidget( widget, OutputProcessXMLInitializer() ); SetupWidget( widget, OutputImageInitializer( m_Application->GetName() ) ); SetupWidget( widget, OutputVectorDataInitializer() ); } /*******************************************************************************/ void QtWidgetView ::SetupFileSelectionWidget( QWidget * widget ) { assert( widget!=NULL ); assert( qobject_cast< FileSelectionInitializer::argument_type >( widget )!=NULL ); FileSelectionInitializer initialize; initialize( qobject_cast< FileSelectionInitializer::argument_type >( widget ) ); } /*******************************************************************************/ void QtWidgetView ::closeEvent( QCloseEvent * e ) { assert( e!=NULL ); if( !IsClosable() ) { assert( !m_Application.IsNull() ); QMessageBox::warning( this, tr( "Warning!" ), tr( "OTB-Application '%1' cannot be closed while running!") .arg( m_Application->GetDocName() ) ); e->ignore(); return; } QWidget::closeEvent( e ); emit QuitSignal(); deleteLater(); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void QtWidgetView ::OnExecButtonClicked() { assert( m_Model!=NULL ); assert( m_Model->GetApplication()!=NULL ); assert( I18nCoreApplication::Instance()!=NULL ); // // Get layer-stack, if any. StackedLayerModel * layerStack = I18nCoreApplication::Instance()->GetModel< StackedLayerModel >(); otb::Wrapper::Application::Pointer otbApp( m_Model->GetApplication() ); // // Check output parameters of OTB-application. StringVector paramKeys( otbApp->GetParametersKeys() ); QStringList filenames1; KeyLayerAccumulator::KeyLayerPairList layers; QStringList filenames2; for( StringVector::const_iterator it( paramKeys.begin() ); it!=paramKeys.end(); ++it ) { if( otbApp->IsParameterEnabled( *it, true ) && otbApp->HasValue( *it ) ) { otb::Wrapper::Parameter::Pointer param( otbApp->GetParameterByKey( *it ) ); assert( !param.IsNull() ); // qDebug() // << it->c_str() << ": type" << otbApp->GetParameterType( *it ); // const char* filename = NULL; std::string filename; switch( otbApp->GetParameterType( *it ) ) { case otb::Wrapper::ParameterType_OutputFilename: filename = otb::DynamicCast< otb::Wrapper::OutputFilenameParameter >( param ) ->GetValue(); break; // // FILENAME. // // IMAGE. case otb::Wrapper::ParameterType_OutputImage: filename = otb::DynamicCast< otb::Wrapper::OutputImageParameter >( param ) ->GetFileName(); break; // // VECTOR-DATA. case otb::Wrapper::ParameterType_OutputVectorData: filename = otb::DynamicCast< otb::Wrapper::OutputVectorDataParameter >( param ) ->GetFileName(); break; // // COMPLEX IMAGE. case otb::Wrapper::ParameterType_ComplexOutputImage: filename = otb::DynamicCast< otb::Wrapper::ComplexOutputImageParameter >( param ) ->GetFileName(); break; // // NONE. default: break; } if( QFileInfo( filename.c_str() ).exists() ) filenames1.push_back( filename.c_str() ); if( layerStack!=NULL ) { KeyLayerAccumulator accumulator( std::for_each( layerStack->Begin(), layerStack->End(), KeyLayerAccumulator( filename, layers ) ) ); if( accumulator.GetCount()>0 ) filenames2.push_back( filename.c_str() ); } } } { QString message; if( filenames1.size()==1 ) { // qDebug() // << it->c_str() << ":" << QString( filename.c_str() ); message = tr( "Are you sure you want to overwrite file '%1'?" ) .arg( filenames1.front() ); } else if( filenames1.size()>1 ) { message = tr( "Following files will be overwritten. Are you sure you want to continue?\n- %1" ) .arg( filenames1.join( "\n- " ) ); } if( !message.isEmpty() ) { QMessageBox::StandardButton button = QMessageBox::question( this, PROJECT_NAME, message, QMessageBox::Yes | QMessageBox::No, QMessageBox::No ); if( button==QMessageBox::No ) return; } } { QString message; if( filenames2.size()==1 ) { // qDebug() // << it->c_str() << ":" << QString( filename.c_str() ); message = tr( "File '%1' is being viewed in " PROJECT_NAME " and will be concurrently overwritten by running this %2. File will be removed from layer-stack before running %2 and reloaded after.\n\nDo you want to continue?" ) .arg( filenames2.front() ) .arg( otbApp->GetDocName() ); } else if( filenames2.size()>1 ) { message = tr( "Following files are being viewed in " PROJECT_NAME " and will be concurrently overwritter by running %2. Files will be removed from layer-stack before running %2. Do you want to continue?\n- %1" ) .arg( filenames2.join( "\n- " ) ) .arg( otbApp->GetDocName() ); } if( !message.isEmpty() ) { QMessageBox::StandardButton button = QMessageBox::question( this, PROJECT_NAME, message, QMessageBox::Yes | QMessageBox::No, QMessageBox::No ); if( button==QMessageBox::No ) return; while( !layers.empty() ) { layerStack->Delete( layers.front().first ); layers.pop_front(); } } } /* U N S A F E // BUGFIX: Mantis-750 // // Remove files which will be overwritten in order to use // file-existence to check whether to emit the OutputImageChanged // signal (see ::OnApplicationExecutionDone()). for( FileInfoVector::const_iterator it( fileInfos.begin() ); it!=fileInfos.end(); ++it ) { qDebug() << "Removing:" << it->filePath(); it->dir().remove( it->fileName() ); } */ m_Message->setText("
    Running
    "); emit ExecuteAndWriteOutput(); } /*******************************************************************************/ void QtWidgetView ::UpdateMessageAfterApplicationReady( bool val ) { if(val == true) m_Message->setText("
    Ready to run
    "); else m_Message->setText("
    Select parameters
    "); } /*******************************************************************************/ void QtWidgetView ::OnExceptionRaised( QString what ) { qWarning() << what; #if defined( OTB_DEBUG ) QMessageBox::warning( this, PROJECT_NAME, what, QMessageBox::Ok ); #endif } /*******************************************************************************/ void QtWidgetView ::OnApplicationExecutionDone( int status ) { otb::Wrapper::Application::Pointer otbApp( m_Model->GetApplication() ); if( status!=0 ) { QMessageBox::information( this, PROJECT_NAME, tr( "'%1' has failed with return status %2.\n" "Please refer to '%1' documentation and check log tab." ) .arg( otbApp->GetName() ) .arg( status ), QMessageBox::Ok ); emit ExecutionDone( status ); return; } /* // Removed as per MVDX-259. QMessageBox::information( this, PROJECT_NAME, tr( "'%1' has succeeded.\n" "Result(s) will be imported as dataset(s).\n") .arg( otbApp->GetName() ), QMessageBox::Ok ); */ CountType count = 0; // // detect if this application has outputImageParameter. emit // the output filenames if any StringVector paramList( otbApp->GetParametersKeys( true ) ); // iterate on the application parameters for ( StringVector::const_iterator it( paramList.begin() ); it!=paramList.end(); ++it ) { // parameter key const std::string& key = *it; // get a valid outputParameter if( otbApp->GetParameterType( key ) ==otb::Wrapper::ParameterType_OutputImage && otbApp->IsParameterEnabled( key, true ) && otbApp->HasValue( key ) ) { // get the parameter otb::Wrapper::Parameter* param = otbApp->GetParameterByKey( key ); // try to cast it otb::Wrapper::OutputImageParameter* outputParam = dynamic_cast< otb::Wrapper::OutputImageParameter* >( param ); // emit the output image filename selected if( outputParam!=NULL ) { QFileInfo fileInfo( outputParam->GetFileName() ); /* U N S A F E // BUGFIX: Mantis-750 // // If output image-exists, it's sure that it has been output // from the OTB-application process because overwritten // files are first deleted (see OnExecButtonClicked()). if( fileInfo.exists() ) { */ ++ count; emit OTBApplicationOutputImageChanged( QString( otbApp->GetName() ), QFile::decodeName( outputParam->GetFileName() ) ); /* } */ } } } emit ExecutionDone( status ); } } } OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdQuicklookViewManipulator.cxx000066400000000000000000000154451301006202600315130ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdQuicklookViewManipulator.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdQuicklookViewRenderer.h" namespace mvd { /* TRANSLATOR mvd::QuicklookViewManipulator Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ #if USE_VIEW_SETTINGS_SIDE_EFFECT QuicklookViewManipulator ::QuicklookViewManipulator( const otb::ViewSettings::Pointer& viewSettings, QObject* p ) : ImageViewManipulator( viewSettings, p ), m_RoiOrigin(), m_RoiSpacing(), m_RoiSize() { m_RoiOrigin.Fill( 0 ); m_RoiSpacing.Fill( 0 ); m_RoiSize.Fill( 0 ); } #else // USE_VIEW_SETTINGS_SIDE_EFFECT QuicklookViewManipulator ::QuicklookViewManipulator( QObject* p ) : ImageViewManipulator( p ), m_RoiOrigin(), m_RoiSpacing(), m_RoiSize() { m_RoiOrigin.Fill( 0 ); m_RoiSpacing.Fill( 0 ); m_RoiSize.Fill( 0 ); } #endif // USE_VIEW_SETTINGS_SIDE_EFFECT /*****************************************************************************/ QuicklookViewManipulator ::~QuicklookViewManipulator() { } /******************************************************************************/ void QuicklookViewManipulator ::SetupRenderingContext( AbstractImageViewRenderer::RenderingContext * const c ) const { assert( c==dynamic_cast< QuicklookViewRenderer::RenderingContext const * >( c ) ); QuicklookViewRenderer::RenderingContext * const context = dynamic_cast< QuicklookViewRenderer::RenderingContext * const >( c ); // Coverity-19843. // { assert( context!=NULL ); // } context->m_RoiOrigin = m_RoiOrigin; context->m_RoiExtent = m_RoiOrigin; context->m_RoiExtent[ 0 ] += static_cast< double >( m_RoiSize[ 0 ] ) * m_RoiSpacing[ 0 ]; context->m_RoiExtent[ 1 ] += static_cast< double >( m_RoiSize[ 1 ] ) * m_RoiSpacing[ 1 ]; #if USE_VIEW_SETTINGS_SIDE_EFFECT #else // USE_VIEW_SETTINGS_SIDE_EFFECT #endif // USE_VIEW_SETTINGS_SIDE_EFFECT } /******************************************************************************/ void QuicklookViewManipulator ::MousePressEvent( QMouseEvent* e ) { ImageViewManipulator::MousePressEvent( e ); assert( e!=NULL ); // qDebug() << this << ":" << e; Qt::MouseButtons buttons = e->buttons(); Qt::KeyboardModifiers modifiers = e->modifiers(); if( buttons==Qt::LeftButton && modifiers==Qt::NoModifier ) { assert( !m_ViewSettings.IsNull() ); PointType center; m_ViewSettings->ScreenToViewPortTransform( static_cast< double >( m_MousePressPosition.x() ), static_cast< double >( m_MousePressPosition.y() ), center[ 0 ], center[ 1 ] ); emit CenterRoiRequested( center ); } } /******************************************************************************/ void QuicklookViewManipulator ::MouseMoveEvent( QMouseEvent* e) { assert( e!=NULL ); // qDebug() << this << ":" << e; Qt::MouseButtons buttons = e->buttons(); Qt::KeyboardModifiers modifiers = e->modifiers(); if( buttons==Qt::LeftButton && modifiers==Qt::NoModifier ) { assert( !m_ViewSettings.IsNull() ); PointType center; m_ViewSettings->ScreenToViewPortTransform( static_cast< double >( m_MousePressPosition.x() ), static_cast< double >( m_MousePressPosition.y() ), center[ 0 ], center[ 1 ] ); m_MousePressPosition = e->pos(); emit CenterRoiRequested( center ); } } /******************************************************************************/ /* void QuicklookViewManipulator ::MouseReleaseEvent( QMouseEvent* e) { assert( e!=NULL ); // qDebug() << this << ":" << e; } */ /******************************************************************************/ void QuicklookViewManipulator ::ResizeEvent( QResizeEvent* e ) { ImageViewManipulator::ResizeEvent( e ); emit ZoomToExtentRequested(); } /******************************************************************************/ void QuicklookViewManipulator ::WheelEvent( QWheelEvent * ) { } /******************************************************************************/ void QuicklookViewManipulator ::KeyPressEvent( QKeyEvent * ) { } /******************************************************************************/ void QuicklookViewManipulator ::KeyReleaseEvent( QKeyEvent * ) { } /*****************************************************************************/ ZoomType QuicklookViewManipulator ::GetFixedZoomType() const { return ZOOM_TYPE_EXTENT; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void QuicklookViewManipulator ::OnRoiChanged( const PointType & origin, const SizeType & size, const SpacingType & spacing, const PointType & ) { /* qDebug() << this << ":OnRoiChanged()"; qDebug() << "origin :" << origin[ 0 ] << "," << origin[ 1 ]; qDebug() << "size :" << size[ 0 ] << "," << size[ 1 ]; qDebug() << "spacing:" << spacing[ 0 ] << "," << spacing[ 1 ]; */ m_RoiOrigin = origin; m_RoiSize = size; m_RoiSpacing = spacing; emit RefreshViewRequested(); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdQuicklookViewRenderer.cxx000066400000000000000000000132141301006202600307560ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdQuicklookViewRenderer.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. #include // // System includes (sorted by alphabetic order) // necessary for the opengl variables and methods // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) #include "otbGlImageActor.h" // // Monteverdi includes (sorted by alphabetic order) #include "mvdStackedLayerModel.h" #include "mvdTypes.h" #include "mvdVectorImageModel.h" namespace mvd { /* TRANSLATOR mvd::QuicklookViewRenderer Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ QuicklookViewRenderer ::QuicklookViewRenderer( QObject* p ) : ImageViewRenderer( p ), m_GlRoiActor( otb::GlROIActor::New() ) { assert( !m_GlRoiActor.IsNull() ); setObjectName( "QuicklookViewRenderer" ); m_EffectsEnabled = false; } /*****************************************************************************/ QuicklookViewRenderer ::~QuicklookViewRenderer() { } /*****************************************************************************/ AbstractImageViewRenderer::RenderingContext* QuicklookViewRenderer ::NewRenderingContext() const { RenderingContext* context = new QuicklookViewRenderer::RenderingContext(); #if USE_VIEW_SETTINGS_SIDE_EFFECT #else assert( !m_GlView.IsNull() ); // // Share otb::GlViewRendering settings with manipulator using // RenderingContext. Manipulator can then setup otb::ViewSettings // directly by side-effect. context->m_ViewSettings = m_GlView->GetSettings(); #endif return context; } /*******************************************************************************/ void QuicklookViewRenderer ::virtual_SetProjection() { SetWktAndKwl(); } /*******************************************************************************/ void QuicklookViewRenderer ::virtual_UpdateProjection() { SetWktAndKwl(); } /*******************************************************************************/ void QuicklookViewRenderer ::SetWktAndKwl() { // qDebug() << this << "::SetWktAndKwl()"; #if DISABLE_QUICKLOOK_VIEW return; #endif assert( GetLayerStack()!=NULL ); if( GetLayerStack()->IsEmpty() ) return; otb::GlImageActor::Pointer referenceGlImageActor( GetReferenceActor< otb::GlImageActor >() ); assert( !referenceGlImageActor.IsNull() ); m_GlRoiActor->SetKwl( referenceGlImageActor->GetKwl() ); m_GlRoiActor->SetWkt( referenceGlImageActor->GetWkt() ); } /*******************************************************************************/ void QuicklookViewRenderer ::virtual_FinishScene() { // qDebug() << this << "::virtual_FinishScene()"; assert( !m_GlView.IsNull() ); #if DISABLE_QUICKLOOK_VIEW return; #endif std::string key( m_GlView->AddActor( m_GlRoiActor, "ROI" ) ); m_GlRoiActor->SetVisible( true ); m_GlRoiActor->SetOverlay( true ); // qDebug() << "Added roi-actor:" << FromStdString( key ); /* ColorType color; color.Fill( 1.0 ); m_GlRoiActor->SetColor( color ); */ m_GlRoiActor->SetFill( false ); m_GlRoiActor->SetAlpha( 0.2 ); m_GlView->MoveActorToEndOfRenderingOrder( key, true ); } /*****************************************************************************/ void QuicklookViewRenderer ::UpdateActors( const AbstractImageViewRenderer::RenderingContext* c ) { // qDebug() << this << "::UpdateActors()"; assert( c!=NULL ); ImageViewRenderer::UpdateActors( c ); assert( c==dynamic_cast< const QuicklookViewRenderer::RenderingContext * >( c ) ); const QuicklookViewRenderer::RenderingContext * context = dynamic_cast< const QuicklookViewRenderer::RenderingContext * >( c ); // Coverity-19842 // { assert( context!=NULL ); // } /* qDebug() << "ROI-origin:" << context->m_RoiOrigin[ 0 ] << "," << context->m_RoiOrigin[ 1 ] << "ROI-extent:" << context->m_RoiExtent[ 0 ] << "," << context->m_RoiExtent[ 1 ]; */ m_GlRoiActor->SetUL( context->m_RoiOrigin ); m_GlRoiActor->SetLR( context->m_RoiExtent ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdSearchableTreeWidget.cxx000066400000000000000000000057741301006202600305240ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdSearchableTreeWidget.h" #include "ui_mvdSearchableTreeWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #define ENABLE_DISPLAY_ID 1 namespace mvd { /* TRANSLATOR mvd::SearchableTreeWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ SearchableTreeWidget ::SearchableTreeWidget( QWidget* p, Qt::WindowFlags flags ) : QWidget( p, flags ), m_UI( new mvd::Ui::SearchableTreeWidget() ) { m_UI->setupUi( this ); SetupUI(); } /*******************************************************************************/ SearchableTreeWidget ::~SearchableTreeWidget() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ void SearchableTreeWidget ::SetupUI() { } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ /* void SearchableTreeWidget ::on_treeWidget_currentItemChanged( QTreeWidgetItem* current, QTreeWidgetItem* previous ) { } */ /*******************************************************************************/ /* void SearchableTreeWidget ::on_searchLine_textChanged( const QString& text ) { } */ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdSearchableTreeWidget.ui000066400000000000000000000025401301006202600303230ustar00rootroot00000000000000 mvd::SearchableTreeWidget 0 0 262 116 0 0 Form 3 2 QAbstractItemView::SingleSelection QAbstractItemView::SelectRows OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdShaderWidget.cxx000066400000000000000000000161201301006202600270440ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdShaderWidget.h" #include "ui_mvdShaderWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdImageSettings.h" #include "mvdGui.h" namespace mvd { /* TRANSLATOR mvd::ShaderWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ ShaderWidget ::ShaderWidget( QWidget * p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::ShaderWidget() ) { m_UI->setupUi( this ); assert( qApp!=NULL ); AddItemsInto( m_UI->effectComboBox, "mvd", EFFECT_NAMES, EFFECT_COUNT ); m_UI->valueLineEdit->setValidator( new QDoubleValidator( m_UI->valueLineEdit ) ); } /*******************************************************************************/ ShaderWidget ::~ShaderWidget() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ void ShaderWidget ::SetGLSLEnabled( bool isGLSLEnabled ) { setEnabled( isGLSLEnabled ); if( !isGLSLEnabled ) { typedef QList< QWidget * > WidgetList; WidgetList childrenList( findChildren< QWidget * >() ); for( WidgetList::iterator it( childrenList.begin() ); it!=childrenList.end(); ++ it ) ( *it )->setToolTip( tr( "Rendering effects have been disabled because OpenGL Shading Language minimal requirements have not been met while running on this system." ) ); } } /*******************************************************************************/ void ShaderWidget ::SetGLSL140Enabled( bool isGLSLEnabled ) { assert( qApp!=NULL ); int index = m_UI->effectComboBox->findText( qApp->translate( "mvd", EFFECT_NAMES[ EFFECT_GRADIENT ] ) ); if( isGLSLEnabled ) { if( index<0 ) m_UI->effectComboBox->addItem( tr( "mvd", EFFECT_NAMES[ EFFECT_GRADIENT ] ) ); } else if( index>=0 ) m_UI->effectComboBox->removeItem( index ); } /*******************************************************************************/ void ShaderWidget ::virtual_SetSettings( ImageSettings * settings ) { assert( m_UI!=NULL ); m_UI->effectComboBox->setEnabled( settings!=NULL ); m_UI->sizeLabel->setEnabled( settings!=NULL ); m_UI->sizeSpinBox->setEnabled( settings!=NULL && settings->HasSize() ); m_UI->valueLabel->setEnabled( settings!=NULL ); m_UI->valueLineEdit->setEnabled( settings!=NULL && settings->HasValue() ); if( settings!=NULL ) { assert( qApp!=NULL ); for( int i=0; ieffectComboBox->count(); ++i ) if( m_UI->effectComboBox->itemText( i ) .compare( qApp->translate( "mvd", EFFECT_NAMES[ settings->GetEffect() ] ) )==0 ) { m_UI->effectComboBox->setCurrentIndex( i ); break; } m_UI->sizeSpinBox->setValue( settings->GetSize() ); char const * const text = settings->GetValueName(); if( text==NULL ) { m_UI->valueLabel->setVisible( false ); m_UI->valueLabel->setText( QString() ); } else { m_UI->valueLabel->setVisible( true ); m_UI->valueLabel->setText( QString( text ).append( ":" ) ); } m_UI->valueLineEdit->setVisible( text!=NULL ); m_UI->valueLineEdit->setText( settings->HasValue() ? QString::number( settings->GetValue(), 'g', std::numeric_limits< double >::digits10 ) // ToQString( settings->GetValue() ) : QString() ); m_UI->valueLineEdit->setCursorPosition( 0 ); } } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void ShaderWidget ::on_effectComboBox_currentIndexChanged( const QString & text ) { if( !HasSettings() ) return; assert( qApp!=NULL ); for( int i=0; itranslate( "mvd", EFFECT_NAMES[ i ] ) )==0 ) { ImageSettings * settings = GetSettings(); assert( settings!=NULL ); settings->SetEffect( static_cast< Effect >( i ) ); m_UI->sizeSpinBox->setEnabled( GetSettings()->HasSize() ); m_UI->valueLineEdit->setEnabled( GetSettings()->HasValue() ); m_UI->sizeSpinBox->setValue( settings->GetSize() ); char const * const textName = settings->GetValueName(); if( textName==NULL ) { m_UI->valueLabel->setVisible( false ); m_UI->valueLabel->setText( QString() ); } else { m_UI->valueLabel->setVisible( true ); m_UI->valueLabel->setText( QString( textName ).append( ":" ) ); } m_UI->valueLineEdit->setVisible( textName!=NULL ); m_UI->valueLineEdit->setText( settings->HasValue() ? ToQString( settings->GetValue() ) : QString() ); emit SettingsChanged(); return; } } /*******************************************************************************/ void ShaderWidget ::on_sizeSpinBox_valueChanged( int value ) { if( !HasSettings() ) return; GetSettings()->SetSize( value ); emit SettingsChanged(); } /*******************************************************************************/ void ShaderWidget ::on_valueLineEdit_editingFinished() { if( !HasSettings() || !GetSettings()->HasValue() ) return; bool isOk = true; assert( m_UI!=NULL ); assert( m_UI->valueLineEdit!=NULL ); GetSettings()->SetValue( m_UI->valueLineEdit->text().toDouble( &isOk ) ); // assert( isOk ); if( !isOk ) return; emit SettingsChanged(); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdShaderWidget.ui000066400000000000000000000053401301006202600266610ustar00rootroot00000000000000 mvd::ShaderWidget 0 0 278 29 Form 3 1 false Select effect to apply to selected layer. QComboBox::InsertAlphabetically false 0 0 Size: false Edit effect-brush size. 1000000000 16 false 0 0 Value: false 0 0 Edit effect-parameter value. OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdStatusBarWidget.cxx000066400000000000000000000161221301006202600275500ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdStatusBarWidget.h" #include "ui_mvdStatusBarWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::StatusBarWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ StatusBarWidget ::StatusBarWidget( QWidget* p, Qt::WindowFlags flags ): QWidget( p, flags ), m_UI( new mvd::Ui::StatusBarWidget() ) { m_UI->setupUi( this ); } /*****************************************************************************/ StatusBarWidget ::~StatusBarWidget() { delete m_UI; m_UI = NULL; } /*****************************************************************************/ QString StatusBarWidget ::ZoomLevel( double scale ) { if( scale>1.0 ) return QString( "%1:1" ).arg( scale ); else if( scale<1.0 ) return QString( "1:%1" ).arg( 1.0 / scale ); return "1:1"; } /*****************************************************************************/ void StatusBarWidget ::SetGLSLEnabled( bool enabled ) { m_UI->renderModelLabel->setText( enabled ? tr( "GLSL" ) : tr( "OpenGL" ) ); } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ void StatusBarWidget ::SetPixelIndex( const IndexType & pixel, bool isInsideRegion ) { assert( m_UI!=NULL ); assert( m_UI->pixelIndexLineEdit!=NULL ); m_UI->pixelIndexLineEdit->setText( isInsideRegion ? QString( "%1, %2" ).arg( pixel[ 0 ] ).arg( pixel[ 1 ] ) : QString() ); } /*****************************************************************************/ void StatusBarWidget ::SetScale( double sx, double ) { // qDebug() << this << "::SetScale(" << sx << "," << sy << ")"; /* if( sx!=sy ) zoomLevel.append( "/" + StatusBarWidget::ZoomLevel( sy ) ); */ m_UI->scaleLineEdit->setText( StatusBarWidget::ZoomLevel( sx ) ); } /*****************************************************************************/ /* PRIVATE SLOTS */ /*****************************************************************************/ /* void StatusBarWidget ::SetPixelIndexText( const QString& text ) { m_UI->pixelIndexLineEdit->setText( text ); } */ /*****************************************************************************/ void StatusBarWidget ::SetText( const QString & text ) { assert( m_UI!=NULL ); assert( m_UI->pixelIndexLineEdit!=NULL ); m_UI->pixelRadiometryLabel->setText( text ); } /*****************************************************************************/ void StatusBarWidget ::on_pixelIndexLineEdit_returnPressed() { // // Cancel if pixel-index coordinates text is empty. if( m_UI->pixelIndexLineEdit->text().isEmpty() ) return; // // Split coordinates. QStringList coordinates( m_UI->pixelIndexLineEdit->text().split( ',' ) ); // // Check split coordinates format. assert( coordinates.size()==1 || coordinates.size()==2 ); if( coordinates.size()!=1 && coordinates.size()!=2 ) return; // // Construct resulting pixel-index. IndexType index; index.Fill( 0 ); // // Convert first pixel-index coordinate. bool isOk = true; index[ 0 ] = coordinates.front().toUInt( &isOk ); // assert( isOk ); if( !isOk ) return; // // Convert second pixel-index coordinate. if( coordinates.size()>1 ) { index[ 1 ] = coordinates.back().toUInt( &isOk ); // assert( isOk ); if( !isOk ) return; } // // If both pixel-index coordinates have correctly been converted, // emit pixel-index changed signal. emit PixelIndexChanged( index ); } /*****************************************************************************/ void StatusBarWidget ::on_scaleLineEdit_editingFinished() { // // Cancel if scale text is empty. if( m_UI->scaleLineEdit->text().isEmpty() ) return; // // Split scale text. QStringList scale( m_UI->scaleLineEdit->text().split( ':' ) ); // // Check scale text format. // assert( scale.size()==1 || scale.size()==2 ); if( scale.size()!=1 && scale.size()!=2 ) return; /* if( scale.size()!=1 && scale.size()!=2 ) { throw std::invalid_argument( ToStdString( tr( "Invalid argument: '%1' should be scale of the form [:] with numerator and denominator being real numbers." ) ) ); } */ // // Convert scale numerator. bool isOk = true; double numerator = scale.front().toDouble( &isOk ); // assert( isOk ); // assert( numerator!=0.0 ); if( !isOk || numerator==0.0 ) return; /* if( !isOk ) { throw std::invalid_argument( ToStdString( tr( "Invalid argument: '%1' should be scale of the form [:] with numerator and denominator being real numbers." ) ) ); } */ // // Convert scale denominator. double denominator = 1.0; if( scale.size()>1 ) { denominator = scale.back().toDouble( &isOk ); // assert( isOk ); if( !isOk ) return; /* if( !isOk ) { throw std::invalid_argument( ToStdString( tr( "Invalid argument: '%1' should be scale of the form [:] with numerator and denominator being real numbers." ) ) ); } */ } // // Emit scale changed. emit ScaleChanged( numerator / denominator ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdStatusBarWidget.ui000066400000000000000000000111471301006202600273650ustar00rootroot00000000000000 mvd::StatusBarWidget 0 0 628 20 0 0 Ice rendering mode (OpenGL texture or GLSL if using OpenGL Shading Language) 0 QLayout::SetMinimumSize 0 16777215 20 Position 0 0 100 20 Qt::AlignCenter 16777215 20 Qt::Vertical 200 0 16777215 20 Radiometry 16777215 20 Qt::Horizontal 40 20 16777215 20 Qt::Vertical 16777215 20 Zoom Level 0 0 150 20 Current zoom-level of view, relative to reference layer (projection and spacing). Qt::AlignCenter Qt::Vertical GLSL Qt::AlignCenter OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdTaskProgressDialog.cxx000066400000000000000000000133501301006202600302430ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdTaskProgressDialog.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAbstractWorker.h" #include "mvdBackgroundTask.h" namespace mvd { /* TRANSLATOR mvd::TaskProgressDialog Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ TaskProgressDialog ::TaskProgressDialog( BackgroundTask* task, QWidget* p, Qt::WindowFlags flags ): QProgressDialog( p, flags ), m_BackgroundTask( task ), m_Object( NULL ), m_Exception() { // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // Do not take ownership of background-task to leave display // independent of execution of background-tas. // // m_BackgroundTask->setParent( this ); QObject::connect( task->GetWorker(), SIGNAL( ProgressTextChanged( const QString& ) ), // to: this, SLOT( setLabelText( const QString& ) ) ); QObject::connect( task->GetWorker(), SIGNAL( ProgressValueChanged( int ) ), // to: this, SLOT( setValue( int ) ) ); QObject::connect( task->GetWorker(), SIGNAL( ProgressRangeChanged( int, int ) ), // to: this, SLOT( setRange( int, int ) ) ); QObject::connect( task->GetWorker(), SIGNAL( Done( QObject* ) ), // to: this, SLOT( OnDone( QObject* ) ) ); QObject::connect( task->GetWorker(), SIGNAL( ExceptionRaised( QString ) ), // to: this, SLOT( OnExceptionRaised( QString ) ) ); // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // Accept progress-dialog when thread has been signaled as // finished() and not when worker object has done or finished it's // job (while the thread is still running when Done() or Finished() // is signalled). QObject::connect( task, SIGNAL( finished() ), // to: this, SLOT( accept() ) ); // Keep informed When some object is destroyed. QObject::connect( m_BackgroundTask, SIGNAL( destroyed( QObject* ) ), // to: this, SLOT( OnObjectDestroyed( QObject* ) ) ); } /*******************************************************************************/ TaskProgressDialog ::~TaskProgressDialog() { // qDebug() << this << "is being destroyed."; // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // Trace (for debugging purposes) if background-task thread is still // running when destroying this dialog. #if ( defined( OTB_DEBUG ) && 1 ) || 0 if( m_BackgroundTask!=NULL && m_BackgroundTask->isRunning() ) { qDebug() << m_BackgroundTask << "is still running!"; } #endif // qDebug() << this << "has been destroyed."; } /*****************************************************************************/ int TaskProgressDialog ::Exec() { m_BackgroundTask->start(); setLabelText( m_BackgroundTask->GetWorker()->GetFirstProgressText() ); return exec(); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ void TaskProgressDialog ::OnDone( QObject* res ) { m_Object = res; // MANTIS-921 (http://bugs.orfeo-toolbox.org/view.php?id=921). // // Accept is slotted to QThread finished() signal for correct thread // synchronization. // // accept(); } /*******************************************************************************/ void TaskProgressDialog ::OnExceptionRaised( QString what ) { QMessageBox::warning( this->parentWidget(), tr( "%1 - Warning!" ).arg( PROJECT_NAME ), what ); reject(); } /*******************************************************************************/ void TaskProgressDialog ::OnObjectDestroyed( QObject* object ) { // qDebug() << this << "::OnObjectDestryed(" << object << ")"; assert( object==m_BackgroundTask ); if( object==m_BackgroundTask ) { // qDebug() << this << "forgetting" << m_BackgroundTask; // Forget background-task. m_BackgroundTask = NULL; // Accept QDialog te prevent locking the UI. accept(); } } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdTreeWidget.cxx000066400000000000000000000323341301006202600265420ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdTreeWidget.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdAlgorithm.h" #include "mvdDataStream.h" #include "mvdTreeWidgetItem.h" namespace mvd { /* TRANSLATOR mvd::TreeWidget Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ const char* TreeWidget ::ITEM_MIME_TYPE = "application/x-qtreewidgetitemptrlist"; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ #if USE_CUSTOM_MIME_DATA class StaticInitializer { public: StaticInitializer() : m_QTreeWidgetItemPtrMetaTypeId( -1 ) { Initialize(); } ~StaticInitializer() { Finalize(); } private: inline void Initialize() { // // Call qRegisterMetaType<>() to make type available in // non-template signatures and serialization. m_QTreeWidgetItemPtrMetaTypeId = qRegisterMetaType< QTreeWidgetItem* >( "QTreeWidgetItem*" ); // // Register serialization operators for custom meta-types. #if QT_VERSION >= QT_VERSION_CHECK( 4, 7, 0 ) qRegisterMetaTypeStreamOperators< QTreeWidgetItem* >(); #else // QT_VERSION >= QT_VERSION_CHECK( 4, 7, 0 ) qRegisterMetaTypeStreamOperators< QTreeWidgetItem* >( QMetaType::typeName( m_QTreeWidgetItemPtrMetaTypeId ) ); #endif // QT_VERSION >= QT_VERSION_CHECK( 4, 7, 0 ) } inline void Finalize() { } int m_QTreeWidgetItemPtrMetaTypeId; }; namespace { static const StaticInitializer STATIC_INITIALIZER; } #endif // USE_CUSTOM_MIME_DATA /*****************************************************************************/ QMimeData* EncodeMimeData( QMimeData* mimeData, const QList< QTreeWidgetItem* >& items ) { #if USE_CUSTOM_MIME_DATA assert( mimeData!=NULL ); typedef QList< QTreeWidgetItem* > QTreeWidgetItemList; QByteArray byteArray; QDataStream stream( &byteArray, QIODevice::WriteOnly ); for( QTreeWidgetItemList::const_iterator it( items.begin() ); it!=items.end(); ++it ) { /* qDebug() << "QTreeWidgetItem::parent()==" << ( *it )->parent(); qDebug() << "Pointer:" << static_cast< void* >( *it ); qDebug() << "Variant:" << QVariant::fromValue< QTreeWidgetItem* >( *it ); */ #if 1 QTreeWidgetItem * item = *it; qDebug() << "Item (encoded):" << item << "\n" << "text[ 0 ]:" << item->text( 0 ) << "\n" << "text[ 1 ]:" << item->text( 1 ) << "\n" << "text[ 2 ]:" << item->text( 2 ); if( item->parent()!=NULL ) { qDebug() << "parent:" << item->parent() << "\n" << "text[ 0 ]:" << item->parent()->text( 0 ) << "\n" << "text[ 1 ]:" << item->parent()->text( 1 ); } #endif // http://www.qtfr.org/viewtopic.php?id=9630 // stream << *it; stream << QVariant::fromValue< QTreeWidgetItem* >( *it ); } mimeData->setData( TreeWidget::ITEM_MIME_TYPE, byteArray ); /* qDebug() << mimeData->formats(); for( QTreeWidgetItemList::const_iterator it( items.begin() ); it!=items.end(); ++it ) { QTreeWidgetItem* item = *it; qDebug() << item->type() << item->text( 0 ) << item->text( 1 ) << item->text( 2 ); } */ #endif // USE_CUSTOM_MIME_DATA return mimeData; } /*****************************************************************************/ int DecodeMimeData( QList< QTreeWidgetItem* >& items, const QMimeData* mimeData ) { assert( mimeData!=NULL ); int count = 0; #if USE_CUSTOM_MIME_DATA if( !mimeData->hasFormat( TreeWidget::ITEM_MIME_TYPE ) ) return 0; QByteArray byteArray( mimeData->data( TreeWidget::ITEM_MIME_TYPE ) ); QDataStream stream( &byteArray, QIODevice::ReadOnly ); // // http://www.qtcentre.org/threads/8756-QTreeWidgetItem-mime-type QTreeWidgetItem* item = NULL; while( !stream.atEnd() ) { QVariant variant; stream >> variant; // qDebug() << "Variant:" << variant; // http://www.qtfr.org/viewtopic.php?id=9630 item = variant.value< QTreeWidgetItem* >(); assert( item!=NULL ); items.push_back( item ); #if 1 qDebug() << "Item (decoded):" << item << "\n" << "text[ 0 ]:" << item->text( 0 ) << "\n" << "text[ 1 ]:" << item->text( 1 ) << "\n" << "text[ 2 ]:" << item->text( 2 ); if( item->parent()!=NULL ) { qDebug() << "parent:" << item->parent() << "\n" << "text[ 0 ]:" << item->parent()->text( 0 ) << "\n" << "text[ 1 ]:" << item->parent()->text( 1 ); } #endif ++ count; } // qDebug() << count2 << "items."; #else // USE_CUSTOM_MIME_DATA /* if( !mimeData->hasFormat( "application/x-qabstractitemmodeldatalist" ) ) return 0; QByteArray byteArray( mimeData->data( "application/x-qabstractitemmodeldatalist" ) ); QDataStream stream( &byteArray, QIODevice::ReadOnly ); // // http://www.qtcentre.org/threads/8756-QTreeWidgetItem-mime-type QTreeWidgetItem* item = NULL; while( !stream.atEnd() ) { ++ count; } */ #endif // USE_CUSTOM_MIME_DATA return count; } /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ TreeWidget ::TreeWidget( QWidget* p ): QTreeWidget( p ) { setSelectionBehavior( QAbstractItemView::SelectRows ); // MANTIS-929: Leave default behaviour // // setDefaultDropAction( Qt::MoveAction ); // setDefaultDropAction( Qt::CopyAction ); // setDefaultDropAction( Qt::LinkAction ); // MANTIS-929: Setting inspired from QGis; don't understand why // there is one call with InternalMode and another with DragDrop but // think it might change setting drag-enabled and accept-drop // behaviour. // setDragDropMode( QAbstractItemView::InternalMove ); setDragEnabled( true ); setAcceptDrops( true ); setDragDropMode( QAbstractItemView::DragDrop ); } /*******************************************************************************/ TreeWidget ::~TreeWidget() { } /*******************************************************************************/ QStringList TreeWidget ::mimeTypes() const { // qDebug() << this << "::mimeTypes()"; QStringList mTypes( QTreeWidget::mimeTypes() ); #if USE_CUSTOM_MIME_DATA mTypes << TreeWidget::ITEM_MIME_TYPE; #endif // USE_CUSTOM_MIME_DATA return mTypes; } /*******************************************************************************/ QMimeData* TreeWidget ::mimeData( const QList< QTreeWidgetItem* > itemList ) const { // qDebug() << this << "::mimeData(" << itemList << ")"; return EncodeMimeData( QTreeWidget::mimeData( itemList ), itemList ); } /*******************************************************************************/ Qt::DropActions TreeWidget ::supportedDropActions() const { // This method is overloaded only to spy/debug Qt behavior. Qt::DropActions supportedActions = QTreeWidget::supportedDropActions(); qDebug() << this << "::supportedDropActions():" << supportedActions; return supportedActions; } /*******************************************************************************/ void TreeWidget ::startDrag( Qt::DropActions supportedActions ) { // This method is overloaded only to spy/debug Qt behavior. qDebug() << this << "::startDrag(" << supportedActions << ")"; QTreeWidget::startDrag( supportedActions ); } /*******************************************************************************/ void TreeWidget ::dragEnterEvent( QDragEnterEvent* e ) { qDebug() << this << "::dragEnterEvent(" << e << ")"; // e->acceptProposedAction(); QTreeWidget::dragEnterEvent( e ); } /*******************************************************************************/ void TreeWidget ::dragMoveEvent( QDragMoveEvent* e ) { assert( e!=NULL ); qDebug() << this << "::dragMoveEvent(" << e << ")"; qDebug() << this << itemAt( e->pos() ); QTreeWidget::dragMoveEvent( e ); QTreeWidgetItem* item = itemAt( e->pos() ); // const QMimeData * mimeData = e->mimeData(); #if USE_CUSTOM_MIME_DATA if( e->mimeData()->hasFormat( TreeWidget::ITEM_MIME_TYPE ) && item!=NULL ) #else // USE_CUSTOM_MIME_DATA if( item!=NULL ) #endif // USE_CUSTOM_MIME_DATA { qDebug() << "ACCEPT"; e->accept(); } else { qDebug() << "IGNORE"; e->ignore(); } /* if( e->source()==this ) { e->setDropAction( Qt::MoveAction ); e->accept(); } */ /* if( itemAt( e->pos() )==NULL ) e->ignore(); else e->accept(); */ } /*******************************************************************************/ void TreeWidget ::dragLeaveEvent( QDragLeaveEvent* e ) { qDebug() << this << "::dragLeaveEvent(" << e << ")"; QTreeWidget::dragLeaveEvent( e ); } /*******************************************************************************/ void TreeWidget ::dropEvent( QDropEvent* e ) { assert( e!=NULL ); // qDebug() << this << "::dropEvent(" << e << ")"; typedef QList< QTreeWidgetItem* > QTreeWidgetItemList; QTreeWidgetItemList itemList; DecodeMimeData( itemList, e->mimeData() ); if( e->source()==this ) { e->setDropAction( Qt::MoveAction ); // e->accept(); } qDebug() << "dropAction:" << e->dropAction(); QTreeWidget::dropEvent( e ); qDebug() << "dropAction:" << e->dropAction(); /* QTreeWidgetItem * item = itemAt( e->pos() ); while( !item->flags().testFlag( Qt::ItemIsDropEnabled ) ) { item = item->parent(); assert( item!=NULL ); #if 1 qDebug() << "Item (target):" << item << "\n" << "text[ 0 ]:" << item->text( 0 ) << "\n" << "text[ 1 ]:" << item->text( 1 ) << "\n" << "text[ 2 ]:" << item->text( 2 ) << "\n" << "parent:" << item->parent() << "\n" << "text[ 0 ]:" << item->parent()->text( 0 ) << "\n" << "text[ 1 ]:" << item->parent()->text( 1 ); #endif } */ /* for( QTreeWidgetItemList::const_iterator it = itemList.begin(); it!=itemList.end(); ++it ) { switch( e->dropAction() ) { case Qt::MoveAction: emit ItemMoved( *it, itemAt( e->pos() ) ); break; default: break; } } */ QTreeWidgetItem * target = itemAt( e->pos() ); qDebug() << "itemAt(" << e->pos() << "):" << target; if( e->source()==this ) for( QTreeWidgetItemList::const_iterator it = itemList.begin(); it!=itemList.end(); ++it ) emit ItemMoved( *it, target ); } /*******************************************************************************/ /* SLOTS */ /*******************************************************************************/ } // end namespace 'mvd' /*****************************************************************************/ /* GLOBAL FUNCTIONS IMPLEMENTATION SECTION */ #if USE_CUSTOM_MIME_DATA #if TREE_WIDGET_ITEM_USE_STREAM_OPERATORS /*****************************************************************************/ QDataStream& operator << ( QDataStream& out, QTreeWidgetItem const * item ) { /* qDebug() << "QDataStream& operator << ( QDataStream&, QTreeWidgetItem const * & );"; */ #if DATA_STREAM_USE_TEMPLATE_OPERATORS return operator << < QTreeWidgetItem >( out, item ); #else // DATA_STREAM_USE_TEMPLATE_OPERATORS DATA_STREAM_OUT( out, QTreeWidgetItem, item ); return out; #endif // DATA_STREAM_USE_TEMPLATE_OPERATORS } /*****************************************************************************/ QDataStream& operator >>( QDataStream& in, QTreeWidgetItem * & item ) { /* qDebug() << "QDataStream& operator >> ( QDataStream&, QTreeWidgetItem * & );"; */ #if DATA_STREAM_USE_TEMPLATE_OPERATORS return operator >> < QTreeWidgetItem >( in, item ); #else // DATA_STREAM_USE_TEMPLATE_OPERATORS DATA_STREAM_IN( in, QTreeWidgetItem, item ); return in; #endif // DATA_STREAM_USE_TEMPLATE_OPERATORS } #endif // TREE_WIDGET_ITEM_USE_STREAM_OPERATORS #endif // USE_CUSTOM_MIME_DATA OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdTreeWidgetItem.cxx000066400000000000000000000114171301006202600273600ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdTreeWidgetItem.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) namespace mvd { /* TRANSLATOR mvd::TreeWidgetItem Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ namespace { int count = 0; } /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*******************************************************************************/ // MANTIS-947: Workaround for QTreeWidget::itemAt() returning NULL for // last item of view after DatabaseBrowserController::UpdateTree() has // been called subsequent to insert new group. // // This workaround reverts the order of insertion of NODE items so // that the last item is always at first index instead of last one. // // Side effect: This inverts the order for all QTreeWidget using // mvd::TreeWidgetItem, not only those in DatabaseBrowser view. #define BUG_WORKAROUND_MANTIS_947 1 TreeWidgetItem ::TreeWidgetItem( QTreeWidgetItem* p, const QString& txt, const QVariant& id, const QStringList& columns, TreeWidgetItem::ItemType itemType ) : #if BUG_WORKAROUND_MANTIS_947 QTreeWidgetItem( QStringList( txt ) << QString() << columns, itemType ) #else // BUG_WORKAROUND_MANTIS_947 QTreeWidgetItem( p, QStringList( txt ) << QString() << columns, itemType ) #endif // BUG_WORKAROUND_MANTIS_947 { assert( p!=NULL ); // parent->addChild( this ); SetId( id ); switch( itemType ) { case TreeWidgetItem::ITEM_TYPE_NODE: setChildIndicatorPolicy( QTreeWidgetItem::ShowIndicator ); setFlags( // Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsEditable | Qt::ItemIsEnabled ); #if BUG_WORKAROUND_MANTIS_947 p->insertChild( 0, this ); #endif // BUG_WORKAROUND_MANTIS_947 break; case TreeWidgetItem::ITEM_TYPE_LEAF: setChildIndicatorPolicy( QTreeWidgetItem::DontShowIndicator ); setFlags( Qt::ItemIsDragEnabled | Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable ); #if BUG_WORKAROUND_MANTIS_947 p->addChild( this ); #endif // BUG_WORKAROUND_MANTIS_947 break; default: assert( false ); break; } /* qDebug() << "NEW Item:" << count << "\n" << "type:" << GetType() << "\n" << "id:" << GetId() << "\n" << "text:" << GetText() << "\n" << "hash:" << this->text( 2 ) << "\n" << "parent:" << this->parent() << "\n" << "text[ 0 ]:" << parent->text( 0 ); */ ++ count; qDebug() << "Item count:" << count; } /*******************************************************************************/ TreeWidgetItem ::~TreeWidgetItem() { /* qDebug() << "DELETE Item:" << "\n" << "type:" << GetType() << "\n" << "id:" << GetId() << "\n" << "text:" << GetText() << "\n" << "hash:" << text( 2 ) << "\n" << "parent:" << parent() << "\n" << "text[ 0 ]:" << (parent()==NULL ? "" : parent()->text( 0 )); */ -- count; qDebug() << "Item count:" << count; } /*******************************************************************************/ QTreeWidgetItem* TreeWidgetItem ::clone() const { qDebug() << this << "::clone()"; return new TreeWidgetItem( *this ); } } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdTreeWidgetItemDragAndDropEventFilter.cxx000066400000000000000000000102771301006202600336010ustar00rootroot00000000000000/*========================================================================= Program: Monteverdi Language: C++ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See Copyright.txt for details. Monteverdi is distributed under the CeCILL licence version 2. See Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt for more details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mvdTreeWidgetItemDragAndDropEventFilter.h" /*****************************************************************************/ /* INCLUDE SECTION */ // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) #include // // ITK includes (sorted by alphabetic order) // // OTB includes (sorted by alphabetic order) // // Monteverdi includes (sorted by alphabetic order) #include "mvdTreeWidget.h" namespace mvd { /* TRANSLATOR mvd::TreeWidgetItemDragAndDropEventFilter Necessary for lupdate to be aware of C++ namespaces. Context comment for translator. */ /*****************************************************************************/ /* CONSTANTS */ const char* TREE_WIDGET_ITEM_MIME_TYPE = "application/x-qtreewidgetitemptrlist"; /*****************************************************************************/ /* STATIC IMPLEMENTATION SECTION */ /*****************************************************************************/ /* CLASS IMPLEMENTATION SECTION */ /*****************************************************************************/ TreeWidgetItemDragAndDropEventFilter ::TreeWidgetItemDragAndDropEventFilter( QObject* p ) : AbstractDragAndDropEventFilter( p ) { } /*****************************************************************************/ TreeWidgetItemDragAndDropEventFilter ::~TreeWidgetItemDragAndDropEventFilter() { } /*****************************************************************************/ bool TreeWidgetItemDragAndDropEventFilter ::DragEnterEvent( QObject *, QDragEnterEvent* e ) { // // Bypass event its MIME data does not contain not URL(s). if( !e->mimeData()->hasFormat( TREE_WIDGET_ITEM_MIME_TYPE ) ) return false; // // Accept event if its MIME data contains some URL(s) and they are // all local filenames. e->acceptProposedAction(); // // Eatup event. return true; } /*****************************************************************************/ bool TreeWidgetItemDragAndDropEventFilter ::DragLeaveEvent( QObject *, QDragLeaveEvent * ) { // // Nothing to do: bypass event & let default behaviour occur. return false; } /*****************************************************************************/ bool TreeWidgetItemDragAndDropEventFilter ::DragMoveEvent( QObject *, QDragMoveEvent * ) { // // Nothing to do: bypass event & let default behaviour occur. return false; } /*****************************************************************************/ bool TreeWidgetItemDragAndDropEventFilter ::DropEvent( QObject *, QDropEvent * e ) { assert( e!=NULL ); assert( e->mimeData()!=NULL ); // // Decode MIME data. typedef QList< QTreeWidgetItem* > QTreeWidgetItemList; QTreeWidgetItemList items; int count = DecodeMimeData( items, e->mimeData() ); if( count==0 ) return false; // // Emit signals. for( QTreeWidgetItemList::const_iterator it = items.begin(); it!=items.end(); ++it ) { emit ItemDropped( *it ); } // // Eatup event. return true; } /*****************************************************************************/ /* SLOTS */ /*****************************************************************************/ } // end namespace 'mvd' OTB-release-5.8/Modules/Visualization/MonteverdiGui/src/mvdVideoColorToolBox.ui000066400000000000000000000032031301006202600276570ustar00rootroot00000000000000 mvd::VideoColorToolBox 0 0 152 133 Video color QFrame::NoFrame 0 0 0 152 79 Video color setup 0 0 152 79 Video color dynamics mvd::ColorSetupWidget QWidget
    mvdColorSetupWidget.h
    1     mvd::ColorDynamicsWidget QWidget
    mvdColorDynamicsWidget.h
    1     OTB-release-5.8/Modules/Visualization/MonteverdiGui/test/000077500000000000000000000000001301006202600234275ustar00rootroot00000000000000OTB-release-5.8/Modules/Visualization/MonteverdiGui/test/CMakeLists.txt000066400000000000000000000006271301006202600261740ustar00rootroot00000000000000otb_module_test() set(OTBMonteverdiGUITests mvdApplicationsBrowserTest.cxx mvdApplicationsToolBoxTest.cxx mvdFillToolBoxWidgetTreeTest.cxx mvdMonteverdiGuiTestDriver.cxx ) add_executable(mvdMonteverdiGuiTestDriver ${OTBMonteverdiGUITests}) target_link_libraries(mvdMonteverdiGuiTestDriver ${OTBMonteverdiGUI-Test_LIBRARIES}) otb_module_target_label(mvdMonteverdiGuiTestDriver) # Tests Declaration # TODO OTB-release-5.8/Modules/Visualization/MonteverdiGui/test/mvdApplicationsBrowserTest.cxx000066400000000000000000000025451301006202600315220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // Monteverdi includes (sorted by alphabetic order) #include "mvdApplicationsBrowser.h" int mvdApplicationsBrowserTest(int argc, char* argv[]) { // // instantiate applications browser mvd::ApplicationsBrowser * browser = new mvd::ApplicationsBrowser(); // // is search path set if (argc > 1) { browser->SetAutoLoadPath(argv[1]); } // // print available applications or exit with failure if ( browser->GetAvailableApplications().size() == 0 ) return EXIT_FAILURE; // return ok return EXIT_SUCCESS; } OTB-release-5.8/Modules/Visualization/MonteverdiGui/test/mvdApplicationsToolBoxTest.cxx000066400000000000000000000021761301006202600314650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // Monteverdi includes (sorted by alphabetic order) #include "mvdApplicationsToolBox.h" int mvdApplicationsToolBoxTest(int argc, char* argv[]) { QApplication app(argc, argv); mvd::ApplicationsToolBox applToolBox; applToolBox.show(); QTimer::singleShot(1000, &app, SLOT(quit())); return app.exec(); } OTB-release-5.8/Modules/Visualization/MonteverdiGui/test/mvdFillToolBoxWidgetTreeTest.cxx000066400000000000000000000047401301006202600317100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // // Configuration include. //// Included at first position before any other ones. #include "ConfigureMonteverdi.h" // // Qt includes (sorted by alphabetic order) //// Must be included before system/custom includes. // // System includes (sorted by alphabetic order) // Monteverdi includes (sorted by alphabetic order) #include "mvdApplicationsToolBox.h" #include "mvdApplicationsBrowser.h" #include "mvdApplicationLauncher.h" int mvdFillToolBoxWidgetTreeTest(int argc, char* argv[]) { // // instantiate the algorithms toolbox widget QApplication app(argc, argv); mvd::ApplicationsToolBox * appToolBox = new mvd::ApplicationsToolBox(); // // instantiate applications browser mvd::ApplicationsBrowser * browser = new mvd::ApplicationsBrowser(); // // connections QObject::connect(browser, SIGNAL( AvailableApplicationsTagsChanged(const ApplicationsTagContainer& ) ), appToolBox, SLOT( OnAvailableApplicationsTagsChanged(const ApplicationsTagContainer& ) ) ); // // is search path set if (argc > 1) { browser->SetAutoLoadPath(argv[1]); } // // get the tags/algs map container in the widget browser->SearchAvailableApplicationsTags(); // // instantiate Application launcher mvd::ApplicationLauncher * launcher = new mvd::ApplicationLauncher(); // // connections QObject::connect(appToolBox, SIGNAL( ApplicationToLaunchSelected(const QString& ) ), launcher, SLOT( OnApplicationToLaunchSelected(const QString& ) ) ); // add quit // QObject::connect(appToolBox, // SIGNAL( (const QString& ) ), // launcher, // SLOT( OnQuit() ) // ); // // show the application for a while appToolBox->show(); if ( argc <= 2 ) { QTimer::singleShot(1000, &app, SLOT(quit())); } return app.exec(); } OTB-release-5.8/Modules/Visualization/MonteverdiGui/test/mvdMonteverdiGuiTestDriver.cxx000066400000000000000000000017111301006202600314570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // this file defines the otbCommonTest for the test driver // and all it expects is that you have a function called RegisterTests #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include #include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(mvdApplicationsToolBoxTest); REGISTER_TEST(mvdApplicationsBrowserTest); REGISTER_TEST(mvdFillToolBoxWidgetTreeTest); } OTB-release-5.8/Modules/Wrappers/000077500000000000000000000000001301006202600166315ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/ApplicationEngine/000077500000000000000000000000001301006202600222225ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/ApplicationEngine/CMakeLists.txt000066400000000000000000000001521301006202600247600ustar00rootroot00000000000000project(OTBApplicationEngine) set(OTBApplicationEngine_LIBRARIES OTBApplicationEngine) otb_module_impl() OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/000077500000000000000000000000001301006202600236455ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperAddProcessToWatchEvent.h000066400000000000000000000042151301006202600324110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperAddProcessToWatchEvent_h #define otbWrapperAddProcessToWatchEvent_h #include "itkEventObject.h" #include "itkProcessObject.h" #include "OTBApplicationEngineExport.h" namespace otb { namespace Wrapper { /** \class AddProcessToWatchEvent * \brief This class implements an event storing a pointer to * itk::ProcessObject and a string describing the process. * * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT AddProcessToWatchEvent: public itk::EventObject { public: typedef AddProcessToWatchEvent Self; typedef itk::EventObject Superclass; AddProcessToWatchEvent(){} AddProcessToWatchEvent(const Self& s) :itk::EventObject(s){}; ~AddProcessToWatchEvent() ITK_OVERRIDE {} /** Set/Get the process to watch */ virtual void SetProcess(itk::ProcessObject * process) { m_Process = process; } virtual itk::ProcessObject * GetProcess() const { return m_Process; } /** Set/Get the process description */ virtual void SetProcessDescription(const std::string desc) { m_ProcessDescription = desc; } virtual std::string GetProcessDescription() const { return m_ProcessDescription; } /** Virtual pure method to implement */ itk::EventObject* MakeObject() const ITK_OVERRIDE { return new Self; } const char* GetEventName() const ITK_OVERRIDE { return "AddProcess"; } bool CheckEvent(const itk::EventObject* e) const ITK_OVERRIDE { return dynamic_cast(e); } private: itk::ProcessObject::Pointer m_Process; std::string m_ProcessDescription; }; } } #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplication.h000066400000000000000000000720661301006202600303420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperApplication_h #define otbWrapperApplication_h #include #include "otbWrapperTypes.h" #include "otbWrapperTags.h" #include "otbWrapperParameterGroup.h" #include "itkLogger.h" #include "otbWrapperMacros.h" #include "otbWrapperInputImageParameter.h" #include "otbWrapperInputImageListParameter.h" #include "otbWrapperOutputImageParameter.h" #include "otbWrapperComplexInputImageParameter.h" #include "otbWrapperComplexOutputImageParameter.h" #include "otbWrapperDocExampleStructure.h" #include "itkMersenneTwisterRandomVariateGenerator.h" #include "OTBApplicationEngineExport.h" namespace otb { namespace Wrapper { /** \class Application * \brief This class represent an application * TODO * * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT Application: public itk::Object { public: /** Standard class typedefs. */ typedef Application Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** RTTI support */ itkTypeMacro(Application, itk::Object); /** Set the parameter name */ //itkSetStringMacro(Name); virtual void SetName( const std::string & name ) { m_Name = name; GetDocExample()->SetApplicationName(name); this->Modified(); } itkGetStringMacro(Name); /** Set the parameter description */ itkSetStringMacro(Description); /** Get the parameter description */ itkGetStringMacro(Description); /** Initialize the application, instantiating the parameter list */ void Init(); /** Check if the application has been initialized */ bool IsInitialized() const; /** Set the parameter xml flag */ itkSetMacro(HaveInXML, bool); /** Get the parameter xml flag */ itkGetConstMacro(HaveInXML, bool); /** Set the parameter xml flag */ itkSetMacro(HaveOutXML, bool); /** Get the parameter xml flag */ itkGetConstMacro(HaveOutXML, bool); /** Update the value of parameters for which no user value has been provided */ void UpdateParameters(); /** Run the application. * * For pipeline ready application, this only wire * and configure the pipeline, and provides * the output image or vector data parameters as pointers. * * In other cases, the application must handle * the I/O (intermediary results for example) * * Returns 0 on success, or a non-null integer on error */ int Execute(); /** Run the application, then writes all the output to disk * if they have an associated filename. * This is a helper function for wrappers without pipeline support. * * Returns 0 on success, or a non-null integer on error */ int ExecuteAndWriteOutput(); /* Get the internal application parameters * * WARNING: this method may disappear from the API */ ParameterGroup* GetParameterList(); /* Get the internal application parameter specified * * WARNING: this method may disappear from the API */ Parameter* GetParameterByKey(std::string parameter); /* Get the internal application parameter specified * * WARNING: this method may disappear from the API */ const Parameter* GetParameterByKey(std::string parameter) const; /* Returns the description of a parameter */ std::string GetParameterName(std::string paramKey); /* Returns the description of a parameter */ std::string GetParameterDescription(std::string paramKey); /* Set the description of a parameter */ void SetParameterDescription(std::string paramKey, std::string dec); /* Enable the use of an optional parameter. Returns the previous state */ void EnableParameter(std::string paramKey); /* Disable the use of an optional parameter. Returns the previous state */ void DisableParameter(std::string paramKey); /* Return the enable state of an optional parameter */ bool IsParameterEnabled(std::string paramKey, bool recurseParents = false) const; /* Return true if the specified parameter is mandatory */ bool IsMandatory(std::string paramKey) const; /* Return true if the specified parameter was set automatically in * the application */ bool HasAutomaticValue(std::string paramKey) const; /* Returns true if the parameter has an associated value provided externally * (not automatically computed by the application) */ bool HasUserValue(std::string paramKey) const; /* If a user value was provided clear it and update the other parameters */ void ClearValue(std::string paramKey); /* Returns true if the parameter has an associated value. * This value can be an automatically computed value or default value, * or a value set externally by user */ bool HasValue(std::string paramKey) const; /* Activate or deactivate the bool parameter */ void SetParameterEmpty(std::string paramKey, bool active); /* Get active flag of parameter with key paramKey */ bool GetParameterEmpty(std::string paramKey); /** Set HasUserValue flag of parameter with key paramKey */ void SetParameterUserValue(std::string paramKey, bool value); /* Return the user level of access to a parameter */ UserLevel GetParameterUserLevel(std::string paramKey) const; /** Get the role of the parameter */ Role GetParameterRole(std::string paramKey) const; /* Get the parameter type from its name */ ParameterType GetParameterType(std::string paramKey) const; /* Returns the description of a parameter */ std::vector GetChoiceKeys(std::string paramKey); /* Returns the description of a parameter */ std::vector GetChoiceNames(std::string paramKey); /* Is the application ready to be executed : All the mandatory * parameters have to be set */ /* Set the Parameter value and Update the UserFlag. used by xml parameter */ void SetParameterInt(std::string parameter, int value, bool hasUserValueFlag); void SetParameterFloat(std::string parameter, float value, bool hasUserValueFlag); void SetParameterString(std::string parameter, std::string value, bool hasUserValueFlag); void SetParameterStringList(std::string parameter, std::vector values, bool hasUserValueFlag); void SetParameterEmpty(std::string parameter, bool value, bool hasUserValueFlag); bool IsApplicationReady(); /* Set an integer value * * Can be called for types : * \li ParameterType_Int * \li ParameterType_Float * \li ParameterType_Radius * \li ParameterType_Choice */ void SetParameterInt(std::string parameter, int value); /* Set a floating value * * Can be called for types : * \li ParameterType_Float */ void SetParameterFloat(std::string parameter, float value); /* Set an default integer value, must used in the * DoInit when setting a value by default * for the parameter * * Can be called for types : * \li ParameterType_Int * \li ParameterType_Float * \li ParameterType_Radius * \li ParameterType_Choice */ void SetDefaultParameterInt(std::string parameter, int value); /* Set a default floating value, must used in the * DoInit when setting a value by default * for the parameter * * Can be called for types : * \li ParameterType_Float */ void SetDefaultParameterFloat(std::string parameter, float value); /** Set a default pixel type for an output image parameter * * \param[in] parameter Name of the output image parameter * \param[in] type Default pixel type */ void SetDefaultOutputPixelType(std::string parameter, ImagePixelType type); /** Set a default complex pixel type for an output complex image parameter * * \param[in] parameter Name of the output complex image parameter * \param[in] type Default complex pixel type */ void SetDefaultOutputComplexPixelType(std::string parameter, ComplexImagePixelType type); /* Set a minimum int value, must used in the * DoInit when setting a value by default * for the parameter * * Can be called for types : * \li ParameterType_Int */ void SetMinimumParameterIntValue(std::string parameter, int value); /* Set a maximum int value, must used in the * DoInit when setting a value by default * for the parameter * * Can be called for types : * \li ParameterType_Int */ void SetMaximumParameterIntValue(std::string parameter, int value); /* Set a minimum int value, must used in the * DoInit when setting a value by default * for the parameter * * Can be called for types : * \li ParameterType_Float */ void SetMinimumParameterFloatValue(std::string parameter, float value); /* Set a maximum int value, must used in the * DoInit when setting a value by default * for the parameter * * Can be called for types : * \li ParameterType_Float */ void SetMaximumParameterFloatValue(std::string parameter, float value); /* Set a string value * * Can be called for types : * \li ParameterType_String * \li ParameterType_InputFilename * \li ParameterType_OutputFilename * \li ParameterType_Directory * \li ParameterType_Choice * \li ParameterType_Float * \li ParameterType_Int * \li ParameterType_Radius * \li ParameterType_InputImageParameter * \li ParameterType_InputComplexImageParameter * \li ParameterType_InputVectorDataParameter * \li ParameterType_OutputImageParameter * \li ParameterType_OutputVectorDataParameter */ void SetParameterString(std::string parameter, std::string value); /* Set a string value * * Can be called for types : * \li ParameterType_InputImageListParameter * \li ParameterType_InputVectorDataListParameter * \li ParameterType_InputFilenameListParameter * \li ParameterType_StringList */ void SetParameterStringList(std::string parameter, std::vector value); /* Set an output image value * * Can be called for types : * \li ParameterType_OutputImage */ void SetParameterOutputImage(std::string parameter, FloatVectorImageType* value); /* Set a complex output image value * * Can be called for types : * \li ParameterType_ComplexOutputImage */ void SetParameterComplexOutputImage(std::string parameter, ComplexFloatVectorImageType* value); /* Set the pixel type in which the image will be saved * * Can be called for types : * \li ParameterType_OutputImage */ void SetParameterOutputImagePixelType(std::string parameter, ImagePixelType pixelType); /* Set the complex pixel type in which the image will be saved * * Can be called for types : * \li ParameterType_ComplexOutputImage */ void SetParameterComplexOutputImagePixelType(std::string parameter, ComplexImagePixelType cpixelType); /* Set an output vector data value * * Can be called for types : * \li ParameterType_OutputVectorData */ void SetParameterOutputVectorData(std::string parameter, VectorDataType* value); /* Get an integer parameter value * * Can be called for types : * \li ParameterType_Int * \li ParameterType_Float * \li ParameterType_Radius * \li ParameterType_Choice */ int GetParameterInt(std::string parameter); /* Get a floating parameter value * * Can be called for types : * \li ParameterType_Float */ float GetParameterFloat(std::string parameter); /* Get a string parameter value * * Can be called for types : * \li ParameterType_String * \li ParameterType_InputFilename * \li ParameterType_OutputFilename * \li ParameterType_Directory * \li ParameterType_InputImage * \li ParameterType_InputComplexImage * \li ParameterType_InputVectorData * \li ParameterType_OutputImage * \li ParameterType_OutputVectorData */ std::string GetParameterString(std::string parameter); /* Get a string list parameter value * * Can be called for types : * \li ParameterType_StringList * \li ParameterType_InputImageList * \li ParameterType_InputFilenameList */ std::vector GetParameterStringList(std::string parameter); /** * Set the input image parameter as an ImageBase * instead * of filename. Useful to connect pipelines between different * application instances. * \in parameter The parameter key * \in inputImage ImageBase pointer to use as input * \throw itk::Exception if parameter is not found or not an * InputImageParameter */ void SetParameterInputImage(std::string parameter, InputImageParameter::ImageBaseType * inputImage); /** * Get the output image parameter as an ImageBase * instead * of writing to disk. Useful to connect pipelines between different * application instances. * \in parameter The parameter key * \return The ImageBase * to the output image * \throw itk::Exception if parameter is not found or not an * OutputImageParameter */ OutputImageParameter::ImageBaseType * GetParameterOutputImage(std::string parameter); /** * Set the input complex image parameter as an ImageBase * instead * of filename. Useful to connect pipelines between different * application instances. * \in parameter The parameter key * \in inputImage ImageBase pointer to use as input * \throw itk::Exception if parameter is not found or not an * ComplexInputImageParameter */ void SetParameterComplexInputImage(std::string parameter, ComplexInputImageParameter::ImageBaseType * inputImage); /** * Get the complex output image parameter as an ImageBase * instead * of writing to disk. Useful to connect pipelines between different * application instances. * \in parameter The parameter key * \return The ImageBase * pointer to the output image * \throw itk::Exception if parameter is not found or not an * ComplexOutputImageParameter */ ComplexOutputImageParameter::ImageBaseType * GetParameterComplexOutputImage(std::string parameter); /** * Add an image to an InputImageList parameter as an ImageBase * pointer instead of reading from file. Useful to connect pipelines * between different application instances. * \in parameter The parameter key * \in img The ImageBase * of the image to add * \throw itk::Exception if parameter is not found or not an * InputImageList parameter */ void AddImageToParameterInputImageList(std::string parameter, InputImageListParameter::ImageBaseType * img); /** * Set the nth image of an InputImageList parameter as an ImageBase pointer * instead of reading from file. Useful to connect pipelines * between different application instances. * \in parameter The parameter key * \in id Position at which to set the ImageBase pointer * \in img The ImageBase * of the image to add * \throw itk::Exception if parameter is not found or not an * InputImageList parameter or if id is out of bounds */ void SetNthParameterInputImageList(std::string parameter, const unsigned int &id, InputImageListParameter::ImageBaseType * img); /** * Clear all images from an InputImageList parameter. * * \in parameter The parameter key * \throw itk::Exception if parameter is not found or not an * InputImageList parameter */ void ClearParameterInputImageList(std::string parameter); /** * Get the number of images in an InputImageList parameter. * \in parameter The parameter key * \return The number of images * \throw itk::Exception if parameter is not found or not an * InputImageList parameter */ unsigned int GetNumberOfElementsInParameterInputImageList(std::string parameter); /* Get an image value * * Can be called for types : * \li ParameterType_InputImage */ FloatVectorImageType* GetParameterImage(std::string parameter); #define otbGetParameterImageMacro( Image ) \ Image##Type * GetParameter##Image( std::string parameter ) \ { \ Image##Type::Pointer ret; \ Parameter* param = GetParameterByKey(parameter); \ if (dynamic_cast(param)) \ { \ InputImageParameter* paramDown = dynamic_cast(param); \ ret = paramDown->Get##Image(); \ } \ return ret; \ } otbGetParameterImageMacro(UInt8Image); otbGetParameterImageMacro(UInt16Image); otbGetParameterImageMacro(Int16Image); otbGetParameterImageMacro(UInt32Image); otbGetParameterImageMacro(Int32Image); otbGetParameterImageMacro(FloatImage); otbGetParameterImageMacro(DoubleImage); otbGetParameterImageMacro(UInt8VectorImage); otbGetParameterImageMacro(UInt16VectorImage); otbGetParameterImageMacro(Int16VectorImage); otbGetParameterImageMacro(UInt32VectorImage); otbGetParameterImageMacro(Int32VectorImage); otbGetParameterImageMacro(FloatVectorImage); otbGetParameterImageMacro(DoubleVectorImage); otbGetParameterImageMacro(UInt8RGBImage); otbGetParameterImageMacro(UInt8RGBAImage); /* Get a complex image value * * Can be called for types : * \li ParameterType_ComplexInputImage */ #define otbGetParameterComplexImageMacro( Image ) \ Image##Type * GetParameter##Image( std::string parameter ) \ { \ Image##Type::Pointer ret; \ Parameter* param = GetParameterByKey(parameter); \ if (dynamic_cast(param)) \ { \ ComplexInputImageParameter* paramDown = dynamic_cast(param); \ ret = paramDown->Get##Image(); \ } \ return ret; \ } otbGetParameterComplexImageMacro(ComplexFloatImage); otbGetParameterComplexImageMacro(ComplexDoubleImage); otbGetParameterComplexImageMacro(ComplexFloatVectorImage); otbGetParameterComplexImageMacro(ComplexDoubleVectorImage); /* Get an image list value * * Can be called for types : * \li ParameterType_InputImageList */ FloatVectorImageListType* GetParameterImageList(std::string parameter); /* Get a complex image value * * Can be called for types : * \li ParameterType_InputComplexImage */ ComplexFloatVectorImageType* GetParameterComplexImage(std::string parameter); /* GetParameterVectorData * * Can be called for types : * \li ParameterType_InputVectorData */ VectorDataType* GetParameterVectorData(std::string parameter); /* GetParameteVetorDataList * * Can be called for types : * \li ParameterType_InputVectorDatalist */ VectorDataListType* GetParameterVectorDataList(std::string parameter); /* Get the parameter as a std::string * * Can be called for types : * \li ParameterType_Float * \li ParameterType_Int * \li ParameterType_Choice * \li ParameterType_Radius * \li ParameterType_String * \li ParameterType_InputFilename * \li ParameterType_OutputFilename * \li ParameterType_Directory * \li ParameterType_InputImage * \li ParameterType_InputComplexImage * \li ParameterType_InputVectorData * \li ParameterType_OutputImage * \li ParameterType_OutputVectorData */ std::string GetParameterAsString(std::string paramKey); /* Get the list of all parameters */ std::vector GetParametersKeys(bool recursive = true); /* Get the pixel type in which the image will be saved * * Can be called for types : * \li ParameterType_OutputImage */ ImagePixelType GetParameterOutputImagePixelType(std::string parameter); void SetParameterList(ParameterGroup::Pointer paramGroup) { m_ParameterList = paramGroup; } /* Get the pixel type in which the complex image will be saved * * Can be called for types : * \li ParameterType_ComplexOutputImage */ ComplexImagePixelType GetParameterComplexOutputImagePixelType(std::string parameter); itk::Logger* GetLogger(); itk::ProcessObject* GetProgressSource() const; std::string GetProgressDescription() const; /** Doc element accessors. */ itkSetStringMacro(DocName); itkGetStringMacro(DocName); itkSetStringMacro(DocLongDescription); itkGetStringMacro(DocLongDescription); itkSetStringMacro(DocAuthors); itkGetStringMacro(DocAuthors); itkSetStringMacro(DocLimitations); itkGetStringMacro(DocLimitations); itkSetStringMacro(DocSeeAlso); itkGetStringMacro(DocSeeAlso); std::vector GetDocTags(){ return m_DocTags; } void SetDocTags( std::vector val ){ m_DocTags = val; this->Modified(); } void AddDocTag( const std::string & tag ) { for (unsigned int i=0; iModified(); } DocExampleStructure::Pointer GetDocExample() { if (! IsInitialized()) { Init(); } return m_DocExample; } unsigned int GetNumberOfExamples() { return GetDocExample()->GetNbOfExamples(); } std::string GetExampleComment(unsigned int id) { return GetDocExample()->GetExampleComment(id); } unsigned int GetExampleNumberOfParameters(unsigned int id) { return GetDocExample()->GetNumberOfParameters(id); } std::string GetExampleParameterKey(unsigned int exId, unsigned int paramId) { return GetDocExample()->GetParameterKey(paramId, exId); } std::string GetExampleParameterValue(unsigned int exId, unsigned int paramId) { return GetDocExample()->GetParameterValue(paramId, exId); } void SetDocExampleParameterValue( const std::string key, const std::string value, unsigned int exId=0 ) { GetDocExample()->AddParameter( key, value, exId ); this->Modified(); } void SetExampleComment( const std::string & comm, unsigned int i ) { GetDocExample()->SetExampleComment( comm, i ); this->Modified(); } unsigned int AddExample( const std::string & comm="" ) { unsigned int id = GetDocExample()->AddExample( comm ); this->Modified(); return id; } std::string GetCLExample() { return GetDocExample()->GenerateCLExample(); } std::string GetHtmlExample() { return GetDocExample()->GenerateHtmlExample(); } /** Return all parameters which role is Role_Output in a vector of pairs that contains the * parameter key and its value. */ std::vector< std::pair > GetOutputParametersSumUp(); /** If need to force readxml more than once in application */ void ForceInXMLParseFlag() { m_IsInXMLParsed = false; } protected: /** Constructor */ Application(); /** Destructor */ ~Application() ITK_OVERRIDE; /* Register a ProcessObject as a new progress source */ void AddProcess(itk::ProcessObject* object, std::string description); /** Add a new choice value to an existing choice parameter */ void AddChoice(std::string paramKey, std::string paramName); /** Add a new parameter to the parameter group * the parent key of paramKey can be the path to a parameter group * or the path to a choice value */ void AddParameter(ParameterType type, std::string paramKey, std::string paramName); /** Add a parameterRAM method with no parameter*/ void AddRAMParameter(std::string paramKey="ram"); /** Add a parameterRAM method with parameter*/ void AddRAMParameter(std::string paramKey, std::string paramName, unsigned int defaultValue); /** Add a parameterRAND method with no parameter*/ void AddRANDParameter(std::string paramKey="rand"); /** Add a parameterRAND method with parameter * by default seed initialization is based on time value*/ void AddRANDParameter(std::string paramKey, std::string paramName, unsigned int defaultValue); void AddInXMLParameter() { GetParameterList()->AddInXMLParameter(); } void AddOutXMLParameter() { GetParameterList()->AddOutXMLParameter(); } /** Remove the items added to the ListWidget */ void ClearChoices(std::string key); /** Get Items selected in the ListView Parameter*/ std::vector GetSelectedItems(std::string paramKey); /** Declare a parameter as mandatory */ void MandatoryOn(std::string paramKey); /** Declare a parameter as NOT mandatory (default state) */ void MandatoryOff(std::string paramKey); /* Set the user level of access to a parameter */ void SetParameterUserLevel(std::string paramKey, UserLevel level); /* Set the parameter role (input/output) */ void SetParameterRole(std::string paramKey, Role role); /* Get an image value * * Can be called for types : * \li ParameterType_InputImage */ template TImageType* GetParameterImage(std::string parameter) { typename TImageType::Pointer ret; Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { InputImageParameter* paramDown = dynamic_cast(param); ret = paramDown->GetImage(); } //TODO: exception if not found ? return ret; } /** Declare a parameter as having an automatic value */ void AutomaticValueOn(std::string paramKey); /** Declare a parameter as NOT having an automatic value */ void AutomaticValueOff(std::string paramKey); /* Set an output image value * * Can be called for types : * \li ParameterType_OutputImage */ template void SetParameterOutputImage(std::string parameter, TImageType* value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { OutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } } /* Set a complex output image value * * Can be called for types : * \li ParameterType_ComplexOutputImage */ template void SetParameterComplexOutputImage(std::string parameter, TImageType* value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { ComplexOutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } } private: /* Implement this method to add parameters */ virtual void DoInit() = 0; /* Implement this method to update non valued parameters */ virtual void DoUpdateParameters() = 0; /* Implement this method to build the output */ virtual void DoExecute() = 0; /* This method will be called after the * ExecuteAndWriteOutput() call to allow for cleanup. Default * implementation does nothing */ virtual void AfterExecuteAndWriteOutputs(); Application(const Application &); //purposely not implemented void operator =(const Application&); //purposely not implemented std::string m_Name; std::string m_Description; ParameterGroup::Pointer m_ParameterList; itk::Logger::Pointer m_Logger; itk::ProcessObject::Pointer m_ProgressSource; std::string m_ProgressSourceDescription; /** Long name of the application (that can be displayed...) */ std::string m_DocName; /** Long and precise application description . */ std::string m_DocLongDescription; /** Doc example structure. Use GetDocExample() to access it */ DocExampleStructure::Pointer m_DocExample; /** Author List. Format : "John Doe, Winnie the Pooh".*/ std::string m_DocAuthors; /** Known limitations (threading, invalid pixel type ...) or bugs */ std::string m_DocLimitations; /** Related applications */ std::string m_DocSeeAlso; /** Tags that define the application (ex : segmentation, OBIA).*/ std::vector m_DocTags; //rashad:: controls adding of -xml parameter. set to true by default bool m_HaveInXML; bool m_HaveOutXML; bool m_IsInXMLParsed; /** * Declare the class * - Wrapper::MapProjectionParametersHandler * - Wrapper::ElevationParametersHandler * as friend to be able to access to the protected method of * Wrapper::Application class. **/ friend class MapProjectionParametersHandler; friend class ElevationParametersHandler; }; //end class } // end namespace Wrapper } //end namespace otb //#ifndef OTB_MANUAL_INSTANTIATION //#include "otbWrapperApplication.txx" //#endif #endif // otbWrapperApplication_h_ OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplicationFactory.h000066400000000000000000000101571301006202600316630ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperApplicationFactory_h #define otbWrapperApplicationFactory_h #include "otbWrapperApplicationFactoryBase.h" #include "itkVersion.h" namespace otb { namespace Wrapper { template < class TApplication > class ITK_ABI_EXPORT ApplicationFactory : public ApplicationFactoryBase { public: /** Standard class typedefs. */ typedef ApplicationFactory Self; typedef ApplicationFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class methods used to interface with the registered factories. */ const char* GetITKSourceVersion(void) const ITK_OVERRIDE { return ITK_SOURCE_VERSION; } const char* GetDescription(void) const ITK_OVERRIDE { return "ApplicationFactory"; } /** Method for class instantiation. */ itkFactorylessNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(ApplicationFactory, ApplicationFactoryBase); void SetClassName(const char* name) { // remove namespace, only keep class name std::string tmpName(name); std::string::size_type pos = tmpName.rfind("::"); if (pos != std::string::npos) { tmpName = tmpName.substr(pos+2); } m_ClassName.assign(tmpName); } protected: ApplicationFactory() { } ~ApplicationFactory() ITK_OVERRIDE { } /** This method is provided by sub-classes of ObjectFactoryBase. * It should create the named itk object or return 0 if that object * is not supported by the factory implementation. */ LightObject::Pointer CreateObject(const char* itkclassname ) ITK_OVERRIDE { LightObject::Pointer ret; if ( m_ClassName == itkclassname) ret = TApplication::New().GetPointer(); return ret; } /** This method creates all the objects with the new class of * itkclass name, which are provide by this object */ std::list CreateAllObject(const char* itkclassname) ITK_OVERRIDE { const std::string applicationClass("otbWrapperApplication"); std::list list; if ( m_ClassName == itkclassname || applicationClass == itkclassname ) list.push_back(TApplication::New().GetPointer()); return list; } private: ApplicationFactory(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented std::string m_ClassName; }; } // end namespace Wrapper } //end namespace otb #if (defined(WIN32) || defined(_WIN32)) # define OTB_APP_EXPORT __declspec(dllexport) #else # define OTB_APP_EXPORT #endif #define OTB_APPLICATION_EXPORT( ApplicationType ) \ typedef otb::Wrapper::ApplicationFactory ApplicationFactoryType; \ static ApplicationFactoryType::Pointer staticFactory; \ extern "C" \ { \ OTB_APP_EXPORT itk::ObjectFactoryBase* itkLoad() \ { \ staticFactory = ApplicationFactoryType::New(); \ staticFactory->SetClassName(#ApplicationType); \ return staticFactory; \ } \ } #endif // otbWrapperApplication_h_ OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplicationFactoryBase.h000066400000000000000000000032141301006202600324520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperApplicationFactoryBase_h #define otbWrapperApplicationFactoryBase_h #include "OTBApplicationEngineExport.h" #include "itkObjectFactoryBase.h" #include "otbWrapperApplication.h" namespace otb { namespace Wrapper { class OTBApplicationEngine_EXPORT ApplicationFactoryBase : public itk::ObjectFactoryBase { public: /** Standard class typedefs. */ typedef ApplicationFactoryBase Self; typedef itk::ObjectFactoryBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Run-time type information (and related methods). */ itkTypeMacro(ApplicationFactoryBase, itk::ObjectFactoryBase); /** Create an application using the CreateObject() method of the current factory */ Application::Pointer CreateApplication(const char* name); protected: ApplicationFactoryBase(){} ~ApplicationFactoryBase() ITK_OVERRIDE{} private: ApplicationFactoryBase(const Self &); //purposely not implemented void operator =(const Self&); //purposely not implemented }; } // end namespace Wrapper } //end namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplicationHtmlDocGenerator.h000066400000000000000000000053771301006202600334650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperApplicationHtmlDocGenerator_h #define otbWrapperApplicationHtmlDocGenerator_h #include "otbWrapperApplication.h" namespace otb { namespace Wrapper { /** \class ApplicationHtmlDocGenerator * \brief This class genertaes the documentation of a class usung the * class doc attributes. * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ApplicationHtmlDocGenerator { public: /** Standard class typedef */ typedef ApplicationHtmlDocGenerator Self; /** Constructor */ ApplicationHtmlDocGenerator(); /** Destructor */ virtual ~ApplicationHtmlDocGenerator(); /** Generate ans dave the documentation. */ /** Add the key is the description of the parameter if showKey is * set at true. */ static void GenerateDoc( const Application::Pointer app, const std::string & filename, const bool showKey = false ); /** Generate the documentation as a string. */ /** Add the key is the description of the parameter if showKey is * set at true. */ static void GenerateDoc( const Application::Pointer app, std::string & val, const bool showKey = false); protected: /** Get the parameter description of one parameter. */ /** Add the key is the description of the parameter if showKey is * set at true. */ static void GetDocParameters( const Application::Pointer app, std::string & val, const bool showKey = false ); /** generate the documentation associated to a group.*/ /** Add the key is the description of the parameter if showKey is * set at true. */ static void GetDocParameterGroup( const Application::Pointer app, std::string & val, const std::string & key, const bool showKey = false ); /** generate the documentation associated to a choice.*/ /** Add the key is the description of the parameter if showKey is * set at true. */ static void GetDocParameterChoice( const Application::Pointer app, std::string & val, const std::string & key, const bool showKey = false ); private: ApplicationHtmlDocGenerator(const ApplicationHtmlDocGenerator &); //purposely not implemented void operator =(const ApplicationHtmlDocGenerator&); //purposely not implemented }; // End class InputImage Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplicationRegistry.h000066400000000000000000000054351301006202600320670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperApplicationRegistry_h #define otbWrapperApplicationRegistry_h #include #include "itkObject.h" #include "otbWrapperApplication.h" namespace otb { namespace Wrapper { /** \class Application * \brief This class represent an application * TODO * * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ApplicationRegistry : public itk::Object { public: /** Standard class typedefs. */ typedef ApplicationRegistry Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Class Methods used to interface with the registered factories */ /** Run-time type information (and related methods). */ itkTypeMacro(ApplicationRegistry, Object); /** Convenient typedefs. */ typedef otb::Wrapper::Application::Pointer ApplicationPointer; /** Set the specified path to the list of application search path. Reinit all previously set paths */ static void SetApplicationPath(std::string path); /** Add the specified path to the list of application search path */ static void AddApplicationPath(std::string path); /** Return the application search path */ static std::string GetApplicationPath(); /** Return the list of available applications */ static std::vector GetAvailableApplications(bool useFactory=true); /** Create the specified Application */ static Application::Pointer CreateApplication(const std::string& applicationName, bool useFactory=true); /** Create the specified Application (faster) * method using dynamic library name to load the right module */ static Application::Pointer CreateApplicationFaster(const std::string& applicationName); /** Clean registry by releasing unused modules */ static void CleanRegistry(); protected: ApplicationRegistry(); ~ApplicationRegistry() ITK_OVERRIDE; private: ApplicationRegistry(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented /** Load an application from a shared library */ static Application::Pointer LoadApplicationFromPath(std::string path,std::string name); }; } // end namespace Wrapper } //end namespace otb #endif // otbWrapperApplication_h_ OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperChoiceParameter.h000066400000000000000000000065371301006202600311320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperChoiceParameter_h #define otbWrapperChoiceParameter_h #include "otbWrapperParameterGroup.h" namespace otb { namespace Wrapper { /** \class ChoiceParameter * \brief This class represent a multiple choice parameter for the wrapper framework * * Represents an enumerated parameter. * The different values of the enumeration can be associated with a parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ChoiceParameter : public Parameter { public: /** Standard class typedef */ typedef ChoiceParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(ChoiceParameter, Parameter); /** Add a value to the choice */ void AddChoice( std::string choicekey, std::string choiceName ); /** Get the key of a specific choice value */ std::string GetChoiceKey( int i ); /** Get the list of the different choice keys */ std::vector GetChoiceKeys(); /** Get the long name of a specific choice value */ std::string GetChoiceName( int i ); /** Get the list of the different choice keys */ std::vector GetChoiceNames(); /** Get the ParameterGroup associated to a choice value */ ParameterGroup::Pointer GetChoiceParameterGroupByIndex( int i ); /** Get the ParameterGroup associated to a choice value */ ParameterGroup::Pointer GetChoiceParameterGroupByKey( std::string choiceKey ); /** Get all parameters that are child of this choice parameter */ std::vector GetParametersKeys(); /** Get the number of available choice */ unsigned int GetNbChoices( void ); /** Set choice value */ virtual void SetValue(unsigned int v); /** Set choice value by its key */ virtual void SetValue(std::string choiceKey); /** Return any value */ virtual unsigned int GetValue(); bool HasValue() const ITK_OVERRIDE { // a choice parameter always has a value return true; } void ClearValue() ITK_OVERRIDE { // nothing to do : a choice parameter always has a value } protected: /** Constructor */ ChoiceParameter(); /** Destructor */ ~ChoiceParameter() ITK_OVERRIDE; struct Choice { Choice() {} std::string m_Key; std::string m_Name; ParameterGroup::Pointer m_AssociatedParameter; }; typedef std::vector ChoiceList; ChoiceList m_ChoiceList; unsigned int m_CurrentChoice; private: ChoiceParameter(const ChoiceParameter &); //purposely not implemented void operator =(const ChoiceParameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.h000066400000000000000000000122411301006202600333170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperComplexInputImageParameter_h #define otbWrapperComplexInputImageParameter_h #include "otbImageFileReader.h" #include "itkImageBase.h" #include "otbWrapperParameter.h" namespace otb { namespace Wrapper { /** \class ComplexInputImageParameter * \brief This class represents a ComplexInputImage parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ComplexInputImageParameter : public Parameter { public: /** Standard class typedef */ typedef ComplexInputImageParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ImageBase<2> ImageBaseType; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(ComplexInputImageParameter, Parameter); /** Set value from filename */ bool SetFromFileName(const std::string& filename); itkGetConstMacro(FileName, std::string); /** Get the input image as CFloatVectorImageType. */ ComplexFloatVectorImageType* GetImage(); /** Get the input image as XXXImageType */ ComplexFloatImageType* GetComplexFloatImage(); ComplexDoubleImageType* GetComplexDoubleImage(); ComplexFloatVectorImageType* GetComplexFloatVectorImage(); ComplexDoubleVectorImageType* GetComplexDoubleVectorImage(); /** Get the input image as templated image type. */ template TImageType* GetImage(); /** Set a FloatVectorImageType image.*/ void SetImage(ComplexFloatVectorImageType* image); /** Set a templated image.*/ template void SetImage(TImageType* image); /** Generic cast method that will be specified for each image type. */ template TOutputImage* CastImage(); /** Cast an image to an image of the same type * Image to Image, VectorImage to VectorImage, RGBAImage to RGBAImage. */ template TOutputImage* SimpleCastImage(); /** Cast an image to a vector image. */ template TOutputImage* CastVectorImageFromImage(); bool HasValue() const ITK_OVERRIDE; void ClearValue() ITK_OVERRIDE; protected: /** Constructor */ ComplexInputImageParameter(); /** Destructor */ ~ComplexInputImageParameter() ITK_OVERRIDE; ImageBaseType::Pointer m_Image; std::string m_FileName; /** Readers typedefs */ typedef otb::ImageFileReader ComplexFloatReaderType; typedef otb::ImageFileReader ComplexDoubleReaderType; typedef otb::ImageFileReader ComplexFloatVectorReaderType; typedef otb::ImageFileReader ComplexDoubleVectorReaderType; itk::ProcessObject::Pointer m_Reader; itk::ProcessObject::Pointer m_Caster; private: ComplexInputImageParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented /** Store the loaded image filename */ std::string m_PreviousFileName; /** flag : are we using a filename or an image pointer as an input */ bool m_UseFilename; }; // End class ComplexInputImage Parameter // template specializations of CastImage<> should be declared in header // so that the linker knows they exist when building OTB Applications #define otbDefineCastImageMacro(ComplexInputImageType, OutputImageType) \ template<> OutputImageType * \ ComplexInputImageParameter::CastImage(); \ #define otbGenericDefineCastImageMacro(ComplexInputImageType, prefix) \ otbDefineCastImageMacro(ComplexInputImageType, ComplexFloat##prefix##ImageType) \ otbDefineCastImageMacro(ComplexInputImageType, ComplexDouble##prefix##ImageType) /********************************************************************* ********************** Image -> Image **********************************************************************/ otbGenericDefineCastImageMacro(ComplexFloatImageType, ) otbGenericDefineCastImageMacro(ComplexDoubleImageType, ) /********************************************************************* ********************** VectorImage -> VectorImage **********************************************************************/ otbGenericDefineCastImageMacro(ComplexFloatVectorImageType, Vector) otbGenericDefineCastImageMacro(ComplexDoubleVectorImageType, Vector) } // End namespace Wrapper } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbWrapperComplexInputImageParameter.txx" #endif #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.txx000066400000000000000000000117141301006202600337170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperComplexInputImageParameter_txx #define otbWrapperComplexInputImageParameter_txx #include "otbWrapperComplexInputImageParameter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "otbImageToVectorImageCastFilter.h" namespace otb { namespace Wrapper { template TOutputImage * ComplexInputImageParameter::GetImage() { // Used m_PreviousFileName because if not, when the user call twice GetImage, // it without changing the filename, it returns 2 different // image pointers // Only one image type can be used // 2 cases : the user set a filename vs. the user set an image if (m_UseFilename) { if( m_PreviousFileName!=m_FileName && !m_FileName.empty() ) { //////////////////////// Filename case: // A new valid filename has been given : a reader is created m_PreviousFileName = m_FileName; typedef otb::ImageFileReader ReaderType; typename ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(m_FileName); try { reader->UpdateOutputInformation(); } catch(itk::ExceptionObject &) { this->ClearValue(); } m_Image = reader->GetOutput(); m_Reader = reader; // Pay attention, don't return m_Image because it is a ImageBase... return reader->GetOutput(); } else { // In this case, the reader and the image should already be there if (m_Image.IsNull()) { itkExceptionMacro("No input image or filename detected..."); } else { // Check if the image type asked here is the same as the one used for the reader if (dynamic_cast (m_Image.GetPointer())) { return dynamic_cast (m_Image.GetPointer()); } else { itkExceptionMacro("Cannot ask a different image type"); } } } } else { //////////////////////// Image case: if( m_Image.IsNull() ) { itkExceptionMacro("No input image or filename detected..."); } else { if (dynamic_cast(m_Image.GetPointer())) { return CastImage(); } else if (dynamic_cast(m_Image.GetPointer())) { return CastImage(); } else if (dynamic_cast(m_Image.GetPointer())) { return CastImage(); } else if (dynamic_cast(m_Image.GetPointer())) { return CastImage(); } else { itkExceptionMacro("Unknown image type"); } } } } template TOutputImage* ComplexInputImageParameter::CastImage() { itkExceptionMacro("Cast from "< TOutputImage* ComplexInputImageParameter::SimpleCastImage() { TComplexInputImage* realComplexInputImage = dynamic_cast(m_Image.GetPointer()); typedef itk::CastImageFilter CasterType; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(realComplexInputImage); caster->UpdateOutputInformation(); m_Image = caster->GetOutput(); m_Caster = caster; return caster->GetOutput(); } template TOutputImage* ComplexInputImageParameter::CastVectorImageFromImage() { TComplexInputImage* realComplexInputImage = dynamic_cast(m_Image.GetPointer()); typedef ImageToVectorImageCastFilter CasterType; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(realComplexInputImage); caster->UpdateOutputInformation(); m_Image = caster->GetOutput(); m_Caster = caster; return caster->GetOutput(); } template void ComplexInputImageParameter::SetImage(TComplexInputImage* image) { m_UseFilename = false; m_Image = image; } } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexOutputImageParameter.h000066400000000000000000000102321301006202600335160ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperComplexOutputImageParameter_h #define otbWrapperComplexOutputImageParameter_h #include "itkImageBase.h" #include "otbWrapperParameter.h" #include "otbImageFileWriter.h" namespace otb { namespace Wrapper { /** \class ComplexOutputImageParameter * \brief This class represents a ComplexOutputImage parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ComplexOutputImageParameter : public Parameter { public: /** Standard class typedef */ typedef ComplexOutputImageParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ImageBase<2> ImageBaseType; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(ComplexOutputImageParameter, Parameter); /** Set the value */ itkSetObjectMacro(Image, ImageBaseType); /** Get the value */ itkGetObjectMacro(Image, ImageBaseType); /** Return any value */ void SetValue(ImageBaseType* image); /** Return any value */ ImageBaseType* GetValue( void ); /** Set/Get m_ComplexPixelType to be used when saving */ itkSetMacro(ComplexPixelType, ComplexImagePixelType); itkGetMacro(ComplexPixelType, ComplexImagePixelType); /** Set/Get m_DefaultComplexPixelType*/ itkSetMacro(DefaultComplexPixelType, ComplexImagePixelType); itkGetMacro(DefaultComplexPixelType, ComplexImagePixelType); /** Set/Get available RAM value */ itkSetMacro(RAMValue, unsigned int); itkGetMacro(RAMValue, unsigned int); /** Implement the reset method (replace pixel type by default type) */ void Reset() ITK_OVERRIDE { m_ComplexPixelType = m_DefaultComplexPixelType; } /** Static method to convert pixel type into string */ static std::string ConvertPixelTypeToString(ComplexImagePixelType type); /** Return true if a filename is set */ bool HasValue() const ITK_OVERRIDE; void SetFileName (const char* filename) { m_FileName = filename; SetActive(true); } void SetFileName (const std::string& filename) { this->SetFileName(filename.c_str()); } itkGetStringMacro(FileName); void Write(); itk::ProcessObject* GetWriter(); void InitializeWriters(); protected: /** Constructor */ ComplexOutputImageParameter(); /** Destructor */ ~ComplexOutputImageParameter() ITK_OVERRIDE; template void SwitchImageWrite(); template void SwitchVectorImageWrite(); //FloatVectorImageType::Pointer m_Image; ImageBaseType::Pointer m_Image; std::string m_FileName; ComplexImagePixelType m_ComplexPixelType; ComplexImagePixelType m_DefaultComplexPixelType; typedef otb::ImageFileWriter ComplexFloatWriterType; typedef otb::ImageFileWriter ComplexDoubleWriterType; typedef otb::ImageFileWriter ComplexVectorFloatWriterType; typedef otb::ImageFileWriter ComplexVectorDoubleWriterType; ComplexFloatWriterType::Pointer m_ComplexFloatWriter; ComplexDoubleWriterType::Pointer m_ComplexDoubleWriter; ComplexVectorFloatWriterType::Pointer m_ComplexVectorFloatWriter; ComplexVectorDoubleWriterType::Pointer m_ComplexVectorDoubleWriter; private: ComplexOutputImageParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented unsigned int m_RAMValue; }; // End class OutputImage Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperDirectoryParameter.h000066400000000000000000000046141301006202600316760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperDirectoryParameter_h #define otbWrapperDirectoryParameter_h #include "otbWrapperStringParameter.h" #include "otbMacro.h" #include namespace otb { namespace Wrapper { /** \class DirectoryParameter * \brief This class represent a string parameter for the wrapper framework * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT DirectoryParameter : public Parameter { public: /** Standard class typedef */ typedef DirectoryParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(DirectoryParameter, Parameter); bool HasValue() const ITK_OVERRIDE { return m_StringParam->HasValue(); } // Set/Get Value otbSetObjectMemberMacro(StringParam, Value , std::string); otbGetObjectMemberMacro(StringParam, Value , std::string); // Clear Value void ClearValue() ITK_OVERRIDE { m_StringParam->ClearValue(); } // Reimplement the SetActive method void SetActive( const bool value ) ITK_OVERRIDE { Superclass::SetActive( value ); m_StringParam->SetActive( value ); } // GetActive method otbGetObjectMemberConstMacro(StringParam, Active, bool); protected: /** Constructor */ DirectoryParameter() { m_StringParam = StringParameter::New(); } /** Destructor */ ~DirectoryParameter() ITK_OVERRIDE {} private: DirectoryParameter(const DirectoryParameter &); //purposely not implemented void operator =(const DirectoryParameter&); //purposely not //implemented StringParameter::Pointer m_StringParam; }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperDocExampleStructure.h000066400000000000000000000102371301006202600320310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperDocExampleStructure_h #define otbWrapperDocExampleStructure_h #include "itkObject.h" #include "itkObjectFactory.h" #include #include #include #include "otbConfigure.h" #include "itkFixedArray.h" #include "OTBApplicationEngineExport.h" namespace otb { namespace Wrapper { /** \class DocExampleStructure * \brief This class is a structure that gathered the necessary * element to generate an example (for CommandLine, python, Java * ...). * User has to set the application name, the binary path and a list of * key/value couple. * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT DocExampleStructure : public itk::Object { public: /** Standard class typedefs */ typedef DocExampleStructure Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standards macros */ itkNewMacro(Self); /** Runtime information */ itkTypeMacro(DocExampleStructure, itk::Object); typedef std::pair ParameterType; typedef std::vector ParametersVectorType; typedef std::vector ParametersVectorOfVectorType; /** Get the number of examples */ itkGetMacro(NbOfExamples, unsigned int); /** Parameter list accessors. */ /** Parameter list accessors : adding key and name */ void AddParameter( const std::string key, const std::string name, unsigned int exId = 0); /** Get the parameter list. */ ParametersVectorOfVectorType GetParameterList(); /** Get number of parameters */ unsigned int GetNumberOfParameters(unsigned int exId = 0); /** Get a specific parameter couple key.*/ std::string GetParameterKey( unsigned int i, unsigned int exId = 0 ); /** Get a specific parameter couple value as string.*/ std::string GetParameterValue( unsigned int i, unsigned int exId=0 ); /** Set Application name. */ void SetApplicationName( const std::string name ); /** Get Application name. */ std::string GetApplicationName(); /** Get the example comment list */ std::vector GetExampleCommentList(); /** Get one example comment */ std::string GetExampleComment( unsigned int i); /** Set one example comment */ void SetExampleComment( const std::string & comm, unsigned int i); /** Add an example using comment. Return the index of the new example.*/ unsigned int AddExample( const std::string & comm = ""); /** Generation of the documentation for CommandLine for one specific * example. */ std::string GenerateCLExample( unsigned int exId ); /** Generation of the documentation for CommandLine. */ std::string GenerateCLExample(); /** Generation of the documentation for Qt for one specific * example. */ std::string GenerateHtmlExample( unsigned int exId ); /** Generation of the documentation for Qt. */ std::string GenerateHtmlExample(); protected: /** Constructor */ DocExampleStructure(); /** Destructor */ ~DocExampleStructure() ITK_OVERRIDE; private: DocExampleStructure(const DocExampleStructure &); //purposely not implemented void operator =(const DocExampleStructure&); //purposely not implemented /** List of the application parameters. List of key/name/value couples. */ ParametersVectorOfVectorType m_ParameterList; /** Application name */ std::string m_ApplicationName; /** Example comments */ std::vector m_ExampleCommentList; /** Stores the number of example. */ unsigned int m_NbOfExamples; }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperElevationParametersHandler.h000066400000000000000000000047201301006202600333370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperElevationParametersHandler_h #define otbWrapperElevationParametersHandler_h #include "otbWrapperApplication.h" namespace otb { namespace Wrapper { /** \class ElevationParametersHandler * \brief This class represent a helper class for elevation modes. It * add the parameters automatically to the application where it is * used, provide method to get the value needed. * * This class allow creating a Choice list with several Elevation * modes to be used, supported modes are DEM, Geoid file, average * elevation. The user can get the value relative to each mode * using one the following methods Get{AverageElevation, DEMDirectory, GeoidFile}. * * * * \ingroup OTBApplicationEngine */ class ElevationParametersHandler { public: /** * Add a Group containing several choices for map projections * */ static OTBApplicationEngine_EXPORT void AddElevationParameters(Application::Pointer app, const std::string & key); /** Method for getting the value of the elevation mode selected */ static OTBApplicationEngine_EXPORT float GetDefaultElevation(const Application::Pointer app, const std::string& key); static OTBApplicationEngine_EXPORT const std::string GetGeoidFile(const Application::Pointer app, const std::string& key); static OTBApplicationEngine_EXPORT const std::string GetDEMDirectory(const Application::Pointer app, const std::string& key); static OTBApplicationEngine_EXPORT bool IsGeoidUsed(const Application::Pointer app, const std::string& key); static OTBApplicationEngine_EXPORT bool IsDEMUsed(const Application::Pointer app, const std::string & key); static OTBApplicationEngine_EXPORT void SetupDEMHandlerFromElevationParameters(const Application::Pointer app, const std::string& key); protected: ElevationParametersHandler(); // not implemented virtual ~ElevationParametersHandler(); // not implemented }; } } #endif // otbWrapperElevationParametersHandler_h_ OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperEmptyParameter.h000066400000000000000000000035741301006202600310340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperEmptyParameter_h #define otbWrapperEmptyParameter_h #include "otbWrapperParameter.h" namespace otb { namespace Wrapper { /** \class EmptyParameter * \brief This class represent an empty parameter for the wrapper framework (boolean value) * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT EmptyParameter : public Parameter { public: /** Standard class typedef */ typedef EmptyParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(EmptyParameter, Parameter); /** HasValue */ bool HasValue() const ITK_OVERRIDE { return false; } bool HasUserValue() const ITK_OVERRIDE { return this->m_UserValue; } protected: /** Constructor */ EmptyParameter() { // It does not make sense for an empty parameter to be mandatory this->MandatoryOff(); } /** Destructor */ ~EmptyParameter() ITK_OVERRIDE {} private: EmptyParameter(const EmptyParameter &); //purposely not implemented void operator =(const EmptyParameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputFilenameListParameter.h000066400000000000000000000054301301006202600333230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputFilenameListParameter_h #define otbWrapperInputFilenameListParameter_h #include #include "otbWrapperStringParameter.h" #include "otbObjectList.h" namespace otb { namespace Wrapper { /** \class InputFilenameListParameter * \brief This class represents a list of InputFilename parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT InputFilenameListParameter : public Parameter { public: /** Standard class typedef */ typedef InputFilenameListParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::ObjectList StringParameterListType; typedef StringParameterListType* StringParameterListPointerType; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(InputFilenameListParameter, Parameter); /** Set file form a list of filenames */ bool SetListFromFileName(const std::vector & filenames); /** Add null element to lists. */ void AddNullElement(); /** Add a filename from a filename */ bool AddFromFileName(const std::string & filename); /** Set one specific stored filename. */ bool SetNthFileName( const unsigned int id, const std::string & filename ); /** Get the stored filename list */ std::vector GetFileNameList() const; /** Get one specific stored filename. */ std::string GetNthFileName( unsigned int i ) const; /** Get one list of the stored files. */ StringParameterListPointerType GetFileList() const; bool HasValue() const ITK_OVERRIDE; /** Erase one element of the list. */ void Erase( unsigned int id ); /** Clear all the list. */ void ClearValue() ITK_OVERRIDE; protected: /** Constructor */ InputFilenameListParameter(); /** Destructor */ ~InputFilenameListParameter() ITK_OVERRIDE; StringParameterListType::Pointer m_FilenameList; private: InputFilenameListParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented }; // End class InputFilenameList Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputFilenameParameter.h000066400000000000000000000045521301006202600324730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputFilenameParameter_h #define otbWrapperInputFilenameParameter_h #include #include "otbWrapperStringParameter.h" namespace otb { namespace Wrapper { /** \class InputFilenameParameter * \brief This class represent a string parameter for the wrapper framework * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT InputFilenameParameter : public Parameter { public: /** Standard class typedef */ typedef InputFilenameParameter Self; typedef StringParameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(InputFilenameParameter, Parameter); bool HasValue() const ITK_OVERRIDE { return m_StringParam->HasValue(); } // Get Value otbGetObjectMemberMacro(StringParam, Value , std::string); // Set Value virtual void SetValue(const std::string value) { itkDebugMacro("setting member m_StringParam to " << value); this->m_StringParam->SetValue(value); SetActive(true); this->Modified(); } // Clear Value void ClearValue() ITK_OVERRIDE { m_StringParam->ClearValue(); } protected: /** Constructor */ InputFilenameParameter() { // Initialize the String Parameter m_StringParam= StringParameter::New(); } /** Destructor */ ~InputFilenameParameter() ITK_OVERRIDE {} private: InputFilenameParameter(const InputFilenameParameter &); //purposely not implemented void operator =(const InputFilenameParameter&); //purposely not //implemented StringParameter::Pointer m_StringParam; }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageListParameter.h000066400000000000000000000063231301006202600326270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputImageListParameter_h #define otbWrapperInputImageListParameter_h #include "otbWrapperParameter.h" #include "otbWrapperInputImageParameter.h" namespace otb { namespace Wrapper { /** \class InputImageListParameter * \brief This class represents a list of InputImage parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT InputImageListParameter : public Parameter { public: /** Standard class typedef */ typedef InputImageListParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef std::vector InputImageParameterVectorType; typedef itk::ImageBase<2> ImageBaseType; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(InputImageListParameter, Parameter); /** Set image form a list of filename */ bool SetListFromFileName(const std::vector & filenames); /** Add null element to lists. */ void AddNullElement(); /** Add an image from a filename */ bool AddFromFileName(const std::string & filename); /** Set one specific stored image filename. */ bool SetNthFileName( const unsigned int id, const std::string & filename ); /** Get the stored image filename list */ std::vector GetFileNameList() const; /** Get one specific stored image filename. */ std::string GetNthFileName( unsigned int i ) const; /** Get one list of the stored image. */ FloatVectorImageListType* GetImageList() const; /** Get one specific stored image. */ FloatVectorImageType* GetNthImage(unsigned int i) const; /** Set one specific image. */ void SetNthImage(unsigned int i, ImageBaseType * img); /** Set the list of image. */ void SetImageList(FloatVectorImageListType* imList); /** Add an image to the list. */ void AddImage(ImageBaseType* image); bool HasValue() const ITK_OVERRIDE; /** Erase one element of the list. */ void Erase( unsigned int id ); /** Clear all the list. */ void ClearValue() ITK_OVERRIDE; /** Retrieve number of elements */ unsigned int Size() const; protected: /** Constructor */ InputImageListParameter(); /** Destructor */ ~InputImageListParameter() ITK_OVERRIDE; private: InputImageListParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented InputImageParameterVectorType m_InputImageParameterVector; FloatVectorImageListType::Pointer m_ImageList; }; // End class InputImage Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.h000066400000000000000000000174061301006202600317770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputImageParameter_h #define otbWrapperInputImageParameter_h #include "otbImageFileReader.h" #include "itkImageBase.h" #include "otbWrapperParameter.h" namespace otb { namespace Wrapper { /** \class InputImageParameter * \brief This class represents a InputImage parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT InputImageParameter : public Parameter { public: /** Standard class typedef */ typedef InputImageParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ImageBase<2> ImageBaseType; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(InputImageParameter, Parameter); /** Set value from filename */ bool SetFromFileName(const std::string& filename); itkGetConstMacro(FileName, std::string); /** Get the input image as FloatVectorImageType. */ FloatVectorImageType* GetImage(); /** Get the input image as XXXImageType */ UInt8ImageType* GetUInt8Image(); UInt16ImageType* GetUInt16Image(); Int16ImageType* GetInt16Image(); UInt32ImageType* GetUInt32Image(); Int32ImageType* GetInt32Image(); FloatImageType* GetFloatImage(); DoubleImageType* GetDoubleImage(); UInt8VectorImageType* GetUInt8VectorImage(); UInt16VectorImageType* GetUInt16VectorImage(); Int16VectorImageType* GetInt16VectorImage(); UInt32VectorImageType* GetUInt32VectorImage(); Int32VectorImageType* GetInt32VectorImage(); FloatVectorImageType* GetFloatVectorImage(); DoubleVectorImageType* GetDoubleVectorImage(); UInt8RGBImageType* GetUInt8RGBImage(); UInt8RGBAImageType* GetUInt8RGBAImage(); /** Get the input image as templated image type. */ template TImageType* GetImage(); /** Set a FloatVectorImageType image.*/ void SetImage(FloatVectorImageType* image); /** Set a templated image.*/ template void SetImage(TImageType* image); /** Generic cast method that will be specified for each image type. */ template TOutputImage* CastImage(); /** Cast an image to an image of the same type * Image to Image, VectorImage to VectorImage, RGBAImage to RGBAImage. */ template TOutputImage* SimpleCastImage(); /** Cast an image to a vector image. */ template TOutputImage* CastVectorImageFromImage(); bool HasValue() const ITK_OVERRIDE; void ClearValue() ITK_OVERRIDE; protected: /** Constructor */ InputImageParameter(); /** Destructor */ ~InputImageParameter() ITK_OVERRIDE; ImageBaseType::Pointer m_Image; std::string m_FileName; /** Readers typedefs */ typedef otb::ImageFileReader UInt8ReaderType; typedef otb::ImageFileReader Int16ReaderType; typedef otb::ImageFileReader UInt16ReaderType; typedef otb::ImageFileReader Int32ReaderType; typedef otb::ImageFileReader UInt32ReaderType; typedef otb::ImageFileReader FloatReaderType; typedef otb::ImageFileReader DoubleReaderType; typedef otb::ImageFileReader UInt8VectorReaderType; typedef otb::ImageFileReader Int16VectorReaderType; typedef otb::ImageFileReader UInt16VectorReaderType; typedef otb::ImageFileReader Int32VectorReaderType; typedef otb::ImageFileReader UInt32VectorReaderType; typedef otb::ImageFileReader FloatVectorReaderType; typedef otb::ImageFileReader DoubleVectorReaderType; typedef otb::ImageFileReader UInt8RGBReaderType; typedef otb::ImageFileReader UInt8RGBAReaderType; itk::ProcessObject::Pointer m_Reader; itk::ProcessObject::Pointer m_Caster; private: InputImageParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented /** Store the loaded image filename */ std::string m_PreviousFileName; /** flag : are we using a filename or an image pointer as an input */ bool m_UseFilename; }; // End class InputImage Parameter // template specializations of CastImage<> should be declared in header // so that the linker knows they exist when building OTB Applications #define otbDeclareCastImageMacro(InputImageType, OutputImageType) \ template<> OTBApplicationEngine_EXPORT OutputImageType * \ InputImageParameter::CastImage(); \ #define otbGenericDeclareCastImageMacro(InputImageType, prefix) \ otbDeclareCastImageMacro(InputImageType, UInt8##prefix##ImageType) \ otbDeclareCastImageMacro(InputImageType, UInt16##prefix##ImageType) \ otbDeclareCastImageMacro(InputImageType, Int16##prefix##ImageType) \ otbDeclareCastImageMacro(InputImageType, UInt32##prefix##ImageType) \ otbDeclareCastImageMacro(InputImageType, Int32##prefix##ImageType) \ otbDeclareCastImageMacro(InputImageType, Float##prefix##ImageType) \ otbDeclareCastImageMacro(InputImageType, Double##prefix##ImageType) /********************************************************************* ********************** Image -> Image **********************************************************************/ otbGenericDeclareCastImageMacro(UInt8ImageType, ) otbGenericDeclareCastImageMacro(Int16ImageType, ) otbGenericDeclareCastImageMacro(UInt16ImageType, ) otbGenericDeclareCastImageMacro(Int32ImageType, ) otbGenericDeclareCastImageMacro(UInt32ImageType, ) otbGenericDeclareCastImageMacro(FloatImageType, ) otbGenericDeclareCastImageMacro(DoubleImageType, ) /********************************************************************* ********************** VectorImage -> VectorImage **********************************************************************/ otbGenericDeclareCastImageMacro(UInt8VectorImageType, Vector) otbGenericDeclareCastImageMacro(Int16VectorImageType, Vector) otbGenericDeclareCastImageMacro(UInt16VectorImageType, Vector) otbGenericDeclareCastImageMacro(Int32VectorImageType, Vector) otbGenericDeclareCastImageMacro(UInt32VectorImageType, Vector) otbGenericDeclareCastImageMacro(FloatVectorImageType, Vector) otbGenericDeclareCastImageMacro(DoubleVectorImageType, Vector) /********************************************************************* ********************** Image -> VectorImage **********************************************************************/ otbGenericDeclareCastImageMacro(UInt8ImageType, Vector) otbGenericDeclareCastImageMacro(Int16ImageType, Vector) otbGenericDeclareCastImageMacro(UInt16ImageType, Vector) otbGenericDeclareCastImageMacro(Int32ImageType, Vector) otbGenericDeclareCastImageMacro(UInt32ImageType, Vector) otbGenericDeclareCastImageMacro(FloatImageType, Vector) otbGenericDeclareCastImageMacro(DoubleImageType, Vector) #undef otbDeclareCastImageMacro #undef otbGenericDeclareCastImageMacro } // End namespace Wrapper } // End namespace otb #ifndef OTB_MANUAL_INSTANTIATION #include "otbWrapperInputImageParameter.txx" #endif #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.txx000066400000000000000000000153041301006202600323660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputImageParameter_txx #define otbWrapperInputImageParameter_txx #include "otbWrapperInputImageParameter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "otbImageToVectorImageCastFilter.h" namespace otb { namespace Wrapper { template TImageType* InputImageParameter::GetImage() { otbMsgDevMacro(<< "GetImage()"); // Used m_PreviousFileName because if not, when the user call twice GetImage, // it without changing the filename, it returns 2 different // image pointers // Only one image type can be used // 2 cases : the user set a filename vs. the user set an image if (m_UseFilename) { if( m_PreviousFileName!=m_FileName && !m_FileName.empty() ) { //////////////////////// Filename case: // A new valid filename has been given : a reader is created m_PreviousFileName = m_FileName; typedef otb::ImageFileReader ReaderType; typename ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(m_FileName); try { reader->UpdateOutputInformation(); } catch (itk::ExceptionObject &) { this->ClearValue(); } m_Image = reader->GetOutput(); m_Reader = reader; // Pay attention, don't return m_Image because it is a ImageBase... return reader->GetOutput(); } else { // In this case, the reader and the image should already be there if (m_Image.IsNull()) { itkExceptionMacro("No input image or filename detected..."); } else { // Check if the image type asked here is the same as the one used for the reader if (dynamic_cast (m_Image.GetPointer())) { return dynamic_cast (m_Image.GetPointer()); } else { itkExceptionMacro("Cannot ask a different image type"); } } } } else { //////////////////////// Image case: if (m_Image.IsNull()) { itkExceptionMacro("No input image or filename detected..."); } else { if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else if (dynamic_cast (m_Image.GetPointer())) { return CastImage (); } else { itkExceptionMacro("Unknown image type"); } } } } template TOutputImage* InputImageParameter::CastImage() { itkExceptionMacro("Cast from "< TOutputImage* InputImageParameter::SimpleCastImage() { if ( dynamic_cast (m_Image.GetPointer()) ) { return dynamic_cast (m_Image.GetPointer()); } else { TInputImage* realInputImage = dynamic_cast(m_Image.GetPointer()); typedef itk::CastImageFilter CasterType; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(realInputImage); caster->UpdateOutputInformation(); m_Image = caster->GetOutput(); m_Caster = caster; return caster->GetOutput(); } } template TOutputImage* InputImageParameter::CastVectorImageFromImage() { TInputImage* realInputImage = dynamic_cast(m_Image.GetPointer()); typedef ImageToVectorImageCastFilter CasterType; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(realInputImage); caster->UpdateOutputInformation(); m_Image = caster->GetOutput(); m_Caster = caster; return caster->GetOutput(); } template void InputImageParameter::SetImage(TInputImage* image) { m_UseFilename = false; m_Image = image; } } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputProcessXMLParameter.h000066400000000000000000000040501301006202600327430ustar00rootroot00000000000000#ifndef otbWrapperInputProcessXMLParameter_h #define otbWrapperInputProcessXMLParameter_h #include "otbWrapperApplication.h" #include "otb_tinyxml.h" #include namespace otb { namespace Wrapper { /** \class InputProcessXMLParameter * \brief This class represent a xml filename parameter for the wrapper framework to load otb application. * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT InputProcessXMLParameter : public Parameter { public: /** Standard class typedef */ typedef InputProcessXMLParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(InputProcessXMLParameter, Parameter); itkGetStringMacro(FileName); bool HasValue() const ITK_OVERRIDE { if(m_FileName.empty()) return false; else return true; } // Get Value //TODO otbGetObjectMemberMacro(StringParam, Value , std::string); bool SetFileName(std::string value); // Set Value virtual void SetValue(const std::string value); ImagePixelType GetPixelTypeFromString(std::string pixTypeAsString); ParameterType GetParameterType(const Parameter* param) const; const std::string GetChildNodeTextOf(TiXmlElement *parentElement, std::string key); int Read(Application::Pointer application); void otbAppLogInfo(Application::Pointer app, std::string info); /* copied from Utilities/tinyXMLlib/tinyxml.cpp. Must have a FIX inside tinyxml.cpp */ FILE* TiXmlFOpen( const char* filename, const char* mode ); protected: InputProcessXMLParameter(); /** Destructor */ ~InputProcessXMLParameter() ITK_OVERRIDE; private: std::string m_FileName; InputProcessXMLParameter(const InputProcessXMLParameter &); //purposely not implemented void operator =(const InputProcessXMLParameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputVectorDataListParameter.h000066400000000000000000000062261301006202600336430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputVectorDataListParameter_h #define otbWrapperInputVectorDataListParameter_h #include "otbVectorDataFileReader.h" #include "otbWrapperParameter.h" #include "otbObjectList.h" namespace otb { namespace Wrapper { /** \class InputVectorDataListParameter * \brief This class represents a list of VectorData parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT InputVectorDataListParameter : public Parameter { public: /** Standard class typedef */ typedef InputVectorDataListParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef otb::VectorDataFileReader VectorDataFileReaderType; typedef otb::ObjectList VectorDataFileReaderListType; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(InputVectorDataListParameter, Parameter); /** Set image form a list of filename */ bool SetListFromFileName(const std::vector & filenames); /** Add null element to lists. */ void AddNullElement(); /** Add an image from a filename */ bool AddFromFileName(const std::string & filename); /** Set one specific stored image filename. */ bool SetNthFileName( const unsigned int id, const std::string & filename ); /** Get the stored image filename list */ std::vector GetFileNameList() const; /** Get one specific stored image filename. */ std::string GetNthFileName( unsigned int i ) const; /** Get one list of the stored image. */ VectorDataListType* GetVectorDataList() const; /** Get one specific stored image. */ VectorDataType* GetNthVectorData(unsigned int i) const; /** Set the list of image. */ void SetVectorDataList(VectorDataListType* vdList); /** Add an image to the list. */ void AddVectorData(VectorDataType* image); bool HasValue() const ITK_OVERRIDE; /** Erase one element of the list. */ void Erase( unsigned int id ); /** Clear all the list. */ void ClearValue() ITK_OVERRIDE; protected: /** Constructor */ InputVectorDataListParameter(); /** Destructor */ ~InputVectorDataListParameter() ITK_OVERRIDE; VectorDataListType::Pointer m_VectorDataList; VectorDataFileReaderListType::Pointer m_ReaderList; private: InputVectorDataListParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented }; // End class InputVectorDataList Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputVectorDataParameter.h000066400000000000000000000044641301006202600330110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputVectorDataParameter_h #define otbWrapperInputVectorDataParameter_h #include "otbVectorDataFileReader.h" #include "otbWrapperParameter.h" namespace otb { namespace Wrapper { /** \class InputVectorDataParameter * \brief This class represents a InputVectorData parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT InputVectorDataParameter : public Parameter { public: /** Standard class typedef */ typedef InputVectorDataParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(InputVectorDataParameter, Parameter); typedef double CoordinatePrecisionType; typedef double ValuePrecisionType; typedef otb::VectorData VectorDataType; /** Set value from filename */ bool SetFromFileName(const std::string& filename); itkGetConstMacro(FileName, std::string); VectorDataType* GetVectorData(); void SetVectorData(VectorDataType* vectorData); bool HasValue() const ITK_OVERRIDE; void ClearValue() ITK_OVERRIDE; protected: /** Constructor */ InputVectorDataParameter(); /** Destructor */ ~InputVectorDataParameter() ITK_OVERRIDE; typedef otb::VectorDataFileReader VectorDataFileReaderType; VectorDataType::Pointer m_VectorData; VectorDataFileReaderType::Pointer m_Reader; std::string m_FileName; private: InputVectorDataParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented }; } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperListViewParameter.h000066400000000000000000000110721301006202600314740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperListViewParameter_h #define otbWrapperListViewParameter_h #include "otbWrapperParameterGroup.h" namespace otb { namespace Wrapper { /** \class ListViewParameter * \brief This class represent a ListWidget parameter for the wrapper framework * * The row selected in the ListWidget are stored in a std::vector. The * method GetSelectedItems() allow the user to access to this method. * * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ListViewParameter : public Parameter { public: /** Standard class typedef */ typedef ListViewParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(ListViewParameter, Parameter); /** Add a value to the choice */ void AddChoice( std::string choicekey, std::string choiceName ); /** Get the key of a specific choice value */ std::string GetChoiceKey( int i ); /** Get the list of the different choice keys */ std::vector GetChoiceKeys(); /** Get the long name of a specific choice value */ std::string GetChoiceName( int i ); /** Get the list of the different choice keys */ std::vector GetChoiceNames(); /** Get the number of available choice */ unsigned int GetNbChoices( void ); /** Set choice value */ virtual void SetValue(unsigned int v); /** Set choice value by its key */ virtual void SetValue(std::string choiceKey); /** Return any value */ virtual unsigned int GetValue(); bool HasValue() const ITK_OVERRIDE { // a choice parameter always has a value return true; } void ClearValue() ITK_OVERRIDE { // nothing to do : a choice parameter always has a value } void ClearChoices(); std::vector GetSelectedItems() { if( m_SelectedNames.size() != 0 ) { this->SetSelectedItemsByNames(); } else if( m_SelectedKeys.size() != 0 ) { this->SetSelectedItemsByKeys(); } return m_SelectedItems; } void SetSelectedNames(std::vector selectedNames) { m_SelectedNames = selectedNames; m_SelectedItems.clear(); m_SelectedKeys.clear(); } std::vector GetSelectedNames() { return m_SelectedNames; } void SetSelectedKeys(std::vector selectedKeys) { m_SelectedKeys = selectedKeys; m_SelectedItems.clear(); m_SelectedNames.clear(); } std::vector GetSelectedKeys() { return m_SelectedKeys; } /** Set selected items using a lit of selected keys. */ void SetSelectedItemsByKeys(); /** Set selected items using a lit of selected names. */ void SetSelectedItemsByNames(); void SetSelectedItems(std::vector selectedItems) { std::vector items; for( unsigned int i=0; i selectedItems) { m_SelectedItems = selectedItems; } protected: /** Constructor */ ListViewParameter(); /** Destructor */ ~ListViewParameter() ITK_OVERRIDE; struct ListViewChoice { ListViewChoice() {} std::string m_Key; std::string m_Name; }; typedef std::vector ChoiceList; ChoiceList m_ChoiceList; unsigned int m_CurrentChoice; std::vector m_SelectedItems; std::vector m_SelectedKeys; std::vector m_SelectedNames; private: ListViewParameter(const ListViewParameter &); //purposely not implemented void operator =(const ListViewParameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperMacros.h000066400000000000000000000027441301006202600273170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperMacros_h #define otbWrapperMacros_h #define otbAppLogFATAL(x) \ { \ std::ostringstream msg; \ msg << "" x << std::endl; \ this->GetLogger()->Write( itk::LoggerBase::FATAL, msg.str() ); \ itkGenericExceptionMacro(<< "Fatal error caught. Aborting..."); \ } #define otbAppLogCRITICAL(x) \ { \ std::ostringstream msg; \ msg << "" x << std::endl; \ this->GetLogger()->Write( itk::LoggerBase::CRITICAL, msg.str() ); \ } #define otbAppLogWARNING(x) \ { \ std::ostringstream msg; \ msg << "" x << std::endl; \ this->GetLogger()->Write( itk::LoggerBase::WARNING, msg.str() ); \ } #define otbAppLogINFO(x) \ { \ std::ostringstream msg; \ msg << "" x << std::endl; \ this->GetLogger()->Write( itk::LoggerBase::INFO, msg.str() ); \ } #define otbAppLogDEBUG(x) \ { \ std::ostringstream msg; \ msg << "" x << std::endl; \ this->GetLogger()->Write( itk::LoggerBase::DEBUG, msg.str() ); \ } #endif otbWrapperMapProjectionParametersHandler.h000066400000000000000000000045371301006202600341120ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperMapProjectionParametersHandler_h #define otbWrapperMapProjectionParametersHandler_h #include "OTBApplicationEngineExport.h" #include "otbWrapperApplication.h" namespace otb { namespace Wrapper { // enum used for the map projection choices enum { Map_Utm, Map_Lambert2, Map_Lambert93, //Map_Transmercator, Map_WGS84, Map_Epsg }; /** \class MapProjectionParametersHandler * \brief This class represent a helper class. * * This class allow creating a Group with several mapProjection * parameters * * \ingroup OTBApplicationEngine */ class MapProjectionParametersHandler { public: /** * Add a Group containing several choices for map projections * */ static OTBApplicationEngine_EXPORT void AddMapProjectionParameters(Application::Pointer app, const std::string & key); /** * Helper method : Compute the ProjectionRef knowing the map * projection picked up by the user * */ static OTBApplicationEngine_EXPORT const std::string GetProjectionRefFromChoice(const Application::Pointer app, const std::string & key); /** * Helper method : Compute the UTM parameters relative an image * Note: The key of the image must be set to be able to get the image. * The key must be totally if the InputImageParameter belongs * to a ParameterGroup, ie set io.in */ static OTBApplicationEngine_EXPORT void InitializeUTMParameters(Application::Pointer app, const std::string & imageKey, const std::string & mapKey ); protected: MapProjectionParametersHandler(); // not implemented virtual ~MapProjectionParametersHandler(); // not implemented }; } } #endif // otbWrapperMapProjectionParametersHandler_h_ OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperNumericalParameter.h000066400000000000000000000071251301006202600316510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperNumericalParameter_h #define otbWrapperNumericalParameter_h #include "otbWrapperParameter.h" #include "itkNumericTraits.h" #include namespace otb { namespace Wrapper { /** \class NumericalParameter * \brief This class represents a numerical parameter * * \ingroup OTBApplicationEngine */ template class ITK_ABI_EXPORT NumericalParameter : public Parameter { public: /** Standard class typedef */ typedef NumericalParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(NumericalParameter, Parameter); /** Typedef of the scalar type */ typedef T ScalarType; /** Implement the reset method (replace value by default value) */ void Reset() ITK_OVERRIDE { m_Value = m_DefaultValue; } /** Set the value */ void SetValue( ScalarType value) { // TODO check minimum/maximum m_Value = value; // Set Active only if the parameter is not automatically set if (!GetAutomaticValue()) { SetActive(true); } } void SetValue( const std::string & valueStr ) { ScalarType value = static_cast(atof(valueStr.c_str())); SetValue(value); } /** Get the value */ ScalarType GetValue() const { if (!HasValue()) { itkGenericExceptionMacro(<< "Parameter " << this->GetKey() << " has no value yet."); } return boost::any_cast(m_Value); } bool HasValue() const ITK_OVERRIDE { return !m_Value.empty(); } void ClearValue() ITK_OVERRIDE { m_Value = boost::any(); } /** Set the default value */ itkSetMacro(DefaultValue, ScalarType); /** Get the default value */ itkGetMacro(DefaultValue, ScalarType); /** Set the minimum value */ itkSetMacro(MinimumValue, ScalarType); /** Get the minimum value */ itkGetMacro(MinimumValue, ScalarType); /** Set the maximum value */ itkSetMacro(MaximumValue, ScalarType); /** Get the maximum value */ itkGetMacro(MaximumValue, ScalarType); protected: /** Constructor */ NumericalParameter() : m_DefaultValue(itk::NumericTraits::Zero), m_MinimumValue(itk::NumericTraits::NonpositiveMin()), m_MaximumValue(itk::NumericTraits::max()) {} /** Destructor */ ~NumericalParameter() ITK_OVERRIDE {} /** Value */ boost::any m_Value; /** Default value (when appliable) */ ScalarType m_DefaultValue; /** Minimum value */ ScalarType m_MinimumValue; /** Maximum value */ ScalarType m_MaximumValue; private: NumericalParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented }; // End class Numerical Parameter // Helper typedef for float typedef NumericalParameter FloatParameter; // Helper typedef for int typedef NumericalParameter IntParameter; } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputFilenameParameter.h000066400000000000000000000045651301006202600327000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperOutputFilenameParameter_h #define otbWrapperOutputFilenameParameter_h #include #include "otbWrapperStringParameter.h" namespace otb { namespace Wrapper { /** \class OutputFilenameParameter * \brief This class represent a string parameter for the wrapper framework * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT OutputFilenameParameter : public Parameter { public: /** Standard class typedef */ typedef OutputFilenameParameter Self; typedef StringParameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(OutputFilenameParameter, Parameter); bool HasValue() const ITK_OVERRIDE { return m_StringParam->HasValue(); } // Get Value otbGetObjectMemberMacro(StringParam, Value , std::string); // Set Value virtual void SetValue(const std::string value) { itkDebugMacro("setting member m_StringParam to " << value); this->m_StringParam->SetValue(value); SetActive(true); this->Modified(); } // Clear Value void ClearValue() ITK_OVERRIDE { m_StringParam->ClearValue(); } protected: /** Constructor */ OutputFilenameParameter() { // Initialize the String Parameter m_StringParam= StringParameter::New(); } /** Destructor */ ~OutputFilenameParameter() ITK_OVERRIDE {} private: OutputFilenameParameter(const OutputFilenameParameter &); //purposely not implemented void operator =(const OutputFilenameParameter&); //purposely not //implemented StringParameter::Pointer m_StringParam; }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputImageParameter.h000066400000000000000000000127221301006202600321740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperOutputImageParameter_h #define otbWrapperOutputImageParameter_h //#include "otbVectorImage.h" #include "itkImageBase.h" #include "otbWrapperParameter.h" #include "otbImageFileWriter.h" namespace otb { namespace Wrapper { /** \class OutputImageParameter * \brief This class represents a OutputImage parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT OutputImageParameter : public Parameter { public: /** Standard class typedef */ typedef OutputImageParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef itk::ImageBase<2> ImageBaseType; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(OutputImageParameter, Parameter); /** Set the value */ itkSetObjectMacro(Image, ImageBaseType); /** Get the value */ itkGetObjectMacro(Image, ImageBaseType); /** Return any value */ void SetValue(ImageBaseType* image); /** Return any value */ ImageBaseType* GetValue( void ); /** Set/Get PixelType to be used when saving */ itkSetMacro(PixelType, ImagePixelType); itkGetMacro(PixelType, ImagePixelType); /** Set/Get DefaultPixelType */ itkSetMacro(DefaultPixelType, ImagePixelType); itkGetMacro(DefaultPixelType, ImagePixelType); /** Set/Get available RAM value */ itkSetMacro(RAMValue, unsigned int); itkGetMacro(RAMValue, unsigned int); /** Implement the reset method (replace pixel type by default type) */ void Reset() ITK_OVERRIDE { m_PixelType = m_DefaultPixelType; } /** Static method to convert pixel type into string */ static std::string ConvertPixelTypeToString(ImagePixelType type); /** Return true if a filename is set */ bool HasValue() const ITK_OVERRIDE; void SetFileName (const char* filename) { m_FileName = filename; SetActive(true); } void SetFileName (const std::string& filename) { this->SetFileName(filename.c_str()); } itkGetStringMacro(FileName); void Write(); itk::ProcessObject* GetWriter(); void InitializeWriters(); protected: /** Constructor */ OutputImageParameter(); /** Destructor */ ~OutputImageParameter() ITK_OVERRIDE; template void SwitchImageWrite(); template void SwitchVectorImageWrite(); template void SwitchRGBImageWrite(); template void SwitchRGBAImageWrite(); //FloatVectorImageType::Pointer m_Image; ImageBaseType::Pointer m_Image; std::string m_FileName; ImagePixelType m_PixelType; ImagePixelType m_DefaultPixelType; typedef otb::ImageFileWriter UInt8WriterType; typedef otb::ImageFileWriter Int16WriterType; typedef otb::ImageFileWriter UInt16WriterType; typedef otb::ImageFileWriter Int32WriterType; typedef otb::ImageFileWriter UInt32WriterType; typedef otb::ImageFileWriter FloatWriterType; typedef otb::ImageFileWriter DoubleWriterType; typedef otb::ImageFileWriter VectorUInt8WriterType; typedef otb::ImageFileWriter VectorInt16WriterType; typedef otb::ImageFileWriter VectorUInt16WriterType; typedef otb::ImageFileWriter VectorInt32WriterType; typedef otb::ImageFileWriter VectorUInt32WriterType; typedef otb::ImageFileWriter VectorFloatWriterType; typedef otb::ImageFileWriter VectorDoubleWriterType; typedef otb::ImageFileWriter RGBAUInt8WriterType; typedef otb::ImageFileWriter RGBUInt8WriterType; UInt8WriterType::Pointer m_UInt8Writer; Int16WriterType::Pointer m_Int16Writer; UInt16WriterType::Pointer m_UInt16Writer; Int32WriterType::Pointer m_Int32Writer; UInt32WriterType::Pointer m_UInt32Writer; FloatWriterType::Pointer m_FloatWriter; DoubleWriterType::Pointer m_DoubleWriter; VectorUInt8WriterType::Pointer m_VectorUInt8Writer; VectorInt16WriterType::Pointer m_VectorInt16Writer; VectorUInt16WriterType::Pointer m_VectorUInt16Writer; VectorInt32WriterType::Pointer m_VectorInt32Writer; VectorUInt32WriterType::Pointer m_VectorUInt32Writer; VectorFloatWriterType::Pointer m_VectorFloatWriter; VectorDoubleWriterType::Pointer m_VectorDoubleWriter; RGBUInt8WriterType::Pointer m_RGBUInt8Writer; RGBAUInt8WriterType::Pointer m_RGBAUInt8Writer; private: OutputImageParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented unsigned int m_RAMValue; }; // End class OutputImage Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputProcessXMLParameter.h000066400000000000000000000037631301006202600331560ustar00rootroot00000000000000#ifndef otbWrapperOutputProcessXMLParameter_h #define otbWrapperOutputProcessXMLParameter_h #include "otbWrapperApplication.h" #include "otb_tinyxml.h" namespace otb { namespace Wrapper { /** \class OutputProcessXMLParameter * \brief This class represent a xml filename parameter for the wrapper framework to save otb application. * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT OutputProcessXMLParameter : public Parameter { public: /** Standard class typedef */ typedef OutputProcessXMLParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(OutputProcessXMLParameter, Parameter); itkGetStringMacro(FileName); // Set FileName void SetFileName(std::string value) { this->SetValue(value); } // Set Value virtual void SetValue(const std::string value) { itkDebugMacro("setting member m_FileName to " << value); this->m_FileName = value; SetActive(true); this->Modified(); } bool HasValue() const ITK_OVERRIDE { if(m_FileName.empty()) return false; else return true; } void ClearValue() ITK_OVERRIDE { m_FileName = ""; } TiXmlElement* AddChildNodeTo(TiXmlElement* parent, std::string name, std::string value=""); std::string pixelTypeToString(ImagePixelType pixType); ParameterType GetParameterType(const Parameter* param) const; void Write(Application::Pointer application); protected: OutputProcessXMLParameter(); /** Destructor */ ~OutputProcessXMLParameter() ITK_OVERRIDE; private: std::string m_FileName; OutputProcessXMLParameter(const OutputProcessXMLParameter &); //purposely not implemented void operator =(const OutputProcessXMLParameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputVectorDataParameter.h000066400000000000000000000056601301006202600332110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperOutputVectorDataParameter_h #define otbWrapperOutputVectorDataParameter_h #include "otbWrapperParameter.h" #include "otbVectorData.h" #include "otbVectorDataFileWriter.h" namespace otb { namespace Wrapper { /** \class OutputVectorDataParameter * \brief This class represents a OutputVectorData parameter * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT OutputVectorDataParameter : public Parameter { public: /** Standard class typedef */ typedef OutputVectorDataParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(OutputVectorDataParameter, Parameter); /** Set the value */ itkSetObjectMacro(VectorData, VectorDataType); /** Get the value */ itkGetObjectMacro(VectorData, VectorDataType); /** Return true if a filename is set */ bool HasValue() const ITK_OVERRIDE { std::string filename(this->GetFileName()); return !filename.empty(); } /** Return any value */ void SetValue(VectorDataType* vd) { m_VectorData = vd; SetActive(true); } /** Return any value */ VectorDataType* GetValue( void ) { return m_VectorData; } void SetFileName (const char* filename) { m_FileName = filename; SetActive(true); } void SetFileName (const std::string& filename) { this->SetFileName(filename.c_str()); } itkGetStringMacro(FileName); void Write() { m_Writer->SetFileName(m_FileName); m_Writer->SetInput(m_VectorData); m_Writer->Update(); } itk::ProcessObject* GetWriter() { return m_Writer; } void InitializeWriters() { m_Writer = otb::VectorDataFileWriter::New(); } protected: /** Constructor */ OutputVectorDataParameter() { this->SetName("Output Vector Data"); this->SetKey("outvd"); } /** Destructor */ ~OutputVectorDataParameter() ITK_OVERRIDE {} VectorDataType::Pointer m_VectorData; std::string m_FileName; otb::VectorDataFileWriter::Pointer m_Writer; private: OutputVectorDataParameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented }; } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperParameter.h000066400000000000000000000160531301006202600300110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperParameter_h #define otbWrapperParameter_h #include "otbMacro.h" #include "itkObjectFactory.h" #include "otbWrapperTypes.h" #include "OTBApplicationEngineExport.h" namespace otb { namespace Wrapper { enum DefaultValueMode { /** * This parameter has no default behaviour and should be set by * the user. */ DefaultValueMode_UNKNOWN, /** * The default value of this parameter can be estimated from * other parameters. */ DefaultValueMode_RELATIVE, /** * The default value of this parameter is not depending on any * other parameter. */ DefaultValueMode_ABSOLUTE }; /** \class Parameter * \brief This class represent a parameter for the wrapper framework * This class is a high level class representing a parameter for the * wrapper framework. It should be subclassed to represent different * kinds of parameters * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT Parameter : public itk::Object { public: /** Standard class typedef */ typedef Parameter Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(Parameter, itk::Object); /** Set the parameter name */ itkSetStringMacro(Name); /** Get the parameter name */ itkGetStringMacro(Name); /** Set the parameter description */ itkSetStringMacro(Description); /** Get the parameter description */ itkGetStringMacro(Description); /** Set the parameter key */ itkSetStringMacro(Key); /** Get the parameter key */ itkGetStringMacro(Key); /** Set the parameter Active flag */ itkSetMacro(Active, bool); /** Get the parameter Active flag */ bool GetActive(bool recurseParents = false) const { bool result = m_Active; if (recurseParents && !IsRoot()) { result = result && GetRoot()->GetActive(recurseParents); } return result; } /** Set the parameter mandatory flag */ itkSetMacro(Mandatory, bool); /** Get the parameter mandatory flag */ itkGetConstMacro(Mandatory, bool); /** Toogle the parameter mandatory flag */ itkBooleanMacro(Mandatory); /** Set the parameter AutomaticValue flag */ itkSetMacro(AutomaticValue, bool); /** Get the parameter AutomaticValue flag */ itkGetConstMacro(AutomaticValue, bool); /** Toogle the parameter AutomaticValue flag */ itkBooleanMacro(AutomaticValue); /** Set the default value mode */ itkSetEnumMacro(DefaultValueMode, DefaultValueMode); /** Get the default value mode */ itkGetEnumMacro(DefaultValueMode, DefaultValueMode); /** Set the user access level */ itkSetEnumMacro(UserLevel, UserLevel); /** Get the user access level */ itkGetEnumMacro(UserLevel, UserLevel); /** Set the parameter io type*/ itkSetEnumMacro(Role, Role); /** Get the user access level */ itkGetEnumMacro(Role, Role); /** Reset to the the default value. Default implementation does * nothing */ virtual void Reset() { } virtual bool HasValue() const { itkExceptionMacro(<<"HasValue() method must be re-implemented by sub-classes."); } virtual bool HasUserValue() const { return HasValue() && m_UserValue; } virtual void SetUserValue(bool isUserValue) { m_UserValue = isUserValue; } virtual void ClearValue() { itkExceptionMacro(<<"ClearValue() method must be re-implemented by sub-classes."); } /** Set/Get the root of the current parameter (direct parent) */ virtual void SetRoot(const Parameter::Pointer root) { m_Root = root.GetPointer(); } virtual const Parameter::Pointer GetRoot() const { return m_Root.GetPointer(); } /** Is the parameter a root or a child of another param */ virtual bool IsRoot() const { return (this == m_Root.GetPointer()); } /** Add a child of this parameter when the param is a Group or a * choice */ virtual void AddChild(Parameter::Pointer child) { m_ChildrenList.push_back(child); } /** Get the children pointer list : not const cause we need to * alterate the m_Active status and the m_IsCheckbox */ virtual std::vector GetChildrenList() { return m_ChildrenList; } /** Store the state of the check box relative to this parameter (TO * BE MOVED to QtWrapper Model ) */ virtual bool IsChecked() { return m_IsChecked; } /** Modify the state of the checkbox relative to this parameter */ virtual void SetChecked(const bool value) { m_IsChecked = value; } protected: /** Constructor */ Parameter() : m_Name(""), m_Description(""), m_Key(""), m_Mandatory(true), m_Active(false), m_UserValue(false), m_AutomaticValue(false), m_DefaultValueMode(DefaultValueMode_UNKNOWN), m_UserLevel(UserLevel_Basic), m_Role(Role_Input), m_Root(this), m_IsChecked(false) {} /** Destructor */ ~Parameter() ITK_OVERRIDE {} /** Name of the parameter */ std::string m_Name; /** Description of the parameter */ std::string m_Description; /** Key of the parameter */ std::string m_Key; /** True if the parameter is mandatory */ bool m_Mandatory; /** True if activated (a mandatory parameter is always active) */ bool m_Active; /** True if the value is set in user mode */ bool m_UserValue; /** True if the application change the value of this parameter */ bool m_AutomaticValue; /** Default value behaviour */ DefaultValueMode m_DefaultValueMode; UserLevel m_UserLevel; /** Default iotype mode */ Role m_Role; /** List of parents Parameters */ itk::WeakPointer m_Root; /** List of children parameters */ std::vector m_ChildrenList; /** Store the status of the checkbox */ bool m_IsChecked; private: Parameter(const Parameter &); //purposely not implemented void operator =(const Parameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperParameterGroup.h000066400000000000000000000057221301006202600310270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperParameterGroup_h #define otbWrapperParameterGroup_h #include "itkObject.h" #include "otbWrapperParameter.h" #include namespace otb { namespace Wrapper { /** * \class Group * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ParameterGroup : public Parameter { public: typedef ParameterGroup Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkNewMacro(Self); itkTypeMacro(ParameterList, Parameter); void AddParameter(Parameter::Pointer p); /** Add a new choice value to an existing choice parameter */ void AddChoice(std::string paramKey, std::string paramName); /** Remove choices made in ListViewParameter widget*/ void ClearChoices(std::string paramKey); /** Get the choices made in a ListView Parameter widget*/ std::vector GetSelectedItems(std::string paramKey); /** Add a new parameter to the parameter group * the parent key of paramKey can be the path to a parameter group * or the path to a choice value */ void AddParameter(ParameterType type, std::string paramKey, std::string paramName); Parameter::Pointer GetParameterByIndex(unsigned int i); Parameter::Pointer GetParameterByKey(std::string name); /** rashad: Add xml parameters eg: -inxml -outxml */ void AddInXMLParameter(); void AddOutXMLParameter(); void Clear() { m_ParameterList.clear(); } /** Get the parameter type as string from its ParameterType enum * For example if type of parameter is ParameterType_InputImage this * function return the string InputImage */ std::string GetParameterTypeAsString(ParameterType paramType); /* Get the parameter type from its string version of ParameterType enum */ ParameterType GetParameterTypeFromString(std::string paramType); unsigned int GetNumberOfParameters(); std::vector GetParametersKeys(bool recursive = true); // Always has value bool HasValue() const ITK_OVERRIDE { return true; } protected: ParameterGroup(); ~ParameterGroup() ITK_OVERRIDE; typedef std::vector ParameterListType; ParameterListType m_ParameterList; private: ParameterGroup(const ParameterGroup &); //purposely not implemented void operator =(const ParameterGroup&); //purposely not implemented }; } } #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperParameterKey.h000066400000000000000000000060451301006202600304620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperParameterKey_h #define otbWrapperParameterKey_h #include #include #include #include #include "itkMacro.h" #include "OTBApplicationEngineExport.h" namespace otb { namespace Wrapper { /** \class Application * \brief This class is a the Parameter key representation. * * The constructor accepts a string key constructed as follow : parent.me.child. * It implements some key manipulation as described in the code. * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT ParameterKey { public: typedef ParameterKey Self; ParameterKey(); ParameterKey( const char * val ); ParameterKey( const std::string & val ); virtual ~ParameterKey(); /** Class Methods used to interface with the registered factories */ /* last() : return "tata" ** parent() : return "toto.titi" ** root() : return "toto" ** split() : return vector ("toto", "titi", "tata") ** append(std::string) ** append(const Key&) */ /** Returns the string after the last point separator */ std::string GetLastElement(); /** Returns the string before the first point separator */ std::string GetFirstElement(); /** Returns the string before the last point separator */ std::string GetRoot(); /** Returns the vector of string that contains each element separated by a point. */ std::vector Split(); /** Append a string at the end of the key. A point separator will be added before the string. */ void Append( const std::string & val ); /** Append a string at the end of the key. A point separator will be added before the string. */ void Append( const ParameterKey & pKey ); /** Get Key value */ std::string GetKey() { return m_Key; } /** Get Key value */ std::string GetKey() const { return m_Key; } /** Set Key value */ void SetKey( const std::string & val ) { // Check chain : lowercase, alphanumerical or "." itksys::RegularExpression reg; reg.compile("([^0-9a-z\\.])"); if(!reg.find(val)) { m_Key = val; } else { itkGenericExceptionMacro( "Invalid key "< Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(RAMParameter, Parameter); /** typedef */ typedef NumericalParameter UnsignedIntParameter; typedef UnsignedIntParameter::ScalarType ScalarType; bool HasValue() const ITK_OVERRIDE { return m_UnsignedIntParam->HasValue(); } // Set/Get Value otbSetObjectMemberMacro(UnsignedIntParam, Value , ScalarType); otbSetObjectMemberMacro(UnsignedIntParam, Value , std::string); otbGetObjectMemberMacro(UnsignedIntParam, Value , ScalarType); // Set/Get extremums otbSetObjectMemberMacro(UnsignedIntParam, DefaultValue, ScalarType); otbGetObjectMemberMacro(UnsignedIntParam, DefaultValue, ScalarType); otbSetObjectMemberMacro(UnsignedIntParam, MinimumValue, ScalarType); otbGetObjectMemberMacro(UnsignedIntParam, MinimumValue, ScalarType); otbSetObjectMemberMacro(UnsignedIntParam, MaximumValue, ScalarType); otbGetObjectMemberMacro(UnsignedIntParam, MaximumValue, ScalarType); // Clear Value void ClearValue() ITK_OVERRIDE { m_UnsignedIntParam->ClearValue(); } // Reset void Reset() ITK_OVERRIDE { m_UnsignedIntParam->Reset(); } // Reimplement the SetActive method void SetActive( const bool value ) ITK_OVERRIDE { Superclass::SetActive( value ); m_UnsignedIntParam->SetActive( value ); } otbGetObjectMemberConstMacro(UnsignedIntParam, Active, bool); protected: /** Constructor */ RAMParameter() { this->SetName("RAM"); this->SetDescription("Set the maximum of available memory for the pipeline execution in mega bytes (optional, 256 by default)."); this->SetKey("ram"); // Initialize the unsigned int NumericalParam m_UnsignedIntParam = UnsignedIntParameter::New(); // 0 RAM is not allowed, make the minimum to 1 by default this->SetMinimumValue(1); } /** Destructor */ ~RAMParameter() ITK_OVERRIDE {} private: RAMParameter(const RAMParameter &); //purposely not implemented void operator =(const RAMParameter&); //purposely not implemented UnsignedIntParameter::Pointer m_UnsignedIntParam; }; } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperRadiusParameter.h000066400000000000000000000034171301006202600311610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperRadiusParameter_h #define otbWrapperRadiusParameter_h #include "otbWrapperNumericalParameter.h" namespace otb { namespace Wrapper { /** \class StringParameter * \brief This class represent a radius parameter for the wrapper framework * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT RadiusParameter : public IntParameter { public: /** Standard class typedef */ typedef RadiusParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(RadiusParameter, Parameter); bool HasValue() const ITK_OVERRIDE { return true; } protected: /** Constructor */ RadiusParameter() { this->SetName("Radius"); this->SetKey("r"); this->SetDescription("Radius in pixels"); } /** Destructor */ ~RadiusParameter() ITK_OVERRIDE {} private: RadiusParameter(const RadiusParameter &); //purposely not implemented void operator =(const RadiusParameter&); //purposely not implemented }; } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperStringListParameter.h000066400000000000000000000057731301006202600320430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperStringListParameter_h #define otbWrapperStringListParameter_h #include #include "otbWrapperParameter.h" namespace otb { namespace Wrapper { /** \class StringListParameter * \brief This class represent a list of string parameter for the wrapper framework * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT StringListParameter : public Parameter { public: /** Standard class typedef */ typedef StringListParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; typedef std::vector StringListType; /** Defining ::New() static method */ itkNewMacro(Self) ; /** RTTI support */ itkTypeMacro(StringListParameter, Parameter) ; /** Set the value */ void SetValue(StringListType sList) { m_Value.clear(); for(unsigned int i=0; iAddString(sList[i]); } } void AddString(std::string value) { if(!value.empty()) { m_Value.push_back(value); if(!this->GetActive()) { this->SetActive(true); } } } /** Get the value */ StringListType GetValue() const { return m_Value; } /** Get the value */ std::string GetNthElement(unsigned int i) const { if (m_Value.size() < i) { itkExceptionMacro( "Invalid index "<Modified(); } protected: /** Constructor */ StringListParameter() { this->SetName("String List"); this->SetKey("strList"); } /** Destructor */ ~StringListParameter() ITK_OVERRIDE { } StringListType m_Value; private: StringListParameter(const StringListParameter &); //purposely not implemented void operator =(const StringListParameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperStringParameter.h000066400000000000000000000037511301006202600312010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperStringParameter_h #define otbWrapperStringParameter_h #include #include "otbWrapperParameter.h" namespace otb { namespace Wrapper { /** \class StringParameter * \brief This class represent a string parameter for the wrapper framework * * \ingroup OTBApplicationEngine */ class OTBApplicationEngine_EXPORT StringParameter : public Parameter { public: /** Standard class typedef */ typedef StringParameter Self; typedef Parameter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(StringParameter, Parameter); /** Set the value */ void SetValue( std::string value) { m_Value = value; SetActive(true); } /** Get the value */ std::string GetValue() const { return m_Value; } bool HasValue() const ITK_OVERRIDE { return !m_Value.empty(); } void ClearValue() ITK_OVERRIDE { m_Value = ""; } protected: /** Constructor */ StringParameter() {} /** Destructor */ ~StringParameter() ITK_OVERRIDE {} std::string m_Value; private: StringParameter(const StringParameter &); //purposely not implemented void operator =(const StringParameter&); //purposely not implemented }; // End class Parameter } // End namespace Wrapper } // End namespace otb #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperTags.h000066400000000000000000000033621301006202600267660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperTags_h #define otbWrapperTags_h #include namespace otb { namespace Wrapper { namespace Tags { static const std::string Analysis="Image Analysis"; static const std::string Calibration="Calibration"; static const std::string ChangeDetection="Change Detection"; static const std::string Coordinates="Coordinates"; static const std::string DimensionReduction="Dimensionality Reduction"; static const std::string FeatureExtraction="Feature Extraction"; static const std::string Filter="Image Filtering"; static const std::string Geometry="Geometry"; static const std::string Hyperspectral="Hyperspectral"; static const std::string Learning="Learning"; static const std::string Manip="Image Manipulation"; static const std::string Meta="Image MetaData"; static const std::string Multi="Image MultiResolution"; static const std::string Pansharpening="Pansharpening"; static const std::string Raster="Raster"; static const std::string SAR="SAR"; static const std::string Stereo="Stereo"; static const std::string Segmentation="Segmentation"; static const std::string Vector="Vector Data Manipulation"; } // end namespace Wrappers } // end namespace Tags } // end namespace otb #endif // otbWrapperTags_h_ OTB-release-5.8/Modules/Wrappers/ApplicationEngine/include/otbWrapperTypes.h000066400000000000000000000101111301006202600271620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperTypes_h #define otbWrapperTypes_h #include #include "itkRGBPixel.h" #include "itkRGBAPixel.h" #include "otbImage.h" #include "otbVectorImage.h" #include "otbVectorData.h" namespace otb { namespace Wrapper { typedef enum { ParameterType_Empty, ParameterType_Int, ParameterType_Float, ParameterType_String, ParameterType_StringList, ParameterType_InputFilename, ParameterType_InputFilenameList, ParameterType_OutputFilename, ParameterType_Directory, ParameterType_Choice, ParameterType_InputImage, ParameterType_InputImageList, ParameterType_InputVectorData, ParameterType_InputVectorDataList, ParameterType_OutputImage, ParameterType_OutputVectorData, ParameterType_Radius, ParameterType_Group, ParameterType_ListView, ParameterType_ComplexInputImage, ParameterType_ComplexOutputImage, ParameterType_RAM, ParameterType_OutputProcessXML, ParameterType_InputProcessXML } ParameterType; typedef enum { UserLevel_Basic, UserLevel_Advanced } UserLevel; typedef enum { // Not int8 because not handle by Gdal ImagePixelType_uint8, ImagePixelType_int16, ImagePixelType_uint16, ImagePixelType_int32, ImagePixelType_uint32, ImagePixelType_float, ImagePixelType_double, } ImagePixelType; typedef enum { ComplexImagePixelType_float, ComplexImagePixelType_double, } ComplexImagePixelType; typedef enum { Role_Input, Role_Output } Role; // enum used for the map projection choices typedef enum { Elevation_DEM, Elevation_Average //Elevation_Tiff, } ElevationType; typedef otb::Image UInt8ImageType; typedef otb::Image Int16ImageType; typedef otb::Image UInt16ImageType; typedef otb::Image Int32ImageType; typedef otb::Image UInt32ImageType; typedef otb::Image FloatImageType; typedef otb::Image DoubleImageType; typedef otb::VectorImage UInt8VectorImageType; typedef otb::VectorImage Int16VectorImageType; typedef otb::VectorImage UInt16VectorImageType; typedef otb::VectorImage Int32VectorImageType; typedef otb::VectorImage UInt32VectorImageType; typedef otb::VectorImage FloatVectorImageType; typedef otb::VectorImage DoubleVectorImageType; typedef otb::Image< itk::RGBPixel > UInt8RGBImageType; typedef otb::Image< itk::RGBAPixel > UInt8RGBAImageType; typedef std::complex FloatComplexPixelType; typedef std::complex DoubleComplexPixelType; // Complex Image Type (first : double and float) typedef otb::Image< FloatComplexPixelType, 2 > ComplexFloatImageType; typedef otb::Image< DoubleComplexPixelType, 2 > ComplexDoubleImageType; typedef otb::VectorImage ComplexFloatVectorImageType; typedef otb::VectorImage< DoubleComplexPixelType, 2 > ComplexDoubleVectorImageType; typedef double VectorDataCoordinatePrecisionType; typedef double VectorDataValuePrecisionType; typedef otb::VectorData VectorDataType; typedef otb::ObjectList VectorDataListType; typedef otb::ObjectList FloatVectorImageListType; typedef otb::ObjectList FloatImageListType; } // end namespace Wrapper } // end namespace otb #endif // otbWrapperApplication_h_ OTB-release-5.8/Modules/Wrappers/ApplicationEngine/otb-module.cmake000066400000000000000000000012351301006202600252740ustar00rootroot00000000000000set(DOCUMENTATION "This module contains classes that ease the implementation of applications (see chapter 'How to write an application' of the SoftwareGuide).") otb_module(OTBApplicationEngine ENABLE_SHARED DEPENDS OTBVectorDataBase OTBImageIO OTBProjection OTBVectorDataIO OTBTransform OTBImageManipulation OTBTinyXML OTBImageBase OTBCommon OTBObjectList OTBBoostAdapters OTBOSSIMAdapters OTBITK OPTIONAL_DEPENDS OTBMPIVrtWriter OTBMPITiffWriter TEST_DEPENDS OTBTestKernel OTBCommandLine OTBEdge OTBAppImageUtils OTBAppFiltering DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/000077500000000000000000000000001301006202600230115ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/CMakeLists.txt000066400000000000000000000032651301006202600255570ustar00rootroot00000000000000set(OTBApplicationEngine_SRC otbWrapperApplicationHtmlDocGenerator.cxx otbWrapperComplexOutputImageParameter.cxx otbWrapperInputVectorDataListParameter.cxx otbWrapperListViewParameter.cxx otbWrapperComplexInputImageParameter.cxx otbWrapperParameterGroup.cxx otbWrapperOutputProcessXMLParameter.cxx otbWrapperInputImageListParameter.cxx otbWrapperElevationParametersHandler.cxx otbWrapperInputFilenameListParameter.cxx otbWrapperOutputImageParameter.cxx otbWrapperInputImageParameter.cxx otbWrapperInputImageParameterUInt8.cxx otbWrapperInputImageParameterInt16.cxx otbWrapperInputImageParameterUInt16.cxx otbWrapperInputImageParameterInt32.cxx otbWrapperInputImageParameterUInt32.cxx otbWrapperInputImageParameterFloat.cxx otbWrapperInputImageParameterDouble.cxx otbWrapperParameterKey.cxx otbWrapperDocExampleStructure.cxx otbWrapperInputVectorDataParameter.cxx otbWrapperInputProcessXMLParameter.cxx otbWrapperMapProjectionParametersHandler.cxx otbWrapperApplication.cxx otbWrapperChoiceParameter.cxx otbWrapperApplicationRegistry.cxx otbWrapperApplicationFactoryBase.cxx ) add_library(OTBApplicationEngine ${OTBApplicationEngine_SRC}) target_link_libraries(OTBApplicationEngine ${OTBVectorDataBase_LIBRARIES} ${OTBImageManipulation_LIBRARIES} ${OTBImageIO_LIBRARIES} ${OTBProjection_LIBRARIES} ${OTBTinyXML_LIBRARIES} ${OTBVectorDataIO_LIBRARIES} ${OTBTransform_LIBRARIES} ${OTBCommon_LIBRARIES} ${OTBImageBase_LIBRARIES} ${OTBBoost_LIBRARIES} ${OTBOSSIMAdapters_LIBRARIES} ${OTBMPI_LIBRARIES} ${OTBMPIConfig_LIBRARIES} ${OTBMPITiffWriter_LIBRARIES} ${OTBMPIVrtWriter_LIBRARIES} ) otb_module_target(OTBApplicationEngine) OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperApplication.cxx000066400000000000000000001374741301006202600300660ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperChoiceParameter.h" #include "otbWrapperListViewParameter.h" #include "otbWrapperDirectoryParameter.h" #include "otbWrapperEmptyParameter.h" #include "otbWrapperInputFilenameParameter.h" #include "otbWrapperInputFilenameListParameter.h" #include "otbWrapperOutputFilenameParameter.h" #include "otbWrapperOutputProcessXMLParameter.h" #include "otbWrapperInputVectorDataParameter.h" #include "otbWrapperInputVectorDataListParameter.h" #include "otbWrapperOutputVectorDataParameter.h" #include "otbWrapperRadiusParameter.h" #include "otbWrapperStringListParameter.h" #include "otbWrapperInputImageListParameter.h" #include "otbWrapperInputProcessXMLParameter.h" #include "otbWrapperRAMParameter.h" #include "otbWrapperAddProcessToWatchEvent.h" #include "otbMacro.h" #include "otbWrapperTypes.h" #include #include "itkMacro.h" namespace otb { namespace Wrapper { Application::Application() : m_Name(""), m_Description(""), m_Logger(itk::Logger::New()), m_ProgressSourceDescription(""), m_DocName(""), m_DocLongDescription(""), m_DocAuthors(""), m_DocLimitations(""), m_DocSeeAlso(""), m_DocTags(), m_HaveInXML(true), m_HaveOutXML(true), m_IsInXMLParsed(false) { // Don't call Init from the constructor, since it calls a virtual method ! m_Logger->SetName("Application.logger"); m_Logger->SetPriorityLevel(itk::LoggerBase::DEBUG); m_Logger->SetLevelForFlushing(itk::LoggerBase::CRITICAL); } Application::~Application() { } itk::Logger* Application::GetLogger() { return m_Logger; } std::vector Application::GetParametersKeys(bool recursive) { return GetParameterList()->GetParametersKeys(recursive); } bool Application::IsInitialized() const { return m_ParameterList.IsNotNull() && m_DocExample.IsNotNull(); } ParameterGroup* Application::GetParameterList() { if (!IsInitialized()) { Init(); } return m_ParameterList; } Parameter* Application::GetParameterByKey(std::string name) { return GetParameterList()->GetParameterByKey(name); } void Application::SetParameterInt(std::string parameter, int value, bool hasUserValueFlag) { this->SetParameterInt(parameter, value); this->SetParameterUserValue(parameter, hasUserValueFlag); } void Application::SetParameterFloat(std::string parameter, float value, bool hasUserValueFlag) { this->SetParameterFloat(parameter, value); this->SetParameterUserValue(parameter, hasUserValueFlag); } void Application::SetParameterString(std::string parameter, std::string value, bool hasUserValueFlag) { this->SetParameterString(parameter, value); this->SetParameterUserValue(parameter, hasUserValueFlag); } void Application::SetParameterStringList(std::string parameter, std::vector values, bool hasUserValueFlag) { this->SetParameterStringList(parameter, values); this->SetParameterUserValue(parameter, hasUserValueFlag); } void Application::SetParameterEmpty(std::string parameter, bool value, bool hasUserValueFlag) { this->SetParameterEmpty(parameter, value); this->SetParameterUserValue(parameter, hasUserValueFlag); } void Application::SetParameterUserValue(std::string paramKey, bool value) { /** UserValue is set/unset parameter must be active. Can't set the m_Active flg in Parameter::SetUserValue() instead of using Application::EnableParameter(); **/ EnableParameter(paramKey); GetParameterByKey(paramKey)->SetUserValue(value); } const Parameter* Application::GetParameterByKey(std::string name) const { // GetParameterList is non const... Application* _this = const_cast(this); return _this->GetParameterByKey(name); } void Application::Init() { m_DocExample = DocExampleStructure::New(); m_ParameterList = ParameterGroup::New(); //reset inXML parse checker in case if reinit-ing m_IsInXMLParsed = false; this->DoInit(); //rashad: global parameters. now used only for inxml and outxml if(this->GetHaveInXML()) { AddInXMLParameter(); } if(this->GetHaveOutXML()) { AddOutXMLParameter(); } } void Application::UpdateParameters() { //read application from xml only once m_IsInXMLParsed is in charge of it. std::string inXMLKey = "inxml"; if (m_HaveInXML && !m_IsInXMLParsed) { if ( GetParameterType(inXMLKey) == ParameterType_InputProcessXML && IsParameterEnabled(inXMLKey) && HasValue(inXMLKey) ) { Parameter* param = GetParameterByKey(inXMLKey); InputProcessXMLParameter* inXMLParam = dynamic_cast(param); if(inXMLParam!=ITK_NULLPTR) { inXMLParam->Read(this); m_IsInXMLParsed = true; } } } this->DoUpdateParameters(); } void Application::AfterExecuteAndWriteOutputs() {} int Application::Execute() { this->UpdateParameters(); // before execute we set the seed of mersenne twister std::vector paramList = GetParametersKeys(true); bool UseSpecificSeed = false; for (std::vector::const_iterator it = paramList.begin(); it != paramList.end(); ++it) { std::string key = *it; if ((key.compare(0, 4, "rand") == 0) && HasValue("rand")) { UseSpecificSeed = true; Parameter* param = GetParameterByKey(key); IntParameter* randParam = dynamic_cast (param); if(randParam!=ITK_NULLPTR) { int seed = randParam->GetValue(); itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->SetSeed(seed); } } } if (!UseSpecificSeed) { itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->Initialize(); } this->DoExecute(); return 0; } int Application::ExecuteAndWriteOutput() { int status = this->Execute(); if (status == 0) { std::vector paramList = GetParametersKeys(true); // First Get the value of the available memory to use with the // writer if a RAMParameter is set bool useRAM = false; unsigned int ram = 0; for (std::vector::const_iterator it = paramList.begin(); it != paramList.end(); ++it) { std::string key = *it; if (GetParameterType(key) == ParameterType_RAM && IsParameterEnabled(key)) { Parameter* param = GetParameterByKey(key); RAMParameter* ramParam = dynamic_cast(param); if(ramParam!=ITK_NULLPTR) { ram = ramParam->GetValue(); useRAM = true; } } } for (std::vector::const_iterator it = paramList.begin(); it != paramList.end(); ++it) { std::string key = *it; if (GetParameterType(key) == ParameterType_OutputImage && IsParameterEnabled(key) && HasValue(key) ) { Parameter* param = GetParameterByKey(key); OutputImageParameter* outputParam = dynamic_cast(param); if(outputParam!=ITK_NULLPTR) { outputParam->InitializeWriters(); if (useRAM) { outputParam->SetRAMValue(ram); } std::ostringstream progressId; progressId << "Writing " << outputParam->GetFileName() << "..."; AddProcess(outputParam->GetWriter(), progressId.str()); outputParam->Write(); } } else if (GetParameterType(key) == ParameterType_OutputVectorData && IsParameterEnabled(key) && HasValue(key) ) { Parameter* param = GetParameterByKey(key); OutputVectorDataParameter* outputParam = dynamic_cast(param); if(outputParam!=ITK_NULLPTR) { outputParam->InitializeWriters(); std::ostringstream progressId; progressId << "Writing " << outputParam->GetFileName() << "..."; AddProcess(outputParam->GetWriter(), progressId.str()); outputParam->Write(); } } else if (GetParameterType(key) == ParameterType_ComplexOutputImage && IsParameterEnabled(key) && HasValue(key) ) { Parameter* param = GetParameterByKey(key); ComplexOutputImageParameter* outputParam = dynamic_cast(param); if(outputParam!=ITK_NULLPTR) { outputParam->InitializeWriters(); if (useRAM) { outputParam->SetRAMValue(ram); } std::ostringstream progressId; progressId << "Writing " << outputParam->GetFileName() << "..."; AddProcess(outputParam->GetWriter(), progressId.str()); outputParam->Write(); } } //xml writer parameter else if (m_HaveOutXML && GetParameterType(key) == ParameterType_OutputProcessXML && IsParameterEnabled(key) && HasValue(key) ) { Parameter* param = GetParameterByKey(key); OutputProcessXMLParameter* outXMLParam = dynamic_cast(param); if(outXMLParam!=ITK_NULLPTR) { outXMLParam->Write(this); } } } } this->AfterExecuteAndWriteOutputs(); return status; } /* Enable the use of an optional parameter. Returns the previous state */ void Application::EnableParameter(std::string paramKey) { Parameter* param = GetParameterByKey(paramKey); param->SetActive(true); } /* Disable the use of an optional parameter. Returns the previous state */ void Application::DisableParameter(std::string paramKey) { GetParameterByKey(paramKey)->SetActive(false); } /* Return the enable state of an optional parameter */ bool Application::IsParameterEnabled(std::string paramKey, bool recurseParents) const { return GetParameterByKey(paramKey)->GetActive(recurseParents); } /* Return true if the specified parameter is mandatory */ bool Application::IsMandatory(std::string paramKey) const { return GetParameterByKey(paramKey)->GetMandatory(); } void Application::MandatoryOn(std::string paramKey) { GetParameterByKey(paramKey)->SetMandatory(true); } void Application::MandatoryOff(std::string paramKey) { GetParameterByKey(paramKey)->SetMandatory(false); } /* Return true if the specified parameter was set automatically in the * application */ bool Application::HasAutomaticValue(std::string paramKey) const { return GetParameterByKey(paramKey)->GetAutomaticValue(); } void Application::AutomaticValueOn(std::string paramKey) { GetParameterByKey(paramKey)->SetAutomaticValue(true); } void Application::AutomaticValueOff(std::string paramKey) { GetParameterByKey(paramKey)->SetAutomaticValue(false); } /* Returns true if the parameter has an associated value provided externally * (not automatically computed by the application) */ bool Application::HasUserValue(std::string paramKey) const { return GetParameterByKey(paramKey)->HasUserValue(); } /* If a user value was provided clear it and update the other parameters */ void Application::ClearValue(std::string paramKey) { GetParameterByKey(paramKey)->ClearValue(); } /* Returns true if the parameter has an associated value. * This value can be an automatically computed value or default value, * or a value set externally by user */ bool Application::HasValue(std::string paramKey) const { return GetParameterByKey(paramKey)->HasValue(); } /* Return the user level of access to a parameter */ UserLevel Application::GetParameterUserLevel(std::string paramKey) const { return GetParameterByKey(paramKey)->GetUserLevel(); } /* Return the role (input/output) of a parameter */ Role Application::GetParameterRole(std::string paramKey) const { return GetParameterByKey(paramKey)->GetRole(); } void Application::SetParameterEmpty(std::string paramKey, bool active) { GetParameterByKey(paramKey)->SetActive(active); } bool Application::GetParameterEmpty(std::string paramKey) { return GetParameterByKey(paramKey)->GetActive(); } /* Return the role (input/output) of a parameter */ void Application::SetParameterRole(std::string paramKey, Role role) { GetParameterByKey(paramKey)->SetRole(role); } /* Get the parameter type from its name */ ParameterType Application::GetParameterType(std::string paramKey) const { const Parameter* param = GetParameterByKey(paramKey); ParameterType type; if (dynamic_cast(param)) { type = ParameterType_Choice; } else if (dynamic_cast(param)) { type = ParameterType_ListView; } else if (dynamic_cast(param)) { type = ParameterType_Radius; } else if (dynamic_cast(param)) { type = ParameterType_Empty; } else if (dynamic_cast(param)) { type = ParameterType_Int; } else if (dynamic_cast(param)) { type = ParameterType_Float; } else if (dynamic_cast(param)) { type = ParameterType_InputFilename; } else if (dynamic_cast(param)) { type = ParameterType_InputFilenameList; } else if (dynamic_cast(param)) { type = ParameterType_OutputFilename; } else if (dynamic_cast(param)) { type = ParameterType_Directory; } else if (dynamic_cast(param)) { type = ParameterType_InputImage; } else if (dynamic_cast(param)) { type = ParameterType_InputImageList; } else if (dynamic_cast(param)) { type = ParameterType_ComplexInputImage; } else if (dynamic_cast(param)) { type = ParameterType_InputVectorData; } else if (dynamic_cast(param)) { type = ParameterType_InputVectorDataList; } else if (dynamic_cast(param)) { type = ParameterType_OutputImage; } else if (dynamic_cast(param)) { type = ParameterType_ComplexOutputImage; } else if (dynamic_cast(param)) { type = ParameterType_OutputVectorData; } else if (dynamic_cast(param)) { type = ParameterType_String; } else if (dynamic_cast(param)) { type = ParameterType_StringList; } else if (dynamic_cast(param)) { type = ParameterType_RAM; } else if (dynamic_cast(param)) { type = ParameterType_Group; } else if (dynamic_cast(param)) { type = ParameterType_OutputProcessXML; } else if (dynamic_cast(param)) { type = ParameterType_InputProcessXML; } else { itkExceptionMacro(<< "Unknown parameter : " << paramKey); } return type; } std::vector Application::GetChoiceKeys(std::string name) { Parameter* param = GetParameterByKey(name); if (dynamic_cast(param)) { ChoiceParameter* paramChoice = dynamic_cast(param); return paramChoice->GetChoiceKeys(); } else if (dynamic_cast(param)) { ListViewParameter* paramList = dynamic_cast(param); return paramList->GetChoiceKeys(); } itkExceptionMacro(<< name << " is not a choice parameter"); } std::vector Application::GetChoiceNames(std::string name) { Parameter* param = GetParameterByKey(name); if (dynamic_cast(param)) { ChoiceParameter* paramChoice = dynamic_cast(param); return paramChoice->GetChoiceNames(); } else if (dynamic_cast(param)) { ListViewParameter* paramList = dynamic_cast(param); return paramList->GetChoiceNames(); } itkExceptionMacro(<< name << " is not a choice parameter"); } void Application::SetParameterInt(std::string parameter, int value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { IntParameter* paramInt = dynamic_cast(param); paramInt->SetValue(value); } else if (dynamic_cast(param)) { FloatParameter* paramFloat = dynamic_cast(param); paramFloat->SetValue(static_cast(value)); } else if (dynamic_cast(param)) { RadiusParameter* paramRadius = dynamic_cast(param); paramRadius->SetValue(static_cast(value)); } else if (dynamic_cast(param)) { ChoiceParameter* paramChoice = dynamic_cast(param); paramChoice->SetValue(value); } } void Application::SetParameterFloat(std::string parameter, float value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { FloatParameter* paramFloat = dynamic_cast(param); paramFloat->SetValue(value); } } void Application::SetDefaultParameterInt(std::string parameter, int value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { RadiusParameter* paramRadius = dynamic_cast(param); paramRadius->SetDefaultValue(value); paramRadius->SetValue(value); } else if (dynamic_cast(param)) { IntParameter* paramInt = dynamic_cast(param); paramInt->SetDefaultValue(value); paramInt->SetValue(value); } else if (dynamic_cast(param)) { FloatParameter* paramFloat = dynamic_cast(param); paramFloat->SetDefaultValue(static_cast(value)); paramFloat->SetValue(static_cast(value)); } else if (dynamic_cast(param)) { RAMParameter* paramRAM = dynamic_cast(param); paramRAM->SetDefaultValue(static_cast(value)); paramRAM->SetValue(static_cast(value)); } } void Application::SetDefaultParameterFloat(std::string parameter, float value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { FloatParameter* paramFloat = dynamic_cast(param); paramFloat->SetDefaultValue(value); paramFloat->SetValue(value); } } void Application::SetDefaultOutputPixelType(std::string parameter, ImagePixelType type) { Parameter* param = GetParameterByKey(parameter); OutputImageParameter* paramDown = dynamic_cast(param); if (paramDown) { paramDown->SetDefaultPixelType(type); paramDown->SetPixelType(type); } } void Application::SetDefaultOutputComplexPixelType(std::string parameter, ComplexImagePixelType type) { Parameter* param = GetParameterByKey(parameter); ComplexOutputImageParameter* paramDown = dynamic_cast(param); if (paramDown) { paramDown->SetDefaultComplexPixelType(type); paramDown->SetComplexPixelType(type); } } void Application::SetMinimumParameterIntValue(std::string parameter, int value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { IntParameter* paramInt = dynamic_cast(param); paramInt->SetMinimumValue(value); } else itkExceptionMacro(<(param)) { IntParameter* paramInt = dynamic_cast(param); paramInt->SetMaximumValue(value); } else itkExceptionMacro(<(param)) { FloatParameter* paramFloat = dynamic_cast(param); paramFloat->SetMinimumValue(value); } else itkExceptionMacro(<(param)) { FloatParameter* paramFloat = dynamic_cast(param); paramFloat->SetMaximumValue(value); } else itkExceptionMacro(<(param)) { ChoiceParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { ListViewParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { StringParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { InputFilenameParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { OutputFilenameParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { DirectoryParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { FloatParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { RadiusParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { IntParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { InputImageParameter* paramDown = dynamic_cast(param); if ( !paramDown->SetFromFileName(value) ) otbAppLogCRITICAL( <<"Invalid image filename " << value <<"."); } else if (dynamic_cast(param)) { ComplexInputImageParameter* paramDown = dynamic_cast(param); paramDown->SetFromFileName(value); } else if (dynamic_cast(param)) { InputVectorDataParameter* paramDown = dynamic_cast(param); if ( !paramDown->SetFromFileName(value) ) otbAppLogCRITICAL( <<"Invalid vector data filename " << value <<"."); } else if (dynamic_cast(param)) { OutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetFileName(value); } else if (dynamic_cast(param)) { ComplexOutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetFileName(value); } else if (dynamic_cast(param)) { OutputVectorDataParameter* paramDown = dynamic_cast(param); paramDown->SetFileName(value); } else if (dynamic_cast(param)) { RAMParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { OutputProcessXMLParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if (dynamic_cast(param)) { InputProcessXMLParameter* paramDown = dynamic_cast(param); if ( !paramDown->SetFileName(value) ) otbAppLogCRITICAL( <<"Invalid XML parameter filename " << value <<"."); } } void Application::SetParameterStringList(std::string parameter, std::vector value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { InputImageListParameter* paramDown = dynamic_cast(param); if( !paramDown->SetListFromFileName(value) ) otbAppLogCRITICAL( <<"At least one image filename is invalid."); } else if (dynamic_cast(param)) { InputVectorDataListParameter* paramDown = dynamic_cast(param); if( !paramDown->SetListFromFileName(value) ) otbAppLogCRITICAL( <<"At least one vector data filename is invalid.."); } else if (dynamic_cast(param)) { InputFilenameListParameter* paramDown = dynamic_cast(param); if( !paramDown->SetListFromFileName(value) ) otbAppLogCRITICAL( <<"At least one filename is invalid.."); } else if (dynamic_cast(param)) { StringListParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } else if(dynamic_cast(param)) { ListViewParameter * paramDown = dynamic_cast(param); paramDown->SetSelectedNames(value); } } void Application::SetParameterOutputImage(std::string parameter, FloatVectorImageType* value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { OutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } } void Application::SetParameterComplexOutputImage(std::string parameter, ComplexFloatVectorImageType* value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { ComplexOutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } } void Application::SetParameterOutputImagePixelType(std::string parameter, ImagePixelType pixelType) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { OutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetPixelType(pixelType); } } void Application::SetParameterComplexOutputImagePixelType(std::string parameter, ComplexImagePixelType cpixelType) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { ComplexOutputImageParameter* paramDown = dynamic_cast(param); paramDown->SetComplexPixelType(cpixelType); } } void Application::SetParameterOutputVectorData(std::string parameter, VectorDataType* value) { Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { OutputVectorDataParameter* paramDown = dynamic_cast(param); paramDown->SetValue(value); } } std::string Application::GetParameterName(std::string parameter) { Parameter* param = GetParameterByKey(parameter); return param->GetName(); } std::string Application::GetParameterDescription(std::string parameter) { Parameter* param = GetParameterByKey(parameter); return param->GetDescription(); } void Application::SetParameterDescription(std::string parameter, std::string desc) { Parameter* param = GetParameterByKey(parameter); param->SetDescription(desc); } int Application::GetParameterInt(std::string parameter) { int ret = 0; Parameter* param = GetParameterByKey(parameter); if (dynamic_cast(param)) { IntParameter* paramInt = dynamic_cast(param); ret = paramInt->GetValue(); } else if (dynamic_cast(param)) { FloatParameter* paramFloat = dynamic_cast(param); ret = static_cast(paramFloat->GetValue()); } else if (dynamic_cast(param)) { RadiusParameter* paramRadius = dynamic_cast(param); ret = paramRadius->GetValue(); } else if (dynamic_cast(param)) { RAMParameter* paramRAM = dynamic_cast(param); ret = paramRAM->GetValue(); } else if (dynamic_cast(param)) { ChoiceParameter* paramChoice = dynamic_cast(param); ret = paramChoice->GetValue(); } else { itkExceptionMacro(< (param)) { FloatParameter* paramFloat = dynamic_cast (param); ret = paramFloat->GetValue(); } else { itkExceptionMacro(<(param)) { ChoiceParameter* paramDown = dynamic_cast(param); std::string choiceKey = paramDown->GetChoiceKey( paramDown->GetValue() ); size_t lastPointPos = choiceKey.find_last_of('.'); if(lastPointPos != std::string::npos) { ret = choiceKey.substr(lastPointPos); } else { ret = choiceKey; } } else if (dynamic_cast(param)) { ListViewParameter* paramDown = dynamic_cast(param); std::string choiceKey = paramDown->GetChoiceKey( paramDown->GetValue() ); size_t lastPointPos = choiceKey.find_last_of('.'); if(lastPointPos != std::string::npos) { ret = choiceKey.substr(lastPointPos); } else { ret = choiceKey; } } else if (dynamic_cast(param)) { StringParameter* paramDown = dynamic_cast(param); ret = paramDown->GetValue(); } else if (dynamic_cast(param)) { InputFilenameParameter* paramDown = dynamic_cast(param); ret = paramDown->GetValue(); } else if (dynamic_cast(param)) { OutputFilenameParameter* paramDown = dynamic_cast(param); ret = paramDown->GetValue(); } else if (dynamic_cast(param)) { DirectoryParameter* paramDown = dynamic_cast(param); ret = paramDown->GetValue(); } else if (dynamic_cast(param)) { InputImageParameter* paramDown = dynamic_cast(param); ret = paramDown->GetFileName(); } else if (dynamic_cast(param)) { ComplexInputImageParameter* paramDown = dynamic_cast(param); ret = paramDown->GetFileName(); } else if (dynamic_cast(param)) { InputVectorDataParameter* paramDown = dynamic_cast(param); ret = paramDown->GetFileName(); } else if (dynamic_cast(param)) { OutputImageParameter* paramDown = dynamic_cast(param); ret = paramDown->GetFileName(); } else if (dynamic_cast(param)) { OutputVectorDataParameter* paramDown = dynamic_cast(param); ret = paramDown->GetFileName(); } else if (dynamic_cast(param)) { OutputProcessXMLParameter* paramDown = dynamic_cast(param); ret = paramDown->GetFileName(); } else if (dynamic_cast(param)) { InputProcessXMLParameter* paramDown = dynamic_cast(param); ret = paramDown->GetFileName(); } else { itkExceptionMacro(< Application::GetParameterStringList(std::string parameter) { std::vector ret; Parameter* param = GetParameterByKey(parameter); if (dynamic_cast (param)) { InputImageListParameter* paramDown = dynamic_cast (param); ret = paramDown->GetFileNameList(); } else if (dynamic_cast (param)) { InputVectorDataListParameter* paramDown = dynamic_cast (param); ret = paramDown->GetFileNameList(); } else if (dynamic_cast (param)) { InputFilenameListParameter* paramDown = dynamic_cast (param); ret = paramDown->GetFileNameList(); } else if (dynamic_cast (param)) { StringListParameter* paramDown = dynamic_cast (param); ret = paramDown->GetValue(); } else if (dynamic_cast (param)) { ListViewParameter* paramDown = dynamic_cast (param); ret = paramDown->GetSelectedNames(); } else { itkExceptionMacro(< (param); if (paramDown) { paramDown->SetImage(inputImage); } else { itkExceptionMacro(< (param); if (paramDown) { return paramDown->GetValue(); } else { itkExceptionMacro(< (param); if (paramDown) { paramDown->SetImage(inputImage); } else { itkExceptionMacro(< (param); if (paramDown) { return paramDown->GetValue(); } else { itkExceptionMacro(<(param); if(paramDown) { paramDown->AddImage(img); } else { itkExceptionMacro(<(param); if(paramDown) { paramDown->SetNthImage(id,img); } else { itkExceptionMacro(<(param); if(paramDown) { paramDown->ClearValue(); } else { itkExceptionMacro(<(param); if(paramDown) { return paramDown->Size(); } else { itkExceptionMacro(< (param)) { InputImageParameter* paramDown = dynamic_cast (param); ret = paramDown->GetImage(); } else { itkExceptionMacro(<(param)) { InputImageListParameter* paramDown = dynamic_cast(param); ret = paramDown->GetImageList(); } else { itkExceptionMacro(<(param)) { ComplexInputImageParameter* paramDown = dynamic_cast(param); ret = paramDown->GetImage(); } else { itkExceptionMacro(<(param)) { InputVectorDataParameter* paramDown = dynamic_cast(param); ret = paramDown->GetVectorData(); } else { itkExceptionMacro(<(param)) { InputVectorDataListParameter* paramDown = dynamic_cast(param); ret = paramDown->GetVectorDataList(); } else { itkExceptionMacro(<GetParameterType( paramKey ); if( type == ParameterType_String || type == ParameterType_InputFilename || type == ParameterType_OutputFilename || type == ParameterType_Directory || type == ParameterType_InputImage || type == ParameterType_ComplexInputImage || type == ParameterType_InputVectorData || type == ParameterType_OutputImage || type == ParameterType_OutputVectorData || type == ParameterType_ListView || type == ParameterType_Choice || type == ParameterType_OutputProcessXML || type == ParameterType_InputProcessXML ) { ret = this->GetParameterString( paramKey ); } else if ( type == ParameterType_Int || type == ParameterType_Radius || type == ParameterType_RAM) { std::ostringstream oss; oss << this->GetParameterInt( paramKey ); ret = oss.str(); } else if( type == ParameterType_Float ) { std::ostringstream oss; //oss << std::setprecision(10); oss << this->GetParameterFloat( paramKey ); ret = oss.str(); } else if( type == ParameterType_StringList ) { std::ostringstream oss; oss << std::setprecision(10); const std::vector strList = this->GetParameterStringList( paramKey ); for (unsigned int i=0; i(param)) { OutputImageParameter* paramDown = dynamic_cast(param); ret = paramDown->GetPixelType(); } else { itkExceptionMacro("Unable to find PixelType in parameter "<(param)) { ComplexOutputImageParameter* paramDown = dynamic_cast(param); ret = paramDown->GetComplexPixelType(); } else { itkExceptionMacro("Unable to find PixelType in parameter "<AddChoice(paramKey, paramName); } void Application::ClearChoices(std::string paramKey) { GetParameterList()->ClearChoices(paramKey); } std::vector Application::GetSelectedItems(std::string param) { return GetParameterList()->GetSelectedItems(param); } void Application::AddParameter(ParameterType type, std::string paramKey, std::string paramName) { GetParameterList()->AddParameter(type, paramKey, paramName); } void Application::AddRAMParameter(std::string paramKey, std::string paramName, unsigned int defaultValue) { GetParameterList()->AddParameter(ParameterType_RAM, paramKey, paramName); SetDefaultParameterInt(paramKey, defaultValue); MandatoryOff(paramKey); } // paramKey default value = ram void Application::AddRAMParameter(std::string paramKey) { // Get the RAM Parameter from the configuration manager AddRAMParameter(paramKey, "Available RAM (Mb)", otb::ConfigurationManager::GetMaxRAMHint()); MandatoryOff(paramKey); SetParameterDescription(paramKey, "Available memory for processing (in MB)"); } void Application::AddRANDParameter(std::string paramKey, std::string paramName, unsigned int defaultValue) { GetParameterList()->AddParameter(ParameterType_Int, paramKey, paramName); SetDefaultParameterInt(paramKey, defaultValue); MandatoryOff(paramKey); } // paramKey default value = rand void Application::AddRANDParameter(std::string paramKey) { // Get the RAND Parameter from the configuration file GetParameterList()->AddParameter(ParameterType_Int, paramKey, "set user defined seed"); MandatoryOff(paramKey); SetParameterDescription(paramKey, "Set specific seed. with integer value."); } std::vector< std::pair > Application::GetOutputParametersSumUp() { std::vector< std::pair > res; std::vector paramList = GetParametersKeys(true); for (std::vector::const_iterator it = paramList.begin(); it != paramList.end(); ++it) { Parameter* param = GetParameterByKey(*it); ParameterType type = GetParameterType(*it); if ( type != ParameterType_Group ) { if ( param->GetRole() == Role_Output && IsParameterEnabled(*it) ) { std::pair keyVal; keyVal.first = (*it); if (type == ParameterType_Float) { std::ostringstream oss; oss << std::setprecision(10); oss << GetParameterFloat(*it); keyVal.second = oss.str(); } else { keyVal.second = GetParameterAsString(*it); } res.push_back( keyVal ); } } } return res; } bool Application::IsApplicationReady() { // Check if all the mandatory parameters are set bool ready = true; std::vector paramList = GetParametersKeys(true); for (std::vector::const_iterator it = paramList.begin(); it != paramList.end(); ++it) { // Check all Input Parameters with Input Role if (GetParameterByKey(*it)->GetRole() == Role_Input) { // When a parameter is mandatory : // return false when does not have value and: // - The param is root // - The param is not root and belonging to a Mandatory Group // which is activated if ( !this->HasValue(*it) && IsMandatory(*it) ) { if( GetParameterByKey(*it)->IsRoot() ) { otbDebugMacro("MISSING : "<< (*it).c_str() << " ( Is Root)"); return false; } else { // check if the parameter is linked to a root parameter with a chain of active parameters Parameter* currentParam = GetParameterByKey(*it)->GetRoot(); if (currentParam->IsRoot()) { otbDebugMacro("MISSING : "<< (*it).c_str() << " ( Is Level 1)"); return false; } int level = 1; while (!currentParam->IsRoot()) { if (!currentParam->GetActive()) { // the missing parameter is not on an active branch : we can ignore it break; } currentParam = currentParam->GetRoot(); level++; if (currentParam->IsRoot()) { // the missing parameter is on an active branch : we need it otbDebugMacro("MISSING : "<< (*it).c_str() << " ( Is Level "<< level<<")"); return false; } } } } } } return ready; } void Application::AddProcess(itk::ProcessObject* object, std::string description) { m_ProgressSource = object; m_ProgressSourceDescription = description; AddProcessToWatchEvent event; event.SetProcess(object); event.SetProcessDescription(description); this->InvokeEvent(event); } itk::ProcessObject* Application::GetProgressSource() const { return m_ProgressSource; } std::string Application::GetProgressDescription() const { return m_ProgressSourceDescription; } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperApplicationFactoryBase.cxx000066400000000000000000000017241301006202600321750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationFactoryBase.h" namespace otb { namespace Wrapper { Application::Pointer ApplicationFactoryBase::CreateApplication(const char* name) { Application::Pointer appli; LightObject::Pointer obj = this->CreateObject(name); if (obj.IsNotNull()) { Application* app = dynamic_cast (obj.GetPointer()); if (app) { appli = app; } } return appli; } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperApplicationHtmlDocGenerator.cxx000066400000000000000000000243231301006202600331740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationHtmlDocGenerator.h" #include #include "otbWrapperChoiceParameter.h" namespace otb { namespace Wrapper { #define otbDocHtmlTitleMacro( value ) \ oss << "

    "; \ oss << value; \ oss << "

    "; #define otbDocHtmlTitle1Macro( value ) \ oss << "

    "; \ oss << value; \ oss << "

    "; #define otbDocHtmlTitle2Macro( value ) \ oss << "

    "; \ oss << value; \ oss << "

    "; #define otbDocHtmlBodyMacro( value ) \ oss << "

    "; \ oss << value; \ oss << "

    "; #define otbDocHtmlBodyCodeMacro( value ) \ oss << "

    "; \ oss << value; \ oss << "

    "; #define otbDocHtmlParamMacro( type, param, showKey ) \ oss << "

    "; \ oss << "["<GetName(); \ if( showKey == true && !std::string(param->GetKey()).empty() ) \ { \ oss << " (-"<< param->GetKey()<<")"; \ } \ oss << ": "; \ if( std::string(param->GetDescription()).size()!=0 ) \ { \ oss << param->GetDescription(); \ } \ oss << "

    "; ApplicationHtmlDocGenerator::ApplicationHtmlDocGenerator() { } ApplicationHtmlDocGenerator::~ApplicationHtmlDocGenerator() { } void ApplicationHtmlDocGenerator::GenerateDoc( const Application::Pointer app, std::string & val, const bool showKey ) { std::ostringstream oss; oss << ""; oss << ""; otbDocHtmlTitleMacro( app->GetDocName() ); otbDocHtmlTitle1Macro( "Brief Description" ); otbDocHtmlBodyMacro( app->GetDescription() ); otbDocHtmlTitle1Macro( "Tags" ); std::string tagList; if ( app->GetDocTags().size() > 0 ) { for (unsigned int i = 0; i < app->GetDocTags().size() - 1; i++) { tagList.append( app->GetDocTags()[i] ).append(", "); } tagList.append( app->GetDocTags()[app->GetDocTags().size() - 1]); otbDocHtmlBodyMacro( tagList ); } else { otbDocHtmlBodyMacro( "None" ); } otbDocHtmlTitle1Macro("Long Description"); otbDocHtmlBodyMacro( app->GetDocLongDescription() ); otbDocHtmlTitle1Macro("Parameters"); oss << "
      "; std::string paramDocs(""); ApplicationHtmlDocGenerator::GetDocParameters( app, paramDocs, showKey ); oss<"; otbDocHtmlTitle1Macro( "Limitations"); otbDocHtmlBodyMacro( app->GetDocLimitations() ); otbDocHtmlTitle1Macro( "Authors" ); otbDocHtmlBodyMacro( app->GetDocAuthors() ); otbDocHtmlTitle1Macro( "See also" ); otbDocHtmlBodyMacro( app->GetDocSeeAlso() ); otbDocHtmlTitle1Macro( "Example of use" ); if( showKey == true ) { oss << "
        "; otbDocHtmlBodyMacro( "
      • Values for GUIs:
        • " ); } otbDocHtmlBodyMacro( app->GetHtmlExample() ); if( showKey == true ) { otbDocHtmlBodyMacro( "
      • Command line to execute:
        • " ); otbDocHtmlBodyCodeMacro( app->GetCLExample() ); oss << "
      "; } oss << ""; val = oss.str(); // Replace "\n" string with
      itksys::SystemTools::ReplaceString( val, "\n", "
      "); } void ApplicationHtmlDocGenerator::GenerateDoc(const Application::Pointer app, const std::string& filename, const bool showKey) { std::string doc; ApplicationHtmlDocGenerator::GenerateDoc( app, doc, showKey ); std::ofstream ofs(filename.c_str()); if (!ofs.is_open()) { fprintf(stderr, "Error, can't open file"); itkGenericExceptionMacro( << "Error, can't open file "< appKeyList = app->GetParametersKeys( false ); const unsigned int nbOfParam = appKeyList.size(); std::string paramDocs(""); if( nbOfParam == 0) { val = "None"; } else { for( unsigned int i=0; iGetParameterByKey( key ); if( app->GetParameterType(key) == ParameterType_Group) { oss << "
    • "; otbDocHtmlParamMacro( "group", param, showKey ); std::string grDoc; ApplicationHtmlDocGenerator::GetDocParameterGroup( app, grDoc, key, showKey ); oss<
      "; } else if( app->GetParameterType(key) == ParameterType_Choice ) { oss << "
    • "; otbDocHtmlParamMacro( "choice", param, showKey ); std::string grDoc; ApplicationHtmlDocGenerator::GetDocParameterChoice(app, grDoc, key, showKey); oss<
      "; } else { oss << "
    • "; otbDocHtmlParamMacro("param", param, showKey ); oss << "
      • "; } } } val = oss.str(); } void ApplicationHtmlDocGenerator::GetDocParameterGroup( const Application::Pointer app, std::string & val, const std::string & key, const bool showKey ) { Parameter * paramGr = app->GetParameterByKey( key ); if( !dynamic_cast(paramGr)) { itkGenericExceptionMacro("Invalid parameter type for key "<(paramGr); const std::vector appKeyList = group->GetParametersKeys( false ); unsigned int nbOfParam = appKeyList.size(); std::ostringstream oss; oss<<"
        "; for( unsigned int i=0; iGetParameterByKey( fullKey ); if( app->GetParameterType(fullKey) == ParameterType_Group) { oss<<"
      • "; otbDocHtmlParamMacro( "group", param, showKey ); std::string grDoc; ApplicationHtmlDocGenerator::GetDocParameterGroup( app, grDoc, fullKey, showKey ); oss<"; } else if( app->GetParameterType(fullKey) == ParameterType_Choice ) { oss<<"
      • "; otbDocHtmlParamMacro( "choice", param, showKey ); std::string grDoc; ApplicationHtmlDocGenerator::GetDocParameterChoice(app, grDoc, fullKey, showKey ); oss<"; } else { oss << "
      • "; otbDocHtmlParamMacro( "param", param, showKey ); oss <<"
        • "; } } oss<<"
      "; val.append(oss.str()); } void ApplicationHtmlDocGenerator::GetDocParameterChoice( const Application::Pointer app, std::string & val, const std::string & key, const bool showKey ) { Parameter * paramCh = app->GetParameterByKey( key ); if( !dynamic_cast(paramCh)) { itkGenericExceptionMacro("Invalid parameter type for key "<(paramCh); const std::vector appKeyList = choice->GetChoiceKeys(); unsigned int nbOfParam = choice->GetNbChoices(); std::ostringstream oss; oss<<"
        "; for( unsigned int i=0; iGetChoiceParameterGroupByIndex(i); std::string grDoc; oss << "
      • "; otbDocHtmlParamMacro( "group", group, showKey ); ApplicationHtmlDocGenerator::GetDocParameterGroup( app, grDoc, fullKey, showKey ); oss<"; } oss<<"
      "; val.append(oss.str()); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperApplicationRegistry.cxx000066400000000000000000000266511301006202600316110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationRegistry.h" #include "otbWrapperApplicationFactoryBase.h" #include "otbMacro.h" #include "itksys/SystemTools.hxx" #include "itkDynamicLoader.h" #include "itkDirectory.h" #include "itkMutexLock.h" #include "itkMutexLockHolder.h" #include namespace otb { namespace Wrapper { // Constant : environment variable for application path static const char OTB_APPLICATION_VAR[] = "OTB_APPLICATION_PATH"; class ApplicationPrivateRegistry { public: typedef std::pair AppHandlePairType; typedef std::list AppHandleContainerType; /** Add a pair (application, library handle) in the private registry */ bool AddPair(Application *app, void *handle) { AppHandlePairType pair; if (app && handle) { // mutex lock to ensure thread safety itk::MutexLockHolder mutexHolder(m_Mutex); pair.first = app; pair.second = handle; m_Container.push_back(pair); return true; } return false; } /** When an application is deleted, unregister its pointer from private registry */ void UnregisterApp(const Application *app) { if (app) { // mutex lock to ensure thread safety itk::MutexLockHolder mutexHolder(m_Mutex); AppHandleContainerType::iterator it = m_Container.begin(); while (it != m_Container.end()) { if ((*it).first == app) { (*it).first = ITK_NULLPTR; } ++it; } } } /** Release the library handles from applications already deleted */ void ReleaseUnusedHandle() { itk::MutexLockHolder mutexHolder(m_Mutex); AppHandleContainerType::iterator it; for (it = m_Container.begin() ; it != m_Container.end() ; ++it) { if ((*it).first == ITK_NULLPTR) { itk::DynamicLoader::CloseLibrary( static_cast((*it).second)); (*it).second = ITK_NULLPTR; } } m_Container.remove(AppHandlePairType((Application*) ITK_NULLPTR, (void*) ITK_NULLPTR)); } /** close all handles at program exit */ ~ApplicationPrivateRegistry() { // unregister all ITK factories, because some of them could have been // registered by the shared libs we are about to close. itk::ObjectFactoryBase::UnRegisterAllFactories(); // Close all opened shared libs AppHandleContainerType::iterator it; for (it = m_Container.begin() ; it != m_Container.end() ; ++it) { itk::DynamicLoader::CloseLibrary( static_cast((*it).second)); } m_Container.clear(); } private: AppHandleContainerType m_Container; itk::SimpleMutexLock m_Mutex; }; // static finalizer to close opened libraries static ApplicationPrivateRegistry m_ApplicationPrivateRegistryGlobal; // Define callbacks to unregister applications in ApplicationPrivateRegistry void DeleteAppCallback(itk::Object *obj,const itk::EventObject &, void *) { Application *appPtr = dynamic_cast(obj); m_ApplicationPrivateRegistryGlobal.UnregisterApp(appPtr); } void DeleteAppConstCallback(const itk::Object *obj,const itk::EventObject &, void *) { const Application *appPtr = dynamic_cast(obj); m_ApplicationPrivateRegistryGlobal.UnregisterApp(appPtr); } ApplicationRegistry::ApplicationRegistry() { } ApplicationRegistry::~ApplicationRegistry() { } void ApplicationRegistry::SetApplicationPath(std::string newpath) { std::ostringstream putEnvPath; putEnvPath << OTB_APPLICATION_VAR << "=" << newpath; // do NOT use putenv() directly, since the string memory must be managed carefully itksys::SystemTools::PutEnv(putEnvPath.str().c_str()); } void ApplicationRegistry::AddApplicationPath(std::string newpath) { std::ostringstream putEnvPath; putEnvPath << OTB_APPLICATION_VAR <<"="; // Can be NULL if the env var is not set const char* currentEnv = itksys::SystemTools::GetEnv(OTB_APPLICATION_VAR); #if defined(WIN32) const char pathSeparator = ';'; #else const char pathSeparator = ':'; #endif putEnvPath << newpath << pathSeparator; if (currentEnv) { putEnvPath << currentEnv; } // do NOT use putenv() directly, since the string memory must be managed carefully itksys::SystemTools::PutEnv(putEnvPath.str().c_str()); } std::string ApplicationRegistry::GetApplicationPath() { std::string ret; // Can be NULL if the env var is not set const char* currentEnv = itksys::SystemTools::GetEnv(OTB_APPLICATION_VAR); if (currentEnv) { ret = std::string(currentEnv); } return ret; } Application::Pointer ApplicationRegistry::CreateApplication(const std::string& name, bool useFactory) { ApplicationPointer appli; // Fast search : uses OTB_APPLICATION_PATH appli = ApplicationRegistry::CreateApplicationFaster(name); if (appli.IsNotNull()) { return appli; } // Classic search : uses factories registered by ITK ( see ITK_AUTOLOAD_PATH ) if (useFactory) { LightObject::Pointer possibleApp = itk::ObjectFactoryBase::CreateInstance(name.c_str()); if (possibleApp.IsNotNull()) { // Downcast Application* app = dynamic_cast (possibleApp.GetPointer()); if (app) { appli = app; appli->Init(); } else { otbMsgDevMacro( << "Error ApplicationRegistry factory did not return an Application: " << possibleApp->GetNameOfClass() << std::endl ); } } } return appli; } typedef itk::ObjectFactoryBase * ( *ITK_LOAD_FUNCTION )(); Application::Pointer ApplicationRegistry::CreateApplicationFaster(const std::string& name) { ApplicationPointer appli = ITK_NULLPTR; std::string appExtension = itksys::DynamicLoader::LibExtension(); #ifdef __APPLE__ appExtension = ".dylib"; #endif std::ostringstream appLibName; appLibName << "otbapp_" << name << appExtension; #if defined(WIN32) const char pathSeparator = ';'; #else const char pathSeparator = ':'; #endif #ifdef _WIN32 const char sep = '\\'; #else const char sep = '/'; #endif std::string otbAppPath = GetApplicationPath(); std::vector pathList; if (!otbAppPath.empty()) { pathList = itksys::SystemTools::SplitString(otbAppPath.c_str(),pathSeparator,false); } for (unsigned int i=0 ; i ApplicationRegistry::GetAvailableApplications(bool useFactory) { ApplicationPointer appli; std::set appSet; std::string appPrefix("otbapp_"); std::string appExtension = itksys::DynamicLoader::LibExtension(); #ifdef __APPLE__ appExtension = ".dylib"; #endif #if defined(WIN32) const char pathSeparator = ';'; #else const char pathSeparator = ':'; #endif #ifdef _WIN32 const char sep = '\\'; #else const char sep = '/'; #endif std::string otbAppPath = GetApplicationPath(); std::vector pathList; if (!otbAppPath.empty()) { pathList = itksys::SystemTools::SplitString(otbAppPath.c_str(),pathSeparator,false); } for (unsigned int k=0 ; kLoad(pathList[k].c_str())) { continue; } for (unsigned int i = 0; i < dir->GetNumberOfFiles(); i++) { const char *filename = dir->GetFile(i); std::string sfilename(filename); std::string::size_type extPos = sfilename.rfind(appExtension); std::string::size_type prefixPos = sfilename.find(appPrefix); // Check if current file is a shared lib with the right pattern if (extPos + appExtension.size() == sfilename.size() && prefixPos == 0) { std::string name = sfilename.substr(appPrefix.size(),extPos-appPrefix.size()); std::string fullpath = pathList[k]; if (!fullpath.empty() && fullpath[fullpath.size() - 1] != sep) { fullpath.push_back(sep); } fullpath.append(sfilename); appli = LoadApplicationFromPath(fullpath,name); if (appli.IsNotNull()) { appSet.insert(name); } appli = ITK_NULLPTR; } } } if (useFactory) { std::list allobjects = itk::ObjectFactoryBase::CreateAllInstance("otbWrapperApplication"); // Downcast and Sanity check for (std::list::iterator i = allobjects.begin(); i != allobjects.end(); ++i) { Application* app = dynamic_cast (i->GetPointer()); if (app) { app->Init(); std::string curName(app->GetName()); appSet.insert(curName); } else { otbMsgDevMacro( << "Error ApplicationRegistry factory did not return an Application: " << (*i)->GetNameOfClass() << std::endl ); } } } std::vector appVec; std::copy(appSet.begin(), appSet.end(), std::back_inserter(appVec)); return appVec; } void ApplicationRegistry::CleanRegistry() { m_ApplicationPrivateRegistryGlobal.ReleaseUnusedHandle(); } Application::Pointer ApplicationRegistry::LoadApplicationFromPath(std::string path,std::string name) { Application::Pointer appli; if (itksys::SystemTools::FileExists(path.c_str(),true)) { itk::LibHandle lib = itk::DynamicLoader::OpenLibrary(path.c_str()); if (lib) { /** * Look for the symbol itkLoad in the library */ ITK_LOAD_FUNCTION loadfunction = ( ITK_LOAD_FUNCTION ) itk::DynamicLoader::GetSymbolAddress(lib, "itkLoad"); /** * if the symbol is found call it to create the factory * from the library */ if ( loadfunction ) { itk::ObjectFactoryBase *newfactory = ( *loadfunction )( ); // Downcast ApplicationFactoryBase* appFactory = dynamic_cast(newfactory); if (appFactory) { appli = appFactory->CreateApplication(name.c_str()); if (appli.IsNotNull()) { appli->Init(); // register library handle m_ApplicationPrivateRegistryGlobal.AddPair(appli.GetPointer(), (void*) lib); // set a callback on DeleteEvent itk::CStyleCommand::Pointer command = itk::CStyleCommand::New(); command->SetCallback(&DeleteAppCallback); command->SetConstCallback(&DeleteAppConstCallback); appli->AddObserver(itk::DeleteEvent(),command); return appli; } } } itk::DynamicLoader::CloseLibrary(lib); } } return appli; } } // end namespace Wrapper } //end namespace otb OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperChoiceParameter.cxx000066400000000000000000000107321301006202600306410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperChoiceParameter.h" namespace otb { namespace Wrapper { ChoiceParameter::ChoiceParameter() : m_CurrentChoice(0) { } ChoiceParameter::~ChoiceParameter() { } void ChoiceParameter::AddChoice( std::string choicekey, std::string choiceName ) { Choice choice; choice.m_Key = choicekey; choice.m_Name = choiceName; choice.m_AssociatedParameter = ParameterGroup::New(); choice.m_AssociatedParameter->SetName(choiceName); choice.m_AssociatedParameter->SetRoot(this); m_ChoiceList.push_back(choice); // check if the new choice matches the m_CurrentChoice : if so the group should be active. if (m_CurrentChoice == (m_ChoiceList.size() - 1)) { m_ChoiceList[m_CurrentChoice].m_AssociatedParameter->SetActive(true); } // Add the associated parameter as a child // in order to not have a gap in the children hierarchy this->AddChild(choice.m_AssociatedParameter.GetPointer()); } std::string ChoiceParameter::GetChoiceKey( int i ) { return m_ChoiceList[i].m_Key; } std::vector ChoiceParameter::GetChoiceKeys( ) { std::vector ret; ChoiceList::iterator it = m_ChoiceList.begin(); for (it = m_ChoiceList.begin(); it != m_ChoiceList.end(); ++it) { ret.push_back(it->m_Key); } return ret; } std::string ChoiceParameter::GetChoiceName( int i ) { return m_ChoiceList[i].m_Name; } std::vector ChoiceParameter::GetChoiceNames( ) { std::vector ret; ChoiceList::iterator it = m_ChoiceList.begin(); for (it = m_ChoiceList.begin(); it != m_ChoiceList.end(); ++it) { ret.push_back(it->m_Name); } return ret; } ParameterGroup::Pointer ChoiceParameter::GetChoiceParameterGroupByIndex( int i ) { return m_ChoiceList[i].m_AssociatedParameter; } ParameterGroup::Pointer ChoiceParameter::GetChoiceParameterGroupByKey( std::string choiceKey ) { ChoiceList::iterator it = m_ChoiceList.begin(); for (it = m_ChoiceList.begin(); it != m_ChoiceList.end(); ++it) { if ( it->m_Key == choiceKey ) { return it->m_AssociatedParameter; } } itkExceptionMacro(<< "Cannot find " << choiceKey); } unsigned int ChoiceParameter::GetNbChoices( void ) { return m_ChoiceList.size(); } void ChoiceParameter::SetValue(unsigned int v) { m_CurrentChoice = v; SetActive(true); // update the active flag in sub parameters for (unsigned int i=0; i< m_ChoiceList.size(); i++) { if (m_ChoiceList[i].m_AssociatedParameter) { if (i==m_CurrentChoice) { if (!m_ChoiceList[i].m_AssociatedParameter->GetActive()) { m_ChoiceList[i].m_AssociatedParameter->SetActive(true); } } else { if (m_ChoiceList[i].m_AssociatedParameter->GetActive()) { m_ChoiceList[i].m_AssociatedParameter->SetActive(false); } } } } // Call Modified(); this->Modified(); } void ChoiceParameter::SetValue(std::string choiceKey) { ChoiceList::iterator it = m_ChoiceList.begin(); unsigned int i = 0; for (it = m_ChoiceList.begin(); it != m_ChoiceList.end(); ++it) { if ( it->m_Key == choiceKey ) { SetValue(i); return; } ++i; } itkExceptionMacro(<< "Cannot find " << choiceKey); } unsigned int ChoiceParameter::GetValue() { return m_CurrentChoice; } /** Return any value */ std::vector ChoiceParameter::GetParametersKeys() { std::vector parameters; ChoiceList::iterator cit = m_ChoiceList.begin(); for (cit = m_ChoiceList.begin(); cit != m_ChoiceList.end(); ++cit) { if (cit->m_AssociatedParameter) { std::vector subparams = cit->m_AssociatedParameter->GetParametersKeys(); for (std::vector::const_iterator it = subparams.begin(); it != subparams.end(); ++it) { parameters.push_back( cit->m_Key + "." + *it ); } } } return parameters; } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexInputImageParameter.cxx000066400000000000000000000102121301006202600330320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperComplexInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" namespace otb { namespace Wrapper { ComplexInputImageParameter::ComplexInputImageParameter() { this->SetName("Complex Input Image"); this->SetKey("cin"); m_FileName=""; m_PreviousFileName=""; m_UseFilename = true; this->ClearValue(); } ComplexInputImageParameter::~ComplexInputImageParameter() { } bool ComplexInputImageParameter::SetFromFileName(const std::string& filename) { // First clear previous file chosen this->ClearValue(); // No file existence is done here : // - Done in the reader // - allow appending additional information to the filename // myfile.tif:2 for example, or myfile.tif:nocarto if (!filename.empty()) { ComplexFloatVectorReaderType::Pointer reader = ComplexFloatVectorReaderType::New(); try { reader->SetFileName(filename); reader->UpdateOutputInformation(); } catch(itk::ExceptionObject & /*err*/) { return false; } // the specified filename is valid => store the value m_FileName = filename; m_UseFilename = true; SetActive(true); return true; } return false; } ComplexFloatVectorImageType* ComplexInputImageParameter::GetImage() { return this->GetImage(); } #define otbGetImageMacro(image) \ image##Type * \ ComplexInputImageParameter::Get##image () \ { \ return this->GetImage< image##Type > (); \ } otbGetImageMacro(ComplexFloatImage); otbGetImageMacro(ComplexDoubleImage); otbGetImageMacro(ComplexFloatVectorImage); otbGetImageMacro(ComplexDoubleVectorImage); #define otbCastImageMacro(ComplexInputImageType, OutputImageType, theMethod) \ template<> OutputImageType * \ ComplexInputImageParameter::CastImage() \ { \ return this->theMethod(); \ } #define otbGenericCastImageMacro(ComplexInputImageType, theMethod, prefix) \ otbCastImageMacro(ComplexInputImageType, ComplexFloat##prefix##ImageType, theMethod) \ otbCastImageMacro(ComplexInputImageType, ComplexDouble##prefix##ImageType, theMethod) /********************************************************************* ********************** Image -> Image **********************************************************************/ otbGenericCastImageMacro(ComplexFloatImageType, SimpleCastImage, ) otbGenericCastImageMacro(ComplexDoubleImageType, SimpleCastImage, ) /********************************************************************* ********************** VectorImage -> VectorImage **********************************************************************/ otbGenericCastImageMacro(ComplexFloatVectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(ComplexDoubleVectorImageType, SimpleCastImage, Vector) void ComplexInputImageParameter::SetImage(ComplexFloatVectorImageType* image) { m_UseFilename = false; this->SetImage( image ); } bool ComplexInputImageParameter::HasValue() const { if( m_FileName.empty() && m_Image.IsNull() ) return false; else return true; } void ComplexInputImageParameter::ClearValue() { m_Image = ITK_NULLPTR; m_Reader = ITK_NULLPTR; m_Caster = ITK_NULLPTR; m_FileName = ""; m_PreviousFileName=""; m_UseFilename = true; } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexOutputImageParameter.cxx000066400000000000000000000146031301006202600332430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperComplexOutputImageParameter.h" #include "itkUnaryFunctorImageFilter.h" #include "itkCastImageFilter.h" #include "itkVectorCastImageFilter.h" #ifdef OTB_USE_MPI #include "otbMPIConfig.h" #include "otbMPIVrtWriter.h" #ifdef OTB_USE_SPTW #include "otbSimpleParallelTiffWriter.h" #endif #endif namespace otb { namespace Wrapper { ComplexOutputImageParameter::ComplexOutputImageParameter() : m_ComplexPixelType(ComplexImagePixelType_float), m_DefaultComplexPixelType(ComplexImagePixelType_float), m_RAMValue(0) { this->SetName("Complex Output Image"); this->SetKey("cout"); } ComplexOutputImageParameter::~ComplexOutputImageParameter() { } std::string ComplexOutputImageParameter::ConvertPixelTypeToString(ComplexImagePixelType type) { std::string ret; switch(type) { case ComplexImagePixelType_float: { ret = "cfloat"; break; } case ComplexImagePixelType_double: { ret = "cdouble"; break; } } return ret; } void ComplexOutputImageParameter::InitializeWriters() { m_ComplexFloatWriter = ComplexFloatWriterType::New(); m_ComplexDoubleWriter = ComplexDoubleWriterType::New(); m_ComplexVectorFloatWriter = ComplexVectorFloatWriterType::New(); m_ComplexVectorDoubleWriter = ComplexVectorDoubleWriterType::New(); } template void CastAndWriteImage(itk::ImageBase<2> * in, otb::ImageFileWriter * writer, const std::string & filename, const unsigned int & ramValue) { typedef itk::CastImageFilter ClampFilterType; typename ClampFilterType::Pointer clampFilter = ClampFilterType::New(); clampFilter->SetInput( dynamic_cast(in)); bool useStandardWriter = true; #ifdef OTB_USE_MPI otb::MPIConfig::Pointer mpiConfig = otb::MPIConfig::Instance(); if (mpiConfig->GetNbProcs() > 1) { useStandardWriter = false; // Get file extension std::string extension = itksys::SystemTools::GetFilenameExtension(filename); if(extension == ".vrt") { // Use the WriteMPI function WriteMPI(clampFilter->GetOutput(),filename,ramValue); } #ifdef OTB_USE_SPTW else if (extension == ".tif") { // Use simple parallel tiff writer typedef otb::SimpleParallelTiffWriter SPTWriterType; typename SPTWriterType::Pointer sptWriter = SPTWriterType::New(); sptWriter->SetFileName(filename); sptWriter->SetInput(clampFilter->GetOutput()); sptWriter->SetAutomaticAdaptativeStreaming(ramValue); sptWriter->Update(); } #endif else { itkGenericExceptionMacro("File format "<SetFileName( filename ); writer->SetInput(clampFilter->GetOutput()); writer->SetAutomaticAdaptativeStreaming(ramValue); writer->Update(); } } template void ComplexOutputImageParameter::SwitchImageWrite() { switch(m_ComplexPixelType ) { case ComplexImagePixelType_float: { CastAndWriteImage(m_Image,m_ComplexFloatWriter,m_FileName,m_RAMValue); break; } case ComplexImagePixelType_double: { CastAndWriteImage(m_Image,m_ComplexDoubleWriter,m_FileName,m_RAMValue); break; } } } template void ComplexOutputImageParameter::SwitchVectorImageWrite() { switch(m_ComplexPixelType ) { case ComplexImagePixelType_float: { CastAndWriteImage(m_Image,m_ComplexVectorFloatWriter,m_FileName,m_RAMValue); break; } case ComplexImagePixelType_double: { CastAndWriteImage(m_Image,m_ComplexVectorDoubleWriter,m_FileName,m_RAMValue); break; } } } void ComplexOutputImageParameter::Write() { m_Image->UpdateOutputInformation(); if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else { itkExceptionMacro("Unknown complex image type"); } } itk::ProcessObject* ComplexOutputImageParameter::GetWriter() { int type = 0; // 0 : image // 1 : VectorImage if ( dynamic_cast( m_Image.GetPointer()) || dynamic_cast(m_Image.GetPointer())) { type = 1; } itk::ProcessObject* writer = ITK_NULLPTR; switch ( GetComplexPixelType() ) { case ComplexImagePixelType_float: { if( type == 1 ) writer = m_ComplexVectorFloatWriter; else writer = m_ComplexFloatWriter; break; } case ComplexImagePixelType_double: { if( type == 1 ) writer = m_ComplexVectorDoubleWriter; else writer = m_ComplexDoubleWriter; break; } } return writer; } ComplexOutputImageParameter::ImageBaseType* ComplexOutputImageParameter::GetValue( ) { return m_Image; } void ComplexOutputImageParameter::SetValue(ImageBaseType* image) { m_Image = image; SetActive(true); } bool ComplexOutputImageParameter::HasValue() const { std::string filename(this->GetFileName()); return !filename.empty(); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperDocExampleStructure.cxx000066400000000000000000000116731301006202600315550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperDocExampleStructure.h" namespace otb { namespace Wrapper { DocExampleStructure::DocExampleStructure() : m_ParameterList(), m_ApplicationName(""), m_ExampleCommentList(), m_NbOfExamples(1) { m_ExampleCommentList.push_back(""); } DocExampleStructure::~DocExampleStructure() { } void DocExampleStructure::AddParameter( const std::string key, const std::string value, unsigned int exId) { if( m_ParameterList.size() < exId+1 ) { while( m_ParameterList.size() DocExampleStructure::GetExampleCommentList() { return m_ExampleCommentList; } std::string DocExampleStructure::GetExampleComment( unsigned int i) { return m_ExampleCommentList.at(i); } void DocExampleStructure::SetExampleComment( const std::string & comm, unsigned int i ) { if( m_ExampleCommentList.size() < i ) itkGenericExceptionMacro( "Index "<m_ExampleCommentList[i] = comm; } unsigned int DocExampleStructure::AddExample( const std::string & comm ) { m_ExampleCommentList.push_back( comm ); m_NbOfExamples++; m_ParameterList.push_back(ParametersVectorType()); return m_ExampleCommentList.size()-1; } std::string DocExampleStructure::GenerateCLExample( unsigned int exId ) { std::string res("None"); if( m_ApplicationName.empty() || m_ParameterList.size() == 0 ) { return res; } else if ( m_ParameterList.at(exId).empty() ) return res; std::ostringstream oss; oss << "otbcli_" << m_ApplicationName << " "; for (ParametersVectorType::const_iterator it = m_ParameterList.at(exId).begin(); it != m_ParameterList.at(exId).end(); ++it) { if( it->second != "" ) { oss<< "-" << it->first << " " << it->second <<" "; } } res = oss.str(); // Suppress last added space res.erase( res.size()-1, 1); return res.c_str(); } std::string DocExampleStructure::GenerateCLExample() { std::ostringstream oss; for( unsigned int exId=0; exIdGenerateCLExample( exId ); oss << std::endl; } std::string res = oss.str(); return res; } std::string DocExampleStructure::GenerateHtmlExample( unsigned int exId ) { if( m_ApplicationName.empty() || m_ParameterList.size() == 0 ) { return ""; } std::ostringstream oss; oss << "
        "; for (ParametersVectorType::const_iterator it = m_ParameterList.at(exId).begin(); it != m_ParameterList.at(exId).end(); ++it) { if( it->second != "" ) { oss << "
      • "; oss << "

        "; oss << it->first << ": " << it->second; oss << "

        "; oss << "
        • "; } } oss << "
      "; std::string res = oss.str(); return res; } std::string DocExampleStructure::GenerateHtmlExample() { std::ostringstream oss; if( m_NbOfExamples>1 ) oss << "
        "; for( unsigned int exId=0; exId1 ) oss << "
      • "; if( !m_ExampleCommentList[exId].empty() ) oss << m_ExampleCommentList[exId]; oss << this->GenerateHtmlExample( exId ); if( m_NbOfExamples>1 ) oss << "
        • "; } if( m_NbOfExamples>1 ) oss << "
      "; std::string res = oss.str(); return res; } } // End namespace Wrapper } // End namespace otb OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperElevationParametersHandler.cxx000066400000000000000000000135501301006202600330570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperElevationParametersHandler.h" #include "otbDEMHandler.h" namespace otb { namespace Wrapper { void ElevationParametersHandler::AddElevationParameters(Application::Pointer app, const std::string & key) { app->AddParameter(ParameterType_Group, key, "Elevation management"); app->SetParameterDescription(key, "This group of parameters allows managing elevation values. Supported formats are SRTM, DTED or any geotiff. DownloadSRTMTiles application could be a useful tool to list/download tiles related to a product."); // DEM directory std::ostringstream oss; oss << key<<".dem"; app->AddParameter(ParameterType_Directory, oss.str(), "DEM directory"); app->SetParameterDescription(oss.str(), "This parameter allows selecting a directory containing Digital Elevation Model files. Note that this directory should contain only DEM files. Unexpected behaviour might occurs if other images are found in this directory."); app->MandatoryOff(oss.str()); std::string demDirFromConfig = otb::ConfigurationManager::GetDEMDirectory(); if(demDirFromConfig!="") { app->SetParameterString(oss.str(), demDirFromConfig); app->EnableParameter(oss.str()); } else { app->DisableParameter(oss.str()); } // Geoid file oss.str(""); oss << key<<".geoid"; app->AddParameter(ParameterType_InputFilename, oss.str(), "Geoid File"); app->SetParameterDescription(oss.str(),"Use a geoid grid to get the height above the ellipsoid in case there is no DEM available, no coverage for some points or pixels with no_data in the DEM tiles. A version of the geoid can be found on the OTB website (http://hg.orfeo-toolbox.org/OTB-Data/raw-file/404aa6e4b3e0/Input/DEM/egm96.grd)."); app->MandatoryOff(oss.str()); std::string geoidFromConfig = otb::ConfigurationManager::GetGeoidFile(); if(geoidFromConfig!="") { app->SetParameterString(oss.str(), geoidFromConfig); app->EnableParameter(oss.str()); } else { app->DisableParameter(oss.str()); } // Average elevation oss.str(""); oss << key <<".default"; app->AddParameter(ParameterType_Float, oss.str(), "Default elevation"); app->SetParameterDescription(oss.str(),"This parameter allows setting the default height above ellipsoid when there is no DEM available, no coverage for some points or pixels with no_data in the DEM tiles, and no geoid file has been set. This is also used by some application as an average elevation value."); app->SetDefaultParameterFloat(oss.str(), 0.); // TODO : not implemented yet // // Tiff image // oss << ".tiff"; // app->AddChoice(oss.str(), "Tiff file"); // app->AddParameter(ParameterType_InputImage, oss.str(), "Tiff file"); // app->SetParameterDescription(oss.str(),"Tiff file used to get elevation for each location in the image"); } void ElevationParametersHandler::SetupDEMHandlerFromElevationParameters(const Application::Pointer app, const std::string& key) { // Set default elevation otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(GetDefaultElevation(app,key)); std::ostringstream oss; oss<<"Elevation management: setting default height above ellipsoid to " << GetDefaultElevation(app,key) << " meters"<GetLogger()->Info(oss.str()); // Set geoid if available if(IsGeoidUsed(app,key)) { oss.str(""); oss<<"Elevation management: using geoid file ("<OpenGeoidFile(GetGeoidFile(app,key)); app->GetLogger()->Info(oss.str()); } // Set DEM directory if available if(IsDEMUsed(app,key)) { oss.str(""); oss<<"Elevation management: using DEM directory ("<OpenDEMDirectory(GetDEMDirectory(app,key)); app->GetLogger()->Info(oss.str()); } } /** * * Get the Average elevation value */ float ElevationParametersHandler::GetDefaultElevation(const Application::Pointer app, const std::string& key) { std::ostringstream oss; oss << key <<".default"; return app->GetParameterFloat(oss.str()); } /** * Get the Geoid file */ const std::string ElevationParametersHandler::GetGeoidFile(const Application::Pointer app, const std::string& key) { std::ostringstream oss; oss << key <<".geoid"; if (IsGeoidUsed(app, key)) { return app->GetParameterString(oss.str()); } return ""; } /** * Is Geoid used */ bool ElevationParametersHandler::IsGeoidUsed(const Application::Pointer app, const std::string& key) { std::ostringstream geoidKey; geoidKey<< key<<".geoid"; return app->IsParameterEnabled(geoidKey.str()) && app->HasValue(geoidKey.str()); } /** * * Is Geoid used */ bool ElevationParametersHandler::IsDEMUsed(const Application::Pointer app, const std::string& key) { std::ostringstream geoidKey; geoidKey<< key<<".dem"; return app->IsParameterEnabled(geoidKey.str()) && app->HasValue(geoidKey.str()); } const std::string ElevationParametersHandler::GetDEMDirectory(const Application::Pointer app, const std::string& key) { std::ostringstream oss; oss << key <<".dem"; if (IsDEMUsed(app, key)) { return app->GetParameterString(oss.str()); } return ""; } }// End namespace Wrapper }// End namespace otb OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputFilenameListParameter.cxx000066400000000000000000000122141301006202600330400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputFilenameListParameter.h" #include "itksys/SystemTools.hxx" namespace otb { namespace Wrapper { InputFilenameListParameter::InputFilenameListParameter() { this->SetName("Input Filename List"); this->SetKey("inList"); m_FilenameList = StringParameterListType::New(); } InputFilenameListParameter::~InputFilenameListParameter() { } bool InputFilenameListParameter::SetListFromFileName(const std::vector & filenames) { // First clear previous file chosen this->ClearValue(); bool isOk = true; for(unsigned int i=0; iSetValue(filename); try { strParameter->HasValue(); } catch(itk::ExceptionObject & /*err*/) { this->ClearValue(); isOk = false; break; } // everything went fine, store the object reference m_FilenameList->PushBack(strParameter); } } if( !isOk ) { return false; } SetActive(true); this->Modified(); return true; } void InputFilenameListParameter::AddNullElement() { m_FilenameList->PushBack(ITK_NULLPTR); SetActive(false); this->Modified(); } bool InputFilenameListParameter::AddFromFileName(const std::string & filename) { // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) // File existence checked by the reader if (!filename.empty()) { StringParameter::Pointer strParameter = StringParameter::New(); strParameter->SetValue(filename); try { strParameter->HasValue(); } catch(itk::ExceptionObject & /*err*/) { this->ClearValue(); return false; } // everything went fine, store the object references m_FilenameList->PushBack(strParameter); SetActive(true); this->Modified(); return true; } return false; } bool InputFilenameListParameter::SetNthFileName( const unsigned int id, const std::string & filename ) { if( m_FilenameList->Size()Size()<<" filenames available."); } // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) // File existence checked by the reader if (!filename.empty()) { StringParameter::Pointer strParameter = StringParameter::New(); strParameter->SetValue(filename); try { strParameter->HasValue(); } catch(itk::ExceptionObject &) { this->ClearValue(); return false; } m_FilenameList->SetNthElement(id, strParameter); this->Modified(); return true; } return false; } std::vector InputFilenameListParameter::GetFileNameList() const { if (m_FilenameList) { std::vector filenames; for(unsigned int i=0; iSize(); i++) { if( m_FilenameList->GetNthElement(i) ) filenames.push_back( m_FilenameList->GetNthElement(i)->GetValue() ); } return filenames; } itkExceptionMacro(<< "No filename value"); } std::string InputFilenameListParameter::GetNthFileName( unsigned int i ) const { if (m_FilenameList) { if(m_FilenameList->Size()Size()<<" filenames available."); } return m_FilenameList->GetNthElement(i)->GetValue(); } itkExceptionMacro(<< "No filename value"); } InputFilenameListParameter::StringParameterListPointerType InputFilenameListParameter::GetFileList() const { return m_FilenameList; } bool InputFilenameListParameter::HasValue() const { if(m_FilenameList->Size() == 0) { return false; } bool res(true); unsigned int i(0); while(i < m_FilenameList->Size() && res == true) { res = m_FilenameList->GetNthElement(i).IsNotNull(); i++; } return res; } void InputFilenameListParameter::Erase( unsigned int id ) { if(m_FilenameList->Size()Size()<<" filenames available."); } m_FilenameList->Erase( id ); this->Modified(); } void InputFilenameListParameter::ClearValue() { m_FilenameList->Clear(); SetActive(false); this->Modified(); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageListParameter.cxx000066400000000000000000000177011301006202600323500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageListParameter.h" #include "itksys/SystemTools.hxx" namespace otb { namespace Wrapper { InputImageListParameter::InputImageListParameter() : m_InputImageParameterVector(), m_ImageList(FloatVectorImageListType::New()) { this->SetName("Input Image List"); this->SetKey("inList"); } InputImageListParameter::~InputImageListParameter() { } bool InputImageListParameter::SetListFromFileName(const std::vector & filenames) { // First clear previous file chosen this->ClearValue(); bool isOk = true; for(unsigned int i=0; iSetFromFileName(filename); if(!tmpInputImageParameter->HasValue()) { // If loading failed this->ClearValue(); isOk = false; break; } m_InputImageParameterVector.push_back(tmpInputImageParameter); m_ImageList->PushBack(tmpInputImageParameter->GetFloatVectorImage()); } } if( !isOk ) { return false; } SetActive(true); this->Modified(); return true; } void InputImageListParameter::AddNullElement() { m_InputImageParameterVector.push_back(ITK_NULLPTR); m_ImageList->PushBack(ITK_NULLPTR); SetActive(false); this->Modified(); } bool InputImageListParameter::AddFromFileName(const std::string & filename) { // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) // File existence checked by the reader if (!filename.empty()) { // Try to build a new ParameterInputImage InputImageParameter::Pointer tmpInputImageParameter = InputImageParameter::New(); tmpInputImageParameter->SetFromFileName(filename); if(!tmpInputImageParameter->HasValue()) { // If loading failed this->ClearValue(); return false; } m_InputImageParameterVector.push_back(tmpInputImageParameter); m_ImageList->PushBack(tmpInputImageParameter->GetFloatVectorImage()); SetActive(true); this->Modified(); return true; } return false; } bool InputImageListParameter::SetNthFileName( const unsigned int id, const std::string & filename ) { if( m_InputImageParameterVector.size()SetFromFileName(filename); if(!tmpInputImageParameter->HasValue()) { this->ClearValue(); return false; } m_InputImageParameterVector[id] = tmpInputImageParameter; m_ImageList->SetNthElement(id,tmpInputImageParameter->GetFloatVectorImage()); this->Modified(); SetActive(true); return true; } return false; } std::vector InputImageListParameter::GetFileNameList() const { std::vector filenames; for(InputImageParameterVectorType::const_iterator it = m_InputImageParameterVector.begin(); it!=m_InputImageParameterVector.end();++it) { filenames.push_back( (*it)->GetFileName() ); } return filenames; } std::string InputImageListParameter::GetNthFileName( unsigned int i ) const { if(m_InputImageParameterVector.size()GetFileName(); } FloatVectorImageListType* InputImageListParameter::GetImageList() const { return m_ImageList; } FloatVectorImageType* InputImageListParameter::GetNthImage(unsigned int i) const { if(m_ImageList->Size()Size()<<" images available."); } return m_ImageList->GetNthElement(i); } void InputImageListParameter::SetImageList(FloatVectorImageListType* imList) { // Check input availability // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) try { for(unsigned int i=0; iSize(); i++) { imList->GetNthElement( i )->UpdateOutputInformation(); } } catch(itk::ExceptionObject &) { return; } // Clear previous values this->ClearValue(); for(unsigned int i = 0; iSize(); i++) { // Try to build a new ParameterInputImage InputImageParameter::Pointer tmpInputImageParameter = InputImageParameter::New(); tmpInputImageParameter->SetImage(imList->GetNthElement(i)); m_InputImageParameterVector.push_back(tmpInputImageParameter); m_ImageList->PushBack(tmpInputImageParameter->GetFloatVectorImage()); } SetActive(true); this->Modified(); } void InputImageListParameter::SetNthImage(unsigned int i, ImageBaseType * img) { if(m_ImageList->Size()Size()<<" images available."); } try { img->UpdateOutputInformation(); } catch(itk::ExceptionObject &) { return; } // Try to build a new ParameterInputImage InputImageParameter::Pointer tmpInputImageParameter = InputImageParameter::New(); tmpInputImageParameter->SetImage(img); m_InputImageParameterVector[i] = tmpInputImageParameter; m_ImageList->SetNthElement(i,tmpInputImageParameter->GetFloatVectorImage()); } void InputImageListParameter::AddImage(ImageBaseType* image) { // Check input availability // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) try { image->UpdateOutputInformation(); } catch(itk::ExceptionObject &) { return; } InputImageParameter::Pointer tmpInputImageParameter = InputImageParameter::New(); tmpInputImageParameter->SetImage(image); m_InputImageParameterVector.push_back(tmpInputImageParameter); m_ImageList->PushBack(tmpInputImageParameter->GetFloatVectorImage()); this->Modified(); } bool InputImageListParameter::HasValue() const { if(m_ImageList->Size() == 0) { return false; } bool res(true); unsigned int i(0); while(i < m_ImageList->Size() && res == true) { res = m_ImageList->GetNthElement(i).IsNotNull(); i++; } return res; } void InputImageListParameter::Erase( unsigned int id ) { if(m_ImageList->Size()Size()<<" images available."); } m_ImageList->Erase( id ); m_InputImageParameterVector.erase(m_InputImageParameterVector.begin()+id); this->Modified(); } unsigned int InputImageListParameter::Size() const { return m_InputImageParameterVector.size(); } void InputImageListParameter::ClearValue() { m_ImageList->Clear(); m_InputImageParameterVector.clear(); SetActive(false); this->Modified(); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameter.cxx000066400000000000000000000046321301006202600315130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otbWrapperInputImageParameterMacros.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { InputImageParameter::InputImageParameter() { this->SetName("Input Image"); this->SetKey("in"); m_FileName=""; m_PreviousFileName=""; m_UseFilename = true; this->ClearValue(); } InputImageParameter::~InputImageParameter() { } bool InputImageParameter::SetFromFileName(const std::string& filename) { // First clear previous file chosen this->ClearValue(); // No file existence is done here : // - Done in the reader // - allow appending additional information to the filename // myfile.tif:2 for example, or myfile.tif:nocarto if (!filename.empty()) { FloatVectorReaderType::Pointer reader = FloatVectorReaderType::New(); try { reader->SetFileName(filename); reader->UpdateOutputInformation(); } catch(itk::ExceptionObject & /*err*/) { return false; } // the specified filename is valid => store the value m_FileName = filename; m_UseFilename = true; SetActive(true); return true; } return false; } FloatVectorImageType* InputImageParameter::GetImage() { return this->GetImage(); } otbGetImageMacro(UInt8RGBImage); otbGetImageMacro(UInt8RGBAImage); void InputImageParameter::SetImage(FloatVectorImageType* image) { m_UseFilename = false; this->SetImage( image ); } bool InputImageParameter::HasValue() const { if( m_FileName.empty() && m_Image.IsNull() ) return false; else return true; } void InputImageParameter::ClearValue() { m_Image = ITK_NULLPTR; m_Reader = ITK_NULLPTR; m_Caster = ITK_NULLPTR; m_FileName = ""; m_PreviousFileName=""; m_UseFilename = true; } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterDouble.cxx000066400000000000000000000020641301006202600326430ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otbWrapperInputImageParameterMacros.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { otbGetImageMacro(DoubleImage); otbGetImageMacro(DoubleVectorImage) otbGenericCastImageMacro(DoubleImageType, SimpleCastImage, ) otbGenericCastImageMacro(DoubleVectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(DoubleImageType, CastVectorImageFromImage, Vector) } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterFloat.cxx000066400000000000000000000020571301006202600325000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "otbWrapperInputImageParameterMacros.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { otbGetImageMacro(FloatImage); otbGetImageMacro(FloatVectorImage) otbGenericCastImageMacro(FloatImageType, SimpleCastImage, ) otbGenericCastImageMacro(FloatVectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(FloatImageType, CastVectorImageFromImage, Vector) } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt16.cxx000066400000000000000000000020571301006202600323340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otbWrapperInputImageParameterMacros.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { otbGetImageMacro(Int16Image); otbGetImageMacro(Int16VectorImage) otbGenericCastImageMacro(Int16ImageType, SimpleCastImage, ) otbGenericCastImageMacro(Int16VectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(Int16ImageType, CastVectorImageFromImage, Vector) } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt32.cxx000066400000000000000000000020571301006202600323320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otbWrapperInputImageParameterMacros.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { otbGetImageMacro(Int32Image); otbGetImageMacro(Int32VectorImage) otbGenericCastImageMacro(Int32ImageType, SimpleCastImage, ) otbGenericCastImageMacro(Int32VectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(Int32ImageType, CastVectorImageFromImage, Vector) } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterMacros.h000066400000000000000000000036131301006202600323030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperInputImageParameterMacros__h #define otbWrapperInputImageParameterMacros__h #define otbGetImageMacro(image) \ image##Type * \ InputImageParameter::Get##image () \ { \ return this->GetImage< image##Type > (); \ } #define otbCastImageMacro(InputImageType, OutputImageType, theMethod) \ template<> OutputImageType * \ InputImageParameter::CastImage() \ { \ return this->theMethod(); \ } #define otbGenericCastImageMacro(InputImageType, theMethod, prefix) \ otbCastImageMacro(InputImageType, UInt8##prefix##ImageType, theMethod) \ otbCastImageMacro(InputImageType, UInt16##prefix##ImageType, theMethod) \ otbCastImageMacro(InputImageType, Int16##prefix##ImageType, theMethod) \ otbCastImageMacro(InputImageType, UInt32##prefix##ImageType, theMethod) \ otbCastImageMacro(InputImageType, Int32##prefix##ImageType, theMethod) \ otbCastImageMacro(InputImageType, Float##prefix##ImageType, theMethod) \ otbCastImageMacro(InputImageType, Double##prefix##ImageType, theMethod) #endif OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt16.cxx000066400000000000000000000020641301006202600324570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otbWrapperInputImageParameterMacros.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { otbGetImageMacro(UInt16Image); otbGetImageMacro(UInt16VectorImage) otbGenericCastImageMacro(UInt16ImageType, SimpleCastImage, ) otbGenericCastImageMacro(UInt16VectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(UInt16ImageType, CastVectorImageFromImage, Vector) } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt32.cxx000066400000000000000000000020641301006202600324550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otbWrapperInputImageParameterMacros.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { otbGetImageMacro(UInt32Image); otbGetImageMacro(UInt32VectorImage) otbGenericCastImageMacro(UInt32ImageType, SimpleCastImage, ) otbGenericCastImageMacro(UInt32VectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(UInt32ImageType, CastVectorImageFromImage, Vector) } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt8.cxx000066400000000000000000000020571301006202600324020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperTypes.h" #include "otbWrapperInputImageParameterMacros.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { otbGetImageMacro(UInt8Image); otbGetImageMacro(UInt8VectorImage) otbGenericCastImageMacro(UInt8ImageType, SimpleCastImage, ) otbGenericCastImageMacro(UInt8VectorImageType, SimpleCastImage, Vector) otbGenericCastImageMacro(UInt8ImageType, CastVectorImageFromImage, Vector) } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputProcessXMLParameter.cxx000066400000000000000000000304531301006202600324700ustar00rootroot00000000000000 #include "otbWrapperInputProcessXMLParameter.h" #include "otbWrapperChoiceParameter.h" #include "otbWrapperListViewParameter.h" #include "otbWrapperDirectoryParameter.h" #include "otbWrapperEmptyParameter.h" #include "otbWrapperInputFilenameParameter.h" #include "otbWrapperInputFilenameListParameter.h" #include "otbWrapperOutputFilenameParameter.h" #include "otbWrapperInputVectorDataParameter.h" #include "otbWrapperInputVectorDataListParameter.h" #include "otbWrapperOutputVectorDataParameter.h" #include "otbWrapperRadiusParameter.h" #include "otbWrapperStringListParameter.h" #include "otbWrapperInputImageParameter.h" #include "otbWrapperInputImageListParameter.h" #include "otbWrapperComplexInputImageParameter.h" #include "otbWrapperOutputImageParameter.h" #include "otbWrapperComplexOutputImageParameter.h" #include "otbWrapperRAMParameter.h" #include "itksys/SystemTools.hxx" #include "otbMacro.h" namespace otb { namespace Wrapper { InputProcessXMLParameter::InputProcessXMLParameter() { this->SetKey("inxml"); this->SetName("Load otb application from xml file"); this->SetDescription("Load otb application from xml file"); this->SetMandatory(false); this->SetActive(false); this->SetRole(Role_Input); } InputProcessXMLParameter::~InputProcessXMLParameter() { } bool InputProcessXMLParameter::SetFileName(std::string value) { // Check if the filename is not empty if(!value.empty()) { // Check that the right extension is given : expected .xml if (itksys::SystemTools::GetFilenameLastExtension(value) == ".xml") { if (itksys::SystemTools::FileExists(value.c_str(),true)) { this->SetValue(value); return true; } } } return false; } void InputProcessXMLParameter::SetValue(const std::string value) { itkDebugMacro("setting member m_FileName to " << value); this->m_FileName = value; SetActive(true); this->Modified(); } ImagePixelType InputProcessXMLParameter::GetPixelTypeFromString(std::string strType) { if(strType == "uint8") { return ImagePixelType_uint8; } else if (strType == "int16") { return ImagePixelType_int16; } else if (strType == "uint16") { return ImagePixelType_uint16; } else if(strType == "int32") { return ImagePixelType_int32; } else if(strType == "uint32") { return ImagePixelType_uint32; } else if(strType == "float") { return ImagePixelType_float; } else if(strType == "double") { return ImagePixelType_double; } else { /*by default return float. Eg: if strType is empty because of no pixtype node in xml which was the case earlier */ return ImagePixelType_float; } } void InputProcessXMLParameter::otbAppLogInfo(Application::Pointer app, std::string info) { app->GetLogger()->Write(itk::LoggerBase::INFO, info ); } /* copied from Utilities/tinyXMLlib/tinyxml.cpp. Must have a FIX inside tinyxml.cpp */ FILE* InputProcessXMLParameter::TiXmlFOpen( const char* filename, const char* mode ) { #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) FILE* fp = 0; errno_t err = fopen_s( &fp, filename, mode ); if ( !err && fp ) return fp; return 0; #else return fopen( filename, mode ); #endif } const std::string InputProcessXMLParameter::GetChildNodeTextOf(TiXmlElement *parentElement, std::string key) { std::string value=""; if(parentElement) { TiXmlElement* childElement = ITK_NULLPTR; childElement = parentElement->FirstChildElement(key.c_str()); //same as childElement->GetText() does but that call is failing if there is //no such node. //but the below code works and is a replacement for GetText() if(childElement) { const TiXmlNode* child = childElement->FirstChild(); if ( child ) { const TiXmlText* childText = child->ToText(); if ( childText ) { value = childText->Value(); } } } } return value; } int InputProcessXMLParameter::Read(Application::Pointer this_) { // Open the xml file TiXmlDocument doc; //Use itksys::SystemTools::FOpen() and close it below because //TiXmlDocument::TiXmlFileOpen( ) is not exposed from tinyXML library. Even //though its available in the TiXmlDocument::SaveFile(). FILE* fp = itksys::SystemTools::Fopen(m_FileName.c_str(), "rb"); if (!doc.LoadFile(fp , TIXML_ENCODING_UTF8)) { fclose(fp); itkExceptionMacro(<< "Can't open file " << m_FileName); } TiXmlHandle handle(&doc); TiXmlElement *n_OTB; n_OTB = handle.FirstChild("OTB").Element(); if(!n_OTB) { std::string info = "Input XML file " + std::string(this->GetFileName()) + " is invalid."; //this->otbAppLogInfo(app,info); } std::string otb_Version; otb_Version = GetChildNodeTextOf(n_OTB,"version"); if(otb_Version != OTB_VERSION_STRING) otbMsgDebugMacro( << "Input XML was generated with a different version of OTB (" << otb_Version << ") and current version is OTB (" << OTB_VERSION_STRING << ")" ); /* std::string otb_Version, otb_Build, otb_Platform; otb_Version = this_->GetChildNodeTextOf(n_OTB,"version"); otb_Build = GetChildNodeTextOf(n_OTB, "build"); otb_Platform = this_->GetChildNodeTextOf(n_OTB, "platform"); */ int ret = 0; TiXmlElement *n_AppNode = n_OTB->FirstChildElement("application"); std::string app_Name; app_Name = GetChildNodeTextOf(n_AppNode, "name"); /* AddMetaData("appname", app_Name); app_Descr = this_->GetChildNodeTextOf(n_AppNode, "descr"); AddMetaData("appdescr", app_Descr); TiXmlElement* n_Doc = n_AppNode->FirstChildElement("doc"); std::string doc_Name, doc_Descr, doc_Author, doc_Limitation, doc_SeeAlso; doc_Name = this_->GetChildNodeTextOf(n_Doc, "name"); AddMetaData("docname", doc_Name); doc_Descr = this_->GetChildNodeTextOf(n_Doc, "longdescr"); AddMetaData("doclongdescr", doc_Descr); doc_Author = this_->GetChildNodeTextOf(n_Doc, "authors"); AddMetaData("docauthors", doc_Author); doc_Limitation = this_->GetChildNodeTextOf(n_Doc, "limitations"); AddMetaData("doclimitations", doc_Limitation); doc_SeeAlso = this_->GetChildNodeTextOf(n_Doc, "seealso"); AddMetaData("docseealso", doc_SeeAlso); */ if(this_->GetName() != app_Name) { //hopefully shouldn't reach here ... /* std::string message = "Input XML was generated for a different application( " + app_Name + ") while application loaded is:" + this_->GetName(); */ itkWarningMacro( << "Input XML was generated for a different application( " << app_Name << ") while application loaded is:" <GetName()); fclose(fp); return -1; } ParameterGroup::Pointer paramGroup = this_->GetParameterList(); // Iterate through the parameter list for( TiXmlElement* n_Parameter = n_AppNode->FirstChildElement("parameter"); n_Parameter != ITK_NULLPTR; n_Parameter = n_Parameter->NextSiblingElement() ) { std::string key,typeAsString, value, paramName; std::vector values; key = GetChildNodeTextOf(n_Parameter, "key"); typeAsString = GetChildNodeTextOf(n_Parameter, "type"); value = GetChildNodeTextOf(n_Parameter, "value"); paramName = GetChildNodeTextOf(n_Parameter, "name"); ParameterType type = paramGroup->GetParameterTypeFromString(typeAsString); Parameter* param = this_->GetParameterByKey(key); // std::cout // << "'" << paramName << "'\t" // << key << "\t" // << typeAsString << "\t" // << type << "\t" // << ParameterType_OutputImage << "\t" // << param->HasUserValue() << "\t" // << value << std::endl; param->SetUserValue(true); param->SetActive(true); TiXmlElement* n_Values = ITK_NULLPTR; n_Values = n_Parameter->FirstChildElement("values"); if(n_Values) { for(TiXmlElement* n_Value = n_Values->FirstChildElement("value"); n_Value != ITK_NULLPTR; n_Value = n_Value->NextSiblingElement()) { values.push_back(n_Value->GetText()); } } if ( type == ParameterType_OutputFilename || type == ParameterType_OutputVectorData || type == ParameterType_String || type == ParameterType_Choice || type == ParameterType_RAM) { this_->SetParameterString(key, value); } else if( type == ParameterType_OutputImage ) { assert( dynamic_cast< OutputImageParameter * >( param )==param ); OutputImageParameter * outImageParam = dynamic_cast< OutputImageParameter * >( param ); assert( outImageParam!=ITK_NULLPTR ); outImageParam->SetFileName( value ); std::string pixelType( GetChildNodeTextOf(n_Parameter, "pixtype" ) ); if( pixelType.empty() ) std::runtime_error( "Invalid pixel type (empty string)." ); outImageParam->SetPixelType( GetPixelTypeFromString( pixelType ) ); } else if (type == ParameterType_ComplexOutputImage) { ComplexOutputImageParameter* paramDown = dynamic_cast(param); if(paramDown!=ITK_NULLPTR) paramDown->SetFileName(value); } else if (type == ParameterType_Directory) { DirectoryParameter* paramDown = dynamic_cast(param); if(paramDown!=ITK_NULLPTR) paramDown->SetValue(value); } else if (type == ParameterType_InputFilename) { InputFilenameParameter* paramDown = dynamic_cast(param); if(paramDown!=ITK_NULLPTR) paramDown->SetValue(value); } else if (type == ParameterType_InputImage) { if(itksys::SystemTools::FileExists(value.c_str())) { InputImageParameter* paramDown = dynamic_cast(param); if(paramDown!=ITK_NULLPTR) { paramDown->SetFromFileName(value); if (!paramDown->SetFromFileName(value)) { ret= -1; } } } else { otbMsgDevMacro( << "InputImageFile saved in InputXML does not exists" ); } } else if (type == ParameterType_ComplexInputImage) { if(itksys::SystemTools::FileExists(value.c_str())) { ComplexInputImageParameter* paramDown = dynamic_cast(param); if(paramDown!=ITK_NULLPTR) paramDown->SetFromFileName(value); } } else if (dynamic_cast(param)) { if(itksys::SystemTools::FileExists(value.c_str())) { InputVectorDataParameter* paramDown = dynamic_cast(param); paramDown->SetFromFileName(value); if ( !paramDown->SetFromFileName(value) ) { ret = -1; } } } else if (dynamic_cast(param)) { InputImageListParameter* paramDown = dynamic_cast(param); paramDown->SetListFromFileName(values); if ( !paramDown->SetListFromFileName(values) ) { ret = -1; } } else if (dynamic_cast(param)) { InputVectorDataListParameter* paramDown = dynamic_cast(param); paramDown->SetListFromFileName(values); if ( !paramDown->SetListFromFileName(values) ) { ret = -1; } } else if (dynamic_cast(param)) { InputFilenameListParameter* paramDown = dynamic_cast(param); paramDown->SetListFromFileName(values); if ( !paramDown->SetListFromFileName(values) ) { ret= -1; } } else if (type == ParameterType_Radius || type == ParameterType_Int || typeAsString == "rand" ) { int intValue; std::stringstream(value) >> intValue; this_->SetParameterInt(key, intValue); } else if (type == ParameterType_Float) { float floatValue; std::stringstream(value) >> floatValue; this_->SetParameterFloat(key, floatValue); } else if (type == ParameterType_Empty) { bool emptyValue = false; if( value == "true") { emptyValue = true; } this_->SetParameterEmpty(key, emptyValue); } else if (type == ParameterType_StringList || type == ParameterType_ListView) { if(values.empty()) itkWarningMacro(<< key << " has null values"); this_->SetParameterStringList(key, values); } } //end updateFromXML //choice also comes as setint and setstring why?? ret = 0; //resetting return to zero, we don't use it anyway for now. fclose(fp); return ret; } } //end namespace wrapper } //end namespace otb OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputVectorDataListParameter.cxx000066400000000000000000000155621301006202600333650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputVectorDataListParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperMacros.h" namespace otb { namespace Wrapper { InputVectorDataListParameter::InputVectorDataListParameter() { this->SetName("Input VectorData List"); this->SetKey("vdList"); m_VectorDataList = VectorDataListType::New(); m_ReaderList = VectorDataFileReaderListType::New(); } InputVectorDataListParameter::~InputVectorDataListParameter() { } bool InputVectorDataListParameter::SetListFromFileName(const std::vector & filenames) { // First clear previous file chosen this->ClearValue(); bool isOk = true; for(unsigned int i=0; iSetFileName(filename); reader->UpdateOutputInformation(); } catch(itk::ExceptionObject & /*err*/) { this->ClearValue(); isOk = false; break; } // everything went fine, store the object references m_ReaderList->PushBack(reader); m_VectorDataList->PushBack(reader->GetOutput()); } } if( !isOk ) { return false; } SetActive(true); this->Modified(); return true; } void InputVectorDataListParameter::AddNullElement() { m_ReaderList->PushBack(ITK_NULLPTR); m_VectorDataList->PushBack(ITK_NULLPTR); SetActive(false); this->Modified(); } bool InputVectorDataListParameter::AddFromFileName(const std::string & filename) { // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) if (!filename.empty()) { VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(filename); try { reader->UpdateOutputInformation(); } catch(itk::ExceptionObject & /*err*/) { this->ClearValue(); return false; } // everything went fine, store the object references m_ReaderList->PushBack(reader); m_VectorDataList->PushBack(reader->GetOutput()); SetActive(true); this->Modified(); return true; } return false; } bool InputVectorDataListParameter::SetNthFileName( const unsigned int id, const std::string & filename ) { if( m_ReaderList->Size()Size()<<" vector data available."); } // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) if (!filename.empty()) { VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(filename); try { reader->UpdateOutputInformation(); } catch(itk::ExceptionObject &) { this->ClearValue(); return false; } m_ReaderList->SetNthElement(id, reader); m_VectorDataList->SetNthElement(id, reader->GetOutput()); this->Modified(); return true; } return false; } std::vector InputVectorDataListParameter::GetFileNameList() const { if (m_ReaderList) { std::vector filenames; for(unsigned int i=0; iSize(); i++) { if( m_ReaderList->GetNthElement(i) ) filenames.push_back( m_ReaderList->GetNthElement(i)->GetFileName() ); } return filenames; } itkExceptionMacro(<< "No filename value"); } std::string InputVectorDataListParameter::GetNthFileName( unsigned int i ) const { if (m_ReaderList) { if(m_ReaderList->Size()Size()<<" vector data available."); } return m_ReaderList->GetNthElement(i)->GetFileName(); } itkExceptionMacro(<< "No filename value"); } VectorDataListType* InputVectorDataListParameter::GetVectorDataList() const { return m_VectorDataList; } VectorDataType* InputVectorDataListParameter::GetNthVectorData(unsigned int i) const { if(m_VectorDataList->Size()Size()<<" vector data available."); } return m_VectorDataList->GetNthElement(i); } void InputVectorDataListParameter::SetVectorDataList(VectorDataListType* vdList) { // Check input availability // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) try { for(unsigned int i=0; iSize(); i++) { vdList->GetNthElement( i )->UpdateOutputInformation(); } } catch(itk::ExceptionObject &) { return; } m_VectorDataList = vdList; m_ReaderList = VectorDataFileReaderListType::Pointer(); for(unsigned int i=0; iSize(); i++) { m_ReaderList->PushBack( VectorDataFileReaderType::Pointer() ); } SetActive(true); this->Modified(); } void InputVectorDataListParameter::AddVectorData(VectorDataType* vectorData) { // Check input availability // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) try { vectorData->UpdateOutputInformation(); } catch(itk::ExceptionObject &) { return; } m_VectorDataList->PushBack( vectorData ); m_ReaderList->PushBack( VectorDataFileReaderType::Pointer() ); this->Modified(); } bool InputVectorDataListParameter::HasValue() const { if (m_VectorDataList->Size() == 0) { return false; } bool res(true); unsigned int i(0); while (i < m_VectorDataList->Size() && res == true) { res = m_VectorDataList->GetNthElement(i).IsNotNull(); i++; } return res; } void InputVectorDataListParameter::Erase( unsigned int id ) { if(m_VectorDataList->Size()Size()<<" vector data available."); } m_VectorDataList->Erase( id ); m_ReaderList->Erase( id ); this->Modified(); } void InputVectorDataListParameter::ClearValue() { m_VectorDataList->Clear(); m_ReaderList->Clear(); SetActive(false); this->Modified(); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputVectorDataParameter.cxx000066400000000000000000000055271301006202600325310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputVectorDataParameter.h" namespace otb { namespace Wrapper { InputVectorDataParameter::InputVectorDataParameter() { this->SetName("Input VectorData"); this->SetKey("in"); this->ClearValue(); } InputVectorDataParameter::~InputVectorDataParameter() { } bool InputVectorDataParameter::SetFromFileName(const std::string& filename) { // First clear previous file chosen this->ClearValue(); // TODO : when the logger will be available, redirect the exception // in the logger (like what is done in MsgReporter) if (!filename.empty() && itksys::SystemTools::FileExists(filename.c_str())) { VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); try { reader->SetFileName(filename); reader->UpdateOutputInformation(); } catch(itk::ExceptionObject & /*err*/) { return false; } // the specified filename is valid => store the value m_FileName = filename; SetActive(true); return true; } return false; } VectorDataType* InputVectorDataParameter::GetVectorData() { // 2 cases : the user sets a filename vs. the user sets a vector data //////////////////////// Filename case: if (!m_FileName.empty()) { //typedef otb::ImageFileReader ReaderType; //typename ReaderType::Pointer reader = ReaderType::New(); m_Reader = VectorDataFileReaderType::New(); m_Reader->SetFileName(m_FileName); try { // Update the viewer here to load the file => no streaming for VectorData m_Reader->Update(); } catch (itk::ExceptionObject &) { this->ClearValue(); } m_VectorData = m_Reader->GetOutput(); } //////////////////////// VectorData case: else { if (m_VectorData.IsNull()) { // Else : error itkExceptionMacro("No input vector data or filename detected..."); } } return m_VectorData; } void InputVectorDataParameter::SetVectorData(VectorDataType* vectorData) { m_VectorData = vectorData; } bool InputVectorDataParameter::HasValue() const { if( m_FileName.empty() && m_VectorData.IsNull() ) return false; else return true; } void InputVectorDataParameter::ClearValue() { m_VectorData = ITK_NULLPTR; m_Reader = ITK_NULLPTR; m_FileName = ""; } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperListViewParameter.cxx000066400000000000000000000102531301006202600312130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperListViewParameter.h" namespace otb { namespace Wrapper { ListViewParameter::ListViewParameter() : m_CurrentChoice(0) { } ListViewParameter::~ListViewParameter() { } void ListViewParameter::AddChoice( std::string choicekey, std::string choiceName ) { ListViewChoice choice; choice.m_Key = choicekey; choice.m_Name = choiceName; m_ChoiceList.push_back(choice); } std::string ListViewParameter::GetChoiceKey( int i ) { if (m_ChoiceList.empty()) { return ""; } else { return m_ChoiceList[i].m_Key; } } std::vector ListViewParameter::GetChoiceKeys( ) { std::vector ret; ChoiceList::iterator it = m_ChoiceList.begin(); for (it = m_ChoiceList.begin(); it != m_ChoiceList.end(); ++it) { ret.push_back(it->m_Key); } return ret; } std::string ListViewParameter::GetChoiceName( int i ) { if (m_ChoiceList.empty()) { return ""; } else { return m_ChoiceList[i].m_Name; } } std::vector ListViewParameter::GetChoiceNames( ) { std::vector ret; ChoiceList::iterator it = m_ChoiceList.begin(); for (it = m_ChoiceList.begin(); it != m_ChoiceList.end(); ++it) { ret.push_back(it->m_Name); } return ret; } unsigned int ListViewParameter::GetNbChoices( void ) { return m_ChoiceList.size(); } void ListViewParameter::SetValue(unsigned int v) { m_CurrentChoice = v; SetActive(true); // Call Modified(); this->Modified(); } void ListViewParameter::SetValue(std::string choiceKey) { ChoiceList::iterator it = m_ChoiceList.begin(); unsigned int i = 0; for (it = m_ChoiceList.begin(); it != m_ChoiceList.end(); ++it) { if ( it->m_Key == choiceKey ) { SetValue(i); return; } ++i; } itkExceptionMacro(<< "Cannot find " << choiceKey); } unsigned int ListViewParameter::GetValue() { return m_CurrentChoice; } /** Clear choices */ void ListViewParameter::ClearChoices() { m_ChoiceList.clear(); } void ListViewParameter::SetSelectedItemsByNames() { std::vector selectedItems; std::vector names = this->GetChoiceNames(); for(unsigned int i=0; iSetSelectedItems(selectedItems); } void ListViewParameter::SetSelectedItemsByKeys() { std::vector selectedItems; std::vector keys = this->GetChoiceKeys(); for(unsigned int i=0; iSetSelectedItems(selectedItems); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperMapProjectionParametersHandler.cxx000066400000000000000000000222051301006202600337000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperMapProjectionParametersHandler.h" // Needed for methods relative to projections #include "otbMapProjections.h" #include "otbImageToGenericRSOutputParameters.h" #include "otbWrapperInputImageListParameter.h" namespace otb { namespace Wrapper { void MapProjectionParametersHandler::AddMapProjectionParameters( Application::Pointer app, const std::string & key) { app->AddParameter(ParameterType_Choice, key, "Output Cartographic Map Projection"); app->SetParameterDescription(key,"Parameters of the output map projection to be used."); // utm std::ostringstream oss; oss << key<<".utm"; app->AddChoice(oss.str(), "Universal Trans-Mercator (UTM)"); app->SetParameterDescription(oss.str(),"A system of transverse mercator projections dividing the surface of Earth between 80S and 84N latitude."); oss << ".zone"; app->AddParameter(ParameterType_Int, oss.str(), "Zone number"); app->SetParameterDescription(oss.str(),"The zone number ranges from 1 to 60 and allows defining the transverse mercator projection (along with the hemisphere)"); app->SetMinimumParameterIntValue(oss.str(), 1); app->SetDefaultParameterInt(oss.str(), 31); oss.str(""); oss <AddParameter(ParameterType_Empty, oss.str(), "Northern Hemisphere"); app->SetParameterDescription(oss.str(),"The transverse mercator projections are defined by their zone number as well as the hemisphere. Activate this parameter if your image is in the northern hemisphere."); // lambert2 oss.str(""); oss << key<<".lambert2"; app->AddChoice(oss.str(), "Lambert II Etendu"); app->SetParameterDescription(oss.str(),"This is a Lambert Conformal Conic projection mainly used in France."); // lambert93 oss.str(""); oss << key<<".lambert93"; app->AddChoice(oss.str(), "Lambert93"); app->SetParameterDescription(oss.str(), "This is a Lambert 93 projection mainly used in France."); // Transmercator /*oss.str(""); oss << key<<".transmercator"; app->AddChoice(oss.str(), "Transmercator"); app->SetParameterDescription(oss.str(), "This is a Transverse Mercator, a cylindrical projection widely used. The required values are set by default."); std::ostringstream subParamKey; subParamKey<AddParameter(ParameterType_Float, subParamKey.str(), "False easting"); app->SetParameterDescription( subParamKey.str(), " Transmercator false easting value."); app->SetDefaultParameterFloat(subParamKey.str(), 0.); subParamKey.str(""); subParamKey<AddParameter(ParameterType_Float, subParamKey.str(), "False northing"); app->SetParameterDescription(subParamKey.str(), " Transmercator false northing value."); app->SetDefaultParameterFloat(subParamKey.str(), 0.); subParamKey.str(""); subParamKey<AddParameter(ParameterType_Float, subParamKey.str(), "Scale factor"); app->SetParameterDescription(subParamKey.str(), " Transmercator scale factor value."); app->SetDefaultParameterFloat(subParamKey.str(), 1.); */ // wgs84 oss.str(""); oss << key<<".wgs"; app->AddChoice(oss.str(), "WGS 84"); app->SetParameterDescription(oss.str(),"This is a Geographical projection"); // epsg code oss.str(""); oss<AddChoice(oss.str(),"EPSG Code"); app->SetParameterDescription(oss.str(), "This code is a generic way of identifying map projections, and allows specifying a large amount of them. See www.spatialreference.org to find which EPSG code is associated to your projection;"); oss <<".code"; app->AddParameter(ParameterType_Int, oss.str(), "EPSG Code"); app->SetParameterDescription(oss.str(),"See www.spatialreference.org to find which EPSG code is associated to your projection"); app->SetDefaultParameterInt(oss.str(), 4326); app->SetParameterString(key, "utm"); } /** * Helper method : Compute the ProjectionRef knowing the map * projection picked up by the user * */ const std::string MapProjectionParametersHandler::GetProjectionRefFromChoice(const Application::Pointer app, const std::string & key) { std::ostringstream zoneKey; zoneKey << key<<".utm.zone"; std::ostringstream hemKey; hemKey << key<<".utm.northhem"; std::ostringstream epsgKey; epsgKey << key <<".epsg.code"; // Get the user choice switch ( app->GetParameterInt(key) ) { case Map_Utm: { typedef UtmInverseProjection UtmProjectionType; UtmProjectionType::Pointer utmProjection = UtmProjectionType::New(); // Set the zone utmProjection->SetZone(app->GetParameterInt(zoneKey.str())); // Set the hem char hem = 'N'; if (!app->IsParameterEnabled(hemKey.str())) hem = 'S'; utmProjection->SetHemisphere(hem); // Get the projection ref return utmProjection->GetWkt(); } break; case Map_Lambert2: { typedef Lambert2EtenduForwardProjection Lambert2ProjectionType; Lambert2ProjectionType::Pointer lambert2Projection = Lambert2ProjectionType::New(); return lambert2Projection->GetWkt(); } break; case Map_Lambert93: { typedef otb::Lambert93InverseProjection Lambert93ProjectionType; Lambert93ProjectionType::Pointer lambert93Projection = Lambert93ProjectionType::New(); return lambert93Projection->GetWkt(); } break; /*case Map_Transmercator: { typedef otb::TransMercatorInverseProjection TransMercatorProjectionType; TransMercatorProjectionType::Pointer transMercatorProjection = TransMercatorProjectionType::New(); // Get the Transmercator parameters std::ostringstream falseeasting; std::ostringstream falsenorthing; std::ostringstream scale; falseeasting <SetParameters(app->GetParameterFloat( falseeasting.str() ), app->GetParameterFloat( falsenorthing.str() ), app->GetParameterFloat( scale.str()) ); return transMercatorProjection->GetWkt(); } break; */ case Map_WGS84: { return otb::GeoInformationConversion::ToWKT(4326); } break; case Map_Epsg: { return otb::GeoInformationConversion::ToWKT(app->GetParameterInt(epsgKey.str())); } break; } return ""; } /** * Helper method : Compute the UTM parameters relative to an image Origin * Note: The key of the image must be set to be able to get the image. * The key must be totally if the InputImageParameter belongs * to a ParameterGroup, ie set io.in */ void MapProjectionParametersHandler::InitializeUTMParameters(Application::Pointer app, const std::string & imageKey, const std::string & mapKey ) { // Get the UTM params keys std::ostringstream zoneKey; zoneKey << mapKey << ".utm.zone"; std::ostringstream hemKey; hemKey << mapKey << ".utm.northhem"; // Compute the zone and the hemisphere if not UserValue defined if (!app->HasUserValue(zoneKey.str()) && app->HasValue(imageKey)) { // Compute the Origin lat/long coordinate typedef otb::ImageToGenericRSOutputParameters OutputParametersEstimatorType; OutputParametersEstimatorType::Pointer genericRSEstimator = OutputParametersEstimatorType::New(); Parameter* param = app->GetParameterByKey(imageKey); if (dynamic_cast (param)) { genericRSEstimator->SetInput(app->GetParameterImage(imageKey)); } else if (dynamic_cast (param)) { genericRSEstimator->SetInput(app->GetParameterImageList(imageKey)->GetNthElement(0)); } genericRSEstimator->SetOutputProjectionRef(otb::GeoInformationConversion::ToWKT(4326)); genericRSEstimator->Compute(); int zone = otb::Utils::GetZoneFromGeoPoint(genericRSEstimator->GetOutputOrigin()[0], genericRSEstimator->GetOutputOrigin()[1]); // Update the UTM Gui fields app->SetParameterInt(zoneKey.str(), zone); if (genericRSEstimator->GetOutputOrigin()[1] > 0.) { app->EnableParameter(hemKey.str()); } else { app->DisableParameter(hemKey.str()); } app->AutomaticValueOn(zoneKey.str()); app->AutomaticValueOn(hemKey.str()); } } }// End namespace Wrapper }// End namespace otb OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperOutputImageParameter.cxx000066400000000000000000000354611301006202600317200ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperOutputImageParameter.h" #include "otbClampImageFilter.h" #include "otbClampVectorImageFilter.h" #ifdef OTB_USE_MPI #include "otbMPIConfig.h" #include "otbMPIVrtWriter.h" #ifdef OTB_USE_SPTW #include "otbSimpleParallelTiffWriter.h" #endif #endif namespace otb { namespace Wrapper { OutputImageParameter::OutputImageParameter() : m_PixelType(ImagePixelType_float), m_DefaultPixelType(ImagePixelType_float), m_RAMValue(0) { this->SetName("Output Image"); this->SetKey("out"); } OutputImageParameter::~OutputImageParameter() { } std::string OutputImageParameter::ConvertPixelTypeToString(ImagePixelType type) { std::string ret; switch(type) { case ImagePixelType_uint8: { ret = "uint8"; break; } case ImagePixelType_int16: { ret = "int16"; break; } case ImagePixelType_uint16: { ret = "uint16"; break; } case ImagePixelType_int32: { ret = "int32"; break; } case ImagePixelType_uint32: { ret = "uint32"; break; } case ImagePixelType_float: { ret = "float"; break; } case ImagePixelType_double: { ret = "double"; break; } } return ret; } void OutputImageParameter::InitializeWriters() { m_UInt8Writer = UInt8WriterType::New(); m_Int16Writer = Int16WriterType::New(); m_UInt16Writer = UInt16WriterType::New(); m_Int32Writer = Int32WriterType::New(); m_UInt32Writer = UInt32WriterType::New(); m_FloatWriter = FloatWriterType::New(); m_DoubleWriter = DoubleWriterType::New(); m_VectorUInt8Writer = VectorUInt8WriterType::New(); m_VectorInt16Writer = VectorInt16WriterType::New(); m_VectorUInt16Writer = VectorUInt16WriterType::New(); m_VectorInt32Writer = VectorInt32WriterType::New(); m_VectorUInt32Writer = VectorUInt32WriterType::New(); m_VectorFloatWriter = VectorFloatWriterType::New(); m_VectorDoubleWriter = VectorDoubleWriterType::New(); m_RGBUInt8Writer = RGBUInt8WriterType::New(); m_RGBAUInt8Writer = RGBAUInt8WriterType::New(); } template void ClampAndWriteImage(itk::ImageBase<2> * in, otb::ImageFileWriter * writer, const std::string & filename, const unsigned int & ramValue) { typedef otb::ClampImageFilter ClampFilterType; typename ClampFilterType::Pointer clampFilter = ClampFilterType::New(); clampFilter->SetInput( dynamic_cast(in)); bool useStandardWriter = true; #ifdef OTB_USE_MPI otb::MPIConfig::Pointer mpiConfig = otb::MPIConfig::Instance(); if (mpiConfig->GetNbProcs() > 1) { useStandardWriter = false; // Get file extension std::string extension = itksys::SystemTools::GetFilenameExtension(filename); if(extension == ".vrt") { // Use the WriteMPI function WriteMPI(clampFilter->GetOutput(),filename,ramValue); } #ifdef OTB_USE_SPTW else if (extension == ".tif") { // Use simple parallel tiff writer typedef otb::SimpleParallelTiffWriter SPTWriterType; typename SPTWriterType::Pointer sptWriter = SPTWriterType::New(); sptWriter->SetFileName(filename); sptWriter->SetInput(clampFilter->GetOutput()); sptWriter->SetAutomaticAdaptativeStreaming(ramValue); sptWriter->Update(); } #endif else { itkGenericExceptionMacro("File format "<SetFileName( filename ); writer->SetInput(clampFilter->GetOutput()); writer->SetAutomaticAdaptativeStreaming(ramValue); writer->Update(); } } template void ClampAndWriteVectorImage(itk::ImageBase<2> * in, otb::ImageFileWriter * writer, const std::string & filename, const unsigned int & ramValue) { typedef otb::ClampVectorImageFilter ClampFilterType; typename ClampFilterType::Pointer clampFilter = ClampFilterType::New(); clampFilter->SetInput( dynamic_cast(in)); bool useStandardWriter = true; #ifdef OTB_USE_MPI otb::MPIConfig::Pointer mpiConfig = otb::MPIConfig::Instance(); if (mpiConfig->GetNbProcs() > 1) { useStandardWriter = false; // Get file extension std::string extension = itksys::SystemTools::GetFilenameExtension(filename); if(extension == ".vrt") { // Use the WriteMPI function WriteMPI(clampFilter->GetOutput(),filename,ramValue); } #ifdef OTB_USE_SPTW else if (extension == ".tif") { // Use simple parallel tiff writer typedef otb::SimpleParallelTiffWriter SPTWriterType; typename SPTWriterType::Pointer sptWriter = SPTWriterType::New(); sptWriter->SetFileName(filename); sptWriter->SetInput(clampFilter->GetOutput()); sptWriter->SetAutomaticAdaptativeStreaming(ramValue); sptWriter->Update(); } #endif else { itkGenericExceptionMacro("File format "<SetFileName( filename ); writer->SetInput(clampFilter->GetOutput()); writer->SetAutomaticAdaptativeStreaming(ramValue); writer->Update(); } } template void OutputImageParameter::SwitchImageWrite() { switch(m_PixelType ) { case ImagePixelType_uint8: { ClampAndWriteImage(m_Image,m_UInt8Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_int16: { ClampAndWriteImage(m_Image,m_Int16Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_uint16: { ClampAndWriteImage(m_Image,m_UInt16Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_int32: { ClampAndWriteImage(m_Image,m_Int32Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_uint32: { ClampAndWriteImage(m_Image,m_UInt32Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_float: { ClampAndWriteImage(m_Image,m_FloatWriter,m_FileName,m_RAMValue); break; } case ImagePixelType_double: { ClampAndWriteImage(m_Image,m_DoubleWriter,m_FileName,m_RAMValue); break; } } } template void OutputImageParameter::SwitchVectorImageWrite() { switch(m_PixelType ) { case ImagePixelType_uint8: { ClampAndWriteVectorImage(m_Image,m_VectorUInt8Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_int16: { ClampAndWriteVectorImage(m_Image,m_VectorInt16Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_uint16: { ClampAndWriteVectorImage(m_Image,m_VectorUInt16Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_int32: { ClampAndWriteVectorImage(m_Image,m_VectorInt32Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_uint32: { ClampAndWriteVectorImage(m_Image,m_VectorUInt32Writer,m_FileName,m_RAMValue); break; } case ImagePixelType_float: { ClampAndWriteVectorImage(m_Image,m_VectorFloatWriter,m_FileName,m_RAMValue); break; } case ImagePixelType_double: { ClampAndWriteVectorImage(m_Image,m_VectorDoubleWriter,m_FileName,m_RAMValue); break; } } } template void OutputImageParameter::SwitchRGBAImageWrite() { if( m_PixelType == ImagePixelType_uint8 ) { m_RGBAUInt8Writer->SetFileName( this->GetFileName() ); m_RGBAUInt8Writer->SetInput(dynamic_cast(m_Image.GetPointer()) ); m_RGBAUInt8Writer->SetAutomaticAdaptativeStreaming(m_RAMValue); m_RGBAUInt8Writer->Update(); } else itkExceptionMacro("Unknown PixelType for RGBA Image. Only uint8 is supported."); } template void OutputImageParameter::SwitchRGBImageWrite() { if( m_PixelType == ImagePixelType_uint8 ) { m_RGBUInt8Writer->SetFileName( this->GetFileName() ); m_RGBUInt8Writer->SetInput(dynamic_cast(m_Image.GetPointer()) ); m_RGBUInt8Writer->SetAutomaticAdaptativeStreaming(m_RAMValue); m_RGBUInt8Writer->Update(); } else itkExceptionMacro("Unknown PixelType for RGB Image. Only uint8 is supported."); } void OutputImageParameter::Write() { m_Image->UpdateOutputInformation(); if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchVectorImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchRGBImageWrite(); } else if (dynamic_cast(m_Image.GetPointer())) { SwitchRGBAImageWrite(); } else { itkExceptionMacro("Unknown image type"); } } itk::ProcessObject* OutputImageParameter::GetWriter() { int type = 0; // 0 : image // 1 : VectorImage // 2 : RGBAImage // 3 : RGBImage itk::ProcessObject* writer = ITK_NULLPTR; if (dynamic_cast (m_Image.GetPointer()) || dynamic_cast (m_Image.GetPointer()) || dynamic_cast (m_Image.GetPointer()) || dynamic_cast (m_Image.GetPointer()) || dynamic_cast (m_Image.GetPointer()) || dynamic_cast (m_Image.GetPointer()) || dynamic_cast (m_Image.GetPointer())) { type = 1; } else if (dynamic_cast (m_Image.GetPointer())) { type = 2; writer = m_RGBAUInt8Writer; itkWarningMacro("UInt8RGBAImageType will be saved in UInt8 format."); return writer; } else if (dynamic_cast (m_Image.GetPointer())) { type = 3; writer = m_RGBUInt8Writer; itkWarningMacro("UInt8RGBImageType will be saved in UInt8 format."); return writer; } switch (GetPixelType()) { case ImagePixelType_uint8: { switch(type) { case 0: writer = m_UInt8Writer; break; case 1: writer = m_VectorUInt8Writer; break; case 2: writer = m_RGBAUInt8Writer; break; default: writer = m_RGBUInt8Writer; break; } break; } case ImagePixelType_int16: { if (type == 1) writer = m_VectorInt16Writer; else if (type == 0) writer = m_Int16Writer; break; } case ImagePixelType_uint16: { if (type == 1) writer = m_VectorUInt16Writer; else if (type == 0) writer = m_UInt16Writer; break; } case ImagePixelType_int32: { if (type == 1) writer = m_VectorInt32Writer; else if (type == 0) writer = m_Int32Writer; break; } case ImagePixelType_uint32: { if (type == 1) writer = m_VectorUInt32Writer; else if (type == 0) writer = m_UInt32Writer; break; } case ImagePixelType_float: { if (type == 1) writer = m_VectorFloatWriter; else if (type == 0) writer = m_FloatWriter; break; } case ImagePixelType_double: { if (type == 1) writer = m_VectorDoubleWriter; else if (type == 0) writer = m_DoubleWriter; break; } } if (ITK_NULLPTR == writer) { itkExceptionMacro("Unknown Writer type."); } return writer; } OutputImageParameter::ImageBaseType* OutputImageParameter::GetValue( ) { return m_Image; } void OutputImageParameter::SetValue(ImageBaseType* image) { m_Image = image; SetActive(true); } bool OutputImageParameter::HasValue() const { std::string filename(this->GetFileName()); return !filename.empty(); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperOutputProcessXMLParameter.cxx000066400000000000000000000242431301006202600326710ustar00rootroot00000000000000 #include "otbWrapperOutputProcessXMLParameter.h" #include "otbWrapperChoiceParameter.h" #include "otbWrapperListViewParameter.h" #include "otbWrapperDirectoryParameter.h" #include "otbWrapperEmptyParameter.h" #include "otbWrapperInputFilenameParameter.h" #include "otbWrapperInputFilenameListParameter.h" #include "otbWrapperOutputFilenameParameter.h" #include "otbWrapperInputVectorDataParameter.h" #include "otbWrapperInputVectorDataListParameter.h" #include "otbWrapperOutputVectorDataParameter.h" #include "otbWrapperRadiusParameter.h" #include "otbWrapperStringListParameter.h" #include "otbWrapperInputImageParameter.h" #include "otbWrapperInputImageListParameter.h" #include "otbWrapperComplexInputImageParameter.h" #include "otbWrapperOutputImageParameter.h" #include "otbWrapperComplexOutputImageParameter.h" #include "otbWrapperRAMParameter.h" #include "itksys/SystemTools.hxx" namespace otb { namespace Wrapper { OutputProcessXMLParameter::OutputProcessXMLParameter() { this->SetKey("outxml"); this->SetName("Save otb application to xml file"); this->SetDescription("Save otb application to xml file"); this->SetMandatory(false); this->SetActive(false); this->SetRole(Role_Output); } OutputProcessXMLParameter::~OutputProcessXMLParameter() { } std::string OutputProcessXMLParameter::pixelTypeToString(ImagePixelType pixType) { std::string type; switch( pixType ) { case ImagePixelType_uint8: { type = "uint8"; break; } case ImagePixelType_int16: { type = "int16"; break; } case ImagePixelType_uint16: { type = "uint16"; break; } case ImagePixelType_int32: { type = "int32"; break; } case ImagePixelType_uint32: { type = "uint32"; break; } case ImagePixelType_float: { type = "float"; break; } case ImagePixelType_double: { type = "double"; break; } default: { type = "float"; break; } } return type; } TiXmlElement* OutputProcessXMLParameter::AddChildNodeTo(TiXmlElement *parent, std::string name, std::string value) { TiXmlElement * n_Node = new TiXmlElement( name.c_str() ); parent->LinkEndChild( n_Node ); if(!value.empty()) { TiXmlText * nv_NodeValue = new TiXmlText( value.c_str() ); n_Node->LinkEndChild( nv_NodeValue ); } return n_Node; } void OutputProcessXMLParameter::Write(Application::Pointer app) { // Check if the filename is not empty if(m_FileName.empty()) itkExceptionMacro("The XML output FileName is empty, please set the filename via the method SetFileName"); // Check that the right extension is given : expected .xml */ if (itksys::SystemTools::GetFilenameLastExtension(m_FileName) != ".xml") { itkExceptionMacro(<GetName()); AddChildNodeTo(n_App, "descr", app->GetDescription()); TiXmlElement *n_AppDoc; n_AppDoc = AddChildNodeTo(n_App, "doc"); AddChildNodeTo(n_AppDoc, "name", app->GetDocName()); AddChildNodeTo(n_AppDoc, "longdescr", app->GetDocLongDescription()); AddChildNodeTo(n_AppDoc, "authors", app->GetDocAuthors()); AddChildNodeTo(n_AppDoc, "limitations", app->GetDocLimitations()); AddChildNodeTo(n_AppDoc, "seealso", app->GetDocSeeAlso()); TiXmlElement *n_DocTags; n_DocTags = AddChildNodeTo(n_AppDoc, "tags"); std::vector docTagList = app->GetDocTags(); std::vector::iterator tagIt; for(tagIt = docTagList.begin(); tagIt!= docTagList.end(); ++tagIt) { std::string tag = *tagIt; AddChildNodeTo(n_DocTags, "tag", tag); } ParameterGroup::Pointer paramGroup = app->GetParameterList(); std::vector paramList = paramGroup->GetParametersKeys(true); // Iterate through parameters for (std::vector::const_iterator it = paramList.begin(); it!= paramList.end(); ++it) { std::string key = *it; Parameter *param = paramGroup->GetParameterByKey(key); std::string paramName = param->GetName(); ParameterType type = app->GetParameterType(key); std::string typeAsString = paramGroup->GetParameterTypeAsString(type); // if param is a Group, don't do anything, ParamGroup don't have values if (type != ParameterType_Group) { bool paramExists = app->HasUserValue(key) && app->IsParameterEnabled(key); if ( type == ParameterType_OutputProcessXML ) { paramExists = false; } std::string emptyValue; if (type == ParameterType_Empty) { EmptyParameter* eParam = dynamic_cast (param); if(eParam!=ITK_NULLPTR) { //Don't use app->HasUserValue which returns false always because of //EmptyParameter::HasValue() is false for EmptyParameter if(eParam->HasUserValue()) { paramExists = true; emptyValue = "false"; if( eParam->GetActive() ) { emptyValue = "true"; } } } } if(type == ParameterType_RAM) { paramExists = true; } // if parameter doesn't have any value then skip it if (paramExists) { std::vector values; std::string value; bool hasValueList = false; std::string pixelTypeAsString; if (type == ParameterType_OutputImage) { OutputImageParameter *imgParam = dynamic_cast(param); if(imgParam!=ITK_NULLPTR) { value = imgParam->GetFileName(); ImagePixelType pixType = imgParam->GetPixelType(); pixelTypeAsString = pixelTypeToString(pixType); } } else if( type == ParameterType_InputImageList || type == ParameterType_InputFilenameList || type == ParameterType_InputVectorDataList || type == ParameterType_StringList || type == ParameterType_ListView ) { values = app->GetParameterStringList(key); hasValueList = true; } else if (type == ParameterType_Int || type == ParameterType_Radius || type == ParameterType_RAM ) { value = app->GetParameterAsString(key); } else if(type == ParameterType_Float) { std::ostringstream oss; oss << std::setprecision(std::numeric_limits::digits10+1); oss << app->GetParameterFloat( key ); value = oss.str(); } else if ( type == ParameterType_String || type == ParameterType_InputFilename || type == ParameterType_Directory || type == ParameterType_InputImage || type == ParameterType_ComplexInputImage || type == ParameterType_InputVectorData || type == ParameterType_Choice || type == ParameterType_OutputVectorData || type == ParameterType_OutputFilename) { value = app->GetParameterString(key); } else if(key == "rand") { std::ostringstream strm; strm << app->GetParameterInt("rand"); value = strm.str(); } else if (typeAsString == "Empty") { //Nothing to do. copy emptyValue value = emptyValue; } //get only file name /* if(type == ParameterType_InputFilename || type == ParameterType_InputImage || type == ParameterType_ComplexInputImage || type == ParameterType_InputVectorData || type == ParameterType_OutputVectorData || type == ParameterType_OutputFilename) { unsigned found = value.find_last_of("/\\"); //std::cerr << " path: " << value.substr(0,found) << '\n'; value = value.substr(found+1); } else if(type == ParameterType_InputImageList || type == ParameterType_InputFilenameList || type == ParameterType_InputVectorDataList) { std::vector::iterator strIt; for(strIt = values.begin(); strIt != values.end(); ++strIt) { std::string val = *strIt; unsigned found = val.find_last_of("/\\"); *strIt = val.substr(found+1); } } */ //parameter node in xml TiXmlElement * n_Parameter = new TiXmlElement("parameter"); const char * mandatory = "false"; if( param->GetMandatory() ) mandatory = "true"; n_Parameter->SetAttribute("mandatory", mandatory); //setting parameter key as child node in parameter AddChildNodeTo(n_Parameter, "key", key); AddChildNodeTo(n_Parameter, "type", typeAsString); AddChildNodeTo(n_Parameter, "name", paramName); if(type == ParameterType_OutputImage || type == ParameterType_ComplexOutputImage) { AddChildNodeTo(n_Parameter, "pixtype", pixelTypeAsString); } if(!hasValueList) { AddChildNodeTo(n_Parameter, "value", value); } else { TiXmlElement *n_Values = AddChildNodeTo(n_Parameter, "values"); std::vector::iterator strIt; for(strIt = values.begin(); strIt != values.end(); ++strIt) { AddChildNodeTo(n_Values, "value",*strIt); } } n_App->LinkEndChild(n_Parameter); } } } // Finally, write xml contents to file doc.SaveFile( m_FileName.c_str() ); } } //end namespace wrapper } //end namespace otb OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperParameterGroup.cxx000066400000000000000000000456311301006202600305510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperChoiceParameter.h" #include "otbWrapperListViewParameter.h" #include "otbWrapperDirectoryParameter.h" #include "otbWrapperEmptyParameter.h" #include "otbWrapperInputFilenameParameter.h" #include "otbWrapperInputFilenameListParameter.h" #include "otbWrapperOutputFilenameParameter.h" #include "otbWrapperOutputProcessXMLParameter.h" #include "otbWrapperComplexInputImageParameter.h" #include "otbWrapperInputImageParameter.h" #include "otbWrapperInputVectorDataParameter.h" #include "otbWrapperOutputImageParameter.h" #include "otbWrapperComplexOutputImageParameter.h" #include "otbWrapperOutputVectorDataParameter.h" #include "otbWrapperRadiusParameter.h" #include "otbWrapperStringListParameter.h" #include "otbWrapperInputImageListParameter.h" #include "otbWrapperInputVectorDataListParameter.h" #include "otbWrapperInputProcessXMLParameter.h" #include "otbWrapperParameterKey.h" #include "otbWrapperRAMParameter.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { ParameterGroup::ParameterGroup() { } ParameterGroup::~ParameterGroup() { } std::vector ParameterGroup::GetParametersKeys(bool recursive) { std::vector parameters; ParameterListType::iterator pit; for (pit = m_ParameterList.begin(); pit != m_ParameterList.end(); ++pit) { Parameter* param = *pit; parameters.push_back( param->GetKey() ); if (recursive && dynamic_cast(param)) { ParameterGroup* paramAsGroup = dynamic_cast(param); std::vector subparams = paramAsGroup->GetParametersKeys(); for (std::vector::const_iterator it = subparams.begin(); it != subparams.end(); ++it) { parameters.push_back( std::string(paramAsGroup->GetKey()) + "." + *it ); } } else if (recursive && dynamic_cast(param)) { ChoiceParameter* paramAsChoice = dynamic_cast(param); std::vector subparams = paramAsChoice->GetParametersKeys(); for (std::vector::const_iterator it = subparams.begin(); it != subparams.end(); ++it) { parameters.push_back( std::string(paramAsChoice->GetKey()) + "." + *it ); } } } return parameters; } /** Add a new choice value to the parameter group */ void ParameterGroup::AddChoice(std::string paramKey, std::string paramName) { ParameterKey pKey( paramKey ); // Split the parameter name std::vector splitKey = pKey.Split(); if( splitKey.size() > 1 ) { // Get the last subkey std::string lastkey = pKey.GetLastElement(); std::string parentkey = pKey.GetRoot(); Parameter::Pointer parentParam = GetParameterByKey(parentkey); // parentParam must be a choice, a listBox or this is an error ChoiceParameter* comboboxParentAsChoice = dynamic_cast(parentParam.GetPointer()); ListViewParameter* listBoxParentAsChoice = dynamic_cast(parentParam.GetPointer()); if (comboboxParentAsChoice) { comboboxParentAsChoice->AddChoice(lastkey, paramName); } else if (listBoxParentAsChoice) { listBoxParentAsChoice->AddChoice(lastkey, paramName); } else { itkExceptionMacro(< splitKey = pKey.Split(); std::string parentkey; Parameter::Pointer parentParam; if (splitKey.size() > 1) { parentkey = pKey.GetRoot(); parentParam = GetParameterByKey(parentkey); } else { parentParam = GetParameterByKey(splitKey[0]); } // parentParam must be a choice, a listBox or this is an error ListViewParameter* listBoxParentAsChoice = dynamic_cast(parentParam.GetPointer()); if (listBoxParentAsChoice) { listBoxParentAsChoice->ClearChoices(); } else { itkExceptionMacro(<GetKey(); // const std::string descr = tmpParam->GetDescription(); const std::string defaultXMLFileName = std::string(GetName()) + ".xml"; tmpParam->SetActive(false); AddParameter(tmpParam); tmpParam = ITK_NULLPTR; /* AddParameter(ParameterType_OutputProcessXML, key, descr); SetParameterDescription(key, descr); MandatoryOff(key); //SetParameterString(key, defaultXMLFileName); DisableParameter(key); */ } void ParameterGroup::AddInXMLParameter() { Parameter::Pointer tmpParam; tmpParam = InputProcessXMLParameter::New(); // const std::string key = tmpParam->GetKey(); // const std::string descr = tmpParam->GetDescription(); const std::string defaultXMLFileName = std::string(GetName()) + ".xml"; tmpParam->SetActive(false); AddParameter(tmpParam); tmpParam = ITK_NULLPTR; /* AddParameter(ParameterType_InputProcessXML, key, descr); SetParameterDescription(key, descr); MandatoryOff(key); //SetParameterString(key, defaultXMLFileName); DisableParameter(key); */ } /** Get the choices made in the QListWidget */ std::vector ParameterGroup::GetSelectedItems(std::string paramKey) { std::vector selectedItems; ParameterKey pKey( paramKey ); // Split the parameter name std::vector splitKey = pKey.Split(); std::string parentkey; Parameter::Pointer parentParam; if (splitKey.size() > 1) { parentkey = pKey.GetRoot(); parentParam = GetParameterByKey(parentkey); } else { parentParam = GetParameterByKey(splitKey[0]); } // parentParam must be a choice, a listBox or this is an error ListViewParameter* listBoxParentAsChoice = dynamic_cast(parentParam.GetPointer()); if (listBoxParentAsChoice) { selectedItems = listBoxParentAsChoice->GetSelectedItems(); } else { itkExceptionMacro(< splitKey = pKey.Split(); // Get the last subkey std::string lastkey = pKey.GetLastElement(); std::string parentkey; Parameter::Pointer parentParam; if (splitKey.size() > 1) { parentkey = pKey.GetRoot(); parentParam = GetParameterByKey(parentkey); } else { parentParam = this; } ParameterGroup* parentAsGroup = dynamic_cast (parentParam.GetPointer()); if (parentAsGroup) { Parameter::Pointer newParam; switch (type) { case ParameterType_Empty: { newParam = EmptyParameter::New(); } break; case ParameterType_Int: { newParam = IntParameter::New(); } break; case ParameterType_Float: { newParam = FloatParameter::New(); } break; case ParameterType_String: { newParam = StringParameter::New(); } break; case ParameterType_InputFilename: { newParam = InputFilenameParameter::New(); } break; case ParameterType_OutputFilename: { newParam = OutputFilenameParameter::New(); } break; case ParameterType_Directory: { newParam = DirectoryParameter::New(); } break; case ParameterType_InputImage: { newParam = InputImageParameter::New(); } break; case ParameterType_InputVectorData: { newParam = InputVectorDataParameter::New(); } break; case ParameterType_OutputImage: { newParam = OutputImageParameter::New(); } break; case ParameterType_OutputVectorData: { newParam = OutputVectorDataParameter::New(); } break; case ParameterType_Radius: { newParam = RadiusParameter::New(); } break; case ParameterType_Choice: { newParam = ChoiceParameter::New(); } break; case ParameterType_Group: { newParam = ParameterGroup::New(); } break; case ParameterType_StringList: { newParam = StringListParameter::New(); } break; case ParameterType_InputFilenameList: { newParam = InputFilenameListParameter::New(); } break; case ParameterType_InputImageList: { newParam = InputImageListParameter::New(); } break; case ParameterType_InputVectorDataList: { newParam = InputVectorDataListParameter::New(); } break; case ParameterType_ListView: { newParam = ListViewParameter::New(); } break; case ParameterType_ComplexInputImage: { newParam = ComplexInputImageParameter::New(); } break; case ParameterType_ComplexOutputImage: { newParam = ComplexOutputImageParameter::New(); } break; case ParameterType_RAM: { newParam = RAMParameter::New(); } break; case ParameterType_OutputProcessXML: { newParam = OutputProcessXMLParameter::New(); } break; case ParameterType_InputProcessXML: { newParam = InputProcessXMLParameter::New(); } break; } if (newParam.IsNull()) { itkExceptionMacro(<< "Parameter type not supported for " << paramKey); } newParam->SetKey(lastkey); newParam->SetName(paramName); // If splitKey is greater than 1, that means that the parameter // is not a root, and have a parent(s): // - Add the parent as root of this param // - Add the param as a child of its parents if (splitKey.size() > 1) { newParam->SetRoot(parentParam); parentParam->AddChild(newParam); } parentAsGroup->AddParameter(newParam); } else { itkExceptionMacro(<< "Cannot add " << lastkey << " to parameter " << parentkey); } } void ParameterGroup::AddParameter(Parameter::Pointer p) { m_ParameterList.push_back(p); } Parameter::Pointer ParameterGroup::GetParameterByIndex(unsigned int i) { return m_ParameterList[i]; } Parameter::Pointer ParameterGroup::GetParameterByKey(std::string name) { ParameterKey pName(name); // Split the parameter name std::vector splitName = pName.Split(); // Get the first parameter key std::string parentName = pName.GetFirstElement(); // Look for parentName in the current group Parameter::Pointer parentParam; ParameterListType::iterator vit; for (vit = m_ParameterList.begin(); vit != m_ParameterList.end(); ++vit) { Parameter::Pointer param = *vit; if (param->GetKey() == parentName) { parentParam = param; break; } } if (parentParam.IsNull()) { itkExceptionMacro(<< "Could not find parameter " << name) } // If the name contains a child, make a recursive call if (splitName.size() > 1) { // Handle ParameterGroup case ParameterGroup* parentAsGroup = dynamic_cast(parentParam.GetPointer()); if (parentAsGroup) { // Remove the parent from the param name std::ostringstream childNameOss; std::vector::const_iterator vvit = splitName.begin() + 1; while(vvit != splitName.end()) { childNameOss << *vvit; ++vvit; if (vvit != splitName.end()) { childNameOss << "."; } } std::string childName = childNameOss.str(); return parentAsGroup->GetParameterByKey(childName); } // Handle ChoiceParameter case ChoiceParameter* parentAsChoice = dynamic_cast(parentParam.GetPointer()); if (parentAsChoice) { // Check that splitName[1] is one of the choice ParameterGroup::Pointer associatedParam; // will throw if splitName[1] is not a choice key associatedParam = parentAsChoice->GetChoiceParameterGroupByKey(splitName[1]); if (splitName.size() > 2) { if (associatedParam.IsNull()) { itkExceptionMacro(<< "Choice " << splitName[1] << "in " << splitName[0] << " has no key named " << splitName[2]); } // Remove the parent and the choice value from the param name std::ostringstream childNameOss; std::vector::const_iterator vvvit = splitName.begin() + 2; while(vvvit != splitName.end()) { childNameOss << *vvvit; ++vvvit; if (vvvit != splitName.end()) { childNameOss << "."; } } std::string childName = childNameOss.str(); return associatedParam->GetParameterByKey(childName); } return associatedParam.GetPointer(); } // Neither ParameterGroup, neither ChoiceParameter itkExceptionMacro(<< "No parameter with key " << name); } return parentParam.GetPointer(); } unsigned int ParameterGroup::GetNumberOfParameters() { return m_ParameterList.size(); } } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/src/otbWrapperParameterKey.cxx000066400000000000000000000031471301006202600302010ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperParameterKey.h" #include "otb_boost_string_header.h" namespace otb { namespace Wrapper { ParameterKey::ParameterKey() : m_Key("") { } ParameterKey::ParameterKey( const char * val ) { this->SetKey(std::string(val)); } ParameterKey::ParameterKey( const std::string & val ) { this->SetKey(val); } ParameterKey::~ParameterKey() { } std::string ParameterKey::GetLastElement() { return m_Key.substr( m_Key.find_last_of(".")+1, m_Key.size() ); } std::string ParameterKey::GetFirstElement() { return m_Key.substr( 0, m_Key.find_first_of(".") ); } std::string ParameterKey::GetRoot() { return m_Key.substr( 0, m_Key.find_last_of(".") ); } std::vector ParameterKey::Split() { std::vector res; boost::split(res, m_Key, boost::is_any_of("."), boost::token_compress_on); return res; } void ParameterKey::Append( const std::string & val ) { m_Key.append("."); m_Key.append(val); } void ParameterKey::Append( const ParameterKey & pKey ) { this->Append( pKey.GetKey() ); } } // end namespace Wrapper } //end namespace otb OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/000077500000000000000000000000001301006202600232015ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/0000436-WrapperInputImage_GetImage.cxx000066400000000000000000000023571301006202600317130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperInputImageParameter.h" #include "otbLineSegmentDetector.h" #include "otbVectorDataFileWriter.h" #include "otbImageFileWriter.h" // Code showing a problem calling twice GetImputImageParameter // http://bugs.orfeo-toolbox.org/view.php?id=436 int main(int argc, char *argv[]) { if (argc != 3) { std::cout << "Usage : " << std::endl; return EXIT_FAILURE; } typedef otb::Wrapper::InputImageParameter InputImageParameterType; InputImageParameterType::Pointer param = InputImageParameterType::New(); param->SetFromFileName(argv[2]); if( param->GetImage() != param->GetImage() ) { return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/CMakeLists.txt000066400000000000000000000123761301006202600257520ustar00rootroot00000000000000otb_module_test() set(OTBApplicationEngineTests otbApplicationEngineTestDriver.cxx otbWrapperApplicationTest.cxx otbWrapperParameterTest.cxx otbWrapperInputImageParameterTest.cxx otbWrapperNumericalParameterTest.cxx otbWrapperStringParameterTest.cxx otbWrapperChoiceParameterTest.cxx otbWrapperApplicationRegistryTest.cxx otbWrapperStringListParameterTest.cxx otbWrapperRAMParameterTest.cxx otbWrapperDocExampleStructureTest.cxx otbWrapperParameterKeyTest.cxx otbWrapperParameterListTest.cxx otbWrapperEmptyParameterTest.cxx otbWrapperInputImageListParameterTest.cxx otbWrapperInputVectorDataListParameterTest.cxx otbWrapperApplicationDocTests.cxx otbWrapperApplicationHtmlDocGeneratorTest.cxx otbWrapperInputVectorDataParameterTest.cxx otbWrapperOutputImageParameterTest.cxx otbApplicationMemoryConnectTest.cxx ) add_executable(otbApplicationEngineTestDriver ${OTBApplicationEngineTests}) target_link_libraries(otbApplicationEngineTestDriver ${OTBApplicationEngine-Test_LIBRARIES}) otb_module_target_label(otbApplicationEngineTestDriver) # Tests Declaration otb_add_test(NAME owTuApplication COMMAND otbApplicationEngineTestDriver otbWrapperApplicationNew ) otb_add_test(NAME owTvParameter COMMAND otbApplicationEngineTestDriver otbWrapperParameterTest1 "param1" ) otb_add_test(NAME owTuParameterNew COMMAND otbApplicationEngineTestDriver otbWrapperParameterNew ) otb_add_test(NAME owTvInputImageParameter COMMAND otbApplicationEngineTestDriver otbWrapperInputImageParameterTest1 ${INPUTDATA}/poupees.tif "mykey" "my description" ) otb_add_test(NAME owTuInputImageParameter COMMAND otbApplicationEngineTestDriver otbWrapperInputImageParameterNew ) otb_add_test(NAME owTuNumericalParameter COMMAND otbApplicationEngineTestDriver otbWrapperNumericalParameterNew ) otb_add_test(NAME owTvNumericalParameter COMMAND otbApplicationEngineTestDriver otbWrapperNumericalParameterTest1 42.42 "mykey" "my description" ) otb_add_test(NAME owTuStringParameter COMMAND otbApplicationEngineTestDriver otbWrapperStringParameterNew ) otb_add_test(NAME owTvStringParameter COMMAND otbApplicationEngineTestDriver otbWrapperStringParameterTest1 "value1" "mykey" "my description" ) otb_add_test(NAME owTvApplicationRegistry COMMAND otbApplicationEngineTestDriver otbWrapperApplicationRegistry ) otb_add_test(NAME owTuStringListParameter COMMAND otbApplicationEngineTestDriver otbWrapperStringListParameterNew ) otb_add_test(NAME owTvStringListParameter COMMAND otbApplicationEngineTestDriver otbWrapperStringListParameterTest1 "value1" "value2" "value3" "mykey" "my description" ) otb_add_test(NAME owTvParameterRAM COMMAND otbApplicationEngineTestDriver otbWrapperRAMParameterNew ) otb_add_test(NAME owTvParameterKey COMMAND otbApplicationEngineTestDriver otbWrapperParameterKey ) otb_add_test(NAME owTuEmptyParameter COMMAND otbApplicationEngineTestDriver otbWrapperEmptyParameterNew ) otb_add_test(NAME owTuInputImageListParameter COMMAND otbApplicationEngineTestDriver otbWrapperInputImageListParameterNew ) otb_add_test(NAME owTvInputImageListParameter COMMAND otbApplicationEngineTestDriver otbWrapperInputImageListParameterTest1 ${INPUTDATA}/poupees_c1.hdr ${INPUTDATA}/poupees.tif "mykey" "my description" ) otb_add_test(NAME owTuInputVectorDataListParameter COMMAND otbApplicationEngineTestDriver otbWrapperInputVectorDataListParameterNew ) otb_add_test(NAME owTvInputVectorDataListParameter COMMAND otbApplicationEngineTestDriver otbWrapperInputVectorDataListParameterTest1 ${INPUTDATA}/ToulousePoints-examples.shp ${INPUTDATA}/ToulouseRoads-examples.shp "mykey" "my description" ) otb_add_test(NAME owTvApplicationHtmlDocGeneratorTest COMMAND otbApplicationEngineTestDriver --compare-ascii ${NOTOL} ${BASELINE}/owTvOReadImageInfoDoc.html ${TEMP}/owTvOReadImageInfoDoc.html otbWrapperApplicationHtmlDocGeneratorTest1 ReadImageInfo $ ${TEMP}/owTvOReadImageInfoDoc.html 0 # don't show key in the parameterdescription ) otb_add_test(NAME owTvApplicationHtmlDocGeneratorNew COMMAND otbApplicationEngineTestDriver otbWrapperApplicationHtmlDocGeneratorNew ) otb_add_test(NAME owTuInputVectorDataParameter COMMAND otbApplicationEngineTestDriver otbWrapperInputVectorDataParameterNew ) otb_add_test(NAME owTuOutputImageParameter COMMAND otbApplicationEngineTestDriver otbWrapperOutputImageParameterNew ) otb_add_test(NAME owTvOutputImageParameter COMMAND otbApplicationEngineTestDriver otbWrapperOutputImageParameterTest1 ${INPUTDATA}/poupees.tif ${TEMP}/owTvOutputImageParameter2.tif "mykey" "my description" ) otb_add_test(NAME owTvDocExampleStructureTest COMMAND otbApplicationEngineTestDriver --compare-ascii ${NOTOL} ${BASELINE}/owTuDocExampleStructureTest.txt ${TEMP}/owTuDocExampleStructureTest.txt otbWrapperDocExampleStructureTest ${TEMP}/owTuDocExampleStructureTest.txt ) otb_add_test(NAME owTuDocExampleStructureNew COMMAND otbApplicationEngineTestDriver otbWrapperDocExampleStructureNew ) otb_add_test(NAME owTvApplicationMemoryConnectTest COMMAND otbApplicationEngineTestDriver otbApplicationMemoryConnectTest $ ${INPUTDATA}/poupees.tif ${TEMP}/owTvApplicationMemoryConnectTestOutput.tif) OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbApplicationEngineTestDriver.cxx000066400000000000000000000031231301006202600320360ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbWrapperApplicationNew); REGISTER_TEST(otbWrapperParameterNew); REGISTER_TEST(otbWrapperParameterTest1); REGISTER_TEST(otbWrapperInputImageParameterNew); REGISTER_TEST(otbWrapperInputImageParameterTest1); REGISTER_TEST(otbWrapperNumericalParameterNew); REGISTER_TEST(otbWrapperNumericalParameterTest1); REGISTER_TEST(otbWrapperStringParameterNew); REGISTER_TEST(otbWrapperStringParameterTest1); REGISTER_TEST(otbWrapperChoiceParameterNew); REGISTER_TEST(otbWrapperChoiceParameterTest1); REGISTER_TEST(otbWrapperApplicationRegistry); REGISTER_TEST(otbWrapperStringListParameterNew); REGISTER_TEST(otbWrapperStringListParameterTest1); REGISTER_TEST(otbWrapperRAMParameterNew); REGISTER_TEST(otbWrapperDocExampleStructureNew); REGISTER_TEST(otbWrapperDocExampleStructureTest); REGISTER_TEST(otbWrapperParameterKey); REGISTER_TEST(otbWrapperParameterListNew); REGISTER_TEST(otbWrapperEmptyParameterNew); REGISTER_TEST(otbWrapperInputImageListParameterNew); REGISTER_TEST(otbWrapperInputImageListParameterTest1); REGISTER_TEST(otbWrapperInputVectorDataListParameterNew); REGISTER_TEST(otbWrapperInputVectorDataListParameterTest1); REGISTER_TEST(otbWrapperApplicationDocTest); REGISTER_TEST(otbWrapperApplicationHtmlDocGeneratorNew); REGISTER_TEST(otbWrapperApplicationHtmlDocGeneratorTest1); REGISTER_TEST(otbWrapperInputVectorDataParameterNew); REGISTER_TEST(otbWrapperOutputImageParameterNew); REGISTER_TEST(otbWrapperOutputImageParameterTest1); REGISTER_TEST(otbApplicationMemoryConnectTest); } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbApplicationMemoryConnectTest.cxx000066400000000000000000000042231301006202600322410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperApplicationRegistry.h" int otbApplicationMemoryConnectTest(int argc, char * argv[]) { if(argc<4) { std::cerr<<"Usage: "<SetParameterString("in",infname); app1->Execute(); app2->SetParameterString("out",outfname); // Connect app1 to app2 app2->SetParameterInputImage("in",app1->GetParameterOutputImage("out")); app2->Execute(); app3->SetParameterString("in",infname); app3->Execute(); app4->AddImageToParameterInputImageList("il",app2->GetParameterOutputImage("out")); app4->AddImageToParameterInputImageList("il",app3->GetParameterOutputImage("out")); app4->ExecuteAndWriteOutput(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperApplicationDocTests.cxx000066400000000000000000000065101301006202600317110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperApplicationRegistry.h" int otbWrapperApplicationDocTest(int argc, char* argv[]) { if (argc < 2) { std::cerr << "Usage : " << argv[0] << " module_name [MODULEPATH]" << std::endl; return EXIT_FAILURE; } // Load path for( int i=2; iGetName()) == "" ) { std::cout<<"Missing Name."<GetDocName()) == "" ) { std::cout<<"Missing Doc Name."<GetDescription()) == "" ) { std::cout<<"Missing Description."<GetDocLongDescription()) == "" ) { std::cout<<"Missing DocLongDescription."<GetDocLongDescription()).size() < 30 ) { std::cout<<"DocLongDescription too small..."<GetDocAuthors()) == "" ) { std::cout<<"Missing DocAuthors."<GetDocLimitations()) == "" ) { std::cout<<"Missing DocLimitations."<GetDocSeeAlso()) == "" ) { std::cout<<"Missing DocSeeAlso."<GetDocTags().size() == 0 ) { std::cout<<"Missing DocTags."<Init(); otb::Wrapper::DocExampleStructure::Pointer doc = app->GetDocExample(); if( doc->GetApplicationName() == "" ) { std::cout<<"Error in doc example: no aaplication name found."<GetParameterList().size() == 0 ) { std::cout<<"Error in doc example: the list of parameter is empty."<GetParameterList().size() && !hasValue ) { if( doc->GetParameterValue(count) != "" ) { hasValue = true; } count++; } if( !hasValue ) { std::cout<<"Error in doc example: no value for the example found !!!"<Init(); // Create the documentation output file DocGeneratorType::GenerateDoc( app, std::string(argv[3]), static_cast(atoi(argv[4])) ); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperApplicationRegistryTest.cxx000066400000000000000000000021271301006202600326310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperApplicationRegistry.h" int otbWrapperApplicationRegistry(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { using otb::Wrapper::ApplicationRegistry; std::vector list = ApplicationRegistry::GetAvailableApplications(); std::cout << "Available applications :" << std::endl; std::vector::const_iterator it; for (it = list.begin(); it != list.end(); ++it) { std::cout << *it << std::endl; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperApplicationTest.cxx000066400000000000000000000015651301006202600311050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperApplication.h" int otbWrapperApplicationNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { // typedef otb::Wrapper::Application ApplicationType; // ApplicationType application = ApplicationType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperChoiceParameterTest.cxx000066400000000000000000000020131301006202600316620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperChoiceParameter.h" int otbWrapperChoiceParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::ChoiceParameter ChoiceParameterType; ChoiceParameterType::Pointer parameter = ChoiceParameterType::New(); return EXIT_SUCCESS; } int otbWrapperChoiceParameterTest1(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { // TODO return EXIT_FAILURE; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperDocExampleStructureTest.cxx000066400000000000000000000034311301006202600325760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperDocExampleStructure.h" #include "itksys/SystemTools.hxx" #include int otbWrapperDocExampleStructureNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::DocExampleStructure DocExampleStructureType; DocExampleStructureType::Pointer docStruct = DocExampleStructureType::New(); return EXIT_SUCCESS; } int otbWrapperDocExampleStructureTest(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::DocExampleStructure DocExampleStructureType; DocExampleStructureType::Pointer docStruct = DocExampleStructureType::New(); docStruct->SetApplicationName("TestApplication"); docStruct->SetExampleComment("Exmaple1", 0); docStruct->AddParameter( "key1", "val1_1" ); docStruct->AddParameter( "key2", "val1_2" ); docStruct->AddExample("Example2"); docStruct->AddParameter( "key2", "val2_2", 1 ); docStruct->AddParameter( "key3", "name3" ); docStruct->AddParameter( "key3", "val2_3", 1 ); std::ofstream ofs( argv[1] ); if (!ofs.is_open()) { fprintf(stderr, "Error, can't open file"); return EXIT_FAILURE; } ofs << docStruct->GenerateCLExample(); ofs.close(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperEmptyParameterTest.cxx000066400000000000000000000016651301006202600316020ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperEmptyParameter.h" int otbWrapperEmptyParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::EmptyParameter EmptyParameterType; EmptyParameterType::Pointer parameter = EmptyParameterType::New(); //std::cout << parameter << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperInputImageListParameterTest.cxx000066400000000000000000000025511301006202600333750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperInputImageListParameter.h" int otbWrapperInputImageListParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::InputImageListParameter ParameterType; ParameterType::Pointer parameter = ParameterType::New(); return EXIT_SUCCESS; } int otbWrapperInputImageListParameterTest1(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::InputImageListParameter ParameterType; ParameterType::Pointer param = ParameterType::New(); const std::string inputFilename1 = argv[1]; const std::string inputFilename2 = argv[2]; param->AddFromFileName(inputFilename1); param->AddFromFileName(inputFilename2); param->SetKey(argv[3]); param->SetDescription(argv[4]); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperInputImageParameterTest.cxx000066400000000000000000000024011301006202600325330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperInputImageParameter.h" int otbWrapperInputImageParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::InputImageParameter InputImageParameterType; InputImageParameterType::Pointer parameter = InputImageParameterType::New(); return EXIT_SUCCESS; } int otbWrapperInputImageParameterTest1(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::InputImageParameter InputImageParameterType; InputImageParameterType::Pointer param = InputImageParameterType::New(); param->SetFromFileName(argv[1]); param->SetKey(argv[2]); param->SetDescription(argv[3]); return EXIT_SUCCESS; } otbWrapperInputVectorDataListParameterTest.cxx000066400000000000000000000026021301006202600343250ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperInputVectorDataListParameter.h" int otbWrapperInputVectorDataListParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::InputVectorDataListParameter ParameterType; ParameterType::Pointer parameter = ParameterType::New(); return EXIT_SUCCESS; } int otbWrapperInputVectorDataListParameterTest1(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::InputVectorDataListParameter ParameterType; ParameterType::Pointer param = ParameterType::New(); const std::string inputFilename1 = argv[1]; const std::string inputFilename2 = argv[2]; param->AddFromFileName(inputFilename1); param->AddFromFileName(inputFilename2); param->SetKey(argv[3]); param->SetDescription(argv[4]); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperInputVectorDataParameterTest.cxx000066400000000000000000000017071301006202600335550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperInputVectorDataParameter.h" int otbWrapperInputVectorDataParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::InputVectorDataParameter InputVectorDataParameterType; InputVectorDataParameterType::Pointer parameter = InputVectorDataParameterType::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperNumericalParameterTest.cxx000066400000000000000000000025611301006202600324170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperNumericalParameter.h" int otbWrapperNumericalParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::NumericalParameter NumericalParameterType; NumericalParameterType::Pointer parameter = NumericalParameterType::New(); return EXIT_SUCCESS; } int otbWrapperNumericalParameterTest1(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::NumericalParameter NumericalParameterType; NumericalParameterType::Pointer numParam = NumericalParameterType::New(); const double value = atof (argv[1]); const std::string key = argv[2]; const std::string desc = argv[3]; numParam->SetValue(value); numParam->SetKey(key); numParam->SetDescription(desc); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperOutputImageParameterTest.cxx000066400000000000000000000032401301006202600327360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperOutputImageParameter.h" #include "otbImageFileReader.h" #include "otbWrapperTypes.h" int otbWrapperOutputImageParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::OutputImageParameter OutputImageParameterType; OutputImageParameterType::Pointer parameter = OutputImageParameterType::New(); return EXIT_SUCCESS; } int otbWrapperOutputImageParameterTest1(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::OutputImageParameter OutputImageParameterType; OutputImageParameterType::Pointer param = OutputImageParameterType::New(); typedef otb::ImageFileReader< otb::Wrapper::FloatVectorImageType > ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); reader->UpdateOutputInformation(); param->SetValue(reader->GetOutput()); param->SetFileName( argv[2] ); param->SetKey(argv[3]); param->SetDescription(argv[4]); // an explicit writer initialization is needed param->InitializeWriters(); param->Write(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperParameterKeyTest.cxx000066400000000000000000000051311301006202600312240ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperParameterKey.h" int otbWrapperParameterKey(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { std::string theKey = "parent.current.child"; otb::Wrapper::ParameterKey pKey; pKey.SetKey( theKey ); if( pKey.GetKey() != theKey ) { std::cout<<"Error in Set/GetKey method. Waiting for \""< tmp = pKey.Split(); if(tmp.size() != 3) { std::cout<<"Error in Split method. Waiting for a 3 size vector, receiving a vector of size "<SetName(name); if (name == parameter->GetName()) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperRAMParameterTest.cxx000066400000000000000000000040261301006202600311150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperRAMParameter.h" int otbWrapperRAMParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::RAMParameter RAMParameterType; RAMParameterType::Pointer parameter = RAMParameterType::New(); // Test Set/Get Value parameter->SetValue(256); parameter->SetValue(2560); parameter->SetValue(128); std::cout <<"Last RAMParameter Value set : " << parameter->GetValue() << std::endl; // Test Set/Get Default, extremum value RAMParameterType::ScalarType min = 0; RAMParameterType::ScalarType max = 1024; RAMParameterType::ScalarType def = 256; parameter->SetDefaultValue(def); parameter->SetMinimumValue(min); parameter->SetMaximumValue(max); if (parameter->GetMinimumValue() != min) { std::cout <<"Minimum Value : expexted "<< min << " --> got "<< parameter->GetMinimumValue() << std::endl; return EXIT_FAILURE; } if (parameter->GetMaximumValue() != max) { std::cout <<"Maximum Value : expexted "<< max << " --> got "<< parameter->GetMaximumValue() << std::endl; return EXIT_FAILURE; } if (parameter->GetDefaultValue() != def) { std::cout <<"Default Value : expexted "<< def<< " --> got "<< parameter->GetDefaultValue() << std::endl; return EXIT_FAILURE; } // Reset Value parameter->Reset(); std::cout <<"Last RAMParameter Value set : " << parameter->GetValue() << std::endl; return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperStringListParameterTest.cxx000066400000000000000000000033541301006202600326030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperStringListParameter.h" int otbWrapperStringListParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::StringListParameter StringListParameterType; StringListParameterType::Pointer parameter = StringListParameterType::New(); return EXIT_SUCCESS; } int otbWrapperStringListParameterTest1(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::StringListParameter StringListParameterType; StringListParameterType::Pointer numParam = StringListParameterType::New(); const std::string value1 = argv[1]; const std::string value2 = argv[2]; const std::string value3 = argv[3]; const std::string key = argv[4]; const std::string desc = argv[5]; numParam->AddString(value1); StringListParameterType::StringListType sList; sList.push_back(value2); sList.push_back(value3); numParam->SetValue( sList ); numParam->SetKey(key); numParam->SetDescription(desc); if( numParam->GetValue()[0] != value2 ) { return EXIT_FAILURE; } if( numParam->GetNthElement(1) != value3 ) { return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/ApplicationEngine/test/otbWrapperStringParameterTest.cxx000066400000000000000000000025021301006202600317410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperStringParameter.h" int otbWrapperStringParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[]) { typedef otb::Wrapper::StringParameter StringParameterType; StringParameterType::Pointer parameter = StringParameterType::New(); return EXIT_SUCCESS; } int otbWrapperStringParameterTest1(int itkNotUsed(argc), char* argv[]) { typedef otb::Wrapper::StringParameter StringParameterType; StringParameterType::Pointer numParam = StringParameterType::New(); const std::string value = argv[1]; const std::string key = argv[2]; const std::string desc = argv[3]; numParam->SetValue(value); numParam->SetKey(key); numParam->SetDescription(desc); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/CommandLine/000077500000000000000000000000001301006202600210175ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/CommandLine/CMakeLists.txt000066400000000000000000000001301301006202600235510ustar00rootroot00000000000000project(OTBCommandLine) set(OTBCommandLine_LIBRARIES OTBCommandLine) otb_module_impl() OTB-release-5.8/Modules/Wrappers/CommandLine/include/000077500000000000000000000000001301006202600224425ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/CommandLine/include/otbWrapperCommandLineLauncher.h000066400000000000000000000134761301006202600305440ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperCommandLineLauncher_h #define otbWrapperCommandLineLauncher_h #include "otbWrapperApplication.h" #include "otbWrapperParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperCommandLineParser.h" #include "itkStdStreamLogOutput.h" #include "otbStandardOneLineFilterWatcher.h" #include "itkCommand.h" #include namespace otb { namespace Wrapper { /** \class CommandLineLauncher * \brief This class check the validity of a command line application. * * To be valid, the expression must be as follow: * ModuleName (ModulePath) --attribut1_Key attribut1_Value --attribut2_Key * attribut2_Value * After the attribute key, if the user give several values (expression * without \"--\" separated by space), it will automatically be * interpreted as a list. * * \ingroup OTBCommandLine */ class ITK_ABI_EXPORT CommandLineLauncher : public itk::Object { public: /** Standard class typedefs. */ typedef CommandLineLauncher Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(CommandLineLauncher, itk::Object); /** Parse result enum */ typedef CommandLineParser::ParseResultType ParseResultType; typedef enum { OKPARAM, MISSINGMANDATORYPARAMETER, MISSINGPARAMETERVALUE, WRONGPARAMETERVALUE, INVALIDNUMBEROFVALUE, DEFAULT} ParamResultType; /** Filter watcher list type */ typedef std::vector WatcherListType; /** Command Member */ typedef itk::MemberCommand< Self > AddProcessCommandType; /** Load the application in several steps : * - Load the paths * - Load the application using the ApplicationRegistry */ bool Load(); /** same as Load method but set the expression before. */ bool Load(const std::vector &vexp); /** Launch the process, using the Execute application method * The method will check if the user asked for help (looking at * --help key) before loading parameter and launching process. **/ bool Execute(); /** Launch the process, using the ExecuteAndWriteOutput application * method * The method will check if the user asked for help (looking at * --help key) before loading parameter and launching process. */ bool ExecuteAndWriteOutput(); /** Gather the code process to do before Execute and * ExecuteAndWriteOutput * Returns false if a problem occurs, true otherwise. */ bool BeforeExecute(); /** Create and display the help of the application */ void DisplayHelp(); /** Performs specific action for testing environment */ void LoadTestEnv(); protected: /** Constructor */ CommandLineLauncher(); /** \deprecated * Constructor with exp argument is deprecated because class * CommandLineLauncher does not have expression attribute anymore. Use instead the * default constructor. It is included for backwards compatibility. */ CommandLineLauncher(const char * exp); /** Destructor */ ~CommandLineLauncher() ITK_OVERRIDE; /** Load the executable path. It looks for the key --modulePath, * extract and interpret as path the following strings. */ bool LoadPath(); /** Load the application calling the CreateApplication method of the * ApplicationRegistry classes. * Pay attention, the executable paths have to be loaded or set in * the environment before calling the function. */ void LoadApplication(); /** Parse the user expression, extract the key and the associated * string and set it as value of each corresponding application * parameter. */ CommandLineLauncher::ParamResultType LoadParameters(); /** Create and display the help of the application */ std::string DisplayParameterHelp( const Parameter::Pointer & param, const std::string paramKey ); /** Check if each key is unique in the expression. */ bool CheckUnicity(); /** Check if option contains at least one "-". */ bool CheckParametersPrefix(); /** Check if each key is valid for the application. */ bool CheckKeyValidity(std::string& key); /** Display the output parameter (Role == RoleOutput) */ void DisplayOutputParameters(); /** Load the watchers for internal progress and writing progress report. */ void LinkWatchers(itk::Object * caller, const itk::EventObject & event); /** Clear watcher list, deleting its pointers. */ void DeleteWatcherList(); private: CommandLineLauncher(const CommandLineLauncher &); //purposely not implemented void operator =(const CommandLineLauncher&); //purposely not implemented std::string m_Path; Application::Pointer m_Application; //std::string m_Expression; std::vector m_VExpression; CommandLineParser::Pointer m_Parser; WatcherListType m_WatcherList; itk::StdStreamLogOutput::Pointer m_LogOutput; AddProcessCommandType::Pointer m_AddProcessCommand; bool m_ReportProgress; unsigned int m_MaxKeySize; }; //end class } // end namespace Wrapper } //end namespace otb #endif // otbWrapperCommandLineLauncher_h_ OTB-release-5.8/Modules/Wrappers/CommandLine/include/otbWrapperCommandLineParser.h000066400000000000000000000102451301006202600302260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperCommandLineParser_h #define otbWrapperCommandLineParser_h #include "itkObjectFactory.h" namespace otb { namespace Wrapper { /** \class CommandLineParser * \brief This class check the validity of a command line application. * * To be valid, the expression must be as follow: * ModuleName (ModulePaths) --attribut1_Key attrubut1_Value --attribut2_Key attrubut2_Value * After the attribut key, if the user give several values (expression without \"--\" separated by space), it will automacally be interpreted as a list. * * \ingroup OTBCommandLine */ class ITK_ABI_EXPORT CommandLineParser : public itk::Object { public: /** Standard class typedefs. */ typedef CommandLineParser Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Defining ::New() static method */ itkNewMacro(Self); /** RTTI support */ itkTypeMacro(CommandLineParser, itk::Object); /** Parse result enum */ typedef enum { OK, NOMODULENAME, MULTIPLEMODULENAME, INVALIDMODULENAME, NOMODULEPATH, INVALIDMODULEPATH, DEFAULT} ParseResultType; /** Get the attribut associatd to a key (list of element after the key and before the next "--") as a vector of string. */ std::vector GetAttribut( const std::string & key, const std::string & exp ); std::vector GetAttribut( const std::string & key, const std::vector & exp ); /** Get the attribut associatd to a key (list of element after the key and before the next "--") as a string separated by spaces. */ std::string GetAttributAsString( const std::string & key, const std::string & exp ); std::string GetAttributAsString( const std::string & key, const std::vector & exp ); /** Look if a given key is in an expression. */ bool IsAttributExists(const std::string key, const std::string & exp ); bool IsAttributExists(const std::string key, const std::vector & exp); /** Get the paths executables in an expression. Store the list in a vector of string. */ CommandLineParser::ParseResultType GetPaths( std::vector & paths, const std::string & exp ); CommandLineParser::ParseResultType GetPaths( std::vector & paths, const std::vector & exp ); /** Get the paths executables in an expression. Store the list in a vector of string. */ std::string GetPathsAsString( const std::string & exp ); std::string GetPathsAsString( const std::vector & vexp ); /** Get the module name in an expression. It can be the first element of the expression (if the expression doesn't start with a "--" or the attribut associated to the key m_ModuleNameKey). */ CommandLineParser::ParseResultType GetModuleName( std::string & modName, const std::string & exp ); CommandLineParser::ParseResultType GetModuleName( std::string & modName, const std::vector & exp ); /** Get the list of keys in an expression. That is to say each word starting by "--". */ std::vector GetKeyList( const std::string & exp ); std::vector GetKeyList( const std::vector & exp); protected: /** Constructor */ CommandLineParser(); /** Destructor */ ~CommandLineParser() ITK_OVERRIDE; private: CommandLineParser(const CommandLineParser &); //purposely not implemented void operator =(const CommandLineParser&); //purposely not implemented /** Return true if the found key is valid : not a number */ bool IsAValidKey( const std::string & foundKey ); }; //end class } // end namespace Wrapper } //end namespace otb #endif // otbWrapperCommandLineParser_h_ OTB-release-5.8/Modules/Wrappers/CommandLine/otb-module.cmake000066400000000000000000000004701301006202600240710ustar00rootroot00000000000000set(DOCUMENTATION "Required to launch applications from command line.") otb_module(OTBCommandLine DEPENDS OTBCommon OTBITK OTBTinyXML OTBApplicationEngine OPTIONAL_DEPENDS OTBMPIConfig TEST_DEPENDS OTBTestKernel OTBAppImageUtils DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Wrappers/CommandLine/src/000077500000000000000000000000001301006202600216065ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/CommandLine/src/CMakeLists.txt000066400000000000000000000040141301006202600243450ustar00rootroot00000000000000set(OTBCommandLine_SRC otbWrapperCommandLineLauncher.cxx otbWrapperCommandLineParser.cxx ) add_library(OTBCommandLine ${OTBCommandLine_SRC}) target_link_libraries(OTBCommandLine ${OTBApplicationEngine_LIBRARIES} ${OTBTinyXML_LIBRARIES} ${OTBCommon_LIBRARIES} ) otb_module_target(OTBCommandLine) add_executable(otbApplicationLauncherCommandLine otbApplicationLauncherCommandLine.cxx) target_link_libraries(otbApplicationLauncherCommandLine OTBCommandLine) otb_module_target(otbApplicationLauncherCommandLine) set_linker_stack_size_flag(otbApplicationLauncherCommandLine 10000000) # Where we will install the script in the build tree get_target_property(CLI_OUTPUT_DIR otbApplicationLauncherCommandLine RUNTIME_OUTPUT_DIRECTORY) # Generate a script in the build dir, next to the cli launcher # Need a two-step process since configure_file don't support permissions file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts) if (WIN32) configure_file( ${CMAKE_SOURCE_DIR}/CMake/otbcli.bat.in ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbcli.bat @ONLY ) file(COPY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbcli.bat DESTINATION ${CLI_OUTPUT_DIR} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) # TODO : test if NO_INSTALL is set install(PROGRAMS ${CLI_OUTPUT_DIR}/otbcli.bat DESTINATION ${OTBCommandLine_INSTALL_RUNTIME_DIR} COMPONENT Runtime) else() configure_file( ${CMAKE_SOURCE_DIR}/CMake/otbcli.sh.in ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbcli @ONLY ) file(COPY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbcli DESTINATION ${CLI_OUTPUT_DIR} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) # TODO : test if NO_INSTALL is set install(PROGRAMS ${CLI_OUTPUT_DIR}/otbcli DESTINATION ${OTBCommandLine_INSTALL_RUNTIME_DIR} COMPONENT Runtime) endif() OTB-release-5.8/Modules/Wrappers/CommandLine/src/otbApplicationLauncherCommandLine.cxx000066400000000000000000000222771301006202600311050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperCommandLineLauncher.h" #include "otb_tinyxml.h" #include #ifdef OTB_USE_MPI #include "otbMPIConfig.h" #endif const std::string GetChildNodeTextOf(TiXmlElement *parentElement, std::string key); std::string PrepareExpressionFromXML(std::string filename); std::vector PrepareVectorExpressionFromXML(std::string filename); std::string CleanWord(const std::string & word); std::string PrepareExpressionFromXML(std::string filename) { std::string expression; if(filename.empty()) { std::cerr <<"Input XML Filename is empty" << std::endl; return expression; } std::string ext = filename.substr(filename.size()-4,filename.size()); if(ext != ".xml" ) std::cerr << ext << " is a wrong extension: Expected .xml " << __FILE__ << std::endl; // Open the xml file TiXmlDocument doc; //Use itksys::SystemTools::FOpen() and close it below because //TiXmlDocument::TiXmlFileOpen( ) is not exposed from tinyXML library. Even //though its available in the TiXmlDocument::SaveFile(). FILE* fp = itksys::SystemTools::Fopen(filename.c_str(), "rb"); if (!doc.LoadFile(fp , TIXML_ENCODING_UTF8)) { std::cerr << "Can't open file " << filename << std::endl; fclose(fp); exit(1); } TiXmlHandle handle(&doc); TiXmlElement *n_OTB; n_OTB = handle.FirstChild("OTB").Element(); if(!n_OTB) { std::string info = "Input XML file " + filename + " is invalid."; std::cerr << info << std::endl; fclose(fp); exit(1); } TiXmlElement *n_AppNode = n_OTB->FirstChildElement("application"); std::string moduleName; moduleName = GetChildNodeTextOf(n_AppNode, "name"); /* AddMetaData("appname", app_Name); app_Descr = this_->GetChildNodeTextOf(n_AppNode, "descr"); AddMetaData("appdescr", app_Descr); TiXmlElement* n_Doc = n_AppNode->FirstChildElement("doc"); std::string doc_Name, doc_Descr, doc_Author, doc_Limitation, doc_SeeAlso; doc_Name = this_->GetChildNodeTextOf(n_Doc, "name"); AddMetaData("docname", doc_Name); doc_Descr = this_->GetChildNodeTextOf(n_Doc, "longdescr"); AddMetaData("doclongdescr", doc_Descr); doc_Author = this_->GetChildNodeTextOf(n_Doc, "authors"); AddMetaData("docauthors", doc_Author); doc_Limitation = this_->GetChildNodeTextOf(n_Doc, "limitations"); AddMetaData("doclimitations", doc_Limitation); doc_SeeAlso = this_->GetChildNodeTextOf(n_Doc, "seealso"); AddMetaData("docseealso", doc_SeeAlso); */ expression.append(moduleName); for( TiXmlElement* n_Parameter = n_AppNode->FirstChildElement("parameter"); n_Parameter != ITK_NULLPTR; n_Parameter = n_Parameter->NextSiblingElement() ) { std::string key="-"; key.append(GetChildNodeTextOf(n_Parameter, "key")); TiXmlElement* n_Values = ITK_NULLPTR; n_Values = n_Parameter->FirstChildElement("values"); if(n_Values) { std::string values; for(TiXmlElement* n_Value = n_Values->FirstChildElement("value"); n_Value != ITK_NULLPTR; n_Value = n_Value->NextSiblingElement()) { values.append(n_Value->GetText()); values.append(" "); } values = values.substr(0,values.size()-1); expression.append(" "); expression.append(key); expression.append(" "); expression.append(values); } else { std::string value; value = GetChildNodeTextOf(n_Parameter, "value"); expression.append(" "); expression.append(key); expression.append(" "); expression.append(value); std::string type = GetChildNodeTextOf(n_Parameter, "type"); if (type == "OutputImage") { std::string t = GetChildNodeTextOf(n_Parameter, "pixtype"); expression.append(" "); expression.append(t); } } } fclose(fp); return expression; } std::vector PrepareVectorExpressionFromXML(std::string filename) { std::vector expression; if(filename.empty()) { std::cerr <<"Input XML Filename is empty" << std::endl; return expression; } std::string ext = filename.substr(filename.size()-4,filename.size()); if(ext != ".xml" ) std::cerr << ext << " is a wrong extension: Expected .xml " << __FILE__ << std::endl; // Open the xml file TiXmlDocument doc; //Use itksys::SystemTools::FOpen() and close it below because //TiXmlDocument::TiXmlFileOpen( ) is not exposed from tinyXML library. Even //though its available in the TiXmlDocument::SaveFile(). FILE* fp = itksys::SystemTools::Fopen(filename.c_str(), "rb"); if (!doc.LoadFile(fp , TIXML_ENCODING_UTF8)) { std::cerr << "Can't open file " << filename << std::endl; fclose(fp); exit(1); } TiXmlHandle handle(&doc); TiXmlElement *n_OTB; n_OTB = handle.FirstChild("OTB").Element(); if(!n_OTB) { std::string info = "Input XML file " + filename + " is invalid."; std::cerr << info << std::endl; fclose(fp); exit(1); } TiXmlElement *n_AppNode = n_OTB->FirstChildElement("application"); std::string moduleName; moduleName = GetChildNodeTextOf(n_AppNode, "name"); expression.push_back(CleanWord(moduleName)); for( TiXmlElement* n_Parameter = n_AppNode->FirstChildElement("parameter"); n_Parameter != ITK_NULLPTR; n_Parameter = n_Parameter->NextSiblingElement() ) { std::string key="-"; key.append(GetChildNodeTextOf(n_Parameter, "key")); expression.push_back(CleanWord(key)); TiXmlElement* n_Values = ITK_NULLPTR; n_Values = n_Parameter->FirstChildElement("values"); if(n_Values) { std::string values; for(TiXmlElement* n_Value = n_Values->FirstChildElement("value"); n_Value != ITK_NULLPTR; n_Value = n_Value->NextSiblingElement()) { expression.push_back(CleanWord(n_Value->GetText())); } } else { std::string value; value = GetChildNodeTextOf(n_Parameter, "value"); expression.push_back(CleanWord(value)); std::string type = GetChildNodeTextOf(n_Parameter, "type"); if (type == "OutputImage") { std::string t = GetChildNodeTextOf(n_Parameter, "pixtype"); expression.push_back(CleanWord(t)); } } } fclose(fp); return expression; } std::string CleanWord(const std::string & word) { std::string res(""); // Suppress whitespace characters at the beginning and ending of the string std::string::size_type cleanStart = word.find_first_not_of(" \t"); std::string::size_type cleanEnd = word.find_last_not_of(" \t\f\v\n\r"); // cleanStart == npos implies cleanEnd == npos if (cleanEnd != std::string::npos) { res = word.substr(cleanStart, cleanEnd - cleanStart + 1); } return res; } int main(int argc, char* argv[]) { #ifdef OTB_USE_MPI otb::MPIConfig::Instance()->Init(argc,argv); #endif if (argc < 2) { std::cerr << "Usage : " << argv[0] << " module_name [MODULEPATH] [arguments]" << std::endl; return EXIT_FAILURE; } std::vector vexp; std::string exp; if (strcmp(argv[1], "-inxml") == 0) { //exp = PrepareExpressionFromXML(argv[2]); vexp = PrepareVectorExpressionFromXML(argv[2]); } else { // Construct the string expression for (int i = 1; i < argc; i++) { /*if (i != argc - 1) { exp.append(argv[i]); exp.append(" "); } else { exp.append(argv[i]); }*/ std::string strarg(argv[i]); std::string cleanArg = CleanWord(strarg); if (cleanArg.empty()) { // Empty argument ! continue; } vexp.push_back(cleanArg); } } // std::cerr << exp << ":\n"; typedef otb::Wrapper::CommandLineLauncher LauncherType; LauncherType::Pointer launcher = LauncherType::New(); //if (launcher->Load(exp) == true) if (launcher->Load(vexp) == true) { if (launcher->ExecuteAndWriteOutput() == false) { return EXIT_FAILURE; } } else { return EXIT_FAILURE; } return EXIT_SUCCESS; } const std::string GetChildNodeTextOf(TiXmlElement *parentElement, std::string key) { std::string value=""; if(parentElement) { TiXmlElement* childElement = ITK_NULLPTR; childElement = parentElement->FirstChildElement(key.c_str()); //same as childElement->GetText() does but that call is failing if there is //no such node. //but the below code works and is a replacement for GetText() if(childElement) { const TiXmlNode* child = childElement->FirstChild(); if ( child ) { const TiXmlText* childText = child->ToText(); if ( childText ) { value = childText->Value(); } } } } return value; } OTB-release-5.8/Modules/Wrappers/CommandLine/src/otbWrapperCommandLineLauncher.cxx000066400000000000000000001006051301006202600302520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperCommandLineLauncher.h" // Single value parameter #include "otbWrapperChoiceParameter.h" #include "otbWrapperDirectoryParameter.h" #include "otbWrapperEmptyParameter.h" #include "otbWrapperInputFilenameParameter.h" #include "otbWrapperOutputFilenameParameter.h" #include "otbWrapperInputImageParameter.h" #include "otbWrapperInputVectorDataParameter.h" #include "otbWrapperOutputImageParameter.h" #include "otbWrapperOutputVectorDataParameter.h" #include "otbWrapperRadiusParameter.h" #include "otbWrapperListViewParameter.h" #include "otbWrapperRAMParameter.h" #include "otbWrapperOutputProcessXMLParameter.h" #include "otbWrapperAddProcessToWatchEvent.h" // List value parameter #include "otbWrapperInputImageListParameter.h" #include "otbWrapperInputVectorDataListParameter.h" #include "otbWrapperInputFilenameListParameter.h" #include "otbWrapperStringListParameter.h" #include "otbWrapperApplicationRegistry.h" #include "otbWrapperTypes.h" #include #include #include namespace otb { namespace Wrapper { CommandLineLauncher::CommandLineLauncher() : /*m_Expression(""),*/m_VExpression(), m_WatcherList(), m_ReportProgress(true), m_MaxKeySize(0) { m_Application = ITK_NULLPTR; m_Parser = CommandLineParser::New(); m_LogOutput = itk::StdStreamLogOutput::New(); m_LogOutput->SetStream(std::cout); // Add the callback to be added when a AddProcessToWatch event is invoked m_AddProcessCommand = AddProcessCommandType::New(); m_AddProcessCommand->SetCallbackFunction(this, &CommandLineLauncher::LinkWatchers); } CommandLineLauncher::CommandLineLauncher(const char *) /*: m_Expression(exp)*/ { m_Application = ITK_NULLPTR; m_Parser = CommandLineParser::New(); } CommandLineLauncher::~CommandLineLauncher() { this->DeleteWatcherList(); m_Application = ITK_NULLPTR; ApplicationRegistry::CleanRegistry(); } void CommandLineLauncher::DeleteWatcherList() { for (unsigned int i = 0; i < m_WatcherList.size(); i++) { delete m_WatcherList[i]; m_WatcherList[i] = ITK_NULLPTR; } m_WatcherList.clear(); } bool CommandLineLauncher::Load(const std::vector &vexp) { m_VExpression = vexp; return this->Load(); } bool CommandLineLauncher::Load() { if (m_VExpression.empty()) { itkExceptionMacro("No expression specified..."); } if (this->CheckParametersPrefix() == false) { std::cerr << "ERROR: Parameter keys have to set using \"-\", not \"--\"" << std::endl; return false; } if (this->CheckUnicity() == false) { std::cerr << "ERROR: At least one key is not unique in the expression..." << std::endl; return false; } if (this->LoadPath() == false) { if (m_Parser->GetPathsAsString(m_VExpression).size() != 0) { std::cerr << "ERROR: At least one specified path within \"" << m_Parser->GetPathsAsString(m_VExpression) << "\" is invalid or doesn't exist..." << std::endl; return false; } } this->LoadApplication(); return true; } bool CommandLineLauncher::Execute() { if (this->BeforeExecute() == false) { return false; } if( m_Application->Execute() == 0 ) { this->DisplayOutputParameters(); return true; } else return false; } bool CommandLineLauncher::ExecuteAndWriteOutput() { try { if (this->BeforeExecute() == false) { return false; } if( m_Application->ExecuteAndWriteOutput() == 0 ) { this->DisplayOutputParameters(); } else return false; } catch(std::exception& err) { std::ostringstream message; message << "The following error occurred during application execution : " << err.what() << std::endl; m_Application->GetLogger()->Write( itk::LoggerBase::FATAL, message.str() ); return false; } catch(...) { m_Application->GetLogger()->Write( itk::LoggerBase::FATAL, "An unknown exception has been raised during application execution" ); return false; } return true; } bool CommandLineLauncher::BeforeExecute() { if (m_Application.IsNull()) { std::cerr << "ERROR: No loaded application..." << std::endl; return false; } // Check if there's keys in the expression if the application takes // at least 1 mandatory parameter const std::vector appKeyList = m_Application->GetParametersKeys(true); std::vector keyList = m_Parser->GetKeyList( m_VExpression ); if( appKeyList.size()!=0 && keyList.size()==0 ) { std::cerr << "ERROR: Waiting for at least one parameter..." << std::endl; this->DisplayHelp(); return false; } // if help is asked... if (m_Parser->IsAttributExists("-help", m_VExpression) == true) { this->DisplayHelp(); return false; } //display OTB version if (m_Parser->IsAttributExists("-version", m_VExpression) == true) { std::cerr << "This is the "<GetName() << " application, version " << OTB_VERSION_STRING <IsAttributExists("-testenv", m_VExpression) == true) { this->LoadTestEnv(); } // Check the key validity (ie. exist in the application parameters) std::string unknownKey; if (this->CheckKeyValidity(unknownKey) == false) { std::cerr << "ERROR: option -"<DisplayHelp(); return false; } try { if (this->LoadParameters() != OKPARAM) { std::cerr << "ERROR: Troubles loading parameter, please check your line argument..." << std::endl; // Force to reload the application, the LoadParameters can change wrong values this->LoadApplication(); m_Application->Init(); this->DisplayHelp(); return false; } } catch (itk::ExceptionObject& err) { std::cerr << "ERROR: Troubles in parameter setting, please check your line argument..." << std::endl; std::cerr << err.GetDescription() << std::endl; // Force to reload the application, the LoadParameters can change wrong values this->LoadApplication(); m_Application->Init(); this->DisplayHelp(); return false; } // Check for the progress report if (m_Parser->IsAttributExists("-progress", m_VExpression) == true) { std::vector val; val = m_Parser->GetAttribut("-progress", m_VExpression); if (val.size() != 1) { std::cerr << "ERROR: Invalid progress argument, must be unique value..." << std::endl; return false; } if (val[0] == "1" || val[0] == "true") { m_ReportProgress = true; } else if (val[0] == "0" || val[0] == "false") { m_ReportProgress = false; } else { std::cerr << "ERROR: Invalid progress argument, must be 0, 1, false or true..." << std::endl; // Force to reload the application, the LoadParameters can change wrong values this->LoadApplication(); this->DisplayHelp(); return false; } } return true; } bool CommandLineLauncher::LoadPath() { std::vector pathList; // If users has set path... //if (m_Parser->GetPaths(pathList, m_Expression) == CommandLineParser::OK) if (m_Parser->GetPaths(pathList, m_VExpression) == CommandLineParser::OK) { for (unsigned i = 0; i < pathList.size(); i++) { ApplicationRegistry::AddApplicationPath(pathList[i]); } } else { return false; } return true; } void CommandLineLauncher::LoadApplication() { // Look for the module name std::string moduleName; //if (m_Parser->GetModuleName(moduleName, m_Expression) != CommandLineParser::OK) if (m_Parser->GetModuleName(moduleName, m_VExpression) != CommandLineParser::OK) { std::cerr << "ERROR: LoadApplication, no module found..." << std::endl; return; } // Instantiate the application using the factory m_Application = ApplicationRegistry::CreateApplication(moduleName); if (m_Application.IsNull()) { std::cerr << "ERROR: Could not find application \"" << moduleName << "\"" << std::endl; std::string modulePath = ApplicationRegistry::GetApplicationPath(); std::cerr << "ERROR: Module search path: " << (modulePath.empty() ? "none (check OTB_APPLICATION_PATH)" : modulePath) << std::endl; std::vector list = ApplicationRegistry::GetAvailableApplications(); if (list.size() == 0) { std::cerr << "ERROR: Available modules : none." << std::endl; } else { std::cerr << "ERROR: Available modules :" << std::endl; for (std::vector::const_iterator it = list.begin(); it != list.end(); ++it) { std::cerr << "\t" << *it << std::endl; } } } else { // Attach log output to the Application logger m_Application->GetLogger()->SetTimeStampFormat(itk::LoggerBase::HUMANREADABLE); m_Application->GetLogger()->AddLogOutput(m_LogOutput); // Add an observer to the AddedProcess event m_Application->AddObserver(AddProcessToWatchEvent(), m_AddProcessCommand.GetPointer()); } } CommandLineLauncher::ParamResultType CommandLineLauncher::LoadParameters() { if (m_Application.IsNull()) { itkExceptionMacro("No application loaded"); } /* Check for inxml parameter. If exists Update all Parameters from xml and * check for user defined parameters for overriding those from XML */ const char *inXMLKey = "inxml"; const char *attrib = "-inxml"; const bool paramInXMLExists(m_Parser->IsAttributExists(attrib, m_VExpression)); if(paramInXMLExists) { std::vector inXMLValues; inXMLValues = m_Parser->GetAttribut(attrib, m_VExpression); m_Application->SetParameterString(inXMLKey, inXMLValues[0]); m_Application->UpdateParameters(); } const std::vector appKeyList = m_Application->GetParametersKeys(true); // Loop over each parameter key declared in the application // FIRST PASS : set parameter values for (unsigned int i = 0; i < appKeyList.size(); i++) { const std::string paramKey(appKeyList[i]); std::vector values; Parameter::Pointer param = m_Application->GetParameterByKey(paramKey); ParameterType type = m_Application->GetParameterType(paramKey); const bool paramExists(m_Parser->IsAttributExists(std::string("-").append(paramKey), m_VExpression)); // if param is a Group, don't do anything, ParamGroup don't have values if (type != ParameterType_Group) { // Get the attribute relative to this key as vector values = m_Parser->GetAttribut(std::string("-").append(paramKey), m_VExpression); // If the param does not exists in the cli, don't try to set a // value on it, an exception will be thrown later in this function if (paramExists) { // Check if there is a value associated to the attribute if ( values.empty() ) { std::cerr << "ERROR: No value associated to the parameter : \"" << paramKey << "\", invalid number of values " << values.size() << std::endl; return INVALIDNUMBEROFVALUE; } // Ensure that the parameter is enabled m_Application->EnableParameter(paramKey); if (type == ParameterType_InputVectorDataList) { dynamic_cast (param.GetPointer())->SetListFromFileName(values); } else if (type == ParameterType_InputImageList) { dynamic_cast (param.GetPointer())->SetListFromFileName(values); } else if (type == ParameterType_InputFilenameList) { dynamic_cast (param.GetPointer())->SetListFromFileName(values); } else if (type == ParameterType_StringList) { dynamic_cast (param.GetPointer())->SetValue(values); } else if (type == ParameterType_String) { dynamic_cast (param.GetPointer())->SetValue( m_Parser->GetAttributAsString(std::string("-").append(paramKey), m_VExpression) ); } else if (type == ParameterType_OutputImage) { m_Application->SetParameterString(paramKey, values[0]); // Check if pixel type is given if (values.size() == 2) { ImagePixelType outPixType = ImagePixelType_float; if (values[1] == "uint8") outPixType = ImagePixelType_uint8; else if (values[1] == "int16") outPixType = ImagePixelType_int16; else if (values[1] == "uint16") outPixType = ImagePixelType_uint16; else if (values[1] == "int32") outPixType = ImagePixelType_int32; else if (values[1] == "uint32") outPixType = ImagePixelType_uint32; else if (values[1] == "float") outPixType = ImagePixelType_float; else if (values[1] == "double") outPixType = ImagePixelType_double; else { return WRONGPARAMETERVALUE; } dynamic_cast (param.GetPointer())->SetPixelType(outPixType); } else if (values.size() != 1 && values.size() != 2) { std::cerr << "ERROR: Invalid number of value for: \"" << paramKey << "\", invalid number of values " << values.size() << std::endl; return INVALIDNUMBEROFVALUE; } } else if (type == ParameterType_ComplexOutputImage) { m_Application->SetParameterString(paramKey, values[0]); // Check if pixel type is given if (values.size() == 2) { ComplexImagePixelType outPixType = ComplexImagePixelType_float; if (values[1] == "cfloat") outPixType = ComplexImagePixelType_float; else if (values[1] == "cdouble") outPixType = ComplexImagePixelType_double; else { return WRONGPARAMETERVALUE; } dynamic_cast (param.GetPointer())->SetComplexPixelType(outPixType); } else if (values.size() != 1 && values.size() != 2) { std::cerr << "ERROR: Invalid number of value for: \"" << paramKey << "\", invalid number of values " << values.size() << std::endl; return INVALIDNUMBEROFVALUE; } } else if (type == ParameterType_ListView) { dynamic_cast (param.GetPointer())->SetSelectedNames(values); } else if(values.size() != 1) { // Handle space in filename. Only for input // files or directories if (type == ParameterType_Directory || type == ParameterType_InputFilename || type == ParameterType_ComplexInputImage || type == ParameterType_InputImage || type == ParameterType_InputVectorData || type == ParameterType_OutputVectorData ) { for(unsigned int j=1; jGetAutomaticValue()) { std::cerr << "ERROR: Invalid number of value for: \"" << paramKey << "\", must have 1 value, not " << values.size() << std::endl; return INVALIDNUMBEROFVALUE; } } // Single value parameter if (type == ParameterType_Choice || type == ParameterType_Float || type == ParameterType_Int || type == ParameterType_Radius || type == ParameterType_Directory || type == ParameterType_InputFilename || type == ParameterType_OutputFilename || type == ParameterType_ComplexInputImage || type == ParameterType_InputImage || type == ParameterType_ComplexOutputImage || type == ParameterType_InputVectorData || type == ParameterType_OutputVectorData || type == ParameterType_RAM || type == ParameterType_OutputProcessXML) // || type == ParameterType_InputProcessXML) { m_Application->SetParameterString(paramKey, values[0]); } else if (type == ParameterType_Empty) { if (values[0] == "1" || values[0] == "true") { dynamic_cast (param.GetPointer())->SetActive(true); } else if (values[0] == "0" || values[0] == "false") { dynamic_cast (param.GetPointer())->SetActive(false); } else { std::cerr << "ERROR: Wrong parameter value: " << paramKey << std::endl; return WRONGPARAMETERVALUE; } } // Update the flag UserValue param->SetUserValue(true); // Call the DoUpdateParameter to update dependent params m_Application->UpdateParameters(); } } } // SECOND PASS : check mandatory parameters for (unsigned int i = 0; i < appKeyList.size(); i++) { const std::string paramKey(appKeyList[i]); Parameter::Pointer param = m_Application->GetParameterByKey(paramKey); ParameterType type = m_Application->GetParameterType(paramKey); const bool paramExists(m_Parser->IsAttributExists(std::string("-").append(paramKey), m_VExpression)); std::vector values; // When a parameter is mandatory : // it must be set if : // - The param is root // - The param is not root and belonging to a Mandatory Group // which is activated bool mustBeSet = false; const bool hasValue = m_Application->HasValue(paramKey); //skip if mandatory parameters are missing because we have it already in XML if(!paramInXMLExists) { if( param->GetMandatory() == true && param->GetRole() != Role_Output && type != ParameterType_Group) { // check if the parameter is linked to a root parameter with a chain of active parameters if( param->IsRoot() || param->GetRoot()->IsRoot()) { // the parameter is a root or inside a group at root level mustBeSet = true; } else { Parameter* currentParam = param->GetRoot(); while (!currentParam->IsRoot()) { if (!currentParam->GetActive()) { // the missing parameter is not on an active branch : we can ignore it break; } currentParam = currentParam->GetRoot(); if (currentParam->IsRoot()) { // the missing parameter is on an active branch : we need it mustBeSet = true; } } } } } if( mustBeSet ) { if (!paramExists) { // If key doesn't exist and parameter hasn't default value set... if (!hasValue) { std::cerr << "ERROR: Missing mandatory parameter: " << paramKey << " " << m_Application->HasValue(paramKey) << std::endl; return MISSINGMANDATORYPARAMETER; } } else { values = m_Parser->GetAttribut(std::string("-").append(paramKey), m_VExpression); if (values.size() == 0 && !m_Application->HasValue(paramKey)) { std::cerr << "ERROR: Missing mandatory parameter: " << paramKey << std::endl; return MISSINGPARAMETERVALUE; } } } // Check if non mandatory parameter have values else { if( paramExists ) { values = m_Parser->GetAttribut(std::string("-").append(paramKey), m_VExpression); if (values.size() == 0) { std::cerr << "ERROR: Missing non-mandatory parameter: " << paramKey << std::endl; return MISSINGPARAMETERVALUE; } } } // Check output paths validity if (hasValue) { if (type == ParameterType_OutputFilename) { std::string filename = m_Application->GetParameterString(paramKey); itksys::String path = itksys::SystemTools::GetFilenamePath(filename); if (path!="" && !itksys::SystemTools::FileIsDirectory(path.c_str())) { std::cerr <<"ERROR: Directory doesn't exist : "<< path.c_str() << std::endl; return WRONGPARAMETERVALUE; } } } } return OKPARAM; } void CommandLineLauncher::LinkWatchers(itk::Object * itkNotUsed(caller), const itk::EventObject & event) { // Report the progress only if asked if (m_ReportProgress) { if (typeid(otb::Wrapper::AddProcessToWatchEvent) == typeid( event )) { const AddProcessToWatchEvent* eventToWatch = dynamic_cast (&event); StandardOneLineFilterWatcher * watch = new StandardOneLineFilterWatcher(eventToWatch->GetProcess(), eventToWatch->GetProcessDescription()); m_WatcherList.push_back(watch); } } } void CommandLineLauncher::DisplayHelp() { std::cerr << "This is the "<GetName() << " application, version " << OTB_VERSION_STRING <GetDescription() << std::endl; std::cerr<GetName()); link.append(".html"); std::cerr << "Complete documentation: " << link << std::endl; std::cerr< appKeyList = m_Application->GetParametersKeys(true); const unsigned int nbOfParam = appKeyList.size(); m_MaxKeySize = std::string("progress").size(); for (unsigned int i = 0; i < nbOfParam; i++) { if (m_Application->GetParameterRole(appKeyList[i]) != Role_Output) { if( m_MaxKeySize < appKeyList[i].size() ) m_MaxKeySize = appKeyList[i].size(); } } //// progress report parameter std::string bigKey = "progress"; for(unsigned int i=0; i Report progress " << std::endl; for (unsigned int i = 0; i < nbOfParam; i++) { Parameter::Pointer param = m_Application->GetParameterByKey(appKeyList[i]); if (param->GetRole() != Role_Output) { std::cerr << this->DisplayParameterHelp(param, appKeyList[i]); } } std::cerr<GetCLExample()); std::cerr << "Examples: " << std::endl; std::cerr << m_Application->GetCLExample() << std::endl; } void CommandLineLauncher::LoadTestEnv() { //Set seed for rand and itk mersenne twister //srand(1); // itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->SetSeed(121212); } std::string CommandLineLauncher::DisplayParameterHelp(const Parameter::Pointer & param, const std::string paramKey) { // Display the type the type ParameterType type = m_Application->GetParameterType(paramKey); // Discard Group parameters (they don't need a value) if (type == ParameterType_Group) { return ""; } std::ostringstream oss; // When a parameter is mandatory : // it must be set if : // - The param is root // - The param is not root and belonging to a Mandatory Group // which is activated bool isMissing = false; if (!m_Parser->IsAttributExists(std::string("-").append(paramKey), m_VExpression)) { if (!m_Application->HasValue(paramKey)) { if( param->GetMandatory() && param->GetRole() != Role_Output ) { if( param->IsRoot() || param->GetRoot()->IsRoot()) { // the parameter is a root or inside a group at root level isMissing = true; } else { Parameter* currentParam = param->GetRoot(); while (!currentParam->IsRoot()) { if (!currentParam->GetActive()) { // the missing parameter is not on an active branch : we can ignore it break; } currentParam = currentParam->GetRoot(); if (currentParam->IsRoot()) { // the missing parameter is on an active branch : we need it isMissing = true; } } } } } } if( isMissing ) { oss << "MISSING "; } else { oss << " "; } std::string bigKey = paramKey; for(unsigned int i=0; i "; } else if (type == ParameterType_Empty ) { oss << " "; } else if (type == ParameterType_Float) { oss << " "; } else if (type == ParameterType_InputFilename || type == ParameterType_OutputFilename ||type == ParameterType_Directory || type == ParameterType_InputImage || type == ParameterType_OutputProcessXML || type == ParameterType_InputProcessXML || type == ParameterType_ComplexInputImage || type == ParameterType_InputVectorData || type == ParameterType_OutputVectorData || type == ParameterType_String || type == ParameterType_Choice ) { oss << " "; } else if (type == ParameterType_OutputImage || type == ParameterType_ComplexOutputImage) { oss << " [pixel]"; } else if (type == ParameterType_Choice || type == ParameterType_ListView || type == ParameterType_InputImageList || type == ParameterType_InputVectorDataList || type == ParameterType_InputFilenameList || type == ParameterType_StringList ) { oss << " "; } else itkExceptionMacro("Not handled parameter type."); oss<< " " << param->GetName() << " "; if (type == ParameterType_OutputImage) { OutputImageParameter* paramDown = dynamic_cast(param.GetPointer()); std::string defPixType("float"); if (paramDown) { defPixType = OutputImageParameter::ConvertPixelTypeToString(paramDown->GetDefaultPixelType()); } oss << " [pixel=uint8/uint16/int16/uint32/int32/float/double]"; oss << " (default value is " << defPixType <<")"; } if (type == ParameterType_ComplexOutputImage) { ComplexOutputImageParameter* paramDown = dynamic_cast(param.GetPointer()); std::string defPixType("cfloat"); if (paramDown) { defPixType = ComplexOutputImageParameter::ConvertPixelTypeToString(paramDown->GetDefaultComplexPixelType()); } oss << " [pixel=cfloat/cdouble]"; oss << " (default value is "<< defPixType <<")"; } if (type == ParameterType_Choice) { std::vector keys = dynamic_cast(param.GetPointer())->GetChoiceKeys(); std::vector names = dynamic_cast(param.GetPointer())->GetChoiceNames(); oss << "["; for(unsigned int i=0; iIsMandatory(paramKey)) { oss<<" (mandatory"; } else { oss<<" (optional"; if(m_Application->IsParameterEnabled(paramKey)) { oss<<", on by default"; } else { oss<<", off by default"; } } if(m_Application->HasValue(paramKey)) { oss<<", default value is "<GetParameterAsString(paramKey); } oss<<")"; oss << std::endl; return oss.str(); } bool CommandLineLauncher::CheckUnicity() { bool res = true; // Extract expression keys //std::vector keyList = m_Parser->GetKeyList(m_Expression); std::vector keyList = m_Parser->GetKeyList(m_VExpression); // Check Unicity for (unsigned int i = 0; i < keyList.size(); i++) { std::vector listTmp = keyList; const std::string keyRef = keyList[i]; listTmp.erase(listTmp.begin() + i); for (unsigned int j = 0; j < listTmp.size(); j++) { if (keyRef == listTmp[j]) { res = false; break; } } if (!res) break; } return res; } bool CommandLineLauncher::CheckParametersPrefix() { // Check if the chain " --" appears in the args, could be a common mistake for (std::vector::iterator it = m_VExpression.begin(); it != m_VExpression.end(); ++it) { if (it->compare(0, 2, "--") == 0 ) { return false; } } return true; } bool CommandLineLauncher::CheckKeyValidity(std::string& refKey) { bool res = true; // Extract expression keys std::vector expKeyList = m_Parser->GetKeyList(m_VExpression); // Extract application keys std::vector appKeyList = m_Application->GetParametersKeys(true); appKeyList.push_back("help"); appKeyList.push_back("progress"); appKeyList.push_back("testenv"); appKeyList.push_back("version"); // Check if each key in the expression exists in the application for (unsigned int i = 0; i < expKeyList.size(); i++) { refKey = expKeyList[i]; bool keyExist = false; for (unsigned int j = 0; j < appKeyList.size(); j++) { if (refKey == appKeyList[j]) { keyExist = true; break; } } if (keyExist == false) { res = false; break; } } return res; } void CommandLineLauncher::DisplayOutputParameters() { std::vector< std::pair > paramList; paramList = m_Application->GetOutputParametersSumUp(); if( paramList.size() == 0 ) return; std::ostringstream oss; for( unsigned int i=0; iIsAttributExists("-testenv", m_VExpression) ) { std::vector val = m_Parser->GetAttribut("-testenv", m_VExpression); if( val.size() == 1 ) { std::ofstream ofs(val[0].c_str()); if (!ofs.is_open()) { fprintf(stderr, "Error, can't open file"); itkExceptionMacro( << "Error, can't open file "< #include #include #include namespace otb { namespace Wrapper { CommandLineParser::CommandLineParser() { } CommandLineParser::~CommandLineParser() { } std::string CommandLineParser::GetPathsAsString(const std::vector & vexp ) { std::string res; std::vector pathList; if (this->GetPaths(pathList,vexp) == OK) { std::vector::iterator it; for (it=pathList.begin(); it!=pathList.end(); ++it) { if (!res.empty()) { res.append(" "); } res.append(*it); } } return res; } std::string CommandLineParser::GetPathsAsString( const std::string & exp ) { std::string res; // The first element must be the module path, non " -" allowed. // The module path list element are the strings between the first // element and the next key (ie. " -" string). std::string tempModPath = exp; if( exp.find(" -") != std::string::npos) { tempModPath = exp.substr( 0, exp.find(" -")); } // Get everything after the module path if( tempModPath.find(" ") != std::string::npos) { res = tempModPath.substr( tempModPath.find(" ")+1, tempModPath.size()); } // Suppress possible multi space at the beginning of the string while (res.size()>0 && res[0]==' ') { res.erase(0, 1); } return res; } CommandLineParser::ParseResultType CommandLineParser::GetPaths( std::vector & paths, const std::vector & exp ) { if (exp.empty()) { return NOMODULEPATH; } // The first element must be the module name, non " -" allowed. // The module path list elements are the strings between the first // element and the first key (ie. string which begins with "-"). std::vector::const_iterator it = exp.begin(); ++it; // first element is module name std::string tmpPath; while (it != exp.end()) { tmpPath = *it; // If this is the first key : exit loop if (tmpPath[0]=='-') { break; } // Add path to result std::string fullPath = itksys::SystemTools::CollapseFullPath(tmpPath.c_str()); if( !itksys::SystemTools::FileIsDirectory(fullPath.c_str()) ) { std::cerr<<"Invalid module path: "< & paths, const std::string & exp ) { std::string pathsList = this->GetPathsAsString( exp ); if( pathsList.size() == 0 ) { return NOMODULEPATH; } std::string tempModPath = pathsList; // remove other key in the string if there's any if( pathsList.find(" -") != std::string::npos) { tempModPath = pathsList.substr( 0, pathsList.find(" -")); } if( tempModPath.size() > 0 ) { std::vector pathAttribut = itksys::SystemTools::SplitString(tempModPath.substr(0, tempModPath.size()).c_str(), ' ', false); // Remove " " string element for(unsigned int i=0; i1 && pathAttribut[i][0]==' ') { pathAttribut[i].erase(0, 1); } std::string fullPath = itksys::SystemTools::CollapseFullPath(pathAttribut[i].c_str()); if( !itksys::SystemTools::FileIsDirectory(fullPath.c_str()) ) { std::cerr<<"Invalid module path: "< & exp ) { if (exp.empty()) { return NOMODULENAME; } itksys::RegularExpression reg; reg.compile("([^0-9a-zA-Z])"); // The first element must be the module path, non " -" allowed. if( exp[0][0] == '-') { return NOMODULENAME; } // It must contain only alphanumerical character if(reg.find(exp[0])) { return INVALIDMODULENAME; } else { modName = exp[0]; } return OK; } CommandLineParser::ParseResultType CommandLineParser::GetModuleName( std::string & modName, const std::string & exp ) { std::vector spaceSplitExp = itksys::SystemTools::SplitString(exp.c_str(), ' ', false); // if the chain is " module", SplitString will return: [ ], [module] for(unsigned int i=0; i CommandLineParser::GetAttribut( const std::string & key, const std::vector & exp ) { std::vector res; if (!this->IsAttributExists(key,exp)) return res; bool foundKey=false; std::vector::const_iterator it = exp.begin(); while(it!=exp.end() ) { if (foundKey) { if (it->find("-") == 0) { std::string tmpKey = it->substr(1,std::string::npos); if (this->IsAValidKey(tmpKey)) { break; } else { res.push_back(*it); } } else res.push_back(*it); } else { if (it->compare(key) == 0) { foundKey=true; } } ++it; } return res; } std::vector CommandLineParser::GetAttribut( const std::string & key, const std::string & exp ) { std::vector res; std::string keySpaced = key; keySpaced.append(" "); std::size_t found = std::string(exp).find(keySpaced); if( found == std::string::npos ) { return res; } std::string expFromKey = std::string(exp).substr(found+key.size()+1, std::string(exp).size()); if( expFromKey.size() == 0 ) { return res; } std::string tempModKey = expFromKey; // remove other key in the string if there's any bool stop = false; std::size_t curPos = expFromKey.find(" -"); std::size_t curPosOld = 0; while ( !stop && curPos != std::string::npos ) { std::string tmp = expFromKey.substr(curPosOld, curPos); if( tmp.find(" ") != std::string::npos) { tmp = tmp.substr(0, tmp.find(" ")); } if( this->IsAValidKey(tmp) ) { tempModKey = expFromKey.substr(0, curPos); stop = true; } else { if( curPosOld>1 ) { if( expFromKey[curPos] != '-' ) { tempModKey = expFromKey.substr(0, curPos); stop = true; } } else { tempModKey = expFromKey.substr(0, curPos); stop = true; } } curPosOld = curPos; curPos = expFromKey.find(" -", curPos); if(curPos!=std::string::npos) curPos += 2; } // Only if the key has values associated if( tempModKey.size() > 0 ) { std::vector spaceSplit = itksys::SystemTools::SplitString(tempModKey.substr(0, tempModKey.size()).c_str(), ' ', false); // Remove " " string element for(unsigned int i=0; i for(unsigned int i=0; i0 && spaceSplit[i][0] == ' ' ) { spaceSplit[i] = spaceSplit[i].substr(1, spaceSplit[i].size()); } res.push_back(spaceSplit[i]); } } return res; } std::string CommandLineParser::GetAttributAsString( const std::string & key, const std::vector & exp ) { std::string res(""); std::vector values = this->GetAttribut( key, exp ); if( values.size() == 0 ) { return ""; } else if( values.size() == 1 && values[0] == " " ) { return ""; } for( unsigned int i=0; i values = this->GetAttribut( key, exp ); if( values.size() == 0 ) { return ""; } else if( values.size() == 1 && values[0] == " " ) { return ""; } for( unsigned int i=0; i & exp ) { for (std::vector::const_iterator it = exp.begin(); it != exp.end(); ++it) { if (it->compare(key) == 0) return true; } return false; } std::vector CommandLineParser::GetKeyList( const std::vector & exp ) { std::vector keyList; for (std::vector::const_iterator it = exp.begin(); it != exp.end(); ++it) { if (it->find("-") == 0) { // Remove first character ('-') std::string key = it->substr(1,std::string::npos); if (this->IsAValidKey(key)) { keyList.push_back(key); } } } return keyList; } std::vector CommandLineParser::GetKeyList( const std::string & exp ) { std::vector keyList; std::string cutExp(exp); std::size_t found = exp.find(" -"); while( found != std::string::npos ) { // Suppress everything before the key cutExp = cutExp.substr(found+2, exp.size()); // Search the end of the key (a space) std::size_t foundSpace = cutExp.find(" "); std::string tmpKey = cutExp; if( foundSpace != std::string::npos ) { tmpKey = cutExp.substr(0, foundSpace); } if( this->IsAValidKey(tmpKey) ) { keyList.push_back( tmpKey ); } // Search the next key (ie. " -") found = cutExp.find(" -"); } return keyList; } bool CommandLineParser::IsAValidKey( const std::string & foundKey ) { bool res = false; std::string tmp = foundKey; // make sure the tested key ends with a dot. // the starting dash should be already removed tmp.append("."); // To be a key, the string must be a series of groups separated by dots so that : // - each group has at least one character // - each group contains only alphanumeric characters (and lowercase) // - there is at least one group // The following regular expression says just that itksys::RegularExpression reg; reg.compile("^([a-z0-9]+\\.)+$"); if( reg.find(tmp) ) { res = true; } // a second test is performed to detect negative numbers (even in // scientific notation). Any key that matches the search pattern for a // number is considered not valid. itksys::RegularExpression regNum; regNum.compile("^([0-9]+(\\.[0-9]*)?([eE][+-]?[0-9]+)?)$"); if( regNum.find(foundKey) ) { res = false; } return res; } } } OTB-release-5.8/Modules/Wrappers/CommandLine/test/000077500000000000000000000000001301006202600217765ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/CommandLine/test/CMakeLists.txt000066400000000000000000000145361301006202600245470ustar00rootroot00000000000000otb_module_test() set(OTBCommandLineTests otbCommandLineTestDriver.cxx otbWrapperCommandLineLauncherTests.cxx otbWrapperCommandLineParserTests.cxx ) add_executable(otbCommandLineTestDriver ${OTBCommandLineTests}) target_link_libraries(otbCommandLineTestDriver ${OTBCommandLine-Test_LIBRARIES}) otb_module_target_label(otbCommandLineTestDriver) # Tests Declaration otb_add_test(NAME clTuWrapperCommandLineLauncherNew COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherNew ) otb_add_test(NAME clTvWrapperCommandLineLauncherTest_WrongParam COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherTest "Rescale" $ -inn image) set_property(TEST clTvWrapperCommandLineLauncherTest_WrongParam PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineLauncherTest_Help2 COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherTest "Rescale" $ -in ${INPUTDATA}/poupees.tif -out ${TEMP}/clTvWrapperCommandLineLauncherTest_Help2.tif -outmin 15 -outmax 200 -help) set_property(TEST clTvWrapperCommandLineLauncherTest_Help2 PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineLauncherTest COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherTest "Rescale" $ -in ${INPUTDATA}/poupees.tif -out ${TEMP}/clTvWrapperCommandLineLauncherTest.tif -outmin 15 -outmax 200 ) otb_add_test(NAME clTvWrapperCommandLineLauncherTest_MissingDash COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherTest "Rescale" $ -in image1) set_property(TEST clTvWrapperCommandLineLauncherTest_MissingDash PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineLauncherTest_MissingManParam COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherTest "Rescale" $ ) set_property(TEST clTvWrapperCommandLineLauncherTest_MissingManParam PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineLauncherTest_Help COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherTest "Rescale" $ "-help") set_property(TEST clTvWrapperCommandLineLauncherTest_Help PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineLauncherTest_DoubleParam COMMAND otbCommandLineTestDriver otbWrapperCommandLineLauncherTest "Rescale" $ -in image1 -in image2 ) set_property(TEST clTvWrapperCommandLineLauncherTest_DoubleParam PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_IsAttExistsEnd COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest4 "-m" "TrainImagesClassifier" "test" "-il" "QB_1_ortho.tif" "-vd" "vd" ".shape" "-m" "name") otb_add_test(NAME clTvWrapperCommandLineParserTest_WithKeyGoodModule COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "Rescale" $) otb_add_test(NAME clTvWrapperCommandLineParserTest_IsAttExists COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest4 "-m" "TrainImagesClassifier" "test" "-il" "QB_1_ortho.tif" "-vd" "vd" ".shape" "-m" "name") otb_add_test(NAME clTvWrapperCommandLineParserTest_IsAttExistsEndNoParam COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest4 "-m" "TrainImagesClassifier" "test" "-il" "QB_1_ortho.tif" "-vd" "vd" ".shape" "test" "-m") otb_add_test(NAME clTuWrapperCommandLineParserNew COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserNew ) otb_add_test(NAME clTvWrapperCommandLineParserTest_MultiplePathOneWrong COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "Rescale" $ "FakePath") set_property(TEST clTvWrapperCommandLineParserTest_MultiplePathOneWrong PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_WithKeyNoModule COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 $ ) set_property(TEST clTvWrapperCommandLineParserTest_WithKeyNoModule PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_GetAttWithoutValue COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest1 "-key" "-key" ) set_property(TEST clTvWrapperCommandLineParserTest_GetAttWithoutValue PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_WithKeyNonAlphaNumModuleName COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "-Re+scale" $ ) set_property(TEST clTvWrapperCommandLineParserTest_WithKeyNonAlphaNumModuleName PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_IsAttExists_Wrong COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest3 "-m" "TrainImagesClassifier" "test" "-il" "QB_1_ortho.tif" "-vd" "vd" ".shape" ) otb_add_test(NAME clTvWrapperCommandLineParserTest_NonAlphaNumModuleName COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "-Re+scale" $ ) set_property(TEST clTvWrapperCommandLineParserTest_NonAlphaNumModuleName PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_GetAtt COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest1 "-key" "this" "is" "a" "line" "test" "to" "extract" "-key" "name1" "name2" ) otb_add_test(NAME clTvWrapperCommandLineParserTest_MultiplePath COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "Rescale" $ $) otb_add_test(NAME clTvWrapperCommandLineParserTest_NoPath COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "Rescale" ) set_property(TEST clTvWrapperCommandLineParserTest_NoPath PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_WrongPath COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "Rescale" "FakePath") set_property(TEST clTvWrapperCommandLineParserTest_WrongPath PROPERTY WILL_FAIL true) otb_add_test(NAME clTvWrapperCommandLineParserTest_GoodModule COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "Rescale" $ ) otb_add_test(NAME clTvWrapperCommandLineParserTest_NoModule COMMAND otbCommandLineTestDriver otbWrapperCommandLineParserTest2 "") set_property(TEST clTvWrapperCommandLineParserTest_NoModule PROPERTY WILL_FAIL true) OTB-release-5.8/Modules/Wrappers/CommandLine/test/otbCommandLineTestDriver.cxx000066400000000000000000000006261301006202600274350ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbWrapperCommandLineLauncherNew); REGISTER_TEST(otbWrapperCommandLineLauncherTest); REGISTER_TEST(otbWrapperCommandLineParserNew); REGISTER_TEST(otbWrapperCommandLineParserTest1); REGISTER_TEST(otbWrapperCommandLineParserTest2); REGISTER_TEST(otbWrapperCommandLineParserTest3); REGISTER_TEST(otbWrapperCommandLineParserTest4); } OTB-release-5.8/Modules/Wrappers/CommandLine/test/otbWrapperCommandLineLauncherTests.cxx000066400000000000000000000026771301006202600314770ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperCommandLineLauncher.h" int otbWrapperCommandLineLauncherNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { typedef otb::Wrapper::CommandLineLauncher LauncherType; LauncherType::Pointer launcher = LauncherType::New(); return EXIT_SUCCESS; } int otbWrapperCommandLineLauncherTest(int argc, char* argv[]) { typedef otb::Wrapper::CommandLineLauncher LauncherType; LauncherType::Pointer launcher = LauncherType::New(); std::vector cmdVector; if (argc > 2) { for (int i = 1; i < argc; i++) { cmdVector.push_back(std::string(argv[i])); } } if (launcher->Load(cmdVector) == true) { if (launcher->ExecuteAndWriteOutput() == false) { return EXIT_FAILURE; } } else { return EXIT_FAILURE; } return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/CommandLine/test/otbWrapperCommandLineParserTests.cxx000066400000000000000000000077451301006202600311730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperCommandLineParser.h" typedef otb::Wrapper::CommandLineParser ParserType; int otbWrapperCommandLineParserNew(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { ParserType::Pointer parser = ParserType::New(); return EXIT_SUCCESS; } int CheckReturn(ParserType::ParseResultType res) { if( res == ParserType::OK ) { return EXIT_SUCCESS; } if( res == ParserType::NOMODULENAME ) { std::cout<<"No module name detected."< cmdVector; for (int i=2; i res = parser->GetAttribut( argv[1], cmdVector ); if( res.size() == 0 ) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbWrapperCommandLineParserTest2(int argc, char* argv[]) { ParserType::Pointer parser = ParserType::New(); std::cout << "Search for paths..." << std::endl; std::vector cmdVector; if (argc > 2) { for (int i=1; i paths; ParserType::ParseResultType res = parser->GetPaths(paths, cmdVector); if (CheckReturn(res) != ParserType::OK) { std::cout << "Can't find paths." << std::endl; return EXIT_FAILURE; } std::cout << "Paths found." << std::endl; std::cout << "Search for module name..." << std::endl; std::string name; res = parser->GetModuleName(name, cmdVector); if (CheckReturn(res) != ParserType::OK) { std::cout << "Can't find module name." << std::endl; return EXIT_FAILURE; } std::cout << "Module name found." << std::endl; return CheckReturn(res); } int otbWrapperCommandLineParserTest3(int argc, char* argv[]) { ParserType::Pointer parser = ParserType::New(); std::vector cmdVector; if (argc > 2) { for (int i=2; iIsAttributExists(argv[1], cmdVector)) { return EXIT_FAILURE; } return EXIT_SUCCESS; } int otbWrapperCommandLineParserTest4(int argc, char* argv[]) { ParserType::Pointer parser = ParserType::New(); std::vector cmdVector; if (argc > 2) { for (int i=2; iIsAttributExists(argv[1], cmdVector)) { return EXIT_SUCCESS; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Wrappers/QtWidget/000077500000000000000000000000001301006202600203615ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/QtWidget/CMakeLists.txt000066400000000000000000000001171301006202600231200ustar00rootroot00000000000000project(OTBQtWidget) set(OTBQtWidget_LIBRARIES OTBQtWidget) otb_module_impl() OTB-release-5.8/Modules/Wrappers/QtWidget/include/000077500000000000000000000000001301006202600220045ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/QtWidget/include/itkQtProgressBar.h000066400000000000000000000033671301006202600254340ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: itkQtProgressBar.h Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) 2002 Insight Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef __itkQtProgressBar_h #define __itkQtProgressBar_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkCommand.h" #endif //tag=QT4-boost-compatibility #include "OTBQtWidgetExport.h" namespace itk { class OTBQtWidget_EXPORT QtProgressBar : public ::QProgressBar { Q_OBJECT public: /** Command Class invoked for button redraw */ typedef itk::MemberCommand< QtProgressBar > RedrawCommandType; /** Constructor */ QtProgressBar( QWidget *parent ); /** Destructor */ ~QtProgressBar() ITK_OVERRIDE; /** Get Command */ RedrawCommandType * GetRedrawCommand( void ) const; /** Manage a Progress event */ void ProcessEvent(itk::Object * caller, const itk::EventObject & event ); void ConstProcessEvent(const itk::Object * caller, const itk::EventObject & event ); /** Manage a Progress event */ void Observe( itk::Object *caller ); signals: void SetValueChanged(int); private: itk::Object::Pointer m_Caller; RedrawCommandType::Pointer m_RedrawCommand; }; } // end of namespace #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbQtApplication.h000066400000000000000000000022621301006202600254340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQtApplication_h #define otbQtApplication_h #include #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkMacro.h" #endif //tag=QT4-boost-compatibility #include "OTBQtWidgetExport.h" namespace otb { namespace Wrapper { class OTBQtWidget_EXPORT QtApplication : public QApplication { Q_OBJECT public: QtApplication(int& argc, char** argv); bool notify(QObject *object, QEvent* event) ITK_OVERRIDE; signals: void UnhandledException(QString message); }; } //end of namespace Wrapper } //end of namepsace otb #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbQtFileSelectionWidget.h000066400000000000000000000041241301006202600270610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQtFileSelectionWidget_h #define otbQtFileSelectionWidget_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperInputImageListParameter.h" #include "otbWrapperInputFilenameListParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility #include "OTBQtWidgetExport.h" namespace otb { namespace Wrapper { /** \class QtFileSelectionWidget * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtFileSelectionWidget : public QWidget { Q_OBJECT public: enum IOMode { IO_MODE_INPUT = 0, IO_MODE_OUTPUT = 1, }; QtFileSelectionWidget(); ~QtFileSelectionWidget() ITK_OVERRIDE; bool IsChecked() { return m_Checkbox->isChecked(); } void SetChecked( bool val ) { return m_Checkbox->setChecked( val ); } std::string GetFilename() { return QFile::encodeName( m_Input->text() ).constData(); } void ClearFilename() { m_Input->clear(); } QLineEdit* GetInput() { return m_Input; } void SetIOMode( IOMode ); IOMode GetIOMode() const; protected slots: void SelectFile(); private: QtFileSelectionWidget(const QtFileSelectionWidget&); //purposely not implemented void operator=(const QtFileSelectionWidget&); //purposely not implemented virtual void DoCreateWidget(); virtual void DoUpdateGUI(); QHBoxLayout * m_HLayout; QLineEdit * m_Input; QPushButton * m_Button; QCheckBox * m_Checkbox; IOMode m_IOMode; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbQtLogOutput.h000066400000000000000000000037101301006202600251320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQtLogOutput_h #define otbQtLogOutput_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkStdStreamLogOutput.h" #endif //tag=QT4-boost-compatibility //#include "itkObjectFactory.h" //#include "itkProcessObject.h" #include "OTBQtWidgetExport.h" namespace otb { /** \class QtLogOutput * \brief Class that get log output and launch an event when received. * * * \ingroup OTBQtWidget * */ class OTBQtWidget_EXPORT QtLogOutput : public QObject, public itk::LogOutput { Q_OBJECT public: typedef QtLogOutput Self; typedef itk::LogOutput Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; itkTypeMacro(QtLogOutput, itk::LogOutput); itkNewMacro(QtLogOutput); /** flush a buffer */ void Flush() ITK_OVERRIDE; /** Write to multiple outputs */ void Write(double timestamp) ITK_OVERRIDE; /** Write to a buffer */ void Write(std::string const &content) ITK_OVERRIDE; /** Write to a buffer */ void Write(std::string const &content, double timestamp) ITK_OVERRIDE; signals: void NewContentLog(QString); protected: /** Constructor */ QtLogOutput(); /** Destructor */ ~QtLogOutput() ITK_OVERRIDE; void PrintSelf(std::ostream &os, itk::Indent indent) const ITK_OVERRIDE; }; } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbQtStringSelectionWidget.h000066400000000000000000000041561301006202600274550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbQtStringSelectionWidget_h #define otbQtStringSelectionWidget_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperStringListParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility #include "OTBQtWidgetExport.h" namespace otb { namespace Wrapper { /** \class QtStringSelectionWidget * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtStringSelectionWidget : public QWidget { Q_OBJECT Q_PROPERTY( QString text READ GetText WRITE SetText RESET ClearText ); signals: void InternalQLineEditEditionFinished(); public: QtStringSelectionWidget(); ~QtStringSelectionWidget() ITK_OVERRIDE; bool IsChecked() { return m_Checkbox->isChecked(); } void SetChecked( bool val ) { return m_Checkbox->setChecked( val ); } inline const QString GetText() const { return m_Input->text(); } inline void SetText( const QString& qString) { m_Input->setText(qString); } std::string ToStdString() { return m_Input->text().toAscii().constData(); } void ClearText() { m_Input->clear(); } protected slots: void OnEditionFinished(); private: QtStringSelectionWidget(const QtStringSelectionWidget&); //purposely not implemented void operator=(const QtStringSelectionWidget&); //purposely not implemented virtual void DoCreateWidget(); virtual void DoUpdateGUI(); QHBoxLayout * m_HLayout; QLineEdit* m_Input; QCheckBox * m_Checkbox; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetChoiceParameter.h000066400000000000000000000035471301006202600307400ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetChoiceParameter_h #define otbWrapperQtWidgetChoiceParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperChoiceParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetChoiceParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetChoiceParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetChoiceParameter(ChoiceParameter*, QtWidgetModel*); ~QtWidgetChoiceParameter() ITK_OVERRIDE; protected slots: void SetValue( int value ); private: QtWidgetChoiceParameter(const QtWidgetChoiceParameter&); //purposely not implemented void operator=(const QtWidgetChoiceParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; ChoiceParameter::Pointer m_ChoiceParam; QHBoxLayout* m_MainHLayout; QComboBox* m_ComboBox; QStackedWidget* m_StackWidget; QVBoxLayout* m_VLayout; QGroupBox* m_VLayoutGroup; typedef std::vector WidgetListType; typedef WidgetListType::iterator WidgetListIteratorType; WidgetListType m_WidgetList; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetComplexInputImageParameter.h000066400000000000000000000034601301006202600331320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetComplexInputImageParameter_h #define otbWrapperQtWidgetComplexInputImageParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperComplexInputImageParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetComplexInputImageParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetComplexInputImageParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetComplexInputImageParameter(ComplexInputImageParameter*, QtWidgetModel*); ~QtWidgetComplexInputImageParameter() ITK_OVERRIDE; protected slots: bool SetFileName( const QString& value ); void SelectFile(); private: QtWidgetComplexInputImageParameter(const QtWidgetComplexInputImageParameter&); //purposely not implemented void operator=(const QtWidgetComplexInputImageParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; ComplexInputImageParameter::Pointer m_ComplexInputImageParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetComplexOutputImageParameter.h000066400000000000000000000037601301006202600333360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetComplexOutputImageParameter_h #define otbWrapperQtWidgetComplexOutputImageParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperComplexOutputImageParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetComplexOutputImageParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetComplexOutputImageParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetComplexOutputImageParameter(ComplexOutputImageParameter*, QtWidgetModel*); ~QtWidgetComplexOutputImageParameter() ITK_OVERRIDE; /** Get the PixelType*/ //itkGetMacro(PixelType, int); protected slots: void SetFileName( const QString& value ); void SelectFile(); void SetPixelType(int pixelType); private: QtWidgetComplexOutputImageParameter(const QtWidgetComplexOutputImageParameter&); //purposely not implemented void operator=(const QtWidgetComplexOutputImageParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; std::string m_FileName; ComplexOutputImageParameter::Pointer m_OutputImageParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; QComboBox* m_ComboBox; int m_ComplexPixelType; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetDirectoryParameter.h000066400000000000000000000033101301006202600314760ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetDirectoryParameter_h #define otbWrapperQtWidgetDirectoryParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperDirectoryParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetDirectoryParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetDirectoryParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetDirectoryParameter(DirectoryParameter*, QtWidgetModel*); ~QtWidgetDirectoryParameter() ITK_OVERRIDE; protected slots: void SetFileName( const QString& value ); void SelectFile(); private: QtWidgetDirectoryParameter(const QtWidgetDirectoryParameter&); //purposely not implemented void operator=(const QtWidgetDirectoryParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; DirectoryParameter::Pointer m_DirectoryParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetEmptyParameter.h000066400000000000000000000027101301006202600306330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetEmptyParameter_h #define otbWrapperQtWidgetEmptyParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperEmptyParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetEmptyParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetEmptyParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetEmptyParameter(EmptyParameter*, QtWidgetModel*); ~QtWidgetEmptyParameter() ITK_OVERRIDE; private: QtWidgetEmptyParameter(const QtWidgetEmptyParameter&); //purposely not implemented void operator=(const QtWidgetEmptyParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetFloatParameter.h000066400000000000000000000031751301006202600306100ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetFloatParameter_h #define otbWrapperQtWidgetFloatParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperNumericalParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetFloatParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetFloatParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetFloatParameter(FloatParameter*, QtWidgetModel*); ~QtWidgetFloatParameter() ITK_OVERRIDE; protected slots: void SetValue( double value ); private: QtWidgetFloatParameter(const QtWidgetFloatParameter&); //purposely not implemented void operator=(const QtWidgetFloatParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; QHBoxLayout * m_QHBoxLayout; QDoubleSpinBox * m_QDoubleSpinBox; FloatParameter::Pointer m_FloatParam; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetInputFilenameListParameter.h000066400000000000000000000042371301006202600331370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetInputFilenameListParameter_h #define otbWrapperQtWidgetInputFilenameListParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbQtFileSelectionWidget.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetInputFilenameListParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetInputFilenameListParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetInputFilenameListParameter(InputFilenameListParameter*, QtWidgetModel*); ~QtWidgetInputFilenameListParameter() ITK_OVERRIDE; signals: void Change(); void FileSelectionWidgetAdded( QWidget * ); protected slots: //void SetFileName( const QString& value ); //virtual void SelectFile(); virtual void UpFile(); virtual void DownFile(); virtual void AddFile(); virtual void SuppressFile(); virtual void EraseFile(); virtual void UpdateFilenameList(); private: QtWidgetInputFilenameListParameter(const QtWidgetInputFilenameListParameter&); //purposely not implemented void operator=(const QtWidgetInputFilenameListParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; void RecreateFilenameList(); void UpdateFileList( std::map idMap ); InputFilenameListParameter::Pointer m_InputFilenameListParam; QHBoxLayout * m_HLayout; QVBoxLayout * m_FileLayout; QScrollArea * m_Scroll; std::vector m_FileSelectionList; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetInputFilenameParameter.h000066400000000000000000000040151301006202600322750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetInputFilenameParameter_h #define otbWrapperQtWidgetInputFilenameParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperInputFilenameParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetInputFilenameParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetInputFilenameParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetInputFilenameParameter(InputFilenameParameter*, QtWidgetModel*); ~QtWidgetInputFilenameParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); protected slots: void SetFileName( const QString& value ); void SelectFile(); private: QtWidgetInputFilenameParameter(const QtWidgetInputFilenameParameter&); //purposely not implemented void operator=(const QtWidgetInputFilenameParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; InputFilenameParameter::Pointer m_FilenameParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; inline const QLineEdit* QtWidgetInputFilenameParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetInputFilenameParameter ::GetInput() { return m_Input; } } // Wrapper } // otb #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetInputImageListParameter.h000066400000000000000000000041651301006202600324410ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetInputImageListParameter_h #define otbWrapperQtWidgetInputImageListParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbQtFileSelectionWidget.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetInputImageListParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetInputImageListParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetInputImageListParameter(InputImageListParameter*, QtWidgetModel*); ~QtWidgetInputImageListParameter() ITK_OVERRIDE; signals: void Change(); void FileSelectionWidgetAdded( QWidget * ); protected slots: //void SetFileName( const QString& value ); //virtual void SelectFile(); virtual void UpFile(); virtual void DownFile(); virtual void AddFile(); virtual void SuppressFile(); virtual void EraseFile(); virtual void UpdateImageList(); private: QtWidgetInputImageListParameter(const QtWidgetInputImageListParameter&); //purposely not implemented void operator=(const QtWidgetInputImageListParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; void RecreateImageList(); void UpdateFileList( std::map idMap ); InputImageListParameter::Pointer m_InputImageListParam; QHBoxLayout * m_HLayout; QVBoxLayout * m_FileLayout; QScrollArea * m_Scroll; std::vector m_FileSelectionList; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetInputImageParameter.h000066400000000000000000000037441301006202600316070ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetInputImageParameter_h #define otbWrapperQtWidgetInputImageParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperInputImageParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetInputImageParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetInputImageParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetInputImageParameter(InputImageParameter*, QtWidgetModel*); ~QtWidgetInputImageParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); protected slots: bool SetFileName( const QString& value ); void SelectFile(); private: QtWidgetInputImageParameter(const QtWidgetInputImageParameter&); //purposely not implemented void operator=(const QtWidgetInputImageParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; InputImageParameter::Pointer m_InputImageParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; inline const QLineEdit* QtWidgetInputImageParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetInputImageParameter ::GetInput() { return m_Input; } } // Wrapper } // otb #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetInputProcessXMLParameter.h000066400000000000000000000040211301006202600325510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetInputProcessXMLParameter_h #define otbWrapperQtWidgetInputProcessXMLParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperInputProcessXMLParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetInputProcessXMLParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetInputProcessXMLParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetInputProcessXMLParameter(InputProcessXMLParameter*, QtWidgetModel*); ~QtWidgetInputProcessXMLParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); protected slots: void SetFileName( const QString& value ); void SelectFile(); private: QtWidgetInputProcessXMLParameter(const QtWidgetInputProcessXMLParameter&); //purposely not implemented void operator=(const QtWidgetInputProcessXMLParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; InputProcessXMLParameter::Pointer m_XMLParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; inline const QLineEdit* QtWidgetInputProcessXMLParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetInputProcessXMLParameter ::GetInput() { return m_Input; } } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetInputVectorDataListParameter.h000066400000000000000000000043571301006202600334560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetInputVectorDataListParameter_h #define otbWrapperQtWidgetInputVectorDataListParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperInputVectorDataListParameter.h" #include "otbQtFileSelectionWidget.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetInputVectorDataListParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetInputVectorDataListParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetInputVectorDataListParameter(InputVectorDataListParameter*, QtWidgetModel*); ~QtWidgetInputVectorDataListParameter() ITK_OVERRIDE; signals: void Change(); void FileSelectionWidgetAdded( QWidget * ); protected slots: //void SetFileName( const QString& value ); //virtual void SelectFile(); virtual void UpFile(); virtual void DownFile(); virtual void AddFile(); virtual void SuppressFile(); virtual void EraseFile(); virtual void UpdateVectorDataList(); private: QtWidgetInputVectorDataListParameter(const QtWidgetInputVectorDataListParameter&); //purposely not implemented void operator=(const QtWidgetInputVectorDataListParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; void RecreateVectorDataList(); void UpdateFileList( std::map idMap ); InputVectorDataListParameter::Pointer m_InputVectorDataListParam; QHBoxLayout * m_HLayout; QVBoxLayout * m_FileLayout; QScrollArea * m_Scroll; std::vector m_FileSelectionList; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetInputVectorDataParameter.h000066400000000000000000000040601301006202600326110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetInputVectorDataParameter_h #define otbWrapperQtWidgetInputVectorDataParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperInputVectorDataParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetInputVectorDataParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetInputVectorDataParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetInputVectorDataParameter(InputVectorDataParameter*, QtWidgetModel*); ~QtWidgetInputVectorDataParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); protected slots: bool SetFileName( const QString& value ); void SelectFile(); private: QtWidgetInputVectorDataParameter(const QtWidgetInputVectorDataParameter&); //purposely not implemented void operator=(const QtWidgetInputVectorDataParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; InputVectorDataParameter::Pointer m_InputVectorDataParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; inline const QLineEdit* QtWidgetInputVectorDataParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetInputVectorDataParameter ::GetInput() { return m_Input; } } // Wrapper } // otb #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetIntParameter.h000066400000000000000000000031311301006202600302650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetIntParameter_h #define otbWrapperQtWidgetIntParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperNumericalParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetIntParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetIntParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetIntParameter(IntParameter*, QtWidgetModel*); ~QtWidgetIntParameter() ITK_OVERRIDE; protected slots: void SetValue( int value ); private: QtWidgetIntParameter(const QtWidgetIntParameter&); //purposely not implemented void operator=(const QtWidgetIntParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; QHBoxLayout * m_QHBoxLayout; QSpinBox * m_QSpinBox; IntParameter::Pointer m_IntParam; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetListViewParameter.h000066400000000000000000000034721301006202600313110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetListViewParameter_h #define otbWrapperQtWidgetListViewParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperListViewParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetListViewParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetListViewParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetListViewParameter(ListViewParameter*, QtWidgetModel*); ~QtWidgetListViewParameter() ITK_OVERRIDE; std::vector GetSelectedItems() { return m_SelectedItems; } protected slots: void SelectedItems(); private: QtWidgetListViewParameter(const QtWidgetListViewParameter&); //purposely not implemented void operator=(const QtWidgetListViewParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; ListViewParameter::Pointer m_ListViewParam; QListWidget* m_ListView; QHBoxLayout* m_VLayout; std::vector m_SelectedItems; int m_LineHeight; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetModel.h000066400000000000000000000102021301006202600267270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetModel_h #define otbWrapperQtWidgetModel_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperApplication.h" #include "otbQtLogOutput.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { class OTBQtWidget_EXPORT AppliThread : public QThread { Q_OBJECT public: inline AppliThread(Application* app) { m_Application = app; } ~AppliThread() ITK_OVERRIDE; inline void Execute() { // Call the signal start to begin running the program start(); } signals: /** * \brief Signal emitted when the OTB-application has finished. * * \param status 0 The result status of the OTB-application. */ void ApplicationExecutionDone( int status =0 ); /** * \brief Signal emitted when an exception has been raised by an * otb::Application and is caught by this calling QThread. * * \param what The std::exception::what() which is forwarded to listeners. */ void ExceptionRaised( QString what ); protected: void run() ITK_OVERRIDE; private: AppliThread(const AppliThread&); //purposely not implemented void operator=(const AppliThread&); //purposely not implemented Application::Pointer m_Application; }; /** \class QtWidgetModel * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetModel : public QObject { Q_OBJECT public: QtWidgetModel(Application* app); ~QtWidgetModel() ITK_OVERRIDE; Application* GetApplication() { return m_Application; } QtLogOutput::Pointer GetLogOutput() { return m_LogOutput; } /** Logger warning message sender */ void SendLogWARNING( const std::string & mes ); /** Logger info message sender */ void SendLogINFO( const std::string & mes ); /** Logger debug message sender */ void SendLogDEBUG( const std::string & mes ); /** Used by inxml when forcing xml parse flag to update widget data via UpdateGui */ void UpdateAllWidgets() { GetApplication()->ForceInXMLParseFlag(); emit UpdateGui(); } signals: void SetApplicationReady(bool); void SetProgressReportBegin(); /** * \brief Signal emitted when execution otb::Application has finished. * * \param status The result status of the otb::application (-1 when * an exception has occurred). */ void SetProgressReportDone( int status =0 ); /** * \brief Signal emitted when an exception has been raised by an * otb::Application and is caught by the calling QThread. * * \param what The std::exception::what() which is forwarded to listeners. */ void ExceptionRaised( QString what ); void UpdateGui(); protected slots: /** * \brief Slot called when execution is requested (e.g. by * otb::Wrapper::QtWidgetView). * * This slot is protected so it can only be called via Qt * signal/slot mechanism and not directly by extern caller. */ void ExecuteAndWriteOutputSlot(); /** * \brief Slots called every time one of the widget needs to be * updated (e.g. by specialized parameter widgets). * * This slot is protected so it can only be called via Qt * signal/slot mechanism and not directly by extern caller. */ void NotifyUpdate(); private slots: /** * \brief * * \param status */ void OnApplicationExecutionDone( int status ); private: QtWidgetModel(const QtWidgetModel&); //purposely not implemented void operator=(const QtWidgetModel&); //purposely not implemented Application::Pointer m_Application; QtLogOutput::Pointer m_LogOutput; bool m_IsRunning; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetOutputFilenameParameter.h000066400000000000000000000040301301006202600324730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetOutputFilenameParameter_h #define otbWrapperQtWidgetOutputFilenameParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperOutputFilenameParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetOutputFilenameParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetOutputFilenameParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetOutputFilenameParameter(OutputFilenameParameter*, QtWidgetModel*); ~QtWidgetOutputFilenameParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); public slots: void SetFileName( const QString& value ); protected slots: void SelectFile(); private: QtWidgetOutputFilenameParameter(const QtWidgetOutputFilenameParameter&); //purposely not implemented void operator=(const QtWidgetOutputFilenameParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; OutputFilenameParameter::Pointer m_FilenameParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; inline const QLineEdit* QtWidgetOutputFilenameParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetOutputFilenameParameter ::GetInput() { return m_Input; } } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetOutputImageParameter.h000066400000000000000000000042431301006202600320030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetOutputImageParameter_h #define otbWrapperQtWidgetOutputImageParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperOutputImageParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetOutputImageParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetOutputImageParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetOutputImageParameter(OutputImageParameter*, QtWidgetModel*); ~QtWidgetOutputImageParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); /** Get the PixelType*/ //itkGetMacro(PixelType, int); public slots: void SetFileName( const QString& value ); protected slots: void SelectFile(); void SetPixelType(int pixelType); private: QtWidgetOutputImageParameter(const QtWidgetOutputImageParameter&); //purposely not implemented void operator=(const QtWidgetOutputImageParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; std::string m_FileName; OutputImageParameter::Pointer m_OutputImageParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; QComboBox* m_ComboBox; int m_PixelType; }; inline const QLineEdit* QtWidgetOutputImageParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetOutputImageParameter ::GetInput() { return m_Input; } } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetOutputProcessXMLParameter.h000066400000000000000000000040561301006202600327620ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetOutputProcessXMLParameter_h #define otbWrapperQtWidgetOutputProcessXMLParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperOutputProcessXMLParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetOutputProcessXMLParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetOutputProcessXMLParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetOutputProcessXMLParameter(OutputProcessXMLParameter*, QtWidgetModel*); ~QtWidgetOutputProcessXMLParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); public slots: void SetFileName( const QString& value ); protected slots: void SelectFile(); private: QtWidgetOutputProcessXMLParameter(const QtWidgetOutputProcessXMLParameter&); //purposely not implemented void operator=(const QtWidgetOutputProcessXMLParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; OutputProcessXMLParameter::Pointer m_XMLParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; }; inline const QLineEdit* QtWidgetOutputProcessXMLParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetOutputProcessXMLParameter ::GetInput() { return m_Input; } } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetOutputVectorDataParameter.h000066400000000000000000000043131301006202600330130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetOutputVectorDataParameter_h #define otbWrapperQtWidgetOutputVectorDataParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperOutputVectorDataParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetOutputVectorDataParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetOutputVectorDataParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetOutputVectorDataParameter(OutputVectorDataParameter*, QtWidgetModel*); ~QtWidgetOutputVectorDataParameter() ITK_OVERRIDE; inline const QLineEdit* GetInput() const; inline QLineEdit* GetInput(); /** Get the PixelType*/ //itkGetMacro(PixelType, int); public slots: void SetFileName( const QString& value ); protected slots: void SelectFile(); private: QtWidgetOutputVectorDataParameter(const QtWidgetOutputVectorDataParameter&); //purposely not implemented void operator=(const QtWidgetOutputVectorDataParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; std::string m_FileName; OutputVectorDataParameter::Pointer m_OutputVectorDataParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; QPushButton * m_Button; QComboBox* m_ComboBox; int m_PixelType; }; inline const QLineEdit* QtWidgetOutputVectorDataParameter ::GetInput() const { return m_Input; } inline QLineEdit* QtWidgetOutputVectorDataParameter ::GetInput() { return m_Input; } } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetParameterBase.h000066400000000000000000000034141301006202600304110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetParameterBase_h #define otbWrapperQtWidgetParameterBase_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperParameter.h" #include "otbWrapperQtWidgetModel.h" #endif //tag=QT4-boost-compatibility #include "OTBQtWidgetExport.h" namespace otb { namespace Wrapper { /** \class QtWidgetParameterBase * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetParameterBase : public QWidget { Q_OBJECT public: QtWidgetParameterBase(Parameter *, QtWidgetModel*); ~QtWidgetParameterBase() ITK_OVERRIDE; void CreateWidget(); public slots: void UpdateGUI(); virtual void SetActivationState( bool value ); void Reset(); protected slots: void ParameterChanged(const QString& key); signals: void ParameterActiveStatus(bool value); protected: QtWidgetModel* GetModel(); private: QtWidgetParameterBase(const QtWidgetParameterBase&); //purposely not implemented void operator=(const QtWidgetParameterBase&); //purposely not implemented virtual void DoUpdateGUI() = 0; virtual void DoCreateWidget() = 0; QtWidgetModel* m_Model; Parameter* m_Param; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetParameterFactory.h000066400000000000000000000036451301006202600311540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetFactory_h #define otbWrapperQtWidgetFactory_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "itkObject.h" #include "itkObjectFactory.h" #endif //tag=QT4-boost-compatibility #include "OTBQtWidgetExport.h" namespace otb { namespace Wrapper { class Parameter; class QtWidgetModel; class QtWidgetParameterBase; /** \class QtWidgetParameterFactory * \brief * * \ingroup OTBQtWidget * */ class OTBQtWidget_EXPORT QtWidgetParameterFactory : public itk::Object { public: /** Standard class typedefs. */ typedef QtWidgetParameterFactory Self; typedef itk::Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** New() method */ itkNewMacro(Self); /** Run-time type information (and related methods). */ itkTypeMacro(QtWidgetParameterFactory, Object); /** Create the appropriate ImageIO depending on the particulars of the file. */ static QtWidgetParameterBase* CreateQtWidget( Parameter* param, QtWidgetModel* model ); protected: QtWidgetParameterFactory(); ~QtWidgetParameterFactory() ITK_OVERRIDE; private: QtWidgetParameterFactory(const Self&); //purposely not implemented void operator=(const Self&); //purposely not implemented }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetParameterGroup.h000066400000000000000000000037061301006202600306370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetParameterGroup_h #define otbWrapperQtWidgetParameterGroup_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperParameterGroup.h" #include "otbWrapperRadiusParameter.h" #include "otbWrapperRAMParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #include "otbWrapperInputProcessXMLParameter.h" #include "otbWrapperOutputProcessXMLParameter.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetParameterGroup * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetParameterGroup : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetParameterGroup(ParameterGroup::Pointer, QtWidgetModel*); ~QtWidgetParameterGroup() ITK_OVERRIDE; public slots: void SetActivationState( bool value ) ITK_OVERRIDE; private: QtWidgetParameterGroup(const QtWidgetParameterGroup&); //purposely not implemented void operator=(const QtWidgetParameterGroup&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; virtual void ProcessChild(Parameter * currentNode, bool status); ParameterGroup::Pointer m_ParamList; typedef std::vector WidgetListType; typedef WidgetListType::iterator WidgetListIteratorType; WidgetListType m_WidgetList; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetParameterLabel.h000066400000000000000000000025071301006202600305600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetParameterLabel_h #define otbWrapperQtWidgetParameterLabel_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperParameter.h" #endif //tag=QT4-boost-compatibility #include "OTBQtWidgetExport.h" namespace otb { namespace Wrapper { /** \class QtWidgetParameterLabel * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetParameterLabel : public QWidget { Q_OBJECT public: QtWidgetParameterLabel(Parameter*); ~QtWidgetParameterLabel() ITK_OVERRIDE; private: QtWidgetParameterLabel(const QtWidgetParameterLabel&); //purposely not implemented void operator=(const QtWidgetParameterLabel&); //purposely not implemented }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetProgressReport.h000066400000000000000000000045201301006202600306750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetProgressReport_h #define otbWrapperQtWidgetProgressReport_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperQtWidgetModel.h" #include "itkQtProgressBar.h" #include "itkProcessObject.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetProgressReport * \brief Create a widget reporting the progress of the application * process. * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetProgressReport : public QWidget { Q_OBJECT public: QtWidgetProgressReport(QtWidgetModel * model); ~QtWidgetProgressReport() ITK_OVERRIDE; void SetApplication(Application::Pointer app); typedef itk::MemberCommand< QtWidgetProgressReport > AddProcessCommandType; void ProcessEvent( itk::Object * caller, const itk::EventObject & event ); std::string GetCurrentDescription() { return m_CurrentDescription; } /* itk::ProcessObject* GetCurrentProcess() { return m_CurrentProcess; } QtWidgetModel * GetModel() { m_Model; } QVBoxLayout * GetLayout() { return m_Layout; } */ public slots: void RemoveLayout(); /*virtual */void ReportProcess(); signals: void AddNewProcessToReport(); private: QtWidgetProgressReport(const QtWidgetProgressReport&); //purposely not implemented void operator=(const QtWidgetProgressReport&); //purposely not implemented Application::Pointer m_Application; QtWidgetModel * m_Model; QVBoxLayout * m_Layout; AddProcessCommandType::Pointer m_AddProcessCommand; itk::ProcessObject* m_CurrentProcess; std::string m_CurrentDescription; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetRAMParameter.h000066400000000000000000000031231301006202600301530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetRAMParameter_h #define otbWrapperQtWidgetRAMParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperRAMParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetRAMParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetRAMParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetRAMParameter(RAMParameter*, QtWidgetModel*); ~QtWidgetRAMParameter() ITK_OVERRIDE; protected slots: void SetValue( int value ); private: QtWidgetRAMParameter(const QtWidgetRAMParameter&); //purposely not implemented void operator=(const QtWidgetRAMParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; QHBoxLayout * m_QHBoxLayout; QSpinBox * m_QSpinBox; RAMParameter::Pointer m_RAMParam; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetSimpleProgressReport.h000066400000000000000000000043231301006202600320500ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetSimpleProgressReport_h #define otbWrapperQtWidgetSimpleProgressReport_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperQtWidgetModel.h" #include "itkProcessObject.h" #include "itkQtProgressBar.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetSimpleProgressReport * \brief Create a widget reporting the progress of the application * process. * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetSimpleProgressReport : public QWidget { Q_OBJECT public: QtWidgetSimpleProgressReport(QtWidgetModel * model); ~QtWidgetSimpleProgressReport() ITK_OVERRIDE; void SetApplication(Application::Pointer app); typedef itk::MemberCommand< QtWidgetSimpleProgressReport > AddProcessCommandType; void ProcessEvent( itk::Object * caller, const itk::EventObject & event ); public slots: void Init(); void ReportProcess(); signals: void AddNewProcessToReport(); private: QtWidgetSimpleProgressReport(const QtWidgetSimpleProgressReport&); //purposely not implemented void operator=(const QtWidgetSimpleProgressReport&); //purposely not //implemented Application::Pointer m_Application; QtWidgetModel * m_Model; QVBoxLayout * m_Layout; AddProcessCommandType::Pointer m_AddProcessCommand; itk::ProcessObject* m_CurrentProcess; std::string m_CurrentDescription; itk::QtProgressBar * m_Bar; QLabel * m_Label; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetStringListParameter.h000066400000000000000000000035101301006202600316360ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetStringListParameter_h #define otbWrapperQtWidgetStringListParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbQtStringSelectionWidget.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetStringListParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetStringListParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetStringListParameter(StringListParameter*, QtWidgetModel*); ~QtWidgetStringListParameter() ITK_OVERRIDE; signals: void Change(); protected slots: void SetString( const QString& value ); virtual void AddString(); virtual void SuppressString(); virtual void UpdateStringList(); private: QtWidgetStringListParameter(const QtWidgetStringListParameter&); //purposely not implemented void operator=(const QtWidgetStringListParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; StringListParameter::Pointer m_StringListParam; QHBoxLayout * m_HLayout; QVBoxLayout * m_StringLayout; QScrollArea * m_Scroll; std::vector m_LineEditList; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetStringParameter.h000066400000000000000000000032021301006202600310000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetStringParameter_h #define otbWrapperQtWidgetStringParameter_h #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperStringParameter.h" #include "otbWrapperQtWidgetParameterBase.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetStringParameter * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetStringParameter : public QtWidgetParameterBase { Q_OBJECT public: QtWidgetStringParameter(StringParameter*, QtWidgetModel*); ~QtWidgetStringParameter() ITK_OVERRIDE; protected slots: void SetValue( const QString& value ); private: QtWidgetStringParameter(const QtWidgetStringParameter&); //purposely not implemented void operator=(const QtWidgetStringParameter&); //purposely not implemented void DoCreateWidget() ITK_OVERRIDE; void DoUpdateGUI() ITK_OVERRIDE; StringParameter::Pointer m_StringParam; QHBoxLayout * m_HLayout; QLineEdit* m_Input; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/include/otbWrapperQtWidgetView.h000066400000000000000000000034641301006202600266150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperQtWidgetView_h #define otbWrapperQtWidgetView_h #include #include #ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829 //tag=QT4-boost-compatibility #include "otbWrapperQtWidgetModel.h" #endif //tag=QT4-boost-compatibility namespace otb { namespace Wrapper { /** \class QtWidgetView * \brief * * \ingroup OTBQtWidget */ class OTBQtWidget_EXPORT QtWidgetView : public QWidget { Q_OBJECT public: QtWidgetView(Application* app); ~QtWidgetView() ITK_OVERRIDE; void CreateGui(); QtWidgetModel* GetModel() { return m_Model; } public slots: void CloseSlot(); void UnhandledException(QString message); private slots: void UpdateMessageAfterExecuteClicked(); void UpdateMessageAfterApplicationReady(bool val); signals: void QuitSignal(); private: QtWidgetView(const QtWidgetView&); //purposely not implemented void operator=(const QtWidgetView&); //purposely not implemented QWidget* CreateFooter(); QWidget* CreateInputWidgets(); QWidget* CreateDoc(); Application::Pointer m_Application; QtWidgetModel* m_Model; QTextEdit *m_LogText; QTabWidget *m_TabWidget; QPushButton* m_ExecButton; QPushButton* m_QuitButton; QLabel* m_Message; }; } } #endif OTB-release-5.8/Modules/Wrappers/QtWidget/otb-module.cmake000066400000000000000000000003351301006202600234330ustar00rootroot00000000000000set(DOCUMENTATION "QT wrappers.") otb_module(OTBQtWidget ENABLE_SHARED DEPENDS OTBApplicationEngine OTBITK OTBQt4 OTBQtAdapters TEST_DEPENDS OTBTestKernel DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Wrappers/QtWidget/src/000077500000000000000000000000001301006202600211505ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/QtWidget/src/CMakeLists.txt000066400000000000000000000121471301006202600237150ustar00rootroot00000000000000set(OTBQtWidget_SRC otbQtLogOutput.cxx otbWrapperQtWidgetModel.cxx otbWrapperQtWidgetParameterLabel.cxx otbWrapperQtWidgetView.cxx otbWrapperQtWidgetInputProcessXMLParameter.cxx otbWrapperQtWidgetIntParameter.cxx otbWrapperQtWidgetInputVectorDataListParameter.cxx otbWrapperQtWidgetSimpleProgressReport.cxx otbWrapperQtWidgetFloatParameter.cxx otbWrapperQtWidgetChoiceParameter.cxx otbWrapperQtWidgetComplexOutputImageParameter.cxx otbWrapperQtWidgetOutputFilenameParameter.cxx otbQtStringSelectionWidget.cxx itkQtProgressBar.cxx otbWrapperQtWidgetStringParameter.cxx otbQtApplication.cxx otbWrapperQtWidgetParameterFactory.cxx otbWrapperQtWidgetListViewParameter.cxx otbWrapperQtWidgetDirectoryParameter.cxx otbWrapperQtWidgetOutputImageParameter.cxx otbWrapperQtWidgetInputVectorDataParameter.cxx otbQtFileSelectionWidget.cxx otbWrapperQtWidgetParameterGroup.cxx otbWrapperQtWidgetInputFilenameListParameter.cxx otbWrapperQtWidgetComplexInputImageParameter.cxx otbWrapperQtWidgetRAMParameter.cxx otbWrapperQtWidgetProgressReport.cxx otbWrapperQtWidgetOutputProcessXMLParameter.cxx otbWrapperQtWidgetParameterBase.cxx otbWrapperQtWidgetInputImageParameter.cxx otbWrapperQtWidgetStringListParameter.cxx otbWrapperQtWidgetEmptyParameter.cxx otbWrapperQtWidgetOutputVectorDataParameter.cxx otbWrapperQtWidgetInputFilenameParameter.cxx otbWrapperQtWidgetInputImageListParameter.cxx ) set(OTBQtWidget_MOC_HDR ../include/otbWrapperQtWidgetEmptyParameter.h ../include/otbWrapperQtWidgetFloatParameter.h ../include/otbWrapperQtWidgetIntParameter.h ../include/otbWrapperQtWidgetStringParameter.h ../include/otbWrapperQtWidgetStringListParameter.h ../include/otbWrapperQtWidgetChoiceParameter.h ../include/otbWrapperQtWidgetInputImageParameter.h ../include/otbWrapperQtWidgetComplexInputImageParameter.h ../include/otbWrapperQtWidgetComplexOutputImageParameter.h ../include/otbWrapperQtWidgetInputImageListParameter.h ../include/otbWrapperQtWidgetInputVectorDataListParameter.h ../include/otbWrapperQtWidgetInputVectorDataParameter.h ../include/otbWrapperQtWidgetOutputImageParameter.h ../include/otbWrapperQtWidgetOutputVectorDataParameter.h ../include/otbWrapperQtWidgetOutputProcessXMLParameter.h ../include/otbWrapperQtWidgetInputProcessXMLParameter.h ../include/otbWrapperQtWidgetParameterGroup.h ../include/otbWrapperQtWidgetParameterLabel.h ../include/otbWrapperQtWidgetParameterBase.h ../include/otbWrapperQtWidgetModel.h ../include/otbWrapperQtWidgetView.h ../include/otbWrapperQtWidgetProgressReport.h ../include/otbWrapperQtWidgetListViewParameter.h ../include/otbQtFileSelectionWidget.h ../include/otbQtStringSelectionWidget.h ../include/otbQtApplication.h ../include/itkQtProgressBar.h ../include/otbWrapperQtWidgetInputFilenameParameter.h ../include/otbWrapperQtWidgetInputFilenameListParameter.h ../include/otbWrapperQtWidgetOutputFilenameParameter.h ../include/otbQtLogOutput.h ../include/otbWrapperQtWidgetDirectoryParameter.h ../include/otbWrapperQtWidgetSimpleProgressReport.h ../include/otbWrapperQtWidgetRAMParameter.h ) QT4_WRAP_CPP(OTBQtWidget_MOC_SRC ${OTBQtWidget_MOC_HDR}) add_library(OTBQtWidget ${OTBQtWidget_SRC} ${OTBQtWidget_MOC_SRC}) target_link_libraries( OTBQtWidget ${OTBApplicationEngine_LIBRARIES} ${OTBQt4_LIBRARIES} ${OTBQtAdapters_LIBRARIES} ) otb_module_target(OTBQtWidget) add_executable(otbApplicationLauncherQt otbApplicationLauncherQt.cxx) target_link_libraries(otbApplicationLauncherQt ${OTBQtWidget_LIBRARIES} ${OTBApplicationEngine_LIBRARIES} ${OTBQt4_LIBRARIES} ) otb_module_target(otbApplicationLauncherQt) set_linker_stack_size_flag(otbApplicationLauncherQt 10000000) # Where we will install the script in the build tree get_target_property(GUI_OUTPUT_DIR otbApplicationLauncherQt RUNTIME_OUTPUT_DIRECTORY) # Generate a script in the build dir, next to the gui launcher # Need a two-step process since configure_file don't support permissions file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts) if (WIN32) configure_file( ${CMAKE_SOURCE_DIR}/CMake/otbgui.bat.in ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbgui.bat @ONLY ) file(COPY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbgui.bat DESTINATION ${GUI_OUTPUT_DIR} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) # TODO : test if NO_INSTALL is set install(PROGRAMS ${GUI_OUTPUT_DIR}/otbgui.bat DESTINATION ${OTBQtWidget_INSTALL_RUNTIME_DIR} COMPONENT Runtime) else() configure_file( ${CMAKE_SOURCE_DIR}/CMake/otbgui.sh.in ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbgui @ONLY ) file(COPY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Scripts/otbgui DESTINATION ${GUI_OUTPUT_DIR} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) # TODO : test if NO_INSTALL is set install(PROGRAMS ${GUI_OUTPUT_DIR}/otbgui DESTINATION ${OTBQtWidget_INSTALL_RUNTIME_DIR} COMPONENT Runtime) endif() OTB-release-5.8/Modules/Wrappers/QtWidget/src/itkQtProgressBar.cxx000066400000000000000000000045501301006202600251460ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: itkQtProgressBar.cxx Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) 2002 Insight Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkProcessObject.h" #include "itkQtProgressBar.h" namespace itk { /** Constructor */ QtProgressBar::QtProgressBar( QWidget *par):QProgressBar(par) { m_RedrawCommand = RedrawCommandType::New(); m_RedrawCommand->SetCallbackFunction( this, &QtProgressBar::ProcessEvent ); m_RedrawCommand->SetCallbackFunction( this, &QtProgressBar::ConstProcessEvent ); m_Caller = itk::Object::New(); this->setMaximum( 100 ); this->reset(); } QtProgressBar::~QtProgressBar() { m_Caller->RemoveAllObservers(); } /** Get Command */ QtProgressBar::RedrawCommandType * QtProgressBar::GetRedrawCommand( void ) const { return m_RedrawCommand.GetPointer(); } /** Manage a Progress event */ void QtProgressBar::ProcessEvent( itk::Object * caller, const itk::EventObject & ev ) { if( typeid( itk::ProgressEvent ) == typeid( ev ) ) { ::itk::ProcessObject::Pointer process = dynamic_cast< itk::ProcessObject *>( caller ); const int value2 = static_cast( process->GetProgress() * this->maximum() ); emit SetValueChanged( value2 ); } } void QtProgressBar::ConstProcessEvent( const itk::Object * caller, const itk::EventObject & ev ) { if( typeid( itk::ProgressEvent ) == typeid( ev ) ) { itk::ProcessObject::ConstPointer process = dynamic_cast< const itk::ProcessObject *>( caller ); const int v = static_cast( process->GetProgress() * this->maximum() ); emit SetValueChanged( v ); } } /** Manage a Progress event */ void QtProgressBar::Observe( itk::Object *caller ) { m_Caller = caller; m_Caller->AddObserver( itk::ProgressEvent(), m_RedrawCommand.GetPointer() ); } } // end namespace fltk OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbApplicationLauncherQt.cxx000066400000000000000000000066441301006202600266450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbWrapperApplicationRegistry.h" #include "otbWrapperQtWidgetView.h" #include "otbWrapperQtWidgetSimpleProgressReport.h" #include "otbQtApplication.h" #include "itksys/SystemTools.hxx" using otb::Wrapper::Application; using otb::Wrapper::ApplicationRegistry; using otb::Wrapper::QtWidgetView; //using otb::Wrapper::QtWidgetProgressReport; using otb::Wrapper::QtWidgetSimpleProgressReport; using otb::Wrapper::QtApplication; int main(int argc, char* argv[]) { // Handle UTF-8 filenames QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8")); QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8")); QtApplication qtApp(argc, argv); if (argc < 2) { std::cerr << "Usage : " << argv[0] << " module_name [module_path]" << std::endl; return EXIT_FAILURE; } std::string moduleName = argv[1]; // Get the module path list std::list modulePathList; if (argc > 2) { std::copy(argv + 2, argv + argc, std::back_inserter(modulePathList)); // Load the path in the environment std::list::const_iterator it = modulePathList.begin(); while( it != modulePathList.end() ) { ApplicationRegistry::AddApplicationPath( *(it) ); ++it; } } // Create module Application::Pointer app = ApplicationRegistry::CreateApplication(moduleName); if (app.IsNull()) { std::cerr << "Could not find application " << moduleName << std::endl; std::string modulePath = ApplicationRegistry::GetApplicationPath(); std::cout << "Module search path : " << modulePath << std::endl; std::vector list = ApplicationRegistry::GetAvailableApplications(); std::cout << "Available applications : " << (list.empty() ? "None" : "") << std::endl; for (std::vector::const_iterator it = list.begin(); it != list.end(); ++it) { std::cout << " " << *it << std::endl; } return EXIT_FAILURE; } // MainWidget : that contains the view and any other widget // (progress, logs...) QMainWindow* mainWindow = new QMainWindow(); mainWindow->setWindowIcon(QIcon( ":/otb_small.png" )); mainWindow->setWindowTitle(QString(app->GetDocName()).append(" - ").append(OTB_VERSION_STRING)); // Create GUI based on module QtWidgetView* gui = new QtWidgetView(app); gui->CreateGui(); // Connect the View "Quit" signal, to the mainWindow close slot QObject::connect(gui, SIGNAL(QuitSignal()), mainWindow, SLOT(close())); QObject::connect(&qtApp, SIGNAL(UnhandledException(QString)), gui, SLOT(UnhandledException(QString))); // build the main window, central widget is the plugin view, other // are docked widget (progress, logs...) mainWindow->setCentralWidget(gui); // Show the main window mainWindow->show(); // Start event processing loop return qtApp.exec(); } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbQtApplication.cxx000066400000000000000000000022621301006202600251530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbQtApplication.h" #include #include namespace otb { namespace Wrapper { QtApplication::QtApplication(int& argcc, char** argvv) : QApplication(argcc, argvv) { } bool QtApplication::notify(QObject *object, QEvent* ev) { try { return QApplication::notify(object, ev); } catch (std::exception &ex) { QString message = QString("
      "); message.append(ex.what()); message.append("
      "); emit UnhandledException(message); } return false; } } //end of namespace Wrapper } //end of namespace otb OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbQtFileSelectionWidget.cxx000066400000000000000000000042501301006202600266000ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbQtFileSelectionWidget.h" #include namespace otb { namespace Wrapper { QtFileSelectionWidget ::QtFileSelectionWidget() : QWidget(), m_HLayout( NULL ), m_Input( NULL ), m_Button( NULL ), m_Checkbox( NULL ), m_IOMode( IO_MODE_INPUT ) { this->DoCreateWidget(); } QtFileSelectionWidget::~QtFileSelectionWidget() { } void QtFileSelectionWidget ::SetIOMode( IOMode mode ) { m_IOMode = mode; } QtFileSelectionWidget::IOMode QtFileSelectionWidget ::GetIOMode() const { return m_IOMode; } void QtFileSelectionWidget::DoUpdateGUI() { } void QtFileSelectionWidget::DoCreateWidget() { unsigned int sp = 2; // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(sp); m_HLayout->setContentsMargins(sp, sp, sp, sp); m_Checkbox = new QCheckBox(); m_HLayout->addWidget(m_Checkbox); m_Input = new QLineEdit; m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setFixedWidth(30); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtFileSelectionWidget ::SelectFile() { assert( m_Input!=NULL ); QString filename( m_IOMode == IO_MODE_INPUT ? GetOpenFileName( this, QString(), m_Input->text(), tr( "All files (*)" ), NULL, QFileDialog::ReadOnly ) : GetSaveFileName( this, QString(), m_Input->text(), tr( "All files (*)" ), NULL ) ); if( filename.isEmpty() ) return; m_Input->setText( filename ); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbQtLogOutput.cxx000066400000000000000000000026221301006202600246520ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include"otbQtLogOutput.h" namespace otb { /** Constructor */ QtLogOutput::QtLogOutput() { } /** Destructor */ QtLogOutput::~QtLogOutput() { } /** flush a buffer */ void QtLogOutput::Flush() { } /** Write to a buffer */ void QtLogOutput::Write(double timestamp) { std::ostringstream oss; oss<DoCreateWidget(); } QtStringSelectionWidget::~QtStringSelectionWidget() { } void QtStringSelectionWidget::DoUpdateGUI() { } void QtStringSelectionWidget::DoCreateWidget() { unsigned int sp = 2; // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(sp); m_HLayout->setContentsMargins(sp, sp, sp, sp); m_Checkbox = new QCheckBox(); m_Checkbox->setChecked(true); m_HLayout->addWidget(m_Checkbox); m_Input = new QLineEdit; m_Input->setEnabled( m_Checkbox->isChecked() ); m_HLayout->addWidget(m_Input); QObject::connect( m_Checkbox, SIGNAL( toggled( bool ) ), m_Input, SLOT( setEnabled( bool ) ) ); QObject::connect( m_Input, SIGNAL( editingFinished( ) ), this, SLOT( OnEditionFinished() ) ); this->setLayout(m_HLayout); } void QtStringSelectionWidget::OnEditionFinished() { // used to propagate m_Input (QLineEdit type) editingFinished signal emit InternalQLineEditEditionFinished(); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetChoiceParameter.cxx000066400000000000000000000054401301006202600304510ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetChoiceParameter.h" #include "otbWrapperQtWidgetParameterLabel.h" #include "otbWrapperQtWidgetParameterFactory.h" namespace otb { namespace Wrapper { QtWidgetChoiceParameter::QtWidgetChoiceParameter( ChoiceParameter* param, QtWidgetModel* m ) : QtWidgetParameterBase(param, m), m_ChoiceParam(param), m_ComboBox( ITK_NULLPTR ), m_StackWidget( ITK_NULLPTR ), m_VLayout( ITK_NULLPTR ), m_VLayoutGroup( ITK_NULLPTR ), m_WidgetList() { } QtWidgetChoiceParameter::~QtWidgetChoiceParameter() { } void QtWidgetChoiceParameter::DoUpdateGUI() { // Update the combobox value unsigned int value = m_ChoiceParam->GetValue( ); m_ComboBox->setCurrentIndex(value); // Update the choice subparameters WidgetListIteratorType it = m_WidgetList.begin(); for (it = m_WidgetList.begin(); it != m_WidgetList.end(); ++it) { (*it)->UpdateGUI(); } } void QtWidgetChoiceParameter::DoCreateWidget() { m_ComboBox = new QComboBox; m_ComboBox->setToolTip(m_ChoiceParam->GetDescription()); m_StackWidget = new QStackedWidget; for (unsigned int i = 0; i < m_ChoiceParam->GetNbChoices(); ++i) { QString key = m_ChoiceParam->GetChoiceName(i).c_str(); m_ComboBox->addItem( key, QVariant(key) ); ParameterGroup::Pointer param = m_ChoiceParam->GetChoiceParameterGroupByIndex(i); if (param.IsNotNull()) { QtWidgetParameterBase* widget = QtWidgetParameterFactory::CreateQtWidget( param, GetModel() ); m_StackWidget->addWidget(widget); m_WidgetList.push_back(widget); } } connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(SetValue(int)) ); connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), m_StackWidget, SLOT(setCurrentIndex(int)) ); connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), GetModel(), SLOT(NotifyUpdate()) ); m_VLayout = new QVBoxLayout; m_VLayout->addWidget(m_ComboBox); if (!m_WidgetList.empty()) { m_VLayout->addWidget(m_StackWidget); } m_VLayout->addStretch(); this->setLayout(m_VLayout); } void QtWidgetChoiceParameter::SetValue(int value) { m_ChoiceParam->SetValue( value ); QString key( m_ChoiceParam->GetKey() ); emit ParameterChanged(key); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetComplexInputImageParameter.cxx000066400000000000000000000060651301006202600326550ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetComplexInputImageParameter.h" #include namespace otb { namespace Wrapper { QtWidgetComplexInputImageParameter::QtWidgetComplexInputImageParameter(ComplexInputImageParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_ComplexInputImageParam(param) { } QtWidgetComplexInputImageParameter::~QtWidgetComplexInputImageParameter() { } void QtWidgetComplexInputImageParameter::DoUpdateGUI() { //update lineedit if HasUserValue flag is set(from xml) if(m_ComplexInputImageParam->HasUserValue()) { QString text( QFile::decodeName( m_ComplexInputImageParam->GetFileName().c_str() ) ); if (text != m_Input->text()) m_Input->setText(text); } } void QtWidgetComplexInputImageParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_ComplexInputImageParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetComplexInputImageParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetOpenFileName( this, QString(), m_Input->text(), tr( "Raster files (*)" ), NULL, QFileDialog::ReadOnly ) ); if( filename.isEmpty() ) return; if( !SetFileName( filename ) ) { std::ostringstream oss; oss << "Invalid filename: '" << QFile::encodeName( filename ).constData() << "'"; assert( GetModel()!=NULL ); GetModel()->SendLogWARNING( oss.str() ); return; } m_Input->setText( filename ); } bool QtWidgetComplexInputImageParameter::SetFileName(const QString& value) { bool res = false; // save value if( m_ComplexInputImageParam->SetFromFileName( QFile::encodeName( value ).constData()) == true) { res = true; // notify of value change QString key( m_ComplexInputImageParam->GetKey() ); emit ParameterChanged(key); } return res; } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetComplexOutputImageParameter.cxx000066400000000000000000000065121301006202600330530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetComplexOutputImageParameter.h" #include #include namespace otb { namespace Wrapper { QtWidgetComplexOutputImageParameter::QtWidgetComplexOutputImageParameter(ComplexOutputImageParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_OutputImageParam(param) { } QtWidgetComplexOutputImageParameter::~QtWidgetComplexOutputImageParameter() { } void QtWidgetComplexOutputImageParameter::DoUpdateGUI() { // Update the lineEdit QString text( QFile::decodeName( m_OutputImageParam->GetFileName() ) ); if (text != m_Input->text()) m_Input->setText(text); } void QtWidgetComplexOutputImageParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_OutputImageParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set the Output PixelType choice Combobox m_ComboBox = new QComboBox; m_ComboBox->setToolTip("Complex Output Pixel Type"); m_ComboBox->addItem( "cfloat"); m_ComboBox->addItem( "cdouble"); m_ComboBox->setCurrentIndex(m_OutputImageParam->GetComplexPixelType()); connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(SetPixelType(int)) ); connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_ComboBox); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select output filename..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetComplexOutputImageParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetSaveFileName( this, QString(), m_Input->text(), tr( "Raster files (*)" ), NULL ) ); if( filename.isEmpty() ) return; SetFileName( filename ); m_Input->setText( filename ); } void QtWidgetComplexOutputImageParameter::SetFileName(const QString& value) { // save value m_FileName = QFile::encodeName( value ).constData(); m_OutputImageParam->SetFileName(m_FileName); // notify of value change QString key( m_OutputImageParam->GetKey() ); emit ParameterChanged(key); } void QtWidgetComplexOutputImageParameter::SetPixelType(int pixelType) { m_OutputImageParam->SetComplexPixelType(static_cast< ComplexImagePixelType >(pixelType)); m_ComplexPixelType = pixelType; } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetDirectoryParameter.cxx000066400000000000000000000046211301006202600312230ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetDirectoryParameter.h" #include namespace otb { namespace Wrapper { QtWidgetDirectoryParameter::QtWidgetDirectoryParameter(DirectoryParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_DirectoryParam(param) { } QtWidgetDirectoryParameter::~QtWidgetDirectoryParameter() { } void QtWidgetDirectoryParameter::DoUpdateGUI() { // Update the lineEdit QString text( QFile::decodeName( m_DirectoryParam->GetValue().c_str() ) ); m_Input->setText(text); } void QtWidgetDirectoryParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_DirectoryParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select d Directory..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetDirectoryParameter ::SelectFile() { assert( m_Input!=NULL ); QString dir( GetExistingDirectory( this, QString(), m_Input->text() ) ); if( dir.isEmpty() ) return; m_Input->setText( dir ); } void QtWidgetDirectoryParameter::SetFileName(const QString& value) { // save value m_DirectoryParam->SetValue( QFile::encodeName( value ).constData() ); // notify of value change QString key( m_DirectoryParam->GetKey() ); emit ParameterChanged(key); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetEmptyParameter.cxx000066400000000000000000000024471301006202600303610ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetEmptyParameter.h" namespace otb { namespace Wrapper { QtWidgetEmptyParameter::QtWidgetEmptyParameter(EmptyParameter* emptyParam, QtWidgetModel* m) : QtWidgetParameterBase(emptyParam, m) { } QtWidgetEmptyParameter::~QtWidgetEmptyParameter() { } void QtWidgetEmptyParameter::DoUpdateGUI() { } void QtWidgetEmptyParameter::DoCreateWidget() { // Set up input text edit QHBoxLayout *hLayout = new QHBoxLayout; hLayout->setSpacing(0); hLayout->setContentsMargins(0, 0, 0, 0); //QCheckBox* checkbox = new QCheckBox; //checkbox->setToolTip(emptyParam->GetDescription()); //QString optionID(emptyParam->GetName()); //hLayout->addWidget(checkbox); hLayout->addStretch(); this->setLayout(hLayout); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetFloatParameter.cxx000066400000000000000000000051641301006202600303270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetFloatParameter.h" namespace otb { namespace Wrapper { QtWidgetFloatParameter::QtWidgetFloatParameter(FloatParameter* floatParam, QtWidgetModel* m) : QtWidgetParameterBase(floatParam, m), m_FloatParam(floatParam) { } QtWidgetFloatParameter::~QtWidgetFloatParameter() { } void QtWidgetFloatParameter::DoUpdateGUI() { // Update the valid range if updated m_QDoubleSpinBox->setRange(m_FloatParam->GetMinimumValue(), m_FloatParam->GetMaximumValue()); bool signalsBlocked2 = m_QDoubleSpinBox->blockSignals( true ); if (m_FloatParam->HasValue()) { m_QDoubleSpinBox->setValue(m_FloatParam->GetValue()); } m_QDoubleSpinBox->blockSignals( signalsBlocked2 ); QFont f = m_QDoubleSpinBox->font(); if (m_FloatParam->HasUserValue()) { f.setBold(true); } else { f.setBold(false); } m_QDoubleSpinBox->setFont(f); } void QtWidgetFloatParameter::DoCreateWidget() { m_QHBoxLayout = new QHBoxLayout; m_QHBoxLayout->setSpacing(0); m_QHBoxLayout->setContentsMargins(0, 0, 0, 0); m_QDoubleSpinBox = new QDoubleSpinBox; m_QDoubleSpinBox->setDecimals(5); m_QDoubleSpinBox->setSingleStep(0.1); m_QDoubleSpinBox->setRange(m_FloatParam->GetMinimumValue(), m_FloatParam->GetMaximumValue()); m_QDoubleSpinBox->setToolTip(m_FloatParam->GetDescription()); connect( m_QDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(SetValue(double)) ); connect( m_QDoubleSpinBox, SIGNAL(valueChanged(double)), GetModel(), SLOT(NotifyUpdate()) ); m_QHBoxLayout->addWidget(m_QDoubleSpinBox); m_QHBoxLayout->addStretch(); this->setLayout(m_QHBoxLayout); if (m_FloatParam->GetRole() == Role_Output) { m_QDoubleSpinBox->setEnabled( false ); } } void QtWidgetFloatParameter::SetValue(double value) { m_FloatParam->SetValue( static_cast(value) ); /** moved to ParameterChanged slot in QtWidgetParameterBase:: **/ /** m_FloatParam->SetUserValue(true); **/ QString key( m_FloatParam->GetKey() ); emit ParameterChanged(key); m_FloatParam->SetAutomaticValue(false); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetInputFilenameListParameter.cxx000066400000000000000000000252611301006202600326560ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetInputFilenameListParameter.h" namespace otb { namespace Wrapper { QtWidgetInputFilenameListParameter::QtWidgetInputFilenameListParameter(InputFilenameListParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_InputFilenameListParam(param) { connect(this, SIGNAL(Change()), GetModel(), SLOT(NotifyUpdate())); } QtWidgetInputFilenameListParameter::~QtWidgetInputFilenameListParameter() { } void QtWidgetInputFilenameListParameter::DoUpdateGUI() { if(!m_InputFilenameListParam) return; std::vector fileList = m_InputFilenameListParam->GetFileNameList(); for( unsigned int i = m_FileSelectionList.size(); i < fileList.size(); i++ ) { this->AddFile(); } int i = 0; std::vector::iterator it; for (it = fileList.begin(); it != fileList.end(); ++it) { m_FileSelectionList[i++]->GetInput()->setText( QFile::decodeName( it->c_str() ) ); } } void QtWidgetInputFilenameListParameter::DoCreateWidget() { m_FileSelectionList.clear(); const unsigned int sp(2); const unsigned int buttonSize(30); // Global layout QHBoxLayout * hLayout = new QHBoxLayout; hLayout->setSpacing(sp); hLayout->setContentsMargins(sp, sp, sp, sp); // Button layout QVBoxLayout * buttonLayout = new QVBoxLayout; buttonLayout->setSpacing(sp); buttonLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * addSupLayout = new QHBoxLayout; addSupLayout->setSpacing(sp); addSupLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * upDownLayout = new QHBoxLayout; upDownLayout->setSpacing(sp); upDownLayout->setContentsMargins(sp, sp, sp, sp); // Add file button QPushButton * addButton = new QPushButton; addButton->setText("+"); addButton->setFixedWidth(buttonSize); addButton->setToolTip("Add a file selector..."); connect(addButton, SIGNAL(clicked()), this, SLOT(AddFile())); addSupLayout->addWidget(addButton); // Suppress file button QPushButton * supButton = new QPushButton; supButton->setText("-"); supButton->setFixedWidth(buttonSize); supButton->setToolTip("Suppress the selected file..."); connect(supButton, SIGNAL(clicked()), this, SLOT(SuppressFile())); addSupLayout->addWidget(supButton); buttonLayout->addLayout(addSupLayout); // Up file edit QPushButton * upButton = new QPushButton; upButton->setText("Up"); upButton->setFixedWidth(buttonSize); upButton->setToolTip("Up the selected file in the list..."); connect(upButton, SIGNAL(clicked()), this, SLOT(UpFile())); upDownLayout->addWidget(upButton); // Down file edit QPushButton * downButton = new QPushButton; downButton->setText("Down"); downButton->setFixedWidth(buttonSize); downButton->setToolTip("Down the selected file in the list..."); connect(downButton, SIGNAL(clicked()), this, SLOT(DownFile())); upDownLayout->addWidget(downButton); buttonLayout->addLayout(upDownLayout); // Erase file edit QPushButton * eraseButton = new QPushButton; eraseButton->setText("Erase"); eraseButton->setFixedWidth(2*(buttonSize+sp)); eraseButton->setToolTip("Erase the selected file of the list..."); connect(eraseButton, SIGNAL(clicked()), this, SLOT(EraseFile())); buttonLayout->addWidget(eraseButton); QVBoxLayout * fileLayout = new QVBoxLayout(); fileLayout->setSpacing(0); QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); fileLayout->addWidget(fileSelection); m_InputFilenameListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateFilenameList())); m_FileSelectionList.push_back(fileSelection); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(fileLayout); QScrollArea * s = new QScrollArea(); s->setWidget(mainGroup); s->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); s->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); s->setWidgetResizable(true); hLayout->addWidget(s); hLayout->addLayout(buttonLayout); this->setLayout(hLayout); m_FileLayout = fileLayout; m_HLayout = hLayout; m_Scroll = s; } void QtWidgetInputFilenameListParameter::UpdateFilenameList() { for(unsigned int j = 0; j < m_InputFilenameListParam->GetFileList()->Size(); j++) { if(m_InputFilenameListParam->SetNthFileName(j, m_FileSelectionList[j]->GetFilename()) == false) { std::ostringstream oss; oss << "The given file " << m_FileSelectionList[j]->GetFilename() << " is not valid."; this->GetModel()->SendLogWARNING(oss.str()); m_FileSelectionList[j]->ClearFilename(); } } emit Change(); } void QtWidgetInputFilenameListParameter::UpFile() { if(m_FileSelectionList.size() < 2) return; m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(2); // Map link between old and new index in the list std::map idMap; // Init map for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { idMap[i] = i; } // If the first item is checked, uncheck it... // It won't be moved if(m_FileSelectionList[0]->IsChecked()) { m_FileSelectionList[0]->SetChecked(false); } // If other item are checked, up the index // Starts at 1 because the first item mustn't move for(unsigned int i = 1; i < m_FileSelectionList.size(); i++) { if(m_FileSelectionList[i]->IsChecked()) { unsigned int tmp = idMap[i]; idMap[i] = i-1; idMap[idMap[i-1]] = tmp; } } this->UpdateFileList(idMap); this->RecreateFilenameList(); } void QtWidgetInputFilenameListParameter::DownFile() { if(m_FileSelectionList.size() < 2) return; m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); // Map link between old and new index in the list std::map idMap; // Init map for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { idMap[i] = i; } // If the last item is checked, uncheck it... // It won't be moved if(m_FileSelectionList[m_FileSelectionList.size() - 1]->IsChecked()) { m_FileSelectionList[m_FileSelectionList.size() - 1]->SetChecked(false); } // If other item are checked, up the index // Stops at size-1 because the last item mustn't move for(int i = m_FileSelectionList.size() - 2; i >= 0; i--) { if(m_FileSelectionList[i]->IsChecked()) { unsigned int tmp = idMap[i]; idMap[i] = i + 1; idMap[idMap[i + 1]] = tmp; } } this->UpdateFileList(idMap); this->RecreateFilenameList(); } void QtWidgetInputFilenameListParameter::UpdateFileList(std::map idMap) { std::vector tmpList; // Keys become values and inverse std::map idMapBis; for(unsigned int i = 0; i < idMap.size(); i++) { idMapBis[idMap[i]] = i; } // Create the new item list for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { m_FileLayout->addWidget(m_FileSelectionList[idMapBis[i]]); tmpList.push_back(m_FileSelectionList[idMapBis[i]]); } m_FileSelectionList = tmpList; QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); // notify of value change QString key(m_InputFilenameListParam->GetKey()); emit ParameterChanged(key); } void QtWidgetInputFilenameListParameter::AddFile() { m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { m_FileLayout->addWidget(m_FileSelectionList[i]); } QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); m_FileLayout->addWidget(fileSelection); m_FileSelectionList.push_back(fileSelection); m_InputFilenameListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateFilenameList())); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); emit FileSelectionWidgetAdded( fileSelection ); } void QtWidgetInputFilenameListParameter::SuppressFile() { m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); std::vector tmpList; for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { if(!m_FileSelectionList[i]->IsChecked()) { m_FileLayout->addWidget(m_FileSelectionList[i]); tmpList.push_back(m_FileSelectionList[i]); } } m_FileSelectionList = tmpList; QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); this->RecreateFilenameList(); } void QtWidgetInputFilenameListParameter::EraseFile() { m_FileSelectionList.clear(); m_FileLayout = new QVBoxLayout(); QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); m_FileLayout->addWidget(fileSelection); m_FileSelectionList.push_back(fileSelection); m_InputFilenameListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateFilenameList())); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); this->RecreateFilenameList(); } void QtWidgetInputFilenameListParameter::RecreateFilenameList() { // save value m_InputFilenameListParam->ClearValue(); if(m_FileSelectionList.size() == 0) { this->AddFile(); } else { for(unsigned int j = 0; j < m_FileSelectionList.size(); j++) { m_InputFilenameListParam->AddFromFileName(m_FileSelectionList[j]->GetFilename()); connect(m_FileSelectionList[j]->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateFilenameList())); } emit Change(); // notify of value change QString key(m_InputFilenameListParam->GetKey()); emit ParameterChanged(key); } } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetInputFilenameParameter.cxx000066400000000000000000000052111301006202600320130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetInputFilenameParameter.h" #include namespace otb { namespace Wrapper { QtWidgetInputFilenameParameter::QtWidgetInputFilenameParameter(InputFilenameParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_FilenameParam(param), m_HLayout( ITK_NULLPTR ), m_Input( ITK_NULLPTR ), m_Button( ITK_NULLPTR ) { } QtWidgetInputFilenameParameter::~QtWidgetInputFilenameParameter() { } void QtWidgetInputFilenameParameter::DoUpdateGUI() { // Update the lineEdit QString text( QFile::decodeName( m_FilenameParam->GetValue().c_str() ) ); if (text != m_Input->text()) m_Input->setText(text); } void QtWidgetInputFilenameParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_FilenameParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetInputFilenameParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetOpenFileName( this, QString(), m_Input->text(), tr( "All files (*)" ), NULL, QFileDialog::ReadOnly ) ); if( filename.isEmpty() ) return; SetFileName( filename ); m_Input->setText( filename ); } void QtWidgetInputFilenameParameter::SetFileName(const QString& value) { // save value m_FilenameParam->SetValue( QFile::encodeName( value ).constData() ); // notify of value change QString key( m_FilenameParam->GetKey() ); emit ParameterChanged(key); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetInputImageListParameter.cxx000066400000000000000000000263311301006202600321570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetInputImageListParameter.h" namespace otb { namespace Wrapper { QtWidgetInputImageListParameter::QtWidgetInputImageListParameter(InputImageListParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_InputImageListParam(param) { connect(this, SIGNAL(Change()), GetModel(), SLOT(NotifyUpdate())); } QtWidgetInputImageListParameter::~QtWidgetInputImageListParameter() { } void QtWidgetInputImageListParameter::DoUpdateGUI() { if(!m_InputImageListParam) return; //update fileSelectionList only if HasUserValue flag is set(from xml) if(m_InputImageListParam->HasUserValue()) { std::vector fileList = m_InputImageListParam->GetFileNameList(); for( unsigned int i = m_FileSelectionList.size(); i < fileList.size(); i++ ) { this->AddFile(); } unsigned int i = 0; std::vector::iterator it; for (it = fileList.begin(); it != fileList.end(); ++it) { m_FileSelectionList[i++]->GetInput()->setText( QFile::decodeName( it->c_str() ) ); } } } void QtWidgetInputImageListParameter::DoCreateWidget() { m_FileSelectionList.clear(); const unsigned int sp(2); const unsigned int buttonSize(30); // Global layout QHBoxLayout * hLayout = new QHBoxLayout; hLayout->setSpacing(sp); hLayout->setContentsMargins(sp, sp, sp, sp); // Button layout QVBoxLayout * buttonLayout = new QVBoxLayout; buttonLayout->setSpacing(sp); buttonLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * addSupLayout = new QHBoxLayout; addSupLayout->setSpacing(sp); addSupLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * upDownLayout = new QHBoxLayout; upDownLayout->setSpacing(sp); upDownLayout->setContentsMargins(sp, sp, sp, sp); // Add file button QPushButton * addButton = new QPushButton; addButton->setText("+"); addButton->setFixedWidth(buttonSize); addButton->setToolTip("Add a file selector..."); connect(addButton, SIGNAL(clicked()), this, SLOT(AddFile())); addSupLayout->addWidget(addButton); // Suppress file button QPushButton * supButton = new QPushButton; supButton->setText("-"); supButton->setFixedWidth(buttonSize); supButton->setToolTip("Suppress the selected file..."); connect(supButton, SIGNAL(clicked()), this, SLOT(SuppressFile())); addSupLayout->addWidget(supButton); buttonLayout->addLayout(addSupLayout); // Up file edit QPushButton * upButton = new QPushButton; upButton->setText("Up"); upButton->setFixedWidth(buttonSize); upButton->setToolTip("Up the selected file in the list..."); connect(upButton, SIGNAL(clicked()), this, SLOT(UpFile())); upDownLayout->addWidget(upButton); // Down file edit QPushButton * downButton = new QPushButton; downButton->setText("Down"); downButton->setFixedWidth(buttonSize); downButton->setToolTip("Down the selected file in the list..."); connect(downButton, SIGNAL(clicked()), this, SLOT(DownFile())); upDownLayout->addWidget(downButton); buttonLayout->addLayout(upDownLayout); // Erase file edit QPushButton * eraseButton = new QPushButton; eraseButton->setText("Erase"); eraseButton->setFixedWidth(2*(buttonSize+sp)); eraseButton->setToolTip("Erase the selected file of the list..."); connect(eraseButton, SIGNAL(clicked()), this, SLOT(EraseFile())); buttonLayout->addWidget(eraseButton); QVBoxLayout * fileLayout = new QVBoxLayout(); fileLayout->setSpacing(0); QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); fileLayout->addWidget(fileSelection); m_InputImageListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateImageList())); m_FileSelectionList.push_back(fileSelection); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(fileLayout); QScrollArea * s = new QScrollArea(); s->setWidget(mainGroup); s->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); s->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); s->setWidgetResizable(true); hLayout->addWidget(s); hLayout->addLayout(buttonLayout); this->setLayout(hLayout); m_FileLayout = fileLayout; m_HLayout = hLayout; m_Scroll = s; } void QtWidgetInputImageListParameter::UpdateImageList() { /* Adding a NullElement so to make the m_FileSelectionList and * m_InputImageList's ImageList are of same size. So that GetImageList().Size() * seems to be happy. */ for(unsigned int i = m_InputImageListParam->GetImageList()->Size(); i < m_FileSelectionList.size(); i++) { m_InputImageListParam->AddNullElement(); } for(unsigned int j = 0; j < m_InputImageListParam->GetImageList()->Size(); j++) { if(m_InputImageListParam->SetNthFileName(j, m_FileSelectionList[j]->GetFilename()) == false) { std::ostringstream oss; oss << "The given file " << m_FileSelectionList[j]->GetFilename() << " is not valid."; this->GetModel()->SendLogWARNING(oss.str()); } } emit Change(); // notify of value change QString key(m_InputImageListParam->GetKey()); emit ParameterChanged(key); } void QtWidgetInputImageListParameter::UpFile() { if(m_FileSelectionList.size() < 2) return; m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(2); // Map link between old and new index in the list std::map idMap; // Init map for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { idMap[i] = i; } // If the first item is checked, uncheck it... // It won't be moved if(m_FileSelectionList[0]->IsChecked()) { m_FileSelectionList[0]->SetChecked(false); } // If other item are checked, up the index // Starts at 1 because the first item mustn't move for(unsigned int i = 1; i < m_FileSelectionList.size(); i++) { if(m_FileSelectionList[i]->IsChecked()) { unsigned int tmp = idMap[i]; idMap[i] = i-1; idMap[idMap[i-1]] = tmp; } } this->UpdateFileList(idMap); this->RecreateImageList(); } void QtWidgetInputImageListParameter::DownFile() { if(m_FileSelectionList.size() < 2) return; m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); // Map link between old and new index in the list std::map idMap; // Init map for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { idMap[i] = i; } // If the last item is checked, uncheck it... // It won't be moved if(m_FileSelectionList[m_FileSelectionList.size() - 1]->IsChecked()) { m_FileSelectionList[m_FileSelectionList.size() - 1]->SetChecked(false); } // If other item are checked, up the index // Stops at size-1 because the last item mustn't move for(int i = m_FileSelectionList.size() - 2; i >= 0; i--) { if(m_FileSelectionList[i]->IsChecked()) { unsigned int tmp = idMap[i]; idMap[i] = i + 1; idMap[idMap[i + 1]] = tmp; } } this->UpdateFileList(idMap); this->RecreateImageList(); } void QtWidgetInputImageListParameter::UpdateFileList(std::map idMap) { std::vector tmpList; // Keys become values and inverse std::map idMapBis; for(unsigned int i = 0; i < idMap.size(); i++) { idMapBis[idMap[i]] = i; } // Create the new item list for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { m_FileLayout->addWidget(m_FileSelectionList[idMapBis[i]]); tmpList.push_back(m_FileSelectionList[idMapBis[i]]); } m_FileSelectionList = tmpList; QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); // notify of value change QString key(m_InputImageListParam->GetKey()); emit ParameterChanged(key); } void QtWidgetInputImageListParameter::AddFile() { m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { m_FileLayout->addWidget(m_FileSelectionList[i]); } QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); m_FileLayout->addWidget(fileSelection); m_FileSelectionList.push_back(fileSelection); /* No need of AddNullElement() here. Moved adding NullElement when updating the list */ //m_InputImageListParam->AddNullElement(); connect( fileSelection->GetInput(), SIGNAL( textChanged( const QString & ) ), this, SLOT( UpdateImageList() ) ); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); emit FileSelectionWidgetAdded( fileSelection ); } void QtWidgetInputImageListParameter::SuppressFile() { m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); std::vector tmpList; for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { if(!m_FileSelectionList[i]->IsChecked()) { m_FileLayout->addWidget(m_FileSelectionList[i]); tmpList.push_back(m_FileSelectionList[i]); } } m_FileSelectionList = tmpList; QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); this->RecreateImageList(); } void QtWidgetInputImageListParameter::EraseFile() { m_FileSelectionList.clear(); m_FileLayout = new QVBoxLayout(); QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); m_FileLayout->addWidget(fileSelection); m_FileSelectionList.push_back(fileSelection); m_InputImageListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateImageList())); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); this->RecreateImageList(); } void QtWidgetInputImageListParameter::RecreateImageList() { // save value m_InputImageListParam->ClearValue(); if(m_FileSelectionList.size() == 0) { this->AddFile(); } else { for(unsigned int j = 0; j < m_FileSelectionList.size(); j++) { m_InputImageListParam->AddFromFileName(m_FileSelectionList[j]->GetFilename()); connect(m_FileSelectionList[j]->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateImageList())); } emit Change(); // notify of value change QString key(m_InputImageListParam->GetKey()); emit ParameterChanged(key); } } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetInputImageParameter.cxx000066400000000000000000000060571301006202600313260ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetInputImageParameter.h" #include #include namespace otb { namespace Wrapper { QtWidgetInputImageParameter::QtWidgetInputImageParameter(InputImageParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_InputImageParam(param), m_HLayout( ITK_NULLPTR ), m_Input( ITK_NULLPTR ), m_Button( ITK_NULLPTR ) { } QtWidgetInputImageParameter::~QtWidgetInputImageParameter() { } void QtWidgetInputImageParameter::DoUpdateGUI() { //update lineedit if HasUserValue flag is set(from xml) if(m_InputImageParam->HasUserValue()) { QString text( QFile::decodeName( m_InputImageParam->GetFileName().c_str() ) ); if (text != m_Input->text()) m_Input->setText(text); } } void QtWidgetInputImageParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_InputImageParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetInputImageParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetOpenFileName( this, QString(), m_Input->text(), tr( "Raster files (*)" ), NULL, QFileDialog::ReadOnly ) ); if( filename.isEmpty() ) return; if( !SetFileName( filename ) ) { std::ostringstream oss; oss << "Invalid filename: '" << QFile::encodeName( filename ).constData() << "'"; assert( GetModel()!=NULL ); GetModel()->SendLogWARNING( oss.str() ); return; } m_Input->setText( filename ); } bool QtWidgetInputImageParameter::SetFileName(const QString& value) { bool res = true; // save value if( m_InputImageParam->SetFromFileName( QFile::encodeName( value ).constData() ) == true ) { // notify of value change QString key( m_InputImageParam->GetKey() ); emit ParameterChanged(key); } else res = false; return res; } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetInputProcessXMLParameter.cxx000066400000000000000000000052471301006202600323030ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetInputProcessXMLParameter.h" #include namespace otb { namespace Wrapper { QtWidgetInputProcessXMLParameter::QtWidgetInputProcessXMLParameter(InputProcessXMLParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_XMLParam(param) { } QtWidgetInputProcessXMLParameter::~QtWidgetInputProcessXMLParameter() { } void QtWidgetInputProcessXMLParameter::DoUpdateGUI() { if (m_XMLParam->HasUserValue()) { // Update the lineEdit QString text( QFile::decodeName( m_XMLParam->GetFileName() ) ); if (text != m_Input->text()) m_Input->setText(text); } } void QtWidgetInputProcessXMLParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_XMLParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetInputProcessXMLParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetOpenFileName( this, QString(), m_Input->text(), tr( "XML File (*.xml)" ), NULL, QFileDialog::ReadOnly ) ); if( filename.isEmpty() ) return; SetFileName( filename ); m_Input->setText( filename ); } void QtWidgetInputProcessXMLParameter::SetFileName(const QString& value) { // load xml file name if( m_XMLParam->SetFileName( QFile::encodeName( value ).constData() ) ) { // notify of value change QString key( m_XMLParam->GetKey() ); emit ParameterChanged(key); GetModel()->UpdateAllWidgets(); } } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetInputVectorDataListParameter.cxx000066400000000000000000000255241301006202600331740ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetInputVectorDataListParameter.h" namespace otb { namespace Wrapper { QtWidgetInputVectorDataListParameter::QtWidgetInputVectorDataListParameter(InputVectorDataListParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_InputVectorDataListParam(param) { connect(this, SIGNAL(Change()), GetModel(), SLOT(NotifyUpdate())); } QtWidgetInputVectorDataListParameter::~QtWidgetInputVectorDataListParameter() { } void QtWidgetInputVectorDataListParameter::DoUpdateGUI() { if(!m_InputVectorDataListParam) return; std::vector fileList = m_InputVectorDataListParam->GetFileNameList(); for( unsigned int i = m_FileSelectionList.size(); i < fileList.size(); i++ ) { this->AddFile(); } int i = 0; std::vector::iterator it; for (it = fileList.begin(); it != fileList.end(); ++it) { m_FileSelectionList[i++]->GetInput()->setText( QFile::decodeName( it->c_str() ) ); } } void QtWidgetInputVectorDataListParameter::DoCreateWidget() { m_FileSelectionList.clear(); const unsigned int sp(2); const unsigned int buttonSize(30); // Global layout QHBoxLayout * hLayout = new QHBoxLayout; hLayout->setSpacing(sp); hLayout->setContentsMargins(sp, sp, sp, sp); // Button layout QVBoxLayout * buttonLayout = new QVBoxLayout; buttonLayout->setSpacing(sp); buttonLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * addSupLayout = new QHBoxLayout; addSupLayout->setSpacing(sp); addSupLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * upDownLayout = new QHBoxLayout; upDownLayout->setSpacing(sp); upDownLayout->setContentsMargins(sp, sp, sp, sp); // Add file button QPushButton * addButton = new QPushButton; addButton->setText("+"); addButton->setFixedWidth(buttonSize); addButton->setToolTip("Add a file selector..."); connect(addButton, SIGNAL(clicked()), this, SLOT(AddFile())); addSupLayout->addWidget(addButton); // Suppress file button QPushButton * supButton = new QPushButton; supButton->setText("-"); supButton->setFixedWidth(buttonSize); supButton->setToolTip("Suppress the selected file..."); connect(supButton, SIGNAL(clicked()), this, SLOT(SuppressFile())); addSupLayout->addWidget(supButton); buttonLayout->addLayout(addSupLayout); // Up file edit QPushButton * upButton = new QPushButton; upButton->setText("Up"); upButton->setFixedWidth(buttonSize); upButton->setToolTip("Up the selected file in the list..."); connect(upButton, SIGNAL(clicked()), this, SLOT(UpFile())); upDownLayout->addWidget(upButton); // Down file edit QPushButton * downButton = new QPushButton; downButton->setText("Down"); downButton->setFixedWidth(buttonSize); downButton->setToolTip("Down the selected file in the list..."); connect(downButton, SIGNAL(clicked()), this, SLOT(DownFile())); upDownLayout->addWidget(downButton); buttonLayout->addLayout(upDownLayout); // Erase file edit QPushButton * eraseButton = new QPushButton; eraseButton->setText("Erase"); eraseButton->setFixedWidth(2*(buttonSize+sp)); eraseButton->setToolTip("Erase the selected file of the list..."); connect(eraseButton, SIGNAL(clicked()), this, SLOT(EraseFile())); buttonLayout->addWidget(eraseButton); QVBoxLayout * fileLayout = new QVBoxLayout(); fileLayout->setSpacing(0); QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); fileLayout->addWidget(fileSelection); m_InputVectorDataListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateVectorDataList())); m_FileSelectionList.push_back(fileSelection); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(fileLayout); QScrollArea * scroll2 = new QScrollArea(); scroll2->setWidget(mainGroup); scroll2->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); scroll2->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); scroll2->setWidgetResizable(true); hLayout->addWidget(scroll2); hLayout->addLayout(buttonLayout); this->setLayout(hLayout); m_FileLayout = fileLayout; m_HLayout = hLayout; m_Scroll = scroll2; } void QtWidgetInputVectorDataListParameter::UpdateVectorDataList() { for(unsigned int j = 0; j < m_InputVectorDataListParam->GetVectorDataList()->Size(); j++) { if(m_InputVectorDataListParam->SetNthFileName(j, m_FileSelectionList[j]->GetFilename()) == false) { std::ostringstream oss; oss << "The given file " << m_FileSelectionList[j]->GetFilename() << " is not valid."; this->GetModel()->SendLogWARNING(oss.str()); } } emit Change(); } void QtWidgetInputVectorDataListParameter::UpFile() { if(m_FileSelectionList.size() < 2) return; m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(2); // Map link between old and new index in the list std::map idMap; // Init map for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { idMap[i] = i; } // If the first item is checked, uncheck it... // It won't be moved if(m_FileSelectionList[0]->IsChecked()) { m_FileSelectionList[0]->SetChecked(false); } // If other item are checked, up the index // Starts at 1 because the first item mustn't move for(unsigned int i = 1; i < m_FileSelectionList.size(); i++) { if(m_FileSelectionList[i]->IsChecked()) { unsigned int tmp = idMap[i]; idMap[i] = i-1; idMap[idMap[i-1]] = tmp; } } this->UpdateFileList(idMap); this->RecreateVectorDataList(); } void QtWidgetInputVectorDataListParameter::DownFile() { if(m_FileSelectionList.size() < 2) return; m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); // Map link between old and new index in the list std::map idMap; // Init map for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { idMap[i] = i; } // If the last item is checked, uncheck it... // It won't be moved if(m_FileSelectionList[m_FileSelectionList.size() - 1]->IsChecked()) { m_FileSelectionList[m_FileSelectionList.size() - 1]->SetChecked(false); } // If other item are checked, up the index // Stops at size-1 because the last item mustn't move for(int i = m_FileSelectionList.size() - 2; i >= 0; i--) { if(m_FileSelectionList[i]->IsChecked()) { unsigned int tmp = idMap[i]; idMap[i] = i + 1; idMap[idMap[i + 1]] = tmp; } } this->UpdateFileList(idMap); this->RecreateVectorDataList(); } void QtWidgetInputVectorDataListParameter::UpdateFileList(std::map idMap) { std::vector tmpList; // Keys become values and inverse std::map idMapBis; for(unsigned int i = 0; i < idMap.size(); i++) { idMapBis[idMap[i]] = i; } // Create the new item list for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { m_FileLayout->addWidget(m_FileSelectionList[idMapBis[i]]); tmpList.push_back(m_FileSelectionList[idMapBis[i]]); } m_FileSelectionList = tmpList; QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); // notify of value change QString key(m_InputVectorDataListParam->GetKey()); emit ParameterChanged(key); } void QtWidgetInputVectorDataListParameter::AddFile() { m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { m_FileLayout->addWidget(m_FileSelectionList[i]); } QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); m_FileLayout->addWidget(fileSelection); m_FileSelectionList.push_back(fileSelection); m_InputVectorDataListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateVectorDataList())); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); emit FileSelectionWidgetAdded( fileSelection ); } void QtWidgetInputVectorDataListParameter::SuppressFile() { m_FileLayout = new QVBoxLayout(); m_FileLayout->setSpacing(0); std::vector tmpList; for(unsigned int i = 0; i < m_FileSelectionList.size(); i++) { if(!m_FileSelectionList[i]->IsChecked()) { m_FileLayout->addWidget(m_FileSelectionList[i]); tmpList.push_back(m_FileSelectionList[i]); } } m_FileSelectionList = tmpList; QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); this->RecreateVectorDataList(); } void QtWidgetInputVectorDataListParameter::EraseFile() { m_FileSelectionList.clear(); m_FileLayout = new QVBoxLayout(); QtFileSelectionWidget * fileSelection = new QtFileSelectionWidget(); fileSelection->SetIOMode( QtFileSelectionWidget::IO_MODE_INPUT ); fileSelection->setFixedHeight(30); m_FileLayout->addWidget(fileSelection); m_FileSelectionList.push_back(fileSelection); m_InputVectorDataListParam->AddNullElement(); connect(fileSelection->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateVectorDataList())); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_FileLayout); m_Scroll->setWidget(mainGroup); this->update(); this->RecreateVectorDataList(); } void QtWidgetInputVectorDataListParameter::RecreateVectorDataList() { // save value m_InputVectorDataListParam->ClearValue(); if(m_FileSelectionList.size() == 0) { this->AddFile(); } else { for(unsigned int j = 0; j < m_FileSelectionList.size(); j++) { m_InputVectorDataListParam->AddFromFileName(m_FileSelectionList[j]->GetFilename()); connect(m_FileSelectionList[j]->GetInput(), SIGNAL(textChanged(const QString&)), this, SLOT(UpdateVectorDataList())); } emit Change(); // notify of value change QString key(m_InputVectorDataListParam->GetKey()); emit ParameterChanged(key); } } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetInputVectorDataParameter.cxx000066400000000000000000000060771301006202600323420ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetInputVectorDataParameter.h" #include namespace otb { namespace Wrapper { QtWidgetInputVectorDataParameter::QtWidgetInputVectorDataParameter(InputVectorDataParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_InputVectorDataParam(param), m_HLayout( ITK_NULLPTR ), m_Input( ITK_NULLPTR ), m_Button( ITK_NULLPTR ) { } QtWidgetInputVectorDataParameter::~QtWidgetInputVectorDataParameter() { } void QtWidgetInputVectorDataParameter::DoUpdateGUI() { //update lineedit if(m_InputVectorDataParam->HasUserValue()) { QString text( QFile::decodeName( m_InputVectorDataParam->GetFileName().c_str() ) ); if (text != m_Input->text()) m_Input->setText(text); } } void QtWidgetInputVectorDataParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_InputVectorDataParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetInputVectorDataParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetOpenFileName( this, QString(), m_Input->text(), tr( "Vector data files (*)" ), NULL, QFileDialog::ReadOnly ) ); if( filename.isEmpty() ) return; if( !SetFileName( filename ) ) { std::ostringstream oss; oss << "Invalid filename: '" << QFile::encodeName( filename ).constData() << "'"; assert( GetModel()!=NULL ); GetModel()->SendLogWARNING( oss.str() ); return; } m_Input->setText( filename ); } bool QtWidgetInputVectorDataParameter::SetFileName(const QString& value) { bool res = true; // save value if( m_InputVectorDataParam->SetFromFileName( QFile::encodeName( value ).constData() ) == true ) { // notify of value change QString key( m_InputVectorDataParam->GetKey() ); emit ParameterChanged(key); } else res = false; return res; } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetIntParameter.cxx000066400000000000000000000046121301006202600300110ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetIntParameter.h" namespace otb { namespace Wrapper { QtWidgetIntParameter::QtWidgetIntParameter(IntParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_IntParam(param) { } QtWidgetIntParameter::~QtWidgetIntParameter() { } void QtWidgetIntParameter::DoCreateWidget() { // Set up input text edit m_QHBoxLayout = new QHBoxLayout; m_QHBoxLayout->setSpacing(0); m_QHBoxLayout->setContentsMargins(0, 0, 0, 0); m_QSpinBox = new QSpinBox; m_QSpinBox->setRange(m_IntParam->GetMinimumValue(), m_IntParam->GetMaximumValue()); m_QSpinBox->setToolTip(m_IntParam->GetDescription()); connect( m_QSpinBox, SIGNAL(valueChanged(int)), this, SLOT(SetValue(int)) ); connect( m_QSpinBox, SIGNAL(valueChanged(int)), GetModel(), SLOT(NotifyUpdate()) ); m_QHBoxLayout->addWidget(m_QSpinBox); m_QHBoxLayout->addStretch(); this->setLayout(m_QHBoxLayout); if (m_IntParam->GetRole() == Role_Output) { m_QSpinBox->setEnabled( false ); } } void QtWidgetIntParameter::DoUpdateGUI() { // Update the valid range if updated m_QSpinBox->setRange(m_IntParam->GetMinimumValue(), m_IntParam->GetMaximumValue()); bool signalsBlocked2 = m_QSpinBox->blockSignals( true ); if (m_IntParam->HasValue()) { m_QSpinBox->setValue(m_IntParam->GetValue()); } m_QSpinBox->blockSignals( signalsBlocked2 ); QFont f = m_QSpinBox->font(); if (m_IntParam->HasUserValue()) { f.setBold(true); } else { f.setBold(false); } m_QSpinBox->setFont(f); } void QtWidgetIntParameter::SetValue(int value) { m_IntParam->SetValue(value); /** moved to ParameterChanged slot in QtWidgetParameterBase:: **/ /**m_IntParam->SetUserValue(true); **/ QString key( m_IntParam->GetKey() ); emit ParameterChanged(key); m_IntParam->SetAutomaticValue(false); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetListViewParameter.cxx000066400000000000000000000054011301006202600310220ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetListViewParameter.h" #include "otbWrapperQtWidgetParameterLabel.h" #include "otbWrapperQtWidgetParameterFactory.h" namespace otb { namespace Wrapper { QtWidgetListViewParameter::QtWidgetListViewParameter(ListViewParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_ListViewParam(param), m_LineHeight(20) { } QtWidgetListViewParameter::~QtWidgetListViewParameter() { } void QtWidgetListViewParameter::DoUpdateGUI() { size_t numSelected = m_ListViewParam->GetSelectedItems().size(); //Clear m_ListView add re-add choices only if no items selected. //Otherwise results in mantis #1025 if(numSelected < 1) { while(m_ListView->takeItem(0)) { m_ListView->removeItemWidget( m_ListView->takeItem(0) ); } for (unsigned int i = 0; i < m_ListViewParam->GetNbChoices(); ++i) { // Add listBox items QString key = m_ListViewParam->GetChoiceKey(i).c_str(); m_ListView->addItem( key); } } //I can't find any reason for calling m_ListView->setCurrentRow(value) in this //case because QListWidget is a MultiSelection widget. if (m_ListView->selectionMode() == QAbstractItemView::SingleSelection) { unsigned int value = m_ListViewParam->GetValue( ); m_ListView->setCurrentRow(value); } } void QtWidgetListViewParameter::DoCreateWidget() { m_ListView = new QListWidget(); m_ListView->setToolTip(m_ListViewParam->GetDescription()); m_ListView->setSelectionMode(QAbstractItemView::ExtendedSelection); connect( m_ListView, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItems()) ); m_VLayout = new QHBoxLayout; m_VLayout->setContentsMargins(0, 0, 0, 0); m_VLayout->addWidget(m_ListView); m_ListView->setMaximumSize(m_ListView->width() , 4* m_LineHeight); m_VLayout->activate(); this->setLayout(m_VLayout); } void QtWidgetListViewParameter::SelectedItems() { // Clear previous item selected m_SelectedItems.clear(); // Item changed (check if selected or not) for (int idx = 0; idx < m_ListView->count(); ++idx) { if (m_ListView->item(idx)->isSelected()) { m_SelectedItems.push_back(idx); } } m_ListViewParam->SetSelectedItems(m_SelectedItems); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetModel.cxx000066400000000000000000000074311301006202600264600ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetModel.h" namespace otb { namespace Wrapper { QtWidgetModel ::QtWidgetModel(Application* app) : m_Application(app), m_LogOutput(), m_IsRunning(false) { // Init only if not already done if(!m_Application->IsInitialized()) { m_Application->Init(); } m_LogOutput = QtLogOutput::New(); // Attach log output to the Application logger m_Application->GetLogger()->SetTimeStampFormat(itk::LoggerBase::HUMANREADABLE); m_Application->GetLogger()->AddLogOutput(m_LogOutput); } QtWidgetModel::~QtWidgetModel() { } void QtWidgetModel ::NotifyUpdate() { // Update the parameters m_Application->UpdateParameters(); emit UpdateGui(); // Notify all if (!m_IsRunning) { bool applicationStatus = m_Application->IsApplicationReady(); emit SetApplicationReady(applicationStatus); } } void QtWidgetModel ::ExecuteAndWriteOutputSlot() { // Deactivate the Execute button while processing emit SetApplicationReady(false); m_IsRunning = true; // launch the output image writing AppliThread * taskAppli = new AppliThread( m_Application ); QObject::connect( taskAppli, SIGNAL( ExceptionRaised( QString ) ), // to: this, SIGNAL( ExceptionRaised( QString ) ) ); QObject::connect( taskAppli, SIGNAL( ApplicationExecutionDone( int ) ), // to: this, SLOT( OnApplicationExecutionDone( int ) ) ); taskAppli->Execute(); // Tell the Progress Reporter to begin emit SetProgressReportBegin(); } void QtWidgetModel ::OnApplicationExecutionDone( int status ) { m_IsRunning = false; // Require GUI update. NotifyUpdate(); // For the view to activate the button "Execute" emit SetApplicationReady( true ); // For the progressReport to close the Progress widget emit SetProgressReportDone( status ); } void QtWidgetModel ::SendLogWARNING( const std::string & mes ) { m_Application->GetLogger()->Write( itk::LoggerBase::WARNING, mes ); } void QtWidgetModel ::SendLogINFO( const std::string & mes ) { m_Application->GetLogger()->Write( itk::LoggerBase::INFO, mes ); } void QtWidgetModel ::SendLogDEBUG( const std::string & mes ) { m_Application->GetLogger()->Write( itk::LoggerBase::DEBUG, mes ); } } } namespace otb { namespace Wrapper { AppliThread ::~AppliThread() { wait(); } void AppliThread ::run() { int result = -1; // // Try to execute OTB-application. try { result = m_Application->ExecuteAndWriteOutput(); } // // Catch standard exceptions. catch( std::exception& err ) { std::ostringstream message; message << "The following error occurred during OTB-application execution: " << err.what() << std::endl; m_Application->GetLogger()->Write( itk::LoggerBase::FATAL, message.str() ); // Signal exception. emit ExceptionRaised( err.what() ); } // // Catch other exceptions. catch( ... ) { m_Application->GetLogger()->Write( itk::LoggerBase::FATAL, "An unknown exception has been raised during OTB-application execution" ); // Signal exception. emit ExceptionRaised( "Exception raised by OTB-application." ); } // // Signal OTB-application has ended with result status. emit ApplicationExecutionDone( result ); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputFilenameParameter.cxx000066400000000000000000000050431301006202600322170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetOutputFilenameParameter.h" #include namespace otb { namespace Wrapper { QtWidgetOutputFilenameParameter::QtWidgetOutputFilenameParameter(OutputFilenameParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_FilenameParam(param) { } QtWidgetOutputFilenameParameter::~QtWidgetOutputFilenameParameter() { } void QtWidgetOutputFilenameParameter::DoUpdateGUI() { // Update the lineEdit QString text( QFile::decodeName( m_FilenameParam->GetValue().c_str() ) ); if (text != m_Input->text()) m_Input->setText(text); } void QtWidgetOutputFilenameParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_FilenameParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetOutputFilenameParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetSaveFileName( this, QString(), m_Input->text(), tr( "All files (*)" ), NULL ) ); if( filename.isEmpty() ) return; SetFileName( filename ); m_Input->setText( filename ); } void QtWidgetOutputFilenameParameter::SetFileName(const QString& value) { // save value m_FilenameParam->SetValue( QFile::encodeName( value ).constData() ); // notify of value change QString key( m_FilenameParam->GetKey() ); emit ParameterChanged(key); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputImageParameter.cxx000066400000000000000000000066751301006202600315350ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetOutputImageParameter.h" #include "otbWrapperTypes.h" #include namespace otb { namespace Wrapper { QtWidgetOutputImageParameter::QtWidgetOutputImageParameter(OutputImageParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_OutputImageParam(param) { } QtWidgetOutputImageParameter::~QtWidgetOutputImageParameter() { } void QtWidgetOutputImageParameter::DoUpdateGUI() { // Update the lineEdit if (m_Input->text() != m_OutputImageParam->GetFileName()) { m_Input->setText( QFile::decodeName( m_OutputImageParam->GetFileName() ) ); m_ComboBox->setCurrentIndex(m_OutputImageParam->GetPixelType()); } } void QtWidgetOutputImageParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit(); m_Input->setToolTip( m_OutputImageParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set the Output PixelType choice Combobox m_ComboBox = new QComboBox; m_ComboBox->setToolTip("Output Pixel Type"); m_ComboBox->addItem( "uint 8"); m_ComboBox->addItem( "int 16"); m_ComboBox->addItem( "uint 16"); m_ComboBox->addItem( "int 32"); m_ComboBox->addItem( "uint 32"); m_ComboBox->addItem( "float"); m_ComboBox->addItem( "double"); m_ComboBox->setCurrentIndex(m_OutputImageParam->GetPixelType()); connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(SetPixelType(int)) ); connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_ComboBox); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select output filename..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetOutputImageParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetSaveFileName( this, QString(), m_Input->text(), tr( "Raster files (*)" ), NULL ) ); if( filename.isEmpty() ) return; m_Input->setText( filename ); } void QtWidgetOutputImageParameter::SetFileName(const QString& value) { // save value m_FileName = QFile::encodeName( value ).constData(); m_OutputImageParam->SetFileName(m_FileName); // notify of value change QString key( m_OutputImageParam->GetKey() ); emit ParameterChanged(key); } void QtWidgetOutputImageParameter::SetPixelType(int pixelType) { m_OutputImageParam->SetPixelType(static_cast< ImagePixelType >(pixelType)); m_PixelType = pixelType; } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputProcessXMLParameter.cxx000066400000000000000000000050011301006202600324700ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetOutputProcessXMLParameter.h" #include namespace otb { namespace Wrapper { QtWidgetOutputProcessXMLParameter::QtWidgetOutputProcessXMLParameter(OutputProcessXMLParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_XMLParam(param) { } QtWidgetOutputProcessXMLParameter::~QtWidgetOutputProcessXMLParameter() { } void QtWidgetOutputProcessXMLParameter::DoUpdateGUI() { // Update the lineEdit QString text( QFile::decodeName( m_XMLParam->GetFileName() ) ); ; if (text != m_Input->text()) m_Input->setText(text); } void QtWidgetOutputProcessXMLParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_XMLParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); // Set up input text edit m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select file..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetOutputProcessXMLParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetSaveFileName( this, QString(), m_Input->text(), tr( "XML File (*.xml)" ), NULL ) ); if( filename.isEmpty() ) return; m_Input->setText( filename ); } void QtWidgetOutputProcessXMLParameter::SetFileName(const QString& value) { // save xml file name m_XMLParam->SetValue( QFile::encodeName( value ).constData() ); // notify of value change QString key( m_XMLParam->GetKey() ); emit ParameterChanged(key); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputVectorDataParameter.cxx000066400000000000000000000050471301006202600325370ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetOutputVectorDataParameter.h" #include "otbWrapperTypes.h" #include namespace otb { namespace Wrapper { QtWidgetOutputVectorDataParameter::QtWidgetOutputVectorDataParameter(OutputVectorDataParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_OutputVectorDataParam(param) { } QtWidgetOutputVectorDataParameter::~QtWidgetOutputVectorDataParameter() { } void QtWidgetOutputVectorDataParameter::DoUpdateGUI() { //update lineedit QString text( m_OutputVectorDataParam->GetFileName() ); if (text != m_Input->text()) m_Input->setText(text); } void QtWidgetOutputVectorDataParameter::DoCreateWidget() { m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip( m_OutputVectorDataParam->GetDescription() ); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetFileName(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); m_HLayout->addWidget(m_Input); m_Button = new QPushButton; m_Button->setText("..."); m_Button->setToolTip("Select output filename..."); m_Button->setMaximumWidth(m_Button->width()); connect( m_Button, SIGNAL(clicked()), this, SLOT(SelectFile()) ); m_HLayout->addWidget(m_Button); this->setLayout(m_HLayout); } void QtWidgetOutputVectorDataParameter ::SelectFile() { assert( m_Input!=NULL ); QString filename( GetSaveFileName( this, QString(), m_Input->text(), tr( "Vector data files (*)" ), NULL ) ); if( filename.isEmpty() ) return; m_Input->setText( filename ); } void QtWidgetOutputVectorDataParameter::SetFileName(const QString& value) { // save value m_FileName = QFile::encodeName( value ).constData(); m_OutputVectorDataParam->SetFileName(m_FileName); // notify of value change QString key( m_OutputVectorDataParam->GetKey() ); emit ParameterChanged(key); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetParameterBase.cxx000066400000000000000000000044711301006202600301340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetParameterBase.h" namespace otb { namespace Wrapper { QtWidgetParameterBase::QtWidgetParameterBase(Parameter * param, QtWidgetModel* m) : m_Model(m), m_Param(param) { } QtWidgetParameterBase::~QtWidgetParameterBase() { } void QtWidgetParameterBase::CreateWidget() { this->DoCreateWidget(); // connect the update signal to this widget connect( GetModel(), SIGNAL(UpdateGui()), this, SLOT(UpdateGUI() ) ); } void QtWidgetParameterBase::UpdateGUI() { // Update the GUI this->DoUpdateGUI(); // Emit State of the Parameter to update this parameter checkbox if (!m_Param->GetMandatory()) { bool state = m_Param->GetActive(); emit ParameterActiveStatus(state); } else { // Activate the Mandatory param and the Mandatory subparam in an // activated Group if (m_Param->GetRoot()->GetActive()) { emit ParameterActiveStatus(true); } } } void QtWidgetParameterBase::ParameterChanged(const QString& itkNotUsed(key)) { m_Param->SetUserValue(true); } QtWidgetModel* QtWidgetParameterBase::GetModel() { return m_Model; } // Slot connected to the signal emitted the checkBox relative to // current widget void QtWidgetParameterBase::SetActivationState( bool value ) { //filter out EmptyParameter if(strcmp(m_Param->GetNameOfClass(), "EmptyParameter") == 0) { //only set user value if there is a change if(value != m_Param->GetActive()) m_Param->SetUserValue(true); } this->setEnabled(value); m_Param->SetChecked(value); m_Param->SetActive(value); } // Slot connected to the signal emitted by the Reset Button void QtWidgetParameterBase::Reset( ) { m_Param->Reset(); m_Param->SetUserValue(false); m_Param->SetAutomaticValue(false); this->UpdateGUI(); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetParameterFactory.cxx000066400000000000000000000114621301006202600306670ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetParameterFactory.h" #include "otbWrapperParameter.h" #include "otbWrapperQtWidgetModel.h" #include "otbWrapperQtWidgetParameterBase.h" #include "otbWrapperQtWidgetEmptyParameter.h" #include "otbWrapperQtWidgetIntParameter.h" #include "otbWrapperQtWidgetFloatParameter.h" #include "otbWrapperQtWidgetStringParameter.h" #include "otbWrapperQtWidgetStringListParameter.h" #include "otbWrapperQtWidgetChoiceParameter.h" #include "otbWrapperQtWidgetListViewParameter.h" #include "otbWrapperQtWidgetInputImageParameter.h" #include "otbWrapperQtWidgetComplexInputImageParameter.h" #include "otbWrapperQtWidgetComplexOutputImageParameter.h" #include "otbWrapperQtWidgetInputImageListParameter.h" #include "otbWrapperQtWidgetOutputImageParameter.h" #include "otbWrapperQtWidgetOutputVectorDataParameter.h" #include "otbWrapperQtWidgetInputFilenameParameter.h" #include "otbWrapperQtWidgetInputFilenameListParameter.h" #include "otbWrapperQtWidgetOutputFilenameParameter.h" #include "otbWrapperQtWidgetDirectoryParameter.h" #include "otbWrapperQtWidgetParameterGroup.h" #include "otbWrapperQtWidgetInputVectorDataListParameter.h" #include "otbWrapperQtWidgetInputVectorDataParameter.h" #include "otbWrapperQtWidgetRAMParameter.h" #include "otbWrapperQtWidgetOutputProcessXMLParameter.h" #include "otbWrapperQtWidgetInputProcessXMLParameter.h" namespace otb { namespace Wrapper { template class QtWidgetParameterGenericFactory { public: static bool CanCreate( Parameter* param ) { return dynamic_cast(param) != ITK_NULLPTR; } static QtWidgetParameterBase* Create( Parameter* param, QtWidgetModel* model ) { QtWidgetParameterBase* widget = ITK_NULLPTR; TParameterType* specificParam = dynamic_cast(param); if (specificParam) { widget = new TQtWidget(specificParam, model); } return widget; } }; QtWidgetParameterFactory::QtWidgetParameterFactory() { } QtWidgetParameterFactory::~QtWidgetParameterFactory() { } QtWidgetParameterBase* QtWidgetParameterFactory::CreateQtWidget( Parameter* param, QtWidgetModel* model ) { QtWidgetParameterBase* widget = ITK_NULLPTR; #define CREATEWIDGET( ParameterType, WidgetType ) \ else if ( QtWidgetParameterGenericFactory::CanCreate(param) ) \ { \ widget = QtWidgetParameterGenericFactory::Create(param, model); \ } if (0) {} CREATEWIDGET(EmptyParameter, QtWidgetEmptyParameter) CREATEWIDGET(IntParameter, QtWidgetIntParameter) CREATEWIDGET(FloatParameter, QtWidgetFloatParameter) CREATEWIDGET(InputFilenameParameter, QtWidgetInputFilenameParameter) CREATEWIDGET(OutputFilenameParameter, QtWidgetOutputFilenameParameter) CREATEWIDGET(DirectoryParameter, QtWidgetDirectoryParameter) CREATEWIDGET(StringParameter, QtWidgetStringParameter) CREATEWIDGET(StringListParameter, QtWidgetStringListParameter) CREATEWIDGET(ChoiceParameter, QtWidgetChoiceParameter) CREATEWIDGET(ListViewParameter, QtWidgetListViewParameter) CREATEWIDGET(InputImageParameter, QtWidgetInputImageParameter) CREATEWIDGET(ComplexInputImageParameter, QtWidgetComplexInputImageParameter) CREATEWIDGET(ComplexOutputImageParameter, QtWidgetComplexOutputImageParameter) CREATEWIDGET(InputImageListParameter, QtWidgetInputImageListParameter) CREATEWIDGET(InputFilenameListParameter, QtWidgetInputFilenameListParameter) CREATEWIDGET(InputVectorDataListParameter, QtWidgetInputVectorDataListParameter) CREATEWIDGET(InputVectorDataParameter, QtWidgetInputVectorDataParameter) CREATEWIDGET(OutputImageParameter, QtWidgetOutputImageParameter) CREATEWIDGET(OutputVectorDataParameter, QtWidgetOutputVectorDataParameter) CREATEWIDGET(EmptyParameter, QtWidgetEmptyParameter) CREATEWIDGET(ParameterGroup, QtWidgetParameterGroup) CREATEWIDGET(RAMParameter, QtWidgetRAMParameter) CREATEWIDGET(OutputProcessXMLParameter, QtWidgetOutputProcessXMLParameter) CREATEWIDGET(InputProcessXMLParameter, QtWidgetInputProcessXMLParameter) #undef CREATEWIDGET if (widget) { widget->CreateWidget(); widget->UpdateGUI(); } return widget; } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetParameterGroup.cxx000066400000000000000000000150701301006202600303530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetParameterGroup.h" #include "otbWrapperQtWidgetChoiceParameter.h" #include "otbWrapperQtWidgetParameterLabel.h" #include "otbWrapperQtWidgetParameterFactory.h" namespace otb { namespace Wrapper { QtWidgetParameterGroup::QtWidgetParameterGroup(ParameterGroup::Pointer paramList, QtWidgetModel* m) : QtWidgetParameterBase(paramList, m), m_ParamList(paramList) { } QtWidgetParameterGroup::~QtWidgetParameterGroup() { } void QtWidgetParameterGroup::DoUpdateGUI() { WidgetListIteratorType it = m_WidgetList.begin(); for (it = m_WidgetList.begin(); it != m_WidgetList.end(); ++it) { (*it)->UpdateGUI(); } } void QtWidgetParameterGroup::DoCreateWidget() { // a GridLayout with two columns : parameter label / parameter widget QGridLayout *gridLayout = new QGridLayout; gridLayout->setSpacing(1); gridLayout->setContentsMargins(0, 0, 0, 0); unsigned int nbParams = m_ParamList->GetNumberOfParameters(); for (unsigned int i = 0; i < nbParams; ++i) { Parameter* param = m_ParamList->GetParameterByIndex(i); if (param != ITK_NULLPTR) { ParameterGroup* paramAsGroup = dynamic_cast(param); ChoiceParameter* paramAsChoice = dynamic_cast(param); OutputProcessXMLParameter* paramAsInXML = dynamic_cast(param); InputProcessXMLParameter* paramAsOutXML = dynamic_cast(param); bool paramIsXML = false; if(paramAsInXML != ITK_NULLPTR || paramAsOutXML != ITK_NULLPTR) paramIsXML = true; if (paramAsGroup == ITK_NULLPTR && paramAsChoice == ITK_NULLPTR && !paramIsXML) { // Label (col 1) QWidget* label = new QtWidgetParameterLabel( param ); gridLayout->addWidget(label, i, 1); // Parameter Widget (col 2) QtWidgetParameterBase* specificWidget = QtWidgetParameterFactory::CreateQtWidget( param, GetModel() ); gridLayout->addWidget(specificWidget, i, 2 ); // CheckBox (col 0) QCheckBox * checkBox = new QCheckBox; connect( checkBox, SIGNAL(clicked(bool)), specificWidget, SLOT(SetActivationState(bool))); connect( checkBox, SIGNAL(clicked(bool)), GetModel(), SLOT(NotifyUpdate()) ); connect( specificWidget, SIGNAL(ParameterActiveStatus(bool)), checkBox, SLOT(setChecked(bool))); connect( specificWidget, SIGNAL(ParameterActiveStatus(bool)), specificWidget, SLOT(SetActivationState(bool))); // if Mandatory make the checkbox checked and deactivated if (param->GetMandatory()) { checkBox->setCheckState(Qt::Checked); checkBox->setEnabled(false); specificWidget->setEnabled(true); } else { checkBox->setCheckState(Qt::Unchecked); checkBox->setEnabled(true); specificWidget->setEnabled(false); } gridLayout->addWidget(checkBox, i, 0); // Reset Button // Make sense only for NumericalParameter if (dynamic_cast(param) || dynamic_cast(param) || dynamic_cast(param) /*|| dynamic_cast(param)*/) { if( param->GetRole() != Role_Output ) { QPushButton* resetButton = new QPushButton; resetButton->setText("Reset"); resetButton->setToolTip("Reset the value of this parameter"); gridLayout->addWidget(resetButton, i, 3); // Slots to connect to the reset button connect( resetButton, SIGNAL(clicked()), specificWidget, SLOT(Reset()) ); connect( resetButton, SIGNAL(clicked()), GetModel(), SLOT(NotifyUpdate()) ); } } m_WidgetList.push_back(specificWidget); } else { QtWidgetParameterBase* specificWidget = QtWidgetParameterFactory::CreateQtWidget( param, GetModel() ); QVBoxLayout* vboxLayout = new QVBoxLayout; vboxLayout->addWidget(specificWidget); QGroupBox* group = new QGroupBox; group->setLayout(vboxLayout); // Make the parameter Group checkable when it is not mandatory if (!param->GetMandatory() ) { group->setCheckable(true); group->setChecked(false); // Update iteratively the children status for (unsigned int idx = 0; idx < param->GetChildrenList().size(); ++idx) { // deactivate the children tree this->ProcessChild(param->GetChildrenList()[idx], false); } } else { param->SetActive(true); } connect(group, SIGNAL(clicked(bool)), specificWidget, SLOT(SetActivationState(bool))); group->setTitle(param->GetName()); gridLayout->addWidget(group, i, 0, 1, -1); m_WidgetList.push_back(specificWidget); } } } this->setLayout(gridLayout); } // Slot connected to the signal emitted the checkBox relative to // current widget void QtWidgetParameterGroup::SetActivationState( bool value ) { // First call the superclass implementation this->QtWidgetParameterBase::SetActivationState(value); // Update the Group status this->setEnabled(value); // Update iteratively the children status for (unsigned int idx = 0; idx < m_ParamList->GetChildrenList().size(); ++idx) { this->ProcessChild(m_ParamList->GetChildrenList()[idx], value); } } // Activate iteratively the children void QtWidgetParameterGroup::ProcessChild(Parameter* currentNode, bool status) { // Activate the current node if it was checked if ( currentNode->IsChecked() && status) { currentNode->SetActive(status); } // If the status is false (deactivating) deactivate all the children // tree if (!status) { currentNode->SetActive(status); } unsigned int counter = 0; while(counter < currentNode->GetChildrenList().size()) { this->ProcessChild(currentNode->GetChildrenList()[counter], status); ++counter; } } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetParameterLabel.cxx000066400000000000000000000021101301006202600302650ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetParameterLabel.h" namespace otb { namespace Wrapper { QtWidgetParameterLabel::QtWidgetParameterLabel(Parameter* param) { // Set up label QLabel *label = new QLabel; label->setText(param->GetName()); label->setToolTip(param->GetName()); QVBoxLayout *labelLayout = new QVBoxLayout; labelLayout->setSpacing(0); labelLayout->setContentsMargins(0, 0, 0, 0); labelLayout->addWidget(label, 0); this->setLayout(labelLayout); } QtWidgetParameterLabel::~QtWidgetParameterLabel() { } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetProgressReport.cxx000066400000000000000000000060401301006202600304130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetProgressReport.h" #include "otbWrapperOutputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperAddProcessToWatchEvent.h" namespace otb { namespace Wrapper { QtWidgetProgressReport::QtWidgetProgressReport(QtWidgetModel * model) : m_CurrentProcess() { m_Model = model; connect(model, SIGNAL(SetProgressReportBegin()), this, SLOT(show()) ); connect(model, SIGNAL(SetProgressReportDone()), this, SLOT(close()) ); connect(model, SIGNAL(SetProgressReportDone()), this, SLOT(RemoveLayout()) ); connect(this, SIGNAL(AddNewProcessToReport()), this, SLOT(ReportProcess()) ); m_Layout = new QVBoxLayout; this->setLayout(m_Layout); m_AddProcessCommand = AddProcessCommandType::New(); m_AddProcessCommand->SetCallbackFunction( this, &QtWidgetProgressReport::ProcessEvent ); this->show(); } QtWidgetProgressReport::~QtWidgetProgressReport() { delete m_Layout; } void QtWidgetProgressReport::SetApplication(Application::Pointer app) { m_Application = app; m_Application->AddObserver( AddProcessToWatchEvent(), m_AddProcessCommand.GetPointer() ); } void QtWidgetProgressReport::ProcessEvent( itk::Object * itkNotUsed(caller), const itk::EventObject & ev ) { if( typeid( otb::Wrapper::AddProcessToWatchEvent ) == typeid( ev ) ) { const AddProcessToWatchEvent* eventToWatch = dynamic_cast< const AddProcessToWatchEvent*> ( &ev ); if(eventToWatch) { m_CurrentProcess = eventToWatch->GetProcess(); m_CurrentDescription = eventToWatch->GetProcessDescription(); emit AddNewProcessToReport(); } } } void QtWidgetProgressReport::ReportProcess ( ) { // Build the widget containing the QtProgressBar for the current // process // Create a itk::QtProgressBar, observing the event ProgressEvent itk::QtProgressBar * bar = new itk::QtProgressBar(this); connect( bar, SIGNAL(SetValueChanged(int)), bar, SLOT(setValue(int)) ); connect( m_Model, SIGNAL(SetProgressReportDone()), bar, SLOT(reset()) ); bar->Observe(m_CurrentProcess); // label QLabel *label = new QLabel(QString(m_CurrentDescription.c_str())); // Build the layout and store the pointers m_Layout->addWidget(label); m_Layout->addWidget(bar); } void QtWidgetProgressReport::RemoveLayout() { // Remove the children of the layout (progress bar widgets) QLayoutItem *child; while ((child = this->layout()->takeAt(0)) != ITK_NULLPTR) { delete child->widget(); delete child; } } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetRAMParameter.cxx000066400000000000000000000046371301006202600277050ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetRAMParameter.h" namespace otb { namespace Wrapper { QtWidgetRAMParameter::QtWidgetRAMParameter(RAMParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_RAMParam(param) { } QtWidgetRAMParameter::~QtWidgetRAMParameter() { } void QtWidgetRAMParameter::DoCreateWidget() { // Set up input text edit m_QHBoxLayout = new QHBoxLayout; m_QHBoxLayout->setSpacing(0); m_QHBoxLayout->setContentsMargins(0, 0, 0, 0); m_QSpinBox = new QSpinBox; m_QSpinBox->setToolTip(m_RAMParam->GetDescription()); connect( m_QSpinBox, SIGNAL(valueChanged(int)), this, SLOT(SetValue(int)) ); connect( m_QSpinBox, SIGNAL(valueChanged(int)), GetModel(), SLOT(NotifyUpdate()) ); // Set a valid range // Using m_UnsignedIntParam->GetMaximum() to set the maximum range // of the SpinBox give a maximum of 0. The SpinBox max is an // integer and m_UnsignedIntParam->GetMaximum() returns an unsigned // integer which is 2 times the itk::NumericTraits::max(). // static_cast(m_UnsignedIntParam->GetMaximum()) = 0 then. m_QSpinBox->setRange(itk::NumericTraits::Zero, itk::NumericTraits::max()); m_QHBoxLayout->addWidget(m_QSpinBox); m_QHBoxLayout->addStretch(); this->setLayout(m_QHBoxLayout); } void QtWidgetRAMParameter::DoUpdateGUI() { bool blocked = m_QSpinBox->blockSignals( true ); if (m_RAMParam->HasValue()) { m_QSpinBox->setValue(static_cast(m_RAMParam->GetValue())); } m_QSpinBox->blockSignals( blocked ); QFont f = m_QSpinBox->font(); if (m_RAMParam->HasUserValue()) { f.setBold(true); } else { f.setBold(false); } m_QSpinBox->setFont(f); } void QtWidgetRAMParameter::SetValue(int value) { m_RAMParam->SetValue(static_cast(value)); m_RAMParam->SetUserValue(true); m_RAMParam->SetAutomaticValue(false); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetSimpleProgressReport.cxx000066400000000000000000000054001301006202600315640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetSimpleProgressReport.h" #include "otbWrapperOutputImageParameter.h" #include "itksys/SystemTools.hxx" #include "otbWrapperAddProcessToWatchEvent.h" namespace otb { namespace Wrapper { QtWidgetSimpleProgressReport::QtWidgetSimpleProgressReport(QtWidgetModel * model) : m_CurrentProcess() { m_Model = model; connect(model, SIGNAL(SetProgressReportBegin()), this, SLOT(show()) ); connect(model, SIGNAL(SetProgressReportDone()), this, SLOT(close()) ); connect(model, SIGNAL(SetProgressReportDone()), this, SLOT(Init()) ); connect(this, SIGNAL(AddNewProcessToReport()), this, SLOT(ReportProcess()) ); m_Layout = new QVBoxLayout; this->setLayout(m_Layout); m_AddProcessCommand = AddProcessCommandType::New(); m_AddProcessCommand->SetCallbackFunction( this, &QtWidgetSimpleProgressReport::ProcessEvent ); m_Bar = new itk::QtProgressBar(this); m_Label = new QLabel("No process"); connect( m_Bar, SIGNAL(SetValueChanged(int)), m_Bar, SLOT(setValue(int)) ); connect( m_Model, SIGNAL(SetProgressReportDone()), m_Bar, SLOT(reset()) ); m_Layout->addWidget(m_Label); m_Layout->addWidget(m_Bar); this->show(); } QtWidgetSimpleProgressReport::~QtWidgetSimpleProgressReport() { } void QtWidgetSimpleProgressReport::SetApplication(Application::Pointer app) { m_Application = app; m_Application->AddObserver( AddProcessToWatchEvent(), m_AddProcessCommand.GetPointer() ); } void QtWidgetSimpleProgressReport::ProcessEvent( itk::Object * itkNotUsed(caller), const itk::EventObject & event2 ) { if( typeid( otb::Wrapper::AddProcessToWatchEvent ) == typeid( event2 ) ) { const AddProcessToWatchEvent* eventToWatch = dynamic_cast< const AddProcessToWatchEvent*> ( &event2 ); if(eventToWatch) { m_CurrentProcess = eventToWatch->GetProcess(); m_CurrentDescription = eventToWatch->GetProcessDescription(); emit AddNewProcessToReport(); } } } void QtWidgetSimpleProgressReport::ReportProcess() { m_Bar->Observe(m_CurrentProcess); m_Label->setText(QString(m_CurrentDescription.c_str())); } void QtWidgetSimpleProgressReport::Init() { m_Bar->setValue(0); m_Label->setText("No process yet..."); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetStringListParameter.cxx000066400000000000000000000123021301006202600313540ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetStringListParameter.h" namespace otb { namespace Wrapper { QtWidgetStringListParameter::QtWidgetStringListParameter(StringListParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_StringListParam(param) { connect( this, SIGNAL(Change()), GetModel(), SLOT(NotifyUpdate()) ); } QtWidgetStringListParameter::~QtWidgetStringListParameter() { } void QtWidgetStringListParameter::DoUpdateGUI() { if(!m_StringListParam) return; std::vector strList = m_StringListParam->GetValue(); for( unsigned int i = m_LineEditList.size(); i < strList.size(); i++ ) { this->AddString(); } int i = 0; std::vector::iterator it; for (it = strList.begin(); it != strList.end(); ++it) { m_LineEditList[i++]->SetText(QString( (*it).c_str() )); } } void QtWidgetStringListParameter::DoCreateWidget() { m_LineEditList.clear(); const unsigned int sp(2); const unsigned int buttonSize(30); // Global layout QHBoxLayout * hLayout = new QHBoxLayout; hLayout->setSpacing(sp); hLayout->setContentsMargins(sp, sp, sp, sp); if( m_StringListParam->GetRole() != Role_Output ) { // Button layout QVBoxLayout * buttonLayout = new QVBoxLayout; buttonLayout->setSpacing(sp); buttonLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * addSupLayout = new QHBoxLayout; addSupLayout->setSpacing(sp); addSupLayout->setContentsMargins(sp, sp, sp, sp); QHBoxLayout * upDownLayout = new QHBoxLayout; upDownLayout->setSpacing(sp); upDownLayout->setContentsMargins(sp, sp, sp, sp); // Add file button QPushButton * addButton = new QPushButton; addButton->setText("+"); addButton->setFixedWidth(buttonSize); addButton->setToolTip("Add a string selector..."); connect( addButton, SIGNAL(clicked()), this, SLOT(AddString()) ); addSupLayout->addWidget(addButton); // Suppress file button QPushButton * supButton = new QPushButton; supButton->setText("-"); supButton->setFixedWidth(buttonSize); supButton->setToolTip("Suppress the selected string..."); connect( supButton, SIGNAL(clicked()), this, SLOT(SuppressString()) ); addSupLayout->addWidget(supButton); buttonLayout->addLayout(addSupLayout); hLayout->addLayout(buttonLayout); } QVBoxLayout * fileLayout = new QVBoxLayout(); fileLayout->setSpacing(0); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(fileLayout); QScrollArea * s = new QScrollArea(); s->setWidget(mainGroup); s->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); s->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); s->setWidgetResizable(true); hLayout->addWidget(s); this->setLayout(hLayout); m_HLayout = hLayout; m_Scroll = s; } void QtWidgetStringListParameter::UpdateStringList() { // save value std::vector updatedList; for(unsigned int j=0; jToStdString()); } m_StringListParam->SetValue(updatedList); // notify model text changed emit Change(); } void QtWidgetStringListParameter::SetString(const QString& value) { m_StringListParam->AddString(value.toAscii().constData()); m_StringListParam->SetUserValue(true); QString key( m_StringListParam->GetKey() ); emit ParameterChanged(key); } void QtWidgetStringListParameter::AddString() { m_StringLayout = new QVBoxLayout(); m_StringLayout->setSpacing(0); for(unsigned int i=0; iaddWidget( m_LineEditList[i] ); } QtStringSelectionWidget * stringInput = new QtStringSelectionWidget(); stringInput->setFixedHeight( 30 ); m_StringLayout->addWidget( stringInput ); m_LineEditList.push_back(stringInput); m_StringListParam->AddNullElement(); connect( stringInput, SIGNAL(InternalQLineEditEditionFinished()), this, SLOT(UpdateStringList())); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_StringLayout); m_Scroll->setWidget(mainGroup); this->update(); } void QtWidgetStringListParameter::SuppressString() { m_StringLayout = new QVBoxLayout(); m_StringLayout->setSpacing(0); std::vector tmpList; for(unsigned int i=0; iIsChecked() ) { m_StringLayout->addWidget( m_LineEditList[i] ); tmpList.push_back(m_LineEditList[i]); } } m_LineEditList = tmpList; QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(m_StringLayout); m_Scroll->setWidget(mainGroup); this->update(); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetStringParameter.cxx000066400000000000000000000040031301006202600305170ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetStringParameter.h" namespace otb { namespace Wrapper { QtWidgetStringParameter::QtWidgetStringParameter(StringParameter* param, QtWidgetModel* m) : QtWidgetParameterBase(param, m), m_StringParam(param) { } QtWidgetStringParameter::~QtWidgetStringParameter() { } void QtWidgetStringParameter::DoUpdateGUI() { m_Input->setToolTip(m_StringParam->GetDescription()); // Update the lineEdit only if there is a change and that's not empty or whitespaces QString text( m_StringParam->GetValue().c_str() ); if (!text.trimmed().isEmpty() && text != m_Input->text()) { m_Input->setText(text); } } void QtWidgetStringParameter::DoCreateWidget() { // Set up input text edit m_HLayout = new QHBoxLayout; m_HLayout->setSpacing(0); m_HLayout->setContentsMargins(0, 0, 0, 0); m_Input = new QLineEdit; m_Input->setToolTip(m_StringParam->GetDescription()); m_HLayout->addWidget(m_Input); connect( m_Input, SIGNAL(textChanged(const QString&)), this, SLOT(SetValue(const QString&)) ); connect( m_Input, SIGNAL(textChanged(const QString&)), GetModel(), SLOT(NotifyUpdate()) ); this->setLayout(m_HLayout); if (m_StringParam->GetRole() == Role_Output) { m_Input->setEnabled( false ); } } void QtWidgetStringParameter::SetValue(const QString& value) { m_StringParam->SetValue(value.toAscii().constData()); // notify of value change QString key( m_StringParam->GetKey() ); emit ParameterChanged(key); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetView.cxx000066400000000000000000000121731301006202600263310ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperQtWidgetView.h" #include "otbWrapperQtWidgetParameterGroup.h" #include "otbWrapperQtWidgetParameterFactory.h" #include "otbWrapperQtWidgetProgressReport.h" #include "otbWrapperOutputImageParameter.h" #include "otbWrapperChoiceParameter.h" #include "otbWrapperQtWidgetSimpleProgressReport.h" #include "otbWrapperApplicationHtmlDocGenerator.h" #include "itksys/SystemTools.hxx" namespace otb { namespace Wrapper { QtWidgetView::QtWidgetView(Application* app) { m_Model = new QtWidgetModel(app); m_Application = app; } QtWidgetView::~QtWidgetView() { } void QtWidgetView::CreateGui() { // Create a VBoxLayout with the header, the input widgets, and the footer QVBoxLayout *mainLayout = new QVBoxLayout(); m_TabWidget = new QTabWidget(); m_TabWidget->addTab(CreateInputWidgets(), "Parameters"); m_LogText = new QTextEdit(); connect( m_Model->GetLogOutput(), SIGNAL(NewContentLog(QString)), m_LogText, SLOT(append(QString) ) ); m_TabWidget->addTab(m_LogText, "Logs"); QtWidgetProgressReport* prog = new QtWidgetProgressReport(m_Model); prog->SetApplication(m_Application); m_TabWidget->addTab(prog, "Progress"); m_TabWidget->addTab(CreateDoc(), "Documentation"); mainLayout->addWidget(m_TabWidget); m_Message = new QLabel("
      Select parameters
      "); connect( m_Model, SIGNAL(SetApplicationReady(bool)), this, SLOT(UpdateMessageAfterApplicationReady(bool)) ); mainLayout->addWidget(m_Message); QtWidgetSimpleProgressReport * progressReport = new QtWidgetSimpleProgressReport(m_Model); progressReport->SetApplication(m_Application); QHBoxLayout *footLayout = new QHBoxLayout; footLayout->addWidget(progressReport); footLayout->addWidget(CreateFooter()); mainLayout->addLayout(footLayout); QGroupBox *mainGroup = new QGroupBox(); mainGroup->setLayout(mainLayout); QVBoxLayout *finalLayout = new QVBoxLayout(); finalLayout->addWidget(mainGroup); // Make the final layout to the widget this->setLayout(finalLayout); } void QtWidgetView::UpdateMessageAfterExecuteClicked() { m_Message->setText("
      Running
      "); } void QtWidgetView::UpdateMessageAfterApplicationReady( bool val ) { if(val == true) m_Message->setText("
      Ready to run
      "); else m_Message->setText("
      Select parameters
      "); } QWidget* QtWidgetView::CreateInputWidgets() { QScrollArea *scrollArea = new QScrollArea; // Put the main group inside a scroll area scrollArea->setWidget(QtWidgetParameterFactory::CreateQtWidget(m_Model->GetApplication()->GetParameterList(), m_Model)); scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded); scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); scrollArea->setWidgetResizable(true); return scrollArea; } QWidget* QtWidgetView::CreateFooter() { // an HLayout with two buttons : Execute and Quit QGroupBox *footerGroup = new QGroupBox; QHBoxLayout *footerLayout = new QHBoxLayout; footerGroup->setFixedHeight(40); footerGroup->setContentsMargins(0, 0, 0, 0); footerLayout->setContentsMargins(5, 5, 5, 5); m_ExecButton = new QPushButton(footerGroup); m_ExecButton->setDefault(true); m_ExecButton->setEnabled(false); m_ExecButton->setText(QObject::tr("Execute")); connect( m_ExecButton, SIGNAL(clicked()), m_Model, SLOT(ExecuteAndWriteOutputSlot() ) ); connect( m_Model, SIGNAL(SetApplicationReady(bool)), m_ExecButton, SLOT(setEnabled(bool)) ); connect( m_ExecButton, SIGNAL(clicked()), this, SLOT(UpdateMessageAfterExecuteClicked() ) ); m_QuitButton = new QPushButton(footerGroup); m_QuitButton->setText(QObject::tr("Quit")); connect( m_QuitButton, SIGNAL(clicked()), this, SLOT(CloseSlot()) ); // Put the buttons on the right footerLayout->addStretch(); footerLayout->addWidget(m_ExecButton); footerLayout->addWidget(m_QuitButton); footerGroup->setLayout(footerLayout); return footerGroup; } QWidget* QtWidgetView::CreateDoc() { QTextEdit *text = new QTextEdit; text->setReadOnly(true); QTextDocument * doc = new QTextDocument(); std::string docContain; ApplicationHtmlDocGenerator::GenerateDoc( m_Application, docContain); doc->setHtml(docContain.c_str()); text->setDocument(doc); return text; } void QtWidgetView::CloseSlot() { // Close the widget this->close(); // Emit a signal to close any widget that this gui belonging to emit QuitSignal(); } void QtWidgetView::UnhandledException(QString message) { m_TabWidget->setCurrentIndex(1); m_LogText->append(message); } } } OTB-release-5.8/Modules/Wrappers/QtWidget/test/000077500000000000000000000000001301006202600213405ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/QtWidget/test/CMakeLists.txt000066400000000000000000000014641301006202600241050ustar00rootroot00000000000000otb_module_test() set(OTBQtWidgetTests otbQtWidgetTestDriver.cxx otbWrapperQtWidgetShowWidget.cxx otbQtLogOutputTests.cxx otbWrapperQtWidgetParameterFactory.cxx ) add_executable(otbQtWidgetTestDriver ${OTBQtWidgetTests}) target_link_libraries(otbQtWidgetTestDriver ${OTBQtWidget-Test_LIBRARIES}) otb_module_target_label(otbQtWidgetTestDriver) # Tests Declaration otb_add_test(NAME owTvQtLogOutputNew COMMAND otbQtWidgetTestDriver otbQtLogOutputNew) otb_add_test(NAME owTvQtWidgetParameterGroup COMMAND otbQtWidgetTestDriver otbWrapperQtWidgetParameterGroup) otb_add_test(NAME owTvQtWidgetParameterFactory COMMAND otbQtWidgetTestDriver otbWrapperQtWidgetParameterFactory) otb_add_test(NAME owTvQtWidgetShow COMMAND otbQtWidgetTestDriver otbWrapperQtWidgetShowWidget ${OTB_BINARY_DIR}/lib/otb/applications) OTB-release-5.8/Modules/Wrappers/QtWidget/test/otbQtLogOutputTests.cxx000066400000000000000000000014421301006202600260640ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbQtLogOutput.h" int otbQtLogOutputNew(int /*argc*/, char* /*argv*/ []) { otb::QtLogOutput::Pointer log = otb::QtLogOutput::New(); return EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/QtWidget/test/otbQtWidgetTestDriver.cxx000066400000000000000000000003551301006202600263400ustar00rootroot00000000000000#include "otbTestMain.h" void RegisterTests() { REGISTER_TEST(otbWrapperQtWidgetShowWidget); REGISTER_TEST(otbQtLogOutputNew); REGISTER_TEST(otbWrapperQtWidgetParameterFactory); REGISTER_TEST(otbWrapperQtWidgetParameterGroup); } OTB-release-5.8/Modules/Wrappers/QtWidget/test/otbWrapperQtWidgetParameterFactory.cxx000066400000000000000000000210011301006202600310450ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if defined(_MSC_VER) #pragma warning ( disable : 4786 ) #endif #include "otbWrapperQtWidgetParameterFactory.h" #include "otbWrapperStringParameter.h" #include "otbWrapperEmptyParameter.h" #include "otbWrapperChoiceParameter.h" #include "otbWrapperQtWidgetModel.h" #include "otbWrapperQtWidgetParameterGroup.h" namespace otb { namespace WrapperTest { class ITK_EXPORT StubApplication : public otb::Wrapper::Application { public: /** Standard class typedefs. */ typedef StubApplication Self; typedef Application Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; /** Standard macro */ itkNewMacro(Self); itkTypeMacro(Self, otb::Application); protected: StubApplication() { } ~StubApplication() ITK_OVERRIDE { } void DoInit() ITK_OVERRIDE { } void DoUpdateParameters() ITK_OVERRIDE { } void DoExecute() ITK_OVERRIDE { } }; } } int otbWrapperQtWidgetParameterFactory(int argc, char* argv[]) { QApplication app(argc, argv); otb::WrapperTest::StubApplication::Pointer application = otb::WrapperTest::StubApplication::New(); otb::Wrapper::QtWidgetModel* model = new otb::Wrapper::QtWidgetModel(application); otb::Wrapper::QtWidgetParameterFactory::Pointer factory = otb::Wrapper::QtWidgetParameterFactory::New(); otb::Wrapper::IntParameter::Pointer intParam = otb::Wrapper::IntParameter::New(); otb::Wrapper::FloatParameter::Pointer floatParam = otb::Wrapper::FloatParameter::New(); otb::Wrapper::EmptyParameter::Pointer emptyParam = otb::Wrapper::EmptyParameter::New(); otb::Wrapper::ChoiceParameter::Pointer choiceParam = otb::Wrapper::ChoiceParameter::New(); intParam->SetName("Int parameter"); intParam->SetDescription("This is an int parameter"); intParam->SetKey("int"); intParam->SetDefaultValue(10); intParam->SetValue(5); intParam->SetMinimumValue(-10); intParam->SetMaximumValue(10); floatParam->SetName("Float parameter"); floatParam->SetDescription("This is an float parameter"); floatParam->SetKey("float"); floatParam->SetDefaultValue(0.567); floatParam->SetValue(0.21); floatParam->SetMinimumValue(-3.75); floatParam->SetMaximumValue(4.97); emptyParam->SetName("Empty parameter"); emptyParam->SetDescription("This is an empty parameter"); emptyParam->SetKey("empty"); choiceParam->SetName("Choice parameter"); choiceParam->SetDescription("This is a choice parameter"); choiceParam->SetKey("choice"); choiceParam->AddChoice("choice1", "Choice 1"); choiceParam->AddChoice("choice2", "Choice 2"); choiceParam->AddChoice("choice3", "Choice 3"); QWidget * intWidget = factory->CreateQtWidget(intParam, model); QWidget * floatWidget = factory->CreateQtWidget(floatParam, model); QWidget * emptyWidget = factory->CreateQtWidget(emptyParam, model); QWidget * choiceWidget = factory->CreateQtWidget(choiceParam, model); if(intWidget) { intWidget->show(); floatWidget->show(); emptyWidget->show(); choiceWidget->show(); //return app.exec(); return EXIT_SUCCESS; } return EXIT_FAILURE; } int otbWrapperQtWidgetParameterGroup(int argc, char* argv[]) { QApplication app(argc, argv); otb::WrapperTest::StubApplication::Pointer application = otb::WrapperTest::StubApplication::New(); otb::Wrapper::QtWidgetModel* model = new otb::Wrapper::QtWidgetModel(application); otb::Wrapper::QtWidgetParameterFactory::Pointer factory = otb::Wrapper::QtWidgetParameterFactory::New(); otb::Wrapper::IntParameter::Pointer intParam = otb::Wrapper::IntParameter::New(); otb::Wrapper::FloatParameter::Pointer floatParam = otb::Wrapper::FloatParameter::New(); otb::Wrapper::EmptyParameter::Pointer emptyParam = otb::Wrapper::EmptyParameter::New(); otb::Wrapper::ChoiceParameter::Pointer choiceParam = otb::Wrapper::ChoiceParameter::New(); otb::Wrapper::StringParameter::Pointer stringParam = otb::Wrapper::StringParameter::New(); intParam->SetName("Int parameter"); intParam->SetDescription("This is an int parameter"); intParam->SetKey("int"); intParam->SetDefaultValue(10); intParam->SetValue(5); intParam->SetMinimumValue(-10); intParam->SetMaximumValue(10); floatParam->SetName("Float parameter"); floatParam->SetDescription("This is an float parameter"); floatParam->SetKey("float"); floatParam->SetDefaultValue(0.567); floatParam->SetValue(0.21); floatParam->SetMinimumValue(-3.75); floatParam->SetMaximumValue(4.97); emptyParam->SetName("Empty parameter"); emptyParam->SetDescription("This is an empty parameter"); emptyParam->SetKey("empty"); choiceParam->SetName("Choice parameter"); choiceParam->SetDescription("This is an choice parameter"); choiceParam->SetKey("choice"); choiceParam->AddChoice("choice1", "Choice 1"); choiceParam->AddChoice("choice2", "Choice 2"); choiceParam->AddChoice("choice3", "Choice 3"); stringParam->SetName("String parameter"); stringParam->SetDescription("This is a string parameter"); stringParam->SetKey("string"); stringParam->SetValue("test value"); otb::Wrapper::ParameterGroup::Pointer list = otb::Wrapper::ParameterGroup::New(); list->AddParameter(otb::Wrapper::Parameter::Pointer(intParam.GetPointer())); list->AddParameter(otb::Wrapper::Parameter::Pointer(floatParam.GetPointer())); list->AddParameter(otb::Wrapper::Parameter::Pointer(emptyParam.GetPointer())); list->AddParameter(otb::Wrapper::Parameter::Pointer(choiceParam.GetPointer())); list->AddParameter(otb::Wrapper::Parameter::Pointer(stringParam.GetPointer())); otb::Wrapper::IntParameter::Pointer intParam2 = otb::Wrapper::IntParameter::New(); otb::Wrapper::FloatParameter::Pointer floatParam2 = otb::Wrapper::FloatParameter::New(); otb::Wrapper::EmptyParameter::Pointer emptyParam2 = otb::Wrapper::EmptyParameter::New(); otb::Wrapper::ChoiceParameter::Pointer choiceParam2 = otb::Wrapper::ChoiceParameter::New(); otb::Wrapper::StringParameter::Pointer stringParam2 = otb::Wrapper::StringParameter::New(); intParam2->SetName("Int parameter"); intParam2->SetDescription("This is an int parameter"); intParam2->SetKey("int2"); intParam2->SetDefaultValue(10); intParam2->SetValue(5); intParam2->SetMinimumValue(-10); intParam2->SetMaximumValue(10); floatParam2->SetName("Float parameter"); floatParam2->SetDescription("This is an float parameter"); floatParam2->SetKey("float2"); floatParam2->SetDefaultValue(0.567); floatParam2->SetValue(0.21); floatParam2->SetMinimumValue(-3.75); floatParam2->SetMaximumValue(4.97); emptyParam2->SetName("Empty parameter"); emptyParam2->SetDescription("This is an empty parameter"); emptyParam2->SetKey("empty2"); choiceParam2->SetName("Choice parameter"); choiceParam2->SetDescription("This is an choice parameter"); choiceParam2->SetKey("choice2"); choiceParam2->AddChoice("choice1", "Choice 1"); choiceParam2->AddChoice("choice2", "Choice 2"); choiceParam2->AddChoice("choice3", "Choice 3"); stringParam2->SetName("String parameter"); stringParam2->SetDescription("This is a string parameter"); stringParam2->SetKey("string2"); stringParam2->SetValue("test value"); otb::Wrapper::ParameterGroup::Pointer group2 = otb::Wrapper::ParameterGroup::New(); group2->SetName("Group parameter"); group2->SetDescription("This is a group parameter"); group2->SetKey("group2"); group2->AddParameter(otb::Wrapper::Parameter::Pointer(intParam2.GetPointer())); group2->AddParameter(otb::Wrapper::Parameter::Pointer(floatParam2.GetPointer())); group2->AddParameter(otb::Wrapper::Parameter::Pointer(emptyParam2.GetPointer())); group2->AddParameter(otb::Wrapper::Parameter::Pointer(choiceParam2.GetPointer())); group2->AddParameter(otb::Wrapper::Parameter::Pointer(stringParam2.GetPointer())); group2->AddParameter(otb::Wrapper::Parameter::Pointer(list.GetPointer())); QWidget * group = new otb::Wrapper::QtWidgetParameterGroup(group2, model); if(group) { group->show(); //return app.exec(); return EXIT_SUCCESS; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Wrappers/QtWidget/test/otbWrapperQtWidgetShowWidget.cxx000066400000000000000000000066111301006202600276730ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include #include "otbWrapperApplicationRegistry.h" #include "otbWrapperQtWidgetView.h" #include "otbWrapperQtWidgetProgressReport.h" #include "itksys/SystemTools.hxx" using otb::Wrapper::Application; using otb::Wrapper::ApplicationRegistry; using otb::Wrapper::QtWidgetView; using otb::Wrapper::QtWidgetProgressReport; int otbWrapperQtWidgetShowWidget(int argc, char* argv[]) { QApplication qtApp(argc, argv); std::cout << "Usage : " << argv[0] << " [module_path]" << std::endl; // Get the module path list std::list modulePathList; if (argc > 1) { std::copy(argv + 1, argv + argc, std::back_inserter(modulePathList)); // Load the path in the environment std::list::const_iterator it = modulePathList.begin(); while( it != modulePathList.end() ) { ApplicationRegistry::AddApplicationPath( *(it) ); ++it; } } bool result = true; // Get list of available applications std::vector list = ApplicationRegistry::GetAvailableApplications(); for (std::vector::const_iterator it = list.begin(); it != list.end(); ++it) { std::cout << "Testing QtWidget for application "<< (*it) << " ..." << std::endl; // Create module Application::Pointer app = ApplicationRegistry::CreateApplication(*it); if (app.IsNull()) { std::cerr << "Could not find application " << (*it) << std::endl; result = false; continue; } // MainWidget : that contains the view and any other widget // (progress, logs...) QMainWindow* mainWindow = new QMainWindow(); // Create GUI based on module QtWidgetView* gui = new QtWidgetView(app); gui->CreateGui(); // Connect the View "Quit" signal, to the mainWindow close slot QObject::connect(gui, SIGNAL(QuitSignal()), mainWindow, SLOT(close())); // Create a progressReport object QtWidgetProgressReport* progressReport = new QtWidgetProgressReport(gui->GetModel()); progressReport->SetApplication(app); // Create a dock widget containing the progress widget QDockWidget* qdock = new QDockWidget("Progress Reporting ...", mainWindow); qdock->setWidget(progressReport); // build the main window, central widget is the plugin view, other // are docked widget (progress, logs...) mainWindow->setCentralWidget(gui); mainWindow->addDockWidget(Qt::BottomDockWidgetArea, qdock); // Show the main window mainWindow->show(); QTimer::singleShot(1000, &qtApp, SLOT(quit())); // Start event processing loop if (qtApp.exec()) { std::cerr << "Failed to show widget for application " << (*it) << std::endl; result = false; } // clean main window if (mainWindow) delete mainWindow; } if (result) { return EXIT_SUCCESS; } return EXIT_FAILURE; } OTB-release-5.8/Modules/Wrappers/SWIG/000077500000000000000000000000001301006202600174025ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/SWIG/CMakeLists.txt000066400000000000000000000000531301006202600221400ustar00rootroot00000000000000project(OTBSWIGWrapper) otb_module_impl() OTB-release-5.8/Modules/Wrappers/SWIG/otb-module-init.cmake000066400000000000000000000020021301006202600234060ustar00rootroot00000000000000option ( OTB_WRAP_PYTHON "Wrap Python" OFF ) option ( OTB_WRAP_JAVA "Wrap Java" OFF ) if ( OTB_WRAP_PYTHON OR OTB_WRAP_JAVA ) find_package ( SWIG REQUIRED ) mark_as_advanced(SWIG_DIR) mark_as_advanced(SWIG_EXECUTABLE) mark_as_advanced(SWIG_VERSION) endif() # # SimpleITK does this check, but it does not seem necessary in our case # TODO: figure out why SimpleITK needs this... # macro(check_PIC_flag Language) if ( UNIX AND NOT APPLE ) if ( NOT ${CMAKE_CXX_FLAGS} MATCHES "-fPIC") # message ( FATAL_ERROR "${Language} wrapping requires CMAKE_CXX_FLAGS (or equivalent) to include -fPIC and ITK built with this flag" ) endif() endif() endmacro() if ( OTB_WRAP_PYTHON ) check_PIC_flag ( Python ) find_package ( PythonLibs REQUIRED ) find_package ( PythonInterp REQUIRED ) find_package ( Numpy ) endif() # # JAVA SWIG configuration # if ( OTB_WRAP_JAVA ) check_PIC_flag ( Java ) find_package ( Java REQUIRED ) find_package ( JNI REQUIRED ) mark_as_advanced( JAVA_HOME ) endif() OTB-release-5.8/Modules/Wrappers/SWIG/otb-module.cmake000066400000000000000000000002271301006202600224540ustar00rootroot00000000000000set(DOCUMENTATION "TO BE DOCUMENTED") otb_module(OTBSWIGWrapper DEPENDS OTBApplicationEngine OTBITK DESCRIPTION "${DOCUMENTATION}" ) OTB-release-5.8/Modules/Wrappers/SWIG/src/000077500000000000000000000000001301006202600201715ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/SWIG/src/CMakeLists.txt000066400000000000000000000110541301006202600227320ustar00rootroot00000000000000# # General SWIG configuration # if ( OTB_WRAP_PYTHON OR OTB_WRAP_JAVA ) include ( UseSWIGLocal ) set_source_files_properties ( otbApplication.i PROPERTIES CPLUSPLUS ON ) list(APPEND SWIG_EXTRA_DEPS otbWrapperSWIGIncludes.h itkBase.includes ${CMAKE_CURRENT_SOURCE_DIR}/itkBase.i ${CMAKE_CURRENT_SOURCE_DIR}/itkMacro.i ) include_directories ( ${CMAKE_CURRENT_SOURCE_DIR} ) endif() # # Python SWIG configuration # if ( OTB_WRAP_PYTHON ) include_directories ( ${PYTHON_INCLUDE_DIR} ) # Run swig set(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_GLOBAL_FLAGS}) if(NUMPY_FOUND) include_directories(${NUMPY_INCLUDE_DIRS}) list(APPEND CMAKE_SWIG_FLAGS "-DOTB_SWIGNUMPY=1") endif() set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}) set(SWIG_MODULE_otbApplication_EXTRA_DEPS ${CMAKE_CURRENT_SOURCE_DIR}/Python.i ${CMAKE_CURRENT_SOURCE_DIR}/PyCommand.i itkPyCommand.h OTBApplicationEngine) SWIG_add_module( otbApplication python otbApplication.i otbApplicationPYTHON_wrap.cxx itkPyCommand.cxx ) SWIG_link_libraries( otbApplication ${PYTHON_LIBRARIES} OTBApplicationEngine ) if(MSVC) set_source_files_properties( ${CMAKE_CURRENT_BINARY_DIR}/otbApplicationPYTHON_wrap.cxx COMPILE_FLAGS "/wd4005" ) else() set_source_files_properties( ${CMAKE_CURRENT_BINARY_DIR}/otbApplicationPYTHON_wrap.cxx COMPILE_FLAGS "-w" ) endif() # byte-compile the resulting python file add_custom_command( TARGET _otbApplication POST_BUILD COMMAND ${CMAKE_COMMAND} -E echo "Byte-compiling otbApplication.py" COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/CMake/PythonCompile.py otbApplication.py DEPENDS _otbApplication ) otb_module_target_label( _otbApplication ) install( TARGETS _otbApplication DESTINATION ${OTB_INSTALL_PYTHON_DIR} COMPONENT RuntimeLibraries ) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/otbApplication.py ${CMAKE_CURRENT_BINARY_DIR}/otbApplication.pyc DESTINATION ${OTB_INSTALL_PYTHON_DIR} COMPONENT RuntimeLibraries ) endif() # # JAVA SWIG configuration # if ( OTB_WRAP_JAVA ) include_directories ( ${JAVA_INCLUDE_PATH} ${JNI_INCLUDE_DIRS} ) # Make sure the nested directory structure exists set(JAVA_SOURCE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/org/otb/application) set(JAVA_BINARY_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/build) file(MAKE_DIRECTORY ${JAVA_SOURCE_DIRECTORY}) file(MAKE_DIRECTORY ${JAVA_BINARY_DIRECTORY}) # Nicely write the bridge code in org/itk/simple set(CMAKE_SWIG_OUTDIR ${JAVA_SOURCE_DIRECTORY}) set(CMAKE_SWIG_FLAGS -package "org.otb.application" ${CMAKE_SWIG_GLOBAL_FLAGS}) set(SWIG_MODULE_otbApplicationJava_EXTRA_DEPS ${CMAKE_CURRENT_SOURCE_DIR}/Java.i OTBApplicationEngine) SWIG_add_module ( otbApplicationJava java otbApplication.i otbApplicationJAVA_wrap.cxx) SWIG_link_libraries(otbApplicationJava OTBApplicationEngine ) if(MSVC) set_source_files_properties( ${CMAKE_CURRENT_BINARY_DIR}/otbApplicationJAVA_wrap.cxx COMPILE_FLAGS "/wd4005" ) else() set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/otbApplicationJAVA_wrap.cxx COMPILE_FLAGS "-w") endif() # Add target for org.otb.Application.jar add_custom_target(org_otb_Application_jar ALL DEPENDS org.otb.application.jar) otb_module_target_label( org_otb_Application_jar ) # Add custom command and target to compile the generated files and put them in a jar file # Make sure the commands depend on the output library from SWIG add_custom_command( OUTPUT org.otb.application.jar COMMENT "Creating jar file..." COMMAND ${Java_JAVAC_EXECUTABLE} -d ${JAVA_BINARY_DIRECTORY} ${JAVA_SOURCE_DIRECTORY}/*.java COMMAND ${Java_JAR_EXECUTABLE} cf ${CMAKE_CURRENT_BINARY_DIR}/org.otb.application.jar -C ${JAVA_BINARY_DIRECTORY} org DEPENDS ${SWIG_MODULE_otbApplication_REAL_NAME} otbApplicationJava OTBApplicationEngine ) # Get the location of the extension directory string(REGEX REPLACE "include" "jre/lib/ext" JAVA_EXTENSION_DIR ${JAVA_INCLUDE_PATH} ) # Add the install target # -- install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.otb.application.jar DESTINATION ${JAVA_EXTENSION_DIR}) # Prefer using OTB_INSTALL_JAVA_DIR which defaults to something that honors CMAKE_INSTALL_PREFIX # Using the system-wide Java extension dir usually require admin privileges, # and shall better be left to packagers. install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.otb.application.jar DESTINATION ${OTB_INSTALL_JAVA_DIR} COMPONENT RuntimeLibraries ) endif() OTB-release-5.8/Modules/Wrappers/SWIG/src/Java.i000066400000000000000000000101741301006202600212270ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if SWIGJAVA %ignore CreateAnother; %ignore Delete; %ignore Register; %ignore UnRegister; %ignore GetReferenceCount; %ignore SetReferenceCount; %ignore DebugOn; %ignore DebugOff; %ignore GetDebug; %ignore SetDebug; %ignore GetMTime; %ignore Modified; %ignore SetGlobalWarningDisplay; %ignore GetGlobalWarningDisplay; %ignore GlobalWarningDisplayOn; %ignore GlobalWarningDisplayOff; %ignore New; //###################################################################### // Simulating smart pointers in SWIG // This gets rid of wrapping ITK smart pointers. // TODO: always tell swig we're the owner // TODO: itk classes with no New() must be marked as abstract %define DECLARE_REF_COUNT_CLASS(itkClass) class itkClass##_Pointer { public: itkClass##_Pointer(); itkClass##_Pointer(itkClass##_Pointer const & p); itkClass##_Pointer(itkClass * p); ~itkClass##_Pointer(); itkClass * operator->() const; bool IsNotNull() const; bool IsNull() const; itkClass * GetPointer() const; private: void Register(); void UnRegister(); protected: }; /* %extend itkClass { public: itkClass() { typedef ::itk::SmartPointer Pointer; Pointer smtPtr = itkClass::New().GetPointer(); itkClass *rawPtr = dynamic_cast(smtPtr.GetPointer()); rawPtr->Register(); return rawPtr; } ~itkClass() { self->UnRegister(); } } %typemap(out) itkClass##_Pointer { itkClass* ptrRaw = $1.GetPointer(); if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } %typemap(out) itkClass##_Pointer & { itkClass* ptrRaw = (*$1).GetPointer(); if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } // Do not wrap the corresponding itkSmartPointer //%ignore itkClass##_Pointer; */ %enddef %pragma(java) jniclasscode=%{ static { System.loadLibrary ( "otbApplicationJava" ); } %} %rename(CreateApplicationInternal) Registry::CreateApplication(const std::string& name); %typemap(javacode) Registry %{ public static Application CreateApplication(String name) { Application_Pointer app = CreateApplicationInternal(name); return app.__deref__(); } %} /* This tells SWIG to treat char ** as a special case when used as a parameter in a function call */ %typemap(in) std::vector< std::string > { int i = 0; int size = jenv->GetArrayLength($input); for (i = 0; iGetObjectArrayElement($input, i); const char * c_string = jenv->GetStringUTFChars(j_string, 0); $1.push_back(c_string); jenv->ReleaseStringUTFChars(j_string, c_string); jenv->DeleteLocalRef(j_string); } } // transform std::vector< std::string > to a more standard String Array %typemap(out) std::vector< std::string > { int i; int len=$1.size(); jstring temp_string; const jclass clazz = jenv->FindClass("java/lang/String"); jresult = jenv->NewObjectArray(len, clazz, NULL); /* exception checking omitted */ for (i=0; iNewStringUTF($1[i].c_str()); jenv->SetObjectArrayElement(jresult, i, temp_string); jenv->DeleteLocalRef(temp_string); } } %typemap(jni) std::vector< std::string > "jobjectArray" %typemap(jtype) std::vector< std::string > "String[]" %typemap(jstype) std::vector< std::string > "String[]" %typemap(javain) std::vector< std::string > "$javainput" %typemap(javaout) std::vector< std::string > { return $jnicall; } #endif OTB-release-5.8/Modules/Wrappers/SWIG/src/Lua.i000066400000000000000000000051741301006202600210730ustar00rootroot00000000000000// Lua specific swig components #if SWIGLUA %ignore CreateAnother; %ignore Delete; %ignore Register; %ignore UnRegister; %ignore GetReferenceCount; %ignore SetReferenceCount; %ignore DebugOn; %ignore DebugOff; %ignore GetDebug; %ignore SetDebug; %ignore GetMTime; %ignore Modified; %ignore SetGlobalWarningDisplay; %ignore GetGlobalWarningDisplay; %ignore GlobalWarningDisplayOn; %ignore GlobalWarningDisplayOff; %ignore New; //###################################################################### // Simulating smart pointers in SWIG // This gets rid of wrapping ITK smart pointers. // TODO: always tell swig we're the owner // TODO: itk classes with no New() must be marked as abstract %define DECLARE_REF_COUNT_CLASS(itkClass) class itkClass##_Pointer { public: itkClass##_Pointer(); itkClass##_Pointer(itkClass##_Pointer const & p); itkClass##_Pointer(itkClass * p); ~itkClass##_Pointer(); itkClass * operator->() const; bool IsNotNull() const; bool IsNull() const; itkClass * GetPointer() const; bool operator<(itkClass##_Pointer const & r) const; bool operator>(itkClass##_Pointer const & r) const; bool operator<=(itkClass##_Pointer const & r) const; bool operator>=(itkClass##_Pointer const & r) const; itkClass##_Pointer & operator=(itkClass##_Pointer const & r); itkClass##_Pointer & operator=(itkClass## * r); // itkClass * Print(std::ostream & os) const; private: void Register(); void UnRegister(); protected: }; // Extend the itk classtype defined for wrapping to simulate a smart pointer in SWIG. // Also, make the ctor public to make the 'new' operator available in java %extend itkClass { public: itkClass() { typedef ::itk::SmartPointer Pointer; Pointer smtPtr = itkClass::New().GetPointer(); itkClass *rawPtr = dynamic_cast(smtPtr.GetPointer()); rawPtr->Register(); return rawPtr; }; ~itkClass() { self->UnRegister(); }; } /* %typemap(out) itkClass * { itkClass* ptrRaw = $1; if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } */ %typemap(out) itkClass##_Pointer { itkClass* ptrRaw = $1.GetPointer(); if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } %typemap(out) itkClass##_Pointer & { itkClass* ptrRaw = (*$1).GetPointer(); if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } // Do not wrap the corresponding itkSmartPointer %ignore itkClass##_Pointer; %enddef #endif OTB-release-5.8/Modules/Wrappers/SWIG/src/PyCommand.i000066400000000000000000000020721301006202600222330ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if SWIGPYTHON %{ #include "itkPyCommand.h" typedef itk::PyCommand itkPyCommand; typedef itk::PyCommand::Pointer itkPyCommand_Pointer; %} class itkPyCommand : public itkCommand { public: static itkPyCommand_Pointer New(); virtual char const * GetNameOfClass() const; void SetCommandCallable(PyObject *obj); PyObject * GetCommandCallable(); void Execute(itkObject *, const itkEventObject&); protected: itkPyCommand(); //~itkPyCommand(); }; DECLARE_REF_COUNT_CLASS( itkPyCommand ) #endif OTB-release-5.8/Modules/Wrappers/SWIG/src/Python.i000066400000000000000000000076121301006202600216320ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if SWIGPYTHON %ignore CreateAnother; %ignore Delete; %ignore Register; %ignore UnRegister; %ignore GetReferenceCount; %ignore SetReferenceCount; %ignore DebugOn; %ignore DebugOff; %ignore GetDebug; %ignore SetDebug; %ignore GetMTime; %ignore Modified; %ignore SetGlobalWarningDisplay; %ignore GetGlobalWarningDisplay; %ignore GlobalWarningDisplayOn; %ignore GlobalWarningDisplayOff; // This macro replaces the use of itk::SmartPointer. // class_name is class name without namespace qualifiers. // Reference: http://www.nabble.com/attachment/16653644/0/SwigRefCount.i %define DECLARE_REF_COUNT_CLASS(class_name) class class_name##_Pointer { public: class_name##_Pointer(); class_name##_Pointer(class_name##_Pointer const & p); class_name##_Pointer(class_name * p); ~class_name##_Pointer(); class_name * operator->() const; bool IsNotNull() const; bool IsNull() const; class_name * GetPointer() const; }; // pointers and references %typemap(out) class_name *, class_name & { // always tell SWIG_NewPointerObj we're the owner $result = SWIG_NewPointerObj((void *) $1, $1_descriptor, 1); if ($1) { $1->Register(); } } // transform smart pointers in raw pointers %typemap(out) class_name##_Pointer { // get the raw pointer from the smart pointer class_name * ptr = $1; // always tell SWIG_NewPointerObj we're the owner $result = SWIG_NewPointerObj((void *) ptr, $descriptor(class_name *), 1); // register the object, it it exists if (ptr) { ptr->Register(); } } // transform smart pointers in raw pointers %typemap(out) class_name##_Pointer & { // get the raw pointer from the smart pointer class_name * ptr = *$1; // always tell SWIG_NewPointerObj we're the owner $result = SWIG_NewPointerObj((void *) ptr, $descriptor(class_name *), 1); // register the object, it it exists if (ptr) { ptr->Register(); } } %extend class_name { public: // make "deletion" in scripting language just decrement ref. count ~class_name() { self->UnRegister(); } } %enddef %typemap(out) unsigned char &, const unsigned char &, signed char &, const signed char &, unsigned short &, const unsigned short &, signed short &, const signed short &, unsigned int &, const unsigned int &, signed int &, const signed int &, signed long &, const signed long &, unsigned long &, const unsigned long & {$result = PyInt_FromLong( *$1 );} %typemap(out) float &, const float &, double &, const double & {$result = PyFloat_FromDouble( *$1 );} // transform std::vector< std::string > to Python list of Python string %typemap(out) std::vector< std::string > { $result = PyList_New( $1.size() ); Py_ssize_t i = 0; for (std::vector< std::string >::const_iterator it = $1.begin(); it != $1.end(); ++it, ++i ) { PyList_SetItem( $result, i, PyString_FromString( it->c_str() ) ); } } // Add a ToString shortcut to all itkLightObject // This will make it easier for string conversion in target languages %extend itkLightObject { public: std::string ToString() { std::ostringstream o; self->Print(o); return o.str(); } } %extend itkLightObject { %pythoncode %{ def __str__( self ): return self.ToString() %} } #endif OTB-release-5.8/Modules/Wrappers/SWIG/src/Ruby.i000066400000000000000000000063641301006202600212750ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #if SWIGRUBY %ignore CreateAnother; %ignore Delete; %ignore Register; %ignore UnRegister; %ignore GetReferenceCount; %ignore SetReferenceCount; %ignore DebugOn; %ignore DebugOff; %ignore GetDebug; %ignore SetDebug; %ignore GetMTime; %ignore Modified; %ignore SetGlobalWarningDisplay; %ignore GetGlobalWarningDisplay; %ignore GlobalWarningDisplayOn; %ignore GlobalWarningDisplayOff; %ignore New; //###################################################################### // Simulating smart pointers in SWIG // This gets rid of wrapping ITK smart pointers. // TODO: always tell swig we're the owner // TODO: itk classes with no New() must be marked as abstract %define DECLARE_REF_COUNT_CLASS(itkClass) class itkClass##_Pointer { public: itkClass##_Pointer(); itkClass##_Pointer(itkClass##_Pointer const & p); itkClass##_Pointer(itkClass * p); ~itkClass##_Pointer(); itkClass * operator->() const; bool IsNotNull() const; bool IsNull() const; itkClass * GetPointer() const; bool operator<(itkClass##_Pointer const & r) const; bool operator>(itkClass##_Pointer const & r) const; bool operator<=(itkClass##_Pointer const & r) const; bool operator>=(itkClass##_Pointer const & r) const; itkClass##_Pointer & operator=(itkClass##_Pointer const & r); itkClass##_Pointer & operator=(itkClass## * r); // itkClass * Print(std::ostream & os) const; private: void Register(); void UnRegister(); protected: }; // Extend the itk classtype defined for wrapping to simulate a smart pointer in SWIG. // Also, make the ctor public to make the 'new' operator available in java %extend itkClass { public: itkClass() { typedef ::itk::SmartPointer Pointer; Pointer smtPtr = itkClass::New().GetPointer(); itkClass *rawPtr = dynamic_cast(smtPtr.GetPointer()); rawPtr->Register(); return rawPtr; }; ~itkClass() { self->UnRegister(); }; } /* %typemap(out) itkClass * { itkClass* ptrRaw = $1; if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } */ %typemap(out) itkClass##_Pointer { itkClass* ptrRaw = $1.GetPointer(); if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } %typemap(out) itkClass##_Pointer & { itkClass* ptrRaw = (*$1).GetPointer(); if (ptrRaw) { ptrRaw->Register(); } *(itkClass **)&$result = ptrRaw; } // Do not wrap the corresponding itkSmartPointer %ignore itkClass##_Pointer; %enddef %pragma(java) jniclasscode=%{ static { System.loadLibrary ( "otbApplicationJava" ); } %} #endif OTB-release-5.8/Modules/Wrappers/SWIG/src/itkBase.i000066400000000000000000000162351301006202600217340ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ // kindly stolen from the build files of OTB-Wrapping (Typedefs/itkBase.includes, Typedefs/wrap_ITKCommonBase.i) %include %include // Customize exception handling %exception { try { $action } catch( itk::ExceptionObject &ex ) { std::ostringstream oss; oss << "Exception thrown in otbApplication $symname: " << ex.what(); SWIG_exception( SWIG_RuntimeError, oss.str().c_str() ); } catch( const std::exception &ex ) { SWIG_exception( SWIG_RuntimeError, ex.what() ); } catch( ... ) { SWIG_exception( SWIG_UnknownError, "Unknown exception thrown in otbApplication $symname" ); } } // Some code from STL // Do not wrap if not necessary as it really slows down compilation %include %include %template(vectorstring) std::vector< std::string >; class itkIndent { public: static itkIndent * New(); void Delete(); itkIndent(int ind = 0); static char const * GetNameOfClass(); itkIndent GetNextIndent(); }; class itkLightObject { public: static itkLightObject_Pointer New(); virtual itkLightObject_Pointer CreateAnother() const; virtual void Delete(); virtual char const * GetNameOfClass() const; void Print(std::ostream & os, itkIndent indent = 0) const; static void BreakOnError(); virtual void Register() const; virtual void UnRegister() const; virtual int GetReferenceCount() const; virtual void SetReferenceCount(int arg0); protected: itkLightObject(); #if SWIGJAVA ~itkLightObject(); #endif }; DECLARE_REF_COUNT_CLASS( itkLightObject ) class itkObject : public itkLightObject { public: static itkObject_Pointer New(); virtual itkLightObject_Pointer CreateAnother() const; virtual char const * GetNameOfClass() const; virtual void DebugOn() const; virtual void DebugOff() const; bool GetDebug() const; void SetDebug(bool debugFlag) const; virtual unsigned long GetMTime() const; virtual void Modified() const; virtual void Register() const; virtual void UnRegister() const; virtual void SetReferenceCount(int arg0); static void SetGlobalWarningDisplay(bool flag); static bool GetGlobalWarningDisplay(); static void GlobalWarningDisplayOn(); static void GlobalWarningDisplayOff(); unsigned long AddObserver(itkEventObject const & event, itkCommand * arg1); itkCommand * GetCommand(unsigned long tag); void InvokeEvent(itkEventObject const & arg0); void RemoveObserver(unsigned long tag); void RemoveAllObservers(); bool HasObserver(itkEventObject const & event) const; itkMetaDataDictionary & GetMetaDataDictionary(); void SetMetaDataDictionary(itkMetaDataDictionary const & rhs); protected: itkObject(); #if SWIGJAVA ~itkObject(); #endif }; DECLARE_REF_COUNT_CLASS( itkObject ) class itkProcessObject : public itkObject { public: virtual itkLightObject_Pointer CreateAnother() const; const float& GetProgress(); protected: itkProcessObject(); #if SWIGJAVA ~itkProcessObject(); #endif }; DECLARE_REF_COUNT_CLASS( itkProcessObject ) class itkObjectFactoryBase : public itkObject { public: virtual char const * GetNameOfClass() const; static itkLightObject_Pointer CreateInstance(char const * itkclassname); static std::list< itkLightObject_Pointer > CreateAllInstance(char const * itkclassname); static void ReHash(); static void RegisterFactory(itkObjectFactoryBase * arg0); static void UnRegisterFactory(itkObjectFactoryBase * arg0); static void UnRegisterAllFactories(); static std::list< itkObjectFactoryBase* > GetRegisteredFactories(); virtual char const * GetITKSourceVersion() const = 0; virtual char const * GetDescription() const = 0; virtual std::list< std::string > GetClassOverrideNames(); virtual std::list< std::string > GetClassOverrideWithNames(); virtual std::list< std::string > GetClassOverrideDescriptions(); virtual std::list< bool > GetEnableFlags(); virtual void SetEnableFlag(bool flag, char const * className, char const * subclassName); virtual bool GetEnableFlag(char const * className, char const * subclassName); virtual void Disable(char const * className); char const * GetLibraryPath(); protected: itkObjectFactoryBase(); #if SWIGJAVA ~itkObjectFactoryBase(); #endif }; DECLARE_REF_COUNT_CLASS( itkObjectFactoryBase ) class itkMetaDataDictionary { public: virtual void Print(std::ostream & os) const; itkMetaDataDictionary(); itkMetaDataDictionary(itkMetaDataDictionary const & arg0); ~itkMetaDataDictionary(); std::vector< std::string > GetKeys() const; bool HasKey(std::string const & arg0) const; }; class itkCommand : public itkObject { public: virtual char const * GetNameOfClass() const; virtual void Execute(itkObject * caller, itkEventObject const & event) = 0; protected: itkCommand(); #if SWIGJAVA ~itkCommand(); #endif }; DECLARE_REF_COUNT_CLASS( itkCommand ) class itkEventObject { public: itkEventObject(); itkEventObject(itkEventObject const & arg0); ~itkEventObject(); virtual itkEventObject * MakeObject() const = 0; virtual void Print(std::ostream & os) const; virtual char const * GetEventName() const = 0; virtual bool CheckEvent(itkEventObject const * arg0) const = 0; }; %define DECLARE_itkEventObject_CLASS(class_name, superclass_name) class class_name : public superclass_name { public: class_name(); ~class_name(); virtual char const * GetEventName() const; virtual bool CheckEvent(itkEventObject const * e) const; virtual itkEventObject * MakeObject() const; class_name(class_name const & s); }; %enddef DECLARE_itkEventObject_CLASS(itkNoEvent, itkEventObject) DECLARE_itkEventObject_CLASS(itkAnyEvent, itkEventObject) DECLARE_itkEventObject_CLASS(itkDeleteEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkEndEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkExitEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkIterationEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkModifiedEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkPickEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkProgressEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkStartEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkStartPickEvent, itkPickEvent) DECLARE_itkEventObject_CLASS(itkUserEvent, itkAnyEvent) DECLARE_itkEventObject_CLASS(itkAbortCheckEvent, itkPickEvent) DECLARE_itkEventObject_CLASS(itkEndPickEvent, itkPickEvent) OTB-release-5.8/Modules/Wrappers/SWIG/src/itkBase.includes000066400000000000000000000043601301006202600233060ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef __itkBase_includes #define __itkBase_includes /* kindly stolen from the build files of OTB-Wrapping * (Typedefs/itkBase.includes, Typedefs/wrap_ITKCommonBase.i) */ #include "itkProcessObject.h" #include "itkObjectFactoryBase.h" #include "itkCommand.h" typedef itk::LightObject itkLightObject; typedef itk::LightObject::Pointer itkLightObject_Pointer; typedef itk::Object itkObject; typedef itk::Object::Pointer itkObject_Pointer; typedef itk::ProcessObject itkProcessObject; typedef itk::ProcessObject::Pointer itkProcessObject_Pointer; typedef itk::ObjectFactoryBase itkObjectFactoryBase; typedef itk::ObjectFactoryBase::Pointer itkObjectFactoryBase_Pointer; typedef itk::MetaDataDictionary itkMetaDataDictionary; typedef itk::Indent itkIndent; typedef itk::Command itkCommand; typedef itk::Command::Pointer itkCommand_Pointer; typedef itk::EventObject itkEventObject; typedef itk::NoEvent itkNoEvent; typedef itk::AnyEvent itkAnyEvent; typedef itk::DeleteEvent itkDeleteEvent; typedef itk::StartEvent itkStartEvent; typedef itk::EndEvent itkEndEvent; typedef itk::ProgressEvent itkProgressEvent; typedef itk::ExitEvent itkExitEvent; typedef itk::ModifiedEvent itkModifiedEvent; typedef itk::IterationEvent itkIterationEvent; typedef itk::PickEvent itkPickEvent; typedef itk::StartPickEvent itkStartPickEvent; typedef itk::EndPickEvent itkEndPickEvent; typedef itk::AbortCheckEvent itkAbortCheckEvent; typedef itk::UserEvent itkUserEvent; #endif OTB-release-5.8/Modules/Wrappers/SWIG/src/itkMacro.i000066400000000000000000000022051301006202600221130ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ %define itkSetStringMacro(name) void Set##name (const char* _arg); %enddef %define itkGetStringMacro(name) const char* Get##name () const; %enddef %define itkSetMacro(name, type) void Set##name (type _arg); %enddef %define itkGetMacro(name, type) type Get##name (); %enddef %define itkBooleanMacro(name) void name##On (); void name##Off (); %enddef %define itkSetEnumMacro(name, type) void Set##name (const type _arg); %enddef %define itkGetEnumMacro(name, type) type Get##name () const; %enddef %define itkNewMacro(name) static name##_Pointer New(void); %enddef OTB-release-5.8/Modules/Wrappers/SWIG/src/itkPyCommand.cxx000066400000000000000000000052311301006202600233150ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkPyCommand.cxx, v $ Language: C++ Date: $Date: 2006/09/06 20:58:42 $ Version: $Revision: 1.1 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "itkPyCommand.h" namespace itk { PyCommand::PyCommand() { this->obj = ITK_NULLPTR; } PyCommand::~PyCommand() { if (this->obj) { Py_DECREF(this->obj); } this->obj = ITK_NULLPTR; } void PyCommand::SetCommandCallable(PyObject *theObj) { if (theObj != this->obj) { if (this->obj) { // get rid of our reference Py_DECREF(this->obj); } // store the new object this->obj = theObj; if (this->obj) { // take out reference (so that the calling code doesn't // have to keep a binding to the callable around) Py_INCREF(this->obj); } } } PyObject * PyCommand::GetCommandCallable() { return this->obj; } void PyCommand::Execute(Object *, const EventObject&) { this->PyExecute(); } void PyCommand::Execute(const Object*, const EventObject&) { this->PyExecute(); } void PyCommand::PyExecute() { // make sure that the CommandCallable is in fact callable if (!PyCallable_Check(this->obj)) { // we throw a standard ITK exception: this makes it possible for // our standard CableSwig exception handling logic to take this // through to the invoking Python process itkExceptionMacro(<<"CommandCallable is not a callable Python object, " <<"or it has not been set."); } else { PyObject *result; result = PyEval_CallObject(this->obj, (PyObject *)ITK_NULLPTR); if (result) { Py_DECREF(result); } else { // there was a Python error. Clear the error by printing to stdout PyErr_Print(); // make sure the invoking Python code knows there was a problem // by raising an exception itkExceptionMacro(<<"There was an error executing the " <<"CommandCallable."); } } } } // namespace itk OTB-release-5.8/Modules/Wrappers/SWIG/src/itkPyCommand.h000066400000000000000000000045571301006202600227540ustar00rootroot00000000000000/*========================================================================= Program: Insight Segmentation & Registration Toolkit Module: $RCSfile: itkPyCommand.h, v $ Language: C++ Date: $Date: 2006/09/06 20:58:42 $ Version: $Revision: 1.1 $ Copyright (c) Insight Software Consortium. All rights reserved. See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef _itkPyCommand_h #define _itkPyCommand_h #include "itkCommand.h" // The python header defines _POSIX_C_SOURCE without a preceding #undef #undef _POSIX_C_SOURCE // The python header defines _XOPEN_SOURCE without a preceding #undef #undef _XOPEN_SOURCE #include namespace itk { /** \class PyCommand * \brief Command subclass that calls a Python callable object, e.g. * a Python function. * * With this class, arbitrary Python callable objects (e.g. functions) * can be associated with an instance to be used in AddObserver calls. * This is analogous to itk::TclCommand, but then a tad more flexible.; ) * * This class was contributed by Charl P. Botha * * \ingroup OTBSWIG */ class PyCommand : public Command { public: ///! Standard "Self" typedef. typedef PyCommand Self; ///! Smart pointer typedef support. typedef SmartPointer Pointer; ///! Run-time type information (and related methods). itkTypeMacro(PyCommand, Command); ///! Method for creation through the object factory. itkNewMacro(Self); /** * Assign a Python callable object to be used. You don't have to keep * a binding to the callable, PyCommand will also take out a reference * to make sure the Callable sticks around. */ void SetCommandCallable(PyObject *obj); PyObject * GetCommandCallable(); void Execute(Object *, const EventObject&); void Execute(const Object *, const EventObject&); protected: PyCommand(); ~PyCommand(); void PyExecute(); PyCommand(const Self&); // Not implemented. void operator=(const Self&); // Not implemented. private: PyObject *obj; }; } // namespace itk #endif // _itkPyCommand_h OTB-release-5.8/Modules/Wrappers/SWIG/src/numpy.i000066400000000000000000003213041301006202600215160ustar00rootroot00000000000000/* -*- C -*- (not really, but good for syntax highlighting) */ /* * Copyright (c) 2005-2015, NumPy Developers. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * * Neither the name of the NumPy Developers nor the names of any * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifdef SWIGPYTHON %{ #ifndef SWIG_FILE_WITH_INIT #define NO_IMPORT_ARRAY #endif #include "stdio.h" #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION #include %} /**********************************************************************/ %fragment("NumPy_Backward_Compatibility", "header") { %#if NPY_API_VERSION < 0x00000007 %#define NPY_ARRAY_DEFAULT NPY_DEFAULT %#define NPY_ARRAY_FARRAY NPY_FARRAY %#define NPY_FORTRANORDER NPY_FORTRAN %#endif } /**********************************************************************/ /* The following code originally appeared in * enthought/kiva/agg/src/numeric.i written by Eric Jones. It was * translated from C++ to C by John Hunter. Bill Spotz has modified * it to fix some minor bugs, upgrade from Numeric to numpy (all * versions), add some comments and functionality, and convert from * direct code insertion to SWIG fragments. */ %fragment("NumPy_Macros", "header") { /* Macros to extract array attributes. */ %#if NPY_API_VERSION < 0x00000007 %#define is_array(a) ((a) && PyArray_Check((PyArrayObject*)a)) %#define array_type(a) (int)(PyArray_TYPE((PyArrayObject*)a)) %#define array_numdims(a) (((PyArrayObject*)a)->nd) %#define array_dimensions(a) (((PyArrayObject*)a)->dimensions) %#define array_size(a,i) (((PyArrayObject*)a)->dimensions[i]) %#define array_strides(a) (((PyArrayObject*)a)->strides) %#define array_stride(a,i) (((PyArrayObject*)a)->strides[i]) %#define array_data(a) (((PyArrayObject*)a)->data) %#define array_descr(a) (((PyArrayObject*)a)->descr) %#define array_flags(a) (((PyArrayObject*)a)->flags) %#define array_enableflags(a,f) (((PyArrayObject*)a)->flags) = f %#else %#define is_array(a) ((a) && PyArray_Check(a)) %#define array_type(a) PyArray_TYPE((PyArrayObject*)a) %#define array_numdims(a) PyArray_NDIM((PyArrayObject*)a) %#define array_dimensions(a) PyArray_DIMS((PyArrayObject*)a) %#define array_strides(a) PyArray_STRIDES((PyArrayObject*)a) %#define array_stride(a,i) PyArray_STRIDE((PyArrayObject*)a,i) %#define array_size(a,i) PyArray_DIM((PyArrayObject*)a,i) %#define array_data(a) PyArray_DATA((PyArrayObject*)a) %#define array_descr(a) PyArray_DESCR((PyArrayObject*)a) %#define array_flags(a) PyArray_FLAGS((PyArrayObject*)a) %#define array_enableflags(a,f) PyArray_ENABLEFLAGS((PyArrayObject*)a,f) %#endif %#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS((PyArrayObject*)a)) %#define array_is_native(a) (PyArray_ISNOTSWAPPED((PyArrayObject*)a)) %#define array_is_fortran(a) (PyArray_ISFORTRAN((PyArrayObject*)a)) } /**********************************************************************/ %fragment("NumPy_Utilities", "header") { /* Given a PyObject, return a string describing its type. */ const char* pytype_string(PyObject* py_obj) { if (py_obj == NULL ) return "C NULL value"; if (py_obj == Py_None ) return "Python None" ; if (PyCallable_Check(py_obj)) return "callable" ; if (PyString_Check( py_obj)) return "string" ; if (PyInt_Check( py_obj)) return "int" ; if (PyFloat_Check( py_obj)) return "float" ; if (PyDict_Check( py_obj)) return "dict" ; if (PyList_Check( py_obj)) return "list" ; if (PyTuple_Check( py_obj)) return "tuple" ; %#if PY_MAJOR_VERSION < 3 if (PyFile_Check( py_obj)) return "file" ; if (PyModule_Check( py_obj)) return "module" ; if (PyInstance_Check(py_obj)) return "instance" ; %#endif return "unknown type"; } /* Given a NumPy typecode, return a string describing the type. */ const char* typecode_string(int typecode) { static const char* type_names[25] = {"bool", "byte", "unsigned byte", "short", "unsigned short", "int", "unsigned int", "long", "unsigned long", "long long", "unsigned long long", "float", "double", "long double", "complex float", "complex double", "complex long double", "object", "string", "unicode", "void", "ntypes", "notype", "char", "unknown"}; return typecode < 24 ? type_names[typecode] : type_names[24]; } /* Make sure input has correct numpy type. This now just calls PyArray_EquivTypenums(). */ int type_match(int actual_type, int desired_type) { return PyArray_EquivTypenums(actual_type, desired_type); } %#ifdef SWIGPY_USE_CAPSULE void free_cap(PyObject * cap) { void* array = (void*) PyCapsule_GetPointer(cap,SWIGPY_CAPSULE_NAME); if (array != NULL) free(array); } %#endif } /**********************************************************************/ %fragment("NumPy_Object_to_Array", "header", fragment="NumPy_Backward_Compatibility", fragment="NumPy_Macros", fragment="NumPy_Utilities") { /* Given a PyObject pointer, cast it to a PyArrayObject pointer if * legal. If not, set the python error string appropriately and * return NULL. */ PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode) { PyArrayObject* ary = NULL; if (is_array(input) && (typecode == NPY_NOTYPE || PyArray_EquivTypenums(array_type(input), typecode))) { ary = (PyArrayObject*) input; } else if is_array(input) { const char* desired_type = typecode_string(typecode); const char* actual_type = typecode_string(array_type(input)); PyErr_Format(PyExc_TypeError, "Array of type '%s' required. Array of type '%s' given", desired_type, actual_type); ary = NULL; } else { const char* desired_type = typecode_string(typecode); const char* actual_type = pytype_string(input); PyErr_Format(PyExc_TypeError, "Array of type '%s' required. A '%s' was given", desired_type, actual_type); ary = NULL; } return ary; } /* Convert the given PyObject to a NumPy array with the given * typecode. On success, return a valid PyArrayObject* with the * correct type. On failure, the python error string will be set and * the routine returns NULL. */ PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode, int* is_new_object) { PyArrayObject* ary = NULL; PyObject* py_obj; if (is_array(input) && (typecode == NPY_NOTYPE || PyArray_EquivTypenums(array_type(input),typecode))) { ary = (PyArrayObject*) input; *is_new_object = 0; } else { py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_ARRAY_DEFAULT); /* If NULL, PyArray_FromObject will have set python error value.*/ ary = (PyArrayObject*) py_obj; *is_new_object = 1; } return ary; } /* Given a PyArrayObject, check to see if it is contiguous. If so, * return the input pointer and flag it as not a new object. If it is * not contiguous, create a new PyArrayObject using the original data, * flag it as a new object and return the pointer. */ PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object, int min_dims, int max_dims) { PyArrayObject* result; if (array_is_contiguous(ary)) { result = ary; *is_new_object = 0; } else { result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary, array_type(ary), min_dims, max_dims); *is_new_object = 1; } return result; } /* Given a PyArrayObject, check to see if it is Fortran-contiguous. * If so, return the input pointer, but do not flag it as not a new * object. If it is not Fortran-contiguous, create a new * PyArrayObject using the original data, flag it as a new object * and return the pointer. */ PyArrayObject* make_fortran(PyArrayObject* ary, int* is_new_object) { PyArrayObject* result; if (array_is_fortran(ary)) { result = ary; *is_new_object = 0; } else { Py_INCREF(array_descr(ary)); result = (PyArrayObject*) PyArray_FromArray(ary, array_descr(ary), NPY_FORTRANORDER); *is_new_object = 1; } return result; } /* Convert a given PyObject to a contiguous PyArrayObject of the * specified type. If the input object is not a contiguous * PyArrayObject, a new one will be created and the new object flag * will be set. */ PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input, int typecode, int* is_new_object) { int is_new1 = 0; int is_new2 = 0; PyArrayObject* ary2; PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, &is_new1); if (ary1) { ary2 = make_contiguous(ary1, &is_new2, 0, 0); if ( is_new1 && is_new2) { Py_DECREF(ary1); } ary1 = ary2; } *is_new_object = is_new1 || is_new2; return ary1; } /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the * specified type. If the input object is not a Fortran-ordered * PyArrayObject, a new one will be created and the new object flag * will be set. */ PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input, int typecode, int* is_new_object) { int is_new1 = 0; int is_new2 = 0; PyArrayObject* ary2; PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, &is_new1); if (ary1) { ary2 = make_fortran(ary1, &is_new2); if (is_new1 && is_new2) { Py_DECREF(ary1); } ary1 = ary2; } *is_new_object = is_new1 || is_new2; return ary1; } } /* end fragment */ /**********************************************************************/ %fragment("NumPy_Array_Requirements", "header", fragment="NumPy_Backward_Compatibility", fragment="NumPy_Macros") { /* Test whether a python object is contiguous. If array is * contiguous, return 1. Otherwise, set the python error string and * return 0. */ int require_contiguous(PyArrayObject* ary) { int contiguous = 1; if (!array_is_contiguous(ary)) { PyErr_SetString(PyExc_TypeError, "Array must be contiguous. A non-contiguous array was given"); contiguous = 0; } return contiguous; } /* Require that a numpy array is not byte-swapped. If the array is * not byte-swapped, return 1. Otherwise, set the python error string * and return 0. */ int require_native(PyArrayObject* ary) { int native = 1; if (!array_is_native(ary)) { PyErr_SetString(PyExc_TypeError, "Array must have native byteorder. " "A byte-swapped array was given"); native = 0; } return native; } /* Require the given PyArrayObject to have a specified number of * dimensions. If the array has the specified number of dimensions, * return 1. Otherwise, set the python error string and return 0. */ int require_dimensions(PyArrayObject* ary, int exact_dimensions) { int success = 1; if (array_numdims(ary) != exact_dimensions) { PyErr_Format(PyExc_TypeError, "Array must have %d dimensions. Given array has %d dimensions", exact_dimensions, array_numdims(ary)); success = 0; } return success; } /* Require the given PyArrayObject to have one of a list of specified * number of dimensions. If the array has one of the specified number * of dimensions, return 1. Otherwise, set the python error string * and return 0. */ int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n) { int success = 0; int i; char dims_str[255] = ""; char s[255]; for (i = 0; i < n && !success; i++) { if (array_numdims(ary) == exact_dimensions[i]) { success = 1; } } if (!success) { for (i = 0; i < n-1; i++) { sprintf(s, "%d, ", exact_dimensions[i]); strcat(dims_str,s); } sprintf(s, " or %d", exact_dimensions[n-1]); strcat(dims_str,s); PyErr_Format(PyExc_TypeError, "Array must have %s dimensions. Given array has %d dimensions", dims_str, array_numdims(ary)); } return success; } /* Require the given PyArrayObject to have a specified shape. If the * array has the specified shape, return 1. Otherwise, set the python * error string and return 0. */ int require_size(PyArrayObject* ary, npy_intp* size, int n) { int i; int success = 1; int len; char desired_dims[255] = "["; char s[255]; char actual_dims[255] = "["; for(i=0; i < n;i++) { if (size[i] != -1 && size[i] != array_size(ary,i)) { success = 0; } } if (!success) { for (i = 0; i < n; i++) { if (size[i] == -1) { sprintf(s, "*,"); } else { sprintf(s, "%ld,", (long int)size[i]); } strcat(desired_dims,s); } len = strlen(desired_dims); desired_dims[len-1] = ']'; for (i = 0; i < n; i++) { sprintf(s, "%ld,", (long int)array_size(ary,i)); strcat(actual_dims,s); } len = strlen(actual_dims); actual_dims[len-1] = ']'; PyErr_Format(PyExc_TypeError, "Array must have shape of %s. Given array has shape of %s", desired_dims, actual_dims); } return success; } /* Require the given PyArrayObject to to be Fortran ordered. If the * the PyArrayObject is already Fortran ordered, do nothing. Else, * set the Fortran ordering flag and recompute the strides. */ int require_fortran(PyArrayObject* ary) { int success = 1; int nd = array_numdims(ary); int i; npy_intp * strides = array_strides(ary); if (array_is_fortran(ary)) return success; /* Set the Fortran ordered flag */ array_enableflags(ary,NPY_ARRAY_FARRAY); /* Recompute the strides */ strides[0] = strides[nd-1]; for (i=1; i < nd; ++i) strides[i] = strides[i-1] * array_size(ary,i-1); return success; } } /* Combine all NumPy fragments into one for convenience */ %fragment("NumPy_Fragments", "header", fragment="NumPy_Backward_Compatibility", fragment="NumPy_Macros", fragment="NumPy_Utilities", fragment="NumPy_Object_to_Array", fragment="NumPy_Array_Requirements") { } /* End John Hunter translation (with modifications by Bill Spotz) */ /* %numpy_typemaps() macro * * This macro defines a family of 74 typemaps that allow C arguments * of the form * * 1. (DATA_TYPE IN_ARRAY1[ANY]) * 2. (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) * 3. (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) * * 4. (DATA_TYPE IN_ARRAY2[ANY][ANY]) * 5. (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) * 6. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) * 7. (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) * 8. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) * * 9. (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) * 10. (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) * 11. (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) * 12. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) * 13. (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) * 14. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) * * 15. (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) * 16. (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) * 17. (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) * 18. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, , DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) * 19. (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) * 20. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) * * 21. (DATA_TYPE INPLACE_ARRAY1[ANY]) * 22. (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) * 23. (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) * * 24. (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) * 25. (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) * 26. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) * 27. (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) * 28. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) * * 29. (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) * 30. (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) * 31. (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) * 32. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) * 33. (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) * 34. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) * * 35. (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) * 36. (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) * 37. (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) * 38. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) * 39. (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) * 40. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) * * 41. (DATA_TYPE ARGOUT_ARRAY1[ANY]) * 42. (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) * 43. (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) * * 44. (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) * * 45. (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) * * 46. (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) * * 47. (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) * 48. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) * * 49. (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) * 50. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) * 51. (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) * 52. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) * * 53. (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) * 54. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) * 55. (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) * 56. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) * * 57. (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) * 58. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4) * 59. (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) * 60. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4) * * 61. (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) * 62. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) * * 63. (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) * 64. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) * 65. (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) * 66. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) * * 67. (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) * 68. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3) * 69. (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) * 70. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3) * * 71. (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) * 72. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) * 73. (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) * 74. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) * * where "DATA_TYPE" is any type supported by the NumPy module, and * "DIM_TYPE" is any int-like type suitable for specifying dimensions. * The difference between "ARRAY" typemaps and "FARRAY" typemaps is * that the "FARRAY" typemaps expect Fortran ordering of * multidimensional arrays. In python, the dimensions will not need * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1" * typemaps). The IN_ARRAYs can be a numpy array or any sequence that * can be converted to a numpy array of the specified type. The * INPLACE_ARRAYs must be numpy arrays of the appropriate type. The * ARGOUT_ARRAYs will be returned as new numpy arrays of the * appropriate type. * * These typemaps can be applied to existing functions using the * %apply directive. For example: * * %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)}; * double prod(double* series, int length); * * %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2) * {(int rows, int cols, double* matrix )}; * void floor(int rows, int cols, double* matrix, double f); * * %apply (double IN_ARRAY3[ANY][ANY][ANY]) * {(double tensor[2][2][2] )}; * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) * {(double low[2][2][2] )}; * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) * {(double upp[2][2][2] )}; * void luSplit(double tensor[2][2][2], * double low[2][2][2], * double upp[2][2][2] ); * * or directly with * * double prod(double* IN_ARRAY1, int DIM1); * * void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f); * * void luSplit(double IN_ARRAY3[ANY][ANY][ANY], * double ARGOUT_ARRAY3[ANY][ANY][ANY], * double ARGOUT_ARRAY3[ANY][ANY][ANY]); */ %define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE) /************************/ /* Input Array Typemaps */ /************************/ /* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE IN_ARRAY1[ANY]) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE IN_ARRAY1[ANY]) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[1] = { $1_dim0 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 1) || !require_size(array, size, 1)) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(freearg) (DATA_TYPE IN_ARRAY1[ANY]) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[1] = { -1 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 1) || !require_size(array, size, 1)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); } %typemap(freearg) (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[1] = {-1}; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 1) || !require_size(array, size, 1)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DATA_TYPE*) array_data(array); } %typemap(freearg) (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE IN_ARRAY2[ANY][ANY]) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE IN_ARRAY2[ANY][ANY]) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[2] = { $1_dim0, $1_dim1 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 2) || !require_size(array, size, 2)) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(freearg) (DATA_TYPE IN_ARRAY2[ANY][ANY]) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[2] = { -1, -1 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 2) || !require_size(array, size, 2)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); } %typemap(freearg) (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[2] = { -1, -1 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 2) || !require_size(array, size, 2)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DATA_TYPE*) array_data(array); } %typemap(freearg) (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[2] = { -1, -1 }; array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 2) || !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); } %typemap(freearg) (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[2] = { -1, -1 }; array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 2) || !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DATA_TYPE*) array_data(array); } %typemap(freearg) (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 3) || !require_size(array, size, 3)) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(freearg) (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[3] = { -1, -1, -1 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 3) || !require_size(array, size, 3)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); } %typemap(freearg) (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { /* for now, only concerned with lists */ $1 = PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL) { npy_intp size[2] = { -1, -1 }; PyArrayObject* temp_array; Py_ssize_t i; int is_new_object; /* length of the list */ $2 = PyList_Size($input); /* the arrays */ array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); is_new_object_array = (int *)calloc($2,sizeof(int)); if (array == NULL || object_array == NULL || is_new_object_array == NULL) { SWIG_fail; } for (i=0; i<$2; i++) { temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object); /* the new array must be stored so that it can be destroyed in freearg */ object_array[i] = temp_array; is_new_object_array[i] = is_new_object; if (!temp_array || !require_dimensions(temp_array, 2)) SWIG_fail; /* store the size of the first array in the list, then use that for comparison. */ if (i == 0) { size[0] = array_size(temp_array,0); size[1] = array_size(temp_array,1); } if (!require_size(temp_array, size, 2)) SWIG_fail; array[i] = (DATA_TYPE*) array_data(temp_array); } $1 = (DATA_TYPE**) array; $3 = (DIM_TYPE) size[0]; $4 = (DIM_TYPE) size[1]; } %typemap(freearg) (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { Py_ssize_t i; if (array$argnum!=NULL) free(array$argnum); /*freeing the individual arrays if needed */ if (object_array$argnum!=NULL) { if (is_new_object_array$argnum!=NULL) { for (i=0; i<$2; i++) { if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i]) { Py_DECREF(object_array$argnum[i]); } } free(is_new_object_array$argnum); } free(object_array$argnum); } } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, * DATA_TYPE* IN_ARRAY3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[3] = { -1, -1, -1 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 3) || !require_size(array, size, 3)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DATA_TYPE*) array_data(array); } %typemap(freearg) (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[3] = { -1, -1, -1 }; array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 3) || !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); } %typemap(freearg) (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, * DATA_TYPE* IN_FARRAY3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[3] = { -1, -1, -1 }; array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 3) || !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DATA_TYPE*) array_data(array); } %typemap(freearg) (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3}; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 4) || !require_size(array, size, 4)) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(freearg) (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3, DIM_TYPE DIM4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[4] = { -1, -1, -1, -1 }; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 4) || !require_size(array, size, 4)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); $5 = (DIM_TYPE) array_size(array,3); } %typemap(freearg) (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3, DIM_TYPE DIM4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { /* for now, only concerned with lists */ $1 = PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL) { npy_intp size[3] = { -1, -1, -1 }; PyArrayObject* temp_array; Py_ssize_t i; int is_new_object; /* length of the list */ $2 = PyList_Size($input); /* the arrays */ array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); is_new_object_array = (int *)calloc($2,sizeof(int)); if (array == NULL || object_array == NULL || is_new_object_array == NULL) { SWIG_fail; } for (i=0; i<$2; i++) { temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object); /* the new array must be stored so that it can be destroyed in freearg */ object_array[i] = temp_array; is_new_object_array[i] = is_new_object; if (!temp_array || !require_dimensions(temp_array, 3)) SWIG_fail; /* store the size of the first array in the list, then use that for comparison. */ if (i == 0) { size[0] = array_size(temp_array,0); size[1] = array_size(temp_array,1); size[2] = array_size(temp_array,2); } if (!require_size(temp_array, size, 3)) SWIG_fail; array[i] = (DATA_TYPE*) array_data(temp_array); } $1 = (DATA_TYPE**) array; $3 = (DIM_TYPE) size[0]; $4 = (DIM_TYPE) size[1]; $5 = (DIM_TYPE) size[2]; } %typemap(freearg) (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { Py_ssize_t i; if (array$argnum!=NULL) free(array$argnum); /*freeing the individual arrays if needed */ if (object_array$argnum!=NULL) { if (is_new_object_array$argnum!=NULL) { for (i=0; i<$2; i++) { if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i]) { Py_DECREF(object_array$argnum[i]); } } free(is_new_object_array$argnum); } free(object_array$argnum); } } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, * DATA_TYPE* IN_ARRAY4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[4] = { -1, -1, -1 , -1}; array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 4) || !require_size(array, size, 4)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DIM_TYPE) array_size(array,3); $5 = (DATA_TYPE*) array_data(array); } %typemap(freearg) (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3, DIM_TYPE DIM4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[4] = { -1, -1, -1, -1 }; array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 4) || !require_size(array, size, 4) | !require_fortran(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); $5 = (DIM_TYPE) array_size(array,3); } %typemap(freearg) (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, * DATA_TYPE* IN_FARRAY4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) { $1 = is_array($input) || PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) (PyArrayObject* array=NULL, int is_new_object=0) { npy_intp size[4] = { -1, -1, -1 , -1 }; array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, &is_new_object); if (!array || !require_dimensions(array, 4) || !require_size(array, size, 4) || !require_fortran(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DIM_TYPE) array_size(array,3); $5 = (DATA_TYPE*) array_data(array); } %typemap(freearg) (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) { if (is_new_object$argnum && array$argnum) { Py_DECREF(array$argnum); } } /***************************/ /* In-Place Array Typemaps */ /***************************/ /* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE INPLACE_ARRAY1[ANY]) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE INPLACE_ARRAY1[ANY]) (PyArrayObject* array=NULL) { npy_intp size[1] = { $1_dim0 }; array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = ($1_ltype) array_data(array); } /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) (PyArrayObject* array=NULL, int i=1) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,1) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = 1; for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i); } /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) (PyArrayObject* array=NULL, int i=0) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,1) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = 1; for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i); $2 = (DATA_TYPE*) array_data(array); } /* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) (PyArrayObject* array=NULL) { npy_intp size[2] = { $1_dim0, $1_dim1 }; array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = ($1_ltype) array_data(array); } /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,2) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,2) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DATA_TYPE*) array_data(array); } /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,2) || !require_contiguous(array) || !require_native(array) || !require_fortran(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,2) || !require_contiguous(array) || !require_native(array) || !require_fortran(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DATA_TYPE*) array_data(array); } /* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) (PyArrayObject* array=NULL) { npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = ($1_ltype) array_data(array); } /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,3) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); } /* Typemap suite for (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { $1 = PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL) { npy_intp size[2] = { -1, -1 }; PyArrayObject* temp_array; Py_ssize_t i; /* length of the list */ $2 = PyList_Size($input); /* the arrays */ array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); if (array == NULL || object_array == NULL) { SWIG_fail; } for (i=0; i<$2; i++) { temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE); /* the new array must be stored so that it can be destroyed in freearg */ object_array[i] = temp_array; if ( !temp_array || !require_dimensions(temp_array, 2) || !require_contiguous(temp_array) || !require_native(temp_array) || !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE) ) SWIG_fail; /* store the size of the first array in the list, then use that for comparison. */ if (i == 0) { size[0] = array_size(temp_array,0); size[1] = array_size(temp_array,1); } if (!require_size(temp_array, size, 2)) SWIG_fail; array[i] = (DATA_TYPE*) array_data(temp_array); } $1 = (DATA_TYPE**) array; $3 = (DIM_TYPE) size[0]; $4 = (DIM_TYPE) size[1]; } %typemap(freearg) (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { if (array$argnum!=NULL) free(array$argnum); if (object_array$argnum!=NULL) free(object_array$argnum); } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, * DATA_TYPE* INPLACE_ARRAY3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,3) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DATA_TYPE*) array_data(array); } /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,3) || !require_contiguous(array) || !require_native(array) || !require_fortran(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, * DATA_TYPE* INPLACE_FARRAY3) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,3) || !require_contiguous(array) || !require_native(array) || !require_fortran(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DATA_TYPE*) array_data(array); } /* Typemap suite for (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) (PyArrayObject* array=NULL) { npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3 }; array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,4) || !require_size(array, size, 4) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = ($1_ltype) array_data(array); } /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3, DIM_TYPE DIM4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,4) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); $5 = (DIM_TYPE) array_size(array,3); } /* Typemap suite for (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3, DIM_TYPE DIM4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { $1 = PySequence_Check($input); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL) { npy_intp size[3] = { -1, -1, -1 }; PyArrayObject* temp_array; Py_ssize_t i; /* length of the list */ $2 = PyList_Size($input); /* the arrays */ array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); if (array == NULL || object_array == NULL) { SWIG_fail; } for (i=0; i<$2; i++) { temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE); /* the new array must be stored so that it can be destroyed in freearg */ object_array[i] = temp_array; if ( !temp_array || !require_dimensions(temp_array, 3) || !require_contiguous(temp_array) || !require_native(temp_array) || !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE) ) SWIG_fail; /* store the size of the first array in the list, then use that for comparison. */ if (i == 0) { size[0] = array_size(temp_array,0); size[1] = array_size(temp_array,1); size[2] = array_size(temp_array,2); } if (!require_size(temp_array, size, 3)) SWIG_fail; array[i] = (DATA_TYPE*) array_data(temp_array); } $1 = (DATA_TYPE**) array; $3 = (DIM_TYPE) size[0]; $4 = (DIM_TYPE) size[1]; $5 = (DIM_TYPE) size[2]; } %typemap(freearg) (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { if (array$argnum!=NULL) free(array$argnum); if (object_array$argnum!=NULL) free(object_array$argnum); } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, * DATA_TYPE* INPLACE_ARRAY4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,4) || !require_contiguous(array) || !require_native(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DIM_TYPE) array_size(array,3); $5 = (DATA_TYPE*) array_data(array); } /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, * DIM_TYPE DIM3, DIM_TYPE DIM4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,4) || !require_contiguous(array) || !require_native(array) || !require_fortran(array)) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); $2 = (DIM_TYPE) array_size(array,0); $3 = (DIM_TYPE) array_size(array,1); $4 = (DIM_TYPE) array_size(array,2); $5 = (DIM_TYPE) array_size(array,3); } /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, * DATA_TYPE* INPLACE_FARRAY4) */ %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, fragment="NumPy_Macros") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) { $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), DATA_TYPECODE); } %typemap(in, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) (PyArrayObject* array=NULL) { array = obj_to_array_no_conversion($input, DATA_TYPECODE); if (!array || !require_dimensions(array,4) || !require_contiguous(array) || !require_native(array) || !require_fortran(array)) SWIG_fail; $1 = (DIM_TYPE) array_size(array,0); $2 = (DIM_TYPE) array_size(array,1); $3 = (DIM_TYPE) array_size(array,2); $4 = (DIM_TYPE) array_size(array,3); $5 = (DATA_TYPE*) array_data(array); } /*************************/ /* Argout Array Typemaps */ /*************************/ /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY]) */ %typemap(in,numinputs=0, fragment="NumPy_Backward_Compatibility,NumPy_Macros") (DATA_TYPE ARGOUT_ARRAY1[ANY]) (PyObject* array = NULL) { npy_intp dims[1] = { $1_dim0 }; array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); if (!array) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(argout) (DATA_TYPE ARGOUT_ARRAY1[ANY]) { $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); } /* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) */ %typemap(in,numinputs=1, fragment="NumPy_Fragments") (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) (PyObject* array = NULL) { npy_intp dims[1]; if (!PyInt_Check($input)) { const char* typestring = pytype_string($input); PyErr_Format(PyExc_TypeError, "Int dimension expected. '%s' given.", typestring); SWIG_fail; } $2 = (DIM_TYPE) PyInt_AsLong($input); dims[0] = (npy_intp) $2; array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); if (!array) SWIG_fail; $1 = (DATA_TYPE*) array_data(array); } %typemap(argout) (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) { $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); } /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) */ %typemap(in,numinputs=1, fragment="NumPy_Fragments") (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) (PyObject* array = NULL) { npy_intp dims[1]; if (!PyInt_Check($input)) { const char* typestring = pytype_string($input); PyErr_Format(PyExc_TypeError, "Int dimension expected. '%s' given.", typestring); SWIG_fail; } $1 = (DIM_TYPE) PyInt_AsLong($input); dims[0] = (npy_intp) $1; array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); if (!array) SWIG_fail; $2 = (DATA_TYPE*) array_data(array); } %typemap(argout) (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) { $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); } /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) */ %typemap(in,numinputs=0, fragment="NumPy_Backward_Compatibility,NumPy_Macros") (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) (PyObject* array = NULL) { npy_intp dims[2] = { $1_dim0, $1_dim1 }; array = PyArray_SimpleNew(2, dims, DATA_TYPECODE); if (!array) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(argout) (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) { $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); } /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) */ %typemap(in,numinputs=0, fragment="NumPy_Backward_Compatibility,NumPy_Macros") (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) (PyObject* array = NULL) { npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 }; array = PyArray_SimpleNew(3, dims, DATA_TYPECODE); if (!array) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(argout) (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) { $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); } /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) */ %typemap(in,numinputs=0, fragment="NumPy_Backward_Compatibility,NumPy_Macros") (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) (PyObject* array = NULL) { npy_intp dims[4] = { $1_dim0, $1_dim1, $1_dim2, $1_dim3 }; array = PyArray_SimpleNew(4, dims, DATA_TYPECODE); if (!array) SWIG_fail; $1 = ($1_ltype) array_data(array); } %typemap(argout) (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) { $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); } /*****************************/ /* Argoutview Array Typemaps */ /*****************************/ /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim_temp) { $1 = &data_temp; $2 = &dim_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) { npy_intp dims[1] = { *$2 }; PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEW_ARRAY1) (DIM_TYPE dim_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim_temp; $2 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) { npy_intp dims[1] = { *$1 }; PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) { npy_intp dims[2] = { *$2, *$3 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_ARRAY2) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) { npy_intp dims[2] = { *$1, *$2 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) { npy_intp dims[2] = { *$2, *$3 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_FARRAY2) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) { npy_intp dims[2] = { *$1, *$2 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) { npy_intp dims[3] = { *$2, *$3, *$4 }; PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) { npy_intp dims[3] = { *$1, *$2, *$3 }; PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) { npy_intp dims[3] = { *$2, *$3, *$4 }; PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEW_FARRAY3) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) { npy_intp dims[3] = { *$1, *$2, *$3 }; PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; $5 = &dim4_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) { npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEW_ARRAY4) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &dim4_temp; $5 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4) { npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; $5 = &dim4_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) { npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEW_FARRAY4) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &dim4_temp; $5 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4) { npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; $result = SWIG_Python_AppendOutput($result,obj); } /*************************************/ /* Managed Argoutview Array Typemaps */ /*************************************/ /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim_temp) { $1 = &data_temp; $2 = &dim_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) { npy_intp dims[1] = { *$2 }; PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEWM_ARRAY1) (DIM_TYPE dim_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim_temp; $2 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) { npy_intp dims[1] = { *$1 }; PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) { npy_intp dims[2] = { *$2, *$3 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEWM_ARRAY2) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) { npy_intp dims[2] = { *$1, *$2 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) { npy_intp dims[2] = { *$2, *$3 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEWM_FARRAY2) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) { npy_intp dims[2] = { *$1, *$2 }; PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) { npy_intp dims[3] = { *$2, *$3, *$4 }; PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEWM_ARRAY3) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3) { npy_intp dims[3] = { *$1, *$2, *$3 }; PyObject* obj= PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) { npy_intp dims[3] = { *$2, *$3, *$4 }; PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEWM_FARRAY3) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3) { npy_intp dims[3] = { *$1, *$2, *$3 }; PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; $5 = &dim4_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) { npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_ARRAY4) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &dim4_temp; $5 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) { npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; $5 = &dim4_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) { npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_FARRAY4) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &dim4_temp; $5 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) { npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; $5 = &dim4_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) { npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_ARRAY4) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &dim4_temp; $5 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) { npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); PyArrayObject* array = (PyArrayObject*) obj; if (!array) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) */ %typemap(in,numinputs=0) (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) { $1 = &data_temp; $2 = &dim1_temp; $3 = &dim2_temp; $4 = &dim3_temp; $5 = &dim4_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) { npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) */ %typemap(in,numinputs=0) (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_FARRAY4) (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) { $1 = &dim1_temp; $2 = &dim2_temp; $3 = &dim3_temp; $4 = &dim4_temp; $5 = &data_temp; } %typemap(argout, fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities") (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) { npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); PyArrayObject* array = (PyArrayObject*) obj; if (!array || !require_fortran(array)) SWIG_fail; %#ifdef SWIGPY_USE_CAPSULE PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); %#else PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); %#endif %#if NPY_API_VERSION < 0x00000007 PyArray_BASE(array) = cap; %#else PyArray_SetBaseObject(array,cap); %#endif $result = SWIG_Python_AppendOutput($result,obj); } %enddef /* %numpy_typemaps() macro */ /* *************************************************************** */ /* Concrete instances of the %numpy_typemaps() macro: Each invocation * below applies all of the typemaps above to the specified data type. */ %numpy_typemaps(signed char , NPY_BYTE , int) %numpy_typemaps(unsigned char , NPY_UBYTE , int) %numpy_typemaps(short , NPY_SHORT , int) %numpy_typemaps(unsigned short , NPY_USHORT , int) %numpy_typemaps(int , NPY_INT , int) %numpy_typemaps(unsigned int , NPY_UINT , int) %numpy_typemaps(long , NPY_LONG , int) %numpy_typemaps(unsigned long , NPY_ULONG , int) %numpy_typemaps(long long , NPY_LONGLONG , int) %numpy_typemaps(unsigned long long, NPY_ULONGLONG, int) %numpy_typemaps(float , NPY_FLOAT , int) %numpy_typemaps(double , NPY_DOUBLE , int) /* *************************************************************** * The follow macro expansion does not work, because C++ bool is 4 * bytes and NPY_BOOL is 1 byte * * %numpy_typemaps(bool, NPY_BOOL, int) */ /* *************************************************************** * On my Mac, I get the following warning for this macro expansion: * 'swig/python detected a memory leak of type 'long double *', no destructor found.' * * %numpy_typemaps(long double, NPY_LONGDOUBLE, int) */ #ifdef __cplusplus %include %numpy_typemaps(std::complex, NPY_CFLOAT , int) %numpy_typemaps(std::complex, NPY_CDOUBLE, int) #endif #endif /* SWIGPYTHON */ OTB-release-5.8/Modules/Wrappers/SWIG/src/otbApplication.i000066400000000000000000001054201301006202600233150ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright: Centre National d'Etudes Spatiales, CS Systemes d'information. See OTBCopyright.txt, CSCopyright.txt for details. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ %module otbApplication %{ #include "itkBase.includes" #include "otbWrapperSWIGIncludes.h" #include // std::string #include #define SWIG_FILE_WITH_INIT %} // Language specific extension %include "Python.i" %include "Java.i" %include "Ruby.i" %include "Lua.i" %include "itkMacro.i" %include "itkBase.i" #if OTB_SWIGNUMPY %include "numpy.i" %init %{ import_array(); %} /*leave the mess to SWIG and let us not worry.*/ %apply (signed char* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(signed char* buffer, int dim1, int dim2, int dim3)}; %apply (signed short* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(signed short* buffer, int dim1, int dim2, int dim3)}; %apply (signed int* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(signed int* buffer, int dim1, int dim2, int dim3)}; %apply (signed long* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(signed long* buffer, int dim1, int dim2, int dim3)}; %apply (float* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(float* buffer, int dim1, int dim2, int dim3)}; %apply (unsigned char* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(unsigned char* buffer, int dim1, int dim2, int dim3)}; %apply (unsigned short* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(unsigned short* buffer, int dim1, int dim2, int dim3)}; %apply (unsigned int* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(unsigned int* buffer, int dim1, int dim2, int dim3)}; %apply (unsigned long* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(unsigned long* buffer, int dim1, int dim2, int dim3)}; %apply (double* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) {(double* buffer, int dim1, int dim2, int dim3)}; %apply (signed char** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(signed char** buffer, int *dim1, int *dim2, int *dim3)}; %apply (signed short** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(signed short** buffer, int *dim1, int *dim2, int *dim3)}; %apply (signed int** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(signed int** buffer, int *dim1, int *dim2, int *dim3)}; %apply (signed long** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(signed long** buffer, int *dim1, int *dim2, int *dim3)}; %apply (float** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(float** buffer, int *dim1, int *dim2, int *dim3)}; %apply (unsigned char** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(unsigned char** buffer, int *dim1, int *dim2, int *dim3)}; %apply (unsigned short** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(unsigned short** buffer, int *dim1, int *dim2, int *dim3)}; %apply (unsigned int** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(unsigned int** buffer, int *dim1, int *dim2, int *dim3)}; %apply (unsigned long** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(unsigned long** buffer, int *dim1, int *dim2, int *dim3)}; %apply (double** ARGOUTVIEW_ARRAY3, int *DIM1, int *DIM2, int *DIM3) {(double** buffer, int *dim1, int *dim2, int *dim3)}; #endif /* OTB_SWIGNUMPY */ namespace otb { namespace Wrapper { enum DefaultValueMode { DefaultValueMode_UNKNOWN, DefaultValueMode_RELATIVE, DefaultValueMode_ABSOLUTE }; typedef enum { ParameterType_Empty, ParameterType_Int, ParameterType_Float, ParameterType_String, ParameterType_StringList, ParameterType_InputFilename, ParameterType_InputFilenameList, ParameterType_OutputFilename, ParameterType_Directory, ParameterType_Choice, ParameterType_InputImage, ParameterType_InputImageList, ParameterType_InputVectorData, ParameterType_InputVectorDataList, ParameterType_OutputImage, ParameterType_OutputVectorData, ParameterType_Radius, ParameterType_Group, ParameterType_ListView, ParameterType_ComplexInputImage, ParameterType_ComplexOutputImage, ParameterType_RAM, ParameterType_OutputProcessXML, ParameterType_InputProcessXML } ParameterType; typedef enum { UserLevel_Basic, UserLevel_Advanced } UserLevel; typedef enum { ImagePixelType_uint8, ImagePixelType_int16, ImagePixelType_uint16, ImagePixelType_int32, ImagePixelType_uint32, ImagePixelType_float, ImagePixelType_double, } ImagePixelType; typedef enum { Role_Input, Role_Output } Role; typedef enum { ComplexImagePixelType_float, ComplexImagePixelType_double, } ComplexImagePixelType; } } class Application: public itkObject { public: virtual void SetName( const std::string & name ); itkGetStringMacro(Name); itkSetStringMacro(Description); itkGetStringMacro(Description); void Init(); void UpdateParameters(); int Execute(); int ExecuteAndWriteOutput(); std::vector GetParametersKeys(bool recursive = true); Parameter* Application::GetParameterByKey(std::string name); std::string GetParameterName(std::string); std::string GetParameterDescription(std::string); void SetParameterDescription(std::string paramKey, std::string dec); void SetParameterUserValue(std::string paramKey, bool value); void EnableParameter(std::string paramKey); void DisableParameter(std::string paramKey); bool IsParameterEnabled(std::string paramKey) const; bool IsMandatory(std::string paramKey) const; bool HasAutomaticValue(std::string paramKey) const; bool HasUserValue(std::string paramKey) const; void ClearValue(std::string paramKey); bool HasValue(std::string paramKey) const; otb::Wrapper::UserLevel GetParameterUserLevel(std::string paramKey) const; otb::Wrapper::ParameterType GetParameterType(std::string paramKey) const; otb::Wrapper::Role GetParameterRole(std::string paramKey) const; std::vector GetChoiceKeys(std::string choiceKey); std::vector GetChoiceNames(std::string choiceKey); bool IsApplicationReady(); void SetParameterInt(std::string parameter, int value); void SetParameterFloat(std::string parameter, float value); void SetParameterString(std::string parameter, std::string value); void SetParameterStringList(std::string parameter, std::vector value); void SetParameterInt(std::string parameter, int value, bool hasUserValueFlag); void SetParameterFloat(std::string parameter, float value, bool hasUserValueFlag); void SetParameterString(std::string parameter, std::string value, bool hasUserValueFlag); void SetParameterStringList(std::string parameter, std::vector values, bool hasUserValueFlag); void SetParameterEmpty(std::string parameter, bool value, bool hasUserValueFlag); void SetParameterOutputImagePixelType(std::string parameter, otb::Wrapper::ImagePixelType pixelType); void SetParameterComplexOutputImagePixelType(std::string parameter, otb::Wrapper::ComplexImagePixelType cpixelType); otb::Wrapper::ImagePixelType GetParameterOutputImagePixelType(std::string parameter); otb::Wrapper::ComplexImagePixelType GetParameterComplexOutputImagePixelType(std::string parameter); int GetParameterInt(std::string parameter); float GetParameterFloat(std::string parameter); std::string GetParameterString(std::string parameter); std::vector GetParameterStringList(std::string parameter); std::string GetParameterAsString(std::string paramKey); InputImageParameter::ImageBaseType * GetParameterOutputImage(std::string parameter); void SetParameterInputImage(std::string parameter, InputImageParameter::ImageBaseType * inputImage); ComplexInputImageParameter::ImageBaseType * GetParameterComplexOutputImage(std::string parameter); void SetParameterComplexInputImage(std::string parameter, ComplexInputImageParameter::ImageBaseType * inputImage); void AddImageToParameterInputImageList(std::string parameter,InputImageParameter::ImageBaseType * img); void SetNthParameterInputImageList(std::string parameter, const unsigned int &id, InputImageParameter::ImageBaseType * img); void ClearParameterInputImageList(std::string parameter); unsigned int GetNumberOfElementsInParameterInputImageList(std::string parameter); itkProcessObject* GetProgressSource() const; std::string GetProgressDescription() const; itkSetStringMacro(DocName); itkGetStringMacro(DocName); itkSetStringMacro(DocLongDescription); itkGetStringMacro(DocLongDescription); itkSetStringMacro(DocAuthors); itkGetStringMacro(DocAuthors); itkSetStringMacro(DocLimitations); itkGetStringMacro(DocLimitations); itkSetStringMacro(DocSeeAlso); itkGetStringMacro(DocSeeAlso); void SetDocTags( std::vector val ); void AddDocTag( const std::string & tag ); std::vector GetDocTags(); otb::Wrapper::ParameterGroup* GetParameterList(); unsigned int GetNumberOfExamples(); std::string GetExampleComment(unsigned int id); unsigned int GetExampleNumberOfParameters(unsigned int id); std::string GetExampleParameterKey(unsigned int exId, unsigned int paramId); std::string GetExampleParameterValue(unsigned int exId, unsigned int paramId); void SetDocExampleParameterValue( const std::string key, const std::string value, unsigned int exId=0 ); void SetExampleComment( const std::string & comm, unsigned int i ); unsigned int AddExample( const std::string & comm="" ); std::string GetCLExample(); std::string GetHtmlExample(); std::vector< std::pair > GetOutputParametersSumUp(); #if OTB_SWIGNUMPY %extend { #define SetFromNumpyArrayMacro(prefix, PixelDataType, ImageClass) \ void Set##ImageClass##From##prefix##NumpyArray_(std::string pkey, ##PixelDataType##* buffer, int dim1, int dim2, int dim3) \ { \ otb::Wrapper::Parameter *parameter = $self->GetParameterList()->GetParameterByKey(pkey); \ InputImageParameter* inputImageParam = dynamic_cast(parameter); \ typedef otb::##ImageClass##<##PixelDataType##> ImageType; \ ImageType::Pointer output = ImageType::New(); \ typedef ImageType::SizeType SizeType; \ typedef ImageType::IndexType IndexType; \ typedef ImageType::RegionType RegionType; \ typedef ImageType::PointType PointType; \ typedef ImageType::SpacingType SpacingType; \ typedef ImageType::DirectionType DirectionType; \ IndexType start; \ DirectionType direction; \ start.Fill( 0 ); \ SizeType size; \ size[0] = dim2; size[1] = dim1; \ SetVectorLengthMacro \ output->Allocate(); \ unsigned int numberOfPixels = dim1 * dim2 * dim3; \ RegionType region; \ region.SetIndex( start ); \ region.SetSize( size ); \ PointType origin; \ origin.Fill( 0.0 ); \ SpacingType spacing; \ spacing.Fill( 1.0 ); \ direction.SetIdentity(); \ output->SetOrigin( origin ); \ output->SetSpacing( spacing ); \ output->SetDirection(direction); \ output->SetLargestPossibleRegion(region); \ output->SetRequestedRegion(output->GetLargestPossibleRegion()); \ output->SetBufferedRegion(output->GetLargestPossibleRegion()); \ output->GetPixelContainer()->SetImportPointer(buffer, numberOfPixels, false); \ inputImageParam->SetImage(output); \ } #define SetVectorLengthMacro output->SetVectorLength(dim3); SetFromNumpyArrayMacro(Float, float, VectorImage) SetFromNumpyArrayMacro(Int8, signed char, VectorImage) SetFromNumpyArrayMacro(Int16, signed short, VectorImage) SetFromNumpyArrayMacro(Int32, signed int, VectorImage) SetFromNumpyArrayMacro(Int64, signed long, VectorImage) SetFromNumpyArrayMacro(UInt8, unsigned char, VectorImage) SetFromNumpyArrayMacro(UInt16, unsigned short, VectorImage) SetFromNumpyArrayMacro(UInt32, unsigned int, VectorImage) SetFromNumpyArrayMacro(UInt64, unsigned long, VectorImage) SetFromNumpyArrayMacro(Double, double, VectorImage) #undef SetVectorLengthMacro #define SetVectorLengthMacro dim3=1; SetFromNumpyArrayMacro(Float, float, Image) SetFromNumpyArrayMacro(Int8, signed char, Image) SetFromNumpyArrayMacro(Int16, signed short, Image) SetFromNumpyArrayMacro(Int32, signed int, Image) SetFromNumpyArrayMacro(Int64, signed long, Image) SetFromNumpyArrayMacro(UInt8, unsigned char, Image) SetFromNumpyArrayMacro(UInt16, unsigned short, Image) SetFromNumpyArrayMacro(UInt32, unsigned int, Image) SetFromNumpyArrayMacro(UInt64, unsigned long, Image) SetFromNumpyArrayMacro(Double, double, Image) #undef SetVectorLengthMacro #undef SetFromNumpyArrayMacro #define GetVectorImageAsNumpyArrayMacro(prefix, PixelType) \ void GetVectorImageAs##prefix##NumpyArray_(std::string pkey, ##PixelType##** buffer, int *dim1, int *dim2, int *dim3) \ { \ otb::Wrapper::Parameter *parameter = $self->GetParameterList()->GetParameterByKey(pkey); \ OutputImageParameter* outputImageParam = dynamic_cast(parameter); \ typedef itk::ImageBase<2> ImageBaseType; \ typedef ImageBaseType::RegionType RegionType; \ ImageBaseType::Pointer imageBase; \ imageBase = outputImageParam->GetValue(); \ imageBase->Update(); \ typedef ImageBaseType::SizeType SizeType; \ typedef ImageBaseType::IndexType IndexType; \ typedef ImageBaseType::PointType PointType; \ typedef ImageBaseType::SpacingType SpacingType; \ RegionType region = imageBase->GetBufferedRegion(); \ SizeType size = region.GetSize(); \ *dim1 = size[1]; \ *dim2 = size[0]; \ typedef otb::VectorImage Int8ImageType; \ typedef otb::VectorImage Int16ImageType; \ typedef otb::VectorImage Int32ImageType; \ typedef otb::VectorImage UInt8ImageType; \ typedef otb::VectorImage UInt16ImageType; \ typedef otb::VectorImage UInt32ImageType; \ typedef otb::VectorImage FloatImageType; \ typedef otb::VectorImage DoubleImageType; \ if (dynamic_cast(imageBase.GetPointer())) \ { \ UInt8ImageType* output = dynamic_cast(imageBase.GetPointer()); \ *buffer = reinterpret_cast<##PixelType##*>(output->GetBufferPointer()); \ *dim3 = output->GetNumberOfComponentsPerPixel(); \ } \ else if (dynamic_cast(imageBase.GetPointer())) \ { \ Int16ImageType* output = dynamic_cast(imageBase.GetPointer()); \ *buffer = reinterpret_cast<##PixelType##*>(output->GetBufferPointer()); \ *dim3 = output->GetNumberOfComponentsPerPixel(); \ } \ else if (dynamic_cast(imageBase.GetPointer())) \ { \ UInt16ImageType* output = dynamic_cast(imageBase.GetPointer()); \ *buffer = reinterpret_cast<##PixelType##*>(output->GetBufferPointer()); \ *dim3 = output->GetNumberOfComponentsPerPixel(); \ } \ else if (dynamic_cast(imageBase.GetPointer())) \ { \ Int32ImageType* output = dynamic_cast(imageBase.GetPointer()); \ *buffer = reinterpret_cast<##PixelType##*>(output->GetBufferPointer()); \ *dim3 = output->GetNumberOfComponentsPerPixel(); \ } \ else if (dynamic_cast(imageBase.GetPointer())) \ { \ UInt32ImageType* output = dynamic_cast(imageBase.GetPointer()); \ *buffer = reinterpret_cast<##PixelType##*>(output->GetBufferPointer()); \ *dim3 = output->GetNumberOfComponentsPerPixel(); \ } \ else if (dynamic_cast(imageBase.GetPointer())) \ { \ FloatImageType* output = dynamic_cast(imageBase.GetPointer()); \ *buffer = reinterpret_cast<##PixelType##*>(output->GetBufferPointer()); \ *dim3 = output->GetNumberOfComponentsPerPixel(); \ } \ else if (dynamic_cast(imageBase.GetPointer())) \ { \ DoubleImageType* output = dynamic_cast(imageBase.GetPointer()); \ *buffer = reinterpret_cast<##PixelType##*>(output->GetBufferPointer()); \ *dim3 = output->GetNumberOfComponentsPerPixel(); \ } \ else \ { \ std::cerr << "unknown image type. cannot make a numpy array" << std::endl; \ } \ } GetVectorImageAsNumpyArrayMacro(Float, float) GetVectorImageAsNumpyArrayMacro(Int16, signed short) GetVectorImageAsNumpyArrayMacro(Int32, signed int) GetVectorImageAsNumpyArrayMacro(UInt8, unsigned char) GetVectorImageAsNumpyArrayMacro(UInt16, unsigned short) GetVectorImageAsNumpyArrayMacro(UInt32, unsigned int) GetVectorImageAsNumpyArrayMacro(Double, double) #undef GetVectorImageAsNumpyArrayMacro } /* end of %extend */ #endif /* OTB_SWIGNUMPY */ protected: Application(); #if SWIGJAVA virtual ~Application(); #endif private: Application(const Application &); void operator =(const Application&); }; DECLARE_REF_COUNT_CLASS( Application ) /* Int8 Int16 Int32 Int64 */ /* UInt8 UInt16 UInt32 UInt64 */ /* Float32 Double64 */ /* Complex32 Complex64 */ /* typedef signed char Int8; */ /* typedef signed short Int16; */ /* typedef signed int Int32; */ /* typedef signed long Int64; */ /* typedef unsigned char UInt8; */ /* typedef unsigned short UInt16; */ /* typedef unsigned int UInt32; */ /* typedef unsigned long UInt64; */ /* typedef float Float32; */ /* typedef double Float64; */ #if SWIGPYTHON %pythoncode { import sys class ApplicationProxy(object): def __init__(self, application, groupkey, value = None): self.__dict__["application"] = application self.__dict__["groupkey"] = groupkey if value is not None: self.__dict__["application"].SetParameterString(groupkey, value) def __str__(self): return self.__dict__["application"].GetParameterAsString(self.groupkey) def __eq__(self, other): if not type(other) == type(self): return (self.__str__() == other) else: return (isinstance(other, self.__class__) and self.__dict__ == other.__dict__) def __ne__(self, other): return not self.__eq__(other) def __getattr__(self,attr): return self.__dict__["application"].GetParameterValue( self.groupkey + "." + attr.lower() ) def __setattr__(self,attr,value): if attr not in self.__dict__: return self.__dict__["application"].SetParameterValue( self.groupkey + "." + attr.lower(), value ) else: return dict.__setattr__(self, attr, value) } #endif #if SWIGPYTHON /*Maybe TODO: change use a dict to GetParameterTypeAsString */ %extend Application { %pythoncode { def __str__(self): s = self.GetDocName() def GetParameterTypeAsString(self, parameter_type): return { ParameterType_InputProcessXML : 'ParameterType_InputProcessXML', ParameterType_String : 'ParameterType_String', ParameterType_InputFilename : 'ParameterType_InputFilename', ParameterType_OutputImage : 'ParameterType_OutputImage', ParameterType_OutputVectorData : 'ParameterType_OutputVectorData', ParameterType_OutputProcessXML : 'ParameterType_OutputProcessXML', ParameterType_OutputFilename : 'ParameterType_OutputFilename', ParameterType_Directory : 'ParameterType_Directory', ParameterType_InputImage : 'ParameterType_InputImage', ParameterType_ComplexInputImage : 'ParameterType_ComplexInputImage', ParameterType_InputVectorData : 'ParameterType_InputVectorData', ParameterType_InputImageList : 'ParameterType_InputImageList', ParameterType_InputVectorDataList : 'ParameterType_InputImageList', ParameterType_InputFilenameList : 'ParameterType_InputFilenameList', ParameterType_StringList : 'ParameterType_StringList', ParameterType_ListView : 'ParameterType_ListView', ParameterType_Int : 'ParameterType_Int', ParameterType_Radius : 'ParameterType_Radius', ParameterType_RAM : 'ParameterType_RAM', ParameterType_Float : 'ParameterType_Float', ParameterType_Empty : 'ParameterType_Empty', ParameterType_Choice : 'ParameterType_Choice', ParameterType_Group : 'ParameterType_Group', }.get(parameter_type, 'ParameterType_UNKNOWN') def __str__(self): s = self.GetDocName() s += '\n' s += self.GetDocLongDescription() return s def SetParameterValue(self, paramKey, value): paramType = self.GetParameterType(paramKey) if paramType in [ParameterType_InputProcessXML, ParameterType_RAM, ParameterType_String, ParameterType_InputFilename, ParameterType_OutputImage, ParameterType_OutputVectorData, ParameterType_OutputProcessXML, ParameterType_OutputFilename, ParameterType_Directory, ParameterType_InputImage, ParameterType_ComplexInputImage, ParameterType_InputVectorData]: return self.SetParameterString(paramKey, value) elif paramType in [ParameterType_InputImageList, ParameterType_InputVectorDataList, ParameterType_InputFilenameList, ParameterType_StringList, ParameterType_ListView]: return self.setParameterStringList(paramKey, value) elif paramType in [ParameterType_Int, ParameterType_Radius]: return self.SetParameterInt(paramKey, value) elif paramType in [ParameterType_Float]: return self.SetParameterFloat(paramKey, value) elif paramType in [ParameterType_Empty]: return self.EnableParameter(paramKey) elif paramType in [ParameterType_Group]: return ApplicationProxy(self, paramKey) elif paramType in [ParameterType_Choice]: return ApplicationProxy(self, paramKey, value) else: print ("Unsupported parameter type '%s' with key '%s'" %(self.GetParameterTypeAsString(paramType) ,paramKey)) return def GetParameterValue(self, paramKey): paramType = self.GetParameterType(paramKey) if paramType in [ParameterType_InputProcessXML, ParameterType_String, ParameterType_InputFilename, ParameterType_OutputImage, ParameterType_OutputVectorData, ParameterType_OutputProcessXML, ParameterType_OutputFilename, ParameterType_Directory, ParameterType_InputImage, ParameterType_ComplexInputImage, ParameterType_InputVectorData]: return self.GetParameterString(paramKey) elif paramType in [ParameterType_InputImageList, ParameterType_InputVectorDataList, ParameterType_InputFilenameList, ParameterType_StringList, ParameterType_ListView]: return self.GetParameterStringList(paramKey) elif paramType in [ParameterType_Int, ParameterType_Radius, ParameterType_RAM]: return self.GetParameterInt(paramKey) elif paramType in [ParameterType_Float]: return self.GetParameterFloat(paramKey) elif paramType in [ParameterType_Empty]: return self.IsParameterEnabled(paramKey) elif paramType in [ParameterType_Group, ParameterType_Choice]: return ApplicationProxy(self, paramKey) else: print ("Unsupported parameter type '%s' with key '%s'" %(self.GetParameterTypeAsString(paramType) ,paramKey)) return None def __getattr__(self,attr): """ __get_attribute__ is called whenever an instance request an attribute. eg: App.SetParameterString(), App.GetName() .. __getattr__ is only called if the attribute is not found by __get_attribute__ call So we keep hide the GetParameter** calls within this method so that it seems like an obivous call for users. App.IN , App.OUT , where 'in' and 'out' are parameters in the 'otb application' with instance App """ if attr is not None: key_list = [k.upper() for k in self.GetParametersKeys(True)] if attr in key_list: return self.GetParameterValue(attr.lower()) else: raise AttributeError def __setattr__(self, attr, value): """ __setattr__ is called if the attribute requested is not found in the attribute list. So these attributes are supposed to be 'key' of parameters used. Here we keep hide the SetParameter** calls within this method so that it seems like an obivous call for users. App.IN='my-input-file-name' , App.OUT='my-output-file-name'w here 'in' and 'out' are parameters in the 'otb application' with instance App Ofcourse, we don't blindly accept any attributes as python, we check them against list of existing parameters for application with 'self.GetParametersKeys(True)' """ if attr is not None: key_list = [k.upper() for k in self.GetParametersKeys(True)] if attr in key_list: self.SetParameterValue(attr.lower(), value) else: raise AttributeError } } #endif #if OTB_SWIGNUMPY %extend Application { %pythoncode { def SetImageFromNumpyArray(self, paramKey, npArray): """ This method takes a numpy array and set ImageIOBase of InputImageParameter by creating an otbImage with same pixel type as numpyarray.dtype """ if len(npArray.shape) == 3: raise ValueError( "(len(npArray.shape) == 3)\n" "Input array given is of 3 dimension.\n" "SetImageFromNumpyArray create ImageIO from otbImage and thus demands a 2d array.\n" "you can either provide an 2d numpy array or use SetVectorImageFromNumpyArray depending on your application.\n") dt = npArray.dtype.name if dt == 'int8': self.SetImageFromInt8NumpyArray_(paramKey, npArray) elif dt == 'int16': self.SetImageFromInt16NumpyArray_(paramKey, npArray) elif dt == 'int32': self.SetImageFromInt32NumpyArray_(paramKey, npArray) elif dt == 'uint8': self.SetImageFromUInt8NumpyArray_(paramKey, npArray) elif dt == 'uint16': self.SetImageFromUInt16NumpyArray_(paramKey, npArray) elif dt == 'uint32': self.SetImageFromUInt32NumpyArray_(paramKey, npArray) elif dt == 'float': self.SetImageFromFloatNumpyArray_(paramKey, npArray) elif dt == 'double': self.SetImageFromDoubleNumpyArray_(paramKey, npArray) else: self.SetImageFromFloatNumpyArray_(paramKey, npArray) return def SetVectorImageFromNumpyArray(self, paramKey, npArray): """ This method takes a numpy array and set ImageIOBase of InputImageParameter by creating an otbVectorImage with same pixel type as numpyarray.dtype. NOTE: Input (npArray) must be an ndarray with 3 dimension, len(npArray.shape) must be > 2 """ if len(npArray.shape) < 3: raise ValueError( "(len(npArray.shape) < 3)\n" "Input array given is not of 3 dimension.\n" "SetVectorImageFromNumpyArray create ImageIO from otbVectorImage and thus demands an array of shape 3.\n" "you can either provide an 3d numpy array or use SetImageFromNumpyArray depending on your application.\n") dt = npArray.dtype.name if dt == 'int8': self.SetVectorImageFromInt8NumpyArray_(paramKey, npArray) elif dt == 'int16': self.SetVectorImageFromInt16NumpyArray_(paramKey, npArray) elif dt == 'int32': self.SetVectorImageFromInt32NumpyArray_(paramKey, npArray) elif dt == 'uint8': self.SetVectorImageFromUInt8NumpyArray_(paramKey, npArray) elif dt == 'uint16': self.SetVectorImageFromUInt16NumpyArray_(paramKey, npArray) elif dt == 'uint32': self.SetVectorImageFromUInt32NumpyArray_(paramKey, npArray) elif dt == 'float': self.SetVectorImageFromFloatNumpyArray_(paramKey, npArray) elif dt == 'double': self.SetVectorImageFromDoubleNumpyArray_(paramKey, npArray) else: self.SetVectorImageFromFloatNumpyArray_(paramKey, npArray) return def GetVectorImageAsNumpyArray(self, paramKey, dt='float'): """ If datatype is unknown this method assumes to numpy.float32 Valid datatypes are: int8, int16, int32, uint8, uint16, uint32, float, double. NOTE: This method always return an numpy array with dimension 3 """ if dt == 'int8': return self.GetVectorImageAsInt8NumpyArray_(paramKey) elif dt == 'int16': return self.GetVectorImageAsInt16NumpyArray_(paramKey) elif dt == 'int32': return self.GetVectorImageAsInt32NumpyArray_(paramKey) elif dt == 'uint8': return self.GetVectorImageAsUInt8NumpyArray_(paramKey) elif dt == 'uint16': return self.GetVectorImageAsUInt16NumpyArray_(paramKey) elif dt == 'uint32': return self.GetVectorImageAsUInt32NumpyArray_(paramKey) elif dt == 'float': return self.GetVectorImageAsFloatNumpyArray_(paramKey) elif dt == 'double': return self.GetVectorImageAsDoubleNumpyArray_(paramKey) else: print ("Unknown datatype '" + dt + "'. Using float instead. Available types are:") print ("int8, int16, int32, uint8, uint16, uint32, float, double") return self.GetVectorImageAsFloatNumpyArray_(paramKey) def GetImageAsNumpyArray(self, paramKey, dt='float'): """ If datatype is unknown this method assumes to numpy.float32 Valid datatypes are: int8, int16, int32, uint8, uint16, uint32, float, double. NOTE: This method always return an numpy array with dimension 3 """ if dt == 'int8': numpy_vector_image = self.GetVectorImageAsInt8NumpyArray_(paramKey) elif dt == 'int16': numpy_vector_image = self.GetVectorImageAsInt16NumpyArray_(paramKey) elif dt == 'int32': numpy_vector_image = self.GetVectorImageAsInt32NumpyArray_(paramKey) elif dt == 'uint8': numpy_vector_image = self.GetVectorImageAsUInt8NumpyArray_(paramKey) elif dt == 'uint16': numpy_vector_image = self.GetVectorImageAsUInt16NumpyArray_(paramKey) elif dt == 'uint32': numpy_vector_image = self.GetVectorImageAsUInt32NumpyArray_(paramKey) elif dt == 'float': numpy_vector_image = self.GetVectorImageAsFloatNumpyArray_(paramKey) elif dt == 'double': numpy_vector_image = self.GetVectorImageAsDoubleNumpyArray_(paramKey) else: print ("Unknown datatype '" + dt + "'. Using float instead. Available types are:") print ("int8, int16, int32, uint8, uint16, uint32, float, double") numpy_vector_image = self.GetVectorImageAsFloatNumpyArray_(paramKey) if len(numpy_vector_image.shape) > 2: raise ValueError("len(numpy_vector_image.shape) > 2\n" "Output image from application is of 3 dimension (len(nparray.shape) > 2). \n" "GetImageFromNumpyArray returns an numpy array of dimension 2 that will result is loss of data.\n" "In this case you must use GetVectorImageFromNumpyArray which is capable of return a 3 dimension image.\n") numpy_vector_image = numpy_vector_image[:,:,1] return numpy_vector_image } } #endif /* OTB_SWIGNUMPY */ class Registry : public itkObject { public: static std::vector GetAvailableApplications(); static Application_Pointer CreateApplication(const std::string& name); static void AddApplicationPath(std::string newpath); static void SetApplicationPath(std::string newpath); protected: Registry(); virtual ~Registry(); }; class AddProcessToWatchEvent : public itkEventObject { public: AddProcessToWatchEvent(); ~AddProcessToWatchEvent(); virtual char const * GetEventName() const; virtual bool CheckEvent(itkEventObject const * e) const; virtual itkEventObject * MakeObject() const; AddProcessToWatchEvent(AddProcessToWatchEvent const & s); itkProcessObject * GetProcess() const; void SetProcess(itkProcessObject * process); void SetProcessDescription(const std::string desc); std::string GetProcessDescription() const; }; %include "PyCommand.i" OTB-release-5.8/Modules/Wrappers/SWIG/src/otbApplicationLuaMain.cxx000066400000000000000000000256751301006202600251530ustar00rootroot00000000000000/* ** $Id: lua.c, v 1.157 2005/12/29 16:23:32 roberto Exp $ ** Lua stand-alone interpreter ** See Copyright Notice in lua.h */ #include #include #include #include #include #include #include #include #define lua_c #if !defined(_WIN32) #define LUA_USE_POSIX #endif extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" } static lua_State *globalL = NULL; static const char *progname = LUA_PROGNAME; static void lstop (lua_State *L, lua_Debug *ar) { (void)ar; /* unused arg. */ lua_sethook(L, NULL, 0, 0); luaL_error(L, "interrupted!"); } static void laction (int i) { signal(i, SIG_DFL); /* if another SIGINT happens before lstop, terminate process (default action) */ lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1); } static void print_usage (void) { fprintf(stderr, "usage: %s [options] [script [args]].\n" "Available options are:\n" " -e stat execute string " LUA_QL("stat") "\n" " -l name require library " LUA_QL("name") "\n" " -c conf configure logger from file " LUA_QL("config") "\n" " -i enter interactive mode after executing " LUA_QL("script") "\n" " -v show version information\n" " -- stop handling options\n" " - execute stdin and stop handling options\n" , progname); fflush(stderr); } static void l_message (const char *pname, const char *msg) { if (pname) fprintf(stderr, "%s: ", pname); fprintf(stderr, "%s\n", msg); fflush(stderr); } static int report (lua_State *L, int status) { if (status && !lua_isnil(L, -1)) { const char *msg = lua_tostring(L, -1); if (msg == NULL) msg = "(error object is not a string)"; l_message(progname, msg); lua_pop(L, 1); } return status; } static int traceback (lua_State *L) { lua_getfield(L, LUA_GLOBALSINDEX, "debug"); if (!lua_istable(L, -1)) { lua_pop(L, 1); return 1; } lua_getfield(L, -1, "traceback"); if (!lua_isfunction(L, -1)) { lua_pop(L, 2); return 1; } lua_pushvalue(L, 1); /* pass error message */ lua_pushinteger(L, 2); /* skip this function and traceback */ lua_call(L, 2, 1); /* call debug.traceback */ return 1; } static int docall (lua_State *L, int narg, int clear) { int status; int base = lua_gettop(L) - narg; /* function index */ lua_pushcfunction(L, traceback); /* push traceback function */ lua_insert(L, base); /* put it under chunk and args */ signal(SIGINT, laction); status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base); signal(SIGINT, SIG_DFL); lua_remove(L, base); /* remove traceback function */ /* force a complete garbage collection in case of errors */ if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0); return status; } static void print_version (void) { fprintf ( stdout, LUA_VERSION " " LUA_COPYRIGHT "\n" ); fprintf ( stdout, "otbApplication\nInsight Toolkit %s\n", itk::Version::GetITKVersion() ); } static int getargs (lua_State *L, char **argv, int n) { int narg; int i; int argc = 0; while (argv[argc]) argc++; /* count total number of arguments */ narg = argc - (n + 1); /* number of arguments to the script */ luaL_checkstack(L, narg + 3, "too many arguments to script"); for (i=n+1; i < argc; i++) lua_pushstring(L, argv[i]); lua_createtable(L, narg, n + 1); for (i=0; i < argc; i++) { lua_pushstring(L, argv[i]); lua_rawseti(L, -2, i - n); } return narg; } static int dofile (lua_State *L, const char *name) { int status = luaL_loadfile(L, name) || docall(L, 0, 1); return report(L, status); } static int dostring (lua_State *L, const char *s, const char *name) { int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1); return report(L, status); } static int dolibrary (lua_State *L, const char *name) { lua_getglobal(L, "require"); lua_pushstring(L, name); return report(L, lua_pcall(L, 1, 0, 0)); } static const char *get_prompt (lua_State *L, int firstline) { const char *p; lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2"); p = lua_tostring(L, -1); if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2); lua_pop(L, 1); /* remove global */ return p; } static int incomplete (lua_State *L, int status) { if (status == LUA_ERRSYNTAX) { size_t lmsg; const char *msg = lua_tolstring(L, -1, &lmsg); const char *tp = msg + lmsg - (sizeof(LUA_QL("")) - 1); if (strstr(msg, LUA_QL("")) == tp) { lua_pop(L, 1); return 1; } } return 0; /* else... */ } static int pushline (lua_State *L, int firstline) { char buffer[LUA_MAXINPUT]; char *b = buffer; size_t l; const char *prmt = get_prompt(L, firstline); if (lua_readline(L, b, prmt) == 0) return 0; /* no input */ l = strlen(b); if (l > 0 && b[l-1] == '\n') /* line ends with newline? */ b[l-1] = '\0'; /* remove it */ if (firstline && b[0] == '=') /* first line starts with `=' ? */ lua_pushfstring(L, "return %s", b+1); /* change it to `return' */ else lua_pushstring(L, b); lua_freeline(L, b); return 1; } static int loadline (lua_State *L) { int status; lua_settop(L, 0); if (!pushline(L, 1)) return -1; /* no input */ for (; ;) { /* repeat until gets a complete line */ status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin"); if (!incomplete(L, status)) break; /* cannot try to add lines? */ if (!pushline(L, 0)) /* no more input? */ return -1; lua_pushliteral(L, "\n"); /* add a new line... */ lua_insert(L, -2); /* ...between the two lines */ lua_concat(L, 3); /* join them */ } lua_saveline(L, 1); lua_remove(L, 1); /* remove line */ return status; } static void dotty (lua_State *L) { int status; const char *oldprogname = progname; progname = NULL; while ((status = loadline(L)) != -1) { if (status == 0) status = docall(L, 0, 0); report(L, status); if (status == 0 && lua_gettop(L) > 0) { /* any result to print? */ lua_getglobal(L, "print"); lua_insert(L, 1); if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0) l_message(progname, lua_pushfstring(L, "error calling " LUA_QL("print") " (%s)", lua_tostring(L, -1))); } } lua_settop(L, 0); /* clear stack */ fputs("\n", stdout); fflush(stdout); progname = oldprogname; } static int handle_script (lua_State *L, char **argv, int n) { int status; const char *fname; int narg = getargs(L, argv, n); /* collect arguments */ lua_setglobal(L, "arg"); fname = argv[n]; if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) fname = NULL; /* stdin */ status = luaL_loadfile(L, fname); lua_insert(L, -(narg+1)); if (status == 0) status = docall(L, narg, 0); else lua_pop(L, narg); return report(L, status); } static int collectargs (char **argv, int *pi, int *pv, int *pe) { int i; for (i = 1; argv[i] != NULL; i++) { if (argv[i][0] != '-') /* not an option? */ return i; switch (argv[i][1]) { /* option */ case '-': return (argv[i+1] != NULL ? i+1 : 0); case '\0': return i; case 'i': *pi = 1; /* go through */ case 'v': *pv = 1; break; case 'e': *pe = 1; /* go through */ case 'c': case 'l': if (argv[i][2] == '\0') { i++; if (argv[i] == NULL) return -1; } break; default: return -1; /* invalid option */ } } return 0; } std::string LogConfigFilename (""); static int runargs (lua_State *L, char **argv, int n) { int i; for (i = 1; i < n; i++) { if (argv[i] == NULL) continue; lua_assert(argv[i][0] == '-'); switch (argv[i][1]) { /* option */ case 'e': { const char *chunk = argv[i] + 2; if (*chunk == '\0') chunk = argv[++i]; lua_assert(chunk != NULL); if (dostring(L, chunk, "=(command line)") != 0) return 1; break; } case 'l': { const char *filename = argv[i] + 2; if (*filename == '\0') filename = argv[++i]; lua_assert(filename != NULL); if (dolibrary(L, filename)) return 1; /* stop if file fails */ break; } case 'c': { const char *filename = argv[i] + 2; if (*filename == '\0') filename = argv[++i]; lua_assert(filename != NULL); LogConfigFilename = filename; break; } default: break; } } return 0; } static int handle_luainit (lua_State *L) { const char *init = getenv("LUA_INIT"); if (init == NULL) return 0; /* status OK */ else if (init[0] == '@') return dofile(L, init+1); else return dostring(L, init, "=LUA_INIT"); } struct Smain { int argc; char **argv; int status; }; #include extern "C" int luaopen_otbApplication ( lua_State* L ); static int pmain (lua_State *L) { struct Smain *s = (struct Smain *)lua_touserdata(L, 1); char **argv = s->argv; int script; int has_i = 0, has_v = 0, has_e = 0; globalL = L; if (argv[0] && argv[0][0]) progname = argv[0]; lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */ luaL_openlibs(L); /* open libraries */ // Insert our custom code luaopen_otbApplication(L); lua_gc(L, LUA_GCRESTART, 0); s->status = handle_luainit(L); if (s->status != 0) return 0; script = collectargs(argv, &has_i, &has_v, &has_e); if (script < 0) { /* invalid args? */ print_usage(); s->status = 1; return 0; } if (has_v) print_version(); s->status = runargs(L, argv, (script > 0) ? script : s->argc); if (s->status != 0) return 0; // See if we have OMP_NUM_THREADS set, and if so, make ITK obey std::string NumThreads; if ( itksys::SystemTools::GetEnv ( "OMP_NUM_THREADS", NumThreads ) ) { itk::MultiThreader::SetGlobalDefaultNumberOfThreads ( atoi ( NumThreads.c_str() ) ); } if (script) s->status = handle_script(L, argv, script); if (s->status != 0) return 0; if (has_i) dotty(L); else if (script == 0 && !has_e && !has_v) { if (lua_stdin_is_tty()) { print_version(); dotty(L); } else dofile(L, NULL); /* executes stdin as a file */ } return 0; } int main (int argc, char **argv) { int status = 0; struct Smain s; lua_State *L = lua_open(); /* create state */ if (L == NULL) { l_message(argv[0], "cannot create state: not enough memory"); return EXIT_FAILURE; } #ifdef USE_TECLA // Initialize Tecla gl = new_GetLine(16*1024, 2048); gl_configure_getline ( gl, "", "", "~/.otbApplicationLua" ); gl_load_history ( gl, "~/.otbApplication.history", "--" ); #endif s.argc = argc; s.argv = argv; try { status = lua_cpcall(L, &pmain, &s); report(L, status); lua_close(L); } catch (...) {} #ifdef USE_TECLA gl_save_history ( gl, "~/.otbApplication.history", "--", 1000 ); del_GetLine ( gl ); #endif return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS; } OTB-release-5.8/Modules/Wrappers/SWIG/src/otbWrapperSWIGIncludes.h000066400000000000000000000030551301006202600246530ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright: Centre National d'Etudes Spatiales, CS Systemes d'information. See OTBCopyright.txt, CSCopyright.txt for details. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef otbWrapperSWIGIncludes_h #define otbWrapperSWIGIncludes_h #include "otbWrapperApplicationRegistry.h" #include "otbWrapperAddProcessToWatchEvent.h" #include "otbWrapperDocExampleStructure.h" typedef otb::Wrapper::Application Application; typedef otb::Wrapper::Application::Pointer Application_Pointer; typedef otb::Wrapper::ApplicationRegistry Registry; typedef otb::Wrapper::AddProcessToWatchEvent AddProcessToWatchEvent; typedef otb::Wrapper::DocExampleStructure DocExampleStructure; typedef otb::Wrapper::Parameter Parameter; typedef otb::Wrapper::OutputImageParameter OutputImageParameter; typedef otb::Wrapper::InputImageParameter InputImageParameter; typedef otb::Wrapper::ComplexOutputImageParameter ComplexOutputImageParameter; typedef otb::Wrapper::ComplexInputImageParameter ComplexInputImageParameter; #endif OTB-release-5.8/Modules/Wrappers/SWIG/test/000077500000000000000000000000001301006202600203615ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/SWIG/test/CMakeLists.txt000066400000000000000000000001551301006202600231220ustar00rootroot00000000000000if (OTB_WRAP_PYTHON) add_subdirectory(python) endif() if (OTB_WRAP_JAVA) add_subdirectory(java) endif() OTB-release-5.8/Modules/Wrappers/SWIG/test/java/000077500000000000000000000000001301006202600213025ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/SWIG/test/java/CMakeLists.txt000066400000000000000000000064411301006202600240470ustar00rootroot00000000000000include( UseJava ) set(TEST_DRIVER otbTestDriver --add-before-env OTB_APPLICATION_PATH $ ) set( PATH_SEPARATOR ":") if (WIN32) set( PATH_SEPARATOR ";") # on windows, loading the module _otbApplication requires the otbossimplugins*.dll # which is in the 'bin' folder set(TEST_DRIVER ${TEST_DRIVER} --add-before-env PATH ${OTB_BINARY_DIR}/bin) endif() set( CMAKE_JAVA_INCLUDE_PATH ${OTBSWIGWrapper_BINARY_DIR}/src/org.otb.application.jar ) set( JAVA_COMMAND "${Java_JAVA_EXECUTABLE}" "-Djava.library.path=${OTB_BINARY_DIR}/Code/Wrappers/SWIG${PATH_SEPARATOR}$" ) add_jar( JavaSmoothingTest JavaSmoothingTest.java ) add_dependencies( JavaSmoothingTest org_otb_Application_jar ) add_dependencies( OTBSWIGWrapper-all JavaSmoothingTest ) add_test( NAME jaTvSmoothing COMMAND ${TEST_DRIVER} Execute ${Java_JAVA_EXECUTABLE} "-Djava.library.path=${OTB_BINARY_DIR}/Code/Wrappers/SWIG${PATH_SEPARATOR}$" -cp "${CMAKE_JAVA_INCLUDE_PATH}${PATH_SEPARATOR}${CMAKE_CURRENT_BINARY_DIR}/JavaSmoothingTest.jar" SmoothingTest ${OTB_DATA_ROOT}/Input/ToulouseExtract_WithGeom.tif ${TEMP}/jaTvSmoothing_ ) add_jar( JavaRescaleTest JavaRescaleTest.java ) add_dependencies( JavaRescaleTest org_otb_Application_jar ) add_dependencies( OTBSWIGWrapper-all JavaRescaleTest ) add_test( NAME jaTvRescale COMMAND ${TEST_DRIVER} Execute ${Java_JAVA_EXECUTABLE} "-Djava.library.path=${OTB_BINARY_DIR}/Code/Wrappers/SWIG${PATH_SEPARATOR}$" -cp "${CMAKE_JAVA_INCLUDE_PATH}${PATH_SEPARATOR}${CMAKE_CURRENT_BINARY_DIR}/JavaRescaleTest.jar" RescaleTest ${INPUTDATA}/poupees.tif ${TEMP}/jaTvRescaleTest.tif 20 150 ) add_jar( JavaRescaleOutXMLTest JavaRescaleOutXMLTest.java ) add_dependencies( JavaRescaleOutXMLTest org_otb_Application_jar ) add_dependencies( OTBSWIGWrapper-all JavaRescaleOutXMLTest ) add_test( NAME jaTvRescaleOutXML COMMAND ${TEST_DRIVER} Execute ${Java_JAVA_EXECUTABLE} "-Djava.library.path=${OTB_BINARY_DIR}/Code/Wrappers/SWIG${PATH_SEPARATOR}$" -cp "${CMAKE_JAVA_INCLUDE_PATH}${PATH_SEPARATOR}${CMAKE_CURRENT_BINARY_DIR}/JavaRescaleOutXMLTest.jar" RescaleOutXMLTest ${INPUTDATA}/poupees.tif ${TEMP}/jaTvRescaleOutXMLTest.tif 20 150 ${TEMP}/jaTvRescaleOutXMLTest.xml ) add_jar( JavaRescaleInXMLTest JavaRescaleInXMLTest.java ) add_dependencies( JavaRescaleInXMLTest org_otb_Application_jar ) add_dependencies( OTBSWIGWrapper-all JavaRescaleInXMLTest ) add_test( NAME jaTvRescaleInXML COMMAND ${TEST_DRIVER} Execute ${Java_JAVA_EXECUTABLE} "-Djava.library.path=${OTB_BINARY_DIR}/Code/Wrappers/SWIG${PATH_SEPARATOR}$" -cp "${CMAKE_JAVA_INCLUDE_PATH}${PATH_SEPARATOR}${CMAKE_CURRENT_BINARY_DIR}/JavaRescaleInXMLTest.jar" RescaleInXMLTest ${INPUTDATA}/jaTvRescaleInXMLTest.xml ${INPUTDATA}/poupees.tif ${TEMP}/jaTvRescaleInXMLTest.tif) OTB-release-5.8/Modules/Wrappers/SWIG/test/java/JavaRescaleInXMLTest.java000066400000000000000000000007601301006202600260400ustar00rootroot00000000000000/* * Example on the use of the Rescale with inxml */ import java.lang.Float; import org.otb.application.*; class RescaleInXMLTest { public static void main( String argv[] ) { Application app = Registry.CreateApplication("Rescale"); app.SetParameterString("inxml", argv[0]); app.UpdateParameters(); app.SetParameterString("in", argv[1]); app.SetParameterString("out", argv[2]); int result = app.ExecuteAndWriteOutput(); System.exit( result ); } } OTB-release-5.8/Modules/Wrappers/SWIG/test/java/JavaRescaleOutXMLTest.java000066400000000000000000000012041301006202600262330ustar00rootroot00000000000000/* * Example on the use of the Rescale with outxml */ import java.lang.Float; import org.otb.application.*; class RescaleOutXMLTest { public static void main( String argv[] ) { Application app = Registry.CreateApplication("Rescale"); app.SetParameterString("in", argv[0], true); app.SetParameterString("out", argv[1], true); app.SetParameterFloat ("outmin", Float.valueOf(argv[2]).floatValue(), true); app.SetParameterFloat ("outmax", Float.valueOf(argv[3]).floatValue(), true); app.SetParameterString("outxml", argv[4]); int result = app.ExecuteAndWriteOutput(); System.exit( result ); } } OTB-release-5.8/Modules/Wrappers/SWIG/test/java/JavaRescaleTest.java000066400000000000000000000024101301006202600251620ustar00rootroot00000000000000/* * Example on the use of the Rescale */ import java.lang.Float; import org.otb.application.*; class RescaleTest { public static void main( String argv[] ) { String[] appAvailable = Registry.GetAvailableApplications(); System.out.println( "Available applications :" ); for (int i = 0; i < appAvailable.length; i++) { System.out.println( " " + appAvailable[i] ); } System.out.println(); System.out.println( "Creating application " + "Rescale"); Application app = Registry.CreateApplication("Rescale"); System.out.println( "Created application Rescale"); System.out.println( "Rescale doc : " + app.GetDescription() ); String[] paramlist = app.GetParametersKeys(); System.out.println( ); System.out.println( "Rescale parameters : " ); for (int i = 0; i < paramlist.length; i++) { System.out.println( " " + paramlist[i] ); } System.out.println(); app.SetParameterString("in", argv[0]); app.SetParameterString("out", argv[1]); app.SetParameterFloat ("outmin", Float.valueOf(argv[2]).floatValue() ); app.SetParameterFloat ("outmax", Float.valueOf(argv[3]).floatValue() ); int result = app.ExecuteAndWriteOutput(); System.exit( result ); } } OTB-release-5.8/Modules/Wrappers/SWIG/test/java/JavaSmoothingTest.java000066400000000000000000000011421301006202600255540ustar00rootroot00000000000000/* * Example on the use of the Smoothing */ import org.otb.application.*; class SmoothingTest { public static void main( String argv[] ) { String[] appAvailable = Registry.GetAvailableApplications(); System.out.println( "Available applications :" ); for (int i = 0; i < appAvailable.length; i++) { System.out.println( appAvailable[i] ); } System.out.println( "Creating application " + "Smoothing"); Application app = Registry.CreateApplication("Smoothing"); System.out.println( Registry.CreateApplication("Smoothing").GetDescription() ); } } OTB-release-5.8/Modules/Wrappers/SWIG/test/python/000077500000000000000000000000001301006202600217025ustar00rootroot00000000000000OTB-release-5.8/Modules/Wrappers/SWIG/test/python/Bug440.py000066400000000000000000000007631301006202600232270ustar00rootroot00000000000000# Import the otb applications package import sys def test(otbApplication, argv): # The following line creates an instance of the Convert application Convert = otbApplication.Registry.CreateApplication("Convert") # The following lines set all the application parameters: Convert.SetParameterString("in", argv[1]) Convert.SetParameterString("out", argv[2]) Convert.SetParameterString("type","linear") # The following line execute the application sys.exit(Convert.ExecuteAndWriteOutput()) OTB-release-5.8/Modules/Wrappers/SWIG/test/python/Bug736.py000066400000000000000000000012321301006202600232270ustar00rootroot00000000000000 def test(otbApplication, argv): RadiometricIndices = otbApplication.Registry.CreateApplication('RadiometricIndices') RadiometricIndices.SetParameterString("in", argv[1]) RadiometricIndices.SetParameterString("out", argv[2]) RadiometricIndices.SetParameterInt("channels.red", 3) RadiometricIndices.SetParameterInt("channels.green", 2) RadiometricIndices.SetParameterInt("channels.nir", 4) RadiometricIndices.SetParameterStringList("list", ["Vegetation:NDVI","Vegetation:RVI","Vegetation:IPVI"]) print( RadiometricIndices.GetParameterStringList("list") ) print( RadiometricIndices.GetParameterValue("list") ) RadiometricIndices.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/Bug804.py000066400000000000000000000003021301006202600232200ustar00rootroot00000000000000def test(otb, argv): app = otb.Registry.CreateApplication('TrainImagesClassifier') app.SetParameterFloat('classifier.libsvm.opt',True) print( app.GetParameterValue('classifier.libsvm.opt') ) OTB-release-5.8/Modules/Wrappers/SWIG/test/python/Bug823.py000066400000000000000000000004231301006202600232250ustar00rootroot00000000000000from sys import exit def test(otb, argv): app = otb.Registry.CreateApplication('Rasterization') try: app.GetParameterInt('szx') except RuntimeError, e: print( "Exception message : " + e.args[0] ) if e.args[0].startswith("boost::bad_any_cast"): exit(1) exit(0) OTB-release-5.8/Modules/Wrappers/SWIG/test/python/CMakeLists.txt000066400000000000000000000076161301006202600244540ustar00rootroot00000000000000set(TEST_DRIVER otbTestDriver --add-before-env PYTHONPATH "${OTBSWIGWrapper_BINARY_DIR}/src" --add-before-env PYTHONPATH $ --add-before-env OTB_APPLICATION_PATH $ ) if(WIN32) # on windows, loading the module _otbApplication requires the otbossimplugins*.dll # which is in the 'bin/' folder set(TEST_DRIVER ${TEST_DRIVER} --add-before-env PATH ${CMAKE_BINARY_DIR}/bin --add-before-env PATH $) endif(WIN32) add_test( NAME pyTvSmoothing COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonSmoothingTest ${OTB_DATA_ROOT}/Input/ToulouseExtract_WithGeom.tif ${TEMP}/pyTvSmoothing_ ) add_test( NAME pyTvRescale COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonRescaleTest ${OTB_DATA_ROOT}/Input/ToulouseExtract_WithGeom.tif ${TEMP}/pyTvRescale) add_test( NAME pyTvHyperspectralUnmixingUCLS COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonHyperspectralUnmixing1 ${OTB_DATA_ROOT}/Input/Hyperspectral/synthetic/hsi_cube.tif ${TEMP}/pyTvHyperspectralUnmixing_ucls.tif ${OTB_DATA_ROOT}/Input/Hyperspectral/synthetic/endmembers.tif ucls ) add_test( NAME pyTvBug440 COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py Bug440 ${OTB_DATA_ROOT}/Input/scene.png ${TEMP}/pyTvBug440Output.tif ) add_test( NAME pyTvBug804 COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py Bug804 ) add_test( NAME pyTvBug823 COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py Bug823 ) add_test( NAME pyTvBug736 COMMAND ${TEST_DRIVER} --compare-image ${NOTOL} ${BASELINE}/apTvRIRadiometricVegetationIndices.tif ${TEMP}/pyTvBug736Output.tif Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py Bug736 ${OTB_DATA_ROOT}/Input/veryverySmallFSATSW.tif ${TEMP}/pyTvBug736Output.tif ) add_test( NAME pyTvBandMathOutXML COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonOutXMLTest ${OTB_DATA_ROOT}/Input/verySmallFSATSW_r.tif ${OTB_DATA_ROOT}/Input/verySmallFSATSW_nir.tif ${OTB_DATA_ROOT}/Input/verySmallFSATSW.tif ${TEMP}/pyTvBandMathOutXML.tif ${TEMP}/pyTvBandMathOutXML.xml ) add_test( NAME pyTvBandMathInXML COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonInXMLTest ${INPUTDATA}/pyTvBandMathInXML.xml ${OTB_DATA_ROOT}/Input/verySmallFSATSW_r.tif ${OTB_DATA_ROOT}/Input/verySmallFSATSW_nir.tif ${OTB_DATA_ROOT}/Input/verySmallFSATSW.tif ${TEMP}/pyTvBandMathInXML.tif ) add_test( NAME pyTvNumpyIO COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonNumpyTest ${OTB_DATA_ROOT}/Examples/ROI_QB_MUL_1_SVN_CLASS_MULTI.png ${TEMP}/pyTvNumpyIO_SmoothingOut.png ) add_test( NAME pyTvNewStyleParameters COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonNewStyleParametersTest ${OTB_DATA_ROOT}/Input/poupees.tif ${TEMP}/pyTvNewStyleParametersTest.tif ${OTB_DATA_ROOT}/Input/apTvUtSmoothingTest_OutXML.xml) add_test( NAME pyTvNewStyleParametersInstantiateAll COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonNewStyleParametersInstantiateAllTest ) add_test( NAME pyTvConnectApplications COMMAND ${TEST_DRIVER} Execute ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/PythonTestDriver.py PythonConnectApplications ${OTB_DATA_ROOT}/Input/poupees.tif ${TEMP}/pyTvConnectApplicationsOutput.tif) OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonConnectApplications.py000066400000000000000000000012521301006202600274160ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # Example on the use of the Rescale # def test(otb, argv): app1 = otb.Registry.CreateApplication("Smoothing") app2 = otb.Registry.CreateApplication("Smoothing") app3 = otb.Registry.CreateApplication("Smoothing") app4 = otb.Registry.CreateApplication("ConcatenateImages") app1.IN = argv[1] app1.Execute() app2.SetParameterInputImage("in",app1.GetParameterOutputImage("out")) app2.Execute() app3.IN = argv[1] app3.Execute() app4.AddImageToParameterInputImageList("il",app2.GetParameterOutputImage("out")); app4.AddImageToParameterInputImageList("il",app3.GetParameterOutputImage("out")); app4.OUT = argv[2] app4.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonHyperspectralUnmixing1.py000066400000000000000000000006341301006202600301060ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # Example on the use of the Rescale # def test(otb, argv): app = otb.Registry.CreateApplication("HyperspectralUnmixing") # input image app.SetParameterString("in", argv[1]) #output image app.SetParameterString("out", argv[2]) #input endmembers app.SetParameterString("ie", argv[3]) #unmixing algorithm app.SetParameterString("ua", argv[4]) app.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonInXMLTest.py000066400000000000000000000005551301006202600252520ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # Example on the use of the inxml via BandMath # def test(otb, argv): app = otb.Registry.CreateApplication('BandMath') app.SetParameterString("inxml", argv[1]) app.UpdateParameters() imagelist = argv[2:-1] app.SetParameterStringList("il", imagelist, True) app.SetParameterString("out" , argv[-1]) app.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonNewStyleParametersInstantiateAllTest.py000066400000000000000000000006161301006202600327540ustar00rootroot00000000000000import operator import inspect def test(otb, argv): # List applications appNames = [app for app in otb.Registry.GetAvailableApplications()] for appName in appNames: app = otb.Registry.CreateApplication(appName) # Generate parameters parameters = app.GetParametersKeys() for param in parameters: upParam = param.upper() if app.HasValue(param): operator.attrgetter(upParam)(app) OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonNewStyleParametersTest.py000066400000000000000000000072351301006202600301230ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Authors: Rashad Kanavath # Julien Malik # # Copyright: (c) CS Systemes d'information. All rights reserved # # Example on the use of otb "pythonization" # def cm_assert(a,b): print "debug print before assert check: '%s'== '%s'" %(a, b) assert a == b def test(otb, argv): app = otb.Registry.CreateApplication('OrthoRectification') # test GetParameterTypeAsString() method in python. print( app.GetParameterTypeAsString(otb.ParameterType_InputImage) ) print( app.GetParameterTypeAsString(otb.ParameterType_String) ) print( app.GetParameterTypeAsString(otb.ParameterType_Empty) ) # one test for each parameter type (string, float, int, ...) # # parameter group io.in # 1 - input image parameter set app.IO.IN = argv[1] cm_assert(app.GetParameterString('io.in'), argv[1]) # 2 - input image parameter get cm_assert(app.IO.IN, argv[1]) # # parameter group io.in # 3 - output image parameter set app.IO.OUT = argv[2] cm_assert(app.GetParameterString('io.out'), argv[2]) # 4 - output image parameter get cm_assert(app.IO.OUT, argv[2]) # 5 - choice with sub parameters set app.MAP = 'lambert2' cm_assert(app.GetParameterString('map'), 'lambert2') # 5.1 - choice with sub parameters get app.SetParameterString('map', 'wgs') cm_assert('wgs', app.MAP) # 5.2 - choice with sub parameters set app.MAP = 'lambert93' cm_assert('lambert93', app.GetParameterString('map')) # 5.3 - choice with sub parameters set app.SetParameterString('map', 'epsg') cm_assert(app.MAP, 'epsg') # 6 - int type 2nd level sub parameters of choice parameter set app.MAP.EPSG.CODE = 32768 cm_assert(32768, app.GetParameterInt('map.epsg.code')) # 7 - another choice with sub parameters set app.MAP = 'utm' cm_assert('utm', app.GetParameterString('map')) # 8 - int type sub parameters of choice parameter set app.MAP.UTM.ZONE = 47 cm_assert(47,app.GetParameterInt('map.utm.zone')) # 9 - int type sub parameters of choice parameter get app.SetParameterInt('map.utm.zone', 31) cm_assert(app.MAP.UTM.ZONE, 31) # 10 - bool type sub parameters of choice parameter get app.DisableParameter('map.utm.northhem') cm_assert(app.MAP.UTM.NORTHHEM, False) # 11 - bool type sub parameters of choice parameter set app.MAP.UTM.NORTHHEM = True cm_assert(True, app.IsParameterEnabled('map.utm.northhem') ) #12 - simple choice parameter set app.OUTPUTS.MODE = 'auto' cm_assert('auto', app.GetParameterString('outputs.mode')) #13 - simple choice parameter get app.SetParameterString('outputs.mode', 'orthofit') cm_assert(app.OUTPUTS.MODE, 'orthofit') #14 - inputxml parameter set app.INXML = argv[3] cm_assert(app.GetParameterString('inxml'), argv[3]) #15 - outputxml parameter get app.SetParameterString('outxml', 'output.xml') cm_assert("output.xml", app.OUTXML) #16 - parameter float get app.SetParameterFloat('elev.default', 5.0) cm_assert(5.0, app.ELEV.DEFAULT) #17 -parameter float set app.ELEV.DEFAULT = -2.5 cm_assert(app.GetParameterFloat('elev.default'), -2.5) #18 - parameter ram get app.SetParameterString('opt.ram', '256') cm_assert(256, app.OPT.RAM) #19 - parameter ram set app.OPT.RAM = '512' cm_assert(app.GetParameterInt('opt.ram'), 512) #20 - parameter bool set app.OUTPUTS.ISOTROPIC = True cm_assert(app.IsParameterEnabled('outputs.isotropic'), True) #21 - parameter bool get app.DisableParameter('outputs.isotropic') cm_assert(False, app.OUTPUTS.ISOTROPIC) #Do not execute. we need LARGEINPUT. so we tried a small application #app.Execute() app = None app = otb.Registry.CreateApplication('Smoothing') app.IN = argv[1] app.TYPE='anidif' app.OUT = argv[2] app.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonNumpyTest.py000066400000000000000000000041431301006202600254300ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Author: Rashad Kanavath # # Copyright: (c) CS Systemes d'information. All rights reserved # # Example on testing numpy # import os #from scipy import misc import numpy as np def test(otbApplication, argv): #from PIL import Image as PILImage inFile = argv[1] outFile = argv[2] # pilimage = PILImage.open(inFile) # npimage = np.asarray(pilimage) # print npimage.dtype ExtractROI = otbApplication.Registry.CreateApplication("ExtractROI") ExtractROI.SetParameterString("in", inFile) ExtractROI.SetParameterInt("startx", 10) ExtractROI.SetParameterInt("starty", 10) ExtractROI.SetParameterInt("sizex", 250) ExtractROI.SetParameterInt("sizey", 250) #Bug or Design ?. #Anyway below two is needed only for ExtractROI application ExtractROI.SetParameterUserValue("sizex", True) ExtractROI.SetParameterUserValue("sizey", True) ExtractROI.Execute() ExtractROIOut = ExtractROI.GetVectorImageAsNumpyArray("out", 'float') #write RGB image to file via python #misc.imsave('ExtractROIOut.jpg', ExtractROIOut) Rescale = otbApplication.Registry.CreateApplication("Rescale") #take numpy array from ExtractROI and feed into Rescale Rescale.SetVectorImageFromNumpyArray("in", ExtractROIOut) Rescale.SetParameterFloat("outmin", 50, True) Rescale.SetParameterFloat("outmax", 100, True) Rescale.Execute() RescaleOut = Rescale.GetVectorImageAsNumpyArray("out", 'float') # misc.imsave('RescaleOut.jpg', RescaleOut) Convert = otbApplication.Registry.CreateApplication("Convert") # take numpy output from Rescale application and feed into Convert Convert.SetVectorImageFromNumpyArray("in", RescaleOut) Convert.SetParameterString("out", "ConvertOut.png") Convert.ExecuteAndWriteOutput() ConvertOut = Convert.GetVectorImageAsNumpyArray("out", 'float') Smoothing = otbApplication.Registry.CreateApplication("Smoothing") # take numpy output from Convert application and feed into Smoothing Smoothing.SetVectorImageFromNumpyArray("in", ConvertOut) Smoothing.SetParameterString("type", 'anidif') Smoothing.SetParameterString("out", outFile) Smoothing.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonOutXMLTest.py000066400000000000000000000011471301006202600254510ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # Example on the use of the outxml via BandMath # def test(otb, argv): imagelist = argv[1:-2] exp = "cos(im1b1)+im2b1*im3b1-im3b2+ndvi(im3b3, im3b4)" out = argv[-2] outxml = argv[-1] app = otb.Registry.CreateApplication('BandMath') app.SetParameterStringList("il", imagelist, True) app.SetParameterString("out", out, True) app.SetParameterString("exp", exp, True) app.SetParameterString("outxml", outxml, True) app.UpdateParameters() #for paramKey in app.GetParametersKeys(): #app.GetParameterValue(paramKey) #print app.HasUserValue(paramKey) app.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonRescaleTest.py000066400000000000000000000005071301006202600256760ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # Example on the use of the Rescale # def test(otb, argv): app = otb.Registry.CreateApplication("Rescale") app.SetParameterString("in", argv[1]) app.SetParameterFloat("outmin", 1) app.SetParameterFloat("outmax", 100) app.SetParameterString("out", argv[2] + ".tif") app.ExecuteAndWriteOutput() OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonSmoothingTest.py000066400000000000000000000010171301006202600262640ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # Example on the use of the Smoothing # def test(otb, argv): print( "Available applications : " + str(otb.Registry.GetAvailableApplications()) ) app = otb.Registry.CreateApplication("Smoothing") print( app.GetParametersKeys() ) app.SetParameterString("in", argv[1]) for type_ in ['mean', 'gaussian', 'anidif']: print( 'Testing ' + type_ ) app.SetParameterString("type", type_) app.SetParameterString("out", argv[2] + type_ + ".tif") app.ExecuteAndWriteOutput() print( dir(app) ) OTB-release-5.8/Modules/Wrappers/SWIG/test/python/PythonTestDriver.py000066400000000000000000000011321301006202600255460ustar00rootroot00000000000000# -*- coding: utf-8 -*- # https://mail.python.org/pipermail//cplusplus-sig/2011-September/016145.html import os import sys if os.name == 'posix': orig_dlopen_flags = sys.getdlopenflags() try: import dl except ImportError: try: import DLFCN as dl except ImportError: dl = None if dl: sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL) # now load the module ! import otbApplication as otb sys.setdlopenflags(orig_dlopen_flags) del dl del orig_dlopen_flags else: import otbApplication as otb t = __import__(sys.argv[1]) argv = sys.argv[1:] t.test(otb, argv) OTB-release-5.8/README.md000066400000000000000000000045541301006202600147050ustar00rootroot00000000000000# ![OTB](https://git.orfeo-toolbox.org/otb.git/blob_plain/HEAD:/Utilities/Doxygen/logoVectoriel.png) Orfeo Toolbox ## Open Source processing of remote sensing images Orfeo ToolBox (OTB) is an open-source project for state-of-the-art remote sensing. Built on the shoulders of the open-source geospatial community, it can process high resolution optical, multispectral and radar images at the terabyte scale. A wide variety of applications are available: from ortho-rectification or pansharpening, all the way to classification, SAR processing, and much more! All of OTB's algorithms are accessible from Monteverdi, QGIS, Python, the command line or C++. Monteverdi is an easy to use visualization tool with an emphasis on hardware accelerated rendering for high resolution imagery (optical and SAR). With it, end-users can visualize huge raw imagery products and access all of the applications in the toolbox. From resource limited laptops to high performance MPI clusters, OTB is available on Windows, Linux and Mac. It is community driven, extensible and heavily documented. Orfeo ToolBox is not a black box! [![Travis Build Status](https://travis-ci.org/orfeotoolbox/OTB.png?branch=develop)](https://travis-ci.org/orfeotoolbox/OTB) [![Coverity Scan Build Status](https://scan.coverity.com/projects/2405/badge.svg)](https://scan.coverity.com/projects/orfeo-toolbox) ### Resources * [OTB's website](https://www.orfeo-toolbox.org/) * [Documentation](https://www.orfeo-toolbox.org/documentation/) * [Downloads](https://www.orfeo-toolbox.org/download/) * [Public git repositories](https://git.orfeo-toolbox.org/) * [GitHub mirror](https://github.com/orfeotoolbox/) * [Build status](http://dash.orfeo-toolbox.org/index.php?project=OTB) * [Bug tracker](https://bugs.orfeo-toolbox.org/) * [Wiki](http://wiki.orfeo-toolbox.org/index.php/Main_Page) * [Task tracking](http://scrum.orfeo-toolbox.org) ### Join the community Get help, share your experience and contribute to the Orfeo-Toolbox project by joining our community and mailing lists. [https://www.orfeo-toolbox.org/community/](https://www.orfeo-toolbox.org/community/) ### Contributing Please see the wiki for contributors guidelines. ### License Please see the license and the Copyright directory for legal issues on the use of the software. ### Issues Please report any issue you might encouter to [our bugtracker](http://bugs.orfeo-toolbox.org). OTB-release-5.8/RELEASE_NOTES.txt000066400000000000000000003777561301006202600162400ustar00rootroot00000000000000OTB-v.5.8.0 - Changes since version 5.6.1 (November 8th, 2016) -------------------------------------------------------------- * Request for Changes (http://wiki.orfeo-toolbox.org/index.php/Requests_for_Changes): * Request for Changes-35: FineRegistration, performances increased * Request for Changes-51: Move Monteverdi into OTB * Request for Changes-52: Faster BandMathX * Request for changes-53: Connect applications in memory * Request for Changes-54: Get OTB ready for gdal derived subdatasets * Request for Changes-55: Monteverdi: Mouse-wheel zoom without CTRL * Request for Changes-56: Spot7 metadata support * Request for Changes-57: Migrate Cookbook to RST * Request for Changes-58: Sampling on multiple images * Request for Changes-59: Build support for msvc 2015 with OTB xdk * Request for Changes-60: Shorter Release Process * Request for Changes-61: Use codespell to fix common misspellings in source code * Request for Changes-62: Enhance text comparison in dashboard * Request for Changes-63: Refactor threading mechanism in sampling filters * Request for Changes-64: Missing RAM for persistent filters in application * Request for Changes-65: Add Shark Random forests implementation * Request for Changes-67: ClassificationMapRegularization option for isolated pixels only * Request for Changes-68: New sampling strategies in classification framework * Bugfixes : * Monteverdi * 0001298: Monteverdi crash with this image * 0001305: SuperBuild falling at BOOST build step * 0001283: GDAL overviews dialog pops under OTB-applications dock * 0001284: GDAL overviews default min-size = 4096 px * 0001282: Status-bar is not always disable at startup * 0001278: Add force OpenGL 1.x compatibility option * 0001267: Monteverdi: unclear "gdal overview" minimum size parameter * 0001274: SuperBuild GLUT compilation problem * 0001277: Missing icon(s) in color-dynamics widget * 0001275: Monteverdi: Histogram view problem with binary image * 0001300: monteverdi $input_filename crash with relative path * 0001303: Memory issue in Monteverdi with images with subdatasets (HDF4) * 0001299: Monteverdi shortcuts list needs some updates * 0001291: Word "Échiquier" is not displayed properly in layer stack (effect column) * OTB-Packaging * 0001290: Unable to run OTB applications from Mapla.app on Mac OS X * 0001297: No translation files in Windows standalone package (branch release-5.8) * Orfeo Toolbox (OTB) * 0001308: Typo in otbenv.profile and otbenv.cmd * 0001286: Sentinel-1 sensor metadata are not retrieved properly if application is run inside the SAFE directory * 0001287: Using S1 images in monteverdi is slow * 0001268: Patch for spelling error in 5.6.1 * 0001306: SuperBuild falling at TIFF build step (GLUT_Xmu_LIBRARY NOTFOUND) * OTB-applications * 0001301: Mapla application does not provide translation files OTB-v.5.6.1 - Changes since version 5.6.0 (August 26th, 2016) ------------------------------------------------------------- * Bugfixes : * 0001262: OTB 5.7 vector sampler bug * 0001259: Patch for various spelling errors in 5.6.0 * 0001258: Patch to only use OTB_GIT_STATUS_MESSAGE in message function if set. * 0001266: Fix covariance computation with high float values OTB-v.5.6.0 - Changes since version 5.4.0 (July 28th, 2016) ------------------------------------------------------------ * Request for Changes (http://wiki.orfeo-toolbox.org/index.php/Requests_for_Changes): * Request for Changes-49: Improve classification on vectors * Request for Changes-48: Add geometric correction to S1 Sensor Model * Request for Changes-47: Improve the CompareImages app * Request for Changes-46: Sample extractor * Request for Changes-45: CMake uninstall target * Request for Changes-43: Update SuperBuild cmake script and thirdparty versions * Request for Changes-42: Generator for completion scripts * Request for Changes-40: clang modernize * Request for Changes-41: Provide a summary after cmake configuration * Request for Changes-38: update gdal to 2.x version in superbuild * Request for Changes-37: Enhance ManageNodata application * Request for Changes-36: Samples selection filter * Request for Changes-26: MPI Image File Writer * Bugfixes: * MANTIS-1255: Remaining log when opening Sentinel1 product in Monteverdi * MANTIS-1254: Checking/Unchecking parameters re-enable execute button on running application * MANTIS-1252: msvc warning C4838 la conversion de 'double' en 'const float' requiert une conversion restrictive * MANTIS-1251: OTB Superbuild does not forward compiler versions to external projects anymore * MANTIS-1249: ioTvMultiChannelROI_*_JPEG2000_2_TIF_res5 are failing when using gdal openjpeg driver * MANTIS-1247: Patch for various spelling errors * MANTIS-1246: Inputs do not occupy the same physical space! * MANTIS-1243: apTvCl*RegressionTest_monovar failing due to error in opencv * MANTIS-1242: otbMapProjectionAdapter.cxx WARNING: Impossible to create the projection from Wkt: ossimUtmProjection * MANTIS-1241: dl_close appears on apTvClTrainMethodANNImagesClassifierQB1 * MANTIS-1240: [ComputeImagesStatistics] Filename extension in uppercase are not supported * MANTIS-1238: Train regression with ANN crashes * MANTIS-1237: Inconsistent parameter order in OTB application * MANTIS-1234: more tests are failing in superbuild * MANTIS-1233: Exception in example Examples/Learning/TrainMachineLearningModelFromSamplesExample.cxx * MANTIS-1227: set all USE_SYSTEM_* to FALSE by default * MANTIS-1225: internal openjpeg driver and confusing OTB_USE_OPENJPEG * MANTIS-1223: Possible error in function "template T InverseValue(const T & value)" defined in otbMath.h * MANTIS-1220: show last git commit message during cmake configure * MANTIS-1218: Segmentation fails - error message not understandable * MANTIS-1217: Degree symbol badly displayed in OTB applications * MANTIS-1215: OTB-FAQ page not found contribute.html (404) * MANTIS-1214: incorrect install instruction for Mac OSX in OTBCookBook 5.4 * MANTIS-1213: incorrect years calculated in cookbook * MANTIS-1212: OTB windows package contains two copies of otbapp_* dll * MANTIS-1211: Patch for various spelling errors * MANTIS-1210: make fails at downloading 'LIBSVM' * MANTIS-1209: superbuild: fix qt build on osx * MANTIS-1208: Need to click in image view to force computation of quantiles (shortcut 'Q') * MANTIS-1207: OTB_SB_CMAKE_COMMAND uses in External_otb.cmake but not set OTB-v.5.4.0 - Changes since version 5.2.1 (2016/05/04) ------------------------------------------ * Core * Ice is now a regular OTB module (RFC 23) * Masked iterator decorator (RFC 22) * Filter to analyse polygons for available samples (part of new sampling framework, RFC 29) * Faster resampling filter for rigid scaling and translation operations (RFC 30) * Modified behavior of reading/writing of TIFF RPC tags (RFC 31) * Allow a module to be built outside the OTB source tree (RFC 32) * Dashboard cleaning, part 1 (RFC 33) * Enhancement of SARDecompositions : Barnes, Huynen, Pauli decompositions (RFC 34) * Monteverdi * Take screenshot of current display (RFC 20) * Allow subdatasets import (RFC 21) * Disable GLSL shader if OpenGL version is lower than 2.0 (RFC 25) * Allow generation of gdal overviews when importing images (RFC 24) * Documentation: * Merge software guide into main OTB repository (RFC 17) * Remove random contributor list generation (RFC 28) * SuperBuild: * Add Monteverdi and its dependencies (glfw, GLEW, glut) * Bug fixed * Monteverdi2 * 0001179: Using the Upper Bound mode for resolution lookup in preferences result in wrong resolution used * 0001197: Clicking on minimap to navigate result in monteverdi crashing * 0001178: Zoom to full resolution does not zoom to 1 image pixel = 1 screen pixel for georeferenced data * 0001203: Clicking on 1:1 button several time result in strange cycling behaviour * 0001205: Gamma slider effect inverted between full and quicklook view * 0001202: Wrong aspect ratio at loading * 0001148: OTB-applications not loaded * 0001196: OTB-application Quit button closes widget but not window when using Mapla * 0001147: With Monteverdi develop branch of today : opening large images with overview file leads to eating all available memory * 0001138: Numeric value editing hell * 0001136: Unable to open sensor products (with RPC) in Monteverdi * 0001159: TrainImageClassifier sample.vtr parameter is sometime ignored * 0001173: KDE grabs drag event before monteverdi, making image navigation impossible * 0001144: Unable to keep unconstrained dynamic mode * 0001156: Linux standalone package doesn't work on Fedora 22 * 0001157: monteverdi crashes when trying to move the view without any images * 0001153: Superimpose app in PHR mode reports wrong origin/spacing/keywordlist * 0001154: Exception raised when opening LUM or LUM+HDR * 0001152: maximum number of class in KMean application limited to 255 * 0001140: Lost pixel position information in layer stack * OTB-Packaging * 0001141: muparser 2.2.4 is missing in superbuild archive 5.2.1 * 0001171: Crash in OGR : libproj-0.dll not found * 0001150: Can't "easily" deactivate LIBKML from OTB Superbuild * Orfeo Toolbox (OTB) * 0001206: Cannot maximize monteverdi window in standalone package * 0001177: SuperBuild fails at MVD configure step (release-5.4 branch) * 0001194: freeglut required x11 extension on osx * 0001188: deactivate openldap, openssl, libssh2 when building superbuild curl. * 0001190: use same compiler for all builds in the superbuild * 0001184: superbuild libtiff is using libjbig from system without warning * 0001185: minimal build of GDAL in superbuild * 0001187: superbuild cannot find Qt4 during OTB configure on osx * 0001193: deactivate finding osx framework for library * 0001163: Windows MinGW packages do not contain the libsvm classifier * 0001164: Monteverdi crashes when opening a tif without projection information * 0001167: GUI applications visual response after clicking the "Execute" button is slow and confusing * 0001158: Missing field in RefineSensorModel statistics file * 0001166: otbgui_MeanShiftSmoothing problem with Mode Search parameter * 0001169: add libsvm package to mxe and enable OTB_USE_LIBSVM * 0001143: Patch for various spelling errors * 0001151: GDAL_SB_EXTRA_OPTIONS can not take multiple options * 0001142: Fails to build with ITK 4.9.0 (itksys/FundamentalType.h: No such file or directory) * OTB-lib * 0001145: Ice doesn't clamp rendered values to the specified minimum of the range * 0001139: OGRLayerStreamStitchingFilter CommitTransaction fail is some cases * 0001137: GDALImageIO does not support SENTINEL2 sub-datasets * OTB-applications * 0001149: ReadImageInfo application crash with Sentinel1 (SLC SM product) * 0001162: Unable to perform Sentinel-1 SAR calibration on extract * 0001183: Unable to edit image path in Qt GUI wrapper with complex image * 0001182: Crash when editing InputImageParameter Qt widget * 0001161: Inconsistency of SAR calibration applications denomination OTB-v.5.2.1 - Changes since version 5.2.0 (2016/01/19) ------------------------------------------ * Bugs fixed: * Mantis-1124: fix the use of Update_command and reorder the patch commands properly * Fix some Coverity reports * Superbuild: * Update OSSIM to latest stable and improve version checking during CMake configuration * Monteverdi: * Mantis-1096: QuicklookView * Mantis-1125: Use OTB_APPLICATION_PATH in startup files * Other: * Apply spelling patch from DebianGIS * Find only required itk components. Patch proposed by Debian. * Fix mxe gcc dir and list of system dlls exceptions OTB-v.5.2.0 - Changes since version 5.0.0 (2015/12/22) ------------------------------------------ * Library (the corresponding requests for changes are mentioned): * Core * Read, write and manage no-data flags (RFC-1 & RFC-14) * Improve otb::DEMHandler interface (RFC-2) * Build examples based on available modules in OTB installation (RFC-3) * Helper functions for string operations using boost (RFC-6) * Gdal 2.0 support (RFC-11) * Enhancement of python wrapping (RFC-12) * Machine Learning * Provide quality index for classification * Regression mode in OTB and OTBApp (RFC-7) * SAR * Add basic support for Sentinel1 Product (RFC-4) * Update SAR radiometric calibration application in OTB (RFC-9) * New applications for SAR processing (RFC-10) * Applications * Improve ApplicationRegistry for application loading (RFC-15) * Provide a default output pixel type in applications (RFC-17) * SuperBuild * Provide a script to build the all-in-one SuperBuild archive (RFC-5) * Upgrade dependencies versions in SuperBuild (RFC-19) * New dependency : Freetype 2.6 * ITK 4.7.1 -> 4.8.1 * JPEG v9a -> turbo 1.4.1 * OpenThreads 3.2 -> 3.4 * Ossim r23092 -> r23537 * GeoTIFF 1.4.0 -> 1.4.1 * muParser 2.2.3 -> 2.2.5 * OpenCV 2.4.10 -> 2.4.11 * OpenSSL 1.0.1e -> 1.0.1p * Qt 4.8.6 -> 4.8.7 * Swig 3.0.5 -> 3.0.7 * TIFF 4.0.3 -> 4.0.6 * Bug fixed: * Monteverdi2 * 0001120: Unwanted zoom-to-extent when loading second image * 0001103: OutputProcessXMLParameter pre-initialization used even if disabled. * 0001111: Geoid-file 5 * 0001090: SuperBuild Openthread download link broken * 0001081: GDAL RPC tags export prevent correct export of wkt in ortho-rectified image * 0001056: ComputeImagesStatistics applications produces incorrect std * 0001093: CMake with Ninja generator configure fails when OTB_USE_QT4=ON * 0001084: Deactivate all 3rd part components in OpenCV configuration * 0001077: Superbuild: Broken open scene graph archive link * 0001069: Unable to install gdal python bindings in custom install directory with OTB Superbuild * 0001065: Build OTB Examples based on available modules in OTB installation * 0001075: prTeEstimateRPCSensorModelExampleTest always failing in examples * 0001074: Missing ITCopyright.txt in OTB sources * 0001066: missing file(Capitole-Shadows) from OTB-Data * 0001055: SuperBuild builds ogr2ogr without sqlite driver * OTB-lib * 0001082: ImageFileReader<> crashes after ApplicationRegistry::RefreshApplicationFactories() is called * 0001098: Exception raised when typing in input process XML parameter * 0001097: Cannot manually type in input vector data line-edit. * 0001085: Add a ::GetInput() accessor to QtWidgetOutputImage/FilenameParameter * 0001083: Extended filename parameters not updated when calling ImageFileReader<>::SetFileName() several times * 0001078: Exception thrown (OTB-Ice) when opening image without projection info * 0001071: Add otb::DEMHandler ::ClearDEMDirectory() and ::ClearGeoidFile() interface. * OTB-applications * 0001119: Band Math X cannot manage large neighborhood (>=25x25 pixels) * 0001112: File not found if filename contains accents when using GUI * 0001059: Input and output image parameters require absolute path * 0001076: Application ComputeImagesStatistics gives wrong standard deviation OTB-v.5.0.0 - Changes since version 4.4.0 (2015/05/28) ------------------------------------------ * Library: * Modularization * Code is now better organized in groups/modules/classes * ITK CMake architecture to handle module and dependencies is used * Modules can be deactivated at will with dependencies tracking * Third parties software are handled as module and can be deactivated * Tests and applications are embedded in modules * Writing of new module or update of existing modules is simplified by cmake magic * Remove deprecated code * MeanShiftVectorImageFilter and MeanShiftImageFilter classes * CommandLineLauncher(const char * exp) and Load( const std::string & exp ) methods in CommandLineLauncher class * ThirdParties * No more internal versions of most third parties (except 6S, siftfast, ossimplugins) * Removed openjpeg sources from OTB source * Removed LibSVM sources from OTB source * Removed Edison sources from OTB source * Removed ConfigFile sources from OTB source * Removed LibKML sources from OTB source * Add support for external openjpeg 2.1 * Third parties copyrights have been cleaned * Superbuild * A separate superbuild project has been added in the Superbuild repository * This download, configure and build all OTB dependencies from source and then build OTB. It replaces the removed internal versions. * Sources are checked out at configuration time or can be downloaded beforehand * Allow building a complete OTB with a handful of prerequisites (gcc, cmake, curl) * Doxygen * Classes are now organized by modules * Direct link to official ITK doxygen * Bug fixed: * Monteverdi2 * 0001033: Crash when updating no data value in mv2 * Documentation * 0001028: URL for online application documentation is not available anymoreon the orfeo website * 0001006: GetPixel is missing on the otb::Image page * OTB-lib * 0001039: ITK patches are not always used * 0001045: StreamingStatisticsMapFromLabelImageFilter can't be templated with otb::Image as support image * 0001023: malloc error in otb::SVMModel destructor * 0001041: Optimization of Band Math Image Filter (from 60M cycles to 40M cycles) * 0001040: Optimization of Concatenate VectorImage Filter (from 28M cycles to 8M cycles) * 0001043: Optimization of Multi to Mono Channel Extract ROI (from 8M cycles to 3M cycles) * 0001011: Need safeguards to test for ExtendedFilename parameters * 0001035: Unexpected maximum number of reader instances with open-jpeg driver * 0001022: RefineSensorModel Segfault * 0001042: Optimization of Image to VectorImage Cast Filter (from 47M cycles to 7M cycles) * 0000005: can not read unsigned char three channels data into otb::Image properly * OTB-Packaging * 0001027: [ubuntugis package] OTB Applications in Ubuntu package do not use custom version of ITK UnaryFunctorImageFilter * 0001010: OTB MXE binary package is buggy * Orfeo Toolbox (OTB) * 0001047: Convolution test needs ITK with USE_FFTD * 0001038: Superbuild configuration fails on Debian Jessie * 0001024: QtWidgetStringListParameter is buggy * 0001026: In command line application launcher, image path and filename can not contain "--" * 0001044: OTB Windows 64bit -error cast from 'const short unsigned int*' to 'long unsigned int * 0001025: QtWidgetListViewParameter gets reset when changing another parameter in applications * 0001014: OTB does not compile with ITK 4.8 * 0000597: Optical calibration gives values greater than 100% on PHR products * 0001047: Convolution test needs ITK with USE_FFTD * 0001030: When writing images with no SRS / kwl, a default WGS84 projection is assigned in gdalImageIO * OTB-applications * 0001032: otbgui_RadiometricIndices output image without spatial reference system EPSG code * 0001037: file and vector outputs need explicit relative paths * 0001036: TileFusion application crashes with SPOT-7 tiled images * 0000728: Inconsistent polygon number in concatenate vector data output * 0001031: Wrong projection for output vector of segmentation application OTB-v.4.4.0 - Changes since version 4.2.1 (2015/02/13) -------------------------------------------------------- * Library: * Core: * Add a BandMathXImageFilter, otbParserX, otbParserXPlugins filters based on MuParserX * Correct a lot of issues related to Coverity scan * Giving access to probability estimates mode in libSVMMachineLearningModel and RandomForestsMachineLearningModel * Clean and update the header include into OTB * Enhance p to xs registration formula * Reduce Curl dependencies * Remove 6S dependency for VarSol computation * Clean and update the Mapnik adapters code into OTB * Add an option to limit the number of samples by class into otbListSampleGenerator * Fix BCO interpolation about coefficients normalization * Fix missing boost namespace * Fix Production date issue in IkonosImageMetadataInterface * Mark ancillary methods as deprecated otbWrapperCommandLineLauncher * Add regression mode to Random Forests * Add absorptances and fcover to SAIL code * Remove MeanShiftKernel file, duplicates of SVMKernel file, and not used anywhere * CMake: * Improve compatibility with cmake 3.0 * Testing: * Avoid multiple declaration of same function over different compilation units * Add test to use SVM machine learning class in regression mode * Remove obsolete and not compiled anymore tests * Rewrite add_test declaration to have exe name on the first line. will help modularisation script * Use a single cmake var for referencing large inputs * Documentation: * Enhance Doxygen Documentation * Applications: * New: * New BandMathX application with awesome mathematical functions * New applications for learning/classification of geometries in a shapefile: * ComputeOGRLayersFeaturesStatistics * TrainOGRLayersClassifier * OGRLayerClassifier * Updated applications: * Smoothing: add conductance parameter for anidifusion which was added recently in ITK filter * Smoothing: keep the time step independent from the image spacing * HomologousPoint: proper computation of the opposite region * Rasterization: fix computation of output image extent * GridBasedImageResampling: fix the wrong channel number otbGridBasedImageResampling. * ColorMapping: clamp before cast to uchar * OpticalCalibration: the toc computation is no more marked as experimental * OpticalCalibration: add an internal test to check if RSR file is correctly set * BundleToPerfectSensor and SuperImpose: Allowing to force default mode with Pleiades images * SuperImpose: fix a bug in PHR mode detection logic * TrainImagesClassifier: add option to limit the min number of samples to the smallest class * MeanShiftSmoothing: add missing ram parameter * StereoRectificationGridGenerator: add warning message about image sizes when enabling inverse transformation estimations. * Bugs fixed: * OTB-lib: * 0001003: logical bug in IkonosImageMetadataInterface ::GetPhysicalGain(),resolved,fixed,"In IkonosImageMetadataInterface::GetPhysicalGain() * 0001005: build error with otbUtilitiesTests * 0000987: update contents of README * 0000974: Bad processing of OTB Smoothing Anisotropic Filtering * OTB-Applications: * 0000975: OTB Applications which use OpenMP cannot be loaded with gcc version < 4.3.0 * 0000976: Strange output for ColorMapping application with LUT computed on support image OTB-v.4.2.1 - Changes since version 4.2.0 (2014/09/19) -------------------------------------------------------- * Bug fixed: * OTB-lib: * 0000973: Include directories in the wrong order * 0000764: otbcli_ComputeImagesStatistics doesn't error check output file location * other minor fix OTB-v.4.2.0 - Changes since version 4.0 (2014/09/04) -------------------------------------------------------- * Library: * Core: * Major compliance upgrade with index coordinates convention between OTB, GDAL and OSSIM. OTB uses pixel centered convention, whereas GDAL and OSSIM use corner pixel convention. More details on JIRA #647 and Mantis #942 * Major performance improvement of Haralick Texture computation (6 to 10 times faster) * Add new texture feature (dissimilarity) in ScalarImageToAdvancedTexturesFilter * Improvements of Simulation code in order to be able to use the solar irradiance information when working with spectral responses for simulations. * Support Jpeg2000 images through GDAL drivers (can use OpenJpeg, Kakadu, ECW) * Reading/Writing RPC coefficients in GeoTIFF tags * Cleaning of ITK pending patches * Update internal ITK to 4.6.0 * Support SPOT6 metadata * Integrate improvements from Monteverdi2 * Support clang 3.5.1 * Support MinGW compiler * API change on the TOC calibration filters, previous classes were not fully functional. Now supports any correction parameters set by user. See Examples/Radiometry/AtmosphericCorrectionSequencement.cxx for details on the migration. * Better support of atmospheric corrections for Pleiades images. Proper computation of satellite zenital angle using incidence angles and satellite orientation angle convention * Applications: * Updated applications : * Superimpose and BundleToPerfectSensor : Add a specific reprojection mode for PHR bundle * OpticalCalibration : parameters more flexible, allow users to overwrite metadata values * Bugs fixed: * Monteverdi2 * 0000915: In mvd2 applications wrappers InputImageList parameters, only the first item of the list is dropable * 0000960: Drop from file explorer doest not work. * 0000928: Output results of applications are not selected in the dataset manager * 0000908: Vector-image model settings serialization persistence (gamma) * 0000919: Inconsistent no-data checks in StreamingVectorImageFilter<> and StreamingHistogramVectorImageFilter<>. * 0000918: Image-view shift on click * 0000907: Serialization/persistence of viewport settings * 0000906: Quantiles editing on mono-bands images. * 0000909: Color-setup on PANCHRO images. * 0000905: Calculation of zoom-extent in Quicklook-view. * 0000964: Wrong update of Gamme cursor position * 0000929: Drag and Drop in otb application a dataset leads to the disappearance of the dataset into the widget * 0000921: Application freezes at the end of image import. * 0000947: Droping dataset to the last subgroup of the data tree crash the application * 0000933: Drag a dataset from temporary in the dataset manager outside the tree leads to a crash * 0000903: Removing mvd2 directory content leads to a core dumped as startup * 0000920: Wide unzoom aborts application * 0000917: Applying same quantiles to all channels crash the application * 0000962: Monteverdi2 cannot be run on OSX (image file not found). * 0000924: Monteverdi2 does not start after the check of OpenGL was added * 0000923: Monteverdi2 does not start after the check of OpenGL was added * Documentation * 0000948: Softwareguide OTB 4-0 : section 14.2.2 SIFT Detector (from chapter 14 Feature Extraction) is empty. * OTB-lib * 0000955: Wrong computation of SFS Textures * 0000940: Some output states are not correctly manage into Qt Application * 0000939: crash with a GIF/BMP image with ColorInterp=Palette when we request overviews via GDAL * 0000966: VectorDataExtractROIApplication does a strange reprojection * 0000932: Error in LSMS * 0000936: Sub-pixel disparity filter is not compatible with disparity maps over subsampled grids * 0000914: MeanShiftSmoothing application foutpos parameters is always mandatory * 0000943: TrainImagesClassifier and ListSampleGenerator problem * 0000954: GeometriesChangeSpatialReference does not work * 0000949: BundleToPerfectSensor application: in PHR mode, the ourpur geom file is the XS one, not the PAN one * 0000926: OTB does not compile with clang 5.1 * 0000968: CommandLineLauncher needs 2 passes to load parameters * 0000951: BundleToPerfectSensor application does not work in default mode with external ITK (internal ITK is fine) * 0000944: OTB does not compile with ITK4.6 git version * Monteverdi * 0000957: Unable to display input and output of ExtractRoadExample in transparency mode in Monteverdi OTB-v.4.0.0 - Changes since version 3.20 (2014/03/13) -------------------------------------------------------- * Library: * Core: * [Breaking change !] Change OTB implementation and API to support ITK version 4.5 * More information at http://wiki.orfeo-toolbox.org/index.php/Migration_guide_OTBv4 * Refactor otbAttributesMapOpeningLabelMapFilter to be compatible with ITK 4.5 * Remove FLTK based Visualization part from OTB: all these projects are now in Monteverdi * Rename EuclideanDistance as EuclideanDistanceMetric * Remove otbMaskedScalarImageToGreyLevelCoocurenceMatrixGenerator * Use local masks in otbHaralickTexturesImageFunction * Remove methods of otbSystem.h which can be replaced by similar ones in itksys/SystemTools.hxx * Move classes about Amplitude and Phase functors from visualization to basic filter * otbImageToLabelMapWithAttributesFilter inherits from itkImageToImageFilter instead of itkLabelMapFilter * Overload GenerateInputRequestedRegion in otbImageToLabelMapWithAttributesFilter * Override VerifyInputInformation in otbImportGeoInformationImageFilter * Adding a gamma parameter in VectorRescaleIntensityImageFilter to allow for gamma correction * Clean up JoinHistogramMI code * Fix race condition in BinaryFunctorNeighborhoodJoinHistogramImageFilter * Remove unused OTB_USE_SYSTEM_VXL and OTB_VXL_DIR from OTBConfig and UseOTB * Improve detection of Large Files Support by not unconditionnally defining LFS related macros * Support for Visual Studio 2012 * Support for Visual Studio 2013 * Support compilation in MacOSX 10.9 with latest XCode * Support for clang 3.5 * Testing: * Correct multibaseline support * Move test related to amplitude and phase functor from visualization to basic filters * CMake: * Use modern CMake style: no block-end arguments and all CMake command to lower case format * ThirdParties: * OTB support now ITK with version greater to 4.5.0 (internal and external) * Remove FLTK dependency * Remove GETTEXT dependency * Remove LIBLAS dependency * Remove PQXX dependency * Improve support of muparser 2.0 * Deactivate the possibility offered by CURL to download multiple files in parallel * Support mapnik 2.2 * Applications: * Updated applications: * ColorMapping : Remove dependency of ColorMapping to Visualization class * Convert : Adding gamma correction method the convert application * HomologousPointsExtraction : add mode.geobins.binsizey and mode.geobins.binstepy to allow for anisotropic geobins mode * HomologousPointsExtraction : new mode.geobins.margin parameter to only search inside image center. * Core framework: * Improve the support of XML parameters input/output file * Improve the input VectorData/Image/Filename parameter to give access to m_Input attribute * Monteverdi: * Support OTB-ITKv4 API * Integrate FLTK visualization framework into Monteverdi from OTB and offers the possiblitity to use it into external project. * Support of MacOSX 10.9 compilation * Improve support of Windows platform for otbViewer * Remove intertionalisation test from Monteverdi * Bugs fixed: * OTB-applications: * 0000884: InputImage parameter in java wrappers didn't overload the input parameters provided by input XML file * 0000883: InputImageList parameter in pyhton wrappers didn't overload the input parameters provided by input XML file * 0000873: BandMath application in gui mode "Save to xml" option doesn't save "exp" parameter * 0000836: Error in Exact Large-Scale Mean-Shift segmentation, step 2 * 0000824: otbgui_Orthorectification : changing the input image does not update UTM parameters * 0000881: GenerateRPCSensorModel application generate stats file with wrong elevation value * OTB-lib: * 0000878: apTvDmStereoFramework fails with muParser 2.2 * 0000850: apTvDmBlockMatchingTest Parser error Unexpected token if * 0000862: Cannot build OTB with mapnik 2.2 * 0000858: cannot build otb tests with ITK trunk * 0000851: Build error on test 0000169-fftcomplextocomplex * 0000861: CMake detects mapnik 2.2.0 as mapnik 0.7 * 0000859: Unable to compile OTB trunk with external ITK trunk * Orfeo Toolbox (OTB): * 0000849: otbgui applications scrambled file names * 0000863: ConvertSensorToGeoPoint application in GUI mode execute button is not activate even if all parameters seem to be filled * 0000872: Internal ITK 4.4.2 and ITK 4.5.0 source codes are mixed together in the OTB internal ITK source directory * 0000864: MultiResolutionPyramid MTV2 is in an endless loop of generation if the parameter "Number of levels" is set with a negative value * 0000830: otb::PolyLineImageConstIterator returns reference to temporary variable * 0000823: problem with python wrapper for otbApplication 'rasterization' * Documentation: * 0000838: ITK classes disappeared from doxygen during migration to ITK 4.x OTB-v.3.20 - Changes since version 3.18.1 (2013/11/13) -------------------------------------------------------- * Library * Core * Fix trapezoidal function in otb::FuzzyVariable * PleiadesImageMetadataInterface * update calibration absolute gains for Pleiades (values provided by CNES and not read from metadata anymore) * add calibration data for Pleiades 1B * StreamingStatisticsMapFromLabelImageFilter : change accumulator type to double instead of unsigned int * DEMHandler : support GeoTIFF as elevation * GenericRSResampleImageFilter & StreamingResampleImageFilter * add accessors for number of thread of deformation filter * set number of threads to 1 by default for the deformation field generator * SpotImageMetadataInterface : add relative spectral response for HRG1 * MeanShiftSmoothingImageFilter : add range bandwidth parameter to adapt spectral radius to actual pixel value * StreamingStatisticsVectorImageFilter : protect against corner cases when image has 0 or 1 pixels * ThirdParties * Synced ossim plugins with the ossim repository * Applications * New applications : * Large scale MeanShift set of applications : LSMSSegmentation, LSMSSmallRegionMerging, LSMSVectorization * See recipe in the CookBook * Updated applications : * ClassificationMapRegularization : handle images with label up to 65535 * DimensionnalityReduction : added new parameter for saving transformation matrix * DownloadSRTMTiles : support projected input images * MeanShiftSmoothing : expose range bandwidth parameter * StereoFramework : deformation field are computed in float precision instead of double * TrainImageClassifier : fix ordering confusion matrix in case of arbitrary labels, like in ComputeConfusionMatrix * DimensionnalityReduction : add bounds for number of components depending on input image * Core framework : * Fix otbgui_XXX scripts to check for existence of otbgui.sh * Support saving and loading application parameters from/to XML files * Support extended filename for complex input images * QtWidgetModel emits a signal with associated exception in case an error occurs during application execution * Bugs fixed : * OTB library * 0000805: All links in html FAQ return Error 404 * 0000776: computeImagesStatistics imagelist input confusing error * 0000804: str and int concatenate error in Python Wrapper Application.GetParameterValue * 0000775: DoUpdateGUI() doing nothing for some parameters in QtWidget Wrapper * 0000799: when using OTB Applications in graphic mode "Execute" button become clickable even if output data is not set * 0000801: Some mandatory parameter with RoleOutput should not be set by user * 0000770: Output parameter does not appear anymore in the command line helper * 0000798: All the OTB app parameters are not all saved into the xml output file * 0000779: [OTB]otbTrainImagesClassifier generates an output *.CSV confusion matrix with a wrong header * 0000809: LSMS Vectorization application didn't support output file with "-" special character * 0000807: otbKmzExport application generate weird kmz if the tilesize parameter is equal to zero * 0000808: otbDownloadSRTMTiles application seems to be broken * 0000803: otbApplicationLauncherCommandLine -inxml parameter does not retrieve pixel type for output image parameter * 0000794: Tiling mechanism didn't work into Large Scale MeanShift application * 0000760: ClassificationMapRegularization output pixel values are always on 8 bits * 0000809: LSMS Vectorization application didn't support output file with "-" special character * 0000803: otbApplicationLauncherCommandLine -inxml parameter does not retrieve pixel type for output image parameter * 0000736: Error setting the index in RadiometricIndices application via python * 0000800: Watershed mode of segmentation application produce an image without CRS even if the input image has one * 0000806: Orthorectifcation application return black or weird output if we request an output in WGS projection * 0000755: otb-bin-qt 3.18.1 package on Ubuntu installation triggered a warning at installation * 0000801: Some mandatory parameter with RoleOutput should not be set by user * 0000770: Output parameter does not appear anymore in the command line helper * 0000793: Using dimensionality Reduction application with MAF algorithm and "Inverse output image" checked leads to crash * 0000773: [OTB]otbStreamingStatisticsMapFromLabelImageFilter wrongly counts and accumulates vectorpixel values * 0000398: OTB does not handle ortho-ready products properly * Monteverdi2 * 0000789: Crash when selecting badly imported dataset. * 0000787: Can't drag up in Quick look view with ortho product * 0000750: Importation of a dataset which didn't exist because otb-app didn't run * 0000791: Accuracy error when converting float (-4.31608963) to string. * 0000792: Checking "Load otb application from xml file" crashes monteverdi2 on any application * 0000785: ITK exception raised when/after importing lena512color.jp2 * 0000754: VertexComponentAnalysis app output importing leads to mvd2 crash * 0000756: BandMath application does not get ready when adding multiple inputs * 0000777: Wrong cartographic coordinates in pixel description widget for geotif product * 0000749: Output of the applications are detected as inconsistent * 0000752: When we run a otb app the selection of the dataset into the database manager didn't move to the output file * 0000748: Drag and drop a dataset into a inputImageList widget of an otb-app didn't work with Win platform * 0000747: Drag and drop an image into MVD2 didn't work with Win platform * 0000746: Locked/unlocked button didn't work * 0000768: Monteverdi 0.5.0 package depend now on QWT * 0000790: Monteverdi 2 crashes when running segmentation OTB-v.3.18.1 - Changes since version 3.18.0 (2013/07/22) -------------------------------------------------------- * Library * Core and Third Parties * Update the JPEG2000ImageIO to decrease cache consumption and avoid memory leak between OTB and internal OpenJPEG library * Improve the control over the generation of GDAL overviews with a new method to set the resolution factor * CMake * remove OTBParseArguments from OTB source because it is not used * Examples * Update HelloWorld example CMakeLists * Applications * Updated applications * Update Stereo application documentation example with new parameters * Add a log message about color mapping method used by application * Core Framework * Initialize properly QtWidgetChoiceParameter * Increase minimum cmake version to 2.8.3 wwhen build applications OTB-v.3.18 - Changes since version 3.16 (2013/07/05) -------------------------------------------------------- Among the classical improvements and bug fixes to existing functionnalities, this release provides the following main functionnalities : * Huge improvements in Stereo framework, to compute DEM from stereo pairs : check the StereoFramework application ! * Whole new classification framework, with seamless integration of all OpenCV classifiers in addition to the existing libSVM classifier, kept for backward compatibility : check the TrainImageClassifier application ! * A classifiers fusion framework based on Dempster Shafer theory : check the FusionOfClassifications application ! The full list of improvements comes here : * Library * Core and Third Parties * Expose Curl timeout as parameter * OGRLayerStreamStitchingFilter : fix issue #610 'Attempt to delete shape with feature id (405674), but it is marked deleted already.' * Preparation for ITKv4 : got rid of most patches in internal ITK version * Removal of old deprecated methods in all OTB classes * Fix mangling of internal OpenJPEG * Simpler and more automatic configuration and build on Windows based on OSGeo4W * Basic filters * Add NoData value and flag for StreamingMinMaxVectorImageFilter * StreamingStatisticsImageFilter & StreamingStatisticsVectorImageFilter : support for skipping Nan and for a background value * Stereo * New classes : * DisparityMapTo3DFilter : convert disparity map in epipolar geometry to 3D image in epipolar geometry * MultiDisparityMapTo3DFilter : convert several disparity maps in sensor geometry to a 3D image in sensor geometry * LineOfSightOptimizer : algorithm to fuse several elevation values by line of sight optimisation * BijectionCoherencyFilter : from 2 disparity maps, compute coherency left-right and right-left, and output a mask of coherent disparities * Multi3DToDEMFilter : fuse several 3D images to produce an elevation map * DisparityTranslateFilter : filter to translate epipolar disparities into sensor disparities * PixelWiseBlockMatchingImageFilter : fix initialization of metric and disparities * PixelWiseBlockMatchingImageFilter : supports a shift on the subsampled grid * SubPixelDisparityImageFilter : supports a subsampled grid (with shift) * PixelWiseBlockMatchingImageFilter & SubPixelDisparityImageFilter : subsampled disparities are now consistent with the dispmap index spaces * IO * GDALImageIO : support reading overviews. "image.tif?&resol=3" is now supported as file name * Extended file names now supports the "box" key for writing only a subset of the image * Learning * Generic framework of classification filters, integrating OpenCV classifiers and libSVM * New classes * MachineLearningModel * MachineLearningModelFactory * LibSVMMachineLearningModel, based on pre exsiting libsvm functionnalities * OpenCV based classifiers : BoostMachineLearningModel DecisionTreeMachineLearningModel GradientBoostedTreeMachineLearningModel KNearestNeighborsMachineLearningModel NeuralNetworkMachineLearningModel NormalBayesMachineLearningModel RandomForestsMachineLearningModel SVMMachineLearningModel * ConfusionMatrixCalculator : add correspondence between class label and indices * ConfusionMatrixMeasurements : add new class for computation of precision, recall and F-score * Fuzzy * New Dempster Shafer based fusion of classifiers framework * Theory explained in http://wiki.orfeo-toolbox.org/index.php/Information_fusion_framework * New classes : DSFusionOfClassifiersImageFilter, ConfusionMatrixToMassOfBelief * Segmentation * Fix some numerical instabilities in mean shift segmentation filter * Radiometry * Fix spectral sensitivity reading of Pleiades images * Add PHR 1B averaged solar irradiance provided by CNES * Applications * New applications * Added new SRTM tiles downloader (DownloadSRTMTiles) * Added new PLY file generator (GeneratePlyFile) * TrainImageClassifier and ImageClassifier : made TrainSVMImageClassifier & ImageSVMClassifier more generic and expose OpenCV classifiers. Check the migration guide at : http://wiki.orfeo-toolbox.org/index.php/Classification_OTB_applications * Updated applications * StereoFramework : * Handles several images in input by stereo couples * More robust block matching with coherency checking in both directions * Choice of metric for block matching * Optional median filtering for disparities * Add variance threshold on input images for masking pixels where variance is too low * Add support for final projection of DEM in other SRS than WGS84 * ExtractROI : add a mode to fit another reference image * StereoRectificationGridGenerator : disable agvdem by default * StereoSensorModelToElevationMap application removed to avoid duplicating functionnalities provided by StereoFramework * MaxiumuAutocorrelationFactor application removed to avoid duplicating functionnalities provided by DimensionnalityReduction * BlockMatching : expose step parameter * BlockMatching : supports a shift on the subsampled grid * ColorMapping : remove flooding of logs * TrainImageClassifier & ComputeConfusionMatrix : enhance reporting of confusion matrix by displaying real labels * ReadImageInfo : add index of largest possible region * ComputeImageStatistics : support for background values, add progress reporting * CompareImages : use whole image when no ROI is provided * RigidTransformResample : all transformations are now synced to be from input space to output space * Core Framework * Manage UTF8 paths in GUI * Fix a crash in string list parameter widget in GUI * Monteverdi * Bug Fixes * OTB-lib * 0000707: Memory leaks in ApplicationWrappers * 0000712: weird result of DempsterShaffer fusion of classification * 0000685: UTF-8 paths not managed by Qt GUI in OTB Applications * 0000686: Input file paths are deleted in some input fields of Qt GUIs * 0000684: Impromptu cursor jumps in some input fields of Qt GUIs * Documentation * 0000643: Installation documentation is outdated * 0000720: [OTB Wiki] Unable to save an edited page with a hypertext link within it * OTB-applications * 0000704: results of otbcli_Segmentation reflexed * 0000711: Segmentation Fault and crash of applications after modifying any input "ParameterType_StringList" field * 0000709: otbcli_ComputeImagesStatistics includes NaNs and background values * 0000710: otbcli_ComputeImagesStatistics "progress" switch doesn't work * 0000697: ComputeConfusionMatrix * 0000670: Confusion matrix report unclear * 0000723: CompareImage application without ROI parameter results in FATAL error * Monteverdi2 * 0000632: Monteverdi2 crashes after zooming twice * 0000714: Import existing image in the database leads to a crash * 0000675: Filename too long * 0000708: MVD2 - Cache-dir removed from disk. * 0000664: Very long loading time the second time with TIFF product * 0000655: ProgressDialog does not close if error is displayed. * 0000646: Viewport is black or diminish when maximising or resizing the window before opening image * 0000645: Viewport goes black or diminish when maximising or resizing the window after opening image * 0000639: Using keyboard arrows with Monteverdi2 maximized grabs all keyboards events * 0000653: "monteverdi2 imagepath" creates a dataset model directory even if the image does not exist * 0000699: Datasets loaded through mvd2-viewer command-line are disabled * 0000679: Inconsistency between mouse cursor position and image displacement when dragging * 0000669: The application don't detect the fact that I didn't modify the settings * 0000668: Precision loss when loading/saving/reloading * 0000666: upper quantile is not set to 0.0 on integer image type, when using min/max button * 0000656: Import Windows does not close * 0000659: At first startup, 'mvd2' dir is not created but Monteverdi2 should create it * 0000660: Wrong display settings saved * 0000657: Radiometry values hide WGS84 coordinates in status bar * 0000654: When minimzing the window, all widgets are closed * 0000665: Monteverdi2-0.1 label in Startup menu does not have an icon * 0000644: Make Monteverdi2 window autofit to the screen's size * 0000638: Displacement in the image let a black line of pixels at the top of the full res window * 0000636: Displacement related to keyboard arrows is to small * 0000637: Displacements associated with vertical keyboard arrows are inverted with respect to Monteverdi 1.x * 0000633: Can not edit spinner fields in Video Color Dynamics widget * 0000634: Steps of Quantiles spin-box are to coarse * 0000718: Confirm dialog only displays MD5 name when deleting dataset. * 0000648: Deploy icons for Monteverdi2 in packages and also for local build if possible OTB-v.3.16 - Changes since version 3.14.1 (2013/02/04) -------------------------------------------------------- * Library * Core and Third Parties * Various enhancement of PleiadesImageMetadataInterface * Added GetEnhancedBandNames method in ImageMetadataInterface * Added read and write geom file support in OssimSensorModelAdapter * Refactoring of DEMHandler: * Turned the class into singleton * Made the DEMHandler the single configuration point for all elevation setup * Deprecated all methods from other classes allowing to configure elevation source * Added Exhaustive testing of all configuration cases (DEM, geoid, default) * Improved documentation * Refactoring of SensorModelAdapter: * Decreased size of the code * Made methods stick to what OSSIM does * Refactored RpcProjectionAdapter into RpcSolverAdapter * Updated ossim to r21971 * IO * Added support for GDAL driver creation options in GDALImageIO * Added support for external geom files in ImageFileReader * Extended filenames * Added framework for extended filenames (see http://wiki.orfeo-toolbox.org/index.php/ExtendedFileName) * Added support for extended filenames in ImageFileReader * Added support for extended filenames in ImageFileWriter * Refactored StreamingImageFileWriter and ImageFileWriter * ImageFileWriter is now the only class to use * StreamingImageFileWriter is a deprecated subclass provided for backward compatibility * Fixed a bug when the largest possible region could be asked in some cases * Projections * Refactored the GCPsToSensorModel filter * BasicFilters * Simplified computation of coefficients in Frost and Lee filters * Fusion * Added the LMVM fusion algorithm (kindly contributed by A. Tzotsos) * Radiometry * Updated solar irradiance for WV2 (kindly contributed by D. Duros) * Enhanced the TOA radiance computation for WV2 by integrating the effective bandwidth * Learning * Improved ListSample generation * Added support for interior rings * Fixed support for class minimum size * Added a filter for classification map regularization by majority voting * Segmentation * Added segmentation algorithm based on multiscale morphological structures classification * OBIA * Added a filter to compute mean radiometric values for each segment of a labeled image * Visualization * Added a method to change RegionGlComponent color in ImageView * Moved layer description in a single place * Applications * Framework * Modified the elevation parameters handling to be consistent with refactoring * New Applications * Added new radiometric indices application (RadiometricIndices) * Added new haralick and structural feature set texture extraction application (HaralickTextureExtraction, SFSTextureExtraction) * Added new morphological operation applications (BinaryMorphologicalOperation,GrayScaleMorphologicalOperation) * Added new local statistics extraction applications (LocalStatisticsExtraction) * Added new edge extraction application (EdgeExtraction) * Added new homologous points extraction application, including large scale extraction of tie points (HomologousPointsExtraction) * Added new application to refine a sensor model from a geom file and a set of tie points (RefineSensorModel) * Added new pan-sharpening application with 3 different algorithms (PanSharpening) * Added new classification maps fusion application (FusionOfClassifications) * Added new classification map regularization application (ClassificationMapRegularization) * Added new confusion matrix computation application (ComputeConfusionMatrix) * Added new tile fusion application (TileFusion) * Added new end-to-end stereo pair to Digital Surface Model application (StereoFramework) * Miscellaneous * Added an optional clamp in OpticalCalibration application output * Added segmentation algorithm based on multiscale morphological structures classification in Segmentation application * Added an optional output to the ReadImageInfo application to write the keyword list to a geom file * Added support for large image in image mode of ColorMapping application * Added support for histogram clamping settings and mask input in Convert application * Added support for UTM zone and hemisphere estimation by default in OrthoRectification application * Monteverdi * Refactored to fit the new elevation configuration method * Added Support for extended filenames * Bug fixes * OTB-Packaging * 0000591: Remove "homemade" gdal from OTB PPAs * Orfeo Toolbox (OTB) * 0000608: Annoying GDAL warning about GCP in OTB writer * 0000619: Superimpose application can't deal with 2 ortho images * 0000622: Extended filename does not seem to be compatible with OTB applicatiosn (command line) * 0000599: Optical calibration of DIMAPv1 PHR products * 0000601: PHR optical calibration : Band_Solar_Irradiance at 999 on some files * 0000618: MultiResolutionPyramid application can not handle relative output path * 0000617: Crash with StreamingStatisticsVectorImageFilter * 0000602: Geom file of extract of ortho PHR data are not loaded in the otbKeywordList * 0000600: Wrong band ordering in 3 Pleiades metadata (gain, bias, solar irradiance) * 0000629: Exception raised in otbcli_MaximumAutocorrelationFactor * OTB-applications * 0000616: otbcli_OpticalCalibration fails to read Worldview-2 metadata OTB-v.3.14.1 - Changes since version 3.14.0 (2012/10/02) -------------------------------------------------------- * Library * Support external FLTK 1.3 on windows * Simplify GDAL import during configuration * Remove ossim dependencies from aeronet file reader * Add adjacency effect in OpticalCalibration application * Improve Pleiades support : * TOA optical calibration available * Improve support of mega tiles products * Monteverdi * Support of MacOSX 10.8 * Bug fixes : * OTB-lib * 0000577: Remove the need for both GDAL_CONFIG and GDALCONFIG_EXECUTABLE * 0000573: tiff error in ossim when we read big uncompress JPEG2000 with Pleiades Primary level * 0000552: Application GridBasedImageResampling doesn't behave properly outside the input grid * 0000576: ImageToPointSetFilter work only with PointSets of type DefaultStaticMeshTraits * 0000575: Not able to access SDS layers in HDF4 datasets using BandMath * 0000572: using Segmentation application with .kml vector output using input which is not in WGS84 causes error * 0000586: OTB does not compile with gcc 4.7 on some distros * 0000579: Can not use files with "--" in their names in applications * 0000556: Help parameters display output wrong MISSING parameters with application launched via command line * 0000507: Java wrapper installation * Monteverdi * 0000570: SVM classification module works only with three bands images * 0000583: Weird spacing value for the Resampling module output * 0000581: Mean Shift Clustering Crash * 0000474: In TileMap Import module, search place by name does not work anymore * 0000529: Monteverdi fails to build using fltk 1.3 opensuse 12.1 * 0000582: Save/Quit button in the Resampling module does not close the module * 0000571: Monteverdi crash in SVM Classification when trying to import SVM model twice * Documentation * 0000366: SG-html has 2 "bibliography" * 0000371: Generate_FAQ script needs updates * 0000367: Software Guide HTML : missing index.html * 0000372: clean up Cookbook generation logs OTB-v.3.14.0 - Changes since version 3.12.0 (2012/07/09) -------------------------------------------------------- * Library * New MeanShift implementation * Add MeanShiftSmoothingImageFilter class with threading support * Add MeanShiftKernels class * Add MeanShiftConnectedComponentSegmentationFilter class to concatenate MeanShift filter and connected component * Add MeanShiftSegmentationFilter which performs segmentation of an image by chaining a mean shift filter and region merging filter. * Move MeanShiftVectorImageFilterExample to MeanShiftSegmentationFilterExample * MeanShiftImageFilter and MeanShiftVectorImageFilter are now deprecated * OGR encapsulation for use in large-scale segmentation framework * Add a method converting a DataTree node to a list of OGRLayer* * Add OGRDataSourceWrapper, OGRDriversInit, OGRLayerWrapper, OGRFieldWrapper, OGRFeatureWrapper, OGRGeometryWrapper and OGR classes to encapsulate OGR in the otb namespace * Add GeometriesProjectionFilter, GeometriesSet, GeometriesSource and GeometriesToGeometriesFilter classes to encapsulate OGR Geometries projection * Add OGRHelpers class for easier conversion to OGR string * Add GeometriesProjectionFilter filter to * Add ImageReference, OGRGeometriesVisitor classes * Large-scale Segmentation Framework (OBIA) * Create a new repository Segmentation * Add GdalDataTypeBridge * Add LabelImageToVectorDataFilter class * Add StreamingImageToOGRLayerSegmentationFilter class which allow stream segmentation and vectorization of the output label image (based on OGRWrappers) * Add LabelImageToOGRDataSourceFilter class to use GDALPolygonize method to transform a Label image into a OGRDataSource * Add PersistentImageToOGRDataFilter class. This class is a generic PersistentImageFilter, which encapsulate any filter which produces OGR data from an input Image * Add option 4Connected/8Connected for Polygonization in LabelImageToVectorDataFilter and LabelImageToOGRDataSourceFilter * Add OGRLayerStreamStitchingFilter class to make fusion of geometries in a layer (ogr) along streaming lines (based on OGRWrappers). * Add LabelImageRegionMergingFilter class * Add Example about OGRWrappers and HooverMetrics * Pleiades Support * enhance support of PHR data with DIMAPv2 official root_tag * manage all cases from geotransform return by GDALJP2metadata * enhance support of PHR data with GML box and Sensor Model * Add TileImageFilter to support mosaic tiled images * Support of TIFF pleiades image and associated DIMAP metadata * upport for DIMAPv1 metadata format * Stereo-rectification framework * Add StereorectificationDeformationFieldSource class * Add BlockMatchingImageFilter class for fast 2D block-matching * Add NCCBlockMatching functor * Add LPBlockMatching functor * Adding an optional geoid file, and the possibility to use height above ellispoid in DEMToImageGenerator * Add SubPixelDisparityImageFilter class to interpolate disparities * Add DisparityMapMedianFilter class * Add AdhesionCorrectionFilter class * Add DisparityMapToDEMFilter * Add example in DisparityMap/StereoReconstructionExample * Miscellaneous * Modify otbImageLayer to enable the contrast stretch on full or zoom view in Monteverdi Viewer module * Add RasterizeVectorDataFilter class * Add VectorDataToLabelImageFilter for VectorData rasterization using an attribute to get the color for burning * Add GDALDriverManagerWrapper class * Add VectorDataEditVertexActionHandler class to allow user editing of vertex in vector data. * Add VectorDataTranslateGeometryActionHandler class to handles the user action for geometries translation * Add VectorDataEditionModel class for vertex edition and geometries translation * Add a method to remove a specific geometry in the VectorData * AddVectorData method always do notification, add a flag (set to true by default) to allow disabling it * Enhance the support for Spot 1,2,3 metadata related to radiometry * Add UnaryFunctorWithIndexWithOutputSizeImageFilter which implements neighborhood-wise generic operation on image * Add WatershedSegmentationFilter composite filter to allow use of itk watershed inside large segmentation framework * Add LabelImageRegionPruningFilter filter to merges regions in the input label image according to the input image of spectral values and the RangeBandwidth parameter. * Rename VectorDataToImageFilter to VectorDataToMapFilter * Move Hoover framework to Code/Segmentation * Make RationalTransform inheriting from otb::Transform instead of itk::Transform * Add Spacing and Origin to RationalTransform * Fix bug in computation of NDBBBI for Spectral rule based classifier * Remove deprecated classes : * QuickLookImageGenerator (replaced by StreamingShrinkImageFilter) * GeometricMomentImageFunction (unused) * Improve removal of geometries in VectorDataEditionModel * HistogramActionHandler : avoid changing positions outside viewed range * PixelDescriptionModel : make the request for placename optional (lags when internet access is slow) * PackedWidgetManager : add Shown method, add Resizable setter * Patch internal muparser to avoid bugs with static storage varialbe deallocation in plugin context * Modify MetaDataKey to avoid bugs with static storage varialbe deallocation in plugin context * Enable KML writing using OGR (was previously done internally by libkml) * GenericRSTransform can now be optimized using a set of tie-points, calling ossim internal sensor model refining implementation * PackedWidgetManager & SplitWidgetManager : add method to set the label of each group * HistogramActionHandler : limit moves of asymptots with min/max of histogram * Curve2DWidget : add label support for each histogram * ImageToEnvelopeVectorDataFilter : support a sampling rate in pixels to be able to generate more than the four corners * GeoInformationConversion : add IsESRIValidWKT to test WKT for shp file support * OGRIOHelper : ensure OGR driver manager is initialized when we need it * New Applications * Add PixelValue application * Add HooverCompareSegmentation application * Add GridBasedImageResampling application to perform grid-based image resampling * Add StereoRectificationGridGenerator application * Add RadiometricWaterIndices application * Add FineRegistration application for pixel-wise horizontal block matching * Add BlockMatching application * Add DimensionalityReduction application * Add LargeScaleSegmentation application * Add DisparityMapToElevationMap application * Add ComputeImageFeatures application * Add VectorDataReprojection application * Misc. Applications * Add image origin to ReadImageInfoApplication * Use now InputFilenameParameter and OutputFilenameParameter instead of FilenameParameter * Use InputFilename and OutputFilename instead of Filename * New option in SVMClassifier application: sample.edg (non mandatory) to manage special cases with small samples * In KMeansClassification, Changing the random initialization method since it can generate centroids that are too far from the image distribution and will never move * Add AddRANDParameter option in order to set mersenne twister seed for test reproducibility purpose * Display which key is wrong in a set of application parameters * Improve the help return by application * MeanShiftSegmentation application, which duplicates Segmentation application has been renamed to MeanShiftSmoothing application * Rasterization application rewritten to use the new OGRDataSourceToLabelImageFilter filter The application can rasterize in binary mode or burn the value of a specified field (similar to gdal_rasterize) * ColorMapping : fix settings of predefined colormap * ColorMapping : fix mode "method.image" in case image contains continuous labels * ImageEnveloppe : expose new sampling rate parameter * otbViewer improvements : add handling of HDF and JPEG2000 files * Remove custom Transmercator projection settings from application * System * Added FLTK License * GDAL copyright notice removed because GDAL source code is not provided with OTB * OpenJPEG copyright file updated * Update internal Ossim to revision 20606 * Support for Mapnik2 * Make siftfast compilation optional (OTB_USE_SIFTFAST cmake option) * Support external tinyXML * Support external muparser * Support external libkml * Add a FindOSSIM.cmake to detect OSSIM easier * Update internal boost to 1.49.0 * Suppress galib from OTB source tree (wasn't used) * Suppress KNN from OTB source tree (wasn't used) * Enhance/Add find_package support for OpenThread, Ossim, Expat, PQxx, Curl, GetText, ICUUC and LTDL * Install OTB-custom FindXXX.cmake files along with OTB, to be used from external projects * Make installation with OTB_WRAP_JAVA honor CMAKE_INSTALL_PREFIX * New compilers supported : * clang 3.2 (current development version) * gcc 4.6, 4.7, 4.8-dev * Intel icc * Bug fixes : * OTB-lib * 0000532: OTB_SHOW_ALL_MSG_DEBUG option changes apTvClTrainSVMImagesClassifierQB456 test results * 0000568: Unable to compile OTB with a local version of the FFTW library * 0000531: Cannot compile OTB 3.12.0 with external FLTK 1.3 on Windows * 0000564: ColorMapping application crash when using support image with input label image which contains holes in label * 0000563: Can not install OTB elsewhere than /usr/lib anymore * 0000557: Weird default value for RAM parameter in OTB application * 0000544: SWIG 2.0.5 not supported on mac * 0000554: OTB compilation : error while loading libfltk.so.9 * 0000559: Even if OTB_USE_MAPNIK is ON, otbapp_Rasterization does not get compiled * 0000558: GetParameterFloat method of WrapperApplication class does not returns exactly input value * 0000550: BlockMatching application throws an exception when the "sub-pixel" mode is activated * 0000549: Error message related to boost_any_cast in StereoRectificationGridGenerator application * 0000547: MeanShiftFilter validation test is fialinf for Iteration and Spatial output * 0000542: Problem with win arch and testing * 0000521: Applications do not work anymore (Wrapper problem) * 0000522: otbApplicationLauncherQT is not reflecting the Disable/Enable state correctly * 0000511: Tags are repeated twice in Application, when using Qt framework * Monteverdi * 0000555: monteverdi -in does not work with JP2 images * 0000560: Monteverdi compilation error * 0000527: While saving dataset with rescaling option, the channels n° > 3 are incorrect * OTB-applications * 0000518: Missing GDAL dependencies * 0000515: Space managing in command line * 0000510: OTB-Applications cannot compile when the sources are located in a directory with spaces in its name * OTB-Packaging * 0000545: Issues with Monteverdi 1.10 binary applications on Mac OSX 10.6 (SL) * 0000525: Python not found during ubuntu package build * 0000526: Fix input of bfTvPolygonizationRasterization_WGS84 * Server administration * 0000519: Search button of current OTB doxygen documentation is broken * 0000523: Update doxygen version to get the same layout as the ITKv4 doxygen website OTB-v.3.12.0 - Changes since version 3.10.0 (2011/01/31) -------------------------------------------------------- * Library * MaximumAutocorrelationFactorImageFilter * MultivariateAlterationDetector * Add Hyperspectral processing filters * Dimensionnality estimation : * EigenValueLikelihoodMaximization * VirtualDimensionnality * Dimensionnality reduction : * PCAImageFilter - perform forward and inverse Principal Component Analysis decomposition * FastICAImageFilter - perform forward and inverse Independent Component Analysis decomposition, based on FastICA algorithm * MNFImageFilter - perform forward and inverse Maximum Noise Fraction decomposition * NAPCAImageFilter - perform forward and inverse Noise Adjusted Principal Component Analysis decomposition * Endmember extraction : * VcaImageFilter - performs Vertex Component Analysis * MDMDNMFImageFilter - performs Minimum Spectral Dispersion Maximum Spatial Dispersion nonnegative Matrix Factorization * Unmixing under Linear Mixture Model hypothesis : * UnConstrainedLeastSquareImageFilter - standard least square solving * NCLSUnmixingImageFilter - least square with non-negativity constraint * FCLSUnmixingImageFilter - least square with non-negativity and additivity constraint * ISRAUnmixingImageFilter - image space reconstruction algorithm * Anomaly detection : * LocalRxDetectorFilter * SparseUnMixingImageFilter : finds correlation in time series using sparse representation * Addition of several mathematical operations to support hyperspectral filters implementation * AngularProjectionImageFilter * AngularProjectionSetImageFilter * BinarySpectralAngleFunctor * ConcatenateScalarValueImageFilter * DotProductImageFilter * SparseWvltToAngleMapperListFilter * ProjectiveProjectionImageFilter * VectorImageToMatrixImageFilter Different sort of gradient filter for noise estimation in MNF : * LocalActivityImageFilter * LocalGradientImageFilter * HorizontalSobelVectorImageFilter * VerticalSobelVectorImageFilter * SobelVectorImageFilter * Add Simulation module, based on Prospect and Sail * AtmosphericEffects * DataSpec5B * ImageSimulationMethod * LabelMapToSimulatedImageFilter * LabelToProsailParameters * LeafParameters * ReduceSpectralResponse * ReduceSpectralResponseClassifierRAndNIR * SailModel * SatelliteRSR * SpatialisationFilter * SurfaceReflectanceToReflectanceFilter * SpectralResponse * Improve WaveletGenerator speed, and fix reconstruction issue is multithreaded environment * ClampImageFilter, ClampVectorImageFilter * ThresholdVectorImageFilter * Support for writing PDS files (Planetary Data System) in ImageFileWriter, through GDALImageIO * ImageRegionAdaptiveSplitter, RAMDrivenAdaptiveStreamingManager, New streaming strategy in writer, taking advantage of both tile size and pipeline memory print estimation * Finer progress reporting in StreamingImageFileWriter * Move ViewerManager application from OTB-Applications to OTB source tree, and rename as otbViewer * Factor MsgReporter class in OTB source tree, and reuse it in Monteverdi * HooverInstances, HooverConfusionMatrix : tools to evaluate a segmentation against a ground truth * Removed deprecated class MapProjection * Removed streaming and threading support from MeanShiftVectorImageFilter, since it was generating wrong labeled images * Pleiades data support * Update to openjpeg rev 1111 * Complete rework of JPEG2000ImageIO * Tile caching support * Multithreaded decoding * GMLBox decoding * Multi-resolution decoding support * Experimental Pleiades metadata support in ossimplugins : * RPC Sensor model * Calibration coefficient * Various information about the product * New application module framework (BUILD_APPLICATIONS:BOOL=ON) * New library OTBApplicationEngine to generate application module as shared plugin objects * This replaces small command line utilities in OTB-Applications * Command line launcher for application module * Generic Qt based widget to show/configure/run an application * Qt based GUI application launcher * SWIG module on top of OTBApplicationEngine to execute applications from Python and Java * Quickstart scripts provided for launching the commandline tools (otbcli_XXX) and for starting the Qt GUI (otbgui_XXX) * The following applications are available in this release : * CartographicDBValidation * ComputePolylineFeatureFromImage * DSFuzzyModelEstimation * VectorDataDSValidation * ChangeDetection * MultivariateAlterationDetector * Classification * ComputeImagesStatistics * ImageSVMClassifier * KMeansClassification * SOMClassification (Kohonen Self Organizing Map) * TrainSVMImagesClassifier * ValidateSVMImagesClassifier * DimensionnalityReduction * MaximumAutocorrelationFactor * Disparitymap * FineRegistration * StereoSensorModelToElevationMap * FeatureExtraction * LineSegmentDetection * Hyperspectral * VertexComponentAnalysis * HyperspectralUnmixing * Projections * BundleToPerfectSensor * ConvertCartoToGeoPoint * ConvertSensorToGeoPoint * ImageEnvelope * ObtainUTMZoneFromGeoPoint * OrthoRectification * RigidTransformResample * Superimpose * RadiometricIndices * RadiometricVegetationIndices * Radiometry * OpticalCalibration * SarRadiometricCalibration * Rasterization * Rasterization * Segmentation * ConnectedComponentSegmentation * MeanShiftSegmentation * Utils * BandMath * ColorMapping * CompareImages * ConcatenateImages * ConcatenateVectorData * Convert * ExtractROI * KmzExport * MultiResolutionPyramid * OSMDownloader * Quicklook * ReadImageInfo * Rescale * Smoothing * SplitImage * VectorDataExtractROIApplication * VectorDataSetField * VectorDataTransform * System * Update internal Ossim to revision 20113 * Update internal Boost to 1.47.0 * Update internal OpenJpeg to rev 1111 * Support for FLTK 1.3 * Support building ossim as a DLL on windows * Support building ossimplugin as a DLL on windows * Remove Ossim, OpenThreads and OpenJpeg headers from the install tree * Compilation with clang is now possible, still with some constraints : * it needs a recent clang version (better use a recent checkout) * you may encounter an issue with boost about fenv.hpp : this is a boost issue, and is fixed in boost > 1.48 * Monteverdi * Support for Pleiades format * Support JPEG2000 image loading with multi-resolution choice * Quicklook generation based on JPEG2000 format capabilities * Support viewing of JPEG2000Images * Add module to uncompress an extract of a JPEG2000 image to TIFF * Reader module tries to save the quicklook next to the original file to improve loading time of JP2 files * Fix gaussian histogram stretching mode to avoid warning and black image * Support Drag'N'Drop of image and vector format into Monteverdi tree * Support bundle generation on MacOSX * ConnectedComponentSegmentation : * Add "Elongation" statistics parameter * Support single band image * Support extracts of images in sensor model geometry * Writer module(s) : * Use StreamingImageFileWriter to take advantage of streaming improvements * Add Monteverdi version number in title bar * Reduce KMeans module memory footprint * Fix sample list size from an amount of RAM * Release temporary filters and variables as soon as possible * OTB-Applications * Removal of command line application migrated to OTB source tree * Migration of Viewermanager application to OTB source tree * OTB-Wrapping * Add otb::Transform * Bug fixes : * OTB-lib * 0000501: Add otbcli_XXX.bat and otbgui_XXX.bat for windows * 0000478: Exceptions thrown inside applications are not caught * 0000479: Can't write int8 image * 0000450: In otbViewer, zoom doesn't work well with link mode * 0000448: In otbViewer quicklook, navigation coordinate are not adapted to multi-res Pleiades images * 0000449: In otbViewer, the slide show crashes * 0000421: ListSampleGenerator is not random * 0000429: Trouble with .geom for Formosat * 0000439: Can't run Qt ReadImageInfo * 0000428: itkCastImageFilter doesn't work well with streaming * 0000416: segfault with non existing input image in the new otb applications framework * 0000424: Execute button enabling problem * 0000393: histogram minimum filter available ? * 0000400: how to return objects when function uses a filter ? * 0000380: wavelet reconstruction filter problem * 0000392: Unable to read Landsat Tiff file. Problem with Tags reading ? * 0000386: Remove direct use of ossim from Simulation tests * 0000401: Error while reading a lum image with several channels * 0000381: No platform testing OTB_USE_EXTERNAL_OSSIM * 0000441: SWIG/Python interface for applications does not catch all exceptions * 0000482: The Object Labeling module seems to hold forever when using "Save / Quit" * 0000471: Multi baseline Test files must begin by 1 and have consecutive number * 0000485: Hide internal CMake variable * 0000419: The new QT applications framework don't work on Ubuntu 11.04 and Ubuntu 11.11 * 0000497: Can not save VectorData in cartographic SRS in KML (empty file resulting) in applications * 0000498: Segmentation fault in Line Segment Detection filter * 0000495: StreamingImageFileWriter and link to source filter * 0000484: Rename CMake WRAP_* options * 0000472: LSD application on sensor image extract produces wrond geo-positioning * 0000491: Build scheduling is buggy with SWIG wrapper * 0000418: ld error on exit when using the new application framework with any engines * 0000473: Saving TIFF with "degenerated" sizes is highly suboptimal * 0000469: Clamp output values to the precision range in new application framework * 0000476: baseline file must have extension * 0000470: New applications framework input image parameter prevents from accessing to intermediate resolutions * 0000423: Internationalisation problem when launching application via Qt * 0000453: DEMConvert application becomes ready even if output parameter is empty * 0000426: RAM parameter has no effect in the new application framework * 0000436: Calling GetParameterXXXImage("in") more than once in DoExecute() breaks streaming * 0000442: In otb::WrapperApplication, calling Init() twice results in doubled parameters in examples * 0000440: In SWIG/python interface to applications, an exception is thrown when setting parameters unless Init() is called before * 0000425: In QT application launcher, some applications are ready to run with missing parameters * 0000435: OTB CommandLine wrappers parameters short key * 0000434: CommandLine launcher does not report outputs of the MeanShiftApplication * 0000431: OTB v. 3.10.0 & Snow Leopard : a bug fixed - Nov. 23, 2011 * 0000420: command line error reporting is not clear ('-' vs '--') * 0000387: [Monteverdi] Unable to display vector data with the viewer * 0000390: Lots of warning from itk::Transform when using otb::GenericRSTransform * 0000457: Crash of new otbApplications * 0000438: KMeans Application crach in Qt Framework * Monteverdi * 0000455: Can't cache a labelimage * 0000481: Add a option that allows a compute the histogram on the zoom (or full resolution) area, * 0000447: Unable to import non-georeferenced VectorData over a non-georeferenced image without a DEM * 0000492: BandMath module closes itself with Help window * 0000474: In TileMap Import module, search place by name does not work anymore * 0000396: Object labeling module crashes * 0000408: KMeans clustering crashes after a while * 0000383: KMeans module requests the largest possible region * 0000477: High memory usage in Monteverdi Viewer module with JPEG2000 images * 0000480: Viewer crashes playing with histogram method * 0000475: Select an Region in the Uncompressed JPEG2000 image module QL view constantly increase memory usage * 0000464: FLU is not compatible with FLTK 1.3 * 0000411: Does not support fluid 1.3 * 0000407: Right click on any list component crashes Monteverdi * 0000410: KMZ export module leaves a lot of .jpg.aux.xml files in the output directory * 0000405: otbSupervisedClassificationApplication does not handle class removal properly * 0000412: Monteverdi segfaults using contextual menu on module item * 0000403: Save dataset (advanced version): Not available for an output of bandmath module * 0000404: Spectral Viewer keep image locked * OTB-wrapping * 0000382: Build fails on CentOS 5.5 because of '$self' in java wrapper * OTB-Packaging * 0000500: Make OSGeo4W otb-wrapping-python and otb-wrapping-java * 0000502: Package cli and qt launcher in OSGeo4W * 0000486: [osgeo4w] Update setup.hint to add osgearth dependency * 0000413: Update CentOS installation manual * 0000399: Ubuntu packaging for Monteverdi fails (resource files are missing) * Documentation * 0000483: "<" or ">" are interpreted as ¿ in Cookbook * 0000370: Cookbook : make a HTML documentation * 0000378: Doxygen not updated OTB-v.3.10.0 - Changes since version 3.8.0 (2011/06/30) -------------------------------------------------------- * Monteverdi * New Rasterization module * New ImageStatistics module * New BayesianFusion module * New SAR Polarimetry modules (conversion, analysis) * New Vector data to image manual registration module * New connected component segmentation and OBIA based on user-defined criterions module * Removed the Orthorectification since its functionnalities are covered by the Reprojection module * Specify output map projection by EPSG code in reprojection module * Handle multi band complex images * Viewer module : Add "save screenshots" feature * Viewer module now handles a NoData field, allowing to correctly rescale ortho-images * DEM fields throughout the modules are now pre-filled with option in otb config file if correctly set * Add a rectify mode in homologous points extraction module (register image without changing resolution) * Applications with command-line interfaces and GUI * Optical calibration * Vectorial objects validation based on Dempster Shafer theory framework * otbDSFuzzyModelEstimation * otbComputePolylineFeatureFromImage * otbVectorDataDSValidation * Multi-images SVM classification framework * EstimateImagesStatistics * TrainImagesClassifier * ValidateImagesClassifier * ImageSVMClassifier * Connected Component Segmentation and OBIA based on user-defined criterions * Object Detection framework (adding the Histogram of Oriented Gradient feature) * TrainHOGDetector * HOGObjectDetector * MeanShiftModesDetection * TrainDeepSVMDetector * Various new utilities : * LineSegmentDetection * Superimpose * RigidTransformResample * ConcatenateVectorData * VectorDataExtractROIApplication * VectorDataTransformFilterApplication * OSMDownloader * Library * Add HistogramOfOrientedGradientCovariantImageFunction * Add Framework for LANDSAT Spectral rule based classifier (contribution from J. Inglada) * Add Multitemporal time point interpolators : SavitzkyGolayInterpolationFunctor, EnvelopeSavitzkyGolayInterpolationFunctor (contribution from J. Inglada) * Add SAR Polarimetry conversions and analysis code : * SinclairImageFilter * SinclairReciprocalImageFilter * SinclairToCircularCovarianceMatrixFunctor * SinclairToCoherencyMatrixFunctor * SinclairToCovarianceMatrixFunctor * SinclairToMuellerMatrixFunctor * SinclairToCircularCovarianceMatrixFunctor * SinclairToReciprocalCircularCovarianceMatrixFunctor * SinclairToReciprocalCoherencyMatrixFunctor * SinclairToReciprocalCovarianceMatrixFunctor * ReciprocalLinearCovarianceToReciprocalCircularCovarianceFunctor * ReciprocalHAlphaFunctor * ReciprocalCovarianceToReciprocalCoherencyFunctor * ReciprocalCovarianceToCoherencyDegreeFunctor * CoherencyToMuellerFunctor * MuellerToReciprocalCovarianceFunctor * MuellerToPolarisationDegreeAndPowerFunctor * Add RationalTransform * Add PipelineMemoryPrintEstimator: computes the total memory used by a pipeline, and proposes streaming parameters depending on available RAM * Add Dempster Shafer framework * MassOfBelief * JointMassOfBeliefFilter * Add a Dempster-Shaffer based vectorial objects validation framework * TODO: List classes here * AssymmetricFusionOfLineDetectorImageFilter: call SetNumberOfDirections on internal filters (contribution from A. Ferro) * RADARSAT 1: more product types supported * VectorDataToImageFilter: Binary rasterization available, support images of arbitrary size * Add VectorDataRendering example: showing how to rasterize OSM roads onto an image for visualisation * LineSegmentDetector & RightAngleDetection: algorithmic improvements * GDALImageIO: multi dataset support (for MODIS HDF4) * GDALImageIO: improve performance by avoiding unnecessary memory copies * GDALImageIO: TIFF are now saved as TILED * GDALImageIO: various improvements to support reading and writing of multiband complex data with all types supported by GDAL * StreamingImageVirtualFileWriter, StreamingImageFileWriter : new streaming strategies, with integrated pipeline memory print estimation * Curl: * Add in-memory download support to avoid writing small temporary files * Better handling of the exceptions than can be thrown when using curl * Add ConcatenateVectorDataFilter * Add OSMDataToVectorDataGenerator : Class implementing the download of the OSM file relative to an extent and a parser to generate VectorData from OSM Datas * Add ImageToOSMVectorDataGenerator : Helper class to compute the extent of an image, use OSMDataToVectorDataGenerator for VectorData generation * Add VectorDataTransformFilter : Apply an affine transform to a VectorData * ImageToSURFKeyPointSetFilter : algorithmic improvements * System * Compilation on Windows and MacOS with mapnik * Update internal tinyXML to 2.6 * Add ThirdPartiesUtilities: Refactoring OSSIM and CURL accesses so as to minimize dependencies using the Adapter pattern * Bug fixes : * OTB-lib * 0000312: Systematic crash when opening images with GDAL (tif, png, jpeg, etc) * 0000330: Suspicious log and output problem in ioImageToKmzAndMapFileProductExport * 0000329: At least 2 platforms don't respect the nightly version for their dashboard submission * 0000298: TestDriver : returns EXIT_SUCCESS when test is not registered * 0000310: PersistentImageToVectorData process the input twice when only one stream is used * 0000273: otbHarrisImageFilter applies final smoothing only over the 0-th direction; + wrong final scaling applied * 0000228: Problems related to the --compare-ascii tool in OTB tests protocol * 0000219: HDF dataset not openable with ImageFileReader * 0000358: Remove ossim from otbFilterFunctionValuesDigitalGlobeTest * 0000320: Design issue: VectorDataIOFactory should not be a template class * 0000334: Some tutorials do not check argc/argv * 0000311: No platform testing OTB_SHOW_ALL_MSG_DEBUG set to ON for examples compilation * 0000245: Wrong path for GDAL_CONFIG or GDALCONFIG_EXECUTABLE cmake variable produce incoherent results in the OTB configuration * 0000229: OTB driver in imageFileReader must support different file extensions related to the HDF format * 0000222: Issues with the TerraSar-X ossim plugin * 0000221: Fail to retrieve the pixel spacing from image metadata. * 0000282: Unable to open tiff image * 0000237: Boost / Fltk conflict * 0000327: CMake configuration abort if no curl is available on system, even with OTB_USE_CURL is set to OFF * 0000276: Trouble with the compare ascii when separations are tabulation * Monteverdi * 0000292: Tilemap import module not working * 0000352: Monteverdi crashes on wrong DEM directory * 0000270: Open RADARSAT2 products as an SAR image in Monteverdi * 0000263: Vectorization module : weird behavior * 0000297: Crash when open change detection output image * 0000281: Crash opening a RAD image. * 0000265: SVM learn module : crash when displaying results * 0000254: Homologous point module * 0000240: Importing shp file in SVM module in Monterverdi 1.6 always results in crash * 0000348: Viewer setup : histogram settings disappear * 0000349: Labeled image can't be viewed * 0000249: otbTrainObjectDetector-cli: malloc(): memory corruption * 0000251: Wrong output of the DEM to image generator module when working on a ROI of the image in raw geometry * 0000226: otbSegmentationApplication: crash when overwriting a .shp file * 0000223: Wrong positioning of polygons from otbSegmentationApplication and open with SVMclassification module (monteverdi) * 0000242: Mean Shift: different display of results in the module and in the Viewer * 0000317: Monteverdi extract ROI module can not perform extraction from geographical coordinates on SPOT5 data * 0000253: Nodata value in SRTM result in wrong ortho-rectified image * 0000315: Monteverdi ROI extraction module broken : can not select by drag&drop anymore * 0000300: One viewer instance block another instance to display another image * 0000269: Inoperative fields in the reprojection module * 0000255: Image is not visible if scroll or Full window is minimized while working with SVM classification * 0000267: Vectorization-Rasterization module * 0000244: Pansharpening EO-1 image with Monteverdi produces NaN * 0000227: Monteverdi crashing while displaying a .tif file * 0000350: KMeans module : weird behavior of "Max nb of iterations" * 0000248: In feature extraction module, for haralick textures : impossible to set min/max for binning * 0000341: weird french warning in ms dos command window with monteverdi 1.7 exe * 0000313: Unable to perform orthofusion of WV2 PAN+XS (4 bands) * 0000239: Trouble in pixel description in Monteverdi viewer * 0000336: Viewer Histogram settings not applied after channel order changes * 0000304: Advanced save dataset module with scaling on results in visible strip in image * 0000262: Wrong metadata interpretation * 0000302: Can't open two image in the viewer * 0000294: Monteverdi doesn't delete files in Caching * 0000280: SVM classification and Feature extraction issues * 0000247: Style of the new screenshots function in viewer module is ugly * 0000238: Monteverdi spreads xml temporary files everywhere * 0000241: A warning appears each time an image is read * 0000271: Default RGB channels are wrong for WV2 images * 0000250: Meanshift clustering module: spectral radius limited * 0000306: Unable to export otb::Image in KMZ in the Monteverdi module "KMZ export" * 0000279: Visualisation from vectorisation module does not use default channels for wv2 images * OTB-applications * 0000231: otbRasterizationApplication -pr options await for OGC WKT strings * 0000318: otbOSMDownloader-cli does not work anymore * 0000233: otbRasterizationApplication fail to rasterize SRTM water bodies shapefile with default parameters * 0000232: Several minor changes in rasterization application * 0000338: otbSegmentationApplication : Enable to use real values * OTB-Packaging * 0000296: gdal 1.8 debian package breaks TIFF support * 0000301: Can't upgrade debian package between different OTB versions * 0000347: Problem with current ubuntu Natty nightly package of Monteverdi * 0000290: Make an Experimental submission on the dashboard with natty * 0000355: Bad timestamp for nightly built Ubuntu packages * 0000288: Nightly packages upload when launchpad is overloaded * 0000345: debian package : enable mapnik * 0000344: debian package : use system boost * 0000326: CentOS packages for Monteverdi and OTB-Applications * OTB-Qgis * 0000272: problem with installation OTB-v.3.8.0 - Changes since version 3.6.0 (2010/12/16) -------------------------------------------------------- * Monteverdi * New Polarimetric Synthesis module * New DEM image extraction / HillShading module: creates an image from a DEM tiles directory, with optional hillshading * New ColorMapping module: apply a colormap to a mono band image * Viewer module: add multi input support, with slideshow or transparency mode, add more rendering functions, add split/packed layout option * Vectorization module: new semi-automatic mode based on segmentation results proposals * Applications * Object Detection applications (see also http://wiki.orfeo-toolbox.org/index.php/Object_detection) * EstimateFeatureStatistics to evaluate descriptors statistics on a set of images * TrainObjectDetector: generates an SVM model from input images and a vector data * ObjectDetector: detects points in an image from an SVM model * Add automatically generated GUI wrappers for OTB processing chains * Add FLTK wrapper * Add a generic Qt based widget class * Add a Qt GUI wrapper based on the generic Qt widget * Add a Qgis plugin wrapper based on the generic Qt widget * Library * Improved local descriptors tools based on ImageFunction : * Rework FlusserImageFunction and HuImageFunction to output all moments in one pass (FlusserMomentsImageFunction, HuMomentsImageFunction) * Rework RealMomentsImagefilter and ComplexMomentImageFilter to output a matrix of all moments associated to p, q inferior to a given parameter (ComplexMomentsImageFunction, HuMomentsImageFunction) * Add image function to compute a vector containing the local mean, variance, skewness and kurtosis (RadiometricMomentsImageFunction) * Add local histogram image function (LocalHistogramImageFunction) * Add image function to compute the local Fourier Mellin coefficients (FourierMellinDescriptorsImageFunction) * Add a class to adapt any image function return types to itk::VariableLengthVector (ImageFunctionAdaptor) * Add a class to build composite image functions (MetaImageFunction) * New object detection framework (see also http://wiki.orfeo-toolbox.org/index.php/Object_detection) * Add filter to generate negative samples (LabeledSampleLocalizationGenerator) * Add filter to evaluate an image function on a set of point and generate ListSample (DescriptorsListSampleGenerator) * Add filter to balance the sample number of different classes in a ListSample by generating new samples from existing ones plus noise (ListSampleToBalancedListSampleFilter, GaussianAdditiveNoiseSampleListFilter) * Add filter to apply a shift/scale to a ListSample (ShiftScaleSampleListFilter) * Add filter to detect object from an SVM model and an image function (ObjectDetectionClassifier) * SVMClassifier: add hyperplanes distances as output * GDALImageIO: support writing of non-streamable format (JPEG, PNG) * Support reading vector images of std::complex * BandMathFilter: add physical and image coordinates variables * Add a class to generate a kmz file from an image * System * Internal liblas updated to 1.6.0b2 + OTB patches (root CMakeList.txt) * Internal libsvm updated to 3.0 + OTB patches (additional kernels) * Internal ITK: removed compilation of medical image formats library and associated ImageIO * Internal ITK: removed dependency on libtiff, libjpeg, libpng and zlib, now handled by gdal * Support for gcc-4.5 * Remove dxflib from Utilities for licensing issues * Bug fix: * Monteverdi * 0000216: Monteverdi viewer unable to display multi band images * 0000193: Crash in vectorization module when the after the activation of the semi-automatic mode * 0000195: unable to perform TSX calibration with the sar calibration module in monteverdi 1.4 * 0000207: Vectorization module shift coordinates * 0000202: Error message "otbSVMModel.txx:310 eps <= O" in the SVM classification module * 0000194: error message opening dataset in monteverdi (development version) * 0000200: Monteverdi -in option does not open viewer anymore * OTB-applications * 0000213: Problem in denomination of otb process chain wrapped as qgis plugin * 0000201: otbFastOrthoRectif switched back to double precision again * OTB-lib * 0000192: Crappy support of gdal: GDALImageIO OTB-v.3.6.0 - Changes since version 3.4.0 (2010/10/07) -------------------------------------------------------- * Monteverdi * New Vectorization module: creates vector data (polygons, lines and points) from image * New BandMath module: mathematical operation on image bands * New SpectralViewer module: designed to display hyperspectral images. also computes spectral angle * New ObjectLabeling module: object based image analysis module, with SVM classification based on object features * Applications * otbFastOrthoRectif: fast orthorectification based on grid subsampling * otbActiveLearning: architecture to enable active learning application (put your own algorithms in the middle) * otbCompareImages: image comparison * otbFineRegistration: produces disparity maps between 2 images * Old GUI applications removed (now in Monteverdi): OrthoRectif, OrthoFusion, Classif, ChangeDetection, RadiometricCorrections * Library * Some classes are marked as deprecated and are available for one release. A migration guide to help the transition is available at http://wiki.orfeo-toolbox.org/index.php/Migration_guide * Add filter to perform arbitrary mathematical operation on image bands (BandMathImageFilter) * Add class to parse mathematical expression (Parser) * Add interpolation function (BCOInterpolateImageFunction) * Add filter to compute the intensity of a complex image (ComplexToIntensityImageFilter) * Add filter to compare two big images (StreamingCompareImageFilter) * Add filters to compute extrema of big images (StreamingMinMaxImageFilter and StreamingMinMaxVectorImageFilter) * Add filter to perform fine registration between images (FineRegistrationImageFilter) * Add filter for higher order texture computation (ScalarImageToHigherOrderTexturesFilter and MaskedScalarImageToGreyLevelRunLengthMatrixGenerator) * Removal of the old textures: http://wiki.orfeo-toolbox.org/index.php/Textures * Add support for Worldview2 data * Add margin sampler for SVM (SVMMarginSampler) * Add generic resample filter that reproject in any arbitrary projection: cartographic, sensor model (GenericRSResampleImageFilter) * Add class to produce a RPC model from a physical model (PhysicalToRPCSensorModelImageFilter) * Add classes related to SAR calibration (SarParametricMapFunction, SarRadiometricCalibrationFunction, SarRadiometricCalibrationFunctor, SarRadiometricCalibrationToImageFilter) * Add an action handler for the visualization enabling dragging (DragFullWindowActionHandler) * System * Internal ITK updated to 3.20.0 + OTB Patches * Internal OSSIM and ossim plugins updated to svn revision 18162 + OTB patches (almost none left) * Enable the use of an external build of libLAS * Support compilation on MSVC 2010 and Windows Seven * Better handling of FLTK configuration * Support compilation of Monteverdi on linux 32 bits systems with official FLTK package * Lots of coverage improvements OTB-v.3.4.0 - Changes since version 3.2.0 (2010/06/30) -------------------------------------------------------- * Applications * New utility otbConvertSensorToGeoPoint to convert from sensor coordinates to lon/lat * otbExtractROI can change its output type * New utility otbSplitImage to separate a multispectral image into N images * otbConcatenateImage can change its output type * otbConvert can now use a log transfer function when rescaling the image * Library * Add HillShadingFilter to produce hill shade image from DEM (HillShadingFilter) * Add point set density function (gaussian, epanechnikov) * Add filter to extract a subset from a point set (PointSetExtractROI) * Add filter to apply a transform to a point set (TransformPointSetFilter) * Add filter to generate a random point set (RandomPointSetSource) * Add class to compute confusion matrix (ConfusionMatrixCalculator) * Add class to generate a list of samples from a vector data (ListSampleGenerator) * Add a class to compute the ground spacing (GroundSpacingImageFunction) * Add a class to read 6S spectral sensitivity files (SpectralSensitivityReader) * Fix radiometry correction for SPOT5 * Fix compilation on windows using osgeo4w dependencies * Lots of bug fixes * System * Internal ITK updated to 3.18.0 + OTB Patches * Internal OSSIM updated to svn revision 16861 + OTB patches * Internal OSSIM SAR plugins updated to svn revision 17643 + OTB patches * Internal libkml updated to 1.2.0 * Internal siftfast updated to 1.2 * Internal boost updated to 1.42 OTB-v.3.2.0 - Changes since version 3.0.0 (2010/01/15) -------------------------------------------------------- * Applications * Monteverdi, a new all-in one user-friendly graphical tool for remote sensing data processing released as a separate package (see README file). Windows binary package of Monteverdi is available and was installed on various operating system including Windows 2000/XP/Vista/Seven. * Library The library includes these additions * Support for TerraSarX, Quickbird and Spot5 calibration metadata * Simplification of the interface to access image metadata * Support for Aeronet files * Various filters for Object Based Image Analysis based on LabelObjectMaps * Support for RPC sensor model estimation from a set of Ground Control Points * Support for affine transform least-square estimation from a set of tie points * Support for SVM cross-validation and parameters optimization * Box and Whiskey filter to detect outliers on VectorImage * Add several Euclidian distance classes * Exhaustive exponential optimizer for learning * Enhanced SOM algorithm taking into account invalid missing values * Wavelet transform * Filters for GIS database interaction (postgis database) * ImageFileWriter now supports streaming natively * Use of a configuration file to change some parameters without recompiling * Lots of bug fixes * System * Internal ITK updated to 3.16.0 + OTB Patches * Internal OSSIM updated to svn revision 15872 + OTB patches * Home brewed metadata SAR reader were moved to ossimplugins * Experimental support for internationalization * Facilitate installation on Mac OSX platform (OTB is now able to compile on Mac OSX by using external libraries like GDAL downloaded from Macports) OTB-v.3.0.0 - Changes since version 2.8.0 (2009/05/11) -------------------------------------------------------- * Applications - Urban area extraction (Pléaides, QB, Ikonos, SPOT5). For more details, see the README file - Image to Data Base registration (Pléiades, QB). For more details, see the README file - Feature Extraction: add new textures, new radiometric indexes and add MeanShift capabilities * Library The library includes these additions - Cloud detection for QB/Pléiades images - Alignment and right angle detection (Burns, Grompone) - Radiometric indices (vegetation, water, soil) - Optimized texture computations including Haralick, SFS, Pantex, Edge density - SIFT density image function and filter - Object-based segmentation and filtering - LSD line segment detector and right angle detector - PCA computation - Automated loading of radiometric correction parameters (SPOT, Ikonos) - Attribute support for shapefile (reading only) - Optimization of vector data - Visualisation refactoring: for more details, see http://wiki.orfeo-toolbox.org/index.php/Visualisation_Refactoring * System - Updated OSSIM library - Updated ITK library (3.12.0) - Miscellaneous bug fixes (support for gdal 1.6) - Fixed some problems under Visual and Cygwin platforms. * Distribution - Distribution of Windows binaries packages installation for OTB-Application (OTB-Applications-3.0.0-win32.exe) - Distribution of Windows binaries packages for GDAL library 1.6.0 for MSVC V71 and MSVC V80 compiler (http://www.orfeo-toolbox.org/packages) OTB-v.2.8.0 - Changes since version 2.6.0 (2009/01/15) -------------------------------------------------------- * System - ITK version updated to 3.10.1 - liblas library added - ossim gdal plugin added - change in OpenGL access for viewer - Edison code from mean shift * Library - Support for Lidat data - SIFT and SURF implementation - Mean Shift algorithm - Conversion of vector data projection (kml, shapefiles) * Applications - Object counting - Fine Registration - Road Extraction OTB-v.2.6.0 - Changes since version 2.4.0 (2008/10/31) -------------------------------------------------------- * System - GCC 4.3 compatibility - ITK version updated to 3.8 - FLTK version updated to 1.1.9 - OpenThreads library added - Expat library added * Library - SAR Polarimetry synthesis classes - Kullback Leibler supervised change detection - KML support - Gabor filters implementation - Optimized convolution using FFT - CNES RAD format support - NCC and MI registration filters for diparity map estimation - Support for MegaWave image format (contributed by Eric Bughin) * Applications - Object segmentation application - Feature extraction application - Land Cover Map application - SAR polarimetric synthesis application - 3D & stereo anaglyh viewer application - Command line conversion from/to all image formats supported by OTB OTB-v.2.4.0 - Changes since version 2.2.0 (2008/07/24) -------------------------------------------------------- - Added OTB_DISABLE_CXX_EXAMPLES_TESTING : allows generating or not only examples testing - Added OTB_USE_JPEG2000 : experimental support for jpeg2000 files. *Common: Extraction ROI Classes : - Lifting of the otbExtractionBase classe - Correction of the SetExtractionRegion method *BasicFilters: - Added pixel size matching in otbSpectralAngleDistanceImageFilter - Modification of otb::ConvolutionImageFilter class to allow the use of non-normalized convolution filters *Platforms: - Fixed compilation problems using external FLTK version < 1.1.9 under fedora unix distribution. - Mac OS X 10.5 supported *Applications: - Added an supervised image classification application (otbSupervisedClassification) - Added an orthorectifcation application (otbOrthoRectifAppli) - Added an orthofusion application (otbOrthoFusionAppli) *Markov: Added full Markov framework for segmentation, restoration and filtering Added related classes: - otb::MarkovRandomFieldFilter - otb::MRFEnergyEdgeFidelity - otb::MRFEnergyGaussianClassification - otb::MRFEnergyGaussian - otb::MRFEnergy - otb::MRFEnergyPotts - otb::MRFOptimizer - otb::MRFOptimizerICM - otb::MRFOptimizerMetropolis - otb::MRFSampler - otb::MRFSamplerMAP - otb::MRFSamplerRandom - otb::MRFSamplerRandomMAP Added related examples: - MarkovClassification1Example - MarkovClassification2Example - MarkovRegularizationExample - MarkovRestorationExample *Projections Added Lambert 93 cartographic projection with otb::Lambert93Projection class * Utilities: - Corrections on new SAR models integrated to OSSIM during release 2.2.0 OTB-v.2.2.0 - Changes since version 2.0.0 (2008/05/29) -------------------------------------------------------- *BasicFilters: Added classes for data importation: - otb::ImportImageFilter - otb::ImportVectorImageFilter Added classes for image interpolation: - otb::WindowedSincInterpolateImageBlackmanFunction - otb::WindowedSincInterpolateImageCosineFunction - otb::WindowedSincInterpolateImageGaussianFunction - otb::WindowedSincInterpolateImageHammingFunction - otb::WindowedSincInterpolateImageLanczosFunction - otb::WindowedSincInterpolateImageWelchFunction - otb::ProlateInterpolateImageFunction Added class for resampling - otb::RationalQuotientResampleImageFilter Added classes for labelization - otb::LabelizeImageFilterBase - otb::LabelizeConfidenceConnectedImageFilter - otb::LabelizeConnectedThresholdImageFilter - otb::LabelizeNeighborhoodConnectedImageFilter *Radiometry: - Bug fixed on otb::DEMCaracteristicExtractor *Visu - Added histogram windows in otb::ImageViewer main class. - Added polygon drawing support in otb::ImageViewer main class *IO: - Fixed bug in GDALImageIO to handle complex images Added classes for vector data use: - otb::VectorDataFileReader - otb::VectorDataFileWriter - otb::VectorDataIOFactory - otb::VectorDataSource *Common: Added classes to handle vector data: - otb::Polygon - otb::VectorData - otb::DataNode Added classes to watch filter progression (ASCII mode): - otb::StandardFilterWatcher - otb::FilterWatcherBase *Learning: - Creation otb::SVMKernels containing a list a useful kernel for SVM - Correction in Kohonen map classes - Added convenience methods in SVMModel class Added classification filters (streamed and threaded): - otb::SVMImageClassificationFilter - otb::SOMImageClassificationFilter - otb::KMeansImageClassificationFilter *FeatureExtraction: Added implementation of Scalar Invariant Feature Transform - otb::ImageToSIFTKeyPointSetFilter *MultiScale: Added mono and multi-scale convex/concave image classification based on geodesic morphology characteristics. - otb::ConvexOrConcaveClassificationFilter - otb::GeodesicMorphologyDecompositionImageFilter - otb::GeodesicMorphologyIterativeDecompositionImageFilter - otb::GeodesicMorphologyLevelingFilter - otb::ImageToProfileFilter - otb::MorphologicalClosingProfileFilter - otb::MorphologicalOpeningProfileFilter - otb::MultiScaleConvexOrConcaveClassificationFilter - otb::ProfileDerivativeToMultiScaleCharacteristicsFilter - otb::ProfileToProfileDerivativeFilter *Utilities: - Updated the internal version of ITK to 3.6.0 - Corrections on OSSIM integration - SVM library: creation of otb::ComposedKernelFunctor allowing composed kernels - Added SAR models in OSSIM library: . Radarsat 1 (SGX and SGF) . Envisat ASAR - SLC (IMS, APS) and PRI (IMP, APP) . ERS - SLC and PRI . Terrasar X - SLC and PRI . Cosmo-Skymed - SLC and PRI . Radarsat 2 - SLC and PRI - Bug fixed in CMake configuration - Added SIFT implementation in InsigthJournal *Applications: - Various Bug fix - otbConvertGeoToCartoPoint and otbConvertCartoToGeoPoint map precision enhancement - Added of histogram manipulation functionalities in otbImageViewer - Added of shape file functionalities and large image support in ICD application - Added otbConcatenateImages application to concatenate multiple image in the spectral domain - Added an unsupervised image classification application based on the KMeans algorithm (otbKMeansClassification) - Added an unsupervised image classification application based on the SOM algorithm (otbSOMClassification) - Added an unsupervised image classification application based on the SVM algorithm (otbSVMClassification) - Added an application to create a contiguous unsigned short labeled image from a colored labeled image (otbUnsignedShortRelabeling) - Added an application to create a colored labeled image from an unsigned short labeled image (otbRgbRelabeling) *Examples: - Added SIFT example (otb) - Added SIFT example (ij) - Added LabelizeNeighborhoodConnected example - Added RationQuotientResample example *Platforms: - Fixed some problems under Visual, Cygwin and MinGW platforms. OTB-v.2.0.0 - Changes since version 1.6.0 (2007/12/14) -------------------------------------------------------- *Projections - Bug correction in otb::OrthoRectificationFilter *Fusion - Added simple Pansharpening algorithm - Fixed streaming bug on BayesianFusion filter *Radiometry: Added classes for atmospheric correction using the 6S Radiative Transfer Code: - Luminance estimation otb::ImageToLuminanceImageFilter - Reflectance estimation TOA: otb::LuminanceToReflectanceImageFilter - Added Composite transform filter: otb::ImageToReflectanceImageFilter, equivalent to the pipeline process ImageToLuminanceImageFilter and LuminanceToReflectanceImageFilter filters - Reflectance estimation TOC: otb::ReflectanceToSurfaceReflectanceImageFilter - 6S effect correction: otb::SurfaceAdjacencyEffect6SCorrectionSchemeFilter - DEM slope and shading estimations: otb::DEMCaracteriticsExtractor *Common: - Added otb::UnaryFunctorNeighborhoodVectorImageFilter - Fixed bug on otb::ExtractROIBase class *IO: - Bug fixed on otb::VectorImage class *BasicFilters: - Bug correction in otb::StreamingStatisticsVectorImageFilter, otb::StreamingStatisticsImageFilter,StreamingMatrixTransposeMatrixImageFilter - Added PrintableImageFilter - Fixed bugs on otb::FrostImageFilter and otb::LeeImageFilter *Utilities: - Fixed memory allocation bug on svm.cxx file - 4 files from ITK 3.4.0 have been replaced by the cvs version to allow correct use of the itkDivideImageFilter.h with VectorImage. These files are: Common/itkNumericTraitsVariableLengthVectorPixel.h Common/itkNumericTraitsVariableLengthVectorPixel.cxx Common/itkConceptChecking.h BasicFilters/itkDivideImageFilter.h *Examples - Tutorials: Added OrthoFusion example - Radiometry: Added AtmosphericCorrectionSequencement example *Applications: - Rename Pireo application to otbPireo - Added transform coordinate point applications: otbConvertCartoToGeo otbConvertGeoToCarto - Pireo corrections in CMakeLists.txt (GUI dir source code) and source code (suppress of call VnlModifiedOptimizer class) *Platforms: - Fixed some problems under Visual and MinGW platforms. OTB-v.1.6.0 - Changes since version 1.4.0 (2007/10/25) -------------------------------------------------------- *BasicFilters: - Added StreamingVectorStatisticsImageFilter to compute the second order stastics on a large vector image. - Added the MatrixTransposeMatrixImageFilter to compute the product of the matrix of vector pixels from image 1 in rowwith the the matrix of vector pixels from image 2 columns for large vector image. - Added the otb::VectorImageTo3DScalarImageFilter which transforms a vector image into a 3D scalar image where each band is represented in a layer of the 3rd dimension. - Added the otb::ImageListToVectorImageFilter and otb::VectorImageToImageListFilter to convert a vector image from/to an image list. - Added the otb::ImageListToImageListApplyFilter which applies a given scalar image filter to a list of images - Added the otb::PerBandImageFilter, which applies a given scalar filter to each band of a VectorImage. This is not the optimal way for most processings but it allows the use of almost every scalar filter on vector images. - Added the otb::StreamingResampleImageFilter, which is a streaming capable version of the itk::ResampleImageFilter. *ChangeDetection: - Added the otb::KullbackLeiblerDistanceImageFilter to compute the Kullback-Leibler distance between two images. - Added the otb::KullbackLeiblerProfileImageFilter to perform a multi-scale change detection using the Kullback-Leibler distance. *Common: - Added an otb::Polygon, which represents a closed polyline on which intersection or point interiority can be tested. *IO: - Added an otb::DEMHandler to fetch the elevation value in SRTMor DTED directories. - Added an otb::DEMToImageGenerator to generate an elevation map. - Added a new tiling streaming mode. - Added the otb::ImageGeometryHandler, which allows handling seamlessly the image geometry information. - Fixed a bug in the otb::MSTARImageIO. *Learning: - Added methods to access the alpha values, the number of support vectors, the support vectors themselves, the distance to the hyperplanes. - Added the otb::SEMClassifier, implementing the Stochastic Expectation Maximization algorithm to perform an estimation of a mixture model. *MultiScale: - Various name changes and bugfixes in the morphological pyramid segmentation classes. *Radiometry: - The 6S Transfer Radiative Code compiles within OTB. - Added the Radiometry directory, containing everything that has to do with image radiometry. - Added the NDVI and ARVI (3 input bands) vegetation index filters. *Projections: - Added the Projections directory, containing everything that has to do with image projections. - Added an otb::DEMHandler to fetch the elevation value in SRTM/DTED directories. - Added an otb::DEMToImageGenerator to generate an elevation map. - Added an otb::OrthoRectificationFilter to perform orthorectification of geo-referenced images. - Added the forward and inverse sensor model projection. - Added several map projection transforms (Eckert4, LambertConformalConic, TransMercator, Mollweid, Sinusoidal, UTM) *Fusion: - Added the Fusion directory, containing everything that has to do with image fusion. - Added the otb::BayesianFusionImageFilter, a pan-sharpening filter which algorithm has been kindly contributed by Julien Radoux. *Documentation: - Added various documented examples in the SoftwareGuide for the new classes. - Added a Tutorial section in the SoftwareGuide. *Utilities: - Added the 6S library which will soon play a role in the radiometry module. - Updated the internal version of ITK to 3.4.0. *Platforms: - Fixed the random segfault of otbInteractiveChangeDetectionAppli under Visual 8.0. *Applications: - Added the otbImageViewerManager application which allows opening multiple images, configure viewers and link displays. - Added the otbRoadExtraction which demonstrates the road extraction algorithm implemented in the FeatureExtraction module. - Added the otbOrthoRectifAppli application which allows ortho rectifying images in command line using the brand new Projections module of the Orfeo ToolBox. Old rigid orthoo rectification application has been moved to otbPseudoOrthoRectif. - Added an option in CMakeLists.txt to use VTK or not (enable or disable the following application). - Added the Pireo registration application (VTK needed). OTB-v.1.4.1 - Changes since version 1.4.0 -------------------------------------------------------- *Platforms: - Minor corrections of main ./CMakeLists.txt to support users applications using OTB install directory when using internal ITK. OTB-v.1.4.0 - Changes since version 1.2.1 -------------------------------------------------------- *IO: - Added the LineSpatialObject class. - Added the ArcSpatialObject class. - Added a DXF file reader to read spatial objects from DXF files. *Common: - Added a PolylineParametricPathWithValue class, to store a scalar value along with a polyline. - DrawPathFilter and DrawPathListFilter can now use the internal scalar values of the path(if present) as a value to draw the path. - Improved performances of the DrawPathFilter and DrawPathListFilter. - Added the base class otbBinaryFunctorNeighborhoodVectorImageFilter (see ChangeDetection) *BasicFilters: - Added the ImportGeoInformationImageFilter providing a workaround for metadata handling in pipeline execution. - Added a VectorRescaleIntensityImageFilter, which rescales a vector image on a per-band basis, clamping a user-defined percent of the pixels lowest and highest values. - Added a filter to compute spectral angle distance image with respect to a reference pixel. *FeatureExtraction: - Added a set of image and path filters to perform road extraction. - Added a composite filter to perform road extraction. *ChangeDetection: - Added the Kullback-Leibler distance change detector with optimized algorithm. - Added a Kullback-Leibler multi-scale change profile image filter with optimized algorithm. *DisparityMap: - Added the DisparityMapEstimationMethod, performing local disparity estimation with respect to a given transform using the ITK registration framework. - Added several methods for deformation field estimation from the estimated disparity map (represented as a pointset with associated point data). *Documentation: - Corrected several warning and French comments in doxygen. *Utilities: - Split of the OSSIM lib to support compilation on the mingw platform. - DXFlib integration. - InsightJournal code integration : ScatteredDataPointSetImageFilter. *Platforms: - Corrected runtime errors of the interactive change detection application under cygwin. - Workaround for ImageViewer on very specific mandrake version. OTB-v.1.2.1 - Changes since version 1.2.0 -------------------------------------------------------- *IO: - Improved support of geographic meta data handling in pipeline execution. *BasicFilters: - Added a cast filter otb::ImageToVectorImageCastFilter to convert otb::Image (templated with scalar pixel types) to mono-channel otb::VectorImage. *FeatureExtraction: - Added a contour extraction filter otb::ImageToEdgePathFilter. *Visualization: - Viewer accepts now otb::Image (templated with scalar pixel types) as well as otb::VectorImage. - Added FlRun() method to the Viewer, which execute Show() method from the Viewer followed by the Fl::run() method from FLTK. *Platforms: - Minor correction of otb::ObjectList and otb::List in order to support visual 7.0 compiler. *Experimental: - Support for python binding compilation including itk binding templated with OTB images, OTB IO and OTB Image viewer. - OSSIM has been integrated in the OTB Utilities directory to prepare its future use in new geometric features. OTB-v.1.2.0 - Changes since version 1.0.2 -------------------------------------------------------- *Platforms: - OTB can now been compiled on several new platforms : - SunOS 5.8 (32bits and 64bits). - Improved robustness of - the Microsoft Visual Studio .NET 2003 (7.1), .NET 2005 (8.0) - the Cygwin and MinGW installation. *Common: - Various bug fixes and warning corrections. - Added support for ObjectList (ie SmartPointers) and thus support for ImageList. - Added base classes for image to image list filters, image list to image filters, image list to image list filters. - Precision for internal calculus has been tuned to double in every filter. *Multiscale: - Added filters for multiscale analysis and synthesis based on the morphological pyramid algorithm. - Added automated region-growing multiscale segmentation algorithm based on the morphological pyramid analysis. *Spatial Reasoning: - Added support for graph representation of RCC8 spatial reasoning relationships. - Added filters for atomic RCC8 computation based on two segmented regions. - Added filter for multiscale segmentation to RCC8 graph calculation with optimisations. *IO: - Added full support (reading and writing) of the HFA image format (ERDAS img files). - Bug fixes on metada writing (now works for tif and HFA formats, limited support envi header file formats due to Gdal limitations). - Bug fixes on memory management in the Reader. - Bug fixes related to the IO framework on MS Windows platforms. *Learning: - Added filters for learning, classification and activation map of data sets using Kohonen's self organizing maps. *Visualization: - Re-factoring of the base classes for visualization. - Re-factoring of the viewer object (and viewer apps). The viewer can now be used to visualised large remote-sensing images (Quickbird, Spot5) with limited memory footprint. *Applications: - Minor changes needed for the portability of OTB-Applications. - Added a viewer application in OTB-Applications. - Added a interactive change detection application in OTB-Applications. OTB-v.1.0.2 - Changes since version 1.0.1 -------------------------------------------------------- - OTB can now been compiled on several new platforms : - Microsoft Visual Studio .NET 2005 (8.0). - Cygwin. - MinGW on Windows platform. - LUM and BSQ formats have been added. Note : On MS Windows platforms, if you have any problem related to using the OTB's internal version of ITK, you could try to use an external version of ITK (use ITK 2.6 or later) by setting OTB_USE_EXTERNAL_ITK to ON and ITK_DIR to the directory where your ITK built resides. OTB-v.1.0.1 - Changes since version 1.0.0 -------------------------------------------------------- - Building the visualization functionnalities is now an option (OTB_USE_VISU variable within CMake). This allows you to build OTB without Fltk and Open GL. - Improved robustness of the Microsoft Visual Studio .NET 2003 (7.1) installation. - Minor changes needed for the portability of OTB-Applications. - Bugfixes related to the IO framework on MS Windows platforms. OTB-release-5.8/Utilities/000077500000000000000000000000001301006202600153715ustar00rootroot00000000000000OTB-release-5.8/Utilities/Completion/000077500000000000000000000000001301006202600175025ustar00rootroot00000000000000OTB-release-5.8/Utilities/Completion/CMakeLists.txt000066400000000000000000000006001301006202600222360ustar00rootroot00000000000000 find_package(OTB REQUIRED) include(${OTB_USE_FILE}) add_executable(completionGenerator EXCLUDE_FROM_ALL completionGenerator.cxx) target_link_libraries(completionGenerator ${OTB_LIBRARIES}) add_custom_target(generate-completion COMMAND bin/completionGenerator lib/otb/applications otbcli_completion DEPENDS completionGenerator WORKING_DIRECTORY ${OTB_BINARY_DIR} ) OTB-release-5.8/Utilities/Completion/completionGenerator.cxx000066400000000000000000000077321301006202600242570ustar00rootroot00000000000000/*========================================================================= Program: ORFEO Toolbox Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved. See OTBCopyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "otbWrapperApplicationRegistry.h" #include "otbWrapperParameter.h" #include "otbWrapperChoiceParameter.h" #include "itksys/SystemTools.hxx" /** * Small executable to : * - find available application * - get list of parameters * - and fill a bash completion script * * This script can be sourced to be used, or deployed into a folder such as * /etc/bash_completion.d * For choice parameters, the completion will propose the available choices */ int main(int argc, char* argv[]) { if (argc < 3) { std::cerr << "Usage : " << argv[0] << " module_path output_script" << std::endl; return EXIT_FAILURE; } std::string module_path(argv[1]); std::string output_path(argv[2]); otb::Wrapper::ApplicationRegistry::SetApplicationPath(module_path); std::vector appList = otb::Wrapper::ApplicationRegistry::GetAvailableApplications(false); otb::Wrapper::Application::Pointer appPtr; std::ofstream ofs; ofs.open(output_path.c_str()); for (unsigned int i=0 ; i < appList.size() ; ++i) { appPtr = otb::Wrapper::ApplicationRegistry::CreateApplication(appList[i],false); if (appPtr.IsNull()) { std::cout << "Error loading application "<< appList[i] << std::endl; return EXIT_FAILURE; } std::vector keys = appPtr->GetParametersKeys(); ofs << "# completion for application "<< appList[i] << std::endl; ofs << "_otbcli_"< choiceKeys; for (unsigned int k=0 ; k < keys.size() ; k++ ) { if ( appPtr->GetParameterType(keys[k]) == otb::Wrapper::ParameterType_Choice) { choiceKeys.push_back(keys[k]); } } if (choiceKeys.size()) { ofs << " case \"$prev\" in" << std::endl; for (unsigned int k=0 ; k < choiceKeys.size() ; k++) { ofs << " -" << choiceKeys[k] << ")" << std::endl; ofs << " key_list=\""; std::vector choices = dynamic_cast(appPtr->GetParameterByKey(choiceKeys[k]))->GetChoiceKeys(); for (unsigned int j=0 ; j < choices.size() ; j++) { ofs << choices[j]; if (j+1 < choices.size() ) { ofs << " "; } } ofs << "\"" << std::endl; ofs << " COMPREPLY=( $( compgen -W \"$key_list\" -- $cur) )" << std::endl; ofs << " ;;" << std::endl; } ofs << " esac" << std::endl; } ofs << " return 0" << std::endl; ofs << "}" << std::endl; ofs << "complete -o default -F _otbcli_" << appList[i] << " otbcli_"<< appList[i] << std::endl; } ofs.close(); return EXIT_SUCCESS; } OTB-release-5.8/Utilities/Data/000077500000000000000000000000001301006202600162425ustar00rootroot00000000000000OTB-release-5.8/Utilities/Data/CMakeLists.txt000066400000000000000000000024201301006202600210000ustar00rootroot00000000000000if (UNIX AND NOT APPLE) # ------------------------- # Install icons # following freedesktop recommandations # http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html # The different icon sizes installed # According to the specs, the 48x48 icon is mandatory, others are optional set( icon_sizes 16 32 48 128 ) foreach( icon_size ${icon_sizes} ) install(FILES Icons/monteverdi-${icon_size}x${icon_size}.png DESTINATION share/icons/hicolor/${icon_size}x${icon_size}/apps RENAME monteverdi.png COMPONENT Resources) endforeach() # Fallback on "/usr/share/pixmaps" # See http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html#directory_layout install(FILES Icons/monteverdi-32x32.png DESTINATION share/pixmaps RENAME monteverdi.png COMPONENT Resources) install(FILES Icons/monteverdi-splash.png DESTINATION share/pixmaps RENAME monteverdi-splash.png COMPONENT Resources) install(FILES Icons/monteverdi-32x32.xpm DESTINATION share/pixmaps RENAME monteverdi.xpm COMPONENT Resources) # ------------------------- # Install freedesktop entry install(FILES monteverdi.desktop DESTINATION share/applications COMPONENT Resources) endif() OTB-release-5.8/Utilities/Data/Icons/000077500000000000000000000000001301006202600173155ustar00rootroot00000000000000OTB-release-5.8/Utilities/Data/Icons/LICENSE.TXT000066400000000000000000000011061301006202600207760ustar00rootroot00000000000000LICENSE Original GIS icons theme was created by Robert Szczepanek [1] and is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License [2]. Fill free to use it for GIS software or for any other purposes. I only ask you to let me know about that and to include licence.txt file in your work. [1] http://robert.szczepanek.pl/ [2] http://creativecommons.org/licenses/by-sa/3.0/ TITLE: gis-0.1 DESCRIPTION: GIS icon theme AUTHOR: Robert Szczepanek CONTACT: robert at szczepanek pl SITE: http://robert.szczepanek.pl/ Cracow 2008, PolandOTB-release-5.8/Utilities/Data/Icons/NOTES000066400000000000000000000004771301006202600201400ustar00rootroot00000000000000Some useful command : Pad image to fit a squared size : > convert -gravity center -extent 128x128 -background None input output Resize an image > convert -resize 48x48 input output To generate a MS-Windows .ico , see : * http://freecode.com/projects/png2ico * http://www.winterdrache.de/freeware/png2ico/ OTB-release-5.8/Utilities/Data/Icons/action-zoomfullextent_24x24.png000066400000000000000000000023531301006202600252430ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<hIDATH_HWƿٹvSCRĔLH!P*]D"BB$Ї@A[$J(bUK$[Ai]ݥ!::;;3!j˜sߝsP;2OH#rnT4veJJʕyMӠ(XY]mm϶Aqn4%A&ܤ,P(D$ZUpVh=555!/..3ЮϿF`u=z /<(7=[R"n)(e0y;.e](BeQQʷN|755|N)uRJ&cq\բyDQ\Yp{,P,Wͼ<&!R)}iq.Iܞ kZ{O' A4msǦU蚦8Caa!?6;Rgu+4Mht>dILQ$xxB"@owEEIWfVxA0fӡ;Փ:Փ{royB"cl`']h/ {$EY}CxzI&~ .1~gge]O< (=}[Oh8{EғQC]n.nבHp8\X u](HՈ4W>e㏿M7$╾[>p~ӜL  rTIENDB`OTB-release-5.8/Utilities/Data/Icons/action-zoomin_24x24.png000066400000000000000000000017171301006202600234620ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<LIDATHOhTǿiMn;"9E َv !il.+"zQ8VemRtzR:mKw,hXd;3٦/yi4Rg;aV~EHiJiJ c1Rq"WՠsKRt2iЕWGFGG/cim8///>5Q_,K~qbB!̅뭃{QZ Jŏ/{2(J(l6Q^ptԊ%\.Inp4%BȼeYr>&0ޝ8vz ,˒ !iJiMӆ h6D^G 4MOPJu]EQ$$A<2tH Q)̾77 `Ϫ}M AR c( @r>M)Ƙ.8anr]RHINѸi;^i>lwwsw:6 q1e۶q=8 lc[xccCNuVq!dH9(A0r9X,zZr[:y*2a\ Mᤤ<55}y2NG Ø ɷ@8U낮벪Phij3}{k@p!$-QWo B+++]=yz9 ^}x{yuuvJޞ˷?|Q@RTyy?weM0s'0ɬU:O85`3nIENDB`OTB-release-5.8/Utilities/Data/Icons/action-zoomout_24x24.png000066400000000000000000000016511301006202600236600ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<&IDATHAHVƿ7yuuk)K)uzX*P(t6-llO^:KB2TE=x+xM2n*a)DKޛ׋ ")u]s>K)Te1fPJC)clا䙠\._',X5t֭ѱ+8<>~ AxB\2 8糖e J%b5QWJ%X594NڶJH0ɳ{e۶N)2(iBUU _|= `0Mg0 0R0 0 as&) CPJC c)^,ˊyq4AReN}?Rvڭ֟y~4 lM=/jFi `xEV1~7N-lɚuff&:y7z%qDYVmۺi0 a"NSqߺwh>YǃG WiypCgiBaD*}vw-rO|QȰ{ORDw~pP~GӾT8pvǙ.jze S1FnIENDB`OTB-release-5.8/Utilities/Data/Icons/action-zoomtolayer_24x24.png000066400000000000000000000020011301006202600245160ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<~IDATHK#WǿLl$Xgt^ XfK>h"Pڮe`_L)(Jn**mi$2hܹ}&5b}{9ܹc4pllͲۂ 90 C{b6٬y;IT*P({֭~ogg'3!BpdY֧+++v899V"!=EA&QJZ^^ JEA2Nwb۶iyzzD)5#N øӨ ?Gm #P;9V¶s@Q,,,mfKiwwwx]7nZlJΙk\GQB!!6J%Ȳ O[[3{'  J$ nG)ue TUA]t(EQa".^nC@JeKmr A-+$ Z ^w 888cIK@ooo#ǺcBH0햀h4b P(<h1֐AE$Gs]בdjgy%`ssX__oMMMahheYtv]oWqkc!dY$IT*PU;;; _6M,ooP.LLL H@QJ%Z"@$0`h-/hp7 ǨutuLA@,C,ԞU^2o{_c~NGw>A__ߕ}w"^4_\51(EQ1:x%YY/DޝZ1lc?h~0==]C2F3{2'7Z˳.^0IENDB`OTB-release-5.8/Utilities/Data/Icons/alg.png000066400000000000000000000011141301006202600205630ustar00rootroot00000000000000PNG  IHDRabKGD pHYs  tIME q_ZtEXtCommentCreated with The GIMPd%nIDAT8œJQXNm%0Ţ@2:O(y!:\&8&-3(-vtbM7.zVs9?߅[FbT0n^IENDB`OTB-release-5.8/Utilities/Data/Icons/document-open_32x32.png000066400000000000000000000030161301006202600234410ustar00rootroot00000000000000PNG  IHDR szzsBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<IDATXŖ͏G13 L>8:bD!=ł+$$ BI-$$2N80H !h3;3Uag{gzfF#}DE|з(.T^ObAͦS3yn_zw;Y}'P.^(Ozq#s1q̷N#y{㵷k}3˾__./d!RBkRJBTU<U@eiV7oޤjcER$I?]#֎o(T8sAR:u c ys]w~g(1Ibiik-ι RJ^{UYyc<À PJaCt:ۍ .ƘdBiZ6V=J)jaͷˁ2A=?,رcIQ cc߇Rs#+eFCnmmO:jW.c EPrv]0??oVWW&>t\}!8 dWF{nuFΏ6_;oFz/_`105c ߒ#>3?&AU5YftYZlngz- w!@ &J*',Iާji. 5ޥh9M?35$g/nB@YKj<5pba71d#Ԓ81kmjGix@"n[K yTE?N3!\cc;&w(%X11H-xQ1P~ pԩO-֖̋jc8Y&NM]\hmkj ؐ1enzL^{1AQjƲӋjj!2unl؍ qf1ZNIFOs`0խ思SnČ$-;GAFߎuZIsnH;0dƍYu gDbl\JNr:.agAMA|QiCCPICC ProfilexMKA!^.`(AR&,:˺YBХd:r y^>@ u ٞ! 4033y0"e侇.i$Ւ1(Q~~ 09b]<>hR%X޼&^zy<&%/i^8Y[aX&470qx@\c|Ƹ̷N,ҹtZ+raX(րзR50||G pj%Mf) 8lQtyl۝M% יƣ^8ͼ~^N[@|XX!/OL.9?.M}Eb%яRN,rrTys cHRMz%z%z%z%z%r2` pHYs   IDATx} x]WuYWg[eKNęмRRBڒNyWZH y$Аfj@I4P(!L8mͱlپ,]ҝ[ɹҽҹwϾ{X{^{(J0@9 0@9 0@9 0@9 0@9 0@9 0@9 0@9 0@9 0@9 0-CZڃ]&CA98\R9wNge جZټb2KLXj2!d$HDdTI$F&өd<VD<WsNS:7 дzurmu$[ˊl"2nwJá7l2)VYK"TO,"e$VFQ$ ċAEyY1ZZΦ9}N3@Sc2>~jX˵T)n˥(`PL~b J D7 * ߯ ޱpP2"a蜢 sys-.fڶ\]P;HQ3 B B :H2i_+ J($&0C~~r?1$H<񅎎߉|пsTW4?q:PRR.Fo+&G1 b&A訒S7 س:bJ ˌC80A2PxP~Ȉ1<χGh\% l,>{ׯdnFonkYYJ]XX**ĎM=T)b!^3'23bdsLwKτѻtt4{_ pڵEP}^EE麒Ņ^o^Lb9۫s%x:t@f0O1&DiH}}A_(P,voSGǙLKeuuWlw`|߹\)+W*Jˣ'O*qb&ITt#3^1L`(2A餎a0<|JHd'>53UQwhwT\QYim˗+V? rIM9 s`{P&^)Nbq]A815bHO;8aRTX7G0ҁ阞"a3c~uT4Ҳ*-:UWwcM~=,[f-ŔQ_$`k@~:^]ĦMF(z,w}Y`,=DzbX0|n`]X%N3 Ű888(Ty϶ hHzG}66vˍ^/,̋2j {6onZ{kjLEUUsf%t9qb4Ax DCrp [nȈ^NbAwan>>3Mmعre$Nj]~>9hJ ?30> d ?8排@ L08a8)%l0xE3|Y{ue|x5,j00 2 s Q ).l)/,4 L)2zopɵ`60SNjCMhϖJ~~(}b&lɆ Z =;tcPSSyG K `kꟘ)ҟ5Y_?Ďe+IIMpR F6k/+)/x5MW\|_(;h)2B0J7k8jy8pvP&z艋:1/6x1rn?L Uʉhz #b.+ Єשּׁ|p[Ir` tCX5TRkK}\e`0vNg80T$O{/,.nfOo>T]ۡP@-V0e;t8 V,+{g>uuKK(Аɜ漫N_ikD:u+`3-7fW0~ [o)w9`h&E;0(PЉiPfPrj邸`ď%Zr׍ڧ“_NL<Ŝ7n!d8ak~VO؈M :6,rp6Er4_zÅnoz[нy{{`vH Tg  c(\Z *Odc1|K"Wa AUBl`Qh{1#:X. grVyӎ lܮy(0p5Q"L<rN0"zF E+ >r1N$5:65ixB}#+.:3lJ=\‚ vfoᆽ?Զ1L>$fy<Ź4Sf[v_p칧m] 5BINkRcq֭yFj(|e˖X񻀦Oz61THӎqhT[n^0GTT2 nak6\Ly~(f= ;0+>w,Y0%@/ҦL@% ]9xaԨ=DwK'KJoLpm)-J]3՛##?CPm!82*+KP ./m",Eec>]0O}x mĠ/uxWzTaA3IPiCa60O.M8ž߇!s~zm0*lCS0ľL*64h+a :&bT+ѣHnP,]<Ǟ*wd]G'nI~Ób_=غEz1/UǠFc,v,!AB)CZ.نDqupb"m|sH3w"zu GɘYub{q(fRNwAA?} Ϥ2#9 [,e6gRLi cQ Z-hᬿ2чw^z"v5cc?*U]zDlyiU+(9GxLo S!tZЃW3ZfL`=07cJf6g>iS-kI Ti`zwpJɓ BT&fQ.Τ763$nL~3ǽW\V) ;aC|@8n6XuZh_vc!+D;J@j~ ._vB G H|3]2q"`S1װa WSsJ/2\=! [s;28'!q4u O!3Johu0%ߨ? @7l0(EsOor F LY vkNnt0`Rd#쬬iw@xL $iaJ " Pt:ea$M%<zy_rkkX B@ e(`^`p^юEo 镀=X*^nj+nzVryu"ZZE">%`Bms(3^޵}X A>H2qǒL:`;EwHk"._HMf*^ϏgPr@H?4j Dp" K\}fF޴k/g8 3ySI0l0w6E^*ƱAOŽjƹ=_}U4-N߅pty_v'\_0J0 S@!p(`CЈ_Yao!1Cdnw(:RÂEoP/L ~T01^c=A! `5Ҹu)$r5׫}o>0'pLW')}v X:Tk؅I;; ";P68 gBԡAؐYrɐI 8o& F=q |+eKcA'~VS0B!$ s^ #h9(2K1+) ٰ ^SzX {/L-aC** khLU6u|NGc/JqYHFḶ̌n(` (gbla|'rl%o\f{`滭0&sű}׿A}k7nACnJJ"g9RP2|ڮk(@Q9 -Mw!7Q e}wK+@,,>ITqRtr8xw{l TXS A(0tO7 @ф^4jP$>. WC Q~h(̊uv8p)%pM Q|= ƽ7n,p8aJv1N%`٩0|KssLeg 1?=G8  )E( C8Ejhqg1]8r)n}R=x}QLNJְs#̣W' B7a&<3AMp,Jm 0mi :@OBPp_/i¢L¸X_[XXiO&wRx;p2^nCQA0Wlϧը 4QB~ Uq)"n!ñm'wݍf!Io:zOHK—|_/N Sw(܁m1SOFC&aIn{ g8 q^*93 0#RiۗvQ--w6)W$|i ֠jB/Ê pzeC7@"<&29 ^QUuh,br6Lω8lي;Nb}rG>3@M5C︴eek=~ "q[h%w:_)[:p ֿonn;S @lvZf B7=_hh,̢v۲e1ML;;{0dMo 0kiLY@X/*=+~"E ñ-ţ!c<~+2K @_YQW8bRI!B'0da]+=yv`c6sEEE=.%aı-!pmN-ر;"n:D+N>t2t7".koC-v MA78"'_xV܊mĜEϻHG{1c.̽K˜B n7raJ-s_:Y([QqYeOcs&hH 6@O07&x?%{Q NdV(9eRHpf]4ywGѣŧjSAy=׃ლ?vdent軜 :8nƼ §qߦl!A '(9o)gX/ E!)@J8 O8 IDAT/ @ы'a!CǴ XbySl}֔@5B!<ξ}DWӪaSL\Q^n~k#KPKpC=tn/N`z7L˛Kal1̅cWP8|btr.3 N7. yVx:JF\_KcY3T;N5=/Ϸt/ u0(TFR{*GĈLC lk˗_^^~_T55`W·0Tc [ Sak({'gL7qC]2f 7pp4Ǣ3Lv#m.2l?^VVL)p ƚL!H|^Nk+(%.F/C a0vN HN@ïp'#F"X~0ғ17=:"뜢jk{WaOyS;2nN6J+ܑ#[Q?wzX'bh*fP:(e9k}(;`kRÅ ͘T~1pIs%@zCM^rK q(ǘO>^t1:M](Mڸ' ؛e4H8,d"תsHF2gPif"oaq qI74pDP G0SEy5yi" pŐtc$>]1:^/$7="-K Y힍kpw1(NA0dR1*t d 1b2)rY( >ǛHßAg1}=\,&<} gN*w{DL "I=up^^ybJ'\ѣ5MnX Gz∏D=cc1jl׉QC B"ȞH$HZl%c=% P]g>Y {Ž!=@ (Vn }&/ߣ._n:|:uNL"#~_';O=v^ Dx߱K9a78/eҧ7u:H3LFY3P׷ql&l!3a}y; ȸ8}KLș2(v80M[FqzN;Ix&?=1>~7OlG6~xP;G1!(a|$y*3a2A2_ϖ-TTPJ @@2Ffa 9DP_<~dY:=#sx ONXדHx(x~0s=yd%\TG>|HxKeH7RX&ZH ȇL#I|II&pOau*(U@E?Zwb8ak!/tL͝Hy,n㢤ts/+ ,dG$w/X&I\-w)d:A6"ȱlM}AA#k3Ԃ ] FĘq[yqknnPd1zx{ /yIDG$b օ[[&&;yW ;5w<Ddۍ+RV갚WK&:dt5` \\Zf'$ĝGa%@d @z@S7F"D#I 42ĖTZdyDؘl:Y$ -љG0}G)l]"D&W;8u|W@k $o$L 3dz/C'7k``*JE_ieWW3+U0WljF }< Kxk.2e$bZN^=qaVNi}&CN1t갌OHZJ#[  RT%Z2,}fa|tFptPem:u:t|rdAO'H_'HXgl6R*^]liRSSI/L`lX0@2h½!^ssa ra ra ~1u'J̦IENDB`OTB-release-5.8/Utilities/Data/Icons/image-export_24x24.png000066400000000000000000000015441301006202600232730ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<IDATHKTQs碳ɔLĬ| * T$|^*  QTd88҃]!,}.>NJEj3-M%T Y~ZVx&H$P%jƕf:)%G>sTxu]񲾾`5nWU)Vuknn U.jomm_jս~ hii5;N'4i#?dii)lL=b]`:Lj-%E  2_}5#}HZF@QBCY-e Cm}Z$:񞯣vKYΤL0;7qdoT(^AE%'ߑPf@Jqnƾ3>rGa]ǑO<{oFzy(Ȧ@D.CE8$G[bt]GT4M0 "FH$T, mH#Ah.Bdۙ]XN tMcanawA>pYY4?3`uDl;G+vSƅEA#Wy)'Hݯ[X=>JpƸUp\]t>}~O_?TTȹ5\},n\8@J3Z"M'饟,_D 4Tx˷2i)HSA0WKE60Ckݢbg-Nŧ4`[ h ^6bؿԚ XJ ôLX}k3Η&えU%2ηFR 2DNLm@2A(EACkq<ɹܞ jXEw*ޠ[]K*&ը}'nhv䵵(V@U5pl*[wi|^rC/nBD dܠ};:ZdW8AO2 3-l8PA{vߙ\(`4`GukH؊ݏy צ^ OM$:/~~m6IENDB`OTB-release-5.8/Utilities/Data/Icons/layer-delete_24x24.png000066400000000000000000000007511301006202600232450ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<fIDATH햽jAhD$@7TR'9}+Y,,&׋`t%dM`հ 9 ẃ0pSUO9L+8 ( [}p4-Kv:9`X*e)jtrlF# \bjBmkHE"ܤRi) \'a Hؾf:wzTPEyh4kIENDB`OTB-release-5.8/Utilities/Data/Icons/layer-up_24x24.png000066400000000000000000000014001301006202600224170ustar00rootroot00000000000000PNG  IHDRw=bKGD pHYs B(xtIME  0/SIDATHǭ;kPÒ%cǸ(Яf087sCzɚ)BL(dkұ7($BLȱ-C6^stO$" ^`P}s)@UJ`1d2<ֺ S+,MxsP|g`4a~q~Dyuv[̖9)"ؽӈJWE^\2LaMnFUzQ!e8aKX# J@]jFKz΍ B D#*m)$c}j Aء*m*@Ub+8$L- <䢌ɈQtڰ={'-g>SK*]p @@,z_Gu4zG󅪰|9I~};H MS \~\60 Ui>1\]x|P+OoCxceNQ:) >b{B9s#ЬKn )#̀Va AiAkmR^9W!g3qt^k56%Aۮf@{A&Z.!KUwN8Z腈H`NI Y0|V4&IENDB`OTB-release-5.8/Utilities/Data/Icons/layers-remove_24x24.png000066400000000000000000000012221301006202600234550ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<tEXtAuthorRobert Szczepanek_V'tEXtDescriptionhttp://robert.szczepanek.plYH`tEXtCreation Time2008-12-12X.;RtEXtCopyrightCC Attribution-ShareAlike http://creativecommons.org/licenses/by-sa/3.0/^Z6IDATHݖnP{A6x b}gݑW( O`X0&61t) \ Yѥ:qȶm %4Vժx.m~-Ym*>?{֚qYɐJn SZ hа eβY-{0k0;l9fXo0x˔7558PX bϳ˪ub`܀:mTww=s 7xjCvy3 oL$sGN}Gz>iY!T*1=I榘ye^:v)eo˲ִ} x+RD"FUn/ZV `%\w{qFUGOE`-\`C\ D$u  D|TZWx(1h(?hxd7nSKRW*SJ)gv ׍+׀ (KD>CF׿/3魨IENDB`OTB-release-5.8/Utilities/Data/Icons/monteverdi-128x128.png000066400000000000000000000314761301006202600231450ustar00rootroot00000000000000PNG  IHDR>agAMA asRGB cHRMz&u0`:pQ<bKGDC pHYs."."ݒ vpAg012IDATxweU'|+Phhr8DDPgGӨ 2E2B;"AQA2MB:T9[7P:Ty>}'kZk(F1Qb(F1Qb(F1Qb(F1QbH7n}m]_P8͑RuAJn{[ۖx<~nBu+׮ m ޢutuMC2_ >M8 㱐mùFӴH}eÄau}fUu5c^rB2p-;JknSu(%BA"(x{۾?P pwخB~{ю;n@Ҩ̜E=/0 04_E9 ;GJ/+*I[Wʑj)ejln|UU7œoǓ/94g*Ɲ};Mu]'$O}dUHH]zpHPpBH)|~ ?*4Uq]b[n@UՒh"!%q+͓n?5i葒D{`8!@~,,(߿ /X88w,l)GDzٶ]覽~؂ z=_{mwKDsdx0Bc]͓B2RB+]}@!]lj !\R&PHEt]HAaQߘy}Wuhߛ.:)0(x=W\u i BQt@UUԴ#%C5)%NXD&?m{\Rz]$(H)gNM|R !EK4-zi=/=͹_9jvt'Hf(;=ضwu=Mx P ~b vjf}=#կgo~+?<\yfWȬ ӱPUz|^<MQ5]QQ%{_)%RJ\q],Ʊ,L"LH$H$mwZ7G R\hw0@$4t#z;wvu]4whE}@JB! `ܸq7****(..&??`(Ûa"r+q\lƲ, IkK ձm66oق)NZQPP6}|8n /IysmkSQb@j 3PaYY}p)ٸq#7p[niN%]x(x|1QrEUz<'ǀ.B].X~X\ӲM!(.*b\x,>\MF~~%DC__m@{PU]׻k}05k_O?֮3a\Bztɓ'd>я`&GnɁ1B $!h~ mѸi?vO&23|*.R&MǓ9Gt!ĐkofPII؅ Ҵp(t.ep 0e„Ev/;߶J8唅tM\PYY(/AMDJ;xϲ,8RJݯiqc.lpLERw(V^^~.e0l8{nhliat̚9[>i*++ZJ9`F444u6mDmm-5jW ?Q9op$ PVZƸxf h=Jל@6L3bՎ몐-Zėe.RћL&ٴi/ 7o g?]˲{< (W`mmzz)JKJ={6]tK.iӧgW9:)yWTM !2ap2?/O~mۤ2==='?)(,:T"u=qxz}G49y$nD"ٶe}Rvvv3cu]%/o$9}_5:(-,6igFфW 7H^^^ܞ^{5| zm i؎cǓĽ^/ecI"c9۶ݹvgO|K8>di=z" ?־Bmip~Q|ϼh?j*+kZ4,/"O9s&]kV{+>Β?@ńz:)$ Ǟ ??"vޝf+ލWJd& WMҩg׼ik%ƭ{._XhQjtƆAD"ql}r?'**6q?L?{/7oz3~&cg"KGTP})yyyTTTd;M2AhSej[@ɫKUy9";i< lڴ/y'7ppHMg{eٲe<a BP|<C)KBIu`đ%DKHIuI#Oi0McɱDb^,fܸ{\x+O<23ټ۱xcbp!?g?)?/^Aɘ {!Us?5B;d#rݏ{XJ離*㸮8aw}7'|2~CDe3b`iZl M\eS3E6-dxTejD ͞ odϊ3O$H&+I 1.mC*%Ry(th^j^^rm֘tdU0 :;eYքS?\ȤA 0u„Y _,; hnn;6O<XPXS>BEHsHOa`HwN< ߟeh;ލޯ00=LIpdvzKǡkpb(X "M(Z6HBA=tԮ`etw֊A JƠi:uɁP\]LBDGH(q8C5Iז.ޯgϺtua"%ɳF[U3ݔMs$뗒 m^/% %drb{W׿t=fb옊,*}2~xv=ܓ%L9jp? `ѢEL6k`;;ޣ`|d__!ٺ=^n z⪙UL?n{N< ӵJH!jI̡qEvX8˶DtOz\->) Rr0p$]ƍOg .Le:~I\`Z/XbE`).[2(\}z^RRU]G/e ښRw-S0{M$2Ї/a*'΢|)k@lsKg]c߄RC[0ӧΠ#h^֗gfet G.0ŕ|Tebf~Oo?{7iks1!s93id^UݓHUU'p+;B&^=T$V,=90c P6(|hO!hmm58vl`6G n H$N>SPs$Nf^Ox{ikۤU Rիtm0fk}_c׭]K]}}BG@pIA@AWWwu?ĠlוݾVj]HP$A$uMm;lDgČd˃iFos_^3Lg:=R*s(t ӴhizP_vm$(;9=]M!ABb8w=P%%viِ1 t7RLXOլ),-!=־KӮ wő?Zhyh~Wt]^43k.cIjY:ftٝc^UQTnK8O՜ ңC.;c>/lرcw5\ß^x﹇;MbikAŸi, P2\ĊwKgfڛ:G"8 իuHPMyWΣ$ԻvXofs"eE)%@`4-[R޲i_Ab1%LU߇G?F7{뮻MӸqqb; P8aFB|0HHL&pC^n`a%Լ3ntx U8 0Q۳woMOOOa0`X"W{ұ ~!{޺:*njᮻ_J(LX3|I;FZEwW;t.2:,VZ_^|+WRW_O4MmȔ*y0SNs墋/ftvv裏ͮtiʴ4=5CRK). C]s}"VBVuBWJ /|?0iZY^~_ԔQ/}{p%p={hii7?~<3f̠,T__OQCۛ M 3=I(E* #@>TEid*bEDX,Y7xW^ySO9o|-"52iFuu5=?H$Hںi\ȴ)ӎY8Id8Cpd@#ЛHQE꺾C/h3$xs\?D"A4eҥtP^^ο3s qE4(,ظ6F1yLv^BhMiI0F"12KyE-FR*~ hiiaÆ (BO~K.o@!HdiHkut^v"rEB BuRwףwlSJKKkG^RK+Ocڵ+4573w\n^q-D$HG]xgخB9L N,'! T7Cr<` Bp~ 'dP4GGO;xNz+ t .=Q4pQBndφJsaUc0J `Б~UU k|>qt;I〿֭c…\s ~;EJ.A0۟cJu|H3;䈙@(ȖZ= wa1iN:XixUJGWfǶ=BzWXE8{̲,<oq}K)LXJnt9BDO`3;G"~tk?]AHlEQXj(*.!Xk/_}5 +ضtøQm!%c 8\R\¢EFI KSu$hUHo?6ބetCa%Ex7F^5j. >G9IZ kg`]~y6!,1(rBv%Mi]]\ ߦmwsF>B?ly_4;OCێ6f_9y%aD@d?%1 ִQz->M,60 ygUa,'5`u'/wahQXΝ{\˲RCRr+pAO3al\2n8&6%x $bFLhJz!^wj^:a_ x?ǔ;JJ_ԾߪkL&U#WY*:3VT8͛7&0 HN+]]Rr;o 38FZӖH">6Ķ ia$ $IIM s~4 ;mʪB^(˖eQMwI Ո#XRcxy9s>#?mH$DEBdt@HJ> >Rc454XD[k;e&n[9i M޶~o.-.~zytM шc1"@CpTO>){,?Ix<>`. ~OJw$?}\R{PU<$!C*g [K{Z+ iO?l_yqB"$:- \F_wƦ&oR\p۷!~!8PP|&#w+.Tzx.&p/ P &(*s@+Q҄.U`n&6cڄ[ R2W\RS:]JY"BkӓE!<~N 6| p].bW gˬC>S 7^ !PNfkRHIaS %A)Ҏ0}0MHV~XRX`⢢x<~a))pQl+$Rݰw-CJɴin\UV /dSЧ:Ke$A[AotMKeC]@^0\iIe0 O>_?OƦ&r[oeYGUtuvX KPG~< 7MSƏfKK5ݫ7oedHYy8vi.2,k\_W `@~CxʧP6aecyTk~w9hNJT̼B ˰-'=DLi S=~dH+B>kyyt8/jonk*ap>sλؓN]sx7ɞ:HD:18e86qSXQM /#PX7cصuMAJhBj}/B򰑤7|>`ֶ! c뇖m{J*yx&J!G "q,AJ\2%r/BhEV@4 b+q5M ׹ǗA<&]^2$R)MC[-!^Sp1EQhkv3رŝOD)R T}H-zuj4HI`Qy sV#yL`k?vH pPV{WWlaYY]n ' !h+;W,~Wj< n4e>h,64Rf#PjT9=WKd"ӗV>y}PS@8$fw$1deۧ]ьi"d,?xBKiس %%yoWO7}4O5-qX!52EPo3f%1`"_&o&f(vs--/6q"!;{Ѧ1%%k=ٴ1w_'\ƈRxVZ׻(/46ɜ8y„Ui5-t]+AS(*y6RO}ZT ]ТQI,UF^Z\JJѫ+~P^\ںaanF++َ3ٲIhD4mçCp,GpqPA׎ٺ:ZP異p [ebU՛eU:3UJ8l,ޖ.A` *JDu!أ|>4MTE1~yy|[L;6?ab_LƸAN'E(*JHII:9N$>UQz͡@‚GfNcY knf0*PP\9)YOR#Iҽw uߤ)%]o ?.+(x`޽X};^~yvO$}dv'.IϷ%PiӶ,iEP/=}}ߏ%Q4Mr"ճ!\9 <#CKozym(=se-7+?X=X"qaL*m[H|.2Ih隶- _SVw=m_J̛1޾mIèRx(WB#qUQ /qzӴm{ұ>go(UYQCv<*~'FYDbiYU㔸R%UQ(UU[tMݮkڇO=>JZ nU<+'uvǯ6LXJkVQ>q.UU-GIq ͻV%i (S_?1^~Yuma~SNQM;v,%_ff(B),r Ᲊx+P#_h,vY<<0enbiNj{|hj8=麸cضmئe8ӟp!Y>>,/ock?IDAT8Kq8($H1DY^6-Ks6AhUD /A$(i^ H(/DQiaAm̕=p$/'gkjQ6̎$$&*^[l[}^&<`FZ؝6 8:mh[k Ԑ$'ç 45+{ jzvTs8ӃWYGʚtcmfn޸w3&t+CLcHKIAniPc{D\aaib6o˃a=BI=(q0Jj(Pr P.X[z8i71LImht|~Uv1"{3 5q+핔^G'/|qkRc5 !{\U^VX&ٌ0J\.uu(UC&D98ƊP')şV£gDL0:U /D"24:pnYCcv .%@qҸq&ӧZ~ks,?PRrH[zwtU455)8mqv@5'>r\_5oޮFsrq'=G,\XDӯokf+߳[[h4j1Fc0gCUM[kt?U/B[>kTռ_Y~}cC!s̙fCkFUM8Npc/ _!~dGX#+Mu׿aEE\rh񤟚Ac$= ՗f%&U5_} ܜ3{|ϗfdӥvl[P}!:8׮~;UU6yv˔^f&)~E"o&SzSfؔ[ `+4UwGhNx"wEno'.'+*ZP]UkDӵNK/O^Xba9^N¾@D(*]@zH$Ďgio&dglnOp?6m ryCGuq^۠= (.˩xl.9\E_pH u'q4.I{C;?g ؓ%fRXRje#o=3[BErŚY4fMJJOMG_9ïvZuio k(o_o|z~/Eke˽ jW?ӞxTTVR0d" h";%Ȗe.rRMO^OUntTDЈl 2h6AE4Z:>B@D*18 %cƠrOWJ=v̹l =~(`Ac_:e2x"@T Il?=VLxcnYgcь]@@s656S| E+5e[ jj/ɗ,"ŪY(&%DE aADPU1d#'ÁUf t?X|6{ҪQPK؏^/O!2{dţotz8uXD8pzg~ r܄UDp;.MIeWFAIJGP%p7*6[S?o{y}ZR-gTnYSiSmy4WpX5dԝT!-o(i`ʤ269SRv;q"FT]E x: ,,|!;33vBϧ\q;AQDE:4}UHOt̨R @/U HƝEՋ͡zݵ~nݻNռ9ƣjшJDVhD8|8@{XSm!} )$`T{ܼ YXz睯~JU՟7e`Yy=IJDAEJq=$"^_y{ݵ]t򪉶]<^_uk߰hG[lfʔ 2a[o'Œ6yh4D‰; APreū~hOaשּׂw`bQ`.tq~?uǎG7TVsϾׯT}ĬAegbdu5b z/>;رcm|iӎ`xSX0<]Qo) H:wWFӿ=?2Sz>zaNڵSZ렂^O.i:M*6ǃ[hIENDB`OTB-release-5.8/Utilities/Data/Icons/monteverdi-32x32.xpm000066400000000000000000000225011301006202600227760ustar00rootroot00000000000000/* XPM */ static const char * monteverdi2_xpm[] = { "32 32 456 2", " c None", ". c #212121", "+ c #3A1314", "@ c #340C0D", "# c #101414", "$ c #121111", "% c #101010", "& c #1E1D1D", "* c #720608", "= c #650103", "- c #001312", "; c #151010", "> c #6A6968", ", c #878584", "' c #171414", ") c #1B1516", "! c #7B080B", "~ c #67090A", "{ c #011817", "] c #000000", "^ c #9B9A9A", "/ c #DEDCDC", "( c #474544", "_ c #535151", ": c #6D6C6C", "< c #727373", "[ c #747374", "} c #737272", "| c #6C6A6A", "1 c #444B4A", "2 c #110708", "3 c #650001", "4 c #520F10", "5 c #1A1817", "6 c #4C4B4B", "7 c #818080", "8 c #DFDFDE", "9 c #FFFFFF", "0 c #E0E8E8", "a c #251314", "b c #4B0000", "c c #3A0F10", "d c #070505", "e c #4E4D4D", "f c #A4A2A2", "g c #C9C7C6", "h c #C1BFBE", "i c #E4E4E4", "j c #E8E7E7", "k c #A8A6A6", "l c #B2B0AE", "m c #E7E5E4", "n c #D4DDDD", "o c #270F10", "p c #440000", "q c #1C0E0F", "r c #1E1B1B", "s c #80807F", "t c #BAB7B5", "u c #85817E", "v c #413F40", "w c #0F0F12", "x c #A19F9F", "y c #CCCBCB", "z c #171518", "A c #14151C", "B c #383635", "C c #6B6864", "D c #CECCCA", "E c #C3C7C6", "F c #180909", "G c #1B0000", "H c #0E0F0F", "I c #232121", "J c #92908F", "K c #9E9B97", "L c #312F30", "M c #0F1B30", "N c #274168", "O c #132034", "P c #9A9794", "Q c #E2E0DD", "R c #262528", "S c #253F64", "T c #274166", "U c #0E1728", "V c #232325", "W c #908E8E", "X c #F3F2F2", "Y c #8A8989", "Z c #020000", "` c #2E0A0C", " . c #4C0D0E", ".. c #551011", "+. c #4C1011", "@. c #3F0C0D", "#. c #2B0C0D", "$. c #110D0D", "%. c #0A1B1B", "&. c #1A1717", "*. c #7D7B7A", "=. c #87827F", "-. c #13161E", ";. c #253E62", ">. c #486DA0", ",. c #5178AE", "'. c #1F3149", "). c #94918D", "!. c #FFFFFD", "~. c #2D2B2A", "{. c #2B466E", "]. c #5680BB", "^. c #4C70A4", "/. c #1B2A42", "(. c #040000", "_. c #1E1915", ":. c #0D0C0C", "<. c #000302", "[. c #0C0202", "}. c #360000", "|. c #730000", "1. c #AC0107", "2. c #C1070B", "3. c #B4070B", "4. c #AA0609", "5. c #93070A", "6. c #49090A", "7. c #111413", "8. c #4D4B4B", "9. c #837F7D", "0. c #141923", "a. c #304E78", "b. c #4B72A8", "c. c #466DA0", "d. c #486C9E", "e. c #1B2B42", "f. c #8E8C88", "g. c #514F4D", "h. c #16243A", "i. c #426392", "j. c #2E415E", "k. c #151821", "l. c #0B101A", "m. c #000510", "n. c #0C130A", "o. c #568F54", "p. c #558F52", "q. c #3A5834", "r. c #1D2115", "s. c #370004", "t. c #A2050A", "u. c #E10C0F", "v. c #DA0A0F", "w. c #DB0A0E", "x. c #C4070B", "y. c #510608", "z. c #171C1C", "A. c #373536", "B. c #575553", "C. c #2F2F33", "D. c #2A4469", "E. c #4B73A9", "F. c #436899", "G. c #436798", "H. c #496C9E", "I. c #1C2A42", "J. c #8A8784", "K. c #BBB9B8", "L. c #1D1D21", "M. c #101828", "N. c #19212E", "O. c #2D405C", "P. c #466999", "Q. c #476B9E", "R. c #111027", "S. c #131C0B", "T. c #72CE71", "U. c #78DC78", "V. c #70D473", "W. c #5EB967", "X. c #255E37", "Y. c #140807", "Z. c #910107", "`. c #D70A0E", " + c #CC0A0E", ".+ c #DA0A0E", "++ c #B0080C", "@+ c #230B0B", "#+ c #302D2D", "$+ c #27211C", "%+ c #19263A", "&+ c #496FA3", "*+ c #44699A", "=+ c #496D9F", "-+ c #888581", ";+ c #D9D8D8", ">+ c #130E0A", ",+ c #33496C", "'+ c #4E78B1", ")+ c #4C76AE", "!+ c #406190", "~+ c #0F0F26", "{+ c #141C0D", "]+ c #6EC56C", "^+ c #74D473", "/+ c #70CD6F", "(+ c #75D574", "_+ c #74D676", ":+ c #2F7040", "<+ c #200002", "[+ c #A90309", "}+ c #D10A0E", "|+ c #D00A0E", "1+ c #420405", "2+ c #1D1A1A", "3+ c #1A212F", "4+ c #3B5781", "5+ c #466DA1", "6+ c #446899", "7+ c #496DA0", "8+ c #1B2941", "9+ c #928E8A", "0+ c #5C5A5A", "a+ c #7E7C7B", "b+ c #676565", "c+ c #0B0F17", "d+ c #0E1D32", "e+ c #142339", "f+ c #0C111C", "g+ c #0D180D", "h+ c #68B566", "i+ c #73D272", "j+ c #6EC86D", "k+ c #6DC86C", "l+ c #6CCB70", "m+ c #204328", "n+ c #5B0002", "o+ c #D5080D", "p+ c #CF0A0E", "q+ c #600609", "r+ c #272A33", "s+ c #40618E", "t+ c #476CA0", "u+ c #4A6FA1", "v+ c #17253D", "w+ c #908B87", "x+ c #999897", "y+ c #716F6F", "z+ c #A6A4A1", "A+ c #6C6762", "B+ c #6E6864", "C+ c #A19E9B", "D+ c #2F2B2F", "E+ c #4F8B4F", "F+ c #77D875", "G+ c #6EC96D", "H+ c #6DC76C", "I+ c #6FCB6E", "J+ c #76D876", "K+ c #3E814A", "L+ c #4A0002", "M+ c #D5050B", "N+ c #CD0A0E", "O+ c #570507", "P+ c #2F3643", "Q+ c #456CA0", "R+ c #446A9D", "S+ c #426696", "T+ c #4B72A6", "U+ c #203350", "V+ c #3B3430", "W+ c #8A8787", "X+ c #E4E3E3", "Y+ c #FEFFFF", "Z+ c #473E3F", "`+ c #0B0000", " @ c #224227", ".@ c #71D073", "+@ c #77DA76", "@@ c #72D171", "#@ c #78DC77", "$@ c #72D675", "%@ c #2B5C36", "&@ c #580002", "*@ c #D5060C", "=@ c #CE0A0E", "-@ c #340405", ";@ c #2E333E", ">@ c #44699B", ",@ c #456A9D", "'@ c #436696", ")@ c #476EA3", "!@ c #365177", "~@ c #000003", "{@ c #A9A6A5", "]@ c #F7F7F7", "^@ c #FDFDFD", "/@ c #F0FAFA", "(@ c #402F2F", "_@ c #740000", ":@ c #2D0205", "<@ c #286037", "[@ c #64BC68", "}@ c #6BC46B", "|@ c #65BF69", "1@ c #347E47", "2@ c #1B0B09", "3@ c #970107", "4@ c #D3090E", "5@ c #D2090D", "6@ c #A5090C", "7@ c #241112", "8@ c #262932", "9@ c #436492", "0@ c #476A9C", "a@ c #111E33", "b@ c #64605C", "c@ c #FBFBFB", "d@ c #FCFCFC", "e@ c #FEFEFE", "f@ c #DCE7E7", "g@ c #312727", "h@ c #AB0000", "i@ c #A9040A", "j@ c #280002", "k@ c #202B1C", "l@ c #314B2E", "m@ c #212A1C", "n@ c #200003", "o@ c #7E0006", "p@ c #D30A0E", "q@ c #D1090E", "r@ c #5A0508", "s@ c #182020", "t@ c #27262B", "u@ c #334A6C", "v@ c #456B9E", "w@ c #436797", "x@ c #3B5A86", "y@ c #111620", "z@ c #76726E", "A@ c #FEFDFD", "B@ c #D4DFDE", "C@ c #342323", "D@ c #AA0000", "E@ c #E30A0F", "F@ c #B4050A", "G@ c #7B0004", "H@ c #700003", "I@ c #7D0004", "J@ c #AF0309", "K@ c #D50A0E", "L@ c #9C070B", "M@ c #210C0D", "N@ c #252F41", "O@ c #456A9C", "P@ c #486FA4", "Q@ c #34517A", "R@ c #101520", "S@ c #514D49", "T@ c #B8B4B1", "U@ c #EEECEB", "V@ c #FFFEFD", "W@ c #FCFBF9", "X@ c #9AA3A1", "Y@ c #271212", "Z@ c #B30000", "`@ c #D80A0F", " # c #D5090D", ".# c #D4090D", "+# c #CA0A0E", "@# c #BD080C", "## c #3E090A", "$# c #0A1E1E", "%# c #221F22", "&# c #314564", "*# c #446798", "=# c #3B5B87", "-# c #17263F", ";# c #22252C", "># c #454242", ",# c #524D4C", "'# c #4C4949", ")# c #263239", "!# c #0C0A0E", "~# c #940507", "{# c #DD0A0E", "]# c #C8090D", "^# c #CA090E", "/# c #BE080C", "(# c #4E090A", "_# c #0E1515", ":# c #22242C", "<# c #354F73", "[# c #476DA0", "}# c #4A6EA1", "|# c #375580", "1# c #264167", "2# c #233F66", "3# c #284670", "4# c #294060", "5# c #131D23", "6# c #390402", "7# c #B5060A", "8# c #D8090D", "9# c #D80A0E", "0# c #D6090E", "a# c #CD080C", "b# c #9A080B", "c# c #3D0909", "d# c #0F1415", "e# c #20232B", "f# c #344A6C", "g# c #44689A", "h# c #4870A6", "i# c #466C9F", "j# c #436799", "k# c #4A71A7", "l# c #517BB3", "m# c #4D75AC", "n# c #3F5A81", "o# c #2A3241", "p# c #181B19", "q# c #36080A", "r# c #7F090C", "s# c #A7070A", "t# c #AB060A", "u# c #8F090C", "v# c #55090B", "w# c #1B0C0C", "x# c #1E1A1C", "y# c #2D3B51", "z# c #38547B", "A# c #406290", "B# c #476DA1", "C# c #4770A6", "D# c #466FA5", "E# c #486EA3", "F# c #38547A", "G# c #2E3D56", "H# c #101213", "I# c #1A0C0D", "J# c #110F0F", "K# c #0F1F1E", "L# c #202127", "M# c #2E3A4E", "N# c #364965", "O# c #394E6D", "P# c #3A4F6F", "Q# c #374D6C", "R# c #364966", "S# c #303C51", "T# c #1F2027", "U# c #231A16", "V# c #292120", "W# c #1C140F", " ", " ", " ", " ", " . + @ # ", " $ % & * = - ", " ; > , ' ) ! ~ { ", " ] ^ / ( _ : < [ } | 1 2 3 4 ", " 5 6 7 8 9 9 9 9 9 9 9 9 0 a b c ", " d e f g h i j k l m 9 9 9 9 n o p q ", " r s t u v w x y z A B C D 9 9 E F G H ", " I J K L M N O P Q R S T U V W X Y ] ] Z ` ...+.@.#.$.%. ", " &.*.=.-.;.>.,.'.).!.~.{.].^./.(._.:.] <.[.}.|.1.2.3.4.5.6.7. ", " 8.9.0.a.b.c.d.e.f.9 g.h.i.j.k.l.m.] n.o.p.q.r.s.t.u.v.w.x.y.z.", "A.B.C.D.E.F.G.H.I.J.9 K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.`. +.+++@+", "#+$+%+&+*+G.G.=+/.-+9 ;+>+] ,+'+)+!+~+{+]+^+/+(+_+:+<+[+}+|+}+1+", "2+3+4+5+G.6+G.7+8+9+9 0+a+b+c+d+e+f+] g+h+i+j+k+^+l+m+n+o+p+ +q+", "r+s+t+G.6+G.G.u+v+w+x+y+9 9 z+A+B+C+D+] E+F+G+H+I+J+K+L+M+|+N+O+", "P+Q+R+G.G.6+S+T+U+V+W+X+9 9 9 Y+9 9 Z+`+ @.@+@@@#@$@%@&@*@}+=@-@", ";@>@,@G.6+F.'@)@!@~@{@9 ]@^@9 9 9 /@(@_@:@<@[@}@|@1@2@3@4@5@6@7@", "8@9@,@6+G.6+G.F.0@a@b@9 9 c@d@e@9 f@g@h@i@j@k@l@m@n@o@p@N+q@r@s@", "t@u@v@6+6+F.6+w@5+x@y@z@A@9 9 9 9 B@C@D@E@F@G@H@I@J@K@ +`.L@M@ ", " N@6+O@G.6+6+6+G.P@Q@R@S@T@U@V@W@X@Y@Z@`@p+ #o+.#|++#K@@###$# ", " %#&#P@>@G.G.F.*#F.&+=#-#;#>#,#'#)#!#~#{#=@]#]#^#|+`./#(#_# ", " :#<#P@,@G.G.F.G.w@[#}#|#1#2#3#4#5#6#7#8#9#9#0#a#b#c#d# ", " e#f#g#h#i#F.G.*#'@j#k#l#m#n#o# p#q#r#s#t#u#v#w# ", " x#y#z#A#B#C#D#h#E#!+F#G#L. H#I#w#J#K# ", " L#M#N#O#P#Q#R#S#T# ", " U#V#W# ", " ", " ", " "}; OTB-release-5.8/Utilities/Data/Icons/monteverdi-48x48.png000066400000000000000000000101501301006202600227710ustar00rootroot00000000000000PNG  IHDR00W/IDAThytU?^{H C2&AZjEJ R D*TE@&A@ @7޳h񷤫~w;{\I~MڹS]0s{ƁUSc+ذeEX߸>t=:#| $}\grs.+<~<Zd'tn޼>f/M;6kyz;Є3G,-5UEDmٲN{BQt/ͼa)&XgGE`ۋyoB.[JMmMwqضy3 *.r"Cfr۷k GPU<.9P`ݮg}-FPnp4P|܋/ ogli겲$Ǎss뼼}6ԲwU5U=]^f#ߪj/F]iצV@;wꤳg`cc:c1c8A|&h2SS Km?\t 4Y3ImݲL}Q3c¡x s5טfuZS[S?$l0joRlX` "o 4Bր}]FLMÓsueeI >v0ļmL?blZ0Mh>H"֯7]4вaiEU3E}iTUͬ3Kb2[7}a:bڵӄW[vOja2KNƉFc,ois_nnԛ-ݢ6wݺ}ܿw3~|Kԓ3D >먪>\ӲYxS:~)tiŀ"Ma,0=ה)|if]f_!%#&q#Etzr&SzS|=/msek[PDJOӢ>}~0bƍܔIybƌrymٹg7FmRu"j>c ͚5`A>t5Zs/׾eYwMemd=Wzҗ= <9=qwMO>}MHƨBQl 'ǎUZUy[b[(3P!Vsb jk /ޯSеCΒD# 5pIZe"(ڀW]?@ y,4UDEP!tU!(U5,ǓSUuӭw)u"*>1/iQ˲|=Ǘj9ܾ M񦩄)@!ЪjT 6)zyɹ DPQKArS pYVu8ͳ[Ҧe8FDd&"q,gYXCو2>_Ykە`c-mC5Q[Q N˯d;JdA}.F w{1 vQ'ʹ)wxbj'n ˠe޵K&,^Rvp*fM7I;̾m7G.v4bs8C^#})M)F-\.?WR2G#qޏkD%ZE}8FccrQ7vy󴦺ZjjjT6mۊ)SpQ[sI6 Q\bueYLQI$UX%E?'gᇩWg8,+K;о˥'N ʕ^k_ϋX(2 (\TJD9Qr[j# ņ"G ##ǧOgI2-ѤM/.=^vm[g~/Ӈbg♿xҔXS|n7-[5GDb0Dc_Aӡk2Lx؛k+dwݬ|Y;/yŭna٘eNz=`RTI#aT?/t[0ֽJp"iDvc8N2w"XWԟN'j,ab8HwZPK<)Lw{Qc% " o]:vދ,jƪڃۭ-hc %IkƝ*⫝;m˲HnB!9\yB@1vxʗ)>F#rXLYOiW8ĖEFFo WNp x·|"ZWi'-jb0GEp"A2;j-Xռ"32Pr"GP*QQA/ C(ѽ_z鋲f4g?7H/MJjŌH=K9 DDb[kн{ h 1(ZJ=/s۠*½zi?gw?P;~kDyq"MEbi4I5 qy+s 0xtI=v86lU ?b $kB .ƅdѣ={}͛qM^yuY_aFuq-Ddd<5. >5up=dlON/ P#ҵ{BW8D䤈 Jݶ?y7O?u$];օFNp!y Trbe#˲O K$߬a_zLZ$eK0L ӐʈA?s̞3uU8\'tlKg۲nQcbUX̗888 PI 螏gKW 7",!$], XghtDI/Ԉu}3NbŻI`"V|1VɺQG]r; aĻJdWhӮ`YnFUxtO&^36/zbD8妫XxPU*1֝WXGk<`WlJSo|祲}^8:]/:"ncG'T_B!˃Ǔ#|*rgej [oܨ _}`HvyN67K ;g% _U8ۮ%]+3O>x豚RoV[rڝKVXi-@xRj8yo^2m˗֟ěG=ASh3NH4myzM7?Үo©mr-7+}Vڥc=s7\pjyٙy3v̇~}g_7ri>xݧۋ4Ӿo$//UR>tss^fNTylU>XXVzyɿ>""@O6mrڴhdӦMgt-/!I~GX܋IENDB`OTB-release-5.8/Utilities/Data/Icons/monteverdi-48x48.xpm000066400000000000000000000171501301006202600230200ustar00rootroot00000000000000/* XPM */ static const char *monteverdi2_xpm[] = { /* columns rows colors chars-per-pixel */ "48 48 179 2", " c #000000", ". c #0B0303", "X c #000807", "o c #0E0A06", "O c #060608", "+ c #08070A", "@ c #050B0B", "# c #0D0A0A", "$ c #170102", "% c #1C0001", "& c #100A06", "* c #120D0D", "= c #03100F", "- c #0A120E", "; c #14120E", ": c #0D0D12", "> c #061313", ", c #0A1515", "< c #0E1912", "1 c #0D141B", "2 c #0F1819", "3 c #131213", "4 c #1A1614", "5 c #1D1916", "6 c #12141A", "7 c #141C1C", "8 c #1C1B1A", "9 c #230203", "0 c #2D0405", "q c #320305", "w c #3B0305", "e c #320808", "r c #221A15", "t c #231D1B", "y c #192117", "u c #21201F", "i c #28221E", "p c #131621", "a c #171922", "s c #181B24", "d c #1B1E2A", "f c #1B2223", "g c #1B212D", "h c #1E2534", "j c #252324", "k c #2A2727", "l c #2D2926", "z c #272529", "x c #2D2A2A", "c c #322A26", "v c #342E2C", "b c #273A26", "n c #232937", "m c #202939", "M c #363332", "N c #393535", "B c #3C3939", "V c #440405", "C c #4A0305", "Z c #4A0708", "A c #550607", "S c #5B0507", "D c #550608", "F c #5E0709", "G c #510809", "H c #600406", "J c #690406", "K c #660709", "L c #67080A", "P c #6B0A0C", "I c #710507", "U c #740608", "Y c #7A0709", "T c #71080A", "R c #7C090C", "E c #423E3E", "W c #2F452D", "Q c #32472E", "! c #324D31", "~ c #345133", "^ c #385536", "/ c #3D5C3A", "( c #40653E", ") c #242F41", "_ c #263146", "` c #2B3143", "' c #26334B", "] c #2A354A", "[ c #2C3A53", "{ c #2E3D58", "} c #303D56", "| c #323F58", " . c #32415B", ".. c #354663", "X. c #3A4967", "o. c #364A6A", "O. c #394C6C", "+. c #354F74", "@. c #3B4F72", "#. c #37527A", "$. c #3D557B", "%. c #4D4B4B", "&. c #554F50", "*. c #4D5050", "=. c #555253", "-. c #5D5B5B", ";. c #615E5D", ":. c #486D44", ">. c #467143", ",. c #60605F", "<. c #40597E", "1. c #656263", "2. c #696667", "3. c #6C6A6A", "4. c #737171", "5. c #7D7B7B", "6. c #830A0D", "7. c #8B090C", "8. c #940A0D", "9. c #9D0A0C", "0. c #A4090C", "q. c #AB0A0E", "w. c #B30B0E", "e. c #BE0A0E", "r. c #BE0C10", "t. c #C60A0D", "y. c #C90A0E", "u. c #D40A0E", "i. c #DB0A0F", "p. c #D80B10", "a. c #817F7E", "s. c #5B9558", "d. c #66A963", "f. c #69B267", "g. c #6DBE6C", "h. c #6DC76C", "j. c #6EC96D", "k. c #71C570", "l. c #73CE72", "z. c #75D474", "x. c #77D876", "c. c #7BE17A", "v. c #3F5982", "b. c #405C84", "n. c #425E88", "m. c #43628E", "M. c #436695", "N. c #486795", "B. c #436798", "V. c #44699A", "C. c #486B9D", "Z. c #466DA2", "A. c #486FA3", "S. c #4A70A5", "D. c #4B73AA", "F. c #868384", "G. c #8D8B8B", "H. c #918F8F", "J. c #989797", "K. c #9A9898", "L. c #A19F9F", "P. c #A6A4A4", "I. c #ABA9AA", "U. c #B5B2B2", "Y. c #B8B7B7", "T. c #BCBABA", "R. c #C2C1C1", "E. c #CCCCCC", "W. c #D2D0D1", "Q. c #D8D7D7", "!. c #DCDCDC", "~. c #E0DEDE", "^. c #E2E1E1", "/. c #E8E7E7", "(. c #EDEDEC", "). c #F4F3F3", "_. c #F8F6F6", "`. c #FEFEFE", "'. c None", /* pixels */ "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.*.=.=.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.# t '.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'. 0.t. v '.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.# 5 '.'.'.'.'.'.'.'.'.'.'.'. 0.w. %.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.+ W.R. '.'.'.'.'.'.'.'.'.'.'.'. w.9. '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.3 `.). O O O O O + * e.I @ '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.l # O `.(.-.F.P.T.E.E.W.E.E.R.I.G.* y.V , '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.5 * %.U.`.`.`.`.`.`.`.`.`.`.`.`.`.`.5 r.9 2 '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.8 j K._.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`._.* q.. 8 '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'. 3 L.`.`.W.F.3.`._.E =.G.R.(.`.`.`.`.`.`.~.. 9. x '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.l %.`.`.5.j 8 `.`. 4 4./.`.`.`.`.E. . P '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.N F.`.J. 1 o._ 5 `.`.4 d n.] : 5._.`.`.T. t f f , , , > 7 f k N '.'.'.'.'.", "'.'.'. H.`.%. s $.Z.S.[ 4 `.`.B + S.Z.V.O.6 x Q.E.E % C J I U Y U S V % @ N '.'.'.", "'.'. 1.`.k .A.C.V.Z.[ ; `.`.3. M.M.V.C.D.` 0 K 9.p.i.u.u.u.u.i.w.Z l '.'.", "'.4 3 _.N @.A.M.B.B.C.[ ; `.`.K. ..Z.C.C.} + 8 ( Q < $ 6.p.y.t.t.t.y.i.R B '.", "'. K.5. O.Z.B.V.V.B.Z.} ; `.`./. p S.<.: : [ $.a ( c.z.l.d./ + Z y.u.t.y.y.y.u.V > '.", "'.* Y. ) D.V.B.B.B.B.C.} * `.`.`.2. n # ..C.Z.A.N.: >.z.j.h.z.x.h.! e y.t.y.t.y.y.w. '.", "k k -. M.V.M.V.V.B.B.Z.} # `.`.`._. n A.Z.B.V.V.S.n >.x.j.j.h.h.j.z./ Z u.t.y.t.t.u.% j ", "v 3 ] Z.B.B.B.B.B.V.V. .o `.`.`.3. : @.C.S.S.M.{ ( z.j.j.h.j.h.j.z.W 7.u.y.y.y.u.S 7 ", "M 6 M.B.V.B.B.M.V.B.Z. .+ `.`.G. Y.Y. 1 ) h ! z.h.j.h.h.j.h.j.g. 0 u.t.y.t.u.J 2 ", "5 o.A.V.M.B.V.V.V.V.V.V. .. `.Q. I.`.`./.;.4 x F.3 5 l.h.h.h.j.h.h.h.x.! $ u.t.y.t.u.J 7 ", "t #.V.B.B.V.B.V.V.B.B.Z... `.B 2.`.`._.`.`.(.!.~.`.`. d.j.h.h.j.h.h.h.z.~ % u.t.y.t.u.C s ", "l $.Z.B.V.B.V.M.M.V.B.V.<. 5.v `.`.`.`.`.`.`.`.`.`.(. G b x.j.j.h.j.h.h.l.- w u.t.y.y.u.. l ", "l #.V.B.V.B.B.B.B.M.V.V.M.: U.`.`.`.`.`.`.`.`.`.`.!. 8.G :.x.j.h.h.l.x./ 6.u.y.t.y.q. '.", "r +.Z.V.B.B.V.B.B.V.B.V.Z.) W.`.`._.`.`.`.`.`.`.`.E. 0.y.9 ^ f.l.k.s.b e t.y.y.y.i.S > '.", "r { C.B.M.B.B.B.V.M.B.B.B.N. l `.`.`.`.`.`.`.`.`.`.U. w.u.t.e @ V y.y.y.y.y.e.. j '.", "'.g S.M.V.V.V.M.B.V.B.V.B.C.O. -.`.`.`._.`.`.`.`.`.K. e.y.y.y.7.F D A T q.u.y.y.y.t.i.L X '.'.", "'.# m.B.B.B.V.V.V.M.V.V.B.M.Z. . %.).`.`.`.`.`.`.`.N.% e.y.y.y.u.u.u.u.u.y.y.y.y.y.u.q. l '.'.", "'.4 _ S.B.B.B.M.V.V.B.V.B.V.V.Z. . # H._.`.`.`.`.`.-.o t.y.y.y.t.y.t.t.y.y.y.y.y.y.u.% 2 '.'.'.", "'.'.# b.C.B.B.B.M.B.V.V.B.V.V.V.Z.$.p B 1.;.%.4 O 8.u.y.y.y.y.y.y.y.t.y.y.y.u.w X '.'.'.'.", "'.'.l 6 A.V.B.B.V.B.B.M.B.V.M.V.B.V.C.$.] 6 : @ , h X.+ 0 p.y.y.y.t.y.y.t.y.y.u.y.q O '.'.'.'.'.", "'.'.'.5 g S.B.B.B.B.V.B.B.B.B.B.V.B.B.V.Z.A.S.A.S.D.| r L i.y.y.y.t.y.y.u.i.7.. @ '.'.'.'.'.'.", "'.'.'.'.* g C.C.B.V.B.V.B.V.V.M.B.B.B.V.V.V.M.B.S._ & '.B V w.u.u.i.u.t.8.0 7 '.'.'.'.'.'.'.", "'.'.'.'.'.r 6 v.Z.V.V.M.V.V.B.B.V.B.B.B.B.C.A.M.g & '.'.'.B @ q S S V $ 2 '.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.c o h v.Z.Z.B.B.B.M.B.B.B.Z.Z.m.' & t '.'.'.'.'.'.B 2 > 2 > f '.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.k 3 g } b.M.V.B.B.B.v...h * 5 '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.v 4 ; r j z j 4 3 3 l '.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.", "'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'." }; OTB-release-5.8/Utilities/Data/Icons/monteverdi-highres.png000066400000000000000000013112201301006202600236260ustar00rootroot00000000000000PNG  IHDR/gAMA asRGB cHRMz&u0`:pQ<bKGDC pHYs."."ݒ vpAgrIDATx,yz=Y̜@,R &A%^fXòCv؎p8Y2IISRa3LL3]ι.?ӷꮮ'2:;/z#[飏>J)u*nme_Ϧ/˲Y}UusOͿ:w.rǢ?`C==A|`>TVRYUQeTQU)t2_NU2HU)ӯK)E-L<^]hs6eltY:\Җy+Mv='x]Yd_M|vgfYGӯN֟GyEm[uMYy>ˢkW +)Rp''SM̏,|D7qƳS < 򯥨FW|7|?5 _ů,ɅEv*H>"*EeEUED총xx>R,՞w|87i9[~޶uZ}s̹ݿrz-~Wė4eO窫""#FpQQQQWU,*˨*ʪ:/*ʔbXU1Jd:RTdUNNKs"郃Z xTA{ ""bo?bo/ac`aU&,N!,U_;jiIY<.v;80Ix0o@RJWϫݬ_7(ct:-WŢ#$܋l48~f<]UբK 0 p/t^#AAN nxt8۫A#$ܻtJiÁex.z8_=yDnj AxϧjCUt""u=b@,A`<"Ne癏梇#&ܛ`8۩WE GL7Ñ U=EDɢ#&ܛO ԃ ;ڭE GL7<RUբKy9cQ-"DE@ po U=.z8SE~t臊 psy>ug'""~k_n:@ļ \OgQ>y! ";>ypZ͇+G:AfNp5{dh<] UUҩAE% Mar0xLEzd]pX   p3EQDeh-zjAY8o~\XJiQފaDg< p/r<԰@ydY6q?g?6)j"ReF񭪪C 3> ܋<҄@QvjEQj"ϛQ!˲ iUUMCVZD[K@ǵǪ__[[G[1<:Nt:ڊ~1=Gy϶5 05#jb{{{X:YE׋^m+Wd,jcmmC` sM7eA]YDDt=$ 0Wq3 Z~vcM DDd;;Kȱ 0W`01AlF;'[o0\^$ٳ"o/zh,&|MAV |2^yDonJȱ 0_կ27*+<ϋ; &slU5N̯}Ac-aXt=c`ҨA{n_k(&E %%ه_q &kLdуZBTYm*j E %,r4iJe'[o0Mfꦃ ɢrl]-2*ɇV :%aiZ<"ʧO#""e[,KTWy'"RqEvwC`86j(5]Vچ^Z(oeYA*@.d2VQsl 54Ҝ:7ZÜ@""7=$ 0WZQAE` No4-Ro ZXbM:v/Ѽ tExdC`96긖h}'[oF\=Ҋi$e*n^$0WGZ$bpf.ρ4.Ro nDD~5VoC` 96&+W52KypYERɊ ϊP7f}4 07y?1ߤ N%A,=eDd]XrMir9/u.v/uѴ0HDk}\חN s-_+ ,%A*4=ގѢRsl@@ `09/%vA""՚'KNE?),z,O_*K% \bOk҉ѓ'sA{/^o`I? ?}gͬbT9QnmKZE %%p~ŋ4jh^UA3+&qAN+?ދ?cp8N. |'R0 *A MR"?ߊRzEڛqs8ׯw";<?" <G=U/Φ Nތ0ma""gO=$V/3xJq, 8>=>َko}5DE""JADG3 IŚEhl4amINeAʲ\L"{򓭨*K 5/g3}!booofAMGvf6ޢs|p ŋ~yQ'y\WYĿ2`bIu{ o eYZw"p?E*X ?2\*A!BA_~xcAv?( z+@ϼAaK_E5M<֤ ק5dEx: pwON.x<<<a)]V("00'Y*ӣ W"HY7\r*bx7_U\;s|/ -zxp+)xM  #'A9M]a݆Wnm-zH'@|!}$ŠJ)ׯgA 59R4UӃ Vkb>{dC`}Ϫ@Xo Cԅ\؏h}{I󓦴A(?_X1 @c_BKB Ua`0hREAۛQl/0FD*NNӧ"AF|oB 4Yd8^xl_ߠ H6fhKYAT8NޢNU.,a奔իW3 eD[?3.a6 ~rd 75LS YE靇?5ACh/S5~,zx 89Yt 9.RD7"HHDx7_n>Eh.n 8gmbFDžA8M7)5ugYT37%R|kggC` Ve.zUUūW ɦZ=%{I͋ʫf"Hz|C` @UU%E6EêAF<ibEQnn w b!Ԙpr"ȋ|.zhAβAzo匊 M1Yi3κE "`01Al*Р"|77Rv~Ϳ`nA7+2,\^ $"!A'fZTY[Q dݘE %Y5lzEfjzk3yDϞ-zH(A`/}嫮fVMUY H6U٢u4IUw#"Χ`6A}/; h4تAi sWY6s)AzEwPHj=4V 0SEX"aà xyI[&l+YMAt&| X ^,5-L=1_Fh: _6+MZ+zAVkfLk{gC` ,ܧrܪAi sUKϟ-zH0AvQjvDklp^d#E[+LPhLEkɲl6kemo{BA&nUUM0嚖Sˮ~0 Ϭ΢ A <(&| MC!,7n`j~CAg'Z0 ڵ1ޢ r|4jjDӉvr:Vr_peQO-kZEvÎ9n*Ŋ gUDphsmm:<H) UՑҚXytFEAAލzDDSD ޞJG#?7|,EFD*hj.nGFNwls]eUŠ*cPbXbP1,Gq<aA  F1 # GF(jYy&yyX`h}x7Mڊ~ȋU?9}"a +SOvwC`E ,NT_#?ץӋ׍Z77bgs#ڊw6ުXX~^(^~Eut(tУޏޏߋ;OgY A|+vADD*8vf dY6Qd{z۬he]N~r짲lf$Eic;6ى/~^vs{Q<6Yo#~r'"~lwo~Eyxy .kI3?e}6^A+Éu?&ZI֫5"H=>nop?, O>yrI;o_o {e~}/^~ybꓭletb0XUU6|M-eYNUiB$b3n_nF ӧQ?=}7GlwO#ݗOD~wm{N.އVeO d#կZWɧ hЪ),mbv6o:n"eyi5LDB󋧡XYz`-zh0(Kf:hњ|'""z^/¢^|['UAVdǏDgE']`665Lc6Z6kX2A^=1DDDݎ/~JhZ HD8A<>C$6Rj>oA@""z[QUh dng<<#bg9w3}!㝧UYam&oE?FNC'uRX2!V7Nyq{ӥw'ۓUYOʚ7OA&"}UOGѢ A=! Kf:dPJ ΫLW?11L^ H5O6%2Qdуyľ;-LS DDjRx,AVNuZ>ۛl;^嶺|n*M ԵC]BEwkX'A%WmnyEAu1#'rMWO7aBEDE֪vA_ KB[(7۔KͼѪuߘll}Un TܷZV,EիDDՎ /A%20؞fWsz2bF9Eq~U5ÉǚP>LY*4HDD{{{</.Wr:^\noVEV-RE42UJsP?S"l ?[hA%20'?eU+1afV]Qkt}ב.KfdFTUUe"7A%2}y}SfONk 3?>ڝ +r"ȇ_ye5HDDwksip[Vkrȟ<O?^Kd:`MA>ۛuAMWY9X`RO=4%2ݾzVt[AA(y!0 KBs~9"2?3+S~fу__o;GãǚRDOrA""GDj AȅA ȽuAnS{*"ãۯ XybQ?ج*O(Ԙ H"Ȼtw=4B`\r~"1:њvefEj 3t=$+p8XS._l ӌuݩ㑦lAv:E pu`LpN A퓰^ߑ R"țxo A&}7c:є HHDc < A% aV5Y xCS0rBk߻omԫDDwvӽMA p"U A2+2]X{:R'㘮#Ԋ EdFʦA+gٿZރ Lͫrfief5ExjUt"H,}$W$"@ , Թb"'ѸY4j 3ᢇd&_~bp5 p|Lkk s0SAWy:2VoCAZw_rI$28ӝDY!rofm'[do}cW|g0gwX˗'n*LUUDJ|LLg2[wԧ,67<OiDD 'kiNkr[,&*n?8FgEv2Ary,=; ;=9hzO=,?RT8li"hUD,W. ť}O_~K)O,yD7߲rvΫLWkrEa}_,Bݔփj 8{j pAƩWkX g.AZeIʲjF`bG,RTedit`/L:[PE6a+I>o poΫMUyhYK/8O.[1' <AqVm{*њ:"\,,7^0~ϦEiѢ_Y()+7v0nt؏ԪK4Ņ #2"HSzE,".QY A"\%ޖ X;cqܢ>_Iy5E *:O|y/ՖܧHOe'OKQ='NUNr,Eg˾䒉ٕ_;9秩˞XY4?9|r6}</?ϳO&MNY<<"ߟLotg@Tp%JtEh%K՝C%_Y4X}mV }gq8ٔ0aϧSf agE*.ⴧQ?<$-V`sO;O/zXs/I#2V߀*~?ãH~hh"UIa@FY(SuĨN1c #b"Y N 32HssusL_l\˖-q1cfI ʹ#"YD7":YȢgh'"ϣUE"YQDnEjGnEj#Hi>~ |_J""R ڋ#1-LS Ot=4FhDQ1]ܵ[ŋlryk˚(,G?ߋ}w/7ԗ~S2t[_/PeAǑG90 0Q 2eHqqϿK)T8k2cl$uma_^v8 -H)"ijnѱ,":q4D,N&Vq6ɋ"": [V;ۉZ_vA6ɢ_͞?;<OPa2/4%Rv>AxX @%P?X ZܗYI9kS8ҏou俶vR ߨ"?:I?j8p(Q 2UUTA8"UcAQfecG?;[""LʈӺ)7RDF"ֳZ2A{3"hE[ÜyM<}4BG:o"nGUDnG~VsR?z:m8j84F9E5*cTbTV1*T-`M ڔoRc6JRJsT]$"8"߯ʈA1GF'㎈xjFݵhoDՓ'Qu:rQ"#o.ERGZE+("k"kQ[/>_/SzÓqķ>6fZK3""1[IAzEj` @'>m75+2G3+TW5L5zj" r{{GP~v,Wz`eA("[;NjNUpprߏ"Ylt֋Fd<Ѫ"uJbg V)ppiߣ؈v=Qs\l=Y8guv; \w(NjQaīW<"EhZn8mu:nZ/4PEce|7oD߿WGZ];v܊ j q֚ OhU`ӟjsLf2ph47oDɅ@Y9g y,-eY^}MMՊ(&n #ӈ*#eD ""SFeEt":Vڭ(:ȋVT(RYE*GQeTeUYƨū~|Zsww7z\`=㓲,7.<AW# }eOW<"̪>QN^J3אRS)qՃYϪ\v2N[Ҝ $,OnԱ ]Ax,WSMq"H٢@ STRBm NEt֎f8x[H1Ux;::EQ&,^6M+_O..yz#0 }UzKւLjUFjo4ߪGe"CKVQ"Ȼy($e'@8NV[Zx,s4fSxnfEeuWpMgmg.PDV]Fd>\@/C4}h$؊ 硐*o/zh4 ôMUd908#r9a}< aZLW)y!@D _ g'[7x.ws6Rdz ~beR_{)㩊 )FAAX 8G\ \|QynWo.m &E&to#Ŋ M DLVyw: t\_^ gk [E5LuMPX&W'j s3 a%"r7+,zD/Ŋ M DLViG΢c @H.zC% tUDkD?ppc"ZUY<"NfڲU9 wӭ`f>AzA|jX--v*,z@ qqrӂ PHʮ%4ˊ̵y0^A2K%繊 w4]l\|RjTdNocc< x @e>}NUYP,v7yѴ&m`c}1< @WqXW<Adbfh,fijrkO,5\ $"}غ  ysCEr0*[qok"Hv?тi@Uxk/9Q#fb~[\syrvRXӉn4b45㌦A1zdC \!coobv+h pUDxĶ|`0X0dE={SJ +cWXs5̃VE2E5}7ym5yW<οWyap_'*\xC]߯;g}\Lmib%tKA1G'1rfkU~²,CLf-sn I)EUUޟM 4W籹yR?Ɋ ,boouӪdY6QdOv6{!4?N)EYҭW\+͕'/i eYy>WM_lV8xo>sW kmSGGGRDs~F>۴ T%VLh/s$BEt0 tP6&eGDqzSD/Eզ#"Md1ٶ+=bSlPV[ԺPmM}hvK4u378_Vbhtiy_;S]wgzOיf<'E*ETLeDQ(Q,?_&7u#UUEY<SJ6fiRECVd:R<ىw7_!4Bk~2 Ar0 \!kߖ}zԦYȢ܊>"ˣ8{Ey^D^Ȋ<<,O&#eYDGI!#b^DH<3ʽFȪ*,#+ʓ8]61]UeHe:E:QedJ'U:NUUDUQ./S2RW)"ADG̵>mB$PHY3EQDu~/sT㩲)?韩E fV/),e?ayՅba6A\Li˂EQ\XhYD"b="zE/ˢhE[' Yd:ZH}jGnEj6j Vk.ksUUȎ";>GD5h8p(eTQJq"T;wY%E-@""=ԥ2nжTE"E fV֗K),G/_M\eY 2Vxs!*9n>uCEEYYYۍEܨ*@O>~:KnV %C\ߕW,KU<'[۾ߏ(8ߏ4D5D9B$UW'! dY6{ҥDΦy*~hnEYNe?zc1A`|+tza ?ح,ri?vvY\yq(L=C*bՎnn7Zdۇ8,RvLp,eYYv;=I{YEYyZY+"<"ϳ(,,<;?<66yv<@麸'Q8ysJ48RB+U:3;/׏*Tƨf)2eUuRɢ:{촥KUr9iRdU:7}T [g:~ۍۍx2ߞV8 41"#+EVVC)NnEq>YE+ZE~zkERI;oEՊnъN^D܇,.lcgY-|rM{o\oM͚kWq^~ih_w~1bXVFa9 8 cpz FQHQ(% x&^18:>*2U"{so [ԷUj;sUd0ξiH;Vg?CM2Ϊ5{MiƇ)? T'zߟhq||Tyr5z.R&$a.N*,]?EnD<'E+6XV(6/y^Hy;Rюh"⨇6΂gzY_,OZ?0ٲp8>=]yV[ޭ_boЏq q4qcx_ Qq x>_Iy58?'w5^(; _½ȲǝkU:1e\$Z<'*wuIQVkn7ڌNR֊En;N֍zacpԏq?R1D^rVDD~z{/"~&"~?"~88:׃A(U۶zEcj9R~Űq#/߇e^ߏ,L_x?Zsz8T!0fDFBB"v'}𱬊 a_ Q}!xԜ)/OfB 71֫WɌUUQ>Oaާ,y(i qfl}ٟ}V/"^dY(~toN1_˲ׯ_FZr\h =A [; 3|˿YT>e|~E߿[g' z>67j Z Ne->w"tHϟG=ۄ<"jAn'ZZ<؈w7b.E13qmtPEݸI=o A ~tYۼ+ m+,zDzJ){e˫ݮ\mVJxP8Óȩ(>Gϫrfu, Rc,"]8q݊ qY%ga""^'({X܌NTUo2qˋAn:[ZP;+1֕F!Ya>Qdyoll;8888qTLD޾D>ػ.Yv3eYp8tb A-Nmn{ <> /~)G3?R*էOeZ<.^MY>w*gۼ"ikގ(=Tyv/^/kwccc-nn{۱sqcsXV+U]dVp>;kZ;/.ycTgݽ?#Ǒ1FOD<}xVG|Y_Wp]cZˌFq+&^_\n>*.?_ଡ଼h7?~ /,ǟu2{I+.KCHS߃ӇG'󙡏_,tb{s#:OFz(76&wت8ZZ<ފwIoߧnqc(22 fDZ%''3p/~o8Ǒ ͈?xEg1x2^~\U<ܹ!@.TY0~#\_[A;4QUxߏ>>Ke9>iēU?|Ei粋IIn1\\yUxEYKU9>>zַg(~xf7wctpYhf@Z[~2x"Q~yg~|'ҥP~&5̪x"HJ)r9S}LO//Qhwws|g˳U3Au+t툣g":؈'{/**UގEk͵ތ{{&^K53q6td,^ekkk;|N\ƲY"`bg^Ǜ7qwQã޷NN~#؉ۏ[ߊ2Y94jɓ'cooK}sVtk+<[kx M?&OTx{߉98W j\c0X\U]Ek,eOA{~Bx^=njj;) EON|?ѻF*nV#eyzkϟlǏ?y[\^e4䱹ZЌF888A^o};[ߎڿ՛=aɊfADX?apjtt:qxx~WB=I]U˩q yOo¤voAWtV`*bo?ߋN@s ]s Aʥa|'!zGQ7>N;76iw=ht*EuNWE7lf|I|${ܶ666b{{mcc6 iZ;;;3?3(rppp[,y'~rgy2>1zyyڦv#Oߏ7YF`oҫzu-LIPi-v!'$\|5{٭_7y߻CyJiGZO=aL\h>Y|&˲(b8ݴGD{E+VϞF;j!U("u֢Xx?YlFә޾}ǤFۍϟ_x,41+(rӶ3nD{^_7i&74Mн-Ck-I&LfVVfWؘͱ={~ؑMv?Z;bT~8]?`lg*2R0*`h -=\! F}A~ϓ9LAʧ! z(O?ş 0 Zt+kEVoZs9Ɗ w"QFb/!o+vcO*^`Ũ絆a4,> ShEQ(%QyW=qHJ"c79 }R o$XH8~,ˈD"a?gMQVBt,ulT '''wi2cd1,%]÷qjr%_ #|ͷ}oEQT*pￊmVD][YVV=0BDD>zxz۰mQr9hkxstUpQ TF=޵5֨{$ı/2Ng 5 HxF9ޡʇ/O(`4xc^=]kap80 EQjߝ+ d-L&q|||n`çx,0=o6_cw rZo/S<ڶ N[V-Kk?j "c-""""j uZF. VW}p^BeE?ĺ0ץg'ke=>xz(d_t i_$X,D ×\CQqq$ڿADDt9TUE?k麎=lmmakk LuDix!a,O`xcu~dنaW:5L7 $ cn +^Q+pϕK4 H uV7%0צI`B65c%=^/"D_hIJfB@PCb!ŢK z#H-Q |D"~(>d2lmmamm Ǯ)?rI>nZ>$#Ϸ%=oږB HWB՛FDDDD DDDG.M]$݀;xZ.Ֆ/bAZϾ'?CK-m~\!Dǣ'5f|Zp#эDEoETr#2Cmz _Əz}ogҹHk3ҍAEPcu<""""8KDDa/RH40i6xE`rm mzu?5D4@> goxmaNޞVoQS!""jc=<zA9.7"AǖZ?ڃdŠ %(TB~DAD\r(GUUKأ{'""B}j ^4׫Zä% 0V@]nF"""" Q?lʺ@AXb؝ZmV][/@&b5FcG!$8(*/Vvt>pR Br/eYbE"""":%2~? B}A4I¾`WVoQ!""jzzD2 ȫ\.Zp6_s.\u{$lx q10qMqYP载$""""1BDDt~QwZs9]9躎Bbؕ8' DDDDžg9y ȥpq8[+ °=A_I8[ȹUpoR,Q(v̥ DDDDdbWMYB`>U8NDDDD{DDDWV1 x^bgk O ܊J%EJ%֣Kj DDDDž+\Nl c_1vP|Yѵb5jGf%H,T*((0 Dfί",[LDDDMUׅn xbA:,$g"X~߁PhA""K _`\fBbصl{l CDDDD&Rr A.Ⱦiu!maXX wxEDDDD7 DDDa{[R}LRBr@m]+0BDDD=t]wz! .'u‚i&A.-?@v}O2Y/˵/|wel& QWN=²\/:nVDѵAsEp՛DDDDDN!""j[C)xGXoTMu]~&z'"""V, st2A H@kVDDDDԆ!"":#bP^~hX,P(tm?e|f!Y{4ы \# DǒYsE. X>Q1BDDµrkx1!ϳ ] sGA[EES*9⌛wkD$Kp0P,EVIDDDDt!""2@rx59t$IVibA"""Q*IFGt,Ê CBgUYq tkks5#+hQ[`k}$WG1P(P(pF]9oLk}=R+LᏜir sZ}D+5 9R"M"""""zg Qײ@$Mb/wvڠGTB>gV`r+u{$ck52rq}l_M`"{{ZIDDDDDA""*?O}Y]:<"M(ǃP((M4`{8 B\*Z >v'ٗ%m<|@x8NDDDD{DDÀͭM{)_u  Δ+( ^o0PhcޟA=R4٥5E$Amab|eCzӈ u${v66cb)\U*Y$IЇ ,6| YIX<>ۼ }tt5/XýXVA"""aR.׃ FL0sIUzЭ!xUhv<7xEDDDDmA""j{o6q/V̶T*P(8KW5jq~?zOMBr #fgA"""ĽV_7 ]%!,!/1Re(zzZIDDDDD -sDhϞaeo. èUujtcaFhE1XAlzۚ""""jon-J}Rz.- T* 3+WFDDDDB Q[qIgPx eHܿ\.#ϳ]Y-f*o(fe8zOg|CM18܋ar5881bDDDDtbͨhޯB! A gESHDDDDmA""j /;8\]wdb|Ȳ t"`AU1L?$B1La<|aߏQaddϚ:ktT,0ޘK0bf>Qe!X `F@ ^nnbe%sޛ烪M=| nD!y Ec(" KԪ~m""""s %SkL!:E >{)*hֵI,-6#o Vo;an{T)~<:¾5MC>GX+VטH1TF 5oO RٍP-0 FA$) _ozemO*J7eǀpvl' DDtc8ڿ 9Pp\F.C\nSzt# yYHO$D`.!DP(6B!attCCCMmu'{kD=Q" Nk 8 ~%'!""""v =WA8j!P,z.N$KCn2GH >/iV.OUH{<<2$C<oDDDDDmɔ1,0PrXANI4$"""6 9"9Vvwe@0  y^;$|FCe} j"~, 5bddkDDDDDms<81D'TYQ.<\P9tNDDDD{DDt%C3|J"r_MӐQ,!:`]YjS HF6<Y _8fF0k~X,Uhjm}IDATץrTo-iZWFA-mbxFDDDDA""6g/^beer9wxv,,c,wzZ" d Et0QBMm$I8FGGDZQ) \.cEsVikYvws5Z$fhxX DDt,-l6BX,"w5OZ=@ `A`4i>s⠕'R5 .UA<0Mz DDt)I7'O.v\[.P.[yZC>BPQhc`cƱ86@m8ZQWt20sqi W0wuX УVo{aދ9"~xprb\.f9$LEcOC?aB@;܋Q 9˲Z#`oh""""9܂ FEGuZ+B! {Dm.`m 3jDDDD!" 1@|~ķ2.%B\SPx94.&UaQd6 z{B4&096# bll : Mp^ ȕi0x+Hd9 U!=1BDDM@p--8U@#e8چ`N1,H% CXm>0>> m!""""zgnA٨ϛ<0~AZE8KyvsE_$h/d""""jK љ,쬬q tIj~f$= 3УQ.41>>ᦷ#cjj ]7QANyt588 h$HI* ՟{kR9GDDDD)!""W^]39L|>|>G$I|>_-a85$L%LC?<<|#bjj SSSb~[.=,,Ӧޏxמ9˲#@kE NJDDDD!"" K&^2B|g?&% S83 p2dDcX,5W7&""""4br=SC$@ƴmGZZcEU* s+g0%""""j [ds ++xC0ZD6E,78$bLA=eeYO`t|KPXY($\DDDDAz0Df-Ky?搻WeAAesħDDDDD7 DD]y',, d*~?~HF6%!y '@o[BDDDDtA"a >1[Eno cj ՛FDDDDta u)Kd{_\.BAQ~`HIh? $&''100pf""""NfTF._{넊 y ؖOatCQ6 .K~A}1BDeu{o@t]G>g IRmxaD& pH8q{x &> DDDDD ^ԚYn>Y,AVoɲIOpPqO""""j[ u K]l?ǚsGZn^@>aׇQhS,7  (TY930DDDDD&9ZzSbj j0nma=XEoo7R0BD ?hǰ 4E(z)#A#*ͅ?<155rsCMXth:_*ky-bus@E[IDDDDDA"eig%ir "uf[LJf ssУ %0#}397+1LMMattaBQM'u]o=sDm\Ъ̊ vAV$""" QTg l6 ]/g CȆ⃯ c$~!`bbڮCDDDDDa*%H +?1O_I$aO sEOT?zǠMM< O cy`b4BP""""e n?1"8^ D$K;҈_,`͙ J:u @>G> `i`I`dhbnB)Z7֏&Sۍ zzzZvu{EtI.Y+zk݊K[M.aH/d""""jk )sD.P{|IrB\.Ǿ]/Ӓ^x砇Bp6!`Sx0>> 7|~"""""{E\~4(U*0/eiڳ"3AU2x K!"""N Q@$MR lgtfZXD 2⃷󓣘5WC$ affUDDDDDtyA rZ1AoYu tXU`=>&""""_k3W5ڔ DD79nmxn8g躎\.F/Aw$f ϱ !4ԋ;Sznǃ `hha(WP=ݯB" \vn aQkEWlVo{cT9:O]bF-"l L ,crpXPUGC׋٩L~aLOOcbb2cZC4gEӉJ^%\vn ";C^DQ""""j{;Ȳowf&14>333C<o[ADDDDD T Mxxh$ȡ$!e !ReOO7R1BDb0?v)P*f|k| XH$[X V q M8dj/sss,7W1Z^䤘\ϙN3ڹ"3OVoѥbEPo`l2,j:,gVor8 G`w5ܡPsssE(cfWIӦ ?G܂ `b2'QA9哧xn8k;hl6RMKz Ϭ1%IsN&0:5ƚz^EQ0>>9 m """" WS ?{DmUAܘ j7j!""""jA"kT ȹR|؇ @.C>o%j]}3Ө 4܇SM=w" Q{W)!r` 3Ah0EW$5X# 5@$Àr.G ,:E x0irO#<:ffRBT`s"""""L0B@6' \vh 'K,BNJ"H[?&70BDj|߻̬B !ϳ LR@@>CSS&Q0<={M=o<fffj"""""maR` &M'fMf[7X~PvbU"""" ]@5"(|ȤV\X,"BVo2]E xVP8|KK!G!)Pz47hϹ)2&&&DDDDD`,,׳ PC5A7j F u"AQ-)Ɖ|MӐdP.ubͶd̎B_d1pd(oۿN#}P(yϟo;j QYC/wG!KW"FGG冉ARa #2r,AGd]q_"" @ZIDDDDDWA"sT 7  dYfڿp/Fhyz,savv D"~ +MA%x|zڡ"ȡ$!%1\d C""""w jU@_uܧR ɰji[}}Pn-z]ۿFpf_)G_b"""""f+TcQ),uu٬Anun4 BA劙{x!oy @t|o+e} @6uƢ/ +6?ϡ3Q Mщsۿx<LMMaaa~ ُAR޵ԦTZì5t;I,A?P__`DDDDD7 DD& !b|ljm/z}蛟6 *Uumam ^M ujsx?30 L1F7(B }~,Cp~[A?t󩪊Y,,, Q9.,s: W|<źj +&Iꈈn4A<|PH܆C"2 n0UU 7p?B-h#b^Ɔ`v!{a,--annQAҶ1,g/9}\ vB\$&h]:AkԪwud2(J\j! m<X ;'LMC3o``g"""""j){|z2]fX 7$ȚKTV9 `vyODDDDA"x?<,P@`Rծ==ܹ 녽`pvM\,cjj KKKmK'"""""  [R> W{ r]0bj$ """""j QG@>77vi4g@$!  Ap{pp19?3aaaXn{kJQ2Y2]i.a]B 38&H=Voѕb:R537xUx\\՛K6,# " َeB82 cqe[^ biq3/cii 333YBDDDDDD7"fxi;c>.Uop59@N=D՛DDDDDt!S H?"#(d2aEA(?32/˘67!) B3ott>RM`b5TO|vmO/ :Ú H# 3uAcT $6Ouݵ H&q QkU gcR<6>PU x<2h_:QA`jqAYw6ALC""""c:B5":R tb7H3^/ 8 Gt|§4Z XZZ<ޛՙȝ}R[Te^nf(&+yA___`DDDDD7 DjU@X.0NQ*yt5EA8xEp@23 ojMLC9k__199yf"""""L4ICJ= qTi5J0z7!C9P@DDDDA"j[=0 |/NNVP( ɰ7 x | #th D1:7c !I&&&Vl"""""fo s\Y A.=⽡ k.maX =b;CDDDDA"j;* #^sz4rH$۷1;; eQ)خLu]obt7"H+4d2`yw_Q`n RA?w,5ydYVi1ǃp8 >* q hn-`"ָTkOOܹ ,"""""NdVr)V<Ί "׊<A1<-0BD7V țM|9v]:4;.S3N ;ŢLĝ;w022LDDDDDtaR=!ge \G7/ j Id 0cDDDDDA">z($@wkBL&* -( -`$܂ޡXDz?zo߂֓p '<{uEQ077[n!% ?42/_FJakF<@a Dt#<|PxRixfa 8ZH@ P(e{}} ZoJ`ay =WUX^^> Q72W1lO \^dSi"`L0BD-U"?ylm!Rd\.#Jq0E{9*=:[[\ǭ[UU[rnM,'S`LQ,C!:ǜ$cvaL4s%v>A"SCz= Ap 3RT.#Im %S(1BDᣇBh}~9PrrZ?]A8x0dnON@s 0<?~DDDDDDmKi!jU69x[6:+4d>c3S1BDᣇ³ObeiHRf o\![mLF0I,>6?d""""" ) dʊ &ٖ%\9rIz Dt>z(`оL&67)!ͶzS,B ǽ=P~a@0<ۃ B{.fgg!"""""z HXod6\YiT Db z Dt>z(7\?5F/U` Z2rnrE5mab p| Dte>z(joEbt3UE$qGR<hRE*B#}*o߆k H2!ty!xUUq-,//CUVTSTdf?Rv!`qq===l:GXtdMPaP~! ! 5 Qk+t(֗ !8 ݴ 벳 ++ԙѡ`vYVoѕH/] ϛM|9]W*R)w'IBeق`za(EDܙG_ xn߾ ͋"Y"NNNja{ǚbyyq_h=`ggdۣ: 9̡@ N#""aNrrŴj Z$Ae |V9%I]/Rz*}[)Qa.G b\l՛5el>_HX3Xq`aaw܁Y4DvB8::1m_O>EOOfffZrix~sC=T*T*u,pH8ƪ"DDDUJD=Q.C! \fX_uVy˾O*%һpGO]*}T*e*"H6- 0&pkp8Y177>`/F;W`fz% :+) +* C4u] ѠLPI yHţ@Q(@U=*>ՃEP!?30Z5FUEbXB""wiq2.T| X+ ԙ(t$""".  W.K4( O$z. CnO: Hܽ{p/erхA4|nj[ӕvwwx?z}="<>.,#9E&''q=DVLkf-U>GIPQ*(U*(i4!@q -R,_4  l`"dXgf!h $%t"80WH 'G G$D_4PJlT>-{<׀H$qn#""&s55M$u*"ș̭azQ^0 % 9ȤiRg\ߏp8lb6/˘YZ62 0!\Z?F_"ѕu888>;Q58PQ) Je@+C2 HBQ($OR/Fq#L"m*d3㧀V$ˀつz To U䫍HBTрJzEv<C><|"z#a cD4M,˲h4Dц}DDD)'S \>s(U}\I‰Ċ g1+LSp""""%wC^FenP@&9T>UUDPA_^ m^ ߿uB}0ׄ1)dyhR !ΖC$M*;ipA@@gF<zeQo(9ŠG#ܲQeh$wc?J27%D(BO z(' .˳,r;xDz]J2Q9c(>Oi?F____"хr9KwjM,G)RYH$QKj侒JC::B%F>GT!oԪ.!].osqk ߂d|P(>SSS~D,`gg888xjau;'Ȟd`dö́>\. 'H 8*0 I,Lq c ^M'cޤ~L6Y yȲܬ N۽:bHԖ0(H^~QH8^DY+Jcn Y!!D1ۇq+MӰmpr!DDty%SD3A@Ί ަcW'#Igk3[^!Q{c>z(ݻ =Dt 5s>N033#pΉ4V3 QӳK;B$ R90}dI x#gN=aoҬ!0gmF!_fvi7>,]<`*b(snPDJ"ZVlQ *2^/B ('p}^2%3|M!a 1pdR10UUۋ 2딈LU?J'Y\*9W 4{pĒj%ҿ{Xp,3 T r՛ٱ 뉲I*c0 Ƀ(>_\"9/T*m`oo1_bcw4B8y^%t|o4 v0 4rxOZ_ξtdSGϞy.UlyUE՟f*% m@xs| z?IFχp$ @? u=VdȾ!ቄID0ܛxTT]'zzz088X """"v ~/]5* $F0ĝ[H~%$AmoŕJ 0;A RUvFEUC?ժ")z `ȣ" "AkP=D@.`:Gjx*) 0b0F{{15!ptt'ObX-288P(귟ڔ}?/^ \Xd]fEȲlI>/`0B>z( rܝ9:'IXXX,yJ76NNN~lIb{(!W3 "/R~Z5j 3 !X䚙 <{s{1Ysn@DUtgc# SⵞґVh8 U@h==QL#mn-J!Jaee jVDD&AB޺ߗ4D- sAZ\ ۲3 u02VDDDDDA.C}G]"!Rg2_@ p8z2kRml{1d tfu}}}OnrmyVuw;L5E9IB''xY\ŋaGR.CI`T. ׬ي ~ @\nW9/ R& @!Cz T`CdT 咨 GˆD0׃Xorx%^| |ﯵmEu~^P^ ICY!&jDDDDԝ'Lԥs/Xs4 d W u i_@̒O,!|>[˥R)lmmassM)Nydv/ry x]c׼jrJW 2RvzYrݪ;EQ*<TUMv+ RIH0"}hB:Z8) srkx"y aa1;ǽ:WT&677Z#"chrmWI-V|75̺SDDDDԽ7Le>z(<7<}P( ܨ@$B!B!^߿=nc|YƳx|>a߯lTY`{v/sڽԝ]wIc0.ozfTWt RM D+\jj8i:R.GG1&IE @̿A%Q%-H0AxazP(aww{g$ w=QA)LֲAgoP[|RV HODDDD!"=g _d2l/pTUE4u; IˉmCa`a Ƨ\יH$~yeJRvӳ^L^{Iallk;{>:*CE`ʬEAȵe^Cbj+s@px], YF P<yhZ܃^@.`pr+FB L1߃DTYq<8<<ē'Ox###$u.1VedsEz)}V28z.DDDDD׋A.cHR0o9m/И:(~`xx/:XX|if0Utg Ss~(478::Ztf~tkjأ2/elu}̃Qcв}U+ U$IC^/TU\`UXfl$#C!cd$H% OX8懆:1 ױഅ0FFF00062DDm̼U,jZ5V9- =n& Dᣇ;!Aa J\._h!:N )~#}zOZ!)OHEQh"ZlgXE0 9ֵqJ oF>-4wB\4K'MU? {! cDj_BZ8$?-o09`#icÐ0#H@Vq oj<8OKFfpp a )"=3+\ suYЂA+ Qh5Qz/8%QTL&9HtdYF$7;/˘s L(@(Α|9{.떖/T:`wdtQ4sx$X3t4S:]ON H%LÊ cζQ( &vww1v\6R'@6 I*V4(o|MlaT*(J(~Yj4Fmj50P,k$9!K1H >>7Tv2x D `OI;Ffddl#CDt؃ )b S_ C): [Ü v%""" Qx|L&S+cNOQDQx&>|F `]JgB>1>>O?QQSY9Û˧BT_cZաSVଵwW ]~)Պ \sDO [V!!JJw$AUUK;>'eUVW1Q1Гg|Z"n$ HV6w0}jmdn{D+Vjl%ejX M ٵ" V@/FP !""" Qxп#ɉcX0 R)K_az?`pqi30&o~?>LMMQ2 fS-BlhF:8Vݟr[f!ĹC+'2 Sֲ51AiwZe&Xmx,UCdYnZ1 S "CCa$(C%Wa06܏V a"ؿԏtƲUM"Wq9"c՛FDDDDt!js'__Ke!Lr@x<DQ @j§ "8J9糫2Jg$^2ײ+\'KD5UakM,yECjղ \X[om s= z{)meYg ļΊd62===`H?]1{DԏlβW0h(%#}_gB Dm/IXRT*!$ ! 9fw@ ǬU@|aܺX>SQT*-\5<d ~h4ܳқ7NfR 4M?XujY/kBކq,z*؃ B: B_bHG]ÏLC BwR8Nw/Va0:ԏ.s||cKQ# #"8 HI ~``m ո)AV2XQz̈1BԦ~Ǒ˲\.l6MX (|C3-8>_p=r>r7o`cc;;;Vg^R>mP-!U4ȯ7z!sҠ`c5\V,}z`EՊ! ?s(D=3`'[_U LL@OKYxu)C| a$AmdK`|| "g歭`JESu$+b jl4h Cu H$ǚ: Dm/<|f0Bi$LInFeh2 $ |toH?H_pba`h[;(%!WNO6RRi^aΦ뺥[㬊 rD \w"d PÊ tUdYB|>d{CB$#$SG* oF0;yB;D"c||[ " s$oR0Uc5ckUw]ᶗ0V < !j'=?|tCud3B.(bY^'z Ca OL7\">#Ge\.7o88883p.|{{'TD?Àgs ldxs,6!*J-Sn [YzwEMD0 ZFAUՆm< &NhnB9TvsxoȘ5 V&'OZ(dhh2[fds˲iAc (8)u]gHƼ0JDDDD݉g$ģ/w.3>2R.A0D8v8YLxZovg?{ {+H$> ~ite2lll8:::󾻹4Vl# :܆|+b\y @T?8xX~'´A,PCd%|`ZFF$Z 4 iV-DT(BSGg+@8ޑ^G}[,Qctt6DDNaY,XkDףU{v+.dZD  Dm/?v99[(N[mOQDQx^A w?y `<]'Iq=|%JW^amm gu/7wQ88\h F&|>xކmlZ5{T $[+ 1~b Ő1UgH+Ȳ!LNNbbb±FDJe?\([.sR1OiՑKE9^XvL,|[!Qc_",N[J~DQG<*?=5*An- 矣/n]accA{xQvvN*!@rokή'r:8\.kU?8X^'5L2 GU,]!ɐ Mr62E c&C!DOCNLI'H+k0B1ćzpk| 1ou{?4FGG%"-Rv\d  rb^dw4+X)bٗ1z\{QWb{=ߟ?0 R) Nɲh4 mvHTX^y8GpELz]'Iܹw,ְlֽA. R/6(ˀqmd^/~B kbΣb gbZ"nK"^F(z!zu]666*&''1==A׀ Q7pL0eCWԊ,OoeFA]4$IyO>hqׇޏ@g IAdj2p}===cuBI4lll`mm ?mcD*Yk)vs|W8Ib]gA?8 ܙA0-a ( 0BmGQPV(m#0 "28xZ-S=)d_˗0Dd1X]]E 4ED]ZJA#,~ Vqs D7_.wmY=X,"N[Zл$ HDySSfU@1|6)wۜׯ_7:ʫ-j?>5}^oU:s5M|tvkVi[o|Py[هԦ222 TUB'Y!cN`'ubZ"Q\ 2߼z )փa,P(ɓ'x bX-[]9sEV@[ _P-jNj&""""b  ?Gï-9\ak jE4ulz1U@&' ׇ?X/ZP(`mm kkkHӮI xj[;nz63Zo"H"?\DV^ӉrAT*T*dY(R XP6%?~|[-dZ0uvz4\+ HbC 8ԏf&][@*·~o$~~'ΔkrV0br!G+QWeAa q""""^ ??q)Ni$!# Zn U@|xF"qy<ܻwKKK҅t]&ְZG|7{I0 o6Ƌ|Gnß./Cnp"app}"cuu^BTr>^چ~| ɨ8ھH+y* JJ}%cuA0A<>O=Axb:a( ( $ ^~^a5๡Խ=,yT ˜P= z@/g&0Olll`ccP󘛛s$"jGbv9N ɚ8:8nma<>tab zӈZA ow뺎d2 YˋI?j0s]裏иU ub/_bmm '''9,kv WNgO;8y ?U?"OSC6ow1A^xlkS!2 !jE_Z%_Uc[lmׇQh3(C|珢g|&&Sas[|wFFF"en S[iS@AuWYa55D""""Z ȣ?7"ci899y<DQI:d߻ t0-~ӟ:B%Թ ~ﰬn5@ΧE堽X1z?,AIViwEv!6VfLB! mU_K:ױϭ%Yr1J JOG13.!677`09q?ڎ"VV =6]ձ =RA'ED+`%_s/eT*!JYNQ"eFXN?f.bou]^1fgg[h/_ lgx!$0T*hTz=b`E[}A3 * * ,<~ÿ;G7">?m >֎ !2ҏ&]ו!rWm#I|>ҎsC mlv""+I@o;kuAܟF~"P(ǵ*!e"QAIAD6gY#_cVj 3<6Mup!""""Y!&?sǏaz!JP*.n=^0puZYdmaf!T" : Dѽ⿭~J0 $I_(bO|~1*0U/LĴ~?>3:?7o޸| }ZEIQz$vhL_}[bii hou1s(,+qtw"-LA9Aƈ DW_.,vܮi$m.#Zf|:9m~F(OF?亮Q|9ST*ŋH&yqkcH°T4 6wwL60   -ӵqAL96BA hL&L&׋@ 瘝& mo!"QG#r.~AܟnXN4<ϟ?(022귂9Y+ʦ61B0~sA#Ie]V Qwc ӉIE*帽\.#J;$ H@r]UZIA|v ?s](裏E,LŋX__w(+h|%R˧ͧ$rϟL9JRuӅaZ>BQIG ]rr Ia$_gP|z18=mb\֊(lolBNbq~Ϲ-DQ,--avvֵ] U0A Y1VZ2B0\ $"4^EIDDDD)8EtEȈTt^,N9kX,f O!>cG1r/~YtI 7osg#uЏ 1_oGry ^Wn M8֗5̵e7~r~Dt9bEQjs@Cm x, Ko[!xb`r&4[MosssXZZB8n[AD)Q2|kYuN~;Q?,! '.2\l՛v e6$,xZ}&dgTXZZG}d,籲`ٷ[y 9ZǜK%O!}gϞattj@D|lS)ZCNLqZUmagۉ&""""22%?'Ǐ4t:D5eXQ Ÿ~4p-Lz\ctt/..?7o޸V)hq}=ZYcɕU|_?&12X<-bx|-AVRARA&A @0m. ?ǃщ h3ӵ^Fis܆{]KMlnn"cii lCD}cRaCHB@ ^onᬚ @Tbl c1{^yg]!<<^/ |ߣu c`C}U_=Chr 쾏L&| dy>"0 L~l"ӖղS_0μ Lmy.EQ,..e{(XYYgϐ]t6!eK.1yCDzAӪ ]0l 2Ct22EA @ ,sx skRɕUkqgn sJ%|177[n!- 6e$*馐zj/KxcUQ:u r,Z  DDDDD $vgqa899awx,?ypiq; \וH$ x/.(ӧX]]u;*:%N6v!s>](V\F>ζ#> i]& H}Y X B:#"! Zv ~_C{, &Ơone6b=[lbs=/^$n߾f6I D=xVZ0s Aa5wa\[a""""n {gg/ONkd2AwF-->Z\6>fg`;H'֖GY}ӧذè:.K!Ky^I =_.օsTK>`B ]i9A [U+AZObbǃ`0_:mFkN$]^ T^Žщ+z ###}6ZQ0A˲rh*:34Ij@mcA ٬Jd2&5jsOb'@3ͪ幆@9FFFZ !QS;=af4 tL@` >˓xqG,zC.cWM4|6ۋ۷ocbbL H:gmSU3ղ}SMtO\&0μg?_DDDD!Tt^.L&](bi>?~v'|{o1|giVWWSd]Uaq,WR9؆z*J .U[ÔK,XX ^SQpT M$@>G>E0 RG>yae:7 ,⾀s/@$[0;;uD90 8^SdlǴB0&Tqq/^s(HiC4?6o:<t6igqd9Ij 5ϔDQ\E߶}sa?0 0`hۍ~mx;~gsTUAJCi q93d&32$XbFȈ~뿎9C!300'Oncs n? <+ߊŢL"6,rNaZ6bJ3T34EAX,², D|A189A'D&融59wSS][8vd]MO&ڵkܹsGr4SBQ)@Rr︹ٴ0H; j p'I!BI BK۶G^c[>'ɼS<']DI\X>-y9޳~Oh!UÇ4mXEn<~Jir|T¹s6ٷy  t Os]RVWDF ?A(Oa-堛AX?\%͒BDQ{}*"xBa6@Sj~Wb]u7X,rmݻGoo/}}} BTqR*y꧆d#͂ 2aeAp,#B! W쟩ׯ3dF.k:h:Q ݋{+ӋvpIѦ̙3RR{<B;gєHg=xL\7qE)%6׷8jǤu/O(@ʼf`P BcJ)"b@ @4%W;mh?ޥ{^?e9Ė;8g|ÇyVj ^ɪuI~.VoHdeAFGR B!Bԑ ۿ uu暬d2V?u4M:::|a΁sp:5[jvg'c.CCC<|T*tl{pf|i?vP)JSi5Տ=З:'%a@Ju! 9C:&T ,US {8m;Hjn?#s 6NyCCC sN?NR!D{ PSiv}꯫e$c)6 A^c7UWzMv'B!Ć#A!^?zJ)4bOq]bc 8ļp3B?y[7Ϯ] B>$bG#YF 5(ddg#bFJA$HDƲ,,0j9"_hdQN4LOqk9tlPnj^cvv/d2I? CBlp]sNrmݫ~@eZU lzM3%"B!HDy e?=cqqQnW! ᛳuqjCxFt>9z~6mLGGGI`qq{122bݩqƟ>C/}?t¹{ss49urQ!P˄ؔRE"`X,V -ۂ8L__HdOQAy}B{,S{U,㫀tyo.^[Y(B!D3q aqqQZ^A4:::|#C'۶ E%7鹓ĂD">#o_*޻/^p=&''wǍaG&/acFeYr9zIW>L&[}B6C}y7&66Ϻ+^"H8C B!B4 K + r@N6zjԈGGg| EMNNr]/7IM%ddͺK\NJ  J*pL&h̷SX\ID8t\.W hZq&bpcsZGG$==Dl6l!OP) 25rbj!]޸crmOFGR B!B4!A!h^MPN(_!L& 'Az._/7Z{ɁSG9G ܹs>|Շ#ꌍq=暮7<%?ݳ 1O&'iPrRmG |f_p}Ҍ4m0nB.L\.G$!Vai SWt8B#8[6y6q"͙#5_)cccΝ;[}B7Pq JU+*񮧆kMIjMZtB!X$"ޯwR7JņYD"A4>6O6a;\x-x>6mLGGGG,QJ1<<̽{HRMY,)֋i4T {+;ϓe$o7;L *Ahn" V RDy\|>_ T:,bmؿg4⼘pŚ_7x/^I?HmDYv5TG .߄ͦ@<ϓR_l B!B |N8T*J3%t]\ \6ZWh򫳧ꍣ9}4P188Ƚ{fMgq`gnMyˍwwff]aߕx}ak;cj, H(B bYm(6ʷ }O9cޑ^Նi|3ÝǞM"| oߦB]A N G}밮5oaFC Zzk]8G7ٝB!4,/J,..i@N_)ú q?4^"1۶mknmIDATs?yn3Y0jaP5lܻ=7B1urE x^0uy"nTh G@B4W,)B!b`nXy Oub78և  gyxm.Krܸq#GpцJFBq=ݭ d2z5 pE~0HFǠ GX\>U:Qr JD!B 8X,8 ( $IQa޳!v^(kƩS8qDJ%>|m7#OsgPt>7),\.'lx꧆ATif8D{ɪz[ruU xWB; b19&7 l$J~܎$z!ďyh;9k_Ǐy ɓ{!D8㔫.suV10y,..U <4tFL:)+E@AA1cCgLyJSea`$B!J$"ʥmԐjhdJeىi.؃Fߙ87ͯΞ$ńa> ɓ'Fzw&ǘ|:^P;cˑ{ M~β,!y**AhĬ#+aeǍiDWV [1&mN!JfFD"j' \+ \pc8]],3Oyۏ WJSĉ2e-V {**DHbM i X -H6B!B qgiҁ ! tvvF\| 'X{ HLJ7죻O?H$i[|w288شSc O[9$!s>79Gm'=O*J}i<an{*jE}5T Y8ضW!bs]L&C.B*X&gBa6;y3gS~?4Nr68H4O>ȑ#BHm$_yz, ˲wz]8lVY)-!Ӝ !B pgzFcGA./ 討>4϶nE;uMjǎٳ2)ܻwǏ7 ؞ˍ!G'ѝ/X\dCn4xHDQ/y,W}iG${ܩi&t-@@".<#͒D"DjG (oiQn$󽇈͆;y1ǎ`0A*D]XZM P#A aT|UR+~ٶeYrOj *hB!b͒ N&!JCh~oP/ξ=P O% |ٳg5Neeq}Nc.מ>!;>Z<rTlZbU B欶Bt _cfTbB7`Ѻ$i~M'j)fspHcR|>O>B*iYh?ȩɶ#{g|51Eh{6Vm;w000@?GmsRqJC)T[k\u]bJ۩|. B!BD bC;ӣ7Yd󯽿vi{8z,NWMIqxӦM|$22}ss SRnaf͚K\N BHm^M0D!Pz5 Ѽ2 V TDӴF`_QJb `J3&d^ӕpHeJ:u%-˒4a  P:UDݶ-{8>{wl@S_O Gz5 J%n޼Ǐ9wxj ZhGf; 8vW*?.td%B!D- XOnyO>ݻ+VlO|]i pבPd{a3K`$Leo;$+ EiDS 1 U$ 4NWzW= 073ÓRk8SFF!b=L$HY]=~žp+|hʡ41Wϗ!Ăiϟ?w>}W=PvT*{5v9%ڙipu.x$"B!D- pwZh)Jdb15FO:p N%-O&|g2B=RJ144ď?H6m[Yd~{i$":ҩaj:s *}l3*z١5;zE3Lw/#tx6Nfr\7|d**J8DSb,90x~|<|ÃC߿g^.s&R<~N:ő#G!r!OW 9_3-jB!%AQHTR꧷hF":y{MIcg޽|+o(w!J5]?03b1RwqoZV_ }uMӪ*?e|~zUQ25LKՏLgҚeU[V4Gj !(W i3Bw{8{F:eζxoC(X?1E"hX, =\>9tX s";spoC IJ,_Ǐ9<;vh !T u,z~"0v $b}kzbyb]<u=\Jy(WrZQK-[PϹuM?Ks Zzw㦗JtB+JdY?jgi4 ' AZ"H4R3Mbj𠝦iQ׮mt%%ALgәgFS:с>HfR)D4M4ML$y^5bYtΉ5K)E.P(ňD"aeGw=zͳm\m 399I__'O\SBj Uejj?x'IlTJC.Q- MѶ,۱mvpoK9.us<M|?Ny롹.UktQn9\)P^G ˅454wC&}#+\%Vej=)pX2y-2ocR" \v{OeW G)70@BA l#m$`xE @+"0柏*ٿ}G9s ,bP(T`w] ,K:Ě8A8ONS웚ȁ8K1<>El.BFGG̙3>|xCN&۔-WRVMXND\Kon/U,YX%{)ܡr \&1~^ϿTEv],ץyGQ) F^d|^)U^@Kс8"ND f @0 `A=B Q0^4NHhD!ڃAĺo`R@hF2uR] GH~pwF'OE">3nCٰj)4ӂ(-l:'Rmp{$ "_Ign9TKdASf4\=GB"9Lg] {p18Ky8)JFaFF(ȔJ%m%x=miqoR 72žGqo*Q<>E|v.ԍ>{|2]]]hA4gd}/r']^Co*{SSrp-pltϦG)s9|U(V da6%סfE0R^6Cj_5M{k߯^Byz:`|2R+iKC' 3n!!MQoAB#B~ID;B TRU3]6g[:Y8tnٲ>h4Cٰ&&&qtdz/?^P{ 0C!P)E.#hcG${zA˗oҝL<-P x ./gx%6;߱3`^K7?ou0:ièA f$ >SìQeOkBѣ8zR|5T.`:1htf/PQfggxZȬZHR<<42'ZŲ, sCe}9d|OxԤRB@.$T4oAOg'8yWpyD+_Ji$jP6EʹU_DiP( hff DRdaIH[3hZ7b\ 0!A7ۋDQ6qG`|c,xu;jj!+U ]*E"xwRM"M.DcO[Rw?zO~wF)߿(/^dΝoذ*ABַ\e- r']hk/RC*F<=EdP2  ̭A4%yRb(T, bE2Hח_qRM- 6ml GFFٳ>|Շ(DK)AlR*%/D8|7(]L=\ˡ3 ؅"E"d]R,8Ƞ[ wbCQS *m+}Qu sRQ-ˌThrpH8B,WCoJ!īIDy=*#;Jءޮ8rD Hχq.T_\tuux]`Dtܸq=g_0xu91Ѵȶm2U?%Aވ/r/ka4oxUA7&LuB5fRn܎GY$c:sZUI4|84{eCD""H5R" ]'7TXOl4'v=R x(45m!b6׮]chh˗/C%b^yѯx{@\*f;}V3}30RiELb>OTbqQ׬ _KMh * kw|~g ~|s>IF>qfR GTB!"k?4W7ؽe3z!HdHXFV`f<%%7FI6y GXN:Z3#izfՔX#:V`V`!gdo!}|5<,-+N鵡R4w<4|D"Y:=+S|b]\>tCә8v'O0VUs.=e*?JEjOsjjӫz[av0Pv6K!_ mY,3jթTTXjg H}XuC#/ | FЉUF0z4^2W6cRKJo%("XפWYG{BuN P0gNm߿zK/kӧ9~xcCq]sSX7RBS7F6\/x]׭u;Kq!܎t͚s\=L؄lT/|_k^# ^4@T # <޽{p%v⽩L -, )RXj;+ǎo|ݳ_߽V EV.GX$e[y AJ_B*?%4R1 4Hu_V$`4 I8ŒFqH&pUWєL=#X$"֤5dy:H 0^8) ;pr`0'|Ν;[}(?oTW)>Aw >p<ʜ|^:riDxD8N6 ؄،G[}QوӁZtD}Ep_<k 66V,LDixVZb`+VnZ-$՝t{{p_X"O\M W*, UC!)d ޅJ(6^?w޽a60j*ܲ-~BViv~>J];Bư2۠WwWHEVu4}zEjDՌh 硔jxb8/ AURZbbM5y($=˦ý|8#N=gT"&1Q,)r"~2˲# .b^{\*]ri!2 8pΝk>-L#wV uSI *l6K(" a. ߥJb܏ !Q~}o%,$J3rY.[MFRH$ىƍ,4"!J6~OXlSM +J/L~1ͧ]q.1 >{6L&_|b =eqpM- DCydYxӆ èVXmgN4oLHaWP ڙZIn˛ RdMB H"ea{7#r]on2X ^5*fP vS v)ӝ'l`hj,CtA{ xu]'FqB@Xl׬x7Rr9"di' #`q 9ǶXCCCLLLpY:FZ?{,AXy33 [#@W$B$D߲gj !V{JĚua65$%f%D4:::#:NwPgtww06gϞ74M?ϥu!z>UI ^-jrҙf*?V;:)7Mٻw+͠J1Hր7Z=kڑeedZD"2LX]aJA7|g( ETJ3(R lEt 93P;ʎYX$))f_@ @" HP*S&\eaap8L"hPc3u>ڽr=׉GGP*z*###|Bm^D;bY:X\!xgR88 7bY`ud309Aءil HƣKS˔2B hmWOUcG.#˽7Mvo.lχ4'Y]H$/I"x_)PJqmݻװSo?"76^ su[E&qD{uH$B4]u"4!^oUӑy !v !BgsUQE!:l7 6E::} >$"޻ء4R(f~zktuuUGϝm Ц[n?yNzJ_}SSS Rܿ=^ThC |=#P,JGW0 h4J$YUgl߽~Y 8FՇ遍iF= H+ԏF7t0rN<YirdQ9I)B6S l@~NșZ[Hqg<_~scll˗/KunT”\[.;H}B!b}zT3``0H   q8 As!\mrhDHn݂ڳGF$"ޫk]7-GV?5!Y߅ƱpNn.۳gOPe| j&&k:HSϹwu&bL&#D0$:$t0n2P6)JUYPw܈3J}ym4XK+ R$j H|VZAаЕM~A؞"-Fw39 OL2?<½bMXi:aKmy(xs{ݻ||+:YFaOMs -ϟСC>4!^RE=d1{(!BlLJ),G^ T޴OQ(al.ZA{UK#>KT A:;;4^ƭX]>Mw4Y]v1Ξ=!;<߷A]t~'w5!s_,.+8,p,sB!bXӑ4`׮]8UP .Ue47~j*t=lO(gYiڐRNCWf O 7w7wtӄ焝i;H 0:bMÄaǡP(P(|$V-Wa: Bŋg-&GmWV4zF? B!D|pAS4.\#GZ}y\~ǏǗ`OM/mlmۤR)i*^XlU#;$#8MthM60 5ۊYE`^,l H}}PuF gHl#m$ɪ"s 1pssd a%A@D"A<X,W  Q4!A2YRX-B!ڛyJ%JRua!@ڛz.G12B_V>Tm)GB!Bl~2ذܶm tttTC-E|z`$'k׮VºW(/-Ks{Ōo>JgنdƢ:hH$ kP׎xt?׷F1GѪoj)74C-TYUDK5ej(w^i2hSm`0"&oҌϤm^]m͛ oYbjbJݓDD"ضM>T*9JeYέ3tz:-WcωIJ,juSx B{R_=5[WMUB!\u݆pHmՐ`0*(&INOs*$߇WC!oBX'$"ީ߯<;۰ܶmdrysfΏ?vUxtQ~ۆa~_yVº7==͕+Wq1:atu9k8C:ƶUNA,#9t0Nֆ2GQ0wR HIʕ1V1EφzBI>_[Yc<!HTKE(FAt g:Pݭx\=J6tlh?!gәZ~Hq{{4I}A:::<:mp/"R*H& |>?O_yY߹Njm|vC? 8p<!ލ=S(Q{U|)B!VU i+NJ_eƩPͻvkԔ+! w_>85ٰq$ ;g0>p8פ2śƍc]Œ1.0[{ 27`0H,# rۄt}R`3s'ڦ"gϚ:pbq9԰)r5&(NA;YAkQ?J-ʪV {$ w=Gj6*R|>Xzm3??ߴ:}aw\8ԋoO g-ցeY|7q%"ZT*UR%d<*A!B*J{PH` (apAlھw><ݿ@kA;W.?R-. R֔r 'r#z=c6~uTqGG'r]W2<<[>0[莿CxG\xG:^G8&\Eum@֭hPH~>W< ..@$:hMwl 0Yݚ O*uf33`4"ecGw(3tKE^BB!\%S,>A4 >iF \ ٳgLOOsECm,_2e5TXj!B~xGX_ ^hpTab ٲ}J $"Z"AÏԟ6Ly@h6 ٦M [vgǛ7o旿*eY |˯ PC0iG\U*Hz`4M#FW,WWٿk7C𛫇)wRnCiq^6p|V?=$2??_}ln{@gNy1]ۢc2ڹ](ToF"bXF'Z9{7toc6>+ `a0 xbHPDS xh4Z]W)|q&.ja~?'gN )J|Wr%pMJdAb,,SJIW!B3Vp`He]N"iu6QPBhS"Z淟} Pl[ Cgǫ$juxvpqOO?WU@lrrW|wmEܼp]YL&%?]׉FD"WNנ'&=z.JCShhA 4oC@*UAJϝD(5Av_TU+ E{?( o"otؓz/8wG`pgx+F*H$m ŢӄRL&CX}L]9ts 3|q*Gqk+cccxK.wVh3{ʙLƿ"=v!B>98y4M4MᰯZHeY06FxlAnQ H!ւ)o+w)ԝΕR,,,8$.v=RƦ#vg} bewΝ;΄ƙǗOhT02Bu DQ+ g1}Gq:=)4Jn]8FZ LU$"-SUK T=@. 6硔j8fmDc+۹X3&& HĞ$l?GWKL{=;G~|Y `x<^$m5TIka>!rᜯ\x|6{wɑ@ߕ+Wػw//^ ⽩ARY +=sB!hRRܰefuJVm[01Nxbc;qN)UBh)o?Up@VT ߏ{n('w.۷o}Qی~,oa||\swoy]j.HR2a&htU,mNtu:v 7U  wp3::ZgϞVh\|?=Z,A!BVXeYd2@5Ri)7- F/#o/=T jg[BTO(討,)ݻ|(-3޲K.RX4_u `<[9߶Ep`rٺQYb} DUM#۶AQ 'oi ֨Az"Y$ QQRʝX@j+iHS nFMg(<ӄS'9|t{˺;+ LKHW@1Yu < BϢjZn__cW/'͊"_~%ŋ *A?ܖ.YrB!kQe \.aapu"p5DH! יn܋MdVVrn#/Q}mCo]C ,@J0 4MkJzP HE ӂ=݄9"$P]t$1/]=z jiV/Jr9F(ADujNQ{u8{:W5b?\p\?ۗˊ"_|… RDu fNfrO*B!qd2d2LӬV *lC:(! 7;}Q?NS,wC~ȹ8]*B /^ȑ#>ukbboDz43Џ][`~'n7t0 2L[tmD@h4껸\I8H;L =ݸzhZ5 6W*E@`0M2L-]CbHb#Yb.}/AvQ l؂ړhKT cGe#Tm|>#N)U/b_..p/=uKY\\w|xxZd׮]Thʶml&g[h5P?F B!b, ˲d2B!p5d{D&ٲgw5 ⧒ x#l^uظf)ڻituu !˕@μ2i~!h!KqM>|X]z_=|HibnTv!W&}64MbX52S`LڦU(w7wiޗXhCh5a ~-hT*U} (-ʁiBA BJ7(ozLYs?akwvdjansn# A<'S(V2 e2\|ut.?E/f|--wT*q@nE?Vm\L. (ha7|?؀9Nm{|A YϘH4 rPeFyUo+m0TajSJ3(wPtXY*'8臗Xy{ H!2=UޥRd2Y=Ysss>&8Wt6uW 155|Ν;[}hbA6/B!h\%͒BDja1<6Ǝ1m}} IDߜ84=ݰX,f[Z>ҥ™ӯ ~m۶Vº444ĵk|030qn>zL>"tZ:Nי t'zzЎC0!o܆QFmEWM^Y%H$i V',>A(.Q<x9 ,+҉D1^8~ g<m1O&~9O4bXbH>M$GTbvvd2I8.yOd2F8>Ndp|vԱ oFdhچ kU<oXp2ZW'.-x S%,\=L6t=EJ(]G;ʁcG9<:p8L8Ʋ,4TP,A!B!NdTH|IbڧY$g:mfqqOC  .:߉Q ׿ՇW_N/OQ4[q` ޼SK*@vѿ};^T4V`ys7Co]0mpTZլ" QX@<گ"HSs1< gFJ3țț; ;Dgk>g/YxBEO("U0f4*&t;F$ɔ1BA+OԷn74b[7և@ .:ӽշ]__CXwyodIF~||=1AT*NQmx.4v;ҋk(܏Xj? ]>W0kI H<AT f` Xt,VCцʟVn5Nșu6o"|Z(`_@ @2$S(r}F!LmfaaM[>5`B!J%JRC@ cf-GH DHD_wH-zD'طO!B, X7WiґJmOeC q8۷B!~_CX7Rܽ{ש9ѝ2s_,.6Q(d21ƽN䀦sh^C s;ys& "H]GF^RKwH$|Ah$\ lvctZyyrMin. Q{we۾욙ecn ] B8C.X,{P,,d2Yep۶;.݃{ДGzpY䣳'Iۏ1;;LOOOK1̧2jq2v*B!D3AlX,F$܆x24ıQv;&6~/x#ўX9!NS*ZZ2L:cV |>{~G_!|1Ri}q/B J)RtZ:E04ٴi/`^]<_Ёr]/ H7jʓ kYa00a7*s=>xأ4ngY[lB|A+N@lB$ٸUDy,..J|) ~?6•k~Zz̔o?|?ܾ}[> B?)yB!bNk|]2_U!B"CLay.lm7HekLpvlm'@~gϞqU߇u!JW_[w{ˍb)<#JaY*~x^'o{{κH|p'ysJ0Qo]36~tyB!bC4o?Up.m=:+|ۋ{oB 7on_lcddķ۷g6!`0(!Uʕ+Ҹ9p)Trutu.T ۶W+{:ݻqUy ys7 7uZntmXQYoʳX0҃hKӝa_]44A˷'/G-~FQk=C%dgoaӶ~=ntiHH$BP Kg. b1xu,A.NNp4ѝf|n>9rR;w055L,kaq>|ݻw~3zו9!ؠ4MC4t]}_Yߗ[6o˫"ʗy+D2ܓatU~iC\+ky\!n݊~8nf@WGZ14}~;-L *F+X RsYެS\,r]ÕJ_5=F:GOzF~TEy6Kne3Z T*H drXEGGG!Q y|^{ȏ).;Agx4|2{m!u]*/W8&S*rm}ٶǶ/pݻ=ɻ糓 T{)/^O>JD6<}tŶS۹wot+7 !ī2 XB]4'ׇDV T\וJ$Be0??O$!H=p޾͇]]2]X$҆~ꏃ ˳lC'};/u1tn+Ǐһ(q/~֭[[,o޽{ `#ts9_N(|>OndňF*x*d~͛Dxf"oBiQ$ޒڗcMEXm,Gtz  J)\m8t@S z@9 +WS: Cx$Xm&ib6\M>Dz,:;;}G`|s@2éJLDJ)&&&x1M)6FFHX1 e:x@q|}<0B>yTGHJ?TXU(ų{ptй32]XW$F;|KdYtOeBdnPu79g?Pyٶm[5::իW@/_ܸ 94ϣ fMZE*wki$UW{p{LQn'ڋ>VZ]^v.7kittt0?s'٦3cABos5^2X4nnLg5FMU:A244ē\:;;ml6+ @)E*T*L&}&sgДⓧ=A,|n|9ˇ~Ȯ]Z}XmT*1:Z~̬ݝ1r'x)A|^j*wTg4 " S+뀡@-?Y^y\]hZڦfoK,jk8 8huմǕZmk5G|_綑[WLA #>/ET²,8$*fW8~T%j+u]T*FLӤx:ûvǗ.]bϞ=~k\~'O4-d~U5; 7)fۺJZ ulVo44r^\=}S6;^_TY:;;}APT( Hg ,,tuV?M!V l l"覈Z9suξٷã < ²,lCZ?b۶y}%.Ǎ 5Ǖ+qQ/ME ?Çshugxx;>VC&_;zOgg{5ZRkBk[bamٔ-0)5 "*E@RD*,Q. χ6-ZyM#A򿹗^T#FN)E&P(L& +OqJuI /_PrT)b~8WFUnX._«tocǪO>Mooȕ+WϽ`t٥ȕI uT0kb1_u%QBg'S'Q5EVr}R_F;THXm,ma Ьr"A\:V*y`)RnCu6:HE:x9a{ ٿ=ˁNc&6mT*feuu]Fr>b(a{@{98X,L&}_ t\8'AĚ>m귗.?4,d2J:]]]ƷNuԨD:wx\pOͱ,W266ְS?w9Mf> H$l ЀӦI8]]VHPhiچGǺQ4 0vfzjRp̹|ʧX\=B:|I d{[U $eڈ T*1??O2q~rB`Mlf&iƫ#駳gfej㵥#۲lȲ$gږ8ֲtlk=҄nlF P9@P`*:VE{|ojJ_ls^ߵ gXuW?֊Ç;M#T*ۦKWJ\!pt杻yjJBT Bq~ڶ`"Q u$<5mJBt; '!iM'x iAB"yteE%gRD,8bӟ//^jQW*({约i?o,]Pr@ j?sR1NhzE EoN[q{B`S DA'uIRD"*RVGx۶)hڎߘ¹w`qFFF}6=\Qa(Z>l_Q !STB<оE"Jh1Y#h usevL' )Nh)]㉦D4;jQmQL_2&^JBZ% 0<̞'A!A.~'ƶmr\w#j!ZupVjz &O6,Y￿`./_… mOR\:s )ad|s֕mddUcN4%~܏=/sM- {a֭xo޽{ƽ8qYZ,7Jq٫e,zBjoсO10K Z#f !R|Jh$iMC&"zgZhi3֭\;A)E6R<[k^-AĂ$=ȯZVK:ك]<ӀVymCs<3o%lMTFH$|G3XRyQ/>ǃ?+ !0W,{6i BO-:Zmk멘21'5EƳvf]N*,dD)$Z4L1Mg&M402Yx *v@H8BŢ|/Bj^V+,?vvY.]w_Ry|7o|=bxx;wzLM\Ct{x(n1y痕JrLRI!p۷h@R,&bS,U% !ŕ"*6 a'B#t\>jmgf2S@%|T*ljMa =v>~=:(2CGTW-=RYa:]<oXh[~M?Q)e@=|cǎQzիAmrpTlI%r D"OpcQA 1hoY25N(iXD`0th H/qeQ ^a(C~@ƛ1<­!DB mzMB!"Hӄ# }gι My'iN`̝;wH& <Þ,n??fִ=0z z!L_4AyGcc33۶?zuE1T}u>K'C˼mNOB,Z0b OBju>_TBpHmtӃ!8DČ<#JD"M]tln>k: tK9f#ZMo}~,Φ(b, Ot'?!5/_mW5U]ߞQ\̽6\%`x|>HdƓ8޵/D[GZL7`*iZ׭lyTYȦA@\} z/jYYJ0"rk"omK 6>2{ $!Ri{ bmcAg3Ҝ:~[7ks<Ͼ}زe|wacxxn$G=w|M9300GH޻w2Y=R.)J21 DYHj\S ΩFMgm8˖_GZrCE{{OK/vA ([AL)JEMP^ Wp~SZ˘ !^cætW310 bP\.3mV1E:/1(Dl_8}4?~j|I&G~2D9RG(<lDT*J%Y DhxCjz5V.KGP._:屮T< L(Xrg]|M?RMZѻjsh`0Ru_|vIuJIKɟq퉓-J2BoM6i:}5 *Mgέlhu:}QOm'矓f>~39ʵsW0O rl6+iD"SFX vl<͢[CɷjBB,TͿ5}JE, V(S m-0ADOqwkl_sNMZOc&}}}eV[DRd2*h\\/p'.x|lٽԟ;228fٲeޏ$0<<צ5ҽ;<a/f*MMn3JRP.{v`zУ,U AED=VyU^5V3uGNNk6R 4Cdw(fTUbX܈R;ǻ+WTAЯM߶t+˲*z,6:ttf-[5i,_ӻ ܹszƕNgFn1~&8{nU|gHb.p})ZQZoMDdty7 O."D"ǏہpZĉŰ^ Åj$` 0W`wUW1lo{8/r&E S((2ԪNcðRdN7pVO\Ngqock|?[k׮E6G*0xzk RSg~Z:u]tOXA"' vz 'nz^|kY}֭[8Νʕ+3>糋==7nڿO&USP7|c陬BcMh%k&xMoaԍgЍi5@f|XAbP=xĠ=JmǏ![n Q BѷpuxB(ػw%r/pXh[&R\.EqdKi]ʇ,޶ZCQs{f *w}ǃxw5bXvv~ݸɣǏޱg-%8N=!Uta`Y>ybJSi|q>BWO)\V|Pk1j摮qWȾH-< V=3Ӌ\%LDO<].cl۹CZňJf#Cʼ~rU?R\?<=j,yrR$ׯBt4/R |!ĢVMbSRƈ1uuN%2N /j!/STM&PH?\gYW6ݸq#;ww8_|Ōm\Ӝ?s f)նϫVd240bMg0Yk'N_?Ek9:<A7l.ɎI>e H0`qT.i* .` 8x!܁Mts{Cn_k^Q,) \$* d|'5咻u{0]o&LΞ=˽{8|0hc?ݻw}6?wpqo|U+kRT*Jj!fYVڋ~h*OxJC!QR9] m xOCFtCgDyk/tLN۶'5Ut \AW捼q[|ǏIym]LZ%JEP(PV*bGDFtsDf"綋[2a<oZrFG)A !AEfȐR/pnZRqzC hZ NXv!|x`7Awbضg}6cfWy|Tr۳Mږ<.˝iD"B9^t6ʵ(K:Bri4rS~)H4Apw2ëaxvAڭjQuXnӻ*Ă(VQ!dCS:jvENgSU|>]"Үp Cv>`|.r,Y;;$hN 8*}6ì[-[?Tɓzc||Gs ޭ<0[#Z {hF0$?b. yNUXzX~'!bfa*DِIcySip0<~c9o-,uI&D"ᩅO6ٓ'ŗ,; b "c޽'EkRUF߇"}V}Ku>C^2~)dʗb0~}k{WkC˖Ν|+6ޚPK1"tqz8oU\,dDַC<ׇĿkqTKj2>1\wSEAiJU+GBY/:w3Y|j+ X9zޮ2۴gڦ׸O)VVmza~DQlۦT*տ2bRD:SEcs]Ɵfqn~2uϝ{@xZɱ!U-2ߠt\)v;{\ݎG\>BtȠRvRΛL3NhVxG\T**|>_x`,+l*bsQEO?N<;O=d Z`8 l&KSClٲN~E>+Ȍs|{rqQ5Cd0lG.] BB!ǩ={^ZW{lb0 |x}."A#_'^(zrru8+W4=o`k>8ؾ};7nwL.?P(}v WKS08ΜW|g:xo.+6aoHڿӻ.DLAZ~4?lYO86zV4{8.ZA41L.vo+sywrԎm/J$ey7mU:\}чItݝlw5c>xH=n>r~>-BP87tޮ/ټAļHd:27zڠyd2N^Gb G;vԷyw:366Ƨ~:J%9YFgxJB&H4hdto&kv LZ1 D7V+ ;'Zyd&H9 @y" ]90^5̓x.sO2LzP8ֳkJgtD|i9,h>Z>ymcc޶gҦh~GY֒f>inDn,V̢M ܽG= mCG<ϣRPT$!D1 cmǿU/ B!XT)>]>]lipj22>ך  [ CZ%L6io&a1g5¼'GZ5g2Vl n|a~wk>裦 "ѣG=zt/_?ojܭ[j>2mFӻ.Ă0}(PwY<x ddJ$MA#DsX$'`MA,/+(t([Ka9<;oݸ6ꀋDmHT"֏+W\/^b?@[;pcgSPUl]dT\:/hj⳻9Q*RcOQ*m?iָveBFqyln:LMra ض].Tep>f:2$"f[#̋Б!5 r MVk>P}? 1mY?яW[ݻw/u[.GϜ8惇;fyH)/ DfHPݸ~?#܆j*hZipꙺW-Hp޽v08iiZτzR8esԦ( \ "8zdh7}a4_Ε+(|-'A,˪A]cVzTOa4FxW*b 'lzdIXCJp?-!t~q$"i&cqbs28fY)IJ,,"R.) R%dQJfmh4Z;߽澽RDJ Б!|sJBXrikXvޅӐS= NE4M'Htz;|Wm'_<^a޽DZ~`ߪl6KTӵt]'8Ax}V+|`3J&„U_6ϋŠ5LCI^ ,FKH5542 .mn V+ p\1o5sh:>'~4MHRYD"r]L8=v};wOjܨTtqz۶;EtݶS2!ǟk䒡{]\  PV)T*NhAT¶mDHq0A#Cʺwө]%tz^9]I$A xo: nĦ>`ʕvNj؃\ g.;%[-֕Rd29Degl[܁e(Y+:B,L qXc5 Y Ac<,Ai=RlvĤ$"KQ"ٰKsN[`RZjb"Xipt|ѣl Yfuk5x'$RjO6ːcZ?$<$8m|guJz!vv5>L>5 F:p]bHT1qljMV+l0hK ^pUGRН>Qn4ySsVo֭[y;qeΝ;k㏹u gc\gwn yiYB!茏ou^۵ W l6sBnҨ"HxXb/KC1f3wbRղ,rwi7(Ίn$)KSR5TnF"}}{ctSQuIcm.&O[M'EB?M#]G(<)!%BiJ%/m:(B!fSZW+6 O,-\A4%S*(x~39B!D/рǿQ2l;C] ,Yx`϶m8]_cLJ~ؓ&_}ony<>;ogjg u5É>=p&NJ3ޠbUow9okE ,D;wԷ m3GT@ӶsrPnGd J( B'V YͷK7 Ar-X\jr>޶j&to?-޶]~vzB!fSK_|k|b19||CTqqUkQd}Ǿ"qm i PhX>Dk3'_&$F LL3Nw+uۆ@J:3c\.ګP}ws;0AG I!io|aK$MX~]2X\ۭ*_}5M'z`sװgͺիٹsgwV|<,NfS_A3r=zU] &PV0h@i,iji`Ɗ 5Ś+c}4.mxׂ *xO- Q:R]z/$a~e g8jF8fpp@ BHxG&a||bmsn_^Ͽ|&) $ !Ҙ7bww^ȁ@~Dύg-Be(pE$ ң/ÌBS7o6MTՖV/Bv\{qCMbޜFyw:TTO>!NT呮O|&&9<~?~rL>R.q]D"Q??*޾͏U _/43tdH?ji^c&$ڼ>/'v5?l;ޭ q*n } vxx+jRi\G<o;xk5_FlM/,!yav}eY \ip4TV>r\{rB!fS͐,d8J%+{c6d2 |r>?vze YF!CG:e>܇$ q֯o{ҧJ$N+f!/~P woȤߴmE%}}ۚm3ڝܛ6lzFl-%ڋmpXчt*. 100 =B<7۶rS*1MWb-n2L.B$RuoeBf<`AUċ.dJRO>~w!xƚ+JM"7Mp|{v׷f$Smcx ֯_]e$@XlS?K%nk^;qH&83)FuD"-tjbｃj\R]|kOM}F^vC ,xӃ y78XUi.bb!8}=L17;p aF-s]l6؜!:goF$X\0tB_;*[ݹ-l4P( pX^Zws"9- a^ A:2n]@ccz^FZBcMַ.]ʾ}:(rk{.xTr#W'ZmJ h۞hξx[4?brB<#/(Z XTAcSmN`^ xE>6|wSB[G* WrD=x5|\BKu!/d2nL_ 9 w>B!M:.X+piHABB^L&ӲLӀAA^ZKڿdٞ[VkT7wv0ãGO[VƖO>M`\X_KZW)f2ۦW@CmXl#F2~zC>'0LӤH$3{B!^.qH-碨i|a# ~3`8%Bmq=jU(9Fu(N]/ˑ7/*# @ L LmabS4ݵpJ{^u>g >>ki咭ʼnsloGmޣ\.NeBL?M ۈ l- SqkyX$lK>~WWՖƋ-%UAX&B[Cкg7sϵp8,ABPmNs˘Fp4VZȟ Ai0օןB!|j˗Ml㓺$ỈgU(fM*IyVWߠW&&>G9y')~ H? ~c}]CfTBRZ)9R `hx ċU*d2MVxr8+an{u;75ɉH$Ҵk߿9Kndy8^~زeKwxyKA>ͅS݉(y>ǯ^%f\T*$D"-A]o/i>7}sBq'Z }11CɊ_V"OL=f5P8yM"`>Y|$X\=@*pep#&_K۳*pۼ6f=WES!.bb|>>﹮yS|ˀ:cXyqr&J៳]WLvUg&D۶=5e<#H{.6o~yfȐ{A^#CLbZK\.2~?P6݋0o,YΞ}}}:tӻJܿ/v WM&͑;|y:6Q,rQU@V}veK[4՚V -<ފJ5DC$8LA򓧋\^̲me1dt|GC_O#VM|>orڶU)  9 !x<ϣ\.S.4 ˲2_YU}BJMC&!k=ZcPsB!LL)~8jOeY}}}T*K}٪*TD"Q?up}źwޖ0H +2|(+ Ro12 X,t5kpSy?޵1 cg)ru!CWa>yP@^,G<o{ $vp?NCuN%ߪNhj2$A`0Pkvd'MNAlPRE6$C{VG_8us3jA2 tGBхRTզaXòv^^4W qϠbjd@dK_}axqlۮAjs<l:|H ]F_#CJ] -a<ɶ'[^o+ds}]"Hww_|^C{|62ܶ|VP ỉLX;kzSjCdo! 6 -σɕeX>+ 5<0NC6@ܱ (L7mBSI6OrMM|y~?Ǐ/]ǴԪr[X!3\u]%~aF4ͦUs! b\7]mV#*B!u_+Ub~jtDr29C*~s[y8_`y )#XCwL&2"H*4b7M/s3KCSAoΪU_YaᛤD_Ok;;K:M=q/Y+6ʊd!:s Ա*ţ14m X"0Q:mTSu$`Ҹ} |nZ B,Rek'VmX(c;-]ʥKyЦ`ib1|>lVyB!^)㴭N1M1M*Vĥo"͑2B!m.V8e>4M(r#{\m E<Ŏ% I%9wuJbj>ؾ !b.]Ukۃڵӻݽ{/uFFڕrb?JW~8Ǧ[u!%A4YR)2[/VA j(ރ04uzWBWFWeKy]V:7r,"NK! BcHRinzK84ͶcPO>]玮{K=q]B8w\> ~{Jx227 <3gػ{A!鐡#CZ8s;j78|Y} Dm˲x+)ܹsmKB \$!W rn?Y{B U#A2OB B,d Ǒn=hTx"A#߶Ǥ=̄l*Umz4!bQ'څ*{+ J0' [ !yjbH.#JFGGI&d2 B߹5~2>DfZ&.B]t'/-4M#ߓe/C- 8<:ws||b[,:yITGGŲӫ+l7M]oշfwU$tz_B {wo9:>vv1(c``fi;qV,W+]]ϷBt '3T W=oцJ콮Ο΃|nӻ)xAf A& O 9f|m ```'?+Bt(dYr|k-߈gMBOUlB_^*IdWkȐ.Ն0mS(:kk6mk\VNMGQ<]9vX[u3W=u/d(OV)fj$,dh/wB:V`M]=ھcSap]>h*YNӻ)x*dƩH43NZ!6J)"cccmט, 2BŧO)^(˙Jb1dsr% rOٶAI~RַRd2N֫G8׷@ooz{?~i.oWht҉˵8WJN%fkSӍ0ߧ4\u27QZ~ эz<>"e``j3hZxԊ@n>WITrh̿dba4vrQ/s^~|Ō+¤UBnyTL&CRy!Yi>~=/cHυB,|<Xoğ2YD9 P DgY 4tdHeϞ'ZV1vx<޴Zu<0Fhxή]&A۷[B rcϠsrǿ6cj!u׫LӤm+Ρq6aRu! SǙn=oB JcE-ߎD#MY5&<*5lcj&?ٸ, dN!D*ˤi]B.O ;ۋ8馱+C HȈ 2tdHYr45(]V)5/pi=-m3Xb۶m4n믿n|pytg>~o>j!QbXCaS%k%FX1P^$DQLq&XlspFGϕ Ȅ;c6U!KR]w Wnp6`ӗ/u x.ks!<zyT]bTu9ls]r)JU~dwiaH$(rg K:۶IR9|CG/~7EdոJ)ZhfKwWZj-_ہ@wyӻܼy%r7ɳyjH*sD"mKCZM!dL2m%"Ģ3"H6=$xiT$oK4?ŕV5ڀqn}V+F!zUѷTx/>qi/_Y3ZZX,B!^8m'$O~=௅eB0_: ev A__Hdno.TՖ_RhHdQ@/808BӻJE"ˀ۞nN7xUVuz_7nmyNkM xm쟏~ !TU3-ht ӑ%LF{`QBebT{ʸh80T* 8Yd9 Rs5ZK˲*.[Sk`p9ٳӻRܸq'N4w/j #ǎzU 8m"bnjeC}D%O [B`ݸ%!aFc@B۱i+,i/O ]Fŧ;BW6$C(Y+PΊwfSx/Bvyi o6?8keBWGYc{eY tmǂP(P*. ,@yCGy>ߔbOUq4xpj\!U\o+f>iF,#Hȵ>K D!+`V{2ݙժFFg3SJN5obY %1yN=o嶫UdRw eSkX*e9tPw{1Ǐo =ȧB xǏzQ8dRB Ϩljhi%p ֲy~!bԵ`4P"bYCiS* X]$ mˑ "`?pH&Zds)V)E6%uB!%mrL>g||qJ> B8 +!jO+r,æpx&ͅB 7UZJdmt:b9%CB,VWwi&Mǒ61rY $bn,Fl?k7_͕m-wmI{!*?_3xO3VzaPce)%AnY7*9ًAT۪ G}bQӕMri+'OɥKܘTXdlll^NB!x9\%+̧JuC|~bB2J7~0[0*4͝ׯc;X RœNn;R⦛&&~-SCP׵9y$ݫo?gZB +|m[B @4xV0o„ $i(Y>B<.r ij/Bc$hZxfݙX/A`"X;^!ۖCS.J3BєGȾGzM.eΌׯ۱m\.m۝B1y @P(imiSZ&ol;kH~!KTlv:.IGjq`0ad2y{Rt:@}aw۳޽#92SiN7 rЏbMj} -aBqzk~p7nܨoO@5@?٣GLpG<MH$mC Ç@QI:]B BFZts.-8Uv24mA7gG #Jadk M("\>N*j)#4W ӑoqWﾅ B!^+T3>ߏa*5'*+ 3$mȐtPRTj;ݭ >TfSK]ڵk\x1n{LJN^5wRT}!DWimh]Xdn, xs+˲ǧ*bSA}钦j֓aqp r8nշ}bQ;O(!ZZ7CJ)tEǦz B}O?<#=;.D{'Y۰Ν;>}9|χo3뺤R))5Oi߶4dTG[n@cqR=8zhFu=5HIntDb538@`s{1O-75Bb>7E,w^kxȧGÑ1X,'8(B,n1cccdyWb݀)[<*!B!{5u]`0] BKկ $ H) [׮Շ|O 0EQkim sxStȹC Lȳ,eYt-<;~߄/2z4k 4=tҍ [5^w9| \\B͵. ,͑(^$Q.=/׹fT*zK!21dd2I\5nV}&.o}\텱!/f㷊eޛUL,#]{K&q+{0>0+`>[t#CʸvKTYG 0n{dmMٸqc״I=z^z:8u-ןc>嫫W[Q L/[.fm[8l:t'@ӻ,XPW_91dT `[hj@bq Lmر3FR!;+&obR)g+SqN]D~k=ϓ3$!kￋ4LM !'6bDJTh09vږ~86^w:B<]U3P86b :ߞ,!ud2$I !=< cccy\5t㠏?O}&^.BBfnq]7n:͑_U~$2#CʽxGەJpӇZ4{Z¨pCmjz͡CbUjZO?XZmh^f:7ΓZ w[\L$np`%2ZkfժU.GmJGm#72>Hc+thH$r|?@۠8zdx!7z4AsŮ12~Y^lq-{ !"h?`ppjyN;α\JN!78C.ɓ'ry533YH/!x!J7J:N__@ӻkz\F aDp:2 /P*J=5?2p%Lߦ &Cn?7ǎctt~߹#GzNktO/3!B=MH$mo7lX@ѷNb12Aֵ1Mq[><_:Q>q T:˲4&LRTUjP1-,77>N:¾3+CTBz; ˽cP`P jc_v*'OK6w )mnLXmrz%4M#mt(&Zܽ6o].Or>!RG 2CP^V.V =~>˿,I LT1nު/T*-}eYB[,<+ۛ+l޼6EZѣMnߠ~}%wfRxBPK `{C6SB3Ot䴸+54\7W =wRAs'}Aë+O,nzLT:ñ'9Q,0ەmۤR)4tB!h.|'O>#]-~#EpR!ċjBD"N悑Z J8k*ϡG@ϕ䙞:aZ87ַoۈЃ>{N3SJqر+~U\;}\NB DfL54-V.?H:oUwW!PTK.^t~ X=- ҫAh_>YPLwxVrTn_8Mm~vΞ92ەd2$j?B!S)(dP4icɟa]]iv t8&wz7LeL(ӻБ!eܸŭj Ri^,`MV+9[lz͞={$ٳgyA}Q!݋W/<}i6|b8}K!M !6sEl63>$=+$`s hjKfjz~[1E~@]F/K &f9zG.c||\i !b*$IRԌ8g#篅5{L!Ĕ?^u+*V"A&9ӶP~~Ffw`!>2Q < Bw4СD/ Kqƹ~|wms9w2*7T>Ή'%j;ωib|>?4ML {)[K Smb~fTb*H-R hVƒM LTi`ٰ+bx%\=Ab9Xn7~x;<}T*Q(zbq4 ˲, 0A顏j.a=ϫ%!!u],|`0H(Bc; mT/KTu\jlF'c% llxt[ _/Akw&3`a ۹q#1G\ d֭$N3)|MgFn=r7X,-C$Z=-Q?ݔ|7uzw= g"eҥ ri?7&ٹ@cÓy4ٰ|P QW!\Emy7@ZpBN4@ @(j .6/#2SH<\׭9!fS(^,4~o?Xa'BK;.T?"^5f[/96?pӻ,0tdHo2<9QKU"HEnˇa}}{Ŗ XTP([o~&_4|R_U?蝑nRIB sJ >=)J9v!K֦" M],YR>>u@Sk|>ƪ㺮cfON:MU왼-A4!XFdww?;l&SmB*^XxB &T @W`j:RTP5pN5Mk9jG) sG&J>P(T~6U,߷L;.͕B􊃎_.Um X rӻQJrL hؓ'O~~OzE  @zʲ? d 'صjmk۷hWL>}ѩn7''OTO5rl6]_t]'HfdEքjkvc ZҶm ]G#hʼnV}8 2/o镖ӕ @=BkVUAD 3Fr k.-kf.]retRIV| ! l V%% lj@oH,/{z>W(K8 jmSp]r#M^˲,`0L\B!/i-#8dY<`P(my C?1|>~f;K!;Wwg(T^ř¤"t}_[4z2p`bUS[ MkY-_hmn?QΜ9t[7 51Q#'Nra֬RHdt]oJ1F xӻ+)-R: 1ȐLuKփ +3|β$.l) j \ JDroBK)J)"BA)BEgBF ` 榍/Ƣ]01Zr=B7\(/I;6O?xSkߪժ@i!CR1;B3=w` v%K7 ,f)MTE^o%ӋUWєzRH+&`6ݯW*T.\L6\AJ% z!B|ҍ$ Z[x?^K&h_F&Bz*R)&B"͘xu]o2LT*Q*|pl>grqya+UuvxkC_8U<'Ly>5If4/^fȐgOO~^sHJp8ܴ2ri]Sܴ98D"l߾ӻ=o7*ߟ]M,gi,ViY0O  8|LpUo./BsE+7'U,Yi(0t-8KM|=;^TڶݽG`J@w([;B0rWGk(*9˜Ii2ZpE6^!jI;}0/b*Ui:ͯu=fDC+4@M\Lm4@(ܢ4UVBU<뢹.砩? x0^M~m`Lf2T 2j15U{VibfSKpm==!GZZb&P@ 0V.p48fls=~^u8]=!H扦fuD"A2ٱZMxܻs檧 j w 8a4 e/`^kzg\=}$ɦ}{ݙX_/*8#!9zZ`0DwIw`NWM 3qEej rl.iW?_Gr26øwiUwUնanslIDt Epu]5<|ǹǏûضM>钳BP:14b03䉰~ѧc- opzD 111<6p nf<*h*[yy?r&Zd˙QT|.XCͩԌ?aYVSCumjZ"b8l|>O(" \䊡s%cU9~BUu?iqtwclۦP(R)z*}C5Ry.Mh4ڔ0> Lnilݱ˗/g՝yr M}uĄu>>|P< B ABO*G݅Ef>r-K.A\ɉk7I7YU ҋ*JjG[Xf0|o wƈTnax׵[\̓9)~3ߺ~=50 HkЛXxAg 3f9ѨأvR=eZ|^v 5D(UD$j|R:CXc3ʳ_ayM^'7y~?`m/.\aG_-U+!?#B~p8ܳ`ELc`\9 ̢g CGqw{k: +^S\`qMػwow{K ].رcMyjCGyçaL&s^{?"څ:BTixL?1 d &(ߛ֬iz=Ү=̕Buc t'W&\Mm_T(;ϩ|E@RŞY!-eزr%ӧF=ÏoWgսn+B]x92SS}Tayֺχf5YM0^H(3$ F<߻|C<@-[(, y8n0 DW+6}K! РRbSv$ɞm8BHd3Eg?\ 3 Б!e|CHXA`0t<o_6!ꛪbvnϋm=z3݉\k({vRd>y"4B, )n?ST0 -[ƃ ֭\&:KY 4N~r\wc2Ps[oBWUN9AWCShӦ2W89OTP(HUD!DjVi@\ F7¿ÿ^O0;:xYTB}ۗ&t}L:̓ryO,j*8N=RV%"Z) BM?3 |f#|BX0-i5Wě|ao֭[[^?~L$}^H='S=jbvO |D?e]xZ|!jXf}>+WA'ïCs 4͞]%P*Z <`%"0Epu]5OY׸=j\.׳BXfatdDYUDB*"`a'uw&8Ijg 1 Y*@a9Q| L]oiӴGHw4c.V7A5ҨuN/Z;f"7>Q$l nz8ضݲr;fE w*Ăc^s?S!˵TOBniZ@^0`LT :c/SE+ѽ`oF6XySyRf_bSL&Zv:ŧQV m`zV6Rpz\wڵjzVC\|ٵm>K7 Cfq ˲ny$N }!?#H9R$iK`^ᬫ7K ]+$Elh\k0o݆o|2K% p=hKvfY0/^7Ȯr۶JBȆ5##XL@C3o&q6-!"Cc}Ϟ!Nj\9ZEQu@L>idOZtl@fIrmͼ -BȦ"Qz,cSTU-gro@?i@> :/q!IFI8su| ֭[} 7|p\*,p<Z8XXXEpnvQBğƼo'j.Jug}}>v;II•eZ)>IDAT 1ֱ\>3N<ޯn@8<3x`=u%޾K*gp81ЩyBHUf bw!󱙤 0D=zn/ k_g@0/q<أHLO6\Js*#cDXx<sYuQ) !l&əzu7Ku9pqsgC=tٗ2:n?l ff@>D4w{n |>/*WB,9}~9*V &mANA8/4G<DepO,Dp+vqi=̳0 :"L1%^,_k<,?i'tZAW۳C֔'l}Ȇ>ti2.k<= ssx(`#q`&< à1GTLe! J`=*a᳼ *M!aƟ1,O{Z1`0x<ޑ @.s}L㗯(+Ȓ?^ o xOAIje7s/O`> oDq_"HX-dJ9K%UBNd`setZ  qfU p} YA(l4V9$_ӕ|d&!1V3D,I>@5$ \Pۧ  p0Xà PUXöb0:b0 W-;EyQph܀B67qCp]t`0f_bS$I(R ܺrc]1 A|gϿY@<OUh] >{W/WmDa4!$*m7ضFʝ5;-d y]{+"aDD/^"9^-.ma-a&(Bu^8e0 yIdCضyJGoM|j-!UXU@DN9d2`>w0r{}yM׶ ./erz]!ؾBGPpprubX/!Í7\lB>/Բ,ڿQY-d ;S9B*2i AzAuK+#|>ǀZqFr&I!-/9~?UC޺4Mdk˜rt]w=|;7c Җ }O~=C?:!ryϮA`Xu {6L&Wm$odzatdZP(T7d riBfAߏJ8UAJWUAlU <}ۦeK4C =h;áq\d#9BZ  }#"Y)kc̀L51 -`iB|W4C^ki4 b|>Osn,,B0;[{I-0gbEv~=oߨ,1D"h4ZxqNk5U[ A*_ *LMM{48ꫯ~<9:s,xb/1 I#aǘ ag'ҎӹUdHD"4X/}-ݺ|"Jwj˵+'I?D'՚C^桛wM@1˂y"~*_oY$!:jo(Gf_%hڠ mD "}GD2!Cc\aB8lc,Q6 ^c BUUp6Mw4MqJ3?a&:(!hX.8/UB!u\ЩmHRm,ܾYA.?H/:;!$Il C`۷B)WQܹٗݐcnnεyj/ ݻ.,-..v܇Z,Ȳ\s0c?zу>!j?P Hǽ{S}xn&SFizY$\.W5ߺA;# w =[81^sRpI!oJ{\`tۜ tnVޭɫH_gyh4^^u`j+|Sv0=Ƌyܱ/#( EiŠNXH68站?+.I~p?;BHc^񪘭Ȅ-~G.d245zj5M[^P,lgKظkΝ;ٳgvkظp2nA7w/}ƥR)Z%@ P7 | l Fq߄ͩ2 '݄VHB <DdP|0wjGIדjʾ=d{%R(߇nK/_k鬾7"Jut!4Vك^0GIrX VBGg X'[h؃GXxwr9<,ːe>m#!QPy'̃`U\-U&~հ~ !lVwi1G^)L"ۯ]ج mU?X ݒ$AӴb{1cvdl"+}>}٫f믫q# f~G$+Df[U@x' !* [FwvN pK  _肰N( G>(N~>`LhIUEx^DQD"^LZx<l,g Setq#5m;qgo(ݘYYdҫ:n2W{rhH:sߵkW믿?WJgq:2Z|>Wr!;BdL1K%w݇+?(#HSUHXFo{ !8 `\)0ZQ0:o#=| [45R8eH#k"I!qWݫzA* .  V}"ճ1Lq5d䰞I0X #i#i /g rf ORɶmq~x<- ^3ϢQBiEjX8#(VK,,,47\:i@ +W1xD/mõM gƥpciU.kT,Vv0{T&6bYؚG3\zϟ(?N1wE+yxց޾r/BVN+\0qm A G°g_[wneAQ7^0 ض]}ӱ15.)Rh/l߫.!ݹF%f2iz!M|Xt öi҇Z J$[Gm E("Oʷ8^/0 'H=ݑ1]ס:,B6툱o>dTL#c% `X,oBl3x4*>UUqiϷCWw\ @w'QWNo*e=8P dΝ-?6;; .emW^mH's}5Im>ʉ؂!!9SV(3ҥKp/X#CܹM\#e٪zp|]|: ^4;߇K+sD_sg4H$`YM - += tҲ*;LKM5! 8'Uٛ4;I!L_@=ܙ_X5(D$~|>ydY%k177P(T3o E?k D R7תK¨Nd>óg846KPm1q!ťR"e}X$`0c''힉A>峁*˳ 4}bt/e`0XwnXH)ٗK!HeF|[kb:Q,JlKaUU[>0xeٚRKA27/}EIv ys\A tU@K[q !N$|>tuu! Yi"(3K: cYkOҒN ]zn.؊wM!aStfx}xiÈbz4bTL&ik.C"BH%.:[c @ٗ_g?똁cn`ym-ͪ2`)Q78ڿ|wUoo @p ?)M@0@/Bޙ\kޭʟ2t\۔HxN\R}FO}0nH,d;Q.ţ V{d2E.aBށX,h4F Bf8Z+9̣6z:Bޚ>jO9] 6ZL^¾Nӱ1ST|KEW_I8H& gg GKh9 !1ZgEQx}.W%8BzcA6}i>3:/>&"40{d79:a||ٗwmgx~"ڥrTA ST*%(.9b{|7_<X}v /ʎWUäiWzٍYl[z-9(VYI[20ہy<\\ja LRa$IiPUX^I*=&upVS?v*ƽ5m_}UՠWg/B`WW è*CJdYo >xR<ԄIݥo~+񠫫 _.n{"?)u[ 4ݦ#L Y1(R{A0 |8 UE8y"Eі# V6T'*k1YLZwچw<#u^% 8nx{q4ux 0 dYy&uq΋C{XUUQП!4U[.~>8Hm7#?_D /+Lncl [LO@^/Ǜ}u=y7npm=!Wg_\\u Ws `!f_2! ^Ѷ=]-ҹq n/ BJ{, Tto܂z @^! |TܗNkq'T`>1X}Im<;!VSA/﫳{'u iz{{]|ku|%BͲ(& 4LU^a/#mwI aWo[1sT*&%GQ~b1b1~(pH/=^|:6'1`bZ[]HED"Y* yAz?*\WI }z~S@F 솭:V tnߎ}q/xFDIp +.|&0G^$G!d=1;g@1D,I+\Yogֶ:#HbYlvSZ8g[)X׋9/~Aү_`\z0 jױ\^XcvNE^5 !dUdi+* CʍA}X`!2Vj񁶜sd2jI8W WH+܃)>.c^*!JQA(fXK2 (724+Z0E?lK3d PxLw8ΜW a! Be$f6WkS"PI/My 8 Ӏ$\y,C%\DqY!2~1Ki^t `MSpU7'! !1M1^||a]W<ƶ9.l@> TqPA4Ms_t+@[9ȕ+W ׶XZgSHuk" լ A3Ŷ!Զ6 !d}faCh+H_^8zB6DpoԟdYxުω˳8Rk\]u7l<+߅ CxǨ kpL&T*E(R Կ ݃`!pAJO̦(QXoS! lAV/ ` `$grTH 1ZG+1VޭHn@H$xe`NL{O=uZu9$I%ԕL&aY~E8 3O@!mDhW|LߏD"0e!ͺϿ|ۦ2d,yUq[.ke+UU!I_L_?DuLKf1 _}UՀ3W p B.7njrݾ)MFZoE_| 2BHs84Bittspܽ0)Y6aGa 2LU |K xHYA61^D w&Lٳ]*q˲H$h c @4(FCagp B6zY?8#0( ) =HHj0 ;c I%%$!`qq5䝫^>{C4* YL< NEy/ 1[D=>1 !q6.fȬ}*dYr9ZG,ZP(T9ǀhL !F90(zWHR48t¾=;wnH9m,P m2uil }kۗ7ӕ{ǡu,G2-_ r}'[BȦU+”xTNppH*L 7!=͗}T,G{ Y1n2?wrsii # CQ5L""a#ðB!?lAG^? ֳ/0! ŊA||&|򤪤 BH&m_җluBAWSsYD)_t#q?N@kQx>a~7_ϮZ6(M~|>ydَ<"xxg !A] sly_H}$app/n܍B &yÔd21>–@ {Df1W^T`&D1z$I*++6: [ `0Ry)|Sx o8S8 իZ "RԆ^+i_c_ ]2ZC:kOpX<BJb;GQv4bXmd1MӠiZ1KH6gf68`EwDQv4O!ݜU>EQZ4t]/η&XWBطٗN^,/nk%@B0]uzKfY\\ę3g\\.|>@͈j/۹v!m) !dc+O0{,̈́pEN=aiZ/%QMdžIB3_U!G&kfT\~͊A sR)q !u)ߏX,h4 Ϸ >E'8r8?}[1grR76}ydg{ V_/:1V{" 9C !Te%\! =kpz+Fu~~r.!Hcaaac^BHcOc^JnV qǻYV1l;-M{pzeC-ds?55r@lƗ_~Y5x+,օ XJ0y<5zVh/Bl1v+AʶJUUv`(3ǀ+Wǫږ7d ?s]K- mjm''F3_—A;baH$m*)@IT\& iYFOO8,_F|ySżg/PY~Ǝ7QCUUa,,,PPV*AkAЇ;Ifg+z Z{1%ny׉10dh_JR, @f _i2 #gn*B٤~3_(f%~?}&Sq `f_;iB{oRr.жo+{=􊢈[6={ m=3W=}~Tf}FےrrN!2 mG"+mLJnNjN_6MHsb[˩BKn@E|ut!9$)׋h4h4 ׻  (G}8Qt?gz j,)R1=9AqbܫLĢ>Rx.咄б8׼jYDh8ycV*ewB)BZF@= ;B $[':vOħ8{i(P(X,qIA.(KO<*(c!lu؈ioTt˗MVM*ewUEW=°g=?::rϞ=͛7]roM iA==8y<gfv$/QfYZ|)Pڿ?FDED" C@,]R !["OpA5:ߑ8v2V{χX,V5i_ibnnfeEUqGtU)I S;Ρ֢vN]/7o7ޙMqg]<:,%æ Arg× K7fY0??twWsDUU@J_`Rp >S'wC!" `} mCNgb,/ua^ < ۹]5e! ?iD@YuWE=?;A{akUAc!j~֗[FD"A {g{T|!S !7_מce&)yբ[Ϟ@[dT O9 76Q]JOL' }.ΝZM`g0_LN%aj50͈.3Ցf_.!4_Umf_srнLNNA{l\ŷRM4ʆ$JUed3\-Zg CxG =[lsyz! 5Mi5kدg#㣰lAG^!/`f}C0{Ӎø]!ID/lW%Us`#0#| _[! x ZO,# #"Pqα˲42 M}f.!ֱrpвT:fa&)>g<wkMYs RMwG `<:ղ|nrm{#_+VT605hVsec?>􁔕RǛ}:PFaW@(zJŁ wWj.>NAL @8}fzm~kظrw x* SM$]<g)=qNARlBH 鬌 ($ m3cX~X],[Q+I.J/_)R B66;gCrkgq_l+}fYQ zE^hhԵg58NBػ*HcD,h7. =h(EQDh~)1H~?aoz[= @>:O1#J+fwXFt/hs\x|ŠsQX谁B@}ǯV} ٬tq U*٬Z>dً/=HtOO#jسeut/… U_^ (DRݻxCD&*0 VB۽Ц}X'. S0=~p_s %a0륞f m 1{Sǁu,~rmc~~Jt(UU*DQYt؂:9a{! tYFق}8+ {QxktU$IB$ZjeqV,r&Bg=!!B_sg{]kr'ݻq@ p8c #! vT, xm=y4(0B_0L#f_ކɝ6wVY3Y\J@9<HV @({UUSdvvׯ_wm)!Y~p69@C /Eo|B֮>KP qD"F Fz Ogj;C 6+W˶PVPbU4ǃ?_\92 ٣Èχ.B }{`Wp&"+b޳sރ(CeRqb=>{Ʊ  Qp"2#J?.R !M8=aG7leWVW 84DQB!WK>lF<eYu0?;!d=|*@U;97ͺ}YoAٷoc+`Y֊L4Wڻ R@g"l4ymoqM:%]׮$L5SsX8kt`Ha$NBiDeCיp(011j#$aVz[i5K3^5DNF5N"> OeyW|/gI&ATUE(B,mK)#Oۏ:`!$izGR)؂q>R`ŢyL 1KMW|r,$d*G䤍ՠ'jcv!(NÈ=TUE$A( !mqqYPe|{BHS4mlkc_Vxu&͛dS<+nl ޲z2mb[u+V4Rea._E׶]`V=>9* SMQi {Ģ|su ! ڿSZ~U?.e!FGG]cm ;V` @YAޚIx>Uœ0H y[ )u m  xQ7*0ݛHQe[<EH3a_q7VW.E| }| cb1^8XXXXu <*/ wiYn6E&SZHؼYAZ{8g+ GS16 ߶m[g^_s|A,} |eq- U}z90wEEmz2p~TYDh֥@_?Y,dl tNMa$#< UʧX3\1#LBy~+oB1YѠ]eY8N)Iťtl&8h@eFVK YIE)&-㻻F}+W ۶k`y's0~?d-TLi%wt%%2Z ['QAlۮ9yñ!=xXlk D'p|`!nғW!W04MqWW~b1&|tt>G];(Ù܏==M,lS b޳Xc8u+j%EH?= Qew )Ýt =?n8Ȫe->q ލiV|ީc%S"XooʠBy7œ/h1Yιk0Imo@Jå20Ŷ~VK.}y|!p:VqiZZ'YYo&:+#S٦0dSSS-pBNeYUe}^5ٗSDg ǁ s$IqX"Fz8ѣyV_olACJì}$IXwswT{ / mhPeJ咍W+DV+AB&UC6!y|0jC#8y |5H$BAm"J5Y+!5BS?IYA2kƫ;7Ғ V9Ӗ{`ۑa`/s|78^x Rn5PR5v&I@Q|=)mr&UEmH^QYxՀ3 n\v;n)59NϫBUIss"5Msss,Bqo/< q>8ZI C aQ 2 ehXg >|{u6@>ٗMV0Xg'&]#B`]zC8QYܲP(X,] "%) Hz/$Q_5!5 "r;\.Wl?we,Z.Rqp-]kl +K`^~v4p ,O8sɲLRNC0]8|0 US%B)Vh`> !DQ klװ!lK4hZ-^yX^ ٗ4"3Pꝗ.pvHӈm,]KVA'#pC@NEi}l q\ǺEz%vܴNV1ㅕ/l0-=bQ)/ ZodTXELLL4L&q׶_ .DFoU3MfMN55w턭"6%R)mj7ʸdSSSR2`zt PJ Y]^lSVn @&wq^~sWmq4ئ@;,-tzNKkVr:9a$)* 1`߁sim#՜QiNBH]:lwThaWc>>O1AE,C p=!7 rGBzvVj',˕eBZXheI>e=w1#HegiCމ1 ọֵB!;N'O\7x<֏ l H#0ZOM!2RBAH-at"p9: JQ씕  |36z~,gtEʟ?:O0#&b ;H0 f*0/ rԲ1\3tWyh@-'+HKӞ&idFzldZG[!͛7bU&ٛٳ(IӰV4Wm?VH՞H+k=5!Z|uheȡ ۷ow1po؞(MʲL5$˞U.]*uD''s^Aa !qαŶ|&dk s@? ߑaE9rr}ENB26y13(I"HUE .-6C7P \X` nAtzU~H$`&4 3(&!l* g󻌱Ym": 5O "C#M7R !d묌 Ua&Ii” 10kNl)Nl;䖓kf8TÛSI#9 |^S\+,c&Q@M;eyM ]NuuЉcPF Z)H#K_aUK6܋E}8l]؇G0%N/"00ʕ./ө!F 9G!l#am@BdYF0D,RceY54K3QDByS-c5םdn9o#F;XN׎ck199Kw}͝[/B6Zmۈf"7S]Od !7|NYA]S*gєGϾ.nw-K([F]2066{.={VlfSH\lϟ9|>ߖi{`b[Z; @w^/.\>rV% F  1O bSpOIV0;hH6)1dpA@ꏕ~T&T4k( !ŻBo.8QpV܂SUBcuhPBYZr0QV^P$K!os8M'erp似w@뗇i@k6rl*:=n{@kbb߻~gK|gwN)ITP=;f@JkBFvPA d5î5Q-,ϥHikmLj|ҫRBVv~Orx\ob2?9k cqqcŕgՌ\L#U-6U(aY,чϞ߁ |ୟY  Mf8RDCAHgtE .8B2t :OnŔzUUD(Sb caa f.!dmZ81˦1IZ"`,# 6J6r`y6]؟"<!dM> z}y"m7vVIyX|m+J;Sr&bаkx:\?k7Ap ovCι;WTV/XIi[iE!SlvaeLΝ-$-d֭j9]tqЗ-U/k<,Vl Yvµ]kᣇHT Mp[]> ӉI tبkg2 CH =€|=DTUE(jeTk|L}BGO؈֮BF |ۇh#E~tuu!'HX$*C! i;YAq-dX|m0ݲb|-֚WR2RI Ci&''vOv.?R\3…;w\ s\epyS*Gphj vP8'u!'u !SO<|3Ȳ\Upbmm+.4h)u?* `{v͚Y36#mr7^ n?ů~>lF<LiD" I.Jtj [N52g $:frI`Xx ic+: !%AV";c8 hZH2l((=*f;bBލX!+H ˳O +Thլ M)=vՍnY]('V4Rl kғ'Ob;kxrnmes)EQ5@a*m] !|D%Wx)m۶!U=e˚{]#JUmHۺKHN 9h vf;t&^lsss0Md^X `ЕQ`$㗶oGey).ĽAh4a2ݥ1;w] ꃈ (ROlt7vf.Kۇ#F-FP `?x"3.!4b`U;kd1MUZ,p+jQRh8m78XYW} 7+m8}kחA [\pO&mWMP~E۽NhSpX#BF't>] 4Nz14^?TÔPf(ͺ]yX'38}oL7!>qJ^_=8$ |ڄ$IB @,[LGV>q f_qg"2R0pٽ-[dQz#N賄;BF+sNQ0T3#Ꞡvk0)ctێ`!bbbkgϞuŵBG.uZg2] Q]L 48$!ށA (L dojOzhb{4 uoVV8ҥb[Y}Ry32WNcZ˲0??t $t]G,C0\Qn!݃G#Z[АԶbweKauV h{jf QAhf9iw|vuÑj;9qC! WDQ od2s _h g !d%cRSpOh -33/E8۶lEWA0Xe5}1hI~_,8o@ PfJ/N<ߑ]ABƜ rx ;.Ba/x}6Q0Qk@/(v9nw}w8~VIk!J [Uƿ`BYưjn#a+_o%1"8cR(ۀae6hy#CM9ӧ].] *c16dV|U mK"4R !UvN9GbUe30G.Z"D~y%zO <>VlsAl?ck}6eYY?}^(g/\@x0jt4,WM Ce[4#NTM4f7>>dkif;|K5Mkhٶ];+H:1YzO!9S:Et2gA^1@o> | AAX9ˁ|+=b NĽRd :L$ y+ Fj@ @6Z`H.wLG-tҾn5B18qǃEHd- *`B:<+H.+gVy=!'d=wk $f3vB`ުf.\Plm /n<( \EpN2l1Vb`Ǟpj>aXog'f܃y vZOބ(rm?2 G,mU`4[VE@ղ-ܝf_*@fɜd'Oq˯}6S8H&8|+$(#5:ρ>(C`{J9Ƃg7={aHUEH3X 8UԡC+um-sKA!DBGl =U!\ ؏XC$&XK0P0!tȲ sWV^5ӊ˲L,`Y:m.5. ӌl .\pM Fl6V7U+}~XhmBY^!onjjǑRVet]o(@'m0l:lQ}P# msߟݸ+|eYd2}#$! "44p~8ZiB^b޳ ]0PEOehjT*T*б*S0!Ta~óW,OHB>eMl坸BYb[D ү1 ܺu~N Y/]cW7AjgU}d8۷466!lމA+PFhQ׶pD (ht}Vd\sm06-5Igqg_d+]Q6E<&2BК&"NF8p\RXw|\rRp`N3 TRח:Oi 9a#.pgcy8X-p9t 1NWE`Be;7+eYJ'ɻw}I.M K_%SYY]eaFG]lx?(pR`N׳tǧ|~ߵ-}m)u nJvt2wd,,5aٶ\.W\2lŀ xzmD8s/n.g/ `aaD>gZ(ÈD" QW8apy99CNŜTljYeiƑi{P(DS`r׻B:qt)"pbApI|=ܷS#B+-CލKM(J!T|j^J$BGd*ϔ{%[g)OHc_}R96rYD۵<|/_,/=/]@ڶmJ T@?<4(jadf_*!t b=QiA 2 7(-$guD7U++H@U6X귥ΜTD~~:; c3 sssuHp8p8pYnb]Ra#܏9A$)e!! +-8>:zk{*Q"VvBZq _ugN"al9uC(D"z:J ))B˟2UI8($KYAZeiU m@BY7*C9 Gv;pAV#` !08V'+$I UlVsWFϟ7ޓxa?ǁmo|m IҊeafF]otY+WV'~}͛UŦiLkIcAtUIYc) !kv]AE$qm;02GZ "Toրb qŝD/$'H4@f+ѳXiӶmMHs-F "Nuuaωe 0漇R!!o)}8ۦq^q-:b?e!^]|}>؂*슢 6\ꏼt:d2q)J`BYkUw_'d)Cn_ @0l򢝲XDLodYT*WKγO|+&;W}hxNYENiBHı_ hǎ(n)wr/^Vyg _D'/ΜD4FӮmo/lƵ?ɸt" b|([zjB!hw+eĖ~,?4 giKtw( Nd}8WUm o}T5"80OO]óU.N#w|Ȳp8p8\LRCGt`?%xЦ1=WAf > el߻:+MӠ,V(C6b?D\Udr}+|r#4 bgs Bp "Bۏڶ]Lza4%x"+H$⚋ `,R0!s)~٬I冲nf wi~@l_tehʴ60{nœ?޵{BfZ8ܝ(ڲ,W-NT+aVwW0)uٗJ!6 BAٳgOնɲx3۱2]0 WjlWЍuǸ_"s$k7p_L+MY9 n1x^b1xZ!U1tV&l>AϏ%.Tf9u^t8{{Qj ;bܣ2LC4 ]u !t 8as4KgY?Hn8[k`2HTwgڐӧOV}6;9wk.$>h@C #'u7R !#ҚWZOA }f}}K^/ DQ/+/ =xXk@y 3^O4~zn8+?Sx<^< x"":"8j8?G?(>gZ =`+!d599 u7T;(T ܥaAܢ@; G^Cwؾ}g!PƪuNz1*nQ0!Ca39*Cz@s4.2/nheD¡k$Lo@6իWv2|\*x 1D3EQt "6:K%N0d}E">잁!8_z)}ǷQmHy?wx.*JydYF8F(Z6`{gL[АЦ[B$MK['m1va!Y_ϊ1r8C!IhUznR)d2U2 P0! :;E}sJiҔ;3-<+hl @u 28Xj*"v+Skkeٳm߼) $N%`2LG3ƪJˆFgea;'S1 i@}5ٳ*jigދaF,|I9'uVw~}( HE`HٱWVݻ:vVPa ${#Ҷ ۽L/|>_/cT)XYpBHz F @:?ڶc PO,L"ͮz\1c]= %tOꔇE]dž}o83!|Џv <(JHou]z/_v-={^j_| x !D3=:9ЏcVE8U(H ˭z\1# tM:cԕڍa'Ol|y NiQ&EQt=WߵT*ׯv 9eqG5Q۷׵-m&Ҳ*>0]tUGٽSiAvU*wp<+4˲cma]Efo3_?y{;avvtd}麎X,׻jvQ'33:qΙ29!dAUw%#%J²ݻ0j}U1WxBχa\Q?>F Be|>qɥ`m8NE!N2sW`\GSF w9vL8~ŽkA.]**8k,m7ʬ|zhL/9lBcѶ-O&d~LLL2mPxQVCBZ.ޭ`y=]4zO Q`{iu!ɽ޾}QQ)!;Zs=9#cN D"x|v,?uKRk V٧jŴ`!W:XB!nCf_ 4;wDܽc|1>0: 8 ͮ)3a~ : <|:6N.n7жվ! @6=Z9dY:YF@BHчlD 'ߞڊp֒$!P&u9|C $4pVBY:CWP_r  ybK_5; &OY~ rk%XrԾwu|>>VDw,9J!%tD/oN:4 Ӯm b;{*\.x<ۮRsl6x{k) 29Ad>Ф%!KNg 0jSP@Ϥo`5;ۧql {*H$BޱKMY !d 9N}uPbyy 7u,sA*j9;zӧmOo>(5^l ^XVN5BiQ1e&dm۶*['TDQlHҞ<b؊'Q>q6׾܃ hq"p&.qU]F H,<:BHz~,c]hŢ:!S_/""eo|l<:\SpSyBH{Ĭik< aՔDܳ m6uB6]|[ p$Ie(  B!Iډn8Bu:.~xuwVBc t?# ξvqX߰｡B6LYAXPӱE"uYK<^aswKe`K/;st:X8h! B⁹>&d#LMMUu]\kF4!B$aB!b "CrcQg, i+fql;VhZ5J !oЯauv⣭[3dY,`c'"t&?8lNR rvP܆}ߍ YXt-d"Zvިl ߽lg];=(UiF}*>#F(QsΪƊ`GMhAFʀ.c >޻#9R@^5] !)ʞ ֙A-NA!&%篪 <:1ǃp8L!˲ꢝ+=!M}bԏ h2 l R{lh O$\P3] pD ^wFw~ Ϟ=ëWmab;sReS6Ԍh+ep2$Fgi e!M699Yym_*7>VVE,[qaZV4R~dy!l IBږ)z)q.! ]C> Ϊ&}rEEQDzuF3M3M=#vzڟ\Ʋb\ {!wA~7~4+6{F{=T.܃ڒ$S7ŋw7oAp5$8Jg2US3]!IvQ5Z HTB6.d;W Ԏ!)A]1we{eYnh9hh4 W7hp1|:6S'`3=R'0oIL^iM ^g$Ul[2"?P$ID"t_{Ll(39IQ1BHa>6k _z35nA/-fkR8&e?]l q'O`vvNyd>/.]Fxq::cj*0T|S‡BFm(#i1׶-0h)(g W|'d=ɲp8`0Xwc`SF],n,3 h"SJ[|pcj y4 !4Fcv0Ts>hx\ p8֫7aX\\\"ھi Phs `E9.9`^S].%,&%*Q%lD{ ,X䜁0鄏L9}NOO_U['=Ox>#Д-3B/d[4Xhҿg26çvm$IH$ͣjL&3y_} .%"oI }{/jzՎ(O94$kvz6KS "Z[dɼ>ӧO166V}[}VC4MJvmm(#@zvU@.QǓ(tm֬Yt:mۗ \95۽ wp+$IB$AoooӒD2C0],h ʾo"ra-I@A[0S L&"޿*[ !9%q(*}H$D"Z*3? pAe94"58Y.Zm*iF͛?߂X&'&#^:C0Oe# EQBr$1񞪣cVڎ ^ (w\$k}DD4ϺᛯYH7pǾ#6T#t~, zzz-EAm=#l=@!BbQ3@`F"DG^sOq4# "J92oT*Ӟcx='"ا5rVJRt8,7R*Z3X;$ ²1whpp)׷܅50 9<~fbXRMD #>ϮX4m7Af۾"ډɼy~iNH$(]}%A&vδBzH ˍ{h" $V?<(9o-[dYGTBXB~}GDޠ8'Kj+J6?d0Azg^ Y0`$ocYl  SJb;^(v=ikLɇuof4 ="{:&}Fؽ|EX,k:YO4 H N7]p,Ǿ>u)nXdjjjHDDHS+J8tu$I-#imٳ>߂H͜=JD5i{|jƎb~ fmn;FD4ApDw4  ~?Հw3ZQ=ҿ;~=+E'gfI0R0k``V+kzSߺ ri3FzY$q $۶Է us,-jlfBQݻױ7Y6v,͚(H&H&Ӗ7F&2W3LXAD4:p0#K5Loct(*ӡPd}HL&IIU0Ͳ D]5 $ɳ4M%^TDK@{ Ȫ=|1 Ñ ƒD@)q!J7gQ5%k돫j/jJݷJDDրfm͚5[;oΝɲ14#kYK> %H_H*GMM&I 98a'"jF񿖄8f M28!gGѧ_ɐ:D8v(j5+H=ςH3/NA1{G_:i۞0<@\oW %K6۰j3h4hpnQH(־Ǖhqk>ف|P8p[`mk=!Kz`0p>o20QV}oF#Q7F@q('"73眀UY^h2躎[n]lNe\)mǻ9sԕ|ys}!{7[9Kw `FZl4֭Hּ߳!xܳ>zHtz20>_XГXd 0%OFDԄ3$s<$X(GDDk{{>||Q~R)~~ ]בdo&vLk7lYA&Dü/ȷ\,b :մQ+M.K2%M""jA:47A۞={lApxzPUh1d( 4}$Ij{rvdB;ˑhF֌ >fiKØl75.`d-zzD\>}>R ?ifӞSsȏ;0L$y5Dz@~%ϳ0 Y{JNb$D3R ]q۾A6'"JWrA@bc҈+CfE( bΝw?66VK%b h[FcЗNB`F#PU{flDD1j6ŕЭ":wb?xf5ځ^c ju`7( "H2O|<׾XYdZ l6*trF㲠H4i5300t0`٧۵[P}+ t]o$=BO%AٷݷJDD- @7oF<[3UfՎñXi]Je$Ii|q#B(2 e FK| 'ZGil3#Q~`QaS>=pn2dT*_Q_Qg:aK-yՊJF4,7,YA%{l.>y ٘ k5\؎vEmD ʈ"VzY""$yu!quYq!C;6Cmm,?Ea.*a1r=78JD-b@!+ԼlKf!"j-Y2eYD;jk̏bRiί՛+۶wayk kj&? |Z_й ,(˖ Iꤽ /^@>oB`|p*v6vUZl ;Ha&2T^ԔdoZ 3X?-DflٲeXnm_B|M};g7R?P(,#y[ f\߯^Ga )Wa<!"j- SR l{MD ]@v0"l&yT*iO~Xߏ~hJ/dikIMJð=6K;@"eWV?{|Ό Lf!Ysg㈨m7L <0#Ȃn9Ash ?ueĎ}јˡ@p/N-41>>>WWsLW&iuD^e#H۩ATUר~IA! ߷O^>\!&n / ~{-mfY.DH*}DD&ք R7s:E$={lbkI|>>-b`p /{z0N!$hQXKÀAZn0y?h1&@A|tΗLLN3 Ӷ9A?~GQg:Myߛ*p%/Y~_SD [&TUt l^Le{ts6`0޲]򯪯&%"n1,!0fiL6mBoomu`#3}hu;\4E"hͦMrὨ)V Bff{uYSk]uA{u_[ p#4mw!?ݰ@:&YA~'{jTGfPk/L wҩ` 2H<ՈdǨV[o_B'6LSI"c.eS[9Q40$"IpȖ6"xۺojKgO$ dҵ=?i`WMd=!}DDl mȪSvE!"jAsY$1j5d٦G$ ?Gg.&nsL0@+ rlN5DoC$׸0w޵m?X0]mA#ݤY6[6շ.+Y?<!H4[^d۶mۼd9|)DyF[xW0`aQti]p4CN mg۞&c]l-,yOD bn݌V7 jPV/?00a'%@>S bN5 َLm+[אS;^l n?w&Rrv&G87) Cԉv؁xiG@[Y\p3 u""1XW-F[ 3-3lلVtLNMf$B)?9\hv^س7o/ StbFIlai!XK0@ܟ0PixoE(rԃ]͂#ACNc{@߰DLx*u""Y3,4wVhs  BPv}~jCkRFeOf3v7.NIz*9ZOFl6WcCK/lws6Z@t9c""`͠Ѥ6L'Q"Ma#ᆌ|hԳƽ`2h g+1EBSsy"#5F@N\ )K(K-.)MAer9ۤ?1>4-b{uO/ Z?KynĂ@N[*ۃ"{6f7X<|ž \.miYe |$"Ft |ڵ˖eOd|u<{VX+P(42]K"Qw+wÔ꓈aA:q lrGt9.&"ZlfقR)\͎Li[d\`2-"ZRBc{XA>@@g'N,aIgLWOYjǏ׷3# gl1H4c6MV- lM+!eGٶt%~&0+"*ɤ%"6lvl+  +>"\2X |""Z3lۂpey4=4dG+2q{; >s BD @]2,,Ȗ) T{L=A< (l BDDN<ܙm-"7t;w۷s34?^],3+"jA$c۷A_Q}_>Ev6ѬȎ06uk K-Z3m[EQ4MC.kz>%xhqڧ7Sy<14tzz2x[B.v6ќhAb2n4 Ѣ7`e`?R(PV]~ȏ"#m'zFJ[Y:Zd@p2biuׅ o?{vnTIf@v[T^h DDWuD"ݻw׷Yƺw*0[tA d~#HȆ.im͙Pm: A:D0ȒiA``0`f_YI0V"Zle>Kh/u޷|!$;8-SN b(@_G[Mu &7ޕJvm]ٲimѢa*{AțlقޥBu|UU=*` foCaMddCPU{}DDEn, #dtYcv;^g! !;LiE? xkR:>lZa ʛ7|ͩNX'dp4d;w k6\ cl=:vn7gqnR-.s'Maw|s ]n ,c >s LybJhYB9?@ow75ݷMD$0 m6h2#QGI0m!Pڽ Hu΀ff2L1֯iC"YK )cT+Mh'VMٲ*'$=2~%$ŋ+!{b- dl 5M""ZT-#HhaDQ۷^޻q/v+IL&]@>D(=/$Toȳ( @600&"4ɣm}M3#! N4r9c-G ӈsA|>kyNV3_N K%޽{4P~5T?V{!rܑ݇eٵƻ5Hٷ5W1,];:6л1,۲PD"`0БCm!)Ȅv$}DD1#P4͎\ IL DD)iC G%?s{T*($ i%bhا7ZykFkhy Hњ;@%CH*A{B,55M@}'͉_d޳f_^!5LYIF1=LDD!y((ڦyՉm/f"?޾kwZi$#-{$dCۡ)_hAժm@_c֭+uߘ6>c( 6̤ D8l2LDs{m0&|ȵ}N$ɶPL >gfy-gls1˹Jkg)y83[YW"jǏH!I:A]Ek{,ˈǝiԕ.1yD6{K;[}gDD^䯘{\ YcG4*ifli c%3)v7i{-#0Pb]RbG]!Kra&D{շo} Y~|fb_$"EIr}UӅ~tZ.MpqdY݃T&ͿP(:غFl_T-CɿݷKD4oTؗo5sm2#Q[foX'a@eR)|HL&:wW`Ϛfa$I\Vk^el@=&#6TĞD$״ȍ={f x15/jڕDfOe)WAHLMFDDNcӼNk{52 'O3)Rw.\dr<'P6oov*ѼR\A>y@s"L}oI0)cf0͇bY~EQJQ9 U@dñD2h ׷>x:\nԪmMӺ2,Bl %?Ć0.ܹsx?~I0xW Z<[LjoԷM+Lj{3H/^c0\BD*F8zH%q`~>Db@rYЇQmDUUOV PZ}W d{A<4@k6|s|]s֡fbl DD4-VXTb8"t 0فG N",bԔwFF VCչ\hSM_|A[+Wһ2~`ׇ[6qx @<ow|>@ IC~0䒈i4}/ei2i}jm N HDUmzBL R ONewdf*J_Sel eJI륉y'ÝyYm-"7o۷]]zӸcIhfT44Ms|IUV,j@%{"AZqLmX2Yk@]k+UP(h4:C6Ft[!l4M†Nb  }֖42!TZc!k2ؽ{l쫩l ҽXe6)l 2Jv&-v.%^6]G ʕ+Ǯ轇2FD[6ivvr9ϙѯ!QkLj=%70 n` 7Q=+S 76mc$A0lw4f]ˀw_ ΢dVybk Hُ[--)ecLu<|\׷޼]zv@V8ͨqJ ӽzP'yΝ;zg@Y\ٳJ%Z#ɸ%3}@@Ft`~"l~c̶bm0 %. X~L@/prȋԤ߈T{`9ǡb1WPp@7A?*LDe{$*}t:k ȸeaN &#$IePA >gcc ? L{b/^})>4ml QjmQGΨ`97oӮo^.|ٞ=Ou*ZZ |ޱ/ ] Rkv3IBG@ool%tžF=]}"n3]i'U$ dҶfX,.% Q{l՛/2RVk Ȱ U%JHX 8q^~;5p}v¨ꚢ͚ [SV}'""Z^ KA󌎎ĉ5߾˛w!~ N)k^RuSidsY@tɉR"<ڋFǷo;qADDZc EԖ,c'a$HQ$vzGjV>לּ'α4g 0xgQB@ˀl 6F K %}m(dmj`eEcRq%fo˖I[GVvV .(I^ q:~ΌrT*Ȝ: 4JW DD# ae}[|&E* ,4KI !"v@[GaG<ow4\?^k#+ uMx)#` "5Z;"   En>J#ȣgա! 7md1W-!zi"""b@mqE?~UռFbmH€tN8rij}lkUZ А,D g#N>$&/q:ql O\AJ^lQҦ>cF"۶qF! ! ;NZuJC{k}MATUT)0k ;5ZĴ<>k HTB- u/_XXZVyX4hZ}eF-V&ٳEGM""(4[aM,"I?#EgZÁ!2thmwVRw4 ǏwM/d|oB:ԁsxZ^'7 A9KG}DDYBDȥWV؊ T%"&KN7@D"EQ}YWqIID ga6]`?k H:UY+FA:_6ajH#v#tr9믎sea\eL1 5%&H)l DD4WݕavnF6>0pI:'fGq]3|MӐ}T"뱷] DH:[VAp>"ZTT$a@ǥWfAHcu9]FDDo)0"qc]8ɲd2iQ}ID $*>j«A5kgcg- 1EvA$EvF7 <|^¿71Y5T׷KwW76Ke>ol U륉I^767_&yOƛ7oǞpuHWC4&7MLNT*5e%;wUUgsy( 0]&_$gX?-mF@YzOؖ#A?UvΝ;Ǐօ=ds"ei.i]rd6@~f!"]ADC#y۹s3W n]Ԡ™;w:B`||uj18VgP8sһU>#t2h~Q$K7&ʔgpe49P(@Ӵ9]_c;@wn5c#""Q7 Sq.>,cXڰ; "BԹB4xM?9^lӛz)+xZ[j H[[`FZ\n߾;w8z*d %Wi8GL&`&ǛCnݮ i*^bv_E"ZxS*(^jb&lo4m5! !"f~SsG_ڇOT,YVwVLo/f=2z'ODXWn`KFbT2=T*5}˚ DIBSU""P4"0\rű\W&@ ܼx5~6m҈:S>G6u|r PҥCs|&"U"R#v"}꘦L&u93; f#"vXyF%IB2<LATs˪OD>ej H86fJۮޱ3~n^,[= @ߦMR@hx4pl{SxΝ;?V)+ rw]kf  oT*ӖZ/+) ]*X*,jHn M,Q<řkצ g6ig'"됷/q=<[{(H$8u.bˎSkշC.meV:犢  :oUTKGMIVu[F{KxE͛78}o0S-+2j~=.KlJeOGH4\v/;w`^V^#UD487oG(490 uXb8TO3&4 {d+B_nߏX,6kr㒄`"jfAdG_AZK ~6X>xX,ma~\\33Gi0ktt'NuT W+쯗!k%HggK!1K!嚖Xś?Cy7EKWlQԞ"YYDyFu]ؘ㻍Vc۶ڤڟ&,kF}M`Q>o!Zbtti鶡>0Q*&V@t ɿ"=YhHn RخV/Xh3a||isZ8c;{DD4Sw.R՗X3+B>>_&̥FD,+>'tj&;mq 7:Rқofx|koMLVl nׯjhBDDσI@ʿ؏1#KXď?/j5%ȵ"`9} PPPv2M0ML|k\40>#tµ}">#tĢ5_4uk@fDD4E $Z\nlلQ{9IL&(Jo#TUj5ce %buȲ U-~Aޯ0_n߅M b_/B4.յ$I@06nrUuIo<@4f&{^NnQT*eCé W'VZgϜ59@T,R*066*L|aPGFLD*]j2&>'#5Y pg/^s4o+U*d2ƀfv,LDNBH)!2'K B >>Qklӛ{%+5D+\ĪŁ Yv.f)߼G4; +۾LluPS۶tiql DD4O^;[\J K4Org/CLtPJå3 T*P(깨;躎b ?]KvRמ57$\{@@4Μş>En6b>G6Ů!0QާY" {dhC4mmw]כyà4"jL=R*N{3~4Mj^ra ;:(ݺ'!Dץ$ Hı?%l 0%?*v*yFQ}/pdāpZ0 ~}=ŋiSZWpm*FGG5,=9)'"z'F"دDZs"p ;4 '."74[̂ag[=o|0M iS60pC޼@s۾{Xѕus߶mev&y4͖46J ŋxc/_2#oJl6@4MdYr95\Od @euYhW"YYLR9$NCos2 N[(չ Q* 3,#H;BXtP$Aoi ťY ,˞n  fa1%(cccP=+Ƚxq$1ƫ|T*M*F[Fao)L_DD:s{LsUn߾;~D]4<8Z2K\vsT].mj.]E?FMŋjC}8s"̓ 8KtvY(8OyODDS);˾:Ɇ}~u+M6R DxO3 &1 im q'FX#lD`$ 2~yoC7nšD"ΈZ֭ݷIDD#<1mfFjA\rűNdcP=O^9>k@1&0=Sɟ>n@ e #"Et]b"HL1/(LJ`:Pcģ3#k"mBO([]bu&JZ]CwDb2 d2tzz]JZ;d+GiS_tj ~ߵQ;jj(Z""j--[[&KP ygΜq?>/&&Wq4~5Mc}7bq Wt>JnR1KH"Z}dHDG1H U6eo 1FBr9dY~'uYRu#l/GDD].рo~58;'\КaY?3Jl:(Bd3g_ zթdɥIp>f Ho\. Zy܋ƩLgPd2U~L}ONQW0::,xhil]%Y^h ![(㳽t2 iG~JK'dыA-. Z>8RgΞ V]fTUUzU.GPSSU""^V4 -RǏ;ڵ=Av1@p5&t]g&jrT*C40_!)fu*h @o<µ޵wZ x>u[=q}J„^8Βbˆ4x2߇XCW6 " Rtn>UFD@$φ@70\u\>B ?,^ V_W\lmWy0\yi?Rd {@@Vq4u]c.|3Ml$pRƕ_NC}!ҥK~ DD@Fx]YA. ӎ?U*fXEh!o&"0eW#'kV;΍)7Jӕy,1AKDأ(n[-aqAf`-x<+ ]Deh "Ô|VKt~3oz0 c&Ny z#P6w4u3#6;%"N&_$8oX#aWIH$}ˋMf/>>rGD l>&=[i1mKADUr ꓧsKWm/9VMvp8oQtC=04Μ97o ېu:FΜ} j'! FGG"ŋ0._dL!/ R{ %jŬ ^T*|F_uŋO_T*att5KV z`""6X95(|FEX,Bg v"y@4c^(cs \zN=~(⧓93ntL7$ Pȱ ]Y ev*y԰Yc?Bʕ+{囐DGY\li6-At]raq9qA$LDH/"%uIV#]`ÿ?=\?3Nc/att| rḆBDD&=ۇPUlپSH~R͗]Q\R;>3!}&JFKC`V(B(ixn>(X(F8zY ,;cRU_L #""Z88 /l8I۷m^2}d1/]ƹ=@h1*˨Vbe,_AգG9=bV(AMI\]3j=,>/CdctG'sC&D"QfĜi(DU$bn0< 2㮓A-J=gd;y,Lov?+{LqAC={ /^)q5DmdH7Dg&촁JnbFeĪ ("?}=ŋMcxA J];m>ëĊ6S/hcRǒ}ZMevW,Ş2D-O ^ +g3- :@!P.]'Ut]8bo-|>|>g-]wbjJ̚yDD"/qi[{7S)٫PG8d2 EVattbѵ_V.f"[K^DN5H!Q ŜeϞWq]~"_4!2Uq]k5>Ic }Һ^NYƝ;И<.)BiK󀊊񈨥x4 2~óMI&dff122Q\:ݢY#'a}q@hAHlyOcִLl2#E.É'l,@'&/A[d %$ƚ^Aa_f'+e!Vyt2|F/#fKW3a¼z N_i3l61~t!@l`v0͓ߙ0b >}I/ӎsѨgVJVkm\3+}&%$ID05ĨLeE$@2H^!@ZERAR',#8oKBUiQhlx11]i٪T*8~8թe]/g/CMdSG{Z~n2|>q,YX5k-Ys\znbTT:;P\k H/#ێ)w։81:4 QT*PwB8>Ǜ 42uᇩ?ݻD$IH$$/D͟B4aUfq/Yt. $Zb~E#B!%ʹ\HM7ol @83l躎ǏP( ']\\_wLeYNN 204zzzzW.rQU}D/>T*RccxOx3uJFFFuҸ kڈDDԘWIdvBXUU}ˋt%b*D"d@Y qk@|f 0>/N0K[$".f%4!~gMMO/C.MWܹp # ?fmD$IHRMZ? +4MriK~`"R{t#Qjo.^B| >>Я<?Oϟ9oTU"7Cݧ1DPYyZwJDD^٬\j/qqn(B0l-/jX,OsyD i^S+2r;A$˥t`0E-/CH_{:usgիW}?^0tOΞŋ\.Ǵ(,Gg>~ zEb2LtŶr1Q*;HC5 syJ"ϐ`"BO{PM?={g3WfokfFb""?=a~>i.lsX[X,LU%Vh"4l )iJnX+e m.92Qy}A}]~=@vtb41tWEY$$2c&Y)qhJݷJDD]yF/4xp2ԩSC1R"ML&SPTʱ ໕>;fFR8aK;[r߭5g(HӈD"~4 0f166:P q_@y8%Z= $T{ɀXYDr= Y@˦ =<<11h. pI .˒@"" r&kvpR5yߺDM&C^L-ȳKU xZ(rL[?_$""BPTpI^2?`2!N ~NL&c6mbqgs/v쀱eS}_=z1T'66ibز _lތd(RE-^all luU b/\DEVˢXu=It~^SgY$ʷ.^BP5Tz7~:?zg3CBwX&qo `*>c~c8fh}!Dw3lr8, Cs&˲jՒcDYMV+Ilydi cN24?X jeܸx Q_Ϟ9rd2[H7$ T r.EQ'lxBamb6km[NdWо}X)5Y~&JQ *Ο: qz=k,U"]8πZRkH!ڎ)"j/Ͽg@h9AzUmzDDД@`_ұ?oﶰkf!97ZFJo]FxV8vڴfMq!ݷIDD;A`I., I/^Đ%Ӈf8s*d}bō/ҝ;h>rպ3d8v4Ê? @{?9f, M $;- eYF2D<̊BX,N;FFpݯW&B^ E@Bk,߄ϰ SGǐ?+N;_9gbJc 9Cv)yU#h/"T9FTUe)^*.^OZYA g_\Z)"Y]WDnj/4DD;B?_CP}?] 2QWu|s@H R7}JsVEĵdcGE*e|aM:ǧ-X:y H}bVGO"[0 ZM:BH/!U&ԇw⺦Wi2 @AygȳLDD٢È%{A$IK`2b3r  OiZ V,h20n(k6zJ@ٷjQ7#p/ ݭT*0W/kT~N4rv~[B!$A0o.TCrpib ݻt9o݊%[6CH”}{m*ΓeT ٝZbtt\αmM]Ïׯ#W(|}bc@ ^YĪPM`\,¸|7:?>ăY,T*}(@1=QB5""jW4&6Q^8# J%p#hfiý07`cYH{FSjx›Ѩc `1*X$""T$?#'OD2qo5~}!5(ܲHܿo18vai5]0My%Iz W^Qk%Ut0x&e,#!Ͷj 0(S} &"ϋA},ZZ8(7[ɲ"@b~jj ev*Qw-9'gѝ;wvV 7 +Uܼz ņy&w߀J<w-ZAﲄ>Z6onz> TH͛7㣏>/!P_|z?_ )?=cG,6~u.U+^.}7%#\{pj/J~h kbV?d^EG,pi(,BaQihȦ*A]LDD5iňmDqP(˨jET*!ɧoXED'2CFNg(+?Z@ψbΎ5}  $v&;Az W\ok3Bߕ0M<{~.uT"p $+x(hBd˦A k׮i@0[lذq,#.]03 *t:h2 ddd|5 j?ݸOA}zaJW*]E@~HoxSgiByoN?]_ T*@hQqK\fjÝ?KDD_[ Br݃^8ͦQTc\od U~Qsa=Ar jYFa:]e/0`upP( |pLhqhltGнǠ/~?]oW_ÞAX,\.$IH$m]>”}Xg6,u*>ý\A<!<4Y猩j(˨V3 OF&o_|eK^F4rveT5xѣGYCA do?8d.]GT'={:@tlZ2P(4ͦy4ǁxzOl$a \{$w P瑅m ^U"s ~9 ~|fb&JFGG1>>h14gB (o{M]ǨLuZf~/tQFʕio+v4-h |&ךwDDD%ͰAMׯ_^c{NL&U#A >϶_Ւ%?#ًoB,l27A${bo+W:&qAA'GbKHӎHEb8c@Ȁ0ǏOP4^}5,>(fsJ[}H +I1_č\2j5dY s%*u0m :2j'r9\ä0Q~%3}>po{r+eG:wD]BB4 J [hR-wu"u6T!!/%jjݷJDDD$K& xnܸQ~U`H4/^¸n&2Le/RTʑ-~7+ŶmXv-9Ҳvχ/W\;wlb =v'\9:#?C-mNy3!R ppx)?}4|6°+f#DQS(@n]}C@_j'W0Lsi\.\.;VWu"M 1oI}[Vxe""$(h\dN.^Dcb4EZeE\vW%Td4g\fGx!b.fXѲ@!ɲd2ضm+tU.GPmk0TA!dp̙vV 7 ٳxP.(vժoUUL&A ![$65\c޽*IۇT*sUIƷ죇>$O뛷p[ ׉PU|~tW y ԳҏVAxJڇo)4I1Y [jxCø0Z R *3#r[,""ZmQlĶ_Oq0/9{?Il%_iiVAT DJpJ 4ƅڕ0^y,H|r˗AH*m\=FDDtm~-Z 'Oth3A֧2@J>Py9&NUUR)ǤyBmb9b-ҷ$X~ڵkFqIǤu ǣkw 5`v|ׇo PUyUc@H(ri5#,})6mZE' !B+r2T|KaH\1jYg723QryO 4Ms˔kWy&!wKDDݤw+Ygj މ_0p~ >l\R/{^̣3u1>}/?l/Aic!od[`ȡv*ѬuGC<"BԩSL'._\շ"*Jo|>R)G{a*A8gXb,q~᷿-N8l־ZlcRFquȕ<5x \ˆOߏs"#&B" 0|>o͌C9TꇱΞQ1ˈT R}BŷUBRfq74,§gY?d1`:4ʳgxaP̾ 0QVQT[޲LDD K ?r"~]?~h4>Ep |%Kx%KXa;$4I  Ә CZ?x, Q&W5 ˈ9Xn͠4}[[9i#Or ^~]>xb| AaRAPh/Z#H|x f # pC+mb17?7o؎"!rblz:Esm'EAOO2 WyLRAR 0 7t 7<'O5D`q{Y11!)KQS|R T3(g9[_% x="@VȵLb'c\ݖXtCb|浭+0 !0R\TZ%iJ Ӵ`XKd MZRqYm7k~?bc!˨(WVȍm?^cܹs4;̣')Z\7`]o:rܜ$ Gc,c' i|u`;L&W_!h78<>|h;|/~xA})/ע=G$R)yJv,g BpӅ~f\+Vc0"Ԕ4j5]yj[4ˠP9/_"3: 2qZ rt]eFa+N*V}DDԅzl؃7n܈';ΏF qQ m.1\x=4\MgF,> H8زZ4 C#[%""%i-)A8)-8w\}ks6L|gÚ7Bl65 `еmCaO`*ޥvnן_l⋦e6E$>|xW\q>?Y1<~2j9on7o8$Š*|]t4g]6pSp "𣧯Xm$ aCGMM@~-' Y~L'dA::kd3xV`=ǚ4vD^8` Q w-,%,8vWc'DTUE(B\x[ mEFYBz'"  Øh#hi HePQQXcx1$ du˖A[BR mc}h""]XwwIJ'OaɺwuP3Yrt;VDŽB!\@G dʒef.ן_v-9YnݺX Ov^7/YޣQ\pr}N$p}"BEA6DM|1%JxߋبXaDq|F>#Hug )n`B1>&efiNY>ԡa_c,Z R]Ӵz}i(w\!""ZxMBflΏFT*ױ4ͱOpMQpD;M̑ٳe1Lg2ĭh&@~'Baf2SgQ'nz5;d POBԩSr<2S5qT\TBRi/p8Z@ GzNן߱cv1+V~ɱB7ĕ0U8+xNd&X[il6|>p8P(4mඡ۷޾:IƪTիmʢ!5dhj wBL)n!d YT5(b*C1?Rt(è}l-ȥz=DsT`/v-u_!U[JP,y{QeaŹ>g4}{@"i6Źa h4m~A~+K U$A4lIDATUU4.D~KI%Ç QU{}DDD{;' f7n۷'=yZzo~F4vFD"!Ď}2-_vlw3Yre~sN'Nؘ=π_Q8>O1$=}(HfALDPi0 L cc臄c1DVC[v~}~}1<.G`ar!`!|^YC5f N|ԃ?jt﨣cdȔK40uj*3͑8k@ŷEDDKPa޴ މ/i8?\.3[yr7\tSF4=eKkQ}>A,H pZ r"X[%""zRÖ:|x֛7opvQ;5jWܱ5Mlݷ bag:kH_l8GUU|XbE_{ qY :۸ wQC)Ne1_ ?6,$ pBaOYn /qyW"jI;V`qyHn)i$ Kl;xF(MI [%""z?]k4-eb8* N>m=r:d}ȹ xsl+VqB!C0GBV-[|>|XdI_QU~)p%JKW7!׊P7_nV4r"Z Z ,# ! κ(r x x i+U4`ho"Z/R ZjcE|uV眈ޏiϯa"+` [귋m[z-60rWgíF$Me,PjiYFLSܭ -x<wt9Lh;wIlym ^q[!,e@nU^P(V$IM3yY6mv7ߠ;%7mڄ:uʑգ/W׀(Uۃ.F Z0(d2L?eLDXDXB0k@&d2?R~$c1{{!z{a<ړ4rZj5Z4 V04 ZMCIț2rii4D}:>n562O` es̻1C۹$! Yɭ-mx-KXe&4q$oXҲ@Qi,UeAT ldDoޓ! ;IDD_"p-z=06v'uժK{Ȳd2 ϹH8'~|7iKwӧOv ~wg`BXg 2< kCOO2 t)]Q(P(  <`"VFG'j4*I2w"5Ӏf!P@Y X!^&?Xha}gkW~*#c1~zQ7Ic` Jy*S#  P*خiU&߉hB7:05#=Dњ@6}H$@\@m}2NjC-VbD:^% X4Ocxx׮]okU=dYF*B.cMsFKTi w}O~Lp=5G H5[""" ]6q|vܽzhLݷ(菼Q>6'`&wB^>,@(c5C_!ȆÐs""EN|ӯ`iNV/~wg._lLMg_5߃lӥ<~?kz]bsN|׮e!/]ݟ}1ϝ,FrhBZ"axx]Q}j(Jr0,2@H78 @)سwJDDCpy=[ޓ\3cv#0/$yKX ejH- M x<7|1D"V~- VhJݷKDD4Oi1(~?=oWDcH$d2ɾ躎bq !4MLaV( d2ǑQ.]}\޼m|wZT݈4cXowQpgF"<>@<#P5ty- b ZQ >hD"ZFU_̭FTH'""2$>dFNu=<`-Ϟշ~3Jrݷ J5:#x KlkA|H&~9mwa˖-c!ŇGU}u3>۳k>@ӌ,DBT*r9ahhf(Jjh2@ZETB>d2ETU}um[yDDDIRdf0K|>vr۹ǹp,1f 1M>13Rg *Nϣn (ZEŷݷLDD4ϤH?\o466+WԷs2] /Ttܹ~Vrf4XmvqN(·~D"V,cXd Ξ=$|VH}HBޓ/ qXt:l6u@ht]붾(PU,Ce(x<_Lӄi0 'mxT$ T^)`p-:^C)Y۷aOxް=ZWBD^/e=7@ī9 qy I$~.ر PhklX-m A3hSN3~x15;6$@6$f<wl7x!$+osB;f Xz54N.T<\uy".D[]@0{b~u9%ŧ!b>cZ>xd{Ih4T*5C4hZZjZRVjuaB;Mf }fo&րٓ?^ms-w$dlMfkĬ D4qaUf}HT*U%`2-F۷J(:4&Ѣ200'OԷ Fŋ::3/_~T*yA $ $kvmö+D"|b~9(O'8_!Շ9@Ty"i<~[mhтI~@H U6:Seھs7`y"N7-[j躽4̼S> s( k+an(VX[&""j.1aSdY\x=L ]C3ٲxE,>$bܷqN4w}h4֭[qb6S~!P÷7zd@z$i!""0VjTmKEQG ڊء:poA0GDٔ4Gi@mʛHPqLU?-er}DDD {;kGf0 :ujg/݀lNY,A/4Md2vD"b}JCݷBR~lY8A '7 m8mJ9vf$Yߧ {~d""Z,2KmY(;BGܼ1( @omXO@f K("V\$$Ix:k:ت`n"8g ""T $7dp-{KpgKEdYN  2eIڽ۱>8'gV$2݋oƑ% G!j&?KP}_|z{a a""Z 2ԝ@DDG %)>mR9Yv ND)仱[29E]GMIH$Y3~ Vq"Gׇ\psohLoWm@hpp1o <}jBZ6>x/{z +ovw}Z|r8ٖXwLe*X_ڽ _mk!"v3Mӑ.~ R(Uy+#~9tf2'7zxWֳc~D4W^~$KpicFC$LC.9  LNd|f Uu @ ٿ#1cqܹau.$1HL:UQVQ,L,M۴Uo/=H۲;;b;ϣ@ /tл~v">UZ_ ?l,CDD6͑joU߄K}KϬ Kôhhqy!Y?zJHc_4E"p DvP(tˏ?~ ڂHODDp}̌ i_lܻ :Qp T0 rv,$ jHwb5"[ȦMdҶ? 7 zjGӣ~豜R1DD.n q۶\)A3#")?׷ucB/tܙxW#DmYjk۶cccT*|`0D"DU8n:;u`[ iB ""6l@ofFP}񲾭ۃ=~gH7Ju>'M8$`A/a!A4dYCDIFd$ILD"bXk55lhDWL{w#Cq޽.Lܽv<%ǹOlBڼE"΁ -_O79K~|Mi~)/tV'zG DvkmA0t֯&"iRwf""ZۜzmAcP(ue9>:DMNj7GUzԱy ym0 [&Z1T^S$$ aɒ%HH&b|bFǂܰD6腈uG(3,fbgϞ;uZqb4e[=ZR[`i.W;;QU_}t_J_K ˗/)>|w`/R7@HSÑڏc8h QUt\hA4.H sz+%y؄l4v5ߔ$ʦea7",YWʅD56B}.wFrZv̭djD"@ 0ۧ,|!_ `\-Yl&h`!YyWhi,6 ٝ9shlWm7ifyf" ًov( ,YP| ܹWYW=i\rru v(2ˏaݹh@\F5i3՛@l*(Uʗva"""ʚ8ģa?{G ~3UHHIԾWTUu~n=0`c x`  ` x?l4fnyؽ7W֮ڨw{q""ŤD2Hmkzjݸ9G>Sܹso[lll&8-cgn8GX`Pgg'l*Qs(ˈҾ*,4"gɉHRU8 &"\.Ϸ9t,˂eYR?|Ѷ;g EQ>|[9X.aﾁZ[[B;KXg&!""ȃA-d`Ed2知}GP*Bc)T],NB NV(E3W_s۷qرFr~UQ8}*Pum:mzd5]H&\pR3-p@DDf:?18jø*H'-#*{TdۋbQozuԱnt+PD- ,0B ЄMBU EU*>Tz{҆%XVj6/˲7HK_L,-@?ߗid2=Je\뎴On 裏pF i> tx_t{0};8+G  LfeI""2MaHaY]yY.SFDDͭ3Rc,:΋D"P%PF4Mi ?щh[k nr0c5S0MSQTQ he+EUn4MPUM4`O8+}XhcLWX_K ?<,0?bKdx~$6=&+>AH$|Cg=ކ(0Cq|54oXʕ+8sL_`hh===o{HQ˗d<5a} ~=??ElVIRD"d2;V$""GR +ԍ Tg j"":\"ۡUw* wuaqy%@4m7=AZ?J_siOE1!AjEqfFگ;;䮾n>kK" fXgð!XcJ|+'#"" 8m:1Fc; Cmccwޕ8}ځuھ&qgN85 0T@ꄑJŒF>(r %e"K!""jJ{@ :P~:eoop9v1,jZF4{B`-0L%+_Fw,9ԩSvZ_'O'i!U9R1a$>=ޭ}B$Ituu.+DDDT/g0q[nyŻ$"֕8Èʓ-HW=i-s2ŒhS+", cA)ʒ352T*auutZZk/$,H DOQ3k$ {Q6=g׬Jt: G7abs7/-Ǐ?nˠH$GGx ~')ueNBlTphr??7hN d@-DDGH$bϞ*J!:\t]eYRd!ǰ%""z8{rBď?J}Ahe1:ֈѻ6KcwE8,YW*+=}n"""j6[ $Pp޽{Ҿ'Ry\.t: 4WH%a #W/`󵃃S;T8?uGa+F'SpbB,;Gh4t:#H HtїHȲ,.{cpTj(u͂H"߃b0De"z6eiRٓaXYY5һ* DDD-n~[q۬,7|#f`./~Ĝkt]GU0K& ŋл:aAॳ8}G;wZ*ROW\T}y| p;$8EA*Bgg)BhooH' J5reܼO)m""jnj 6BXƯϫh#Њ Y\{0Mf{2pܸ"Q@r qiI\7'mmjUCea}}їg(qGz=cpd/~$B ŋ̮@0jx } >sCZ(BGG:;;FzbhkkkVZ|+m @!DD'#}g9H$RLpчz[ZSC ,K.X*}\.[HK0Ek~*g[({4ښgI7lJ>lS B/N>4 MꫯZbRğKO][/4wqDQqWG"!Ylx^AMDD/yݻ<&SjDfR+5wE c4}6 X__Jm+ BDDxV V2!ﶗ1kߟhor|ї'EA{{4/b`n|yk$~_lU+RU׮]ïk ᗗ/k0#cAq_^MUUJ!" t]]S'OtC>mIV": Ði03L_ػJDDDEk3a$}}Ҷ_Vi""hj{SuO-dV`]0EEDQ$?pQiN{KbyyVJy4ao|>nY666v]tڳW0Ϟ$~uk(~_quşٟ~ĄtxG7'!zʮHwKܛ|5MC:F\F6MD%fSGa9emsh'O`TBw๣(r;}{jBJE f0$wDDD,t2 ܯ`Dr.H$J@jZA+W]caG?bwAu͋~, SKX2q"Q+ aUܿ_7??blEG&y*w(Lzپ.]j||U*IlWZ4Mí[W_yAdt=_~;v8atvvN"DىȕP|<} g!73?Eվ rHN`6{N&"":P)a,MùXT׊4 /uATQ0yZKYDER'4 !"4Mϒ0?ϼ֪hW-6ۯBї'bgDpE#9Bܹs]]]~ $gg8~Xw G=7SvbZG7kp^+EFQtww#LBQ8G (N} Bϡʦbø ,* 5?~g_~"DD ZyΣGP(rDID@- S} ȶ9G9)]=kmr՚묇:;ǬBDDzZa&XY l &_[Gx4, J}7QD?xkK38[na``/L$?wa|ŧP{wv_x|>VI$5K@~cgKPc}8yfZ~1 SSչBUUD$j~Jhut:hO-`P "榵[0I9ۭVͬyF+ޚ J4 R,Xv|fu$Tӕn) "M>{Ǫ=lX&^=|nǍWα$ad2=y}R(6̭}ŝk<_wQ|'u"Ɵٳg{g&p kԈ} _bC-wHEQ&BP(Ȅ5 C9vw早8#Hg*BsPH^1r?GT$4O_'Q-Qr$8,4SkJ"I{ĝy P -UXVS XW}:""" V( lri}Yo>R ~(~z³$LRTROnؚ]dAɳ:;;_pIz/B9sK&|>6owt9zOMCzD"xTD 9!N qz?c7N&;|jSAx[sjR4Ս t+6%""YꚉqgPh?㏐q4BP ~}-v=3rEgD~uA߷6^lveK4Ӈv)n+!|!, 7|#L 䧦߱[y٧M"@,c\=^ݗ<~ ';z<_W_yDF駟矱 OGbW1&*G1xǟkL;:I r!D *8boDp1Fɓ/֌ptd}$zzz`P,'z\Fu|9r,-3].{ R@їJDD#-m' #0V}tO^i^@"z_A+4{AFuE3A"^ `4h&ksJ{  1]בf}, [ }XN|zup/ чkݻXYYOwi5MB11}tgNx2;7X,X,b\.TD #Kէ:,b{;g`$|~ #a9p1#_fff1-K8arAP3Yj[G)Pئ&":Htu9 8"@]D?'Dz'+g竎fs@ё~04 Q k)}AI97 ǥ}!66R ?X__??p8T*%~j6>~I:GUU@{{{_099w"Hǯ 20?}uߪ(0Ξg06/޼ KFF((J~D%@4E<9SuT(8q֙ӰST#z}BFFF066d2=}[зuqiërlMaȿRa(""j~)Ԋ ~}.3bIDt{dw' ~ ʛAb f (5rԱ`$Q ~z}oV`(fƲ T4 tZ O] ݸ8K`Y$r;O?Eooo߉?~ØQ(TVC;g!7:N4P 0NNWxj~ppa ϣP(pQPUծktzl.3ގ#<09066gzBUQg0MS˭ :B|dwMDDZڄN@-W=P;@+i " WqOt;LT/5KJY_7j ا+\Xv#E@6+ϟciiI͓'PE|wtrܮGQ9.>Dņq7np_!N>D\];. sz=@ea^<>3~.d26 &:lBo8сٳ01όNKhкpfRׇ1 ] oZCR {y\']:V~!"AtFj?i& F$DkAc &9op8V \MsT*᧟~eP^Ke3̡ !N/ 0B[3Ɲ礯={,Ξ=@-JUU?OƳgcBH2//]Zq?񫫗TG0Y;#2?ϥgP: @uyE (x<^sxO7ӧaF#> ՉX gΜSjV{uA|_~C|&LMO┊PsL#""zĘ}DBjhڮ6YkQ=j%p/(;ջP7K5EQ< SV. CDDDƊ {myyҾ&!rkTs1˲(J!H>8 ;v4jŽ^|u':`tt8޾}kᏮ_|n={݅?ůVװ1~*=4MC*i DmG,l2I]tFF3ߗݍ1 Lvӿl>Pgp3 iJ;o@1jLk`bP+Պ4joM %5{;Ahak | l.$cЕخ;8R6 F, ~tsP+Xx6ig9&6M}$ \7m.˿j0_~ Q1>>iX_"0]ÃG/eH4>d66(QDDR BW"ڍP(X,h4ikw-7Sӌ;܇+CP7!0Ξ==~wD8r?i{y7<ιgK9""q`z{W96RiDZwlAss[;FX^,~I#5cu% ODDDpaE411ei7㏡"s,XT}-MwNό&v,W_}"BԬz{{ۋuիWv'Ѷ4~t <{۷Vu0H!Mux9?a{4Q,Q(,PL( (b~٬C8}"N:3g Cro궩{WBasA\\߀^] OfaDDC궑J"iGXЂ ~}^&"{AA3A !,~il K wFiUUN$y.]=;w $́;wsWߏq\~/^ijg 08}?MMb,rNzh?ڏBGOhu>' ! !LK B5+M_u/M!=ЍKǎ!$% w ov{d$ ÀaRhyeMṁ Z"";MJYHn KNLzj09ُ jgx3TB~x)vDW!""`+oҾo_R(l6~/ NKz OOgqo 1{ƍhK 3p.\ٳgKZW(~ε%y/N ?]GR022ۿst>CE4Y-,B?kSK9$Ή)(bFBZį?&XGCױWAbQn_~!nADwDDDP Fl={ +++Ҿ?їO8v;cff>>l 5oTs]}r T*<śo4}߭00ɤ )JMQ/# ԷՖFP/. ! ѣkR~΄#6eX%gf8 @Vhgj sG1Cî1b"j&w~ysLjT}ttt[?,pdLDDD>f٭bY|ej,BU-H$bҾBAKhh?y I&/Zȑ#8rSz f@,3c1<[^k+Vu p ɵ5^5sB* "C!0("H_S`ĢKې<ڍ ǐ=N<$d|0 ˔ IP0)eY(ˈDsW~ZނQ𰺭 ZE?D;~yqA _;ek5ˠ_EwtDDDRK%U@j^&i5Ӳ0q$1Al6{(e(\AF? cUԡP/VN똜ijgϰl?u W)IORJϡP_)g{2X=CB ^>0Pc !G i=θ~qj.>>T;(22%nŔA8R$o^: o\h萉sG*%B@Q@gT\+8#G>b8 A wt3Ut%'$""G7܍ZAhgxϟA)oǕR ?ڿR#4\(B p9 |ݵ<si(VVV011!U I¸=z=Wo eK"ۋi|5>C!mmmubr3M- fˁ9u8O*KXBhpC###8~;w3pVe*heG_'ЇL QsSL5l6A "Z&}ہmZ$bT]͒ Xյ< A(x9&i5+˲JVyd&_O?c;5UUN=38:hF v7nѣGRgg;=(:yE({>4A4Mh/'4;G:1J1S3ؘ_R@J) ѓHħ Xz/J嚕BD"iJ.#\J2Nic8j~Ff(.?1Xϩ( 122CTpm,AT*IAl]TvDDD !Br"*g0vA" rEUD,); rwt9ֿC@DDD$jnRGwQP{}g%{Gv U4d}ٻN ihuEkЄ]ׇ>їOtT%3Nb>%绹 :;γcΡ8; ^F "ݼ6 C 4˽<힪r/ ?0#=pͰyA'1ٻiĉa`$2DIR V\FjɅ{A=IDJAx|ǯ}dVg5;. CDD-4kvZebr[ʣ'xhf2i+J!K -L%]O&sN;NUB i`X/hjks+PpGr)/.b;CUUb1b3u]GR,a( BGӴ+~lK10}%Pg'zqD"8~8FFFўqAU 5+ r ˲v@N:β񳂎ODDMRQhmCD [cRa0{)8nvWQχV=չ%/b0O qj\Z]15+xWǵhM˲p 0!'QOŢh(B{{gO on3sn޼gчJhB~zCR³y,/@_߀) AhCj.1*Vr9ڄRەC Àafh&B `$EG_̓'`K AIwP/CcYP(a?gRx{0rP_MB=i][]HDDGBځA . "[Tp/F$|??xfH͸ RR` AurL˂*L ߿/ϭx`ozȞ+:r\/n"N{~?F!\~Oƙ3g>DwUBr޼y7o`qqP׆`|nv f LH'f (b9ÌcW9div(UB"@Q:B(*S B?8w(Tul/r ;v콫fU햣R*yt3MJEz[CD!&""j^B,4~A{-ZZQk\&Q=?PgD-a3;Wz CDDD,an5lK߇s?vF} Z&i%Mt:i#R>6g_yUG}@Ξ=gϢP(ء}FRtfK+X_@䠔Klmnl d2ȔKX1 `v(/$bYLy~?ONH>s÷ }}}ƱccM Attt,T*IcOE4Mo^o,;?5&w9}DP 'v F|ǫ^WD v3;_R꺵\Y5*j`-Ҿ%`mk))XP 5vL 8M@`&9d_|E;X,3g̙3(ׯ1??Ή &;eW_l1R) mO?& 5 <2tK;^®Qgpd{kB۵5=0`HQ# |Ee =#[ᏐV^?~ǎC4mmFzc0)wazaאq;( y{aZۏ"UC_75_x}AQ 7 H8VB""" `ְuo&VWW+jwzڰO?cn=, lї\x<ѭ)T69v Ha|W9EQ{rlBv*Nw#rKKX^YGi#XW9(0:@Gzz8@堮@/QTPTP4t yDnضaCՐ zo}λ&ptLo?:K:Xi%eRq- fcFR0 gmvm a9YF7ZuADU+bY֡I>UY\6RO9G +j =nMiU*[>Iiߣ@:~^C3 L&=?@eF IDžsRT_B8ɓ'qIT*͛7i*åC!{_00Y66( E(jD= 'sR*A|(a0J%;Yxw(TBP)tv`8zzzpq 3_¬4c_Rx:Y>ksJ@DDt RkD-m{a\ob_A+|I R !""jq67H7eٯr ҙy={їP?g'nMbyir(t:AӠ]0 |u眛7o/>@(qqaBUvVUOwx[o&rX\F&RX*e(F;DHf$tV{1M]0 lu?%i`9v_T_*B!X])֟^H ކՏF"z Fk H3*RdUڛ)Ǫ9a>Tai [X-ԨRęfFuM{'H4M g61 @yf9H쬴ǩI(ͥ_R ߯,DzlӴwwI#,͋rԩS8sL/8v;0077Y,//cuugdReaj.|| b z T 욢 7! 0Dd}u þ?~ts.Jǣ( tt'Og2`yyr(Jd7Do<3- ylMnb0 Àa0 izlg! oJ\1@@@Ua MC4B,A"FL NUc?:;;[~qAkX*JR;k @hf>aXVA症Cŝv~)⇽DkYԚ a:uY>( Z,f@7{,LDDD!V:f(ZDRBG<Ο?K>PeݻҾc}r{JeO?hooC\0-;wu%I$I Ku]G>!\x;Q!ָtvvtrA v@5p Hk[&35#yx""**4x~ Ik}Dy @*V6Í ^I$ &Q0 iBuh)™BV7 o1]\\i-U ŋX__3(栏9a{< 0D<_wu9rїODiHRHR5)v0T*\.C H$D"xxUqA,rܘJDDD$sMP}fVJ7rgCib.{{#{YB7ݳh Jf4/Οa| mrAt0y R$mg3,c.* nŷ"H/,/ޱ4aۍcu p,vٛ <},˲4Ǧsg`G[Y;dOXؕ+vU7.] '""K(Hhm/4579O]_ "":<}SvU RįPZsv!A0HAxiDH~k0DDDJ+ t ЗqxX{5'l_4}FyK}:| zW'@Õc\|їODDd1z""j[yOXQB*lD-FE 繗RwwQgEfuvk&09qqeC:4M,..6r2^~-y5bf)X6m%S*J@ vIKܺu ( HDDԪLt m"m)e(_xP IeE9AjW!V3((ߞ>.mg%䧫t6 tfH$g3gĈt͛7'"":t&kaCi`TP\GخR,kWlo^;i|Ǎ|""C)N‚U k QxaxϏ ښ|/ZLiZ 2fKF_5 >νx*s/qA vXB1MAjbvvVv5axlkj dӠGv0˿?uDDDT?wDAr͞^:9O-d`U"":8[9.-{ |CDtaY[$9v^ T/9ڱ;ĉHnWq6r39Aqi۰LdG<~L\xDUB?#Xm=*/G!N7򉈈5Oĵ4L\dJ%ý̆gYm|g"":uj9'hA. C*?A-s켖JyAȏ"HnJP@^9Mo$arrR+(Fܜt~QTʳNo/>ɍǏcttїODDt蹃 "Z(9 9l0ySWP^DDtL@)˒6@AY&]v?Oqv[;(AwEhѱuMȗϥaȣ 5KyѣGduKLmՁu)KR)\ KShW+֭[t""@p,:CV` <';DD *%vЪBj- cF E5zo{cWAF@WAWrl,TK Ϲ*HTϥ}wg@Tg~~܌@b"@GjO.ۊΝ;B|""@AAkAr2 KUWXWw| ` 篝EHipܹF_:Qx fuptk0j.RuUTXZwqsN nB:j- )  HUa^;߉qrE٬DDD{p8Kwoyf~]ffܺ<3hkmYVA't\Do^ǏX{G<ǧ~K'"" ˲<ĄYIk:Y, >aXcU""GJA(y1\K"H_ e&^&"H3ULG{j zǒ߀a YGI6V '~eB̡PmmmҾ3/jZ4>=u>.g}{ȟ;XZ1 qD!?~ mj{2>)-*<蹑Iۆa4U~5ԪeaoEkz||h gDqE[0DDD3!DqA^:9!,/s0ȹ:2?:f4S5!=?޽YTButҥK8rH/(pAL(mW*` 4MEaXKq;ķ x7V!jMB`J7eY!":GciJA? m*E:]8,{ R! kma1tbSGۑHgf  ,kZBGGzzz|},=y9WX&5CEDDe:M BOIlDֲ0@p jB?KJ. CDDD,Fp8Nl~, Y d%TVgY##Y:8E]a%6=ǝ~)b1lKDD_A%y hV Z $HH04>V$r ښdV!"=gey2Li[*(K%8GZŸߞT*Mc GWa*F6մH%sNЫ8o'-֠rY KKKXXX95@cxT]"R)O)cqFzڞ=w}DDD] f0((JG{{Y+J `Ϲ2W;EDD#;&jF H;?^ZB^RjA]$Ns*= 75 CbAt]o ͔}t;l,@JlZ'zeK,O? QuI.\zїNDDx HY;Jqd'xɤcU)/xO[lDDJ60MrU { !j T7KBx*Gz_]8ci& !U vyw"""ڝa?nzoW"bk~hccSSSҾ_bV;1ڏ:AUU$Iy41̘}< Ν; """{B"d[1R/TїTŢwpsLeѡd ,ĠAܡUAZCviP H뽟P/ ?Z XǎyjiwgMs(Ͷ<B6- om$^o7Mbї `s`!Y,%o\'hkkkwEQDTt8[-( Tu犻q˲|C?CuHϭ*}}MZujA x+4 T*+fAcuܟ^F>K#""&Rc36{^u#coO) xꕴ里I(z5դ87E;5Hx~N) kW#gGMۣn wpTQ JAvK[[[]VQ(<ь*z DDA}\󙌴mYV` 8M'DD 5 {}OO3m:tK85DDDԬLTJ>"H/s_! `oK]]XXh<~aH޾ksxln5iDBn',իLWD"7n4҉ZrA Y( `UZ~\[RfU""7rC:^r?JPC D聪¨q,({xW=߮ @"ٳ"ZuyxWʊX_x[qo0011!{8? f_4!=BHL-;W%an߾DDDܝ[9ҫ_|KWѨrg_@}~aXs%"CdU3p9]DAwF5 U?Bx1>9w &~XޡV ㊢xWAx,0\/_ L=k8 @w+ Rг*Hc\6 "! !09u, -BDDDuno==b(؏߮I}38r2 }O_ۏEE}GzPTJ)3f,;gI_sW!""jFNB4!jG/Z)"- 㳤Pp6U*rY*R9#e6nx+p(j A O';A,n!Koi""""V89A^LͲaX\\S爫 i{.jogȉ6ݖ~n޸ Cooo߃{َL(mW 94NdqWGkuYYeX> (krPyZ/o~et>.~DDD ɻKZ-(b1YK%?NQDj,Ӫr >gU""WY,LO], 8!! )E`F HuImCBںG7_wP/ |\WIDDDYs{]w/]Lyw{(re5m?6RI Hݍq&`AlwL[x:/0: i"r\xǦi6S#JJ7Vó$۷$ Qp!ʥuSq'vJeA3 eeE9UAd[U_0 }݈_mbx3Q&H3W[Fj kWzy0'oȟ`(Q{X<9'W*;laLVWs:siŋi{1åX,6ln,,#tkhF[n\9'x"|#"""e` f *8TR;4zM jTFrVL?y/,+&"fe-m4ܫU*aAY( 5n/VIZG;AM7DDDTZ]&9˲PTg.//ۏ |>94w}ܳ箣"H_~gQiA6SI{? ;-]g`=YKFdz(I$,˷ $]+T]%:pCj .\hȵQmYuu njb~IMVU/_z ڿ2vzJ""jEjILM{kj a5z"Z]G4 ѻjXA  77ǢQ T*x^{YW/厌vTjȀL<R!'/]P;ko !pmoa(҆+p*A!4RoD{eucB.Lh/]aT7DDDneя#j(Msi@l5et~.5{;S.Z6UYF}#Q ךi]DI=66t:}JDDDT̴,] 9.Heb$,G@6kWq PLۋҹzaU;OաH$!]ޅjeh4˗/u3y֬CѲg[Gݲ{x|>? ٯn!X穉(ԲٱVi nDfUL)-垔Nw4wMB,(hvOGsNЃ aHay$ ܥ}IY뺎Ii_fN:k$""qWɻ!G Ι:jBW{|޷}:lֳc0 JDj6W!,9lys^#&43DjU Z58P PA+~oZ0Q+0%ČOᮗjYցWQm$UU!w[F* T AAN -A/ueGU#Hї,˒ГlEQrX,bQ}eLOOKǢ\GH$jX(}bm #WU @kjA?{ߵ\.ʲti8o\cn[[[_rSsfg \LU#" (Ҿ>U*JEw;j DtOxU*U@rA `}|5j#u/ Ǜh$""WVnX! 'oCՖ)O/eGzZ<~aUrS Rt0mmmR;0 q "":dAA 7AeYf<ՕU_p4QJ5Yᠫ6gtՈZIQOkT ڲ0yDDt0̒5&xOT4j3pWeEy rJdOX h8Dk8S|DDDԔjuyXxЃ ~nP(ia0G@(jv0My'Ƶpܘ /_%~͔KpN(*;[%A=|^_UAj {߳_m sUAd &Qs9\{+ -^j qQ^?Q+[i`-sPXdž/xI,ùi5q 0DDDZT9ڏ9!|ę6X&Yy<9%m?]BrVK8~#{{mGv:ɓ'hogeJrcU HeAr5LܪQ$H47r>ܷ%mїLDD{ iW#́=g8nNt=uqێ f$oK&Ap\Z%BP)X:n'JAXXZndPЫQ'ݘw, rYgir@s%T8wZ:ի(5?w{'.:k HrD"W&V}sZaw BDkߩPjP)sfs^Xl6)eagUQZ3r?mj=^;. V!"""PQVWGsF;MӔ Vytax8>5@&հjur 0~FFh zWCG4nobpp@woQj %換&>Qȥ*4}[.C+`d 5B\C8yX DQi^AV= =-w~TB7VE+>HUn/ڱ"s7gok0DDD>t%ST`QZ|Hї ÀWD|&Ƨc x!wT?g8)f^!UH^rTѢ5zJ:ի~]DDDzTJA"r~sTUE,`~---tjjf]ȧi(>m8X (p- A8&&ľ|+400 )ka=ݞA@P 4U .ُ,2̎W(<ũEg!4q-  =UT@7R *vA^iUADa|_\N k,,?V XۇKDD2g9/fFv5iD䮦< B Ǒ<|䛆fȊ DDDj5b4EiA Yv=:2-+bTȮۅ֛έ(H$._Hn;ao˗/urw gD Z{+[>*˲|ؿ_]=rYg&"fPZT,Jgf. v0󙈨YSCJ%pfq_>AG850,2)kc3 m*07/9Q ΈϽ,pVp{^-}zPDBjOHa::ǎK珍!ȵq^-G YgEkZ{,y)\.{%3wUAeb_DD6'τVigZ3[@d5V  'C7K_De"];?"].2LzqITAE{{un~<;;εiWVV&U^As^> |邽m%8wdøpn5)w Yd0J:B9#Y6^:O=窹 VA T(++uܝV_e5kB8B.ᶮNGX}.;WSʹKôƍ:폲Z ;9 - 7c%fixUy䉴f}JZadQT*ȀNp . Qt" QndgeOUAhb|_i.4Ԃ7P]}#-DD#`V". Fܭ,iAsh Ծ}]- lXJIpAeic<ao[=9 &''}եdLJEiԁ @xzBf"ؾ_ wD1zZrUB ìai;_ӧ07euGz1M@A+==B%-˗/sz"",KMLTvk "AAҖ] [666<¿/9۔dr"fCNݽ8\V4 DBw0oQFE ALG-e"a,z.X>@Y&qlls+tVVcJӉ"ԁ:wގ#۽ͷ ""&Kr0$6*AR ou$j|߶6saccó5h ޓ_/8%_)PjeTmn?q Tߒ0f; DsWOUU;L?OY(giq(,"""c(QJuOiVXྟAlCeǧ%a~GdYLOO#Xx!DEW.`b_DDD_S`>[M=y;U$I1ˆ+ 7J A㜨8j}nWA0Vtn[0DDDZ*H[P(tؽV*Yg4\T?w}'=j1ce_X[X,&-s 3vljAD!O;R*YV (NTnEGGx#j%wU;c !PuYΞ};A"[}`2>LE퀵z*Bs v,g &ז|6W)X;{qI@?U ~8}DDDtܝc9&i H#GwWx#,/? `"נgYe Y@wҾOw2 *%ZEeL -LQժ v? EX&?wA7T}ewb>%Tj(#9 jA+ǖwGv7x8T*yX%EQǥ}N$ UU˗gJDDDT!E k^+*\=Ū V(<Oޅ0g(a ޚDDl_ (R/29ϲ,dOkwW~M4;$7DDDZuyА3d%ՙ,J9.JFu@4j /{ͽE~⸽=rnD:ll!""p[  X8m pK7pӋD"-QClllx:'- fֱcU"PW`Z~l62Tw} QZsYUS0ފ +eE"""e~wvV.JRrwsշ131}pTT**#{ɯSkMvt{;… c%""Pt (EX &X余 r\l^,!KQp􉈇xfzǰt]I3ͬVim3VrW%F_ھCЏ{t3' SS DDDt%STcފ< Oiz i%*P͠o/ݱ&U;jЇ.\οpBKzZ'jVF,e+4rimc5fB!DF_bS+r> ''zB" +40J.o}d2܆a51<7oƾ.%(PȾBc @ 868BDDD{Y$9*bi W)u'Q]i?05٭ibX  &Kq]DvMT J5K*W6E"WV0Or),cULL.P~Uڷ]d|rKҾVN= jA>p(h 5 9~Гn[xcEfR78BDDD{1rBL]d7ADE~ Wg9dPֺPqi˗߹-S`TeGصU B 5-q&%k}}3isBoF_1Q,W]-cYVW -6#j%k} =j?u<57ͼ4 #Š DDDGjzmJoʤe7h1!*ʾV BR= gp_: {###q1MS)!R A~?tjRߒ$a`ó O<ֿg8hVfo ]}0 iA>0DOIJ@VFB ڜZ @=}`ױ Vpr"Shtn{g =$S/<xo r|OL~pqW؍kK 1իWޮ%""P̔`j1ҪAfݲcB$]>c)!쿞Ahfֳ J }Ң޲炙9W}z!|g, Q+ӊ{PB!D:` }`;A6WXo^Š DDD?UA"㚦̬D4{-"EZ{)HYTۉH1`hh`xDDDN|Iك w+::j\W,~u2/c!ұ DL"ϊVXhvlxQ,˪ٿjԆL -%j%ߵ0]]^'|#虓~7喣'+^*kcH/:}i rٷt-ax5ѩQkEDDDT, 9GU*Cˁ j^} ! #Ur砯E{*(e`E"""7BZsFAٵ+++m!7F<#J;!pF興g R. i HI;^T{yAVO.m߭Q~[ds"ze` j;B} s-UVS;a0mBD'Uj cT/|@E{] ɓHӍrw,;J,=]YxOhf(jfWERHZȣ.(CrH.EJ 53")jEJh@hkwgGUEF)wN$ndF9Jշ/,A湽l|ԲFCբq v[+W} 8@+-;PFPıw[.CUՖ0Gԋڵ7*(쪏MEF?)qNDDDGAD;Ek0Ve0111J_HB J{)~Q"xS DUUaQHӴHʲ, u._Z,W?,W7K ʘ9\uZ?m߃, i{m\Q znBoٸa6U\A+ 0maz`D?Əu "첋 s+Ah%ܴ6anɤo  tHb$F5z[Bers3e a}#}v(Jzc@Seլau&" 4iTS ]vuJuPU-# |ֲDNi c67N_>䲁GQ*ZZ;&)YV I`w +m5Dvv]T"F5d2'x"aQ@ iL6>k[`mAL&i^0Ċ"Llyexx^}DDm?9PJS'NQcmfK&lȟ,) -ˆ"pͿv^1F`o>?xZ*D-]hƊ DDD$j=48r N*ܓGs5{͡g""" oİm٘72LA F 9)vl0wحERJ :ly^1 λQMTMǻz낦|>TUD:D' ~S!k Dܹݪ ?@J@6*h^-'o{e۶ ,%iEA"=|, {MDDD2F/^ kDt)O:,E"qԙm(KpΜky^Oaw9Q0 T8|iXb϶=XNO\(lNAqz7.k|t`cj=?,heZ|`+ZωXd4W8n7|#V"""Z=}u]gu1 HZ2+&;OiV[4Q*{sr-+#Ce&")5'4>7թ<_ֶF}ZKձ Q/ zث@\lj7o]~_R(PoN[ދuV!""b+IJ3}1-ݲ/l,C9z|Ty.54`{@M""" o5( Ǫ H`56mӶlfj5hrp|w4 {ʞ=orz_펊S0p?W.TUmۢ.+%>eUUyjDV 6npm\?ظZy/ x[4?43"ڻ%""PUA64 Kj w6 i$_xᅠLDDDk`MQX 58Nh-bT*p-hws"W J!Kc6P =ԩ6d7Zm;{A$qwy橥PO~ Wh Hye"""bhc{V$0˫]5Tٷݷe[.aQ zS{\1*3gyYBn#[FF[YgP<3& e(|<.3۷)+ .Vj - QOm0 5v$3},, RCs\-@Μ>IUHkSAW*jynF#q=R?|C&"".1BR]ˢMkE; %P϶|E.\:o#G+"Qoq `5fuU(3+ѴvA-{.BD]U zC[1hc@۲}:A: Zy bE"""Z!R(0F{ᡡc"H \Zv@PU7o zDDD TIa dKB?^|3X4m9Yձ$ OCm#c(ae" {ՂZ/FF֝hYPVzWk7OW"][=Sm5X?_@*xmAtn\5 $C?v@ZVYl۵}۸j zDDD%'m5a es,"e2Y$0PpCsj'( D90Ԓ}Pp]Q,z׋D"!) Q:١-L^wyǎY-y[à邩ۂ iKV!""kc'urAǧ( gث(o0] }j @2 zDDD%+8ӴݫZ+ uDn1L=עzqQ󖔸vxk(b&.0&ԊOu\;F4;A)?%M6Uzw-ox}dm tOEٔ :\< qD9h49ZL&[vpG7G&:}O=d""""-fc Kh[˭afeď"&2Gsj(JmݔN0 a3; bGZ@i)[fiUj ϱ- Q& Ac)xZFI5~BDDD+MzNf !X1!Zz֮)T駟#"""jhE eNoQ^>N\q **J}sAScc"Zԡ78xQ|~ض|>s<ݦ9!VA,˂mf{CU rwFj_Dz+0BDDD+ K[Jݺ}]tۘT*=d"""2aӨaaWiSW cu9\.Ue*˨Vm9=!fH8x(.٭kM rknz}E^/FOp'-*AI KAA]K= DDDl%[I3ٖcx%IV+H{}>,'"%X1F$,w BkYREA. |^s-*J' gG0uDԝ+Uze_;8k-K)aY\Z?aX %moTO/] HS2FL Cah5ڠ8uK~EQYX,M_4ش}\ d׮]A7Rk}uOA3-~_Eój*D_wHZn?h47-i MǠK-EY'9f"mvE` (mWǑB6&'';¢΄d2>ij D=][)eh "]aA.Ro*0 n k9F4*K 'HD`g'dR'ъ'zDDDŚ+XzcHT}Ry>+~?]30W3T*ŀ.v rN6ѺOb&zDԛ2JeLy ǫՖ}eFsKR90uq!p^mѳ{!B5ع׿~ $ j?qMlCDDDE_vsD"-a۶w>޾};dC&"".Mj٧ <[&0;K5|jQ\[׏t]Th \k;4VGuh |MKsxlIE]A MCbE"""Z-TZ˿Eіw&@<=w=(M6=d"""r-AO۳/,w !ڴ zTuykl60,q055PpuW>h٧Xu*0 BDKWbSSm".=Dj-?b'p)oӼRX,%ixҫ^֌Z oV[+HĽ S7/hT)?<+) &]r,9_jzAӚ' h83%6 $oٲ%м-g$ׯ__h'QG@" `wڷGXCZ>cj&'' f̶Mk>:DapWXﷳ!حp+/0 ڷF8pΜśgޫVjY;FtG&nLUmEsh-GQ`g_~v|tqEu11BDDDz=aqi7ҦHC&""50A'"=A^Bei+.'(Pr)CY}앐a6jsDULN䜇j#q0MN8(J yUU:.3v8Ωx-ʶ0[@- 0g\AtJq E׆;X &-[)mN4M0BDDD \DZ  H3l@JL@bo}}}]1? t]d;+x!ϽvZcU ZR8b+U8WF!d"v`|o\0yMyё:bBZϷNma2]#4z{7\贻8PJ%"PTۻEQB_{ۆD8sX]ב2uIHO,V%naqSuc2?bY&''[*̲Gf낱bP L0Q+R1kuB5sݻ+[K)Q* frT?Y7)QhqTCw^D{+]#TjxJ*GDDDj3ZֺaPZ'%b_ulkAUw-?z(!Q{ڿpKGjd=eGh'`jj j:>mte6G1G uIyF<׮\=~hu~A'NZ!4=l Ci~A[V[` HSѨuiE0DDD$GDQntrA50RJb͍qexAh>ފ Nc1_TwI~Ÿ69FrAJ% 70$<p~ZBY[Nh# y] , SSS( B<G*9oG"-G"*mϦi|UP@h 5'/iz YH`Vn)c;s.P:4;::qBAʦ:Hf2H Y ˲09999FZ 4oS#QXO@SP͹ (.^l?'&&P]MisM]Pj.o܋}mak'>Yp %uCE)eKnz BDDD]݆s*kNdU޾:bݾ|؋/fᆈ;Y*1֊ l x1 L3.L~9)B1߾r3m iC^W :ъp1 #Z 8^p m##|ہn!/^ ?P ^Fݽͯj3hDDbOihx>iBwhm8umZFD"yٞp0LwݧT 8w](pΝDDDe*MAgAZ~)>o[t:d2p{NTT`)<8&R1jL`5A䏪*#P͹[hcp4:T*LLL|Qste zDFZs^pt[ɀ"XH5}tC{RE<Q7DyTRzJ<q^sŋ2u#ݳ`!U)XX w@l#嚁RJE x > ~qZPq`ّhp0kUgyh:{8kt8B)XWBAӴ91DaSksss{hPvr07(WpC֥Ks@Vf62_M ^Q/9ivxܭOQf[` k|D>5 (> Qtm~rӦcxWmRV}_/ݺ,iūqll/`Uݺ KGq0n;w.!Qi8 sZXe񥯊6mUݜ󘅖ݧ똘Ou P?~J[(F~{ Px _-8: TCwG'pX JR$9yv\_# J7^o (-{_d,kg"HM iw =BDDDRе ES6H$<+(UANx&k%.]׃2u Al/, O)Ydyis(2\RlԜlG+e9+W;jT,ngF!1[67!, e|A|5 W7V^i$985|$ ?p嚫xrUvr=se@I4XЭa,OIeL%},cν*fNWٶI9*nJo}xȃP'Q@ώz"v6<7N k.DLfcٚa' DaGQc$һHd[ @ۂ^T䢥$Cu+JDDDJl'z{wc}*rݶ|xᢻX5w[_ADDD=98 n5:y!u/Ys/vj* &&&c[/c[&&#qW&0DNxCv! 8W_?o]󖉅9: ]&!yv8G"BࠦgFϿhpk- $`rK7ṰPY#F;o9 {UZ+|]:{ʝ('N҄DDD47okûU%naV kg-0 JlF>,s iPzbqIT(F~BnW<;SVD;8~-1:{ @ B/%h\nFݜ7HD﵈zS^4Y}V 8J}|wKEQHDDDD+ GD֦x!k9&N=@J ccN\(@;K>47mKLt'lFYEa`bbRi d'OvBjzcgIØ0^@ǁu<:t= * 똘` -4x?iZ |U"Uڶ=oN4h3PoOCZ9F$ HɅ @7~B)TTb;gFx<i8UΜu\q{PӉ=d[?Ry@VGR?_5ٙ0VApRN!mDt*ua L"Jͻxz[J~CAhO='k9NHbb78md?DC˫vKE՜^XHHE \*WPXdqTUj|nu >k;Ҟah}D~yKz|_sS#4tCR]Jْ{)ҘNburlXyllBj(J퓵*.T*8}tC&""U\2sARqK)C0a YkI)QT0>>*d ;6Z,u0˨}ktFGQ;~·nE@,BTJנ@\MGDama % M鉓E]>vA@oA"""rC-޽_˝?L+I)Q,}+䡍Oqr3g=l"""Z͓3WdHX &x -mX,b||juA m[ׯ7By 0jV!!M S*ɟ}rJTG`ߕPc[_Wjӭ_>| uU/⯟]؛Ăb}V|!"jhDDa2EQ9 8{v=e0 TL'؅"ez1Esj}I"""UWnC|Els9QO4$ jb1 ۶aƪ_kcy~gJe nۧOܯ^۷c}ψh5WgSa 5LiSe5qJ%T*$I$tnI[c}<=8pfړPK'48}E%!׼ ЀR*OWYğWt~p2a.2 zz)= #{ܾH?r"jcA?x<=NC\Cʫ=]PD B:xOn H)}'rլBDDDk*}g|z G2DV[sW:eY%WajH$~T0z,?q=uWKl=m3MB\.p)8*ہvP;3Q愀9%a$dنP5_{11/m*Mܙ\Zömȧ-?Q3GDrMUpNk6[V18PHUn2[ `3A./%cY0b[|d2LNNx kGӴU ::oAc#61/_ƶm044ԿaEzq>", {a[wSa[%DUUJB g`bۺa}{,0T`g\BO@!QE|'|渀5 @V-@X㿡BܴIo|u v#uT*t:=qʰ𣺹"D[~/9PCq oۊ^V.:"5 < 8pw[*1K{a"""c;H8OǮpS<ZE;A m3{xZ?y?C x/|a5 zcL-o &քńAC;ٶrrh4D"X,186>xGT4m[:AHj ʰ3@I(JRQ"B$Ui5hY@듈HHo"`UX% 8U .! XmM'[s|Àrc].@u0o<2̼7_M91hQ:뇡H<w>Zk<1(#k[ @kz (Ҁ" 8bai"""J&$|{ōW}d2`WJXҗ5 8(n` ŬO=`:8x %""|b {\+]ZRhR f/fm-~n?)@HvwX T*<1*HkRa A\.X,6q ^D0:& gw^@6>Ŷ0b*@u:ǁrAIݶN_Ftm0a-X5 sBZnysLHlK)Q,QF*lۆi0 #SsŒ;y^?ݭ5;vlق-[:n"""z|A,1x RPA-Y[T+ i15508**4MC<G,[p(dh>B`{&-6nX iAWLՠÚBTz wkh0`f(>haEA__"ȜETG${t^ӯT*Aqiľ==XD_? P !(JW(kN*6N *mH7y ΞeNWi]ٛE̱ !+t?~8/_s6MNqS-VCs5a֢'lP(*sQU ]Ȳ,uFbF js[J.K ^=$6n}{$-0 h3j|GxM۶}U?yD*:-%Q6hSTCw ˲o5xw2>=t"""z ͭaiA [ +MlX5(sE|WٶZZ!"bb؂*sOU7q"Q C;<ӂZ,2Jfb-K5Eu=4H$^RUCrNCDcB C5!/y,1b BqB-aA"_ = *ѝd>,߁L"@VJi=l/ݻz4tƷlP"3]\~{ zDDDDA2=a ad8I0t!ׇBo֤0a(JPU D"yT3 }cؘL!34esOCeA-R v VE]7P6 SDiR²,XVduZX,\.7-t ;L'Qcq`}/&X;wj  2n H)a۶o<#AiBu강;%""VCҼ.I~95;&bbb"X,bppнxݺk6iݳ>QSNad2AenLsc0[/Uul2 aB?llFZEZBfyM)qR*e۷UlN$ܲN*8'aYP%XSPuTME”(aj˰,+4/"~f0IDVߚHZ]ī]d}|`x(ᬚEAP!taU̅uA1AgIDATxCbiAkNA"""ZJ诞h=oC~MӐL&CsIs kx~z8Dy ޾0}xQ|_Pn""". ފӨVBRazӠŪ/':`ZiH)S! @Ӵ9%;RNT+wb=~EE*A"C,LBd2p2iHUT r߿YCaap 2!- elXv?q`J#aH u Dӣv>NZ@3]7 zD&aTaSJys#HI@}qe H$aL ǁJ@AfKig#X["v 60T3E6!a>4BQP|62x؀nz(:}U޶(Xb``M^::1hBz=sxܽ>zJ` G5`a!$gDf{07XH S$*ђԵaĵDIة>a^y;&.&L8DKIN?bz$P(G?Љh HX1 MdžAsEYV GM$BP(,)Tm{ι}EQ( TUu?Xe{ǁgn6Ե4MC۪]^lD@2,DPy5f[tQlQ\9D"A= H~t̝ i XB|)uˀ;MtKE0*t'"/6wgu9{Wb˖-شiSC'""yxC P Reymaz&RӼx χ&Eq8Ӷ| {wzI4E__߼?gXdx?qnh&L z+.M6Aڹ#!EqFD#E ^WPg+ Tc]O?ݒM&д~{m(˾玎Aޘûwn;veaO .A2\PyI7'H'ZNUx=70Zm#j58q"a< Ѹ[ݩ|i^lrQ5~#j.!de |e"9~?ڹxmۡ-SP8 7~߹ʆuBhWfԸ Tsʋy9"""$!Pu/a``x|㞱rUǎ8xw>T yoKxYc-a+|hzJJ_t"""mڇzd:!#>kW1tѾE̱R{J߷ɓ@"""Zfs|/AӖT3.@?DC&"x|AUhXh"ZV:8Ea< _C clQPZP<%A5UA7cs2kN!xѲt/gfN2њdZ*sf՛딦7V*P\R)kp@K 8Z#)>)MA>0R>j.=D"""e*F%G>1O;%+ٍ._V3\BR vϫ:/w?JͻxIDDͶۚ-Ӷ]1zDԣ~7:w5`BRךkmA)PK (Zr`}iZ\04Wdc+QE6Ts; f\-He{9YA!@jxEsajj*Qn?jv +=* ʰ#O:^Xc<G?[J-B47I+~D7Wu 2ID+=U*$Iw{]; ȫ߸,qo|Vm-SƄtk'""(b!.?SUW/*JKpĭ[Pf"rrgr9~;w"-TiUO8!\UHZ ]5'o5ూ f H]TOU] zDDDD˪[hnXZ'&2L ZĜL1q?ׯ_zDDD4x#a k9_ZɰkN!ߏD"lX,(隁T^(x|ӟj5!j ϥpl^zĉ6C7A+>rj QBA9NeY-)1+Q/ҵAtD;ZIs B;gy,0sp]ܜs۶ÇѪqfQwl Cr] wL&5DDM\.l6;{EEVDz~/ӻNXg}$w[Z487KvsU Ooͩ@ DDD.H1ƳMg6,lF_sg\9wݸ\.ѣA(Լ@=U5>A?e{l,.x"^F188x<񘜔5nMh5=PޞH{* A1llwS}W]zDDDD1T; `j{SSf *fG޻=\t)Vs4s@ 9%k1 H$AbMDfiWt||:"`ݬJa[uBDf$Ǭs$\3 dYKD|VBF\=RWy Ho/qk2Mb_z&#vq/IDDDF{-giV4_j:̤( A w1Ȗ#GPk똈V^s5/lT5F0@s!I $+L&*zB_0,j/ :Ee3VXAoƯPSUU[JQEJ 7Nl CDDDTE6Mo( V1DcTUE6 bXbVձ=$D60~R8`5fI4\\)&e:##:'""W9MkEG^GV=i9{ .d4LÇC'"" 7RLX){G2Bi)b,[QWD"ĜǾ`7:gZDD9TPI* ?=< ƶͯ{V 7^XQ`sUJ>fE""" [IkTsh%;)&R%P|db0U',0MMMĉ{hA! R*&H```n$pb@`5_󓈺\@L&qVʓONX Ųcuþńnjco{sw v""" KI>|r`L&U I)Q(| H6w^:sqT 8t}ᇸvZ'""iz}\BJR], *F4 "ɰ:*!7:UNJXĿx;hm*89O50\!L& # wuR[E%)\@= bX#b !"ò,es<\`#8v1Nd'""Yފ O(DaBhr[L`͡!_n"( Rf% ~RlCDh簃juvy$Df5,g;)%MFce{""" K͠i(1hԗj[lmƻgҍ[4rݶmn $m7S=`5߱a dY Vb[(\.~V$e*2 N۶JӴ+:n"K"rWURTBqR $sZc}MALޛV>jl;,%c4'j= o .ݸ9%q<(rG zDDD=yGAdA`=Je_UchHlCD- ahhw\n`$ D;;j xܽz"!ue(׹]Uy`d*>yoDDDDExYP!r\CRJyHϢp "@H {qy=\x1 F#b@DX6$_7k# 5?Y3п9!R75!ߏH_g# JDᲪy9Rz'Jaϴ6g[Ζ=b   in[3wu HD|C$"""Z5F%G &NζmysE{bf2I1k8rEعsѣODD3o=ASoeRfb"H#0k kAΪ}}}]u#!u'o\.h4?7 %WĿ)7J:mۨ5UCUD­\- aC1TaT*P:8n+<;nK)qaŠODD hfPHX!X_Mrewb1 "Ͳ-%x̶i=vّu_- 肪j 3Z VϲWA ' JFQk22bLSxJELjRxUw{^s [Gh?OԭA-1BA8gU?V7^a" 2̂z7iv5R6 D:G5˲BY 6֌9N5Mk#!Hފ pRqN 4DDDD,%Jli4 tzq/"L{'|x>tK|M6K=@&>U 18~x'""ZӚ+1SqJn` ǗN].'%_.]Tm@Qz,\:[{ ZJi\ d]AiMY lf0y ' ;wlCDDD4"fyks8a6o.$tc󨘍t7o>њq %2+ul lr(@H$h!H$0007-JW3"1'4WR.V٧0oj b 7knA&Ꮸ/(|l%Jl[$UUL&v4Q*|Ͻ!.\t#',ȼ{yf'""ZwuO_AYx7ñ8n- uOY6]Y7;( ,ǃhf #.⍎_Mr?^7*#"ZKh X a-@v|W  x:VIJ,__ L i#bDDDDkZ58>}{1DMjժ##>r; zDDDk&ժ0A\.~W*ua!UUU0885BQ$I_TU1 UZ AG"ioDTU:O^Ecz@nك `9i]WBܛ@f{""" b|?>MX1l֗&T*1M.]Ro,TY#quw۶m曡#""Z HXT̰ATI.QKt^OzuirLD+Ox<> #,f ėtYn҉^0M3ax<{޵@b*87>*Hs{ꃇcA(l%rl=ї!r\C:BWyn`M\k{꺎#rTsW(p,V=斿ޘqju߱2$ H \8h#5{Ŋ NchhLUDd0<<~EWH%f|b" qVeYAsUqhZ{{&Bgś^R%%JfU""" R|?1}e3>rL*B4 z]Ų, s'5XNBZVaGĉAa4#[M`l􈈖nU/.BdCCCleITUE* L&R|²3?a!F" ߋjtI)C[ dP`n j "AD@\7.x nmA""" 9Gh(& c:x]]Q*|.!.^v[P2Yׯ_ǥK>QWknk;̦Vka 4}͊ ~f_Vu|²\!@D"!r9D4 Lb``CCCHKޑP <DDS@*JhkZ!Z{u몂4OLT#""" :( 4+(\.PNZESq=zbV;gۍ3gΝ;Ak5f"yR]EAwS^Ԅv<w,eQ !ׇad2%VrW~~N^F`vg6jC\5j {hemUAlSj3'i!j"Qʱ fə$W4E2 z]\.ܼ C9^¡g`{=ODDԕ[8Fcn KDѲuFg J1m,K$A.s+m Qgh\rb~  ߬LQه(,n+ E:eȐ皫ݾ < Psw(7wh̑GDDD ' Ew>h },^W,}- N\ mQNƙm˲pС"DDDZGնa kї \1FGOWS8+T*!/i!Őf1<<%W8KT7-V""c:Kej ;gwCZV{np}D;vswfORl%Rl^\.u{AR"*?}'!'GqEwVСC0MsQk xZUd#;ڝ{BS ;n+:~^}4E__Jچz(/}}}H$Kw0H/]o*:aa+S뢪]s5RWMs5ۦ+RY[D 躻D M \6 (3!-D-&"""zdtm #z閻TUE6 z]GJ)؞IOxpǮnOMM᭷ BB4A,-y>2]R/&~\߮ص"NX՚h9d2~_ۗ̑gZŪVnbGH>wo:P]X{Y d9hW^v*[O:\ݎAk`+哭u-q$žts|P:9zLn™ԩSAkx#1SD*0AŕPE|i_UtӪϚ6EF,sziHR2̒hb?r?V7퀷j-QMjez)%rC\5X_ d6VB@AH#& ؗ$"""IRh(Ɵh<ܳxVki{eA.X&J%1z\m,z*._wWJ?Y +PDu"M(d2[< HtD:^ EO veC]ҫ~gj jWUץi6!`F^#H7fZ̺b[P55Pnwe 9}0 bz ֻm!z2nm O>>`QAJ R ğ3,|\߯x^l;PH:ݵJ (,100T*ӌ^7:~f೦8?Zk kR=U\ ֭X dܲۘ=͎F-U88LtS6ugqkIDDD5*ED)8^ڿo\ s(d:z ɸ=/C>$@H =_ºq'OD$Ν;m S7j8 7\%DMl|²qOx3-MCeqk "J!J,躎z˲:DK4D"DQbǺVm;xvec?۽<_.}{V=hʫNıs"oTZSP@1$l%ng[D"5TUT=zMw[ >y%czKJGݻA(09籬v2\$/hɶ8A7k:~ hT*HRPUưh !DJׇa ""/)1[Vy&0BD߈ۖeV=U}@ز,Uս)Htc{7 \wْ1k,!uGh($3=b$DJRwj8r9ݞPJz >\_GDD xzK턥"Hsman/&ZVu|ѰпC!NchhmFE: Bb1i^4bؒZ l?dXUS֧[AD*ƅF:/JAq!|@@>/aUkf^(OkEQܶm_{ ~/(jMAXJ j}v>[MILe4YeYX(nXX"K8t /AUض7|ߍu%抮'bnwZIAGX_M\RQqLSQXd#4春eY0 a4T+ !*E4 hwwI-/6xz ]a^p K$JjOl V%+?/^lX,um{7yv"N-NDDDDtm[/wO}W.dheJJ|>w/3x擟"Sx9|頲eY8x >a`` /hU4A,jNYlm8 ǗMbmO~&k 4T m1>, m0Q yx}n)=:IJ``=`Zʸ*xKB\.=U#pϋ`3'=jA(8Lx8˲8gk>G+Cj k&g&ّ-DDIx0jZ%I5̓6 Y M7h@MDg qsA"""诞T`؎ġI1ht:T)mSSSp' ?Gcw~@2x;7Su|}zk Fi _USXFg!Z-/[6U\QU\V\V|*xv\v^&:(؅: `Lc-vq>+jy-F*PjTQ_5p<z֪A^}U#?e(͜C0JE<5Xs* Jji/NDDDäPQH<(҄x[8kCS,jYȡ2|s,;~O}}|&ģxa@V÷m|G2 ""Z1A`7Bg7xڵ1B*x5]pOQpWN"@Q`>_5/opAUXk>)ޙoXHp,-DDDݠ*~'y9T*&L {ÖOlRV"isJ0z݇e3 fŠ zDDDD]V(&D_<O| [_dY76BkrVw8^vr bxbFӽD_u|sC< ""ZsAiwz6;ɰQFTCC)0BuH$n޻'aU ʫ/~7o00 _❻HA(* ud}(v#_F䙳xydW vzUU}^*'E/tpH~4VBo{weYDLAi»',B ǞX;K(6D k0!` `i !@ZN?; z15=EF&@ V5H߼nGFu ^t@Q:uD"L50V->s^uWDUUr9LMM=ܮTT(ˑb9u/p$>"%O'''qA||4mOV"HѨ3gj;.A, Dk l-K&SlE1 }=!`0f `pb3ӏ.PP!O" raHqLJJpՊXcHRRij O*ۂV[a(85&@}cF!"""G)SE.ڳ15#h4l6bĿJ%X,>wg= 089|/#áC]]NDD=)IZ> }p} ЈHD0 LC:= jQPNi*hlFRY+mުa@V/8ظݞmMfxMܻ>cƓg"""n"x y%3bpƝ=‘#GBFDD T K8؞{%6|Mqi@Q 0Z֠{`ÓO=$"UOv[x0ĵcF"њ`OpQ9>EN-a)>@}k b1_@j(-|7/]sm曡+EIDDk_ANs-LGV!"""" jew][ez]"NX dsflOx*tMBB{بª DDDD%P? KN> WZd+ERAJ>8> ˾c߿7xfS}""n6W @%"hchUb(JAqU !|@2Y@h=Ls[1[#Ah͑BE> l%*ac,hZbm8{8r}1###xCwG]-Yv#m Hs5AVbECR ]Ud2VyipN,B) ȫ*{PU&0 JbfRAutD4Q9"|8BHGE__4M z]]D846>Wso];n||ZK<""ny%V[*,Af9 Ѫ*x=g6jC\U Jޟu5Wd&I-ԾӓR5^{vQvutLt11aݮ5)n]vm'WUrEOz@wgD&HD~?!O&.NR A~VHA4V҅Sgc]@I A:~qbojZO貚+A!w)ֿaO+D=+""""rߜ,H-G6lԹ/*]yÆivNa&_l,>xj6If]>J cձ1P* |;YJDD9Rvv-e/A(:nht^mZ:bXv! ﻗ@"ydE6.BHA0R n!CŨIDDDԳmv<h{d2QO-] 8.ny\VoBm;5+7[A"""""&?3aؗtn=)ȃ 5 ۽?8go*)4،`>8K+J|)aKrbmسgfgg~DDDm> ,UVcQTdA,/cu۷Hĺ"[v4>u]Ì-9(A T[a<[ExwM]+ R^Ja2{CN=cR.ywrMbWGa֪5Ƃ ￏ Q3]feA' 񼉈M %ѹEZEQORUe^@Y KtUDcg0 㚎w9ӶHe1٥64z~6x62L׽g& aSS<S:>&*Dž!>CPףMN[KAhQO. Ww Phg.cU"""!&J ux4"BU_,AjZ}{ Ҹ6N.|#GK+bEzS_B +,=cw0 MmB@{t ,شqcs4v7DͲ_UF$ fFBdYhvUߣ_TUT*5}_8SBǿLoy_|M}"".K7Ȧ Ho DDDDDtzV; |먟 qA5RHA:Ua2U% ۏG3-k ;PhGQZ۶0F -A)iI UV@Qgp^1P;)%b[й&vdcL'7Nv|mf HO K+hMDDDDtCT|LKq6U4[o@XWAv[$i UA>1V!"""qVԌ퐚m>Dd2rj2xYC-9jbԱ1ٳ=2мZksZ{rKdiEV!"""">B_/FJro:!Dۆ{n @XWAlܴiFi"%aQjԍ-Mw>6txL*Pq7jm'qe\O1Q)6fgg믣P(DTh ð%bۋZ/!""""1eZT* 7K$P )ۣ]Aw%+oc01% /6>2F=M"""5jK߈ ƒ>l t{neY BIb)^|%N7jx ?>BDDkҲˮc~}(4a}2-a-=0[ ~u{^Xݸ=LVk܎SQOhͫCŐL&]W>.|[z }@ل1!|tXc}ݻZ$""Zm-}w1Q%j.+]7l &NџFNE=-Z ,zKs]סiZSjavK@ PsG&"""( 0 cBdٮ{?٭ @Phb|>(4*QÞ///I)q߿o.эY *֚H)5LϛF\Krܗ[X! @zDA #CŢR )eۂąٹ1o:irjmxav,-( r\KOKZR jeHBm2?>E;u~DDD+tEzA*M~Zm IFHSeZ,='BnO]YH640KOxA"""BBA)~/<5`xq,=3Ql:-VP(>#%F?jXŮ>Xa16==_(JQ?""AmAR$ QmCOAc2́]˵ ð[4w<Oߴ1i*vX((JK n.!ԩm5C&b>j {\1!Ͷ幮9.I%陖*_ _kUU8|OzLKTBs BDDDDt}\%LRag<0[8XXIJ-BC1|%GL2]בfjO |KAB=yB=r <<>>쳖 5, Нe@4ah>LK۶7nBE=5Z,$6n3 JywlSZb3I9 ă8O?G0djORX,tୱ3oKDD}9Rպ) l CDDDDtmuLGy0r/hd2xcGDd4 xr;ME=E"""(1 TMl|.'Z۶[ڼpڷj[×7c㣏>G}W}4A*KgDtXfh>TLK$No<n8iU Ȃm4>u,M7p#&hM?EzWqd""""@1 B#[y [~%J!G=՞>|Ku3R>~aJar7źӧO^C>QjYq[ׯAPXDDDDD$2-aq<ay@zXOA뱣d꥔-P8{0IDDDԗ|%b~~q𘁁T{N( s(mg&ޏ1Y-62x ;v,CDD]Q 쓪Һ7O˴inOEA*j{xH B3eA4-X}!"""@Ra 7nSV_+dpjx0ezT:n ?o-i5 X(֣(J"9Š DDDDDc:-H)Q*viiKRi6F=-z. uۭ5MipqE<]\6YD=M""""P7flYc$2 r*JK:/GKJp*_Ļ4>t~_"Gt&h8R< K[$gsݚi`F\ZUqmH$-{-a֘ ~u V8n t!LbS$"""Kj-w (0uU |ffζ=ޛǞ?Lmqw>/K|}{ND/V b#Vb +]^]>qZ*UUJɟ2dd-bfi{sΌ5nǽHDDDDM* au t[5^өU ='O~(xŮpXcLJÇ?9&&&~JDDt4A*M,ӺA"""""Z0kf0 Q.bdZ)'o s''(0M3)}v9A jhDDDDtcw> r9Ab$l >S-#֗_ TU;*Qk^m 8NzK?Aah ER% Ѹ@Gf Ww =⋵, r$4n騧HDDDDKwՆ |/0өU=gP!ԥfq42~g?éSVmG4A,{1a7+Ҽ{O` ΗkZ&~iZKKx[6Chm ȂMѶ+"jm#m `؉ Q(f!zaZhSZ>h?#Zß[[oRD9Tm }a5""""E'T?^%yVQO12K[Zi/|Wx0;;""4A2Zil&ιrܲtj Ķm_g@ָ,n\uZaضxrR?[ӻEzWsh""""PL<@I@y!An)%2b˅*&1^hbc\ k% x | "t-EEX?@bk"""""cM[zöm[ !2LCQOn~unX, BDDDBx =aquݖÁ}_| 7MٷgK@8z(~… Q?-""ZZ~R H bz @\zI&-ki a=Ypgzy7A|o_xXw'䝈[D1 BaByaAn0 Q(PTZ-Z޽x}\15;xl0X{a߾}mg, `!Rk HAIK@Et5J~:dؓ6?C }bA\Ӵ\|_Zd r@LˉYPH,A^1 ruyx^kKa ၯ!k@[ǩL۱Ξ=g8vX. r5LXk]_ hZ1""""cnhZ|Z# !ZQ5{zjt Ww 07qA2vh|`p'"]AaчB.An Qw{{M/? ~3 /l}.>3,DDݨ9RZթ߂ XAU-a\m[?'Te]2`#l oDdM;2= PAZؿzEk|aZP( `:75ljcy8NO4AMn}AA?t&!JRSaH$-cO[ 5n~[ )0V˲ONN4HDDDD+}f0ȍ.Z.`_c}b1xu>57px'OOS8qbD- H3 """"B4n :rߞ#tj sB<@S iܡX$ ö)9ӍDDDDZ =0M&DTBTj;?gk fݏ'ێ8>Y X~k~ZKYnSǨw^늯tx<`#%LZSAز~}X,v z7SSA!CĽHDDDD+d0ȍe6NU+8^h7ٯ/Bٵڎ7;;_~)%Ήðwc/~^#ATy}}Tը0[ƞٰ?xwn5n!vކ0B߶<@:{lCDDDKZ ?3,AStabر:$=Ǐ~(bCgD8~8~ӟԩSQ?="49U@|AR*_ ) P5_*̒4{EhMA 4Mܣ\W335a,EMDDDK aAAn媃H>h?Cqz:~ۿ?x QXnAҒk$ӟkDDDDԇ$nL'Ji(e6<([5n~m0Z^qAk)9AV!"""U-a'÷媃=5}j18U+ev1/^/K|} V/ wk{sU.Bx> 5_Q(Ja@c9ضvI⭃Q !=zӧOGִ5KJk~0BDDDDcM }A\.G=(ֵG=5k2"Uwƶ]+ o")Uh 'h錱@ Wwmۆatn0 ;N<07ẈyS2#QԖA[& U|Z q0;;۱ThAoM»C8_hb_կzсFh}!D84ɰ"a.ߏΙZufdxKW ѝ; 5kݭUA:) =!ļHDDDDW9 b>8K1 #yRJe A{Xu߻OxQk)%0o-Ҍah-㘎JKٞZkiH[N5J ZAieA|V;/@q!"""q-a Bdٮ}Ϻָl2޻q!}TNwnS,㫯2!"i X{NJ?AX֪uo)K)Q*bdd2-7C l C-ldEۚumN 8ߌB 0|,$"""eaSO[,T*};B+㊻.]k+M.yb;mÁt^Csʹr7Rkɟ2B-l밽) խ;, b e#鞍zDDDDt ;tv600d2tyj?x?)0"3RpɎR7x ">]VS-Ҽ돭ahq2˲`vӌiH$-cf7nzjԅtdmCCݼSUoF~>)5j6oFuT'8RJTUul[*{>_hޏpbv혇k/Fz5)R [vi 5h8tNAJ#( Zn GfKhMA@.,?Eڪ eAv8RZXhX[oEwD'XP(T*u8ӧ1hrc\qk8}Wv1R o&KV!"ZAYRYvA DDDDkx_W;'DXx-_d2(}·њ%r*c)# @QA_XJ8[o w݅tX,l60Mf6fgg;V_y.~9_A4]d~|t]~3?>GD61%  ޿kDDDDƜRqL_j Wqĵ%L0g׭h5ny[a4x,EZCzDDDDtB!Jޖx0 r?xRJT*m8Ϟk zf]%b*}}]ʔJ,Rx)-,] e5""""Z+B xPHR-c*ă% ]V_&ePV}cOr@uRUUA֊P(&_{:>կ~׻YӶ{w-!"""5_tL) aT*kLelGe/ _-oظǻvV8E\A9: BAxj~6{~ 隦app $+iW_PE|c|=qA`tt?p9Ѣ ȥ~ U!"""5/ ho|ZncNhޝE;1xs!bXSuݎUA\уЃ4:BE1\-0zw+' !HD=tv1O:>_| q1Jbj^{Z{wA\)uA%}T- !+Q;*z5~ڮg?H y[S7G|M_>8O\Uzv0 ;=:4 Ő QO'!렅5mT=4Mh'Q e! CVmpֶQ<{0< XuԱ>55JǏG\F*vDD7h#pWt,ꎝ9i<<8sUߣb1<$G Q+ I-uݾn *r\˚6l|OX Vo sϾ<6>ݔv `f[Pp,B;՚҂&HlۊS3۫Oh0.$wG}X!t}t Yr0!Tg0ؾn]E8q333bXL֖4MʘTNd\Z0(x`DDDDD7q΍+0DP\.rG?cKZ أ/oBtΑ :}ܞAUA$G[Ee ƶQU_UUy^WpBӴN0a4e.Tc_*Μ9sA4dٶ#DDkm8tPR̩S7-;ӱUZg&~8""""O { m CϩT% G̅!Z;v[eGiP'p]wپsЃ-DDDDUbwnl(?z+6B(A(N?xa}P`QE߿w"/zeٍ KB O\"""""ZתqJҗaa L=G=5A}Us/P|E0 Jm/|ܞ@TH$"""HA a. SSvxBkA!lۆy4#LMNb b$LQ$6f}LMMرcmlaDt95nW*A!keYV_uaQ(Ixj6*v(\.RvO?WX V p-/V_ۤ[AXo&dy(JDDDD7 #( L$a&'u}GAи@z[%yؔ-_FQL+O0,=RT*DDvLLL`bbqjj-}YDuE_QO B0q~N VY&/VKQ,Z6RpZApf 2[(`9DT1mǮj8<;zD"x<™u)%>Ӗ ɱs yaײъ4~;B;DDDDԽ>TQL_RW!ͶT >4v1U </0n&͖ 2O@MH80BDDDDk ]p1l}<σeY1RpXDpz ,<2.^8_)#;E ?q!X%z;2vD;_;)%j EExbxL""""aFx9n ZNҏrPKI <#_g@m'|9saSvjU}.[v@JlCDDDJA@"f-7wr _([tuaY4c tҙ1+ BjD#V‰q-kP"e… 8z(j8DON>Kvoaz#!hNFB]帉e6r10Meŭ[ý{kַAWyɗOOO 8NVRv 2+%vb0#(""",PpAx [ 39:7knnӧKp]zRʎ ma9 O_D|`al~@HVEqr'ΜX[ 0HAt0 q ?RJ 4!"h w>y0{4暪[A;[B{lCDDDD]M @X X Tƞ'bq4LjЇ/ rf+RJe;wGETiHRmߏz, {m[)uL?Pffpjnjڵk77-swI9'"""1_i/?{R#ŐJZ $zD=?Z[>WIK tmI";Л<ܞ L$ xjDDDDӲL???۶ⶺ*:].SUxULRu]uH);B,gmg/#}~l1BJ%ǹz4bjk0 Q(p?~zi"HD@Dk8xw;12?ucrZz[{yPJ0DDDDu?6abanMӐf[s6C`s՟ wu 櫂: ñjÊ_Z:!"""t|uyJRSif-vTT > v1 ń@a Uef %T(*BC0!ܒJÚr2*w-T Yw|F8⹃lqf<)RT*all GEPd>!>}f ף(9 !_QXxY"ѺS2MDDDD7ABIBrM:yI!"[bK{{qRY۶:6<='-yG)TY rkh`Fk^/э3+~'a߸ž_?H6֭c'FGG_z~8`iU˲P.ֲUa ݿrIDDDD]F 0Yi ?uz pb V+)x?5#x<0 gR[6bc*y bغu+2L,DԤR`bbϟe7͌N^)r+ 8w0%D\m_oRR֭kJ͈0;w(pb1)Fnڤ{yMn:薱]R07m-FbhhPoڌ#%l}CS%""".rN#ជx!2KAa !g#e ۮxPO".[6odm6lٲcW\E\ڵn\^wp;u%Ltzw>|vVY8o߁~)2(|]ƮvɉǑK ^d/|B v""""ˋ{H'ώC geRIZ$hT tq]R;xyƠeez1*ibؼy36ndKP(`bbb''ͅs=?޹v4N=PVn=!H NwGDDDD=nZ$LT:a|>mM088زy[O>ݯx_x]R;o;^B jl3WT[*ӟŀuZ3WJ<*MNH$1q[ 5 j6 qMЕօXn]#!IRJ ŋeYWkȅq@ !~ǁ<~'g18,UVIUU W[ZJ?""""j^k $PK{T -Ov"zi}T{\--;ro=$f6|zDDDDujɧ^j+g&U9bvj:m?3pIB d1qnڂc5DK !~UT0;;YͭjdP)@+:;s1w:6+3X˲Xy\{?;a*H7yFXd-mcX:= ~)R|^vIyyxcP(tuyҡe={7P4G5 5:}iy(][MEQUB. m7ۺX!H@&2m]6!KzN###`rayβFcΎYq~b\|P-W?c"p\)eG7d2T*6UόjZ-)FniFw?x=^E^%ۋC"yQOkYa,[Y{Ea*EzXeh3qQeV #!-۲ic/zzf3ع~#҆HӍPHKVzas3BX-_*3cǕN˲`6\g˵0DDDD:o*exeY(QO1r#Aw۰~5~SW qvKj33:X.J+82DTTlwO<1DDDDb!#0YE{ĮT*_1 X i^6"l[Si$7oie@h$adn};oXUM022 6`dd-6D  ,:Ә))V *j,spXi^!aبo*㺃VkU "P(D=)&OH? v B\]/풥>BwzZRCCC.zˀV#mGܛC7=+jeE=}a0Mi^ C-Ư^c)4֏ bLUJ麎7! PRT*>Uj1;[[Bam| 8]br}8qkW<DDDDte0Qp^<7r0Ŋ)۾<^?u W_~%N+JWbd2（jQOzLC= Цg.J~ ]a&bC! [͙7maB$x lX7׍@[`hhjKYr-A~Tqmv N:+p]_@םijHX߄DDDDԏB&L('a">&xG~*|A®vIOV0KovvR^y%*lٹCCP~ă*LDDDD.M m(O?Wjnj]^n>G˔j.΢4[FP@+QB35rc V5K'J!L0DDDDԁqkKl{kr-\B{Q~u7SrvK_BBlW|I$H{:D♧`#(zDDDDԃuBΗf0(++j6*JWo!𡬠G`\A0yf 0_vpprD<n EnD`1^*P,j޽P'&`bJH)?zlOKTmp -:\\.ò9UU188ز6qc 3B]/̫޽_mYrӺT{!C(n7hAYk\P>/QXNJZij! X@lCH#-D:ơ,WNbX#`[~#wWs1^.`PB\Wǂ{Ѣu :ֹNBUÏyO]/Ϋ]RӍ9Ԗi;.:ާiyېB\1ŒzDDDDԃBjX.T>ĉS879 !\.w{k5B!(|0d}:M + J̇Cs20eUUᐅ DDx|Eppe-ezZY%XIdP.vqӵ*pE0yl%IRx6۱Ѽ9nS}zJB&A,k6po:;u5@Ү[ȻcR/tqP,e-~moW͢x0QR} ?vvΝ8#+uTUH)~J#!a EH:}bʂ! i&Ȧq(ܪ!bX#H$L&[#]ImmòK?^klbj݂m9, 8` ,b Z Rb%5B AknOHU U֖1EO:ڶRBkߴ ?+^cU.?=6|r0 m|3~HUAռ ucKS%"""&rNA څq?qWJDYi0db$Blp8 \l 8ց @<o ,h~ޫ tj:- xz`JNFv`;.\DžSyHׅ]UpnA\W,V#ؘ CTWP}r?I!"""ky!w&f;#4Mdٖ $y_;'Է"^%y.<|>i]lcBB|@DDDD4O mĽ ļi(vaNġ+BARu&]WIӑK%Dqx|W 2N Kc|(4WMQUtPUBvzaWy7:(;uTm5ǁxp#TU]׎بȦR0.CLs_/n@cbqx DC$ʏo0DwQ\خ `/ #^0 2J @) FuP|e.͚C7>PKK !0<< eL?Z0DDDDԻ|$L|ݡ%<{顡u,'x?ymz_hK0ϗ}sssx/ ߣjJDDDDk"=q$ mmc 8z^f}oHGQv2jF@&1<`d=qZP!U0 (-f@T(UU*TM*UATC`:LU˵e~ CxA !p0 !d" % D a!-n6P+URAX­[UE9k\qin`Zt:D"6-ϲ= Q_ A~1y ؃YT|N?uu)|^˷ 2,ˊzZ)Ͷ7#.@1~?\&""""R{qwM ag3QJ^GZNj`6&)7@jMRP ŕ*>ʎ^BJir)V!-cwxa>a Qp{,?KJ4 ?-c~>!_86_](mrYO<,x 0O>PQO E:H:&|Y[( ֲף0DRmQ? UC>VZ5EY&8XJ2R" c.AzB߃p=U)Qp3j I)|GڅnAz뚎 Ui0u9R(_Uo?bd2-c޼pө'{_?~Zj(J!L?O GF)~oS%"""5L m0-$N9ӗ6.*P$TU4快  EAR7 1Z"H h#kj=57 |Cz|#}xA0p H KBأS>( xmO_ODDD?훽( \KDur >-ԓ½NvKڟ|.?RJv~]lTbw7D=U""""Z㌠}ZXkʗ9, j[+!:D4M[U~:S :t! ]ЄMQ^h|+v| !CR"a.Vyu z,|NMXn];D==""""UX B q詪A(b;z)?tY|^GMGPu] uEappmQ`v~@Q |QJ<њ'w'r neŲP9+|fձ\CJZzV ԵEi A ÖQ/d2bmT1J"""hFR6(I <Ѓ=pf eZr?l@J+Ǭ4ADW/L"JA]60QpVQTb>['x o]LS|>MD6mmܱ(1A uG'""""6BHgp,^ffpaH)QPyQ(Xn]_|vW(?abCW6,tDea9)ʵ㟈;w`7*h8ӱ7AqH;'*!)4TېO>W5;/7cpB JahhmZ!K:>Ԏ㉈wYD"٩(z騧Ftݱ +] EQ 쉪 4͖1ᙋ0mhaD$.PjzX"+uشe 6勘tt*v( bLӄlCDD}ci[BV""""Ee!.({i6opOGY Anǿݗt0 ضe=C<o=an~`""(I&zPTږ͸-C,f zx<UUy^OO'""ZA H@ *JDDDDQ\ e @&iy/< К+77GWӕ RԪ¶k<򍷰+0B-7ABhA >t xZ>U:Va<V2_z,@>]B)E_WyL""""*BwtضHMӐZB :?x]@hbfj2/^]i|GtN `TuebN }@6W])48zxZZP"2؎ .-xN0 X a2BDDkxe,!҈zBR2!Ro%|gfO5A>򹩩Fr]aYVZN-b&;rhh%0B#DDDD@26"TKbB@}dg1tz(X,Bh @<oYǿyDDDDݮ*~'nȕ(\.ײLJ2Bk_7}NAe S^GR#fڹ>N}Wo1t;H@Ӵ"mö햱q[ kH:g*Q )4T0|67mĎﾈm܄ey麎l6A+Q[G%X8[Յ2bL-r"QOa&'o-%zZ+"P[oڄjKDDDDԑrNA k1qPk|V׻Zu~*DDDWmppma|K(5*HDDDD7J]7q!@<o}?qD__xS|UUU!Ed~qT*>4FPo,6CDDDD'PⰌzP@iжlm,bgq2bTUE<G,GVMZ΂x<1([Yd21#G{? M̷yb| ņa<AԮ( C!ZJb̩io6}]%""""Za! @#u ze( LD"aE,r0$hgDDDDqYx3 ǝʇ~wdrNJDDDDtEjh!圂/GApt_]EagMömضAo""o\ed9FDDD1R; if-clé/.|/gbW(4 }X]E<7'k5ܚJ#pBzDDDDD%G_O@ P(blڶ ۫U- Wz( @"aB0BDD]-vPb[0DDDDQ_l6r^ b7 P?"rϱch>.˰,+ꩭH<@&~9zz 736Dxу80Gioop]eu]H kDDXn]ۂA_݉zzDDDD}$Qi!X.D,Jkol.?k"D>QOmE,K횹5c{S%""""Z!}$ݳ{rp]T>s uaq`Y<[L*=˜h01_erm!{TML8=˕sPt[0zEL,ҔJ (!6nA CWmn>a @ kUظCނ;T.*+9uxf""xm<> DDDD7˸"?&ML3"!˵\g#D=G1 ~ych^TV=0ZT߻N[%|QH&!ĽI$ Pd{|Pw&Ɵe HDDk˺uc5I4#"""N ^(˶e\.G=Ů*$ㇿAC+&"7&IRA=$K㖾؝QOH4hacΌavfP뺰,g*ڐNH$eHF:*z+qfQU\ں=kDDCx׿vM,Zyy hkP'پ zX(FDDDDD,cl}MUBA#};nƆRs GVUX D 8 "ש=̤{>w k* v7\jj5)vEQ088Q|gv֕  o*?KԚBVDQ az6F'БO>PQO5ha zPBn~q:oy̭⸎^uU|tj/[.8"]5f;r ˲bWQ\0~ry-.wyT2VTPףڊ\.2&|vwp* gE L"9_Z_!đc865s:lFQ?5""Zc2 bXc~ߵF$"""^5ۘNR-cB AN$gz7Ql E΋/Ob"Xj\  aV,pK&0ڐBf. (1,c B%-C \Cނ;\BEiH$4 RJwh)2(xb2"""O >hRX,q8%@6mi^?w!e0EFGG_y׾u~-+z0M?-pl:&iX&jjhA\[vDRs+E;4 xx UT!""Z* C$ Ѿx8 JDDDDL?Mf@0DXyQO!d`f}ۅ ]@o|aMce\.G=QUCCCm&?|QBoADDDD I<S, 8\cfs]eqBdَ))68&3޾?? C q˽?pxz׸Aн>b cMU@t]G=`LҒA[5`d [zDDDDD7]$`j9҅ZeF؁!`V+ہ*b8TU'KQBt\hw-dАhjBNTk$ [v000бuaZf!Z A+;{MLӄm=} ]oqVm8tjhBSQO(чHZXDؙ`}[27Z0BDD+!df DDDD1Äv( <_ N#HfhoPny|S[!iZ0GyA"(&梞.Q䴰{19p]ȣp|"c `6l*DDM= I/TqU DXP, Ju '. Ѫ'{ΎUUj"appb{T _6 : v%""""5#鞻i ~hc0},F=W7""ZN2D*x߷r"QXS:sr]b'l˽UL2Bjʵn`mx*Z(J-;J6~8}@2a*v6E@9v撏GМwlз>8**$044d2Vŏ8޷_SQ\'"""442!۶YF"3!$ۿ)t?LXeLV@؊ykS%"""":t&w'tt XAq8\;)!+D}%Z6 [rHDDDuB}eY(QO+q t ^& mIڶRVD!23= ?Ն.Q09Ľ ~#b\٫ K)qxBӴƇPUEH)~#b6jo kf#n K3vVZF=ͮtȳ4I^&Jn{~m*1Mav]xe1@05m[Eh!KSl}deP:a2e& z q"i0MdiBQH) !Hh0ǑJNH$`4MkTX@aH$0 ae $ C$B}jKjZ-ivX,L&'bqi@zȮvəa_,)\,L$ 'bq{iCIDDDDtE! ?ӛ!ds\ . 8KxavD;TU-QV}nppp?j}oBDDDiE% u"K)Q.avJ <xy^$$F!17S~?McP(̢D6im۰{JDDDDSV :ɹ<>Ơ>uݞ QwYPk/`k ttBS9+< \-L\XX,̺FVqD""" M abN.[Q_]A1^%3gɖzJ%魈(l[1x}6J{h뢞.QOZq(IJ!ϜA~63:_-BED(Xm+f&҉8b 08?eE&&qQJmR)FQ[LB\p H#S؀5 nXB OM5u]3|Tm ~ VDu ops!BE>(%tzJC!0R U~0 B髝DHӴЇiW},`c`pbd=7xf,˰,E) -{; BDDD}X\u]J%6c]. SnMtG[Kz}iZL sss=&L"Jߧiy[WR($v&"| NBsRj-d|jQ7BUPVXv`$Djx-c抿>Pb$C )4C m҂Tuv4ANA`nnomahhhw BDDD}b\qΗVmF\u:y͚:U.﫯мqŨb\a?J#K߈J쎨JDDDD,B.Pjy5  t4=0 \j#A#.{)uaT2خ aX1CaS3p <-_Iz,q cA}'^k{LmVW ld󕈈 'zdzc)%2l^B I aFW.rƘ|g-\;wfHxhB0"/4&,x߇z~kn#aK0WmMӠiZ#ie&,%P3 {ކG}yƗ&Rbff}nt Y֘yg0 Q*6]Vi"v/ +P[W~Mc#L/T*d= W($ꪏODDDDDF j!+ ϞCa.շ/. ʹQB4 Pl r9 dF$e7/U271t~O"7-\B qc p![vKj/c\@ٲ,娧b\Ѿ]|[[_rJDDDD`Fxx` (uz}6[$%]Ӱ.Bl0M!+8$jL@L"2a*j/_t}Xր5"fZ y(w}'x~׿ 4hK#Rjȕ(*^L]4ffWbw.F33!DJ%j%Ѩ7۪uQUr~"@o Uo Vu/bќ/ZH{(>fGmd2Vfu(Pt > oAXѐVy|߯sԍEPUuTCQ{&8K-^Ji8t9& bO Q3uК~>T*r\0B [ u|Sc\1fSu$Ɇ%hߎš@  GMzDDDDD`j!(rUmdn!md 7 pڙ3QU,mD,L걾bUcjZ-^XćbQLJzsY[a_q<_XPAK1yebBk@t!S ޔ2=r RŶm  _D 4CWV&LŤܹL.`ΔfߟW#ؠLWX`n ' /M<5W*~lqZ;7?g=z6nf .lg ,`ȎyU ?0b.Jw}YDA폔rͶM(?U<bX.,,Dh==,I?`ؓJc>[}*c8], xϻ>aMHSC{tၔLQe%ׁR)ۻG*QQSd2 *hUm!VIJ!I\xLR)QRQa=~$O!EUhh4I: q]Gض` z6/Z]ڼLg,hngW./L0EM~wUK!""2pBk}Lk&kC D-_[_g>ك{#\TU=== W@ [EsUKDDDDD3@04t/ =Cȩ5_ER ^8(y ȵ(02Fᐑ!FO 9F9l\S1`b"j6h"L@s D*xjڜ}*Zًцt:ݵ+C5MCOOOӟĿ+VaӜR[@zswqfT3BR H gUUE,C6m&}dY$xM DDDDD<5 Os5(C /@qCjdH& N@CF64A5_(K%8*H2$*(Apdxm.ͪ6V>fdcOf|c`6*DTӄGpcħaԂ^-=&Cֈ#|y T*!n\"g;\=KDDDG}SǏ muR |Ý!KR)?Fmfi3aD">LB}eH"eih"pHQfRBTj:@A:\<> @UJJ( =vlR1 4X4Ԑ #DX挼*|a}bCSlCDDDaMjȏS}d2n*e!7!y])<܈m0006遦w3e3ŋ dB[m"""""jDH #աЈ3΋Ȍ|AẀAZ'rlۃn0q7\`Q{ ='``pdc? ϧ@*T( (BB(P<[(BQ :x[U!t0 0 MeB[0BO!/@Givn>:P(X,z-L&aCFCk^gOxSC~ "fdmX~@韂;?kWׯiX,l6Ml===uNö_+țkZ=d"""""c#4X֡ !P!?Hbh'=ҟV5~i9"bߝN{N^Sh_@1jutDkAimM}hr9,XaYpOEV{C"""q_㴂bBᶅP(h4t?C D)D7%K@iDF2ԋ>6 o%"""".& GC##$H0@ k-pm A ]E/M3*Q:nW|v)Tȑaړ0y>xx~ڵPD̼MDDDDDD5"G 4BT _D  J"^_ [Vu}|_\FDDD3K@ 2 C F@T0B26n{tk4 a]Gr%""""""6yޣ~"Q4Ytrjtr hf<4dI)dP,[= e-0҅}*#H~MW8 \>Dȹ<q5. ck EH\*ۼUTT3b硿ܰ*av};  ~ZRRUf+lj\.\.7w탇 @z7=7Cw7HjKDDDDDDD-faw'}g{u,˂`:jb:.$""j*qI/ ɨdi$)K!jgE-baX#׵!j2T*5-Upt#G ~~jONDDDDDDDmO3SzQ? j!\fMWSiLS]U! O\Zb```hȃY! P/[Mܲwdy^}ץ! ^jPiph "wmSNJfMأSxF"""4O $l2~AJ|>L&V0S*zzzi6!( (X{F#)'=V} !)ht?7/7p8̪ M8Btts 0pΐ躎r/ure5\h4+ v{~IDDD-Qr(v[2 dBo@: P__w7Yt>HW s]C4 au$iFR(pՉ'|}#*Ӯ@8z?VKiXF jd.I)n)T mꗈ E;!G/Qzt:si, xiB@: T__wwگ߸au]~pՂ,#?xg,axJC&""""""`ig0v[JP&\+ch.ydnݪeϪ RJpIMV?BDDD/ 60 &J%dY NK(B,k`Lt4y;c>{e\.45!<y~%"""""" Xĭ>R { yȓ}r$Z]QBVZTjz?ғ@DDDD!+Gnp&od2 NK$A4mOp!^WiνK&UV(D"MLi%+2@/ 5""""""v%}r_ܼ I*2 2LË..BeF@eYuߎyЂ' qp>.Fw8 ^)JM'c\/^?}pzKDDDDDDD/ RaB)qy^QVuBjӕg}M_[ mWI| @aȷټQ ngAL&l6VUUL&jϓ(. M/ܕdrvMZ=)rpƧ$y>qJs%""""""$bs0LmqmL%HV0bJ+I@}ټ ZH5)ex3ۘ)U? 8M܈ZjuLhd2 M* D]ahKNm<4VJTU EEw"9\-@J""""""$V{X=|'N93n`>a@UGOIǏ̲g dcǸ5f|C(4(ߴcEபuj7uo P(=麎d2Yw:!"X^݅cGѦ%+)%2Lc ( DDDDDDD4["ի;4qd2 /< _!4}e< ֤'* J.{5h׼Q*o~jh(1\Y5<0L&.n= 4m^r;a8B!aT*mRu]Xհ\m 2x!L?Rׇ"k9j+W(h?0)%ǁmu%TgbYDX1 \=+4m}}}k*pXmW]s 1LȨ Ϣ/X%k;7kpo!ao)B8 \,eq~xզ뺠UUXp+T $ xAh.Wmo =Bb -@h { yv'ELD8泶NRA.kpyxes"HBQ..6KNDDD3'/6 p.}4 ===un C D4 I3ﻛ>w=x[#V(0PTZ=)VuaU(*DG[@x"""""""OȹHZvn>i00!aRJ_*@C+W?H,X;wPyEL;Ε8Mg"XQci}g |(ra L6\`E@hW~K7nĤPUjC0ؕ:IBZ& R_+""""""*هչ <>I=F3-x#/ EQr* hZI嚪@Bt*DP@k&4}hX1BDS ͊m3rCJt:p$8P>RDDDDDDDO#02"u.B A6@^ b-Oh &w>SDDDqEU߅L:AqX,zED"P(TO`c$OE4kěk^?Šz7eA N7uwu9\EP~\~nDžw:eLxa p7Q/l~? M]ĕ A 5],Kӧ( $LӬ۷m@)0B[ YhԶtcM'>f]2 bsf5Q9wF@yV,ảJ7/^l(x՝$F4Dі|qUYwmikTÐڄY2Q.[=쎣izzz.ޠ8=Om[w{ޓ! @Rygo .,˪[s7HA8 -(AT2Q[;V/ هSwV@9۶G< A0t"Ț"ƆK1~E!36!""2B,?SGqf(Js~d2 E^_x+_ݼ=5Ah}ޱn' @Ӵ xrŋ! ZPGi浱!=pr@@J0`3^q0 bA&<Aа: (7oz>x5 'ߵM\ R lm`fI(j0,ϭZi Lh|_ۇrK|7-e!m_-^xMȡ EceKDDDDDD4/]D+" B #%0—֯q;|l(JF(q=WkT2@qy^ݱ(BPy͖f+М9}wyx>og#|>?/ϳ:DmaZ@h1Bsm\Ȯriuݶ,56`;0Cϭjn۽$xg/!y{q" ]k A??c {%iBq&| (2`eRbU DDD##e?X:N HRA&atd2Yw IŋK!Y ͹oΪb ׊QMDZdmŪLb뇫F+t^c @.޽A\ d$u j]/F/Īxn;Z0 ?8S鐦)a""0.~6qAU&f(JmyM]Xd2 U}9v!7^z ?t!"5 М/;<ĭ)S!LDRif 7eq=ȅ @X2QKX}F@ه3~H;TR XxrO gc#ߏfUUaYBLӬ]HhI+TUhMI5AsTs>]7A@JRl6sYFFk!a/ֽff22񞺉qN[=i㰬!֯rҡmlCDDDDDD]g0r \w")24M$W"o6Q<:|'maA6e&(BP} Rv>?[DDDc]UgKǧ V/rv4;TUE<[4x3ϟY"B-}KN-GlWUZzRVV=~ Um!ЧbDDDDDDDmrg  fWH]j%V U*QCUUض 4g0DcF> ࠮bE +Ql=CeLA βPd n?v!"3 PK>{_[Smܵ띕V֫ZA ;HX Caɝ}X ({b@ #-Y `S=g%K`޻Dzq`0 ޶Ugy<i]<H`nا&'pLrR=n6)D"1* ,O^ϝnID݇Ajn|wV*Z(g&jۖ+k~6˟TtYT DDDDDDaF@U\߷|obyy!{R0">׭A| N ѕ4{hMi} ˲A*V2 BDDUE P'@|G.CPh*0 $ɺV0~=;zU@exy#՛} IK,K V:򤎖D _K""""""yJ{liB,XdUX+>6P ,]FBk^ PH-BjQ3GP*U\ٷW;04^v<} {@*^v[v{\FiNUU$Q>W!"qᇆ$/eVCBqC|ZbVCD-; 19Jl6=Fa W9{$&Z yt[_m%L\>hprT훨ß~&Vd2K Hj;L?bM:+;Ep|Mt]G< .+< ѼcȌ^,Q(Z=( w5 Ry """"""U \ƥpCC }jFd4?9a-GN 4'@" a0 a""WToS'8}yTV4k]7p.|O\h^A|3ٞfQTZ=( ;Wyj{3O=F|Z*ѡ!MӐL&(/,ss1G ?gl.n8˸~ .5^2 ҜX eӲ ,(ᐦb2ܤ((Jl6TUE<$fxkb`f!y&׾}ݻI)N4u~D"/ gp5mA iQE\8p+!EQSW|9 Gmn+ AѾ8dab1ض]]`eAh&] d2 B[?#˲ Ӹenw@h潯Y+sA~{os6x |D _ DDDDDDDoT%Bg !L&VNB7Fm 4 ?kspV1AC8P*5_RA6mn^k4G Ai+ S1908<*U {0ѳ{?5V"&pWwbEQH$ʯBb8jC'OB{U$K'V=)L@B ݯY x UQz5|6peYFsB|n _jԟߵ 㰉 L&t:u , t)o-~Ov]t5Zu_2*2&j%""""""=D+j.OH vնLpu9|p.հ(5Bau+/Ta*H)Q,Q*G; ÈD"uۗC`Ӗ/b+"j~ Nd2T)>swFBu7iA%̺c>Z)>4O`U)W6'"J](uQ(8E3-#mxs7c:d־:q6SP(X,zxOMu$5K^ i_7WBy""""""gazGO@vR$LUT ϼF[A>S3jN۾\mhnuo8m;@DD @>b< TV ]MUUqzUB`ݶmDx0M8P}r9V5+CJs'X hC#^0$8r4ܷSB B4 STxMH}B ja;qKͅW_u<,WhQ(PTZ%t=˲9_ ޵܎h"`3?wI"B L6\)VQ7 B #zSRdp1Z"ɴzmAQb1>*ϻ>XQ7b* Ԃ @P舅NH$PzXo|k܎ب#~'{u2LG\B Hj3,^zUm[xsuLDDDDDDmJ.Ђ@z _FK-A&HP›#0͎PMI5ǙGp2r\60"ȸ1|kurOKDD-`t brϋ:x` ּ~2vDDF!o}ѧfRJd28!>5!b,]%K!7omjCBi(d4ԠP]wnkpjl6; ;/:| ޔTE\F2{3mW"koB <=u)5(#Q> 5q4>x.iT*dVyF$!XklB R)+Bb!V$\uB"yᔪ '4S92K)Q.Q, ͪuE%ڪU׾БuDDc@G[́;f{HR!p8p8 !I_uyw*kΉhx>Up]ZUHT8>_WmPWc}^GD4vԑ/GA```cN,B<۾F(xC6@ Y%8ZOLDDDDDD(A4K@@TB>ogD,muۗزkX+.zSR݇4\rCl+!MX6늃gV!" !7bjo2iD"UUGmވDaځ zԱ/'N"7} t̉aH$u+Mغ};eV"Q>D``>w-( hvu1;wݿˮ7K<ܳѭuP(H$2au UuDD"熆4T/DTBT ĶmDѺۘ^{yxϯ`/X|vr?8FbDDDDDDԙLbsPe\WdT"#msv7eޔ8\dPVnA`T],c"i TpQUxQ*P.;AQUx x+/ u=+|g׫7cz qd:dNQ$Ih6jv" m˵m07S61}X 5Gp:N,m[ι2< āғ*0RJdYAi*A4xi+"YWu ?5"*J\3Di"UH_ `]V0DD`ȷmwnZZ"ɴzx3FD"pRae!kC'H ֋KZ=l""""""#seߏ'NQuEf!^߲'a8 R=t{v)%2 Ǚsw;۶F'UGJ.>%"jg$cyW F lv{?] l(?xn{RA6mfX e[x՝FB.ˑ7_ DDDDDD-Dz ݻAGND96> 8mﴟVPX iNת5~0u˪j]5p]bcBY+vZo BD4u~k\}\.#Mfxe&KTqrK>W """""v^EȹЮ'/~RJi!$ Ï>8 SqjeYFuNE- KIG4?14|N|lu] DV04 ؁\+@TT*!Ϸzx3ʲ,br]mb!koD*DDDDDD4E+`wKM4|2L\oV><^»~ȹIO0 2EA4mXٵ×jOD4Gk CezoߎX,2FzMo.^ l* DD֯xNsK VoF麎D"Qތ`MBAZ&"""""&\>3}4j.44|3.(7 عu+aw KM Ϩ0 2sD" ~YmN,u?74|N|CJrR17ݢQ0Rz,sxķ;"IZ7!oًA`'VB 5,5oQ/!ZNDDDDDDS dx oP>p<tAL%X,۶/xoaOa8 ]_pq 000m3D4D"#LduU3BDmp@S3CiurՑ}R rRi=NV0Kl[~1ވMzŽpIaTB>og\)J5/[W,dM^ZEHrt? hY `WW 0%wZe0 D"^YH|qczQmE纆tiqR juZ4 Xne!k'?9IۿAkR u\zز,b11'*,}[m*r:TE6C.>h~j߸]HyYlڵO96jawy כaaY"TUc $c""LJR;mYKݿoDD(ѐo᣸ 0qd:frlH$z aZH*-LxsuMDDDDDD ArԠ q?Nr\C1B _gE0H?8RJdY ׭B)Uï:VDU*ث V0pN v#UUFak6o»݈fDc7}quuj[!x݉ع~=g?>(6FxJC'"""""zhX,P(Lf!5B85GjaLrrؑ4MC$i83_s=XJD誢g5 xWn6*[%{`&<#"!<5oC8T.^hjg=qCm*rzT6Q ;7^<1vA>H4NQɽjToJ:[#ZvZi1 HOq1)k+h纊OQ#e[ٍ @4L0ޟ݈fDƺuLn{'mhaaدF++Q4WzDDDDDD]E@"Z}5#GqU6i-:ƫjQ;jToJ*2.?k#~&;%|dY"TUT=_qAUW8qj 6@M4)C)t? ]>wM2LǔRB H0}[t}s]@7%j7ɌJZE6兽Y$@(+?YxxaLDmB#]tוW#JRG.Vm#Π~e;xFD4x%u4Z;Q*󝪪H$u`)[[WB+) M(A PΞwN;(H$ _l[85zSR݇3" Xyb6)p8 ۶J/>~"㬪纆mrJ1+hX,VwPfFxK hg>#?FEL;x+lo\ 6)T j Z=t"""""YgUTžB};b(H& +,㚇R))IɥBdxo(P(P(4@1_v?W4MC"hy#\VH$āR=d2\ZBmBW_t}aqys`DTRp)H)k?i|e&"H]նjxϯfEx%o}kԗ0#麎xV !jy!_SSUW(JTUE$eY+v!ķo!"x &z ޔ[tXFBuUo@yys5Js|v"""""d^"C!6xH)d:ܺaH$u!s gp> Ap4>xhENjn @8ngM~/^|̄;eTTTŹ0QΜYTx14MC8[=U! ycD8أ8xJr?@(B8k׷+{!"gxP&ޔT]wn7<-!H@UKlݼޒŵmF_y"""""NHUX6=9{9yY 4W.;YQCMo-]ڶ@hY/ђ:QsIEy|rƫ+ى/Ch7֭û|9MI5|tꨟNNEA(j`T/{>`X% *k*O; * * z]BuD"~`ab-c1@9fطy\k0!.2 3aFQBvY6bwAs5JƊVh΅vnV=t{󹦏R"ˡRz3D/p]uToJjncυ (W,Q(Z=D eYm?ťg\_t}й2 \P|اH@#ZNjAGSUHakB_Y@DߐS(}d2=nV _~~2QV g^=)CrZ*Ρ87ة%-(XsުzSR{Ξ88fi۶aSW 5~/>|D;l(DWWSPyC)e8O|> +?%XrF`M4KR)9OM5MC"x}*k_m 9%jt BDDDDD^x IEmp‘ӧvj !`&ln2xT=oz>v{Bv#zZ=O4wf(QVkN;נ !`60EO+EhVQ⁛hzSRx ܼF{|gilǕfB H4\4˲9WEoGq(K|H,kƪ`MN<+*88*LuZD׮YlCDx'ޔT \9tWdIv, Xa;׭\/S":ѴX tkMtH"tgDEQL&iZݾcqES(ߐ;}.SZҨtX5T)eχ/hdqm0qRU3>* 2|'5it,~W7Ν"9óC8Z/an5MC"hxx{(۷նI((XkP֗zDDDDDDSfiH;z {2wٺS+4LxsTз5ym~\n&d2;gf&lۆi3! |`}Yjc~\QT j?x| l[ 0BDaxP'cޔ遺{)%,j9+M?o ,ڽ }1lCDDDDDm#Bz ԧu΍7r<:D] rVĻs~[_wǹwHJ|>ra$)۶aU x a`fi͜86 U?GTj0gM$A8no-[6[WBCb“|"""""'XGMw\7RUV)dC!*`(dc[АΫ*Ψ NBՏ/m_ފc"Hc j%5/` hIv^pEK>GTj0giMmT5,߹~$\V֗`a"""""3C|~XÖ:Dae뜃Y{RymJ^[)R 4:<%N?&̿WBପ \Wf6D(e@nX(  DD |MIq?N<{ erVs!`YV V6O '"DDDDDDdw\$]W"dEJBѡ~EQL&ߎ9D ˟}^ #ͲB 0V}:}w "pvYUCe߶|߯Up]c4&jEl| r\!""!տ+o8s VuJ2mhw`w(𮝵[)4QzDDDDDԁD+`7Ga8`Wq54krj>LD<|ܫK\M`aM/> @bc`Y#| +'FUwp敥K{iqr9mb 4~Agt QpOWn+ J3 ~ЌPMK ,iM,w~qJ\.@t]G<oR#`ʕ׮m++P0W;""""", V>EVP9\=z eG7Ubmn~yiÒ%r`RJyV恹 n C" ;x~o<cE( =)_ |8VR4TUE(m@z Vu M~2} 9e=C&U, 5m!Dw jY{aNe+Ivnֶ 3òl_ Rxaڮҥx)1Ѽ5k|E=*r\W4 u}V!Rbe r($"q DlI@Q`pۢ yt*iH3q M SQJʌd2YW1&ֽw\wW^ηeJWUyVI C:2 "%lȿw CvMA.<ϫ! a UT)dM ь QKc '(*lG'ڛ'ib厗bGM go@ ɾ u !}Dak۴K F?|g`Zβ,ah> lYmK Ѭ QH$>'R"v|b]=~0ѳ @hDx<usU i\<~r܋!8L]e'Ou|SS|&?J|hF12A}?÷D۶ j=॥K  { l QI~?" ”!D\࿸1'""""YHyޓOLKwf R B+.:D"QOxuzǜGMIPD8T@B4hUUGiwA4 w7Q;PUPmz^(X\4 uI>K >8UUdَ4MX 46W^ C ygZ=t"""""7X9Ax@A vM+]בH$>Cv/9D]#՛ڍeAV (!D˫41NgBP]^R5Xުj!"7MI(݇3~G( (˭.C˲ iW^ `%Cݗ""EeR)=ocln-@,eYobնz pVF oFc˗8GD4v1/͛x~P(t\ Q;QPmCQ_bg] ݗ""FEԅR)=|SpR|>?mGe!{ox}([WM`Z=|"""".'@ع `0С^7o"#qV~hD"QW1*מ_㷂y!N?<Q !B2bWami[`ˊg<ۿQIdp>i PV[=9cb؄I-۷j|a`EU[/~%hAƫ B״:xg,O<0e̽+W jV4tS[+"BԪm7`Bbxն3BDDotDP7%wpy?fXhƥzSÇl3pPh~Eӱl&x zj<5kBDDDD04u~J>eQ=C>60`X,ְFU{!Ir_NnV(]{&1 eq9h[HXos1ADD4{&KDbU3gpr|>ߵNTUE$i{ ݶ ~ȮmKP4VW,#܀!\~_ 7AbR/elF4xbxcb`f^ !iQKe8l:M3:Rtmu&"a0MoϚ41ułL *3++z(K r8MrԳҝ);9잭Hwh6ʬʪ7kDՏ.B@y̎Ǘ8_)r:ItO}1.rUvn8Zjup:?y{S"ɬ_HSv[4"f-EӤ}syY__O4}8,ˬ߱բ+?I큐$>$_eޟ7C!OjFu^$y(Ᵽ^}%m-@ |NsͻwV1|/SǓ3i|}(3>a4E'giEFo=e2dmm퉾Ӽw;I?Ϳ?7_px i3T͍v_l;I]Y]]tJO(;="o򿘧BNs|궶mdhD=QY ]yx9ɛ~=e<;?Y;_߬^cba>OdBUU9peoN7QcO7E7NMy}4Ldiev$|y>|E@4Y__p8CWN'L_G`Q%d}=GKQkfu̓\ eN'~?~mN7O:6W'0rrw9v&~|͔p8]$Q2zyy_Ī$ka1+?};[zo6E?2>؍gaM_lo_?m>h{p8zfbw<Z_ ցε~q>r%ef>g:f2d:>90v)Zyرfaarxx9I?nG>5: ,--bup?y{K"^.db}(<,LJ޸s|μi_$kkkOeYfeeeJg_JwB.]Oѵ.ڶ ",7۽zJCJmY&'l`_~t͇6U,--w,e;,ξN޸X׹r%u~9d/x'>$~?+++w\l9&_ȟg>x$IsYvm5}]יL&L&,(ͪ^oWU?6l7r2;ur2x8yw]_lv 2WŢ_y5oyVzL}8쓲fqefg6 \{b4nmf4e8;7meӓ'n??'s1#iPH端s/pؾi-Bat:zt;M?ɛ^z&_LnoG98~,___ 1{~qS?z3@ա_ʬZ{R5,N`v6h*.333ozYYY$ ;B!Md3jm5=JM`jR{eYnzz|m`OH iz$qb:?IsuAn*2Y\\k JAGo9z~ߑgqEfgr2W/]p:}HIR ڮRH/r|<=Q-dluknm$/e]9gI}Kx|9n;~_|q.n\uʲR$BVteBrydHQי^~qRrV`:f}}=trG"oFfNUUmB2_9e٤s4 UiH&srih68И6eY [$Iӟ_˟sh;B(\x)ǹG+J(v?HS)R|:K{KPU|8O}#d3 9ݖQ./,ׯ_wmn^?/-g2_ZڲlZz̪C}8j'Y|L[ >o><_-yaFة 6M]p؅B,g2x!WE]guYJF0IY[}tbN//gԧNv620)9v~q~gx۲;M\ߦeyy_4IJ~+mef_ȴ:e;v>ǟ{_foӎA8 H[XaٿWB!:/e~l]oƓ||lߗzt:IrJO=mɄ?$n4_U;J\~=t?Cgyy_@q [xU+Yｐi~ko~*"=L2wT{6E~~Y`C(g2t)E3۴m7+f3UCx :NiR$9" 9xpS'S>tzn4n;gwOq<guum6&t`o8MeY]zL:GpMܦI3f-`q׵U(-S~68i9w>sڵ|5.{ՐUeGEQl {l<'$$/eZZѣi=uGuD#mNo~Wm۬f4׽!O~{9&xpzo涻!r92xlmY~):wuk2dmmMk$U^۩qQ`ڢ9R?镫Y[_˥4ߴMv2|WGY*eYn |o{Ƽکʑ K:z$nOc A1 9Vk˿_,m=ru;zY^^g d%>omݺ\ʰBƝ}8"Mdqyʛ,~t)wl5-`a60+ISi~3ozo7t.]N{RWhY%٩FK|7"폍GTIN^7+KK<8ʎ[ ౱Qn{WzוA߷;M[i[^Y=qDf`v.KOS5$I9d{+Ws}ìd߇P۩ Lq#h` Gm1YKEp1ӹp!Y+qvmeYn>vPe YܨqضU>n%|_ :wNŬz=Y]]5!~ I#Gћi-@Sqؽ^}9˓Oi֓(o?z;Z!ng>g}}]{]XXXN&yWS 6avjm=ŋWW3>ڬΥ1$Ҷm|q{(=tc; IN' =x0//j~1[9vΟ:ms7xi`Gj&7$fkbi6 OEvs;Z#CO1lΗtմׯgh4W:fQ̶m}k~kxaS%9pY` T++:fiwa[ ~ ౶.xsvmpvmU?X/ 9멏ݲ)zͨ{*mQ!<4fɧ$+Ws0]l߶máPe"9ӷ3_9"gیG)W436̳ڶ~ Hr(dOq!CS<|" @x"~t[/*f6k_dyy"ɏ;ݜz̞}f˲d=a4+LӌFO&MLuy&mvIMd(TVYztAŅ4iV0F5/c:H?ʙmY[[s'=t:,--e0sU^zԯ6Eݧ2=y߇):/8:E;O친tחq2&2d۩ $x4ogNH%ur}r}=pv2I3uyz>|>O4&IݶmmiLdR$6roUA􋤗WH,-t"JUTUʪJթRVT~2$7=nL6ڢxxlOn{Zn4MVWW3m/gS'7~0'cˬZCi0:/Ru_}>(]_L&Y[[Snc~r0?InWGUN)f,fu$tur Q/emoviݴ~[r4LfV̰\&}HP,M>ON|ɧM B4kkkƦPEGzOR\?jS|qߍ(ӖݤyGm]_7}Ϸa<guuU]K d9OdGodeY].e{.8UA}!KOS5T}?<WNӬg:?N t/e^R?|4͍G;O47+,]՗<4f-o~jN@gyy9NgGSi~F=| 3wNxy}>gmm-x?#,,..Q{;Eݜ|̞9eY[t2ʰLSBf_;3gٛnnk9K?I O!lsRzz^߱l6Tf 2aYKK7ʁԦ̸T2/~P,dau0s~fY[[٥`pDzv{y>|Hx"F fuFQ4$+" KKK{z9Ç{?&ˬ:߇<:z_g0;r6_o.]=CdoҶ^,R?D31p9M*⥬m۬g8C'F >%y?ȱW^-fա˴sd xBY}^}%x{寮\=|ٻ,//QaP?~o(I@']:\_Ub45@yVWW3L>R~vwEW~:_K{K.2=qDh8:U3L5e{wf6e}}ݘqz^8pGo/$M/pI=h={.A>lw3N>RnwJQdݓ+ү/hTW't:9p@zޖ$?rR>,p%a#R}_6Fi=t`$ou9_zq˲IhFݓvaN\)[:/o2~ڶd2p8lۭ*KKKYXXcٛU'Ͻ'؁Io;ۢ3_\m۶p8zڶHٸ0 R;]Jcx=-E ɌO)zd)ǹt>ɗ_~hn>g4e4 AYe^{^x>I@ pm5eo~X_.Ѧih$GeYfqq1,$y{a1^{5,)2˨w2~ϊv~}1\z4~.\ș=o:f4e߬e}ߖ۶xVܪgyyo?/O~faA0=T|w*gYg<gmm~m_*ʼ|h M˸{<Ή̪>D6E;O~)R7w9K}3p8x<>z,//حbW$b{vm&ysyua4RϭbA[ZF7[^Nzt˲\̤{"Ή˅>Tx\f#~|Tu>ΙgA]gu֦iRUUY^^`0cُN}O>Db`m3ջܶN4Y__h4rQ[vmcb刺W2/8ֺ\θ{"Ή˽W?ΧW_NB/ʕϿ۝uК۩*KKKYX3 jQ^MsI@k&_뫹{WB,TUIsnͬZɸs"4Eo9EK.W_ڱKTWf՜ f>GFd0}>ExԯDb!\˿~?BC~?ྫO,JÇo[ZdZʤ{k]?d6m?VMUUY\\¶NJ'&eb-c]ϵ~_@ȃUeAA%ySO= iSf9ih&ͯ?;~}1eskΗ_eZa<8(|[r7eYfiii'ӾC #`B@/BUUeaa! U*$ot{9ԉv`ɬ: >dNt3ϧ?nNQ)?"WϞoǣ\۶xv Eiu$L;G{oS߷N|Tjm-ḁ̈̄m3^L1΃wȉ$o?t7xxmBֳ{m!(.|n~~::e!~|:KۇB"j%-d~6lfN3vr&ILCvd9\VI~})bvB˯r/p{4f Ǔ䩧)3 'Օ+z40d?lB$y͉GRB+v\)zveZɴs(MC!WGo~9EssY|{Ꮝ|?yR<L<6!żI> =su]g8f<#{Rf(L䅢sV̩̞9ur1LÙV IRG";+W3|tڶc-?3rD(m%0$I'/as睾Md8f8 |B,=m(ɫA/uc#1 O.=O[!o>ʯf4׶mFQa V t:mղӇmQeZʴ:Yprq ӝ_Mjb:Mf^gltxHw KǞI'F(sJr8dqá;zIUU[Zթyii)'O~FiPՑL;{쟪7n}%۱Y>υ3gtxvmn{L&if[]t:Y\\`0#r4O@&H@H9ekWsuia&\Pez^Az{eM~رc)^z1Ņ{nSK7ά:[TFc~%ꮂIҹz5ϿȹWylUfc:v6-&)zK b-6!E]}|l^]iv(tzzt=m_&y(" Y\\RQg& O*BՖ@W_Gzvmf<g8ܴF,VH{9r8ճϤ>thW`ȼ?#lW7~Th7M:g7|sU?6~<\ T՝ެ)= o ~\~=]?͊~|8ɧR:훢:Yu r9uu M#߅o>nQ{<5M/dv|]3IIFc6e: ~$Ntpd=jK0,=p<ȁɴ{hI3/ᐺ{\;m:jU3^ٳY|%|3|KGOBRw~%(ϧ~?/&N2ü{j.o|>֣߬l lwq^$E,dСO?=c^.ܬY<[VI5_OYOYKgNi?hL/]|5?( ,,,MHVSg@VL.5Io͝ڶd2h4t:}5Cۭ$yrǎ9t~OC{St7Q,I1sbW2\]8Cl6| n m$o9>q\$߻-mcΝϕ}_GۖW%PEf(WŐ$)<"':ĉ'.nܬ C#x4f=ZvâiR]匯h ,粗VϻQF۬4MqFQ^aQ喪!N羫$I79eey)ÇӞ8ҞUr)ux3(r# 'TxKN~).^լsi:7m9lf3hè, Vx(_K 3C@H1&]>;w>=22]\{EN%RN%9UU9ϕͧiLG]^~`c0̋O=v@&xm4)QL>ٮN|>h4h4J4{M$Emuh7Ꮥ$o--k>vT}g GUB]׮L&FL&{ȣkAU Ց$*{,-,w@C2?r8}4`kC6[7[;|#q|~G I~XVy?R*IwB>,2ͦ^$l&(8u]{T`ȃr"ɱY\C>Y=F8d!󲟦 ;kSm"7y[^ߺl[׻(К^ǭfI=z^A]e;r8_N}pEI+iB(o~.]ʗ;\:8Xi'Y%9hJtWVCR>-\j64E'mѽ|[=*)|;E;O&Emn1n|spƲ?=64MsG裮 hmղsGK$5W<6nt&?,o6mB*2^oK;jvINȑN'˽^~: )8fe%muDv)irKXMōisEmoe5loTh߿Nm^{fse./nsFn llGsKc@m|Wyr}=z2SO&Mg̦Y=q+|uo$9PQ@bAbr++i!g):0z(xr31ͤe\3ϳ6YmcnmT{ld:f23댚&km${Զm]T`'^/~?`GgXZڲ\G-B뫙}q>r9PiPt:C!W!.D~HTY( *N'n'^/Ur0HdaC_i4)gi,lv6K:N[uYY&:ya3ZzG9ֶmyI4o{v  rر/FǐI.HB:/eɧk96<8XKY)2EQ~WI^$K)XTee,өTeSU'eIMzMVG(f/4lLg)fdz#Yo<4a+bǰN[{UIIm[_Ϸ˶,/m66ͤM&E2MFڶM۶if?ol#߅GOv27ھ<{XW_#27 it><&Ol6l'@폻-u?5n}93<,ڬSHjY#Gy̗XG'I0bV9w.ԳP1 s.f`l6]t: t:;B?LKu?`L`PW_W_\MlBөj!ff(DoEQl :6OR>s*Uc&` \/s3> L&C$p? z_'Kϥ>w<$v u/s|:=Q-d2>,QeYm>HrQCGl|LChPHt.]/s|s0B6*Nn ~tt:IɣGSRXG&S0NS~E;ǣ\~fYiif`,tǽI^?RAu?`G];W_kId~m{G0WQ[Z&KRYYx̟y&mUޱ<Lrg}FcG۽6$/e^ZS'2;F?dw $7L&]'u=׶f(d:>D(-^vX9o?vN &1u`HӤ͙Ϟ͹gz5M%2*nw^$/EN--e4?q}x'݂!E] ϝ7kkmrǭlbwhǭ,]",.i{6͠3O{)_| p=_m{if-Vll }t:]mW$y&E]Xci{6Ž ~Ǥp`H5%_|k.0gvߺ7C!lj^/NgW>̉,>o$#e3MΥi.\ڵ\|=`2u]g>Oo%IINE9iN|a}~IG`ߝ~6}(sj 2r5Ü׹|w>oDn Re|Ok$9&*G̏KH[t/ٟ|LBI[4=mS'erJsf6%^{m",<{}?$O%y͡ťJqx+{ӿ-{gbx$m9ir#i:~T&&+Ge=v+W^Y_t[!SHd/ vHK2h~SWEEnYשvRu{)d0H4i6e/ Oy4)M|nM47^74M{uۤidEq,~^Y|]n.Ouu2Eycl[ionӖeeEڲJ2mu˫En)UڲTU~O߾_3?n3OR lhS&E?'P$'˨/`my pqՑI̲/2>3%sIƅ c iM/DHe87%.\EKI۴&RhBI8,h4],d\p1IfeZ| 0z ͝$ 1!u _p0FA@Q^A䰋 Pnd-IM  和۶ѳ?w852(_3w}dlvDǡYViII.ɸ$b}y {{0?ry=qDMs-+|>K#VQ,ɒ$<HdR.ɸpJ:pKDU?BQv-+O28$Z+Ze ^/pp8]k * 8ϐF^{ǶmȤ%cvI®TH_>f{GdK IV}WW#ˮqIŨfEmgH0 "ȶm#EY2mok ~4R b4lFa 4t@7OJ$E~#Qd(T^EAd!Y>?ETx-2,zQQ=OC"L&+dA['$Jl';$.ɸPTKxEGjk;Aϱ0G.I/uQE+x\oPuNr*(xKlW"fdaK2.ɸry(1rB] bd\` ^~YIe2Ú1Rӗ'2p8vIŨ֢mǹ!$VhqU<I咼KhUU `]knX.EnWaIe@K(P(Lc!ԻpIHX2VqBDYv.rPK&Q(){1f ݅rIhnXAKe8K2p!rc1J)I,d$IqD"w\q1Md€lbxxEژIĠ"8'1a1-===z&}NE|Ʌ?^" 6֤Ȃ-])q,ryo zYbc*px{]q1Dkk=#Is3DnT:&3XqDBDD*EAeDEF^ ~,oj"]4,%Mq{pp0qBЏWzy=>ª@p׋x^^/#EQ<(#q qt]GӴ :@ .ϓȤI2erdr9r9 -AobON_/z&M;_4HYms & >I-A!_/">qUnd\\)R)G ҇a9.Zy4M+I<ϐMRO,xeq$GU  LǙ4*L4$31XEU$B  Ͽy,tz%ǡP(_Bl6K>'I{_T&G.K `vwNh8c>7:&U⬓S/-i: d\ Mhnnv<{:uGi e*xUb?E*5?pƍSDD#Aꫢ̙8H$r ~W F\ad24LL&C"`Km=ďPx;c}beM)jHXeյwIH,Ξ=jjݽ8{$֮]lx.GAF-H10 Ŝ6pNS%R2o4"$ *iZ㡺> Lr6,y5.) EdLAĠ,Ƙ.ɸvtwwohnn^qNN?u;MgZ8˒+*N,J륾SPUp8L$! WH[nsq:(EZ@gD|'IƘ.ɸhƩSKIM LB]QAPҡET}Liid5#OsW%B,[yoxaWg {IA 붺 ضUϞĒ>?Vw\q1Xř3g~n7|$rxV֡t3SNJyȔ)S\E,D ]:x/aȜE2p8@8~])d2^]kn\φ^ҙLE\c(pocFnZO.:PaYLn dK4I"|>?㫣nkdN8sϒ|s 45HJ`gix\ml̚5 .Â\.GP Q}|)h*##2@Sf &|>ϯ~yٺ8lvYc,0{ |wޥKY&ONt14BA'98(4Q/IBM j&3g8癧} 6\z֋(A>s&;xl,Y &;ňZ2f@o"J. BAY&Nv3\\$cYk7mp~$׽ÖDd*5$Ew*[q;7ݸwq L3 .i %Z1QQB52.>IR?w:x2|> 7M{xlJnYzuug b1$L|>O}}=3gV'Aww7x4Lt>KU0_xPUߏ'W%n3$1և5Q"$SN<`ǃ?}zHTSO>AׯX:5aP5b+UW-fYX8| :k.@8CL>hii9iX68 *2׋Q>,ٯy G̝:3PFr3*E2Đ#/;$ S/]I B$8l|ſ>EwٕJfDh8-U;W3g [Eww7=ĞljSOQ#W(Х6 IPXonbCL&CXw t#-KEDQDE%q/~~ #̘B:̌n5ښjkkqK|>*MPr_eB Əw`\}) g]?%KS}> Ca^uosa#J8{,mgx::-ew2.SxN e?uz7t~]4(%r ɡT^]v8;q17TAݿ>h䀽X OGÇS驪浙Qa)urLBmm5w` \P YN{:Y7Ř"۶[;oعw#r}\y+wv;ӦMvvvǚ's !r$%?@,]`FE)7:Uj f˲HldPq:@rTݹ-%Kill~Z:يX2 Ų$EǏwI&/?'2SA6}~YdIE:::ضںm=Él|>?.Kq,۪=H$;9s2bBirXq;-ۗ,c޼ycN(vu!c.H4Rj$ uI%o^p"QreIr[0jkkc;X}ƻF[.;)\mƩ; AŢ ir-<0hK&fh'~Ku-Z4f<{ ^gz±yɣPEzdtYVGO2\bԑLww㛫zYz>ǃ7dٳlzka#ζђIiژ 2>ZWU}EL(ba PD.)M'n\ 4MzI^dзm3Gۗq[HR5ΐ6X2'ˈ XixbW ,: xq{j0}Ő`ʻ($I>EyJQvHG27-:x ɓ ?(_zanY|Hv[[_gВ͌2hH(xE b PEt]l]P(T C b XR$IL!yodv=dr9ͺN^'H²,4or|;rb欺Oݱ~i4b|^HRGLҦidrNPtx&M:` ]71 Ӵ-v 16Ll4<8]ñ? B !@eIQ$ ţ(^C:a T#|>|>4UU[}>K2Wϵ;r78RԅBR\<>A@|_I"~Q/,#+2׋C(bF< WiQ* ̨ā;O  @o{HYSV#S#QVr+3.{Z۷7w9t0i °tdYv^*&\Hz&91DR Q>nt(d ݻ%|q]h\YUtQGP4f7=y$'t|P^njӱDYjּE~N?u?QBΒE&ȥ3uvuTʹbqҙB#C,Չa/4Iƶ/r6 g) ^(E’DTVzUWG&sxmv.mb{"A&r׋gÌh4^O^[H_J^/¸v콘4D[ǒ.}P )!Μ8Cd3qD+) .l à3B gݺ?җX0oި kԤʟߛڮNnӤBj U&9f,}Th$5xl{ww)*(UUWHo4 y ࡠSGcu$XZ|>?|VMOXgX]|巾xEStcFffy7;oF^ Bm#4ɇ>'2Yf.[y ̟5ӧ ciˆL*kƣ\LQV@;jdx7x5t_X߰]dY&0YUYP]p9H#]ryEZ4kIT*ULiCemN`#Q(!ޱIf Nn'r=||E.&R[ylBl;> ,XCM̨d.Q/p߅O8>fƁ^7@%KXx ho4b$_98(`kD䁇_eʺ6~_;|p`?evt<@yʌɤ&ᝄ%lAc}DjKf&1a]2Ϣ4&#~6't rana񲮳<ݏg|@ 0kz-$㢲3QO78nXʔEsϬh~="$S([dV1)~?h²v䇿|7yd5/Ggc9$gST \&> *_3m oLSY/E]zϰF:q\rJst:ͺBio¡|7?ٳGl-zuuA]$ {1BXNW&r[,QH<8g|mL,W\fY{6-[+h͋#DQ;:SөqPc 0!R"04M6 !{Lnf5myRܰ1 S>s|< wZ="3T2 2۾`&t Xs$ÏhBa ~/lMYQ<ͯg^^x/G9LV >?5󗐘|3]rK 5Ȳ\ɘ8c\6snHVy3+gw&M,'[fJy]Ә籛9tE] $ 7P(PX&͜ӧGw#̙3ld^|5gu]$O$Q>0/_.`lfˬ&TD|^dt#0)68X@~bI2a4}tqs0N4lE-]9K۶0ZZh>~7*֐½+9B޺IF`__(T? ȅՃ^zP(pP|8=ŧy`ȣ%t?lC'ę3cw^1XC2XWraσT3 fT ;O.8.(x d  B|)˱Yӈ_~pr+1vXH~{v]H:{;_dREϞ= oMgZ@,˄B!y<̟:u%\Sc$A{eK nǦ^DUX9]zid2s eZ=?Zr#Mhmm{ٲ'я`og9e{$paA⅗"I 0q;ǡʁC0 9~+dL@ @(PdzHbpp.v ޷, ^)'(?̲=Ï>^SSԘ&'©wަ ,b]/~4e۶[ü ~;ҩ5_Q \WOvRs%.a(!UUU>Ʃ*GJc7Nz+*lQ%^xdNd:t'Jheaﵞ?]+W_-봵qqM߉f{hH>O.CާE$I%)a0޶g;,9q2ς@(%tx:D"ii^qG4Ҷc+zin}'gϞ-VuYy^`o*Yi(׭>w߱$ؖ-[x;ˤ˚y!^/p}~ԛfbWn!0._|5hCH؂dh.,Lg5H-nR=NFY<{'#fʔ)]=Bv<κݻ;ي/f "p5Ptf0Ͳn DLs`ChZEVUUiʕg6}8i'| ܷ.a$sVd7^qN? K Yt7^~GI$f oi6! Q]c^ys7a9Re8Bsp G墕0zm [=lC2i,Vtwv$L4vоa=RYu ^'pZH7`8@[O7sY6eFYn;4-tcHZD6COO(,ϡ`4) sr9:~Yv_h#:>K֟m+& rL}Wt/^| 69Dw2y~XQ9x0w:hms6q6 2ٞ.NS4k1J,UE:Wwx$lU$ "X=8v_zӨ&'~/8vRB^/Ll x]\;u! @ `;>l37&H$=u%m`Fv>/Mȭ9] =/ l+#"a\UŔ|W^0,4,ג}}YQd"&%aYr!"mDWOgj&GO0,q!igGR%Ibyu O%ٳgy9X{!dH4HOhwXUUTWEPx˲mgVOՇFoj&Ǭg[O7LŚU0M U ,[-Le]Md<|^7Yȼ mb: `/ؙ>mZIfmΩ_e]Wg9 03a|aƌE}'_y4kۈ%e*=S"j$t9:7#P4 ǹ&3EUi)sai; džfN@[enFؕ˒JV.EeXxLfm3vbUTMMޓ%~ dʮ* o̞5D3$_*! %z^n*2UKZx]`0ȍ0CWRqlǤ"te6Lbwه>UVOs_D b=ЫN7idl(RfulZ+A^0_3uh/bu5 >0!I X#sXfZdZ̰g[ gn:U^äu]qarA) T$ٙfYӍgyoqHJ&X,WbEeJč>&%I?bR F07Cz@0CUU_WxL]91ŊFsւ&=KK>W4..O8\\.Gg~?T6,曮}s9rUxDt͈?9Lq}U,S2<ﮣlPI&]\St>"kΝ-E&h(ݿGN]dQ`-_pOvbg^~эki@M7}B44MCe6PUmO&8OAg"jb%;Co2LYI@%OOOoaCG{OUUV{nla<ү8⫬km!VHUUw֍G0krVh6a2/ -Q8tqzz7Ng__ NRu1tI*=ʫx.O&_3,ђٶMk*EӖ?Sٮ,^6/2/3AcMsf}t'J$*BnJ { MDm9죠5kmJǑljvx<H( mMyp" øZAW~~qnaQm n3,|7.)q(/Ӆs|wJf&hq9s\ga玭K&&w\F`vp1GQj'0[Ю(%esRzIF2TJNiRl!3Z*s!/Ѐ 8 cXHrR)T\.GR,z~1 ]ׇe)  Ҋ³~?a|J7i1 ԴcoŊV4[<Ͻos)h&ʴ-4DQp=sK_ޤ)/YK$*VLmsfEfxh &'+hDZ܇4+ԄTr4‰C;׳)"9\ ,}>Lƺ183$iWDk2>$;;3:3H<#L LE^x7Vw4 es+M(Hx8_8ēIN?Y^I|7N(` K;7mϾ*g~ݱX>3nۿ՜,v4 .s$bn)l IDATHw g}=>`ߋYS^K7o^|2?~MlNAm"DXn$Rnd-k\IL0ȦtmXPN;q\.<:EGׯӜ: 1'|~Fϒw[7`U#}l"fusBP{AQ|y o/:t䫺ɏaɤ󻫧ߖ\\ɚac,|vն.^+W3r姯pndP>?_&%S(z fӸSm/ײ,rpU/Ff9bqTBc & hyj# (=ȌW6\A$ dܑ޺c ^ 1 դ2| xc"8b-bF9sGEC>g'{n?{j H2VI.WF^_/4MmΩ]^FO.1J?Zxd|K%ys9Nw0. x8=ّۍ0CXCh\H66.D|,Ić0u0$cU0~gQր.DvgvӧM&aqoj> h{ S3eΟB(b44{4H2>@ ;S5{  SNko)dYfR(LG*_d|XEuG$cB^\.D"C )bW>#\Pdr|<f.b1KɕMG3t1uGhO&G%O#IflyjԪI@/5sGr9°[E:_O!! 6i[r$Ng[/OPI_u`A`a0D`Ιk$?Wn=v DX6g]ՏCl]c:u*S60: Kr9yr͠~Ax׾w5T K,>Sd3+*q!FJsˬ+ʑ#{^Q ]le X%w~!sJ)%t.R0M6ȯ+C#:ǚ/lQ.͞GnZ,a8 UX-IpS# $G#1Wq=̑.ڊEE!L-%sgECyAx'#vۺ5McoW'GioLMww/_kRʞ4,,./qƔ>'^f2~t~6#=n7sB!뿁&^dzo'w -İ$IAjclU~&xwh{0gD\¤ _e^ @$ $=>Aߢ|A1o|'kkTVFYYcE𾠪*x_дWywonaC+Q Gl=@=3vNjtp|R8~o>g_&MYazꓯp|va+MeH$„ b#6>]uP F$O1vE(!x%[Or&6SQVF$Xl]I$_6<ɲmVK7xw~ý}>櫗ϟAA 0;V^Lkk+lʱ8l <@v55=gJdrFhՏ=vĞ'Niә Gx=\4k]̙3vw; @m0DdZ ZA33zYeg ʛtE4W{H?DDxlZ iii=I& Q+2ӣQN+Tv ǮDQCe$H Q1V5O$7hQrm`U4J4tF4$Du u~BmiN$8{*Dbʀ$݉ oNګӋ9z'vTxX!wC:u*/\ŒFB$h4ʒOoB~sfT)2&El'`"Q3Z`V O<ͣ!iTU%LOh_DkUshii2 \lX(dyc;+i^۹,GAb Q+J2TU-޷߽brnZƪaM\" B̊xv 3"W2nzp wIŷ}̓'RY6xVUT*Ż.W3 KuӶ'*ڹӜ̀$Oȩ|$05唗z zv@6(YX}TfՄo:fhlmY7HosOy 4Pِ DYzhς6zY|b=O̚ŤUW=.>q=k0liԩ;s2L ,^HdPU|eL&yC9WD,i^NܞEOf&mP hmmIbd oJCv-?=?ƚU.{YDpxf)"*_07rBjAA2?z]jbôV5$I/AL[2eh{vw )IU^͘B`ءɓ'y8_Ǿx|a4IgpzC&^[s|B]03E"*RQU\, \.t5RT iܳE$_Of4wv8 ,./'Q#>'ϝ;/?x$>t[rI+Tf%+XҹU&,S zh\.iبhZVHQ4dIFuB?Dp0 }wYc%IE_* W^啭rxw|>ϩd}PuǸ~.#CqWPIFuL,m~3_u-\AWCi~ijGehZ2aPe9urߞeش ozM{/6v)&.U90cmmm78_Ƕ.2!EQx>a*,P uu3L#-B7M,. ZD_ YJu]'],w^j6L[Uxeюi}x2ֽ+YLeYO7,&!i#"˲n~:ndG a~L_ ӫ<՗~E3gJ-Bu(y2$\K21T!@6[0ٙzӴ]שIg /ZFXu҉?y-|>>ҕh6cf2~:yr9N+ OeMe!%C.Z*)}[(%RppaUud7PΚgNӓH8_l\/Rn=>Ma"ypO0( dz2)q1YŇĒ):rYۗ ~sYHњY,y78?–IR.m:=8 LM"yr5cQpUWFл蠳X ͎a`Y `H&"t-a]{q^P(zGFxe!ЛW1J0 [ N%m <3!9qyi;f"Qu^W z-y'ҹܐɩP(pQQ(Yߘ)+/i-ɚmh*Ɏ)Erܰ5Z a '*܌3$[+ggAafϿ(Ě,lCbNI#y^$}y2eaz'޺an$ ì@ ;T~ $I@7؛ۖ=x<̋Fiz9կaÆ۽n7RVVƏ+2TjؒኢЦ(Nǒ.j'דm\MU1Pd.d[r6ᆪP,)at]'SUqhiȲsU fbOA~G}:L.UIr_ bSӇdBBaU(Ee*y->]nzY-_ϿիAEQVVOvdrXKХ(|O|@z2ܕhhidjlfqx;vӝJqNbitj*є ΡST<#}c =Giu Lc{3vehgP(U Ul\@E㿍&J;ueˇ?ڱcoÇW/ݫaѷoeVX1N|e~UC+ۿ{J8p1œ;{D,Ge$I0 C0LM#kL.,4@QTUEU114HCbuxה1B=W/hi 23ǻ'd ҟdkFQUE`0H6;B`0PGM]UڥCK7޺ے>w?}uNORp8@6/%-[fw/HUY WSl~[D 9Bk:a%>65| _ 94t,YĂk:*N1 i8tCG7;Hۦus7ق@GI68;Sk8xOInTώF,io_fҥ6?΄Z~XWE٫of:1O(2&( ])vw#]-b ]xѣI[xxjo>WœH$lO- IDAT^Ἢ`ZjPMP-qC b^&^ڕ ':?՛|=ݶ`&yM~0 0| x}$x.ɡD$iY+%_e3gΰ]bYqj0M 4>#_8G6CUU"^[_a p"2DD7C n2Ҝ%[!T`:_Y/C,_uNo33wr2lv\ݡP5"] X!34m1Mi0(,J;Mu\lv2L ?+\09m%Ȃ.J;q0%7nGÕ;h!zv 3+/geȲ̪+#NR&1Ap.\|dȝ@OzfVUQ זvrѕ?x m-Y"Q-_/=뇽zlXi`,d|Ar5; Gjdj+iOwiz,T07B5O^An-L6loRu\L]05 `G񳏶ryNlE"%/>sO>mkLp`|/i1m04'ˍMϊr nW6lbq{xj(i*)=J?maOD|nw/t$zK%y`a&v$& l2y/ nHUE̙_66x3mﾣpbbxtnA$|^/s&MAXM466.iooGDFB0 . =) Z:XC>j%+62Rq""̅-h!e$J4.y\aӧٺ}{.^ghE%gOWef͚şϜɕBط7s';ʒ/(zyaeg,;ɓ'V4 PDFoL*W_ZQ:(o5Q!"MlQ~.͜L*6@(P1^'kCur9r|aY?י6mذ0zygNL8uaqNdoJ g$I\.n7.7ʢf4]iZ´it]Gp0:)"\,JgeԂAQpI(?%L:2"D|ui7>h.m_8t?ɇmm&eY1e '7oޘ\X,Gֲf*._s F?qtB]h7ʌ^%ٛip;)"$,e. ީq-^)iӦQSScN4|nĬ_MӸNVPH wA{pf<!^/($S#JpiW+Kuww֞]\?a(RҴbXjm2 444Or5Z[[iiLg7:zzBSU21χ  cMFkY:s.SL.{AUUF̓,b*Eϫ =`+ /If,ɨVT) Cv8!M0U+a}:b_210i e>vDKG$&^fr ڛ4T?H "?H4baDF\gJj00s &r^QP@ ]Y4L]`\ntVAkO7.]&N ~:oE#FLyxxw([oh#\(  e X:7N&4157h$qNo _G(4){<*ƀcCtwn+|~2h ` ғPUU0Hf3ȒeY\Tx.] uX*-`.(ܙWD[ Prx<\R$ JS-ɤUi:::V:ӧEHY+V3wnIwНMc[ȅB+W),}YU hKTe^/k{,\DIJxi(-t=z8_a9 nJ=˾ky#2h6$*sY[)^+y3uMBؓD\,xM"gA@$JA1Lj؆ap9LK DuvvC\9w_ ˚pg4j1eYd­ N!S--weS#O^D ˲M2bʪ{23PTƾp[zER-̎8ArQ3NY$Ô?$k_'BQMC`@ @yyc)fphR2$"{^ºrv ɜDۢnYƚ6X,@4 LmO1NM@;(h*zN!OEY4fW^F*:y$3@@eY$ rǎQlY${l_(2LvTP^^3OF01rI{Uisi;}dXQIË 0Zҝ*Iޔ9qdrOg/_R؊*P,ھxEQ$GI;Jg0-t.MmH89%I61.p$š9 > zc9xTy~kk+]T?e`f͏R___ZQ%ä-+EE9syx.\  kfH8d:\.U|Z"|4Ȳ퐈q?wGY_ZQ&E$Tn2L{3eh;u̎R@0NpwD2w^d6D].3o'?#Re@˘|S+.H}m%CdΟSB2lZԳD"Ң"4MCH%%EQ$;.#"g-5_\G(}IA("ASY]~;ɔ* tяv^Ʋ,N7_]e̵$YvY[]C̟?S)GDQ$9NZEpfYLΓߛ4JHSS==P)"dYf8]ʣ~sYtFg$CixBqZ~yEcGr ˲8q4¡bjA\kJMdBޱ'hyӛqQ<G_f8w"iQGCʼ^/s9l?v52e;]~aMEGǍ뼾c_Ξsgh#qzYUSˢK5kViV!(E_ y2A2 Z!V B:b$Iw1I{rq5SSSs' Jz2n;I1aJQjaĠ9m|}6n Z0ZްҺOTUQ5aH),^V5BРoEZ.}{_PyΓpطtLӪ}71vv M3 ˊ,#ɨhec ' ˃g@XbXDS5216Bkϫ:,8qar?@O,\P^m}ӎnC] x,ts{w Dz,,dbxEQ-s<^/c>HTN}=˵]%~(4M*%$}>|+VzɲbAQ W@_NNԚ mi yٍd? Ug&t!ݽD~v xY7ǩ6d\].XZHEEl%(VΤ^$IbsusK} G=2}I TH$20k:b>ǡ1_=E|h$:}?l2Haс/k(D6nSߣ.odI5@8ifiXDU͌ډA2*ŌI;'K&$z/8zt aE^(~3G*eGa~2^xv$ral3ʧ1q~_#|>dY#IWMw `A"7[HK8\ͤ9~ ]]]TUUs x2V>d" ͞hD"z zG\u\Ⱥ8]G>&0cl[VQg;Ogߍ6ZrA_x/j:siE(! jYT?.);vyHbiș-0V}*K}'qCf OeQe6eee*m7]==|I~x󎍬@ϻ"= ~}[/BA]Db_"]Ȭ3?2@uY9^م(}ZQa@&U(L޴Wr-|>ϩbV5-&>=у(<z,ʟ=7=kj4I&)\QGbή%腑7DGIN}SJ+c h DQ*dWciJmelj=I& #y}L!C2RtQo)vS,bȎHoϚ7o^i14q$BiU!ii<ݪBxFo"Q~cxM"{¼}K9cy?WsB9)({#".]+C@Xw$Y"|rXSkL&sW+O~ɿ2ePb% \jt^N047F(+t;#$+$2Q&%k&fe92&1UВ"uBQy-WQZZiNnEŢ)N _sI dɌϿ$ai444ZISדi5YYT4Va!^Z??WXu=ޚ;^j)l6PbQ%/4&&W H&Ct:M&!-(kiaϏn /GA  \&brsp=R'[&gi3xzj|>=OrUwDq]ulݴҍ0QpUS?g!;߲Ks;/5ÛpR>icF9PcZ_^ј0~ݲ, B p<3=^jB!dFp15 K0uSUA4uT]G44MCa I(++W(?d2yy\I>5+9sdѿ ߝqd/4 "mJV؅@GYu,f`H#?0r"ɨFցelW)*M+}ۣ1qeYc  H!|xg;eYXaEH9E\.( ?P<փsˤMv ,,썹czcä:jB~2QH$BFФ0OR :u$?%^,% b/w[pM̲ۼLAkd @UU7 \.w+S(zD c SYVokRTQx-*Vf%YP߀?Vf4B-|VLtr|z]þK 9H9 M 0#jYmAaiQV6xq"3A]AaK&aY$<Ƭ̘1R&2ia\Qd3SLA&9i.x/sHv;ˆ VPyQ)F=&`RYQD/2cJUx͡,_ɳl75 ɔ#Ob(]:&f5BaGbs<_'HsUc BHyA溺%3v)++cq(̿/jElX;.n^L93sLZG_JUUĶK`[a: >O^'o6%8,UӁ$-b~bn DX,F0| JAR^^NC$ʟ!Wd`synɑ)[׬w6?Tg$+( =x!zɯ !^i>̾_;[zaB*(`1J *-p.:V 2P B+<xi^(Ff1frlU&M3~e Wlf2M3,Tt3UKzj",TabTTj҂htˀ! K σAU`cE׋/ˬ6LTtG%eJz/3)S` /xn]$3ajiy;GU^=Jv֌0^)IaI&F"̞=Ìt^q xZy\3.Kp-0"E,Wa^7ؐSEmD‘`XdK{;u??)mc*d g1lG-UoYт@$vId zGmXmD ,eQfZXպE^}'$H&i10i1/=㢡I޿p5u.NR)[⚓D'8 }es{Ȝ$ onkS/{p#]G%'d,+J<0m\ytY?b 9eHDo>2-21_9ox tPwi;X<{!+NNU{ZX63t)Š|}ZGe"SVV&( 1,.x"A~:BәsSh à.;߳F4.MKE(~|d]y5w\LFvΟ^ʎpWzÄ`B/@9X?;J?O'Ongm Q?KrhK&3rn.0oιRXg {?@jf ŋ1Jʲ-47odߣw6lȨ(lN%StdX oX-odvFnYu\hqN),,LcYjfZqk'=(^ŒWRzBcmu;TN#39YI$" 2Q1jJyλ"pՌ/ݫ4M JfB3v 3w Mb4=$Iv_p7|]̛L&IwHe(VE1AGX,%w XMLEf0w޳$ >hڋ OjJo>ӪxT_y_h6"m"ljxފ.H3BytW2+b :bO"rp6 Y̤iZXO~92&,YY*{U{:rC~_AzfdI$vpX+6QM(T|^_閍5B(￿O?X>xGoة^O7 F m[+`r"x,MhNKVUDږfOv4$ @RFN:^p[kF$ЌhJ"?s 3r,oT^gx<l9.k7z1 񝵨04aj9J"js{[3dDGұ#;ζc8ﱯCb8xG2 :\["3R 4E+{<,*bŷUh9`"PVXЖT4BND$caHZ!NfjtUϻWĒINFڽO㄂m(B6l6r4VtfaRUhfc^ ½w#O"ޫ?.gX'Sf#}b@V0D]&2UN ITA2D4іf|Zj8M n@mm-/:;^}5'F3%I"OQbaw(l$ Hi ko#999\@A T՚ &:Y%֪'*N,wE)>4M4M9*$x#9Ķ9qhgMp:\SDŷ_W^o^C4G .'k5z$", 3JY1k_0ez0udj90zjF,q[!&ܷYX G"$&d$:DsU1 1bEŌ3Ko:9z$@(DC2I"(s;vRE538 K9^E0ΐ `)ٙǜ0 Bp4FE~~T3Mh4J8& hhibωc4tkD8rH[+4*ju~enOi4u٩ 2riX5wgu4 iӅܫW%Lat9PSŸu]Vpl̸%bNY%'x M4#D9D9ՀzC()CWD L.)p`q88NYc;*T UU9BsG-tB1$ZRloG#F0:QSQ1G2d)k gb6"F$|3𕻖_ %p+79KgUn>U.:3B!;cK(D0hEQDQE(=>?ߏi#v;jWzibB"  d#@W5t:tV5Ew&pB̪xack2QcYANYY%wrx{y7 lQVkFiMg\XS!{/ \ 0 RT(-H$IxAzuy2 KI"`br wHxic[*,6~/@eL)CU˛j H4H4%Z=#C S>ivTM%%WY(rvhF:0AE0 "7׫i6Ƈj*=ޣe_+W_eop\t.u"^d H)ZE# !^4ETO$LQ N[-SdL&Zqxss1jJJ d#5"0nM53d8(K|ϡPgԲpP1{*x3fPn*..nmq=BϜ@EKfכ&)9T~>B=L=$k9rLSIv"6, eP"\rsN"&hݘBWLEN_%ILu]'HjMfY30ȬI;]}+)'O?XraGxCoj_:!]Ƭ. ꭰVE/֍*9D&W"MJ`ilj}$;'hTth|3',9XBΞbΞbOI"9D$ 5'&z^hD&ߦAEQސ%nD `GGqGhs~&TVjWЀ,_u>g9a& * v7ДkZ.ѕBY5H0b ƙ)d5nGJDAM"5THkiwfiCGMqO&ZɢSQ$ I%Ŧ <F T]p`TE-l"q83j/w>ur,kfq\ 5E8k)YL8q }>> LAbYV6BBM ifSG p0t)) ȧ]]CkķZ]QK,V M,x&M3BWe3?w͘9$Zg)µwnu>D,P(GĚmѺnLDkUZ\c{Sȹ82ސ"YH,]rBCm@(WXXqgƔC&[^q0YA6֟ ݺoa11!I҅)J4HG6Dv)%|mcC_v)zt9)LaL3I\V~XATV0 X, OB-FSŗ¶}_X@ p2͸~"NcHGvVXMg.. ޮFk,֯ a+O~D "$"m,.^PC=dכNQ4ձbEejEOii3g6bm-mt)ڪp8I VŢNY粳E`0|>S\w-?ɏる @NN,#ԅ$Q%NV6CZX"D"epQ4vvۅMli^Pt6: BP" g?/^9lW,\/zT?ܸوYbx L0 㣎8b6(l(|>__wm2eɺz_.;O"- H_1Q=?}Y2=7o ֓{Рg5SH-)bda/r~϶P`&j:7÷h-4tw0Hu;lg rRLzvQ )X{;*(.(¬ʉ슄s-zL&iVSL7;O: K.0C4{vCiIyWPАл;dbhi,KgΛ?t؈Ay^rj yKWpZ;( 9iS+8HstMR"LQij+@R2-Ҵ>=p8PT OTvME%Sw:MBv1[7,'բOv^EQ"SxX?[}7fN>:_t3cƬ;rv"gI4MX*E{)JDNeX i4}"LMv:pΘÔy3+H)" I3rϤi4;=nKh2Ex®Kd`?[(\]1)}BAA]]X g]}4Ģ$Ss M[it-ǰb4C~7Pc(x V^ۯqĉg͜<3ۻ.c47ҩi UO.&oh).6+4yƠ=6-;sͽ.`}(sz4yߘUs`(tVי \YVN[$X L*B+@-X ͕k&:m|nsgvtd|IT1|& 6dFr9mz%w0ca=P뒊L?enyTC=|1>W[eRJ6X zi#y}N( EK-okV>i|eg9kh&r{<\ܮj8FaS#b$K5X,֯v0$I(;u yE_6tX ]X5-'y5g&!Rgq ,Ϟm^R ~Pޯm$-+ܥj,FnIU§H2" ]3*/2׬rX'2?G~mD">f/μX 2 'Q:w]EQ(Ys_K з~Ϟ=O=MՋ/I[k\.< /i&wgU$K&Q#$Ib؀MYÚdr3~N*ǏQ'A#2xuyWO9'fQ0gʯ@\XX\z[6peev*7Փܧg_NNӉ$I:4AdnaX=ydOٜyT\1cX,2w6_OsTΝ]q~?LmZҒz AAOIDAT[:H$-9@wҊ?ng|C,y' 647 ,`p:v$AR7X6XNSh\| u[,ݒH[XRԀP2}L6 2vm>_R KDϊQ$~Úi1bHo~-0pO)E_w}_">k~qޯ#3]Dv%%FqZǁcAId,Q-hN*"JiqvUWrWp"PSSc_q߳OA2aԂtZh,Tɩȱ[8y~ceN.c2w.ʬ]y7;>'&,`ٰl(4L * q;o ( P%TI" H04~"y˖UYrM[1EcC=gy>NBE%Ͼh9[(${|XwpO.\Abl U{~Q#̟D>xCA:#jzEQeEQ$$0]|c`@DhTA8=4m(cQc].fƶl+-ʥ/j%"LWhn|PO. Y|w{p-p`"VEF&a-dK8LI(X>u{]2},~k~-wng[4rޭ3Y$ Q$3 N{~A]_g{n.Ri/sEZp-SO qr]ՇcpRLY|9_^lPlNǏ7{wU8;VGfEr1颢e2_ܕ69ESOxM_^EQ|q]M9xg~ALSйk;qp49t#mT*m|ouDbĉMOp0%w\Kp,3Gz0E  o5' ij].e瑘qXkEXtc"m}m [/,󱲤?yϠޤBp7oaIb#CldYtRp2!7yl͟-dBegva"]^{m'9P!YzLLīP95#Z\z_aW{+mjH$%4 o~25mmmo۽sݟ>Lb_;z]xgn]LDQpp0[>٬Z0s0zh+bgsAiye6v |^Yv3.#8fls#ٌg+inE׉d}%"Y>+F{M![`҇Ӿ;Nk2yA /$$aqv;a|MEK(++_,#`~y7/NdP|&NUs vk cqwSĺ]E}fQ3kywaaR)wm=1w젭O#aB-?8v&ÜyO.ƥ+(/[,̧֌Ap\`j Z1{78RSqM%gLRE/+G·v-ߺL:uXZ_wسSMrt2/;cJ":bHށkT{bEN>s1GLRkkuuuw}N!~QR͍ 'hOk &ҽ&(e0֦Pp ƎC`̘B.Z̄b̅C4n>:4̰Dzw4s ɤE+q(hvJUINh*h4cqe"%cǑuõۿ{,D"477;~zB(jk3A(I('R:1 ixz. A (d͆@0sFaPfS>vF2,ttt,n⫝̸ܹP)=1,/i ̱96-oKj>2""~yV曯.zkpsy4%P@mk3XX"@`c Xa%2#UUon`D2pz n73K'9a)9ZQeac7:ZOϳvp13׮+`zwd2,JmLޫ5Le8Qp8) zTUgxqIb~5 t8n F CNU[:0- hUSm:btJYDiiYXX"7:::}-_Ǧ&ڣ~eg)6;Y U.&%ab¢jޣhDh:*^WN$g\{-ӦNQYXX"?Z[[~ wm|[>bs{XyL"J<B6"8V<'v=HSj`)x]Zuu̜>ÊXXX"30455/Mvlފ#45ig(鉁B?T>h$T9*TXt;O՟P$JL&IRN98V֫`ѼV%2zu6p0N15h,4%U XV.NSGCش6<; p8YH&z^5e\UkY8w5BCcc-xNRiy(Lr΂1$?(*a=3ҀMFT*wcOf`͌qeV-c᜹baḁퟜ|Ml1vCDX,+GtFl9] +*y$04`" d=qG8uPgjd 퉕Mx?ܾjΘ%8V KdD/.fnLETqcga+%-zDDM4F Ɉb`oho&ЙJQJ݆DUm+o8Ț8q72r-faa$Ns s|c7鏷Rw#awq)5SQ(%m6N/3dXҲ]t LQdHLLL#`v]F@C;BR0dHZ]7h1t4u(8񹅅 2c,nb-EEEV%2C`0Hѣly~rTꂴBt%$IH0P 9_Vp) v I#*6D6;Áiw`&2A BM!uHt4 S0 #R5TZ'&1LBI00 ]O^f%,].JF!NArn\y3fY| Kd6S__on۳v"vjmx"A"{ sEt?lB`gCϟ\{-ɲ`EE^>Y'z:,掟D٘撟oW,,,JGGFGG;BS1Ht4L"%YU :i0zsYgf\ 6QDKp2nE&Hbw 98s|fZZNYa1YYY~ 8 Kd,.aF"zF۞lnDs#0h-A,b,B#gl+eLv0<IB,YA$Ctxrv &ZXX"c1TH$DѧUU=KO3I4Y,EAl6_}*r$IHt0Te,k¢MnAV<IENDB`OTB-release-5.8/Utilities/Data/Icons/monteverdi.ico000066400000000000000000010547251301006202600222030ustar00rootroot00000000000000u*u q=(կ 00h͵@@h 5HH ``h(mh=  00(@@(U7HH}M``,Ei(L h }  00 %@@ (BU&HH T}h``  (QPNG  IHDR\U0PLTEDh ]16mlDdWtRNSHc.IDATx\=hIVb8<\`1g=<ᵫmlb[nkŭ`53d^` bQf pG/9хpE{U]U=X[qW~jZjZjZjy[Gq>I)W^qS0U|Lh l G@0zݼNH߼Q$=Md /sӿl ۹êz,[*O_}x^& /SI2*8:Jn[sClvX 9@F@ /;Ҕa P4$eʴA;a}@Z?Ld~HBuXx$d c 7ZUe` 0q,nߏ8I.aqĨ.Spm0l ƪ $b` @磿1 G*l2(`\O$'B-ɷ㑩K26KGu[e99DbN'LP*-o'AU7o.&,nWହa ^~%4Sr/>³1$z-d|!s$ڪ|MLNG/gP x4yΒ~_\8ZE>Ϩ_2p@8-zQO8ޙkfG-/JH8pH`3xQxQ^qah}0pzPW_^?YI:S!p&a vcG ::vfB&|kTO=!Aqdz ?|̫<@d hᷣƉ{Dd%~k3o:e28(@V88 +@]E\N cF\*Ml~r*,m'fIB|W HD0P8,,0Iha 7[ÑןfSбw}@! Bje\$:} ׆C!4='p<%A1Hxnp=KL`(dG l%!4&ĩtFrmIL8.IjPLA >p36# p.dy!H1B9A `5tQ`.OJ?:"-IMete[)!~6 wxeA ;~eLQ)Q;ZȖ2ؖ䚢! 3j`py.ʪ eu]0-6c;[_].[h (=\Z;2 w\A2a|% e 9,&#PQ>&Zr~~&.̬@.;]@g@7_s30<{BmD|uv>;1J3#YIVP4tq Xb>j>@m .pA, H=ReŪ,(]F4źMVMyi0D~!)]@wﻲɠNದ @b,N8Yqر9@,أ@[ؤ*#(M;om8\@cEϋh>4Z",D.l`e 1'I_kXl NQH]2P.CM& rƾPs!Qa.lgw᠉Nv G!` DDsĚ 1==5K,H^hЇE!1 2-7]p4Z.k@s2DW  hC),1XwT~?|\ 8gf_55i{{{lqB بs\ 6U@&Hǿr@ @.Yℬ"zWƙ[?2`B1+J߹+ ZpS\1r9%uqӻ2b׊`X2v 43nM1vUe]1?bCM\ 'e[1WWobpFu1[h:V'&=W_@8AP1[X8,Z.мL yA+(v\X2"N%QKQJvW8Ö p-&7/rZ>Qũ1?Br@*M @ⴹwh#,K2ڄ%0U@0goH}%L( 1as[n 1'.:9'(8o$ˆ#ܐfF0z^AAөsųzŅބ+6G3!r1ZdзemP8|u^C퀧sR.XU4Z-`g~kV%ͣs-/ ft1 TPa[fܦYZ.]'`iMe}in`[2SALnu3`kRn ܚ*᲼ ?W<<%O{)BA Lv(ڬiVj!U*A*]8Ny+\:[!swaD+9])Rx!JcȈUݐCH SXEXv8n˚طS ylU. 쇐?8#%T0 N0_._6KŢvJWt2&jkҊWőx}|a~pt d/#e+^6 g XL_Q=PdC@TZ4݂ u`jȦI9j{o91Dڑ?ߴ$ ֬pk̗5*  6MV8o~g (6?\ / pv ̍A T oF@b' vЋ55q ͳQkW Eg,++GUK CEnyA=]$9a IDATx}{Pיt5.%:65x9 eV(kƬB`@7k@Ȃ| +[Wh.+F% Yp%\udLc 1;V )9u+O~=齟#"7tuܿc4B&՟Qj+5.I 0``@ɏ?(5d)r ""cw6=T9& %`( {*!~8!Ty$ D@fODĉ~Ozs}"vgNU=B0u(kzyA(^7"Itm6 %LL ~%-]LlX$~ͮ?/(P@@؋/?/]n%`{_/>߾2ωd}@09`]mRǿQ~iEQ,6pHщї.31LI@/Mnȓ0h,S-ϯ?/"n8!HK'~ ANCl5@` L}e3@@%& C"df088X'j>4KIh.( ؈l`:sYL  ԆL}Ug[wwpsaXSO_qq{y++ij*,m6vV3 W0SH#$ ii=e+-,94'z1<֓tz.bO'%5WtUU3fL$`J8[y`NLupgU[wEoOe4O;"b.rM@X W8kv2EIp<ｄXoE08P' ,۬_RmB'i5l ,Y41\!= w&DD>MlKBzmwF\7$ N`aSGє\(08j<ǒw„񀒀.d6p:IOQp_O Imv2Z:S:F6ޔp:sH(5$fB.>&<8rTz ^]3/b}U荽Gzz%FU*b;NG"~\שD <q⧫6?[\ߦd iDFhɬ2Vy.NEm[8/T.MU (=u򀙠S' yIN1w7bʩfKG69r0 EݽZ*q,C2n;``읕Ubǥu0Gwmr199®7_$0Y_?~+xV}=gtݑnLLdL̹5%,,Fqy1|rΝv|$(ҙf}}3:z~vqdX-})!/RCsQ`pLLLdh֑~LV(s9ǵ@u(ARq)"0:s ':矛4Yl)Eӆ3ʎ:]'X^s1b6$-C`jBE\fIPU8D;-H}@&lQ~qi?29Eg ؋$Қ##PbfdFOe5ǡ O~C8Kr:-0J" .y$R@B α %HT#]p3_,4-M o|X\8_Qu _*9Wׁ~\s';8A Q4=¡q_.L3D3V &H~X 69 >G@- W yTt#"e40d4L+mb`N=BF t[JyyKKK[SrT)%/}ctl2IGx)ͣ,ӐuI 5f۰qyD]hLU\DexQl+DO/(M)O:RQ6BIzϭ%X^|o De gy|)|z]R]LĎ--):iAQ^}冀kJZ^wh&{&FM/JĎ3Z(<̳Ќ>Nd١JڕNDD_wOnYlр`^TK%[_%~^8ȗVfOj-=E`l?T7]2r}$A>I~|B/-5*Ӏ=$Ӯb1bruljll@˾8(o)o\1`}~ `lOQLۮ9UG`XǎX|UHn|I(//˻.}kS$YÞs5@ Th k8[XPXFIJ}+ b% oSo?@DQtlC K$ AF@,ne]5>I0j),oD ?LE0Ѝ?6u]ҋ(YEqI£KN1"'$2cϹ_" }z@$.Y=퓀fsEExA]⟝ʫO2ݕw$@ `Ele4|QՅw(;@(;tR1Bv_9 Vv+U]mwh@l*Ph8v§WuLG2/B9gM,٠|K2ZMsT7"/d9#ޅ%ÇX(=hʱ9D#WiLxhY9n=O78 PT%Nc\, $24dn9ӫV]!DlʞS‡~0nPKLkdH*3}tHӐ]3YǰՉ[qu?i.kdϦ,;!+UE6"E?4 d,J*p1;'}m12" brXh,ŗߣ?Teh!! Fex6` J Ij9@v't fJLV2.oQpcah|h[~E ༒Q.C]%_"K"z X3%wL 6GcjPXv):T'h,ݧ-SLyc0 ZDnBП" .8R/ZNaLN\&@0C2"h ԗVLp599^IB҆ ܳj/ ړ*v=^l& $YwM7ت3yoIC#4 dSLmMACƴ# 'pxPg@xYU@ J힀 4?r"`nxK0RBque_ϕHЇࢣjlKk[#؉&3>xN0>ь, h\H@ĀGJKݿ] # h!C!AYx #FVΉ̖xHU4 tܙڳ1ȝPn h!֣feV pxY8z Kkxr 5*GÒ icg^)Arφpk |p*W x`[X%@^_{ӟ鷺4p0t'Q+@l@?ND-^ @Gp\xXdpP:ks pce;<cW9yWȅyّhIeN蔼\!uH!d {=% [?57lMI#tG)yop Dؐd(؍--0b9p~-kDY )-(Kt~;%/ ѻ ֣\<~7̓OV&clW r\1sKbna9Q=rɏ$Yѻ+Pt:zdLC#g3 jEQ*p Fܫ@|yK8?1${g$ S0׌ά;& yX|U&"ÞV2p{q!b[ZlY;" tlk](b_R[ޞ0t7 ch.p@wlp7SZ{d"{TlV#V' ߎw$(56uc (G hO2ݭ'đˆ =e@::=PAxnNS~\+MiݾcD#Su'dq@G-AR h rX@,k'Dl k$ (@_9Xxa'bCwa pAnb7lGX{l~!$ Q"b9bAcPta&e0Op.@\ T&AEՠ1NzCUGqtF! rdw$ P,?OpeB7IE76gb#iXx[ #? %Q hn7\H}'wث2@oqa!8m$pPUr KB,-= ؤʞ¾Y/ԡz+pJ O鲕 @ 8D::Vx~ xj!K,)@BSD ҧ 'ƼUQse"MēqrD]R I](;"(AlfwQUC1.md;BDzN bH?o\ȝL >)ƣKQ<`RnH*4,/?I(I;̀ $$Ke/sbdR7'0/\:XZ_=qHԓ7*pFR(@\ {D& tqT{ /3xc6G4f3Z0Ǜ?iHo+}9/ F&cݝI6H+ͨIQjc.*p1GW EhC5>j8n)sG)fWrQW]+}-N5htc@?NtEmc`@!sBJJL@GXNy +lUx8왁Go;KRw>$#OzqCb2>i=GAv[$\;MV6-ZfG H \]a73t-^V ;x|hƗx 1?M*ȋo9!7ч7vb>e.*B.8kGb\ϸJ Q8Qވ@ȣ7 FQѥewy5E"JBB` >ǽ&UCRq,:@z?Y#@iςB_!yԽQnh|!<񕅡j*Au,Z"/EEBd(Z{Pd^j}rqE8uW}EtI &+AphnN&X>~r\w  1@JpGLOV$ۻ0? d3iQ XwtoTJ{,J BS|O[Hp߳X8ϨO=/se}%^uiPq)=%=@Yv;uLxz0WHcl܂.@ 8[ݜ7q'Vع jE2#I-X-4#K9OUᦁb"DHo~ɡn'Kn#e@YP!1`#((l˫W4;V4ՅuNnӄ]N84`^?Ad@;ܵ8y)?y?iHR(BrHDNQ*S؁kq/ ~%@13!0B;z8_wdbNr;T]vico"jxDN)gqA>'!/tDŽ|M n` $^Q ˺~@qi>Ĕ0Y}n&hI~g,҇IDAT0۳f\2P!U-jhe麰@H陜={ddEس'+gfL!J+ =syOx 3{l4DFsDD҇(n'( +]~ k .8-e¸MX_ڼf8Vnu7:`v '`L-)zH4Km쥚v!K߼zpHد#F&7PONj/ /rW#.|1Ar)޳. @nUf=iM"۴ *oWn7@#הڬp[4>P3\'`/f#g@߿nצok,re(]40` YM]B2pbidoMƧvm+M\^Q[aAt6HERޖT{n)/hbI=O2%'L#YB ⱗ Ksҗ)2moUӀ)$hz89tPE˥k7e)@q]vyƪr8e| C2}1Bk[>RL62nMV޵>55P.4V byƽ g2SVZ`ENjHYYzzzYȈα5Sҵ OGE 8o|ͷD y8 "t]<;aXvB#Yx`=SKӼ;HO/Cl^ZQ)q pvӀXR\scO-[L.%b'-mцQAg1f[0Y:_6?>VEU?i#LgZRS6sE @xx8IR=iȸ.~zs9 *zf}4O_sd 念# '] "c MO{Ċf` se7Ϣd=3}ȅ~~쫇%Dqs r^1b(.#(ggR# s9%'n~qgĨ#a)٬ i?(>%'HEw;` %{rq2 o9l:'+=H]D,bfx aJfd ɨ^]734\1ub5&x (Jǟd8*a$M0]_ycF$r_ mVS@ T"OVמw S+8}Wo (;˭7նK;SK+ v=5h|ڵI.V7Y-loe LE2 " " " " " " "  N{o/jIENDB`PNG  IHDR\rf IDATxwWz{/m Cz7?GZiWnC{qq{wbW8rhęD㐜琄#thoWf{Gu0UEͪWUBHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH{!*BaI)>Yk ֪q eSD(BV!i[ViZTw֭,+R BH!B"`jjoj}X @Ȫ:uϦr(+_J֠5ņ8c33Ik]^üd#eugάu,B8(@'!8NwX\R"\݋| @j#-jJU8|PXYU4zH$x7^CRaUy)8u!z /iN+P6R nm W (CeZI /P6B@B6M&mⓖ\Sp4)CB!2QMBlVNU[Ua:I_40duUkH$Z[IYV $!e $bA!PruץyCa 5L3tmۭK=l&/TZW@) QuhJP,PTAlPe2I4-ϩh:H4ږP@eD0Ls\ ChBp>B )zXɊ~_.O [ j!Z/uY?^'˵ڶeZ !>WHtM-JH)JB iFby^j%ϝZ݈T2۲ iP_ihP,PaYV8RMwnj }y c˵w> m3B6%? 4U1 1M3Ze$ H۶1 ZQeߧT*Q(( UTVqVU\qu;uBxCkDc1 P(F(BB ڱ>p#DEieJ,oXݗpEbfDŽ_h$9dcJOu׾ƍ\g~Gd۷jQ2/B d@$@)uvc Fcnݺ`vv6,۾ôVԸql&S!tM @L=Vú~pHBp.5"uuQ>]k CbTy)Q)Œf'}߯=+WaYfo  )As 駔PŅ'ؖՐ_jVAP*c@!aYVBJiL#%1CBLhBk˰V0 UҠBK/{& RE!UPRPTNi]0<5Jh`r_>Wq97JWr劚KJ^/(K!Q)YgYVArJ+=Z祔}X,|n@Ij#KT:Q.s5/RP! #bfSտZkTuv jQJZ* 眿#󿜫~iHB7 RJ95>Rﵘv5踮fG ÀH(BY5o]-@Ek PG5Cm$Pt ei02κTZNnz;Ǟ5Ml˲-H$H$R)RMͤD#.xD*Fp#.ű,´,,²LLĔRʏ9887A_|R/=bD>|r ҙ 3LMO3=5Ezvtt&Kqy~LP. kS>PE`/-2T 4caRv5%w:`+0:6fy_Di8Mu1LqF4REGW'JsK ͩX uD"88 X,R*( r3LNM29>8c>}a<Ա!؎icrr2R(\> Y 뮻۷AgW]]ttwEks3xdoضp0 X,F,ViN 3_ӳu]O8bbmbV`)ҲV۲-˼ڵH)Lg2ݓSSV瓍c7ˎk!8hèuBV#U!.ĜTd}zDi= RJq~4LF2?{EBJ4h-e@-9 |cFVX&`F4[LӼB7=S4 eDQZaM8CZK)5"Dz!> i-X.k`HbכAmmE-, qF6oU6?0@*]rl&C yjmFLy(F|2X !ٔH|0~o/".2M8ݬ[-[uV֯_OO_-sO}5(Ju籨nd\Bm pE!:Φdr_}ueM{t|"+E] 3raF*H uᦛn[n{kΦͪJ8i {>>8|6lT24|~-ي>8ڃњp_!.iIbPZԔ[oB:]]]p|׷l5?2%ϣT,err4:݀ObN)022%a8}mt&^ĘaI6o]w=Ϯ;D"5S 5bL6$C'O8p#s)&&r< PJXC-POLM1:9Y9[۲E"$S)϶[~=kd2N,JΦ+U@qQqT'2MaxbX!.Ls 8_̤mT=qo`ޛ\YkMP`zj3g8vd߾};!gNaffBT3t\.7Tj2F12B)><~㭷pd"A{{;kְyf6m̺k룭x<ސ6r)6#;Ǖ0-KRNJp B\* lf[7AR)YkBk{;３M6-j<ɩ)N?΁۷'N0>>l:_.74 ޺@#u%\&qft}_6lm* KJV*4-U*W>c*  !&N@+ǥµL?Zq pbϵ &34<7ѣL*RqyVF5uqmn;'fifiywxg۶ٳg;kzٵl6K&F7 \iHJ~}A+ a|# gUñg%߿/U'xkv{aÆ D`J)4_7ʻ0E&b8n$f%# ؿ/"6nduruױuVzzz.[t&C6m|d8! W糚͘BY5 p\۾OJ?>/~={۸Yv%Yr|UApXAĔ2~XAV\mB[JװL;wGw~wk_ɓ__G:r [$dJ3܆5XeuwtZ(NReu[NJ9k|?Q*b ~Z* Z˹/A |s6 ²|Bh)B()r Cٮ$Rʶ˖aC *cRh&=Z,Gf+% 4om? 7":xشiSݕhzfg|{㥗_frjj*aģQXs3eD s`YvUbYDK) 0@iH+֭m,8JFOc) 5Rc'N0Sƛ|K_{[nŴR "+27JX3ץG ":;qɜۓJJ Цa:hiѮΖ෾WzP,|rfETU`%t,ZqOrkBWʟ288X 'OWO'}8@i8%DnHEn(X-RRɳ=/} jJ+2mD(d`gL:vi%Bgdls7Ŗ-2,E-9(;.EA R1ijfMJyiw:"}|br%rLah$L&SuRf`>7zi) |;G?çO7WZRӳf3Ɂ]Ac C*@`EH$RS}r1Ma;pQ[ijD3d̉P(e/PJ16>'N~?9U*mvv>|QJyfaA2zO{\r[1TFЋdY2XLv]4 G100P(ͯg+,iH.zl!ٿFżUhaDT2!E+bb_`kb  #\O~FNg|t\6ݰV&o022¡C#_c]$EkJ)&&&A-0{ij9mN /brRJ+`uH?fs;}a088W555&y;vgy>$@z0M|7Bs{k6nԢ&97SMMM455aFU^)2$u %($m5;9Afv Rrc'N~G~;ﺫJr\>ș3k7νRDs  QD ABTFAQz.( Mb tb ۘuF_K`t%K-iģA_=֭][ug2~;<?fԩUH)%mKg&Z\H-rſ!eZE_MITE)(dA%/"$n칎MtLe~&G13=AZkgg/_)9%lR5]35=ɓ꫼ی^Ω$B\! +%؀#%1!Ry#AsIIoVb'PJ@QCAk @^+JZSԚV"qGBa19S;bx,_={P*ZE0Zbȿ_3RɃ>ģ_:W]uE_k$wK/l:]75tٿ5۱Z֡B#qiko"_Ȣ XKEozZǏ29Gh2_<:_%Ǐ}믿 9ujC;ǎ1>1APXSsDJIHRRY&5Q Q`VU4 IDAT[ AI0H)fFk2Z֊YVs5'RdrV׶8\c_|[ZR:Hr<ϻȁ/y'~lݺ"URk0=,O<8o UR'iBN]Ѧ[x"9WmH.ގ]#AkWg%:A`좷u-ͽ;#'i IG)(?'N`};%c-U Ape^HCCִ(MDX &ԐDWԅ?+#Y!IK0Ԛ* "A' !ģѫ .Jҧ¢@,WYXjv3c1n&ٹsE+RcǎԓOC|B|mˢuI ˆW+~!@$hOWSN55#PN3nߵ 4h21>Pfc:^chh'x(d:Bf䶲S-ŮDZ1oTrip29djYe _l;<RyPx{kXEJOs:/8;ok<޽{/4 >'o)hMt}XQO3o,ƼQ àd""Zkw?u:DYaD&z@^oQ (Lk)dgFVR3G=&C3N,'5 I+E\fXx4 ~lM>h+: ]kldT%l.S"߂ ^Pᔺ̵ZKQx<?s0e5̖:5L'"Lbrl)b/:P >jwXm|4"zkw8.UӞwQJ9}h$' 2UUئ0E!ʅ0Mqƒ$R-L/؇7m,^ Q3h Z$nI3݇71{h#:z3Sg .&zQ)l&ӮakجbGeh5Lomzy'"`f8N.<&`M?ws/g/~93Z&T…n{(JrT`i&]:~ӟ29]m9JsVTNB#KS8ćorz(B|/DJeD1RM4wkJu$;؁W=g,NI-) 0 ̶.m*F=é89Iz&Mar#̗M{SDyDܬ jͣe}i[SJ]'mۛ&fuqݵמM }5W4w^Z98ܸw/׭cꭷG)8cimX*{١rw[0ϭhDdK7^bNG 3Fʆh3ξ_12|tz׵"V|ec!:MqO 0oC94ĢzCJa>_D"iAHt{9%h)y^<ױ ><`f*ܚd[>çW^yJ)we7@t`*Rٺe ｑfBAq:51ᛜ:yl./,$-4uo[AI0VJk;v }S/eɈ}Ug:8F84cCc3h-xL6GA]yYeŻ(27ږu]T:>o/ 5M\~2M6ou{}ff@BB6ew-R[ZZ;>8rcRLNvz?vu 2pw]koJ*{- (A5n--^mcG]T0kw S[ݭ$F90g4$L Mvl %i6*g-XEy'sۚX,vmY,yϾ!aYV[)d]{v?0p6<;~ظxu%/^$ҷP7\{o'jjJbHtm錟L03G^Hg2 kϖHOh@Sf-h+Jڋ"!L̦w/BH)1m4C`uښoӹѷG8 N!DkMTZSr]dG1(^t#roy/R~ֲ<,gg? 0D"'\#];wMMSO׼-ˢw`-"Wzv͢K<>^~e|ah$Sb7@gGdlT{mӜJѿdV>d-URfͷSTB`X¸0l5I5Ѷ9MZ<@.+LS[MZ@PX8%{ܖejc;׌źٰq#㠵7 ?uTvB&.IJҙq_VRJnnf(ո<ZQFihշ,dM$v6"&0V`4ڸb>]K\4C`Y4Ӽ Ǐ$_#X px%HWM>4/8U|hMx )T 6o)%<3|pHM)tn؀^+8YXKtwuqo^d^orjoHY f)y W5 T"AϚ4 n@)Xɉ.n]OVf'GM/SPB^~MPǥ^ kb[Sg^#@.46 0.Z,nR !>Е^0PŷiFZk~K?I)i衩wڮҺR>XF йM7mwA,89s4㣧(HGA"gƭ\}Ϋ%F.%:@4TƌElnY{e@]AyٶeKcԂ=۶`Mװ{ "͗6D y%FX`[xն5Rߔ7/hi5^kɤ.nͬ\Pd ~{Ƶ_M/ds9~ܐWV 5;t~5rB5aF\EDQzzzDWkMӤcdϖ+ 1YlV4ٲe {sk\PAww?W E TقW0w7 pպit&%5@iT\X4z҅4ivWiim%N'bq:7A|[u+e8۶Ynk4vފٳgٽW x Ӏt\q-#*il+k g ^NZnarSR{##TʾX$Bu9p o&\aGgss.`E@TO=Żp,r`*'i5hc 3mlg;}u;&+ 1S2 5WBCJڳ6y\؎ y啚|*E>tlF:/:E~'ؿo=?z)fzL)A4BXx9sMf&(h!fv厭tvcAJE~jIUD #Ҫ_JgG'@U N?ΫTZJIK[m{^*2_rjZR-{YF8gǩ533|ۗ9Q^K h()ϩ^`}5?]Ҋy#;,zeMijnk̔J<G.cQu{YM7!>:MZky79p@MןFտX|wZ;~o[_5gFGtN5\c7gCk=8"(f1uEp?E@= . N˚װuDq)9Q,!H_ƭ@M.rHtP11"0Z3::t%-D U%/O;?|ꇜ>s0 Ri93L6=CI ޵ ᶬxޅP:7Jz0C?s|Qu Ѕim̎52z;MZ#ZjqlsBƤ%E ׭,k6] qUi%`n <5c(lbuv#[LԽRt&MLCᶯGI5RP3G0yS'Ig W֩6bq?yG]?'~>ZkƼ0Lv Ae()fQ=5P S.4@ P mihq_8,'83|'OVmVpw322“? ML,2cd23L{m[pXEc ]f)NdvS'˥}Yi1ZAHHHnZFWZkJZSLz%\&ģݧΌP<$dh,Ik:HCH{ {}{`}#@"" %Ҳ,'f$cŲ8J*HlNŎSq$~X%. %XA`f0?zf8t`}Kwϛ=s9d̀rJ}/ \6rZI)ƛoO=ދfn޾GE> B8^_;wmWܟzPJ|R *-+{aYm@uۤOI%2s]eR۶>Մ"kbb?y{eJ OVG6<?oߎgwIq̅f*0f}6޳?ϝß~ʃeuVv\к~LӬk4YI:!c##y o, ^:Pz+m 9Ǒ#GwA$!MMxO\x%0ưiF<x+^{ￏA!UA.Va׭aσĭ;w1|򲚁L!E"Ѻ yY7U^iOxe !ǎ>e..MˆVhYҠ+pKHǑ޻`mNA&/}o&lٲ`lYv؁-[3 8t ~-tuwcP@"J5L&N &lݼw|cqw`ӪPrqAž"U؛6NӨok5Ha4څ8' ˲3ת ˫|}`+UKi8xۇ ^sك뿎;c!v4y&lڸ?0uvɓ0**(mMzPFa4V^[n[oMtLBE/SJ8V@| ۛ2+0 `R !lض*f%N_̊!꾦BOO^z%|3ցi]e{=W._5&Ԅ;brbr#V1PZ r9jkC{[ZZZl!D4rc_Ys!rLe2(LwBaY f/p GIdZš~g(شq#/ӟ4,kq)1477nFH 0(cF Yk,LjTQ%ȓ`kR?;֒Z3V3vcT|N@Py/s&`Uk+y8rdz7s3gNСC(Mttƣ=xTjyϹy isz@R }GzwU\RJ8 5Φa@)uLyd=mpsmXaرcP ;s?~ǏYٳw2bBfc )4݃}+ (W@پ3 XOآ>N0(I)=&gxj{uo<#@\Jwڏ>߿zW1-[66l]`g"w."m0V8y$Joja>*V'&F"Bd0lYd}*N2M+Sb3nXZPrzHڐj0+pA|[odC|.xw\)%GG @xDK|7}8_YB+7AwqJ)m[Q YFj~ !3T!*"`BagV˴4; =v Zkn =֮YɭR A g|&[43RSևӀ2W`lha#7 hDL&[r1`m?ԝ[BT l+ c8}j&={ng#DjDYd-Z5jjUΗP@<8)JޏA&v.*0 ~/ϔ"!!ą`dt1i+IqĄ״^:L6ݻw㮻3u!_!(י[Ú6ˆ56ã#8!M/xI@{q셣[%G>wO8D * Z3LF{q_ Gm@u @|}]T~p ڎwXj"9GuP#ru`Rp| R.$X^`{ԨP#ѻ'^>9?nsܷ+:AC)SADgNCӪu9΋u(EkK ֮[]E64j'c[)2wAC#+ a%_؄MiPOMZhaο֍cs>B8,%8ՠ;c\1H~ܱR7PB&䚏Z& B̿pQV/h~2J)sl#g5iQd&u4p# 1<wC 1畹8W}m3:j!E 1,mko E )q/{ ؼyP[4( =)Vi* 0, ÆLJ D@a 6`kޞ˳1cLЉa Jl rQ)ȸ.>L|Njt,QO ZM!8Zׯ0@*ud 3Ձ"@kk6i[p?B-F25Zcxd{;n_A&Y3(>9u1ZB6-<(/fZA 1>6>0Ø.=):_c /RKf$R6J~Jk V:Nv@R90bn40o֛v5 !pi<8rH]wzAJ Fr\v+lZ?OP\lZC*(>*22**s'ERt𛦉;~ d~j2=11Pޏ%u B|>w>~o7ܿwݽ$ۋR ~ #5E$ĿQkreJ)Eq7v+ KG6F~FJvdR\ǡ(ޙBJjyf.w= m<<$j KZ4 ' {2Yd<tz,0Jyd6bXBa^)4&Co N:Rw Bul{SLE@5/Bm#[O 5H!5+ 6ma_FAq k E@(uMjm)2'=_º%S~r8~K==:1>S{V`K1ӝmF]f|!մbR8f[~U%joߏ7^~}=O,&mJc, q )zAx)|ΰ䌿\6wLa~vGq|Ql ZK?N4rgꎩ"^w@7F˥Pn;602~p>Ǜh+\;:QhqlbĖ&) "C߿1Lݻa{ @Zm H)E:9 %P0jX(>YRN>>)jJ=6]kW֦4\}{tk'(ʶS~|Kk=/i(q:oU|dtܰia6܍A~:}*^y)5w}+R4,J^Q7F[ %8c {0ʌ{ܙK)׽?uӿXJsMHк`gZa~i@Z[ZоzFGF{qĉaxXC qXRJe6z^JU06(!4Vݴp-̪MneL+COO,Ξ=[?0wV$wBQ! gײ0Wv!NM7A X2R!FGGىbT:M(Dgg'>'kUp㖐-,)SP8u~ ͞q!/OZҜpY) 9rp 4Ce剆F@J tvvy(܌t:콁{bAci1BLWOSxJ&pJȿW;.2Zk(5Mø;㎩94a+cZTdε@GEs5*z{{q)q]477/!Ǐ޽{111Q= HآvĽC 1\K״֍E)RN%H@e\0'$SB2UD\"cc8s Ξ9҂l6,(pȻ /Thjx0,_3>N4΄BД͞,W%|kR>4gƃ\p5rl IN@]&@$GeOǎEWW'lA{[;l^VBAM"fjJ&+ft 8͈D\4 kƘlR2Ѳ~'F4P'|&ؼRi|^@-8}4~} )_6CJ*xM( P'7PAQ˲`2~~[i]ϓ{zJ 4 BL/c#o m7dK10Sȭَf#D0x))Ç+С(W*<tzb{Btwwg|Р ?ǒ<+A8XK|{(:J=_ ߓR^u\#X nBlRBDU $BSΪޔAXC`M7)%& >so=B\!Y`Vxsza?xşaPhܸ@Q:  +KOQDZ9s5R+y ;ANv˲滱/, 9щw`|ߟwY6s ֯[moͷΝ;qM7aMG2,,˂aNFajO-sJE N{Au%)vrc\`'8T.7 y30~nܑ2:gRC65Hb1qUCs6lZfZlڼ [m[|m 2j蕂q# CR1 `@_Q K0fyNMܦ"`|̯ !L`Q !eW|F*7QY !ظ~#}5 u>7DP.{OToP}c1L:&r9خ ۲`2p)sFx(0@~sްo>0L<^\d߰4mY8^ G0YQ!ticǠ̕Yܲthp$H'*"Ut%̥ǵ`S6?>0!>x27U1 #pLXs~da^a|Tdg-\5TJ!ќ̮I . 0fH3  UbjY}"ô9Ye ]Il ǟQm:(8*}bFk-4Йrݝ\-SA5 - v5xEPʭAu-k5#ڰdXRJ)LDj2`& 5A:qF J=b$DI)mSR~pYY*Ud`-^ HA6H5呹"!0T+Rkn݀\F4@.g3PkPJiȥhkku[f.1|'rMA AP{#KὀF-f"~i)qke'a2?T Բ|3h tbe@)5Bd*DX".###轜ZA x4tAm`Lv˶a,7N`xM`v@ Hc(a|lA9aq1+oP ˔iq&:!D۶}NH&U·6Jk^VӚ 񕩭 5J |EzIЂ fZaS1$PZ @ ZI=,Qւ@ Y jԄ& n 6 _k1Q:Au*  ^# ƳIDATDύT*EѿBxg)hJ)KhĔRb|l7Y} N&b45jG 13}7&Dǰ88p)^G'a=Fm  xN9u( V /͔RԛLjx3GT@t /̙&\уəуM>f?oIkr )qFb7ĶO ~~`PT !f;p!FM_>}V7J͜>.%B ~Gh|=EFgx5 P uN1Y[M{޻ZG|׵d!zmBUzzYNeR`d_ⱳ9c>{-,oiKl6u;spV+t2 BҨMI ^I5^# %˦'3F\qaJ[x_ :CS) !aPZ# QK"&P+,S@}Lk±A~ J(}L&E)s^9T R}J0(LJr$1Bp#' ?}AALck f|3q|LxS5 Ri$j qx^*2Q{݇>!iZ(q~!2L$lBm F( J0A)$ÌE#CDhBюeA}GH98gy\W3Q:d[FuvbB&F#pmV*MGC(t@/addoطbο΅8=ѴQ'0Ms;QJ$NC!d%jAF,e2 QUJW+q4MiJqQJɅFo_`brͦ^u,:(um{zTj:*P.a 7L Z@0r t؏ [k!Fȟp7s>UZG1-LsRcEqV+F7%3(*X80D1W )cr @6RO8~JqŊ=5BHI 98N&5u~ N6i2 8㯠(K sB9:Bf `z{OJ _IZ8 l/EI`x>8c1.f!mQUG֋{,tKal׹Af zftl^.h#i*}@8b!>AijV!:BqҺ*< 8&c4(j@Q 206fR'hivS+!*! c0ƔW Vi dҩ c0/8'., ߥXT4>N(Ryke-vдTb ؃o1˅x !x1qէ3jv>k?(t:" !@fe)1Ui 5b(@+J#a JLxrߍ9?Rf,bf>Rx4V݊5;jG\d+E 4wRg:E)MY=@irrf2S!i6SjZM?I)V1Ǥj_ K2B 06?*fגB`rflز 7Iu@'CrN | }=gP/In`P TB(%$L78b1u5 %)St/ALgRٿҿ&L>-!Uw&mƦw^7t?p(r?FO( uE(cȥg(ALi]_r!PXtzgS6Jghl,ukeYhe˴~_嗤I7E/Œ/ !8tmkJV!ED8ذ~#9]I| ,}rÂDzkߩr!D/4l[K,z"{Ƌ%kM5JіiL*=/XWa.me $2͍tQodؼi+v<Ҵց8$$Amt:B2\,Z )Kpu!ДmmmjeYȅX*U7mcSqd&"H XOREj 6)X.KgRG)! )ӪNmd%lܸ [kR+KTu?{uLveؖ\_ {Kmn{Ql%:!cNE ք̀fM ,S(H)eYűmircQoBx'(ȤX Mnݲ̓ h@ Cab|Q&RicY߬ Raf4͜m-(ijDB #¸LX(Vu3 90|3j uU wVVN]!DPDTDy4{ϠXkk4-|Qj<s>X#1=(!G-hdlF.CS7ɭjsP84D #N .#Ai㣃(W* U)-kQz4Ŝ'#$,C4|q!Rޭ5"V'1ǶiYT:8vةf^p2h9">GΣ0>J>T69) Ŝ?E ˜ez74&׶wSJZVJ;WelB6A* ^nvL L7B.4,وh "a _@XCP_B0R1ǠP2J;7/aXf?!a) RE)GQx)KuJaछfच`YN Z0:PR Zh#؇k> JD"BZE c4c0NkZ!z+\Jkڎmo31v/c1't ؖv`)XNe{Lۅa0LԴ`0 Џ삮iZ (!y .8!qDG>xXA\yՠOs Bȡ8 !) )0Vbb4o-AJﯫHqjQ 10e(5@dRJ`RIMU1PJɚZPRB*9"r*&RB˲q!^-)n!e {/?aq0\0(m۾ݵa_+UT̡նܠ2Md3in0})+A9?#䜏_/) uifscyJH޶mtSaܯX*r21ئ\6 ۲Vc(oJ)RʒRjE֟',/{0B!.4f?O hAKRAERλe( 4v]1֩:BV־:PJZEL ,!B B:l.s)@H*KmZS-%tx!Q2PB@Qa2~bjRTjs[JC)DQJH|µF6W!o~G uګO t4!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! GsIENDB`( eCTPQ65Tvmb cbrPche5[R"#_b""w<ϘR"WM2"SeCqqOfӑ Bfff舂fffcNm-fˈU]fꈊU^fkL."URfnUf{ȼRf!\"&fp(*"qZ"{˻-pzpp( @hDj^W v_ =9I;8\~~{fC s4;7?""G~w """"#7{ޙ 3""""?3ffmؐ B"""#K3fffm""""4QfffffIs"""#Afmffː"""DMfm"""ԵUTm"""EQDUUSf"/8EUUUfN4"/AUUTfCB"/DEUUffs3"/AC4EUTfmy[?/t4DDffܙ54[/DDD8 sUDAD8DG~x5SQI =I XqxM >>= ~}x`??(0`hD w[po87? F8? h}""",az""""",qq""""""""ھ݁"""""""""+33a""""""""""ʮ3333m""""""",˻͓33333"""""",DL33333>""""""UUU3333333q"""""")UUUU3333333k""""""uUUUUJ3>333""""""UUUUUJ33"""""+UUUUUJDDI33ꀲ"""""˴UUUUU}DDD3;"""""-xUUUUUzDDDDM3>֒"""""XEUUwU{DDDDM3>؉"""""UUIDDDDJ33z""""U{LDDDD3>y""""UT""DDDD3>kJ""""UWݲ""*DDDM33>y"""U\"DDL33"""U},ݻDI333`J""UJ""*ڽ33>T""U""˼ھ333{"U"u\ڭuKۼUۻEUTګfwwwaULWݩEUUTۺzUUUuUUUUWUUUUUUUUpUuUUUUWpyWɛ:kWxxwmm>w`;m8?0(@hD N@>76D!hi lma@ jeUF]"ghg]kDKU-%KvDh'K333Dn]{O33333Du-մc333333JmWwwW33333333k{UUWO33333336ek)333333333kM׶333333333i}wY333333333?Fյ3?c33?k[Y3KKD333n-wO?t\UG33H%EO\Ŵ33?GeGOkEĿ33?kuU!OD\F333e[\K̷333e[tEG333iW!DF*DLG3337zuWu'Kw{DDLG333RWKUwD|O333;j[}WD|{333WEݴlǻ333\wWG}%l{3333ty[]W}WKuD|gK333?F-WTR-[KwD|k3333{]W!k-{DDDGkD333?gQEWw-DDDDDKo333?Frt}WEմzDK?gf]-WE-tTDDKKKKibWuwEUw+DKifUtGDKuG{,UVUO{uGnuGn馷,Gh蚷G7wfUUUeVtGIZjfjjGƮG?DDK?誮GKw{K?>??(H hD QN3/@lmbB_` i33379}y978"""""-77"""""""""77"""""""""""< c33378""""""""""""yq9g8"""""""""""""-79tO88"""""""""""""""|s7"""""""""""""""-81x""""""""""-www?G3 ="""""""""""y3333331r""""""""""s3&33""""""""""(3UUUUZ3sq7"""""""""">UUUUU\3H< 2"""""""""(8UUUUUU38"""""""""UUUUUUU3tsp""""""""'9UUUUUUU3339H;"""""""">UUUUUUUU33x37""""""""UUUUUUUU3~7c"""""""-3uUUUUUUUUos79si""""""""-9UUUUUUUUs3z`x"""""""(>wUUUUUUUUsx8qh"""""""5ȥUUUUUUU><""""""""ӕWUUUU\U3<"""""""ӕU8UUUy39~3z7""""""5UuUx3333s3ꪪ73""""""5UW73׃33ꪪ7 37""""""5UUs7""-3ꪪ3<w8""""""5UUY3""""38<3r"""""5UU37""""3ꪪ<"""""ӅUUs3"""3s8cp >Y7"""""ӅUZ3r3"-33ꪪ3Z3r""""ӕUW8""38s33ꪪs388""""#UX7""-3333wx38;W3r"""ӕU="""'33333338` 8U8""ӅU"""x3y3333<su^3""5Uӂ""x3U333ww87U35Usr-x37UU^333333333sU38sUsw37UU\3833U3U33UUUU3?3`c7UU^yU~UUUUUU4 >UUUUUUUUUUUUUU?`6UUUUUUUUUUUUU?s`3UUUUUUUUUUU?p9UUUUUUUUUU?c1cUwUUUUZ&s?<U3333?<Ufvffll?6Z7?633>?7wwq?7?3 333333@???? `????????(`hD <5>lmoqncBghc33333}3xfffs3w3""""".f33svn"""""""""g6w6""""""""""".cwfm6""""""""""""".g=333368n"""""""""""""""s37s33js"""""""""""""""""83xDDLs3""""""""""""""""".czsvDDDDLȃ33b"""""""""""""""""""&68DDDDDDDD36"""""""""""""""""""""c83DDDDDDDDD3n"""""""""""""""""""""-c8DDDDDDDDDD38"""""""""""""".ffffns""""""""""""7UUUUUUUUUX7DDDLs3337DDDDDD6""""""""""".s=UUUUUUUUUUV3DDD333333DDDDDL3b"""""""""""&3UUUUUUUUUUV8Ds3؃3wDDDDDb"""""""""""8UUUUUUUUUU]3D3m3|DDDDD:"""""""""""c6UUUUUUUUUUU]3Hcvs8DDDDD="""""""""".8UUUUUUUUUU]33i3DDDDH6h"""""""""".cUUUUUUUUUU_363DDDDL3""""""""""&3}UUUUUUUUUU_33sDDDDL""""""""""3UUUUUUUUU_33ic|DDDDD""""""""""8UeUUUUUUUUUZ338|DDDDDb""""""""""6UX=UUUUU/ߥZ338"&37n33i37DDDDDDD{_v""""""=UU]3""33333h33xDDDDDDDLsa8U7b"""""=UUX3b"""33333vfgw338DDDDDDD3 wV3""""=UUS3""""h3333333337DDDDDDDLszU8""""=UU7""""33333333xDDDDDDDL38]c7"""=UU8""""3mh33333DDDDDDL̇3}sjU36""=UU6"""3UZ33338Ljx366UZ36"=UUc>""s38UUV33333333333333xsjU]3xnh=UUc~fs38UUUV3333hxfڡ8UVs373=UU8336eUUUU]373UU]g33}UU333vUUUUU]3837jUUYs=UUs33UUUUUU_s8G37UUUUUfmUUUUUUUUZs8H3a38UUUUUUUUUUUUUUUUUYc8L3a37UUUUUUUUUUUUUUUUZs83a37oUUUUUUUUUUUUUUUU8Dsq37UUUUUUUUUUUUUU7ă;3=UUUUUUUUUUUUUUs8D:=UZhmUUUUUZs7:=UZ333wws733s8==UZ333333333c7D6=UZݪ 7G76 7H337 7H3336 7H3 7L3 7L3q 33a 3333qhf???????????????( hD MLlm:.D523bB`a3333333}k38xw3xaw7͈38"͈s6.w6sj}؇ww3w}k87as333337v7}333378s胊s3FDDḊ33x8.7s8DDDDDDF33xs{3DDDDDDDDD37=83xDDDDDDDDDDD37;s* mR@)Ci]]d^A]][\]A *)X  Y={_K<;>-#42baTB664/Ol_`qqu9yV>GBDpflZsrq uu )jzu/DX/SmhJn}}$.Sbm7[_q&;HaKNr6k>Xj%CPWy'8&?1RFG!, .S/;4/0/X { o?5-###( uuv3\4E=7 ghccc7Wu\K GC<6.&^>?>` 2& hhhE1"eSD999~V:\@VVV}wzS7[ "!9gDjk S9(9c; +!CBW<74%#WmnJC>cAkj 9(H2"qcXbbcJD@\=+g`[ eC )?QR  ?942.+0# zz{B. F@= lmhD FzG'( _yS8XXXZ<IFCffhkYNA6/ 5&IHp_?"<;1*drO7Y :jk J<27b8vmg '"111\\b t~)(]=3+.P7 ZK?nL3fg%I xxx^> !U݀=UUUg%%%UuK@1%%%%%Xg^48%%%%%l0~%%%%%T8%%%%,CȔkznUH%%%%%%v hFC(%%%%쩅$$2I<e"%% )?+t#ߊ-w%%&/cM%1 [&)9հ0f`nxJ%XTbL6zHĢ-{WEB>iSr q@8|AU73'.CB(( @hD mngD gC kYM eCnnnXH< fClm aA^A,Z<+)e5,&1' nki#!q:f?.#___~~uP6POtBBC ```=3, w0$kl \jP>^>bAXY H2"hRCHJ4#aa= l952zV;wwx CBiqR<kkkHFE) |iii4%#='"%Y~}MGCDzE sjeO?3 cB B92a[W {neST[[\c#;18(poqr,"MMNYYlsO5ZYk vvz}W9@60 q#+ijN6%IbD.H3# \]cA_@pM5 Qiiikltss$ z666EEEOhS QPO.O3xS8fed{{{1"G9/;:\'1#1.,efCgDX;]@,a@ mnfB E=7nnmeC eRD {yy{zU%'{{`+߰43y{ZdB=EOF`+BPc.bc k^) g: u͌{0  )I bAg7J TWx{UD~ ^6>-IF 5~7l[--->:,vr---Lr]?BRH:Y0YvS---ʰfRHv˪S---ǻf0/HбNSrl9qp/HQ0gNsllJ b{fU2k2U;nsWOh9A?gX4iiq{,f DWX{{{{  ~9Xxz56ΰΰO8ʄ=\y]ma`??(0` hD mnrO6B6-  !*O556KKL 3& S;+ #~~~ 889gH2( dhD!]>hiYZgD 666dC  ." kl  ]]^ v /00^B0``` + N7' 5&000 w^^^)1!nM68_9 3PQ```Z?-""#IUT}#! OOO888`@Y=MMMW000`alll7 D0#xy 'a@]B.cB'&%GGGHFDfDmmUVdBbA, FFF fC\?@- 3`_`[A.>97TiiiY<a@___xxyQQRG!!!V=+tss-  ,H-kK5PPQ t NFA{U;1#  K6& =''(eee))*aD/  r KKLV5Xyѫ<ܥ>-Œ^*Xy`@X;wR8RQP111 vvw  ... iI2^B/KtQ7X !,rrsX>,>>>III 1#2Q35ppqbcE 22$,''(,"|U9H?9hiS;*&)&QQQ }[t\fffddd[[[1& f dBbA[= kkNNNIIIN7(\\\ vTTT%(%P9*>, (''+}V:,.:.G4'667G heee1stqqq.A/ DDD112V=+AAA;%%%RlL4__`\A.dF2 ;*  nno  [\HHIzT8 dBgD aaaaaa᭟Ä'w̄æ]a(Íh:Gc'KLK̦˭%aadP22GwB''⹭Sh<hYǛ '9v';;* aFG<)̯В;C ufK<:GKKKKGG /Z*Khv^^^vvr> hv/666ѐQVWnê8\Y6kTTOTTkV 'aK8Tk*ݵ\6O܋fL6Oܐsiii *C ˆ?<\ѻOTV WMMZgǛC{G^kOOQ*>&xxV; ݵJ&6O6M~~NWpK)O6&ϒ/77s;:6O&gx7ʬ c&k6kO/l~slfdO6OTTkOx7~N{W˰v8W&Tkr2okɿv2ZiCMnOk92Ӌk&29GYɐMVCCCCC>ϱ nFUOk/2LkOK/ѻOO6&'ggӮTTɐ/&v)kT6ߵYT/ZݽnnFFn[Oܔѿ&kT&NOnkTOTk66TƐkTkYi QkTOOTTTOOܿi˯6kTM˯YєkTT1FFn̐kTkkTOOOOOOOTTk VfkыѨ666ѳ&C F kҦnݲnn{;u1kfF{;sMݭF'&*nFaff*ϒFE(?>??(H@hD mnhDgDffftS< ,# U?1 fg" fJ7]tV ^ s`A"""mmmaK251 !4mnddd nbZ ??@ ""(]@_AVVV n TkylE3';63 bc zh\\?===mO:fD-1&#/QmmnEEF e J0 !!"'{{{`AM:, dB eCaA gDffgbB~~  kuuvkl \]  ^@(666ZZ[  ZB2!!" G6* 777445ATTT6P76)"  rrsbcij9,$?>-99:BJJK../ I6* ,,-^D2   QQQ BEC +_@++,vvv j gDcC gE gE 7I[I[I7 ϟ77q)O!D7ar!tlL=UI̕Lޗ[?O[Y88mV`[FU[[$B/t7a.B[[Fvz44WiDͼ!BeD }}}d/$[ {d  YU7r=} +4x>=\}h  \h VV#Vm# }_V:ЬڮXLd^/QQ/ AAN` +.JӖ[P \mY0`óBjP! h$pa"B4J"hhՕ"{"GjPv nJhn}}:$Nvv]hh{ddQ Iai]^""mQri]n}>F/K&]^!-GAj=&{G"..d }i}"4  7}"-oinJ o!Gʻ۳\>O مG"J۳_4` ŕ-=+A>{DL-/}"͂}H_q&<zdJD $H+A4N7d DL"=J]^4.B#$VB.4|7^}zDLL>l-h7ĺhdJQ }R|NNjNNcXRIJdQ\  hN7bhQ\/ /{d^ d   .b"  Y1 /d{$ER /[I^"d}h^^^^^h}"H_ ^{ Hx \%Njbbbbjc|B7 }h}d8$17mId8dm[7RIR7@???? `????????(`$hD mnhD gDzfY!!! " O:,5)"6N7 C3(*BBB`F5yyy ^*-)pQ; hK7LLMk5H6* KrL ?@.;-%U?0 ncClmcSH <<= 5)**fC  ' ``a abc]@dC_@_F`AjkaB [@`B ff gD!!"  999 fDttuoopkl iyV<D &&' JYYZ}}~%  SSU'+'IIJ ppp555AAA^^^cid==>/#``a'hhifD 334vU= e ij*!QRR2%EHGCiD^^^0<1===qrrLLW  ggh$"!*fff T''( E74  621 111u1111ZZ1^#N1ZZu(gQ66;qZ7lb   l"&LZN7x _";jZub Mxͻ\1-#`N1Zϻ'ZZuj1Z1"sb'P=//[1s1~ 8S*H1uJ6s\ZC$C(qZ17jZ2F11J  $ ZM '&%vmz"667'[$Hv)z04GH(vZPJ"z[d躺 2Lfb 7Ɲ{{}}}}{{~͓dxM65{ 4/*C!m{ {;ww%ZJ'M} /wS/n1s:6 }S2HPZN 0 { }S8%%%8$qcx' Hw*<=wC1xT C286 54RG33dCPZ7xQ{ /&3ۖg<U,0} T*Fg?34~'иd 83d8 &Z4Ӗ5 2&/w8 0T{; 4224+ {&{  <~ϖs5 {r~*,s5  {{{&38s ;; & ݲ{$$JZ4",zz { {r*$dmz   3d~$d0z {' $G:m "b,?g$8Jc7m dks?3c؉xm G'63; H`}mD ;z?3CW*NG{{4mD {D"mx4gHwF:kD :z&gz _ۖgH*~-Z{6kT '7Qx:_3<g dkT z x4Qr32$Z}g 7 _T  x4 dg wՆj J0b_T '"G߰*S$ZP{TJx_T {;:,/%*w/ϐ1{T&)M_T _JT$2SwѮ2$ } ='_GT T0 x0}{/%Ԥ88%/H4-&}{ק x ,Msd{ g{ }G;7''Q  lz74蝃 -@44-Ϧ{ }Td }&ɴd&  ˅ϻ {&4 }d&T{ WPd{ }{  }{} gCv} {؉ }T} [/Z  {&8-Z1;T {4WZZز{ CJ˦P ݲ} }w(T }ZT {؝{{}}}}{{42vT {g42$+ {dW~ {cW[Zƃ}Wi~WPZ^~%qN~8+N~*SS$PZjU/ZuP1!II--ː???????????????(@hD mn  8GGH ;-$YYZL9,dCFFGgD uT< ``a~~~ ef:4/D3(oZM77*" AAA[[[  p ~mc*.*'''ab_@  ]@mm  xxy\BfDfD `AbC`BaAeD>D0eCTTU XA1 d   QQQaaaEG R .# `F4 # ,,,99: y ||}+4+yy& fJ6 ]lM8ccd{{| ) 3(!mmm8q//1001+ eH5 ||}3& V0gD[C3''( Y A1& UUV_υF[t[RFFϊ_ःEnnnnnnnnnn†lϊ__Ϥlnkx###xnnzx# A*Hн=JnEll%AQ"n_lJQH= _A=Qa"ƅυFvlllll`FF_ƵA=%E`FlEnEFzE *,FEnnnnnnnnnnnnlHQXJZ_nnnnb )bnnnnnÑFҵn#XH__znnn3> Bdnnnnn_n%XzEnnWjj>ո+nnnznJQn`znn/3j>WnnnF_φnAQ=xnznnO3nn`=Tn@nn?>jnnnlJXQ=4&nn dnn_z"H"nn;1>/nn˽X'**HabnnW;nnEφ#QXJ+nnnnnnnnnnnk"nOٙnnE*X=A#nnnnnnnnnnnnnnnnnnLjnEJHXATnnnnk&۩+nnnnn n5l#=#nnnk7$$8nn)nnϵXJnn4$cc4nnLW/nnz_lˬnn&cnn1ObnEZEX'#nnnn1nzTnnە.nnL nnzn"nn.nnL3OnZ֥#nn.ndWWnFn#%nnn$ndj );;;WůOj;nnn XAn8n?jnnnnnnnnnnοjbnn_A'TnnޕnO?bnnnnnnnnnnnnnnnbߒ nbg' nk$cnj nnn4: :nnnnռbnzxf*n;nnn9C$D$CC9:rnnn3)nnEln#Hnnnn nn9D\KKKKKK\C9MnnıWdnnllnˋf*nn4nnj nnCKKKKKKKKKKKVC9knn1jnnnˋQH nnncMnnbnnDKKKKKKKKKKKKKK\9knnnnӖgnng$]]8nn/Œ/nnDVKKKKKKKKKKKKKKK\9nn1O3nkn%n+8nn/չnnMCKKKKKKKKKKKKKKKKKDnnbWnnƊn"AnnەcnnbnnC\KKKKKKKKKKKKKKKKKKKKCnn?>nE"#nn$A:nnL)nnnDKKKKKKKKKKKKKKKKKKKDnnٿΣnkn =ng$8nn4bnnCVKKKKKKKKKKKKKKKKKKKKKV9nn/nn%'nnw$k$nnnnnnDKKKKKKKKKKKKKKKKKKKKKVCn1;nnlnˋ'nn.g]wnnnnnn9VKKKKKKKKKKKKKKKKKKKKKKKC n1nҤln#'nn$gnc볗4k+7nnnnn:CKKKKKKKKKKKKKKKKKKKKKKKCnnzz#'nn볠&wc+nnnnnnnnnn+.nnnnnDKKKKKKKKKKKKKKKKKKKKKKKV9n?nElk4*'nn4n4nnnnnnnnnnnnnnk:nnnnn9\KKKKKKKKKKKKKKKKKKKKKK\nn1?n8_8"'nn$"nknnnn"J"#nnnnnnnnnn9KKKKKKKKKKKKKKKKKKKKKKKKC+nn?n7nnnnJHnnnT$nnn *X=*JTnnnnnnn4CKKKKKKKKKKKKKKKKKKKKKK\nnnٹ?n5nknfnnnknn̖QHAnnnnnn:CKKKKKKKKKKKKKKKKKKKKKKV9nnLWnzunnn%nnwnnnnnnnnnDKKKKKKKKKKKKKKKKKKKKKK$nn)>nҤunTnnn뗠knnnn4nnnnDKKKKKKKKKKKKKKKKKKKKDnnĒ;nnlngnn nn뾕4nnnn%HnnnnDKKKKKKKKKKKKKKKKKKKDnnL/n_{nnnn$nnnnЌ&nnnnDKKKKKKKKKKKKKKKKKKDnn nnۗnnHnnnnnnnn%f*nnnnDKKKKKKKKKKKKKKKKKKDknn O)nnEFnn֔nnnn"knn"=:nnnnDKKKKKKKKKKKKKKKKKCMnnBOjnnƊnT8nnnnw4nn%nng"*nnnnDKKKKKKKKKKKKKK\94nnnOnnnnnn]nnn QAnnnn"QnnnnnDKKKKKKKKKKKK\9nnnnnn_lnn4nnJfannnnk,nnnn'Hfnnnnnn DKKKKKKKKiVD9nnnn;>?nnnnanncnn%Axnnnnn"nnnnnnnCKKKiVVDC4nnnnnn$"naa*nnnnaJxnnnnnnnnnnnnnnnx9\\\\D$9:nnnnn;į1nnz_ncnnXa*nn4nn#=QJxnnnnnnnnnnnnn:4nnnnnn/)3O)nnln$Tnna*nnknn nnnnnnnnnnnnnnnnnnnnnnnnnL?ĮO;nEnn8nnAf*nnnA=nnnnnnnnnnnnnnnnnnnnnd?W1/nnzn.4nn%Xannnx*nn44nnnnnnnnnnnnnn3տOO1;nnFlnwnn#Qannn#苬Annnkۡ$nnnnnnnnnnn 3O>1ĭ nnnnT볕7nn HXn랩nn苬#nnn]w$nnnnnnnnnnn)?歭W333W渶/dnnnEn4]nnn"HXn+nn A#nnn8$cnnnnnnnnnnnnnnnndbLLd nnnnnnnEl_n+8nnnnXnnJQ"#nnnnxc$nnnnnnnnnnnknnnnnnnnnnnnnnnnnnn,E҃ϊ_ng.c+nnnn#J̽JnnnJJgnnnn8$nnnnnnnnnnzlƆ244:ƓlEn.nnnnggn$nn+JTnnnnnnї]wgnnnndnnn__n:$knnnnnnnn!nnnnnnnnnnnn8$cnnnW1nnnEnnknnn$nnnnnnng::nnnW>)nnnn8랕$&x$k4nnn?nn&_lnn+볗$.$nnnnαLnnbznn4w]nnnn/nnEnnnnnn漿nnnzznn$nnnn;nnnnn+$nnnnjnn_nnnk몡nnn?Lnn_zlEnnn&nnn?>nnυlƵnnn몕cwnnnnnZlnn볲۲$]]]nnn;nn`n.n"ީ7.........&&74 Tgnnnnln]&nnnnnnnnnnnnnnngnnnWdn-n볠nn:4bnnnnnnnnnnnnnnnnnk+:Ennn)1LnN n]nҊzzllllllllzzEnnnnn.nnn nnn$$nnn nnFnnnnnnzφnn; ?nnzҵnn nlnnWnnn~nEln>3~nnElnd;) ;nnnZnnnnnnnknnnnnnnnnnzƆz_??`????(  @oubUqS>rU@udWg,OH#wo[>hDhD`?[?mQ>njh98y LKL o]?hDhD]?lZGBD 87=gTHՙhDhDcA}cQqqu&?e)Ci ih%fJ7hDhDY;uh^|||!8E_`^a/Ol $"yrrv>95܅[-#Z>*=*BwC[\*HI ;:sȰO6omm]KKA;RRS 8}!66o͸GQ||{kji𐏎/򆅆z,& ,䮮ޯʱɦJ~~lY88232TdctJ?(0 ` \sjd\K?[G7[G;dWOŌ4%UJC̀Y=cAhDhDhDfC^>jO<늉y<;:=$#J&%=___!5M?94  W"<)?I  44; 7/)hDhDhDhDhDH2"hhh _9c;lmmnQRG  ^E92,hDhDhDhDfC2&###.&ghmnmnjk4+   ]]]JIIS9(gChDhDfC;1*```>,.S/mnmnmnde'(   %%%__`<74\=hDhDeC=3+ N6%fCeC%7b8mnmnfg.P7 {   ||}RXXX+!fChDeC?5-VVVrO7E1" B. 3\4jkFzG  o  +eeeJ<2zS7dBA6/JD@gDZ<0#999 :   *)XٲM(;;<娨IFC(2.+;4/9('" 󓒗nxxtt{|Rccc/ Afff^^^7+2PPQLLMbbbZZ[ZZ[aaarssHYXQ}/?>` t}ttt;;<̏p( @ (9@>:.Jj_X\K?[F7\G8[H4-00/N6&I3$8(Q8&cD.0! XYkl^^BvC";* Q    d;;;C;5bD.eChDaA@6. `@^>`B-+ !:!$?%/*F z    ;:R0^OOOIC?H3"Z;_@A703$gD[=H2#*&$kkk[[\<_ {  ze CIIYA oTTTomk*$2$2.+nnm(9(RPN222󖖚jtt{tt{j@ d@@@ꤤnnnJJK==>N:OOOIIJ񢢣EEEf5 Ebbc;;<666f6^PPQEEF\\\bbbZZ[ZZZ[[\aaammnBBBfYyyzzzzkkkRRSmh qRQT("]%$K J99;&gs_(0` %!&%##sTTT98961.:2,<3-<4/741888TTTu%iii ."kL6eDhDhDhDhDhDfDmM8." jjk  w)%#L5&Y=hDhDhDhDhDhDhDhDhDhDhDY>>TTU}< JJJ,!a@gDhDhDhDhDhDhDhDhDhDhDhDhDhDgD`@."<<=]]]R  w@ EEE!DCC@- a@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDbA>, IHH?TTT r      u1 XXXJ5&eChDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfCS=/          ===x+a@hDhDhDhDhDhDhDhDhDhDhDhDgD\=fG1:*# 6'A/# c            DDD8XhDhDhDhDhDhDhDhDhDhDhDdB<*^^^(               j<A5%fChDhDhDhDhDhDhDhDhDhDhDP:*qqq   C U       *UUVjjkO8'hDhDhDhDhDhDhDhDhDhDhDqO6qqr  y "8#)C)3   [     6===bE/hDhDhDhDhDhDhDhDhDhDdC-  u/aaijklhi`a/K0F     )WWW(()jJ3hDhDhDhDhDhDhDhDhDhDY< +++  _amnmnmnmnmnij)F*     T--.lK4hDhDhDhDhDhDhDhDhDhDoM5MMN2TUmnmnmnmnmnmnmnWX ~    񸸸H:::gH2hDhDhDhDhDhDhDhDhDhD_C0eee^__ 2!mmmnmnmnmnmnmnmnjk r     vvwdde:+ qO6hDhDhDhDhDhDhDhDhD^B/...,,, 889?k@mnmnmnmnmnmnmnmn^_ r     ;<<旗moN5hDhDhDhDhDhDhDhD]B/000PPP [A/[@cG3OPmnmnmnmnmnmnmnlm2S2      FFGҧ[!!!- cBhDhDhDhDhDhDhD\B.222B.!`@hDhDhDgD`D/  UVmnmnmnmnmnmnmnNO  7      |E(()nnouQ7hDhDhDhDhDhDhD[A.334Z?hDhDhDhD]?  VWmnmnmnmnmnmnQR!      t5112%aAhDhDhDhDhDhDZ@.555999 _C0>, sP6cBgDT;) UVmnmnmnlm\]8_9 $       4999 KKKLLL3$cBhDhDhDhDhDY?-777\B0hD^?I5' /#PQmnhiQQ(@(  <        CW A- a@hDhDhDhDW>,999ffg ^>hDhDhDwS:  3        oop UUU))*$sP7hDhDhDV=+;;<$$%&cAhDhDeC[?- ^^_))* `        }; iii;;<666>-!Z7'dC`@kJ4OOO   ///ҭS#@@@001zzz +AAA6'!!!||}yyy@Sclonh\J3BBC+,,GGG112?T @@@9 0#QQR!!"ttt2 g>ddd,,,]]]+ eee{888###000888???BCCCCDBBC??@888--.% 7../R223ttu~sssgggccccccgggmmmwxxy]UUU O HJJJ777+u e) ouuvuuvSe sGV U6b5111(((**+778ˣ](@ B"CZhqmf`WB"#akkkJJJ98952081,:1,<3-<4/:40631888JJJiiib%0{{{>>?-*)9,"S;*iI2tP6zT8}V:}V:|U9yS8tP6jJ2U<+9,",*)@@@||}/}333(!S;+{T8]>dBgDhDhDhDhDhDhDhDhDdC]>yS8S;))"556ˆz 6[lm^6 hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_?=,驩V N @        a򍍍sQ'%%E1#`@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaA?- ccd            e WWX"8:99;*]?hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDcB^?\=[<[<[<\=^>Z>B4,  u             8DDD5_^^+}V;hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgD\=qN5O8(1$# /#G3%3%:               \DDD9hjJ3hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_@iI24&  $$$99:EEEGGGCCC999'''                  jPPP0210E1"fChDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDX;I3$ BBBvvvYYY                  ^ iiid~W;hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD~W:;) ../!!!0                   E葑nAAA<, gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDY<<* HHH((((                    (444<* mM6hDhDhDhDhDhDhDhDhDhDhDhDhDhDhD^?F1# JJJ...     kZWWb          fuuur bBhDhDhDhDhDhDhDhDhDhDhDhDhDhDeC^B- 556444    _# . g       4 <[[\+ hDhDhDhDhDhDhDhDhDhDhDhDhDhDhD|U9(:::   J .>f?J{KDpE1M1 @       g}}}===?."hDhDhDhDhDhDhDhDhDhDhDhDhDhDdCX>,IIIBBB  L  AlBcdijkljkgh`a?h@ F      )011**+J6'hDhDhDhDhDhDhDhDhDhDhDhDhDhD\=5&)))KKL z GvIklmnmnmnmnmnmnklNO       GB&&'O9)hDhDhDhDhDhDhDhDhDhDhDhDhDhDzT8333GGHqqqXWX z1N2lmmnmnmnmnmnmnmnmnlm+D,]      o} 223P9)hDhDhDhDhDhDhDhDhDhDhDhDhDgDiJ3___CCDfff    bcmnmnmnmnmnmnmnmnmnmnWX>      UUV*:::G3&hDhDhDhDhDhDhDhDhDhDhDhDhDfC_C0eeeCCCppp 2N3mmmnmnmnmnmnmnmnmnmnmnhi4       )001՝gSTT/#Y;`@hDhDhDhDhDhDhDhDhDhDhDeC^C/222YYYVVV++,qqqNNO TVmnmnmnmnmnmnmnmnmnmnmn`a3       /``b +N7'_@hDhDhDhDhDhDhDhDhDhDeC]B/eefqqq (+! gimnmnmnmnmnmnmnmnmnmnlm8[9>       0KLL뚛i  [@-gDhDhDhDhDhDhDhDhDhDeC]B/lllYYYHHH ;*fG2[?^@wS:Y>,3$ lmmnmnmnmnmnmnmnmnmnmnWW   s       - !qqr[AAB - \>hDhDhDhDhDhDhDhDhDeC\B.UUU [@-`@hDhDhDhDgD[=G3%  - mnmnmnmnmnmnmnmnmnmn]^"5#7        %;;<ɰRKaab::; Z?,gDhDhDhDhDhDhDhDhDeC[A.gghU;*_AhDhDhDhDhDhDsQ9 #6$mnmnmnmnmnmnmnmnmn\\)B*        hhh,HHI , }W;hDhDhDhDhDhDhDhDeCZ@....3&  3$dF1bAhDhDhDhDZ@- #5$mnmnmnmnmnmnmnklPQ#9$         QZ""#%%%RRS G2#`@hDhDhDhDhDhDhDeCY@.rrr Y=jK4# 1#_C0^@fDiI2,mnmnmnmnmnjkWX2T3"         (---'yyzyyy*** X=*cBhDhDhDhDhDhDeCY?-;;<\B0fCgDX,""# Z=hDhDhDcBvR96' / 0    0           hJJJ(v\\]L7'aAhDhDhDhDdBV>,3&a@hDhDhDhDgDvS9%'X           G001=NNO+ zU:eBhDhDdBU=+hhhO8)dBhDhDfC`@Z@. iijrrr,,,9      w@ BBC;/;;<::: >-!{V;a@a@Q:*UUUdG3dCbA\=[@. <<-!  )**ppqqqq ???ƅ}lllVVVHHH???:::99:@@AKKL]]]ssttL@EEEgghkkl555 ???888ppq J0bbb9[[[>>>ghhFFFPPPYYZ---:::MMMjjkZ aLLL&+++[[[V <<<Q```QQQQ 1119!Xdde"""444[\\J %%%ܬTCxIIK)))D A葑p*{@AA'''000666<<<@@ABCCCCDCCCBBB??@::;333**+= d wwwS334///]]^XXXHHI>>?:::778777999;;dBgDhDhDhDhDhDhDhDhDhDgDdBpR=gghgghP5( ;;;d++,KKL9M rQ8hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfI4 3AAA E  c;;<ȻEa `BhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDY=򾾾B  n         V \\] P+!fDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_@ l1             Y4+ fDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaA!                'O--. _AhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDcCzU;YA2E4);-$5)#4)"8,$I7+fJ6Y=kO<                  PXaabqP9hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`AH7+ &                   |MJ6)hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDQ=0 "qqrKKL                      v4888cChDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfD                       H  Y@/hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDeCppq                       &ZZZ^@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgD                        T' hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD#       h b _ g            b**+kM8hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDH6+     d A          n?\>hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`B    ;(8($1$ p        o*++bBhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgD#   5 -!YZlmmnmnlm`a4Q5   i         7ddfeDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_@445  G4M5mnmnmnmnmnmnmnmnef$        WVVVKKLgEhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDeJ8##$ n .C/mnmnmnmnmnmnmnmnmnmnef @       MMN gEhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD%\\]DDE77899: R himnmnmnmnmnmnmnmnmnmnmnEqF        _`agEhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDcCYYZ FnFmnmnmnmnmnmnmnmnmnmnmnmnab         2GnnofDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaB445 vvwghmnmnmnmnmnmnmnmnmnmnmnmnkl         nvvwwaAhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaB!!!::;$$%'5(mnmnmnmnmnmnmnmnmnmnmnmnmnhi        FFH "*]@hDhDhDhDhDhDhDhDhDhDhDhDhD`Buuu778[[\GqHmnmnmnmnmnmnmnmnmnmnmnmnmnPQ         -.-eChDhDhDhDhDhDhDhDhDhDhDhD`BEEE666001G5(zV<^AzW=ZA0WXmnmnmnmnmnmnmnmnmnmnmnmnjk        AAB ^C1hDhDhDhDhDhDhDhDhDhDhDhD`A2232&_BhDhDhDhDhDgDiK7 `amnmnmnmnmnmnmnmnmnmnmnmn:Z;         poop OOOfDhDhDhDhDhDhDhDhDhDhDhD`A#hDhDhDhDhDhDhDhDhD^@cdmnmnmnmnmnmnmnmnmnmnmnJuK9         5R  \B2hDhDhDhDhDhDhDhDhDhDhD_AJ7*cChDhDhDhDhDhDhDbAdemnmnmnmnmnmnmnmnmnmnKuK          XXXdChDhDhDhDhDhDhDhDhDhD_A +++ 0$aF3dChDhDhDhDhDiL7cdmnmnmnmnmnmnmnmnij6O8          $%%OOPllm0$hDhDhDhDhDhDhDhDhDhD_A XB3hDjP>YC5bBhDhDrP9`amnmnmnmnmnmnikQ}R            ~F6+hDhDhDhDhDhDhDhDhD^@ CCCgDhDhDgD#;/)Z[mnmnmnlmgg6H7 /           o//0mmnppqS=.hDhDhDhDhDhDhDhD^@ F3'hDhDhDhDhD~Y@"*#9R:-;.              Z$[[\:-$gDhDhDhDhDhDhD]@ zW?hDhDhDhDhDhDfDQ>0 @             illlppqggg_AhDhDhDhDhD]? gDhDhDhDhDhDgDG4(""# n              pqqrFFG667D2&bChDhDhD\? \\\$hDhDhDhDgD\C3  4E T b j n k c VF4쩩X88999: D2%[@hD[> >>?9*!hDhD_BN9*<==wxy >>>ȓo777&&'{{| 3' ,,--#I6)!%%%tDax~~~vvvtstuuu~~xcH'=== ***555 ~~~VVWHHHppq--. ==>  XXY_ xxx .==>112XXY  P&&&$&&'  x %\\]&&'  *LHHJ ...889``aQRS  d   +llm  񉉉{}}}jjk[[\QQQIIJHHJHHIHHIMMOQRRYYYbbbooqg]  U@@A  --.  x***FFG  <<<<<<<<<<<<@@A   ##$   -**+e778{{{  (` 8PX}gYTL?0>xxz556  //1oopI c]]^(((#3&=-#A1%B2&A1&>.$8*!/$# TTTq#R?4\CfDgCgDhDhDhDhDhDgDgDgCfC`E_H9(#  nno"| ! -"W?/[AgDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD^C\C23& {{{- b 4)#yU;dChDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDeC~W<<.%䋋v8QQR445../,,-222CCEttuGnnn*rR>>œoF|X>hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`B*"`QQR ( v       @**,ۻE a=-#`BhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDeDM8)򋋌vMMM W            ~ A \\]-: F5*fDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDQ>0xxz%))*                 /=@I6*gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDU>/  *                   ,x 7789* dBhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfC_J!%#             $2T@2hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD[? MMN    5 -!M{Nijmnmnmnmnlm`aAfB*           ixkklfJ8hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDH8.ZZ[   <7N9efmnmnmnmnmnmnmnmnlmefImJ '           99:WWWqRhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDvU>==>!!"vuv g #-$ffmnmnmnmnmnmnmnmnmnmnmnmnmnjk.C/.          k|MMNzW>hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDN:-\\]qqq R f cdmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnff            EEF_`azW>hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDeD/###$ &7R8mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmn*;+           !""#fffwV>hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaB!nnp=>?  YZmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnAhC           S6ttuhL9hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaB ==>"""ffg}}~uutwww .!jkmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnIxJ           w󠠠ewL:.hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaB FGHuuv**+112AbCmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnBiC            rrs0 '!_D2dI6`AhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`B HHIKKK))*\^mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnlm&2'           OPP,!_@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`BIIJmmn #C2&C3(2(! jjmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnST           QRR&&'K7(hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`AKKJJJJ$vV?gDhDhDhDgDkO=" % mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnfg            ... dDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`AMMM `E2dDhDhDhDhDhDhDhDfDiK7&/>/mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnlm:Z;            p򦦦^556PPP667P=1hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`ANNO"_AhDhDhDhDhDhDhDhDhDhDhDbB7O8mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnlmRwS L            G2>??KKL [@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`AOOPrQ9gDhDhDhDhDhDhDhDhDhDhDhD:0+:W:mnmnmnmnmnmnmnmnmnmnmnmnmnmnklMxM)             '''OOP000))*F3'gDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_APPQ668 H7,bDhDhDhDhDhDhDhDhDhDhD4+%:Y;mnmnmnmnmnmnmnmnmnmnmnmnmnlmHnJ                ZZ[lll ~X=hDhDhDhDhDhDhDhDhDhDhDhDhDhD_ARRR4+%aF3_@gDhDhDhDhDhDhD[? 7U9mnmnmnmnmnmnmnmnmnmnmnmncd6O8              3MkNNN( cChDhDhDhDhDhDhDhDhDhDhDhDhD_ASSSGGGcD\?A3) Q<.`EhDhDhDhD]@)2L4mnmnmnmnmnmnmnmnmnmnggElF'               0023,,, <.$fDhDhDhDhDhDhDhDhDhDhDhDhD_@TUU iM9hDhDgDcJ8  @3+~[AdB]A)9*mnmnmnmnmnmnmnlmfgIkJ               LkTTV T<+hDhDhDhDhDhDhDhDhDhDhDhD^@VVWjjk!`AhDhDhDhD\AC1&  lmmnmnlmhi[\GsH/G0 I                222&!!"ppqS=.hDhDhDhDhDhDhDhDhDhDhD^@WWXF3'hDhDhDhDhDhDfD~Y@,$ 0=19R:2E3")#  ,                 ZppqrrsRRSL7)dChDhDhDhDhDhDhDhDhD^@XYYnP:hDhDhDhDhDhDhDhDeDdJ7 H                 wwx(''(___*!\AhDhDhDhDhDhDhDhD]@[[ZcDhDhDhDhDhDhDhDhDgDcI7 1 \                  = eef e``anM6dBhDhDhDhDhDhD]?\]]yyz"gDhDhDhDhDhDhDgD]?E4)//1WWW--. {                 ?ggh z6671%oP:gDhDhDhDhD\?^^_\\\G8/hDhDhDhDhDhD]BI6) ppquuu+9E P [ d j m m j c Y NB4%//0թXggh**+*# zW>fChDhD[>```DDEgL;hDhDhDfC`BB3+667猌xccd333kkl+!U=-tR;pQ; bbb555|ZCbDuS;V>-1% ccdLLMLKLlllVVV@@A000""" %%&455EEFXXXnnnyOkkkXXZ eef(()# MNObab/o  hhi ttuffg***iij&&&aaattu' ~~~ o 011ffg!!"oon!!"bbc%  aaaY jjk}}~PPPCCE556CCDaab# 8IIK -[[[!!"nnn! m777ZXXY  &&&&#}}}*** BBC   4w//0yy{  -KjJJK[Z[  Ku ,dHHJWWX...001KKLkklhhhAAB  hhhhCCDVVW         @@BFGGTTU  !--.    IIKPPPl&?Ym{{zlcQ?#///   $ IJK::; ^EFF   #P KKM YVVW   B{TKKKccc   [bbc7eeeee]nno    o==?zz{   }**+*;=+'o7G;;<(((&&&&&&&&'&'(///666DDE3(  Aczuuwjjlwwx{vg[G)  )gffg556 ##$NNPI! 8zGGH             &&'dddX).cWWY '7*"K8,]E4lN:wV?}ZB]D^E]E}[CyXBsT>kN:`F5R<.@1&/$! ..0yyzB;y==> '=-#YA1tS=aDgEhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfE]CkN:N:-3& aacT" 7|99:  $A0$bG4[AgEhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDbDqQ;R<-3&``aW nDDE  + P:+uS;dDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_BfH3<,!""#kklE C\p~|||zzzzzzweJ)?``a (U=-{W=eChDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`BgI4>.#777ˊw G~[[[;;;$$$ 334QQQuuu_)g:::M8*yU;dChDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgD_AhI49*! ^^_8Teef445#$$IIJxxyG sst 3'oN7aBhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfD\?ZA/ ==>İO2nnn**+ # 5 :3" //0aaaS&WWX L9-\>gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDdBqP90%'''ڠ`PAAA  A r    } S#%%&]]]F4BBDeI8cBhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfD[?C2& 蓓n ]*** $ g            N&&'uuv$1==>zW>fDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDbBN:, 򇇉| ` l                   j  ?>@ĵK%EEF)"aBhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfCQ>0 xxzgD                       r뎎tZZ[*"`BhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDR>1 CCD  K                         ^iijxxx"Y>hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDS?3 ++. ?                            7MMM( h!!!qP8gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDeDcCbAaA`@_@_@_@_@`@aAcBeDgDhDgD_PG)                              Z;;;2E;;; aF3eChDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfD`AX/%:-$6*#4)"4)"4)"8,$@1'L9-\D3nN7|V;]?xXB j                               {*3335$__` N9+aAhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDcC~X=cG3B2'"  4(!0%3                                  :3339r8*![>hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDeCyUhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDP;- 666GGH u                                         111ҴL4'eDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDZB2 668ZZ[ g                                          fhhig ZB2hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDkN:**,oop Z            b C60,*+3 E f                     + 橩XRRS~[BhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDZ?)!!" L          / [                  ybbc!+!fEhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDcCE3'?        L P                 8鬬T4B3)gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDgJ6 xxy2       6    #                v kklb [D4hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD\@6) FFG*      3"-D.FjGVX[\XYQ}REhF2K3/  s               5()*޿A nQ=hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDfD]C1  %     56S7WXijmnmnmnmnmnmnkl`aIuK.F/ u              i xqqq {YAhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD\@7*!99:!    ?!-"N~PjkmnmnmnmnmnmnmnmnmnmnmnhiPR,@- &              'MMN"bbc ^DhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDnN7"""   T %4'WYlmmnmnmnmnmnmnmnmnmnmnmnmnmnmncd8U9 O              O>PPQbFhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDeDX?/rrr""$  }"/#WYklmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnde3L4#              ro JJKeGhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_A>.% HHI!!"/.0  >PQjkmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnlm[\( j              'bbcKKMfFhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDzV;#,,-IIIbbb==> t x >^?ghmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnijEmEK              @//0ZZ\fFhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDgDiK5 XXXOOP O :!+"Z[lmmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnZ[ 5              Z 6_`afFhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDdCR<.--.224ccd   BgBijmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnde1I2'              zbfffeGhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaBF5)nnp ^_`vvv *!YZmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnikAhC               )zz{ nnp `FhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaBE4)889##$9X:ijmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnlmIxJ               :ZZ[+ uU?hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaBD4)FFG}~~jjk,,- &&'eefK|LmmmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnllHvI               CAAB̲Si ]F5eCfDgDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDaBC3(GGH99:../FFG 789, YZmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnhi=_?               G..0偁0 6+$_D2bG5uS;cBhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`BB2(HHICCDccc,C-demnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmn_`&2'               H""#hih$%&cG4dBhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`BB2(III NNN89:   8Y9jkmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnjkJxK %               H!""ghf446!nN7gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`BA2'JJJ^^^ MMN$$%7)YA1tS<|Y@vU>hM9R=.8*   CmDlmmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmm__$/%;               G++.xxz??A<-"]@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`AA2'KKKMMN ==>SSS;,"iL7cDhDhDhDhDhDhDcDrQ;L8*%M~Nmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnij>^@ g               BAAB˲SGHI jK5gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD`A@1&MMMFFF-"`E2bDhDhDhDhDhDhDhDhDhDhDfDwT0%OOPqqq* nP:fDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD<0+/ \]mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnlm^^%2% ?                 W 8~~000 nO9gDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_A=/&PPQ H7,_DhDhDhDhDhDhDhDhDhDhDhDhDhDhD4+%0 \]mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnlmWX!-! .                  6223jSST2)#_@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_A<.%QQRYYY  T?2aChDhDhDhDhDhDhDhDhDhDhDaD.Z\mnmnmnmnmnmnmnmnmnmnmnmnmnmnmnmnkkIpJ "                  {qqr7 hhh !\E6fDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_A;.%RRR<.$ZAZC3XB4bDhDhDhDhDhDhDhDhDeD4*$,XZmnmnmnmnmnmnmnmnmnmnmnmnmnmnmn`a3J4                      M L--.;;hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_A:-%SSSXXYiK7hDgDwWA'!UB6`EhDhDhDhDhDeD8,&'UWmnmnmnmnmnmnmnmnmnmnmnmnmmcd?ZA                    EEF${{|;;<_BhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD_@:-%TUU?0$cDhDhDhDcEH:0 @3+pR=`BeC]A1'!PQmnmnmnmnmnmnmnmnmnlmhi[\:Q< +                    Lk 3KKL!!!)# `@hDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhD^@9-$VVWgJ7hDhDhDhDhDgDrT?)! 9.(IyJmnmnmnmnmnlmijef__MvN,9,  N                    xEEF,ggguuv;+!^?hDhDhDhDhDhDhDhDhDhDhDhDhDhDhD^@8,#WVX==>3&_BhDhDhDhDhDhDhDeEWB4  6W7``ab`a^_YZQR@`A*6+) y                    '뢢_CBBC]]^ :+"Z=gDhDhDhDhDhDhDhDhDhDhDhDhDhD^@8,#WWX P;,hDhDhDhDhDhDhDhDhDgD[AJ8, "+#&4'"-#7 n                     7 nnoppq rrsRRS 2&vS:fDhDhDhDhDhDhDhDhDhDhDhDhD^@7*#XYYnP:hDhDhDhDhDhDhDhDhDhDhDeDvV>=/&  % H {                      .NNO5;555""#TTU&dH4bChDhDhDhDhDhDhDhDhDhDhD]@5)"ZZZ~)_ChDhDhDhDhDhDhDhDhDhDhDgD_AS=/ !2H g                        ]BBB¹Gl::;]]] N9+Z>gDhDhDhDhDhDhDhDhDhD]?4("\\[QRS:,"fEhDhDhDhDhDhDhDhDhDhDfCwT;@/$; n                         `+ GGGKnno NNNpoq 5'gI4aBhDhDhDhDhDhDhDhD]?3(!]]]./0 O;.hDhDhDhDhDhDhDhDhDgD]BW?/'001}}~MMN : o                      } d F#```=/WWX XXY+++@/$oP:dChDhDhDhDhDhD\?2' ^^_ cI7hDhDhDhDhDhDhDgD]BW@0."  OOPuuu+5?H P Y ` f j m n m j f _ W NE;0% //0Վt';GGH YY[KKL?/%oP;fDhDhDhDhD\>0%__` uT>hDhDhDhDhDgE|X@N:-(  !wwwKKM    '()yyz;B==> PPQppp 4( cI7cEgDhD[>.$aaa ]ChDhDhDbDkN:>0% ==>opq  )*+XXYl1@888;;=DDE  A2)bI8aI8"bcc%bG]CeK9@2)"  !yyz[[\DTsxxy__`KKL::;--.###$$%113@@ASSTggh~~oR4$ ;111&&(99; eef  kll+/ ggi  2///wwx??@ hhhghh !vvw  g &KKL#::<JJK``a kklUUV??A g 6,,.TTU $$$ggh445  rrrHHI ++,TTU d J  HHIbbcNNOjkm224556>>?OOPmmn++, ` f1R??@^^^===\ W*qqq)))]]]PQQY  "~XWWXKKLeefU  .ffg#lPPQ 111eeeyyyQ  EAAA,jWWX;<oTTUZYZE    M $?zHHJWWXKKK###001CCD[[\ttuhhhMNN'&'A   (s,sssVVW668 ###''),,.00233466777988:88:88:889779668445112--/'')### =   Errr}UUV8888   iOOPwSST;;;   +,->>?3454     //1 rPPP<<=XXY&9L^my~{zqh_QD47///2     !$ rHHH556fff/BBB/    뿿D p \\]wwxyz{vvwhhhkkl)OOO,    3𠠠f_ $ZZ[*    I 􁁂)\\]KKK, ccc'    [bbc-uuuUUVUUVUUVUUVUUVUUVUUV__`+kkl&    jEEG ttu$     y224}}} |    t''(0 *:<>+ⷷK s蠠cd 쐐s2nnoPPQFFFDDDDDDCCDDDEDEFKKM__`__`iijR OTB-release-5.8/Utilities/Data/Icons/monteverdi.svg000066400000000000000000001751721301006202600222270ustar00rootroot00000000000000 image/svg+xml OTB-release-5.8/Utilities/Data/Icons/projection_24x24.png000066400000000000000000000025171301006202600230470ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<tEXtTitleprojectionjjtEXtAuthorRobert Szczepanek_VtEXtCreation Time2010-08-19bdeRtEXtCopyrightCC Attribution-ShareAlike http://creativecommons.org/licenses/by-sa/3.0/^Z IDATHUO[U{ngoi{;JteR0SgƦI|@qc?mhAK5RZ ۗ{7@99<<ϡ4M^Sv6{{/ȐCH2(8͏^DFrj6MU,ge/7p' Y\+ʹW@GIωYIe_|5z@p&뀁!QM~ >žsJLLPi3}3?11q#|^'x@ŗWn92daVrz8TWaEQXJ&^ys TLHe mK{l=}y0}7|BN!4$``TMg6T5ZufB(P>?ٖ =v:iZxٜǢAU50ƍ(2u|^'}vԕnP{|lBNwSMv+(0݊崰*d 鮭VgUӰn)#r-XYAQ512de%`u=;  T,fָ<*L5I*(+-e wںkMU0=VXaAQ*F03/y@S~'l3del9o)4E`tft`9+Pm<&$[ܬ @oiյ5QQKE󣂁 E R< )LLŐ/l@`6FQ~E`&#XB*͏x1*`] WL hnBS}%~5w^?Z(\:W_p# pحXJyQ%1g16þ-Iq pi;873"482tf۰++vSpJoC .<#0ǃL.@(P/ Yi8[_=EUIENDB`OTB-release-5.8/Utilities/Data/Icons/reload_24x24.png000066400000000000000000000023741301006202600221420ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<yIDATHU]hW=wd$TkbJO*KbZ#郴IR*/BRbP Ij~tݍ̽}hתjι}  i;VEi鍼E){ƘD)?9s0?vm)șPIJ-U@E8HS#mgٸ`pbVB:F"m >oYų:nͩSOt݊,ɛU-]}756>e[[eMxܜ(dm! S5jJkl=ỹi }:Ikϵhkܾ\PvڡڂݑKp74.~z^TSSS?XxqwoN?]A퐶|"T{r!!Yx9A2۝iB,qIC3:j*f3'<leY"+(+-䓐{|IPQQUUa8[#͞sWސ-]PJz5-A(YM)=_[S  y^s#֟#oY"H߀n ۶1<<<{(]Y]NNM>snGvx 4I'XEr-jreözf|q|G"Z L@T׌Mf^FkꞸvK8B  ˲BT{ yDj2 FJV 7t8<@&x] )%k櫎eH٩Ȅ(9>UeNpK*"ZGbYqԝlf)eSvritp _B۶*3uL67S ~gCIENDB`OTB-release-5.8/Utilities/Data/Icons/zoom-1to1.png000066400000000000000000000024401301006202600215710ustar00rootroot00000000000000PNG  IHDRw=sBIT|d pHYs B(xtEXtSoftwarewww.inkscape.org<tEXtTitlezoom 1 to 1B!tEXtAuthorRobert Szczepanek_VtEXtCreation Time2011-03-11aRtEXtCopyrightCC Attribution-ShareAlike http://creativecommons.org/licenses/by-sa/3.0/^ZIDATHOHwǿjucS,PiҸ$E jhBK-xȥ y(TBnTc4hZFNY'f~Ԧv9ޛ7c :B!R&IRq~B,I!L 0̧| 8yTy}}kkk177g,--%)=ϔ8\Scdb^/8T@eY/;۶ ӧ7j{IXYA=$IUU4L& !\XUU!IScl&HTRВI2(k'isu1.ƦCclJ49q֙UOp\Woovf1ǎ%``EuuUj"|v_ L9>98T۶;bg,z0恁|ຮ#ҞZ"EQΧ'&&2M\ȥd.ڽ@Q@M3wO7221??544^/dYH${*xl򅗊{#|UI9&<_7!\fcxp=a\š9y >˺I ZxOOO<%.x* 8E+zJUppg3$ Db|_)pV4e ?$D>IENDB`OTB-release-5.8/Utilities/Data/monteverdi.desktop000066400000000000000000000006301301006202600220100ustar00rootroot00000000000000[Desktop Entry] Type=Application Name=Monteverdi Name[fr_FR]=Monteverdi GenericName=Image processing Comment=Remote sensing image processing application based on OrfeoToolbox TryExec=/usr/bin/monteverdi Exec=/usr/bin/monteverdi %F Terminal=false StartupNotify=false Icon=monteverdi Categories=Education;Science;ImageProcessing;Geography;Qt; MimeType=image/tiff;image/jpeg;image/jp2;application/x-esri-shape; OTB-release-5.8/Utilities/Data/monteverdi2.desktop000066400000000000000000000006301301006202600220720ustar00rootroot00000000000000[Desktop Entry] Type=Application Name=Monteverdi Name[fr_FR]=Monteverdi GenericName=Image processing Comment=Remote sensing image processing application based on OrfeoToolbox TryExec=/usr/bin/monteverdi Exec=/usr/bin/monteverdi %F Terminal=false StartupNotify=false Icon=monteverdi Categories=Education;Science;ImageProcessing;Geography;Qt; MimeType=image/tiff;image/jpeg;image/jp2;application/x-esri-shape; OTB-release-5.8/Utilities/Doxygen/000077500000000000000000000000001301006202600170065ustar00rootroot00000000000000OTB-release-5.8/Utilities/Doxygen/CMakeLists.txt000066400000000000000000000130651301006202600215530ustar00rootroot00000000000000# # Build the documentation # include (${CMAKE_ROOT}/Modules/Documentation.cmake) mark_as_advanced(BUILD_DOCUMENTATION) # ------------------------------------------------------------- # # Generate Doxygen configuration file in all configuration file # if( ${DOXYGEN_DOT_FOUND} ) set( OTB_HAVE_DOT "YES" ) else() set( OTB_HAVE_DOT "NO" ) endif() set( DOX_MODULE_LIST ${OTB_MODULES_ENABLED} ) foreach(otb-module ${DOX_MODULE_LIST}) if(${otb-module}_IS_TEST) list( APPEND DOXYGEN_TEST_DIRS "\"${${otb-module}_SOURCE_DIR}\" \\\n ") else() if( EXISTS ${${otb-module}_SOURCE_DIR}/include ) list( APPEND DOXYGEN_INCLUDE_DIRS "\"${${otb-module}_SOURCE_DIR}/include\" \\ \n") endif() endif() endforeach() list( APPEND DOXYGEN_TEST_DIRS "\"${OTB_SOURCE_DIR}/Examples\" \\\n") # By definition DOXYGEN_TEST_DIRS can not be empty. In the worst case if # BUILD_TESTING is turned OFF, there is only ${OTB_SOURCE_DIR}/Examples; # thus we don't need to do any replacement in the string. if( BUILD_TESTING ) # replace ";" in the string by space+backslash+newline string( REPLACE ";" " \\\\n" DOXYGEN_TEST_DIRS ${DOXYGEN_TEST_DIRS} ) endif() list( LENGTH DOXYGEN_INCLUDE_DIRS _doxygen_include_dirs_size ) if( ${_doxygen_include_dirs_size} GREATER 0 ) # replace ";" in the string by space+backslash+newline string( REPLACE ";" " \\\\n" DOXYGEN_INCLUDE_DIRS ${DOXYGEN_INCLUDE_DIRS} ) endif() # # Configure the script and the doxyfile, then add target # set( OTB_DOXYGEN_OUTPUT_DIR ${OTB_BINARY_DIR}/Documentation/Doxygen ) file(MAKE_DIRECTORY ${OTB_DOXYGEN_OUTPUT_DIR}) set( OTB_DOXYGEN_INPUT ${DOXYGEN_INCLUDE_DIRS} ) SET( OTB_DOXYGEN_DIAGRAMS YES ) option( OTB_DOXYGEN_HTML "Doxygen will generate HTML Output" ON ) option( OTB_DOXYGEN_DOCSET "Doxygen will generate additional index files for Xcode 3" OFF ) option( OTB_DOXYGEN_CHM "Doxygen will generate Microsoft HTML help" OFF ) option( OTB_DOXYGEN_QHP "Doxygen will generate Qt Compressed Help" OFF ) option( OTB_DOXYGEN_ECLIPSEHELP "Doxygen will generate Eclipse help plugin" OFF ) option( OTB_DOXYGEN_LATEX "Doxygen will generate LaTeX output" OFF ) option( OTB_DOXYGEN_RTF "Doxygen will generate RTF output optimized for Word 97" OFF ) option( OTB_DOXYGEN_XML "Doxygen will generate XML output" OFF ) mark_as_advanced( OTB_DOXYGEN_HTML OTB_DOXYGEN_DOCSET OTB_DOXYGEN_CHM OTB_DOXYGEN_QHP OTB_DOXYGEN_ECLIPSEHELP OTB_DOXYGEN_LATEX OTB_DOXYGEN_RTF OTB_DOXYGEN_XML ) set( OTB_DOXYGEN_OUTPUT HTML DOCSET CHM QHP ECLIPSEHELP LATEX RTF XML ) foreach( var ${OTB_DOXYGEN_OUTPUT} ) if( OTB_DOXYGEN_${var} ) set( OTB_DOXYGEN_GEN_${var} "YES" ) else() set( OTB_DOXYGEN_GEN_${var} "NO" ) endif() endforeach() set(OTB_DOXYGEN_ITK_TAGFILE "" CACHE FILEPATH "Tagfile containing ITK doxygen") mark_as_advanced(OTB_DOXYGEN_ITK_TAGFILE) set(OTB_DOXYGEN_ITK_DOXYGEN_URL "" CACHE STRING "URL to ITK doxygen") mark_as_advanced(OTB_DOXYGEN_ITK_DOXYGEN_URL) if(("${OTB_DOXYGEN_ITK_TAGFILE}" STREQUAL "") OR ("${OTB_DOXYGEN_ITK_DOXYGEN_URL}" STREQUAL "")) set(OTB_DOXYGEN_TAGFILE_FIELD "") else() set(OTB_DOXYGEN_TAGFILE_FIELD "${OTB_DOXYGEN_ITK_TAGFILE}=${OTB_DOXYGEN_ITK_DOXYGEN_URL}") endif() find_package( Perl ) if( PERL_FOUND ) set( OTB_DOXYGEN_INPUT_FILTER "${PERL_EXECUTABLE} ${OTB_SOURCE_DIR}/Utilities/Doxygen/otbgroup.pl" ) else() set( OTB_DOXYGEN_INPUT_FILTER ) endif() configure_file(${OTB_SOURCE_DIR}/Utilities/Doxygen/doxygen.config.in ${OTB_BINARY_DIR}/Utilities/Doxygen/doxygen.config) #set( OTB_DOXYGEN_OUTPUT_DIR ${OTB_BINARY_DIR}/temp ) set( OTB_DOXYGEN_INPUT "\"INPUT_SINGLE_FILE\"" ) set( OTB_DOXYGEN_DIAGRAMS NO ) configure_file(${OTB_SOURCE_DIR}/Utilities/Doxygen/doxygen.config.in ${OTB_BINARY_DIR}/single-doxygen.config) # ------------------------------------------------------------- if (BUILD_DOCUMENTATION) find_package( LATEX ) if( NOT LATEX_COMPILER ) message( "Warning: LaTeX not found. Formulas will not be generated in documentation." ) endif() # Custom command to generate a examples page which include all OTB examples #add_custom_command( OUTPUT "${OTB_BINARY_DIR}/Documentation/Doxygen/Examples.dox" # COMMAND ${CMAKE_COMMAND} -D "PROJECT_SOURCE_DIR:PATH=${OTB_SOURCE_DIR}" # -D "OUTPUT_FILE:PATH=${OTB_BINARY_DIR}/Documentation/Doxygen/Examples.dox" # -P "${OTB_SOURCE_DIR}/Utilities/Doxygen/GenerateExamplesDox.cmake" # WORKING_DIRECTORY "${OTB_SOURCE_DIR}/Examples" # DEPENDS "${OTB_SOURCE_DIR}/Examples" "${OTB_SOURCE_DIR}/Utilities/Doxygen/GenerateExamplesDox.cmake" # ) add_custom_target(Documentation-doxygen COMMAND ${DOXYGEN_EXECUTABLE} ${OTB_BINARY_DIR}/Utilities/Doxygen/doxygen.config #COMMAND ${CMAKE_COMMAND} -E copy # ${OTB_SOURCE_DIR}/Utilities/Doxygen/favicon.ico # ${OTB_BINARY_DIR}/Documentation/Doxygen/html # DEPENDS ${OTB_BINARY_DIR}/Documentation/Doxygen/Examples.dox WORKING_DIRECTORY ${OTB_BINARY_DIR}/Utilities/Doxygen ) add_custom_target(Documentation COMMAND ${CMAKE_COMMAND} -E tar cjf ${OTB_BINARY_DIR}/Documentation/Doxygen/OTB-Doxygen-${OTB_VERSION_MAJOR}.${OTB_VERSION_MINOR}.tar.bz2 ${OTB_BINARY_DIR}/Documentation/Doxygen/html DEPENDS Documentation-doxygen WORKING_DIRECTORY ${OTB_BINARY_DIR}/Documentation/Doxygen ) # Somehow the logo image is not copied into the html folder. # Here we ensure that the logo image ends up in the right directory # where html pages could find it. message( STATUS "To generate Doxygen's documentation, you need to build the Documentation target" ) endif (BUILD_DOCUMENTATION) OTB-release-5.8/Utilities/Doxygen/DoxygenFooter.html000066400000000000000000000022541301006202600224730ustar00rootroot00000000000000
      Generated at $datetime for $projectname with   doxygen $doxygenversion
      OTB-release-5.8/Utilities/Doxygen/DoxygenHeader.html000066400000000000000000000036661301006202600224350ustar00rootroot00000000000000 $projectname: $title $title $treeview $search $mathjax $extrastylesheet
      $projectname  $projectnumber
      $projectbrief
      $projectbrief
      		 $searchbox
      OTB-release-5.8/Utilities/Doxygen/DoxygenStyle.css000066400000000000000000000001611301006202600221540ustar00rootroot00000000000000body, table, div, p, dl { font-family: Lucida Grande, Verdana, Geneva, Arial, sans-serif; font-size: 12px; } OTB-release-5.8/Utilities/Doxygen/GenerateExamplesDox.cmake000066400000000000000000000020261301006202600237140ustar00rootroot00000000000000# # Usage: cmake -D "PROJECT_SOURCE_DIR:PATH=${PROJECT_SOURCE_DIR}" # -D "OUTPUT_FILE:PATH=${PROJECT_BINARY_DIR}/Examples.dox" # -P GenerateExamplesDox.cmake # This cmake script gets a lists of examples for the project and # generates a file suitable for doxygen. The file is a list of # "\examples filename", where doxygen will search for fileanme in it's # example path. Doxygen should then generate an examples page with the # referenced files. # glob the examples for each language file( GLOB_RECURSE EXAMPLES_LIST RELATIVE "${PROJECT_SOURCE_DIR}/Examples" "*.cxx" "*.py" "*.java" ) # remove the file before we begin appending file( REMOVE ${OUTPUT_FILE} ) # begin comment file( APPEND ${OUTPUT_FILE} "/**\n") # After updating to Doxygen 1.8.4, this new line is required for any # of the \example to be utilized file( APPEND ${OUTPUT_FILE} " \n") FOREACH( f IN LISTS EXAMPLES_LIST ) file( APPEND ${OUTPUT_FILE} "\\example ${f}\n" ) ENDFOREACH( ) # end comment file( APPEND ${OUTPUT_FILE} "*/\n" ) OTB-release-5.8/Utilities/Doxygen/Module.dox.in000066400000000000000000000000131301006202600213460ustar00rootroot00000000000000@_content@ OTB-release-5.8/Utilities/Doxygen/OTB/000077500000000000000000000000001301006202600174325ustar00rootroot00000000000000OTB-release-5.8/Utilities/Doxygen/OTB/Blox.dox000066400000000000000000000024421301006202600210540ustar00rootroot00000000000000/** \page BloxPage Blox Framework \section BloxIntroduction Introduction The itk::BloxImage object is a regular, rectilinear lattice of ``blocks'' in n-dimensional space. The word ``blox'' was chosen to bring to mind a set of ``city blocks'' in 2D or ``building blocks'' in 3D. Being a regular lattice, itk::BloxImage logically derives from itkImage. In an itk::BloxImage, each pixel represents an isometric space-filling block of geometric space, called an itk::BloxPixel. Each itk::BloxPixel generally covers many pixels in the underlying image and is used to store a variable number of image primitives (such as boundary points) or features (such as medial nodes) gathered within that region of geometric space. To do this, each itk::BloxPixel contains a linked list. The itk::BloxImage object facilitates certain forms of analysis by providing geometric hashing. For example, if boundary points are stored in an itk::BloxImage, pairs of boundary points that face each other (called ``core atoms'') can be found by searching relatively small regions of geometric space that face each boundary point for appropriate mates. Because an itk::BloxImage is rectilinear in geometric space (even though the underlying image may not be) subsequent analysis can be invariant to rotation and translation. */ OTB-release-5.8/Utilities/Doxygen/OTB/Geometry.dox000066400000000000000000000007101301006202600217370ustar00rootroot00000000000000/** \page GeometryPage Geometry Concepts Insight provide basic classe to represent geometrical concepts, alghought the aim of the toolkit is not computational geometry, some of these elements are necessary for common procedures in image processing. This document present the different geometric concepts used in the toolkit, as well as their relationships and how they can effectively be used. At the beginning there was the Point */ OTB-release-5.8/Utilities/Doxygen/OTB/ImageSimilarityMetrics.dox000066400000000000000000000103451301006202600245710ustar00rootroot00000000000000/** \page ImageSimilarityMetricsPage Image Similarity Metrics \section MetricsIntroduction Introduction It is a common task in image analysis to require to compare how similar two image might be. This comparison may be limited to a particular region of each image. \em Image Similarity Metrics are methods that produce a quantitative evaluation of the similarity between two image or two image regions. This techniques are used as a base for registration methods because they provide the information that indicates when the registration process is going in the right direction. A large number of Image Similarity Metrics have been proposed in the medical image and computer vision community. There is no a \em right image similarity metric but a set of metrics that are appropiated for particular applications. Metrics fit very well the notions of tools in a toolkit. You need a set of them because none is able to perform the same job as the other. The following table presents a comparison between image similarity metrics. This is by no means an exhaustive comparison but will at least provide some guidance as to what metric can be appropiated for particular problems. \subsection RegistrationMetrics Similarity Metrics Metrics are probably the most critical element of a registration problem. The metric defines what the goal of the process is, they measure how well the Target object is matched by the Reference object after the transform has been applied to it. The Metric should be selected in function of the types of objects to be registered and the expected kind of missalignment. Some metrics has a rather large capture region, which means that the optimizer will be able to find his way to a maximum even if the missalignment is high. Typically large capture regions are associated with low precision for the maximum. Other metrics can provide high precision for the final registration, but usually require to be initialized quite close to the optimal value. Unfortunately there are no clear rules about how to select a metric, other that trying some of them in different conditions. In some cases could be and advantage to use a particular metric to get an initial approximation of the transformation, and then switch to another more sensitive metric to achieve better precision in the final result. Metrics are depend on the objects they compare. The toolkit currently offers Image To Image and PointSet to Image metrics as follows: \li Mean Squares Sum of squared differences between intensity values. It requires the two objects to have intensity values in the same range. \li Normalized Correlation Correlation between intensity values divided by the square rooted autocorrelation of both target and reference objects: \f$ \frac{\sum_i^n{a_i * b_i }}{\sum_i^n{a_i^2}\sum_i^n{b_i^2}} \f$. This metric allows registering objects whose intensity values are related by a linear transformation. \li Pattern Intensity Squared differences between intensity values transformed by a function of type \f$ \frac{1}{1+x} \f$ and summed them up. This metric has the advantage of increase simultaneously when more samples are available and when intensity values are close. \li Mutual Information Mutual information is based in an information theory concept. Mutual information between two sets measures how much can be known from one set if only the other set is known. Given a set of values \f$ A=\{a_i\} \f$. Its entropy \f$ H(A) \f$ is defined by \f$ H(A) = \sum_i^n{- p(a_i) \log({p(a_i)})} \f$ where \f$ p(a_i) \f$ are the probabilities of the values in the set. Entropy can be interpreted as a measure of the mean uncertainty reduction that is obtained when one of the particular values is found during sampling. Given two sets \f$ A=\{a_i\} \f$ and \f$ B=\{b_i\} \f$ its joint entropy is given by the joint probabilities \f$ p_(a_i,b_i) \f$ as \f$ H(A,B) = \sum_i^n{-p(a_i,b_i) * log( p(a_i, b_i) )} \f$. Mutual information is obtained by subtracting the entropy of both sets from the joint entropy, as : \f$ H(A,B)-H(A)-H(B) \f$, and indicates how much uncertainty about one set is reduced by the knowledge of the second set. Mutual information is the metric of choice when image from different modalities need to be registered. */ OTB-release-5.8/Utilities/Doxygen/OTB/Iterators.dox000066400000000000000000000227411301006202600221300ustar00rootroot00000000000000/** \page ImageIteratorsPage Image Iterators \section ImageIteratorsIntroduction Introduction ImageIterators are the mechanism used in ITK for walking through the image data. You probably learned image processing with the classical access to the image data using "for loops" like: \code const int nx = 200; const int ny = 100; ImageType image(nx,ny); for(int x=0; xGetRequestedRegion() ); it.GoToBegin(); while( !it.IsAtEnd() ) { it.Set( 10 ); ++it; } \endcode This code can also be written as: \code ImageType::Pointer im = GetAnImageSomeHow(); ImageIterator it( im, im->GetRequestedRegion() ); for (it = it.Begin(); !it.IsAtEnd(); ++it) { it.Set( 10 ); } \endcode One important advantage of ImageIterators is that they provide support for the N-Dimensional images in ITK. Otherwise it would be impossible (or at least very hard) to write algorithms that work independent of the image dimension. Another advantage of ImageIterators is that they support walking a region of an image. In fact, one argument of an ImageIterator's constructor defines the region or portion of an image to traverse. Iterators know a lot about the internal composition of the image, relieving the user from these details. Your algorithm can go through all the pixels of an image without ever knowing the dimension of the image. \section IteratorTypes Types of Iterators The order in which the image pixels are visited can be quite important for some image processing algorithms and may be inconsequential to other algorithms as long as pixels are accessed as fast as possible. To address these diverse requirements, ITK implements a set of ImageIterators, always following the "C" philosophy of : "You only pay for what you use" Here is a list of some of the different ImageIterators implemented in ITK: - itk::ImageRegionIterator - itk::ImageRegionReverseIterator Region iterators don't define any specific order to walk over the pixels on the image. The user can be sure though, that all the pixels inside the region will be visited. The following iterators allows you to walk through the image in specific directions - itk::ImageLinearIteratorWithIndex Along lines - itk::ImageSliceIteratorWithIndex Along lines, then along planes Iterators in general can have Read/Write access to image pixels. A family of iterators provides Read Only access, in order to preserve the image content. These iterators are equivalent to "C" const pointers : \code const * PixelType iterator; \endcode or to STL const_iterators: \code vector::const_iterator it; \endcode The class name of the iterator makes clears if it provides const access or not. Some of the const iterators available are - itk::ImageConstIterator - itk::ImageConstIteratorWithIndex - itk::ImageLinearConstIteratorWithIndex - itk::ImageRegionConstIteratorWithIndex - itk::ImageSliceConstIteratorWithIndex \subsection NeighbohoodIteratorType Other Types of Iterators Another group of iterators support a moving neighborhood. Here the neighborhood can "iterate" over an image and a calculation can iterate over the neighborhood. This allows N-dimensional implementations of convolution and finite differences to be implemented succintly. This class of iterators is described in detail on the page \ref NeighborhoodIteratorsPage. \subsection STL ImageIterators vs. STL Iterators Given the breadth and complexity of ImageIterators, they are designed to operate slightly differently than STL iterators. In STL, you ask a container for an iterator that will traverse the container. Furthermore, in STL, you frequently compare an iterator against another iterator. Here is a loop to walk over an STL vector. \code for (it = vec.begin(); it != vec.end(); ++it) {} \endcode ImageIterators, unfortunately, are more complicated than STL iterators. ImageIterators need to store more state information than STL iterators. As one example, ImageIterators can walk a region of an image and an image can have multiple ImageIterators traversing different regions simultaneously. Thus, each ImageIterator must maintain which region it traverses. This results in a fairly heavyweight iterator, where comparing two ImageIterators and constructing iterators is an expensive operation. To address this issue, ImageIterators have a slightly different API than STL iterators. First, you do not ask the container (the image) for an iterator. Instead, you construct an iterator and tell it which image to traverse. Here is a snippet of code to construct an iterator that will walk a region of an image: \code ImageType::Pointer im = GetAnImageSomeHow(); ImageIterator it( im, im->GetRequestedRegion() ); \endcode Second, since constructing and comparing ImageIterators is expensive, ImageIterators know the beginning and end of the region. So you ask the iterator rather than the container whether the iterator is at the end of a region. \code for (it = it.Begin(); !it.IsAtEnd(); ++it) { it.Set( 10 ); } \endcode \subsection IteratorsRegions Regions Iterators are typically defined to walk a region of an image. ImageRegions are defined to be rectangular prisms. (Insight also has a number of iterators that can walk a region defined by a spatial function.) The region for an iterator is defined at constructor time. Regions are not validated, so the programmer is responsible for assigning a region that is within the image. Iterator methods Begin() and End() are defined relative to the region. See below. \section IteratorAPI Iterator API \subsection IteratorsPositioning Position \subsection IteratorsIntervals Half Open Intervals - Begin/End Like most iterator implementations, ImageIterators walk a half-open interval. Begin is defined as the first pixel in the region. End is defined as one pixel past the last pixel in the region (one pixel past in the same row). So Begin points a valid pixel in the region and End points to a pixel that is outside the region. \subsection IteratorsDereferencing Dereferencing In order to get access to the image data pointed by the iterator, dereferencing is required. This is equivalent to the classical "C" dereferencing code : \code PixelType * p; // creation of the pointer *p = 100; // write access to a data PixelType a = *p; // read access to data \endcode Iterators dereference data using Set() and Get() \code imageIterator.Set( 100 ); PixelType a = imageIterator.Get(); \endcode \subsection IteratorsOperatorPlusPlus operator++ The ++ operator will move the image iterator to the next pixel, according to the particular order in which this iterator walks the imaage. \subsection IteratorsOperatorMinusMinus operator-- The -- operator will move the image iterator to the previous pixel, according to the particular order in which this iterator walks the imaage. \subsection IteratorsIteratorsBegin Begin() Begin() returns an iterator for the same image and region as the current iterator but positioned at the first pixel in the region. The current iterator is not modified. \subsection IteratorsIteratorsEnd End() End() returns an iterator for the same image and region as the current iterator but positioned one pixel past the last pixel in the region. The current iterator is not modified. \subsection IteratorsIteratorsGotoBegin GotoBegin() GotoBegin() repositions the iterator to the first pixel in the region. \subsection IteratorsGotoEnd GotoEnd() GotoEnd() repositions the iterator to one pixel past (in the same row) the last pixel in the region. \subsection IteratorsIsAtBegin IsAtBegin() IsAtBegin() returns true if the iterator is positioned at the first pixel in the region, returns false otherwise. IsAtBegin() is faster than comparing an iterator for equivalence to the iterator returned by Begion(). \code if (it.IsAtBegin()) {} // Fast if (it == it.Begin()) {} // Slow \endcode \subsection IteratorsIsAtEnd IsAtEnd() IsAtEnd() returns true if the iterator is positioned one pixel past the last pixel in the region, returns false otherwise. IsAtEnd() is faster than comparing an iterator for equivalence to the iterator returned by End(). \code if (it.IsAtEnd()) {} // Fast if (it == it.End()) {} // Slow \endcode \section IteratorFinalComment Final Comments In general, iterators are not the kind of objects that users of the toolkit would need to use. They are rather designed to be used by code developers that add new components to the toolkit, like writing a new Image filter, for example. Before starting to write code that use iterators, users should consider to verify if the particular operation they intend to apply to the image is not already defined in the form of an existing image filter. */ OTB-release-5.8/Utilities/Doxygen/OTB/MainPage.dox000066400000000000000000000015431301006202600216320ustar00rootroot00000000000000/** * * \mainpage Orfeo Toolbox * *
      logoVectoriel.png
      * * \section intro Introduction * * Welcome to CNES' ORFEO Toolbox (OTB). OTB is an open-source image processing * software, designed for remote sensing applications. * * \section homepage Home Page * * The Home Page of the project can be found at: * * http://www.orfeo-toolbox.org * * \section howto How to use this documentation * * This documentation describes the API of the toolbox. You can start your * visit by the Classes link above which details all available classes in OTB. The Modules * link presents a hierarchy of classes organized according to their * functionality. The Related Pages link presents design details, in * particular the use of the data pipeline model and the philosophy of * iterators. * */ OTB-release-5.8/Utilities/Doxygen/OTB/Modules.dox000066400000000000000000000433031301006202600215610ustar00rootroot00000000000000/** \defgroup Thematic Thematic modules The Orfeo Toolbox includes processing modules corresponding to radiometry, geometry, etc. */ /** \defgroup Radiometry Radiometry modules \ingroup Thematic This category includes the elements related to the radiometry processing of the image. */ /** \defgroup Projection Projection modules \ingroup Thematic This category includes the elements related to the geometry of the image: projection, orthorectification. */ /** \defgroup FeatureExtraction FeatureExtraction modules \ingroup Thematic This category includes the elements related to feature extraction: texture indexes, etc. */ /** \defgroup Textures Textures modules \ingroup FeatureExtraction This category includes the elements related to texture indexes. */ /** \defgroup Visualization Visualization modules Classes related to the visualization framework of OTB to enable an easy building of new simple applications with a plugin system */ /** \defgroup DataRepresentation Data Representation Objects The Insight Toolkit includes several data representation objects such as Image, Mesh, Pixel, Points, etc. */ /** \defgroup ImageObjects Image Representation Objects \ingroup DataRepresentation This category includes the objects required to represent images in ITK. */ /** \defgroup MeshObjects Mesh Representation Objects \ingroup DataRepresentation This category includes the objects required to represent meshes in ITK. */ /** \defgroup PathObjects Path Representation Objects \ingroup DataRepresentation This category includes the objects required to represent paths in ITK. */ /** \defgroup Geometry Geometry Representation Objects \ingroup DataRepresentation This category include the objects required to represent geometrical entities like positions, vectors and space mappings. A detailed description of the rationale for these classes can be found in \ref GeometryPage */ /** \defgroup DataAccess Data Access Objects The Insight Toolkit includes several ways to access data through the user of iterators, pointers, indexes, etc. */ /** \defgroup TensorObjects Objects Related to Tensor Images This category includes the objects required for representing diffusion tensor images in ITK. */ /** \defgroup ImageAccess Image Access Objects \ingroup DataAccess */ /** \defgroup MeshAccess Mesh Access Objects \ingroup DataAccess */ /** \defgroup Iterators Iterators \ingroup DataAccess Iterators are the mechanism used to walk over the content of a particular data object. They allow defining paths and directions along which the data should be walked through. */ /** \defgroup ImageIterators Image Iterators \ingroup Iterators Image Iterators allow going through the content of an image in a predefined way. For a detailed description of iterators rationale see \ref ImageIteratorsPage */ /** \defgroup DataProcessing Data Processing Objects The Insight Toolkit includes several ways to process the data using objects such as adaptors, functions, filters, and transforms. */ /** \defgroup Filters Filters \ingroup DataProcessing Filters implement the operations on the pipeline architecture. */ /** \defgroup ImageFilters Image Filters \ingroup Filters Image filters process input images and produce output images. Inputs are unmodified. The pipeline architecture makes provisions for supporting streaming by using packets of data defined by regions \sa Image \sa PhysicalImage \sa ImageRegion */ /** \defgroup MeshFilters Mesh Filters \ingroup Filters Mesh filters process input meshes and produce output meshes. Inputs are unmodified. \sa Mesh */ /** \defgroup IntensityImageFilters Intensity Image Filters \ingroup ImageFilters Intensity Image filters only alter the values stored in image pixels. \sa Image \sa PhysicalImage \sa ImageRegion */ /** \defgroup MathematicalMorphologyImageFilters Mathematical Morphology Image Filters \ingroup IntensityImageFilters Mathematical morphology filters are a particular class of cellular automata. They modify the value of a pixel based on the values of a neighborhood. The neighborhood is now as the structured element. \sa Image \sa PhysicalImage \sa ImageRegion \sa BinaryMorphologicalFilterBase */ /** \defgroup ImageEnhancement Image Enhancement Filters \ingroup ImageFilters Image enhancement filters process an image to enhance the appearance of an image either for visualization purposes or for further processing. Examples of image enhancement filters available in ITK are: anisotropic diffusion, Gaussian filter, and histogram equalization. */ /** \defgroup ImageFeatureExtraction Image Feature Extraction Filters \ingroup ImageFilters Image feature extraction filters process an image to extract features of interest such as gradients, edges, distances, etc. Examples of image feature extraction algorithms available in ITK are: image gradients, first and second derivatives, and Danielson distance. */ /** \defgroup GradientFilters Image Gradient Filters \ingroup ImageFeatureExtraction These filters compute local gradients of images. */ /** \defgroup GeometricTransforms Geometric Transformation Filters \ingroup Filters Geometric transformation Filters transform the coordinates of an image in various ways. Examples of geometric transformation Filters available in ITK are: image shrinking, and affine transformation. */ /** \defgroup PyramidImageFilter Image Pyramid Filters \ingroup GeometricTransforms Image pyramid filters generate a set of downsampled versions of an image according to a user defined multi-resolution schedule. */ /** \defgroup ImageSegmentation Image Segmentation Filters \ingroup ImageFilters Image segmentation filters process an image to partition it into meaningful regions. Various types of image segmentation algorithms are available in ITK - some examples are, unsupervised pixel classification methods, region-growing methods, watershed-based methods, deformable-model based methods, and level-set based methods. */ /** \defgroup IntensityImageSegmentation Intensity-Based Image Segmentation Filters \ingroup ImageSegmentation Intensity based image segmentation filters use intensity values of image pixels to segment an image. Typically, spatial contiguity is not considered in intensity-based segmentation filters. Examples of intensity-based algorithms in ITK are supervised and unsupervised pixel classification algorithms. */ /** \defgroup ClassificationFilters Pixel Classification Filters \ingroup IntensityImageSegmentation Pixel classification filters use statistical classification algorithms to assign a label to a given image pixel. Classification algorithms can be supervised when training data is available or unsupervised when no training data is available. */ /** \defgroup SupervisedClassificationFilters Supervised Classification Filters \ingroup ClassificationFilters Supervised classification filters rely on the existence of training data to classify pixels into different types. An example of supervised classification algorithm in ITK is the Gaussian classifier that uses the training data to build Gaussian models of intensity distributions. */ /** \defgroup UnSupervisedClassificationFilters Unsupervised Classification Filters \ingroup ClassificationFilters Unsupervised classification filters typically cluster the image intensity data into different groups. An example of unsupervised classification algorithm in ITK is the K-Means clustering algorithm. */ /** \defgroup WatershedSegmentation Watershed-based Segmentation Filters \ingroup IntensityImageSegmentation These filters segment an image based on intensity values using the watershed algorithm. */ /** \defgroup RegionBasedSegmentation Region-Based Segmentation Filters \ingroup ImageSegmentation These filters segment an image based on similarity of intensity values between spatially adjacent pixels. Examples of region-based segmentation filters in ITK include fuzzy connectedness, region growing, and Markov Random Fields. */ /** \defgroup FuzzyConnectednessSegmentation Fuzzy Connectedness-based Segmentation Filters \ingroup RegionBasedSegmentation These filters segment an image based on fuzzy connectedness principles. Here you typically start with one or more seed points and grow regions around these seed points based on fuzzy affinity. */ /** \defgroup RegionGrowingSegmentation Region Growing Filters \ingroup RegionBasedSegmentation Typically region growing involves starting several small regions on an image and merging them iteratively based on some pixel intensity similarity criterion. ITK provides an intensity and edge-based region-growing algorithm for segmentation. */ /** \defgroup MRFFilters Markov Random Field-based Filters \ingroup RegionBasedSegmentation Markov Random Field (MRF)-based Filters assume that the segmented image is Markovian in nature, i.e., adjacent pixels are likely to be of the same class. These methods typically combine intensity-based Filters with MRF prior models also known as Gibbs prior models. */ /** \defgroup ModelImageSegmentation Model-Based Image Segmentation Filters \ingroup ImageSegmentation These filters segment an image by starting with a model and then updating the model based on image features and the updates are typically constrained by a-priori knowledge about the models. Examples of these types of algorithms in ITK include: deformable model (snakes)-based algorithms and level set-based algorithms. */ /** \defgroup MeshSegmentation Mesh Segmentation Filters \ingroup ModelImageSegmentation These algorithms represent models using a mesh and update the models based on image features. Examples of this type of filter in ITK include: balloon force filter and the deformable mesh filter. */ /** \defgroup LevelSetSegmentation Level Set-Based Segmentation Filters \ingroup ModelImageSegmentation These algorithms represent models implicitly using level-sets and update the models based on image features. Examples of these types of segmentation methods in ITK include: curvature flow-based filters, fast marching filters, and shape-detection filters. */ /** \defgroup HybridSegmentation Hybrid Segmentation Filters \ingroup ImageSegmentation These filters are hybrid between intensity-based, region-based, or model-based image segmentation filters. */ /** \defgroup RegistrationFilters Registration Filters \ingroup Filters */ /** \defgroup RegistrationComponents Components of Registration Methods Registration methods are implemented by combining basic components. This framework allows great flexibility in the construction of registration methods, and maximize code reuse. The basic components of a registration method are described in \ref RegistrationPage \ingroup RegistrationFilters */ /** \defgroup RegistrationMetrics Similarity Metrics of Registration Methods Similarity metrics are the objects that evaluate how similar two objects are. They are used in registration to quantify how well a transform is mapping the reference object on top of the target object. \ingroup RegistrationComponents */ /** \defgroup ImageRegistration Image Registration Methods \ingroup RegistrationFilters */ /** \defgroup RigidImageRegistration Rigid Registration Methods \ingroup ImageRegistration */ /** \defgroup AffineImageRegistration Affine Registration Methods \ingroup ImageRegistration */ /** \defgroup DeformableImageRegistration Deformable Registration Methods \ingroup ImageRegistration */ /** \defgroup ModelImageRegistration Model - Image Registration Methods \ingroup RegistrationFilters */ /** \defgroup PointSetToImageRegistration PointSet to Image Registration Methods \ingroup ModelImageRegistration */ /** \defgroup IOFilters Input and Output Filters \ingroup Filters */ /** \defgroup DataSources Data Sources \ingroup DataProcessing */ /** \defgroup Transforms Transforms \ingroup DataProcessing */ /** \defgroup ImageAdaptors Image Adaptors \ingroup DataProcessing Image Adaptors are an implementation of the Adaptor Design Pattern. They are designed to present an image of a particular type as being an image of a different type. Adaptors perform simple operations on pixel values for which is not easy to justify the use of an image filter. One of the principal tasks of ImageAdaptors is to perform casting. For example: you have an image whose pixels are of type unsigned char and you need to feed this image in a process that expects pixels of type double. You have the option of using and ImageFilter that convert the input unsigned char image into another of pixel type double. However this filter will allocate memory for this second image and will need to be executed. Image Adaptors allows you to simulating that you have made the conversion but will avoid the overhead in memory. There is however a penalty in performance. The mechanism used by image adaptors is to provide a simple function that will be used by ImageIterator (see \ref ImageIteratorsPage) to convert the value of a pixel, in a pixel-by-pixel basis. */ /** \defgroup Functions Functions \ingroup DataProcessing Functions provide an efficient mechanism for computing values */ /** \defgroup ImageFunctions Image Functions \ingroup Functions Image functions compute single values using data from a previously specified Image. A value can be computed at an image index, continuous index or point. \sa Image \sa Index \sa ImageFunction */ /** \defgroup ImageInterpolators Image Interpolators \ingroup ImageFunctions Image interpolators compute pixel values in non-grid positions. A value can be computed at an image index, continuous index or point. \sa Image \sa ImageFunction */ /** \defgroup SpatialFunctions Spatial Functions \ingroup Functions */ /** \defgroup FiniteDifferenceFunctions Finite Difference Functions \ingroup Functions Finite difference functions are used in the finite difference solver (FDS) framework for solving partial differential equations on images using an iterative, finite difference update scheme. \sa FiniteDifferenceImageFilter \sa FiniteDifferenceFunction */ /** \defgroup Operators Operators \ingroup DataProcessing Operators implements the abstraction of performing an operation using data from a neighborhood of a pixel. ITK Operators work in conjunction with Neighborhood iterators in order to walk over an image. */ /** \defgroup Numerics Numerics Insight provides support for numerical operations at two levels. First, Insight uses an external library called VNL, which is one component of the VXL toolkit. This library provides linear algebra, optimization, and FFTs. Second, Insight provides numerical optimizers designed for the registration framework and statistical classes designed to be used for classification and segmentation. */ /** \defgroup Optimizers Optimizers \ingroup Numerics RegistrationComponents \sa RegistrationComponents Set of Optimization methods. Some of these methods are adaptors for classes already defined in the VNL library. These methods have been particularly tailored to be used as modular components in the registration framework. */ /** \defgroup SystemObjects System Objects */ /** \defgroup ITKSystemObjects ITK System Objects \ingroup SystemObjects These objects are the basic system objects used in building ITK. */ /** \defgroup OSSystemObjects OS System Objects \ingroup SystemObjects These objects are the basic operating system related system objects in ITK. */ /** \defgroup ThreadSafetyGroup Thread Safety This groups catalog classes according to its compliance with thread safety. ITK is designed to be thread-safe, but in some particular cases this capability cannot be supported and for this reason a classification is needed. */ /** \defgroup ThreadSafe Thread Safe classes \ingroup ThreadSafetyGroup */ /** \defgroup ThreadUnSafe Thread Unsafe classes \ingroup ThreadSafetyGroup */ /** \defgroup ThreadSafetyUnknown Thread Safety Unknown \ingroup ThreadSafetyGroup */ /** \defgroup MultithreadingGroup Support for Multithreading This category classifies filters according to their support for performing processing in multiple threadS */ /** \defgroup Multithreaded Multithreaded Filters \ingroup MultithreadingGroup Filters on this category divide processing across several threads. */ /** \defgroup Singlethreaded Singlethreaded Filters \ingroup MultithreadingGroup Filter on this category perform all its processing in a single thread */ /** \defgroup ShouldBeThreaded Filters that can potentialy be modified to be Threaded \ingroup MultithreadingGroup Filter on this category could be implemented to use several processing threads */ /** \defgroup StreamingGroup Processing images region by region This category classifies filters according to their capatity for supporting Streaming. */ /** \defgroup Streamed Filters supporting Streaming \ingroup StreamingGroup Filter can respond to a request for a portion of the output using only a portion of the input. */ /** \defgroup CannotBeStreamed Filters that cannot be streamed \ingroup StreamingGroup Filter requires either all the input or produces all the output. */ /** \defgroup ShouldBeStreamed Filters that could be implemented to be streamed \ingroup StreamingGroup Filters that can potentially be modified to support streaming but currently are not supporting it. */ /** \defgroup Deprecated Deprecated classes that are scheduled to be removed from the Toolkit The classes on this group will be removed soon. Their funcionality is now provided by other classes or changes in the toolkit have made them useless. Please report to their documentation and look in to their "Deprecated" section. This section should indicate what to do to replace this class in your code. */ OTB-release-5.8/Utilities/Doxygen/OTB/NeighborhoodIterators.dox000066400000000000000000000233731301006202600244620ustar00rootroot00000000000000/** \page NeighborhoodIteratorsPage Neighborhood Iterators \section IntroductionSection Introduction This document provides a general overview of the intended use of the NeighborhoodIterator classes and their associated objects for low-level image processing in Itk. For a more detailed description of the API, please refer to the inline Itk documentation and manual. \par Neighborhood iterators are the abstraction of the concept of \em locality in image processing. They are designed to be used in algorithms that perform calculations on a neighborhood of pixel values around a point in an image. For example, a classic neighborhood-based operation is to compute the mean of a set of pixels in order to reduce noise in an image. This is typically done by taking a region of 3x3 pixels and computing the average of their values. A new image with fewer narrow high frequency spikes (noise) is produced using the resulting means. \par This code in classical \em texbook notation can look like: \code int nx = 512; int ny = 512; ImageType image(nx,ny); for(int x=1; x ImageType; 2 typedef itk::SmartNeighborhoodIterator NeighborhoodIterator; 3 typedef itk::ImageRegionIterator ImageIterator; 4 5 ImageType::Pointer input_image = GetImageSomehow(); 6 ImageType::Pointer output_image = GetImageSomehow(); 7 8 // A radius of 1 in all axial directions gives a 3x3x3x3x... neighborhood. 9 NeighborhoodIterator::RadiusType radius; 10 for (unsigned int i = 0; i < ImageType::ImageDimension; ++i) radius[i] = 1; 11 12 // Initializes the iterators on the input & output image regions 13 NeighborhoodIterator it(radius, input_image, 14 output_image->GetRequestedRegion()); 15 ImageIterator out(output_image, output_image->GetRequestedRegion()); 16 17 // Iterates over the input and output 18 for (it.SetToBegin(), out = out.Begin(); ! it.IsAtEnd(); ++it, ++out ) 19 { 20 float accum = 0.0; 21 for (unsigned int i = 0; i < it.Size(); ++i) 22 { 23 accum += it.GetPixel(i); 24 } 25 out.Set(accum/(float)(it.Size())); 26 } \endcode \par Note that the computational work is confined to lines 18-26. The code is also completely generalized for multiple dimensions. For example, changing line 1 to: \code 1 typedef itk::Image ImageType; \endcode produces an averaging filter for five-dimensional images. \par The values in the neighborhood are dereferenced through the GetPixel(n) method of the iterator. Think of the iterator as a C array, storing neighborhood values in the same order that they are stored in the image, with the lowest dimension as the fastest increasing dimension. \section OperatorsOperationsSection Neighborhood operators and operations NeighborhoodOperators are container classes for generating and storing computational kernels such as LaPlacian, Gaussian, derivative, and morphological operators. They provide a generalized interface for creation and access of the operator coefficients. \par Applying a NeighborhoodOperator to a NeighborhoodIterator requires defining some sort of operation. One common case is that of convolution with a kernel of coefficients. In Itk, convolution filtering of an image can be done in just a few lines of code using an inner product operation between a neighborhood iterator and an operator. The following convolution with a LaPlacian kernel demonstrates this concept. \code 1 LaPlacianOperator OP; 2 ImageIterator out( outputImage, regionToProcess ); 3 NeighborhoodIterator it ( OP.GetRadius(), inputImage, regionToProcess ); 4 NeighborhoodInnerProduct IP; 5 6 out = out.Begin(); 7 for (it.SetToBegin(); it != it.End(); ++it, ++out) 8 { 9 out.Set( IP( it, OP) ); 10 } \endcode \par Sometimes it may be more appropriate and efficient to work outside of the operator/operation model. The mean calculation above is one example. A ``half'' directional derivative, shown below, is another example. \code 1 NeighborhoodIterator::RadiusType radius = {1, 0, 0}; 2 NeighborhoodIterator it(radius, inputImage, regionToProcess) 3 ImageRegionIterator out( outputImage, regionToProcess ); 4 for (it.SetToBegin(); it != it.End(); ++it, ++out) 5 { 6 out.Set( it.GetPixel(3) - it.GetPixel(2) ); 7 } \endcode \par In this example the neighborhood is defined as a three pixel strip with width along only the first axis. Mapping the spatial orientation of neighborhood pixels to the array location is the responsibility of the code writer. Some methods such as GetStride(n), which returns the stride length in pixels along an axis n, have been provided to help in coding algorithms for arbitrary dimensionality. The index of the center pixel in a neighborhood is always Size()/2. \section ImageBoundariesSection Calculations at image boundaries For any neighborhood operation, conditions at data set boundaries become important. SmartNeighborhoodIterator defines a special class of neighborhood iterators that transparently handle boundary conditions. These iterators store a boundary condition object that is used to calculate a value of requested pixel indices that lie outside the data set boundary. New boundary condition objects can be defined by a user and plugged into SmartNeighboroodIterators as is appropriate for their algorithm. \par A SmartNeighborhoodIterator can be used in place of NeighborhoodIterator to iterate over an entire image region, but it will incur a penalty on performance. For this reason, it is desirable to process the image differently over distinct boundary and non-boundary regions. Itk's definition of image regions makes this easy to manage. The process is as follows: first apply the algorithm over all neighborhoods not on the image boundary using the fast NeighborhoodIterator, then process each region on the boundary using the SmartNeighborhoodIterator. The size of the boundary regions are defined by the radius of the neighborhood that you are using. \par Rewriting the inner product code using this approach looks like the following. (Here we are using the default SmartNeighborhoodIterator boundary condition and omitting some template parameters for simplicity.) \code typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator RegionFinderType; LaPlacianOperator OP; RegionFinderType regionCalculator; RegionFinderType::FaceListType regions; RegionFinderType::FaceListType::iterator regions_iterator; regions = regionCalculator( inputImage, regionToProcess, it.GetRadius() ); regions_iterator = regions.begin(); ImageIterator out; // // Process non-boundary regions normally. // out = ImageIterator(outputImage, *regions_iterator); NeighborhoodIterator it (OP.GetRadius(), inputImage, *regions_iterator); NeighborhoodInnerProduct IP; out = out.Begin(); for (it.SetToBegin(); it != it.End(); ++it, ++out) { out.Set( IP( it, OP) ); } // // Process each boundary region with boundary conditions. // SmartNeighborhoodInnerProduct SIP; SmartNeighborhoodIterator sit; for (regions_iterator++ ; regions_iterator != regions.end(); regions_iterator++) { out = ImageIterator(outputImage, *regions_iterator); sit = SmartNeighborhoodIterator(OP.GetRadius(), inputImage, *regions_iterator); for (sit.SetToBegin(); sit != sit.End(); ++sit, ++out) { out.Set( SIP( sit, OP) ); } } \endcode \par The NeighborhoodAlgorithm::ImageBoundaryFacesCalculator is a special function object that returns a list of sub-regions, or faces, of an image region. The first region in the list corresponds to all the non-boundary pixels in the input image region. Subsequent regions in the list represent all of the boundary faces of the image (because an image region is defined only by a single index and size, no single composite boundary region is possible). The list is traversed with an iterator. \section FurtherInformationSection Further information Many filters in Itk use the neighborhood iterators and operators. Some canonical examples of their use include the class of AnisotropicDiffusionFunctions and the morphological image filters. itk::WatershedSegmenter also makes extensive use of the neighborhood iterators. \par The best documentation of the API for these objects is are the class definitions themselves, since the API is subject to change as the tookit matures and is refined. */ OTB-release-5.8/Utilities/Doxygen/OTB/Registration.dox000066400000000000000000000200151301006202600226160ustar00rootroot00000000000000/** \page RegistrationPage Registration Techniques \section RegistrationIntroduction Introduction \b Registration is a technique aimed to align two objects using a particular transformation. A typical example of registration is to have two medical images from the same patient taken at different dates. It is very likely that the patient assume a different position during each acquisition. A registration procedure would allow taking both images and find a spatial transformation to find the corresponding pixel from one image into the other. Another typical example of registration is to have a geometrical model of an organ, let's say a bone. This model can be used to find the corresponding structure in a medical image. In this case, a spatial transformation is needed to find the correct location of the structure in the image. \section RegistrationFramework ITK Registration Framework The Insight Toolkit takes full advantage of the power provided by generic programming. Thanks to that, it have been possible to create an abstraction of the particular problems that the toolkit is intended to solve. The registration problem have been decomposed in a set of basic elements. They are: \li \b Target: the object that is assumed to be static. \li \b Reference: the object that will be transformed in order to be superimpossed to the \e Target \li \b Transform: the mapping that will conver one point from the \e Reference object space to the \e Target object space. \li \b Metric: a measure that indicates how well the \e Target object matches the \e Reference object after transformation. \li \b Mapper: the particular technique used for interpolating values when objects are resampled through the \e Transform. \li \b Optimizer: the method used to find the \e Transform parameters that optimize the \e Metric. A particular registration method is defined by selecting specific implementations of each one of these basic elements. In order to determine the registration method appropriated for a particular problem, is will be useful to answer the following questions: \subsection TargetReference Target and Reference Objects Currently the Target an Reference objects can be of type \b itkImage and \b itkPointSet. Methods have been instantiated for a variety of Image to Image and PointSet to Image registration cases. \subsection Transforms Transforms This is a rapid description of the transforms implemented in the toolkit \li \b Affine: The affine transform is N-Dimensional. It is composed of a NxN matrix and a translation vector. The affine transform is a linear transformation that can manage rotations, translations, shearing and scaling. \li \b Rigid3D: This transform is specific for 3D, it supports only rotations and translations. Rotations are represented using \e Quaternions. \li \b Rigid3DPerspective: A composition of a \e Rigid3D transform followed by a perpective projection. This transformation is intended to be used in applications like X-Rays projections. \li \b Translation: A N-Dimensional translation internally represented as a vector. \li \b Spline: A kernel based spline is used to interpolate a mapping from a pair of point sets. \subsection RegistrationMetrics Similarity Metrics Metrics are probably the most critical element of a registration problem. The metric defines what the goal of the process is, they measure how well the Target object is matched by the Reference object after the transform has been applied to it. The Metric should be selected in function of the types of objects to be registered and the expected kind of missalignment. Some metrics has a rather large capture region, which means that the optimizer will be able to find his way to a maximum even if the missalignment is high. Typically large capture regions are associated with low precision for the maximum. Other metrics can provide high precision for the final registration, but usually require to be initialized quite close to the optimal value. Unfortunately there are no clear rules about how to select a metric, other that trying some of them in different conditions. In some cases could be and advantage to use a particular metric to get an initial approximation of the transformation, and then switch to another more sensitive metric to achieve better precision in the final result. Metrics are depend on the objects they compare. The toolkit currently offers Image To Image and PointSet to Image metrics as follows: \li Mean Squares Sum of squared differences between intensity values. It requires the two objects to have intensity values in the same range. \li Normalized Correlation Correlation between intensity values divided by the square rooted autocorrelation of both target and reference objects: \f$ \frac{\sum_i^n{a_i * b_i }}{\sum_i^n{a_i^2}\sum_i^n{b_i^2}} \f$. This metric allows registering objects whose intensity values are related by a linear transformation. \li Pattern Intensity Squared differences between intensity values transformed by a function of type \f$ \frac{1}{1+x} \f$ and summed them up. This metric has the advantage of increase simultaneously when more samples are available and when intensity values are close. \li Mutual Information Mutual information is based in an information theory concept. Mutual information between two sets measures how much can be known from one set if only the other set is known. Given a set of values \f$ A=\{a_i\} \f$. Its entropy \f$ H(A) \f$ is defined by \f$ H(A) = \sum_i^n{- p(a_i) \log({p(a_i)})} \f$ where \f$ p(a_i) \f$ are the probabilities of the values in the set. Entropy can be interpreted as a measure of the mean uncertainty reduction that is obtained when one of the particular values is found during sampling. Given two sets \f$ A=\{a_i\} \f$ and \f$ B=\{b_i\} \f$ its joint entropy is given by the joint probabilities \f$ p_(a_i,b_i) \f$ as \f$ H(A,B) = \sum_i^n{-p(a_i,b_i) * log( p(a_i, b_i) )} \f$. Mutual information is obtained by subtracting the entropy of both sets from the joint entropy, as : \f$ H(A,B)-H(A)-H(B) \f$, and indicates how much uncertainty about one set is reduced by the knowledge of the second set. Mutual information is the metric of choice when image from different modalities need to be registered. \subsection RegistrationOptimizers Optimizers The following optimization methods are available: \li Gradient Descent : Advance following the direction and magnitud of the gradient scaled by a learning rate. \li Regular Step Gradient Descent : Advances following the direction of the gradient and use a bipartition scheme to compute the step length. \li Conjugate Gradient : Nonlinear Minimization that optimize search directions using a second order approximation of the cost function. \li Levenberg Marquardt : Nonlinear Least Squares Minimization \li LBFGS : Limited Memory Broyden, Fletcher, Goldfarb and Shannon minimization. \li Amoeba : Nelder Meade Downhill Simplex. \li One Plus One Evolutionary : Stategy that simulates the biological evolution of a set of samples in the search space. \section MultiResolutionRegistration Multiresolution The evaluation of a metric can be very expensive in computing time. An approach often used to improve performance is to register first reduced resolution versions of the target and reference objects. The resulting transform is used as the starting point for a second registration process performed in progresively higher resolution objects. It is usual to create first a sequence of reduced resolution version of the objects, this set of objects is called a pyramid representation. A Multiresolution method is basically a set of consecutive registration process, each one performed at a particular level of the pyramid, and using as initial transform the resulting transform of the previous process. Multiresolution offers the double advantage of increasing performance and at the same time improving the stability of the optimization by smoothing out local minima and increasing the capture region of the process. */ OTB-release-5.8/Utilities/Doxygen/OTB/Streaming.dox000066400000000000000000000003061301006202600220760ustar00rootroot00000000000000/** \page StreamingPage Streaming \section StreamingIntroduction Introduction \image html Streaming.gif "Pipelines can be set up to stream data through filters in small pieces." */ OTB-release-5.8/Utilities/Doxygen/OTB/Threading.dox000066400000000000000000000116721301006202600220620ustar00rootroot00000000000000/** \page ThreadingPage Threading \section ThreadingIntroduction Introduction ITK is designed to run in multiprocessor environments. Many of ITK's filters are multithreaded. When a multithreading filter executes, it automatically divides the work amongst multiprocessors in a shared memory configuration. We call this "Filter Level Multithreading". Applications built with ITK can also manage their own execution threads. For instance, an application might use one thread for processing data and another thread for a user interface. We call this "Application Level Multithreading". \image html Threading.gif "Filters may process their data in multiple threads in a shared memory configuration." \section FilterThreadSafety Filter Level Multithreading A multithreaded filter provides an implementation of the ThreadedGenerateData() method (see itk::ImageSource::ThreadedGenerateData()) as opposed to the normal single threaded GenerateData() method (see itk::ImageSource::GenerateData()). A superclass of the filter will spawn several threads (usually matching the number of processors in the system) and call ThreadedGenerateData() in each thread specifying the portion of the output that a given thread is responsible for generating. For instance, on a dual processor computer, an image processing filter will spawn two threads, each processing thread will generate one half of the output image, and each thread is restricted to writing to separate portions of the output image. Note that the "entire" input and "entire" output images (i.e. what would be available normally to the GenerateData() method, see the discussion on Streaming) are available to each call of ThreadedGenerateData(). Each thread is allowed to read from anywhere in the input image but each thread can only write to its designated portion of the output image. The output image is a single contiguous block on memory that is used for all processing threads. Each thread is informed which pixels they are responsible for producing the output values. All the threads write to this same block of memory but a given thread is only allowed to set specific pixels. \subsection FilterMemoryAllocation Memory Management The GenerateData() method is responsible for allocation the output bulk data. For an image processing filter, this corresponds to calling Allocate() on the output image object. If a filter is multithreaded, then it does not provide a GenerateData() method but provides a ThreadedGenerateData() method. In this case, a superclass' GenerateData() method will allocate the output bulk data and call ThreadedGenerateData() for each thread. If a filter is not multithreaded, then it must provided its own GenerateData() method and allocate the bulk output data (for instance, calling Allocate() on an output image) itself. \section ApplicationThreadSafety Application Level Multithreading ITK applications can be written to have multiple execution threads. This is distinct from a given filter dividing its labor across multiple execution threads. If the former, the application is responsible for spawning the separate execution threads, terminating threads, and handling all events mechanisms. (itk::MultiThreader can be used to spawn threads and terminate threads in a platform independent manner.) In the latter case, an individual filter will automatically spawn threads, execute an algorithm, and terminate the processing threads. Care must in taken in setting up an application to have separate application level (as opposed to filter level) execution threads. Individual ITK objects are not guaranteed to be thread safe. By this we mean that a single instance of an object should only be modified by a single execution thread. You should not try to modify a single instance of an object in multiple execution threads. ITK is designed so that different instances of the same class can be accessed in different execution threads. But multiple threads should not attempt to modify a single instance. This granularity of thread safety was chosen as a compromise between performance and flexibility. If we allow ITK objects to be modified in multiple threads then ITK would have to mutex every access to every instance variable of a class. This would severely affect performance. \section NumericsThreadSafety Thread Safety in the Numerics Library ITK uses a C++ wrapper around the standard NETLIB distributions (http://www.netlib.org). These NETLIB distributions were converted from FORTRAN to C using the standard f2c converter (http://www.netlib.org/f2c/). A cursory glance at the f2c generated NETLIB C code yields the impression that the NETLIB code is not thread safe (due to COMMON blocks being translated to function scope static). We are still investigating this matter. */ OTB-release-5.8/Utilities/Doxygen/doxygen.config.in000066400000000000000000003326661301006202600222770ustar00rootroot00000000000000# Doxyfile 1.8.5 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all text # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv # built into libc) for the transcoding. See http://www.gnu.org/software/libiconv # for the list of possible encodings. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = OTB # The PROJECT_NUMBER tag can be used to enter a project or revision number. This # could be handy for archiving the generated documentation or if some version # control system is used. PROJECT_NUMBER = @OTB_VERSION_MAJOR@.@OTB_VERSION_MINOR@.@OTB_VERSION_PATCH@ # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = "Orfeo Toolbox" # With the PROJECT_LOGO tag one can specify an logo or icon that is included in # the documentation. The maximum height of the logo should not exceed 55 pixels # and the maximum width should not exceed 200 pixels. Doxygen will copy the logo # to the output directory. PROJECT_LOGO = "@OTB_SOURCE_DIR@/Utilities/Doxygen/logoVectoriel.png" # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. If a relative path is # entered, it will be relative to the location where doxygen was started. If # left blank the current directory will be used. OUTPUT_DIRECTORY = "@OTB_DOXYGEN_OUTPUT_DIR@" # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this # option can be useful when feeding doxygen a huge amount of source files, where # putting all generated files in the same directory would otherwise causes # performance problems for the file system. # The default value is: NO. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # Possible values are: Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese- # Traditional, Croatian, Czech, Danish, Dutch, English, Esperanto, Farsi, # Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en, # Korean, Korean-en, Latvian, Norwegian, Macedonian, Persian, Polish, # Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, # Turkish, Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member # descriptions after the members that are listed in the file and class # documentation (similar to Javadoc). Set to NO to disable this. # The default value is: YES. BRIEF_MEMBER_DESC = NO # If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief # description of a member or function before the detailed description # # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. # The default value is: YES. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator that is # used to form the text in various listings. Each string in this list, if found # as the leading text of the brief description, will be stripped from the text # and the result, after processing the whole list, is used as the annotated # text. Otherwise, the brief description is used as-is. If left blank, the # following values are used ($name is automatically replaced with the name of # the entity):The $name class, The $name widget, The $name file, is, provides, # specifies, contains, represents, a, an and the. ABBREVIATE_BRIEF = "The $name class" \ "The $name widget" \ "The $name file" \ is \ provides \ specifies \ contains \ represents \ a \ an \ the # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # doxygen will generate a detailed section even if there is only a brief # description. # The default value is: NO. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. # The default value is: NO. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path # before files name in the file list and in the header files. If set to NO the # shortest path that makes the file name unique will be used # The default value is: YES. FULL_PATH_NAMES = NO # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. # Stripping is only done if one of the specified strings matches the left-hand # part of the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the path to # strip. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = "@OTB_BINARY_DIR@/Utilities/" # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the # path mentioned in the documentation of a class, which tells the reader which # header file to include in order to use a class. If left blank only the name of # the header file containing the class definition is used. Otherwise one should # specify the list of include paths that are normally passed to the compiler # using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but # less readable) file names. This can be useful is your file systems doesn't # support long names like on DOS, Mac, or CD-ROM. # The default value is: NO. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the # first line (until the first dot) of a Javadoc-style comment as the brief # description. If set to NO, the Javadoc-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first # line (until the first dot) of a Qt-style comment as the brief description. If # set to NO, the Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a # multi-line C++ special comment block (i.e. a block of //! or /// comments) as # a brief description. This used to be the default behavior. The new default is # to treat a multi-line C++ comment block as a detailed description. Set this # tag to YES if you prefer the old behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a # new page for each member. If set to NO, the documentation of a member will be # part of the file/class/namespace that contains it. # The default value is: NO. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen # uses this value to replace tabs by spaces in code fragments. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 2 # This tag can be used to specify a number of aliases that act as commands in # the documentation. An alias has the form: # name=value # For example adding # "sideeffect=@par Side Effects:\n" # will allow you to put the command \sideeffect (or @sideeffect) in the # documentation, which will result in a user-defined paragraph with heading # "Side Effects:". You can put \n's in the value part of an alias to insert # newlines. #OTB-TEAM : lines below should be updated #ALIASES = "wikimainaddress{1}=All Examples" \ # "wikiexamplemaintitle=\par Wiki Examples:\n\n" \ # "wikiexample{2}=\li \2\n" \ # "wiki=\wikiexamplemaintitle \li \wikimainaddress{http://www.itk.org/Wiki/ITK/Examples}\n" \ # "endwiki=\n\n\n" # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding "class=itcl::class" # will allow you to use the command class in the itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all # members will be omitted, etc. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for VHDL. # The default value is: NO. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, and # language is one of the parsers supported by doxygen: IDL, Java, Javascript, # C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. For instance to make # doxygen treat .inc files as Fortran files (default is PHP), and .f files as C # (default is Fortran), use: inc=Fortran f=C. # # Note For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. EXTENSION_MAPPING = # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See http://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by by putting a % sign in front of the word # or globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should set this # tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = YES # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen # will parse them like normal C++ but will assume all classes use public instead # of private inheritance when no explicit protection keyword is present. # The default value is: NO. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES will make # doxygen to replace the get and set methods by a property in the documentation. # This will only work if the methods are indeed getting or setting a simple # type. If this is not the case, or you want to show the methods anyway, you # should set this option to NO. # The default value is: YES. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. # The default value is: NO. DISTRIBUTE_GROUP_DOC = YES # Set the SUBGROUPING tag to YES to allow class member groups of the same type # (for instance a group of public functions) to be put as a subgroup of that # type (e.g. under the Public Functions section). Set it to NO to prevent # subgrouping. Alternatively, this can be done per class using the # \nosubgrouping command. # The default value is: YES. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or # enum is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically be # useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. Private # class members and static file members will be hidden unless the # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = YES # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file will be # included in the documentation. # The default value is: NO. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined # locally in source files will be included in the documentation. If set to NO # only classes defined in header files are included. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. When set to YES local methods, # which are defined in the implementation section but not in the interface are # included in the documentation. If set to NO only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base name of # the file that contains the anonymous namespace. By default anonymous namespace # are hidden. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO these # members will be included in the various overviews, but no documentation # section is generated. This option has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. If set # to NO these classes will be included in the various overviews. This option has # no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # (class|struct|union) declarations. If set to NO these declarations will be # included in the documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any # documentation blocks found inside the body of a function. If set to NO these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file # names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. # The default value is: system dependent. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = YES # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the # (detailed) documentation of file and class members alphabetically by member # name. If set to NO the members will appear in declaration order. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO the members will appear in declaration order. # The default value is: NO. SORT_BRIEF_DOCS = YES # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy # of group names into alphabetical order. If set to NO the group names will # appear in their defined order. # The default value is: NO. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by # fully-qualified names, including namespaces. If set to NO, the class list will # be sorted only by class name, not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the alphabetical # list. # The default value is: NO. SORT_BY_SCOPE_NAME = NO # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the # todo list. This list is created by putting \todo commands in the # documentation. # The default value is: YES. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the # test list. This list is created by putting \test commands in the # documentation. # The default value is: YES. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug # list. This list is created by putting \bug commands in the documentation. # The default value is: YES. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) # the deprecated list. This list is created by putting \deprecated commands in # the documentation. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have for it to appear in the # documentation. If the initializer consists of more lines than specified here # it will be hidden. Use a value of 0 to hide initializers completely. The # appearance of the value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at # the bottom of the documentation of classes and structs. If set to YES the list # will mention the files that were used to generate the documentation. # The default value is: YES. SHOW_USED_FILES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This # will remove the Files entry from the Quick Index and from the Folder Tree View # (if specified). # The default value is: YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces # page. This will remove the Namespaces entry from the Quick Index and from the # Folder Tree View (if specified). # The default value is: YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. You can # optionally specify a file name after the option, if omitted DoxygenLayout.xml # will be used as the name of the layout file. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = "@OTB_SOURCE_DIR@/Utilities/Doxygen/DoxygenLayout.xml" # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. Do not use file names with spaces, bibtex cannot handle them. See # also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some parameters # in a documented function, or documenting parameters that don't exist or using # markup commands wrongly. # The default value is: YES. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO doxygen will only warn about wrong or incomplete parameter # documentation, but not about the absence of documentation. # The default value is: NO. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that doxygen # can produce. The string should contain the $file, $line, and $text tags, which # will be replaced by the file and line number from which the warning originated # and the warning text. Optionally the format may contain $version, which will # be replaced by the version of the file (if it could be obtained via # FILE_VERSION_FILTER) # The default value is: $file:$line: $text. WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning and error # messages should be written. If left blank the output is written to standard # error (stderr). WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is used to specify the files and/or directories that contain # documented source files. You may enter file names like myfile.cpp or # directories like /usr/src/myproject. Separate the files or directories with # spaces. # Note: If this tag is empty the current directory is searched. INPUT = "@OTB_SOURCE_DIR@/Utilities/Doxygen" \ "@OTB_BINARY_DIR@/Utilities/Doxygen" \ "@OTB_BINARY_DIR@/Utilities/Doxygen/Modules" \ @OTB_DOXYGEN_INPUT@ # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: http://www.gnu.org/software/libiconv) for the list of # possible encodings. # The default value is: UTF-8. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank the # following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, # *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, # *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, # *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, # *.qsf, *.as and *.js. FILE_PATTERNS = *.cxx \ *.h \ *.txx \ *.hxx \ *.dox # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = YES # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = "@OTB_SOURCE_DIR@/Modules/ThirdParty/" # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* EXCLUDE_PATTERNS = "*/vxl_copyright.h" \ "*/vcl/*" \ "*/dll.h" \ "*/test*" \ "*/example*" \ "*config*" \ "*/contrib/*" \ "*/Templates/*" \ "*_mocced.cxx" # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories use the pattern */test/* EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or directories # that contain example code fragments that are included (see the \include # command). EXAMPLE_PATH = @DOXYGEN_TEST_DIRS@ # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank all # files are included. EXAMPLE_PATTERNS = *.cxx # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude commands # irrespective of the value of the RECURSIVE tag. # The default value is: NO. EXAMPLE_RECURSIVE = YES # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be included in the documentation (see the # \image command). IMAGE_PATH = "@OTB_SOURCE_DIR@/Utilities/Doxygen" \ "@OTB_BINARY_DIR@/Utilities/Doxygen/Modules" # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command: # # # # where is the value of the INPUT_FILTER tag, and is the # name of an input file. Doxygen will then use the output that the filter # program writes to standard output. If FILTER_PATTERNS is specified, this tag # will be ignored. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. INPUT_FILTER = "@OTB_DOXYGEN_INPUT_FILTER@" # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: pattern=filter # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER ) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = YES # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will be # generated. Documented entities will be cross-referenced with these sources. # # Note: To get rid of all source code in the generated output, make sure that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = YES # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES then for each documented # function all documented functions referencing it will be listed. # The default value is: NO. REFERENCED_BY_RELATION = YES # If the REFERENCES_RELATION tag is set to YES then for each documented function # all documented entities called/used by that function will be listed. # The default value is: NO. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set # to YES, then the hyperlinks from functions in REFERENCES_RELATION and # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will # link to the documentation. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = YES # If the USE_HTAGS tag is set to YES then the references to source code will # point to the HTML generated by the htags(1) tool instead of doxygen built-in # source browser. The htags tool is part of GNU's global source tagging system # (see http://www.gnu.org/software/global/global.html). You will need version # 4.8.6 or higher. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the config file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a # verbatim copy of the header file for each class for which an include is # specified. Set to NO to disable this. # See also: Section \class. # The default value is: YES. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all # compounds will be generated. Enable this if the project contains a lot of # classes, structs, unions or interfaces. # The default value is: YES. ALPHABETICAL_INDEX = YES # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in # which the alphabetical index list will be split. # Minimum value: 1, maximum value: 20, default value: 5. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. COLS_IN_ALPHA_INDEX = 1 # In case all classes in a project start with a common prefix, all classes will # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag # can be used to specify a prefix (or a list of prefixes) that should be ignored # while generating the index headers. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES doxygen will generate HTML output # The default value is: YES. GENERATE_HTML = @OTB_DOXYGEN_GEN_HTML@ # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of # it. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each # generated HTML page (for example: .htm, .php, .asp). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_HEADER = "@OTB_SOURCE_DIR@/Utilities/Doxygen/DoxygenHeader.html" # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FOOTER = "@OTB_SOURCE_DIR@/Utilities/Doxygen/DoxygenFooter.html" # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style # sheet that is used by each HTML page. It can be used to fine-tune the look of # the HTML output. If left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- # defined cascading style sheet that is included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefor more robust against future updates. # Doxygen will copy the style sheet file to the output directory. For an example # see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = "@OTB_SOURCE_DIR@/Utilities/Doxygen/DoxygenStyle.css" # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = "@OTB_SOURCE_DIR@/Utilities/Doxygen/favicon.ico" # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the stylesheet and background images according to # this color. Hue is specified as an angle on a colorwheel, see # http://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use grayscales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting this # to NO can help when comparing the output of multiple runs. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_TIMESTAMP = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = YES # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files will be # generated that can be used as input for Apple's Xcode 3 integrated development # environment (see: http://developer.apple.com/tools/xcode/), introduced with # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a # Makefile in the HTML output directory. Running make will produce the docset in # that directory and running make install will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at # startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html # for more information. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = @OTB_DOXYGEN_GEN_DOCSET@ # This tag determines the name of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "OTB Doxygen generated documentation" # This tag specifies a string that should uniquely identify the documentation # set bundle. This should be a reverse domain-name style string, e.g. # com.mycompany.MyDocSet. Doxygen will append .docset to the name. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = OTB # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = cnes # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = CNES # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on # Windows. # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = @OTB_DOXYGEN_GEN_CHM@ # The CHM_FILE tag can be used to specify the file name of the resulting .chm # file. You can add a path in front of the file if the result should not be # written to the html output directory. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # The HHC_LOCATION tag can be used to specify the location (absolute path # including file name) of the HTML help compiler ( hhc.exe). If non-empty # doxygen will try to run the HTML help compiler on the generated index.hhp. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # The GENERATE_CHI flag controls if a separate .chi index file is generated ( # YES) or that it should be included in the master .chm file ( NO). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # The BINARY_TOC flag controls whether a binary table of contents is generated ( # YES) or a normal table of contents ( NO) in the .chm file. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help # (.qch) of the generated HTML documentation. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_QHP = @OTB_DOXYGEN_GEN_QHP@ # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify # the file name of the resulting .qch file. The path specified is relative to # the HTML output folder. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- # folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's filter section matches. Qt Help Project / Filter Attributes (see: # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # The QHG_LOCATION tag can be used to specify the location of Qt's # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the # generated .qhp file. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = @OTB_DOXYGEN_GEN_ECLIPSEHELP@ # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = OTB # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. If the tag # value is set to YES, a side panel will be generated containing a tree-like # index structure (just like the one that is generated for HTML Help). For this # to work a browser that supports JavaScript, DHTML, CSS and frames is required # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can # further fine-tune the look of the index. As an example, the default style # sheet generated by doxygen has an example that shows how to put an image at # the root of the tree instead of the PROJECT_NAME. Since the tree basically has # the same information as the tab index, you could consider setting # DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = NO # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 1 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used # to set the initial width (in pixels) of the frame in which the tree is shown. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. When you change the font size after a successful # doxygen run you need to manually remove any form_*.png images from the HTML # output directory to force them to be regenerated. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANSPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are not # supported properly for IE 6.0, but are supported on all modern browsers. # # Note that when changing this option you need to delete any form_*.png files in # the HTML output directory before the changes have effect. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # http://www.mathjax.org) which uses client side Javascript for the rendering # instead of using prerendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # the MathJax output. See the MathJax site (see: # http://docs.mathjax.org/en/latest/output.html) for more details. # Possible values are: HTML-CSS (which is slower, but has the best # compatibility), NativeMML (i.e. MathML) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from http://www.mathjax.org before deployment. # The default value is: http://cdn.mathjax.org/mathjax/latest. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = http://www.mathjax.org/mathjax # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , /